JimmyChin1998/Pytorch-Learning-File

1{2 "cells": [3  {4   "cell_type": "code",5   "execution_count": 1,6   "id": "2f31dc66-f1bd-495a-80f8-d869fa2a3c4b",7   "metadata": {},8   "outputs": [9    {10     "name": "stdout",11     "output_type": "stream",12     "text": [13      "torch version: 2.5.1+cu118\n",14      "torchvision version: 0.20.1+cu118\n"15     ]16    }17   ],18   "source": [19    "# For this notebook to run with updated APIs, we need torch 1.12+ and torchvision 0.13+\n",20    "try:\n",21    "    import torch\n",22    "    import torchvision\n",23    "    print(f\"torch version: {torch.__version__}\")\n",24    "    print(f\"torchvision version: {torchvision.__version__}\")\n",25    "except:\n",26    "    print(f\"[INFO] torch/torchvision versions is not available\")"27   ]28  },29  {30   "cell_type": "code",31   "execution_count": 2,32   "id": "3de9368b-883a-4efb-8ec5-b76f415e06fb",33   "metadata": {},34   "outputs": [],35   "source": [36    "# Continue with regular imports\n",37    "import matplotlib.pyplot as plt\n",38    "import torch\n",39    "import torchvision\n",40    "\n",41    "from torch import nn\n",42    "from torchvision import transforms\n",43    "\n",44    "# Try to get torchinfo, install it if it doesn't work\n",45    "try:\n",46    "    from torchinfo import summary\n",47    "except:\n",48    "    print(\"[INFO] Couldn't find torchinfo... installing it.\")\n",49    "    !pip install -q torchinfo\n",50    "    from torchinfo import summary\n",51    "\n",52    "# Try to import the going_modular directory, download it from GitHub if it doesn't work\n",53    "try:\n",54    "    from going_modular import data_setup, engine\n",55    "    from helper_functions import download_data, set_seeds, plot_loss_curves\n",56    "except:\n",57    "    # Get the going_modular scripts\n",58    "    print(\"[INFO] Couldn't find going_modular or helper_functions scripts... downloading them from GitHub.\")\n",59    "    !git clone https://github.com/mrdbourke/pytorch-deep-learning\n",60    "    !mv pytorch-deep-learning/going_modular .\n",61    "    !mv pytorch-deep-learning/helper_functions.py . # get the helper_functions.py script\n",62    "    !rm -rf pytorch-deep-learning\n",63    "    from going_modular.going_modular import data_setup, engine\n",64    "    from helper_functions import download_data, set_seeds, plot_loss_curves"65   ]66  },67  {68   "cell_type": "code",69   "execution_count": 3,70   "id": "edae0e3a-792f-497b-bb2e-4091d481c270",71   "metadata": {},72   "outputs": [73    {74     "data": {75      "text/plain": [76       "'cuda'"77      ]78     },79     "execution_count": 3,80     "metadata": {},81     "output_type": "execute_result"82    }83   ],84   "source": [85    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",86    "device"87   ]88  },89  {90   "cell_type": "code",91   "execution_count": 4,92   "id": "0ebd955e-d11d-46e5-b6d2-4b4ebae9f4ff",93   "metadata": {},94   "outputs": [95    {96     "name": "stdout",97     "output_type": "stream",98     "text": [99      "[INFO] data\\pizza_steak_sushi_20_percent directory exists, skipping download.\n"100     ]101    },102    {103     "data": {104      "text/plain": [105       "WindowsPath('data/pizza_steak_sushi_20_percent')"106      ]107     },108     "execution_count": 4,109     "metadata": {},110     "output_type": "execute_result"111    }112   ],113   "source": [114    "# Download pizza, steak, sushi images from GitHub\n",115    "data_20_percent_path = download_data(source=\"https://github.com/mrdbourke/pytorch-deep-learning/raw/main/data/pizza_steak_sushi_20_percent.zip\",\n",116    "                                     destination=\"pizza_steak_sushi_20_percent\")\n",117    "\n",118    "data_20_percent_path"119   ]120  },121  {122   "cell_type": "code",123   "execution_count": 5,124   "id": "10da01c4-b572-4b38-bc88-cc8d660c37d5",125   "metadata": {},126   "outputs": [],127   "source": [128    "# data_20_percent_path = data/pizza_steak_sushi_20_percent\n",129    "\n",130    "# Setup directory paths to train and test images\n",131    "train_dir = data_20_percent_path / \"train\"\n",132    "test_dir = data_20_percent_path / \"test\""133   ]134  },135  {136   "cell_type": "markdown",137   "id": "04a28253-cd22-4304-9b71-91eb37d5145e",138   "metadata": {},139   "source": [140    "### Goals are :\n",141    "### 1. Performance - A model that performs at 95%+ accuracy.\n",142    "### 2. Speed - A model that can classify an image at ~30FPS (0.03 seconds inference time per image, also known as latency)."143   ]144  },145  {146   "cell_type": "code",147   "execution_count": 7,148   "id": "a6c13fc8-ebbb-4d1e-a730-85cc7149601a",149   "metadata": {},150   "outputs": [],151   "source": [152    "# 1. Setup pretrained EffNetB2 weights\n",153    "effnetb2_weights = torchvision.models.EfficientNet_B2_Weights.DEFAULT\n",154    "\n",155    "# 2. Get EffNetB2 transforms\n",156    "effnetb2_transforms = effnetb2_weights.transforms()\n",157    "\n",158    "# 3. Setup pretrained model\n",159    "effnetb2 = torchvision.models.efficientnet_b2(weights=effnetb2_weights) # could also use weights=\"DEFAULT\"\n",160    "\n",161    "# 4. Freeze the base layers in the model (this will freeze all layers to begin with)\n",162    "for param in effnetb2.parameters():\n",163    "    param.requires_grad = False"164   ]165  },166  {167   "cell_type": "code",168   "execution_count": 8,169   "id": "67b1a45c-bfa4-44a5-9f94-3514e075db66",170   "metadata": {},171   "outputs": [172    {173     "data": {174      "text/plain": [175       "ImageClassification(\n",176       "    crop_size=[288]\n",177       "    resize_size=[288]\n",178       "    mean=[0.485, 0.456, 0.406]\n",179       "    std=[0.229, 0.224, 0.225]\n",180       "    interpolation=InterpolationMode.BICUBIC\n",181       ")"182      ]183     },184     "execution_count": 8,185     "metadata": {},186     "output_type": "execute_result"187    }188   ],189   "source": [190    "effnetb2_transforms"191   ]192  },193  {194   "cell_type": "code",195   "execution_count": 9,196   "id": "b78df4de-7692-4c7c-bcd2-b37efdce31b1",197   "metadata": {},198   "outputs": [199    {200     "data": {201      "text/plain": [202       "Sequential(\n",203       "  (0): Dropout(p=0.3, inplace=True)\n",204       "  (1): Linear(in_features=1408, out_features=1000, bias=True)\n",205       ")"206      ]207     },208     "execution_count": 9,209     "metadata": {},210     "output_type": "execute_result"211    }212   ],213   "source": [214    "# Check out EffNetB2 classifier head\n",215    "effnetb2.classifier"216   ]217  },218  {219   "cell_type": "code",220   "execution_count": 10,221   "id": "4e34a1e4-6d6b-4d76-8cd7-4827fe3b83d1",222   "metadata": {},223   "outputs": [],224   "source": [225    "# 5. Update the classifier head\n",226    "effnetb2.classifier = nn.Sequential(\n",227    "    nn.Dropout(p=0.3, inplace=True), # keep dropout layer same\n",228    "    nn.Linear(in_features=1408, # keep in_features same \n",229    "              out_features=3)) # change out_features to suit our number of classes"230   ]231  },232  {233   "cell_type": "code",234   "execution_count": 11,235   "id": "45c88337-e1c6-4164-862d-c171f6935b27",236   "metadata": {},237   "outputs": [],238   "source": [239    "# Creating a function to make an EffNetB2 feature extractor\n",240    "def create_effnetb2_model(num_classes:int=3, \n",241    "                          seed:int=42):\n",242    "    \"\"\"Creates an EfficientNetB2 feature extractor model and transforms.\n",243    "\n",244    "    Args:\n",245    "        num_classes (int, optional): number of classes in the classifier head. \n",246    "            Defaults to 3.\n",247    "        seed (int, optional): random seed value. Defaults to 42.\n",248    "\n",249    "    Returns:\n",250    "        model (torch.nn.Module): EffNetB2 feature extractor model. \n",251    "        transforms (torchvision.transforms): EffNetB2 image transforms.\n",252    "    \"\"\"\n",253    "    # 1, 2, 3. Create EffNetB2 pretrained weights, transforms and model\n",254    "    weights = torchvision.models.EfficientNet_B2_Weights.DEFAULT\n",255    "    transforms = weights.transforms()\n",256    "    model = torchvision.models.efficientnet_b2(weights=weights)\n",257    "\n",258    "    # 4. Freeze all layers in base model\n",259    "    for param in model.parameters():\n",260    "        param.requires_grad = False\n",261    "\n",262    "    # 5. Change classifier head with random seed for reproducibility\n",263    "    torch.manual_seed(seed)\n",264    "    model.classifier = nn.Sequential(\n",265    "        nn.Dropout(p=0.3, inplace=True),\n",266    "        nn.Linear(in_features=1408, out_features=num_classes),\n",267    "    )\n",268    "    \n",269    "    return model, transforms"270   ]271  },272  {273   "cell_type": "code",274   "execution_count": 12,275   "id": "2591791a-6335-4a09-9a7b-b03cc3f2557b",276   "metadata": {},277   "outputs": [],278   "source": [279    "effnetb2, effnetb2_transforms = create_effnetb2_model(num_classes=3,\n",280    "                                                      seed=42)"281   ]282  },283  {284   "cell_type": "code",285   "execution_count": 13,286   "id": "0c428169-fbf4-4bb2-94e9-59614d507778",287   "metadata": {288    "scrolled": true289   },290   "outputs": [291    {292     "data": {293      "text/plain": [294       "============================================================================================================================================\n",295       "Layer (type (var_name))                                      Input Shape          Output Shape         Param #              Trainable\n",296       "============================================================================================================================================\n",297       "EfficientNet (EfficientNet)                                  [1, 3, 224, 224]     [1, 3]               --                   Partial\n",298       "├─Sequential (features)                                      [1, 3, 224, 224]     [1, 1408, 7, 7]      --                   False\n",299       "│    └─Conv2dNormActivation (0)                              [1, 3, 224, 224]     [1, 32, 112, 112]    --                   False\n",300       "│    │    └─Conv2d (0)                                       [1, 3, 224, 224]     [1, 32, 112, 112]    (864)                False\n",301       "│    │    └─BatchNorm2d (1)                                  [1, 32, 112, 112]    [1, 32, 112, 112]    (64)                 False\n",302       "│    │    └─SiLU (2)                                         [1, 32, 112, 112]    [1, 32, 112, 112]    --                   --\n",303       "│    └─Sequential (1)                                        [1, 32, 112, 112]    [1, 16, 112, 112]    --                   False\n",304       "│    │    └─MBConv (0)                                       [1, 32, 112, 112]    [1, 16, 112, 112]    (1,448)              False\n",305       "│    │    └─MBConv (1)                                       [1, 16, 112, 112]    [1, 16, 112, 112]    (612)                False\n",306       "│    └─Sequential (2)                                        [1, 16, 112, 112]    [1, 24, 56, 56]      --                   False\n",307       "│    │    └─MBConv (0)                                       [1, 16, 112, 112]    [1, 24, 56, 56]      (6,004)              False\n",308       "│    │    └─MBConv (1)                                       [1, 24, 56, 56]      [1, 24, 56, 56]      (10,710)             False\n",309       "│    │    └─MBConv (2)                                       [1, 24, 56, 56]      [1, 24, 56, 56]      (10,710)             False\n",310       "│    └─Sequential (3)                                        [1, 24, 56, 56]      [1, 48, 28, 28]      --                   False\n",311       "│    │    └─MBConv (0)                                       [1, 24, 56, 56]      [1, 48, 28, 28]      (16,518)             False\n",312       "│    │    └─MBConv (1)                                       [1, 48, 28, 28]      [1, 48, 28, 28]      (43,308)             False\n",313       "│    │    └─MBConv (2)                                       [1, 48, 28, 28]      [1, 48, 28, 28]      (43,308)             False\n",314       "│    └─Sequential (4)                                        [1, 48, 28, 28]      [1, 88, 14, 14]      --                   False\n",315       "│    │    └─MBConv (0)                                       [1, 48, 28, 28]      [1, 88, 14, 14]      (50,300)             False\n",316       "│    │    └─MBConv (1)                                       [1, 88, 14, 14]      [1, 88, 14, 14]      (123,750)            False\n",317       "│    │    └─MBConv (2)                                       [1, 88, 14, 14]      [1, 88, 14, 14]      (123,750)            False\n",318       "│    │    └─MBConv (3)                                       [1, 88, 14, 14]      [1, 88, 14, 14]      (123,750)            False\n",319       "│    └─Sequential (5)                                        [1, 88, 14, 14]      [1, 120, 14, 14]     --                   False\n",320       "│    │    └─MBConv (0)                                       [1, 88, 14, 14]      [1, 120, 14, 14]     (149,158)            False\n",321       "│    │    └─MBConv (1)                                       [1, 120, 14, 14]     [1, 120, 14, 14]     (237,870)            False\n",322       "│    │    └─MBConv (2)                                       [1, 120, 14, 14]     [1, 120, 14, 14]     (237,870)            False\n",323       "│    │    └─MBConv (3)                                       [1, 120, 14, 14]     [1, 120, 14, 14]     (237,870)            False\n",324       "│    └─Sequential (6)                                        [1, 120, 14, 14]     [1, 208, 7, 7]       --                   False\n",325       "│    │    └─MBConv (0)                                       [1, 120, 14, 14]     [1, 208, 7, 7]       (301,406)            False\n",326       "│    │    └─MBConv (1)                                       [1, 208, 7, 7]       [1, 208, 7, 7]       (686,868)            False\n",327       "│    │    └─MBConv (2)                                       [1, 208, 7, 7]       [1, 208, 7, 7]       (686,868)            False\n",328       "│    │    └─MBConv (3)                                       [1, 208, 7, 7]       [1, 208, 7, 7]       (686,868)            False\n",329       "│    │    └─MBConv (4)                                       [1, 208, 7, 7]       [1, 208, 7, 7]       (686,868)            False\n",330       "│    └─Sequential (7)                                        [1, 208, 7, 7]       [1, 352, 7, 7]       --                   False\n",331       "│    │    └─MBConv (0)                                       [1, 208, 7, 7]       [1, 352, 7, 7]       (846,900)            False\n",332       "│    │    └─MBConv (1)                                       [1, 352, 7, 7]       [1, 352, 7, 7]       (1,888,920)          False\n",333       "│    └─Conv2dNormActivation (8)                              [1, 352, 7, 7]       [1, 1408, 7, 7]      --                   False\n",334       "│    │    └─Conv2d (0)                                       [1, 352, 7, 7]       [1, 1408, 7, 7]      (495,616)            False\n",335       "│    │    └─BatchNorm2d (1)                                  [1, 1408, 7, 7]      [1, 1408, 7, 7]      (2,816)              False\n",336       "│    │    └─SiLU (2)                                         [1, 1408, 7, 7]      [1, 1408, 7, 7]      --                   --\n",337       "├─AdaptiveAvgPool2d (avgpool)                                [1, 1408, 7, 7]      [1, 1408, 1, 1]      --                   --\n",338       "├─Sequential (classifier)                                    [1, 1408]            [1, 3]               --                   True\n",339       "│    └─Dropout (0)                                           [1, 1408]            [1, 1408]            --                   --\n",340       "│    └─Linear (1)                                            [1, 1408]            [1, 3]               4,227                True\n",341       "============================================================================================================================================\n",342       "Total params: 7,705,221\n",343       "Trainable params: 4,227\n",344       "Non-trainable params: 7,700,994\n",345       "Total mult-adds (Units.MEGABYTES): 657.64\n",346       "============================================================================================================================================\n",347       "Input size (MB): 0.60\n",348       "Forward/backward pass size (MB): 156.80\n",349       "Params size (MB): 30.82\n",350       "Estimated Total Size (MB): 188.22\n",351       "============================================================================================================================================"352      ]353     },354     "execution_count": 13,355     "metadata": {},356     "output_type": "execute_result"357    }358   ],359   "source": [360    "from torchinfo import summary\n",361    "\n",362    "# Print EffNetB2 model summary (uncomment for full output) \n",363    "summary(effnetb2, \n",364    "        input_size=(1, 3, 224, 224),\n",365    "        col_names=[\"input_size\", \"output_size\", \"num_params\", \"trainable\"],\n",366    "        col_width=20,\n",367    "        row_settings=[\"var_names\"])"368   ]369  },370  {371   "cell_type": "code",372   "execution_count": 14,373   "id": "398b34ac-71a8-4b9b-ad14-62f2ded81052",374   "metadata": {},375   "outputs": [],376   "source": [377    "# Setup DataLoaders\n",378    "from going_modular import data_setup\n",379    "train_dataloader_effnetb2, test_dataloader_effnetb2, class_names = data_setup.create_dataloaders(train_dir=train_dir,\n",380    "                                                                                                 test_dir=test_dir,\n",381    "                                                                                                 transform=effnetb2_transforms,\n",382    "                                                                                                 batch_size=32)"383   ]384  },385  {386   "cell_type": "code",387   "execution_count": 15,388   "id": "a2079280-ec90-4cc4-80fa-34c4826111bd",389   "metadata": {},390   "outputs": [391    {392     "data": {393      "application/vnd.jupyter.widget-view+json": {394       "model_id": "2beae74b5815416fb6d9d5a42c41c2d3",395       "version_major": 2,396       "version_minor": 0397      },398      "text/plain": [399       "  0%|          | 0/10 [00:00<?, ?it/s]"400      ]401     },402     "metadata": {},403     "output_type": "display_data"404    },405    {406     "name": "stdout",407     "output_type": "stream",408     "text": [409      "Epoch: 1 | train_loss: 0.9855 | train_acc: 0.5625 | test_loss: 0.7407 | test_acc: 0.9347\n",410      "Epoch: 2 | train_loss: 0.7175 | train_acc: 0.8438 | test_loss: 0.5869 | test_acc: 0.9409\n",411      "Epoch: 3 | train_loss: 0.5876 | train_acc: 0.8917 | test_loss: 0.4909 | test_acc: 0.9500\n",412      "Epoch: 4 | train_loss: 0.4474 | train_acc: 0.9062 | test_loss: 0.4355 | test_acc: 0.9409\n",413      "Epoch: 5 | train_loss: 0.4290 | train_acc: 0.9104 | test_loss: 0.3915 | test_acc: 0.9443\n",414      "Epoch: 6 | train_loss: 0.4380 | train_acc: 0.8896 | test_loss: 0.3512 | test_acc: 0.9688\n",415      "Epoch: 7 | train_loss: 0.4245 | train_acc: 0.8771 | test_loss: 0.3268 | test_acc: 0.9563\n",416      "Epoch: 8 | train_loss: 0.3897 | train_acc: 0.8958 | test_loss: 0.3456 | test_acc: 0.9290\n",417      "Epoch: 9 | train_loss: 0.3749 | train_acc: 0.8812 | test_loss: 0.3129 | test_acc: 0.9131\n",418      "Epoch: 10 | train_loss: 0.3757 | train_acc: 0.8604 | test_loss: 0.2813 | test_acc: 0.9688\n"419     ]420    }421   ],422   "source": [423    "from going_modular import engine\n",424    "\n",425    "# Setup optimizer\n",426    "optimizer = torch.optim.Adam(params=effnetb2.parameters(),\n",427    "                             lr=1e-3)\n",428    "# Setup loss function\n",429    "loss_fn = torch.nn.CrossEntropyLoss()\n",430    "\n",431    "# Set seeds for reproducibility and train the model\n",432    "set_seeds()\n",433    "effnetb2_results = engine.train(model=effnetb2,\n",434    "                                train_dataloader=train_dataloader_effnetb2,\n",435    "                                test_dataloader=test_dataloader_effnetb2,\n",436    "                                epochs=10,\n",437    "                                optimizer=optimizer,\n",438    "                                loss_fn=loss_fn,\n",439    "                                device=device)"440   ]441  },442  {443   "cell_type": "code",444   "execution_count": 16,445   "id": "a2bfdce2-c017-425c-8270-f61055a2874f",446   "metadata": {},447   "outputs": [448    {449     "data": {450      "image/png": "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",451      "text/plain": [452       "<Figure size 1500x700 with 2 Axes>"453      ]454     },455     "metadata": {},456     "output_type": "display_data"457    }458   ],459   "source": [460    "from helper_functions import plot_loss_curves\n",461    "\n",462    "plot_loss_curves(effnetb2_results)"463   ]464  },465  {466   "cell_type": "code",467   "execution_count": 17,468   "id": "fdba16bb-a4a5-40a8-b3fe-93fa94939740",469   "metadata": {},470   "outputs": [471    {472     "name": "stdout",473     "output_type": "stream",474     "text": [475      "[INFO] Saving model to: models\\09_pretrained_effnetb2_feature_extractor_pizza_steak_sushi_20_percent.pth\n"476     ]477    }478   ],479   "source": [480    "from going_modular import utils\n",481    "\n",482    "# Save the model\n",483    "utils.save_model(model=effnetb2,\n",484    "                 target_dir=\"models\",\n",485    "                 model_name=\"09_pretrained_effnetb2_feature_extractor_pizza_steak_sushi_20_percent.pth\")"486   ]487  },488  {489   "cell_type": "code",490   "execution_count": 19,491   "id": "0c4c2c07-9699-4561-80bb-25b7b0c85cd3",492   "metadata": {},493   "outputs": [494    {495     "name": "stdout",496     "output_type": "stream",497     "text": [498      "Pretrained EffNetB2 feature extractor model size: 29 MB\n",499      "7705221\n",500      "{'test_loss': 0.2812717080116272, 'test_acc': 0.96875, 'number_of_parameters': 7705221, 'model_size (MB)': 29}\n"501     ]502    }503   ],504   "source": [505    "from pathlib import Path\n",506    "\n",507    "# Get the model size in bytes then convert to megabytes\n",508    "pretrained_effnetb2_model_size = Path(\"models/09_pretrained_effnetb2_feature_extractor_pizza_steak_sushi_20_percent.pth\").stat().st_size // (1024*1024) # division converts bytes to megabytes (roughly) \n",509    "print(f\"Pretrained EffNetB2 feature extractor model size: {pretrained_effnetb2_model_size} MB\")\n",510    "\n",511    "# Count number of parameters in EffNetB2\n",512    "effnetb2_total_params = sum(torch.numel(param) for param in effnetb2.parameters())\n",513    "print(effnetb2_total_params)\n",514    "\n",515    "# Create a dictionary with EffNetB2 statistics\n",516    "effnetb2_stats = {\"test_loss\": effnetb2_results[\"test_loss\"][-1],\n",517    "                  \"test_acc\": effnetb2_results[\"test_acc\"][-1],\n",518    "                  \"number_of_parameters\": effnetb2_total_params,\n",519    "                  \"model_size (MB)\": pretrained_effnetb2_model_size}\n",520    "print(effnetb2_stats)"521   ]522  },523  {524   "cell_type": "markdown",525   "id": "f5511d15-7ef6-49bf-b0af-af4e8c3ccc9f",526   "metadata": {},527   "source": [528    "### Creating a ViT feature extractor (做比較)"529   ]530  },531  {532   "cell_type": "code",533   "execution_count": 20,534   "id": "16a54b06-1482-4953-abc2-5f01ffaa7bd4",535   "metadata": {},536   "outputs": [537    {538     "data": {539      "text/plain": [540       "Sequential(\n",541       "  (head): Linear(in_features=768, out_features=1000, bias=True)\n",542       ")"543      ]544     },545     "execution_count": 20,546     "metadata": {},547     "output_type": "execute_result"548    }549   ],550   "source": [551    "# Check out ViT heads layer\n",552    "vit = torchvision.models.vit_b_16()\n",553    "vit.heads"554   ]555  },556  {557   "cell_type": "code",558   "execution_count": 21,559   "id": "1495de1d-b266-4669-acee-538115a10069",560   "metadata": {},561   "outputs": [],562   "source": [563    "def create_vit_model(num_classes:int=3, \n",564    "                     seed:int=42):\n",565    "    \"\"\"Creates a ViT-B/16 feature extractor model and transforms.\n",566    "\n",567    "    Args:\n",568    "        num_classes (int, optional): number of target classes. Defaults to 3.\n",569    "        seed (int, optional): random seed value for output layer. Defaults to 42.\n",570    "\n",571    "    Returns:\n",572    "        model (torch.nn.Module): ViT-B/16 feature extractor model. \n",573    "        transforms (torchvision.transforms): ViT-B/16 image transforms.\n",574    "    \"\"\"\n",575    "    # Create ViT_B_16 pretrained weights, transforms and model\n",576    "    weights = torchvision.models.ViT_B_16_Weights.DEFAULT\n",577    "    transforms = weights.transforms()\n",578    "    model = torchvision.models.vit_b_16(weights=weights)\n",579    "\n",580    "    # Freeze all layers in model\n",581    "    for param in model.parameters():\n",582    "        param.requires_grad = False\n",583    "\n",584    "    # Change classifier head to suit our needs (this will be trainable)\n",585    "    torch.manual_seed(seed)\n",586    "    model.heads = nn.Sequential(nn.Linear(in_features=768, # keep this the same as original model\n",587    "                                          out_features=num_classes)) # update to reflect target number of classes\n",588    "    \n",589    "    return model, transforms"590   ]591  },592  {593   "cell_type": "code",594   "execution_count": 22,595   "id": "2508a6b6-7607-4534-b994-f14df9babf21",596   "metadata": {},597   "outputs": [],598   "source": [599    "# Create ViT model and transforms\n",600    "vit, vit_transforms = create_vit_model(num_classes=3,\n",601    "                                       seed=42)\n"602   ]603  },604  {605   "cell_type": "code",606   "execution_count": 23,607   "id": "20ff1f61-b148-4927-bb37-ffd4e27da09c",608   "metadata": {609    "scrolled": true610   },611   "outputs": [612    {613     "data": {614      "text/plain": [615       "============================================================================================================================================\n",616       "Layer (type (var_name))                                      Input Shape          Output Shape         Param #              Trainable\n",617       "============================================================================================================================================\n",618       "VisionTransformer (VisionTransformer)                        [1, 3, 224, 224]     [1, 3]               768                  Partial\n",619       "├─Conv2d (conv_proj)                                         [1, 3, 224, 224]     [1, 768, 14, 14]     (590,592)            False\n",620       "├─Encoder (encoder)                                          [1, 197, 768]        [1, 197, 768]        151,296              False\n",621       "│    └─Dropout (dropout)                                     [1, 197, 768]        [1, 197, 768]        --                   --\n",622       "│    └─Sequential (layers)                                   [1, 197, 768]        [1, 197, 768]        --                   False\n",623       "│    │    └─EncoderBlock (encoder_layer_0)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",624       "│    │    └─EncoderBlock (encoder_layer_1)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",625       "│    │    └─EncoderBlock (encoder_layer_2)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",626       "│    │    └─EncoderBlock (encoder_layer_3)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",627       "│    │    └─EncoderBlock (encoder_layer_4)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",628       "│    │    └─EncoderBlock (encoder_layer_5)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",629       "│    │    └─EncoderBlock (encoder_layer_6)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",630       "│    │    └─EncoderBlock (encoder_layer_7)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",631       "│    │    └─EncoderBlock (encoder_layer_8)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",632       "│    │    └─EncoderBlock (encoder_layer_9)                   [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",633       "│    │    └─EncoderBlock (encoder_layer_10)                  [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",634       "│    │    └─EncoderBlock (encoder_layer_11)                  [1, 197, 768]        [1, 197, 768]        (7,087,872)          False\n",635       "│    └─LayerNorm (ln)                                        [1, 197, 768]        [1, 197, 768]        (1,536)              False\n",636       "├─Sequential (heads)                                         [1, 768]             [1, 3]               --                   True\n",637       "│    └─Linear (0)                                            [1, 768]             [1, 3]               2,307                True\n",638       "============================================================================================================================================\n",639       "Total params: 85,800,963\n",640       "Trainable params: 2,307\n",641       "Non-trainable params: 85,798,656\n",642       "Total mult-adds (Units.MEGABYTES): 172.47\n",643       "============================================================================================================================================\n",644       "Input size (MB): 0.60\n",645       "Forward/backward pass size (MB): 104.09\n",646       "Params size (MB): 229.20\n",647       "Estimated Total Size (MB): 333.89\n",648       "============================================================================================================================================"649      ]650     },651     "execution_count": 23,652     "metadata": {},653     "output_type": "execute_result"654    }655   ],656   "source": [657    "from torchinfo import summary\n",658    "\n",659    "# Print ViT feature extractor model summary (uncomment for full output)\n",660    "summary(vit, \n",661    "        input_size=(1, 3, 224, 224),\n",662    "        col_names=[\"input_size\", \"output_size\", \"num_params\", \"trainable\"],\n",663    "        col_width=20,\n",664    "        row_settings=[\"var_names\"])"665   ]666  },667  {668   "cell_type": "code",669   "execution_count": 24,670   "id": "d7a77bfd-4554-4a70-a27e-38a43f023e15",671   "metadata": {},672   "outputs": [],673   "source": [674    "# Setup ViT DataLoaders\n",675    "from going_modular import data_setup\n",676    "train_dataloader_vit, test_dataloader_vit, class_names = data_setup.create_dataloaders(train_dir=train_dir,\n",677    "                                                                                       test_dir=test_dir,\n",678    "                                                                                       transform=vit_transforms,\n",679    "                                                                                       batch_size=32)"680   ]681  },682  {683   "cell_type": "code",684   "execution_count": 25,685   "id": "5e7a1d6c-6ee0-493e-a362-c843b33545de",686   "metadata": {},687   "outputs": [688    {689     "data": {690      "application/vnd.jupyter.widget-view+json": {691       "model_id": "580f8fa5aa9b4eccaa9491b854fba5f6",692       "version_major": 2,693       "version_minor": 0694      },695      "text/plain": [696       "  0%|          | 0/10 [00:00<?, ?it/s]"697      ]698     },699     "metadata": {},700     "output_type": "display_data"701    },702    {703     "name": "stdout",704     "output_type": "stream",705     "text": [706      "Epoch: 1 | train_loss: 0.7023 | train_acc: 0.7500 | test_loss: 0.2714 | test_acc: 0.9290\n",707      "Epoch: 2 | train_loss: 0.2531 | train_acc: 0.9104 | test_loss: 0.1669 | test_acc: 0.9602\n",708      "Epoch: 3 | train_loss: 0.1766 | train_acc: 0.9542 | test_loss: 0.1270 | test_acc: 0.9693\n",709      "Epoch: 4 | train_loss: 0.1277 | train_acc: 0.9625 | test_loss: 0.1072 | test_acc: 0.9722\n",710      "Epoch: 5 | train_loss: 0.1163 | train_acc: 0.9646 | test_loss: 0.0950 | test_acc: 0.9784\n",711      "Epoch: 6 | train_loss: 0.1270 | train_acc: 0.9375 | test_loss: 0.0830 | test_acc: 0.9722\n",712      "Epoch: 7 | train_loss: 0.0899 | train_acc: 0.9771 | test_loss: 0.0844 | test_acc: 0.9784\n",713      "Epoch: 8 | train_loss: 0.0928 | train_acc: 0.9812 | test_loss: 0.0759 | test_acc: 0.9722\n",714      "Epoch: 9 | train_loss: 0.0933 | train_acc: 0.9792 | test_loss: 0.0729 | test_acc: 0.9784\n",715      "Epoch: 10 | train_loss: 0.0662 | train_acc: 0.9833 | test_loss: 0.0642 | test_acc: 0.9847\n"716     ]717    }718   ],719   "source": [720    "from going_modular import engine\n",721    "\n",722    "# Setup optimizer\n",723    "optimizer = torch.optim.Adam(params=vit.parameters(),\n",724    "                             lr=1e-3)\n",725    "# Setup loss function\n",726    "loss_fn = torch.nn.CrossEntropyLoss()\n",727    "\n",728    "# Train ViT model with seeds set for reproducibility\n",729    "set_seeds()\n",730    "vit_results = engine.train(model=vit,\n",731    "                           train_dataloader=train_dataloader_vit,\n",732    "                           test_dataloader=test_dataloader_vit,\n",733    "                           epochs=10,\n",734    "                           optimizer=optimizer,\n",735    "                           loss_fn=loss_fn,\n",736    "                           device=device)"737   ]738  },739  {740   "cell_type": "code",741   "execution_count": 26,742   "id": "c4cedd0e-4cd9-4037-98c6-b0890cfdd6d3",743   "metadata": {},744   "outputs": [745    {746     "data": {747      "image/png": "iVBORw0KGgoAAAANSUhEUgAABL4AAAJuCAYAAAC+DMsZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADJD0lEQVR4nOzdd3xT9f7H8XeSNt0tlA4KlJaWTQGRDaIoCuLeqNfBFVR+XK9XcV/HBfSK44qoV/AqIk5wK15B5ToARUEQlD3KKKOlA+hu0ybn90falLJb2p6kfT0fj/OwJCfJJy2R9J3P9/O1GIZhCAAAAAAAAGhkrGYXAAAAAAAAANQHgi8AAAAAAAA0SgRfAAAAAAAAaJQIvgAAAAAAANAoEXwBAAAAAACgUSL4AgAAAAAAQKNE8AUAAAAAAIBGieALAAAAAAAAjRLBFwAAAAAAABolgi8Appo9e7YsFotWrFhhdikAAACo8OKLL8pisSglJcXsUgDglBB8AQAAAACqmTVrliRp3bp1WrZsmcnVAEDtEXwBAAAAADxWrFih33//XRdeeKEk6fXXXze5oqMrKioyuwQAPoDgC4DX+/HHHzVs2DCFhYUpODhYgwYN0pdfflntnKKiIt17771q166dAgMDFRkZqT59+mjOnDmec7Zt26Zrr71WrVq1UkBAgGJjYzVs2DCtXr26gZ8RAACA96oMup566ikNGjRIc+fOPSJk2rNnj2677TbFx8fLbrerVatWuuqqq7Rv3z7POQcPHtQ999yjpKQkBQQEKCYmRhdccIE2btwoSfrhhx9ksVj0ww8/VLvvHTt2yGKxaPbs2Z7LRo8erdDQUK1Zs0bDhw9XWFiYhg0bJklauHChLr30UrVp00aBgYFq3769br/9dmVnZx/x3DZu3KjrrrtOsbGxCggIUNu2bXXTTTeptLRUO3bskJ+fn6ZMmXLE7RYvXiyLxaIPP/ywVt9TAObxM7sAADieRYsW6bzzzlOPHj30+uuvKyAgQNOnT9fFF1+sOXPmaNSoUZKkCRMm6O2339YTTzyhXr16qbCwUGvXrlVOTo7nvi644AI5nU4988wzatu2rbKzs7V06VIdPHjQpGcHAADgXYqLizVnzhz17dtXKSkpuuWWWzR27Fh9+OGHuvnmmyW5Q6++ffuqrKxMf//739WjRw/l5OTo66+/1oEDBxQbG6v8/HydccYZ2rFjhx544AH1799fBQUFWrx4sdLT09W5c+ca1+ZwOHTJJZfo9ttv14MPPqjy8nJJUmpqqgYOHKixY8cqIiJCO3bs0NSpU3XGGWdozZo18vf3lyT9/vvvOuOMMxQVFaXJkyerQ4cOSk9P17x58+RwOJSYmKhLLrlEr7zyiu6//37ZbDbPY//73/9Wq1atdPnll9fBdxlAgzIAwERvvPGGIcn49ddfj3r9gAEDjJiYGCM/P99zWXl5uZGSkmK0adPGcLlchmEYRkpKinHZZZcd83Gys7MNSca0adPq9gkAAAA0Im+99ZYhyXjllVcMwzCM/Px8IzQ01BgyZIjnnFtuucXw9/c31q9ff8z7mTx5siHJWLhw4THP+f777w1Jxvfff1/t8u3btxuSjDfeeMNz2c0332xIMmbNmnXc+l0ul1FWVmbs3LnTkGR8/vnnnuvOOecco1mzZkZmZuYJa/r00089l+3Zs8fw8/MzJk2adNzHBuCdWOoIwGsVFhZq2bJluuqqqxQaGuq53Gaz6cYbb9Tu3bu1adMmSVK/fv20YMECPfjgg/rhhx9UXFxc7b4iIyOVnJysZ599VlOnTtWqVavkcrka9PkAAAB4u9dff11BQUG69tprJUmhoaG6+uqrtWTJEm3ZskWStGDBAp199tnq0qXLMe9nwYIF6tixo84999w6re/KK6884rLMzEyNGzdO8fHx8vPzk7+/vxISEiRJGzZskOQei7Fo0SJdc801io6OPub9Dx06VD179tTLL7/sueyVV16RxWLRbbfdVqfPBUDDIPgC4LUOHDggwzAUFxd3xHWtWrWSJM9SxhdffFEPPPCAPvvsM5199tmKjIzUZZdd5nmDZrFY9O2332rEiBF65plndPrppys6Olp33nmn8vPzG+5JAQAAeKmtW7dq8eLFuvDCC2UYhg4ePKiDBw/qqquuklS102NWVpbatGlz3Ps6mXNqKjg4WOHh4dUuc7lcGj58uD755BPdf//9+vbbb7V8+XL98ssvkuT5MPTAgQNyOp0nVdOdd96pb7/9Vps2bVJZWZlee+01XXXVVWrZsmWdPh8ADYPgC4DXat68uaxWq9LT04+4bu/evZKkqKgoSVJISIgmTZqkjRs3KiMjQzNmzNAvv/yiiy++2HObhIQEvf7668rIyNCmTZt09913a/r06brvvvsa5gkBAAB4sVmzZskwDH300Udq3ry556jc3fHNN9+U0+lUdHS0du/efdz7OplzAgMDJUmlpaXVLj/aUHrJ/UHm4dauXavff/9dzz77rP76179q6NCh6tu3r1q0aFHtvMjISNlsthPWJEnXX3+9WrRooZdfflkffvihMjIy9Je//OWEtwPgnQi+AHitkJAQ9e/fX5988km1pYsul0vvvPOO2rRpo44dOx5xu9jYWI0ePVrXXXedNm3adNStrjt27KhHHnlE3bt312+//VavzwMAAMDbOZ1Ovfnmm0pOTtb3339/xHHPPfcoPT1dCxYs0MiRI/X99997Rk4czciRI7V582Z99913xzwnMTFRkvTHH39Uu3zevHknXXdlGBYQEFDt8v/85z/V/hwUFKSzzjpLH3744TGDtUqBgYG67bbb9Oabb2rq1Kk67bTTNHjw4JOuCYB3YVdHAF7hu+++044dO464fMqUKTrvvPN09tln695775Xdbtf06dO1du1azZkzx/Nmp3///rrooovUo0cPNW/eXBs2bNDbb7+tgQMHKjg4WH/88YfuuOMOXX311erQoYPsdru+++47/fHHH3rwwQcb+NkCAAB4lwULFmjv3r16+umnNXTo0COuT0lJ0b///W+9/vrr+ve//60FCxbozDPP1N///nd1795dBw8e1FdffaUJEyaoc+fOuuuuu/T+++/r0ksv1YMPPqh+/fqpuLhYixYt0kUXXaSzzz5bLVu21LnnnqspU6aoefPmSkhI0LfffqtPPvnkpOvu3LmzkpOT9eCDD8owDEVGRuqLL77QwoULjzi3cqfH/v3768EHH1T79u21b98+zZs3T//5z38UFhbmOXf8+PF65plntHLlSs2cObNW31MAXsLc2foAmrrKXR2PdWzfvt1YsmSJcc455xghISFGUFCQMWDAAOOLL76odj8PPvig0adPH6N58+ZGQECAkZSUZNx9991Gdna2YRiGsW/fPmP06NFG586djZCQECM0NNTo0aOH8fzzzxvl5eVmPHUAAACvcdlllxl2u/24Ox5ee+21hp+fn5GRkWHs2rXLuOWWW4yWLVsa/v7+RqtWrYxrrrnG2Ldvn+f8AwcOGH/729+Mtm3bGv7+/kZMTIxx4YUXGhs3bvSck56eblx11VVGZGSkERERYdxwww3GihUrjrqrY0hIyFHrWr9+vXHeeecZYWFhRvPmzY2rr77aSEtLMyQZ//jHP4449+qrrzZatGhh2O12o23btsbo0aONkpKSI+536NChRmRkpFFUVHSS30UA3shiGIZhWuoGAAAAAICXyczMVEJCgv7617/qmWeeMbscAKeApY4AAAAAAEjavXu3tm3bpmeffVZWq1V/+9vfzC4JwCliuD0AAAAAAJJmzpypoUOHat26dXr33XfVunVrs0sCcIpY6ggAAAAAAIBGiY4vAAAAAAAANEoEXwAAAAAAAGiUCL4AAAAAAADQKPnEro4ul0t79+5VWFiYLBaL2eUAAAAfYBiG8vPz1apVK1mtfNbnrXifBwAAaqom7/N8Ivjau3ev4uPjzS4DAAD4oF27dqlNmzZml4Fj4H0eAACorZN5n+cTwVdYWJgk9xMKDw83uRoAAOAL8vLyFB8f73kfAe/E+zwAAFBTNXmf5xPBV2Xbe3h4OG+IAABAjbB8zrvxPg8AANTWybzPY+AFAAAAAAAAGiWCLwAAAAAAADRKBF8AAAAAAABolHxixhcAAHXNMAyVl5fL6XSaXQpOgb+/v2w2m9lloJ7xekVds9ls8vPzYwYgADQBBF8AgCbH4XAoPT1dRUVFZpeCU2SxWNSmTRuFhoaaXQrqCa9X1Jfg4GDFxcXJbrebXQoAoB4RfAEAmhSXy6Xt27fLZrOpVatWstvtfOLvowzDUFZWlnbv3q0OHTrQ+dUI8XpFfTAMQw6HQ1lZWdq+fbs6dOggq5UJMADQWBF8AQCaFIfDIZfLpfj4eAUHB5tdDk5RdHS0duzYobKyMoKvRojXK+pLUFCQ/P39tXPnTjkcDgUGBppdEgCgnvDRBgCgSeLT/caB7p+mgdcr6gN/rwCgaeD/9gAAAAAAAGiUCL4AAAAAAADQKBF8AQDQBCUmJmratGl1cl8//PCDLBaLDh48WCf3B6C6uny9AgDQ1DDcHgAAHzF06FCddtppdfIL8K+//qqQkJBTLwrAUfF6BQDAOxB8AQDQSBiGIafTKT+/E//zHh0d3QAVATgWXq9VHA6H7Ha72WUAABopljoCAJo8wzBU5Cg35TAM46RqHD16tBYtWqQXXnhBFotFFotFs2fPlsVi0ddff60+ffooICBAS5YsUWpqqi699FLFxsYqNDRUffv21f/+979q93f40imLxaKZM2fq8ssvV3BwsDp06KB58+bV+nv68ccfq1u3bgoICFBiYqKee+65atdPnz5dHTp0UGBgoGJjY3XVVVd5rvvoo4/UvXt3BQUFqUWLFjr33HNVWFhY61rQePjCa1Xy7ter0+nUmDFj1K5dOwUFBalTp0564YUXjjhv1qxZntdwXFyc7rjjDs91Bw8e1G233abY2FgFBgYqJSVF//3vfyVJEydO1GmnnVbtvqZNm6bExMRq35/LLrtMU6ZMUatWrdSxY0dJ0jvvvKM+ffooLCxMLVu21PXXX6/MzMxq97Vu3TpdeOGFCg8PV1hYmIYMGaLU1FQtXrxY/v7+ysjIqHb+PffcozPPPPOkvjcAgMaJji8AQJNXXOZU18e+NuWx108eoWD7if85fuGFF7R582alpKRo8uTJkty/AErS/fffr3/9619KSkpSs2bNtHv3bl1wwQV64oknFBgYqDfffFMXX3yxNm3apLZt2x7zMSZNmqRnnnlGzz77rF566SX96U9/0s6dOxUZGVmj57Ry5Updc801mjhxokaNGqWlS5dq/PjxatGihUaPHq0VK1bozjvv1Ntvv61BgwZp//79WrJkiSQpPT1d1113nZ555hldfvnlys/P15IlS2oUOqDx8oXXquTdr1eXy6U2bdrogw8+UFRUlJYuXarbbrtNcXFxuuaaayRJM2bM0IQJE/TUU09p5MiRys3N1U8//eS5/ciRI5Wfn6933nlHycnJWr9+vWw220l9byp9++23Cg8P18KFCz2vb4fDoccff1ydOnVSZmam7r77bo0ePVrz58+XJO3Zs0dnnnmmhg4dqu+++07h4eH66aefVF5erjPPPFNJSUl6++23dd9990mSysvL9c477+ipp56qUW0AgMaF4AsAAB8QEREhu92u4OBgtWzZUpK0ceNGSdLkyZN13nnnec5t0aKFevbs6fnzE088oU8//VTz5s2r1rVxuNGjR+u6666TJD355JN66aWXtHz5cp1//vk1qnXq1KkaNmyYHn30UUlSx44dtX79ej377LMaPXq00tLSFBISoosuukhhYWFKSEhQr169JLmDr/Lycl1xxRVKSEiQJHXv3r1Gjw+YzZtfr/7+/po0aZLnz+3atdPSpUv1wQcfeIKvJ554Qvfcc4/+9re/ec7r27evJOl///ufli9frg0bNng6tZKSkk78TTlMSEiIZs6cWW2J4y233OL5OikpSS+++KL69eungoIChYaG6uWXX1ZERITmzp0rf39/SfLUIEljxozRG2+84Qm+vvzySxUVFXmeFwCgaSL4AgA0eUH+Nq2fPMK0xz5Vffr0qfbnwsJCTZo0Sf/973+1d+9elZeXq7i4WGlpace9nx49eni+DgkJUVhY2BHLjE7Ghg0bdOmll1a7bPDgwZo2bZqcTqfOO+88JSQkKCkpSeeff77OP/98z5Ktnj17atiwYerevbtGjBih4cOH66qrrlLz5s1rXAcaH19/rUre8Xp95ZVXNHPmTO3cuVPFxcVyOBye5YmZmZnau3evhg0bdtTbrl69Wm3atKkWONVG9+7dj5jrtWrVKk2cOFGrV6/W/v375XK5JElpaWnq2rWrVq9erSFDhnhCr8ONHj1ajzzyiH755RcNGDBAs2bN0jXXXMPGAADQxBF8AQCaPIvFctJLmLzR4b/U3Xffffr666/1r3/9S+3bt1dQUJCuuuoqORyO497P4b9MWiwWzy+eNWEYhiwWyxGXVQoLC9Nvv/2mH374Qd98840ee+wxTZw4Ub/++quaNWumhQsXaunSpfrmm2/00ksv6eGHH9ayZcvUrl27GteCxsXXX6uS+a/XDz74QHfffbeee+45DRw4UGFhYXr22We1bNkySVJQUNBxb3+i661W6xFLk8vKyo447/DvQ2FhoYYPH67hw4frnXfeUXR0tNLS0jRixAjP9+JEjx0TE6OLL75Yb7zxhpKSkjR//nz98MMPx70NAKDxY7g9AAA+wm63y+l0nvC8JUuWaPTo0br88svVvXt3tWzZUjt27Kj/Ait07dpVP/74Y7XLli5dqo4dO3rmAPn5+encc8/VM888oz/++EM7duzQd999J8n9C/zgwYM1adIkrVq1Sna7XZ9++mmD1Q/UBW99vS5ZskSDBg3S+PHj1atXL7Vv316pqame68PCwpSYmKhvv/32qLfv0aOHdu/erc2bNx/1+ujoaGVkZFQLv1avXn3CujZu3Kjs7Gw99dRTGjJkiDp37nxEB1uPHj20ZMmSowZplcaOHau5c+fqP//5j5KTkzV48OATPjYAoHGrVfA1ffp0tWvXToGBgerdu7dnIO3RjB492rObzaFHt27dal00AABNUWJiopYtW6YdO3YoOzv7mN0d7du31yeffKLVq1fr999/1/XXX1+rzq3auueee/Ttt9/q8ccf1+bNm/Xmm2/q3//+t+69915J0n//+1+9+OKLWr16tXbu3Km33npLLpdLnTp10rJly/Tkk09qxYoVSktL0yeffKKsrCx16dKlweoH6oK3vl7bt2+vFStW6Ouvv9bmzZv16KOP6tdff612zsSJE/Xcc8/pxRdf1JYtW/Tbb7/ppZdekiSdddZZOvPMM3XllVdq4cKF2r59uxYsWKCvvvpKkjR06FBlZWXpmWeeUWpqql5++WUtWLDghHW1bdtWdrtdL730krZt26Z58+bp8ccfr3bOHXfcoby8PF177bVasWKFtmzZorffflubNm3ynDNixAhFREToiSee0J///OdT/XYBAE6FYbgPk9U4+Hr//fd111136eGHH9aqVas0ZMgQjRw58phzCF544QWlp6d7jl27dikyMlJXX331KRdfF9btzdXl03/Sda/+YnYpAAAc17333iubzaauXbt6lgEdzfPPP6/mzZtr0KBBuvjiizVixAidfvrpDVbn6aefrg8++EBz585VSkqKHnvsMU2ePFmjR4+WJDVr1kyffPKJzjnnHHXp0kWvvPKK5syZo27duik8PFyLFy/WBRdcoI4dO+qRRx7Rc889p5EjRzZY/UBd8NbX67hx43TFFVdo1KhR6t+/v3JycjR+/Phq59x8882aNm2apk+frm7duumiiy7Sli1bPNd//PHH6tu3r6677jp17dpV999/v6e7rUuXLpo+fbpefvll9ezZU8uXL/eE3scTHR2t2bNn68MPP1TXrl311FNP6V//+le1c1q0aKHvvvtOBQUFOuuss9S7d2+99tpr1ZZ9Wq1WjR49Wk6nUzfddNOpfKsAADVlGFLWJmnFLOmjMdLUrtLuX098u3pmMWq4P3j//v11+umna8aMGZ7LunTpossuu0xTpkw54e0/++wzXXHFFdq+fbtnt6YTycvLU0REhHJzcxUeHl6Tck9oW1aBznlukYL8bVo3aYSsVsuJbwQA8FklJSXavn27p3MZvu14P8/6fP+AunO8nxOvV9TGrbfeqn379mnevHnHPY+/XwBwilwuKXOdtHOptONH93+LsqufM+wf0pAJdf7QNXmfV6PpoA6HQytXrtSDDz5Y7fLhw4dr6dKlJ3Ufr7/+us4999zjhl6lpaUqLS31/DkvL68mZdZIfGSw/KwWFZc5lZFXolbNjj80EwAAAID3yc3N1a+//qp3331Xn3/+udnlAEDj4yyXMv6Qdv7kDrl2LpVKDlY/xy9QatNXRsJgHYzuq4B2/RVsSrGHlFSTk7Ozs+V0OhUbG1vt8tjYWGVkZJzw9unp6VqwYIHee++94543ZcoUTZo0qSal1Zq/zaqEFsFKzSpUalYBwRcAAIcZN26c3nnnnaNed8MNN+iVV15p4IoAHEtTfr1eeumlWr58uW6//Xadd955ZpcDAL6v3CHtXSXtrOjmSlsmOfKrnWLYQ1Ua11d7I3ppnX93/VzcVptyHNqyKF95JaWaeVORzu0aZtITcKvVftBH26L88MuOZvbs2WrWrJkuu+yy45730EMPacKEqla4vLw8xcfH16bUk5IcHeoOvjILNKRDdL09DgAAvmjy5MnHnNHDEkLAuzTl1+sPP/xgdgkA4NvKiqXdKyq6uX6Udv0qlRdXP8U/THvCT9MfthQtKu2gbw60VP6mQ8/Y5/nKapHS80oapvbjqFHwFRUVJZvNdkR3V2Zm5hFdYIczDEOzZs3SjTfeKLvdftxzAwICFBAQUJPSTklSdKikfdqWXdhgjwkAgK+IiYlRTEyM2WUAOAm8XgEAJ620QNq9XNpRsXRxzwrJ6ah2Sr4tQr9bu+qHkg5aWt5ZG0vaypVffZ9EP6tF7aJC1CE2VO1jwtQ+JlQdYkLVLipEgf62hnxGR1Wj4Mtut6t3795auHChLr/8cs/lCxcu1KWXXnrc2y5atEhbt27VmDFjaldpPUqODpEkpWYVmFwJAAAAAABAPSjJldJ+kXb+JNf2H2VJ/10Wo7zaKZlGMy1zddYyVxf94uqirUZrSe4VfgF+VnWODvUEW5VBV0KLYPnbrEd5QO9Q46WOEyZM0I033qg+ffpo4MCBevXVV5WWlqZx48ZJci9T3LNnj956661qt3v99dfVv39/paSk1E3ldcjd8SVty6LjCwAAAAAAb5FfUqatmQXaklmgrZkFSsspUrDdpuYhdkWG2NWi8r+hdkWGBCgyxK7wQL+TGsfU6BXtV8nWxcrftFh+u5YqIm+TrHJJkipjqt1GlCfoWu7qrB1GS4XY/dQ+LlQ9Y8J0Vaw75GofE6o2zYNls/re97XGwdeoUaOUk5OjyZMnKz09XSkpKZo/f75nl8b09HSlpaVVu01ubq4+/vhjvfDCC3VTdR2r7PhKzy1RQWm5QgNqNfoMAAAAAADUwoFCh7ZkFmhLZr62VoRcW/YVKKMWM6L8rBY1PyQUqwrIAhQZWv3yyBC7mgfbfTLQOVRuUZl27Nymgs2LZN/9s1oe/E3xZTsUKCnwkPO2u2I9Idd6ew+FtmynDrGh6hQTpgsrOrniIgIbVXBYq4Rn/PjxGj9+/FGvmz179hGXRUREqKioqDYP1SCaBdsVFWpXdoFD27MK1b1NhNklAQAAAADQqBiGoaz8Uk/31pbMfG3Z5/46p9BxzNvFhAWoQ2yoOlQsqystd2l/oUM5BQ7tLyx1f13o0IFChwodTpW73I+TlV96UnVZLFKzIP+KgMzdNVYZkDUPruwms1e73u7X8Ev7DMNQTqHD/T3LKlDmrq0K3PuLWh38TT2c69TTmn7EbTa7WusPWzftbdZbJa36q2WbdmofE6phMWGKCrU3qoDrWGhtqpAUFarsgv3all1A8AUAAAAAQC25XIb25hZX69zamlWgLfvylVdSfszbtW4W5J4bFR1abVB6RJD/ST92SZlT+wsdnjBsf2FpRUDm0IEih+fryutzi8tkGNKBojIdKCpT6kmOQAoL8FNkaEUwVtk9FlrVWXZ4V1mw3XbSIZNhGNqXV+oJBrdkFih1X76KM7eqs2ON+ls3aqhlg+KtWVU3skouWZTmn6R9zXvL0WagwjoOUWLbBF0VfPwNBhs7gq8KyTEhWr5jv1IzGXAPAMDR7NixQ+3atdOqVat02mmnmV0OAAAwmdNlaNf+oiOWKG7NLFCRw3nU21gtUkKLECVXhFuV86OSo0MVUgdjhwL9bWrVLEitmgWd1PllTpcOFDl0oLBMORXdY1XdZNWPnIrwzOkylF9arvzScu3MObnVbQF+VncYFnr0YCy/pKwq5MosUH5pmZIte9XfulEDrBt0p3Wj4iz7pUMyQJdsOhjRReVtBym045kKbn+GEoOaK7EW37fGjOCrQnLFgPvUbAbcAwC809ChQ3Xaaadp2rRpdXJ/o0eP1sGDB/XZZ5/Vyf0BqMLrFUBj4ih3aWdO4SFLFN3dW9uyC+Uodx31Nn5Wi9pFhVTr3OoQE6p2USEK9Lc18DM4Nn+bVTFhgYoJC5QUdsLzXS5DeSVlFd1k7oDsQJGj2tLLnMPCMke5S6XlLu3NLdHe3KPPLLPIpU6W3epv3aBbrRvUP2Cjoix51R/b6i+1Ol3WxMFS4mBZ4/srMuDENTd1BF8VkioG3NPxBQAAANS9srIy+fuf/HIleJnCbGnnT9KOn6TszVJsNynxDKntACmoudnVoZJhSPu3uX9WO5dKRfulNn2lhEFS696Sf+Bxb15S5lRqVsERSxR3ZBeq3GUc9TYBflYlR4d6gq3KoCuhRbD8bQ0/B6u+Wa0WNQu2q1mwXcnRJz7fMAwVOZxHLL08kF8k/+x1ispeoTZ5v6lj6VqFuPKr39gvsOLnVxF0te4j2YPr54k1YgRfFSo7vrZnF8rlMmT18R0dAAA1YBhSmUmbsPgHuyeqnsDo0aO1aNEiLVq0yLNL8vbt21VUVKR7771XixcvVkhIiIYPH67nn39eUVFRkqSPPvpIkyZN0tatWxUcHKxevXrp888/17PPPqs333xTkjzzJr7//nsNHTq0RuUvWrRI9913n37//XdFRkbq5ptv1hNPPCE/P7/jPn5ISIh++OEH3X///Vq3bp38/f3VrVs3vffee56dooEj+MBrVfKe1+sDDzygTz/9VLt371bLli31pz/9SY899li18GnevHmaPHmy1q5dq9DQUJ155pn65JNPJEmlpaV69NFHNWfOHGVmZqpt27Z68MEHNWbMGM2ePVt33XWXDh486Lmvzz77TJdffrkMw/3L8cSJE/XZZ5/pzjvv1BNPPKEdO3bI6XTq66+/1hNPPKG1a9fKZrNp4MCBeuGFF5ScnOy5r927d+vee+/VN998o9LSUnXp0kUvv/yyYmNjlZSUpOXLl6tPnz6e81966SX961//0o4dO5rEoOYGkZdeEZ5Uhl2bql+/7Xvp539LskixKe5gJXGw+xf0kChTSm6SDEPK2lT1s9q5VMo/bMD5lq/d/7UFeEKw4tYDtNW/izYdcGlLZr5SK7q40vYXyTh6vqUQu03tY9yh1qFLFNs0D/b5HRHrk8ViUUiAn0JsLsUXrJGyKn5Wacskx2FBl3+I1La/+3WUMFhqfbrkF2BO4Y0IwVeFNs2DZbdZVVru0p6DxYqPJEUFgCajrEh6spU5j/33vZI95ISnvfDCC9q8ebNSUlI0efJkSZLT6dRZZ52lW2+9VVOnTlVxcbEeeOABXXPNNfruu++Unp6u6667Ts8884wuv/xy5efna8mSJTIMQ/fee682bNigvLw8vfHGG5KkyMjIGpW+Z88eXXDBBRo9erTeeustbdy4UbfeeqsCAwM1ceLE4z5+eXm5LrvsMt16662aM2eOHA6Hli9fzi+sOD4feK1K3vN6DQsL0+zZs9WqVSutWbNGt956q8LCwnT//fdLkr788ktdccUVevjhh/X222/L4XDoyy+/9Nz+pptu0s8//6wXX3xRPXv21Pbt25WdnV2jb9vWrVv1wQcf6OOPP5bN5l7aVFhYqAkTJqh79+4qLCzUY489pssvv1yrV6+W1WpVQUGBzjrrLLVu3Vrz5s1Ty5Yt9dtvv8nlcikxMVHnnnuu3njjjWrB1xtvvKHRo0fz/5BTcWCnOzTZ+aP7v/u3HXlOTDd3wBXTRcr4wx2I5WyR9q1xH8v/4z4vqlNVCJYwWAqPa9jn0pi5XFLmOvf3vvJnVZRT/RybXWrdxx1w2VuoOPVHBe39RUGOnIrb/KggSZ0NmxxGkrJcnVXu6qIcV0cZClZEkL+nc8s9hytMHWJCFRcRyGusJspKpD0rKn5WP0m7lkvlxdXPCYiQEga6X1cJg6W4npKNzti6RvBVwWa1KDEqWJv3FSg1q4DgCwDgVSIiImS32xUcHKyWLVtKkh577DGdfvrpevLJJz3nzZo1S/Hx8dq8ebMKCgpUXl6uK664wtNF1b17d8+5QUFBKi0t9dxfTU2fPl3x8fH697//LYvFos6dO2vv3r164IEH9Nhjjyk9Pf2Yj79//37l5ubqoosu8nR5dOnSpVZ1AN7GW16vjzzyiOfrxMRE3XPPPXr//fc9wdc///lPXXvttZo0aZLnvJ49e0qSNm/erA8++EALFy7UueeeK0lKSkqq6bdCDodDb7/9tqKjq9YDXXnlldXOef311xUTE6P169crJSVF7733nrKysvTrr796Ar727dt7zh87dqzGjRunqVOnKiAgQL///rtWr17t6VTDSahcDrejIjjZ+ZOUu6v6ORar1LK7lHCGO8RqO1AKPkrgmr9PSlta8cv9Uncok73JfayY5T4nMqniF/sz3P9tTmfvSXOWSxm/V31/05ZKJbnVz/ELkuL7Vn1/2/SR4Reohz9bq/eWpUlKkHS92lky1N+6wXO0suxXb8sW9bZu0f/pCxkWq8pjusuv3RmyJA6W2nY++s8cR+colHYtc/+cdvzkDr2cjurnBEVWdEee4Q66YrtJVu+Zd9ZYEXwdIjk6tCL4KtTQTmZXAwBoMP7B7m4Osx67llauXKnvv/9eoaGhR1yXmpqq4cOHa9iwYerevbtGjBih4cOH66qrrlLz5nUzi2XDhg0aOHBgtU9/Bw8erIKCAu3evVs9e/Y85uNHRkZq9OjRGjFihM477zyde+65uuaaaxQXR1cAjsNHX6uSOa/Xjz76SNOmTdPWrVs9wVp4eLjn+tWrV+vWW2896m1Xr14tm82ms846q9aPL0kJCQnVQi/J/XwfffRR/fLLL8rOzpbL5R6MnZaWppSUFK1evVq9evU6ZlfbZZddpjvuuEOffvqprr32Ws2aNUtnn322EhMTT6nWRs0wpKyNVcsWdy6VCjKqn2P1k1r1qurSattfCow48X2HxUrdLncfknum1M6lVd1jGWvcIdv+bdKqd9znRMRXPE5FABCZdNJLiRu9coe097eqn9WuZZLjsDnU9lD3bLXKMLFVL8nPXu2UL//YWxF6SXERgRXzt5LUIXa42sSEKigqRCpLrwppdv4oy4Ed8t/3u7Tvd+mXl+VextqtqhspYZAUGtNA3wgfUJLrXq6480f39zB9teQqr35OaKxnPpcSBru7Ia2Nb+6ZtyP4OkTlgPttWQy4B4AmxWI56SVM3sTlcuniiy/W008/fcR1cXFxstlsWrhwoZYuXapvvvlGL730kh5++GEtW7ZM7dq1O+XHNwzjiCUPlbN9LBbLCR//jTfe0J133qmvvvpK77//vh555BEtXLhQAwYMOOXa0Ej56GtVavjX6y+//OLp5hoxYoQiIiI0d+5cPffcc55zgoKCjnn7410nSVar1fN6r1RWVnbEeSEhR/68Lr74YsXHx+u1115Tq1at5HK5lJKSIofDcVKPbbfbdeONN+qNN97QFVdcoffee6/Ods9sNFxOad+6ivDkRynt56Mvh6scep4wWIrvVzevr+BIqctF7kM6JByoWO61d5W7u+yPue5DkkJbVp8RFt256QRhZcXS7hVVP6vdK45cDhcYIbU95PvTsodkO/av8gcKHZo4b50k6c5hHTThvI7HODNRap4onXa9+4+5e6o6AHdWbGKwb637WP6q+5yojlXhaOJgKdyk5edm8IS6Fd+fjDWScdiOloS6Xong6xCVA+5TCb4AAF7IbrfL6XR6/nz66afr448/VmJiomeY/OEsFosGDx6swYMH67HHHlNCQoI+/fRTTZgw4Yj7q6muXbvq448/rhaALV26VGFhYWrduvUJH1+SevXqpV69eumhhx7SwIED9d577xF8oVEw+/X6008/KSEhQQ8//LDnsp07d1Y7p0ePHvr222/15z//+Yjbd+/eXS6XS4sWLfIsdTxUdHS08vPzVVhY6Am3Vq9efcK6cnJytGHDBv3nP//RkCFDJEk//vjjEXXNnDlT+/fvP2bX19ixY5WSkqLp06errKxMV1xxxQkfu1Fzlknpf1TNfNr5s1R6tOVw/SqWWA1yz4A6wQ5/dSIwQuo43H1IFcvBllcNYt/9q7v7bN0n7kOSglu4l1Y2xuVgpQUVy+Eqnv+elUcuhwuOOmQ53CD3bLUadAk9/uV6ZRc41CEmVH85O/nEN6gU0VrqcbX7kKSCzEOCnqXuACx7s/tY6Z43qOaJVcthEwZJzRIaT9CTv6/que/8Scpcf+Q5LOP1CQRfh0iqCL62ZRWaXAkAAEdKTEzUsmXLtGPHDoWGhuovf/mLXnvtNV133XW67777FBUVpa1bt2ru3Ll67bXXtGLFCn377bcaPny4YmJitGzZMmVlZXlmaSUmJurrr7/Wpk2b1KJFC0VERFTb7e1Exo8fr2nTpumvf/2r7rjjDm3atEn/+Mc/NGHCBFmtVi1btuyYj799+3a9+uqruuSSS9SqVStt2rRJmzdv1k033VRf3z6gQZn9em3fvr3S0tI0d+5c9e3bV19++aU+/fTTauf84x//0LBhw5ScnKxrr71W5eXlWrBgge6//34lJibq5ptv1i233OIZbr9z505lZmbqmmuuUf/+/RUcHKy///3v+utf/6rly5dr9uzZJ/y+NG/eXC1atNCrr76quLg4paWl6cEHH6x2znXXXacnn3xSl112maZMmaK4uDitWrVKrVq10sCBAyW5ZwIOGDBADzzwgG655ZYTdok1OuWl0p7fqjpP0pZJZYf9DmMPq1oOl3iGFHfaEcvhTGEPkZLPdh9S1QDwnUvdHU+7lru70zb+131Ihw0AP0OK6+E7A8CLD0ppvxzS8bZaMg4LscPiqncJRXWsdXi0aHOWPvltjywW6akreyjA7xQCw9AYqdtl7kNydzyl/Vz1s8r4Qzqww32srljGGt7mkO69M6QWyb4ThOXurhpEv/MnKWfrkedU27hhUNPqePNhBF+HqFzqmJlfqrySMoUH+sj/TAEATcK9996rm2++WV27dlVxcbG2b9+un376SQ888IBGjBih0tJSJSQk6Pzzz5fValV4eLgWL16sadOmKS8vTwkJCXruuec0cuRISdKtt96qH374QX369FFBQYG+//57DR069KTrad26tebPn6/77rtPPXv2VGRkpMaMGeMZqH28x9+3b582btyoN998Uzk5OYqLi9Mdd9yh22+/vT6+dUCDM/v1eumll+ruu+/WHXfcodLSUl144YV69NFHNXHiRM85Q4cO1YcffqjHH39cTz31lMLDw3XmmWd6rp8xY4b+/ve/a/z48crJyVHbtm3197//XZJ7V8l33nlH9913n1599VWde+65mjhxom677bbjfl+sVqvmzp2rO++8UykpKerUqZNefPHFas/Fbrfrm2++0T333KMLLrhA5eXl6tq1q15++eVq9zVmzBgtXbpUt9xyy0n+VHyYo6j67nC7f5XKS6qfE9isatli4mAptvtxl8N5Df9Ad9iTeIZ01v3uGVfpq6sG76f94u5e2/yV+5Ak/xD3DLLKJXetT5f8Akx9Gh6FOYcM+/9RylgrqfqyYEW0rR6e1NFyuMLScv39kzWSpJsHJqp3Qt3M9PQIjpQ6X+g+JKkkr6p7bcdP7tlkebulNR+4D6lixtWgqp9VdGfvmHFlGNKB7YfMOPtJOrjzsJMsUmxKVZDXdpAUGn3Uu4N3sxiHL873Qnl5eYqIiFBubm61gZz1od8//6fM/FJ99pfBOi2+Wb0+FgCg4ZWUlGj79u1q166dAgMbYIkH6tXxfp4N+f4BtXe8nxOvVxzPP//5T82dO1dr1qyp1e29+u9Xab47UNhxyHI412Ez1EKiqy+xiunqHYFCXXOWuzuLDl1yV3Kw+jl+gRXzyipCv9Z9JPupbUhx0vIzqm8akLXhyHMik6sHXc3a1kspE+et0+ylO9S6WZC+uftMhQQ0cPDpKHSHspXfi92/Ss7S6udU7mpY+b1o2b1hlrEahpS9pWo58I6fpPzDNkux2KS4nlWdd20HSEF1HB6iztTkfZ4PfATQsJKiQ5SZX6ptWQUEXwAAAICXKSgo0IYNG/TSSy/p8ccfN7uculF8sGIJWUWAkv77sZfDVS4hi+rgO0vIToXNz93R1fp0adAdksvlnrVUuRxtx09SUba0Y4n7WCTJ6i+17l3VqRPfXwoIq5t6Du6q/tj7U488J7pL9WH9YS3r5rGPY+XOA3rz5x2SpClXdG/40EtyL2NNGuo+pIplrCurdvjctVwq3n/YMtbwiiW5gyuW5Pasm2Wsnr8nS6vCrsKs6udY/d1/rw7dybSu/p7AqxB8HSY5OlS/bNvPgHsAQJPz5JNP6sknnzzqdUOGDNGCBQsauCIAx9KUX6933HGH5syZo8suu8x3lzkWZh+2O9xRlsM1a1t9aHjzdk0j6DoRq1VqmeI++t9evZOncslafrq06xf38ePUqk6eyiDqZDt5DEPav63qZ7XjJyk37bCTLO5aKjvvEgZJIVH18tSPpbTcqQc//kOGIV1xemud2dFLluP5B7q/54mDJd1XsYz196ogKu0XqTRP2vKN+5Dcy1jj+x3Svdf75Jax1qgzsKLjrE3fhusMhKkIvg6TzIB7AEATNW7cOF1zzTVHva7JDY4GvFxTfr3Onj37pAbpe5X8jKqZVTt/krI2HnlOi/ZVnScJg6Rm8Q1fpy+yWKToju6jzy1Vs5sql9vt/FE6mOaeP7X3N2npS/LMbjp0+WFIlPu2WZuqAsmdS90hWrXHs0mtTqtaZtp2gBTUzIQnXmX696naklmgqFC7Hr2wq6m1HJefXYrv6z7OuFtyOavCqh0/uWejFR+Qtn3vPiTJFuAOqCoD4Db93GHV0WbBOfKrP15liFbZJelNs+DQoAi+DlM54J6OLwBAUxMZGanIyEizywBwEni9ehmXUyrYJ+XukfL2SHl73f/N3e3+xX7/tiNvE9O1+qyjBlgO1yRYLO5h8ZFJ0uk3ui87uKv6krecrdK+Ne5j2Svuc6I6unctLMqufn+VyyYrQ7L4fl61HG5TRr6m/+DefXDiJd3UPMQLdu48WVab1KqX+xj4F/fyxKwN1XdWLMyq+Ln9WHEbfym6k/s1VVZU/f4CwqW2A6t+VnW1bBI+j+DrMJUdXzuyi+R0GbJZaScGgMbIB/Z2wUng59g08HNGfTjpv1fHCrXy9lRcttfdFXT4TK5qLO4h3olnVCy1GyiFtKiT54GT0CxeajZK6jnK/ef8jOrLF7M2SNmb3ddVLodLrFi62Kav5O+dXZROl6EHPv5DZU5D53aJ1YXd48wu6dRYrVJsN/fR/zZ3B17O1oqurp+qBtLvW+s+/9BB+YmD3V18DTEoHz6H4OswrZsFKcDPqtJyl3YfKFJCixCzSwIA1CF/f/cnf0VFRY1+OVBT4HA4JEk2G290GyNer6hPRUVFkmHIvyRbys5wd2fVKtSqYLFJ4a0qjtZV/23R3t0lZPJyOBwirKWUcoX7kKTCHPcOhIERPrUcbvbSHVq966DCAvz0xGUpsjS2GXAWi3sTh6gOUp8/Vyxj3SFlrHG/rqI7N86dTFHnCL4OY7Va1C4qRBsz8pWaVUDwBQCNjM1mU7NmzZSZmSlJCg4ObnxvFJsIl8ulrKwsBQcHy8+PtzSNEa9XnBLDkFxl7qHXnv+Wy3A6VFTsUGZ2tppt/lC2D94+8X0dK9SKaF3x59ZSaAzdJr4qpIXU6Xyzq6iRXfuL9K+vN0mSHrqgi1pGBJpcUQOwWKTIdu4DqAHeJR5FckyoO/jKLNQ5nc2uBgBQ11q2dM9RqfxlGr7LarWqbdu2hCGNGK9XHJVhSIZLcpW7u7Fclcdhfz58p8RKToea7VygllveI9SCzzEMQw99skbFZU71bxepa/uyEQJwPARfR5Ec5e7y2pbNgHsAaIwsFovi4uIUExOjsrIys8vBKbDb7bKyzKFR4/XaBLmcUlGOVJDpnsVUkCkV7nP/tyBTyt/nHnitk1h+KJs7tDr0CImVf/Mo2RJvkS5+lFALPuejlbv149ZsBfhZ9dSVPWRlLjVwXARfR5Ec4x5wn5pZaHIlAID6ZLPZmA0F+Aher41YQZa07hNpwxfS/u21nKnVqqo7i04tNGKZ+SV6/L/rJUl3n9dR7aIYzQOcCMHXUSRFuYMvOr4AAACAelBaIG38UlrzgZT6/ZFBF6EWcFQT561TXkm5UlqHa+wZzLoCTgbB11EkRbtT8+wChw4WOdQs2G5yRQAAAICPc5ZJqd9Jf3wgbZovlRVVXdfqdKnHNVKbvoRawDF8tTZD89dkyGa16Okre8jPxlJ/4GQQfB1FSICf4iIClZ5botSsQvVOIPgCAAAAaswwpF3L3Z1d6z51z+6qFJkkdb9G6n61FNXevBoBH5BbXKbHPl8rSbr9zCR1axVhckWA7yD4Ooak6BCl55ZoW1aBeic0N7scAAAAwHdkbXJ3dq35UDq4s+rykGgp5Up34NX6dIkdWYGTMmX+BmXmlyopKkR3DutgdjmATyH4Oobk6FD9tDVHqVkMuAcAAABOKC9dWvuxu7sr/feqy/1DpC4XSz2ultoNlWz8CgLUxNLUbM39dZckacoV3RXozzJgoCb4V+cYkip2x9iWxYB7AAAA4KhKct27Mf7xgbR9sSTDfbnVT0oe5p7b1WmkZGfnOaA2ih1OPfTJGknSDQPaqn9SC5MrAnwPwdcxJMe4d3ZMJfgCAAAAqpSXSlsWuju7Nn0lOUurrovv757Z1e0KKYRf0IFT9fz/NmtnTpHiIgL1wPmdzS4H8EkEX8eQHO0OvnbmFKnM6ZI/O2YAAACgqXK5pLSl7s6u9Z+5O70qRXVyL2PsfrXUPNGsCoFG54/dBzVzyTZJ0hOXpSgs0N/kigDfRPB1DC3DAxXkb1NxmVO79hcpqSIIAwAAAJqMjLXuzq41H0t5u6suD4tzD6nvcY3UsgdD6oE6VuZ06f6P/pDLkC7u2UrDusSaXRLgswi+jsFqtSgpOkTr9uYpNauQ4AsAAABNw8Fd7t0Y13woZa6vujwgXOp6iXtHxsQzJCsDthuTcqdL+4sc2l/o0P4Ch3IKHTpQ5FBOQcVlhQ7lFJZqf6FDVotFD4zsrLM7xZhddqP1n0Wp2piRr+bB/vrHxV3NLgfwaQRfx5EcHVoRfBXoPJGwAwAAoJEq2u9ewvjHh+4ljZVsdqnDcPcyxo7nS/6BppWImikpcx4SWDm0v7D0sBDLoQOHfJ1bXFaj+7/97ZWaPbqvBrWPqqdn0HRtzSzQi99ulSQ9dnFXRYUGmFwR4NsIvo4jKZqdHQEAANBIlRVLm79yh11bvpFchwQfCWe453Z1vVQKam5ejZAkGYahgtLyqhCrMsCq6NByB1qlh4RcDhU5nDV+HItFah5sV2RIxRFsV2SoXS1Cqi5rERKgt37eoW/W79PYt1bonbH9dXpb/o7UFZfL0IMf/yGH06WhnaJ12WmtzS4J8HkEX8dROeA+NavQ5EoAAACAOuByStsXu5cxrp8nOfKrrotNcXd2db9KimhjXo1NgMtl6GBxWUVY5f5vziFLDI/WleVwumr8OP42iyfIahFqV2RIQLUQqyrMcv+3WbBdNuuJ57X1bddcY99coSVbsjV61nLNvW2gurYKr823Aod5Z9lOrdh5QCF2m564LEUW5ucBp4zg6zjo+AIAAIDPMwwpfbW7s2vtx1JBRtV1EfHuoKv7NVIsc4TqUmZeib5ev0+bMvIO6cpyHweKHHIZNb/PIH/bISHW0bqyAqqCrFC7wgL86iU4CfCz6T839taNry/Xyp0HdNOsZfrg9oHMRT5Few4W6+kFGyVJ95/fWW2aB5tcEdA4EHwdR1KU+3/cB4rKtL/QocgQu8kVAQAAACdp/zZpzUfSHx9IOVuqLg9sJnW73L0jY/wAyWo1rcTGZs/BYn21NkNfrU3Xip0HZJwg3AoP9Duk8yrAE1gdvSsrQEF279lQINjup1mj++q6V3/R+vQ83TBzmT78v0Fq3SzI7NJ8kmEYevjTNSp0ONU7obluHJBgdklAo0HwdRxBdptaNwvSnoPFSs0qUGRIpNklAQAAAMdWmC2t/URa84G0+9eqy/0CpU4j3Z1d7c+V/PhAt67szCnUgrUZWrA2Q7/vOljtutPim2lw+xaKDg1QZGjVMsMWIXY1D7HL3+bboWNEkL/eHtNP1/znZ6VmFepPr/2iD8YNVEwYmyDU1Oer9+qHTVmy26x6+srusp7EklMAJ4fg6wSSokO052CxtmUVqG8iwRcAAAC8jKNQ2vilu7Mr9TvJqBhqbrFK7c5yd3Z1vkgKZAZTXdmaWaCv1qZr/poMrU/P81xusUh9EyI1sntLjejWUq2aQPdTi9AAvTO2v66a8bN25BTppteXa+5tA9QsmHD1ZOUUlGrSF+skSX89p73ax4SZXBHQuBB8nUBydKiWbMlmwD0AAAC8h7NMSv3e3dm18UuprKjqurjT3GFXypVSWEvTSmxMDMPQxox8d2fXmnRtyayaAWyzWjQgKVLnp8RpRLfYJtntFBcRpPdu7a+rX/lZGzPydfMbv+rdsf0VGsCvmydj8n/X60BRmTq3DNPtZyWbXQ7Q6PB/ohNIZsA9AAAAvMkfH0hfPSQVZVdd1jzRvYyxxzVSVAfTSmtMDMPQ2j15mr82XV+tzdD27KoPwv1tFg1KjtIF3VvqvK4tmQUsKaFFiN4Z21/X/Odn/b7roG59c4Xe+HNfBfp7z1wyb/Tdxn36fPVeWS3S01f2kN3Pt5e/At6I4OsEkit2JqHjCwAAAKbbvlj6dJx7OWNwlJRyhTvwatPHvc4Op8TlMrRq10F9tTZdC9ZmaPeBYs91dj+rzuwQrQu6t9SwLrGKCPI3sVLv1DE2TG/d0k/Xv7ZMP2/L0V/e/U2v3Njb52eZ1Zf8kjI9/OlaSdKYM9qpZ3wzcwsCGimCrxNIjnEHX2n7i+Qod5HAAwAAwBz7t0sf3OwOvbpfLV02Q7IRvpwqp8vQrzv2V+zGmKGMvBLPdUH+Np3dOVrnp8TpnM4xLN07CT3aNNPrN/fRTbOW69uNmZrwwe+aNuo02RjWfoRnvtqk9NwStY0M1oTzOpldDtBo8X/uE4gJC1CI3aZCh1Np+wsZNAgAAICGV5ovzb1eKt4vteolXfISodcpKHO6tGzbfs1fm65v1mUou8DhuS40wE/ndI7RBd1b6qyOMQqys1SvpvontdB/buytW99aoS9+36sQu01TruguC12JHsu379fbv+yUJE25ojt/z4B6RPB1AhaLRckxofpjd662ZhJ8AQAAoIG5XO7ljZnrpdBYadS7kn/j3y2wrjnKXfppa7YWrE3XN+v36WBRmee68EA/nde1pS7o3lKD20cxl6oODO0Uoxeu7aU73vtNc3/dpdAAPz18YRfCL0klZU49+PEfkqRRfeI1uH2UyRUBjRvB10lIjnYHX9uyGXAPAACABrboKWnjfyWb3R16RbQ2uyKfUVLm1KLNWfpqbYb+t2Gf8kvKPddFhtg1oluszk+J08CkFow0qQcXdI/TU1f20P0f/aGZP25XWKC//nYumy+89N0WbcsuVHRYgP5+QRezywEaPYKvk5AU5d7ZMTWTAfcAAABoQOs+lRY97f76omlSfF9Ty/EFhaXl+mFTluavTdf3GzNV5HB6rosOC9DIlJY6P6Wl+iVGyo+h6/Xumj7xKiwt16Qv1uv5/21WaKCfxpzRzuyyTLNub67+s2ibJOnxS7spIpgly0B9I/g6CZUD7lOz6PgCAABAA0n/Q/psvPvrAX+Rev3J3Hq8WF5Jmb7bkKkFa9P1w6YslZa7PNe1igjU+SlxuqB7S53etrmsDFlvcH8e3E4FJeV6buFmPf7f9QoNsGlU37Zml9Xgyp0uPfDxHyp3GRUBbJzZJQFNAsHXSUiKdnd8bcsqkGEYrEsHAABA/SrIcg+zLyuSks6WzptsdkVe52CRQ9+s36ev1mboxy3Zcjirwq62kcEa2b2lRqbEqWebCN6/e4E7zmmvgtJy/WfxNj34yRoF2/10cc9WZpfVoF7/cbvW7slTeKCfJl3azexygCaD4OskJLYIkcUi5ZWUK7vAoeiwALNLAgAAQGNV7pA+uEnK3SVFJklXvyHZeNsuSdkFpfpm3T4tWJuun1NzVO4yPNclR4doZEqcRnZvqa5x4YRdXsZisejBkZ2VX1qu95al6e73VyskwKZzOseaXVqD2JFdqKkLN0uSHrmwq2LCAk2uCGg6+Bf0JAT62xTfPFhp+4uUmlVA8AUAAID6YRjSgvuktKWSPUy6bq4U1Nzsqky1L69EX63N0IK16Vq+fb8OybrUuWWYRlYsY+wQy+7r3s5isejxS1NUWFquz1fv1f+985tm/7mfBia3MLu0emUYhh785A+Vlrs0uH0LXd2njdklAU0KwddJSooOUdr+Im3LKtSApMb9P2YAAACY5NeZ0srZkizSVa9L0Z3MrsgUuw8UVYRdGVq580C167q3jvAsY2xXsQkVfIfNatG/ru6pwlKn/rdhn8a++avevXWATotvZnZp9Wbur7v0y7b9CvK3acrlPehGBBoYwddJSo4O1Q+bshhwDwAAgPqxfYn01YPur8/9h9RxhLn1NLC0nCJ9uSZdC9am64/dudWuO71tM41MidP5KS0VHxlsUoWoK/42q/59fS/dMvtXLU3N0c2zluv92weoc8tws0urc/vySvTk/A2SpHuGd1TbFvz9BRoawddJOnTAPQAAAFCnDuxwz/VylUvdr5YG32V2RQ1q6dZs3fzGcpU53esYLRapX2KkRqa01IiUloqLCDK5QtS1QH+bXrupj254fZlWpR3UDTOX68NxAxtVF59hGHrks7XKLylXz/hm+vPgdmaXBDRJBF8nKTk6VJKUmlVociUAAABoVEoLpDnXS8X7pbjTpEtecic/TYSj3KVHPl+rMqehnvHNdE2fNhretSVzdZuAkAA/zR7dT9e+9os2pOfphpnL9OG4gWrVrHEEnfPXZGjh+n3ys1r09JXdZbM2ndc14E2sZhfgKyqDr10HilRS5jS5GgAAADQKLpf06e1S5jopJEa69j3Jv3H80n+y3vp5h7ZlFapFiF1v3dJPf+qfQOjVhEQE++utW/opKSpEew4W64aZy5RdUGp2WafsYJFD/5i3VpI0fmhyo1zGCfgKgq+TFBVqV1ignwxD2plTZHY5AAAAaAwWPS1t/K9ks0vXvitFtDa7ogaVlV+qF/63RZJ034hOigjyN7kimCE6LEDvjO2v1s2CtC27UDe+vly5RWVml3VKnvhyg7ILHGofE6q/nNPe7HKAJo3g6yRZLJZDljsy5wsAAACnaP3n0qKn3F9f9LwU38/cekzw7NcblV9aru6tI3R1n3izy4GJWjUL0jtj+ysqNEAb0vP059nLVVhabnZZtbJ4c5Y+WrlbFov09JXdFeBnM7skoEkj+KoBBtwDAACgTmSskT4d5/56wHip1w3m1mOC33cd1Icrd0uSJl7SlflHULuoEL0ztp8igvz1W9pB3fb2Cp8bM1NYWq6/f7pGknTzwET1Tog0uSIABF81wIB7AADgy6ZPn6527dopMDBQvXv31pIlS457/ssvv6wuXbooKChInTp10ltvvVXt+tmzZ8tisRxxlJSU1OfT8H2F2e5h9mVFUtLZ0nmPm11Rg3O5DE38Yp0MQ7q8V2vCAXh0bhmuN2/ppxC7TT9tzdEd761SmdNldlkn7blvNmv3gWK1bhak+0Z0MrscACL4qhGWOgIAAF/1/vvv66677tLDDz+sVatWaciQIRo5cqTS0tKOev6MGTP00EMPaeLEiVq3bp0mTZqkv/zlL/riiy+qnRceHq709PRqR2BgYEM8Jd9U7pA+uEnKTZMik6Sr35BsTW+j9c9W79GqtIMKttv04MjOZpcDL3NafDPNvLmvAvys+t+Gfbr3w9/lchlml3VCv6Ud0BtLt0uS/nl5ikICmt5rG/BGBF81kOxZ6lgow/D+//ECAABUmjp1qsaMGaOxY8eqS5cumjZtmuLj4zVjxoyjnv/222/r9ttv16hRo5SUlKRrr71WY8aM0dNPP13tPIvFopYtW1Y7cBxfPSDt/Emyh0nXzZWCmptdUYMrKC3XlAUbJUl3nNNeseEEpTjSwOQWmnHD6fKzWvT56r165PO1Xv07mKPcpQc//kOGIV3Rq7WGdooxuyQAFQi+aqBti2DZrBYVlJYrM9/3t9gFAABNg8Ph0MqVKzV8+PBqlw8fPlxLly496m1KS0uP6NwKCgrS8uXLVVZWtdtaQUGBEhIS1KZNG1100UVatWrVcWspLS1VXl5etaPJ+HWmtGKWJIt05Uwpumkug3rpuy3Kyi9VQotgjTmjndnlwIud0zlWz486TRaL9N6yND21YKPXhl/Tf9iqzfsK1CLErkcv6mp2OQAOQfBVAwF+NrWNDJYkpWay3BEAAPiG7OxsOZ1OxcbGVrs8NjZWGRkZR73NiBEjNHPmTK1cuVKGYWjFihWaNWuWysrKlJ2dLUnq3LmzZs+erXnz5mnOnDkKDAzU4MGDtWXLlmPWMmXKFEVERHiO+PgmspPf9iXSggfcXw97TOp0vrn1mGR7dqFm/eheCvbohV3Z7Q4ndHHPVnrqiu6SpP8s3qaXv99qckVH2rwv31PXxEu6qXmI3eSKAByK4KuGkqLcyx1TsxlwDwAAfIvFUn3XPMMwjris0qOPPqqRI0dqwIAB8vf316WXXqrRo0dLkmw2d1gxYMAA3XDDDerZs6eGDBmiDz74QB07dtRLL710zBoeeugh5ebmeo5du3bVzZPzZgd2uOd6ucqllKukM+42uyLTPP7f9SpzGjqrY7SGdWEpGE7OqL5tPV1U//pms974abvJFVVxugzd/9EfKnMaOrdLjC7qEWd2SQAOU6vgq6Y7ApWWlurhhx9WQkKCAgIClJycrFmzZtWqYLMlx1QMuKfjCwAA+IioqCjZbLYjursyMzOP6AKrFBQUpFmzZqmoqEg7duxQWlqaEhMTFRYWpqioqKPexmq1qm/fvsft+AoICFB4eHi1o1ErLXDv4Fi8X4o7Tbr039IxwsbG7vuNmfpuY6b8rBY9elHXY4auwNGMOaOd7jq3gyRp0hfr9eEK7wjN31y6Q6t3HVRogJ8evyyFv9eAF6px8FXTHYEk6ZprrtG3336r119/XZs2bdKcOXPUubNv7t5S2fG1jY4vAADgI+x2u3r37q2FCxdWu3zhwoUaNGjQcW/r7++vNm3ayGazae7cubroootktR79LaRhGFq9erXi4uh4kCS5XNKnt0uZ66SQGOna9yT/ILOrMoWj3KXH/7tekvTnwYlqX/FhMlATfxvWQWMr5sI98PEfmr8m3dR6du0v0rNfb5IkPXRBZ8VFNM3XN+Dtary/6qE7AknStGnT9PXXX2vGjBmaMmXKEed/9dVXWrRokbZt26bIyEhJUmJi4qlVbSI6vgAAgC+aMGGCbrzxRvXp00cDBw7Uq6++qrS0NI0bN06Sewninj179NZbb0mSNm/erOXLl6t///46cOCApk6dqrVr1+rNN9/03OekSZM0YMAAdejQQXl5eXrxxRe1evVqvfzyy6Y8R6+z6Glp438lm1269l0porXZFZlm9tLt2pZdqKjQAN05rIPZ5cBHWSwWPXxhFxWUlmvur7v0t7mrFGy3mbKDomEY+vuna1Rc5lS/dpG6rm/bBq8BwMmpUcdXbXYEmjdvnvr06aNnnnlGrVu3VseOHXXvvfequLj4mI/jzbv9JEe7g689B4tV7HCaXA0AAMDJGTVqlKZNm6bJkyfrtNNO0+LFizV//nwlJCRIktLT06t18DudTj333HPq2bOnzjvvPJWUlGjp0qXVPsA8ePCgbrvtNnXp0kXDhw/Xnj17tHjxYvXr16+hn573Wf+5tOgp99cXPS/FN93vSWZ+iV781j34+/7zOyks0N/kiuDLLBaL/nl5d13UI05lTkPj3lmpZdtyGryOj3/boyVbsmX3s+qpK7rLamWJI+CtatTxVZsdgbZt26Yff/xRgYGB+vTTT5Wdna3x48dr//79x5zzNWXKFE2aNKkmpTWYyBC7mgX762BRmbZnF6prq0Y+lwIAADQa48eP1/jx44963ezZs6v9uUuXLlq1atVx7+/555/X888/X1flNR4Za6RP3Z10GjBe6nWDufWY7JmvNqmgtFw920ToqtPbmF0OGgGb1aLnR52mYodT327M1Jg3V+i9W/urR5tmDfL4WfmlnqW7d53bQUnRLN0FvFmthtvXZEcgl8sli8Wid999V/369dMFF1ygqVOnavbs2cfs+vL23X4qu75Ss1juCAAAgEMUZruH2ZcVSUlnS+c9bnZFplqVdkAfrdwtSZp4STe6YlBn/G1Wvfyn0zUwqYUKSst186zl2rwvv0Eee+K8dcotLlO3VuG6dUhSgzwmgNqrUfBVmx2B4uLi1Lp1a0VERHgu69KliwzD0O7du496G2/f7ccz4D6LAfcAAACoUO6QPrhJyk2TmreTrpol2Wo8UrfRcLkMTZy3TpJ05elt1Kttc5MrQmMT6G/Tazf3Uc/4ZjpQVKYbZi7Tzpz6/R3tm3UZ+nJNumxWi56+sof8bbXqJQHQgGr0Kq3NjkCDBw/W3r17VVBQ1R21efNmWa1WtWnjm63OngH3dHwBAACg0lcPSDt/kuxh0nVzpeBIsysy1ce/7dbvu3MVGuCnB87vZHY5aKRCA/z05p/7qnPLMGXml+pPM5cpPffY86RPRW5xmR79fK0k6dYhSUppHXGCWwDwBjWOpydMmKCZM2dq1qxZ2rBhg+6+++4jdgS66aabPOdff/31atGihf785z9r/fr1Wrx4se677z7dcsstCgryze1eWeoIAACAan59XVoxS5JFunKmFNPZ7IpMlV9Spqe/2iRJ+us57RUTHmhyRWjMmgXb9daYfkpsEazdB4p1w8xlyikorfPHeWrBBu3LK1W7qBDddS67kwK+osbBV013BAoNDdXChQt18OBB9enTR3/605908cUX68UXX6y7Z9HAkqKrljq6XIbJ1QAAAMBUO36UFtzv/nrYY1Kn882txwu89N1WZReUKikqRH8e3M7sctAExIQF6p2x/dUqIlCpWYW6adZy5RaX1dn9/5yaoznL3bOnn7qiuwL9bXV23wDql8UwDK9PbvLy8hQREaHc3FyvmPdV5nSpy6NfqdxlaOmD56hVM9/sXAMAoDHztvcPODqf/zkd2Cm9drZUlCOlXOXu9jrGpk9NRWpWgUY8v1jlLkNvjO6rszvHmF0SmpBtWQW65j8/K7vAoT4JzfXWmH4Ktp/arL1ih1MjX1isHTlFur5/Wz15efc6qhZAbdXk/QOT+GrB32ZVQotgSSx3BAAAaLJKC6S517tDr7ie0iUvNfnQyzAMTf5ivcpdhs7pHEPohQaXFB2qt27pr/BAP63YeUC3v71SpeXOU7rPaf/brB05RWoZHqgHRzbtZcyALyL4qqWkijlf7OwIAADQBLlc0mf/J+1bK4XESNe+J9mDza7KdN9tzNSizVnyt1n06EVdzS4HTVTXVuGafUs/BdttWrIlW3fOWaVyp6tW97Vmd65eW7JNkvTEZSkKD/Svy1IBNACCr1piwD0AAEATtvgZacM8yWaXRr0jRfjmbuV1qbTcqcf/u16SdMsZ7dQuKsTkitCUnd62uWbe1Ed2P6u+XrdP93/0R43nM5c5Xbr/4z/kMqSLesTp3K6x9VQtgPpE8FVLhw64BwAAQBOyfp70wxT31xdOldr2N7ceLzHrxx3akVOk6LAA/fUcdryD+Qa1j9L060+XzWrRJ6v26B/z1qkmI65fXbxNG9Lz1CzYXxMv6VaPlQKoTwRftUTHFwAAQBOUsVb69Hb31/3/Tzr9RnPr8RL78kr07++2SJIePL+zQgNObZg4UFfO7Rqrqdf0lMUivf3LTj379aaTul1qVoFe+Nb9d/qxi7oqKjSgPssEUI8IvmopuaLjKz23RIWl5SZXAwAAgHpXmCPNvU4qK5KShkrDnzC7Iq/x9IKNKnQ41attM13eq7XZ5QDVXHpaa/3zMvdOjNN/SNXL32897vkul6EHP/5DjnKXzuwYzd9pwMcRfNVSs2C7WoTYJUnbs1nuCAAA0Kg5y6QPbpIOpknN20lXvSHZ6GqSpJU7D+iTVXskSRMv7iartWnvbAnvdH3/tnr4gi6SpGe/3qS3ft5xzHPfXZ6mX3ccULDdpicvT5Glie/WCvg6gq9TwHJHAACAJmLBA9LOHyV7mHTdXCk40uyKvILLZWjivHWSpGv6tFHP+GbmFgQcx61nJunOc9pLkh77fJ0+Xrn7iHP2HizWU/M3SJLuH9FJbZqzWyvg6wi+TkHlgPtUBtwDAAA0XitmSStel2SRrnxNiulsdkVe48OVu7RmT67CAvx03wi+L/B+d5/XUX8enChJuu+j3/XV2nTPdYZh6JHP1qrQ4dTpbZvpxoGJ5hQJoE4RfJ0COr4AAAAauR0/SfPvc3897FGp00hz6/EiucVleuYr96Dwv53bQdFhDP+G97NYLHr0wq66pk8buQzpr3NWafHmLEnSvN/36ruNmbLbrHr6yh6ysWwXaBQIvk5BckxFx1cmwRcAAECjc2Cn9MGNkqtcSrlSOmOC2RV5lRe/3aKcQoeSo0N0E50x8CFWq0VTruihC7vHqcxp6La3V+jrdRma9MV6SdId57RXh9gwk6sEUFeYyHkKkqLcHV/bswvlchkM8gQAAGgsSgukuddLRTlSXE/pkn9LDLj22JqZrzeX7pAkPXZxN9n9+DwdvsVmtej5Uaep0FGuHzZl6fa3V0qSOsWGadxZySZXB6Au8S/UKWjTPEh2m1Wl5S7tOVhsdjkAAACoCy6X9Nn/SfvWSiEx0rXvSXYGXFcyDEOTvlivcpehc7vE6qyO0WaXBNSK3c+qGX/qrX7t3JtVWC3S01f1IMgFGhle0afAz2ZVQgv3myDmfAEAADQSi5+VNsyTrP7SqLeliDZmV+RV/rchU0u2ZMtus+rRi7qYXQ5wSoLsNr1+cx+NHpSo567pqdPYmRRodAi+TlHlgPtt7OwIAADg+zZ8If3wpPvri56X2g4wtx4vU1Lm1OP/dc9BGjuknRJahJhcEXDqwgL9NfGSbrq8FyE30BgRfJ0iz4B7Or4AAAB827510ie3u7/uP046/UZz6/FCr/+4XWn7ixQbHqC/nN3e7HIAADghgq9TVDngno4vAAAAH1aYI825ViorlJKGSsP/aXZFXic9t1j//m6rJOmhkV0UEsA+WQAA70fwdYqSY9zBFx1fAAAAPspZJn14s3QwTWreTrrqDclGqHO4pxZsVHGZU70TmuvS01qZXQ4AACeF4OsUJUW7lzpm5pcqv6TM5GoAAABQY189KO1YItlDpevmSMGRZlfkdVbs2K/PV++VxSJNuqSbLBaL2SUBAHBSCL5OUXigv6LDAiSx3BEAAMDnrJgl/TpTkkW6cqYUwy6Fh3O6DP1j3jpJ0rV945XSOsLkigAAOHkEX3UgOZoB9wAAAD5nx0/S/PvcX5/ziNRppLn1eKkPVuzSur15Cgv0073DO5ldDgAANULwVQeSohlwDwAA4FMOpkkf3Ci5yqVuV0hD7jG7Iq+UW1SmZ7/eJEm6+9yOahEaYHJFAADUDMFXHUiOZsA9AACAz3AUSnOul4pypLie0qUvS8ysOqpp327W/kKHOsSE6saBCWaXAwBAjRF81QGWOgIAAPgIw5A++z9p3xopJFq69j3JHmx2VV5p8758vfXzTknSYxd3lb+NXx0AAL6Hf73qQGXH147sIjldhsnVAAAA4JgWPyut/1yy+kuj3pEi2phdkVcyDEOTvlgnp8vQiG6xGtIh2uySAACoFYKvOtCqWZAC/KxyOF3afaDI7HIAAABwNBu+kL7/p/vri6ZKbQeYW48X+3rdPv20NUd2P6seubCr2eUAAFBrBF91wGa1qF2Ue7kjA+4BAAC80L510ie3u7/uP046/SZz6/FiJWVOPfHleknS7WcmKT6SpaAAAN9F8FVHGHAPAADgpQpzpDnXSWWFUruzpOH/NLsir/ba4m3afaBYcRGB+r+hyWaXAwDAKSH4qiMMuAcAAPBCzjLpw5ulgzul5onS1bMlm5/ZVXmtvQeL9fIPWyVJD13QRcF2vlcAAN9G8FVHkjwdXyx1BAAA8BpfPSTtWCLZQ6Xr5krBkWZX5NWmLNiokjKX+iVG6uIecWaXAwDAKSP4qiOVSx230fEFAADgHVK/l359TZJFuuI1KaaL2RV5tWXbcvTF73tltUj/uKSrLBaL2SUBAHDK6F2uI0kVSx2zCxzKLSpTRLC/yRUBAAA0cUlDpXMnSoZL6nyB2dV4NafL0MQv3APtr+vXVt1aRZhcEQAAdYPgq46EBPipZXigMvJKlJpdoNPbNje7JAAAgKbNYpHOuNvsKnzCnOVp2pCep/BAP90zvJPZ5QAAUGdY6liHkmMqBtxnstwRAAAAvuFgkUP/+maTJOme4Z0UGWI3uSIAAOoOwVcdSoqqmPOVzYB7AAAA+IbnF27WwaIydYoN05/6tzW7HAAA6hTBVx1KjqbjCwAAAL5jY0ae3v5lpyTpHxd3lZ+NXw8AAI0L/7LVoeQYd8dXKjs7AgAAwMsZhqFJ89bLZUgXdG+pQe2jzC4JAIA6R/BVh5Ki3cFX2v4ilTldJlcDAAAAHNuCtRn6eVuOAvys+vsFXcwuBwCAekHwVYfiwgMV5G9TmdPQrv1FZpcDAAAAHFWxw6l/frlBkjTurGS1aR5sckUAANQPgq86ZLVa1C7KPedrWxYD7gEAAOCd/rM4VXsOFqtVRKDGnZVsdjkAANQbgq86xpwvAAAAeLPdB4o044dUSdLDF3ZVkN1mckUAANQfgq865tnZkeALAAAAXmjK/I0qLXepf7tIXdC9pdnlAABQrwi+6ljlgHuWOgIAAMDb/Jyaoy/XpMtqkSZe0k0Wi8XskgAAqFcEX3WMji8AAAB4o3KnS5O+WCdJumFAgrrEhZtcEQAA9Y/gq45VDrc/UFSm/YUOk6sBAAAA3N5bnqaNGflqFuyvCed1NLscAAAaBMFXHQu2+6l1syBJ0ja6vgAAAOAFDhQ69Nw3myVJ9wzvpGbBdpMrAgCgYRB81YMkljsCAADAizy3cJNyi8vUuWWYru/X1uxyAABoMARf9SCZAfcAAADwEuv35um9ZWmS3APtbVYG2gMAmg6Cr3rAgHsAAAB4A8MwNPGLdXIZ0oU94jQgqYXZJQEA0KAIvupBZcdXKh1fAAAAMNGXa9K1fPt+Bfpb9fcLuphdDgAADY7gqx4kVQRfafuL5Ch3mVwNAAAAmqJih1NPfrlBkjR+aHvPBkwAADQlBF/1IDY8QCF2m5wuQ2n76foCAABAw5uxKFV7c0vUpnmQbjszyexyAAAwBcFXPbBYLJ6uL5Y7AgAAoKHt2l+kVxalSpIeubCLAv1tJlcEAIA5CL7qCQPuAQAAYJZ/frlBjnKXBiW30IhuLc0uBwAA0xB81RPPgPtMOr4AAADQcH7amq2v1mXIZrXoHxd3k8ViMbskAABMQ/BVTyqXOm7LpuMLAAAADaPc6dKkL9ZJkm4ckKBOLcNMrggAAHMRfNWT5JiKpY6ZBTIMw+RqAAAA0BS888tObd5XoObB/rr73I5mlwMAgOkIvupJYosQWSxSXkm5sgscZpcDAACARi6noFRTF26WJN03orMigv1NrggAAPMRfNWTQH+b2jQPkiRtY8A9AAAA6tlzCzcrr6Rc3VqFa1TfeLPLAQDAKxB81SPPgPssBtwDAACg/qzdk6s5y9MkSRMv6SablYH2AABIBF/1KimqYsA9HV8AAACoJ4ZhaNIX62QY0iU9W6lvYqTZJQEA4DUIvuqRZ8A9wRcAAADqybzf9+rXHQcU5G/TQxd0NrscAAC8CsFXPWKpIwAAAOpTkaNcU+ZvlCT95exkxUUEmVwRAADeheCrHiVFuzu+dh8oUkmZ0+RqAAAA0NhM/z5VGXklio8M0tghSWaXAwCA1yH4qkfRoQEKC/STy5B25hSZXQ4AAAAakbScIr26ZJsk6dELuyrQ32ZyRQAAeB+Cr3pksViUFM2AewAAANS9J75cL0e5S0M6ROm8rrFmlwMAgFeqVfA1ffp0tWvXToGBgerdu7eWLFlyzHN/+OEHWSyWI46NGzfWumhfkhzNgHsAAADUrSVbsvTN+n3ys1r0j4u7ymKxmF0SAABeqcbB1/vvv6+77rpLDz/8sFatWqUhQ4Zo5MiRSktLO+7tNm3apPT0dM/RoUOHWhftSxhwDwAAgLpU5nRp0hfrJUk3DUxU+5gwkysCAMB71Tj4mjp1qsaMGaOxY8eqS5cumjZtmuLj4zVjxozj3i4mJkYtW7b0HDZb05hBUNnxxVJHAAAA1IV3ftmprZkFahFi19/ObRofJgMAUFs1Cr4cDodWrlyp4cOHV7t8+PDhWrp06XFv26tXL8XFxWnYsGH6/vvvj3tuaWmp8vLyqh2+6tCOL8MwTK4GAAAAvu6/f6RLku4c1kERQf4mVwMAgHerUfCVnZ0tp9Op2NjqwzNjY2OVkZFx1NvExcXp1Vdf1ccff6xPPvlEnTp10rBhw7R48eJjPs6UKVMUERHhOeLj42tSpldp2yJYVotUUFquzPxSs8sBAACADzMMQ1sz3SsJ+iZGmlwNAADez682Nzp8eKZhGMccqNmpUyd16tTJ8+eBAwdq165d+te//qUzzzzzqLd56KGHNGHCBM+f8/LyfDb8CvCzqW1ksHbkFCk1q0Cx4YFmlwQAAAAflVPoUG5xmSwWKalipAYAADi2GnV8RUVFyWazHdHdlZmZeUQX2PEMGDBAW7ZsOeb1AQEBCg8Pr3b4MgbcAwAAoC5Udnu1aR6kQP+mMTMXAIBTUaPgy263q3fv3lq4cGG1yxcuXKhBgwad9P2sWrVKcXFxNXlon5bEgHsAAADUgcrgq33FB6sAAOD4arzUccKECbrxxhvVp08fDRw4UK+++qrS0tI0btw4Se5linv27NFbb70lSZo2bZoSExPVrVs3ORwOvfPOO/r444/18ccf1+0z8WJ0fAEAAKAueIKvGIIvAABORo2Dr1GjRiknJ0eTJ09Wenq6UlJSNH/+fCUkJEiS0tPTlZaW5jnf4XDo3nvv1Z49exQUFKRu3brpyy+/1AUXXFB3z8LLJVUGX5l0fAEAAKD2UrMIvgAAqAmLYRiG2UWcSF5eniIiIpSbm+uT875yCkrV+4n/yWKR1k86X0F25jEAAFDffP39Q1PBz6lmBk35VntzS/TRuIHqw66OAIAmqibvH2o04wu1ExliV7NgfxmGtD2b5Y4AAACoucLScu3NLZFExxcAACeL4KsBWCwWJUVVDLjPZrkjAAAAaq5ymWNUqF3Ngu0mVwMAgG8g+GogngH3mXR8AQAAoOYqB9sns6MjAAAnjeCrgSTHVO7sSMcXAAAAao7B9gAA1BzBVwNhqSMAAABOBR1fAADUHMFXA6ns+NqWVSgf2EgTAAAAXqYy+KLjCwCAk0fw1UDaRgbLz2pRkcOpjLwSs8sBAACADylzurQzp0gSwRcAADVB8NVA/G1WtW0RLIkB9wAAAKiZnTmFKncZCrbbFBcRaHY5AAD4DIKvBuTZ2ZEB9wAAAKiBrRUfnCZHh8pisZhcDQAAvoPgqwElRVcMuCf4AgAAQA2woyMAALVD8NWAqjq+WOoIAAAa3vTp09WuXTsFBgaqd+/eWrJkyXHPf/nll9WlSxcFBQWpU6dOeuutt4445+OPP1bXrl0VEBCgrl276tNPP62v8ps0BtsDAFA7BF8NKLmi44uljgAAoKG9//77uuuuu/Twww9r1apVGjJkiEaOHKm0tLSjnj9jxgw99NBDmjhxotatW6dJkybpL3/5i7744gvPOT///LNGjRqlG2+8Ub///rtuvPFGXXPNNVq2bFlDPa0mozL4qvwgFQAAnByLYRiG2UWcSF5eniIiIpSbm6vw8HCzy6m1A4UO9Xp8oSRp3aQRCgnwM7kiAAAar8by/qGu9O/fX6effrpmzJjhuaxLly667LLLNGXKlCPOHzRokAYPHqxnn33Wc9ldd92lFStW6Mcff5QkjRo1Snl5eVqwYIHnnPPPP1/NmzfXnDlzTqoufk4n5nIZSpn4tYocTv1vwll0fQEAmryavH+g46sBNQ+xq0WIXZK0PZvljgAAoGE4HA6tXLlSw4cPr3b58OHDtXTp0qPeprS0VIGB1XcPDAoK0vLly1VWVibJ3fF1+H2OGDHimPdZeb95eXnVDhxfRl6JihxO+VktSqjYJRwAAJwcgq8GlsRyRwAA0MCys7PldDoVGxtb7fLY2FhlZGQc9TYjRozQzJkztXLlShmGoRUrVmjWrFkqKytTdna2JCkjI6NG9ylJU6ZMUUREhOeIj48/xWfX+FUuc0xoESx/G2/fAQCoCf7lbGAMuAcAAGaxWCzV/mwYxhGXVXr00Uc1cuRIDRgwQP7+/rr00ks1evRoSZLNZqvVfUrSQw89pNzcXM+xa9euWj6bpoPB9gAA1B7BVwOrCr7o+AIAAA0jKipKNpvtiE6szMzMIzq2KgUFBWnWrFkqKirSjh07lJaWpsTERIWFhSkqKkqS1LJlyxrdpyQFBAQoPDy82oHj25pF8AUAQG0RfDWwyqWO2+j4AgAADcRut6t3795auHBhtcsXLlyoQYMGHfe2/v7+atOmjWw2m+bOnauLLrpIVqv7LeTAgQOPuM9vvvnmhPeJmqHjCwCA2mNbwQZW2fG1PbtALpchq/XYSwEAAADqyoQJE3TjjTeqT58+GjhwoF599VWlpaVp3LhxktxLEPfs2aO33npLkrR582YtX75c/fv314EDBzR16lStXbtWb775puc+//a3v+nMM8/U008/rUsvvVSff/65/ve//3l2fUTd2FbR8VX5PhIAAJw8gq8G1qZ5kPxtFpWUubQ3t1htmrMzDwAAqH+jRo1STk6OJk+erPT0dKWkpGj+/PlKSEiQJKWnpystLc1zvtPp1HPPPadNmzbJ399fZ599tpYuXarExETPOYMGDdLcuXP1yCOP6NFHH1VycrLef/999e/fv6GfXqN1sMih7AKHJIIvAABqw2IYhmF2ESeSl5eniIgI5ebmNoo5EOdNXaQtmQV685Z+OqtjtNnlAADQKDW29w+NFT+n41uxY7+ueuVntYoI1NKHhpldDgAAXqEm7x+Y8WUCz4D7TAbcAwAA4Ngq53slM98LAIBaIfgygWfAfTbBFwAAAI4tlR0dAQA4JQRfJqjq+GJnRwAAABybp+OL+V4AANQKwZcJKju+Kj/BAwAAAI5mKx1fAACcEoIvEyRVfGKXmV+q/JIyk6sBAACANyopc2r3gWJJBF8AANQWwZcJIoL8FR0WIEnalsVyRwAAABwpNatAhiE1C/ZXixC72eUAAOCTCL5MkhTFgHsAAAAcW2rFB6TJ0aGyWCwmVwMAgG8i+DJJ5ZbUDLgHAADA0VQOtm/PYHsAAGqN4MsklR1fDLgHAADA0aRmMtgeAIBTRfBlksqOL2Z8AQAA4Gi2EnwBAHDKCL5MUtmyvj2nUE6XYXI1AAAA8CblTpe2Z7s/ICX4AgCg9gi+TNKqWZDsflY5yl3aU7FNNQAAACBJuw8Uy+F0KcDPqlbNgswuBwAAn0XwZRKb1cKcLwAAABxV5TLHpOhQ2azs6AgAQG0RfJkouWK5I8EXAAAADrU1i/leAADUBYIvEyVFV3Z8MeAeAAAAVTyD7aMJvgAAOBUEXyai4wsAAABHk0rHFwAAdYLgy0SVHV/bCL4AAABQwTAMT8dXckyIydUAAODbCL5MlFTR8ZVd4FBuUZnJ1QAAAMAbZOWXKr+kXFaL1C6K4AsAgFNB8GWi0AA/tQwPlCSlZtP1BQAAgKr5Xm0jgxXgZzO5GgAAfBvBl8mqljsy4B4AAADs6AgAQF0i+DIZA+4BAABwqFTPfC+CLwAAThXBl8kqO74q3+AAAACgaavs+Kr8gBQAANQewZfJKt/QbMtmqSMAAACqZnyx1BEAgFNH8GWyyhb2nTmFKne6TK4GAAAAZsorKdO+vFJJBF8AANQFgi+TxYUHKtDfqjKnoV0His0uBwAAACaqHH8RExag8EB/k6sBAMD3EXyZzGq1KCmqYsA9c74AAACatNSKnb7p9gIAoG4QfHmByuWO7OwIAADQtFXO92KwPQAAdYPgywskRbl3dtyWxYB7AACApozB9gAA1C2CLy9AxxcAAACkqveDBF8AANQNgi8vUNnxRfAFAADQdJWWO7UzhxlfAADUJYIvL5AU7Q6+DhSVaX+hw+RqAAAAYIadOUVyGVJogJ9iwgLMLgcAgEaB4MsLBNv91LpZkCRpG11fAAAATZJnsH1MqCwWi8nVAADQOBB8eYnKri8G3AMAADRNnsH27OgIAECdIfjyEpVbVjPnCwAAoGliR0cAAOoewZeXqOz4IvgCAABomtjREQCAukfw5SUqO75Y6ggAAND0uFyGJ/hKrvhAFAAAnDqCLy9RGXzt3F8kR7nL5GoAAADQkPYcLFZJmUt2m1VtI4PNLgcAgEaD4MtLxIYHKMRuk9NlKG1/kdnlAAAAoAFtrej2SowKlp+Nt+gAANQV/lX1EhaLRUkMuAcAAGiSUhlsDwBAvSD48iIMuAcAAGiaPIPtowm+AACoSwRfXoQB9wAAAE3T1oqOr2Q6vgAAqFMEX14kmaWOAAAATZIn+KLjCwCAOkXw5UUqlzpuyyqUYRgmVwMAAICGkFNQqgNFZbJYCL4AAKhrBF9epF1UiCwWKbe4TDmFDrPLAQAAQAOo7PZq3SxIQXabydUAANC41Cr4mj59utq1a6fAwED17t1bS5YsOanb/fTTT/Lz89Npp51Wm4dt9AL9bWrTPEhS1c4+AAAAaNxSK+a7sqMjAAB1r8bB1/vvv6+77rpLDz/8sFatWqUhQ4Zo5MiRSktLO+7tcnNzddNNN2nYsGG1LrYpSIqqGHCfzYB7AACApoD5XgAA1J8aB19Tp07VmDFjNHbsWHXp0kXTpk1TfHy8ZsyYcdzb3X777br++us1cODAWhfbFHgG3NPxBQAA0CRsrdjYiI4vAADqXo2CL4fDoZUrV2r48OHVLh8+fLiWLl16zNu98cYbSk1N1T/+8Y+TepzS0lLl5eVVO5qKygH37OwIAADQNFR+4EnwBQBA3atR8JWdnS2n06nY2Nhql8fGxiojI+Oot9myZYsefPBBvfvuu/Lz8zupx5kyZYoiIiI8R3x8fE3K9GmVHV8sdQQAAGj8CkvLtedgsSSpPUsdAQCoc7Uabm+xWKr92TCMIy6TJKfTqeuvv16TJk1Sx44dT/r+H3roIeXm5nqOXbt21aZMn5Qc4+742rW/SKXlTpOrAQAAQH3aXvFhZ4sQu5qH2E2uBgCAxufkWrAqREVFyWazHdHdlZmZeUQXmCTl5+drxYoVWrVqle644w5JksvlkmEY8vPz0zfffKNzzjnniNsFBAQoICCgJqU1GtGhAQoL8FN+abl25hSpY2yY2SUBAACgnjDYHgCA+lWjji+73a7evXtr4cKF1S5fuHChBg0adMT54eHhWrNmjVavXu05xo0bp06dOmn16tXq37//qVXfCFksFiXFMOAeAACgKfAEX8z3AgCgXtSo40uSJkyYoBtvvFF9+vTRwIED9eqrryotLU3jxo2T5F6muGfPHr311luyWq1KSUmpdvuYmBgFBgYecTmqJEeF6PddBxlwDwAA0MhtZbA9AAD1qsbB16hRo5STk6PJkycrPT1dKSkpmj9/vhISEiRJ6enpSktLq/NCm5LKT/y2ZTHgHgAAoDGr/KCT4AsAgPpR4+BLksaPH6/x48cf9brZs2cf97YTJ07UxIkTa/OwTUZytHvAPR1fAAAAjVe506UdOe4POivf/wEAgLpVq10dUb+Soqs6vgzDMLkaAAAA1Ied+4tU5jQU5G9Tq4ggs8sBAKBRIvjyQgktgmW1SPml5crKLzW7HAAAANSDqsH2IbJaLSZXAwBA40Tw5YUC/GxqGxksSdrKckcAAIBGyTPYPpr5XgAA1BeCLy916HJHAAAAND4MtgcAoP4RfHkpBtwDAAA0bqmVSx3p+AIAoN4QfHmpyo6vVDq+AAAAGh3DMDzv8+j4AgCg/hB8ealkz1JHOr4AAAAam4y8EhWUlstmtSihRYjZ5QAA0GgRfHmpyqWOew4Wq6TMaXI1AAAAqEuVg+0TWgTL7sdbcgAA6gv/ynqpyBC7IoL8ZRjS9myWOwIAADQmqezoCABAgyD48lIWi4UB9wAAAI3U1or3d8nM9wIAoF4RfHkxz4D7TDq+AAAAGpOtdHwBANAgCL68mGfAfTYdXwAAAI3J1kx2dAQAoCEQfHkxljoCAAA0PrlFZcouKJXEUkcAAOobwZcXq1zquC2rUIZhmFwNAAAA6kLlfK+4iECFBviZXA0AAI0bwZcXS2gRLD+rRUUOpzLySswuBwAAAHWgckfHZOZ7AQBQ7wi+vJi/zaq2kcGSGHAPAADQWFR2fDHfCwCA+kfw5eWSGHAPAADQqFTu6Mh8LwAA6h/Bl5dLjqkYcJ9J8AUAANAYVG5c1J6ljgAA1DuCLy+XHOV+Q5SaxVJHAAAAX1dS5tSu/UWSqj7gBAAA9Yfgy8tVviHalkXHFwAAgK/bnl0olyGFB/opOjTA7HIAAGj0CL68XFJFx9fe3BIVOcpNrgYAAACnonK+V/uYUFksFpOrAQCg8SP48nLNQ+yKDLFLkrax3BEAAMCnHRp8AQCA+kfw5QOSoysG3LPcEQAAwKd5BtsTfAEA0CAIvnxAEgPuAQAAGoXKjq9kdnQEAKBBEHz5AAbcAwAA+D6ny9C2bPcHmXR8AQDQMAi+fEDlJ4J0fAEAAPiu3QeK5Ch3ye5nVZvmwWaXAwBAk0Dw5QOSKoKv7dkFcrkMk6sBAABAbVQuc0yKCpHNyo6OAAA0BIIvHxDfPEj+NotKylzam1tsdjkAAACoBQbbAwDQ8Ai+fICfzaqEFpU7O7LcEQAAwBcx2B4AgIZH8OUjkqMZcA8AAODLKoMvOr4AAGg4BF8+omrAPcEXAACArzEMg+ALAAATEHz5iMoB96mZLHUEAADwNdkFDuWVlMtqkdpFhZhdDgAATQbBl4/wLHXMpuMLAADA11R2e8VHBivQ32ZyNQAANB0EXz6isuNrX16p8kvKTK4GAAAANbE1i8H2AACYgeDLR0QE+SsqNECStD2b5Y4AAAC+JJX5XgAAmILgy4dULndkwD0AAIBv8Qy2p+MLAIAGRfDlQxhwDwAA4JsqP7hMpuMLAIAGRfDlQxhwDwAA4HsKSsuVnlsiiY4vAAAaGsGXD6n8hJCOLwAAAN9ROd8rKjRAEcH+JlcDAEDTQvDlQ5Kj3MHX9pxCOV2GydUAAABfM336dLVr106BgYHq3bu3lixZctzz3333XfXs2VPBwcGKi4vTn//8Z+Xk5Hiunz17tiwWyxFHSUlJfT8Vn+KZ7xUTYnIlAAA0PQRfPqR18yDZ/axylLu050Cx2eUAAAAf8v777+uuu+7Sww8/rFWrVmnIkCEaOXKk0tLSjnr+jz/+qJtuukljxozRunXr9OGHH+rXX3/V2LFjq50XHh6u9PT0akdgYGBDPCWfsTWLHR0BADALwZcPsVktateCnR0BAEDNTZ06VWPGjNHYsWPVpUsXTZs2TfHx8ZoxY8ZRz//ll1+UmJioO++8U+3atdMZZ5yh22+/XStWrKh2nsViUcuWLasdx1NaWqq8vLxqR2OXyo6OAACYhuDLxyTHEHwBAICacTgcWrlypYYPH17t8uHDh2vp0qVHvc2gQYO0e/duzZ8/X4ZhaN++ffroo4904YUXVjuvoKBACQkJatOmjS666CKtWrXquLVMmTJFERERniM+Pv7UnpwP2MqOjgAAmIbgy8ckV3xSmJrFgHsAAHBysrOz5XQ6FRsbW+3y2NhYZWRkHPU2gwYN0rvvvqtRo0bJbrerZcuWatasmV566SXPOZ07d9bs2bM1b948zZkzR4GBgRo8eLC2bNlyzFoeeugh5ebmeo5du3bVzZP0Uo5yl3bmFEliqSMAAGYg+PIxSdHujq9tdHwBAIAaslgs1f5sGMYRl1Vav3697rzzTj322GNauXKlvvrqK23fvl3jxo3znDNgwADdcMMN6tmzp4YMGaIPPvhAHTt2rBaOHS4gIEDh4eHVjsZsZ8WmRKEBfmoZzuwzAAAamp/ZBaBm6PgCAAA1FRUVJZvNdkR3V2Zm5hFdYJWmTJmiwYMH67777pMk9ejRQyEhIRoyZIieeOIJxcXFHXEbq9Wqvn37Hrfjq6mp3NExOTrkmCEjAACoP3R8+Zh2Ue6Or+yCUuUWl5lcDQAA8AV2u129e/fWwoULq12+cOFCDRo06Ki3KSoqktVa/a2izWaT5O4UOxrDMLR69eqjhmJNVSrzvQAAMBXBl48JC/RXbHiAJJY7AgCAkzdhwgTNnDlTs2bN0oYNG3T33XcrLS3Ns3TxoYce0k033eQ5/+KLL9Ynn3yiGTNmaNu2bfrpp5905513ql+/fmrVqpUkadKkSfr666+1bds2rV69WmPGjNHq1aurLYds6qo6vgi+AAAwA0sdfVBydKj25ZUqNatQvdo2N7scAADgA0aNGqWcnBxNnjxZ6enpSklJ0fz585WQkCBJSk9PV1pamuf80aNHKz8/X//+9791zz33qFmzZjrnnHP09NNPe845ePCgbrvtNmVkZCgiIkK9evXS4sWL1a9fvwZ/ft6qckdHBtsDAGAOi3GsXnUvkpeXp4iICOXm5jb6Aagn45HP1uidX9L0f0OT9cD5nc0uBwAAr8T7B9/QmH9OLpehbv/4WsVlTn17z1l0fQEAUEdq8v6BpY4+qPJNE0sdAQAAvFd6XomKy5zyt1mUEBlsdjkAADRJBF8+iJ0dAQAAvF/lfK/EFiHys/G2GwAAM/AvsA9Kinbv7Lgzp1DlTpfJ1QAAAOBoGGwPAID5CL58UKuIIAX6W1XmNLTrQLHZ5QAAAOAoKoMvBtsDAGAegi8fZLVa1C6qYrljJnO+AAAAvFEqwRcAAKYj+PJRyRXLHbdlE3wBAAB4o9Qsgi8AAMxG8OWjPAPuMxlwDwAA4G0OFDqUU+iQVDWfFQAANDyCLx+VRMcXAACA19pa0e3VulmQgu1+JlcDAEDTRfDlozwdX1l0fAEAAHgbz46OLHMEAMBUBF8+qrLja3+hQwcq2ugBAADgHTw7OkYTfAEAYCaCLx8VbPdTq4hASSx3BAAA8DYMtgcAwDsQfPmwytZ5BtwDAAB4F0/HF8EXAACmIvjyYUlR7uWOlZ8oAgAAwHzFDqf2HCyWJCWzoyMAAKYi+PJhno4vBtwDAAB4jdSsAhmG1DzYXy1CA8wuBwCAJo3gy4dV7uy4jY4vAAAAr8F8LwAAvAfBlw+r3NkxbX+Rypwuk6sBAACAJKUy3wsAAK9Rq+Br+vTpateunQIDA9W7d28tWbLkmOf++OOPGjx4sFq0aKGgoCB17txZzz//fK0LRpWW4YEKtttU7jK0M6fI7HIAAAAgaWtFx1dldz4AADBPjYOv999/X3fddZcefvhhrVq1SkOGDNHIkSOVlpZ21PNDQkJ0xx13aPHixdqwYYMeeeQRPfLII3r11VdPufimzmKxeLq+GHAPAADgHSp3dEym4wsAANPVOPiaOnWqxowZo7Fjx6pLly6aNm2a4uPjNWPGjKOe36tXL1133XXq1q2bEhMTdcMNN2jEiBHH7RLDyaua88WAewAAALOVO13anu1+X9aeji8AAExXo+DL4XBo5cqVGj58eLXLhw8frqVLl57UfaxatUpLly7VWWeddcxzSktLlZeXV+3A0VUGX3R8AQAAmG/XgWKVOQ0F+dvUulmQ2eUAANDk1Sj4ys7OltPpVGxsbLXLY2NjlZGRcdzbtmnTRgEBAerTp4/+8pe/aOzYscc8d8qUKYqIiPAc8fHxNSmzSalc6sjOjgAAAOarXOaYFB0iq9VicjUAAKBWw+0tlur/iBuGccRlh1uyZIlWrFihV155RdOmTdOcOXOOee5DDz2k3Nxcz7Fr167alNkkVHV8FcowDJOrAQAAaNo8871Y5ggAgFfwq8nJUVFRstlsR3R3ZWZmHtEFdrh27dpJkrp37659+/Zp4sSJuu666456bkBAgAICAmpSWpPVLipEFouUW1ymnEKHokL5vgEAAJilMvhqz2B7AAC8Qo06vux2u3r37q2FCxdWu3zhwoUaNGjQSd+PYRgqLS2tyUPjGAIPmR/BgHsAAABzbc0i+AIAwJvUqONLkiZMmKAbb7xRffr00cCBA/Xqq68qLS1N48aNk+Reprhnzx699dZbkqSXX35Zbdu2VefOnSVJP/74o/71r3/pr3/9ax0+jaYtOTpUuw8UKzWrQP3aRZpdDgAAQJNkGIa20fEFAIBXqXHwNWrUKOXk5Gjy5MlKT09XSkqK5s+fr4SEBElSenq60tLSPOe7XC499NBD2r59u/z8/JScnKynnnpKt99+e909iyYuKTpEizZnKTWTAfcAAABmycwvVX5puWxWixJaBJtdDgAAUC2CL0kaP368xo8ff9TrZs+eXe3Pf/3rX+nuqmeVw1O3ZbPUEQAAwCyV873aRgYrwM9mcjUAAECq5a6O8C5J0SGSpNQsOr4AAADMwo6OAAB4H4KvRqB9xZurXfuLVFruNLkaAACApokdHQEA8D4EX41AdFiAwgL85DKknTlFZpcDAADQJKWyoyMAAF6H4KsRsFgsVcsdGXAPAABgCjq+AADwPgRfjQQD7gEAAMyTV1KmzPxSSVXzVwEAgPkIvhqJ5IpPFun4AgAAaHiV3V6x4QEKD/Q3uRoAAFCJ4KuRSIqqWOpIxxcAAECDS2WZIwAAXongq5Go7PjallkgwzBMrgYAAKBp2Vo52D6a4AsAAG9C8NVIJLQIltUi5ZeWK6tivgQAAAAaRmXHVzIdXwAAeBWCr0YiwM+m+MhgSVJqFssdAQAAGpJnR0c6vgAA8CoEX41I5c6OqVkMuAcAAGgoJWVOpe0vksSMLwAAvA3BVyPiGXBP8AUAANBgduYUyWVIYYF+ig4LMLscAABwCIKvRsQz4J6ljgAAAA1m6yE7OlosFpOrAQAAhyL4kqSyYqkwx+wqThkdXwAAAA2vMvhKZr4XAABeh+Br7yrplTOkz8dLhmF2NaeksuNrz8FilZQ5Ta4GAACgadiaVdXxBQAAvAvBly1AOpgmbf5K+uN9s6s5JS1C7IoI8pdhSNuzWe4IAADQENjREQAA70XwFdtVOusB99cL7pfyM8yt5xRYLBYlRbPcEQAAoKG4XIa20fEFAIDXIviSpMF3SXGnSSW50hd3+fSSx8rZEgy4BwAAqH97DhartNwlu82q+Mhgs8sBAACHIfiSJJufdNkMyeovbV4g/fGB2RXVWmXwRccXAABA/atc5tguKkQ2Kzs6AgDgbQi+KsV2lYb6/pLHyqWOdHwBAADUP898L5Y5AgDglQi+DjX4Limup1RyUPrv3T655PHQji/DB+sH8P/t3Xd4VGX6xvF7ZpJJL5BGgCRAQHoNvdkQQWXFtaCrIIrrsqLCoq7ys7vusuqqKAqKiqwNsIsKaNAVRFQwCCKdUEJJSEJJ73N+f0yqBCSQ5MxMvp/rOlfOnDkz84wH5fXO+z4HAOBOKoKveIIvAABcEsFXdTbvqiWP25dKm94zu6I6i23uL5vVovziMqVlF5pdDgAAgEdLprE9AAAujeDrt6K6Vt3lcek9Us5hc+upI7uXVXHljVVZ7ggAANBwDMPQrorgK4LgCwAAV0TwVZuh06QWPdx2yWM7GtwDAAA0uCN5xTqeXyKLparPKgAAcC0EX7WpXPLoJW3/XPr1A7MrqpN4GtwDAAA0uIr+Xq2b+cnX22ZyNQAAoDYEXyfTops0/O/O/aV3u9WSx3hmfAEAADS4ZJY5AgDg8gi+TmXYdKlFd6ngmPT5dLdZ8lgx1T45neALAACgoVTM+KKxPQAArovg61SqL3nc9pnbLHmsmPF1KKtQ+cWlJlcDAADgmQi+AABwfQRfv6dFd2n4Pc79pfdIuenm1nMamgXY1TzALknampptcjUAAACeqWJ2fTxLHQEAcFkEX6dj2F3lSx6Pus2Sx4S4ZpKkvy3eqPScQpOrAQAA8Cx5RaU6lOUcYzHjCwAA10XwdTps3tLlc5xLHrd+Km3+0OyKftc/x3ZTTHM/pRzN18T565RTWGJ2SQAAAB6j4u7Z4YF2hfrbTa4GAACcDMHX6YruIQ2727n/+d1Sboa59fyOyGBfvXnzAIUF2LUlNVu3vpGkwpIys8sCAADwCLsyciSxzBEAAFdH8FUXw+6SosqXPC69y+xqfleb8AAtuKm/Auw2fb/7iKa/u0FlDtdfpgkAAODqKhrbx7PMEQAAl0bwVRdedmls+ZLHLZ9Iv7r+ksfurUM0b0JfedssWropTQ8v+VWGG/QoAwAAcGWVd3RkxhcAAC6N4Kuuons4Z35J0lLXX/IoSUPah+vZcb1ksUhv/ZCi57/aZXZJAAAAbq0y+GLGFwAALo3g60wMu1uK7CrlH3GGX27gsh4t9ciYrpKkZ1fs0Fs/7DO5IgAAAPdUUubQviP5kgi+AABwdQRfZ6JiyaPFJm35WNr8kdkVnZYbB7fRHRe0lyQ9+MmvWrYp1eSKAAAA3M++I/kqdRjyt9sUHeJrdjkAAOAUCL7OVMteVUseP79Lyss0tZzTNf2ic3Rd/1gZhjR10QZ9n3zE7JIAAADcSmVj+4hAWSwWk6sBAACnQvB1Nobf43ZLHi0Wix4f200Xd41ScZlDt77xkzYfyjK7LAAAALeRnEF/LwAA3AXB19nwsktjX3Quedz8kbT5Y7MrOi02q0XPXdtb/ds2V05RqW6cv04p5X0qAAAAcGo0tgcAwH0QfJ2tlr2lYdOd+2605NHX26ZXJvRVpxZByswt0vj5Pyojp8jssgAAAFxexYyv+AiCLwAAXB3BV30Yfo8U2UXKz5SW3mN2NactxM9bb9zcX62b+WnfkXzdtGCtcgpLzC4LAADAZRmGoWRmfAEA4DYIvuqDl490ecWSxw+lLZ+YXdFpiwz21ZuTBigswK5fD2Zr8ltJKiotM7ssAAAAl5SaVai84jJ5WS2KC/M3uxwAAPA7CL7qS6s+0tBpzv3P75Ly3OduiW3DA/T6Tf0UYLfpu11HNP3djSpzGGaXBQAA4HIq+nvFhfnL28ZQGgAAV8ff1vXp3HuliM5SXoa0zH2WPEpSj9aheml8grxtFn3+S6oe/XSzDIPwCwAAoDru6AgAgHsh+KpPXj7S2DnOJY+/fiBtWWJ2RXUyrEOEnr6mlywW6Y3v9+mFr3eZXRIAAIBL4Y6OAAC4F4Kv+taqjzRkqnP/8+lS/lFz66mjP/RsqYcv6yJJejpxhxauTTG5IgAAANdB8AUAgHsh+GoI590nRXQqX/L4d7OrqbOJQ9pqyvnxkqT7P9qk5b+mmVwRAACAa6hY6hgfQfAFAIA7IPhqCJVLHq3SpvekrZ+ZXVGd3T2yo8b1jZHDkO5c9LN+3O0+zfoBAAAawvH8YmXmFksi+AIAwF0QfDWUVglVSx4/+5vbLXm0WCz65xXddFGXKBWXOnTLGz9pa2q22WUBAACYpmK2V8sQXwX4eJlcDQAAOB0EXw3p3Iolj+nSsnvNrqbOvGxWzb6ut/q1aaacwlJNmL9W+4/mm10WAACAKSr6e8XT3wsAALdB8NWQvH2lyyuWPL4rbfvc7IrqzNfbplcn9FPHqCBl5BRpwvy1yswtMrssAACARkdjewAA3A/BV0NrnSANvtO5/+k0t1vyKEkh/t56Y1J/tQr1057MPN28YJ1yi0rNLgsAAKBRVc74or8XAABug+CrMZw3Qwo/x7nkcfl9ZldzRqKCffXGpP5qHmDXLweyNPnNJBWXOswuCwAAoNHsymDGFwAA7obgqzF4+0pj5zqXPP6yWNq21OyKzkh8RKDmT+wnf7tNq3dl6q73NsrhMMwuCwAAoMEVlpTpwLECSQRfAAC4E4KvxtK6rzT4Duf+Z9PccsmjJPWKCdVLNyTIy2rRpxsP6bHPtsgwCL8AAIBn252RJ8OQQv29FRZgN7scAABwmgi+GtN5/+dc8ph7WFo+w+xqztjwcyL09DU9JUkL1uzVnG+STa4IAACgYVUsc4yPCJTFYjG5GgAAcLoIvhpT9bs8/rJI2r7M7IrO2OW9WunBy7pIkp76YrsWr0sxuSIAAICGU3lHRxrbAwDgVgi+GltMP2nQFOf+p9OkgmOmlnM2Jg1tq7+eFy9JmvHhJiVuOWxyRQAAAA0jOZ3G9gAAuCOCLzOcf78U1kHKTXPrJY+S9PeLO+rqhNZyGNLt76zX2j3u2bsMAADgVJK5oyMAAG6J4MsM3n7S2DmSLNLGhdL25WZXdMYsFotm/rG7LuwUqaJSh2757zptS8s2uywAAIB6U+YwtDszTxLBFwAA7obgyywx/auWPH42za2XPHrZrHrhT33UN66ZsgtLdeP8tTpwLN/ssgAAAOrF/qP5Ki51yMfLqpahfmaXAwAA6oDgy0wXPCCFtZdyUqUv7je7mrPiZ7fp1Rv76pyoQB3OLtKE19bqaF6x2WUBAACctYrG9u0iAmWzckdHAADcCcGXmbz9nHd5lEXa8La04wuzKzorof52/ffm/moZ4qvdmXm66fW1yisqNbssAACAs0J/LwAA3BfBl9liB1S7y+NUqeC4qeWcregQP70xaYBC/b218UCWJr+VpOJSh9llAQAAnLGKGV/tIwi+AABwNwRfruD8+6Xm8R6x5FFy/jb09Yn95Odt07c7M3XP+xvlcBhmlwUAAHBGdjHjCwAAt3VGwdecOXPUtm1b+fr6KiEhQd9+++1Jz/3www910UUXKSIiQsHBwRo0aJC++MK9l/TVO7t/1V0eN7wl7fjS7IrOWu/YZpp7Qx95WS36ZMMhPf75VhkG4RcAAGaqyxhOkt5++2317NlT/v7+io6O1k033aQjR47UOOeDDz5Qly5d5OPjoy5duuijjz5qyK/Q6AzDqJzxFR8ZYHI1AACgruocfC1evFjTpk3T/fffr59//lnDhg3T6NGjlZKSUuv5q1at0kUXXaSlS5cqKSlJ559/vsaMGaOff/75rIv3KLEDpYG3Ofc9YMmjJJ3XMVJPXd1DkjT/uz16aeVukysCAKDpqusYbvXq1ZowYYImTZqkzZs367333tO6det0yy23VJ7z/fffa9y4cRo/frw2btyo8ePH65prrtGPP/7YWF+rwWXkFCmnsFRWi9Q2nOALAAB3YzHqOA1nwIAB6tOnj+bOnVt5rHPnzho7dqxmzpx5Wu/RtWtXjRs3Tg899NBpnZ+dna2QkBBlZWUpODi4LuW6l+J86aUh0tHdUu8bpMtfNLuievHqt7v1+OdbJUlPXtVD1/SNMbkiAEBT0GTGD6eprmO4//znP5o7d66Sk5Mrj82ePVtPPvmk9u/fL0kaN26csrOztWzZsspzRo0apWbNmmnhwoWnVZerX6c1yZn60ys/qk2Yv76553yzywEAAKrb+KFOM76Ki4uVlJSkkSNH1jg+cuRIrVmz5rTew+FwKCcnR82bNz/pOUVFRcrOzq6xNQl2/6q7PP78lrRzhdkV1YtbhrXTX85tJ0ma8eEmrdhy2OSKAABoWs5kDDd48GAdOHBAS5culWEYOnz4sN5//31deumlled8//33J7znxRdffMpxobuN85LT6e8FAIA7q1PwlZmZqbKyMkVFRdU4HhUVpbS0tNN6j6efflp5eXm65pprTnrOzJkzFRISUrnFxDShGUJxg6SBf3Xuf3qnVJhlbj315L5RnXRln9Yqcxia8s56Je07anZJAAA0GWcyhhs8eLDefvttjRs3Tna7XS1atFBoaKhmz55deU5aWlqdx4XuNs6r6u9F8AUAgDs6o+b2FoulxmPDME44VpuFCxfqkUce0eLFixUZGXnS82bMmKGsrKzKrWI6fZNxwYNSs7ZS9kGPuMuj5Pwz8+8ru+uCTpEqKnXo5gU/acfhHLPLAgCgSanLGG7Lli2688479dBDDykpKUnLly/Xnj17NHny5DN+T8n9xnkVd3SMjyD4AgDAHdUp+AoPD5fNZjvht3jp6ekn/LbvtxYvXqxJkybp3Xff1YgRI055ro+Pj4KDg2tsTUr1uzz+/Ka0yzOWPHrbrHrxT33UJzZUWQUlmvDaWh08XmB2WQAAeLwzGcPNnDlTQ4YM0T333KMePXro4osv1pw5czR//nylpqZKklq0aFHncaG7jfN2sdQRAAC3Vqfgy263KyEhQYmJiTWOJyYmavDgwSd93cKFCzVx4kS98847NfpC4BTiBksDyn+jusRzljz62W2aP7Gf2kcGKi27UBNe+1FH84rNLgsAAI92JmO4/Px8Wa01h4o2m02Sc1aXJA0aNOiE9/zyyy9POS50JzmFJTqcXSSJ4AsAAHdV56WO06dP16uvvqr58+dr69at+tvf/qaUlJTKae8zZszQhAkTKs9fuHChJkyYoKeffloDBw5UWlqa0tLSlJXlGUFOg7qw2pLHLx8wu5p6E+pv1xs391d0iK+SM/J084J1yi8uNbssAAA8Wl3HcGPGjNGHH36ouXPnavfu3fruu+905513qn///mrZsqUkaerUqfryyy/1xBNPaNu2bXriiSe0YsUKTZs2zYyvWO+SM/IkSZFBPgr29Ta5GgAAcCbqHHyNGzdOs2bN0mOPPaZevXpp1apVWrp0qeLi4iRJqampSklJqTz/5ZdfVmlpqaZMmaLo6OjKberUqfX3LTyVPUC6/EXn/vo3pF1fmVtPPWoZ6qc3J/VXqL+3Nuw/rtveXq+SMofZZQEA4LHqOoabOHGinnnmGb3wwgvq1q2brr76anXs2FEffvhh5TmDBw/WokWL9Prrr6tHjx5asGCBFi9erAEDBjT692sILHMEAMD9WYyKueouLDs7WyEhIcrKynL5PhANYunfpbUvS8Gtpdu+l3w9559B0r5juv7VH1RY4tAVvVvp6at7ymr9/RslAADwe5r8+MFNuPJ1+veybXppZbLGD4zTP8Z2M7scAABQri7jhzO6qyMa2YiHpWZtpOwDUuKDZldTrxLimmnu9QmyWS366OeDmrlsq9klAQAASJKSM5jxBQCAuyP4cgfVlzwmLZCSvza1nPp2fqdIPXllD0nSK9/u0bxVySZXBAAAICWz1BEAALdH8OUu2gyV+t/q3F9yp1SYbW499ezKhNb6v0s6SZL+tXSbPkg6YHJFAACgKSsudWjf0XxJBF8AALgzgi93cuHDUmiclLVfSnzI7Grq3a3D4/XnYW0lSX//4Bd9ve2wyRUBAICmau+RPJU5DAX6eCkyyMfscgAAwBki+HInPoHVljy+LiX/z9x6GsCM0Z31x96tVOYwdNvb65W075jZJQEAgCao4o6O8ZGBsli48Q4AAO6K4MvdtB0m9fuzc3/JHVJRjrn11DOr1aInruqh8zpGqLDEoZsXrNPOw571HQEAgOur7O8VwTJHAADcGcGXOxrxiEcvefS2WTXn+j7qFROqrIISTZi/VoeOF5hdFgAAaEJ2cUdHAAA8AsGXO/IJlC5/wbn/03xp9zemltMQ/O1een1iP8VHBCg1q1AT5q/V8fxis8sCAABNxC7u6AgAgEcg+HJXbYdL/W5x7n/ieUseJalZgF1vTBqgFsG+2pWeq5sXrFNBcZnZZQEAAA/ncBhKLp/xFR8RYHI1AADgbBB8ubMRj0qhsVJWipT4sNnVNIhWoX56Y1J/hfh5a33KcU15Z71KyhxmlwUAADzYweMFKixxyG6zKra5v9nlAACAs0Dw5c58AqU/VCx5fE3avdLcehrIOVFBmj+xr3y9rfp6W7puXrBO6dmFZpcFAAA8VMVsrzbh/vKyMVwGAMCd8Te5u2t3rtR3knN/ye1SUa659TSQhLjmmnN9H/l4WfXtzkxdPGuVlv+aZnZZAADAA9HfCwAAz0Hw5QkuelQKiZWOp0grPHPJoyRd0ClKn90xVF2ig3Usv0ST30rSve//otyiUrNLAwAAHqRixlf7CIIvAADcHcGXJ/AJki6f7dxf96q0Z5W59TSgDlFB+njKEE0+N14Wi7T4p/265LlvlbTvmNmlAQAAD1Ex4yueGV8AALg9gi9P0e48KeEm5/4nnrvkUZLsXlbdN7qTFv15oFqF+inlaL6ufmmNnkncQeN7AABw1iqDL2Z8AQDg9gi+PMnIf0ghMdLxfdJXj5pdTYMb0C5My6YN0xW9W8lhSM9/tVNXzV2j3RmeG/oBAICGdTSvWMfyS2SxEHwBAOAJCL48iU+Q9IfyJY9r50l7vjW3nkYQ7OutZ8f10vPX9Vawr5c2HsjSpc+v1js/psgwDLPLAwAAbqZitlerUD/52W0mVwMAAM4WwZeniT9fSpjo3P9kinR0j6nlNJY/9Gyp5dOGa3B8mApKyvR/H23Sn9/4SZm5RWaXBgAA3Ah3dAQAwLMQfHmii6oteXyxv7TiEakox+yqGlzLUD+9NWmAHri0s+w2q1ZsTdeoWav09bbDZpcGAADcBP29AADwLARfnsg3WJrwibPhfVmxtPpZ6fk+0vo3JYdnN3+3Wi26ZVg7fXL7EHWMClJmbrFuXvCT7v9ok/KLS80uDwAAuLjkDGZ8AQDgSQi+PFVYvDT+Y+nahVLzdlJeurTkdumV86R9a8yursF1jg7WJ7cP0S1D20qS3v4xRZc9v1q/HDhubmEAAMClsdQRAADPQvDlySwWqdMl0m0/OJc/+gRLqRul10dL702UjqeYXWGD8vW26YHLuujtWwaoRbCvdmfm6Y9z1uiFr3eqtMyzZ74BAIC6yy8u1cHjBZKk9ix1BADAIxB8NQVePtKQO6U71kt9bpRkkTZ/JL3QT/r6cako1+wKG9SQ9uFaPm2YLu0RrVKHof98uUPj5v2glCP5ZpcGAABcyO6MPElS8wC7mgXYTa4GAADUB4KvpiQwQvrD89JfVklthkmlhdKqp6QX+kobFnp0/69Qf7teuK63nh3XU0E+Xkrad0yjn1ul937aL8MwzC4PAAC4gMpljsz2AgDAYxB8NUXRPaQbP5WueVMKjZNyUqWPJ0uvjZD2rzW7ugZjsVh0Re/WWjp1mPq3aa684jLd8/4vuu3t9TqWV2x2eQAAwGQVje3j6e8FAIDHIPhqqiwWqcsfpClrpQsfluyB0sEk6bWLpA9ukbIOmF1hg4lp7q+Ftw7U30d1lJfVomW/puniWau0akeG2aUBAAAT0dgeAADPQ/DV1Hn7SsOmS3ckSb1vkGSRNr0nze4rffNvqdgz+2DZrBbddl57fTxliOIjApSeU6QJ89fqkSWbVVhSZnZ5AADABARfAAB4HoIvOAW1kC5/Ubr1f1LsIKm0QPpmprP/1y/vSR7aB6tbqxB9dscw3TgoTpK0YM1ejZm9WpsPZZlcGQAAaEylZQ7tPeJsbh8fEWByNQAAoL4QfKGmlr2lm5ZJV70uhcRI2QelD2+RXhvpXArpgfzsNj16eTe9flM/RQT5aGd6rsa++J1eXpmsModnBn4AAKCmfUfzVVJmyM/bppYhfmaXAwAA6gnBF05ksUjd/ijdvk46/wHJ2186sFZ65QLpo8lSdqrZFTaI8ztGavnUYRrZJUolZYZmLtumP73ygw4eLzC7NAAA0MCS0ysa2wfIarWYXA0AAKgvBF84OW8/6dx7nP2/el7nPLZxoTQ7QVr1lFTieYFQWKCPXh6foCeu7C5/u00/7jmqUbNW6ZMNB80uDQAANKBd5Xd0bB9Bfy8AADwJwRd+X3BL6YqXpFu+llr3l0rypK8fl17oL/36ocf1/7JYLBrXL1bLpg5T79hQ5RSWauqiDbpz4c/Kyi8xuzwAANAAaGwPAIBnIvjC6WudIE36Uvrjq1JwKykrRXr/Jun1S6RDG8yurt7FhQXovb8M0t9GnCOb1aIlGw9p9HOrtCY50+zSAABAPatc6siMLwAAPArBF+rGYpF6XO3s/3XufZKXn5SyRpp3nvTJFCnnsNkV1isvm1VTR3TQ+5MHqU2Yvw5lFer6V3/Uv5ZuVVFpmdnlAQCAemAYhpIznHd0ZMYXAACeheALZ8YeIJ0/Q7rjJ6n71ZIM6ee3nP2/Vj8rlRaZXWG96h3bTJ/fOUzX9Y+VYUjzVu3W5S98p+1pOWaXBgAAztLh7CLlFpXKZrUoLizA7HIAAEA9IvjC2QlpLV35qjQpUWrZRyrOkVY8Ir3YX9qyxKP6fwX4eGnmH7vrlQl91TzArm1pORrzwmq9tnqPHA7P+Z4AADQ1Ff294sL8ZfdieAwAgCfhb3bUj5j+0i1fSWNfkgJbSMf2Su+Ol/47RkrbZHZ19eqiLlFaPm2Yzu8YoeJSh/7x2RZNmL9WaVmFZpcGAADOwK505wxu7ugIAIDnIfhC/bFapV7XSXckScPulmw+0t5vpZeHS59OlXIzzK6w3kQG+Wr+xH56fGw3+XpbtXpXpi6etUpLN6WaXRoAAKijXRnlje3p7wUAgMch+EL98wmULnzQ2f+r6xWS4ZCSFkiz+0hrZkulxWZXWC8sFotuGBinz+8cpu6tQpRVUKLb3l6v6e9uUE5hidnlAQCA05ScXt7YnhlfAAB4HIIvNJzQWOnqBdJNy6TonlJRtvTlA9KcAdK2pR7T/ys+IlAf3jZYt5/fXlaL9OH6gxr93Ldat/eo2aUBAIDTUDHjizs6AgDgeQi+0PDiBkt//p/0hxekgEjp6G5p0XXSm2Olw1vMrq5eeNusuvvijnr3L4MU09xPB44VaNzL3+upL7apuNRhdnkAAOAksgpKlJHjvBs1Sx0BAPA8BF9oHFab1Ge8dOd6aejfJJtd2v2N9NIQ6fO7pLwjZldYL/q2aa6ldw7TVQmt5TCkF/+XrCvnrqm8WxQAAHAtFX9HR4f4KtDHy+RqAABAfSP4QuPyCZJGPCJNWSt1HuPs/7XuVWl2b+mHuVKZ+/fGCvL11n+u7qk51/dRqL+3Nh3M0mWzv9Wb3++V4SHLOwEA8BTJ5cFXPP29AADwSARfMEfzttK4t6QbP5WiukmFWdLy+6Q5g6QdX5pdXb24pHu0vpg2XMM6hKuwxKEHP9msmxasU3pOodmlAQCAcsn09wIAwKMRfMFcbYdLf1klXTZL8g+XjuyU3rlaeutKKWO72dWdtahgX/33pv56eEwX2b2s+mZ7hkbN+lZfbk4zuzQAAKCqpY709wIAwDMRfMF8VpvU9yZn/6/Bd0hWb2nXCufsr2X3SvnufXdEq9Wim4a01Wd3DFXn6GAdzSvWrW8m6b4PflFeUanZ5QEA0KRV3tGRpY4AAHgkgi+4Dt8QaeTj0pQfpY6XSEaZ9ONL0uw+0tpXpDL3DonOiQrSx1MG6y/ntpPFIi1at1+XPv+t1qccM7s0AACapMKSMu0/mi9Jio8MMLkaAADQEAi+4HrC4qXrFkrjP5IiOksFx6SldzvvALnrK7OrOys+XjbNGN1Z79wyUC1DfLX3SL6uful7zfhwkxatTVHSvqPKKnD/Bv+eqqi0zOwSAAD1aE9mnhyGFOzrpYhAH7PLAQAADYB7NsN1xV8gTV4tJb0u/e9fUsY26a0/SuEdpQ4XSe1HSHGDJS/3G6gOig/TsmnD9dAnv+qTDYe0cG2KFq6tej4q2EcdIoPUISqw8uc5kUEK8fc2r+gmwuEwdPB4gZIzcpWckafdGbmV+xk5RerWKlj3XNxJwzuEy2KxmF0uAOAsVG9sz3/TAQDwTARfcG02L6n/n6XuV0krn3Queczc7ty+f0Hy9nc2yG8/whmGNWtjdsWnLcTPW89d21tje7XS6l2Z2nE4R7vSc5WaVajD2UU6nF2k1bsya7wmIshHHSIDdU5UkNpHBlbuNwuwm/Qt3FdeUan2ZOY5Q630XCVn5ik5PVd7MvNUVOo46et+PZitG+ev1aB2Ybp3dCf1igltvKIBAPWqorE9d3QEAMBzEXzBPfg1k0bNlM79u7T7G2nnCmcD/Nw0acdy5yZJYR3KZ4NdKMUNlbx9TS37dJzfKVLnd4qsfJxdWKJd6bnadThXO9NztONwrnal5+rg8QJl5BQpI6dIa5KP1HiP8EC72peHYB0iA9U+MkjnRAUqrIkv2zAMQ2nZhUpOdwZcu8tnbiVnOAPGk7HbrGoT7q924YGKjwxQfESg2kUEKizArv+u2as3vt+n73cf0dgXv9Pobi1018iO/E8TALghgi8AADyfxTAMw+wifk92drZCQkKUlZWl4OBgs8uBqzAMKW2TtCvR2fsr5QdnQ/wKXn5S22FS+4ukDiOk5u3Mq7Ue5BaVald6rnaWzwzbcThHO9NzdeBYwUlf0zygIhArXzIZGagOUUEKD7R71JKOwpKyytlbu8uDrYr9/OKT9+UKC7CXh1rOcCs+MkDtwgPVupmfvGwnb4F48HiBnk3coQ/XH5DDkKwW6Zq+MZo6ooOiQ/wa4isCOAOMH9yDmddp1KxV2paWo9du7KsLO0c16mcDAIAzV5fxA8EXPEdhVvlssPIgLOdQzeebx1f1BmszVPL2jIAiv7giEMvVzvJgbGd6rvYfy9fJ/u0O9feuDME6RDpDsXOiAhUR5OOygZhhGMrILaoKtipmcWU6w7+TfVeb1aK4sJqzt5xbgEL9z26J6I7DOXrqi+1K3HJYkuTjZdXEwW301/Piz/q9AZw9xg/uwazrVOYw1Pmh5SoudWjlPecpLoy7OgIA4C4IvgDDkNK3lIdgK6SU7yVHadXzXr7O8Kv9Rc4wLCzevFobSEFxmZIznMsldx7OLV8ymaN9R08eiAX7elWFYZU/A9Ui2LfRArHiUof2HcmrXJJYfRZXTmHpSV8X7Oul9pHOJYkVwVa7iEDFNveX3athb2CbtO+onli2XWv3Hq2sZfJ58bppcFv52W0N+tkATo7xg3sw6zqlHMnX8Kf+J7uXVVsfGyWb1TV/8QMAAE5E8AX8VmG2tGdlVRCWfbDm883aVjXIbzNMsvubU2cjKCxxBmIVs8QqmurvPeK8pXttgny81D4qsGZj/aggtQw580DsaF5xjTsmVvTfSjmar7KTFGK1SDHN/dUuvGJpYqBzP9LZf8vM2WqGYeh/29P15PLt2paWI0mKDPLR1BEddE3fGHmfYukkgIbB+ME9mHWdvt52WDcv+EmdWgRp+bThjfa5AADg7BF8AadiGFLGtvIQLFHa973kKKl63uYjtRlSbTZYe8lFl//Vp6JSZ5+sHYdztat8ueSOwznae+TkQVSA3ab25TPDKvqItY8MVKtQP1mtFpWWObT/WIHzrom/6b91LL+k1veUpEAfr8oZW/ERVc3l48L85evt2jOoyhyGlmw8qKe/3FHZf61teIDuHtlRl3Rv4bJLSQFPxPjBPZh1neatSta/lm7TZT2i9cKf+jTa5wIAgLNH8AXURVGOtGeVcybYzhVSVkrN50PjqmaDtR0u2ZtWD5DiUof2HslzNtMvv8PkjsM52pOZp9KTBGL+dpsignx06HiBSspO/p+YVqF+1RrLByq+fPZWpAv3GjtdRaVleufHFL3w9S4dySuWJHVvFaJ7R3XS0A7hJlcHNA2MH9yDWdfp7+9v1Ls/HdDUCzvobxed02ifCwAAzh7BF3CmDEPK3FFtNtgaqay46nmbXYob7JwN1n6EFNGxScwGq01JmbMX147DFY31ncHY7szcGmGXn7dN7U6YveW8e2JT6H+VW1SqV7/drVdW7VZe+R0mh7YP172jOql76xCTqwM8G+MH92DWdbpy7hol7Tum2df11pieLRvtcwEAwNkj+ALqS1GutHe1MwTbmSgd31fz+ZBYqf2F5bPBzpV8As2p04WUljm072i+0rOLFBvmr+hgX1lpGKzM3CK98PUuvf3jvspg8NIe0brronPULoI/N0BDYPzgHsy4ToZhqNdjicoqKNGyqcPUOZo/HwAAuBOCL6AhGIZ0ZFfVbLC930llRVXPW72luEFVs8EiOzfZ2WA4uf1H8/Vs4g59tOGgDEOyWS0a1y9GUy/soKhgX7PLAzwK4wf3YMZ1ysgpUr9/rpDVIm15bJTL948EAAA1EXwBjaE4v+ZssGN7aj4f3LrmbDBf/uyiytbUbD31xXZ9vS1dkuTrbdVNQ9pq8rnxCvHzNrk6wDMwfnAPZlyn75OP6LpXflBcmL9W3nN+o3wmAACoP3UZP3g1Uk2A57H7S+eMdG6SdCS5vEF+orT3Wyn7gLT+v87N6iXFDnIGYe0vkqK6MhusiescHaz5E/tp7Z6jemL5NiXtO6a53yTrnR9TdNt58bpxcBtmIABAA9mVkStJimepOQAAHo/gC6gvYfHObcBfpJIC51LIitlgR5OdYdjeb6UVj0hBLatmg7U7T/KlyXlT1b9tc70/eZBWbE3XU19s047DuZq5bJsWrNmraSM66Mo+reVls5pdJgB4lOR0Z/DVPpLgCwAAT8dSR6AxHN0t7frKGYLtWSWVFlQ9Z7FJ0T2ds8CiukqRXZw/A8LNqxemKHMY+nD9AT2buEOHsgolSfERAbrn4o66uGsLWZglCNQJ4wf3YMZ1Gv/aj/p2Z6aevLKHrukX0yifCQAA6g9LHQFX07yd1L+d1P/PUkmhtO+7qmWRR3ZKh9Y7t+oCIqWoLlJk1/KfXaSITs4llvBINqtFV/eN0ZieLfXWD/v04v92KTkjT5PfWq+eMaG6d1RHDY4nEAWAs7WrfMZXPDO+AADweMz4Asx2bJ906GcpfYt0eLPz59E9kmr7V9MiNW9bNSus4mfzdpKVflCeJruwRK+u2q1XV+9RfnGZJGn4ORH6+8Ud1a0Vy2OB38P4wT009nXKLSpVt4e/kCRtfGikQvy5oQgAAO6mwWd8zZkzR0899ZRSU1PVtWtXzZo1S8OGDav13NTUVN11111KSkrSzp07deedd2rWrFln8rGAZ2oW59y6jq06VpwnZWyTDm+pGYjlZTiXTR7dLW37rOp8L18pomPN2WFRXaXAKJrou7FgX29NH9lR4we10eyvd+qdH1O0akeGVu3I0B96ttRdI89RXFiA2WUCgFup6O8VHuhD6AUAQBNQ5+Br8eLFmjZtmubMmaMhQ4bo5Zdf1ujRo7VlyxbFxsaecH5RUZEiIiJ0//3369lnn62XogGPZw+QWiU4t+pyM6T0zeWBWPnPjG1SSb6UutG5VefXvNrMsPJlk5GdJR+WdriTiCAfPXZ5N00a2lZPf7lDSzYe0pKNh7R0U6r+NCBWt1/QXpFBvmaXCQBuITmjorE9vzgAAKApqPNSxwEDBqhPnz6aO3du5bHOnTtr7Nixmjlz5ilfe95556lXr151nvHFUgXgFBwO6die8plh1QKxo8mS4aj9NaFxJwZiYe0lG23/3MHmQ1l6cvl2rdyRIUny87bplmFt9efh7RTsy+wFoALjB/fQ2NfpyeXbNOebZN0wMFaPj+3e4J8HAADqX4MtdSwuLlZSUpLuu+++GsdHjhypNWvW1L3SkygqKlJRUVHl4+zs7Hp7b8DjWK1SWLxz6zym6nhJgZSxveZSycNbpNw06fg+57Z9adX5NrsU3rHmUsnILlJwS5ZLupiuLUP035v76/vkI3pi+TZt2H9cs7/epbd+2Kcp57fXDQPj5OtNzzcAqE1FY/v2Ecx+BgCgKahT8JWZmamysjJFRUXVOB4VFaW0tLR6K2rmzJl69NFH6+39gCbJ209q2cu5VZd/tFoQVv4zfatUnCsd3uTcqvMNrTYzrCIQ6yz50lzdbIPiw/TRbYP1xebDeuqLbUrOyNPjn2/V69/t1bQRHfTHPq1lsxJaAkB1uzK4oyMAAE3JGa1rsvxm9odhGCccOxszZszQ9OnTKx9nZ2crJiam3t4faNL8m0tthzm3Cg6HlJVSc6lk+hYpc6dUeFxKWePcqguJqblUMqqLFNZB8rI36tdp6iwWi0Z1a6ERnSP1wfoDejZxpw4eL9A97/+ieat2656LO+qiLlH1+t9oAHBXJWUOpRzJlyS1J/gCAKBJqFPwFR4eLpvNdsLsrvT09BNmgZ0NHx8f+fj41Nv7AfgdVqvUrI1z63RJ1fHSIilzx4mBWPZBKWu/c9v5RbX38ZbCO5zYTD8kxvkZaDBeNqvG9YvV5b1a6Y3v9+rF/yVrZ3qubn0zSQlxzXTvqE7q37a52WUCgKn2HclTqcNQoI+XWgRzUxAAAJqCOgVfdrtdCQkJSkxM1BVXXFF5PDExUZdffnm9FwfAZF4+Uovuzq26gmPO5ZHVe4elb5GKssuXTm6Rfq12vj1QiuhUtVwysrPzZ2Bko36dpsDX26Zbh8drXL9YvbwyWfO/26Okfcd0zcvf64JOkbrn4o7qHE2T74ZiGIYchuQwDDkMQ0blvvOn4XD+LKvteUf1x85jv32/2Ob+CuIGBsAZq+jvFR8RwExYAACaiDovdZw+fbrGjx+vvn37atCgQZo3b55SUlI0efJkSc5ligcPHtQbb7xR+ZoNGzZIknJzc5WRkaENGzbIbrerS5cu9fMtADQuv2ZS3GDnVsEwpKwDJ/YOy9ju7B928CfnVp1/eFUIVvmzE/3D6kGIn7f+PqqTJg5uo+e+2qlF6/br623p+t/2dI3t1UrTLzpHMc39zS6zBsMwVFzmUEFxmQpKypRfXFa5X1Bc/rikVAXFDuUXl6qw4pwazzv3C0vKysOlivDIkKM8dDJOFUydKnhy/P75Dc3X26pLukfr2n6x6temGf/jDtRRZfDFMkcAAJoMi2EYdR6qz5kzR08++aRSU1PVrVs3Pfvssxo+fLgkaeLEidq7d6+++eabqg+pZWAeFxenvXv3ntbncTtywI2VlUhHd9ecGZa+1XlMJ/nPT0hMeRBWEYZ1kcLPkbxZlnKm9mTm6T9fbtfnv6RKkrxtFl0/IE63X9Be4YGnt7TcMAwVljjKQ6lqwVNxmfJLylRYHj5V33cGUaUnBFn55eFU9bCqoKRMZY2RHrkIi0WyWiyyWpx/T1orH1tqPOd8bFGZw6Fj+SWVr28XHqBx/WL0xz6tFRFEe4DaMH5wD415naYt+lkfbzikey7uqCnnt2/QzwIAAA2nLuOHMwq+GhsDV8ADFec7+4elVwvD0rc6+4fVxmKVmsdXhWEVyyabtZVsZ3SfjiZp04EsPfnFNn27M1OSFGC36ZLu0XIYKg+iSk8aShWUlKmx/sbwtlnk522Tn90mf7uXfL1t8rfbqh2r2vcrf855jpf87Fb5etlkszpDJJu1epD0m6DJWv1x9aDpJOdXD6asdTz/N+9f19lahmFofcpxvbtuvz795ZDyi8skSV5Wi0Z0jtK4/jEa3iGCO3lWw/jBPTTmdRoze7U2HczSy+MTdHHXFg36WQAAoOEQfAFwXwXHpPRtNcOw9M3O47Wx+UgR51TNDKtYNhnS2jmlBrX6blemnli+Tb8cyDqj19u9rCcJorzk522tEVZVhVK/Dau8agRXfvaq57xt3AzhVHKLSvXZxkNatG6/Nuw/Xnk8OsRXV/eN0dUJrV1uKasZGD+4h8a6Tg6HoW6PfKH84jJ9dde5io9guSMAAO6K4AuAZzEMKfdwtTCsfNlkxjapJL/21/gE195QPyC8cWt3YYZhKHHLYf16KLtm+PTbkMpuk7+3V41gillFrmNbWrYWr9uvj34+qOPlSyEtFmlo+3Bd2y9WI7pEysfLZnKV5mD84B4a6zodPF6gIf/+Wt42i7Y+NkpeBOwAALgtgi8ATYPDIR3fVzUrrGKGWOYOyVFa+2sCImrODKtoqO8T1Li1A/WssKRMX245rMXrUvTdriOVx5sH2PXH3q00rl+MOkQ1rT/njB/cQ2Ndp5U7MnTj/LXqEBmoxOnnNtjnAACAhleX8QONcQC4L6tVat7WuXW6pOp4abF0NLn87pJbq2aJHdsr5WVIe1Y6t+pCY38ThnV2NtT3cvGm4YbhvIGAo6T8Z2nNx6fznJev84YCoTEEgG7M19umP/RsqT/0bKmUI/l696f9ei9pvw5nF+nV1Xv06uo9SohrpnH9YnRp92gF+DAEQNNSeUdHljgCANCkMOoF4Hm87FV3hayuOM+5PLJ6GHZ4i5SbJh1PcW47lledb7FJYe1rzgyzB/wmUCr9TbBUfBrPldYSSNX2XMXri2t5r/JzTjaz7Uz5hjpDwNDY8jAs1hmIVez7NaN3mhuIDfPX3Rd31LQRHbRyR4YWrduvr7elK2nfMSXtO6bHPt2iMT2jNa5frHq2Dqlzo33AHSVnOIOv9pEEXwAANCUEXwCaDnuA1CrBuVWXf7QqCKv8uUUqzJIytzu3LR+bUvIZsdgkm7dk9Xbe8dLqXf7YS7LZq+2Xn1OSJx3fLxUed25px6W0X2p/b3tgzUCsRkAW61xKSojiMrxsVl3YOUoXdo5SenahPlh/UIvXpWjvkXwtXLtfC9fuV6cWQRrXL0ZX9G6lUH+72SUDDaZixhfBFwAATQs9vgCgNoYh5aRWhWEVzfQdJdWCpPJgyWY/ScjkXf5ctZDpjJ+r9t6nes7q7VwCeiYKs6Ws/c4QLGu/s39a5X6Kc5no7/Hydd5RszIQi5FC46r2g6Ila9NstO4qDMPQj3uOavG6/Vq6KVVFpQ5Jzjt1juraQtf2i9HAdmGyesANDBg/uIfGuk4J/0jUkbxifXbHUHVrFdJgnwMAABoeze0BAPWvpEDKOnBiIFaxn31I0u/8lWL1koJbnXw5ZUhrZ4CHRpGVX6JPNh7UwrX7tTU1u/J4bHN/jesXo6sSWisq2NfECs8O4wf30BjX6VhesXr/I1GStOWxi+VvZ9EDAADujOb2AID65+0nhXdwbrUpLZayD54YiFX0T8s+6OxJdnyfc6uNxeqcFVZbf7HQWGcw5u3XcN+xiQnx99aEQW00fmCcfj2YrUXrUrRkwyGlHM3XU19s1zOJO3R+xwiN6xer8ztGyMt2hrMJAZPtKu/v1SrUj9ALAIAmhr/5AQD1w8tedZfN2jjKpJzyGwlUD8SqL68sLXQGZNkHpf0/1P4+AZG1BGLVgjLuTFlnFotF3VuHqHvr7rr/0s5auilNi9elaN3eY1qxNV0rtqYrMshHVyW01jV9Y9QmPMDskoE6Sa64oyP9vQAAaHIIvgAAjcNqk0JaOTcNOvF5w3D2ETte3l+sIhCrHpQV50p56c7tYFLtn+PXTApu7QzA7P7Omxp4Bzj3vSse+5c/Dqj5s7Zzm9jSS3+7l65KaK2rElprV3qu3vtpv95POqD0nCLN+SZZc75J1qB2Ybq2f4wu7tpCvt70bIPrq2xsH0HwBQBAU0PwBQBwDRaLFBjp3FonnPi8YUgFx2oPxCr2C45VbfXF6v2bkKw8EKsM0GoL0vxrPn+yc71c+y6K7SMDNeOSzrprZEd9ve2wFq3br5U7MvT97iP6fvcRhfh564rerTSuX4w6R9NDC66rYqkjd3QEAKDpIfgCALgHi0Xyb+7convWfk5RjjMUyz7knB1Wki8V51X9rNzPl0ryyn/+9pzy5xylzvd0lEiFWc6tvlm9fhOW+Uv2wJMHaQERzrtkVizrtDfOkkO7l1WjukVrVLdoHTxeoPd/OqB3f9qvg8cLtGDNXi1Ys1c9W4doXL9YjekZrSDfpjVLDq6vYsZXfATLdAEAaGoIvgAAnsMnSIrq4tzOVmnxKcKxvN8c+22QllvL66qd4yhxfoajVCrKcm5nwj+8qs9Z5dawwVirUD9NHdFBt1/QXt/tytTidfv15ZY0bTyQpY0HNukfn23RZT2idW3/GPWJbSaLxVLvNQB1UVBcpoPHCyQx4wsAgKaI4AsAgNp42Z2bX7P6f++ThmrVA7S8mjPQivOknMPlSzv3SUXZUn6mczu0vvbPqQzGYn4TipXfEMDnzEMAm9Wi4edEaPg5ETqSW6SPfj6oRev2O/uCJR3Qe0kH1D4yUNf2i9EVvVspLNDnjD8LOBu7M3NlGFIzf2/+HAIA0AQRfAEA0NjqI1QrOF7V36zGHTL3OfcLs04jGAs7yWyxugVjYYE+umVYO00a2lbrU45p0dr9+uyXVO1Kz9Xjn2/VE8u36aIuURrXL1ZD24fLZmUWGBpPZWN7ZnsBANAkEXwBAOCO/EKdW3SP2p8vOF6z+X/lVj0YO+LcDv1c+3vUMRizWCxKiGuuhLjmemhMF326MVWL16Vo44EsLd2UpqWb0tQq1E9X922tq/vGqFWoX33+E8FpmDNnjp566imlpqaqa9eumjVrloYNG1bruRMnTtR///vfE4536dJFmzdvliQtWLBAN9100wnnFBQUyNfXt36LP0PJBF8AADRpBF8AAHiiimCsRffan6+PYMyv+UmDsaDQWP1pgHPbcihb7/60Xx/9fFAHjxdo1oqdeu6rnRreIULX9ovRhZ2jZPeyNtA/CFRYvHixpk2bpjlz5mjIkCF6+eWXNXr0aG3ZskWxsbEnnP/cc8/p3//+d+Xj0tJS9ezZU1dffXWN84KDg7V9+/Yax1wl9JKq7ugYH0HwBQBAU0TwBQBAU1QfwVjBUeeWuuEkn+EMxrqExuqR0Fjdf1GMkrKD9OFumz5P8dLKHRlauSNDj13eVRMGtWmQr4kqzzzzjCZNmqRbbrlFkjRr1ix98cUXmjt3rmbOnHnC+SEhIQoJCal8/PHHH+vYsWMnzPCyWCxq0aJFwxZ/FpLT8yRJ8cz4AgCgSSL4AgAAJzrjYKx8Kzx+QjDmLWlg+fakr5TvFaIUR7hahz4lqU2Df6WmrLi4WElJSbrvvvtqHB85cqTWrFlzWu/x2muvacSIEYqLi6txPDc3V3FxcSorK1OvXr30j3/8Q7179z7p+xQVFamoqKjycXZ2dh2+Sd2Uljm0J9MZfLVnxhcAAE0SwRcAAKi73wvGCrOk478NxvbVCMb8S7PUSVmSr70xK2+SMjMzVVZWpqioqBrHo6KilJaW9ruvT01N1bJly/TOO+/UON6pUyctWLBA3bt3V3Z2tp577jkNGTJEGzduVIcOHWp9r5kzZ+rRRx898y9TB/uPFai4zCE/bxs95QAAaKIIvgAAQP3zDZFahEgtutX+fPVg7GThGeqdxVLzjpqGYZxwrDYLFixQaGioxo4dW+P4wIEDNXDgwMrHQ4YMUZ8+fTR79mw9//zztb7XjBkzNH369MrH2dnZiomJqcO3OH0tQ3215PYhSs8ukpW7iQIA0CQRfAEAgMb3e8EY6lV4eLhsNtsJs7vS09NPmAX2W4ZhaP78+Ro/frzs9lPPzrNarerXr5927tx50nN8fHzk4+Nz+sWfBR8vm3q0Dm2UzwIAAK6JWygBAAB4OLvdroSEBCUmJtY4npiYqMGDB5/ytStXrtSuXbs0adKk3/0cwzC0YcMGRUdHn1W9AAAA9YUZXwAAAE3A9OnTNX78ePXt21eDBg3SvHnzlJKSosmTJ0tyLkE8ePCg3njjjRqve+211zRgwAB163bi7LxHH31UAwcOVIcOHZSdna3nn39eGzZs0Isvvtgo3wkAAOD3EHwBAAA0AePGjdORI0f02GOPKTU1Vd26ddPSpUsr79KYmpqqlJSUGq/JysrSBx98oOeee67W9zx+/LhuvfVWpaWlKSQkRL1799aqVavUv3//Bv8+AAAAp8NiGIZhdhG/Jzs7WyEhIcrKylJwcLDZ5QAAADfA+ME9cJ0AAEBd1WX8QI8vAAAAAAAAeCSCLwAAAAAAAHgkgi8AAAAAAAB4JIIvAAAAAAAAeCSCLwAAAAAAAHgkgi8AAAAAAAB4JIIvAAAAAAAAeCSCLwAAAAAAAHgkgi8AAAAAAAB4JIIvAAAAAAAAeCSCLwAAAAAAAHgkgi8AAAAAAAB4JIIvAAAAAAAAeCSCLwAAAAAAAHgkgi8AAAAAAAB4JIIvAAAAAAAAeCSCLwAAAAAAAHgkL7MLOB2GYUiSsrOzTa4EAAC4i4pxQ8U4Aq6JcR4AAKiruozz3CL4ysnJkSTFxMSYXAkAAHA3OTk5CgkJMbsMnATjPAAAcKZOZ5xnMdzg16AOh0OHDh1SUFCQLBZLvb9/dna2YmJitH//fgUHB9f7+6P+cK3cA9fJfXCt3AfXqu4Mw1BOTo5atmwpq5XuDq6KcR4qcK3cA9fJfXCt3AfXqu7qMs5zixlfVqtVrVu3bvDPCQ4O5g+Zm+BauQeuk/vgWrkPrlXdMNPL9THOw29xrdwD18l9cK3cB9eqbk53nMevPwEAAAAAAOCRCL4AAAAAAADgkQi+JPn4+Ojhhx+Wj4+P2aXgd3Ct3APXyX1wrdwH1wo4M/y74z64Vu6B6+Q+uFbug2vVsNyiuT0AAAAAAABQV8z4AgAAAAAAgEci+AIAAAAAAIBHIvgCAAAAAACARyL4AgAAAAAAgEdq8sHXnDlz1LZtW/n6+iohIUHffvut2SXhN2bOnKl+/fopKChIkZGRGjt2rLZv3252WTgNM2fOlMVi0bRp08wuBbU4ePCgbrjhBoWFhcnf31+9evVSUlKS2WWhmtLSUj3wwANq27at/Pz81K5dOz322GNyOBxmlwa4BcZ5ro9xnvtinOfaGOe5B8Z6jaNJB1+LFy/WtGnTdP/99+vnn3/WsGHDNHr0aKWkpJhdGqpZuXKlpkyZoh9++EGJiYkqLS3VyJEjlZeXZ3ZpOIV169Zp3rx56tGjh9mloBbHjh3TkCFD5O3trWXLlmnLli16+umnFRoaanZpqOaJJ57QSy+9pBdeeEFbt27Vk08+qaeeekqzZ882uzTA5THOcw+M89wT4zzXxjjPfTDWaxwWwzAMs4swy4ABA9SnTx/NnTu38ljnzp01duxYzZw508TKcCoZGRmKjIzUypUrNXz4cLPLQS1yc3PVp08fzZkzR48//rh69eqlWbNmmV0Wqrnvvvv03XffMfvBxV122WWKiorSa6+9VnnsyiuvlL+/v958800TKwNcH+M898Q4z/UxznN9jPPcB2O9xtFkZ3wVFxcrKSlJI0eOrHF85MiRWrNmjUlV4XRkZWVJkpo3b25yJTiZKVOm6NJLL9WIESPMLgUnsWTJEvXt21dXX321IiMj1bt3b73yyitml4XfGDp0qL766ivt2LFDkrRx40atXr1al1xyicmVAa6NcZ77Ypzn+hjnuT7Gee6DsV7j8DK7ALNkZmaqrKxMUVFRNY5HRUUpLS3NpKrwewzD0PTp0zV06FB169bN7HJQi0WLFmn9+vVat26d2aXgFHbv3q25c+dq+vTp+r//+z+tXbtWd955p3x8fDRhwgSzy0O5e++9V1lZWerUqZNsNpvKysr0z3/+U9ddd53ZpQEujXGee2Kc5/oY57kHxnnug7Fe42iywVcFi8VS47FhGCccg+u4/fbb9csvv2j16tVml4Ja7N+/X1OnTtWXX34pX19fs8vBKTgcDvXt21f/+te/JEm9e/fW5s2bNXfuXAZELmTx4sV666239M4776hr167asGGDpk2bppYtW+rGG280uzzA5THOcy+M81wb4zz3wTjPfTDWaxxNNvgKDw+XzWY74bd+6enpJ/x2EK7hjjvu0JIlS7Rq1Sq1bt3a7HJQi6SkJKWnpyshIaHyWFlZmVatWqUXXnhBRUVFstlsJlaICtHR0erSpUuNY507d9YHH3xgUkWozT333KP77rtP1157rSSpe/fu2rdvn2bOnMlgCDgFxnnuh3Ge62Oc5z4Y57kPxnqNo8n2+LLb7UpISFBiYmKN44mJiRo8eLBJVaE2hmHo9ttv14cffqivv/5abdu2NbsknMSFF16oTZs2acOGDZVb3759df3112vDhg0MhlzIkCFDTrhd/I4dOxQXF2dSRahNfn6+rNaaf1XbbDZucQ38DsZ57oNxnvtgnOc+GOe5D8Z6jaPJzviSpOnTp2v8+PHq27evBg0apHnz5iklJUWTJ082uzRUM2XKFL3zzjv65JNPFBQUVPnb25CQEPn5+ZlcHaoLCgo6oSdHQECAwsLC6NXhYv72t79p8ODB+te//qVrrrlGa9eu1bx58zRv3jyzS0M1Y8aM0T//+U/Fxsaqa9eu+vnnn/XMM8/o5ptvNrs0wOUxznMPjPPcB+M898E4z30w1mscFsMwDLOLMNOcOXP05JNPKjU1Vd26ddOzzz7LrZNdzMl6cbz++uuaOHFi4xaDOjvvvPO4zbWL+uyzzzRjxgzt3LlTbdu21fTp0/XnP//Z7LJQTU5Ojh588EF99NFHSk9PV8uWLXXdddfpoYcekt1uN7s8wOUxznN9jPPcG+M818U4zz0w1mscTT74AgAAAAAAgGdqsj2+AAAAAAAA4NkIvgAAAAAAAOCRCL4AAAAAAADgkQi+AAAAAAAA4JEIvgAAAAAAAOCRCL4AAAAAAADgkQi+AAAAAAAA4JEIvgAAAAAAAOCRCL4ANBkWi0Uff/yx2WUAAACgnjHOA3AyBF8AGsXEiRNlsVhO2EaNGmV2aQAAADgLjPMAuDIvswsA0HSMGjVKr7/+eo1jPj4+JlUDAACA+sI4D4CrYsYXgEbj4+OjFi1a1NiaNWsmyTk9fe7cuRo9erT8/PzUtm1bvffeezVev2nTJl1wwQXy8/NTWFiYbr31VuXm5tY4Z/78+eratat8fHwUHR2t22+/vcbzmZmZuuKKK+Tv768OHTpoyZIllc8dO3ZM119/vSIiIuTn56cOHTqcMIADAADAiRjnAXBVBF8AXMaDDz6oK6+8Uhs3btQNN9yg6667Tlu3bpUk5efna9SoUWrWrJnWrVun9957TytWrKgx4Jk7d66mTJmiW2+9VZs2bdKSJUvUvn37Gp/x6KOP6pprrtEvv/yiSy65RNdff72OHj1a+flbtmzRsmXLtHXrVs2dO1fh4eGN9w8AAADAQzHOA2AaAwAawY033mjYbDYjICCgxvbYY48ZhmEYkozJkyfXeM2AAQOMv/71r4ZhGMa8efOMZs2aGbm5uZXPf/7554bVajXS0tIMwzCMli1bGvfff/9Ja5BkPPDAA5WPc3NzDYvFYixbtswwDMMYM2aMcdNNN9XPFwYAAGgiGOcBcGX0+ALQaM4//3zNnTu3xrHmzZtX7g8aNKjGc4MGDdKGDRskSVu3blXPnj0VEBBQ+fyQIUPkcDi0fft2WSwWHTp0SBdeeOEpa+jRo0flfkBAgIKCgpSeni5J+utf/6orr7xS69ev18iRIzV27FgNHjz4jL4rAABAU8I4D4CrIvgC0GgCAgJOmJL+eywWiyTJMIzK/drO8fPzO6338/b2PuG1DodDkjR69Gjt27dPn3/+uVasWKELL7xQU6ZM0X/+85861QwAANDUMM4D4Kro8QXAZfzwww8nPO7UqZMkqUuXLtqwYYPy8vIqn//uu+9ktVp1zjnnKCgoSG3atNFXX311VjVERERo4sSJeuuttzRr1izNmzfvrN4PAAAAjPMAmIcZXwAaTVFRkdLS0moc8/Lyqmws+t5776lv374aOnSo3n77ba1du1avvfaaJOn666/Xww8/rBtvvFGPPPKIMjIydMcdd2j8+PGKioqSJD3yyCOaPHmyIiMjNXr0aOXk5Oi7777THXfccVr1PfTQQ0pISFDXrl1VVFSkzz77TJ07d67HfwIAAACeiXEeAFdF8AWg0SxfvlzR0dE1jnXs2FHbtm2T5LwTz6JFi3TbbbepRYsWevvtt9WlSxdJkr+/v7744gtNnTpV/fr1k7+/v6688ko988wzle914403qrCwUM8++6zuvvtuhYeH66qrrjrt+ux2u2bMmKG9e/fKz89Pw4YN06JFi+rhmwMAAHg2xnkAXJXFMAzD7CIAwGKx6KOPPtLYsWPNLgUAAAD1iHEeADPR4wsAAAAAAAAeieALAAAAAAAAHomljgAAAAAAAPBIzPgCAAAAAACARyL4AgAAAAAAgEci+AIAAAAAAIBHIvgCAAAAAACARyL4AgAAAAAAgEci+AIAAAAAAIBHIvgCAAAAAACARyL4AgAAAAAAgEf6f69rdAf4knlkAAAAAElFTkSuQmCC",748      "text/plain": [749       "<Figure size 1500x700 with 2 Axes>"750      ]751     },752     "metadata": {},753     "output_type": "display_data"754    }755   ],756   "source": [757    "from helper_functions import plot_loss_curves\n",758    "plot_loss_curves(vit_results)"759   ]760  },761  {762   "cell_type": "code",763   "execution_count": 27,764   "id": "915b4aa9-9b38-433d-bc57-cde2c471d7ff",765   "metadata": {},766   "outputs": [767    {768     "name": "stdout",769     "output_type": "stream",770     "text": [771      "[INFO] Saving model to: models\\09_pretrained_vit_feature_extractor_pizza_steak_sushi_20_percent.pth\n"772     ]773    }774   ],775   "source": [776    "# Save the model\n",777    "from going_modular import utils\n",778    "\n",779    "utils.save_model(model=vit,\n",780    "                 target_dir=\"models\",\n",781    "                 model_name=\"09_pretrained_vit_feature_extractor_pizza_steak_sushi_20_percent.pth\")"782   ]783  },784  {785   "cell_type": "code",786   "execution_count": 28,787   "id": "086cb6c9-6d4f-4a00-ae0a-2db7f724dd5a",788   "metadata": {},789   "outputs": [790    {791     "name": "stdout",792     "output_type": "stream",793     "text": [794      "Pretrained ViT feature extractor model size: 327 MB\n",795      "85800963\n",796      "{'test_loss': 0.06418209867551923, 'test_acc': 0.984659090909091, 'number_of_parameters': 85800963, 'model_size (MB)': 327}\n"797     ]798    }799   ],800   "source": [801    "from pathlib import Path\n",802    "\n",803    "# Get the model size in bytes then convert to megabytes\n",804    "pretrained_vit_model_size = Path(\"models/09_pretrained_vit_feature_extractor_pizza_steak_sushi_20_percent.pth\").stat().st_size // (1024*1024) # division converts bytes to megabytes (roughly) \n",805    "print(f\"Pretrained ViT feature extractor model size: {pretrained_vit_model_size} MB\")\n",806    "\n",807    "# Count number of parameters in ViT\n",808    "vit_total_params = sum(torch.numel(param) for param in vit.parameters())\n",809    "print(vit_total_params)\n",810    "\n",811    "# Create ViT statistics dictionary\n",812    "vit_stats = {\"test_loss\": vit_results[\"test_loss\"][-1],\n",813    "             \"test_acc\": vit_results[\"test_acc\"][-1],\n",814    "             \"number_of_parameters\": vit_total_params,\n",815    "             \"model_size (MB)\": pretrained_vit_model_size}\n",816    "print(vit_stats)"817   ]818  },819  {820   "cell_type": "markdown",821   "id": "2bbe54d0-1576-4d65-b3ca-c4c4812429fc",822   "metadata": {},823   "source": [824    "### 評估兩個模型"825   ]826  },827  {828   "cell_type": "code",829   "execution_count": 29,830   "id": "0c7fa966-e2c6-4981-8a48-86e3cad0f18e",831   "metadata": {},832   "outputs": [833    {834     "name": "stdout",835     "output_type": "stream",836     "text": [837      "[INFO] Finding all filepaths ending with '.jpg' in directory: data\\pizza_steak_sushi_20_percent\\test\n",838      "[WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/1001116.jpg'), WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/1032754.jpg'), WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/1067986.jpg'), WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/129666.jpg'), WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/1315645.jpg')]\n",839      "150\n"840     ]841    }842   ],843   "source": [844    "# Get five images in the test data\n",845    "from pathlib import Path\n",846    "\n",847    "# Get all test data paths\n",848    "print(f\"[INFO] Finding all filepaths ending with '.jpg' in directory: {test_dir}\")\n",849    "test_data_paths = list(Path(test_dir).glob(\"*/*.jpg\"))\n",850    "print(test_data_paths[:5])\n",851    "print(len(test_data_paths))"852   ]853  },854  {855   "cell_type": "code",856   "execution_count": 30,857   "id": "3c13ad05-a3ca-4737-aaf1-f38f21de3dea",858   "metadata": {},859   "outputs": [],860   "source": [861    "import pathlib\n",862    "import torch\n",863    "\n",864    "from PIL import Image\n",865    "from timeit import default_timer as timer \n",866    "from tqdm.auto import tqdm\n",867    "from typing import List, Dict\n",868    "\n",869    "# 1. Create a function to return a list of dictionaries with sample, truth label, prediction, prediction probability and prediction time\n",870    "def pred_and_store(paths: List[pathlib.Path], \n",871    "                   model: torch.nn.Module,\n",872    "                   transform: torchvision.transforms, \n",873    "                   class_names: List[str], \n",874    "                   device: str = \"cuda\" if torch.cuda.is_available() else \"cpu\") -> List[Dict]:\n",875    "    \n",876    "    # 2. Create an empty list to store prediction dictionaries\n",877    "    pred_list = []\n",878    "    \n",879    "    # 3. Loop through target paths\n",880    "    for path in tqdm(paths):\n",881    "        \n",882    "        # 4. Create empty dictionary to store prediction information for each sample\n",883    "        pred_dict = {}\n",884    "\n",885    "        # 5. Get the sample path and ground truth class name\n",886    "        pred_dict[\"image_path\"] = path\n",887    "        class_name = path.parent.stem\n",888    "        pred_dict[\"class_name\"] = class_name\n",889    "        \n",890    "        # 6. Start the prediction timer\n",891    "        start_time = timer()\n",892    "        \n",893    "        # 7. Open image path\n",894    "        img = Image.open(path)\n",895    "        \n",896    "        # 8. Transform the image, add batch dimension and put image on target device\n",897    "        transformed_image = transform(img).unsqueeze(0).to(device) \n",898    "        \n",899    "        # 9. Prepare model for inference by sending it to target device and turning on eval() mode\n",900    "        model.to(device)\n",901    "        model.eval() # 關閉Dropout、Batch Normalization等等\n",902    "        \n",903    "        # 10. Get prediction probability, predicition label and prediction class\n",904    "        # 禁用梯度計算(Gradient Computation)\n",905    "        # Gradient Descent：梯度下降\n",906    "        # Gradient Backpropagation：梯度反向傳播\n",907    "        # Compute Gradients：計算梯度\n",908    "        with torch.inference_mode():  \n",909    "            pred_logit = model(transformed_image) # perform inference on target sample \n",910    "            pred_prob = torch.softmax(pred_logit, dim=1) # turn logits into prediction probabilities\n",911    "            pred_label = torch.argmax(pred_prob, dim=1) # turn prediction probabilities into prediction label\n",912    "            pred_class = class_names[pred_label.cpu()] # hardcode prediction class to be on CPU\n",913    "\n",914    "            # 11. Make sure things in the dictionary are on CPU (required for inspecting predictions later on) \n",915    "            # round(..., 4)\n",916    "            pred_dict[\"pred_prob\"] = round(pred_prob.unsqueeze(0).max().cpu().item(), 4)\n",917    "            pred_dict[\"pred_class\"] = pred_class\n",918    "            \n",919    "            # 12. End the timer and calculate time per pred\n",920    "            end_time = timer()\n",921    "            pred_dict[\"time_for_pred\"] = round(end_time-start_time, 4)\n",922    "\n",923    "        # 13. Does the pred match the true label?\n",924    "        pred_dict[\"correct\"] = class_name == pred_class\n",925    "\n",926    "        # 14. Add the dictionary to the list of preds\n",927    "        pred_list.append(pred_dict)\n",928    "    \n",929    "    # 15. Return list of prediction dictionaries\n",930    "    return pred_list"931   ]932  },933  {934   "cell_type": "code",935   "execution_count": 31,936   "id": "4b4cecdf-6856-40d4-b9a3-d621c900a754",937   "metadata": {},938   "outputs": [939    {940     "data": {941      "application/vnd.jupyter.widget-view+json": {942       "model_id": "b9ad13a6ad254f999666ad9819768bfe",943       "version_major": 2,944       "version_minor": 0945      },946      "text/plain": [947       "  0%|          | 0/150 [00:00<?, ?it/s]"948      ]949     },950     "metadata": {},951     "output_type": "display_data"952    }953   ],954   "source": [955    "# Make predictions across test dataset with EffNetB2\n",956    "effnetb2_test_pred_dicts = pred_and_store(paths=test_data_paths,\n",957    "                                          model=effnetb2,\n",958    "                                          transform=effnetb2_transforms,\n",959    "                                          class_names=class_names,\n",960    "                                          device=\"cpu\") # make predictions on CPU "961   ]962  },963  {964   "cell_type": "code",965   "execution_count": 32,966   "id": "e5b8fa61-a8b5-4b69-8b55-7e1ee30f6ffe",967   "metadata": {},968   "outputs": [969    {970     "data": {971      "text/plain": [972       "[{'image_path': WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/1001116.jpg'),\n",973       "  'class_name': 'pizza',\n",974       "  'pred_prob': 0.9941,\n",975       "  'pred_class': 'pizza',\n",976       "  'time_for_pred': 0.1143,\n",977       "  'correct': True},\n",978       " {'image_path': WindowsPath('data/pizza_steak_sushi_20_percent/test/pizza/1032754.jpg'),\n",979       "  'class_name': 'pizza',\n",980       "  'pred_prob': 0.4901,\n",981       "  'pred_class': 'pizza',\n",982       "  'time_for_pred': 0.042,\n",983       "  'correct': True}]"984      ]985     },986     "execution_count": 32,987     "metadata": {},988     "output_type": "execute_result"989    }990   ],991   "source": [992    "# Inspect the first 2 prediction dictionaries\n",993    "effnetb2_test_pred_dicts[:2]"994   ]995  },996  {997   "cell_type": "code",998   "execution_count": 33,999   "id": "0c73ee2b-37b8-46f5-95a8-a61ccf8803fa",1000   "metadata": {},1001   "outputs": [1002    {1003     "data": {1004      "text/html": [1005       "<div>\n",1006       "<style scoped>\n",1007       "    .dataframe tbody tr th:only-of-type {\n",1008       "        vertical-align: middle;\n",1009       "    }\n",1010       "\n",1011       "    .dataframe tbody tr th {\n",1012       "        vertical-align: top;\n",1013       "    }\n",1014       "\n",1015       "    .dataframe thead th {\n",1016       "        text-align: right;\n",1017       "    }\n",1018       "</style>\n",1019       "<table border=\"1\" class=\"dataframe\">\n",1020       "  <thead>\n",1021       "    <tr style=\"text-align: right;\">\n",1022       "      <th></th>\n",1023       "      <th>image_path</th>\n",1024       "      <th>class_name</th>\n",1025       "      <th>pred_prob</th>\n",1026       "      <th>pred_class</th>\n",1027       "      <th>time_for_pred</th>\n",1028       "      <th>correct</th>\n",1029       "    </tr>\n",1030       "  </thead>\n",1031       "  <tbody>\n",1032       "    <tr>\n",1033       "      <th>0</th>\n",1034       "      <td>data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...</td>\n",1035       "      <td>pizza</td>\n",1036       "      <td>0.9941</td>\n",1037       "      <td>pizza</td>\n",1038       "      <td>0.1143</td>\n",1039       "      <td>True</td>\n",1040       "    </tr>\n",1041       "    <tr>\n",1042       "      <th>1</th>\n",1043       "      <td>data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...</td>\n",1044       "      <td>pizza</td>\n",1045       "      <td>0.4901</td>\n",1046       "      <td>pizza</td>\n",1047       "      <td>0.0420</td>\n",1048       "      <td>True</td>\n",1049       "    </tr>\n",1050       "    <tr>\n",1051       "      <th>2</th>\n",1052       "      <td>data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...</td>\n",1053       "      <td>pizza</td>\n",1054       "      <td>0.9922</td>\n",1055       "      <td>pizza</td>\n",1056       "      <td>0.0360</td>\n",1057       "      <td>True</td>\n",1058       "    </tr>\n",1059       "    <tr>\n",1060       "      <th>3</th>\n",1061       "      <td>data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...</td>\n",1062       "      <td>pizza</td>\n",1063       "      <td>0.6918</td>\n",1064       "      <td>pizza</td>\n",1065       "      <td>0.0349</td>\n",1066       "      <td>True</td>\n",1067       "    </tr>\n",1068       "    <tr>\n",1069       "      <th>4</th>\n",1070       "      <td>data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...</td>\n",1071       "      <td>pizza</td>\n",1072       "      <td>0.7661</td>\n",1073       "      <td>pizza</td>\n",1074       "      <td>0.0394</td>\n",1075       "      <td>True</td>\n",1076       "    </tr>\n",1077       "  </tbody>\n",1078       "</table>\n",1079       "</div>"1080      ],1081      "text/plain": [1082       "                                          image_path class_name  pred_prob  \\\n",1083       "0  data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...      pizza     0.9941   \n",1084       "1  data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...      pizza     0.4901   \n",1085       "2  data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...      pizza     0.9922   \n",1086       "3  data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...      pizza     0.6918   \n",1087       "4  data\\pizza_steak_sushi_20_percent\\test\\pizza\\1...      pizza     0.7661   \n",1088       "\n",1089       "  pred_class  time_for_pred  correct  \n",1090       "0      pizza         0.1143     True  \n",1091       "1      pizza         0.0420     True  \n",1092       "2      pizza         0.0360     True  \n",1093       "3      pizza         0.0349     True  \n",1094       "4      pizza         0.0394     True  "1095      ]1096     },1097     "execution_count": 33,1098     "metadata": {},1099     "output_type": "execute_result"1100    }1101   ],1102   "source": [1103    "# Turn the test_pred_dicts into a DataFrame\n",1104    "import pandas as pd\n",1105    "effnetb2_test_pred_df = pd.DataFrame(effnetb2_test_pred_dicts)\n",1106    "effnetb2_test_pred_df.head()"1107   ]1108  },1109  {1110   "cell_type": "code",1111   "execution_count": 34,1112   "id": "55d81dfe-d613-4ba4-b14c-7557682a45b1",1113   "metadata": {},1114   "outputs": [1115    {1116     "data": {1117      "text/plain": [1118       "correct\n",1119       "True     145\n",1120       "False      5\n",1121       "Name: count, dtype: int64"1122      ]1123     },1124     "execution_count": 34,1125     "metadata": {},1126     "output_type": "execute_result"1127    }1128   ],1129   "source": [1130    "# Check number of correct predictions\n",1131    "effnetb2_test_pred_df.correct.value_counts()"1132   ]1133  },1134  {1135   "cell_type": "code",1136   "execution_count": 35,1137   "id": "5c500dbb-e62b-461a-8cdd-111466f73cd7",1138   "metadata": {},1139   "outputs": [1140    {1141     "name": "stdout",1142     "output_type": "stream",1143     "text": [1144      "EffNetB2 average time per prediction: 0.0382 seconds\n"1145     ]1146    }1147   ],1148   "source": [1149    "# Find the average time per prediction \n",1150    "effnetb2_average_time_per_pred = round(effnetb2_test_pred_df.time_for_pred.mean(), 4)\n",1151    "print(f\"EffNetB2 average time per prediction: {effnetb2_average_time_per_pred} seconds\")"1152   ]1153  },1154  {1155   "cell_type": "code",1156   "execution_count": 36,1157   "id": "f601dc85-1d5e-4545-954b-0313d4929fbf",1158   "metadata": {},1159   "outputs": [1160    {1161     "data": {1162      "text/plain": [1163       "{'test_loss': 0.2812717080116272,\n",1164       " 'test_acc': 0.96875,\n",1165       " 'number_of_parameters': 7705221,\n",1166       " 'model_size (MB)': 29,\n",1167       " 'time_per_pred_cpu': 0.0382}"1168      ]1169     },1170     "execution_count": 36,1171     "metadata": {},1172     "output_type": "execute_result"1173    }1174   ],1175   "source": [1176    "# Add EffNetB2 average prediction time to stats dictionary \n",1177    "effnetb2_stats[\"time_per_pred_cpu\"] = effnetb2_average_time_per_pred\n",1178    "effnetb2_stats"1179   ]1180  },1181  {1182   "cell_type": "code",1183   "execution_count": 37,1184   "id": "4fb9b740-6f74-4092-9fac-6d6666f065e1",1185   "metadata": {},1186   "outputs": [1187    {1188     "data": {1189      "application/vnd.jupyter.widget-view+json": {1190       "model_id": "71dc8d6e4e324a39ba27f61c60a9be98",1191       "version_major": 2,1192       "version_minor": 01193      },1194      "text/plain": [1195       "  0%|          | 0/150 [00:00<?, ?it/s]"1196      ]1197     },1198     "metadata": {},1199     "output_type": "display_data"1200    }

Showing the first 1,200 of 2689 lines. Download the file for the rest.