diff --git a/notebooks/rag/vision_rag_voyageai_claude.ipynb b/notebooks/rag/vision_rag_voyageai_claude.ipynb new file mode 100644 index 0000000..58b9485 --- /dev/null +++ b/notebooks/rag/vision_rag_voyageai_claude.ipynb @@ -0,0 +1,781 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "1-AXM-y3j-PU" + }, + "source": [ + "# Vision RAG: Enabling Search on Any Documents" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, you will learn how to implement Vision RAG applications using Voyage AI's multimodal embedding models and Anthropic's vision-capable LLMs.\n", + "\n", + "Vision RAG is especially useful for extracting information from complex documents like PDFs, slide decks, and figures. With Voyage AI’s multimodal embeddings, retrieval works on both text and images, including screenshots of those documents. Paired with vision-capable LLMs, this extends traditional text-based RAG into Vision RAG, enabling retrieval and reasoning that go beyond text alone.\n", + "\n", + "To showcase the power of multimodal embeddings and vision-capable LLMs, we’ll extract rich image content containing text, figures, and diagrams from the latest GitHub Octoverse survey. You can find the survey here: [GitHub Octoverse 2025](https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/).\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mongodb-developer/GenAI-Showcase/blob/main/notebooks/rag/vision_rag_voyageai_claude.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want a full end-to-end example using MongoDB as a vector store and GCP for storing image files, see this tutorial: [Building Multimodal AI Applications with MongoDB, Voyage AI, and Gemini](https://dev.to/mongodb/building-multimodal-ai-applications-with-mongodb-voyage-ai-and-gemini-49g3)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "teN0wSY7kXA7" + }, + "source": [ + "## Step 1: Install necessary libraries\n", + "\n", + "First, we need to set up our Python environment. We will install the **voyageai** client for generating embeddings and the **anthropic** client for the generative model." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "6PLquBqSjzWD" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.1.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.3\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install -qU voyageai anthropic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Initialize API clients\n", + "\n", + "To interact with the models, you must initialize the client objects with your API keys. You will need a Voyage AI API key (for the voyage-multimodal-3 model) and an Anthropic API key (for claude-sonnet-4.5).\n", + "\n", + "*Note: It is best practice to use environment variables or a secret manager rather than hardcoding keys in production.*" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "tzTg5U8Okfjl" + }, + "outputs": [], + "source": [ + "import anthropic\n", + "from voyageai import Client\n", + "\n", + "voyage_api_key = \"\" # get an api key https://www.voyageai.com/\n", + "anthropic_api_key = \"\" # get an api key https://platform.claude.com/\n", + "\n", + "vo = Client(api_key=voyage_api_key)\n", + "client = anthropic.Anthropic(api_key=anthropic_api_key)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mEfzLvp8ksHf" + }, + "source": [ + "## Step 3: Extract visual content\n", + "\n", + "For this example, we will scrape charts and infographics directly from the GitHub Octoverse blog post. In a production setting, this step might involve converting PDF pages to images or processing a directory of PNGs.\n", + "We’ll start by importing the standard utilities we need for web requests, image processing, and math operations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iwlo2GW8ZMkF", + "outputId": "b0d5a160-a4b7-4a9b-b726-3d808f6d7d6d" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import numpy as np\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "from PIL import Image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we define a helper function `extract_image_urls` to parse the article’s HTML and grab image links, filtering out small icons or logos." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def extract_image_urls(url):\n", + " \"\"\"Extract all image URLs from the GitHub Octoverse article.\"\"\"\n", + " try:\n", + " response = requests.get(url, headers={\"User-Agent\": \"Mozilla/5.0\"})\n", + " response.raise_for_status()\n", + "\n", + " soup = BeautifulSoup(response.content, \"html.parser\")\n", + "\n", + " # Extract unique image URLs, filtering out icons/logos\n", + " image_urls = []\n", + " for img in soup.find_all(\"img\"):\n", + " src = img.get(\"src\") or img.get(\"data-src\")\n", + " if src and not any(\n", + " x in src.lower() for x in [\"icon\", \"logo\", \"avatar\", \"emoji\"]\n", + " ):\n", + " # Normalize to absolute URL\n", + " if src.startswith(\"//\"):\n", + " src = \"https:\" + src\n", + " elif src.startswith(\"/\"):\n", + " src = \"https://github.blog\" + src\n", + "\n", + " if src not in image_urls: # Avoid duplicates\n", + " image_urls.append(src)\n", + "\n", + " return image_urls\n", + "\n", + " except Exception as e:\n", + " print(f\"Error: {e}\")\n", + " return []" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let’s run the extraction on the specific URL." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "Pn-xP4cwmeII", + "outputId": "4d156c9c-79bb-4ad0-bbd7-a71c169cf229" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fetching infographic URLs from GitHub Octoverse article...\n", + "URL: https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/\n", + "\n", + "Found 38 images:\n", + "\n", + "1. https://github.blog/wp-content/uploads/2024/06/AI-DarkMode-4.png?resize=800%2C425\n", + "2. https://github.blog/wp-content/uploads/2024/05/Enterprise-DarkMode-3.png?resize=800%2C425\n", + "3. https://github.blog/wp-content/uploads/2024/07/Screenshot-2024-07-23-at-8.42.45 AM.png?resize=800%2C425\n", + "4. https://github.blog/wp-content/uploads/2024/07/Screenshot-2024-07-23-at-8.43.47 AM.png?resize=800%2C425\n", + "5. https://github.blog/wp-content/uploads/2024/07/Screenshot-2024-07-23-at-8.44.23 AM.png?resize=800%2C425\n", + "6. https://github.blog/wp-content/uploads/2024/07/Screenshot-2024-07-23-at-8.46.23 AM.png?resize=800%2C425\n", + "7. https://github.blog/wp-content/uploads/2024/07/Screenshot-2024-07-23-at-8.47.04 AM.png?resize=800%2C425\n", + "8. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-hero-image.png?resize=1600%2C850\n", + "9. https://github.blog/wp-content/uploads/2025/10/Octoverse-2025-top-level-metrics.png?resize=1440%2C810\n", + "10. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-year-of-record-growth.png?resize=1152%2C288\n", + "11. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-number-of-new-developers-on-github.png?resize=1728%2C972\n", + "12. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-80-percent-of-new-devs-use-copilot-in-week-one.png?resize=1440%2C810\n", + "13. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-developer-productivity-top-line-metrics.png?resize=1728%2C432\n", + "14. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-contributions-by-type.png?resize=1024%2C576\n", + "15. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-where-the-world-codes-top-line-metrics.png?resize=1728%2C432\n", + "16. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-10-countries-on-github-1.jpeg?resize=1944%2C1094\n", + "17. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-projecting-the-top-developer-populations-2030.png?resize=1728%2C972\n", + "18. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-top-metrics.png?resize=1728%2C432\n", + "19. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-growth-metrics.png?resize=1584%2C891\n", + "20. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-fastest-growing-open-source-projects-by-contributors.png?resize=1440%2C810\n", + "21. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-fastest-growing-projects-by-contributors-2.png?resize=1728%2C972\n", + "22. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-projects-attracting-most-first-time-contributors.jpg?resize=1944%2C1094\n", + "23. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-10-countries-by-contributors-contributions-open-source.png?resize=1024%2C576\n", + "24. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-security-top-metrics.png?resize=1728%2C432\n", + "25. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-dependabot-metrics.png?resize=1440%2C810\n", + "26. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-vulnerability-types-codeql.png?resize=1728%2C972\n", + "27. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-common-vulnerabilities-in-github-actions-codeql.png?resize=1728%2C972\n", + "28. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages-metrics.png?resize=1728%2C432\n", + "29. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?resize=1728%2C972\n", + "30. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-js-ts-combined-usage.png?resize=1728%2C972\n", + "31. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-languages-in-repos-built-in-the-last-12-months.png?resize=1728%2C972\n", + "32. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-languages-in-ai-projects.png?resize=1440%2C810\n", + "33. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-code-environments-in-ai-projects.png?resize=1728%2C972\n", + "34. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-generative-ai-top-metrics.png?resize=1728%2C432\n", + "35. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-growth-in-number-of-contributors-to-genAI-projects.png?resize=1728%2C972\n", + "36. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-total-number-of-projects-using-genAI-model-SDKs.png?resize=1728%2C972\n", + "37. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-total-contributions-to-generative-AI-projects-by-country.png?resize=1728%2C972\n", + "38. https://github.blog/wp-content/uploads/2025/12/Colorway-2.jpg?resize=400%2C212\n" + ] + } + ], + "source": [ + "# The Octoverse survey contains many images and diagrams\n", + "article_url = \"https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/\"\n", + "\n", + "infographic_urls = extract_image_urls(article_url)\n", + "\n", + "print(\"Fetching infographic URLs from GitHub Octoverse article...\")\n", + "print(f\"URL: {article_url}\\n\")\n", + "\n", + "# Display results\n", + "if infographic_urls:\n", + " print(f\"Found {len(infographic_urls)} images:\\n\")\n", + " for i, url in enumerate(infographic_urls, 1):\n", + " print(f\"{i}. {url}\")\n", + "else:\n", + " print(\"No infographic URLs found.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The scraping might still return general blog assets. To ensure high relevance, we will filter the list to only include images containing “octoverse-2025” in their URL, which targets the report’s charts." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 29 octoverse-2025 images:\n", + "\n", + "1. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-hero-image.png?resize=1600%2C850\n", + "2. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-year-of-record-growth.png?resize=1152%2C288\n", + "3. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-number-of-new-developers-on-github.png?resize=1728%2C972\n", + "4. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-80-percent-of-new-devs-use-copilot-in-week-one.png?resize=1440%2C810\n", + "5. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-developer-productivity-top-line-metrics.png?resize=1728%2C432\n", + "6. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-contributions-by-type.png?resize=1024%2C576\n", + "7. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-where-the-world-codes-top-line-metrics.png?resize=1728%2C432\n", + "8. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-10-countries-on-github-1.jpeg?resize=1944%2C1094\n", + "9. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-projecting-the-top-developer-populations-2030.png?resize=1728%2C972\n", + "10. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-top-metrics.png?resize=1728%2C432\n", + "11. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-growth-metrics.png?resize=1584%2C891\n", + "12. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-fastest-growing-open-source-projects-by-contributors.png?resize=1440%2C810\n", + "13. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-fastest-growing-projects-by-contributors-2.png?resize=1728%2C972\n", + "14. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-open-source-projects-attracting-most-first-time-contributors.jpg?resize=1944%2C1094\n", + "15. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-10-countries-by-contributors-contributions-open-source.png?resize=1024%2C576\n", + "16. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-security-top-metrics.png?resize=1728%2C432\n", + "17. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-dependabot-metrics.png?resize=1440%2C810\n", + "18. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-vulnerability-types-codeql.png?resize=1728%2C972\n", + "19. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-common-vulnerabilities-in-github-actions-codeql.png?resize=1728%2C972\n", + "20. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages-metrics.png?resize=1728%2C432\n", + "21. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-top-programming-languages.png?resize=1728%2C972\n", + "22. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-js-ts-combined-usage.png?resize=1728%2C972\n", + "23. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-languages-in-repos-built-in-the-last-12-months.png?resize=1728%2C972\n", + "24. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-languages-in-ai-projects.png?resize=1440%2C810\n", + "25. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-most-common-code-environments-in-ai-projects.png?resize=1728%2C972\n", + "26. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-generative-ai-top-metrics.png?resize=1728%2C432\n", + "27. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-growth-in-number-of-contributors-to-genAI-projects.png?resize=1728%2C972\n", + "28. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-total-number-of-projects-using-genAI-model-SDKs.png?resize=1728%2C972\n", + "29. https://github.blog/wp-content/uploads/2025/10/octoverse-2025-total-contributions-to-generative-AI-projects-by-country.png?resize=1728%2C972\n" + ] + } + ], + "source": [ + "octoverse_2025_urls = [url for url in infographic_urls if \"octoverse-2025\" in url]\n", + "\n", + "print(f\"Found {len(octoverse_2025_urls)} octoverse-2025 images:\\n\")\n", + "for i, url in enumerate(octoverse_2025_urls, 1):\n", + " print(f\"{i}. {url}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Build the multimodal index\n", + "\n", + "This is the core indexing step. We loop through our filtered URLs, download the images locally, and then pass them to Voyage AI’s `voyage-multimodal-3` model. This model converts the visual content into a dense vector embedding." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "id": "ItpRWH_smfEQ", + "outputId": "096462d1-cc49-4f08-fe2d-2e4f1bd7a969" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 3 embeddings (out of 38):\n", + "[[ 0.01434326 -0.03149414 0.00759888 ... -0.00411987 -0.00897217\n", + " -0.02502441]\n", + " [ 0.01721191 0.00854492 0.01452637 ... 0.0123291 -0.05688477\n", + " 0.02380371]\n", + " [ 0.01525879 -0.00958252 0.04370117 ... 0.01385498 -0.02563477\n", + " -0.00300598]]\n" + ] + } + ], + "source": [ + "img_folder = \"img\"\n", + "os.makedirs(img_folder, exist_ok=True)\n", + "\n", + "\n", + "def download_and_embed(idx, url):\n", + " \"\"\"Download image and return its path and embedding.\"\"\"\n", + " # Extract filename from URL\n", + " filename = url.split(\"/\")[-1].split(\"?\")[0]\n", + " if \".\" not in filename:\n", + " filename = f\"infographic_{idx}.jpg\"\n", + "\n", + " img_path = os.path.join(img_folder, filename)\n", + "\n", + " # Download if not cached\n", + " if not os.path.exists(img_path):\n", + " response = requests.get(url)\n", + " response.raise_for_status()\n", + " with open(img_path, \"wb\") as f:\n", + " f.write(response.content)\n", + "\n", + " # Generate embedding\n", + " pil_img = (\n", + " Image.open(img_path).convert(\"RGBA\").convert(\"RGB\")\n", + " ) # safely handle the transparency before converting to RGB\n", + " result = vo.multimodal_embed(inputs=[[pil_img]], model=\"voyage-multimodal-3\")\n", + "\n", + " return img_path, np.asarray(result.embeddings[0])\n", + "\n", + "\n", + "# Process all images\n", + "results = [download_and_embed(idx, url) for idx, url in enumerate(infographic_urls, 1)]\n", + "img_paths, doc_embeddings = zip(*results)\n", + "doc_embeddings = np.vstack(doc_embeddings)\n", + "\n", + "print(f\"First 3 embeddings (out of {len(doc_embeddings)}):\")\n", + "print(doc_embeddings[:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 5: Define RAG components\n", + "\n", + "We need three specific capabilities to make our RAG pipeline work:\n", + "- **Image Encoding**: Converting images to base64 so they can be sent to the Anthropic API\n", + "- **Vector Retrieval**: Searching our array of embeddings to find the image most semantically similar to the user’s text query\n", + "- **Generation**: Sending the retrieved image and the user’s query to a VLM to get a natural language answer.\n", + "\n", + "Let’s define helper functions for each." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "Aw5t1WC7qp3o", + "outputId": "b1631541-695c-4609-f148-c5935499c697" + }, + "outputs": [], + "source": [ + "import base64\n", + "import mimetypes\n", + "\n", + "import PIL.Image\n", + "\n", + "\n", + "# Helper function needed to provide bas64 URL to Anthropic API\n", + "def image_to_data_url(img_path):\n", + " \"\"\"Convert image file to base64 data URL.\"\"\"\n", + " mime_type = mimetypes.guess_type(img_path)[0] or \"image/png\"\n", + " with open(img_path, \"rb\") as f:\n", + " b64 = base64.b64encode(f.read()).decode(\"utf-8\")\n", + " return f\"data:{mime_type};base64,{b64}\"\n", + "\n", + "\n", + "def vector_search(query):\n", + " \"\"\"Find most relevant image for the query using vector similarity.\"\"\"\n", + " # Embed the query\n", + " result = vo.multimodal_embed(inputs=[[query]], model=\"voyage-multimodal-3\")\n", + " query_emb = np.asarray(result.embeddings[0])\n", + "\n", + " # Compute similarity and find top match\n", + " # Voyage AI embeddings are normalized to length 1, which means that cosine similarity is equivalent to dot-product similarity\n", + " cos_sim_scores = np.dot(doc_embeddings, query_emb)\n", + " top_idx = int(np.argmax(cos_sim_scores))\n", + "\n", + " # Display result\n", + " hit_img_path = img_paths[top_idx]\n", + " print(f\"Query: {query}\")\n", + " print(f\"Most relevant image: {hit_img_path}\")\n", + "\n", + " image = PIL.Image.open(hit_img_path)\n", + " image.thumbnail((546, 546))\n", + " display(image)\n", + "\n", + " return hit_img_path\n", + "\n", + "\n", + "def generate(query, img_path):\n", + " \"\"\"Generate response based on the image using Claude Sonnet.\"\"\"\n", + "\n", + " # Read and encode image to base64\n", + " with open(img_path, \"rb\") as image_file:\n", + " image_data = base64.standard_b64encode(image_file.read()).decode(\"utf-8\")\n", + "\n", + " # Determine media type from file extension\n", + " media_type = mimetypes.guess_type(img_path)[0] or \"image/jpeg\"\n", + "\n", + " message = client.messages.create(\n", + " model=\"claude-sonnet-4-5\",\n", + " max_tokens=1024,\n", + " messages=[\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"image\",\n", + " \"source\": {\n", + " \"type\": \"base64\",\n", + " \"media_type\": media_type,\n", + " \"data\": image_data,\n", + " },\n", + " },\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": f\"Answer the question based on the image. Be succinct.\\n\\nQuery: {query}\",\n", + " },\n", + " ],\n", + " }\n", + " ],\n", + " )\n", + "\n", + " return message.content[0].text" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 6: Combine the components into a complete pipeline\n", + "\n", + "We can now wrap these steps into a single entry point, vision_rag. This function accepts a user query, performs the retrieval to find the correct chart, displays it, and then answers the question." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def vision_rag(query):\n", + " \"\"\"\n", + " Perform vision-based RAG: search for relevant image and generate response.\n", + "\n", + " Args:\n", + " query: The user's question or query string\n", + "\n", + " Returns:\n", + " str: The generated response based on the most relevant image\n", + " \"\"\"\n", + "\n", + " img_path = vector_search(query) # Vector search\n", + " response = generate(query, img_path) # Generation\n", + "\n", + " return response" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 7: Run queries\n", + "\n", + "Let's test our pipeline. We will ask a specific question about developer communities. The system should identify the correct infographic from the report and read the data directly from it." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 519 + }, + "id": "hpJ5XpwjsKXa", + "outputId": "cac97f0c-2683-4215-d2ef-920ee69e5d5c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Query: What countries has the biggest developer communities?\n", + "Most relevant image: img/octoverse-2025-top-10-countries-on-github-1.jpeg\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Based on the GitHub developer population data from 2020-2025, the countries with the biggest developer communities are:\n", + "\n", + "1. **United States** - 28M developers (steady at #1)\n", + "2. **India** - 21.9M developers (moved up 1 spot)\n", + "3. **China** - 10.7M developers (dropped 1 spot)\n", + "\n", + "These three countries have significantly larger developer populations than the rest, with the US having the largest community, followed by India which showed substantial growth (34.36% CAGR), and China in third place.\n" + ] + } + ], + "source": [ + "query = \"What countries has the biggest developer communities?\"\n", + "\n", + "response = vision_rag(query)\n", + "print(response)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can try a quantitative question regarding open-source repositories." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 519 + }, + "id": "x_8e3bi9rVxG", + "outputId": "c97b3c1e-242a-46dd-f2c5-f8e2ba2b7268" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Query: How many open source repositories are there in 2025?\n", + "Most relevant image: img/octoverse-2025-open-source-growth-metrics.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "According to the image, in 2025 there are **395M public and open source repositories**.\n" + ] + } + ], + "source": [ + "query = \"How many open source repositories are there in 2025?\"\n", + "\n", + "response = vision_rag(query)\n", + "print(response)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And finally, a ranking question about programming languages." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 571 + }, + "id": "kR9T9Tirrien", + "outputId": "ed2aede6-a9dc-445a-db48-9bcc8fdd5d9b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Query: What are the top programming languages?\n", + "Most relevant image: img/octoverse-2025-top-programming-languages.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Based on the GitHub data from 2023-2025 shown in the image, the top 10 programming languages are:\n", + "\n", + "1. **JavaScript**\n", + "2. **Python**\n", + "3. **TypeScript**\n", + "4. **Java**\n", + "5. **C#**\n", + "6. **PHP**\n", + "7. **C++**\n", + "8. **Shell**\n", + "9. **C**\n", + "10. **Go**\n", + "\n", + "Notable observations from the visualization:\n", + "- JavaScript, Python, and TypeScript switch positions at the top throughout this period\n", + "- JavaScript starts at #1, drops to #2, then falls to #3 by 2025\n", + "- Python moves from #2 to #1 and back to #2\n", + "- TypeScript rises from #3 to eventually claim the #1 spot by August 2025\n", + "- Languages ranked #4-6 (Java, C#, PHP) remain relatively stable\n", + "- The bottom positions (#7-10) show more movement, with languages like Go, HCL, Shell, C++, and C shifting positions\n" + ] + } + ], + "source": [ + "query = \"What are the top programming languages?\"\n", + "\n", + "response = vision_rag(query)\n", + "print(response)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "id": "TqmWCkfqqFbT", + "outputId": "08932c14-9319-4700-de21-036c714dbabf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Query: Whats the top programming of 2025 in terms of contributors?\n", + "Most relevant image: img/octoverse-2025-top-programming-languages-metrics.png\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAACJCAMAAAAmLqMcAAADAFBMVEXQ9fz3///5//7q/vz4//73//7v//2Dx/7f/voAAADx//3y//7g/vvn/vvw//71///z//3p/vvm/vvk/vv6//7l/vvj//v1//3h/vvu//3q//z1//7p/vzv/v3w//zr//v8///u/v38//4zmf/3//3r/vzu/vzi//3j/vvP9Pvs/vzo//zp//zs//3v//7w/v3o//7+///x/v31/v7i//v6///O8/vQ9fvz/v3o/vzM8/vg//v0/v/v//8zmv/z///j//rU9/vf/foUGRn0//8HCwvk/H7////K8fvk/IHt//9AnP/m//0Ajv+kxv/f/Pj6/f8LDw/l/YXx//8ymf8bIB/g/Gz6/v/j/Hrl///5///m/Ir+//7q/PoQFBPd/GABAgIEBgXH8Pvf/Gfq/fvl//v4///k/Prq///i3f/o///D7vvt//vn/Y3u/fvc/FY4nP/Y6Obl3//i/HXs/fvk/fr4/v6lqv+qqv/ExP64ycfs//+Y1P3T0v7h/HK6uf/f2//Qzf+vrP+f2Pys4Pza3P6yrP+ktrQhJiWS0P3f0fppuP6m3Pxhs/5Pqf9Xrv62tf+/vf/o//ufqf/j//8oLSzZ+0mx4/zw/fvKyP+yr/8+oP+zsv+tq/+bp6ZtfHpOVlWCjowyODdrd3Xh8e+Wo6Hl9fPu//t7hoS/6/zp+ffU2f61w8F1gH88Q0LN3Nu25vza9fJFTUy76fyMzf3S4d/d7etFpP+wvbvJ19VvvP7Y1f/L1v3V8O1lcW+qt7Z1v/5bZGOXp//d2P/R7emHk5KHyv1hamlUXl2xx8TA0v1/xf2jsK6cravR5+STnp3c/PqNmJfD0dC9zMuDx/18w/3I4t+rwb7t+/m9wf7Jzv2709B4wf2prP/f1/PD3Ni1uP6vsf7x/vysrv/x/t3u/smNn52nvrur1v7H6P71/++mz/7Z0fvq/bPY+zbs8f7z+f/m/Z/o5/4cnP8Dl//3//fW+xL5//2Ctv/b6/7m//uzxf/C56Vxt+WVy87x/uhM/wg2AAAACHRSTlP+/////////kgsYtwAAHjSSURBVHgBYmDQ1GTQBJGaDJpQABYCCYOEGEDSEAm4OEwljIZIw0mQaXC1YFGIQgaoRZoQ+8AyICsgDCjJoGkGZ4HdAOaBdDJAzAWRYDE4ATFdUxOmE6wCJgjWqQnSC8JgPTApkDMgbLAOkEchXE2oxSBhkP9BClF1gnnmIEmoR8ECYG0gAbAmqBCMghsNFoCoQBKDMCE2glRAFIBYMAySA7EZsHsU5GiQZ0F+hRgGD1uYTpBuEIabDXIrWADMAAUQXCecoclgBgIgS0E2m2mCeWZmZlZWZlZmZpogvqaVmZkVKPhBcmZWICmwDEjOzEzTTNPKCqJUE6QdpM8KZK0VWDlYK5gFUg4S0wSZZway10pT08oKbIcmyEKQpBnIQBCG2AzhgiIflG7MNEHOAFlgZmbGANEK0gkyGWwFyDFg80AOAVkB1gk1DmQvGINVaIK8B7IR5Haod8DmgDwBYoAwyKsgr4CcoWkFMl0TZBjIFRD7QCRICGQQiAbzoTo1NUGhBnKJlRWYDU78ZpogQ8HqQFJgB4KsBJmraQZ2M8h9UAPBFoPNAxFW4JAGqwZFB0gIEkygQASJgFxoZmUGcirYcnjggJRaWYFIiAZQBIPNAfscxtMEBQ9YN1hYkwHiUQYrcASDUgSIAeJ5WFlZeXh4QLCVB4gDZlvBhUAMK4gKiGKwDpA8SCGyXpA0WBxqMEgOpBgkBjYAbDqI8IBKgSyEKraCqgJJg4SgjgSlWDNwDENdbAaShOj3ADkXpB7kRBAHbATErRASZg1ID9QCkBBYPUQFyH0eIH0QzyCzwBwQAdMJUgtRACXBFMgPIEPBdoBcB3YtKG2ARaAEyEqIfqjbQeLgQAGFGlg/xCqQmWDFIHGw2WDrIc4DKwH5FOxzkC6oUhATZCLYCrARYKVQLlgRXBqkFywLdgkoyYCLAog8A8hKUNCADLnAQVdgTaJtF0CBAncvyK8gr9HL0aS6Fuq5C6DIAEchOIJBkWtlZUUvR0MdQRJlzcEBcjQksD08rBhA6QaU4Dw8SDJnYBQ7gV0LKiVAHgBxKHAHmXHOwUFCagHZYQ1yJxK28nACGTLIMcLBkCSS5OHhQYLHB9B35kkeHiDXQnxgNoAuQQOgxIAmBOdagZyc5AGCHh5J5nBxCAOfTogKYknqmcTBwQEPZwawu5OSNIl1BknqyHczTp0XkpI8ksDpJCnJEZtjcOrEpphOYo4eoABPAgO0OoawcwmrwOUL8nWCTNQEBXRSUhID2NlJdMyOpLkbU/UFiIuTcKQQkOdIwEjmIzGJMYAk5Y5wR6OlEJhNqKah8mBqqEUTa7oZxNHQJAKxHateHogcfhKrTixaiFWHRStcyDwpKTspKSkbe+MJagOUgmtCZaDLovNRVeMDuHSii3tkg9yMM1mjK8dnJVQOqgVKQQXRKfyyCNXY1YGSSHYSA8jp2Qi12FjY9WNTSR8xUPpISiLgaHKcQkuPZiclZWdnJ5HjrIHTkw1yMgOIHDg3kGXzBZCbs2kZn2Q5Cz+wBjsaRzWDXyuSLFFFOpJ6SpkgR4OSyEpcBsFjAc7ApZK+4iCH43Q0OU6B+w/OIMcU/IDqjiap943uNiI9CnI0Q/bKbEqTNpHWobuSfC86gso/LMYNXiFrDg5QPYPe3x28Doa6zHFldjYoiUC5tKXIT0eY7rJemU1xusY0lUoiEI9CSGQjQdUjpiiyigFhE6i6VmavZFi5kqpFNn28uXLlykEY2viByZAM6eyVoCSyGb/X6C5LROSvXInV0UTopLtvEGAzdkcjFAxG1mZQEtmMNbQhzh2sYY4jiUAcTQ5JvkeJ17l5Mw366eR4lhQ9m1duZtiML4mQYhhJamE1IPEBjGJ8Np0dDXMuiiOI4sA8aM3BQWISgekkyhqaKdowYEkEu5eIDhWykgjRpmN3HMVg82Z4q4+2TiHfdEydGzaDSpENFHse3QBMm9BVUMhfuQFP7UjAbGo6jiSzkJIIKesJCHgHtzRJjsNlzIYNmxk2bKZ+EsFlH9XEV24Ygo7esAFeilAtIGhu0IYNGxg2UBDaVEmn5PhyNInQCGDEKKVJBOpODHOh4oQpcnUOuSQC8ih5pQhIJ+GApJmK6eBSZDrNzCfbYELhsnLDoHI0IedCwoG8JALRO2AkKIlMnw4NbeL8SbRbSTMOl2oc4ps3bCC/H4rVCzgswg/AmsAEfnUQ2enTN8ObqURrgmgdOBKURDYMdIYkJ7Q2g9M1OToHLrA5ppPdDaNydiAlDKZvmM4wfXoLKVqoqJaCGIYkEZhbyDeIZJ0ka4C5kYODA1yKIPHpySTb3S0bNgxgEqEgiFCTCAUG0VPr9OlDsKfeMp06pQjZaRRfrsRiKFxoA7iiwRW/cGXoCnBKwBXiKtIJ64QbgZMxvYX88T7shuJ0FU4J7OYgiaLrBCWRFkoqGnQDkezCwiRNNRYD4EIbKHE0yBQnJ1pud8Lu0ZYWwqUIdp0gF0MwdnlifINdJ8RUJBJdWcv0FoaWlh4cXkLSSDIzcgoIRIL0RU6ZEgnCU6bAYwUkB8KRU9BdBNJABN7QQkkDyjry+uIFJ+bdjvSHWwVyzZQpEFeDnTtlijpcksNfHSSF5FZ1iIciYUJgjSACoQeThZJEYDoxleETsQbZAXKrE7xvxGFt3b6Oc9HF27DgtQb5A+I+kMopIO6UKVM4OMC8yClw8yHxMgUcSXBBdEZPCySJoItTzHfiDAQBTn8ODn9nEAuE425DzT0XB+KCsPMRqBCJFCVJRH0FZyAnCCS4csLLkvkg16DguOdwN93nBHknkXMFPNWchCjlhCrxD4XwQ/Eu8URJIlCdpFHQYA0MDIXHK8w3CQmJ+yCxfwTiFjTyOMcUiCOdoZ5wgkXCfbxuQE0i5CVsrBZkxYHigBOcRBIhTE5OzsXQYmQfXMSV/klkL9xyTk5O133QggThJLh0O9RnU+AinJx7oWInoWLQIINx90E9CFWFRlGeRK7BwjIQnkSgDgFTcedANh4Bs9GJ4xxTXMFirlA3b4RwOV2hIQDSigWjJhEsCkgUgtrOwfEc7BpOTicODn+YtzjBXA4ODn+oJCiKcCYRuFFYnYCvFMGvMxKaeOFuAIeQ0wI4H86AJpEjoXARTs5AaNECSxMQu+CJCMLF6mIODo6eFuggJYoC/HpQ2wBwl4CTiDUHhzWy4zg5A0HlNJFJBGpWAkgLioPAHLirelp6wG0RsCgViUio/WilCCekjIOHKCcnuaXI9J4e8pzrBHMZnF4KMsg/Ac6HMyBJxNoZLgBiBELKEdQkcgIkw8nJuRFkFG7c04MtieBWjyEDD1ZOcBJByWwQJzhP4eAgLom0QzSAC3oMi5AEwEmE3NBGMgeF6cSxEWY9WhJxhhaPiIxM9yRyHyMtJIIchVSwwd3eDmoROsGiHyacAE7mKElkCiwV4a1mODgoTSJIjoQmkdswVyFof+KSyBRoHIDSFN7NKs09LQw9FCYRdTAAJxJrDg51UO2B7GCUigacYzmeIeSRkgi8aAMbRYBAKUXw6AS7DRypEANhhUjc7b1HOqDOWIRa90FFOTnBpQi89ocLgypPDuQkAisUXUFpDWINdpLoJILuaqhx8xBugCSRSGjajFvbvgnKTLSGJZFECIDqiduI2haBCeMJO5Ct1hzNPT0MPT3NIA4KJqARRS1nAghkQcWgbSKoC9BKEUhjxB/SnwArQUoiUAOIo1CSCG4tTmDHcSIaPFmQkEwEifjDmqgg/WDXcHJGqk9RnzIFRKhPAY2iwZIUp7q/9UKImg5QSkAkEWun4xBxzusgc/Dhnh7ieuqRoABNgPWW4CbCCytOTmhFA61SAkEV3F5ok+8ZNIks2AgBUMdxOsGTCCjHwKqZtXDTcTHASaQZKYmQkjaghkLcAEsi6tB2MkQUI4mA9FhD5UAU2UkE2dEgQ7FjJ3C1gmTJRkgSAbmLgwOaXkDFAqjwA7kH3ZhIiHecQeECK+dXcHAglyJTYCke3O5FNwCZT2wpAm1yIGvl4OBwgjod5ExIEnFaDGZDmhMw13HCkgik1rsGUQLyADT3gno0kTA3g/yFZg+cC5Frbu5h6MES2hBZuGK8DIgbYEkE6g6IINjxyD2aUJAy5NyAFHvoluB1w3QsjoYbgNCJkUSOQKJ8HVgtrIjw5+CYAk5LYPeCpWAErLIHRz+s0kFJIjBDoJU6TCM2uqeZuOYq9iSCXPhCkggsVVSBLYNV3yhJBOY6Vw4OeClizcEB7QfFgYofsGbcBDiJYKlocOvAlIGkBlDcg+RwJhFIHICGaSADE5DmEp4kAjINhBERjmBxtKAkESQJkA4YtuaAJRG4An9IVjwBVgILPycODlitDk4KYEkw4QRtr0C6utBGh7M/cikCq3IgSsC6cBHNxFY0kCBFNQbqWEgShyQRmBCo5uDgWArRhVqKQF0XCIoeaNS4mnBYQwKf8wSkpEG1CI0HSiLNPc2gWhcmg8wmavsIxGUgN4CMUAeNpboGQn0CKtCRSxHOBRwcHOA6PREyEIGeRKC2QygICTIVFfNwcLTA0jW6GggfQnLAkwhcfxbEYVPBjXhoEIMq/UhIvtrn5DQlcgp8WJ2DA+I5cGXPAeMlqiMlEVhOBvkUbgsOBslJBOYNkHmQ8swZWgSDm6vWnKGhoc7OoZAkAqt1kEsRWJ0+FZT0YUlEneMoxFuJJiCDwZEMz0NgERgBEq3paWZobq6BCaHSYAeCCBCGSEFYPFAKLCYBsQ6WRDjUTUwk1NX3QqICFHAoSYTTH9YCxEwiEFPBhmIjoNISYDnUUgQshI2AlSJwOWiqAFd4HNcgJRso/1tDKud5VZwghztz3gaFKQcPtMiPg/gOqplzClISOQvxPicoNOG2oDGgLudoboY0V2F8NGVgLg8H3FYYH0xPgaTh69DiDpxEOPwhABzJsEZgOzSJhIJKCHBu5OR0BSciWBIxgda2nFUcYJ0cHBw8EjAW2DJkoqYZnEQkwOEOJjg4JDgkODgkQKSEBJTiALOgUiD9EhAFIBFoRssCs0E6wfIwV4DmaKBN7XWgwAzN4oA276aCuKChM7gesAkQq8D2wl0CdQ6ED+ZAKhqQG5HUgx0JdhlIEKROApZEoKIcEhL+0DI20kT9GowJEoY6EuwoMGECck4WJGJAQ36g0IFm1CkS8OYqNMY4/UHSIB0gGhScYLeBggIUUlAJaBKBe1iCQ4IHqk4CFEscIHU8EhLQhAnRCRLj4IBmRE4naBM7MBLuR7BH4eM3geoS0JQDauGCfcLJuUKCg8NaApZEYE1zUP6FuQVkNcTZYDeDkgCIIcHBAU0iIOt4QCEMdjKYgUyAHYEkAOU/vw4GEGecBLOv35aQ4AGZBk8iEhKwUuQ6SGHCEQlIJ2EFLIkgmQtyAkgzSAiUHkA0OAhBDJgEONlKgEoRkCgqhqrhkJAQgzgHbCdnYjuEt1GCQwI20u7KyQlJFQlVIDPg9QXIkRDsJCEhAc27oBQAshc6rXBEQgJax3MugqjldIJaDVIFMg+UJsE0hADLcjTX9CBxQdkArhzCuAZxJ9RwCOc6WAs0WjdKwJJIlgQoVYHlwMQRSDEIciqID7KQRyIL4rrQSJAQNOA5E6HVTGgWWBRCgNRDWCASFBESEhASmkRAwiRjB4j9qOQJUMBKSEjAkogTIolAOlprJSBF80aIl1yPkGwvWENPTTOYxkXAcjeK666BVKMlBtejYBejiYK0rZCQkNgLcSWnP0inhAQkxXHeRiQRkEJOTs4ESCRAVOEkm5tbcMqBJSBBAzUTSrmC3Acde3H1R04iYC1QIgvq0DgxqACYWgsxYx3ICAlYEoGIcXJyngWrIUR0NteA2iKElGGXh9uFxDgBVQpviyCSiBhEGTQyoAmc3CTSUlMDtQk7hTFZB7IcnEQkpoBrPBAfhPdC9FeB2KjYOVJC4hykpOGEhDEsiZzESCLEBXdNM7QUgdgpIWECY0BpnEkEOnF+XQIpiVhDNYEoaGhycm6CuhQkKGEC9dBGMA8jiXASla5rmmsYamo6UdyK7m6I+VhIqANQKGgS0cCSRKBpA1KrxkEoTnKTSA+BJAINUxS3cV4D+xM6mASVOq4O9hm2yFmLSCLQUgRaAzzHTCKcKLkXbCQmUQOraDClICLYXOHqJGECayf7IycRiBYwCQ1aTk5OlMiDCjuD1WCWIpzgKhYqiZPqrIEkEQ2cKiASDhDKBBzGElAeNJBRKGgSkYAnEQcJJ1hOBDf2nKEJHup8cBJBsh3EhBoPsRIH2dMMKUVA6rEpwZFEJBwkUFMIJyckL0HrZ07OSP8pVdBCm9PBBHspch1LErkNdgXYOajuh0QaWAycREAsEAarRyOwJxEHaLUdCCrxkNoiYM0go/xhLaI4cLkAEpIAuQQ2wQBVCGkEIkcXVAKzOANLgAmHzppmcCkiAYl2kLlgw0FciN/A6sQggmA2hHCQkNAAz38kQDqOUHbCQag0PIlIaMCaqxLggiNhI6QfAc0YoCSiISEhDNIGtl1CQkMDxIBhCZjVIAGQKggGlSImEClkCQ2QdgkJCY0sZ/A8B6rjQBUNbAySk5MTMorGCWrMaUB7h5xOINM2QrQFSmjA2iKg4lsD0RbRgDdX4QEeB238gQIGVKKAzIE4FcrSMJEAJxGQ6yASIFID7AeoEomzEEdDrIcGaaCEBjS9PwN1caGNrMAsf39/CbBuMWimg6V2kLFgDGuftIMDFEspwukDsh1mObaQ1pCQgJYiGiAgBiJA8QOlwZSEhgZMXEMDFHtgEsSQ0NiLPE/kD+FshBoATyIaiCQC8UoVOADmgdMLaL0IxFSIJZAIhhghIQG1WQJsJYQAWQzWAEoioACCOQ+kE+xgkGYJDTExiHP2gi1zvQbhSWjAQpsTFNywHi2nhoYEtH1yG2QGrNPJmSEBU+IPsR7aozknoQGtcjg5OaHdYs5nIJvBbgOpBcUe2CwQB+pIiZrOHoSfwBIgZ4MwSKmGhAY0EKElLMTRGzUkIJkKnhrhjCxwcECClZOTMw7MB8U02DgN6BqYwAwIVwM6bAjSDg4WTs44iHtBCQUSymADNTQ0wIkc7CGNzppOhprOLVAziKUg8QlSDWKBrOTkrAZxERgpiaRDKxoJf3BoglvZrhsRSQTiTCgJNkEMHHwgJsh8EI2EIUI9nZ0QTyHJgLyGytWQAIeF61648CaIa0FxrqGhAeEk+mho+Pj4+KT6+EDUQaOIs1ojA+xkTk4fsK0SYLdzcho4IJJIHLQVzsmZBdGMToJ1ggUlOmt6wAy4X2FeEIOmHIisBjTSoTykUgLiXhgJiXu4/c7noBpgFKzyTIUKwJNIwn2oEaE43AzVAKa21HQydNZs0dAQBqd0YbAghICxwc6HcsDehbIhquDhjJREQKrgSURYA5ZESqExAnJeQhZSEoGbpAG2C8aFOAnEEwY5T0NDwwHEgeBmcBKBsEGkmDDIVhBLWAyqGsSBJRGYzlKQ5ZycCdDQhFYv0JQB0gAOhlJoFVQNi6w4SEaE6gYlBngpsknjIsRMzuuo8QwxDYXs7IQmEZBKZGeiqNKA2QrzBzTFQK1BUOAkAg1HTk5nUAGObBAsoXP6Qw2CJxFOeIPsIDjU0GMUHAgwo8BJpHOLMBRoCGuAWSBSDMzWEBMTFgYZISYGEgT5DZqexISFxYQ1xISFIW6uBkmDVIKVC8OTiIZGKbQUKYWqBKsXhnrN9QjYQmFhsD1QtrCGhjA4WYDNAxkMthPsU7ASDeHmzk4oC0SBlAgLC4MTApivAUoxIJdASxGwiWLCGtWQyA/1AlsgBpn34GwXhtZLoFAWFtYoBQ3Cc3JyeglDE0WoD9gGKI/TR1gMnkQMhOEh7wO2BRSGYOeCfKQBDkWQZjFhYY3OzmYNYTExiO9ArhMGBS7Iq2AMchNYDpomQHxhDWE8pYiwhsZBcHBycgb6gz0OdgLYNGEfqMxSkPUgSZhDnTNgkcbpnAGOUUg4Q2IUpFIYFHwgpwgLi23p7GTohCcRmFkQVZgk2EMgReDkApWHlg1eIO+CFYDFYUkkXVgYVopoCJ+BOpqT80QpNLjBSQTsNmFwkgNpRpgiDE6DoHQITq9QCVBoN3d2ghwCUg7BqDyImLBwKTSJwGzwgszchnpBFECTyDPhLGdXEHDOAounQ91ZLQz1HOcRkOOEoWV6aDo8iSTeFxYuhbZjEu6DvQB2KYQFNgxBgJIIhAf1CIQDJZHEMiD2QyWEoSkGIohEBmYIC2dB819cKkQ1kinQFJGwESIjDE/L84SFhWEL2BZCNYiBEjREIVQExoEkkWMwLogWFRYFURgYRSc4xKDhAHE0NNCh2lKxJJFSYVjNzpnoD8ufrkeEIZ4DGw8mhIWFU6GCUNOwUM2gdA3SKSosCnIvQidUMUQAlkSggsJe0LbFObBAKTQLLhU2gHgicS/YTwaQ9mFgurAwNBFxloI0wNaLCAsLw0oRkBOgyjk5fUCKQBgkCqJhGORCYWHhzs5mqIgYyI9gNkgpCIM5UFEik0hchjAsMXNmIZkBNeo2OHtwBhoIQ2MUmmZcwc6EeJgzzgCsGupAMBusHGHcMXApcgysQjQ1VRgU4KJgQlhYFAZSYQxQ6oFgYZA5EHWiEMu8QFGVCtUkLApPIqKisFJEODUVohTU9kZKIiCjhFNTIbY4gCIcbB8opaSCbYM4C8QXTYVKCzdv2QJKBCAngMTAOqAOB/kuFaRTVBReiqSKggwRFoUGPidnOkgnLHveF4UHdXpqqmgpbKVhqbBwBqTOcTYQFYbHx1pRUVFYEvklKioqDFPfDnFuKsSZIH+JCoNdBwrMVGHhLVuaoSEsKioG8gk4vIRFhcHOFQa5Eawc6kqIf0RFf51EAtBBm8SqkydP+gjD2p0ZIHPBFoKMBVknKgpbe5glCnaPKKwUcfUBWQ6TPVgKChlRsBaQISBLhYVFQeEHjkzhY1u2MHRuOQYSgUUSJKpEQeaC1cD5IBEIBpHQKBUVhSURUCylgmVAoYYliZSKQisXTk5OONv1CEgfSBvYRggHg0RyA1QOVIqAmTApGA0VhHKhNu4Fi4qKIlxwwiBdtBqWYn1ERWHDJZsMfAwuQrIfJyfIIzA1Buk+KyDs0CykJAK2xwDSwgFpAPNhtgmDEwuIBxYGJREQBw8Gq4MlZFDMItRCpEQzIHYFZoBkoN7j5ERKQ9ehAQlP6KBUDFIsCi9FQAYbQD0ZmAVKFCB5kAUgDNIPpUHxcmxLJ8OWLVdgKkA0BoYrFxUVhVuHpKpUtBScBhHSqanYSpFSREQchEcWLIn8EoKbmAqyBW4puo1QPjyJgBTDtYI5qVAlYKpUuLS0FJzUwVzRNZBoBpOQAoKTMzRdVBQ2AMKZAJ0A5uRM2AgyF5bWwTogRClSEgGbCi+DQIkHpAmRf0A8GAYnkV8Qn6WmiqamQthgI2BqIDpLS4VLRUHWgCITJgWhkZPIL1HYODDEYRASHAjwAAYVmBCdSElE9Jeo8HyIas4V4NCBKkFQEGeKiqayb9kCSiJCQkKiYCgEAqKpokLQGPslKir0SwiEhUBiv0SFREXBSsASYDZIHCQJEhH6BeGJCsFCNl30F6yiKRUVgs3/3hb6Bc0ArkdA9oIsB1kp9AucVECuAVkFEoI4GmStqChImSjYCtHmLVtArgJbB7YV5AWQe36BNIOcCdYIFgUToiBvCAnBmvnQ8IFQICegb5fhBIUtyAEQJQjSOQPkDuSKRlRoI7TRuOIXKLRAzoS6AkaBXCYkumVLM0gvNLRADgQFrSjYaaJCoKQCCnYILQQT/SUkJATCIOW/RIWgfbLA6l9Cv+B1CcJ1nJycoLASEkIUmOlgnUJCQtBK01UbHBSwsVdOA7B7QYrA9gjB3AMKNiGhX7AkAo53UOCD/ARKA2gY5EYQBjsXFA5CsHiBKwTFGMjzEAF4EvklBEsioqJCGZCgjNMWEkIkEbCZEF1gN4LsAXsCxECV/AW2GiQOTiIgT4j+AnHBoQjxBMQkiCCEDSIhqn4JiV6DlR3wYHXNACmANljhopyu1SBhISFowwAu8QxsDTyJgNwA8wxnYAYokQulCoEpaFiCnSIKSrrHtjSDgw2SsCGehQQ6SM0viBshtoI9BBKFBDQocEHSSEkEZDGsJIA7DsQAmQvSCWJzcnIuKoUFESyJGICtgEYAJ+dZMBc5oGECIEeIXgGVIsdOg8XAwQ8yH8yDE79ACuE8MAPkWCFtSDCAHAPXqQ23CJZESoXgSaRUSEgI6uwstCQCNhWDgNkMoREWgRTWHNsCokCCIJogBikEYSEhWDsN6hTOuCyQ5l+wPAYXTgcJgzBq+eIKFv8FSyLgwPkldAmqDRTcEGtApLYQOGRATJBBose21IBoDAzzIEQhiATrg6uDyEO4sFLES0hIqBTShYfaDaMg6uBhfQLC/4VUikBEoOPznJylYE9ABKEk2A2gaNYWOr3lGMOxLad/8QppC/Hy8grx8moLCf3S5gWp/AUS4RX6JcQrBEJCIOlfvLy8v3iFfvGC8C9QMhHiBakDiYN08/IKafOCRLAkEVCSgoxELuDl5YUmYtcjIK0gs4VAOsEMXrCFv37xgtwEcgmIz6sNUQhy1C9toZpjx0CuAMkIgZwHcg/IgSAOL8hhYCeDjAOJgrwGkhECuV2IE9pSA4fp81JekMG8vLwZnJC+Lkg4YWkp2KMgjdraIBEoThcC+V9ICJZEQE7k5RWCDbZBi55fQkLaoEDkBen/xQsKElBAHjtWA3aWNkgcFMYgt4ECGOoNIVDQgWIC5EkQBoW2ENRrIJ282kJe0OZqtRAvrLKGOg1GgbMpL+8vKH8+KLpBNsIygasOyCghIdh4Dqe/EK8QrzYoCUCDHBKToLTAKyR0+hgoiVzl5QV5QxscWFCngZQJ8f6CiIE4YG/BCG2wBpAmkBKIdhgJdg5kIwQnZ7oQL6wxBwrcQrC7b4NCDszi5DwCtQGkC4RhNoCUQNwDSjpIorxClry80CTyC5QatWGu+wVWD3IZxA/gRAcKZW2Qwdqg+ADFO2/6xk2coYGJrs6JnJe8wCb/4gWlQKH0E5zOcYHOcZzHvSxB+mB+E7rPmRiYGBjKuRCsH2QfPIlAdPJCfcO5D2Q91B3g4IGbz/tL6NiWGjAXRoDqTZB6iHNBLN5fIItB8jDPQERBIqBY5OX1gtoEcjg0m0FFYBQ4SfLywpy0GORccGjCqkwDsJkIFZzpEI+CsgoYgwi446+Cksixq2A9IMdp82prwwIUEhxgx/Fqa4NkwcpAen+BwhwcOGBpCA9sMC/Egb9409NL00vT00Fa0kGgNB2sFMSEskrTQWrAolBCWxtkOISDlAghAmDjITbx8vLWHLsCSvkgDSAJbYi1MGkQDcIwL4AMBinV5uW1BFkhxOsllJ6e4QVxCcR8sPp0L20hVGGIEeleQulCXqVgNeCsIAT2SHo62HJebV6QZ8BCIONBBoIkQDRYNSQKhK4cAyURkFshBoH9CFWozfsLyoJ4BawXpAyCQeQksFlgW0Chqc3LCwphMAYLgsMTFOSgQOfVhoqB0h9INy8vL0gEHCdggyB8kBhYGmo7mA22nNcSHFagJMIOTSK84LQBNh5CaIPcBDYNFLyg0IVoBZsCJiDpBiIKkwdJQE2CCUGMgykDKQCzIaaCLIALQdyAbCzEDdAUCtYG0gBKIghNvCBtYDstwUxeXogukHKwMJgLVw9N4CBNEJeBpaE6QaosQQQsrsFskEkgPAmUYrR5J4EEwRhMgGSgGMSHaQGzQa6FMSBJBKQSlBV54f4HicA0gdkgAhRl4DQEkQGZAcGW2hD3gUyGyIGUQ3wCUgETA2kG8yEWgZggDNIGshnKBukF5SCIfhAPDV+9cozhyrE7UFOhVkMpsCZwvgNHNShYQEZD1YJsAhmmDYkOqIXa0NjR1uYFxbM2KCWCVPHCkhtEN0g1OO5ApoA4EDUgEqRTWxtkGSQK4SYgdIIcVnPlCkjgF9hpIH0QDCkCQQp4eXktUZwLsQ9MgsIYHANwq0E6wBxLSHIB6wQZCeKD9YBUgHIVWBXMaeBkBfEoryXIx5ZgDSC7IUpAqkFusgSlXd4r7DUgRWAMcj3ITLAKkBG80KADWQIKFhAfbjPIKSgYZChIAOxcmEdBZoHMBEmA2VD9EAuhojAxsE7U1AOVAsnAA2DSnStXGK5cuQPyKjgwLEFBDpEGOVsb5LVJ4OiGVEAgPthCUCEEztravFAK5DaQHnD4gJwDZYDcCg4gS0uwShAb7BZQREGCRVvb0hJsMthosD5L3kmQQAaZBLIMRINqCZB2XkvtGnZ2sIi2Ja8lOElDnW8J1qUNSh6gcAY7CCQPYkACHxy4IJeAvAnCIJtBNCi4QP6HKdDWnmQJ8TrUWSBNoJgFZTqIM0CmgrMIyGvQXKvNy6sDUzkJVEFDc/0kXl72KzUQN0BIsLGgvAMKIpBrQT4CGwkKApBTQN4AmQUNAJBHQMHMCw4tcGYCaYFhUNSCUirYbSDfgPI3hAPiQcIa4luQwZaQWABZDrIDFLi8IK+CYhTkF7CLtLXvXGFnuMJ+R5tXR0cHZDovr6UOKDuAOLzaOpNAvtDh5eXVsQRFBcT5YDkQH6IBXkBY8vLq8E4Ca9fWgSi11OEF80GemAQKOhADZD4kXYF4IFGQTh1ecHkBsh6UTC1Btk4CsUA+A/kLpFgbpEoHlGZr2E9bauvo8IIcDrNLZ5IgOD+BtIJCEiQODiWQhydZ8lqCtOuARHhlQP6HmqrDq6MjA/IoKLB0QMEP0gjxNLgYBDkY5ERQxIFcAY7zSSC7wW00kGqQNDhOQeaCvASiwfpA9oI18Wrznmav4QVpA1kMyn2CIBN1QCZBPArKqSBH8FqCvQ/SD44WbTAXFD5gu0DehjBApoGjFRT0IHmQt3l1eEHqdUCxB9JpCcqAEE/oQGJDhxcEQekMZAzIbpCLQNaBLZYBmQB2M4gLLkVOH5ARFJSR4ZURlNHR0RGUEZQRFBQU5LWU0REEeUJGUIZXUFBQZpKOjIyljswkQUsZGZlJgjIyOoI6MoJgDNaoAzIEhGV4ZXTACGQASLMML0jVJB1BkOHaMjIyOjIyIJ0g7TI6ION4QaaBFIGcoQNyiKAgSLfMJBkdGcFJOryCgjKCk2QEZSbJgICgTueV06D0B3KqjA5IA8QAXohTdUCuA7lSRwfsKxmQRyBqBWVkQBZC3AJyiCAvL8gdgrwgO8AeFZwECgMZHUFeGRlBHVC4COrIyOiAHQGiQaaDQkyQVxDkUZCXQcEGthrsB4jhIE9OEgS5H+RZQRkdy9PsnbwgV4AVgQNAECQlIwNK6CBBHR3eSYK8Mryg4AF5S4YXZAhIHqINbDMoXHR4ZXh1BAUFdQR1dEBKwPEGDmWIo8ChDvKooA7IH4Ig9wkKgrKCIK8lxA2gOAbZAzIZ5FFBsHd5QaosZXgFQbEEtu7AaXaG0+wHQHEHShkg+0ChIQMyDZQKQK4AmwOR0QEFGYgQZAZFC9gckDRICCQA8pagjA4oYMDGgBKRDsiRIAJkBNhiGZA+SEzL6ICDE2QGyA06oDSqA4o4kOsEQekRlFRAZoGkBEHWgwNVsPP0VUtQAIFiAJIeIEEFikxQxE4CBaAMyBSQcbCELAO2BKQeHGZgi8DmgWIcFNSTZHQmgTTIgAiQr8AehaYYkJNBSUQGlITBvgE5DoQhykFOnAQWB+kGuQQU7aDcBfa2oOXp052WIL2ghAHyOEgbyFZQGgc5EeIFUCCCPQpOqiB1oHgGeRTkMUhWALF0QC4HeVMHnEMhhoGCFoQh+RcUj6AwAGkGBSLIYpBFYJ064HQFshPsUbAcyIsgDSCHg10lMwmcRE4fAHlBChRMgjIyUlKCUlKCOlIyMjIgDCZAwqAkAJIAmSIoBXaGlJSUDkg1yEaoADhwQDp1BME6wUaA2KDECvIUOPPICMqAdIKKE1AeBHFBQQcqvcCpBRR3UlKgkgtsE9hsECEF4kqBSrPO01dBKV1HRkpKRlBKClQ8gVOeFChUpEB2g5SCQxoiDvKCFMhCZpBHQeEkpSMoJSUF9gnIbFDEg/wmBWZICUrJ6EgJCkqBY1hKRwrsJKhHpWRkpHRkwDpBMSwI9iSIgHhUCpw6pED5EaQPFJRSoIKK9+rpThmQQTpgrSCfglyvA3IzKKGBcgDIPHDwSQlK6UiBzAQ5F+wPUMSAzII4FuwXsC6QR0H+AblQBuwqsD6QKTLyIM9LSUnJS4ECCuwzUASD0zzIcJAfQb4RBPkBHETgdMMM9SgoYnadPs1w+uouKSlmQWYpZmbmSWAWM7MgM7OUIDMzM7OUDChIQQxBQWZmGWZmUMwxg8IWxAOpERRklpKSAusEK2MGGwQKe5AxUiCuFMhoZilmkBEgQ6H6J8mAoohZCqxBBuwEGUFBKSmQeSAPgtwE0QlKtCCTBEHSIHmZztNXZZilmOXB8iAzQVIg10lJyUgxg6IZJCgFsgnkFykpkP9AOpkFQY6WmiQIkgOpAbkLbDbI6yAVIA+BfCIlKMgsIyXFDLIH5CiwM6FBJAUOHpA2CAukBqwHpAjkJpCLmZlB1kMVMUsxy1w93QlWBAlZKWZmGSmQErArQOEECjBmQZB2ZmaQT5lBKQgcPCA3Q5XBPQrSLaUjAxaGuhsUADKgYBMExxrIHilBkA/AimRAfFDoSDHLg0IdZDvEPYJQh4JiFyQD8gUoFkDaQEnk6tVdIKagINgxIGeCSgYoDxS7EDeDWCB1IENBTgGxBcGxDnE0yGWggAN5EaQDFisgdWA+yG6kIAGnF1BAgJIOKArA1oMDFESAXAmh5UGxAIpQsA6QccxSzJ1X78hIyYM4oNCBKIYoB6UxSBJmBsnDnAOJApBDIIkFFH8gbbAoAaVpkCwoZMA0zGywqSA94GhjBiUkkFdBwQ3igMwFyYL1gPIKyFCQIrB3QIaAAhaU7KRk7lztBOcEaEggtICUgbIL2C+gxAsyBIRBBoHjDRzQYKeAhcEmgCVBWsHRAXIQRAFICGQ7yFkgNjjGQDkQpBWkExREIHeDHQDSBxKEeRQUyoKgNAQyTIqZedfpqwxXr+4C8UB6IH4GkSArwJEMNgakHWQMWA3IIrAoyHqwp0BuAEUymAaJgpSAsCAzKJpgpoPMBMuC1DGD0iGIBzIKaj7IeBBTilkVFHOQAAfpgmYiUJSDo1BKqvPqHR1QegOZADEOZB/MjSBDwAEEDhhIiQh2BZgAJWSQrWC9YONBwiA9zIhiCaoAIgqxASQEKjIh+mAehimB5CmQSdCSAaoVVD+AdEpJCd65CilFwAaA3AsSFwTlc1AOAPkeVHyDEiBYBah+ABkCwqB0BhaERR5YOyhZgZWDDAInenCEI5wLFQcrBikEOQ9kHCRowTaClIAwxHSQEEgBVDEzM/Ouq1cZrt7ZBY5oKVVmVbDhzMxSqlKqzGAes5QqKB+CdDCrgi0AC4PiDGwuRCc4mCA6VEHRpArKxlIgM6SkmFVBRoAiDJzqQY4D6ZRSZQYhhE6I6aogX4OiTRXkUFDwgg0EByNImFlQVRVk8JY7d0AWMYPYMD1wE8HmgzwLkgE5XwriDZCZIAeBPQpiQDwqBfYuyHMgPSBjQY6WAqkGxTYoUEDOhCtTBSVhkLfAPlAFuwEUDqogApSjQSUSSCcoZkBqVEFmSYFLEVDoqULUgBwnJQXyDkgaZC1YHJQIwT4FGQcKc5BDQY5TZQa5CBQkzMzMqqogBBIGhyLIfYIgV4Osk1JVBQcmSAWEAXIsyFFgc0GaQDmXGaxeFZRhQMlDEGQXM0gnyEKQgSBRVebuq1cZ7tzpVgVFL8ihqiDTQWkFQqtKpaSkpMSmpDCrCoJYKVJggRTmlNgUVWbV2FhV1ZTYWFUpVZAqEMHMDFaeArZJFSyiKgVSkSIlxQxSBDYlRVWVOTY2JRZkGEivqlQKRJ8gRG1KLCj4YmNBga8KDl+QA8ERqQpKB6qqzFvuHEgBORYUbJDQAkmDYlEKmrZBPlCVSolNAVkMsiUWZLdgLLNUiqqUYKyqqmCKlBSvKtTA2FgpKdWU2BRmwVhm1RSIZ0HOl1IFu0w1NiVFVTVFEITB5kgxxwqCpVSlmAVjY6VAyQYU32D3gNwMSn1SzCAnqkKSgaCqzIE7WwRBaRqU6sAhBApykHulQJanpKSAQ1IK5DDmFFDYS4HCSUpQVTU2FuSLFGaQP1JSQOEGkgaFNcjbqlLgqJBKiRWUUk2RUgWFZgokeMFxkCII9poqKMTAfosFxWCsFMhXIJtjeUGJE5T1QO4FORrkMDDNLNV95w44iYDcCJIG+QakVEpVFywUDJ0+TJFaC9pavMgLLLCTmZOTc5WqFyfnJtWFnJzrvFJAysBMW8jKCZBjVEEKOFMEj3Nybk3htJWCrgkEbW866GUL0hHLycl53Gsxp6ot504QnzNlByfnNpDoOl3BpZyci1VVdcGuAeULUODDnAdJIqAogYQ4RByUIcH+AkUKKIVIqaqCbBDk5JTS5YRsZVjDqWsfaGsLcvl+Tq+UBJBOKSnBKk7OE6ogv3md59SN5YScLAfi70gBucw5OIGTsyqW85lqISfEG1ILOF297Dk5Ofel6HZwcq4HJU5QYgalDhBbC+oGUHEMjUUp5gN3toDcCPINKA+AlED8Bwp60Gr8raopnPNV13OmSBVyenlxLlWVkuLkPKibcpaTcyvIK+tSdEHhBAq8BZAp34NgS6WOcnKujVXl5HT22saZksJ5DqSKE+T+9aqg9RcXV3Fycq734ixUDeYEL0NaaOvMySkFirajqoKcnJzLQMEMcgUYg8sIUOiCDIclEYgKKSldVSktmA9AtO28s4nP5ql26AYn2nIeXMPJGRx4dN68bfs5Vfcl2nKuqOI8uJBzTSCn7dKFnPOkFoKCr3De+cR58wRVpaR0dTk5d3JePMp5eYVzrCtn7BrOpfM4j8+7HLd/DSen7jzOfUtjOb0uJZ4AJZHES/PmJc5buiTx4o7QYM7Fa+LiCp23buO0BaVTKVUtXajLpVRVdXVBjlTdcucAKJ+qqkKdC0pMICwlpQqJHVDYS0mpxu3fz8m5qkP1krP9vDOc85aCkshUW07OwoQT+znXpISC3CmluiRwxRpXkCgn53nOy7Gc5+fNC5w3z55zzdLAqiXz4s6eDe5QXcq5jPO8amHcuXnznefNOwhK1MEdVTs4L63jVD3TAXagqqqWqpYqyI2g2AflRFVdcJqQ0pWS0oUkEVD6ASlR1QKHNshnIC1SqvvnnU3cKrWWkzPWvsNWdR1nihcnp6oXZ2gK54rChKX7Q704z6/hXKg7j3PdPFvOFWs4QaE5dd4OUCxK2XLOO5t4edG6rZychYnLUji3zjvLOW+el3PVwsBll89ynr28qiO4Ks4loVDVnnPNvHWc86o4Oc9xJtqGVrUnLqyK09oXZwtJs7pgh4NiHuQwKV1dVUgpcqBbS1VLS1dVS0sL5FotKVUpsICWlq6Uqm3cNq0UTteLnLGcK7SCO4Lj1quqqi5Yq5tiG9zhpcrJuZBTS9c5VnU9Z6zqQk7VVR32UkviwKbpai3psNfdxsl5QleV097VVW8Np64u51LdFOdtUvM49XQ5z6jGctqmcC4AJZGEKl3bOC/B45yxWonrOS9qgYoVflWQu3WlVEHGaUmBQlRXS0sX4sotBw6o6mqp6kqp6mqB4kULJKMrpQuS1wUlEy0pLSktVdW4JaoXOVM4t3Ie1FK150zR2sGp6zKVP65Q6yJnuyunbmiJqq6qrtZ8zhRVzkuBy3RXTb0Yx5nCeV7LtsNLN5jTS5UzUDWlI1jKvkM3uGMZ53mtwjhb1f1TU7w4F+ouCzWdaqt7cQUnZ06srZSqrq6Wrq4WyFIQLQV1iq4uKIGDyypd1QMHtqjqgoJdChTaoGSjBdGkpSslpSUVHLhVi3PrVPsUziUpnDtUL67qCLaNq9K1td3EmRLLuZPzkuoSTsFYzsVatpztqpecY1U5N6lqaUlJaele5owFlQi2qpedlyRwruJcr2XraqulGmqrx3lR1ZYzGBQvulP5Ewq17Dm9VA9y6gYnXNbycl7VYa81lfP8ca1YW1VdKS2QWbq6WqpaUrqgtA5KC6q6ut0HDjAcONAL8hQo6EEYFA26oHCDBLdt3DZdrRTXhEuxnCtsd4TagtZcr1Lt4ORcZj81VislZSHn1nWctlrrOWO1FnLaLuW01QUlEVB60z3nHKylpcV5VCuFUyt0J+caTi1dzqVaKc6XdnJyxupyntECVSn7dBdzagUnVmnZxtmmJIKi6gzniq2bptpyxnEeBUU8KCGA3Ad2DsiBIKwKSiKgVAGS0VIFxYMuKIJAGkDCuhCermrcMi9OzpRVnJzBWlounLFaO0CHYzN2LNPaz9nOyTmvQ1VVV0tXdRNnipaqbmiKlv3U85yca8BJxFYrmPPcmsDLuikd9lrBHZyuVbGc53UL42y19k9NseU8o7vKmX9q4U7OnYWBnJyXwSkXGnSgnAaOe6ggmJLS0lLddWALKOVIgdSB0jLI8WBJkGt1dYMDt8Z2BHNWaS1caNthq8Vpy7kmZV0H5wqtOM4UrVgpzv1bOReqxnIuVrXl3G87n1M+hXOTFMijulprAlO0UmzjbLVWdSzj5FwGTyLnzsQt07LlDNZaFcfJuc02oVDXntNW6yCnrn1ooVZw6LmOwkuca4NDOTmXgAMNGnogJ4GwFsh9Wr2QJAJyYg7I4aCsoJUDjo0cLa0cXV1dUBLRjeUE1dCJHZzz7OPWnDunpcW/k9OZcWqsrq0tqGlhm6O1njNFayFnB+d+La0lcSkgs7S0CkFJxBacRFJCgzl3gJOIbkogZwKnrhYkiUTpcnLuAycRXVAScQVVpOBtnV6qqoWLE2IhLtXS0s3RAgUGKOAhDt9yYBcoqYBcCnI8RBCsGsLV0tXKAXnbNbSDc5VWrOtCrRxdF84U3R2cWws70kKX6e7gbOeUTAzV0tLK0UrZxKmqa2vrHKsLSiK6nJAkohvMyZl4MUULlETsO/iXuM4DlyLBOZAkorXKmT+UkzMwRSt4fZwr2CEgF4GjHhLWIC7Y1SC35+iCkwjITSBxUOiD9EBokGisVnDgVlvOeZycKbqclzhTgkOXcnKqpthfTuRM5IzVtdUDtS9StGI5F6fYcsZ1cG7VVeXcBLYoR2sNZ4qurUucrVZsxzLO9Zyc63VBpYhWImfiJS1dW85g3VUdCqs6ChMKdV3ASUTLBZxEtrlyJi7WKuHfydkRDHIjBINIXVCwQIITmkTAjs7JgcRsjlYOKHRBSURLKwdU0WiBSuJYzhWxKVr2cedc+PU41+gtcXbh3MYIqmgkORfk8J/jtNdayBlbogtKIiVaOaB05uJ8NHiBMycn/7JQxdDgVXGcOZKcS7VKnLelOJ/T4ufc7xLLyW9/gnN9Iv9WVz1QEtHa4RzMH7qK82IO56oVnC62nOdyQFGoC3IYiAUxVitHS1fr2C5QEskBlRxgu3J0dUEpG+RycOrIAaWQHN2SuCWxWjm6OZxrtLRy+CEVDf9Ue85NwZyc+zljz8aBIkdL67LzMhfOc5wHgxdynueMXch5Pse2Q0/LntP2fKKtrctUBReXjmB+zhOcnMELOPW09k8FlX8umzj5pwbbBtpy7rNNC7UFBxcoJYPcBHKhLsgJIFeDOKDMpqW1a9cxKVBq1wKFsC4oiHLAjgd50rbDPrZj2dF2Sd1Q2xLXqWu0LnLqFoamcRbqcXKeTQxmdNXjvGTrHKxlz7nYxZbzTIoWqIDeBDZfV8s+ztaFcyHn2WBOzm2csaEJ63NASaQk1HYTp1ZwFKdC8KoOU5fEds4E+zWcKVoHObVSOBOC14TadvBvDQzuaLeN7YjVzQEBkMNAqSAHxAU5S0u3d9cuUEUDdijYkyA3g1IQyG5wRgzm3JaTo7sYlL3X5uTkuHAmBAbu1OPkdN6Xctm5g1NyIWfO2bhgzgROZ62FnGCdSzhBCQUUWfs5OziDbTk7QjelxAVrcXJqgZKIluu2FFCzl5OTE1TRcBZqcXbETU3Rsk2wzSnh7OhYG8t5Uaud05YzNBBkHiygQe4FOwiUTrSgSQRsHyiWQbaBvQdK32AtII/k5GglLAF7i3NNjpYWP2dszg5OXf7Q4ELOUE6X/ZyxtomglKSVo8UZ2sFZsp4zlHPrec4SW1AScbYFJRFbzhU7XTkDp7rEcbpy2tpydnBu1crZ3wHKmh2cS/g7gmM5z2zjTAzlBBUeIJtADskB2Q1OBiDX6IKCEmwNKImAGSBF4HwKUpSTA0k1nB0dnLGcwVrBrme0OAODtTgX6gZzXl7hysmppcXZMXVBCuclrcWcOXGcnHGgag5kBuc6sJUg93dMBTkvlFNyG6eWbdx6LVtO2xytONtgzp0XAzkDL65K4EzglFzG2cEZq6t1kDMnZxlnKGd7SSg/KCo4E5wPQkMSZB4o8eUogoIZnGh6dx1g2LWrdzk4eEGxAMEgry3XWg7ygZYtyDN6tjk5tnogVba2trbLtWxdgktytOxdcnL0bHNKbHVBolqStrogh0vagsIBZGSOrYutVk6OS7CWlm2Obo6trpatnpaWrVaOpK0WSEeOra2t5PIcLZdgUAjbgtzm4qK1HKJI18VFS0tLUg0e4SBpkAu0cpbngJPIcpBtILu0QH7JyZEEscEhDvKpLjjkbZfngPTZ6oGMsc1ZLgnyiJaWrYuWFthPOVo5y7WWS4K9ogtyrp5tznKQapC3bbW0bCEuBTkXZLqLnm4OSKNuTo6LXo6WrZaWpG3OcpAHQeZraeWoaUGLPDAf5ECQ20Ahqbhcq3vXMZBT1SCFdA7IayDnggzW0tVysQcFkxYojGxttXJsJbVybG21gvlzJJdr2buUaNlKgsIOFG7LbdnA8WQLKru0dLUUc7RcXHJytGxdJHXBHpTUWm6bk5MDdr+era2tHsT9upIuwcvB7tfK0QNFDcgaW109l+ASUBIBBRTItTmguAOHXk6Obg6oFNm1q1dLDeSO5ZLL1dS0JHPUJCW11MBuUFueAw55yeXLtZYvz9FSy1m+fLmk2vLly9XU1LSWa+VoLVeTlFwOimAIXxKUnkA2LNfSWg7SlAM2YrmW2nItLTVd3eXLc5arqYENACdBLcnlOSClWjlaamo5asuXg4JYa7nachAXlEJzloMCFGRbzvIcNZCZIGNBpUh3jqSk1nJJyeVqy9VADlPTUlMDOShHS225JMi1IJ0gh2rlgMyT1JLUAvtAMgeUtNSWL5fM0QJ7VE0rR01teQ7IfyD71UApMAdkky7IIWpqklrL1XLUtNQkQUGnBfKJJCgLgeyERDjIpOU5WqCw0gVJL1+uq7s8J0cN7FFQwIIStuRySXASAbtBLQfkiByt5ZLLc0ABBzJ5uZokyHBdkP2KIAdBdKqB/AgKcpAvQPGyHGQP2KNqIPcvV4MEEcgcUOxoSYLCE5RHQD6UlJRU05LUgsQoKHjVQLqXg3SC/ACKHXAQSYLDABQvOctBHgWlbTUtLZBHoUlEUk1SUg2UPsBxsxwUxFAXqanlSEqqgdKBGsidYFWSIF9JqkmColpNEpywloP8pAYKlhyQEcvBiWj5cjU2yeXLQTG/HKwaRKipgXTmqC1Xg0Tuci02kMtAqrRAMqAkqAaWBZm2XG25JChNSuaAfKKmC9IHco3alV3doCJGbbkaSCfIseCUoqYGSjQ5OSCbIKlZEhRSoPiVBEUZ2P1gj6qB0gUoZYD1aoGiU5JtOSjlgNwlqQhSvVwSlNwgZkF8CwplUDpargbKLSDHgdwFcgLIJaCYV1sOtgjEBXtlOTgTgROZIqgUAenUAgUlWCFIdjkokYMxyHUgBihVgAwAB4wiKGeAQg2kDlSqggIH5FxQhOSA7Fi+HBR7kstBiRzkWEk1WVCYgUJRSw0UHSBfgb0Jjiu1HEk2UPqWBAUq2LGgXAeyQVJNDRQEEKvVQGktJ0cNnES6+yUl2UCyYLtAoQyyqLAE5CYwVpNcLgeKUZDPJJezgeMf5ABQ5gYFJRso2iVBhkiqSUJ8DQpRsD9A8mpqimqSanlgH4P0samB8gvEUSCFkmps4OQGShCKYEeDXLlcTTIPzAEpYVsOiSqwGYpqase6u9XATgYJgBIxKJGDQx0kAE4doDS/XA3m3OXLJRVBUQpKkKAgW75825LloEympibJBkouy0u0IAWcJDT1LgcHlxZIFJRqli9bosamxgbSA4pKUBCB8gcoTEApC+QYNbBHwSKQOGIDhZqaHMilkpJqit3dVySXqymCtEuCrAYFJChJgGwEBRbIo6Asp6i2HKRTUk0O5GJQIpQsVAMFOzg4QHkW7FKwT0HuAJmjBXYayBSQiJqkpKTickm1HFCcg3KJXmEJyKOgUAJlZ0lQggJlfZD1YKPV1BBCoJgBeRTs+v5duxi6u/vZFNlAaZMNFAZsbGpybJKSO9apsYEiXI5NMpbTdrmaJOcatXmcJ5azFfKzscmxrecsYXM5qMfJGbjmMmce2ypONjVJOTVJNTY2ObU8Ts7ES/ycamz84DFgTjVQd00PvJ23EDR2zJZzkJNzmxrneklbzjw5Njm1EpACtZ071NSOQobJozjZtDjXg9TaMnIGS24qkZOTkwOVJ3JsamwglHLoULcam5za8uVskmxsoKIDJK7GthzkDza15SBngBLncjmwKpA4SBTkPzVFOZARcoWcJaAABSVPW0615SA3FG7j5FRj0+MHRekqTja5S5wloZycsUs4S9QYObVKOAtB3gN7VE2NTQ6kc7kkm5qcGhuIBCdhUEIBpSeQ/Wxyy5ezsUnKsYEINTU5NsXubnZFkC5Q/MtJgkNbkU2STVYRXGixLZeUk1vOxqYmKQnSqSYnJ8nGJqmmKLmcTe3o4uVsbKCYyZvKyXlGTS2Hk385GyhFgcMWHMLzgjkDtZYHr5BVU1vOx2nP5sJp286ZcDaYM1jOhTNY7cw6SXChzgYq2cE62dhAIcQmuVxNTo5tuexyOVDgqoEKPVBpwgbigWK0v7ubYVd3P8gDoHBTY1MDu1yNTY3zBpuaWvBaW1m1PE5ZNTY2fs4bapxqnGxbd6jJqrGplXAuUeO0P77iRtTUEs5lJZyFbGqXbNXAUcC2ZN6NtI5gzjy2y8eDnYNdXEo47YMXzw92OeviwsZZWHJiYSGnXnCHfdz6YE41kEPUSjhvBG/jLInjCw61dzHl5Hfh52TL41y/b1/JTk7+0IVqJ/LAaQ+UGNTUQCHFdejQoUN5oMgBuVpOTk5NTg0UF6B0AooRNjZQULOxybLJSkIiEJSuwPrBIa2mxlbCuY2Nja1kcbCkGhvnVja2JZwl9pyLbNflsa3NY2Njky3hrFJLsN0RyObCyca5U2sdvyxbIWeJHMhgSbAZ4BiWBSdBNjk2UJiA3MImJwdyIciRIBepgeIX5GY5NjVQKcIODSJQ7IOKTnDaBZXg4GSrpiYLMltOEuoXkKEQCc40OTW14MV5cttCb9hzqrHt3AQ2aDkbWzC30eX5wZtu2HNe3sYZHMwZrMbGJsl2mVONc40tJyNjoloVZw7nGjm5YOcSsIUgl4FSHiifg1wKxiDDwHEHTsCybCBJUMyAXNO/qxtcirDJyYFSO0wpG1swZzAbmxqIVCvcsY2fTY1zybI8zjTOwnkgM9nk1JZxLuNU43RRy5savIRzCecNNllnUJEAcsHiKLa8hCXz2NQ4V9k7l5Tk5XHqqW3jLGGbx8YG8l4w5/EdoCQYtx4UNSDjbnCukgvmtD8+b/F5NjYXzmA2fs6SG5zrOW+o2YcacnKWnMgDOQxkNDjQ1BRBKeTQQ1BMgYo8kIfAbJAKkHmguAL7GMQAyahBlIHiCsQFCdvGMbKBEoq9mhobJxuj2irOG7Gci4I51UApBKTQxTVqgVriNjY1TntQaajGxsYYZwvSCYpRkC2gsgacTsBGgkVgUnIg2yHJRg2ckMFpV7a3+4qaHFg1iACLgRggZ4NokABYJ0g3uHqCRKoaWxqnHpuaHCjXBQersXHmqXHaM4ISMtg5tpzBy9ar5U1dc4nTFpRCQGWDGmcwp9yOE2xsi9eUcAZzsrGx3eC0BZkPtQdsJYgPcjZIjE0O5GewxeAEAjYZZBIbqBTp7u4HpRuQNFgCrCOYM0+Nbf1Wzq1bgznPX3Tm38q5g3NF8FH+eba2IHlQMcOZl8fpwqa2wP4GZyDItv22oGzLxqa2gJGNbdF6/qXBnHr2oB3WNzi3bgXl2XmglJfHFsy5aSsbG+eqwAWcwRB33eAMZtzPqeaSwKkHTSLOnJyJ6zkZ5exD3Tm3LTmRpwY2GuQfkFN/gpPIIS6Ik8HRpCYLcjtIAch5smqyoFIULAQSA1kDEmcD6QZHLVswpwsb29b1nIVbg5esd+HMU7vEycloe3TbAhcXkDY2WbZ9nPxqoIzCaa92HJSYQYkXZCM4lqEmgvwNth+UOEA2gAVADFDJCyq6wOkXEtWKvd2nQe6CxQ+SHpBrZaFmgtwIVgJ2B1hRHqcaW/DWrZzr18vK5i1YobY1IY+TEWQLyC9rFucFc6bd6HA5k8dpmgYqAdlAheJWtnkH1diOzmPbxrkEnERA5YsaGyygIA4FBQ7UGrBxIAJUAYHtB6dmNUgS6QOrghRpIMeCyw81WbV5ZzjPnOXnVFNbuH/BJTZG5+BgzotnOKE+UeNUUwMlkU32ajc4b4BNYAMbKneQUU2tYysfZ+E6NRfnYHv7PM79m46yqbHNk1Oz5wQlkQWX2Ng4YxMXnNgEcpIaWx5oyj6YTW3+TjY2WX5wKWIfzLme00XN3tmds4RzASTHgEOLjY2Na/KhyeBEkgf2L8hSUCNBFhRX4LQkC4ofEIbEEZssm5osNOChImpswYn8ampn53GeOWPPya/Ayb9jXTDjVH41zp3nQckCFExpIA/ysbFx2rMFgzzIxu8azAZKfCBJkMOhsQH2OjiswQSbGhssskF8iL0gFptab/dpiP1gLsgIaFiC9IC4MBMhlRXIYxDRKE42NpczZzjnzVNTW8p5I48zip/TkA3kKzU1e1cXNrZLHedBruVPOLgKYuENTja2MwfZ2I6eUVPjvKEGKkWCQeEHqvDAZoKDB8QCuUUNkndAXAgG1TIgFWpybH3dvQy93X0gcZAIzIlqbMHOjHKgTB/MZs+Zl7f48oI1bPycLpx8zsGc9iDVbHJ5IDddUsvj5JNdxZnHxiZ7ORic9tjY1heqqXEGq3Hu28ZmH3cjLy+Pk8+lw4VNFlSKhKbJ7Zg673jejQT7uPWgVhVITx7nKlA5obZ2Jxuo0QOqaNjUONdzrlfj52TkzFvBCSoUwLaCCMVDkydDksjPR2zg+hEkysYmKwdKC1AvQJIKWB8oDEAxA44OWTY2aGrhXKbGxpbHyc8GWlbByXliP9sNzhucjMf5joLypxqbbBqnGtuJpXk3OoLVQEW8GtsyTphREAsRaQPMAlUsYAlZqA0gUVlZRHqVBZcikHIcnIkhsSnLJgtLU7LgqAIbAko14CgBKQIFuhooJtjY9nPeyGMENe8589QWr2FjUzu/D+SqYGd+tTPBwVuXXQTZCvIYKFXcuMG5hE0NFDtq9qGQfAYyDh4GoMCHOxtUmauBW6kgIVD6BBnM1tcNaov0gfWBsiQonEGOY1M7eIYN1HQIZlM7cXABp7095zzOy5zBsgcvQcKJjU2NU41Nbeo+Tk42NnASSesApR2QJ4M7FnOuy1Nb0GHP5gI6xFKNk09t0RlQEpFl28G5Is7entM59ITa1PVsfHFgd+dxrgI5Vm3FTllZaCkCSiJ8HQtDd0Zx5vE7gwMU7DY2Nrafk8FpBJROuOChCfa1PogL8ossuEcBzhsgLjjZgBkQAhyHZzaxqbHd4OSXZVPL4+fMCw4FHUXKqFa1g9MelI70ZdOcZdn4ORdwXlRjAyURWbZN89jAOsEhB/IoJELBXLCFoNpQH0SAUiTILRApCMnGxtbbexrsALB7wOpAisBxqq/GBnY92EiIdyFpCaxWjfMyODby2ApBp87k5amxcTKyBcdx5rG5LOIH6eEsZLu0hM1+0dFtYOPY8jj52MC9nTw2UNuFTbYQ1CCB2g6iQBjkBNlHEBaIDXENiK8G8h6IwcbW19vN0NsLLkUg8iAS7Na8jjw2Nn2Qu/X5XR7ps+Xx54FzLH8eSAyk7BEbG1sePyhdgENkGyixgsQhovogabAB+mz6oCocRLLpsz0CGwCq8PPY9PXZwKrAiRKUSEA2sj16BHKAvposyE59kCJQGIPEwKYLTIYAcDoBRSakegNZpQ8KLIib2UD6oKaDtOmD2wRQAiTAlneiEEyDDX7E9iiPP5hN7REbm0seyEA5sF59NjUXFzaIV+S2nQCnZ7AmMAHKaPpsYIVQg8HZHiwANhUaUmA2KOn09l6FFDD6YI9CfK8vB+LowxRB9YDqU5C4LMg7+myyi0B2g5oCYE1Q/XkgQUjaAhkPCsFgsDlg57GxsbmAYwck5DI1GKYTZCzYjRC3gJkgJSCbQBohUQJigTwITSLb9dm4ICq5QGpBsuC0qK+vD82nECEQCRIB+QcUbmBDjdhAduqzXVoPEgIpAQk8QjIJZKccxCCITpAl+mz6RmCfgtwB0wmSeARSAzICahQ4rkF8LjZ9fX02/YeTJ5dDEsnkyZMhCZ0L5AKQEpB+CBvBAhuj/4iNiwsaRiApEAalB4irQFpA3oAoBcmB0jIXJLb02dgg5uuDUiqIC00zENWP2KA6QdpACQbicZAn9MFpHWQ4yG1sj2R7e6+CzYAIgXwDMgOkFETLgc1mA5kHDlhw6ID8rP+Iiy0PHD9cYAlQ8gc7HBRtIJ0g80CqjdggTgN7FBKjIF+DXMYGytkgf4DiD6Sei4sN7Dyw98DGgqIJnOCNwHaBxEDx0tfby9Dbu52LiwschKDAADHZ5PS52PRBfgeZqM/1COR6LjYufS42Iy59Ni6wA9mgLuQCA3BAcoFyE0gnSA3IQWzgcNaH6GTTh7sLZDQbyGywWVwgzdCgZQO7BWQ2yBKQZ7nYjCApWJ9Ln0tfoHxyeXl5OSydyIKcC/INyIVsXCCoDzIBFClcoDTIxfYIZDzI5Wwg14M8CjIZYrs+iAIHIUQnOJi42LhAgc0GihqQQ8D2G0EdxgajH4GDyAhsJZs+Fzxlg3wMcsEjUPCAvRgcDOKzcan1914FhTDYvqdgZ4JcwqUPCh82NpD3wIaD7AMFNRs42EDSkHTABkkh4LDVB9kLCjyQGJcRmPsI5DaIHpARYB44HMAGgZwLKptATgIFGMhqfbBHuUCBAAolsO3gNAONYZAl2+FJ5BEXFzgUjMDhCIp1NiN9LiOIINiLRiBBUIywcXGBQ4YtD8TjAkW8fl5enhGXUR6X/iM5LqNHeWxseSCdeXlcRlz6eXlcXHl5efpGIPIRiNA3ysvLm5HHxbVUjQtkGBcXlz7IeJCxIFvYuIzAwiBfguTA9oAl2G6Vl08GwcmTwUlFACQKiVOQHnAC4IL5BSQH8pSR0SOwCaBkwPWIi83ISB9kPBtEFOwCIyNQOjQyMuICeRqkEeQvEA3WBDYXpAmkk4tL/xHYDlAWBRvEZQTSD3YtKJhBEQYOMn2QDWz2b0GCXFxs/b1XjUDxwcVlFFwHMhvkcFC4g+IVZAVEnRHYXCNwygaFCsSBYPUQxSAmG5sRF5ccKHBg1oKj5RFIDmIUJFcYgeLKCOR9IzY2I302cIyC7QHFG1g1hJADJQuIb0FJzwgcA/psbIgkAnYHRDGECXIcCIN5IAYIQywHRwaX0SXONaAAAmkq7AjlzONycXV5tHg/F9eZ+VwunHlcXIWcnAu58o5zci7jDg3t2DFja6hr6NoZzqGha2ZwOrs6TzXl4rwET5Ego0FGwe2DciCUESzVgBMGqBwBJZXyyZUgabCPofpgbIgbwcEGdjhI2ggUXqBkD9IEEgDTIGlQgIDUPgK5AiQAorlAMY9QAmIZcYFUQnwNNgzC5OICJUKEVyBKQTaAAjr4mxwoMtn0+3uvgsoOkOz/XBCJhCEWgY2DMhHmg1MpVBSsBSQF9qg+G9RBILvAmqHyIAqkCuIPEA8hC+aBsw4kkEBqwN6C+A5sEYQJkt/e2w+taMD6IBaBJKBcqHJU48GCXHzcnPyc9hB1RlxcNzjzuJZscuG6wfnIiPMGV+G641xRcfxpcfxr10Ut6zDizJvBeYmLj9PUfgbnjBucO/PyOLlucHFFcYKSPTfCRkgsQu2DWAQhQRaBWJDUAScPgcTB2sEBAuKBVIF9DBaGGAUWA0lCMIIL0QXiQ2QgeiCuABkCloEoAikACXFxg1iQlAaWBiUlsBA0+EBWIrRwcQW/A9U0XFz6/b13QBpA+NtHkCq4BjADJA4VRTcOTRjmLFj6gNgG0g/CMM3QFI6QBJkCVwBhwCXBPoPrhBgMVrK9v5ehvx/UFoGECtxuuGmgbADTCWaDzALrfbT24kJQkQ7iGHHd4Jwxg9OUcwYXJ+MjzhmPOPk5H5l2cPHP4OZUMDIq5OLM49px0Iib05TrEecjrq0nHnFz8nNxcXFzKsAMB1kNMgoS9hBRsIUgJoRhxMX1EJo4KiCgvByULSGyIHUgDDYExACHO8hYkGegAihMSEBAhZANAbNBHoXrApkFNRhKgYQgGC4A0QZJMci6v4WBtHNx9ffegejgsnn3FsTC0AlyLVwQpAKEEQJgC0BqQMIQDJIEYZgvjLgEIFyo56AciANgHIg5cDGQMAhDTISmLKiBXKAk0ts7m4tLAFSpQ5IUTCGUhlNgcxE+N3rEycm9NI2LC6QTVIrM4Oe8wcnPtbBK4QyXKecMTkauQk7nOC5wIrDgPLrQlZsLkkRu3OAs5IIkESPOR6AkAbEYbAHUZ2BbIc6GkFxGYIsgKaTibkV5RXlFRUV5xU2QLhCG6QArBxPgIICzIHaAPApiQYVB3gExQRgc9FABaDkL9hok8xiBdILsgEqBmCAM1glmQFgQ1bDwBZv56Ns7cGlrBEoiIFVGXG+nPQVLgTSCLIDQYBLqUQgbRIKcCzUP6jqQKBSDjINKwkTAAQURh9gBZYM5MDZCMchMCA8SinDtIK4RF9fsXlApMptLgEvASACW/EBmCXAJwJ0ODmoBUOYwAqVRASNQSWvENW/NVk7OKLAI1wxQKbI1lDO0kEuAc6up0bZQTtdVj2bMMD04A5RE+Lk5lxzczyUATiIJx48veQRJIgLSnArgmAe5HBQfAqDECql3BLjA9oAcwwVKhyD3cBvdLQeljIqKiruQYqRiMsjtXALcAiCFEJ1cYJ2gpifUWAEuI4jfQL4CWQES5wZZDBEAccGhZMRlxA32KCiejEAO4uICU2AmKIjAykA6YU4Cy4AiCWYIKAkJcIGNgSjmkvv27ilImVF//wGQKgEurnfvnhgJgBwN8ho4kkARAlYPyqwgVSAMtR3kCiOIhSCDQTpBvgUJc3MJgDwK0gmyAhR8ICmQJ2DOhXoY5FUjLmgtCXIwSA1YL8hGLi4uC7ABIAKkEyIoAEoi/Qz9/bO5BARAJoANExCwAHEEuMFiFrDgADkCpAwsLSBgJPBo6rZHCzkfgVVxc85YxXmDc5vpzkWP+DkXCDxa9MjU/fhWzhkWO7dx7nwkzfmIc4YpJ7+RAKfpo0ecj4wsLAS4Ofm5BbhNOV0gBoDSp4CAgAUoyMBsCwsBcHoGuYULFPUCFlwCAuLl5XfvwlJHRUXF3IoKLpBDwR4S4ALpBPke7FhQ2hEA6eQ2AhnCDSIEwLaB/ATyH8hEAQELUGIRsAAnBZCMkQA3zKPcFiAzubnAdoP0gwwGCVmAIk/AghskAXYzOIRBrgDJgo0E2WRkAbLw0btp30BSRn39B0BJh0vg/7Rpr0DFEijhWhiBLAH5VUAAHIEgQS4jLpBWLlCIgGJFAOQmkEchZRkopAS4LECpCKQaVM5wc4HyOChiQI4HYVDUgVxjAY4ykAiIJwDOBKD0Bkr8oNQmYAFRAfE3TB0o9CxAiXh2PyiJFFgISENsBRsC8hYYcwlYgNILiA1yMIjmBgUtGAvMAN0/ugQkKDCDk9N5mwsnv4UCp7TFcU6LqLgogUecLqCpBIE0Tk7OBdyg5smZ9ZwJnMcfcT4CGSrNySjAJbD/uIUAFyjBWAgIcHODxMHmQSwAOwkkCLYcFEACRuXlFdAkMhcKwL6E67QAK4MYIgDyIogJ0m9hwW0BDgwBkK/AAQGSgmAuiAzYQrCIBdQckE5IIIBYILeAeCA7uLhBIiAdMBosAJICmwBlgCXfTZv234JbAJxELEAlzLdp016BzAWrBKU0iFPBJsCdBok4AXAJCSZBxQ7Eo2ApqEKQDSC/QS0UEBAAGQMShXgUpB9iDyjRgpwP4UHyBygRg3SC1AtYQBMLOIhAqR/kRmgSAWkCKQIpBgmD+NJQBtg5UJMtBKRBwQ4REuCPEpBOAykVEHgUxShgkcbNLcAoIMDPKACiLBgtHqVF8UtLu0SlPeJiFBCQZnQxNmblF4BqYRQQEHjEyQgyD+QtsP8FoEkVZCg4PkAMaZDLBLi5uQUELN7DShBo+pg7dy4occPcDVYpANYJYkpbSEOCFOoVkGkQJsgsaDoEmwuRERAA+Q+mE2EOxHiw28BskBaEmyF2QHKZgIDFI1BqB/kGJiItMG3atHePLMBJxAjkXJDAV1DqAruOG2KwgMV/kM0gnRAMJSGCIAeCki2YB8u40DQPcTXEWrCJIMVg48EMUFkHthUhBFIFNQQSlxaQkId5FGQLiA0K9AJwKWInDTYCRIIYIM0gNihfg9IGSEyaG+piaQtQAIGEBLghJNgdoNCFxCWYCzLfApQVuQVAJoEUgtI2KH4sQKkMzIHoB+kUsACZD1IF1i0ACjUQBjvcghukBeQQC4E9d8tBiWRuBSKJMIGiG6IV4kZpqE5wSpEGGwFymTQ4JsAKQU4CWQQOHrAIN7gYATFBGKxTABzFIF0gDPM9SKs0KFGADQanb1BEgXSBpLgFBJ68AkWAgIU0KLkJSIPSVP60afmgHNfXfwAsHJ+fP20GSAsoPMCeBbky3wZECghYWEiDgghkAlQO5FaIHMhmCA8UwkgeBYUlyEnghAIyGiwHYgiAYwAUfCCN3GBzpLkhkQfxKFgBWCnIFAFukEekpUG+Bgna9fUz9PXbCYBEQIkRZAvYTFCgWkhzW4AUgQhQhgR7CCQBDThQmINNEpC2ABkLChqIAZDcC7ME5DSQ30B8kAshaqQFQM6UBkcEqIADRwlICThBgJIWKC2DsjIoiYPZFtI374KbIpAE0tQ0d25TkxEojYHcLy3ADXIcKIRBDgLlGZBNYAtAAtLS0iB3gl0C9hLIXSA3g2iQANgVUI9CIxjiHpBHQXELMg4UNaBAkRYAuROUyEDSIFGQMaDQzn8LsRIWSdICydPyp30TkLaAJpFH+dPy88UFQGkAlILAQSfAnw+uIMDJDywjDTILHNIC0sYg54BsNYZ4FJz6IPEE8iY4fYNdLwD2ogDYj6DoAvsGYgHIhxDjQIkQEtkW0iBdFhYgq0DpEqQdqgasCWSlXX8fQ18fKImATAAJQ+IcbAIoQCERBwobkHJQRIGyA8jF4MgGOd4C4g6QNcYgAuR0SCAhlIESMUQZxCVg88G+A6kGhwvIDpAwKD4gbJDdoCQEigtQ/EpbCDx8fPcxqC0CSiNNEPAepAHiL6jbQcaBkoOAMSTWwKSAOCgpgSwAGw5WCvISOKagzgaZBHK5Mci5oGwDShcgP4P8CrICxAZHHZgAOR2kHCQLUiYtIG0sICDtkl8HStSgGAIZKC0gUAxKEwICFn19u0BRAuLl84PVgNwCxvzT8kEWgIwEOx3EATsPGi+gqAGbBkojEOeCHChgAeaDFIG0gqMY5F2Q+8COBaVfsDkQn0OyMjhiweotQDUGKB4gUSUgIGAMtgVmhoC0ALgU6fssLS0tDrIMhKXFwcaCLJEGscVBfAsQExQMAtLi4iA/WAiIC0hLi4PsAesEudUCpBLsN5C7pQUExCGRJW4hLiAtbgxWBzIHxAMrA2kCJRlpC5BKEAYHF8h8aWkBkGmg9C1uDLFY2lhcfM7du48fz62A1DOgJNLW9l5cAOREUAIApSOQF0E6QakVklMFpMUtxEGulQa5XBrMErAQFwd5DiQEcYq0gDRIBOQHcZB9II64tLgFKPRBboEFEcjN4CAAaQPHEigGpMVBwQ4x0Xha/jR+UNiAkyHILbn5+dOmTROw2N63y0Jamj8/P39aPCPIsWBHgzz6Kn8aOApAthmDjAKZDHYcKISlLUBeAIc4JKmAHAOyDORIkEcFLMRBOi3gHgWFJTi8QTEqDtIJEgFZCY4AkIfEQYSxACjwQP4RB8coiAd2CCTmQK74DC5FPouDAgwURuAANAY5CGwcKJJB+kHhZwxyjzSopAM7UFpa2hgc5CA7QcLgoAenNIiwsbQ42FiwV4ylQWkEbCYo4EBmgmUh5SKICzYYxIAoFBeHGI9iqYD0nMd3H4NKEBBuampramtr+wC2HKTTWADkInGwAcZg54qDTYVEF9Q8Y5AXxcGOBmkERQOEAyHFpUE6jaVhOsEGGBuDKGOQWpBOcZDXQdZAAgIsBA48aXGQeoGn+fnv+EF+BakxlhYQ/5gPAvzG2/t2GUuL54I4+YwgSZAB4uLiIB35ECtA2kBpFRxX4CAChybIe1ApkDpxsEfBQQR2lTTIXpAHIIpBMQvSC6FBloAxSCcoh4OiBRR9KEEENh3sT2lwEIFiTADk0c99oIoGVIqALAAbBLYFZAKEB7IKFDZg80EMqGshfLDB4DgBqwZxIfpBNoD8ATfIWBwW6iBFED9BQgkUxHDd8LgBiYDsEJcWBwUIiCktLX3z8ePH4DQCKkGamiBJBGQjyD6Q60Da4HaCJCCBB/cdyHJwsgMTIB5IByiHIDsDrBFMQM2EmAIOU5B6qA0g7aCcAAtZsJSxOP+0/Px8fphOaWnpt+BE8RGURCCFSH5+PD/ISEiYCIASzVtQxEF9CQkduN0ga8ChDnIR2A0gBkgUogTEgwQl2AEQCRAJkgBlVBAbFNugoAQ5C5T/wOIgBcaQvAMxCqISFDag4ABbipxEwOaDRZGUgwyB6EMhQcKQ9AvVAJEVBwUYhAkKRZA1YFOhQuBMBpIA82E6weECMhCEIcqhLJB3IEpB3jCWNjauffj44ePHj5ua5jbNBaWStrY2VrAK7IQxOB5AJRiIBUujYIvBBNhqiFaIlXABEAOsBOxciCQoe4H4IDdCPA8yHlR0GEMiFepf6Sfx+fHgmgRkirS0+NP8eFAigSQRECc+H1RogEosUNIGpahpoKIDFI3GIG9CjAPZA7EPGmcQDkIYEU9gi0DmQVwEzZyglA8qNuD6kBhQLyGJgOMOHkYgW0DFlDhyEgHJgq0Chwo4esBckPuQTAI7ApkPigGon0BFMFgKrBHMAstA3YMsipAEs6BSkEQEVQ6yCcQEYZAiY2nx9w8fghIJKIlAU0jbd5AUKLBAqQDsaogrILogbJASqA1QJhIPYicolkEhAJKHYkjhAPYAVATkIiQmxHCwUSAChEEhKy2enJ8fH/8W4gJpaen/8fEgAVBbxFg8Px7Ey+cHqQapYJwWH58fDy5PQMUlyHhI+gMpAPFgGMoHOReUsMA2weVAzgdhsABUJXKJDBIH2QaiQY06MA0jMD0KDQmQjs992xm2g5urcOUwBqsxqzQoh4KUSYNZEBmY/SAejA2mjeGKxEH6QLEGCl5WULRBDAFpAQlBaDAJ1olsPFgUZBJUBhIrkEBjZZWe83AOKJWA0ge4mmlrg6mDaATxQBjEAzvIWBrqGpAIKmYFKRSXZkV2HESFONQBICmQIgiBSC1QnajuBnsabJYxY3J8fHx8MoQDTiIgftj2vm5pRhArPn4aWLW0NCuUD8uHYC3SxmBZsM2QYIQ7AJ4woJJg94I9CmaBwhrCAJNgRRAjQTLQkAD7DiwvDfcBVBHcHnByA5sLKkW2930ByRiD3AUSBKUMVhAhzQqmymCmgRIbK0QMZDRIkhXEAOkEBxqIA9YI1qECMhXsV2mwTpBxrKziIG0wp8GSIYRvzApSDcZgAmQKKJ2ygnSCMCsr04MHc+Y8fAhJIZDmKsjZYFeBbJeGGwEKZlZjqARYszRYEmIySAYkCEoKIBFpVlYVsFaQndLGxiB5KB9shArYoxAzQUqgngC5G5QFjCF2g2RAtrCquIETwjRQt4VVWvoVmBcfv317t/RHCHuaOMQ1/yGJiREUVtJgj4LsY2UFhSfYASDXgS0HMcCGg1WBdENEQFZDnQuSMQbrBGVEEA+kExQjIAzSIi2NFORw54INYjUGKYBEr7EKSAPIflbWL+BS5AvUcaDgKGMFhxYoKkF2gIQgyqFOB5sBlQEHMERcBURJg8IZxIDrgBoMFgPpBLsCaiZUUAXERVYHYiPCAhQZUJUg/9U/mDBnzsNZs2bNgjRW2+aC3AJVwMoqDXYHOGDgYhB7wTZD3QUxHeRRiChIKcgVIGkwDRIAY5BKsBpwRKD5FyIJIjEsTEtOBsV9fhrYuFfx8cnxyfHxf7Z3gwoNkAw4ibCKPwWJJydHqKggBR2rNCsoFsAOQCZAAQPnG7OC0oU0IsjBMmBnglhQtSDry0BhAskDIBmQfyBBAuaBJKFcmEfB4qBwL1ORZjUGJ5HtX6AuYoFKQrgQEiqETIEkYEqh4iAhVlZWZFFkNlQV2A1QNkwxVCcovkAyoHyPRSdICozrH9Q/mDNnDiiNzGoDdXrrwcKsKthDlZUVIg4zEmobiAvCEL24SJTgh+iUxqULLg6KFFZp1o/JEMAICpWv8fHJySC0vfspSBjUGhEH2ZoLEo5PTk4DcaA6WVlZQSUM2OFwU0HyEIzwKAtYA0QURIJcKA7SoVIG1gyKeJA4CIPkYIIgPiouA/kOpBMhDDObhfXL9u0M27d/YWUBAagZcLUsLCCtMG0sSAkArAQswAIiWVhAEQ4WZAUZBVIJ5oEkIPrBykDBBZWDSLOCFICkQNrAHFYoD6QLJIlkMEgn68z6+gcTJsyZMwucStra2t6DhRHKwVywq8AskAQEQ3wIJqH+ArsBJMnCUgZigzDYfjADoZ0F7BAQCWKAHAjCYHmwx0FGwDFIioWVNQqUFJKTk/OjWMtYVaCc5H/d+VBmvAorqwo4vSQnJ+eCdYN0gkMI7AaQx8tAVkMcA1IBY8FokGIoG0qBVIFEQRjsXmgEgqTBmKUMlFhA3oBaAtUBoSDiLKCIgHqMhZUFlkRADgLhMlAQggxjZWUpAwUC2N0qYOvATBgLZA5ELchcFhaWMrBWiNtAJoFiCaoYHP9g34LVglggIZgKCBtqGEgSzATLQqXAghD2h5sTJ9bXgxIJOI3MmiXCAgLg0gISoiBnguMcLA42BuoOkAzE+ywgz0FFQb4sA7uYlRXk0TKYFpB+qBoQBVIHFoJ5FKQHbBzI7yBBkAAoaMGq3oaFgVJDWNhXFhZQegkD8eP7w5KTweLJKiwq0RBWclgUKNjAGBRAYI+CrAQ5BB6TYEPB7ihjBVsGkQVpAEmBHQLSBMIgZSDPgiQhgQJyPKgEgHkUZAIIg7SCDALRYCMgWsFOAImxwEqR2cYQLjLJBOYgjAFzIQRcEM6AiKOQTAhJVhYEG0UNWLgMYhMLC4yGqQY7GawErAkcMCxlEysnTpxYP2ECNJVMBMthIxA6YSYjiUA0wG0EJSmIEBoJVYGhE0kZkhw0esCSKnVhUBCRZgplIVF1Kipw3n9QJCGMgXq0DMVWuDTURaBMCbYH2elwncgOAUc6SClUJ9wkkBgsaOA0kk6I+rLZ4IpmOws4giBiYNVMLExMUWBBFiYmJigD5CyIGpAQRJCljIkFBMH2gQgmljKWKJBKFoROkDfKWMCaysDGQ/SCBUB6kDFIP8RCmLEgHhMTUxlLFMgpRZXgNAIuSSbMmQPxMFQp1HEQ34DsBzkBrB3MgdgKk4XwmJhY4B4FOQ3kJiYmsKdArgJxQcJgNowBFQGFEUichcWU5TtIDCQAKUxB/s8FJ4G6urqweFASqQsLqwOlGgiuc/tfFwZihtWF1X1nAeUnsE6QR8AejfoKsg3EBZkMsQbscrAfQb4GM0CKwMIgn7KwgEMepAHkaYg4VAVIHqQDJAExFSoNkgcJgqwAKYAJQ2gmlrLts2czbJ89WykKFFTgOAD5E4yZypigABy5EDFQJEG5IC1RCFEQCyQDUgHSCYoUUPCDrAcZDhIHuxOkEGQwhMPEwgJWzcTEFAVyIdj5IGmmKKYyJhEIQAgyMYnMrIQmElBJ0gZKeUxRIH+WsTCJKCkpiYgwpYH0Q40HxTHEelBKBlkCsx9Mg11ZBibhDoT5AiQKCW6IASBTQSyQZSCaiQnidBYmhfygr1GgVAIVBlsVVVwHA6DEAGNDaYRkXTRUF8z871GmT5OfQnggEuQOkONAGOQeKB8khYJhPoZECih6wN6FmS4CCgqoGggFIcGhDoollihQuQA2EiQD8hwLC5PS7O2zGWbP9v4JiiawJJhA5YGFmEwhFIIE5WkQRhaJguoEWQFPYhg6ETpgLFRzQKJlIiKfGg4fbmhtaGgA0e+ZREDCTExMu2dWVkJqm/oJE95DBMtE3s+smNs2q23WrIcP51bMfC8CjiWwJJL1UaDyASQItk8EwoPIQx0OkkTHYMUQtdAwR+hkAYmXMal8LK6Lf2pqCpUHm1D2sa4OlBCKwSQ0ZaBTxXXFEaZgu1lMwXGpYvrqY3Jx2HewEeBUDGFBSahbQKkFKgLWhawQpATuUbAiWMiB7QGLYCHKIG4H6QbLgnIokylT1M/Z3t4Ms7dv/1zGJMIEcioovKJAsWHKxCQSZSoCEmcyFQGJgDETk4gICIFNYWJiMmUCcU1FIOZD1IEKBJBNIJeVQQIYpAykBaSZiYlJhCkKrBPMBIlDzQYzwUTZ4d2tb1pbISkElEoaDh/OLAOl0yilxpkzQakE3GwF+bpM6VMbtBv8cFYTaOz18cPH5bcUykAOAJsGdiiYBfIWmBEFlhQBuQUkC/IoqNACyyERIPNBoAwU/RDXR0H1gDwB8R1IwduI4uLisI9fTb/DDGYyLSYKfCyLAoU6OOxMn8aDzQFFASzMQKaDwwcUpmAOhACHBsgysE6IGIgLiQqQkeCIAkUeyDiQAhFQVEIYTCLgLAxO7CJRTCIwj0aB1ILiFBw3IkxlX2bP9maYPXv2dlYREVNIsQ4yFxQWYItFRMpEQMFoKmIKpkVEokTgDLC7ITWBqUgUSAVIDmSpCBOTqSmIwwRSLiJSBuJAYkdEhAkUOyBJsC0iIPeBrQEFSTjIGaamn94c3v1mdSsYNGQ2NGQ2ZB7OPHz48O5PIFdlgtLITHBJ8gFkBqTxOgvUE5416yEIPQSDB2VlIpBgBTuyDJy8QZ5kEoE6tgwUMuDwAHnMlAnkTZD/QYqiID4G+QwU8JBQEDFlgni0DOQQEAYZCgoRpq91xRHFxRERyW+/g4wAWfG0GCQASicREaCYBxEREcUQDkgYjEFhA3Kgwqvc5IhikLSbqSkTyOVg80EhBbYE5OoykLEg60TKRCDhCXIqSBoU8SC2CChAQTETxSRiCspSoBASEQF5FBTATKCgBnmUCRSToGQAKghANMQZYENFTEEqokA6TVm3z54Nqmhmz57tDo5TEAEKJxGIU0BMUxAB4YpAmCD/gKISImgqAlFhCuFCJMFRADKMiQnGNIUoEwHZD1EEchRIDdwyiPCHrq6urjdvVoNB6+HWhtbMhsxMUCppOHx4924REabGRlAiqZxZmSki8r4eBCaAujhzJsyZABpVA43QP5zz8MHDBw9uKkHMBLuNCWQhzDKwc0EEVBDkLqj/QKJgZRApUFKBsEA+BZsEIcCCIA+AsIjp9yduERDgVhzxBCwWBuHjJV+JiHw3FXmLUBoGC1GwGyB2gnwBsQ7kHDCGECAJiGtAEQrigdIJWClCJ0QByEWgxAThQUmQShgG6QSZALYXGgju3rPBSaRg9uzZn9NgKkF2g9hg1SBzQXaBaWgQghSAJUFmQY2Ci8F1QlRApU1BCQSkHCIKch/ERBgfJALBRZAUUvtmDyiNgAoSUAIBpZGGw5ngZomIQm0jJJX8EIE2SsDJBNR8BXWFHzyApI8HIPAhHGwF1Fkg54AsBiVXSExAJUB+FAE5EsIHyYP1QQlw3gBpBKtDUgiSAWsBmaxQF+EW4ebmBiaK35qafgVx3CLcIkDiEWDxCDdPsBKwGjc3t+Lvpk/CQNIQgQjPt98RdoJMBjkKGnJgV8BlQQyQAlDQg2gQBomBghHJqbC0D9cMcinI72D1IAZEE4QE2wYlREREwj8XgBIHw+zZBQWzC36Eg7wLMh9iJ1QzxDKwPTBDQPLgUAIrhkqB1IGNBpkCCWGQCWD3gB0DEofqBNkNkgCFN8jlIIUQs0xFQAmkq+tN7ZvaPXtW71m9uhVU30CKkYaGTFBtc/jwz+7du0GJxO4QqFEC7t9MrAcNqNXXTwAliwlg8sGD3zdBQAlqNNhR4LQKcg/IXpCTQALI7oZ4EqQF5CNQ3EBkISyQLEg31CMgKRAXqsbUtNjTE5wqoEQEODV4url5QsXBsiBOBEzgYxhYDKrBzfMVzAqQ2SAHgsMXFFpgi0CyoGCDOADkTLAImAtmgcISpBXkP5APQDpBEiAxkHKQOIiGYJCvQHohZkNIkIUgneGmIuE/CmYXzC4oYCgAg9k/QC0GmEkgx4FMB+sCC4LsBuuGSIElREREFERMRUAZFRRKUHWgtAZJQmBBsI9AOsFuMVUA6QQ7WsRUCcQGGQxSGC5iGv7pHjSJvHlza88ecDkCSiKtoNZIJgSACpLfh3e/2V17E1KUVEI6waABNVBhAsYPboKSCiSJ3ISEBthxEGdBHAJyAySIQIkHFCggV5iaKoAdbGpqCvYWXC1UP0gS5GqwoQpwb4EMBhmT64kBwOkDIgpiQlg4SLevYBeFwyyD8EAhDsPgSIFKg90MdgJMFhIVIBLkGLAbw0E6QL4AmwVyPtitUB5IN8iPIKNAbLAwLEbDf4BTBjyJFBR8DgcpNFUwBUUjOKRAfBEFUxFTBUjEgsIPbK+IKShtgNQoKIBYIqaQ0AK5ABTlICebiiiA3AnSDvIyyARw2IJ0gdQomIoogZSAogRskanpvXuwJHLr1i1QGoGkktbWzNbMzMwiRBrxO3x495tbtbWNjTMbQeMk0G7wRBCov1k/cWI9qPy4efNmZWXlqVvvIc4RUTBVAGNIWIDcAHIgmAdyGcgLCiA3i4iAQgAsDvIoNIwhesHJCBLIIANAJoN4CqBgA0XEq6AglOgP8vQECSCJQkU8QRIgKbA8mAiKgMW9iEg4OOLAbgAJguwCORZsPcix4KADSYOCDmQ5xJWmIqBIBMcTSDnIRSAngvwDDneQVhGQR0GOBqUHkO/AUQqxAaQTGqPgWgaSRqClSEFBgW9UOCjGTRVAuVvBVEkJlDbAKUBJAeROEFdBAZRcQClEBMQEGaegYKoEYoMCVkkBXLIoiJgqgUsYsMMVFEQgikFuM1UwBSlWAgmamoISH0gU7NJ7iCTypnbPrT2nTu0BFyXQJJKZWQQCoITSUAvq37x50whqlcwEA0hhUglOGhNBaeNm5anKyspbt2411maKKCiZKomAXA6yHeIEUyVTEAJlAQWQKCi5ggMN5AWIe0HFnIKpiALIe6DEpWSqBHI8yGcgj4L9DQotcLoyBeUJESWFCHAaCPIMAgFPzyAoC8RDZQdB0w1IPUg2+inIVlD6BAWQKchWUyWQy0CBDwp2JVAOBFkKCjeQWiWQw0WUQDYrKICyGigTiCiBnQsiQP4DeRqUOkREkGNUCWywqSks5pQgMQrSBIpwBVOlcNMvkPRRUGDHUFBgV1Bgp1ygbOft+9NdKVxEAWwJyHFKCiCHKoDThqmCEkQcZA5IiYgCiDSFKIFQUBWgcATJgTWDPAdRA+aCvQ42CqwK5AOQuJKC0idQEoGUI29qb+25deoULI2sbgWVIqCCpKioKLMIVJw0NBzefXj3bkijBFSWgNIJKJnA8a1bt2beulW7pxbUogF5BOwBUEJRUoLYCHUVxKPgwAKVhqD4AcmDZZVA3lCC6IS5HCwJCQqwF0zBxoG1KYA0fQyKjgZHOYQGczyjg6KDgkBEdHRQtGe0pydYGCQCEgBJen4Fpz+YOeDABXMgWRWUecHJAhT8IAYoXEHpHuw4UPCDJEBuA7kZ4kWQa0BYRAGkQQlkPliRAih3gMyGxBfIL2A/gGJeSUnJNFzB/ecXb1C6ULYDJQwGZeUCO2VlEGlnZ2fn/dl3oAA4iYAbI29AFQ0oiYDLkT2g9gg4gUDKkSJIpQNqlYBTye7GN6BmCRjPnAlKGTNBhUfjrdpbtbWrV69u9aOvjz4HRUeDIh6CQWwkDJEDJxeIPEggKDr6D33diNe2z96gBGFnp2xnV1CgbGfHoKysDBIBpRIQtgPzwKSdnTIoGYEVgNgQhSDFIB6IBmkAS4MZCBGQRpA5KOrg0hAGmASlSpjegj2wmuZN4y1QIfLi1AZwSQKK5tbWzJ/Qqqao6AeoxgENqjUcBtU4u3fvrgU1TBpvNTbeAhGNt/bUgsHu1btbW/0KwL4B+wVsKchCkP9B/rEDORHkVLBPYc4BC4I8BmbANYE0gkVBDLBamEdBJsCVhUTnghJFLhIZHQ3i5UIlosF0LlgMpDI6928ByEiwg+BGQZwIcjaUBYo0kCwEg6wDOw/scpBWZag/QfIgWZBTwcaCvAGWA4nC9IDYIMPBOsFmQGQgOsAkxCA7BuUQ5ZCQEBCpDCXA3BA7EC8kBCQIYoFwiLIySC1IA9gIEB8mDzECpBWkCIZBonYgTcohynZwS0BmgVSA9IMNg9hV8ANSz3S9aQSlkN+/f596MR1ckKwG1TWg2gaUNop+fwJRIG4mpB8MqXPAiQJG7F69GpQ8Whsa+kFOBrsS7A6QvXAexAEgIbhHQXIhoGADewUwO4j/7cAckPtBhoGdDPUDiA8KC7AnIRLKygX/ctFANDIfhQOSiPaF6QTZDnaOMsRikLNATJAYxCqwCMhG5RA7BFsZFNBgRSAWyBSQHNjVIO1gWZAIRFYZFN5gRRAC5F+IfVAjQHpAPgIrDwEAUNWP5IL4shoAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Based on the image, **TypeScript** is the top programming language in terms of contributors in 2025, with **+1M contributors** and a growth rate of **+66% YOY**, which allowed it to overtake both Python and JavaScript.\n" + ] + } + ], + "source": [ + "query = \"Whats the top programming of 2025 in terms of contributors?\"\n", + "\n", + "response = vision_rag(query)\n", + "print(response)" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {} + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}