From 95b21cbe10815b1d413bbdc7a42913c8681b3234 Mon Sep 17 00:00:00 2001
From: Christopher Hertel <mail@christopher-hertel.de>
Date: Fri, 21 Feb 2025 19:57:29 +0100
Subject: [PATCH] refactor: remove visitor infavor of single converter class

---
 .env                                          |  2 +-
 README.md                                     |  3 +-
 examples/chat-gemini-google.php               |  4 +-
 examples/image-describer-binary-gemini.php    | 32 ++++++
 examples/stream-google-gemini.php             | 33 +++++++
 .../Google/{GoogleModel.php => Gemini.php}    | 10 +-
 src/Bridge/Google/GooglePromptConverter.php   | 77 +++++++++++++++
 .../Google/GoogleRequestBodyProducer.php      | 97 -------------------
 src/Bridge/Google/ModelHandler.php            | 58 ++++++++---
 src/Model/Message/AssistantMessage.php        |  5 -
 src/Model/Message/Content/Audio.php           |  5 -
 src/Model/Message/Content/Content.php         |  1 -
 src/Model/Message/Content/ContentVisitor.php  | 12 ---
 src/Model/Message/Content/Image.php           |  5 -
 src/Model/Message/Content/Text.php            |  5 -
 src/Model/Message/MessageInterface.php        |  2 -
 src/Model/Message/MessageVisitor.php          | 14 ---
 src/Model/Message/SystemMessage.php           |  5 -
 src/Model/Message/ToolCallMessage.php         |  5 -
 src/Model/Message/UserMessage.php             |  5 -
 src/Platform/RequestBodyProducer.php          |  8 --
 .../Google/GooglePromptConverterTest.php      | 87 +++++++++++++++++
 22 files changed, 281 insertions(+), 194 deletions(-)
 create mode 100755 examples/image-describer-binary-gemini.php
 create mode 100644 examples/stream-google-gemini.php
 rename src/Bridge/Google/{GoogleModel.php => Gemini.php} (77%)
 create mode 100644 src/Bridge/Google/GooglePromptConverter.php
 delete mode 100644 src/Bridge/Google/GoogleRequestBodyProducer.php
 delete mode 100644 src/Model/Message/Content/ContentVisitor.php
 delete mode 100644 src/Model/Message/MessageVisitor.php
 delete mode 100644 src/Platform/RequestBodyProducer.php
 create mode 100644 tests/Bridge/Google/GooglePromptConverterTest.php

diff --git a/.env b/.env
index e54cafe..45ebf2e 100644
--- a/.env
+++ b/.env
@@ -41,4 +41,4 @@ PINECONE_HOST=
 RUN_EXPENSIVE_EXAMPLES=false
 
 # For using Gemini
-GOOGLE_API_KEY=
\ No newline at end of file
+GOOGLE_API_KEY=
diff --git a/README.md b/README.md
index fb94a39..1bafc06 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ LLM Chain categorizes two main types of models: **Language Models** and **Embedd
 Language Models, like GPT, Claude and Llama, as essential centerpiece of LLM applications
 and Embeddings Models as supporting models to provide vector representations of text.
 
-Those models are provided by different **platforms**, like OpenAI, Azure, Replicate, and others.
+Those models are provided by different **platforms**, like OpenAI, Azure, Google, Replicate, and others.
 
 #### Example Instantiation
 
@@ -63,6 +63,7 @@ $embeddings = new Embeddings();
   * [OpenAI's GPT](https://platform.openai.com/docs/models/overview) with [OpenAI](https://platform.openai.com/docs/overview) and [Azure](https://learn.microsoft.com/azure/ai-services/openai/concepts/models) as Platform
   * [Anthropic's Claude](https://www.anthropic.com/claude) with [Anthropic](https://www.anthropic.com/) as Platform
   * [Meta's Llama](https://www.llama.com/) with [Ollama](https://ollama.com/) and [Replicate](https://replicate.com/) as Platform
+  * [Google's Gemini](https://gemini.google.com/) with [Google](https://ai.google.dev/) as Platform
   * [Google's Gemini](https://gemini.google.com/) with [OpenRouter](https://www.openrouter.com/) as Platform
   * [DeepSeek's R1](https://www.deepseek.com/) with [OpenRouter](https://www.openrouter.com/) as Platform
 * Embeddings Models
diff --git a/examples/chat-gemini-google.php b/examples/chat-gemini-google.php
index 04f6865..2967981 100644
--- a/examples/chat-gemini-google.php
+++ b/examples/chat-gemini-google.php
@@ -1,6 +1,6 @@
 <?php
 
-use PhpLlm\LlmChain\Bridge\Google\GoogleModel;
+use PhpLlm\LlmChain\Bridge\Google\Gemini;
 use PhpLlm\LlmChain\Bridge\Google\PlatformFactory;
 use PhpLlm\LlmChain\Chain;
 use PhpLlm\LlmChain\Model\Message\Message;
@@ -16,7 +16,7 @@
 }
 
 $platform = PlatformFactory::create($_ENV['GOOGLE_API_KEY']);
-$llm = new GoogleModel(GoogleModel::GEMINI_2_FLASH);
+$llm = new Gemini(Gemini::GEMINI_2_FLASH);
 
 $chain = new Chain($platform, $llm);
 $messages = new MessageBag(
diff --git a/examples/image-describer-binary-gemini.php b/examples/image-describer-binary-gemini.php
new file mode 100755
index 0000000..3006c80
--- /dev/null
+++ b/examples/image-describer-binary-gemini.php
@@ -0,0 +1,32 @@
+<?php
+
+use PhpLlm\LlmChain\Bridge\Google\Gemini;
+use PhpLlm\LlmChain\Bridge\Google\PlatformFactory;
+use PhpLlm\LlmChain\Chain;
+use PhpLlm\LlmChain\Model\Message\Content\Image;
+use PhpLlm\LlmChain\Model\Message\Message;
+use PhpLlm\LlmChain\Model\Message\MessageBag;
+use Symfony\Component\Dotenv\Dotenv;
+
+require_once dirname(__DIR__).'/vendor/autoload.php';
+(new Dotenv())->loadEnv(dirname(__DIR__).'/.env');
+
+if (empty($_ENV['GOOGLE_API_KEY'])) {
+    echo 'Please set the GOOGLE_API_KEY environment variable.'.PHP_EOL;
+    exit(1);
+}
+
+$platform = PlatformFactory::create($_ENV['GOOGLE_API_KEY']);
+$llm = new Gemini(Gemini::GEMINI_1_5_FLASH);
+
+$chain = new Chain($platform, $llm);
+$messages = new MessageBag(
+    Message::forSystem('You are an image analyzer bot that helps identify the content of images.'),
+    Message::ofUser(
+        'Describe the image as a comedian would do it.',
+        new Image(dirname(__DIR__).'/tests/Fixture/image.jpg'),
+    ),
+);
+$response = $chain->call($messages);
+
+echo $response->getContent().PHP_EOL;
diff --git a/examples/stream-google-gemini.php b/examples/stream-google-gemini.php
new file mode 100644
index 0000000..9756c9a
--- /dev/null
+++ b/examples/stream-google-gemini.php
@@ -0,0 +1,33 @@
+<?php
+
+use PhpLlm\LlmChain\Bridge\Google\Gemini;
+use PhpLlm\LlmChain\Bridge\Google\PlatformFactory;
+use PhpLlm\LlmChain\Chain;
+use PhpLlm\LlmChain\Model\Message\Message;
+use PhpLlm\LlmChain\Model\Message\MessageBag;
+use Symfony\Component\Dotenv\Dotenv;
+
+require_once dirname(__DIR__).'/vendor/autoload.php';
+(new Dotenv())->loadEnv(dirname(__DIR__).'/.env');
+
+if (empty($_ENV['GOOGLE_API_KEY'])) {
+    echo 'Please set the GOOGLE_API_KEY environment variable.'.PHP_EOL;
+    exit(1);
+}
+
+$platform = PlatformFactory::create($_ENV['GOOGLE_API_KEY']);
+$llm = new Gemini(Gemini::GEMINI_2_FLASH);
+
+$chain = new Chain($platform, $llm);
+$messages = new MessageBag(
+    Message::forSystem('You are a funny clown that entertains people.'),
+    Message::ofUser('What is the purpose of an ant?'),
+);
+$response = $chain->call($messages, [
+    'stream' => true, // enable streaming of response text
+]);
+
+foreach ($response->getContent() as $word) {
+    echo $word;
+}
+echo PHP_EOL;
diff --git a/src/Bridge/Google/GoogleModel.php b/src/Bridge/Google/Gemini.php
similarity index 77%
rename from src/Bridge/Google/GoogleModel.php
rename to src/Bridge/Google/Gemini.php
index 5943a05..576dd75 100644
--- a/src/Bridge/Google/GoogleModel.php
+++ b/src/Bridge/Google/Gemini.php
@@ -6,7 +6,7 @@
 
 use PhpLlm\LlmChain\Model\LanguageModel;
 
-final readonly class GoogleModel implements LanguageModel
+final readonly class Gemini implements LanguageModel
 {
     public const GEMINI_2_FLASH = 'gemini-2.0-flash';
     public const GEMINI_2_PRO = 'gemini-2.0-pro-exp-02-05';
@@ -35,12 +35,12 @@ public function getOptions(): array
 
     public function supportsAudioInput(): bool
     {
-        return false; // it does, but implementation here is still open; in_array($this->version, [self::GEMINI_2_FLASH, self::GEMINI_2_PRO, self::GEMINI_1_5_FLASH], true);
+        return false; // it does, but implementation here is still open
     }
 
     public function supportsImageInput(): bool
     {
-        return false; // it does, but implementation here is still open;in_array($this->version, [self::GEMINI_2_FLASH, self::GEMINI_2_PRO, self::GEMINI_2_FLASH_LITE, self::GEMINI_2_FLASH_THINKING, self::GEMINI_1_5_FLASH], true);
+        return true;
     }
 
     public function supportsStreaming(): bool
@@ -50,11 +50,11 @@ public function supportsStreaming(): bool
 
     public function supportsStructuredOutput(): bool
     {
-        return false;
+        return false; // it does, but implementation here is still open
     }
 
     public function supportsToolCalling(): bool
     {
-        return false;
+        return false; // it does, but implementation here is still open
     }
 }
diff --git a/src/Bridge/Google/GooglePromptConverter.php b/src/Bridge/Google/GooglePromptConverter.php
new file mode 100644
index 0000000..2dbe711
--- /dev/null
+++ b/src/Bridge/Google/GooglePromptConverter.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\Google;
+
+use PhpLlm\LlmChain\Model\Message\AssistantMessage;
+use PhpLlm\LlmChain\Model\Message\Content\Image;
+use PhpLlm\LlmChain\Model\Message\Content\Text;
+use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
+use PhpLlm\LlmChain\Model\Message\MessageInterface;
+use PhpLlm\LlmChain\Model\Message\Role;
+use PhpLlm\LlmChain\Model\Message\UserMessage;
+
+use function Symfony\Component\String\u;
+
+final class GooglePromptConverter
+{
+    /**
+     * @return array{
+     *     contents: list<array{
+     *         role: 'model'|'user',
+     *         parts: list<array{inline_data?: array{mime_type: string, data: string}|array{text: string}}>
+     *     }>,
+     *     system_instruction?: array{parts: array{text: string}}
+     * }
+     */
+    public function convertToPrompt(MessageBagInterface $bag): array
+    {
+        $body = ['contents' => []];
+
+        $systemMessage = $bag->getSystemMessage();
+        if (null !== $systemMessage) {
+            $body['system_instruction'] = [
+                'parts' => ['text' => $systemMessage->content],
+            ];
+        }
+
+        foreach ($bag->withoutSystemMessage()->getMessages() as $message) {
+            $body['contents'][] = [
+                'role' => $message->getRole()->equals(Role::Assistant) ? 'model' : 'user',
+                'parts' => $this->convertMessage($message),
+            ];
+        }
+
+        return $body;
+    }
+
+    /**
+     * @return list<array{inline_data?: array{mime_type: string, data: string}|array{text: string}}>
+     */
+    private function convertMessage(MessageInterface $message): array
+    {
+        if ($message instanceof AssistantMessage) {
+            return [['text' => $message->content]];
+        }
+
+        if ($message instanceof UserMessage) {
+            $parts = [];
+            foreach ($message->content as $content) {
+                if ($content instanceof Text) {
+                    $parts[] = ['text' => $content->text];
+                }
+                if ($content instanceof Image) {
+                    $parts[] = ['inline_data' => [
+                        'mime_type' => u($content->url)->after('data:')->before(';')->toString(),
+                        'data' => u($content->url)->after('base64,')->toString(),
+                    ]];
+                }
+            }
+
+            return $parts;
+        }
+
+        return [];
+    }
+}
diff --git a/src/Bridge/Google/GoogleRequestBodyProducer.php b/src/Bridge/Google/GoogleRequestBodyProducer.php
deleted file mode 100644
index 292b2b3..0000000
--- a/src/Bridge/Google/GoogleRequestBodyProducer.php
+++ /dev/null
@@ -1,97 +0,0 @@
-<?php
-
-namespace PhpLlm\LlmChain\Bridge\Google;
-
-use PhpLlm\LlmChain\Model\Message\AssistantMessage;
-use PhpLlm\LlmChain\Model\Message\Content\Audio;
-use PhpLlm\LlmChain\Model\Message\Content\ContentVisitor;
-use PhpLlm\LlmChain\Model\Message\Content\Image;
-use PhpLlm\LlmChain\Model\Message\Content\Text;
-use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
-use PhpLlm\LlmChain\Model\Message\MessageVisitor;
-use PhpLlm\LlmChain\Model\Message\SystemMessage;
-use PhpLlm\LlmChain\Model\Message\ToolCallMessage;
-use PhpLlm\LlmChain\Model\Message\UserMessage;
-use PhpLlm\LlmChain\Platform\RequestBodyProducer;
-
-final class GoogleRequestBodyProducer implements RequestBodyProducer, MessageVisitor, ContentVisitor, \JsonSerializable
-{
-    protected MessageBagInterface $bag;
-
-    public function __construct(MessageBagInterface $bag)
-    {
-        $this->bag = $bag;
-    }
-
-    public function createBody(): array
-    {
-        $contents = [];
-        foreach ($this->bag->withoutSystemMessage()->getMessages() as $message) {
-            $contents[] = [
-                'role' => $message->getRole(),
-                'parts' => $message->accept($this),
-            ];
-        }
-
-        $body = [
-            'contents' => $contents,
-        ];
-
-        $systemMessage = $this->bag->getSystemMessage();
-        if (null !== $systemMessage) {
-            $body['systemInstruction'] = [
-                'parts' => $systemMessage->accept($this),
-            ];
-        }
-
-        return $body;
-    }
-
-    public function visitUserMessage(UserMessage $message): array
-    {
-        $parts = [];
-        foreach ($message->content as $content) {
-            $parts[] = [...$content->accept($this)];
-        }
-
-        return $parts;
-    }
-
-    public function visitAssistantMessage(AssistantMessage $message): array
-    {
-        return [['text' => $message->content]];
-    }
-
-    public function visitSystemMessage(SystemMessage $message): array
-    {
-        return [['text' => $message->content]];
-    }
-
-    public function visitText(Text $content): array
-    {
-        return ['text' => $content->text];
-    }
-
-    public function visitImage(Image $content): array
-    {
-        // TODO: support image
-        return [];
-    }
-
-    public function visitAudio(Audio $content): array
-    {
-        // TODO: support audio
-        return [];
-    }
-
-    public function visitToolCallMessage(ToolCallMessage $message): array
-    {
-        // TODO: support tool call message
-        return [];
-    }
-
-    public function jsonSerialize(): array
-    {
-        return $this->createBody();
-    }
-}
diff --git a/src/Bridge/Google/ModelHandler.php b/src/Bridge/Google/ModelHandler.php
index f02adc2..3a13c83 100644
--- a/src/Bridge/Google/ModelHandler.php
+++ b/src/Bridge/Google/ModelHandler.php
@@ -4,6 +4,7 @@
 
 namespace PhpLlm\LlmChain\Bridge\Google;
 
+use JsonException;
 use PhpLlm\LlmChain\Exception\RuntimeException;
 use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
 use PhpLlm\LlmChain\Model\Model;
@@ -12,9 +13,7 @@
 use PhpLlm\LlmChain\Model\Response\TextResponse;
 use PhpLlm\LlmChain\Platform\ModelClient;
 use PhpLlm\LlmChain\Platform\ResponseConverter;
-use Symfony\Component\HttpClient\Chunk\ServerSentEvent;
 use Symfony\Component\HttpClient\EventSourceHttpClient;
-use Symfony\Component\HttpClient\Exception\JsonException;
 use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
 use Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface;
 use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
@@ -31,13 +30,14 @@
     public function __construct(
         HttpClientInterface $httpClient,
         #[\SensitiveParameter] private string $apiKey,
+        private GooglePromptConverter $promptConverter = new GooglePromptConverter(),
     ) {
         $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
     }
 
     public function supports(Model $model, array|string|object $input): bool
     {
-        return $model instanceof GoogleModel && $input instanceof MessageBagInterface;
+        return $model instanceof Gemini && $input instanceof MessageBagInterface;
     }
 
     /**
@@ -47,13 +47,20 @@ public function request(Model $model, object|array|string $input, array $options
     {
         Assert::isInstanceOf($input, MessageBagInterface::class);
 
-        $body = new GoogleRequestBodyProducer($input);
+        $url = sprintf(
+            'https://generativelanguage.googleapis.com/v1beta/models/%s:%s',
+            $model->getVersion(),
+            $options['stream'] ?? false ? 'streamGenerateContent' : 'generateContent',
+        );
 
-        return $this->httpClient->request('POST', sprintf('https://generativelanguage.googleapis.com/v1beta/models/%s:generateContent', $model->getVersion()), [
+        $generationConfig = ['generationConfig' => $options];
+        unset($generationConfig['generationConfig']['stream']);
+
+        return $this->httpClient->request('POST', $url, [
             'headers' => [
                 'x-goog-api-key' => $this->apiKey,
             ],
-            'json' => $body,
+            'json' => array_merge($generationConfig, $this->promptConverter->convertToPrompt($input)),
         ]);
     }
 
@@ -82,22 +89,41 @@ public function convert(ResponseInterface $response, array $options = []): LlmRe
     private function convertStream(ResponseInterface $response): \Generator
     {
         foreach ((new EventSourceHttpClient())->stream($response) as $chunk) {
-            if (!$chunk instanceof ServerSentEvent || '[DONE]' === $chunk->getData()) {
+            if ($chunk->isFirst() || $chunk->isLast()) {
                 continue;
             }
 
-            try {
-                $data = $chunk->getArrayData();
-            } catch (JsonException) {
-                // try catch only needed for Symfony 6.4
-                continue;
-            }
+            $jsonDelta = trim($chunk->getContent());
 
-            if (!isset($data['candidates'][0]['content']['parts'][0]['text'])) {
-                continue;
+            // Remove leading/trailing brackets
+            if (str_starts_with($jsonDelta, '[') || str_starts_with($jsonDelta, ',')) {
+                $jsonDelta = substr($jsonDelta, 1);
+            }
+            if (str_ends_with($jsonDelta, ']')) {
+                $jsonDelta = substr($jsonDelta, 0, -1);
             }
 
-            yield $data['candidates'][0]['content']['parts'][0]['text'];
+            // Split in case of multiple JSON objects
+            $deltas = explode(",\r\n", $jsonDelta);
+
+            foreach ($deltas as $delta) {
+                if ('' === $delta) {
+                    continue;
+                }
+
+                try {
+                    $data = json_decode($delta, true, 512, JSON_THROW_ON_ERROR);
+                } catch (JsonException $e) {
+                    dump($delta);
+                    throw new RuntimeException('Failed to decode JSON response', 0, $e);
+                }
+
+                if (!isset($data['candidates'][0]['content']['parts'][0]['text'])) {
+                    continue;
+                }
+
+                yield $data['candidates'][0]['content']['parts'][0]['text'];
+            }
         }
     }
 }
diff --git a/src/Model/Message/AssistantMessage.php b/src/Model/Message/AssistantMessage.php
index 90d385f..aabca47 100644
--- a/src/Model/Message/AssistantMessage.php
+++ b/src/Model/Message/AssistantMessage.php
@@ -50,9 +50,4 @@ public function jsonSerialize(): array
 
         return $array;
     }
-
-    public function accept(MessageVisitor $visitor): array
-    {
-        return $visitor->visitAssistantMessage($this);
-    }
 }
diff --git a/src/Model/Message/Content/Audio.php b/src/Model/Message/Content/Audio.php
index 1927021..fe04f9a 100644
--- a/src/Model/Message/Content/Audio.php
+++ b/src/Model/Message/Content/Audio.php
@@ -32,9 +32,4 @@ public function jsonSerialize(): array
             ],
         ];
     }
-
-    public function accept(ContentVisitor $visitor): array
-    {
-        return $visitor->visitAudio($this);
-    }
 }
diff --git a/src/Model/Message/Content/Content.php b/src/Model/Message/Content/Content.php
index ee017d7..a97cc9d 100644
--- a/src/Model/Message/Content/Content.php
+++ b/src/Model/Message/Content/Content.php
@@ -6,5 +6,4 @@
 
 interface Content extends \JsonSerializable
 {
-    public function accept(ContentVisitor $visitor): array;
 }
diff --git a/src/Model/Message/Content/ContentVisitor.php b/src/Model/Message/Content/ContentVisitor.php
deleted file mode 100644
index 8c9c9a7..0000000
--- a/src/Model/Message/Content/ContentVisitor.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<?php
-
-namespace PhpLlm\LlmChain\Model\Message\Content;
-
-interface ContentVisitor
-{
-    public function visitAudio(Audio $content): array;
-
-    public function visitImage(Image $content): array;
-
-    public function visitText(Text $content): array;
-}
diff --git a/src/Model/Message/Content/Image.php b/src/Model/Message/Content/Image.php
index 3bc3bdc..66ea74e 100644
--- a/src/Model/Message/Content/Image.php
+++ b/src/Model/Message/Content/Image.php
@@ -41,9 +41,4 @@ private function fromFile(string $filePath): string
 
         return sprintf('data:image/%s;base64,%s', $type, base64_encode($data));
     }
-
-    public function accept(ContentVisitor $visitor): array
-    {
-        return $visitor->visitImage($this);
-    }
 }
diff --git a/src/Model/Message/Content/Text.php b/src/Model/Message/Content/Text.php
index 551df00..08b0d87 100644
--- a/src/Model/Message/Content/Text.php
+++ b/src/Model/Message/Content/Text.php
@@ -18,9 +18,4 @@ public function jsonSerialize(): array
     {
         return ['type' => 'text', 'text' => $this->text];
     }
-
-    public function accept(ContentVisitor $visitor): array
-    {
-        return $visitor->visitText($this);
-    }
 }
diff --git a/src/Model/Message/MessageInterface.php b/src/Model/Message/MessageInterface.php
index 34ad302..efae114 100644
--- a/src/Model/Message/MessageInterface.php
+++ b/src/Model/Message/MessageInterface.php
@@ -7,6 +7,4 @@
 interface MessageInterface extends \JsonSerializable
 {
     public function getRole(): Role;
-
-    public function accept(MessageVisitor $visitor): array;
 }
diff --git a/src/Model/Message/MessageVisitor.php b/src/Model/Message/MessageVisitor.php
deleted file mode 100644
index 3a084ca..0000000
--- a/src/Model/Message/MessageVisitor.php
+++ /dev/null
@@ -1,14 +0,0 @@
-<?php
-
-namespace PhpLlm\LlmChain\Model\Message;
-
-interface MessageVisitor
-{
-    public function visitSystemMessage(SystemMessage $message): array;
-
-    public function visitUserMessage(UserMessage $message): array;
-
-    public function visitAssistantMessage(AssistantMessage $message): array;
-
-    public function visitToolCallMessage(ToolCallMessage $message): array;
-}
diff --git a/src/Model/Message/SystemMessage.php b/src/Model/Message/SystemMessage.php
index 169e456..b914c3b 100644
--- a/src/Model/Message/SystemMessage.php
+++ b/src/Model/Message/SystemMessage.php
@@ -28,9 +28,4 @@ public function jsonSerialize(): array
             'content' => $this->content,
         ];
     }
-
-    public function accept(MessageVisitor $visitor): array
-    {
-        return $visitor->visitSystemMessage($this);
-    }
 }
diff --git a/src/Model/Message/ToolCallMessage.php b/src/Model/Message/ToolCallMessage.php
index 2ddef68..20a9767 100644
--- a/src/Model/Message/ToolCallMessage.php
+++ b/src/Model/Message/ToolCallMessage.php
@@ -34,9 +34,4 @@ public function jsonSerialize(): array
             'tool_call_id' => $this->toolCall->id,
         ];
     }
-
-    public function accept(MessageVisitor $visitor): array
-    {
-        return $visitor->visitToolCallMessage($this);
-    }
 }
diff --git a/src/Model/Message/UserMessage.php b/src/Model/Message/UserMessage.php
index 8cf9d05..ef925c5 100644
--- a/src/Model/Message/UserMessage.php
+++ b/src/Model/Message/UserMessage.php
@@ -68,9 +68,4 @@ public function jsonSerialize(): array
 
         return $array;
     }
-
-    public function accept(MessageVisitor $visitor): array
-    {
-        return $visitor->visitUserMessage($this);
-    }
 }
diff --git a/src/Platform/RequestBodyProducer.php b/src/Platform/RequestBodyProducer.php
deleted file mode 100644
index ff31b72..0000000
--- a/src/Platform/RequestBodyProducer.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-namespace PhpLlm\LlmChain\Platform;
-
-interface RequestBodyProducer
-{
-    public function createBody(): array;
-}
diff --git a/tests/Bridge/Google/GooglePromptConverterTest.php b/tests/Bridge/Google/GooglePromptConverterTest.php
new file mode 100644
index 0000000..78b51d0
--- /dev/null
+++ b/tests/Bridge/Google/GooglePromptConverterTest.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Tests\Bridge\Google;
+
+use PhpLlm\LlmChain\Bridge\Google\GooglePromptConverter;
+use PhpLlm\LlmChain\Model\Message\Content\Image;
+use PhpLlm\LlmChain\Model\Message\Message;
+use PhpLlm\LlmChain\Model\Message\MessageBag;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Small;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+#[Small]
+#[CoversClass(GooglePromptConverter::class)]
+final class GooglePromptConverterTest extends TestCase
+{
+    #[Test]
+    #[DataProvider('provideMessageBag')]
+    public function testConvert(MessageBag $bag, array $expected): void
+    {
+        $converter = new GooglePromptConverter();
+
+        self::assertSame($expected, $converter->convertToPrompt($bag));
+    }
+
+    /**
+     * @return iterable<array{0: MessageBag, 1: array}>
+     */
+    public static function provideMessageBag(): iterable
+    {
+        yield 'simple text' => [
+            new MessageBag(Message::ofUser('Write a story about a magic backpack.')),
+            [
+                'contents' => [
+                    ['role' => 'user', 'parts' => [['text' => 'Write a story about a magic backpack.']]],
+                ],
+            ],
+        ];
+
+        yield 'text with image' => [
+            new MessageBag(
+                Message::ofUser('Tell me about this instrument', new Image(dirname(__DIR__, 2).'/Fixture/image.jpg'))
+            ),
+            [
+                'contents' => [
+                    ['role' => 'user', 'parts' => [
+                        ['text' => 'Tell me about this instrument'],
+                        ['inline_data' => ['mime_type' => 'image/jpg', 'data' => '/9j/4AAQSkZJRgABAQEASABIAAD/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAAAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVkAAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBIZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyBfOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t////2wCEAAUGBgcJBwoLCwoNDg0ODRMSEBASEx0VFhUWFR0rGyAbGyAbKyYuJiMmLiZENjAwNkRPQj9CT19VVV94cnicnNIBBQYGBwkHCgsLCg0ODQ4NExIQEBITHRUWFRYVHSsbIBsbIBsrJi4mIyYuJkQ2MDA2RE9CP0JPX1VVX3hyeJyc0v/CABEIAasCfwMBIgACEQEDEQH/xAA3AAAABwEBAQAAAAAAAAAAAAAAAQIEBQYHAwgJAQABBQEBAQAAAAAAAAAAAAAFAAECAwQGBwj/2gAMAwEAAhADEAAAAPNMQ67E3rpCeapvGd2KXNBDDMACuRAyTGAE4ADoABkADSIAJKStLOQMOyTJSQBhORGExkpLOAYdkmA6Bjsn4GYZESgkkGaSUqNkZoXsrBGJMRKJkkGIuRAs8gojdEYEXCk9mnyC0pEag7pSA0EgBRPpzUpBHTmkAAogAOpbvEzRGCJdlF03MuJlnrAArkAAkCMklEpLOYAkxGRsgAbORKJMtHRCkRmHZCkrTAwucuZdERRkomcgYdkgGmNaQ8iANmSZKZ0gzSQDSmUayd0mR6qiADsQBQdJKLO5gCaIwcJK78ej2pNfN3HECFYADRSAHiDIJdOfXk8gAGiAAkbxmJO5bGUXMAOxAyigZGnBGaQJZKRAzdualhJB9CTpT1Wz80OUJch2ObNV9wm4n1EkhK+ifgl0iK4H3EmbjuHXIdTT8ldDZ25d0xSAuUlGFRoMPsqrPWYjo2NgsYrOB9ClXyLsTLmnulLmFhklQNpcj6dHZuYDIEAmAIMiBh4kDCXXitDyAAaIACQACSkqSnAATAAJAAJAA0l8+iHkRg5wAMTYgYkiWSk6+XbknAMaKyHaz741I78w6OioOr7aCtVFhtmdW48mgdWuVGbz7F+hWAfHgZbdWx/Q5r1eMxW7mRvaWkdAZQOvn4xu7nTJ2szMI+KUQje6U/l9jYACkQMJJCiZ0hRRRLSqEkABmBGGRAwyIjEXIwGRABkAAkAAyAASAUE5EsJIHQ0/IdlJNw4UnaqchPx5vDTsw+Eosg9OTsQ96p47pIcXXHjL7EQxZJaJ28+ih8o0CpVfuLtETTXz2XSPoN7pqz++aJlz02+RtmQgxOm1qsTeUP2ZWZzrOd4hjSm30vrfMs4/Vq9R124+fea4hTZyu9Z7PJQtriep1d4F+7YLSCd9PONzASCUmIdoUW5O0Mm3Tp1hNkTxKZqHJMzcdkRZBLTFEYEXSAGQBhIgYZEDCRgCMjBm0iCzUkDqbS4n2CXI+pqXMdjZ+J9jT8R1NlxWdoaMFf8ASYk7z8Wyj5Hs+T17JJLSCjZJeI6idj1l6nsLlYts2ZP9Qz14ptzXGI12NlXrDbj7vL9p/OZa48t7vm9FQpmeQPWbagsa7hG5zotQAAJF2fJ3Bj0lvoupZP01OevJDlhobQe6VUeTyk7lU/PLeQ7qC6WpuSd25OVJM0u0tBmh2h4N+fd6oxCLRA3VtQBXUQ6dWk3LuTLiOhJkBZMuxEcpc1duFU1jmqEuquSmn1XwCk4DcM7o2imd0bU2m5RxnHbjc9VljvI0btoE/Pz/AM3XHSkdx2FKyHV806bbZNJxytl7vUvPzkeWvaMzuNZeMe1t87Guj6xx1oPQymGtIAZ9azK4+Odmr1r5Gc6oVvx31h5B9SjeYiMN3DByJHVJzObDSQqKHsH1HS1eXtNfFvsWWbLmUs1pgKHL7AOXI0Sk+L9izU8UB1MiekkzDrlFuCJSzNbS3nF9syQ7Sd5vVBpcN6qTN6q+DAnyEzQnZJ2ocEzr59WeaxxzQumY6J6NZ1X3bykAnm0Jl/CaJjL1bj6kbiNHm/p6KetDy7vufS3Sh+Oy5NVuo5HvtfnGy9AJl7dg+ndQa2Kq5bM7tbqtbi9owweZ3+5j5x1Zr+rrPFWzH4GOfa8J2Dy4Y2+1vKXZhuruec73asVuK0acz/FpltJymZ2v6HsHnfcA/HR1Ha61p5uCtFMa4u5jbPXdLu7eEKfzarirIb/Ctpe3Y76Gq0D2HubxTvDD3PpYo2KrvM+F+CwcoWblJk+YP9uVrzeRKrbs5KNrzvlqe3zjk9HLwjkzkakzLsUIysJsea574ZT1pVIu3TpVc7bNntzF1fRLXW3SqRoPLdTl90yNqd5j2BE+X9aBErJ1xtz6iC1+SxUtwD0jJeYLJHj9KqUDbuj6DMefqLlus8u7c6ZKvDtji32zXnVk0awV4MDqvra30x8gXPXM+I7bJrXkalQXqvzM0lyFj2HY3GmdE07G1l+itWvYP6GD8r5013NNPw83nXW4TuQ7hU301HqtlDsVwIDmwCZ27MegNWskELOHkWotPEj1fpso359q5wlYzQO6zUVPThAvdj4WZcMfTCtFVdiJ6DsyPJ6MkqtVZfI5PQ3Q64qHMKkor035cWdrcEjrTZK8enfNtj4yyjXTWXblManW7YfuvM9RiUdYUnBMFPVv0lbipTl7MHRtZ56TSCeOOuMa+uA5Om61b0ck0stfcFl6SXn9C8wB7ZEY50OFtMjKf32jmzO2Z0VlHPL28LFICyNHw27PJaasuiyi1z0Dm4q/G3SOmvI/9cYDOUgLjOY7sAfDBNbxmmrt+OUX22E8WqeUPTfknFzVn1bA9rM+kQNMYbotMDE6VlfmJbIGVqj+FAn1cccWyME+vRCo93694f3Nd/EmjjiNMwW/0DfkmZupphLtwCWjZuMO1jpkGfEnoHdHZlzLmcJWH6IfOzlVp+jnmjz0y15F8uMzKCt7q9u5LtPOCbJXOm5HZdddceP6qlPTnfTeVhn4jZBZNtVLNqB5tIbRA9KfwN/dSNUyVbsU7yeKmcpeU1QiOHObL54TONhe6X4xlwqNe2Is9c1zTfnN7a8R9tNe6JlO3XjLdx06AU0U43wqOzO6Oozhsmg0DRX9nYUnBvZHl0mO0ftXKflJalXW2fEiE7qeA6Vvz2+t1+U4QnlCu9n8kjVH0jHRv9GaFlmiU58982atmZLDyV0jLIHGykVC60NYxLM84N0szmUgzha7Z8jUErdXN1SeWh0eE33LoVeqNRIMNg4W+ouZR9rUXzv6D47tsZrafSvU8peGvonB+ONVra8VPtQd7tfjb12QAOqlAOt+bHnfoaq9ftFSzrTtMqpbmFgAWsZCRkxwjOo3ceNvLUSj6vZNMM3vbLzmU6XQtgdpGaWfn+Mp3T7m9r2K0anw/KPZ+WA8fnT1t5CsxQJ6Xr/n/TK6dAl6Q3u7vacH0Nxh4HzvebG2MemVHW8ZtWg9ziJe4wGYVZpt7zeSy+iK5V/Dyc/4EvVAJS4I7syYLpJ19NtTzgcjXaxh5aKa2xo5qqth3s76blV5EX6m81qMNfaKiVbnecLcR0b95wkoqDS3onz1qmQhdfL2y5zqyV556AvMo+Vt3x7dOP7DzVytK+s5v05EPHHnhnILhiY945L1jjNC2qnFxf3/ABJC9aVk0wW0aB5s9YRz6cov+EON1eywOdxJYffJGp6Nkw1rXqyxG0aJlsJP7aLjF5M+kfgrrnj4/uvEJouUYE31vzOo9U+rNq7gmrd4yXSh1uuRtJHSGLsuLpML7W/rWv5N9FHVhs0vdq8o70N5RqwiYzznpPVY819fMWoeZ2avHJwSu1/LAKfD+mcQsg15eqGtN3kdo+jroe8vONPjYVcbhTLLJl0zQqyygSWV9Ut1cLHm+MXYoOup0o7nlI0OR4PN2SSm6z2z9ZZNZyDXuF6DH4y2OOr5PQp+NuvJ5PPlC0Tv6QPTU7bMHeTpV1gYzUI3KrZPr9GzSXVeRgPVzMvRHms/XdG0LB90D0WEpOpBufxjTZunaSW3YXw0ZtVcpkxL6Ct+rODMzz61C0Robz2ySz9Wptg0Xy/yD6PQGL3CmcNotaG+m4DCstv1fPWcmsbJ9C3osNZrz8zk8kqL6MdSXUPP+JF8gXLOivBxvG7UYN0W5w2eSesdsmBPm+kdCsLXHX1VZhKRWMjP6rm2s06NH7VJ9znay2BaljREfA9ZZXQcU1dVc8ZG6V2DdVysk5EQ2IjNyNHmd+FO306dYknTsj1nzLra28kXZLFWvVHnbYgefyzqlDvvWSTbC0k7xnib0BpmOHxnnthpF972OTWnEJ6qz1C0zavCN97Lvfuk55lWJsgYrBdSnW+7ZKea+m1mNej4L6apwXUycZ5nJvRpdDZ2gtCvUzZoHas8iXsb1+ZUc94+PENa1vPNk+auyZQltY1KG7L2b2hYC0tlO9Gqu+RbJhWjgL7UZzCucJbHIYnvfC3uPOnrXyRz5vSLjkWt9aHhatqOGc9RdKq2lNGal1yZhn2aDTbtnlVm3yNLzHD021UVu+1DniO/LWJoIBTo5qPkPuvVZsNfoKsl2TmWEsbBPRA43b9awnbOI6CBymfrfSc7Uvpf8xfeg2nLMsm8TIN7g0vzlIaDO5Q2NWNpXLzdsr8yVi8S9N41vD5jrNH0zrOSzOmbXZzozKKV6LZiROBWPZZlyPO/V6lgtGj0/EuMWou22i8d65c3g565h1fO4Tgsu9H9oQ8E1zUHXEFY/ccilOGPWTL6hDdSJ9t4V7Axgtpw6vWR79CzpvGdruYVYbFAtvmUoU3WIQjz+iUSHs6Mu6a/j/qLm9GxKUi/l4h01XJ7vDTBQs/XrKrPXOap1WGC5prtskhTphrmThi6nhm4N71nbAczPM12gZOsZS2m6jjNvnPWXmXagBLcWN6oYMx5wgOfL0Dz+S+kXz6+hXnG/wA7+SvVflTpsuvc6tKejE7TE09/ZjvnCjS1UrfwqHPXTq198kb3xO7IzqjzohHezUqSx6eburivN7W8ZbHiY2fSy1ieMYvQVky7Tu6Hxhy9I3vJzlGTpe7t6BH1yyZ3HOPOrh1ZFTOROIuMLNT9I+etA4TosMpmoSf00Lo1/wC2UEcdhq25+d/PYSUjR1htHO8zXobos/ji8zgE3Z7UXbTlrFdW9ksqiIix1ylGpJzgEgVOCMopZoElKyVXOm4KScqns7VpHPqFhppzhpGueYrjDZ6poOSw4w/SzIz/ABmv+mPE8CC2abmMpxKPuVzxyybfSa9uuCbBswxcoy1MkJg8X9D+dJjMaulN2LmBWWOtsrc9WbW7dK5jzeaZFq13Z/ZPjn0Z5tFb167kPoXfRPU67XvuQXnWXgvSfcWec5d9ol7Z/Xvb2JcovF8q3s/D66iqc7zrq2p02/gj9Y2HzfIzy7nm7KhkK7N6v8p3r1IHM12n2jps1Wlw8ldMsKpBcFbJRyHXBlmrNy0rh25GiVThl34ZZmB0k3IjKDmQEUB06wm1VKRNVayTpEY5wejZsmWpBve7ex8jdKSZP2M74AyE8Y6bRso4Z5nq1tq+g9J8dDsZnqsxi9HusJYu1v8AMEMWXTFkmiXO4T6+8ierfOdkJX9wPmTHkKu+tOfQC/IHHTuRLLd8Z9j+WxOyle1/LPqquWJ061QnqXPs1TBdBOEe2vgTw1QtIYaXyS56bK+F9Fg0TZfR20R400aw0bGTrMbLuyg2AYaTm1D9Oa5aF8hAbZjeXTFGRbxoQYsUsuJkM+lo3XzvoMEGZAI80pDtx476G6OnMdoAMoOQBRVorBWbPlrPo7LorHh0HNYZWwrO8olVml0+h+kpXXk3ibNrDrqfKv0B/cKnYhGHvnmhipsY7642I9LnBzlM1C9KrmbSprjNQo0A00gmfsbyPYQtPr8eSp8Bu9HKe+fB1TZFHl+pp9G+am7GFmmeitsWMF+FpWp5t6C+kzOVt+ofRrFlDG3PptkxR4o+hLjn0n4R2Vo2TzRj1nOervP1X9ftVhbn0XhOXpKb589b+biLS+245tNFlfwH0Lhl1Ho3Mbjwj5J5b9BefPYGrVyrOnyQDk8Sy/6O14v2vjXHfqn4R2bMNc2qL2FozmaSBBNk0rZuQ43xOWlZyY6PnoEP6FGgvL/qDzivUQ1XLERLs2Uk9PQLUg06unHqrZBo+ZT1+i5OyaRyPr3nu7aHhOrmtS7t58VqiIrR6Q9uT5Du2VdBOhD6a8Y+I/M7pOty+SC5ynG7Sw9YeW7HTX7u8/QGcc9ydORJc+t61ip2uS9j3zyta+G83nvJ24Y91HUxiJFJfonlhqPQnhsy6mmDz7OLNnerZvmZ97G8wQwTn/pL86eNHY5Kc44zurS9EY+wuU3+UMW1yhZzVChr9spoF5TldFzXRDQoR9tobHc65IVXjvLWGJzVb7H0T0hbc0meJ8na+ebT606HuPIMd6N8mETnpR1jMvXPKLHFx249v2BeovLmPFLsOYKmeZkM8lGk059eHRT2qv6ZBAAWq6liUsL9x2CdyEqed1+1+frK+XZqRW4R1mWObF52NdX7WjfF/sPF5cPIv0k+dB/i4jgORgmBzD3apmuk5lmPrQSNvOrXwXJ+9vpl1zFqhyLnqDqJCZ2dvVflH6F4KLP4P+j3hPFRhi+Kje11Z6nKtg9w+f7LkjeXUuP6N4+wKVzN5eyPTvyhuQ2nX8bbMKivf6C/Oeb2A/ox5U9R5UPh4xtFKhtm7X6pW+ER7/1t49sUNnsbzhE5qE5j0DD4mjeV0bO+HbcXGp1G5YQ2qYFsOdDReao6DsO55J7t6LCAGS0ABILQtSs7Jtxs1bvAsUD/AHKyu4SxZG5yPXtids5WM0ywnUcqNcyyvFEsJHlnFUfRerhFISm/MoIN5anml6oNJzogk6gClc1SfrdaReKC1KQrnpDBIKU1SkS+rVvo1qqNEwpB6o9nLPs1MtIxEvnnVOSud0+gQEkzcFLspuLiVXbXruLF+J1ybKy1NOcm3a1BoWz8mb4oWdo182k3M1iFjfunpF3jmITGizVg0Vz6H1LVLnw78c9iTAyWgAM4UlSd6g0aNmicZKwZfVqq+vkVnjEPHNoy3VFxcE5lQc02LHyA6KtNTtRLn4aKlIzTx6UmiwWo0qk96pFzpkSwI03BjUkOutzpVtpKQUe8Y3CAQKVhvGTyMpmtT1fjNRoEqu3RuuMZKerNhruqaAiUOgQE5SsPJSgg0IJwfSdekqswYzEXS/bgnmrS5n3qubl0S7qSlEXAUIy5KSUZ9+SDZkp6pjMxyDOtBCuQNIpcyASM0hn7DktS3TccR9EA+wsWeX/PsQmu61jWsZylshLBX3CYz5433z0X69lP09XVchLpixu5uRXHL3QkusSq6uxtIZea6WEWe3JKrilWRmH9a5D9c0ybI2ZXAbHbN52j+lUXzblyjJ2TQEWeOIvpXF51ZNg13fmSDDdezNSS0Kah5defNLXKVwLPN4TQq2etxzgjVxKmx12YdpQ5kaYWBXMRdaATOZGTOCBRdIApkCMmcGRsgAJsAQg5deSqp6RpWAv6up9C17HuWWvT3eSdJ7tr6YpzqfS8s4xW3EoEC/JKBHaxmk7GM0iSM0mmUEiaUCDowCdjBBOZpNMAQTmCKKUCEkYIMjCRFGEiLmQEUAQg5AFU5kAzgARQADIABkACZGCDIABkCMkgAGQADIACDgjJnIwcEQMOkhRMiAFaBkckYI7EAA6MAWsSVopfoCPVEGQsZQISYzISRgg6MEcmAAdGCDoGQZGCEkZAMgAGRkAkAQZGCDOABFAEUXMgIoACLgAMgAGQADIAEkZAooGQSAASAASAASAAZf/EADIQAAICAQMCBQMEAgIDAQEAAAIDAAEEBRESEyEQFCAiMSMyMxUwQEFDUCQ0QkRgBnD/2gAIAQEAAQUCrtW3t/u40drvb/4uiurEqpdfLB2h77/y7/2FXBrecfqO/h3+1fr/AK/1FRcVexMPe/4V/tX+zX8bf+FRXUsrv+JfjXprwv5/Yr9qv9ZvN5vN5vN5v4bzebzebzf0dp2nadp2nadp2naVO3iCrKeXCpdLnAbljdfvb/zb/av5/Yob3rDeU6J8iwnjOkc6DNrq69FfPgpe93sI3e9+AVyoh2lf6m/2r+fGqu4OK250EVC6cXkGE8yFwVYxwl5YEbORAauNLOPUNS8MCX5BlwgupXgA72FRpb2IEUvGLwC9ifXf+/8AY1L8FINlnjiqxd3vpkF4HccC4KsYV5GUBCIkREGRjwdQ3oaxWTy40PQypaMyeSySitPEZmhjSk0VjVVKHYAQRk+xC6YdE+u4/Lvlg/6ftO07TtO07TtO07TaptU9soN5hKRdOUSiAlPB2KQQSISFx0a8ixoRO4vAKU7HxxY5uQacNNA4F0ysgxg59ytRGfqQxmoNuGso96bTvEGvgsF0JVdVVWR5e3NA7m29zZ3nGcJwnCcZtONzacZtc43ONzjc43Nrm3+h2i1pCMpzYIEDF2LRycRiorMupb8M50sO4tOKMZl4wxuaVxGKxkQoF1lZlFMNZERlVBg7WdYeMUrAx55ZNXlI5ia9jDHK7yL2sm/8RHEgqlKorsi6XSQFbkPuYWNCWdeG02m02m04zabTabTabf6HGxjcQ4uKmjy1jCe6KsmW0+DV5YMp2HRWWG+p0mQcV9wNOdcVp6gj8ta4WTZD5Y+kV49qw6pygWIzpjcsSGam1nVVmlSxuIVvWaraL9yyGxsaI7XhoRWc3mZj0wVUHHXwYLglo3H9yhuXtUv9zb+CtdnZASxFS7ZlY9clFbHeS78FoE7rdWcdQc9FzzWPPO41Q9UCOznMiMNrKxrTRY5/X/TQiwEBGcqqj1RXPJJVKYG8xu7AGqmYA2vGKcIv2zJ6zXdGk1fJhXcHlS8pxb6aCSXl4Xfv4953ned538Nrnep1Ll95tf7m87fvpTbDTjCMzEWYIEFAzpb8B3r23mqIxHIKlViHw2vboNnRZ08bDUxWK5AliHdMZgUUx8MV3/U/UMejOqYrIUxZG5jbyk9HCxy2b5gIR2UYmwYGSYzziYzOgoa0rVwiR3bMxMq+EA33CHqhtNptNvQIXc6dDV1Aqdp2heFfv9p2naUA3LR36G10krnlmSsRt0OORFp2JS6sye0q7Dk3ZJ3tbcwxJL+oHXUFLFJTUOU80VoyaZ5ROXfTwE2tR6XVmSU46RIDppcArUm8h43WTjEo61C1o2a0ko6UyXUdo+8cgdw7xiQKHh1c/T2br01VQ91zIKylY3ufskQOmQ0JucRqiUIC4dr4lOBzpslrZU7+FNupyu7gfN8t/dC8K3nf138eki7+2cZtKiepuD1HKQa63A4TaFAC45WE2Mwz2LHyanRYN1nuqMOyPHegAzSEi07fdj1jMasco/UAAscxYORnspmFkW1erfOm79V2Rj7Hwoiz3RSXtJek1u61KC+pkXtLnlz2xcixIzu1qzGWw28AZlCMfk98cuVicyF0xWCQ+Ze5NzzrNxujAcb2ux7Cr4zHXRL4XV34VUX8wPknFN4fgN3ORTkU3udtrO5yuco1TAm3psLK+nc4SqgL3LiNMbd9XG1CwnLHdGrZVKyULH9SDf8AUV3fnse78wi506l4SCh6b3ZhuCJyWKht5HhtQpbePUx8rHUvIsDNGYa15OQ06pRlBwMi4GlxWCgYN0NP1LHGPa10WHTPJXxekeTCKwmTVbqOzV8XkDyXZEy2X7t7gZBjFZjAsa4QQsidj2ExRIV5BM6hblCHak3fSobtsuVFffB+S+7tsf2wfk6vbtLO9vQWl5VQhuruvAB5Efa7vvTblcbh71Enyn+R1/V5lBZta9RPgtV2alchWmyWtREAiRWV8YGW8aVqQ86YpkfjrIL0sYzTGbfpjpWlHB0uoGnIqEhQ32qMy8cYzU1VD1F9w2GUQnqsxh5SgMW6jW2QF7XvCv2aeP8Ax3D773lJs4KQCORYTAVjsXWnL64YtCNrqZVnMQitTKvYd6WO3DlYCLKl1W8GLviQ54VCzjKdM97BkZ4AJQiO50ynG5dXNrm0pcytXHgRXd8r8Mf8rPyXtt4q++/vYz3c+/Kokd4IXUWHFHAuir/pj7V498i48ryQEXGBKtee+BnruXqOPL1JEvVAl6ocrNyCt7XcqoSAgKoSTpWKFEvDCiXjXYvcovMedu413Mr+bqKCyJYiC3qXwte1CuunYzJUVpQO7KriOQxhFj5BCTF0VOadUo2dWsbZhlQiRXfgjbqv/LVXcur8KqYWFhkr9PxprCAU+LPa2uopyucrgy9pznK5tOMupcR+U699DLCpfabxd+8vuO1cr3nIpWMSonmLsjdDcP6hhslqqp+SF8ckAtI44XeRlHyeYVQUoqWwSpdrLp9O+ihfKscau8cBLI5TN/Dk/wDS0vu3TfaxWPdZia5usB45T02BQYqZObuONuTMln09q2bkAN1nXvXSgmkk2ZXAG7Jja2FtiQGJUMeradGp0xiwrqP/ACqrtYXt0jnTOpjZT0z9ayZmZJuP02V+ne5d+GP+UVYV15XCmqMwQnO97veJ++/uP79730zH5HnuoSvPCFnhxTk4wwui6sfEJTMzENkDqPe3cM3JWQNfRcnM9r7+i38OR7cZQ/8ADQGw4P8A2Lra3Jo8kRpmNpfZuGsjxfOj08ZPFTWE8vJLFf8AXjVsXBZ1ZVXcLB3IMcFjZXdiwyWYpKFa1UD655XDni2k1H0wLJsobDKCFxf5W/l07TLan9GmdgNx1crnUKdQofgLBobZOVTepW2/AZdDO07TbxR+Urrl7ZfzFKNhDp2VV7e56TW0vu0+qrHzsem3+nK2/S1QdLCFpp8rRkqteacSaWTNxepFlRChfUDGqnrUHmLQrqrsOs7GuiVYbJyx6LqxxJ+BVmzMHoPPIT0sNbBRlafTJb2Urr4+LWpZYkypxhDtMDF2rMRVXjQJcqhoSpdPzMkLEGGdlycIrO7mJfAOAlDu7xlL5X0oCvqt/Lg6oSUfrszs433SyuWplVD9W83v07eCfyEN8tvHFeamfrdEI3sb8hr3cdywh+gZb5GHk226qDkp6u/uIr2biKZG4DgvHzy5OQpo4uMSrfhHU0wvp5WKzlhMDjlYlFeGqjZeOBk3BascJYEjpBHaUNxNH03GADbLAXuJ5r049srAoV1cv7xfQC3LS0WCO9DtB+SrealS4nDs4CBWOmOoXv48rALvJ/DyHZgFx0pCary2DHr06qd+Si9lFN6lPuqst57YzwFnGraV+FV2rabVNphY6GHKwcq55HJqFV1afybe4qvfw2uI/JKv3aXnIVS2KMNTzRosNHSLGzSbKthvuZmbSph5tOm/vfjAydbISY5ieI6mmj/UsaVqONc85jXK4FKAaKqLq++Pd01L1J9GJhHuoFkLW2PWyCx8MFy6l12zdPhfLTuXdkGO7lXXlOgZdRjk3AKFcVj8Dot/DoXsGKAFihtkENTo3dv/ADO/IDLGiK78R23sgh/Eqq26dRKKNn6FcLQLjBoT8Uaw9YHrrtjIiLH/ACjobrjNGdxsbm0sYmr6nfbhc43NJo7x8qtm+Y3VlD0rNq6WWW62Z2IwmadimBZOQtVpyAbLWJVlYxKJWHjmqtPxiq9MTD0ufprhm+Wug1K6YrMQyMGjpekjR5maKBwAYYZ7uu3qLTiY+o15fBy7tmVnkRuz68paqNY3V1txHC+O0KDcYVcQGxGr5Qu1VXYe5UztcV/2to9wqrJ7td+TwP4iwuWMOtvDF0rGLH1BaVN5Tz+WEZmZB16irvj/AJVajkLmTqOQxfxWEnTyBuNpNCpf1Nu3Gx8NHyeKc33V0Tu/MM4iwtntQ7FS4bx8hmVZaiF9TTUlyKve1YmAsZjFeXk0pGa8aXlNWy9SfZ3qY7B0ci2aYFwyfjytVDghJNl6g11GY2I4rrmOkhBmIyEG06RQcPIuHp+QNRLemnfKgP3v4hvqBlrgoSwD7W4+AY7j6pXtTnUNE21lWtFC1mdTkbvy8e2JhtcRaLkx+MxJ42XpfSyMrSeB+AOOhu/AlGS6wMm45VqP0V8t+/G/Lf3F8fNAkihosbBd1BKxjmMafGaQrkWqqMJi3dP4/VzEqAE8ytTLWWTnixS8ldY96gd181dTIxuoGMauHWxem7yOzMHHqM09g1fMSwsylwsxHRxUW5mVnMXeIjkI0ICWoKGHqjJeo5ELMeUrUMiovUzi8pTJk4dFBKqh++GNtjh4RI1RLyaIvcnIBdneVp67DGwOFuKc+Z5P2TaLr6jvy6aen0nzVLyL1rI2yGmxv/hD8B+MJayFXTqGy4JzL7v2nHxH7nfkxvytw2hC+Br228umt5hKe0px2Vw7cJprOm3UDtmPjFsVoLzmoX79NXM7YnJxmHA4gbcoLxQsukLqIgmcuxcrEU6m4bwuiK4WSZkx2O1+Thks04bDPKcWLWKu8t+RkgMNhnBreWN+jjfgnNOoZVZY33isilgy5eKRDyICSJtal/Esl/UFZ7W+huJ5WeT8cZxgK7s+9Ab1YSq9xBXVsJwjPAK3rG9tb9yE9t+zb+vx77TqDOQytuTPvxvymRFCr2hXtodiSkSoPgq+nx9vGK3rKcgLXjQLjkAyUuqB4l5jHCkqyG2wyAqpI3kXiDQZQnW+3J2TgFyVqt1PM4LKYOFdfjfj4j2FmkSEtyHNmBjdJIafua8RYzqLEszLtbc3KBkPyZ0XaC26Hfxwh3dihdFYdhq6trrOfp7BnUIIPe+hXFlXyLEIKIhIqTOjOlD+7BH2Wupw2lVuZVAZdE8qI4PZPMpjMsqc8Bi8ijFnd1l4DxuFXhUxfyEy9+dwHbUeUJ2vIMRU5fG/s29u02nK7pA7MqptvBX26NTPE/L42CRHqBgKqu6teQwCWqlPPPOpp2WRzI8tx/TseLwsa5bMVD8/KKlnkPZWHh0uDHnQ3l5hhbcvqlfJ0Xpt3L01cPTbhqMPRp9fXV+U/sC64fFNyqtTK5QRqmueVAtv1cjO3o4DmDMRjDGxhfKMglROUplu2ofMcJWVZWQRnht9CBupMxd+d3s8eM+30bzF/IW3Kd5dd19WyrTclUv7GZAALGdhYdFg3TMbMaGPlJzCLKE+yX+08iEcAvdlkxmRh4tKHMFYuWs7a7AXZXh5S7Z1d157RSLjAnvNzFYDimNiLVN5/wCWo70kQIrRgCMraoPxfzfxwq6dplXHJtfgpprYhtRzbcrAuxMa5WeZa7vPZCcd3u05aGVSFXzdjrG+sKyvUigag24Nbm5aquZOWFrlfPUu0s+J5i+Et5WExz4mY7u5XV8r8b8Mb77H3kKttrhbdEXNGMyHkdmPTZfmLyca0jNKBw4mtiXXC9ivJWIY+WBQ81QsDIA664BQZCzsr7YuLxsyyLc5xrUvUgn6gm4x+PVjkYsrJTTKy13fe5k5vQhao0yx2UTMVQCNj2qpQ97HuQdhVOn7chmMydRZCrNcu8vI3VTdlgdiWLlqcrXcYiMMOpa1BXm6qWxhzD26ua++rbOar7XTL36w1Y33K4VePAbFvx6d5TNyKVtOZFRgQzbwx/v5FvimNESRslAIEjHQ224aRpihFAN4URXcSHNimbBrtVYQLHrnVkzE6dXfK2Y1BbH8OpTGvOt1vw27lq34a+wbopVlZ0xlW4tyxjsW577Ui738MfuxTiFIOyEkF5eRYZLkNAsrILzbUkvzT6PLcSN+9XKvaEUDvOBTTDvqM5lGPIbu7uKxDKF0kCpi6v2taeWdwWI4d9zxHAO8FVgt7KI/Arh/b+yk+JPZZn4Y9+7+8TbmXYguaYXtyvsdC+Zg1d5NJsZqzA2luLiq2VRXZWLmDRMIrU9gUbmkVs3Gzvnku6mJ/dSruEZbeDiJuD4I5dSqrrDlLdd5iUHzXkH5isY6JLa8zSbaxAqlejruEdMGkPVm45HqKy80vHFcfl8BWDHMdjihFDvOFzjBFIgpyyrOxARebkiwfFBLqPZzv9lRVVuYJV4AV1LXYiJ7TzNwMuYubsbmrsMotvHSNvNZ2rgqshpbzFdyJzBBaX/UrHXMzpqrBUt1ZGLjqWXS8AK+ntcGL/I7GLhFUNsQgUru97mJ9ilgQfp74WMYl+m5EZhMCg01p0zSzAHYXHGnC9tpdX4Y9707hZaUChrVWWa1ZZCuqu7wkgsdSyeZgFUkdrLIDjeHvcsrSWRkG2w8b8C/eqc78R+cfIJdnkWUY29vBbLEZuXFe3JLACXkrIU9ETHOVMokOrDNKxzrBqHcQlVMTDO7yVUESvcdLIPLN1OuRluVQru8bwRiXw4imgvasoSp2KJCnUxLq6MJTKQBpJNXhcezrrZdfVyBumBcV2K+5LvdmS0i8Eutdlndh25NdRAqq5PaBQH8IxhndLK5Q3Xpu/Hb1cv2Ri5fwX2+jJuBXfjOJbAnetrgrKxvcbtZbdPeBd0SWUQZ910rvpnzYAUu9yG6uYA2SVK5u43yEdqyz5HWU2ebbPNul5TrnmMjbzj7huyJ8KUvi3HuupkjxbV7QT2XkUNM+2y5SvFKrMT+fCvCr/Yr47+tqrWfhjae51ZOnuTXjUX8l8X8eGnab5iO0RPBy23A7GQAVjxqhxV3AWAieJVQErGqxe/BcLsWGN9HpjOkM8inccJQzKXvmYy+ObtcxL/5bP8Aucbjk0x4A4ozHtd/XbDwiGbZbRZhe0U5BHeFV01P0sTH+p+hrKZOmEmy/GeOVQqGDYUFSpyrbHGgQX2ej+r9e+1S/Vkt6jPBuqEuFqziHkvbkqclzcYJDKHkTme32z6cxdVJC714rla5tWVmrddPqeYqVl7V5s51B4XkSsgeDWXLve8b8O028cga8+sa/UW3svTw5ZC9OyHuZjOGmstJ3lgK6zO7MrjAy2bufS4vM3JuUITEb1JdVF8RZWSuZrlsq9ODesYJ5RUysVYoUO809NGXkEx2MsF0FlWLp+NNV02sfww9OAhfpKSHF0a2DkaKwbvByaYWj5FCQ2Nyq8dr3vEft4hhFdROM1k8k2jyQoW+mvkmbXZ73tLoalLXKxQnlBnlAnlQloGOHYN/obzrHNpsVzplKvIqc8qIHNaytLuhyhykkw7svNZcNuSVLtwEsaoLupqJt8zW42biKlssLY82ULCG2PIoq2XabQoLyVS8gJkHsfSoixMeuDcQbqm1VuaFqDHOKxnhYlfF92QXuokZq99Yz1NVEvqw60Rk0V1VRt1Uuq21gR6q8NxUSjG73rw00B2bkjVZQUZXV1MXbqiVTtOsKhblcpklyb6a+TlfK1wkjFKXZfTCcJ050pa5lh9P/wBcVkUJZDfCdOcJxnGf/n6Go58zi5I4Tjc2ubXNPy2Fj+ZqassTTsU2Kd4q6qbplmFTr1csxnIZvU3ii2Zi6gkZTQKss1lk+2bxWddQchJVbVzLuiJPzfzBu99uSsUyW/zDKprXcb1t1j1ba8y70I1WSKzEcdpRTjRCdZXp6q21PHDo1e1+YPwJpSrhfPpr5ZK+ccewqg4/JuZhvsqxWdMcNsvEOMxDmYHHHQnqLx8dagycdbQMLA/Rj5BpMstpU3IJnpwskRC8le+XlDav2qisNzKfjsXfmDAfHSNPF13jK45mPQHxCM41MfSrZWfprUWPyBj1NLUFlq91WLhH/wAfJ262NjMcXlXAT38a3Yy0iFBnqAlf1jZhLvM1C3DambTKw6oYPwXz6a+cPEB8ycXotxS2C6owBO13tBg+DdpqN7qxndOv1FdUOdbrzNIEq9P+P1bdvTpWmAYMwcYxz8Ty7vHHCibNV/If3eOgOHp3e1ai4bKym/uwmiQOULR1PTFKWS6uYOZ0pmZYtAcggXV3c0UR8rllUyGbq0tvFN6hW786zH+hmGjazDashUy8gaX4X6qmkMoZqh0Tca/p09FSsrGnmMaDkY0HKxp5rGhGkpqO/S/9dN3z0YqoDeFRx0TfR/j9QfHp0pwHiWVVNaeLH+IFYl+pLuspvUK/nxEyG7yXmM38FZDQJL1sDWjHyhF2H5uX9o/GLmtRGZzClld3vcrw/rH2qC/a8pleWcdXjftA0ghGRGu/p7XKo5wOcDnEpYnssTqZ1/R/9dX5ByWrNuQ679P+L1B9npWV1bGMqvSHyXzfpD4vxupv3K+5/Iy5f2j8eFeFeH9LLadSG/dO97S5X7H9/wDlyvbncpxSnFOqc6pzrHOqyZRXav8AAr8h/lb93p/w+pX2ekPuf8ekPm/n0j8ej+/78Ln9V/Guf3/UqVU2lVONzh3yK+l/gX97PyO+703f0vUr7Wff6A+53qD7r+fSPx48YQ7eNy/5Fz+6HsKLueWuparlBKRPLS0zJDZP+APub97fu2v0l+Labelf2H93oD7m+oPn1V6KuXe8v+Z/ax3pCZ0x2agKsUhupK9ugqMQuZo1SP8ABXy758dpt4WfabTabTjOMr4uptNptNvC+82m02m3o2m02m04+rf1b/x6+UlEn26lRrauC0d1PGc6jWzLL6X+Heb3OVzecpyucrnO5ynO5zuc7nUudSdSc51JznOc5znOpzqc5znOc5znUnOc5ynKcpzqbzebzebzebzeb+jeb/xa+RLaJNm13cJZzjcoWSmnULJKOZuv/F/8N1SnmWzzLZ5hk8wyeZbPNNl5DLltL/8Arn//xAA8EAABAwIDBgMGBAYCAgMAAAABAAIRITEQEkEDIjJRYXEggZETM0JyobEjMFJiQFBggsHRBOFTkmNwsv/aAAgBAQAGPwKMDhb+jJF11wiKq/8ARoUdUP6OlE/0gev9eVcrK/8AQFB9VC4VZTH5sfzrl3VdpPZUatPRb+yHdbm0ylCHZl+IHNPRRmB+ZcDfIrgfCzNa9EinzU8dFfAfzeAocJP0X6R0QzU5c1AeEd9tEX8cIZJB5KBdA5lD2Ardojz9FR31Wvqq/UqX732QJFeivHfCVCyMFVUoFBBeX8zsuGT1X2Kh3EuanULNqnUqdVSSt85VSpUKDDjqVGzquIiFVrT2ouFy4HKgA+qD9rNT5lBrBGDA7ki4L2nNy7oDpgUB+3+ZVGd3LRAEQosUWx3UireahwlV+qp91XIPqqEnst0ZVNhzTu6yttzVKdUWOZvzdOBbLYqqNHkuFUaB1UHmiOS6Idl/aiwqUTzUniKCK3XNKqP5dApzK39pJX4bFJlBsgKh3hqFWjuSltFwyuB3oqMKrAU3PVczyRzc/JF9gm5WQ9fiCSDAKgCMOaioEUTgTJ0xBUdFVRUr2m0PYKdNAurlPNNOVH9KzN9P5ZRNpAKDNmfmcs2yzUQz6LddTkUc+9mVJjRb1VUkLjC41utJV4HRSKDmj7QSFlHATELiMLK2gwk2CgtMc1LwCESAB0Ca3moCKynE0NLLM6p5KUE0RYLLYJ1N5Etv+Xb+Pj1WZ9B8LV1lQFQqYXdSNEWQIWZTBXA5Z8py81nLpjQJ+Zl7apwFi0oEGDFVNzjllETxBbwTR5AL9zrpvfCyj0W8J6rX0W6FJUIA4Zgpa6qdtJ4bon4h+T1/ieJCuvJGT9DhUR5KY+hUL2j9bJ3P7KqlyEotbouoK3lmgFDkhscoUawJXs4kclvXJspa6AnVvqVukFF3JViOWH7ZomsaK8yjclZ3uhCAh0V8GyoDlcLekqIkKlzZCN3sgSSaoQLGoXCFAEJ5b6Lp4K4XWi0xsuHGysrK38Aya7wgFOZtAOIqW77OSpWlRqtp2W6OkqS1sIH2YnWCrH1XC6ey0RMICt6ygQQQnck4EZrURLdmGkIgCUHAIhlgpNwUPojyiqILwt0yFAoFIBPVTtD5BWhoqnHlp4MpsiOibJUkqcxpcLVF0YdqraRaEd4SMJRadDIKl2tlZPNaIyY+/g8jjGAx1x4vAA4R4qY3QlbP5wnx+oqCuR/UERtKt/UFlBlcDlwuQv6KjwuaO7rot13qqtnsoFuSzVqjO0ElOgzVBsk+SLmA15rK1o7red5KjSVwx3W8/wBFwz3wocx6JzjYJhm8fVOCC0IQcNUCuxVLqMsTxKyuuarULaPbYtogOavKEpmUp8/+J3kraJ881bXweRxKsm4BGvj4J7KCK4gIjCtVQ4bPotl84T/mKuv9ItvIomCeILaOnhCe+bJ7v0qMqoS36Linut9vohlcDVHM1brz5qhartXGPRVeVqfNMhgvhV4W6CVSilziVlmFtNnqR9k1pvmCMYtCHmn9zhU05BUC6KCAXaoiCWxRbVmkpvRW3VXmurap0WcDHmh2Q6q8KmIND0Kp/wAXYL3Gw/8AVTGAwBhW8cbKZ5qZxand/BdNrqtn8yd82FlI5fVZv/iaB3dRf8gciPumbMXfvHstp84U/qp5KvUoRqfunNbYKDRyAJzBVa5fF6L4vRUY5UYPVXA7BCXuRLn1QkXsmv0JW1OrRK24/Ytmf3BbXLcOQzsBhOPPGAgNAF1wCuVSbpomK3VTMaoz6IA2W8aKNm2nNC5QcDu3hHFncJ/zHwjKS5cChtowHhuqDxNR742Vk2mq2fzI98dgHXdJK2ezdYOkJzolj7ra7TyHZP2b+By/a23ZPB6/WqzuuKNHXmmA6mU/utgRczKaZG82UHUrP0QfSphF8/FCeXGjWynzowlCnNHqv+N8i2CcObCq24T5prOT/strtP3KoFkWtHnjeiyN80OQMoxjusU7djAjloIVVZVaVLaDkpwf1V1xJu98QT/mKKhWVlSV/wBLM6/iv+Q1Ubs/ovd7NZNlsxm5iwxHdbPuj3RXtDZv3WzzaNMIUREfRHLuz0RBc26kOkELMIlNa/QIEp0901v6GhbLl7MLZDuVsOxWyHOXJ/XaBbc8mx6oTqCo8ls9no1ifsxdhkJ7uTE8656JxPvg3KtkO7iixgMBOoS6PDAFdU3uronMUSFJUuaApIvZAQACi0nsVTzXu2yuLKjyhVK7pvzBP+YrNm1XEFmDhCurq6GFpXCFZW/JajTXwZWtJPRA+yMBbPut5pHdFbNNJNKq7ldy43Iw4HuhRw7Leh3ZAiMw9VTiiib7YQWGh/2v+Q7mmtmMn/5W05ZYC9lMOa6R/lOpuhsBbXZ6mo7hN2fxEyVsnjQfZDbD3fF5rabY6mi9qzzC2pYIc+4TBbVSDvJrI/Edu/8Aaawi9ym+zOmmIWY3KfMiYIKc7TNjJVRDZssrCmN5FPAu0qIwe4qXcTl/aMW/ME/5ioygiVwBVVFbAfnNR7+APa6Co9nU9VszyKLnmUVs/lRZoGJzSNKYFk1xqIPMIlu9Hqg1/qv8hHelp0WfZ+YCcPimoWdgrrBThUEFZ9nfknTxKDNuadkkgoS2ovK4QpYY6Jua8KXGEdtFXW7IUUuMKdnNL4BBzlB5aprRTEIHVGacl1VfiRhWCPdAjiyxCyCpiI7IjbbMg85orNRo0nkE7uVHXCygUVZwb2wGNvAQ/aZeWHunei9070UEQUEfC1MwLdo0d4Qc2xCyNZY1KdtCRlii2jNYOVAfFKHdZQJMKIhwXkps7mq2PoVmzI8VVr6Li+i941aFSLri0VgnOy2UuMjkrokVKG02h3b+XRRp9lT1xL9nfUYN7KZQJuFY+i1VQVonHmUFM9sYIRK2U3Mkqyom/MndzhXwcKbgMGtzBs6le9HovfD0RAdm6+AAgOjmt1jQiSZJTVOZq09fA1Nxb5hOJ5hewBrmjyWz2jfh+y9ppdNeZyzQLO0TRF7qaAJsrdKc1woumhUiSuE+qu4Km09Qt0j7Kub7rebpoqOryKLTYqXOkcl+42CzbU0NYRLeFgQLNfunZjvD6oh5vVbhho+qDxd1EXA7wqRzUFGt049fAZQj0UjEY7PAHyTT+9O7nHhjCfAwmatWXZmRgANq5Q7aOPn+QFAfQItLqIdQvxnEOnnAR/F9DJVJTVUEHAt5OTynQLFZc5hNa6rBooBgt0THdLIPgtbNFm0LQi/SEEWlEc1lNjrqiBXvopknnKkEDohDTOqkt0W4fI1Q5eoR3Tm5J+2fWPqjswA3meQQ2eyaSNeq916lEHZNXu1Ex3VK9lwFEwOysqXzKYUOoVcqDK3tms2xdHRQ6hUodcB1Ka/UKrAhDBKb88+qf3OENrF1ZZXiChn2eU9pRy7IOdpSEMIk47KGk3XBHdZTE9PCO6KCPfBvZdJuuimqYRoi95knDadgmkHdJgr5qKCPj/ym5aGVlDZ1Vo6FQRBTMx+FbmzTDgRqDROG1E5DZSNiM0xCYcjt4aGyEbSJtKoPRXP2RDyY0WeZFoTqQ3X/AEnbJrGgCi3jTlzWgXNbrQFcKrvouL6Leb6IQa8lLaFFhpVAmQeYqE0Nr1QnRO/ULdVle0QVDeaqAVHAVmcahBWpC8sW9wn90fbNl0ou2AyjktPROLjJX93hfmaCqMaPJXQR7eFvzI90FLsvaa4BBuFEO2J6hGloKJ5FWpOZM7Iv50Ufp/ynFtYVu7UMh1FFsq6D7IgPaUai/JT+oKdm+HatKq0x0qryhUtrQINLZ0zIBpmbc1HqU1mzAAi6OflUqA2SqnCx8QDzTmj3X9gVHQryhFwt9lVn0lf6wIMp3ZGRG7C8sQndyji/uh38ATsJQ8N03uihiO2A3oLplOKHbHZfpJhObzBTkE2eapotpzzIzpdF6GYRyQa/aW0W1aLBRNSh0d/he02NDyWXatqqlvmqO9KqWk9JWd0j7oezpVDM6eSrxG6OY0lUYE1poSE0AUuU0N7oQcp1orgojwf2BQeqnog4GEB7K/Ky07KFQreVK1U9EIOngd3Tu+L/AJk3uiVMRgCrlVRrVWsjhbAVxCPdXQ7qSApDAnDpRN7YjDaDr4JisLd51QLxTkoIqbYOOrtSpLp/DJJW7SUWvMlD2mXzVJ9VRxMdVFjlumHZ7TXRZS4kHRZn8eg5KqJ0iVsyx1IUlq3WE9VvO9FxOW65bw8B+QI+eM8k2LrewpJjogYWUfXCjlvDArmFFiinUmqEjAYDAu9MSiF08IRx8kAJkovcyAAh2VZRc03KkGq2bubVtp1ggJp0OmJGBKdQ9FWrjdQzzCDR6FDK6CVIHmFL5nqjsx5HkpaYKk3jRSd3uuZ545hcKBVAvr0xGEKWU6LevgS1s7oWd1N0kp4ZaFJtZZRWU5uUyOasFOZULipUOrTmhDZpZV2AW60KCLoDqt04Q3F2XQVTcA2MMpiMO6d4wrLdLp7YCGb31Qq5Bud0d1MyAgGEU50uqxXDZprjq37IHqgVCNVQoZnAKhGGd917Rovbsg5wMgwQqghXPoofHmFTIjvNsoDlZCQVSGrfM5rShGuuJQ8DuLPJWU8I5J2UAtKiBmN0RYoEJn6iKwtm5o0gqrlZUCj6L+1RyU65lBwjLbXA+ChTfGScSK1VcQr63QkApkOkmSQNFL2ghbcxTPT0RMJwCKqU1vMpgTHcnEYVG7NOS/Cba8JwcKxqs2xbRH2o3+q/CFRyWUnJ0WXPI1VXdkPmTiNFFkJqqC/TBpHNEi5oFXBo6otHEDA7oe34T8SJ2ZysCy7fldZmnK2Vk21ooUdp7TINAnMzQ5gOc9sLqmEc1YrZgf8Akn6JwcKHqoCqpNAuv3T9ob8k5xoER8PJSc2ceinqg8ihwDz8VkYt4G/lA8lPhryx23z4EI4bMfuQ6BBhvBd2wy6KjoVSoDqKS4yt0rNNU0ZW0UrZn93gviw/pNcRCGYw3UrI94Abqdeq3XBw6LNtdoG8ggGvzs5Iv2u0roOSe1jszSKdEfZkkkQ7xFspj3PGV2yJ7Lj2lSQJH+lyBiCpusouo1Uo4hwBkXQYCCHD/wBVPWy2Rb+kyOXgl4nogYj8o9k3GitfDRcKDBlyl1eaG8K/7Tu2IcfhUNq5Em7hg6QiYC3gDJ5LgHogBs2yeiIdsmyNYTnZBRO3BRk4ROuIQOXXBodaUQFOB7p2bktPVZS5gPdfD6reLR5qQ5hHdFzntAC9oH5hhPgghWgD6o7VxE/COSZOpoEW35YXrzWUWapQ7oIjROb8KGY2t4h/BkhCgkK+LowqhKPVEGVJM+SugfatBC960lFoeNFthrbCXCAmmFtBrVRlFLyg1osbonmcC8OPDje9UZPEgnTqUwHkgdIon/pULbZRy9Qp6poB0CHdd64DsiUEAdLYTC3aFCbKFJsMDCqf5CO2FTCJ0U5wjrCmiKnLRATcemAKEXlNeBIc2oTSDCjVEYbRjgUGdVHWMHCYyLjK4yveOUe0K4nr3j/VVL48075gmcjs5Rd6Yz+1HLZBT4Hff+GLTjNh1Umo5+M45nGG/dbkgrhNKISqqMIhUdCIvK4t3kj+5EdUJGMqiy8yFl5E4DuV/fhtIWTL9E0s0WXLA7IO2eig0am5DvNTfacIKeJgF0pwF8sIZgb/AFUuc5ETLdCr6YVC2g6UxhOOeZ0TT/CzjkYwUhFpa2q4Pqvd/VcH1XCuD6ogM/6QZFMNUGBtAuBe6CB9nB5harVWXRTKoCp+i3hbBvhZXkjXUp1dEOgT3No3PcqbomOJSKkreC3alQ+iAUEQuZROAdFldBk1VyrLhTyBoj2RkUVgjl1WzbzKgtlBzOE/TAO2mui3N0qXujovwzm7oMyGSpooIr4pyHwVMYboQDhTmiB47IYWV/EaaLzw4lOYK+FHn1XGfVBjXme63v8AkbSV705TqpDiXc1xfQKC5S0wgBg9o4Q6ilVUhQYU37rRadyo9oF7xq42rddToUPxK91Wq3aFQXNTxnbMK49VLTC3jKIF0zoVxJjGGaycAQroAHCcGx1Ux6qIriXnnGEsHdVQxAC80T4x2QXkqhZTsy03WWR4Xdl5rdBPZbwI7+LbHWmDpxurre7Ye0HECr41KufRUP0VfC09VlJUgrakH4sd6qocKeC6cM1UKeSsVmyErgHqml/MKMIKMNJRa5pxLtR+aOyCHbDPoBA81Sf9oCaxdGvNXXEiP2pjeb0GtEBFrgnN5GPDmagaWQnwljjFZC4lkaZm/wCZIFOqAfCcxtB4C9/CNFGULorqhU2UmrTrhB5J7+sBQNSExPhQ1Al8xhSUB0R6YWWUCApynDM38p06QmVuUFGaOyBO1c6NDHid2TH8nq6ysknsi5nH9/EPl8f9vi9rtBM2Cg7Nqy6XHgY06nDZ9ind/A/Z6gzhHVWQnmoWVwkL2jKVsplFpmCoHNADCdc1cHjqE8dURCIAxlw7YFwsjX8raT0WzVTjdXXEuNUKNV5oLa/P/jB5Grj4R8vjHbxbMC7RBwAHwjwAjRWMoHwyCQUJ2jj5+AbxogQQiJ+IKPCctirDxE4B7eyHl+XRCVGHCuBcK92vdqyPZf3JqhpuqvPiHy+MeKhIXG71/NH8KGdZ/MGF1cK4V2r4V8K+FfD6oyv7k1Dxjt4x4h3Xn/LhjotF8Ks1WauFq4Wo0hf3IIeMdvH5o9/CP5eMNF8Ks1WarNXC1cDVwiUaQvNDuh4x2/IPhH8xFAVVjFVoVguEKwXCFZOjkvND+hh4Lq6vg/svP+iKYU8FU7svP+iLq6urq6ur/wD27//EACwQAQACAgEDAwMFAQEAAwAAAAEAESExQVFhcRCBkSChsTDB0eHw8UBQYHD/2gAIAQEAAT8hoA5lqUeXpcrRBmNlpdJLKorH3/8AC/oHo79T6j/4c/4HllTzk+JslMVBdtzEu1m4/wDhd+p6Pqem3pxD0fRMEIbjH/yH0P18fVgmBb7QKzrC5a7N1ZfiL+g/oG/Tacehv0ZxCEJt6cQ9GMVp2hDcdxnH0P656BbFOP0OPqVRpfQTBV1zU4LB+i+p6M49DfpvOIcw36O5wTrDcNzaM4hCO4ziHM2juM4nWHqnofp4lIUxen6PH16yNJXq/SfU9GcQ0w36bziGmbejucE4Z1Q2ek8TiHPiG47jOIczaMdx4nWHo7+k+nEPrr9Pj9e5cuMuX9YB2RQfR4SnSU6SnSU6SyYhVxylxcX9QFLjlMTE1WusR3DgW+04VHvGaZjrA7yjrMdZiYnvKJX0rf07/wDFt+ibm79FgxMoL4E4nNzNLrtn8TJW0Q4PzNoJ9M79M86iuVVR7n1sHxklybfpH/v2/RNk3fQhQXBLQPVVOTLof3YK0x3W7g1AjvAO1HRH/BH/AGd/Oc/mMHEOP2Ysmh05i3aeCchdQ3BCmcmBJQAg4gum+5km3qFWpjeCMYe8oYC9Jkady9Q6PXcCv0h/7iP6NL9REd9YaUxfSKqeSufllWOdVM+cetg6HcUlLlzUBC9KXGN7KleVXBO0DV37VPjm/wAMQwX0MfafZBYC6faVcxuZnyxD4R+UOA5awY4xPX8IRuK/xgn5MMA7pmRvJPNCCy7x4O0QR6h+f0g/9GJiYmJjpPCeEqKjwnjPGeM8Z2J2Z4M2LB14jDRM/uINzWbL/blKsPnyR7GPbfxAA9yPr2hLXrN2MLbNMbTO3X7xuQHTmPgnRN+7BFC/xK+I/wAEUsk3ec9CD0W2RyfeffyrT/kGf7iG195QZSn+DpG00dJr3m0oz8JQLTOvSkPnKjoOIoO2Z4xiG3SBPIlupLdSW6kWdIN9K8t9fAVpT/6KlMplMplMph3lOJVv2s/mWCjgqg9oQeEw8VHAXoWO3dhslbQdTc0Y9mfmXs78fzijcO7b7xuu04H7TAiPvFfkufEqrAbPaXA93J8Stvu6PEtmBZmfNwlboF0wq/8AN2hP7szznRuVTdjyQb2/ROlPRAFeZavzYR9Snq79pzgUy8ejzKZ7szHGYw17rNintK9HnPOX6zznlPP6oJKf/JUqVKlT2+rA4GziYMUaHfxMBT3qoTCb4qoDrGe+I2HrLLD2ZXcDf8JTn9s/YCDtfcT+iM2v7szg/wBOIPR40FrcwIzjRjqxwYqt/uWgWk7qFUx2IMuqephgG698Mo+impR2Kzl2XKuZmcxj7EQPgle9jKot+YWxDuNxDsdBxFAdfwSn3I3cIMwYvsCpXqOMjf6Vy5cdKMyD1CVKlSpUqVKP0lkslkslksmJiUCgBaugik/ecRCLppsCGqi2nftcXFrnFal9S3Bcyjwa+0yJIcnj3JhxXrzPvAH8enNzbwLC7zq4IEj2mEwK6qaPDGLhmS5RnDN/O1/cEhR6BZ6C1gqj/jMfcRDm3tNpBXgAlGNLMFwUS1OkO/ghPYxKxeYYYqIbnCIlry+Id+ESfUjkbAz3lgCrl5rtDsdLSNGmZmfUv1FPSWalbYxxPoH0pmZmZmfoYRajX6WPTExCAwbXQjxVjG7cveYPVAhNsl2htgBnUwLdsFda+xlELc6lyBXvi5uxVWjjc6UXV1if8yW0SLQRsFezGS6mHDtmY8GU6VqD2YNLJkDu9IFbQqLSWGrrEGeFNneV7ZpvcfWaAUKpq4P4TtGs9+ayOKLzGIqdG5g34WnB7zM2Hv8AsTjqg+/vBHMdAuyQhYD0YKFqbc3ABxv7kF2lu0t2lu0p7T4i+IzG9gFzB11jn6dvSlTExMTExMenHoiS/XBsZ4s8J4TiHimKBlYLsbiwUVdXmgxW2qKc3KrsRwqZAVCq6ulyPEYsXp7dYCbVlcCF1qNeJeZqsF4JZjs5htFOrcxiUoNzixhICB3WpTQ3q/PETzds25nKklX7xZeBoZYrOS7I0tTpLrxLYyFOxl9E7Q6LS6maCvFXnCfmMVMskSFQb4PBBN3T0lLM1omFgOuVi3d1x9aStJeAIb95a6GrzBq0nXcfv8EixPyZ1Rg85xABoc8qu2K0hQKJ9loJiLOR5xTCqQ7S1IaHoxmU6bF319E6cF4gl4SuqBmMF+MMiw79AWYb6Suh8Qt59MEVDMZj2ntMyu00+foPTJEGF+p95bhGWNkEovFi8iFaAe9yiR1Gzwwbk8hgyxDdSpzthV6w7IxK9xe/tGFEeR/cH4+395TtQ8pvr+SVJF8S2IW6H8Sk2OGX9sfMo1SB7e8uGKnt4ilWNLdEprX2ldwlXV2kpRVBqBz3+HeAvr23aWbbKQz+Ick67hiS07UD9ztfLKi38HzKkAuBy8Si0xslyixU2ceIattrswrdVSrSnHzBbmVHKoozLLFTXuSydMD6XmI/lL87eDEg0PDkhtAnSGhySwX8y4hGqt15x2IOK8rEk2RVNRsoNVeUyZi9QGFud77R36DLtRfSD6vzLUut+gTC/MwR3H5nfY0yXt6gtLQVLSn0IGYgab1zO5L9Yh0w6LDkdahUSFrXj8xMejq695eLuvCQ2bMc9dyWPO+CIVwHiBNkHjcCyjnKgR4erhXVArzLRhl0Q6i6XC4Q4HXKdCnIl1U8uZmj9vaMYnZE7y9kLVFtgkhk93aBB+VW2wmYrNAJiLp4Gfuwn9QlC5OuUzSgl74D+UV4RjguOfcqfEGPgvHvBFdZ34mQCprmpx/NznUmfMz/ALMMuTLYinYFjtG0s9NsxmUARUVi3UzktvNfEJv3exZyZ6pRuBnClz4hDqu76NdZcYwY7sXaVm94TH2aQAip3qczZmsXy/HHcZA+SAN99Z+T6G6NzJB8TaKpdeIlets0PvCL0AaTk9BiAcwdtaYuk4Ck6CejBiSDQbsPxGA3+zc8zzmJcFMc3kAzDdk8E4q3GN9JRYFeNrMGaB7yoE8vggZfIQJoHsucY4q8oDlH9o+goYeYLQxoWRFfuiHN8jE7OCn2QTg/JFMXx7TBwS4y+hl+0EpTronC/HLF/dDGqBIpfaVGxgX1giUGD3l4XQ+0VfDL9Y2V1ag3vX8pqtfvS4AMVD7UvjBcQg/Zb19PM3gjLftCoRb2PRjIc2HhJcXtjacQ/LMnWCC+kJba07nMqasHxF1Crv8AaiiqBadojJcdsGIlYRngfM/YBNcB7oKyct4MTnE17T0BTBKVzOxO36mtGq1qOVRczXiIkldq59BWp93Ae7gezfq3WVHVS0g+PEDvlwdZzfsRbj8R2lpB5EIrDla7M+COLme3TFxaf68R38nTw2xTRo97UK4Z4ospUrrmZGUWI9YdyAYd/MIsXwzqvlnBtFrK+CN1vMUb/A6zrJda/EtKcBb/ADCWoC8NxU1hHXEzwoUOTmEY3Y9rhk6Hzib9tNG8ysEUI6cTE+57TCac8MPHbLx/nRGCUq+70lbdZ2y4ZLzvrMstyqsnaU9Yg7JUuIt0/EQmgqltRILbXiZ8h2dYaqdLMvNpeTtOUNBjNA4lLejRKm6v+6Ax/wCGH0eZUHiqlTNE8AM3jPiK/wBmDDrJUYjlaOINgSd+PVZdNRjY8ER/J6GfMp1lDBgn3E+Rehbtht0xBWGpfiaTYhVSja2sXADqdSDpV3xLCfg5qUnz164xNZ5Q4zsjHTK1dIRBuPa8MsOKsOzUshV1/BHZ15lp7Jw8ns3Gb3nxiYcR+BluHwKmiRirgt7LB45mstCVLvDQcrolgFRm6yeJZ4at10RtYxZa8xf5dpXD1na8CcLK4EH3vGU6RLD8y9fIQ5y9BiDTFXiVxh1QRW+o/EYqtBfMbIy4PLiAVeCVZbehKYs946N31195WHKDFfmGUMm+sLUnJdQaKrsq4rVsgSEyR7P9maxotOa1dan+JCY2PyejHuHtO0J0LRdlxzVHoECmFHoa+hZSvpJWS8T7mGLJ4h5vhIBY83/BuA2GXroPE+3eg/cvzEKlMz25Ir9Tge+5pFvpGsWTTCODkyCWy6VZpJRDQ6hStJrV/wBy+vaSsH8xU5lPuVDLk073C9xP3/Mq6qqU19vsrM6v7bgyuV8mD8y+lyF+07mpe8X/ANi5jodi+7UwNdP2mVarczsBrh4DM92MkK/rI8vfyRqxtPcRAAsv8xv1ly/tMMEogN4I63wj7+IQaJzOiTlMJzIwMFQvc3uZUyoBW2OAqpbzDgxp/uV81DExutI00Ma1K7m4v+YW7SPas6KdOJg1wgS7f70/2OswGBVR/wCaJsypTcbdp3X0aCGbvqWfsk7WPSS7Ij3oLmPTcDqlevr95M35IHGvebvQ/wBEhH6ORlkCEhYtlKn3kL+uX8xRoAFTAbMnMF4veMNXxDBjLoVEgAcuz4gdA64My8dXSUb0W7u0DKB9jiLAbWh+YvrlnuoSwq/t3qWC+EGhF5JfgJeGqgfgiEmEfd0RQuAP87kagWLeg4YI1YvCKblL7j+zLYqI3HWoZKwt1zmXVTr4fMxF9bwbi+B2o+7E7CWtcvoszmtkpjxY7ESmFULycSigUlXxFicYrt1AvXgzRMqOcp0iWbAddIB27YHJFYVm7iI04lPsYqFBVtfEYWcl/aeGIoNRv8m5/gdZj0d/MRV/cZe0UaCD2MS0NSZmvj6F19BRi230r0pi5Uv70Wtco09amF9zow4rUssRy92RsLvHQO0+QnIGP2ROAXzzBaG3jL5UOzGMPiYjGxmc7kuPgBmLAtmBBkrTWGfcgZS7MbIIHIIyJLS28m57eZgKUuhTnUZ30Ml9TvMX5II2FYiNBtbyvqRmFkvozPOcFQye+Bz7kGUFQWMykQoe0f8AdWoYjRo12iMgOsS4uxeP7RzGNUBmM9imWVat1LsmLEys7RqA6RpXegNyqtOAxxDPMRWOQdb+JUurLz7wJJxPl1iqm1VvvCwMWH8xuC4LPicCLVLoPdqK6Murq+Zb2NjydsQQ/fnZ7Ezc/wBbrF7OUUi/9pU3y5l20nuz3TT0CwrnPBM9ZQrjrkehKRk7rhv3fQkSuE1v30fqDYlMFx1rqlzO/fRfdTmaV5mRwbMz7ylW8mKmzE8efEOqRezeYE2Enh0lYnBjpX8R7whm9t0BLJUGTr4jRd/wmIds/vG/PY/B3meUHjm+lSyCg6ckN0+cHlSxyd2ogx+SUKqlWTTe4XL6z3qLYrGPM2kuaVjtEcYSdRdcHmc4plix0dJta2vtBKi2sqW0dyZniG0q2HnuRuUVvrCbwVs5I1sbRiW/yJn18I3HxJSVZ6pmCnUftiXIibKoQL3jcdmYpgdFrV8S6fuxxHukwIuNPH/M/wB7rHYBl2xe1frg3qX2j8x/B6KuHyR6jHJcdiWmfY/vKV0f73hTANA09yLLlEEMihtcbVLrljpkWrtgHyTOMud3uDeXR2V8wbqDvJMRQw3mjkCaljZMuovl0P5p3MD7x2EgU1lK08RPhCOOlutwChi4K595gyoEN4gm2rqMxgeb0bqBLo2OElyS1/M6rX/BgC5eV6cYhFAvui9e4v8AMx03yfipzj3Fc7Q+2Yhujy+GYATwH7wH8FTFjOKVfmUEp/7DMvzUXPd7Sr2gdN/vOYOJ16r8QGa1+Wpjr2C9YXGTju79pZHiHR5nIuBw6kshXRiMMtDENVFsHxLgRBmFBKmfiVn+EPptEyWUmGl7vtD2l0V8/Mp4rPt6Lsjh+Ux3SH7k/wA7rOPQYYeilgZ1BvJLlQiTJBW+sWJIzfWZ8SgEPN/mVQ3T6Fela8ypz82ZaWUDmZ0bYYuA2NWS69VMCMwrrUzDbgt9u8E0nE1egET8y1mD+X5nsEgsd3VsmfYpVOfzHMvEYi4QLHhxuohdurdm4saVQauvzM1NQ+OJiZMZ3uUdwYaNjFkWB/7M8xO1dovVUxksZ114WzKYTtxM+XBoIyFdKTIzNUewj+x3f5Ip6iY4PvNe4UHTOPEKRJtxA4kbVZUb0grqvcjC712pjKy7BX5ioZ+K4Djdzj8y8pRaG2Zi1paR9pjweMRslJsN/amRYp1rXeW/u3f5lNnVwvuRUl2uHxMS8Ez9u1VEX4l65wQcgguZ/NDHpVjedTKu3Ad1+ki3LcVjQXDD+cQ4peejMBKaSw+ZqMOXLzNfQBFVauXRqLHPaL5j/B1QS+apeVnqEqD400Oik/Jh+VDN+ASEDqq1qc8taPWJmjrqc2hZP84Fg7QUovRJYBhH3IgKwH3GYXHSGFc5o+DtLu3rTp7zDLBzq9yXw3nc3Eo7Rjb0nBQNv9S3rNPyRIXXo4vYgeyqh1fq2ubuAcmmz5Rg2q0z3Nge7/aJQBjIKvcl5D3qZeeAMr0qAgWbrx2TCCVziZrJb6vKYkD8RhpX2iRPIZidF4JVZab0/icUfZBrUj4RT3JhjeNdnDKwtrD0SbnS0Wd8RIyjmV8xLaPUfmWRnIYFJJUuzJgeRgTa/wC3K9FNdLl2JuA/eUI8sHxLUeuYcPOV6P8ALcz77ALIeFxFZNZtNPnFo4YmHX+HpsemmOFKlXE9eAjJLSo9096EaPoqVB8afcp+RLmhnS8GfiJlHBLY+Y+5agrbbyh6KnVir4gJhb4mmNv6KlCiXk4/1xm7VmUqGMPtG3/TlNeB1eW+kGcsObE6VhgCQ1x8EOjDYFxO/wDQRGC99EvALqPh6RN5TBF82AHcqVhiCyv+xipcBil6T4xG93acC/a/uXmQbZltLOBroTHz7JHLbxxF4PtBvB4+gUUMTIxxB+QnaFoy2NtQYRNpZFaE4A2TpHDKM3r8S88C3xwTAv7otF47Q2NHXMtRWKj3ZcsB08VNJ3wglLuiMz/3ZjeZEI9CeIzg/wA6iibHo8R8uoKtS0RUw96M+2NvSOrO2j2TWVsOVh+7BKvTUq9BKEespfCOpB0RXyv4xPg0Ism+5D3mh1D5Lhs9kcPhK0XwagIFFa9ogqVYHL0l3Tk++2M7C67HSMK3LXaNXo46jtNcBRNOWLXNQLHifhfzA2Mtox8Ru2DaH5I5D+FMWi54/kuWgpRpLt8S8A3ldphuSri9ypJVwo37Q6upm4plxy55g3yNsXmYCF8QUdblIStsc9IEVcwskA0xOSUlMsU+toSbpbUgKDxEaY4turY++pSEBfDUtLKeZTmJQqe5qUmqlZ54lAt5Y0w9DeGbJm6lAn3T8wn/AD16RGVS7x9/nlJGBAeDXoqiZ7PmnX45mVeDmVLBX5haHBcABpzzFeqDY1CDA+n75+VAidUtw4zJLa6OIZuKwUEtJBkeniY7y8nMV+BP8+8YRfY34qD19mdkK/eYYUWdmXzkuMGeYmgWyg3W5VI3ttrr2lYzp9O/tLjmzSdoEE0vF3gfDcH3NFFbPILBK0yL0liYlxHNR4hBsVSGnxLPBBpf3lZYWKjpLZs7rZWlfBz/ANRWcTp/M1b/AAJlDE9mGNTFdYDyXVogAgdhLJ+xCm3sk2Sd+PR1MV6DH4Y/BEYo0RHugzq9Eu3V6EPfPee2YV+SCp0ziY8sr2RCxO08OSO0zomLmB8T7pjDRZsmyE4YU+zKqljacRjcqvGHMNfL0+y9Dd8uPdGKwNVmBYiRaOYvLwfV3BEd+BnMcvpdKlw8Yr/JQHMWSUtsi+FDeRXVTLy+tq5YLld3HuFnc65gHcjcw1e4mp7TC8RELx8voP8AAgfcjQ7Rc1B4HYjw2vYvoS7Qb5KxnJ0l+PGcjB71NZZ9yV/3laDirMwQqHIygxcFdkcKB12+JmM9tXxDoo8ZmvPOf4nNic8jhhcFcEWyb7CAAACL4Yn5UGXiNyLKiank1BgG0M9I2J14F/EEYQ9glErbTdNkuMXO7LqYwsHESNxTpmL0H3hTC9sQ/KdlnAW1v2jLO1xbXichI5OWUNHzlmqIxURD8LMTu5WZkvaHEsEtkY6E2ZZW6DPs/QEAxzOYe+I9AG9YQsmq/iFxiLG8Mp9KemHuxhCrvVTKM7hK+pmlqO8x1W+6PMxbq4pHaWLSVQANnb0PiZRSyqg3UQdC2D0bgukHyqdtgy0NitQ0FicMAm/guNm+vmGTBn5gQdy+0yqiXo7h36yzfjrFEAEaybI37JMc36G0r8G6Y2aXx/qYxcO37QYFXQS9H2fzAQYuqqBKme7NrYbK6ZS+6Z6ozNsqHwz7nEv4jMN3aXTomcMWwKjTXvLywNcBjiWgoa6S5vJMdsx4KRE9o6XVYcE3AKVZNeLiTm6EeY+XMoZvwR3ZvgTKrdph7Qax3zBVZgwuhcAEC1x2gxUuXXMqbEs0YlQlCUXuCj6H1CESJQLZtLiAk0eutalOCrlJUx8DFnfkR3QpoaKeuZTFfoIu3aD0Iaz0htqKj2SgnULWj+YAqzWHvG7Re8Uh0E6QiB4JzO+WL9KLNcXNmNbBsKKwwwsUmnaC7q0aSg335riNKLo3EItjZ15lD1EtzmO6/wDamBBaLvv0hOZ0L1l2MP2ibBbL3TkbiIUgjwZLPMVKlXl9OzWBdv3NYH1dY4YKllDNghwmzEqH+5izsW8MyBS6uhMvSQ6anvOSbQpcZWqY7MzBtN3Soy+sb8TcOpU27RwSJhsitpWf24SmT+UX5HROstD532mgbPEIlFxP2SqKRzk2+kEMLQsLYHAmfvKg1fE5l1FxFfg/RGp1ZUvz2zfrgeGLy6y5OWVENFFeIxjszEef2m/yfmJ7Ed+b0E20TKNZ5VtdRydX6MCcKxEpW3uOVlgVoG6hZQaYvKbb0QmqAqwqPSFrwb8xa1b4ntafiJSL9GiMDk/W7dv8S/U2y7jMja+1pCg5riRw8w1jeT/dy+3AwY8XAklzTiZk28uksNyfqhpcebzfOYQejDEyBLpUlsqP9nmXu6gFWM4hNUo2MDHDk5eJohf28ykMrnoRdQb2PLHAGpklzDEREOxJRjMfieGZms+TsSo7TsyrEZzGNuD1GJArAcH6VidUobZePVfqgFSuXcmHQWNwdyWZkBHPPWMA3ALy79CbmaVmrqjUMLu9QdMLPLiVyG449462V2vt6KQKxUAjdCuZdQarTHiMiFYeudCHRAOgSL3Gwd4E0AD3VcJcrAwPaN2oHczELV0SiNq4rnjESscy6C1Gu8sDdtsdFtbhEH+mpVrXVOnfvAFQOfQAJtnmCihyL+JsahuAhcFUd/T3LUs8QOyNvEobmJr+jXlSqkWWacsa8BXkqtx55cniEwtX3mLhW4omv80tAtW8zyCDpG4bR6EmxS7xespX+dZyj9DTx/WSNkXttt366IAuUqMJ4DtEMtrPv63Mpiq2xQ5VxAuJeZai1/CUcr7TIejggv8AWGIEmeRmWr8jgO0v2Vpnoy8K4UxigiLQXLr+AeY8QpamKihSLoVasHMpjKbVBQ8TvcPzEjc2sDnn1yjmTwhT/Cgla6Eymyp3Gb6YGzc24lJPRXS5e2QbQgIoZFlXC164wucVAXERnOOFIVt9GHsIXkllBMQ7P5O0zKpDw3Ddy7jeRlmUBu4TyGV1fMtU3ZLRdWjg8Sux8wluMfWwPHrbp9IkKfVfqs+3oOUP4fQblVSLt6oWGaAjhmIZDuaMxFphskpzHzERXGeYG/yYmDVsVNNQEnDMptReQ01zGoIKt3UFzecmkeviMmRmxpgNwI8dWVuLYbpfiebhSFcRhBTrqzor4itcb2n/AGoC2TpuUXqDyEMSx7OUbP1LGQ8q+yMG9kSU1ct7r90vC15+YedXiWPOzCTDT4lrDe4E8rLm0vfo81gMcLIKZ9IaMcdeZoY/XuJHf1cVHrSdcbymMXRfQVuukwhlob7Hq9mC1jcX1uDbcQTOrUXqPGc5IcRmGjCukDHJ7yuTTvvC1fsnmILFoLb3CWTWlQduR6TuxOx943a5zzjM1moR20WBY4RMGWHea+zTBl4/mdyGV8X8wLXwr+6DUNM+etRrw2dkuxkZ/mB1XJxA1Oh6w9WA7MzTmKtzVOhxETzqAF+7tLzZOq0RgXC6M44ZR4jr5qJdTtLJZ5ikvF8c36l2LtBQARa6rvAdY36no6eYsR+rQlvWbfUanWvVnCmi546R+UFOGeV6zi/ljwV90aOHvLZg+6U5ccwoeg31WVzGf5sgC2ze85hVV+ZiD5ImCbDooC/5hUC+0LRTul6eEz3S6zZFflcTwOld85iIvLcQ5OJ5vzPdEerKerO7i/idikPNagoaZQrHIw2wFXWHjrMqA5qMe5Wk7QI3AP5jDw3yQgGZOqw6VBuxqAHlLjoewTVsUe06KB0MpXgACzZ7TLc1ynSWX8JQlSLPSNgLdT0J1AOEJm0JhF61jV6+qeXpeI8NPmNXB+IVdfhDNI50SKDiOky5fpHtYbPTk9KglAtYG6v1C5bPE36dHevExEJ0mr4qvj6tUsq2rM1fTC3EYLhrpEG5353PQHAwQkCHU36zDUDCgPnM/wCxPF8wqgkktYQOdA6sy9V2VUC50xX8kH4ib9ukU/0/EtST2mZC4XtNWgek2StCupKWmd06lMpu9S3BfecZXaawXulHZhyEc0i9yrJ82t7Z/YJ/bouXw7EuWWpzjw5zljGnQikJGkuClEwyQSgq4xNJKlIWpQT0KXMkzc/MEcZbVZpxXEYunE6mDRoypF+o9AAmyW9pT4DjSWW/DMCUielZM4J0FCbleEcoI94VdxdQu4DQ6zCIAxMCuLQRua/H1aJvD7ol3wla7OhFriUHk7VLqRUBUJJfT0L0k2l+l+y5SFeyod88o908vR/qMm6oHhq83LdZ3fXYqvTTvUIlMYhTkcR/6p3InXLmw9r9Knb+zIbGLj6FSA/ojCuV8JMSRdfiLwZQbGYPH15l4h1cIt0gp3A2xzHc0CPDOIOFsy6XSM3fSZ+klkcTGdxnRRxcSrioiTy16baU3w8kQwhq+IwQvPvM+5j1ba5YgBUXBNk7noxBzRHSb/q1TaB+YlvgwmUXN93kx+XZcU1Zu7/mcco27VU3O7T30wGd5UcrYizaCIS1i+8AmECkie54iN23wjH1wxtKR0kpJlaDAAHB9NOpkceJwyEgWDTivpqY9alQyloWlVfiE5Z0jcdy5FtX26erC3taOp7zEDPExrFtTqGEjJDbazB5GBx2fTJZAfuj5BfgEaURYq9X+YTwN+6SnutvSFz53VVcC0mBCt3wQB1iNc2FPaMWXKC7457wVlHiEWjSGpzHGz6tUMV8aU9bhAEnJxTLJWKzUTX35pccxuwfYI4pKVHUxM7Ci7smbxEhDTqVl8hR5Y96bNuI8xj6h/t0+sCf919JCtJt6rqzAO7FVEW9st7epNCGX8wAJ/idY/mfQprqzqMNFlKZ29Bu0oD95QTkiUC8RFfQDwzAl+2HWWLK4ZmBo5JTzBFW1u4GjZQCHb8k0ln9sGRIOHrKCl4fRaXlR6oNlkp0rVAwCpDct4m31bECs/24gnV/JAySuk317nUsfQj/ANOPRfMpstztSvRodtdIbv8AlILlmoZB8xZfr/t4+tfP+kjgGDdyEWsym2j7+ozeErIa1pkqbWwR5efoJnGkaYIe9I3FRbjiGIwPEUOs6zCK3D7ytRrjxNUU+4AMv7hY2VFCl+l36KHJqLm1FdSFKW6wVGFx+o3Nl2S0F0ktUPTiuqdl6M6KKRQhtOzMFfoPvIjrDtxGAgZcv6F/w6fX+f8ASQKWiXTUuBt64qtv0D6Gr2mz5+n7iVj6ABmFcMRHNfR2+gGJxNo+h36MrpEMoC6yQwLxDUU0jv6jcfsTj5IAKB5hELHD/JDrfKHW+U7/AHZnahjhp036X3kMfxfUv1n7t+r7NF9Q/t9J2/T+/KlTUCn0LLuPoZ0gx9OIRnEPTj0NRhH6jc2jjOGveNyVlL1Ak7EWZ/Yw9ileBg69L7+ffz8H1Yr67xj7l9P3ZE48v1P0Dv6X6LgwLLBOZzNoZeIQ+vEfUPV+o36XCMj8pxHoSB7Mv+zGRy3FH8sUb+dNL4aPTHxp93DY9KmUymUz3E2lpTKZTKZ+aF96UzMplMD78vjyzP0ZixjuO36dfW4pHBLy2XFuBiIyo+hK+pl/pGZwjUfMjUMQn2GYp8U/iifxlFP4JWusphyhH74mmbbWMr1KIaCtFSj1a+ogpMzH1BAAjKxSVlZSBEgxmspKxjX0X6FnHqMt9Ny//Do8yuDTO6RdpucKlUEZ1O2galp90Gdp3vQvLfRRf6Si3SX6Rdy/SeM8J4SnSdqdqU6SnSU6SkDKdI5SkrKyvoJlZSUlPUrES5cuUlIvpcv/AMOjzFheSohrPn0hz5ILK95rr8+le6EvX/6NGAdIBqv0/of4E2w+IkRcf/rn/8QAPREAAQQABAMGBAQEBQQDAAAAAQACAxEEEiExE0FRBRAiMmFxFIGRoSAjQrEwQFLRBlNicsEVJJLhM0NU/9oACAECAQE/AeaG3z7if5VqP4T/AArtXScSf4p/gg0r07ie8ofwbP8AA1Wq1QtUeioqiiEAVlKylUVRVFZSmwOKfA8clqtf5jkm7d0cEr/K0lRdk4h3KkOxiPOSfb/2v+nYYaWb6O0T+z42jVrvlsjg2E6OPzT8I8bUVJG9o1BCaEG60g9g0RbbbWJiyjNy/Cf5G1azK1FE8gaadVhsNFHlflzjnaMQkGZh1+6yYwA5TZHojGAblk1003+yzvkI8OWIc3IcJ7iGZm/smRy2ap33Q+KG0Q/8U6CR2szt/wBO5PyWMZGJPDHk9FJiXRh3hN8lhoxl6/3UTfy1NFcRb1BKsKx3n+TulAxp1yk/YJmjTttsFh3yMp24O4WXCPAOYxu99E6FpGuK091mwMPMyH7J5xOIrw0zl0RDcvDiF2ac/dSSsZG6PLre99OiM79s5+qiwsghZKHA2dua4Yfme7msThGnL9VBhGk3mACjDJnhkYOQbuUgs6bbKTs3DSeXwLE4SSE67dVatWrV91d1KlRVFGv4FKAtaf3KGYzDU1X1Ud/alDE6rbqeY9EIsHK0eLIeiODwv/6L9kz4dubhwukc3fMppXOkLZneHLpl5LET0/8AKJAoD39UGPfdNJWBw0EjncQ0eS4fwsXi/wDkdy6BNzOibSa2wGnfkuG8Gi0r83ghriGM/dPFC1DlsXSxGEtzyXDI87FY3BOglrlyWVZe9qy93DXD9Vw/VcP1Tt/wUnkjmviiNCKP7r4o7VqmRl7D4w37lNYxwHiArkuBmIyZdv6lkYIGeB2fn0XwzBhzIH68wmYhrYfFDdOtp9U1xZF4orBNg7J/xUY411nQgzYczGTVYCOJwdnjcemiw2Gnw5L3PYwEagoYzDxGoGZnu3eVim/lPLjb7F+iw0NRCzv6KZrmvTnzx00P9kOI91uNqSzXpsm06F5s52qCOSQbbLExNlieD5uXuuJ6ISEkjorVpm6s91q1mXhVIj8E7nZx7FGJr2AEck7CPBGTX06JsUI5koww9XDVGAB9B/1UUWLYARZ9l8Zr+YwO+xTsTE+NrDIQ32T5cO9rWumJA6NTsVhcoac7wNrTcexnkhahjcfKPCD8gj2ZiJNZH176lNw0GG8tueKu+h6LHebfNcf/ACsOxr2jXYbLGACNp9SFMK4Z/wBKYHG+Slfh2wXk9NOSmmwzz+WCOqjxL3yNqhyRaRK663Psu14+DicwGjv3TcwLj172vcD5fuie+u7VUjsm+b5d+L87fYoHQIPqRo5m0C6yNNrHyKDibFagh1J+uf8Aqy2sPK3Nmb5WMPzI1WIDDA0ytDnOG45aWo4sO53mdV0hh8L1efFl+adFh2tfUZJbW56rCeJxaGNaRRtNxkrmw61mfRpYyw7ENvbKW/v/AMLETjiZx/lD7lW1wdli/TrR25rCWbWKY57mMFV6KZrmvDbulDmOgXEfCx7SzzbdV2UG8Ylw5aLGBgl8GmmqNRx1lacw35rtiPiQZjuwj+yDmJ/n+Sa5W3qsmu1+qGyLRayqlXc7ZN3+SAVLGednsUNh7LDnP2kC4nKLCrC/6/sqw96SOHyQbJmzNeHLDS+Oj4W0R7WpnyZaP6B9eSJyCq8jrP8AwuPVN/pcXf2T5R+ay/NJfy3WHxPDJkP6mfcJjvEI71aBl/3DX/lYqVzi+QjKXObof9I1TzG5o4elutw6afsonSyOEbGlsZ5nnXVYN+R1EajRYrFxsZYbqt/F15oSOa7Q0sFNbpbZm8KZDIWF9aBRRRlrrfRHJYrDs+HZ4rdei7SirCv1tGhoj5vksuvNNADdUMvp3ZQq76TtkzvxukjPmjssFhy3EuOe7J+6kYTITH5QApsPky63YUeHka3PRA6qLEMLcsrb00dzCfHIxlB2ZjtlKycty8M6c6Tmy0AWnT0RlfkrT0KZK5m1exUWHmnzuby9VJPNJkYSTrooMMBduaarP0HonY/KMsWgHPmmYgh9k3a0lIBKMLGVkJIRjcVh+LDMDlKc+R+azubU0bXTZ235QE54Y5v1Xaso+FcQjPrsv7Jl1si0Hdbcu6gie7Ke4+VC7+SbdLMse782NZygY48XJROYvshMjDgC1wPMj3WQRGnMu9L6BR4qRzOFYA2/9JrIhhs+fxdFDiSx3p0Rjmc8ZZPNsbXw2Nbm/N2213UgxRy5mNf8v7L/ALc6ODmH6hNjxTGHhG2u0OVPw+WMsZRdY4j+noFwmCNjScrWnyk1Y9UwYZ3GboMx0N7J+Cw7hFVANOp6rExRMJcyRu/lHJRPzPA3soRn3WSzoLKkJirM0gdeSDrqli4TmAcPZdtPIjjjG7j+yZBOD5FRFA9E0+BR6qnXsUEGFOoUg9l0CO8oOAcuXzUrJmOO1cljiQ+K982y4ikdh24mz53UsFiPO08mJry3DBxNm1w2FrJHNynquC5pHgzZjvyTc6hkd5fogyLPXFc03qC4gqT4mMtt19bTJY5GZZG5SdUwNYSyI293O/KP7rJle2NrfHlGauqZ2eN5HJmEwetMB+dr4SDX8ofRSdnQm8tgrEQSYc3s4at6FM7ewzGgyeCvmFhsZhpBlbK06fb2Tg0Zv6CzreqdxuM3LoF4zJbzei7WlzdpNHIaK1MfEPZRgUm5QUD3Tn8v6ItGbUqBlPJVrKE5tBNbb/kshoe6nlzbNpdoD86LT9SL1iZ2Mc0llkir9lDJ+d7qSWqFpmM4oiYfCBomYmNsjY2C27FTMy58p8J5dNVh4HzSBrFMXMdwpmZq2I3RdByfImyPNNY2s2mdyjyYZnjDXPu2+qhxEvEebNv5qLCSyFpOzr230TY8NHkznxN3G9qDFQt/+x9dHBRujLbbzX+IJ7nYwfpH7rtJ35RHp/wsNI9r2uH+UF2f2hLLhIXNAuy13uEwgtOlGlgxKQ5x+iP+H2z/AJjiWP5UsVhJoLsghRtL5WtvcgfVYvszE4dxsEt/qCaU3buKyW5MFHvKYaeVm0VlwPh+q7RZIXQk9VHG1o9TyWNLWhjsmbWqWGaxzQ8DcKfDOdThaZA5os37qHEviJcG2sPiDmc9ztf3Xxgw7o3l2Vz+iPaoJvwE1uNCm4uMZiGCnb6hDGEMytAA+qdKwu1kBd76ps44jVNjHEZW+Efcqws4TMY6N1tdSmxLppZXuB83MfssVh3Shjcu51NqLC1E5gNCqC/w6I4JOA91tcfus2FHkYp3TOgkDQGjKdU/G444oNE8gblsjMUXZvNZPqVEy8REGj9QTpBGx2Y5gGlAalOdSB0QCGi5/JNKOypN8xThr8lMHtY45k5z3sbZ/WPsmtG67WdNxGZLoDVdmOccM2wspoHw7VujC/U6Wfovh5c1+m16KHCSOeG5RXMLtIF+MjfyDqTcOxzSdUG2w+EFVpSwrMrT1tclEbhBy3Y1Naj2Q1sFgEdaaeJOa0k+FuStKGqlbTXHKKbqzw7e6aU5BxWPZIcz4rsUR7hdn9oRy4WOXL43DxDoUGultzzTAd1L2WySV00I3NUV/wBKxX+UQsNhThnNlrM4b9Au2e0HOMMTNWyEl56DkExuUAKr7uX4QjatFoIXwvrz7n4ZzpSS7w/0qJlNAT4PzLDDSlYL8LSEBCIP1Z1GaaTrmoqVzGt1TcceHypPleXkBuyvRYXd5J1tTSNa3Vdl4yRkNsOhT8ZO1jXCQHNypPxU7cNxeIPak7tCWXDPt5u6qhsUEQFjNBSdGeDVrBy8FrUcazEsDAcnoi6GIMYHCm6n3WJmYwC3Dyj6p3aIYfD4k92Yk/g177QKc8N1KDg7buHe7EMBpQGmjXZfEupfGEcyU3HHrfyRxWbY+67QAyA+qbOA2q6oY6PouJ4L/wBNqCQniuHS1jXW2P2WELWQMFCg0bqKVt3w2Js7LH5cX0QxTRrw4/8AxWKxDRM9g5u/dOmAl50AsQ5j8tKEN4Z8XzKkIzEBB9JkpMj+gpWh5Vz/AAWKRKvu8LWomN7wLvS0Ggbd19weU8Ra2N00wtOgXHCaQeXNNho7hUWbLEYd0jQEezpALzBNw5c6swtfDS5RWvgpR4OVkbxzKeMwF8lgIjJE0HzfuEMLKOQ+q4Mmbb7p8ZaPFoFjAZMQ9zWmj6LDxSk1t7o8Rp0dqU7jDmVh3PynNanc/NbXqAuo2dVCXh2trFyPY0V81HiX+q+Ie0bikJXBwB1tRSRucRmGiKmxWWTKBaZIHNHI9FNNTquliMOZC3WgmYdkeo/C6Z2ZN8bvE7KKVE7FeIbmlE8cO75oTk61p3ZVIwlprdQYaTPbuqpUpopOK6rrksKH8PxWtepTMQ9raACdO48guM70XGd6LERmQh21LDh7SSaXHd0CnawnRteyiy7i094DGfNRkFPIANiwnxtbHnNnxVSpmQO2tv7rwsprPE4qIPgbWaydfZQCNxc/KM3NCMhxJ5m7Qyu6FYcuI166J34OKfi8l/L5J+jz7p0pP6T9Co5svJTTgjksOAYK6lOwjGN1e5QPB0Buu+Pn3v275TQCjd4wO98tjLSG3c6N16KOLK2lJG48OvVMPiBvmnMD/CeqEDGsy1op2ktFLD4NwkzP3vRfCNdK4uN9OSiiYwENCxHELKaFDmDgeR0XJO2H4Mo3rVcLW05knoiJPROje4UaULcsYHqsrToRaa0DYV3sHe/bvI0UY073fg4Pqsu3osotBnNUi3ZEaoDVAbrKsgHc/b8HJFwC4rSnSALjDqozbR/uQGvyVFZT0WU9E0Glld0WU9E8GkAeio9FR6IDTvPeO493Lv5/htFUq9FQXJS7p2+icDYu1Jk5LDeUf7ll1CBag5izsTcgWdizxqWnDRNLKWaPqnFlKPIBSzwpxh9FK1pGh1TeBXJOEHKk/JyWZqJCsIkd1/jKHda5J7QUIysh9FwR0Ca0CvdX3WrVq+61avutWr7r/jlAKgqXJD8B3H8K/wAF/wAh/8QAQREAAQQABAQEAQgHBgcAAAAAAQACAxEEEiExEyJBURAyYXGBBRQgIzBCcpEVM1JzkqGxJDRTdILRQ1BgYmTh8f/aAAgBAwEBPwHdV/ycLSj9kdz9rX2p+y0Wi0WiNWtFotEPDTxHhYRcg76en25+gE7c+FhGQIynoEZn+idiXtbsovlDM/Lp8E2ZhTSLTjS4rnPoKOCV/lbabo6ih5q+iPtaVKlSyrKsiy12UkjW3quMT7K0MnVUnA2pGjXooYJG2c133Qv0TPRG3CrTsc+LPym70PRYeSmRU48Sx7LH5Ti35e6vmtZSsp7KiqKAVFV9nSpUqVKvCaZ2wCl4wBLqy0sGCGDsdVzUOyDtdkXJykDcqBo1SCCfI+6CkgzMhv7r1FiMrdG2ehRsWTv4bb/yTSCsoWULKFlCoLKi2vs7Vq1axk7W5c21pmNe6c5GjKD8SnW7ZcOqVnbwKDlJ0pZSgE1Y6GZxHDfl7pnlyk9N1CSFFHndygucfyCxWHkicGu3Ke71TDLxbDuStkw5gspVFUhGStbRHhazLMrQ8KV0VmUbA4bLgtRhrop7a6msJUkAcDmB1T8I3MC0IBGrRKCco9WhAIN1Oq6+DYZJLyg6LFxSEU12U3upPn0T6Dw6wOi+Rp8VE8ukeHD8ljcQ6c5vRa6+ijqtUI9RS4IHU/muG3KHa6+qIXNoiiW9yiqCoLL4UgulrkvVFrQLUQbwyQuNRKZiGkaqSdzm7U6/hSLnHoFOLkYbI1900nus3REnNt/NAO7J2bXZMOiB02VWmhAaKHFCKHKBqTusfI0kv27qdwuMjdRxFwadh2TjSjex2yEQykm01v1IIulhxxGuvsntjLWMz0W66qQV+a+6FkKawi90d03yndcypV4Ddf8AD/1IsJVVawfkcsl3zBWCnj/2jX8k+Jpez0TW1ujpajnlzuaWt5VxXjoFJnI3CidyNvwb1QanDTzLcBfKGEkkaG5q13Qj+saOybVJ16rAYeSNr87rJdawjtDm2QPFd5yKO3RQHI45RuCnxS3r/VMBEevdOjsLI/sVbq3KO6EjgCFmKMmis+A3TxyD3VuHVZjssEKY73TtL90+DLCKHNV6omXs1SSPA1AXFGYagLohRXDHEJ/aXW+6eao+ibRCvp4AovutBorpYvEtgiL3a9lh3NlDH96RWcEprmpzngtyiwo5CZTp7qOTm7JjXO5imtIYfxIvcOqJe52llEyDuijI5ZigRW3iN07yD8SO6CwNFjtOqFfzXzlxBB2WZ2Wn+ayg0vGopcJl+qa1CrTg0a2EWjNaxjiGHevTdYKR/DFlNs6qyqrweAVisM2YMadv9lh8II5gQ5xuQXampR4TEDF5zeQ+tKCMVfposNbY+bdTvbt3UAt49j/RcP8A7iFVNPupavfVNe4bIaiyQnbrM+t0B3Vqx4feCI5B7lOFnVBo21WBbUbvdcFpUbdBoKoJz6vM09h8E+TNqDt0WZmc660s5zVSLbTvLtsq9FM3MEGNralBFKy+fNZsJo7IAIBEKrUYym7WdPIrXRRBnR1+ifpZ7BSNbLr2WDj857NTnR/tBBwcHV3CeOdSbrOzLSKL0HErK+rI8AEfOPZEcg9yh5z7LDjAvjbqc1ant6LhQNZTHX3QjVPEo7LGRG2kftKWISTlp7Ix5ZHNbzLO5zHFuhHQoNT2dUapTOOYV3TboJqYBVov7BWVaBI3CHDL2epopsDiSN1lkzWGHlXEe7KDZfm7UaU1ud6JsYaaCw/92kPe1lWHbTD7qQHMnWTSIN16eGGZcovbVCMVo1Yz9WPgsqzlNOZ4UhqNvuU14zk+iwzAxvnv2ULszCfCXMS05qpT8wJ+Kkdl6KNot7gNSvmriwvfod1G9ttvfupTTTaIT25jQGoXDOloC0AFYRHYrm7Jz3kUTsoG6FRedyefqz+9UwIcANaUglDDQtYF+Lc17pmFp6AilgcRjI8M4T5SSdPZNkaVEeRx7IShyI+tH4VR4rj6BFdk7EFkbR94qWQviBPfxCkFxN91lNoZWe57LCFuV4CmJc4EONNK1PVGV4oXsnwMe4CxZWHw8QdVi/dT4SOUBuavRYvCcjGMbp37IQk5qsgd06N4+6UA8P8A1ZXMeiyPrZP5IXPq8vRNAq1atO1TuThtaM1710TSGl7rU0jM7Tv1KmmlLiWCiem6EWMc23uAHv8A7KQYcffc53p3WH4fzXM9t2VKHNdy6ilhzUbsxTw3KCO6vQKKMuJ9k/zeDnuduUHjIGn9pP08ZD9W1RbWtCW6KNo5vZOe6qvQKLLl17qYAOUThIcjWvOuawBY9AvnMYphBAadwOZfPIMuSiBd565k/FMIPM4uvzFQSAxZa1H87RncNFE+MEFzn2O3VSSF0hf3KmNkeyA1CqiR2Phqr8LVN62sK8N81bKZsskjgXcoKcWR6N1chiDkDSbF2m4gg7p7xYbrR6qCIAuJ6J5sqyj9HMarwaRWtoOITJjeqbiA0O9vCwGjupHZn9tlh8Wz5sGvmZxKOthYKT6twklY43pqCn8Y4g+UsrSqWJJBbbW5bHRQ5s+iOGGbdMADaPVVqsRplCgaS5R4Z7sbiruuSvyTYhmIqqWUZiKVDMBSyqjVrBtJDndtEZGulHJSmviGinxcpF7pmVoAVjL8UG2NUwG0fpUmkEWE5wA1THtdsfAbo+EmIa07H1pPeySXQgg0m/JQPYDoeq/RWarDW+oJNr9G7UMpH3s1qfBhgujp3KwhNlEeq4BPVZeb40pWjkHqsOKL/dRue/NIJHAP8tKRr9nPdYVH9or4qKO2h3opHhsW2t7LCSO4LqOh/qpi4SDlPwTMxFnusoPVPjAjb38QfoUb+gMkbAL0C4sUkrQHXykprGgkgb+A3RDQ/L1tH5IoXnZ8Wr9Cxm+Zn8Kb8hwtII4YrblQw0/+M3+FYhk7HFpl2jL9B2TvlFzhry+wtTYrito6KLEMZeq+exL9Iw5ww6E7J84DunmvdPxMZc03svnD2kuBGvRNlYGgM0bWg7Iyna7WdWVDTWAFwXyix5p8cjb2o6pkjIGtY853uJIpQyxydKI7qVozClG3TULE5uEco1DTS+TXTZ3iTPmu9ey+V5p2Rs4dizqQoPlGbynPl7p08sbMxcK9UyWVszGOOYPuvSkMRESQHtJHqgVP8o5ZnMaPL/NQzCRgOx7LGYp7JAxpr1WKw7pMlOoC7WGwjYzm9K8W7hSj+1fELEYoNsJuMoHK2yPgn40DqosYCd1O+3vP/jPT5njUDRcZ/dCV/dPc8tU+AxAxMTnVpTlncsxWJGJErsjTX5rAPl4IzijZWb2TmAuuyhG1cNvqjS+qlxTcsoEjQRW6i4hsvA9Fl1Qxczdm5vc0oZ2YmAOboD36EJ+SOV2Z29UiWubosQYxghyjm5a91NBw8OHk5+esutKJsXDMm1s3JurUkVuaxhzd/dYcvwzQwOBJ6HosNw5XOdlAfdGlFARI4ubzZrDkWxv7FYY+cWS0bH6A3CfI79KsHEOp1b8FiYM7nVe/RDBvvZ/8Klwcn7L/AOFYfCvDrIeP9Kk+9/lnrFYSJ2Cz2Rz5U0szZWm6H5IDwx452fu2+OG8k34FXg6tLXI17Wjc9PCVrixwG9Gl8jYKdmNa57SKDv6IDwcXAaVqsHDwIcl3qST6lYiN5nEjSOXQg9QUCw07Nv6qaGOWDKRpSiwsTY2sq25r1T2GjQ2OygwTzMZH0OYH8k/AMkkc6Q5h0HZRQRxNpgrVYx8jg5jAsNG+N7SNnGvAb+IRjZxc9DNY1XEAXFPRcV3ZcV1VSxOjnf5d/wDVRxh+Boix84banhYyaQNaAMx28cdq9n7tvjhd5PwHxqynMa2R1Dr4EKJv1gPofEozeizeb1XX4IO0pdvdA7pq6eBY0m01gAr1VoeITvN+Se8JsoPVGQBNlasQbc7/AC7lhz/Y3/vmLF1x5PxHxxn6xv4G/wBPHC+Z34Sh4DcJ/md7+LPN4u28HtPRMJ6oBdPp19EeZYt7lAX5liOJXVRukzDUonzX/gPXzmoHsrzEG/ZFribJWVyyOUnEebPalkesj1BnY6z2WV6pyp97I5ydllei1yZmHRU5U5AO6qiqWVAKkR9mN0/ExFNxDB/8XzyP1/JDFwXssRi2E8oPkLdfX/ob/8QAKhABAAICAQMEAgIDAQEBAAAAAQARITFBUWFxEIGRobHB0fAg4fEwQFD/2gAIAQEAAT8QomXuXdiXmYha2eciA9FqIOAYzuOA5i6isQ3QhGl7ANt9z7y6Iv8AiziEPRnEOYb9N5xDmGz0Y6IaZtDc3R4nHvP0hHbHjxEx7w58QZI7Yx1DUPQ/8Mf5hcqVKlYjjH+LzOP8mExKWMdhxBgEk3hdA1WfeWuM1n4lJ43Qb1WukNhGDZWx8x01z/m7nEIejOIaYbPW494c+Jsem04IGGbQ2eZsjx4nLzOXiE2fMePEqfqfjE5eJqmzNvaOiGmG4kun/GvXn/M5JWHzKzAbIgKPd/yH/NSmrKo7LGaktFtGeO3MRfKjbA7hBWxiBhYqpxHoxnEIb9NpxDmGz0ZxDTNE5mycPMNPiaPPptHT3gwzabHmbI8eJ+05eIbJs+Zw8RRuk17zl4mqbpv7R094aYbhBmcHof8Ai+px7Th8xqDpKwDW3r/mb/zWNWRVQcYPVwVHSBGVald3x+4V4DAVee7cDc5jGcQ5hv02nHvDT4mx59NvaOkNM1Q3Ns4eWaeE1efWfyQMeyaveaPM3zh4n7zn4ZseZs8zh4J+8GPCDGHKbngjp7w1Gx6XlmAhpm3o7jOGEI79AuEGMQZhszXmFaJrnvX/AMAetLuLRKvPfmcT+Jm5UZxDmBn03lY94c+Jsem3tHT39Bqhs8zbHTyz6E0em6P5INexD+kOLuTZPxT95+ZBh5mzzNzwSsfLDjwhxm76WBBqNvTBS8ETDNpzNmOiftAs5juMOImWcy3SV6v/ALbYy2Wy2Wy5bLS08IqZeX6S3SW6TwnhPCeECy+UYYgOkr6gu6ndR6bLvpjYw3Klds7DDoM7DB6GX3/Eu3PxL634l9b8QpZTpAFa/Ee/6j3/AFF8a5LEwjQ7mPWn8mK8zca/JK/1WuiS/wDhCuyGyElXVK6oAcJ3CI6ko6ko6kB6y6vWYRWA6EX/AMtKr/wf/jNXk/8AAVAhSbJto+WYxa7QfTMbbpVP7IcrjnB+UQ+AWn4YFtVekWOw3PtsE/P+GibPPohDj9xcwBgOY8fPBwRWFJTM/FPcrt4iOdGp+L1qV/lo+P8A5X/4z7h/iBCk6Audkdo/eYB1b+sqU1Kc23sAqATTQDXxTD90VTX6/cMqa0Ub+F+zC9SDyK5s/RjsNKaUOf44JkHLk92C867YV1IqCuCgA9Kp+4shaLju1ZnTyVt7OmPQANW2eGaY7fMUuhuUAwJjr/LKUFG00EE3sxX3EcCBpHiNfYun3lPFVT2cxUH/AMtHx/8AK/8AjSy5X/xNFwh59D6XarVdbqVeIM2Hta1KkABoWOmy+8Yzttr7wK+XvCtRKOkG3FxKYRJaDnJiPGKKsBeMgY95Z4KNaS7GMQQlcFcv8lArQW8m+9TGq5awD2vmF8sfEzHYqwjviIObuX8kRFZHYB+qiYIztq+NwtZTQfRt/EuJFBLTp4lVHi2Y8OrCQi73eIoDKfaF3F56RzKNsAh157wdYqiQqm83tG6sY900n5lB6+ibiU/+KU//AC2dJZ0lnSX0TwnhK6Z4vQqHYnZ+5X/aV/0gdT5ldb5idT5gpd68zFd/mBBWAioO7V0eYgppFkZ6mAiSMHg3F9HPWYlgvLw5X8TmN1w+R+SI3ksrdOuekZivAe726ShAK0rbi+vR4hDJibt3xTiUXINhf6IocYUtv0EyIyVWAZq10F+82/im7/AJrKEwA5DLXMXKAEFzoq1fUvZTrPouBD41D5sYUXk80/Mr7VoTL4ui/aKCUAc82B08zNGkzupMsvmUUtvTtBLrbApGvEwKFR7EV4NyS6KublFv9/Eoym73/wCRnVgv6EsI2YPaMHV+6Asyzug/80f93P8AuzmvYwxRPeeD5ifSCvEKqx8zx/M8XzO2fM7MS2ffoJcet+tMplMplMp/wxMTEr0qVKZT1JbtPBPBPHPHPHPHCj0S+iyug2xywtETt9X7VMihshR5NvmJjmuV3Vw8kwJ6sMdysp0YgQDZg8tfmFhj0z38LGQNjpj2fzCrt9MB7qPAyn+eV9RgNDR+Cks1XkBfvxDaFG3db7eYDkVtstDKx8I0MrsLg7zQmN2rwOXtKlDKhtsM640x2YsEmwB1iy4nSOVJ+UWuv9u8aK10V89y8lKOCyWPlVdVK2oWtcW9iGiqgEalHB9Te1vmvh6xzOnZa7QjRyK34IUFew5Fo9jcdTV2PQy3EZDBj0KolTK6oj8Mvag5yPkxC/Mv1lov6IOLReL9ZfrF9YvrAc2wjX+ZX+VY9KlSpUrtK7E8JboS3SW6S3SAxXaU9JnpKekz0jlQr0B7bXpChtqor5PsQFonW3+2VoEtDKHTmWWdkjbbDZlltAZUXaDPuTH8mfT36hjC/co7Pjic7FXbE/TEIRGnqfESwnv/ACqOYTu3+D+YFaLI6HjT5ixwChcHl4jbZJqgLbZy+ZZh6xSwea4PMxsFGDuvK+HcqkWHKg7M4upUl3VW+vWbiOL/ALDcojV7PlKGNuHFlheXGFjYGPMpdjb0ICUUFdVlODKEi0FXvEk4T+krIlPZe4wWK9Ar/wBTFGBZBZyGF6VrmasXIsHd5WV4ZKcnx5ZXFsA8E54mKtqd5jhnTSPCBioGF9caIZwwZfeX3l9yW9SZ6kz1IvcilSnUiepMnDc42+8FBKa1Loa0ET0t6S3Qi+0v2i+kt0luktBO0WamtwSCS4JBIJLPUDrzv+ur1y+qJUQLULasPXfy5rTKYymQlZHaQjmgDcsIN7durXyTccsqBwB6N7giQlwVPSuI5/hdNqtAfdxKMBw1dOpBwnXYJ50w4EO7+bQxP55bEZY/SEPTgC/itgQ37Su7tgsE3mw10DLA3NBtAjnB1hqwSxntdZTYJ2CFh0t/2cUknPny9Z+0v0B0wFsEMTyGjqCVeiVi1otyxGoVJRF47EBY1RcniBQAeZmPzwWiZj7FLl9epBTIJ8xroJ2FTOEqbU6rcZlkoZ2B690+plNXwA4ISvAWrpiOaaWE3Re6jsAKaU5z2hAtdhgwq3BGFqcLZdX5hZgRpE1L6yX2y+glngnaPiWuD4l9J8R2NIMAX4ikwX15hjUEeWsub/7P6XAjnfobCXNzcXFstls1I53iDpANMGWQrrLOpBOpLOpLO0s7QrtK6j5lHU+YeHzPZ8xkgToQ2+ekq2ViCxWG7TmnUDGRE0dG3wwyt7KPdxwfiVgIhQ4bd75gcMwAyhq5WsbqOhnHZhdCGjKjupTsAEZ5PMXQYLNgFmWNnG2XZ9L1cFaqxdrCvLLlg9lYaut1fMCDJqGIWo2sb6NVQfu6y0m0XAyXk1FmVA2ENmSpl7VQijqogFdmKl31m6DBSExuZDEGbAwkdGMgAnec1BR5QqorHd5YEVtJwI4di4NloIyww37FxxsTv3jVicsevA9SCDw1+QRGyT/RqWCs+H4Ilprp3PwX2hhL6r2pKMKsR2LT3qoVRJC2CLU2PtzBhOM0DfSukxs0LKm49jbByAcccXvEG/hDrfCd74Tv/GH/ACRT/iU8/CUaj8S+Xspr8RRZfKsutCqX1x3mYdGtzy+4C9av0wYsspFRUVCEUCpeZQuPQLS2ApjcMwh7Yl/7X+ovBfP+pf8A0gmDbNpzzghdqJ2yrSXOaDACrWMRQFizuWpqJskLsyvBGoIZVqDq0MuEbimButCw5UqtrLkNb4viXzuBUQtVbrv1YK6RjGsPtjsu6tFvivmNxKygyjqx5qKipF6a441q4LU+DTfJ5gwuwF8rO27ktn7jriEmaotGVulChdgA63zDggOZKFf9QfwsFuewUWz2lfpa7IoAe/WZ8OO6cUTHmUkX0ixMB27EGkeBYniLho6G2uJS7YApDs9Y0SwXyRd6WjmxyFbsnnmoRsA3Q1mdUKfQ6q4CIywQJkHvu3tBJLYKe6Vv4gWgBK8OsLVs4vBFUvmJWYli7MfphZxQqcDnOH5iJdsKfbH5g18hi6PY2eWD1BRoAFax27Sv2oNZU6fHMRuFCulgyBStyko3alvTgjauVettco76x+bDag9zE7P0AGepzcEyyLWBWrs6i4CM2wHn9PeCAjvWSL0vqIYbXQlBqdzpHEppyYm9Rp5gFH835mTLDgPxNk1TDWLQyAhQFvHoaaCeI9D8MTp/cex9xvpiPRK6JfmPsPx6Z6xIMkDMcEg1bY47kF9r8Oh+5d9A5+GKKQ8lQcUUriI1LJJHRvZMNJYooCK670y0ri1CV7kEKhH5B2Q4RFQNiiZONwJFfFKq1d2RI0HNrwM25mOVtGhoqwhINpAMGdYiiXtjYj15JXlzkcfpIC1sULV8pfWFIewiw62KjiQwoabz8yhF5D0y/iDJOBKMm7X1h1efQVJeXRitxCAJsN2kOIb2UERpGo6btqxFO9FxGLo2Whs+ZkeiB5Fw76g3aXZate3fcMKEWvSaq0clxwOLp/uM6KADkDAW3HxK7GA9luV08HZ9qgK9AQWNDu7ZWS3Ljt37yw1mv7cQOec+Zh1vV5Z/7EiSUnfQ8QRG25qmtxD2LfFf5l2RoDW/4lDAQ2B4zj40xkZ7FGvcJUgKp4Hq114hAXxGVltZVqGhXKLUC47TVZCcGLSVZrH4gr2XhTXk5mWcSr+EZfhRichk/TMMija4rZvY9pQrX9pzX6lLwdoNi5OY2Z2Be3gL+bibkOngiFHR1hC5JnRQpeI3Q4TEYEYA47kW4+dAnDwPWmMG4HQ/SZ+S/UbYBAjlEPQXEiBR1rMr5Z11lqYtLRs7VcT4nNUdTaXE7w5qKS2kLEQJ1INoOOkwduxL+ofrdTKO2SUmCve1pvcKgsbkmcz/AGyKrw48ywBdit9LOPMdKf8AAP3S2brO4XdtGp41m9+OYdkV3l9GAJxVyKo1fWXYUTYD8MRa6M0C+ZYhvQp1xx4jw5aAaY2V1jxS8lPjD9QKwszrXvuMUNAHLBMUVxRFJtfvgUHnrCAlIlEV57nMUKKiSltWGIx2EaBbbS9946StUROaxCyrSgCcnP3CgYG0L1vU3JPYPxcVTFjJ+x/iVSOqceziPlDNqATwvsp76TCU2F6Irq94WGiQ5aT2g0gWHQA17XH6QJVqK0mCvN3fhmZpUPc/cMBdHophlsNf1vqZJYQ3rzEK7iw32Xgvp1lOWTY24MxVsTwNVzomPhgUtw42dpYVCxZHl27xp6C/dlp8MMhnw8ubhNRVWFU1ffEbgjtHFVx7P1LB1O3AGurFxNFAtQAfa3YxXllzc3MLB00BhM4I6CTZW/QPihgirwvvGCzKzJvrMT3/AJlNcfaFCeDHpmMYVrOOkLdAaQgAHOOsyxHQBGpnZct6y3qzuQRt8n+yWDlApDhGWGEX4fieKdo5QLoZVm0TrXSDSqrTMALuYfmdanb+GZ5ECXpDs6oIFwHn+8RUsOn8kvO5lV9NkBdQQ2DXnEEZQXDLW/NFxGlk2zWg+aiQYkMrtVvFQr1cbW08HeAFPAlCZcpDxGhptvrVXF1QXQbZ2UxYWx2KGbVHMPaAUHIHIcmo0DOCg9kzBgxIoF8Uy8C8NfyTXH3s/U+mhP7I5Fjut+bi9r+9XwUQvbTaG2k7nMQOuCVqo2v1WiCnsKvuz9TAk64fY/xM+S2DIeDRBjwwWKLqMvyQ4ZqgCkLcWMnaZaBse4X9ymFFD5ghtnvEOyPEFx8x2BGr5RVd9bw5Z8RNagvizqvTtGuDwObntMGhqr2r3XMfknX4v5RoKNGdFw9ldJmTBSUIKHQcdYwBcVzRx7LMSFhF2Sql+NMFrIVacHSKBtgF0Gs8WwIbAPkcDyEooSfVvgSklPxCxGdgNPiCPXgNHxLIQpU6emZfQ2upbtls4pVURpguG9SREdHJ/NJaSJwVvBxXEp2PxA1o2gxIvZA2XdROB2XO7iTSoqrNFfE7E7MUBBLJrBpIU7G892NSa1FPVXLFClvzuIAtxV/TplwW9HzFjgGCvV0GUDWyC4yhgrC5Itie52YlXVtXaVbiLoFvlj4jhes1X8SnzqlXQD7hksqPUKV4puA7tU02hfGJT7OmKVcYL8zN7tkVfKdb0/iVqZmSomgVEegw6UMHcu3mUogybUM0+YAEAbiAxk5gJ0sGqDdA8cy8DN4D6ZUVCuH9JD8jzPzUCim0qX5ZZA3Vl+AJieN1s+UxIYiThx4RVAO7Y90u6eGgOp2zKC7jt5LU6YimWAQDLTrqF9u9ctqOFD2it9MDboDBRKp4uKMXHAq7qnMz8BgLbRPzUTd0biEpgsdwvbNZcHFrwEEBad9m35gJArpyP2WGY8hfL9QwnixY2qu1x6fljpSlaVQJrtuIRlnc5h3nWkJAu6pE5TFIF157xUpSFvLFkEihY0dlvQjBTKDo+KuveDoNnq2t4e0Wnhk3QpxxzAjuqDk4r2jdmCuAJSE5ISo02MN8QhgAIDVWgG9BUcHeOotBbxj0AgesHcgSucrFVDqT/TvLIMcl0vn0OsNaGZ8xpuo9X8xD+5iODa54+WW2d5X5hrAO+TFG1zBdTxmDO/xAqu5U9mbmH9emA/1szsQgAL41mXwjoXM3gsbIYQ+YM7io2wPwMGFqrZJ6dI9QCGsnzUGElQDLbwS3x7Xsj4WHtBX+tCl0i+a4lKlJR5DvyX4mGs0dIaParjY7UdGSiumnpCBBhuraJXC5YGpHXAsGXMHdCyOgyQRW1r2038xQrgHY/wBUMIeJtHCKeJfdYdNHBzdxcjCBWKrpzFcBktavdullQvB1cTdgrd8QmW1CCisl7hFZFlKc6dZTfXx2wc+YzPStYMrr7lpu/wBww2tLX5puC2yEnufzBYxfHVUz7NQWWz+hXyFwgXwmjf4VFUYJsGK8xgJTABTeHmYfYloHlvpEQAcg/UAYMGlRofubuLHCmF+XPtKQAHvNPzDqBSfBEzuiWnmCaNcDZXwEUkTgFvq02xjZbxY1sOHedJYsVY6wBKE6Be4xUDyR3q44QNE4TokeVocJeesC+MbPEJjbBxhXY/plwA6XbArvBFAWFu37jKK4dJwl1v7XHsC21fMTmTooliWWaK5lGG9Inc8yVY+SEKLu8VEgNFBWKCLEUikuc3AyAcaP8BqC5vzAriveLQdIBJaN3tUTlxsS4+3y64wxC0vZpIu3EoQOpWH2iXsCqFEBejwQ5f7wxX3JNqQ01BQmwOt6jucd48VBFmhAGt6JuzR5eOYiKPkIyoGCi8TtVRKUUyyc2WkVsFkLsbMmJghC8EyZ4HE2hpdw5ETry7ROhZHgPwYR29Oh3j8QXU+yrT9hEqCYBrH/AGMMlSTPHfCQHBVvs3OTS/H6EUKpS6A4Sw0TgRWq+iIgEpl8lA+5BOaodjhKJgR6G34QjN5ZbDlPNqQqTV28o/qOGEZ1jPc/ManZtKFasdDccOJkvIAHwIQvxqMD3XTocwc0gMDXCaTyTHHMW4IkiLwBa+IHBbvDpx6/MawDzUhuYIE9n9TJDy4PzFkhSq2i6xUfoK3nJ1rx2jBdinI1dcEQ1NJhvhfe9RSAUCgxuHsJTNhxpf3LLn2DjXMMllUIcsiWXLeNFN51urUQ81pGvBS+hK1xNHA9osVLSjsdYB6LK60guMtMbBFcYl5+5MUZ6TeCr+6lk3K5VW4DIHl8EtkmUV94xnUToP5MN2h2oIpNHFMVhejKOH5TaV7Xb9Q8nuiOR7QXVo4ahPsvwzZ7nHvH7eGEqABXHo9AF5jRt7HePHixDAbdwDlriHOGLPnBbF8XufYQalY95SAiblM5G8j0iSOwOl7EFr4V/JBaMLER5GuhB19AlPGxenSWZUMbv+uIb0y0D5NL8QOsaAA4/NMuxyuwHK83iLItjhyHrHl3EJEFvV2Pkg21tM5NHSqq4Z3WWgongLfMO0Mszk4HUb+o0OiOsDje9sZYMsrqeQhB+O81YHrko+JbyUhpRVfITz8oFUuG8y5Ea/YN/gPaWWbbNbBD/pKZs1LJt1DfEU4G45t/ugRjdFey/Mry8cNQjpJwOU2tEHk8BMnvpxkyNc0RiUmZuhEozbGzU17BsZbJ4WPhNAodKDqa6QLHJ/2gF5dCDmB6ASicf7jqClc1OG93zCli4BApwvWU8nqyywr2jwa1OqfO4KcCgJVdYiBQ0jhIi5jQ4tLqvNyikjRoAYX4mebEfN3T2qWGGi3+JWChxUIuRs80GNEf7qEEhUlEcqxC4gdIhBQ2K1RKrXqsPzFDg5UPzA7Pn1804fiMuMa4q/FzenoJaJTDpe8Tkb4ijCVGEC22PZhIwU33jLKSu8DvLnZpsauz2mPHSikVKvVyl3AXqwgw6gdVocEH5zEt6g76H+Y8kwh3Z+iStCNi7RinvklITkuMU77osLycMRVGF7mYZ0MJ8MAVrr7mt+GJCop7qo/Uulgiq3ig7wMWwqp5N+GEZw6DAWJiW/ItVDhRyDKQgOW6oALh0VOdVhiGnx5EtgBrlAWHNYZhq00wdfnqcwSqCAqXC1ikKJWNNnZDvc7aX1ciYfJmXC4KKN3T1u4FpCkBTfWNrdy3L8OyAFCvWLhZ2YL+tqreh1Yr8c03ce+0GAC1ZbVqU8Cr/M8EGtPjk5U7naG5Jgsyy+Fg0RQBlU1Qbh2XIpLVwuLh6a9gpdIfBWbyr+Yu/r1lIC0BdXa6iKAQVy19O8ScDWL5ae2IgoyzjAMBwSw1YvJR+SKYNBZzuEzB2hZZ41broNTC6A+Ft9xjYgMlA5V6VPxFGpgEOKLCd5fBQN1/mLQSG5cNOJj/AHsoPqEvipd04djkfM6V8KBgg4U/JGF33rJX9SExegkLKVzW5e0N6GfliLNPmLlC6b1BVGv0d6c4MCRVcvAV0gF6qP2sEbFjzmLgQ6P8LjyApQPI5JSLrL+GIu2iOGHTDUW1fHoRIVMEy/v0wMnn8Mu9pex5jY45Ra4rqOkbhdGROnGofpOkLUiisom5SnLW93K2qCO4YQ1Wou5jM1QO1pbG04NpnTgfZX7m6Bg2DBbnLxAFSGywatQQd73VP5hyYBgZa0Dkgs6JY0HK4i5Bm3ydWjmV0CN58GrvUvYF62/U/BZ/qAFAsYE/NS/InkqKM2Wg0wXKu4tk6VAzIuol8Ix9ZiLEVgunVwUJsog5YZsggmU6wHOLH3F+tylt21kp8C+Ya3Ubq6+C8EUsYNpXLXQhjqfU3Kz7pgXLGx1jw9TmAN7aK9pzwI0b2ks0WBXVmnud4KN6gtcUL7MxQaa/oR6J7zPzCAM62fxKYOKL4XCa3heP9E7qKvgJiDkpVJeLfaWg2vrEQt3WallTYtWNmYiAbVXh0iiByVvIWnYgbodI33WUDoQEFClL62iv+tlFB2yi69pb6vj8S3rFjFG7ZKuEBiYFQfBDajTlSuJjyTge9Cb1Ok9muuiG4ncqLAEBVXQHeFw3DoTqcQeIpHGGZNS4LAhXi0u68RUhlWae4Yi06rWndgk6tfwwGuu7OpuoPh0RLKZ4BUqWQ6TI+IMWVctQjzcdEwLr0ZYoUmvaNVuW6T8Mr2GekuRWz3hsDyL0pf1BpLF7WpvnFXDwLXORp9xcNFA2MAOqjiKNW0HYFekbuEGJGKPIurEiib6EoIVavpiMDsqK0ilrpca0taWRqx4h/GoHplZ0RuBky0o2fklM4XcEdqUDpCOg4OuvMvvNBp8GW/AD8kOWnz9ED+YYN0LLvNWw41Nx0M8/ySmUP+FtLYilW66jCLrwPEFbjxAYidoPwH3Fq1wqzz/A6do7W3JTHATy0TDOq1yuTuij4GC0tafuFlUaarkvgriHASowg7/AQlGoBv8AjcSijeuZMPdHCc7lb5G67p6MD2unYN8zc6CqopeveXaZkueBEY5hYQblyAWbPde7tLhLr+xjeW0eXUpHQInB37H+00nNW12jwStryv1cfC0obQh38jFU3iKm70a5D7hr+9lD8mCCOEiCZmbq8SjtDvUJYv3I8DDVWcxRyri+kJcCZvCFi2u0KlCyGuYJsIIXT4hQj6DBjplF6SU2A9kKsiZlRhARsitgiESsv5n2vwYK3sCAA6LIpCsBAHRqGZsFezeSNghA3C1Vc9bjGAVBR6AjmZYYIcoRzTobdQSRV0BuyVg4M032oxLlutQg7FLeq/zGqlNNeGoUdqTKHTW/iKKQSrwcPVEQxZmB2evHYgSKk1BoB3hTEvDSDkWMF9zcBAEqCzzm7VvUV7cmOSnjdy0MokoaHHWq33lgOM+zZ+5TLddx4TuS7Yo6KYD3OSZZcqlDbhq7jz0BFR5HnwxpmC0g9G9dkgDiQhR0Vy+Za1oKNjkHNwf/AHQqT1PzLZvvX32fcXALhsr2H6ajMQ6Mt16DzKf6bQdnh5i8QhoDtzq9QdBy6OhSsHmGCgc4q744ipb2JjpkIwVzk4PZuWVF7Cg4RuaQD7cyjUToUfcTkLIAdg2kS2Kd+IyhPF0NG6igS3k/iuUn0x0K9nVw1CVAKSvAYlx+JTVLaRv2hSWDwtT4R6lH7ROB8R6vW7OjlckRSFU6FsSSknQN6rxDx3j5YiILDQ3KBCbRXH7n6DD9QaZXXV4TOusGsC6Do/DpD/a5iEmiyajdydBQ4N9ZiAe1f5j7zAKN6Eq+kqJeytjkF7h83wAVuVVVRKq20wanesor4jO3MQMoS10mTpxuiGs0vDce9/Uwwamgvi6M4iRJhhFo9S+WXOMJ8sC1f1TP6HyzI8y9/jfBf8wMoWS4XnW4wckCLBdXjIeZWUITBCJruMwm3ossOkQDuOgBwHA4IJucAgHlX+JSuTRKWs33BeldXgfuA7ogqvoSYIiZYIObYy1K2riKGG8eUQ2Jpm1LhMh4lCxUrLQuk1jrFmCkliFqC4LzALVyGqwPmIMVb2H9EAgFd4g09mNxVgUUtdW6cQwJAx1EcDNNYxuNtlKkgaaXlHjtKa6QgppqnPeNFKdQV3VRLg8KHcIIxwaC+QrYMfSModKt5v7UuAFDQXXdeOm5egK61jhDAYYa1MRaowK6HErhHLVCZk1WOKO7iWgDApX1U0w1VD+7mJRAWtJFXhHDR9BBZMFchitN3qYy0J7p7+0QFYKb/wBPeXngd/i3qMoCiKcPYODDJZS8p3QZ9Q5NlfCVvqqKql66rCbxFDhWjctxiTnhj1q4Ai+H4h1mtxe2QU/cvRQEoHXlZqOrRSgdiv3Gpio9gHHAv4n9E6Qxg6jWdPxJ/Z9Yuq2viSqrE5rrTY5W7304iEUUw0uJ0yq9uDoQE62fEU3G0cBiMOTtEjFxfGOhNSHhAYwwRwNEvS2uzGsacDtuMhLIQx9P9d5lGuu35ZgvT9JdxFNChzola8zPdsqQmsDqxwLy4Jd4rPzAC4wVrB5hLv75TNa6/meMNJo8Oqv8LOe0N5P1jFkASOhaPvTEjz0mAZS+tIOWuYeqg/ghHFtvXNU98e0pJgJYt4F9VCXVBeiZUtWHWJFYtpu9+R+mYKKZcINiV9xwLkVoYt1g57vBOOGIySZWs4d4M7AKAq06dtX7QNSG/QToUq4cx4aNKlfjJ8R9RRq0BoPao4MXKilq2mrcwoZmcIq0ZrvBIq2wAFtdPdM/UKeE9A6uD5iz7QbKOemeVY1PmkChgA5joCbMW3prMcpF4Cg8EWKU5RcxjIwrJm9xuyUxgCMLUwEaRuXJGFAq17/mVwidShWvqUipYq8X1jkCsqsoL0VHb5bmyw8rE7kOTuK4lxdSy7dFcGB6CrKp0Wb7wgFaFUJKzmjHvEWBhQrXoqa9pfWAtWmKq3NS7Cv36C8fUoWAHRcV8kFm/vURjPEMsq09m47XX8iVWaz+I0lZju6lAc4A9oxYVahRyQ170YYBs3Kx1L6jQCqFBzAAhWbS32i/Li4LwPqEl8EY6h8MKh2aj0KhVviFMWKvyss/o1OuR+DiczdVnrLyWrH4lXM6d4VGhQ0UMg9IXWiXVYHR4iWf0xMvHX8wM4lknPDhCF+WYrU96P7kQqZT82ELwvtdTEUECiLOpxBfiQNB/pNcRk2AU62ErAUbuKHwGiKY4h6Ol1794nGvBVrkf1D4cHDAAI1+WMCo0ctWOYc0yV8g1ddJnlCPLIu+CxWvdvvyTTxFM+7+oayGdZ8gyif2dL7AQGM3gbDBhzibw85eaB0efiPaArRUHNt2rtYoN6AyxihcD1bA4XQeCLUoQNFi09YWLlVY+xthrSJSh4q+tweAlHUAHioGiIK59zxzLx6KEa1Wt9Id8BS4R5LluYsvkjFvLLq/Ees0RjbBJBY9YGcKseSHqPBvHniWlipo7ivkNRYqSgYYvC8vxFAywApL6n7IzYk8ZF7ksjWjRKq6kLYuoGwby5z1lRJbkbMqcOojQ1o4Rs2McMkoVAgs8h+Jkn97REoar9IlWsxzmBmFcr+gglHbZ8S6AA4IJXTMcHKmpgMfFxjbBTmAMJXhEOWUwpt/3L0zbF70+onKcW82d05EAPIXLpQShVZn/B/zAKvnKWfmUscsxxzGoMHlNvt+ER9LyX3gW0eFxsUnZSkmoe8BQc9ggFlKS222hrvH7LXL91kQF/0Iacbiy4FgFPF2yGNCUr2hp+onX72CjC8WeTMQeB+BuXwmEqBa28SlWOZbT3NbXgb4uJGBqVdk4txzG9nhTY+sDAjLhJ1Y1Hd6uQrduOd8RPIRXJQY7dJeNgRloKri63ccQrGWrZ7Q0DoOl325i2c0ssTPS7mF0CcujwlwaIky12rTUP0sUvYznpC4cIgRNmAuODVXyHl4/SOy+uX8v1GfaMY3XNHxCOtaKchuELZf22uBrrCAC5dGKFwHYgBFByHPd/iHMzXfh7RwlQxSb8n8SipXWy8JOY6y04hktqXFOmWa+34j4si6bqEB+lKH6Y8Vc0eOGNaUNiUHe9rEEtrAusHqfuIwBQwA1a0cRYOeTyv7m9DRrT4TBDPZsnF1qz6GE8BKzk3hv5lGLlM+7+aEY01Wm+owhe2A9+ExBZWGPiVqx9qCGYg+HfEpmyzYLw8Yh4RDS94jLql4kS5olSh04X7Syqqq2ruckH16j06KD5CVuAwOo5+omDv4PZh6WjRMvHT8ESAV5um5VxqWaG6j12q4b4hPDHqs8F0RuZFoFlcLKFeP0R7GBhDQ27qAKWVne7Q4gsHkFr36zRAF6oD9kyWeWiEv3GrWc1gUHnMcqdj+kVVdhjGFuPuV+Zfg1H0lCj7ZftmMo9HB17O7mAkyqw7nHV5ikQqjIeh/UH+rsKB9BhuoEWEoqAtS8isykhQfXf1AmNnAHxBMA8BXYde3SMX1OB0ep2YAuR2NvIO/SBwzkv2DMF2hSvhtogGD2xb6lKjxAu2zDQmQNkMA6Ve9+0feTDo79vMcQ4TdsvrCDAoAoJdTqfg4h/q6ShOiYJGgESxlourye3klKy/A2VWEhAgrs7JePcKU3bAllIdWBZSEWNOF6cUyuld02dKj8zJ7AhmtW3Dq2gig8XD6snbf8JavQ9i/EujrBYfxBFRBYMrtWiUvhFRkg3FkieIhAyeZW6Gmm0dRcM1wnJmg2UdZnqWE0t3mHehVZ1ljXMV1p1IbMq1npGyihUTGuYlVYrDrHJDgERW+sKXN55+Iw0YFKzftGm0CChKdhO9ywZWTk9r1CRoAr4EPgCdo/tqWnfcALpoxfo7UHomsXZbxUPdttIQvowCDEwQpxwsMzcSXSstB2h1saCgert2hDKjIFe6ahqJErbzbohMnBl7qgbAVbdgN3L6IBV1WWsyxQ7RANhtL6RfRTtVZZT/h3NxsKjQy9fiO2VkM11OsSEBFuyCqxCDAWmh5GWcAwXK5OIq3ugc1pZ5l7IGnM2+oWQWVLzMlE47XejD13MEV0WbFK6y8aere7GKYKuLohZjsnGBpq8tVEm0XAG2A6iU5Ms4qE4RSG3wAXLL8i/2hh9UMGOtJUGbyVNHlqC1BGCXB0uPAYKGUc/6iitmTyZJQEMIPzGpOfkK/UX3PwlLra+4LZxGMWW3zGwaAzFSgPAd5RYpidwummCi8CnEoO1EYBUS7J3fW8SuwBoORt9RrbY6Ksad0ynFUik2V8dSMuNHVETJtu45Vo0jX29Y1NJy/tGgZWN2S7UVZYxd8ZhBCl+Umb4q0Vor7dodrSvnQmXgrRCYBQgzQl/MoMjm3ThlwUITgnT34jLram/LAXgtiZoQ0YMlwU1ZUVFOo0YjsoqijZx6EYiniXEQpER6JACQ5xhorEV2azwSpwWbiD2jLdgrtUUbRsHcwbzFDHYf7EtA2pFTP4jHFegBu+HT5lfdA6KAR0Q8jgzp21KS5nUAEr5Zc6TDeH5hCRFo6qXRXSLjAB9ofrILVtEpON50HbKcD2IaPohiPohfpLqXm2AwKuuEuMAOQwqopwfuPPE1cUWtXrEQtlLFJcJWCnpG+Dg5FXrr04rUPB/UTXjvhihQM3COejFlurcVLdsUEEZKOMs1yHBTALRKX7KZ8LmsA6Kct7ig0S+ybK+4uqmYcgLpDULiNHwaxBZ0ALu2Gcpa92k9xlRogOHkeCP0a1FXysGnEC0uQ1sac+0qAwu9HN8N2fEHrilW6lA/Eci3WWtC0q1vgixtNl6tKQLLx1Jfa3LRrRRa6uo9tsHm3hYF3rVjK+f0zWi8J8txWuy1nUJWeoj1DKFAGl7dGtwawHY0xG1yqrNxbGM4szkhApWrbedRksIO8N9rhGylEw7KK0JXM3TXYbOgy6lcrfxCAm/NmZ1BlAQfBkO8fg9heK3b8kNnhzOAAdVgBBIgIJpsLvGZRtKmy14MMzO3pgPfEQKjUZo5z7c6iCq1V9JXtB0BjldWKpjzsHXuxqCwYspoOO8GijTH0NxZbVf4LavWIrJTa5IHcSZ5gFBwEvPonikSrNWhqBl1o0P0wKFQR0u4YWf8AjKnNYfIxYzOH5EPkRGQ8y/XZavFxR1AdsA94U0ZC7pX0StHAOTr4PSvPiECq13iib7AG1hU3Ra9JUSwFVd3eoMgaspPCVKsSwKW+al81QJU4/criaFt0xkub5ljQQjgCdIXODLdo4hiq8xIiFpmX7ZbeO0WiBxVzfpflUHbgyehM3AKvFc3AhDDsFka4Y/z7QtKy7R8S9QnAVDCIY6hgFILrYYSlgO+1mQnhRUeMD4wzL7AKMmjEMURA24tvpzXaPklQgUXuWVjrFCVFqrfqXTDEq42f2gpStCdeYHIsWCBFyhcWOUAsjkDdF5xAFOQ3qKeXtE3mAq24roMJgC1WB1/hAKOarQfolDiA2HwP+pgMAU6xxLFupkJunBnEfY4gVG7dFQphHby+Dip0ygiAt4FvBrG+0qZiQTQWrTjH+FXoBwUr1uJahXSDR6Ef81LVA88Sg6ZVMF9+b9OJYTljV7lEn7Z8PTMcMFE1nwt67SxqQu7D5hFUYCfdZqUIIWKlVoqrOkqJmGC0qC5bljNP8J6hzag64H5YczkbYd+zocxHRbuFW/FEJSuxCjBqu8aaAYFKaLlSOiEFODTXaEbfIjbABGgxdG1hQ1guWPk5jlxoKtYD3YRgJS7EUPzM3PvMmrVeL2lglrbsnF0HXrAoBIIW3xmtwp5SKrFLGJznftM9WBR9oSCNcp4Ce8WgLWm1rmvEoctKuq3NoA0iZ34RvsuRsAZ3UubpPDB+SXUQVpvV4xcULyO3+kLv0FmX4mqsCBASitUsuAOqx5tRbMoEbbE6VBqFJ4NDiw5gyhLBA25OsKF1ee8q4F6UuC5WU6g4HWdwAJnLIaDq/iDFa8aaW6XepUahk3R2d+0tgful/MshPfUe3Y4hX2G051+olDZejggCwAlHdmDsFbtWFvUMjY8QmJng4I8WbSIcFc9Or1XLzNYeYuZwg4Zb/wA6PoQUlI3G1R2178+ouXdKrWBvpFnAbovVjOMxeKLOhVn29Uq1oHnOIwRVbVyqy4isjenNdoNrm8DNQUjmWqoaIcYCrLJ0SImbZMLNLuOGvlEHpIvjIrzH4aghAaBfzBZXklLBzUvJLYYQw94WQnQFsrrJg0rxDgFPFZ2Q7QXNcl0weh0ilKNvAR5sFsvX3p1mCaw/S1wCGkbPJMgw2+KUnz6DGA7sFZHQmAEuY25x9x1W0D4IKFKFOoK61qAShFjsFsHwQy2gTkLZ5hryy+pnde1XEouZhaB0G66RPgyDZqD4MwU2MeRtqLKLxQ1+JWUWmDTT/qJ8CoB0OM98RAZBV5qEyuD45YajhueW4l0FuL6lPzHWw7M8KeutyriLmPlgUbU7p4mjxq2vfq9GZiqGuWufmNHR4AUV/qYzbMgb4oUuNlNm0lUZ0LmZCIhtoxe6y7gpVFaA6A0RmjB04H3KBg9LH8R79C2TiEHpT0piZdv8QGommPY9CMI4YYQfShPRTgeWVrXH5hCr/BVFkAGKx8a1CyYA7oai2tqYKA0Q58xTGBkbE8wQqS9KusPPZw1TyRtlSiMAe8fUqDksPvBDAeopmivOfiYkm6/EdrmM1D4GYA8G9RVJAN67ZwMOh0aRtcV6HUq4acFJ9Qg6UHciAAq6DLCK03QUaavowR7LBxa0+JkEeI9bqY2YB8FSvmCckLU/EHtF8H8ImlizhXjEWb+SUQkOex8SmR7FIj2oiRctAX6Z7SYzxziNlA7tUCoF79wULnxUaEWYXGXj6glXLyzXZ2jitijvGpgJRyWlkG4GgHUUsdLgBl7Wrb0I8IJv1hq4IUBswEFF4sZQDpT0Gr8RZfEZmmBSlac/6m0tq5Yoy/8ACwkM3LCDJvvMV5/yyCLw9ThnPocNnK+AbJVwW7ceR9blLpfUhj3i2dA+YYh2Sso0Lx1NeplFMbBul0HWXQsZUV6IxztlCL2yEa4FEQp94lRXIpfmpRSrWGMzbWtow+4kyhllt1XcCdOeX2JFKKNbj/EKdBsG0OOkDROtzQpijzDbc/ENRl4KFXB+MtNYGRiVV6OyGhYiIob3zOQsC9ahZtl7g19RBOAM5hUQdT3QSs57exKOEeu+57Cs97gkGphlHdY+IgdOtC7GTYyisYtacZtXL4IcWYpaVrIvryS07BawJ3pV8TAEGyrOW05uBhFhZh2NwyIBq0AwZNDcwo7BK4VV8Sh8286GF+6KiiAIB6GMwyy7aWOeh17y+AkWtjTBLdYxd2cbjkTQFDEIAZDgCU9m5YV6RlI1DGNpR4zi4tsSoWKXhzUVWzBeta9GbRm10RLPjFH00epQDa5e0zXaMbHJKZ5j68XgD1rn1EGhKRVHAr8xmeMBh92aFtNn8RUBVrf+qMcHuo2gO67Ck5AZ/TNqkI2aXstysohy00ou8nGYBj2qH5g9EDqsaq1Z4J1l7HfT/aH/ADG85loRV5adG9wblu9lxyy3ZwhKtDH9MZuGgH7lOJSs7vpXWKqg8sR1OhAZdENFnvMWsPhNgSLy5mYR5SkQuvylqFBBQtLnqOh71CCnkW19hcOQNzjNQ5KlPriv3L7WrQcqhmiZjABHJZ7MfId6gmm75qapkRrPPZUxIlsVDwmTxHcK6AXvO/1E1UvVrLjcEzkLXbxb0JWxKALZdXqLWwR6XlYoQWehyrRH4joH4EV6WJf3EXqQYakNWm1D5lxmKwQy+0IaEVdbgy36oMtVElLdmeCtLD6UtnJHq54pgMtvRXfMrpAy6M79pl0plqr+vaJ8n3rabAeRI7llARFQDkwzbH9SKWq64R15lVLYEs8rcDHOmQ7phl4BZGUG2+kcpwWlfzG0NpNj6ChbnUX0ClIoAtfEXlVu6/W4iNJSeiIAVWgOYQCnNCx59LVdG218oY9qUsP9wVUMhb4csGD6X6KvIQcoQsuASqjPaUc3zDwo+0CGp2gUcQkbztjzCSWEwgT+oJ3nwRDl+CCNFvGCHdwqhvEZcGxfZhgb35lmRXSj+IM2IGr45iKkJd04XBtC8CAQgoBAe1wOpX17VWA32CFEBlTt2EX7gWpowE7ZMwSeUAKtZAwU6jW35yh8ObrDJ4JcCHBHJ73Knq4fz7xIljKW6oMNqfbE1qGgYPiWTJgQWPlinHEwHcGgxWJme98ywqJQjDjr7QGlVZQfG4+vNTht6v4I2vSeLTsfUACfE/mLKKntgYw1pMldZx4m5ciFLdB94EgAHKtRuAzIML3IstyBYjSMGhOUZSi4cTWoWiZKqHm7Yq1/MD1CtIfEYEqsEPnmZ/GgnJt+Y3g0iW68w1XSRQhbqrNmY/CfImK9plklcrMoERvNdSUOoKFWWfs94rTFQMgA8EV+YLSy0rJ2Jr3rAZHUqKFBwlMuZaD4AAteblMvTmBNVCOTTjrE4VwKfuPNcFbqGJ+yyoiWC3i5gQQHNEoK2D2EZbAr7CH+Fz7ksd4fmZf0MwUNbb5m1swBarwRWgaFow2SY6RW6kJ0aL6XLIrxMGpXxCWNiebqfK/ePyirFZfWrqHmTQr+5d/rEB/GUf6R/sTyPiAslKfd/MqQoAcl24oqI6M/pWd18sHNvlgO1dr0JlhKtzGZuuJfwa6LiP2n3Snn8xe7e8xHVNLSK/3fmAbH2H3KDlOhiKYE9orV/HoiauamGr9R2kVvZZ5J3wxCaa0bDb3SD5fZlYkTIliQoLtsH9MXXgoRERfMENivDDbSdErFRqJMG41xZXHeBKJUOwK7pD8QTeSN0srI9Ri4B3mA7HzERWIWhVuhWKMZYUMOmYaYd5WV7QXYoAYW146xBKQHaUIM9cW+YNPyJ1GFxjIFWGsLD0GISkGLL2Qi2yAzq5QElo7YCGVoo9RaSJnSWMKsL5lDEZwAVlycZqpTB/hfp9qV/q5lh9fzQn9ZiGIFNTt1ofAVR1zDOurCWQowYaeFYl6BD6FXeC5l7IGZGFXo4ilXkuQ6/uZEgN4DsVK+BleaSWUBW6GS+wQ4Q8bXqvKzCnY1k4VwkcW1j1tv3ix6H0fJY7wcNdIsTbIXWtbjcGuxberFly4MCDYT1AK+LgwY3WZZxcKwOw8rFixhCLWkfeJK9B6EzxSQOuCpHIB5gGMtGrj5OSEBjbl2iEqaSrz79V29wXEKoKoJFzmIeA8V5jRgRUBN34l9VChLWZlPB0J0DrtLW6xAQiL0cXM4yJzQF15YQxywxpuAcUxvWUHaibBosM6E5fAP5g6DUmh0u3iIU3qI6migtnV0VEQuAnLRKtLV9EX9xIE2BBeKbLqJBAbtqNBXEp5dVpymf1SdJ46wVylNKdx3/jXF8ksMoBR/SoGoVAzQ5N7mwXfkesMoiWwp0yO4lmLGF6oW5jiK5PmC+yUYVEWuVIpRlhLBAq7+3TMAxkB3KP0xVILo3Z2llMaUyHNFHvFf3Gi4Z3pe0bFAiKI7Ewj6VF9Kl7YHBFiy4MuINbXyKLiLLi+gdLF4g1VzfB0j+wFCK7hKRh/VwdrxT3JcH0aOMDqGR71UIAABQHBGIdPwIS3X87Fly4cARyBgp1pMxIAAtWJqE2HQNRUQHvCmcGxwBbgEGyr2ObiDzLXNNn3HyGy1V6svUobUBhnENQXDeim+zDjukWGvMGUORXO1cRWyknlY0EyrmzB9RYDYZlJmTHvn8QnxF7bWwRnKwUoHMUrXY9OY/jArAVdBlY1PNHQvbMzAzDwpocreT4jwAADtfQDdolT4/wAbi+aYdLKQp+CALV7dkKiLQVTbnuRhkvmPcL5YF4+8CGJDSTKAXpGzEQpvaAguusv+/eGGSW7NaeIwAWX+niO0cGrhVBV2qU37+gwsGaTti5eJcuDLgLvR+kl4IsuLFKSIWMmH73EogOViyAYHVjX1Lg+gulFbuNw7WRZAPnmdbgZK23LH7vzF9VlPaweEgmxW763ZjG7XvL2vuXvBHlFOwHJ7kISE1S8yoMGByhaVIZvcVJ0ufZjvzzM942WNDpWcneD0l7RbipdkVwlrBQfMeWbvMv6S4S7U7Q4i+UaUs9wnJ9J7INzATwnQZa/8tXmIJRVfsv8AMXdZe7FEaeI93w1GLRb2glWkDbCYTHeVXMuHWoILhsSyCW2znRXWOIs2PqcYf9HRgTTcBbCsXB/xkwYeMBGGFlwZR4sLLxLlwYMFp2P2wcRfRigWIVu2eyTNixyuPdjhFVtVtV5fQYPpJV4h+KF8yXCMWLF3fmPxfM8/uIHxGEDcWlOWaU/Ey8U4tWvmNUBDk9o9eIBFxZe8qkX0GpN2bvMPwlEO30xrAxAYLV5eA+ZaXWbriyPolhqKHl/lq8xf0dYuT+lzMwGeqDz901mi8rPuPKcmisNtwOkz1mJhwqLS/tLdL7v4lWC4CpVeCXJf09IY3f8AUVH+ty4sv0JU95vF9bhCZB2PuOMdPS4wY/6HM0P6wy/UYMzPKZkeKj+Z9Lixmn0AwEUemXV+8yHvDagrU/SLGL7QY8TmP5TdmzCMBh6tGZkR1N4f46PMXwRfnPzBrt4FLqAAruLlQWnPMoCuhn68SjZYUCPOuko/8z8R6ZhypzfJEN0w7NbmvKHXhzchY/1uDFly4MA5UrLl+gwntaiMMLlxYM/ousxj/wApfpcGDKh4Y7b3PxFl5ZcuMZQfDFhGTMHshYTmJR8yiNBKCKqTX1OtQLNQoY7g4haCmOvQA3L7y8zb/LR5m3g/mP3n5juC86+JzXnrKA1tYznBuAg4DT/cRcW4bF3/AMjogRtq3viHJfRQYY54gX27LHtOt6bL4rMC/wC/MYT+lzc7I1DpCjiPrCdOEB8PiPRiM7c7c7cOnCgs5xK1HYldE7EOnNA4xp5/yyuiZ6TML6TwZUz3jEMfyMuWxYrHj7+mZa5XUxgsxFgtTBcVdxwQ05IZmHEWJbUeI2iMvEH0sg9Hv6PWFsplMzKYDV2bid2H2E0gWb1V9MTqiM2r16dY+BtVhZXwRIic5BzMNyHDiVi4tYcwRvM2+6/zOWdGfEHQDQdiOyf1mGk/tcbaYY3YFihaAgOkJWLiNrxUIUgISBAdIy1buWp1YPrhOgxI6qbq/v8AwhJER7sItFwVXq+gSHIZCqEQjOfSRfCLbjFJ3Itkd+g+hiz/AMHUJnrMzMzBYLU+ghEXwQuvJDLxbzGkwKNdSCpkvVww4qrO2F4ZHWYEbQ7nkPicODrxZtT5zO5PHAek8EO1OwTtkC4J2CHTJ2CHTQ6aLtVe8w1+UX/1P7XAwdZDmcerne/M7yd5OwwfDO+hNiyPQY92eWB9Y1c/EW8x6DPNH0CkpAIhuMggYFGyAwSUlJZLJZMS/wDBh/kT6CUlcRMoK7Q4gg1QX3suUGzg64yW4jml1Yr9d4yKwmTZZyS+pesIcV5i+l8SzXmj5IEyZcD2/wAD/G5f/wAl/wD4DCXLl+pKEejFMfSG1U7ExV+M/qIE2C+tTRZa7TDr8IZTPZBYWESusv8A87l+ly/W5cuX6XL/AMr/APwGBKlSpUqEf/Fh/wDHcuX/APksP8H0I/4P+LqEP/2v/8QAKBEBAAICAQMDBAMBAQAAAAAAAQARITFBUWFxEIGRobHB8CDR4TDx/9oACAECAQE/EGw0XEYdV95YZXQRUDj+B/xNevEYa9UJBhlRIuYTaGWVK/mbjdMuC+F+8Qt/4miV6BiCoaPWomIa9NxFEq8S9QK9B9FY8Rc/wfULT6Kvpn0zM9JXRK6JXRBQo9B2WFOmIGnUpGGdhnYY9JjUwQgjgnMnwsHtsdSUCaSmU+jMV/J/4moECVHbxDj4gQSxOuj5YuWC8sZoRxqPtyilJgxk/khFyOVY983KITwuFqhGmsPwx0OJiyr+ZgDtLxbzKm9ShHHMWkZYezAwSpUqDDKlSpUT+eOsx1lnWWdYJ1lJWU7xKJTmKwrNW1BFPIGnpXEI2gNBjDRT94iUAVjau8vSafqiw+5tHBjs0N86/qUtbKJsHKXZBLnuRRFdnUs4TwkIhuBh2AMR2WAznjpfeX7YaVYlquQUrvqi7FDgmLsge2vtAAzO5LOsxMj1qJE9KZTKen8Lly5cuXEhXRCT3EhZwnkVlf3KSNJMj2SUZQZOSUwfK35gIofV4/CM38JQDk6w92QoUL/fEBbCByArflLdPDaUxQwbDdQSi1WsfwwNIjD7bbVQFAchQpwd4S8DTwRXNVbXCnaBq2tDXh6P8kXeKlKlem/RnaZ2mUNJEOH0r1qVCzUEgjdf0HiPPQpnS7w8aMKGq95bOXlqU91x4eO2Kv3g0sWxVF7VVw3nE2YXGuvtFLFFMC1OTN6hg26PKOXeLBvbQr5YGrRRN+3V7RBXs2g8W4DyoXddZeqvudI0Re32hUQzBVPs6zIqzQB0/wBlZGlO9WmL95hXwz5XQfh4jJjbNt+HuSnSU6RAhUN4I5biZYWLv0rwqHCy5XeWgtnsY2l2lW48GoPVg0Ke8tgj0LA3WquNJT0Iqvi9zYG7UG/mpTArUqXo3qUAWdus1X1gMc57R5Q1XY68q4hZdfaj1yYiPTe0ebaq+sN0UzEn00ytWRN38VHNhNDl6EtuuHk/z2lWE4ZP2g0uu50eSLWCg0B35IyqKaePHSUEGMB0esAWxF6IoV9ZgCUW3wMtLrSndMc/Es3WQo40nvKTHVh6X1lehA04NTXMjYb6zrBdJfo/vtPd++0VbuFttvNFSqG6gPT0pCpwfMIklIaoNgJpy2MNBEBbrbX3gb1APOX2hAmtCoYpbL2XvUsu8qslHvMezLu/JxNZsRC+M7zK1amqPpUEw+il6lSIeIPeY1F3aCVuxMVXQfmU1NJEMNGnHaWIQAabxmWDsCPKRBktDBgbFXvtgzD4tpaN+sI29FHA/wDkwW2qcPl+0Ir2prk/i5ZcjoxhvcYMsWO3EG5WHwwY6+MscVu9wGojeCU6TPAy+4lCHOBt+twa3HKYlzHv7ELUmOcQu0A7BbMqJRlw6CNZDDqRtPa/pDVJye11R7EzKlRTVCz3rXvE4jdCvsRK14GOfjtBA1vB4aiWY2eTTmEHRQA741zCylshwKc3upVSXLNusC4eaW+Ox035LgZa1CRAOVe0sZYvdXX+MWmjACgOsvbIM9L4jWhXoFxIdS2xRStdIsC1gS/KTt0NCqYg7fHkX+SCa5M7i2PrBFGjtEISaEMYh0nzLCw7CTScxQeYiD6xi4sobR+swbysrd1M2/SoOCKRQVnADVeWArbLFW+raviMaHqOdckABqNN0GXPfMQOiCNlqw7VKK/IvDbVPmNi6uut/lcMcA+ja/BDCYoPjB8xgtXU6uUPyJWAWcB8jLBfM6NAwp6LWCJ1rEPku/SHQLrDjUwMprgFOWt1BxySi9Slv1ia7hZiApGJt8Nh3YAq3barnF8RmvlqM6se9wGhDB2LxKBkxeMYbx11FiURCf1uWU1s6l+AK7dy3VvE6znzfmV/WU3uU9YSKU2XmoNksqrmNHinvGgQ4lCTrHRX+wNNxd7dwKKoFzp/qVHcmHxCVDgGP7CA7ILGS+nZjdvY23gwPzBn/BUNdPEVaJCk2F3XiMFEYXINSi4CVO7NEFoml9i8XGQJk3QXkJvU3feLZ6sdCWKLZW4lKhW3eLYOs4KSkWCq7qIWlXpofLMsKZBq/HaF6hYHqRQUsQC9JfRrAX3TEG+KrxBbG9w8NK63uFUL8xyAWuIG5nVM3AwSr03LO0ahLe0VldEqS3l0xGJTyXZ94A9pnDBGi2yvmDOqsNKHP0mQQamWJiyuYWojthefqJ1gCrFZaqYM2t2+vmXFIi2qj18cwZg52v7L17wsXnIFOy6RHQNTGLyOYpLSRXnWekEEQkTN1yY5SbejpIuRu1+CJGVq5+HvDkAFHB2294q2NrLe4qMa2B7YGEtEpum4qvAYCOJS0UsPSyVNluK5mLBq8uNcTe82uwr7soa8pmzFR5sF94QF0GYgVzBm0e0wcy823BnBlrMfY3dCfiVFiwnaUFQsAi4wdNg4HJw31jwwwA3XWIlhKal5sqvxKMAwD1rNfWWYBALjeoEpgQON8nebHABasnipmWtbjSy7tDSJ0e8xwdYQJgFw512ic0lWpXczEjtnWWuj/cvSdpCgz4gxiKWLlpzzz2g0pYtBD5WXOFVdn3iyHC8DpCURLzZvknBObC6dnvEpWGmkb8Zl7ShQw2024lmAECUDwocykFTyLiGaMFPFdoRDlB936xEBq6vvE5t2ZIMM4gt55nL5iCpR6GuYMuR4WAJ0T6xwl+lho3LrBYK+swDTVmMcmfKRjQAV4xEv3YV2sdFr/MApePzJctPITApBZfa3wQ1eIDnx37ysXSo1sBtrsbmU1S1cAajATxdRHVPJ5gXFDij+5lY8wqdB4PED2+aMvc2YBgTbpG73RLN0quQbGR8QlEAgbO9aqI0NbkHsmSHqm4rCaOVfP/iPnYfzRiUTLLI50GzedWR45JrIwDLq6/xxGE3V2D5GOIg1Y1vtKEBuHRarh4K0GEO0VF50Sm3Nw58xCPmUZNGPeEldFly8SqvS4viEBln7RfYIoCMvtcA+9WuM4uELazZDZcUOJ0FtJd/SPUssdOKi4BWLqDgR1GJrwkF0d45BhgOXfsQADHNvk6SwzFXYPrFGWTKH6ahYWtFcOcXiN1pluylE7zMhW2uTlYhEKzBKEfuYOW2HBdYPB4lPxgALVU+KhXACzLgqZUwF0hyYz4lWmXlSj6xyVMGG6xT/AFA/zABWtXLt0XUfvEYRTx537RyTZudSlK5lQ8zY6wEgLYoWACTsjN3EXTnpAOpYTsR2409UuSujWOYkK0jbwhlh5JA1rVprPX4iAw53yXxK2PQOGeWoutWFFcHfntGhiuHxfjtCsDMFYrbbuFVthOldK4l5xWTPQlJrdXjxKvSqoZcZR9oqJMNYjtE3XHBQo78RpxMIwPGdrjPEEMTlSt10bxm8QbmDEdDl/e2NacMBui4EoBe7UrQrkNU137VNXtV1XkmaKF4HiXzmild6Lx3ZwYTlsD7xJBrooVsetQY3g6AUPPWEJdBWW33idogKGoMMYPSWUdSYsBRKOsWmYvxalVK44ZU/vaGome4CDdd+kAg1jHaXbDMU6Igo1ZwhO8Huc/1COX1DrEsLCsl7fETYLCtd6m0lRtmS4almwYHyQnercT3IwswvWOosmjGCVHe1q61R3mRYtpCFdLuIM7lgM5IAxnFx1LMZdsqQaVThL0wtYKzat96xKGL2mV0lL0As90Y1AKZ0nGqjqVa3RD1BGBjFge8BBINZRcGVWemsykHEV5NbQwQA7ZYe9xENq4snD7RAqBtGHjD5i0ScIgrfGZb2ykL3JtbsYW21vaoDu6e0rpWg2WEXIq0/NS+pgMN5fOWNWC1d1iu0vVRWb1iiRBusGpj6FHgAFfEKGXBLH/yO2LkHxEAloDyQJGAKeMnE1IGOynuf5KRYQ28+iy4kTODNQbczL0sVtBi2aTDoayhLulXBgrjbxjjzOBcC2SyuUtYMWE1lg8rFGQfMGwU7sFNRvpxDwgjeY8VIXcpHC08y8qjK5PfU4SHF1DvtKIoBQurA4NxlwA5EksFccgE9o7dXKpA62AtZoq4+OVXg1iEZ10qtRIh7CxG0HC9PeVmBqiNexPO8ESmd5dJKatLkR9jjZmvzEpU7txKqXDFIhcGLuwJcQnaWwkNVVq9gjpVhlbIhHRfmZBhdhtuUgN0lreHP49TZBYRheOkwxsjLee1w5j7QFMbuMsVgb9ghGO3fMAQTTAQarhi5QMXk5h5/M8n5gQBtpqoEWDbWaxKr+dhpkOor94nkPBAePhHpfCMdUaEOs2ZCjx1gRVkXtzm1D7QkuXFTATbgV3nfc5mdQ41uHaHYWuvETq2FtVSneF1bE0lPe4hZZYdeB3lQjGxzCsvC7P8ANQtoPmZaUMjFZ7+pshatrN8OUs4FTgXAqo/TpLGa+RPxKO0vm3+oKWqXwksjCzbQXL+kB7QPQ48oEqHCBOI4NC5ZUR2Nnbr61IYcrBQ8RJcYUvPFwiteVXuwhVsMHm4VbKnP0m2aeGGU1YZznMIxaBj2iaoQoN0DcUiDoXTrkcyhwOXN38xUs1u+eah19P0xDPtCEn0NzbRllrMyQrMM4+6M/wDf9xLg3w/2+m3NAE0lmGYMB0CvWgfMPTV5h6EuziCXov1MNelXcof4hlnpAg805hCW7xsPj8w2l6JYezNu5TtsgAPEEY6q+XMrFdpo8+psnLzB8s4iTmv35luvq/2YVmGDjlBHA6J3UOqmkHbDqJ3XxNoMpGWuk7j4jQ5fEamGU9GZ6Q2XLlzN9ojLcSse01Dv2lZ9BOHxLxEnjGI4gKMMr1TJpl4eZbfVytM+82aJg6+0KWdMBd0uE4ht38TFr6R2mctw7/xP2qY1cwYF0dIf+CKQJkjMka5h1T4Yow/CYINoqhyqJMpxVTe4pyTqidwlDcUvcB1lnUmOss6zHroxlEs6xEH6oDiveCcJ8RU38II5+pHQd0IGHoHoX/AXNvUs9CxYv/B/howEPSR6LVBgQPTEGXBgy5cuD6Lly/QsuXLiy/8Al//EACkRAQACAgIBAwQCAwEBAAAAAAEAESExQVFhEHGBkaGx8MHhINHxMED/2gAIAQMBAT8QsHUsq9ETLjbA9Xf+LtnU4nPxOo7Z1OIG4Go8ypVkTMN/4kCVKwy/Qjx6jIOv4leU8QA9eI7Z16c/E4Pf0BxOGc/EOPeO2denftDZO5U1GxAySoHqQTuYoYt/4cPXEZiYmJjuNW5nDM9023DQuZGZwzqabl9uIizPMUtzL7SzuWdxFkUtiXMAP7hTClRCVKlQldoURl+r/g7/AMdmX67HvF9aXEtsD2wGYWG35FS6IXwTIB+419WcpXvFCkcwQrohVlBt6ILaRasTNIx1k0/aP+G3/lUqVLS8HFrxLdkv2QTyS6G4uCMFoTFRPZ+YWpdPMsTQzMnBMBRXMSUXDZqOojlh+KxK9g+YtW+mIcwrmOnNRXlmionS+OH8tx4tVNd0XKW6JLXBPOmaqlHES9MeplumU9f+ASv8Q+c+UaMxy0s4pywqButy1jL/AFK0uoA8D1fHUo8nCUWhLy1DRgvXuxVHThNnzAQYVxqB7lrFYRYbNvHkg1mbH4zBKgSoAHW5VVZnn5ihENJfKvrXoR6H44wZFtTueh6YmIIwxBgwZ8IPxL+Iroj62U3QXyzEQBaVZz7RqOGKTcK07SY+QRvplS6zUuvp1AuTnqCXhmLWYEaclzPxr5W7viAM00fccxzDfkzEqdgPJ3N6Fl4hpRoEEeMLM32M1jcPLPIx8odejzMcGiWcxmPo9k9sVEMwhKBTXZL9H0ImvMNl1P37h8KfMIgFXd0H1h4i1to/Eo/KTxR4qCVriO4rgzMmsS240GolTdoufxMX+5SlkeOoI0mA1iXxVLazjzCqADQ45i1cBQZ1FLiqx8jIY6SdQYAdQtTNiMBlldXkjctjxt9mNeatD9Epbt3zBVlasm3zLFCfBNoIbfpBuX6f3EHP79ZmJvD97gqGLNXUtrK7z1KIF9nExxyGfiDqXvWyINPD/EvPUZ0GveHZ0cYjhIslfDiPvav3mCuxMEXF2Uo+Zea++MFqe2ZSS1+09wmSrg3Ua93Q2y3m6oaqjERAWp6CmYai2T4pjUDaWX6rGvd0RC0I9e9QNw9o+AIHzjcqG2HxEQEeRvMpbHsZJV+4MtvDLQlnxcxp7TEnJ0QBeyMDdEpdFETgxBH61DRKO4Yy/mVa0qzv+YtZFPGZoDmzipYaatPCzcKB4aD44iHWyD8J92MK5OfaVsOO9YiLwotPD8y1gWr3xEwoUax1EustZNdwoD3SaeyZvFxTP4VLaG9Q0LEozfiZvkDd7z/yUU0HMasWnEsUZDVUPgwe0EPLo6YTJx7wOtRB/giFkyFVexHhTHv4lq5tPxqP9FLhReGype+bwZ+IdXCw51mgH1i0Ll4S6+Z9iIMfdFTJRdQRWf8AENnfxluJAtorCDdvFLiJmn4f9xe0B2eeyNZb5vuZBvhiATNdcAZuIbjUr23AKcA+dRkpx/bDP2feCh1qZtzCOA01n5lEi0TwYAcrCsbpe1wj8/SGsJiWQYqAxVrVRMVNIb4SMaQRp1USrWV1T45+stVW9N5lz8/wj1AAMa1KcqDR/UQLT7qTf4PxEUYo8Es3X0g8rMUePQ4TQrFueaIaRLXdXUt5W6Jd6P7gV81aonBw+gQ0S1FchECyFAgGINM+0A1geOJQu+YoBrHFmJfkbpKHGazXeIMWVu9DyQN8tO3yxqjuCUVzDvtZQtu4B54lxdryYRyxCNNWxpK6DZC1BPAR3YsTIFgUiZ1L5HIXvHXwCgHXcMKQQ/6jXK2Y8LMyCgBzCptUOX2gzj0xWvmWKqvkAgsAb5u4/tPxLQGFaMQS1B1i5TxGQeJVB4Yiwnm9iKZTBsglRb2lESsnfgiK+XOIuTAhHL3HRA3YFkUCg5dnn6SvEpZzo1dQbPo5gEiLFB2xENKPDUABrHx+YAGjqFnCqVSDxMCbWW9SpuDbx/Mre4gBkdj1CtWVu6+OIBSxzqyoOgLFC6jgCHIu7+YC44+hzFyt2ovZKFtOe1/8ii7wHF7iUrP4Jas7qVLDZ+9RADNHe4R10SnS+0s8vcc4B2y/QP138T9O4IWrxm5EPM8JYIveRhxAo9ogi8yOAsSvi9w4MAVgcMNiZcVuXkAqBmw5uLRqFStVTXmbQq9WwI4XWjn4id3VQ0WYPzBNJMMObXxLdymcDrG4egPLVDzBkUousLXviLlCzusumuLjaQSi0OV+IAGGlMagIZqZ1ci/0hLD7L9pYvmUXhNC0LnXsfiFUX2e0wAY6JUH9Yhm+8BLol+qqGcup/ATDDTU94msNLoPUMJvdvmoTiI0HtE1Ja6Q1jK5bghgr7HvB2upfB5jqNWe144hUlK0ECjFwKxgcv8AUKkhougosiIRarMvlt+Im1YVEbyD4gC6GTiDEVoS5kNzHxn8yrJyh10XyD5jBYrAbWXYCiiwZw8XpiPJaGGx4idBTKa17V7ETvS8TMVi1/WNA1/sgpPY/ELGmMR8lhdvBomw2gutSvOPRJVOY3Zt+CGBxXGZV2oDdqz3DDBSuLrXFwZi5jA457jSmt3GHwZ8+8xx4QsuorvjYBZnTWKEtDioAFyz0H8sLHBXDE1THtEmB7tu4WbjyTvaPFEK/gXRziOFrsx6CQDUzh4xPplZYdVUWYu7gDcMDyvmKxCGGQYxHFMXmiV4jN4Jrh9UbAbIWWyvFUI0c9yuEW73sisYtK5ruWbOSKRWMs0vVQ0joPxFbiA2IVmJ0IH45hNNTCZcmIsFreX+Imqqh1DA5XmXAAZ8eGOF1mCZ4suEwhHErRG4hg2LgK3C5fkAWNeDz3Dko4D2Od3zFQJwRLOqMEBYrVb/AEqokIEqk+Yfyl0LF0sVwDZRxE6FEhJJZZZ2TY94F8XZ9omcMHA5gsF++fxNPtBVVtdQYbCtIX8RoGHAvdcVLrvwK7qYE8nUoQFYHMVNG92X+1EpNmmQTuIBkFHd8x7HuBWXXcVtzn1rEAWFMZh7K10TUtSiEVe019IqOVYI9no0kul38wDcB5YD38QfYJQKtfSUWK8mV5phSOKWH+7lVDoMucQo0acLwQOxcvyZlhLKSoergAGqUitOCc5Z5tZzr5iHtKbywbuA2HGeI2G8dQs001MP6Qj3zK9GVKPL+4IThMBiWMVjZ1KIMBQeJsVa2CPXYzf1lA013HmLb6WevuILSxLGWZUQC7qaex8+mr3myePRMKhsLD+fpPcvLFIFtcRNFANFqeLHBUoAKGWirp1LCFM3gOKwbzMR4goG3sriUl1QyxXwiwxA+dR0cboZZvS/ELI1T6RxHLpchgMVj3gSy0bbvzGpFXw7jdUqZT0E+FxAwpejddzvBNaaYzFoJbaHVZi5Cre8MLq0oilVIV+H+5U5mJ9otsr0G05lMr0CygAKwBalAybDL34goBpbvU+n0mrBvqMbVgSuIl6o5/tiQK2q5c+zGdTcPH3lYNX75gMMciX0q4KAoC9h+UogCjTdYGJJDZ31B2hz7ylxt0azUDY0q6Y8Vcp4pXsuYsyu1Uxdyjkt8PiPNB5qFCrzLeReIroTdJzKCILBkcJSVC/Vy1eratoJaFdoprxMLFVo/qGEynZKvoALao+0CklmvSvfqAyBdRo4vi4LsS7Wj1boZdRBwtD3KuCzBZQKF8cTcWIBZAQzcUoWhkVT1UqFYWtyQpFy1l7jdhFBhb1KW3bsto/x6XPuiUIP0CPJVeYlGZgKSeaiqIPNynBfFzMX/aHIPDmX0mKWYJ/wI4Bt4NXKQQrRuuSDbr6R8f0ho05KEA5iGHSJxB9fRHTBeq/1Dd/MA0/VCDmcToCLGUT8xOETFOTtM19ZTIUgaATyPhpmcIImCikfaKqLoAKuOAvUcORnZT8jLmRHRb2ipdA0oYvuJSLCmIHRdwQvYoJtyITLFsXFOjzLTJCqxxhJegQBWuvHtM2leL3FQEAI37g9EHFerr3iUogRvALj4iOFzYX+Zk39HhjWxflB4TyiV6/3TsN9Pi7l/XFZd9Av0Kn7dxAiQCHm/RIQEzhULXv4itIAqOjlIkYmkS6Uwwcrsc2j0KlUKVQrqCQaaFV5FlrQXoBp7xAyzR0u+Kghyi4UbM2Qa1MWVtcxVGoJp2Yg6LQBvazXtGGJ4vLJuEaps+8wSEBby+CA9Rtr4vPmW3Fl67EPVuVM6OYW/IPHU6hLuP3g6Rp92UH3JVFgDmxAgdFiAG/ECVFa/SoESV9z8xAgSoCCKYZWIeB6gn7CoEqDB7yyE1h/pKM6zjMGnAQwQpcNzAfMWFwRSjLKuMWc5ytzabvrsRZ+/wCEAUvBDgyr96meU/fiLrI/T/UNx+7GA6T7k5r/AKQruY7iNhj8SY7mO5TfuQKM8THcru5IrbtSokNewfvAlTEe8qUbVMQBtEuXQvuWfWBLzKgU7g+gJbLYLLIV6gNaWHxWueo0afhMU2dxzNwfcgA1YFtQksLtWPijFgUUHTAUT2vrH9WJIWLPrC9x9544EG2GBDYtue5FmmFsqqh5Y+eIwGHVL9TbUW3E0nSSnqVA8f4vqqDBefknPv694fof7lEr96zETUUaRX+NSvSvSpUqV/8ATcNf5V/4VK/9/wD/2Q==']], ]],
+                ],
+            ],
+        ];
+
+        yield 'with assistant message' => [
+            new MessageBag(
+                Message::ofUser('Hello'),
+                Message::ofAssistant('Great to meet you. What would you like to know?'),
+                Message::ofUser('I have two dogs in my house. How many paws are in my house?'),
+            ),
+            [
+                'contents' => [
+                    ['role' => 'user', 'parts' => [['text' => 'Hello']]],
+                    ['role' => 'model', 'parts' => [['text' => 'Great to meet you. What would you like to know?']]],
+                    ['role' => 'user', 'parts' => [['text' => 'I have two dogs in my house. How many paws are in my house?']]],
+                ],
+            ],
+        ];
+
+        yield 'with system messages' => [
+            new MessageBag(
+                Message::forSystem('You are a cat. Your name is Neko.'),
+                Message::ofUser('Hello there'),
+            ),
+            [
+                'contents' => [
+                    ['role' => 'user', 'parts' => [['text' => 'Hello there']]],
+                ],
+                'system_instruction' => [
+                    'parts' => ['text' => 'You are a cat. Your name is Neko.'],
+                ],
+            ],
+        ];
+    }
+}