diff --git "a/Week16_\354\230\210\354\212\265\352\263\274\354\240\234_\354\225\210\354\230\210\354\235\200.ipynb" "b/Week16_\354\230\210\354\212\265\352\263\274\354\240\234_\354\225\210\354\230\210\354\235\200.ipynb" new file mode 100644 index 0000000..1b92113 --- /dev/null +++ "b/Week16_\354\230\210\354\212\265\352\263\274\354\240\234_\354\225\210\354\230\210\354\235\200.ipynb" @@ -0,0 +1,1038 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tPIid4tlF7_d", + "outputId": "d452d4a4-84b0-4f29-b4b6-6b57bdebf3f8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using device: cuda\n", + "GPU name: Tesla T4\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(\"Using device:\", device)\n", + "print(\"GPU name:\", torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"CPU\")\n" + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XWk5Ee4zGkQa", + "outputId": "8bf428e4-e239-4161-972f-dfb7f6dce280" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "\n", + "os.listdir(\"/content/drive/MyDrive\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WnimMe19Gt0H", + "outputId": "045884a8-832d-48c8-e194-2e251c1f0b0c" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Week16_예습과제_안예은.ipynb',\n", + " 'Classroom',\n", + " '제목없는 폴더',\n", + " '2020 2학년 2기말 수학2_서술형채점기준표.pdf',\n", + " '2020 2학년 기말 수학2 문항정보표.pdf',\n", + " '2020 2기말 수학2 문제지.pdf',\n", + " '2020학년도 2학기 기말고사 2학년 확률과통계 출제원안.pdf',\n", + " '2020학년도 2학기 기말고사 2학년 확률과통계 서술형채점기준표.pdf',\n", + " '2020학년도 2학기 기말고사 2학년 확률과통계 문항정보표.pdf',\n", + " 'Colab Notebooks',\n", + " 'Untitled0.ipynb',\n", + " 'Untitled1.ipynb',\n", + " 'Chap_4_Intro_to_Python (1).ipynb',\n", + " 'Markdown_Guide (1).ipynb',\n", + " '통계수학_개강_전_과제 (1).ipynb',\n", + " 'Section_1_Matrix_LAB.ipynb',\n", + " 'Section_1_Matrix_HW (3).ipynb',\n", + " 'Sec_3_Linear_system_and_matrix_HW.ipynb',\n", + " '제목 없는 설문지 (1).gform',\n", + " '제목 없는 설문지.gform',\n", + " 'Sec_7_HW_Solution.ipynb',\n", + " 'IMG_1929.jpeg',\n", + " 'test (1).txt',\n", + " 'ArrayStack (1).h',\n", + " '입학허가서_2229014_안예은_입증서류.pdf',\n", + " '입학허가서.pdf',\n", + " '수강예정교과목리스트_2229014_안예은_수강예정 (1).pdf',\n", + " '수강예정교과목리스트.pdf',\n", + " '수강예정교과목리스트_2229014_안예은_수강예정.pdf',\n", + " '개별프로그램 수학서약서_2229014_안예은_서약서.jpeg',\n", + " '방문학생 지원서_2229014_안예은_신청서.jpeg',\n", + " 'freemover 마인츠 메일_2229014_안예은_입증서류.png',\n", + " '옌니의 파리 여행.gdoc',\n", + " '기니예니 독일여행쓰.gdoc',\n", + " '탑건 매버릭 (정식릴) Top Gun Maverick,2022.1080p.KOR.FHDRip.H264.AAC-REEL.mp4',\n", + " '드뎌 혼자가는 옌니의 런던!.gdoc',\n", + " '안&문 의 한달 유럽여행기.gdoc',\n", + " 'IMG_5945.jpeg',\n", + " '10.jpg',\n", + " 'sage 인증사진.png',\n", + " 'Untitled2.ipynb',\n", + " '(01-1) (실습) RISS에서 석박사 학위논문 제목 초록 추출하기 (2).ipynb',\n", + " '(01-2) (실습) RISS에서 국내학술논문 제목 초록 추출하기.ipynb',\n", + " '(01-3) (실습) RISS 학위논문 학술논문 File 통합하기.ipynb',\n", + " '(02-3) (실습) NAVER API Selenium을 이용한 Blog 본문 가져오기.ipynb',\n", + " '(02-1) (실습) Google Play Store Scraper.ipynb',\n", + " '(02-2) (실습) Apple App Store Scraper.ipynb',\n", + " '(03) (실습) 시계열 분석 (Auto-Arima).ipynb',\n", + " 'share.HWP',\n", + " 'Project.pdf',\n", + " 'project2.pdf',\n", + " 'download.pdf',\n", + " '안예은_사진.jpg',\n", + " '안예은_캠.mp4',\n", + " 'Untitled4.ipynb',\n", + " 'content',\n", + " 'POSTECH DSC103 수료증 _ SmartLearn.pdf',\n", + " '안예은-수강증명서.zip',\n", + " '사용자 경험 연구실_안예은.pdf',\n", + " '쿠팡 로켓배송 서비스에 대한 소비자 인식 조사 설문지.gform',\n", + " '안예은_신분증사본,통장사본.zip',\n", + " '최종_데이터분석_프로젝트_안예은_수정본.ipynb',\n", + " '데이터분석_최종_중복제거본.ipynb',\n", + " '데이터분석_프로젝트_최종_export추가.ipynb',\n", + " 'processed_data.csv',\n", + " 'final_df_prepared.csv',\n", + " '융합소프트웨어프로젝트_2229014_통계학과_안예은.ipynb',\n", + " 'IMG_3498.jpeg',\n", + " 'Untitled5.ipynb',\n", + " '250624_디지털직무교육그룹_청년 AI Big Data 아카데미 30기(25년-2차) Big Data 교육일정표.pptx',\n", + " '제목 없는 문서 (2).gdoc',\n", + " '제목 없는 문서 (1).gdoc',\n", + " '빅데이터 2주차.gdoc',\n", + " '인도 교통수단 이용여부.gdoc',\n", + " 'A2조 인도 중고차 시장.ipynb',\n", + " 'A2조_인도_중고차_시장.ipynb',\n", + " 'A2조_인도_중고차_시장1.ipynb',\n", + " 'Untitled6.ipynb',\n", + " '안예은_사진2.jpg',\n", + " 'A2_종합실습1_인도 중고차시장 전략.xlsx',\n", + " 'A2_종합실습1_인도 중고차시장 전략.ipynb',\n", + " 'A2_종합실습2_후판 압연공정.ipynb',\n", + " 'A2_종합실습1_인도 중고차시장 전략.pdf',\n", + " 'A2_종합실습2_후판 압연공정.xlsx',\n", + " 'A2_종합실습2_후판 압연공정.pdf',\n", + " 'A2_빅데이터프로젝트.zip',\n", + " 'Fibo.ipynb',\n", + " 'fibo2.ipynb',\n", + " 'score.ipynb',\n", + " 'race.ipynb',\n", + " 'bisect.ipynb',\n", + " 'race2.ipynb',\n", + " 'binary_search.ipynb',\n", + " 'Untitled7.ipynb',\n", + " 'hacker.ipynb',\n", + " 'Untitled8.ipynb',\n", + " '2_Gradient_descent_학생용.ipynb',\n", + " '제목 없는 문서.gdoc',\n", + " '3_MLP_학생용.ipynb.ipynb',\n", + " '5_CNN_학생용 (1).ipynb',\n", + " '5_CNN_정답.ipynb',\n", + " '6_RNN_학생용.ipynb',\n", + " '6_RNN_정답.ipynb',\n", + " 'Untitled9.ipynb',\n", + " '3_MLP_정답.ipynb.ipynb',\n", + " '1_tutorial.ipynb',\n", + " '2_Gradient_descent_정답.ipynb',\n", + " '보이스피싱(대출사기2).ipynb',\n", + " 'GRU 공부.gdoc',\n", + " 'GRU실험.ipynb',\n", + " 'GRU실험.ipynb의 사본',\n", + " 'Untitled10.ipynb',\n", + " 'backpropagation_quiz (1).ipynb',\n", + " 'c1_남정수_quiz.ipynb',\n", + " 'a2_안예은_quiz.ipynb',\n", + " 'dataset.csv',\n", + " 'bert가보자.ipynb',\n", + " 'bertbert.ipynb',\n", + " 'Untitled11.ipynb',\n", + " 'Untitled12.ipynb',\n", + " 'AIOT과제.gdoc',\n", + " 'kakaocorp kanana‑1.5‑v‑3b‑instruct.ipynb',\n", + " 'Untitled14.ipynb',\n", + " 'Untitled15.ipynb',\n", + " 'Untitled16.ipynb',\n", + " 'Qwen 7B 성공.ipynb',\n", + " 'Qwen 2.5 7B.ipynb',\n", + " 'naver_blog.json',\n", + " 'tokenizing.ipynb',\n", + " 'word_embedding.ipynb',\n", + " 'HowToGenerateWithSLLM.ipynb',\n", + " '모델 성능 비교 샘플 60.ipynb',\n", + " 'gemma_3_4b_it.ipynb',\n", + " 'Qwen2.5-3B-Instruct.ipynb',\n", + " 'Phi-3.5-mini-instruct.ipynb',\n", + " 'chap02',\n", + " 'colab_2장.ipynb',\n", + " 'Week1_예습과제_안예은.ipynb',\n", + " 'CV_이화여자대학교_안예은 (3).pdf',\n", + " '성적표 (2).pdf',\n", + " 'sample_submission.csv',\n", + " 'Week1_복습과제_안예은.ipynb',\n", + " 'numpy기초.ipynb',\n", + " 'pandas기초.ipynb',\n", + " '통계프로그래밍_과제1_2229014안예은.ipynb',\n", + " 'Gradient_Descent_1_2229014_안예은.ipynb',\n", + " 'Week2_복습과제_안예은.ipynb',\n", + " 'Week3_예습과제_안예은.ipynb',\n", + " 'car_feature.jpg',\n", + " 'Week3_복습과제_안예은.ipynb',\n", + " 'Week4_예습과제_안예은.ipynb',\n", + " 'Untitled18.ipynb',\n", + " 'CV_이화여자대학교_안예은.pdf',\n", + " '성적표.pdf',\n", + " 'Week4_복습과제_안예은.ipynb',\n", + " 'Week5_예습과제_안예은.ipynb',\n", + " '통계프로그래밍_과제2_2229014안예은.ipynb',\n", + " 'share 2',\n", + " 'share',\n", + " 'Untitled19.ipynb',\n", + " 'Week5_복습과제_안예은.ipynb',\n", + " 'Untitled20.ipynb',\n", + " '기계학습개론_2229014_안예은.ipynb',\n", + " 'OIBC_2025_DATA.gz',\n", + " 'Untitled21.ipynb',\n", + " '통계프로그래밍_과제3_2229014안예은.ipynb',\n", + " '통계프로그래밍_과제4_2229014안예은',\n", + " '강북데분 전반기 스터디 발표 자료.pdf',\n", + " '이화여자대학교 통계학과 3학년 안예은_포항공대 산업경영공학과 인턴십 지원서.pdf',\n", + " 'CV_이화여자대학교_안예은 (1).pdf',\n", + " '성적표 (1).pdf',\n", + " 'Week6_복습과제_안예은.ipynb',\n", + " 'Week9_예습과제_안예은',\n", + " 'Untitled22.ipynb',\n", + " 'submission_sample.csv',\n", + " '63.39.ipynb',\n", + " 'Untitled3.ipynb',\n", + " 'HW#5_2229014_안예은_코드.ipynb',\n", + " 'test.jpg',\n", + " 'Week10_예습과제_안예은',\n", + " 'Week9_복습과제_안예은.ipynb',\n", + " 'test.csv',\n", + " 'train.csv',\n", + " 'Untitled13.ipynb',\n", + " 'Untitled17.ipynb',\n", + " 'tabmlp_best_20251113_112829.pt',\n", + " 'kaggle_authors.csv',\n", + " 'All_English_Stopwords.txt',\n", + " 'papers.csv',\n", + " 'Week10_복습과제_안예은.ipynb',\n", + " 'Week11_예습과제_안예은.ipynb',\n", + " 'CV_이화여자대학교_안예은 (2).pdf',\n", + " '12주차 실습과제_2229014_통계학과_안예은.ipynb',\n", + " '9기 DL세션 12주차 2팀 발표자료_B,C파트 완성.pptx',\n", + " 'Week11_복습과제_안예은.ipynb',\n", + " 'glm_poisson_logistic_student_version (7).ipynb',\n", + " 'Week12_복습과제_안예은.ipynb',\n", + " 'Week15_예습과제_안예은 (1).ipynb',\n", + " 'Week15_예습과제_안예은.ipynb',\n", + " 'archive.zip']" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import zipfile\n", + "import os\n", + "\n", + "zip_path = \"/content/drive/MyDrive/archive.zip\"\n", + "extract_path = \"/content/archive\"\n", + "\n", + "with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n", + " zip_ref.extractall(extract_path)\n", + "\n", + "print(\"Extracted files:\")\n", + "print(os.listdir(extract_path))\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ljbaeo3EGVy_", + "outputId": "e2855029-d441-40bd-ffff-3432f03cc6a9" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracted files:\n", + "['train', 'test']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "for root, dirs, files in os.walk(\"/content/archive\"):\n", + " print(root)\n", + " print(\"dirs:\", dirs)\n", + " print(\"files:\", files)\n", + " break\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2IFRBST-GYho", + "outputId": "d41c0dd4-59bc-41dc-996c-93cd73370887" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/archive\n", + "dirs: ['train', 'test']\n", + "files: []\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "from torchvision import models, transforms, datasets\n", + "from torch.utils.data import DataLoader\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from tqdm import tqdm\n", + "import time\n" + ], + "metadata": { + "id": "4z259dQVHFJ8" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(\"Using device:\", device)\n", + "print(\"GPU:\", torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"CPU\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mLoFNhB6HH7q", + "outputId": "b19706e7-b88b-426a-8537-41b9bf413da3" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using device: cuda\n", + "GPU: Tesla T4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "train_transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.RandomVerticalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(\n", + " mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]\n", + " )\n", + "])\n", + "\n", + "val_transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(\n", + " mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]\n", + " )\n", + "])\n" + ], + "metadata": { + "id": "6qFQ4fnKHKTn" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "train_dataset = datasets.ImageFolder(\n", + " root=\"/content/archive/train\",\n", + " transform=train_transform\n", + ")\n", + "\n", + "val_dataset = datasets.ImageFolder(\n", + " root=\"/content/archive/test\",\n", + " transform=val_transform\n", + ")\n", + "\n", + "train_loader = DataLoader(\n", + " train_dataset,\n", + " batch_size=32,\n", + " shuffle=True,\n", + " num_workers=2,\n", + " pin_memory=True\n", + ")\n", + "\n", + "val_loader = DataLoader(\n", + " val_dataset,\n", + " batch_size=32,\n", + " shuffle=False,\n", + " num_workers=2,\n", + " pin_memory=True\n", + ")\n", + "\n", + "print(\"Classes:\", train_dataset.classes)\n", + "print(\"Train size:\", len(train_dataset))\n", + "print(\"Val size:\", len(val_dataset))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FY5BjBdeHLwH", + "outputId": "b2e49e24-e5cf-47ca-f9a9-912b189af089" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Classes: ['hot_dog', 'not_hot_dog']\n", + "Train size: 498\n", + "Val size: 500\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "model = models.resnet50(pretrained=True)\n", + "model.fc = nn.Linear(2048, 2) # 이진 분류\n", + "model = model.to(device)\n", + "\n", + "total_params = sum(p.numel() for p in model.parameters())\n", + "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "\n", + "print(f\"Total params: {total_params:,}\")\n", + "print(f\"Trainable params: {trainable_params:,}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p-5D5w6pHNgU", + "outputId": "b17c9b9e-d44f-460c-b290-bbafdba209dd" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 97.8M/97.8M [00:00<00:00, 134MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Total params: 23,512,130\n", + "Trainable params: 23,512,130\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "epochs = 100\n" + ], + "metadata": { + "id": "tEEUNRqbHO5v" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "class EarlyStopping:\n", + " def __init__(self, patience=5, delta=0, path=\"checkpoint.pt\"):\n", + " self.patience = patience\n", + " self.delta = delta\n", + " self.path = path\n", + " self.counter = 0\n", + " self.best_score = None\n", + " self.early_stop = False\n", + " self.val_loss_min = float(\"inf\")\n", + "\n", + " def __call__(self, val_loss, model):\n", + " score = -val_loss\n", + "\n", + " if self.best_score is None:\n", + " self.best_score = score\n", + " self.save_checkpoint(val_loss, model)\n", + " elif score < self.best_score + self.delta:\n", + " self.counter += 1\n", + " print(f\"EarlyStopping counter: {self.counter}/{self.patience}\")\n", + " if self.counter >= self.patience:\n", + " self.early_stop = True\n", + " else:\n", + " self.best_score = score\n", + " self.save_checkpoint(val_loss, model)\n", + " self.counter = 0\n", + "\n", + " def save_checkpoint(self, val_loss, model):\n", + " torch.save(model.state_dict(), self.path)\n", + " self.val_loss_min = val_loss\n" + ], + "metadata": { + "id": "HBFpe3xEHQee" + }, + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def train_one_epoch(model, loader):\n", + " model.train()\n", + " running_loss = 0.0\n", + " correct = 0\n", + " total = 0\n", + "\n", + " for x, y in tqdm(loader):\n", + " x = x.to(device, non_blocking=True)\n", + " y = y.to(device, non_blocking=True)\n", + "\n", + " optimizer.zero_grad()\n", + " outputs = model(x)\n", + " loss = criterion(outputs, y)\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + " _, preds = torch.max(outputs, 1)\n", + " correct += (preds == y).sum().item()\n", + " total += y.size(0)\n", + "\n", + " return running_loss / len(loader), 100 * correct / total\n" + ], + "metadata": { + "id": "mAtbzWVuHR9C" + }, + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def validate(model, loader):\n", + " model.eval()\n", + " running_loss = 0.0\n", + " correct = 0\n", + " total = 0\n", + "\n", + " with torch.no_grad():\n", + " for x, y in tqdm(loader):\n", + " x = x.to(device, non_blocking=True)\n", + " y = y.to(device, non_blocking=True)\n", + "\n", + " outputs = model(x)\n", + " loss = criterion(outputs, y)\n", + "\n", + " running_loss += loss.item()\n", + " _, preds = torch.max(outputs, 1)\n", + " correct += (preds == y).sum().item()\n", + " total += y.size(0)\n", + "\n", + " return running_loss / len(loader), 100 * correct / total\n" + ], + "metadata": { + "id": "rypDxFK6HTTc" + }, + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "early_stopping = EarlyStopping(patience=5)\n", + "\n", + "train_losses, val_losses = [], []\n", + "train_accs, val_accs = [], []\n", + "\n", + "start_time = time.time()\n", + "\n", + "for epoch in range(epochs):\n", + " print(f\"\\nEpoch [{epoch+1}/{epochs}]\")\n", + "\n", + " train_loss, train_acc = train_one_epoch(model, train_loader)\n", + " val_loss, val_acc = validate(model, val_loader)\n", + "\n", + " train_losses.append(train_loss)\n", + " val_losses.append(val_loss)\n", + " train_accs.append(train_acc)\n", + " val_accs.append(val_acc)\n", + "\n", + " print(f\"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}%\")\n", + " print(f\"Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.2f}%\")\n", + "\n", + " early_stopping(val_loss, model)\n", + " if early_stopping.early_stop:\n", + " print(\"Early stopping triggered\")\n", + " break\n", + "\n", + "end_time = time.time()\n", + "print(f\"Training time: {(end_time - start_time)/60:.2f} minutes\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XMTrXlJVHUkV", + "outputId": "f7bca499-4a43-478b-ddde-4310ec991939" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Epoch [1/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:06<00:00, 2.36it/s]\n", + "100%|██████████| 16/16 [00:03<00:00, 4.93it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.6556 | Train Acc: 71.08%\n", + "Val Loss: 20.9153 | Val Acc: 38.00%\n", + "\n", + "Epoch [2/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.19it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.01it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.5698 | Train Acc: 73.29%\n", + "Val Loss: 0.9917 | Val Acc: 57.00%\n", + "\n", + "Epoch [3/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:04<00:00, 3.23it/s]\n", + "100%|██████████| 16/16 [00:03<00:00, 4.55it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.4785 | Train Acc: 76.91%\n", + "Val Loss: 7.5350 | Val Acc: 55.00%\n", + "EarlyStopping counter: 1/5\n", + "\n", + "Epoch [4/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:04<00:00, 3.25it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.78it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.4384 | Train Acc: 80.32%\n", + "Val Loss: 0.6574 | Val Acc: 67.00%\n", + "\n", + "Epoch [5/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.18it/s]\n", + "100%|██████████| 16/16 [00:03<00:00, 5.14it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.3844 | Train Acc: 83.13%\n", + "Val Loss: 0.7276 | Val Acc: 74.80%\n", + "EarlyStopping counter: 1/5\n", + "\n", + "Epoch [6/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.19it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.76it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.3318 | Train Acc: 87.35%\n", + "Val Loss: 1.2309 | Val Acc: 69.00%\n", + "EarlyStopping counter: 2/5\n", + "\n", + "Epoch [7/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 2.96it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 7.09it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.3199 | Train Acc: 85.94%\n", + "Val Loss: 0.8005 | Val Acc: 69.80%\n", + "EarlyStopping counter: 3/5\n", + "\n", + "Epoch [8/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.14it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.38it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.3747 | Train Acc: 83.53%\n", + "Val Loss: 0.6036 | Val Acc: 75.00%\n", + "\n", + "Epoch [9/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.04it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 7.09it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.3137 | Train Acc: 85.34%\n", + "Val Loss: 0.6874 | Val Acc: 77.80%\n", + "EarlyStopping counter: 1/5\n", + "\n", + "Epoch [10/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.08it/s]\n", + "100%|██████████| 16/16 [00:04<00:00, 3.45it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.2804 | Train Acc: 88.96%\n", + "Val Loss: 5.7902 | Val Acc: 51.40%\n", + "EarlyStopping counter: 2/5\n", + "\n", + "Epoch [11/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 3.03it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.79it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.3374 | Train Acc: 86.55%\n", + "Val Loss: 1.1042 | Val Acc: 63.40%\n", + "EarlyStopping counter: 3/5\n", + "\n", + "Epoch [12/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 2.92it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.83it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.2140 | Train Acc: 91.57%\n", + "Val Loss: 0.6565 | Val Acc: 75.00%\n", + "EarlyStopping counter: 4/5\n", + "\n", + "Epoch [13/100]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 16/16 [00:05<00:00, 2.88it/s]\n", + "100%|██████████| 16/16 [00:02<00:00, 6.33it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Loss: 0.1978 | Train Acc: 92.57%\n", + "Val Loss: 0.7710 | Val Acc: 79.40%\n", + "EarlyStopping counter: 5/5\n", + "Early stopping triggered\n", + "Training time: 1.77 minutes\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(12,4))\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.plot(train_accs, label=\"Train Acc\")\n", + "plt.plot(val_accs, label=\"Val Acc\")\n", + "plt.legend()\n", + "plt.title(\"Accuracy\")\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.plot(train_losses, label=\"Train Loss\")\n", + "plt.plot(val_losses, label=\"Val Loss\")\n", + "plt.legend()\n", + "plt.title(\"Loss\")\n", + "\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 235 + }, + "id": "n2M_mO0UHVzg", + "outputId": "606c87af-b45b-4006-93bf-ff1d67266c7b" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9EAAAF2CAYAAABpthsMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlrxJREFUeJzs3Xd8VFX6x/HPpPeEkkIgoUPoSBGRIk0BFVFQwLL2taErYllZG1ZW/dnXti5iQ7EhYheRonRQeq8JhISaBEJ67u+Pk5kQaSmT3Ezyfb9e87pn7r1z55kkMPPMOec5DsuyLERERERERETkjLzsDkBERERERETEUyiJFhERERERESklJdEiIiIiIiIipaQkWkRERERERKSUlESLiIiIiIiIlJKSaBEREREREZFSUhItIiIiIiIiUkpKokVERERERERKSUm0iIiIiIiISCkpiRYREREREREpJSXRIpXkjTfewOFw0KNHD7tDERERkWrqvffew+FwsHz5crtDEZFSUhItUkmmTp1KkyZNWLp0KVu3brU7HBERERERcQMl0SKVYMeOHSxcuJAXX3yRyMhIpk6dandIJ5WZmWl3CCIiIiIiHkVJtEglmDp1KnXq1OGiiy7i8ssvP2kSnZaWxj333EOTJk3w9/enUaNGXHvttRw4cMB1TnZ2NhMnTqRVq1YEBATQoEEDRowYwbZt2wCYO3cuDoeDuXPnlrj2zp07cTgcvPfee659119/PSEhIWzbto0LL7yQ0NBQrr76agB+++03rrjiCuLj4/H39ycuLo577rmHrKysE+LeuHEjo0aNIjIyksDAQFq3bs1DDz0EwJw5c3A4HHz11VcnPO7jjz/G4XCwaNGiMv88RUREarM///yToUOHEhYWRkhICAMHDmTx4sUlzsnLy+Pxxx+nZcuWBAQEUK9ePXr37s2sWbNc56SkpHDDDTfQqFEj/P39adCgAcOHD2fnzp1V/IpEPJuP3QGI1ERTp05lxIgR+Pn5ceWVV/Lmm2+ybNkyunfvDsDRo0fp06cPGzZs4MYbb6RLly4cOHCAmTNnsnv3burXr09BQQEXX3wxs2fPZsyYMdx9990cOXKEWbNmsXbtWpo3b17muPLz8xk8eDC9e/fm//7v/wgKCgLg888/59ixY9x+++3Uq1ePpUuX8tprr7F7924+//xz1+NXr15Nnz598PX15ZZbbqFJkyZs27aNb775hqeffpp+/foRFxfH1KlTueyyy074mTRv3pyePXtW4CcrIiJSu6xbt44+ffoQFhbGAw88gK+vL2+//Tb9+vVj3rx5rtorEydOZNKkSdx8882cffbZZGRksHz5cv744w/OP/98AEaOHMm6deu46667aNKkCfv27WPWrFkkJibSpEkTG1+liIexRMStli9fbgHWrFmzLMuyrMLCQqtRo0bW3Xff7Trn0UcftQBr+vTpJzy+sLDQsizLevfddy3AevHFF095zpw5cyzAmjNnTonjO3bssABrypQprn3XXXedBVgPPvjgCdc7duzYCfsmTZpkORwOa9euXa59ffv2tUJDQ0vsOz4ey7KsCRMmWP7+/lZaWppr3759+ywfHx/rscceO+F5REREarMpU6ZYgLVs2bKTHr/00kstPz8/a9u2ba59ycnJVmhoqNW3b1/Xvk6dOlkXXXTRKZ/n8OHDFmA9//zz7gtepJbScG4RN5s6dSrR0dH0798fAIfDwejRo5k2bRoFBQUAfPnll3Tq1OmE3lrn+c5z6tevz1133XXKc8rj9ttvP2FfYGCgq52ZmcmBAwc499xzsSyLP//8E4D9+/czf/58brzxRuLj408Zz7XXXktOTg5ffPGFa9+nn35Kfn4+11xzTbnjFhERqW0KCgr4+eefufTSS2nWrJlrf4MGDbjqqqv4/fffycjIACAiIoJ169axZcuWk14rMDAQPz8/5s6dy+HDh6skfpGaSkm0iBsVFBQwbdo0+vfvz44dO9i6dStbt26lR48epKamMnv2bAC2bdtG+/btT3utbdu20bp1a3x83DfrwsfHh0aNGp2wPzExkeuvv566desSEhJCZGQk5513HgDp6ekAbN++HeCMcSckJNC9e/cS88CnTp3KOeecQ4sWLdz1UkRERGq8/fv3c+zYMVq3bn3CsTZt2lBYWEhSUhIATzzxBGlpabRq1YoOHTpw//33s3r1atf5/v7+PPvss/zwww9ER0fTt29fnnvuOVJSUqrs9YjUFEqiRdzo119/Ze/evUybNo2WLVu6bqNGjQJwe5XuU/VIO3u8/8rf3x8vL68Tzj3//PP57rvv+Oc//8mMGTOYNWuWqyhZYWFhmeO69tprmTdvHrt372bbtm0sXrxYvdAiIiKVqG/fvmzbto13332X9u3b87///Y8uXbrwv//9z3XOuHHj2Lx5M5MmTSIgIIBHHnmENm3auEadiUjpqLCYiBtNnTqVqKgoXn/99ROOTZ8+na+++oq33nqL5s2bs3bt2tNeq3nz5ixZsoS8vDx8fX1Pek6dOnUAU+n7eLt27Sp1zGvWrGHz5s28//77XHvtta79x1fzBFzDyM4UN8CYMWMYP348n3zyCVlZWfj6+jJ69OhSxyQiIiIQGRlJUFAQmzZtOuHYxo0b8fLyIi4uzrWvbt263HDDDdxwww0cPXqUvn37MnHiRG6++WbXOc2bN+fee+/l3nvvZcuWLXTu3JkXXniBjz76qEpek0hNoJ5oETfJyspi+vTpXHzxxVx++eUn3O68806OHDnCzJkzGTlyJKtWrTrpUlCWZQGmguaBAwf4z3/+c8pzGjdujLe3N/Pnzy9x/I033ih13N7e3iWu6Wy/8sorJc6LjIykb9++vPvuuyQmJp40Hqf69eszdOhQPvroI6ZOncqQIUOoX79+qWMSERER8x59wQUX8PXXX5dYhio1NZWPP/6Y3r17ExYWBsDBgwdLPDYkJIQWLVqQk5MDwLFjx8jOzi5xTvPmzQkNDXWdIyKlo55oETeZOXMmR44c4ZJLLjnp8XPOOYfIyEimTp3Kxx9/zBdffMEVV1zBjTfeSNeuXTl06BAzZ87krbfeolOnTlx77bV88MEHjB8/nqVLl9KnTx8yMzP55ZdfuOOOOxg+fDjh4eFcccUVvPbaazgcDpo3b863337Lvn37Sh13QkICzZs357777mPPnj2EhYXx5ZdfnrToyKuvvkrv3r3p0qULt9xyC02bNmXnzp189913rFy5ssS51157LZdffjkATz75ZOl/kCIiIrXQu+++y48//njC/okTJzJr1ix69+7NHXfcgY+PD2+//TY5OTk899xzrvPatm1Lv3796Nq1K3Xr1mX58uV88cUX3HnnnQBs3ryZgQMHMmrUKNq2bYuPjw9fffUVqampjBkzpspep0iNYGdpcJGaZNiwYVZAQICVmZl5ynOuv/56y9fX1zpw4IB18OBB684777QaNmxo+fn5WY0aNbKuu+4668CBA67zjx07Zj300ENW06ZNLV9fXysmJsa6/PLLSyxzsX//fmvkyJFWUFCQVadOHevWW2+11q5de9IlroKDg08a1/r1661BgwZZISEhVv369a2///3v1qpVq064hmVZ1tq1a63LLrvMioiIsAICAqzWrVtbjzzyyAnXzMnJserUqWOFh4dbWVlZpfwpioiI1C7OJa5OdUtKSrL++OMPa/DgwVZISIgVFBRk9e/f31q4cGGJ6zz11FPW2WefbUVERFiBgYFWQkKC9fTTT1u5ubmWZVnWgQMHrLFjx1oJCQlWcHCwFR4ebvXo0cP67LPP7HjZIh7NYVl/GYcpIuIG+fn5xMbGMmzYMCZPnmx3OCIiIiIibqE50SJSKWbMmMH+/ftLFCsTEREREfF06okWEbdasmQJq1ev5sknn6R+/fr88ccfdockIiIiIuI26okWEbd68803uf3224mKiuKDDz6wOxwREREREbdST7SIiIiIiIhIKaknWkRERERERKSUlESLiIiIiIiIlJKP3QH8VWFhIcnJyYSGhuJwOOwOR0REBMuyOHLkCLGxsXh56ftnd9D7vYiIVCdlea+vdkl0cnIycXFxdochIiJygqSkJBo1amR3GDWC3u9FRKQ6Ks17fbVLokNDQwETfFhYmM3RiIiIQEZGBnFxca73KKk4vd+LiEh1Upb3+mqXRDuHdIWFhelNVUREqhUNO3Yfvd+LiEh1VJr3ek3sEhERERERESklJdEiIiIiIiIipaQkWkRERERERKSUqt2c6NIqKCggLy/P7jCkDHx9ffH29rY7DBERERGRUlPeUXP4+fm5ZalKj0uiLcsiJSWFtLQ0u0ORcoiIiCAmJkbFeURERESkWlPeUfN4eXnRtGlT/Pz8KnQdj0uinX/IUVFRBAUFKRnzEJZlcezYMfbt2wdAgwYNbI5IREREROTUlHfULIWFhSQnJ7N3717i4+Mr9Pv0qCS6oKDA9Ydcr149u8ORMgoMDARg3759REVFaWi3iIiIiFRLyjtqpsjISJKTk8nPz8fX17fc1/GowmLOuQhBQUE2RyLl5fzdaV6JiIiIiFRXyjtqJucw7oKCggpdx6OSaCcNpfBc+t2JiIiIiKfQZ9eaxV2/T49MokVERERERETsoCTagzVp0oSXX37Z7jBERKqFg0dzWLL9IFOX7OLxb9bxt8lLuPn95XaHJZVt7yp4/xL49G92RyIiUmMp7yjJowqLeaozDRt47LHHmDhxYpmvu2zZMoKDg8sZVUmffPIJ11xzDbfddhuvv/66W64pIuJulmWRnJ7N1n1HXbdt+46yZd8RDh87sdZCsJ83lmVpOF5Nt2MeBEfaHYWIiO2qc97Rr18/OnfuXCOScSXRVWDv3r2u9qeffsqjjz7Kpk2bXPtCQkJcbcuyKCgowMfnzL+ayEj3fWCYPHkyDzzwAG+//TYvvPACAQEBbru2iEhZ5RcUknjoGFuOS5S37jfbzNxTFwNpVCeQFlEhtIgMMduoECwLlEPXYOFxZpu5H/KywDfQ3nhERGzkCXlHTaDh3FUgJibGdQsPD8fhcLjub9y4kdDQUH744Qe6du2Kv78/v//+O9u2bWP48OFER0cTEhJC9+7d+eWXX0pc96/DKhwOB//73/+47LLLCAoKomXLlsycOfOM8e3YsYOFCxfy4IMP0qpVK6ZPn37COe+++y7t2rXD39+fBg0acOedd7qOpaWlceuttxIdHU1AQADt27fn22+/Lf8PTERqjey8AtYnZzBzVTIv/ryJO6au4IKX5tH20Z8Y8MI8bv1wBc//tInpf+5h9e50MnML8PFy0DwymCHtYrizfwteHt2Zb+/qzfonBvP7Pwfw3g1n8/DFbRlzdjzdmtTFy0sZdI0WWAd8i3pH0vfYG4uIiM2qe95xOl9++aUr32jSpAkvvPBCieNvvPEGLVu2JCAggOjoaC6//HLXsS+++IIOHToQGBhIvXr1GDRoEJmZmRWK53Q8vifasiyy8ipWory8An293TZE8MEHH+T//u//aNasGXXq1CEpKYkLL7yQp59+Gn9/fz744AOGDRvGpk2biI+PP+V1Hn/8cZ577jmef/55XnvtNa6++mp27dpF3bp1T/mYKVOmcNFFFxEeHs4111zD5MmTueqqq1zH33zzTcaPH8+///1vhg4dSnp6OgsWLADMouVDhw7lyJEjfPTRRzRv3pz169drDWgRKSEjO+8vw69NO+nwMSzr5I8J8PWieWQILaOKe5VbRIXQuF4wvt76DliKOBwQ3ggObIL0JKjfwu6IRKSGUt5RUnnyjlNZsWIFo0aNYuLEiYwePZqFCxdyxx13UK9ePa6//nqWL1/OP/7xDz788EPOPfdcDh06xG+//QaY3vcrr7yS5557jssuu4wjR47w22+/YZ3qA4YbeHwSnZVXQNtHf7Lludc/MZggP/f8CJ944gnOP/981/26devSqVMn1/0nn3ySr776ipkzZ5boBf6r66+/niuvvBKAZ555hldffZWlS5cyZMiQk55fWFjIe++9x2uvvQbAmDFjuPfee9mxYwdNmzYF4KmnnuLee+/l7rvvdj2ue/fuAPzyyy8sXbqUDRs20KpVKwCaNWtWnh+BiNQg2XkFvDF3Gyt2HWLrvqOkZuSc8tzwQF9aRBUny82LhmM3jAhUL7KUTkRcURK92+5IRKQGU95RUlnzjtN58cUXGThwII888ggArVq1Yv369Tz//PNcf/31JCYmEhwczMUXX0xoaCiNGzfmrLPOAkwSnZ+fz4gRI2jcuDEAHTp0KHMMZeHxSXRN0a1btxL3jx49ysSJE/nuu+9cfxhZWVkkJiae9jodO3Z0tYODgwkLC2Pfvn2nPH/WrFlkZmZy4YUXAlC/fn3OP/983n33XZ588kn27dtHcnIyAwcOPOnjV65cSaNGjVwJtIjInrQsbv1wOWv3ZJTYHx3mXzxfOTrUNW+5foifCn9JxYQ3Mtv0JHvjEBHxAHblHaezYcMGhg8fXmJfr169ePnllykoKOD888+ncePGNGvWjCFDhjBkyBDXUPJOnToxcOBAOnTowODBg7ngggu4/PLLqVOnTrliKQ2PT6IDfb1Z/8Rg257bXf5a7e6+++5j1qxZ/N///R8tWrQgMDCQyy+/nNzc3NNex9fXt8R9h8NBYWHhKc+fPHkyhw4dIjCwuBBLYWEhq1ev5vHHHy+x/2TOdFxEapdF2w4y9uM/OJSZS91gP+69oBVtG4TRPCqEsADfM19ApDxcSbR6okWk8ijvKKmseUdFhIaG8scffzB37lx+/vlnHn30USZOnMiyZcuIiIhg1qxZLFy4kJ9//pnXXnuNhx56iCVLlrhG1rqbxyfRDofDbUMbqpMFCxZw/fXXc9lllwHmG6KdO3e69TkOHjzI119/zbRp02jXrp1rf0FBAb179+bnn39myJAhNGnShNmzZ9O/f/8TrtGxY0d2797N5s2b1RstUotZlsUHi3bxxLfrKSi0aBcbxtt/60qjOkF2hya1QXjRnL200/eaiIhUhPKOytOmTRtXzaXj42rVqpWr1pKPjw+DBg1i0KBBPPbYY0RERPDrr78yYsQIHA4HvXr1olevXjz66KM0btyYr776ivHjx1dKvDXvr6CGaNmyJdOnT2fYsGE4HA4eeeQRt3+z8+GHH1KvXj1GjRp1wlDKCy+8kMmTJzNkyBAmTpzIbbfdRlRUlKuI2IIFC7jrrrs477zz6Nu3LyNHjuTFF1+kRYsWbNy4EYfDUa75ECLiebLzCnhkxlo+X2F6AS/tHMukER0J9FOBQU80adIkpk+fzsaNGwkMDOTcc8/l2WefpXXr1q5zsrOzuffee5k2bRo5OTkMHjyYN954g+joaHuCVk+0iEi5VUXe4bR//35WrlxZYl+DBg2499576d69O08++SSjR49m0aJF/Oc//+GNN94A4Ntvv2X79u307duXOnXq8P3331NYWEjr1q1ZsmQJs2fP5oILLiAqKoolS5awf/9+2rRpUymvAcqxxNWRI0cYN24cjRs3dr25Llu2zHXcsiweffRRGjRoQGBgIIMGDWLLli1uDbo2ePHFF6lTpw7nnnsuw4YNY/DgwXTp0sWtz/Huu+9y2WWXnXQu4siRI5k5cyYHDhzguuuu4+WXX+aNN96gXbt2XHzxxSV+p19++SXdu3fnyiuvpG3btjzwwAMUFNhTuVBEqtbe9CxG/3cxn6/YjZcDHr6oDS+N7qwE2oPNmzePsWPHsnjxYmbNmkVeXh4XXHBBiaVC7rnnHr755hs+//xz5s2bR3JyMiNGjLAv6IiitaIz9kAlffATEampqiLvcPr4448566yzStzeeecdunTpwmeffca0adNo3749jz76KE888QTXX389ABEREUyfPp0BAwbQpk0b3nrrLT755BPatWtHWFgY8+fP58ILL6RVq1Y8/PDDvPDCCwwdOrRSXgOAwypj7e/Ro0ezdu1a3nzzTWJjY/noo4946aWXWL9+PQ0bNuTZZ59l0qRJvP/++zRt2pRHHnmENWvWsH79egICAs54/YyMDMLDw0lPTycsLKzEsezsbFfV6NJcS6of/Q5Fao7lOw9x20d/cOBoDhFBvvznyi70blnf7rAqxenem2q6/fv3ExUVxbx58+jbty/p6elERkby8ccfu9bo3LhxI23atGHRokWcc845pbquW3+mBXnwVBRYhXDvJgiNqdj1RKTW02fWmul0v9eyvC+VqSc6KyuLL7/8kueee46+ffvSokULJk6cSIsWLXjzzTexLIuXX36Zhx9+mOHDh9OxY0c++OADkpOTmTFjRplfpIiIVE9Tl+ziyncWc+BoDgkxocwc27vGJtC1XXp6OoBr3c8VK1aQl5fHoEGDXOckJCQQHx/PokWLbIkRb18IjTXtNFXoFhGRylWmJDo/P5+CgoITsvbAwEB+//13duzYQUpKSok31vDwcHr06HHKN9acnBwyMjJK3EREpHrKyS9gwvQ1PPTVWvIKLC7q2IDpd5xLfD0VEKuJCgsLGTduHL169aJ9+/YApKSk4OfnR0RERIlzo6OjSUlJOeW1Kv39XstciYhIFSlTEh0aGkrPnj158sknSU5OpqCggI8++ohFixaxd+9e15vnXwuLnO6NddKkSYSHh7tucXFx5XwpIiJSmfZlZHPVO0v4ZGkiDgf8c0gC/7nyrBpZqVSMsWPHsnbtWqZNm1bha1X6+71zXrSSaBERqWRlLiz24YcfYlkWDRs2xN/fn1dffZUrr7wSL68yXwqACRMmkJ6e7rolJenNT0Skuvkz8TDD/vM7K3YdJjTAh3ev787t/ZqftDCh1Ax33nkn3377LXPmzKFRo0au/TExMeTm5pKWllbi/NTUVGJiTj0XudLf71WhW0REqkiZM9/mzZszb948jh49SlJSEkuXLiUvL49mzZq53jxTU1NLPOZ0b6z+/v6EhYWVuImISPXx2fIkRr+9mNSMHFpGhTDzzt70bx1ld1hSSSzL4s477+Srr77i119/pWnTpiWOd+3aFV9fX2bPnu3at2nTJhITE+nZs+cpr1vp7/dKokVEpIqUewxecHAwwcHBHD58mJ9++onnnnuOpk2bEhMTw+zZs+ncuTNgqpwtWbKE22+/3V0xi4hIFcgrKOTJb9fzwaJdAFzQNpoXR3cmxF/Dt2uysWPH8vHHH/P1118TGhrqmo4VHh5OYGAg4eHh3HTTTYwfP566desSFhbGXXfdRc+ePUtdmbtShMebrQqLiYhIJSvzJ6GffvoJy7Jo3bo1W7du5f777ychIYEbbrgBh8PBuHHjeOqpp2jZsqVriavY2FguvfTSSghfRKT6OnA0B38fL0IDfO0OpcwOHM3hjql/sHTHIQDGn9+KO/u3wMtLw7drujfffBOAfv36ldg/ZcoU13qdL730El5eXowcOZKcnBwGDx7MG2+8UcWR/oUKi4mISBUpcxKdnp7OhAkT2L17N3Xr1mXkyJE8/fTT+PqaD4kPPPAAmZmZ3HLLLaSlpdG7d29+/PFHra8mIrXG3vQsnv1hIzNWJhPg68WF7RswqnscPZrW9Yg5xGt2p3Prh8tJTs8mxN+Hl0Z35vy20Wd+oNQIlmWd8ZyAgABef/11Xn/99SqIqJScSXR2GuQcAf9QW8MREZGaq8xJ9KhRoxg1atQpjzscDp544gmeeOKJCgUmIuJpsvMK+N9v23l9zjay8gqK9hUy/c89TP9zD43rBTGqWxwjuzQiJrx6frE4/Y/dTJi+hpz8QprVD+a/13ajRVSI3WGJnFlAGASEQ3a6mRcd1cbuiEREpIbSxDYP0q9fPzp37szLL79sdygichzLsvhxbQpPf7+B3YezAOjauA6PDWtLfqHFZ8uS+GZVMrsOHuP5nzbxws+b6Nc6ilHd4hjYJgpf7/KtbuBO+QWFTPphI5N/3wHAgIQoXh7TmTAPHIoutVh4PGSvMfOilUSLiJSb8o7Ts/+TWy0wbNgwhgwZctJjv/32Gw6Hg9WrV7vt+bKysqhbty7169cnJyfHbdcVkRNt2JvBVe8s4fapf7D7cBYxYQG8MqYzX9zWk46NIugSX4d/j+zI0ocG8fzlHenepA6FFvy6cR+3fbSCnpNm8/R369m674htr+FQZi7XvrvUlUDfNaAF/7u2mxJo8TyaFy0itVxV5R3vvfceERERFb6Op1JPdBW46aabGDlyJLt37y6x1iaYQi3dunWjY8eObnu+L7/8knbt2mFZFjNmzGD06NFuu7aIGIcyc3lx1iY+XpJIoQX+Pl7c2rcZt/VrTpDfif+1Bvv7cEW3OK7oFse2/Uf5bHkSX67Yw4GjObzz2w7e+W0HXeIjGN09jos6xlZZBez1yRnc8uFydh/OIsjPmxdHdWJI+wZV8twibhcRZ7ZKokWklqrqvKO2Uk90Fbj44ouJjIzkvffeK7H/6NGjfP7559x0000cPHiQK6+8koYNGxIUFESHDh345JNPyvV8kydP5pprruGaa65h8uTJJxxft24dF198MWFhYYSGhtKnTx+2bdvmOv7uu+/Srl07/P39adCgAXfeeWe54hCpifIKCpmyYAf9np/DR4tNAn1Rhwb8Mv48xl/Q+qQJ9F81jwxhwtA2LJowgP/+rSuD2kTh7eXgj8Q0/vnlGs5++hce+GIVK3YdKlWRp/L6ZlUyI95cwO7DWTSuF8RXd/RSAi2eTWtFi0gtV9V5x6kkJiYyfPhwQkJCCAsLY9SoUaSmprqOr1q1iv79+xMaGkpYWBhdu3Zl+fLlAOzatYthw4ZRp04dgoODadeuHd9//71b46soz++JtizIO2bPc/sGQSkq7fr4+HDttdfy3nvv8dBDD7mq837++ecUFBRw5ZVXcvToUbp27co///lPwsLC+O677/jb3/5G8+bNOfvss0sd0rZt21i0aBHTp0/Hsizuuecedu3aRePGjQHYs2cPffv2pV+/fvz666+EhYWxYMEC8vPzAbO0yfjx4/n3v//N0KFDSU9PZ8GCBeX44YjUPPM37+eJb9ezdd9RANo0COOxYW05p1m9cl3P19uLC9rFcEG7GPZlZPPlH3v4fHkS2w9k8tny3Xy2fDfNI4MZ1S2OEV0aERnq75bXUVBo8dxPG3l73nYA+raK5LUxZxEepOHb4uGURItIZVLeUSqFhYWuBHrevHnk5+czduxYRo8ezdy5cwG4+uqrOeuss3jzzTfx9vZm5cqVrtWexo4dS25uLvPnzyc4OJj169cTElK9ipx6fhKddwyeibXnuf+VDH7BpTr1xhtv5Pnnn2fevHmutTenTJnCyJEjCQ8PJzw8nPvuu891/l133cVPP/3EZ599VqY/5nfffZehQ4dSp04dAAYPHsyUKVOYOHEiAK+//jrh4eFMmzbN9YfaqlUr1+Ofeuop7r33Xu6++27Xvu7du5f6+UVqop0HMnnquw38ssF8g1onyJf7BrdmTPd4vN20bnJUWAC392vObec1Y9nOw3y2PInvVu9l2/5MJv2wked/2sSAhChGd4/jvFaR+JSzGFn6sTzumvYn8zfvB+C285pz/+DWbnsdIrYKjzfbNA3nFpFKoLyjVGbPns2aNWvYsWMHcXFmms0HH3xAu3btWLZsGd27dycxMZH777+fhIQEAFq2bOl6fGJiIiNHjqRDhw4ANGvWrMIxuZvnJ9EeIiEhgXPPPZd3332Xfv36sXXrVn777TfXUmAFBQU888wzfPbZZ+zZs4fc3FxycnIICgoq9XMUFBTw/vvv88orr7j2XXPNNdx33308+uijeHl5sXLlSvr06eNKoI+3b98+kpOTGThwYMVfcC1nWRbTliXx+pythPj70KVxHbrE16Fr4zo0qRfkEWsFCxzNyee1X7fw7u87yCuw8PFycG3PJtw9sGWl9do6HA7OblqXs5vW5bFhbfl29V4+XZbEyqQ0fl6fys/rU4kK9Wdk10aM6hZH0/qle0MF2JRyhFs+XM6ug8cI8PXi+cs7MayTTR8GRCqDsyf6SDIU5IO3PuaISO1TFXnH6WzYsIG4uDhXAg3Qtm1bIiIi2LBhA927d2f8+PHcfPPNfPjhhwwaNIgrrriC5s2bA/CPf/yD22+/nZ9//plBgwYxcuTIajeP2/PfXXyDzDczdj13Gdx0003cddddvP7660yZMoXmzZtz3nnnAfD888/zyiuv8PLLL9OhQweCg4MZN24cubm5pb7+Tz/9xJ49e04oJFZQUMDs2bM5//zzCQwMPOXjT3dMSm9vehYPfrmGeUU9fQAbU47w8ZJEAOoG+9ElPoIujevQNb4OHRtFEOjnbVe4chKFhRZf/rGb537axP4jpsJ9n5b1eWxYW1pEhVZZHKEBvlx5djxXnh3P5tQjfLosia/+3MO+Izm8OXcbb87dxtlN6zK6WxwXdmhw2r+jH9fuZfxnqziWW0CjOoH892/daBsbVmWvRaRKhESDly8U5plEOiLe7ohEpCZR3uE2EydO5KqrruK7777jhx9+4LHHHmPatGlcdtll3HzzzQwePJjvvvuOn3/+mUmTJvHCCy9w1113VVl8Z+L5SbTDUeqhDXYbNWoUd999Nx9//DEffPABt99+u6tHcsGCBQwfPpxrrrkGMHMJNm/eTNu2bUt9/cmTJzNmzBgeeuihEvuffvppJk+ezPnnn0/Hjh15//33ycvLO6E3OjQ0lCZNmjB79mz69+9fwVdb+1iWxfQ/9jDxm3Ucyc7Hz8eL+y5oRXzdYP5MPMyKXYdZvSedQ5m5/LJhH79s2AeAj5eDtrFhdImvYxLrxnWIDQ9Qb7VNVuw6zOPfrGP17nQAmtQL4pGL2zIgIcrW30mr6FAeubgt/xySwOwNqXy6PIn5m/ezdMchlu44xMSZ6xjWOZbR3eLo2CjcFWthocVLv2zmtV+3AnBu83r856ou1A32s+21iFQaLy8IbwiHd5p50UqiRcSdlHeUSps2bUhKSiIpKcnVG71+/XrS0tJKPEerVq1o1aoV99xzD1deeSVTpkzhsssuAyAuLo7bbruN2267jQkTJvDOO+8oia6tQkJCGD16NBMmTCAjI4Prr7/edaxly5Z88cUXLFy4kDp16vDiiy+Smppa6j/m/fv388033zBz5kzat29f4ti1117LZZddxqFDh7jzzjt57bXXGDNmDBMmTCA8PJzFixdz9tln07p1ayZOnMhtt91GVFQUQ4cO5ciRIyxYsKBa/dFWR/uOZPOv6Wtdc2Y7xUXwwhWdaBFliiAMaR8DQE5+AeuTM1ix6zB/FCXWqRk5rN6dzurd6by3cCcA0WH+dC0aAt6lcR3axYbh76Pe6sqUkp7Nsz9u5Ks/9wAQ4u/DXQNacH2vJtXqZ+/n48XQDg0Y2qEBe9Oz+GL5bj5bkUTSoSw+XpLIx0sSSYgJ5YpucZzfJprHv1nH7I3mC5ubezflwaEJ5Z5PLeIRwuNMEp2WBI3tDkZExB6VmXc4FRQUsHLlyhL7/P39GTRoEB06dODqq6/m5ZdfJj8/nzvuuIPzzjuPbt26kZWVxf3338/ll19O06ZN2b17N8uWLWPkyJEAjBs3jqFDh9KqVSsOHz7MnDlzaNOmTUV/JG6lJLqK3XTTTUyePJkLL7yQ2NjiuYgPP/ww27dvZ/DgwQQFBXHLLbdw6aWXkp6eXqrrfvDBBwQHB590PvPAgQMJDAzko48+4h//+Ae//vor999/P+eddx7e3t507tyZXr16AXDdddeRnZ3NSy+9xH333Uf9+vW5/PLL3fPia6hvViXzyNdrSTuWh6+3g3GDWnFr32YnTVT8fbw5K74OZ8Wbwm+WZZGcnm2S6qLEel1yBqkZOXy/JoXv16QAJnHq2DDcNbe6S+MIokIDqvR11lTZeQX877ftvD5nG1l5BTgccEXXRtw3uHW1/xk3CA/kroEtGdu/BYu3H+Sz5Un8sDaFjSlHePLb9Tz57XrArGH975EduOysRme4okgNEK61okVEoPLyDqejR49y1llnldjXvHlztm7dytdff81dd91F37598fLyYsiQIbz22msAeHt7c/DgQa699lpSU1OpX78+I0aM4PHHHwdMcj527Fh2795NWFgYQ4YM4aWXXqrgT8O9HFZlLkJaDhkZGYSHh5Oenk5YWMn5etnZ2ezYsYOmTZsSEFC9P9zKydWk3+HBozk8+vU6vluzF4B2sWG8MKoTCTEVm2ealVvA6t1prEh0JtZpHMo8cY5KXN1Auhb1VHeJr0NCTKh6GMvAsix+WpfCU99tYPfhLAC6Nq7DY8Pa0rFRhL3BVUD6sTxmrtrDp8uTWLsng9jwAN7+Wzc6NAq3OzSPdrr3JimfSvuZznkG5j0LXa+HYa+c8XQRkZOpSZ9Zpdjpfq9leV9ST7RIOfy4NoWHZ6zhwNFcfLwcjO3fgjsHtMDXDUlsoJ83PZrVo0fR2sOWZbHz4DHXEPA/dh1mU+oRkg5lkXQoixkrTYGLID9vOjWKoGvRvOqz4iOICNK815PZsDeDJ75Zz6LtBwGICQtgwoUJXNIp1uPnoocH+fK3nk34W88m7DyQSWSoP8H++q9eahGtFS0iIpVMn6xEyiD9WB6PzVzrSlxbRYfw4qjOtG9Yeb18DoeDpvWDaVo/mMu7mg+HGdl5rEpKY8UuM696ZWIaR3LyWbT9oCsxBGgeGcygNtFc0S3ONT+7NjucmcuLszYzdckuCi0zzPnWvs24rV9zgvxq3n+HTcqw/JVIjeEazq0kWkREKkfN+9QoUknmbNzHP79czb4jOXg54NbzmjNuUEtbik6FBfjSp2UkfVpGAqYC85Z9R0v0Vm8/kMm2/Zls27+dt+dvp1vjOozqHsdFHRrUup7JvIJCpi7exUu/bCE9Kw+Aizo04MGhCcTVdc+aiCJSTTiT6LQksCxTTVdERMSNatcnaZFyyMjO46lv1/PZctOr0SwymP+7ohNdioqDVQdeXg5ax4TSOiaUq3qYJV0OZeayePtBvlyxmzmb9rF812GW7zrM4zPXcXHHWEZ1j6NLfITHD18+k9+27OeJb9azZd9RABJiQnlsWDt6Nq9nc2QiUinCG5ptXiZkHYaguvbGIyIiNY6SaJHT+H3LAR74YhXJ6dk4HHBjr6bcP7g1Ab7VZ8mjU6kb7MeFHRpwYYcGpGZk88WK3Xy+PImdB4/x6fIkPl2eRIuoEEZ3i+OyLg2pH+Jvd8hucygzl/mb9/P1yj3M2bQfgDpBvtw3uDVjusfj7VWzvzgQqdV8AyE4EjL3mwrdSqJFRMTNPDKJLiwstDsEKSdP+d1l5uQz6YcNfLQ4EYD4ukH83xWdOLupZ34Yiw4LYGz/FtzRrzlLdxzi0+VJfL9mL1v3HeXp7zfw7I8bGdgmitHd4+jbMtLjqnwXFlqs35vBrxv3MWfTPlYmpeFcd8Dby8G1PRszbmArwoN87Q1URKpGeKOiJHo3NOhkdzQi4sE85bOrlI67FqbyqCTaz88PLy8vkpOTiYyMxM/Pr8YPRa0pLMsiNzeX/fv34+XlhZ9f9a0avWT7Qe7/YjWJh44B8LdzGvPg0IQaMY/Y4XC4Kn9PvKQd36xK5rNlSazanc5P61L5aV0q0WH+XN61EaO6xdG4XvUtTJWRncfvWw4wZ+M+5m7ez/4jOSWOJ8SE0j8hipFdGqmomkhtEx4HyX+aedEiIuWgvKPmsSyL/fv343A48PWtWMeKR2UFXl5eNG3alL1795KcnGx3OFIOQUFBxMfH4+VV/Xo6s/MKeO7HTUxZuAPLgoYRgTx3eUd6tahvd2iVIizAl6t7NObqHo3ZmJLBp8uSmPHnHlIzcnh9zjZen7ONc5rVZXT3OIa0a0Cgn71D2C3LFE/7deM+5mzcx4pdh8kvLP42McjPm14t6tO/dRT9EyJpEB5oY7QiYitXhW4l0SJSPso7aiaHw0GjRo3w9q7Y51qPSqLBfCsUHx9Pfn4+BQUFdocjZeDt7Y2Pj0+1/Bbvj8TD3PfZKrYfyARgdLc4Hr64DaEBtWP4b0JMGI8Na8eDQxP4Zf0+Pl2exG9b9rN4+yEWbz/EowHruKRTLKO7x9GhYXiV/Q6P5eazcOtB5mzax9xN+9mTllXieLPIYJM0t46ie9M6tlRKF5FqKEJJtIhUnPKOmsfX17fCCTR4YBINuLrgK9oNL5KTX8BLs7bw3/nbKLQgOsyff4/oSP+EKLtDs4W/jzcXdWzARR0bsCctiy+W7+bzFUnsPpzF1CWJTF2SSEJMKKO7x3Fp54bUCXb/sPydBzJdc5uXbD9EbkHxXCQ/Hy96NqvHgIQo+rWOrNbDzUXERuGNzFZrRYtIBSnvkJPxyCRaxB3W7E7n3s9XsjnVLH102VkNmTisnYpPFWkYEcjdg1py14AWLNp+kE+XJfHjuhQ2phzh8W/WM+n7jZzfLprR3eLo3aI+XuWseJ2dV8DSHYdcvc07ikYDHB/HgAQzRLtns/q2DysXEQ/gGs6tJFpERNxPSbTUOrn5hfxnzlZen7OVgkKL+iF+PH1ZBwa3i7E7tGrJy8tBrxb16dWiPmnHcvl6ZTKfLkti/d4Mvlu9l+9W76VhRCCXd23EFd0a0ahO0BmvuSctyxQE27SPBVsPkpVXPETKx8tB9yZ1XYlz88iQajkFQESqMWcSfTQV8rLBN8DeeEREpEZREi21yoa9Gdz72SrW780A4KIODXjy0vbUrYRhyTVRRJAf153bhOvObcLaPel8ttwUI9uTlsUrs7fw6q9b6N2iPqO6xXF+22jXetp5BYWs2HXY9DZv3M+m1CMlrhsV6u8qCNarRf1aMxddRCpJUF3wCYT8LMjYA/Wa2x2RiIjUIEqipVbILyjkrXnbeGX2FvIKLCKCfHlyeHuGdYq1OzSP1b5hOO0bhvOvC9vw07oUPl2WxMJtB/ltywF+23KAiCBfLu7YgEOZufy2+QBHcvJdj/VyQJf4OvQvmtvctkGYeptFxH0cDlNc7MBmU1xMSbSIiLiRkmip8bbuO8K9n61i1e50AAa1ieaZEe2JCtXwPncI8PVmeOeGDO/ckMSDx/hiRRKfr9jN3vRsPlqc6DqvbrAf57WKpH9CFH1b1iciSL3/IlKJwhsVJdGaFy0iIu6lJFpqrNz8Qt5buIP/+3kzufmFhAb4MHFYO0Z0aahez0oSXy+I8Re05u5Brfhty35+WpdKZIgf/ROi6NgoAu9yFh8TESkz57zoNC1zJSIi7qUkWmqc9GN5fLRkF+8v3Mm+IzkA9G0VybMjO9AgPNDm6GoHby8H/VpH0a917VwqTESqAVXoFhGRSqIkWmqMxIPHeHfBDj5bnsSxXFPtOTrMn3sGtWJ09zj1PouI1CYRziQ68fTniYiIlJGSaPF4fyQe5n+/befHtSkUWmZfQkwof+/TjGGdYvHz8bI3QBERqXrhjcxWPdEiIuJmSqLFIxUUWsxan8o7v21nxa7Drv19W0Xy9z5N6d2ivnqeRURqM9dw7j1QWAhe+kJVRETcQ0m0eJRjufl8sWI3k3/fwa6DxwDw9XZwaeeG3NynGa1jQm2OUEREqoWwWMABBTmQuR9Co+2OSEREaggl0eIR9h3J5oOFu/hoyS7SjuUBEB7oyzXnxHNdzyZEhWm5KhEROY63L4Q2gCPJZki3kmgREXETJdFSrW1OPcL/ftvOjD+TyS0oBCC+bhA39W7KFd0aEeSnP2ERETmFiLiiJDoRGnW1OxoREakhlIFItWNZFgu3HeS/87czb/N+1/4u8RH8vU8zLmgXo/WGRUTkzMIbQdISFRcTERG3UhIt1UZufiHfrk7mnd92sGFvBgAOBwxpF8PNfZrRtXEdmyMUERGP4iwulpZkbxwiIlKjKIkW26Vn5fHJ0kTeW7CTlIxsAAJ9vRnVrRE39m5K43rBNkcoIiIeSctciYhIJVASLbZJOnSMdxfs4LNlSWTmFgAQGerP9ec24eoe8UQE+dkcoYiIeLSIeLNNT7Q3DhERqVGUREuVW5mUxju/beeHNXsptMy+1tGh3NynKZd0jsXfx9veAEVEpGZQT7SIiFQCr7KcXFBQwCOPPELTpk0JDAykefPmPPnkk1iW5TrHsiweffRRGjRoQGBgIIMGDWLLli1uD1w8S2Ghxc/rUhj11iIufX0B3602CXSflvV5/8az+XFcH67oFqcEWkRE3Mc5JzrrMOQctTcWERGpMcrUE/3ss8/y5ptv8v7779OuXTuWL1/ODTfcQHh4OP/4xz8AeO6553j11Vd5//33adq0KY888giDBw9m/fr1BARoLd/aJiu3gC//2M3k33ew40AmAD5eDi7pHMvNvZvRNjbM5ghFRKTGCggD/3DISTe90VEJdkckIiI1QJmS6IULFzJ8+HAuuugiAJo0acInn3zC0qVLAdML/fLLL/Pwww8zfPhwAD744AOio6OZMWMGY8aMcXP4Ul3l5Bfw4aJdvDF3G4cycwEIC/Dhqh6Nuf7cJsSE6wsVERGpAuGNYJ+SaBERcZ8yDec+99xzmT17Nps3bwZg1apV/P777wwdOhSAHTt2kJKSwqBBg1yPCQ8Pp0ePHixatMiNYUt1VVho8fXKPQx8YR5PfbeBQ5m5NKoTyGPD2rJowkAeHJqgBFpERKpORNGQbhUXExERNylTT/SDDz5IRkYGCQkJeHt7U1BQwNNPP83VV18NQEpKCgDR0dElHhcdHe069lc5OTnk5OS47mdkZJTpBUj1sXDbASZ9v5E1e9IBiAr1Z/z5rbi8ayN8vMv0fY2IiIh7qLiYiIi4WZmS6M8++4ypU6fy8ccf065dO1auXMm4ceOIjY3luuuuK1cAkyZN4vHHHy/XY6V62JRyhGd/3MivG/cBEOLvw619m3FTn6YE+akAvIiI2MhZXCwtyd44RESkxihThnP//ffz4IMPuuY2d+jQgV27djFp0iSuu+46YmJiAEhNTaVBgwaux6WmptK5c+eTXnPChAmMHz/edT8jI4O4uLiyvg6xQUp6Ni/O2sQXK3ZTaJmCYVf3iOeugS2pH+Jvd3giUtslrwSHFzToaHckYif1RIuIiJuVKYk+duwYXl4lh+V6e3tTWFgIQNOmTYmJiWH27NmupDkjI4MlS5Zw++23n/Sa/v7++Psr4fIkGdl5vD1vG5N/30F2nvndX9ghhvsHJ9C0frDN0YlIrVdYAAtegTlPQ50mcOt88NP/TbVWRLzZpqsnWkRE3KNMSfSwYcN4+umniY+Pp127dvz555+8+OKL3HjjjQA4HA7GjRvHU089RcuWLV1LXMXGxnLppZdWRvxShXLzC/l4yS5e/XWrq+J2t8Z1mHBhG7o2rmNzdCIiQFoifHUb7Fpg7kcmQEEuoCS61nL2RGckQ0E+eGuakYiIVEyZ3klee+01HnnkEe644w727dtHbGwst956K48++qjrnAceeIDMzExuueUW0tLS6N27Nz/++KPWiPZglmXx/ZoUnvtpI7sOHgOgWWQwDw5J4Py20TgcDpsjFBEBVn8O391r1gT2DYahz8JZ14D+j6rdQmLAyxcK8+BoSnFSLSIiUk4Oy7Isu4M4XkZGBuHh4aSnpxMWFmZ3OLXe0h2HeOb7DaxMSgOgfog/95zfktHd4lRxW0Sqh6w0kzyv/cLcb9QdRvwX6jZz21Povcn9qvRn+nJHSNsFN/wIjXtW7nOJiIhHKsv7ksY0yUlt3XeEf/+wiV82pAIQ5OfN3/s045a+zQj215+NiFQTO3+H6bdCxm5weMN5D0Cf+zRkV0qKiDdJtIqLiYiIG+hThpSwLyObl37ZwqfLEim0wNvLwZjucdw9qCVRoRqSLyLVRH6uKRy24BXAgjpNYcQ7ENfd7sikOnJV6E60Nw4REakRlEQLAEdz8vnv/O28M387WXkFAFzQNpoHhiTQIirE5uhERI6zfxN8eTOkrDb3z/obDJkE/qH2xiXVl5a5EhERN1ISXcvlFRTy6bIkXv5lCweO5gBwVnwE/7qwDd2b1LU5OhGR41gWLPsf/Pww5GdDYB0Y9iq0vcTuyKS6C48z2zQtcyUiIhWnJLqWsiyLn9en8uyPG9m+PxOAJvWC+OeQBIa0j1HFbfFsR1Jh6X9h7ZfQ+SozT1Y825FU+HosbJ1l7jcfAMPfgLAG9sYlnkE90SIi4kYqr1wLrdh1iMvfWsStH65g+/5M6gX78cTwdswafx5DOzRQAi2eK3U9zLgDXm4Pv/0fHN4Bi16HwkK7I5OK2Pg9vNnTJNDe/jDkWbj6SyXQlWj+/PkMGzaM2NhYHA4HM2bMKHH8+uuvx+FwlLgNGTLEnmBLIyLebNOTzIgGERGRClBPdC2yff9RnvtxEz+uSwEgwNfLVXE7NMDX5uhEysmyYNuvsOg/ZusU1wP2robsNDiwCaLa2BailFNuJvz0L1jxnrkf3d4UD4tua2tYtUFmZiadOnXixhtvZMSIESc9Z8iQIUyZMsV139/fv6rCK7uwhmabe9T8nxBYx9ZwRETEsymJrgX2H8nh1dlb+HhpIgWFFl4OGNUtjnGDWhETrorb4qHyc2DNF6aned86s8/hBW2GQc+7TJXm94fBjvmwa6GSaE+zZwV8+Xc4tM3cP/cuGPAI+FTjRK0GGTp0KEOHDj3tOf7+/sTExFRRRBXkFwRB9eHYATMvWkm0iIhUgJLoGiwrt4B3ftvO2/O2kZlrKm4PTIjin0MTaBWtKrbioY4dguWTYek7cNSsY45vMHT5G5xzO9RpUnxufE+TRCcuhu432RKulFFhAfz+Isz9NxTmQ2gsXPYWNDvP7sjkL+bOnUtUVBR16tRhwIABPPXUU9SrV++U5+fk5JCTk+O6n5GRURVhFgtvZJLo9N3QoGPVPreIiNQoSqJrIMuy+Gb1Xv79/QaS07MB6NgonAlD29Cz+ak/4IhUawe3weI3YOXHkHfM7AuNhR63QtfrITDixMfE9zTbxEVVFaVUxOGdMP1WSFps7re7DC56EYK0UkB1M2TIEEaMGEHTpk3Ztm0b//rXvxg6dCiLFi3C29v7pI+ZNGkSjz/+eBVHepyIONi7UsXFRESkwpRE1zBr96Tz+DfrWLbzMAANIwL559AELu7QAC8vFQwTD2NZJgFe9Dps/A4oKggU08EM2W53Gfj4nfrxjbqDw9sUE0pLMh+ipfqxLFg1Db6/H3KPgF8oXPg8dBoDKnRYLY0ZM8bV7tChAx07dqR58+bMnTuXgQMHnvQxEyZMYPz48a77GRkZxMVV4b9J5zJX6YlV95wiIlIjKYmuIQ4czeH/ftrEp8uTsCxTNOyOfi24pW8zAnxP3isgUm0V5MOGr2HhfyD5j+L9LS+AnndC076lS678Q8ywzeQ/zZBuJdHVz7FD8O09sH6GuR93Dox4u+SwfKn2mjVrRv369dm6despk2h/f397i49pmSsREXETJdEeLje/kA8W7eSVX7ZwJCcfgOGdY/nnkARiIwJtjk6kjLIz4M8PYfFbxb1F3v6mR7LnWIhsXfZrxp9blEQvgo5XuDdeqZjtc+Gr2+FIMnj5QL8Hodc94K23Jk+ze/duDh48SIMG1XjZMWdPdFqSvXGIiIjH0ycVDzZn4z6e/HY92w9kAtC+YRgTh7WjWxPNHxQPk74blrwFK96HnKJiQ0H1oPvfofvNEBJZ/mvHnwOLX9e86OokPwdmP2GWJQOo1wJG/BcadrU3LnE5evQoW7dudd3fsWMHK1eupG7dutStW5fHH3+ckSNHEhMTw7Zt23jggQdo0aIFgwcPtjHqM1BPtIiIuImSaA+0bf9Rnvp2PXM27QegfogfDwxO4PKujTTvWTxL8p9myPa6r8AyFeSp19L0OncaA75uGE3hLC62bz1kHdbSNnZLXQ/T/w6pa839rjfA4KfBL9jeuKSE5cuX079/f9d951zm6667jjfffJPVq1fz/vvvk5aWRmxsLBdccAFPPvlk9V4rOiLebI+mmC9ytFyaiIiUk5JoD5KRncerv2zhvYU7yS+08PV2cEOvptw1oAWhAb52hydSOoWFsOUnkzzv+r14f5M+Zi3gFueDl5f7ni8k0vR0HtwKiUug9RD3XVtKr7AQlr4Nsx6Dghwz0uCS/0DChXZHJifRr18/LMs65fGffvqpCqNxk6B64BMI+VmQsQfqNrM7IhER8VBKoj1AQaHF58uTeP6nTRzMzAXMes8PXdSGZpEhNkcnUkq5x2DVJ2aZqoNFw0S9fKDdCNPzHNu58p47vmdREr1ISbQdMvbC13fAtl/N/ZYXmAQ6NNreuKR2cTjMkO6DW8y8aCXRIiJSTkqiq7mlOw7x+DfrWJds5ok2jwzmkYvb0q91lM2RiZTS0X2w9B1Y9j/IOmT2+YdD1+ugx20Q3rDyY4jvaQqWaV501Vs/E7652/zufQLggqfMPHctXSV2cCbRmhctIiIVoCS6mtqTlsWk7zfw7eq9AIQG+DBuUCuu7dkYX283DnUVqSxZafDLY7DyEzN8FyA8Hs65Hbr8DfxDqy6WxkXzovf8AXlZ7plrLadXWGCWrvrjfXM/piOM/F/5KqyLuItzmTsl0SIiUgFKoquZrNwC3p6/jbfmbSM7rxCHA8Z0j+e+C1pRL0RFUMokOwOWT4bmA81awVJ1Dm6Dj0ebHh+Aht3g3DshYZg9yxfVaQoh0XA01STSTXpVfQy1zcqpRQm0A3rdDf0fAh8/u6OS2s65zJVzCT0REZFyUBJdTViWxber9zLp+w0kp2cDcHbTujw2rC3tYsNtjs4DFRbClzfBlp9h7rMw+iNoOcjuqGqHHfPh079BdhqExpqli5r0tnf4rsNhhnSvn2GGdCuJrly5x2DOJNM+/wno9Q974xFx0jJXIiLiBkqiq4G1e9J54pv1LN1p5os2jAjkXxe24cIOMTg0b7B85j5jEmgwlVg/GQMj3ob2I+2Nq6Zb/i58fz8U5ps1f8d8DKExdkdlHJ9ES+Va+jYcSTbD93vcanc0IsWcPdFpSfbGISIiHk1JtI0OHM3hhZ83MW1ZEpYFAb5e3NGvBbf0bUaAr7fd4Xmu9TNh/vOmPfx12Dob1k2HL24yQ7y73WBvfDVRQT789C+TPAG0vxyG/6d6zT12zotOWmrm63rp31ilOHYIfn/JtPv/S2vxSvVyfE+0ZanAnYiIlIuSaBvk5hfywaKdvPLLFo7k5ANwSadYHhyaQGxENUo6PNG+jTDjdtM+5w446xrodCUERphe0m/HQdZh6DPezihrlqw0+OKG4uWLBjwMfe6rfh9Oo9uDXyjkZEDqOs2Tryy/vwTZ6RDVDjqOsjsakZLCGgIOU+wwcz+EaKULEREpOyXRVWzOpn08+e16tu/PBKB9wzAeG9aO7k3q2hxZDZCVBtOugtyj0KSPmYsJpsfxohchsA789gLMftwk0uc/Uf0SPU9zfAEx3yC47C1oO9zuqE7OyxvizoZts82QbiXR7pe+G5YUjUYYNFG9/VL9+PiZKSZH9kJ6kpJoEREpFyXRVWT7/qM8+e165mzaD0D9ED/uH9yay7vG4e2lRK7CCgth+t/h0DYz5+2K98Dbt/i4wwEDHzWJ9M8Pw8JXTSI97BV90C+vvxYQu/ITiO1sd1SnF9+zOInWXF33mzPJ9PA17g0tz7c7GpGTC48zSXRakqndICIiUkZKoitZRnYer83ewpQFO8kvtPD1dnBDr6bcOaAFYQG+Z76AlI6zkJhPgKnEHVz/5OedexcERMA3/4A/PzRDe0e8o3mbZVWdC4idjnNe9K5Fmg/pbvs2wKqPTXvQRP1spfoKbwS7l6pCt4iIlJuS6EpgWRYbU44wY+Uevli+m4OZuQAMSIji4Yva0CwyxOYIa5jjC4kNe/XMvaFd/gYB4WYJrPVfm2Jjoz8Cf/1ezsgTCoidTsOu4OULR1Pg8E6o29TuiGqO2U+AVQhthkFcd7ujETm1COda0UqiRUSkfJREu1HSoWPMXJXM1yv3sDn1qGt/s8hgHrm4Lf1ba+6V2/21kFin0aV7XNtLwP8zmHY1bJ8DH14KV30GQZqbfkqeUkDsdHwDIfYs0wuVuEhJtLvsWgSbvgeHNwx8zO5oRE7PucxVupa5EhGR8lESXUGHMnP5bnUyX69MZvmuw679ft5eDEiIYnjnWAa1jcbX28vGKGuoEwqJPVm2xzfvD9fNhI9Gwu5l8N5FcM10CGtQKeF6NE8qIHYmjXsWJ9Gdr7I7Gs9nWfDLRNPu8jeo39LWcETOyLXMlZJoEREpHyXR5XAsN59Z61P5emUy8zfvJ7/QAkyHXM9m9RjeOZYh7RsQHqg5z5WmsOAkhcTK8efcqBvc8AN8eBnsWw/vDoZrZ0DdZu6O2HNtnwefXWsKiIU1NAXEGnSyO6ryi+8JC14xvadScZt+gKTF4BMI5z1odzQiZ+bsiU5TEi0iIuWjJLqU8goK+X3LAWas3MPP61LJyitwHWvfMIxLOzfk4o6xxIQH2BhlLTJ3UukKiZVGdFu46Sf44FI4vAPeHQJ/+wqi27ktXI9VooBYNxgz1TMKiJ1OXA+zPbgFMg9U7G+ntivIN0vGAZxzu0ZxiGdw9kRnHYLcTPALtjceERHxOEqiT8OyLP5IPMyMP5P5bs1eDhUVCAOIrxvEpZ1juaRzQ1pEqSBVlSprIbHSqNMEbvwRPhwB+9bBlKFw9RdmXeHayNMLiJ1OUF2IbAP7N5gh3W2G2R2R51r1CezfaJaO63W33dGIlE5gBPiHmdUZ0ndDZGu7IxIREQ+jJPoktqSaytpfr0xm9+Es1/76IX5c3DGW4Z1j6RwXgcOTCirVFOUtJFYaoTFww3cwdZSZM/vBcNPL3WKg+57DE9SEAmJn0rhnURK9WEl0eeVlmREhYP4+AiNsDUekTMIbmSk86UlKokVEpMyURBdJTsvim1XJzFiZzIa9Ga79wX7eDG4Xw/CzGtKreT18VCDMPhUtJFYagXXMnOhP/wbbZptiWiPfgXaXuf+5qqMTCoi9bSqZ1zTxPc1Q9V0L7Y7Ecy39L2TsgbBG0P1mu6MRKZvwOJNEa160iIiUQ61OotOO5fLD2hRm/LmHpTsPYZn6YPh4OejXOpLhnRsyqE00gX7e9gYq7iskVhp+wXDlNPjqFlj3FXxxI2SnQ9frK+f5qouaVkDsdOJ7mu3eVZoTWR5Zh+G3F0x7wEPgq1oQ4mFcFbq1VrSIiJRdrUuis/MK+GWDqaw9d9M+8gos17Gzm9ZleOdYLmzfgDrBfjZGKSeY84z7ComVho8fjJwMAeGw4j345m7TE957XOU+r11qYgGx04mIMz2oGbvN8mbN+tkdkWf5/SXzxVJUW+joxikVIlUlwrlWtJJoEREpu1qRROcXFLJw20FXZe2jOfmuYwkxoVx6VkOGdYqlYUQNKJpUE62fCb/9n2m7q5BYaXh5w8UvmyHev78EvzxmeuAGTaw584P/WkCswxVwyWs1o4DYmTTuCWs+N/OilUSXXvoeWFL09zJoovl3IuJpnMtcaa1oEREphxqdRK/dk84XK3bz7eq9HDia49rfMCKQ4Z1jGd65Ia1jQm2MUM6oMguJlYbDYRKFgAiTRC942STSF7/k+cnDCQXEHoE+99acLwjOJP4ck0RrXnTZzJ0E+dkQfy60vMDuaETKR0m0iIhUQI1Oomf8uYf3Fu4EoE6QLxd1bMClnRvSJb4OXl61JFHwZFVRSKy0eo8zPdLfjoM/3jdDWUe8Y4Z9e6LaUkDsdOLPNdvdy6EgD7x97Y3HE+zbCCunmvb5j9eeL1yk5nHOic5INjU3PP1LURERqVI1Oom+9KyG7DuSw6VnxdKnZSS+qqztOaqykFhpdb3OzJH+8mZYP8OsMTr6I88rSlWbCoidTmSCGWGQnQYpq6FhV7sjqv5mPwFWISRcXHvXUJeaITQGvHxMHYgjKRDe0O6IRETEg5Qpq2zSpAkOh+OE29ixYwHIzs5m7Nix1KtXj5CQEEaOHElqamqlBF4a7RuG8+qVZzEgIVoJtKep6kJipdXuUrjqU9N7u+1X+OBSM7zbUyybDB+NMIljw27w919rZwIN4OVlhnSDmRctp5e4BDZ9Bw4vGPiY3dGIVIyXN4TFmraGdIuISBmVKbNctmwZe/fudd1mzZoFwBVXXAHAPffcwzfffMPnn3/OvHnzSE5OZsSIEe6PWmq24wuJXfJa1RUSK60WA+Har02v9O6lMOUi05NRnRXkm+rb3403PS8droDrv6vZFbhLw5lEa1706VmWqQkAcNY1ENnK3nhE3CFcFbpFRKR8ypRER0ZGEhMT47p9++23NG/enPPOO4/09HQmT57Miy++yIABA+jatStTpkxh4cKFLF6sXh4ppX0b4KvbTPucsdBxlL3xnErc2XDDDxASDfvWwbuD4dAOu6M6uaw0+PgKWPpfc3/AI2Y+t9b2LZ4XnbgY10LxcqLNP0LiIjMypN8Eu6MRcQ9nEp2WaG8cIiLicco9xjk3N5ePPvqIG2+8EYfDwYoVK8jLy2PQoEGucxISEoiPj2fRokWnvE5OTg4ZGRklblJLZaXBtKshLxOa9oXzn7A7otOLbgc3/ggRjeHwTnh3CKSutzuqkg5ug/8NMkPPfYNg1IfQ9z4VhHKK7Qze/nDsABzcanc01VNhAfzyuGmfc3vxEFgRT+csLqaeaBERKaNyV2qaMWMGaWlpXH/99QCkpKTg5+dHREREifOio6NJSTn1UNdJkybx+OOPlzcMqSn+Wkjs8in2FxIrjbrN4MafzDzjfethylC4+guI6151MeTnmA+Bh3dC2i44vMts0xJNz37esdpdQOx0fPyhUTfYtcAM6a7f0u6Iqp9V02D/BlOErdc4u6MRcZ8IDecWEZHyKXeWMnnyZIYOHUpsbMV6JSZMmMD48eNd9zMyMoiLi6vQNcUDVddCYqUR1sDML/54FOxeBh8MhzFToXl/91y/sAAy9pRMjp3tw7vgyF7gNEORG3WH0VMhNNo98dQ08T1NEp242FRgl2J5WTDnadPucy8ERtgajohbuXqiVVhMRETKplxJ9K5du/jll1+YPn26a19MTAy5ubmkpaWV6I1OTU0lJubUxYv8/f3x9/cvTxhSU1T3QmKlEVQX/jYDPr0Gts8xCfXI/0Hb4Wd+rGXB0X3H9SLvLNommn3pu00xsNPxDTLDyus0hoj44nadJhDVzlSilpOL72m2iSoudoKl75gvcMIawdm32B2NiHuFx5uteqJFRKSMypVET5kyhaioKC666CLXvq5du+Lr68vs2bMZOXIkAJs2bSIxMZGePXu6J1qpeTylkFhp+IeY5a++vBk2zITPr4dhr5pqxlmHj0uSE08cdp2fffpre/maoYeuRPm4bURj03Ovec7lE3e2Wbbp8E7I2GtGFoipUfDbC6bd/18qRCc1j3Nt6JwM8/eukRYiIlJKZU6iCwsLmTJlCtdddx0+PsUPDw8P56abbmL8+PHUrVuXsLAw7rrrLnr27Mk555zj1qClhshKg2lXeU4hsdLw8Ycr3oNv7oY/P4SZd8JP/zIf0k7H4WXmLR/fi3z8NjTGrGsq7hcQZorEpawxFajba1k+ABa8bNYTj2wDncbYHY2I+/kFQ2BdyDpkeqOVRIuISCmVOYn+5ZdfSExM5MYbbzzh2EsvvYSXlxcjR44kJyeHwYMH88Ybb7glUKlhXIXEtpshdZe/5xmFxErDy9sMSw+sAwtfLU6gg6P+khwflzCHNQIfP3vjrs3izy1KohcriQbISIbFb5r2oMf0BY7UXBFxRUl0EsS0tzsaERHxEGXOWi644AKsU6ynGhAQwOuvv87rr79e4cCkhju+kNiYjyC4nt0RuZfDARc8CV2vh4I8kzD7BdkdlZxK/Dmw9G3Ni3aaO8lMMYjvCa2G2B2NSOUJj4O9qzQvWkREyqSGdP2JR/lrIbGavOxSveZ2RyCl4SwulroOstMhINzeeOy0fzP8+ZFpD3pcc+2lZgsvWg0kLdHeOERExKOoZK9UrZpUSExqjrAGppK5VQhJy+yOxl6zHzc/h4SLIb6H3dGIVC7XMlfqiRYRkdJTEi1VJ+twzSskJjVH/Llmm7jI3jjslLQUNn5rCt0NfNTuaEQqX0RRT7SSaBERKQMl0VI1CgvgyxpaSExqhviiVQRqaxJtWTDrMdPufDVEtrY3HpGq4OqJTrI3DhER8ShKoqVqzHkGts4Cn8CaWUhMPF/jop7oPSsgP8feWOyw5WdTWM0nAPpNsDsakaoRHm+2R1IgP9feWERExGMoiZbKV5sKiYnnqtcCguqbqtTJK+2OpmoVFsAvE027x20Q3tDWcESqTHB98PYHLMjYY3c0IiLiIZRES+U6vpBYzzuh4xX2xiNyKg5H7R3SvfpT2LfeVCXvPc7uaESqjsOh4mIiIlJmSqKl8mSllSwkNuhxuyMSOT3nUle1KYnOy4ZfnzbtPvdCYB174xGpaq7iYpoXLSIipaMkWirP/OdVSEw8S2NnEr0YCgvtjaWqLPsfZOyGsIZw9i12RyNS9dQTLSIiZaQkWipH+h5Y+o5pD3tJhcTEM8R0At9gyE6D/RvtjqbyZaUV1yvo/y/wDbQ1HBFbOIuLpSXaG4eIiHgMJdFSOeY/DwU5Zu3d5gPtjkakdLx9oFE3064NQ7oXvGLWb49MgE5X2h2NiD3UEy0iImWkJFrc79AO+PND0x74iCncIuIpnEtd1fQkOmMvLH7TtAc+Bl7e9sYjYhfXnGgl0SIiUjpKosX95v4bCvNND7QzIRHxFK4K3YvtjaOyzfs35GdB3DnQeqjd0YjY5/ieaMuyNxYREfEISqLFvfZtNMvlAAx42N5YRMqjUXdweJtKvWk1tFrv/s3wR9FokfMf12gRqd3CGgIO86XSsYN2RyMiIh5ASbS415ynAQvaDIOGXeyORqTs/IKhQSfTrqm90b8+AVYBtL6wuOddpLby8YeQaNNWcTERESkFJdHiPsl/woaZgAP6P2R3NCLl55oXvdDeOCpD0jLY8A04vGDgo3ZHI1I9qLiYiIiUgZJocZ9fnzLbjqMgqo29sYhURE2dF21Z8Mtjpt35Kv07FXFyFReroVM4RETErZREi3vsWgRbfwEvH+j3oN3RiFRMfE+z3bcejh2yNxZ32jILdi0AnwDoN8HuaESqD/VEi4hIGSiJloqzLPj1SdM+6xqo28zeeEQqKrg+1Gtp2klL7I3FXQoL4JeJpn32LcVJg4hAeLzZak60iIiUgpJoqbhtv5reLW9/6PuA3dGIuEfjot7omrJe9JrPYd86CAiH3vfYHY1I9aKeaBERKQMl0VIxx/dCd78ZwhvaG4+IuziHdO+qAUl0XnZxzYLe4yGorr3xSLU3f/58hg0bRmxsLA6HgxkzZpQ4blkWjz76KA0aNCAwMJBBgwaxZcsWe4J1B9ecaCXRIiJyZkqipWI2fmeqcvsGq3dLahZnEp38J+Rl2RtLRS2fbAomhcZCj1vtjkY8QGZmJp06deL1118/6fHnnnuOV199lbfeeoslS5YQHBzM4MGDyc7OruJI3cTZE33sAOQeszcWERGp9nzsDkA8WGFBce/WObdDSKS98Yi4U50mEBIDR1Ngzwpo0tvuiMonOx3mP2/a/SeAb6C98YhHGDp0KEOHDj3pMcuyePnll3n44YcZPnw4AB988AHR0dHMmDGDMWPGVGWo7hEQAX6hkHsEMvZA/ZZ2RyQiItWYeqKl/NZ+Cfs3mDmW595ldzQi7uVw1Ix50QtehazDUL81dLrK7mikBtixYwcpKSkMGjTItS88PJwePXqwaJGH/ltxOIp7o1VcTEREzkBJtJRPQR7Meca0z/0HBEbYGo5IpfD0edFHUmBR0XDcQY+BtwYfScWlpKQAEB0dXWJ/dHS069jJ5OTkkJGRUeJWrai4mIiIlJKSaCmflVPh8A4IjoQet9kdjUjlcCbRSUvN9AVPM/ffkJ8FcT2g9YV2RyO13KRJkwgPD3fd4uLi7A6pJFdxsSR74xARkWpPSbSUXV42zHvOtHuPB/8Qe+MRqSzR7cA/zMyTTF1rdzRlc2Ar/PGBaQ+aaIarirhBTEwMAKmpqSX2p6amuo6dzIQJE0hPT3fdkpKqWbKqnmgRESklJdFSdiummMIrYQ2h2412RyNSeby8Ie5s005cbG8sZTX3GbAKoOVgaHyu3dFIDdK0aVNiYmKYPXu2a19GRgZLliyhZ8+ep3ycv78/YWFhJW7VSni82aZVs+ReRESqHSXRUjY5R+G3F0z7vAfAN8DeeEQqm2te9EJ74yiLlLWm8B/AwEfsjUU80tGjR1m5ciUrV64ETDGxlStXkpiYiMPhYNy4cTz11FPMnDmTNWvWcO211xIbG8ull15qa9wV4uqJVhItIiKnpyozUjZL3oLM/VCnKXS+2u5oRCqfM4lOXAyW5RnDouc8bbbtRkBMB3tjEY+0fPly+vfv77o/fvx4AK677jree+89HnjgATIzM7nllltIS0ujd+/e/PjjjwQEePAXq8450Rl7TA0EL2974xERkWpLSbSUXlYaLHzVtPv/C7x9bQ1HpEo07Arefma96MM7oG4zuyM6vd3LYdP34PAy/05FyqFfv35YlnXK4w6HgyeeeIInnniiCqOqZCEx4PCGwnw4mgphsXZHJCIi1ZSGc0vpLXwNstMhsg20H2l3NCJVwzcAYs8ybU+YF/3rk2bb6Sqo39LeWEQ8ibePqfUBKi4mIiKnpSRaSufoflj8pmkPeEjD3KR28ZR50Tvmw/a54OVrahaISNk450WnJdobh4iIVGtKoqV0fn8J8jJNj1zCxXZHI1K1jp8XXV1ZFswu6oXuej3UaWxrOCIeybVWtHqiRUTk1JREy5ml74Fl/zPtAY94RmElEXeK72G2B7eYURnV0ZafYfdS8AmEvvfZHY2IZ1KFbhERKQUl0XJm85+Dghxo3AuaD7A7GpGqF1gHotqadlI17I0uLCyeC93jFgiNsTceEU/lSqLVEy0iIqemJFpO79B2+PMj01YvtNRmrnnRi+yN42Q2fA0pa8A/DHqNszsaEc8VHm+2aeqJFhGRU1MSLac3999muY8Wg6BxT7ujEbGPa150NUuiC/JhzjOm3XMsBNW1Nx4RT6aeaBERKQUl0XJq+zbA6s9Me8DD9sYiYjfnl0h7V0HOUXtjOd7qT+HAZgisC+fcYXc0Ip7NmUTnpJslHUVERE5CSbSc2pynAQvaDCteJ1ektgpvBOFxYBXAnuV2R2Pk58K8f5t273EQEGZrOCIezz/E1EAA9UaLiMgplTmJ3rNnD9dccw316tUjMDCQDh06sHx58QdKy7J49NFHadCgAYGBgQwaNIgtW7a4NWipAsl/woZvAAf0f8juaESqh+o2L/qP9816tiHR0P3vdkcjUjOEa5krERE5vTIl0YcPH6ZXr174+vryww8/sH79el544QXq1KnjOue5557j1Vdf5a233mLJkiUEBwczePBgsrOz3R68VKJfnzLbjqMhqo29sYhUF/HnmG3iQnvjAMg9BvP/z7T73g9+QfbGI1JTOJPotER74xARkWrLpywnP/vss8TFxTFlyhTXvqZNm7ralmXx8ssv8/DDDzN8+HAAPvjgA6Kjo5kxYwZjxoxxU9hSqXYthK2/gJcP9HvQ7mhEqo/G55rt7uVQkAfevvbFsux/cDQFIuKhy3X2xSFS00SoJ1pERE6vTD3RM2fOpFu3blxxxRVERUVx1lln8c4777iO79ixg5SUFAYNGuTaFx4eTo8ePVi06OTDH3NycsjIyChxExtZFswuWm/2rL9B3aanP1+kNqnf2syXzDsGe1fbF0d2Bvz+kmmf9yD4+NkXi0hN46rQrWWuRETk5MqURG/fvp0333yTli1b8tNPP3H77bfzj3/8g/fffx+AlJQUAKKjo0s8Ljo62nXsryZNmkR4eLjrFhcXV57XIe6ybbYZqurtb4aIikgxLy+Icw7ptnFe9OI3IOsQ1GtpplyIiPtomSsRETmDMiXRhYWFdOnShWeeeYazzjqLW265hb///e+89dZb5Q5gwoQJpKenu25JSfrm1zaWVTwXuvvNEN7Q3nhEqqPGNq8XfewQLPyPaff/F3iXaVaOiJxJeLzZpunziIiInFyZkugGDRrQtm3bEvvatGlDYqIpvhETEwNAampqiXNSU1Ndx/7K39+fsLCwEjexycZvTVVu32DofY/d0YhUT/HHJdGWVfXPv+BlyD0C0R2g7aVV//wiNZ2zJ/rIXlP7QERE5C/KlET36tWLTZs2ldi3efNmGjduDJgiYzExMcyePdt1PCMjgyVLltCzZ083hCuVprAAfn3atHveASGR9sYjUl016Aw+AXDsIByo4uX7jqTAkv+a9oCHzfByEXGv4EgzpQkLMvbYHY2IiFRDZfoEds8997B48WKeeeYZtm7dyscff8x///tfxo4dC4DD4WDcuHE89dRTzJw5kzVr1nDttdcSGxvLpZdeWhnxi7us/RL2b4CAcOh5p93RiFRfPn7QsJtpV/WQ7t9egPwsaNQdWg2u2ucWqS28vIqnM2letIiInESZkuju3bvz1Vdf8cknn9C+fXuefPJJXn75Za6++mrXOQ888AB33XUXt9xyC927d+fo0aP8+OOPBAQEuD14cZOCPJhT1Avd624IjLA1HJFqz4550Yd3wfKi5QUHPAIOR9U9t0htE65lrkRE5NTKXJHm4osv5uKLLz7lcYfDwRNPPMETTzxRocCkCv35ERzeaYaw9bjN7mhEqr94Gyp0z3sOCvOg6XnQ7Lyqe16R2siZRKu4mIiInIQm1NV2edkw/3nT7nMv+AXbG4+IJ2h0Nji8zJdPGXsr//kObIFVH5v2wEcr//lEarsIZ0+0kmgRETmRkujabvm7pnBKWEPoeoPd0Yh4hoAwiG5v2lXRGz3nGbAKodVQaNSt8p9PpLZzrRWtJFpERE6kJLo2yzlqChUBnPcA+GreukipNT7XbCs7iU5ZA+umm/aAhyr3uUTEcCXRmhMtIiInUhJdmy15C44dgLrNoPPVZz5fRIpV1bxo59Jz7UZATIfKfS4RMY6fE23HevAiIlKtKYmurbIOw4JXTbvfv8Db1954RDxNfFGF7pS1kJ1eOc+RtAw2/2DmX/f/V+U8h4icKKxoiav8LDh2yN5YRESk2lESXVstfA1y0iGqLbQfaXc0Ip4nNAbqNAUsk+xWhl+LVjnodBXUb1k5zyEiJ/INgJBo005PtDcWERGpdpRE10ZH98Pit0y7/0PgpT8DkXJxzYte6P5rb58HO+aDly/0+6f7ry8ip+cp86Jzj8EHl8IP+n9CRKSqKHuqTJYF+zZCzhG7Iynp9xchLxNiu0DCRXZHI+K5XPOiF7v3upYFvz5p2t1ugIh4915fRM7MOS+6uifR67+G7XNMnZPDu+yORkSkVlASXZlWfwZv9IDnmsPHY+DPqfbPrUrfA8smm/aAh8HhsDceEU8WX9QTvXs55Oe477qbf4Ldy8AnEPrc577rikjpOXui06r5MlerPy1uOyv5i4hIpVISXZn+/NBsC3JMcaCv74DnW8D7l8DSdyBjb9XHNP85E0/jXtB8QNU/v0hNUq85BEeaf1PJK91zzcJC+PUp0+5xC4RGu+e6IlI2zhEg1Xmt6Iy9sGNe8f21X9oXi4hILaIkurIc3Qe7Fpj21V9AvwkQ3R6sAvOG9/198GIC/O98UyX70I7Kj+ngNvjzI9Me8Ih6oUUqyuE4bki3m+ZFr/8KUteAfxj0Gueea4pI2bnmRFfjJHrN52AVQlQ78PIx68rv32x3VCIiNZ6S6Mqy8VvzxhZ7FrQ8H/o9CLcvgLv+gPOfgEbdzXm7l8KsR+DVzvBWb5j3HOzbUDnrUs79NxTmQ4vzoXFP919fpDZyDul2x7zognyY84xp9xwLQXUrfk0RKR9PKCy2+jOzPftmaNbftDWkW0Sk0vnYHUCNtf5rs207vOT+es2h193mlpEMG7+DDTNh5wLzDXLKGpjzNNRrAW2GmVtsl4r3GqeuN99Yg5kLLSLucXxxscLCilW7Xz0NDm6FwLpwzh3uiU9EysdZWCxzP+RlgW+gvfH8Veo6M2rF2w/aXgq+QbB1Fqz5As77p0abiYhUIvVEV4bMg7DjN9P+axJ9vLBYOPvvcN03cN8WGP46tBpi3hAPboXfX4J3BsBL7czSFTt/h8KC8sU052nAgjaXQGzn8l1DRE4U0xF8gyE7DfZvKP918nNg7rOm3fseCAhzS3giUk6Bdcy/bTBFOaubVdPMtuUFZtRK6wvB2x8ObjFfyIuISKVREl0ZNn1n5j7HdIS6zUr3mOB6cNY1cNWncP82uPxdaHeZeQPP2GOWrnjvIvi/VjDzLtgyq/TVgPf8YYaX4zDrQouI+3j7QFzR9IzEReW/zh8fQHoihMSYL9dExF4OB0Q4l7lKtDeWvyosKB5d1mmM2QaEQasLTFsFxkREKpWS6MpwqqHcpRUQBu1HwhXvwQPb4Mpp0PlqCIiAYwfMh+2pl5tK31/ebJ4vN/PU13NW+u04GqISyheTiJyac170rnIm0bnHYP7zpt33vuo3bFSktqqu86J3/gZH9prPBS0vKN7ffqTZrp1eObVVREQE0Jxo98s6DNvnmnbbSyt+Pd9AaD3U3AryTMXvDd/Ahm/haIr5JnrN5+ATAC0GmTnUrQabYWgAuxbCttmmame/Bysej4ic6Ph50eWx9L9wNNUsqdPlOvfFJSIV45wXXd2S6FVFa0O3uwx8/Iv3txwMfiGm53z38uJRMiIi4lZKot1t0w+mAnZUO6jfwr3X9vaFZv3MbejzsHuZKUq24RtI22WGbG/81iTMTfuahNo5Z6rLtVC3qXvjERGjUTfz7y5jN6QlFq8vWxrZ6bDgZdM+70Hw8auUEEWkHJw90WnVaJmr3GPmvR+Kh3I7+QWZudFrPoO1XyiJFhGpJBrO7W7rZphteYdyl5aXF8T3gMFPw92r4NbfoO8DENnGJPHbfoVv74GkJaaXuu/9lRuPSG3mFwwNOpl2WXujF71hRrDUa2mmXIhI9eH8Qqw6rRW96XvIPQoRjSGux4nHnUO6131V/mKkIiJyWkqi3Sk73SSvUPlJ9PEcDmjQEQY8BGMXw53LYeBjZmksgD73mkrgIlJ54ovWXt+1sPSPOXYIFr1u2v3/ZYqUiUj14ZoTXY2SaOcIs46jT76MVfMBEBBupojsWlC1sYmI1BJKot1p049QmAf1W9tbwKt+S+gzHm6ZAw/vUy+0SFVwJtFl6Yn+/SXIPQIxHdxTQ0FE3Ms1J3qPWQfebkf3FX9Z/9eh3E4+fmY5S1CVbhGRSqIk2p0qWpW7Mvj4n/ybahFxL2dxsf0bTA/zmWTshaXvmPaAR8wUDRGpXkIbgMPLfEF+NNXuaGDNF2YJzYbdoF7zU5/nHNK9/mtTlFRERNxKn9rcJecIbP3FtKtTEi0iVSO4PtRvZdpJS858/m//B/lZ0OjskkvUiEj14e0DoUXToapDhe7VRVW5z1Q/oWlfCI4y9Ra2zan8uEREahkl0e6y+ScoyIF6LSC6nd3RiIgdSjsv+vAuWPG+aQ98RKNFRKqzCOeQ7kR749i/CfauNCsBOHuaT8XLG9pdatoa0i0i4nZKot3l+KHc+kAsUjs1PtdszzQvet6zZnho0/NMj5GIVF+u4mI290Q7C4q1OB+C6535fGeivfE7yMuqvLhERGohJdHukJsJW2aZtoZyi9ReznnRyX+e+kPr/s2w6hPTHvho1cQlIuXnKi5mYxJdWAhrPjftTqVcCq/R2RDWyBQvdH5GERERt1AS7Q5bZpm5jXWaQExHu6MREbtENDbzJwvzYM+Kk58z9xmwCqHVUGjUrWrjE5Gyc/ZEp9m4zFXiQrPMln8YtBpSusd4eUH7y0xbQ7pFRNxKSbQ7aCi3iID59+/sjd616MTje1fDuq9Me8DDVReXiJRfRLzZ2tkT7RzK3XY4+AaW/nHtLzfbzT+aAqgiIuIWSqIrKi/LFBUDDeUWkePmRZ8kif71KbNtPxJi2lddTCJSfq450TYVFsvLKv6y/lRrQ59Kg05QtznkZ8OmH9wfm4hILaUkuqK2/gJ5mWbOVGwXu6MREbs5e6KTlkJhQfH+pKWw5SdweEO/f9kTm4iUnTOJzk6H7Iyqf/7NP0JOhvmcEX9u2R7rcBQXGNOQbpHKcWgH7NtodxRSxZREV5SGcovI8aLagn+4KeaTurZ4/+wnzLbzlVC/hT2xiUjZ+YdCQIRp2zGke1XR2tAdrjDznMvKmURvnQ3HDrkvLhGBrDR4pz+83RcObrM7GqlCSqIrIi8bNv1o2hrKLSJg1meNO9u0nfOit8+Fnb+Bly+c90/bQhORcrKrQnfmAdhaVFm7rEO5naISIKqdKXi48Vv3xSYisPxdyDoMBTkw7zm7o5EqpCS6IrbPMb1NobHQUFV2RaRI455mm7gILAtmP2nud7uhuEiRiHiOCGcSXcXzotd9BYX50KAzRLYu/3U6FPVGr/nCLWGJCKYzbclbxffXfAYHttgXj1QpJdEV4RrKfUn5hliJSM0Uf1wSvekH2LMcfAKhz332xiUi5eMqLlbFPdHOqtwdS7k29Km0G2G2O3+DI6kVu5aIGKunwdFUsx57i/PN8pXznrU7KqkiyvzKKz8XNn5v2m0vtTUUEalmYruAt595c/2+KHHucSuERtsbl4iUjx3DuQ9sNV/AObyhw+UVu1bdptCwq/mQ7+wAEJHyKyyABa+ads+xMPAR017zBezfZF9cUmWURJfXjnmQkw4hMRDXw+5oRKQ68Q0ortafsQf8w6DX3fbGJCLl5+yJTkuquudc85nZNh8AIVEVv56qdIu4z8Zv4dA2U3Swy7VmObmEiwFLvdG1hJLo8lo/w2zbDNNQbhE5kXNeNEDPOyGorn2xiEjFOGsZVFVPtGXB6qKq3BUdyu3U7jLAAUmLq/bLAJGaxrLg95dN++y/g3+Iafd70GzXTod9G2wJTaqOsr/yKMiDjd+Ztqpyi8jJNOlttoF14Zzb7Y1FxM0mTpyIw+EocUtISLA7rMrj7Ik+kmw+A1S2pCVweCf4hUDCRe65ZlgsNO5l2uumu+eaIrXRzt8g+Q/wCYCzby3eH9MB2lwCWDD337aFJ1VDSXR57JhvytkH1YfG59odjYhUR80HwkUvwDVfQECY3dGIuF27du3Yu3ev6/b777/bHVLlCY4ydQ6sQjiyt/Kfz1lQrM0l4Bfkvuu2LyowpiHdIuXn7IU+6xoIiSx5rN8EwGFGrKasreLApCopiS4PZ1GONsPMmrAiIn/lcED3m00xH5EayMfHh5iYGNetfv36dodUeby8IKyhaVf2UOj8HLO0FUDHUe69dtvhplDZ3lWmcJmIlM3e1bBtNji8zFStv4puC+0uNe156o2uycqURJ9p+FZ2djZjx46lXr16hISEMHLkSFJTa9hSCgX5ppgAaCi3iIjUWlu2bCE2NpZmzZpx9dVXk5h4+jWUc3JyyMjIKHHzKFW1zNWWnyE7DUIbQNO+7r12cH1o1s+0NaRbpOwWFlXkbneZqXp/Muc9CDhgwzcm6ZYaqcw90acbvnXPPffwzTff8PnnnzNv3jySk5MZMWKEWwO23a4FcOygmefonPMoIiJSi/To0YP33nuPH3/8kTfffJMdO3bQp08fjhw5csrHTJo0ifDwcNctLi6uCiN2A1dxsdN/WVBhzqHcHa6onNFuzuWy1nxhCiSJSOkc3mWKhsHpV9yISiiuhq+50TVWmZPoUw3fSk9PZ/Lkybz44osMGDCArl27MmXKFBYuXMjixYvdHrhtnEO5Ey4Cb197YxEREbHB0KFDueKKK+jYsSODBw/m+++/Jy0tjc8+++yUj5kwYQLp6emuW1KSh1WIroqe6GOHTE80QKcxlfMcCReZ+d0HNkHqusp5DpGaaNF/wCowy8416HT6c8/7pxnyvek7SP6zauKTKlXmJPpUw7dWrFhBXl4egwYNcp2bkJBAfHw8ixYtcl/EdiosMEMzANpeamsoIiIi1UVERAStWrVi69ZTz7P19/cnLCysxM2jhBf1nFfmnOj1M6AgF6LbQ3S7ynmOgHBoeYFpq8CYSOlkHoA/PjTtXuPOfH5kKzOaBNQbXUOVKYk+3fCtlJQU/Pz8iIiIKPGY6OhoUlJSTnlNj5ojlbgYMveZhdWbnWd3NCIiItXC0aNH2bZtGw0aNLA7lMpTFT3Rq9y8NvSpHF+lW0O6Rc5s6X8hPwsadC59rYK+D5je6M0/wu4VlRqeVL0yJdHlGb51Jh41R0pDuUVERLjvvvuYN28eO3fuZOHChVx22WV4e3tz5ZVX2h1a5XHNid5dOYnnoR2QtBhwFPdgVZZWQ8A3CNJ2wZ4/Kve5RDxdbqZJogF6jzOrb5RG/RbQsWhaxtxJlRKa2KdCS1wdP3wrJiaG3Nxc0tLSSpyTmppKTEzMKa/hMXOkCgthw0zTVlVuERGpxXbv3s2VV15J69atGTVqFPXq1WPx4sVERkae+cGeyrnEVV4mZB12//XXfG62zc6DsEru0fcLhtYXmraGdIuc3h8fmH/zdZuZtdvL4rz7zbJyW2dB0rLKiU9sUaEk+vjhW127dsXX15fZs2e7jm/atInExER69ux5ymt4zByp3cvgyF7wDyteHkJERKQWmjZtGsnJyeTk5LB7926mTZtG8+bN7Q6rcvkGQHCUaae7+Qt/yyquyt2xkgqK/ZWzevC66abmi4icqCAPFr1u2ufeVfaK+XWbQeeiETpzn3FvbGKrMiXRpxu+FR4ezk033cT48eOZM2cOK1as4IYbbqBnz56cc845lRV/1Vk/w2xbDwUff1tDERERERs450W7u7jYnhVwaJsZYt1mmHuvfSotBoJ/uOkgSKwhBWBF3G3tdPOlWXAUdLqqfNfoez94+cC2X019JakRypREn2n41ksvvcTFF1/MyJEj6du3LzExMUyfPr1SAq9ShYXF86E1lFtERKR2qqziYquLCoolXAT+Ie699qn4+Bcn7BrSLXIiy4IFr5j2ObeZ0SjlUacJdL7atOeoN7qm8CnLydOmTTvt8YCAAF5//XVef/31CgVV7ST/ARl7wC/ErA0nIiIitY+ruJgbe6IL8oqT2Koayu3UfgSs/Mh0FAx9TkVTRY63ZRbsWwd+odDtpopdq+99sPJj2DEPdi6AJr3cE6PYpkJzomsN51DuVoPBN9DWUERERMQmrp5oNybRW3+BYwfNcNGqrrnS9DwIqm+ef8e8qn1ukepuwctm2+16CIyo2LUi4uGsa0xblbprBCXRZ2JZGsotIiIiEF60DKc750Q7h3J3uAK8yzRAsOK8faDdpaa9tgZMvxNxl6RlsGsBePnCOXe455p97gVvP9j5G+yY755rim2URJ/J3pWQlmiKfbQ43+5oRERExC7unhOdnQ4bvzftjqPcc82yclbp3vAN5GXbE4NIdePshe44GsJi3XPNiDjocq1pz5lUOevNS5VREn0mzl7olueDX5C9sYiIiIh9nHOiM/e5J+Fc/zUU5EBkAjToVPHrlUfcORAaCzkZZmi5SG23fzNs/M60e/3DvdfuPR68/SFxoaZQeDgl0adTYij3pbaGIiIiIjYLrGNGpoEpOFpRq4qGcnccDQ5Hxa9XHl5epsAYqEq3CMDCVwALWl8Eka3de+3whtD1etOe84x6oz2YkujTSV0Lh7aDTwC0vMDuaERERMRODkfxvOiKFhdLS4Jdv5t2hysqdq2Kcg7p3vwj5GbaG4uInTL2Fn+51Xtc5TxH73tMbpG0xKwdLR5JSfTpOHuhWwyqunUbRUREpPpyzouuaHGxNZ+ZbZM+Zq6knWLPgjpNIe8YbPrB3lhE7LT4DSjMg/hzIe7synmOsAbQ7UbTnqu50Z5KSfSpWBasm2HaGsotIiIi4J7iYpZVcii33RyO4t5oDemW2iorDZZPMe3K6oV26jUOfAJh9zLVIvBQSqJPZd8GOLjFlKJvNdjuaERERKQ6iHDDcO69q+DAJjOks+0l7omropxJ9JZZkHXY3lhE7LD8Xcg9AlFtK38aZ2g0dL/JtDU32iMpiT4V51Du5gMhIMzeWERERKR6cMecaOfa0K2HQkB4xWNyh+i2ENnGDGV1ViYWqS3ysmHxm6bd6+6qKfTXa5wpVJj8B2z+qfKfT9xKSfSpuKpyD7c3DhEREak+nEl0eedEF+TDmi9Mu+MY98TkLh00pFtqqVWfmKXrwhoVj8qobCGRcPbfTXuueqM9jZLok9m/CfZvAC9faD3E7mhERESkunDOic7YA4WFZX/89jnmw3pQPWgx0L2xVVS7oqWuts+Do/vtjUWkqhQWwMJXTbvnWPD2rbrnPvdu8A02Uzw2fV91zysVpiT6ZNbPNNtm/cyakCIiIiIAYbHg8IKCXMgsR6LpHMrdfmTVflgvjXrNTaVuqwDWz7A7GpGqseEbs6RtQAR0ubZqnzu4HvS41bTnTCrfF3NiCyXRJ6Oh3CIiInIy3r4Q2sC0yzovOucIbPjWtKvbUG4nV5Xu6fbGIVIVLAsWvGLaZ99iz5K2594FfqGQugY2flv1zy/loiT6rw5uM3/EXj6QcJHd0YiIiEh1U97iYhu+gfwsqNcCGnZxf1zu0O4ys01cCOl77I1FpLLt/M0U9vIJLO4RrmpBdeGc20x77r/VG+0hlET/lbMXumlf80ctIiIicjznvOiyFhdbfdza0FVR/bc8whtB/Lmmve4re2MRqWy/v2y2Z10DwfXti6PnWPAPg33rYMPX9sUhpaYk+q80lFtEREROx7VW9O7SPyYj2RTsAug4yv0xuVP7ogJjqtItNdne1bBtNji84dw77Y0lsA6cc4dpz31WvdEeQEn08Q7tgL0rTcGQhIvtjkZERESqI2dPdFmGc6/5HLAgvifUaVIZUblP20vNZ6HkP8w0N5GayDkXut1l1ePf5Dm3g3+4WSFovUaBVHdKoo+3oagqd5Pe9g7pEBERkeqrPHOiV39mth1Huz8edwuJhKbnmfY6FRiTGujwzuK/7V532xqKS2BEcY/43H+bpbek2lISfTwN5RYREZEzcSbRpZ0TnbIWUteCtx+0u7TSwnIrVemWmmzhf8AqhOYDoEFHu6Mp1uM2s9TWgc36t1fNKYl2SkuEPSsAByQMszsaERERqa6cw7mz08yyVWeyeprZthps5j56gjbDwMsX9q2H1PV2RyPiPpkH4M+PTLvXOFtDOUFAWHFv9Lx/Q0G+vfHIKSmJdtrwjdk2PhdCo+2NRURERKqvgDAICDftMy0DVVgAa74w7eq6NvTJBEZAy/NNW0O6pSZZ+l+z1FzsWWY1nuqmx23my7aDW2HtF3ZHI6egJNpJQ7lFRESktEo7L3rHfDiy1wzRdCalnsI5pHvNF2BZ9sYi4g65mSaJBtMLXR2XmvMPhXP/YdrznlVvdDWlJBrMshNJS0y7jYZyi4iIyBmUNol2rg3dfgT4+FduTO7Wagj4BMLhHZD8p93RiFTcHx9A1mGo27x6f+Y/+xYIqgeHthf/HyLVipJoKB7KHXcOhMXaG4uIiIhUf8550acrLpabCeuLVv7wpKHcTv4h0HqoaWvNaPF0BXmw6HXTPvcu8PK2N57T8Q8prho+71kTu1QrSqJBQ7lFRESkbCKcPdG7T33Oxu8hL9OsQRt3dpWE5XbOId3rvoLCQntjEamItV+akSPBUdDpSrujObPuN0NwJKTtglWf2B2N/IWS6COpsGuhaVfnYR0iIiJSfTh7ok83nNtZlbvj6Oo597I0WgwC/zDI2FM89U3E01gWLHjFtM+5HXwD7I2nNPyCi6uHz3se8nNtDUdKUhK9YSZgQcNuxd8qi4iIiJxO+Bl6oo+kwrZfTbvj6KqJqTL4BkDCxaatSsHiqbb8bJZr8wuFbjfaHU3pdbsRQqIhPRFWTrU7GjmOkmgN5RYREZGycibRGcknr5679guwCqFRd6jXvGpjczfXkO4ZqhQsnun3l8222/Vm+TZP4RcEve8x7d9egPwce+MRl9qdRB/dD7sWmHbbS+yNRURERDxHSDR4+YJVYJaw+itnRV1P7oV2anaeqRR87ADsnG93NCJlk7QUEheaf6/n3GF3NGXX9XoIiTFTR/780O5opEjtTqI3fmu+JW7Q2RT9EBERESkNLy8Ib2jafx3SvW8j7F0FXj7QbkTVx+Zu3r7FI/ZUpVs8jXMudKfRnrkKj28g9LnXtH97EfKy7Y1HgNqeRGsot4iIiJTXqdaKdhYUa3kBBNer2pgqi3NI94ZvNKRUPMf+zbDxO8AB595tdzTl1+VaCI01Bf7++MDuaITanEQfOwQ7ioYkKYkWERGRsjpZEl1YCKs/N+2Oo6o+psoS3xNCG0B2OmydbXc0IqWz8BXAgoSLILKV3dGUn28A9C3qjf79RcjLsjceqcVJ9MbvzDym6A6eX/BDREREqp5zmau045LoXQsgYzf4h0OrofbEVRm8vKHdZaatId3iCTKSYVVRbQLnUlGe7Ky/QVgjU4NhxXt2R1Pr1d4kWkO5RUREpCIiTrLMlXMod7vhnrEWbVm0v9xsN30PuZn2xiJyJovfgMI8aNwL4rrbHU3F+fhD3/tM+/eXIPeYvfHUcrUzic46DNvnmna7S+2MRERERDyVsyfaOZw7LwvWzzTtjmPsiakyNewCEY0h7xhs/snuaEROLSsNlr9n2jWhF9qp89UQHg9HU2H5u3ZHU6vVziR60w/mm6motlC/pd3RiIiIiCcKP64n2rLM54ucDLM/vqe9sVUGh6O4wJiGdEt1tnwy5B4xn/Vbnm93NO7j4wfn3W/aC17WiBAb1c4kWkO5RUREpKKcPdG5R80oN9fa0KPMElg1kTOJ3jLLFBkTqW7ysmHxW6bd627z5U9N0ulKszRv5n5Y9j+7o6m1auj/8KeRnQ7bfjVtJdEiIiJSXr6BEFTftPeuhK2/mHbH0baFVOmi20H91lCQU7R0kEg1s+oTyNxnRoQ4v/SpSbx9oa+zN/oVyDlqbzy1VO1Lojf/BAW5UL8VRCbYHY2IiIh4MmdxsQWvQmE+NOgMka1tDalSORzQoajAmIZ0S3VTWAALXzXtnmNNwlkTdRwDdZrCsYOw7B27o6mVal8SffxQ7po2vENERESqlnNI9/Y5ZtupBhYU+6t2I8x22xzIPGhvLHbJy4LExbDodfjiJnP77UUzzD0j2cyRl6q34Rs4tB0C60CXa+2OpvJ4+8B5/zTtBa9AzhF746mFKpRE//vf/8bhcDBu3DjXvuzsbMaOHUu9evUICQlh5MiRpKamVjRO98g5Yv5zAw3lFhERkYoLjy9uO7xr5vDRv6rfAhp0AqsANnxtdzSVr7AA9m2APz+Cb8bBW33gmYbw7mD46V+w9gtzm/04TL0cXmwDzzWD9y6GHyeYxyWvNHN1pfJYlim2BXD2LeAXbGs4la7DFVCvhanHsORtu6OpdXzK+8Bly5bx9ttv07FjxxL777nnHr777js+//xzwsPDufPOOxkxYgQLFiyocLAVtuVnM4enbjOIbm93NCIiIuLpnD3RAM0HQEiUfbFUpfYjYe8qWPMldLvR7mjcKyMZdi+HPSvMLXmlqfT8V8FR0KibWfrL4QUpayF1HRzcAlmHYOdv5ubk8DarwkS3M59Do9tDTHsIbaDRke6wYz4k/wk+gXD2rXZHU/mcvdHT/w7znjV5TkwHiOlotlFta95a9dVIuZLoo0ePcvXVV/POO+/w1FNPufanp6czefJkPv74YwYMGADAlClTaNOmDYsXL+acc85xT9TlpaHcIiIi4k7OOdFQO4ZyO7UbAbMehV0LTNIZFmt3ROWTnWESL2fCvGcFHNl74nm+wRB7lkmYG3Y1yXNYw5N/nszLgv0bi5Pq1LWQsgay08z+/RtLzicPrFucWMe0N+3INkqAysrZC93lbxBcz9ZQqkz7kWakw455kLTE3Jwc3qY+w/GJdUwHCKprX7w1SLmS6LFjx3LRRRcxaNCgEkn0ihUryMvLY9CgQa59CQkJxMfHs2jRopMm0Tk5OeTk5LjuZ2RklCekM8vN1FBuERERca+6zc3WLxRaX2hvLFUpIg7izoGkxbBuBvS8w+6IzqwgzyS1xyfM+zcBf5m/7PCCqHYlE+b6rU3PX2n4BpqEO/as4n2WZb5scCbVqUUJ9oHT9FrXa1GcVEd3MNuwWHUEnczeVWb1HYe3KShWW3h5w9++Mn9HKauLbmtg72rzd7Vvvbk5l98DU7X8r4l1RLz+rsqozEn0tGnT+OOPP1i2bNkJx1JSUvDz8yMiIqLE/ujoaFJSUk56vUmTJvH444+XNYyy2/oL5B2DiMamcqaIiIhIRUW3hUteM5Vy/YLsjqZqtR9pkui1X1a/JNqy4PDOkgnz3lWQf5J5yeHxJmFu1M0kzQ06uX8+rcMB4Q3NrdUFxfvzsk3PtDOpTllj2lmH4cAmcyvRa12neCh4dDuTZEcmmMS9NltQVJG73WVmDeXaxMsbohLMreMos8/5pU3KmuLkeu9qSNsF6Unmtun74msEhBcl1ccl1pGta251czcoUxKdlJTE3XffzaxZswgIcM8QkwkTJjB+/HjX/YyMDOLi4k7ziHJaN8NsNZRbRERE3KkmVwE+nbbD4cd/wp7lJmG1M3k5dqhkwrxnhVn+56/8w0smzLFdIDS66uN18g2A2M7m5mRZZki5K6ku6r0+sMUk1yf0WntBWCMzhDk40qxdXqJdv3gbXL/mFdw6vBPWTTftXnfbGkq1cfyXNq2HFO/PSiv6uzqux3r/BshOP/HvytsPotoUJdWdirbtwT+0al5DYaHpAM09akYU5xwx29xMU6PA2c45as7pdXeVDlUvUxK9YsUK9u3bR5cuXVz7CgoKmD9/Pv/5z3/46aefyM3NJS0trURvdGpqKjExMSe9pr+/P/7+/uWLvrTyssz60ABtL63c5xIRERGpDUKjoUkfMx9zzRdw7l2mpzc/12wLirYn3XfcsRP25ZhCsPnO2/HnHLe/4LjjJ0uYvXzNB39nwtywmyku61XNV3h1OMyw7bBYaHl+8X5Xr/VxQ8JT1pphu+mJ5lYaPoEmwQ6uVzK5drWPS8SDipJuOzqgCvIhP8u87tNt134JViE0HwgNOp75urVZYAQ06WVuTvk5ZlqDM7F23nIyzOiNvauAj4rPr9vsuOHgHc3PPCTa/Ds8VbKbU5QI5x4tTopzjx63/ySJcV5m2V5bx9HVN4keOHAga9asKbHvhhtuICEhgX/+85/ExcXh6+vL7NmzGTnSLPGwadMmEhMT6dmzp/uiLquts80vIqyR+fZRREREaoR1yelc9sZCAn29CfD1IsDXmwAfbwL8vAnwKbrv61V03Nz8j79fdE6gnzf+PsXXKD7fy/W4AF8v/Ly9cGhEW7H2I00S/euT5manei2KkuWihDmmPfhUckdNVTplr3UKpO+GYwcg8wBk7jdfKmQeKNq336znnbm/6IuHrHIk3fUhqN5xSXa9kgm3j99JktxSJMAn3WabHsjC/LL9fHqPK9v5Yvj4m0T4+C8gCgvN0G/XcPCiXusjyWYd7kPbiws2gxkNYRVWTnwOL/ALKboFg/9x7eO3AWGV8/ynUKYkOjQ0lPbtSy4NFRwcTL169Vz7b7rpJsaPH0/dunUJCwvjrrvuomfPnvZW5lZVbhERkRopO6+A3PxCcvMLSc+q/OdzOCDAxyTdxUl6UaLuV5x8BxYl5oG+3vg77xed89fjzms47wf6euPv44WXlwd8Zmk7HOY8DUdTS+739jcfzn38wSfADA31CTDJlk+A2V/iHOd5f9nnfdyxk+7zM/fDGpj5wrWNw2Fee1iDM59rWab3L/NAUZK9/7hE+8DJ2/lFya1zHq1dvP3NvG/fQPN7/+u2UXczKkLcw8sL6jY1t7aXFO/PPFAysU5ZAwc2l0ygfYOLEtvjE97jkl3/kOLjfqFnPtcnoFrmb+VeJ/pUXnrpJby8vBg5ciQ5OTkMHjyYN954w91PU3r5ObDpB9NWVW4REZEapX3DcH7/Z3+y8wrJzisouhW18wvIyi0gO7+QnKJjWccfP/4x+ea+Ob+AnKJjWUXHC4sKOFsWZBXtr2zH96AH/iXRdrYDfExi7ufthbe3A18vL7y9HPh4OfDx9sLHy4G3lwNfbwfeXl5F+x1F53jh4+047pxyPNY7BO87V+KbdxQv3+MS5mr4obfWczjMfFb/UJMcnYllmaG1J+3Z/ksiXpj/l+Q2wPRg+waAb9DJE9/Sbn0Cqv8Q/NoiuD40729uTrnHzJxq/xDzu/byti++KuSwLMs682lVJyMjg/DwcNLT0wkLc0O3/KYf4ZPRZiH7e9brH6GIiJSZ29+bxKN+ppZlkVdgmUQ7tyj5zi9KyouSdGcynpVb4Eqys4uO/XWfs52VW0DOX47n5lfSkMgq4Eyyfb3NsHdfby98fcx9X6/j2q7jJll3ts35JY+Zc4sf5+vjha/X8eeatk/RY/z+0jbHSradz+8RPf3VSGGhRW5BIXkFheQVWOQVmBEgeQXmb9bPx8vcvM3Wt+iLGE1/EE9Rlvclt/dEVzvOodxtLlECLSIiImXmcDjw83Hg5+NFWEDlLvlSUGiV6AE3iXlhicQ7+7hedee+vAKL/IJC8gstCgot8gsLyS+wyC+0ivaZxKeg6H6Jc49r5xUUHndO8WOL2xZ5hYWcrAvG+VzZeZ7xRYCXA1dC7XN8on6q9l8S+OK2A29HcbLo5XDgcIAD8PJy4ABwgAMHXg6KjhWd4zDHHY6ixxW1Ha5rOIqOFbf/v727i4nibPsA/t+ZZRceBCwYPjaCpX1NbBWpFSFKkx5IShpjY5pq29CW6Cm0IEkDtkEPWqVqbIhIoPSgR7W1B7UfPmnfUEowJioUSlNTizYlltQANWldwLCwM/dzsDv7AWhX3Z173fn/ks3OJ143s8zlNfc9s0v9G8axM4pbY9oocgPzmo5574J5/8sbOu/1F8kh+2r63fe72WzwFdUhhbXv3QaHXfUX3bbgOnVxIR767rSHXCBZsJ2q+I6DqvrejZEUxsuuKFAUwK4oUBUERlcoSsi2IfurIcvv5UKAcUw8ocfAG/wdG8dmzjhuXn3BuuCx9Cw8jsa2/uWKzYZUpx2pTjvSku1IdajBaWO5Mzi9zGmHyotI9yWxi2jvHDDyX980h3ITERFRnFOV4H+G45luFNohxXloYbCwmAsUC15fwb5UoRA6PRdSyHl1HXPe0O10zPmLDt+64L5ePVg4evVgYWJcAAhrgwA8Xl+BQnfPGOqf5O+k8viPaSgR+jv2yIgyOhQbwopwxQbYQwp3AIHPt1EI38M1B1OlJKn+glrFsmQ7Uh2+4npZcrDQXhYoulUscyYh1akGt3EE1zvs1uuojO8z9P0aPesbo5+aDRRIfLAZERFRAmpvb8fRo0cxPj6O4uJitLW1obS0VHZYZAJFscGh2ODAg/Of52Bvra/X1SjW/236dhcFQnsFdSEgBCDge9f90xAIWQf/Ol91JYSAwML1/mn//nrItG+5CPs5xj6KzbZoCH1g3r/M4R9enRTS6xvobbcvmF8wbfT2hq5bqidTCBF2kcToMTUudPjmNcx5RVjRGb5dcN95TYcn0IOrBXpyF25vjKDQdAFN+EZR6CI4emLhy6uLwIUgTQSX344ufEUyNAC4t4sujpDfdegtDWG97aG3QIT0yof+3gM9+aoaOK6aLjDj8WLao2HaM48Zj4ZpjxfTHq9/eXB6XvO10xjJcmP6npoTRlWMURa+0RSKzTev+IdLhM4bIy2UsNEXNihKcN7YLvw9OJIjbN6//bFdxViVZd53oCd2EX3ZGMq93TI3uRMREZnh1KlTaGhoQGdnJ8rKytDa2orKykqMjIwgOztbdnhEi/iG9foeykaxYbPZAgXffxyyo7k7QvguWnh1Hboe/v5vxTmAxcPVQy9iqPFzb7jHq2F61nvHQnva4/VtM+cvzGeXLsyNURyaLnzXFyCv+93s20gS+8Fis27gyv8D2Wt8XwpORER0Dx6kh2CZpaysDJs2bcKJEycAALquIz8/H6+//jqampr+dX/+TomIHmzzmo4Zjxez83pg5ITuv6ig+y9KBEZaLJgPe4cxHxx94ds/ODIjbB4Cuh78NwCBLf+34r6fWcEHixmS04H1O2VHQURElFDm5uYwODiIffv2BZYpioKKigqcP39+yX08Hg88nuBNkW63O+ZxEhFR7CSpCpY/aEMOouTBuZGFiIiI4sKNGzegaRpycnLClufk5GB8fHzJfVpaWpCRkRF45efnmxEqERFR1LGIJiIiopjbt28fbt68GXiNjY3JDomIiOieJPZwbiIiIoq6FStWQFVVTExMhC2fmJhAbm7ukvs4nU44nU4zwiMiIoop9kQTERHRXXE4HNi4cSN6enoCy3RdR09PDzZv3iwxMiIiothjTzQRERHdtYaGBlRXV6OkpASlpaVobW3FzMwMdu/eLTs0IiKimGIRTURERHftxRdfxF9//YX9+/djfHwcTzzxBL799ttFDxsjIiJKNCyiiYiI6J7U1taitrZWdhhERESm4j3RRERERERERBFiEU1EREREREQUIRbRRERERERERBGKu3uihRAAALfbLTkSIiIiHyMnGTmK7h/zPRERxZO7yfVxV0RPTU0BAPLz8yVHQkREFG5qagoZGRmyw0gIzPdERBSPIsn1NhFnl9V1Xcf169eRlpYGm8123z/P7XYjPz8fY2NjSE9Pj0KEDxa2n+1n+9l+tv/+2y+EwNTUFFwuFxSFd0JFQzTzPT/rbD/bz/az/Wy/mbk+7nqiFUXBypUro/5z09PTLfnBMrD9bD/bz/ZbVbTazx7o6IpFvudnne1n+9l+q2L7zc31vJxOREREREREFCEW0UREREREREQRSvgi2ul04sCBA3A6nbJDkYLtZ/vZfraf7bdm+63E6sea7Wf72X62n+03t/1x92AxIiIiIiIioniV8D3RRERERERERNHCIpqIiIiIiIgoQiyiiYiIiIiIiCLEIpqIiIiIiIgoQgldRLe3t+Phhx9GcnIyysrK0N/fLzskU7S0tGDTpk1IS0tDdnY2duzYgZGREdlhSfPee+/BZrOhvr5ediim+fPPP/HKK68gKysLKSkpKCoqwg8//CA7LFNomobm5mYUFhYiJSUFjz76KN555x0k8jMUz549i+3bt8PlcsFms+GLL74IWy+EwP79+5GXl4eUlBRUVFTg6tWrcoKNgTu1f35+Ho2NjSgqKkJqaipcLhdee+01XL9+XV7AFFVWzfUA830oK+Z6gPneSvmeuT6+cn3CFtGnTp1CQ0MDDhw4gKGhIRQXF6OyshKTk5OyQ4u5vr4+1NTU4MKFC+ju7sb8/DyeeeYZzMzMyA7NdAMDA/jggw+wfv162aGY5u+//0Z5eTmSkpLwzTff4JdffsGxY8fw0EMPyQ7NFIcPH0ZHRwdOnDiBy5cv4/Dhwzhy5Aja2tpkhxYzMzMzKC4uRnt7+5Lrjxw5guPHj6OzsxMXL15EamoqKisrMTs7a3KksXGn9t+6dQtDQ0Nobm7G0NAQPv/8c4yMjOC5556TEClFm5VzPcB8b7BirgeY762W75nr4yzXiwRVWloqampqAvOapgmXyyVaWlokRiXH5OSkACD6+vpkh2KqqakpsXr1atHd3S2efvppUVdXJzskUzQ2NoqnnnpKdhjSbNu2TezZsyds2fPPPy+qqqokRWQuAOL06dOBeV3XRW5urjh69Ghg2T///COcTqf45JNPJEQYWwvbv5T+/n4BQFy7ds2coChmmOvDWTHfWzXXC8F8b+V8z1wvP9cnZE/03NwcBgcHUVFREVimKAoqKipw/vx5iZHJcfPmTQBAZmam5EjMVVNTg23btoV9Dqzgq6++QklJCXbu3Ins7Gxs2LABH374oeywTLNlyxb09PTgypUrAICffvoJ586dw7PPPis5MjlGR0cxPj4e9neQkZGBsrIyS54PAd850WazYfny5bJDofvAXL+YFfO9VXM9wHzPfB/EXL9YrHO9PSY/VbIbN25A0zTk5OSELc/JycGvv/4qKSo5dF1HfX09ysvLsW7dOtnhmObTTz/F0NAQBgYGZIdiut9//x0dHR1oaGjAW2+9hYGBAbzxxhtwOByorq6WHV7MNTU1we12Y82aNVBVFZqm4eDBg6iqqpIdmhTj4+MAsOT50FhnJbOzs2hsbMTLL7+M9PR02eHQfWCuD2fFfG/lXA8w3zPfBzHXhzMj1ydkEU1BNTU1uHTpEs6dOyc7FNOMjY2hrq4O3d3dSE5Olh2O6XRdR0lJCQ4dOgQA2LBhAy5duoTOzk5LJNXPPvsMH3/8MU6ePIm1a9dieHgY9fX1cLlclmg/3d78/Dx27doFIQQ6Ojpkh0MUVVbL91bP9QDzPfM9LcWsXJ+Qw7lXrFgBVVUxMTERtnxiYgK5ubmSojJfbW0tzpw5g97eXqxcuVJ2OKYZHBzE5OQknnzySdjtdtjtdvT19eH48eOw2+3QNE12iDGVl5eHxx9/PGzZY489hj/++ENSROZ688030dTUhJdeeglFRUV49dVXsXfvXrS0tMgOTQrjnGf186GRVK9du4bu7m72QicA5vogK+Z7q+d6gPme+T6Iud7HzFyfkEW0w+HAxo0b0dPTE1im6zp6enqwefNmiZGZQwiB2tpanD59Gt9//z0KCwtlh2SqrVu34ueff8bw8HDgVVJSgqqqKgwPD0NVVdkhxlR5efmirzi5cuUKVq1aJSkic926dQuKEn5qU1UVuq5LikiuwsJC5Obmhp0P3W43Ll68aInzIRBMqlevXsV3332HrKws2SFRFFg91wPWzvdWz/UA8z3zfRBzvfm5PmGHczc0NKC6uholJSUoLS1Fa2srZmZmsHv3btmhxVxNTQ1OnjyJL7/8EmlpaYF7ITIyMpCSkiI5uthLS0tbdD9YamoqsrKyLHGf2N69e7FlyxYcOnQIu3btQn9/P7q6utDV1SU7NFNs374dBw8eREFBAdauXYsff/wR77//Pvbs2SM7tJiZnp7Gb7/9FpgfHR3F8PAwMjMzUVBQgPr6erz77rtYvXo1CgsL0dzcDJfLhR07dsgLOoru1P68vDy88MILGBoawpkzZ6BpWuCcmJmZCYfDIStsigIr53rA2vne6rkeYL63Wr5nro+zXB+TZ37Hiba2NlFQUCAcDocoLS0VFy5ckB2SKQAs+froo49khyaN1b724uuvvxbr1q0TTqdTrFmzRnR1dckOyTRut1vU1dWJgoICkZycLB555BHx9ttvC4/HIzu0mOnt7V3yb766uloI4fvqi+bmZpGTkyOcTqfYunWrGBkZkRt0FN2p/aOjo7c9J/b29soOnaLAqrleCOb7hayW64VgvrdSvmeuj69cbxNCiOiX5kRERERERESJJyHviSYiIiIiIiKKBRbRRERERERERBFiEU1EREREREQUIRbRRERERERERBFiEU1EREREREQUIRbRRERERERERBFiEU1EREREREQUIRbRRERERERERBFiEU1EREREREQUIRbRRERERERERBFiEU1EREREREQUIRbRRERERERERBH6H8q++/cPEx9mAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "torch.save(model.state_dict(), \"final_model.pth\")\n", + "print(\"Model saved as final_model.pth\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o3eTykvUHZxZ", + "outputId": "fe85b3c8-54eb-4639-cf48-bec3a9f148c5" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model saved as final_model.pth\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "yX3stLpxH1nS" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git "a/Week16_\354\230\210\354\212\265\352\263\274\354\240\234_\354\225\210\354\230\210\354\235\200.pdf" "b/Week16_\354\230\210\354\212\265\352\263\274\354\240\234_\354\225\210\354\230\210\354\235\200.pdf" new file mode 100644 index 0000000..f7a3d51 Binary files /dev/null and "b/Week16_\354\230\210\354\212\265\352\263\274\354\240\234_\354\225\210\354\230\210\354\235\200.pdf" differ