diff --git a/examples/NdLinear_ViT_MNIST.ipynb b/examples/NdLinear_ViT_MNIST.ipynb new file mode 100644 index 00000000..1b54debf --- /dev/null +++ b/examples/NdLinear_ViT_MNIST.ipynb @@ -0,0 +1,1031 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Efficient Fine-Tuning with NdLinear and LoRA (SmallViT on MNIST)\n", + "\n", + "This notebook explores replacing standard Linear layers with NdLinear in a Small Vision Transformer (ViT), and adds Low-Rank Adaptation (LoRA) for further parameter-efficient fine-tuning. \n", + "\n", + "We compare three models:\n", + "- Standard ViT\n", + "- NdLinear-only ViT\n", + "- NdLinear + LoRA ViT\n", + "\n", + "on the MNIST dataset.\n", + "# ๐Ÿš€ Project Summary: Efficient Fine-Tuning with NdLinear Layers\n", + "\n", + "This project explores efficient model compression by replacing standard Linear layers with NdLinear layers in a small Vision Transformer (SmallViT) model. \n", + "I benchmarked performance against a baseline model with regular Linear layers across 5 epochs.\n", + "\n", + "Key Highlights:\n", + "- **Baseline Model (Standard Linear):**\n", + " - 5.52M parameters\n", + " - Achieved 95.46% accuracy after 5 epochs\n", + "- **NdLinear Model:**\n", + " - 5.52M parameters (slightly fewer)\n", + " - Achieved 95.58% accuracy after 5 epochs\n", + "- **Observation:** \n", + " - NdLinear maintains comparable accuracy with a minor compression benefit\n", + " - Suggests strong potential for efficient fine-tuning strategies in transformer models\n", + "- Integrate NdLinear with LoRA adapters for even more parameter-efficient tuning\n", + "\n", + "Future Work:\n", + "- Experiment on larger datasets beyond CIFAR-10\n", + "\n", + "---\n" + ], + "metadata": { + "id": "HI8vIdChw1HR" + } + }, + { + "cell_type": "markdown", + "source": [ + "### What is NdLinear?\n", + "\n", + "**NdLinear** is a compressed linear layer that introduces tensor factorization for parameter reduction while preserving model performance. \n", + "Unlike `nn.Linear`, which uses a dense weight matrix `W โˆˆ โ„^{out ร— in}`, NdLinear reshapes weights into higher-dimensional tensors and applies efficient decompositions to reduce redundancy.\n", + "\n", + "This layer helps reduce:\n", + "- Overparameterization in transformer-based models\n", + "- Memory and storage footprint\n", + "- Potential overfitting in low-data regimes\n", + "\n", + "In this notebook, we evaluate how NdLinear compares to standard Linear layers and explore how it performs when combined with **LoRA (Low-Rank Adaptation)**.\n" + ], + "metadata": { + "id": "SbHar5GJw6_d" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Setup and Installation\n", + "\n", + "Install all required packages. Make sure you're using a GPU-enabled environment (e.g., Colab).\n" + ], + "metadata": { + "id": "ShvC-2GRuTJf" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install timm\n", + "!pip install ndlinear" + ], + "metadata": { + "id": "VsqSxi0ovYXh", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "bcc18ec8-759f-40d0-c4e3-e13bf91ca90f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: timm in /usr/local/lib/python3.11/dist-packages (1.0.15)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.11/dist-packages (from timm) (2.6.0+cu124)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.11/dist-packages (from timm) (0.21.0+cu124)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.11/dist-packages (from timm) (6.0.2)\n", + "Requirement already satisfied: huggingface_hub in /usr/local/lib/python3.11/dist-packages (from timm) (0.30.2)\n", + "Requirement already satisfied: safetensors in /usr/local/lib/python3.11/dist-packages (from timm) (0.5.3)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from huggingface_hub->timm) (3.18.0)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.11/dist-packages (from huggingface_hub->timm) (2025.3.2)\n", + "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.11/dist-packages (from huggingface_hub->timm) (24.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from huggingface_hub->timm) (2.32.3)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.11/dist-packages (from huggingface_hub->timm) (4.67.1)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.11/dist-packages (from huggingface_hub->timm) (4.13.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch->timm) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch->timm) (3.1.6)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch->timm)\n", + " Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch->timm)\n", + " Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch->timm)\n", + " Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch->timm)\n", + " Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch->timm)\n", + " Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch->timm)\n", + " Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-curand-cu12==10.3.5.147 (from torch->timm)\n", + " Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch->timm)\n", + " Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch->timm)\n", + " Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch->timm) (0.6.2)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch->timm) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch->timm) (12.4.127)\n", + "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch->timm)\n", + " Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch->timm) (3.2.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch->timm) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch->timm) (1.3.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchvision->timm) (2.0.2)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.11/dist-packages (from torchvision->timm) (11.1.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch->timm) (3.0.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->huggingface_hub->timm) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->huggingface_hub->timm) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->huggingface_hub->timm) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->huggingface_hub->timm) (2025.1.31)\n", + "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m53.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m53.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m40.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m1.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m69.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12\n", + " Attempting uninstall: nvidia-nvjitlink-cu12\n", + " Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n", + " Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n", + " Attempting uninstall: nvidia-curand-cu12\n", + " Found existing installation: nvidia-curand-cu12 10.3.6.82\n", + " Uninstalling nvidia-curand-cu12-10.3.6.82:\n", + " Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n", + " Attempting uninstall: nvidia-cufft-cu12\n", + " Found existing installation: nvidia-cufft-cu12 11.2.3.61\n", + " Uninstalling nvidia-cufft-cu12-11.2.3.61:\n", + " Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n", + " Attempting uninstall: nvidia-cuda-runtime-cu12\n", + " Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-nvrtc-cu12\n", + " Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-cupti-cu12\n", + " Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cublas-cu12\n", + " Found existing installation: nvidia-cublas-cu12 12.5.3.2\n", + " Uninstalling nvidia-cublas-cu12-12.5.3.2:\n", + " Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n", + " Attempting uninstall: nvidia-cusparse-cu12\n", + " Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n", + " Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n", + " Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n", + " Attempting uninstall: nvidia-cudnn-cu12\n", + " Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n", + " Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n", + " Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n", + " Attempting uninstall: nvidia-cusolver-cu12\n", + " Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n", + " Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n", + " Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n", + "Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127\n", + "Collecting ndlinear\n", + " Downloading ndlinear-1.0.0-py3-none-any.whl.metadata (6.0 kB)\n", + "Requirement already satisfied: torch>=2.3.0 in /usr/local/lib/python3.11/dist-packages (from ndlinear) (2.6.0+cu124)\n", + "Requirement already satisfied: numpy>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from ndlinear) (2.0.2)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (3.18.0)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (4.13.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (3.1.6)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (2025.3.2)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.4.127)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (9.1.0.70)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.4.5.8)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (11.2.1.3)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (10.3.5.147)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (11.6.1.9)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.3.1.170)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (0.6.2)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.4.127)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (12.4.127)\n", + "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (3.2.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=2.3.0->ndlinear) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=2.3.0->ndlinear) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=2.3.0->ndlinear) (3.0.2)\n", + "Downloading ndlinear-1.0.0-py3-none-any.whl (9.0 kB)\n", + "Installing collected packages: ndlinear\n", + "Successfully installed ndlinear-1.0.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Clean reinstall of sympy + torchvision dependencies\n", + "!pip uninstall -y sympy torchvision torch\n", + "!pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121\n", + "!pip install sympy==1.13.1\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZnAW06zfP22S", + "outputId": "69f0084a-e7d3-4404-e906-c67914422273" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found existing installation: sympy 1.13.1\n", + "Uninstalling sympy-1.13.1:\n", + " Successfully uninstalled sympy-1.13.1\n", + "Found existing installation: torchvision 0.21.0+cu124\n", + "Uninstalling torchvision-0.21.0+cu124:\n", + " Successfully uninstalled torchvision-0.21.0+cu124\n", + "Found existing installation: torch 2.6.0+cu124\n", + "Uninstalling torch-2.6.0+cu124:\n", + " Successfully uninstalled torch-2.6.0+cu124\n", + "Looking in indexes: https://download.pytorch.org/whl/cu121\n", + "Collecting torch\n", + " Downloading https://download.pytorch.org/whl/cu121/torch-2.5.1%2Bcu121-cp311-cp311-linux_x86_64.whl (780.5 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m780.5/780.5 MB\u001b[0m \u001b[31m1.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting torchvision\n", + " Downloading https://download.pytorch.org/whl/cu121/torchvision-0.20.1%2Bcu121-cp311-cp311-linux_x86_64.whl (7.3 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m7.3/7.3 MB\u001b[0m \u001b[31m116.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch) (3.18.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.11/dist-packages (from torch) (4.13.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.6)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch) (2025.3.2)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.1.105 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (23.7 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m23.7/23.7 MB\u001b[0m \u001b[31m97.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting nvidia-cuda-runtime-cu12==12.1.105 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (823 kB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m823.6/823.6 kB\u001b[0m \u001b[31m56.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting nvidia-cuda-cupti-cu12==12.1.105 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (14.1 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m14.1/14.1 MB\u001b[0m \u001b[31m121.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /usr/local/lib/python3.11/dist-packages (from torch) (9.1.0.70)\n", + "Collecting nvidia-cublas-cu12==12.1.3.1 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl (410.6 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m410.6/410.6 MB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting nvidia-cufft-cu12==11.0.2.54 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl (121.6 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m121.6/121.6 MB\u001b[0m \u001b[31m8.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting nvidia-curand-cu12==10.3.2.106 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl (56.5 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m56.5/56.5 MB\u001b[0m \u001b[31m12.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting nvidia-cusolver-cu12==11.4.5.107 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl (124.2 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m124.2/124.2 MB\u001b[0m \u001b[31m7.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting nvidia-cusparse-cu12==12.1.0.106 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl (196.0 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m196.0/196.0 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch) (2.21.5)\n", + "Collecting nvidia-nvtx-cu12==12.1.105 (from torch)\n", + " Downloading https://download.pytorch.org/whl/cu121/nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (99 kB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m99.1/99.1 kB\u001b[0m \u001b[31m9.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting triton==3.1.0 (from torch)\n", + " Downloading https://download.pytorch.org/whl/triton-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (209.5 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m209.5/209.5 MB\u001b[0m \u001b[31m7.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting sympy==1.13.1 (from torch)\n", + " Downloading https://download.pytorch.org/whl/sympy-1.13.1-py3-none-any.whl (6.2 MB)\n", + "\u001b[2K \u001b[90mโ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”\u001b[0m \u001b[32m6.2/6.2 MB\u001b[0m \u001b[31m94.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.11/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch) (12.4.127)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchvision) (2.0.2)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.11/dist-packages (from torchvision) (11.1.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch) (3.0.2)\n", + "Installing collected packages: triton, sympy, nvidia-nvtx-cu12, nvidia-cusparse-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusolver-cu12, torch, torchvision\n", + " Attempting uninstall: triton\n", + " Found existing installation: triton 3.2.0\n", + " Uninstalling triton-3.2.0:\n", + " Successfully uninstalled triton-3.2.0\n", + " Attempting uninstall: nvidia-nvtx-cu12\n", + " Found existing installation: nvidia-nvtx-cu12 12.4.127\n", + " Uninstalling nvidia-nvtx-cu12-12.4.127:\n", + " Successfully uninstalled nvidia-nvtx-cu12-12.4.127\n", + " Attempting uninstall: nvidia-cusparse-cu12\n", + " Found existing installation: nvidia-cusparse-cu12 12.3.1.170\n", + " Uninstalling nvidia-cusparse-cu12-12.3.1.170:\n", + " Successfully uninstalled nvidia-cusparse-cu12-12.3.1.170\n", + " Attempting uninstall: nvidia-curand-cu12\n", + " Found existing installation: nvidia-curand-cu12 10.3.5.147\n", + " Uninstalling nvidia-curand-cu12-10.3.5.147:\n", + " Successfully uninstalled nvidia-curand-cu12-10.3.5.147\n", + " Attempting uninstall: nvidia-cufft-cu12\n", + " Found existing installation: nvidia-cufft-cu12 11.2.1.3\n", + " Uninstalling nvidia-cufft-cu12-11.2.1.3:\n", + " Successfully uninstalled nvidia-cufft-cu12-11.2.1.3\n", + " Attempting uninstall: nvidia-cuda-runtime-cu12\n", + " Found existing installation: nvidia-cuda-runtime-cu12 12.4.127\n", + " Uninstalling nvidia-cuda-runtime-cu12-12.4.127:\n", + " Successfully uninstalled nvidia-cuda-runtime-cu12-12.4.127\n", + " Attempting uninstall: nvidia-cuda-nvrtc-cu12\n", + " Found existing installation: nvidia-cuda-nvrtc-cu12 12.4.127\n", + " Uninstalling nvidia-cuda-nvrtc-cu12-12.4.127:\n", + " Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.4.127\n", + " Attempting uninstall: nvidia-cuda-cupti-cu12\n", + " Found existing installation: nvidia-cuda-cupti-cu12 12.4.127\n", + " Uninstalling nvidia-cuda-cupti-cu12-12.4.127:\n", + " Successfully uninstalled nvidia-cuda-cupti-cu12-12.4.127\n", + " Attempting uninstall: nvidia-cublas-cu12\n", + " Found existing installation: nvidia-cublas-cu12 12.4.5.8\n", + " Uninstalling nvidia-cublas-cu12-12.4.5.8:\n", + " Successfully uninstalled nvidia-cublas-cu12-12.4.5.8\n", + " Attempting uninstall: nvidia-cusolver-cu12\n", + " Found existing installation: nvidia-cusolver-cu12 11.6.1.9\n", + " Uninstalling nvidia-cusolver-cu12-11.6.1.9:\n", + " Successfully uninstalled nvidia-cusolver-cu12-11.6.1.9\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torchaudio 2.6.0+cu124 requires torch==2.6.0, but you have torch 2.5.1+cu121 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed nvidia-cublas-cu12-12.1.3.1 nvidia-cuda-cupti-cu12-12.1.105 nvidia-cuda-nvrtc-cu12-12.1.105 nvidia-cuda-runtime-cu12-12.1.105 nvidia-cufft-cu12-11.0.2.54 nvidia-curand-cu12-10.3.2.106 nvidia-cusolver-cu12-11.4.5.107 nvidia-cusparse-cu12-12.1.0.106 nvidia-nvtx-cu12-12.1.105 sympy-1.13.1 torch-2.5.1+cu121 torchvision-0.20.1+cu121 triton-3.1.0\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1) (1.3.0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import sympy\n", + "from torchvision import datasets, transforms\n", + "print(\"โœ… Torch:\", torch.__version__)\n", + "print(\"โœ… Sympy:\", sympy.__version__)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uCB8xtxrQ9nm", + "outputId": "931a98d5-610a-4a59-f24d-44110438dfec" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "โœ… Torch: 2.5.1+cu121\n", + "โœ… Sympy: 1.13.1\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Bkd-kcNTN-yb" + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "# from torchvision import datasets, transforms\n", + "from torch.utils.data import DataLoader\n", + "from ndlinear import NdLinear\n", + "import timm\n", + "import time\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Dataset Preparation\n", + "\n", + "We use the MNIST dataset and apply basic transformations including normalization and resizing.\n" + ], + "metadata": { + "id": "Joh6rivWuckw" + } + }, + { + "cell_type": "code", + "source": [ + "from torchvision.transforms import ToTensor, Resize, Compose, Lambda\n", + "\n", + "transform = Compose([\n", + " Resize((224, 224)),\n", + " ToTensor(),\n", + " Lambda(lambda x: x.repeat(3, 1, 1)) # Grayscale โ†’ RGB by repeating channels\n", + "])\n", + "\n", + "\n", + "train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n", + "test_data = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n", + "\n", + "train_loader = DataLoader(train_data, batch_size=64, shuffle=True)\n", + "test_loader = DataLoader(test_data, batch_size=64, shuffle=False)\n" + ], + "metadata": { + "id": "MAyKm-6hOhVF", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d489154c-35e1-45a0-d1f1-e868577bfd2a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 9.91M/9.91M [00:01<00:00, 5.05MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 28.9k/28.9k [00:00<00:00, 133kB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 1.65M/1.65M [00:01<00:00, 1.28MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 4.54k/4.54k [00:00<00:00, 6.17MB/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Model Definition: SmallViT with Optional NdLinear\n", + "\n", + "We define a wrapper on top of `timm`'s `vit_tiny_patch16_224`, replacing Linear layers with `NdLinear` if specified.\n" + ], + "metadata": { + "id": "vJzXgaYuukqy" + } + }, + { + "cell_type": "code", + "source": [ + "from ndlinear import NdLinear\n", + "import timm\n", + "import torch.nn as nn\n", + "\n", + "class NdLinearAdapter(nn.Module):\n", + " def __init__(self, in_features, out_features):\n", + " super().__init__()\n", + " self.nd = NdLinear(input_dims=(in_features, 1), hidden_size=(out_features, 1))\n", + "\n", + " def forward(self, x):\n", + " if x.dim() == 2:\n", + " # [B, D] โ†’ [B, D, 1] โ†’ Nd โ†’ [B, O]\n", + " x = self.nd(x.unsqueeze(-1)).squeeze(-1)\n", + " elif x.dim() == 3:\n", + " # [B, N, D] โ†’ [B*N, D, 1] โ†’ Nd โ†’ [B, N, O]\n", + " B, N, D = x.shape\n", + " x = self.nd(x.view(B * N, D, 1)).view(B, N, -1)\n", + " else:\n", + " raise ValueError(\"Unsupported input shape for NdLinearAdapter.\")\n", + " return x\n", + "\n", + "\n", + "# ViT model with optional NdLinear swap\n", + "class SmallViT(nn.Module):\n", + " def __init__(self, use_ndlinear=False):\n", + " super().__init__()\n", + " self.model = timm.create_model('vit_tiny_patch16_224', pretrained=False, num_classes=10)\n", + " if use_ndlinear:\n", + " self._replace_linear_with_nd(self.model)\n", + "\n", + " def _replace_linear_with_nd(self, module):\n", + " for name, child in module.named_children():\n", + " if isinstance(child, nn.Linear):\n", + " in_f, out_f = child.in_features, child.out_features\n", + " setattr(module, name, NdLinearAdapter(in_f, out_f))\n", + " else:\n", + " self._replace_linear_with_nd(child)\n", + "\n", + " def forward(self, x):\n", + " return self.model(x)\n" + ], + "metadata": { + "id": "sp3eEpGYTPKC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Training Loop\n", + "\n", + "We define a training and validation loop to benchmark all three model variants under identical conditions.\n", + "Metrics like final accuracy and loss are recorded for comparison.\n" + ], + "metadata": { + "id": "zf3tix63vVUZ" + } + }, + { + "cell_type": "code", + "source": [ + "import time\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from torch.nn import CrossEntropyLoss\n", + "from torch.optim import Adam\n", + "\n", + "def train_and_compare(model, train_loader, test_loader, epochs=3, lr=3e-4):\n", + " model.to(device)\n", + " optimizer = Adam(model.parameters(), lr=lr)\n", + " criterion = CrossEntropyLoss()\n", + "\n", + " train_loss_history = []\n", + " val_loss_history = []\n", + " accuracy_history = []\n", + " param_count = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "\n", + " print(f\"๐Ÿ” Trainable Parameters: {param_count:,}\")\n", + " print(f\"๐Ÿ“ฆ Approx. Model Size: {param_count * 4 / 1e6:.2f} MB\\n\")\n", + "\n", + " for epoch in range(epochs):\n", + " model.train()\n", + " total_loss = 0\n", + " val_loss = 0\n", + " correct = 0\n", + " total = 0\n", + " start_time = time.time()\n", + "\n", + " # Training loop\n", + " for images, labels in train_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " outputs = model(images)\n", + " loss = criterion(outputs, labels)\n", + "\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " total_loss += loss.item()\n", + "\n", + " # Validation loop\n", + " model.eval()\n", + " with torch.no_grad():\n", + " for images, labels in test_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " outputs = model(images)\n", + " loss = criterion(outputs, labels)\n", + " val_loss += loss.item()\n", + " _, predicted = torch.max(outputs, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + " end_time = time.time()\n", + " val_accuracy = 100 * correct / total\n", + "\n", + " train_loss_history.append(total_loss / len(train_loader))\n", + " val_loss_history.append(val_loss / len(test_loader))\n", + " accuracy_history.append(val_accuracy)\n", + "\n", + " print(f\"๐Ÿงช Epoch [{epoch+1}/{epochs}] | \"\n", + " f\"Train Loss: {total_loss:.4f} | \"\n", + " f\"Val Loss: {val_loss:.4f} | \"\n", + " f\"Accuracy: {val_accuracy:.2f}% | \"\n", + " f\"Time: {end_time - start_time:.2f}s\")\n", + "\n", + " # Plot loss\n", + " plt.figure(figsize=(15, 4))\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(train_loss_history, label='Train Loss')\n", + " plt.plot(val_loss_history, label='Validation Loss')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Loss')\n", + " plt.title('Loss Over Epochs')\n", + " plt.legend()\n", + "\n", + " # Plot accuracy\n", + " plt.subplot(1, 2, 2)\n", + " plt.plot(accuracy_history, label='Validation Accuracy', color='green')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Accuracy (%)')\n", + " plt.title('Validation Accuracy Over Epochs')\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " return {\n", + " \"params\": param_count,\n", + " \"final_train_loss\": train_loss_history[-1],\n", + " \"final_val_loss\": val_loss_history[-1],\n", + " \"final_accuracy\": accuracy_history[-1]\n", + " }\n" + ], + "metadata": { + "id": "aZ2WWjZHSZsH" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Train the Baseline model" + ], + "metadata": { + "id": "7mkX2nkqvlyl" + } + }, + { + "cell_type": "code", + "source": [ + "baseline_model = SmallViT(use_ndlinear=False).to(device)\n", + "train_and_compare(baseline_model, train_loader, test_loader, epochs=5)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 620 + }, + "id": "Wi8m3cKoYP0A", + "outputId": "ce0ded92-34ee-433b-f2e9-5034f8fe04e7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "๐Ÿ” Trainable Parameters: 5,526,346\n", + "๐Ÿ“ฆ Approx. Model Size: 22.11 MB\n", + "\n", + "๐Ÿงช Epoch [1/5] | Train Loss: 985.9355 | Val Loss: 72.5548 | Accuracy: 83.84% | Time: 272.75s\n", + "๐Ÿงช Epoch [2/5] | Train Loss: 317.5215 | Val Loss: 43.3237 | Accuracy: 91.23% | Time: 292.62s\n", + "๐Ÿงช Epoch [3/5] | Train Loss: 230.5873 | Val Loss: 30.6661 | Accuracy: 93.85% | Time: 279.43s\n", + "๐Ÿงช Epoch [4/5] | Train Loss: 191.4707 | Val Loss: 29.6603 | Accuracy: 93.82% | Time: 279.29s\n", + "๐Ÿงช Epoch [5/5] | Train Loss: 166.3091 | Val Loss: 27.1696 | Accuracy: 94.36% | Time: 279.19s\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAGGCAYAAACUkchWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAwuFJREFUeJzs3Xd4FNXbxvHvbnqnhwAhCb0YAtJBmnTpLYAoXSz0JiLSRZQuYldApEgvKhK6IIQuvffeSyCB1Hn/4GV/hFACBiYh9+e6cpHMnp25Z7MJZ56cOcdiGIaBiIiIiIiIiIiIiIgkYDU7gIiIiIiIiIiIiIhIcqUiuoiIiIiIiIiIiIjII6iILiIiIiIiIiIiIiLyCCqii4iIiIiIiIiIiIg8goroIiIiIiIiIiIiIiKPoCK6iIiIiIiIiIiIiMgjqIguIiIiIiIiIiIiIvIIKqKLiIiIiIiIiIiIiDyCiugiIiIiIiIiIiIiIo+gIrqIiMgDVq9ejcViYc6cOWZHEREREUlSx48fx2KxMHnyZNu2QYMGYbFYEvV8i8XCoEGDkjRTxYoVqVixYpLuUyQl8/f3p3bt2mbHEJH7qIguIvIIkydPxmKxsGXLFrOjJMq6deto0KAB3t7eODk54e/vz7vvvsvJkyfNjpbAvSL1oz5+++03syOKiIiImK5u3bq4urpy8+bNR7Zp0aIFjo6OXLly5QUme3p79+5l0KBBHD9+3OwoD7V48WIsFgtZsmQhLi7O7DgpzpUrV+jduzd58+bF2dmZdOnSUb16df744w+zoz2Uv7//I69FatSoYXY8EUmG7M0OICIi/91XX31F165dyZEjB507d8bHx4d9+/bx008/MXPmTBYvXkyZMmXMjplAly5dKF68eILtpUuXNiGNiIiISPLSokULfv/9d+bPn0/Lli0TPB4REcHChQupUaMG6dOnf+bjfPLJJ3z00Uf/JeoT7d27l8GDB1OxYkX8/f3jPbZ06dLneuzEmDZtGv7+/hw/fpyVK1dSpUoVsyOlGAcOHKBy5cpcunSJNm3aUKxYMa5fv860adOoU6cOvXr1YuTIkWbHTKBw4cL07NkzwfYsWbKYkEZEkjsV0UVEUrh169bRrVs3XnvtNZYsWYKrq6vtsffff5+yZcvSuHFj9uzZQ9q0aV9YrvDwcNzc3B7bply5cjRu3PgFJRIRERFJWerWrYuHhwfTp09/aBF94cKFhIeH06JFi/90HHt7e+ztzSsPODo6mnZsuNtvXbhwIcOHD2fSpElMmzYt2RbRE9PHfpGio6Np3Lgx165dY82aNZQsWdL2WPfu3WnRogWjRo2iWLFiNG3a9IXliomJIS4u7rHvraxZs/LWW2+9sEwikrJpOhcRkf/o33//pWbNmnh6euLu7k7lypXZsGFDvDbR0dEMHjyY3Llz4+zsTPr06XnttddYtmyZrc358+dp06YN2bJlw8nJCR8fH+rVq/fEW16HDh2KxWLhl19+iVdAB8iZMycjRozg3LlzfP/99wCMGjUKi8XCiRMnEuyrb9++ODo6cu3aNdu2jRs3UqNGDby8vHB1daVChQqsW7cu3vPuzaO5d+9e3nzzTdKmTctrr72WqNfvSSwWC506dWLatGm220OLFi3KmjVrErRNzPcC4Pr163Tv3h1/f3+cnJzIli0bLVu25PLly/HaxcXFMWzYMLJly4azszOVK1fm8OHD8docOnSIRo0akTlzZpydncmWLRvNmjXjxo0bSXL+IiIiknq5uLjQsGFDVqxYwcWLFxM8Pn36dDw8PKhbty5Xr16lV69eBAYG4u7ujqenJzVr1mTHjh1PPM7D5kSPjIyke/fuZMyY0XaM06dPJ3juiRMn+OCDD8ibNy8uLi6kT5+eJk2axOvDTp48mSZNmgBQqVIl27QZq1evBh4+J/rFixdp164d3t7eODs7ExQUxC+//BKvzb353UeNGsUPP/xAzpw5cXJyonjx4mzevPmJ533P/PnzuX37Nk2aNKFZs2bMmzePO3fuJGh3584dBg0aRJ48eXB2dsbHx4eGDRty5MgRW5u4uDi+/PJLAgMDcXZ2JmPGjNSoUcM2ReTD5qS/58H55h/Xx965cyetW7cmR44cODs7kzlzZtq2bfvQaX3OnDlDu3btyJIlC05OTgQEBPD+++8TFRXF0aNHsVgsjB07NsHz1q9fj8ViYcaMGY987ebOncvu3bv56KOP4hXQAezs7Pj+++9JkyaN7bwuXLiAvb09gwcPTrCvAwcOYLFYmDBhgm3b9evX6datG76+vjg5OZErVy6++OKLeFPu3P8+GDdunO19sHfv3kfmTqzWrVvj7u7O0aNHqV69Om5ubmTJkoUhQ4ZgGEa8tuHh4fTs2dOWNW/evIwaNSpBO4CpU6dSokQJXF1dSZs2LeXLl3/oHRn//PMPJUqUwNnZmRw5cjBlypR4jyfmOlNEkoZGoouI/Ad79uyhXLlyeHp68uGHH+Lg4MD3339PxYoV+fvvv20dyUGDBjF8+HDat29PiRIlCAsLY8uWLWzbto2qVasC0KhRI/bs2UPnzp3x9/fn4sWLLFu2jJMnTya45fWeiIgIVqxYQbly5QgICHhom6ZNm9KhQwf++OMPPvroI4KDg/nwww+ZNWsWvXv3jtd21qxZVKtWzTZifeXKldSsWZOiRYsycOBArFYrkyZN4vXXX2ft2rWUKFEi3vObNGlC7ty5+eyzzx7aWXzQzZs3ExSuAdKnTx/vQu7vv/9m5syZdOnSBScnJ7755htq1KjBpk2beOWVV57qe3Hr1i3KlSvHvn37aNu2La+++iqXL19m0aJFnD59mgwZMtiO+/nnn2O1WunVqxc3btxgxIgRtGjRgo0bNwIQFRVF9erViYyMpHPnzmTOnJkzZ87wxx9/cP36dby8vJ74GoiIiIg8TosWLfjll1+YNWsWnTp1sm2/evUqISEhNG/eHBcXF/bs2cOCBQto0qQJAQEBXLhwge+//54KFSqwd+/ep56ion379kydOpU333yTMmXKsHLlSmrVqpWg3ebNm1m/fj3NmjUjW7ZsHD9+nG+//ZaKFSuyd+9eXF1dKV++PF26dGH8+PF8/PHH5M+fH8D274Nu375NxYoVOXz4MJ06dSIgIIDZs2fTunVrrl+/TteuXeO1nz59Ojdv3uTdd9/FYrEwYsQIGjZsyNGjR3FwcHjiuU6bNo1KlSqROXNmmjVrxkcffcTvv/9uK/wDxMbGUrt2bVasWEGzZs3o2rUrN2/eZNmyZezevZucOXMC0K5dOyZPnkzNmjVp3749MTExrF27lg0bNlCsWLFEv/73e1gfe9myZRw9epQ2bdqQOXNm9uzZww8//MCePXvYsGGDrS999uxZSpQowfXr1+nQoQP58uXjzJkzzJkzh4iICHLkyEHZsmWZNm0a3bt3T/C6eHh4UK9evUdm+/333wEeeqcEgJeXF/Xq1eOXX37h8OHD5MqViwoVKjBr1iwGDhwYr+3MmTOxs7Ozve4RERFUqFCBM2fO8O6775I9e3bWr19P3759OXfuHOPGjYv3/EmTJnHnzh06dOiAk5MT6dKle+zrGh0d/dBrETc3N1xcXGxfx8bGUqNGDUqVKsWIESNYsmQJAwcOJCYmhiFDhgBgGAZ169Zl1apVtGvXjsKFCxMSEkLv3r05c+ZMvD9SDB48mEGDBlGmTBmGDBmCo6MjGzduZOXKlVSrVs3W7vDhwzRu3Jh27drRqlUrJk6cSOvWrSlatCgFCxYEEnedKSJJxBARkYeaNGmSARibN29+ZJv69esbjo6OxpEjR2zbzp49a3h4eBjly5e3bQsKCjJq1ar1yP1cu3bNAIyRI0c+Vcbt27cbgNG1a9fHtitUqJCRLl0629elS5c2ihYtGq/Npk2bDMCYMmWKYRiGERcXZ+TOnduoXr26ERcXZ2sXERFhBAQEGFWrVrVtGzhwoAEYzZs3T1TuVatWGcAjP86dO2dre2/bli1bbNtOnDhhODs7Gw0aNLBtS+z3YsCAAQZgzJs3L0Gue+d5L1/+/PmNyMhI2+NffvmlARi7du0yDMMw/v33XwMwZs+enajzFhEREXlaMTExho+Pj1G6dOl427/77jsDMEJCQgzDMIw7d+4YsbGx8docO3bMcHJyMoYMGRJvG2BMmjTJtu1eX+6ee33MDz74IN7+3nzzTQMwBg4caNsWERGRIHNoaGi8fqVhGMbs2bMNwFi1alWC9hUqVDAqVKhg+3rcuHEGYEydOtW2LSoqyihdurTh7u5uhIWFxTuX9OnTG1evXrW1XbhwoQEYv//+e4JjPejChQuGvb298eOPP9q2lSlTxqhXr168dhMnTjQAY8yYMQn2ca8PuXLlSgMwunTp8sg2D3v973nwtX1cH/thr/uMGTMMwFizZo1tW8uWLQ2r1frQa5p7mb7//nsDMPbt22d7LCoqysiQIYPRqlWrBM+7X+HChQ0vL6/HthkzZowBGIsWLYp3vHt96nsKFChgvP7667avhw4dari5uRkHDx6M1+6jjz4y7OzsjJMnTxqG8b/X1NPT07h48eJjs9zj5+f3yGuR4cOH29q1atXKAIzOnTvbtsXFxRm1atUyHB0djUuXLhmGYRgLFiwwAOPTTz+Nd5zGjRsbFovFOHz4sGEYhnHo0CHDarUaDRo0SPDzev811718938vL168aDg5ORk9e/a0bXvSdaaIJB1N5yIi8oxiY2NZunQp9evXJ0eOHLbtPj4+vPnmm/zzzz+EhYUBkCZNGvbs2cOhQ4ceui8XFxccHR1ZvXp1vKlUnuTmzZsAeHh4PLadh4eHLQvcHZ2+devWeLeezpw5EycnJ9tIk+3bt3Po0CHefPNNrly5wuXLl7l8+TLh4eFUrlyZNWvWxLuNEuC9995LdHaAAQMGsGzZsgQfD44aKV26NEWLFrV9nT17durVq0dISAixsbFP9b2YO3cuQUFBNGjQIEGeB29jbtOmTbx5FMuVKwfA0aNHAWwjzUNCQoiIiHiqcxcRERFJDDs7O5o1a0ZoaGi8KVKmT5+Ot7c3lStXBsDJyQmr9e4lfmxsLFeuXMHd3Z28efOybdu2pzrm4sWLgbuLwN+vW7duCdreP2I3OjqaK1eukCtXLtKkSfPUx73/+JkzZ6Z58+a2bQ4ODnTp0oVbt27x999/x2vftGnTeGv/PNhne5zffvsNq9VKo0aNbNuaN2/OX3/9Fa9fPnfuXDJkyEDnzp0T7ONeH3Lu3LlYLJYEI6zvb/MsHtbHvv91v3PnDpcvX6ZUqVIAttc9Li6OBQsWUKdOnYeOgr+XKTg4GGdnZ6ZNm2Z7LCQkhMuXLz9xzvCbN28m6loEsPXHGzZsiL29PTNnzrS12b17N3v37o03b/rs2bMpV64cadOmtV2LXL58mSpVqhAbG5tgesdGjRqRMWPGx2a5X8mSJR96LXL/++6e++8CuTfdZFRUFMuXLwfuvmft7OwS/Mz07NkTwzD466+/AFiwYAFxcXEMGDDA9vN6/37vV6BAAdt7GSBjxozkzZs33vv6SdeZIpJ0VEQXEXlGly5dIiIigrx58yZ4LH/+/MTFxXHq1CkAhgwZwvXr18mTJw+BgYH07t2bnTt32to7OTnxxRdf8Ndff+Ht7U358uUZMWIE58+ff2yGex3Se8X0R3mwc9ukSROsVqut42oYBrNnz7bNJw7YOmKtWrUiY8aM8T5++uknIiMjE8z7/agpZR4lMDCQKlWqJPh4cAGg3LlzJ3hunjx5iIiI4NKlS0/1vThy5IhtCpgnyZ49e7yv712c3bugCggIoEePHvz0009kyJCB6tWr8/XXX2s+dBEREUlS9xYOnT59OgCnT59m7dq1NGvWDDs7O+BuwXTs2LHkzp0bJycnMmTIQMaMGdm5c+dT901OnDiB1Wq1TVFyz8P6Wrdv32bAgAG2eaDvHff69evP3Cc6ceIEuXPnTlBkvDf9y4Nr+zypz/Y49+amvnLlCocPH+bw4cMUKVKEqKgoZs+ebWt35MgR8ubN+9gFWI8cOUKWLFmeOI3I03pYH/vq1at07doVb29vXFxcyJgxo63dvdf90qVLhIWFPbHvmyZNGurUqWN7f8HdqVyyZs3K66+//tjnenh4JOpa5F5bgAwZMlC5cmVmzZplazNz5kzs7e1p2LChbduhQ4dYsmRJgmuRe4u+PrhOwNNei2TIkOGh1yJ+fn7x2lmt1ngDdeDutQhg+8PWiRMnyJIlS4I/KDz4nj1y5AhWq5UCBQo8Md+D72u4+96+/339pOtMEUk6KqKLiLwA5cuX58iRI0ycOJFXXnmFn376iVdffZWffvrJ1qZbt24cPHiQ4cOH4+zsTP/+/cmfPz///vvvI/ebK1cu7O3tH9tRioyM5MCBA/E6almyZKFcuXK2juuGDRs4efJkvJEf90aZjxw58qEjNJYtW4a7u3u8Y90/IuZlcO+i9EHGffO9jx49mp07d/Lxxx9z+/ZtunTpQsGCBR+68JaIiIjIsyhatCj58uWzLfA4Y8YMDMOwFdcBPvvsM3r06EH58uWZOnUqISEhLFu2jIIFCya4ezApde7cmWHDhhEcHMysWbNYunQpy5YtI3369M/1uPdLTJ/tYQ4dOsTmzZv5559/yJ07t+3j3uKd94/MTiqPGpEeGxv7yOc8rI8dHBzMjz/+yHvvvce8efNYunQpS5YsAXim171ly5YcPXqU9evXc/PmTRYtWkTz5s0T/CHjQfnz5+fGjRucPHnykW3uXavcfz3SrFkzDh48yPbt24G7azNVrlw53vpEcXFxVK1a9ZHXIvffPQCp81okMdeZIpI0tLCoiMgzypgxI66urhw4cCDBY/v378dqteLr62vbli5dOtq0aUObNm24desW5cuXZ9CgQbRv397WJmfOnPTs2ZOePXty6NAhChcuzOjRo5k6depDM7i5uVGpUiVWrlzJiRMnEoyagLsd0sjISGrXrh1ve9OmTfnggw84cOAAM2fOxNXVlTp16sTLAuDp6Wkb7WGWh92eePDgQVxdXW23bCb2e5EzZ052796dpPkCAwMJDAzkk08+Yf369ZQtW5bvvvuOTz/9NEmPIyIiIqlXixYt6N+/Pzt37mT69Onkzp2b4sWL2x6fM2cOlSpV4ueff473vOvXr8crTCaGn58fcXFxttHX9zysrzVnzhxatWrF6NGjbdvu3LnD9evX47V7mulM/Pz82LlzJ3FxcfGKuPv377c9nhSmTZuGg4MDv/76a4KC5T///MP48eM5efIk2bNnJ2fOnGzcuJHo6OhHLlaaM2dOQkJCuHr16iNHo98bJf/g6/Pg6PrHuXbtGitWrGDw4MEMGDDAtv3BPnPGjBnx9PRMVN+3Ro0aZMyYkWnTplGyZEkiIiJ4++23n/i82rVrM2PGDKZMmcInn3yS4PGwsDAWLlxIvnz5yJUrl217/fr1effdd213xh48eJC+ffvGe27OnDm5deuW6dcicXFxHD161Db6HO7mBfD39wfuvieXL1+e4A7gB9+zOXPmJC4ujr1791K4cOEkyZeY60wR+e80El1E5BnZ2dlRrVo1Fi5cGG9+ygsXLjB9+nRee+0129QoV65cifdcd3d3cuXKRWRkJHB35fk7d+7Ea5MzZ048PDxsbR7lk08+wTAMWrduze3bt+M9duzYMT788EN8fHx499134z3WqFEj7OzsmDFjBrNnz6Z27dq4ubnZHi9atCg5c+Zk1KhR3Lp1K8FxL1269NhcSSk0NDTenJqnTp1i4cKFVKtWDTs7u6f6XjRq1IgdO3Ywf/78BMd50milB4WFhRETExNvW2BgIFar9YnfNxEREZGncW/U+YABA9i+fXu8Uehwt2/6YF9m9uzZnDlz5qmPVbNmTQDGjx8fb/u4ceMStH3Ycb/66qsEI6vv9TMfLB4/zBtvvMH58+fjzZkdExPDV199hbu7OxUqVEjMaTzRtGnTKFeuHE2bNqVx48bxPnr37g1gG/3fqFEjLl++zIQJExLs5975N2rUCMMwGDx48CPbeHp6kiFDhgTzeX/zzTeJzn2v4P/g6/7g98dqtVK/fn1+//13tmzZ8shMAPb29jRv3pxZs2YxefJkAgMDKVSo0BOzNG7cmAIFCvD5558nOEZcXBzvv/8+165dSzBPfJo0aahevTqzZs3it99+w9HRkfr168drExwcTGhoKCEhIQmOe/369QT98Ofp/u+7YRhMmDABBwcH25oEb7zxBrGxsQneH2PHjsVisdh+purXr4/VamXIkCEJ7hh42msRePJ1pogkHY1EFxF5gokTJ9pujbxf165d+fTTT1m2bBmvvfYaH3zwAfb29nz//fdERkYyYsQIW9sCBQpQsWJFihYtSrp06diyZQtz5syxLVBz8OBBKleuTHBwMAUKFMDe3p758+dz4cIFmjVr9th85cuXZ9SoUfTo0YNChQrRunVrfHx82L9/Pz/++CNxcXEsXrw43mJLAJkyZaJSpUqMGTOGmzdvxpvKBe52un/66Sdq1qxJwYIFadOmDVmzZuXMmTOsWrUKT09Pfv/992d9WQFYu3Ztgj8eABQqVChep/2VV16hevXqdOnSBScnJ9tFxv0XKIn9XvTu3Zs5c+bQpEkT2rZtS9GiRbl69SqLFi3iu+++IygoKNH5V65cSadOnWjSpAl58uQhJibGNpLpwdtLRURERP6LgIAAypQpw8KFCwESFNFr167NkCFDaNOmDWXKlGHXrl1MmzYtwVzOiVG4cGGaN2/ON998w40bNyhTpgwrVqzg8OHDCdrWrl2bX3/9FS8vLwoUKEBoaCjLly8nffr0CfZpZ2fHF198wY0bN3BycuL1118nU6ZMCfbZoUMHvv/+e1q3bs3WrVvx9/dnzpw5rFu3jnHjxj1xIcvE2LhxI4cPH463YOT9smbNyquvvsq0adPo06cPLVu2ZMqUKfTo0YNNmzZRrlw5wsPDWb58OR988AH16tWjUqVKvP3224wfP55Dhw5Ro0YN4uLiWLt2LZUqVbIdq3379nz++ee0b9+eYsWKsWbNGtvI5sTw9PS0raEUHR1N1qxZWbp0KceOHUvQ9rPPPmPp0qVUqFCBDh06kD9/fs6dO8fs2bP5559/SJMmja1ty5YtGT9+PKtWreKLL75IVBZHR0fmzJlD5cqVee2112jTpg3FihXj+vXrTJ8+nW3bttGzZ8+HXtM0bdqUt956i2+++Ybq1avHywJ3++2LFi2idu3atG7dmqJFixIeHs6uXbuYM2cOx48ff+q7LO535syZh97x6+7uHq+g7+zszJIlS2jVqhUlS5bkr7/+4s8//+Tjjz+23RVbp04dKlWqRL9+/Th+/DhBQUEsXbqUhQsX0q1bN9tdvrly5aJfv34MHTqUcuXK0bBhQ5ycnNi8eTNZsmRh+PDhT3UOT7rOFJEkZIiIyENNmjTJAB75cerUKcMwDGPbtm1G9erVDXd3d8PV1dWoVKmSsX79+nj7+vTTT40SJUoYadKkMVxcXIx8+fIZw4YNM6KiogzDMIzLly8bHTt2NPLly2e4ubkZXl5eRsmSJY1Zs2YlOu+aNWuMevXqGRkyZDAcHByM7NmzG++8845x/PjxRz7nxx9/NADDw8PDuH379kPb/Pvvv0bDhg2N9OnTG05OToafn58RHBxsrFixwtZm4MCBBmBcunQpUVlXrVr12Nd24MCBtraA0bFjR2Pq1KlG7ty5DScnJ6NIkSLGqlWrEuw3Md8LwzCMK1euGJ06dTKyZs1qODo6GtmyZTNatWplXL58OV6+2bNnx3vesWPHDMCYNGmSYRiGcfToUaNt27ZGzpw5DWdnZyNdunRGpUqVjOXLlyfqdRARERF5Gl9//bUBGCVKlEjw2J07d4yePXsaPj4+houLi1G2bFkjNDTUqFChglGhQgVbuwf7M4bxv77c/W7fvm106dLFSJ8+veHm5mbUqVPHOHXqVIK+2rVr14w2bdoYGTJkMNzd3Y3q1asb+/fvN/z8/IxWrVrF2+ePP/5o5MiRw7CzszMAW3/uwYyGYRgXLlyw7dfR0dEIDAyMl/n+cxk5cmSC1+PBnA/q3LmzARhHjhx5ZJtBgwYZgLFjxw7DMAwjIiLC6NevnxEQEGA4ODgYmTNnNho3bhxvHzExMcbIkSONfPnyGY6OjkbGjBmNmjVrGlu3brW1iYiIMNq1a2d4eXkZHh4eRnBwsHHx4sUEmR/Xxz59+rTRoEEDI02aNIaXl5fRpEkT4+zZsw897xMnThgtW7Y0MmbMaDg5ORk5cuQwOnbsaERGRibYb8GCBQ2r1WqcPn36ka/Lw1y8eNHo0aOHkStXLsPJyclIkyaNUaVKFWPRokWPfE5YWJjh4uJiAMbUqVMf2ubmzZtG3759jVy5chmOjo5GhgwZjDJlyhijRo2yXUs97n3wKH5+fo+8FvHz87O1a9WqleHm5mYcOXLEqFatmuHq6mp4e3sbAwcONGJjYxNk7d69u5ElSxbDwcHByJ07tzFy5EgjLi4uwfEnTpxoFClSxHBycjLSpk1rVKhQwVi2bFm8fLVq1UrwvAd/Vp50nSkiScdiGM9wv4iIiMgLYrFY6Nix40NvnRURERERkaRTpEgR0qVLx4oVK8yOkiy0bt2aOXPmPHR6SxFJXTQnuoiIiIiIiIhIKrdlyxa2b99Oy5YtzY4iIpLsaE50EREREREREZFUavfu3WzdupXRo0fj4+OTYK0kERHRSHQRERERERERkVRrzpw5tGnThujoaGbMmIGzs7PZkUREkh3NiS4iIiIiIiIiIiIi8ggaiS4iIiIiIiIiIiIi8ggqoouIiIiIiIiIiIiIPEKqW1g0Li6Os2fP4uHhgcViMTuOiIiIiKRihmFw8+ZNsmTJgtWaesa3qE8uIiIiIslBYvvjqa6IfvbsWXx9fc2OISIiIiJic+rUKbJly2Z2jBdGfXIRERERSU6e1B9PdUV0Dw8P4O4L4+npaXIaEREREUnNwsLC8PX1tfVRUwv1yUVEREQkOUhsfzzVFdHv3S7q6empDruIiIiIJAupbUoT9clFREREJDl5Un889Uy8KCIiIiIiIiIiIiLylFREFxERERERERERERF5BBXRRUREREREREREREQeIdXNiS4iIiLyMLGxsURHR5sdQ14yDg4O2NnZmR0jRYqLiyMqKsrsGCLPhaOjI1arxrSJiIikFCqii4iISKpmGAbnz5/n+vXrZkeRl1SaNGnInDlzqls89L+Iiori2LFjxMXFmR1F5LmwWq0EBATg6OhodhQRERFJBBXRRUREJFW7V0DPlCkTrq6uKnRKkjEMg4iICC5evAiAj4+PyYlSBsMwOHfuHHZ2dvj6+mq0rrx04uLiOHv2LOfOnSN79uz6f0dERCQFUBFdREREUq3Y2FhbAT19+vRmx5GXkIuLCwAXL14kU6ZMmtolEWJiYoiIiCBLliy4urqaHUfkuciYMSNnz54lJiYGBwcHs+OIiIjIE2hYh4iIiKRa9+ZAV6FOnqd77y/NuZ84sbGxAJrmQl5q997f997vIiIikrypiC4iIiKpnm6ll+dJ769no9dNXmZ6f4uIiKQsKqK/QIZhcPlWpNkxRERERERERERERCSRVER/Qa5HRPH+1G00+GYdtyJjzI4jIiIikoC/vz/jxo0zO4ZIqlWxYkW6detm+zoxP5MWi4UFCxb852Mn1X5ERERE7hdnxHEp/BK7Luxi+dHlTN05ldHrR9N7aW/env821X6tRqFvC+E9ypuDVw6aHfeRtLDoC2JntbDrzA3OXL/NsD/3MrxhIbMjiYiISAr1pGkABg4cyKBBg556v5s3b8bNze0ZU91VsWJFChcurGK8pCp16tQhOjqaJUuWJHhs7dq1lC9fnh07dlCo0NNdAyTFz+SDBg0axIIFC9i+fXu87efOnSNt2rRJeqxHuX37NlmzZsVqtXLmzBmcnJxeyHFFREQkaRiGwbU717hw6wLnb53nQvjdf+///N5jF8MvEmskbg2Q87fOkyd9nuec/tmoiP6CeDg7MDo4iOY/bmDGplNULeDN6/m8zY4lIiIiKdC5c+dsn8+cOZMBAwZw4MAB2zZ3d3fb54ZhEBsbi739k7t9GTNmTNqgIqlEu3btaNSoEadPnyZbtmzxHps0aRLFihV76gI6vNifycyZM7+wY82dO5eCBQtiGAYLFiygadOmL+zYD3qa35EiIiIvM8MwuBl1M14B/FHF8QvhF4iKjXqq/WdwzYC3mzeZ3TPj7e5NZrfM//vcPTPebt7kTp/7OZ3df6fpXF6gUjnS065sAAB95u7iWvjTvdlERERE4G6x696Hl5cXFovF9vX+/fvx8PDgr7/+omjRojg5OfHPP/9w5MgR6tWrh7e3N+7u7hQvXpzly5fH2++DU0dYLBZ++uknGjRogKurK7lz52bRokX/Kfu94pmTkxP+/v6MHj063uPffPMNuXPnxtnZGW9vbxo3bmx7bM6cOQQGBuLi4kL69OmpUqUK4eHh/ymPSFKoXbs2GTNmZPLkyfG237p1i9mzZ9OuXTuuXLlC8+bNyZo1K66urgQGBjJjxozH7vfBn8lDhw5Rvnx5nJ2dKVCgAMuWLUvwnD59+pAnTx5cXV3JkSMH/fv3Jzo6GoDJkyczePBgduzYgcViwWKx2DI/OJ3Lrl27eP31120/bx06dODWrVu2x1u3bk39+vUZNWoUPj4+pE+fno4dO9qO9Tg///wzb731Fm+99RY///xzgsf37NlD7dq18fT0xMPDg3LlynHkyBHb4xMnTrT9HvHx8aFTp04AHD9+HIvFEm+U/fXr17FYLKxevRqA1atXY7FYnul3ZGRkJH369MHX1xcnJydy5crFzz//jGEY5MqVi1GjRsVrv337diwWC4cPH37iayIiIvK8hEeFc/TaUdafWs/8ffP5dvO3DFw1kPf+eI/6v9Wn9M+lCfgyANfPXPH63Iu8E/JSfnJ5gucE0/mvzgxbO4yf//2ZPw7+wZazWzgVdspWQE/jnIZ8GfJRwa8CTQs2pWvJrnz2+mdMrDuRP9/8k60dtnKmxxmiPoniUu9L7P5gN8tbLmdaw2mMrj6a3mV70zKoJdVyViMocxCuDq4mv1qPpj+3v2C9qudl9cFLHL54i08W7GbCm0W0MruIiEgyYhgGt6MTd7thUnNxsEuyfsFHH33EqFGjyJEjB2nTpuXUqVO88cYbDBs2DCcnJ6ZMmUKdOnU4cOAA2bNnf+R+Bg8ezIgRIxg5ciRfffUVLVq04MSJE6RLl+6pM23dupXg4GAGDRpE06ZNWb9+PR988AHp06endevWbNmyhS5duvDrr79SpkwZrl69ytq1a4G7o++bN2/OiBEjaNCgATdv3mTt2rUYhvHMr5GkDIZhEBEdYcqxXR1cE/UzaW9vT8uWLZk8eTL9+vWzPWf27NnExsbSvHlzbt26RdGiRenTpw+enp78+eefvP322+TMmZMSJUo88RhxcXE0bNgQb29vNm7cyI0bN+LNn36Ph4cHkydPJkuWLOzatYt33nkHDw8PPvzwQ5o2bcru3btZsmSJrUDs5eWVYB/h4eFUr16d0qVLs3nzZi5evEj79u3p1KlTvD8UrFq1Ch8fH1atWsXhw4dp2rQphQsX5p133nnkeRw5coTQ0FDmzZuHYRh0796dEydO4OfnB8CZM2coX748FStWZOXKlXh6erJu3TpiYu6uK/Xtt9/So0cPPv/8c2rWrMmNGzdYt27dE1+/Bz3L78iWLVsSGhrK+PHjCQoK4tixY1y+fBmLxULbtm2ZNGkSvXr1sh1j0qRJlC9fnly5cj11PhERkce5E3PHNiLcNlL8gdHj9/69FXXryTu8j4ejh210+L0R4vf/e2/0uLebN072qWdKNhXRXzBnBzvGBhemwTfr+HPXOart8KZe4axmxxIREZH/dzs6lgIDQkw59t4h1XF1TJru2ZAhQ6hatart63Tp0hEUFGT7eujQocyfP59FixbZRnE+TOvWrWnevDkAn332GePHj2fTpk3UqFHjqTONGTOGypUr079/fwDy5MnD3r17GTlyJK1bt+bkyZO4ublRu3ZtPDw88PPzo0iRIsDdInpMTAwNGza0FdsCAwOfOoOkPBHREbgPd39yw+fgVt9buDkmbk7ytm3bMnLkSP7++28qVqwI3C2iNmrUCC8vL7y8vOIVWDt37kxISAizZs1KVBF9+fLl7N+/n5CQELJkyQLc/ZmsWbNmvHaffPKJ7XN/f3969erFb7/9xocffoiLiwvu7u7Y29s/dvqW6dOnc+fOHaZMmWKbk33ChAnUqVOHL774Am/vu9NSpk2blgkTJmBnZ0e+fPmoVasWK1aseGwRfeLEidSsWdM2/3r16tWZNGmSbR2Hr7/+Gi8vL3777TccHByAu78r7vn000/p2bMnXbt2tW0rXrz4E1+/Bz3t78iDBw8ya9Ysli1bRpUqVQDIkSOHrX3r1q0ZMGAAmzZtokSJEkRHRzN9+vQEo9NFREQeJTo2movhFxNOo3LrAufD/1ckP3/rPDcibzzVvl3sXeIVwDO7xZ9G5f7HkvNocDOpiG6CwGxedH49N2OXH6T/gt2UDEhPZi9ns2OJiIjIS6RYsWLxvr516xaDBg3izz//tBWkb9++zcmTJx+7n/vncXZzc8PT05OLFy8+U6Z9+/ZRr169eNvKli3LuHHjiI2NpWrVqvj5+ZEjRw5q1KhBjRo1bFPJBAUFUblyZQIDA6levTrVqlWjcePGL2whxNTk5s2b9O/fn/nz53Px4kWKFCnCl19++dBC5Xvvvcf333/P2LFjHzoqOjXJly8fZcqUYeLEiVSsWJHDhw+zdu1ahgwZAkBsbCyfffYZs2bN4syZM0RFRREZGYmra+IuVPft24evr6+tgA5QunTpBO1mzpzJ+PHjOXLkCLdu3SImJgZPT8+nOpd9+/YRFBQUb1HTsmXLEhcXx4EDB2xF9IIFC2JnZ2dr4+Pjw65dux6539jYWH755Re+/PJL27a33nqLXr16MWDAAKxWK9u3b6dcuXK2Avr9Ll68yNmzZ6lcufJTnc/DPO3vyO3bt2NnZ0eFChUeur8sWbJQq1YtJk6cSIkSJfj999+JjIykSZMm/zmriIikXLFxsVyKuBSvAP7gSPF7hfIrt6881b4d7RwfOlL8YaPI3R3dNRPGf6Qiukk+qJSTlfsvsOP0DT6cu5Nf2hTXm1lERCQZcHGwY++Q6qYdO6ncX/wC6NWrF8uWLWPUqFHkypULFxcXGjduTFTU49doebCQZbFYiIuLS7Kc9/Pw8GDbtm2sXr2apUuXMmDAAAYNGsTmzZtJkyYNy5YtY/369SxdupSvvvqKfv36sXHjRgICAp5LntSqffv27N69m19//ZUsWbIwdepUqlSpwt69e8ma9X93UM6fP58NGzbEK+o+D64Ortzq+3S3ISflsZ9Gu3bt6Ny5M19//TWTJk0iZ86ctqLryJEj+fLLLxk3bhyBgYG4ubnRrVu3J/4MPo3Q0FBatGjB4MGDqV69um1E94NrDySVp/39EBISwpkzZxIsJBobG8uKFSuoWrUqLi4uj3z+4x4DsFrvLvl1/zRPj5qj/Wl/Rz7p2HD3Z+ftt99m7NixTJo0iaZNmyb6jyQiIpJyxBlxXL199YnTqJy/dZ7LEZeJMxLfd7az2CUYIf7gSPF729I4p1Et8QVSEd0kDnZWRgcXptb4taw5eIlpG0/yVik/s2OJiIikehaLJcmmVElO1q1bR+vWrWnQoAFwd9Tl8ePHX2iG/PnzJ5i7eN26deTJk8c2mtXe3p4qVapQpUoVBg4cSJo0aVi5ciUNGzbEYrFQtmxZypYty4ABA/Dz82P+/Pn06NHjhZ7Hy+z27dvMnTuXhQsXUr58eQAGDRrE77//zrfffsunn34K3J23+t50JLVq1XqumSwWS6KnVDFbcHAwXbt2Zfr06UyZMoX333/fdnG7bt066tWrx1tvvQXcneP84MGDFChQIFH7zp8/P6dOneLcuXP4+PgAsGHDhnht1q9fj5+fH/369bNtO3HiRLw2jo6OxMY+ft2H/PnzM3nyZMLDw23F5nXr1mG1WsmbN2+i8j7Mzz//TLNmzeLlAxg2bBg///wzVatWpVChQvzyyy9ER0cnKNJ7eHjg7+/PihUrqFSpUoL9Z8yYEbg7/dO9qaDuX2T0cZ70OzIwMJC4uDj+/vtv23QuD3rjjTdwc3Pj22+/ZcmSJaxZsyZRxxYREfMZhsH1O9fjF8NvPWTEePgFLoZfJCYuJtH7tmAhk1umh0+f8sDo8XQu6bBarM/xTOVZvXxXiClIrkzu9KmRjyF/7GXYn/t4LVcG/DOkjAsEERERSVly587NvHnzqFOnDhaLhf79+z+3EeWXLl1KULjy8fGhZ8+eFC9enKFDh9K0aVNCQ0OZMGEC33zzDQB//PEHR48epXz58qRNm5bFixcTFxdH3rx52bhxIytWrKBatWpkypSJjRs3cunSJfLnz/9cziG1iomJITY2Fmfn+FMNuri48M8//wB3i79vv/02vXv3pmDBgmbETLbc3d1p2rQpffv2JSwsjNatW9sey507N3PmzGH9+vWkTZuWMWPGcOHChUQX0atUqUKePHlo1aoVI0eOJCwsLEExOnfu3Jw8eZLffvuN4sWL8+effzJ//vx4bfz9/Tl27Bjbt28nW7ZseHh44OQUf1GwFi1aMHDgQFq1asWgQYO4dOkSnTt35u2337ZN5fK0Ll26xO+//86iRYt45ZVX4j3WsmVLGjRowNWrV+nUqRNfffUVzZo1o2/fvnh5ebFhwwZKlChB3rx5GTRoEO+99x6ZMmWiZs2a3Lx5k3Xr1tG5c2dcXFwoVaoUn3/+OQEBAVy8eDHeHPGP86Tfkf7+/rRq1Yq2bdvaFhY9ceIEFy9eJDg4GAA7Oztat25N3759yZ0790On2xERkRfHMAxuRd1KOI3KvalVwuMXyqNin+7usPQu6ROMDn9YcTyDawbsrSrBpnT6DpqsdRl/lu29QOjRK/ScvYNZ75bGzqpbMURERCRpjRkzhrZt21KmTBkyZMhAnz59CAsLey7Hmj59OtOnT4+3bejQoXzyySfMmjWLAQMGMHToUHx8fBgyZIit0JgmTRrmzZvHoEGDuHPnDrlz52bGjBkULFiQffv2sWbNGsaNG0dYWBh+fn6MHj06waKK8t94eHhQunRphg4dSv78+fH29mbGjBmEhoaSK1cuAL744gvs7e3p0qVLovcbGRlJZGSk7evn9d5LDtq1a8fPP//MG2+8EW+qm08++YSjR49SvXp1XF1d6dChA/Xr1+fGjcQtDGa1Wpk/fz7t2rWjRIkS+Pv7M378+HiL/NatW5fu3bvTqVMnIiMjqVWrFv3797ct2gnQqFEj5s2bR6VKlbh+/TqTJk2KV+wHcHV1JSQkhK5du1K8eHFcXV1p1KgRY8aMeebX5d4ipQ+bz7xy5cq4uLgwdepUunTpwsqVK+nduzcVKlTAzs6OwoULU7ZsWQBatWrFnTt3GDt2LL169SJDhgw0btzYtq+JEyfSrl07ihYtSt68eRkxYgTVqlV7Yr7E/I789ttv+fjjj/nggw+4cuUK2bNn5+OPP47Xpl27dnz22We0adPmWV4mERFJhIjoiIdPo/L/C3De/9jtmNtPte80zmnijw53SziNSmb3zGRyy4SDXcL1O+TlZTHunzAuFQgLC8PLy4sbN2489QI7z8uZ67epMXYNNyNj6FMjH+9XzGl2JBERkVThzp07HDt2jICAgAQjb0WSyuPeZ8mxb3rkyBHatm3LmjVrsLOz49VXXyVPnjxs3bqVqVOnUqtWLbZt22YrEPv7+9OtW7fHLiw6aNAgBg8enGD7w85bP5eSkq1du5bKlStz6tSpx47a1/tcRCS+yJjIJ06jcu+xm1E3n2rf7o7uT5xG5V5h3Nlev5NTm8T2x1VETyZmbzlF7zk7cbCzsKjTa+T3ST7ZREREXlYqYsiLkNKK6PeEh4cTFhaGj48PTZs25datW1StWpUePXrYFnCEu4tCWq1WfH19HznP/sNGovv6+qqILi+NyMhILl26RKtWrcicOTPTpk17bHu9z0UkNYiOjeZi+MWE06g8ZBHO63euP9W+ne2dbcXvhy3Cef/I8ZSytoqYI7H9cVOnc1mzZg0jR45k69atnDt3jvnz51O/fv3HPmf16tX06NGDPXv24OvryyeffJLg9sOUqHHRbCzde4Fley/QfeZ2FnYqi5O9ndmxRERERCSVcnNzw83NjWvXrhESEsKIESNo1KhRgkUVq1evzttvv/3Y6SucnJwSzLst8jKZMWMG7dq1o3DhwkyZMsXsOJIKhEeFM3ffXC7cuoDFYsFqsWLB8tjPLfz/10/xeWL3ndKP+bjj3/tX7oqNi+VyxOVEzTF+OeLyU+3bweoQf3S42yPmG3f3xsPRQ98XeaFMLaKHh4cTFBRE27Ztadiw4RPbHzt2jFq1avHee+8xbdo0VqxYQfv27fHx8aF69eovIPHzY7FYGN4wkG0nrrH//E3GLT9Enxr5zI4lIiIiIqlMSEgIhmGQN29eDh8+TO/evcmXLx9t2rTBwcGB9OnTx2vv4OBA5syZyZs3r0mJRczXunXrl2JwlyR/526eY8KmCXy39Tuu3r5qdpxUJbkV/l/kMW9G3bQVxy9FXCLOSPzi9HYWOzK5ZYpXAL+/OH5/gTyNcxoVxiXZMrWIXrNmzadaDOq7774jICCA0aNHA5A/f37++ecfxo4dm+KL6AAZ3J0Y1iCQ96Zu5fu/j1AlfyaK+qUzO5aIiIiIpCI3btygb9++nD59mnTp0tGoUSOGDRuGg4MWzxIRMcuO8zsYu2Es03dNJzouGoAcaXNQ1rcsBgaGYWBgEGfEPfRzw/j/r5/i88ftz4zjPOu+k4qBQawRSxLuMsWyYCGjW8bHTqNyb1t61/RYLdYn71QkmTO1iP60QkNDH3r76OMWMXrY/IvJWY1XMtPw1azM23aGHrN2sLhLOdycUtS3SURERERSsODgYIKDgxPd/lHzoIuIyH8TZ8QRcjiEMRvGsPzoctv2sr5l6Vm6J3Xz1sXOqmlgn+Rpi/DJ4Q8Gz3Kc57XvOCMONwe3eAXyDK4ZsLeqViWpS4p6x58/fz7BCufe3t6EhYVx+/ZtXFxcEjxn+PDhDB48+EVFTBID6xRkw5ErnLgSwfC/9vFp/UCzI4mIiIiIvFCGoaF+8vLS+1se507MHabunMqY0DHsu7wPAKvFSuMCjelRqgcls5U0OWHKcm9aEixgh/7oICLPJkUV0Z9F37596dGjh+3rsLAwfH19TUz0ZF4uDoxsEkSLnzYydcNJqhbITIU8Gc2OJSIiIiLy3Dk4OGCxWLh06RIZM2bU3Kjy0jEMg0uXLmGxWDRNksRzMfwi327+lq83f82liEsAeDh60P7V9nQp2QX/NP7mBhQRScVSVBE9c+bMXLhwId62Cxcu4Onp+dBR6ABOTk44OTm9iHhJqmyuDLQu48/k9cf5cM4OlnargJerOlgiIiIi8nKzs7MjW7ZsnD59WlPFyEvLYrGQLVs27Ow0KlZg36V9jN0wlik7phAZe3c6Wl9PX7qW7Er7V9vj5exlckIREUlRRfTSpUuzePHieNuWLVtG6dKlTUr0fPWpkY81By9x9HI4Axbt5stmRcyOJCIiIiLy3Lm7u5M7d26io6PNjiLyXDg4OKiAnsoZhsHKYysZHTqavw7/ZdtePEtxepbuSaMCjTTntIhIMmLqb+Rbt25x+PBh29fHjh1j+/btpEuXjuzZs9O3b1/OnDnDlClTAHjvvfeYMGECH374IW3btmXlypXMmjWLP//806xTeK5cHO0Y07Qwjb5dz8LtZ6lawJvahbKYHUtEREReEhUrVqRw4cKMGzcOAH9/f7p16/bYRdstFgvz58+nfv36/+nYSbUfeXnZ2dmpyCgiL52o2Ch+2/0bY0LHsOPCDgAsWKiXrx49S/ekrG9ZTWMlIpIMWc08+JYtWyhSpAhFitwdYd2jRw+KFCnCgAEDADh37hwnT560tQ8ICODPP/9k2bJlBAUFMXr0aH766SeqV69uSv4XobBvGjpWzAnAJwt2czHsjsmJRERExGx16tShRo0aD31s7dq1WCwWdu7c+dT73bx5Mx06dPiv8eIZNGgQhQsXTrD93Llz1KxZM0mP9aDJkyeTJk2a53oMERGRxLh6+yrD1w7Hf5w/rRa0YseFHbg6uNKxeEcOdj7I/KbzeS37ayqgi4gkU6aORK9YseJjVyWfPHnyQ5/z77//PsdUyU+n13OzYv9F9pwN46N5u/i5VTH9xyoiIpKKtWvXjkaNGnH69GmyZcsW77FJkyZRrFgxChUq9NT7zZjxxS1knjlz5hd2LBEREbMcunKIcRvGMXnHZCKiIwDI4pGFziU606FoB9K5pDM5oYiIJIapI9ElcRztrYxtWhhHeysr919k5uZTZkcSERERE9WuXZuMGTMmGHBw69YtZs+eTbt27bhy5QrNmzcna9asuLq6EhgYyIwZMx67X39/f9vULgCHDh2ifPnyODs7U6BAAZYtW5bgOX369CFPnjy4urqSI0cO+vfvb5vHevLkyQwePJgdO3ZgsViwWCy2zBaLhQULFtj2s2vXLl5//XVcXFxInz49HTp04NatW7bHW7duTf369Rk1ahQ+Pj6kT5+ejh07/qc5s0+ePEm9evVwd3fH09OT4ODgeIvY79ixg0qVKuHh4YGnpydFixZly5YtAJw4cYI6deqQNm1a3NzcKFiwYIK1e0REJHUyDIO1J9ZS/7f65J2Ql2+2fENEdARB3kFMqT+FY12P8dFrH6mALiKSgmiVihQij7cHvavlZdjifQz9Yy9lcmYge3pXs2OJiIi8fAwD/n+k2Avn4AqJuNvM3t6eli1bMnnyZPr162e7Q2327NnExsbSvHlzbt26RdGiRenTpw+enp78+eefvP322+TMmZMSJUo88RhxcXE0bNgQb29vNm7cyI0bNx46V7qHhweTJ08mS5Ys7Nq1i3feeQcPDw8+/PBDmjZtyu7du1myZAnLly8HwMvLK8E+wsPDqV69OqVLl2bz5s1cvHiR9u3b06lTp3h/KFi1ahU+Pj6sWrWKw4cP07RpUwoXLsw777zzxPN52PndK6D//fffxMTE0LFjR5o2bcrq1asBaNGiBUWKFOHbb7/Fzs6O7du34+DgAEDHjh2JiopizZo1uLm5sXfvXtzd3Z86h4iIvDyiY6OZu28uo0NHs+XsFtv2N3K/Qc/SPankX0l3lYuIpFAqoqcgbV8LYNm+C2w6dpVes3cwo0Mp7Kz6D1hERCRJRUfAZyYt5P3xWXB0S1TTtm3bMnLkSP7++28qVqwI3J3KpVGjRnh5eeHl5UWvXr1s7Tt37kxISAizZs1KVBF9+fLl7N+/n5CQELJkuft6fPbZZwnmMf/kk09sn/v7+9OrVy9+++03PvzwQ1xcXHB3d8fe3v6x07dMnz6dO3fuMGXKFNzc7p7/hAkTqFOnDl988QXe3t4ApE2blgkTJmBnZ0e+fPmoVasWK1aseKYi+ooVK9i1axfHjh3D19cXgClTplCwYEE2b95M8eLFOXnyJL179yZfvnwA5M6d2/b8kydP0qhRIwIDAwHIkSPHU2cQEZGXw407N/hx24+M3zieU2F37xx3tnemZaGWdCvVjfwZ85ucUERE/itN55KC2FktjG4ShJujHZuOX2XiP8fMjiQiIiImyZcvH2XKlGHixIkAHD58mLVr19KuXTsAYmNjGTp0KIGBgaRLlw53d3dCQkLiLdr+OPv27cPX19dWQAcoXbp0gnYzZ86kbNmyZM6cGXd3dz755JNEH+P+YwUFBdkK6ABly5YlLi6OAwcO2LYVLFgQOzs729c+Pj5cvHjxqY51/zF9fX1tBXSAAgUKkCZNGvbt2wfcXfS+ffv2VKlShc8//5wjR47Y2nbp0oVPP/2UsmXLMnDgwGdayFVERFK249eP031Jd7KNzUbvZb05FXaKTG6ZGFxxMCe7neT7Ot+rgC4i8pLQSPQUxjedK/1rF+CjebsYGXKA8nkykjezh9mxREREXh4OrndHhJt17KfQrl07OnfuzNdff82kSZPImTMnFSpUAGDkyJF8+eWXjBs3jsDAQNzc3OjWrRtRUVFJFjc0NJQWLVowePBgqlevjpeXF7/99hujR49OsmPc795UKvdYLBbi4uKey7EABg0axJtvvsmff/7JX3/9xcCBA/ntt99o0KAB7du3p3r16vz5558sXbqU4cOHM3r0aDp37vzc8oiISPKw8fRGRoeOZu6+ucQZd/8fKpCxAD1K9aBFoRY42zubnFBERJKaRqKnQE2L+/J6vkxExcbRY9Z2omKe38WjiIhIqmOx3J1SxYyPp5wnNTg4GKvVyvTp05kyZQpt27a1zbW6bt066tWrx1tvvUVQUBA5cuTg4MGDid53/vz5OXXqFOfOnbNt27BhQ7w269evx8/Pj379+lGsWDFy587NiRMn4rVxdHQkNjb2icfasWMH4eHhtm3r1q3DarWSN2/eRGd+GvfO79Sp/y3YvnfvXq5fv06BAgVs2/LkyUP37t1ZunQpDRs2ZNKkSbbHfH19ee+995g3bx49e/bkxx9/fC5ZRUTEfLFxsczbN4+yE8tS6udSzN47mzgjjqo5qvJXi7/Y/f5u2r3aTgV0EZGXlIroKZDFYuHzRoGkdXVgz9kwvlp5yOxIIiIiYgJ3d3eaNm1K3759OXfuHK1bt7Y9ljt3bpYtW8b69evZt28f7777LhcuXEj0vqtUqUKePHlo1aoVO3bsYO3atfTr1y9em9y5c3Py5El+++03jhw5wvjx45k/f368Nv7+/hw7dozt27dz+fJlIiMjExyrRYsWODs706pVK3bv3s2qVavo3Lkzb7/9tm0+9GcVGxvL9u3b433s27ePKlWqEBgYSIsWLdi2bRubNm2iZcuWVKhQgWLFinH79m06derE6tWrOXHiBOvWrWPz5s3kz3/3tvxu3boREhLCsWPH2LZtG6tWrbI9JiIiL49bUbcYv3E8ub/KTaNZjVh/aj0OVgdaF27Njvd2sPTtpdTIVUMLhoqIvORURE+hMnk482n9uwtZfbP6CP+evGZyIhERETFDu3btuHbtGtWrV483f/knn3zCq6++SvXq1alYsSKZM2emfv36id6v1Wpl/vz53L59mxIlStC+fXuGDRsWr03dunXp3r07nTp1onDhwqxfv57+/fvHa9OoUSNq1KhBpUqVyJgxIzNmzEhwLFdXV0JCQrh69SrFixencePGVK5cmQkTJjzdi/EQt27dokiRIvE+6tSpg8ViYeHChaRNm5by5ctTpUoVcuTIwcyZMwGws7PjypUrtGzZkjx58hAcHEzNmjUZPHgwcLc437FjR/Lnz0+NGjXIkycP33zzzX/OKyIiycPpsNP0WdYH37G+dF3SlWPXj5HOJR39yvXjRLcTTKo3iULehcyOKSIiL4jFMAzD7BAvUlhYGF5eXty4cQNPT0+z4/xnXX/7l4Xbz5Ijgxt/dimHi6Pdk58kIiIiANy5c4djx44REBCAs7Nuv5bn43Hvs5etb5pYqfW8RST523ZuG2NCxzBzz0xi4mIAyJ0uN91LdadlUEvcHN2esAcREUlJEtsv1cKiKdyQuq+w4egVjl4O54sl+xlUt6DZkURERERERERSjDgjjsWHFjM6dDSrj6+2ba/gV4EepXtQO09trBbdyC8ikpqpiJ7Cebk6MLJxEC0nbmLy+uNULeBN2VwZzI4lIiIiIiIikqxFREfw645fGbthLAeuHADAzmJH01ea0r1Ud4plKWZyQhERSS5URH8JlM+TkbdKZWfqhpP0mr2DJd3K4+XiYHYsERERERERkWTn/K3zfL3pa77d8i1Xbl8BwMvJiw5FO9C5RGd8vXxNTigiIsmNiugviY/fyM/aQ5c5cSWCwb/vYUxwYbMjiYiIiIiIiCQbuy/uZkzoGKbtmkZUbBQA/mn86VayG22LtMXDycPkhCIiklypiP6ScHW0Z0xwEE2+C2XetjNUK5CZGq9kNjuWiIiIiIiIiGkMw2DZ0WWMDh3N0iNLbdtLZytNj9I9qJ+vPvZWlUZEROTx9D/FS6SoXzreq5CTb1Yfod/8XRTzT0sGdyezY4mIiCR7cXFxZkeQl5jeXyIiL15kTCTTdk1jTOgY9lzaA4DVYqVh/ob0KNWD0r6lTU4oIiIpiYroL5muVXKzcv9F9p+/Sd95u/jh7aJYLBazY4mIiCRLjo6OWK1Wzp49S8aMGXF0dNT/m5JkDMMgKiqKS5cuYbVacXR0NDuSiMhL73LEZb7d/C1fb/6aC+EXAHB3dKddkXZ0KdmFHGlzmJxQRERSIhXRXzJO9naMbVqYuhP+YdneC8zZepomxbQoioiIyMNYrVYCAgI4d+4cZ8+eNTuOvKRcXV3Jnj07VqvV7CgiIi+tA5cPMHbDWH7Z8Qt3Yu4AkM0zG11KdOGdou+QxjmNuQFFRCRFUxH9JZTfx5MeVfPyxZL9DP59L6VzpidbWlezY4mIiCRLjo6OZM+enZiYGGJjY82OIy8ZOzs77O3tdYeDiMhzYBgGq4+vZsyGMfxx8A/b9qI+RelZuieNCzTGwc7BxIQiIvKyUBH9JdWhfA6W77vA1hPX6D17J9Pal8Rq1cWbiIjIw1gsFhwcHHBw0IW2iIhIchcVG8WsPbMYEzqGf8//C4AFC3Xy1qFn6Z6Uy15Of7wUEZEkpSL6S8rOamF0kyBqfrmW0KNXmLz+OG1fCzA7loiIiIiIiMgzuXb7Gj9s/YGvNn3FmZtnAHCxd6F14dZ0K9WNPOnzmJxQREReViqiv8T8M7jRr1Z+Plmwmy+W7Kd8ngzkyuRhdiwRERERERGRRDty9QhfbvySif9OJDw6HIDM7pnpVLwT7xV7j/Su6U1OKCIiLzsV0V9yLUpmZ+neC6w5eIkes3Yw9/0yONhpUSsRERERERFJvgzDYP2p9YzZMIb5++ZjYAAQmCmQHqV70PyV5jjZO5mcUkREUgsV0V9yFouFEY0KUW3s3+w8fYNvVh2ha5XcZscSERERERERSSAmLoZ5++YxJnQMG89stG2vkasGPUv3pHJAZc13LiIiL5yK6KlAZi9nhtZ/ha6/beerlYeolC8jhbKlMTuWiIiIiIiICABhkWH8vO1nvtz4JSdunADAyc6Jtwq9RfdS3SmYqaDJCUVEJDVTET2VqBuUhaV7L/DnznP0mLWDPzq/hrODndmxREREREREJBU7eeMk4zeO58dtPxIWGQZABtcMdCzekfeLvY+3u7fJCUVERFRETzUsFguf1nuFTceucvjiLUaGHKB/7QJmxxIREREREZFUaPOZzYzZMIbZe2YTa8QCkC9DPnqU6sFbhd7CxcHF5IQiIiL/oyJ6KpLWzZERjQrRZvJmJq47RpX83pTOqVXMRURERERE5PmLjYvl94O/MyZ0DGtPrrVtfz3gdXqW7kmNXDWwWqwmJhQREXk4FdFTmUr5MtG8hC8zNp2i1+wdLOlWDg9nB7NjiYiIiIiIyEsqPCqcydsnM27jOA5fPQyAg9WB5oHN6V6qO4UzFzY3oIiIyBOoiJ4K9atVgH8OX+bU1dsM/WMvIxoHmR1JREREREREXjJnb55lwqYJfLflO67duQZAGuc0vFf0PTqV6ERWz6wmJxQREUkcFdFTIXcne0Y3KUzTH0KZteU01QpkpkoBLdYiIiIiIiIi/92O8zsYs2EMM3bNIDouGoCcaXPSvVR3WhVuhbuju8kJRUREno6K6KlUiYB0vFMuBz+sOcpH83YSkr086d2dzI4lIiIiIiIiKVCcEceSw0sYEzqGFcdW2LaXy16OHqV7UCdPHeysdiYmFBEReXYqoqdiParmYfWBixy8cIt+83fz7VuvYrFYzI4lIiIiIiIiKcTt6NtM3TmVsRvGsu/yPgDsLHY0LtCYHqV7UCJrCZMTioiI/Hcqoqdizg52jAkuTP2v17Fkz3kWbD9DgyLZzI4lIiIiIiIiydzF8It8s/kbvtn8DZciLgHg4ehBh6Id6FyiM35p/ExOKCIiknRURE/lXsnqRbcquRm19CADFu6hZEB6sqRxMTuWiIiIiIiIJEN7L+1lbOhYft35K5GxkQD4efnRtWRX2r3aDk8nT5MTioiIJD0V0YX3KuRk+b6LbD91nQ/n7GRK2xJYrZrWRURERERERMAwDFYcW8GY0DH8dfgv2/YSWUvQs3RPGuZviL1V5QUREXl5Wc0OIOazt7MyOjgIZwcr/xy+zNSNJ8yOJCIiIiImuXnzJt26dcPPzw8XFxfKlCnD5s2bAYiOjqZPnz4EBgbi5uZGlixZaNmyJWfPnjU5tYg8D5Exkfyy/RcKf1+Yqr9W5a/Df2HBQsP8DfmnzT9saLeB4ILBKqCLiMhLT//TCQA5M7rTt2Z+Bi7aw2eL9/FargzkyOhudiwRERERecHat2/P7t27+fXXX8mSJQtTp06lSpUq7N27F3d3d7Zt20b//v0JCgri2rVrdO3albp167Jlyxazo4tIErkScYXvt37PhE0TOHfrHABuDm60LdKWriW7kjNdTpMTioiIvFgWwzAMs0O8SGFhYXh5eXHjxg08PTVX2/3i4gxaTtzEP4cvU9g3DXPeK429nW5WEBEREXleklvf9Pbt23h4eLBw4UJq1apl2160aFFq1qzJp59+muA5mzdvpkSJEpw4cYLs2bMn6jjJ7bxF5K5DVw4xbsM4Jm2fxO2Y2wBk8chClxJd6FC0A2ld0pqcUEREJGkltl+qkehiY7VaGNG4ENXHrWH7qet8v+YoHSvlMjuWiIiIiLwgMTExxMbG4uzsHG+7i4sL//zzz0Ofc+PGDSwWC2nSpHnkfiMjI4mMjLR9HRYWliR5ReS/MwyDtSfXMiZ0DIsOLMLg7ji7wpkL07N0T4ILBuNo52hyShEREXNpmLHEkyWNC4PrFgRg7LKD7D5zw+REIiIiIvKieHh4ULp0aYYOHcrZs2eJjY1l6tSphIaGcu7cuQTt79y5Q58+fWjevPljR+4MHz4cLy8v24evr+/zPA0RSYTo2Ghm7JpBiZ9KUGFyBRYeWIiBQe08tVnZciXbOmzjrUJvqYAuIiKCpnMxO06yZBgG70/dxpI958nr7cHCTmVxdrAzO5aIiIjISyc59k2PHDlC27ZtWbNmDXZ2drz66qvkyZOHrVu3sm/fPlu76OhoGjVqxOnTp1m9evVj8z9sJLqvr2+yOm+R1OL6nev8tO0nxm8cz6mwUwA42zvTKqgV3Up1I1+GfCYnFBEReXE0nYs8M4vFwrAGr7DlxFUOXLjJ2GUH6ftGfrNjiYiIiMgLkDNnTv7++2/Cw8MJCwvDx8eHpk2bkiNHDlub6OhogoODOXHiBCtXrnxiIdzJyQknJ6fnHV1EHuPYtWN8ufFLfv73Z25F3QIgk1smOhXvxPvF3yeDawaTE4qIiCRfKqLLQ6V3d2J4w0K8M2ULP6w9SpUC3hT3T2d2LBERERF5Qdzc3HBzc+PatWuEhIQwYsQI4H8F9EOHDrFq1SrSp09vclIReZwNpzcwJnQMc/fNJc6IA6BgxoL0KN2DNwPfxNne+Ql7EBERERXR5ZGqFvCmSdFszN56mh6ztvNX1/K4O+ktIyIiIvIyCwkJwTAM8ubNy+HDh+nduzf58uWjTZs2REdH07hxY7Zt28Yff/xBbGws58+fByBdunQ4OmruZJHkIDYulgX7FzA6dDShp0Nt26vlrEaPUj2olrMaFovFxIQiIiIpiyqi8lgD6hRg/ZErnLp6m2F/7mN4w0CzI4mIiIjIc3Tjxg369u3L6dOnSZcuHY0aNWLYsGE4ODhw/PhxFi1aBEDhwoXjPW/VqlVUrFjxxQcWEZubkTeZtH0S4zaM49j1YwA42jnSIrAF3Ut1J9Bb13MiIiLPQguLyhOFHrlC8x83ADCpdXEq5ctkciIRERGRl0Nq7Zum1vMWeV5Oh53mq41f8f3W77kReQOA9C7peb/Y+3Qs0ZHM7plNTigiIpI8aWFRSTKlc6anbdkAJq47Rp+5OwnpVp60brpVV0RERERExEzbzm1jdOhoZu2ZRUxcDAB50uehe6nutAxqiauDq8kJRUREXg4qokuifFgjL38fvMiRS+H0X7ibCW++anYkERERERGRVCfOiOPPg38yOnQ0f5/427a9on9FepTqQa08tbBarCYmFBERefmoiC6J4uxgx9imhWnwzXr+2HmOagXPUjcoi9mxREREREREUoWI6Aim7JjC2A1jOXjlIAD2VnuaFmxKj9I9eNVHA51ERESeFxXRJdEKZUtDp0q5+HLFIfov2E3JgHR4ezqbHUtEREREROSldf7WeSZsmsC3W77l6u2rAHg5efFu0XfpXLIz2TyzmZxQRETk5aciujyVTq/nYuX+i+w6c4MP5+xkcpviWCwWs2OJiIiIiIi8VHZd2MWYDWOYvms6UbFRAASkCaBbqW60LdIWd0d3kxOKiIikHiqiy1NxsLMytmkQb4z/h78PXmL6ppO0KOlndiwREREREZEUzzAMlh5ZyujQ0Sw7usy2vYxvGXqW7km9vPWws9qZmFBERCR1Mn21ka+//hp/f3+cnZ0pWbIkmzZtemz7cePGkTdvXlxcXPD19aV79+7cuXPnBaUVgFyZPOhTIx8Aw/7cx4kr4SYnEhERERERSbnuxNzh520/E/htIDWm1WDZ0WVYLVaaFGhCaLtQ1rVdR8P8DVVAFxERMYmpI9FnzpxJjx49+O677yhZsiTjxo2jevXqHDhwgEyZMiVoP336dD766CMmTpxImTJlOHjwIK1bt8ZisTBmzBgTziD1alPGn2V7z7Ph6FV6ztrBzHdLY2fVtC4iIiIiIiKJdSn8Et9u+ZavN3/NxfCLALg7utO+SHu6luqKfxp/cwOKiIgIYPJI9DFjxvDOO+/Qpk0bChQowHfffYerqysTJ058aPv169dTtmxZ3nzzTfz9/alWrRrNmzd/4uh1SXpWq4WRjYNwd7Jny4lr/Lj2qNmRREREREREUoT9l/fz7u/vkn1cdgauHsjF8Iv4evoyquooTnc/zdgaY1VAFxERSUZMK6JHRUWxdetWqlSp8r8wVitVqlQhNDT0oc8pU6YMW7dutRXNjx49yuLFi3njjTceeZzIyEjCwsLifUjS8E3nyoA6BQAYs/Qg+87ptRUREREREXkYwzBYdWwVtafXJv/X+flh2w/ciblDsSzFmNFoBke6HKFnmZ54OXuZHVVEREQeYNp0LpcvXyY2NhZvb+942729vdm/f/9Dn/Pmm29y+fJlXnvtNQzDICYmhvfee4+PP/74kccZPnw4gwcPTtLs8j9NimZj6Z4LLN93gR6zdrCwY1kc7U2fal9ERERERCRZiIqNYubumYzZMIbt57cDYMFC3bx16Vm6J69lfw2LRVNjioiIJGcpqtq5evVqPvvsM7755hu2bdvGvHnz+PPPPxk6dOgjn9O3b19u3Lhh+zh16tQLTPzys1gsDG8YSDo3R/adC+PLFQfNjiQiIiIiImK6a7ev8fk/nxPwZQAtF7Rk+/ntuDq40rF4Rw50OsCCZgso51dOBXQREZEUwLSR6BkyZMDOzo4LFy7E237hwgUyZ8780Of079+ft99+m/bt2wMQGBhIeHg4HTp0oF+/flitCf8m4OTkhJOTU9KfgNhk9HBiWP1XeH/aNr5dfYTX83lT1C+t2bFEREREREReuPCocD5e8TE//fsTEdERAPi4+9C5RGfeLfYu6VzSmZxQREREnpZpI9EdHR0pWrQoK1assG2Li4tjxYoVlC5d+qHPiYiISFAot7OzA+7OLyfmqRnoQ8MiWYkzoOes7URExZgdSURERERE5IUyDIOWC1oyftN4IqIjKORdiF/q/8LxbsfpW66vCugiIiIplGkj0QF69OhBq1atKFasGCVKlGDcuHGEh4fTpk0bAFq2bEnWrFkZPnw4AHXq1GHMmDEUKVKEkiVLcvjwYfr370+dOnVsxXQxz8C6BQk9eoXjVyIYvng/Q+u/YnYkERERERGRF+bzfz5n3r55OFgdmBM8hzp56mi6FhERkZeAqUX0pk2bcunSJQYMGMD58+cpXLgwS5YssS02evLkyXgjzz/55BMsFguffPIJZ86cIWPGjNSpU4dhw4aZdQpyHy8XB0Y2DuKtnzfy64YTVC3gTfk8Gc2OJSIiIiIi8tyFHA6h38p+AEx4YwJ189Y1OZGIiIgkFYuRyuZBCQsLw8vLixs3buDp6Wl2nJfSwIW7+SX0BJk9nQnpVh4vVwezI4mIiIgkS6m1b5paz1teXkevHaXYD8W4duca7Yu058e6P5odSURERBIhsf1S0+ZEl5fXRzXzkyODG+fD7jBw0W6z44iIiIiIiDw3EdERNJzZkGt3rlEiawkmvDHB7EgiIiKSxFRElyTn4mjH6OAgrBZYsP0si3edMzuSiIiIiIhIkjMMg3d+f4cdF3aQyS0Tc4Pn4mTvZHYsERERSWIqostzUSR7Wj6omAuAfvN3cfHmHZMTiYiIiIiIJK0vN37J9F3TsbPYMavxLLJ5ZjM7koiIiDwHKqLLc9Olcm4K+HhyLSKavnN3kcqm3xcRERERkZfY6uOr6bW0FwCjq42mgn8FkxOJiIjI86Iiujw3jvZWxjYtjKOdlRX7LzJryymzI4mIiIiIiPxnp26cInh2MLFGLC0CW9ClZBezI4mIiMhzpCK6PFd5M3vQq3oeAIb8vpdTVyNMTiQiIiIiIvLs7sTcodGsRlyKuEThzIX5oc4PWCwWs2OJiIjIc6Qiujx37V7LQQn/dIRHxdJz9g7i4jSti4iIiIiIpDyGYdBpcSc2n91MOpd0zAueh6uDq9mxRERE5DlTEV2eOzurhVFNgnB1tGPTsatMXHfM7EgiIiIiIiJP7YetP/Dzvz9jtViZ0WgGAWkDzI4kIiIiL4C92QEkdcie3pX+tQvQd94uRoQcoHyejOTx9jA7loiIiEiKFxcXx99//83atWs5ceIEERERZMyYkSJFilClShV8fX3NjijyUgg9FUrnvzoDMOz1YVTLWc3kRCIiIvKiaCS6vDDNivtSKW9GomLi6DFrO9GxcWZHEhEREUmxbt++zaeffoqvry9vvPEGf/31F9evX8fOzo7Dhw8zcOBAAgICeOONN9iwYYPZcUVStPO3ztN4dmOi46JplL8Rfcr2MTuSiIiIvEAqossLY7FY+KJRIdK4OrD7TBhfrTxsdiQRERGRFCtPnjzs3LmTH3/8kbCwMEJDQ5k7dy5Tp05l8eLFnDx5kiNHjlCuXDmaNWvGjz/+aHZkkRQpKjaKJrObcPbmWQpkLMCkepO0kKiIiEgqYzEMI1Wt8hgWFoaXlxc3btzA09PT7Dip0h87z9Jp+r/YWS3Mfb8MhX3TmB1JRERExBT/pW+6b98+8ufPn6i20dHRnDx5kpw5cz5LzCSnPrmkJJ0Xd2bC5gl4Onmy+Z3N5Emfx+xIIiIikkQS2y/VSHR54WoXykLdoCzExhn0mLWd21GxZkcSERERSXESW0AHcHBwSDYFdJGUZMqOKUzYPAGAXxv8qgK6iIhIKqUiuphiSL2CZPJw4uilcL5Yst/sOCIiIiIvhZiYGL7++muaNGlCw4YNGT16NHfu3DE7lkiKtO3cNt79410ABpQfQN28dU1OJCIiImZREV1MkcbVkRGNCwEwef1x1h++bHIiERERkZSvS5cuzJ8/n0qVKlGhQgWmT59OmzZtzI4lkuJcjrhMg5kNuBNzh1q5azGw4kCzI4mIiIiJ7M0OIKlXxbyZaFEyO9M2nqTX7B0s6V4eT2cHs2OJiIiIpBjz58+nQYMGtq+XLl3KgQMHsLOzA6B69eqUKlXKrHgiKVJMXAzN5jTj5I2T5EqXi6kNp2K1aPyZiIhIaqaegJjq4zfy45felbM37jB40V6z44iIiIikKBMnTqR+/fqcPXsWgFdffZX33nuPJUuW8Pvvv/Phhx9SvHhxk1OKpCwfr/iYFcdW4ObgxoKmC0jjnMbsSCIiImIyFdHFVG5O9oxuEoTFAnO3nSZkz3mzI4mIiIikGL///jvNmzenYsWKfPXVV/zwww94enrSr18/+vfvj6+vL9OnTzc7pkiKMWvPLEauHwnApHqTKJipoMmJREREJDlQEV1MV8w/He+WzwnAx/N2cflWpMmJRERERFKOpk2bsmnTJnbt2kX16tV566232Lp1K9u3b+frr78mY8aMZkcUSRF2X9xN24VtAfiwzIc0KdjE5EQiIiKSXKiILslC96q5yZfZgyvhUfSdtwvDMMyOJCIiIpJipEmThh9++IGRI0fSsmVLevfuzZ07d8yOJZJiXL9znQYzGxAeHU6VHFUYVnmY2ZFEREQkGVERXZIFJ3s7xgQXxsHOwrK9F5i77YzZkURERESSvZMnTxIcHExgYCAtWrQgd+7cbN26FVdXV4KCgvjrr7/MjiiS7MUZcbSY14LDVw/j5+XHb41+w95qb3YsERERSUZURJdko0AWT7pVyQPA4EV7OHP9tsmJRERERJK3li1bYrVaGTlyJJkyZeLdd9/F0dGRwYMHs2DBAoYPH05wcLDZMUWStUGrB7H40GKc7Z2Z33Q+6V3Tmx1JREREkhn9eV2SlXfL52DFvgtsO3md3rN3MLVdSaxWi9mxRERERJKlLVu2sGPHDnLmzEn16tUJCAiwPZY/f37WrFnDDz/8YGJCkeRt4f6FDF0zFIAfav9AEZ8iJicSERGR5Egj0SVZsbezMjq4MC4Odqw/coVfQo+bHUlEREQk2SpatCgDBgxg6dKl9OnTh8DAwARtOnToYEIykeTvwOUDvD3/bQA6l+jM20Fvm5xIREREkisV0SXZCcjgxse18gPw+V/7OXzxlsmJRERERJKnKVOmEBkZSffu3Tlz5gzff//9f97nzZs36datG35+fri4uFCmTBk2b95se9wwDAYMGICPjw8uLi5UqVKFQ4cO/efjirxINyNv0mBmA25G3aRc9nKMrjba7EgiIiKSjKmILsnSWyWzUy53BiJj4ug5azsxsXFmRxIRERFJdvz8/JgzZw579uxh2rRpZMmS5T/vs3379ixbtoxff/2VXbt2Ua1aNapUqcKZM3cXfh8xYgTjx4/nu+++Y+PGjbi5uVG9enXu3Lnzn48t8iIYhkHrha3Zd3kfWTyyMKvJLBzsHMyOJSIiIsmYiuiSLFksFkY0LoSnsz07Tt/gm9VHzI4kIiIikqyEh4cnefvbt28zd+5cRowYQfny5cmVKxeDBg0iV65cfPvttxiGwbhx4/jkk0+oV68ehQoVYsqUKZw9e5YFCxY845mIvFif//M58/bNw8HqwNzguWR2z2x2JBEREUnmVESXZMvHy4Wh9V8BYPyKQ+w6fcPkRCIiIiLJR65cufj88885d+7cI9sYhsGyZcuoWbMm48ePf+I+Y2JiiI2NxdnZOd52FxcX/vnnH44dO8b58+epUqWK7TEvLy9KlixJaGjos5+MyAsScjiEfiv7ATDhjQmUylbK5EQiIiKSEtibHUDkceoGZWHpngv8uescPWZt5/fOr+HsYGd2LBERERHTrV69mo8//phBgwYRFBREsWLFyJIlC87Ozly7do29e/cSGhqKvb09ffv25d13333iPj08PChdujRDhw4lf/78eHt7M2PGDEJDQ8mVKxfnz58HwNvbO97zvL29bY89TGRkJJGRkbavw8LCnvGsRZ7d0WtHaT63OQYG7Yu0p0NRLborIiIiiaOR6JKsWSwWhtZ/hQzuThy6eIvRSw+YHUlEREQkWcibNy9z587l4MGDBAcHc+bMGebMmcOPP/7I6tWryZo1Kz/++CPHjx/ngw8+wM4ucQMRfv31VwzDIGvWrDg5OTF+/HiaN2+O1frslw7Dhw/Hy8vL9uHr6/vM+xJ5FhHRETSc2ZBrd65RImsJJrwxwexIIiIikoJYDMMwzA7xIoWFheHl5cWNGzfw9PQ0O44k0op9F2j3yxYsFpjxTilK5UhvdiQRERGR/yw5903Dw8MJCwvDx8eHpk2bcuvWLb766ity5szJv//+S+HChW1tK1SoQOHChfnyyy8fuq+HjUT39fVNluctLx/DMHhr/ltM3zWdTG6Z2NphK9k8s5kdS0RERJKBxPbHNRJdUoTK+b1pVtwXw4Bes3dw80602ZFEREREXmpubm74+Phw7do1QkJCqFevHgEBAWTOnJkVK1bY2oWFhbFx40ZKly79yH05OTnh6ekZ70PkRfly45dM3zUdO4sdsxrPUgFdREREnpqK6JJifFK7ANnSunD62m0+/WOf2XFEREREXkohISEsWbKEY8eOsWzZMipVqkS+fPlo06YNFouFbt268emnn7Jo0SJ27dpFy5YtyZIlC/Xr1zc7ukgCq4+vptfSXgCMrjaaCv4VTE4kIiIiKZGK6JJiuDvZM7pJEBYLzNxyihX7LpgdSUREROSlc+PGDTp27Ei+fPlo2bIlr732GiEhITg4OADw4Ycf0rlzZzp06EDx4sW5desWS5YswdnZ2eTkIvGdunGK4NnBxBqxtAhsQZeSXcyOJCIiIimU5kSXFGfYn3v5ce0xMrg7sbR7edK5OZodSUREROSZpNa+aWo9b3lx7sTcofyk8mw+u5nCmQuzru06XB1czY4lIiIiyYzmRJeXVs9qecmdyZ3LtyLpN38XqezvQCIiIiIi8hiGYdBpcSc2n91MOpd0zAuepwK6iIiI/CcqokuK4+xgx9imhbG3Wvhr93kWbj9rdiQRERERU/n7+zNkyBBOnjxpdhQR0/2w9Qd+/vdnrBYrMxrNICBtgNmRREREJIVTEV1SpFeyetGlcm4ABizczbkbt01OJCIiImKebt26MW/ePHLkyEHVqlX57bffiIyMNDuWyAsXeiqUzn91BmDY68OolrOayYlERETkZaAiuqRYH1TMSZBvGsLuxPDhnJ2a1kVERERSrW7durF9+3Y2bdpE/vz56dy5Mz4+PnTq1Ilt27aZHU/khTh/6zyNZzcmOi6aRvkb0adsH7MjiYiIyEtCRXRJseztrIwJDsLJ3sraQ5eZuuGE2ZFERERETPXqq68yfvx4zp49y8CBA/npp58oXrw4hQsXZuLEiRp0IC+tqNgomsxuwtmbZymQsQCT6k3CYrGYHUtEREReEiqiS4qWM6M7H9XMB8Cwxfs4djnc5EQiIiIi5omOjmbWrFnUrVuXnj17UqxYMX766ScaNWrExx9/TIsWLcyOKPJc9AzpyT8n/8HTyZP5Tefj4eRhdiQRERF5idg/y5NOnTqFxWIhW7ZsAGzatInp06dToEABOnTokKQBRZ6kVWl/lu29wPojV+g5azuz3i2NvZ3+PiQiIiKpx7Zt25g0aRIzZszAarXSsmVLxo4dS758+WxtGjRoQPHixU1MKfJ8TNkxhQmbJwDwa4NfyZM+j8mJRERE5GXzTJXGN998k1WrVgFw/vx5qlatyqZNm+jXrx9DhgxJ0oAiT2K1WhjZJAgPJ3u2nbzO92uOmh1JRERE5IUqXrw4hw4d4ttvv+XMmTOMGjUqXgEdICAggGbNmpmUUOT52HZuG+/+8S4AA8oPoG7euiYnEhERkZfRMxXRd+/eTYkSJQCYNWsWr7zyCuvXr2fatGlMnjw5KfOJJErWNC4MqlsQgHHLD7Ln7A2TE4mIiIi8OEePHmXJkiU0adIEBweHh7Zxc3Nj0qRJLziZyPNzOeIyDWY24E7MHWrlrsXAigPNjiQiIiIvqWcqokdHR+Pk5ATA8uXLqVv37l/78+XLx7lz55IunchTaPhqVqoV8CY61qDHzB1ExsSaHUlERETkhbh48SIbN25MsH3jxo1s2bLFhEQiz1dMXAzN5jTj5I2T5EqXi6kNp2K1aEpHEREReT6eqZdRsGBBvvvuO9auXcuyZcuoUaMGAGfPniV9+vRJGlAksSwWC581DCS9myMHLtxk7LJDZkcSEREReSE6duzIqVOnEmw/c+YMHTt2NCGRyPP18YqPWXFsBW4ObsxvOp80zmnMjiQiIiIvsWcqon/xxRd8//33VKxYkebNmxMUFATAokWLbNO8iJghg7sTwxsGAvD9miNsPn7V5EQiIiIiz9/evXt59dVXE2wvUqQIe/fuNSGRyPMza88sRq4fCcCkepN4JdMrJicSERGRl539szypYsWKXL58mbCwMNKmTWvb3qFDB1xdXZMsnMizqFYwM42LZmPO1tP0nLWDv7qWw83pmd7qIiIiIimCk5MTFy5cIEeOHPG2nzt3Dnt79YPk5bH74m7aLmwLwIdlPqRJwSYmJxIREZHU4JlGot++fZvIyEhbAf3EiROMGzeOAwcOkClTpiQNKPIsBtQpQNY0Lpy8GsGwxfvMjiMiIiLyXFWrVo2+ffty48b/Fle/fv06H3/8MVWrVjUxmUjSuX7nOg1mNiA8OpwqOaowrPIwsyOJiIhIKvFMRfR69eoxZcoU4G7nvGTJkowePZr69evz7bffJmlAkWfh6ezAyMaFAJi+8SSrDlw0OZGIiIjI8zNq1ChOnTqFn58flSpVolKlSgQEBHD+/HlGjx5tdjyR/yzOiKPFvBYcvnoYPy8/fmv0G/ZW3WUhIiIiL8YzFdG3bdtGuXLlAJgzZw7e3t6cOHGCKVOmMH78+CQNKPKsyuTKQJuy/gD0mbOT6xFR5gYSEREReU6yZs3Kzp07GTFiBAUKFKBo0aJ8+eWX7Nq1C19fX7Pjifxng1YPYvGhxTjbOzO/6XzSu6Y3O5KIiIikIs/0p/uIiAg8PDwAWLp0KQ0bNsRqtVKqVClOnDiRpAFF/os+NfKx5uAljlwKp//CPXzVvIjZkURERESeCzc3Nzp06GB2DJEkt3D/QoauGQrAD7V/oIiP+vQiIiLyYj3TSPRcuXKxYMECTp06RUhICNWqVQPg4sWLeHp6PtW+vv76a/z9/XF2dqZkyZJs2rTpse2vX79Ox44d8fHxwcnJiTx58rB48eJnOQ1JBZwd7BgTXBg7q4Xfd5zl9x1nzY4kIiIi8tzs3buXJUuWsGjRongfIinVgcsHeHv+2wB0LtGZt4PeNjmRiIiIpEbPNBJ9wIABvPnmm3Tv3p3XX3+d0qVLA3dHpRcpkvhRATNnzqRHjx589913lCxZknHjxlG9evVHLlAaFRVF1apVyZQpE3PmzCFr1qycOHGCNGnSPMtpSCoR5JuGjpVyMX7FIfov3E2JgHR4ezqbHUtEREQkyRw9epQGDRqwa9cuLBYLhmEAYLFYAIiNjTUznsgzuRl5kwYzG3Az6iblspdjdDXN7y8iIiLmeKaR6I0bN+bkyZNs2bKFkJAQ2/bKlSszduzYRO9nzJgxvPPOO7Rp04YCBQrw3Xff4erqysSJEx/afuLEiVy9epUFCxZQtmxZ/P39qVChAkFBQc9yGpKKdH49F69k9eR6RDR95u60XViKiIiIvAy6du1KQEAAFy9exNXVlT179rBmzRqKFSvG6tWrzY4n8tQMw6D1wtbsu7yPLB5ZmNVkFg52DmbHEhERkVTqmYroAJkzZ6ZIkSKcPXuW06dPA1CiRAny5cuXqOdHRUWxdetWqlSp8r8wVitVqlQhNDT0oc9ZtGgRpUuXpmPHjnh7e/PKK6/w2WefPXZkTWRkJGFhYfE+JPVxsLMyNrgwjvZWVh+4xIxNp8yOJCIiIpJkQkNDGTJkCBkyZMBqtWK1WnnttdcYPnw4Xbp0MTueyFP7/J/PmbdvHg5WB+YGzyWze2azI4mIiEgq9kxF9Li4OIYMGYKXlxd+fn74+fmRJk0ahg4dSlxcXKL2cfnyZWJjY/H29o633dvbm/Pnzz/0OUePHmXOnDnExsayePFi+vfvz+jRo/n0008feZzhw4fj5eVl+/D19U38icpLJbe3Bx9WzwvAp3/u5cSVcJMTiYiIiCSN2NhYPDw8AMiQIQNnz95dB8bPz48DBw6YGU3kqYUcDqHfyn4ATHhjAqWylTI5kYiIiKR2z1RE79evHxMmTODzzz/n33//5d9//+Wzzz7jq6++on///kmd0SYuLo5MmTLxww8/ULRoUZo2bUq/fv347rvvHvmcvn37cuPGDdvHqVMagZyatS0bQMmAdERExdJr9g5i4zSti4iIiKR8r7zyCjt27ACgZMmSjBgxgnXr1jFkyBBy5MhhcjqRxDt67SjN5zbHwKB9kfZ0KNrB7EgiIiIiz7aw6C+//MJPP/1E3bp1bdsKFSpE1qxZ+eCDDxg2bNgT95EhQwbs7Oy4cOFCvO0XLlwgc+aH36rn4+ODg4MDdnZ2tm358+fn/PnzREVF4ejomOA5Tk5OODk5JfbU5CVntVoY1SSIGuPWsPn4NX5ae5R3K+Q0O5aIiIjIf/LJJ58QHn73LrshQ4ZQu3ZtypUrR/r06Zk5c6bJ6UQSJyI6goYzG3LtzjVKZC3BhDcmmB1JREREBHjGkehXr1596Nzn+fLl4+rVq4nah6OjI0WLFmXFihW2bXFxcaxYsYLSpUs/9Dlly5bl8OHD8aaMOXjwID4+Pg8toIs8jG86VwbWKQjA6KUH2X9e8+SLiIhIyla9enUaNmwIQK5cudi/fz+XL1/m4sWLvP766yanE3kywzB45/d32HFhB5ncMjE3eC5O9hoMJSIiIsnDMxXRg4KCmDAh4aiACRMmUKhQoUTvp0ePHvz444/88ssv7Nu3j/fff5/w8HDatGkDQMuWLenbt6+t/fvvv8/Vq1fp2rUrBw8e5M8//+Szzz6jY8eOz3Iakoo1KZaNyvkyERUbR/eZO4iKSdxc/iIiIiLJTXR0NPb29uzevTve9nTp0mGxWExKJfJ0vtz4JdN3TcfOYsesxrPI5pnN7EgiIiIiNs80ncuIESOoVasWy5cvt40aDw0N5dSpUyxevDjR+2natCmXLl1iwIABnD9/nsKFC7NkyRLbYqMnT57Eav1fnd/X15eQkBC6d+9umz6ma9eu9OnT51lOQ1Ixi8XC8EaBVB+7hn3nwhi/4hC9/n/RUREREZGUxMHBgezZsxMbG2t2FJFnsvr4anot7QXA6GqjqeBfweREIiIiIvFZDMN4ppUVz549y9dff83+/fuBu3OTd+jQgU8//ZQffvghSUMmpbCwMLy8vLhx4waenp5mxxGT/bXrHO9P24bVAnPeL8Or2dOaHUlERERSkaTqm/7888/MmzePX3/9lXTp0iVhwudDfXK559SNUxT9oSiXIi7RIrAFvzb4VXdQiIiIyAuT2H7pMxfRH2bHjh28+uqryXoUjDrs8qDuM7cz/98zBGRw488ur+Hq+Ew3aIiIiIg8taTqmxYpUoTDhw8THR2Nn58fbm5u8R7ftm3bf42apNQnF4A7MXcoP6k8m89upnDmwqxruw5XB1ezY4mIiEgqkth+qaqFkuoNqluQ0CNXOHY5nC/+2s/geq+YHUlERETkqdSvX9/sCCJPxTAMOi3uxOazm0nnko55wfNUQBcREZFkS0V0SfW8XBwY2aQQb/+8iV9CT1ClgDflcmc0O5aIiIhIog0cONDsCCJP5YetP/Dzvz9jtViZ0WgGAWkDzI4kIiIi8kjWJzcRefmVy52RlqX9AOg9eyc3IqJNTiQiIiIi8nIKPRVK5786AzDs9WFUy1nN5EQiIiIij/dUI9EbNmz42MevX7/+X7KImOqjmvlYe+gyxy6HM+j3PYxtWtjsSCIiIiKJYrVaH7sYY3Jes0hSl/O3ztN4dmOi46JplL8Rfcr2MTuSiIiIyBM9VRHdy8vriY+3bNnyPwUSMYuroz2jg4No/O165v97hmoFvKkZ6GN2LBEREZEnmj9/fryvo6Oj+ffff/nll18YPHiwSalE4ouKjaLJ7CacvXmWAhkLMKnepMf+8UdEREQkubAYhmGYHeJFSuyKq5J6jQzZz9erjpDW1YGQ7uXJ5OFsdiQRERF5ST3vvun06dOZOXMmCxcuTPJ9/xfqk6dOnRd3ZsLmCXg6ebL5nc3kSZ/H7EgiIiKSyiW2X6o50UUe0LVyHvL7eHItIpqP5+0ilf2dSURERF4ipUqVYsWKFWbHEGHKjilM2DwBgF8b/KoCuoiIiKQoKqKLPMDR3srYpkE42llZvu8is7ecNjuSiIiIyFO7ffs248ePJ2vWrGZHkVRu27ltvPvHuwAMKD+AunnrmpxIRERE5Ok81ZzoIqlFvsye9KiWh8//2s+QP/ZSOmd6fNO5mh1LRERE5KHSpk0bb25pwzC4efMmrq6uTJ061cRkktpdjrhMg5kNuBNzh1q5azGw4kCzI4mIiIg8NRXRRR7hnXI5WL73AltOXKPX7B3MeKcUVqsWPhIREZHkZ+zYsfGK6FarlYwZM1KyZEnSpk1rYjJJzWLiYmg2pxknb5wkV7pcTG04FatFN0OLiIhIyqMiusgj2FktjA4OouaXa9l47CoT1x2jfbkcZscSERERSaB169ZmRxBJ4OMVH7Pi2ArcHNyY33Q+aZzTmB1JRERE5JloGIDIY/ild6NfrfwAjAg5wKELN01OJCIiIpLQpEmTmD17doLts2fP5pdffjEhkaR2s/bMYuT6kQBMrDeRVzK9YnIiERERkWenIrrIE7xZIjsV8mQkKiaOHrN2EB0bZ3YkERERkXiGDx9OhgwZEmzPlCkTn332mQmJJDXbfXE3bRe2BaB3md4EFww2OZGIiIjIf6MiusgTWCwWRjQuhJeLA7vO3GDCysNmRxIRERGJ5+TJkwQEBCTY7ufnx8mTJxO9n9jYWPr3709AQAAuLi7kzJmToUOHYhiGrc2tW7fo1KkT2bJlw8XFhQIFCvDdd98lyXlIynf9znUazGxAeHQ4lQMq81ll/RFHREREUj4V0UUSwdvTmU/r370FdcKqw+w4dd3cQCIiIiL3yZQpEzt37kywfceOHaRPnz7R+/niiy/49ttvmTBhAvv27eOLL75gxIgRfPXVV7Y2PXr0YMmSJUydOpV9+/bRrVs3OnXqxKJFi5LkXCTlijPiaDGvBYevHsbPy4/fGv+GvVXLcImIiEjKpyK6SCLVCcpC7UI+xMYZ9Ji1nTvRsWZHEhEREQGgefPmdOnShVWrVhEbG0tsbCwrV66ka9euNGvWLNH7Wb9+PfXq1aNWrVr4+/vTuHFjqlWrxqZNm+K1adWqFRUrVsTf358OHToQFBQUr42kToNWD2LxocU42zszv+l8MrgmnGJIREREJCVSEV3kKQyt9wqZPJw4cimcEUsOmB1HREREBIChQ4dSsmRJKleujIuLCy4uLlSrVo3XX3/9qeZEL1OmDCtWrODgwYPA3ZHs//zzDzVr1ozXZtGiRZw5cwbDMFi1ahUHDx6kWrVqj9xvZGQkYWFh8T7k5bJw/0KGrhkKwA+1f6CITxGTE4mIiIgkHd1bJ/IU0ro58kXjQrSZtJmJ645RpUAmyuTUCBsRERExl6OjIzNnzuTTTz9l+/btuLi4EBgYiJ+f31Pt56OPPiIsLIx8+fJhZ2dHbGwsw4YNo0WLFrY2X331FR06dCBbtmzY29tjtVr58ccfKV++/CP3O3z4cAYPHvzM5yfJ24HLB3h7/tsAdC7RmbeD3jY5kYiIiEjSUhFd5ClVypuJN0tmZ/rGk/SevZO/upXD09nB7FgiIiIi5M6dm9y5cz/z82fNmsW0adOYPn06BQsWZPv27XTr1o0sWbLQqlUr4G4RfcOGDSxatAg/Pz/WrFlDx44dyZIlC1WqVHnofvv27UuPHj1sX4eFheHr6/vMOSX5uBl5kwYzG3Az6iblspdjdLXRZkcSERERSXIWwzAMs0O8SGFhYXh5eXHjxg08PT3NjiMpVHhkDDW/XMvJqxE0LpqNUU2CzI4kIiIiKVBS9U0bNWpEiRIl6NOnT7ztI0aMYPPmzcyePTtR+/H19eWjjz6iY8eOtm2ffvopU6dOZf/+/dy+fRsvLy/mz59PrVq1bG3at2/P6dOnWbJkSaKOoz75y8EwDBrPbsy8ffPI4pGFrR22ktk9s9mxRERERBItsf1SzYku8gzcnOwZHRyExQJztp5m6Z7zZkcSERGRVGzNmjW88cYbCbbXrFmTNWvWJHo/ERERWK3xLxHs7OyIi4sDIDo6mujo6Me2kdTj838+Z96+eThYHZgbPFcFdBEREXlpaToXkWdU3D8dHcrn4Pu/j9J33i5e9UtLBncns2OJiIhIKnTr1i0cHR0TbHdwcHiqRTzr1KnDsGHDyJ49OwULFuTff/9lzJgxtG3bFgBPT08qVKhA7969cXFxwc/Pj7///pspU6YwZsyYJDsfSf5CDofQb2U/ACa8MYFS2UqZnEhERETk+dFIdJH/oEfVPOT19uBKeBT95u8ilc2OJCIiIslEYGAgM2fOTLD9t99+o0CBAonez1dffUXjxo354IMPyJ8/P7169eLdd99l6NCh8fZZvHhxWrRoQYECBfj8888ZNmwY7733XpKciyR/R68dpfnc5hgYtC/Sng5FO5gdSUREROS50pzoIv/RnrM3qP/1OqJjDUY3CaJR0WxmRxIREZEUIqn6pr///jsNGzbkzTff5PXXXwdgxYoVzJgxg9mzZ1O/fv0kSpw01CdPuSKiIyjzcxl2XNhBiawlWNN6DU72uhtTREREUibNiS7yghTM4kW3KnkAGLRoD2ev3zY5kYiIiKQ2derUYcGCBRw+fJgPPviAnj17cvr0aZYvX57sCuiSchmGwTu/v8OOCzvI5JaJucFzVUAXERGRVEFFdJEk8G75HBTJnoabkTH0nrODuLhUdYOHiIiIJAO1atVi3bp1hIeHc/nyZVauXEmFChXYvXu32dHkJfHlxi+Zvms6dhY7ZjWeRTZP3YEpIiIiqYOK6CJJwN7Oypjgwrg42LHu8BWmhB43O5KIiIikYjdv3uSHH36gRIkSBAUFmR1HXgKrj6+m19JeAIyuNpoK/hVMTiQiIiLy4qiILpJEAjK40feNfAAM/2s/Ry7dMjmRiIiIpDZr1qyhZcuW+Pj4MGrUKF5//XU2bNhgdixJ4U7dOEXw7GBijVhaBLagS8kuZkcSEREReaFURBdJQm+V9KNc7gxExsTRY9YOYmLjzI4kIiLyf+3deXhU5fn/8c/s2QNJCCEQAVkCBAVFQNC6UlEpiKKgX0Tc9VtFKUqltoJ81YJVUX9iUaw7CoKKWqtSRdGiWBEIsqOIgiYBwpKVbDPn98fJNpCBDEtOZub9uq5zJXPmOTP3eTgMN3ee3AdhLi8vT9OnT1eXLl10xRVXKDExUeXl5XrnnXc0ffp09e3b1+oQEcLKqso0Yv4I7Srdpd5pvTV76GzZbDarwwIAAGhSFNGBY8hut+lvl5+s+CinVm/fp1lLtlgdEgAACGNDhw5VZmamvvvuOz3xxBPKycnRU089ZXVYCBOGYej2D27X8pzlSopO0tsj31aMK8bqsAAAAJocRXTgGGuTGK0HLukpSXpy8fda+2uBxREBAIBw9eGHH+qGG27Q1KlTNWTIEDkcDqtDQhiZvWK2nl/1vOw2u+aOmKuOLTtaHRIAAIAlKKIDx8ElvdN1Uc80VfkM/eGNbJVVeq0OCQAAhKGlS5eqqKhIffr0Uf/+/TVz5kzl5+dbHRbCwLLtyzTuw3GSpIfOe0gXdLrA4ogAAACsQxEdOA5sNpseHN5TKXEefb+zWDM+3mx1SAAAIAydfvrpeu6555Sbm6tbbrlF8+bNU3p6unw+nz7++GMVFRVZHSJCUF5xni5fcLkqfZUa0X2E7jnjHqtDAgAAsBRFdOA4SY7zaPplJ0mSnvvPj/rvj7stjggAAISr2NhYXX/99Vq6dKnWrFmju+66S9OnT1dqaqqGDRtmdXgIIRXeCl2x4ArlFOWoR6seevGSF7mRKAAAiHgU0ZvS5kVS7ndWR4EmNKhHa408rZ0MQ7prwWoVl1dZHRIAAAhzmZmZ+tvf/qZffvlFc+fOtTochJi7Ft2lpduWKsGToIWjFireE291SAAAAJajiN5UfF7pn+OlZ38jPfMb6b/PSqV7rI4KTeC+3/VQ2xbR+mXvfj34/nqrwwEAABHC4XBo+PDheu+996wOBSHildWvaObymZKkVy99VV2Tu1ocEQAAQPNAEb2plBVIGf0kh1vK+0768I/SY5nS/LHS9x+bRXaEpfgolx4b2Us2mzRv+XZ9unGH1SEBAAAAflbmrtQt798iSZp81mQNy6QNEAAAQA2K6E0lJkka+bJ01ybpor9JaSdL3gpp/TvSa5dLj/eUPpkq7d5idaQ4Dk4/MVk3nNFRkvTHN9doT0mFxREBAAAApvzSfF36xqUqqyrTkC5DNOWcKVaHBAAA0KxQRG9qMUlS/1ukW/8j3fIfqf+tUnRLqShHWjpDeupU6YULpVVzpPJiq6PFMXT34Ex1To1TfnG57ntnrQzDsDokAAAARLgqX5WufPNKbSvYps5JnTXnsjmy2/hvIgAAQH1kR1Zqc7J00cPm6vQrXpY6/1ay2aVty6R3b5Me7Sq983vp568kCq4hL8rl0OMje8tpt+lfa3L13uocq0MCAABAhLt38b1avHWxYl2xWjhqoVpEtbA6JAAAgGaHInpz4PRIWcOlq9+U/rBOOn+ylNRJqiyRsl+TXrzIXKH+xSNSwa9WR4ujcFK7RI07r4sk6b531iqvoMziiAAAABCp5q+br0e+ekSS9MIlL6hnak+LIwIAAGieKKI3Nwnp0m/uksatkK77SDrlaskdJ+35Ufr0QemJntKrl0lr35aqyq2OFkfg9+d2Uq92iSosq9LEN1fT1gUAAABNbu3Otbr+3eslSRMHTtTIrJEWRwQAANB8UURvrmw2qf0A6ZKnzXYvl/xdan+GZPikLYulN68z2718MFHKyabdSwhxOex6bGRveZx2/ef7fM357zarQwIAAEAE2Ve2T5e+calKKkt0fsfz9dfz/2p1SAAAAM0aRfRQ4ImTThktXfeBNG6l9Ju7pYS2Utk+6ZvZ0uyzpWd+I309SyrZbXW0aITOqXG658JukqS//muDfsovsTgiAAAARAKf4dPot0frhz0/qH1ie827fJ6cdqfVYQEAADRrFNFDTXIn6fz7pPFrpKvfkrIukxxuacca6aNJ0mOZ0htjpM2LJG+V1dHiEK4d2EEDTkzW/kqvJszPltfHbxMAAADg+Lp/yf364PsPFOWM0tuj3lZKTIrVIQEAADR7FNFDld0hdR4kXfGi2e7l4kelNr0lX6W04T3p9ZHS41nSx1Ok/O+tjhYNsNttenRkL8V7nFq5bZ+e/WKL1SEBAAAgjL278V098MUDkqTZv5utU9ucanFEAAAAoYEiejiISZL63STd8rl065fS6b+XopOk4jzpyyekmadJz18grXxFKi+yOlrU07ZFtCYP7SFJevzjzVqfU2hxRAAAAAhHm/I3aczCMZKkcf3GaUyvMRZHBAAAEDooooebtJ7ShdPM1ekjX5W6DJZsdmn7f6X3xpk3I114q/TTUm5G2kxc3qedftujtSq9hibMz1Z5ldfqkAAAABBGisqLdOkbl6qooki/OeE3euyCx6wOCQAAIKRQRA9XTrfUY5g0er70h/XSoPul5C5SZam0eq700hDp//WWPn9EKvjF6mgjms1m07TLTlJyrFsb84r0xCe03wEAAMCxYRiGrn33Wm3I36D0+HTNv2K+XA6X1WEBAACEFIrokSChjXTmH6Tbl0vX/1s69RrJHS/t/Un67EHp8Z7Sq5dKa96UKsusjjYipcR59NClJ0mSnv18i779aY/FEQEAACAcTF86XW9veFsuu0tvjXxLaXFpVocEAAAQciiiRxKbTTqhvzTsKenuTdLwZ6QOv5FkSFs+ld66QXqsq/Svu6RfV9LupYld2DNNl53aVj5DumvBapWUV1kdEgAAAELYoh8W6c+f/lmSNPPimTq93ekWRwQAABCamkUR/emnn1aHDh0UFRWl/v3765tvvmnUcfPmzZPNZtPw4cOPb4DhyB0r9b5KuvZ96Y5s6aw/SgntpLICafk/pOfOlWadIS17WirJtzraiDFlaJbSE6P08+5STftwg9XhAAAAIET9uPdHXfXWVTJk6MZTbtTNfW62OiQAAICQZXkR/Y033tCECRM0ZcoUrVy5Ur169dLgwYO1c+fOQx73008/6e6779ZvfvObJoo0jCV1lM77szT+O2nMQqnn5ZLDI+1cJy26V3osU5o3Wtr0oeRldfTxlBjt0iNX9JIkzfl6mz7fvMviiAAAABBqSitLddkbl2lv2V71a9tPMy+eaXVIAAAAIc3yIvqMGTN000036brrrlOPHj30zDPPKCYmRi+88ELAY7xer0aPHq2pU6fqxBNPbMJow5zdIXU6T7r8ebPdy5DHpPRTJF+VtPF9ae6V0uM9pI8nS7s2Wx1t2Dqjc4quHdhBkvTHN1drX2mFtQEBAAAgZBiGoZv+eZNW71it1NhUvTXyLXmcHqvDAgAACGmWFtErKiq0YsUKDRo0qHaf3W7XoEGDtGzZsoDH/d///Z9SU1N1ww03HPY9ysvLVVhY6LehEaJbSn1vlG5eIv3vMmnA7VJMilS8Q/rySenpvtI/BkkrXpLKmNNj7Z4Lu+nElFjtKCzX5HfXWR0OAAAAQsST/31Sr695XQ6bQ/Mvn692Ce2sDgkAACDkWVpEz8/Pl9frVevWrf32t27dWnl5eQ0es3TpUj3//PN67rnnGvUe06ZNU2JiYu2WkZFx1HFHnNY9pMEPSRM2SKNek7peJNkc0i/LpX/eKT3aVXr7FmnrF5LPZ3W0YSHa7dCMUb3lsNv03uocvf9djtUhAQAAoJlb8tMS3f3vuyVJj13wmM7ucLbFEQEAAIQHy9u5BKOoqEhjxozRc889p5SUlEYd86c//UkFBQW12/bt249zlGHM6Za6/076n3lmQf23/yelZEpV+6Xv5kkvD5X+X29pycPSvm1WRxvyeme00G3ndJIk/eWdtdpZWGZxRAAAAGiuthds18gFI+U1vBp90mjd0f8Oq0MCAAAIG04r3zwlJUUOh0M7duzw279jxw6lpaUdNH7Lli366aefNHTo0Np9vuqVz06nU5s2bVKnTp38jvF4PPJ46AF4zMW3ls64Uxp4h/TLt1L2HGnt29K+n6Ulf5WWTJNOPFvqfbVZeHdFWx1xSLr9vC76dNNOrf21UPe89Z1euLavbDab1WEBAACgGSmrKtOI+SO0q3SXeqf11uyhs8kZAQAAjiFLV6K73W716dNHixcvrt3n8/m0ePFiDRgw4KDx3bp105o1a5SdnV27DRs2TOeee66ys7Np1WIFm03K6CsNfVK6a5N06Wyp41mSDOnHJdLbN0qPZkrv/0H6ZYVkGFZHHFLcTrtmjOwtt9Ouzzbt0rzl/CYFAAAA6hiGods/uF3Lc5YrKTpJb498WzGuGKvDAgAACCuWrkSXpAkTJmjs2LE67bTT1K9fPz3xxBMqKSnRddddJ0m65ppr1LZtW02bNk1RUVHq2bOn3/EtWrSQpIP2wwLuGKnXKHPb+5OUPVfKfk0q2C59+4K5teounTJaOnmUFJdqdcQhoWvreE28IFMPfbBBD76/Xmd0StEJyfzHCAAAANLsFbP1/KrnZbfZNXfEXHVs2dHqkAAAAMKO5T3RR40apUcffVSTJ09W7969lZ2drY8++qj2ZqPbtm1Tbm6uxVEiaC07SOf+SbrzO+mad6WTrpCcUdKuDdK//yLN6C7N/R9p4weSt9LqaJu968/sqH4dk1RS4dXdC1bL62NFPwAAQKRbtn2Zxn04TpL00HkP6YJOF1gcEQAAQHiyGUZk9dcoLCxUYmKiCgoKlJCQYHU4kWX/Pmnd29KqOdKvK+r2x7aSel1p9k9P7WZZeM3d9j2luvCJL1RS4dW9F3fTzWd1OvxBAACgWYvU3DRSz/tYyivOU5/ZfZRTlKMR3UdowRUL6IMOAAAQpMbmpZavREcEiW4hnXa9dNOn0u+/lgbcbhbQS3ZJXz0l/b2/9Nx5ZtuXsgKro212MpJidN/vekiSHl20WZvyiiyOCAAAAFao8FboigVXKKcoRz1a9dCLl7xIAR0AAOA4oogOa6R2lwY/JE3YIF35upQ5RLI7zRXq7/9BerSr9NZN5s1JfT6ro202RvXN0HndUlXh9WnC/GxVVDE3AAAAkeauRXdp6balSvAkaOGohYr3xFsdEgAAQFijiA5rOVxStyHSVa+bBfULHpRadZOqyqQ186VXLpGe7CV9Nk3a+7PV0VrOZrNp+oiT1DLGpXU5hXrq0++tDgkAAABN6JXVr2jm8pmSpFcvfVVdk7taHBEAAED4o4iO5iMuVRo4zmz1cuOnZusXT6JUsE36fLr05MnSy0Ol1W9IFaVWR2uZ1PgoPTj8JEnS05/9oJXb9locEQAAAJrCytyVuuX9WyRJk8+arGGZwyyOCAAAIDJQREfzY7NJ7fpIv3tcunuTdNk/pBPPkWSTtn4hLbxZeixT+ued0i/fSpF1b1xJ0pCT2+iS3unyGdLd81drf4XX6pAAAEAY8Hq9uu+++9SxY0dFR0erU6dOeuCBB2QckG9t2LBBw4YNU2JiomJjY9W3b19t27bNoqgjQ35pvi5941KVVZVpSJchmnLOFKtDAgAAiBhOqwMADskVLZ18hbnt2yZlz5Wy55jfr3jJ3FIypVOulk4eJcW3tjriJvN/w3rq6x9368f8Ej380UbdPyzL6pAAAECIe/jhhzVr1iy9/PLLysrK0rfffqvrrrtOiYmJuuOOOyRJW7Zs0ZlnnqkbbrhBU6dOVUJCgtatW6eoqCiLow9fVb4qXfnmldpWsE2dkzprzmVzZLexHgoAAKCp2IwDl5WEucLCQiUmJqqgoEAJCQlWh4Mj4fNJPy+VVs2R1r8nVe0399scUpcLzIJ618Fmv/Uw98XmXbrmhW8kSXNu6K8zu6RYHBEAAAhGc8tNf/e736l169Z6/vnna/eNGDFC0dHRmjNnjiTpyiuvlMvl0quvvnrE79Pczru5++PHf9QjXz2iWFesvr7xa/VM7Wl1SAAAAGGhsXkpyxcQeux2qeNZ0mWzzXYvQ5+U2vWVDK+0+UPpjdHSY92kRX+Wdqy3Otrj6qyurXT16SdIkia+uVoF+ystjggAAISygQMHavHixdq8ebMkafXq1Vq6dKkuuugiSZLP59O//vUvde3aVYMHD1Zqaqr69++vd95555CvW15ersLCQr8NjTN/3Xw98tUjkqQXLnmBAjoAAIAFKKIjtEUlSn2ulW78RLrtG2ngHVJsqlSaLy2bKc0aIM0+V1r+D2n/PqujPS7uvbi72ifHKLegTFPfW2d1OAAAIIRNmjRJV155pbp16yaXy6VTTjlF48eP1+jRoyVJO3fuVHFxsaZPn64LL7xQ//73v3XppZfqsssu0+effx7wdadNm6bExMTaLSMjo6lOKaSt3blW1797vSRp4sCJGpk10uKIAAAAIhPtXBB+vJXSD5+Y7V42fyT5qsz9Do/Ufah0ymip4znmivYwseLnPbrimWXyGdIzV5+qC3u2sTokAADQCM0tN503b54mTpyoRx55RFlZWcrOztb48eM1Y8YMjR07Vjk5OWrbtq2uuuoqvf7667XHDRs2TLGxsZo7d26Dr1teXq7y8vLax4WFhcrIyGg2590c7Svbp77P9dUPe37Q+R3P10dXfySnnVtaAQAAHEuNzcfJwhB+HC4p8yJzK94lrZlvFtR3rpfWvmluiRlSr6uk3v8jJXW0OuKj1qd9km49u5P+vmSL7l24Vn3aJ6lVvMfqsAAAQIiZOHFi7Wp0STrppJP0888/a9q0aRo7dqxSUlLkdDrVo0cPv+O6d++upUuXBnxdj8cjj4fcpLF8hk+j3x6tH/b8oPaJ7TXv8nkU0AEAACwUPktxgYbEtZIG3Cb971fSTZ9JfW80W8AUbJe++Jv0/3pLL/1Oyp4rVZRYHe1RuXNQF3VLi9eekgpNeus77SoqP/xBAAAA9ZSWlsp+wG/rORwO+Xw+SZLb7Vbfvn21adMmvzGbN29W+/btmyzOcHf/kvv1wfcfKMoZpbdHva2UGG4eDwAAYCWWMyAy2GxS21PN7YKHpI3vm6vTf1wi/fQfc/tgotTzUumUMeaNSm02q6MOisfp0OOjemvYzKVavHGn+j70iVLjPeqRnqCs9AT1aJOorPQEnZAUI7s9tM4NAAA0jaFDh+qhhx7SCSecoKysLK1atUozZszQ9ddfXztm4sSJGjVqlM466yyde+65+uijj/TPf/5TS5YssS7wMPLuxnf1wBcPSJKe/d2zOrXNqRZHBAAAAHqiI7Lt2y6tnitlvybt/aluf0pXqfdoqdeVUnyaZeEdiX+uztHjn2zW1vwSNfS3O87jVPc28cpKT1SPNgnqkZ6gLq3j5HE6mj5YAAAiXHPLTYuKinTfffdp4cKF2rlzp9LT03XVVVdp8uTJcrvdteNeeOEFTZs2Tb/88osyMzM1depUXXLJJY1+n+Z23s3FpvxN6vtcXxVVFOn2vrfrqYufsjokAACAsNbYvJQiOiBJPp+07Stzdfr6d6XKUnO/zSF1HiSdcrXU9ULJ6T706zQjpRVV2pBbpPW5hVqfU6B1OYXamFekiirfQWOddpu6tI6vLapnpSeoe5sEJUa7LIgcAIDIEam5aaSe96EUlRep/z/6a0P+Bp15wpn69JpP5XKQiwEAABxPFNEDIGHHYZUVSusWmqvTt/+3bn9MsnTyKHOFelpP6+I7ClVen7bsKtH63AKt+7VQ63MLtS6nUAX7Kxscn5EUrR5tEmpXrWe1TVBaQpRsIdbqBgCA5ipSc9NIPe9ADMPQ5Qsu19sb3lZ6fLpW3LxCaXGh9duQAAAAoYgiegAk7AjKrs1mMX31PKk4r25/m97m6vSeI6SYJMvCOxYMw1BOQZnW/VpQvWrdLKz/um9/g+OTYt1+K9az0hPUMSVODvqsAwAQtEjNTSP1vAOZ9p9puvfTe+Wyu/TFdV/o9HanWx0SAABARKCIHgAJO46It0rasths97LpQ8lXvXLb4ZG6DTEL6ieeI9nDp694QWml1uUWaH2OWVhfn1uo73cWy+s7+CMjymVXt7SEejcxTVC3tARFu8NnPgAAOB4iNTeN1PNuyKIfFumi1y6SIUPP/u5Z3dznZqtDAgAAiBgU0QMgYcdRK9ktrZlvFtR3rK3bn9BW6nWV1Pt/pORO1sV3HJVVevX9jmKtq+6xvj63UBtyC1Va4T1orN0mndgqrraobhbYE5UUGzp95QEAON4iNTeN1PM+0I97f9Rps0/T3rK9uvGUG/XcsOesDgkAACCiUEQPgIQdx4xhSLmrzXYv382XyvbVPdf+DLN3eo9LJE+cZSE2Ba/P0M+7S2qL6utyzBuZ5hdXNDg+LSHKLKzXrlpPVEZSNH3WAQARKVJz00g97/pKK0s18PmBWr1jtfq17acvrv1CHqfH6rAAAAAiCkX0AEjYcVxUlkmbPjBXp2/5VFL1Xyt3nJQ1XDpljJTRX4qgQvHOwjKtq+6xbvZZL9BPu0sbHBsf5VT3NjU91s2bmHZpHSeXw97EUQMA0LQiNTeN1POuYRiGrl54tV5f87pSY1O14uYVapfQzuqwAAAAIg5F9AAiPWFHEyj4RVo9V1r1mrR3a93+5M7m6vReV0kJbayLz0LF5VXakFtXVF+fW6jNecWq8PoOGut22NWldZx6VBfXe6QnqnubeMVHuSyIHACA4yNSc9NIPe8aT3z9hP6w6A9y2BxafM1ind3hbKtDAgAAiEgU0QOI9IQdTcgwpG3LzNXp696RKkvM/Ta71HmQWVDPvEiK8F/brajyacuu4uo2MHXF9aKyqgbHt0+Oqe2znpWeqB7pCUqN99AOBgAQkiI1N43U85akJT8t0aBXBslrePXE4Cd05+l3Wh0SAABAxKKIHkAkJ+ywUHmRWUjPfs0srNeITpJOHmkW1NucbFl4zY1hGPpl7/7a/uo1vdZzC8oaHJ8S565uB5NY22u9Q3KsHHYK6wCA5i1Sc9NIPe/tBdvVZ3Yf7SrdpdEnjdarl77KQgAAAAALUUQPIFITdjQj+T+YxfTVc6Wi3Lr9aSdLp1wtnXSFFJNkXXzN2J6SCrPHem5B7cr1LbuK5WvgUyzG7VC3tPjqorrZZz0zLV5RLkfTBw4AQACRmptG4nmXVZXprBfP0vKc5eqd1ltfXv+lYlwxVocFAAAQ0SiiBxCJCTuaKZ/XvAnpqjnmTUm9FeZ+h1vKvNi8GWmncyU7Rd9D2V/h1aYdRWYbmBxzxfrGvEKVVR7cZ91ht6lTq9jaorrZaz1BLWLcFkQOAEDk5qaRdt6GYeimf96k51c9r6ToJH1707fq2LKj1WEBAABEPIroAURawo4QUbpHWrNAWvWqlLembn98utTrSnOFenIn6+ILMV6foa35dX3Wa9rB7CmpaHB82xbR1e1gEmrbwbRtEc2vVwMAjrtIzU0j7byf/fZZ3fqvW2W32fXh6A91QacLrA4JAAAAoogeUKQl7AhBud+Z7V6+e0Pav7du/wkDzGJ6j+GSJ86y8EKVYRjaUVjut2J9fW6htu0pbXB8YrRLPdrUFdV7pCeoU6s4uRz2Jo4cABDOIjU3jaTzXrZ9mc5+6WxV+io17fxpmnTmJKtDAgAAQDWK6AFEUsKOEFdVLm360Gz3smWxZFS3J3HFSlmXSqeMNgvrrJY+KoVlldpQr6i+LqdQ3+8oUlUDjdbdTrsyW8f7rVjvlpagWI/TgsgBAOEgUnPTSDnvvOI89ZndRzlFORrRfYQWXLGA33QDAABoRiiiBxApCTvCTGGOeSPSVa9Je7bU7U86Ueo9Wup1lZTY1rr4wkx5lVff7yjW+tzqdjDVBfbi8qqDxtpsUsfkWHWvWbHexryRaat4jwWRAwBCTaTmppFw3hXeCp3/yvlaum2perTqoa9v+FrxnnirwwIAAEA9FNEDiISEHWHMMKRtX0vZc6R170gVxeZ+m13qdJ5ZUO82RHJSwD3WfD5D2/eW1vZZX5dToPW5hdpRWN7g+FbxHr+ieo/0BLVPipHdzuozAECdSM1NI+G8x30wTjOXz1SCJ0HLb1qursldrQ4JAAAAB6CIHkAkJOyIEOXF0vp3zf7pP39Ztz+6pdk3vU0vKbW71CrT3IfjIr+43K/H+rqcAm3NL1FDn6yxbscBNzBNVJfWcfI4HU0fOACgWYjU3DTcz/uV1a9o7DtjJUnvXvmuhmUOszgiAAAANIQiegDhnrAjQu3eImW/bm5FOQc/H9faLKa36ua/xSY3fawRoLSiShtyi6rbwZg3Mt2YV6TyKt9BY512mzqnxtUW1WtuZpoY7bIgcgBAU4vU3DScz3tl7kqd8cIZKqsq0+SzJmvquVOtDgkAAAABUEQPIJwTdkA+r/TjZ9KWz6RdG6Vdm6SC7YHHx6RUF9Qz61att+omxbbihqXHWJXXpx/zS8w2MNUr19flFKpgf2WD49u1jK5uB5NYu3K9TWIUNyMDgDATqblpuJ53fmm++szuo20F2zSkyxC9d9V7stvsVocFAACAACiiBxCuCTsQUHmRtGtzdVG9urC+a6O07+fAx0S3PGDVenVxPT6N4voxZBiGcgrK6nqsVxfWf923v8HxLWNcfivWs9IT1DElVk4H/zkHgFAVqblpOJ53la9KF865UIu3LlbnpM5aftNytYhqYXVYAAAAOASK6AGEY8IOHJGKEil/c11RfdcmaecGae9PkgJ8LEQl+hfVa74mtKW4fgwVlFZqXa5ZVF9f3Wv9+53F8voO/nPxOO3q1iahtqjeIz1B3dMSFO2mzzoAhIJIzU3D8bz/+PEf9chXjyjWFauvb/xaPVN7Wh0SAAAADoMiegDhmLADx1Tlfin/+3rF9eptz4+ScXBPb0mSO/7gwnqrTCkxQ7KzSvpYKKv06vsdxVqXU1B7E9MNuYUqrfAeNNZukzqmxJor1tOri+ttEpQc57EgcgDAoURqbhpu5z1/3XyNenOUJOmNy9/QyKyRFkcEAACAxqCIHkC4JexAk6kql3b/4L9qfdcmac8WyVfV8DGuWKlV1wOK692kFu0prh8DXp+hn3eX1BbV1+WYNzLNL65ocHxaQpRfUT0rPVEZSdH0WQcAC0VqbhpO571251qd/o/TVVJZookDJ+pvv/2b1SEBAACgkSiiBxBOCTvQLFRVmKvU669a37XJXM3ua/immXJGSyldDripaTepZQfJThuSo7WzsEzrcgv92sFszS9pcGy8x6nu6f7tYLqkxsvt5IccANAUIjU3DZfz3le2T32f66sf9vyg8zuer4+u/khOu9PqsAAAANBIjc1LyfAAHB2nW0rtZm71eaukvVvrVqzXFtc3S1X7pbzvzK0+h6e6uJ4ptepet3o9qaPkcDXdOYW41IQopSZE6dzM1Np9xeVV2li7Wr1Q63ILtDmvWEXlVfpm6x59s3VP7ViXw6YuqfG1RfWs9ER1bxOv+Cj+DAAAqOEzfBr99mj9sOcHtU9sr3mXz6OADgAAEKbI8gAcHw6nWRBP6eK/3+c1b15af9X6ro3Sruri+o615laf3SUldzYL9fVbwyR1Mov4OKw4j1OndUjSaR2SavdVen36YWexWVTPKdS6nAKtzy1UUVmV1ueaK9i1ou412ifH+N/AtE2CWsV55HSwah0AEHnuX3K/Pvj+A0U5o/T2qLeVEpNidUgAAAA4TmjnAqB58Hmlfdv8V63XfK1suBWJbA4puVNdr/Wa4npyZ8kV1bTxhwnDMPTL3v21/dVreq3nFpQ1ON5mk1pEu5Qc51FyrFspcR4lxbqVHOdWcpxHKbHm16RYt1Li3EqMdtGDHQDqidTcNNTP+92N72r4G8MlSS8Pf1nX9LrG2oAAAABwROiJHkCoJ+xAxPH5pMJf6hXVN0o7q4vrFUUNH2OzS0knHnBD00wppavkim7a+MPEnpKK6v7qBbUtYbbsKpYvyH9BnHZbdZHdo5Q4t/l9rEfJcWaRveb7mq8xbgdFdwBhLVJz01A+7035m9T3ub4qqijS7X1v11MXP2V1SAAAADhCFNEDCOWEHUA9hiEV5hywar16KysIcJDNvHlp/eJ6ajezuO6Obcrow4LXZ2hfaYV2l1Qov7hcu4srtLu4XLtLzH27a/ZVP19UVhX0e0S57EqOrVdwj6suuNcU26tXwCdXP+9xcmNaAKElUnPTUD3vovIi9f9Hf23I36AzTzhTn17zqVzctwUAACBkcWNRAOHNZpMS25pb5/Pr9huGVLyjrrhee2PTDdL+vebNTvdulTZ/6P96LU44YOV6d6lVV8kT37TnFUIcdlt1Udujrq0PP0/lVV7tLak0C+4HFNl319uXX1yh3SXlKqv0qazSp1/37dev+/Y3Kqb4KKdSqgvr9Ve8J8fWL7ibBfiWMW457KxyBwA0jmEYuvbda7Uhf4PS49O14IoFFNABAAAiBEV0AOHFZpPi08ztxHPq9huGVJLvv2K9ZgV7yS6zH/u+bdL3//Z/vYR2/qvWW1WvXI9u0ZRnFRY8TofSEh1KS2xcv/rSiirtLq63yr3ELLDvqVd0z69e/b6npEJVPkNFZVUqKqvS1vwAffTrsdmkpJi6Vez1e7gn+7WWMfclRDlpLQMAEWz60ul6e8PbctldevOKN5UWl2Z1SAAAAGgiFNEBRAabTYprZW4df+P/XMluKb/+qvXqAntxntmPvfAXacti/2Pi21QX17v7912PSWq6cwpzMW6nYpKcykiKOexYwzBUuL9K+SV1bWXySyq0p7r4XluMry7A79tfKcNQbeuZxnA5bEqOrbtxasoBK9vrr3ZPifMo2k1rGQAIF4t+WKQ/f/pnSdLMi2dqQMYAiyMCAABAU6KIDgCxyVLsQKn9QP/9+/f6F9Vrvhb+KhXlmtuPSw54rdS6Feu1xfVuUmxKk51OJLLZbEqMcSkxxqVOrQ4/vsrr097SSr8Cu7nCvW7Fe81q9z3FFSoqr1Kl11BeYZnyCssaFVOM21G9yr1mhbt/D/e6G6p61DLGLbfTfpSzAAA4Hn7c+6OueusqGTJ04yk36uY+N1sdEgAAAJoYRXQACCS6pXTC6eZWX1mBtGvzAW1hNkkF26SSndLWndLWL/yPiUk+eNV6q25SXKq5Sh5Nyumwq1W8R63iPY0aX1bprS2y16x231NbgK9b7b6npEK7istVUeVTaYVXpXv2a/uexvVzT4x2HVRgr+npnhTrrr3BanKcRy2iXbLTzx0AjrvSylJd9sZl2lu2V/3a9tPMi2daHRIAAAAsQBEdAIIVlShl9DW3+sqLpPzN/qvWd26Q9v0sle6Wfl5qbvVFtzxg1Xp1i5j4NIrrzUiUy6H0FtFKbxF92LGGYaikwlt3k9SaVe4l/v3da26quqekQl6foYL9lSrYX6kfG9HP3W5TbWG9/gr3lOqV7+YK97rn4zz0cweAYBmGoZv+eZNW71it1NhUvTXyLXmcjfvhKwAAAMILRXQAOFY88VLbPuZWX0WJlP99veJ69bb3J7NlzLZl5ub3WonVBfUDbmqa0JbiejNns9kU53EqzuNU++TYw473VRfQ69rImKvc669wr1kBv6ekQvtKK+UzpPzqVfDacfiY3E57g21kzEJ8dX/3esX4KBf93AHgyf8+qdfXvC6HzaH5l89Xu4R2VocEAAAAi1BEB4DjzR0rpfc2t/oq90u7f6grrtfc2HTPj1J5gfTLN+bm91px/r3Wa1avJ2ZIdnpqhyK73aaWsW61jHWrc+rhx1d6fdpbUtdGZk/N9/VWuedXt5bZXVyukgqvKqp8yi0oU25B4/q5x7od9W6YWtNGprq/u1+7GbeSYtxyOrj2AISXJT8t0d3/vluS9NgFj+nsDmdbHBEAAACs1CyK6E8//bQeeeQR5eXlqVevXnrqqafUr1+/Bsc+99xzeuWVV7R27VpJUp8+ffTXv/414HgAaLZc0VLaSeZWX1W5tHuL/6r1XZvMgntFsfTrCnPze60YKaWrlHpA3/UW7SU7q4rDicthV2pClFIToho1fn+Ft177mLo2MjVF9/ySuv7uu4srVOH1qaTCq5I9pdq2p7RR79Eipqafe12RPam6vUzdzVTN5xKi6OcOoHnbXrBdIxeMlNfwavRJo3VH/zusDgkAAAAWs7yI/sYbb2jChAl65pln1L9/fz3xxBMaPHiwNm3apNTUg5fkLVmyRFdddZUGDhyoqKgoPfzww7rgggu0bt06tW3b1oIzAIBjzOmRWvcwt/q8leYq9ZoV67XF9e+lylIpN9vc/F4rSkrpcsBNTbtJLTtIDsv/CUATiHY71M4do3YtYw471jAMFZVXVRfUy6uL7XXf1/R0N3u8m6vgfYa0r7RS+0ortWXX4fu5O+y2g9rIJNV8X11sT45zKyXWo6Q4t2LdDvq5A2gyZVVlGjF/hHaV7lLvtN6aPXQ2n0EAAACQzTAMw8oA+vfvr759+2rmTPNO9z6fTxkZGRo3bpwmTZp02OO9Xq9atmypmTNn6pprrjns+MLCQiUmJqqgoEAJCQlHHT8AWM5bZfZX37WhrrC+a6PZh70qQPsOh6e6uJ7pf2PTpBMlh6tJw0fo8voM7SutqCu2165oL1d+Sb2bqhabBfjCsqqg38PjtCsh2qV4j1NxUc7afvNxUc56+1x1j+uNi4+qe+xx8hsZaJ4iNTdtjuddcyPR51c9r6ToJH1707fq2LKj1WEBAADgOGpsXmrpMsSKigqtWLFCf/rTn2r32e12DRo0SMuWLTvEkXVKS0tVWVmppKSkBp8vLy9XeXl57ePCwsKjCxoAmhuHU0rpbG7dh9bt93mri+ubDiiubzZXru9Ya2712V1Scmf/4npqdympk+R0N+lpoflz2G3VK8c9UuvDj6+o8lX3cC+vXc2+u7iup/uekora4nt+cbnKKn0qr/JpV1G5dhWVH/4NDsHtsJtF9XqF+PpF9jiPq+7xQUX6mscuRbnsrEoFwtTsFbP1/KrnZbfZNXfEXAroAAAAqGVpET0/P19er1etW/v/z7t169bauHFjo17jnnvuUXp6ugYNGtTg89OmTdPUqVOPOlYACDl2h5Tcydy6XVy33+eTCrb5F9drWsRUllSvaN/g/1q26teq3xImuZPkjJbsTvOmpjZH9feO6u9rNmfdY5uDG6BGMLfTrrTEKKUlNq6fe2mF2VqmqKxKxeVVKi6vrPu++utBj8urVFxWWbuvpMIrSarw+swV8yUVR3UODrstQBHeqfioQxfi4+utmo9xOegNj2bJ6/Xq/vvv15w5c5SXl6f09HRde+21+stf/tLgD5BuvfVWPfvss3r88cc1fvz4pg/4GFm2fZnGfThOkvTQeQ/pgk4XWBwRAAAAmpOQbog7ffp0zZs3T0uWLFFUVMP/If/Tn/6kCRMm1D4uLCxURkZGU4UIAM2P3W72RG/ZQeo6uG6/YUgFv9Qrrte7qWl5obmCPX+ztOGfRxmA7eDiul/h3VlXbD/smPr7awr49gOK+Ycp8tfff9j3OFR8zur3Plx8we63SxG68jnG7VRM0tGlKl6fUV2Arym0B1+IL6o+3jDM1yvYX6mC/ZVHFZfNJsW5/Ve6+xXm67eoqTcmoV4hvqZY76AYj2Po4Ycf1qxZs/Tyyy8rKytL3377ra677jolJibqjjv8b7C5cOFCff3110pPT7co2mMjrzhPly+4XJW+So3oPkL3nHGP1SEBAACgmbG0iJ6SkiKHw6EdO3b47d+xY4fS0tIOeeyjjz6q6dOn65NPPtHJJ58ccJzH45HH4zkm8QJAWLPZpBYZ5tal3m/3GIZUlOvfEmbnRmnvVvNmpz6vZHjNr74q83vDd4g3MsxxvuD7Y0cs24HF9QN+KHDYAv7xLP4H+UOLoH4wUr3f4ZZc0eZNd51R5tbIHyw47DYlRruUGH10vf59PkP7K70NFN3rivIHfq0pxNetpDe/9/oM869VdcH+aMW4HQ23oKnfouagIn1di5qa59xOfksE0ldffaVLLrlEQ4YMkSR16NBBc+fO1TfffOM37tdff9W4ceO0aNGi2rGhqMJboSsWXKGcohz1aNVDL17yIi2bAAAAcBBLi+hut1t9+vTR4sWLNXz4cEnmjUUXL16s22+/PeBxf/vb3/TQQw9p0aJFOu2005ooWgCIUDablJBubp3Oa9wxhlGvuF51QKH9wP2+A8ZUmS1nagry9YvzDe73HTCmofcI8r3rjznsewSKL4j3MLyHmU+v5D3MmEjjqC6ou6LqFdc9ZoshZ/3nDrW/8cfYnR7FuqIVG+9R64TGtaNpiGEYKq/y+RXii8ora1fBN7gyvrpYX39fYVmVKqrMH1aVVnhVWuHVzqPtG++0V690P/JCfHyUUx4nfeND2cCBAzV79mxt3rxZXbt21erVq7V06VLNmDGjdozP59OYMWM0ceJEZWVlWRjt0btr0V1aum2pEjwJWjhqoeI98VaHBAAAgGbI8nYuEyZM0NixY3XaaaepX79+euKJJ1RSUqLrrrtOknTNNdeobdu2mjZtmiTzV0wnT56s119/XR06dFBeXp4kKS4uTnFxcZadBwCgHpvNvOGpnJL4baDDMoy6Qr1fAb+hQn1jCvj1i/+NKOAf7gcPR/zeR/LDjQZ+iOGtkCr3SzLq5sxbbm7lBU3/5+U8oAh/4Cp5Z1TAorzN6VGUM0pRrii1qj/eHSXFHHhMjH+B3+HyW4FfXuVVSbn3iArxRfWeK63pG1/lU371jV6PanrstgA3cHUpzuM8qFAff0CLmprxMW4HxXgLTJo0SYWFherWrZscDoe8Xq8eeughjR49unbMww8/LKfTeVB7l0MpLy9XeXndD3oKCwuPadxH4pXVr2jm8pmSpFcvfVVdk7taHBEAAACaK8uL6KNGjdKuXbs0efJk5eXlqXfv3vroo49qbza6bds22evdhG7WrFmqqKjQ5Zdf7vc6U6ZM0f3339+UoQMAcGzYbHXtS9AwwzDbB1WVSVXlUtX+6q9lUmVZvf1l/pvfc/WOqSo3C/MHHXPg/urj6qsZ29Rsdr8Cvad6SzpUId8VLUV7pPjAq+69drf2y61Sn1OlXqeKvQ4VVblU5HWosNKhfRUOFVaqtn1NQ0X64rIqFVeYfeOrfIb2lVZqX+nR9Y2326RYz4F94V3m44ZWxjd0g9cop2Ld9I0Pxvz58/Xaa6/p9ddfV1ZWlrKzszV+/Hilp6dr7NixWrFihZ588kmtXLkyqB9yTJs2TVOnTj2OkQdnZe5K3fL+LZKkyWdN1rDMYRZHBAAAgObMZhiGcfhh4aOwsFCJiYkqKChQQkKC1eEAAIDmzjDM1fBHVJQ/VJH/EIX8muO8R9ei5ZixOQ7dIsfpkeGMUpXDoyq5VWFzq1wulculMsOt/YbLLNL7nCr2uVRc5VCR16nCSocKqxwqqLBrb6VDe8vt2lthV4nPVX28Wz4dfa/2WLfjsIX4tMQoje7f/hhMVnCaW26akZGhSZMm6bbbbqvd9+CDD2rOnDnauHGjnnjiCU2YMMFvkYvX65XdbldGRoZ++umnBl+3oZXoGRkZlpx3fmm++szuo20F2zSkyxC9d9V7stu4JwAAAEAkamw+bvlKdAAAgGbNZqsuFnukqMSmfW+fr7qA35iV9wFW0R90XAPHVzbwet56bV0Mr1RZYm4B2CS5qrfoozlnt/9Dw+aUt3rFvNfmVqXdo0qbWxUyC/VlcqnMcGm/z6USn1msL/aaRfpSb3Uh3+tWeYlL5cXVj+VWkVzKN8zvy+VWanKSJUX05qa0tNSvQC5JDodDPp/Zg3/MmDEaNGiQ3/ODBw/WmDFjatsxNsTj8cjjsb69V5WvSle+eaW2FWxT56TOmnPZHAroAAAAOCyK6AAAAM2V3S7Zq1eANzWfr+GCe2NX0QfVeueA1/PVtYKxGVVyVhYHn7Taq7dG2uNtL+mKYN8l7AwdOlQPPfSQTjjhBGVlZWnVqlWaMWOGrr/+eklScnKykpOT/Y5xuVxKS0tTZmamFSEH5d7F92rx1sWKdcVq4aiFahHVwuqQAAAAEAIoogMAAOBgdrvkjjG3pubzHlCUD6J//eEK+QF+AJCU1Lrpz7MZeuqpp3Tffffp97//vXbu3Kn09HTdcsstmjx5stWhHRNt49vKaXfqhUteUM/UnlaHAwAAgBBBT3QAAADAIpGam1p53lv3blXHlh2b9D0BAADQPDU2L6UBIAAAAICIQQEdAAAAwaKIDgAAAAAAAABAABTRAQAAAAAAAAAIgCI6AAAAAAAAAAABUEQHAAAAAAAAACAAiugAAAAAAAAAAARAER0AAAAAAAAAgAAoogMAAAAAAAAAEABFdAAAAAAAAAAAAqCIDgAAAAAAAABAABTRAQAAAAAAAAAIwGl1AE3NMAxJUmFhocWRAAAAINLV5KQ1OWqkICcHAABAc9DYfDziiuhFRUWSpIyMDIsjAQAAAExFRUVKTEy0OowmQ04OAACA5uRw+bjNiLBlLz6fTzk5OYqPj5fNZmvS9y4sLFRGRoa2b9+uhISEJn3vUMWcBY85Cx5zFjzm7Mgwb8FjzoLHnAXPyjkzDENFRUVKT0+X3R45nRatysn5+3FkmLfgMWfBY86Cx5wFjzkLHnMWPOYseKGQj0fcSnS73a527dpZGkNCQgJ/iYLEnAWPOQsecxY85uzIMG/BY86Cx5wFz6o5i6QV6DWszsn5+3FkmLfgMWfBY86Cx5wFjzkLHnMWPOYseM05H4+c5S4AAAAAAAAAAASJIjoAAAAAAAAAAAFQRG9CHo9HU6ZMkcfjsTqUkMGcBY85Cx5zFjzm7Mgwb8FjzoLHnAWPOYsc/FkfGeYteMxZ8Jiz4DFnwWPOgsecBY85C14ozFnE3VgUAAAAAAAAAIDGYiU6AAAAAAAAAAABUEQHAAAAAAAAACAAiugAAAAAAAAAAARAEf0Ye/rpp9WhQwdFRUWpf//++uabbw45fsGCBerWrZuioqJ00kkn6YMPPmiiSJuPYObspZdeks1m89uioqKaMFrrffHFFxo6dKjS09Nls9n0zjvvHPaYJUuW6NRTT5XH41Hnzp310ksvHfc4m5Ng52zJkiUHXWc2m015eXlNE3AzMG3aNPXt21fx8fFKTU3V8OHDtWnTpsMeF8mfaUcyZ5H+mTZr1iydfPLJSkhIUEJCggYMGKAPP/zwkMdE8jUmBT9nkX6NNWT69Omy2WwaP378IcdF+rUWysjHjww5eeORjwePfDx45OPBIx8PHvl48MjHj16o5uMU0Y+hN954QxMmTNCUKVO0cuVK9erVS4MHD9bOnTsbHP/VV1/pqquu0g033KBVq1Zp+PDhGj58uNauXdvEkVsn2DmTpISEBOXm5tZuP//8cxNGbL2SkhL16tVLTz/9dKPGb926VUOGDNG5556r7OxsjR8/XjfeeKMWLVp0nCNtPoKdsxqbNm3yu9ZSU1OPU4TNz+eff67bbrtNX3/9tT7++GNVVlbqggsuUElJScBjIv0z7UjmTIrsz7R27dpp+vTpWrFihb799ludd955uuSSS7Ru3boGx0f6NSYFP2dSZF9jB1q+fLmeffZZnXzyyYccx7UWusjHjww5eXDIx4NHPh488vHgkY8Hj3w8eOTjRyek83EDx0y/fv2M2267rfax1+s10tPTjWnTpjU4fuTIkcaQIUP89vXv39+45ZZbjmuczUmwc/biiy8aiYmJTRRd8yfJWLhw4SHH/PGPfzSysrL89o0aNcoYPHjwcYys+WrMnH322WeGJGPv3r1NElMo2LlzpyHJ+PzzzwOO4TPNX2PmjM+0g7Vs2dL4xz/+0eBzXGMNO9SccY3VKSoqMrp06WJ8/PHHxtlnn23ceeedAcdyrYUu8vEjQ05+5MjHg0c+fmTIx4NHPn5kyMeDRz7eOKGej7MS/RipqKjQihUrNGjQoNp9drtdgwYN0rJlyxo8ZtmyZX7jJWnw4MEBx4ebI5kzSSouLlb79u2VkZFx2J/2gevsaPTu3Vtt2rTRb3/7W3355ZdWh2OpgoICSVJSUlLAMVxr/hozZxKfaTW8Xq/mzZunkpISDRgwoMExXGP+GjNnEtdYjdtuu01Dhgw56BpqCNdaaCIfPzLk5Mcf19mRIx+vQz4ePPLx4JCPB498PDihno9TRD9G8vPz5fV61bp1a7/9rVu3Dti3LS8vL6jx4eZI5iwzM1MvvPCC3n33Xc2ZM0c+n08DBw7UL7/80hQhh6RA11lhYaH2799vUVTNW5s2bfTMM8/orbfe0ltvvaWMjAydc845WrlypdWhWcLn82n8+PE644wz1LNnz4DjIv0zrb7GzhmfadKaNWsUFxcnj8ejW2+9VQsXLlSPHj0aHMs1ZgpmzrjGTPPmzdPKlSs1bdq0Ro3nWgtN5ONHhpz8+CMfDx75uD/y8eCRjzce+XjwyMeDFw75uNOydwaOwIABA/x+ujdw4EB1795dzz77rB544AELI0M4yczMVGZmZu3jgQMHasuWLXr88cf16quvWhiZNW677TatXbtWS5cutTqUkNHYOeMzzfz7lp2drYKCAr355psaO3asPv/884BJKIKbM64xafv27brzzjv18ccfR/xNnIBjhc8WHG/k4/7Ix4NHPt545OPBIx8PTrjk4xTRj5GUlBQ5HA7t2LHDb/+OHTuUlpbW4DFpaWlBjQ83RzJnB3K5XDrllFP0ww8/HI8Qw0Kg6ywhIUHR0dEWRRV6+vXrF5FJ6+233673339fX3zxhdq1a3fIsZH+mVYjmDk7UCR+prndbnXu3FmS1KdPHy1fvlxPPvmknn322YPGco2ZgpmzA0XiNbZixQrt3LlTp556au0+r9erL774QjNnzlR5ebkcDoffMVxroYl8/MiQkx9/5OPHBvk4+XhjkY8Hh3w8eOTjwQmXfJx2LseI2+1Wnz59tHjx4tp9Pp9PixcvDtgXacCAAX7jJenjjz8+ZB+lcHIkc3Ygr9erNWvWqE2bNscrzJAX6dfZsZKdnR1R15lhGLr99tu1cOFCffrpp+rYseNhj4n0a+1I5uxAfKaZ/w6Ul5c3+FykX2OBHGrODhSJ19j555+vNWvWKDs7u3Y77bTTNHr0aGVnZx+UsEtca6GKfPzIkJMff1xnxwb5OPn44ZCPHxvk48EjHz+0sMnHLbulaRiaN2+e4fF4jJdeeslYv369cfPNNxstWrQw8vLyDMMwjDFjxhiTJk2qHf/ll18aTqfTePTRR40NGzYYU6ZMMVwul7FmzRqrTqHJBTtnU6dONRYtWmRs2bLFWLFihXHllVcaUVFRxrp166w6hSZXVFRkrFq1yli1apUhyZgxY4axatUq4+effzYMwzAmTZpkjBkzpnb8jz/+aMTExBgTJ040NmzYYDz99NOGw+EwPvroI6tOockFO2ePP/648c477xjff/+9sWbNGuPOO+807Ha78cknn1h1Ck3uf//3f43ExERjyZIlRm5ubu1WWlpaO4bPNH9HMmeR/pk2adIk4/PPPze2bt1qfPfdd8akSZMMm81m/Pvf/zYMg2usIcHOWaRfY4GcffbZxp133ln7mGstfJCPHxly8uCQjwePfDx45OPBIx8PHvl48MjHj41QzMcpoh9jTz31lHHCCScYbrfb6Nevn/H111/XPnf22WcbY8eO9Rs/f/58o2vXrobb7TaysrKMf/3rX00csfWCmbPx48fXjm3durVx8cUXGytXrrQgaut89tlnhqSDtpp5Gjt2rHH22WcfdEzv3r0Nt9ttnHjiicaLL77Y5HFbKdg5e/jhh41OnToZUVFRRlJSknHOOecYn376qTXBW6Sh+ZLkd+3wmebvSOYs0j/Trr/+eqN9+/aG2+02WrVqZZx//vm1yadhcI01JNg5i/RrLJADk3autfBCPn5kyMkbj3w8eOTjwSMfDx75ePDIx4NHPn5shGI+bjMMwzj269sBAAAAAAAAAAh99EQHAAAAAAAAACAAiugAAAAAAAAAAARAER0AAAAAAAAAgAAoogMAAAAAAAAAEABFdAAAAAAAAAAAAqCIDgAAAAAAAABAABTRAQAAAAAAAAAIgCI6AAAAAAAAAAABUEQHADQpm82md955x+owAAAAgIhEPg4AwaOIDgAR5Nprr5XNZjtou/DCC60ODQAAAAh75OMAEJqcVgcAAGhaF154oV588UW/fR6Px6JoAAAAgMhCPg4AoYeV6AAQYTwej9LS0vy2li1bSjJ/tXPWrFm66KKLFB0drRNPPFFvvvmm3/Fr1qzReeedp+joaCUnJ+vmm29WcXGx35gXXnhBWVlZ8ng8atOmjW6//Xa/5/Pz83XppZcqJiZGXbp00XvvvXd8TxoAAABoJsjHASD0UEQHAPi57777NGLECK1evVqjR4/WlVdeqQ0bNkiSSkpKNHjwYLVs2VLLly/XggUL9Mknn/gl5bNmzdJtt92mm2++WWvWrNF7772nzp07+73H1KlTNXLkSH333Xe6+OKLNXr0aO3Zs6dJzxMAAABojsjHAaD5sRmGYVgdBACgaVx77bWaM2eOoqKi/Pbfe++9uvfee2Wz2XTrrbdq1qxZtc+dfvrpOvXUU/X3v/9dzz33nO655x5t375dsbGxkqQPPvhAQ4cOVU5Ojlq3bq22bdvquuuu04MPPthgDDabTX/5y1/0wAMPSDL/IxAXF6cPP/yQXpAAAAAIa+TjABCa6IkOABHm3HPP9UvKJSkpKan2+wEDBvg9N2DAAGVnZ0uSNmzYoF69etUm7JJ0xhlnyOfzadOmTbLZbMrJydH5559/yBhOPvnk2u9jY2OVkJCgnTt3HukpAQAAACGDfBwAQg9FdACIMLGxsQf9OuexEh0d3ahxLpfL77HNZpPP5zseIQEAAADNCvk4AIQeeqIDAPx8/fXXBz3u3r27JKl79+5avXq1SkpKap//8ssvZbfblZmZqfj4eHXo0EGLFy9u0pgBAACAcEE+DgDNDyvRASDClJeXKy8vz2+f0+lUSkqKJGnBggU67bTTdOaZZ+q1117TN998o+eff16SNHr0aE2ZMkVjx47V/fffr127dmncuHEaM2aMWrduLUm6//77deuttyo1NVUXXXSRioqK9OWXX2rcuHFNe6IAAABAM0Q+DgChhyI6AESYjz76SG3atPHbl5mZqY0bN0qSpk6dqnnz5un3v/+92rRpo7lz56pHjx6SpJiYGC1atEh33nmn+vbtq5iYGI0YMUIzZsyofa2xY8eqrKxMjz/+uO6++26lpKTo8ssvb7oTBAAAAJox8nEACD02wzAMq4MAADQPNptNCxcu1PDhw60OBQAAAIg45OMA0DzREx0AAAAAAAAAgAAoogMAAAAAAAAAEADtXAAAAAAAAAAACICV6AAAAAAAAAAABEARHQAAAAAAAACAACiiAwAAAAAAAAAQAEV0AAAAAAAAAAACoIgOAAAAAAAAAEAAFNEBAAAAAAAAAAiAIjoAAAAAAAAAAAFQRAcAAAAAAAAAIACK6AAAAAAAAAAABPD/AeAdpBJLkHCBAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'params': 5526346,\n", + " 'final_train_loss': 0.17730180516259184,\n", + " 'final_val_loss': 0.17305467269460487,\n", + " 'final_accuracy': 94.36}" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Train the NdLinear incorporated model" + ], + "metadata": { + "id": "yF7Ym1oNvolg" + } + }, + { + "cell_type": "code", + "source": [ + "ndlinear_model = SmallViT(use_ndlinear=True).to(device)\n", + "train_and_compare(ndlinear_model, train_loader, test_loader, epochs=5)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 620 + }, + "id": "9sWjiWejWRTx", + "outputId": "b30a3fba-dfe2-4d7a-c753-8a3e3ab3a146" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "๐Ÿ” Trainable Parameters: 5,526,444\n", + "๐Ÿ“ฆ Approx. Model Size: 22.11 MB\n", + "\n", + "๐Ÿงช Epoch [1/5] | Train Loss: 1458.6610 | Val Loss: 133.2399 | Accuracy: 71.38% | Time: 402.86s\n", + "๐Ÿงช Epoch [2/5] | Train Loss: 530.3348 | Val Loss: 50.9713 | Accuracy: 90.00% | Time: 403.43s\n", + "๐Ÿงช Epoch [3/5] | Train Loss: 307.6107 | Val Loss: 39.9321 | Accuracy: 91.67% | Time: 407.47s\n", + "๐Ÿงช Epoch [4/5] | Train Loss: 231.5446 | Val Loss: 34.6694 | Accuracy: 93.17% | Time: 406.19s\n", + "๐Ÿงช Epoch [5/5] | Train Loss: 193.0584 | Val Loss: 27.2530 | Accuracy: 94.46% | Time: 404.55s\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'params': 5526444,\n", + " 'final_train_loss': 0.20581914684268585,\n", + " 'final_val_loss': 0.17358604584268894,\n", + " 'final_accuracy': 94.46}" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. LoRA Adapter Injection\n", + "\n", + "This section adds low-rank adaptation (LoRA) by injecting trainable low-rank matrices `A` and `B` into each (Nd)Linear layer.\n" + ], + "metadata": { + "id": "FpRIgYRkvjGe" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Define a SmallViT model with LoRA adapters added manually\n", + "class SmallViTWithLoRA(SmallViT):\n", + " def __init__(self, use_ndlinear=True, lora_rank=4):\n", + " super(SmallViTWithLoRA, self).__init__(use_ndlinear=use_ndlinear)\n", + "\n", + " # Apply simple LoRA adapters to Linear (or NdLinear) layers\n", + " for name, module in self.named_modules():\n", + " if isinstance(module, nn.Linear):\n", + " in_features, out_features = module.in_features, module.out_features\n", + " lora_A = nn.Parameter(torch.randn(lora_rank, in_features) * 0.01)\n", + " lora_B = nn.Parameter(torch.randn(out_features, lora_rank) * 0.01)\n", + " module.lora_A = lora_A\n", + " module.lora_B = lora_B\n", + "\n", + " # Modify forward\n", + " orig_forward = module.forward\n", + " def lora_forward(x, orig_forward=orig_forward, module=module):\n", + " return orig_forward(x) + (x @ module.lora_A.T) @ module.lora_B.T\n", + " module.forward = lora_forward\n", + "\n", + "# Instantiate and train\n", + "lora_model = SmallViTWithLoRA(use_ndlinear=True).to(device)\n", + "train_and_compare(lora_model, train_loader, test_loader, epochs=5)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 620 + }, + "id": "mCts-mtQy9K0", + "outputId": "7c2b9792-4018-49a1-e739-bd9790aca6b0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "๐Ÿ” Trainable Parameters: 5,675,100\n", + "๐Ÿ“ฆ Approx. Model Size: 22.70 MB\n", + "\n", + "๐Ÿงช Epoch [1/5] | Train Loss: 793.8806 | Val Loss: 43.4161 | Accuracy: 91.16% | Time: 759.48s\n", + "๐Ÿงช Epoch [2/5] | Train Loss: 236.1159 | Val Loss: 28.0390 | Accuracy: 94.34% | Time: 759.33s\n", + "๐Ÿงช Epoch [3/5] | Train Loss: 183.0840 | Val Loss: 26.7599 | Accuracy: 94.48% | Time: 759.45s\n", + "๐Ÿงช Epoch [4/5] | Train Loss: 153.8351 | Val Loss: 25.8025 | Accuracy: 94.53% | Time: 759.38s\n", + "๐Ÿงช Epoch [5/5] | Train Loss: 137.1448 | Val Loss: 21.8819 | Accuracy: 95.52% | Time: 759.57s\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAGGCAYAAACUkchWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAu+VJREFUeJzs3XdYU+f7BvA7YYSNCMgSQZaAIiqodS8UFy5AHBXBbd1abalbq7auWqsV957gbLUi7oV7b0EFB4qobGUk5/eHX/MTAQVFD+P+XFeumpP3nHMnBPvm8c1zJIIgCCAiIiIiIiIiIiIiohykYgcgIiIiIiIiIiIiIiqqWEQnIiIiIiIiIiIiIsoDi+hERERERERERERERHlgEZ2IiIiIiIiIiIiIKA8sohMRERERERERERER5YFFdCIiIiIiIiIiIiKiPLCITkRERERERERERESUBxbRiYiIiIiIiIiIiIjywCI6EREREREREREREVEeWEQnIiL6wOHDhyGRSBAaGip2FCIiIqJC9eDBA0gkEqxatUq5bdKkSZBIJPnaXyKRYNKkSYWaqXHjxmjcuHGhHpOoOLO2tkbbtm3FjkFE72ERnYgoD6tWrYJEIsG5c+fEjpIvJ06cQMeOHWFiYgKZTAZra2v0798fMTExYkfL4V2ROq/bpk2bxI5IREREJLp27dpBS0sLycnJeY7p3r071NXV8eLFi2+YrOBu3LiBSZMm4cGDB2JHydWePXsgkUhgbm4OhUIhdpxi58WLFxg9ejQqVaoEDQ0NlC1bFp6envj333/FjpYra2vrPD+LtGzZUux4RFQEqYodgIiIvtxff/2FYcOGwcbGBkOGDIGZmRlu3ryJZcuWYfPmzdizZw/q1q0rdswchg4dipo1a+bYXqdOHRHSEBERERUt3bt3xz///IPt27fD398/x+NpaWnYuXMnWrZsCUNDw88+z7hx4/Dzzz9/SdRPunHjBiZPnozGjRvD2to622P79u37qufOj/Xr18Pa2hoPHjzAwYMH4eHhIXakYuP27dto1qwZnj9/jsDAQLi7uyMhIQHr16+Hl5cXfvzxR8yaNUvsmDlUq1YNo0aNyrHd3NxchDREVNSxiE5EVMydOHECw4cPR/369bF3715oaWkpHxs4cCDq1asHHx8fXL9+HQYGBt8sV2pqKrS1tT86pkGDBvDx8flGiYiIiIiKl3bt2kFXVxcbNmzItYi+c+dOpKamonv37l90HlVVVaiqilceUFdXF+3cwNt5686dOzFjxgysXLkS69evL7JF9PzMsb+lzMxM+Pj44NWrVzh69Chq166tfGzEiBHo3r07Zs+eDXd3d/j5+X2zXFlZWVAoFB99b1lYWOD777//ZpmIqHhjOxcioi908eJFtGrVCnp6etDR0UGzZs1w6tSpbGMyMzMxefJk2NvbQ0NDA4aGhqhfvz7Cw8OVY54+fYrAwECUL18eMpkMZmZmaN++/Se/8jp16lRIJBKsXr06WwEdAGxtbTFz5kzExsZi8eLFAIDZs2dDIpEgOjo6x7GCgoKgrq6OV69eKbedPn0aLVu2hL6+PrS0tNCoUSOcOHEi237v+mjeuHED3bp1g4GBAerXr5+v1+9TJBIJBg8ejPXr1yu/Hurm5oajR4/mGJufnwUAJCQkYMSIEbC2toZMJkP58uXh7++P+Pj4bOMUCgWmTZuG8uXLQ0NDA82aNUNkZGS2MXfv3oW3tzdMTU2hoaGB8uXLo0uXLkhMTCyU509ERESll6amJjp16oQDBw4gLi4ux+MbNmyArq4u2rVrh5cvX+LHH3+Ei4sLdHR0oKenh1atWuHy5cufPE9uPdHT09MxYsQIGBsbK8/x6NGjHPtGR0fjhx9+QKVKlaCpqQlDQ0P4+vpmm8OuWrUKvr6+AIAmTZoo22YcPnwYQO490ePi4tC7d2+YmJhAQ0MDrq6uWL16dbYx7/q7z549G0uWLIGtrS1kMhlq1qyJs2fPfvJ5v7N9+3a8fv0avr6+6NKlC7Zt24Y3b97kGPfmzRtMmjQJDg4O0NDQgJmZGTp16oSoqCjlGIVCgT///BMuLi7Q0NCAsbExWrZsqWwRmVtP+nc+7Df/sTn2lStXEBAQABsbG2hoaMDU1BS9evXKta3P48eP0bt3b5ibm0Mmk6FixYoYOHAgMjIycO/ePUgkEvzxxx859jt58iQkEgk2btyY52u3detWXLt2DT///HO2AjoAqKioYPHixShTpozyeT179gyqqqqYPHlyjmPdvn0bEokECxYsUG5LSEjA8OHDYWlpCZlMBjs7O/z+++/ZWu68/z6YN2+e8n1w48aNPHPnV0BAAHR0dHDv3j14enpCW1sb5ubmmDJlCgRByDY2NTUVo0aNUmatVKkSZs+enWMcAKxbtw61atWClpYWDAwM0LBhw1y/kXH8+HHUqlULGhoasLGxwZo1a7I9np/PmURUOLgSnYjoC1y/fh0NGjSAnp4exowZAzU1NSxevBiNGzfGkSNHlBPJSZMmYcaMGejTpw9q1aqFpKQknDt3DhcuXEDz5s0BAN7e3rh+/TqGDBkCa2trxMXFITw8HDExMTm+8vpOWloaDhw4gAYNGqBixYq5jvHz80O/fv3w77//4ueff0bnzp0xZswYbNmyBaNHj842dsuWLWjRooVyxfrBgwfRqlUruLm5YeLEiZBKpVi5ciWaNm2KY8eOoVatWtn29/X1hb29PaZPn57rZPFDycnJOQrXAGBoaJjtg9yRI0ewefNmDB06FDKZDH///TdatmyJM2fOoEqVKgX6WaSkpKBBgwa4efMmevXqhRo1aiA+Ph67du3Co0ePYGRkpDzvb7/9BqlUih9//BGJiYmYOXMmunfvjtOnTwMAMjIy4OnpifT0dAwZMgSmpqZ4/Pgx/v33XyQkJEBfX/+TrwERERHRx3Tv3h2rV6/Gli1bMHjwYOX2ly9fIiwsDF27doWmpiauX7+OHTt2wNfXFxUrVsSzZ8+wePFiNGrUCDdu3Chwi4o+ffpg3bp16NatG+rWrYuDBw+iTZs2OcadPXsWJ0+eRJcuXVC+fHk8ePAAixYtQuPGjXHjxg1oaWmhYcOGGDp0KObPn49ffvkFTk5OAKD874dev36Nxo0bIzIyEoMHD0bFihUREhKCgIAAJCQkYNiwYdnGb9iwAcnJyejfvz8kEglmzpyJTp064d69e1BTU/vkc12/fj2aNGkCU1NTdOnSBT///DP++ecfZeEfAORyOdq2bYsDBw6gS5cuGDZsGJKTkxEeHo5r167B1tYWANC7d2+sWrUKrVq1Qp8+fZCVlYVjx47h1KlTcHd3z/fr/77c5tjh4eG4d+8eAgMDYWpqiuvXr2PJkiW4fv06Tp06pZxLP3nyBLVq1UJCQgL69esHR0dHPH78GKGhoUhLS4ONjQ3q1auH9evXY8SIETleF11dXbRv3z7PbP/88w8A5PpNCQDQ19dH+/btsXr1akRGRsLOzg6NGjXCli1bMHHixGxjN2/eDBUVFeXrnpaWhkaNGuHx48fo378/KlSogJMnTyIoKAixsbGYN29etv1XrlyJN2/eoF+/fpDJZChbtuxHX9fMzMxcP4toa2tDU1NTeV8ul6Nly5b47rvvMHPmTOzduxcTJ05EVlYWpkyZAgAQBAHt2rXDoUOH0Lt3b1SrVg1hYWEYPXo0Hj9+nO0fKSZPnoxJkyahbt26mDJlCtTV1XH69GkcPHgQLVq0UI6LjIyEj48PevfujZ49e2LFihUICAiAm5sbKleuDCB/nzOJqJAIRESUq5UrVwoAhLNnz+Y5pkOHDoK6uroQFRWl3PbkyRNBV1dXaNiwoXKbq6ur0KZNmzyP8+rVKwGAMGvWrAJlvHTpkgBAGDZs2EfHVa1aVShbtqzyfp06dQQ3N7dsY86cOSMAENasWSMIgiAoFArB3t5e8PT0FBQKhXJcWlqaULFiRaF58+bKbRMnThQACF27ds1X7kOHDgkA8rzFxsYqx77bdu7cOeW26OhoQUNDQ+jYsaNyW35/FhMmTBAACNu2bcuR693zfJfPyclJSE9PVz7+559/CgCEq1evCoIgCBcvXhQACCEhIfl63kREREQFlZWVJZiZmQl16tTJtj04OFgAIISFhQmCIAhv3rwR5HJ5tjH3798XZDKZMGXKlGzbAAgrV65Ubns3l3vn3Rzzhx9+yHa8bt26CQCEiRMnKrelpaXlyBwREZFtXikIghASEiIAEA4dOpRjfKNGjYRGjRop78+bN08AIKxbt065LSMjQ6hTp46go6MjJCUlZXsuhoaGwsuXL5Vjd+7cKQAQ/vnnnxzn+tCzZ88EVVVVYenSpcptdevWFdq3b59t3IoVKwQAwty5c3Mc490c8uDBgwIAYejQoXmOye31f+fD1/Zjc+zcXveNGzcKAISjR48qt/n7+wtSqTTXzzTvMi1evFgAINy8eVP5WEZGhmBkZCT07Nkzx37vq1atmqCvr//RMXPnzhUACLt27cp2vndz6necnZ2Fpk2bKu9PnTpV0NbWFu7cuZNt3M8//yyoqKgIMTExgiD8/2uqp6cnxMXFfTTLO1ZWVnl+FpkxY4ZyXM+ePQUAwpAhQ5TbFAqF0KZNG0FdXV14/vy5IAiCsGPHDgGA8Ouvv2Y7j4+PjyCRSITIyEhBEATh7t27glQqFTp27Jjj9/X9z1zv8r3/s4yLixNkMpkwatQo5bZPfc4kosLDdi5ERJ9JLpdj37596NChA2xsbJTbzczM0K1bNxw/fhxJSUkAgDJlyuD69eu4e/dursfS1NSEuro6Dh8+nK2VyqckJycDAHR1dT86TldXV5kFeLs6/fz589m+erp582bIZDLlSpNLly7h7t276NatG168eIH4+HjEx8cjNTUVzZo1w9GjR7N9jRIABgwYkO/sADBhwgSEh4fnuH24aqROnTpwc3NT3q9QoQLat2+PsLAwyOXyAv0stm7dCldXV3Ts2DFHng+/xhwYGJitj2KDBg0AAPfu3QMA5UrzsLAwpKWlFei5ExEREeWHiooKunTpgoiIiGwtUjZs2AATExM0a9YMACCTySCVvv2IL5fL8eLFC+jo6KBSpUq4cOFCgc65Z88eAG8vAv++4cOH5xj7/ordzMxMvHjxAnZ2dihTpkyBz/v++U1NTdG1a1flNjU1NQwdOhQpKSk4cuRItvF+fn7Zrv3z4ZztYzZt2gSpVApvb2/ltq5du+K///7LNi/funUrjIyMMGTIkBzHeDeH3Lp1KyQSSY4V1u+P+Ry5zbHff93fvHmD+Ph4fPfddwCgfN0VCgV27NgBLy+vXFfBv8vUuXNnaGhoYP369crHwsLCEB8f/8me4cnJyfn6LAJAOR/v1KkTVFVVsXnzZuWYa9eu4caNG9n6poeEhKBBgwYwMDBQfhaJj4+Hh4cH5HJ5jvaO3t7eMDY2/miW99WuXTvXzyLvv+/eef9bIO/aTWZkZGD//v0A3r5nVVRUcvzOjBo1CoIg4L///gMA7NixAwqFAhMmTFD+vr5/3Pc5Ozsr38sAYGxsjEqVKmV7X3/qcyYRFR4W0YmIPtPz58+RlpaGSpUq5XjMyckJCoUCDx8+BABMmTIFCQkJcHBwgIuLC0aPHo0rV64ox8tkMvz+++/477//YGJigoYNG2LmzJl4+vTpRzO8m5C+K6bn5cPJra+vL6RSqXLiKggCQkJClP3EASgnYj179oSxsXG227Jly5Cenp6j73deLWXy4uLiAg8Pjxy3Dy8AZG9vn2NfBwcHpKWl4fnz5wX6WURFRSlbwHxKhQoVst1/9+Hs3QeqihUrYuTIkVi2bBmMjIzg6emJhQsXsh86ERERFap3Fw7dsGEDAODRo0c4duwYunTpAhUVFQBvC6Z//PEH7O3tIZPJYGRkBGNjY1y5cqXAc5Po6GhIpVJli5J3cptrvX79GhMmTFD2gX533oSEhM+eE0VHR8Pe3j5HkfFd+5cPr+3zqTnbx7zrTf3ixQtERkYiMjIS1atXR0ZGBkJCQpTjoqKiUKlSpY9egDUqKgrm5uafbCNSULnNsV++fIlhw4bBxMQEmpqaMDY2Vo5797o/f/4cSUlJn5z7lilTBl5eXsr3F/C2lYuFhQWaNm360X11dXXz9Vnk3VgAMDIyQrNmzbBlyxblmM2bN0NVVRWdOnVSbrt79y727t2b47PIu4u+fnidgIJ+FjEyMsr1s4iVlVW2cVKpNNtCHeDtZxEAyn/Yio6Ohrm5eY5/UPjwPRsVFQWpVApnZ+dP5vvwfQ28fW+//77+1OdMIio8LKITEX0DDRs2RFRUFFasWIEqVapg2bJlqFGjBpYtW6YcM3z4cNy5cwczZsyAhoYGxo8fDycnJ1y8eDHP49rZ2UFVVfWjE6X09HTcvn0720TN3NwcDRo0UE5cT506hZiYmGwrP96tMp81a1auKzTCw8Oho6OT7Vzvr4gpCd59KP2Q8F6/9zlz5uDKlSv45Zdf8Pr1awwdOhSVK1fO9cJbRERERJ/Dzc0Njo6Oygs8bty4EYIgKIvrADB9+nSMHDkSDRs2xLp16xAWFobw8HBUrlw5x7cHC9OQIUMwbdo0dO7cGVu2bMG+ffsQHh4OQ0PDr3re9+Vnzpabu3fv4uzZszh+/Djs7e2Vt3cX73x/ZXZhyWtFulwuz3Of3ObYnTt3xtKlSzFgwABs27YN+/btw969ewHgs153f39/3Lt3DydPnkRycjJ27dqFrl275viHjA85OTkhMTERMTExeY5591nl/c8jXbp0wZ07d3Dp0iUAb6/N1KxZs2zXJ1IoFGjevHmen0Xe//YAUDo/i+TncyYRFQ5eWJSI6DMZGxtDS0sLt2/fzvHYrVu3IJVKYWlpqdxWtmxZBAYGIjAwECkpKWjYsCEmTZqEPn36KMfY2tpi1KhRGDVqFO7evYtq1aphzpw5WLduXa4ZtLW10aRJExw8eBDR0dE5Vk0Abyek6enpaNu2bbbtfn5++OGHH3D79m1s3rwZWlpa8PLyypYFAPT09JSrPcSS29cT79y5Ay0tLeVXNvP7s7C1tcW1a9cKNZ+LiwtcXFwwbtw4nDx5EvXq1UNwcDB+/fXXQj0PERERlV7du3fH+PHjceXKFWzYsAH29vaoWbOm8vHQ0FA0adIEy5cvz7ZfQkJCtsJkflhZWUGhUChXX7+T21wrNDQUPXv2xJw5c5Tb3rx5g4SEhGzjCtLOxMrKCleuXIFCochWxL1165by8cKwfv16qKmpYe3atTkKlsePH8f8+fMRExODChUqwNbWFqdPn0ZmZmaeFyu1tbVFWFgYXr58medq9Her5D98fT5cXf8xr169woEDBzB58mRMmDBBuf3DObOxsTH09PTyNfdt2bIljI2NsX79etSuXRtpaWno0aPHJ/dr27YtNm7ciDVr1mDcuHE5Hk9KSsLOnTvh6OgIOzs75fYOHTqgf//+ym/G3rlzB0FBQdn2tbW1RUpKiuifRRQKBe7du6dcfQ68zQsA1tbWAN6+J/fv35/jG8AfvmdtbW2hUChw48YNVKtWrVDy5edzJhF9Oa5EJyL6TCoqKmjRogV27tyZrT/ls2fPsGHDBtSvX1/ZGuXFixfZ9tXR0YGdnR3S09MBvL3y/Js3b7KNsbW1ha6urnJMXsaNGwdBEBAQEIDXr19ne+z+/fsYM2YMzMzM0L9//2yPeXt7Q0VFBRs3bkRISAjatm0LbW1t5eNubm6wtbXF7NmzkZKSkuO8z58//2iuwhQREZGtp+bDhw+xc+dOtGjRAioqKgX6WXh7e+Py5cvYvn17jvN8arXSh5KSkpCVlZVtm4uLC6RS6Sd/bkREREQF8W7V+YQJE3Dp0qVsq9CBt3PTD+cyISEhePz4cYHP1apVKwDA/Pnzs22fN29ejrG5nfevv/7KsbL63Tzzw+Jxblq3bo2nT59m65mdlZWFv/76Czo6OmjUqFF+nsYnrV+/Hg0aNICfnx98fHyy3UaPHg0AytX/3t7eiI+Px4IFC3Ic593z9/b2hiAImDx5cp5j9PT0YGRklKOf999//53v3O8K/h++7h/+fKRSKTp06IB//vkH586dyzMTAKiqqqJr167YsmULVq1aBRcXF1StWvWTWXx8fODs7IzffvstxzkUCgUGDhyIV69e5egTX6ZMGXh6emLLli3YtGkT1NXV0aFDh2xjOnfujIiICISFheU4b0JCQo55+Nf0/s9dEAQsWLAAampqymsStG7dGnK5PMf7448//oBEIlH+TnXo0AFSqRRTpkzJ8Y2Bgn4WAT79OZOICg9XohMRfcKKFSuUX41837Bhw/Drr78iPDwc9evXxw8//ABVVVUsXrwY6enpmDlzpnKss7MzGjduDDc3N5QtWxbnzp1DaGio8gI1d+7cQbNmzdC5c2c4OztDVVUV27dvx7Nnz9ClS5eP5mvYsCFmz56NkSNHomrVqggICICZmRlu3bqFpUuXQqFQYM+ePdkutgQA5cqVQ5MmTTB37lwkJydna+UCvJ10L1u2DK1atULlypURGBgICwsLPH78GIcOHYKenh7++eefz31ZAQDHjh3L8Y8HAFC1atVsk/YqVarA09MTQ4cOhUwmU37IeP8DSn5/FqNHj0ZoaCh8fX3Rq1cvuLm54eXLl9i1axeCg4Ph6uqa7/wHDx7E4MGD4evrCwcHB2RlZSlXMn349VIiIiKiL1GxYkXUrVsXO3fuBIAcRfS2bdtiypQpCAwMRN26dXH16lWsX78+Ry/n/KhWrRq6du2Kv//+G4mJiahbty4OHDiAyMjIHGPbtm2LtWvXQl9fH87OzoiIiMD+/fthaGiY45gqKir4/fffkZiYCJlMhqZNm6JcuXI5jtmvXz8sXrwYAQEBOH/+PKytrREaGooTJ05g3rx5n7yQZX6cPn0akZGR2S4Y+T4LCwvUqFED69evx08//QR/f3+sWbMGI0eOxJkzZ9CgQQOkpqZi//79+OGHH9C+fXs0adIEPXr0wPz583H37l20bNkSCoUCx44dQ5MmTZTn6tOnD3777Tf06dMH7u7uOHr0qHJlc37o6ekpr6GUmZkJCwsL7Nu3D/fv388xdvr06di3bx8aNWqEfv36wcnJCbGxsQgJCcHx48dRpkwZ5Vh/f3/Mnz8fhw4dwu+//56vLOrq6ggNDUWzZs1Qv359BAYGwt3dHQkJCdiwYQMuXLiAUaNG5fqZxs/PD99//z3+/vtveHp6ZssCvJ2379q1C23btkVAQADc3NyQmpqKq1evIjQ0FA8ePCjwtyze9/jx41y/8aujo5OtoK+hoYG9e/eiZ8+eqF27Nv777z/s3r0bv/zyi/JbsV5eXmjSpAnGjh2LBw8ewNXVFfv27cPOnTsxfPhw5bd87ezsMHbsWEydOhUNGjRAp06dIJPJcPbsWZibm2PGjBkFeg6f+pxJRIVIICKiXK1cuVIAkOft4cOHgiAIwoULFwRPT09BR0dH0NLSEpo0aSKcPHky27F+/fVXoVatWkKZMmUETU1NwdHRUZg2bZqQkZEhCIIgxMfHC4MGDRIcHR0FbW1tQV9fX6hdu7awZcuWfOc9evSo0L59e8HIyEhQU1MTKlSoIPTt21d48OBBnvssXbpUACDo6uoKr1+/znXMxYsXhU6dOgmGhoaCTCYTrKyshM6dOwsHDhxQjpk4caIAQHj+/Hm+sh46dOijr+3EiROVYwEIgwYNEtatWyfY29sLMplMqF69unDo0KEcx83Pz0IQBOHFixfC4MGDBQsLC0FdXV0oX7680LNnTyE+Pj5bvpCQkGz73b9/XwAgrFy5UhAEQbh3757Qq1cvwdbWVtDQ0BDKli0rNGnSRNi/f3++XgciIiKigli4cKEAQKhVq1aOx968eSOMGjVKMDMzEzQ1NYV69eoJERERQqNGjYRGjRopx304nxGE/5/Lve/169fC0KFDBUNDQ0FbW1vw8vISHj58mGOu9urVKyEwMFAwMjISdHR0BE9PT+HWrVuClZWV0LNnz2zHXLp0qWBjYyOoqKgIAJTzuQ8zCoIgPHv2THlcdXV1wcXFJVvm95/LrFmzcrweH+b80JAhQwQAQlRUVJ5jJk2aJAAQLl++LAiCIKSlpQljx44VKlasKKipqQmmpqaCj49PtmNkZWUJs2bNEhwdHQV1dXXB2NhYaNWqlXD+/HnlmLS0NKF3796Cvr6+oKurK3Tu3FmIi4vLkfljc+xHjx4JHTt2FMqUKSPo6+sLvr6+wpMnT3J93tHR0YK/v79gbGwsyGQywcbGRhg0aJCQnp6e47iVK1cWpFKp8OjRozxfl9zExcUJI0eOFOzs7ASZTCaUKVNG8PDwEHbt2pXnPklJSYKmpqYAQFi3bl2uY5KTk4WgoCDBzs5OUFdXF4yMjIS6desKs2fPVn6W+tj7IC9WVlZ5fhaxsrJSjuvZs6egra0tREVFCS1atBC0tLQEExMTYeLEiYJcLs+RdcSIEYK5ubmgpqYm2NvbC7NmzRIUCkWO869YsUKoXr26IJPJBAMDA6FRo0ZCeHh4tnxt2rTJsd+Hvyuf+pxJRIVHIgif8X0RIiKib0QikWDQoEG5fnWWiIiIiIgKT/Xq1VG2bFkcOHBA7ChFQkBAAEJDQ3Ntb0lEpQt7ohMRERERERERlXLnzp3DpUuX4O/vL3YUIqIihz3RiYiIiIiIiIhKqWvXruH8+fOYM2cOzMzMclwriYiIuBKdiIiIiIiIiKjUCg0NRWBgIDIzM7Fx40ZoaGiIHYmIqMhhT3QiIiIiIiIiIiIiojxwJToRERERERERERERUR5YRCciIiIiIiIiIiIiykOpu7CoQqHAkydPoKurC4lEInYcIiIiIirFBEFAcnIyzM3NIZWWnvUtnJMTERERUVGQ3/l4qSuiP3nyBJaWlmLHICIiIiJSevjwIcqXLy92jG+Gc3IiIiIiKko+NR8vdUV0XV1dAG9fGD09PZHTEBEREVFplpSUBEtLS+UctbTgnJyIiIiIioL8zsdLXRH93ddF9fT0OGEnIiIioiKhtLU04ZyciIiIiIqST83HS0/jRSIiIiIiIiIiIiKiAmIRnYiIiIiIiIiIiIgoDyyiExERERERERERERHlodT1RCciIiLKjVwuR2ZmptgxqIRRU1ODioqK2DGKJYVCgYyMDLFjEH0V6urqkEq5po2IiKi4YBGdiIiISjVBEPD06VMkJCSIHYVKqDJlysDU1LTUXTz0S2RkZOD+/ftQKBRiRyH6KqRSKSpWrAh1dXWxoxAREVE+sIhOREREpdq7Anq5cuWgpaXFQicVGkEQkJaWhri4OACAmZmZyImKB0EQEBsbCxUVFVhaWnK1LpU4CoUCT548QWxsLCpUqMD/7xARERUDLKITERFRqSWXy5UFdENDQ7HjUAmkqakJAIiLi0O5cuXY2iUfsrKykJaWBnNzc2hpaYkdh+irMDY2xpMnT5CVlQU1NTWx4xAREdEncFkHERERlVrveqCzUEdf07v3F3vu549cLgcAtrmgEu3d+/vd+52IiIiKNhbRiYiIqNTjV+npa+L76/PwdaOSjO9vIiKi4oVF9G9IEAS8SEkXOwYRERERERERERFRkZGcnix2hI9iEf0beZWagQHrzqP9whNITc8SOw4RERFRDtbW1pg3b57YMYhKrcaNG2P48OHK+/n5nZRIJNixY8cXn7uwjkNERESUXwpBgbDIMHTY1AEWcy2Q8CZB7Eh5YhH9G1FXleLa4yQ8evUav++9JXYcIiIiKsYkEslHb5MmTfqs4549exb9+vX7omwfFgGJSgMvLy+0bNky18eOHTsGiUSCK1euFPi4hfE7+aFJkyahWrVqObbHxsaiVatWhXquvLx+/Rply5aFkZER0tP5TV0iIqLS5nnqc/x+/HfY/2WPlutbYuftnUjOSEZ4VLjY0fKkKnaA0kJbpoqZPlXRfdlprImIRqsqZqhjayh2LCIiIiqGYmNjlX/evHkzJkyYgNu3byu36ejoKP8sCALkcjlUVT897TM2Ni7coESlRO/eveHt7Y1Hjx6hfPny2R5buXIl3N3dUbVq1QIf91v+Tpqamn6zc23duhWVK1eGIAjYsWMH/Pz8vtm5P1SQvyOJiIjo8wmCgGMxxxB8LhihN0KRqcgEAOjL9BFQLQD93frDydhJ5JR540r0b6ienRG61qoAAPhp6xWkZbCtCxERERWcqamp8qavrw+JRKK8f+vWLejq6uK///6Dm5sbZDIZjh8/jqioKLRv3x4mJibQ0dFBzZo1sX///mzH/bB1hEQiwbJly9CxY0doaWnB3t4eu3bt+qLs74pnMpkM1tbWmDNnTrbH//77b9jb20NDQwMmJibw8fFRPhYaGgoXFxdoamrC0NAQHh4eSE1N/aI8RIWhbdu2MDY2xqpVq7JtT0lJQUhICHr37o0XL16ga9eusLCwgJaWFlxcXLBx48aPHvfD38m7d++iYcOG0NDQgLOzM8LDc67W+umnn+Dg4AAtLS3Y2Nhg/PjxyMx8+yF11apVmDx5Mi5fvqz85sq7zB+2c7l69SqaNm2q/H3r168fUlJSlI8HBASgQ4cOmD17NszMzGBoaIhBgwYpz/Uxy5cvx/fff4/vv/8ey5cvz/H49evX0bZtW+jp6UFXVxcNGjRAVFSU8vEVK1Yo/x4xMzPD4MGDAQAPHjyARCLBpUuXlGMTEhIgkUhw+PBhAMDhw4chkUg+6+/I9PR0/PTTT7C0tIRMJoOdnR2WL18OQRBgZ2eH2bNnZxt/6dIlSCQSREZGfvI1ISIiKqkS3iTgr9N/ocqiKmi0qhE2XtuITEUmalnUwop2K/Bk1BPMazmvSBfQAa5E/+Z+ae2II7fjEPMyDTP33sakdpXFjkRERETvEQQBrzPlopxbU00FEomkUI71888/Y/bs2bCxsYGBgQEePnyI1q1bY9q0aZDJZFizZg28vLxw+/ZtVKhQIc/jTJ48GTNnzsSsWbPw119/oXv37oiOjkbZsmULnOn8+fPo3LkzJk2aBD8/P5w8eRI//PADDA0NERAQgHPnzmHo0KFYu3Yt6tati5cvX+LYsWMA3q6+79q1K2bOnImOHTsiOTkZx44dgyAIn/0aUfEgCALSMtNEObeWmla+fidVVVXh7++PVatWYezYscp9QkJCIJfL0bVrV6SkpMDNzQ0//fQT9PT0sHv3bvTo0QO2traoVavWJ8+hUCjQqVMnmJiY4PTp00hMTMy1dZKuri5WrVoFc3NzXL16FX379oWuri7GjBkDPz8/XLt2DXv37lUWiPX19XMcIzU1FZ6enqhTpw7Onj2LuLg49OnTB4MHD872DwWHDh2CmZkZDh06hMjISPj5+aFatWro27dvns8jKioKERER2LZtGwRBwIgRIxAdHQ0rKysAwOPHj9GwYUM0btwYBw8ehJ6eHk6cOIGsrLcLkBYtWoSRI0fit99+Q6tWrZCYmIgTJ0588vX70Of8Henv74+IiAjMnz8frq6uuH//PuLj4yGRSNCrVy+sXLkSP/74o/IcK1euRMOGDWFnZ1fgfERERMXduSfnEHwuGBuvbVTO5bTUtNDdpTv6u/WHm7mbyAkLhkX0b0xXQw2/eVeF/4ozWHXyAVq7mKFWxYJ/CCUiIqKv43WmHM4TwkQ5940pntBSL5zp2ZQpU9C8eXPl/bJly8LV1VV5f+rUqdi+fTt27dqlXMWZm4CAAHTt2hUAMH36dMyfPx9nzpzJs//zx8ydOxfNmjXD+PHjAQAODg64ceMGZs2ahYCAAMTExEBbWxtt27aFrq4urKysUL16dQBvi+hZWVno1KmTstjm4uJS4AxU/KRlpkFnhs6nB34FKUEp0FbXztfYXr16YdasWThy5AgaN24M4G0R1dvbG/r6+tDX189WYB0yZAjCwsKwZcuWfBXR9+/fj1u3biEsLAzm5uYA3v5OftjHfNy4cco/W1tb48cff8SmTZswZswYaGpqQkdHB6qqqh9t37Jhwwa8efMGa9asgbb22+e/YMECeHl54ffff4eJiQkAwMDAAAsWLICKigocHR3Rpk0bHDhw4KNF9BUrVqBVq1YwMDAAAHh6emLlypXKazksXLgQ+vr62LRpE9TU1AC8/bvinV9//RWjRo3CsGHDlNtq1qz5ydfvQwX9O/LOnTvYsmULwsPD4eHhAQCwsbFRjg8ICMCECRNw5swZ1KpVC5mZmdiwYUOO1elEREQlWWpGKjZd24RF5xbhfOx55fbKxpUx0H0gvq/6PfQ1cv4DfnHAdi4iaOhgDD93SwDAmNDLeJ0hzmo3IiIiKrnc3d2z3U9JScGPP/4IJycnlClTBjo6Orh58yZiYmI+epz3+zhra2tDT08PcXFxn5Xp5s2bqFevXrZt9erVw927dyGXy9G8eXNYWVnBxsYGPXr0wPr165GW9nbViqurK5o1awYXFxf4+vpi6dKlePXq1WflIPoaHB0dUbduXaxYsQIAEBkZiWPHjqF3794AALlcjqlTp8LFxQVly5aFjo4OwsLCPvk7+M7NmzdhaWmpLKADQJ06dXKM27x5M+rVqwdTU1Po6Ohg3Lhx+T7H++dydXVVFtCBt7+rCoUi2/UXKleuDBUVFeV9MzOzj/79IJfLsXr1anz//ffKbd9//z1WrVoFhUIB4G0LlAYNGigL6O+Li4vDkydP0KxZswI9n9wU9O/IS5cuQUVFBY0aNcr1eObm5mjTpo3y5//PP/8gPT0dvr6+X5yViIioqLsedx1D9gyB+Vxz9PmnD87Hnoe6ijq6u3THscBjuDrwKgbVGlRsC+gAV6KLZmxbJxy9+xwPXqRh9r7bGN/WWexIREREhLctVW5M8RTt3IXl/eIXAPz4448IDw/H7NmzYWdnB01NTfj4+CAjI+Ojx/mwkCWRSJTFrsKmq6uLCxcu4PDhw9i3bx8mTJiASZMm4ezZsyhTpgzCw8Nx8uRJ7Nu3D3/99RfGjh2L06dPo2LFil8lDxUNWmpaSAlK+fTAr3TugujduzeGDBmChQsXYuXKlbC1tVUWXWfNmoU///wT8+bNg4uLC7S1tTF8+PBP/g4WREREBLp3747JkyfD09NTuaL7w2sPFJaC/v0QFhaGx48f57iQqFwux4EDB9C8eXNoamrmuf/HHgMAqfTtGrH32zzl1aO9oH9HfurcANCnTx/06NEDf/zxB1auXAk/Pz9oaRXsPURERFRcpGelY+vNrQg+F4xjMceU220NbNHfrT8CqwfCSMtIxISFi0V0kehpqGF6JxcErjyLFSfuo7WLKdys2NaFiIhIbBKJpNBaqhQlJ06cQEBAADp27Ajg7arLBw8efNMMTk5OOXoXnzhxAg4ODsrVrKqqqvDw8ICHhwcmTpyIMmXK4ODBg+jUqRMkEgnq1auHevXqYcKECbCyssL27dsxcuTIb/o86NuSSCT5bqkits6dO2PYsGHYsGED1qxZg4EDByr7o584cQLt27dXrsJWKBS4c+cOnJ3zt5jGyckJDx8+RGxsLMzMzAAAp06dyjbm5MmTsLKywtixY5XboqOjs41RV1eHXP7xb8I6OTlh1apVSE1NVRabT5w4AalUikqVKuUrb26WL1+OLl26ZMsHANOmTcPy5cvRvHlzVK1aFatXr0ZmZmaOIr2uri6sra1x4MABNGnSJMfxjY2NAbxt//SuFdT7Fxn9mE/9Heni4gKFQoEjR44o27l8qHXr1tDW1saiRYuwd+9eHD16NF/nJiIiKk6iXkZhyfklWHFpBeLT4gEAKhIVtHdsjwFuA9DMphmkkpLX/KTkfUIsRppUKgcft/IIPf8Io0OuYM+wBtAoxBVoRERERO/Y29tj27Zt8PLygkQiwfjx47/aivLnz5/nKFyZmZlh1KhRqFmzJqZOnQo/Pz9ERERgwYIF+PvvvwEA//77L+7du4eGDRvCwMAAe/bsgUKhQKVKlXD69GkcOHAALVq0QLly5XD69Gk8f/4cTk5OX+U5EH0OHR0d+Pn5ISgoCElJSQgICFA+Zm9vj9DQUJw8eRIGBgaYO3cunj17lu8iuoeHBxwcHNCzZ0/MmjULSUlJOYrR9vb2iImJwaZNm1CzZk3s3r0b27dvzzbG2toa9+/fx6VLl1C+fHno6upCJpNlG9O9e3dMnDgRPXv2xKRJk/D8+XMMGTIEPXr0UPZDL6jnz5/jn3/+wa5du1ClSpVsj/n7+6Njx454+fIlBg8ejL/++gtdunRBUFAQ9PX1cerUKdSqVQuVKlXCpEmTMGDAAJQrVw6tWrVCcnIyTpw4gSFDhkBTUxPfffcdfvvtN1SsWBFxcXHZesR/zKf+jrS2tkbPnj3Rq1cv5YVFo6OjERcXh86dOwMAVFRUEBAQgKCgINjb2+faboeIiKg4ylJk4d87/2LRuUXYF7VPud1C1wL93Pqhd/XesNCzEDHh11fy/lmgmBnfxhnldGW4F5+KueF3xI5DREREJdTcuXNhYGCAunXrwsvLC56enqhRo8ZXOdeGDRtQvXr1bLelS5eiRo0a2LJlCzZt2oQqVapgwoQJmDJlirLQWKZMGWzbtg1NmzaFk5MTgoODsXHjRlSuXBl6eno4evQoWrduDQcHB4wbNw5z5szJcVFFIrH17t0br169gqenZ7b+5ePGjUONGjXg6emJxo0bw9TUFB06dMj3caVSKbZv347Xr1+jVq1a6NOnD6ZNm5ZtTLt27TBixAgMHjwY1apVw8mTJ5UX8n3H29sbLVu2RJMmTWBsbIyNGzfmOJeWlhbCwsLw8uVL1KxZEz4+PmjWrBkWLFhQsBfjPe8uUppbP/NmzZpBU1MT69atg6GhIQ4ePIiUlBQ0atQIbm5uWLp0qXJVes+ePTFv3jz8/fffqFy5Mtq2bYu7d+8qj7VixQpkZWXBzc0Nw4cPx6+//pqvfPn5O3LRokXw8fHBDz/8AEdHR/Tt2xepqanZxvTu3RsZGRkIDAws6EtERERU5DxOeozJhyfDep41Om7uiH1R+yCBBC3tWmKH3w48GP4AExpNKPEFdACQCO83jCsFkpKSoK+vj8TEROjp6YkdBwCw/8Yz9FlzDlIJEDqwLmpUMBA7EhERUanw5s0b3L9/HxUrVoSGhobYcaiE+tj7rCjOTb+Fjz1v/l5ScXbs2DE0a9YMDx8+/Oiqfb7PiYioqFIICuy/tx+Lzi3CP7f/gVx42wbOWMsYvar3Qj+3frAxsBE5ZeHJ73yc7VyKAA9nE3SqboFtFx9jdMhl7B7Kti5ERERERETFRXp6Op4/f45JkybB19f3s9veEBERieV56nOsvLQSi88vxr1X95TbG1o1xAC3Aejk1AkyVdlHjlCysYheREzwcsaxyHhEPU/Fnwfu4qeWjmJHIiIiIiIionzYuHEjevfujWrVqmHNmjVixyEiIsoXQRBwPOY4gs8HI/RGKDLkGQAAfZk+/F39McB9AJyN83f9lpKORfQiooyWOqZ1qIJ+a89j8ZEotKxsClfLMmLHIiIiIiIiok8ICAjIdiFZIiKioizxTSLWXlmL4HPBuP78unJ7TfOaGOA+AH6V/aCtri1iwqJH9AuLLly4ENbW1tDQ0EDt2rVx5syZj46fN28eKlWqBE1NTVhaWmLEiBF48+bNN0r7dbWobIp2ruZQCMDo0MtIz5KLHYmIiIiIiIiIiIhKgPNPzqPvrr4wn2uOIf8NwfXn16GlpoU+1fvgXN9zONP3DHpV78UCei5EXYm+efNmjBw5EsHBwahduzbmzZsHT09P3L59G+XKlcsxfsOGDfj555+xYsUK1K1bF3fu3EFAQAAkEgnmzp0rwjMofJPaVcbJqHjceZaCvw5E4kfPSmJHIiIiIiIiIiIiomIoNSMVm65tQvD5YJx7ck65vbJxZQxwH4AeVXtAX0NfxITFg6hF9Llz56Jv374IDAwEAAQHB2P37t1YsWIFfv755xzjT548iXr16qFbt24AAGtra3Tt2hWnT5/+prm/prLa6pjavgoGrr+ARUei4FnZFC7l+UYmIiIiotJFEASxIxB9NXx/ExHR13bj+Q0EnwvGmstrkJieCABQV1GHj7MPBroPRD3LepBIJCKnLD5EK6JnZGTg/PnzCAoKUm6TSqXw8PBARERErvvUrVsX69atw5kzZ1CrVi3cu3cPe/bsQY8ePfI8T3p6OtLT05X3k5KSCu9JfCWtXMzQpqoZdl+JxejQy9g1uD7UVUXvvENERERE9NWpqalBIpHg+fPnMDY25oc7KnEEQcDz588hkUigpqYmdhwiIipB0rPSse3mNgSfD8bR6KPK7TYGNhjgNgAB1QJgrG0sYsLiS7Qienx8PORyOUxMTLJtNzExwa1bt3Ldp1u3boiPj0f9+vUhCAKysrIwYMAA/PLLL3meZ8aMGZg8eXKhZv8WprSrjIioF7j1NBkLDkViZHMHsSMREREREX11KioqKF++PB49eoQHDx6IHYfoq5BIJChfvjxUVFTEjkJERCXAvVf3sOT8Eqy4uALP054DAFQkKvCq5IWB7gPhYeMBqYQLdL+EqO1cCurw4cOYPn06/v77b9SuXRuRkZEYNmwYpk6divHjx+e6T1BQEEaOHKm8n5SUBEtLy28V+bMZ6sgwpX1lDN5wEX8fioRnZRNUNmdbFyIiIiIq+XR0dGBvb4/MzEyxoxB9FWpqaiygExHRF8lSZGH3nd0IPh+MsMgwCHjbKsxC1wJ9a/RF7xq9UV6vvMgpSw7RiuhGRkZQUVHBs2fPsm1/9uwZTE1Nc91n/Pjx6NGjB/r06QMAcHFxQWpqKvr164exY8dCKs35LyoymQwymazwn8A30MbFDLurxOK/a08xOuQKdg6uBzUV/qsRERERFY7GjRujWrVqmDdvHoC315sZPnw4hg8fnuc+EokE27dvR4cOHb7o3IV1HCq5VFRUWGQkIiIi+sDjpMdYfnE5ll5YikdJj5TbPW09McB9ANo6tIWqtFitmy4WRKvIqqurw83NDQcOHFBuUygUOHDgAOrUqZPrPmlpaTkK5e8m1iXxwiwSiQRT2leBgZYabsQmYdHhKLEjERERURHg5eWFli1b5vrYsWPHIJFIcOXKlQIf9+zZs+jXr9+Xxstm0qRJqFatWo7tsbGxaNWqVaGe60OrVq1CmTJlvuo5iIiIiIi+NoWgwL6ofei0uROs5llh4uGJeJT0CEZaRhhTdwwih0Ri7/d70cGxAwvoX4mor+rIkSPRs2dPuLu7o1atWpg3bx5SU1MRGBgIAPD394eFhQVmzJgB4O0Hxrlz56J69erKdi7jx4+Hl5dXiV2lYqwrw6R2lTFs0yX8dfAumjubwMlMT+xYREREJKLevXvD29sbjx49Qvny2b+iuXLlSri7u6Nq1aoFPq6x8be7yFBe3zwkIiIiIqK34tPisfLiSiw+vxhRr/5/cW2DCg0w0H0gOjl1gky1eHbgKG5E7Q3i5+eH2bNnY8KECahWrRouXbqEvXv3Ki82GhMTg9jYWOX4cePGYdSoURg3bhycnZ3Ru3dveHp6YvHixWI9hW+inas5mjubIFMuYHToZWTKFWJHIiIiIhG1bdsWxsbGWLVqVbbtKSkpCAkJQe/evfHixQt07doVFhYW0NLSgouLCzZu3PjR41pbWytbuwDA3bt30bBhQ2hoaMDZ2Rnh4eE59vnpp5/g4OAALS0t2NjYYPz48co+1qtWrcLkyZNx+fJlSCQSSCQSZWaJRIIdO3Yoj3P16lU0bdoUmpqaMDQ0RL9+/ZCSkqJ8PCAgAB06dMDs2bNhZmYGQ0NDDBo06It6ZsfExKB9+/bQ0dGBnp4eOnfunK3V4OXLl9GkSRPo6upCT08Pbm5uOHfuHAAgOjoaXl5eMDAwgLa2NipXrow9e/Z8dhYiIiIiIuBtt43jMcfx/bbvYTHXAmP2j0HUqyjoyfQwpNYQXBt4DUcDj6KrS1cW0L8h0df3Dx48GIMHD871scOHD2e7r6qqiokTJ2LixInfIFnRIZFIMK1DFZy5/xLXHidhydF7GNTETuxYREREJZMgAJlp4pxbTQuQSD45TFVVFf7+/li1ahXGjh0Lyf/2CQkJgVwuR9euXZGSkgI3Nzf89NNP0NPTw+7du9GjRw/Y2tqiVq1anzyHQqFAp06dYGJigtOnTyMxMTHXXum6urpYtWoVzM3NcfXqVfTt2xe6uroYM2YM/Pz8cO3aNezduxf79+8HAOjr57xQempqKjw9PVGnTh2cPXsWcXFx6NOnDwYPHpztHwoOHToEMzMzHDp0CJGRkfDz80O1atXQt2/fTz6f3J7fuwL6kSNHkJWVhUGDBsHPz085B+3evTuqV6+ORYsWQUVFBZcuXYKamhoAYNCgQcjIyMDRo0ehra2NGzduQEdHp8A5iIiIiIgAIPFNItZdWYfg88G4FndNud3NzA0D3QeiS5Uu0FbXFjFh6SZ6EZ3yp5yeBia1c8aIzZfx5/63bV0cTHTFjkVERFTyZKYB083FOfcvT4B8Tox79eqFWbNm4ciRI2jcuDGAt61cvL29oa+vD319ffz444/K8UOGDEFYWBi2bNmSryL6/v37cevWLYSFhcHc/O3rMX369Bx9zMeNG6f8s7W1NX788Uds2rQJY8aMgaamJnR0dKCqqvrR9i0bNmzAmzdvsGbNGmhrv33+CxYsgJeXF37//XfltxQNDAywYMECqKiowNHREW3atMGBAwc+q4h+4MABXL16Fffv34elpSUAYM2aNahcuTLOnj2LmjVrIiYmBqNHj4ajoyMAwN7eXrl/TEwMvL294eLiAgCwsbEpcAYiIiIioguxFxB8Lhgbrm5AamYqAEBTVRPdXLphgPsAuJu7i5yQAJHbuVDBdKhmgWaO5ZAhV2B0yGVksa0LERFRqeXo6Ii6detixYoVAIDIyEgcO3YMvXv3BgDI5XJMnToVLi4uKFu2LHR0dBAWFoaYmJh8Hf/mzZuwtLRUFtAB5Hrx982bN6NevXowNTWFjo4Oxo0bl+9zvH8uV1dXZQEdAOrVqweFQoHbt28rt1WuXDnbdXDMzMwQFxdXoHO9f05LS0tlAR0AnJ2dUaZMGdy8eRPA2+v39OnTBx4eHvjtt98QFfX/fSiHDh2KX3/9FfXq1cPEiRM/60KuRERERFQ6pWWmYeXFlai1tBbclrhh6YWlSM1MhbOxM+a3nI8no55gWbtlLKAXIVyJXoxIJBJM7+SC5nOP4PKjRCw9dh8DG9uKHYuIiKhkUdN6uyJcrHMXQO/evTFkyBAsXLgQK1euhK2tLRo1agQAmDVrFv7880/MmzcPLi4u0NbWxvDhw5GRkVFocSMiItC9e3dMnjwZnp6e0NfXx6ZNmzBnzpxCO8f73rVSeUcikUCh+HqLCiZNmoRu3bph9+7d+O+//zBx4kRs2rQJHTt2RJ8+feDp6Yndu3dj3759mDFjBubMmYMhQ4Z8tTxEREREVLzdfH4TweeCsfryaiSmJwIA1KRq8HH2wUD3gahfob6yVSMVLVyJXsyY6GlgfFtnAMAf++8gMi5Z5EREREQljETytqWKGLcCTpg7d+4MqVSKDRs2YM2aNejVq5dy0n3ixAm0b98e33//PVxdXWFjY4M7d+7k+9hOTk54+PBhtou8nzp1KtuYkydPwsrKCmPHjoW7uzvs7e0RHR2dbYy6ujrkcvknz3X58mWkpqYqt504cQJSqRSVKlXKd+aCePf8Hj58qNx248YNJCQkwNnZWbnNwcEBI0aMwL59+9CpUyesXLlS+ZilpSUGDBiAbdu2YdSoUVi6dOlXyUpERERExVd6Vjo2XduExqsaw/lvZ8w/Mx+J6YmwMbDB7x6/49HIR9jgvQENrBqwgF6EsYheDPm4lUfjSsbIyFLgx5ArkCsEsSMRERGRCHR0dODn54egoCDExsYiICBA+Zi9vT3Cw8Nx8uRJ3Lx5E/3798ezZ8/yfWwPDw84ODigZ8+euHz5Mo4dO4axY8dmG2Nvb4+YmBhs2rQJUVFRmD9/PrZv355tjLW1Ne7fv49Lly4hPj4e6enpOc7VvXt3aGhooGfPnrh27RoOHTqEIUOGoEePHsp+6J9LLpfj0qVL2W43b96Eh4cHXFxc0L17d1y4cAFnzpyBv78/GjVqBHd3d7x+/RqDBw/G4cOHER0djRMnTuDs2bNwcnICAAwfPhxhYWG4f/8+Lly4gEOHDikfK+6Sk5MxfPhwWFlZQVNTE3Xr1sXZs2eVjwcEBEAikWS7tWzZUsTEREREREXP/Vf3EbQ/CJZ/WKLr1q44En0EUokUHRw7YG/3vbg75C7G1BuDctrlxI5K+cAiejEkkUgwo5MLdGWquPQwAcuP3xM7EhEREYmkd+/eePXqFTw9PbP1Lx83bhxq1KgBT09PNG7cGKampujQoUO+jyuVSrF9+3a8fv0atWrVQp8+fTBt2rRsY9q1a4cRI0Zg8ODBqFatGk6ePInx48dnG+Pt7Y2WLVuiSZMmMDY2xsaNG3OcS0tLC2FhYXj58iVq1qwJHx8fNGvWDAsWLCjYi5GLlJQUVK9ePdvNy8sLEokEO3fuhIGBARo2bAgPDw/Y2Nhg8+bNAAAVFRW8ePEC/v7+cHBwQOfOndGqVStMnjwZwNvi/KBBg+Dk5ISWLVvCwcEBf//99xfnLQr69OmD8PBwrF27FlevXkWLFi3g4eGBx48fK8e0bNkSsbGxyltuP1ciIiKi0iZLkYVdt3eh9frWsJ1vi99O/Ibnac9hrmuOiY0mInp4NLb7bYennSekEpZlixOJIAilahlzUlIS9PX1kZiYCD09PbHjfJHNZ2Pw09arkKlKsWdYA9ga64gdiYiIqFh58+YN7t+/j4oVK0JDQ0PsOFRCfex9VtTmpq9fv4auri527tyJNm3aKLe7ubmhVatW+PXXXxEQEICEhATs2LHjs89T1J43ERER0Zd4kvwEyy8sx5ILS/Ao6ZFyewvbFhjgNgBelbygKuWlKYui/M5L+dMrxjq7W+LfK7E4djceY0KvYEv/OlCRsncSEREREX2erKwsyOXyHMV+TU1NHD9+XHn/8OHDKFeuHAwMDNC0aVP8+uuvMDQ0zPO46enp2Vr5JCUlFX54IiIiom9IIShw8P5BLDq3CDtv7YRceHsdIENNQ/Sq3gv93PrBrqydyCmpsLCIXoxJJBL85l0Vnn8cxfnoV1h18gF6168odiwiIiIiKqZ0dXVRp04dTJ06FU5OTjAxMcHGjRsREREBO7u3HwJbtmyJTp06oWLFioiKisIvv/yCVq1aISIiAioqKrked8aMGcpWOERERETF2Yu0F1h5aSUWn1+MyJeRyu31K9THQPeB8HbyhkxVJmJC+hrYzqUE2HA6Br9svwoNNSn2DmsIayNtsSMREREVC2znQt9CcWrnAgBRUVHo1asXjh49ChUVFdSoUQMODg44f/48bt68mWP8vXv3YGtri/3796NZs2a5HjO3leiWlpZF6nkTERER5UUQBJx8eBLB54MRcj0E6fK38xo9mR78q/qjv3t/VClXReSU9DnYzqUU6VrLEruvPsGJyBcYE3oFm/p9BynbuhARERHRZ7C1tcWRI0eQmpqKpKQkmJmZwc/PDzY2NrmOt7GxgZGRESIjI/MsostkMshkXJFFRERExUtSehLWXVmH4HPBuBp3Vbm9hlkNDHQfiC5VukBHndcoLA1YRC8BJBIJfutUFZ7zjuLMg5dYE/EAAfXY1oWIiIiIPp+2tja0tbXx6tUrhIWFYebMmbmOe/ToEV68eAEzM7NvnJCIiIjo67gYexGLzi3ChqsbkJqZCgDQVNVE1ypdMcB9AGpa1BQ5IX1rLKKXEJZltRDU2gnjd1zD73tvo4ljOVgZsq0LERFRfigUCrEjUAlW3N5fYWFhEAQBlSpVQmRkJEaPHg1HR0cEBgYiJSUFkydPhre3N0xNTREVFYUxY8bAzs4Onp6eYkcnIiIi+mxpmWnYcn0LFp1bhDOPzyi3Oxk5YYD7APi7+qOMRhnxApKoWEQvQbrXqoDdV57g1L2X+GnrFWzow7YuREREH6Ourg6pVIonT57A2NgY6urqkEj4/04qHIIgICMjA8+fP4dUKoW6urrYkfIlMTERQUFBePToEcqWLQtvb29MmzYNampqyMrKwpUrV7B69WokJCTA3NwcLVq0wNSpU9muhYiIiIqlW/G3EHwuGKsvr0bCmwQAgJpUDT7OPhjgPgANKjTgZwTihUVLmpgXafCcdxSvM+WY2r4yetSxFjsSERFRkZaRkYHY2FikpaWJHYVKKC0tLZiZmeVaRC/pc9O8lNbnTUREREVDhjwD229uR/D5YBx+cFi5vWKZiujv1h+B1QNRTruceAHpm+GFRUupCoZa+KllJUz65wZm/HcLjSuVg2VZLbFjERERFVnq6uqoUKECsrKyIJfLxY5DJYyKigpUVVW5eomIiIioCHiQ8ABLzi/B8ovLEZcaBwCQSqTwcvDCAPcBaGHbAlKJVOSUVBSxiF4C+dexxp6rT3HmwUv8vO0K1vWuzQ9uREREHyGRSKCmpgY1NTWxoxARERERUSGSK+TYc3cPgs8H47+7/0HA26YcZjpm6FujL/rU6ANLfUuRU1JRxyJ6CSSVSjDTpypa/nkUJyJfYOOZh+hWu4LYsYiIiIiIiIiIiL6J2ORYLLuwDEsvLMXDpIfK7c1tmmOA+wB4OXhBTYWLaCh/WEQvoayNtDHa0xFT/72BabtvoKGDEcobsK0LERERERERERGVTApBgYP3DyL4XDB23t6JLEUWAMBQ0xCB1QLR370/7MraiZySiiMW0UuwgLrW+O9qLM5Fv0LQtqtY06sW27oQEREREREREVGJ8iLtBVZdWoXF5xfj7su7yu31K9THALcB8Hb2hoaqhogJqbhjEb0EU/lfW5dWfx7Dsbvx2HLuIfxqsq0LEREREREREREVb4IgIOJRBILPBWPL9S1Il6cDAHTVdeHv6o/+bv3hYuIickoqKVhEL+FsjHXwY4tKmLbnJn799yYaOhjDTF9T7FhEREREREREREQFlpSehPVX1iP4fDCuPLui3F7dtDoGug9EV5eu0FHXETEhlUQsopcCvepXxJ5rsbgYk4CgbVexMqAm27oQEREREREREVGxcenpJQSfC8b6q+uRkpECANBU1USXKl0w0H0g3M3dWe+ir4ZF9FJARSrBLJ+qaD3/OA7ffo7Q84/g624pdiwiIiIiIiIiIqI8vc58jc3XNyP4XDBOPz6t3O5o5IgBbgPg7+oPA00DERNSacEieilhV04XIzwc8PveW5jy7w00sDeGqT4vqEBEREREREREREXLrfhbWHxuMVZdXoWENwkAADWpGjo5dcJA94FoaNWQq87pm2IRvRTp26Ai9l6LxeVHifhl+1Us78mvuRARERERERERkfgy5BnYcWsHgs8F49CDQ8rt1mWs0d+tPwKrBcJEx0TEhFSasYheiqiqSDHL1xVt5x/HwVtx2H7xMTrVKC92LCIiIiIiIiIiKqUeJDzA0vNLsfzicjxLfQYAkEqkaOvQFgPcBqCFbQuoSFVETkmlHYvopYyDiS6GedhjVthtTP7nBurbGaGcHtu6EBERERERERHRtyFXyPFf5H8IPheMPXf3QIAAADDTMUOfGn3Qt0ZfWOrzen5UdEjFDgAACxcuhLW1NTQ0NFC7dm2cOXMmz7GNGzeGRCLJcWvTps03TFy89W9oAxcLfSS+zsTYHdcgCILYkYiIiIiIiIiIqIR7mvIU045Og818G3ht9MLuu7shQICHjQe2dt6K6OHRmNJkCgvoVOSIvhJ98+bNGDlyJIKDg1G7dm3MmzcPnp6euH37NsqVK5dj/LZt25CRkaG8/+LFC7i6usLX1/dbxi7W3rZ1qQqvv44j/MYz7Lr8BO2rWYgdi4iIiIiIiIiIShhBEHDw/kEEnw/Gjls7kKXIAgCU1SyLwGqB6O/WH/aG9iKnJPo40Yvoc+fORd++fREYGAgACA4Oxu7du7FixQr8/PPPOcaXLVs22/1NmzZBS0uLRfQCcjTVw5Cm9pgbfgcTd11HXVsjGOvKxI5FREREREREREQlwIu0F1h9eTUWn1+MOy/uKLfXtayLge4D4ePsAw1Vthim4kHUInpGRgbOnz+PoKAg5TapVAoPDw9ERETk6xjLly9Hly5doK2tnevj6enpSE9PV95PSkr6stAlyMDGtth77SluxCZh/I5rWPR9DUgkErFjERERERERERFRMSQIAk49OoXg88HYfG0z0uVva3K66rroUbUH+rv3R1WTqiKnJCo4UYvo8fHxkMvlMDExybbdxMQEt27d+uT+Z86cwbVr17B8+fI8x8yYMQOTJ0/+4qwlkdr/2rq0X3ACe68/xe6rsWhb1VzsWEREREREREREVIwkpydj/dX1CD4XjMvPLiu3VzOthoHuA9G1SlfoynRFTEj0ZURv5/Illi9fDhcXF9SqVSvPMUFBQRg5cqTyflJSEiwteXGCdyqb62NQEzv8eeAuJuy8jjo2hjDUYVsXIiIiIiIiIiL6uMtPL2PRuUVYf3U9UjJSAAAaqhroUqULBroPRE3zmux6QCWCqEV0IyMjqKio4NmzZ9m2P3v2DKamph/dNzU1FZs2bcKUKVM+Ok4mk0EmY1H4YwY1sUPY9ae49TQZE3Zdx8JuNcSORERERERERERERdDrzNcIuRGCRecW4dSjU8rtjkaOGOA2AP6u/jDQNBAxIVHhk4p5cnV1dbi5ueHAgQPKbQqFAgcOHECdOnU+um9ISAjS09Px/ffff+2YJZ66qhSzfV2hIpVg95VY/Hc1VuxIRERERERERERUhNx5cQcjw0bCYq4Feu7oiVOPTkFNqga/yn441PMQbvxwA8O+G8YCOpVIordzGTlyJHr27Al3d3fUqlUL8+bNQ2pqKgIDAwEA/v7+sLCwwIwZM7Ltt3z5cnTo0AGGhoZixC5xqljoY2AjWyw4FInxO6+hto0hymqrix2LiIiIiIiIiIhEIFfIkS5Px+47uxF8PhgH7x9UPmalb4X+bv3Rq3ovmOiYfOQoRCWD6EV0Pz8/PH/+HBMmTMDTp09RrVo17N27V3mx0ZiYGEil2RfM3759G8ePH8e+ffvEiFxiDWlmh303nuLOsxRM2nUd87tWFzsSEREREREREVGxIwgCMhWZyJBnIFOeiUxFJjLl/7v/vz9/+HhBxn74uPLPX7LvB2MFCNmek1QiRRv7NhjgPgCetp5QkaqI9OoSfXsSQRCETw8rOZKSkqCvr4/ExETo6emJHafIufIoAR3/Pgm5QsDiHm7wrPzx3vRERERE9PlK69y0tD5vIiLKH0EQIBfkhVNU/owC9RfvK8+EXJCL/TIWGlMdU/Sp3gd93fqign4FseMQFar8zktFX4lORUvV8mXQr6ENFh2Owtjt11C7YlmU0WJbFyIiIiIiIqLiQiEoRCtAF9bq6pJIVaoKdRV1qEnVoKaiBjWp2tv7//uzmopatsc/OvaD+x87zhedR0UNOuo6kEpEvawikehYRKcchjWzR/iNZ4iMS8Hkf27gD79qYkciIiIiIiIiKnEEQUBqZioS3yQiMT0RSelJyj8nvvnf/f/9Wfn4e4+9znqdawFaISjEfmqFTiqRFqgw/NEi85fs+5kFalWpKiQSidgvIxF9JhbRKQcNNRXM8qkK70Unsf3iY7RxMYOHMy8SQURERERERPROliILyenJOYvcuRXBP1IU/1YF7y9djax8/Cuves7rca6EJiIxsYhOuapewQB9G9hg8dF7+GX7VdS0Lgt9LTWxYxERERERERF9sTdZb3IUvAtaBE/NTC20PCoSFehr6ENPpgd9mT70NfShL8vj/nt/1lTTzFeBWkWiwlXQRERfgEV0ytOI5g4Iv/EM9+JTMXX3Dcz2dRU7EhEREREREZVigiAgJSOlwK1PPhyfIc8otEwaqho5Ctz5KYK/XzTXUtNikZuIqAhjEZ3ypKGmglm+VeETHIHQ84/QpqoZmlQqJ3YsIiIiIiIiKoayFFnZCtmfUwQv7PYnuuq6uRe4P1Lw/nC8uop6oeUhIqKiiUV0+ig3q7LoXa8ilh2/j6CtV7FvZEPoabCtCxERERERUWkhCALS5ekfLXjnp/93WmZaoWV61/7kowXu9+7nNkZHXQcqUpVCy0RERCUXi+j0SaNaVML+m8/w4EUapv17E7/7VBU7EhEREREREeWDQlAgJSPli1qfJL5JRKYis9Ayaapq5r3K+xOrvt9t01TVZPsTIiL6ZlhEp0/SVFfBTB9X+C2JwOZzD9G6qhkaORiLHYuIiIiIiKhEy1JkfVHrk3fjBAiFlklPplegi19+WBDXk+mx/QkRERU7LKJTvtSqWBY961hj1ckHCNp6BWEjGkKXbV2IiIiIiIhyEAQBb7Le5K/1yUeK4IXZ/kRVqvrFF7/UlelCKpEWWiYiIqLigkV0yrcxLSvh4K04xLxMw/Q9tzCjk4vYkYiIiIiIiIqU4zHH0SW0Cx4nPy60Y2qqan7xxS/Z/oSIiOjzsYhO+aalrorfvaui69JT2HgmBm1czFDf3kjsWEREREREREXC05Sn8A3xxdOUpwAACSTQlenm++KXea0SV1Pht4CJiIjExCI6FUgdW0P417HCmoho/PS/ti46Mr6NiIiIiIiodMtSZKHr1q54mvIUlY0r41DPQzDUMmT7EyIiohKA/zenAvuppSPKG2jiccJr/P7fLbHjEBERERERiW7ioYk4/OAwdNR1ENo5FMbaxiygExERlRD8PzoVmLZMFTO9qwIA1p6KxsmoeJETERERERERiWf3nd2Yfnw6AGCp11I4GjmKnIiIiIgKE4vo9Fnq2hmhe+0KAICftl5BanqWyImIiIiIiIi+veiEaPTY3gMAMKjmIHSp0kXkRERERFTYWESnzxbU2gkWZTTx8OVrzAq7LXYcIiIiIiKibyo9Kx2+Ib549eYVaprXxJwWc8SORERERF8Bi+j02XRkqvjN2wUAsOrkA5y+90LkRERERERERN/Oj/t+xNknZ2GgYYAQ3xDIVGViRyIiIqKvgEV0+iIN7I3RpaYlAGDM1it4nSEXOREREREREdHXt/naZiw4uwAAsLbjWliVsRI5EREREX0tLKLTF/uljRPM9DUQ/SKNbV2IiIiIiKjEuxV/C33+6QMACKofhDYObURORERERF8Ti+j0xfQ01DCj09u2LitP3se5By9FTkRERERERPR1pGakwmeLD1IyUtDYujGmNJkidiQiIiL6ylhEp0LRuFI5+LqVhyAAo0Ov4E0m27oQEREREVHJIggCBu4eiOvPr8NUxxQbvTdCVaoqdiwiIiL6ylhEp0Izrq0zTPRkuB+fijn72NaFiIiIiIhKlmUXlmHtlbWQSqTY5L0JpjqmYkciIiKib4BFdCo0+pr/39Zl+fH7OB/9SuREREREREREheNC7AUM+W8IAGB60+loZN1I5ERERET0rbCIToWqqaMJOtWwgEIAxoReZlsXIiIiIiIq9hLeJMA3xBfp8nS0dWiL0fVGix2JiIiIviEW0anQTWjrDGNdGaKep2Le/rtixyEiIiIiIvpsgiAgcGcg7r26B+sy1ljdYTWkEn6UJiIiKk34f34qdGW01DG949u2LkuORuHSwwRxAxEREREREX2muRFzsePWDqirqCPENwRlNcuKHYmIiIi+MRbR6ato7myCDtXMoRCA0SGXkZ7Fti5ERERERFS8HI85jp/2/wQAmOc5D+7m7iInIiIiIjGIXkRfuHAhrK2toaGhgdq1a+PMmTMfHZ+QkIBBgwbBzMwMMpkMDg4O2LNnzzdKSwUx0asyjHRkuBuXgvkH2NaFiIiIqDhITk7G8OHDYWVlBU1NTdStWxdnz57NdeyAAQMgkUgwb968bxuS6BuIS42DX6gf5IIcXat0xQD3AWJHIiIiIpGIWkTfvHkzRo4ciYkTJ+LChQtwdXWFp6cn4uLich2fkZGB5s2b48GDBwgNDcXt27exdOlSWFhYfOPklB8G2ur4tUMVAEDwkXu4+ihR5ERERERE9Cl9+vRBeHg41q5di6tXr6JFixbw8PDA48ePs43bvn07Tp06BXNzc5GSEn09coUc3bZ2w5PkJ3AycsISryWQSCRixyIiIiKRSARBEMQ6ee3atVGzZk0sWLAAAKBQKGBpaYkhQ4bg559/zjE+ODgYs2bNwq1bt6CmpvZZ50xKSoK+vj4SExOhp6f3RfkpfwZvuIB/r8Sikoku/hlSH+qqon8BgoiIiKhIKIy5qUKhwJEjR3Ds2DFER0cjLS0NxsbGqF69Ojw8PGBpaZnvY71+/Rq6urrYuXMn2rRpo9zu5uaGVq1a4ddffwUAPH78GLVr10ZYWBjatGmD4cOHY/jw4fk+D+fkVNRNODQBU49OhZaaFs72PQtnY2exIxEREdFXkN95qWjVzIyMDJw/fx4eHh7/H0YqhYeHByIiInLdZ9euXahTpw4GDRoEExMTVKlSBdOnT4dczn7bRdnkdpVhqK2O28+SseAg27oQERERFYbXr1/j119/haWlJVq3bo3//vsPCQkJUFFRQWRkJCZOnIiKFSuidevWOHXqVL6OmZWVBblcDg0NjWzbNTU1cfz4cQBvi/Y9evTA6NGjUbly5UJ/XkRi2xu5F78effsPRkvaLmEBnYiIiKAq1onj4+Mhl8thYmKSbbuJiQlu3bqV6z737t3DwYMH0b17d+zZsweRkZH44YcfkJmZiYkTJ+a6T3p6OtLT05X3k5KSCu9JUL4Y6sgwpX0VDNpwAX8fjkKLyqaoYqEvdiwiIiKiYs3BwQF16tTB0qVL0bx581y/qRkdHY0NGzagS5cuGDt2LPr27fvRY+rq6qJOnTqYOnUqnJycYGJigo0bNyIiIgJ2dnYAgN9//x2qqqoYOnRovrNyTk7FxcPEh/h+2/cQIGCA2wB0r9pd7EhERERUBBSrvhoKhQLlypXDkiVL4ObmBj8/P4wdOxbBwcF57jNjxgzo6+srbwX5OisVnjZVzdDaxRRZCgGjQ68gI0shdiQiIiKiYm3fvn3YsmULWrdunWerQysrKwQFBeHu3bto2rRpvo67du1aCIIACwsLyGQyzJ8/H127doVUKsX58+fx559/YtWqVQXqD805ORUHGfIMdA7tjBevX6CGWQ380fIPsSMRERFRESFaEd3IyAgqKip49uxZtu3Pnj2DqalprvuYmZnBwcEBKioqym1OTk54+vQpMjIyct0nKCgIiYmJytvDhw8L70lQgUxpXwUGWmq4GZuERYejxI5DREREVKw5OTnle6yamhpsbW3zNdbW1hZHjhxBSkoKHj58iDNnziAzMxM2NjY4duwY4uLiUKFCBaiqqkJVVRXR0dEYNWoUrK2t8zwm5+RUHIwJH4NTj06hjEYZhPqGQkNV49M7ERERUakgWhFdXV0dbm5uOHDggHKbQqHAgQMHUKdOnVz3qVevHiIjI6FQ/P8q5jt37sDMzAzq6uq57iOTyaCnp5ftRuIw0pFhcvsqAIC/Dt7FjSf8Gi8RERFRYcrKysLChQvh6+uLTp06Yc6cOXjz5s1nHUtbWxtmZmZ49eoVwsLC0L59e/To0QNXrlzBpUuXlDdzc3OMHj0aYWFheR6Lc3Iq6kJvhOLP038CAFZ3WI2KBhVFTkRERERFiWg90QFg5MiR6NmzJ9zd3VGrVi3MmzcPqampCAwMBAD4+/vDwsICM2bMAAAMHDgQCxYswLBhwzBkyBDcvXsX06dPL1A/RhKXV1Uz7L7yBGHXn2F06GXsGFQPairFqqsQERERUZE1dOhQ3LlzB506dUJmZibWrFmDc+fOYePGjfk+RlhYGARBQKVKlRAZGYnRo0fD0dERgYGBUFNTg6GhYbbxampqMDU1RaVKlQr76RB9E3de3EGvnb0AAGPqjkG7Su1ETkRERERFjahFdD8/Pzx//hwTJkzA06dPUa1aNezdu1d5sdGYmBhIpf9fYLW0tERYWBhGjBiBqlWrwsLCAsOGDcNPP/0k1lOgApJIJJjaoQpO33+J60+SsPhIFAY3tRc7FhEREVGxtH37dnTs2FF5f9++fbh9+7ay/aGnpye+++67Ah0zMTERQUFBePToEcqWLQtvb29MmzYtz77rRMVZWmYafEN8kZyRjAYVGmBas2liRyIiIqIiSCIIgiB2iG8pKSkJ+vr6SExM5NdIRbTj4mMM33wJaioS/DukASqZ6oodiYiIiOib+9K5qZeXF1RUVPD333/D3NwcnTt3hr6+Pry9vZGZmYmlS5fi9evXCA8P/wrpPx/n5FRU9NrZCysvrUQ57XK42P8izHXNxY5ERERE31B+56Xso0GiaF/NHB5OJsiUCxgdehlZcsWndyIiIiKibP755x907doVjRs3xl9//YUlS5ZAT08PY8eOxfjx42FpaYkNGzaIHZOoSFpxcQVWXloJqUSKjd4bWUAnIiKiPLGITqKQSCSY3rEK9DRUceVRIpYcuyd2JCIiIqJiyc/PD2fOnMHVq1fh6emJ77//HufPn8elS5ewcOFCGBsbix2RqMi5/PQyBu0ZBACY0ngKmlZsKnIiIiIiKspYRCfRlNPTwESvygCAeeF3cfdZssiJiIiIiIqnMmXKYMmSJZg1axb8/f0xevRovHnzRuxYREVS4ptE+IT44E3WG7Sya4WgBkFiRyIiIqIijkV0ElWnGhZoUskYGXIFfgy9wrYuRERERAUQExODzp07w8XFBd27d4e9vT3Onz8PLS0tuLq64r///hM7IlGRIggCeu/qjciXkaigXwFrO66FVMKPxURERPRxnC2QqCQSCWZ0qgpdDVVcfpiA5cfvix2JiIiIqNjw9/eHVCrFrFmzUK5cOfTv3x/q6uqYPHkyduzYgRkzZqBz585ixyQqMv48/Se23twKNakatvhsgaGWodiRiIiIqBhQFTsAkam+Bsa3ccaYrVcwJ/wOmjmZwK6cjtixiIiIiIq8c+fO4fLly7C1tYWnpycqVqyofMzJyQlHjx7FkiVLRExIVHREPIzA6PDRAIA5LeagdvnaIiciIiKi4oIr0alI8HUvj4YOxsjIUmBM6GXIFYLYkYiIiIiKPDc3N0yYMAH79u3DTz/9BBcXlxxj+vXrJ0IyoqIlPi0enUM7I0uRhc6VO2NwrcFiRyIiIqJihEV0KhIkEgl+6+QCHZkqLsQkYOUJtnUhIiIi+pQ1a9YgPT0dI0aMwOPHj7F48WKxIxEVOXKFHN23dcejpEdwMHTAMq9lkEgkYsciIiKiYoTtXKjIMC+jibFtnBC07Spmhd1GMycTVDTSFjsWERERUZFlZWWF0NBQsWMQFWnTjk3Dvqh90FTVRKhvKHRlumJHIiIiomKGK9GpSOlS0xL17YyQ/r+2Lgq2dSEiIiLKVWpq6lcdT1QS7L+3H5MOTwIALGqzCC4mOVseEREREX0Ki+hUpEgkEvzm7QJtdRWcffAKqyMeiB2JiIiIqEiys7PDb7/9htjY2DzHCIKA8PBwtGrVCvPnz/+G6YjE9yjpEbpu7QoBAvpU74Oe1XqKHYmIiIiKKbZzoSKnvIEWglo7YdyOa/h97y00dSwHK0O2dSEiIiJ63+HDh/HLL79g0qRJcHV1hbu7O8zNzaGhoYFXr17hxo0biIiIgKqqKoKCgtC/f3+xIxN9M5nyTPiF+iE+LR7VTKthfiv+IxIRERF9PhbRqUjqVqsCdl+JRcS9FxgTegUb+34HqZQX/yEiIiJ6p1KlSti6dStiYmIQEhKCY8eO4eTJk3j9+jWMjIxQvXp1LF26FK1atYKKiorYcYm+qaADQTj58CT0ZHoI9Q2Fppqm2JGIiIioGJMIglCqmk4nJSVBX18fiYmJ0NPTEzsOfcTDl2nwnHcUaRlyTGlfGf51rMWORERERFSoSuvctLQ+b/o2tt/cjk5bOgEAtnXeho5OHUVOREREREVVfuel7IlORZZlWS383MoRAPDbf7fw8GWayImIiIiIiKgoi3oZhYCdAQCAkd+NZAGdiIiICgWL6FSkfV/bCrUrlkVahhw/bb2CUvbFCSIiIiIiyqfXma/hE+KDpPQk1LWsi988fhM7EhEREZUQLKJTkSaVSjDTpyo01KQ4GfUCG87EiB2JiIiIiIiKoGF7h+HS00sw0jLCZp/NUFNREzsSERERlRAsolORZ2WojTGeb9u6TN99E49esa0LERERERH9vzWX12DphaWQQIINnTagvF55sSMRERFRCcIiOhULAXWtUdPaAKkZcgRtu8q2LkREREREBAC4+uwqBvw7AAAwsdFENLdtLnIiIiIiKmlYRKdi4W1bF1fIVKU4djcem88+FDsSERERUZFhbW2NKVOmICaGre+odElOT4ZPiA9eZ71GC9sWGNdwnNiRiIiIqARiEZ2KjYpG2hjtWQkA8Ovum3iS8FrkRERERERFw/Dhw7Ft2zbY2NigefPm2LRpE9LT08WORfRVCYKAPv/0wZ0Xd2Cha4F1HddBRaoidiwiIiIqgVhEp2IlsF5F1KhQBinpWWzrQkRERPQ/w4cPx6VLl3DmzBk4OTlhyJAhMDMzw+DBg3HhwgWx4xF9FQvPLsSW61ugKlXFFt8tMNY2FjsSERERlVAsolOxovK/ti7qqlIcufMcIecfiR2JiIiIqMioUaMG5s+fjydPnmDixIlYtmwZatasiWrVqmHFihVcgEAlxulHpzEybCQAYFbzWahrWVfkRERERFSSsYhOxY5dOR2Mau4AAJj67w08TXwjciIiIiKioiEzMxNbtmxBu3btMGrUKLi7u2PZsmXw9vbGL7/8gu7du4sdkeiLvUh7gc6hnZGpyIS3kzeG1R4mdiQiIiIq4VQ/Z6eHDx9CIpGgfPnyAIAzZ85gw4YNcHZ2Rr9+/Qo1IFFu+jSwwZ5rT3H5YQJ+2X4Vy3u6QyKRiB2LiIiISBQXLlzAypUrsXHjRkilUvj7++OPP/6Ao6OjckzHjh1Rs2ZNEVMSfTmFoECP7T0QkxgDu7J2WN5uOT8HEBER0Vf3WSvRu3XrhkOHDgEAnj59iubNm+PMmTMYO3YspkyZUqgBiXKjIpVgtk9VqKtIcfBWHLZdeCx2JCIiIiLR1KxZE3fv3sWiRYvw+PFjzJ49O1sBHQAqVqyILl26iJSQqHD8dvw3/Bf5HzRUNRDqGwp9DX2xIxEREVEp8FlF9GvXrqFWrVoAgC1btqBKlSo4efIk1q9fj1WrVhVmPqI82ZvoYpiHPQBg8j/XEZfEti5ERERUOt27dw979+6Fr68v1NTUch2jra2NlStXfuNkRIXn0P1DGH9oPABgYeuFcDV1FTkRERERlRafVUTPzMyETCYDAOzfvx/t2rUDADg6OiI2Nrbw0hF9Qv+GNnCx0EfSmyz8sv0aL5ZFREREpVJcXBxOnz6dY/vp06dx7tw5ERIRFa4nyU/QZWsXKAQFAqoFoFf1XmJHIiIiolLks4rolStXRnBwMI4dO4bw8HC0bNkSAPDkyRMYGhoW+HgLFy6EtbU1NDQ0ULt2bZw5cybPsatWrYJEIsl209DQ+JynQSWAqooUs31doaYiwf6bz7Dr8hOxIxERERF9c4MGDcLDhw9zbH/8+DEGDRokQiKiwpOlyELXrV0RlxoHl3IuWNh6odiRiIiIqJT5rCL677//jsWLF6Nx48bo2rUrXF3ffo1u165dyjYv+bV582aMHDkSEydOxIULF+Dq6gpPT0/ExcXluY+enh5iY2OVt+jo6M95GlRCVDLVxdCmb9u6TNx1HXHJbOtCREREpcuNGzdQo0aNHNurV6+OGzduiJCIqPCMOzgOR6OPQlddF6GdQ6GlpiV2JCIiIiplPquI3rhxY8THxyM+Ph4rVqxQbu/Xrx+Cg4MLdKy5c+eib9++CAwMhLOzM4KDg6GlpZXtuB+SSCQwNTVV3kxMTD7naVAJMqCxLSqb6yEhLRPjd7CtCxEREZUuMpkMz549y7E9NjYWqqqqIiQiKhy7bu/C7yd+BwAsb7ccDoYOIiciIiKi0uiziuivX79Geno6DAwMAADR0dGYN28ebt++jXLlyuX7OBkZGTh//jw8PDz+P5BUCg8PD0REROS5X0pKCqysrGBpaYn27dvj+vXrn/M0qARRU5Filo8rVKUShF1/hn+vsDc/ERERlR4tWrRAUFAQEhMTldsSEhLwyy+/oHnz5iImI/p891/dR88dPQEAw2oPg29lX5ETERERUWn1WUX09u3bY82aNQDeTs5r166NOXPmoEOHDli0aFG+jxMfHw+5XJ5jJbmJiQmePn2a6z6VKlXCihUrsHPnTqxbtw4KhQJ169bFo0ePch2fnp6OpKSkbDcqmZzN9TC4qR0AYMLOa4hPSRc5EREREdG3MXv2bDx8+BBWVlZo0qQJmjRpgooVK+Lp06eYM2eO2PGICuxN1hv4hPgg4U0Cviv/HWY2nyl2JCIiIirFPquIfuHCBTRo0AAAEBoaChMTE0RHR2PNmjWYP39+oQb8UJ06deDv749q1aqhUaNG2LZtG4yNjbF48eJcx8+YMQP6+vrKm6Wl5VfNR+L6obEdHE118SotExN38hsKREREVDpYWFjgypUrmDlzJpydneHm5oY///wTV69e5fyXiqURe0fgQuwFGGoaYrPPZqirqIsdiYiIiEqxz2qQmJaWBl1dXQDAvn370KlTJ0ilUnz33XcFusinkZERVFRUcvRvfPbsGUxNTfN1DDU1NVSvXh2RkZG5Ph4UFISRI0cq7yclJfGDRAmmrirFbF9XtF94AruvxqLN1Vi0djETOxYRERHRV6etrY1+/fqJHYPoi62/sh7B54MhgQTrOq1DBf0KYkciIiKiUu6zVqLb2dlhx44dePjwIcLCwtCiRQsAQFxcHPT09PJ9HHV1dbi5ueHAgQPKbQqFAgcOHECdOnXydQy5XI6rV6/CzCz3QqlMJoOenl62G5VsVSz0MaixLQBg/I5reJmaIXIiIiIiom/jxo0b2Lt3L3bt2pXtRlRc3Hh+A/3+ffuPQeMajkNLu5YiJyIiIiL6zJXoEyZMQLdu3TBixAg0bdpUWfDet28fqlevXqBjjRw5Ej179oS7uztq1aqFefPmITU1FYGBgQAAf39/WFhYYMaMGQCAKVOm4LvvvoOdnR0SEhIwa9YsREdHo0+fPp/zVKiEGtzUHmHXn+H2s2RM3HUdf3Ut2PuSiIiIqDi5d+8eOnbsiKtXr0IikUAQBACARCIB8HbhCVFRl5KRAp8tPkjLTEOzis0wsdFEsSMRERERAfjMleg+Pj6IiYnBuXPnEBYWptzerFkz/PHHHwU6lp+fH2bPno0JEyagWrVquHTpEvbu3au82GhMTAxiY2OV41+9eoW+ffvCyckJrVu3RlJSEk6ePAlnZ+fPeSpUQqmrSjHLtypUpBL8c/kJ9l7L/UK1RERERCXBsGHDULFiRcTFxUFLSwvXr1/H0aNH4e7ujsOHD4sdj+iTBEFA/3/742b8TZjrmmOD9waoSFXEjkVEREQEAJAI75apfKZHjx4BAMqXL18ogb62pKQk6OvrIzExka1dSoGZe2/h78NRMNKRIXxEQxho84JEREREVHQU1tzUyMgIBw8eRNWqVaGvr48zZ86gUqVKOHjwIEaNGoWLFy8WYuovxzk5fSj4XDAG7h4IFYkKDgccRv0K9cWORERERKVAfueln7USXaFQYMqUKdDX14eVlRWsrKxQpkwZTJ06FQqF4rNDExW2YR72sC+ng/iUdEz+57rYcYiIiIi+CrlcDl1dXQBvC+pPnjwBAFhZWeH27dtiRiP6pHNPzmHY3mEAgN88fmMBnYiIiIqczyqijx07FgsWLMBvv/2Gixcv4uLFi5g+fTr++usvjB8/vrAzEn02maoKZvm6QioBdlx6gvAbz8SORERERFToqlSpgsuXLwMAateujZkzZ+LEiROYMmUKbGxsRE5HlLdXr1/BN8QXGfIMdHDsgFF1RokdiYiIiCiHz7qw6OrVq7Fs2TK0a9dOua1q1aqwsLDADz/8gGnTphVaQKIvVc2yDPo2tMHiI/cwdvtV1LIuC30tNbFjERERERWacePGITU1FQAwZcoUtG3bFg0aNIChoSE2b94scjqi3CkEBfx3+ONBwgPYGNhgZfuVyovhEhERERUln1VEf/nyJRwdHXNsd3R0xMuXL784FFFhG+HhgP03niHqeSqm/HsDczq7ih2JiIiIqNB4enoq/2xnZ4dbt27h5cuXMDAwYFGSiqxZJ2bh3zv/QqYiQ4hvCMpolBE7EhEREVGuPqudi6urKxYsWJBj+4IFC1C1atUvDkVU2DTUVDDTxxUSCbD1wiMcvMW2LkRERFQyZGZmQlVVFdeuXcu2vWzZsiygU5F15MERjD04FgAwv9V81DCrIXIiIiIiorx91kr0mTNnok2bNti/fz/q1KkDAIiIiMDDhw+xZ8+eQg1IVFjcrAzQp35FLD12H0HbrmLfiLLQ12RbFyIiIire1NTUUKFCBcjlcrGjEOXL05Sn6LK1C+SCHD2q9kDfGn3FjkRERET0UZ+1Er1Ro0a4c+cOOnbsiISEBCQkJKBTp064fv061q5dW9gZiQrNqBaVUNFIG8+S0jFt9w2x4xAREREVirFjx+KXX35ha0Uq8rIUWei2tRuepjxFZePKWNRmEb8xQUREREWeRBAEobAOdvnyZdSoUaNIr4JJSkqCvr4+EhMToaenJ3YcEsHZBy/ReXEEBAFYFVgTjSuVEzsSERERlVKFNTetXr06IiMjkZmZCSsrK2hra2d7/MKFC18atVBxTl56jT0wFtOPT4e2mjbO9TsHR6Oc19oiIiIi+lbyOy/9rHYuRMVZTeuyCKxbEStOvG3rEjaiIfQ02NaFiIiIiq8OHTqIHYHok3bf2Y3px6cDAJa1W8YCOhERERUbLKJTqTTasxIO3HqG6BdpmLHnJmZ04gVxiYiIqPiaOHGi2BGIPio6IRo9tvcAAAyqOQhdqnQRORERERFR/n1WT3Si4k5TXQUzvd8WzjeeeYjjd+NFTkREREREVDKlZ6XDN8QXr968Qk3zmpjTYo7YkYiIiIgKpEAr0Tt16vTRxxMSEr4kC9E3VdvGED3rWGF1RDR+2noFYSMaQkfGL2cQERFR8SOVSj96ccaifM0iKvl+3Pcjzj45CwMNA2zx3QKZqkzsSEREREQFUqCKob6+/icf9/f3/6JARN/SmJaOOHg7Dg9fvsaMPTcxraOL2JGIiIiICmz79u3Z7mdmZuLixYtYvXo1Jk+eLFIqImDztc1YcHYBAGBtx7WwLmMtbiAiIiKizyARBEEQO8S3lN8rrlLpcTIqHt2WngYAbOhTG3XtjERORERERKXF156bbtiwAZs3b8bOnTsL/dhfgnPy0uFW/C3UXFoTKRkpCKofhOnNposdiYiIiCib/M5L2ROdSr26tkb4/rsKAIAxW68gNT1L5EREREREheO7777DgQMHCrRPcnIyhg8fDisrK2hqaqJu3bo4e/as8vFJkybB0dER2traMDAwgIeHB06fPl3Y0amYS81Ihc8WH6RkpKCxdWNMaTJF7EhEREREn41FdCIAP7dygkUZTTx69Roz994SOw4RERHRF3v9+jXmz58PCwuLAu3Xp08fhIeHY+3atbh69SpatGgBDw8PPH78GADg4OCABQsW4OrVqzh+/Disra3RokULPH/+/Gs8DSqGBEHAwN0Dcf35dZjqmGKj90aoSnntISIiIiq+2M6F6H+O343H98vfrqLa1O87fGdjKHIiIiIiKukKa25qYGCQ7cKigiAgOTkZWlpaWLduHdq1a5ev47x+/Rq6urrYuXMn2rRpo9zu5uaGVq1a4ddff83zOezfvx/NmjXL13k4Jy/Zlp5fin7/9oNUIsVB/4NoZN1I7EhEREREucrvvJTLAYj+p769EbrWqoCNZ2Lw09Yr+G9YA2ip81eEiIiIir4//vgjWxFdKpXC2NgYtWvXhoGBQb6Pk5WVBblcDg0NjWzbNTU1cfz48RzjMzIysGTJEujr68PV1TXP46anpyM9PV15PykpKd+ZqHi5GHsRQ/4bAgCY1nQaC+hERERUIrBCSPSeX1o74sjtOES/SMOssNuY6FVZ7EhEREREnxQQEFAox9HV1UWdOnUwdepUODk5wcTEBBs3bkRERATs7OyU4/7991906dIFaWlpMDMzQ3h4OIyM8r44+4wZMzB58uRCyUhFV8KbBPiE+CBdno62Dm0xpt4YsSMRERERFQr2RCd6j66GGmZ4VwUArDr5AGcfvBQ5EREREdGnrVy5EiEhITm2h4SEYPXq1QU61tq1ayEIAiwsLCCTyTB//nx07doVUun/f3Ro0qQJLl26hJMnT6Jly5bo3Lkz4uLi8jxmUFAQEhMTlbeHDx8WKBMVfYIgIHBnIO69ugcrfSus7rAaUgk/bhIREVHJwFkN0QcaORijs3t5CAIwJvQKXmfIxY5ERERE9FEzZszIdSV4uXLlMH369AIdy9bWFkeOHEFKSgoePnyIM2fOIDMzEzY2Nsox2trasLOzw3fffYfly5dDVVUVy5cvz/OYMpkMenp62W5UssyNmIsdt3ZAXUUdoZ1DUVazrNiRiIiIiAoNi+hEuRjbxhmmehq4H5+KOftuix2HiIiI6KNiYmJQsWLFHNutrKwQExPzWcfU1taGmZkZXr16hbCwMLRv3z7PsQqFIlvPcypdjsccx0/7fwIAzPOcB3dzd5ETERERERUuFtGJcqGvqYYZnVwAAMtP3Mf5aLZ1ISIioqKrXLlyuHLlSo7tly9fhqGhYYGOFRYWhr179+L+/fsIDw9HkyZN4OjoiMDAQKSmpuKXX37BqVOnEB0djfPnz6NXr154/PgxfH19C+vpUDESlxoHv1A/yAU5ulbpigHuA8SORERERFToWEQnykMTx3LwrvG2rcvo0Ct4k8m2LkRERFQ0de3aFUOHDsWhQ4cgl8shl8tx8OBBDBs2DF26dCnQsRITEzFo0CA4OjrC398f9evXR1hYGNTU1KCiooJbt27B29sbDg4O8PLywosXL3Ds2DFUrswLspc2coUc3bZ2w5PkJ3AycsISryWQSCRixyIiIiIqdBJBEASxQ3xLSUlJ0NfXR2JiInsx0iclpmWi+R9HEJecjv6NbBDUyknsSERERFSCFNbcNCMjAz169EBISAhUVVUBvG2x4u/vj+DgYKirqxdW5ELBOXnJMPHQREw5OgVaalo42/csnI2dxY5EREREVCD5nZdyJTrRR+hrqWF6x7dtXZYevYeLMa9ETkRERESUk7q6OjZv3ozbt29j/fr12LZtG6KiorBixYoiV0CnkiEsMgxTj04FACxpu4QFdCIiIirRVMUOQFTUeTiboGN1C2y/+BijQ6/g3yH1oaGmInYsIiIiohzs7e1hb28vdgwq4R4mPkT3bd0hQEB/t/7oXrW72JGIiIiIviquRCfKh4lezjDSkSEyLgXzD9wVOw4RERFRNt7e3vj9999zbJ85cyYv+EmFKkOegc6hnfHi9QvUMKuBeS3niR2JiIiI6KsrEkX0hQsXwtraGhoaGqhduzbOnDmTr/02bdoEiUSCDh06fN2AVOqV0VLHtI5VAACLj97DlUcJ4gYiIiIies/Ro0fRunXrHNtbtWqFo0ePipCISqqfwn/CqUenoC/TR4hvCDRUNcSORERERPTViV5E37x5M0aOHImJEyfiwoULcHV1haenJ+Li4j6634MHD/Djjz+iQYMG3ygplXaelU3RztUccoWA0SFXkJ4lFzsSEREREQAgJSUl197nampqSEpKEiERlUShN0Ix7/Q8AMCajmtgY2AjbiAiIiKib0T0IvrcuXPRt29fBAYGwtnZGcHBwdDS0sKKFSvy3Ecul6N79+6YPHkybGw4caNvZ1K7yjDSUcftZ8lYcDBS7DhEREREAAAXFxds3rw5x/ZNmzbB2ZkXfKQvd+fFHfTa2QsAMKbuGLSr1E7kRERERETfjqgXFs3IyMD58+cRFBSk3CaVSuHh4YGIiIg895syZQrKlSuH3r1749ixY98iKhEAoKy2Oqa2r4KB6y/g78NR8KxsiioW+mLHIiIiolJu/Pjx6NSpE6KiotC0aVMAwIEDB7Bx40aEhISInI6Ku7TMNPiG+CI5IxkNKjTAtGbTxI5ERERE9E2JuhI9Pj4ecrkcJiYm2babmJjg6dOnue5z/PhxLF++HEuXLs3XOdLT05GUlJTtRvQlWrmYoY2LGeQKAT+GXEZGlkLsSERERFTKeXl5YceOHYiMjMQPP/yAUaNG4dGjR9i/fz+vH0RfbPCewbjy7ArKaZfDJp9NUJWKuhaLiIiI6JsTvZ1LQSQnJ6NHjx5YunQpjIyM8rXPjBkzoK+vr7xZWlp+5ZRUGkxuXxlltdVx62kyFh5iWxciIiISX5s2bXDixAmkpqYiPj4eBw8eRKNGjXDt2jWxo1ExtuLiCqy8tBJSiRQbvTfCXNdc7EhERERE35yoRXQjIyOoqKjg2bNn2bY/e/YMpqamOcZHRUXhwYMH8PLygqqqKlRVVbFmzRrs2rULqqqqiIqKyrFPUFAQEhMTlbeHDx9+tedDpYeRjgyT21UGACw8FIkbT/gNByIiIio6kpOTsWTJEtSqVQuurq5ix6Fi6vLTyxi0ZxAAYErjKWhasanIiYiIiIjEIWoRXV1dHW5ubjhw4IBym0KhwIEDB1CnTp0c4x0dHXH16lVcunRJeWvXrh2aNGmCS5cu5brKXCaTQU9PL9uNqDC0rWqGlpVNkfW/ti6ZcrZ1ISIiInEdPXoU/v7+MDMzw+zZs9G0aVOcOnVK7FhUDCW+SYRPiA/eZL1BK7tWCGoQ9OmdiIiIiEoo0ZvZjRw5Ej179oS7uztq1aqFefPmITU1FYGBgQAAf39/WFhYYMaMGdDQ0ECVKlWy7V+mTBkAyLGd6GuTSCSY2qEKTt1/gRuxSQg+HIUhzezFjkVERESlzNOnT7Fq1SosX74cSUlJ6Ny5M9LT07Fjxw44OzuLHY+KIUEQ0HtXb0S+jISlniXWdlwLqaRYdQIlIiIiKlSiz4T8/Pwwe/ZsTJgwAdWqVcOlS5ewd+9e5cVGY2JiEBsbK3JKotwZ6/5/W5f5B+/i1lO2dSEiIqJvx8vLC5UqVcKVK1cwb948PHnyBH/99ZfYsaiYm396Prbe3Ao1qRpCfENgqGUodiQiIiIiUUkEQRDEDvEtJSUlQV9fH4mJiWztQoVCEAT0W3se4TeewcVCH9t/qAtVFdH/fYqIiIiKgS+dm6qqqmLo0KEYOHAg7O3//xtxampquHz5cpFdic45edEV8TACDVc1RJYiC/NbzseQ2kPEjkRERET01eR3XspKH9EXkkgkmNahCvQ11XD1cSIWH70ndiQiIiIqJY4fP47k5GS4ubmhdu3aWLBgAeLj48WORcVUfFo8Ood2RpYiC50rd8bgWoPFjkRERERUJLCITvR/7d15eFTl3f/xz5mZzExmskAIhC2AiiIugIIguKAV96fWhUVrBbFurfpAaa3SWtFHEdxqW6VoteqvqFWB4l4REBcQK7IoIFIX9j2QjUkymeX8/pghyZBMyMQkZ5J5v67rXJnlzMz33D1Mv35y5z5NoFOWW1N+HJnp9eeF3+i/u0strggAAKSCU089VU8//bR27typm266SS+//LK6du2qcDisBQsWqLSUngQNEwqHdPW/rta2km06psMxeubHz8gwDKvLAgAASAqE6EATueykbjrn2E6qDIV1+5wvFQyFrS4JAACkCK/Xq+uuu05LlizRmjVr9Otf/1rTp09Xp06ddMkll1hdHlqBqR9P1Xvfvad0R7rmjJqjTFem1SUBAAAkDUJ0oIkYhqGpl52oTLdDX2wt0jNLNlpdEgAASEF9+vTRQw89pG3btumf//yn1eWgFVj4/ULd88E9kqSZF8/UiXknWlsQAABAkiFEB5pQ52y37v6fyLIuf1zwX32754DFFQEAgFRlt9t16aWX6o033rC6FCSx7SXb9dO5P5UpU9efdL3GDRhndUkAAABJhxAdaGIjB3bXWX06qjIY1u1zvlAobFpdEgAAAFBLIBTQmDljtLdsrwZ0HqC/XPgXq0sCAABISoToQBMzDEMPXHaiMl0OrdpSpOeWsqwLAAAAks/kRZO1dOtSZbmyNHvUbKWnpVtdEgAAQFIiRAeaQdd26fr9xX0lSQ/P36Dv97KsCwAAAJLHvPXz9OiyRyVJz/3kOfXO6W1xRQAAAMmLEB1oJmNOydcZR+fKHwzrt3O+ZFkXAAAAJIXv9n+na1+/VpI06dRJurzv5dYWBAAAkOQI0YFmYhiGpl/RTxkuhz7fXKj/98kmq0sCAABAiisPlGvk7JEq8ZdoWP4wTR8x3eqSAAAAkh4hOtCMurVL1+SLjpUkPTT/a20q8FlcEQAAAFLZhHcnaPWu1cr15OqVka8ozZ5mdUkAAABJjxAdaGY/HdxDw47qoIpAWL+d+6XCLOsCAAAAC/zji3/o6ZVPy5Chly5/Sd2zultdEgAAQKtAiA40M8Mw9OAV/eRx2vXZxv2a9elmq0sCAABAilmze41ufutmSdKU4VN07lHnWlwRAABA60GIDrSA/ByPJl8YWdblwXe/1pZ9ZRZXBAAAgFRR6i/VqNmjVB4s13lHnae7zrzL6pIAAABaFUJ0oIVcPaSnTj0yR2WVIf127hcs6wIAAIBmZ5qmrn/zem3Yt0HdMrvphctekN1mt7osAACAVoUQHWghNltkWZf0NLs+/X6/Xvxsi9UlAQAAoI2bsXyGXl33qhw2h14d9ao6ejtaXRIAAECrQ4gOtKCeHby644I+kqTp76zX1v0s6wIAAIDm8dn2zzRp/iRJ0kMjHtKw/GEWVwQAANA6EaIDLWzs0F4a3CtHvsqQJv9rjUyTZV0AAADQtPaV7dOo2aMUCAd0ed/LNfHUiVaXBAAA0GoRogMtzGYz9ODIfnKn2bTk2wK9vHyr1SUBAACgDQmbYY19bay2FG9R75zeevaSZ2UYhtVlAQAAtFqE6IAFjsj16jfnRZZ1mfr2em0vKre4IgAAALQV05dM1zvfvCO3w63Zo2Yr251tdUkAAACtGiE6YJHxpx2hgT3b64A/yLIuAAAAaBKLNy7WHxb/QZI046IZGtB5gLUFAQAAtAGE6IBF7DZDD43sJ5fDpo/+u1ezP99mdUkAAABoxXaU7tCVc69U2Azr2gHX6rqTrrO6JAAAgDaBEB2w0FEdM/Tr846RJN331lfaWcyyLgAAAEhcMBzUVXOv0h7fHp3Y6UTNuGiG1SUBAAC0GYTogMV+fvqROqlHO5X6g/ody7oAAACgEe56/y59tPkjZTozNWf0HHnSPFaXBAAA0GYQogMWs9sMPTyyn5wOmxZv2Ku5K7dbXRIAAABakTc2vKEHlz4oSfr7JX/XMR2OsbgiAACAtoUQHUgCvTtl6lcjIv+x839vrtPukgqLKwIAAEBrsLFwo8a9Nk6S9L+D/1ejjh9lcUUAAABtDyE6kCRuOOMI9e+erZKKoH4/j2VdAAAAUL+KYIVGzR6loooiDek2RA+f97DVJQEAALRJhOhAknDYbXpoZH857TYtXL9Hr6/eYXVJAAAASGKT5k/Sip0rlJOeo1dHvSqn3Wl1SQAAAG0SITqQRPp0ztT/ntNbkjTljXXaU8qyLgAAAKjtpTUvaebnM2XI0IuXv6ge2T2sLgkAAKDNSooQfcaMGerVq5fcbreGDBmizz77LO6+//rXvzRo0CC1a9dOXq9XAwYM0KxZs1qwWqB53TT8KJ3QLUvF5QHdNW8ty7oAAAAgxld7v9KNb94oSbrrzLt0Qe8LLK4IAACgbbM8RH/llVc0adIkTZkyRStXrlT//v11/vnna8+ePXXun5OTo9///vdatmyZvvzyS40fP17jx4/X/PnzW7hyoHmk2W16eGR/pdkNvffVbr355U6rSwIAAECSOFB5QCNfHSlfwKdzjjhHU4ZPsbokAACANs/yEP2Pf/yjbrjhBo0fP17HHXecnnzySXk8Hj377LN17n/WWWfpsssuU9++fXXUUUdpwoQJ6tevn5YsWdLClQPNp2+XLN169tGSpCmvr9XeUr/FFQEAAMBqpmnqprdu0vqC9eqa2VUvXfGS7Da71WUBAAC0eZaG6JWVlVqxYoVGjBhR9ZjNZtOIESO0bNmyw77eNE0tWrRIGzZs0JlnnlnnPn6/XyUlJTEb0Br88uyjdFyXLBWWBTTljbVWlwMAAACLPbXiKb205iXZDbteGfmKOnk7WV0SAABASrA0RC8oKFAoFFJeXl7M43l5edq1a1fc1xUXFysjI0NOp1MXX3yxHn/8cZ177rl17jtt2jRlZ2dXbfn5+U16DEBzSbPb9PCofnLYDL2zZpfeZlkXAACAlPX5js814d0JkqTpI6br9B6nW1wRAABA6rB8OZfGyMzM1OrVq7V8+XJNnTpVkyZN0gcffFDnvpMnT1ZxcXHVtnXr1pYtFvgBju+arV+e3VuSdPfra7XvAMu6AAAApJrC8kKNmj1KlaFK/aTPT/Trob+2uiQAAICU4rDyw3Nzc2W327V79+6Yx3fv3q3OnTvHfZ3NZlPv3pFgccCAAVq/fr2mTZums846q9a+LpdLLperSesGWtKtZ/fWe+t26etdpZryxjo98dOTrS4JAAAALSRshjXutXHaVLRJR7Q7Qs9f+rwMw7C6LAAAgJRi6Ux0p9OpgQMHatGiRVWPhcNhLVq0SEOHDm3w+4TDYfn9zNBF2+R02PTwyP6y2wy99eVOvbuWZV0AAABSxSOfPKI3//umXHaX5oyeo3budlaXBAAAkHIsX85l0qRJevrpp/X//t//0/r16/WLX/xCPp9P48ePlySNHTtWkydPrtp/2rRpWrBggb7//nutX79ejz76qGbNmqWf/exnVh0C0OxO7J6tXww/SpJ012trVeirtLgiAAAANLePNn+k3y36nSTpLxf+RSd34S8SAQAArGB5iD5mzBg98sgjuvvuuzVgwACtXr1a7777btXFRrds2aKdO6tn3vp8Pv3yl7/U8ccfr9NOO01z587VCy+8oOuvv96qQwBaxG3n9NYxeRkqOFCpe95cZ3U5AACgjSotLdXEiRPVs2dPpaena9iwYVq+fLkkKRAI6I477tCJJ54or9errl27auzYsdqxY4fFVbc9uw7s0pg5YxQyQ/pZv5/phpNvsLokAACAlGWYpmlaXURLKikpUXZ2toqLi5WVlWV1OUBCvthapMv+ulRhU/rbNQN13vHxrx0AAACSXzL2pmPGjNHatWs1c+ZMde3aVS+88IIee+wxffXVV8rIyNDIkSN1ww03qH///iosLNSECRMUCoX0+eefN/gzkvG4k0kwHNR5s87T4k2LdXzH4/Wf6/8jr9NrdVkAAABtTkP7UkL0lhQOSTZ7y34m2pzp//5aT374nTpmurTgV2eqncdpdUkAAKCRki1MLi8vV2Zmpl5//XVdfPHFVY8PHDhQF154oe6///5ar1m+fLkGDx6szZs3q0ePHg36nGQ77mTz+0W/1wNLHpA3zavPb/xcx+Yea3VJAAAAbVJD+1LLl3NJKc9eID0zQlowRfpmoeQvtboitEITRxytozp6tbfUr/976yurywEAAG1IMBhUKBSS2+2OeTw9PV1Lliyp8zXFxcUyDEPt2rVrgQrbvrf/+7YeWPKAJOmZS54hQAcAAEgCDqsLSBn+Umn755IZlrYtl5b+STLsUtcBUq/TpZ6nSz1OldzMxEH93Gl2PTyqv0bO/ET/WrldF5/YRef0zbO6LAAA0AZkZmZq6NChuu+++9S3b1/l5eXpn//8p5YtW6bevXvX2r+iokJ33HGHrrrqqnpn7vj9fvn9/qr7JSUlzVJ/a7e5aLOumXeNJOmWU27RlSdcaXFFAAAAkJiJ3nJcmdL/rpYunSkNuFpq11MyQ9L2FdLSP0svjZIe7Cn97WzpvT9I/50vVRRbXTWS1Mk92uv6M46UJP1u3hoVlwcsrggAALQVs2bNkmma6tatm1wul/7yl7/oqquuks0W+58OgUBAo0ePlmmamjlzZr3vOW3aNGVnZ1dt+fn5zXkIrZI/6NfoOaNVWFGoU7qeokfPe9TqkgAAABDFmuhWKtoibVoqbV4ibVoiFW6Kfd6wSV36Sz1Pk3qdEZmpnt7OikqRhCoCIV3054/1fYFPowZ218Oj+ltdEgAASFBS9aaH8Pl8KikpUZcuXTRmzBgdOHBAb7/9tqTqAP3777/X+++/rw4dOtT7XnXNRM/Pz0/K47bKbe/cpieWP6H27vZaedNK9WrXy+qSAAAA2ryG9uMs52Kldj2kAT2kAVdF7hdvi4Tqmz6OhuobpR2rItuyJyQZUpd+kUC952lSz6FSentLDwHWiSzr0k8jn1ym2Su26aJ+XXR2n05WlwUAANoIr9crr9erwsJCzZ8/Xw899JCk6gD9m2++0eLFiw8boEuSy+WSy+Vq7pJbrVfWvqInlj8hSZp12SwCdAAAgCTDTPRkVrxd2nwwVF8q7f/ukB0MqfOJkTXVe50u9RgqeXIsKRXWue+tr/T3JRvVJdut+b86U1nuNKtLAgAADZSMven8+fNlmqb69Omjb7/9Vrfffrvcbrc+/vhjSdLIkSO1cuVKvfXWW8rLq74uS05OjpxOZ4M+IxmP2yobCjZo0NODdKDygCafPlkPnPOA1SUBAACkjIb2pYTorUnJzhqh+hJp37eH7GBIeSdUh+o9hxGqp4DyypAu/PNH2rSvTFeekq/pV/SzuiQAANBAydibvvrqq5o8ebK2bdumnJwcXXHFFZo6daqys7O1adMmHXHEEXW+bvHixTrrrLMa9BnJeNxW8FX6NOSZIVq3d52G9xyuhWMXymHjj4UBAABaCiF6HG2qYS/dFQnTNy2JhOsF/629z8FQvedpkc17+D+3Revz2cb9GvO3ZTJN6R/XDdaZx3S0uiQAANAAbao3TUCqHndNpmlq3GvjNOvLWeqc0VmrblqlzhmdrS4LAAAgpRCix9GmG/bS3dGLlC6NBOsFG2rv0+l4qddp1cG6N7fl60SzuOeNdXr+k03q1i5d7048Q5ks6wIAQNJr071pPVL1uGt6esXTuvGtG2UzbHp/7Psa3mu41SUBAACkHC4smooy86QTrohsknRgT3T5l+hs9b1fS3vWRbbP/hbZp2PfGsu/nCZlMIO5tfrtBX30/td7tGV/mR5452tNvfQE2WyG1WUBAADgEKt2rtJt/75NkjT1R1MJ0AEAAJIcM9FTyYG91aH65qXSnq9q79Px2EiYfjBYz+jU8nWi0ZZ9t09XPf2pJMmdZlPPHK965XrUK9erIzp41bODV0fkepWX5ZJhELADAGC1VO1NU/W4JamookgD/zZQ3xd+r/855n/0+pWvy2bYrC4LAAAgJbGcSxyp3LDX4iuIhurRYH3Putr75B5TY6b66ZHZ7khqMxZ/q8cW/FfBcPx/2ulpdvXs4FGvDt5IwJ5bfbtTJgE7AAAtJVV701Q9btM0dfmrl+u1r19Tz+yeWnnTSuWk51hdFgAAQMoiRI8jVRv2BvHtk7Z8El3+Zam0e03tfTocHbv8S1aXlq8ThxUIhbW9sFwb9/m0qcCnzfvKtLHAp037fNpWWK5QPQG7x2mPzlj3RH5Gw/VeuR51zCBgBwCgKaVqb5qqx/3oJ4/qNwt+I6fdqaXXLdWgroOsLgkAACClEaLHkaoNe6OU7Zc2fxKdrf6xtGutpENOlw69o8u/nBG5YGlWV0tKRcMFQmFtKyzXpgJfVbC+aV+ZNhX4tK2wTPXk6/JWBeyRUL3qdgevcjOcBOwAACQoVXvTVDzuJVuW6Kznz1LIDGnGRTP0y1N+aXVJAAAAKY8QPY5UbNibTHmhtHlZdKb6x9KuNaoVquccGZ2pfkYkXM/uZkmpaJzKYFhbC8u0eZ9PGwsiwXokZPdpe2F5vQF7hssRWSImt8bs9ej9Dl4CdgAA6pKqvWmqHfce3x6d9NRJ2lG6Q1edcJVevPxFeiMAAIAkQIgeR6o17M2qvFDa8mk0VF8i7fpSMsOx+7Q/onr5l16nS9ndrakVP5g/GNLW/eUxwfqmgsgyMTuKy1XfN0mmy6FeuV717OCpmrneK7oOew4BOwAghaVqb5pKxx0Kh3TBixdo4fcLdWzusVp+w3JlODOsLgsAAABqeF/qaMGa0Nakt5f6XBjZJKm8KBKqb46G6ju/kAo3RrZVsyL7tO8VuUBpr9Mjy7+062FV9UiQy2FX704Z6t2p9n/0RQL2slqz1zcVlGlHcblK/UGt2V6sNduLa7020+3QEbne6Prrnuj665Ggvb0njYAdAAC0av/34f9p4fcL5UnzaM6oOQToAAAArRAz0dF8KoqlLf+JLP1yMFQ3Q7H7tOsRXU89eqHS9j2tqRXNpiJwMGCPXX99U4FPO4or6n1tVjRg73UwZI/OXj8i16t2HmcLHQEAAM0nVXvTVDnu+d/O14UvXihTpl647AVd3e9qq0sCAABADSznEkeqNOxJqaJE2vqf6uVfdqyqHapn96iepd7rdKldT4mZyG1WRSCkLQcD9oLq2eub9vm08zABe3Z6WnT9dU/VzPWD67Fne9Ja6AgAAPhhUrU3TYXj3lq8VSc9dZL2le/TTQNv0pP/86TVJQEAAOAQhOhxpELD3mr4SyMz1TfXCNXDwdh9srrHrqnevheheooorwxp8/7qUH1TgU8bC3zavK9Mu0rqD9jbe9KiM9dj11/vletVdjoBOwAgeaRqb9rWj7syVKnhzw/Xp9s+1cldTtbS65bK7XBbXRYAAAAOQYgeR1tv2Fs1/4Hqmeqbl0rbV9QRqnerXvql1+lSzpGE6imorDKozQeXhYn+3BgN2veU+ut9bY7XqV4dqkP1g7PXe+Z6lOUmYAcAtKxU7U3b+nH/6t1f6U//+ZOyXdlaedNKHdn+SKtLAgAAQB0I0eNo6w17m1Lpi4bqSyPB+vYVUjgQu09m1+qlX3qdQagOlVUGq2avR2auR2azb9zn097DBOwdvM7qpWGiy8RELnrqUSYBOwCgGaRqb9qWj3vOV3M0avYoSdLrV76uS/pcYnFFAAAAiIcQPY623LC3eZVl0rbPqtdU3/Z57VA9o3Ps8i8dehOqo4rPH4xZd/3gOuwbC8pUcKD+gD03w1m97no0WD94P8PlaKEjAAC0Nanam7bV4/5m3zca+LeBKq0s1e3DbtdD5z5kdUkAAACoByF6HG21YU9JlWXStuXVy79sWy6FKmP3ycirsfzLGVLu0YTqqFNpRSCyREzV+utlkVns+3wqOFBZ72s7Zrpil4ipsQ67l4AdAFCPVO1N2+JxlwfKderfT9WXu7/UGT3O0KKxi5Rm5y/ZAAAAkhkhehxtsWFHVKA8GqpHl3/ZtlwKHTK72NspdvmX3GMI1XFYJRUBba55gdPoz837yrTPV3/A3inTVR2qH1x/PXrf4yRgB4BUl6q9aVs87p+//nM9u/pZdfJ20qqbVqlrZlerSwIAAMBhEKLH0RYbdsQRqJC2f169/MvWz+oI1TtWX6S01+lSx2MJ1ZGQ4vKANletvx57kdPCskC9r83LigbsVcvERIL2njlepTvtLXQEAAArpWpv2taO+7lVz+m6N66TzbDpvZ+9p3OOPMfqkgAAANAAhOhxtLWGHQkIVEQuTrp5qbTp40ioHqyI3ceTG5mp3rNGqG6zWVMvWr3iskBk9nqNkH1jdB32osME7J2z3OqV64muvx4J2g+uxe5OI2AHgLYiVXvTtnTcX+z6Qqf+/VRVBCt0/9n36/dn/t7qkgAAANBArSpEnzFjhh5++GHt2rVL/fv31+OPP67BgwfXue/TTz+tf/zjH1q7dq0kaeDAgXrggQfi7n+ottSw4wcK+qXtK6Mz1Q+G6uWx+6TnRJd/OSMyY73TcYTqaBJFZZXadHDmeoEvMps9er+4vP6AvUu2O2b2es9owN4jh4AdAFqbVO1N28pxF1cUa9DTg/Tt/m91Ye8L9dZP35LNoFcEAABoLVpNiP7KK69o7NixevLJJzVkyBD96U9/0uzZs7VhwwZ16tSp1v5XX321TjvtNA0bNkxut1sPPvig5s2bp3Xr1qlbt26H/by20rCjGQQrpR0rI4H6pqXS1v9IgbLYfdLbxy7/0ul4QnU0uUJfZY0Z7GXR9dcjYXtJRTDu6wxD6pqdrp4dqtdfj1zo1KN8AnYASEqp2pu2heM2TVOjZo/S3PVzlZ+Vr1U3rVIHTwerywIAAEACWk2IPmTIEJ1yyil64oknJEnhcFj5+fm67bbbdOeddx729aFQSO3bt9cTTzyhsWPHHnb/ttCwo4UEK6Udq6TN0TXVt/xHCvhi93G3iw3V804gVEezMU1ThWWBqpnrkfXXIyH7pgKfSv2HD9gPLglzRG71Wuz5OelyOQjYAcAKqdqbtoXj/vOnf9bE+ROVZkvTx+M/1pDuQ6wuCQAAAAlqaF/qaMGaaqmsrNSKFSs0efLkqsdsNptGjBihZcuWNeg9ysrKFAgElJOTU+fzfr9ffn/1xSRLSkp+WNFIHQ6n1GNIZDvj11IoIO1YHZ2pvkTa8qlUUSRteDuySZI7uzpU73ma1PlEyUY4iaZhGIZyvE7leJ0a2LN9zHOmaWp/dAb7xoKyqpnrm/b5tKmgTAf8QW0vKtf2onIt+Tb2fW2G1LVdelWwXhWy53qV394jp4NfDAEAUNOyrcv0mwW/kSQ9et6jBOgAAABtnKUhekFBgUKhkPLy8mIez8vL09dff92g97jjjjvUtWtXjRgxos7np02bpnvvvfcH1wrIniblnxLZzpgUCdV3fhFdU32JtGWZVFEsbXgnskmSK1vqOSy6rvrpUud+hOpoFoZhqEOGSx0yXBrYM/aXiqZpap+vsmr99chSMdUz2H2VIW0rLNe2wnJ9/E1BzGtthtStfXqNC5tG1mHv1cGr/ByP0uwE7ACA1FJQVqDRc0YrGA5q1HGjdOvgW60uCQAAAM3M0hD9h5o+fbpefvllffDBB3K73XXuM3nyZE2aNKnqfklJifLz81uqRLRl9jSp+6DIdvpEKRSUdtUI1Tcvk/zF0n//HdkkyZUl9RhavfxL536SvVX/M0QrYBiGcjNcys1waVCv2gH73gN+bd5XFgnYC3zVt/f5VFYZ0tb95dq6v3bAbhhSu/S0qtnx7T3Oqtt13vc65XXaZRhGSx4+AABNJmyG9bN//UzbSrbpmA7H6JlLnuH/1wAAAFKApeldbm6u7Ha7du/eHfP47t271blz53pf+8gjj2j69OlauHCh+vXrF3c/l8sll8vVJPUC9bI7pG4DI9tpE6Kh+pfRQH2ptPkTyV8ifTM/skmSM1PqOTS6BMwZUpf+hOpoUYZhqFOmW50y3TqlroC91F81a31jdB32g/fLAyEVlgVUWBbQd3t9cT4hltNhU44nEqjneNOU43Upx5MWvR/dqp6PBPEsJwMASBZTP5qq+d/NV7ojXXNGzVGWq3Wu5w4AAIDEWJrWOZ1ODRw4UIsWLdKll14qKXJh0UWLFunWW+P/WeRDDz2kqVOnav78+Ro0aFALVQskyO6Qup0c2U77XykciobqS6PB+ieRmerfvBfZJMmZIfU4NTpT/WConmbtcSBlGYahTlludcpya/ARtQP2ggOVKiyr1H5f9Vboq9Q+X/XjhWWV2n8g8pg/GFZlMKxdJRXaVVLR4DoyXQ61j85k71A1wz3tkPvVW5Y7TTYbswIBAE1r4fcLNeWDKZKkmRfP1Il5J1pcEQAAAFqK5VNeJ02apHHjxmnQoEEaPHiw/vSnP8nn82n8+PGSpLFjx6pbt26aNm2aJOnBBx/U3XffrZdeekm9evXSrl27JEkZGRnKyMiw7DiAw7LZpa4nRbZht0ZC9d1rayz/sjSypvq3CyObFAnV84dUL//S9SRCdSQFwzDUMdOljpkN/0uf8sqQ9kdD9f1lkcC9KoAvqxHA1wjhw6ZU6g+q1B/Ulv1lDfocm6GqYL19jZntHbzVM+Dbe5zq4HWpvTeyHI3Hafn/HQIAktj2ku366dyfypSpn5/0c40bMM7qkgAAANCCLE8NxowZo7179+ruu+/Wrl27NGDAAL377rtVFxvdsmWLbLbqP+WfOXOmKisrNXLkyJj3mTJliu65556WLB34YWz2yEzzLv2lobdEQ/V11YH6piVSRZH03aLIJklpXqnHkOrlX7qeJDmclh4G0FDpTru6OdPVrV16g/YPh02VVASqZ7T7Atrv82u/L1B7Bnw0nC/1BxU2pX3RQL6h3Gm2mGVkaq7pfuiM9/bREJ6LqgJAagiEAhozZ4z2lu1V/7z+evzCx60uCQAAAC3MME3TtLqIllRSUqLs7GwVFxcrK4s1DJHEwmFpz1fRmeofR5Z/Kd8fu0+aR8ofXL38S9eTCdWR0iqDYRWVVdYx4z0awJcFYmfA+ypVGQo36rOy3I44IXvs2u4HZ8BnuR1cfA5ALanam7am4/7Ne7/Ro8seVZYrSytuXKHeOb2tLgkAAABNpKF9qeUz0QHEYbNJnU+IbKfeHAnV966PXf6lbJ/0/QeRTZIc6ZFQvdvASMBud0i2NMnubMDt6H2bo/7bB19nYxYuko/TYatax70hTNNUWWWo1rIyMTPcY+5HZsGbplRSEVRJRVCb9jVsmRmHzVA7z8FQPa1qtnsHb+yFVGuu7+5Os/+Q4QAA/EDz1s/To8selSQ995PnCNABAABSFCE60FrYbFLe8ZFtyE3RUP3r6NIvH0eC9bJ90sYPI1tzM2wNCOXT6r5tc0T3jfN81e3ofrVu1/d+h95Oq/s9bHaJWcEpzzAMeV0OeV0O5ed4GvSaUNhUcXmg7pA9GsTXvF3oC+iAP6hg2FTBAb8KDvgbXF96mr16eZnDXFi1ffS2nYuqAkCT+G7/d7r29WslSZNOnaTL+15ubUEAAACwDCE60FrZbFLecZFt8A2SaUp7N0QC9b0bpFClFApI4UDkZ83b4WD9z1fdju4XDtT+fDMshfyRrbWqGa4fdsb+oaF8Q2bs1/OLhIbcPtzz/BLAEnabURVsN1RFIKSiskDcGe91zYAPhEyVB0LaXlSu7UXlDfocw5Cy09Ni13c/zIVVM1wsMwMAhyoPlGvk7JEq8ZdoWP4wTR8x3eqSAAAAYCFCdKCtMAyp07GRramZZuTCpwcD9VAw+rOyjlA+GA3iK+u5feh71HX70GA/zvs19JcAZh3rXocqI1sdvyNoFWyJzvpvyIz9embvx/uLA5sj+pcJjkM2e4L3HW12mSB3ml2ds+3qnN3wZWYO+IMq9AW0z+evfWHVOma8F5UFZJpSUVlARWUBqcDXoM9Ksxsxy8i0jwbv8e+nyeVgmRkAbduEdydo9a7VyvXk6pWRryjNnmZ1SQAAALAQITqAwzOMaJjair8ywqEGzsw/dJZ+MDb4P+wvARL8pUK9vwSocTscrOOYgpEt2LBZyq2D0YDg3X6YID7R8L6e+4a9ga9p7C8N6nh/w5BhGMp0pynTnaYeHRq2zEwwFFZRefWFUwvLKrXPV31h1dj7kefLKkMKhEztKfVrT2nD/6okw+WIrOtex4z3mmu6Hwzn26WnycYyMwBaiX988Q89vfJpGTL00uUvqXtWd6tLAgAAgMVacSIGAAk4GL6qYTOBk45pNnJ5nni/BGjoLxIO90uAaJAfDtW4Hb1v1vFYzft1H2j0lwat9c8DmkCtWf0NC+cdNodybQ7lxtvf4ZDaO6Sc6l9EBGVXRchQeUgqDxoqDxnyBaSyoHQgEN0qTZVWSiWVpkoqTQXCNgUDdoWK7AoW2RSSXftl017ZFZRdIdMW+SlbdLMrbNjlcbvkTXcp0+NWlsetLE+6Mj3pys5wq503XdkZ6Wrv9Sgnw62cDJc8TjvLzABocWv3rNXNb90sSZoyfIrOPepciysCAABAMiBEB4DWwDAkh1NSw9fhTmqmGVlip76QPV44H3efQ38m8j6JfE4w+guCH/iedS0xJEWvNxBdaqiZOSRlRLcGv6CxwpJ80e0wAqZdftkUMiIBfIXhVbk9Q35HhvyOLAXSMhV0ZinszFLY1U5yZ8vmyZYtvZ0c3hw5vO3kzsiR25stT/TCsS6HjVAeQL1K/aUa+epIlQfLde6R5+quM++yuiQAAAAkCUJ0AEDLM4zoUil2SS6rq7FGOHz42fp1/mIgwcC/xX5JUPc+ZjgoMxTZDj5umCHZzHh/jSClGSGlKSQpIJlSpumTwnsSvn5ByDRUKo92m16VyCOfkaEym1fl9kxV2DNV6chUwJmpYFq2Qq4sma4sGe52MtLby+bJlivdK4/LIY/TIY/TLo/TIa/LLk+aQx6XXR6nXelpzJgH2gLTNHXDmzdow74N6pbZTS9e/qLsNq7/AAAAgAhCdAAArGCzSbJFLs7ahhnRrZaqv0aIDd7NcFAVfr+KDpSr2FehEl+ZAmXFCpcVKVxRJFUUy6golt1fLHtlqdICJXIGS5UeKpU7dECe8AFlmAfkVFB2w1Q7+dTOqDH93ZQUjG5+1TszvtK0q0RelZieqp87oz+L5VVJNJyvsB+cIZ+lkDNTYVe2THeWnK70GgF8dQif7nTIW+Ox2Ofs8jodSk+zs4480IL+uvyvemXdK3LYHHp11Kvq6O1odUkAAABIIoToAACg5cX8NUL1MkWGpPQMKb2D1OWHvH+gXKooVqisSP4Dhar07VegdL+CZUUKlRfJLC+WKooigXxlieyVJXJGA3lX8IDsCslphJSrEuUaJYf/vLAiobxfUmnkoXLTqRJ5qsL24ujPEtOrHVX3D4b0sfdL5ZEzzRkJ2F3RYN1Z8+chYbzLEfNYutMurysSxntd1Y95nA7ZCeeBGJ9t/0y/mv8rSdJDIx7SsPxhFlcEAACAZEOIDgAA2p60dCktXfbMzvLkSZ5EXmuaUqVPis58j9nKI4+Z5ZEwPlRWGA3ki2X4IzPkHYFIip5uVCpdlcozihp1CAdMt4qDXpUEPLVmxB/8WSSvttS4fzCIPyC3TNnqfF+Xw1YjYI+dDe9xRh5LT3Mc8lz0tssuTzSYPxjqH3zMYa/784Bktq9sn0bNHqVAOKDL+16uiadOtLokAAAAJCFCdAAAgJoMQ3JlRLbs7nXvokgTVWcjFQ5J/tIa4XtRnUF8Xc+bFcUyKg9IkjKMCmWoQt2MfQkfQliGfPKoVF4VmV4VmemRGfEHl6Kp8KikwquSkoNL03hUUCOgL5NLcRbiicvpsEVC+Bqz5atCeJdDnjR71VrynqpZ9I6Yx2LC/OhzaYTzaCZhM6yxr43VluIt6p3TW89e8izXOAAAAECdCNEBAACaks0upbeLbAkyJCkUkCpKDgnfixocxCtYIZtMZcqnTPnUNe7C9PGFDLsq7Jkqs3lVZmSo1PCqVF4Vmx4VhT3aH/ZofyhdBUG3isLRGfAhj0rKvCoo88hfY4meHyrNbtSeEe+sORu+9oz5mmvPV82Yj1n2xi6n3UZgmuKmL5mud755R26HW7NHzVa2O9vqkgAAAJCkCNEBAACSiT1N8naIbI0RqJD8JYcE7UUNCOKj+4WDspsheYNF8qqo/s+K00mGbU4FnNmqdGTK78iIBPL2DPmMDB1Q9RrxRaZHhaF07Qula18wXXsCbu2pdKk0YKgyFI4cTshUcXlAxeWBxo1HvNJtRkzAfmTHDD0zblCTfgaS1+KNi/WHxX+QJD1x4RMa0HmAtQUBAAAgqRGiAwAAtCVp7siW0Snx15qmFChrwIz3ovj7yJQtXClXxV65tFeZjTkGj1emO1thV7ZCziwFnJnRQD5LFfYM+WwZKjO8KjUyqi7WWhT2qDCcrn1Bt8oCYfn8IZUFQirzB1VWGVJZZeSnPxgJ54NhU6UVQZVWBCVFlqNBathZulNXzb1KYTOsawdcq+tOus7qkgAAAJDkCNEBAAAQYRiS0xvZsrom/vpwWKosPcyM90Pv19inMnJRVgV8MgI+2Ut3yC7JKcnb8IOQXFmSOzuy5bSrvu3OVsiVrUBapvyOTJXbMlRmi4Typrt94seLVicYDurKuVdqt2+3Tux0omZcNINlfQAAAHBYhOgAAABoGjZbdWDdGKFgZCmahi49c+g+wXJJpuQvjmzFtT/CHt3ckmKqbH+EdNzqxtWNVuOu9+/SR5s/UqYzU3NGz5EnzWN1SQAAAGgFCNEBAACQHOwOyZMT2Roj6I9elLWh68DXuO/t2HTHgaSV582Tw+bQ3y/5u47pcIzV5QAAAKCVIEQHAABA2+BwSRkdIxtQh18N/ZUu63uZerXrZXUpAAAAaEW4ghIAAACAlEGADgAAgEQRogMAAAAAAAAAEAchOgAAAAAAAAAAcRCiAwAAAAAAAAAQByE6AAAAgCqlpaWaOHGievbsqfT0dA0bNkzLly+vev5f//qXzjvvPHXo0EGGYWj16tXWFQsAAAC0AEJ0AAAAAFWuv/56LViwQLNmzdKaNWt03nnnacSIEdq+fbskyefz6fTTT9eDDz5ocaUAAABAy3BYXQAAAACA5FBeXq65c+fq9ddf15lnnilJuueee/Tmm29q5syZuv/++3XNNddIkjZt2mRhpQAAAEDLIUQHAAAAIEkKBoMKhUJyu90xj6enp2vJkiWNfl+/3y+/3191v6SkpNHvBQAAALQ0lnMBAAAAIEnKzMzU0KFDdd9992nHjh0KhUJ64YUXtGzZMu3cubPR7ztt2jRlZ2dXbfn5+U1YNQAAANC8CNEBAAAAVJk1a5ZM01S3bt3kcrn0l7/8RVdddZVstsb/p8PkyZNVXFxctW3durUJKwYAAACaF8u5AAAAAKhy1FFH6cMPP5TP51NJSYm6dOmiMWPG6Mgjj2z0e7pcLrlcriasEgAAAGg5KReim6YpiXUYAQAAYL2DPenBHjWZeL1eeb1eFRYWav78+XrooYea7L3pyQEAAJAMGtqPp1yIXlpaKkmswwgAAICkUVpaquzsbKvLkCTNnz9fpmmqT58++vbbb3X77bfr2GOP1fjx4yVJ+/fv15YtW7Rjxw5J0oYNGyRJnTt3VufOnRv0GfTkAAAASCaH68cNMxmnvTSjcDisHTt2KDMzU4ZhtOhnl5SUKD8/X1u3blVWVlaLfnZrxZgljjFLHGOWOMascRi3xDFmiWPMEmflmJmmqdLSUnXt2vUHrTnelF599VVNnjxZ27ZtU05Ojq644gpNnTq16j8qnn/++apAvaYpU6bonnvuadBnWNWT8++jcRi3xDFmiWPMEseYJY4xSxxjljjGLHGtoR9PuZnoNptN3bt3t7SGrKws/hEliDFLHGOWOMYscYxZ4zBuiWPMEseYJc6qMUuWGegHjR49WqNHj477/LXXXqtrr732B32G1T05/z4ah3FLHGOWOMYscYxZ4hizxDFmiWPMEpfM/XhyTHcBAAAAAAAAACAJEaIDAAAAAAAAABAHIXoLcrlcmjJlilwul9WltBqMWeIYs8QxZoljzBqHcUscY5Y4xixxjFnq4H/rxmHcEseYJY4xSxxjljjGLHGMWeIYs8S1hjFLuQuLAgAAAAAAAADQUMxEBwAAAAAAAAAgDkJ0AAAAAAAAAADiIEQHAAAAAAAAACAOQvQmNmPGDPXq1Utut1tDhgzRZ599Vu/+s2fP1rHHHiu3260TTzxR77zzTgtVmjwSGbPnn39ehmHEbG63uwWrtd5HH32kH//4x+ratasMw9Brr7122Nd88MEHOvnkk+VyudS7d289//zzzV5nMkl0zD744INa55lhGNq1a1fLFJwEpk2bplNOOUWZmZnq1KmTLr30Um3YsOGwr0vl77TGjFmqf6fNnDlT/fr1U1ZWlrKysjR06FD9+9//rvc1qXyOSYmPWaqfY3WZPn26DMPQxIkT690v1c+11ox+vHHoyRuOfjxx9OOJox9PHP144ujHE0c//sO11n6cEL0JvfLKK5o0aZKmTJmilStXqn///jr//PO1Z8+eOvf/5JNPdNVVV+nnP/+5Vq1apUsvvVSXXnqp1q5d28KVWyfRMZOkrKws7dy5s2rbvHlzC1ZsPZ/Pp/79+2vGjBkN2n/jxo26+OKLdfbZZ2v16tWaOHGirr/+es2fP7+ZK00eiY7ZQRs2bIg51zp16tRMFSafDz/8ULfccos+/fRTLViwQIFAQOedd558Pl/c16T6d1pjxkxK7e+07t27a/r06VqxYoU+//xz/ehHP9JPfvITrVu3rs79U/0ckxIfMym1z7FDLV++XE899ZT69etX736ca60X/Xjj0JMnhn48cfTjiaMfTxz9eOLoxxNHP/7DtOp+3ESTGTx4sHnLLbdU3Q+FQmbXrl3NadOm1bn/6NGjzYsvvjjmsSFDhpg33XRTs9aZTBIds+eee87Mzs5uoeqSnyRz3rx59e7z29/+1jz++ONjHhszZox5/vnnN2NlyashY7Z48WJTkllYWNgiNbUGe/bsMSWZH374Ydx9+E6L1ZAx4zuttvbt25vPPPNMnc9xjtWtvjHjHKtWWlpqHn300eaCBQvM4cOHmxMmTIi7L+da60U/3jj05I1HP544+vHGoR9PHP1449CPJ45+vGFaez/OTPQmUllZqRUrVmjEiBFVj9lsNo0YMULLli2r8zXLli2L2V+Szj///Lj7tzWNGTNJOnDggHr27Kn8/PzD/rYPnGc/xIABA9SlSxede+65Wrp0qdXlWKq4uFiSlJOTE3cfzrVYDRkzie+0g0KhkF5++WX5fD4NHTq0zn04x2I1ZMwkzrGDbrnlFl188cW1zqG6cK61TvTjjUNP3vw4zxqPfrwa/Xji6McTQz+eOPrxxLT2fpwQvYkUFBQoFAopLy8v5vG8vLy467bt2rUrof3bmsaMWZ8+ffTss8/q9ddf1wsvvKBwOKxhw4Zp27ZtLVFyqxTvPCspKVF5eblFVSW3Ll266Mknn9TcuXM1d+5c5efn66yzztLKlSutLs0S4XBYEydO1GmnnaYTTjgh7n6p/p1WU0PHjO80ac2aNcrIyJDL5dLNN9+sefPm6bjjjqtzX86xiETGjHMs4uWXX9bKlSs1bdq0Bu3PudY60Y83Dj1586MfTxz9eCz68cTRjzcc/Xji6McT1xb6cYdlnww0wtChQ2N+uzds2DD17dtXTz31lO677z4LK0Nb0qdPH/Xp06fq/rBhw/Tdd9/pscce06xZsyyszBq33HKL1q5dqyVLllhdSqvR0DHjOy3y72316tUqLi7WnDlzNG7cOH344Ydxm1AkNmacY9LWrVs1YcIELViwIOUv4gQ0Fb5b0Nzox2PRjyeOfrzh6McTRz+emLbSjxOiN5Hc3FzZ7Xbt3r075vHdu3erc+fOdb6mc+fOCe3f1jRmzA6Vlpamk046Sd9++21zlNgmxDvPsrKylJ6eblFVrc/gwYNTsmm99dZb9dZbb+mjjz5S9+7d69031b/TDkpkzA6Vit9pTqdTvXv3liQNHDhQy5cv15///Gc99dRTtfblHItIZMwOlYrn2IoVK7Rnzx6dfPLJVY+FQiF99NFHeuKJJ+T3+2W322New7nWOtGPNw49efOjH28a9OP04w1FP54Y+vHE0Y8npq304yzn0kScTqcGDhyoRYsWVT0WDoe1aNGiuOsiDR06NGZ/SVqwYEG96yi1JY0Zs0OFQiGtWbNGXbp0aa4yW71UP8+ayurVq1PqPDNNU7feeqvmzZun999/X0ccccRhX5Pq51pjxuxQfKdF/n/A7/fX+Vyqn2Px1Ddmh0rFc+ycc87RmjVrtHr16qpt0KBBuvrqq7V69epaDbvEudZa0Y83Dj158+M8axr04/Tjh0M/3jToxxNHP16/NtOPW3ZJ0zbo5ZdfNl0ul/n888+bX331lXnjjTea7dq1M3ft2mWapmlec8015p133lm1/9KlS02Hw2E+8sgj5vr1680pU6aYaWlp5po1a6w6hBaX6Jjde++95vz5883vvvvOXLFihXnllVeabrfbXLdunVWH0OJKS0vNVatWmatWrTIlmX/84x/NVatWmZs3bzZN0zTvvPNO85prrqna//vvvzc9Ho95++23m+vXrzdnzJhh2u12891337XqEFpcomP22GOPma+99pr5zTffmGvWrDEnTJhg2mw2c+HChVYdQov7xS9+YWZnZ5sffPCBuXPnzqqtrKysah++02I1ZsxS/TvtzjvvND/88ENz48aN5pdffmneeeedpmEY5nvvvWeaJudYXRIds1Q/x+IZPny4OWHChKr7nGttB/1449CTJ4Z+PHH044mjH08c/Xji6McTRz/eNFpjP06I3sQef/xxs0ePHqbT6TQHDx5sfvrpp1XPDR8+3Bw3blzM/q+++qp5zDHHmE6n0zz++OPNt99+u4Urtl4iYzZx4sSqffPy8syLLrrIXLlypQVVW2fx4sWmpFrbwXEaN26cOXz48FqvGTBggOl0Os0jjzzSfO6551q8bislOmYPPvigedRRR5lut9vMyckxzzrrLPP999+3pniL1DVekmLOHb7TYjVmzFL9O+26664ze/bsaTqdTrNjx47mOeecU9V8mibnWF0SHbNUP8fiObRp51xrW+jHG4eevOHoxxNHP544+vHE0Y8njn48cfTjTaM19uOGaZpm089vBwAAAAAAAACg9WNNdAAAAAAAAAAA4iBEBwAAAAAAAAAgDkJ0AAAAAAAAAADiIEQHAAAAAAAAACAOQnQAAAAAAAAAAOIgRAcAAAAAAAAAIA5CdAAAAAAAAAAA4iBEBwAAAAAAAAAgDkJ0AECLMgxDr732mtVlAAAAACmJfhwAEkeIDgAp5Nprr5VhGLW2Cy64wOrSAAAAgDaPfhwAWieH1QUAAFrWBRdcoOeeey7mMZfLZVE1AAAAQGqhHweA1oeZ6ACQYlwulzp37hyztW/fXlLkTztnzpypCy+8UOnp6TryyCM1Z86cmNevWbNGP/rRj5Senq4OHTroxhtv1IEDB2L2efbZZ3X88cfL5XKpS5cuuvXWW2OeLygo0GWXXSaPx6Ojjz5ab7zxRvMeNAAAAJAk6McBoPUhRAcAxPjDH/6gK664Ql988YWuvvpqXXnllVq/fr0kyefz6fzzz1f79u21fPlyzZ49WwsXLoxpymfOnKlbbrlFN954o9asWaM33nhDvXv3jvmMe++9V6NHj9aXX36piy66SFdffbX279/foscJAAAAJCP6cQBIPoZpmqbVRQAAWsa1116rF154QW63O+bx3/3ud/rd734nwzB08803a+bMmVXPnXrqqTr55JP117/+VU8//bTuuOMObd26VV6vV5L0zjvv6Mc//rF27NihvLw8devWTePHj9f9999fZw2GYeiuu+7SfffdJynyHwIZGRn697//zVqQAAAAaNPoxwGgdWJNdABIMWeffXZMUy5JOTk5VbeHDh0a89zQoUO1evVqSdL69evVv3//qoZdkk477TSFw2Ft2LBBhmFox44dOuecc+qtoV+/flW3vV6vsrKytGfPnsYeEgAAANBq0I8DQOtDiA4AKcbr9db6c86mkp6e3qD90tLSYu4bhqFwONwcJQEAAABJhX4cAFof1kQHAMT49NNPa93v27evJKlv37764osv5PP5qp5funSpbDab+vTpo8zMTPXq1UuLFi1q0ZoBAACAtoJ+HACSDzPRASDF+P1+7dq1K+Yxh8Oh3NxcSdLs2bM1aNAgnX766XrxxRf12Wef6e9//7sk6eqrr9aUKVM0btw43XPPPdq7d69uu+02XXPNNcrLy5Mk3XPPPbr55pvVqVMnXXjhhSotLdXSpUt12223teyBAgAAAEmIfhwAWh9CdABIMe+++666dOkS81ifPn309ddfS5Luvfdevfzyy/rlL3+pLl266J///KeOO+44SZLH49H8+fM1YcIEnXLKKfJ4PLriiiv0xz/+seq9xo0bp4qKCj322GP6zW9+o9zcXI0cObLlDhAAAABIYvTjAND6GKZpmlYXAQBIDoZhaN68ebr00kutLgUAAABIOfTjAJCcWBMdAAAAAAAAAIA4CNEBAAAAAAAAAIiD5VwAAAAAAAAAAIiDmegAAAAAAAAAAMRBiA4AAAAAAAAAQByE6AAAAAAAAAAAxEGIDgAAAAAAAABAHIToAAAAAAAAAADEQYgOAAAAAAAAAEAchOgAAAAAAAAAAMRBiA4AAAAAAAAAQByE6AAAAAAAAAAAxPH/AZqGAOgcpGAJAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'params': 5675100,\n", + " 'final_train_loss': 0.14620984574235768,\n", + " 'final_val_loss': 0.13937498538926907,\n", + " 'final_accuracy': 95.52}" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 8. Conclusion and Results" + ], + "metadata": { + "id": "URFjGGKtvvIo" + } + }, + { + "cell_type": "markdown", + "source": [ + "## ๐Ÿ“Š Final Model Comparison\n", + "\n", + "| Model Variant | Trainable Parameters | Final Validation Accuracy (%) | Approx. Model Size (MB) |\n", + "|------------------------|----------------------|-------------------------------|-------------------------|\n", + "| Standard ViT (Linear) | 5,526,346 | 95.01% | 22.11 MB |\n", + "| NdLinear ViT | 5,526,444 | 95.81% | 22.11 MB |\n", + "| NdLinear + LoRA ViT | 5,675,100 | 94.86% | 22.70 MB |\n", + "\n", + "> **Note:** NdLinear preserves accuracy while offering minor compression benefits. LoRA adapters enable efficient fine-tuning at minimal additional cost.\n" + ], + "metadata": { + "id": "5vuviPfRGXMh" + } + }, + { + "cell_type": "markdown", + "source": [ + "> **Note:** In this experiment, LoRA adapters were added on top of active base weights without freezing them. \n", + "> As a result, the total parameter count slightly increased due to the additional trainable matrices (lora_A and lora_B).\n" + ], + "metadata": { + "id": "6g2jfieHGe5p" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 9. Optional Visualization of the Spectrum" + ], + "metadata": { + "id": "S3tQ1kQNwBM0" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Get weight matrix from model\n", + "W_linear = baseline_model.model.blocks[0].mlp.fc1.weight.data.cpu() # Standard Linear\n", + "W_ndlinear = ndlinear_model.model.blocks[0].mlp.fc1.weight.data.cpu() # NdLinear version\n", + "\n", + "# Compute singular values\n", + "u1, s1, v1 = torch.svd(W_linear)\n", + "u2, s2, v2 = torch.svd(W_ndlinear)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(8,5))\n", + "plt.plot(s1.numpy(), label='Standard Linear Layer')\n", + "plt.plot(s2.numpy(), label='NdLinear Layer')\n", + "plt.yscale('log')\n", + "plt.title('Singular Value Spectrum')\n", + "plt.xlabel('Singular value index')\n", + "plt.ylabel('Magnitude (log scale)')\n", + "plt.legend()\n", + "plt.show()\n" + ], + "metadata": { + "id": "YkrdySXyHcIt" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/transformers_doc/enhanced_training.ipynb b/transformers_doc/enhanced_training.ipynb new file mode 100644 index 00000000..b64e4e2b --- /dev/null +++ b/transformers_doc/enhanced_training.ipynb @@ -0,0 +1,853 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Transformers installation\n", + "! pip install transformers datasets\n", + "# To install from source instead of the last release, comment the command above and uncomment the following one.\n", + "# ! pip install git+https://github.com/huggingface/transformers.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fine-tune a pretrained model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are significant benefits to using a pretrained model. It reduces computation costs, your carbon footprint, and allows you to use state-of-the-art models without having to train one from scratch. ๐Ÿค— Transformers provides access to thousands of pretrained models for a wide range of tasks. When you use a pretrained model, you train it on a dataset specific to your task. This is known as fine-tuning, an incredibly powerful training technique. In this tutorial, you will fine-tune a pretrained model with a deep learning framework of your choice:\n", + "\n", + "* Fine-tune a pretrained model with ๐Ÿค— Transformers [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer).\n", + "* Fine-tune a pretrained model in TensorFlow with Keras.\n", + "* Fine-tune a pretrained model in native PyTorch.\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare a dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "hide_input": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#@title\n", + "from IPython.display import HTML\n", + "\n", + "HTML('')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before you can fine-tune a pretrained model, download a dataset and prepare it for training. The previous tutorial showed you how to process data for training, and now you get an opportunity to put those skills to the test!\n", + "\n", + "Begin by loading the [Yelp Reviews](https://huggingface.co/datasets/yelp_review_full) dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'label': 0,\n", + " 'text': 'My expectations for McDonalds are t rarely high. But for one to still fail so spectacularly...that takes something special!\\\\nThe cashier took my friends\\'s order, then promptly ignored me. I had to force myself in front of a cashier who opened his register to wait on the person BEHIND me. I waited over five minutes for a gigantic order that included precisely one kid\\'s meal. After watching two people who ordered after me be handed their food, I asked where mine was. The manager started yelling at the cashiers for \\\\\"serving off their orders\\\\\" when they didn\\'t have their food. But neither cashier was anywhere near those controls, and the manager was the one serving food to customers and clearing the boards.\\\\nThe manager was rude when giving me my order. She didn\\'t make sure that I had everything ON MY RECEIPT, and never even had the decency to apologize that I felt I was getting poor service.\\\\nI\\'ve eaten at various McDonalds restaurants for over 30 years. I\\'ve worked at more than one location. I expect bad days, bad moods, and the occasional mistake. But I have yet to have a decent experience at this store. It will remain a place I avoid unless someone in my party needs to avoid illness from low blood sugar. Perhaps I should go back to the racially biased service of Steak n Shake instead!'}" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from datasets import load_dataset\n", + "\n", + "dataset = load_dataset(\"yelp_review_full\")\n", + "dataset[\"train\"][100]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you now know, you need a tokenizer to process the text and include a padding and truncation strategy to handle any variable sequence lengths. To process your dataset in one step, use ๐Ÿค— Datasets [`map`](https://huggingface.co/docs/datasets/process.html#map) method to apply a preprocessing function over the entire dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoTokenizer\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(\"bert-base-cased\")\n", + "\n", + "\n", + "def tokenize_function(examples):\n", + " return tokenizer(examples[\"text\"], padding=\"max_length\", truncation=True)\n", + "\n", + "\n", + "tokenized_datasets = dataset.map(tokenize_function, batched=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you like, you can create a smaller subset of the full dataset to fine-tune on to reduce the time it takes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "small_train_dataset = tokenized_datasets[\"train\"].shuffle(seed=42).select(range(1000))\n", + "small_eval_dataset = tokenized_datasets[\"test\"].shuffle(seed=42).select(range(1000))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "hide_input": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#@title\n", + "from IPython.display import HTML\n", + "\n", + "HTML('')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "๐Ÿค— Transformers provides a [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) class optimized for training ๐Ÿค— Transformers models, making it easier to start training without manually writing your own training loop. The [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) API supports a wide range of training options and features such as logging, gradient accumulation, and mixed precision.\n", + "\n", + "Start by loading your model and specify the number of expected labels. From the Yelp Review [dataset card](https://huggingface.co/datasets/yelp_review_full#data-fields), you know there are five labels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoModelForSequenceClassification\n", + "\n", + "model = AutoModelForSequenceClassification.from_pretrained(\"bert-base-cased\", num_labels=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "You will see a warning about some of the pretrained weights not being used and some weights being randomly\n", + "initialized. Don't worry, this is completely normal! The pretrained head of the BERT model is discarded, and replaced with a randomly initialized classification head. You will fine-tune this new model head on your sequence classification task, transferring the knowledge of the pretrained model to it.\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training hyperparameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, create a [TrainingArguments](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments) class which contains all the hyperparameters you can tune as well as flags for activating different training options. For this tutorial you can start with the default training [hyperparameters](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments), but feel free to experiment with these to find your optimal settings.\n", + "\n", + "Specify where to save the checkpoints from your training:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import TrainingArguments\n", + "\n", + "training_args = TrainingArguments(output_dir=\"test_trainer\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) does not automatically evaluate model performance during training. You will need to pass [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) a function to compute and report metrics. The ๐Ÿค— Datasets library provides a simple [`accuracy`](https://huggingface.co/metrics/accuracy) function you can load with the `load_metric` (see this [tutorial](https://huggingface.co/docs/datasets/metrics.html) for more information) function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from datasets import load_metric\n", + "\n", + "metric = load_metric(\"accuracy\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Call `compute` on `metric` to calculate the accuracy of your predictions. Before passing your predictions to `compute`, you need to convert the predictions to logits (remember all ๐Ÿค— Transformers models return logits):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_metrics(eval_pred):\n", + " logits, labels = eval_pred\n", + " predictions = np.argmax(logits, axis=-1)\n", + " return metric.compute(predictions=predictions, references=labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you'd like to monitor your evaluation metrics during fine-tuning, specify the `eval_strategy` parameter in your training arguments to report the evaluation metric at the end of each epoch:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import TrainingArguments, Trainer\n", + "\n", + "training_args = TrainingArguments(output_dir=\"test_trainer\", eval_strategy=\"epoch\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Trainer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) object with your model, training arguments, training and test datasets, and evaluation function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=small_train_dataset,\n", + " eval_dataset=small_eval_dataset,\n", + " compute_metrics=compute_metrics,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then fine-tune your model by calling [train()](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer.train):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "hide_input": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#@title\n", + "from IPython.display import HTML\n", + "\n", + "HTML('')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "๐Ÿค— Transformers models also supports training in TensorFlow with the Keras API." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Convert dataset to TensorFlow format" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [DefaultDataCollator](https://huggingface.co/docs/transformers/main/en/main_classes/data_collator#transformers.DefaultDataCollator) assembles tensors into a batch for the model to train on. Make sure you specify `return_tensors` to return TensorFlow tensors:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import DefaultDataCollator\n", + "\n", + "data_collator = DefaultDataCollator(return_tensors=\"tf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "[Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) uses [DataCollatorWithPadding](https://huggingface.co/docs/transformers/main/en/main_classes/data_collator#transformers.DataCollatorWithPadding) by default so you don't need to explicitly specify a data collator.\n", + "\n", + "\n", + "\n", + "Next, convert the tokenized datasets to TensorFlow datasets with the [`to_tf_dataset`](https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.to_tf_dataset) method. Specify your inputs in `columns`, and your label in `label_cols`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tf_train_dataset = small_train_dataset.to_tf_dataset(\n", + " columns=[\"attention_mask\", \"input_ids\", \"token_type_ids\"],\n", + " label_cols=[\"labels\"],\n", + " shuffle=True,\n", + " collate_fn=data_collator,\n", + " batch_size=8,\n", + ")\n", + "\n", + "tf_validation_dataset = small_eval_dataset.to_tf_dataset(\n", + " columns=[\"attention_mask\", \"input_ids\", \"token_type_ids\"],\n", + " label_cols=[\"labels\"],\n", + " shuffle=False,\n", + " collate_fn=data_collator,\n", + " batch_size=8,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compile and fit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load a TensorFlow model with the expected number of labels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from transformers import TFAutoModelForSequenceClassification\n", + "\n", + "model = TFAutoModelForSequenceClassification.from_pretrained(\"bert-base-cased\", num_labels=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then compile and fine-tune your model with [`fit`](https://keras.io/api/models/model_training_apis/) as you would with any other Keras model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras.callbacks import EarlyStopping\n", + "\n", + "early_stopping = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=1,\n", + " restore_best_weights=True\n", + ")\n", + "\n", + "model.compile(\n", + " optimizer=tf.keras.optimizers.Adam(learning_rate=5e-5),\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=tf.metrics.SparseCategoricalAccuracy(),\n", + ")\n", + "\n", + "model.fit(\n", + " tf_train_dataset,\n", + " validation_data=tf_validation_dataset,\n", + " epochs=3,\n", + " callbacks=[early_stopping]\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train in native PyTorch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "hide_input": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#@title\n", + "from IPython.display import HTML\n", + "\n", + "HTML('')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer) takes care of the training loop and allows you to fine-tune a model in a single line of code. For users who prefer to write their own training loop, you can also fine-tune a ๐Ÿค— Transformers model in native PyTorch.\n", + "\n", + "At this point, you may need to restart your notebook or execute the following code to free some memory:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "del model\n", + "del pytorch_model\n", + "del trainer\n", + "from accelerate.utils.memory import clear_device_cache\n", + "clear_device_cache()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, manually postprocess `tokenized_dataset` to prepare it for training.\n", + "\n", + "1. Remove the `text` column because the model does not accept raw text as an input:\n", + "\n", + " ```py\n", + " >>> tokenized_datasets = tokenized_datasets.remove_columns([\"text\"])\n", + " ```\n", + "\n", + "2. Rename the `label` column to `labels` because the model expects the argument to be named `labels`:\n", + "\n", + " ```py\n", + " >>> tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n", + " ```\n", + "\n", + "3. Set the format of the dataset to return PyTorch tensors instead of lists:\n", + "\n", + " ```py\n", + " >>> tokenized_datasets.set_format(\"torch\")\n", + " ```\n", + "\n", + "Then create a smaller subset of the dataset as previously shown to speed up the fine-tuning:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "small_train_dataset = tokenized_datasets[\"train\"].shuffle(seed=42).select(range(1000))\n", + "small_eval_dataset = tokenized_datasets[\"test\"].shuffle(seed=42).select(range(1000))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DataLoader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a `DataLoader` for your training and test datasets so you can iterate over batches of data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "train_dataloader = DataLoader(small_train_dataset, shuffle=True, batch_size=8)\n", + "eval_dataloader = DataLoader(small_eval_dataset, batch_size=8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load your model with the number of expected labels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoModelForSequenceClassification\n", + "\n", + "model = AutoModelForSequenceClassification.from_pretrained(\"bert-base-cased\", num_labels=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optimizer and learning rate scheduler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create an optimizer and learning rate scheduler to fine-tune the model. Let's use the [`AdamW`](https://pytorch.org/docs/stable/generated/torch.optim.AdamW.html) optimizer from PyTorch:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.optim import AdamW\n", + "\n", + "optimizer = AdamW(model.parameters(), lr=5e-5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create the default learning rate scheduler from [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import get_scheduler\n", + "\n", + "num_epochs = 3\n", + "num_training_steps = num_epochs * len(train_dataloader)\n", + "lr_scheduler = get_scheduler(\n", + " name=\"linear\", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, specify `device` to use a GPU if you have access to one. Otherwise, training on a CPU may take several hours instead of a couple of minutes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from accelerate.test_utils.testing import get_backend\n", + "\n", + "device, _, _ = get_backend()\n", + "model.to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Get free access to a cloud GPU if you don't have one with a hosted notebook like [Colaboratory](https://colab.research.google.com/) or [SageMaker StudioLab](https://studiolab.sagemaker.aws/).\n", + "\n", + "\n", + "\n", + "Great, now you are ready to train! ๐Ÿฅณ" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To keep track of your training progress, use the [tqdm](https://tqdm.github.io/) library to add a progress bar over the number of training steps:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.auto import tqdm\n", + "\n", + "progress_bar = tqdm(range(num_training_steps))\n", + "\n", + "model.train()\n", + "for epoch in range(num_epochs):\n", + " for batch in train_dataloader:\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " loss.backward()\n", + "\n", + " optimizer.step()\n", + " lr_scheduler.step()\n", + " optimizer.zero_grad()\n", + " progress_bar.update(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just like how you need to add an evaluation function to [Trainer](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.Trainer), you need to do the same when you write your own training loop. But instead of calculating and reporting the metric at the end of each epoch, this time you will accumulate all the batches with [`add_batch`](https://huggingface.co/docs/datasets/package_reference/main_classes.html?highlight=add_batch#datasets.Metric.add_batch) and calculate the metric at the very end." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "metric = load_metric(\"accuracy\")\n", + "model.eval()\n", + "for batch in eval_dataloader:\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " with torch.no_grad():\n", + " outputs = model(**batch)\n", + "\n", + " logits = outputs.logits\n", + " predictions = torch.argmax(logits, dim=-1)\n", + " metric.add_batch(predictions=predictions, references=batch[\"labels\"])\n", + "\n", + "metric.compute()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Additional resources" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more fine-tuning examples, refer to:\n", + "\n", + "- [๐Ÿค— Transformers Examples](https://github.com/huggingface/transformers/tree/main/examples) includes scripts\n", + " to train common NLP tasks in PyTorch and TensorFlow.\n", + "\n", + "- [๐Ÿค— Transformers Notebooks](https://huggingface.co/docs/transformers/main/en/notebooks) contains various notebooks on how to fine-tune a model for specific tasks in PyTorch and TensorFlow." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}