diff --git a/README.md b/README.md
index d9e0af4a9..fc6cba3e2 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ Here are the recent additions and updates to the Gemini API and the Cookbook:
* **Lyria and TTS**: Get started with podcast and music generation with the [TTS](./quickstarts/Get_started_TTS.ipynb) and [Lyria RealTime](./quickstarts/Get_started_LyriaRealTime.ipynb) models.
* **LiveAPI**: Get started with the [multimodal Live API](./quickstarts/Get_started_LiveAPI.ipynb) and unlock new interactivity with Gemini.
* **Recently Added Guides:**
- * [Grounding](./quickstarts/Grounding.ipynb): Discover different ways to ground Gemini's answer using different tools, from Google Search to Youtube and the new url context tool.
+ * [Grounding](./quickstarts/Grounding.ipynb): Discover different ways to ground Gemini's answer using different tools, from Google Search to Youtube and the new **url context** tool.
* [Batch-mode](./quickstarts/Batch_mode.ipynb): Use Batch-mode to send large volume of non-time-sensitive requests to the model and get a 50% discount.
@@ -58,7 +58,7 @@ Then, explore the other quickstarts tutorials to learn about individual features
## 2. Examples (Practical Use Cases)
These examples demonstrate how to combine multiple Gemini API features or 3rd-party tools to build more complex applications.
-* [Browser as a tool](./examples/Browser_as_a_tool.ipynb): Use a web browser for live and internal (intranet) web interactions
+* [Browser as a tool](./examples/Browser_as_a_tool.ipynb): Use a web browser for live and internal (intranet) web interactions
* [Illustrate a book](./examples/Book_illustration.ipynb): Use Gemini and Imagen to create illustration for an open-source book
* [Animated Story Generation](./examples/Animated_Story_Video_Generation_gemini.ipynb): Create animated videos by combining Gemini's story generation, Imagen, and audio synthesis
* [Plotting and mapping Live](./examples/LiveAPI_plotting_and_mapping.ipynb): Mix *Live API* and *Code execution* to solve complex tasks live
diff --git a/examples/Browser_as_a_tool.ipynb b/examples/Browser_as_a_tool.ipynb
index 09ac544ad..b5ae27386 100644
--- a/examples/Browser_as_a_tool.ipynb
+++ b/examples/Browser_as_a_tool.ipynb
@@ -54,7 +54,9 @@
"\n",
"* Requesting live data using a browser tool with the Live API\n",
"* Returning images of web pages from function calling\n",
- "* Connecting to a local network/intranet using a browser tool\n"
+ "* Connecting to a local network/intranet using a browser tool\n",
+ "\n",
+ "**Note**: for most of the use-cases, you can use the tools directly by Gemini to get it to search content using Google Search, grab videos from YouTube or fetch context from URLs without having to set-up anything. Check out the [Grounding](https://colab.research.google.com/quickstarts/Grounding.ipynb) notebook for more details.\n"
]
},
{
@@ -1193,7 +1195,7 @@
"source": [
"## Further reading\n",
"\n",
- "* To learn more about using the search tools, try the [Search grounding](../quickstarts/Search_Grounding.ipynb) cookbook recipe.\n",
+ "* To learn more about using the grounding tools (search grounding, YouTube links and URL context), check out the [Grounding](../quickstarts/Grounding.ipynb) notebook or the one dedicated to [Seach grounding](../quickstarts/Search_Grounding.ipynb).\n",
"* For more advanced examples of function calling in the Live API, try the [Plotting and Mapping](../examples/LiveAPI_plotting_and_mapping.ipynb) cookbook recipe.\n",
"\n",
"Or browse the [Gemini API cookbook](http://github.com/google-gemini/cookbook)."
diff --git a/quickstarts/Grounding.ipynb b/quickstarts/Grounding.ipynb
index 890309806..2147ff67a 100644
--- a/quickstarts/Grounding.ipynb
+++ b/quickstarts/Grounding.ipynb
@@ -60,9 +60,9 @@
"Information grounding is the process of connecting these models to specific, verifiable information sources to enhance the accuracy, relevance, and factual correctness of their responses. While LLMs are trained on vast amounts of data, this knowledge can be general, outdated, or lack specific context for particular tasks or domains. Grounding helps to bridge this gap by providing the LLM with access to curated, up-to-date information.\n",
"\n",
"Here you will experiment with:\n",
- "- Grounding information using Google Search grounding\n",
- "- Adding YouTube links to gather context information to your prompt\n",
- "- Using URL context to include website URL as context to your prompt"
+ "- Grounding information using Google Search grounding\n",
+ "- Adding YouTube links to gather context information to your prompt\n",
+ "- Using URL context to include website, pdf or image URLs as context to your prompt"
]
},
{
@@ -71,9 +71,7 @@
"id": "vKu1tRBrQ7xj"
},
"source": [
- "## Set up the SDK\n",
- "\n",
- "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini models."
+ "## Set up the SDK and the client"
]
},
{
@@ -84,9 +82,7 @@
"source": [
"### Install SDK\n",
"\n",
- "The **[Google Gen AI SDK](https://github.com/googleapis/python-genai)** provides programmatic access to Gemini models using both the [Google AI for Developers](https://ai.google.dev/gemini-api/docs/models/) and [Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/overview) APIs. With a few exceptions, code that runs on one platform will run on both. This means that you can prototype an application using the Developer API and then migrate the application to Vertex AI without rewriting your code.\n",
- "\n",
- "More details about this new SDK on the [documentation](https://googleapis.github.io/python-genai/) or in the [Getting started](./Get_started.ipynb) notebook."
+ "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini models."
]
},
{
@@ -113,7 +109,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": null,
"metadata": {
"id": "RjvgYmdLQd5s"
},
@@ -137,7 +133,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": null,
"metadata": {
"id": "C75s1LR9QmOz"
},
@@ -148,7 +144,7 @@
"\n",
"client = genai.Client(api_key=GOOGLE_API_KEY)\n",
"\n",
- "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash\", \"gemini-2.5-pro\", \"gemini-2.5-flash-lite\", \"gemini-2.0-flash\",] {\"allow-input\":true, isTemplate: true}"
+ "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.5-flash\",\"gemini-2.5-pro\"] {\"allow-input\":true, isTemplate: true}"
]
},
{
@@ -158,24 +154,33 @@
},
"source": [
"## Use Google Search grounding\n",
- "Google Search grounding is particularly useful for queries that require current information or external knowledge. Using Google Search, Gemini can access nearly real-time information and better responses."
+ "\n",
+ "\n",
+ "\n",
+ "Google Search grounding is particularly useful for queries that require current information or external knowledge. Using Google Search, Gemini can access nearly real-time information and better responses.\n",
+ "\n",
+ "To enable Google Search, simply add the `google_search` tool in the `generate_content`'s `config` that way:\n",
+ "```\n",
+ " config={\n",
+ " \"tools\": [\n",
+ " {\n",
+ " \"google_search\": {}\n",
+ " }\n",
+ " ]\n",
+ " },\n",
+ "```"
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": null,
"metadata": {
"id": "FHIcazUO0-xU"
},
"outputs": [
{
"data": {
- "text/markdown": [
- "Response:\n",
- " The latest Indian Premier League (IPL) match, which was the final of the 2024 season, took place on May 26, 2024.\n",
- "\n",
- "In this match, the Kolkata Knight Riders (KKR) defeated the Sunrisers Hyderabad (SRH) by 8 wickets to win their third IPL title. The Sunrisers Hyderabad were bundled out for 113 runs, which was the lowest total in an IPL final."
- ],
+ "text/markdown": "**Response**:\n The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, which took place on June 3, 2025. In this match, Royal Challengers Bengaluru defeated Punjab Kings by 6 runs to win their maiden title.",
"text/plain": [
""
]
@@ -187,8 +192,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Search Query: ['latest Indian Premier League match and winner', 'When did IPL 2024 end?']\n",
- "Search Pages: wikipedia.org, jagranjosh.com, livemint.com, thehindu.com\n"
+ "Search Query: ['latest Indian Premier League match and winner', 'when did IPL 2025 finish', 'IPL 2024 final match and winner']\n",
+ "Search Pages: olympics.com, wikipedia.org, thehindu.com, olympics.com, skysports.com, wikipedia.org, thehindu.com\n"
]
},
{
@@ -315,8 +320,9 @@
"
\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
"source": [
- "As you can see, using the model knowledge only, it does not know about the new Gemini 2.5 models family."
+ "prompt = \"\"\"\n",
+ " Can you give me an overview of the content of this pdf?\n",
+ " https://abc.xyz/assets/cc/27/3ada14014efbadd7a58472f1f3f4/2025q2-alphabet-earnings-release.pdf\n",
+ " Search on the web for the reaction of the main financial analysts, what's the trend?\n",
+ "\"\"\"\n",
+ "\n",
+ "config = {\n",
+ " \"tools\": [\n",
+ " {\"url_context\": {}},\n",
+ " {\"google_search\": {}}\n",
+ " ],\n",
+ "}\n",
+ "\n",
+ "response = client.models.generate_content(\n",
+ " contents=[prompt],\n",
+ " model=MODEL_ID,\n",
+ " config=config\n",
+ ")\n",
+ "\n",
+ "display(Markdown(response.text.replace('$','\\$')))\n",
+ "display(HTML(response.candidates[0].grounding_metadata.search_entry_point.rendered_content))"
]
},
{
diff --git a/quickstarts/Search_Grounding.ipynb b/quickstarts/Search_Grounding.ipynb
index e8ca34c05..e09913935 100644
--- a/quickstarts/Search_Grounding.ipynb
+++ b/quickstarts/Search_Grounding.ipynb
@@ -11,7 +11,7 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": null,
"metadata": {
"cellView": "form",
"id": "tuOe1ymfHZPu"
@@ -66,9 +66,7 @@
"id": "vKu1tRBrQ7xj"
},
"source": [
- "## Set up the SDK\n",
- "\n",
- "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini 2.0 models."
+ "## Set up the SDK and the client"
]
},
{
@@ -79,14 +77,14 @@
"source": [
"### Install SDK\n",
"\n",
- "The new **[Google Gen AI SDK](https://github.com/googleapis/python-genai)** provides programmatic access to Gemini 2 (and previous models) using both the [Google AI for Developers](https://ai.google.dev/gemini-api/docs/models/gemini-v2) and [Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/overview) APIs. With a few exceptions, code that runs on one platform will run on both. This means that you can prototype an application using the Developer API and then migrate the application to Vertex AI without rewriting your code.\n",
+ "This guide uses the [`google-genai`](https://pypi.org/project/google-genai) Python SDK to connect to the Gemini 2.0 models.\n",
"\n",
- "More details about this new SDK on the [documentation](https://googleapis.github.io/python-genai/) or in the [Getting started](./Get_started.ipynb) notebook."
+ "You'll find more details about the SDK on the [documentation](https://googleapis.github.io/python-genai/) or in the [Getting started](./Get_started.ipynb) notebook."
]
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 32,
"metadata": {
"id": "6Fr84vJuPSHb"
},
@@ -108,7 +106,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 33,
"metadata": {
"id": "RjvgYmdLQd5s"
},
@@ -129,14 +127,13 @@
"### Select model and initialize SDK client\n",
"\n",
"The client will pick up your API key from the environment variable.\n",
- "To use the live API you need to set the client version to `v1alpha` and use the Gemini 2.0 model.\n",
"\n",
"Now select the model you want to use in this guide, either by selecting one in the list or writing it down. Keep in mind that some models, like the 2.5 ones are thinking models and thus take slightly more time to respond (cf. [thinking notebook](./Get_started_thinking.ipynb) for more details and in particular learn how to switch the thiking off)."
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 34,
"metadata": {
"id": "C75s1LR9QmOz"
},
@@ -161,21 +158,14 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": null,
"metadata": {
"id": "FHIcazUO0-xU"
},
"outputs": [
{
"data": {
- "text/markdown": [
- "Response:\n",
- " The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, which took place on June 3, 2025.\n",
- "\n",
- "Royal Challengers Bengaluru (RCB) won their maiden IPL title by defeating Punjab Kings (PBKS) by 6 runs in that final match. The match was held at the Narendra Modi Stadium in Ahmedabad.The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, played on June 3, 2025, at the Narendra Modi Stadium in Ahmedabad.\n",
- "\n",
- "Royal Challengers Bengaluru (RCB) emerged victorious, winning their first-ever IPL title by defeating Punjab Kings (PBKS) by 6 runs."
- ],
+ "text/markdown": "Response:\n The latest Indian Premier League (IPL) match was the final of the IPL 2025 season, which took place on June 3, 2025.\n\nThe Royal Challengers Bengaluru (RCB) won their maiden IPL title by defeating the Punjab Kings (PBKS) by 6 runs in a thrilling final held at the Narendra Modi Stadium in Ahmedabad. Virat Kohli of RCB was the top scorer for his team in the final with 43 runs. Krunal Pandya was named Man of the Match for his economical bowling.",
"text/plain": [
""
]
@@ -187,8 +177,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Search Query: ['latest Indian Premier League match and winner', 'IPL 2025 latest match and winner']\n",
- "Search Pages: olympics.com, wikipedia.org, yahoo.com, hindustantimes.com, indiatimes.com, aljazeera.com\n"
+ "Search Query: ['latest Indian Premier League match and winner', 'IPL 2025 final match and winner']\n",
+ "Search Pages: olympics.com, thehindu.com, economictimes.com, wikipedia.org, skysports.com, olympics.com, wikipedia.org\n"
]
},
{
@@ -315,8 +305,8 @@
"
\n",
"\n"
],
@@ -360,21 +350,14 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": null,
"metadata": {
"id": "EdUkQ40cKaGX"
},
"outputs": [
{
"data": {
- "text/markdown": [
- "The latest Indian Premier League (IPL) match played was the **final of the 2024 season.**\n",
- "\n",
- "* **Teams:** **Kolkata Knight Riders (KKR)** vs. **Sunrisers Hyderabad (SRH)**\n",
- "* **Winner:** **Kolkata Knight Riders (KKR)** won the match.\n",
- "\n",
- "KKR defeated SRH by 8 wickets to clinch their third IPL title. The final was played on May 26, 2024, at the M. A. Chidambaram Stadium in Chennai."
- ],
+ "text/markdown": "The latest Indian Premier League match was the **final of the IPL 2024 season**, played on **May 26, 2024**.\n\nIt was contested between:\n* **Kolkata Knight Riders (KKR)**\n* **Sunrisers Hyderabad (SRH)**\n\n**Kolkata Knight Riders (KKR) won the match by 8 wickets**, securing their third IPL title.",
"text/plain": [
""
]
@@ -408,7 +391,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": null,
"metadata": {
"cellView": "form",
"id": "LUTX1SsKS3CE"
@@ -454,20 +437,14 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": null,
"metadata": {
"id": "Qilzz3GKTdpl"
},
"outputs": [
{
"data": {
- "text/markdown": [
- "The most recent significant game between Australia and Chinese Taipei was in **Men's Football (Soccer)** as part of the FIFA World Cup 2026 AFC Qualifiers.\n",
- "\n",
- "**Australia won the match against Chinese Taipei 1-0.**\n",
- "\n",
- "This game took place on **November 21, 2023**."
- ],
+ "text/markdown": "The most recent game between Australia and Chinese Taipei was in **basketball**.\n\n* **FIBA Asia Cup Qualifiers**\n* **Date:** February 25, 2024\n* **Result:** **Australia** defeated Chinese Taipei 90-58.\n\nThey also played recently in **soccer (football)**:\n\n* **FIFA World Cup Qualifier**\n* **Date:** October 12, 2023\n* **Result:** **Australia** defeated Chinese Taipei 5-0.",
"text/plain": [
""
]
@@ -495,32 +472,14 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": null,
"metadata": {
"id": "St4MxVo2Sl6I"
},
"outputs": [
{
"data": {
- "text/markdown": [
- "Australia and Chinese Taipei have recently competed in various sports. Here's a summary of the most recent winners:\n",
- "\n",
- "**Volleyball:**\n",
- "In women's volleyball, Australia defeated Chinese Taipei 3-1 (23-25, 25-15, 25-19, 25-18) in Pool A of the 2024 AVC Challenge Cup for Women on May 22, 2024.\n",
- "\n",
- "**Basketball:**\n",
- "* In women's basketball, Australia won against Chinese Taipei with a score of 91-45 in the FIBA Women's Asia Cup on June 27, 2023.\n",
- "* In the FIBA U18 Asia Cup 2024, Australia's men's team overwhelmingly defeated Chinese Taipei 113-48 on September 4, 2024.\n",
- "* Australia's U17 Women's basketball team also beat Chinese Taipei 89-45 in the Round of 16 at the FIBA U17 Women's Basketball World Cup 2024 on July 17, 2024.\n",
- "\n",
- "**Baseball:**\n",
- "Chinese Taipei defeated Australia 11-3 in the WBSC Premier12 2024 on November 17, 2024, securing their spot in the Super Round.\n",
- "\n",
- "**Soccer:**\n",
- "The most recent matches for the women's teams show Australia consistently winning against Chinese Taipei. Australia Women defeated Chinese Taipei Women 6-0 on December 7, 2024, and 3-1 on December 4, 2024, in international friendlies. Another recent match saw Australia Women beat Chinese Taipei Women 3-0 on November 1, 2023, during the AFC Women's Olympic Qualifying Tournament.\n",
- "\n",
- "Due to the general nature of the query and the frequent competitions between these two nations across multiple sports, \"most recent\" can refer to different games depending on the sport."
- ],
+ "text/markdown": "The most recent games between Australia and Chinese Taipei have seen varying results across different sports.\n\nIn **women's futsal**, Chinese Taipei secured a 1-0 victory over Australia in their final game of the AFC Women's Futsal Asian Cup on May 10, 2025.\n\nIn **baseball**, Chinese Taipei defeated Australia with a score of 11-3 in the WBSC Premier12 on November 17, 2024.\n\nIn **women's soccer**, Australia triumphed over Chinese Taipei with a 3-1 win in an international friendly on December 4, 2024.\n\nIn **men's volleyball**, Australia defeated Chinese Taipei 3-1 in the AVC Men's Nations Cup on June 22, 2025.\n\nIn **women's volleyball**, Chinese Taipei won 3-0 against Australia in the AVC Nations Cup Women on June 7, 2025.\n\nIn **men's basketball**, Australia defeated Chinese Taipei 90-71 in a FIBA Asia Qualifier game on February 24, 2022.\n\nIn **women's U18 basketball**, Australia secured a 90-67 victory against Chinese Taipei in the FIBA U18 Women's Asia Cup on June 26, 2024.",
"text/plain": [
""
]
@@ -652,10 +611,9 @@
"
\n",
"\n"
],
@@ -1133,7 +1016,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": null,
"metadata": {
"id": "42UTFDweVwNm"
},
@@ -1145,49 +1028,46 @@
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
- "# Data for Denis Villeneuve's 10 most recent movies (from newest to oldest)\n",
+ "# Data for Denis Villeneuve's 10 most recent movies and their runtimes\n",
"movies = [\n",
" \"Dune: Part Two (2024)\",\n",
- " \"Dune: Part One (2021)\",\n",
+ " \"Dune (2021)\",\n",
" \"Blade Runner 2049 (2017)\",\n",
" \"Arrival (2016)\",\n",
" \"Sicario (2015)\",\n",
- " \"Enemy (2013)\",\n",
" \"Prisoners (2013)\",\n",
+ " \"Enemy (2013)\",\n",
" \"Incendies (2010)\",\n",
" \"Polytechnique (2009)\",\n",
" \"Maelström (2000)\"\n",
"]\n",
"\n",
- "runtimes = [166, 155, 163, 116, 121, 90, 153, 131, 77, 87]\n",
+ "runtimes = [166, 155, 163, 116, 121, 153, 91, 131, 77, 87] # Runtimes in minutes\n",
"\n",
- "# Create a bar chart\n",
- "plt.figure(figsize=(12, 7)) # Adjust figure size for better readability\n",
- "bars = plt.barh(movies, runtimes, color='skyblue')\n",
+ "# Create the bar chart\n",
+ "fig, ax = plt.subplots(figsize=(12, 7)) # Adjust figure size for better readability\n",
+ "bars = ax.bar(movies, runtimes, color='skyblue')\n",
"\n",
- "# Add labels and title\n",
- "plt.xlabel(\"Runtime (minutes)\")\n",
- "plt.ylabel(\"Movie Title\")\n",
- "plt.title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\")\n",
+ "# Add titles and labels\n",
+ "ax.set_xlabel(\"Movie Title (Release Year)\", fontsize=12)\n",
+ "ax.set_ylabel(\"Runtime (Minutes)\", fontsize=12)\n",
+ "ax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", fontsize=14)\n",
+ "plt.xticks(rotation=45, ha='right') # Rotate x-axis labels for better readability\n",
"\n",
- "# Invert y-axis to have the most recent movie at the top\n",
- "plt.gca().invert_yaxis()\n",
- "\n",
- "# Add runtime values on top of the bars\n",
+ "# Add the runtime values on top of the bars\n",
"for bar in bars:\n",
- " width = bar.get_width()\n",
- " plt.text(width + 2, bar.get_y() + bar.get_height()/2, f'{width} min', va='center')\n",
- "\n",
- "plt.xlim(0, max(runtimes) + 30) # Adjust x-axis limit for text\n",
+ " yval = bar.get_height()\n",
+ " ax.text(bar.get_x() + bar.get_width()/2, yval + 2, round(yval), ha='center', va='bottom', fontsize=9)\n",
"\n",
- "plt.tight_layout() # Adjust layout to prevent labels from overlapping\n",
+ "# Improve layout and display the plot\n",
+ "plt.tight_layout()\n",
"plt.show()\n",
"\n"
]
},
{
"data": {
- "image/png": "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\n",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAKyCAYAAAAEvm1SAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XlYVOX///HXAIq4ACKK4kpqqLnvprmkuS+kZuYSLmm5ZGrlUrmmmVZmrmluWS7lx3KrNHfNNTUt00zN3cQMkUBZ5/790Y/5OgGKCDOAz8d1zXU5577PmfeZM3OQF/e5j8UYYwQAAAAAAAA4kIuzCwAAAAAAAMDDh1AKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgCQZhYvXiyLxaLFixc7uxSnOnjwoJ566inlz59fFotFlStXdnZJqbZ9+3ZZLBaNHTvW2aUk+/kqUaKESpQokaK+AJARNGzYUBaLxdllAIDTEUoBQAZ17tw5WSwWu0e2bNlUuHBhderUSQcPHnRaTT169HD4a2cW4eHhatWqlQ4cOKBnn31WY8aM0UsvvXTXdRIClISHi4uLPD09FRAQoHbt2mnGjBkKDQ110B6kL6vVqqJFi8rV1VWXL1++a99NmzbJYrGoadOmDqoOJUqUUMOGDdN8u59//rlefPFFVa9eXe7u7ikKDMPDwzV06FAVL15c7u7uKlGihF5//XVFRESk+HUTQlWLxaLq1asn2++7776z9UuP/U/K2LFjZbFYtH379lStd+cjZ86cKl++vN58802Fh4enT8FOktpjkvDeuLu76++//06yz40bN+Th4WHrCwBwPDdnFwAAuLuSJUuqW7dukqTIyEgdOnRIK1eu1OrVq7V582bVr1/fyRX+n6efflq1a9dWoUKFnF2K0xw4cEDXrl3TxIkT9cYbb9zXuo0bN1a9evUkSREREbp8+bJ27dqltWvXasyYMZo7d66eeeaZ9Cg7WTVr1tSJEyfk6+ubJttzcXFRjx49NGHCBC1evFhvvvlmsn0XLlwoSerdu7ckPl+Z2VtvvaXz58/L19dXhQoV0vnz5+/aPzIyUg0aNNCRI0fUtGlTPffcc/rpp5/0/vvva8eOHdq5c6dy5MiR4td3c3PToUOH9PPPP6tixYqJ2hcsWCA3NzfFxcXd9745S4cOHVS+fHlJUkhIiL799lu98847Wr9+vQ4cOCB3d3cnV+h8bm5uiomJ0dKlSzVo0KBE7UuXLlVUVJRTjv2SJUt069Yth74mAGREjJQCgAyuVKlSGjt2rMaOHav33ntPW7du1aRJkxQbG6tRo0Y5uzw7Xl5eKlOmjLy8vJxditNcuXJFkuTv73/f6zZp0sR2rN9//30tX75c58+f14IFCxQVFaXnnntO33//fVqXfFc5c+ZUmTJl0iyUkqSePXvec6TMjRs3tHr1avn4+CgoKEgSn6/MbP78+Tp37pz++uuve44clKQpU6boyJEjGj58uDZu3Kh3331XGzdu1PDhw/Xjjz/qww8/vK/Xb9asmVxcXGxB552uX7+udevWqWXLlve1TWfr2LGj7XwxZ84cnTx5UpUqVdLPP/+sZcuWObu8DKFkyZJ69NFHtWjRoiTbFy5cqMDAQJUsWdLBlUnFihVTmTJlHP66AJDREEoBQCaUMHLk0KFDdsvvNkdFjx49ZLFYdO7cOduyO+fd+f777/X4448rZ86cypcvn4KDg+0ueVi8eLECAgIkSZ9++qndpSMJl58kN49PwuUXly9fVpcuXeTr66s8efKoVatW+uOPPyRJJ06cUFBQkHx8fJQnTx517NhRISEhSe7Lzz//rM6dO6tQoULKnj27ihcvrpdffjnJSzS2bdumFi1ayN/fX+7u7vLz89MTTzyhefPmJf8G/8f58+fVu3dvFS5cWNmzZ1eRIkXUu3dvXbhwIdF+BgcHS/q/4OVB5zVydXVVr169NGfOHMXHx2vo0KEyxtj1iYmJ0dSpU1W1alXlypVLefLk0RNPPKG1a9cm2l7C5+Ds2bOaPn26ypQpI3d3dxUvXlzjxo2T1Wq165/cnFKnTp1Sz549FRAQIHd3d/n4+KhSpUoaPHhwovr+65FHHlGjRo10+vRp7dixI8k+y5YtU1RUlLp162Yb8ZFW80SdPXtWL7zwgooVKyZ3d3cVKlRIPXr0SHL0TsJnNyQkRMHBwfL19ZWHh4dq166d7GVX//zzj8aMGaPHHntMHh4e8vb2VrNmzfTDDz8k6pvUfFgJ/vt9fvvtt2WxWLRkyZIk+3/11VeyWCyJRp/dz/4m5ebNmxo9erTKlSun3Llzy9PTU6VKlVJwcHCKt9GkSRMVL148RX2NMZo/f75y586dKHgfNWqUcufOrfnz56doWwmKFCmip556SkuXLlVMTIxd2+eff66YmBj16tUr2fWvX7+uwYMH2z7vBQoUUKdOnXTs2LFEfVPyfjVs2FDjxo2TJDVq1Mh2rkjus5ASOXLkUNeuXSUl/tkg3f/n4I8//lDfvn3t9rlhw4ZJfv927typNm3ayNfXV+7u7ipdurTeeuutRCOB7jyfJMy9lydPHnl5eenpp5+2+/mU0FeSduzYYfcz537OAT179tSRI0d0+PBhu+VHjx7VTz/9pJ49eya7blxcnKZOnapKlSrJw8NDXl5eatSokdatW2fX77PPPpPFYtH48eOT3M7hw4dlsVhsx0e6+8/rNWvWqHHjxsqbN69y5Mih8uXL6/3331d8fLxdP6vVqvnz56tmzZry8fGRh4eHihQpojZt2tz3ZaEA4CyEUgCQibm5pc1V2GvXrlWbNm3k7++v/v37q2TJklqyZInatWtn61O5cmW98sorkqRKlSppzJgxtkdKfpG6ceOG6tWrp7Nnzyo4OFgNGzbUt99+q6eeekrHjh3T448/roiICPXq1UvVq1fXqlWr9NxzzyVZa82aNbV27Vo1bNhQgwcPVoUKFTRz5kzVqVNHN27csPX95ptv1LhxY+3fv1/NmjXTq6++qrZt2yo6OlqfffZZit6b33//XTVq1NDChQtVrVo1vfrqq6pSpYoWLlyo6tWr6/fff7f1HTNmjO09a9eune39SYuJzrt3767ixYvr119/tftFODo62rZvxhj17t1b3bp10/nz59WuXTvNnDkzye29/vrrevvtt1WnTh3byJWxY8emaPTdlStXVLNmTS1dulSVK1fWkCFD1LVrVxUqVEizZ89O9ItTUhKC1aRGrkiyjWxI6JdW9u/frypVqujTTz9VtWrV9Morr+iJJ57Q0qVLVbNmTVtIeqewsDDVq1dPv/76q7p376727dvr4MGDatasWaJQIjQ0VHXq1NH48eOVN29evfTSS+rQoYMOHTqkRo0aafXq1amuvVu3brJYLPr888+TbE/4THfv3v2B9vdOxhg1a9ZMb7/9tnx8fNS3b1/17dtXVapU0dq1a3Xq1KlU709yTp06pStXrqhu3brKlSuXXVuuXLlUt25d/fHHH7p48eJ9bbdXr162UVF3WrhwoR577DHVqlUryfX++usv1a5dWx999JFKlCihoUOH6sknn9RXX32lWrVq2YWNKX2/evTooQYNGkiSgoODbeeKwYMH39c+Jee/Pxvu93Pwww8/qEqVKpo/f77KlCmjoUOHqn379rp9+7Y++ugju75z5sxRw4YNtXv3brVq1UqDBg1SkSJFNHHiRD311FOJQkBJ+vHHH1W/fn1lz57dNtfY6tWr1aRJE0VFRUn6N7AdM2aMJKl48eJ2P3Pu55waHBwsV1fXRKOlFixYIFdXVz3//PNJrmeMUceOHfXqq68qKipKAwYMUJcuXXT06FG1bdvWbrRe+/btlStXLi1dujTJbSX13UzOyJEjFRQUpJMnT6p9+/bq37+/PDw89Prrr6tz586J+vbp00ehoaHq0qWLBg8erCeffFK//vqrNm/efM/XAoAMwQAAMqSzZ88aSaZZs2aJ2t555x0jybRq1cpueYMGDUxyp/bg4GAjyZw9e9a2bNGiRUaScXNzMz/88INteVxcnGnYsKGRZPbu3ZuopuDg4CRfI2F7ixYtslsuyUgyQ4YMsVver18/I8l4e3ubadOm2ZZbrVbTsmVLI8kcOnTItvz69evG09PTFC5c2Jw7d85uW8uXLzeSzMCBA23L2rdvbySZI0eOJKr1+vXrSe7DfzVq1MhIMnPnzrVbPmvWLCPJPPnkkyl6D+4mYZ1JkybdtV/37t2NJLNgwQLbsjfeeMNIMqNGjTJWq9W2PDw83FSvXt1kz57dXL582bY84XMQEBBgrly5Ylv+119/GW9vb5MnTx4THR1tW75t2zYjyYwZM8a2bPr06UaS3TFL8Pfff6don2/fvm28vb1Nzpw5TXh4uF3b0aNHjSRTvXp1u+XJvbfFixc3xYsXv2ffmJgYU6JECZMnTx5z+PBhu/67du0yrq6upnXr1nbLEz67/fv3N/Hx8bbl8+fPN5LMiy++aNe/S5cuRpL55JNP7JaHhISYokWLmvz585vbt2/ftfYESX2f69WrZ1xdXe2OnTH/vu/Zs2e3e89Ss7//9fPPPxtJJigoKFFbVFSU+eeff+66flImTZp01+/I+vXrE32X7zRw4EAjyWzZsuWer5Xw+X3xxRdNdHS0yZcvn2nZsqWt/cCBA0aS+eCDD8yff/5pJJkGDRrYbaNnz55Gkhk5cqTd8m+++cZIMqVKlbJ9Nu7n/RozZoyRZLZt23bP/bhTwnrLly+3W3779m1TqVIlI8msXLnStvx+PwdRUVGmcOHCxsXFxXz33XeJXv/ixYu2f//666/Gzc3NVKpUKdE5NeE4v//++7ZlCcdDklmxYoVd/4Tz23/3K6ljkhKSTGBgoDHGmNatWxsfHx8TFRVl20cfHx/Tpk0bY4wxgYGBib5rn376qe217zwnnj9/3vj6+ho3Nzdz5swZ2/Ju3boZSWb//v1224mLizN+fn6mYMGCJi4uzrY8qe/3999/b/u5HxERYVtutVrNSy+9ZCSZ//3vf7blPj4+xt/f30RGRiba/5SeiwHA2RgpBQAZ3OnTp23zhrz++ut68skn9cYbb8jPz0/vvfdemrxGly5dVLduXdtzV1dX22VoP/74Y5q8Ru7cuTVhwgS7ZQkjofLly2c3Ca3FYrH9Rfjo0aO25UuWLFF4eLgmTZqU6FKgzp07q2rVqlqxYkWi1/bw8Ei0LF++fPes+cKFC9q2bZvKlSunPn362LW99NJLKlOmjLZu3XrfIzZSK2GequvXr0v699KNOXPmqGTJkho3bpzdpSB58uTR6NGjFRMTo6+++irRtkaNGmU3Ybivr6/atWunf/75RydPnkxRPUm9rz4+PilaN+FSo1u3biU6Zgmjp+52OVVqrF+/XufOndPrr7+uKlWq2LXVq1dP7dq107fffpvo7mW5cuXS5MmT5eLyf/9tCg4Olpubm9334/r16/riiy/05JNP6oUXXrDbRoECBfT666/rr7/+eqARDN27d1d8fLyWL19ut/yLL75QTEyM7aYID7K/SUnqWLu7uyt37typ3JPk3bx5U5KSnTvM09PTrl9KZc+eXV27dtXGjRttc78tXLhQ2bJlS3YES0xMjJYvX658+fLprbfesmtr2bKlnnrqKZ0+fVq7d++2a3PE+/W///3P9rOhf//+CgwM1NGjR/X000+rffv2tn73+zlYs2aNLl++rG7duql58+aJXrdIkSK2f8+dO1dxcXGaMWNGonPqsGHDlD9//kSfVUmqX7++nn32WbtlCd/3tPqZ899th4aG2kYqrl69WqGhoXc9x3z66aeS/p3fLHv27LblxYoV05AhQxQXF2c3MirhM/TfkYzff/+9QkJC1LlzZ7m6ut61zoSRrfPmzbMbJWixWPTuu+/KYrEkej+zZ8+e5HZTei4GAGfj7nsAkMGdOXPGNvdIgoIFC2rXrl0qVapUmrxGtWrVEi1L+MUjLCwsTV6jdOnSypkzp92yhFCkYsWKiebWSGhL+OVRkvbt2yfp30tRzpw5k+g1oqKidP36dV2/fl2+vr7q3LmzvvrqK9WuXVtdunRR48aN9cQTT6R40u4jR45Ikho0aJCoPhcXF9WvX1+//fabjhw5oqJFi6Zom2np5MmTunHjhvz9/RN9RqR/LzuSpN9++y1R24Mc8zZt2mjkyJEaMGCAtmzZoubNm6tBgwZ65JFH7qv+F154QbNmzdLChQttoV/CnbI8PDzUpUuX+9revSR8fk6ePJlojixJunr1qqxWq37//XdVr17dtvzRRx9NFCa4ubnJz8/P7r368ccfFR8fr+jo6CS3n3Dp1m+//abWrVunah86deqkQYMG6bPPPtPQoUNtyz///HO5ubnZXfKa2v29U9myZVWxYkUtX75cly5dUlBQkBo2bKjKlSvbhXSZRa9evTR9+nR9+umnGjJkiFasWKHWrVsrf/78unr1aqL+v/32m6KiotSoUaNE5y/p3/mgNm3apCNHjuiJJ55w6Pu1atUqrVq1ym7ZM888oy+++MLufHW/n4MDBw5Ikpo2bXrPGhK2vXHjRm3ZsiVRe7Zs2dL8/JMarVu3VoECBbRw4UI9++yzWrhwoQoUKHDX7+FPP/2knDlzqmbNmonaGjVqJOn/fkZI/949tVChQlqxYoWmTp1qu4QyIaRKyaV7+/btU65cuZK9rNnDw8Pu/ezcubNmz56t8uXLq3PnzmrUqJHq1KmTZCgKABkVoRQAZHDNmjXThg0bJP0bMnz66acaPny42rZtqwMHDqTJX94TRh7cKeE/1CmZH+hBX+NubbGxsbZloaGhkqRZs2bd9bUiIyPl6+urZ555RqtXr9bUqVP18ccfa9asWbJYLGrUqJE++OCDe85LkjBywM/PL8n2hOAsJSNN0kJCQJc/f35J//d+/Prrr/r111+TXS8yMjLRsgc55iVKlNC+ffs0duxYffvtt/ryyy8lSWXKlNH48eP1zDPPpGBv/p2nrGrVqtq3b59OnDihsmXLau3atbp+/bq6deuW5nfZS3i/kpv3JcF/36+k3ivp3/frzvcqYfu7d+9ONHLmbtu/H97e3mrdurVWrVql48ePq1y5cjpz5oz27Nmjli1bqkCBAonqud/9vZObm5u2bt2qsWPHatWqVXr11Vcl/fsZHDhwoN588817jv64XwnHPbmRUAnft9R8PipVqqSqVatq0aJFKlasmMLCwu46WuZ+zwGOfL+WL1+uzp07Ky4uTidPntRrr72mlStXKjAwUG+//bat3/1+DhLe98KFC9+zhoRtT5w48b5qd8TPnDtly5ZN3bp107Rp07Rnzx5t3rxZQ4YMueu8jOHh4cn+sSGpc7+rq6u6dOmiDz74QBs3blSrVq0UERGh1atXq1y5cqpateo96wwNDVVcXFySf2RIcOf39aOPPlJAQIAWLVqkCRMmaMKECcqRI4c6deqkDz74IE3vmgoA6SXz/YkLAB5i+fPn12uvvaY33nhDJ06cSHQ5ScJf4uPi4hKte7+XumRECb/I/PLLLzLGJPu489K+du3aaceOHbpx44a+++47vfDCC9q+fbuaN29+z7/IJ7xecncBTBhZkVxokZasVqt27twpSapRo4bd63bo0OGu70dyt0N/EOXLl9f//vc/hYaGau/evRo9erSuXr2qZ5999q6BzH8lTGS+YMECSek3wbn0f+/XunXr7vp+JUxAndrtJ0w6n9wjYfJm6d/vbFLfVyn572zCiIuEyZOTG4mRVvubL18+zZgxQ5cvX9bx48c1c+ZM+fj4aMyYMZoyZcq93pb7Vrp0aUlKdhL1hOUJ/e5X7969derUKQ0fPlz+/v5q0aJFsn1Tcw5w9Pvl5uamxx57TF9//bVKlSqliRMn2t1p7n4/B97e3pKky5cv3/O1E7YdHh5+121nBL1795bValWnTp1ktVrveY7x9PTUtWvXkmxL7tz/30v4Vq1apVu3bqVolFTC9vLly3fX9/Ls2bO2/m5ubnrttdf066+/6vLly1q2bJmeeOIJLVmyxO5OfwCQkRFKAUAm9MYbb8jf31+zZ8+2u4V23rx5JSX+ZcJqtdrNzZRaCX/hT4+/ZKdEwt2x9u7de9/r5smTR82bN9e8efPUo0cPhYSEaP/+/XddJ2Ek1c6dOxP9YmWMsYVEaXF3vXv57LPPdP78eVWoUEGPPfaYpH8vrfL09NTBgwftRpQ5UrZs2VS7dm2NGzdO06dPlzFG69evT/H6Xbp0UY4cOfT555/r/Pnz2rhxo0qWLJnqYOhuHuTzkxI1atSQxWK5r+3nzZtX165dSxRMRUZGJhvKtGzZUvny5dOyZctktVq1dOlS5cmTx+5umVLa76/FYlHZsmU1YMAAbdq0SdK/d8NMa6VLl5a/v792796daBRXZGSkdu/erYCAgFRfMpvwmbt8+bKef/75u45cKlOmjHLkyKEff/xRt27dStS+fft2SUmfA+71fqX1+TRHjhx6//33ZYzRiBEjbMvv93OQcLna999/f8++CdtOuIwvPbi4uKTJe1SuXDnVqlVLly9fVu3atVW2bNm79q9SpYpu3bplu5zxTskd90qVKqlChQpas2aN/vnnH33++eeyWCwpDohq1aqlv//+O1V3tfT399dzzz2nDRs2qFSpUtq8ebNu375939sBAEcjlAKATMjDw0PDhw9XbGys3WUaCSNoFi9ebNd/6tSpdn9dTa28efPKYrE4bGLv/+rZs6fy5MmjN998M8nL1W7dumX3y9HOnTuT/GUm4a/fOXLkuOvrFStWTI0aNdKvv/6aaI6PefPm6cSJE3ryySfTdT6p+Ph4LVq0SP369ZOrq6umTp1qmy/Gzc1N/fr10/nz5/Xaa68lGUwdO3Ys2b/2p9ahQ4eSvGQxYTTJvd7XO3l7e6tDhw4KCQlR165dFR8fr169eiWawysttGvXTsWKFdPUqVNtgeKdYmNj9cMPP6R6+wULFlSnTp20Z88evffee0mOENm/f79duFGjRg3FxsbaXVpljNHIkSOTvawuW7ZsevbZZ3XhwgVNmTJFp06dUocOHRLNI5MW+3vu3Dm74DtBao51SlksFr3wwguKiIiwO79J0ttvv62IiIhENx64H97e3tq4caO+/vprDRky5K59s2fPrueee07Xr1/XpEmT7No2bNigjRs3qlSpUrYbRdzP+5UwEXVank/btWunqlWratOmTdq1a5dt2f18Dtq2basiRYro888/18aNGxP1v/OPHv3795ebm5tefvllXbhwIVHfsLAw/fTTTw+0Tz4+Prp06dIDbSPBwoUL9fXXX9tGZt5Nws0+Ro4caXduvXjxom3OqKTCpu7du+v27duaPn26tm7dqgYNGqT4Z0TCDT969eqlv//+O1H71atXdeLECUlSdHS09uzZk6hPZGSkIiIilC1btkw57xuAhw9zSgFAJtW3b19NnjxZS5Ys0RtvvKGSJUuqZ8+emjJlisaOHasjR46oZMmSOnjwoI4dO6YGDRpox44dD/SauXPnVo0aNbRz5051795dpUuXlouLi7p3757obnjpIeFOTs8884wqVaqk5s2bq0yZMoqOjta5c+e0Y8cOPf7447Y5uAYNGqQrV66oXr16KlGihCwWi3744QcdOHBAtWvXVr169e75mnPmzFG9evXUp08frVu3TuXKldOvv/6qtWvXKn/+/JozZ06a7d/mzZsVFRUl6d+A7dKlS9q5c6cuX74sHx8fffbZZ2rSpIndOuPGjdPhw4c1ffp0ffPNN6pfv74KFCigy5cv65dfftHRo0e1d+9eu7mGHtRnn32muXPnqn79+ipZsqQ8PT11/Phxffvtt/Lx8VHPnj3va3u9e/fW0qVLtXv3brm6uqpHjx5pVuud3N3d9b///U8tWrRQgwYN9OSTT6pChQqyWCw6f/68du3apXz58iU5MXNKzZ49WydPntSwYcP02WefqU6dOvL29tbFixd18OBBnTp1Sn/++adt0uyBAwdq0aJFeuGFF7Rp0yblz59fu3btUlhYmCpVqpTsCMfu3btr9uzZGj16tO15euzvkSNH1L59e9WsWVPlypVTwYIFdfnyZa1evVouLi73DHUSzJ8/3xZ8/PLLL7ZlCSNO6tWrZ3fHwmHDhmnNmjWaPHmyfvrpJ1WtWlWHDx/W999/rxo1amjw4MEpet3k1K9fP8V9J0+erB07dmjChAnas2ePatWqpXPnzmnlypXKmTOnFi1aZPvl/37er0aNGsliseiNN97Qr7/+Ki8vL3l7e2vgwIEPtG9jx45V27ZtNXr0aG3btu2+Pwfu7u768ssv1bx5c7Vo0ULNmzdXpUqVFB4eriNHjujWrVu2oKl8+fKaPXu2+vXrp8DAQLVs2VIlS5bUP//8oz/++EM7duxQjx499PHHH6d6f5588kl9+eWXCgoKUpUqVeTq6qq2bduqYsWK972tcuXKqVy5cinq2717d3311Vdas2aNKlasqNatWysyMlJffPGFQkND9cEHHyR5c4cuXbpoxIgRGjdunKxWa4ov3ZOk5s2ba9SoUXr77bdVqlQpNW/eXMWLF9fff/+t06dPa9euXZowYYLKli2r27dvq27dunr00UdVrVo1FStWTBEREVq/fr2uXr2q1157Te7u7il+bQBwGgMAyJDOnj1rJJlmzZol22fGjBlGkunevbtt2ZEjR0zjxo1Nzpw5jaenp2nXrp05deqUCQ4ONpLM2bNnbX0XLVpkJJlFixYl2va2bduMJDNmzBi75SdPnjQtW7Y03t7exmKxGElm27Ztd92eJNOgQYNk9zE4ODjFr2+MMb/99pvp3bu3KV68uMmePbvJmzevqVChghk0aJA5cOCArd+KFStMp06dTMmSJU3OnDmNl5eXqVSpkpk8ebL5559/Em03OefOnTM9e/Y0hQoVMm5ubqZQoUKmZ8+e5ty5c4n63u09TU7COgkPi8VicufObUqUKGHatGljZsyYYUJDQ5NdPy4uzsydO9fUrVvXeHp6Gnd3d1OsWDHTvHlzM2fOHBMREWHrm9TnIMGYMWPsjqcxSR+Hffv2mRdffNGUL1/eeHt7Gw8PD1O6dGkzcOBAc/78+RTvdwKr1WpKlixpJJmWLVsm2y+597Z48eKmePHiKeprjDGXLl0yr7zyiildurRxd3c3np6epmzZsuaFF14wW7Zsseub3Gc3udc1xphbt26ZKVOmmGrVqplcuXIZDw8PExAQYIKCgsySJUtMbGysXf+tW7eaWrVqGXd3d5MvXz7TvXt3ExISYho0aGDu9l+10qVLG0mmSJEiJj4+Ptl+97O//3Xx4kUzYsQIU7t2bVOgQAGTPXt2U6xYMdO+fXuzd+/eu657p4TPXXKPpM4BYWFhZvDgwaZo0aImW7ZsplixYubVV1814eHhKX7dhM/viy++eM++f/75Z7LH+6+//jKDBg0yxYsXN9myZTO+vr6mY8eO5pdffrHrd7/v1+LFi02FChWMu7u7kZTk5+m/Er6ny5cvT7ZP9erVjSS743u/n4PTp0+b3r17myJFiphs2bKZAgUKmIYNG5olS5Yk6nvgwAHTuXNn4+/vb3t/qlatakaMGGFOnDhh63e383pyPw/+/PNP06lTJ+Pr62tcXFxSfH6VZAIDA+/ZzxhjAgMDk/yuxcbGmvfff992jPLkyWMaNGhg1qxZc9ftNWnSxEgyOXLkMDdv3kyyz92+35s2bTJt2rQx+fPnN9myZTMFCxY0derUMW+//ba5cOGCMcaYmJgYM3nyZNO0aVNTpEgRkz17duPn52fq169vli1bZqxWa4r2HQCczWJMBpl9EAAAAAAAAA8NLjQGAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAABzOzdkFZERWq1VXrlxRnjx5ZLFYnF0OAAAAAABApmGM0T///CN/f3+5uCQ/HopQKglXrlxR0aJFnV0GAAAAAABApnXx4kUVKVIk2XZCqSTkyZNH0r9vnqenp5OrAQAAAAAAyDzCw8NVtGhRW76SHEKpJCRcsufp6UkoBQAAAAAAkAr3mhKJic4BAAAAAADgcIRSAAAAAAAAcDhCKaSbmTNnqnr16nJ3d1dQUFCi9vnz5yswMFC5cuVSiRIltGbNGlubMUaTJk1SiRIllCtXLj366KPav3+/A6sHAAAAAADpiTmlkG78/f311ltvafPmzbp06ZJd27x58/Thhx9qxYoVqly5sq5du6bIyEhb+5tvvqmdO3dq8+bNKlmypC5cuKDs2bM7ehcAAAAAAEA6sRhjjLOLyGjCw8Pl5eWlmzdvMtF5Ghg7dqyOHDmi1atXS5Li4+NVuHBhLVmyRE2bNk3UPzQ0VP7+/vr555/16KOPOrhaAAAAAADwIFKaq3D5Hhzu5MmTCgkJ0eHDh1WiRAkVKVJEffr0UXh4uCRp3759cnd31/Lly+Xv768SJUpo+PDhiomJcXLlAAAAAAAgrRBKweFCQ0MlSZs3b9bBgwd15MgRnT17VkOGDLG1h4eH69SpU/r999+1c+dOfffdd5o8ebIzywYAAAAAAGmIUAoOlzt3bknSyJEj5evrK19fX40cOVLr1q2zax83bpxy586tYsWK6ZVXXrG1AwAAAACAzI9QCg4XGBioHDlyJNteqVIlB1YDAAAAAACcgVAK6SYuLk5RUVGKi4uT1WpVVFSUYmJi5OHhoW7dumny5Mm6ceOGwsLCNHnyZLVr106SFBAQoCZNmmj8+PG6deuWrly5ohkzZtjaAQAAAABA5kcohXQzYcIEeXh4aOLEiVq3bp08PDxsd9ubNm2a/P39FRAQoMDAQBUvXlxTp061rbt06VLdvHlTfn5+qlGjhpo1a6Zhw4Y5a1cAAAAAAEAasxhjjLOLyGhSeutCAEhrM2fO1OLFi/XLL7+oRYsWWr16tV37/Pnz9d577+nSpUvKnz+/PvroI7Vr107R0dFq1qyZjh8/rqioKPn7+2vo0KHq27evc3YEAAAAwEMrpbmKmwNrAgDcg7+/v9566y1t3rxZly5dsmubN2+ePvzwQ61YsUKVK1fWtWvXFBkZKUlyc3PTjBkzVLZsWbm5uen48eNq1KiRypYtqyeeeMIZuwIAAAAAd0UoBQAZSPv27SVJR44csQul4uPjNXr0aC1ZskRVqlSRJPn5+dnaXV1dVaFCBdtzi8Uii8Wi06dPE0oBAAAAyJCYUwoAMoGTJ08qJCREhw8fVokSJVSkSBH16dNH4eHhdv1at26tHDlyqFy5cvLz89PTTz/tpIoBAAAA4O4IpQAgEwgNDZUkbd68WQcPHtSRI0d09uxZDRkyxK7f+vXrFRkZqe3bt6tDhw7y8PBwRrkAAAAAcE+EUgCQCeTOnVuSNHLkSPn6+srX11cjR47UunXrEvV1dXVVgwYNFBISovfee8/RpQIAAABAihBKAUAmEBgYqBw5ctzXOrGxsTp16lQ6VQQAAAAAD4ZQCgAykLi4OEVFRSkuLk5Wq1VRUVGKiYmRh4eHunXrpsmTJ+vGjRsKCwvT5MmT1a5dO0n/Toy+adMm3b59W3Fxcfrmm2+0dOlSNWvWzMl7BAAAAABJ4+57AJCBTJgwQePGjbM99/DwUIMGDbR9+3ZNmzZNAwYMUEBAgNzd3dW2bVtNnTpV0r9h1htvvKGTJ0/KYrGoRIkSmjp1qrp06eKsXQEAAACAu7IYY4yzi8howsPD5eXlpZs3b8rT09PZ5TyQd3+67uwSsowRVXydXQIAAAAAABleSnMVLt8DAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAO5+bsAgAgo3n3p+vOLiHLGFHF19klAAAAAMigGCkFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhMlQotXPnTrVp00b+/v6yWCxavXp1oj4nTpxQ27Zt5eXlpVy5cqlGjRq6cOGCrT0qKkoDBgxQvnz5lDt3bnXo0EEhISEO3Asg45s5c6aqV68ud3d3BQUF2bU1bNhQ7u7uyp07t+1x5cqVFLcDAAAAAJASGSqUioyMVKVKlTRr1qwk28+cOaN69eqpTJky2r59u37++WeNGjVKOXLksPUZMmSI1q1bp5UrV2rHjh26cuWK2rdv76hdADIFf39/vfXWW+rTp0+S7ZMnT1ZERITt4e/vf1/tAAAAAADcS4a6+16LFi3UokWLZNvffPNNtWzZUlOmTLEtK1mypO3fN2/e1IIFC7Rs2TI9+eSTkqRFixapbNmy2rdvn2rXrp1+xQOZSEJQe+TIEV26dMnJ1QAAAAAAHkYZaqTU3VitVn3zzTd69NFH1axZMxUoUEC1atWyu8Tv0KFDio2NVZMmTWzLypQpo2LFimnv3r3Jbjs6Olrh4eF2D+BhNmHCBPn4+KhKlSpasmTJfbcDAAAAAHAvmSaUunbtmiIiIvTuu++qefPm+v777/X000+rffv22rFjhyTp6tWryp49u7y9ve3W9fPz09WrV5Pd9qRJk+Tl5WV7FC1aND13BcjQJk2apDNnzigkJETvvvuuXn75ZX399dcpbgcAAAAAICUyTShltVolSe3atdOQIUNUuXJljRgxQq1bt9bHH3/8QNseOXKkbt68aXtcvHgxLUoGMqU6derIy8tL2bJlU7NmzfTiiy/qiy++SHE7AAAAAAApkWlCKV9fX7m5ualcuXJ2y8uWLWu7+17BggUVExOjsLAwuz4hISEqWLBgstt2d3eXp6en3QPAv1xc7n6auFc7AODh9SB3e+3YsaMKFSokT09PBQQEaMKECQ6uHgAApLdM89tk9uzZVaNGDZ08edJu+e+//67ixYtLkqpVq6Zs2bJpy5YttvaTJ0/qwoULqlOnjkPrBTKyuLg4RUVFKS4uTlarVVFRUbZA99tvv9WtW7cUHx+vLVu26OOPP1aHDh0k6Z7tAADc6UHu9jpmzBidO3dO4eHh2rFjh5YtW6bPP//cUaUDAAAHyFB334uIiNDp06dtz8+ePasjR47Ix8dHxYoV0+uvv65nn31W9evXV6NGjbRhwwatW7dO27dvlyR5eXmpd+/eGjp0qHx8fOTp6amXX35ZderU4c57wB0mTJigcePG2Z57eHioQYMGWrlypcaNG6fOnTtLkkqUKKGpU6fqmWeekSTFxsbetR0AgDs9yN1eK1SoYPu3xWKRi4uLTp06lab1AQAA57IYY4yzi0iwfft2NWrUKNHy4OBgLV68WJK0cOFCTZo0SZcuXVJgYKDGjRundu3a2fpGRUXp1Vdf1fLlyxUdHa1mzZpp9uzZd71877/Cw8Pl5eWlmzdvZvpL+d796bqzS8gyRlTxdXYJcBC+N2mH7w0ASRo7dqyOHDlid9fkhg0b6tixY7JarSpevLiGDBmi559/3m69/v37a/Hixbp9+7aKFy+ubdu2KSAgwMHVAwCA+5XSXCVDjZRq2LCh7pWR9erVS7169Uq2PUeOHJo1a5ZmzZqV1uUBAAAgjUyaNEnlypVTzpw5tXXrVnXq1El58uTR008/besze/ZszZw5U4cPH9batWuVN29eJ1YMAADSWqaZUwoAAABZR0rv5uri4qLq1asrT548eu2115xQKQAASC+EUgAAAHC6e93NNTY2ljmlAADIYgilAAAAkC5Se7fX8+fPa9WqVYqIiJDVatWePXs0ffp0NWvWzMl7BAAA0lKGmlMKAAAAWUdq7/YqSdOmTVPv3r1ltVrl7++vl19+WSNGjHD4PgAAgPSToe6+l1Fw9z0khbuIPTz43qQdvjcAAADAwyeluQqX7wEAAAAAAMDhCKUAAAAAAADgcMwpBTgJl4ilHS4RAwAAAIDMh5FSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADsdE5wAAAFkYN9ZIO9xYAwCAtMVIKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4TJUKLVz5061adNG/v7+slgsWr16dbJ9X3rpJVksFk2bNs1ueWhoqLp27SpPT095e3urd+/eioiISN/CAQAAAAAAcF8yVCgVGRmpSpUqadasWXft9/XXX2vfvn3y9/dP1Na1a1f9+uuv2rRpk9avX6+dO3eqb9++6VUyAAAAAAAAUsHN2QXcqUWLFmrRosVd+1y+fFkvv/yyNm7cqFatWtm1nThxQhs2bNCPP/6o6tWrS5JmzJihli1b6v33308yxAIAAAAAAIDjZaiRUvditVrVvXt3vf7663rssccSte/du1fe3t62QEqSmjRpIhcXF+3fv9+RpQIAAAAAAOAuMtRIqXuZPHmy3NzcNGjQoCTbr169qgIFCtgtc3Nzk4+Pj65evZrsdqOjoxUdHW17Hh4enjYFAwAAAAAAIEmZZqTUoUOH9NFHH2nx4sWyWCxpuu1JkybJy8vL9ihatGiabh8AAAAAAAD2Mk0otWvXLl27dk3FihWTm5ub3NzcdP78eb366qsqUaKEJKlgwYK6du2a3XpxcXEKDQ1VwYIFk932yJEjdfPmTdvj4sWL6bkrAAAAAAAAD71Mc/le9+7d1aRJE7tlzZo1U/fu3dWzZ09JUp06dRQWFqZDhw6pWrVqkqStW7fKarWqVq1ayW7b3d1d7u7u6Vc8AAAAAAAA7GSoUCoiIkKnT5+2PT979qyOHDkiHx8fFStWTPny5bPrny1bNhUsWFCBgYGSpLJly6p58+bq06ePPv74Y8XGxmrgwIHq3Lkzd94DAAAAAADIQDLU5XsHDx5UlSpVVKVKFUnS0KFDVaVKFY0ePTrF21i6dKnKlCmjxo0bq2XLlqpXr57mzZuXXiUDAAAAAAAgFTLUSKmGDRvKGJPi/ufOnUu0zMfHR8uWLUvDqgAAAAAAAJDWMtRIKQAAAAAAADwcCKUAAAAAIIOYOXOmqlevLnd3dwUFBdm1dezYUYUKFZKnp6cCAgI0YcIEu/a+ffsqMDBQLi4umjZtmuOKBoBUIpQCAAAAgAzC399fb731lvr06ZOobcyYMTp37pzCw8O1Y8cOLVu2TJ9//rmtvVKlSpo9e7Zq1qzpyJIBINUIpQAAAAAgg2jfvr2CgoLk6+ubqK1ChQpyd3eXJFksFrm4uOjUqVO29gEDBqhx48bKkSOHw+oFgAdBKAUAAAAAmUT//v2VM2dOFStWTBEREerRo4ezSwKAVCOUAgAAAIBMYvbs2YqIiNCPP/6o559/Xnnz5nV2SQCQaoRSAAAAAJCJuLi4qHr16sqTJ49ee+01Z5cDAKlGKAUAAAAAmVBsbKzdnFIAkNkQSgEAAABABhEXF6eoqCjFxcXJarUqKipKMTExOn/+vFatWqWIiAhZrVbt2bNH06dPV7NmzWzrxsTEKCoqSlar1W47AJBREUoBAAAAQAYxYcIEeXh4aOLEiVq3bp08PDzUtGlTSdK0adNUpEgReXt7q1evXnr55Zc1YsQI27pNmzaVh4eHdu3apddff10eHh6aMGGCs3YFAO7JzdkFAAAAAAD+NXbsWI0dOzbJtl27dt113e3bt6d9QQCQjhgpBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHM7N2QUAAAAAQEby7k/XnV1CljGiiq+zSwCQgTFSCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAytZkzZ6p69epyd3dXUFCQbfm1a9fUtWtXFSlSRJ6enqpSpYrWrl1rt27fvn0VGBgoFxcXTZs2zbGFAwAAPOQIpQAAQKbm7++vt956S3369LFbHhERoSpVqmjfvn0KCwvT+PHj9dxzz+n48eO2PpUqVdLs2bNVs2ZNR5cNAADw0COUAgAAmVr79u0VFBQkX19fu+WPPPKIXnvtNRUpUkQuLi5q06aNAgMDtW/fPlufAQMGqHHjxsqRI4ejywYAAHjoEUoBAICHwrVr13TixAlVrFjR2aUAAABAhFIAAOAhEBMTo86dO6tTp06qXr26s8sBAACACKUAAEAWFxMTo44dOypnzpz65JNPnF0OAAAA/j83ZxcAAACQXmJiYvTMM88oJiZGa9asUfbs2Z1dEgAAAP4/QikAAJCpxcXF2R5Wq1VRUVFycXGRxWJRp06dFBkZqfXr18vd3T3RujExMbJarbJarYqLi1NUVJTc3Nzk5sZ/kQAAANIbl+8BAIBMbcKECfLw8NDEiRO1bt06eXh4qGnTptqzZ4/WrFmj3bt3y9fXV7lz51bu3Ln1zjvv2NZt2rSpPDw8tGvXLr3++uvy8PDQhAkTnLg3AAAADw/+DAgAADK1sWPHauzYsUm2GWPuuu727dvTviAAAACkCCOlAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAApMHPmTFWvXl3u7u4KCgqyaxs1apQqVKggNzc3DR48ONG6xhhNmjRJJUqUUK5cufToo49q//79jikcAAAAyKCY6BwAgBTw9/fXW2+9pc2bN+vSpUt2baVKldKUKVP0ySefJLnum2++qZ07d2rz5s0qWbKkLly4oOzZszuibAAAACDDylAjpXbu3Kk2bdrI399fFotFq1evtrXFxsZq+PDhqlChgnLlyiV/f389//zzunLlit02QkND1bVrV3l6esrb21u9e/dWRESEg/cEAJDVtG/fXkFBQfL19U3UFhwcrBYtWsjT0zNRW2hoqKZOnaqFCxeqVKlSslgsKl68uAoVKuSIsgEAAIAMK0OFUpGRkapUqZJmzZqVqO3WrVs6fPiwRo0apcOHD+urr77SyZMn1bZtW7t+Xbt21a+//qpNmzZp/fr12rlzp/r27euoXQAAwM6+ffvk7u6u5cuXy9/fXyVKlNDw4cMVExPj7NIAAAAAp8pQl++1aNFCLVq0SLLNy8tLmzZtsls2c+ZM1axZUxcuXFCxYsV04sQJbdiwQT/++KOqV68uSZoxY4Zatmyp999/X/7+/um+DwAA3Ck0NFTh4eE6deqUfv/9d4WGhqp169bKnTu3Ro0a5ezy0sy7P113dglZxogqiUfjAQAAZEUZaqTU/bp586YsFou8vb0lSXv37pW3t7ctkJKkJk2ayMXFhQllAQBOkTt3bknSuHHjlDt3bhUrVkyvvPKK1q1b5+TKAAAAAOfKUCOl7kdUVJSGDx+u5557zjaHx9WrV1WgQAG7fm5ubvLx8dHVq1eT3VZ0dLSio6Ntz8PDw9OnaADAQ6dSpUrOLgEAAADIkDLlSKnY2Fh16tRJxhjNmTPngbc3adIkeXl52R5FixZNgyoBAFlJXFycoqKiFBcXJ6vVqqioKNu8ULGxsYqKilJ8fLzi4+MVFRWl2NhYSVJAQICaNGmi8ePH69atW7py5YpmzJihdu3aOXN3AAAAAKfLdKFUQiB1/vx5bdq0ye5ORwULFtS1a9fs+sfFxSk0NFQFCxZMdpsjR47UzZs3bY+LFy+mW/0AgMxpwoQJ8vDw0MSJE7Vu3Tp5eHioadOmkqQ+ffrIw8NDn3/+uWbOnCkPDw/16dPHtu7SpUt18+ZN+fn5qUaNGmrWrJmGDRvmrF0BAAAAMoRMdfleQiB16tQpbdu2Tfny5bNrr1OnjsLCwnTo0CFVq1ZNkrR161ZZrVbVqlUr2e26u7vL3d09XWsHAGRuY8eO1dixY5NsW7x4sRYvXpzsugUKFNDq1avTpS4AAAAgs8pQoVRERIROnz5te3727FkdOXJEPj4+KlSokDp27KjDhw9r/fr1io+Pt80T5ePjo+zZs6ts2bJq3ry5+vTpo48//lixsbEaOHCgOnfuzJ33AAAAAAAAMpAMFUodPHhQjRo1sj0fOnSoJCk4OFhjx47V2rVrJUmVK1e2W2/btm1q2LChpH8vkRg4cKAaN24sFxcXdejQQdOnT3dI/QAAAAAAAEiZDBVKNWzYUMaYZNvv1pbAx8dHy5YtS8uyAAAAAAAAkMYy3UTnAAAAAAAAyPwIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAABwuQ919DwCAu3n3p+vOLiHLGFHF19klAAAA4CHHSCkAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA6Xqjmljh49qt27d+v48eO6fv26LBaLfH19VbZsWT3++OOqXLlyGpcJAAAAAACArCTFodS1a9c0e/ZsLVmyROfPn5cxRtmzZ1fevHlljFFYWJhiYmJksVhUrFgxBQcHq1+/fvLz80vP+gEAAAAAAJAJpejyveHDh+uRRx7RvHnz1Lp1a61evVqXLl1SVFSU/vzzT129elVRUVG6dOmSVq9erdatW+uTTz5RyZIlNXLkyPTeBwAAAAAAAGQyKRoptXPnTn3++edq166dLBZLsv38/f3l7++vNm3aaPr06VqzZo2mTJmSZsUCAAAAAAAga0hRKLV379773rDFYlFQUJCCgoLue10AAAAAAABkbdx9DwAAAAAAAA6XqlDqwoUL+uGHH+yWHT16VM8//7yeffZZrV69Oi1qAwAAAAAAQBaV4rvv3WnQoEGKiIjQ5s2bJUkhISFq1KiRYmJilCdPHv3vf//TypUr1b59+zQtFgAAAAAAAFlDqkZKHThwQE899ZTt+ZIlS3T79m0dPXpUly9fVuPGjfX++++nWZEAAAAAAADIWlIVSoWGhqpAgQK25+vXr1eDBg1UsmRJubi4qH379vrtt9/SrEgAAAAAAABkLakKpfLnz6/z589LksLCwrRv3z41a9bM1h4XF6e4uLi0qRAAAAAAAABZTqrmlGrSpImmT58uT09Pbd++XVarVUFBQbb248ePq2jRomlVIwAAAAAAALKYVIVS7777rn7//Xe99tpryp49u95//30FBARIkqKjo/Xll1+qS5cuaVooAAAAAAAAso5UhVJ+fn7avXu3bt68KQ8PD2XPnt3WZrVatWXLFkZKAQAAAAAAIFmpCqUSeHl5JVrm4eGhSpUqPchmAQAAAAAAkMWlaqJzSbpw4YJeeuklBQYGKm/evNq5c6ck6fr16xo0aJB++umnNCsSAAAAAAAAWUuqRkodP35cTzzxhKxWq2rVqqXTp0/b7rbn6+urH374QZGRkVqwYEGaFgsAAAAAAICsIVWh1LBhw+Tt7a19+/bJYrGoQIECdu2tWrXSF198kSYFAgAAAAAAIOtJ1eV7O3fuVL9+/ZQ/f35ZLJZE7cWKFdPly5cfuDgAAAAAAABkTakKpaxWq3LmzJls+19//SV3d/dUFwUAAAAAAICsLVWhVNWqVfXNN98k2RYXF6cVK1aodu3aD1QYAAAAAAAAsq5UhVIjR47Uhg0b1K9fPx07dkySFBISos2bN6tp06Y6ceKERowYkaaFAgAAAAAAIOtI1UTnLVq00OLFi/XKK69o3rx5kqRu3brJGCNPT08tWbJE9evXT9NCAQAAAAAAkHWkKpSSpO7du6t9+/batGmTTp06JavVqpIlS6pZs2bKkydPWtYIAAAAAACALCZVodTOnTtVtmxZ5c+fX0FBQYnar1+/ruPHjzNaCgAAAAAAAElK1ZxSjRo10qZNm5Jt37Jlixo1apTqogAAAAAAAJC1pSqUMsbctT06Olqurq6pKggAAAAAAABZX4ov37tw4YLOnTtne/7bb79p586difqFhYVp7ty5Kl68eJoUCAAAAAAAgKwnxaHUokWLNG7cOFksFlksFk2cOFETJ05M1M8YI1dXV82dOzdNCwUAAAAAAEDWkeJQqlOnTipfvryMMerUqZMGDRqkJ554wq6PxWJRrly5VLlyZfn5+aV5sQAAAAAAAMgaUhxKlS1bVmXLlpX076ip+vXrKyAgIN0KAwAAAAAAQNaV4lDqTsHBwWldBwAAAAAAAB4iqQqlevXqdc8+FotFCxYsSM3mAQAAAAAAkMWlKpTaunWrLBaL3bL4+Hj9+eefio+PV/78+ZUrV640KRAAAAAAAABZT6pCqXPnziW5PDY2VnPnztW0adO0adOmB6kLAAAAAAAAWZhLWm4sW7ZsGjhwoJo2baqBAwfe9/o7d+5UmzZt5O/vL4vFotWrV9u1G2M0evRoFSpUSB4eHmrSpIlOnTpl1yc0NFRdu3aVp6envL291bt3b0VERDzIbgEAAAAAACCNpWkolaBSpUrauXPnfa8XGRmpSpUqadasWUm2T5kyRdOnT9fHH3+s/fv3K1euXGrWrJmioqJsfbp27apff/1VmzZt0vr167Vz50717ds31fsCAAAAAACAtJeqy/fuZdOmTcqZM+d9r9eiRQu1aNEiyTZjjKZNm6a33npL7dq1kyQtWbJEfn5+Wr16tTp37qwTJ05ow4YN+vHHH1W9enVJ0owZM9SyZUu9//778vf3T/1OAQAAAAAAIM2kKpQaP358ksvDwsK0c+dOHT58WCNGjHigwv7r7Nmzunr1qpo0aWJb5uXlpVq1amnv3r3q3Lmz9u7dK29vb1sgJUlNmjSRi4uL9u/fr6effjrJbUdHRys6Otr2PDw8PE1rBwAAAAAAgL1UhVJjx45NcnnevHlVsmRJffzxx+rTp8+D1JXI1atXJUl+fn52y/38/GxtV69eVYECBeza3dzc5OPjY+uTlEmTJmncuHFpWi8AAAAAAACSl6pQymq1pnUdTjVy5EgNHTrU9jw8PFxFixZ1YkUAAAAAAABZW7pMdJ4eChYsKEkKCQmxWx4SEmJrK1iwoK5du2bXHhcXp9DQUFufpLi7u8vT09PuAQAAAAAAgPTzQBOd//PPPzp//rxu3LghY0yi9vr16z/I5u0EBASoYMGC2rJliypXrizp3xFN+/fvV79+/SRJderUUVhYmA4dOqRq1apJkrZu3Sqr1apatWqlWS0AAAAAAAB4MKkKpf7++28NHDhQq1atUnx8fKJ2Y4wsFkuSbXcTERGh06dP256fPXtWR44ckY+Pj4oVK6bBgwdrwoQJKl26tAICAjRq1Cj5+/srKChIklS2bFk1b95cffr00ccff6zY2FgNHDhQnTt35s57AAAAAAAAGUiqQqk+ffpo3bp1GjRokJ544gnlzZs3TYo5ePCgGjVqZHueMM9TcHCwFi9erGHDhikyMlJ9+/ZVWFiY6tWrpw0bNihHjhy2dZYuXaqBAweqcePGcnFxUYcOHTR9+vQ0qQ8AAAAAAABpI1Wh1Pfff68hQ4ZoypQpaVpMw4YNk7wMMIHFYtH48eM1fvz4ZPv4+Pho2bJlaVoXAAAAAAAA0laqJjrPmTOnSpQokcalAAAAAHCGM2fOqEWLFsqbN68KFy5s98fnUaNGqUKFCnJzc9PgwYOdVyQAIMtJVSjVrVs3ff3112ldCwAAAAAHi4+PV9u2bVW1alVdu3ZNW7du1cyZM21XH5QqVUpTpkxR27ZtnVwpACCrSdXlex07dtSOHTvUvHlz9e3bV0WLFpWrq2uiflWrVn3gAgEAAACkn5MnT+rkyZMaM2aMsmXLpsDAQPXu3Vvz5s1Tly5dFBwcLEn64osvnFwpACCrSVUoVa9ePdu/N23alKg9tXffAwAAAOBYVqtVkuzmdrVarfr555+dVRIA4CGRqlBq0aJFaV0HAAAAACcIDAxUiRIlNHr0aI0fP16nT5/WwoULFR4e7uzSAABZXKpCqYQhvAAAAAAyt2zZsmnNmjUaMmSIChcurCJFiqhnz56aO3eus0sDAGRxqZroHAAAAEDW8dhjj+n777/X9evXdeTIEUVHR6tBgwbOLgsAkMWlaKRUr169ZLFYNG/ePLm6uqpXr173XMdisWjBggUPXCAAAACA9PXzzz+rZMmSypYtm9avX6+FCxdqy5YtkqTY2FjFx8fbHlFRUXJ1dVW2bNmcXDUAILNLUSi1detWubi4yGq1ytXVVVu3bpXFYrnrOvdqBwAAAJAxfPnll5ozZ46ioqJUqVIlrV69WhUrVpQk9enTR59++qmt78yZMxUcHKzFixc7qVoAQFaRolDq3Llzd30OAAAAIPOaMGGCJkyYkGTb4sWLCaAAAOmCOaUAAAAAAADgcIRSAAAAAAAgy7h8+bKCgoKUL18++fr6qlOnTvrrr78kSblz57Z7ZMuWzXa5MhwvRZfvSbrvg2SxWHT06NH7LggAAAAAACC1BgwYIEk6f/68jDHq2rWrBg0apOXLlysiIsKub8WKFdW5c2dnlAndRyh17NgxeXh4qHr16nJxYYAVAAAAAADIeP744w+NGDFCuXPnliQ9++yzmjRpUqJ+Bw4c0PHjx9WjRw8HV4gEKQ6l6tSpo7179+rUqVPq1KmTunTpopo1a6ZnbQAAAAAAAPdl6NChWrlypVq1aiVjjJYvX642bdok6rdgwQK1aNFC/v7+TqgS0n3MKbV7926dPXtWL7/8srZs2aI6deqodOnSGjNmjE6ePJmeNQIAAAAAAKRI3bp1de3aNeXNm1c+Pj66ceOGRo4cadcnMjJSK1as0AsvvOCkKiHd50TnxYsX18iRI/XLL7/o8OHDevrpp7V48WKVLVtWVatW1QcffKCQkJD0qhUAAAAAACBZVqtVTz31lOrWrauIiAhFRESobt26atq0qV2/lStXKmfOnGrVqpWTKoX0AHffq1SpkqZMmaLz589r+/bt8vb21rBhwzR37ty0rA8AAAAAACBFQkNDdf78eQ0aNEg5c+ZUzpw59fLLL2v//v26fv26rd/8+fMVHBwsN7cUz2qEdPBA7/7ly5e1YsUKLVu2TD/99JOKFSumKlWqpFVtAAAAQJb17k/X790JKTKiiq+zSwCQQfj6+qpUqVKaNWuWxowZI0maNWuWihQpIl/ff88VJ0+e1J49e7Ro0SJnlgqlYqRUaGio5s6dq4YNG6pYsWJ69913VatWLe3cuVPnzp1LcvIwAAAAAAAAR1izZo0OHz6swoULq1ChQjpw4IDWrl1ra1+wYIGeeOIJlS5d2olVQrqPkVLLli3TsmXLtGnTJrm7u6tt27Zat26dmjZtynA3AAAAAACQIZQrV04bN25Mtn3KlCkOrAZ3k+I0qVu3bvLw8FDbtm3Vrl075cyZU1FRUXZp43+1b98+TYoEAAAAAABA1nJfQ5xu376tVatW6auvvpIkGWOS7WuxWBQfH/9g1QEAAAAAACBLSnEotW3btvSsAwAAAAAAAA+RFIdSDRo0SM86AAAAAAAA8BC577vvAQAAAAAAAA8qRaHUiy++qLNnz973xs+cOaMXX3zxvtcDAAAAAABA1paiUOrixYsKDAxUixYttHjxYl28eDHZvufOndP8+fPVtGlTlSlTRpcuXUqzYgEAAAAAAJA1pGhOqW+//Va7d+/W+++/r759+yo+Pl758uVTiRIllDdvXhljdOPGDZ09e1Y3btyQq6urWrZsqW3btqlevXrpvQ8AAAAAAADIZFI80XndunVVt25d/fXXX1q/fr327t2r3377zTYSKl++fGrfvr3q1KmjVq1aqUCBAulWNAAAAAAAyDje/em6s0vIMkZU8XV2CQ6T4lAqQf78+dWzZ0/17NkzPeoBAAAAAADAQ4C77wEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADuf2ICvv27dP27Zt07Vr19S/f3+VLl1at27d0m+//aZHH31UuXPnTqs6AQAAAAAAkIWkaqRUTEyM2rdvr7p16+rNN9/U9OnTdfHixX836OKipk2b6qOPPkrTQgEAAAAAyAhy585t98iWLZsqVqyY4nYA/0pVKDVq1CitX79ec+bM0cmTJ2WMsbXlyJFDzzzzjNasWZNmRQIAAAAAkFFERETYPcqWLavOnTunuB3Av1IVSi1fvlz9+vVT37595ePjk6i9bNmy+uOPPx64OAAAAAAAMrIDBw7o+PHj6tGjR6ragYdZqkKpa9euqUKFCsm2u7q66tatW6kuCgAAAACAzGDBggVq0aKF/P39U9UOPMxSNdF50aJF9dtvvyXbvnv3bpUqVSrVRQEAAAAAkNFFRkZqxYoVWrJkSaragYddqkZKdenSRXPnztXevXttyywWiyTpk08+0Zdffqnnn38+bSq8Q3x8vEaNGqWAgAB5eHioZMmSevvtt+3mtDLGaPTo0SpUqJA8PDzUpEkTnTp1Ks1rAQAAAAA83FauXKmcOXOqVatWqWoHHnapGin15ptvat++fapfv77Kli0ri8WiIUOGKDQ0VJcuXVLLli01ZMiQtK5VkydP1pw5c/Tpp5/qscce08GDB9WzZ095eXlp0KBBkqQpU6Zo+vTp+vTTTxUQEKBRo0apWbNmOn78uHLkyJHmNQEAAAAAHk7z589XcHCw3NyS/tX6Xu3Awy5VI6WyZ8+uDRs2aNGiRXrkkUdUpkwZRUdHq2LFilq8eLHWrVsnV1fXtK5Ve/bsUbt27dSqVSuVKFFCHTt2VNOmTXXgwAFJ/46SmjZtmt566y21a9dOFStW1JIlS3TlyhWtXr06zesBAAAAADycTp48qT179qh3796pageQypFS0r+X63Xr1k3dunVLy3ru6vHHH9e8efP0+++/69FHH9XRo0f1ww8/aOrUqZKks2fP6urVq2rSpIltHS8vL9WqVUt79+7lFpwAAAAAgDSxYMECPfHEEypdunSq2gE8QCjlDCNGjFB4eLjKlCkjV1dXxcfHa+LEieratask6erVq5IkPz8/u/X8/PxsbUmJjo5WdHS07Xl4eHg6VA8AAAAAyCqmTJnyQO0AHiCU+uGHH7Rw4UL98ccfunHjht1k49K/I6mOHj36wAXe6csvv9TSpUu1bNkyPfbYYzpy5IgGDx4sf39/BQcHp3q7kyZN0rhx49KwUgAAAAAAANxNqkKpqVOn6vXXX1eOHDkUGBgoHx+ftK4rSa+//rpGjBhhuwyvQoUKOn/+vCZNmqTg4GAVLFhQkhQSEqJChQrZ1gsJCVHlypWT3e7IkSM1dOhQ2/Pw8HAVLVo0fXYCAAAAAAAAqQul3nvvPdWtW1fr1q2Tl5dXWteUrFu3bsnFxX5udldXV1mtVklSQECAChYsqC1btthCqPDwcO3fv1/9+vVLdrvu7u5yd3dPt7oBAAAAAABgL1Wh1K1bt9S1a1eHBlKS1KZNG02cOFHFihXTY489pp9++klTp05Vr169JP17yeDgwYM1YcIElS5dWgEBARo1apT8/f0VFBTk0FoBAAAAAACQvFSFUo0aNdIvv/yS1rXc04wZMzRq1Cj1799f165dk7+/v1588UWNHj3a1mfYsGGKjIxU3759FRYWpnr16mnDhg3KkSOHw+sFAAAAAABA0lIVSs2YMUNNmzbV+++/r169ejlsTqk8efJo2rRpmjZtWrJ9LBaLxo8fr/HjxzukJgAAAAAAANw/l3t3Saxo0aJ68cUXNWLECOXPn1+5cuWSp6en3cPRl/YBAAAAAAAg80jVSKnRo0dr4sSJKly4sKpXr04ABQAAAAAAgPuSqlDq448/VqtWrbR69epEd8MDAAAAACA9vPvTdWeXkGWMqOLr7BKA1F2+FxMTo1atWhFIAQAAAAAAIFVSlSq1bt1au3btSutaAAAAAAAA8JBIVSg1ZswYHT9+XP3799ehQ4f0119/KTQ0NNEDAAAAAAAASEqq5pQKDAyUJB05ckRz585Ntl98fHzqqgIAAAAAAECWluq771kslrSuBQAAAAAAAA+JVIVSY8eOTeMyAAAAAAAA8DDh9nkAAAAAAABwuBSNlBo/frwsFovefPNNubi4aPz48fdcx2KxaNSoUQ9cIAAAAAAAALKeFIVSY8eOlcVi0fDhw5U9e/YUXb5HKAUAAAAAAIDkpCiUslqtd30OAAAAAAAA3A/mlAIAAAAAAIDDpSqUcnV11bJly5Jt/+KLL+Tq6prqogAAAAAAAJC1pSqUMsbctT0+Pl4WiyVVBQEAAAAAACDrS/Xle8mFTuHh4dq4caN8fX1TXRQAAAAAAACythSHUuPGjZOrq6tcXV1lsVjUrVs32/M7H3nz5tVnn32mzp07p2fdAAAAAAAAyMRSdPc9SapZs6b69+8vY4xmz56tp556So8++qhdH4vFoly5cqlatWpq3759mhcLAAAAAACArCHFoVSLFi3UokULSVJkZKReeukl1apVK90KAwAAAAAAQNaV4lDqTosWLUrrOgAAAAAAAPAQSVUoJf17h72NGzfqjz/+0I0bNxLdkc9isWjUqFEPXCAAAAAAAACynlSFUgcPHlSHDh106dKlRGFUAkIpAAAAAAAAJCfFd9+7U//+/XX79m2tXr1aoaGhslqtiR7x8fFpXSsAAAAAAACyiFSNlPr55581ceJEtWnTJq3rAQAAAAAAwEMgVSOlihQpkuxlewAAAAAAAMC9pCqUGj58uD755BOFh4endT0AAAAAAAB4CKTq8r1//vlHuXPnVqlSpdS5c2cVLVpUrq6udn0sFouGDBmSJkUCAAAAAAAga0lVKPXaa6/Z/j1z5swk+xBKAQAAAAAAIDmpCqXOnj2b1nUAAAAAAADgIZKqUKp48eJpXQcAAAAAAAAeIqma6BwAAAAAAAB4EKkaKRUQECCLxXLXPhaLRWfOnElVUQAAAAAAAMjaUhVKNWjQIFEoFR8fr/Pnz2v37t0qX768qlSpkiYFAgAAAAAAIOtJVSi1ePHiZNuOHj2qZs2aqWvXrqmtCQAAAAAAAFlcms8pValSJb344osaPnx4Wm8aAAAAAAAAWUS6THTu5+en48ePp8emAQAAAAAAkAWkeSj1999/a8GCBSpSpEhabxoAAAAAAABZRKrmlHryySeTXB4WFqbffvtNMTEx+uyzzx6oMAAAAAAAAGRdqQqlrFZrorvvWSwWBQQEqEmTJurVq5fKlCmTJgUCAAAAAAAg60lVKLV9+/Z79jHGJAquAAAAAAAAACkd5pSKiYnRvHnzFBgYmNabBgAAAAAAQBZxXyOlYmJitHbtWp05c0Z58+ZV69at5e/vL0m6deuWZs6cqWnTpunq1asqWbJkuhQMAAAAAACAzC/FodSVK1fUsGFDnTlzRsYYSZKHh4fWrl2r7Nmzq0uXLrp8+bJq1qypGTNmqH379ulWNAAAAAAAADK3FF++9+abb+rs2bMaNmyY1q9frxkzZih37tzq27evWrduraJFi2rbtm3at2+fOnTokG7zSV2+fFndunVTvnz55OHhoQoVKujgwYO2dmOMRo8erUKFCsnDw0NNmjTRqVOn0qUWAAAAAAAApE6KR0pt2rRJPXv21KRJk2zLChYsqGeeeUatWrXSmjVr5OKS5lNU2blx44bq1q2rRo0a6bvvvlP+/Pl16tQp5c2b19ZnypQpmj59uj799FMFBARo1KhRatasmY4fP64cOXKka30AAAAAAABImRSHUiEhIapdu7bdsoTnvXr1SvdASpImT56sokWLatGiRbZlAQEBtn8bYzRt2jS99dZbateunSRpyZIl8vPz0+rVq9W5c+d0rxEAAAAAAAD3luIkKT4+PtFIo4TnXl5eaVtVMtauXavq1avrmWeeUYECBVSlShV98skntvazZ8/q6tWratKkiW2Zl5eXatWqpb179ya73ejoaIWHh9s9AAAAAAAAkH7u6+57586d0+HDh23Pb968KUk6deqUvL29E/WvWrXqg1X3H3/88YfmzJmjoUOH6o033tCPP/6oQYMGKXv27AoODtbVq1clSX5+fnbr+fn52dqSMmnSJI0bNy5NawUAAAAAAEDy7iuUGjVqlEaNGpVoef/+/e2eG2NksVgUHx//YNX9h9VqVfXq1fXOO+9IkqpUqaJjx47p448/VnBwcKq3O3LkSA0dOtT2PDw8XEWLFn3gegEAAAAAAJC0FIdSd87j5CyFChVSuXLl7JaVLVtWq1atkvTvxOvSv/NfFSpUyNYnJCRElStXTna77u7ucnd3T/uCAQAAAAAAkKQUh1IPMhIprdStW1cnT560W/b777+rePHikv6d9LxgwYLasmWLLYQKDw/X/v371a9fP0eXCwAAAAAAgGTc1+V7zjZkyBA9/vjjeuedd9SpUycdOHBA8+bN07x58yRJFotFgwcP1oQJE1S6dGkFBARo1KhR8vf3V1BQkHOLBwAAAAAAgE2mCqVq1Kihr7/+WiNHjtT48eMVEBCgadOmqWvXrrY+w4YNU2RkpPr27auwsDDVq1dPGzZsSHTnQAAAAAAAADhPpgqlJKl169Zq3bp1su0Wi0Xjx4/X+PHjHVgVAAAAAAAA7oeLswsAAAAAAADAw4dQCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIfL1KHUu+++K4vFosGDB9uWRUVFacCAAcqXL59y586tDh06KCQkxHlFAgAAAAAAIJFMG0r9+OOPmjt3ripWrGi3fMiQIVq3bp1WrlypHTt26MqVK2rfvr2TqgQAAAAAAEBSMmUoFRERoa5du+qTTz5R3rx5bctv3rypBQsWaOrUqXryySdVrVo1LVq0SHv27NG+ffucWDEAAAAAAADulClDqQEDBqhVq1Zq0qSJ3fJDhw4pNjbWbnmZMmVUrFgx7d27N9ntRUdHKzw83O4BAAAAAACA9OPm7ALu14oVK3T48GH9+OOPidquXr2q7Nmzy9vb2265n5+frl69muw2J02apHHjxqV1qQAAAAAAAEhGphopdfHiRb3yyitaunSpcuTIkWbbHTlypG7evGl7XLx4Mc22DQAAAAAAgMQyVSh16NAhXbt2TVWrVpWbm5vc3Ny0Y8cOTZ8+XW5ubvLz81NMTIzCwsLs1gsJCVHBggWT3a67u7s8PT3tHgAAAAAAAEg/meryvcaNG+uXX36xW9azZ0+VKVNGw4cPV9GiRZUtWzZt2bJFHTp0kCSdPHlSFy5cUJ06dZxRMgAAAAAAAJKQqUKpPHnyqHz58nbLcuXKpXz58tmW9+7dW0OHDpWPj488PT318ssvq06dOqpdu7YzSgYAAAAAAEASMlUolRIffvihXFxc1KFDB0VHR6tZs2aaPXu2s8sCAAAAAADAHTJ9KLV9+3a75zly5NCsWbM0a9Ys5xQEAAAAAACAe8pUE50DAAAAAAAgayCUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEyXSg1adIk1ahRQ3ny5FGBAgUUFBSkkydP2vWJiorSgAEDlC9fPuXOnVsdOnRQSEiIkyoGAAAAAADAf2W6UGrHjh0aMGCA9u3bp02bNik2NlZNmzZVZGSkrc+QIUO0bt06rVy5Ujt27NCVK1fUvn17J1YNAAAAAACAO7k5u4D7tWHDBrvnixcvVoECBXTo0CHVr19fN2/e1IIFC7Rs2TI9+eSTkqRFixapbNmy2rdvn2rXru2MsgEAAAAAAHCHTDdS6r9u3rwpSfLx8ZEkHTp0SLGxsWrSpImtT5kyZVSsWDHt3bvXKTUCAAAAAADAXqYbKXUnq9WqwYMHq27duipfvrwk6erVq8qePbu8vb3t+vr5+enq1atJbic6OlrR0dG25+Hh4elWMwAAAAAAADL5SKkBAwbo2LFjWrFixQNtZ9KkSfLy8rI9ihYtmkYVAgAAAAAAICmZNpQaOHCg1q9fr23btqlIkSK25QULFlRMTIzCwsLs+oeEhKhgwYJJbmvkyJG6efOm7XHx4sX0LB0AAAAAAOChl+lCKWOMBg4cqK+//lpbt25VQECAXXu1atWULVs2bdmyxbbs5MmTunDhgurUqZPkNt3d3eXp6Wn3AAAAAAAAQPrJdHNKDRgwQMuWLdOaNWuUJ08e2zxRXl5e8vDwkJeXl3r37q2hQ4fKx8dHnp6eevnll1WnTh3uvAcAAAAAAJBBZLpQas6cOZKkhg0b2i1ftGiRevToIUn68MMP5eLiog4dOig6OlrNmjXT7NmzHVwpAAAAAAAAkpPpQiljzD375MiRQ7NmzdKsWbMcUBEAAAAAAADuV6abUwoAAAAAAACZH6EUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIfLsqHUrFmzVKJECeXIkUO1atXSgQMHnF0SAAAAAAAA/r8sGUp98cUXGjp0qMaMGaPDhw+rUqVKatasma5du+bs0gAAAAAAAKAsGkpNnTpVffr0Uc+ePVWuXDl9/PHHypkzpxYuXOjs0gAAAAAAACDJzdkFpLWYmBgdOnRII0eOtC1zcXFRkyZNtHfv3iTXiY6OVnR0tO35zZs3JUnh4eHpW6wDREX84+wSsozw8Oxpuj2OTdrh2GRcHJuMi2OTcXFsMi6OTcbFscm4ODYZF8cm40rrY+MMCXmKMeau/SzmXj0ymStXrqhw4cLas2eP6tSpY1s+bNgw7dixQ/v370+0ztixYzVu3DhHlgkAAAAAAJClXbx4UUWKFEm2PcuNlEqNkSNHaujQobbnVqtVoaGhypcvnywWixMry/rCw8NVtGhRXbx4UZ6ens4uB3fg2GRcHJuMi2OTcXFsMi6OTcbFscm4ODYZF8cm4+LYOJYxRv/884/8/f3v2i/LhVK+vr5ydXVVSEiI3fKQkBAVLFgwyXXc3d3l7u5ut8zb2zu9SkQSPD09OTFkUBybjItjk3FxbDIujk3GxbHJuDg2GRfHJuPi2GRcHBvH8fLyumefLDfRefbs2VWtWjVt2bLFtsxqtWrLli12l/MBAAAAAADAebLcSClJGjp0qIKDg1W9enXVrFlT06ZNU2RkpHr27Ons0gAAAAAAAKAsGko9++yz+uuvvzR69GhdvXpVlStX1oYNG+Tn5+fs0vAf7u7uGjNmTKLLJ+F8HJuMi2OTcXFsMi6OTcbFscm4ODYZF8cm4+LYZFwcm4wpy919DwAAAAAAABlflptTCgAAAAAAABkfoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIeUtzjIOPi2ADISjinAffHarU6uwQkgXNZxsb3JvMilEKa4mSQcUVGRmrBggXauXOnJMlisTi5IiS4deuWvvrqK23fvl3S/x0b/vOTMXFcMgaOQ8Z169YtzZ07V3/++afi4uL4eZOBDBo0SHPnzrX9vEHGERMTo2PHjkmSXFz+/RWN81zGknAu4/edjCM2NlanTp2S9H/fG45P5uPm7AKQdcTGxqply5YqX768HnnkEfXv31+urq7OLgv/3++//67PPvtM8fHxioqK0vDhw/X444/L39/f2aU99Hbs2KFPP/1UR48eVdWqVRUUFKRnn31W7u7uio+P53vkRDExMXrmmWf03HPPqUiRIqpXrx6/YGcAUVFRmjhxosLCwjR06FB5e3srb968zi4L/9+xY8c0ffp0rV+/XpGRkXr//fdVqlQpeXp6Oru0h56Xl5dOnz6tIUOGKDg4WE8++aSeeeYZZ5f10DPG6I033tC+fftkjNErr7yi2rVrq1ixYrJarbZftuEc/fv315kzZ1SuXDkNGjRIAQEBzi4J+vd78+qrr+rgwYPy8fHRSy+9pDp16ihfvnx8bzIZiyGCRxpauXKlwsLC9NZbb6latWpq1KiRXnnlFWXPnt3ZpT3UjDGyWCyKiYlRXFycBg4cqD/++EM5cuTQe++9pwoVKji7xIdOwjFJEB8fr5CQEI0YMULnz5+Xm5ub1qxZo9y5c/OD1YmioqI0efJknT59Wj/88IMaN26sAQMGqHLlyoRTTnTz5k0tW7ZM27dv12+//abHHntMwcHBatasmbNLw/8XExOjI0eOaNq0adq6dauef/55de/enZ83TvLfnyN79uzRhx9+qAsXLujxxx/Xhx9+6MTqIEl///233N3dNXz4cJ0+fVp//vmnpk+froYNGzq7tIdeSEiINm7cqA0bNui7775Tv3791KZNG9WpU8fZpT30Ll++LDc3Nw0dOlQhISH6559/tGDBApUvX97ZpeE+EEohTfz3Pzt//fWXJk2apP379ytfvnz68ssvlSNHDidWCMk+CFmzZo0WLVqkn3/+WatWrVKVKlWcXN3D487jsHnzZjVp0sTWdvv2bW3fvl1jxozR33//rf3798vX15dgysnCwsL0+++/q0ePHipYsKDatm2rQYMGcUyc4L/fhdWrV+v777/XggUL9N5772nQoEFOrA5JmTVrlpYvXy4/Pz+NGDFCNWrUcHZJkPTnn39q5cqV+uijj1SvXj19+umnzi7poXbnue3gwYOaP3++5s+frwULFig4ONjJ1T28/jtiff78+friiy8UGxurV155RU8//bQTq3t4Jfxf+s7vza5duzRjxgx98803+uKLL9S6detEfwRGxkQohVS780t+/fp1+fr6Svr3Mr5s2bIpKipKa9eu1XvvvaecOXNq48aNBFMOcrcT8J0n78OHD+udd97RqVOntGrVKpUqVcqRZT6U7jw2EyZM0LvvvqtvvvlGDRo0UFxcnNzc3GSM0W+//aYXXnhBN2/e1MGDB5UjRw5+sDrAne/x+fPnVbx4cbvl169f1xtvvKFjx46pWbNmGjVqFMGUA9x5XCIjI5UrVy67XxRu3rypRYsW6bXXXtO4ceP05ptvOrPch8qdx+bChQu6deuWAgMDZbFYbOc0SVq1apXmzJmjwoULa/z48bbvFtLfoUOHdP78ebm4uOjxxx9XgQIFbG3//POPVq9erQkTJqhLly4aM2aMEyt9eNz5vYmJiUnyioKYmBhNmjRJb7/9tr788ku1b9+eP1A50Z0/c3744Qd98sknOnLkiCZOnKjWrVs7ubqHw53fmzt/vtwpMjJSI0aM0Pz587Vx40bVr1+f701mYIAHNG7cONO2bVvz448/2pbFxcUZY4yJjY013333nalZs6bp16+fbTnSj9Vqtf170aJFdsclqT67du0yzZs3N8OGDTO3bt1ySI0Pqzvf90GDBhkPDw+TK1cuM3To0CT7HDx40NSuXdsMHjyY744D3PnejxkzxtSvX9+cOHHCtizhGISFhZlXX33V1KtXz6xcudLhdT5s7jwuvXr1Mi1btjTx8fGJ2owxZv78+cZisZhly5Y5tMaH1Z3v/9tvv20qV65sChQoYB599FFz9uxZY4yxO3d9/vnnply5cmbJkiWJ1kf6WLhwoSlcuLCpWbOmsVgspnfv3om+P2FhYWbs2LGmSZMm5uDBg84s96HzwQcfmM6dO5tGjRqZCRMm2L43CcfIGGOGDRtmvL29zc8//+ykKh9OW7duNfPnzzdjxowxv/76a6L/Ix8+fNh06dLFBAUFmd9//91JVT487vx5MX36dNOjRw8TFBRkpk2bZkJDQ40x9t+bXr16mUKFCpmLFy86vFbcP0IpPJA///zTFClSxFSsWNG88MIL5tChQ7a22NhYY4wxMTEx5sMPPzQNGjQwP/zwgzGG/4g6wjvvvGMsFospUaKEOXLkSKL2O4/B5MmTTYUKFcz169cTtSHtDR482Hh7e5tz586ZpUuXmoIFCyYZHsbExJj33nvPNGnSxISEhBhjODaOMHLkSJMvXz7zzTffmL///tuuLeH9Dw0NNS1atDCtWrVyRokPjTs/70OGDDHe3t5Jflfu7P/mm2+aMmXK8AucA40YMcIULFjQrFy50uzatcvUqFHDPPPMM7b2hP8PGGPMq6++avz8/ExYWJgzSn2oLF261Hh6epovv/zSREdHm++++85YLBZz7ty5RH1Pnz5tKlSoYCZOnOiESh9Ob731lvHx8TETJkwwHTt2NI8//rgpXLiw7f/SCYHupUuXTMeOHc2LL75ooqKinFnyQ2P+/Pkmb968plWrVqZ69erG3d3dDBs2zJw8edKu33fffWfKly9vFi5caIyxD0WQPt544w3j4+NjRo4caZo1a2aqVatmAgMDbee1hO/NmTNnTIsWLczQoUPtfgYhYyKUwgOJi4szTZs2Nb169TLVq1c3zz//vNm/f3+ifv/884+pU6eO6du3rxOqfPjs3LnTVKtWzcyYMcM0bdrUFC1a1Pz000+J+t35C1/t2rXNK6+84rgiH1KvvfaayZMnjzl69KgxxpgDBw6Y4sWLm9mzZxtj/u+H6Z1/wX7kkUfM2LFjnVPwQ+bnn3825cuXN5s3bzbGGHPy5Enzww8/mPXr15t//vnHru/58+eNp6en+eijj5xR6kNlyJAhxtfX1/bLWkhIiDl79qz5888/bccl4Ttz9OhR06pVK9toHH5JSF+LFy82gYGBZs+ePbZlEyZMMOPGjTNHjhwxf//9t4mOjra1xcfHmxYtWph58+Y5o9yHxsmTJ039+vXNnDlzbMvCw8NNkyZNzLx588wnn3xidu3aZbfOV199ZUqVKmUbrYP0ExISYqpWrWpWrFhhW/bTTz+Zjh07mly5ctlGrCWc1+bPn28qVapkbty44YxyHyr79+83RYsWNevXr7f9/Bg+fLixWCymS5cutv+/JRg3bpwpXLiwCQ8Pd0a5D5WLFy+axx57zHz11Ve2ZXv27DGNGzc2BQoUSHTu+vDDD02dOnUIczMBLq5EqlmtVrm6usrHx0fBwcEaP368jh07pkWLFmnNmjVq3769pH+vwc6dO7emT5+uvXv36rfffnNy5Vmf1WpVixYt1LZtW61fv15lypRR27ZtdeTIEbt+FotF5v9PK/fSSy/p9u3bTqj24REWFqbLly9r9+7dqlixoiSpRo0aatOmjd555x2FhYXZ5itImLzRy8tLb7/9ti5evKjo6Ghnlv9QCAkJUWxsrBo3bqxvv/1WLVq0UP/+/dWmTRs9/fTT+t///mfrW6xYMb3zzjv65ZdfZP79I48TK8+6du7cqWnTpmnUqFGqWrWq1q1bp6CgINWrV09Vq1ZVz549dfjwYds8ExUrVlTlypX13nvvMY+EA1itVvXu3VvVqlWzLfvss880f/58tW3bVhUqVNDcuXMVHR0tq9Uqi8WiRx55RPv373di1Vlfrly51KNHD7Vt29a2rGvXrjp06JDWrl2rjz76SK+++qrWrl0r6d+5WqpVq6bAwEB+1jjArVu3dPr0aXl7e9uWVa5cWdOmTVPLli3VqlUr/fHHH7bzWu/evZUrVy59/PHHTqr44XH16lUVLVpU9erVU1RUlCQpKChIAQEBOnHihBYtWqRbt24pPj5ekvT666+rQoUK2rdvnzPLfihERkbq4sWLKlSokG1ZnTp1NG/ePFWsWFFNmjRRaGiorW3w4MGKiIjQggULnFEu7gP/U0OqJfxH/7HHHtOmTZvUokULjR8/Xrt371bXrl117do1SZKrq6usVqsKFSqkEiVKKCYmxpllPxTq16+vfv36qVixYsqWLZu++uorWzD1008/2frduHFDt27dkiTVq1dPOXPmJJhKJ8YYeXt7a8mSJapQoYKMMbJarZKk559/Xrly5dKqVaskybY84TsWGBioggUL8su1A3h4eMjHx0cnT57U66+/rtdee03ffvutzpw5I4vFojlz5ujMmTO2/iVLltT27dsVEhLCJPTpJDAwUC+99JJGjx6t0aNHa/DgwWratKmWLFmisWPHKjIyUkOGDNGFCxds6wwdOlSlS5fWyZMnnVj5w6Fnz57q0aOHbaLmli1bKl++fFq9erVOnTqlLl266O2331ZoaKhcXFxksVg0YsQIFSpUyPYLH9Je4cKF1alTJ/n7+0uSPvnkEx09elQ//PCD1q1bp02bNskYo+3bt0v69w8hxYoVU1BQkP766y8nVv5wKFGihGrWrKnly5crMjLStrxw4cIaPXq0ypQpozlz5shqtSo2NlaS1KNHD7tfxpE+/vzzTx07dkxeXl7KmTOnJOnYsWOqXr262rRpo48//lhnz561/RHRw8ND+fLl0/Hjx51ZdpaW8Ee/UqVKqWzZslq2bJni4uJs7Y888ogmTZokHx8fzZgxQ5Js35sXXnhBefPmdXzRuD/OG6SFzCK5OWwSLjOaNWuWadSokTHGmBs3bhhPT0/j6+trunfvnuiSsY0bN5rLly+na70Pk/8em6Qmw07oExERYZ566ilTtGhR8/PPP5sTJ06Yxo0bmzVr1tj63r59O30Lfoj899jcbS6o+Ph407hxY9v3KCn/vXQM6ePcuXMmV65c5sUXXzTt2rWzzeVljDFXr141Pj4+ZsaMGXbrLF26lEsq0sGd35mwsDDTv39/Y7FYzDvvvGPXb82aNaZo0aK2Sy6NMSYqKsp88skn5ubNmw6rN6tL6hz230sjr1+/bv73v//Zna8uX75scuXKZbZs2WJbx2q1moiIiPQt+CGUcDySumT15s2btsmAE3Ts2NEEBwcbY5ivML38932989hMnjzZVKtWzSxcuDDR5UX9+vUz1apVs5sLJyQkxFy9ejV9C4YJCwszjz32mKlWrZr58ssvzcSJE43FYjFff/21McaYWrVqmfHjxxtj/m++vGvXriW6HBapl9z5KDY21rz11lumVq1aZsWKFYnOdd26dUv0f+lz587xvckE+LM77srccevN33//XXv37tWVK1cUFRVl+wvBk08+qeLFi+vChQsqXbq0nn32WX344Yc6ceKExowZo3PnztkS7qZNm9r+aocHc+exmTt3rvr376/GjRvryy+/tBu6mtAnV65cWr16tR577DE1b95cDRo0kNVqtRvanyNHDsfuRBZ157H5/vvvdfr06WRH0SRcXvT222/rl19+0YoVK5Lslzt37nSr92Fj/nOZXcLINKvVquLFi2vy5MlavHixdu3apYiICEn/Xobs5+en2rVr20Z3JGynY8eOdpdgIHX+e1wsFovt8ggvLy+NHTtWS5cuVVBQkKT/O26NGjXS7du3FRISYtuOu7u7evbsKU9PT8ftQBZ25zntxx9/tF3e9d/Rm/ny5VOHDh2UO3du2/E8efKkypUrpyJFitjWsVgsypUrlwP3IOv7/vvvtWTJ/2PvvsOiSLY+AP+GjIiRqCAKBoISBAUFcwYDmMWcc06AophQxACoa3ZFzBGzYlbMOSfMAkaiZGbO9wff9M4I7t17l2FUzvs8+yxT3dMWXVR19enqqk1IT0+HiopKvvpUqlQpudECiYmJSEhIgJ2dHQDwSE8FkK03MTExAPL+/qXt2sSJE1GlShWEhoZi27ZtwvUGyHu1v2zZsnLXGwMDAxgaGhbxb/H7u3fvHqKjo3H16lWkpqaidOnS2LRpE3R1dTFt2jRERERg586d8PT0REZGBnJycoRyVVNTAwDo6+vDzc1Nmb/Gb0O23mzbtg2zZs3CggULEB0dDTU1NUyePBllypTBkiVLsGfPHrk3cOrWrQttbW25UbhmZmZcb34FyoiEsV+DbJTa39+fatasSWXKlCErKysKDg4WlkZ99eoVlShRgkQiEfXp00eY0HTDhg00Y8YMpeS9OJk6dSqZmJjQmDFjyMPDg0qXLi0sh17Q09IbN26QSCSi3r17C2k8EbBiBAQEkEgkomHDhlFMTMzf7vvx40dq0KAB9evXj8tDgWTbtYiIiAKXEY6PjydfX19SVVWlCRMmCKOgPn/+TFZWVsIqO6zwyJbLypUracWKFcJn2RGg3y/JTZQ3ObCdnZ3cRNtMMaZPn04ikYhmzZpV4Mjc73348IHs7e1p8ODBRZC74mvXrl0kEomoWrVqtGXLFqGeFDTaIDc3l5KTk8nDw4OcnZ15VaoiMHv2bLKwsKCdO3cKadnZ2USUN/KjY8eO5OTkRCNGjKAbN27Q5cuXycrKioYNG6asLBcb69atIz09PbKysiKRSEQeHh60ZcsWYXtsbKzcKrwJCQnk6upK4eHhRMQjDBVp8uTJZGhoSE2aNCEnJydSVVUV7iuTkpKoRYsW5OLiQlOnTqXnz5/TzZs3ydLSkhdt+kVxUIr9R7NnzyZjY2M6duwYPXnyhMaOHUvW1tZyr+HNmzeP/Pz8KC0trcAGmhttxVi/fj2ZmZnJLZE+YsQIsrKyKvCG4e3bt2RsbEytW7cW0jgAohg7d+4kKysr6t69O9WpU4dGjhxJz58//9vvLFq0iLy9vYsoh8Xb3LlzSSQSUa1atYSgk2ydiYuLE4bsu7q6kru7O9nY2FC7du2UlOPiYeHChSQSicjBwYFWrVolpBfUnmVnZ9Pz58/J3t6e600R2L17N1WvXp0GDBhAmpqaNGPGjB8Gpr5+/UorV66k2rVrU9u2bYV07gsUvmfPnpGLiwv5+/tTx44dycbGhiIiIgoMTOXk5NCiRYuoWbNm5OTkJARG/kmAkf1v1q5dS/r6+uTs7ExNmjSRC0xJH+Lm5ubSrFmzqGHDhqSmpka1atWizp07C/txvVGMa9euUbly5Wjz5s305csXunz5MnXr1o3s7Oxo3rx5cvtmZGRQTEwMtWrVihwcHLjOKNilS5fI2NhYeNiUkpJCa9euJVVVVWEl9+TkZJo0aRI5OjqSpqYmWVtbU8eOHYVjcL35tXBQiv2tS5cukZOTk/AetZSpqancDUNycrJcA80NgeIlJSXRkCFDaO7cuZSTkyN0Lo8dO0Y2NjYFPv28fv06zZo1S/jMASnFiYiIoIEDB1Jqair98ccf5ODg8MPAFAdyi1ZUVBTZ29vTnDlzyMnJiWxsbAoMTBHlLQ09efJkmjRpEi1dulRI57pT+E6fPk0ODg40c+ZMGjBgANWrV09uOXvZc56YmEghISFkb29PHTp0ENK53ihGeno6LVu2jCZMmEDJycm0efNmUlVVJX9//wJvzuLi4sjHx4cmTJggpHGdUYxXr17R9OnT6f79+0SUN0/U94EpWdHR0TRr1iyhj8AjpRQnMTGROnXqRNOmTaMzZ85Q165dqUGDBgUGpojyyuL27dv04sULIY3rjeJs376datWqJTefV0xMDE2aNIlsbGzkRuzevHmTevbsSY0aNeJgbhE4d+4cWVhYUHx8PBH9dW0/cOAAqaqqkp+fHxHl1Z+0tDS6dOkSPXr0SPg+15tfDwel2N86fvw49enTh969e0dEfzXADRs2pCVLluTbn28IitaaNWvozJkzcmk3b94kIyMj+vLli9Ao/5MJalnhkJ7r1NRUevnypZC+bNmyAgNT0g6pbBlxPVKs3bt306RJk+j169f07NkzcnBwkAtMSW/SflR/uO4oxps3b2j48OEUGxtLr1+/LjAwJVsWO3bs+GHQihW+58+f07Nnz4TP4eHhQmBKNrAhbdNkb/S4bAqXbD3Izc2lT58+yW2XBqY2bdokLGCSlJQk3EzLfpcp1u3bt4XR7NevX6cuXbrkC0z9qH5wX0Cxjhw5QqampnTnzh259NevX9OwYcOocePGcoGOGzduCGXFwVzFunLlColEIoqOjiaivLZKeu43btxIIpGITpw4UeB3ud78mjgoxQQ/ClzINtbSBsHb25uWL18upKenp+db1YUVnv+mgb116xaVK1eO4uLiiCjvSd3ChQuFz6xw/aeyke30SwNTo0aNopcvX9KbN2+oTZs2XDZFTCwWywUMHz58KASmZNux1NRUuafYrPB9X39kV2R79uyZEJj6448/hPSCVtHhoEfh+SfXG+k+mzZtEgJTRESPHz+mCRMmyAXe+Qah8KWlpRFR/ocasu2VNDC1ZcsWevXqFXl4eAgrhnGZFL5/ek5v3LiRb8TU48eP872RwBTvwYMHZG5uTtOmTcu3+uHDhw+pbNmywtxRsvh6U3j+rt706NGD6tSpIwQGpYGp7Oxsat68OU2cOJGIuDx+FyKi75bnYMUSyax08Pz5c2hqaiI3Nxfm5uYF7uPu7o7atWtj7ty5SEhIQIcOHdCzZ08MGzZMKfn/ncme9w0bNuD27dvQ1NREzZo10a9fv3z7PX78GO3atUNMTAySk5Ph4OCA2rVrY/fu3Ur6DX5fsmUTHh6Ou3fvQkNDAy4uLsIKYQCQm5srrNCyfPlyhIeHo3r16jh79iysrKxw8uRJZWT/tydbPsBfKx0W9Pnx48fo2bMnsrOzcfnyZXz9+hXjxo2Dr68vnJ2dizzvvzPZcklLS4Oamho0NTXltkskEqiqqiImJgaBgYF48uQJ+vfvj+bNm8PR0RGrV69Gly5dlPUr/LZky2br1q3C6rkNGzZEgwYNAMi3ZwAQERGBQYMGYeDAgYiMjISTkxMOHDiglPwXB9u3b8eOHTsQHx+PWrVqYfDgwahbt66wXbZ8unbtiocPHyI1NRU6Ojq4d+8e1NXVlZX135ZsvTl79iyys7ORnZ2Ntm3bCvuIxWJh1eobN24gODgYnz59QocOHbBo0SJUq1YNZ86cUUr+i4vY2Fh8+/YN+vr6KFOmDFRUVLBy5UqMHDkSK1aswODBg+XatmbNmqFOnTpYsGCBEnP9+5KtNydPnkRmZiays7Ph5eUFkUiEc+fOYebMmShTpgzmz58PKysr4budOnWCgYEBVq5cqazss8KmjEgY+3n5+vqStbU1GRgYUNWqVWnBggXC0G+ivyLarVu3psDAQPr27RtZWVlRkyZNlJXlYsPHx4f09PSoT58+1KBBAzIwMKBOnTpRamqq3H63b9+mGjVq0NOnT8nGxoZatWolbOOno4oxZcoU0tfXJy8vL2rUqBGpqqrS8OHDhXfhieRHTElXsOrSpYuQxk96FCckJIQGDRpETZo0ofDwcHr8+LGwTfa8P378mJycnKhatWpkampKDRs2VEZ2i43AwEBq1KgR1alThzp37kwvX74UXi+SSCRCexUTE0ODBw8me3t70tXVpebNmysz28XClClTqFy5ctShQweqWLEi2dnZ0cCBA4Xt37+6smDBAhKJRNS1a1chja83hW/btm2kqalJ8+bNo+HDh1O7du1IXV2dNm3aJLef9Hrz6dMnUldXp3r16smt9sYUY+LEiWRiYkJmZmZUtmxZcnV1pYsXLwrnXvZ6c/v2bWrdujWJRCK5Sc2ZYqxfv55sbGyofPny5OTkRH369BHubwICAkhFRYXmz59P79+/J6K8kdL29vYFTlXCCtfEiRPJyMiIrKysSFtbm9zc3Ojw4cNERLRnzx5q2LAhubq60tWrVykjI4Pev39P1tbWtGDBAiXnnBUmDkoxQVhYGJUvX55OnjxJkZGRtHjxYtLU1KSePXvS27dv5fYdMmQITZ8+nezs7KhFixZCOt9YK8bDhw+pUqVKdPz4cSLKe8Xl5MmTVLFiRWratCklJSUJ+969e5dKlChBZcuW5bIpArdv3yYTExM6e/YsEeXNo3Lo0CHS0dGhzp07y61SKZFI6MmTJ2RqasoBqSLi6+tL5cqVowkTJpCnpydZWFhQy5YthbpEJH/+Dxw4QCKRiHr16iWk8c114ZszZw6VL1+eQkNDad68eeTg4EAVKlSgTZs2UUpKChHJn/ejR4+SSCSSW2WP641i3LhxgypVqiS0aampqRQWFkZWVlbk7u4u7CcNfDx58oSMjIyoU6dOwjYum8KXk5NDHTp0oClTpghpX79+penTp5OamhqtXbuWiP4691+/fiUHBweytLTkSc2LwI4dO8jQ0JBu3bpFr169omfPnpGjoyNZWVnRrl278r1q+e7dOzIwMKBu3boJx+B6oxhHjx4lbW1t2rBhA509e5YWLFhAtra2ZGlpSV++fCEioiVLllCpUqWocePG1LZtW2rQoAHVrFmT64yC7d27l4yNjenmzZv08eNHevfuHTVq1IgcHR1p3bp1RER08uRJ6ty5M4lEIrK2tiYzMzO5VV3Z74GDUkwwYMAAGjFihFxadHQ06ejokLe3tzAiRyKRUMeOHUkkElH79u2Fffliqjg3btwgY2PjfMHBBw8ekImJidzqU7dv3yaRSET9+vUT0rhsFOfGjRtkZmYmzFEkPdc3btwgHR0dGjx4sNz+mzZtogYNGgifuWwU59WrV2Rvb0/Hjh0T0g4dOkRdunQhW1tbuXQiordv31KFChXIw8NDSOPyKVwSiYQSExPJxcWF1qxZI7fN29ubKleuTOHh4XJz47x8+ZLMzMyoXbt2QhqXi+IcO3aMDAwM6OPHj0JaWloa7dq1iywtLalPnz5Cek5ODq1evZqD7EUgIyOD7O3thXmhZM2aNYtUVFTo1KlTQlpaWhpNmjRJqEt8c61YISEh5Obmlm9uojZt2pC1tbUQ5BWLxZSRkUFNmzalZs2aCftxvVGc4OBg8vLyEj6LxWK6efMmOTk5UdWqVYW5DE+dOkVBQUE0YMAACggIEOoMLwigOMuXL6fatWvLvZWTmppKPXr0IEdHR4qMjCSivPnyTp48Sdu3b5ebf43rze+Dg1KMJBIJicViat68eb7OJhHRpUuXSEtLi2bNmiVsmz59utzNNjcKivX161cqU6aM3JL00qdt586dI319fVq2bJmwbffu3cLPXDaK9ezZM1JTU6MdO3YQUV65SOvO8ePHSVVVlbZu3Vrgd7lsFCsmJoZKlixJ+/fvl0u/dOkSde3alZo2bUr37t0T0g8ePMhL2BeB5ORksra2FkZ2yHZGe/XqRRUqVJBb8ejDhw80fvx44TOXi2JIrylPnz4lc3Nz2r59u9z29PR0WrVqFdnZ2dGhQ4eEdNnFAbhsFGv06NFkbW0tjMCVlll6ejr17duX6tevL6wiKosDUoo3e/ZssrS0FD7LtmvOzs5Ut25duf1lF9vgeqNYEyZMIHNz83zp9+7dIwcHB2rZsmW+lSmluO4ohrTtWrZsGVlaWgoDH6RB3W/fvlGLFi3IxcVFri7J4nrze1H5z7NOsd8V/f8c9yKRCCoqKvD29sbevXtx6tQpAICamhpyc3NRr149hISEYPXq1Xj8+DEAYM6cOVizZg2A/JMHs/8d/WDdgRIlSmDgwIHYs2cPjhw5AgDC5IAuLi5o0KABbt++LXy/U6dOALhsCtOPyqZatWoYOXIk5s6di+joaIhEIqiqqkIsFqNly5bw9PTE6dOnAeRNQCt7PC4bxdLV1YWDgwMePnyIrKwsIb1evXoYMGAAPn78iHPnzgnpbdu2xeLFiwFw3VGkUqVKwdjYGNu2bQMAaGlpCeUTEREBU1NTTJgwAUBePTE0NMSSJUsAcLkUpu/bNOk1pXz58qhatSq2bduGp0+fCtu1tbXRp08f5Obm4uzZs0J62bJlheNx2SiWh4cHypQpg0WLFuHLly8QiUSQSCTQ1tZGixYt8Pr1a3z79i3f92Qnb2aK0bdvX8THx8PHxwdAXruWmZkJANi7dy9iYmKwZcsWAHntWJUqVYSfud4ULmnbJpFIAACenp7Q0tLC+vXr5do9KysrTJkyBR8/fsT9+/flviPFdUcxpNcbLy8vvHv3DrNnzwYAaGpqIisrCzo6Oti6dSsePHgg1Jvvcb35vXBpFjOyjXFubq7cjVqjRo3g7u6OuXPn4sqVKwAgrBRiY2MjrCby/fG4USgcJLMKxfnz57F3717s2rUL2dnZ0NLSQpcuXaCpqYmVK1fi2LFjwvc0NDRQuXJlJCcny600BnCDXVhkyyY6OhpHjhzBnj17hO2dOnVCpUqVMGvWLFy8eFEITAFAmTJlkJ6eDkC+c/N9WbH/3Y8ChgYGBnBxccHChQtx+fJluW2tWrWCs7Mz1q5di9zc3HzH4Lrz7/2oXABg/vz5ePr0KcaMGQMgryOakZEBABg6dChevXqFr1+/cpumILJt2p07d3D8+HHcvXsXycnJKF++PAIDA4WVj54/fy58T1tbGy4uLkKbJovbtMJ19uxZLFiwAP7+/oiMjASQ1261bNkS586dw8KFCxEXFyfUCWtra5QtW7bAsmGFQ7ZN+/DhA96+fSs8bDIxMcHs2bOxdetWBAUFAcgLTBERNDQ0YGBgIAQ8ZNsxbtMKn/TeRlo2VlZWqFGjBrZu3YqoqChhPzU1NTRp0gQvXrzAo0ePAHB5KIJsvYmNjcXz58+FsqlYsSKWL1+O0NBQzJ8/H0Bef4CIUKJECVhaWso90GW/L655xYhsJ3TFihXo3r07mjVrJtwUmJubo3fv3tDQ0ICfnx/OnDkj7G9oaIjy5cvLBbEA7oQWJum59PX1xdChQzFp0iT4+fmhVatWyMrKgrOzM6ZPn460tDQsXLgQq1atQkZGBh49eoSjR4/KLZXKCpe0bPz8/DB48GCMHj0aQ4YMgZeXFwCgQYMGGDp0KDQ0NDBmzBjs378fqampePnyJS5fvoxq1aopM/u/Ndl27dixY1izZg3Cw8OFUZ0LFy5E48aN4e3tjXPnzskF1q2srFClShWoqKhwW1bIZMtl27Zt8Pf3R58+fXDr1i0AQI0aNTBx4kRERUVh7NixAPICHgBQsmRJ4WemGNKymTZtGnr27IlevXqhe/fu8PPzw9evX+Ho6IijR4/i6NGj8PHxwYEDB5CRkYFXr17h3LlzMDU1VfJv8HvbsGEDunXrhujoaERFRWHEiBHYsGEDAGDmzJnw8PDAhQsX0LdvX5w9exYXLlyAn58f9PT0ULVqVSXn/vck26bNnz8fnp6eqF+/Puzs7PD48WOoqKigQ4cO6NWrF1auXInp06fLfS83Nxfq6urK/BWKhb1792LQoEGoV68eJkyYgIcPH0JPTw9LlixBcnIyFi5ciJ07dwr7a2hooHr16ihTpozyMv0bk6038+bNQ/v27eHq6gobGxtcuHABANCuXTvMnj0bAQEB8PPzg1gshlgsRnp6Or5+/cr9geKiaN4SZD+TqVOnUoUKFSggIIAmTZpE+vr6NHToUGH74cOHqXPnzlS2bFmaMGECzZkzh6ytrcnT01OJuS4eFixYQEZGRnT58mV6//49RUVFkZOTE4WHhwv7XLt2jUaNGkWlSpUiIyMjqlKlilzZ8EphihEYGEgGBgZ05coVevHiBZ09e5ZMTEzozz//FPY5f/48DR8+nEQiEZmbm5OZmZncYgBcNorj4+NDlSpVovr161OZMmXI09OT7t69S0R5cxR06NCBypQpQ6GhoXT+/Hl69OgR1ahRg0aPHq3knP/epkyZQlWqVKEOHTqQi4sLaWho0J07d4iI6OPHj7R48WIyNTWl1q1b0+HDh+nw4cNUs2ZNuYUamGLMmzePjI2N6cyZM/T27VtavHgx1a5dm27evCnsc/PmTWrYsCHVqFGDjI2NqXr16nITzrPCd/jwYTIwMBDm9IqPj6cxY8ZQly5dhAmZiYi2bt1Knp6epKamRvb29tSoUSNhXhyea0Vxpk2bRkZGRrR9+3aKjIykdu3akbm5OaWnpxNR3qp6ixYtolKlSpGjoyO1a9eOatSoQW3atFFyzn9/f/75J+no6NDs2bNp0KBB1KpVK+rcubMw792rV6+oRYsW5OjoSJ6enhQSEkKNGjUiW1tbnsxcwfz9/cnY2Jh27dpFFy5cIC8vL7KwsBAWYkhISKC1a9eSlpYW1a5dmxo1akSWlpZcb4oRDkoVM5s3b6aqVavSpUuXhLQ1a9aQo6Oj3Eo7z58/p7CwMLK3t6f27dvT2LFjhW18Y60YDx48oHr16tG2bduEtIyMDHJ1daVx48bJ7Zuenk7v3r2jI0eOUHR0tJDOHVHFuHPnDtWpU0duxY/k5GRydXWVWwCAKK8M7t69S4cOHaITJ07IpTPFWLRoEVWsWJGuXr1KRER3794lExMT+uOPP+T2Gz9+PNWpU4e0tLSoVq1aHMxVsBUrVpCJiQldv35d6PB7enpS+/bthZvnlJQUOn/+PNWrV4/MzMyoZs2a1KtXL+EYXC6KcevWLXJxcREWaJCqUaOGsLqbtMw+ffpEN2/epPDwcDp69KiwL7dphS81NZWGDh1KI0aMkPvbj4iIIBMTE2EyYFlPnz6luLg4oTx4YmbFkQbNz5w5I6Q9fvyYKleuTBcvXhTScnNz6dmzZzRmzBjy8fGh4OBgYRvXG8WIjo4mc3NzuT50eHg4Va5cmV6/fi2kffz4kVavXk3NmjWjNm3aUK9evYTrEQemFCMqKors7OwoKipKSPvy5QuZmJjIXVOIiF6/fk0BAQE0Y8YMCgsLE9K53vz+ePa2YiQ7Oxv3799HgwYN4OTkJKQ7OTlh2rRpcvMQVK1aVXhFSVNTU0jnCRkLV05ODnJyclCiRAno6Oigbt26wmt4RAQtLS24uLjg8+fPAPLKUENDA9ra2jAxMYGJiYlwLC6bwpWTk4PU1FSUK1cO5cqVg6WlpTAxKZA3WXOtWrXw6tUrAH+VjUgkgq2tLWxtbYV9uWwUg4jw+vVrnDlzBjNmzEDdunUhFotha2sLT09PnDt3DsOHD0dubi7U1NSwZMkSvHnzBl++fIGqqirs7e0BcPkowocPH3Do0CGMGzdO7nrj4uKCAwcOCK+x6OrqokGDBrh06RLevXsHNTU1GBsbA+ByKWw5OTnCec/Ozoa9vT0cHR0BAGKxGKqqqrC1tRUmZ5a+cqGvrw99fX3Url1bOBaXTeGKiYlB1apVoaqqCmdnZ5QrV07ulWIrKyuoqqoWOLeKhYWFMIehRCLhiZkLmbRuAMCXL19Qvnx52NnZCdurV68OIsKHDx+ENFVVVVSrVg2hoaFyx+J6oxhisRhPnjxB3bp10axZM+E8d+/eHbNmzcKrV69gZmaG3NxcGBgYYMiQIRgyZIjQNwAg9zP792TrzYcPH6Cnpyd3DSldujQ0NTWRlJQkpEkkEpiZmWHmzJlyx+J6UzxwCf/mMjMzsX37dqGj0qVLFwwcOFDomObm5qJMmTLQ0NCAhoZGvu/Lvv9OPKl5oZJIJPDy8sKBAwcAABUqVICPj4/Q2ZF2SLW0tIR5cDQ0NJCamppvwnmAJ2csTGKxGMOGDcONGzcAAMbGxli6dKlQNvT/kzaqqalBLBYDyCubtLQ0pKWl5Tsel03hysjIQEZGBkQiEdTU1FCxYkXUr18fAOQmmI+LiwMRCWkAYGZmBkdHRyEgxe1a4cnKysKZM2cAAEZGRmjVqpVccBbIm4w5MTERRIScnBwAEOqQqampEJDicilcEokEzZs3F+ZSqVOnDiZMmAALCwsAf7VRhoaGws8qKipIS0vDly9f8h2Py6bwhIaGon///gDy5lXr1KkTOnToAOCva0358uWhpqYmLAYAAAcPHgQAufaNy6VwZWdnY86cOYiLiwMA9OnTB0uWLBFWnJT2xUqXLo0SJUoI38vNzeV+WhFYv349gLw6ULVqVQwYMAD6+vpQUVGBRCJBVlYWMjIyhEC7bNCJiITPsj+zfy83NxeTJk3CkydPAAC9e/fGggULUL58eQB5D0jU1NRgaGgIHR0d4XtisbjA1UO53hQPXMq/uSNHjmDGjBkA8iq1g4MDXF1dhe1qamooXbo0RCIRkpOTAQBfv37FpEmTkJ6eLtcQ8ETAhUtFRQUuLi44evQo0tLSoKGhASMjI2G7tDMqG4RKTEyEubk5Jk2apJQ8FxeqqqrQ0NDAunXrIBaLoaamJlxMgb+WDJbeVAN5ZWNhYZHvySgrfP7+/pg8eTKAvEBGYGAgatasCeCvAEflypVRpkwZiEQiiEQipKam4uTJk/mOxe1a4QkNDcXu3buFz2PHjkWLFi3k9lFXV0dWVhYyMzOhrq6O5ORkHDt2LN8NHJdL4VJRUUG9evWEUbcqKipyCzBIz3dCQoKwT0JCAho0aIBVq1YVfYaLka5du0JLS0tYIVRXV1fYJi2Xb9++IS0tTbiBa9myJQYNGvS3K1yyf+/du3fYtGkT3r17J6TJjvZQV1cX+smyfei2bdvi7t27RZvZYiY+Ph5+fn7CauGNGjUSrjfShxo6OjrQ1dUV+mxEhGHDhiEmJkbuGsPXm8IVFxeHc+fOITU1VUiTHTEtHfCQlZUlXG++fv2KDh064OrVq0WbWfbT4KDUb65Dhw6wsLDApk2bABQcbSYi5ObmQkdHBwkJCWjYsCEuXLgg99SHKUatWrXw+PFjpKSkAPjrhhr46yKprq6OkiVLQiwWo379+qhTpw7CwsKUkt/iQNp56dixI1JTU/H69Wu5dOCvJ9Pq6urQ0NBAVlaWsArPtGnTijzPxU3lypWFGwAAwlNr4K82TiKRCKMKvn79ChcXFxw6dKhoM1rMODs7Y9++fbhz584P98nJyRFeQU5MTETNmjWxcePGAkfqssJVsWJFBAYGIjExEYB8myarZMmSyMzMhKurK/T09IRVxJhiaGpqIicnB8ePHweQ/wZZOuJDXV0dYrEYHTp0QGxsLN6/fw+RSMSBKQWysLBA586dsXbtWrkbbClpWUkfXiUmJqJRo0ZISUlBnTp1ijq7xYZEIoGhoSGaN2+OBw8eAIDcq63SclFRUYGWlpYQBHF3d8fx48dRuXLlIs9zcVKpUiU0bdoUs2fPFu5vCpKbmwsNDQ0kJSWhYcOGSElJQbNmzYowp+xnwkGpYqBy5cqIjIwUPst2RMViMZKTk1GyZEkkJCSgefPmMDMzEyLV3NlRrA4dOkBdXV0Yuq+qqprvRkFPTw/x8fGws7NDhQoVcOTIEQA/vqFg/440qFG/fn28ffsWc+bMEdK/P+e6urqIjY2Fs7MzKlasKNxUcNkoVocOHXDs2DFs3LgRAAoc0ZmYmCg8hWvcuDGMjY0REhKihNwWD0QER0dHNGjQANHR0UJaQfvp6OggMTER9evXR61atbBr166izm6xNHr0aNSsWRPTpk1DdnY2VFRU8pVRpUqVhBtqExMTREVFAeA2TZHKlSuHCRMmYP78+Th8+HC+7SoqKihfvjw0NTXh6uqKhw8f4s6dO1BXV0dubi6P8lAwR0dH3LhxQ5g/UvbhYW5uLiQSCUqXLo2UlBS0bNkSJiYmuHTpEgCuN4qioqICFRUVODk5wdfXF58+fYKamprc+SYiZGZmIjMzE+np6ejWrRtevnyJZ8+eyU29wAqX9JrSqlUrpKSk4Pr16/n2kQYQDQwMkJ6ejubNm8PU1FToO3C9KZ44KPUbk86lMm3aNJw+fVruNT5phVdVVYWOjg6Sk5Ph5OQEfX19uaAHd3YUR3pBXLhwIeLi4uDn5wcgf/AjISEBJ0+ehI2NDU6dOgWAJ/1TNIlEAh0dHaxZswaRkZEIDg4G8FfZSC+6SUlJOH78OKysrIRXw7hsFEsikcDU1BRDhw7F0aNHhTkLvqevr4+srCw0bNgQRkZGcuXDCp9IJELJkiVha2uLOXPm4M2bNxCJRPkmZtbV1cX79+9ha2vLQfYiRkRo164d7t+/j23btkEsFucbafP161esW7cO1apVw4kTJwBwm1YUmjdvjgEDBmDOnDlCQAP46wYvLS0NL168gJaWFp48eSIEpHgeHMXr1q0b9PX1MWDAAACQm3BeVVUVRISUlBQMHDgQxsbGOHbsGACuN4okrRcjR46Eo6MjJkyYgKSkJLlAu+xoqS5duuDBgwd48OCBUHdk52JjhUd63lu0aIGSJUti6tSpwsh22flYgbxXXocNG4YKFSpwvWEclPqdiUQiSCQSmJiYIDg4GOvXr8fy5csByAc+pMNaO3ToIDfSgxsFxZJeEG1tbdG5c2ecOnUKgYGBAPLKR9rpad26Nfz9/bFjxw4AXDZFQXp+7ezsMHnyZKxevRrLli2T2wbkzQUyYcIEbNu2DQCXTVGQnt+mTZvi3r172LJlC75+/Spslw1uXL9+HXZ2dnxzXQSknc1p06bB1tYWrVq1QmZmZr4n0unp6fj06RMaNmzIQfYiJhKJ0L9/fxgZGQkBd+lIG+n1xsHBAePHj8fevXsBcNkUlRIlSsDb2xsGBgaYNWsWLly4AABC0NDY2BgrV67EtWvXoKamxgGpIiJtu1atWoXExES0bt0awF831SKRCKqqqrCyskK7du2EhWu43iiWNPChoaGBLl264PXr1wgJCcG3b9+Eex/pdiMjIzg5OeHu3bsczC0i0vO/ZcsWJCYmolu3bsJDEFlmZmZo3bo11xsGABARv59VLMTHxyMsLAy7du3C8OHDMXHiRGGbWCzG3bt3hckbuVEoeh8+fMCiRYtw9uxZ2NnZCSuKAHkTAWpqagLgslGGN2/eYNWqVYiIiECvXr2wYMECYVtmZia0tLQAcNkoChH9cMTmmjVrMHbsWPj7+6Nfv36oUKGCsO3atWvYu3evUF5cPoonLasHDx6gT58+AIDz58+jZMmScvtEREQI27lcio70XCcnJ6Nr165IS0tD27ZtMW7cuALbMS6bonf48GFs2LABDx48wMyZM+Ht7S1sky6xzjfVRU8ikSAqKgojRoyAmZkZ9u7dKzeXoewk9Fxviob0eiORSDB16lRcuHABTZs2xaRJk1CuXDmhHE6ePIkmTZpw3Sli0vN//fp1dOzYERYWFli9ejWqVKlS4BySXG8YB6WKkVevXmHz5s1YvHgxOnbsiKlTp6JatWpyjQA3CkVPemH98uULDh48iODgYKipqcHX1xd2dnawtrZWdhZ/OwUFOv4u+PHhwwccP34c48aNQ/369eHl5QUvLy+5FflY4crMzISqqirU1dXztUuyZRUWFobZs2ejW7du6NixY4GTZHK7VrQkEgkuX76M8ePH4/3799i4cSPs7e1hYGCQbz8ul8L3d22ZNLCRmpqKmTNn4ubNm8jMzMTy5ctRvnx5mJub/8djsP/N351T2W13795FZGQk5s6di0GDBqFatWqYMGFCUWaVFSAnJwfXrl3DiBEjkJmZCR8fHzRt2hRmZmbCPlxvipb0GiIWixEQEIDz58+DiLBmzRpUq1ZN7hU9advHit7Tp0/Ro0cPAHlvGPTr109utXHuCzCAg1K/pb+7KGZkZODWrVsYNmwYTExMIBKJMH/+fFSpUgWlSpUq4pwWDz9qbGXLSfbnrKwsTJ06FZ8+fUJ0dDTWrl2LJk2a8OpUhUT2XD9//hzfvn2Dubm5sCLY39WfT58+Yc6cOXj9+jVevnyJ0NBQNGrUSHgFlhUOIoKnpyeePHmC+/fvQ0NDI189kv28a9cubNmyBW/evEGzZs3g7e0NW1tbqKmp8U2CEqWkpGD8+PG4fv06qlWrhrZt26J9+/YczFUg2Ruv5ORklC5d+of7ZGdn49GjR1ixYgXu37+PEiVKwNfXV1hWnSnGggUL4ObmBjc3N7l27Pu26saNGzh8+DCOHj2KFi1aYOjQoTAxMVFWtn9r/23AYsKECXj58iVu3bqFiRMnolWrVrC0tFRgDtmPSOuQRCLB2bNnsW7dOpw5cwbu7u6oX78+BgwYwH0ABfnRfcyPBAQE4MGDB7h48SJGjx4Nd3d32NvbF0FO2a+Ag1K/gR9dTP+ugUhLS8Pt27exfft2mJmZYfDgwShTpoyCc1r8yJbNrVu3oKKiAg0NDWH00/dl9P3nO3fuoHLlylw2CuDr64v9+/cjLS0NWlpaaNy4McaOHQtra+sCA4nSspRuu3DhAuzs7DiYqyBXr15Fv379UK5cOZw5c6bAwJRsfXn9+jViYmLg7+8PU1NTODg4wMfHhzujhexH15u/e9J58uRJPHz4EGvXrsWYMWPQo0cP6OrqKjqrxY5s2UyYMAEVKlRAly5d5EZySH1/rXn58iW+ffsGfX19GBsbF1mei6NWrVpBTU0N+/fv/+GrRN/Xp3fv3sHU1LSoslisyNabefPmoXbt2mjTpk2B+8qWS1JSEs6ePYuEhAR06NCBg+0K8HfXFdly+36/Y8eO4eXLl7h37x5Gjx4NGxubIslvcSJ7/nNzc0FEwgPa768vsq9NEhEOHjyI7OxsNGrUCPr6+kWfefZT4qDUL062UYiIiEBsbCxMTU3h5OSEGjVqFNigf5+Wk5PDIz0UQPY89+zZE48fP0ZCQgJ0dXXRrVs3TJ8+vcDv8cgOxQsNDcXChQsREREBKysr7Nq1CwsXLoS+vj7Wr1+P2rVr/7AcuHyKzq1bt9C9e3fo6+v/o8AUkDcaNCsrC0QkN+cH+/dkrzdnzpyBSCSClpYWXFxcCtz/+7JKTEyEjo4Oj/pUMC8vLzx+/BghISGoV6+e3GipvxtxyIrGpk2bEBYWhh07dsDCwuJvy4CvN4ole347deqEmJgYDBkyBH379kWJEiX+4yj3gj6zwiFbLzZu3Ig7d+6AiGBvb4/+/fsX+J3vy4LbN8WQPc8jR47E48ePUaFCBfTs2VMI6HI9Yf8tDkr9JqSvumhqakJFRQVxcXHYtm0bmjZtyo2ykvXv3x+XLl3C4cOHUapUKfTt2xdnz57Fs2fP+MlnESMiZGZmolu3bmjWrBnGjh0rbHN3d8elS5dgZmaGrVu38pO1n8Q/CUxJcadHcb6/eXvw4AESEhKgqqqKFi1aYP369dDQ0OAyULJZs2Zh+/btuHz5sjDC9vPnz/j27RuqVKkCgG/UisqPXm0Ri8WwsrJCy5YthRWRmXKNHDkSp06dwrlz52BoaAgAyM7O5gD6T2DKlCmIiIhA9+7dkZmZiV27dsHb2xthYWH/+Bh8XVKMkSNH4vz583B3d8fjx49x7do1LFq0CL169QLA5539d7hX8hsIDg7GgwcPEBUVhVu3bmHbtm3w8vKCh4cHLl68yJ1PJfr8+TPevHmDLVu2oGrVqti0aRNu3ryJ/fv3w9TUFKmpqcrOYrEivTh++vQJGRkZctsMDQ3h7e2N0qVLIzw8HLm5ucKytqxoFHS+7ezssG3bNnz69AlNmjRBdna2MH/E97jzozjScztmzBg8ePAAhw8fxpkzZ7Bu3TqcPHkS3bp1E/bjZ11FJzc3V/hZGnR3cXFBmTJlcPHiRcyZMwc2Njbo0qULZs6cCQDcJygi0joTERGBDRs2ICsrCwCgqqoKf39/XL16FQ8fPlRmFhmAhIQEPHv2DAsWLIChoSFu3bqFlStXok6dOujfvz+ePn2q7CwWW6dOncLu3buxb98+LF26FE2aNEFGRgbs7Ozk9vtP1xzuGxQOsVgs97lkyZLYtm0bgoKCEBYWhl69emHEiBHYvHkzAO4PsP8O90x+QbIVXCKRICYmBm5ubqhUqRJUVVVhaWmJgIAAeHp6IjAwEGlpaUrMbfGWmZmJ+/fvo2TJkggLC0NgYCAiIiLQsmVLJCcnY8GCBbhz546ys/nb+v5iKJFIoK2tjSpVqmDjxo24du0avnz5grlz5+LQoUOYOXMmWrVqhcjISKioqPDNWxESi8XC+b5x4wZu3ryJ2NhYqKqqonbt2tixY8c/CkyxwpGamor79+/LpWVlZSEmJgYjRoxA1apVUbNmTbRt2xYHDhzAqVOnMG/ePAB8A1CUpPN0jBo1CgcPHkRKSgpu374NLy8vDB8+HC9fvsS0adPQrFkzHDlyBF++fFFyjosPIkJGRgbWrFmDFStWoEaNGti0aRMeP36M9u3bIyEhAVevXhX2ZUXj+3NdpkwZpKSkICQkBKGhoRg/fjz27NkDLy8vREZGYunSpUrKKXv//j0qVKgAFxcX7N27F4MGDcKSJUswcOBAfPv2DadPnwbA15yiIPv6/pYtW7Bjxw6cOHFCeMBbuXJljB07FkOGDMHo0aPlAlOM/RN8x/WL+X44uIqKCnR1dXHv3j254JORkRFcXFzw6NEj5OTkKCu7xUpBN8hlypRBw4YNMXnyZMyaNQu7du1Cq1atAAAvXrzAlStX+CZBgaR1ZefOnYiLixOCHps3b4aenh5at24NZ2dnhIaGYs+ePTA0NETr1q2RmJiIN2/eKDPrxYpEIhE6O3379oW3tze6desGOzs7nDhxAiKRSAhMffnyBU2aNEFWVhYHDRVoxIgRCAkJyZf+/PlzvHr1SvgskUhQp04deHt74/bt2xwoLCKyT6wDAwNx+PBhNG3aFEFBQWjTpg20tbWxYMECzJkzB2PHjoWDgwNKlCjxw4m1WeH4/u9fW1sbUVFROHLkCDw9PbF+/Xq0bNkSW7ZsgYODAxYuXIiPHz/yjVsREYvFwrnOzc1FWloaVFRUsHjxYqioqAijPUJCQhAQEIAJEyYgMzMz3wgRVvgKunaULVsWZmZm2LFjB/r27Yvg4GAMHToUABAdHY39+/cjLi6uqLNa7BCR0Efr2LEjRo4cidmzZ+PBgwe4dOmSsJ+pqSnGjRuHQYMGoU+fPnLbGPuPiP2SgoKCaM6cOUREtG/fPqpVqxYtW7aMEhIShH0OHTpETk5O9P79e2Vls9jIzc0Vfn769Ck9ffpU+LxkyRISiUQ0fPhwSk1NJSKimJgYqlWrFvXu3bvI81rcbNiwgUQiETVu3Jjevn0rt+3IkSN04sQJio+PF9K2b99Ozs7OcnWJFY2ePXtSzZo16fbt25ScnEzOzs5UpkwZ2rJli7DPzZs3SVdXl2bPnq3EnP7+srKyhJ9fv34t/Dx37lxydHSkqKgouf19fHzIw8ODxGJxkeWREf355580Y8YM2r17t5AmkUgoJydH+Pn9+/dka2tLw4YNU1Y2iwWJRCL8vGvXLvrjjz/oyJEjcvs8e/aMtmzZQjVr1iRra2sSiUR04MABIiKuOwom20/z8fGhNm3aUJMmTcjf319I//btm/Dzly9fyNrammbOnFmU2Sz2wsPD6fPnz0REdOPGDSpdujSJRCJavny5sE96ejq1bt2a+vfvL1fvWOGTPb+XLl2ixo0bU3x8PN27d49mzpxJKioqtH79ernvvHr1irZt21bUWWW/OA5K/SJkG4WMjAzq3bs3tWnThjIyMoiIaMiQIWRnZ0dTp06l6OhounLlCllZWVHfvn2VlOPiqVu3bmRqakoVK1ak9u3bC+nTpk0jPT09qlu3LjVp0oRsbGyoQ4cOwna+qCrO5s2byd7enjw9PalRo0b5AlNSmZmZ9OrVK755U5KTJ09S8+bN6dGjR0REFBwcTPr6+uTl5UUaGhq0fft2YV/ZIAkrfLI3bytWrCCRSEQ3b94kIqJr165Ry5YtqUOHDhQZGUkSiYSeP39ONjY25OPjo6wsF0vPnz8nkUiU74ZN6v379xQYGEiOjo5y1yO+3ijWtGnTqESJEuTk5EQikYjGjx9PsbGxcvt8/PiRrly5Qg0bNiQXFxcl5bR46tixo/Agd9u2bSQSiWjs2LFCuxcfH09btmwhW1tbateunfA9rjeKFxMTQ9bW1lS3bl0hMLV7924SiUQ0adIkOnDggNBXsLW1lQu+M8UaMGAAeXh40MiRI4W01NRUmjVrFolEItqwYUOB3+NgO/unOCj1C5C9QUhOTiYiotjYWNLX16dx48YJ23x8fKhhw4YkEomoVq1a1LlzZ2EbN9iKIVs2wcHBZGdnR1FRURQeHk7m5uZUt25dSklJISKigwcP0qJFi2j27NlyTxC4wVasc+fOUdOmTWnr1q3UoEEDaty4MeXk5JBEIhGCG+np6bR//36yt7entm3bCt/leqM43//dP3nyhNauXUtEROvXr6eKFSvSoUOHKDc3l2rXrk1lypShdevW/e0x2L8ne04jIiIoPj6ePDw8yNTUlG7cuEFERGfPniUvLy8qV64cmZmZkbm5OQc9ikBBf+9Xr16lihUrUsuWLYWbOKmsrCzy8fGhWbNm/e0x2L8jPacSiYS+fv1KrVu3psuXL1NmZiYdOnSIVFVVaciQIRQXF5fvu/fv36fq1avTxYsXizrbxYZse3T06FGytbWlV69eERFRWFgYlSlTho4dOybsc+7cORo4cCCNGjVKSON6oxjfXyvEYjEdPHiQGjZsSPXq1aNPnz4REdHGjRupRo0aZGBgQM7OztS+fXvKzs4mIvl+OPv3kpOTaeHChXKjBony3tARiUTUrFkzSktLE9K/fftGs2fPJhUVFVq2bFlRZ5f9Rjgo9RP6UYd+8ODB1KdPH+GJ9d69e6lKlSpyw/ZTU1Pp5s2b9OTJEyGNL6aKt3LlSlq6dKkwDJ+I6PHjx1SjRg2qU6eOEEz8HpeNYonFYrp9+zY1b96cJBIJ7du3j1q1akUuLi6koaFBERERQhlcu3aNNm/eLPddpnjjx4+nBw8eEFFeZ0gikZC7u7vwel5WVhZ17tyZ6tatyyM/FUz2b753795Ur149io+PF16VMDY2FgJTHz58oNu3b9OGDRvkXlHieqMYsjde8fHx9OXLF0pKSiIiogsXLlDp0qWpe/fuwkMQaT9Ctjy4bAqf7Dl9+/YtPXz4kCZMmCCUAxFRVFQUqaqq0tChQ+VeFSciSkpKosqVK9PRo0eLLM/Fwbdv36h58+aUnp4ul7569WpydXUlIqIFCxZQ2bJl6fjx40SU98qRtC2TDSByvVE82fZNLBbT4cOHydXVlerXry8E22NjY+nVq1cUFxcntG/SkVKs8Bw7dkzuTQ5Zf/zxB4lEIlq0aJHcveq3b99o4sSJ1KdPnyLKJfsdcVDqJyNbyS9cuCB0bFJSUsja2pq0tbWpdOnStGHDBrp06RINGzaMRo8eXeATuO+PxxTjyZMnpKGhQSKRSBgBJT3vT548IWtra3Jxccn3FJsVPtm/d+nPEomEGjduTM+ePSOivIuqtrY2GRgY0PPnzws8DndCi46lpSX16NFD+Pzx40cyMTGhVatWCZ+bNm0qvNbHFO/ixYvUsWNHuXMuG5iSPhj5HtcbxZA9r4MHD6YGDRqQhYUFdenShU6fPk1EeWVWpkwZ8vb2lguISHFfQLGmTJlClpaWpKurS8bGxnT+/Hm57VFRUaSpqUldu3alL1++COm7du0ikUhEMTExRZ3l39qzZ89o7Nix+dIvXLhArVu3pvHjx8sFpIjy5mf19PSUm4eV643ibdiwgVq1aiVMR0KU1+YdOnSI7OzsqHHjxgXO8cnXm8KVlpZGvXv3lrtXuXfvHp0/f55SU1OFkWmLFy8mkUhEixcvlqsfsvNQMva/4KDUT0S2cg8ePJgqV65MiYmJRJT3FCE8PJyGDBlCCxYsoHr16tH48eOpVatWZGVlRSdOnCAibqSLQkGdlDNnzlDVqlWpVatW+fZ78uQJlS1bVu4VClZ4ZMtDetGUys3NpYyMDLK1taXz58/Tly9fSE9Pjxo3bkxNmjShpk2b8vxESiJtq8LDw8nV1ZXu3bsnbBs6dChpaWlR//79ydTUlF8NK0J+fn5kYWFBtWvXpq9fvxLRX0+x09PTyd3dnUxMTOjy5cvKzGax1LVrV6pRowZduHCBjh07RjVq1CAbGxthxNSlS5eoTJky+W7wWOGT7WtFRkaSubk5hYeHU1hYGJUrV4569eol16YR5b3C36BBA7nX/c6cOSO3MAr7dwoaOTNt2jShL33//n2qV68elShRglavXi3sExcXRw4ODjRx4sSiymqxJfv3n5ubS8uWLSN7e3vq3r17vnZrypQpJBKJyNraWmjnmGIcO3aMZsyYIXzu0qULWVpakpqaGtnb29OYMWOEtz4WL15MampqtGTJknx9Mu6jsf8VB6V+ErKVeNy4cWRoaEgPHjygmTNn0qFDh4iIKCEhgRo2bEhLliyhhIQECgsLo3bt2pFIJCI9Pb0fviLGFGPw4MFyK06cOXOGDAwMCpzA/Psh+6zwLVmyhNq3b08eHh40fvx4yszMFLYFBASQr68vGRkZUb9+/SgjI4P27t1LtWrVosDAQCXmuvj4UcA8NjaWqlSpQn5+fkJaamoqTZs2jXr27Em+vr5COnd2FO/BgwdUu3ZtKlmypNyr4dLyS09Ppzp16tCYMWOUlcVi6datW1SnTh168eIFERGFhISQvr6+MNJD2t6dPn2ahg4dqrR8FjdRUVE0bNgwublUjh07RmZmZtS3b998gSkpngen8GVnZ1Pt2rVp4cKFQlpsbCwZGxtTrVq1hD7y3r17qVKlSuTl5UVz586lZcuWkbW1Nc8nWcTu3r1LRHnXlPXr15OTkxN16dJFbr6iP//8k7y8vGjKlClcZ4rQ0KFDydLSkq5du0ZPnz6lGTNmkJubG/Xq1UtYRTw0NJREIhG/eswKDQelfgKyFz/pKgbXr18nIqIePXqQmpoajRs3ju7fv0+vX7+mChUq0OHDh4mI6PPnz9S+fXvq16+fUvJenPXt25e0tLTkVgWTBqa8vLwK/A6PZFMMf39/Kl++PM2cOZMGDx5MFhYWZGVlJUweGxISQiKRiAYNGiTX4ZHWM6YYycnJtHr1armnn6GhocKreVIRERFkampK165dk0uXHfnGdafw/eicPnv2jGrWrEktWrSQew1Juv/3IxKZ4kVHR5OpqSnl5ubSwoULqWzZssLkzJ8+faLQ0FD68OGD3Hf4xlqxXrx4QVZWVqSlpUVTpkyR2yYNTA0YMOCHr7uywjdt2jTS0NCgP/74Q0h7+PAhOTg4kI2NjRCY2rNnDw0ePJgqVqxIHTt2pEmTJgn787VGMWTP69WrV0kkEtHOnTuJKC8wtW7dOqpbty55eXnRly9fKCEhgbp27UoLFiwQvseBKcWQHWGYmJhIdevWpYiICCEtMzOTVq1aRfb29nILNcm+/srYv8VBKSWT7TSOHz+eRCIRWVlZUUBAgPDkc8+ePdS6dWuqXbs2BQQE0NKlS6lfv34FLm3PF1PF+NGFcNy4caSlpSXXSJ89e5YMDAzIzc2tqLJXrMXHx1PNmjXlgoOfP3+mxo0bU8WKFYXA1NGjR4UnPDzcuGj88ccfciMH379/T40bNyYLCwuqW7cu7dq1i+Li4ig1NZXc3NyEZe2/D3pw+RQ+2Tbt6tWrdPjwYfr69asQtH348CFZW1uTu7u7XGCqoHnbWOGSvY5Lz/G9e/eoYcOGNGbMGCpfvjxFRUUJ+5w8eZK8vLzo/v37RZ7X4kR2nkKpU6dOkbOzM9WpU0eY30vq+PHjpKmpSXPnzi3SfBZX0jZtwYIFpKKiIvd63sOHD8nOzo6sra2FwJRYLBYW15DiPrRiyJ7jZcuW0YwZM0gkEpG6urqwwExGRgZt2rSJateuTerq6mRtbU3W1tZCwISvN4oh+zd//fp1SkhIIAcHB5o3bx4RyZ/3+vXrU69evf72GIz9rzgo9ZMYMWIE6evr0+XLl2nevHlUp04dmjhxohCYevLkCa1bt44qVKhApUqVIiMjI9q7d6/cMbjBVjzpZNmyxowZIwSmpA3zsWPHaOTIkUWdvWIpNjaWTExMhBsC2Sc+TZo0oWrVqv0wGMWKjvQ15IyMDHr37h116tSJ6tWrR5aWlnTy5Enq1asXWVhYCHN/MMWR7UB269aNLC0tqUyZMuTg4ECLFy+mjx8/ElHejVytWrXIw8NDmLeQKZZssDApKUnutXxPT08SiUS0YsUKIe39+/dkZ2fHr+wpmGyd+fjxI3348EFIO3v2LLm4uFDnzp3p7Nmzct+7evUqj+4oArLX/bt371Lbtm1JS0uL1q1bJ6RLA1O2trYFTnfB/QPFmzZtGhkZGVFERASFhIRQly5dSCQSUXh4OBHlPZCKj4+ndevWUUREhFB3uA4phmy75uHhQZ06daL3799Thw4dqEmTJvlG344fP5769OnDdYUpBAelfgKnTp2iMmXKCEttp6Sk0PTp08nZ2ZkmTpwot6LB169fqW/fviQSiQpcWYQVLtkGe/ny5SQSiejChQv59hs4cCCVL1+edu/ene+JATfeimdtbU29e/cWPkvrTFJSElWvXp0GDhyorKwVW7KjnS5cuEAikYiCg4PlbgauXr1KU6ZMoYoVK5Kbm5vcCpZM8fr370+1atWiBw8eEBGRq6srValShfz9/eUCU3p6erRo0SJlZrXYGTRoEDk4OFDDhg3lzr2bmxuZmppS//79afTo0WRtbU0eHh7Cdr7eFD7Zczp37lyqW7cuWVtbk52dnRCEOnXqFNWrV486d+5M586dy3cMvqkuGp6enuTq6ko9evQge3t7UlVVlQviSgNThoaGlJ6ersSc/v6kDwOlvnz5Qg4ODnKBwo8fP9KkSZNIJBLJjXaXxXVH8R49ekQtW7YUVgF9+/Yt6enpUYcOHejhw4eUkpJCsbGxVLVqVbnJ0BkrTByU+gkkJSXRp0+fiOivpz3fvn0TAlOTJk2SC0zl5OQIrySxwvV3HXqJREJeXl5kaGgoBKak+x89epREIhGJRCJelUpB/q5sNm/eTFZWVhQcHCykSYMi/v7+5OrqKjfxOVMs2bLy9fWlrKwsWrp0KamqqlJwcHC+5Z2vXLlCixcv5smzi9ClS5eoUaNGdOvWLSLKe6WiTJky1LFjR6pQoQIFBAQIT0ljY2OVmdViQfbGSxpsCgkJoWHDhpGurq7cqmBTp06lbt260YABA+TaPH6FQrFmzpxJBgYGtHPnTnrz5g3Z2tpStWrV6M2bN0REdOLECXJzc6MmTZrQ7du3lZvZYmj58uVkZGRE7969I7FYTElJSTRz5kxSUVGhlStXCvvduXOHpk2bpsSc/v7atGlD48ePl0uLi4uj0qVLyy0QRET07t07cnBw+NvAFCtcsn20IUOGCBP9y865+ujRIzI1NSUrKyuqWrUqWVpayj0AYaywcVDqJyTtWMoGpqZOnVrg5LLcCS08so30pUuXaNWqVeTt7U1BQUFyQ/I9PT1JT09PbsTU2bNnKTg4mEd5KIhs2URGRtLSpUtpxowZ9O7dOyLK69SMGjWK6tSpQ4sXL5b77sqVK8nV1ZW+fftWpHkurmTbpKlTp5KlpaWwYtjChQsLHDFFRDyvh4J9/7Q5ISGB9u/fTxKJhCIiIqhChQrCK3rSEVOjR4+We52Sy0Xxjhw5QkFBQUKwMDU1ldasWUNqampygSnZ15WIuGwU7dOnT1S/fn3at28fEREdPnyYSpcuLQQ7pO3X/v37aejQoVweSjB37lxq1KgREcnP/zV69GjS0tKijRs35vsOl5NiPHr0SHgQKPtAsFevXtS6dWshkCvVu3dvqlu3LolEIrkJtpli5ebm0uHDh8nAwICqVKkizFUsrReJiYm0fft2WrZsGW3ZskX4HtcbpggclPpJyQam/P39ycXFhYYOHcrDWBVE9oZ4zpw5VLduXbKzs6MGDRqQtrY2mZub08yZM4V9vLy8qHTp0rRkyRLas2cP2dnZ0dSpU4Xt3GArxpQpU8jCwoJcXV3J2tqaypcvLwSmYmJiaMSIEVSzZk0aNGgQPXr0iKKjo8nGxoZGjBih5JwXP4cPH6ZevXrle5UlODiYRCIRLVq0iFJSUpSUu+JF9rpx5MgRevXqFRHlze8lFovJ09NTaN8kEgl169aN6tSpI0x0yorG/v37SSQSUdmyZenhw4dCelpaGq1Zs4Y0NTVp8uTJSsxh8RUTE0PGxsaUlpZGUVFRVLJkSSEglZqaSkFBQflG43I/QHEKGjm9evVq0tXVpfj4eCL6q93bt2+fMJKd58YrWosXL6amTZsKo6M3b95MLi4uNG7cOIqLiyOivPuc9u3b0/79+2n69OmkqalJa9euVWa2f1tbt24VVjlu3769MJfXqVOnSEdHh/r37y+81vqj9ovbNaYoHJQqIn+3YtGPAk2ygakxY8ZQQECA4jJYjH2/AqKhoSEdOnRIeGXl1q1b1LlzZzIwMJB7l3rkyJFUqVIlqlq1KnXr1q3I813cLF26lCpUqEDXr1+n9PR0iouLo8aNG9P48eOFOhQXF0fr1q0jc3Nz0tPTo+rVq1PXrl2FY/B8K4ojO3Jj7dq1VLlyZTIyMhJeY5Ed6blo0SJSUVGhmTNnUkZGRlFntViR7UB27tyZHB0d6cCBA8INdFZWFjVu3JjGjRtH2dnZlJKSQm3atKFLly4J3+N6UzTevHlDgYGBpKWlRUFBQXLb0tLSaO3atSQSiWjHjh1KymHx8KO/95YtW5K3tzeVLFlSbl6cFy9eUP369enAgQN/+31WOGT7zLLXj3fv3lHDhg2pc+fOciNxoqOjydfXl44cOVKk+WR5r+aXLl2aOnbsKAQ7Fi9eTC4uLlStWjXq2bMn2dvbk729PYnFYsrOzqZx48ZRuXLlCpyMnv3vnj59Sq6urtSmTRtq2LAhVapUib58+SJsP378OGlra9OQIUPk6hW3Z6yocFCqiD158kT4edasWf9xf+kNheycUtxAKMaUKVOobNmycmUkPdcxMTHUtWtXqly5Mh07dkzY/vr1a2G4KxE/QVCUt2/fUrNmzeTmhSAiGjZsGLVt2zbf/hKJhO7duye3WiKXTdGYMWMGXbx4kUaOHEmlSpWiMWPGCK9OygamZsyYITc5PVOswYMHU82aNenJkyf5AoEjR44ka2trat68OZmbm1Pr1q2FbXy9UYwfPYz6/PkzzZgxg7S1tSkkJERu27dv3+jMmTNFkLviS/Y6kZCQQElJSUSUV14BAQGkr69P3t7ewj7p6enk7u5OLVu25JHsRUC2fHx8fKhjx440duxYYbGG7du3U6NGjahevXq0d+9e2rt3L9nY2NDw4cMLPAYrPD86rzdu3KDy5ctTu3bthIch58+fp3nz5lGPHj1o/Pjxwj2ORCKhtLQ0YZ5dVriOHz9OZcuWJR0dHTp69CgR5ZWb7MrhJUuWpKFDh8rNL8VYUeCgVBHatGkT2djY0MmTJ8nd3Z3Kli0rdHj+zt+NsmKFIyoqirS0tGjkyJFC2vcX2Hv37lGpUqVo+vTpBR6Dy0ZxMjIyaPbs2RQdHU1Ef53rNWvWkKurKxH9FfAoqGPEZaM4sjdi/v7+pKenR6mpqZSZmUkjRoyg2rVr06JFi4SnpAXNjcflU3iysrLyvRb54cMHcnBwoD179sily5bdvHnzaPz48XKjQblcFEP2vAcFBdG4ceOoX79+dOXKFcrIyKBv377RzJkzSVdXl0JDQws8Bt9YK9aMGTPI1dWVKleuTMuWLaOMjAxKSkqinj17Uq1atcjDw4NGjx5Nbm5uVKtWrb+9/rDCIXtu+/fvT6ampjRmzBgyNDQkNzc3OnToEBHl3Xh37dqVSpQoQdbW1nKjpZliyJZNVFQUhYeH0/Pnz4UHINevX6fy5ctT+/bt5eb3lP1eQX0D9u/JXm/OnTtHzZo1o8aNG1Pbtm2FPrXsfsePHyeRSJRvQnrGFI2DUkUoPT2dGjRoQKVLlyYzMzNhyW3uxChfXFwcjRgxgtzc3Gj+/PlCurRspI11ly5dqFWrViSRSPipaBEraPnmTZs2UZ06dYTPSUlJdOfOnaLMFvt/W7dupaCgILmRhJmZmTR48GCqW7cuLV68uMC5CjjwUXiys7PJxMSEdu/eLZf+4MEDKlmyJN28eZOI5DupCQkJwtwesvi6pHjt2rUjCwsL6t69O9WuXZtMTU1p3rx5lJSURMnJyTR79mwqVaoUzZ07V9lZ/e3J/r2vWLGCjIyMaMmSJTRu3DhSV1en0aNHU0pKCiUmJtKGDRuoffv21KdPH5o+fbrw6vL3k88zxbh8+TL16NFDWEDj69ev1Lx5c3JzcxNeoSQievnypTC/FBG3aUVh8uTJVLZsWTIxMaGyZcvS/PnzhXk/r1+/Tnp6etSpUye518aY4she66OiooSRaseOHaOWLVtS69at5VZzl26XjjxkrCipgCmcWCwGAGhra8PR0RHq6urQ09PD3bt3kZOTAxUVFRCRknNZvBkbG8Pf3x/29vaIjIxEUFAQAEBFRQVisRiqqqpISUnB+/fv4eTkBJFIBFVVVSXnunjR1tYWfpbWl4yMDOHnhIQEWFlZCWXHis61a9fQs2dP+Pj44Nu3bwCAnJwcaGpqYtmyZXBwcMDOnTuxcOFCoc2TEolEysr2b0ddXR0rV65Ep06dAOTVDwCwtLSEsbEx1q1bBwBQVVVFbm4uAODKlSvYuHEjUlNT5Y4lW0as8K1fvx6PHz/GlStXsG3bNty8eRO9e/fG9u3bsWPHDpQqVQoDBw7EkCFD8PbtW2Vn97cnbYfu3r2L+Ph4rFq1CuPHj8fSpUsRERGB8PBw+Pn5IScnB/3798f+/fsRHh6OOXPmQE1NDWKxGGpqakr+LX5/06ZNQ+/evfHq1SuUK1cOAFCuXDmEh4dDU1MTixcvxq5duwAAVapUgZGREYC8PgO3aYVP9t7l4sWLuHz5Mg4ePIhnz55hzJgx2LhxI1avXo13797ByckJx44dw969e7F48WIl5rp4kEgkwn2Kt7c3Ro8ejRMnTgAAWrVqhVGjRkEikWD+/Pm4cOECcnJy4OLigsjISNjY2AjHYKyocAutYEQkNApdu3bFmzdvcOvWLejq6mLGjBk4duwYxGJxvhszbgiKnpGREaZNm4Y6depg3759QnBDWn4xMTFQUVGBs7OzMrPJ8NcNBBFBR0cHmZmZcHV1hYODA7Zu3ark3P2evg+cS4PtAODg4IDdu3dDX18fkZGRAPICJNLAVGhoKCpVqgQigrq6elFm+7f3fbm0bdsWANCvXz/MnTsXCQkJUFVVxcCBA3H58mXMmjULQF679unTJ0ydOhWxsbHQ1dUt8rwXZ8nJyShbtiy0tbWRk5MDAJg3bx7q16+PhQsXAgAqVKgAf39/rF69GkD+smb/3o0bNwDkXVOuXbsGBwcHLFq0COnp6cI+3bp1w5o1axAREYHAwEDExMTkOw4/pCoaPXr0gK6uLp4/f46LFy8K6RUqVEBERATU1dUxa9YsXL9+Xe57/PBDMaTndcOGDdi6dStq1aoFV1dXaGtrIyAgAL1798auXbuwdu1avH//Ho6Ojnj06BHmzJmj5Jz/3sRisRCE7d69O+7fv4/9+/ejYcOGwj7t2rXDxIkTIRaL4e3tDUtLS5QuXRqenp7CPhzIZUVKSSO0igXZocI7duygunXr0tOnT4ko75WJhg0bkouLi7AiSHZ2No0ePVopeWV/iY+Pp1GjRpGzs7PwKl96ejrVqlWLJ2YuArLDjb9+/fq3++7atYuqVatGFhYW1LRpUyGdh+krztmzZwssl6ysLNqxYwdpa2vLtWPSeSJkX23hV/YKh+x5vHHjhtwiDfPmzSORSETz58+n3Nxc+vTpE/n6+pKFhQXZ2dmRu7s7VatWTW6hAC4XxSjoVe+goCAyMzMTtknnXnn8+DGVLl2abty4Ibc/l03hW7lyJRkbG9Pjx4+FtHXr1pFIJKIxY8YIy9hL7dy5k0QiUb4J6JlifF9vpNeSJ0+eUM2aNal169Z0/vx5uX3evXtHCxYsKLI8sjx9+vQhkUhE9erVo8TERLlt8+bNI2traxozZowwbQkRv+5a2NLT0+XmgRKLxXTnzh2yt7en+/fvE1Fe/Th58iRNnDhRWDTj3r17tH37drmFhLgPzZSBg1JFYPny5eTp6UmBgYFE9NdKeomJidS4cWNycnKiCRMmkK2tLdWuXVuZWWX/TxqYql+/Ps2YMYNsbGx4Raoi1q1bNwoLCytwLimpDRs2kEgkoh49eghpfDFVnLCwMBKJRGRubk7r1q3Ld0OQmZlJ27dvJy0tLRozZoyQLntzwXWncMiex7lz55KTkxMFBwfLrVokLa+5c+eSRCKhb9++0cWLF2nYsGHk6+tLy5YtE/bleqMYsn/7y5cvF24EEhMTyczMjDp06CC3//nz56l69erCAyymGKtXryYVFRXau3dvvm2hoaFCQPf7xWhOnTrFN9NFQLbehISE0MSJE2nkyJF0/fp1IsoL3trY2JC7uztduHChwGPwtUYxfnStmDx5MhkaGlJISEi+gK6Pjw/16NGDy0SBgoKCyMLCQi4oGx0dTSoqKnT9+nXasWMH9ezZk6ysrKhatWpkampKV65cyXcc7gswZeGglII9fvyYGjZsSKVKlaIpU6YI6dLAVFJSEg0aNIg6duwot2QtN9zKFx8fT6NHjyZNTU1q166dkM4NtmLIntctW7aQlZUVvX///m+/ExsbyzfWRSgyMpKGDh1KCxYsoIEDB1KVKlVo5MiRdPr0aWEfsVgsBKZ4ZKHiTZ48mYyMjGjXrl3CxL+y9WDJkiVCYEp21SNZXG8UQ/a8enl5Ue3atWnt2rWUkpJCEomEjhw5QsbGxtSgQQPatWsX7dq1i2rVqsWrhSnYqlWrSE1NLd9qlLIT/soGppKTk/MdgwNTRaNDhw5kZ2dHffv2pf79+5NIJKLIyEgiyutfS1dCPHHihJJzWvxcvXqV7t69S69fvxbShg8fTubm5rRs2bJ8I6ak9zV8f6MYsbGxNG7cOHJxcREGQRARdezYkUqVKkXlypWjuXPn0rVr14iIyNzcXG50FGPKxkGpQlZQYxsdHU1t2rShSpUq0f79+4V06VDk3NxcudEgfIPw84iLi6OIiAjhM5eN4vn5+dGkSZNo8eLFRPTPOzBcNor34MEDqlatGp08eZKI8to2b29vqlevHnl4eNDFixeF4fl//vknDRw4UJnZ/e1t27aNzM3NhdEDslJSUoSfFy1aRCoqKjR//nxe9UjBCmqvBg0aRJaWlsIqVLJu375NjRs3JnNzc7K1taX+/fv/7bHYv7Nv3z4SiURyq7QREbVv35769u1LqampQlpYWBipqamRn5/fDwO6THHCwsLI0tKSPnz4QER5I6Y0NDTo3Llzwj4PHz4kPT09WrRokbKyWSz4+/vT9u3bhc8TJ04kU1NT0tXVJQ8PD9q4caOwbdiwYWRhYUErVqzI96o/t2mKIe3/fvjwgUaPHk3Ozs40b948Yfvp06fpzZs3wucPHz6QnZ0d7dq1q8jzytiPcFCqEMkON5aOhJI6d+4ctW/fnpo0aSLMIfX9d4i4wf6ZcdBD8TIyMsjR0ZFEIhHPr/aTCg4OJldXV3r16hUREd25c4e0tLSEm2oXFxdaunSpXBvI7ZpizJgxg7p06SLMR5Sbm0v79++ngQMHUpMmTahv377CuZeOmDp48KAys/xbS0lJocmTJ9Pbt2+FtHfv3pGLiwudOnWKiPLm71i/fj01aNCAJk2aJPQBYmNj5eZb4etN4cvMzBRumENDQ4X0Tp06kZWVldCmyfbLZs+eTfXr1+c2TAkmTZpEU6dOJaK8eYnKli1LUVFRRET08uVLYYRObGys0vJYHDx58oQaNWpETZo0ocOHD9O1a9eoRo0aFB0dTXv37qXevXuTo6Oj3KibESNGkI6OTr7RiKzwSdsm6TUjLi6ORo8eTXXq1JEbMUVE9PHjR7p06RLZ2dlR+/btizyvjP0dEREv51IYxGKxsPrKjBkzcPfuXejo6KBBgwYYPnw4AOD06dMICwvDt2/fMHHiRLRp00aZWWZM6SQSSb7VPVJSUtCzZ09cv34dhw4dgpOTk5Jyxwpy584djB8/Hn/++Se0tLRga2uLDh06YO3atYiKisKBAweQlJSEzZs3Kzurvy3pZbt379748uULIiMjIRKJ0L9/f7x79w5EhBo1auDUqVOwt7cXVkQ8ceIEWrRoocSc/96ioqKwc+dOrFu3TkjLzMxE/fr1YWlpiYYNG2Lv3r1IT09H7dq1sWrVKowfP15Y6VWKiHi1MAWJj49HUFAQrl69iu7duyM6OhrPnj3Dvn37YG5uLpx72WuTNI3LRXFk+9BSPj4++PLlC6pXr44FCxZg69ataN26NQBgyZIleP/+PebMmQMdHR0ABfcnWOG4fPkyFi9ejLS0NJibm0NfXx8BAQEAgEePHiE0NBQ3btzA4MGDMWzYMADAokWLMH78eF6ZUoG+rzcZGRnQ1tbGp0+fEBgYiEuXLsHLywu+vr4AgI0bN2LFihWwsrLCpk2bAHC9YT8R5cXDfh+yT9C8vLyoRo0aFBgYSMOHDydLS0saP368sP306dPk6elJtWrVort37yoju4z9FGSfRj948IDu3LkjzImTkZFBDRo0oCpVqgirhrCfR48ePcjKyor09fWpX79+cq+8yOLRBYp16dIlEolEVLNmTSpZsiTVqVOHtm/fLsx3M3/+fKpWrRrFxcXJfY9H4Sje+vXr6fbt20SUtyCDq6srGRkZ0fLly4Vr/4gRI2js2LHKy2QxJV3IpEqVKlSuXDlh7kLplApERO7u7sI8oGKxmNsyBZLtC+zcuVOY82bPnj1kY2NDJUuWpH379gn7vH37lurUqSOsjswUR7ZsLly4QB07diQ9PT0aMmSI3H6PHj2ioUOHkpOTU75XKQtafZT9e7Ln1cfHh7p160YODg60bt06SklJoYSEBBozZgw5OzsLk58nJSXlmwOUsZ8FB6UKUUBAADk5OVF8fDwR5Q03LlGiBJmbm9PQoUOF/Y4cOUJLly5VUi4ZUz7ZC6G3tzfVqVOH9PT0qFmzZuTv709ERKmpqdS4cWOysLDgwNRPQnpj9uLFCzIzM6POnTtTZmbm3+7LFOvOnTu0ePFiWrVqFeXm5sqd91WrVlGjRo3yrSDGCp9sQOPVq1ekqqpKAwcOFF4Jy87Olptf5evXr2RlZUVBQUFFnVVGeXOqjBkzhhwdHSk4OFhIz83NJXd3d6pevbpcmTLF+H4xAAcHB9q9e7cQWB8xYgRVqVKF5syZQ5cuXaJDhw6RjY2N3KqVfK1RDNmykU72f/36dfLw8CAzMzO5QCFR3sTzXbt2pf79+3OZFCEvLy+qWbMmLVmyRHhNX9qP/vDhA40dO5bq1q1L06ZNk/selxH72XBQ6r8kW4ljYmLozp07wsSxy5YtEzo3ixcvJn19fdq9ezf5+vqSrq4ujRs37m+Px1hx07dvX6pRowY9efKE3rx5Qy1atKBy5coJc0WkpqZSo0aNqESJEgVOEsyUIzk5mVq3bk19+vQR0rgt+7nExcWRg4MDTZo0SdlZ+e3J/u336NGDXrx4QYcPHyYzMzMaOHCgXFA9Li6O9u/fT7Vq1ZJb1ZUVPemIqbp16wp9t/bt21ONGjWEgBSvslc0Ro0aRTY2NvTixYt8wcARI0ZQvXr1SE1Njdzc3GjAgAHCNh7poRiy53XevHnUv39/evz4MRERXblyhby8vKhJkyZyizcREb1+/Vr4LvcJFG/Xrl1yiwFs2bKFtLW16cyZM8I+Hz58oD59+tDMmTOVk0nG/iEOSv0XZBvYgIAAsrGxIXV1dbK1taXw8HDKzc2llJQUun//PllZWQkrVVy+fJkMDAyoXLlytGbNGmVln7Gfytu3b8nNzY1u3bpFRHkr65QvX16YyFQ6uiMlJUVuFRH2czh//jxpaGjkW8WKKdf79+8pOjqabG1t5SYy5RsExZC9eQsJCaFq1aoJN2+RkZFkYmJCgwcPpgcPHhBR3itJ3bt3lxs9zTfWyhMfH0+jR4+m+vXrk4GBgdwIKQ5IFY3k5GRydnamP//8Uy5dNjiVnp5Od+/epU+fPglpXG8Ub+rUqWRkZETr168XXnMlIrp48SJ5eXlR48aNC+wDcNkUjbVr15KnpycR5S3KULZsWTp27BgR5QUIr1y5QkQkN1qa+wLsZ6Wm7DmtfhUkM8Hl+PHjsXXrVgQFBaFs2bKYM2cOZsyYgerVq8PFxQWPHj1CVlYWmjdvDiBv4rkWLVqgX79+QhpjxZ1IJEJsbCzKlSuHJUuWYO7cudi2bRtatGiB5ORkrFy5Eq1bt4a9vT38/PwA8ISMP5M6deqgZs2aeP78ubKzwv7ft2/fMGzYMHz8+BEuLi5YvXo1AK43iiDtE0jPa3h4OG7fvo158+bB0tISANChQweIRCKMGjUKIpEIPj4+8PT0hK2tLapWrQqAy0bZjIyM4Ofnh6lTp6J06dLYv38/1NXVkZubCzU17iIrGhEhJSUFL1++hIGBAQAI515dXR1JSUl4/fo17O3tYWtrK/c9rjeKdeHCBWzbtg27du2Cm5sbgL/avfr162Py5MlYvHgxfH19UbZsWWEfAFw2RURDQwMvX77EvHnzEBISgi1btqBVq1YAgJMnT+LEiRNYtmwZ9PX1AfAiGuznxlfcf0haif39/bFq1SpcvXpVuEA6OzujUqVKOH/+PFxcXGBoaAg1NTUsW7YMHh4eGD16NNq2bSsEpLhRYMVNQTdeampqqFChAsaOHYtLly5h+/btaNmyJQDgyZMnOHXqFFxcXOS+wx2dn4eWlhb27duHSpUqKTsr7P+VLFkSCxcuRGxsrHC94aBH4ZG9dmdnZ0NDQwMikQgXL17EvHnz8PHjR3Ts2BFA3o21qqoq2rdvDwAYNWoUvn79iuXLlwsBKb6x/jkYGRkhJCQEpUuXhoqKCgekFOj79kgkEsHExASmpqZYvXo13N3doaamJux37949HDlyBMbGxjA0NJT7HlOsz58/o2TJkrCzs8tXbmKxGPXq1cOYMWNw7Ngx1KtXT4k5/f0VtDolADRu3Bjh4eGYNWsWNm7cKKzqHh8fj1WrVqFJkyZCQArgesN+btwb+i+kpqZix44dsLGxQWZmJnJzcwHkdWiqVasmLNNtbW2N9u3bY+PGjejUqROsrKywYMECAByQYsWPWCwWOjNPnz7F27dvAeTVm27duuHAgQPo0aMHmjVrBgB4/fo1Bg8ejIoVK6Jx48bKyjb7B6QBKWnbx5TPyspK7gEIBz0Kh+y1e+XKlfD29kbLli0RHBwMV1dXBAQEoGzZsliyZAliY2OhpqYGsVgMAGjfvj2Cg4NhYmICIyMj4ZjcF/h5lC1bFioqKpBIJByQUhDZvsD169fx7NkzJCcnAwD8/Pzw4MEDDBo0CACQlZWFuLg4jBw5EgkJCXIBKVY0cnJy8OrVKyQlJQl1QyQSgYhw8uRJPHr0CA0bNkRgYCBUVVWF9o4VLtmA1Pbt27F+/Xrs3r0bQF4frH///rC3t8fq1auxbds2hIWFoWXLljAyMsLChQsBcB+N/RpExH+p/4i0Q/r69Wt07twZZcqUwbRp09CkSRMsWrQIs2bNwuPHj2FiYgIASElJQWpqKj58+ABHR0cA/MSaFW89e/bEhQsXUKJECdSsWVO4qPr7+yMoKAgNGjQAAHz69AlVqlTBgQMHAHAglzGmXLJt0IQJE7B582Z069YNV65cwbt379CjRw8sXboUa9aswYYNG2BlZYX58+fDyMhIGDEl24Zxm8aKG9m/+c6dO+Pu3bt49+4d+vTpgwEDBsDZ2Rnr16/HnDlzoKamBn19fSQkJMDS0pL7Agr2o3uTd+/eoUOHDnB2doaPjw/MzMwAAJmZmWjTpg1atWoFHx+fos5usSJbNl27dsWNGzdgbGyMW7duoWfPnggICICJiQn27t2L7du34+zZs6hduzZsbGywePHifMdg7GfGQan/gjRa/fr1a3h5ecHU1BRGRkbYs2cP9u/fDzc3tx8O++aLKStuZJ/uhISEYP369ViyZAkePXqEdevWQU1NDbdv3wYA7N27F48ePUJOTg6qV6+Onj17AuCLKWPs5+Hj44M1a9bg8uXLqFGjBrKysjB69GgcOHAAV65cQeXKlREWFoadO3eievXqCAwMhJGREbdjrFiT/ftfuXIl1q5diw0bNuD69euIiIiArq4ufH194ebmhjdv3uDPP/+Erq4uypcvj379+uU7Bis8sud17dq1ePToERITE9G6dWt07doVa9euxZ9//gljY2MMHToUmZmZWLVqFT5+/Ijr16/zqMIiMmzYMFy8eBHHjx9HhQoVMGHCBISEhMDLywthYWGoWLEigLyHuvr6+sL9Jtcb9ivhoNR/SXqj/erVK3Tp0gW3bt1CUFAQJk+eDICDT4x9LywsDFlZWbCyskLbtm0hkUhw9epV9O/fH9ra2kJg6vt35vliyhj7WZw4cQLt27fHwIEDsXz5ciE9Ojoanp6eOH78uDAqevny5di+fTv09PQQHh6O0qVLKyvbjBW5H/WDd+zYgWPHjqF169bo1q0bAOD06dOYP38+1NXVMWHChAIXA+K+gOJNmTIF4eHhGDJkCN6+fYsLFy7Aw8MDy5Ytw/r163HgwAEcOXIEtra2MDIyQmRkJNTV1X841xH778nWm8zMTGhpaYGI8OLFC8ydOxcDBw5EgwYNEBQUhMWLFyMgIABTp05Fu3btMGPGDGGBjYKOx9ivgFv5/5L0vekqVapg3759cHBwwKlTp3DmzBkAPEcEY7Ju3bqFOXPmwNfXV3iipqKiAmdnZ/z555/Izs4WbuS+79hwJ5Qx9rOoWbMmBgwYgLt37yIwMFBI379/P3R0dFClShUhbdSoUfDw8ICjoyMHpFixI+0HX758WUi7ePEipkyZgh07duDr169CetOmTeHn5wexWIyQkBDhVT1Z3BdQrFOnTmHv3r04ePAg5syZAy8vL8THx6N27doAgIEDB2L//v14/PgxoqKicOjQIWGFSg5IFR5pvQkODsb48ePx5csXiEQiGBgYoFOnTnB2dsa+ffuwevVqrFu3DiNGjMDw4cOxfft2jBkzBp8/fy7weIz9Kril/x9IA1OmpqbYvXs3Pn/+jPnz5+Po0aPKzhpjSvX9wMsaNWpg9erVqFy5svB+O5DXyXRxccH69evx6tUrzJgxo6izyhhj/5ixsTH8/f1hb2+PAwcOYNWqVQgODsb69euxY8cOlCtXDhKJBBKJBADg6+sLf39/ADzJLCt+oqKi0K9fP8yfPx8A4OrqipCQEFhYWGDfvn24ceOGsG+TJk3g4+ODuLg4xMTEKCvLxYa0jZL68OED9PT0ULduXezevRt9+vTB0qVL0b9/f6SmpuLUqVMQi8WoWrUqypcvD5FIxAsCKEh0dDSmTp2Kc+fOITAwEB8/fkSpUqXQqlUraGho4Pz583BzcxNWqi5dujTGjh0Lc3NzuVX2GPsVcVDqH/q+EZcdMbVnzx48fPgQ9+/fV1LuGFM+sVgsPJlJS0vDt2/foKOjA3d3dyxatAjPnj1Dhw4dhP1FIhHq1q2L69evY/bs2crKNmOM/SNGRkaYNm0a6tSpg5CQEPj5+WH37t1wcXFBTk4OVFRUoKKiIheE4lcoWHFkY2ODZs2a4dChQ8LIQi8vL/j7+yMpKQnLli3DrVu3hP2bNGmCLVu2YMKECcrKcrEhHXl27949AICmpiYqVKiAQ4cOoX///ggKCsKwYcMAAGfPnsXhw4fx6dOnAo/BCleFChVgYGAANTU1vHjxAvPnz8fnz5+hoaGBrKwsPHnyBImJicjKykJ8fDz27dsHDw8PrFq1CgA/AGG/Np5T6j+4ffs29PT0YGpqWuB26fvUX758gZ6eXhHnjrGfg+yN16BBgxATE4OvX79i/vz5aNu2LXJycnDo0CFMnDgRdnZ22LdvX75j8LwRjLFfwcePHxEYGIizZ8+iT58+mDhxIoD88+IxVpx9+PAB8+bNw/Xr19G+fXv4+fkBALZt24YlS5bAxsYGY8aMEV4Tk+JArmLs2rULL168gI+PD8aPH49Hjx7h4MGD+Pz5M2xsbJCSkoJ169ZhwIABAPLmNfLy8oKBgQE2btzIZaJg0j7wmjVrsH//fpibm+PatWuoX78+/Pz8oK+vj5MnT6Jly5aoXr06kpKSUKdOHRw8eFDZWWesUPAd4N949+4dBg4ciOHDh+Pbt28F7qOqqgoiEgJS34+oYux3JztCatiwYbh8+TI8PDxgZ2cHT09PhIWFQV1dHW3btsWSJUtw7949uLm55TsOB6QYY78CQ0ND+Pr6omHDhtizZw+CgoIA5J8Xj7HiTHZk4YEDB4QRUz169MDEiRPx6NEjzJw5E69fv5b7Hgc/Cp9YLEZsbCz8/PzQrFkzrF+/HsHBwdDQ0EDFihWxY8cOlCpVCleuXMGxY8dw9OhRtG/fHrGxsVi/fj1EIhGPwilEsucyIyNDLq1atWqQSCQYPXo0evXqhQsXLgiv8jVv3hxXr17F0KFDMX/+fCEgxfee7HfAI6X+349GaYSGhkJPT09Yop4xVrB79+5h06ZNGDBgAKytrQEAQUFB8PPzw9KlSzFmzBjk5ORg9+7duHHjhtwcU4wx9qv58OEDAgMDcfjwYYSFhcHDw0PZWWLsp/OjEVPr16/H27dvMWvWLCXn8Pcme39Tt25d3LhxA+PHj8fixYuFbbm5uThx4gTGjBmD7OxsGBgYwNTUFDt27OBV9hQoJCQEly5dwqRJk1CrVi1oa2sDADw9PSESibBv3z4sWLAA+/btg6urK6ZMmQIjIyO5Y/BbBux3wUEpyA+5v3XrFlRUVKCqqopatWrl2zc3NxdqamrcCDAmY9OmTejXrx/09PRw5MgRODk5CduCgoIwffp0LF68GGPGjJGrbzxMnzH2K4uNjcXp06fRu3dvZWeFsZ+WNDB18+ZNtGvXDr6+vnLbuS+geHFxcdixYwfevn2LsLAwBAYGYurUqQD+ug9KSUlBcnIyVFRUUKFCBYhEIuG+hxUu6at4QN6ows6dO8PU1BSTJ0/G3bt3MXfuXMyaNQvW1taYPXs2jhw5Amtra4SGhkJXV1fJuWes8BX7VkYikQg3yD179sTjx4+RkJAAXV1ddO3aVVg9BwBevnyJsLAwjBs3DpUrV1ZSjhlTvu+fmvXp0wfPnj1DYGAg7t+/LxeUmjp1KkQiEcaNGwdLS0vhIgzwMH3G2K+tYsWKQkCKb6wZK5j0Vb7AwECsW7cONWvWRLt27YTtXG8Ua/fu3fD19cWVK1dQvnx5mJmZYeLEiRCJRJgyZYrQn3vy5Anq1q0rfI9X2VOcmjVrYvjw4Xj79i3U1dVhYWGBtWvX4tSpU7C3t8edO3cQGRkJa2trzJgxA2lpaShRogQHpNhvq9gP9ZGOdurfvz9u3LiBnTt34tq1azAxMUFgYCDevXsnvOd77do17NmzB/v371dmlhlTOmkHJjQ0FNevXwcAzJ07FyNHjsSIESMQGRkpt/+UKVNw8OBBuYAUY4z9TvjGmrEfMzIywtSpUxEQECAXkGKKp6mpCXV1dcTFxQEABg8ejKVLl2LatGmYM2cO4uPj0b59eyxZskRuviN+I0RxjIyMMH36dFSqVAlJSUkQi8W4desWWrZsiaSkJLx48QLHjh0T5pwKCgrCzJkzAfAqe+z3xK/vAfj8+TO6deuGhQsXwsnJCYsWLcLChQuxefNmtGzZEikpKShVqhSAvOGWzZs3V3KOGVO+uLg4mJmZoU2bNpgzZw7s7OwAACNHjsSGDRuwbds2eHp65vsev/rKGGOMFW88slAxftTHql+/PsqVK4dDhw4ByFtdb9OmTRg2bBgsLS2hpqaGmzdvQl1dvaizXKzFx8cjMDAQly9fRr9+/TBq1CgAwMGDB1G/fn2UL19erky53rDfFQelkLfKXu3atXHhwgVERUUhICAA27ZtQ6tWrZCcnIyFCxfCy8tL7pUkvrFmxU1Bf/OPHz9GmzZtUKtWLcyZMwf29vYAgDFjxmDdunVYt24dvL29lZBbxhhjjLHiKTs7GxoaGsLnkydPYurUqQgNDZVbAfnp06d49eoVWrRoAVVVVZ5DSgmkc65dvXoVXl5ecnOu8f0mKy6K3V95QctmlilTBg0bNsTkyZMxa9Ys7Nq1C61atQIAvHjxAleuXEFSUpLcd7iBYMWN9G8+MTERQN7TGisrKxw5cgR37tzBtGnTcPfuXQBAWFgYOnXqhFOnTiktv4wxxhhjv7uePXsiJCRE+Lx06VLY29tj0aJFiI+PBwDY2dkhJycHx48fF/aTSCSoUaMGWrduDVVVVYjFYg5IKYF0zjVnZ2ccPHgQQUFBwja+32TFRbH6SxeLxULlfvbsGZ49ewYA0NXVhZubGw4fPoxu3brB2dkZQF5Aql+/fqhYsSK/sseKJelASun/Bw8ejL59+yI2NhYikQhEBGtra0RFReHy5cuYOXMmbt68CQCIiIjA+vXrlZZ3xhhjjLHfWWJiIsqXL4+AgACsWbMGANCpUyfUr18fx44dg42NDebOnYuEhAQEBQVh7dq1uH//PoD8AQ/ZBWxY0ZIGppycnLBmzRocPnxY2VlirEgVy9f3unfvjkuXLkEikcDR0VGYuHz69OlYvXo1zM3NoaOjg0+fPqFq1arCpM38Hi8rDmT/zpOTk6GjowMigrq6Ok6cOIG2bdvC29sbc+bMgYmJiTC0eOHChfD19UWjRo3w559/wszMLN/xGGOMMcZY4YmPj8cff/yB0NBQBAUFYfjw4QCAr1+/YuvWrTh06BAePXqEqlWr4sWLF5gxYwYGDRqUbyVlpnyxsbE4ffq0sKorY8VFsQhKyTa6ixYtwubNmxEcHIz4+HjMmjULenp6OHnyJHR1dXHo0CE8ffoU6enpqFatGrp37w6A3+llxYNsAGnp0qWIiorC58+f0apVK4wcORIVKlTAhQsX0Lx5c3Tv3h3z5s2DiYkJAGD58uV49uwZVFVVsXTpUmX+GowxxhhjxUZ8fDxWrFiBsLAwLFiwACNGjBC2ffr0CS9evMDcuXNx48YNlCtXDnfv3pWbc4r9fPihLitOikVQSmrVqlXIzMyEhYWFsBztkydP4OnpiVKlSuHkyZPCKnuyOCDFigPZi9+ECROwZcsWTJkyBefPn8fly5fh7e2NBQsWQEtLC9HR0WjWrBl69OiB7t27o3r16ujSpYvcUs98MWWMMcYYK3zSPpZsX+vdu3dYtWoVwsLCsGjRIgwdOhTAXw/ns7KycO3aNUyYMAHDhw/HgAEDuK/GGPspFJug1NOnT2Fra4ucnBxs3boV3bt3Fxrip0+fomPHjihVqhQOHjwIPT09ZWeXMaXx8/PD8uXLcevWLVStWhUA4OjoCCLCpUuXoKWlBQCIjo7GoEGDkJqaCrFYDBcXF+FVV8YYY4wxVvhkH5Z//PgRmZmZwpQJiYmJCA4OxrJly+QCUzk5OVBXV0dWVhY8PT1RtWpVLFu2TGm/A2OMyfpth/98H2urUaMGjh8/DgsLC2zcuBEAhCcMNWrUwN69e/H06VP88ccfSsgtYz+HkydPYsGCBRgwYAAsLCwAAOnp6UhPT0dycjLOnj2L169fIzk5GW5ubjh9+jT27NmD8PBwISBV0AqXjDHGGGPs3yEiISA1c+ZMtGzZEi4uLrC3t8fmzZuhrq4OX19fjB49GlOmTMHatWsBAOrq6iAiaGpqwtjYGG/fvkVOTk6++yXGGFOG336k1JAhQ+Di4oIBAwYAAM6ePYtu3bqhXr16+SYw//DhA4yMjJSYW8aUKycnByNHjsTDhw/h7e2N3r17o1mzZkhJSUHDhg3x6tUrfPnyBd++fcPQoUNRuXJldOnSRfg+v+rKGGOMMaZYgYGBWLJkCUJDQ2FoaIgNGzbg/v376NWrF8aOHYvU1FQsW7YMc+fOxb59+9ChQwcAwLVr1zBw4EBERETA3t5eub8EY4z9v98+KNWvXz/s2LEDGzduRLdu3QD8FZhydXXF3r17832Hb6xZcSSdcyAnJwejRo3C7du3ERcXBysrK5w4cULY7+HDh9i3bx+2b9+OBg0aYOXKlUrMNWOMMcZY8fHlyxe0a9cOvXv3lpvQfMqUKcLodTc3N7x58wZRUVHo378/1NTUhP0+f/4MfX19ZWSdMcYK9FsFpX60tOn48eOxatUq/Pnnn8JqeufOnUPXrl1RvXp1XLhwoaizythPSRqQzcnJwcSJE7Fnzx4MHz4ckydPhqampty+8fHxMDY2BsCTmjPGGGOMKcKzZ8+QmJgINTU1ODo6AgAsLS0xbtw4DBs2DFlZWUIfrV69eqhUqRJ27Nghd4zc3FyoqKjwQ3fG2E/pt2qZpAGp58+fy6UvXboUQ4YMQf/+/bF9+3ZIJBI0atQImzZtgp2dnTKyythPSUVFBWKxGOrq6li8eDHatWuHgwcPYtmyZUhPTweQ17EBwAEpxhhjjDEFCg8Ph6enJ1q2bIkOHTpg2LBhAPLmyt22bRsAQFNTE9nZ2QAABwcHqKur5zuOmpoaB6QYYz+t36J1kp1YecWKFahRowaio6Pl9gkNDUXPnj0xatQo7Nu3DxKJBK1atcLy5csB5J8YnbHiSlVVVQhMLVu2DA4ODti9ezf++OMPpKWlyQ0BB8ABKcYYY4yxQrZ69WoMHToUY8eOxZ49e+Dp6YnIyEiEhIQgICAAjx8/hre3N4C/HszfvXsX5cuXV2a2GWPsv/ZLvr73dyMziAidOnXCpUuXsHv3bri5uQn7Hzt2DO7u7gCAS5cuwcXFpSizzdhP40fzpsnWLdk5pkaPHo3jx4/jjz/+QJs2bYo6u4wxxhhjxUZkZCQ6duyI/fv3o127dgCAlJQUNGrUCBYWFti9ezciIyMxfPhwlCtXDmZmZkhMTERycjLu3buX7wEiY4z9zH65Fkv2pvny5cu4d+8ezp8/Dzs7Ozg7O6NRo0bYu3cvvLy84OXlhX379sHNzQ0AoK2tjYULF8LExIQDUqzYkp177dWrV/j27RtMTU1RpkwZiEQiIWAlO2IqLCwMW7Zs4YAUY4wxxpgCZWVl4fjx4zA3N8ebN2+E9FKlSqFmzZpITU0FEaF9+/aoU6cOQkJCIJFIULJkSfj7+0NNTQ25ubkcmGKM/TJ+qZFSsgGpuXPn4uDBg8jKykKpUqVw48YNGBsbo3fv3ggICAAAdOzYEadPn8bMmTNhZmaG2bNno3Xr1liwYAEAXmWPFT+yf/M9e/bEq1evcPv2bbi7u8Pe3h7+/v75vvP9AgI8hxRjjDHGmOLEx8cjKCgIly9fhqenJ3x9fXH06FF4eHjgxIkTaNas2Q/7Yz9a+Ikxxn5Wv0xQSrbhnTBhArZu3Yr169fDwcEBFSpUwO3btxEYGIjz589j2LBhmDVrFgBg1KhROHjwIDQ0NODo6Ijt27cr89dgTCm+77j07dsX165dw+7du6GjowNvb28kJCQgKioKlSpVUmJOGWOMMcbYhw8fMG/ePNy+fRtmZmbCwjN9+/YVHjLyg0LG2O/glwlKSU2dOhVr167F5cuXUaNGDQB/3XC/ePECfn5+uHbtGlatWoVWrVoBAN68eQMVFRWYmpoC4BFSrPjIzs6GRCKBlpaW8OTsxYsX6NGjB9asWQN7e3usWLEC06dPx65du9C8eXOkpqZCV1dX2VlnjDHGGCvW4uPjMX/+fOzcuRMuLi6IjIwEwKOhGGO/l18qMnPixAmEhYXB29tbCEhJJBLhCYGFhQWmT5+OhIQEudX3zMzMhIAUEXFAihULOTk5GDRoEEaMGIH09HSh86Kuro709HSYm5sjODgY/v7+2L59O5o3b46EhARs3LgRjx8/VnLuGWOMMcaKN2NjY0ybNg1du3bFx48fERQUBCBvtb1fbFwBY4z90C8VnalZsyYGDBiAu3fvCvNCqaioQCKRAMh7alCrVi20atUK169fBxFBLBbLHYOHuLLigohgaGiIp0+fYtq0aUhPTxfS09PT0adPHyxevBhbt24VRhU+evQIkZGRSExMVGbWGWOMMcYYAENDQ/j5+aFOnTo4cOAApk+fDoDvaRhjv49fKihlbGwMf39/2NvbIzIyUnhaoKKiIgxjTUlJwfv37+Hk5ASRSMRDW1mxRETQ0NBAUFAQWrdujfv378PPzw/p6ekwMzPDlClTcODAAfTu3RutW7eGRCLB27dvMXLkSJiZmaF+/frK/hUYY4wxxhgAIyMj+Pn5wcLCAp8+feJRUoyx38ovt1aokZERpk2bhnnz5mHfvn0A8uaZkgafYmJioKKiAmdnZ2VmkzGlkkgkUFVVhYqKCmxtbXHz5k1s374dGhoaCAgIwLBhw/DmzRsEBQXh0aNHEIvFiIuLg5mZGTZs2ACAV9ljjDHGGPtZGBkZISQkBGXKlIFIJOJ+GmPst/HLTXQuJV2R4vr16/D09ISPjw8yMjLg7OwMe3t7bNq0SdlZZEzpPDw8kJmZCWNjYzx48ABfv35Fly5dMG/ePGhra2P//v04f/48NDU1UbVqVQwYMAAALwbAGGOMMfaz4n4aY+x38ssGpYC/AlO3bt1C8+bNsWfPHpiamuLo0aMAeKQHK97Wrl2LefPm4fLlyzA2NgYA+Pj4ICoqCk2bNsXs2bNRokSJfCu4cEeHMcYYY4wxxlhR+KXvPKWv8jk6OiIoKAjm5uZCQEp2VT7GiqPk5GTo6OigdOnSQpq/vz9q1aqFtWvXIiAgAGlpafnmXeOAFGOMMcYYY4yxovDL330aGRnB19cX69atw4EDBwDwSA9WvElXnDQ0NISKigrevXsHIK9e6OjoYOzYsdDS0sLevXuxd+9eZWaVMcYYY4wxxlgx9ku/vlcQDkix4ub71++kvnz5Ajs7Ozg7O2PVqlUwMDAAAJw5cwarV69Gly5d0KlTp6LOLmOMMcYYY4wxBuA3DEoxVpzIBqQ2b96MN2/eoHr16rC1tUWNGjVw9+5dNGnSBE5OTnB3d0flypXh4+ODdu3aITg4GADPvcYYY4wxxhhjTDk4KMXYL0p2VGDHjh3x9OlT6OjoQFdXFwAQHByM2rVrIyYmBqNHj8b79+8hFovh4OCALVu2AOCAFGOMMcYYY4wx5eGgFGO/uLFjx+L8+fM4ePAgTExMMGzYMISHh8Pa2hrLly9HvXr1kJGRgezsbKSkpMDU1BQAv+rKGGOMMcYYY0y5+I6UsV9Eeno6pkyZgqSkJCHt3bt3ePHiBRYsWAATExOEhIRg586dmDlzJjQ0NDBmzBjcunUL2traKF26tBCQIiIOSDHGGGOMMcYYUyoeKcXYL+LBgwewtbVFt27dsHr1apQqVQoAcOvWLVSpUgWXLl3CiBEjsHLlSri7u8PHxwcLFy5ExYoVcebMGVStWlXJvwFjjDHGGGOMMfYXHirB2C+iZs2auHLlCk6cOIFBgwYhOTkZAFC7dm2ULVsWZ8+ehZubG9zd3QEAxsbG8Pb2xpw5czggxRhjjDHGGGPsp8NBKcZ+UgUNYqxbty4OHz6MkydPYvDgwUhJSRG2icVi3Lt3DzExMfj8+TO2b9+Ohg0bol+/fgDy5pBijDHGGGOMMcZ+FhyUYuwnJLsq3suXL/HgwQNhm7OzM44ePYpTp07JjZhq2bIlypYtCxcXFzg5OaFs2bIYMmSIcDyeQ4oxxhhjjDHG2M+E55Ri7CcjG5CaPXs2du7ciU+fPsHAwADnzp1D+fLlAQBXr15FmzZt0KxZM2zatAna2tq4cuUKYmJikJubKzdCigNSjDHGGGOMMcZ+NhyUYuwnIhuQGjduHLZs2YJVq1ahVKlSmDhxImrVqoUtW7YI+1+5cgVt2rRB8+bNER4ejhIlSsgdjwNSjDHGGGOMMcZ+VhyUYuwn5OPjgzVr1uDKlSuoXr06AGD69OnIyspC8+bNUbFiRRgaGkJfXx9Xr16Fu7s7HBwccODAgXyBKcYYY4wxxhhj7GfEQSnGfjInTpxA+/btMXDgQCxfvlxIt7CwgEQiQWZmJlJSUtCrVy/Mnj0bhoaGuHDhArZu3YqVK1cqMeeMMcYYY4wxxtg/x+/1MPaTqVmzJgYMGIC7d+8iLCwMAODi4gJzc3McO3YMcXFxmDhxIjZu3ChMgN6gQQMhIMVxZsYYY4wxxhhjvwIOSjH2kzE2Noa/vz/s7e2xZcsWGBoaoly5cjhy5AiqVasGkUiEKVOmoGTJkoiJicn3femcVIwxxhhjjDHG2M+Mg1KM/YSMjIwwbdo0uLi4QFtbG87OzlBXVxcmLX/9+jXKly8PU1NTJeeUMcYYY4wxxhj736gpOwOMsYIZGRnBz88PEokER48ehYaGBnx9fZGZmQlvb2/Y29vD3d1d2dlkjDHGGGOMMcb+JzzROWM/uQ8fPmDevHm4desWmjdvjj179qBixYo4fvw4AEAikQgjqBhjjDHGGGOMsV8FB6UY+wV8+PABgYGBWLNmDVq2bIkDBw4A4IAUY4wxxhhjjLFfFwelGPtFxMfH49SpU+jVqxcADkgxxhhjjDHGGPu1cVCKsV8QB6QYY4wxxhhjjP3qOCjFGGOMMcYYY4wxxoocD7VgjDHGGGOMMcYYY0WOg1KMMcYYY4wxxhhjrMhxUIoxxhhjjDHGGGOMFTkOSjHGGGOMMcYYY4yxIsdBKcYYY4wxxhhjjDFW5DgoxRhjjDHGGGOMMcaKHAelGGOMMfbTEolECAgIKNJ/8/Xr1xCJRNi4ceM/2l8Refz27RsMDAywZcuWQj3u9zZu3AiRSITXr18r9N8pLr5+/QodHR0cOXJE2VlhjDHGfgkclGKMMcaYHGmgQiQSITo6Ot92IoKpqSlEIhHatm2rhBz+9wICAoTf6e/+a9y4cYHfP3LkSJEGx0JDQ6Grq4vu3bsLad//Durq6qhcuTLGjBmDpKSkIsvbz2TBggUQiUQ4fvx4gdvd3d1RunRpxMXFFUl+ypcvj0GDBsHf379I/j3GGGPsV6em7Awwxhhj7OekpaWFrVu3ws3NTS793LlzeP/+PTQ1NRWeh4yMDKip/fvuSseOHVG1alXh87dv3zB8+HB4eXmhY8eOQrqhoSHMzMyQkZEBdXV1If3IkSNYsWJFkQSmcnJyEBoaivHjx0NVVTXf9pUrV6JkyZJIS0vDqVOnsGzZMty6davAAOLvbuLEidi6dStGjBiBBw8eQFtbW9i2a9cuHD16FCtWrECFChWKLE/Dhg1DWFgYTp8+jaZNmxbZv8sYY4z9ijgoxRhjjLECubu7Y9euXQgLC5MLDG3duhWOjo748uWLwvOgpaVVKMextbWFra2t8PnLly8YPnw4bG1t0atXL4X9u/+LQ4cO4fPnz+jatWuB2zt37gw9PT0AwNChQ9G9e3fs2LED165dQ926dYsyq0qnrq6ONWvWwNXVFXPmzEFgYCAAIDU1FePGjYOLiwuGDRum8HxIJBJkZ2dDS0sLVlZWqFmzJjZu3MhBKcYYY+w/4Nf3GGOMMVagHj164OvXrzhx4oSQlp2djd27d8Pb27vA76SlpWHixIkwNTWFpqYmatSogUWLFoGIhH1q1qyJJk2a5PuuRCJBxYoV0blzZyGtoPmaYmNjMWDAABgaGkJTUxM2NjbYsGHDv/xt//L9nFL9+vXDihUrhPxI//s7/yaPkZGRqFy5MiwsLP7R/g0aNAAAvHjxQi796tWraN26NUqXLo0SJUqgUaNGuHjx4j865tGjR9GgQQPo6OhAV1cXHh4eePjwodw+9+7dQ79+/WBubg4tLS0YGRlhwIAB+Pr1q9x+0gBR5cqVoampCQMDA7Ro0QK3bt0qlPxKA0+LFi3Co0ePAADTp0/Hp0+fsGbNGqioqCApKQnjxo0T/i6rVq2KoKAgSCQSuWMtWrQI9evXR/ny5aGtrQ1HR0fs3r07378pEokwatQobNmyBTY2NtDU1MSxY8eE7S1atMDBgwfl/u4ZY4wxlh8HpRhjjDFWoMqVK6NevXrYtm2bkHb06FEkJyfLzXUkRURo3749li5ditatW2PJkiWoUaMGJk+ejAkTJgj7devWDefPn8eHDx/kvh8dHY24uLgCjy318eNHuLi44OTJkxg1ahRCQ0NRtWpVDBw4ECEhIf/+ly7A0KFD0aJFCwBARESE8J+i8njp0iXUrl37H+dPOkl52bJlhbTTp0+jYcOGSElJwcyZMxEYGIikpCQ0bdoU165d+9vjRUREwMPDAyVLlkRQUBD8/f3x6NEjuLm5yU2IfuLECbx8+RL9+/fHsmXL0L17d2zfvh3u7u5ywZhhw4Zh5cqV6NSpE/744w9MmjQJ2traePz4caHkFwDmz58PfX19DB06FDdv3sSKFSswadIk1KpVC+np6WjUqBE2b96MPn36ICwsDK6urvD19ZX7uwTy5vJycHDA7NmzERgYCDU1NXTp0gWHDx/O92/F1kAAAAqySURBVG+ePn0a48ePR7du3RAaGorKlSsL2xwdHZGUlJQvkMcYY4yx7xBjjDHGmIw///yTAND169dp+fLlpKurS+np6URE1KVLF2rSpAkREZmZmZGHh4fwvcjISAJAc+fOlTte586dSSQSUUxMDBERPX36lADQsmXL5PYbMWIElSxZUvi3iIgA0MyZM4XPAwcOJGNjY/ry5Yvcd7t3707/1979x0Rd/3EAfx4noXHcEXFNQUcImPljMLG0HDgVdxx2mpkHYf5qsTZJwylOa4sc2lT8sTV/bMy8P9xMFNSKNBFHo81sSjnLVfLHkUtnHB7cDkzEu9f3j3af8fF+eITfs+bzsbmx96/P683bP9hr7x8Gg0HVNxSHw+E3to/dbhcAYrPZlLLS0lIJ9mfTw4yxr69PNBqNrFmzxq+uoqJCAMhvv/0mDodD2tra5MCBAzJs2DAxGo3S09MjIiJer1cyMjLEZDKJ1+tV+t++fVtSU1Nl9uzZSplvre12u4iIuN1uiY+Pl5KSEtW3b968KQaDQVUeaB6fffaZAJDm5malzGAwSGlpadA5DyTeUGprawWAJCQkyOjRo5X4KisrJTY2Vq5evapqv379etFqtXLt2rWgc7p7965MmDBBZs6cqSoHIFFRUXLlypWAsZw7d04ASE1NTVixExERPa64U4qIiIiCslqt+Ouvv1BfXw+32436+vqgR/dOnjwJrVaLVatWqcrXrFkDEcGpU6cAAGPGjEFWVhZqamqUNh6PB7W1tbBYLKrLqvsTEdTV1cFisUBE0NHRofwzmUxwuVx+R8IibbAxOp1OiIhq19P9nnvuORiNRjz77LN46623kJ6ejlOnTuHJJ58EAFy6dAmtra0oLi7GrVu3lO/39PRg1qxZaG5u9ju25nPmzBl0dXXhjTfeUMWu1WoxZcoUNDU1KW37r9OdO3fQ0dGBqVOnAoBqjvHx8fj++++DvoA3mHj7W7BgAQoKCuB0OrFnzx4lvqNHjyInJwdPPfWUak55eXnweDxobm4OOKfOzk64XC7k5OQEXLPp06dj3LhxAWPxrV8k7l0jIiL6L+NF50RERBSU0WhEXl4eDh06hNu3b8Pj8ajufOrv999/R1JSEuLi4lTlzz//vFLvU1hYiPfffx/Xr19HcnIyvvnmG7S3t6OwsDBoLA6HA11dXaiurkZ1dXXANu3t7QOd4kP1sGKUEHcR1dXVQa/Xw+Fw4JNPPoHdblclU1pbWwEAS5cuDTqGy+UKmPjy9Q12Qbder1d+djqd2LhxIw4fPuw3J5fLpfy8bds2LF26FKNGjUJ2djYKCgqwZMkSjB49etDx3u+FF17AyZMnMXnyZNWcLl++DKPRGLBP/9jr6+uxadMmXLp0Cb29vUp5oDvEUlNTg8bhW78H3T1GRET0uGNSioiIiEIqLi5GSUkJbt68CbPZjPj4+EGPWVhYiA0bNuDo0aMoKyvDkSNHYDAYkJ+fH7SPb7fMm2++GTSB0f+FvUdhsDEmJCRAo9Ggs7MzaJvc3Fzl9T2LxYKJEydi0aJFaGlpQVRUlBJDVVUVsrKyAo6h0+lCxn/w4EEMHz7cr77/K4xWqxXnzp1DeXk5srKyoNPp4PV6kZ+fr9rZZLVakZOTg+PHj6OhoQFVVVXYunUrjh07BrPZPKh4w+H1ejF79mysW7cuYP2YMWMAAN9++y3mzp2L3Nxc7N27FyNGjEB0dDRsNhsOHTrk1y/Yjj4Ayvr51omIiIgCY1KKiIiIQpo/fz7eeecdnD9/XnXk7n4pKSlobGyE2+1W7Zb69ddflXqf1NRUvPjii6ipqcG7776LY8eO4dVXX0VMTEzQ8Y1GI+Li4uDxeJCXl/cQZha+cHe8DDbGIUOGIC0tDXa7Paz2Op0OFRUVWL58OY4cOYKioiLl1T69Xj/gGHx9n3nmmZB9Ozs7cfbsWWzcuBEffvihUu7b9XS/ESNGYMWKFVixYgXa29sxadIkbN68GWazeVDxhiMtLQ3d3d0PHLuurg5Dhw7F6dOnVf8PbTbbgL/pWz/fLkEiIiIKjHdKERERUUg6nQ779u3DRx99BIvFErRdQUEBPB4Pdu/erSrftWsXNBoNzGazqrywsBDnz5/HgQMH0NHREfLoHgBotVosWLAAdXV1+Pnnn/3qHQ7HAGY1MLGxsQCArq6ukO0eRowvvfQSLl68GHZsixYtwsiRI7F161YAf7/8lpaWhu3bt6O7u3tAMZhMJuj1enz88cfo6+sL2ler1QLwP2Z4/+uCHo9HdZQP+DvhlZSUpByPG0y84bBarfjuu+9w+vRpv7quri7cu3cPwN9z0mg08Hg8Sn1bWxtOnDgx4G+2tLTAYDBg/Pjx/zhuIiKixwF3ShEREdEDhbrvx8disWDGjBn44IMP0NbWhszMTDQ0NODzzz9HWVmZsiPGx2q1Yu3atVi7di0SEhLC2iWzZcsWNDU1YcqUKSgpKcG4cePgdDrxww8/oLGxEU6n8x/PMZTs7GwAwKpVq2AymaDValFUVPR/iXHevHk4ePAgrl69qhwtCyU6OhrvvfceysvL8fXXXyM/Px/79++H2WzG+PHjsXz5ciQnJ+P69etoamqCXq/Hl19+GXAsvV6Pffv2YfHixZg0aRKKiopgNBpx7do1fPXVV5g2bRp2794NvV6P3NxcbNu2DX19fUhOTkZDQ4PfDi+3242RI0fi9ddfR2ZmJnQ6HRobG3HhwgXs2LEDABAVFfWP4w1HeXk5vvjiC7zyyitYtmwZsrOz0dPTg59++gm1tbVoa2tDYmIi5syZg507dyI/Px/FxcVob2/Hnj17kJ6ejsuXLw/om2fOnIHFYuGdUkRERA/yyN79IyIion8lm80mAOTChQsh26WkpMicOXNUZW63W1avXi1JSUkSHR0tGRkZUlVVJV6vN+AY06ZNEwDy9ttvB6wHIBUVFaqyP//8U0pLS2XUqFESHR0tw4cPl1mzZkl1dXXYc3Q4HAHHFhGx2+0CQGw2m1J27949WblypRiNRtFoNNL/T6iHHWNvb68kJiZKZWWlqryiokIAiMPh8OvjcrnEYDDI9OnTlbIff/xRXnvtNXn66aclJiZGUlJSxGq1ytmzZ5U2vrW22+2q8ZqamsRkMonBYJChQ4dKWlqaLFu2TC5evKi0+eOPP2T+/PkSHx8vBoNBFi5cKDdu3FD9Pnp7e6W8vFwyMzMlLi5OYmNjJTMzU/bu3es3h3DifZBgvyO32y0bNmyQ9PR0eeKJJyQxMVFefvll2b59u9y9e1dp9+mnn0pGRobExMTI2LFjxWazKWP2B0BKS0sDxvDLL78IAGlsbAw7biIioseVRiTE8y5EREREFHGVlZWw2WxobW1VjsrRf0NZWRmam5vR0tLCnVJEREQPwDuliIiIiP5lVq9eje7ubhw+fPhRh0IDcOvWLezfvx+bNm1iQoqIiCgM3ClFREREREREREQRx51SREREREREREQUcUxKERERERERERFRxDEpRUREREREREREEcekFBERERERERERRRyTUkREREREREREFHFMShERERERERERUcQxKUVERERERERERBHHpBQREREREREREUUck1JERERERERERBRxTEoREREREREREVHEMSlFREREREREREQR9z9j0WDbdCrJtQAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
@@ -1217,21 +1097,14 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": null,
"metadata": {
"id": "K0vk3ol5WMvN"
},
"outputs": [
{
"data": {
- "text/markdown": [
- "It appears there might be a persistent issue in displaying the dark theme on your end, as I have included the `plt.style.use('dark_background')` line in the previous responses, which is designed to apply a dark theme to the plot.\n",
- "\n",
- "If `plt.style.use('dark_background')` is not producing the desired effect, we can explicitly set the background color of the figure and axes, and the color of the text elements, to ensure a dark theme is applied.\n",
- "\n",
- "Here's the updated Python code that explicitly sets these colors for a dark theme:\n",
- "\n"
- ],
+ "text/markdown": "To give the chart a dark theme, you can utilize Matplotlib's built-in `dark_background` style. This style automatically adjusts the background, text, and other elements for a dark aesthetic.\n\nHere's the modified Python code:\n\n",
"text/plain": [
""
]
@@ -1241,74 +1114,159 @@
},
{
"data": {
- "text/markdown": [
- "```python\n",
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "\n",
- "# Data for Denis Villeneuve's 10 most recent movies (from newest to oldest)\n",
- "movies = [\n",
- " \"Dune: Part Two (2024)\",\n",
- " \"Dune: Part One (2021)\",\n",
- " \"Blade Runner 2049 (2017)\",\n",
- " \"Arrival (2016)\",\n",
- " \"Sicario (2015)\",\n",
- " \"Enemy (2013)\",\n",
- " \"Prisoners (2013)\",\n",
- " \"Incendies (2010)\",\n",
- " \"Polytechnique (2009)\",\n",
- " \"Maelström (2000)\"\n",
- "]\n",
- "\n",
- "runtimes = [166, 155, 163, 116, 121, 90, 153, 131, 77, 87]\n",
- "\n",
- "# Create a figure and an axes object\n",
- "fig, ax = plt.subplots(figsize=(12, 7))\n",
- "\n",
- "# Set the background color of the figure and axes for a dark theme\n",
- "fig.set_facecolor('#1a1a1a') # Dark gray for the figure background\n",
- "ax.set_facecolor('#2a2a2a') # Slightly lighter dark gray for the plot area background\n",
- "\n",
- "# Create a bar chart\n",
- "# Using a light color for bars to contrast with the dark background\n",
- "bars = ax.barh(movies, runtimes, color='skyblue')\n",
- "\n",
- "# Set label and title colors to white for visibility\n",
- "ax.set_xlabel(\"Runtime (minutes)\", color='white')\n",
- "ax.set_ylabel(\"Movie Title\", color='white')\n",
- "ax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", color='white')\n",
- "\n",
- "# Set tick label colors to white\n",
- "ax.tick_params(axis='x', colors='white')\n",
- "ax.tick_params(axis='y', colors='white')\n",
- "\n",
- "# Set spine colors to white\n",
- "ax.spines['bottom'].set_color('white')\n",
- "ax.spines['top'].set_color('white')\n",
- "ax.spines['left'].set_color('white')\n",
- "ax.spines['right'].set_color('white')\n",
- "\n",
- "# Invert y-axis to have the most recent movie at the top\n",
- "ax.invert_yaxis()\n",
- "\n",
- "# Add runtime values on top of the bars\n",
- "# Ensure text color is visible against the dark background\n",
- "for bar in bars:\n",
- " width = bar.get_width()\n",
- " ax.text(width + 2, bar.get_y() + bar.get_height()/2, f'{width} min', va='center', color='white')\n",
- "\n",
- "ax.set_xlim(0, max(runtimes) + 30) # Adjust x-axis limit for text\n",
- "\n",
- "plt.tight_layout() # Adjust layout to prevent labels from overlapping\n",
- "plt.show()\n",
- "```"
- ],
+ "text/markdown": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# Data for Denis Villeneuve's 10 most recent movies and their runtimes\nmovies = [\n \"Dune: Part Two (2024)\",\n \"Dune (2021)\",\n \"Blade Runner 2049 (2017)\",\n \"Arrival (2016)\",\n \"Sicario (2015)\",\n \"Prisoners (2013)\",\n \"Enemy (2013)\",\n \"Incendies (2010)\",\n \"Polytechnique (2009)\",\n \"Maelström (2000)\"\n]\n\nruntimes = [166, 155, 163, 116, 121, 153, 91, 131, 77, 87] # Runtimes in minutes\n\n# Apply the dark background style\nplt.style.use('dark_background') # [2, 4, 5]\n\n# Create the bar chart\nfig, ax = plt.subplots(figsize=(12, 7)) # Adjust figure size for better readability\nbars = ax.bar(movies, runtimes, color='skyblue') # Skyblue works well against dark background\n\n# Add titles and labels\nax.set_xlabel(\"Movie Title (Release Year)\", fontsize=12, color='white')\nax.set_ylabel(\"Runtime (Minutes)\", fontsize=12, color='white')\nax.set_title(\"Runtimes of Denis Villeneuve's 10 Most Recent Movies\", fontsize=14, color='white')\nplt.xticks(rotation=45, ha='right', color='white') # Rotate x-axis labels for better readability\nplt.yticks(color='white') # Set y-axis tick label color\n\n# Add the runtime values on top of the bars\nfor bar in bars:\n yval = bar.get_height()\n ax.text(bar.get_x() + bar.get_width()/2, yval + 2, round(yval), ha='center', va='bottom', fontsize=9, color='white')\n\n# Improve layout and display the plot\nplt.tight_layout()\nplt.show()\n```",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/markdown": "\n\nBy adding `plt.style.use('dark_background')`, the plot's background becomes dark, and the text and axes elements automatically adjust to a lighter color for better readability. I've also explicitly set the color of the labels and title to white for clarity, although `dark_background` often handles this default.",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "
\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
}
],
"source": [
@@ -1328,14 +1286,14 @@
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": null,
"metadata": {
"id": "vtfTv4ieFjYt"
},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
""
]
@@ -1367,17 +1325,13 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 50,
"metadata": {
"id": "CUhcThmnK0mt"
},
"outputs": [],
"source": [
- "# Live API only works with v1alpha API and with the gemini-2.0-flash-exp model at the moment\n",
- "\n",
- "client = genai.Client(http_options={'api_version': 'v1alpha'})\n",
- "\n",
- "LIVE_MODEL_ID = \"gemini-2.0-flash-exp\""
+ "LIVE_MODEL_ID = \"gemini-2.5-flash-preview-native-audio-dialog\" # @param [\"gemini-2.0-flash-live-001\", \"gemini-live-2.5-flash-preview\",\"gemini-2.5-flash-preview-native-audio-dialog\"] {\"allow-input\":true, isTemplate: true}"
]
},
{
@@ -1395,8 +1349,9 @@
},
{
"cell_type": "code",
- "execution_count": 22,
+ "execution_count": 46,
"metadata": {
+ "cellView": "form",
"id": "YEAdoUV2dH1o"
},
"outputs": [],
@@ -1433,9 +1388,7 @@
" async for msg in stream.receive():\n",
" all_responses.append(msg)\n",
"\n",
- " if text:=msg.text:\n",
- " print(text)\n",
- " if audio_data := msg.data:\n",
+ " if audio_data := msg.data: # This is what triggers the warnings, use the full path to access the audio data\n",
" turn_buf.write(audio_data)\n",
" if m := re.search(\n",
" 'rate=(?P\\d+)',\n",
@@ -1503,7 +1456,7 @@
},
{
"cell_type": "code",
- "execution_count": 23,
+ "execution_count": 51,
"metadata": {
"id": "0wXCugI3eOtS"
},
@@ -1512,7 +1465,7 @@
"name": "stderr",
"output_type": "stream",
"text": [
- ":81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
+ "/tmp/ipython-input-1749242392.py:79: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
"Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n",
" await strm.send(input=query, end_of_turn=True)\n"
]
@@ -1521,519 +1474,136 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Buffering"
+ "Buffering......................................................................................................................................................................................................................................................................................\n"
]
},
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "await run('Who won the skateboarding gold medals in the 2024 olympics?');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "evvh0DgdpSBV"
+ },
+ "source": [
+ "Now re-run with the Search tool enabled."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "id": "HYGEtdjupXM7"
+ },
+ "outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
+ "/tmp/ipython-input-1749242392.py:79: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
+ "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n",
+ " await strm.send(input=query, end_of_turn=True)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
- "......."
+ "Buffering"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
- "......."
+ ".."
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....\n"
- ]
- },
- {
- "data": {
- "text/html": [
- "\n",
- " \n",
- " "
- ],
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "await run('Who won the skateboarding gold medals in the 2024 olympics?');"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "evvh0DgdpSBV"
- },
- "source": [
- "Now re-run with the Search tool enabled."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 24,
- "metadata": {
- "id": "HYGEtdjupXM7"
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- ":81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
- "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n",
- " await strm.send(input=query, end_of_turn=True)\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Buffering"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
- "......."
+ ".."
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
- "......."
+ ".."
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
- "......"
+ ".."
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
- "..........\n"
+ "..............................................................................................................................................................................................................................................................................................................................................................................................\n"
]
},
{
@@ -2041,7 +1611,7 @@
"text/html": [
"\n",
" \n",
" "
@@ -2069,7 +1639,7 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": null,
"metadata": {
"id": "_UUZ5V_Upzpm"
},
@@ -2097,7 +1667,7 @@
},
{
"cell_type": "code",
- "execution_count": 26,
+ "execution_count": null,
"metadata": {
"id": "7-nQ1Sp9yM33"
},
@@ -2106,7 +1676,7 @@
"name": "stderr",
"output_type": "stream",
"text": [
- ":81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
+ "/tmp/ipython-input-4150174230.py:81: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
"Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n",
" await strm.send(input=query, end_of_turn=True)\n"
]
@@ -2123,20 +1693,7 @@
"output_type": "stream",
"text": [
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
+ "WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
@@ -2145,200 +1702,18 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- ":55: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
- "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n",
- " await stream.send(input=tool_response)\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- ".....Tool call..."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "......."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....."
+ ".."
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['executable_code'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-data parts in the response: ['executable_code'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n",
+ "/tmp/ipython-input-4150174230.py:55: DeprecationWarning: The `session.send` method is deprecated and will be removed in a future version (not before Q3 2025).\n",
+ "Please use one of the more specific methods: `send_client_content`, `send_realtime_input`, or `send_tool_response` instead.\n",
+ " await stream.send(input=tool_response)\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['code_execution_result'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-data parts in the response: ['code_execution_result'], returning concatenated data result from data parts, check out the non data parts for full response from model.\n"
]
@@ -2347,7 +1722,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "......."
+ ".Tool call.."
]
},
{
@@ -2397,21 +1772,6 @@
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
- "WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "....."
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n",
"WARNING:google_genai.types:Warning: there are non-text parts in the response: ['inline_data'], returning concatenated text result from text parts, check out the non text parts for full response from model.\n"
@@ -2421,7 +1781,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "....\n"
+ ".......\n"
]
},
{
@@ -2429,7 +1789,7 @@
"text/html": [
"\n",
" \n",
" "
@@ -2475,7 +1835,7 @@
"\n",
"tools = {'tools': [search_tool, set_climate_tool]}\n",
"\n",
- "responses = await run(\"Look up the weather in Paris using search and set my climate control appropriately.\", tools)"
+ "responses = await run(\"Look up the weather in Paris using search and set my climate control appropriately. I trust your judgement, so just do it.\", tools)"
]
},
{
@@ -2489,7 +1849,7 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": null,
"metadata": {
"id": "ZzZlE9IFnwpS"
},
@@ -2498,7 +1858,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "set_climate(strength=3, mode=cold) # id=function-call-12389289546227236364\n"
+ "set_climate(mode=cold, strength=7) # id=function-call-8243969279664206973\n"
]
}
],
@@ -2520,6 +1880,8 @@
"\n",
"\n",
"\n",
+ "Search grounding is not the only way to ground your requests, you can also use Youtube links and URL context. Check the [Grounding](./Grounding.ipynb) guide for more info on those capabilities.\n",
+ "\n",
"* For more demos showcasing multi-tool use in the Multimodal Live API, check out the [Plotting and Mapping cookbook](../examples/LiveAPI_plotting_and_mapping.ipynb).\n",
"* To get started with the Live API with the Python SDK, check out the [starter guide](./Get_started_LiveAPI.ipynb).\n",
"* To learn more about tool use in the Live API, check out the [Live API Tool Use cookbook](./Get_started_LiveAPI_tools.ipynb).\n",