{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":3649,"databundleVersionId":46718,"sourceType":"competition"}],"dockerImageVersionId":30787,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-11-15T07:48:48.132468Z","iopub.execute_input":"2024-11-15T07:48:48.132968Z","iopub.status.idle":"2024-11-15T07:48:49.125284Z","shell.execute_reply.started":"2024-11-15T07:48:48.132933Z","shell.execute_reply":"2024-11-15T07:48:49.12421Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"/kaggle/input/cifar-10/trainLabels.csv\n/kaggle/input/cifar-10/sampleSubmission.csv\n/kaggle/input/cifar-10/test.7z\n/kaggle/input/cifar-10/train.7z\n","output_type":"stream"}]},{"cell_type":"code","source":"import torchvision\nimport torchvision.transforms as transforms\nfrom torch.utils.data import DataLoader\n\n# Custom CutOut transformation\nclass CutOut(object):\n    def __init__(self, n_holes, length):\n        self.n_holes = n_holes\n        self.length = length\n\n    def __call__(self, img):\n        h, w = img.size(1), img.size(2)\n        mask = np.ones((h, w), np.float32)\n\n        for n in range(self.n_holes):\n            y = random.randint(0, h)\n            x = random.randint(0, w)\n\n            y1 = np.clip(y - self.length // 2, 0, h)\n            y2 = np.clip(y + self.length // 2, 0, h)\n            x1 = np.clip(x - self.length // 2, 0, w)\n            x2 = np.clip(x + self.length // 2, 0, w)\n\n            mask[y1:y2, x1:x2] = 0.\n\n        mask = torch.from_numpy(mask).expand_as(img)\n        img = img * mask\n        return img\n\n# Transformations for training and testing\ntransform_train = transforms.Compose([\n    transforms.RandomHorizontalFlip(p=0.5),\n    transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1)),\n    transforms.RandomCrop(32, padding=4),\n    transforms.ToTensor(),\n    transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\n    CutOut(n_holes=1, length=8),\n])\n\ntransform_test = transforms.Compose([\n    transforms.Resize((32, 32)),\n    transforms.ToTensor(),\n    transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\n])\n\n# Load CIFAR-10 dataset\ntrain_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\ntest_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n\n# Create data loaders\ntrain_loader = DataLoader(train_dataset, batch_size=256, shuffle=True, num_workers=2)\ntest_loader = DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)\n\nprint(\"Data loaders created successfully!\")\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T07:50:24.698331Z","iopub.execute_input":"2024-11-15T07:50:24.699335Z","iopub.status.idle":"2024-11-15T07:50:35.269596Z","shell.execute_reply.started":"2024-11-15T07:50:24.699288Z","shell.execute_reply":"2024-11-15T07:50:35.268517Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 170498071/170498071 [00:03<00:00, 43616316.68it/s]\n","output_type":"stream"},{"name":"stdout","text":"Extracting ./data/cifar-10-python.tar.gz to ./data\nFiles already downloaded and verified\nData loaders created successfully!\n","output_type":"stream"}]},{"cell_type":"code","source":"!pip install torch torchvision wandb einops\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T07:51:45.905142Z","iopub.execute_input":"2024-11-15T07:51:45.905847Z","iopub.status.idle":"2024-11-15T07:51:59.377046Z","shell.execute_reply.started":"2024-11-15T07:51:45.905786Z","shell.execute_reply":"2024-11-15T07:51:59.375688Z"},"trusted":true},"execution_count":3,"outputs":[{"name":"stdout","text":"Requirement already satisfied: torch in /opt/conda/lib/python3.10/site-packages (2.4.0)\nRequirement already satisfied: torchvision in /opt/conda/lib/python3.10/site-packages (0.19.0)\nRequirement already satisfied: wandb in /opt/conda/lib/python3.10/site-packages (0.18.3)\nCollecting einops\n  Downloading einops-0.8.0-py3-none-any.whl.metadata (12 kB)\nRequirement already satisfied: filelock in /opt/conda/lib/python3.10/site-packages (from torch) (3.15.1)\nRequirement already satisfied: typing-extensions>=4.8.0 in /opt/conda/lib/python3.10/site-packages (from torch) (4.12.2)\nRequirement already satisfied: sympy in /opt/conda/lib/python3.10/site-packages (from torch) (1.13.3)\nRequirement already satisfied: networkx in /opt/conda/lib/python3.10/site-packages (from torch) (3.3)\nRequirement already satisfied: jinja2 in /opt/conda/lib/python3.10/site-packages (from torch) (3.1.4)\nRequirement already satisfied: fsspec in /opt/conda/lib/python3.10/site-packages (from torch) (2024.6.1)\nRequirement already satisfied: numpy in /opt/conda/lib/python3.10/site-packages (from torchvision) (1.26.4)\nRequirement already satisfied: pillow!=8.3.*,>=5.3.0 in /opt/conda/lib/python3.10/site-packages (from torchvision) (10.3.0)\nRequirement already satisfied: click!=8.0.0,>=7.1 in /opt/conda/lib/python3.10/site-packages (from wandb) (8.1.7)\nRequirement already satisfied: docker-pycreds>=0.4.0 in /opt/conda/lib/python3.10/site-packages (from wandb) (0.4.0)\nRequirement already satisfied: gitpython!=3.1.29,>=1.0.0 in /opt/conda/lib/python3.10/site-packages (from wandb) (3.1.43)\nRequirement already satisfied: platformdirs in /opt/conda/lib/python3.10/site-packages (from wandb) (3.11.0)\nRequirement already satisfied: protobuf!=4.21.0,!=5.28.0,<6,>=3.19.0 in /opt/conda/lib/python3.10/site-packages (from wandb) (3.20.3)\nRequirement already satisfied: psutil>=5.0.0 in /opt/conda/lib/python3.10/site-packages (from wandb) (5.9.3)\nRequirement already satisfied: pyyaml in /opt/conda/lib/python3.10/site-packages (from wandb) (6.0.2)\nRequirement already satisfied: requests<3,>=2.0.0 in /opt/conda/lib/python3.10/site-packages (from wandb) (2.32.3)\nRequirement already satisfied: sentry-sdk>=1.0.0 in /opt/conda/lib/python3.10/site-packages (from wandb) (2.15.0)\nRequirement already satisfied: setproctitle in /opt/conda/lib/python3.10/site-packages (from wandb) (1.3.3)\nRequirement already satisfied: setuptools in /opt/conda/lib/python3.10/site-packages (from wandb) (70.0.0)\nRequirement already satisfied: six>=1.4.0 in /opt/conda/lib/python3.10/site-packages (from docker-pycreds>=0.4.0->wandb) (1.16.0)\nRequirement already satisfied: gitdb<5,>=4.0.1 in /opt/conda/lib/python3.10/site-packages (from gitpython!=3.1.29,>=1.0.0->wandb) (4.0.11)\nRequirement already satisfied: charset-normalizer<4,>=2 in /opt/conda/lib/python3.10/site-packages (from requests<3,>=2.0.0->wandb) (3.3.2)\nRequirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.10/site-packages (from requests<3,>=2.0.0->wandb) (3.7)\nRequirement already satisfied: urllib3<3,>=1.21.1 in /opt/conda/lib/python3.10/site-packages (from requests<3,>=2.0.0->wandb) (1.26.18)\nRequirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.10/site-packages (from requests<3,>=2.0.0->wandb) (2024.8.30)\nRequirement already satisfied: MarkupSafe>=2.0 in /opt/conda/lib/python3.10/site-packages (from jinja2->torch) (2.1.5)\nRequirement already satisfied: mpmath<1.4,>=1.1.0 in /opt/conda/lib/python3.10/site-packages (from sympy->torch) (1.3.0)\nRequirement already satisfied: smmap<6,>=3.0.1 in /opt/conda/lib/python3.10/site-packages (from gitdb<5,>=4.0.1->gitpython!=3.1.29,>=1.0.0->wandb) (5.0.1)\nDownloading einops-0.8.0-py3-none-any.whl (43 kB)\n\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.2/43.2 kB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n\u001b[?25hInstalling collected packages: einops\nSuccessfully installed einops-0.8.0\n","output_type":"stream"}]},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torchvision\nimport torchvision.transforms as transforms\nfrom torch.utils.data import DataLoader\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\nimport wandb\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# Initialize WandB\nwandb.init(project=\"vit-cifar10\", config={\n    \"epochs\": 25,\n    \"batch_size\": 128,\n    \"lr\": 1e-3,\n    \"patch_size\": 8,\n    \"num_heads\": 8,\n    \"num_layers\": 6,\n    \"mlp_dim\": 512,\n    \"dropout_rate\": 0.3,\n    \"num_classes\": 10,\n})\n\nconfig = wandb.config\n\n# Data Augmentation for CIFAR-10\ntransform_train = transforms.Compose([\n    transforms.RandomHorizontalFlip(),\n    transforms.RandomCrop(32, padding=4),\n    transforms.RandomRotation(15),\n    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n])\n\ntransform_test = transforms.Compose([\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n])\n\ntrain_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\ntest_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n\ntrain_loader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True, num_workers=4, pin_memory=True)\ntest_loader = DataLoader(test_dataset, batch_size=config.batch_size, shuffle=False, num_workers=4, pin_memory=True)\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n# ViT Model\nclass VisionTransformer(nn.Module):\n    def __init__(self, patch_size, num_heads, num_layers, mlp_dim, num_classes, dropout_rate):\n        super(VisionTransformer, self).__init__()\n\n        self.patch_size = patch_size\n        self.num_classes = num_classes\n        self.embed_dim = 128  # Lowered embedding size for CIFAR-10\n        self.num_heads = num_heads\n        self.num_layers = num_layers\n\n        # Adjusted patch embedding size for better fit to CIFAR-10\n        self.patch_embed = nn.Conv2d(3, self.embed_dim, kernel_size=patch_size, stride=patch_size)\n        \n        # Positional encoding\n        self.positional_encoding = nn.Parameter(torch.randn(1, (32 // patch_size) ** 2, self.embed_dim))\n\n        # Transformer layers\n        self.encoder_layers = nn.ModuleList([\n            nn.TransformerEncoderLayer(d_model=self.embed_dim, nhead=self.num_heads, dim_feedforward=mlp_dim, dropout=dropout_rate)\n            for _ in range(self.num_layers)\n        ])\n        \n        self.fc = nn.Linear(self.embed_dim, self.num_classes)\n\n    def forward(self, x):\n        # Patch embedding\n        x = self.patch_embed(x)  # (batch_size, embed_dim, patches, patches)\n        x = x.flatten(2).transpose(1, 2)  # (batch_size, patches*patches, embed_dim)\n        \n        # Add positional encoding\n        x = x + self.positional_encoding\n        \n        # Transformer encoder layers\n        for layer in self.encoder_layers:\n            x = layer(x)\n        \n        # Classification head: global average pooling\n        x = x.mean(dim=1)  # (batch_size, embed_dim)\n        x = self.fc(x)  # (batch_size, num_classes)\n        \n        return x\n\n# Initialize the model with adjusted parameters\nmodel = VisionTransformer(\n    patch_size=4,  # Reduced patch size for better feature extraction\n    num_heads=8,\n    num_layers=4,  # Reduced transformer layers\n    mlp_dim=512,\n    num_classes=config.num_classes,\n    dropout_rate=config.dropout_rate\n).to(device)\n\n# Adjusted learning rate for better convergence\noptimizer = optim.AdamW(model.parameters(), lr=1e-4)  # AdamW is often more stable for transformers\nscheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)\ncriterion = nn.CrossEntropyLoss()\n\n# Training and Evaluation Functions\ndef train(model, loader):\n    model.train()\n    running_loss = 0\n    all_labels = []\n    all_preds = []\n\n    for inputs, labels in loader:\n        inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n        optimizer.zero_grad()\n        outputs = model(inputs)\n        loss = criterion(outputs, labels)\n        loss.backward()\n        optimizer.step()\n\n        running_loss += loss.item()\n        all_labels.extend(labels.cpu().numpy())\n        all_preds.extend(outputs.argmax(dim=1).cpu().numpy())\n\n    acc = accuracy_score(all_labels, all_preds) * 100\n    return running_loss / len(loader), acc\n\n\ndef test(model, loader):\n    model.eval()\n    running_loss = 0\n    all_labels = []\n    all_preds = []\n\n    with torch.no_grad():\n        for inputs, labels in loader:\n            inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n            outputs = model(inputs)\n            loss = criterion(outputs, labels)\n            running_loss += loss.item()\n            all_labels.extend(labels.cpu().numpy())\n            all_preds.extend(outputs.argmax(dim=1).cpu().numpy())\n\n    acc = accuracy_score(all_labels, all_preds) * 100\n    precision = precision_score(all_labels, all_preds, average='macro')\n    recall = recall_score(all_labels, all_preds, average='macro')\n    f1 = f1_score(all_labels, all_preds, average='macro')\n    return running_loss / len(loader), acc, precision, recall, f1\n\n# Visualizing Correct and Incorrect Classifications\ndef visualize_classification_results(model, test_loader, device, num_images=10):\n    model.eval()  # Set model to evaluation mode\n    \n    correct_images = []  # To store correctly classified images\n    incorrect_images = []  # To store incorrectly classified images\n    correct_labels = []  # True labels for correct classifications\n    incorrect_labels = []  # True labels for incorrect classifications\n    incorrect_preds = []  # Predicted labels for incorrect classifications\n\n    # Loop through the test loader and collect predictions and true labels\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            _, preds = torch.max(outputs, 1)\n            \n            # Compare predictions with true labels\n            for i in range(len(images)):\n                if preds[i] == labels[i]:\n                    correct_images.append(images[i])\n                    correct_labels.append(labels[i].item())\n                else:\n                    incorrect_images.append(images[i])\n                    incorrect_labels.append(labels[i].item())\n                    incorrect_preds.append(preds[i].item())\n\n            # Break after collecting enough samples\n            if len(correct_images) >= num_images // 2 and len(incorrect_images) >= num_images // 2:\n                break\n\n    # Create subplots for visualization\n    fig, axes = plt.subplots(2, num_images // 2, figsize=(15, 8))\n    \n    # Visualize correctly classified images\n    for i in range(len(correct_images)):\n        ax = axes[0, i]\n        ax.imshow(correct_images[i].cpu().numpy().transpose(1, 2, 0))\n        ax.axis('off')\n        ax.set_title(f\"True: {correct_labels[i]}\")\n\n    # Visualize incorrectly classified images\n    for i in range(len(incorrect_images)):\n        ax = axes[1, i]\n        ax.imshow(incorrect_images[i].cpu().numpy().transpose(1, 2, 0))\n        ax.axis('off')\n        ax.set_title(f\"True: {incorrect_labels[i]}, Pred: {incorrect_preds[i]}\")\n\n    plt.tight_layout()\n    plt.show()\n\n# Train and evaluate the model\nfor epoch in range(config.epochs):\n    train_loss, train_acc = train(model, train_loader)\n    test_loss, test_acc, test_precision, test_recall, test_f1 = test(model, test_loader)\n    scheduler.step()\n\n    # Log metrics to WandB\n    wandb.log({\n        \"epoch\": epoch + 1,\n        \"train_loss\": train_loss,\n        \"train_accuracy\": train_acc,\n        \"test_loss\": test_loss,\n        \"test_accuracy\": test_acc,\n        \"test_precision\": test_precision,\n        \"test_recall\": test_recall,\n        \"test_f1\": test_f1\n    })\n\n    print(f\"Epoch [{epoch + 1}/{config.epochs}], Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%, \"\n          f\"Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.2f}%, Precision: {test_precision:.4f}, \"\n          f\"Recall: {test_recall:.4f}, F1: {test_f1:.4f}\")\n\n# Save the model\ntorch.save(model.state_dict(), 'ViT.model')\n\n# Visualize results\nvisualize_classification_results(model, test_loader, device)\n\nwandb.finish()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T11:22:10.887708Z","iopub.execute_input":"2024-11-15T11:22:10.888106Z","iopub.status.idle":"2024-11-15T11:33:00.526316Z","shell.execute_reply.started":"2024-11-15T11:22:10.888068Z","shell.execute_reply":"2024-11-15T11:33:00.524922Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stderr","text":"\u001b[34m\u001b[1mwandb\u001b[0m: Using wandb-core as the SDK backend. Please refer to https://wandb.me/wandb-core for more information.\n\u001b[34m\u001b[1mwandb\u001b[0m: Logging into wandb.ai. (Learn how to deploy a W&B server locally: https://wandb.me/wandb-server)\n\u001b[34m\u001b[1mwandb\u001b[0m: You can find your API key in your browser here: https://wandb.ai/authorize\n\u001b[34m\u001b[1mwandb\u001b[0m: Paste an API key from your profile and hit enter, or press ctrl+c to quit:","output_type":"stream"},{"output_type":"stream","name":"stdin","text":"  ········································\n"},{"name":"stderr","text":"\u001b[34m\u001b[1mwandb\u001b[0m: Appending key for api.wandb.ai to your netrc file: /root/.netrc\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"VBox(children=(Label(value='Waiting for wandb.init()...\\r'), FloatProgress(value=0.011112611844444271, max=1.0…","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"fe5a1ea82532404caa1ca9eb7bc02f51"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Tracking run with wandb version 0.18.3"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Run data is saved locally in <code>/kaggle/working/wandb/run-20241115_112236-attrjobo</code>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Syncing run <strong><a href='https://wandb.ai/i210325-nuces/vit-cifar10/runs/attrjobo' target=\"_blank\">warm-forest-3</a></strong> to <a href='https://wandb.ai/i210325-nuces/vit-cifar10' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View project at <a href='https://wandb.ai/i210325-nuces/vit-cifar10' target=\"_blank\">https://wandb.ai/i210325-nuces/vit-cifar10</a>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run at <a href='https://wandb.ai/i210325-nuces/vit-cifar10/runs/attrjobo' target=\"_blank\">https://wandb.ai/i210325-nuces/vit-cifar10/runs/attrjobo</a>"},"metadata":{}},{"name":"stdout","text":"Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 170498071/170498071 [00:03<00:00, 46893726.08it/s]\n","output_type":"stream"},{"name":"stdout","text":"Extracting ./data/cifar-10-python.tar.gz to ./data\nFiles already downloaded and verified\nEpoch [1/25], Train Loss: 2.0824, Train Acc: 21.42%, Test Loss: 1.9723, Test Acc: 28.06%, Precision: 0.2974, Recall: 0.2806, F1: 0.2493\nEpoch [2/25], Train Loss: 1.9522, Train Acc: 27.75%, Test Loss: 1.8598, Test Acc: 32.57%, Precision: 0.3330, Recall: 0.3257, F1: 0.3201\nEpoch [3/25], Train Loss: 1.8782, Train Acc: 31.22%, Test Loss: 1.7846, Test Acc: 34.54%, Precision: 0.3394, Recall: 0.3454, F1: 0.3239\nEpoch [4/25], Train Loss: 1.8299, Train Acc: 33.46%, Test Loss: 1.7430, Test Acc: 36.92%, Precision: 0.3722, Recall: 0.3692, F1: 0.3591\nEpoch [5/25], Train Loss: 1.7893, Train Acc: 34.66%, Test Loss: 1.6710, Test Acc: 39.58%, Precision: 0.3939, Recall: 0.3958, F1: 0.3764\nEpoch [6/25], Train Loss: 1.7471, Train Acc: 36.38%, Test Loss: 1.6383, Test Acc: 40.73%, Precision: 0.4044, Recall: 0.4073, F1: 0.3977\nEpoch [7/25], Train Loss: 1.7086, Train Acc: 37.92%, Test Loss: 1.6305, Test Acc: 41.45%, Precision: 0.4088, Recall: 0.4145, F1: 0.3984\nEpoch [8/25], Train Loss: 1.6868, Train Acc: 38.48%, Test Loss: 1.5863, Test Acc: 42.40%, Precision: 0.4182, Recall: 0.4240, F1: 0.4077\nEpoch [9/25], Train Loss: 1.6611, Train Acc: 39.28%, Test Loss: 1.5585, Test Acc: 43.99%, Precision: 0.4348, Recall: 0.4399, F1: 0.4248\nEpoch [10/25], Train Loss: 1.6431, Train Acc: 39.65%, Test Loss: 1.5271, Test Acc: 45.00%, Precision: 0.4393, Recall: 0.4500, F1: 0.4388\nEpoch [11/25], Train Loss: 1.6133, Train Acc: 41.16%, Test Loss: 1.5237, Test Acc: 44.56%, Precision: 0.4349, Recall: 0.4456, F1: 0.4302\nEpoch [12/25], Train Loss: 1.6129, Train Acc: 41.01%, Test Loss: 1.5140, Test Acc: 45.01%, Precision: 0.4415, Recall: 0.4501, F1: 0.4367\nEpoch [13/25], Train Loss: 1.6074, Train Acc: 41.31%, Test Loss: 1.5151, Test Acc: 45.10%, Precision: 0.4421, Recall: 0.4510, F1: 0.4364\nEpoch [14/25], Train Loss: 1.6085, Train Acc: 41.46%, Test Loss: 1.5118, Test Acc: 45.36%, Precision: 0.4453, Recall: 0.4536, F1: 0.4413\nEpoch [15/25], Train Loss: 1.6048, Train Acc: 41.46%, Test Loss: 1.5056, Test Acc: 45.47%, Precision: 0.4467, Recall: 0.4547, F1: 0.4413\nEpoch [16/25], Train Loss: 1.6004, Train Acc: 41.92%, Test Loss: 1.5049, Test Acc: 45.38%, Precision: 0.4457, Recall: 0.4538, F1: 0.4389\nEpoch [17/25], Train Loss: 1.6041, Train Acc: 41.43%, Test Loss: 1.5090, Test Acc: 45.54%, Precision: 0.4453, Recall: 0.4554, F1: 0.4397\nEpoch [18/25], Train Loss: 1.6007, Train Acc: 41.74%, Test Loss: 1.5041, Test Acc: 45.38%, Precision: 0.4481, Recall: 0.4538, F1: 0.4399\nEpoch [19/25], Train Loss: 1.5966, Train Acc: 41.80%, Test Loss: 1.4974, Test Acc: 45.65%, Precision: 0.4491, Recall: 0.4565, F1: 0.4433\nEpoch [20/25], Train Loss: 1.5938, Train Acc: 41.87%, Test Loss: 1.5045, Test Acc: 45.50%, Precision: 0.4483, Recall: 0.4550, F1: 0.4410\nEpoch [21/25], Train Loss: 1.5898, Train Acc: 42.06%, Test Loss: 1.5006, Test Acc: 45.60%, Precision: 0.4484, Recall: 0.4560, F1: 0.4422\nEpoch [22/25], Train Loss: 1.5950, Train Acc: 41.77%, Test Loss: 1.4993, Test Acc: 45.61%, Precision: 0.4484, Recall: 0.4561, F1: 0.4424\nEpoch [23/25], Train Loss: 1.5897, Train Acc: 41.74%, Test Loss: 1.4984, Test Acc: 45.62%, Precision: 0.4478, Recall: 0.4562, F1: 0.4423\nEpoch [24/25], Train Loss: 1.5931, Train Acc: 41.95%, Test Loss: 1.4987, Test Acc: 45.62%, Precision: 0.4478, Recall: 0.4562, F1: 0.4422\nEpoch [25/25], Train Loss: 1.5919, Train Acc: 42.00%, Test Loss: 1.4978, Test Acc: 45.62%, Precision: 0.4484, Recall: 0.4562, F1: 0.4425\n","output_type":"stream"},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)","Cell \u001b[0;32mIn[2], line 229\u001b[0m\n\u001b[1;32m    226\u001b[0m torch\u001b[38;5;241m.\u001b[39msave(model\u001b[38;5;241m.\u001b[39mstate_dict(), \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mViT.model\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m    228\u001b[0m \u001b[38;5;66;03m# Visualize results\u001b[39;00m\n\u001b[0;32m--> 229\u001b[0m \u001b[43mvisualize_classification_results\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    231\u001b[0m wandb\u001b[38;5;241m.\u001b[39mfinish()\n","Cell \u001b[0;32mIn[2], line 188\u001b[0m, in \u001b[0;36mvisualize_classification_results\u001b[0;34m(model, test_loader, device, num_images)\u001b[0m\n\u001b[1;32m    186\u001b[0m \u001b[38;5;66;03m# Visualize correctly classified images\u001b[39;00m\n\u001b[1;32m    187\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(correct_images)):\n\u001b[0;32m--> 188\u001b[0m     ax \u001b[38;5;241m=\u001b[39m \u001b[43maxes\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m    189\u001b[0m     ax\u001b[38;5;241m.\u001b[39mimshow(correct_images[i]\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy()\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0\u001b[39m))\n\u001b[1;32m    190\u001b[0m     ax\u001b[38;5;241m.\u001b[39maxis(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moff\u001b[39m\u001b[38;5;124m'\u001b[39m)\n","\u001b[0;31mIndexError\u001b[0m: index 5 is out of bounds for axis 1 with size 5"],"ename":"IndexError","evalue":"index 5 is out of bounds for axis 1 with size 5","output_type":"error"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1500x800 with 10 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport torch\n\n# Function to visualize a batch of images\ndef visualize_classification_results(model, test_loader, device, num_images=10):\n    model.eval()  # Set model to evaluation mode\n    \n    correct_images = []  # To store correctly classified images\n    incorrect_images = []  # To store incorrectly classified images\n    correct_labels = []  # True labels for correct classifications\n    incorrect_labels = []  # True labels for incorrect classifications\n    incorrect_preds = []  # Predicted labels for incorrect classifications\n\n    # Loop through the test loader and collect predictions and true labels\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            _, preds = torch.max(outputs, 1)\n            \n            # Compare predictions with true labels\n            for i in range(len(images)):\n                if preds[i] == labels[i]:\n                    correct_images.append(images[i])\n                    correct_labels.append(labels[i].item())\n                else:\n                    incorrect_images.append(images[i])\n                    incorrect_labels.append(labels[i].item())\n                    incorrect_preds.append(preds[i].item())\n\n            # Break after collecting enough samples\n            if len(correct_images) >= num_images // 2 and len(incorrect_images) >= num_images // 2:\n                break\n\n    # Adjust the number of images to show in the grid\n    total_images = min(len(correct_images), len(incorrect_images), num_images // 2)\n\n    # Create subplots for visualization\n    fig, axes = plt.subplots(2, total_images, figsize=(15, 8))\n    \n    # Visualize correctly classified images\n    for i in range(total_images):\n        ax = axes[0, i]\n        ax.imshow(correct_images[i].cpu().numpy().transpose(1, 2, 0))\n        ax.axis('off')\n        ax.set_title(f\"True: {correct_labels[i]}\")\n\n    # Visualize incorrectly classified images\n    for i in range(total_images):\n        ax = axes[1, i]\n        ax.imshow(incorrect_images[i].cpu().numpy().transpose(1, 2, 0))\n        ax.axis('off')\n        ax.set_title(f\"True: {incorrect_labels[i]}, Pred: {incorrect_preds[i]}\")\n\n    plt.tight_layout()\n    plt.show()\n\n# Call the visualization function\nvisualize_classification_results(model, test_loader, device, num_images=10)\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T11:33:52.472993Z","iopub.execute_input":"2024-11-15T11:33:52.473957Z","iopub.status.idle":"2024-11-15T11:33:53.701069Z","shell.execute_reply.started":"2024-11-15T11:33:52.473907Z","shell.execute_reply":"2024-11-15T11:33:53.700106Z"},"trusted":true},"execution_count":4,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1500x800 with 10 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAABdIAAAKwCAYAAACcbY14AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACQaklEQVR4nOz9f5znc70//t/ntOPHiClGGbFixJKtLMfytmIVp6JsHfohx4/ysx+q40dUhH7pBxVJSflRqVAttR1RrcPKWUfrU6ta1VJDhmOUIZNMvL5/9OW0h573u53X7szsXq+XS3+Yx23vz8fr9Xo+H8/H895rZztarVYrAAAAAACAJ/VPYz0BAAAAAAAYzzTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUb6SqKjo6P0v6uvvnqsp/qk3vWud8W0adNi7bXXjq6urthiiy3ipJNOij/96U9jPTWgTSb6OvXQQw/FRz7ykdhyyy2jq6srnvOc58Q+++wTP//5z8d6akAbWKOA8Wyir1EREQ888EAce+yxsfHGG8eqq64az3nOc2LvvfeO4eHhsZ4aMEoTfY36xje+Efvtt18873nPi46Ojthll13GekqMkUljPQGWjy9/+ctL/PeFF14YV1111RN+vsUWWyzPaZX993//d+y0005x0EEHxWqrrRY33XRTnHrqqfGDH/wgrrnmmvinf/L/CcFEN9HXqTe+8Y1x+eWXxyGHHBLTpk2LO++8M84666zYYYcdYuHChbHRRhuN9RSBUbBGAePZRF+jhoaGYuedd4477rgjDj300Nh0003jnnvuiWuvvTb+8pe/RFdX11hPERiFib5GnX322fGTn/wk/vmf/znuvffesZ4OY6ij1Wq1xnoSLH9ve9vb4qyzzors4x8eHh63m5bTTjstjj766Lj++utj++23H+vpAG02kdap3//+97HBBhvE0UcfHR//+Mcf//ncuXNj1113jdNPPz3e9a53jeEMgXazRgHj2URaoyIi3vKWt8TXvva1WLBgQWy88cZjPR1gGZtoa9Ttt98ez3nOc+Kf/umfYquttoqenp5x++15li1f4+Vxu+yyS2y11Vbxk5/8JF784hdHV1dXvOc974mIv/01nJNOOukJf+a5z31uHHjggUv87L777ot3vvOdseGGG8aqq64am266aXz0ox+NRx99dIncwMBALFq0KEZGRpZqvs997nMfPx6wchiv69QDDzwQERHPfvazl/h5b29vRESsvvrqT+VlAhOUNQoYz8brGnXffffFeeedF4ceemhsvPHG8fDDD8df/vKXUb1WYOIZr2tURMSGG27oNyEQEX61C//HvffeGy9/+cvj9a9/fey3335PeODKDA8Px8477xy///3v47DDDovJkyfHj3/84zj++ONjYGAgPvWpTz2ePf744+OCCy6I22677fGmeJO//vWvcd9998XDDz8cN998c7zvfe+LNddcM7bbbrun+CqBiWw8rlN9fX2xwQYbxGmnnRabb755bL311nHnnXc+/ns+X//61y/lqwUmGmsUMJ6NxzVq3rx58dBDD8Wmm24ae++9d8yePTseffTR2GGHHeKss86KF73oRUv3YoEJZzyuUfD3NNJZwl133RWf+9zn4rDDDluqP3/66afH4sWL46abbornPe95ERFx2GGHxfrrrx8f//jH46ijjooNN9xwqWrfeOONscMOOzz+35tvvnlcfvnlsfbaay9VPWBiGo/rVGdnZ3zzm9+MfffdN171qlc9/vNtttkmfvzjH8cznvGMpZorMPFYo4DxbDyuUb/+9a8j4m9Nrb6+vrjwwgtjaGgoTj755Nh1113j5z//+eN/gwZYsY3HNQr+nr+XwBJWXXXVOOigg5b6z19yySWx0047xTOf+cwYHBx8/H8vfelL45FHHolrrrnm8ez5558frVar/P/8bbnllnHVVVfF7Nmz49hjj4011lgj/vSnPy31XIGJabyuU8985jPjRS96URx33HExe/bs+MQnPhG//e1vY5999omHHnpoqecLTCzWKGA8G49r1GPPdB0dHfHDH/4w9t133zjiiCNi9uzZ8cc//jHOOuuspZ4vMLGMxzUK/p5vpLOE5zznObHKKqss9Z//9a9/HT/72c9i3XXXfdLx//mf/1nq2muttVa89KUvjYiIvfbaKy666KLYa6+9YsGCBfHCF75wqesCE8t4XKeGhoZip512imOOOSaOOuqox3++7bbbxi677BLnnXdeHHHEEUs9Z2DisEYB49l4XKMe+3caXvnKV8bTn/70x3++/fbbx8Ybbxw//vGPl26ywIQzHtco+Hsa6Szhqf5jU4888sgS//3oo4/GbrvtFscee+yT5jfbbLOlntv/9ZrXvCb+7d/+Lb7+9a9rpMNKZDyuU9/85jfj7rvvXuJXJkRE7LzzzrHWWmvFddddp0kFKwlrFDCejcc1av3114+IJ/6DyBERz3rWs+KPf/zjU64JTEzjcY2Cv6eRTskzn/nMuO+++5b42cMPPxwDAwNL/Kyvry/+9Kc/Pf7N8WXpL3/5Szz66KMxNDS0zI8FjH9juU7dfffdEfHEjVyr1YpHHnkk/vrXv7btWMDEZI0CxrOxXKO22WabiIj4/e9//4SxO++8M6ZMmdK2YwET03jsSbFy8jvSKenr61vid0lFRJxzzjlPeCB77WtfG9dff318//vff0KN++67b4kHtYGBgVi0aFGMjIw0Hvu+++570sy5554bEX/7a8kAY7lOPfbNhq9//etL/Pzyyy+PBx98MLbeeuun9FqAFY81ChjPxnKN2nzzzeOFL3xhXHbZZTE4OPj4z6+88sq4/fbbY7fddlualwSsQMZyjYK/5xvplBx88MFx+OGHx7/+67/GbrvtFj/96U/j+9//fvT09CyRO+aYY+Lyyy+PPffcMw488MDYZptt4sEHH4yFCxfGpZdeGr/97W8f/zPHH398XHDBBXHbbbc1/uMOV199dRx55JGx9957x/Oe97x4+OGH49prr41vfetbse2228Z+++23LF86MEGM5Tr1yle+Mp7//OfHKaecEr/73e9i++23j9/85jfxmc98Jnp7e+PNb37zsnzpwARgjQLGs7FcoyIiPvnJT8Zuu+0WM2bMiMMOOyyGhobi9NNPj80228yvngLGfI265pprHm/k33PPPfHggw/GBz/4wYiIePGLXxwvfvGL2/+iGZc00ik55JBD4rbbbosvfvGLccUVV8ROO+0UV111VbzkJS9ZItfV1RX/+Z//GR/+8IfjkksuiQsvvDDWWmut2GyzzeLkk0+O7u7up3zsqVOnxsyZM+Oyyy6LgYGBaLVa0dfXFyeeeGIcc8wxo/qHKIAVx1iuU6usskpce+218YEPfCDmzJkTX/va12LNNdeMWbNmxYc//OEnbPCAlY81ChjPxnKNioiYOXNmXHHFFXHCCSfEe97znujq6opZs2bFxz72sSX+AVJg5TTWa9SPfvSjOPnkk5f42QknnBAREe9///s10lciHa1WqzXWkwAAAAAAgPHK70gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaRq8MKOjjTTWagzuQ01+guZwTbMJSJiKBkfKdSovKauQqZdx+pNxtdq03HuL2QGCpnhQiZTOR9uLWQqrzubb7vO8ezcrB6rcu5l87mhUOORQqbVahVSABPPhe2qs6h5/NZkPCLi67PyzHal2QArjMKz3ksLZX44+pnEKwuZvQqZyrPTXcn4eoUalb30VYVMXyFTMScZv7FNx3laIVPZ/7PyGM2z3qWFNWrvpa4Oy1alX3JmIfOVQuYlyXg77tMrquoa5RvpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABpOqwf5C5q+jmMhj+gqZrkKmp011Mp2FzOJCZrCQqbym7kJmnWS88poqVi9khguZ7Ny7vw01qpnKe5NlphRqtOv8HSpkKkaS8UfadByAFdWOhUxlXb81uYkMF25mmxeOA6xkCg9htxceatZMxt9QmMouhUxFtn+NiNgrGa88q1T221sVMpXnjHsLmd0LmcyNhUzlufMPo50I/P/tPdYTYMKprN+VPtxNyfjrCzVeUchU7lkVldfE6PhGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoMGkavCvbTrgSDLeWagxXMh0FzKVY2V1KnOZXMgMFjKVY1Uy9ybjlfdl9UKmUic7HyIibk7GzyvUGE++U8hsWchMLWQq50NXIZNdB88u1Li7kAFYUfUUMpX1eMNkvLdQpLJHAlYyhbXj3wpl3p08+PT35zVuLxxnXiFTWeuGkvHKXnrzQqYim0tE7T5xVzI+rVCjcs+qPOOeU8gAPFU3FTKLCpnFhUzWP6usy1cVMjsWMmsWMj8tZBgd30gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaRqcJ02HbArGd+kTcepWH05HivTW8hsfVQhNDuPfHHx6OeSfY4REf2FzM2FzHmFzIrmF23KbFzIbF7IdCbjGxZqDBUyACuq7uVUp7dyg4ZlYKCQqewxGRvDhY3a23vyTGdf83hfYTH888I8UzG1kBlJxgsvOZKXHBER9xcykwuZyp77umS8sievXKtXFzI7FDLXFzIrmjULmQeW+Szgf1XWhZsKmcFCJltfKvuJpKUVERG3FDKV+Wb3ia0KNa4pZK4oZFYrZFj2fCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQYFI7i3W2ITNYqLF6IXN7IbNhIXN/Mj5SqFGxYW8h9Im/5Jlpq6aR29/YPH5DYSqVz+lbhcz40lPIVF75+HFbIVN5RVsn49l1EhHRVcjAyuqq4Tyzm4uIiEi3C0PLYxasbL5W2CxMLWyjKttdxkibHmpumts8vl7hPOkvHGdqIbNjIZO97HbderO9dFXlY5qcjC9qx0Qi4m2FzHqFzPWjncgE9EAhs1oh89BoJ8K4l62HtxRqVJ73K+vurYVMO9aods23kqn0MO9Kxtcp1Fi7kPlDIVPZR1V6QIyOb6QDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaTKoGby1kvlfIDCXjexdq7FbI9BQyfy5kOpPxkUKNrkLmpoE8s9ueq6aZL87J65yejD+Ql5iAJhcylU9quE2Z8aPyeWfvzHqFGuXFBlYw2X0vIqKrsvxA5OvtwOKH8yIzV2nLXFh57Lv+q9PMBb/8dprZqq8ds2FZ6JqaZ4b688zpg83jJxXmskkhc38hU7Ei3n43TMYXFmpcVcjsUsjsX8hkz9NHFmq0ywaFzB3LfBZ/89ByOs6KpLBEpefbLYUalWuou02ZbD6LCzUqzyKVvlaly5H1zyIikttEab7tUukbZq+78jn2FjKV1319ITPRrF3IZOfn8u5h+kY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaRq8HOFzEOjmMhjzipkNixk9i5k/lzIrD7K8YiI+wuZzkLmbXPyzNcKdUYKmYlk476+NLPbjOlp5pwLLmrHdFZItyTjWxVqDLZjIrCcXVbIDCfjA4UaN83PM2cWLqJdpuWZw3vzDONXVzJ+85wr8yIH79mWubD0Knuxyt5wuenN91qfm/3LNLPbUVvkhypNiLbbY3Ia+do7+tNMluibkk9leF6eadfzTHYPz9bcssoFXXhRlTLdyfhuhRr5Jx1xQyGzSSHzhmR8RqHGpYVM5ZypZD5VyKyM1lzG9V9VyFT23JlsTYiorQuVOvmqG3FrMl7pR1XmW8lka0u76rRjnWun7LOs7Fsqa8sVhcxEs1oh047P8oE21HgqfCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQYFI12FPI3DGKiTwVNxUyuxcyw6OdSESsVcjcUsh8rpC5opB5diGz95Tm8a8sKhQZR25bvDjN7H3UAWlmwUX5sW4cqcxoxXNbMr5hoUZXOyYCy9lebagxWMhMn55n+gt1ugsZJrZsLd1kZGi5zIPR6SxkBgqZ13/gJ2nmmhP3SxLt2fhdf/RpaWb9o9tyqFSr1Vo+B1qRDORrxxGFMmcn4/0L8xqVPWMlU9m2p3V6C0UqF+s4Unmun1nIVJ6lK59B9hZX9jaVZ/J/K2QmFzI8uQeWcf3vtKnOmsl45f68SSFzfyHTjmuocu5XrqHKulCpU8lsnoxXnp0qa8uthUxlvtl9onLOfLGQmWiyaymiti5kvabqsZYn30gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaRq8OofnZVmNt31raOaTNXWnXmmfyTPdBWOlR1qqFBjlxl5Zta8QqGCD+3bl2ZGupozX1l0ZXsmM4588OgT08y06VPTzI3zFrZjOiucuwqZdZb5LGB86mlTZsfRToQxNVzYlwwM5Jmrr7yzcXxo4Na0xkjhVtaZbydieN49aaZr93XzQjypt53xuzRzzYlfK1SaPMrxiIjhQqaisvse/T60o2ObNDPnu99IM6/YY9M0MzT/Z2nmhisvbBzf7YRPpDUi8vMhYqNC5smdeWr+VHNMoU53Mn5D4eGpcr+rnJGVe+tyU7gHtEv23lSeX/vblLm6kHlFMr51oUbhlhVvKGSmFzI3JeO/KtRg2XhaIZOtC4VWU7rORdQu+d421KncVSvHqayXaxUy9xYyg8l43pWJ2KSQua6QqbzubHt+c6HGA4XMePKSQqZyL8nWy4iIRwqZ8fb++UY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaRqsG/mAWlmy1kjaeYXs9/ZOH7aF76V1njzwGvSzGUnppEYyCMxlIy/u3VeocqBaaJVqPK5LdZPM3vPeHeaOemMLxaOtmLJz8yIoeE8tVlnXudXlYOtYH5VyGy8jOfQ8dpv56HCZxw9vY3D286ckpa4/IB100zzUWDsVO6Nd7XpWFu3qc5EsMYqLyikuguZbGeyMK2wygsKm6Q2WbNn98bx7aZMTmv0Fe69vT35e7dO3yZppqsnX+NvWtTfON6zR/NrjogY6c73dN+6aF6aiegqZPZKxu8t1FhQyBQ+qJhfyDR7ycH5s8INc76WZhYtWpRmFl55aZo57ozj00xm4wvy6/a2xfl712rdt9RzqGxf1ypkrkvG31ao0Vs5ldq0316cjE8u3BQr0y1dqsN5JLsDRETcOvrDxFaFTGUuVxUy2Vv8rkKNfOWu7b3XK2Q2T8Yrz0UsG5XLbJ3ldJzKulCp01PItOM4lXN/eiGT31nztaOyvN/fhuNERNxQyGRrZnYfmYh+2KY6T2tTnfHGN9IBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANOlqtVqttxTq2SDOv+cR3Gsf/fd9N0xo7zs2Pc+YbF6WZnjQRsW8y3sa3L3X1Tq9NM7sc9+4087kzTm8cP+LKi8pzmige/Nn1aeZrF12aZoajM80ceeqppTnxRKO5njo2Lbzvi/N1IbqSlaErL3Ho+R9PM5/foyMvBH/n6kLmawvzzMKFDzaODy0eTGvcvrA/zTyweEGaOebT70gzH5uRRiaEjo6Jds3n97uIkWU+i7+p7Njy87b2mqYUMtObh6funZcYGMgzg18rzKUdn8HiQia/5msq7+/kxtE1pzaPR0Q8sPDcNPPWI05IM5/57ClppnZtdyfjQ4UaudHso55feB2/KNTJniLekL0VETFUeDu6K8tC5W3N9nWVZaOwN6xcqiOFZeFzhUNlb/HUQo2tj8hvvkNz56WZ9xa23nOT8X3yErFVIVO5S1RW1CMLmZXRaoXMn0fzrFdYozYu1NkkGR8u1OgtZCp3zcodMTtvK+dsZb75nTVirULmM4XM5sl4Zb5ZjYiI3QuZ7XYvHO3TP20en7JuWmKtVfI+5wMjlf0Yy1J1H+Ub6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAaT2luuP00sXjzQOL5e76b5YabvnkdiUZrZJD9SbJmMd3R0pDVarVZ+oKGH08iGfV15na7BNHL4xR9uHD/zGRelNX6Rz2Rc6Zq6fZrp7r0uzdwwd147psMy0PrNcWM9BVimtitkdplaCE1dIwlk4xGLY6M0c+xp09PMx2akEZaF3k/kmYHm/drfnDbqqUQU9jaTP55n+i8sHGs4j0z99zzTt0/zeOWtG7yyEMr3uxGVfclQMt5XqNFdyCxME8d8O99BfmxWvrfOHHbilDRz1geOTjOf+ewpaea0U/LMUSeemGbGWrv29q/oaR7/Yv6oEjcVjvOZQp2o3BNHkvHCsjGSPwJHZbo9ydISEfH2Uz6VZobm3No4ftLRZ6Q1BufnC9ku05IPOyI2WZS/8quS8cJHUHjyj7i/kPlaIcOTe2gZ19+skFmnkMnuZtmSUM1UVM7tLNOu+VZ2JfcWMpXnlW9+4ivNgaPeWKgysXz94d+kmVcU6hx2Rl7nnHc8r1CJ0fCNdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQIOOVqvValuxjo40s9r0sxrH7/2vt6Q1Ri46MM3c8sYL0sx2aSLia8n4voUaC7/wwzy04P1p5NCz56WZH//yG/mxpry2cfjSD+yZltjnxDn5cZaT9xx3Spr50EdOSDNnfuADaebIE08szYml08blaKXRn4xPbtNxhgqZZ3RsWkj1FjLJrCf35SWmbp5Gdth99zSz1x7rppl3F6YDlT1SxKxCpisZv6hQY49CprOQmV3I9DQP7/6dtMJme2yfZvoLi9RDF30/D40k842ImDyteXz+/LzG8PfyTCwsZAYKmew1TS/UyO42EdHTnUZ+c88n0szyWlJXL1yTt1+b7+F7eqekmY5Nn1Oa02iNZh9VW6MKczggCVxSKFJZonbP3/e4clGeySKFS+xzg3lmah6JHb9a2CPtm5+TQ8cf1Dh+5qn5GpU/OdWsVsg8lIzvUKiR7+giKk+vNxYyLL3RrFEvL6xRI4U62R2xcDmnNSJqz07DhUz2mio1/lzIVHpjby5kNjkiv8/fML250ulz8qv1+kvOLMymsB9bbmakiVbr2rYcqV3385VRdY3yjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAECDScv7gO89+IDG8a5CjY43XpBmti3U+Y/OPDNlpFAo8bkzDkozw4v708xZp8zMDzalrzKlRnsf9fE088qL5qWZ7y0aSjOPlGbUbJ3eTdpQJeL2gcG21GFsdGz6ozw0MFCodHvz8OSt0wov3n33NPOlT3ekmcrVPLmQaYfLhiupxW3KJPLlspS5fs4eaebts75bOBhUVK7WnkJm0WgnEhFz2lCjqrt5+MrT0wq/unK3/DB7zCpMZUqeWVRYPDqT/UJv4XPsz+8lMVLY3/QUNrMjyQI+dVqhRn7/fM0B09PM6Hep7fPlT3wjzWy30+vSzFXfv6Yd01lh3Jw8pq1XqNEzKz+Xor+wp0uWn4iImNo8fN3CvMSthcMcfnAh1JNMJiLitLemkdsvmt84Pqs3P0xX4e09Ko/E/oVM9rhd2TlWzqubCxnGr8oOqfKIkCncVUtLSyVzWSGTndt3FWq8opCpPCUXulERZx/dnsyKprNwX2uTc89vNY4ffGDeh6CZb6QDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQoKPVarXaVqyjI80s/E3z4bbqa89xKs4uZKYn49PaMZGIeHEh859t+qgGFv6ucfy9H7gwrbFVd3+auWXxwjRzztz5aSbzgU9/K82878hXp5n/t82uaebWgYE0c/fAojTDkxvNctSudaEt9r0xjbxk96lpZkZXfqiT9lmlMqNRu6qQ2b3j+EJqcSHT0zj64k98Nq3wn0cVDjPBXFhYWm6Y92CauWz27MbxOwZuTWs8e/I6aWbDvilp5v7BkTQzMDCYZraeNbNx/D+PWD+tsax1dOT3mIjOQmYoGa/cVwuLSwwXMpX5HtA83Pe+vMSMjdLI2vmSGj2FPeY6vXlmJHnZI9lHFBH35qd1vGL3PNNV+CiHk/n05JdhDBeW7lcU3t/dCu9vO4z05/uJ/sH8HN90m6e3YzrLzUTYR11UyLzhI4ULeiB/Fon5hYtxavMFPTivcIEUlsKeT8/KQ4XnjP5D8jX+9uTU3rHyALtvvpEa6s8/g+498s9y8MorG8d7Jk9Oa1x6Wn5mvalwyjyQRxiF0axRbyqsUYWPOLJbVeH23LZdVN7FiFgzGa/cVivvy0OFDEvvwcK5Xzmv2qGjo9I/KNz7VkDVNco30gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA0mtbPYxpOPTDPrtOE4z979E2nm7iuPTjOXFY410pUEhvMazy4cp3dKdqD2ee/xZzaOL1i0OK1x1eLZaeaO6oRG6ZaLDk0zN/cNpZlX7D49zZxw6qmlOfFE2471BMqar8XVjrgirdDb15lmfnjgqnkmetLMjt/+ReP41rPWTWvkR4nYrZBptT5SSI0f+aoQ8b2FeeaqOb9rHL/6ygVpjdvm35AfaHhOnomBQqZ3lOMRdy/I71l3z8ivgxfPmpVm9j4yP4c3mZZGxoF3FzKFTUVP8vkMFU7arilpZIMjd0oznYXFY8PkUJP78hqbFzLdeSRGCpn8rM1V5nJTIdNVmPAmhQmPJJ/TTVfmNc458JA087XefDJ7Tc1PmncdsFfj+JQp+QV/S/9gmhnpydeWlcmLC5lr2nCcwioX0VW4inoLC0Pk99+bL2q+0Lbat3CYGfkzREzO193omZyX+Wz+Dk4+LbkPVO6ZU/PPoHv6jnmdwdvTSM/MGc2BrnzPMWVKPt/39uc7v+PSxPjywkLmp8t8FstHae0oyM6mSlemv5DJz/yIlxQytyTjvyrUYJQ6mxfN1sM/WU4TaZfCPSvmLfNZTGS+kQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGgwqZ3Fdtvn3Wnm3qHm8d7CcX7w1aPSzNR1j04zV3XNSDPDnfMax1+cVoi4ppDZbsY+aWZw/k/SzA3zr0ozA/3nNo7/dHHyIY0zH5o6mGa+d/ZBaebe7vx8eGFfT5r56eJ8Piua9xcyi5f5LNpjy32+1Tj+88/ulNbY+dTvppnbYmqaeeW06Wlmq57OxvH8jF0xjRQyb5vzYJrpH8gr9UzZqHF8l5nN4xERb5vy6jRzV/9H0kzFepObx7u78xqFSOxSyCyv8/O6QmZRIfPm0Uxi2u6FSfTnmenN59MGu2+flhgu3KbWSc6TiIip+W0zRpqXqOgqnEx/ziPRVchUVNaOLHNvocZgYat11QV5Zp3CsXqTN+e6ORfnRQaa944REXcPTMnrTD84jdzUP9w4/ueejrTGYGF1GSl8BhvP/ESa2XHqemnmy59+Y+P46Wf/KK1x1FtekmZGo3A5l2TPPTdViiwq7BqHms+TiIiRgbzM15IyhxXWy8nTCu9e31Z55pJL80x3X57pWtg8ngxHRMSswpu3qHDn7C/UGUlW1d68Q7DVPvummeHh2flc5hXmO44UVt0o7D7i46OdyHJQuT8vrzp3FTK3teE4ERF3tKnOiuaMa1tp5u3turFNMB0d2ySJBctlHu30kqRH03PJ6WmNb0Rzb/ep8I10AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAg45Wq9VqV7GrFuWZzs7m8V368hojhbms0tFRSOXOPuWcxvFb5h2a1vjUlflx1i7M5Q+FzIpov97m8a8MtOc4axYyvd3JCRwRvxqqnKETy+uS8cJlGwsKmf8YxXLU0aZrvo1LIkxIlSW1ssrdVMhcujDPLCpk7lpwT+P40NBQWmPr6flK9p8HL/0607HKL/PQ1C3yzJRkfEHhOIsuyzOxeppY+9PvSDN77ds83tOTz6Qrj5TOyf5CaEF/nrllcfP4I4UaMXRfnlmcHCgiNpucbJIi4m37rt84fmth/37puV9NM3vNmJZmXjEzP8f7F9/ZON7Z2/x6IiJuX3Rfmlm9Mz8h7h3IV8St+/IztDea3+TFhXPm5oHhNPPJj7w2L/QPnNmmfdTNyfj+hRo7Hjw5D1UWj+H8PXvTGc2fzXb5JRaH33lFmlm0zcvSzJcKm+WPHZlfZ9Gf3PNm52tL9jlGREwqLM5TpuXPTovnN1+L9xfW7rl5JI4qZCaa7BktImKXQuaIUc6jajTPWa8vrFH5FR+RnZGVffD1hQxL72Un5O/wf5yy/XKYyfhz7Ku/m2Y+PvuVy2Em7bPZtE+kmY99unkFnzz/wbTGtKOfnmaqa5RvpAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpMamex3abkmZuS8cHCcbork5lyQJ5ZdEEa+d6C4cbxHad/JK3xwoXHp5mfDqSRki0LmV8k42sXarzh4Pz9Pevc/P2tmDx9cuP4xrP70xq3FY7zQCUzNFJIjR+bFTJvK2R6k/H8E4iYXsgsawed3xrrKdAGpxcytxbW1OFFeWa7aXnmpqTOOW/5WV6kJ7vKIjY+eN000784P9Qjc37THJj3xbxIDBUyzffPcqZrap6Zsl3j8NpT+tISN89bmB/n4BfkmX+kN/+MY8HFhUz2+RROgtgnj8z49zTyh8KmbSC5QQwXbqtXLcgzfyh8fKVNZlceeVryUW7WvG2JiIjNpz8jzUzt3SbNLCq8N9lVtt2MvEZ35xvTzIaFDXp3IdM7ef3G8UWFz3FS4UCdhfVnIDuBI+JrF1yaZu5YOKc50JWvUcec8PE0MxqF211p5c/ejc5CjZi5e2EyhYt10fw8koyfV9hPHD6Yn5TXFa7VN+WRiIP3zTOvPbpxeK3CYV5RyHyjcAt/67x8kc/uag8V5rKy2q0S6ilkKvfHCaDypJ5d0pXd6ysLme8UMjy5V+yx/VhPYdw69rg908zHZy/7eUREvLD3vDSz+xH5PWutwu386nn3NI7vPS1/Tm4n30gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaTlfcB1kvHOQo1KZr99908zXznxgjTzndk3NI/PGU5r7DDjiDSz3+SFaeYr8+elmbvSRG6v6VPTzGe+cH6aOevcOYWjDaaJC2f3N45vWDghVu/tSTO/6M/nMtF8ppDZvJC5NRnPr4L2nJuNZvxPGtn7gLzM669sHu9vPh0jIuL2whsylEdipFCnOxmvrJdDhcmMFOp0dRVCBX/ILsULHsyLDOVrasV507fPQ/3JfAbmF46UfZIRt13ZW6hTed23JOOFkzzyNTViciFTOGmG18oziwYah/9QuOKePX1KfpzR6M/3HBHvL2SmNQ/P+E1aYc2D86NsnRwmIuKWwul2xSVJoPmj+5uRwjU/bY00svHueZnt+vLMVsmp3VNYeCvr7r2FbcnAQCvN3NLV0TheuU+sXrhUK69poHAz6UmWw5Hhh9MatyxelGa+cvYX88ksPjfPlHZBWYn8w750Xn7BfSx2WuopZM9oERHfK2SuScbzTyZiu8pZOW3vPFPYmLwimu/R1+dHiY+uv1+aefcJM/NC8+fmmdkXpZHrkjd5r/wo8eWvfiTNfP2Nx6eZ/1c41kOFDE8u3z1G7HXKUWnme285o3H8W6UngYnhpmT8r53T8yIP/1ca6ehovvfyj3UX9mIrq57C6dlqNe8NTzoj3zuuNys/f28tLAtdhX3+nwsbg+Gh5r3WO089NS/SRr6RDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaNDRarValeB1F52fZnbc98BRTiciRgqZzjzywUvuTDMnvPY5aWaDGec1jl937YFpjY06OtLM8tXVONp6+MG8ROEzeO+JF6eZD3/gdXkhltp+zR/13wznkcuS8cpl+1AhU1yOnlRH266zKcl4b6FGXxuOExGxXiHTnYxXToLCXDoLr7uv8BlMziPpCTVYqFFYo9K3LiJiqJDpT9bMwUWFIosLmZvbVGcgGa+cMz2FTOWDqsy3cqwZyfDmaYVtd5+WZv77hBcU5vLkOrYphEYKa2B3cp1VlpZ2qSx12ek/+HBaYsujVsmnUnjd3YVTe6RwTxxOTu1brsxr/OqS7+ah+Z/LMzE/TTz7hGsax988a4u0RmfhRr9WHknfu4iIWxff1zh+3qnvzIsMXFCYzYpnNPuoxYV91E2FOllmr0KN7T4yKw/NeHOeWZDtYCNOf8e5jeNH5UcpeVohU3hFsVUh871CJvMfnYUFc1q+qfvc/HwPdERlQjyp+YWPabvvN/czIiJumte8x5x2/GnVKTUazRr18sIadWuhzmHJ+L+PYo5/r6Ojsmdc2JZjrWguKXwGexfqtKm1mOpY5fg8NHJqG44UMfvB/L3Zq/Iol6g8oVX2BIuzx86IuH1unpk/+6uN4zdesl9hNrnqGuUb6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAaTqsEZbzwzzbT2PXA0c/mbwUKmN49cNXfuqKcSEbH/vjMbxycXarRarTSz+Ws/m2YmdXanmT322CfNfGjfVdJMO7zhuNemmQ/PGcgLLXjn6CezQpqSJr4yPFSo01nI9Bcy7TjOeLBolOMREe1Zf8aVkUKm8tZUMtGXjBduAiWVc7LywrProx3Xz0RUeX97CpnCnbZzuHH42Z135SWGFhfm8oJC5h8YyfcCMaUjz2RvWeWUrXw0+ZajVOdpya3qkfl5jV/MKWQKy+7ahVOpq7C8jCS31ruP3ikvEvMKmfa4e/b3GseH99girbFwwX1p5uYFC/K5XHJZmomhC7JAXoOnLLvzRtSWjpuT8fwsidhuYWU9bj6vIyKuOvvcNHNU4Ujt8Eghc84yn0XdeiPN99WIiN3m55u6r7RjMvxDc/OPKbZbfHua2XpKZT82tm4qZApvR0ydekLj+FUL8xofnXNfHurdN88MHJ9nVkJdbarTptZidHS8I0mcUajSHrPWyJ8Vjvmv5meOj03Pj1O5339tdp65ef7v0szA/Hyj/8DctxZmtPz4RjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKDBpHp0apoYLlQZSca7uvManYXjdFUKFXzoiI3aUidzy8VvSTMdh/wyzfzi1Dlp5uNzZjYHFvWnNSIG88jCQmbko4VjjSeVs29aMj65UCO7UiIieguZyrEqr2lBG+YyUMhARMTiUY6z7PUUMge36Vhz88jIosbhdbrzdW6v3feuTmjpLNw2z/T+JM9MScYrm7GKSp0z/iuNPNL/vSSxsHCgwn6ikPnDjPPSTM+R26eZofS9qdwTl6PFzdfHp3Y6MK8xMq9yoNJ0WLFlu73Kw+eii/J14c+75/vKqyqPNDypuwuZryzzWZA5rpB589nnppnO3bPNxdirnJMbFzK7L/xAc+AFyXhV36faU2fC6StkmvsllU5eu7olzTukx5xRSo0XH9++oznwo1ZaY27h8evG2d/OQ0O35Jn+4/PMOOMb6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAaT6tGuNLHGv+RV9vtC8/i7J+c1tsoj8b7j9swzB/+lUGn56Nj12jw098XtOdjC9pTJdRYyvW04Tn5uRkxtw3Eiaq8pm0+lxpRCZriQGWxTnew1VT6DyusGlr1kPez897TCfn3daea6RVelmdvi7DRTWV82nr5P4/iMmfnOYf/dNy3MZTQW5JF5380zQ9OSwEheo7snzwwO5Jn+l+SZ0j2mHQr3mMGhNLJ65baZlLl76hvyGqW92LxCpvA5DZ9bORikvlfI7JiMV3b+VxcyPYvyi7WwGsYOyXjh0TS+UcjAWPm3+f1p5stdzfeSzQrH+VVxPsvSbWM9gb83ubB6LF7201j+Ci+q+4DG4ew+0k5vO+PO5Xi08eHju746zWx8ZOHOVjnH57ymMKOJxzfSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaDCpHp2cR658dRr5ykY9jeNXf/YLaY1vHpFP5d9ee3SaufVHn8gLtcGr5hRCc99fCDW/d3/TWch0JeMjhRqDbZrLUBvqDBdqDBQyvYVM5b3J3t9sPCJiw0Lm/kKmYp1CJnuP7y3U2KuQgYiIgxtHZ387v0+87S0Xp5k7Bi4tzKW/kMnWhe421Ih4cfSlmb26t0sz9ydrx0eH3prW+Mqiyrpbka+Ha/fNTDNbz2x+3W84+IC0RuUOsMwNX5dnBpJ7YlfhfOsu3Id6K3uOGYXMwmR8WqFGfu5H5+Z5ZiDfC/z0LW8szOeiQgYmlgsLmcpd8+PJ+NaFGoWVMC4r3J4/v3u+Hk6eNrVxfODUeWmNb+RTic0KmbUKmcqKma10VxVqPFTIMDFcUch8aG7zPvRdhRqFFs1KptI3WDlt+4kTxnoKj/vhaaeP9RTGwOw00dlVeNbrXHnPcd9IBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANJhUjx5eyIwUMrMbR+94yzvSCi8d+HThOBsWMsvHd/Zct5CaVsj0FTJdhUymv5CpfNbDo51IUXebMpPbVKcnGd+xUKPyOQ60qU5vIZN9lrvmJXYvHAYiIuLcxtG93pJfQ3t1Fc79nl3yzOD9eSYGk/FFaYWBWJxmPhPz0sxRQxekmfFk7an5va97ar42b71H8wKzSVdHeU7LTmU9Ltw3O5P70OBQXmPx3DwzUrnHZPe7iPweM79QY04eqWxLCm8NrKwqK9T7CplNkvHKU0ZWI6K0KsQnr8wv+k8ONd9bew/Ij/PWwq33bZ155uuFdeyjeSR90nhFoca3ChlWHJ9qQ41t21BjhbLolrGewTIws5DJF7KpU5rHr27LUWr3khheXj2rieVXpx5aSOXPuCsq30gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA0mFSPdhcymxQyk5PxK9MKD3xgpzSz5pE/LMxl9DoOubaQGixkBgqZKYXMcCGzoJDJ9LShRruOVZlLJTOtkNmqDceqnA83FDIjhUzlfHhzHunbtHm8cmrOLWSg4KMDB6WZdy+HeVSdWcgcucxn0WbdXXmmq7DuFursOGPHNDNtRvMaVZjtclBZj8/II4sLGYBloLLzvLUNx9m/kKns2o8pZDrmN4//rrB0V3b2WxTevGcX6jxUyOydjFfeu8qT/3mFDCuPG8d6AuPNwKJCKOuNRUT0j3YmEXFwmtjhu19IMx/fIz/SOoXZ9CXjnYUabTN1lzwz9+xlPo3x55KxnsC45hvpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABpPq0aFCpquQmZKMdxdqLE4TD5zx/rzMpz9SOFbikqsLoRmFTHted8TUQqanDcepzLeSyeZSybTjvIuoneM3FDJbJeMjhRrDhUx/IfPmPDJ50zwzmIzPOa0wl8r7e0ohw8quchW2y6JCZotlPovla83OzjTzQGUdG8nXse6e/D5RyoxyHGBll231Imo72NOT8b5Cjc8UMqsXMrsUMlck429amNfYu3CcbxQylc9gg0ImezKqPDlVXtPXCpmHChnG3pbJ+C+WyyxWNJcUMpVVtR3OTRPX75lnKl2tiN5CZnIynj+L1HoLlToLChlYkm+kAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGkyqR0cKmeFCZr1kvLtQo7eQmZsmOrb5XZr5zU82ag4MnV2YS1ebMpPblMmONaVQY34hM1jIVM6ZnmS8cs5U5lKpU7kOrmtDjcpc3pBHunbKM/0PF4710WT8xEKNIwsZyH2rkPliIXPwaCcyHlWWjmTZfWCksEb15PfhNXv70sw6k/N7VmdXZ5oZymqkFQBWbpXdf38hc0Uy/pJCjcqu/apCJtuRR0S8LBmv3D+OKGSeXch8vpC5qZDJ7uKVp6/KE+XehUzlnMl2FDcUamT7gIj8iTIi71RERExLxgcKNSrvS+U1/bmQua2Q+UUhk3lrG2qsWCrP/CuiyhVQycD45RvpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABpPKyc5188xIZ6HQ7cn4VoUaw4VMXx5Z8Nw0smnHAUlioDCXisWFTHch0473ZnKhxlAhU5lv5VhdyfhIoUYlU3lNlc+7PxmfUqixfx6Zun2eqbzsRasUQhsWMpmFbagBNQeP9QSeoo0LmdULS+ovKgfLbtU9+b18gyn5PXbzadPTTM/kzfM6U6elmU3SBABNzixkCk9XsV8y/u5CjexpMSKit5DZu5DJVF5z5YmnUie/I9Zk2/9FhRo9hUzlqb3SHcjmU3n62q2QqTyBVeabfU7bFWrcXMhUnuor781thUzmJYXMjm04DsBE4BvpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANJhUTo6065ADyfiGbTpOVyEzvZC5IBnvLNRo15s3VMhc2YbjVF5TbyEzpZAZLmQ2ScZnFGoMFjJfa1Od7NzbLi/Rt32eOa4wlfmFzKKHC6HLkvHKZzC3kIEVz5qFTLbKRUTcUrkFVPQk471ZICI6C/eJQqZ38uQ0093TndfJZwNAg60Lmd0LmcIuN3VTIZPfPSLWKmT+nIxXnuLeXMhsVcgU7r4l1yXjXyzUuLeQ2aWQqTzpZXf5yntX+Zwq3YFKcyQ7VuUJuLKlq2QqT6abFTLZ51TZZ/UXMgArAt9IBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANJhUj95ZyHQu9UT+181tqBERMdymTPaaRgo1JprKa+pvU6ankOlKxqcUaiwuZIYKme42HKtwnVQupQVtysQFhUz2WfZWDgQTzmqFzORkvLISXldYCh+qLFGVtaOneR1buzufzHqTs1cd0dWdr5edXdn6HjEykt+Tbo9VGscrKzfAyqyvkNmuDcep3BOPKWR+WMgcVMjsloxX7h+nFzLTCplNCpn8rhkxkIzfXqhxRyFTeWLcupDJnuSy1xNR2/5sWMhUXlO2S6rMpXJe3VLI7NimTHZOrFWosSJ2Rf6x3dtUp/KwPtimYwHt4hvpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABh2tVqs11pMAAAAAAIDxyjfSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGumsdM4///zo6OiI3/72t2M9FYAnsEYB49nVV18dHR0dcfXVV4/1VACewD4KGM+sUROfRvoy1tHRUfrfeH4Yufzyy2PatGmx2mqrxeTJk+P9739//PWvf13qes997nOXeO3PetazYqeddopvf/vbbZz1snXxxRfH9ttvH894xjNinXXWiZ133jnmzJkz1tOCp2xFWKMeeOCBOPbYY2PjjTeOVVddNZ7znOfE3nvvHcPDw0tVb0VYox4zMjISW265ZXR0dMQnPvGJsZ4OPGUTfY1617veFdOmTYu11147urq6YosttoiTTjop/vSnPy11zV122WWJ17722mvHP//zP8eXvvSlePTRR9s4+2XjpJNOetLPcLXVVhvrqcFTNtHXqAjPen/v0UcfjfPPPz9e9apXxYYbbhhrrLFGbLXVVvHBD34wHnroobGeHjxlE32N+r/ryWP/O/zww9tWcyKtUY959NFH4+yzz44XvehFsfrqq8c666wTu+66a/z0pz8d66mtFCaN9QRWdF/+8peX+O8LL7wwrrrqqif8fIsttlie0yr7j//4j5g1a1bssssuceaZZ8bChQvjgx/8YPzP//xPnH322Utd90UvelEcddRRERFx5513xuc///l4zWteE2efffaoFsXl4cwzz4wjjzwy9thjjzj11FPjoYceivPPPz/23HPP+OY3vxmvec1rxnqKUDbR16ihoaHYeeed44477ohDDz00Nt1007jnnnvi2muvjb/85S/R1dW1VHUn8hr1984888zo7+8f62nAUpvoa9R///d/x0477RQHHXRQrLbaanHTTTfFqaeeGj/4wQ/immuuiX/6p6X7TssGG2wQH/nIRyIi4p577okLL7ww3vzmN8evfvWrOPXUU9v5EpaZs88+O57+9Kc//t9Pe9rTxnA2sHQm+hrlWW9Jw8PDcdBBB8X2228fhx9+eDzrWc+K66+/Pt7//vfHD3/4w/jRj34UHR0dYz1NKJvoa1TEkuvJYzbbbLO21ZxIa9Rj3vSmN8VXv/rV2H///eNtb3tbPPjgg3HTTTfF//zP/4z11FYOLZart771ra3K2/7ggw8uh9nkttxyy9YLX/jC1sjIyOM/e+9739vq6Oho/fKXv1yqmhtttFFrjz32WOJnAwMDrTXWWKO12Wab/cM/NzIy0vrLX/6yVMf8e+edd14rIlq33XbbUv355z3vea1//ud/bj366KOP/2xoaKj19Kc/vfWqV71q1PODsTTR1qgjjjii9YxnPKN16623tq3mRF+jHnP33Xe3uru7W6ecckorIlof//jHRz03GGsTbY16Mp/4xCdaEdG6/vrrl+rP77zzzq3nP//5S/zswQcfbG2wwQatNdZYo/Xwww8/6Z975JFHWn/+85+X6ph/b+7cua2IaM2dO3ep/vz73//+VkS07rnnnlHPBcabibZGedZb0l/+8pfWdddd94Sfn3zyya2IaF111VWjnh+MpYm2Rj3ZerIsak6UNarVarW+8Y1vtCKi9a1vfWvUc2Hp+NUu48Auu+wSW221VfzkJz+JF7/4xdHV1RXvec97IuJvfxXnpJNOesKfee5znxsHHnjgEj+777774p3vfGdsuOGGseqqq8amm24aH/3oR5/w13wHBgZi0aJFMTIy0jivX/ziF/GLX/wiDj300Jg06X//8sJb3vKWaLVacemlly7dC34S6623XmyxxRZx2223RUTEb3/728d/FcGnPvWp6Ovri1VXXTV+8YtfRETEokWLYu+994611147Vltttdh2223j8ssvf0Ldn//857HrrrvG6quvHhtssEF88IMffNK/9jw0NBSLFi2KoaGhdK73339/POtZz1ri2whrrbVWPP3pT4/VV199ad8CGLfG6xp13333xXnnnReHHnpobLzxxvHwww/HX/7yl1G91n9kIq1RjznuuONi8803j/32228pXzVMDON1jfpHnvvc5z5+vHbp6uqK7bffPh588MG45557IuJvr/1tb3tbfPWrX43nP//5seqqq8YVV1wRERG///3v401velM8+9nPjlVXXTWe//znx5e+9KUn1L3jjjti1qxZscYaa8SznvWseNe73vWk6+zw8HAsWrQoBgcHy3NutVpx//33R6vVWspXDRPDeF2jPOs90SqrrBL/7//9vyf8/NWvfnVERPzyl798yq8dxrvxukb9vYcffjgefPDBp/zaqibKGhURcfrpp8d2220Xr371q+PRRx9dpu8LT86vdhkn7r333nj5y18er3/962O//faLZz/72U/pzw8PD8fOO+8cv//97+Owww6LyZMnx49//OM4/vjjY2BgID71qU89nj3++OPjggsuiNtuu+3xh7knc9NNN0VExLbbbrvEz9dff/3YYIMNHh9vh5GRkbj99ttjnXXWWeLn5513Xjz00ENx6KGHxqqrrhprr712/PznP48dd9wxnvOc58Rxxx0Xa6yxRlx88cUxa9as+OY3v/n4Rueuu+6KmTNnxl//+tfHc+ecc86TNru//e1vx0EHHRTnnXfeE24I/9cuu+wSl156aZx55pnxyle+Mh566KE488wzY2hoKN7xjne07T2B8WQ8rlHz5s2Lhx56KDbddNPYe++9Y/bs2fHoo4/GDjvsEGeddVa86EUvWroX+yQm0hoVEXHDDTfEBRdcEPPmzfNXkFkpjMc16jF//etf47777ouHH344br755njf+94Xa665Zmy33XZP8VU2u/XWW+NpT3taPOMZz3j8Zz/60Y/i4osvjre97W3R09MTz33uc+Puu++O7bff/vFG+7rrrhv/8R//EW9+85vj/vvvj3e+850REfHnP/85XvKSl0R/f38ceeSRsf7668eXv/zl+NGPfvSEY99www0xc+bMeP/73/+kD9xPZpNNNok//elPscYaa8SsWbPitNNOe8qfG0wU43GN8qxXd9ddd0VERE9Pz1N/8TABjMc16jE/+tGPoqurKx555JHYaKON4l3velfb+y4TZY26//7744Ybboi3vOUt8Z73vCfOPPPM+NOf/hQbb7xxnHrqqfHa1762re8LT04jfZy466674nOf+1wcdthhS/XnTz/99Fi8eHHcdNNN8bznPS8iIg477LBYf/314+Mf/3gcddRRseGGGz6lmgMDAxER0dvb+4Sx3t7euPPOO5dqrhF/W6ge+9bSnXfeGR/5yEfi7rvvjre//e1L5O644474zW9+E+uuu+7jP3vpS18akydPjv/+7/+OVVddNSL+9s2JGTNmxLvf/e7HF66PfvSjcc8998T8+fMff1g94IADHn9/ltYZZ5wRg4ODceSRR8aRRx4ZEX/bVP3whz+MHXbYYVS1Ybwaj2vUr3/964j422asr68vLrzwwhgaGoqTTz45dt111/j5z3/+pOtXxUReo1qtVrz97W+P173udbHDDjv4F+FZKYzHNeoxN9544xL7g8033zwuv/zyWHvttZeqXkTEI4888vgaNTg4GGeffXYsWLAgXvnKVy7xb0PccsstsXDhwthyyy0f/9nBBx8cjzzySCxcuPDxB8bDDz883vCGN8RJJ50Uhx12WKy++upxzjnnxK9+9au4+OKLY5999omIiEMOOSRe+MIXLvW8IyKe+cxnxtve9rbYYYcdYtVVV41rr702zjrrrLjhhhvixhtvjLXWWmtU9WE8Go9rlGe9uo997GOx1lprxctf/vK214bxYDyuURERL3jBC2LGjBmx+eabx7333hvnn39+vPOd74w777wzPvrRjy7VXCMm7hq1ePHiaLVa8fWvfz0mTZoUH/vYx6K7uzs+/elPx+tf//pYa6214mUve9lS16doLH+vzMroyX4n1c4779xaddVVn/T3LUVE6/3vf/8Tfr7RRhu1DjjggMf/+wUveEHrZS97Weuee+5Z4n8/+MEPWhHR+spXvvKU5/rY79W9++67nzC20047tV74whc+5ZqPzT0ilvjf0572tNa//du/tYaHh1utVqt12223tSKiddBBBy3xZ++9995WR0dH6wMf+MATXutjv7vujjvuaLVardZmm23W2n777Z9w/Le85S2j+p1UDzzwQOstb3lL64ADDmhdcsklrS996UutqVOnttZbb73Wr3/966WqCePFRFyjenp6Wg888MDjP7/++utbEdF673vf+5RrPjb3ibxGfelLX2qtvvrqrf7+/iXm6neksyKYSGvUY4aGhlpXXXVVa/bs2a1jjz22NW3atNZ3vvOdpa638847P2GN6ujoaO2xxx5L/N7xiGjNnDlziT/76KOPtp7xjGe0Dj300Ce81sd+Z+e8efNarVartfvuu7d6e3uX+DdhWq1W62Mf+9iofkf6k/nqV7/aiojWRz7ykbbVhLEwkdYoz3o1H/rQh1oR0frsZz/blnowlibSGvVkHn300da//Mu/tCZNmtS6/fbbl6rGRF6jrrnmmsfn/F//9V+P//yBBx5o9fT0tHbcccenXJOnzjfSx4nnPOc5scoqqyz1n//1r38dP/vZz5b4f8r+3tL8672P/ZWTJ/tdmA899NCofh/49OnT44Mf/GB0dHREV1dXbLHFFkv8VeTHbLzxxkv8929+85totVpxwgknxAknnPCktf/nf/4nnvOc58Tvfve7mD59+hPGN99886Wed0TEPvvsE5MmTYrvfOc7j/9sr732iuc973nx3ve+N77xjW+Mqj6MR+N5jXrlK18ZT3/60x//+fbbbx8bb7xx/PjHP166ycbEXaPuv//+OP744+OYY45Z6m/PwkQ0Hteox6y11lrx0pe+NCL+tl+46KKLYq+99ooFCxYs9be7n/vc58YXvvCF6OjoiNVWWy2e97znxbOe9awn5P7vGnXPPffEfffdF+ecc06cc845T1r7sdf6u9/9LjbddNMn/Hqo0e6jnsy+++4bRx11VPzgBz+I4447ru31YayNxzXKs17uG9/4Rrzvfe+LN7/5zXHEEUe0rS6MN+NxjXoyHR0d8a53vSu+//3vx9VXX73U/xbURF2jHluXN9544yVqP/3pT49XvvKV8ZWvfCX++te/LvHvXtB+3t1x4qluVB555JEl/vvRRx+N3XbbLY499tgnzW+22WZPeU6P/TW/gYGBJzRkBgYGRvW7PXt6eh5/qGzyf9+Xx/5hhqOPPjr+5V/+5Un/zKabbrrU88rceuutccUVVzzh4XPttdeOGTNmxHXXXbfMjg1jaTyuUeuvv35ExJP+Dr9nPetZ8cc//vEp13zMRF2jPvGJT8TDDz8cr3vd6x7/lS533HFHRET88Y9/jN/+9rex/vrrj2qjDOPReFyj/pHXvOY18W//9m/x9a9/fakb6Wusscao1qj99tsvDjjggCf9My94wQuWak6jteGGG8Yf/vCHMTk2LGvjcY3yrNfsqquuiv333z/22GOP+NznPrdcjgljZTyuUf/IY+vVaPYME3WNyp5/R0ZG4sEHH4zu7u5lNgc00se9Zz7zmXHfffct8bOHH3748d9p95i+vr7405/+VFoMqh77h/puvPHGJTZSd955Z9xxxx1x6KGHtu1YVZtssklERHR2dqavdaONNnr8dyj/vVtuuWWpj3/33XdHxBNvHBF/+z1bf/3rX5e6NkxEY7lGbbPNNhER8fvf//4JY3feeWdMmTKlbceqGus1qr+/P/74xz/G85///CeMffjDH44Pf/jDcdNNN7X1H2KF8Wws16h/5C9/+Us8+uijMTQ0tMyP9X+tu+66seaaa8YjjzxSWqNuvvnmaLVaS3wrfTRr1D/SarXit7/9bWy99dZtrw3jmWe9JY31Puox8+fPj1e/+tWx7bbbxsUXX+zbnay0xuM+6tZbb42I+Ifffl+WxnqNWn/99WO99db7h8+/q622Wqy55ppLXZ+afxrrCdCsr68vrrnmmiV+ds455zyhkfva1742rr/++vj+97//hBr33XffEg3egYGBWLRoUYyMjDQe+/nPf35MmTLlCcc7++yzo6OjI/bee++leUmj8qxnPSt22WWX+PznP/+ExTvib39l+TGveMUr4r/+67/ihhtuWGL8q1/96hP+3NDQUCxatCh9qN10003jn/7pn+Ib3/hGtFqtx39+xx13xLXXXusBkJXOWK5Rm2++ebzwhS+Myy677PF/LCYi4sorr4zbb789dtttt6V5SaMy1mvUkUceGd/+9reX+N/nP//5iIg48MAD49vf/vYT/ooirMjGco267777njRz7rnnRkTEtttuW34d7fK0pz0t/vVf/zW++c1vxs033/yE8f+7Rt15551x6aWXPv6z4eHhJ/2VMMPDw7Fo0aIl1uJ/5O+P8Zizzz477rnnHv9AFisdz3pLGut9VETEL3/5y9hjjz3iuc99bnz3u98d1a+4gYluLNeoP/zhD084zsjISJx66qmxyiqrxMyZM5/qyxm18bBGve51r4vbb789rrrqqsd/Njg4GJdddlnsuuuu8U//pM27rPm/Vse5gw8+OA4//PD413/919htt93ipz/9aXz/+9+Pnp6eJXLHHHNMXH755bHnnnvGgQceGNtss008+OCDsXDhwrj00kvjt7/97eN/5vjjj48LLrggbrvttnjuc5/bePyPf/zj8apXvSp23333eP3rXx8333xzfOYzn4mDDz44tthii8dzv/3tb2PjjTeOAw44IM4///x2vw1LOOuss2LGjBkxderUOOSQQ2KTTTaJu+++O66//vq444474qc//WlERBx77LHx5S9/OV72spfFO97xjlhjjTXinHPOiY022ih+9rOfLVHz29/+dhx00EFx3nnnxYEHHvgPj73uuuvGm970pjj33HPjJS95SbzmNa+JBx54ID772c/Gn//85zj++OOX5UuHcWes16hPfvKTsdtuu8WMGTPisMMOi6GhoTj99NNjs802W+J3Wa4sa9S0adNi2rRpS/zssV/x8vznPz9mzZrVzpcK495YrlFXX311HHnkkbH33nvH8573vHj44Yfj2muvjW9961ux7bbbPuH3enZ0dMTOO+8cV199dbvfhiWceuqpMXfu3Jg+fXoccsghseWWW8Yf/vCHWLBgQfzgBz94/K9KH3LIIfGZz3wm9t9///jJT34Svb298eUvfzm6urqeUPOGG26ImTNnxvvf//446aSTGo+/0UYbxete97qYOnVqrLbaajFv3rz4+te/Hi960YvisMMOWxYvGcatsd5HedZb0gMPPBD/8i//En/84x/jmGOOiTlz5iwx3tfXFzvssEPbXzOMV2O5Rl1++eXxwQ9+MPbee+/YeOON4w9/+ENcdNFFcfPNN8eHP/zhWG+99R7PrixrVMTf3r+LL744/vVf/zX+/d//Pbq7u+Nzn/tcjIyMxIc//OFl9bL5Oxrp49whhxwSt912W3zxi1+MK664Inbaaae46qqr4iUveckSua6urvjP//zP+PCHPxyXXHJJXHjhhbHWWmvFZpttFieffPJS/46kPffcM771rW/FySefHG9/+9tj3XXXjfe85z1x4oknLpH705/+FBH/+7v2lqUtt9wybrzxxjj55JPj/PPPj3vvvTee9axnxdZbb73EvHp7e2Pu3Lnx9re/PU499dRYZ5114vDDD4/1118/3vzmNy/18c8+++x44QtfGF/84hcfb5z/8z//c1x44YXx4he/eNSvDyaSsV6jZs6cGVdccUWccMIJ8Z73vCe6urpi1qxZ8bGPfWyJf4B0ZVqjgP81lmvU1KlTY+bMmXHZZZfFwMBAtFqt6OvrixNPPDGOOeaYJf6tguW5Rj372c+OG264IU455ZT41re+FZ/97GdjnXXWiec///nx0Y9+9PFcV1dX/PCHP4y3v/3tceaZZ0ZXV1e88Y1vjJe//OWj+ub4G9/4xvjxj38c3/zmN+Ohhx6KjTbaKI499th473vf+6RNeliRjfU+yrPeku699964/fbbIyKe9B8+PuCAAzTSWamM9T5qyy23jK985Stxzz33xCqrrBIvetGL4uKLL4599tlniezKskZF/G0fN2/evDj66KPjk5/8ZIyMjMQOO+wQX/nKV5b6397hqelo/f3vp4Cl9NnPfjaOPfbYWLx48ZP+wwcAY8kaBYxn3/ve92LPPfeMn/70pzF16tSxng7AEuyjgPHMGsXy5Jfn0BZz586NI4880qIFjEvWKGA8mzt3brz+9a/XRAfGJfsoYDyzRrE8+UY6AAAAAAA08I10AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAaTqsEzL/p2mpmx76vTzFbJeGdxPpkbhvJMV1eeGU7G1ylMuC+PAKPU0dEx1lNgZZXdB0YKNboLmcJ9rS1mFjKLC5n+0U5k/Gm1Wkv9Z8fTGjV3Sp7ZZVZlR1Y4uQeaN1uLF2c7rdp+rbey2coPVbteK5lMm675q6/MMy9P6jxUmEq7nFr4nN598VHNgYVz8yKdhfN3pPBBdhXqdBZO0KHk5BsqfNgjhRP4qN/lmX+gY5X8Wa+k8t63o0ZlYWjHsUpLYeGzqdSpvKbK+dadnduFc7+0zrVjMYz8NZUOU7lWK5mBwrEGm4eHCxMeLp0QeaTy3lTWsWwNytawiNJH0PrdgXnoHxhP+yhgxVR91vONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQINJ1eDwyJQ0M1ioM5CMTy7NJjd/YZ4ZGcozvb3N44tH8hp3deWZDXvyTE8yl4iI/sJr6upuHr95QV6jO6kREbFeYb639+eZruT9Gxku1CjMd8PCfAcL7+9fk/lM6sxr9FTOhzwCLA+F+0CqsLYsLxvskWfumFcoVFjfGRvzF+WZXXYvnAj9hRNhpHlnd/tgflPsH56fZrbLNpgRMWVaYTNQ2eAMJzf6wcKOuLcvz0yZkUa2mpZvgrY7/pLG8WvymbTNu085JQ9N27p5vKewkeosbL67KpvmwgJfuQdkG8jKOTPSjptNg+7KzrIwh87C59MO2QNCVTbfrjadb+2YS0TtPMgileOUXlIh1Fk5b7NM4dysfAaVuST3rIiIGE4eGrsr94D8prXltPx1z9pj+zRT6dGcc/T3mwOLC0W6Vp6n0/32yF/rDXPyd/5X7ZgMsNz5RjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKDBpGqwa2QwzQwV6txfPeAo7T8jz3QV6nT2J4FFhSLTC5k2mdI9+hqTp42+RlXflOV3rHboqby/bfgMAMbK5n353XFo0XCaeaAdk2GZOKmQeXdnZx4azM+Dm/tHGscHuvfIjzN9Vhr53twPpJlbFzTPJSLiFXtMzefTmbzurvx9ib6+QiafS8+MHdPMf04/vHG8Y9eX5HNpl333L4SSz2ly4dwsGShk7s0jlen0Jk9JnYXN41D+LDYqldeRX0J5qFSjcpjCdVZ6UdlxChNu1ylZOdZw4XW3Yz5dhSflrsKBKvNN+wyF41Tm0lW45ocrr6mnebw7/xw3K6xj5x23fZrZLk1EnLm4EBpMmh4jlc7JiuHsA3rTzMhgfi51F96y1QuXx0/zCLCc+UY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADSZVg/fGTmmmq1BnuHrAUepuV6HtX9s8PjAvr/Hpa/JM16Z5pjOPlF74wkImM1LIHFDI9Bcy2Yk1rVBjoE2Z6YXMnFbz+B4dhSIAY6O7K7+RbNWX382vb8dkqrIpDy2XWUwYD1VCCxenkeH5+XmwaMGixvGpR+ydz2XmC/K5TFkvzVx6xvvTzOYjU9JM38ztmgPdhQ1bb2XXXNlsVeo0b7ZeWajwnULm0Gn5exexUSGTqWx2BwuZdm2sC3U6k2ulp7BIdd1fmMsodBbOpZHKYpq8H5W3vbMSWk5KU6lcq22y3N6bwnFGKnOprFFZpk3n5uLLCnPpySPdOzYOr92X1/jYCbummeROExERzXfYvzn2xIvz0FCyvlTWhwli22T8kxfkTYHKSli5Cz1SyDytDTWA9vKNdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQINJ7SzWWch0JeNDhRrdhUzbDE9vHu99e15jbn+emf2SwmSmFjIV2bs8XKjRl0c+UPmkKsdKMt1T8hJDleMUzOzNM3Mvah7//s/yGrvXpsMykH3EA8tlFjBm+rrye81uR05LM9cfP6cd04mYXMhkt5uF7ZjIymXx7AVp5q7FeZ2bF480jr+iN7+vduWnW8S0A9PI/Pl3pZmPnX1JmtnuyuYTasep+Uk75YBd0kz09eSZgcIec+ENeaYNTrr4rOVynIh125TZopB5uJAZHH2ms1CjcxlvQLoKT3Ijlae9RGehRiVTMdK8/tRqtC20HGVP3IX3t/Lo1Nmu152sdZ2FtXCocKNfeGptOok1D/hO4/jln94zrbFjW2YS8fpTf5NmHlpY6LB0rpMEsnOqFhkPbmxDjS0LmbvbcJyIiEfaVAdoH99IBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANJhUDQ4NPZxmhmOVNDNSPWCD/kKmu02ZOOLfm8eP7MhrVF705O/kmYNfkGd6C8c69c7m8e7COzNljTyzT2EuK6TjxnoCjMbAWE8AxtYmvVPSzF5d26WZI/rm5AcbqsyoYEYbaixsQ40VyHuvzDOH9+WZtZLx/gXz0xpT9t0zP1DB9BlvSDMfOu0DaeachcON42vOzufy77Pz0G67F07soc40cumV8xrHu6bm1/xbp09LM719u6aZiSd/tolYv02ZRNfoSzTqzM+lUma8HKdtCg9yI+14wm2nZD6V6VY+gna97K7kAXak8tTevC630+F7NM9nxzYd5/QFeeanF1U2L4WbdWc73r/xdh0sO7eO9QSAMeUb6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAaTysnOPDI0nGeGu8pH/IfuL2R6K4WOL2ROTf6/hq5f5zW6+vLMyAvyzNw8EtHKI6fNbh7vLcx3+tQ8M7J+nhnII3FAMr6oUGNeIXNUIXNaIbN7Ml6Z77RCZkohA+NNdxsyhftRLC5keFLT+nZJM70xIy80vXCwkUJmKI9sMGufxvE7zr6kcCD+3jcKma9/IbvhRWwyt/lGP9xd+IDbZLsZG6WZrXrzG/DdA82bigcKc/ncwsE0c/LC2Wlms8KxfpWMv6w3X5i//oWvFo4EEdFZuUlPICOV1zPOXnNn8lDeVZhv5XWX3pvCw3+6F6hs6vKHyrUPyB/2/nBB/rA3PHBVktgprZFViIg46vif5aGRwnN7dj5ERHRlmcKGrXCYFcVDYz0BYEz5RjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKDBpGpwve5V0kxXoc7wKMcjItYpZDoLmTj1/Eqq2YkfzTNTXlEoNCWPnD03zxw1Pc/MGEkCi/Ia8xbnmdndeSbuyiPnbtg8vuj2wnHm5JGLds8zCwtn1tSjmsffeHShxo555mevzjOwPM0qZLLlJyK/mVxSqLEiasdNNiJin+bhM+NraYkvx8z8OFMLcxmenGcG8xc1NFB5c3gqHmxdX0jl98T7B97ZOD6w+Na0RmGHVNOTR7753SvSzLsOfF3j+NBQf1rjpv6F+WQKftWGGiODlYW5XVqFTMcynwVPYnmeBpmRcTSZ0lTG2T2oa6h5vLMdm7GI0hP3SCGTrZld+Zoa0/MFvqfr3jTzh8n58+tVVzY/V9505ClpjZcf/5s0E4uTzzEioqewj4rBNHHMZ/dsrlDYX553yHcLcwGY+HwjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAaTqsG+yXlmpGs0U6mrHGakUui+A9NIZ3eSmZcfZrg7z3T25Zno3yKvMyUvs3h4m8bxrs68Ru9Qnil9UMvpnIn5R+WZqYU67Zjvg59YPsdh2dinkJlauKBPXDzqqYw7vYXMokJmcLQTaaPCeli74bTB7oXMrEJmWvPwosHZaYnP9SRFIiIi3zisVrjhPNSV30QfmLuwMJ+x1Wp9K81cePbn0swBb7myDXO5sZBq3iv8zbVpYtHC5rXuvaeemNa4bsYJaaZnZhop6Z62Rpr50k++2zh+0wUXpzU+d1r+WV+6aG6aqehJNhVd3YWN6qIH88yU/L2LqGwgn1HIjCe/LGTyPTy0T3ZNVzY3FZUN0EAh03yf2PaofPN9zgGrpJm3vvGNaWa1wjPYr65c0Dj+0gNPTWs8snjD/ECdhY11d38aueCru6aZ/Xuax19V2XoMFzLjwJbJ+C+WyyyAicw30gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA0mVYPbTc8z9xbqDFQP2GCwkOksZCZ355mRZPxzw4W5FI5z+4I8s2HhRd0+J88MJi9qk8l5jd7C657Sm2eiL48MJ8daXHjvojDf3oV5pr8rz0yb2jy+XaEG49iUnjSy5u7T0swDkwsX2oFzKzNaPnYvZArXWVTO/+X1sis3igMKmXOT8cpaeFQhU6lTsWfz8JQf5W/Mzd2FBbMru4NGRFfhOhgufFAXjKNr5R+akSb2PyK5gUTE/kfMSxJ5jYhtCpmK/PMbGmpeGCr7wpsW/iTN7DazXa+pIDklt56Wb5p7+65OM39YlJ/XaxcW1eFkwosHh9Iai/vzT6pvyqZpJuIZhcxEU9mILk7Gk4UZnpLk4bNwe47I14XoLGTybXO87IBZjeP/ccAqeZGC7qFFaaZzKH9NDyXv3x8uOCOfTN8ReWZa/jxx5flbpJndCnvvG5Lx73zgR3mR0sZ62Vq7kHl3sp8+s7AxublwnIcKGWBi8o10AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAg0nVYE9XnplcqNOZHadQY6iQqdSpGE7GO7vzGpX3rlAmBvrzzFa9eSabT2/hzVuv8JqGBvPM7YvyTFamd2peY7hw0kwuvHe92QkREevlESayofwk6OzKVrqIjadPSTO39czN51O4ztqicH3EnEJmZLQTaaPphcyCQuaoZHyPQo2BPLJaYa176AWFYyU278rvSH/uLCzehc/6oa4ZeWiocmJNBOsWMu3YvfS1oUZVvtbd3t98Az58Zn5i71jIjCc3L8gXjjlXXtmWY1WW1GwLNFzYWd8/XNgArbTa8d78rpDZqA3HaZBfzhGdlVAbdBUeNJaXkcJVVsksT9l0Ogvz7c7P66dNz5/+P3Tkpmnm3ZU9ZhsMDy5OM92FU++BNFHY1BXe32OO3CLN7NamS+WgE+9sDiwuPHB0L9sPcnYh86+FzOnJx5M/odUyXytkHilklpffnJLvQa8ayq/5I06rPDyN3tMKmZOOmpVmblmYP9N85crCcw8rFd9IBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANJhUDXa16YBbtaFGTyGzuE11upPxw6cXirTL1OV4rDbomZxn+pb9NP4m+yCXdx0mrsXDaWRocCjNdPXlJ9OaPzoizTzwgrPTTGqfQmawPZkXF8pck4yvPTN/795wyr5p5nsL56SZ2zr700xkH/eJeYmYn0ceatc9YGbz8JTeJBARFw5ekh9noLBgTi5kuisn34qio5DZdJnPoi5f67aaMqVxfMrU/FrtmrpKeUbLw8CcXzaOn3nGmWmNG0cqO9XONLHbtFlp5uaFCxvHV++q7PLza3Vk8OE009kzUjjWGoXMeJJ/ThF3JePzCjXy6y3iBYXMP1J5HW3QuZyO0y6V+Y6715RdZ/l9dc3pvWnmpH3z+9G/52WWm/0PODjN3LwwvxY/dXZh05Z4SV++Fu5YOK0qK+rpV+aZX8xtvk+UHuyX8XXQXdgy9hSWyZ8m47cX5vKZQmbzQuaEQqYd3t+8FYuIiL4Tbkwz3Yvzc//WkfenmfWSU+XfD3hfWiN68sVluHBKDizKn/UGFx7UON5ZeJ75/BfOSzO9kyvdsfyqH1jcvMe8es7VaY03nZj3GB5KEysu30gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA0mDTWE/i/+guZry3KM5//wLVpZu+ZO6WZjx1cmBCw8piTRx4ZykNDn94nzXRNnZJmHvh0b3Ng0UBaI7rzSJybR3YolJlWyFyTjP9h7lBa43unnZ1mduvqSTPz80PFrclbvOGCvMbkPBJXFOo8rVDnkWR8UeQ32Z6e5LyLiJhfuKOPHJ9Gnj1rapq5+wOF83yF0UrGK+9F4fOLkUJmME3sfcDhjeMD/V2FwzyYZ3rWyMssfDjNdI7kr7uru3nOG07Or+gNFubrz9bTZqWZd5/yvjTz0VM/2ji+4/Tt0hqrd+fzHRzI37vewuc08eT384gLkvHCzaZwvY1O5ZqvZDrbUKOgcK2mUylpS5H2qUynt/l63Wz3LdIS3zsyP8wN836SZtZa98Vp5v57Cmt8G7zhiH9PMzfMye9Ju03va66xIL9W58+bm2a+d9o70szwER9OM1+aV1hfOpP7VnLf+5vKOrb0hgqX/N6FOmcl468o1Li6kKnsxmbvkT8ZDQwsbBzfZUbz+RgRMeWEc/LJDOX79htmX5pmhhfnzxF9M5pf9+CCG9IanX2bp5nu6fn72zclf97+0vnnNY53Tc73SN1T8rkMLsof9gYH8/VlyoxZjeNv6M3nssseO6aZ9x6yX5o5r/D8OhH5RjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKBBR6vVao31JP7ehQvzzEln/zLN3HbuoXmhkXmFGXU2jh508E/TCl/6whaF4wCj0dHRMdZT+F89hczMPLLZ+SekmbVGhhvHp190ZVpj8TvyhXfa5DQSA4vzzFAeif5k/K5CjcFC5qFCpmLbZHx6V16jp/D+LlyUZ3Yr1Pli8gZPOyKvMbxvd5r5ytmFT3tm8z02IuLZM/KL5e4t8vO8HZb9lum+Qqb5mo8YKNSYkkcWvyfPzC8ca9+vNA73z70oLXHp7JvSzHULKld9fr6dfMrJeZmhkcbhz519elpiq8nbpZn9jzgwzfQXzpkvz2l+j3ebuXt+nIXZyhzRVbj37b3PrnlohfS7ZDxfUyOe0YZ5/GMd2/xXHhourOud2U0vvw6ju/B+9GRrYUSM5OdtTM5unIW5pK85Ys3e/ALpTPZ0ERHr9eTzOXz35j3xm/vSElHYusQNC3+SZqa/INslRcy+9prG8b1m7FSYzcSyaM75aWaLPQ9qz8F2/0ae6Uz2BZUNfEHr2hcs9Z+9apX8WW+w+fYcEfljWmU1nl7IVJxxwL5p5u0n/HtzoG9q4Uj5Q9rpu74wzXxybv4Gb1iYzYePal6ELj07n2/3tPw4H7r2xsJsCgtiqnBfizUKmWyvELFo/tw0M2V6sq8bLqzww4X750j+cPqm9V+XZs7LjxQvScZ/WKhRUX3W8410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGnS0Wq3WWE9irLzqkPPTzHfOPWjZTyQiXnPA/6SZb56/7nKYCUxMHS/oyEMLl/08IiKir5BZnEc2+9nBeai7s3F463dckJZYNHs4zdyazyR6C5ndmqcbERHdSaGtZ+Y1Fi3IM7cWzoeRPBLXJeNrFWp0FzIV7943f3O6k3NmeLg/rfGqCxalmZGjutLMIzMLr3y4kHltPp92WPZbpocLmex6HSjU2CJNLD5wozRz8yX5ubLXg8tnmzm46J40M9KZn5O9fWsUDtY8/P+2f2Na4qbF89LMn3/2uzQz1PtgmvnYRac3jm89eau0xitmvjrNdHbn529nrJJmGBsdO/0sDw0PFSold86RfM8Rvflm4Wm9+frz9hn5zuRDB+/ZOJ6vGiuvq+Z+P83svuvL0szaU3oax+/9Zb6+r4jetNP2aea8efPzQjPPKhwtuVZGmj+jv8mvlta12xTqPLmbn5E/663Thgv2pMI26pzRHyYiIl7cNznN/Oe11zcHetdPayyafWKa2erVH0gzj6SJiJcUMrslp9OXkn1WRMSGheP8oPXDQmrXQoalNvezaeSwXd+aZg4/bnrj+NZHHp7W6Fg/7+1Wn/V8Ix0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBg0lhPYCxd/oUD81CS6ehYpXCkkTTxrQuelWbWuvKcNHPrnYekmZ40ARPQwrGewN8ZKmQ688ivrpybZjbYY0bjeM/uM9Ma/9/5h6eZnZ/xyjRzTZqI+FW+HMZbB5rHr74gr/GKWXnmfUftk2b6589LMxfObp7wLcnrqfpKITNtQX7OfPK7P2wOLBpMa3x5+Jg086aL+tPMA7tPSTOxKK+z4sjf+3zx6GrHRKKvu3ltiYi4bPiithyrHXqmrNuWOosX3Jdmuruf0Tj+qc/m+7UrTzszzVx1wRfSzG6fODjN7DVtw+a5XHJZWmPvWa9OM5Ub23D/d9NM1+Q9C8ei7bqnFkKL8shQsmZPLTyJXPSSNPJIDKeZrWfm12J7VsyVU29vb1vq/CHZd/QP/yatMblr07bMZTz50rX/lWaGT7s2zXzjguvyg3W3oUNQ2OOPxlbdhVDhZdycjJ/Tpn17xTWL8z3u4GBzpqd3/bTG7QP5cSpX8xsKmYobKtvdxN7TKqm+0R+I0Zl5QBrpj7emmbeeOr9x/Mt9+Rm8dhsbob6RDgAAAAAADTTSAQAAAACggUY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaDBprCcw0T3YejjNrNHR0ZZjPTBwaJpZtyPPvGyP8xrH/+O7B1anBCuf7kJm9848M31qnhkaTCPDQ0ON42fNmZPW+My0mWnmP3/5nTTTscUr00zFVlO7GsenTM4/hK6u/DM4/cRL0kxfXxqJ951/QHNguHA+9Oav6ZPz5qeZD504L828fpuXNI5//Ze/TWvsvccv0szXOp6eZr51yYI0U7vo2mDW8jlMs5FC5spkvPn6KWem7Z9GOuOivE72kgqXR8VQf74f6568Sp7pyc+36+b+rHF8lxkvSGts95Hj0sxa2+T7x8t7bk4zuxz3743jFx79nrTGTed+Os1svc8eaebCUz+aZo44u/lecu6RPWmNN3/6njTD/zGS7zlieFEa2e/8VzeOf35afpjLphycZqZO2STNbDIt32sNDT3YON7dvUZaY2W11ZT8/V27N7/f/GF4uHH8k6edntb40Aknp5mRgcI5XnDZlc17resW3p7W6C9M5ZaB5vclIuK2Kwv7qCl75Zmu5N6XTyVqe5hRmFzYMHTmmTmLSy9m3Lh5wXWN47tM3T6tsdu+b0gzVy3M93Tdc/PP+Gv5bSIWJuPr5CXizQcUHtJio0KGZSu/h/YW9t5XDDb3PLY7ZHZa4w9pos430gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA06Wq1Wa6wnsaLr6Hh1ITV7WU+jrTbuOzLNfPPbn04zW09tx2wgoqOjoz2FpiTjw4Ua+3bnmdOG8szBhTqLkzqT8xJrnptn7v/djWnm5jmXpZlj3vKBNLNLT/P4/gfskdaIzjxyV/9AmhkazjOLFzdnJk9OXlBEDA8OppmeqXmdDaflH/j3LljQON47fZ+0xmVzrkwzb5+1e5qZdtolaSam55GYX8i0wbLfMj2cJm4YOLRxfGh+vkjt1vuGfCo9s/LMRfl5EDOTRXXGRnmNcWaov3m8q6tQY+F9aWbzXZ+ZZ/JDxY8fbl6/P7rrK9Ma02bk6+5uH/lCmum/4B1p5lUHntE4/tO0QsR+hf3ll3/2w0Klwk00khMiIiJ2LWTGVsc2F6eZQz/92jTz+Rmjn8t1p74lzWw9a/80MxC9aeaWwZHG8VfM2DStwT/2r2/8lzTzrSuTe0lh733uFz6VZm6df0Oa+fAZF+UHa4tpeWRKvo+K7sJdoDPfP+Yb58KNrbD5bl27faHOP3DgC9LIdQsXppkZzdvgcecDBzfff9/3he+26UiFPe4lr0sjl74j39tfnTxeLc5nEpd/IX9A6Dz4vwqVKh5Mxtdo03FWTm/a5hlp5rwFzT2PDQrHuaOQqT7r+UY6AAAAAAA00EgHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACgwaSxnsDKYIeZu6WZ6+fOXvYTaaPbFp+RZqa9IM9UbNC9R+P4sSecl9aYMmXdNLNb82FYWew7uXl88UBeo38oz4wU5nJ2oU7m4DzyQHeeWWejbdPMva1WmvnwooVp5q1nzG4c71vQn9ZY3J9n3n1c4c3p60kjG86d11xicl9+nKH8vPrcJZfkZfq60szU6c3zWTj/yrTGwOL83Jx2Wj7fkvntKZOavpyO02iVNLF579TG8Zu682sspk8rzKUjj5zwL4U6K57u5DZR0TPtGWnm7bP2STMnz86vs5tPPbNxvLc3X6N6enrTTMR9aWJkcb42/8dxMxrHvza7ec2NiPhk4TL46J6vSzN77bt7mrl1YFGaecVRb08SB6Y1lrmefGNyePNHU/LSF6yfZn64ML8nvrNz7zSz/1EbpZmt0wSj05lHBkd/lDNPOz3N/LSwfxxX+l6RZ4YLdSrPHMNJaKRwoM7CZz0aXfke9z0Llu0UxsIJ585pHH/fJ+7Ji3TnvZDSvm+fT6WRvafkG+ruDxzdOH5m4RHi5sLlXFrfhx/OM0OLm8eTvfnfFN7feLCQWaOQWU4Gf5ZGbiiszSML8ufKHZLxmWmFiHz3WOcb6QAAAAAA0EAjHQAAAAAAGmikAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADSYNNYTWBlcP/eDYz2FCe2OoTmN40ce/azlNJOI6DwgjVz03U81jr9h92e0Zy4saWYhM1LIdPU2j1/QX5nN8tOVjC/MS6z2kb4084e3LE4zL19jlTTzH7+5Is28feG8xvHJ02akNfY+bpc0M7Tge2lmpD9/3X377t8c6OxMa3zvxI+mmaHKqdefH2swmc/Q8FBaY2p+ysQV+Vu3/JySvy8vPvio5TCR0euO5vNtl5nN18/fbNSeybD0uvPISed/Jc0M77kozZx5xgWN45/8wjlpja7Cujt0wZlp5qpLZqeZV8yY2jg+dXJyn46IvQcG0sxe02almSndU9LM/QvzY136luZngR13vyqt0Tvrq2lmVDrzhf2fj/5Jmnlk4aXNgcL7VblAPnVlvq5/ajg/0gt7msf7Juc1XrFHnnlzHlkhjYxUNt+j99MF42x/nuksnDSRnJwREcOFk7zyAJR9ToW9YeSX5KhcNnt+mrlm2U5hXNp51+emmf/8yYNtOtr6eWRqvtrt9tkNG8c7e45Ja3ROzh/+F837WZr582B+bm89Lbs/dqQ1YjifS3QVrvlYo5Bph3y+p2//wjRzV+F58A2V6SQqy09ltazyjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAaaKQDAAAAAECDjlar1RrrSUxkXzz3vjRz8CHPXPYTYaWz2dQT0sx7Tzklzew/qw2TGQc6Tlw/Dy0ayjOXDI9+MstTXzK+uE3H2beQuSiPrFYo8+f/Oq9xfGjRXWmN7j1ekR9oYDCN9M++LM1MntLTHJi2Y1rj6rO/lmYGF85PM9tNS+YSEbcPN18HF160IK2xuHAp/XAkzyw3X52SZ3rzF9WaeWcbJrOs/aSQ2WaZz2LCGno4z3Svsuzn0UY3nPiOxvHtjjg8L7IwXxfO/MB70swt8/rTzP77Tmsc7+zM17l1+pprRERMnrZ1mhlefFOaufCSws2vs3lB7O7pTktM2T1fx7Y++Nv5XP6Bjl1/k4cGF+WZ4fwzTnX25pmubAMUEZ1deWZkIKlRuJn1TU4jz56Sz+XmE/K9bH72jy8dHR2jrrHtPvkm9Kzj3p5m5s6+NM3csLgzzXzrolOTRGHPMesbeWY4n0sMFZ5bRgrn8FCyBxrO98wR+Xxbd762UOfJrVU4lx5Y6uortnt+9sM00zN11zYd7Xdp4uq5c5oDhXtvf7J0R0QMDFXuAfl5O6Vvw8bxzp4/pzUWLMif4/Y/eP80M3nKq9NMOwzMOS3NbL7n0WkmX5kjPlS4nWeyJSwi4nuFZewNxfa4b6QDAAAAAEADjXQAAAAAAGigkQ4AAAAAAA000gEAAAAAoIFGOgAAAAAANNBIBwAAAACABhrpAAAAAADQQCMdAAAAAAAadLRardZYT2IiO/YdP0kzC+ddlmamT9suzZx87itLcxovzv7I9WmmZ0pfmnnTIYc2jj8wOLs6pQljg76D08w3v/2FNDM0lB9r68l5pqeQGWuTztgpzTzyjnmjP1BXIdNTyPSPdiLL2RcKL+odg3lmOI/M/sg+jeN7HXdOXmRgfp5ZPJJnps9MIzcd3bxGxfBAWmOtwhtz06LFaaa/P/8M+qZ1N45fdmW+cCwufI7X5JGawvqz7c8+0Th+4yVH50UKp0PriImwZbqnkCncHGLT0U5kHHo4TVx22gfTzF5HndKOySxH9zUPL8zvjWceclCauXpBvv7sMjPf902fNqNxfMPJU9MavVM2TzODi25OM1ddOTvN3LxoUZrZPN3vdqY1vndlfl/7+oNLv0Z17PTLPDRcuM9nRgqLbeH9iM7ChqyrUCc/UHsyI/k9fPZ//Uua2aswm+WlsBWINToq95Lm9+aS3+Tn9d750tI2G36g+T57x5Vz8yLdhc1N5Q2u3M4r11z20DhcmExnfh207nx1Xucf6OjoWOo/u7J7YeH6+P8K11nF4rnnp5nd/qV5T3Fb5TaxAlqtkPnzcmrfDs/5bppZY8+8P/nCwrH+v+mFUPPja0RPFogYHsgXzK4f1d5f30gHAAAAAIAGGukAAAAAANBAIx0AAAAAABpopAMAAAAAQAONdAAAAAAAaKCRDgAAAAAADTTSAQAAAACggUY6AAAAAAA0mDTWE5joPvbpbQqpSiZ30hdaaebfTvxdmukaScajM63x5gPWTzNbTUkjJXvP+nbj+OmX5DWmTs0zu7Vpvl+b1zw+NJTXOHyP9sxlPElOu4iIwpn3jz0yO3nj22W4kOkrZPpHO5Gij/TmmYUDeeaQwTxzQk8aWe2CvE7/SPLmjMzP59JbeN2Di/LMQJ7Zeve9Gse/OPvMtMbNl+SvabeZ+UI2rbcrzXR1Ni9Ce09PS8TVhXXsmgV5puSofEG8cfHZzYHC6VtapCaEddPEosG5aWZKz6btmMw4s0qa2Kp3w0KdbK+1UWk2y0/z3XXxnMvSCp+cn19EW+fLT8yYOTPNrNXVvH4Pj7RpR9GZZyrH2qQvv+nfML95QZxbuA3/Io/E1wuZ0RnNTu2xEm2oERHtW7Sz+bTnXIooXCATzKWV+3zf2/PMyP2Nw1tV9tVt8sXC/vyOK5N76FDlYaGQGWnXtbK8TLT5rjx+uriSeriQyfdRf+6/K83ctsLsudvroULmg+/YNc2879M/GvVcuvbYM828s/C4/anC/uaywnPlXjOSgw3kB6qszNU7tW+kAwAAAABAA410AAAAAABooJEOAAAAAAANNNIBAAAAAKCBRjoAAAAAADTQSAcAAAAAgAYa6QAAAAAA0EAjHQAAAAAAGkyqBkcKmc5RTITcYCFz0ikbjfo4lc+xq3BCLCpM+Ob+PNPZ1Tw+c4+8xvBwnrlsUZ7p6ckz283IM5lLF+aZRYX5/rnwujdJ3t+IiMmTm8c7p+c1Fs3OM4fPyjP/0PxR/Nm/87KPNL/Y/zjuG2mNk4Zfk2ZOvnIgn8yr80hqoHAhziictBfNyzMfyI+1/wn5yfLmGbs3jg9ecGFao2ffN6SZGLw1jyy4Pa/TuU7jcFfhOtxuel+a2XrK1DRz8/wr08wmfc3n+HBnvrgs6MtvAhssSCMRhbXjjp7CYjdncfN4/tZFFNbdFcVfo7D+rKT69j24kOpY5vNoq6Hmz/vSSy5JS6xeOMwuM5LNQkSsU9hI3Tsw1Dg+MpKvP33TpqWZnuH8OpgyZUqaGS5sMr83p3lB/GtaIWKHQob/qw1Pp+16wC2ctxPNmXMfzEOd+boQXc37x7sKc8mv1JqPnfuzPDSUXfOFh6uhNnVXOisn6Ip37rEsrNKWKpWe1cumNe8FrlhQqbJyOuGMuXmo/7WNw+/7wnlpiavn5s+Uc0cKzbHCGTGr8Kh3Rmfznq2z0FecXHgmf0UeiQjfSAcAAAAA/n/t2mGIZeV5B/B3yF7BG5pb2ilxQKck44cR3ASHdpeyNmQJu7SJRVvcErdBLVHQNk20K9Q0mkg2rQ3RGjeUWBvbxpS1ZbdlF7LSrMRZNrONI+1IOktzVzoG74bMijeSa8hFvMj0w7YfStf3ebJzdnbW/n5f3/885z3nvOc95z4MUKWRDgAAAAAAFRrpAAAAAABQoZEOAAAAAAAVGukAAAAAAFChkQ4AAAAAABUa6QAAAAAAULEhG7xobCyRmkxkZoLxhUSNYSLTT2Q4e9sTmWsTmfZqJ1JKaTWUycwlk4meg8xzclEcyZzSKJFJWakPb0zsD92/DSO3vX5zajZndHd8bz6y9ZYw87WrHz77Ofy3+9rfDjOXXfcrYeZjLy+HmdceDALDxCL4vbk4k1n6m+PIo4vzYeahzfVCnX7inLpLcaYXZwZlOsxMdsbr46344i3243fWxMf/KMx09oSRcmx+tjp+cDG+vicSt+D7caSUeDmUMszcy2A8sTbLVCLzFvHu8c75nsJ50bvmE2Fm8uF74kJTv9DAbNbQ7OHq8KuD+Lt6JvEO6IzX98JSSvlhYq9bWOxWx9ut+DibuvUapZQySrwfO534WZmdre+ppZQyPV2vMzWK57Lcy/z+WY3GPhrfWjKXJfNNfoF5NpH517n4O7W0E797RvW13U0s/fcn9qjHEnWeP5zoRUTfde14jyqDOLKmC6vVwLES+xgXutfDxGAQv+f/4Pbbq+P/fOvu9Iz4v+49sG9V4+vRxxdXX2NvYmvO8h/pAAAAAABQoZEOAAAAAAAVGukAAAAAAFChkQ4AAAAAABUa6QAAAAAAUKGRDgAAAAAAFRrpAAAAAABQoZEOAAAAAAAVG5otN5PIjAfj2xuoUUopw0SmlciMgvF+okY7kRkkMsuJTOacokwnUSPjZCKTuX5LwXjm+mZE97qUZu535vom7uOoqfOeTWSC817MHCdzfW/OFDqzhfiZ/7u5PWGmd0s985c7/iasMZ04j4+Wo2GmM/5bYebz99cv/guJbeOVzBJI3OP33f/ZMDM9c0mYObjn8er4DePTYY3ulx8LM5/6anxSo4n4Wfz7u3dVx7fMbAxrtDqJfaHXCyPt9mSYOTZXXxT9xKN6Z3wLyq7May0js79Ep52pcVciszOROe++GybaqW+FHyUyP5vIrI39V1wTZnZ0D4WZlamJ+GAP352ZUuDFBmqUUhbjxf3s/LF6oBWvh+VhvDEMh/F7eGkp+qYrpd+vf3O0E/Pd/+VHwsxoGH/T9fvxvptxcbv+zbawEL+sjzcyk4rMZxrn1HLmZ0bmZ3ADPh9vl6X0EhNuJ75vBvXME4nv1OHWOLPr1mfiUOYCR99so8Q7NrGP5X4PJnoeo8TDHWUyNVLfFlzY4nf4aBC/zxbnuk1MBn4qOxOvrBuStfxHOgAAAAAAVGikAwAAAABAhUY6AAAAAABUaKQDAAAAAECFRjoAAAAAAFRopAMAAAAAQIVGOgAAAAAAVGikAwAAAABAxYZmyx1IZCYbOE47kek3lAEuCAeaKXP0cH38is2/G9aYe+aFMLOlbAkz15cvhJlO+Vx1/I6JubDG6N/CSPnxXXHm6DWfjjM74jpPjerjRxbjc3p0Pj5OSi+YTCnlqcP7quPXXndTWGPTddvCzBO7fz/MbJvZGGau3TldHb9kvhfWeKQ7DDONaSUy0et8TxMTWS9+EowvhhUG5UiY6ZR47ZdycyKzNsaH8UK5NFNokDnvqMbTcWahmygUn1N37kiYWVxYqI7PJ57n5TBRyqA/CDPDYXx9jy8sVcenpuK5PHV4Nsw8F5cpVyUy135oJswMh/VrPDMd34OpQXx9Wc/i5zl1i8dXP5PML+B/2vufiVTiBT1MnFS7/tv+6J5vhCWOPpj4Lhl24kwn0auITjvxPiqdzLVLvI8yn2PB/pPKjDLvxjX8NuQceDGRybzD4x9hnztQf8/Deuc/0gEAAAAAoEIjHQAAAAAAKjTSAQAAAACgQiMdAAAAAAAqNNIBAAAAAKBCIx0AAAAAACo00gEAAAAAoEIjHQAAAAAAKjas/SF7a39I4PybON8TaMh8HLl6bHeYuWOlE2ZuKDvCzLbyF9XxfylPhjU+1vpkmHnigTBS3piOM5nr972gzqPDxHEWE5lMnYR+dCtHo7BGd9/BMHPDrj+M68zF93v/oW51/OLxsET5ThxpTiuRefCcz2IdWQ7GT4YVTpb6GjidiR+QK8vNYWatvP+v/jTMnNy7LS70wC1xpvd0dbg/uz8sMer1w8zx7lKY6Xbje3miV7+X3wwrlHJpInOqH5/TYBDvh4NBfXxpKT7n42GilHi2pZzIZBL3YNv27dXxqen4BdpbitfDW0Yrs/GvJ/G6LiVY2KWU9uonkvJY5hupF71rSint+Fu2DBPXphWcebQplFJKKzGXTGaUWHtRpJ24k5klkwklvjFT5xRlUvO90J5b/peFQ3FmZiaMPHEgfle9kZkPrGP+Ix0AAAAAACo00gEAAAAAoEIjHQAAAAAAKjTSAQAAAACgQiMdAAAAAAAqNNIBAAAAAKBCIx0AAAAAACo00gEAAAAAoGLD+Z4AcAHYGoy3JuMah3uNTOWt4ou/Oggzw299JcxcVbZVxzvltrDG18ownktrd5h58vYwUl7bGWfKUjA+HZd45y1xZtSP1+0re+N1e2Spntkymg1rPNfrhpnxjfF8p6emwszFo/r4vfFUmtNKZP4skQn2qIWnj4YlZq54X+JA59rLiczyqo/SW44eslL6g36YuTLxLK6Z7Vc0kxl8N4wsH9pfHT8+Fz/zrVG8+Jd78T040Y337/1xJHRZItNfDjaXpPHx+viomcOU1xKZzA+ldqcTZqIpDxLP2/Huud6cG7qwTWhlXg7rSeLatePI5MTqZ5Lx0L54nyuJb8PSDh7WUkppxc9H/FA3tR4aqhPt36PEtctsZMNMncQ5jRKLL5pPpkZj94nzYTQ8FWfmj4SZ5xuYy3rz3mAbOx7/rC9vNDMV1gn/kQ4AAAAAABUa6QAAAAAAUKGRDgAAAAAAFRrpAAAAAABQoZEOAAAAAAAVGukAAAAAAFChkQ4AAAAAABUa6QAAAAAAULHhfE8AOM9umokzX10IAr1GprIq44lM/5zPIm8ujjy6O85cde9nquO3lXZiMp8NE/9YbgwzXyq/EWae6iyHmRMzg+r4862wRHkpsyT3JELR0i+lLA9H1fGD0/HNnpy6Osyc7A3DzP65vWHm3vrlXVv1S5f2ka/Xx99RHo+LxLdglX6SyOwLE6PyanW8VX4+rDEYxIvgyUPxs3rjdBhZZxL3YHkpjLywVN87lrpxjYnOZJg53o3vwXy8LZSX4kgjnk3sLZck6kxP1MdbiXfAKDGXSxNzmekkjjWKN7Ijs7OrrtHrNbRhvvkkmslkbtCFpJV4yMYzizJeTI/si/eo3szbw8yJ4Hv3pfluWKO0Eou/NHWvg3W13tZU9BwME2sm9bxl6mTWXuZYcWSNinAOfCbxc7/VjtfSnXd9uoHZNOPnEpnMzpFZtd9ZT7+dWBf8RzoAAAAAAFRopAMAAAAAQIVGOgAAAAAAVGikAwAAAABAhUY6AAAAAABUaKQDAAAAAECFRjoAAAAAAFSMraysrKSCY2Pnei7AT6OVyOzYGmf2zq56Kk1JbkdnNPb2xB41POvy69cD9eE/3jUelrivfCHMtMpN2RkFDoWJL5XHquOPlwNhjZkyFWaWFpfCzDffE0beci69vxNmvj83iAt1EweLl2f5mXsnw8wHP9Svjm9KrIddv7gYZlZePPs9ark8GGaenD0QZqY3TlTHt4xvCWs8Vx4PMx/+7YUwc+d1j4aZ23beGmbWk/2f+M0w86k9B6rjo8Rx3p3IZF7zTyUybwTjb0vUSDyqqfO+MpHZPN2ujne78cs8M5eJxEkNEltdL3Gw6FAbp+rnXEop7xiP9+Z7nvlBPJk3MXbFt+JQZlG2MqFAO74eayexCEr9HXQ6ksiMJ847c22iezBIfBC36u+a05nEQzRKrIfRBfaBPgoe+mg8mxkmrktmeWYub3iszIHie72y8juJOme2nvpR70pkvnfOZ3HaBxKZe3bE39KjxJr88IHlxNFiHwy2saaWfma2/5HI8P9Hth/lP9IBAAAAAKBCIx0AAAAAACo00gEAAAAAoEIjHQAAAAAAKjTSAQAAAACgQiMdAAAAAAAqNNIBAAAAAKBCIx0AAAAAACrGVlZWVlLBsbFzPRfgf0w0VGe5oTprJLkdnZE96k18I4780vY4s720w8x95R/CTKtcEx+sPF0dPVYOhhW2lI8mjvOeMLFULg8zl1+0VA+MElNpysY48msPbK2OP7T9i2GNv17aH2bmSjeeTOLibJ26PswslWer45vKVWGN+/beEWZe3fmjMPOm9ffF623fvsUwM7O5Pr5pZjKs0Znoh5mbrhmGmXcOx8PMqR+8HGaa8XqYOPaVPw8zv37rJ8PMj1Pz4Uw+kMiMd+rj/UFco5U4Tn3XOO2VROZdicz1G+vPymUT8YffqeX4o+5P/v3sn7exy+vv3tMSL7R28L3QStydTCajiTqjxMf0MPPBHX9HlYl4/07VGQV7/CjzYRI8iKWU0srMJXMP1vJDqQHR9RvG789cJnFdEmXKIHN9o0zmQLGVlZvP+m9/OfFb71SiTrRqNyRq/DCRyVz1xOusvBGMvy1R48aG5pI5p8RPkfBY8Vdq7j2/VnW+najBhSHbj/If6QAAAAAAUKGRDgAAAAAAFRrpAAAAAABQoZEOAAAAAAAVGukAAAAAAFChkQ4AAAAAABUa6QAAAAAAUKGRDgAAAAAAFWMrKysr53sSAAAAAACwXvmPdAAAAAAAqNBIBwAAAACACo10AAAAAACo0EgHAAAAAIAKjXQAAAAAAKjQSAcAAAAAgAqNdAAAAAAAqNBIBwAAAACACo10AAAAAACo+C/Pyeweu01S6wAAAABJRU5ErkJggg=="},"metadata":{}}]},{"cell_type":"code","source":"import os\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torchvision\nimport torchvision.transforms as transforms\nfrom torch.utils.data import DataLoader\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\nimport wandb\nimport matplotlib.pyplot as plt\n\n# Initialize WandB\nwandb.init(project=\"cifar10-hybrid-cnn-mlp\", config={\n    \"epochs\": 25,\n    \"batch_size\": 128,\n    \"lr\": 1e-3,\n    \"cnn_out_channels\": [64, 128, 256],\n    \"mlp_hidden_units\": [512, 256],\n    \"dropout_rate\": 0.3,\n    \"num_classes\": 10,\n})\n\nconfig = wandb.config\n\n# Data Augmentation for CIFAR-10\ntransform_train = transforms.Compose([\n    transforms.RandomHorizontalFlip(),\n    transforms.RandomCrop(32, padding=4),\n    transforms.RandomRotation(15),\n    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n])\n\ntransform_test = transforms.Compose([\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n])\n\ntrain_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\ntest_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n\ntrain_loader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True, num_workers=os.cpu_count(), \n                          pin_memory=True, prefetch_factor=2)\ntest_loader = DataLoader(test_dataset, batch_size=config.batch_size, shuffle=False, num_workers=os.cpu_count(), \n                         pin_memory=True, prefetch_factor=2)\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n# Define Hybrid CNN-MLP Architecture\nclass HybridCNNMLP(nn.Module):\n    def __init__(self, cnn_out_channels, mlp_hidden_units, dropout_rate, num_classes):\n        super(HybridCNNMLP, self).__init__()\n        self.cnn = nn.Sequential(\n            nn.Conv2d(3, cnn_out_channels[0], kernel_size=3, stride=1, padding=1),\n            nn.BatchNorm2d(cnn_out_channels[0]),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n\n            nn.Conv2d(cnn_out_channels[0], cnn_out_channels[1], kernel_size=3, stride=1, padding=1),\n            nn.BatchNorm2d(cnn_out_channels[1]),\n            nn.ReLU(),\n            nn.MaxPool2d(2),\n\n            nn.Conv2d(cnn_out_channels[1], cnn_out_channels[2], kernel_size=3, stride=1, padding=1),\n            nn.BatchNorm2d(cnn_out_channels[2]),\n            nn.ReLU(),\n            nn.MaxPool2d(2)\n        )\n        self.mlp = nn.Sequential(\n            nn.Flatten(),\n            nn.Linear(cnn_out_channels[2] * 4 * 4, mlp_hidden_units[0]),\n            nn.ReLU(),\n            nn.Dropout(dropout_rate),\n            nn.Linear(mlp_hidden_units[0], mlp_hidden_units[1]),\n            nn.ReLU(),\n            nn.Dropout(dropout_rate),\n            nn.Linear(mlp_hidden_units[1], num_classes)\n        )\n\n    def forward(self, x):\n        x = self.cnn(x)\n        x = self.mlp(x)\n        return x\n\n# Instantiate the model\nmodel = HybridCNNMLP(\n    cnn_out_channels=config.cnn_out_channels,\n    mlp_hidden_units=config.mlp_hidden_units,\n    dropout_rate=config.dropout_rate,\n    num_classes=config.num_classes\n).to(device)\n\n# Define Loss, Optimizer, and Scheduler\ncriterion = nn.CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=config.lr)\nscheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)\n\n# Track metrics for visualization\ntrain_losses, train_accuracies = [], []\ntest_losses, test_accuracies = [], []\ntest_precisions, test_recalls, test_f1s = [], [], []\n\n# Training and Evaluation Functions\ndef train(model, loader):\n    model.train()\n    running_loss = 0\n    all_labels = []\n    all_preds = []\n\n    for inputs, labels in loader:\n        inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n        optimizer.zero_grad()\n        outputs = model(inputs)\n        loss = criterion(outputs, labels)\n        loss.backward()\n        optimizer.step()\n\n        running_loss += loss.item()\n        all_labels.extend(labels.cpu().numpy())\n        all_preds.extend(outputs.argmax(dim=1).cpu().numpy())\n\n    acc = accuracy_score(all_labels, all_preds) * 100\n    return running_loss / len(loader), acc\n\ndef test(model, loader):\n    model.eval()\n    running_loss = 0\n    all_labels = []\n    all_preds = []\n\n    with torch.no_grad():\n        for inputs, labels in loader:\n            inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n            outputs = model(inputs)\n            loss = criterion(outputs, labels)\n            running_loss += loss.item()\n            all_labels.extend(labels.cpu().numpy())\n            all_preds.extend(outputs.argmax(dim=1).cpu().numpy())\n\n    acc = accuracy_score(all_labels, all_preds) * 100\n    precision = precision_score(all_labels, all_preds, average='macro')\n    recall = recall_score(all_labels, all_preds, average='macro')\n    f1 = f1_score(all_labels, all_preds, average='macro')\n    return running_loss / len(loader), acc, precision, recall, f1\n\n# Train and evaluate the model\nfor epoch in range(config.epochs):\n    train_loss, train_acc = train(model, train_loader)\n    test_loss, test_acc, test_precision, test_recall, test_f1 = test(model, test_loader)\n    scheduler.step()\n\n    # Log metrics to WandB\n    wandb.log({\n        \"epoch\": epoch + 1,\n        \"train_loss\": train_loss,\n        \"train_accuracy\": train_acc,\n        \"test_loss\": test_loss,\n        \"test_accuracy\": test_acc,\n        \"test_precision\": test_precision,\n        \"test_recall\": test_recall,\n        \"test_f1\": test_f1\n    })\n\n    # Store metrics for visualization\n    train_losses.append(train_loss)\n    train_accuracies.append(train_acc)\n    test_losses.append(test_loss)\n    test_accuracies.append(test_acc)\n    test_precisions.append(test_precision)\n    test_recalls.append(test_recall)\n    test_f1s.append(test_f1)\n\n    print(f\"Epoch [{epoch + 1}/{config.epochs}], Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%, \"\n          f\"Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.2f}%, Precision: {test_precision:.4f}, \"\n          f\"Recall: {test_recall:.4f}, F1: {test_f1:.4f}\")\n\nwandb.finish()\n\n# Plot Loss and Accuracy over Epochs\nplt.figure(figsize=(12, 6))\nplt.subplot(1, 2, 1)\nplt.plot(range(config.epochs), train_losses, label='Train Loss')\nplt.plot(range(config.epochs), test_losses, label='Test Loss')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.legend()\nplt.title('Loss over Epochs')\n\nplt.subplot(1, 2, 2)\nplt.plot(range(config.epochs), train_accuracies, label='Train Accuracy')\nplt.plot(range(config.epochs), test_accuracies, label='Test Accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy (%)')\nplt.legend()\nplt.title('Accuracy over Epochs')\n\nplt.tight_layout()\nplt.show()\n\n# Plot Precision, Recall, and F1 Score\nplt.figure(figsize=(12, 6))\nplt.plot(range(config.epochs), test_precisions, label='Precision')\nplt.plot(range(config.epochs), test_recalls, label='Recall')\nplt.plot(range(config.epochs), test_f1s, label='F1 Score')\nplt.xlabel('Epoch')\nplt.ylabel('Score')\nplt.legend()\nplt.title('Precision, Recall, and F1 over Epochs')\nplt.show()\n\n# Visualize some test images with predictions\ndef visualize_predictions(model, loader, num_images=10):\n    model.eval()\n    images, labels = next(iter(loader))  # Get the first batch\n    images, labels = images.to(device), labels.to(device)\n    \n    outputs = model(images)\n    _, preds = torch.max(outputs, 1)\n\n    # Convert to CPU and NumPy for plotting\n    images = images.cpu().numpy()\n    preds = preds.cpu().numpy()\n    labels = labels.cpu().numpy()\n\n    # Plot images with predictions\n    plt.figure(figsize=(12, 12))\n    for i in range(num_images):\n        plt.subplot(5, 5, i+1)\n        img = images[i].transpose(1, 2, 0)  # Reorder dimensions for plotting\n        img = (img * 0.2023 + 0.4914, img * 0.1994 + 0.4822, img * 0.2010 + 0.4465)  # Denormalize\n        plt.imshow(img)\n        plt.title(f\"Pred: {preds[i]}, True: {labels[i]}\")\n        plt.axis('off')\n    plt.tight_layout()\n    plt.show()\n\nvisualize_predictions(model, test_loader)\n\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T11:37:13.479363Z","iopub.execute_input":"2024-11-15T11:37:13.479872Z","iopub.status.idle":"2024-11-15T11:46:26.640999Z","shell.execute_reply.started":"2024-11-15T11:37:13.479819Z","shell.execute_reply":"2024-11-15T11:46:26.639628Z"},"trusted":true},"execution_count":5,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Finishing last run (ID:attrjobo) before initializing another..."},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"VBox(children=(Label(value='0.020 MB of 0.020 MB uploaded\\r'), FloatProgress(value=1.0, max=1.0)))","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"<style>\n    table.wandb td:nth-child(1) { padding: 0 10px; text-align: left ; width: auto;} td:nth-child(2) {text-align: left ; width: 100%}\n    .wandb-row { display: flex; flex-direction: row; flex-wrap: wrap; justify-content: flex-start; width: 100% }\n    .wandb-col { display: flex; flex-direction: column; flex-basis: 100%; flex: 1; padding: 10px; }\n    </style>\n<div class=\"wandb-row\"><div class=\"wandb-col\"><h3>Run history:</h3><br/><table class=\"wandb\"><tr><td>epoch</td><td>▁▁▂▂▂▂▃▃▃▄▄▄▅▅▅▅▆▆▆▇▇▇▇██</td></tr><tr><td>test_accuracy</td><td>▁▃▄▅▆▆▆▇▇████████████████</td></tr><tr><td>test_f1</td><td>▁▄▄▅▆▆▆▇▇████████████████</td></tr><tr><td>test_loss</td><td>█▆▅▅▄▃▃▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁</td></tr><tr><td>test_precision</td><td>▁▃▃▄▅▆▆▇▇█▇██████████████</td></tr><tr><td>test_recall</td><td>▁▃▄▅▆▆▆▇▇████████████████</td></tr><tr><td>train_accuracy</td><td>▁▃▄▅▅▆▇▇▇▇███████████████</td></tr><tr><td>train_loss</td><td>█▆▅▄▄▃▃▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁</td></tr></table><br/></div><div class=\"wandb-col\"><h3>Run summary:</h3><br/><table class=\"wandb\"><tr><td>epoch</td><td>25</td></tr><tr><td>test_accuracy</td><td>45.62</td></tr><tr><td>test_f1</td><td>0.44246</td></tr><tr><td>test_loss</td><td>1.49781</td></tr><tr><td>test_precision</td><td>0.44837</td></tr><tr><td>test_recall</td><td>0.4562</td></tr><tr><td>train_accuracy</td><td>41.996</td></tr><tr><td>train_loss</td><td>1.59192</td></tr></table><br/></div></div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run <strong style=\"color:#cdcd00\">warm-forest-3</strong> at: <a href='https://wandb.ai/i210325-nuces/vit-cifar10/runs/attrjobo' target=\"_blank\">https://wandb.ai/i210325-nuces/vit-cifar10/runs/attrjobo</a><br/> View project at: <a href='https://wandb.ai/i210325-nuces/vit-cifar10' target=\"_blank\">https://wandb.ai/i210325-nuces/vit-cifar10</a><br/>Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Find logs at: <code>./wandb/run-20241115_112236-attrjobo/logs</code>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Successfully finished last run (ID:attrjobo). Initializing new run:<br/>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Tracking run with wandb version 0.18.3"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Run data is saved locally in <code>/kaggle/working/wandb/run-20241115_113713-fc7pa2up</code>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Syncing run <strong><a href='https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp/runs/fc7pa2up' target=\"_blank\">autumn-aardvark-2</a></strong> to <a href='https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View project at <a href='https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp</a>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run at <a href='https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp/runs/fc7pa2up' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp/runs/fc7pa2up</a>"},"metadata":{}},{"name":"stdout","text":"Files already downloaded and verified\nFiles already downloaded and verified\nEpoch [1/25], Train Loss: 1.6461, Train Acc: 39.01%, Test Loss: 1.2680, Test Acc: 54.84%, Precision: 0.5676, Recall: 0.5484, F1: 0.5382\nEpoch [2/25], Train Loss: 1.3329, Train Acc: 51.82%, Test Loss: 1.0660, Test Acc: 61.60%, Precision: 0.6223, Recall: 0.6160, F1: 0.6050\nEpoch [3/25], Train Loss: 1.2015, Train Acc: 57.05%, Test Loss: 0.9768, Test Acc: 64.96%, Precision: 0.6745, Recall: 0.6496, F1: 0.6436\nEpoch [4/25], Train Loss: 1.1065, Train Acc: 60.97%, Test Loss: 0.9169, Test Acc: 67.25%, Precision: 0.6911, Recall: 0.6725, F1: 0.6683\nEpoch [5/25], Train Loss: 1.0457, Train Acc: 63.26%, Test Loss: 0.8429, Test Acc: 70.62%, Precision: 0.7189, Recall: 0.7062, F1: 0.7006\nEpoch [6/25], Train Loss: 0.9880, Train Acc: 65.36%, Test Loss: 0.7974, Test Acc: 72.33%, Precision: 0.7298, Recall: 0.7233, F1: 0.7200\nEpoch [7/25], Train Loss: 0.9408, Train Acc: 67.07%, Test Loss: 0.7635, Test Acc: 73.37%, Precision: 0.7557, Recall: 0.7337, F1: 0.7336\nEpoch [8/25], Train Loss: 0.9074, Train Acc: 68.68%, Test Loss: 0.7333, Test Acc: 75.04%, Precision: 0.7527, Recall: 0.7504, F1: 0.7432\nEpoch [9/25], Train Loss: 0.8749, Train Acc: 69.72%, Test Loss: 0.7605, Test Acc: 73.86%, Precision: 0.7585, Recall: 0.7386, F1: 0.7385\nEpoch [10/25], Train Loss: 0.8457, Train Acc: 70.95%, Test Loss: 0.6930, Test Acc: 76.10%, Precision: 0.7641, Recall: 0.7610, F1: 0.7578\nEpoch [11/25], Train Loss: 0.7477, Train Acc: 74.36%, Test Loss: 0.5802, Test Acc: 80.05%, Precision: 0.7997, Recall: 0.8005, F1: 0.7994\nEpoch [12/25], Train Loss: 0.7229, Train Acc: 74.96%, Test Loss: 0.5700, Test Acc: 80.32%, Precision: 0.8027, Recall: 0.8032, F1: 0.8018\nEpoch [13/25], Train Loss: 0.7073, Train Acc: 75.33%, Test Loss: 0.5664, Test Acc: 80.56%, Precision: 0.8050, Recall: 0.8056, F1: 0.8046\nEpoch [14/25], Train Loss: 0.7007, Train Acc: 75.78%, Test Loss: 0.5596, Test Acc: 80.51%, Precision: 0.8052, Recall: 0.8051, F1: 0.8041\nEpoch [15/25], Train Loss: 0.6877, Train Acc: 76.36%, Test Loss: 0.5547, Test Acc: 80.86%, Precision: 0.8074, Recall: 0.8086, F1: 0.8068\nEpoch [16/25], Train Loss: 0.6864, Train Acc: 76.19%, Test Loss: 0.5483, Test Acc: 81.12%, Precision: 0.8097, Recall: 0.8112, F1: 0.8098\nEpoch [17/25], Train Loss: 0.6829, Train Acc: 76.42%, Test Loss: 0.5468, Test Acc: 80.95%, Precision: 0.8092, Recall: 0.8095, F1: 0.8077\nEpoch [18/25], Train Loss: 0.6687, Train Acc: 76.99%, Test Loss: 0.5364, Test Acc: 81.55%, Precision: 0.8148, Recall: 0.8155, F1: 0.8140\nEpoch [19/25], Train Loss: 0.6670, Train Acc: 77.00%, Test Loss: 0.5313, Test Acc: 81.79%, Precision: 0.8162, Recall: 0.8179, F1: 0.8164\nEpoch [20/25], Train Loss: 0.6607, Train Acc: 77.15%, Test Loss: 0.5274, Test Acc: 81.78%, Precision: 0.8177, Recall: 0.8178, F1: 0.8171\nEpoch [21/25], Train Loss: 0.6481, Train Acc: 77.48%, Test Loss: 0.5263, Test Acc: 81.83%, Precision: 0.8168, Recall: 0.8183, F1: 0.8169\nEpoch [22/25], Train Loss: 0.6479, Train Acc: 77.42%, Test Loss: 0.5275, Test Acc: 81.77%, Precision: 0.8166, Recall: 0.8177, F1: 0.8164\nEpoch [23/25], Train Loss: 0.6442, Train Acc: 77.74%, Test Loss: 0.5236, Test Acc: 82.05%, Precision: 0.8195, Recall: 0.8205, F1: 0.8194\nEpoch [24/25], Train Loss: 0.6462, Train Acc: 77.73%, Test Loss: 0.5230, Test Acc: 81.94%, Precision: 0.8181, Recall: 0.8194, F1: 0.8182\nEpoch [25/25], Train Loss: 0.6455, Train Acc: 77.64%, Test Loss: 0.5234, Test Acc: 81.91%, Precision: 0.8180, Recall: 0.8191, F1: 0.8179\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"VBox(children=(Label(value='0.019 MB of 0.019 MB uploaded\\r'), FloatProgress(value=1.0, max=1.0)))","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"<style>\n    table.wandb td:nth-child(1) { padding: 0 10px; text-align: left ; width: auto;} td:nth-child(2) {text-align: left ; width: 100%}\n    .wandb-row { display: flex; flex-direction: row; flex-wrap: wrap; justify-content: flex-start; width: 100% }\n    .wandb-col { display: flex; flex-direction: column; flex-basis: 100%; flex: 1; padding: 10px; }\n    </style>\n<div class=\"wandb-row\"><div class=\"wandb-col\"><h3>Run history:</h3><br/><table class=\"wandb\"><tr><td>epoch</td><td>▁▁▂▂▂▂▃▃▃▄▄▄▅▅▅▅▆▆▆▇▇▇▇██</td></tr><tr><td>test_accuracy</td><td>▁▃▄▄▅▅▆▆▆▆▇██████████████</td></tr><tr><td>test_f1</td><td>▁▃▄▄▅▆▆▆▆▆███████████████</td></tr><tr><td>test_loss</td><td>█▆▅▅▄▄▃▃▃▃▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁</td></tr><tr><td>test_precision</td><td>▁▃▄▄▅▆▆▆▆▆▇██████████████</td></tr><tr><td>test_recall</td><td>▁▃▄▄▅▅▆▆▆▆▇██████████████</td></tr><tr><td>train_accuracy</td><td>▁▃▄▅▅▆▆▆▇▇▇▇█████████████</td></tr><tr><td>train_loss</td><td>█▆▅▄▄▃▃▃▃▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁</td></tr></table><br/></div><div class=\"wandb-col\"><h3>Run summary:</h3><br/><table class=\"wandb\"><tr><td>epoch</td><td>25</td></tr><tr><td>test_accuracy</td><td>81.91</td></tr><tr><td>test_f1</td><td>0.81792</td></tr><tr><td>test_loss</td><td>0.52341</td></tr><tr><td>test_precision</td><td>0.81802</td></tr><tr><td>test_recall</td><td>0.8191</td></tr><tr><td>train_accuracy</td><td>77.636</td></tr><tr><td>train_loss</td><td>0.64555</td></tr></table><br/></div></div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run <strong style=\"color:#cdcd00\">autumn-aardvark-2</strong> at: <a href='https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp/runs/fc7pa2up' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp/runs/fc7pa2up</a><br/> View project at: <a href='https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-hybrid-cnn-mlp</a><br/>Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Find logs at: <code>./wandb/run-20241115_113713-fc7pa2up/logs</code>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x600 with 2 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x600 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAA/MAAAIjCAYAAABPtUs4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACy80lEQVR4nOzdeZyN5f/H8ddZZ9/NZsaenexElkSJfkoRrSjapVKJb/sqLVKpUEp920Qq31ZS1rJnDVkGYxvMmH052/3743AYM4oxHMP72eM8zn3uc9/X/bnPDHmf676vy2QYhoGIiIiIiIiIVBhmfxcgIiIiIiIiIidHYV5ERERERESkglGYFxEREREREalgFOZFREREREREKhiFeREREREREZEKRmFeREREREREpIJRmBcRERERERGpYBTmRURERERERCoYhXkRERERERGRCkZhXkRE/GrgwIFUr179pPaZM2cOJpOJOXPmnJaazkUmk4mnn37a93ry5MmYTCa2bdvmt5pORFl+P+TsZzKZGDJkiL/LEBGp0BTmRUTOM4dD3OFHYGAgderUYciQIaSlpfm7vArp2M/UarWSlJTEwIED2bVrl7/LOy9ccsklxX4GRz82bNjg2+6FF17gqquuIj4+vsQXHOeS430WJpOJu+66y9/liYhIObD6uwAREfGPZ599lho1alBYWMiCBQt49913+eGHH1i7di3BwcFnrI733nsPj8dzUvt07NiRgoIC7Hb7aaqqbI7+TBctWsTkyZNZsGABa9euJTAw0N/lnfOSk5MZNWpUifWVK1f2LT/++OMkJCTQrFkzfv755zNZ3hl32WWX0b9//xLr69Sp44dqRESkvCnMi4icp7p3707Lli0BGDx4MDExMYwZM4Zvv/2WG264odR98vLyCAkJKdc6bDbbSe9jNpvPynB87GdaqVIlRo8ezYwZM+jbt6+fqzv3RUREcPPNN//jNikpKVSvXp0DBw4QGxt7hiorf4WFhdjtdszm419kWadOnX/9PEREpOLSZfYiIgLApZdeCnjDDnjvVQ4NDWXLli306NGDsLAwbrrpJgA8Hg9jx46lYcOGBAYGEh8fz5133snBgwdLtPvjjz/SqVMnwsLCCA8Pp1WrVnz22We+90u7J/qLL76gRYsWvn0aN27MG2+84Xv/ePfMT506lRYtWhAUFESlSpW4+eabS1zmfvi8du3aRa9evQgNDSU2NpaHH34Yt9td5s+vNB06dABgy5YtxdZv2LCBPn36EB0dTWBgIC1btmTGjBkl9s/MzOTBBx+kevXqBAQEkJycTP/+/Tlw4AAADoeDJ598khYtWhAREUFISAgdOnTgt99+K9fzONaJHnfbtm2YTCZeffVVJk6cSK1atQgICKBVq1YsXbq0RLvffPMNjRo1IjAwkEaNGvH111+Xe+2nev/9n3/+Sffu3QkPDyc0NJQuXbqwaNEi3/vLli3DZDLx0Ucfldj3559/xmQy8d133/nW7dq1i9tuu434+HgCAgJo2LAhH3zwQbH9Dv++f/HFFzz++OMkJSURHBxMdnb2KZ0LeG9PaNSoEcuXL6ddu3YEBQVRo0YNxo8fX2Lbffv2MWjQIOLj4wkMDKRJkyalnqfH4+GNN96gcePGBAYGEhsbyxVXXMGyZctKbHv4Z3743H/66adi7+fk5PDAAw/4/gzExcVx2WWXsWLFilM+dxGRik498yIiAhwJnDExMb51LpeLbt260b59e1599VXf5fd33nknkydP5tZbb2Xo0KGkpKQwbtw4/vzzTxYuXOjrbZ88eTK33XYbDRs2ZOTIkURGRvLnn3/y008/ceONN5Zax6xZs7jhhhvo0qULo0ePBmD9+vUsXLiQ+++//7j1H66nVatWjBo1irS0NN544w0WLlzIn3/+SWRkpG9bt9tNt27daNOmDa+++iq//PILr732GrVq1eLuu+8+pc/xaIcHl4uKivKtW7duHRdffDFJSUmMGDGCkJAQvvzyS3r16sVXX33FNddcA0Bubi4dOnRg/fr13HbbbTRv3pwDBw4wY8YMdu7cSaVKlcjOzub999/nhhtu4PbbbycnJ4dJkybRrVs3lixZQtOmTcvtXI52ssf97LPPyMnJ4c4778RkMvHyyy9z7bXXsnXrVt/vysyZM+nduzcNGjRg1KhRpKenc+utt5KcnHzCdbndbt8XHYcFBgYSGhp6yucM3p9dhw4dCA8PZ/jw4dhsNiZMmMAll1zC3LlzadOmDS1btqRmzZp8+eWXDBgwoNj+U6ZMISoqim7dugGQlpbGRRdd5BsMLjY2lh9//JFBgwaRnZ3NAw88UGz/5557DrvdzsMPP0xRUdG/3mZSWFhY4vMACA8PL7bvwYMH6dGjB3379uWGG27gyy+/5O6778Zut3PbbbcBUFBQwCWXXMLmzZsZMmQINWrUYOrUqQwcOJDMzMxifzYHDRrE5MmT6d69O4MHD8blcjF//nwWLVrku3IFYMGCBUyfPp177rmHsLAw3nzzTXr37s2OHTt8fw/dddddTJs2jSFDhtCgQQPS09NZsGAB69evp3nz5ifwUxMROYcZIiJyXvnwww8NwPjll1+M/fv3G6mpqcYXX3xhxMTEGEFBQcbOnTsNwzCMAQMGGIAxYsSIYvvPnz/fAIxPP/202Pqffvqp2PrMzEwjLCzMaNOmjVFQUFBsW4/H41seMGCAUa1aNd/r+++/3wgPDzdcLtdxz+G3334zAOO3334zDMMwHA6HERcXZzRq1KjYsb777jsDMJ588slixwOMZ599tlibzZo1M1q0aHHcY/6T0j7TadOmGbGxsUZAQICRmprq27ZLly5G48aNjcLCQt86j8djtGvXzqhdu7Zv3ZNPPmkAxvTp00sc7/Dn53K5jKKiomLvHTx40IiPjzduu+22YusB46mnnipRc0pKykmf74keNyUlxQCMmJgYIyMjw7f+22+/NQDjf//7n29d06ZNjcTERCMzM9O3bubMmQZQ7PfjeDp16mQAJR4DBgwodfv9+/eX+Ez+Ta9evQy73W5s2bLFt2737t1GWFiY0bFjR9+6kSNHGjabrdg5FxUVGZGRkcU+n0GDBhmJiYnGgQMHih3n+uuvNyIiIoz8/HzDMI78vtesWdO37t+U9lkcfnz++ee+7Q5/bq+99lqxWps2bWrExcUZDofDMAzDGDt2rAEYn3zyiW87h8NhtG3b1ggNDTWys7MNwzCMX3/91QCMoUOHlqjp6D/3gGG3243Nmzf71q1atcoAjLfeesu3LiIiwrj33ntP6JxFRM43usxeROQ81bVrV2JjY6lSpQrXX389oaGhfP311yQlJRXb7tie6qlTpxIREcFll13GgQMHfI8WLVoQGhrqu9R61qxZ5OTkMGLEiBL3t5tMpuPWFRkZSV5eHrNmzTrhc1m2bBn79u3jnnvuKXasK6+8knr16vH999+X2OfYEb07dOjA1q1bT/iYpTn6M+3Tpw8hISHMmDHD17uckZHBr7/+St++fcnJyfF9dunp6XTr1o1Nmzb5bgv46quvaNKkia+n/miHPz+LxeLrYfV4PGRkZOByuWjZsuVpvQz5ZI/br1+/YlcnHL794PDnvWfPHlauXMmAAQOIiIjwbXfZZZfRoEGDE66revXqzJo1q9hj+PDhZTrHY7ndbmbOnEmvXr2oWbOmb31iYiI33ngjCxYs8F323q9fP5xOJ9OnT/dtN3PmTDIzM+nXrx8AhmHw1Vdf0bNnTwzDKPZnqVu3bmRlZZX4LAcMGEBQUNAJ13z11VeX+DxmzZpF586di21ntVq58847fa/tdjt33nkn+/btY/ny5QD88MMPJCQkFBtPw2azMXToUHJzc5k7dy7g/b01mUw89dRTJeo59s99165dqVWrlu/1hRdeSHh4eLE/h5GRkSxevJjdu3ef8HmLiJwvdJm9iMh56u2336ZOnTpYrVbi4+OpW7duicG0rFZricucN23aRFZWFnFxcaW2u2/fPuDIZfuNGjU6qbruuecevvzyS7p3705SUhKXX345ffv25YorrjjuPtu3bwegbt26Jd6rV68eCxYsKLbu8H28R4uKiir1nv+TcfgzzcrK4oMPPmDevHkEBAT43t+8eTOGYfDEE0/wxBNPlNrGvn37SEpKYsuWLfTu3ftfj/nRRx/x2muvsWHDBpxOp299jRo1TulcyvO4VatWLfb6cLA//Hkf/vnVrl27xL5169Y94S8mQkJC6Nq164mdwEnav38/+fn5pf6O1a9fH4/HQ2pqKg0bNqRJkybUq1ePKVOmMGjQIMB7iX2lSpV8Y1Ps37+fzMxMJk6cyMSJE0s95uE/S4ed7M80OTn5hD6PypUrlxjY8vCI99u2beOiiy5i+/bt1K5du8TfEfXr1weO/Ay3bNlC5cqViY6O/tfjHvt7ASX/HL788ssMGDCAKlWq0KJFC3r06EH//v2LfaEiInK+UpgXETlPtW7dutj9q6UJCAgo8Y93j8dDXFwcn376aan7nOoI4XFxcaxcuZKff/6ZH3/8kR9//JEPP/yQ/v37lzrYVllYLJZyaedYR3+mvXr1on379tx4441s3LiR0NBQ3xR8Dz/8sO++6WNdcMEFJ3y8Tz75hIEDB9KrVy8eeeQR4uLisFgsjBo1qsSge+XpZI97vM/bMIzTVqO/9evXjxdeeIEDBw4QFhbGjBkzuOGGG7Bavf/0Ovy7cPPNN5e4t/6wCy+8sNjrk+mVrwhO5Peib9++dOjQga+//pqZM2fyyiuvMHr0aKZPn0737t3PVKkiImclhXkRETkptWrV4pdffuHiiy/+x3Bx+PLZtWvXnlRABe9lvj179qRnz554PB7uueceJkyYwBNPPFFqW9WqVQNg48aNvp7PwzZu3Oh7/0w6HG47d+7MuHHjGDFihK830Waz/WuPaa1atVi7du0/bjNt2jRq1qzJ9OnTi13CXNolzuWpvI97+OezadOmEu9t3LixbEWWs9jYWIKDg0utZ8OGDZjNZqpUqeJb169fP5555hm++uor4uPjyc7O5vrrry/WXlhYGG63+7RdTXCidu/eXWLayb///hs4Mvp/tWrVWL16NR6Pp9gXfBs2bPC9D97f259//pmMjIwT6p0/EYmJidxzzz3cc8897Nu3j+bNm/PCCy8ozIvIeU/3zIuIyEnp27cvbreb5557rsR7LpeLzMxMAC6//HLCwsIYNWoUhYWFxbb7px7Z9PT0Yq/NZrOvh7KoqKjUfVq2bElcXBzjx48vts2PP/7I+vXrufLKK0/o3MrbJZdcQuvWrRk7diyFhYXExcVxySWXMGHCBPbs2VNi+/379/uWe/fuzapVq0qdnu3w53e4Z/Poz3Px4sX88ccf5X0qxZT3cRMTE2natCkfffQRWVlZvvWzZs3ir7/+OrViy4nFYuHyyy/n22+/9c1SAN4R6T/77DPat29PeHi4b339+vVp3LgxU6ZMYcqUKSQmJtKxY8di7fXu3Zuvvvqq1C9tjv5dON1cLhcTJkzwvXY4HEyYMIHY2FhatGgBQI8ePdi7dy9Tpkwptt9bb71FaGgonTp1Ary/t4Zh8Mwzz5Q4zsleieF2u4v9PoD3yp3KlSsf9+8CEZHziXrmRUTkpHTq1Ik777yTUaNGsXLlSi6//HJsNhubNm1i6tSpvPHGG/Tp04fw8HBef/11Bg8eTKtWrbjxxhuJiopi1apV5OfnH/eS+cGDB5ORkcGll15KcnIy27dv56233qJp06a++3OPZbPZGD16NLfeeiudOnXihhtu8E1NV716dR588MEynevAgQP56KOPSElJKfP85I888gjXXXcdkydP5q677uLtt9+mffv2NG7cmNtvv52aNWuSlpbGH3/8wc6dO1m1apVvv2nTpnHddddx22230aJFCzIyMpgxYwbjx4+nSZMm/N///R/Tp0/nmmuu4corryQlJYXx48fToEEDcnNzT7rWw9P7ffjhhwwcOPC425X3cQFGjRrFlVdeSfv27bntttvIyMjgrbfeomHDhmVuszT//e9/2b59O/n5+QDMmzeP559/HoBbbrnlH6/ieP7555k1axbt27fnnnvuwWq1MmHCBIqKinj55ZdLbN+vXz+efPJJAgMDGTRoUIlbVl566SV+++032rRpw+23306DBg3IyMhgxYoV/PLLL2RkZJzSuf7999988sknJdbHx8dz2WWX+V5XrlyZ0aNHs23bNurUqcOUKVNYuXIlEydO9E0deMcddzBhwgQGDhzI8uXLqV69OtOmTWPhwoWMHTuWsLAwADp37swtt9zCm2++yaZNm7jiiivweDzMnz+fzp07M2TIkBOuPycnh+TkZPr06UOTJk0IDQ3ll19+YenSpbz22mun9NmIiJwT/DSKvoiI+MnhKcmWLl36j9sNGDDACAkJOe77EydONFq0aGEEBQUZYWFhRuPGjY3hw4cbu3fvLrbdjBkzjHbt2hlBQUFGeHi40bp162JTYx07Nd20adOMyy+/3IiLizPsdrtRtWpV48477zT27Nnj2+bYqekOmzJlitGsWTMjICDAiI6ONm666SbfVHv/dl5PPfWUcez/Fnv37m0EBQUZBw8ePO7nYBj//Jm63W6jVq1aRq1atXzT7W3ZssXo37+/kZCQYNhsNiMpKcn4v//7P2PatGnF9k1PTzeGDBliJCUlGXa73UhOTjYGDBjgm8rM4/EYL774olGtWjUjICDAaNasmfHdd9+V+EwN48SmpnvrrbcMwPjpp5/+8XxP9LiHp6Z75ZVXSrRxbD2GYRhfffWVUb9+fSMgIMBo0KCBMX369FLPpTSdOnUyGjZseELbcZwp2479fSrNihUrjG7duhmhoaFGcHCw0blzZ+P3338vddtNmzb52l6wYEGp26SlpRn33nuvUaVKFcNmsxkJCQlGly5djIkTJ/q2Ofz7PnXq1H+t77DjnSNgdOrUqdjn0bBhQ2PZsmVG27ZtjcDAQKNatWrGuHHjSq311ltvNSpVqmTY7XajcePGxocfflhiO5fLZbzyyitGvXr1DLvdbsTGxhrdu3c3li9fXqy+0qacq1atmm86waKiIuORRx4xmjRpYoSFhRkhISFGkyZNjHfeeeeEPwcRkXOZyTDO4dFnRERETkF8fDz9+/fnlVde8XcpZ0Tfvn3Ztm0bS5Ys8XcpcoZccsklHDhw4F/HZxARkbOPLrMXEREpxbp16ygoKODRRx/1dylnhGEYzJkzp9TLskVEROTsozAvIiJSioYNG5Kdne3vMs4Yk8lUYl5zEREROXtpNHsRERERERGRCkb3zIuIiIiIiIhUMOqZFxEREREREalgFOZFREREREREKhgNgFcKj8fD7t27CQsLw2Qy+bscEREREREROccZhkFOTg6VK1fGbP73fneF+VLs3r2bKlWq+LsMEREREREROc+kpqaSnJz8r9spzJciLCwM8H6I4eHhfq5GREREREREznXZ2dlUqVLFl0f/jcJ8KQ5fWh8eHq4wLyIiIiIiImfMid7qrQHwRERERERERCoYhXkRERERERGRCkZhXkRERERERKSC0T3zZWQYBi6XC7fb7e9S5ARZLBasVqumGxQRERERkQpPYb4MHA4He/bsIT8/39+lyEkKDg4mMTERu93u71JERERERETKTGH+JHk8HlJSUrBYLFSuXBm73a6e3grAMAwcDgf79+8nJSWF2rVrYzbrLhMREREREamYFOZPksPhwOPxUKVKFYKDg/1djpyEoKAgbDYb27dvx+FwEBgY6O+SREREREREykRdk2WkXt2KST83ERERERE5FyjZiIiIiIiIiFQwCvMiIiIiIiIiFYzCvJxWJpOJb775pty3FREREREROZ8pzJ9HBg4ciMlkwmQyYbfbueCCC3j22WdxuVyn7Zh79uyhe/fu5b6tiIiIiIjI+Uyj2Z9nrrjiCj788EOKior44YcfuPfee7HZbIwcObLYdg6Ho1zmYk9ISDgt24qIiIiIiJzP1DNfDgzDIN/hOuMPwzBOutaAgAASEhKoVq0ad999N127dmXGjBkMHDiQXr168cILL1C5cmXq1q0LQGpqKn379iUyMpLo6Giuvvpqtm3bVqzNDz74gIYNGxIQEEBiYiJDhgzxvXf0pfMOh4MhQ4aQmJhIYGAg1apVY9SoUaVuC7BmzRouvfRSgoKCiImJ4Y477iA3N9f3/uGaX331VRITE4mJieHee+/F6XSe9OciIiIiIiJSkahnvhwUON00ePLnM37cv57tRrD91H6EQUFBpKenAzB79mzCw8OZNWsWAE6nk27dutG2bVvmz5+P1Wrl+eef54orrmD16tXY7Xbeffddhg0bxksvvUT37t3Jyspi4cKFpR7rzTffZMaMGXz55ZdUrVqV1NRUUlNTS902Ly/Pd+ylS5eyb98+Bg8ezJAhQ5g8ebJvu99++43ExER+++03Nm/eTL9+/WjatCm33377KX0uIiIiIiIiZzOF+fOUYRjMnj2bn3/+mfvuu4/9+/cTEhLC+++/77u8/pNPPsHj8fD+++9jMpkA+PDDD4mMjGTOnDlcfvnlPP/88zz00EPcf//9vrZbtWpV6jF37NhB7dq1ad++PSaTiWrVqh23vs8++4zCwkI+/vhjQkJCABg3bhw9e/Zk9OjRxMfHAxAVFcW4ceOwWCzUq1ePK6+8ktmzZyvMi4iIiIjIOU1hvhwE2Sz89Ww3vxz3ZH333XeEhobidDrxeDzceOONPP3009x77700bty42H3yq1atYvPmzYSFhRVro7CwkC1btrBv3z52795Nly5dTujYAwcO5LLLLqNu3bpcccUV/N///R+XX355qduuX7+eJk2a+II8wMUXX4zH42Hjxo2+MN+wYUMsliOfQ2JiImvWrDnhz0NEREREpEJzuyBnD2TthIIMsAWDPRTsIYceh5atAXCog07ODQrz5cBkMp3y5e5nSufOnXn33Xex2+1UrlwZq/VI3UcHZ4Dc3FxatGjBp59+WqKd2NhYzOaTG3KhefPmpKSk8OOPP/LLL7/Qt29funbtyrRp08p2MoDNZiv22mQy4fF4ytyeiIiIiMhZpTDbG9SzdkJW6qHHziOP7N1guP+9HZP5mJB/VNAv8QVASCmvS1lvCwFLxchB5yJ98ueZkJAQLrjgghPatnnz5kyZMoW4uDjCw8NL3aZ69erMnj2bzp07n1Cb4eHh9OvXj379+tGnTx+uuOIKMjIyiI6OLrZd/fr1mTx5Mnl5eb4vGRYuXIjZbPYNziciIiIiUqF53JCbBpnHhvTUI8+FWSV3Aw5YLOyyWtgVHECqzU6KLZQDZishhkGY4Sbc4yLc4yDc7STE4/E+DAchjkJCCg8QYhxa5zFOLRRaA4/zZUAImC1gsoDZetSy2fvaZDlqnaWM2x7a3mT+9/0DwiDxwlM507OOwrwc10033cQrr7zC1VdfzbPPPktycjLbt29n+vTpDB8+nOTkZJ5++mnuuusu4uLi6N69Ozk5OSxcuJD77ruvRHtjxowhMTGRZs2aYTabmTp1KgkJCURGRpZ67KeeeooBAwbw9NNPs3//fu677z5uueUW3yX2IiIiInIeMQzwuMDt8IY3S4A3rJ3NHHlHQnnmsWE91dur7nGV2M0AMsxmdtms7A4JJsUewlZrCDssVvZaINPqxGMubWarw1eomgH7oce/M3vM2A0LgR4zQYaZYMNEMBBmGIQaHsI9HsI8LsI8TiLcDsJchYR6XIR6PAR73IQ6swgpyiTE48H2r0fzk8QmcOc8f1dRrhTm5biCg4OZN28ejz76KNdeey05OTkkJSXRpUsXX0/9gAEDKCws5PXXX+fhhx+mUqVK9OnTp9T2wsLCePnll9m0aRMWi4VWrVrxww8/lHq5fnBwMD///DP3338/rVq1Ijg4mN69ezNmzJjTes4iIiIifmEY3h7YnL3e+59z9kJ+Ot5YZzp0r7PJG2J9y4fufy72urTnY/c59vmYNkzmYtu4DCh0erDgwo4bC25voHY7vQ+P89BrV/Flt+PQ66O3O/xwHArmzpLbHbut56jtj2WyeO8Ft9i84d5iB6vd+3z4Uex926HXZXn/OPs4848f1gsOlv7jBrLNZnZaLeyyhrA5IIKttmB2mC3stRhkWx24zcfeOuoBHEc1YsJqRBFqiSc6IJ7KIUnEBseQ5ywgpyiHPGceea58Clx5FLoLcHjycRoFuIxCPKYCDFMRmLyfqcfsoRAPhRbI/MdfVOuhR/BxtzB7zFgNK3bDggUzJrxfLZgN05FlTJiNw8uH3z+ybPGtM3zLFsM48r5hYME4tK1x6D0Di+F9bT38GgOL4fFWbFi5+x/PreIxGWWZrPwcl52dTUREBFlZWSUuLy8sLCQlJYUaNWoQGBjopwqlrPTzExERkTOuKKd4SC/xfOjhKjjjpRmAEyg0m3CYTBSaSn8uMnmDmAmwGGA+FKTMh8LTscsWA0wcCmJHbV/avibjcHgzDr1fMrxVxGHbck0mdtmsbLOHstkewVZLIDssFtLMbm9Yt5Ty5cTRDBNWI5JQSyzRAQlUDq1MjYgq1K1Uncbx1akSkYjNfGr94A6Xg/SCHPbnZXEgL5v0gmwOFuRysCCHrKJcchw55DjyyHfmke/Kp8CdR9GhLwZcRiFuCvCYCjFMRZjMzlOq5XSzu6uy/Lbv/V3GP/qnHFoa9cyLiIiIiJSFIx9y9/5DQD+07Mg98TYDIzHCEsgKjSMjOJx8j0Gex0m+y02Bx0Wex02hx02Bx02B4abI46EAD0WGmyLDgwMPRRi+Z6fJ+3CZDi+D03xk2WUCoyIkZQMOx3oTZjDMmLFgwuz9z/D2AVswex+GCQveh/XwwzjSr2wzTNgwDi0b2DGwYXiXDc+hdR7shhu7cfjZjc1wE+hxYzNc2D1uAjwucsxWNtnD2WoOYIfZRJrZTa6tCLflqF50PEB+idOyGuGEmOOICUwgMaQyNSKrUK9SNRrF16BKWGXslhO7TL6s7FY7iWExJIbFnFI7hmGQU1TE/txs9udncyAvm4OFubg8LjyGB7fHjYdDz4ZRbJ3HcOP2eA4tex9uw7veOGrZu5/buw1H2vEY3nYM48j+3m2OrDPwEB+cUE6f2tlDYV5ERERE5GiuopKBvLSwXlRyYLLjcdvDKAyKJS0ghp32cHZYg9lttrEbE/sMN+lGEVlGPkVk4TJlA9tKy35Huq1PCxM2kx2b2Y7dEkCgJZAAawDB1kACrN5Q6fK4Dz28YcxluA8FNA9ujwe34T4Uvjy+oGUYxqFgdSh0YWAYHsAbsjCdwIXCJjh8P7iBG0xwAuO3n0aWQ4/DYbvw0OOYrYxQQi1xvsvgq0cmU69SdRrEVqNKeBJB1qAzWPPpYzKZCA8MJDwwkFrE+buc84bCvIiIiIicv1xFsHMZbJsP2xZA2jrvXN0nyGkKIMNWiW3WKFIsoWwzBbHTZGOPycR+PORaXTishRjWXEzWXEymNCDNu/PRGfbwNexHMdyBGB47GDZM2LBgx2qyYTMH+AJ3gCWAIGsAQbZAgm1BBNsCCLUHERYQRHhAEBGBwUQEBhNmDyLA6t0+wBJQfPlQcLearZj8NA+5tzfWG/zdh74gKHQ5KXC4KXA6yXe4KHA5KXQ6KXC6cLhcODwOHG4Xbo8Lh9uJ03Dicrtwelw4PU5cHhcujwun4cLlduIyXLg93meXx4X70LN3vfd18Ycbj+E89OzGjfNQz7DrUM+w99lqsnsvgw+pTI1DYb1+pWokhycTYgv595MXKSOFeRERERE5f7idsGsFbJsHKfMxUpdgKuVedYdhZbcRxWZLJFstoaSag9hjDWC/xUKm1SDX4sJhLcLjC+nZQHaphzw2p1uMMAJMkQRbogizRhNhr0R0QAyxwbHEB8dSOSyepPA4YoJDCA+0ERpoxWKuCNfCl53ZZMZsKn7JQaidfxpnTeS8pzAvIiIiIucutwv2rISUebBtAcaORZiceb63TcAuI5ypAbWYFxhGaoBBocVxVEgvAoqO27z5qJZCrZFE2mOIDowhLjiOhJBYKoclUDk0jrjgOGKDY4kJjMFmOWsn7xKRCkRhXkRERETOHR437F0NKfNh23w823/HfNQAdCbggBHK19bazA6KZFOQA0fwXjCnA+m+7Q6HdLPJTHRgNLFBscQGxxZ/Pmo5Oij6lEcWFxE5GQrzIiIiIlJxeTyQttbb675tHsa23zEfNTCdGcg0QvjBXIefgmLYEOSmMGQvhqV4eK8UVImLEi+iaWxT4kPij4T0wGisZv2TWUTOPvqbSUREREQqDsOAfeth23yMlHm4UxZgLcoEjtybnm0E8St1+CEwntXBJgrD9uE+JrwHW4NpldCKixIv4qLEi6gVWctvg7+JiJSFwryIiIjIuc5ZCDm7IWsXZO/2Tq9mDYCgaAiKguBDz0FREBgBZou/Kz7CMODA35AyD/fWeXi2LcRW6A3lJrz/mM01Allo1OG7gMqsDLZSEHGQIksqcNDXjNVk5cLYC73hvfJFNKrUSJfFi0iFpjAvZ5TJZOLrr7+mV69ebNu2jRo1avDnn3/StGlTf5cmIiJSMTnyvAE9e9cxz0ct56f/ezs+Jm+gPzrglxb6fesOvQ6IAHM5TIBuGJCxFVLm4dgyFyNlAQGF+4EjM3vnGwEs9tTmB3tVVoQEUhCVQ555Cx7+KtZU7ajavp73FvEtNE2YiJxTFObPIwMHDuSjjz4CwGq1kpyczHXXXcezzz5LYGCgn6sTERGREopyDvWmlxLQDy8XZp5QU4Y1iPSIymwPjmaHLYQAj4dYZyGxjlwqFWYTXJiJ2ZkLGN42T7BdH5MZAiP/IfQfXhdZfF1AOBzcBtvmk//3XEzb5hNU6J2H3X6o6ULDxjJPbX621OTPiDDyovPIMW+iyLO2WAkJIQm+8N4msQ2Vgiqd3DmIiFQgCvPnmSuuuIIPP/wQp9PJ8uXLGTBgACaTidGjR/u7NBERkfOHYUBh1lHhvLRe9d1QVPq85SWas4fgCElkd2AsW2zhbDbbScFEquFir6eATHJwmg+C2QmkgYH3GnX7oUeoGcOdiOEOxeIKxO4OINBlJcRtIcID0W6DWI+LBI+TRKOIJE8+UeQRTi4RRg5BFILhgYIM7yNjywl/FB7MmPEAR6YULzKsrDQuYLbpAlZFx5AT4yDLtJFs1+qjdyTMHkbrhNa+AF8tvJruexeR84bCfHkwDHDmn/nj2oLhJP+HFRAQQEJCAgBVqlSha9euzJo1i9GjR+PxeBg9ejQTJ05k79691KlThyeeeII+ffr49l+3bh2PPvoo8+bNwzAMmjZtyuTJk6lVqxZLly7lP//5D3/++SdOp5OmTZvy+uuv07x583I9bRERkQrBkQfpWyB9s/f5YApk7TwS1I+a6/yfuO0RFAbFkx0Qyw5LFBtMQWzGTIrHw26jiHQjD6c1C7PtICbzLmDXkZ1NHD0ROgCGKxyrJwpMLjzmXAxzDpg8mCxFmCxFGHbvrOpFQBawu5SaDMOE4Q7BcMViuEMxuYKwu+0EuW2EusxEuA2iPAaxbifxbgexRgGRplwiySXKlEuEKZdI8gg2FWHGg9OwsNKoxTyjLn/FVSazkpss80bSCg+Fd7f3yWa20TyuORdV9ob3+tH1sZxN9/eLiJxBCvPlwZkPL1Y+88f9z26wl/3er7Vr1/L7779TrVo1AEaNGsUnn3zC+PHjqV27NvPmzePmm28mNjaWTp06sWvXLjp27Mgll1zCr7/+Snh4OAsXLsTlcgGQk5PDgAEDeOuttzAMg9dee40ePXqwadMmwsLCyuWURUREziouB2RuPxTYNxcP7zmlxeDiHPYo8gLjyLLGss8UzWbCWO+xstkNOzxOMi1FeOzZmGwHMdv2YjKnltrO0XHWakQSbI4l0hZHbFAiSaGVqR5ZhTrRVakfV5XYkJBivdeGYZDtyCajMMP3OJCfzoEC7yO9IIODhRkcLDpIZlEGOc5sTCYDkzUXrEfmb3cDuYcee4+pz2oKIMgcQaA5kQBzOHZTOHbCsRvBBLstOOx5ZFo2sT13HW5jFTi8+5kwUS+6ni+8N4trRpA16IR+NCIi5zqF+fPMd999R2hoKC6Xi6KiIsxmM+PGjaOoqIgXX3yRX375hbZt2wJQs2ZNFixYwIQJE+jUqRNvv/02ERERfPHFF9hs3tFf69Sp42v70ksvLXasiRMnEhkZydy5c/m///u/M3eSIiIi5cnj8V7+fjiwZ2w9snxwOxju4+6ab41kvy2ZnebKbDHiWO8MYaPbxB4rZFpdeGzZmO0HD4X1dZjMzmL7mynRsU6QOYpIezxxQYkkhSZRIzKZOjHVqBVVhYSQBAIsASd1eiaTiYiACCICIqgRUeNft3e6nRwsOugN/gUZpBemF/si4PD6jELve0XuIlxGETnufeS495XeqOvIYnJosi+8t05oTVRg1Emdj4jI+UJhvjzYgr295P447knq3Lkz7777Lnl5ebz++utYrVZ69+7NunXryM/P57LLLiu2vcPhoFmzZgCsXLmSDh06+IL8sdLS0nj88ceZM2cO+/btw+12k5+fz44dO07+3ERERM4kw/CO+H5UD7uRvhnPgc2YMrZidhced9d8AkkxEthoxLHWEs1mSyg7rQHst4LDVoDZmoXJlo7ZtqVYWD/eP8LCbTHEBSWSHOYN6lXDk6kcWpmk0KQyhfXyZrPYiAuOIy447l+3NQyDAleBL/CnF6SXGvqjAqN8g9YlhyWfgbMQEan4FObLg8l0Spe7n0khISFccMEFAHzwwQc0adKESZMm0ahRIwC+//57kpKSiu0TEOD9R0NQ0D9f1jZgwADS09N54403qFatGgEBAbRt2xaHw3EazkRERM46bhfk7QNnAVhsYLaBxQ4Wq/fZbPPOX+7HAcqMwmxy9/xN3u6NOPdvwpS+mYCsFMLythPozim2rYkjl6/nGRZWWuJZY4lhkzWMHZZA0qxmsqxunLZ8zLZMTJa9HHuBuZ2SYgJjSQ5LIulQQK8cWvmsCuvlyWQyEWwLJtgWTJWwKv4uR0TknKIwfx4zm8385z//YdiwYfz9998EBASwY8cOOnXqVOr2F154IR999BFOp7PU3vmFCxfyzjvv0KNHDwBSU1M5cODAaT0HERE5AzweyD8AOXsgZ2+JZyNnD57sPZjz9mPC+Nfm3GYbHpMVz+Fnkw2P2Yr78LLJitts9T6brLgPryvl4TLZcGPBY7LiMllxc+TZbbJgOIsIzdtOdGEqCa6dxHKQMODokVw8QLrFzEZ7AH9ZI9lojmCbNYi9VgsHrR4KbUV4LPlgMvAOCZdV7HyOvl89xBZCYkgi8SHxJAQnkBCSQGJIIgkhCb7HuRTWRUTEfxTmz3PXXXcdjzzyCBMmTODhhx/mwQcfxOPx0L59e7Kysli4cCHh4eEMGDCAIUOG8NZbb3H99dczcuRIIiIiWLRoEa1bt6Zu3brUrl2b//73v7Rs2ZLs7GweeeSRf+3NFxERPzIMyM8oPaTnpuHJ3oORvQdz3j5MhqvE7kUm2GuxstdqYY/Vyp7IMHZbbOSaLdgNDzbDIAAPVgNsGFgNo9iyzTCwGg6sOA4tG9gAm8fA5jawwlHbHd4PAgzDt2wzDKzFlr096r5TBLLNZvZaLfwVZGGPNZStlmC2WUPYa7OTYTPIMTvwmDxH7VV46FGc3Wz3hvRDAT0+OL5EWA+za8BXERE5MxTmz3NWq5UhQ4bw8ssvk5KSQmxsLKNGjWLr1q1ERkbSvHlz/vOf/wAQExPDr7/+yiOPPEKnTp2wWCw0bdqUiy++GIBJkyZxxx130Lx5c6pUqcKLL77Iww8/7M/TExE5Px2ew7yUXnQO9aJ7DoV0s6f0W6EO91bvsVrZG2RjtzWIFGswqZYA9lotpFsh33r8gd/8yWKYsAIWTLgxKDKVdrWAGyjwvTKbzMQGxfpCuS+gBx/pUY8OjNYc5iIictYwGYbx79fDnWeys7OJiIggKyuL8PDwYu8VFhaSkpJCjRo1CAwM9FOFUlb6+YlIhefxQG6ad3T1rJ2Hnndh5OzGnXW4Jz0Nyz8M2AaQZzJ5g7rVwiZLKCnWYHZa7KRZzRy0esi1OTFKDcHFBZgDiQ9OICkskcRQbwAOs4Xh8rhwepwlnktb5/K4yrzO/Q8jyR8tKiCq2KXuxwb22OBYrGb1cYiIiP/8Uw4tjf6vJSIicrYwDCg4eFRI3+lbNrJ24snchSl3D2aPs8SuJo78T90JpB0K6ZssYWyzBLHLZmef1USm1U2e1YHbUrIN3+Teh5gxExscS2JIojf4hnqDb2KIN7gnhiQSbg/3a2+1x/Dg9rh9XxQcG/otJgtxwXEEWvUFroiInFv8HubffvttXnnlFfbu3UuTJk146623aN269XG3Hzt2LO+++y47duygUqVK9OnTh1GjRhXrZT3ZNkVERM6IotwSIZ2sXZC909u7nr0LkzO/1F0Pj6zuwHuf+gZLFJst4eywBLHbame/xUSWzU2hrQinb7A234EPPYoLt4cX66E++jkxJLFC9FabTWbMFjM2S+nTpoqIiJyr/Pp/6ClTpjBs2DDGjx9PmzZtGDt2LN26dWPjxo3ExZWcu/Szzz5jxIgRfPDBB7Rr146///6bgQMHYjKZGDNmTJnaFBERKReuIsjeXXpYz9rpDeyFWcfd3QNkmM3ss9vYbAljiyWMVEsQeyw20q0msi0eCqxFeKxHh3LnoUdJNrOtxOXkxz6H2CrGtKoiIiJSkl/vmW/Tpg2tWrVi3LhxAHg8HqpUqcJ9993HiBEjSmw/ZMgQ1q9fz+zZs33rHnroIRYvXsyCBQvK1GZpdM/8uUs/PxEpF4XZ8PtbsH/9oeC+yzu/+nHkmkzss1rYZ7GwwxLMFksoOy2BpFmtpFtM5FpdFFqLjulNPz672U5ccJzvERsc6738PTTR9xwdGI3ZZC6vMxYREZHTrMLcM+9wOFi+fDkjR470rTObzXTt2pU//vij1H3atWvHJ598wpIlS2jdujVbt27lhx9+4JZbbilzmwBFRUUUFR3p6cjOzj7V0xMRkXOY8b/7Ma2bjhPYfyik7wsOYrfFToollJ3WAPZZrBy0GuRaXbjNpQ3SVvLSdxMmYoJiiA2KJT443hfU44PjiQ2O9Yb3oDgiAiI0qrqIiMh5zm9h/sCBA7jdbuLj44utj4+PZ8OGDaXuc+ONN3LgwAHat2+PYRi4XC7uuusu39RpZWkTYNSoUTzzzDOneEYiInJe2DqXlZu/45EqlUmzHu9/o65DjyOCLCHEB8cRHxrnDedB3nB+dFCPCYrBZta93yIiIvLvzu5RbY4xZ84cXnzxRd555x3atGnD5s2buf/++3nuued44oknytzuyJEjGTZsmO91dnY2VapUKY+SRUTkXOJykPPtgzxbKdoX5M1YCbdFUykojsph8VQJTzhyCXzQkUvhg23Bfi5eREREziV+C/OVKlXCYrGQlpZWbH1aWhoJCQml7vPEE09wyy23MHjwYAAaN25MXl4ed9xxB4899liZ2gQICAggICDgFM9IRETOdc7f3+FHTxqb7dHYCWFG769IDEnUvekiIiJyxvntXx92u50WLVoUG8zO4/Ewe/Zs2rZtW+o++fn5mM3FS7ZYLAAYhlGmNkVERE5I9m6y545mXFQEAPc0u5ek0CQFeREREfELv15mP2zYMAYMGEDLli1p3bo1Y8eOJS8vj1tvvRWA/v37k5SUxKhRowDo2bMnY8aMoVmzZr7L7J944gl69uzpC/X/1qaIiEhZpH89nMnhdg5aLMQHVqF/o+v9XZKIiIicx/zandCvXz9effVVnnzySZo2bcrKlSv56aeffAPY7dixgz179vi2f/zxx3nooYd4/PHHadCgAYMGDaJbt25MmDDhhNs8Xw0cOBCTyVTisXnzZgDmzZtHz549qVy5MiaTiW+++eZf23S73bz00kvUq1ePoKAgoqOjadOmDe+///5pPhsRkTOr6O855KX+yCcRYQA8dfFIDVQnIiIifuXXeebPVufiPPMDBw4kLS2NDz/8sNj62NhYLBYLP/74IwsXLqRFixZce+21fP311/Tq1esf23zyySeZMGEC48aNo2XLlmRnZ7Ns2TIOHjzIww8/fFrOw+FwYLfby7x/Rf35iYgfuZ3sf6UVL4TnMDskmNYJbZnUbaK/qxIREZFzTIWZZ/5cYhgGBa6CM37cIGvQSc0zHBAQcNyBALt370737t1P6vgzZszgnnvu4brrrvOta9KkSbFtPB4Pr776KhMnTiQ1NZX4+HjuvPNOHnvsMQDWrFnD/fffzx9//EFwcDC9e/dmzJgxhIaGAt4vITIzM2nVqhVvv/02AQEBpKSkkJqaykMPPcTMmTMxm8106NCBN954g+rVq5/UOYiI/JvUn8awh93MDonHjJmRrYf7uyQRERERhfnyUOAqoM1nbc74cRffuNivUx0lJCTw66+/cs899xAbG1vqNiNHjuS9997j9ddfp3379uzZs4cNGzYAkJeXR7du3Wjbti1Lly5l3759DB48mCFDhjB58mRfG7NnzyY8PJxZs2YB4HQ6ffvNnz8fq9XK888/zxVXXMHq1atPqedeRORohRk7iVw6hgcrRwHQt25fLoi6wM9ViYiIiCjMn1e+++47X483eHvjp06dWub2xowZQ58+fUhISKBhw4a0a9eOq6++2tfDn5OTwxtvvMG4ceMYMGAAALVq1aJ9+/YAfPbZZxQWFvLxxx8TEhICwLhx4+jZsyejR4/2jXMQEhLC+++/7wvpn3zyCR6Ph/fff993ZcKHH35IZGQkc+bM4fLLLy/zOYmIHG3LJw+yMdTCxgA7obZQ7ml6j79LEhEREQEU5stFkDWIxTcu9stxT0bnzp159913fa8PB+iyatCgAWvXrmX58uUsXLjQN4jewIEDef/991m/fj1FRUV06dKl1P3Xr19PkyZNitVx8cUX4/F42Lhxoy/MN27cuFhv+6pVq9i8eTNhYWHF2issLGTLli2ndE4iIodtXPQ91Q7O4t7kygDc3eRuogKj/FyViIiIiJfCfDkwmUx+vdz9RIWEhHDBBeV7eajZbKZVq1a0atWKBx54gE8++YRbbrmFxx57jKCgk/uy4XiO/dIhNzeXFi1a8Omnn5bY9niX+4uInIzCwkICZj7K+5HhpFstVAuvxg31bvB3WSIiIiI+fp2aTs49DRo0ALz3w9euXZugoCBmz55d6rb169dn1apV5OXl+dYtXLgQs9lM3bp1j3uM5s2bs2nTJuLi4rjggguKPSIiIsr3hETkvLTw0+exmnfz30MjyT7U4iFsFk1FJyIiImcPhXkBvL3dK1euZOXKlQCkpKSwcuVKduzYcdx9+vTpw+uvv87ixYvZvn07c+bM4d5776VOnTrUq1ePwMBAHn30UYYPH87HH3/Mli1bWLRoEZMmTQLgpptuIjAwkAEDBrB27Vp+++037rvvPm655RbfJfaluemmm6hUqRJXX3018+fPJyUlhTlz5jB06FB27txZrp+LiJx/1mzYQJsd7/F6VCQOs4k2iW24pMol/i5LREREpBiFeQFg2bJlNGvWjGbNmgEwbNgwmjVrxpNPPnncfbp168b//vc/evbsSZ06dRgwYAD16tVj5syZWK3eOzieeOIJHnroIZ588knq169Pv3792LdvHwDBwcH8/PPPZGRk0KpVK/r06UOXLl0YN27cP9YaHBzMvHnzqFq1Ktdeey3169dn0KBBFBYWntB8jCIix1PodLNv2iP8HWgwMzQEs8nMIy0fOalpQEVERETOBJNhGIa/izjbZGdnExERQVZWVolwWFhYSEpKCjVq1CAwMNBPFUpZ6ecnIv/ksymfcv36e7ihcgJ/BdjpU6cPT7V9yt9liYiIyHngn3JoadQzLyIiAvy5bR8t173A/0JD+CvATogthCFNh/i7LBEREZFSKcyLiMh5r9DpZtHno0i27GZslHf6uTsuvIOYoBg/VyYiIiJSOoV5ERE570368XduLvycDyLCOWA1kxyazM31b/Z3WSIiIiLHpTAvIiLntVWpmSQvfZFcq4MPI73TWz7U8iHsFrufKxMRERE5PoX5MtK4gRWTfm4icrQil5uPP/+Uqy2/MzY6EocJWsa3pEvVLv4uTUREROQfKcyfJJvNBkB+fr6fK5GyOPxzO/xzFJHz27hZ67kj9x1WBdj5ITQEEyYeaaWp6EREROTsZ/V3ARWNxWIhMjKy2Fzp+kff2c8wDPLz89m3bx+RkZFYLBZ/lyQifrZ6ZyYFC8dTx7qTGytVBqDXBb1oENPAz5WJiIiI/DuF+TJISEgA8AV6qTgiIyN9Pz8ROX8Vudy8OOU33rNM44eQYNbarQRZg7iv2X3+Lk1ERETkhCjMl4HJZCIxMZG4uDicTqe/y5ETZLPZ1CMvIgC8NXsz/TLfw2ot5PXYaoCH2xvfTmxwrL9LExERETkhCvOnwGKxKByKiFQwa3ZmsXze/3jYtpDxERGkmTxUDqnMLQ1u8XdpIiIiIidMYV5ERM4bDpeHR79czhjLZNIsFj6IigI8PNjiQQKtgf4uT0REROSEaTR7ERE5b4z7dRMXpU+nnjmVN2LjKMBD09imdKvezd+liYiIiJwU9cyLiMh5Ye2uLL6cs4xZtmmss9v5X5B3ispHWz+qWUlERESkwlHPvIiInPMcLg8PT13FcMtnhJoKGJ2YDEDPmj1pVKmRn6sTEREROXkK8yIics4b99tmwtOWcK1lATODg/nT7CLIGsTQ5kP9XZqIiIhImegyexEROaet3ZXFxN828I1tMkUmGJOYDJ5Cbm14KwkhCf4uT0RERKRM1DMvIiLnLIfLwyPTVnOjaSb1zKn8Nyae3Z5C4oPjGdhooL/LExERESkzhXkRETlnvTNnMwf2bOdB2zQOWMy8FxEKwAMtHiDIGuTn6kRERETKTmFeRETOSX/tzmbcr5sZafucMAp4K6kW+R4njSs1pkeNHv4uT0REROSUKMyLiMg5x+n2jl7f3PiLay0L+Mtu52uLA4DhrYZjNul/fyIiIlKxaQA8ERE557zz2xY27jnIj4EfYQCvVKuH4cqke43uNI1r6u/yRERERE6ZuiZEROSc8tfubN76dRP9LTOpww5+jYxlmSuTAEsADzZ/0N/liYiIiJQLhXkRETlnON0eHpm2iijPQYbbp+MAXov3Tj83oOEAEkMT/VugiIiISDnRZfYiInLOGD9nC+t2Z/NW4BcEGXlMrlKPVEcWsUGxDGo0yN/liYiIiJQb9cyLiMg5YcPebN78dROtTBvoyTzSzRYmBBgADG0+lGBbsJ8rFBERESk/CvMiIlLhHR693uN28XrYfwF4p05rct0F1I+uz1W1rvJzhSIiIiLlS2FeREQqvAlzt7B2VzZ3BP5KsiOFv8NimFa0B4BHWz+qqehERETknKN/3YiISIW2cW8Ob8zeRCyZDLNOPTQVXX08eLis2mW0iG/h7xJFREREyp3CvIiIVFiuQ5fXO90Gb1T6Gpsrl3nJDVmUtwOb2cawFsP8XaKIiIjIaaEwLyIiFdaEeVtZsyuLToGbaZc7CycmXo0IAeCWBreQHJbs5wpFRERETg+FeRERqZD+TsvhjV82YcHNG+GfADClQWe25e8lOjCa2xvf7ucKRURERE4fhXkREalwDl9e73B7eLbyIiKz/yYzOIp3XHsBGNpsKKH2UD9XKSIiInL6KMyLiEiFM3H+VlbvzKJ6YC435H4MwDv1O5DjzKVuVF16XdDLvwWKiIiInGYK8yIiUqFsSsth7KxNAExO/h6zI4etlRvz5cE1AAxvNRyL2eLPEkVEREROO4V5ERGpMFxuDw9PW43D7eH2amlU3/ktYOKVytVwG24urXIprRNb+7tMERERkdNOYV5ERCqM9xeksCo1k8hAE8M97wOwoHEPFqSvxmq28lDLh/xcoYiIiMiZoTAvIiJnPZfbw+9bDjBm1t8AfNBwNbb963AFRvKKKRuAm+rdRNXwqv4sU0REROSMsfq7ABERkWPlFblYmZrJ0m0ZLNt2kBU7DpLvcAPQs5aVZpvfBmBqs6vZuvc3ogKiuKPJHf4sWUREROSMUpgXERG/259TxLJtGSzddpBl2zNYtzsbt8cotk1YoJX2F1Ti5YAJmHZlk5V4Ie8c/BOAe5veS7g93B+li4iIiPiFwryIiJxRhmGQciCPZdsOsmRbBsu2ZbAtPb/EdpUjAmlVI5qW1aNpVT2KOnFhmHcuhg+mADChdmsyU2dyQeQF9K7T+0yfhoiIiIhfKcyLiMhp5XR7WLc7+1DPu/ey+fQ8R7FtTCaoGx9Gy+pRtKruDfBJkUHFG3K74PuHAdjWpA+f7/wVgEdaPYLVrP+diYiIyPlF//oREZFylVPo5M8dmb7L5v9MPUih01NsG7vVTNPkSF94b141iohg2z83/Mc4SFsDgZG8FmLDle2iY3JH2lVudxrPRkREROTspDAvIiKnJC270NfjvnRbBuv3ZHPM7e5EBNloVT3Kd8l8o6QIAqyWEz/IH2/DL095F9sMZM6O6VhNmopOREREzl8K8yIicsIMw2DL/lyWbjvI0pQMlm7PIDWjoMR2VaKDaFXtyP3utWJDMZtNZTkgzB0Nc0YB4G57H69krwGgX71+1IyoeUrnIyIiIlJRKcyLiMhxOVwe1uzK8l0yv3x7BgfzncW2MZmgfkK4r+e9ZfUoEiOCjtPiSTAMmPm49/J6gEsfZ3p8dTYt+pZwezh3N7n71I8hIiIiUkEpzIuIiE+h083K1EwWb81gcUo6K3aUvN890GamaZVI30B1zapGEh74L/e7nyyPG757EFZ85H19xUvkNL+ZcV//HwD3NL2HiICI8j2miIiISAWiMC8ich4rcLhZseMgi7emsyglg5WpmThcxcN7dIidltUOjzIfRcPKEdit5tNXlNsJX98Fa6eByQw938TZ5HqeX/g4GYUZ1IioQd+6fU/f8UVEREQqAIV5EZHzSF6Ri+XbD7JoazqLUzJYvTMTp7v4aHWVQgO4qGY0bWrGcFGNaC6IC8VkKsP97mXhLISpA+HvH8FshWvf40CtjgybOYg/9/2JCRMjWo3AZi7nKwFEREREKhiFeRGRc1hOoZNl2w6yKCWdxVszWLMrC/cxQ80nhAfSpmY0bWrE0KZmNDUrhZy58H60olz44kZImQvWQOj7Metikrn/u+tJy08jzBbGy51epl2SpqITERERUZgXkfPe8u0HeWTqKmwWM1Wig0iOCiY5Kogq0cFUiQomOTqo/O8JP02y8p0s2ZbB4kM97+t2Z5WYJi4pMog2NaO56FB4rxod7J/wfrSCTPj0Oti5BOyhcMMXfG9k89SPAyhyF1E9vDpvXfoW1SOq+7dOERERkbOEwryInNc27s3h1g+XkF3o8r5Oyyl1u4ggmzfoRwZTJdob9JOjgrxhPyqYIPtJzJlejg7mOVic4h2sbvHWDNbvzcY4JrxXiwmmTY0jPe/JUcF+qfW4cvfDf6+BtDUQGIn7pqm8sW8BH679EICOyR15qcNLhNnD/FyoiIiIyNlDYV5EzlupGfn0/2Ax2YUumleNZGiX2uw8WMDOgwWkHsxnZ0Y+qQcLyMhzkFXgJGuXk7W7skttq1KoneSo4GIhv0q097lyZFC5DRi3P6eIJUeF99K+fKhZKaTYZfPlMk3c6ZK1Cz6+GtI3QUgc2dd/wvCNH7Bw10IABjcezJCmQ7CY/fNliYiIiMjZSmFeRM5LB3KL6P/BEtKyi6gTH8oHA1sRGWwvddu8Ipc34Gfke0O+b7mAnRn55BS5OJDr4ECug5WpmSX2N5m896VXOXT5fnJ0MFWigg6F/yASI4KwmEu/zH1fdiGLUjK8A9ZtTWfL/rwS29SOCz0S3mtEExceeEqfzRmTsRU+uhqydkB4MluvfZuhy55je/Z2Ai2BPHfxc1xR4wp/VykiIiJyVlKYF5HzTm6Ri1s/XErKgTySIoP4+LY2xw3yACEBVuomhFE3ofTLvLPynaQezCc1I9/Xq3/0cqHTw56sQvZkFbJkW8n9rWYTiZHesF8lKpikqCB2ZxawOCWDlAMlw3u9hDDa1IjmopoxtKoRTaXQgLJ+FP6zbz183Aty90J0TeZd/jiP/j6SXGcuCSEJvNH5DRrENPB3lSIiIiJnLYV5ETmvFLnc3PnfZazZlUV0iJ2PB7UmIeLUerIjgm1EBEfQKCmixHuGYXAg11GsR3/nUcu7Mgtwug1SMwpIzSgA0ovtbzJBg8Rw3yXzratHExVy/C8eKoTdf8J/r4WCDIy4+kxqfT1vLn4GA4Pmcc0Zc8kYYoJi/F2liIiIyFntrAjzb7/9Nq+88gp79+6lSZMmvPXWW7Ru3brUbS+55BLmzp1bYn2PHj34/vvvARg4cCAfffRRsfe7devGTz/9VP7Fi0iF4fYYPDhlJQs3pxNitzD51lbUig09rcc0mUzEhgUQGxZA86pRpdaUll1Y4jL+6BA7bWpE07J6NBFBFWMk/ROy/Xf4tC84ciio3IwnL2jCT+smAdC3Tl9GtB6BzXIOna+IiIjIaeL3MD9lyhSGDRvG+PHjadOmDWPHjqVbt25s3LiRuLi4EttPnz4dh8Phe52enk6TJk247rrrim13xRVX8OGHH/peBwRUwMtQRaTcGIbBE9+u5Yc1e7FbzEzs35ILkyP9XRYWs4nKkUFUjgyidY1o70rD8HbJn2s2/wJf3AyuAvZUu4j7Y0JZn/orVpOVkW1G0rduX39XKCIiIlJhlM/wyqdgzJgx3H777dx66600aNCA8ePHExwczAcffFDq9tHR0SQkJPges2bNIjg4uESYDwgIKLZdVFTJHjEROX+8/ssmPlu8A5MJXu/XlIsvqOTvkkq36Rd4vRG80w7WfgUet78rKh9/zYDPrgdXActqXcz1QQWsP/g30YHRvN/tfQV5ERERkZPk1zDvcDhYvnw5Xbt29a0zm8107dqVP/7444TamDRpEtdffz0hISHF1s+ZM4e4uDjq1q3L3XffTXp6+nFagKKiIrKzs4s9ROTcMXlhCm/O3gTAc1c34soLE/1cUSmcBfDDI/Bpb8jeCfvWwbTb4J22sGZaxQ71Kz+HqQPA4+TLOhdzu7GbjKKD1Iuux+dXfk6L+Bb+rlBERESkwvFrmD9w4ABut5v4+Phi6+Pj49m7d++/7r9kyRLWrl3L4MGDi62/4oor+Pjjj5k9ezajR49m7ty5dO/eHbe79H8Mjxo1ioiICN+jSpUqZT8pETmrfLtyF0//7y8Ahl1Wh5svqubnikqxZzVM6ARLJnpft74DOj8OgRFwYCN8NQjeuahihvol78E3d+E0PDxbtw3POVNxGW6uqH4FH3f/mMqhlf1doYiIiEiFZDIMw/DXwXfv3k1SUhK///47bdu29a0fPnw4c+fOZfHixf+4/5133skff/zB6tWr/3G7rVu3UqtWLX755Re6dOlS4v2ioiKKiop8r7Ozs6lSpQpZWVmEh4ef5FmJyNli7t/7GTR5KS6PwYC21Xj6qoaYzqZ70T0e+OMtmP0ceJwQGg9XvwO1D12tVJgFiyfCH+OgMNO7rlId6DgcGl0LZovfSj8hC16HX54m3Wxm2AWNWeE8iAkTQ5sPZVCjQWfXz0JERETEz7Kzs4mIiDjhHOrXnvlKlSphsVhIS0srtj4tLY2EhIR/3DcvL48vvviCQYMG/etxatasSaVKldi8eXOp7wcEBBAeHl7sISIV2587DnLXf5fj8hj0bFKZp3qeZUE+ayd8fBXMetIb5OteCXf/fiTIg7dnvtMj8MAauPRxCIyEA3/D9MHwdhtY/eXZ2VNvGDD7WfjladbbbVxfsw4rnAcJtYUyrss4BjcefHb9LEREREQqIL+GebvdTosWLZg9e7ZvncfjYfbs2cV66kszdepUioqKuPnmm//1ODt37iQ9PZ3ExLPwPlkRKXeb9+Vw6+SlFDjddKhdideua4LZfBaFxzXT4N12sG0+2IKh55tw/acQcpxB+QLDoePhUP8EBEVB+iaYfrs31K+aAm7XmT2H4/F44MfhMP81fgwJpn9yMnvd+VQLr8anPT6lY3JHf1coIiIick7w62X24J2absCAAUyYMIHWrVszduxYvvzySzZs2EB8fDz9+/cnKSmJUaNGFduvQ4cOJCUl8cUXXxRbn5ubyzPPPEPv3r1JSEhgy5YtDB8+nJycHNasWXNCU9Sd7OUNInL22J1ZQO93f2dPViFNqkTy2eA2hAT4fRZOr8Is7yB3q6d4Xye1gGvfg5haJ9dOUY73/vrf34KCg951MRd4A3+jPmDx0/m6XfC/obhXfspbUZFMivT+/Xlx0sW83PFlwu36+1RERETkeE42h/r9X7j9+vVj//79PPnkk+zdu5emTZvy008/+QbF27FjB2Zz8QsINm7cyIIFC5g5c2aJ9iwWC6tXr+ajjz4iMzOTypUrc/nll/Pcc89prnmRc1xGnoNbJi1mT1YhtWJD+HBgq7MnyG//HabfCVk7wGSGDg9Dp+FgsZ18WwFh0OEh70B5S97zhvr0zfD1nTD3ZW+7ZzrUuxwwfTA562fwaHwc84MDAbi10a3c3+x+LGf7/f0iIiIiFYzfe+bPRuqZF6l48opc3Pj+YlalZpIYEci0u9uRFBnk77K8IXfuS97B4AwPRFbz9sZXbVN+xyjKORLqCzK866JregfKa3zd6Q/1jnz48ha2bZvDfQlxbLNZCbAE8Ey7Z7iy5pWn99giIiIi54iTzaEK86VQmBepWBwuD4M+Wsr8TQeIDLYx7a62XBAX5u+y4MAm+Gow7Fnpfd3kRug+2nsP/OlQlAtLD4X6/HTvuuia3svvG/c9PaG+MBs+v575+5bzaFwlcsxm4oPjeePSN2gY07D8jyciIiJyjlKYLwcK8yIVh8djcP+Ulfxv1W6CbBY+u70NzapG+bcow4BlH8DPj4GrwDsKfc+x0PCaE9p9Z85O3IabKmFVMJvKME5pUS4sfR9+f/NIqI+q4Q31F/Yrv1Cfn4HxybV8mLeZsVGRGCYTTWOb8nrn16kUdJzB/ERERESkVArz5UBhXqRiMAyDp2es46M/tmOzmHh/QCs61Yn1b1G5+2HGffD3j97XNTpBr3chIukfdyt0FTJr+yym/j2VP/f9CUCILYR60fVoENOA+tH1aRDTgOrh1U/8/vOiXFg2CRa+cUyof/hQqC/D/fqH5eyl8L+9eMrYxw+hIQD0rt2b/7T5D3aLveztioiIiJynFObLgcK8SMXw5uxNjJn1NyYTjO3XlKub/nNgPu3+ngnf3gN5+8Fihy5PwUX3gPn4vetbs7YydeNUZmyZQbYjGwCLyYLFZMHhcZTYPsgaRJ2oOr5w3yCmATUja2Iz/0Mwd+TB0sOh/oB3XVR17yB8Ta4/+VCfuYO9/72KoQEFrA+wYzVZeLT1CPrV7af540VERETKSGG+HCjMi5z9/rtoO098sxaAp3s2YODFNfxXjCMfZj3hvbQdILY+9H4PEhqXvrnb4euFX5623Lc+MSSR3rV7c03ta4gKjCIlK4X16etZn7Gev9L/YkPGBgpcBSXas5lt3oAfU98X8mtH1SbAcswMHo487+X/C9/wfuEA3gH5Oj4MTW44sVB/YDMrPruKB0Mhw2Ihyh7Oa53H0iqh1Ql9VCIiIiJSOoX5cqAwL3J2+371HoZ8vgLDgKGXXsCwy+v6r5jdK2H67XDgb+/rNndD16fBFlhi021Z25j29zS+3fItmUWZAJhNZjomd+S6OtdxceWL//ESerfHzfac7d6Afyjkr09fT44zp8S2VpOVWpG1igX8OlF1CLYFHyfUV/XeU/9PoX7vGqZN7cMLYTZcJhN1wmvw5mXvkhTq5ysiRERERM4BCvPlQGFe5Oy1YNMBbp28BKfb4MY2VXmhVyP/XNrtcXsHmPv1BfA4ITQBer0DF3QptpnT7WT2jtlM/XsqS/Yu8a2PD4739cInhCSUuQzDMNiZs5O/Mv4q1ot/+MuCo5lNZmqE1/AF/PoRNamXspiwReMhb593o8iqhy6/vwGsR+59d27/g5e/H8AXId7e/suSOvJ8p1e8Xw6IiIiIyClTmC8HCvMiZ6fVOzO5YeIi8hxuejRO4K0bmmMx+yHIZ6bC13fB9gXe1/X+D3q+CSExvk1Ss1OZumkq327+loxC79zvJkx0SO7AdXWuo31Se6zm0zP/u2EYpOWn8Vf6X/yV/pevB39/wf5St68amkwDUwD192ygfk4G9R1OIsOSoeND0ORGMrbM4qG5D7EswNtjf1+j27m9+X26P15ERESkHCnMlwOFeZGzz5b9uVw3/g8y8hy0qxXDh7e2IsB6gqO6l6fVU+H7h6AoC2wh3nnjm90MJhNOj5M5qXP4cuOXLNqzyLdLXFAc19S+ht61e5MYmnjmaz5kf/5+X7A//Lw7b3ep21Z2uqjvcFDXFMQ3dg+7rRZCMDGqw2g61+x+hisXEREROfcpzJcDhXmRs8verEJ6v/s7uzILaJwUwed3XERowOnp1T6ugkz44WFYM9X7OrkVXDsRomuyM2cnX236iq83fU16oXcKOBMm2iW147o619EpudNp64U/VQcLD5YI+DtydpTYrgp23rryv9Sq1MAPVYqIiIic+042h56d/7oUETkkM9/BLZMWsyuzgJqVQph8a6szH+S3LfBeVp+VCiYLdBqO6+IHmLt7IVOXv8zvu3/HwPu9aExgDNfWvpZra19Lcljyma2zDKICo2hXuR3tKrfzrctx5LAhYwPr96/mr80/EomZu7u9Q0RwJT9WKiIiIiJHU898KdQzL3J2yHe4uPn9xazYkUl8eADT7mpHlegzOOCaywFzXoQFYwEDoqqzp8dLTMvdzNebvi52D3rbxLZcV/c6LqlyyT/P+S4iIiIiUgr1zIvIOcHp9nDPpytYsSOT8EArH9/W5swG+f1/w/TBsGcVLmBBo+5MjYhg/u+P+nrhowOj6XVBL/rU7kOV8CpnrjYREREROe8pzIvIWcfjMXhk6irmbNxPoM3Mh7e2om5C2Jk5uGHAsknw8+PsNRxMj41nelQcaXnrIM+7SeuE1lxX5zq6VO2C7XhzsouIiIiInEYK8yJyVjEMg+e+/4tvVu7GYjbx7k0taFEt+swcPHcf7m/uZeGueUyNDmVeSCweAGcWkQGR9LqgF71r96Z6RPUzU4+IiIiIyHEozIvIWeWdOVv4cOE2AF7pcyGd68WdkePuWzOF6fOeZHqgmT0JR47ZMr4l19W5jq7VumK32M9ILSIiIiIi/0ZhXkTOGl8s2cErP28E4PEr63Nt89M8GrzHTdbaqYxfPpYvTLm4Qr1hPdwWwtW1r6VPnT7UjKh5emsQERERESkDhXkROSv8tHYP//l6DQD3XFKLwR1OY4guzMK1/CO+WvUe4wLdZFosgImmtij6tnyAy2r2INAaePqOLyIiIiJyihTmRcTvft9ygKGfr8RjQL+WVXikW93Tc6CMrbB4Aov++oLR4YFsDrEDFmpZwxneegTtavc8PccVERERESlnCvMi4ldrd2Vxx8fLcbg9XN4gnheuaYTJZCq/AxgGbF8If7xD6pafeTU6kl8reeftDLcEck/Te+nb4CbNDS8iIiIiFYrCvIj4TcqBPAZ+uITcIhdtakTz5g3NsFrM5dO4qwjWfgWL3iE3bS0TIyP4JDkRp8mEBTN96/bjnqb3EBkYWT7HExERERE5gxTmRcQvtqfnccukxRzIddAgMZz3BrQk0GY59YZz98OyD2Dp+3jy9vFtaAhvVEki/dCXBO0qt+ORlo9wQdQFp34sERERERE/UZgXkTNq3e4sJszdyvdr9uD2GFSLCeaj21oTHniKl7mnrYNF78DqqeAuYkVAAC9VqcJ6q/eS/Wrh1Xik5SN0TO5Yvpfxi4iIiIj4gcK8iJx2hmHw+5Z0xs/dwvxNB3zrO9SuxIvXNCY2LKBsDXs8sHkW/PE2pMwFYI/FwpiqtfnJUgRAqC2Uu5rcxY31bsRm0X3xIiIiInJuUJgXkdPG7TH4ce0eJszdyppdWQCYTfB/F1bmjo41aZQUUbaGi3Jh1eew6F3I2AJAvtnCB7VaMNmTTpGnCBMmetfpzZCmQ4gJiimvUxIREREROSsozItIuSt0upm6fCfvzdvKjox8AAJtZvq1rMLgDjWpEh1ctoYzU2HJRFjxERR6vxwwAiL4vkFnXi/czr7CvQC0jG/Jo60fpV50vXI5HxERERGRs43CvIiUm8x8B//9YzuTf99Gep4DgMhgGwPaVqd/22rEhJbxcvrUpbDobfhrBhhu77romqy58Bpeyl3P6vQVACSFJvFQy4foWrWr7osXERERkXOawryInLJdmQW8P38rU5amku/whu2kyCBu71CDvq2qEGwvw181bif89a33Uvpdy46sr9GRfc1v4o3M1czYOhWAIGsQtze+nf4N+xNgKeMXBiIiIiIiFYjCvIiU2fo92Uyct5UZq3bj9hgA1E8M565ONbmycWLZ5owvOAjLJ8OS9yB7l3edxQ6N+1LYahAfpy/j/dVjKHAVAHBVrau4v/n9xAXHldNZiYiIiIic/RTmReSkGIbBoq0ZTJi3hTkb9/vWt6sVw12datGhdqWyXeJ+YJO3F37V5+D03mdPSCy0GozR4lZmpq9kzB8j2Z23G4AmsU0Y0XoEjSo1Ko/TEhERERGpUBTmReSEuD0GM9ftZfy8raxKzQS8I9N3b5zInR1rcmFy5Mk3ahiwdY53fvhNM4+sj28EF90DjfuwPmsroxc+yvK05d63guN5sMWD9KjRQ/fFi4iIiMh5S2FeRP5RodPN9BW7eG/+VlIO5AEQYDVzXctkBrevSfVKIWVrePNsmPk47Pvr0AoT1O0OF90N1TtwoDCdcUtGMX3TdAwMAi2B3NroVgY2HEiwrYyj4YuIiIiInCMU5kWkVFn5Tj5ZvJ0PF27jQG4RABFBNvq3rcaAdtWpVNaR6V1FMPtZ+GOc97UtBJrdDG3uhJhaON1OPl33EeNXjyfP6f3yoHv17jzY4kESQxPL49RERERERCo8hXkRKWZPVgGT5qfw+ZId5B0amb5yRCCDO9SkX6sqhAScwl8bBzbBtNtg72rv61aD4dInICgSwzCYs+M3Xl32KjtydgDQIKYBI1qPoFlcs1M9LRERERGRc4rCvIgA8HdaDhPmbuXblbtwHRqZvl5CGHd2qsn/XVgZW1lGpj/MMODPT+DH4d7B7YKi4eq3oV4PADYd3MTLS19m0Z5FAFQKqsT9ze/nqlpXYTadwnFFRERERM5RCvMi5zHDMFi2/SDj52xh9oZ9vvUX1Yzmzk61uKRO7KkPMleQCd89AOu+9r6u0RGumQDhlckszOTtlW8z9e+puA03NrONAQ0HMLjxYEJsZbwXX0RERETkPKAwL3Ie8ngMZq1PY8LcLazYkQmAyQRXNEzgjo41aVY1qnwOtGMRfHU7ZO0AsxU6PwYX3w9mCz+l/MRzi54j25ENQNeqXRnWchhVwqqUz7FFRERERM5hCvMi55Eil5tv/tzFhHlb2brfO7ic3Wqmd/Nk7uhYkxplHZn+WG4XzH8N5r4EhgeiqkPvDyC5BR7Dw7gVb/LemvcAqBNVh0dbPUrrxNblc2wRERERkfOAwrzIeaLA4eam9xf5euLDAq3cclE1Bl5cnbiwwPI7UGYqTL8ddvzhfX1hP+jxKgSGk+vIZeT8kczZOQeA2xrdxtBmQ7GYLeV3fBERERGR84DCvMh5wOMxGPblSlbsyCQ80MrQLrW5vnVVQk9lZPrSrPsG/jcUCrPAHgZXvgZN+gGQmp3K0N+GsjlzM3aznWcufob/q/l/5Xt8EREREZHzhMK8yHnglZkb+XHtXmwWE+8PaEXrGtHlewBHHvw0AlZ87H2d1AJ6vw/RNQFYvGcxD819iKyiLOKC4njj0jdoVKlR+dYgIiIiInIeUZgXOcd9uTSVd+dsAeDlPheWf5Dfsxq+GgQH/gZM0P5B6PwfsNgwDIMvNn7B6CWjcRtuGldqzNjOY4kLjivfGkREREREzjMK8yLnsN83H+A/X68BYGiX2lzTLLn8GjcMWPQu/PIUuB0Qluidcq5mJwCcbicvLnmRaX9PA6BnzZ481e4pAiwB5VeDiIiIiMh5SmFe5By1eV8ud32yHJfH4KomlXmwa+3yazx3H3xzD2ye5X1dtwdcNQ5CYgDIKMzgwd8eZMW+FZgwMazFMAY0HHDqc9aLiIiIiAigMC9yTkrPLeK2yUvJLnTRoloUL/e5sPyC9OZf4Ou7IW8fWAPh8ueh1WDvRPXAxoyNDP11KLvzdhNqC2V0x9F0TO5YPscWERERERFAYV7knFPodHPnf5ezIyOfqtHBTLylBYG2cpj6zVUEs5+FP8Z5X8fWhz4fQHwD3yazts/isQWPUeAqoFp4Nd689E1qRtQ89WOLiIiIiEgxCvMi5xDDMHj0q9Us236QsEArHwxsRUxoOdyjfmATTLsN9q72vm51O1z+HNiCAPAYHiasmsA7q94BoG1iW17p9AoRARGnfmwRERERESlBYV7kHDL2l018u3I3VrOJ8Te34IK40FNr0DDgz0/gx+HgzIegaLj6bajXw7dJvjOfxxc+zqzt3vvnb2lwC8NaDMNq1l8vIiIiIiKni/61LXKO+PrPnbwxexMAL1zTiIsvqHRqDRZkwncPwLqvva9rdPSOVh9e2bfJ7tzdDP11KBsPbsRmtvHERU9wTe1rTu24IiIiIiLyrxTmRc4BS1IyeHSadwq6uzrVol+rqqfW4I5F8NXtkLUDzFbo/BhcfD+Yj9x7vzxtOcPmDCOjMIOYwBjGdh5L07imp3ZcERERERE5IQrzIhXctgN53PnfZTjcHro3SmB4t7plb8ztgvmvwdyXwPBAVHXo/QEktyi22bS/p/HC4hdweVzUj67Pm5e+SUJIwqmdiIiIiIiInDCFeZEKLDPfwW2Tl3Iw30mT5AjG9G2K2VzGKegyU2H67bDjD+/rC/tBj1chMNy3idPj5JWlr/D5hs8B6Fa9G89d/BxB1qBTPRURERERETkJCvMiFZTD5eGuT5az9UAeSZFBvDegJUH2Mk5Bt+4b+N9QKMwCeyhcOQaa9Cu2SWZhJg/PfZjFexcDcF+z+7i98e3lN3+9iIiIiIicMIV5kQrIMAz+8/UaFm3NIDTAyqSBLYkLCzz5hhx58NMIWPGx93VSC+j9PkQXnxt+88HN3PfrfezM3UmwNZhRHUZxadVLy+FMRERERESkLBTmRSqgd+ZsYdrynZhNMO7GZtRLCP/3nY61ZzV8NQgO/A2YoP2D0Pk/YLEV22xO6hwenfco+a58kkKTePPSN6kTVadczkNERERERMpGYV6kgvlu9W5e+XkjAM9c1ZBL6sadXAOGAYvehV+eArcDwhK9U87V7HTMZgaT1k7izRVvYmDQKqEVr3V6jajAqPI6FRERERERKSOFeZEKZMWOgwz7chUAt11cg1vaVj+5BnL3wzd3w+ZZ3td1e8BV4yAkpthmBa4Cnlr4FD9u+xGAfnX78WjrR7GZbce2KCIiIiIifqAwL1JBpGbkc8fHy3C4PHStH8djV9Y/uQacBfDR/8H+DWANhMufh1aD4ZgB7Pbm7eX+3+7nr/S/sJqsjGwzkr51+5bjmYiIiIiIyKlSmBepALILndw2eSkHch00SAznjeubYTnZKehmPeUN8qHxcMs3EN+gxCYr963kgd8eIL0wnciASMZcMoZWCa3K5yRERERERKTcKMyLnOWcbg/3frqCTftyiQ8PYNLAloQEnOQf3U2/wJIJ3uWr3yk1yH+7+Vue+eMZnB4ntaNq82bnN0kOSy6HMxARERERkfKmMC9yFjMMg6dmrGP+pgME2SxMGtCKxIigk2skLx2+vce73PoOqN212Nsuj4vXl7/Ox395p6frUrULL7Z/kWBbcHmcgoiIiIiInAYK8yJnsUkLUvhs8Q5MJnjzhmY0Soo4uQYMA/43FHLToFJd6PpMsbezHdkMnzuchbsXAnBXk7u4u8ndmE3m8joFERERERE5DRTmRc5SP6/byws/rAfgsR71uaxB/Mk38ucnsOE7MNvg2olgP9LbnpKVwtBfh7ItexuBlkCeb/883ap3K6/yRURERETkNDorut/efvttqlevTmBgIG3atGHJkiXH3faSSy7BZDKVeFx55ZW+bQzD4MknnyQxMZGgoCC6du3Kpk2bzsSpiJSLNTuzeOCLlRgG3HxRVQa1r3HyjWRshZ9GeJcvfQwqN/W9tWDXAm76/ia2ZW8jISSBj7t/rCAvIiIiIlKB+D3MT5kyhWHDhvHUU0+xYsUKmjRpQrdu3di3b1+p20+fPp09e/b4HmvXrsVisXDdddf5tnn55Zd58803GT9+PIsXLyYkJIRu3bpRWFh4pk5LpMx2ZxYw6KOlFDjddKwTy9M9G2IyneTI9W4XTL8THLlQ7WJoNxTwftH10bqPuHf2veQ4c2gW14zPr/yc+jEnOc2diIiIiIj4ld/D/JgxY7j99tu59dZbadCgAePHjyc4OJgPPvig1O2jo6NJSEjwPWbNmkVwcLAvzBuGwdixY3n88ce5+uqrufDCC/n444/ZvXs333zzzRk8M5GTl1vkYtBHy9iXU0Td+DDevrEZVksZ/pguGAM7l0BAOFwzHswWAF5a8hKvLnsVj+Hh2trX8v7l71MpqFI5n4WIiIiIiJxufg3zDoeD5cuX07XrkdG1zWYzXbt25Y8//jihNiZNmsT1119PSEgIACkpKezdu7dYmxEREbRp0+a4bRYVFZGdnV3sIXKmudwehn7+J+v3ZFMp1M6kgS0JC7SdfEM7l8Ocl7zLPV6FyKoAfL/1ez7b8BkmTIxoPYKn2z6N3WIvxzMQEREREZEzxa9h/sCBA7jdbuLjiw/sFR8fz969e/91/yVLlrB27VoGDx7sW3d4v5Npc9SoUURERPgeVapUOdlTETllz3+/nl837CPAaua9/i1JjirD1HBFuTB9MBhuaHgtXNgXgB3ZO3hu0XMA3NnkTm6qf9PJX7ovIiIiIiJnDb9fZn8qJk2aROPGjWnduvUptTNy5EiysrJ8j9TU1HKqUOTEfPT7Nib/vg2A1/s1pVnVqLI1NPMx78B34Unwf2PAZMLpdvLIvEfIc+bRPK45d154Z/kVLiIiIiIifuHXMF+pUiUsFgtpaWnF1qelpZGQkPCP++bl5fHFF18waNCgYusP73cybQYEBBAeHl7sIXKm/LZhH8/8bx0Aw6+oS4/GiWVraMMPsHyyd7nXuxDk/UJg7Iqx/JX+FxEBEYzuOBqrWTNSioiIiIhUdH4N83a7nRYtWjB79mzfOo/Hw+zZs2nbtu0/7jt16lSKioq4+eabi62vUaMGCQkJxdrMzs5m8eLF/9qmyJm2fk82Qz5bgceAvi2TubtTrbI1lLsPZtznXW47BGp2AmDeznl8/NfHADzX7jkSQv75SzIREREREakY/N5FN2zYMAYMGEDLli1p3bo1Y8eOJS8vj1tvvRWA/v37k5SUxKhRo4rtN2nSJHr16kVMTEyx9SaTiQceeIDnn3+e2rVrU6NGDZ544gkqV65Mr169ztRpifyrfdmFDJq8lDyHm7Y1Y3i+V+Oy3cduGPDtEMg/AHENocuT3vbz9/H4gscBuKn+TXSu2rk8yxcRERERET/ye5jv168f+/fv58knn2Tv3r00bdqUn376yTeA3Y4dOzCbi19AsHHjRhYsWMDMmTNLbXP48OHk5eVxxx13kJmZSfv27fnpp58IDAw87ecjciLyHd4p6HZnFVIzNoTxN7fAbi3jhTLLPoBNP4PFDr3fA2sAbo+bkfNHcrDoIPWi6zGsxbDyPQEREREREfErk2EYhr+LONtkZ2cTERFBVlaW7p+XcufxGNz96XJ+XpdGVLCNb+69mGoxIWVr7MAmGN8BXAXQ7UVoey8AE1ZNYNzKcQRZg5jyf1OoEVGjHM9ARERERETK28nm0Ao9mr1IRTT6pw38vC4Nu8XMxP4tyx7k3U74arA3yNfoBG3uBmB52nLeWfUOAI9f9LiCvIiIiIjIOUhhXuQM+nzJDibM2wrAK9ddSKvq0WVvbM5LsGclBEZ6R683m8kqyuLReY/iMTz0rNmTq2pdVS51i4iIiIjI2UVhXuQMWbDpAI9/sxaAB7rW5uqmSWVvbMciWDDGu9xzLEQkYRgGTyx8grT8NKqFV+Oxix479aJFREREROSspDAvcgZsSsvh7k+X4/YYXNMsifu71C57Y4XZMP0OMDzQ5AZoeA0An2/4nN9Sf8NmtvFyx5cJsZXx8n0RERERETnrKcyLnGYHcou4dfJScgpdtKoexUu9yzgF3WE/jYDM7RBZFbq/DMCGjA28uuxVAB5q+RANYhqUR+kiIiIiInKWUpgXOY12ZxZw2+Sl7DxYQLWYYCbc0pIAq6XsDa77BlZ+CpjgmgkQGE6+M59H5j6C0+PkkuRLuLHejeVVvoiIiIiInKX8Ps+8yLlqxqrdPPb1GnIKXUQE2fhgYCuiQ+xlbzB7N3z3gHe5/YNQrR0ALy5+kW3Z24gLjuO5i587tV5/ERERERGpEE4pzDscDlJSUqhVqxZWq74XEAHIKnDy1Ldr+WblbgCaVolkbL+mVK90CvewezzwzT1QcBASm8AlIwH435b/8e2WbzGbzLzU4SUiAyPL4QxERERERORsV6bL7PPz8xk0aBDBwcE0bNiQHTt2AHDffffx0ksvlWuBIhXJ4q3p9HhjPt+s3I3FbOL+LrWZdlfbUwvyAEsmwtbfwBoE174PVjvbs7fz/KLnAbjrwrtoldCqHM5AREREREQqgjKF+ZEjR7Jq1SrmzJlDYGCgb33Xrl2ZMmVKuRUnUlE4XB5G/7SB699bxK7MAqpGB/PlnW158LI6WC2nODTFvvUw60nv8uXPQWwdHG4Hj8x9hHxXPi3jW3LHhXec+kmIiIiIiEiFUaZr47/55humTJnCRRddVOz+3IYNG7Jly5ZyK06kIti8L5cHpvzJ2l3ZAPRtmcyTPRsSGlAOt564iuCr28FdBBdcBq0GA/D68tdZn7GeyIBIRnUYhcV8CoPqiYiIiIhIhVOmtLF//37i4uJKrM/Ly9PgW3LeMAyDTxZt54Uf1lPo9BAZbOOlaxtzRaPE8jvIr89D2hoIjoGr3waTibmpc/lk/ScAPH/x8ySEJJTf8UREREREpEIo0/W/LVu25Pvvv/e9Phzg33//fdq2bVs+lYmcxfbnFHHb5KU88e06Cp0eOtSuxM8PdCzfIJ8yD35/y7t81VsQFk9aXhqPL3wcgJvr30ynKp3K73giIiIiIlJhlKln/sUXX6R79+789ddfuFwu3njjDf766y9+//135s6dW941ipxVfvkrjUe/Wk16ngO71czI7vUY0LY6ZnM5XpVSkAlf3w0Y0Lw/1LsSt8fNiPkjyCzKpH50fR5s8WD5HU9ERERERCqUMvXMt2/fnlWrVuFyuWjcuDEzZ84kLi6OP/74gxYtWpR3jSJnhXyHi/98vYbBHy8jPc9BvYQwvruvPbdeXKN8gzzADw9D9k6IqgHdRgEwcc1ElqUtI9gazCudXsFuOYU560VEREREpEI76Z55p9PJnXfeyRNPPMF77713OmoSOeusSs3kgSkrSTmQB8AdHWvy0OV1CLCehoHnVk+FNVPBZIFr34OAUJbtXcb4VeMBePyix6kWXq38jysiIiIiIhXGSffM22w2vvrqq9NRi8hZx+0xGPfrJnq/+zspB/JICA/ks8Ft+E+P+qcnyGemwvcPeZc7DYcqrcgszOTR+Y/iMTxcVesqetbqWf7HFRERERGRCqVMl9n36tWLb775ppxLETm7pGbk02/CH7w6829cHoMrL0zk5wc60u6CSqfngB43fH0XFGVBUkvo8DCGYfDEwifYl7+P6uHVeazNY6fn2CIiIiIiUqGUaQC82rVr8+yzz7Jw4UJatGhBSEhIsfeHDh1aLsWJ+INhGHy1YhdPz1hHbpGLsAArz/ZqSK+mSad36sU/xsH2BWALgWsngsXKZ+s/Zc7OOdjMNl7p9ArBtuDTd3wREREREakwTIZhGCe7U40aNY7foMnE1q1bT6kof8vOziYiIoKsrCzCw8P9XY6cQZn5Dh77ei3fr9kDQKvqUYzp25Qq0ac5RO9ZDe9dCh4n9HwTWgxgffp6bvrhJpweJyNbj+TG+jee3hpERERERMRvTjaHlqlnPiUlpSy7iZzVFmw6wENTV5KWXYTVbOLBy+pwV6daWMp7pPpjOQtg+h3eIF/3SmjenzxnHo/MewSnx0nnKp25od4Np7cGERERERGpUMoU5o92uGP/tF5+LHIaFTrdvPrzRt5f4P2SqmalEMZe35QLkyPPTAG/PAP710NIHFz1JphMvLj4RbZnbychJIHnLn5Of75ERERERKSYMg2AB/Dxxx/TuHFjgoKCCAoK4sILL+S///1vedYmctpt2JtNr7cX+oL8TW2q8t3Q9mcuyG+eDYvf9S73egdCKjFjywxmbJmB2WTmpQ4vEREQcWZqERERERGRCqNMPfNjxozhiSeeYMiQIVx88cUALFiwgLvuuosDBw7w4IMPlmuRIuXN4zH48PdtjP5pAw6Xh5gQOy/3uZAu9ePPXBH5GfDNPd7lVrdD7cvYlrWN5xc9D8DdTe6mRXyLM1ePiIiIiIhUGGUeAO+ZZ56hf//+xdZ/9NFHPP300xX+nnoNgHdu25tVyMNTV7Fg8wEALq0Xx+jeFxIbFnDmijAM+PIWWP8/qFQH7piLw2Llph9uYkPGBloltOK9y97DYj4Nc9mLiIiIiMhZ54wMgLdnzx7atWtXYn27du3Ys2dPWZoUOSN+XLOHkV+vITPfSaDNzONXNuCmNlXP/D3pKz/zBnmzFa59D+zBjFnyEhsyNhAVEMVLHV5SkBcRERERkeMq0z3zF1xwAV9++WWJ9VOmTKF27dqnXJRIecstcvHw1FXc/ekKMvOdNE6K4PuhHbj5ompnPshnpMCPw73Lnf8DlZvy247f+HT9pwA83/554oLjzmxNIiIiIiJSoZSpZ/6ZZ56hX79+zJs3z3fP/MKFC5k9e3apIV/En5Zvz+DBKavYkZGPyQT3XFKL+7vUwW4t8/iPZed2wdd3gSMXqraFix9gb95envj9CQD6N+hPx+SOZ74uERERERGpUMoU5nv37s3ixYt5/fXX+eabbwCoX78+S5YsoVmzZuVZn0iZOd0e3pq9iXG/bcZjQFJkEK/3a0rrGtH+K2rh65C6COxhcM0EXBg8Ou9RsoqyaBDTgAeaP+C/2kREREREpMIo8zzzLVq04JNPPinPWkTKTcqBPB6YspJVqZkAXNssiaevbkh4oM1/Re1aDnNe8i5f+SpEVWPiyndYsW8FIbYQXun4CjaLH+sTEREREZEKo0xh/ocffsBisdCtW7di63/++Wc8Hg/du3cvl+JEymLL/lyuemsBeQ434YFWXrimMT2bVPZvUY48mH4HeFzQ8Bq4sB9L9y5lwuoJADx50ZNUDa/q3xpFRERERKTCKNNNwyNGjMDtdpdYbxgGI0aMOOWiRE7Fu3O2kOdw0yQ5gp8e6Oj/IA8w83FI3wxhleHKMRwsymTEvBF4DA+9LuhFj5o9/F2hiIiIiIhUIGXqmd+0aRMNGjQosb5evXps3rz5lIsSKau07EK+XbkLgKevakjlyCA/VwT8/TMs+8C7fM27GEFRPP7rEPYV7KN6eHVGth7p3/pERERERKTCKVPPfEREBFu3bi2xfvPmzYSEhJxyUSJlNfn3bTjdBq2qR9GsapS/y4G0v+Cbu73LF90LNS/hk/WfMG/nPOxmO692epVgW7B/axQRERERkQqnTGH+6quv5oEHHmDLli2+dZs3b+ahhx7iqquuKrfiRE5GbpGLTxdtB+D2DjX9XA2weyVMvhLy0yGxKXR5knXp6xizfAwAj7R6hLrRdf1aooiIiIiIVExlCvMvv/wyISEh1KtXjxo1alCjRg3q1atHTEwMr776annXKHJCvlyaSnahixqVQuhaP96/xexcBh9fBQUZkNQC+n9DHm6Gzx2Oy+OiS9Uu9Kvbz781ioiIiIhIhVWme+YjIiL4/fffmTVrFqtWrSIoKIgmTZrQoUOH8q5P5IS43B4mLUgBYHCHGpjNJv8Vs/0P+PQ6cORA1bZw45cYAWE8t2AkO3J2kBiSyDPtnsFk8mONIiIiIiJSoZ1Uz/wff/zBd999B4DJZOLyyy8nLi6OV199ld69e3PHHXdQVFR0WgoV+Sc/rN3LrswCYkLs9G6e7L9Cts6BT671BvkaHeHmryAwnBlbZvD91u+xmCyM7jiaiIAI/9UoIiIiIiIV3kmF+WeffZZ169b5Xq9Zs4bbb7+dyy67jBEjRvC///2PUaNGlXuRIv/EMAwmzvOO39C/bXUCbRb/FLJpFnzaF5z5cEFXuPFLsIeQkpXCC4tfAODepvfSLK6Zf+oTEREREZFzxkmF+ZUrV9KlSxff6y+++ILWrVvz3nvvMWzYMN58802+/PLLci9S5J8s2prB2l3ZBFjN3NK2mn+K2PA9fH4DuIug7pVw/WdgCyLHkcPDcx+mwFVAm4Q23NboNv/UJyIiIiIi55STCvMHDx4kPv7IwGJz586le/fuvtetWrUiNTW1/KoTOQHvzfdOk3hdy2SiQ+xnvoC10+HL/uBxQoNe0PcjsAaQ78zn3tn38vfBv4kOjObFDi9iMfvpqgERERERETmnnFSYj4+PJyXFO8iYw+FgxYoVXHTRRb73c3JysNls5VuhyD/YlJbDrxv2YTLBoPZ+mI5u5efw1SDwuODC66H3JLDYKHIXcf9v9/Pnvj8Js4Uxvut44oLjznx9IiIiIiJyTjqpMN+jRw9GjBjB/PnzGTlyJMHBwcVGsF+9ejW1atUq9yJFjuf9+d4vly5vEE+NSiFn9uDLJ8M3d4Phgeb9ode7YLHidDt5aM5DLNqziCBrEO90fYf6MfXPbG0iIiIiInJOO6mp6Z577jmuvfZaOnXqRGhoKB999BF2+5HLmj/44AMuv/zyci9SpDT7cgr5+s9dANzR8Qz3yi+eCD8+4l1ufQdcMRrMZlweFyPmj2DuzrkEWAJ4u8vbNI1remZrExERERGRc95JhflKlSoxb948srKyCA0NxWIpfv/v1KlTCQ0NLdcCRY7no9+34XB7aFEtihbVos/cgRe+AbOe9C63uw8uew5MJjyGh6d+f4qZ22diNVsZ23ksrRJanbm6RERERETkvHFSYf6wiIjS58iOjj6DgUrOa3lFLj5ZtAOA2zucoV55w4B5r8Bv3mnm6DgcOv8HTCYMw+CFRS8wY8sMLCYLr3Z6lfZJ7c9MXSIiIiIict4pU5gX8bepy1LJKnBSPSaYyxrE//sOp8ow4NfnYP5r3teXPg4dHzn0lsGry17ly7+/xISJF9u/SJeqXf6hMRERERERkVOjMC8VjsvtYdJC78B3gzrUxGI2nd4DGgb8/Bgsetv7+vIXoN0Q39tvr3ybj//6GICn2z1Nj5o9Tm89IiIiIiJy3lOYlwrn53VppGYUEBVso0/z5NN7MI8HfngYlk3yvu7xKrS+3ff2pDWTmLB6AgAjWo/g2trXnt56REREREREUJiXCsYwDCbO2wLALW2rE2S3/Msep8Djhv8NhT8/AUxw1ZveKegO+XT9p4xdMRaA+5vfz031bzp9tYiIiIiIiBxFYV4qlCUpGazamUWA1Uz/ttVO34HcLvjmLlgzFUxm6DUemvTzvf31pq95aclLANx54Z0Mbjz49NUiIiIiIiJyDIV5qVDem78VgN4tkqkUGnB6DuJywFeDYP0MMFuh9yRo2Mv39g9bf+Cp358CoH+D/tzb9N7TU4eIiIiIiMhxKMxLhbF5Xy6/rN+HyQSD2tc4PQdxFsLUAfD3T2CxQ9+PoW5339uzt8/mPwv+v707j466uv8//pzsBJKwhISwhkV2cEEJiGItKKC1VdGitVWpYqvo18rX1lrFpfrVfu231l9bKxWLWq2tiopaEBdUrAiiUAWURdawmLAnECAJmfn9MTAQCXuSYcLzcc6cfHLv/Uzec/w457y493M/vyJEiO93/D63nnorgUANb8AnSZIkSd9gmFfM+OuH4Vn5gV2yad+0QfX/gbJt8PwVsORdSEiBy/4OHQZGuj9c/SG3fnArFaEKvtv+u9zR5w6DvCRJkqSoMMwrJqzbUspLs1cDcF3/dtX/B0q3wj8ug+X/hsT68IN/Qtv+ke5PCj7hZ+/9jJ3BnZzb5lzuPf1e4gJx1V+HJEmSJB0Cw7xiwjPTl1O2M8hJrRpyaptG1fvmO4rg2Utg1UxISoMfjofWfSLdn6/7nJFTRlJaUUr/lv35zZm/ISHO/3UkSZIkRY+JRMe8bWU7+duMFQD8pH+76l3avm0jPHsxrPkPpGTAj16BFr0i3fM3zOf6t69n+87t9Mnpw8PfepjE+MTq+/uSJEmSdAQM8zrmjZ+1is3bymndOJVzuzWrvjcuWQ9/uxAK50JqE/jRBMjpGelesnkJP3n7J2wp38IpWafw/87+fyTH19AO+pIkSZJ0GAzzOqZVBEM88e9lAFx7Zlvi46ppVn5LATz9XVi/EBpkw5WvQlaXSHd+cT4j3hrBptJNdGvSjUcHPEpqYmr1/G1JkiRJOkqGeR3T3vqigPyN22iYmsglvVpWz5sWrYKnL4CNSyGtOVz1OmR2iHSv2bqGa9+6lnXb13FCoxP4yzl/oUFSDeyeL0mSJElHyDCvY1YoFOIvH4QfR/ejPm1ITaqGy3XT8nCQ35wPDVvDla9B4z3PrF+7bS3XvnUtX5d8TW56Lo+f8zgZyRlH/3clSZIkqRoZ5nXMmrViE5+t3ExSfBxX9s09+jdcvxj+9l0oXg2N24Vn5DP2zPZv3LGREW+NYOWWlbRo0IKx544ls17m0f9dSZIkSapmhnkdsx7fNSt/8SktaJp2lBvPrV0QDvJbCyGzE1z1GqTt2UyvqLSIn7z9E5YWLSUrNYsnzn2CZvWrcbM9SZIkSapGhnkdk5au28rb8wsBuPbMdkf3ZgVz4W/fg20bILt7eNf6Bk0j3SXlJdzwzg0s2LiAximNeeLcJ2iZVk3350uSJElSDYiLdgGPPvooubm5pKSkkJeXx8yZMw84fvPmzYwcOZKcnBySk5Pp2LEjkyZNivTfc889BAKBSq/OnTvX9MdQNXviw2WEQjCwSxYdso5i87nVs+Cp74SDfM5J4aX1ewX57Tu3c+OUG5mzfg4ZyRmMPXcsbTPa7v/9JEmSJOkYENWZ+eeff55Ro0YxZswY8vLyeOSRRxg0aBALFy4kKytrn/FlZWWcc845ZGVlMX78eFq0aMGKFSto2LBhpXHdunXjnXfeifyekOAChFiyfmspL81aBcCIo5mVz58Bf78USouhZW/44XhI2bOZXVlFGbe8dwufFn5Kg8QG/GXgX+jYqOPRli9JkiRJNS6qKffhhx9mxIgRDB8+HIAxY8YwceJExo0bxy9/+ct9xo8bN46NGzfy0UcfkZiYCEBubu4+4xISEmjW7NDvdy4tLaW0tDTye3Fx8WF+ElWnZ6avoHRnkBNbZtC7beMje5Nl/4bnhkF5CbTpBz94HpLTIt3lwXJ+PvXnTFszjXoJ9fjzwD/TLbNbNX0CSZIkSapZUVtmX1ZWxqxZsxg4cOCeYuLiGDhwINOnT6/ynNdee42+ffsycuRIsrOz6d69Ow888AAVFRWVxn311Vc0b96cdu3accUVV5Cfn3/AWh588EEyMjIir1atWh39B9QR2V5WwTMzVgAwon87AoHA4b/Jms/CM/LlJdDubLhifKUgXxGs4I5/38G7K98lKS6JP3z7D5ycdXI1fQJJkiRJqnlRC/Pr16+noqKC7OzsSu3Z2dkUFBRUec7SpUsZP348FRUVTJo0idGjR/O73/2O+++/PzImLy+Pp556ismTJ/PYY4+xbNkyzjzzTLZs2bLfWm6//XaKiooir5UrV1bPh9Rhe2n2KjaWlNGyUT0GdzuC3eTLtsFL18LO7dB+AFz+T0hKjXQHQ0HunX4vbyx/g4RAAr8/+/f0yelTjZ9AkiRJkmpeTN1MHgwGycrK4vHHHyc+Pp5evXqxevVqfvvb33L33XcDMGTIkMj4nj17kpeXR5s2bXjhhRe45pprqnzf5ORkkpOP8tFnOmoVwRBP/Dv8OLprz2hLQvwR/FvT26Nhw1fQoBkMfQISUyJdoVCI38z8Da8sfoW4QBz/2/9/6d+yf3WVL0mSJEm1JmphPjMzk/j4eAoLCyu1FxYW7vd+95ycHBITE4mPj4+0denShYKCAsrKykhKStrnnIYNG9KxY0cWL15cvR9A1e7tLwtZvmEbGfUSufTUI7jVYdGb8MkT4eOLHoPUPffbh0IhHpn9CP9Y8A8CBLi/3/2cm3tuNVUuSZIkSbUrasvsk5KS6NWrF1OmTIm0BYNBpkyZQt++fas8p1+/fixevJhgMBhpW7RoETk5OVUGeYCtW7eyZMkScnJyqvcDqNqN3TUr/8M+ramffJj/zrR1Hbw6Mnzc5wZo/+1K3X+Z8xfGzRsHwJ197uSC9hccdb2SJEmSFC1Rfc78qFGjGDt2LE8//TTz58/n+uuvp6SkJLK7/ZVXXsntt98eGX/99dezceNGbr75ZhYtWsTEiRN54IEHGDlyZGTMrbfeytSpU1m+fDkfffQRF110EfHx8Vx++eW1/vl06Gat2MisFZtIio/jqr65h3dyKASv3Qgl6yCrKwy4u1L30188zaOfPQrAz0/9Od/v9P1qqlqSJEmSoiOq98wPGzaMdevWcdddd1FQUMBJJ53E5MmTI5vi5efnExe3598bWrVqxZtvvsktt9xCz549adGiBTfffDO33XZbZMyqVau4/PLL2bBhA02bNuWMM85gxowZNG3atNY/nw7d2A+WAXDhyc3JSk85yOhvmPUkLJoM8Ulw8dhK98k/v+B5/u/T/wPgxpNu5MpuV1ZbzZIkSZIULYFQKBSKdhHHmuLiYjIyMigqKiI9PT3a5dR5y9eXcPbv3icUgrdu6U/H7LSDn7Tb+q9gzJnh3evP/R84/cZI16uLX+XOaXcCcE33a7j5lJuP7FF3kiRJklTDDjeHRnWZvQTwxIdLCYXg7E5NDy/IV5TDyyPCQb7tWeF75XeZvHwyd310FwBXdLnCIC9JkiSpTjHMK6o2bC3lxU9XAXBd//aHd/L7v4E1/4GUhnDhY7Drloy56+Zy+we3EwwFGXrCUG477TaDvCRJkqQ6xTCvqHp2Rj6lO4P0aJFBn3aND37Cbiumw4cPh48veAQyWgCwM7iTX8/4NTtDOxnYeiCj+4w2yEuSJEmqcwzzipod5RX8bfpyAEb0b3fooXtHEbx8HYSCcOLl0O2iSNc/F/yTBRsXkJ6Uzp197iQ+Lr4GKpckSZKk6DLMK2penr2aDSVltGhYj/O6Nzv0E9+4DYryoWFrGPJQpLmwpJA/ffYnAH7W62c0qdekukuWJEmSpGOCYV5REQyGeOLfSwH48RltSYg/xEtx3svw+T8gEBd+DF3Knl0eH/rkIUrKS+jZtCdDTxhaE2VLkiRJ0jHBMK+omLJgLUvXl5CWksCw01od2klFq+FfPwsfn/nf0LpPpGva6mm8teIt4gJxjO4zmriAl7YkSZKkusvEo6h4/IMlAPywTxsaJCcc/IRgECb8NHy/fPOT4azbIl07du7gfz7+HwB+0PkHdG7cuUZqliRJkqRjhWFetW52/iY+Wb6JxPgAV5+ee2gnzXgUln0Aialw8RMQnxjp+uu8v7Jyy0qy6mVx48k31kzRkiRJknQMMcyr1u2+V/57J7UgOz3l4CcUzIUpvw4fD3oAMjtEupYXLeevc/8KwG29b6N+Yv1qr1eSJEmSjjWGedWqFRtKmDyvAIARZ7Y7+Anl2+GlEVBRBp3Og15XR7pCoRD3f3w/5cFy+rXoxzltzqmhqiVJkiTp2GKYV60a9+EygiE4q2NTOjVLO/gJ79wL6+ZD/Sz47h9hr2fRv7HsDT7++mOS45O5o/cdh/6cekmSJEmKcYZ51ZpNJWW88OkqAK7rfwiz8ounwMePhY+/9yjUz4x0bSnbwm8//S0A1/a4llbph7gjviRJkiTVAYZ51ZpnZ6xge3kFXXPSOb19kwMPLtkAE24IH592LXQ8t1L3H//zR9ZvX09uei4/7v7jGqpYkiRJko5NhnnVih3lFTw9fTkAPzmr3YGXxIdC8K+bYWsBZHaEc+6r1P3F+i/454J/AnBnnztJik+qqbIlSZIk6ZhkmFetmPCf1azfWkbzjBTO65Fz4MH/eRbmvw5xCXDxWEhKjXRVBCv49YxfEyLEeW3PIy8nr4YrlyRJkqRjj2FeNS4YDDF21+PofnxGWxLjD3DZbVwKb9wWPj77Dmh+UqXuFxa9wJcbviQtMY2fn/bzGqpYkiRJko5thnnVuPcWrmXJuhLSkhMYdtoBNqqr2AkvXwflJdCmH/S7uVL3+u3r+cPsPwDwX6f8F5n1Mqt6F0mSJEmq8wzzqnGPfxCelf9BXmvSUhL3P/Df/werPoHkDLhoDMTFV+p+6JOH2Fq+lW5NunFpx0trsmRJkiRJOqYZ5lWjPl+5mY+XbSQhLsDV/XL3P3DlJzD1ofDx+b+Dhq0rdU9fM503lr1BXCCO0X1HE/+NoC9JkiRJxxPDvGrU47vulf/uSc3JyahX9aDSLfDyCAhVQPdLoGflWfeyijIe+PgBAIZ1Gka3Jt1qtGZJkiRJOtYZ5lVjVm7cxhtzvwZgxJnt9j9w8u2waRmktwzPyn/DuHnjWF68nMx6mdx08k01Va4kSZIkxQzDvGrMXz9cRjAEZ56QSZec9KoHzX8d/vMMEAjfJ1+vYaXu/OJ8xs4ZC8AvTvsFaUlpNVu0JEmSJMUAw7xqxOZtZbzw6UoAruu/n1n54q/htf8KH/f7L2h7ZqXuUCjEAx8/QFmwjD45fRicO7gmS5YkSZKkmGGYV434+8f5bCuroHOzNM7oUMUj5IJBePUG2L4RmvWAs+/cZ8hbK95i2pppJMYlckfeHQQCgVqoXJIkSZKOfYZ5VbvSnRU89dFyIDwrX2UIn/k4LHkXElLg4icgIalS99ayrTw0M7y7/bU9riU3I7eGq5YkSZKk2GGYV7V79T9rWLellGbpKXynZ/N9B6ydD2/fFT4+5z7I6rzPkEc/e5S129fSOq011/S4poYrliRJkqTYYphXtQoGQ5HH0f34jFySEr5xie0shZdGQEUpdBgIvUfs8x7zN8znuQXPAXBH3h0kxyfXeN2SJEmSFEsM86pWUxetY/HarTRITuCy3q33HfDufVA4F1KbwPf+DN9Ygh8MBbl/xv0EQ0EG5Q7i9Ban11LlkiRJkhQ7DPOqVo9/EJ6Vv7x3K9JTEit3Lp0KH/0pfPzdP0Ja9j7nj180njnr51A/sT6/OO0XNV2uJEmSJMUkw7yqzdxVRUxfuoGEuADD+7Wt3Ll9E0y4HgjBKVdB5/P3OX/D9g08MvsRAG46+SayUrNqvmhJkiRJikGGeVWbsbvulf9OzxyaN6y3pyMUgn+NguLV0LgdDHqgyvN/9+nv2FK2hS6NuzCs07DaKFmSJEmSYpJhXtVi1aZtTJz7NQAj+rer3DnnBfjiZQjEhx9Dl9xgn/M/KfiE15e+ToAAo/uMJiEuoTbKliRJkqSYZJhXtXhq2nIqgiHO6JBJt+YZezo2rYBJt4aPv/VLaNlrn3PLK8q5f8b9AFza8VJ6NO1RGyVLkiRJUswyzOuolZTu5PlPVgJwzRl73SsfrIBXfgKlxdAqD84YVeX5T3/5NEuLltI4pTH/dcp/1UbJkiRJkhTTDPM6ai/NXsWW0p20y6zPWR2b7umY9gjkT4ekBnDRXyB+36Xzq7asYsznYwC49dRbyUjO2GeMJEmSJKkyw7yOSjAY4qlpywG46vRc4uJ2PTd+9Wx4b9dGd0MegsZt9zk3FArx4MwHKa0opXez3nyn3XdqqWpJkiRJim2GeR2VqV+tY+n6EtKSExjaq2W4sawEXh4BwZ3Q9Xtw0g+qPPfd/Hf5YNUHJMQlcEefOwgEArVYuSRJkiTFLsO8jsqTu2blv39aKxok71pG/9adsGExpOXAdx6BKkL6tvJtPDjzQQCGdxtOu4x2+4yRJEmSJFXNMK8jtnjtVj5YtI5AAK7qmxtuXDgZPh0XPr7wz5DauMpzH/v8MQq3FdKiQQuu63ld7RQsSZIkSXWEYV5H7KmPlgEwoHM2rZukwta18OrIcGefkdD+21Wet3DjQp758hkAfpX3K1ISUmqlXkmSJEmqKwzzOiJF28p5adZqAH7cLxdCIXj1Rti2HrK6wYC7qjwvGApy/4z7qQhVMLD1QPq37F+LVUuSJElS3WCY1xF5/tN8tpdX0Ck7jb7tm8CcF+CrNyE+CYaOhcSqZ9snLJ7AZ+s+IzUhldt631bLVUuSJElS3WCY12HbWRHk6Y9WADC8X254F/pZT4U7z7wVsrtVed6mHZt4eNbDANxw0g00q9+sNsqVJEmSpDrHMK/D9s78tazevJ1GqYlceHIL2LwS8j8CAnDyD/d73sOzHqaotIiOjTpyRZcraq9gSZIkSapjDPM6bE9OC298d3nv1qQkxsO8l8IdbU6HjBZVnjO7cDYTFk8AYHSf0STEJdRGqZIkSZJUJxnmdVi+WFPEx8s2Eh8X4Ed924Qb540P/+xxSZXnlAfLuW/GfQAMPWEoJ2WdVAuVSpIkSVLdZZjXYXlq2nIAhnRvRk5GPVi7AArmQlwCdL2wynOe/fJZFm9eTKPkRtzS65baK1aSJEmS6ijDvA7Zhq2lvPr5GiC88R2wZ1a+/QBIbbzPOWu2ruGxzx8DYNSpo8hIzqiNUiVJkiSpTjPM65A993E+ZTuD9GyZwSmtG4WfLT939xL7S6s85zczf8P2nds5JesUvtf+e7VYrSRJkiTVXYZ5HZKynUGemfGNx9Gtng2blkFiKnQass857698n/dWvkdCIIHRfUaHz5EkSZIkHTXDvA7JG/O+Zu2WUpqmJXN+j+bhxrkvhn92Og+SG1Qav618Gw9+/CAAV3a7kg6NOtRmuZIkSZJUpxnmdUjG7dr47od5bUhKiINgBXzxcrizil3sH5/zOGtK1tC8fnN+0vMntVipJEmSJNV9hnkd1H/yN/H5ys0kxcfxg7zW4cbl/4athZDSMLz53V4Wb1rM0188DcAve/+S1MTUWq5YkiRJkuo2w7wO6slds/IXnNicpmnJ4cbdS+y7XQgJSZGxoVCI+z++n52hnXyr1bc4u/XZtVusJEmSJB0HDPM6oIKiHUya+zWw1+PodpbCl6+Hj7tXXmL/2pLXmFU4i3oJ9bi99+21WKkkSZIkHT8M8zqgZ2esYGcwRO/cxnRvsesZ8V+9DaVFkNYc2pweGVtUWsTvPv0dAD898ac0b9A8GiVLkiRJUp1nmNd+7Siv4LmZ+cBes/KwZ4l994shLj7S/PtZv2dT6SY6NOzAj7r+qBYrlSRJkqTji2Fe+/XaZ2vYWFJGi4b1OKdrdrixdAssmhw+3msX+znr5vDSVy8BcGefO0mMS6ztciVJkiTpuGGYV5VCoRDjpi0D4Ed925AQv+tSWTARdu6AJh0g56TI+Ge+fAaA77b/Lr2ye9V2uZIkSZJ0XDHMq0ozlm5kQcEWUhLjuOy0Vns6di+x73EpBAIAlJSX8P7K9wH4Qecf1G6hkiRJknQcMsyrSk/umpW/+JSWNEzd9ei5kvWw5L3w8V672L+b/y47KnaQm55L1yZda7tUSZIkSTruGOa1j5Ubt/H2/EIAhp+eu6fji1cgVBFeXp/ZIdI8celEAM5rdx6BXbP1kiRJkqSaE/Uw/+ijj5Kbm0tKSgp5eXnMnDnzgOM3b97MyJEjycnJITk5mY4dOzJp0qSjek9V9rfpywmF4MwTMjkhO21Px9zx4Z89Lo00rd++nhlfzwDg/Lbn12aZkiRJknTcimqYf/755xk1ahR33303s2fP5sQTT2TQoEGsXbu2yvFlZWWcc845LF++nPHjx7Nw4ULGjh1LixYtjvg9VVlJ6U7++clK4BuPo9ucDytnAIHwI+l2eXP5m1SEKuiR2YPW6a1rt1hJkiRJOk5FNcw//PDDjBgxguHDh9O1a1fGjBlDamoq48aNq3L8uHHj2LhxIxMmTKBfv37k5uZy1llnceKJJx7xe6qyl2evYsuOnbTNrM+3Ombt6ZgXfuwcuWdAevNI86Sl4VUR57dzVl6SJEmSakvUwnxZWRmzZs1i4MCBe4qJi2PgwIFMnz69ynNee+01+vbty8iRI8nOzqZ79+488MADVFRUHPF7ApSWllJcXFzpdTwKBkM8+dFyAK7q24a4uL3uf48ssd+z8d3K4pXMWT+HuEAcg3IH1WKlkiRJknR8i1qYX79+PRUVFWRnZ1dqz87OpqCgoMpzli5dyvjx46moqGDSpEmMHj2a3/3ud9x///1H/J4ADz74IBkZGZFXq1at9ju2Lvvgq3UsXVdCg+QEhvZquadj7XwonAdxidDlu5HmicvCG9/1yelDZr3M2i5XkiRJko5bUd8A73AEg0GysrJ4/PHH6dWrF8OGDeOOO+5gzJgxR/W+t99+O0VFRZHXypUrq6ni2PLktOUAXHpqS9JSEvd07J6V7zAQUhsDEAqFIrvYu8RekiRJkmpXQrT+cGZmJvHx8RQWFlZqLywspFmzZlWek5OTQ2JiIvHx8ZG2Ll26UFBQQFlZ2RG9J0BycjLJyclH8Wli3+K1W5m6aB2BAFy99+PoQiGYt+8S+/kb57O8eDnJ8ckMaD2gdouVJEmSpONc1Gbmk5KS6NWrF1OmTIm0BYNBpkyZQt++fas8p1+/fixevJhgMBhpW7RoETk5OSQlJR3Reyrs6V33yg/onEWbJvX3dKyeBZuWQ2IqdBoSad49K/+tVt+ifuJe4yVJkiRJNS6qy+xHjRrF2LFjefrpp5k/fz7XX389JSUlDB8+HIArr7yS22+/PTL++uuvZ+PGjdx8880sWrSIiRMn8sADDzBy5MhDfk/tq2h7OS/NXgXA8H5tK3fOfTH8s/P5kBQO7RXBCt5Y9gbgs+UlSZIkKRqitsweYNiwYaxbt4677rqLgoICTjrpJCZPnhzZwC4/P5+4uD3/3tCqVSvefPNNbrnlFnr27EmLFi24+eabue222w75PbWvFz9dybayCjplp3F6+yZ7OoIVMO/l8HGPSyPNnxR+wrrt60hPSueMFmfUcrWSJEmSpEAoFApFu4hjTXFxMRkZGRQVFZGenh7tcmpURTDEWb99j1WbtvPgxT24vHfrPZ1L3oNnLoR6jeC/F0FCEgB3TbuLVxa/wiUdL+HuvndHp3BJkiRJqkMON4fG1G72qn7vzC9k1abtNExN5MKTWlTu3L2LfdcLI0G+tKKUt1e8DbjEXpIkSZKixTB/nHty2jIALu/dmnpJe54SQPkOmP96+HivJfYfrPqAreVbaVa/Gadkn1KbpUqSJEmSdjHMH8fmf13MjKUbiY8L8KM+bSp3Ln4bSosgvQW03vMkgElLJwEwpO0Q4gJePpIkSZIUDaax49juWfnB3ZrRvGG9yp27d7HvfjHs2oSwuKyYqaumAi6xlyRJkqRoMswfpzZsLWXCZ2sAGN4vt3LnjmJY9Gb4eK8l9u+seIfyYDkdGnagU+NOtVSpJEmSJOmbDPPHqX/MzKdsZ5AeLTLo1aZR5c4FE2HnDmhyAjTrGWnevcT+/HbOykuSJElSNBnmj0PlFUGembECCM/KBwKBygN2L7HvcSns6issKWRmwUwAzmt7Xq3VKkmSJEnal2H+ODRp7tcUFpeS2SCZ83vmVO7cug6Wvh8+7nFJpHny8smECHFK1ik0b9C89oqVJEmSJO3DMH8ceuqj5QD8sE9rkhPiK3d+OQFCFdD8ZGjSPtI8celEwCX2kiRJknQsMMwfZz5buZn/5G8mKT6OK/La7Dtg7yX2uywtWsr8jfNJCCRwTptzaqlSSZIkSdL+GOaPM7sfR/edE3NompZcuXPTClj5MRCAbhdHmnfPyvdr0Y9GKd/YLE+SJEmSVOsM88eRwuIdTJzzNQDDT2+774B5L4V/5p4B6eF76UOhkLvYS5IkSdIxxjB/HHl2xgp2BkOc2qYRPVpm7Dtg7vjwz72W2M9ZP4dVW1dRL6EeZ7U8q5YqlSRJkiQdiGH+OLGjvILnPs4HYHi/KmblC7+EtV9AXCJ0/W6kefcS+wGtB5CamFortUqSJEmSDswwf5x47fM1bCgpo3lGCoO6Ze87YN6uWfkTzoF64fviy4PlvLn8TcAl9pIkSZJ0LDHMHwdCoRBPTlsOwI/65pIQH/fNAXstsd/zbPmPv/6YjTs20jilMX1y+tRStZIkSZKkgzHMHwc+XraR+V8Xk5IYx+W9W+07YNWnsHkFJNaHjkMizbuX2A/KHURCXEJtlStJkiRJOgjD/HHgqV2z8hed3JKGqUn7Dtj9bPnO50NS+L74beXbmJI/BXCJvSRJkiQdawzzddzKjdt468sCAIb3y913QMVO+OLl8PFeu9hPXTWV7Tu307JBS3pm9qyFSiVJkiRJh8owX8c9M2MFwRCc0SGTjtlp+w5Y/gGUrIN6jaH92ZHm3Uvsz2t3HoFAoLbKlSRJkiQdAsN8HbatbCf/nBl+HN3Vp+dWPWj3xnfdLoT4RAA27djEtNXTAJfYS5IkSdKxyDBfh700ezXFO3bSpkkq3+6cte+A8h0w//Xw8V5L7N9a/hY7Qzvp0rgL7TLa1VK1kiRJkqRDZZivo4LBEE9NWwbAVX1ziYurYqn8V29BaTGkt4RWex49N2nZJMBZeUmSJEk6Vhnm66h/L17PknUlNEhO4NJTW1Y9aPcu9t0vhrjwpbBm6xpmr51NgACDcwfXUrWSJEmSpMNhmK+jntw1K39Jr5akpSTuO2BHESx6M3y81xL73bPyvZv1Jrt+do3XKUmSJEk6fIb5OmjJuq28v3AdgcABNr5bMBEqSiGzEzTrEWneexd7SZIkSdKxyTBfBz390XIAvt0pi9zM+lUP2r3EvsclsOvRcws3LmTx5sUkxiUysM3AWqhUkiRJknQkDPN1TPGOcsbPWgXA8H5tqx60dS0sfT983H1opHnisvCs/FktzyI9Kb0my5QkSZIkHQXDfB3zwicr2VZWQcfsBvTr0KTqQV9MgFAQWvSCJu0BCIaCvLHsDcAl9pIkSZJ0rDPM1yEVwRBPT18OwNWntyUQqOJxdLDXLvaXRJpmF86moKSAtMQ0+rfsX8OVSpIkSZKOhmG+Dpkyv5CVG7eTUS+Ri05uUfWgTcth1UwgEH4k3S67l9gPbDOQ5Pjkmi9WkiRJknTEDPN1yJPTlgNwWe9W1EuKr3rQvJfCP9v2h7RmAJRXlPPW8rcAOL/d+TVdpiRJkiTpKBnm64j5XxczfekG4uMCXNk3d/8D544P/+yxZ4n9h6s/pLismKb1mnJq9qk1W6gkSZIk6agZ5uuIp3bNyg/qlk2LhvWqHlT4Baz9EuKToMsFkebdS+yHtB1CfNx+ZvQlSZIkSccMw3wdsLGkjAmfrQYO8Dg62DMrf8K5UK8RAFvLtvL+yvcBl9hLkiRJUqwwzNcB/5iZT+nOIN1bpHNqm0ZVDwqF9oT5vZ4t/+7KdymtKCU3PZcujbvUQrWSJEmSpKNlmI9x5RVBnpm+AoDhB3oc3cqZUJQPSQ2g4+BI88Sl4SX257c7f//nSpIkSZKOKYb5GDd5XgEFxTvIbJDMd07M2f/Aebtm5Tt/B5JSAVi/fT0zvp4BwPltXWIvSZIkSbHCMB/jnpy2DIAr8lqTnLCfzesqdsK8l8PHe+1i/+byNwmGgvTM7Emr9FY1XaokSZIkqZoY5mPY5ys3Mzt/M4nxAa7o03r/A5e9D9vWQ2oTaPetSPPuJfbntTuvZguVJEmSJFUrw3wM2z0r/52ezclKS9n/wLkvhX92uwjiEwFYUbyCuevnEh+IZ3Du4P2fK0mSJEk65hjmY1QwGGJDSRkAw/vl7n9g+XaY/3r4uPueJfaTlk0CoE/zPjSp16SmypQkSZIk1YCEaBegIxMXF+CZa/JYum4r7Zo22P/Ar96Csi2Q0Qpa5QEQCoWYtDQc5t34TpIkSZJijzPzMe6AQR5g7ovhn92HQlz4P/eXG75kefFyUuJT+Hbrb9dwhZIkSZKk6maYr8t2FMGit8LHe+1iP3FZeOO7s1udTf3E+tGoTJIkSZJ0FAzzddn8f0FFKTTtDNndAagIVjB52WTAXewlSZIkKVYZ5uuy3Uvse1wCgQAAMwtmsm77OjKSM+jXvF8Ui5MkSZIkHSnDfF21pRCWTQ0f77WL/e5nyw9qM4jEXY+pkyRJkiTFFsN8XfXlBAgFocWp0LgtADt27uCd/HcAl9hLkiRJUiwzzNdVkSX2l0aaPlj1ASXlJeTUz+HkrJOjVJgkSZIk6WgZ5uuijctg1ScQiINuF0Wady+xP6/tecQF/E8vSZIkSbHKRFcXzXsp/LNtf0jLBqCotIh/r/43AOe3Oz9alUmSJEmSqoFhvq4JhapcYv/OincoD5ZzQqMTOKHRCVEqTpIkSZJUHQzzdU3hF7BuAcQnQ5cLIs0Tl4WX2J/f1ll5SZIkSYp1hvm6Zt748M8TzoGUDAAKSgr4tOBTIHy/vCRJkiQpthnm65JgEObuul9+ryX2k5dNJkSIU7JOIadBTpSKkyRJkiRVF8N8XbJqJhTlQ1IadBwUaY4ssXfjO0mSJEmqEwzzdcncXUvsu3wHEusBsGTzEhZsXEBCXALntjk3isVJkiRJkqqLYb6uqCiHL14JH/e4JNK8+9nyZzQ/g4YpDaNQmCRJkiSpuhnm64qlU2HbekjNhLbfAiAUCjFp2STAJfaSJEmSVJcY5uuK3bvYd7sI4hMA+Hzd56zeuprUhFTOanVWFIuTJEmSJFUnw3xdUL4d5r8ePt5rF/vdS+wHtB5AvYR60ahMkiRJklQDDPN1waLJULYVGraGVr0BKA+W8+byNwGX2EuSJElSXXNMhPlHH32U3NxcUlJSyMvLY+bMmfsd+9RTTxEIBCq9UlJSKo25+uqr9xkzePDgmv4Y0bN7F/vuQyEQAGD6mulsKt1E45TG5OXkRbE4SZIkSVJ1S4h2Ac8//zyjRo1izJgx5OXl8cgjjzBo0CAWLlxIVlZWleekp6ezcOHCyO+BXQF2b4MHD+bJJ5+M/J6cnFz9xR8Ltm+Gr94KH++1xH73xndD2g4hIS7q/5klSZIkSdUo6jPzDz/8MCNGjGD48OF07dqVMWPGkJqayrhx4/Z7TiAQoFmzZpFXdnb2PmOSk5MrjWnUqFFNfozomf86VJRBVlfI7gbAtvJtvJv/LgDntT0vmtVJkiRJkmpAVMN8WVkZs2bNYuDAgZG2uLg4Bg4cyPTp0/d73tatW2nTpg2tWrXie9/7Hl988cU+Y95//32ysrLo1KkT119/PRs2bNjv+5WWllJcXFzpFTPm7bXEfpf3Vr7H9p3baZXWih6ZPaJUmCRJkiSppkQ1zK9fv56Kiop9Ztazs7MpKCio8pxOnToxbtw4Xn31VZ599lmCwSCnn346q1atiowZPHgwf/vb35gyZQr/+7//y9SpUxkyZAgVFRVVvueDDz5IRkZG5NWqVavq+5A1aUsBLPsgfNzjkkjz3s+Wr+oWBEmSJElSbIu5m6n79u1L3759I7+ffvrpdOnShb/85S/cd999AFx22WWR/h49etCzZ0/at2/P+++/z4ABA/Z5z9tvv51Ro0ZFfi8uLo6NQP/FKxAKQsve0CgXgE07NvHR6o8Al9hLkiRJUl0V1Zn5zMxM4uPjKSwsrNReWFhIs2bNDuk9EhMTOfnkk1m8ePF+x7Rr147MzMz9jklOTiY9Pb3SKybs3sV+r1n5N5e/yc7QTro26UrbjLZRKkySJEmSVJOiGuaTkpLo1asXU6ZMibQFg0GmTJlSafb9QCoqKpg7dy45OTn7HbNq1So2bNhwwDExJxSCU66Etv2h20WR5olLJwJwflufLS9JkiRJdVXUl9mPGjWKq666ilNPPZXevXvzyCOPUFJSwvDhwwG48soradGiBQ8++CAAv/71r+nTpw8dOnRg8+bN/Pa3v2XFihVce+21QHhzvHvvvZehQ4fSrFkzlixZwi9+8Qs6dOjAoEGDovY5q10gAL2uCr92WbVlFZ+t+4wAAQa3HRzF4iRJkiRJNSnqYX7YsGGsW7eOu+66i4KCAk466SQmT54c2RQvPz+fuLg9Cwg2bdrEiBEjKCgooFGjRvTq1YuPPvqIrl27AhAfH8+cOXN4+umn2bx5M82bN+fcc8/lvvvuq7vPmt/ljWVvANA7pzdZqVlRrkaSJEmSVFMCoVAoFO0ijjXFxcVkZGRQVFQUM/fPh0IhLnr1IpYULeHXp/+ai0646OAnSZIkSZKOCYebQ6N6z7yqz6JNi1hStISkuCQGthkY7XIkSZIkSTXIMF9H7N747qxWZ5GWlBblaiRJkiRJNckwXwcEQ0EmLZsEuIu9JEmSJB0PDPN1wKzCWRRuKyQtMY0zW54Z7XIkSZIkSTXMMF8H7F5if07uOSTFJ0W5GkmSJElSTTPMx7iyijLeWvEW4BJ7SZIkSTpeGOZj3IerP2RL2RayUrPold0r2uVIkiRJkmqBYT7G7V5iPyR3CPFx8VGuRpIkSZJUGwzzMWxr2VamrpoKwPntXGIvSZIkSccLw3wMeyf/HUorSmmX0Y7OjTtHuxxJkiRJUi0xzMewSUt3PVu+3fkEAoEoVyNJkiRJqi2G+RgVCoXo0qQL2anZDGk7JNrlSJIkSZJqUSAUCoWiXcSxpri4mIyMDIqKikhPT492OQcUDAWJC/hvMpIkSZIUyw43h5oCY5xBXpIkSZKOPyZBSZIkSZJijGFekiRJkqQYY5iXJEmSJCnGGOYlSZIkSYoxhnlJkiRJkmKMYV6SJEmSpBhjmJckSZIkKcYY5iVJkiRJijGGeUmSJEmSYoxhXpIkSZKkGGOYlyRJkiQpxhjmJUmSJEmKMYZ5SZIkSZJijGFekiRJkqQYY5iXJEmSJCnGGOYlSZIkSYoxhnlJkiRJkmJMQrQLOBaFQiEAiouLo1yJJEmSJOl4sDt/7s6jB2OYr8KWLVsAaNWqVZQrkSRJkiQdT7Zs2UJGRsZBxwVChxr7jyPBYJA1a9aQlpZGIBCIdjn7VVxcTKtWrVi5ciXp6enRLkc6LF6/inVew4plXr+KZV6/imUHun5DoRBbtmyhefPmxMUd/I54Z+arEBcXR8uWLaNdxiFLT0/3i0wxy+tXsc5rWLHM61exzOtXsWx/1++hzMjv5gZ4kiRJkiTFGMO8JEmSJEkxxjAfw5KTk7n77rtJTk6OdinSYfP6VazzGlYs8/pVLPP6VSyrzuvXDfAkSZIkSYoxzsxLkiRJkhRjDPOSJEmSJMUYw7wkSZIkSTHGMC9JkiRJUowxzMewRx99lNzcXFJSUsjLy2PmzJnRLkk6qHvuuYdAIFDp1blz52iXJVXpgw8+4IILLqB58+YEAgEmTJhQqT8UCnHXXXeRk5NDvXr1GDhwIF999VV0ipW+4WDX79VXX73P9/HgwYOjU6z0DQ8++CCnnXYaaWlpZGVlceGFF7Jw4cJKY3bs2MHIkSNp0qQJDRo0YOjQoRQWFkapYmmPQ7l+v/Wtb+3zHfzTn/70sP6OYT5GPf/884waNYq7776b2bNnc+KJJzJo0CDWrl0b7dKkg+rWrRtff/115PXhhx9GuySpSiUlJZx44ok8+uijVfY/9NBD/OEPf2DMmDF8/PHH1K9fn0GDBrFjx45arlTa18GuX4DBgwdX+j7+xz/+UYsVSvs3depURo4cyYwZM3j77bcpLy/n3HPPpaSkJDLmlltu4fXXX+fFF19k6tSprFmzhosvvjiKVUthh3L9AowYMaLSd/BDDz10WH/HR9PFqLy8PE477TT+9Kc/ARAMBmnVqhU33XQTv/zlL6NcnbR/99xzDxMmTOCzzz6LdinSYQkEArzyyitceOGFQHhWvnnz5vz3f/83t956KwBFRUVkZ2fz1FNPcdlll0WxWqmyb16/EJ6Z37x58z4z9tKxaN26dWRlZTF16lT69+9PUVERTZs25bnnnuOSSy4BYMGCBXTp0oXp06fTp0+fKFcs7fHN6xfCM/MnnXQSjzzyyBG/rzPzMaisrIxZs2YxcODASFtcXBwDBw5k+vTpUaxMOjRfffUVzZs3p127dlxxxRXk5+dHuyTpsC1btoyCgoJK38UZGRnk5eX5XayY8f7775OVlUWnTp24/vrr2bBhQ7RLkqpUVFQEQOPGjQGYNWsW5eXllb6DO3fuTOvWrf0O1jHnm9fvbn//+9/JzMyke/fu3H777Wzbtu2w3jeh2ipUrVm/fj0VFRVkZ2dXas/OzmbBggVRqko6NHl5eTz11FN06tSJr7/+mnvvvZczzzyTefPmkZaWFu3ypENWUFAAUOV38e4+6Vg2ePBgLr74Ytq2bcuSJUv41a9+xZAhQ5g+fTrx8fHRLk+KCAaD/OxnP6Nfv350794dCH8HJyUl0bBhw0pj/Q7Wsaaq6xfgBz/4AW3atKF58+bMmTOH2267jYULF/Lyyy8f8nsb5iXVqiFDhkSOe/bsSV5eHm3atOGFF17gmmuuiWJlknR82ftWkB49etCzZ0/at2/P+++/z4ABA6JYmVTZyJEjmTdvnnvsKCbt7/q97rrrIsc9evQgJyeHAQMGsGTJEtq3b39I7+0y+xiUmZlJfHz8Prt1FhYW0qxZsyhVJR2Zhg0b0rFjRxYvXhztUqTDsvv71u9i1RXt2rUjMzPT72MdU2688Ub+9a9/8d5779GyZctIe7NmzSgrK2Pz5s2VxvsdrGPJ/q7fquTl5QEc1newYT4GJSUl0atXL6ZMmRJpCwaDTJkyhb59+0axMunwbd26lSVLlpCTkxPtUqTD0rZtW5o1a1bpu7i4uJiPP/7Y72LFpFWrVrFhwwa/j3VMCIVC3Hjjjbzyyiu8++67tG3btlJ/r169SExMrPQdvHDhQvLz8/0OVtQd7Pqtyu7NoQ/nO9hl9jFq1KhRXHXVVZx66qn07t2bRx55hJKSEoYPHx7t0qQDuvXWW7ngggto06YNa9as4e677yY+Pp7LL7882qVJ+9i6dWulfyFftmwZn332GY0bN6Z169b87Gc/4/777+eEE06gbdu2jB49mubNm1faMVyKlgNdv40bN+bee+9l6NChNGvWjCVLlvCLX/yCDh06MGjQoChWLYWNHDmS5557jldffZW0tLTIffAZGRnUq1ePjIwMrrnmGkaNGkXjxo1JT0/npptuom/fvu5kr6g72PW7ZMkSnnvuOc477zyaNGnCnDlzuOWWW+jfvz89e/Y89D8UUsz64x//GGrdunUoKSkp1Lt379CMGTOiXZJ0UMOGDQvl5OSEkpKSQi1atAgNGzYstHjx4miXJVXpvffeCwH7vK666qpQKBQKBYPB0OjRo0PZ2dmh5OTk0IABA0ILFy6MbtHSLge6frdt2xY699xzQ02bNg0lJiaG2rRpExoxYkSooKAg2mVLoVAoVOW1C4SefPLJyJjt27eHbrjhhlCjRo1CqampoYsuuij09ddfR69oaZeDXb/5+fmh/v37hxo3bhxKTk4OdejQIfTzn/88VFRUdFh/x+fMS5IkSZIUY7xnXpIkSZKkGGOYlyRJkiQpxhjmJUmSJEmKMYZ5SZIkSZJijGFekiRJkqQYY5iXJEmSJCnGGOYlSZIkSYoxhnlJkiRJkmKMYV6SJEVdIBBgwoQJ0S5DkqSYYZiXJOk4d/XVVxMIBPZ5DR48ONqlSZKk/UiIdgGSJCn6Bg8ezJNPPlmpLTk5OUrVSJKkg3FmXpIkkZycTLNmzSq9GjVqBISXwD/22GMMGTKEevXq0a5dO8aPH1/p/Llz5/Ltb3+bevXq0aRJE6677jq2bt1aacy4cePo1q0bycnJ5OTkcOONN1bqX79+PRdddBGpqamccMIJvPbaazX7oSVJimGGeUmSdFCjR49m6NChfP7551xxxRVcdtllzJ8/H4CSkhIGDRpEo0aN+OSTT3jxxRd55513KoX1xx57jJEjR3Ldddcxd+5cXnvtNTp06FDpb9x77718//vfZ86cOZx33nlcccUVbNy4sVY/pyRJsSIQCoVC0S5CkiRFz9VXX82zzz5LSkpKpfZf/epX/OpXvyIQCPDTn/6Uxx57LNLXp08fTjnlFP785z8zduxYbrvtNlauXEn9+vUBmDRpEhdccAFr1qwhOzubFi1aMHz4cO6///4qawgEAtx5553cd999QPgfCBo0aMAbb7zhvfuSJFXBe+YlSRJnn312pbAO0Lhx48hx3759K/X17duXzz77DID58+dz4oknRoI8QL9+/QgGgyxcuJBAIMCaNWsYMGDAAWvo2bNn5Lh+/fqkp6ezdu3aI/1IkiTVaYZ5SZJE/fr191n2Xl3q1at3SOMSExMr/R4IBAgGgzVRkiRJMc975iVJ0kHNmDFjn9+7dOkCQJcuXfj8888pKSmJ9E+bNo24uDg6depEWloaubm5TJkypVZrliSpLnNmXpIkUVpaSkFBQaW2hIQEMjMzAXjxxRc59dRTOeOMM/j73//OzJkz+etf/wrAFVdcwd13381VV13FPffcw7p167jpppv40Y9+RHZ2NgD33HMPP/3pT8nKymLIkCFs2bKFadOmcdNNN9XuB5UkqY4wzEuSJCZPnkxOTk6ltk6dOrFgwQIgvNP8P//5T2644QZycnL4xz/+QdeuXQFITU3lzTff5Oabb+a0004jNTWVoUOH8vDDD0fe66qrrmLHjh38/ve/59ZbbyUzM5NLLrmk9j6gJEl1jLvZS5KkAwoEArzyyitceOGF0S5FkiTt4j3zkiRJkiTFGMO8JEmSJEkxxnvmJUnSAXlHniRJxx5n5iVJkiRJijGGeUmSJEmSYoxhXpIkSZKkGGOYlyRJkiQpxhjmJUmSJEmKMYZ5SZIkSZJijGFekiRJkqQYY5iXJEmSJCnG/H/VfyohONvltwAAAABJRU5ErkJggg=="},"metadata":{}},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","Cell \u001b[0;32mIn[5], line 238\u001b[0m\n\u001b[1;32m    235\u001b[0m     plt\u001b[38;5;241m.\u001b[39mtight_layout()\n\u001b[1;32m    236\u001b[0m     plt\u001b[38;5;241m.\u001b[39mshow()\n\u001b[0;32m--> 238\u001b[0m \u001b[43mvisualize_predictions\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_loader\u001b[49m\u001b[43m)\u001b[49m\n","Cell \u001b[0;32mIn[5], line 232\u001b[0m, in \u001b[0;36mvisualize_predictions\u001b[0;34m(model, loader, num_images)\u001b[0m\n\u001b[1;32m    230\u001b[0m img \u001b[38;5;241m=\u001b[39m images[i]\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0\u001b[39m)  \u001b[38;5;66;03m# Reorder dimensions for plotting\u001b[39;00m\n\u001b[1;32m    231\u001b[0m img \u001b[38;5;241m=\u001b[39m (img \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m0.2023\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m0.4914\u001b[39m, img \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m0.1994\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m0.4822\u001b[39m, img \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m0.2010\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m0.4465\u001b[39m)  \u001b[38;5;66;03m# Denormalize\u001b[39;00m\n\u001b[0;32m--> 232\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimshow\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    233\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPred: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpreds[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, True: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlabels[i]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    234\u001b[0m plt\u001b[38;5;241m.\u001b[39maxis(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moff\u001b[39m\u001b[38;5;124m'\u001b[39m)\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/matplotlib/pyplot.py:2695\u001b[0m, in \u001b[0;36mimshow\u001b[0;34m(X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, data, **kwargs)\u001b[0m\n\u001b[1;32m   2689\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mimshow)\n\u001b[1;32m   2690\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mimshow\u001b[39m(\n\u001b[1;32m   2691\u001b[0m         X, cmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, norm\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m, aspect\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, interpolation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m   2692\u001b[0m         alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, vmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, vmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, origin\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, extent\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m   2693\u001b[0m         interpolation_stage\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, filternorm\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, filterrad\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4.0\u001b[39m,\n\u001b[1;32m   2694\u001b[0m         resample\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, url\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m-> 2695\u001b[0m     __ret \u001b[38;5;241m=\u001b[39m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimshow\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2696\u001b[0m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcmap\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnorm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maspect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maspect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2697\u001b[0m \u001b[43m        \u001b[49m\u001b[43minterpolation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43malpha\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvmin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvmin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2698\u001b[0m \u001b[43m        \u001b[49m\u001b[43mvmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvmax\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morigin\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextent\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextent\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2699\u001b[0m \u001b[43m        \u001b[49m\u001b[43minterpolation_stage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minterpolation_stage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2700\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfilternorm\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilternorm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilterrad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilterrad\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresample\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresample\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2701\u001b[0m \u001b[43m        \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2702\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2703\u001b[0m     sci(__ret)\n\u001b[1;32m   2704\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m __ret\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/matplotlib/__init__.py:1446\u001b[0m, in \u001b[0;36m_preprocess_data.<locals>.inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1443\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m   1444\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(ax, \u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m   1445\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1446\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1448\u001b[0m     bound \u001b[38;5;241m=\u001b[39m new_sig\u001b[38;5;241m.\u001b[39mbind(ax, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m   1449\u001b[0m     auto_label \u001b[38;5;241m=\u001b[39m (bound\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget(label_namer)\n\u001b[1;32m   1450\u001b[0m                   \u001b[38;5;129;01mor\u001b[39;00m bound\u001b[38;5;241m.\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mget(label_namer))\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/matplotlib/axes/_axes.py:5663\u001b[0m, in \u001b[0;36mAxes.imshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m   5655\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mset_aspect(aspect)\n\u001b[1;32m   5656\u001b[0m im \u001b[38;5;241m=\u001b[39m mimage\u001b[38;5;241m.\u001b[39mAxesImage(\u001b[38;5;28mself\u001b[39m, cmap\u001b[38;5;241m=\u001b[39mcmap, norm\u001b[38;5;241m=\u001b[39mnorm,\n\u001b[1;32m   5657\u001b[0m                       interpolation\u001b[38;5;241m=\u001b[39minterpolation, origin\u001b[38;5;241m=\u001b[39morigin,\n\u001b[1;32m   5658\u001b[0m                       extent\u001b[38;5;241m=\u001b[39mextent, filternorm\u001b[38;5;241m=\u001b[39mfilternorm,\n\u001b[1;32m   5659\u001b[0m                       filterrad\u001b[38;5;241m=\u001b[39mfilterrad, resample\u001b[38;5;241m=\u001b[39mresample,\n\u001b[1;32m   5660\u001b[0m                       interpolation_stage\u001b[38;5;241m=\u001b[39minterpolation_stage,\n\u001b[1;32m   5661\u001b[0m                       \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m-> 5663\u001b[0m \u001b[43mim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   5664\u001b[0m im\u001b[38;5;241m.\u001b[39mset_alpha(alpha)\n\u001b[1;32m   5665\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m im\u001b[38;5;241m.\u001b[39mget_clip_path() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m   5666\u001b[0m     \u001b[38;5;66;03m# image does not already have clipping set, clip to axes patch\u001b[39;00m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/matplotlib/image.py:710\u001b[0m, in \u001b[0;36m_ImageBase.set_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m    706\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A[:, :, \u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m    708\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m    709\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m]):\n\u001b[0;32m--> 710\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid shape \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m for image data\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    711\u001b[0m                     \u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A\u001b[38;5;241m.\u001b[39mshape))\n\u001b[1;32m    713\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[1;32m    714\u001b[0m     \u001b[38;5;66;03m# If the input data has values outside the valid range (after\u001b[39;00m\n\u001b[1;32m    715\u001b[0m     \u001b[38;5;66;03m# normalisation), we issue a warning and then clip X to the bounds\u001b[39;00m\n\u001b[1;32m    716\u001b[0m     \u001b[38;5;66;03m# - otherwise casting wraps extreme values, hiding outliers and\u001b[39;00m\n\u001b[1;32m    717\u001b[0m     \u001b[38;5;66;03m# making reliable interpretation impossible.\u001b[39;00m\n\u001b[1;32m    718\u001b[0m     high \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m255\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39missubdtype(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_A\u001b[38;5;241m.\u001b[39mdtype, np\u001b[38;5;241m.\u001b[39minteger) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m1\u001b[39m\n","\u001b[0;31mTypeError\u001b[0m: Invalid shape (3, 32, 32, 3) for image data"],"ename":"TypeError","evalue":"Invalid shape (3, 32, 32, 3) for image data","output_type":"error"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x1200 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"import torch\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Assuming you have a device (GPU or CPU)\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n# Function to visualize predictions\ndef visualize_predictions(model, loader, num_images=5):\n    model.to(device)  # Move the model to the appropriate device\n    model.eval()  # Set model to evaluation mode\n\n    # Loop through the test loader and collect predictions and true labels\n    with torch.no_grad():\n        count = 0\n        for images, labels in loader:\n            # Move images to the same device as the model\n            images = images.to(device)\n\n            # Pass the image tensor to the model\n            outputs = model(images)\n            _, preds = torch.max(outputs, 1)\n\n            # Show images and predictions\n            for i in range(min(num_images, len(images))):\n                img = images[i].cpu().numpy().transpose(1, 2, 0)  # Convert back to (H, W, C) for plotting\n                plt.figure(figsize=(3, 3))  # Set smaller figure size for the plot\n                plt.imshow(img)  # Display the image\n                plt.title(f\"Pred: {preds[i].item()}, True: {labels[i].item()}\")\n                plt.axis('off')\n                plt.show()\n\n                count += 1\n                if count >= num_images:\n                    return\n\n# Example call to visualize predictions\nvisualize_predictions(model, test_loader)\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T11:50:46.902203Z","iopub.execute_input":"2024-11-15T11:50:46.903134Z","iopub.status.idle":"2024-11-15T11:50:47.894432Z","shell.execute_reply.started":"2024-11-15T11:50:46.903083Z","shell.execute_reply":"2024-11-15T11:50:47.89351Z"},"trusted":true},"execution_count":12,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 300x300 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 300x300 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 300x300 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 300x300 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 300x300 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"import os\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.optim.lr_scheduler import CosineAnnealingLR\nimport torchvision\nimport torchvision.transforms as transforms\nfrom torchvision import models\nfrom torch.cuda.amp import GradScaler, autocast\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\nimport wandb\nimport matplotlib.pyplot as plt\n\n# Initialize WandB\nwandb.init(project=\"cifar10-resnet-transfer-learning\", config={\n    \"epochs\": 15,  # Set to 15 epochs for faster training\n    \"batch_size\": 128,\n    \"lr\": 1e-3,\n    \"num_classes\": 10,\n    \"pretrained_model\": \"ResNet-18\",  # Change to ResNet-18 (or any other)\n    \"freeze_layers\": True,  # Freeze layers for feature extraction\n    \"optimizer\": \"AdamW\",\n    \"scheduler\": \"CosineAnnealing\",\n})\n\nconfig = wandb.config\n\n# Data Augmentation for CIFAR-10\ntransform_train = transforms.Compose([\n    transforms.RandomHorizontalFlip(),\n    transforms.RandomCrop(32, padding=4),\n    transforms.RandomRotation(15),\n    transforms.AutoAugment(transforms.AutoAugmentPolicy.CIFAR10),\n    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2),  # Add color jitter\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n])\n\ntransform_test = transforms.Compose([\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),  # Corrected\n])\n\n\ntrain_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\ntest_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n\ntrain_loader = torch.utils.data.DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True, \n                                           num_workers=os.cpu_count(), pin_memory=True)\ntest_loader = torch.utils.data.DataLoader(test_dataset, batch_size=config.batch_size, shuffle=False, \n                                          num_workers=os.cpu_count(), pin_memory=True)\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n# Enable cuDNN optimization for GPUs\ntorch.backends.cudnn.benchmark = True\n\n# Load Pretrained ResNet\nclass ResNetTransfer(nn.Module):\n    def __init__(self, num_classes, freeze_layers=True):\n        super(ResNetTransfer, self).__init__()\n        self.model = models.resnet18(pretrained=True)  # You can change this to resnet34 or resnet101\n\n        # Freeze layers if specified for feature extraction\n        if freeze_layers:\n            for param in self.model.parameters():\n                param.requires_grad = False\n\n        # Replace final fully connected layer to adapt to CIFAR-10\n        in_features = self.model.fc.in_features\n        self.model.fc = nn.Linear(in_features, num_classes)\n\n    def forward(self, x):\n        return self.model(x)\n\n\nmodel = ResNetTransfer(num_classes=config.num_classes, freeze_layers=config.freeze_layers).to(device)\n\n# Define Loss, Optimizer, and Scheduler\ncriterion = nn.CrossEntropyLoss()\noptimizer = optim.AdamW(model.parameters(), lr=config.lr, weight_decay=1e-4)\nscheduler = CosineAnnealingLR(optimizer, T_max=config.epochs)\n\n# Mixed Precision Training\nscaler = GradScaler()\n\n# Training and Evaluation Functions\ndef train(model, loader):\n    model.train()\n    running_loss = 0\n    all_labels = []\n    all_preds = []\n\n    for inputs, labels in loader:\n        inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n\n        optimizer.zero_grad()\n        with autocast():  # Mixed Precision\n            outputs = model(inputs)\n            loss = criterion(outputs, labels)\n        \n        scaler.scale(loss).backward()\n        scaler.step(optimizer)\n        scaler.update()\n\n        running_loss += loss.item()\n        all_labels.extend(labels.cpu().numpy())\n        all_preds.extend(outputs.argmax(dim=1).cpu().numpy())\n\n    acc = accuracy_score(all_labels, all_preds) * 100\n    return running_loss / len(loader), acc\n\n\ndef test(model, loader):\n    model.eval()\n    running_loss = 0\n    all_labels = []\n    all_preds = []\n\n    with torch.no_grad():\n        for inputs, labels in loader:\n            inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n\n            with autocast():  # Mixed Precision\n                outputs = model(inputs)\n                loss = criterion(outputs, labels)\n\n            running_loss += loss.item()\n            all_labels.extend(labels.cpu().numpy())\n            all_preds.extend(outputs.argmax(dim=1).cpu().numpy())\n\n    acc = accuracy_score(all_labels, all_preds) * 100\n    precision = precision_score(all_labels, all_preds, average='macro')\n    recall = recall_score(all_labels, all_preds, average='macro')\n    f1 = f1_score(all_labels, all_preds, average='macro')\n    return running_loss / len(loader), acc, precision, recall, f1\n\n# Save Model\ndef save_model(model, path=\"resnet_transfer.pth\"):\n    torch.save(model.state_dict(), path)\n\n# Visualize Few Predictions\ndef visualize_predictions(model, loader, num_images=5):\n    model.eval()\n    with torch.no_grad():\n        for inputs, labels in loader:\n            inputs, labels = inputs.to(device), labels.to(device)\n            outputs = model(inputs)\n            _, preds = torch.max(outputs, 1)\n\n            # Show few predictions\n            for i in range(min(num_images, len(inputs))):\n                img = inputs[i].cpu().numpy().transpose(1, 2, 0)  # Convert to (H, W, C)\n                plt.imshow(img)\n                plt.title(f\"Pred: {preds[i].item()}, True: {labels[i].item()}\")\n                plt.axis('off')\n                plt.show()\n            break\n\n# Train and Evaluate the Model\nfor epoch in range(config.epochs):\n    train_loss, train_acc = train(model, train_loader)\n    test_loss, test_acc, test_precision, test_recall, test_f1 = test(model, test_loader)\n    scheduler.step()\n\n    # Log metrics to WandB\n    wandb.log({\n        \"epoch\": epoch + 1,\n        \"train_loss\": train_loss,\n        \"train_accuracy\": train_acc,\n        \"test_loss\": test_loss,\n        \"test_accuracy\": test_acc,\n        \"test_precision\": test_precision,\n        \"test_recall\": test_recall,\n        \"test_f1\": test_f1\n    })\n\n    print(f\"Epoch [{epoch + 1}/{config.epochs}], Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.2f}%, \"\n          f\"Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.2f}%, Precision: {test_precision:.4f}, \"\n          f\"Recall: {test_recall:.4f}, F1: {test_f1:.4f}\")\n\n# Save final model\nsave_model(model, \"resnet_transfer.pth\")\n\n# Visualize few predictions\nvisualize_predictions(model, test_loader)\n\nwandb.finish()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-15T12:19:23.462076Z","iopub.execute_input":"2024-11-15T12:19:23.462456Z","iopub.status.idle":"2024-11-15T12:27:07.145617Z","shell.execute_reply.started":"2024-11-15T12:19:23.462414Z","shell.execute_reply":"2024-11-15T12:27:07.14469Z"},"trusted":true},"execution_count":26,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Finishing last run (ID:fkyiwvqh) before initializing another..."},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"VBox(children=(Label(value='0.016 MB of 0.016 MB uploaded\\r'), FloatProgress(value=1.0, max=1.0)))","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run <strong style=\"color:#cdcd00\">faithful-wildflower-3</strong> at: <a href='https://wandb.ai/i210325-nuces/cifar10-advanced-resnet/runs/fkyiwvqh' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-advanced-resnet/runs/fkyiwvqh</a><br/> View project at: <a href='https://wandb.ai/i210325-nuces/cifar10-advanced-resnet' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-advanced-resnet</a><br/>Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Find logs at: <code>./wandb/run-20241115_121901-fkyiwvqh/logs</code>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Successfully finished last run (ID:fkyiwvqh). Initializing new run:<br/>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"VBox(children=(Label(value='Waiting for wandb.init()...\\r'), FloatProgress(value=0.011113614344443098, max=1.0…","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"bf4aac16b597494aba3c217eab3c9465"}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Tracking run with wandb version 0.18.3"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Run data is saved locally in <code>/kaggle/working/wandb/run-20241115_121923-v88lgdme</code>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Syncing run <strong><a href='https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning/runs/v88lgdme' target=\"_blank\">pleasant-microwave-2</a></strong> to <a href='https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View project at <a href='https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning</a>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run at <a href='https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning/runs/v88lgdme' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning/runs/v88lgdme</a>"},"metadata":{}},{"name":"stdout","text":"Files already downloaded and verified\nFiles already downloaded and verified\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:85: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n  scaler = GradScaler()\n/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [1/15], Train Loss: 2.1212, Train Acc: 23.59%, Test Loss: 1.8304, Test Acc: 36.58%, Precision: 0.3849, Recall: 0.3658, F1: 0.3549\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [2/15], Train Loss: 2.0314, Train Acc: 27.47%, Test Loss: 1.8051, Test Acc: 37.43%, Precision: 0.3885, Recall: 0.3743, F1: 0.3681\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [3/15], Train Loss: 2.0153, Train Acc: 28.08%, Test Loss: 1.7635, Test Acc: 38.64%, Precision: 0.3912, Recall: 0.3864, F1: 0.3800\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [4/15], Train Loss: 2.0046, Train Acc: 28.16%, Test Loss: 1.8040, Test Acc: 37.57%, Precision: 0.3893, Recall: 0.3757, F1: 0.3632\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [5/15], Train Loss: 1.9940, Train Acc: 28.98%, Test Loss: 1.7911, Test Acc: 37.81%, Precision: 0.3903, Recall: 0.3781, F1: 0.3630\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [6/15], Train Loss: 1.9848, Train Acc: 29.29%, Test Loss: 1.7772, Test Acc: 38.42%, Precision: 0.3989, Recall: 0.3842, F1: 0.3817\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [7/15], Train Loss: 1.9818, Train Acc: 29.32%, Test Loss: 1.7637, Test Acc: 38.46%, Precision: 0.4021, Recall: 0.3846, F1: 0.3826\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [8/15], Train Loss: 1.9763, Train Acc: 29.64%, Test Loss: 1.7858, Test Acc: 38.38%, Precision: 0.4081, Recall: 0.3838, F1: 0.3787\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [9/15], Train Loss: 1.9711, Train Acc: 29.85%, Test Loss: 1.7638, Test Acc: 38.60%, Precision: 0.4040, Recall: 0.3860, F1: 0.3800\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [10/15], Train Loss: 1.9731, Train Acc: 29.54%, Test Loss: 1.7409, Test Acc: 40.00%, Precision: 0.4047, Recall: 0.4000, F1: 0.3930\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [11/15], Train Loss: 1.9708, Train Acc: 29.60%, Test Loss: 1.7654, Test Acc: 38.69%, Precision: 0.4034, Recall: 0.3869, F1: 0.3810\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [12/15], Train Loss: 1.9623, Train Acc: 30.12%, Test Loss: 1.7436, Test Acc: 39.88%, Precision: 0.4055, Recall: 0.3988, F1: 0.3953\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [13/15], Train Loss: 1.9615, Train Acc: 29.98%, Test Loss: 1.7528, Test Acc: 39.45%, Precision: 0.4108, Recall: 0.3945, F1: 0.3883\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [14/15], Train Loss: 1.9572, Train Acc: 30.34%, Test Loss: 1.7478, Test Acc: 40.09%, Precision: 0.4109, Recall: 0.4009, F1: 0.3966\n","output_type":"stream"},{"name":"stderr","text":"/tmp/ipykernel_30/3649381278.py:98: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n/tmp/ipykernel_30/3649381278.py:124: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n  with autocast():  # Mixed Precision\n","output_type":"stream"},{"name":"stdout","text":"Epoch [15/15], Train Loss: 1.9577, Train Acc: 30.48%, Test Loss: 1.7457, Test Acc: 39.90%, Precision: 0.4089, Recall: 0.3990, F1: 0.3949\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"VBox(children=(Label(value='0.024 MB of 0.024 MB uploaded\\r'), FloatProgress(value=1.0, max=1.0)))","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":""}},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"<style>\n    table.wandb td:nth-child(1) { padding: 0 10px; text-align: left ; width: auto;} td:nth-child(2) {text-align: left ; width: 100%}\n    .wandb-row { display: flex; flex-direction: row; flex-wrap: wrap; justify-content: flex-start; width: 100% }\n    .wandb-col { display: flex; flex-direction: column; flex-basis: 100%; flex: 1; padding: 10px; }\n    </style>\n<div class=\"wandb-row\"><div class=\"wandb-col\"><h3>Run history:</h3><br/><table class=\"wandb\"><tr><td>epoch</td><td>▁▁▂▃▃▃▄▅▅▅▆▇▇▇█</td></tr><tr><td>test_accuracy</td><td>▁▃▅▃▃▅▅▅▅█▅█▇██</td></tr><tr><td>test_f1</td><td>▁▃▅▂▂▆▆▅▅▇▅█▇██</td></tr><tr><td>test_loss</td><td>█▆▃▆▅▄▃▅▃▁▃▁▂▂▁</td></tr><tr><td>test_precision</td><td>▁▂▃▂▂▅▆▇▆▆▆▇██▇</td></tr><tr><td>test_recall</td><td>▁▃▅▃▃▅▅▅▅█▅█▇██</td></tr><tr><td>train_accuracy</td><td>▁▅▆▆▆▇▇▇▇▇▇█▇██</td></tr><tr><td>train_loss</td><td>█▄▃▃▃▂▂▂▂▂▂▁▁▁▁</td></tr></table><br/></div><div class=\"wandb-col\"><h3>Run summary:</h3><br/><table class=\"wandb\"><tr><td>epoch</td><td>15</td></tr><tr><td>test_accuracy</td><td>39.9</td></tr><tr><td>test_f1</td><td>0.39487</td></tr><tr><td>test_loss</td><td>1.74573</td></tr><tr><td>test_precision</td><td>0.40893</td></tr><tr><td>test_recall</td><td>0.399</td></tr><tr><td>train_accuracy</td><td>30.484</td></tr><tr><td>train_loss</td><td>1.95767</td></tr></table><br/></div></div>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":" View run <strong style=\"color:#cdcd00\">pleasant-microwave-2</strong> at: <a href='https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning/runs/v88lgdme' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning/runs/v88lgdme</a><br/> View project at: <a href='https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning' target=\"_blank\">https://wandb.ai/i210325-nuces/cifar10-resnet-transfer-learning</a><br/>Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"Find logs at: <code>./wandb/run-20241115_121923-v88lgdme/logs</code>"},"metadata":{}}]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}