# How to Use Genie This tutorial helps you download and configure example code that automates preparing, converting, and using an LLM on a target device with the Genie SDK. Throughout the tutorial we will refer to this example code as the “Jupyter Notebooks” as that is how they are implemented. These code-based tutorials consist of three notebooks that must be run in order: 1. **Step 1: Preparing your model** - This notebook helps quantize your model and prepare it for execution on the target device. This uses Qualcomm’s AIMET library to do the Quantization. This is also where optimizations like [LoRA](https://www.cloudflare.com/learning/ai/what-is-lora/) are done to improve the accuracy / efficiency of your model. 2. **Step-2: Converting your model** - The second notebook takes your optimized model and uses the [QNN SDK (aka the ”AI Engine Direct SDK”)](https://www.qualcomm.com/developer/software/qualcomm-ai-engine-direct-sdk) to build it into a format that your target device can execute. 3. **Step-3: Configuring Genie and executing your model** - The final notebook shows you how to use the Genie specific settings and configuration files at runtime with your model. This tutorial currently focuses on explaining how to configure the Genie specific settings in Step-3, but it will also provide some guidance on how to complete Step-1 and Step-2 in order to have the proper files for Step-3. These files are downloadable from Qualcomm’s Package Manager (QPM). There are many different Jupyter Notebooks which can help with various use cases. Note If you run into any problems, you can ask for help in the [Developer Discord](https://discord.gg/akBfTuX2bR). ## Pre-requisites Begin the tutorial by accessing your Linux host machine. This tutorial assumes you are working on a Linux host machine (where the Jupyter Notebook code will run) with an Android target device (where your model will execute). Based on your situation you may have to modify these steps, and the tutorial will try to call out where those changes will be needed. Note If you are using a Windows machine, you can use WSL to get Linux-like syntax or adapt the commands to PowerShell syntax (ex. using an AI like ChatGPT). If you are using WSL, install the Linux version of files from QPM. You will need your host machine to be connected to your target device for running the steps in the Step-3 Notebook. If you are using a different target device than Android, you will likely need to change how you move files onto the target devices (ex. using `ssh` instead of `adb`). ## Part 1: Installing Qualcomm’s Package Manager (QPM3) Warning If you already have QPM3 installed, skip this section. We need this package manager to extract the downloaded tutorial files we will download later. 1. Open a terminal on your host machine (where you are doing your dev work). 2. Check whether you have qpm-cli installed by running: qpm-cli --help Copy to clipboard 3. If you have qpm-cli installed, skip to Part 2: Downloading the GenAI Tutorial. 4. If you do NOT have `qpm-cli` installed, [click this link](https://qpm.qualcomm.com/#/main/tools/details/QPM3) and sign into [Qualcomm Package Manager 3](https://qpm.qualcomm.com/#/main/tools/details/QPM3) on the browser. 1. If you do not have an account, you can create one by clicking “Sign up” in the bottom right corner and following the account creation steps. Warning After signing in, the site may show an error like “502 bad gateway”, the login will still be successful and you can continue to the next step. 5. Click this link after signing in to go directly to the QPM3 desktop download: [https://qpm.qualcomm.com/#/main/tools/details/QPM3](https://qpm.qualcomm.com/#/main/tools/details/QPM3) 6. Download the version of QPM3 which matches your host machine’s OS. 1. If you are using another dev machine via `ssh` or some other connection, make sure you download the version that corresponds to your connected device and you can transfer the executable file using `scp`. 7. Start QPM3 by running the QPM3 executable / downloaded file. 1. It should have a name similar to `QPM.3.0.92.3.Windows-AnyCPU.exe` if you are on Windows, with a different extension for Linux (ex. `.deb`). 8. This will open an installation wizard, follow all steps it presents to install QPM3. 1. This will also install the `qpm-cli` tool for installing packages via the CLI. 9. Wait for the installation to complete (this can take ~5-10 minutes). 10. Verify the new install was successful by running: qpm-cli --help Copy to clipboard You should see a list of options for `qpm-cli` if it was installed properly. ## Part 2: Downloading the GenAI Tutorial (GAIT) 1. Check if you have Python installed by running: python3 --version Copy to clipboard 2. If you do not have Python 3.10, you can install it by running: sudo apt-get update && sudo apt-get install python3.10 python3-distutils libpython3.10 Copy to clipboard 3. Install [Jupyter Notebook](https://jupyter.org/install) if you do not have it already by running: pip install notebook Copy to clipboard 4. Login to the QPM3 CLI by replacing <username> in the below command with your QualcommID username, then running the command: qpm-cli --login Copy to clipboard 5. Run this command to set which directory our tutorial files will live in. Note You can modify this path, but `/tmp/genie_tutorial` is a sensible default. export TUTORIAL_DIR="/tmp/genie_tutorial" Copy to clipboard 6. Create the folder by running: mkdir -p $TUTORIAL_DIR Copy to clipboard 7. Activate the license so we have permission to download the tutorial files by running: qpm-cli --license-activate Tutorial_for_Llama_3_x Copy to clipboard 8. Install the tutorial files by running: qpm-cli --install Tutorial_for_Llama_3_x --path $TUTORIAL_DIR Copy to clipboard Note You will have to confirm during the download by typing `y`. 9. Verify the files were installed properly by running: ls $TUTORIAL_DIR Copy to clipboard You should see `common` and `model` folders, along with a few other files. 10. Navigate to the newly installed files by running: cd $TUTORIAL_DIR Copy to clipboard ## Part 3: Read and run the Step-1 Notebook This Notebook helps quantize and prepare your model. This is where optimizations such as LoRA take place. It helps show how you can use AIMET to create an efficient representation of your model, with fine-tuned values. 1. Read the overall README by running: cat $TUTORIAL_DIR/model/README.md Copy to clipboard 2. Follow the instructions in that README for configurations you must do. 3. Read the README.md for Notebook 1 located at: cat $TUTORIAL_DIR/model/Step-1/README.md Copy to clipboard 4. Follow the instructions within the Step-1 README.md 1. This will help you install necessary dependencies, set up a docker container, and prepare your model for the Step-2 notebook. 2. This will also walk you through running the notebook ## Part 4: Run the Step-2 Notebook These will help you use the QNN SDK to prepare your model to be executed on a specific target device (ex. Android phone with a GPU). By the end, you should have one or more context binary files that can be used in the Step-3 Notebook to run the model on the target device. 1. Read the README for Step-2 cat $TUTORIAL_DIR/model/Step-2/host_linux/README.md Copy to clipboard 2. Follow the steps in the README for Step-2 3. Follow any instructions within the notebook file (`$TUTORIAL_DIR/Step-2/host_linux/qnn_model_compile.ipynb`) and run each frame in order. The end result should be context binaries that we will copy into the right folder for Step-3’s notebook. ## Part 5: Prepare the config file In order to run the Step-3 notebook (which contains the Genie-specific logic) we need to create several configuration files. These will tell the notebook where to find dependencies such as the QAIRT SDK, configure basic information like where to output the files, etc. 1. Check if you have `QNN_SDK_ROOT` set: echo $QNN_SDK_ROOT Copy to clipboard 2. If `QNN_SDK_ROOT` is not set: 1. This variable should have been set during the Step-1 Notebook setup, but may have been unset if you are using a new terminal. 1. If you do not know what the QAIRT SDK is, you can install it by clicking “Get Software” on [this page](https://www.qualcomm.com/developer/software/qualcomm-ai-engine-direct-sdk). 2. Navigate to `qairt//bin` (Ex. `qairt/2.22.6.240515/bin`) 3. Run `source ./envsetup.sh` to set the environment variable. 1. Note These changes will only apply to the current terminal instance. 4. Verify that `QNN_SDK_ROOT` is now set. If this does not work you can manually set the value to be the location of `` in the above path. 3. Set the folder where you want to put the outputs of running Part-2 by running: export WORKING_DIR="$TUTORIAL_DIR/working_dir" Copy to clipboard 4. Set the `BINARIES_PATH` variable and create the folder structure within your working directory by running: export BINARIES_PATH="$WORKING_DIR/artifacts/serialized_binaries" mkdir -p $BINARIES_PATH Copy to clipboard 5. Copy ALL serialized binary files from running Part-2 (ex. `weight_sharing_model_x_of_y.serialized.bin`) into your working directory by replacing `` and running the command: cp /* $BINARIES_PATH Copy to clipboard 6. See what your working directory looks like by running: tree $WORKING_DIR Copy to clipboard This should an output similar to this (with potentially a different number of serialized.bin files): /tmp/genie_tutorial/working_dir ├── artifacts │ └── serialized_binaries │ ├── weight_sharing_model_1_of_5.serialized.bin │ ├── weight_sharing_model_2_of_5.serialized.bin │ ├── weight_sharing_model_3_of_5.serialized.bin │ ├── weight_sharing_model_4_of_5.serialized.bin │ └── weight_sharing_model_5_of_5.serialized.bin 2 directories, 5 files Copy to clipboard 7. Set the target directory where you want the output artifacts from Part-3 to be saved: export TARGET_DIR="/data/local/tmp/$(whoami)/genie_tutorial" Copy to clipboard 8. Check if you have `adb` installed by running: Note This tutorial assumes you are working with Android target devices. If you are using a target device with a different OS (ex. Linux), you should use ssh instead of `adb` to connect, and may need to modify the code in the notebooks which uses `adb`. adb --help Copy to clipboard You should see many options for `adb` if it is installed. Warning If `adb` is NOT installed, you can install it by downloading the Android NDK onto your host machine. See the Setup steps for QNN Part 5 specifically for Android for more details on how to install the Android NDK. 9. Connect your target device to your host machine (ex. using a USB connection). 10. Check the device ID of your target device by running: adb devices Copy to clipboard You should see your target device and the ID. The ID will look something like *d925310.* 11. Update `` below with the device ID from your target device and run the command: export TARGET_DEVICE_ID="" Copy to clipboard 12. Run the following command which combines all the values we have set so far into a single configuration file: echo '{ "aimet_path": ".", "qnn_sdk_path": "'${QNN_SDK_ROOT}'", "export_dir": "'${WORKING_DIR}'", "target_dir": "'${TARGET_DIR}'", "device_id": "'${TARGET_DEVICE_ID}'", "adb_executable": "adb" }' > "$TUTORIAL_DIR/model/config/notebookconfig.json" Copy to clipboard Note We are hardcoding the `adb_executable` to be adb for this tutorial. We are also setting `aimet_path` to be the current directory, which is where it should be following Part-1. If you run into an aimet related error though, you may need to modify this in your `model/config/notebookconfig.json` 13. Check to see that your `notebookconfig.json` was set correctly by running: cat $TUTORIAL_DIR/model/config/notebookconfig.json Copy to clipboard You should see the values you set previously for each field in the config file. ## Part 6: Modifying the Genie config.json Next, we need to configure Genie in order for it to work with our serialized binaries. In this part of the tutorial, we will create and update a Genie JSON configuration file. Note If you are using a model other than Llama 3, you will need to use Genie’s docs to understand what each field in the config file is for in order to modify it to your situation. Keep in mind that you may need to copy files from your model (ex. tokenizer.json) into the config folder. 1. Set a variable for the path to the Genie config folder by running: export GENIE_CONFIG_FOLDER="$TUTORIAL_DIR/model/config/genie" Copy to clipboard 2. Set a variable for the path to our Genie configuration JSON file by running: export GENIE_CONFIG_FILE="$GENIE_CONFIG_FOLDER/config.json" Copy to clipboard 3. Create the Genie config file by running: touch $GENIE_CONFIG_FILE Copy to clipboard 4. Open the newly created config file, for example using `vim`: vim $GENIE_CONFIG_FILE Copy to clipboard 5. Copy the following template config file into your Genie config file: Note If you want to configure Genie differently, you can find other example configurations in the [Genie docs’ Library section](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-10/library.html#components) (by clicking into the features you are interested in seeing configurations for). { "dialog": { "version": 1, "type": "basic", "context": { "version": 1, "size": 4096, "n-vocab": 128256, "bos-token": 128000, "eos-token": 128001, "eot-token": 128009 }, "sampler": { "version": 1, "seed": 42, "temp": 0.8, "top-k": 40, "top-p": 0.95 }, "tokenizer": { "version": 1, "path": "" }, "engine": { "version": 1, "n-threads": 3, "backend": { "version": 1, "type": "QnnHtp", "QnnHtp": { "version": 1, "use-mmap": true, "spill-fill-bufsize": 0, "mmap-budget": 0, "poll": true, "pos-id-dim": 64, "cpu-mask": "0xe0", "kv-dim": 128, "rope-theta": 10000 } }, "model": { "version": 1, "type": "binary", "binary": { "version": 1, "ctx-bins": [ "" ] } }, "extensions": "htp_backend_ext_config.json" } } } Copy to clipboard 6. Update the `"tokenizer" > "path"` variable with an absolute path to your tokenizer. Note You can search for a `tokenizer.json` file by running `find . -type f -name 'tokenizer.json'`. Keep in mind that different models may have slightly different file names for their tokenizer info file. Ex. Replacing `""` with `"/tmp/usr/model/tokenizer.json"` 7. Look up the names of your context binary files by running: ls $BINARIES_PATH Copy to clipboard You should see a list of context binary file names such as: weight_sharing_model_1_of_5.serialized.bin weight_sharing_model_2_of_5.serialized.bin weight_sharing_model_3_of_5.serialized.bin weight_sharing_model_4_of_5.serialized.bin weight_sharing_model_5_of_5.serialized.bin Copy to clipboard 8. Update `"model" > "binary" > "ctx-bins"` with a list of each context binary name in a list of strings. 1. For example: "model": { "version": 1, "type": "binary", "binary": { "version": 1, "ctx-bins": [ "weight_sharing_model_1_of_5.serialized.bin", "weight_sharing_model_2_of_5.serialized.bin", "weight_sharing_model_3_of_5.serialized.bin", "weight_sharing_model_4_of_5.serialized.bin", "weight_sharing_model_5_of_5.serialized.bin" ] } } Copy to clipboard 9. We will need to update the Jupyter Notebook for Part 3 to point to our Genie configuration as part of the `genie-t2t-run` command, but we will explain how to do that later once we have opened the Part-3 Notebook. ## Part 7: Create and activate the Python virtual environment 1. Run `cd $TUTORIAL_DIR/model/Step-2/host_linux/` 2. Create a Python virtual environment: run `python -m venv venv` Warning If you receive a **Permission Denied** error, run `ls -l` and check whether venv already exists. If it already exists, you can skip to the next step. 3. Activate the virtual environment by running `. venv/bin/activate` ## Part 8: Open the notebook 1. Set the path to the Step-3 Notebook folder by running: export STEP_3_FOLDER="$TUTORIAL_DIR/model/Step-3/host_linux_target_android_without_native/" Copy to clipboard Note If you are using other tutorial notebooks, you may need to specify a different folder after `Step-3` as that folder name changes from tutorial to tutorial. In this case, the provided notebook expects to be running on a linux host, with an android target that is not using native Linux features. 2. Navigate to the Step 3 Notebook by running: cd $STEP_3_FOLDER Copy to clipboard 3. Run the following command to install all dependencies: python3 -m pip install --upgrade pip pip install -r ../../requirements.txt pip install -r requirements.txt Copy to clipboard 4. Open the Jupyter Notebook by running: jupyter notebook --ip=* --no-browser --allow-root & Copy to clipboard If this succeeds it will share multiple ways you can see / interact with the Jupyter Notebook in the terminal. 5. Pick one of the options to see the Jupyter Notebook in the browser. ## Part 9: Run the notebook 1. Once you’ve opened the URL in your browser, click on `qnn_model_execute.ipynb`. 2. You should see a Jupyter Notebook with the title “QAIRT Model Execution on Android”. 3. Search for where the Genie config file is specified, and set it to the value of your `$GENIE_CONFIG_FILE`. 1. You can run `echo $GENIE_CONFIG_FILE` in your terminal to recall what the value you set for that was. 4. In the top toolbar, click **Run > Run All Cells**. 5. Wait until the Notebook completes running before you click on anything. 1. Note The last two steps can take a long time to run, and look like they’ve failed but are executing in the background. 2. Note Click on the progress wheel in the top right corner of the toolbar (beside *Python 3 (ipykernel)*) to see which cells are still running. 6. When the Notebook is completed, scroll to the results of the final `llama3.execute.run()` command. You should see [Prompt] and [Begin] lines near the bottom of the results. ![Terminal output after llama3.execute.run() with \[Prompt\] and \[Begin\] markers.](data:image/png;base64,UklGRqiAAABXRUJQVlA4WAoAAAAsAAAAVQgAhwEASUNDUOAPAAAAAA/gYXBwbAIQAABtbnRyUkdCIFhZWiAH6QAFABUACQATADdhY3NwQVBQTAAAAABBUFBMAAAAAAAAAAAAAAAAAAAAAAAA9tYAAQAAAADTLWFwcGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFkZXNjAAABUAAAAGJkc2NtAAABtAAABLxjcHJ0AAAGcAAAACN3dHB0AAAGlAAAABRyWFlaAAAGqAAAABRnWFlaAAAGvAAAABRiWFlaAAAG0AAAABRyVFJDAAAG5AAACAxhYXJnAAAO8AAAACB2Y2d0AAAPEAAAADBuZGluAAAPQAAAAD5tbW9kAAAPgAAAACh2Y2dwAAAPqAAAADhiVFJDAAAG5AAACAxnVFJDAAAG5AAACAxhYWJnAAAO8AAAACBhYWdnAAAO8AAAACBkZXNjAAAAAAAAAAhEaXNwbGF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbWx1YwAAAAAAAAAnAAAADGhySFIAAAAUAAAB5GtvS1IAAAAMAAAB+G5iTk8AAAASAAACBGlkAAAAAAASAAACFmh1SFUAAAAUAAACKGNzQ1oAAAAWAAACPHNsU0kAAAAUAAACUmRhREsAAAAcAAACZm5sTkwAAAAWAAACgmZpRkkAAAAQAAACmGl0SVQAAAAYAAACqGVzRVMAAAAWAAACwHJvUk8AAAASAAAC1mZyQ0EAAAAWAAAC6GFyAAAAAAAUAAAC/nVrVUEAAAAcAAADEmhlSUwAAAAWAAADLnpoVFcAAAAKAAADRHZpVk4AAAAOAAADTnNrU0sAAAAWAAADXHpoQ04AAAAKAAADRHJ1UlUAAAAkAAADcmVuR0IAAAAUAAADlmZyRlIAAAAWAAADqm1zAAAAAAASAAADwGhpSU4AAAASAAAD0nRoVEgAAAAMAAAD5GNhRVMAAAAYAAAD8GVuQVUAAAAUAAADlmVzWEwAAAASAAAC1mRlREUAAAAQAAAECGVuVVMAAAASAAAEGHB0QlIAAAAYAAAEKnBsUEwAAAASAAAEQmVsR1IAAAAiAAAEVHN2U0UAAAAQAAAEdnRyVFIAAAAUAAAEhnB0UFQAAAAWAAAEmmphSlAAAAAMAAAEsABMAEMARAAgAHUAIABiAG8AagBpzuy37AAgAEwAQwBEAEYAYQByAGcAZQAtAEwAQwBEAEwAQwBEACAAVwBhAHIAbgBhAFMAegDtAG4AZQBzACAATABDAEQAQgBhAHIAZQB2AG4A/QAgAEwAQwBEAEIAYQByAHYAbgBpACAATABDAEQATABDAEQALQBmAGEAcgB2AGUAcwBrAOYAcgBtAEsAbABlAHUAcgBlAG4ALQBMAEMARABWAOQAcgBpAC0ATABDAEQATABDAEQAIABhACAAYwBvAGwAbwByAGkATABDAEQAIABhACAAYwBvAGwAbwByAEwAQwBEACAAYwBvAGwAbwByAEEAQwBMACAAYwBvAHUAbABlAHUAciAPAEwAQwBEACAGRQZEBkgGRgYpBBoEPgQ7BEwEPgRABD4EMgQ4BDkAIABMAEMARCAPAEwAQwBEACAF5gXRBeIF1QXgBdlfaYJyAEwAQwBEAEwAQwBEACAATQDgAHUARgBhAHIAZQBiAG4A/QAgAEwAQwBEBCYEMgQ1BEIEPQQ+BDkAIAQWBBoALQQ0BDgEQQQ/BDsENQQ5AEMAbwBsAG8AdQByACAATABDAEQATABDAEQAIABjAG8AdQBsAGUAdQByAFcAYQByAG4AYQAgAEwAQwBECTAJAgkXCUAJKAAgAEwAQwBEAEwAQwBEACAOKg41AEwAQwBEACAAZQBuACAAYwBvAGwAbwByAEYAYQByAGIALQBMAEMARABDAG8AbABvAHIAIABMAEMARABMAEMARAAgAEMAbwBsAG8AcgBpAGQAbwBLAG8AbABvAHIAIABMAEMARAOIA7MDxwPBA8kDvAO3ACADvwO4A8wDvQO3ACAATABDAEQARgDkAHIAZwAtAEwAQwBEAFIAZQBuAGsAbABpACAATABDAEQATABDAEQAIABhACAAYwBvAHIAZQBzMKsw6TD8AEwAQwBEdGV4dAAAAABDb3B5cmlnaHQgQXBwbGUgSW5jLiwgMjAyNQAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAg98AAD2/////u1hZWiAAAAAAAABKvwAAsTcAAAq5WFlaIAAAAAAAACg4AAARCwAAyLljdXJ2AAAAAAAABAAAAAAFAAoADwAUABkAHgAjACgALQAyADYAOwBAAEUASgBPAFQAWQBeAGMAaABtAHIAdwB8AIEAhgCLAJAAlQCaAJ8AowCoAK0AsgC3ALwAwQDGAMsA0ADVANsA4ADlAOsA8AD2APsBAQEHAQ0BEwEZAR8BJQErATIBOAE+AUUBTAFSAVkBYAFnAW4BdQF8AYMBiwGSAZoBoQGpAbEBuQHBAckB0QHZAeEB6QHyAfoCAwIMAhQCHQImAi8COAJBAksCVAJdAmcCcQJ6AoQCjgKYAqICrAK2AsECywLVAuAC6wL1AwADCwMWAyEDLQM4A0MDTwNaA2YDcgN+A4oDlgOiA64DugPHA9MD4APsA/kEBgQTBCAELQQ7BEgEVQRjBHEEfgSMBJoEqAS2BMQE0wThBPAE/gUNBRwFKwU6BUkFWAVnBXcFhgWWBaYFtQXFBdUF5QX2BgYGFgYnBjcGSAZZBmoGewaMBp0GrwbABtEG4wb1BwcHGQcrBz0HTwdhB3QHhgeZB6wHvwfSB+UH+AgLCB8IMghGCFoIbgiCCJYIqgi+CNII5wj7CRAJJQk6CU8JZAl5CY8JpAm6Cc8J5Qn7ChEKJwo9ClQKagqBCpgKrgrFCtwK8wsLCyILOQtRC2kLgAuYC7ALyAvhC/kMEgwqDEMMXAx1DI4MpwzADNkM8w0NDSYNQA1aDXQNjg2pDcMN3g34DhMOLg5JDmQOfw6bDrYO0g7uDwkPJQ9BD14Peg+WD7MPzw/sEAkQJhBDEGEQfhCbELkQ1xD1ERMRMRFPEW0RjBGqEckR6BIHEiYSRRJkEoQSoxLDEuMTAxMjE0MTYxODE6QTxRPlFAYUJxRJFGoUixStFM4U8BUSFTQVVhV4FZsVvRXgFgMWJhZJFmwWjxayFtYW+hcdF0EXZReJF64X0hf3GBsYQBhlGIoYrxjVGPoZIBlFGWsZkRm3Gd0aBBoqGlEadxqeGsUa7BsUGzsbYxuKG7Ib2hwCHCocUhx7HKMczBz1HR4dRx1wHZkdwx3sHhYeQB5qHpQevh7pHxMfPh9pH5Qfvx/qIBUgQSBsIJggxCDwIRwhSCF1IaEhziH7IiciVSKCIq8i3SMKIzgjZiOUI8Ij8CQfJE0kfCSrJNolCSU4JWgllyXHJfcmJyZXJocmtyboJxgnSSd6J6sn3CgNKD8ocSiiKNQpBik4KWspnSnQKgIqNSpoKpsqzysCKzYraSudK9EsBSw5LG4soizXLQwtQS12Last4S4WLkwugi63Lu4vJC9aL5Evxy/+MDUwbDCkMNsxEjFKMYIxujHyMioyYzKbMtQzDTNGM38zuDPxNCs0ZTSeNNg1EzVNNYc1wjX9Njc2cjauNuk3JDdgN5w31zgUOFA4jDjIOQU5Qjl/Obw5+To2OnQ6sjrvOy07azuqO+g8JzxlPKQ84z0iPWE9oT3gPiA+YD6gPuA/IT9hP6I/4kAjQGRApkDnQSlBakGsQe5CMEJyQrVC90M6Q31DwEQDREdEikTORRJFVUWaRd5GIkZnRqtG8Ec1R3tHwEgFSEtIkUjXSR1JY0mpSfBKN0p9SsRLDEtTS5pL4kwqTHJMuk0CTUpNk03cTiVObk63TwBPSU+TT91QJ1BxULtRBlFQUZtR5lIxUnxSx1MTU19TqlP2VEJUj1TbVShVdVXCVg9WXFapVvdXRFeSV+BYL1h9WMtZGllpWbhaB1pWWqZa9VtFW5Vb5Vw1XIZc1l0nXXhdyV4aXmxevV8PX2Ffs2AFYFdgqmD8YU9homH1YklinGLwY0Njl2PrZEBklGTpZT1lkmXnZj1mkmboZz1nk2fpaD9olmjsaUNpmmnxakhqn2r3a09rp2v/bFdsr20IbWBtuW4SbmtuxG8eb3hv0XArcIZw4HE6cZVx8HJLcqZzAXNdc7h0FHRwdMx1KHWFdeF2Pnabdvh3VnezeBF4bnjMeSp5iXnnekZ6pXsEe2N7wnwhfIF84X1BfaF+AX5ifsJ/I3+Ef+WAR4CogQqBa4HNgjCCkoL0g1eDuoQdhICE44VHhauGDoZyhteHO4efiASIaYjOiTOJmYn+imSKyoswi5aL/IxjjMqNMY2Yjf+OZo7OjzaPnpAGkG6Q1pE/kaiSEZJ6kuOTTZO2lCCUipT0lV+VyZY0lp+XCpd1l+CYTJi4mSSZkJn8mmia1ZtCm6+cHJyJnPedZJ3SnkCerp8dn4uf+qBpoNihR6G2oiailqMGo3aj5qRWpMelOKWpphqmi6b9p26n4KhSqMSpN6mpqhyqj6sCq3Wr6axcrNCtRK24ri2uoa8Wr4uwALB1sOqxYLHWskuywrM4s660JbSctRO1irYBtnm28Ldot+C4WbjRuUq5wro7urW7LrunvCG8m70VvY++Cr6Evv+/er/1wHDA7MFnwePCX8Lbw1jD1MRRxM7FS8XIxkbGw8dBx7/IPci8yTrJuco4yrfLNsu2zDXMtc01zbXONs62zzfPuNA50LrRPNG+0j/SwdNE08bUSdTL1U7V0dZV1tjXXNfg2GTY6Nls2fHadtr724DcBdyK3RDdlt4c3qLfKd+v4DbgveFE4cziU+Lb42Pj6+Rz5PzlhOYN5pbnH+ep6DLovOlG6dDqW+rl63Dr++yG7RHtnO4o7rTvQO/M8Fjw5fFy8f/yjPMZ86f0NPTC9VD13vZt9vv3ivgZ+Kj5OPnH+lf65/t3/Af8mP0p/br+S/7c/23//3BhcmEAAAAAAAMAAAACZmYAAPKnAAANWQAAE9AAAApbdmNndAAAAAAAAAABAAEAAAAAAAAAAQAAAAEAAAAAAAAAAQAAAAEAAAAAAAAAAQAAbmRpbgAAAAAAAAA2AACuFAAAUewAAEPXAACwpAAAJmYAAA9cAABQDQAAVDkAAjMzAAIzMwACMzMAAAAAAAAAAG1tb2QAAAAAAAAGEAAAoF79Ym1iAAAAAAAAAAAAAAAAAAAAAAAAAAB2Y2dwAAAAAAADAAAAAmZmAAMAAAACZmYAAwAAAAJmZgAAAAIzMzQAAAAAAjMzNAAAAAACMzM0AFZQOCBGbgAAUOcCnQEqVgiIAT8BfrhUqygloySTahFgIAllbvxFycmcckrTLGkVlm/uj/2Lr/hy+//3s17+4Pnpc//fT/9OHOj+m//D9MD/8vZ7/tHqr/xn0vP//60mS9fBv6H/p/7b+Mvx2+Ofun+y/x/42+l/lS+x/wXoeZL/UP8fzR/nX499A/n97lftL46/nn8H+y/sO/n39Y/9336/J79z+1nd+br/xPQI9pPyn/+8xf9r0Q7+v/Z/ev378a3/t6Vf//9V/tMPzh9sj9zB7T7ULaRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnhEjwbID71AwOoAWoUpPx/WCAXEax3RtgmmplDHofPjtIsM/7D9zKtTSESBRcgMFq7j9CDR2uLmOUKCksq7m3PZM/Rcq9lR3VVJF7ROsotik6h1TJZ3PYQYqLVQVw8t7wA4kMCDzHcEQ1ewjChSCUweKBf57JpF3tCPQ6pTZwCSumdXeYu4meiXxL2m41q413ZwwsOvymyWsoYdvaKeGD5AtSbKdMomDvucPbHmOufy6p2V0fCyEH4FlYp2FLXlBJRwXPTU96zTxetc8+XO+KXC4emvMQYLaE4o2gxlpEaYOfjkYThAKqBH/2F/ItbAYDdge4z3mHrS546F7LPjj/fMiH9ZCA52FTNycLXNVvXbiNeoSAhUmKJlEp4Yp6hwGQ4+MKYG94n9GmDLueig856If3PPWGTz2mKyg8OKo4Gh7vhRPZCkuTfdnQJxm5d/e5ZAl7k7PjkTb8wFk3zed9qU1bU9O+R/Ztb/BEpJlKeWLZ/pOIhwk7PBlEpKJcvYGjvPk9yX216TvU7MWmc1EtzlYfL9kQByzy1q/9eCbshXLwt9z6ulp6t4ScAvsMKo79rTxJav1jj7oSkg4C7A30XFmsMmHox0JKMmHG1FZaBZXyG+gIgoMZbzZIKbOLRx3JGXxXIPB0rb6avu6HhvEiyPCTzuBS8WPhD13Xpftv7zrfbYvvwIaE0im12HpsKIygdRI9045wOHRBDOy5iBawb47KYMGIOM6kitFKuDi9wMBOslS7c17vijOzz0qXg18EQegm2nFobURRW0BPEjJiJN/UD0LjtomnqFEUtATgpDra5rVsHBzwWvrKjKZWjJIRlfbQWOnw8OfJ4n+tfyqawPbMXBEaXe1elYReB8gjrliMQyFdmDgHCJnRspXTz4Q8oFs002AiFU6IJqUwzrCwYfnxlJbejNiS0XAymfJRnJUrgMGoer7iJSXuzMEPQaq/4Sf7mOKH+3CWL9r6AUC7ECUgJqcZUFmY8AfbEr242H2m8oId0UE+aaTIDKnWBIHCfaBQNEYUnskfxkOTK5105Xv+wrlc2Fsb8K7jReCo4vIwC3HFwjZ3uLlnnpiaSESLZ6w0/C1zagEl9H8x5xCOmvKqI04NWEYRZ22nEAtErYiGL5ksGBBYOKMXgE/Xts5Ju9dBBfAfOxV2Z3DNSxIDcYlhYo2jhLsB0/g0EqQeezksnopbjv/molHAPr/Sk2AVtBTOUtAjVoTgJB6X0/flAnpBvtlWSEr3RuVk7TeY7jWQmmqbcbEvRIT0sfPqsosm1FxR3JcJMljNOoOd7h0XiE86jJ84eDIDs+W4DOsgbDHtnCFLZ2ZUX4y4FZi/OPEjM2epbFWh1JN0Z8wbUYYOBOBj2JVPmcNbWxNXFtKHDE/wNjEez6y1mqza/lc/eLmxxh4fUl9kX87bT2eEdHT3DI5SK1bSqyx0Yw13AACnig/404gOYVW8EwlgyNavpo1O0BQFnyq229sY8OxAVuU5JWB18Zq+IFmizMDuaAPe7yUEUi/PdXEDrKWk7exwZTfbSqOua0Kd3zK7+LA9I8NcDWiXvKF7WwwAYBicewGZSTWt7fZw71hCxyTr7GIjiUthT/kQlTZrHlklYxRh5SSJRSWsk6rVap7/t9G5DsTRMAiMnDx6NjU6WkwSGk/D5kZKGrs1GETZia0INFmXW/QKUujxaEssDnAUFqpyhdJqJ/jfZxI5m2f+udZTwUp3BGeKysXJy2Ty4WSWXARkpihdT8fRyHPCDrVEQ+LaSiCXvsoJyAXvlKlzEmykwoESvLNP1hFlnJMKCwiHyazPXB9altufIEppGuuWfrj7fvhYHaVZLlLN0RDNNRZDGgULawWUMfY5gC9WNmJvQjriSPbrajVeOO/fFcFqxP9y7BeEwgrohbkwqZmkJzRRyybKH9pAxTRI2BxHANpRrKGAkALfRlbgH8rTt1+c0i38DOxR8TubpJpWUFtb+1udmWtut/j5HIHhdLbWU6ySskfBXfRYZegPPOxsLJcKL9jbKClzxiXq1PBD28ISrBfrgSC/nnzuZZmLpteX3ACMckh8d9mzOyYzSPOZJtAkFReH4neoPGsV69XWKQ4qv6FeKbfuCrU9EkJlIRaH2l6k+fPWR66Fw2S62GP2c49zajR9Cw7FusrzNYuSAhDiDv2olb8QQh7W17avRg1sMeWI8LdpY2uf2jC+dZEvw1d4KTzw15LtPE0zgBQyx7rhG5lME0UA5DNpt0pHUwpR9diULIAxKgtBjVfMhf1O2dQtpzKfIzAc177B2obEubJsfd7MBC3vhDVvafmlbGrq5vaDFMvpWzcjKualiMS5BnDHE4PIqs8cTJ9ZUJdL3MGmFHJa3MsskoBTHtecEqCsRvkXOqMYmIIUlGFnmZ/WiRkTZivpoFMnlfFChkRZx4rBLX44mXhrCQ7MohFOs5OJR2LDHTLl7xAHPoWVdyoSYD5yjg4lfA1iq16iN1NmDXSQo3yak2kN8pY4Q+gMZK4U1mIG4ZHp8KA03//uR7JwFwVrOkdxgjQjFpq+e6JDwV/sA+tU5cECFQr5cHWv/cjNea6DAgx4TdZ/9UFZAG5l7l/KkAHPNfiEe1otq0MIIQnLFWweKjXYOmjk2pYp8DWA1UZ2gQYerSsYrTih+Y1I9MEU0Jj71Ofynvck5tNp7+LsajhcI3ESxLGWDeGhJS3/QaJRLW+RweQoHbSsG/pabNPYFJMJUamSiCewtAn+eXNfqNZpwO3lQ3YcyHpRglceSMX1njibXMyebW0iq1Hc4toubB9s/HYsT/APuT1NuKFN3bB5kTU6BhgckfafsShTmrgHUcy+V0tRYya+2NcYOGNDhH4qckh9sc4FhqzrEV41yhiHsGqATPHE8StQtpFVnjibW0iqzxxNraRVdjiZ44m4aOGOJnjibW0iqzxxNruMLukM+g2tpXO4wtpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeE0OQKW5tmIAy03SQ2hEgDZtrKDO57AsdjPA+rjHzZq0UfmXQmCR8uOVCnNsTyycsHwRHB/OuDNr6VvUoZrV4Aico8yIrOVvYzO5QQdGF08+X+OOXw12WKdQjK9YJA/eCBxefWnV0Q5LbIvg+O/Tm58dp0XSWlhtWa+yd24A5J4llohCDwHxtuB1FBBb0T4TbOuCPa4z45nPOXgiU2nHGk8awHtbK/YtuturaxTegg+AWjYukzwUCpUbqL9Z+T4bzlSGar3gWdNeq7uu4WK9nLWH7aMXtAsg+wUR/O+Ey57uaAhJTAU5YZMe6BQsuZ8vuYZ2xSC2fI1PmDLrbXSGm5HXzR0ZgIxKCFJ4Qdngd8604OSS42QJtJK92ZXCByuoZuXpZtJUzEOqhDHwY6+HuGiaNfdB9ykHqf3q2r/s5oTNiDfwz+exU032na4RHy0y1SD2GxyagosfHltwbXfXXxlWi7VFqUaMPaAr3fpifq1UmWryeT+1baIu7rEd2ROId+UcLBhkpn+fQJNutLd4Oa8ak7TXPs/EENfeKUV6rallylK0vMWYvUQr1mtRnGznPr8e5ZH3H5aJGOUEp5Vhyubg+HncJWRsxyl9bcg6vI3lqxdWnSDPJ+90je0v1LK1ZfJTKXRWDSTqD030Tucc25ESsLVKVOzMDA4sabrxfvAeDMPfI75h890mG6XeyVcHs2M0ygnkuS1UT1iYG8BMpRH89UFbmVhJoXCinoSGlEJahreAGmR+/8cXbLv9w+5N8iQEFH5KXcWoSmItBKAeRvoV4Yt/TSMjS0HrzFFFc2VE700u6CWLD5qSca9jgtcgM87Kc2/of0UMdmFwga2I/mwVm+xhly11+a78w7ZXJC0bjV84MVEdItZWV3nsLwLULO20aQOvW/sIzht34N0kXlREeiyCcaIRj1AEwuroOgJesyO7eij74FkkOxt7KRdFCNSIfHfAtfVr+PoDZhCDgHBy0k/PXslsN2vIdQtsHZ+fxWlCda9C9+h2E4BYs1dGiPnmpK6r4d1CUGxRiw3buERe4ToBwwcFZODf32M01RXQ0GUVGLA6p8PrcWy/0k/gtvp3NNYnENiq6lgT5PCW6b54ZYo1txUabsqoo4Q9Hqze9pMttKGAymyqK65GVKJcUquAqizdaTA91ZoBohBWZ6RybW6cvycTy+RhU6zOoi6P3VldbVG2PXI7u0gJk3lJAdjBwDGJ56Iw55rc+sDMp6L9jla3/CMO3Q3SKnExmC+XbjAsCrNRzixYmkkO8xeueneE1QdJAOv9QIKaqW50KvfX7IPXtidA9V4Y2wZz85rEgVBya9mw4paQJ/RTDXsU1Ymi8/K6QfKer+2DkqFiwfCUM6S3yCi6L1QzKutZQzq6PIgs65CWb5J72Xxnj51gCFvCNRTM1Ch6MoyJHscfFtZIkW0ScrDSIVtI/Y36v0kV74MR+/m+h5322NIWkp/N2KAEjwKS6B4oUgZ7Q3vMpEjS2OIiOl+KxSZpwAf3ZqaPvAUdLvjcpU1Um9yKc19xy/nGTGkcYmCKiTPxTedHK1HkB8u5HmbZK2tyFSOyXFO7zplFnZyV2/+++9/EXo5LWxb/GE7Mp4uIHaitFau0YBYQ0cjFXRBDVTh7O3PY8z5oN9R72aqsItjxIUmWfALwMM5xNLtgmeHgzPQ0t2YHuVH67UGwBMcZ7vlKQCrnVb4CdFImsCAPvUvwX6AD8B00qGhC9P0oywXPfHt/LD9gZ86D1uNzyhbSKrPHE2tr6ULukM+g2tpFVnjidDRFqFtIzGb3gBxxNwt82tpFV2OJnjibW0iqzxxNrukUIetyY3GXDJX0Ea+0l1lN4EMaqhQOOJtbSMxm+AKD4AccTa2kVWeOJtdxhbSKrPHE2tpFVnjibW0iqzxxNraRVZ5uO50jQfADjjKn2oW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSJKyYOyj5i+XNgaaSDitmxpWVNT/iQSC9//N7wA47s44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2s1I28L9Qcd6moKAGMUzPsRxNcf/iaITFX3f+bVkzy5xB+F9J+sw1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0c6FStiOcAkw3dTmwnH/muh6lz4codoJJyUmzFMT6/8ltIC4zDYm1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpEoD8CYgYv0RWl3uV/IRcF6tTTaT1Dy7rd9y6zvtTm2yYx89dq8bSvZpo9aLPGCLpGbYwlx5MY2Nxz37UI7Wh1n7DAYFUquIieRTH6cpqPIzxraj2cjYic6DX/cJdkVRVXhpdhrmlfFGwREBaGOpOyKntsi1C2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibO0aq06WEVpAR5dXwrfEpgUZPDHPG5iJXAy4f2hqFXNduMy+HslFePIjdsCumd8JjDkuB5GJ2VjwWkSWVi3jcrEv8WngeT1PcNdi8wK8556I5uEF2hPz9/hxRveROJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTZ83vHUPX8unPUdnPZHHNbGcJX++nnra+e0tMEnQohn7XS96NsxAV11smNQ3RIqsoUIN75uL1LHTqHq/aw99XSU3L3XW8ksgg/SKDTcbXszlSeQaccqc+uT1lwRVb9GBoEROBsQnc7kCT5eCKK1xMliJikyAquY+vCfiQ337jx9NNYwOb8wLyGkgambqBTZX9o3Gpq5M7TyfvR351KDLr6tyM4Xw+3qIuYJIfR/fmQEkbo3igy1pRCLyrZ64e2iypuvDUdb65hFAqiHtfmt+y/wHumvxqjaCbatAznyWMHn+DPZFFq1OvmW5YFgsy9qfYkohBLEdK0mnpaerrNyFUdQqXbgORNjz6to/CvFlrIbJFA83SICKrwj8GGY31m8Q8F9BO1Q07upRCZ/6f+kRWEbr7vAeXu1CoqhwAsnAhRel/6ZMK13+j0FZ1TRsmSuPkkarfH9vzEYkguPrdB6nc0D7C97nzws6YyH/ri6Z/Ss2j5N2FaaAiQpVuPbzSaonEv4dWDW60OBxvkBo4dKodSlfxkwLnXschNgvb3zGHPrJmLsj7IdlJRNYiJp9Jiqon7KMfl6Vze8AOOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1n6FzV/ByM74T33A3e9qkR3GBzZdxG1X9O35D8rsXR453LkeZQGC2ufGnEZ7t1IWBIuya+VQ82k8tm2ih7cUtU3ldj6z5OQoOF3XHptYyZyF6ZDDYMeiYzKWPKcH8KvgEn65y/xLG4hIpPYY8mwy2NB8AOOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44elNj7ns8sH+cRIDS5Zht9JKB88O1t1tOFT7fM+k7M7U6Fi/PBs1S1ymWtnrT/Os9SSuuif13pZw+dMBX/isbvZMiokqjwurwHEq/HunWhV/jRIwdLVOW2WExh5pNRFu7cU6K4yXHLq9AabTRO4HLr0n9wFEl54GlgsFaza9hSnwhBgPu9T1wAk9c5roU00BEPXWdH7hVZ1dkD383snwcLgsA7bDOH9iUb7bohxBJL5b2dxu+87njWekz/w5v0h0cQT6cm9IQPwOGIhc6U4xgYqaM6auE4lKtYur8cXnrVTLfK5e7oeozHJQDVID3pzFB5YZYsEa4/xDfGbRQ+d7CFCTFsOWCBj/UnoHfClSsVyLhQy0btfDtfTuaT7fxbTdCiZvpz5o63Ws4AfNDinUoa8CQL/c+KxsuHH8xNK7h00/5VDj53qT7NMAhSZj4SglunjMBdUm4y1/nWICDhPpFfsodkS7+yF89MV8ksOEoaItQtpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWTK8STb97rlav0dBlTAxmonNXJiQObtgAPrQYa7TGjvQS5F2redMUl0h+RDCUpVQjFkq6xstPy2lM0zeCzOgziTcSkdN54+WEZsL9kQX7QH2RJKqPXlpyuEwLNltk4Ehz0YSmpxoj6NklRiFw5GmDqrJWCw4gBjTdjejyU1FQ+1xTSZw9M6Tq0ARQ1hSIf/HDxB7phV/i7XIk9yseTc59F0hPWlgXx7AzlwBowAVb5tbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cU13Krh3isRsZ0qxR/YGIh7c/OzdA5B+YvbWiT/aOHBrSa1lEatkGlh4GIQR9u8aBxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOn1njibW0iqzxxNraRVZ44m1tIqs8cTa2kVWeOJtbSKrPHE2tpFVnjibWQAAP7+mgAAAAAAAAAAAAAAi5wDYzlhgugzwiX13uADWHcVvHcrj0fBccTQJRx5s/FQJpSGj6qReFK7yU+NwumIFdrpPuh8S70D3jp5/1uwFXlKN8aqTd29fIBiJsxX9UHB3G6K0iC5MMynPU4XZ6tD01q9FX/iUuJyOSyzEbUvgAxNE3wfaMh47Y73TPMbpMJTUXwFaGqfT1B15dC8NWGXVO5x7Gv/2YEprwHgAhFBgR5ZPbVIXBvj6k9gH++Ce2STzS1Kgpxo30VeEPJFBIPc1wHAtQmvzI4VV+jdhm/GzpbmwkEE6JYzxqi9YwoMl9UjaQHxVi8ccTr5oMaltwAenckK+fNPIde9dFMUOkcXCNQKy44Qjg9EO1GcSzx2dV78rz6pLsbvoR/rHqxrKd/aV0BevHJa0oJkF2+jWTdgE7qjyrzNlbbK8oVKMmuhK6j+n2MtmAUJJ0tCFFxcwQvqItTsS8MJJda8f+W+IBXt3heOg5tuJdNwr4e+UVDMRhZ3EK1MWe7pW8uuCfbWSKv/rd2KmPAFj5lETnDLqsASIH/J0KkG1G4A9nMAb4RLtITKDV/k2iNKYtpHuUKlKCpsS5bN5twLlewjpfQhHwNAT3wO2+EIvjLepqpO9Mt34oJCcPJXKJcTwhqOU48toxy8CT6RkjuxEvr1koWgTnhHVUcvtYtf8rJJ+Qe8cs3cedx34430ZhlNW4UOt17b7082TqEyegxmURo0hDsffXqqj51gVB8U/wQcCTs7YEvhP1di2cPe731CJLUDRtGxbOQfJbSPaUM+G6vX2NCmUW9nfZdfPn+IAk6OZuxvIW3q8lYxFi2g4Kigp0Oe5xTsXQeLu0n2VQHDUJdUCz+ZM4OnpIr76p37Zwlbv3fkWt3eL0Fi9uQ2jMEWLKQyJhvbisdvuVcMLGM+2BOCGR9qWaY0Ae7mVNMxM66SeScASdS7O/F7HflvpphlTnTJLCLgWnjzfW0Sdk2Ju2ke3TwvnQU8iOKZEpcJ/Bs06UpuDOCbiIF/YDoe0x9Nr6w1bssSy8cFbAs2d+mTpfPyFD4g9USA408HvA4WcP/cqTyod6JWkrHdbI3eXmJIfY+nB0+OtcXFYAMIpk/zKNMfPsUIfQnuKWQIYLE37aFUdUHU5NSXLkhMJFp3mLlQ7TLukjEqUx2xDeCPE3oLH2mHvhrUA6zsxWRPuKigShJEi7ZNlhES46H7jC92f3T8To7SSa02+Tqc6zgHGp6oNP15yys9MreAl9TMprkAoPRdGTtL62p7UGLAfWVvUUiGDZlpna36dUSEzL/+wqJa0ATnK2+9Ok9eBTGGHfWLcOatMAWBCoz7Jn+1iHTQe8QRf9a+YNuBvWXx6fVuUnkgx6eOMyqjVn/F0tCK/f7VSKDWguAdV74FlZFCgYG3a7UbAtWIpGaBI33yZMzkDVy0tPGaZwyybCdFNr0jWHAmZtN4woBy18CmLGYGxFWqWjNLJa/FihT5u+b8/cfs5Q74Xhw39HBvNWZIdkJvJvOTAUBPa+N2bwW6OKmhGnWPaNJaoCfnB6cLg4N7fKzuMgjWgIs7uUs1hxcN3WCaLIFPMKJs48E7IyVfQEJwcllOJmzh81+BxfNtq5WsaHyClwjwKH+0KODG4j5zz2mhLOFDz+iuGzGJdy+Tmm0xTYQDORZqxCaQ1V4mlEjJfDjtcGRnFRjcw1yKGZvufl9GWIP8Qh+AEgom3jJFs5M9sVUSyqtw4XJMBt3DmiRaCCjz2BFGKT3iOU12nc/0XVykgiTLyaL7cWl09aLimcitw/GWIdJgCKPVcF4c+2KkHF6Q+6mMkrsTMhE4VQGnWIOtNv2cTQiO1fpamZ8hhITi3tdtDCjuxr7Ggh5mV30CPk4/ZRF9b0bPwt6sPZxEiOUoapmWNiTIaZMWYIZl/7e6SG/BFJU6GgeI0F68o2uyP1lkyyfm3dVTMQC0XJlxvPXeWCiY2/Ps+A4bUPo3VNmPwZ500i8Aity9YCrhdLMcF5vVLi/vHFxjzabxsipRgoQ+zps9HPxGoJREllZ9v+Fhl/5GPBnBapFqE/u0oN5PD2rbMGofZITBDNC6hhPbo62jLbKaGd56vSfopaRP3DLGU6oEu1PHNtEC7Luc2Z5yaf+FvR1Cq9+qTO7wOGWTKkmc4/FXBwdQd0VHyyvguyad72V93ABp/HBcibRtnOFZj0yi8WwuTnGeq6i9lU/ktGSiQulYOjZxnjOCBfRtbfZlxmTWNBL1TkR5rxXsXJCzGctIcSBcAq+kBkX229NasnorvRrIj9tsZBSADRe0Dm8wkV/H785yUcdkGKl2pGUMWB81a+PtMLsfl4LYNZZDTS0R8tNrXeau3a6MWaYlmaqg5g/xgn3TZMhxAYvUiyg/3tneMa3diJexznxLsw+aWhsj0uhHJhYMY+zxFZaq+RU06gmcvWCAD0pL9a/CPD+rLBnb+d6fQEJQLQvxOgu6dkbddHztNye6nDGHURK0a1nwV12BLQzDQNW3v/wc/pRXNhPyNZNS6Y2dQ8RS93slutIkgwr6kGfjjrJet035HW0WNbYkcqSm0aCwNMisOuV+5M8LQabj1PftZ+6OXHUpFKCLs7kmhr+darg8axbmm1dxoQPtSeXrtZlnSAeKdY1HZfQJ6GfcmdvLX/rKTb315jHJt4bNvjAiBqFj3/VU4fXGz6y6R7qwKESi5j+UfUDL2SIlfXmxv9AnYKuspmjstB62mjidYOQ4grm1yYCPHUtJTZA/KK33CpPUnzAi73WwaqH7XOw4x4RWB81OdEFfQMIey5UtZ3L0Ncg9Tlkg8YoWXSrPvR9jFf1shj0qvY2nzo8zNOtzv6M657CZ50wrEEePV+rT2JU4jIaUzt7P6fvw1OJvnsq8s/DC7djQ/rpmmY9rWH3gU3HYePUKOnisstugHn1rXd3xL96W3eQSk04Ea6iM4IFiTR0QgVv6GvhrErktGehnHry+K1mRqIWQoNAgV5ChiHz0pWOFft4uca8dlaND80QGefsMh7zsHy2wNyKmSzBgqjPBrqW94KnVAobFCBYaLZDY2Ot+Sz9VgxzUbfZ/ML1qDzpCU3UKho/e/tm+2ykCa+UbBXBqaOHUaCIEuyqifV11rGDrUwlppM4/4RwDalH+DieCVYOWatQhWc7j7dXVjoeKLFAqgCMwA6ttLaAZWnWk3lOT2mQaVGolLMed/PpIa7rdyc7brgrXHnda330olGlCZnOnsfT9XfEPY5g49fzBpzo9XoZbCyuU0YYhhZJx1ywiSR0mYneZMA84XNvM+OJZsMeKpbcAa1OWqczkOMCfCoy0hFBGYLWzHkTyFSfcCZw0y4p0uuwFkQyiKd3F/hbO/sFh5uiRVSdcPvK+W/wT0YmW2YFIdPfHudH7SWWEiKqo0k1ivc/mDm0tE+zn0R22RQCn2lSaeQr2KPztT9YjfrqUHFZpPKY4MtOg3v7vyu7bdlyBj3rlBwBLCGP52Inax6+0PxvZA2pAEalEw+Lg6FoBWTorK6dG/mUhOJcFFJR6n6s7BzJfapOuyFYNH3GL9F2B98hmAeqltaYyJ3i1ajapFfJQ9ISNCKAG/xZSCY3KeckTjHvnNtLOQWTyytGED3XLP8IK67xVDpj0TJIC/bDxwlgjd+DNiCj3alBrmV5A5iUeBkGZDber31NwlN2LDaqABibEdPc0Q6kPE3N1E0mklrOXrYvXdjiMGkcq84v688I6kT8Ci1/8SnUG0sgD23TJJW3HNGHLIlbx5gcHJAJnVYACua90H/XNa5QXi2tsqc14AYkzmBbuHLUNM3K4pGb8NbGn7rBZfhk2QfNKXAXUDWaYoVQ0coRDwOBai/za3fFGLf20v3+Bso4rCcJRX8nGfIWVIrw06iRagL4Ydw0u+nEtceQC94vLRh7vVkW/bUbrXiy2vQa4/NSIDX0ScDuGtI2cpUHUy8MLonX7KFabblU2oQEOzrkFVy8+NO5k5K0zmSU5frtENzRp/N7rdPhazwka9vDTvmU0mk5y3Hl5ggEFo5yDSLxFiqh3eVbtzxcU+9ySvcxhVCx7hZ1Lz+zEnfcQa1Z1rsenxG+s/doiTc6jI6cJYruB0PzmgftPug2MAEnHm4egsdAU2Do8NEpVhmTgtC11eEvhJ7yDvBz/FK6VfOqKnq47odLGKJ2t5oAl0TEW8MomCl2ttF+blXqiHx970Ma5sdEVRjgYc54anpjvz5GDXEqcYPqqldxB186Av9SqmL3XlxyXfJbeVo4RezOZfQCNCKIyrKz6jSfgK06SouCTXppn8oZFIFCNAiLY7p46L/MturTYEkQN5P12HNGsSjGxNdtj148FKmkMEdePmjTCxyv+vfmPSbbeVIWi94JMXQzzhWeyjHJolQHlLzsMiH1pjzoHFTzpt19SST7IKQs3X/UeTNcQIzcNLL/n7T51UTFQftn8WcDYqVYVcp5jF21mGz33g0wwOIGXxIGGCf8TDdOLUo8P3tTsPGHBgtLhkhjyRJDI5GgZU7SG8CK9XkE04vZ3P2gpfJup+iZu7++TWSzxc6HPtOYzf1pvun0nXqYzDXMixFN5sqgyIPuKVysD/1/BBtSW46x3Xq9AqqVZdNbWBpl1NsK3TkDQbaL+u3s8ZjBXN7cdL9NhTzPswk7wC8ZbLpEN0BVO9OwbZ2ADYeqKqO0LMfLhmfoUtqSWzOIVlcvU+MHtn1pFBLtcO+e6RTxnF+mqHT0jc/xx2sGvmcVv17Z8CxRs2nuGmDqJWTTM48ZBhYKJaPSS2QF2BfABWevPuMJua5iLnNCArif6/Dz5OcMNvh5e7H612+pNvjfRpEjhRp2gTeX0x+L0/upWTn0zbGBqR7bSPzaBODBV1OcMtkRkx0hFBks4RAmuFSDikI/mnhbwQ2MKFLWWj9HrdFk7dLirFxDG+vVl+ajL0ESfs3HFeS9H6K7Q5aktyayKdUsi9ptT4GXefIJQyXMg+SRN8GotUl9ATVUWZ+Asg7bFsR30kgCu7qWBM2jCylGV9L86ZWB+QgpirYUp0bYe3P1PyZxN0LBl6orPGyVRTfAcZnAVNsT2ZQAPf4y8ZsImTqxY9ZbbwrNBQSgvN1H4ybhaidtaWd19IPdCnHNq+2zC+BcviezjMXgzlDdoNy15asvGpWKB9HFmwvWeL8gZi/mRLuagCcW3G94Jn53cDC81lmt8dE1T8YMaUaexZJ7bRUlbuB/1lWGVf9YecD67EeCildFV9Z3IUxMz/8o+ZYO9g8WU2JmOUIU8IaZtWyIisFF3Iu7zxGchXPwJhSdnxRaFb2xyPNrbosxnXywhze5xXOxvuvg3BsKoVZtxbsxe3zt+L8Gw/BZWZe4oevuYaJuEdXsVfnsoTjTbg3I/QXVAHjRX2bO4Cl8JSM8iMcTJfvyvrBCOBB1a96x0aBSuTVO6A4iF9VUWOYkhf6q6okoDs79o9QamwTOdwi6UmIX1ssMkxceFvcaw3imdYayyP3WsjgZN4KWcIlDb73Ock5aeMeYejw4PUrJVLURnrGmQ5/D108g96aNVnQGu7ma/pctdc8kOTp8GM8saTfO7MjYCyzSP/HajfKYc7E6ybxML3M66uE7ltp+MY0rrxYo2XuIK0BnxKiPbGde1LbPRlTx7rEPJ+hqps5xz0rheZdqN8iW/by7HSYNJS5UzAMJLTpB1jMUWiirwU3+cgglMJb2HjOw5/YUQ5wtCIb7xcmPSKrI0lSjx0df8eMfCA2t3uxBcy/923ouXXJjXN5sN6oo2C72nZKCfjYt9+6Gq+9DmsVR5BS3t9Y4ig+Rjcl/uWDF0opoDRcPZ3hy8JLxpY/XoJTBsr/jklx35zITStM1bVQNyhj4KRMYDIfJCArUV2b11VyIgU+IluImoStfmiX3JEl9brvyXCeEQ1Z59TQym0dob0JMrNO9IPaHPopC7x5fps06UFPtUSR45r/4QBhXOuWO7e1abKoUgZ/Y71dlV1OgXoY3T/VDKU/JbaOn9TJ45+GgB1WENrjSxpHKr+PMeQwWh7JIC8pdyAp4PlHG1mlyZyIgKXLKCPaEcJh5KMomTcqblilAAV3OTatCt73C+kHYiA17wnRGFsrKffAsH3FyV93+ncW8CNPuBWX4ahacG4+Oa9TjArCiZDpA9+cwfbXo+rDoCRkBZORnCghKImyrwckAXUhDXVT1eRRaVU3MiwAB9ah42AxqMjmoFId3K46svTJLJjN1zwET4NAFzffn+P9IoBfSz7cx/xf7t8aJpkzsZv2kdPSvG6hsMWBZlMqogBAP7GoYeiLEHmmKBELn7Op/WstW+ZQo5jmktS1CkV4+G2pAf5TDbDqgWP6JIpq8xPHLIm3T3qajlbIKPHkst9QK0iF0NVjMWxQAbhJJgvoBkmVzF35fyr09RZx3NKPomlNTr8DwphTkcMdh91cT9/5i16HcZMn+UCjAzWr6mb336LUmUs6VEKnGA1q/IolHPyf2Ud4/v1lVYUK6UHTUVNuxIPYAWAFnrEh7JfUdEI/sC0Bin+npd1jBhTJJsnyEoqIFEH6RG+zVtQSm1OtSYpmS7EArisgcABiet+gAgnYLvOip05wnn1/QAijRe593LLKchD6NQJd7dlGiYmhuAAHJZjzgOKyy5AAGh6tZ2ZyYIWd3eEkm1FkNSp5otMC17v8/qly02McKJgy5iNfUEXb0e3hd7zrHoplpZE+bPs3kcL5Duo8yfwmnNUijU/U4ErDT3VgpjOTz8fWXq/rVnrt57KHLqZhuCEIi7F+/AAARmIF5/HaT0A+eDZaggZz/RBoovbCLJjl4gmFeuHDUBM4APrIp1rXIi+LDSlZrfGgJnFnC2EpujHye6zVqjODWmgiDRNDIFV8j1vqghMeZGp1nxnQYT8Vo/6F8V/N+Z/SQjApT1CF36XBwYURiBxitk96PyI+Y7zncUg3xX3ZS3zVTPPO8wDHtMAqFKDOcEBDLiKZdAb6BY/kvpvIIFo23sqdZvTzyckNII5PLNUTA7EJT7yLJH3PD+JZFp82lsK/FrZUtanxaIgt3OIMApwyxTf/7uR0pATRP+uTIszEJRIhOi6Knjrp7c4HimYjuvTNT5UAQDE7Hi7s9+LgtVIMThdwWkBHHlUwg9PZmadSRzsvF3P25Ywld61+k5mnoQV0+OaQaDaEn0VXlsHM8vZ278iOYJnjeBl0jle7BAVJOwg4e4qalfQNUIFpI/VhtFSKj8iMtt7Uzx1fvLeiE/OHHDN8UQLvxBM0vo5r6vQ7ihzkai4/IZ4Lw7HhXzzk4G2hMwLV5e1fBT0GCAs1mbCqzTfoUjztDUOt4RztYlfTc/K39c4hzw82d5akyHDbVxivhRuJBlY2k73E2envfmY1vIdakmyab0EZ4nMi6zvMGQrOhbruDHMjFGW0ce2qDhYePHHBIkbLtOVSw8X/cCtgQkoSePSPflngjGrb1vWveZ6pcYRqvyBgorrf9kmRDD9SmB6BanpC2qKnE2WxxdKJMU+q61Q8or/mRU+4Je1cY8W+Lr702ihawXzLghG7WrsnxqB8s5iX6c63N9GBMCc4+t1krCZBn0EgAw+6AclJqUUaUtscXJgRctwwanTtDK50ekm36Ew+Nn68Yunr6Jiiu14oAP8fiTTnD6Xr5npmjCGJL+p2ogTvYbpfRb+Sps+1pAx1GWhNWNFELYvMAyaYrBhzHWnjSOFLsi16WNhHA1ZfW6q9l1ffiKTsjPzcVrbTrd0VG/ZQeBgaSS0LMX+/M5ZnwSlhPAK0OES+Z3T7DHQShLJCVJ3ky3gm+s1KTMfYQJEmEtc77SWEb5Di0hapIgS5BKI/VttqORq50vFw/gzWva2RLXRbubWJtnE2dYx5pMD3pID+pdkLiVaoU2h5wEGSK8rkr6c0J2GB1CEUYITtvKq099tMn03x5icjxF+kB3IlClSh2jsewVlVDuHhHJzgK67DJHy+bevOoFzSlBnHeTzS33DR7OClWAy/umf//4dAOGW1WfBcIBJFsxyteH/Y1yme2UoV1xeqprv/B5zfPpjkwr13mhf4ALn+gG1Mx9NOp+laSXlOKIRXDaJsJddv8ciBIMrtAgC/rII+mWy19QrEubvNVhHGdkCh+tQZcGr6LrL8K7z1vSTaQPYJy/tSGkw1tg5sujx0HoUPbpBsiu9lgMRVeVuVVlSzZJZp6QDfeO6w1Kj5cuiwdakZtQtfZ2MOTCIJXj6jYrX9uRWVvGeyM9i3w+WZQSQZSctYpQFfvV7BzvmWEXbh+1bRGyNEix76LJy4RXWwfMLK0R47VXMTxsPh3zfUXrk5SgFideQ3cDJRJHYe9JcQxsZXpue/kkTr0QhUeDmoVSVn8OWiJyC7O8qPA2kDHVPvEYlL2ZEqcRaJNQimaMZjmZuFFJ0HU5yuPa79GwcsfjXSY1A3M9SZX/uIi1ewN5mnKEssXd4HtKa9A5ITDtsygpnDIISuBROep+nwjqNENOawfaXeu5x0kYTVupG1DxoW6g8/TzsReOJY4/2enm+aFgrQ608TLOV8jufLtALk1cp94RzBgTAxg9IQbDPbwjDS6woC3EsZuHQXxKc+8oC4mheqKO+zGXKbXE925KJ0QEEqZM79S54tFfmAc/dBsxBo44lL/8g7PdnOnIz91B66Un3a07cjE4V3mewqs1XL1+eDZDmVc4N/GbbLbfCqvyGnvppmshsz6fTz45q0nVKiz6VKs4INIwuht2QuUKfmcGgKofirQTVUJz/D2eZB9aAO/DHflXohsSvhdZaHMGzIy9e3YMij788+tX3mmZoolKQ9lVluCL396REAOsqDPZLkRdpPwrk6VbHklEN0dpvDXAStc9/cYjH/Q6VQg0jhYaYO6ARmltSUQUCxC/PSZuNXaS9ZX6t752N48ohZ6IqlW02W433WF6CGQPYH4nCHaw+Xt8IAg+3XDY21vQ3gNuxskKUTXR638c85C4Fmw7zF3qPpaeRIZ/4c/WeNs1Dw0KqSFgL2/RMN3ae0hqTMgWhzEk6iqbQFYhgZ2uqlF2z2BKcb+Ty0vhWsIDHtX5sf8g+f3JTOor3umdciX2rnG03DLV7jea0IrMl8SlKxaBNi7A/uqfbggB8OKXumhbpBfO8Qkxxd8QQFwaWmxFfC+wbUYl0deXhkDHKeEPIWQ0AIPOQaCLLo2junbP8ACJgeCYpyM6XdP2dWyoxP8mw3NNjW9WqlvBaUc6OXqsokqlKW6xzEdtwJ2D3OzX+PDlyvuxseVI0tO7JncKG87Ng1cC9LtD6sAH4ej3Jhi1Bj1UeJxQGQx/Yv8k3i4Wthsf9arQlG0H6MgM1+uxoak0r3kOK7kdy5grrBdTqAJdvOpxJeGOz9602ecEQSx70UZ6Ngwsy2smJxz4gUlSVFYAztFCSh8yhsjLyNHKDPjwGbDEG2yKauId6U7HTwqu5imTY7bv2Hpdj73whhZDMlohKuulCumdGkNJ8ct1viYnf+thmfCTY+eGqsiAtzV+5vyreJAupeQcYDMCKhHzrZOzeEo/Mkl7P6ZEEpCnXzyDMTvor/a2/Tk5wzjEKdfc7YoVFkRb5TxlxMLxph5lvsk3/etSeXedEtTs/NUJCr8T7mYRU2+IPLYo0RK59NNu5MHqnifpI1ggo2lmQlfu0AekBWF3V5FYEYnv5ShR29RgNsL/v5hTS1euJ93WRTTU/LkWbM7i/3VtCq2V1/LdV2Le3VoeAN9xsYGgLL46hHbZRV3qUsA//v4WpQogKfjnttWwyoz5rJNlMY3E1v0AIpXNPKycMSoOlQfoflLS2/w04uoMKdshToSbPoRoklirziHGwgVhfSsptnAO7wIFTcZeWKmRumARWdDl8oxNCfVV9nQ9ZSBw2CC01Ex4Slc8fE4Zx7XUQGllIufRygSd+U/eKjOgR67Kb85HmkYjk8H+WNrZ4tOHSPAoAmwXlkwwPTvBAwpHwBCtOS0HEjryzwxK7i9abGXI/cn77j0f10C7n8zbLj6Km3bJU3dBCUKvIHZfGB7jiACZ+Te+5SoU7t43w6ydUdXkkmWVmUvNFSDmeBT4KsmZViHi1FbY40ILg7imLMp+6ZEj5c80RNDEg0EnBW1K9TfPnBP+UpaGXQISyc7TxfssyH/2VkVDyrcS/2XxLF3m5+kJ88jRduVNsYt+6XCJPn9XRooCFK2ZYJB62KLq0VgD/1wbIQ15I6L5yRSOT/NzwKYq3bidA0GUO+hsX6UZvz556p/+1ns0FwYeTa1btG4hm3mSeI+RpW1zWpYlbqkL5yFb9Xb7GvLWEZB2kxbaVPg+yfP24KZzF8zWtiG8go479W47BUk9niwrMIxlpUERQOgPNwVJ3PPMoqeROZjFXiVbHVcKjcSZ7XaNgyyuiLW+BDXVROfXz3bNInBCbx45Kb/kFJ8eeUIGjzjvDubEpLMRLNij9U9p0aYLD/0LxjIdaebLQN0X7XvvqFG4+DKl8IIhyenB6cPTBCDc8d2AhOs4AJTkMBruq7Hk81nI3yWik3ScCGc6mBL2d9oWHANZ2cRqCPXe+6ZwwfHCPN4nTmLfVfHSBSo2gpOafk4MsKVHLCdJxK4RoN3aifF91QRHuQwlrzbUn3lWM8GOAkA+gHva4c1CBPe/tde0OSKynKzzStizPyHOF6wotiobCRIErT3KCcN3l4U7IstH7VCIcdRGUmhJ/tg7emzVgn+zTeYOlmoEZWnaMBAR7xntToRNgh8eNtLGvsUuLI6ZhhOsYerJueY8pPTV7pxcytFeudZzB+hPQ6UbYHAGCh5xeXZtOoKb04l47s7eGBKCCI68QR8fYg7CugG0tQGUx4vc0T5+QybKz2IbQIT0O78V2leR89yq8bb5Y98Xs86ZClYWBB/taONI2O1nBfL2ZwOWxfproqNn03M+YdtnZYuaBTFggV/mqEp3qIN5DXWTSfTwXGxycIiEKdlu/CPx92NgpE6haLWaRq7hnpPB4NcYLn+wHEBs7alKEPDIcCe+r8gg4T96bx3XDah7RsJ0Ot2wAUtOMqHdQYQDahTWBC5abhppb7a03cSJ09gJpk755Wfp94pBPLHxUDfCwxC75wYZ2GkKPgCLblafJeinef43N2W3U/VFwEBoCP1dfr6d4qmADw7pKmEaHeAQVBt7l4FUv5BUbLDQ3Imrlrzm+Qjy2+d3UtGg08wEiVBQsoukixPwNOnoWQ16CnNuHJkr+riYdLNXVBymAUpCAMljg99OC7PZxGXSm9wv0B8c2VgdydyO2BDFSm2F0b/6HVouvkEoKVU3nVDdrIz88GzsEYPFbr4hS0A+dnrVIr4eKm+S5thh+uwNsWU6XYfBD3AHOcKyB6GMnANCM0XWLuYQakrISIZbOcyGowEr6nJxfxmtZgKERxtC2cqrJTT7kRGtC6M1gLIq16i0dbY822xmGo2/Jm2ewB2GNOUTuUYcTcWP29SkGvEHVNZqagxaAC1YGnowA8CWwXs+AIK3zIQHCwlaUzXxniHHlEY54BENTgRKCDOti16AW5iQDB4iMuj3T4YcKiUAaDF1g8ojclglkSuRis4AicERNLrHKD4+fCm8uFptuTj+dBZ4tJmnG299xkLJsbX+gcpWB+/FZwlfUK3if6A7l7UABQwz67c/X5R8NP8CXlyHvQUddpktjqty1n6ClQGFmkMfv4tKYnhWGN6ykP3f//Cm6KvTvDxqjcB9DJWQDv6IWe3zrKLxTboGUMCnYUk068G6REmTy10DJPNngKJ+x8l8qRhHpTAUHnu+xFYeOMWRnEqhVBgY6txt9AA4hygCJTzuYHSxond+EoMfsa+xgrC+hlMZDwv3chEwBimDOcat5SUtKozRzwBOjz1CZzXLFDSbb3Eq+IaYGL7SsW1wRuiwP0Lf32CmezNB7yYCQasc4C7lBwcXhzNQNNVjtFv7l4eOpLRBdlQ4xN3/0zSR4mpx5eY5A6lTpU3+eNXIYIFQz3gdaUhiAEzVjDZy2/wMAhNTavpcMUCjy3F+UUt02lhIWsfWMwlXcNQmexk6ZslHjCo6S47IQ14ziC7knB0Gv9yEeSXPdeedJmBYTeHU8VBdwgoiwAxD7+IIllO1jEFBIu2sgqsXBM8bMIaAb+SqOutq0LVbAxIys/DPLtMcGtU1pLw/VCVmB00TEuOrUiMDxaLBFkw/YX6YZu1K/LlkFnFultEz/YCN9XXAbjZsol4YNEoghG2HwVJKBQrQO0meYDZMxIupGXtoQabMxtEP+Dga1GkF2nw41TvxwGTcKM5H8TFn6ntn1Ku7gH1qzs9O2NvwLmB3p80BVzU+TYq+OhIIpyfZsUv1ZiSWQSjUaiVnYtpnRhItHnV/AIwBAEtZANQcm4SkLebRXebDoFnCd4Oe4AABvAGiVhb+O9ntbNqfgEDpNyy2mvArrtMfgAAAAAAAAAAFNN/gAAAAAAAAAS/u6eFctjxh3XWhbhLCis9OA5bCMKry7v+Z6JB90NGhuMAI8/dosLMAH86VNlq+/5rUQxsKJ5DGhjilfngf7rN97pZW8UAKqRviQ7RbvTS3DnN4ddpZUyitaeW4SpYHPGbgNp7rYZnw+Hx+Eys1c9GIYIJSXwEtIp3vzejNbVcEKq3bOSSmp0Ziuuwt4KQEtGmedUVzekfDtf1AobskRe1P4gjbX5izpY8jCXmKae6+Hk1SHN5N9TYlAXJJOQdl2SL4t65lX2ryIwzlf60iAQqGtTHNx//QGrDfjEBwIfDJBgmzlde3oD87M9dcYCLXJj68LFivcy9SoDqdmG0Nr+bNHFl2WEEX/fzOm+popda92qTGzBoQ8KVt85nATMxXaIlU2m63dpvwMMMAot6XeRwjka8LzSILVO6UdRDqQM7SnNcqHb2xV6Mbu7PcAjDA5ZXZscnEsauRceyL33lwsck8HkHlrqKR5Kun9s24C7RWxaEedNTrBcUSPwYg5ROG/HbWD2VRQNjYGNl49BJl+clZzX4BORAU89ogKKvfAwsdVFgia8wPy6h01ZhhKgiJ1cDQrS05m8g4xqrJMJyk0mg9LzowkhUmNAsu/fMC6oKpF4mZwENgrgKVXpEUJHRxoUXwKHE0rUu0ynnarFMVIlnPBxXAFSUMs2GWP8bKv/6oANXGrWCM6A5/S0AAUun7Jy1F1MFIOvDS5uBYDW6Ll+PuCdYqXsoT8DHhgg2AFo3ZcfvciSkpCNPwF6TF/SzP9JtYYTfxQ8WaetBZS4scWtLAPQZ5B7Nx093DWMSRJucGNYuTXIt+PQSrPhYhJK6FqjJiILUXOZb3qS1mvAVC732w0MdF8DupGnXM8tAceKOQfNFRkKge2UYEUZFFqYX5YG6O8Dq3uNxeag9BFuHsNkrzWWepL8tYTA7E0qy7jjDF9h4E3fpZiq0SqbFRqpqqWW7uQuOARRnmQbkPzV5W36mmN70bm4eiLHAzHOPUEwaQc9girzZ49Vw7FcWcE/528L1sEzU/5qdwlr3tUlDpdRpah5sk2C+ZqBSq+pD75WiX7aiZR4egG28Zt/sv5ew0w33/2ExpHv0TUzSnjw5V0MxvnbsBOC8JYLniWHUE/DORihFwIOJbu3LzT9SOqsGAhs5CBbfdAavo42OX2IRMag72StgIHJQ62UMWFpnZz+eB3i+r2Y1RTKztM/s2ClQZpdrA2B71miPaaDOqbxhUbzBUvKk4/bf3l6BAHk9bL1OSO9GVJjQcdxnkFn6rXXrj+pHi9Y7hn5TQtxZir4+OJISqZB/GQNtxHKErnUTnDG2Uh5aXmWpO258JKXwcA7u/gyhckoM3c4/0ITNaIYUEp5m8vGoXs2jHvYUIMdvcg8S8Vc/WEuuF0gXkstTFovnLnxJFcZwLztoSWvp0IMjHZfAJQ398G/mErt95I+3GR0WymuUjBakPGbbILTtOC+lzAEDTJScYZsSMhHe/YBD0ncsnasp+szHFJgR5yBQGuS2P0TxYT/rJoZKibTyK1v1yq3CesBTsWdFHbjv2gqkXQlGkk1qUyww5iCcVq3e83ZcLhjyLOsyi/8Ak/xHte9+C/lZvWerCKwypA1T9NQu6zmWg1QMj9mrlLJdWxxu7a5RFVbkpTdaGSzO++dGEODR33tKKDF+AZI6kQpLzld+8twBJm8wXxatqHMbrkgn5sQpJbruCygJ4ufsgTy8PW9wgafrKZfg7jmTeXiuuhzjC+WYQVChUMhHGYShqpcqfMxYZ1ozCjOcdqoRRx0DkPO/jPrrjJOvj8jsb9CyCax/yINdGaxJDk4VKWerYRzs/s2k/j96knCcJDa8R1BsighNsz3Oef0Dn3LYQ4T2RuHYvNftj71Bctuw0jfWF8Eg9IC+NJM9okUqB+A3RB10AknrDrEEjjR4Kw+UK+nGzzZdYncVPgqNB+Bx10cMJLO4kM/qEz480Cr5nqgK4IwsJY1hw9ORMTv/Vr8ldYGcq1leiJEdkKJ48my7TmxmUxNtmOnpApvNQyS8Eui4tO4PYrk2nOZTmccYL4NkU/q3zHUsJ0jZ0qrLnbiXmCw4sYkaG0ks9zOmFNT7O/G4CanNoLJiA0GAqBSJ6ShWdzzn5V1y4sA90xZCZuyEQ7I92mgy8ZfVlBZeciqszuTr0+Y6uym7k8axWTCCW63Q+aEMX6QdggrQ+kn3gjjCi5YtAUpCZv95J8i1OVbP8eJeFaz1qPqqKzwu5BNwjwGruLLlJeJQIMZc28eTb81woyY2rbKB9XCZGewZhhdefC9zAFFMDI/GSxL78ppnm/6luy57QRkRyCfXeCkdR2A15temI9ardOwBopsOCm3Lqg0MsIkfiTa7WMpGpAWrpgzuFqC9xPZQEzk+qz3mNa/lao3M8FlT7k5HjS5Vf0MORyVFM2HoGiTZCn+EhGaTcjuSS49Db9YkYugGFErVcIXfErLgfSG22JDijXhFOmv0IZPMOnb1Se4qHHOygZUUH3C4PyPUhpcXUXvSuIl766iedWbCVsx/CoZfbkbfmYzwLE8uTy1sL8BxsRlQiFbtcl4BqQ1Wxh0H15H7FWBC6DJKFERDZ9sLmBikauSW43Twg0KYiQjaZS3netKsBQTfvXs6W0EgZlNuduPXg34tUOrmkhjOl5sZyPeklcJ+FsmrgBKDgVBL3tRBrwAL37Zy6D+yC2Fy4C4ckjXJ6MrFAwbR87+MNqXAsHJP7Vnk/Jsei6JNuShMSqMH/9wUOYlg611uKoUahqYpLHDGvppR+tJK9xJp4FU/bhCuFVu91BBagTDjtD/xaIXmPOWTygNprLTmVHllnk1TB8aH9m1OE3ica2yqFDRLYp4dhKSa+X3Ep5oFCWSol9ZCNQcFKa/s0EMIORwk5HjlEuvC/uTsbENqXWwuQJSYcUT3a3tAd4212/F9m+RHL8YphfdbF6vejHLYDNLNel9/amtF8mgsaOqeqSwkZpelHjRSDtZtDayCaaBfJRVSGS5IYlfwi++9ZAf21+qF3TL/Y3owjNyFZKfSt0ZSQ5/aegh6ogMeffPAdMt69uGBLNwkX78HakEPVj2QQvjZYsfJ/Q4PV5Nz1PRTuDvTuZGVsqFMr3HaP8z6N+SxAUcizptHDSSp/erRfQdigmD21itGmMnzUa73d93TGmO+uxsoO1HDKK2rqpZ7JuyVICgSDx++BC0dm+MQWK49ornBjerELxfY2GD2V8IHzw5xOjEXAdNnnkA40SG09B4G7SqN5C1I5RBlTXaE330nrRMXP72k970J/xugygkeq4vTjAx3kLzieAt+s84NKvhZaZ1aN0jGx3qWXCCMem3J9C9UA6xIm8iROKCRsBxIIL5qzm684wgzV9SC9QAwmsK3g5wn4gzSrw9qWpxenoSurXJY43JFVU7N5+ZVmQOm6LE5bI67AAAw1vxmUEwJmgfOLhE/RcYlB1TFkJn9ynNB5m6wW9FkrcD6VavM20q9sIVPqi8vrm4KSvyWs3YKI4pFzDLmxKrl+/svHCmiSM/hPI45AoA6k87SBObMvhCEeoOeVU8urVu4rQHQjYgCqEdWALt/6uAkK4I5dbeW5CVKSZ4bWToPpM0A5i2Tg7zMcv+5M9aw2uQJeuDaNAtZZ0tD02ihDglHDWr9gphS/nSnKvDwr5xzdgT5FI2LuUswOc80IKawsiHuZWnNrf+aB+H3kl/RkxVJnmrS839VhJP1F7/cn5LPXLxXVmkhOKMBPDGgX31Ixj42NdAu2SLUSGnrVUIWXejltVWKCztvOHVT5iCeYKC9sVzxjuyiFW1bIb5EYH1ws1AUovmVlE+7511VhY7bV1OBTllR3j44FQ8QYiB0FCTkUd0xry+0048YZdjZztQ71BRx0sge8VLC/8MfQ8/eC3uz2A2yn1jxC3MzXbtDeVnlcdmY9Qo/dIqYZk9Mdf8PzkCpVKqrKtTzBudQfpIUeXDsWw6PG9J/AqR3KW0R2c9N1iEcaE4hDxGTRjMIKtXMg2ask0ry3Oz1bLG40+gK3KjSI3zG1hJ9KeBKVdJ8roRUjgL4y8T+2kLmgrE+jvmuHTFAATYiabMnBUmrARjMeDcS5bmcDKwdepfMfzegjfUJqO5MUsI4Is8GGcmpWPLUBWvx+KTcBJXlSo6IBbepQCOM1Ukg9oYAp7m3r1hVvHP6h4CAzxyD/N5VwaN+8JSRA1EHLMwsXLWK7o1AT68+vYFoWnZiZRaAgziQWPyA9XxdOBN4UVJTL8mXuBZoeY7TRz2cbvd+20f4I93pbYuEObjvsBO4nAD4zcpaLnKfmzkrS+U4yF0a380M6OwPNl75SoZbi+8/xFxbz8Ug5fbTt7BeULe7CAtrwG+LgxDQi7VYRKdN1VE9B38+kC7dv+vqQRiEmbXLu78OXQKOFYx1rWCQAJzI4Xz1eyY9Lsj6FEAB0MTbI55nBJncp+JYZbVcO/mASMfDm7i/+zj+ZPAPja9SxlcsGWBAPasyZ019BAOXzi8bFovd8ao+qIQNc/pdJXXp9H4CW5SHHarUli+o8H6uJ+ZD0x4SawtNwLJhWaPS7k27p8zB2bEY7PLVIwyAHwBdJ4d8a5+agc2kht9nmWs0mxImHalMyNjpq5BFIIN05y9eM8naIzcJpdgBHGDnBsnGVUN5i7NhHufmIts3Gv+aN8Gx3X7R3vxvufZOhIx93uVIFZ2LpLUl/NlBLPuerz0T8h99m+u3RGWVFqOBahWzZd2Jxe/hcFR6WwU/G6rjbGx7vq6LJgq78FmhXrHWij7gV/xUfc7dBfKYxdXZMWfNfiXpH1st151xkE8zINtMMaxY0zizk3hlrw7aIAfzDQ+TFv68yWFYGRrGuj0WFmAnyRdzcpeEyu7Ps8dhXW+1jyAJKaMGn1UVRANVTKzHD9aLg+npUhDm2Gb6OWPGB0oMTpBw3qnHVKhBFhLbvf0S8d+2X/mVBHnIX+TO9BTqAq82oedxWLysWDTl2/4MwmMilh3dHsAVE4bXyWEtUpuwh1w0L/dcPiM33JPhePk2kvovXExHRma/8jwKtqCmd3Dr6g2cXHcZRGEamz97sDInPTkr7ncPmtBocA4HT3HKSuWWPMIQ15oDBA0DSx+9Qp2KpprBqe1XswvBvcUivfzchUeVgmiWFGKlX6NXKQSGbylfT4JS/1Dsxk1VsQXwxlZSRptFTgnPqrTklJumz3J7JPtc3L7cMRIGDg3EBLQqXCHf3terEvmS6oy6DiKsgesPJ4W+Cba+4tB4tzObGtLnfbROrXNdYlpYgshRe6zRHKgShZs8vCWL9HMjS8bQ4w/707GO8ctInJs6rakQQiVQECL3XUz/GnLmuMUuiNZywYJeUd/FdZdNjWz1mZXhBtwq1IAd4imbiXjxmpMoKTj+puuoyQHG81br0iHUZfIr13HOR4NcwQ657ioo4vW1PJAevNqlyWrjcxOi4FoqZpBErraE5LZRfbtOMeYn0uBZCNSEiiLO/LWnTGFmweXeb+x7AMkwWAjT9b4P2sBhu+acfEKcX3PwWYboYv7IdO449EdjTEeb/lX28G3th91yda+3ULgIX+iMpq9esutT8e2heq/jFH7dzRchbxX47+c0PRANYpM+btINkeOeWmGaYbpYr3WawzrF4M6vtlv00+qkx63kCkqXafkhw9dOcmbLzVP+BriUSO0cYmXzKCEk3tvhNdUwVED9A2J+ky8XZIYXt/UiRXU/NZv+wEfJluRxq02e1VCHLQQikUE64w9+NS14TdU4vPCboC/bXYq+UrMKrxglp24wAuT/f/O2OYiIpadMf5hFoVb/93/cJ8DEv6o2pzWBIFVSVTZoLOb8uUsP90hkPq8eSNzzJ81esf9ozgomTf1Bg2q/7Ye5m6jdXhwtlHHsSwtEDg974yrFDGd+M3hguBi//8ioAeIAJk/8MrszFmJbiV+l1pZ59PwIYLQNTowOi2X5soS563T0CJHRY9Q0yHC+Ah3k54ZxWJUXWx9ENuJesHom+1Iee003qIQDz40259zXPcWn1lHc9wjlQXhjQeRQ1ZwF0A4WbXszi3WWHrVg+9CqIOLREUsC6s70ERBwRzYuM8atqlsVqGz+5HWoFIugYqFMcPbGaM/lbzcIOJoAsg+lDU2E96+ZtOPMukicnhNsZKkcLtWFwtLITRobowLuHV67NLLggdz9gifLdzW0rrEyL6nJIxphlRJqu8M8lHu5Ps5qqE3TnEQAaKIFmZT+QJa+Kqi8+DmiKvuCtZbIB5zkIUW6+2lDc+0sp0i6fJnUNOB2D2uIOs5iPhT7kTjz1kDINAk2Wyc6U7gnYkaREnkQ9z0LrJHbp8ERI1NMd+JzbXPtYcG2Bj+Co0KBBVy82sfc31d8TA/DFcOIbz2GRVqOuI2jUhGaNuJT7zqHD69GnBLxSdvFnRGQ7drVdvp6i7RW8+29ZrEyw6ldBMPkXFZ7J3Ysk7Tb+0kV8TZIOlpZ7O84g74Pq798rF0G+nUnQgw2RuHLB/EEt5WF8vqSTDnLBbACLL9Nh0aBEMptwRhj0ql6BzEny+lq+EuLqKIMtvOHfxZUF2vsdkgTsCIFDRk7U4AydVXhrZGhmVSMMU4hr5BXkm3b0/Rup+mgl5VJhnEam8x+IqqZD6Vk7XAiYaDqEuKvqHa6B0fKng0ZSoqLSPnvnJpFfSvJfVxavhjvIZyDMZ4kE1t2Md4Vt8H3SRmROCxC1fiyKmy6SSAdt/MgJmywVbx+3JuBwlCX1dZ4sOELYacLOm5Ke+mezmK5GH4N1cLhp1ZaYLHMzJJKt9jxu9cJtJ7xEd6/f2/jtj7gF5Q0DexEdamYtr9vOCpSvmCpB77RRADs2FnMtrXkMPOeqbAr9TC27tRJPu2S9JLJO70vy5Th3QkbymD4B0q98PyHxpRmZBtPP77XJ+ARowo3zKP5aZllH3aPBxMBK8R2niQ9YUY4zIaSwc7F+8NO8s/H+YzVo/WrOgeeJ4DgVekvP7RzaLnE4Mg2/SLmYMljHpz1dZ2p2lYP+fmgx281xEgpJTsaYT50/KYC0Rkt+KU1R97JzOY8JCYl7AzriD+h1Iq3p5w9JvyPUkBYCAiqPTQGKl4PnOordgplw33Mgnmc3+GPkCVll64QtCl7Uk5oELEcUMCGHlqcj5ao8apZr30Y2P1wLjTs7e21pJqTaQ3/P4wW5BHQGigkF4GaAoIPAGIUelmCgVRKH6nbd7lt4HE0OQKao9sAG+KtI0ZJPb/h26Bw+Og2bEHwyE07QT6Mtg1KGyvpH6dPNDyLjIsDqZEz9RG6gHax/ldZYkvnUUPaE0+SxGc98h+WSpripdnw50AdU/D04e3AZRKtySFMhh6lGWuuE0JE6BYZhJ+SvDxP+7MmHFvYSDyJXy2/iYqpmHAdJpjgUjES2+bJ2TUanLzYLToV0aEvK6hc3LA8FpnuxrMaEt9eZTTHOQlLFWRERxsLfZQg/StRMWRCsbOTaERMPV2J826kJ6w/DEBObumdGwSSB5rGALyIiyp6xQFpaeTOP3RXOOULwiSkoPPkLcE9SKmHOv5ADEHYOrtyA10Z9SLi4ZTGo6JK54gBuaXVy1wtPL77D3y4AQ63hUNb1HzqF/vfSUXrMk603zNZ3LwT/fiKu6/xwJjk3ERRAYihkYkj9l3UgcuU39tMtUgHmRZmwIh4YpBJGUOl5abqd0xS3eZ++mhJnn++NCZIB95W8c11xuaTJ2DPB3HazCJrtD+C5qYcwhhwvho9wogclpNw8gBIUFfN7vvDQ71ybbcdOTG7ckZ9VnG0asXwoTfwNmCL3VZw1GTRmBcV7SXSCWlg4DnEyEPuaL7A0gmA2+StTBpDO1wFxQuAU/do5I6mP7MeOk80iQrvyz6FfYxQMjqjiVl3pvzhWentDgrj7txkAC7cAL4oAAACOe6OnkgzjbSj72zte7U0meya16S2EO/zLoPA4iGopp48JdT3HFLdl6545tFMCmgNvjOeHgxQgEwDWjnbpcdZmU8oaQy8dnZPzQik0dbBpErcCHkeTRZQn8rMoG+HDb2zaFtIBkCTnXlRvaY/yRVg3+NIpEIsswbfInJAWsPsW9DZany+TOaSslF1VZ8tXMWe8B4TrS9TapTAO2F2pxi4d/2SRIvMX78S5R1CjcISATHHlNFsNo/SGBsVCXjHswwFIs+fUfwJJR+8BBbdDGviG57et0OfQWSfWH7bMpmVoaO5uhsuFFm9xsEbF8/b5L8xEVIJo/a9IgQj8uNnd6dRd/CAfdEWnDPTK2qMkT8L5JjwIbF7JOVptHJOi4EdTQBCv2uLdNZMHLXbmXT4V7JBnvt0bGaizPH9HUmf2eQYzqUUn/JcndUbEWe4kKEygdwT0qJf3nqZhJ+5a/WAWxHweyYxm4tsHEmY0S2UUrI8qIOzt4ckQW9/EsQRPshDRdyYeP84zmDa1/HuU+iDEjtyCWWPJtr4BeXQXUV6VZko+q5AI0caoIQSGwYPVHjRL5hLxh8+JT8DnMuL1JLawYBOAYRZvmC0fI4SRZ3bMDY/UgNi5yPBIuNcfBDf5mHxoTvcGK80DwwwflT6car6mO2pArC8A/J5IvLeTGSWToJFCSCckqKsCGH4KDcoYCGoEsXC6B9ocCB+kTelOQlxXVZp801XbTeBclkuViO2nKaZVsCAR+S6AmkB67yc28A6v0317lNowaEop+AYRYCcAAAAAAA/7+NwAAAfdcbgAAAAAAAAAAAAAAJtkAAAAAAAAAAACpq1KU/NUtUax8zD7+KD48VnmXjVRcxplka2x9ECVT2m355rjd0Odkj802UN7X4/eQ4RUmdd+PktPBP7XMNCiBTjQF/lZpu0LB0V251wN5sNF3iCy+58n9kub1GI5h8T5CHX+12Om1QEUB5ZKXlUeMQiH2ZQpMqquQEX44QAAAAAAAAAAAAASGobYRvfzct7RTV5awdPho2F6y/fV3n7D3Soa86mMVzHTlzyMeZGuBS3fwtipaCORy9n104i6eHnHN+y9Bcxxhiimhv4JU0ljpClOA4vQoHxDmqH2HvQfUIgpW7bYGXTaWI7dUcbGhRyEWTOhPjb8rwQ/ewekwar4sskXfcjJWcsxJsV0OmjtstAAAAAAAAAAAAAEK6U1unoQCddGOWdjlnv9dN29CmJiE/GUvCbbJabALToCDtaSfQRVpT0/yI0NJfqIqL4TPsBUrdvL9+yuIlF+TFx0RH90HEhtRtlg5Id94VTZRBMCmPl7MKYqbSdu5HV6mPplt9Ntg4J8QSJcrGW/9IkGB1xP685tYIzOarjBxXUJZSd4Vo2c34kxfhNxFZ+OITymDEp0A7uGwAemekrp1LquuBwJxeAAAAAAAAAAAACpqoLcsBZWu53svpBqq0rRIHW7+HYMj8Mja0wgTMqvPs3LHdWql53emCfIEMSg13CE+MXAf7fy6Y1+Kl5/BAMYmr9bAOWruVKf66HAxoXIr1DXUoZd1GRrR7QEZPsAVhC+SF5dhoJtU4p3+0rPD2nl+67VyKNEmSk3pnk52neHkSP7cBfMtddHPoV8zv9LCXocpWUHiAnPSVIYZbXul0bJcLpbfYyLD2XjkuPCBokzwhKgnW4cUA7e6VM1rCXG6pHAYmyAzImrQbT+YOvd4TBHXGukm9nu2iQOZ2blPlPGzTU1uNx5mTmDO11OpstgShVSQa2piPdYdYmRfBhZo8hgPHVSaLd3+20WgbrQ4a57vKjE+O3ehaR3fVGEQUJbNd5EPfemHRwQFPhKSANl4tgboiMZbrDUqvKFj//Y9GfhfbR2eAyRSpQdiBevszATzjfZGXhBiCoglykzNQ83fOsEpNOmiq3HKA1RumZbR4kY9oumipxIf3gG32IBGZnAks3uDQIO3BdEklEaIdrbUExIINetQWqdPFDq+3sdFo7v7+BzW7/3zQwmIF3YtPQlN6G/TheDsce3HZO2ZJGxcDiKT1TuUdbASpiyQS0fHcZuvgDKUzwnUd+cEXqFt0QvQyqx7GOjAzwV30TeDP4ic8M76uAK/EQ/8bJBzcuXo5gAemkyDR1Nbc9Z36n9afW+jUHApbhBpfwRkNIUIT13PAWigEXqQpe7jL7uIa8V7u98/pS20oceGlx1euLkafz6EPgAAAAAAAAAAADqrBe7LWFG2bRClkEAQEW6n2z3zUVEfe2QoBuAiEXBCiIF/TXoVzkKg1BKE3Ibv29YLAJXdYQJAB8Sg2WtA64HjUWozuKJMKLUZ2eSwJKPCi1Gd7WDVuNJiPEYpFggP09achiU1918laEO5KR2224k5JCbbqmt0EB+/0J1aqa7vkCMpfmt6W7mkOM0KiKAPcRdQa1sxoaUDizpsf2vCC2tvslny8ILb+nosUREtTDbD335wfd4qhUWokoDV5lriPrYhmv/kCRdaGzvq+dgxw66DMovoUOMFeXLRBMaoAAAAAASCQeNvo1ChExevN0yYY2RLqlYHX7pMVknGJXau9Y8/u0nYTeJkMKaY9/Eyl37kMYTa8ngidDelohYzhB9BmwBAbWyKeBCKqyOItFEj9IBDGlquzaI6xjnBDk5T9q9ytT1yv018TRpLsjYOQjADl09q3N9XApZplA1luGlStAe2SznxZ7UYiITlOduWTdOOeg6I49qVHRtnQ5YTrO6UjeyehNhXJc9GnKlaOaPaEYYGgsbJUSHVzD+6D847QmoK8OuvMWlBRb2TzzziwYC6XrYHDq/zJzAQX+Kecd4z+01Hn7lFUTwuKHhpoJeV2+F4su0fs3XKxE/eeA5FMwfs2ql6W+dSG0puldnhmQ/1eKU3FMRAW0abnuvAuxalOZNmk2ADR95+XIMc++sVTmwo+lzyCrR4DxHIni358CGsoDzKCKv3VHV5GkZFMaZ/cmxg4IXpS/IMOinLvtXSsKE51v/kfkjUipfDUyWTdaTnciMYLqiqx2M/OKMtRfL3LMgiBAb/Hs8WXTmr9qP2WZqsUVONLIQP+xn0f03P5YUSvmuSNXjfXpYYMAcFGnelNbYSNCEnu6+avanBSIuQF98/P7d/6X06d3ZlDnzIq3I6hn3duFjzjFeUTKANnu2zZp7xqFDZ9fRFbWr8m8GubG+NMlmnwxR9yQEYayZl62YQK9g3EUlmiXINOzjZrZjScDX5t9RKgR3rh0HpaY7iDuhAFo3SG/FZuaR3z+iIGfBvEpge8fvj6Wd94cCOkUko5fNVRK7tIs2Fc3i0EJwKZ497bnM907EO4+uL6fKpb8zZ2NZSaqllgbyd5RRXGDJMh5NhNvkUJuVSfViG1Q1u1gJ/ExxakcMgptqmvSP93AesSQc0wZbct1tUO+1ajZvZG5OuGVHyrmpHbIM9pDjmpfooWg1oymyzc5zQAxe7LHoSBfnjkW3+MQM7rTOPWqaUYgeIQ2gtaQPMBmRHPyTBbeZ72XmUu5+MIIeq5fLzcP0GXQNuEDmuPxnEWN+mP+a7C7kha9OxAdh/WCkWNZwD34W13w1+xaHkocbgPwMCJhQZ8/YmSeQDp8WE8hfl23+R/QGwDD1l7y5rxfPxUWwTsV/3XW/m5zOYGNDb/GphDiMgA40qiKyBySDyOeC/25xHuG7oRivHEbi+B16DphZqJsyEyPkGd+CuLHE8gkPJIYhx71tp04rFS6dkvGMzW8BKFSeuQvssRNYATytX/fPMTfRcXKk52U/JacMBhHuPOjbEoYMGSauu1X8sqZAOY5lscp4Wxa+4ifusloESPm7Z8qtRHVca3jStZTqosrctfjrb9U9p6/rGjPv6aB+o7NZ995ykynq2nzbgEAxjCquIaquoJAoAa+VrT8p11WM7V034dCSP3+vlgCwTXFHu3Q6mj5vcbjghDngsqt99W5nKPi1xvzProR2IHXrNeGDBy54y8Rr0JMMkFWc4ZpgVFkgkavED1ZBpK+rBRRlWjEBhwRG6VirobFffklWTl5UQvruAQb/0+ASCNPOALMdI4WAPpJry4hhOhy+TE/A3+ykYcQGAfQLT0uUhbBM/USTyFyD/CAccQiq9HLVO6CXMSPhaDaQKgraIQ+OgO8qyt8XRaooYP94gfPnol1Ai/RHZYXVAE3RiKXhm8/ABvdfJkqmO3q6hBOndOJ45n74lABOPPioMnpFxrvfFVHl6rW+p+JpJgcnt8sjhpoOV9Sn48Ee3ObhyqXP9YpksFQNaApwTNZzkdPe4oNAcT5Ky1fUlMI6bR32F8zsTIxGvuRN3iACGqBLe/24BVP9mKuIOLeSRRPOOnbgwdGBac7wb9N+LUy1Vs+M9iaU8apSFl654VzosydSVgpknc4gInnU0GIReSl3E/ThV/XUeboc0fOEaLLHVf2DrnjY64+/dDi+NP+CYkI9m4jKlRY90xlPTcPgl++Q+8Thw2HKriaz5TctF33lq/+m8puaeRNiy2C9sttvrVboRGS6wkSS836bz9OYEM9ItTncKDA1+bfg186a6vQjlV4fYUEz0umlN96A+Jbg3YyzADoFV9Tpf6AGs5m1xroEdm/NOR1NR0fLFz94P+bZ4ldtepaqWfkbE13cu3qHMWlcV3O05c3w8yhqxFFI7EpQolPSoBoLsBml43A98kvrGiHEKyVtms5b2KmUJ9jBLMu50y5Xm1GaEfTETCOPB4uh+Sw0UqYT4X5HNN0cq0BBysUSxL7r9nx7nwstUcRCHRE7sxm9tf8SvzCBh2KvvI62WzW2qMBhSUPw0oUrs/t3orTAFY011z9gnkxd3BPdcMuu3oYSZrxtcwYhzSt2gdGeCdcVo4jzmsELK6yibUG1GHU/2kNkzXkNcBkjoDO+w3eGNz+QlteD4St+JV9/a8Cy9EZ4iZgdXjmoixiG/BlehKnJHwaGg6r1kvXEe3lMksu73IXPlGlVmqZ1EFLW4rnEgFedKj6i55eUUCF8kXBQIDUohMwg+29yGsJUvhvchFSXMT9xqvPQbOik2GErmNXD7lpXBdUvW+4EZdjrmH+drHnOOyiBTXx1jjqoBX2LC43hRxHcYaxh12AFMhfS+VhBI2yHRws53Itxm3eP3nkP7cAwQbq2r101eP7ShFZmqY4n9Z2XsP2oxWQ2QWpFn0hPuYFfUq0z01yZmDS3kOnu0ts2BwonvIDAgfu3/Xnl3VMQwt68qB/tFRNjNfvCdp9h7qzKgfQFraac1wImAKDNt/UdgKVYZoQ7wFuSF44CgOpuPp/B8IFx7r4An7HfnSrR00KiJ0cX2ncwct4WtYFJm1FiXyT6iuWaiMf6tiIgpnQ92cJEdR69Erm4jOCHSNuZ0Tq4St86UzNeJQc3GNGg9JEhLSb09nIjuhEU/e4IrMZOtJy5gnP7fbjHuni9zgslCAnPtxxGXbqdRE0rP52GL7+wM69PJWLF/WSy70bcfD69TntJTH7jIMKVCZzLB8oaEIuWo/2EXsb0Xe+tcKqmyFuEDFE8t0fkcaeBe2mmK6Hdz+YO6XvMjP9MNu5K1MNYP1GDKwxXzUw/UthT1TMdURkBNoOPVrttse9FAhTXO9gpqa9ZgLRzyAGyZEgkBmWxpQVNWeKsECF4bsu3Hu+sVNoFdODpTtR8n6TenOE37BTuEL8lwRtNCZFg4k0wAAAAAAsGkb6DvYBe9l5NjSx0JRRSythOzJ4AWmceVQq8MHCenB7o7PiJTHKLgbt+s9dUKW/EN4qnUdgpmQAA998d2DfG2C7aLvOw2DuOK9/UmHqTUbX6xrk2sXMW2O9gEdBhm+CFwFQ2B6tLWHIJauFVT8VbQtVI3YuHMP6Cn/eC4ADf8ALemSIX6SBPGnRjwpd7lfjCZouMzRWlc9kAAAAAA7NIJm13NbpPaSfQOfasSK5M2CQlxhvSNrazWy/St3PQbXtFN1wzn5s314N+HWVJFTRrrv1xcanLARZswvIlDx15jyIGbzErJbo7+NkN6HSfU0idkr8Hr+Stut+pdREBOXo9jPUXF7Zc/sU+pjABmCZSkCxjq/SfCOhaskWSH//QaCcNOdlvkZ1/OC/JLnePa6FHE6jjkBSQcxPXFXQ+KwYanZnAedEOzQz456PZMAEPMsURPqSRQmZCPaaObAamcaeObga50ZtBzz95vuF9WO2y0Qu1GMnTLFfXAT8M818qADBfKTN3wpUv7CjpT3CBY6ckY6bHfmhvFjyYiWPpq/UhA5AZhP3MpTWBOq/RMFL3lvKZrxm90NSnUg6cKYiOeHHShRFWlxQtdPabiHiT8YC4nkTIsi9SGNNFnj1SOVXP7C53FfEuEu2AXBDBF9wIEnsZX6q6tDNeXPAV9WlPUO87cEFrRmF4xkjGJkNPVyByj4uAhR0ZB1ETRBHc/TD721IDjMittLaRSe7NUAVv7mc3OU06LjldCRD1lR4FBrqvFbIN5zTn35txeMxK7mh1M30pwnxSPO6aDtPueXdG7XZVbra0RFdd2rmoXAQeZwE20axxIhmH3EQPj1G3/QQzvH0LEvLAmsFcbxaFqc0oHHarJiB3yp0P739muEjPphhZ641tc3wpJKaL3rlpm4nLUJRc2GZwTiTi+35UHCy5o4XasOSHV4LSKJsBmKh8HCAJt7YxEK26d2C5CxRv4XvfvNYtPMM5omEfDXnYcmwl5tv00rra+dKprxMAa3+RlkgC8d+GMdTwZIcIQORza9ADZFMzIUqvNzaCGoGoz82t9aIvf58EIn96YEWyGQYU+FFJR8cNCU8nI2DPq2Vasr9rELzPD35ApxqKw2nAqdcfqb/FbAbRLl57lDtt6Zdvt1q8GyaflIZQvMy0EU3mbouDyOeCmk2Z5dxTUV/O8Q0bQL+pimuNL5g25BeU6Egim8Mu0h5p0Hj3cNuanGC4Aedt/Zj2J9e1WtbPnUzRcl/9QWSkuvX2PedMpt53+pC3CMHdMCQg5aShR/deuTBtzZZdWBFpr8KTAYTK1S5rXzAmRTgofeFm+DnvFuztxB9VpZiJHVtr4qjO7M7shqA+MIzuy6hAsaY9u9zU8WWCwg7CoHlijXVwi2KaKwBnZaFtFYeTpJlS32ryFXjr3gpv8UgS4G03D2W5etcPh+JVgZ0Wup+nY2u/i+u/qjJpCIS61rYPCtjYFLOAWECzVetPHPipzaBAfNaaUZu+15X27vaiegEdEHg6ylGsSbgB8G9of5rv73XkcbMH2vIwLcfhi7nshnqvfukMjVNde1A2t9qleP3IH6SULDsHH1ne+u+1gDZ4vXe5DH/f1MgoHXNvIntm9ZdBhkq+HdWgz9icPKYfvasGpQQYhx+LUGTXelS47egGrUGVtvyoS9/6lIQXW93RI4JK8N4E0mLElG7S20LdLGJoJl+94dVahiL1BjVyWNacaP8tjRgUS3elnuqtXEKj+JVOJpk8hIbRp/llJ2fjb5k+2r++whyLK9LZ02JyTt330R9zXugk/UESc78m8IfirX2yP9G2PNfJ38D1cQ4IqwLZkD0s67MVCEQCBMG85Fd//Eb1pb1D9bw36vzXIipPozemHI4f/d8qendpSvFtbDVulbjohvDxDZGw2DTUk++Mv1GClf05hzQfll7jBXDHOnApZxpiMLf4N2vU389ggctfZ5DT0p3U0He4tNIbSEQUN0RMBWDif/LXkMgvAb8b6X1xdzRnXYKY0xbqYDukfI/83jdl0LH7f69RYZcZrtCVKjwT1ICVRnJiCEL+RfTriZZ/LlQtovUnLnCMbgwp+O9rbKEYHtf70ni06L6okEzpHV/x740ISiyKt3LBJpirAfve8kNLngF9kmyetzrjwkYKoxJW87w1hMoqThBT2HStyjby2jSJDyEcNA4TDbQ6/+et9fU7TyCRwAGbk9hCOsn7bEzVcqW/NpGCNdJqGzPusQV9PLSuCDNhic4AFcycvGT33tZ43ljUq3OSwPOlgF7WyHpofHC1MtceVZSqHmkbaaiO8J3U8KpY0wY6OBW0h5+U0dAMQsY1ADC0fIE8Tw+bk9qS7fR2PfQMEGhOThH3CVstFYpMpQFMNdagdbbNYWlI9ISBCGgXFSbhdOh82Hj481FBy7oZ2ecyDM0YMwDfDEauyTxT1x41rD/LTjdoW26Rt5E/E0Sj+ouwH4fY+Kw0fJ3aF4eoQBasw4YqBVXtrbNDZIRgqkr2VO4UrgaVTAPFFWFEFcy2rnMpmdwTnnB+iRnZ/VlghnoJSp0wn5ZKQcmphcAOtO8E4oMbI6Lb1TFZ3tcbx0k6OgUHp+g4QpcpLFWQy7Mj1X9KSm1juJCGRBVK9w9FQo3diJ6SX7WS5bdHLlEn1+pWloT2TNvvYVXVBzyMPRdpDqMr4bz0830czT/zXz02m1OZCKp8SbrsZdY73mg0u951UqOYj10Obe6i/9DKbyPTrYw+ZVDASFRvolEpb8pUFd0yQVVRY0+iXdDRmmwGZSpifDQr5msYFC+lqZBRm5PLAmExtLjQJvyLJOUVAM4SIxvYzb1jRlNxCLOmsAA/c3bIxwiehPjz+5mVtJnwwnrz8i9EHQJm5sQW0b5DU3dSt4tz3HOULqJnelAy8V1LVIQYtEtXzd9y69ieuw2/aw5YlzDWQvQY+Ck5XQ0kCcEx5TDLz0PJC1dKWJ9t19qJID51jyV/cGhvQtpI0SyjIfmF+RJsxo55SQYfCMJh2eicnoia6yzQCqGs36AYrWnk04GvOesprc1ZKIRZynaseAAAAAAFWB20P67WXGVY31MvC/UBgSnMs/ij2Kh+Aoc5pBxtHBksMXQ2d9IxOINb1Hgf1sUk03AbxwySgZAsqrMAd7kErktg1XJAHJ4ugFeimUwC2Hn+FDu4FPn1s+jOY5W9Iwo5w4B4kpYQdEUDOwa7i4x3oasGsF0PIFgJwV9i41SrQcjS6BTj+/uMP68IdVhCwa8VR2orox2s5kcooseun5DevJQrEoNdm3gs7Yw/al6lDKAd4AaMrbeVi1RVhFlCwIDLpMyE3zDmAIfwkcVR4j8Ft4XunbILZwwjCWXPeh3mRs7CAxTLYec5hhdNOsIRnzkEjQXQM/jGC9ioW9ijr4sED7dbxO7nN52EOIaGGdeORfUjfE6Cim/51wcjTMGL9SnE1NF76tXhB199lQt6HAlK4qrG6wCkrZozaGupE7cfjF9j6B0nLCnvXyS3IVBgkdKEXKEyQNb5c8yyXnuYG4vS2CrvRYmNAkDQqvvtF5GhhM2SqaryUKQMzPrbITiVCDANMLJst+hYIbP+iQrul4bgCumpjhceEANu39QhKlSNTKPcygYDzEUKum+P7NmAKlndwHlS+B4AAAAAAAAAAAAKog5C4AAAAAAAAAAAAADh8AAAAAAAAAAARVhJRooAAABNTQAqAAAACAAEARoABQAAAAEAAAA+ARsABQAAAAEAAABGASgAAwAAAAEAAgAAh2kABAAAAAEAAABOAAAAAAAAAJAAAAABAAAAkAAAAAEAA5KGAAcAAAASAAAAeKACAAQAAAABAAAIVqADAAQAAAABAAABiAAAAABBU0NJSQAAAFNjcmVlbnNob3RYTVAgwQEAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+MzkyPC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjIxMzQ8L2V4aWY6UGl4ZWxYRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpVc2VyQ29tbWVudD5TY3JlZW5zaG90PC9leGlmOlVzZXJDb21tZW50PgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KAA==) ## Summary You have now successfully used Genie from start to finish! In order to apply this to your own model and situation going forward, you can use this as a starting point and tweak the notebooks and configuration files to your situation. 1. To use a different model, consider starting from different notebooks by searching for “Generative” in [QPM3](https://qpm.qualcomm.com/#/main/tools/find) and expanding all results. That will show all notebook tutorials that have been released to date. 2. To quantize and fine-tune your model via Quantization or LoRA using [AIMET](https://quic.github.io/aimet-pages/releases/latest/index.html), modify the Part-1 Notebook. 3. To change how you are preparing the serialized binaries (ex. to spread them out into smaller files that are easier to load into memory), configure and modify the Part-2 Notebook. 4. To change how Genie is used on your target device, configure and modify the Part-3 Notebook. You can also leverage Genie’s [profiling and benchmarking capabilities](https://docs.qualcomm.com/doc/80-63442-10/topic/profile_profile.html) for further optimization of your model’s performance. If you have any questions, you can ask in the [Developer Discord](https://discord.gg/akBfTuX2bR)! Last Published: Jun 04, 2026 [Previous Topic Setup](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/setup.md) [Next Topic Source Code Examples](https://docs.qualcomm.com/bundle/publicresource/80-63442-10/topics/source_code_examples.md)