{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.12.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceType":"competition","sourceId":3649,"databundleVersionId":46718}],"dockerImageVersionId":31287,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"## Convulation operation : practice ","metadata":{}},{"cell_type":"code","source":"import torch \nimport torchvision \nfrom torchvision.transforms import transforms\nfrom torch.optim import Adam \nfrom torch.utils.data import Dataset, DataLoader","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:20:51.532898Z","iopub.execute_input":"2026-04-05T11:20:51.533882Z","iopub.status.idle":"2026-04-05T11:20:59.407324Z","shell.execute_reply.started":"2026-04-05T11:20:51.533839Z","shell.execute_reply":"2026-04-05T11:20:59.406646Z"}},"outputs":[],"execution_count":2},{"cell_type":"code","source":"transform = transforms.Compose([\n    transforms.Resize(256),\n    transforms.ToTensor()\n])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:01.994818Z","iopub.execute_input":"2026-04-05T11:21:01.99522Z","iopub.status.idle":"2026-04-05T11:21:01.999466Z","shell.execute_reply.started":"2026-04-05T11:21:01.995193Z","shell.execute_reply":"2026-04-05T11:21:01.998716Z"}},"outputs":[],"execution_count":3},{"cell_type":"code","source":"train_set = torchvision.datasets.CIFAR10(root=\"./data\",train=True,download=True,transform=transform)\ntest_set = torchvision.datasets.CIFAR10(root=\"./data\",train=False,download=False)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:03.794193Z","iopub.execute_input":"2026-04-05T11:21:03.795046Z","iopub.status.idle":"2026-04-05T11:21:08.967955Z","shell.execute_reply.started":"2026-04-05T11:21:03.795013Z","shell.execute_reply":"2026-04-05T11:21:08.96726Z"}},"outputs":[{"name":"stderr","text":"100%|██████████| 170M/170M [00:02<00:00, 79.6MB/s] \n","output_type":"stream"}],"execution_count":4},{"cell_type":"code","source":"train_set","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:08.969401Z","iopub.execute_input":"2026-04-05T11:21:08.969849Z","iopub.status.idle":"2026-04-05T11:21:08.976174Z","shell.execute_reply.started":"2026-04-05T11:21:08.969811Z","shell.execute_reply":"2026-04-05T11:21:08.975231Z"}},"outputs":[{"execution_count":5,"output_type":"execute_result","data":{"text/plain":"Dataset CIFAR10\n    Number of datapoints: 50000\n    Root location: ./data\n    Split: Train\n    StandardTransform\nTransform: Compose(\n               Resize(size=256, interpolation=bilinear, max_size=None, antialias=True)\n               ToTensor()\n           )"},"metadata":{}}],"execution_count":5},{"cell_type":"code","source":"train_loader = DataLoader(train_set,batch_size=32,shuffle=True)\ntest_loader = DataLoader(test_set,batch_size=32,shuffle=True)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:09.799159Z","iopub.execute_input":"2026-04-05T11:21:09.799835Z","iopub.status.idle":"2026-04-05T11:21:09.803851Z","shell.execute_reply.started":"2026-04-05T11:21:09.799806Z","shell.execute_reply":"2026-04-05T11:21:09.803113Z"}},"outputs":[],"execution_count":6},{"cell_type":"code","source":"for image,label in train_loader:\n    break","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:12.542404Z","iopub.execute_input":"2026-04-05T11:21:12.543144Z","iopub.status.idle":"2026-04-05T11:21:12.666432Z","shell.execute_reply.started":"2026-04-05T11:21:12.543115Z","shell.execute_reply":"2026-04-05T11:21:12.665686Z"}},"outputs":[],"execution_count":7},{"cell_type":"code","source":"image.shape , label.shape","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:14.509069Z","iopub.execute_input":"2026-04-05T11:21:14.509366Z","iopub.status.idle":"2026-04-05T11:21:14.514587Z","shell.execute_reply.started":"2026-04-05T11:21:14.509343Z","shell.execute_reply":"2026-04-05T11:21:14.513892Z"}},"outputs":[{"execution_count":8,"output_type":"execute_result","data":{"text/plain":"(torch.Size([32, 3, 256, 256]), torch.Size([32]))"},"metadata":{}}],"execution_count":8},{"cell_type":"code","source":"# Mean and Std for CIFAR-10 normalization\nstats = ((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n\ntrain_transform = transforms.Compose([\n    transforms.Resize(256),\n    transforms.RandomHorizontalFlip(), # Basic augmentation for better generalization\n    transforms.ToTensor(),\n    transforms.Normalize(*stats)\n])\n\n# Test transform should NOT have random augmentations\ntest_transform = transforms.Compose([\n    transforms.Resize(256),\n    transforms.ToTensor(),\n    transforms.Normalize(*stats)\n])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:16.277318Z","iopub.execute_input":"2026-04-05T11:21:16.277771Z","iopub.status.idle":"2026-04-05T11:21:16.285414Z","shell.execute_reply.started":"2026-04-05T11:21:16.277724Z","shell.execute_reply":"2026-04-05T11:21:16.284911Z"}},"outputs":[],"execution_count":9},{"cell_type":"code","source":"# Training Set\ntrain_set = torchvision.datasets.CIFAR10(\n    root=\"./data\", train=True, download=True, transform=train_transform\n)\n\n# Test Set (Fixed: added transform and download=True)\ntest_set = torchvision.datasets.CIFAR10(\n    root=\"./data\", train=False, download=True, transform=test_transform\n)\n\n# Loaders\ntrain_loader = DataLoader(train_set, batch_size=32, shuffle=True, num_workers=2)\ntest_loader = DataLoader(test_set, batch_size=32, shuffle=False, num_workers=2)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:18.992146Z","iopub.execute_input":"2026-04-05T11:21:18.992602Z","iopub.status.idle":"2026-04-05T11:21:20.666878Z","shell.execute_reply.started":"2026-04-05T11:21:18.992573Z","shell.execute_reply":"2026-04-05T11:21:20.666234Z"}},"outputs":[],"execution_count":10},{"cell_type":"code","source":"# Take a peek at one batch\nimages, labels = next(iter(train_loader))\n\nprint(f\"Image batch shape: {images.shape}\") # Expected: [32, 3, 256, 256]\nprint(f\"Label batch shape: {labels.shape}\") # Expected: [32]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:22.574874Z","iopub.execute_input":"2026-04-05T11:21:22.575597Z","iopub.status.idle":"2026-04-05T11:21:22.87609Z","shell.execute_reply.started":"2026-04-05T11:21:22.575569Z","shell.execute_reply":"2026-04-05T11:21:22.874985Z"}},"outputs":[{"name":"stdout","text":"Image batch shape: torch.Size([32, 3, 256, 256])\nLabel batch shape: torch.Size([32])\n","output_type":"stream"}],"execution_count":11},{"cell_type":"code","source":"import torch.nn as nn\nfrom torchvision import models\n\n# 1. Load a pre-trained ResNet18\nmodel = models.resnet18(weights='DEFAULT')\n\n# 2. Modify the final layer (CIFAR-10 has 10 classes)\nnum_ftrs = model.fc.in_features\nmodel.fc = nn.Linear(num_ftrs, 10)\n\n# 3. Move model to GPU if available\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel = model.to(device)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:24.697935Z","iopub.execute_input":"2026-04-05T11:21:24.698753Z","iopub.status.idle":"2026-04-05T11:21:25.855909Z","shell.execute_reply.started":"2026-04-05T11:21:24.698719Z","shell.execute_reply":"2026-04-05T11:21:25.855205Z"}},"outputs":[{"name":"stdout","text":"Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 44.7M/44.7M [00:00<00:00, 154MB/s] \n","output_type":"stream"}],"execution_count":12},{"cell_type":"code","source":"import torch.optim as optim\n\ncriterion = nn.CrossEntropyLoss()\noptimizer = optim.Adam(model.parameters(), lr=0.001)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:28.805231Z","iopub.execute_input":"2026-04-05T11:21:28.805685Z","iopub.status.idle":"2026-04-05T11:21:28.810814Z","shell.execute_reply.started":"2026-04-05T11:21:28.805654Z","shell.execute_reply":"2026-04-05T11:21:28.809966Z"}},"outputs":[],"execution_count":13},{"cell_type":"code","source":"import torchvision\nfrom torchvision.transforms import transforms\nfrom torch.utils.data import DataLoader\n\n# 1. Define the transform WITHOUT Resize(256)\nnew_transform = transforms.Compose([\n    transforms.ToTensor(),\n    # Optional: You can add normalization here as well\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) \n])\n\n# 2. Re-initialize the datasets with the new transform\ntrain_set = torchvision.datasets.CIFAR10(root=\"./data\", train=True, download=True, transform=new_transform)\ntest_set = torchvision.datasets.CIFAR10(root=\"./data\", train=False, download=True, transform=new_transform)\n\n# 3. Re-initialize the DataLoaders\ntrain_loader = DataLoader(train_set, batch_size=32, shuffle=True)\ntest_loader = DataLoader(test_set, batch_size=32, shuffle=False)\n\n# Quick verification test\nimages, labels = next(iter(train_loader))\nprint(f\"New flattened image shape: {images.view(images.size(0), -1).shape}\") \n# This should now print: torch.Size([32, 3072])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:21:30.931977Z","iopub.execute_input":"2026-04-05T11:21:30.932598Z","iopub.status.idle":"2026-04-05T11:21:32.715129Z","shell.execute_reply.started":"2026-04-05T11:21:30.932569Z","shell.execute_reply":"2026-04-05T11:21:32.714404Z"}},"outputs":[{"name":"stdout","text":"New flattened image shape: torch.Size([32, 3072])\n","output_type":"stream"}],"execution_count":14},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# 1. Setup Device (GPU if available, else CPU)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"Using device: {device}\")\n\n# 2. Define the loss function for all autoencoders\ncriterion_ae = nn.MSELoss()\n\n# 3. Un-normalize function for visualization later\ndef imshow(img, title=None):\n    mean = torch.tensor([0.4914, 0.4822, 0.4465]).view(3, 1, 1).to(device)\n    std = torch.tensor([0.2023, 0.1994, 0.2010]).view(3, 1, 1).to(device)\n    \n    img = img * std + mean     \n    img = img.clamp(0, 1)      \n    npimg = img.cpu().numpy()\n    \n    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n    if title:\n        plt.title(title)\n    plt.axis('off')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-06T13:24:25.529666Z","iopub.execute_input":"2026-04-06T13:24:25.529934Z","iopub.status.idle":"2026-04-06T13:24:30.378936Z","shell.execute_reply.started":"2026-04-06T13:24:25.529904Z","shell.execute_reply":"2026-04-06T13:24:30.378058Z"}},"outputs":[{"name":"stdout","text":"Using device: cuda\n","output_type":"stream"}],"execution_count":1},{"cell_type":"code","source":"class VanillaAutoencoder(nn.Module):\n    def __init__(self):\n        super(VanillaAutoencoder, self).__init__()\n        # ENCODER: Flattens 32x32x3 (3072) down to 128\n        self.encoder = nn.Sequential(\n            nn.Linear(3072, 512),\n            nn.ReLU(),\n            nn.Linear(512, 128),\n            nn.ReLU()\n        )\n        # DECODER: Expands 128 back to 3072\n        self.decoder = nn.Sequential(\n            nn.Linear(128, 512),\n            nn.ReLU(),\n            nn.Linear(512, 3072)\n        )\n\n    def forward(self, x):\n        batch_size = x.size(0)\n        x = x.view(batch_size, -1)     # Flatten the image\n        encoded = self.encoder(x)      # Compress\n        decoded = self.decoder(encoded)# Reconstruct\n        return decoded.view(batch_size, 3, 32, 32) # Reshape back to 3D image\n\n# Initialize model and optimizer\nvanilla_ae = VanillaAutoencoder().to(device)\noptimizer_vanilla = optim.Adam(vanilla_ae.parameters(), lr=1e-3)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-06T13:24:35.996589Z","iopub.execute_input":"2026-04-06T13:24:35.996905Z","iopub.status.idle":"2026-04-06T13:24:39.256787Z","shell.execute_reply.started":"2026-04-06T13:24:35.996878Z","shell.execute_reply":"2026-04-06T13:24:39.256214Z"}},"outputs":[],"execution_count":2},{"cell_type":"code","source":"class ConvAutoencoder(nn.Module):\n    def __init__(self):\n        super(ConvAutoencoder, self).__init__()\n        # ENCODER: Compresses the image using convolutions\n        self.encoder = nn.Sequential(\n            nn.Conv2d(3, 16, 3, stride=2, padding=1), \n            nn.ReLU(),\n            nn.Conv2d(16, 32, 3, stride=2, padding=1), \n            nn.ReLU()\n        )\n        # DECODER: Upscales the image using transposed convolutions\n        self.decoder = nn.Sequential(\n            nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1), \n            nn.ReLU(),\n            nn.ConvTranspose2d(16, 3, 3, stride=2, padding=1, output_padding=1)  \n        )\n\n    def forward(self, x):\n        encoded = self.encoder(x)      # Compress\n        decoded = self.decoder(encoded)# Reconstruct\n        return decoded\n\n# Initialize model and optimizer\nconv_ae = ConvAutoencoder().to(device)\noptimizer_conv = optim.Adam(conv_ae.parameters(), lr=1e-3)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-06T13:24:41.83042Z","iopub.execute_input":"2026-04-06T13:24:41.830781Z","iopub.status.idle":"2026-04-06T13:24:41.83949Z","shell.execute_reply.started":"2026-04-06T13:24:41.830759Z","shell.execute_reply":"2026-04-06T13:24:41.838586Z"}},"outputs":[],"execution_count":3},{"cell_type":"code","source":"def train_autoencoder(model, optimizer, dataloader, epochs=5, is_denoising=False, noise_factor=0.3):\n    model.train()\n    print(f\"\\n--- Training {model.__class__.__name__} | Denoising Mode: {is_denoising} ---\")\n    \n    for epoch in range(epochs):\n        running_loss = 0.0\n        for images, _ in dataloader:\n            images = images.to(device)\n            \n            # --- DENOISING LOGIC ---\n            if is_denoising:\n                # Add random static to the images\n                noisy_images = images + noise_factor * torch.randn(*images.shape).to(device)\n                inputs = noisy_images\n            else:\n                inputs = images\n                \n            optimizer.zero_grad()\n            \n            # Pass the input (noisy or clean) into the model\n            outputs = model(inputs)\n            \n            # The target is ALWAYS the clean, original images\n            loss = criterion_ae(outputs, images)\n            \n            loss.backward()\n            optimizer.step()\n            running_loss += loss.item()\n            \n        print(f\"Epoch [{epoch+1}/{epochs}] - MSE Loss: {running_loss/len(dataloader):.4f}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-06T13:24:46.697884Z","iopub.execute_input":"2026-04-06T13:24:46.698211Z","iopub.status.idle":"2026-04-06T13:24:46.703792Z","shell.execute_reply.started":"2026-04-06T13:24:46.698172Z","shell.execute_reply":"2026-04-06T13:24:46.703234Z"}},"outputs":[],"execution_count":4},{"cell_type":"code","source":"# 1. Standard Vanilla Autoencoder\nvanilla_ae = VanillaAutoencoder().to(device)\noptimizer_vanilla = optim.Adam(vanilla_ae.parameters(), lr=1e-3)\n\n# 2. Standard Convolutional Autoencoder\nconv_ae = ConvAutoencoder().to(device)\noptimizer_conv = optim.Adam(conv_ae.parameters(), lr=1e-3)\n\n# 3. Vanilla Denoising Autoencoder (Same architecture, separate fresh weights)\nvanilla_denoise_ae = VanillaAutoencoder().to(device)\noptimizer_vanilla_denoise = optim.Adam(vanilla_denoise_ae.parameters(), lr=1e-3)\n\n# 4. Convolutional Denoising Autoencoder (Same architecture, separate fresh weights)\nconv_denoise_ae = ConvAutoencoder().to(device)\noptimizer_conv_denoise = optim.Adam(conv_denoise_ae.parameters(), lr=1e-3)\n\nprint(\"✅ Successfully initialized 4 distinct Autoencoders and Optimizers.\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-06T13:24:51.259861Z","iopub.execute_input":"2026-04-06T13:24:51.260587Z","iopub.status.idle":"2026-04-06T13:24:51.323828Z","shell.execute_reply.started":"2026-04-06T13:24:51.260556Z","shell.execute_reply":"2026-04-06T13:24:51.323245Z"}},"outputs":[{"name":"stdout","text":"✅ Successfully initialized 4 distinct Autoencoders and Optimizers.\n","output_type":"stream"}],"execution_count":5},{"cell_type":"code","source":"EPOCHS = 5\nNOISE = 0.4 # How much static to add during denoising\n\nprint(\"--- 1. Training Vanilla Autoencoder (Standard) ---\")\ntrain_autoencoder(vanilla_ae, optimizer_vanilla, train_loader, epochs=EPOCHS, is_denoising=False)\n\nprint(\"\\n--- 2. Training Convolutional Autoencoder (Standard) ---\")\ntrain_autoencoder(conv_ae, optimizer_conv, train_loader, epochs=EPOCHS, is_denoising=False)\n\nprint(\"\\n--- 3. Training Vanilla Denoising Autoencoder ---\")\ntrain_autoencoder(vanilla_denoise_ae, optimizer_vanilla_denoise, train_loader, epochs=EPOCHS, is_denoising=True, noise_factor=NOISE)\n\nprint(\"\\n--- 4. Training Convolutional Denoising Autoencoder ---\")\ntrain_autoencoder(conv_denoise_ae, optimizer_conv_denoise, train_loader, epochs=EPOCHS, is_denoising=True, noise_factor=NOISE)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:33:06.648712Z","iopub.execute_input":"2026-04-05T11:33:06.649152Z","iopub.status.idle":"2026-04-05T11:38:29.969306Z","shell.execute_reply.started":"2026-04-05T11:33:06.649122Z","shell.execute_reply":"2026-04-05T11:38:29.968564Z"}},"outputs":[{"name":"stdout","text":"--- 1. Training Vanilla Autoencoder (Standard) ---\n\n--- Training VanillaAutoencoder | Denoising Mode: False ---\nEpoch [1/5] - MSE Loss: 0.3508\nEpoch [2/5] - MSE Loss: 0.2723\nEpoch [3/5] - MSE Loss: 0.2671\nEpoch [4/5] - MSE Loss: 0.2649\nEpoch [5/5] - MSE Loss: 0.2629\n\n--- 2. Training Convolutional Autoencoder (Standard) ---\n\n--- Training ConvAutoencoder | Denoising Mode: False ---\nEpoch [1/5] - MSE Loss: 0.1006\nEpoch [2/5] - MSE Loss: 0.0159\nEpoch [3/5] - MSE Loss: 0.0104\nEpoch [4/5] - MSE Loss: 0.0081\nEpoch [5/5] - MSE Loss: 0.0067\n\n--- 3. Training Vanilla Denoising Autoencoder ---\n\n--- Training VanillaAutoencoder | Denoising Mode: True ---\nEpoch [1/5] - MSE Loss: 0.3544\nEpoch [2/5] - MSE Loss: 0.2663\nEpoch [3/5] - MSE Loss: 0.2617\nEpoch [4/5] - MSE Loss: 0.2572\nEpoch [5/5] - MSE Loss: 0.2543\n\n--- 4. Training Convolutional Denoising Autoencoder ---\n\n--- Training ConvAutoencoder | Denoising Mode: True ---\nEpoch [1/5] - MSE Loss: 0.1231\nEpoch [2/5] - MSE Loss: 0.0483\nEpoch [3/5] - MSE Loss: 0.0437\nEpoch [4/5] - MSE Loss: 0.0422\nEpoch [5/5] - MSE Loss: 0.0413\n","output_type":"stream"}],"execution_count":26},{"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, random_split\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport copy\n\n# ==========================================\n# 1. SETUP & DATA SPLITTING\n# ==========================================\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"🚀 Using device: {device}\")\n\ntransform = transforms.Compose([\n    transforms.ToTensor(),\n    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n])\n\n# Load data\nfull_train_set = torchvision.datasets.CIFAR10(root=\"./data\", train=True, download=True, transform=transform)\ntest_set = torchvision.datasets.CIFAR10(root=\"./data\", train=False, download=True, transform=transform)\n\n# Split into Train (40k) and Val (10k) to track overfitting\ntrain_subset, val_subset = random_split(full_train_set, [40000, 10000])\n\ntrain_loader = DataLoader(train_subset, batch_size=64, shuffle=True)\nval_loader = DataLoader(val_subset, batch_size=64, shuffle=False)\ntest_loader = DataLoader(test_set, batch_size=64, shuffle=False)\n\n# ==========================================\n# 2. STANDARD CONVOLUTIONAL MODEL\n# ==========================================\nclass StandardConvAE(nn.Module):\n    def __init__(self):\n        super(StandardConvAE, self).__init__()\n        # Encoder: Compresses the image\n        self.encoder = nn.Sequential(\n            nn.Conv2d(3, 32, 3, stride=2, padding=1), \n            nn.BatchNorm2d(32),\n            nn.LeakyReLU(0.2),\n            \n            nn.Conv2d(32, 64, 3, stride=2, padding=1), \n            nn.BatchNorm2d(64),\n            nn.LeakyReLU(0.2),\n            \n            nn.Conv2d(64, 128, 3, stride=2, padding=1), \n            nn.BatchNorm2d(128),\n            nn.LeakyReLU(0.2)\n        )\n        # Decoder: Reconstructs the image\n        self.decoder = nn.Sequential(\n            nn.ConvTranspose2d(128, 64, 3, stride=2, padding=1, output_padding=1), \n            nn.BatchNorm2d(64),\n            nn.LeakyReLU(0.2),\n            \n            nn.ConvTranspose2d(64, 32, 3, stride=2, padding=1, output_padding=1), \n            nn.BatchNorm2d(32),\n            nn.LeakyReLU(0.2),\n            \n            nn.ConvTranspose2d(32, 3, 3, stride=2, padding=1, output_padding=1) \n        )\n\n    def forward(self, x):\n        return self.decoder(self.encoder(x))\n\nmodel = StandardConvAE().to(device)\ncriterion = nn.MSELoss()\n# AdamW prevents the weights from growing too large (fights overfitting)\noptimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)\n\n# ==========================================\n# 3. TRAINING LOOP (NO NOISE)\n# ==========================================\nEPOCHS = 15\ntrain_losses = []\nval_losses = []\nbest_val_loss = float('inf')\nbest_weights = None\n\nprint(\"\\n--- Training Standard Convolutional Autoencoder ---\")\nfor epoch in range(EPOCHS):\n    \n    # --- TRAINING PHASE ---\n    model.train() \n    running_train_loss = 0.0\n    for images, _ in train_loader:\n        images = images.to(device)\n        \n        optimizer.zero_grad()\n        outputs = model(images)           # Pass clean image in\n        loss = criterion(outputs, images) # Compare to clean image\n        loss.backward()\n        optimizer.step()\n        running_train_loss += loss.item()\n        \n    avg_train_loss = running_train_loss / len(train_loader)\n    train_losses.append(avg_train_loss)\n    \n    # --- VALIDATION PHASE ---\n    model.eval() \n    running_val_loss = 0.0\n    with torch.no_grad():\n        for images, _ in val_loader:\n            images = images.to(device)\n            \n            outputs = model(images)\n            loss = criterion(outputs, images)\n            running_val_loss += loss.item()\n            \n    avg_val_loss = running_val_loss / len(val_loader)\n    val_losses.append(avg_val_loss)\n    \n    # --- SAVE BEST WEIGHTS ---\n    if avg_val_loss < best_val_loss:\n        best_val_loss = avg_val_loss\n        best_weights = copy.deepcopy(model.state_dict())\n        saved_msg = \" 🏆 (New Best Saved!)\"\n    else:\n        saved_msg = \"\"\n        \n    print(f\"Epoch [{epoch+1}/{EPOCHS}] | Train Loss: {avg_train_loss:.4f} | Val Loss: {avg_val_loss:.4f}{saved_msg}\")\n\n# ==========================================\n# 4. PLOT LEARNING CURVES\n# ==========================================\nplt.figure(figsize=(8, 4))\nplt.plot(train_losses, label='Train Loss', color='blue', linewidth=2)\nplt.plot(val_losses, label='Validation Loss', color='red', linewidth=2)\nplt.title('Learning Curves (Standard ConvAE)')\nplt.xlabel('Epochs')\nplt.ylabel('MSE Loss')\nplt.legend()\nplt.grid(True)\nplt.show()\n\n# ==========================================\n# 5. FINAL TEST & VISUALIZATION\n# ==========================================\n# Load the absolute best version of the model\nmodel.load_state_dict(best_weights)\nmodel.eval()\n\n# Grab a batch of test images\ntest_images_vis, _ = next(iter(test_loader))\ntest_images_vis = test_images_vis.to(device)\n\nwith torch.no_grad():\n    reconstructed_images = model(test_images_vis)\n\ndef imshow_unnorm(img, title):\n    mean = torch.tensor([0.4914, 0.4822, 0.4465]).view(3, 1, 1).to(device)\n    std = torch.tensor([0.2023, 0.1994, 0.2010]).view(3, 1, 1).to(device)\n    img = img * std + mean     \n    img = img.clamp(0, 1).cpu().numpy()\n    plt.imshow(np.transpose(img, (1, 2, 0)))\n    plt.title(title)\n    plt.axis('off')\n\nplt.figure(figsize=(15, 6))\nnum_images = 6\n\nfor i in range(num_images):\n    # Top Row: Original Clean Image\n    plt.subplot(2, num_images, i + 1)\n    imshow_unnorm(test_images_vis[i], \"Original\")\n    \n    # Bottom Row: Reconstructed Image\n    plt.subplot(2, num_images, i + 1 + num_images)\n    imshow_unnorm(reconstructed_images[i], \"Reconstructed\")\n\nplt.tight_layout()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-04-05T11:44:20.339136Z","iopub.execute_input":"2026-04-05T11:44:20.339903Z","iopub.status.idle":"2026-04-05T11:48:02.626722Z","shell.execute_reply.started":"2026-04-05T11:44:20.339873Z","shell.execute_reply":"2026-04-05T11:48:02.625965Z"}},"outputs":[{"name":"stdout","text":"🚀 Using device: cuda\n\n--- Training Standard Convolutional Autoencoder ---\nEpoch [1/15] | Train Loss: 0.1377 | Val Loss: 0.0539 🏆 (New Best Saved!)\nEpoch [2/15] | Train Loss: 0.0538 | Val Loss: 0.0359 🏆 (New Best Saved!)\nEpoch [3/15] | Train Loss: 0.0424 | Val Loss: 0.0335 🏆 (New Best Saved!)\nEpoch [4/15] | Train Loss: 0.0368 | Val Loss: 0.0228 🏆 (New Best Saved!)\nEpoch [5/15] | Train Loss: 0.0324 | Val Loss: 0.0205 🏆 (New Best Saved!)\nEpoch [6/15] | Train Loss: 0.0289 | Val Loss: 0.0183 🏆 (New Best Saved!)\nEpoch [7/15] | Train Loss: 0.0266 | Val Loss: 0.0165 🏆 (New Best Saved!)\nEpoch [8/15] | Train Loss: 0.0257 | Val Loss: 0.0172\nEpoch [9/15] | Train Loss: 0.0241 | Val Loss: 0.0139 🏆 (New Best Saved!)\nEpoch [10/15] | Train Loss: 0.0229 | Val Loss: 0.0161\nEpoch [11/15] | Train Loss: 0.0225 | Val Loss: 0.0121 🏆 (New Best Saved!)\nEpoch [12/15] | Train Loss: 0.0219 | Val Loss: 0.0106 🏆 (New Best Saved!)\nEpoch [13/15] | Train Loss: 0.0203 | Val Loss: 0.0123\nEpoch [14/15] | Train Loss: 0.0201 | Val Loss: 0.0092 🏆 (New Best Saved!)\nEpoch [15/15] | Train Loss: 0.0203 | Val Loss: 0.0091 🏆 (New Best Saved!)\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 800x400 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1500x600 with 12 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAABdEAAAIsCAYAAAAd/uBDAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA7mtJREFUeJzs/Xm0bVld339/V7f7vU/f3L6/1dMVlIhFpxg7bJAmNkFKiWKMqAmS2DwKYoYM0YwwhlGDeaDQh9ggCmLUAEosQEGhCqqg+lt1++7c05+z+9U8fxAKyuLz3ZdTBQWn3q8xfmP8Up+z5lxrrtmteY7coCiKwgAAAAAAAAAAwCOEj/cNAAAAAAAAAADw1YpDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFD9G3k9a9/vQVBsKVr3/72t1sQBHbixInH9qa+wIkTJywIAnv729/+ZasD2I4Y28D2xfgGtifGNrB9Mb6B7YmxjVE4RP8qceedd9q/+Tf/xnbt2mXlctl27txpP/iDP2h33nnn431rAB4FxjawfTG+ge2JsQ1sX4xvYHtibOMrISiKoni8b+KJ7s///M/t+7//+21yctJe+cpX2oEDB+zEiRP21re+1ZaWluyP//iP7UUvetHIctI0tTRNrVKpfMn3kGWZDYdDK5fLW/7N2ygnTpywAwcO2M0332w33XTTl6UO4KsJYxvYvhjfwPbE2Aa2L8Y3sD0xtvGVEj/eN/BE98ADD9jLX/5yO3jwoH3oQx+ymZmZh7Kf/umftmc/+9n28pe/3O644w47ePDgFy2j3W5bvV63OI4tjrf2SqMosiiKtnQtgEdibAPbF+Mb2J4Y28D2xfgGtifGNr6S+J9zeZz9xm/8hnU6Hfu93/u9hw12M7Pp6Wl7y1veYu122970pjeZ2ef/N5ruuusu+4Ef+AGbmJiwG2+88WHZF+p2u/ZTP/VTNj09bc1m077ru77Lzp49a0EQ2Otf//qHfu6L/e837d+/3174whfaRz7yEbvhhhusUqnYwYMH7Q/+4A8eVsfy8rL97M/+rF133XXWaDSs1WrZt33bt9ntt9/+GLYU8LWFsQ1sX4xvYHtibAPbF+Mb2J4Y2/hK4i/RH2d/+Zd/afv377dnP/vZXzR/znOeY/v377e/+qu/eth/f+lLX2pHjhyxX/u1XzPvf5Hnpptusne+85328pe/3J75zGfaLbfcYt/xHd9x2fd37Ngxe8lLXmKvfOUr7RWveIW97W1vs5tuusmuv/56u+aaa8zM7MEHH7T3vOc99tKXvtQOHDhgFy9etLe85S323Oc+1+666y7buXPnZdcHbBeMbWD7YnwD2xNjG9i+GN/A9sTYxldUgcfN6upqYWbFd3/3d7s/913f9V2FmRXr6+vF6173usLMiu///u9/xM99LvucW2+9tTCz4md+5mce9nM33XRTYWbF6173uof+280331yYWXH8+PGH/tu+ffsKMys+9KEPPfTfFhYWinK5XLzmNa956L/1er0iy7KH1XH8+PGiXC4Xb3jDGx7238ysuPnmm93nBb7WMbaB7YvxDWxPjG1g+2J8A9sTYxtfafzPuTyONjY2zMys2Wy6P/e5fH19/aH/9uM//uMjy/8//+f/mJnZT/zETzzsv7/61a++7Hu8+uqrH/YbvZmZGbviiivswQcffOi/lctlC8PPdqUsy2xpackajYZdccUVdtttt112XcB2wdgGti/GN7A9MbaB7YvxDWxPjG18pXGI/jj63ED+3MBXvtjEcODAgZHlnzx50sIwfMTPHj58+LLvce/evY/4bxMTE7aysvLQ/zvPc/tv/+2/2ZEjR6xcLtv09LTNzMzYHXfcYWtra5ddF7BdMLaB7YvxDWxPjG1g+2J8A9sTYxtfaRyiP47GxsZsx44ddscdd7g/d8cdd9iuXbus1Wo99N+q1eqX+/bMzOS/Llx8wf9m1K/92q/Zf/yP/9Ge85zn2Dve8Q573/veZx/4wAfsmmuusTzPvyL3CXw1YWwD2xfjG9ieGNvA9sX4BrYnxja+0viHRR9nL3zhC+1//s//aR/5yEce+heBv9CHP/xhO3HihL3qVa/6ksvet2+f5Xlux48ftyNHjjz0348dO/ao7vlfete73mXPf/7z7a1vfevD/vvq6qpNT08/pnUBXysY28D2xfgGtifGNrB9Mb6B7Ymxja8k/hL9cfba177WqtWqvepVr7KlpaWHZcvLy/bjP/7jVqvV7LWvfe2XXPa3fMu3mJnZ7/zO7zzsv//Wb/3W1m/4i4ii6BH/mvGf/umf2tmzZx/TeoCvJYxtYPtifAPbE2Mb2L4Y38D2xNjGVxJ/if44O3LkiP3+7/++/eAP/qBdd9119spXvtIOHDhgJ06csLe+9a22uLhof/RHf2SHDh36ksu+/vrr7cUvfrG9+c1vtqWlJXvmM59pt9xyi913331mZhYEwWPyDC984QvtDW94g/3wD/+wPetZz7JPf/rT9r/+1/+ygwcPPiblA1+LGNvA9sX4BrYnxjawfTG+ge2JsY2vJA7Rvwq89KUvtSuvvNLe+MY3PjTIp6am7PnPf779wi/8gl177bVbLvsP/uAPbH5+3v7oj/7I3v3ud9sLXvAC+5M/+RO74oorrFKpPCb3/wu/8AvWbrftD//wD+1P/uRP7GlPe5r91V/9lf3cz/3cY1I+8LWKsQ1sX4xvYHtibAPbF+Mb2J4Y2/hKCYp/+X8zgG3vU5/6lD31qU+1d7zjHfaDP/iDj/ftAHiMMLaB7YvxDWxPjG1g+2J8A9sTY/uJi/9N9G2u2+0+4r+9+c1vtjAM7TnPec7jcEcAHguMbWD7YnwD2xNjG9i+GN/A9sTYxhfif85lm3vTm95kt956qz3/+c+3OI7tb/7mb+xv/uZv7Md+7Mdsz549j/ftAdgixjawfTG+ge2JsQ1sX4xvYHtibOML8T/nss194AMfsF/5lV+xu+66yzY3N23v3r328pe/3H7xF3/R4pjfoQBfqxjbwPbF+Aa2J8Y2sH0xvoHtibGNL8QhOgAAAAAAAAAAAv+b6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIBw2f8r+Df/h6fKLChy99pSoqsJwkhmg0FPZmk29OsslWSW5fp+i9z/n4gPwkxmzqNYMWzoMi1160xKuh0i5xUGoX6WLPfrHKa6jfI80BcGfpdKM31t3ynXqdHyEf0vCPTVg4HuR1nmP4vX70PT/WTg9L+2/1qsM9Dl/sY7j/sXOxYXF2WWpv5Nee27nXzVPac3VY34ly7cS51frRYjCg79i7VAj4nAyT5brDdv6Pv5cv1zII+mn3j3NDc3t6Uyb/6/zryQ+WN76dIFmfV7el06eOiwzMbHmm6dSaQX0lLiZJH/NwGlUOdx4KyVaVdmjXri1plEui/EThY5m4mVlWW3zmZTt28S6/uNvQ2MmQWhvt80H8jMafaRQmf8djodmY36B57KlYrMhgP9LOmgL7NqperW6W0QJ1sjrnX8f9/6OzJrTB91r61Gep/cauo960Zf70Pa60tunWHo7C2dRSIe0ZGqcVlmlcjpD84+2d14mrlrWpbrNvKuy73rbEQbOf0+HDW+t7huBc7cGTjv2mz0s+o6/Xstl3VfKIU6s0JnQclvv87S3TJ77re+xL1Wef43P01mpeaYe+3FZT0Ol1dWZdbf0Ov6xHzLrTOenJZZkDjjd8TaPdzQ32mnbr1TZsmYnt/2HNnh1lmNdR/Lh3odzYb6uolZf57feWBKZpEztvMR+7g40e2wvqzbduHCRZkNc/+dPeuGK2VW9PX9vu/9t7jl7t6/W2bVRI/fs6fPyyyq+nvSVl3nf/vHf+de6/nf/1nPC/csLLjXfuj2YzKr12oye8aRvTIb977fzKxo673wsNDvNGn4/T501vb19Q2ZefP8qI3nWkfPc2t9nWXePqOhx6+Z2XJb7y0vXNJjzbr++G4lej/r7WFSc86ihnqva2ZWrup3mnrnh0N/zW+U9bPMOOvLqYv6W7XtnPOZ+du8935Kr+tm/CU6AAAAAAAAAAASh+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAACC80/WP9zAOW8vCv0v9pqZWa7/pday1WUWmv7X0OPY/xde3X+YV/9j8v6/IG5m/YH+13XT3Llf5189jiL/NcTOLQW586/Opvpf1w3Nb7/ceZZBoP/13Cxy/rVkMxvk+lkHmX7QINf367aBmVWcdxoHOgtjp6OYWTZ06g30v6ZcOG1fuP9OsFk04l+x36ow9Mbal6XKrzmB/2q+qgTOnGvmToFmoX7QfET/tEL3Iyv0tUGo7yhw/gXx/1ewk+k6C394b9mj6Sdfjntq1PScHHrvy8z6bX1tPujIrFLSjVCvJm6dsdN+3rpV9hZKM6uWnLne6WP9zKtTr4VmZiXnnrw9Shzr91JK/HcWBlsbS6VSyS3Xa952R6+F3ltJRtRpzh7Qa79kxKJVSnQfTPt63xQ7g7tS9vc+X64FJC90H0yjCffaYaL331nUkFmY6P1Nu7vp1llkbZk5r8X6hb9nHYa6b/eczhs7r20w7Ll1hpHun92O/i6KnOsSrxHMbDBwxlqosyLX3y5mZqGzt/TmhjR19rMjlu4g8PadegxPTPj9ulx1+q4zb+TePqTsv5dsU9e5VUmjKrPqjN8GDWceW15dkdnkXFNm84d2unWu9rwX7sx/I+brTm9DZpnz/TfWGpPZzKx+TjOzpNB9fm1NP2ce6XttTtfcOofOXqPf1Vk29Md2ue6tPXoMDvu6beOS/yxTYy2ZdTbXdLau95VmZgvnFmVWdeapyDnTqLfG3Tq9tn80koZuo8GpU+611195QGaT43ouanrbx03/OYuqfufjdT1X5Zl/Rpg5/b5a1jccBHocpj09/5mZtbx1NtPzUduZV6NI723MzIKe3k84nyfW87/YzTsBc1ct54MzGfE31psregznmX4vY01/3q2V9RgOnA1FvaL3wfGIPVUxaqPi4C/RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAACG+3B8s8tQJ+/61mb42yCKZ5cOBzKKqf/4fWK6v1VVanmduuaUkkVla6CwfOs/pta2Zpam+p6AoZBYWuo2CqOTWWUQVmXUznV1Y0u/MzKw90Pe7uem870K3QbPivFAzKwW6L7RqNZlVy0O33DzU9xtaILPI6YC6B33WMNft9+jocgunjz2RPB7NEAS6H7k3VOg+/9mCvWK98eRcaGb9oZ7LYmfutMyZr4NH0/CPR9/128jz5RhrcaDfSWgj1rtIv5ck1NeWQ11nxSnTzCyJdPv1ux2ZRVHZLbcSV2U27HdlFpp+liLtuXUWgd5iZZl+16VE32s4ajwUzn7L+buJPPfXu41OW2ZLlxZlNjc9IbMw9MdKWNLt581So9oocbaPsTPn9jPd571+a2Y2dObGL2Er/gih874zZ99kZpY5e6Ms0H270tT3O7Vvzq0zXFuRWaOzKbNBz//OyBp6X5qPjcusWdLvzWtbM7Mw1B1p0Nf7wyzX7V6p+POY17W99cPdS4zIvedMnX7tPOb/q1RHpVjvF6pVPT+OKNYC0/Nc7qyH+ah1fUT7bkU81pJZUva/4Zqtpszqy/ra+d1TMqs1626dawM9fmPnfVroz39ZV6/PsTOX1505Yeh8V5uZRYW+p97mss6G6zLL0xm3zt6annOXLuh5Myr5fWF2rx4vsTP/9Z1v8uqM3xcqZf2+s55evXsdfx8y6Og5bn5K991KqyGz4Yi/Jz138qybb1Ua6naYGp90r53fofvSoK/3aoP1DZlt9vX+2swsKul3njl7uXzgr6OVsrfmOXuU1Pm2GTEdD51nrTlzfexMOKXI33cOYz3nXHLup90bMVcFeqwlzjisxvr8q1nzx0SzqsdpxfnW9/YSZuZuGvo95/vPed/hiDPWMNj635Pzl+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIMSX/YNZX4dR4V4b5kOZlaPUqTRwCvXP/8PIyZ3bTXP/WSzU95SUajKb339UZuuri26Vi0sdXWdcklloFZkNUv/Vd4uqzO4+eUlmRXnKLXcY1fU9NfT9bq4ty+zsxRW3zkYlkVl2QV+7d063rZnZVLMss0qs2zcodJ8vOV3ezCwrMv8HtkxXHAQjbuprSFGMGN9fS5zXko14ziLXF6d5LrNh6pd7/4MPymxuflZm+WAgs5nJCbfOSlmP7/xr7H1/OcZaKdRzRp7qdjczi0yv3Umo+0niXBdmej0zMyslel4NIv0sSeg/SxLqOTkPnPvN9d4n7fnzcTnSe4LeQNdZq+n1N3L2IGZm5u5hdNbu9dxib731kzIbdvU7nWg9Q2blsr+Pi5xHDQrd/yzz30vobQLNGS+5XruL3K+zyJy97qOQWlNmofl7mDzSbdgvIplFhX5v9ViPXzOzVs2Zr2/7uMwGi5tuuTuuvUJmwSW9t+wHek/a8DqgmW102zKrOH2sXOg2CKcabp2hM294nz39mm4DM7N4qO83Gup22Kjrebe8tubXuedqmXXGx2SWp/5clTlzZCXXbR947yXz+3WUPfZ/kzY2o/dMG6v6m8jMrNLQa09zQvex8R2TMtt0jgHMzJJQt1+1pNe0gbPnNDNLnbWpXHLep7NfXbmw4dZZ8cZS27k20OtALfLHYLOu30s+1Dc0HLFvjJzv0Tx19j7OGUyS+GtLFOr1o1rW7TC/e6db7p69+2W2Y5ceL33n4/r0iTNunZ2uf8awVUNnTzA7N+9eW3H2TonTz/KOM3cG/jisVvVYKwq9DsQj1tFqRc+tmdM/S7HuY6WqP9Y2N/R+Isv0vJE489jGut9PmqEuN3DOWNc3/fUucI5yE9PvNHC+j2Pz17vxmt431cvO+3T20GZmqXPGtbq+rq8b6uvGGy23znDEebJ77ZavBAAAAAAAAABgm+MQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAIb78Hw10Eo/7Vwb62rTIZRaGqcwG6cCtsxSVZZZlmcyKXGdmZuY8SynRv5O44QXfLLPb/vGjbpXnVhdl1k4TmaVZXWYnzyy4dR4/e0Zm5fEdMts9d8Attyg3ZTaI9TtLGjMyS3ubbp1LC+dkVhuflNmZzQtuub1c9925pn4vtSSSWTbsuHWGhRs/CrrgovAr9cb3drLV5xzVflun7yeKdf8zM8uc3592N/syW11ru+VeXFyWWbWp56Oppp4XwsD/XW/gPEsQ6DH6qDhd4attNJRifUfFiD6deBNOpvtJZHrtDpzrzMwS0/PjMO3p28n9Z4laJX1PxVBfmOu9Rp6O6F+ZXtM211dl1qhVZBaOmE/SgW7fONFbvtWOv/Ysr+u8GusxONBdwQZDv/3ikrcu6Wvz3HmfZjZ09o9Dp/1KsW6/wtkPmJllo/aWW+bszQun8c0sdPp9luq+a5FXp7/29AI91ye5XiOC6Vm33M6G806P3yezNKjKLNfD0MzM2onzTp3+UBrqth2c1vOfmZk5YyYwnfUa/sNEPX1t7Hxu9ef1++5e0PsBM7NmoPf1wdi0zLIRY23orFtJqO83d+aUKPTHb/xl2JyXY90XAiczM5ud3ymz9b7+pgycNaK35q/dpdD5hsv1GpGPWNOGA90Bvbeyvrgis0pdzzVmZr2KLnl8alxmzaaeTzYKvw91vP1NTbdt4C2yZtZd02t3qeTsnxP9XmqNmltnOdTt0JrV11711Kvccs3p90VV328Y6eesV/016/pnPdm/p61y12f/nlbWNvSVJd1GA6cLVqv+GtGoOW3vnCFEme4LZmZFrtuhUdfXep8v6VCPJTOzUtWZ5zrOgue8s9kxvbcxM0uGev7ct0ufqy32L7nlDobOS/U+i5x5d2N1za0zL+v2LbdaMoucbwUzs9CJy4keE94SMqJKc6aGkfhLdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQ4sv9wX7Yktlap+Zem6V9mU00Upm1okxmcVG4debpQGaBc2mR6/sxMwsj/XuHTmdZZv/3f/+FzC6u6vYxM7u4Gcns5Fld58nzp2QWVRpunVmk33e9NSOzpOaXG1eqMisHum0rYV1mi4OuW+eO3Xtl1uu2Zfbg8QtuuctrPZlFgW6H/TNNmSVZ7tYZZH7/3KowDGRW5Dp7vBTeLflTgysIdMFOE7ky8y/Mc33DkTPfDAZDmV1aW3frXG/rvtvt63m33fHnqrCs14J2V8/JjZpug3TE+yw5mfM6v2wCZx57PJQD/T6zwJ9PklDPR8O+7kOh6XKLXF9nZhYGelsSh7rcOPJfdmR6vBSZ16+dvpnrMs3MMqfOzQ09Rk95bRv7/aso9Dvb09Ljc+nSJbfc2++4Q2ZPuuYameXOe+lnek4wM6sUiS4319d2O365pVi3UTrsyCyKdfsNU38sDfq6XLMx91pPlunxnY/YTxTe39E469KgcOaU2B8TYxvOOJyZk1l1dp9bblqs6bCk55Riel5m3cRffOILSzqM9L697eyDi7kpt84k1++sl+v3Um/qPbSZ2WBD98++M4bjql6BI2efYWYWT83KLEh0382Ksltu01kKInPGfqDnmyDU2edKfqxtrOk+HeT+2D596qTM6oluv86SXpeyYcWts+y00ebqqszCmreLM8tSPWdEziYvKev7mdo77tZZH9d5vel854Z6fGZDfz4Zbup9SOB89Gws6HMAM7O1S4syu+YZV8psen5CFzpiX15OdF8Zb+m5qD6pzx7MzLqZ7gtDZ2xPNMZ1tsefTzY2N918q0pVvQ70B/5+9uLFDZntnJuUWbmq34u3lzAz9517+2/vu9rMzLy51dlrBN6+fUSdpZJuh67zrbre02dGE7P+2j2V63muaOk+mAZ+/1y8pNeJPVP6nkqJbvelSytunUmgnyUd6jGajzgPKZx9U7Wi31mlrMeSd8ZiZlaKR63t2lfX1z4AAAAAAAAAAF9FOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAACG+3B+81I1ktjwcd6+95R//XmZXH6nL7PnXTMtsIircOvMsk1kY6WcJw8QtNyuGMgucX0kcP3lcZsvdsltnUZuQWdRoyCyc2JBZdXzMrXPQ6+ksyGXWmtDv08ys1dD5woULMltfWZZZs+R340q1KrNTK4syKzXn3HIXLpyUWeOibvv5Vk1m1cB/ljTX/e/RaHe6Osz9sRY746lwro1ifV0U+7/fCwKdFU4W5k44Quj9ztG5oc2+HktmZkWh26ga6/7QG6YyO7+07ta5sKLz3PSzDFO/L3Q2NnWdi3oMnzl7XmZXHzno1nlo326ZRabXAa/dP/sD3vv2L93qZeFWC3ZEqe5/+bDjXhumA5l115w+1tflFqE/h0VV3edLzvxXcuYTM7Mgbcssc+7XMl1uEPvvqwh0+7XbazK7eFHfT72l13wzsyLU/bZw5pPBpt8XKonep1xaXZXZbZ+5Q2b1sv/ODh/UYz82PX77Hb3+mplVY31t3tdrYZbqvU/mbx3Net6cvGPExQ6nC2a5nv/MzHJvbXemv8zZXyeBX2f52P0y6936YZmlz+i75Vqo+2dR6D1XaUPPKT3zx0Tj/KrMorK+n7yu2ygoSm6d2VDfb3NqXGbJ2SW3XNvUa3cy19TXndblxiPmqt4lPTdENX1tfvRqv9ySHoyh8/1S0lsqi0fsfQpd7JZttHX/G4Z+hcc/pdt2176dMmvV9TfaRF2PIzOzwhmiq6u6f1nq9/m8r19M3fmmPPDkfTKbOTzl1hlFegIMnI/9iydXZXbq7jNunZNN/a1/7bVPktnH7zzhlru6qNu+3tRnAaFzztLv+/N8bVzPGZWyHtv1esUtt1roa4NM3+/0+IzMPn3nbW6d99x1r5tvVX1M98Hzx/X5gpnZINd9sFLR4zQb6j1pMWJ8m/P9nDrlVmv++E5DnZec+Tp31qxSacSzON8LhdO1Bx29j1sb+HuUsnO+M1nR7/P6ffos1MxspanHTDHUY6Jw9sGdkj++B0Nn/XHOQ9pt/R1m5p/PVmt6rveu886azMzi6NGcCwEAAAAAAAAAgC+KQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAIT4sn9w7IDMOkv+WfywNCOz5Xakyx1UZNYqDdw68yL1QhlFUc0ttzeoyuxSX1+3uKHvpza+w61zYmavzNr5usymTd9rVNGZmdkg0e3ba2/obFPfj5nZvrkpmXVKujsuDLoyC5KyW+fackeHeabvp912y41Kuq9cXF+R2fk1/Sz7pvV4MDMLczfestWu7ryNWt29NowTmWW57ve5N20EbpXmtZJ3aRj67esq9LwROLVeOH/WLXZyclJm1UpJZv2e7te1sr7OzGx+ZlpmhfMs7U7PLbde0vUOerrfR07H3uw7E6uZpaG+38BZ4gpnHfjsxU65Tt8d0XVd+ZdhfFcCp986fdrMLEz1OlAu9NzZyHUrjLmj1yxc0/Nu2ZmvKyNeZ9jR/S90xlIpdNaXzH/bg3Xdfs26LnfCmROOn7ng1vngaZ3fd+zvZLayuOqWu9nTz9IZ3imzyPR1w/aaW+d1VxyV2Xd9x7fKbJezzzAz61d0P+o56/6grdu2Veh9rplZ0NX7JrMr3Gs9SaTX33DEWMszPeHkoR5QsfP3N40Vf9+Unjkns5azl9s45/f7QWVMZoXpb4ngwoLM6jv9vc+gpduoML1WVjf1mlZa9fqJWc+GMksXz+tynfFrZpau67FYXm7JbNjVc2BRPejWuXr8tMxK1YbMmjv2ueVGFf3eilCP/b4zXtJAX2dmNvgyLN5tZ880cPbWZmZ95xu4sVPv/6q5HoPZwN+LhYFuv0bV+XZeXnbL7TnfJ4eu2y+zA0/dJbN+4Y8Hb4+3cW5VZvf+42dk1l7ddOusX+l8S5lug9bsnFtu2XmWcqj37ENn69Pc5Z8hLPT1O202mjKrV/0zmDh3vm1SPQazoW6EB+7V85CZ2cVjeo14NPpDPaecPHXKvXbfvv263K5ee0Jnngqdbx4zs6LQ11Zruj/EZX8fUgz0Olr2vsMip++O+BJLU9329ZLu+P1c98/cmf/MzIpIl5s4e6oo9ef6qKbb4fhZZ0/Q0O8s0FORmZn1nG+myLl4o+Ocx5lZuazbqFTS+7jc+ZZNEv+oOxvxHefhL9EBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQIgv9weveNINMjvzsXvdaxtjszK74Vm63Fp0UmaD9oZbZxgnMguSqsyyYsIttzm7R2afuuOYzBrjUzLbte8at84iLMssSQYyy/tLMhsMcrdOr/2iQHebO2+/wy23Vdbl1up1mdVrDZmdu3DRrTPNC5lFiW7byabuJ2Zmq9lQZivLOjt+YU1mO+d2uHXGJf2+H424pftnFvq/axsGkQ6TTGeBzrLMuc7MQtP9N9Cv23JzwlEC536cJkoHfb/YwnnWPJXReFOPl+FwxHNGzjhsNGXW7vTcYoNIj6cg0g1Yrjrzdeg0vJmlgW58r2lH/QrZr1a3r34StwuNLHerTp84IbPh0J9PNtb1OpsNdb8+e/aszFacNcDMrL25LrPZqUmZNeoVt9wo1p1hMNTjLC7pdSCMS26d7V5HZj2vgxV6jT11btGt8/iZZX0/A32/FWefZmYW1PWcq1dns3pJD7TzJ+9z6zx3Tq/tH/7wP8jsqiMH3XJnxlsy626uyqy9rvdUw6uucOvcXFuR2Y3XPMe91lMu6X5fOPO8mZnlztqU6/4ZOtlm4k+sm09/ssxa8fUy62z4e/5hpOfOoOx86gz0vJBU/Tmlnen5Mwx0Gw0z3UZJ6OynzKzrjCfvyu6IPVVnU7dv3WmHnnM/5YY3M5hNNvX3VuZ8g2w6+wUzM0t0X6gO9f2mzjtzuryZmQ2Lx37trjVqMttc9NeB+V27Zbb/kJ4fJ6r6nZx64Lhb57kH9Tf71IzeV5bM31cOdozJbM+V+pspdOaisOePsyDVL/yBT5yRWXupLbOjT/bXpau+7mqZnT91WmZjZb9zXvkMvTaFLT2Wqs65RVLz5/neYFVmF5d1vw7M31NFzr4pc+bOjY2uzC5d8sdS4ZwhPBqnTp+X2fysfxbg9d72pt53NpwxkTvfm2ZmifMNlzrXRiOOGiPT1/Y39LMkud6T5iW/zs5A94dsoM9vBpmuczDiOTeGep4bqzjf5P5UZc2q/kaZnNbfTPUpPa92Qr3XNTNb7uj9bJY65xYT+n7MzMoVfYZQOGts7Iz9L8PS/BD+Eh0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQ4sv9wdrYlMz2HTzqXtsd6mzvgcMymx4WMls9fsKtc1ikMsvSusxueM73uOXuPfh0mR24Tt/TrZ+8XWYTjXm3znMLizKLi5LMykmiC9VNa2Zmm+22zFZXlmU2WXfqHFFtlut0emZGZv2hftdmZosrazILIv17pGZD9xMzszjSw2fQ0+33wKkzMpsZr7p1HtndcvOtetsfvENmgfNezMySWL/zRrMis8MH9srsGU+62q0zdn79591vUfjPUoSBU7CO0jyX2cTkpFtnqVzW9+NUWirpsT81MebWWVgks9gptxSPWDIS/b57qR6nq+t6TlldW3er3Fhbldmw09UXBn5fmJoal9mRwwdllpR0G43ofhZETifbog//48d0fYHuB2ZmeZ7JrNvVc9yJC+dk5g0xM39sT4zp+a9e0f3WzKzs1JvEznhwxmcY6/5uZtbpDXS5zrMUka7zwvKmW+cw1w1Ya447V/rr6GCzI7PQmad6zlrYavrr2TOvv05m7TU9Z/R6PbfcU6dWZPbAAw/IrJvqAXxyyZlrzKzb0e1w4/e4l7rqdb1nSEeMiWHmzY967HvrXVDy9zDVOb02rbd1H7u05vf7INJjeNDRHyGlwNnHrer7MTNLC90O5ZLeF607e5RKMmKNDXXuzdf9Tt8vN9ftt9bVc8PAKbYW6/YxM2vu3iOzyLs09BfSwPv7MG/v6H2hjFi8c6cvbFV1simzkvNdY2YWOg/aqOh5t9qqyezgVVe4dZ4/dUFnF/V37I6GP2c81fke2DO/U2aFsxamoXMwYWb333lMZpdOX5LZ3EH9rXrV113r1tmc0m3f7eo1rdXU+wUzs/Kc/gYJE71GDJ09wcVjug3MzPYcnZNZN9XrTjxibFvo3G+u9yGLl/SedGVR900zs2qo38ujUQR6jYhCfz+2uabH/6yztyzFzkY48sdE4uwJNjb1+pyOmDsbiV57ai19DjN09mMbmX8W1S/puSHP9b692tJjKRv472zd6WfDNT2+51p6HTAzizL9ThPnmzyp6H5dafnP0j2j999V50woGbEn9T4Qc2ff5J3lDfv6fZqZRc7ecRT+Eh0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAAhPhyfzAqN2R27uLd7rVPuf4ZMquP1XSdG2dllqWFW2dc0o/24Ol1md04ccAt12q7ZNSsd2RWiXX7VUu6DczMKqWyDvNMRrt27pDZXQ884NZZKlVktr6h2+/A7qNuuUevvFpmy8srMmu0xmV27sKCW2cQRjIbn5iU2dq6vh8zsyjSv4Oq1iZk1i3rfnL/6Q23zmrpy/N7r26nJ7NBV2dmZkmsx9rGmr6u5lyXXXWlW2evGMgszHOZlUeMtcKZVjInK4JAZmOTM26dob7UzOm7A2fsR6WSW6cFuh/p1jPLzZ93T5x8UGZnF/Q4XV5aklm323XrzPqpzAZd3U/6fT0Ozcx275mT2d49u2VWd9YeG9F+gXmdYWs+db9+J7Vq0722KHTb9lPdfmMTUzIrO2uLmdmg15bZpU09F0XOGDQza1bqMkuzocyCRI+VKPKfJYh1neV2IrPBUK+xy8vLbp1eH/OaaJD13VI32nocDrr62j0zeo2dmph362y39QKyvHJJlzvuv5enP/kamZ05r/eda109H99zRs9hZmahM5c/GrHTP6tNf73b7GzqcmNdbhbqPhYH3gpiFjprd246CyI9F5mZxU77ei0/HOh5rJroMfrZOvVcn8S61sS51yz1n3PQ02MtdVbvpOrPj3mm85LTx5LcyVK/zw8KXWfgPEvF24yZmWVOGzrNkDvhqJ33l2PtrsS6/yW5X1861O2XZzoLnA1pte7Pq4evuUJmn/jQx2R299kzbrlPuvFamfUT3ReSNf2cU4X/LBs2LrNrjx6R2fQRvaYldedb3szaHb33mdmn76c05j9LV29vbLKqx+gDn7ogs9OnLrp13njldTLLQ72Py0cM7SLUZynDTO8X8qGe5/NMf0uZmeWBn2/V4tKqzBbO6H27mdmTr9ZjreLssdOB3sfVyv56582r42POt0Tg9/tSqNe0vvMN4gxvWzK99zYzi2r6fqt1PdtPzuvvwmTD3wN2BrrfbyzqfX3S8/tft9ADPHX2KKvr+n5WNv3vgUtreq7aPa7PH7w9p5lZ5pzfJLEu1+tipcQ/6g5HfDu61275SgAAAAAAAAAAtjkO0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEOLL/cGk0pJZrzdwr+33h7rcUk1mtbqus17R15mZlaNUZo24L7O3/95b3XK/81//pMyS9gWZlcr69xVhqO/VzOzAwV0yW1g+J7PeZltm87PTbp3L6x2Z9Qf6fR88fNgt99DhozJb++RtMmtvbMpsva3v1cwszXKZdbs9mY2Pj7nlZsWGzMbGE30/A/2+o1Dfj5nZmfMLbr5VL/ve75VZv+PfU71akVngXFct6ekn0K/MzMzW19dllqfOfBN33XJj51mKOJJZd6jHRJH702wY6rkhiXU/ip37SRL/96NBWMisCPRbGxb6OjOzXq7bvt5qyGxifFxm2UCXaWZWiaoyW11ak9mZsyfccg8f0HNZFOp3mjltFDlta2Y2onm3ZD3Vhea530/qNf3OqpEeK7v3HJLZcMT7vHRBr6OLS0sym5ubdcstT++WWXtVl5uHejIam5jz6yxPyKznNEMn1fNbxdkXmZllQ71WRkEms1JUdstNSnq+GVZ0dsPTrpHZ0X073Tp7A72HOf6A7n8P3HuXW+7XP+M6me3Zo+/p1B0nZTbM/MGbZ/4+b6tKznspOe/FzCwv9DuvJjpLnX60se5/D2SRvqfK2KTM5upNt1wr9DgNTL+bwNmlRCP+zigKdF6KL/vz6ktSOPvZ1HSWRX7/LJz2C52sZE4fc9rHzKzvfPt4l8a5v0HMTPfPwFmDA2evFvlLt0XRY/83aXOR/s493vH3slmq23bY12M0S3XbhWV/Ptl9dL/Mzp/Qc+f5Rf99lnfqPd6Ss1bOrulnaWb+991EVe99Dj//BTKb3KnnsLWu3o+amW0GyzLrZ/p9l87p5zQzy9u6fTer+vs5CfT7PvLUK906K9N6vl5aWpFZZ+j3sYaz3nnnPt5SGI7Yl7c39bf+o/H+D35IZrsm6+61Y03dvosL+pyg4zzL3j3+HrpVc76PneUlH/ENvLyu7zfVn8AWT+u92p6dT3Hr7Kzpc8BzDxzX99PWG/dmzX9n5bqex9Y3dNvmVX/v0yv02pMN9f0uL+j56DP3P+jXmTrnBLmz3wpHLKTOWEwLPc+lQ+dcrfDrDEcdOHnXbvlKAAAAAAAAAAC2OQ7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQ4sv9wSBKZNbZbLvX9jpdmSVJWWYbS5kuNKq6dSa2JrMd45HM7r/7frfcc2eO6bBzTkYnz5yQ2VPnb3Dr3LVvXmY7F+Zk1j52UmaT5XG3zub4tMweePC4zHbs3OWWu7q+LrNhlsvs4qUlmeVF4NYZRLqbd7o9fV3o9D8z82qtN+o6zCdlVAr0WDEzGyxdcPOtyoeFzKIRv2vTo8msUdLtUK3osd/t6X5iZtYZ6ndz4sETMiuV/Hlj74F9Mjt+Wo/v//1//k5mw1DPnWZmlXJJZjWnjerViszGWi23zvGxpsye+tQnyWxmesIt99BuPf7DQPeUKNB9bNDru3XGoR7f3Vk91nbuGHfL3blrh8yyTPe/Tmcos3rV739OM2xZUm7IbHZ2p3ttpaRvaHHxjMza7Q1daO7P171hKrOxGb0W7jpw2C23Oab7bmt6VmZLyysyy3J/C+VMU9bt6n1Tp7Mps8HQXyPMdP8rlfT9VsrOmmVmSTGQ2awz38xM6KyS+B1+ZkLvb1olPa8unTrllnvygRMym5/Ue5+1ix+TWTI549Y5cPYhj0bs7FOiQPcFM7OKs69fXdD9fnnzvMwundfzgpnZRHNKZtdefZ3Mkope78zMvFVimOk5Jcy3vvcJQz2XhaG+NnCmwELfjpmZZYHeJ4feXth5zv93V7pcbw/jPExR6Hs1M4ude/L2C+79mFkS6T1V4i0/ThOFkbfTNcucvrBVmyt6HW2P+O52ms/WVvT+unD2NrN79PprZhY6e9Jrv/7JMruud8gtN4r0PNZd1N/6cyW9f65lI97Xil6DLzyozwGiSO+BW2HNrTLKdPv1h3oslVb8PXIp1vUuntPz/OGG/k7om25bM7Pehv62jmM9ftfb+lvfzKxf6L4wP66fM3faL3b2RWZmO+f9tX2rPnNSP+vuPXvdayecb7go1/2hfuiAzFot/a1gZraxrvtK3/lOy3J/HVjs6cmqWtH3ND6u56NGw/8G7iydkFkc6b77yds+JbOlxUtunft3671PP9P7hXjE3rFV1220saTf2UpXL3i5+d+quTMOL2zotWm84j9L1dtyFc61zsKepX7/855lFP4SHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABDiy/7JvJBRVOTupTump2RWq5Rl9sE7HpDZROrXeWQykVmlnMqsFPfcci8tnJBZ3l+R2d5DB2QWOW1gZlZrTchsem63zJaWN2W2tt5x68wync3OzMosTvxn6Q102w+GOuv2+jJLvZsdkff6A31d6v+OaWpat0MQ6P5XCnQfKwe6DczMsqLm5lv1nr98v8zy4dC9NjTdho2Svt9mqyWz/Ud0vzYzm5lqyGxqx16ZTU7PuOVW6lWZrd59Umafvvu0zLqFnjvNzOLIyUxf26pXZHZ47z63zq+/4Wkym6o3ZVaP/CWjCHQ2cMZ+munx3VlbdescZrp/Vmu6jcbH6265Fy9clNni4rKu0+lDc/N6zjAzq9X0/Dnd0u/FMzE+LbNoxPvs9/VcFTi/g19eWpXZ+rpel8zMImcNiXI9WE6e1e/LzKy13pXZ2Ni4rjPSfajf03OfmVngzOflxGn7up43q4W/xoaxMwidvVq96q8tSaHH2e4pPZZqJf3O2uurbp1pR/eVwJlWDxw47JZ79z0Pyuzo0Sv0hZl+n+fOnXXrrExMuvlWBYF+33HkLC5mlod6DG9sbMjs0qULMltd8dvhvjv+WWb33P5RmR0+fLVb7v7DV8lsYnpOXxjq9styfz9mhW4/ZxRa5LT7KHHs1BnoLM/9b6bc3Ufrp4mc+ynM73/e1qgYsW9yy830talTrldjEPj7YO/bZqsCZz+wY/e8e23PWbsz51tr4HxrrVy45NY5u3+PzCam9PxXXx6xDzl9Tma7Svo7YhjqNX8w4n3u3OmUO9RjaXh6QWaXhn6fzp35ulnX3zz16phbblwqySwMddYq67G9uLTm1jk4ofNiUu+pas69mplFVWfuTPR3d985w9p/5UG3zoN7/e/RrZpzzsbK1RHfJ4u6fRNn8WmM677SH/hjooj0fJRU9Xtb2dBjwsysX+jxPz+9U2alWH9rrZ095dY5WD4vs/GqHodXHj4ks9tHtN/UDt2PvPWuP9BzsplZ0tB79+6lRZmtd3W5g9Sfq9z1ztnf1FJ/nSw73y9h6Izvod6/DFP/Oy2KL/8o/BH3tOUrAQAAAAAAAADY5jhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABAiC/3B5M4ktlYo+peO97UeZCnMlsv6jJbXAncOqeb+n7rpZLMsnDVLffEuRMym5sYk9m+w1fLrDd0q7R/vvVumZ09vyKzZmNCZklSceu889gpJ9W/e8lH/F6mP9Dve7Pdldn45KTM0sLvC+cvLsis3tTvLI4Kt9xarSazUqmsLxwuyShrr7p1zs023XyrPv7Jz8ismujxYmY26K/LLCnp/vB1z3yGzE6ePe3WuXReZ9dec43MSlV/rur0BzJLKvqdPu1pT5JZr9t36ywleho+cvCAzK656gqZ7Zwed+ts1XQ75D3dBqcvXHLLXVjR89H5RX1te7Mts9XVVbfOwVC3b1LSbVsq+3NglurxPxzqeaw2rsfotab7ppnZ2Ji+9uD8jHutEiW633a6+l2bmUWBboMo1u2XZXrcx3HDrTMv9LWlsm6f6ekdbrkNZ59SqepnGXP6STxibiwCvTYVmW7bNNWbgrGW335hqMvNM/2+48LvC3l/U99T2XnOVI/PLPPnxkGq93FdZ56qOeu6mdnJC3oNvuuB98us39d7lGFPzwlmZkWkn+XLJYr9/Vilovv2lVdcKbPDV+2SWWfjglvnnbfdJrNPfuJjMvvwh0665d59l97DHL3qKTI7csVVMhufGHfrLJX0O40i7/PK27Nmbp3+3z7lMhnmfrm5M+e412X6WbIRe/Pc9FzlX7l1QaHrLAL9PsPQ/1xOc/97YSsq4/obuLTorz3Vlh7bpVg/S+z025Vz/tie3TEvsyzSbzRd99eB4UpHZgvOmubt2VsNf/9XSXRWa7Zk1uvodaDf6bl1Fpkeo5ubGzqL/XKj2HmYyPmOndJnCHvG9De5mVme6/dy7N4zMpuYm3XL7Sd6jG46+9nIOe6qlp32MbPBiL3RVj3nSXqNbTrnC2Zmt37qXpldfXSvzOYGzhox9NeIntO+ZefbutLwzy3mnfE0OTkts+FQr1nr57wzLLOsvSazsSndB6fn9uhs55xbZ3NMt9H6uj5HKTlnlmZmSxf1t3UQ6f1CUnbKDf0VuN7Q/TMMdD+KE39P2nDm5W5Plztw9jdZ6u/NE2dPMAp/iQ4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAQny5PxgFgczmZ+dHVKLP6vNeX2Y7dh+Q2SfOnXDrXA1mZFZEbZmNTWduuWOtRGZJpSmz/Yevlll9bMqt8+1v+//JrOO033p3WV/X1W1gZpY4PWN+QrdBb/mkW267rNt3rFWX2T333i+zixcvuXWub2zKbHxcP2ir3nDLjYqhzJKBbt+oc05mM/WBW+dYRY/DR+PSGf3eJicm3Gt3756V2dVPOiKzpKyf5c5P/bNb51ylIrNGoPvYwuJ5t9x6a0xmUy1d53d963NkFgb+7yrHxnSd01OTMlte1uP7+Ek9XszM1lbXZba+tiGzjfWOW+5qW/f75fU1maVDZywler4xMyuVdR5Guu3HWv5YGh8fl9nErJ7ry7WazEpVnZmZbXZ7br4VUzN6fc6HuXtto6rbNs+6MktCPVZmZ3e6dQaxrrNUqeqsrOs0M6tU9FwfxbqfFM7eJ4hGzMfOtZEzL3Taes0KC/+dlZ3FuwgLXefaklvu2RN6TllO9HOOV/X9zE2Nu3VWKnq89AapzIq47JYb11oyu3RGr897duh9ZXPgv5f1vr7fRyPPdb1h6G/xi9C71um7kR6j41N73DpvfJ7eLxw+rPf8H7nl791yjx8/K7P2J5198vqqzK570pPdOvfs0c8aO3NDluo9Sua8TzOzPHf6venxbYWTmVkQ6NyZxiwI9TwWjPg7rdy5pdAptxjxLG4bOtcW3reqX6VlxWO/N2+39X4rHeg9k5lZGjmZ04eyTD9oXNPrr5lZZ13vHStj+nsqbun9lJnZs573XJn90223yewfPqGz644edeucm9D3tLGk1+excb2f3z23w62z66z7S6t6v9/r+t+NFul3enHpgsxqzZLM9h2+wq0y6Ok+dsAZnyeWF9xy45beP7Z7uh1O3P+AzI7fd7db5879N7r5Vh2Y1PuQ8wuL7rVdZ/+Tm35vYagnhlLi75s6pvf8S8srMmtMjrvl1hv67Ccp6X19OdbPObF3t1vn0kXdDklN309c1dfFI86Mhqnun2NNfa23FpqZtSu6HXbs2iWzta5eQyoj5vrc6X+Dnv6OrTrnHWZmu3bp97bmnD+cOnfRLdcT2NbXbv4SHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAACE+HJ/sFQqy6w1Me9em2a6mnKsyz16YK/MPnFr061zPTksszzYkNncrsQt9667PyqzZz33h2X20X/8mMza7XW3zuFgUWYLF047V+rfkWwO/d+fxDaU2US4IrNdVf9Z1i7dL7M0mpDZ3KzOsix16+x2ezLrdTsyaye6b5qZpfmmzIa9szKbTXSdOxt1t85+qq99NM7de6fM1lsN99rv/Ff/Tmbf+q3fJLO//eD7ZTY77o/v2Zpup2ocyKwS5G65c2MtmTWdrFKryCy1wq2zVHauTfX9Xrik+9iphYtunYOhvqe4otu22Zx0y52t1GQ2HOg5xZOU/Dk5ivRc5mXNpt/HWi2dR5HuY5ttPUYvXtRzuZlZr+eM76c/2b1WqdV0vx32Bu611brum+OtWZnlqdO/SiW/zoZu9yKIZBZG/nYmL5xrvb8ncKJixJ8hFKbHb5p2dZbpfrC+5PchrxWSUL+XzbVLbrnnz52T2dyk7mPj9WmZdQb+fJzHuoFT50mLzJ9zd+3eI7MrjhyU2VOu1tl9D3p7MbNPfvpuN9+qIHT6deCPiTDuyyyJdBtmzjgMLPPrTPR8fuTok2SWp/5gO3/+z2S2sqj77v39NZldPHuvW+ehI1fK7Kpr9LPMzu2QWRz782M61Pkw1XvhrPDfize3BqFe7/xC/fEd2NbKLUZd544Jp9zcmTcCv/+Fob9P2YpBV68R9Zq/Lx8633B5Rb+XqrPfr9Vn3Dq9b7E80/3v7NqSW+6Rmt4T3HDd02R26213yazT978bq9UxmVVKTv9yOti5c/6+vFzWfWjf/v0yK3J/PCSJvt89m22ZnXfu99jdum3NzI5e81SZHZq8RmbL/+TvQ5ZX9N5oaPo5F9dXZTY2ofcoZmYHDx1y861qBHq+2dH0x/fFNb12dzrOmUdPX5dl/nydDvUYXl7R62g04gxhypnLKpWqzDaW9VlUKfLPb6JQlzvo6rmhPK7n1aKn293MrHC+gbNC94XE2TOZmc1O6O/yPNfr1kZbn2F1enrtMTO7sLgqs2pJz0e1xk633EpFf3O2xvU4PbOo+4LXN83Mppv+nsvDX6IDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAQny5P1hv1GU2MT3tXpsGuppeWJJZpdGS2fj4mFvnqdMXZHbjM67R97OZu+XWmpdkdv7sGZkdu+8+maXZwK0zjHTWXl+TWXNqh8zW1jpunWONisyuOHqtzD5++z1uubfdc1xmNz7v22WWlGoye/DYMbfO1Y22zHLTjdvrbrrl7ptryqxar8psclJfV8SpW2c6KNx8q7pd3UbXPuU699pv/KZvlNnU+JTMvuHrniOzMPSfs5mUZdZy5qqopPu1mVlc0u+tCPQ95abH8NrqkltnK9LP4vXPg1focTi7+6hb5/LKusya4+MyG2b+ewkK/XvZxJnI8lzPu71e161zs637bpFn+rqOP75Pnz+v76mr589hpyezLNP3Y2ZWq+u+sFXtrr6fZlXPRWZmUaTX7oVLul+vr63KLM/9390fPnqFzMYn9V4jSpyF0swCZyylme5/g0FfZp2B7ntmZr2+7ifpQI/BIBvKrOjr+zEzq5cSmY2PT8qsWppxy42d+W+8odfnsabOBiOepeP0lUFft1EY+OvoxJjeW9bKus4zp0/KLBqxNF9zxRH/B7YoDAKZRU722VzfdMm5NPc2pbnfEF46GOj3tnvPfrfc/ft1/vGLei5PU31HlxZW3TovLZ6T2d133yGzAwcOy+zQIb+fzM3tklmz6XwXBXpeMDPrDfTalDn7zqSkv+GKwu8LudMbvEuLwP9O8+mCg0J3en8kmUUjf+JLFzn3Wms03GtbUzrv53reLZX0/Ld4Ro8jM7P6tF5f1s/payvOmmVm9rG79HflNzz5GTJ70fe+SGZnTp5w68wGen2pNJ19k9MNmg3/yCXLdZ3nzugzjZLz3WJmlqe63Liq235ut94TrC35e5/FC855yJre++yY3++We+bCCZkVDT0X7btin8yO3/WgW+eFM4tuvlWJs1ZOVP1vgUp1XGaTLZ0VzhyXlPw6x8Z1Xzl5QY/vNecbzczsipbej911x6dltnh+QWbXHLnSrTNMdJ2bK/p9L9x3p8yC2G+/Rm1cZm2njUZ9N244++j7z+k2On5S72fPL+kxambWHep7CgvnTMP51jczd4NYdvpna0p/G55e8Mdvqe2fh3r4S3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEOLL/cE87chsbLLhXtvuZjLrZIXMokif8e/ds9ut874775fZWieXWaO+1y13zyGdnbzvpMzOnj0vs69/1jPcOjudTZk1d+6S2eTOAzI7tXyPW2e3r9uoVJ+UWWtmj1vuU5v6vV26tCSzEydvl1m7O3DrXF3T7TczMyuzseKcW+6+xrTMZlu67yaBHkuDoc7MzOpB4OZbdfDKp8js+17+b91rO1kis3uPXZRZHujrKi1/ThkWuh2WV/V8Y7nfvlnWlVngzJa59WW2sb7h1hldHMrs3MKCzPp9fV3eS90667W6zB68/4zMjp865ZYbxPqdTk5PyWzQ1+23trbm1rm0uCizItN9IQz1HGdmFjh5vVqV2XhFt22lUnbr7G7q/rdV5US/k6VF3b/MzB5Y0W2bZfqdjU9MyGzHjjm3zkGq+/Vw0JNZXjjj3szWO22Zdbt6XshS/ZxRqPcvZmalRK8D9ZIz/9V1/6om/rat5+wXcnP6dMOfcyNn7SlFkb7O2cclThuYmfVSPY8FTp2B85xmZsOh3jOcWVqRWaet56I49sf2/A5/z7pVUaCf1cvMzMxpXwv0OLRC9/tiRNu7nHIrlYp7abPZklkQOvsmp18Xzv2YmQWFbr+NFT23fnLxgszuvP3jbp2TU3punZ/X++/5HfvdciuVMZlNTe2Q2czcvMwCPUTNzCwvdF9Jcz2fp851ZmZZ7uReV8j1XFVkfp2FV+cW1Zx9Rpr53wITk/r7JHT2jj1njV04q/eGZmYTznBJh3ofXN2hv8PMzJYT3Rf+8fZPyuw7vvFfyazo+XutUw8ck1m5qtfK/kCvLTvn9TsxMyuX9dq+uqHX9UrJX3uCTL/vi94er6zHQ7Xuz8fd9rrMhn2937rlk/rsxszsREf3o8a43k+MTemxtOcK/9xies7fs25VraTbMDN/7VlZ0+0QhPpbq+ysk4PM/7vatKf30D1nTjl9zJ83rrv6KTLbXNF7rulWU2aT0/qcyszszIOnZXbb7XfIbGxOr79LC/oMy8xsbmanzBY39Zg4taDHqJnZWlfP2WfP6H1It6O/bSo1PV7MzCzUi/t4w9mLpf53WmtMfz9bTc9zE9MzMutnd7t1rjpz9ij8JToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACPHl/uDG0nmZVZOye22/N5BZkOtbCIJCZtOTU26d94UPymxhuS2zpSh3yx1rzMvsymvHZPbgyVMyG2Zulba63pHZkSNHdHbgkMxOnl9z67zzzk/LbGmxJrNSueGWO9FoyuzMnffI7PySvt8gLLl1RpWWzHbuPiCzfYFbrO1tVmRWCVOZ9Xu6j+V54tY5THW5j8ZLfuAHZDYxv9u99vbPnJHZYDDUWa7bIbPIrbPI9e//ItMvLjA9p5iZZZm+p8K5NnR/HenXOUx1nYtLF2WWpl19P/40ZuOtcZkNBn2ZLS/pudPMzCL93hYXezLrD/WzpF19nZlZNtDrS1TS60ut4s8b5cjpY6l+zkFP93kzf7Kv1vWcslWrK0syO3f2nHttva7n+iuvvk5mk9OzMqvVqm6dva7uYysryzIbDnW/NTPrFLqf1Gq63cdaen9TL/t7n2pJz+dxoOepLNN9KE31c5iZDZ0NRc9ZlwJn3jQzC0Pd57NMz3FDZ/qLI38MFrke+72+zpYuLbrlLi7pfGNjQ2Yrq6syq9fqbp3lpr9n3aqg0JN9NGIPUwT62qDQ/cir04IRf5vj5IkzXrqbm26xFy7ob5Rz53W2tqb7YCnyP5GazvxYr+g5pRbrOrPMXyPOntf7rftP6O+ebu+Dbrlppt/L9PROmV133dUyO3J4j1vnzIxeJ1pj0zIrV/We3sysMGcddfadqdf0I/r1YMT8uRXVMf2cWeHvkcNQj6VzJ4/LbFDXz5HH/jNePKX75u79c7rOEXu8yV26n9z10U/JrP6hD8vsqdfqb2czs15Xzzelmv7OnZ7X37iDjv/d7e29vTOP3NlLmJmdO3dBZtnA6dcDXW46os4s14OpWtbz3+mFBbfccErPC8uLKzIbrurs+ufc6NY5P6377qMROx+Oax39TWRmtuzs66d7uo3ceao24dbp3e/YxKTM3vu/b3HLPbL/Spkd2n9YZll7XWZrq/pbwcxsZfmSzMYb4zJ7zrO+WWanj93n1nnPPTo/55xx3b+g+66Z2cA5L0kzvQ7smByXWbXhf4uec9q3luhrkxHnIc4Rgo3v1PuQtVTv1Zxjnc9e2/PHmoe/RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAACE+HJ/8MFjD8ps75Gr3Gsr4UBm+aArs7hS0WU6mZlZs9mQWaPVktmVV17hlvu37/9rmXXWLsisNjkns2NnFtw69+zeK7MDVzxNZuWSfr0H9+oyzcxWl1dkdtfd98ssLzK33DOrui+sd/W1vaysr1vtuHXOzu+R2cklfe3knjG33KWyvifL9XOupvo5i9jv132n3Efjk5/6hMzu+PSn3GsDq8osihKZxYluv2hEO5jpcqMo0nWW/N8bevNKkug6S05fCEu6fczMokKX2ypN6HLLeo4bRv447GWpzNJCX1eq1dxyh52+zDrtdZkNUn1dMBy6dVqo3+kg0w+Ttf15o72h76nmzK0zY/q9xDW/X5d0V9iyyRm99kxMz7rXxt5YcsbKxuamzDY3dT8wMyuXdSMMh85eIvX7yc65GV1npSSzKNR9qMj1ODIza/f0/qa3viGz1ZVlmS0tX3Lr7HbbMrvqKr2/ScbH3XIDJ4tCnfZS3Ub9tm4DM7MzF07L7NKibofBwF8nO23dRqurazIrR3rce33ezOxvP/hBmf3ia3/avdYV6PbNc2cyN7Mi1etWWuS6XGcZDZw138ysyHW5erYxu/22W91yN1d0f5hs1mV25rzef7fG/D1g4uxT8lSP/VZDj5co8VrBrBTrNTgp6+eMQt3nzcyWnH5/4sSdMltdOSOz2z7hf2KWSrr99uw5KLOdO/zvlx079Z5/55y+tt7Q+62g6u8dg9D5HtiiakO/642ev8c7fu8xmbVXFmVWr+l1cuh3Tdt01p4o0e/6wROn3HLXl/U6seu6wzL767/7iMw2+v4+5IbrrpNZv6f3GjVnj1dK/PGwtroqs0G3J7NqTe85zczCRH+DlKt6Pq46690g9/tf39m3953vjz0HD7nlbsZ6fVlz9moTzv7PvG95M7vYW3LzrQoiPafUqv631t49eh6rxM66PtDvJSz57zR33lsY6vdy5qy/Z/3dt/+RzL7rW58ns+nxpsyqC/5+bO3sqg43dButnzgvs12tKbfOS3V9v/ccPyuzYMP/Vp2a0994Vtd7gqqzPUwCf+8YOXvsDWcey6b9fl1yzoUaVT2P7dilv2WnZvW6bma2cME/g/Xwl+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIMSX+4OfOrYgs73X3uBem1tbZkGaOhcWMlrf2HDrXF1dlNnU5FNk9u3f+ny33Kc8+UqZvfPP3y2zIIhkNjY24da5a+dumTVa4zKLUt3uk/P+q99xYCiztWpFZrfd/im33PObgcyKpCWzsfkpmU0fGnPrjGJ9v1mh7+feou6We+xCJrNSpMvt9noyazvDwcwszXU/ejQ+cssHZNZeX3WvLZdqMqtUm86ViUyiwn/OwnQeJU5Wdou1Srmqs4q+uFTRbRDXdN81M6uUdP8th7qNYudXoEFF9z8zsyDQc+uwP5BZr6v7rpnZcKivzYPcuSF9P7HpzMzMQqevlHX7jdd1ZmY2VtdzZKNacqrUz5kEel41MwuyvptvxbDQ7ef1aTOzONZtlBX6OSPvfUb+7+5Dp+tWKrrdu23d98zMumt6z9B1thNxSd9vmPjPUmR6Qr/37rtkdvLECZmlmf+cRaHXpZ075mU2Oeavo91OZ0vZ6sqqzJZWlvw6B12ZZU7bdpz7MTNbXV+XWejMN/VYzwnnz59367xwwc+3apjqOWMw8PtKkOq5Mwx0P3JmcivMn+OcrZFtbuqB2Ov6c+MVR6+S2dOe8nSZ3XrHZ2T2sU983K1zdVP3s8x5L7M7dsrsxhtvdOuMnTn7xMmTMvvYxz7qlnvtVVfLrOXMDRcvXNDZxYtund5+YX5uh8wOHNjvlptluoe2N9ZkVjhjP4n974HewO/3W1GO9bs+f+m0e+2Je+6R2ZOeca3MoljPCRtOu5qZNZ1+0uvqdz01OemWe/K07tc7ju6T2YHrdZ8+duKMW+fB/XtldmifrrO3qb+708zfy87O75LZuTO6DVbW/fOQkjNjp7nutyvLutxyzd87Frlen4vU+XYe8e3SXtN7ht0H9Dvbd/UhmZ1dOeXWudnz19GtqlT196b3uWRm1l3Re5jO2qbMhs46mpmeG83M1i7puf7UKT2e4tDfJy8u63r/5C/eJ7OxcX2+MD/hzykzkf6WCFdXZdZp6/HdmvH30JfaejzlZb237Bf+2tJZuSSzItLzedU5/9o54T/LjNP2RaS/G4fOvt3MbGND7/lnnLOJWkW338Sk/yzL5/x9ioe/RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAIb7cH7xvrSqzxazpXlskPZmFgzV9XR7p60KdmZnt3DErs2c/62kyqySZW+6Bfbtk9h0v+T6ZvevdfyWzxQu6DczMzq/lMuv1jsmsZKnMlrs6MzM7dvKCDgdDGRXTV7rlTszWZJZbIbMgSPR1FV2mmVkelGQ2zHSda5mu08yskuhyK3Egs3bQ0feT+HUWuW77R2N2dkxm53uX3GuzdFVmrakpmcXOO924tOzWubbeltkwG8gsT/tuuVboseZyniWp6rnIzKxIWjJLnXJDp4/VS/6YqNV0ng2ducEZL2ZmVtG/lw1L+n7LJb0UVStlt8rJRl1mexp6bdq9Y9ott1bRWb+3IbOw0OtdHOk2MDMbb+l1dqvuu+9umV1zzdXutdWKnuNyZ6iEpp8zz/019uLCgsza63qt7He7brlZqvt1luns4OH9MpuZ9ftQ5jRSEuuxPT6m54Sy807MzCJna9Tr6755z733uuVutje3VO7Qafe88OeT9oYeZx3nfXc6en0wMxv09RpRTvRcdGphUWarqytundmouXOLCqcNR9bo/EAQ6jEcOX9+kwf++HamBqs669Kzn/dNI4rVBceRHmtHn3KDzK69/hlunaHTft4cOO3siw4ePOTWGTvjf/+RJ8ls594r3HKrVb32jI3p/aHX/5aXl9w6s0zPj7Mz8zJrNvX9mJlFsR7DYa47b5br/eHQGQ9mZnnw2I/vtdV1mW2urbrXNmu6nwS5npPLZf0ckxPOpsjMzi/qObk90G27/9Bet9yxmQmZPXD/AzK7cp8eS2Hs75EHhV4jOj29vrRqzndNqtdJM7PBUOe11rjMFlf1nsnMrLui16aWM5ZqibOfHzHPT9T1fLKR6b1Eva2/j83Mxsv6e2BsTn9rXerr79jNVO8zzMys8PdcWxWVnO/9nn9GM+zpvhI4e8DN5VWZ5S3/fGF9Xc9HSwsXZXbtgR1uuWOT+r2dOX9eZpeW9ffAiRH9qN9oyGympPtYp6zXlntOn3DrPHZB7x+Dip5b1/3jThs4faFwhumlvrPepX5f2D01KbM41PPGMPXXyQcfPCWz6dmdMgtauv0mmv53tX/q5uMv0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABAiC/3B+9d1eftf/GRT7vXPmXftMzmS3WZ1RJ9ezvm5906d0y3ZHbw4G59YTFwyz1/aUlmb/vjv5LZrZ+6S2b9nl9nmjphod9Lkelys7JuHzOzLExkFltVZmkQueWmob624vXGIpBRb+D/LqgI9bVxXJFZlOd+uT39YlLT1ya5vt8o8J9lMNTP8mgUw7bMxmol99rNXk9mw2xDZldeea2+nx2Tbp0Li3ocLixektnmauaW2+l2ZJZl+n0XmW6DRjzm1nnFkw7L7NyGbr9L6ysy6/b1+zQz6zrPGTq/Wy2X/L5QT/S8MV7XY39mfFxmO3b6c/3hXXMymy3r+Wizve6Wu7ys+1FU0m1Uq0/IrNHUbWBmNjWlr92qYU/3od7mqntt6KwhhRX6ukhP5lk6dOu87/77ZLa5tiqzkrNfMDMrlfVcH0e6n+SpnjPC1F8jLNNtNDWp5zhnybJOd9Otsuvkp0+f2VKdZmbe0lSEOuwM9Ny4urrq1tleWpNZ4vSxNPP7WJrpd9pe0/NC6rRt5pT5WbovPBrdbldm0boe+2ZmcaH7/cDZC6emnzUdMSa8dsqdPVcxovlSZ30OnP45yPX97Nx7wK8014MmcLLQ2bcfP7XsVtkd6DbynrM55j+L1/Yra7pt41iPw3prv1unt69fXtP9+txFv43yXHeWcqj3MN72Jmj460tvRc9zW9Vx9ii1st5rmZk96wXPl9mVVx2U2emlB2R2Zt3/vuver99Zt6P3pBtD7yPXbKYxJbOlfFFmd995j8yec82T3TqnG/obeWNJf3+0nHU9SPtunWsd5ywg0P0vHLENqdebMqtV9J606/S/ctn/FsgDPR46Zadfd/yHObhjl8yWYl3nypruJ0m17NaZdket7Vvj7UPWRuyNGrWGzBJnIttY1uXG/it19/z79+hztaP7/cX7/Dk9niotPQ6vmtbfhlHib2gLZ4843tR1Lqzp7+7PnL7o1nl6Ve8fc1uVWRT7c30S6RcXO2d56863TXvJX2M3e3oum63o+9m/e4db7qJT7/F77pXZgav1mrZr0v+uvjfx1zUPf4kOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACPHl/uBmWJLZ3952n3vtfQ88KLNvu/5qmR3aOSaz4w/e79b5nGdcK7NqkshsYxC55b7z/3xcZrfddU5mnbSsC40rbp1hon/XkeeFvi5IZVaEgVtnlmcy6+f6foaZvs7MLAiGulzT76Uo9HPGsf+7oCjSea2m+3XJ/GfJcicL9NDKnAvToX5nZmal5ribb9XS2TMyy4c999qu6XfTPnVKZpORft/TlYZbZ9Jvy6wa6fbtRvpezcws99rf6w9OG3QX3Sqfc8M1MrvmqutkdurUSZktra64dfb7Ax06c0oc+vNjNdTXTlf0HDher8ssGzEOLyzqPnbv4nmZBRU99s3MWrNTMqu2mjKrNfWzTE7rMs3MGmN6zduqijM/DrqbI67V60Tg9IXQmXPDxN92jLX02K8mus5GveaWGzn9r1bRa3A61GvW/ffc49a5tryss/aGrrPQfb5U8sdg7LR9uaT7fOCMXTOzTq8rs4XlJX1dX68f0Yj5ZKI1LrNBV5fb2fT7dTrU7Zu7exhn3xT4e6og/PL8zcqHPvR/ZbaW3uFeW4/1mMn6HZkNc73GDjNnbTGzLNPjydvnDVN9nZm/Z41iPef0+vq6LPPHRFDo/pvEer6ZHJ+WWaMx7tY5zJzvAed2g1H908lDp+8GgTPXO9+NZmZxrPPQKder08zM6UYWOPv2INB9Iaj5dYa9S26+FZPzkzLbceSoe+1Tju6T2cS03me0JvW+vORvZS1u6D60dFHvrfNcr4VmZqdO6n3ceE0/SzIzL7OFrl/nHmdPGqW6g2W9vszSgc7MzDLT+5BSpOew0ojx0E112++YddpoQZe56exfzMxWnfbtFbqfdFf9b+BLXf2tWkzPySwY6PWjXPe/N8Oyv/Zs1ZKzb1pZXnWv3b1zt8zGxidkdnJVv9TV83qcmZntO3BIZjP79XyzeOput9yz9+p835jun1Gux0StrOcxM7PhUK/d6xt675P3dV/w1nUzs06h9wRDp3/2nczMrBjq8dTJ9bWpcwYTOOeOZmYX27qN5lt67gycfZGZ2aWLug8W/btkVqnpvjA34X93Hz2s+/Uo/CU6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAjx5f7g1PSMzJZXCvfa8yurMvvH2++RWTbc55Racuucmd8tsyAqy+yfP/EZt9y/+uBHZdbPa/rCWNcZhlv/XUbWH8isyPV7yfPMLbco9LVZEcgsif0uFUSRDiP9TmPnuijy62w2G/pap+2jYuiWmxX62twS58JcRjvmx9w6my0/36r5nZMyO3PyjHtt2k91GOjs+L33ymyt5Iwl83/71871e2unI95p5jyLdz/ODQ36m+61t/3D+2X2vLruu9c6lXbHmm6dearHf5DqNugNem65a1lfZgtLizI7ec9FmS121t06eyU9H1Vndb+emB93yy23dB+Mqnquqo21dJm1ultnMGIu24oo1HNnluq5yMwsCPS1Xh/q9zecOv0xWHXWkDDR82q33XbL7S+fk9mpjh6juTMeAmedNDMrOfcbxRV9XUW3eziiiwwG+n43Vroy6/X8earX68hMj0CzijNPDXt6/2JmNjTdDt2+fpZuV2dm/v4nCPXTpM5YKjJ/H1dKvFbaukqi56lh5K+jUa47U7ms57E80NdluT+nhE77FubtWf21OQh0+xeFft+5s88L3J5tVjh7YXfudLbfofljIo50O/T7ev0NRn1nOI+apvq9DIf6fqLIrzN0xlMQ6Bt6NN9Mg029NhXOs/ScTxczs3K0tNVbkrodvd86s3nWvXYw1HuqfQcOyGz33LTMrth5hVtn5CxO1dKyzPp9/3u0v6HbYX1Nj98nHT0qs0rN+UYzs9UF/T5nnLX7zCW9zz275PeRItH7w4PzczJr1qpuud53d3eg55s41PvcTWccmZmlQ/1e5hqzMrurfb9b7meOPyizg/v0d0+tpN/3sOt/15w+ecrNtyp0vmR3ON8uZmblUL+39rruZ2VnnVxbXnXrvBjodijt2SGzxo6dbrn7nvokmc1OOGePZy/J7MJpPQ7NzBqJHsNjVZ3ldWddqvpzStNZt9aH+n1eGvFt03H2/NZzvrcyXWcl1G1gZpZUdD4s6Xnj/Lr/PX9xcU1mg1y3fe9T+ix5737vLNls3549bu7hL9EBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQIgv+wejSGZJUnavTXslmR2/uC6zfvtumT3naUfdOqvjO2S21stldss/fcItt1ukMhumQ5mVyxWZ5bm+HzOzTqfj5koU6NcbBCMuLnRUjpxywxFdysmDck1m1WpVZnHs1zkc6ne20W7LLMudRjCzfqrf29jEtMzmd+isUfGfpbux4eZbtffIXpmtb+oxambWPrO0pTr72UBmy5k/JkrO1DUw/b5HjTWzUfkXF+Z6QI0q8f7b/1lmpzf0nDIT6jFRFH7fzUL9+9PNUN/xhaLnlnusr8fTmbQvs05Nv8/mnp1unXMH9smsMt7SF46aqyLdRo1GQ2a1VlNXOWKtLILH/vfa66uLMutsrLrXXjyn1+5+T7/PzHnXw6Ee92Zmw4Eev16/DiN/UUuSTGZxrNs9cvY+caIzM3+dHWZ6bHfbuo36zhgzM9tY78rM2b5Yvan3KGZmkTNnFEM9Z/Tbev+SOnsmM7O1vm6Hblc/Z5Y7D2pmgTnzdbG1NSCO9VgxMwty/1m3KnfG2mZ7xb22Fun5qHD6bub8/c0w9dt+MPT6g7O+hH65RaHb15tz8lSvA2k2Yh1N9ZwSOHN57s1jI5aAotDvu99zxkSm73XUPRXOXjh3dzh+ne6HhjNGR62SuVNuNNT9JHWytreXMLMde/SeYKuWLui1O3X6npnZXfecktmBi2dl9qyvf4bMpsf9Z9w3vVtmUajXytOrC265e66aldnCGT3HHTv2cZmNT8y7dbac8bChh5mdOnVGZveePO3WOTuln3O6pteXmfEpt9wJp++ePq/7SaumvzHGJ8fdOttt/T1/aX1ZZstt/xt3bd3JnQ1X1xkvFx485tZZHXEWsHXOnmrEQtD3FuhA3+/U+LjMaq26W+eZRT1OP/qPuh9d/8ynu+Wmkd573vqZu2TWCPSckjrfb2ZmE7MzMqt53wNrzjrpvRMzCwt9v+tDva6PNfVYMjPLnb7S6ejJqu2cfzXqfl/wvosGA11nr62f08xsfmZcZrvmdslsbpc+873rrs+4de6YmHBzD3+JDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAjx5f5gnmY6LPyz+DyqyGxgkcwubvZldtu959w6v71TyGyj2JDZ2RWdmZmVGw2ZpR39LL2+fpZarerWGSf6NXnlBqG+nzDQmZlZEus6i9DJRvxeJinrvrA51H1skLZlVq367VcUui/001xm7d7ALbcxPi2ziZl5mQ1SXe4999zj1pnkzjh8FFoTkzKbmZ91rz1/ZklmgXOd9yT9XL8XM7OhpTLLTV+bOtmjkZvuY6N+VTns9mTWvrSgi61MyCzqdd06zzmt/ynTc8qx2G+/djORWX2Xvt+ZXbtkNjUz59ZZrtdkNnDeS1H4z1KO9RwZeVnkXecvuaFz7VZdOHm/zIoR4yzLdD8JQj2647LuB0HkzQpmgROXkrLMaiXdDz5bri44d9ohTfVcs7k5dOscDJx5qtD3Ewa63fPMr7PktMPczp0y29xcc8tdX12RWTrQ91SkOgtGTI6dQUfX6ZTrrfn/r2In0mHi9PnIXdHMOm1/b7lVp0/fKbP7L/h7mFpSklmS676buSu7HvtmZlnhlJvrd1pK/Hkjd64des/iDSdvMjKzKNL9Nwh0H4y8ckfVGev29eax/kCv62Zmeaav9eb6MNBrWhDo/mVmludbW58fxfC2oekXnk3UZbbruqvcOsf0pVvW6erx26r46919J/Te8eSDF2S2ua6/tZ7xrKvdOicn9B5vfnqvzOrVMbfcUysnZJbv1g2/WdHPst4+7daZVvS36kaue1h3pimzON7j1rmyuanvx9sajhgQ6yurMpua0/vrrrMnWFnz9wthrMf+2aVFmd167Lhb7sxTDsmsFOj5+Mx9Z2TWqPnzVKnw91xblTrnakWi+5+Z2UXnrKrsbKsOjOkxGjrzsZlZs6zPWlZSvT88cc8Jt9yJOX3GcKat2yh1JvqKs06amYXOPiTM9GCbiHUbLGd6vjEza9X098tk0pJZ5sw3Zma9rv7e73nfYpO6zlbLn5Mz5yyq3dHz2Ki9eeJ8AzfrepzWY93p66UR+5C+f17i4S/RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAECIL/sn80JnRe5eGkWJU2wksyzU1x1f2HDrfNs7/1pm3/i8p+tyz11yy21n+vcOufM7iaRSkllU0pmZWS3S5ZaqFZl1N9oyGw5Tt84i1e80qehuE8X6fY6qN4r0tbnT/7qdTbdO71qvzvGJSbfc6bkdMru0tCyz1cULOjt1v1vn4QMH3HyrqpW6zMqVsnttUgpklqW67Z0ZxVI3NTPz5xx9mb7XzxpVryjWvHL9Ojdz/Sz3DDoyGytV9XW9i26dd6Z6blhq1WQ2tfegW+6O/TtlNr5Dj6dyvSGzcMQ7GzrrTxQ7827i9+vYmZeD0OnzWaavC/xnCYPH/vfaUa77UJ754yhP9XzttkGo14iw0Ou6mZnXRP1sILN0qJ/TzCwvvHfmr4dKHPvPkjh9KHKujQs9D2XO2mxmVinrti9XdZ9fXuy75bY39DqbhLrfRoFeYwf9nltn6oztwpmrR44z534Dp+0rsW7bzfUVt85ue83Ntyos9DtNRixnYaafx21fb02L/P4ZOHNKHOq+EjlziplZrqddd84pnP7pTkZmVuTOvOFM5ZnTtrGzJzUzy5w1YuDcTx753xlF6Iw17/PPGUtWOC/FzAJnHxc476WI/XUydfLmzjmZ7bnuqMziwN8vrN73aTffimpNf99ZqtdCM7Mw03334oUlmf3tX3xYZq0xv28eue6wzGpxS2a7mzNuuWWnb96bn5FZoD/RrNT3J8eir9t3WBnKbG56VmazqXNDZtZeXpfZhnM/jcI/D+kM9DobV/W8UC/rPr/iTQpmdvzMgzK757jznVvT3zVmZrO7dsvs9ls+JrPnPf0ZMnvGs7/erfPDH3y/m29VpaqfdeCtS2a2sqH3u+NVvd71e7ovrK+tunVubup+NuGcIQRDv688cOe9Mhsr63L3zc7LrNNedesscj2ecme/UHL2IRM1/e1sZjZI9LVJoOtsr/lnXN6IiRs6TZz7qY0Yh0NnHzdw5pTMOe8wM8udPcPmpp4fH7xbn3nMTfjry/55PWePwl+iAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIAQX+4PTo2Py6zX23CvbXcHMitFVZmlaS6zMCm7dd7yz3fI7Pi5czJbbQ/dcpc3uzJL9WNavd7Q1+X6Oc3MymX9rHGpJLNKNZNZFEZunXGiy82c372keeGWGzh5Uej7zYb6vQyGTsObWbVSkdn01JTMJqd3uOUOCt0OvZIeWt2ybtsiStw62z3d/x6NYZbqOrv++G6O6/bttfsyy5y+kAWBW2fmdTMnDHQX+9xPjPqBL6oo9HVF5I+1jhN/eLAms5Md/c6Wav7vR+P5PTLbsWtGZgdmdGZmNjWmx1PozIFt0++sF/hzShzrBqxU9NxZqdX9cku6X1eqNZmVnfkmSfzx/eWQZ3ruLAq/bYtC97Eid/r80BnbmT8IvREYhLpfZyPGWeTsGcpl/c4ip85wRJ1e6xa5t94582a349Y5cJ6z223LrN3edMvNU92PgpKus9fRdY7sf8405l0ZjFg/vGtjZ29UDHoyW1286NY5HHx51u40dfrKiDoHzvyYehvaXO9vwhFfFbmzzwtD/WaGA3/eyAvdP/NM77HzXHeyUqLnBTOzwOmf3nO6/XPEnzZlA+cbxfmWCAr/OyOOnBfn3G8QeOX6e/NSrB926OwPhzW9hzYzm7zioMx27dd7n95FPYYfuOcTbp3VoT9/bkVSd7619NL82Wsn9B5l3/i8zM7cfUFmH37/p9w6ay39PV+r67FUr/qdfnZMv8+kpvecJxePyWy943/r95zv55W1SzLbGOist6D382ZmtY5uo2E+KbPVij+2S+WmzAYDfe3K5rLMzm76z7Kc6PGbtvRz7ijpfmtmdun4SZnFzrPsPay/P6J4ya1zvDHm5lu1cFGPtXK95V4744y1+Wk9JgY9vV9IAn8/O1HT/cgiPYbLLec6/1IrOxuKivdtOGIdLZx1q2d6boidgqtV/1wycL7Fes54Gnb0vtPMrNXU37IVZ271vqcqzne1mVlQ0t+y3b6zFxtxxDLM9cLWNb3GTo3pMTo9MeHW2XDOUUfhL9EBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQIgv9wd7va7MyiOO4vvZUGZJVJJZGukyi9CvNKw2ZHbi3CV9XexUambpsNBZmsus1+vJrN1uu3WGzrOWy2WZ1UuJzKrVyog69bOUK7rOak23u5nZYJDK7NLyssxy09fFid8XJlp1mc1PjutsftItd7Xdl9n66orMNtdWZTY25de5uLDo5ls1zPSzRCXd583MJmZ1+w67zvge6D7mDKXPlpvrH8gzfb9OtzYzs8ACnQU6K5zMYj0OzcziWF87rOn264/pvnJobM6tc2KyJbNGSy8LjZo/P5Yr+tpemslsYDorEr/9osRZxrz34mVmlpR020fOOpE49xNFfvsV5o+1regNBjKLY38L4PXryLk2dPp8GPnvMwydOkOnzmjERsRp+8BZYwtnrklTvS6ZmWW57tdDZzxEvY6+bmPDr9Npo3pf70PyEc8SOn2h39XlWr71Pp0XW7t21HuJnTklcvrR8oUFmQ37/j7OWVoeHWdKiRK/0ijW7RvEznjKvLHmj8PIuWHvytxZI8z89bmc6DonWxPO/fjtl2W6n2W5zqLIudeyXnfMzNLUeWfO/ebOPGbmz1Ub65sy84Zo7nzfmZmtOe80ntfvZd/Ro265ExPTMjt7zzGZLd5/XN+P8z7NzCqlx36AF7leB1aX/Pnm/Fn9nXv11+2X2aCtX+jqkr/2fPB9H5dZGjr7v6N+2+4c6nyqNSWzK+avkdnKxppb50JHf2tFTr+thTWZ9Uvjbp33ffIumZ1f0GvPjt2H3HKXH3xAZgPnbMebT6qz426de6++QmYTe/fKrN3Tc42ZWeisS1M7ZmVWVHUfWt3wx9Lqum6jR6NWq8qs1fDnzqZzbamsz3eWV/T3QGnE90CU6HvKC72+FM75gpnZ9Lg+Q6jGus5k6OwJRnwObGa6HRZ7+n7Tnq6zWfHfWZ7qOiPnHKDa8s/rCmc/EUb6nQbOt5Z7pmFmFaePOdsiy0aUmzrnN7W6Pl/MC/2cyYjv6kFHr7Oj8JfoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgBBf7g/2uz2ZlaPAvbbm1JIPuzILIuc6y90680LnuemC00HhlltkzrPm+tqi0Fme+88Shvp3HSvLKzJbTnXbthp1t86xiUl9baTvp2IVt9ws78ssDjKZRWX9zvo9XaaZWSXW78yrM+2sueWmHV3v5uqSzPLhQGaVcuLW2YudQfEoRIluo/HJhntto6b7Q+aMp3So+32a+WOiMH2/YagnnGDE7w3DwCtXt30Y63LjxJ9Tas47bTZ12881xmTWKFfdOuslnZecPjjwu6dtlnQ7dLNUZlngzCmxX2kp0u87KZVkFkb+WAqcedebzweDocxKJZ2ZmZWSx358J2U9J3t92sws8fq81z7OOPJ3C2aBN1zcNVbP5WZmlul5N3PW4DzV/TYd+u9zMNB1drt6fc66HV2nc52ZWT3V7VBtTelynX5rZjbs6Wfx5k1PMOo6571kTj8pzJ9z687Yb68ty2x9fdUt1xMGl73d/pJEqTOGB/6YyEznhen+EJuekyMnMzMLnLk+y/VYS9yJwSwInL6S6r7b6ej2C0bMj+a1n7fnH+rresMR65IzgwbeR9OoIeo0b+b0Be/CbMQa25ydkNns0QMyC0d8/9378X+SWe+i3ptHzh4lHvEsufO+t2r1ov6+u/vWe91re239fRJV9P5vao9+J4Ou/6119v5FmX3UPiWzpOrPGeszek5uLY/LbOfsQZmNN6fdOkuJnqdqgd5XztR0uTP7a26d+8aaMrvlY5+Q2fH2BbfcxfYZmU2N75DZrr37ZLZ7t77OzGzPzj36fpZ0v940fdb0WXqcNZu67/bzti4y89/L7C69fjwa5aoeh426/90dO99a6139rGecPcz6yoZb53RD98/WmD5Tivr+d/fFdT0n12plmZWdKTfM/fl6GOkxPHDOJVc31mVWpP53d835Fqs4fWGY+utd4OyNSmX9nN4eJY79/aq3d4+cM8Kec/5lZtYo6/fdqOj2G+TO+aGz5zQzK5z94Sj8JToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACEFRFMXjfRMAAAAAAAAAAHw14i/RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdGxLJ06csCAI7O1vf/vjfSsAHkOMbWD7YnwD2xNjG9i+GN/A9sTY/uI4RP8X3v72t1sQBA/9f3Ec265du+ymm26ys2fPPt6395j6nd/5ncd9QHw13AOeGBjbT7x7wBMH4/uJdw94YmBsP/HuAU8cjO8n3j3giYGx/cS7hyeS+PG+ga9Wb3jDG+zAgQPW6/XsYx/7mL397W+3j3zkI/aZz3zGKpXK4317j4nf+Z3fsenpabvpppue0PeAJxbG9hPnHvDEw/h+4twDnlgY20+ce8ATD+P7iXMPeGJhbD9x7uGJhEN04du+7dvs6U9/upmZ/dt/+29tenrafv3Xf93e+9732ste9rLH+e6+8trtttXr9cf7NoBHjbH9cIxtbCeM74djfGO7YGw/HGMb2wnj++EY39guGNsPx9jeHvifc7lMz372s83M7IEHHnjov91zzz32kpe8xCYnJ61SqdjTn/50e+973/uIa1dXV+0//If/YPv377dyuWy7d++2H/qhH7LFxcWHfmZhYcFe+cpX2tzcnFUqFXvyk59sv//7v/+wcj73v0n0m7/5m/Z7v/d7dujQISuXy/aMZzzDPv7xjz/sZy9cuGA//MM/bLt377ZyuWw7duyw7/7u77YTJ06Ymdn+/fvtzjvvtFtuueWh/zOb5z3veWb2+f/zm1tuucV+4id+wmZnZ2337t1mZnbTTTfZ/v37H/GMr3/96y0Igkf893e84x12ww03WK1Ws4mJCXvOc55j73//+0few+fa7Wd+5mdsz549Vi6X7fDhw/brv/7rluf5I9r3pptusrGxMRsfH7dXvOIVtrq6+oh7Ab4YxjZjG9sX45vxje2Jsc3YxvbF+GZ8Y3tibDO2twP+Ev0yfW6gTExMmJnZnXfead/wDd9gu3btsp/7uZ+zer1u73znO+17vud77M/+7M/sRS96kZmZbW5u2rOf/Wy7++677Ud+5EfsaU97mi0uLtp73/teO3PmjE1PT1u327XnPe95duzYMfvJn/xJO3DggP3pn/6p3XTTTba6umo//dM//bB7+cM//EPb2NiwV73qVRYEgb3pTW+y7/3e77UHH3zQkiQxM7MXv/jFduedd9qrX/1q279/vy0sLNgHPvABO3XqlO3fv9/e/OY326tf/WprNBr2i7/4i2ZmNjc397B6fuInfsJmZmbsl3/5l63dbn/JbfYrv/Ir9vrXv96e9axn2Rve8AYrlUr2T//0T/bBD37Q/tW/+lfuPXQ6HXvuc59rZ8+etVe96lW2d+9e+8d//Ef7+Z//eTt//ry9+c1vNjOzoijsu7/7u+0jH/mI/fiP/7hdddVV9u53v9te8YpXfMn3iycmxjZjG9sX45vxje2Jsc3YxvbF+GZ8Y3tibDO2t4UCD3PzzTcXZlb87d/+bXHp0qXi9OnTxbve9a5iZmamKJfLxenTp4uiKIpv+qZvKq677rqi1+s9dG2e58WznvWs4siRIw/9t1/+5V8uzKz48z//80fUled5URRF8eY3v7kws+Id73jHQ9lgMCi+/uu/vmg0GsX6+npRFEVx/PjxwsyKqampYnl5+aGf/Yu/+IvCzIq//Mu/LIqiKFZWVgozK37jN37DfdZrrrmmeO5znyvb4MYbbyzSNH1Y9opXvKLYt2/fI6553eteV3xhd7r//vuLMAyLF73oRUWWZV/0ub17+NVf/dWiXq8X991338P++8/93M8VURQVp06dKoqiKN7znvcUZla86U1veuhn0jQtnv3sZxdmVtx8883q8fEEw9hmbGP7YnwzvrE9MbYZ29i+GN+Mb2xPjG3G9nbG/5yL8IIXvMBmZmZsz5499pKXvMTq9bq9973vtd27d9vy8rJ98IMftJe97GW2sbFhi4uLtri4aEtLS/Yt3/Itdv/99z/0rw7/2Z/9mT35yU9+6LdoX+hz/6caf/3Xf23z8/P2/d///Q9lSZLYT/3UT9nm5qbdcsstD7vuX//rf/3Qb+/MPv9/FvPggw+amVm1WrVSqWR///d/bysrK1tugx/90R+1KIq2dO173vMey/PcfvmXf9nC8OHd7Iv9n6j8S3/6p39qz372s21iYuKh9l1cXLQXvOAFlmWZfehDHzKzz7ZdHMf27/7dv3vo2iiK7NWvfvWW7hvbH2ObsY3ti/HN+Mb2xNhmbGP7YnwzvrE9MbYZ29sR/3Muwm//9m/b0aNHbW1tzd72trfZhz70ISuXy2ZmduzYMSuKwn7pl37JfumXfumLXr+wsGC7du2yBx54wF784he7dZ08edKOHDnyiIFx1VVXPZR/ob179z7s//25wf+5wV0ul+3Xf/3X7TWveY3Nzc3ZM5/5THvhC19oP/RDP2Tz8/OX2QJmBw4cuOyf/ZceeOABC8PQrr766i1df//999sdd9xhMzMzXzRfWFgws8+2zY4dO6zRaDwsv+KKK7ZUL7Y/xjZjG9sX45vxje2Jsc3YxvbF+GZ8Y3tibDO2tyMO0YUbbrjhoX9J+Hu+53vsxhtvtB/4gR+we++996H/Ef6f/dmftW/5lm/5otcfPnz4y3Zv6jdZRVE89P//Mz/zM/ad3/md9p73vMfe97732S/90i/ZG9/4RvvgBz9oT33qUy+rnmq1+oj/pn7jlWXZZZV5ufI8t2/+5m+2//Sf/tMXzY8ePfqY1ocnDsY2YxvbF+Ob8Y3tibHN2Mb2xfhmfGN7YmwztrcjDtEvQxRF9sY3vtGe//zn23//7//dfuRHfsTMPvt/HvKCF7zAvfbQoUP2mc98xv2Zffv22R133GF5nj/sN2f33HPPQ/lWHDp0yF7zmtfYa17zGrv//vvtKU95iv3X//pf7R3veIeZXd7/Cci/NDEx8UX/ld5/+Zu9Q4cOWZ7ndtddd9lTnvIUWZ66h0OHDtnm5ubI9t23b5/93d/9nW1ubj7sN2f33nuvex1gxtj+QoxtbDeM789jfGM7YWx/HmMb2w3j+/MY39hOGNufx9j+2sb/Jvplet7znmc33HCDvfnNb7ZWq2XPe97z7C1veYudP3/+ET976dKlh/7/X/ziF9vtt99u7373ux/xc5/7Lde3f/u324ULF+xP/uRPHsrSNLXf+q3fskajYc997nO/pHvtdDrW6/Ue9t8OHTpkzWbT+v3+Q/+tXq9/0cHrOXTokK2trdkdd9zx0H87f/78I57ve77neywMQ3vDG97w0G8ZP+cLf7un7uFlL3uZffSjH7X3ve99j8hWV1ctTVMz+2zbpWlqv/u7v/tQnmWZ/dZv/daX9Fx44mJsf74cxja2G8b358thfGM7YWx/vhzGNrYbxvfny2F8YzthbH++HMb21y7+Ev1L8NrXvtZe+tKX2tvf/nb77d/+bbvxxhvtuuuusx/90R+1gwcP2sWLF+2jH/2onTlzxm6//faHrnnXu95lL33pS+1HfuRH7Prrr7fl5WV773vfa//jf/wPe/KTn2w/9mM/Zm95y1vspptusltvvdX2799v73rXu+wf/uEf7M1vfrM1m80v6T7vu+8++6Zv+iZ72cteZldffbXFcWzvfve77eLFi/Z93/d9D/3c9ddfb7/7u79r/+W//Bc7fPiwzc7O2jd+4ze6ZX/f932f/ef//J/tRS96kf3UT/2UdTod+93f/V07evSo3XbbbQ/93OHDh+0Xf/EX7Vd/9Vft2c9+tn3v936vlctl+/jHP247d+60N77xje49vPa1r7X3vve99sIXvtBuuukmu/76663dbtunP/1pe9e73mUnTpyw6elp+87v/E77hm/4Bvu5n/s5O3HihF199dX253/+57a2tvYltRme2BjbjG1sX4xvxje2J8Y2YxvbF+Ob8Y3tibHN2P6aV+Bhbr755sLMio9//OOPyLIsKw4dOlQcOnSoSNO0eOCBB4of+qEfKubn54skSYpdu3YVL3zhC4t3vetdD7tuaWmp+Mmf/Mli165dRalUKnbv3l284hWvKBYXFx/6mYsXLxY//MM/XExPTxelUqm47rrriptvvvlh5Rw/frwws+I3fuM3HnFvZla87nWvK4qiKBYXF4t//+//fXHllVcW9Xq9GBsbK77u676ueOc73/mway5cuFB8x3d8R9FsNgszK5773OeObIOiKIr3v//9xbXXXluUSqXiiiuuKN7xjncUr3vd64ov1p3e9ra3FU996lOLcrlcTExMFM997nOLD3zgAyPvoSiKYmNjo/j5n//54vDhw0WpVCqmp6eLZz3rWcVv/uZvFoPB4GHt+/KXv7xotVrF2NhY8fKXv7z45Cc/WZjZI9oQT1yMbcY2ti/GN+Mb2xNjm7GN7YvxzfjG9sTYZmxvZ0FRfMH/HQAAAAAAAAAAAHgI/5voAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgBBf7g++9T/cILMoyNxrgyTQWZ7LbNgf6uuK1K0zrpRklvYH+sLQ/71CWBQyyzLdnEms7ydLnfsxs1pZt1FY0llg+r0MTD+HmVmR6rw7iPT9BIlbbprpcr2+YLoLWZH772yQ63tKe12ZZfoxzcwsCnS9We70Xed2N7y+aWbrw7LM/usf3+de67l06ZLMBkN/fIeB83KcKHKy3OsLZuZW6YxhZ/iamVma6x9wn9MZT4l7nVnm3FTgXes9p/McZmZDp31D56Xl3gs1s1LozI/Oc4be+xzRft5LdaYbC0bMgXmh6429+chpo9h7UPPbaHZuzr1WecffPyiz/tAfZ0sLel5IB3ruPHxov8xqjaZbZznR/TpxslrsT9iZ86ilyBlLWUdmE3W9rpuZWaDfZ62s16XCWSTWV5fdKsuVmswqTp3upGpmSVnvb7JBX2aRU24QjdgvOPNUt9OWWTn2t7ZxqSKzbKjX7uFAr8+Nql6bzcxCZ+yPjfljwvOWt9wss/Fpf85ISk5fqU/IrN/ryWxtbd2ts+qM4SzTbR+G/vgOS7ovefOGN5eXCn/v442ZwnTf9dbR4Yg5OXUmskpFP+eo9rPcGafOfJR4Dei0gZlZmulr01R/48Wxv+evVPRYTEreONX3k4yoc2nposy+9Vu/2b1Wee63fJ3MavWqe+3C4pLMVpwxutbZlNns3LRbZ7VZl1lU1vdbhP460N3Q93T/3ffIrN7Qde7aNe/WWS1737l6XR/mut+OTU+5de7aodvXXSpHfNgUzsdsp6vX7ksXdR8KR5z7POMp18ms29N13vJ/P+SWu3OHfm+lkn7fFxacZ3HOZ8zMmrWWzD7wzv/rXuv54//P98ns+Em99zYz+8Qdn5bZzNiYzK7cr/cELefczMys39b7n8Bbl6r+3Bk76+ilDf2dUa3ofdxwxNrTd/ZyKz3dt1Pn2LQ8pvdMZmYbm7rOMxcW9YUj9gRVZ20qOXvh/sB5zlFnMBXn+8XpC+lA7/HMzFqNhs6aep+8uLQmszVn/TAzC5z9wl98/A73Wv4SHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAQf+zrf9CXuh/cXrQ67nXllP9L0dXEv2vAXv/AnY44vy/GOh//Tl0/jH5wP2X5s1667odcqfgXqr/Vd6a94/Fm1nk/SO5zr8wHJq+11Ht13f+deIi1P8Cds/8h0lzXW+qb9dCrxGG/r9M7r3RJNb3Gwb+vyI86Oh+H5X0PWUD/SyR0+fNzMLMv6etCkM9FeTm31Pi/Mvaw0xfGzmzT+b0EzOzktMfCucfjQ8iv9zc+Repk0g/Z+Y8ZxG5VVpeOP+ydqTLzZ1/ATsY0Y8Cp41ip07vfZqZFYF+liLX7Rc5bZRn/pxszv06TWTJiH+9PXfaKCzpGx44692I5cWCYERn2YJyWQ+0uORvAXrOv8C+NtjQ5TpjJQ79Z6zFzlhyXko4olxvjqs4c32/66yx9VHvS4+HOHDmMNPlht5gMTOn+1me60U2jvRezMys5PTd9Z7eb5WcPpY7c4KZWams1+e2c20yqi84c663YejnunGrJb/9cncnsnXe+hHGFffaoFTX5Sb62pIzlrKVNbfOjpNXQz0mvPFrZjZw9iFhQ+9Zh0779TLdr83MQme+Hg70/tBZWqxS0fdqZrbZ1eX2O7r9ssLvf4kzr4TOPjku9NxZZN6TmrsJ9PYS09MTbrFJotuwVNbjNHPmlJJeCs3MLHTm7K1KqvpeW5Pj7rUbzpx8aW1FZlOzYzLbvW+HW2enr9fKjtMVktgf28OhXrcK58Ox7ry0qfGmW2fZmc/bm5syS5195Viz5taZZ/pZOs64H/WNVop1vYWzRxkO9P2M2Dpaa1zXGbR12y4v6bY1M4uiJZlVq3rcp86zzEzMuHUOerpfPxq1mr7fwjkzMjN70pUHZDZe120/Xnbmqb4/X9cTfW25puvMRpylFEM9Zqqh7p+BM9/YiLOSprOmFYEut93R82owYlCEzrdEVOg26KX+s5RDPc+FTrll57Akc84Wzcw2Om2ZOZ/kVqv6e1JvFx05+4l6ots+rPt1+ifYPv4SHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABDiy/3BIu/JLCgGI67VWeic42eDvszi0ohbjyLvjmQyyJybNbO4msgsC8oyy7OhLjTw68zyVF+a6evy1Ck30ff62bgus42ObvuFjlusrXT1PaUW6Gyg+1gt0deZmY2V9f2WIp1Vyl4fMnNet0WBft9Bod9n2ZwXamYV3f0elSjR4zAe+u0bhjovO1ng9Psw9n+/FwXOPYX62tzJzMxKemqwINf3m3j36zefxYX+Ae85k5IuM3Xu9bN1Og/qRKWSPyYGQ923k8ibc3S/j2O/AfNIt33kLD5B4feFsjPWvO5XinUbRaHTuDayq2xJ1enUvaG/dnvXZk5Wi/X7HKv4bVCvOOvAUM+rpchvvdjJY2d9iZxnKY1YuyNnXggLXW6lVpFZp+/vfQpnvxAVum+OWlva66s6W2vLrDk1JrNydcTfcTjrUsWZFxJvgJpZuaTL7eptp1tnxZswzGyQ6vfyaOShrnfgvG8zMwt1HsfOvqmi++f87JxbZXlDrwOlfE1mvTV/rio1dD+Lyvp+Kw291828jxczi5z9xKDrbIadfVHs3KuZWeHsFwrnOyNO/L6QOXuGOHa+bQbOt2Hkz/V90303iHTm9T8zf961wLsnncUj9o6j2ncrauNNmYXOd42ZWWOyIbN6V5c7Naez2njVrbO9qMdoteq8s9R/ll5Xry+x8xE8Vtf9dsS20kJnX7nZ0X2+m+ksy/3vu43NTZktLlySWVLVc5iZ2fy8zr09faej2706qfuJmVmprD9QSkPdDv2ubj8zs+FQj9GZGb0G7N4zLrNsxLfAgxeOu/lWedPjRNN/p7Pze2SWD7oy66/qNbbT3XDrrJT1+A+c6a838Pt9vaL7Ss30upQ73y/RwF97bKjX52qm92ol57wpd852zMy87Vje1/2+13POD82s5Kx3FWd/WHHOUZt1f65vOOeLlUSXO+IT2BLn+3nY1/06dPY+idOH/l+lfu7gL9EBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQIgv9weDIpNZGPhn8XGQ6zAtZFQrl3SdoX/rQSmR2TDTdYbB0C03zfU9VSJd574D18pseemcW+eFsxdk1qpUZZaUdRttOs9hZrbU1u/szFJXZu2i5pZr1TEZ9SyQWTfdkNlSu+1WeXGlI7PA6ZtzE34bjVUrMhuPdR9LEl1uFA7cOgdF5OZblee67XPnvZiZFU6eOWMtcR4lD0fNKbrO1JluikLfj5lZqqc5K0X6hr3nDEe8stz7XabT9EPnQZ0mMDOz1HnfQaGzTtfvn+fOnZZZo9mSWaumx0Sp5M8p9YaeA7PMWbdCv19nqc4SPdXbMNd9IRrRGfzeuUW5XtNCp9+amSWh0whOuZE5A6no+3VGui9kA93/Rm1mImecBaG+X68Ppc79mJnlzlgqnMkmjMsyCwp/dGeF85yBbqXVVb1Ompnde9+dMtvs6HZojV8vs2rqz/MVbwkeMZd7isyp13lnw6Fue28NMDNLnaHk7zRGcPad2Yi9ee7kPWdvHjpjtFxpunWOmR7/J26/S2YbC8tuuXsOXCGzfG1NZoNYt1+55rffxqYeM2VnfUlNrwPRuF4nzcx6fT1vJM5+djBi7Un0lGM957MoiXQbLa1vunWO7T8gs7Ck+9Ew8+fAYabbvlJxrnWicET7BZf/OX3ZWlMTMtvcWHev9fZF9Yb+dpmfm5HZiCnOIufbJqnofVzaHTF3DvTkWS3rjjt0Jt3VNf1NaWYWdvQ81Xc2h4Hz7VJy2sfMrDmm+/zAW7P8rawlzrdL9P9v176aLMvS876/2x5/TvqsLN9V1dW+Z3pmAMLQCAQpAGIIkiKoC30JfSddMBShkEIBBSVQBEA4gjMAZjDTPdPTvstlVWalPd5sq4u+VDzvqcgGJIXi/7t9cq+199rL7ZXHmaeiVNfZavv78jhx2iHV7XDn4V233N1rB/ram7dk5jXfl18+dussvsVew1M6a+zu3p57baet163CW/ebTr+eLN06G4me44JC97G2s8aamTWd/lC7Y033wUbLWdDMbDHTz9puOmPCWbsnmT4bMzOrnCUkjXRfmC389xI57Rs581Ec6utiZ84w88+/eh39XqrcP2NdZbp/LjLdDrWzOHXX9IVyTe7hl+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIMSv+oe1pbqQpPYraUQyS2PnHD/L9f3UmVunRYETVTJblSu32LguZdbu9WX2m7/9KzL7yd987tb5/FS3w7BKZJYt9XW/fDFx63xxMpJZ2tmQ2e3X77rlJu1dmdXOO1tl+r1cnJ25dU6GJ/p+It0XDqe6DczMslLfb2PQlFnTGXWL1dytM4r1OPw2AtPtEIf++A6c8ZSk+mGTUI/9wK/SwkjPKXGt30tR6vFrZhY5/SGKdbmB03cb3hxnZqWu0iJnbg1q3QZl3XDrtKCQ0WzhjLWJP2+cXAxl1mi1ZZakXZm1mnqOMzMLnc7irS/Rmk5Wx7p9E+eVhs77DHWR/2C6TvPla9pgWes1JK51H2rFuhEatb/GtmI9Z1ShrjPM/XLbqR6jeaX3E3Gi54yw8utMnN8prFb62jjRL23dfFzmS5kFzpYvW/MsF2O9HjYaHZkVpjt9Zfp9mpkFgX5nYajfS2D+/rAOdfvWhb62lTprljOnmpnVbr9fM1975QbOHOes62ZmdaHHd+CMl7J2vgcC3f/MzFrO/Xad+bEx0PtrM7N4OZPZxZMXMnOWbisH/tpjzr60Drz1WVd63tJroZlZudR1BqbnhkZD70nNzKpY9/uq0vfb6umxf3rq782TzW2ZdRPdDvma/WHq7TudPUEd6Dklivx9nLc/vKoo0OOs2fC/BXa3BjLLVlOZJc5cNJ8t3DqbSU9maaT733LN2hPkzrpf6s6wmum5qLShW6fXrwfbOuv29T43d74Zzcwmcz0fR4luP6e7m5lZMdXflVFLz3Gtts66fX8+aaW6HTpt3ccevnHPLTdx5rHaGduxMz4HOy23zht7r7v5VS2d79E48T8Wzi4vZTZw2rd09vSJ3wzW29JrsPfdk2X+3iiOnPHd1c/SinX/zJ39wDd0+zrD0CJnjd1a863acI4f7tQbMpv506MtnH1cGuuXGkX6WRbzoVtnttTvJa30gybOd7WZWdMZwytnTATO2U2crFmbG2v2eQ5+iQ4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAQvyqf7gKujI7X9TutfUsl9lOvyWzrXgqs2yWuXU240JmlZUyC0t9r2ZmVaX/7zC5eCmzP/n3fy6zp0f+s5yN9f0en17qcl+OZJY3dLubma2sI7Obm9dk1uxuuuWGYaSzRN9TFOh2n7X8Z2mkBzJbrlYyO7rU7WdmNrrQeTvuyazXbcssKvX9mJnVfve8ssAZwlXlX5tE+t0UuR6Hcaqnn6LwK9W9yKzQVZqFgVtuVTv/V6x1I9WVLjdf8ywrJ29GiczmS91XLkYTt86Lsc7zTN/PfLl0y81N3++5sw70uvqlBc58bWbWSXQ/Kp3/E0eB/16KQtcbJU6fr3VfiM3vf04Xu7LY6dJ55bdtGjn9ejaWWe0Mwny5cOsMS92HLNP9L3LmEzOzutbvuyz0GpxnOsuC1K2zdPrQ8PxCZqdnel1vdhtunVmhO1Grrdeeo+dnbrkf/eJzmd198IbM8kLPU6s1e8duS/eFMtPzyXjhr6NprustMt0/A2flyeYzt86l0486vYF7rad01o/SWZfM/PkodxfSuUwyp8+bmQUr/d42W/o7Y+dgyy13OtbvrXF9X2aDnt7rBv5Qs8VYz4FNp20DZ6+bbO+6deZOv/f2RWniz1V57XyHxHpuTRq61p0bt9w64029T14663Pa9Pf8WanbvnTWvLrWz1mv+c1Z7az7V7VY6nFWlt74NDs9P5dZ5dzrdKHrXGX+2E6c/erkbCizaM1RRL5y9mpO37S27pubN/xv1c0t3TcHXT1n5LnT95x+aWY2udRnHklDT0YvHr9wy12MdLnf/UCv3YOuXpdKd7YxSxp6vml2d2TW2/DfS+6sL3Wts15vW2ap8w1hZrYY6nn+2+j0dB9bOd93ZmbTqR6nzVi/m1ZHr7FRuWaOy/U4LJyunTT9hdT7FPPejHd+E63rn6kew9VMfx9PM13ntQO/75qzH7vfdp609p/l8lLvfa7v6XtqRLrc83O/z9e1Ht+Jc15XOmdCZmZBrNeQTlN/vwTOfqu2Nd/6a864PPwSHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABDiV/3Dk2VLZvMgda/9y7/+iczubiUy+73v78us1++4dZbVXGah5TKL48Att6gqmVV1W2Yf/fxrmU3yrltno7sps3zs/B+kr19va7Dj1pkU+jkXTtbv6TYwM9vp92X29NmxzMbn5zJrxZFbZ9LR7bucL2UWxP57GRcTmX11MpZZv6fHUj9uuHVWte6738ZitZJZWfrXVqFu/7rWF2eFHmtx4L9TL4+c6agM/PEdRzoP61pmSarH2ng6c+usKl1nWevxnRX6fk5HU7fOs9NLmdW1vp9l5ve/6Uw/6/MjPYYvT/S88fqD19w6X9++I7PQGS9B4P8POUl0+1ZOP/JKDcI1/c9NryZy2iAsM//aQs8Lq+lIXzjXc2Pc9ue4ONd5L9bvJF7TeHGtnyUv9TrQiPR65+0lzMzCWu9vxk77LZb6fpKlv8aGkW6INNb3s1oztotAXzsd6ff98S8+llmvpddCM7O7r12XWSPS/WSx8ufcRqxHaZnpvWPkrHVW+fNJ7YylbyN23ndV6fFiZhY5t5yEut/Hznhp1gu3zvNnj2R28vlH+n5uvuGWW4W6P4Qt3XeXgW6j1cKfH2cT/azNSPeVJHX2PhM9lszMykJnfee7yNu3m5kt5s6ztPVe+HIylFmv58/1l0/0d9E81HXuvn7fLTcK9SawcMZE4KzrxZqNcFX77XsVo6nuC1XtdAQz++rzz2R2/br+tm73BjJrNZpunVGm2/b88kJm6/b7tbOHifp6Dbnzht477r6mv6vNzPqJnjNCZ1p48vhIZs+f+GO7N9B9/u2339N1Th+75V6c6f1+t7cls6XXx5zvBDOzZkv3lU5Hj8+e0//MzJwjGHd93u7qs4effa7nITOzLz/Ta9a30d3YkNnTT75wr82cr4Uw1WMiyPX+ptn195Z5pjt+4L0XZy00M4ud/VjifDPVzj4kdva6ZmaR6Txb6X4/db6ZRgt/79Ns6vYdOB8w79/adcud9HS9tek5OTPdtuPQX++WuW6HotbPMlus2QeHOu/29PzofVoHod8X1kxlLn6JDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAABC/Kp/2N24KbPptHSvnZUDmeVpR2aLXJ/xd9ParTOodR6mqb6foOmWW+SJzMaTQGbDcSGz1taWW+dg50BmB9GmzKbRiczijn4nZmar2UpmVaGz0cWFW+7tHV3voKXbb2S6/azy+8JiMtHZYqmLrSq33KrW/ejCqfNilslssKP7l5mZrZx2+BYmc/1Og0Q/p5lZVEcyywrdhs1Qv+9yzTuNQt0OVaXnjTDR92pmlhV6LmtEutxskcvs5OiFW2ejuyGzpNnQdRa6/Rpr3tlgQ9fZSvUceHah+7WZWburr724GOkLnb4wmeu2NTPLS93HCtPlemuEmVme67zZ0EtnYboPJWvqtOCVl+RXFlf6fqJKz0VmZmExl1la6mubzmM0E/1OzMyWU6+P6faLzZ+v81zfb7WY6QsDpw8F/nyyLPW8urHRllmn7Mvs+Zo19tPPfyGzLz97JLPh0u+bF2PdRtn8Q5l1Iz1+s0Kvv2Zm77/5UGa/+YNfl9m7b99xy81D3VfKXD/n8em5zJrJPbfO6VI/6457pS8OnT64Zr4pS53XhR4vaaLXwulk6tZZl7odaud74Gzm95Wwoe+piHQbLRd6vmm09f2YmWVpS2Yrr+1LPafUE2cuMrPV0pl357rta2c9MzNbzIYya3V6Motaeq+hZ79vHJ3pvVHZ1t8KvZv6m8jMrIz0mlenup/UtbN3XDPXF86+86oWmW7BIvdbN690H+ttbMus1XT2jv5WzGLn87nf1t8252eXbrkLZ4y+/Z33ZHb7oT63sNhvv8jZa1wcj2X2ycdfyOzkRO+nzMy+8977Oqz1mtXr6b2EmVmc6BUmivV80ujrvrBu77Ny1vak1h2pPej65c51O4TOFJe29J7q6eMjt87HXz5386uaTXR/mHjfS2bW7+q1p6712C9yPTfGTh8zM2s434YW6L7ScNZmM7Pa2Zs3nUvrypmr/GNJq5w/GAz02lMX+uOmivz2s0LPgR2njcrMLzdM9T0dnZ7KLO7r/U3k7JnMzIqVvqcq0+N7kfn7uDh0zmedcutQt23s7AfMzOpozbmbg1+iAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIAQv+of3nvwKzI7+tkX7rWdjQOZvfeD78gsbD2R2fn40K1zEKcyK8KWzEalvlczs/5gS2YvXzzWFzaaMtq7/ZZbZxFEMsuHhcwWq1pmdbVy64zrUte5yGX2xedfuuX2WonOOh2Zpanuqkcvz906Zyv9rElT94Uk0e1uZpY2GjI7OTuT2VeH+n73+vtunWFr4OZXVXV128exbiMzs6WThaluo9J03w1KnZmZFXWm64x1H6ucsWRmVlulw1D/z7F2is0yr4XMeqEep1Gt26GTBjJbNf3n7La6+n7aOuv39fs0M0ubuu2DQI/hRupc5z+KZboZrHCyOljzP2SnfUun3DDyQv2uzcws0PPuVT1//EhmZabHkZnZ2JnHokqPledP9Nrdbuq12cxstZzIbGdjQ2adTtstN3Je9yJfyKzZ0vNf0fCfZTLVY78wZ55K9Xz82Venbp2Pn41lNi31PiRwxqCZWbuv72ljU/frTqj72OHzp26dnz46klloP5JZtTxxy93u63YYzaYym0x0Vgb+mjUe635998H77rWeJNTvLQr8d7rM9XtLE923V065dazb1sysvX9PZrs335DZ5FK3vZlZ4awvQUMP/qx05sCO/yxF5uxhTK8DkbP2xM51ZmZRrfM4dq4t9b7dzCxebug6G3pujZx+Erf1nGFmdm1/T2bLSrfR0nnXZma1s1eLnKws9Zq2qv39QlY7e8cranb02nN24o+H7R39rfDwzfsySyK9xzt6/tyt8/iRXvf7A2ftqf1xNiv1s1y/tSOzlvONNl/4+/LS2eQ9/uSZzCbDmcze+c5rbp3vvndbZkdH+pxlY8vfV757R9cbdvX38UG355Tqz1OjS/2d62wdrV74ZxNJqN9pXeh5YXSs7+f4c/88Kcr+/vflZmbHx3ov1+3r7zAzs0Zbr8HDkd4DdiPd+IH5a0TofLPXTmaZvzcPnXV0nul9k1W635fO/trMbDXXzzrPnfOvUtc5Wvgfq+FKP8ugpdfR1pqT2k5Xj4lepteQxp4+z5xUF26dL2Y6T5yP9mTNnqrVcL63nGkudPr1qvD35pZe/ffk/BIdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEOJX/cPt/Zsy27w2cq994733ZHb9hi73RrqU2cnlc7fOoKplNpyuZPYrv/Mv3XLvvPamzG7d/1xmn332RGatRs+t83w0llldlDLrtdoyGy1zt85VlulrLy5k1kj9LhU4WR3pd7azvyez8UL3EzOzbKqzKE1k1qw6brlR0pLZbDGT2eHLU5k9HqRunfv7O25+Vf/Dv/mfZTaeLdxrN7oNmTVj/Tzvvv6azN5+6123zp227mfLhR7facPrgWZ1pbPlUo+JvNR9t9vbcOusAv2/zKoqZBY4o2lza+DWOZvrNkoSPSbagT++o4bO586cMxvqQXp+dunWOV3q+XE81eOwEep3ZmbW7+s2fO+N+zKLE93nY2e+NjOr1tzTVfzHH/1YZmXhdPhv/kBGk+lEZl8cncjM67dmZqHpcbbV0++k29Hr3Td024axbodGU5cbN/z5er7UdaZt534TnZ1f+uMhd7pQt7+hr1vTFSzU60BQ6H6yXOlsa3vbrfKdNx/IrJrrcX85GrrlTnTXtV98+qXMSmfL/Pil/16KWr+Y//xf/XfutZ5GW+9T4qbeo5iZLUu9DuS5nq9r5/c3cdh060z7er8wdfYaw8LZyJlZHuj7DZyFPc/0/jHKdfuYmWWZrrOT6rYPaj0HtlJ/Tqmc+bMudB9bLeZuuWGlnyWs9HspJ7r9Ork/19+6dU3X6SyV3p7JzCx3rvW+DUtnH1eX/tpd5Hqeu6p+R38bnof6O8zMLG3o/hcleh7b3N6UWdLSe0Mzs6PDQ5k9d+bkrX7XLfeNnS2Z3djSa0jidJM00fOQmdnjx/pZXhwdy2xrT3+jffCr+izEzKzX0XP5eKH3BL2ev/fZ3NL9qNnzvmP1uD8/O3frvN7T76wo9VyTVXr/Z2aWOGtaWer55viZfmcXI39tacSRm19V0tBr5XTmrz2LqZ7POw09TjvOvjNYs97Fpt/bdKbXgWrNd0Y31QM17er7XTjHWBPzx/fMWbtr03N92tRtG63pu947zS70pnTTaQMzs06q+2fsrCGNlu5/zaZ//lXWQ12nc06QrtnfBKG+tnbW2MgZo5X5a3Pt7AnW4ZfoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACDEr/qHC+e8/fx87F773rvvymxrry2zcnwis6qI3DqzSmeLrJZZ1D5wy017t2TW29OVto90G210um6dRa7LPaqOZbbVa8psuli6dVocyOh8rJ/lu995xy329Xffltnl+ZnMWm39vg9PTt06g9VcZu22biPT3cTMzGZL/V46g32ZnU+nMvvi2civNOn4+RXNZ7qNLs4m7rXlsiGzjtOPjp22f/PhW26d81UuszR0Bn+g78fMrKx0XjnFpql+lv6O7gtmZlGtO1qS6ik6rAqZlVHq1tmPE5lVeelcqdvdzOzp4ZHMjo71+B6e6jE8dfqmmVkVOmvTUPfd1dTv1289vCuzN+7dllkj1eMhTPx16x/iv9o//ewrmSXOvZqZWa37Qu1MkD3nSRpO3zMzq3Ldr4/Ger2L15TbbrdkluXOfNLQ5QapPx/HzjjsdPVcs8r1OnA6Grp15pl+Z6Ez/1XeBGdm0/lMZtlCZzcPNmTW7+jMzKwsVjI7v9Bzxm7/ulvugzf0PuTzQ13u5Uz3ky9fDN0648Bv36tqNfWc0uz647ue67EWN/TaU9a6HyWJ/1lRRbodskxft2r7z1KUej6qK72GhM4aG6yZU5qJnlNSd27V91qs23cu9DurnbaNW85e18zqyGmHSD+Ls32xsuW/s1Ws6ywCvYZUlb8PiWN9bV3rNgoC/TChk5mZRf7SfiVdZ1+Zrvl8X+ULmUW1M7ZNj+3+1oZb59139fffj/7mxzI7O3zhlvuD77wns9TZrqZLPVa6tT8ezhP9Xf7ag4cyu3b7hswSfzqxyUzvSQ+ubctsc6Pnlps7+5sk0O3w7OuvZXZ5ceHW+atv6nOf5VKfP9Sx/+3izcl1oBeQ0slWmT+fVNWaSfmKnh3p76XTF/65xpv39R6n39XnarO5bvtO4n+BBIGe5Ho9vRbGazp+Vej2nzm3NKn0PHZR+mtPY2Ogw1JPKlu7W7rMzD9Xmy31c14e6/m61fHbbzVxNk6Jns+XE72/vpzr+zEzeznWe6r9zQ2ZFXP/ez4w3YaRs8jGzvocO2uamVkY+rl77ZWvBAAAAAAAAADg/+c4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQIhf9Q/TRk9mk8nEvbasEpk1ujsya9mBzOLuhlvnbtqR2cvPXsrsf/of/1e33N/7fd1kQVDJrMr1dZ126tYZpZsyO75s6wtn+n8kg0Hu1rnMdZ7npczu3HvLLfe1e2/oOheZzCbjS5mNRlO3zvlSP0u/F8hs0B+45WblXGbtdl9m1c4NmaU2dOt8ee6Ptav6b37/92W28ruKDeJIZoEVMms2dP9MEl2mmdlyuZDZ5XSsy23q68zMwrghsyhpyezkxVBf1/LHdxjqeaNV6LkzDJsyi9ParXOVLWWWxrrcutL3amZWVSuZddq6bXfv35VZUekxamZmoe4rRy/PZHZ2fOgWe21fj9NGqttolet5LI30+zQzq4K///9rD5d6vt5s6ecwM2s6txsE+r0c3L6przP/fR49eyqz4VxPRnv7u265yZbea2STkcymub7frd6eW2ejrfdNRannxoVTZ9Jy1nwzs8SZsAtdZ6ep90xmZq2W3sNketjbr37/OzK7e+e6W2dd6LH08x/rufzsUPchM7PO++/K7OGdOzL787/5ucyqxB/bWe2vaVfVcJaXtOHX2Ta9piUNnVmly52N9F7NzKxo6H402NFjOOn6/XPlLHlxoPt97MxjifntVzlzWTvV611Ve+uovwYscv0sFupG8Obrb+ixVtb62maqO2BV+fuQ3MmzyntnbrFWl069zn6r1kulxaE/vqM1+VV0nL1jtvC/e/JSrwNe/8sq3QiN1JkTzOytt/X339OjY5ld1P5HRrej26Fc6L3s0lljm42uW+ded0tmb/zG2zLbubcvs8vpc7fOpfOtWsz0+Cwmaz7SnHV0vDiX2aCh59zNm3pvY2bW39Lt9+xMf6NVkT//BQ09zuKV3ogkzmY2TPwJpS78756r+pO//KnMdvsb7rW/8T19LjQ8O5XZcjqTWff2NbfOpOF8L5S6jcI1J43eN3sR6ncTDrZl9vod/yxqNtH7x5fPnshs5Cy/UdOfU5qb+nth5XzbFIm/90kivU9ZOovaxak+T/ryie5DZmbO7Vrh3E+85hO39PY3zvmDt5dIojXj29+muPglOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAI8av+YWGRzFar0r02n49k1knvymy2LJzrGm6dzXAqs9vXWzL76OMv3HJnw69ldnkxkdnp+bnMDq6/7tb55ltvymyy0s/5808+k9n1vW23ziBMZPbFJ7oNbh1cc8stC91X6jKX2XSo2zYMArfOtNGV2ehSt9+6PtZOdRtZ1JfRRlO3QVI5ZZrZ+emRm19VUjv/T8tW7rWtRE8jG1tbMoucR13MZ26dRaHnhhdHuo2qSM9jZmb7116T2fOjJzL7gz/4Q11nrOcbM7NetymzTk9njWZHl9lK3ToHPX1PP/j+r8hsc1P3azOzt+/flllV6T4WOfPNYun3vyTU7/TOtR2ZXd7edcvd378hs6rUYzh0pqMw9pfcuqzc/Cra3Q2Zbe/683Uc6uccXZ7KLFtlMqudsWtmZk4/2d7dl9mN23rsmpltbuo1Ly+XMju70PuXsvLnk9CZ5KaLhczmS30/s/ncrdNbDpO4llna9NeeONZ982D3QGY39nW7b7b9ubHTGMis+6u/JrO/+qN/55b74rmey29v6zmunJzpbODPJ2lTz+XfRuws3ak3GZlZ7qzdk+GFzKZnxzK7PNWZmdnulm7fO299V2Z7m3q9MzNbZnquWjnzURTqNmjGfvtVpvM00eOpDvRLK8s186Mz5VSVboNgzT45CnX/rGtn3nDWtNr0dWZmVaWfNXL6bhr5v/8KnT1BHOnnrCo9xzUa/trdSPy14Cqml2OZFXN/X1TVui8MT/XYLpzr2s58YWbW6ev5+je+/z2ZBQ/uuOXGte4nq/NLmTWd/f6mM+7NzCYXL2U2z/T9lM7WuxP5+/Km/gS2xUzXuW6eT0zPnReneh93a6DfZ9rzn6Wc6W/rblO3/ZMXeo01Myucueia8010Xur91qDrj93Ngf6O+DY+/lqvlf/Zb+i9rpnZ1r6+pyjQY/j1h/dk1u/13DpHw6HM8lx33uFcX2dmdr7Q77S7p/vgzvU9mW3t6OvMzKZjva/PnGf5+S8+kdmjl/7e5/Y1fb/exj1ZM763enpPlU/0OFw6n5u5s7cxMytjPWbOhrptN1N/7e4452refiJK9P163+tmZkXlTLxr8Et0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQIhf9Q/bSSSzxCr32v1r12RWlLXMPvr0icxaw5lb58ae/v9A0mrKrNlYuuU+e/K5zBalbqO9Pd0G1ui4dSYbGzLbOdiX2eDoSGbTZenWOV/mus5rus52t+2Wu3DKHU8XMhtO5jLL/e5neaHrXOWZzEIL3HLbPf2sW42WzJbjqS4zarh1WqnL/Tb+t//9j2U2GY3dazfbqczqSr+cvevbMrt/9zW3zv2dnsza/U2Z7ewduOXWgX6nw+FnMvvs68cyG6/0HGdmlgZ6rup3dB9sN/W88cbD+26dm28+lFmvpftgGvhLRhzo+53O9fi2QLfR+dm5W2dghczCVM/1nY7uQ2Zmp+cnMrs4P5VZnOg+9ODuDbfOINZryHbfv1+lN9iQWRj577Mu9DpR62a3s5ORzKbTiVtnGOp76jn7kMMXL91yh2O9Z9jZ7sssCnWdq8wf26vlSmZx5OypnH47iBO3ziDU95SG+n02G3657a5ee3YHus+3Ez0njE/0HsXMbOEswa2WrvPa7p5b7qMnut4b13WlufO6z470nGBm1nLa79sITN9UuOZnMqEzX48megyfn+q58eTlc7fOTz/8icx+9MMfyey99993y9298UBn+3r/XTvvtKr88Z0Xen/jdHszZ46LI3/fmZfOniDVY7hct1F2+krtfC6kTh/KK/9ZLNL3mzt11mseZeU8axbpd1o736NuI5jZcqW/Ja6q6ezFtnb0/tnMzOu6WaEX7yzX2dmJvxdrpfpbYH9jILOw9tvu8kiv7ZtdvXYnpX5nyzVnCPtbOzKrY92/Lp/qtSUP/D4UO/vrQX9DZs1A7yXMzNKG3k+0tnUW6ddpJ2fHbp2Trr442dR9t9/096SRM09FiZ5PikIPiDv377l1HuztuvlV3XDK7bf8c6HTYz0Wm6Fuh7YzXqYLfxxW3pGhE80yfyOSm+4rW/0tmXWd9z1+/sytc3Ki55Rrm3quCpz192Llnx/uX9fff+Vct733XW1mFrW7MpucXchsONffJ+Ol84Fn/rmbs7xY7ay/ZmaVt+47e93MOWcpnHMoM7PCOUNYh1+iAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIAQv/IfRpXMBv2Be+1GpyuzOkxkdjHTZRYXbpW2tdmUWWilzLJ66Jb74uREZs3elszuv/+ezBYWuHX+h7/8C5ll06XMBhv6fmxWuHWenT2RWS/V3WY2unTLHfY6Mgsi/c6avU2ZbW7lbp35aKzL7fdltm5w9PptmbXbDZmdzfT9VpW+VzOza7utNXd1NX/9t38rs35Pt5GZ2ceX5zJrt3Q7/MrgBzKLnj936zzXw9Aevv2mvp+enovMzEaTTGatrm77D773ri5zrseomVmz0ZPZ+2/eldnD+/dldvPaDbfONI10WOj+eXTov5eL0UhmT58dyWy1WMhsPPHHRFXrd1Y5/ydutvR8Y2Y2X+r3VlV6Pez0t2UWJv6ssjnQ/fPe9T33WiVJ9Ty1WOnnMDOLnThKdPuVeS2zINL3Y2ZWVnpPkDT1OrCzr9vdzKzV1vX223pdGmzosRIm/nxcOv0kDHSWl3p93ujr+cLMLAqc30bkelMVB3pfZGZWruYy66b6umKk62xEfp2mu5ENF0OZbV6/6Rb70z/5U5l9+NmnMjt35qKpvw2xyBtM30ag949pqtdfMzNr6L79xpsPZBa/8ZrMxmenbpWf/d3fyOwnf6uzP//Df+uWe+3mXZk9ePu7Mju4pa+7ccNfR9upHmtRpN+L1xOiNWuEN75TZ8Dklb/nn690Xle63KLU91NF/u+0Kufbp3YaKXfmVTOz2mmHYs2UozSq/+d/c9Zo6vWlt2YdsNBZt5ysyHUDnU/1Xt/M7JrzzRnWeo9Xng3dcmtnD+3t2SOnf20536JmZoOO8z3a0PPqdKbXybzwx2C10otIPtTr6LL2zxBWDa9efe3ewYHMtm9tuHUuKt0Ojz89lFlrwy83buo98sTpJ6tAzwm1sw6amUXOmce38avv6DV20NL7YDOzn3/0mcwePrgls2Wu586Vs2//JtfXBs661OhuuOVea+szxO0tva+vnLF2+ezYrbOe6L6S7u3L7O03XpfZ7r27bp3eWcpioufHas2iNR3rc7fQ2QOWge7X4Zo+n8bO+lLr+cbZFpmZWbet5935Qs+PmdM388zfnJdr5mUPv0QHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAACF+1T9ME/2ne3ub/sVBLaOqCGS2u/9AZh89e+JWmbX2ZVZkI5ltbeVuuRaUMtrZ0u1w6/Y9mdWtrlvl0bMjmZ1dnMksyzOZTRY6MzOr9WuxZqTboBn65WarscxWy4XMprOpzI7PdZlmZqOpzrcHfZn1nczMLKoLmS0n+n7jaiKzQcOt0hpN58V8C5cnuh8tZ/6YuHPrmswevqH7fTPWz/LzD3/i1rnZ1v//Cyr9Xk5PXrrlxk09Fvu9tsx+65/8pszaznVmZlFLv/S7B7dldnZ2IbNPP/+lW+dopMdEPtV99+XZ0C13ulzK7OxcXxtZJbM69P/X226nMssq3ce2t/zx3WzrvrC9uSWzRrsnsyjx+8J0pefWq9rc3pVZWei12cys19RtW+X6XSdxJLP9g5tunY1Ut1Fluty14yzVz5J4exRnMQwjfT9mZkGk902Rs5eYzucyiyM9VszMvOGSxE2Zjc78ufH5409l1m3o57zW03Vu9P131nLm49FC97/OmrW7jDoyOx3q/daNO3dlVuR63TEzGw71vPptlM4cV/rD26zWfSlyfmMTRbrO/s6OW+U//91/KbM7d/We/yc/+ku33I8++Vxm5xO953pwcSKz0L7j1rlzTe99tnp6HchKPW8Umb+HXuV63ihLneXOdWZmgfNOS6cv1IF+lnrdcuZMn27XDfw9Qe10/CB05nrnfsvKrzNb8+l4FQtnjZ2s9PeSmb82dU3Pj83YWbPKxK1z4ez/Gq2WzPa29X7KzGznvv6O+OWHX8vsh3/21zL73vcfunV6PXA1ncls99qezHo9f11aOOVeON+5q+WaOaPSfWE21/0oW+h9SK+jz1jMzPob2zLLa70nOBxeuuVmtpJZGev++fjZucweHeo138zs+pbeQ38bN51vkMmlv1+YON9pZaW/KZsNvfepS93/zMxWmTMfzXUfbA30Wmhm1m7p/tBs6z1iUes5+bUH9906z451P0ti3X6dxDmkaes5zsxssdCLRN+5Ngz9c58y0+P0hnM+M1rp65pr+t/S+VatVnov3B34553XdvW8MnPa7/BQ7+OKas1GuOmvax5+iQ4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAQvyqf1iFDZn1Nrfda8ui1mGgb+He3bdk9pMf/9it89liILNBW2c7O869mtmjr1/I7Pr112X28c9/KLOXZ3O3zheHj2V2dvJSZkWgn2VS+f8/adUrmW22dBYVz9xyXzw/kVnaasvsYFdno3Hq1jmfRzJbzpYym1jglpvUhcyyxZnMthuZzK613CptFfzD/N/r8JcfySxq+jf1+7/z38vst37rt2T2t//p38lsI9Z9zMxsr7shs0agr20Euu3NzHY3mjLr9zu63LbOQmccmpklqa6zrHQf++XLpzI7PD1161ysFjLrOONwcOuGW+5+qyezW5kzb0SVzmLdPmZmsTMmAtNjv9/zy+31uzJLYr1ujaczmR2fHLt1Zkv9XuyDN9xrlU5Xr3fz2cS9tt3R/XrQ2ZNZEHjv0992tDuJzOpI70Pq0C+3yPU9BYm+Noh0H6pCPT7NzALTeVXpd12Vug+dnvljOzL9nLHzXkYXem02Mzt+odf2/W1nT9U7kNnc2xuaWZbrNXhlet2fX0zdcm/duiWzNx/ek9nbb+kxePj0sVvnzz78pZtfVVjrNmyG/n6hctamOtRtH0d6vBS5v8aGsR7Db7z3rnNl6Zb79TO9Nz85OZRZthrK7PkTvS8yM3v7rXdk9s6b78ts5/prMgsjPf+ZmaXOtnRV5DKr9ND/pt7YmXedtq+8fXK0Zr9a6vkxDp37KfyHqZ1bCr0x4cyPlTMezPx14qrG87HM2j1/X15Uztxa6/fZbup5NR3oPZGZWVbqcqdL/a01PTl3y+329BnDG2/oMfjhjz+V2cnQ/+7e2tuVWSPWbVSY7rdPnuo5ysys2dDX7t/Q99Ns+N/ApTP4RyO9Vp6dj2T27NDZq5rZu9vfk9mdXb0GXJxfuOWOz/SYqFt6TEyc9WEr9sf2r36gz6K+jU1vqk/9ubNs6u+X5VyPtbOzS6dUfz+2XOhvOK/cQervzTf3tmSWBXpezZzbDf1HsVWu26h2xkuy1GMiLP1xGCz0mJk5a3dvoPfXZmadvu4LRaXLHQ2HMps637FmZmdjPW90nKUwbPnP0ujrMdzd1uvA01N95nYx0nOGmVmz88pH4f83/BIdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEOJX/cN2vy+zje1d99ogTGU2nWYyS1N9xt/rdt06j19cyOzOr70ts6SfuOU+enIps5PLicx++Yd/JrM6qNw6o7qW2Wq50Nd1NmU2XORunUmjKbPX7z2Q2cc//dQt9+MvH8vsB7/xT2UWJwOZHT87cus8OtF9oRtHMstbfl+4vdOR2f5Al3tzoIddrzF36zyeFW5+VcPxWGa/+Z1fda/9wQ9+U2abezdk9tZ3/rHMvveBzszMtnq6fzaaem6IO/68EYT63dTOvxzzopTZdKrnDDOzVlcXnCb6OW/ffkdmu9ffcuscjkcyazpjf+VPGxYleq5PG854KnW/ni6Wbp3z2VRmeaHn1sux/16eHR7LbJnpOpdL3RfC2p/r00TPG1e1dNqn3ey51wa1Hg8vTnX7jIe6bcNA9xEzs4cP9fqysb0ns8iZy83MnCFqhRMuljOZVfXKrXM+1XuCKtNZXeqB5u0HzMzCQOcb2xsya8YHbrmNIJDZVr+t6+y2ZJbl/npWOM+6WOm2r80fZ92e7vdtZ995cnwqs7zwf5Ny//49N7+qwKm2rJ1Ob/6vaOpSp0Gk+0K45rOiLHTfXjjz9fXbd91yb9zV+emZM5cv9Piez4ZuncOzc5l99tEvZHbj3n2Zvfnmd9w6270tmQ029Xda0tRj1Mwsy/V7yXLnOy3W83ld+n3BWV5s4Ww24sof35nT7dOmrjQv9HyThv68W665p6uInMHd7+jvDzOzdlfnoTOXe6vo8EJ/S5mZNRt6rp8Xeq5vO3OCmdlHn34us/t3H8rsd/+r35HZ8690mWZm5txSr+esac5ednPLPytZLfWadnqs55pwzbYxcfp8Heh9+f7Bvsyml/636qOvH8usDJ2+0PX3pJfn+tvlYqzb6NZrd2X29KnfFz5/9LWbX1XsrHd7a9qh09Lje6Or1wELdGdJW35HSlKdPzs8kdlq7u+Tm87a9Okvfi6zixO9H3vvvv6OMDNLI71uzYf6PGTo9PvcaR8zs1Zbv7PxVH/nHh3736or02vT08MXMvvyq0OZvbzQ3ydmZgtnOUw7+n3mK3+dLJ240dLl9jZ3ZPbsRM8LZmb1Qu9v1uGX6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgxK/6h1VQyGxrd8u9djyeyazd1tclQVNm9x6+4db505/9UGaL3PnfQXPDLfe1978ns0ePX8jsq88+l9nv/c4/duscXQ5l1mjqNrr+2lsye/bRl36dc/3O0s6uzDb2l2657/T2ZTacZDL7+ouPZHbqtI+Z2SKby2x3f1tmSTV2y93f6Mhsq6OfpZcsZFZmU7fOOhi4+VV9/3v/SGb/+l//1+61Uaz74PPDY5nloX6WxOnXZmaXZSCzYFbJrJ77/XOZ6XnOgkhHga5z4sx/3xS7ktnpyZnMikw/S+7WaBYmun0XC30/Lw6f++U62dbunszylR4T58NLt86z8xOZrbJSZonVbrlpot9pp9eQWbut54VWnLp1RqbrvKo00ffq9S8zs8vTl065+l67Az22d/d33DpL/cps6fTNNPK3MxcXuh9lS93/Kmc0BaH/vlLnlnpt/V6aqe5D655zNZvILHQat9tuueUm127ozJn/KmdSCGL/dxxZpcdo5I2lypnHzWxZ6vd9cjaS2dmpHi9NZ5yZmd1//aGbX1Wc6DaKQ3+O86bANNFrrDnzVBR715l5t+Sto0mn55a7ubEps6rQ/d57b1nlj++q0vPRxUT3lcufXcjskw9/7ta5sbEhs51rBzK7ceueW26jr+fs7W29dicdPQ6jNHHrLJz5M3T6WLF0Fgkza+itmtvHIue6uvbnlDVT2ZW0W7rPV6V/Pzf39Xw9X+lvIqt0256+OHLrHGzqPlQX+n5bPT12zcymK31Pn36uv61/55/9c5kFmV4DzMwef6HLbTsvu4501t/ou3V2OxsyW8z0urRmmFke6O/R0Uh/nwShHhBRw9+HLJ05d3ipn+Wzw8duuZfOHrC5syGzrrNnv3Xvjlvn1p4+t/g2OrF+cUXtr6OnY91/A2ePmHY3ZBZW/pdjZvp8Ineu/eSLR265b76lz/PmEz1Xbfb0eNrZv+bW+fzRM5l9+MlnMuu19Bw3XPrnN822ns9HKz1vHJ+fu+WeO+d1x8enMptM9HWNpnM4a+Z+7Pfbek8QmN+v252uvqeO/kbZ2tPn0NOP/P1CPnPWwzX4JToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACPGr/uHo8khmzWTpXpvFuczCOpNZVVUy62603Tp7O7sye3Q8ldl2R9dpZhY2d2R2cKsps/OzS5ldjiZunZPzhczeefOhzB6+cV9mnz7T92Nm9vgL/b5PTi9kttHecMs92G7J7Md/87Gu81zfbx6mbp3dTd0Xdvb0++wH+l7NzPa3ezJrR7XM8mIus6K95da5WDTc/Kp++/f/S5nt37nnXvv4+aHMhmPddzPT761YFW6daZzILAh0uVmu297MLK/0/xWjMJBZGOj7qUs935iZZYWec4ZnZzIrc2fuDEu3zn5/Q2arlZ6vh6OxW66Z7veXQ90OdanrnGcrt8aZ01fCWC9x7TRyy030dG51oPtCkev78a4zM6vrV16SX9n5+VBmh8/1PG9mttHX6+y91+7K7NqNA5m1ul23zmyux+hkrNeB5dlLt9xVpsdLt6tfdqej14F22197GomeT9qpftelMx4Wc3+/NV/qa+NQ30/szH1mZlGkx0tR6Pmmmeo1K0n8NXY5G8lsNNXzyWyirzMzO3P2MOOh7mOTiZ7/tgYbbp2N9nM3v6qgdvasa+abqtTXFrl+p2lD94XKWQPMzMJIr5WpsycYjU/cck+PHuvsTM9z85mus93x56peRz9Lp6kzbyytlnqeMjM7PHoms88ffymz/C/+3C03dz4Ht7f0vvSD730gs9fuv+7Wub2ry220+zLrNjpuuY2GnlfySrfvKtfjoeHsOc3Mgtofa1fR7elvjCj09y+lM7ZPT05lFjpbkJmzNzQzK0czmfVa+p2tAn/OaHb0GvLoqxcy+6Mf/lhmv/62/11zo9T7uG6iG6nV0e9slfntN53r76UNZ31pOHONmdlzZ84oSmePEjvfaMWavuCc31iq73e08Pf7mfPbz9GFc07g7Km+/2vvu3Xev3fXza8qjvW+czbxvxsXU31uNJnoPfT1UI+lqO2fL7Qjfb9pf19mH/3tn7nl3n7tK5nduf+GzOJCzxsvz/1zteOjc5ntdfdk9k/+2a/J7Isnj906P/lU5ycv9f7m6Ut/P5uFzvzp7DVu3bgms7TpfACb2csLfU8tZ34Ma3+ubzvfh5vXdB+bOmt37OxXzczmK/+bysMv0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAACBQ3QAAAAAAAAAAAQO0QEAAAAAAAAAEDhEBwAAAAAAAABA4BAdAAAAAAAAAAAhftU//PLTT2X2xoP77rWroJBZXcxkljbbMhv0um6dzU5HZpvbezJ75/5Nt9y/+k8/lNnLJ09lVmW1zE6HK7fOO7fvyuz+Ox/IrNvdkNn7D3SZZmbVpX6WZ4919su5fp9mZicL3RfyXLfRKkxlNsrdKi0qdF95NtF1vnlt2y131erpLA9kNikbMps6z2lmdl78w/zf6yc//7nMfvHJJ+61YdyUWZLqZ00aOmskLbfOIHCmrkiP/Tqo3HKbqZ5zmqF+p2lb94U00X3MzCwMdftt9fRcVZl+llXtzylFrq8tVnpAtVsDt9x8NZTZcjKWWZ3rOrPCb78o0WMiKkqZzRZTt9ylEzfbkczSgdOHOolbZyd95SX5le1e35fZYMef4zoNPR81W/o5l0vd/+bzpVtnq6HbIHD6vFV+n7+2p5+109FzkTnjPg71emZmFpT6ns5fHstsNNKd7/DohVtnsdRr8DtvvCGzpjNXm5kloW77sKH7dVXr67znNDN7eqj3GmeXpzJbLBZuufOZzmcT3X5xpPvCxfTCrfPkJ8/c/KrqQvfBJPL3C17vLUo97wa1bocw0JmZWRDpuTMvdV/5+MOfueUOz89kNujp9fniVL+3uvKfpdPYkNlopvvRxkDvSYPE3wN2U7036gR9mZ2c6PFiZlYXel4+Of5CZn/1589l9rOf+N9p5vSV1x48lNnB3g232P3rd2R25+ZdmTU6uv1i3W2/uTZd8wdX0HT2lUXur3ePvvxSZstCz3+dgd4/t1v+GjEajWR24Ky/T54/dsvtdvS+c//mrsx+/Isfyyyu/LXng3f1Wtlw5sa2887iqV9nOZrIrKj0Xjat/DmjEet3as5+K4l0Frb8/j6a6fm4qPQ8v3NN71fNzIpY39Px7FxmNw/0nNDZ9ffBZ2v2KVdVOfuJdld/F5qZ3Whek1mnq9sorzKZtRKnn5jZotDfaWlH3+/HX710yz35N38gs//iX/yGzA52tvT9VP5343Sq17va+X4ZXlzK7Fpfrx9mZsddnVeHhzIrc38/29vbkdlesiGzpPb2jv74fpnp9ltOnJ3ljn+GEDljYrCh9xO3TO8Jdnd0+5iZHZ+euLmHX6IDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgBC/6h/+4vPnMnv9je+719bhSmarxVxmaVzKbHRx4tZ5/lzf769/79dk9nu/+6/ccu/efldmP/zhn8ns5OSlLvPhQ7fOnc1dmXW3BjJblZXM+gd33Tpvvqnfy+HTL2X2+Iuv3XJfTKcyi5OuzAYH2zK72d5y66ySls7qTGYvq9ott77Qw6csmzI7z/V4KILArbPSr/Rb+fGP/qPMRheX7rWNVD9ru92RWZXo6+LQn5rqUr+bJEpkFsSRW24zacis19TlWjPVUW/PrTOJ+jLrpLodqkS3QRXr+zEzC01fG6yWMhtOZ265tTNkyiKXWeLcjyX+mIhS/U5rZ7xsdvw+ttl1+rXz7+d2qCsNSz3fmJmFr74kv7Jlrtu93dF9z8wsjnXbr5xnCQJvnK35370zB4aJLjfM/HLnS72mLVc6ixJdbsvJzMzyQs/1n338qcwePXois6LU79PMLHKG0o2D6zJrd3tuubVT72ym2298eSGzi4uRW+d4NpFZUev9YbZa+OWOdb1Brftfq6HnhJeHL9w6L9bsWa8qywuZzRd6Ljczi5y1stTFWh7qvrBm22Sp897OznVfGY/8d/r6g7dl9oPv/0Bmf/OTD2X2s49+7tZ5dD6WWerMnXu7t2T2z/7xP3HrDBO9Rjx68kxmF5c/c8u9cVPvozc39HfG6PJUZk8Oj9w6vfWlv7Ejsxs377nl1pWel4cXzjtb6rW7N9DfJ2Zmq9xf26+i1dDv+onzjWtmdvxC53fvHshssKWfc77Q87GZWeAsh42ODtOOs7c2s5cX5zK7ffuOzK7fuCazJ4/0d6yZ2YOb+rt777oev8ul7gdlqec+M7ONTd3nR0PdBqOR/q42M4sj3faFs35Mh3pdj2N/75MG+lkrZ5OSrNlTXThr+63XH8hs7+5dmc0X/jfucHLm5lfVauiziWDNN9xqrOexxUi/t2zufN8V/gHDS2euf/RYrz3OJ5qZmY2Guv3/6I//SpfrnD3c3tFrlpnZhtP2izNnrDntfu3AP4s6Gulrs1jP9fM1m6qZs6Z5w7QR6nK3Bn777WzrZ00qPfYj75DAzEaXui9cd+bPdlP3hX7f/7Z5cXTs5h5+iQ4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAQvyqf3g01eftp8vUvTZq7ugwO5VRXujLeknPrfP+jesye+/1GzJrNdxi7YMPXpdZlSYy+z//w1/I7MPHl26drRdLmYX1E30/VSmz89nCrfP8dCiz2VB3m2xw1y13a6cps7LSfayK2zIr4pZbZ17p+w3DQGZnde2Wez7X14Yd/ZyrKpfZfLVy69xM9Dv9NnZ7uu2Lqb5fM7Mq13mv3ZFZ3NVtND7X84KZ2eR8qMNSTxx56T+LlZmMklC30bKMZJYO9FxkZmaxnnQKfTuWdPUcGDqZmVk71c+S5Hq+KdZ0vyDUzxI57deMddZp+P/r3drWz3pwoNv+1sGuW25UO3NkPZdRXOuXFta6n5iZddYtQFfw+NEXMrv/+pvutYO2btuy1O8lCvTcWJWVW+fR4aHMlsupzBbzmVtuVurOmzsD7d5rd2TW3PP7UO2NF2e96/X6Mus78+Y35ep1K1vq5/zqyy/dYiezkczy0qtTr2mZt8kzs+VKj8E8088yHg3dcotM31MU6WcZnp/I7PL4wq0zL/S8+m3UzvQYOfsbM7PA9LMmzpzszeWBM87MzMzZL+zu6G+F3/6d33WLrQvdl5JIt8M73/01mX348WdunQ3nCyoxfT9bW5syu/uaPyfHTb3fvfPwXGbXX3vLLbfT0XPOxtaGzMpCj9HpbOLWuXLmo93da/p+urr9zMxqp9sngf5OWzl7/sp5n9/4+/9N2nyq17Thpb9HjkyPw42e/p4Kcj03tlP/W3+S6n3Rybnum6+/89Atd3ih2+Hw+XOZHRzo+aS1ve3WWTjzSTbXc7m3h8tz/8glcs4Q4oZe9/OJ3heZmU0mzjttOnU6fdqb+8zMKmffXq/0GtBp+d/dDWf72B/o781VrvvQ0eSFW+fAX0avLIl12zvbODMzWzl7mMKZAEeXQ5l113w3Tsf6rOr08JnM3rt/4Ja7vaXH6ZPnes91fjGW2ScTnZmZ7Q30s+53BjKbx3oc/tVXj906n78cymwV6G/DiXOmYWa2mOp1NDDdF8qFHhPjhXP4YGa39vU7azufuUun35qZPXv6WGbbt/WeoN/V8/lG1z8j9D/UfPwSHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAACE+FX/8ONpIrPGj75wr33r9pbMrrW2ZdZp6DKbzUu3zn/66/9IZt95822ZVUXllvvp4bHM/u2//xOZ/R9/9mOZZWHLrTMMdNuHpu83q0qnUP/VB6H+/0pQ6RezcjIzszBtyyxOdTvUVS2zMvP/F1QFOk9Dp20Dt1gri0hfmzVlllddXWYwd+ucrTL/pq4oTXU/ajb8vjIvFjKrcn2/d6/v6EJ3dRuZmY1OT2R2fnYhs8vJyC13Os1ltiyWzpW639dWuHW+/c6bus6xvp+vjqcyW838frSY63vqZCuZhYn/XgYNXW+v05fZrV29Rly/se/Wef/BnsyiUL+X5Xzoljsan8ssjPXc2m4NZNbv99w6t3f0enhVi8VEZtlcZ2Zmw0D3kzLXfbMR6/lv5VxnZvblV5/L7PJyLLNmS8/lZmZxnMqs09RzufectbfGmpk39K/v6fkvTfXis5jP3CpnSz1+nzx7KrPSWWPNzOKWXgeKXK8fRa7vZzgcunWOR7p/Rs4epiz8ddJ7p9lKz2GLic4C8zcMccPfG13VcqH7w/lQr4VmZg1nPq+cvhvVOizWDIm61m2/cvpRHPp78+lEr89Jot9Nnuv94bVrB26dSVPvWfWMYlaXOv3y0ZFb53Sl26/d1WtPr/+aW25d6/Y7vdRZs6n39K3eNbfOONH7saMzPW8cHvptlDrrfjvV89zKGcONrl7TzMwWmbc/vJrLkf7O3dxw9s9m9hsfvCuzew9uyexkpNs2OdH7bjOz4FL365NT/a4vx37bNTf1/vD50VBm+ctTmX335h23zm5b71cXY733TkpnHSj9NXZ4rufrINL7lzD2zxAC03NGf2NDZtl06BTqP0sj0fPqdKW/GZuRv47e2N+UmTPs7fHLR7rOnv+Nm6w7DLgir9R1e6NOquejpKvX9fmFnlMK53vdzCxy7vit1/ScUtd+X7m80HNDsKXXl9d29Lyw4bSBmVnljMXY2VteLHTf/fTJS7fO55d63ggTXecs99uv3XHO1Zxyl7V+n4cX+lvLzGzunEXtDPT9vH6w65Z7+nIos+dffCWz7hv6Oa8POm6dfef7bx1+iQ4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAI8av+4UXeldkf/+RT99onTxsy+7V33pBZcntDZl8/P3Lr/O077+hy202Znc7dYu0P/+iHMvuPP/1aZlNryawVt/1Kw1pGtVUyqyr9P5IgCvw6g0hGi8VK1xkmbrFVXsossUJmYa2vC8LUrbOR6HtqNXQWOXWamZl+LVZXucyWRSazonQKNbNec01fuaLDJ7rvVmuaIcv185yc6r7SfaSfdbffcetMiqnMUlvIrA70/ZiZRYkeT3nhvJtQ9916euzW+dvf+29l9oO33pLZ4VNd7suXun3MzIpyKbMw1+3Xaep5zMwsqmYyGwz0GjJo92WWBX4HfHH2ucxOTs9lFgT+HLi1vyOzxpa+38F2T2b9Hd0GZmadwd//+G6Geh3I5hP32lWtx0OS6Hm3LvX8l67ZdfR6en0OnH/7d7r+nNFKdbmdVBdc5/pZPvnlR26d49FQZpORHqOF0+6pc69mZmGk1+5mqte7MPHHw3gyktlkovvRfO5sqvzlzjZ6erzkKz2Xj8b+Rq4o9DvNMr2eRU77rZZ6TjUzCyv9Tr+NP/n3fyqzynSfNzMLY92+pTPtZgs9z9uafVNR6rWyrHUfzDO9Ln1zrc6iWI+J3BnfRe6/s8DZ7zadtbI/0GtLz1kLzcwy3XxWVDqMY3/iDZz+GSa6H9XOt0QYr9mbh/ra2nTbBs78aGaWOM8aOHuf0lkrw5Y/P9a5nh/N/oV7rbK7N5DZdt/fS3z3zYf62l3dx7an+p3FHX9sNwZ6Th5s63LLsT+2nx/pfdyms+5vdnX7jTN/vl6YnheimX7OZqL70HzlDF4zK5zv44Yzh5kzp5qZBabL3RzoNjor9XMuxmO3zsuRXoMXmS53OLt0y102nX1T4pwvhHrOGDT1GZWZ2fRY979v4+jlS5ldnvh13rp9Q2abG3pu+PzlicymU/974NrtA5m9+b33ZXb02D8jfP7L5zK7u7Mhs8g540qdPm9mVjn5tNR7wGCh26jb99fuHed3y8OlrrO15rxuUTjnGrmz3nnfGc65mZnZyUSP796mnlPyNeWeOWMi/6nuR4mz1z3o6fsxM3v3vj6HXodfogMAAAAAAAAAIHCIDgAAAAAAAACAwCE6AAAAAAAAAAACh+gAAAAAAAAAAAgcogMAAAAAAAAAIHCIDgAAAAAAAACAEL/qH27u7MtsNAzca78+OZNZUH0ks7C8owsNG26du9f0tbNS3+9PP/qFW+5f/M1fy2y4qGTW6W3JrFgt3DrjUP+voy4KneUrnVni1pnnucwq0+3n9wSzMHCudbIo0u87Sfy+0O70ZBbHXtvq92lmVlVOG4W6fWunlW7s77p1dpu1m1/VtevXZPb08aF7bZHpdigr3T8ffflYZsO2/04T0+0wmy9ltqj8HloU+lli59IiKJ0yh26dX/7wL2X2213dP99udGS22Gq6deaZ7tuXtX7Q2i/WhmUqs/GlXge++OJTmZ1Mp26dy67O+t0NmW3s7LjltgcDmYXtlsyipn4vSUtn3/zBKy/Jr8zr8XWp+62ZPyfnhR5nq5Uen3Xl19mMdRvULZ2tlnO33NHlib52PJJZ6ayjFvnzcTPR4yGO9LOksV4/EqdMM7PVSs9hF7OhzJaLmVvuwtmnhM4eJXb6UJnr9cHMrIh1X5nPdP+bzvw9VVDr91Y576V01ro48t+LlZmfX1G3o/tKUfjrXR3qdigTfW23qfdUVvvvNAicOt3JyqnTzGrvnTpzjpeFgb9PdmdXb68b6r4QBv56F4X6flcrPQdGgf+bqbqMZOYtE7kThs7+2swsD52xlus9ShjqezUzS5w4W+q5oXK2/Fngj9/c/PnzKqYLPZZWs1P32irT69bBwZ7M7t7X+6IH91936wzaugGbZ5cyK/vOJs7MJnN9bebsZftb+rvmWkfv78zMVsOhzJoNPS+czvX4/fLw2K2zGbdldv2arjN17sfMLI36MpvOvHMCPZCmk4lbZ7bQ46XV1fvn1fDCLffDR1/I7N6+fs60q7PLid5LmJmdXfj3dFXePm9/zfdJWOt59/xEzw2x6fGyWjh7XTM7P9F76NDZq+3des0t997but6dLT1OJxd6zn3x1XO3zn5H98GBt4A4Zw9VR49fM7NOot932xmHw5n/bdOs9Dq7dL4HilpfF5b+t03PedbE2WucHus+ZGZ2djGWmbe1/PBn+iz5zp27bp2bW5tu7uGX6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgxK/6h0nclFma9N1r5+FMZs+HOvvLjz6X2W++/4ZbZ//mXZkt81Jmf/3RZ26545W+Ng8TmUWRbuqkpdvWzCxbLHSdi5XM4kaqCw3X/P8kca4NAh1Fug3MzMJU52Go26GZNmQWefdqZpmTzWa6/VZz3TfNzOqglll/e09mu7vXZNZp+s9SL4duflV379yR2XQ8da89fPZCZkmk+8oy0+07LnO3zsT5/19eOmPUdGZmVlmlQ/26LXWy3LvQzL740Z/K7Hil236ro8dE88yt0oK2vqdpS7ftYe6/l2em56rhZC6zVRDJrLF/4NZ58NpDmXXaHZkVpvummVnhje9+V2bdjQ2ZNbv6fszMaqf7XdXk8lRmq+nQvTaO9XxUFHpmzQs9r+a5zszMipUut3IaKIp1HzIziyP9PmNnTUtTvXaHib/eOcVa7rTfYuWsS5d6HJmZzZ39QlboNui1/X1IEun2rZxnmc+W+rrKnxtXc31t5rRRWfjzfBTrd1qXzj05LzRas6X6hxjbZmZlpfvDYlG414axl+sHKmvdRlXp17nM9P1mue5Htbc2m5nV+p0vnb7irQKV1xfMrCq9e3JKdtovWNOR8kw/yzLT48VZzszMrHCeNaj0uu+9l2DNGlsH+lmrQtdZVn65aaL3RoWzP5ytJjLrbOo138xsd2/Xza/i5Fhv5MLa34t99OFHMnv4+nWZxc3vyay72XPrvL6j92ot5xv45YludzOzBw/1/Xpt9OjwC5mNOltunTst3YfGKz1Wnjx9LrPPv37p1rnV1u37T3stmV3f3nbLzZ114PLkXGbtrt7/dbt+X0g6el4YT/T7Pj65dMtdLPX812m3ZTZzvucPXz5y6+zkaybPKyoK/V4aqb+fzZylJ0j0vHptayCz2dI7LTF7MdZ95dlPdd9+793X3XLDju7bP/vsa5kltd5/By3/eHPzmp6vU2dNa411mdnUb7/Ghj4r7Tadve6G/93o7bi88TKc6POFbk+PJTOzMHTOAZ3zm6XzPWBmtrGxKbMbB/rsbGtTX/eLL/zx3d/x1wIPv0QHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAAhPhV/7AsSpmt8ty9tpE2ZJbpYu1wPJfZJ89Hbp1fnehrt3t9mX359VO33LTdkVmnEclsuljJrNlsunUu5hOZRWElsyTS91MGgVtnYLUuN071dVHilltHui8sFpnMilzfT7Otn9PMLAv1s04Wup/Uld+vu/0tne3syWxV6Xf28Wef+nUGzoD5FgZbA5lt7++61758eSqzwpkb4lBPP0Wt28jMrNbdwQqn71ZO9g1nXAT62qxyxotXppmVzj2NJ3rsL2rdF4YjPd+YmZ1NdPt+Fi/1dbG/ZLyI9LUbe7of3bnzQGbNnU23zqCv5+TceS/r+lja1HNZlOo5p3L6SbSm/YI1+VUcHz6WWZkX7rWB6TZymtaSll4j1j1hGOn/7Uehbve4p/uBmVnkjkP9nHmh16X5bObWWWT62qDW91M6bVuVukwzs7TRktmN63oMFrk/Z1ye6Xm+zvU91aWep/LCn49LZ4gWTp2Bs+abmRXOGuxJYt3/ospfm1dOP/o2nj55JLPnLy7ca5O0K7O60uMwdMZLEPhtW5pup9JZ2J3trJmZVaXea5TO+/b6mDltYGbmbaNjp69UTl8J1/TdJHHKddo2W/n9ryx1vYHpdaLV0Otk4G3UzCx31h/vtdRrvjNG2UJf66whnS29hty5d8Ots9nS8+5VlaVunzjy+8nLEz1fn5++lNky1233wQ/eceu8+5r+JtrdOZBZ2uq55b44OZNZWW3ILByNZTZb+GcI9UrvVOJczwt5T3/Pb17fcevMJnoNzpxv/aJas49z1p5uW3+T185e1lt/zcxKZ5764vlzmT19qfummdnuvbsyq51zqosTXedGU+9XzczS6Gr7hXXqUNebr1nwLs91/02aei4abOtyux1/Duvner9wfqrH2vnJ0C03TPR8XjnrkjnvpbGm/Urn+zlp6DHRSPUa0aj096+Z2WZDzymbG3pv7hx/mZnZcqnn7NVK31O5pefd/taGW2fmfNssF/q7KKr9PVXkfL/0222ZbWzqteflyyO/zjVnAR5+iQ4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAQvyqfxjkS5l148i9drVybqDRlVmUtGT26NmRW+cf/C//Vmbvf/9XZHY0nrnlzpa5zIpaN2e7qZ8lThO3zp29XV3nbCGz0VRnZV66dVqonyUK9PuunevMzMo6kFmz1ZRZlel2Xy7nbp3zqpJZ4vTdzmDTLbe/dSCzxTKT2enxU5mdHD5263zzpu4L30aj39ZZ2x/fcarbN471+y5Kpw+u6Ud5oa9NnGuzVeGW63Rtq/SjWJjq/0fmS90+ZmYLp86PFi9lVm/dlNnX+dSt8/FU5+NtPR/t39F1mpkd3H1TZhs7uu82enqs1YHffmWt5wZzxnezqfu8mVnc9uZlb07RHSUJ/f9bJ5E/1q4iKvS7Tta0bZ7reSyOnTFa63EWr9kv1KVzT4GuczLWexQzs8AZv2Wu+1DkPGcQ+fNU01nbw1DfUOqUmS/8tbvr9Nt+T/f54xdDt9zVTK+z7dRpB+c5q6D268z15jGK9FgK15QbRPqeotDZEzT0dZOLS7fO1Xzk5lcVOc/aTJ1Ob2ZhqMdp5QwYr87Ied9mZlmp62w4c0Nd+3OVOe80d5b9ytmTmvnP4lRptTMHRonuu2t25hZG+i+Kwqmz4a89obcdC/WcUte6L9ThmnHorJWB6b6QVWt+/9XtyGjnht63v/7GPX0/zvs0Mzt9dujf0xU0nHm1nfh9s+Fkx8fHMvvTPz6V2VZft6uZWaeh3/f16/pZbu9ed8sNnHEYOH0sajv9ZM03cOX06/lM7xeu39X968a5v1+Yj8YyW1V6LbycnLnl2lCfBdy8fUtmtTPBnV747ff5i2cy++SZzso1a9bBgf5W+OTvfiqz73/vbZn9ygc6MzP7xY9/5uZX5sx/YeKNYLOTid7X7zrr6Hyi98nD0cStc+mcA+53ejKbrdmbT4YnMusnejd852BbZuXCPxdqRM7aVOm+3Wro+9ns+t+U3l64dL4VZhP/WTrOtJI09D3FqX6WZsM/l1w6a1PV0td6Z4Bm3pe12WQ2lNmLc71u3d7V58xmZlvX99zcwy/RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAECIX/UP+/2+zC6Hl+61qzCSWVk6F8aJjOZh6tb5pz/7Wma/PBrL7GScueXO5jpf5ROZdbqFzBod/38Z7TiQWbPVlFkv0NdVa/5/kjptX4W63Kys3XKrwMlr3RlqJ8sWM7fOuN2R2bXtDZlt7Gy55VaRbvvji7nMyloPu0bQcOucnPtj7aqKIpfZdLF0r2332zLLlyuZeV3Baj1nmJlZVMloudTPEsZ+v6+dsWaBrtMbT4FXppkNC923P53ra4+/vJBZWa55zms7Mrv51jWZbd3cdsvd3NmUWdIeyGypp0erK7/9wtgZT82WzFpdfT9mZnGqx3ez1ZVZmur5xp8dzYpC97GrqkpdZuAOQv9+i9yZr0P9Qus1z1hXTu6M7Trx9wTNVK9pTaefBKb7X+D0PTOzMNQtWJW6japMP2fmzKlmZqupXnsWvYXMpiN/Ha2cvVrm9IWy0M+58ga+mdWRN4/prFo30pw+mDT0O53PdNteDvW+0sxsNtL7w2+jctbuIteZmVmU6mfNV968oct0tvvf3FOp7yly1sLQ2XeamVXOx0ThdV7TN5wkax6m9vazOiqd8RI5/c/MrMidudW5H2cL/U29sfOs3mM6a0i2Zn0pE/2sWa6vTXp6jTUzu/Xgocx29/W+fnh6KrMXh8/cOucjf/xfRaPl9T+/bRtdvUfZad6S2dHzQ5n9xV/9xK0zbOv7TZv6fqI1a/e1/esy627rfdzTwyOZLWf+erd051X9rseXug8VJ/58XJR6PMSJPnvob+275bZ39P7maKXXtJmzPj+9HLp1jp39TT3Qe+tBovuJmdnpVNe7Wum90c6+/jYZ9HtunaUzF30b88uRzBoNf593c0s/z+aWHhNBofdNvdg/f0gr3Q5hQ++vwzXz9bjWa3vqfLM3nXOC5br1rtb7m6zWbV853yfdhj+PFYVuv8uxHofFQu/bzcy6Lf3euonOvO11M/L3IT1nzi6dM6Mi8vdxS2dvtHLOF1Nn/3J9U48VM7O4oc+w1uGX6AAAAAAAAAAACByiAwAAAAAAAAAgcIgOAAAAAAAAAIDAIToAAAAAAAAAAAKH6AAAAAAAAAAACByiAwAAAAAAAAAgxK/6h0Gd6ULC0r02iXQ1da2vC8tIl9nccOucLycy++zwSGZpQ9dpZrZ07ndZBjILskJm49mxW2eapjJLQv1/kCTQ2WDQdusM04bM4kZTl9vquuXOVrqvTCZjmWVlLrM08v8XtLnZl9m1nU2ZHdy45pZ7Nl7I7ORE97+w0m3QSnS7m5lNh7rvfhurbC6zJK7ca3v9lszqbqLrLPSYKAo9lszMipW+ttHSY7gu/WdJm3qs5ZWeA4NAP2ca6vYxM4sKfU8nztwZb23J7MYtnZmZbe3qMdHc1W3Q6fj905vQV7nuY4ulboO0qecbM7PYGTNhpJ8lDvzlr+FcmwROluhyo1T3k2/q9Nefq1isljKLnXs1M6trPQ6jRD9L7GSBsy6ZmYWl7kNh6OwJGv6zhM5YCgP9nGWp5+u60HOCmdnCWe+KlV7TiuXKuU6vLd/Qz9Kd6zXLe85vcn2/y1K/0zzT13n7PzOzINDz/FJHFjjv08ys1dT9s671/Z6fXchseKn3L2ZmUe3c8LfgPauzPfyG0/5Rqi+uvH177M9hUaTv11uf1/WVKHbmeqfOfrcnsyT25+ui9PYwuh9ZpZ+z3fX3C0GonyV3xnDl7DvNzKpcN/B4OpXZqtbPslqz31o5344HN2/JbP/2gVvuoKu/Q54ffi2zoxdPZVY433BmZokz715VVek+9OLoxL32xZn+rnz33TdlVhT6nTw70vOfmdl/+Iufymwx02vP9z943S13I9dt39vckNmD2/dlNh2P3DovxkOZJc63vnX0vBnUug3MzL5+or/vHh1dymwy8fcElxd6Dzhz9gTW1HN5v6/nTTOze999W2abD16T2XTur6Pm7JG/19f9erM/kNnL45d+lc6+89toOt/WmwO9npmZ9dr6eUJn/315ofvKujV20OzIrIr1xev2ltsbutxOor//StPlOp+b3+TO3Ho5mclsttB7825PP4eZtzM3S0On8VO//4XO76FT59raWdNCZ49iZtZ2zkpWlS63/Ba/3R50dPvGsfMNl/v9bzb01wIPv0QHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAABA7RAQAAAAAAAAAQOEQHAAAAAAAAAEDgEB0AAAAAAAAAAIFDdAAAAAAAAAAAhPhV/7CxHMqsmWfutUG9lNkyr2QWms7q2q3Sumkgs0mg/3cQLGZuueFKP2uz1vdrS30/Ublw66wLXecsy3WVS31dOWu6dXZ6mzLb3N3VF4Z+l2o497sqdJYmusyicNrdzPqm+1+ar2RWTyduueVI59XFsb5wOJTRVqLbwMysSP9h/u/l9Yadjb57ba+hX84q021fOa+trPwBnkS6zrIoZFaXfrlpQ/ffMI5kljt9MCxTt85OuyGz7b5u+3ZHt8HuVtets93TdaYDZ7BV/ly/nOj2jZ1maKf6fhoNnX1TbkdmodNPItPv08wsqPScbU4/yhZ6Timd5zQzy0N/LruKVqobPk79+TqKdBsVptsnDHQWOJmZWeLcU+60e+CMezOzysm9Vl9462jp15k7dWYr3U9Gl3ptiWt/DJa1fmeDgV7XrfKfpXTW7jDU61Ia6/edFaVbp1U6j5z+10icOczMfdb5ZC6z6cLbq61ZW9ot/56uqHQ6b7BmP1aUui/lTneIY12ut66bmcWR7iuF04TBmj1/Weq+4l07d95pEvn7Me9DxPnMcOeFYjx1qwxCXWfk7FHWdE+rSz2eamc/1kh0X4hif7+60dVjYm9L732aa/aHx0+eyuzFo0cyW610X9gcDNw6G8Erf06/stPnZzL7+kv9HGZmlfOtWi712nN9Y1tfN/fXnpNn+rvno1r3hf2+sy6Z2elL/V2+sb0js52DA5n1O853rJklvba+NtB9YWuwobPI35dv/N3fyeyjn30is+nMP7c4O9P7iWZPf/09uHdPZrv7up+Yme3c0G2/melxtlxzBlM5e4JBT7dvXjnnC5F/HnJj746bX1Wws6HDTs+9dtHQc/1irNvw6ehcZqXz7WJm1nX2ML2u/g5bBP7espjpc4LARjJrJvp7qvIOjcwscNaQS+e6hbN2r9bsZ1sN/S2WdnT7pZlfbuYdPTrfz0HT+YZz9mlmZnVL94WV07YL5zzTzMwSPe+muzrzPiv9Xm2We5u1NfglOgAAAAAAAAAAAofoAAAAAAAAAAAIHKIDAAAAAAAAACBwiA4AAAAAAAAAgMAhOgAAAAAAAAAAAofoAAAAAAAAAAAIQV3X9f/bNwEAAAAAAAAAwP8X8Ut0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAAAEDtEBAAAAAAAAABA4RAcAAAAAAAAAQOAQHQAAAAAAAAAAgUN0AAAAAAAAAACE/wvq2DWwfIPxBwAAAABJRU5ErkJggg==\n"},"metadata":{}}],"execution_count":34}]}