From 6c019095950c6d918bc0d448d6ccfc06d151deb0 Mon Sep 17 00:00:00 2001
From: Hyeon Soo Kim <64349347+shawnhyeonsoo@users.noreply.github.com>
Date: Mon, 20 Dec 2021 21:05:25 +0900
Subject: [PATCH 01/26] add: clipmodel

---
 clipmodel.py | 128 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 clipmodel.py

diff --git a/clipmodel.py b/clipmodel.py
new file mode 100644
index 0000000..52301b6
--- /dev/null
+++ b/clipmodel.py
@@ -0,0 +1,128 @@
+import torch.nn as nn
+from transformers import AutoTokenizer, RobertaConfig, RobertaModel
+import torch
+import timm
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+from transformers import DistilBertModel
+import cv2
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+
+
+class CustomDataset(Dataset):
+    def __init__(self, texts, images):
+        self.tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert")
+        # self.tokenizer = AutoTokenizer.from_pretrained("klue/roberta-large")
+        self.texts = texts
+        self.images = images
+        self.transform = A.Compose([A.Resize(224, 224), ToTensorV2()])
+
+    def __getitem__(self, index):
+        t = self.texts[index]
+        single_im = cv2.imread(self.images[index])
+        single_im = cv2.cvtColor(single_im, cv2.COLOR_BGR2RGB)
+        # single_im = Image.open(images[index])
+        im = self.transform(image=single_im)["image"]
+        return t, im
+
+    def __len__(self):
+        return len(self.texts)
+
+
+class ImageEncoder(nn.Module):
+    def __init__(self, model_name, trainable):
+        super().__init__()
+        self.model = timm.create_model(
+            model_name, pretrained=False, num_classes=0, global_pool="avg"
+        )
+        for p in self.model.parameters():
+            p.requires_grad = True
+
+    def forward(self, x):
+        return self.model(x)
+
+
+from transformers import DistilBertConfig
+
+
+class TextEncoder(nn.Module):
+    def __init__(self, pretrained):
+        super().__init__()
+        self.model = DistilBertModel.from_pretrained("monologg/distilkobert")
+
+        for p in self.model.parameters():
+            p.requires_grad = True
+        self.target_token_idx = 0
+
+    def forward(self, input_ids, attention_mask):
+        output = self.model(
+            input_ids=input_ids,
+            # token_type_ids=token_type_ids,
+            attention_mask=attention_mask,
+        )
+        last_hidden_state = output.last_hidden_state
+        return last_hidden_state[:, self.target_token_idx, :]
+
+
+class ProjectionHead(nn.Module):
+    def __init__(self, embedding_dim, projection_dim, dropout):
+        super().__init__()
+        self.projection = nn.Linear(embedding_dim, projection_dim)
+        self.gelu = nn.GELU()
+        self.fc = nn.Linear(projection_dim, projection_dim)
+        self.dropout = nn.Dropout(dropout)
+        self.layer_norm = nn.LayerNorm(projection_dim)
+
+    def forward(self, x):
+        projected = self.projection(x)
+        x = self.gelu(projected)
+        x = self.fc(x)
+        x = self.dropout(x)
+        x = x + projected
+        x = self.layer_norm(x)
+        return x
+
+
+class CLIPModel(nn.Module):
+    def __init__(
+        self,
+    ):
+        super().__init__()
+        self.image_encoder = ImageEncoder("resnet50", trainable=True)
+        # self.image_encoder = ImageEncoder("xcit_tiny_12_p8_224_dist", trainable=True)
+        self.text_encoder = TextEncoder(pretrained=True)
+
+        self.image_projection = ProjectionHead(
+            embedding_dim=2048, projection_dim=512, dropout=0.1
+        )
+        self.text_projection = ProjectionHead(
+            embedding_dim=768, projection_dim=512, dropout=0.1
+        )
+        self.temperature = 0.07
+
+    def forward(self, text, image):
+        # Getting Image and Text Features
+        image_features = self.image_encoder(image)
+        text_features = self.text_encoder(
+            input_ids=text["input_ids"],
+            attention_mask=text["attention_mask"],
+            # token_type_ids=text["token_type_ids"],
+        )
+        
+        image_embeddings = self.image_projection(image_features)
+        text_embeddings = self.text_projection(text_features)
+
+        logits = (text_embeddings @ image_embeddings.T) * self.temperature
+
+        targets = torch.arange(len(text_embeddings), device="cuda")
+        tttt = F.log_softmax(logits, dim=1)
+
+        texts_loss = nn.CrossEntropyLoss()(logits, targets)
+        images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
+
+        loss = (images_loss + texts_loss) / 2.0  # shape: (batch_size)
+        return text_embeddings, image_embeddings
+        # return loss.mean()

From 35b8432b83829a9d4b07361d6da1d006d162ae12 Mon Sep 17 00:00:00 2001
From: Hyeon Soo Kim <64349347+shawnhyeonsoo@users.noreply.github.com>
Date: Mon, 20 Dec 2021 21:07:29 +0900
Subject: [PATCH 02/26] add: clip reranking baseline

---
 clip_reranking_example.ipynb | 191 +++++++++++++++++++++++++++++++++++
 1 file changed, 191 insertions(+)
 create mode 100644 clip_reranking_example.ipynb

diff --git a/clip_reranking_example.ipynb b/clip_reranking_example.ipynb
new file mode 100644
index 0000000..c4582a2
--- /dev/null
+++ b/clip_reranking_example.ipynb
@@ -0,0 +1,191 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0a9e9261-01a6-491c-a789-1087db739848",
+   "metadata": {},
+   "source": [
+    "### Reranking 예시"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a9621cd-aec4-42bd-91d7-596e467f4080",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from clipmodel import *\n",
+    "import cv2 \n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "CUDA_LAUNCH_BLOCKING=1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "311c31c3-2164-4bf4-a542-f0238cb7adaf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = torch.load('fashionclip_fn.pt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68723e83-85f7-40c2-a506-9d9faa4174ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Text, Image processor 정의 ### \n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"monologg/distilkobert\")\n",
+    "transform = A.Compose([A.Resize(224, 224), ToTensorV2()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83bc01cc-c38c-47ce-8278-c77977230675",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 예시 text, image 가져오기 ### \n",
+    "\n",
+    "baseline_dir = \"./data\"\n",
+    "image_dir = os.path.join(baseline_dir, \"cropped_train_img\")\n",
+    "text_dir = os.path.join(baseline_dir, \"train_label\")\n",
+    "images = sorted([os.path.join(image_dir, i) for i in os.listdir(image_dir)])\n",
+    "text_pre = sorted([os.path.join(text_dir, i) for i in os.listdir(text_dir)])\n",
+    "\n",
+    "val_text_dir = os.path.join(baseline_dir, \"cropped_img_selected/val_label\")\n",
+    "val_img_dir = os.path.join(baseline_dir, \"cropped_img_selected/val_img\")\n",
+    "val_text_pre = sorted(\n",
+    "    [os.path.join(val_text_dir, i) for i in os.listdir(val_text_dir)]\n",
+    ")[1:]\n",
+    "val_images = sorted([os.path.join(val_img_dir, i) for i in os.listdir(val_img_dir)])\n",
+    "\n",
+    "texts = []\n",
+    "print(\"Extracting text information!\")\n",
+    "for i in tqdm(range(len(text_pre))):\n",
+    "    with open(text_pre[i], \"r\", encoding=\"utf-8\") as f:\n",
+    "        te = f.read()\n",
+    "        texts.append(te)\n",
+    "\n",
+    "val_texts = []\n",
+    "for i in tqdm(range(len(val_text_pre))):\n",
+    "    with open(val_text_pre[i], \"r\", encoding=\"utf-8\") as f:\n",
+    "        te = f.read()\n",
+    "        val_texts.append(te)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9be7a5d2-ab3f-4382-ab6d-c2ea4e4e534e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### 예시: DALL-E에 들어가는 문장: \n",
+    "val_texts[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a06eb52-ba64-43e6-a1fa-774997a21a13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Image Inputs ###\n",
+    "### 예시: DALL-E가 위의 text에 대해 생성해내는 이미지가 5개라고 할때:\n",
+    "### transform으로 224 x 224, ToTensorV2 형식으로 변환, 하나의 tensor로 stack\n",
+    "test_images = []\n",
+    "for im in val_images[:5]:\n",
+    "    single_im = cv2.imread(im)\n",
+    "    single_im = cv2.cvtColor(single_im, cv2.COLOR_BGR2RGB)\n",
+    "    ima = transform(image=single_im)['image']\n",
+    "    test_images.append(ima.float())\n",
+    "test_images = torch.stack(test_images, dim = 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a05ed66-4a9d-49cc-819e-9c32f5cc040b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Text Input ###\n",
+    "input_texts = tokenizer(val_texts[0], padding=True, pad_to_max_length=True, max_length = 128, truncation=True, return_tensors = \"pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77f921de-56ca-4df2-b03f-eb26a6c30029",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = model.to(device)\n",
+    "input_texts = input_texts.to(device)\n",
+    "test_images = test_images.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e2e2918-e11f-4470-9e41-0bb4450c3265",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    model.eval()\n",
+    "    ### Input text 1개, DALL-E 가 만들어낸 test_images 5개 ###\n",
+    "    text_embeds, image_embeds = model(input_texts, test_images)\n",
+    "    lgits = (text_embeds @ image_embeds.T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5951653-f09f-4087-baef-d11e7cf4be24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Re-Ranking 결과 ### \n",
+    "probs = torch.nn.Softmax(dim=1)(lgits)\n",
+    "import matplotlib.pyplot as plt\n",
+    "print(f'Input Text: {val_texts[0]}')\n",
+    "### Sorting 통해 text랑 image사이 거리가 가장 가까운 순으로 출력 ### \n",
+    "for idx, prob in sorted(enumerate(probs[0]),key = lambda x: x[1], reverse = True):\n",
+    "    print(f'probability: {prob.item()}')\n",
+    "    tmp = Image.open(val_images[idx])\n",
+    "    plt.imshow(tmp)\n",
+    "    plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 092ea783e63021d3170985af32b8f49b2723d510 Mon Sep 17 00:00:00 2001
From: Hyeon Soo Kim <64349347+shawnhyeonsoo@users.noreply.github.com>
Date: Mon, 20 Dec 2021 21:15:24 +0900
Subject: [PATCH 03/26] Update clipmodel.py

---
 clipmodel.py | 46 +++++++++++++++++++++++++++++++++++-----------
 1 file changed, 35 insertions(+), 11 deletions(-)

diff --git a/clipmodel.py b/clipmodel.py
index 52301b6..2012d56 100644
--- a/clipmodel.py
+++ b/clipmodel.py
@@ -9,6 +9,7 @@
 from transformers import DistilBertModel
 import cv2
 import os
+
 os.environ["TOKENIZERS_PARALLELISM"] = "true"
 
 
@@ -51,6 +52,12 @@ def forward(self, x):
 class TextEncoder(nn.Module):
     def __init__(self, pretrained):
         super().__init__()
+        # if pretrained:
+        # config = DistilBertConfig.from_pretrained("monologg/distilkobert")
+        # config = RobertaConfig.from_pretrained("klue/roberta-large")
+        # self.model = RobertaModel(config)
+        # self.model = RobertaModel.from_pretrained("klue/roberta-large")
+        # self.model = DistilBertModel(config)
         self.model = DistilBertModel.from_pretrained("monologg/distilkobert")
 
         for p in self.model.parameters():
@@ -91,10 +98,14 @@ def __init__(
         self,
     ):
         super().__init__()
+        # self.image_encoder = ModifiedResNet(
+        #    [3, 4, 6, 3], 0, 2048
         self.image_encoder = ImageEncoder("resnet50", trainable=True)
         # self.image_encoder = ImageEncoder("xcit_tiny_12_p8_224_dist", trainable=True)
         self.text_encoder = TextEncoder(pretrained=True)
-
+        # self.image_projection = ProjectionHead(
+        #    embedding_dim=2048, projection_dim=268, dropout=0.1
+        # )
         self.image_projection = ProjectionHead(
             embedding_dim=2048, projection_dim=512, dropout=0.1
         )
@@ -111,18 +122,31 @@ def forward(self, text, image):
             attention_mask=text["attention_mask"],
             # token_type_ids=text["token_type_ids"],
         )
-        
+        # Getting Image and Text Embeddings (with same dimension)
         image_embeddings = self.image_projection(image_features)
         text_embeddings = self.text_projection(text_features)
 
-        logits = (text_embeddings @ image_embeddings.T) * self.temperature
-
-        targets = torch.arange(len(text_embeddings), device="cuda")
-        tttt = F.log_softmax(logits, dim=1)
-
-        texts_loss = nn.CrossEntropyLoss()(logits, targets)
-        images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
-
-        loss = (images_loss + texts_loss) / 2.0  # shape: (batch_size)
+        # Calculating the Loss
+        # logits = (text_embeddings @ image_embeddings.T) * self.temperature
+
+        # targets = torch.arange(len(text_embeddings), device="cuda")
+        # tttt = F.log_softmax(logits, dim=1)
+        # texts_loss = nn.CrossEntropyLoss()(tttt, targets)
+        # images_loss = nn.CrossEntropyLoss()(tttt.T, targets.T)
+
+        # texts_loss = nn.CrossEntropyLoss()(logits, targets)
+        # images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
+
+        # images_similarity = image_embeddings @ image_embeddings.T
+        # texts_similarity = text_embeddings @ text_embeddings.T
+        # targets = F.softmax(
+        #    (images_similarity + texts_similarity) / 2 * self.temperature, dim=-1
+        # )
+        # targets = torch.arange(len(logits), device="cuda")
+        # texts_loss = cross_entropy(logits, targets, reduction="none")
+        # images_loss = cross_entropy(logits.T, targets.T, reduction="none")
+        # texts_loss = nn.CrossEntropyLoss()(logits, targets)
+        # images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
+        # loss = (images_loss + texts_loss) / 2.0  # shape: (batch_size)
         return text_embeddings, image_embeddings
         # return loss.mean()

From bc36c08515ab29321664104888e8680b55d7ea79 Mon Sep 17 00:00:00 2001
From: Hyeon Soo Kim <64349347+shawnhyeonsoo@users.noreply.github.com>
Date: Mon, 20 Dec 2021 21:17:12 +0900
Subject: [PATCH 04/26] Delete clip_reranking_example.ipynb

---
 clip_reranking_example.ipynb | 191 -----------------------------------
 1 file changed, 191 deletions(-)
 delete mode 100644 clip_reranking_example.ipynb

diff --git a/clip_reranking_example.ipynb b/clip_reranking_example.ipynb
deleted file mode 100644
index c4582a2..0000000
--- a/clip_reranking_example.ipynb
+++ /dev/null
@@ -1,191 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "0a9e9261-01a6-491c-a789-1087db739848",
-   "metadata": {},
-   "source": [
-    "### Reranking 예시"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6a9621cd-aec4-42bd-91d7-596e467f4080",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from clipmodel import *\n",
-    "import cv2 \n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "CUDA_LAUNCH_BLOCKING=1."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "311c31c3-2164-4bf4-a542-f0238cb7adaf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = torch.load('fashionclip_fn.pt')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "68723e83-85f7-40c2-a506-9d9faa4174ff",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### Text, Image processor 정의 ### \n",
-    "tokenizer = AutoTokenizer.from_pretrained(\"monologg/distilkobert\")\n",
-    "transform = A.Compose([A.Resize(224, 224), ToTensorV2()])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "83bc01cc-c38c-47ce-8278-c77977230675",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 예시 text, image 가져오기 ### \n",
-    "\n",
-    "baseline_dir = \"./data\"\n",
-    "image_dir = os.path.join(baseline_dir, \"cropped_train_img\")\n",
-    "text_dir = os.path.join(baseline_dir, \"train_label\")\n",
-    "images = sorted([os.path.join(image_dir, i) for i in os.listdir(image_dir)])\n",
-    "text_pre = sorted([os.path.join(text_dir, i) for i in os.listdir(text_dir)])\n",
-    "\n",
-    "val_text_dir = os.path.join(baseline_dir, \"cropped_img_selected/val_label\")\n",
-    "val_img_dir = os.path.join(baseline_dir, \"cropped_img_selected/val_img\")\n",
-    "val_text_pre = sorted(\n",
-    "    [os.path.join(val_text_dir, i) for i in os.listdir(val_text_dir)]\n",
-    ")[1:]\n",
-    "val_images = sorted([os.path.join(val_img_dir, i) for i in os.listdir(val_img_dir)])\n",
-    "\n",
-    "texts = []\n",
-    "print(\"Extracting text information!\")\n",
-    "for i in tqdm(range(len(text_pre))):\n",
-    "    with open(text_pre[i], \"r\", encoding=\"utf-8\") as f:\n",
-    "        te = f.read()\n",
-    "        texts.append(te)\n",
-    "\n",
-    "val_texts = []\n",
-    "for i in tqdm(range(len(val_text_pre))):\n",
-    "    with open(val_text_pre[i], \"r\", encoding=\"utf-8\") as f:\n",
-    "        te = f.read()\n",
-    "        val_texts.append(te)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9be7a5d2-ab3f-4382-ab6d-c2ea4e4e534e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### 예시: DALL-E에 들어가는 문장: \n",
-    "val_texts[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3a06eb52-ba64-43e6-a1fa-774997a21a13",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### Image Inputs ###\n",
-    "### 예시: DALL-E가 위의 text에 대해 생성해내는 이미지가 5개라고 할때:\n",
-    "### transform으로 224 x 224, ToTensorV2 형식으로 변환, 하나의 tensor로 stack\n",
-    "test_images = []\n",
-    "for im in val_images[:5]:\n",
-    "    single_im = cv2.imread(im)\n",
-    "    single_im = cv2.cvtColor(single_im, cv2.COLOR_BGR2RGB)\n",
-    "    ima = transform(image=single_im)['image']\n",
-    "    test_images.append(ima.float())\n",
-    "test_images = torch.stack(test_images, dim = 0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5a05ed66-4a9d-49cc-819e-9c32f5cc040b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### Text Input ###\n",
-    "input_texts = tokenizer(val_texts[0], padding=True, pad_to_max_length=True, max_length = 128, truncation=True, return_tensors = \"pt\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "77f921de-56ca-4df2-b03f-eb26a6c30029",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = model.to(device)\n",
-    "input_texts = input_texts.to(device)\n",
-    "test_images = test_images.to(device)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1e2e2918-e11f-4470-9e41-0bb4450c3265",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with torch.no_grad():\n",
-    "    model.eval()\n",
-    "    ### Input text 1개, DALL-E 가 만들어낸 test_images 5개 ###\n",
-    "    text_embeds, image_embeds = model(input_texts, test_images)\n",
-    "    lgits = (text_embeds @ image_embeds.T)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b5951653-f09f-4087-baef-d11e7cf4be24",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### Re-Ranking 결과 ### \n",
-    "probs = torch.nn.Softmax(dim=1)(lgits)\n",
-    "import matplotlib.pyplot as plt\n",
-    "print(f'Input Text: {val_texts[0]}')\n",
-    "### Sorting 통해 text랑 image사이 거리가 가장 가까운 순으로 출력 ### \n",
-    "for idx, prob in sorted(enumerate(probs[0]),key = lambda x: x[1], reverse = True):\n",
-    "    print(f'probability: {prob.item()}')\n",
-    "    tmp = Image.open(val_images[idx])\n",
-    "    plt.imshow(tmp)\n",
-    "    plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

From e3931a112b1660a91b4ac0cf5cd19fa899faa5d5 Mon Sep 17 00:00:00 2001
From: Hyeon Soo Kim <64349347+shawnhyeonsoo@users.noreply.github.com>
Date: Mon, 20 Dec 2021 21:18:52 +0900
Subject: [PATCH 05/26] Add files via upload

---
 clip_reranking_example.ipynb | 334 +++++++++++++++++++++++++++++++++++
 1 file changed, 334 insertions(+)
 create mode 100644 clip_reranking_example.ipynb

diff --git a/clip_reranking_example.ipynb b/clip_reranking_example.ipynb
new file mode 100644
index 0000000..bc2d4c5
--- /dev/null
+++ b/clip_reranking_example.ipynb
@@ -0,0 +1,334 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0a9e9261-01a6-491c-a789-1087db739848",
+   "metadata": {},
+   "source": [
+    "### Reranking 예시"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6a9621cd-aec4-42bd-91d7-596e467f4080",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from clipmodel import *\n",
+    "import cv2 \n",
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "from PIL import Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "311c31c3-2164-4bf4-a542-f0238cb7adaf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### https://drive.google.com/file/d/1rhdXSDm14CylgwXHvQhYPdLv_msoDAl5/view?usp=sharing ###\n",
+    "model = torch.load('fashionclip_fn.pt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68723e83-85f7-40c2-a506-9d9faa4174ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Text, Image processor 정의 ### \n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"monologg/distilkobert\")\n",
+    "transform = A.Compose([A.Resize(224, 224), ToTensorV2()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "83bc01cc-c38c-47ce-8278-c77977230675",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Extracting text information!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 541851/541851 [00:10<00:00, 54142.15it/s]\n",
+      "100%|██████████| 11899/11899 [00:00<00:00, 52347.58it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "### 예시 text, image 가져오기 ### \n",
+    "\n",
+    "baseline_dir = \"./data\"\n",
+    "image_dir = os.path.join(baseline_dir, \"cropped_train_img\")\n",
+    "text_dir = os.path.join(baseline_dir, \"train_label\")\n",
+    "images = sorted([os.path.join(image_dir, i) for i in os.listdir(image_dir)])\n",
+    "text_pre = sorted([os.path.join(text_dir, i) for i in os.listdir(text_dir)])\n",
+    "\n",
+    "val_text_dir = os.path.join(baseline_dir, \"cropped_img_selected/val_label\")\n",
+    "val_img_dir = os.path.join(baseline_dir, \"cropped_img_selected/val_img\")\n",
+    "val_text_pre = sorted(\n",
+    "    [os.path.join(val_text_dir, i) for i in os.listdir(val_text_dir)]\n",
+    ")[1:]\n",
+    "val_images = sorted([os.path.join(val_img_dir, i) for i in os.listdir(val_img_dir)])\n",
+    "\n",
+    "texts = []\n",
+    "print(\"Extracting text information!\")\n",
+    "for i in tqdm(range(len(text_pre))):\n",
+    "    with open(text_pre[i], \"r\", encoding=\"utf-8\") as f:\n",
+    "        te = f.read()\n",
+    "        texts.append(te)\n",
+    "\n",
+    "val_texts = []\n",
+    "for i in tqdm(range(len(val_text_pre))):\n",
+    "    with open(val_text_pre[i], \"r\", encoding=\"utf-8\") as f:\n",
+    "        te = f.read()\n",
+    "        val_texts.append(te)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9be7a5d2-ab3f-4382-ab6d-c2ea4e4e534e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'스타일에서 스타일은 스트리트이다. 하의에서 기장은 발목이다. 하의에서 색상은 네이비이다. 하의에서 카테고리는 청바지이다. 하의에서 디테일에는 디스트로이드이다. 하의에서 소재에는 데님이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 서브색상은 네이비이다. 상의에서 카테고리는 티셔츠이다. 상의에서 디테일에는 드롭숄더이다. 상의에서 소매기장은 반팔이다. 상의에서 소재에는 저지이다. 상의에서 프린트에는 레터링이다. 상의에서 핏은 오버사이즈이다.'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "### 예시: DALL-E에 들어가는 문장: \n",
+    "val_texts[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3a06eb52-ba64-43e6-a1fa-774997a21a13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Image Inputs ###\n",
+    "### 예시: DALL-E가 위의 text에 대해 생성해내는 이미지가 5개라고 할때:\n",
+    "### transform으로 224 x 224, ToTensorV2 형식으로 변환, 하나의 tensor로 stack\n",
+    "test_images = []\n",
+    "for im in val_images[:5]:\n",
+    "    single_im = cv2.imread(im)\n",
+    "    single_im = cv2.cvtColor(single_im, cv2.COLOR_BGR2RGB)\n",
+    "    ima = transform(image=single_im)['image']\n",
+    "    test_images.append(ima.float())\n",
+    "test_images = torch.stack(test_images, dim = 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5a05ed66-4a9d-49cc-819e-9c32f5cc040b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/envs/lightweight/lib/python3.7/site-packages/transformers/tokenization_utils_base.py:2233: UserWarning: Though `pad_to_max_length` = `True`, it is ignored because `padding`=`True`.\n",
+      "  warnings.warn(\"Though `pad_to_max_length` = `True`, it is ignored because `padding`=`True`.\")\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Text Input ###\n",
+    "input_texts = tokenizer(val_texts[0], padding=True, pad_to_max_length=True, max_length = 128, truncation=True, return_tensors = \"pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "77f921de-56ca-4df2-b03f-eb26a6c30029",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = torch.device(\"cuda\")\n",
+    "model = model.to(device)\n",
+    "input_texts = input_texts.to(device)\n",
+    "test_images = test_images.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1e2e2918-e11f-4470-9e41-0bb4450c3265",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    model.eval()\n",
+    "    ### Input text 1개, DALL-E 가 만들어낸 test_images 5개 ###\n",
+    "    text_embeds, image_embeds = model(input_texts, test_images)\n",
+    "    lgits = (text_embeds @ image_embeds.T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b5951653-f09f-4087-baef-d11e7cf4be24",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Input Text: 스타일에서 스타일은 스트리트이다. 하의에서 기장은 발목이다. 하의에서 색상은 네이비이다. 하의에서 카테고리는 청바지이다. 하의에서 디테일에는 디스트로이드이다. 하의에서 소재에는 데님이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 서브색상은 네이비이다. 상의에서 카테고리는 티셔츠이다. 상의에서 디테일에는 드롭숄더이다. 상의에서 소매기장은 반팔이다. 상의에서 소재에는 저지이다. 상의에서 프린트에는 레터링이다. 상의에서 핏은 오버사이즈이다.\n",
+      "probability: 1.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 4.001023068411769e-09\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 8.19589079763261e-17\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 3.247010050923288e-22\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKwAAAD8CAYAAADqv08vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAACjr0lEQVR4nOz9a6xt25bXh/1a732M+Vhr7cfZ+5xzz7mvwlQVuJyESlUFk8cHYuIY86WwlCCIFJccovIHkBIpH4LzJY4cJEeyjWQlQioryDiKg5ETRImQBxAsK8QYDCEYCoq6Vdxb933PY7/WWnPOMXrvLR9a72P0Mddca+9zbh17XXP7OXOv+Ryv3kbrrf1ba/8mqsoPxw/HD8pw/3kfwA/HD8cnGT8U2B+OH6jxQ4H94fiBGj8U2B+OH6jxQ4H94fiBGj8U2B+OH6jxmQmsiPxuEfllEfmKiPyRz2o/Pxz/aA35LHBYEfHAPwD+aeAbwF8H/oCq/tJv+M5+OP6RGp+Vhv3twFdU9ddUdQD+FPCzn9G+fjj+ERrhM9ru54GvN6+/AfyTt3356dOn+uUvf/noXQFM++v0Tx169L32PeF1Q+t32z+3rTRatif1y9rsvRyfKqoZD+xevmR3+ZKUIi54cs6owqpfsb04BwHVjGgmjiPX19fs9gdiyjgXSKpkVWJKqCqIAIJzDu8dmjOaMzFnsop9p7kGzjm8c6DZ9l2uich8vFL+zWX7mhVVRZwr3+PGRbdzBHHz9XVStqG2X+cEVcjZvouAoIiAL79TVQTBe8+q73jy9B1Cv0bFI+IA5Vvf+gbPnj07OZGflcC+dojIzwM/D/DFL32Jv/L/+avtZ4hIuUjzA1g8B3DOHb0n3CW0p7ZlQnU8OeWKZ49NXAbq+xklo5rJOZE04yWx3e34m3/x/8Z/+lf+A169+pBu0xNz5tWra37rj/8E/+R/53fieiEP17g4cPXiGb/0d3+Jv/G3/jZf+/aHrM4fc70feXYYeXl5xfXhgErA+47tdsPDB+eMhx376yuev7zmxRhIKdNK2dm65+JsDePIsL9kyKCht6U0RxwZ7xziPfsh2d/DyBgz680GUJyYUOU44r1DgP1+jyqE1RrVjObEerVmHAc0Z1arnu16RUqJ611kGAVxGSeRVQ9nm56+84yHAU3Ko4eP+dLn3+V/8HP/Y77w4z8Nm7fIGuhF+f1/4PbF+LMyCb4JfLF5/YXy3jRU9RdU9WdU9Wfefvr0MzqMNx/1JmmfC+BcIw/Yc3EO5xz15hAxjWH3ScZ3wnrTgyRwcBgHQt/TBUfnhVXncCSExPn5mgcXW/qQCS6y6hWnSu8DAUGSaW6vglNwas/9LeeRcyZnbe7ZcvOXm62uD7NSKM/dfP71c/s7i4g4Kedt+2m/pzmTyqpg79mqIyKg2I2lQggdKWXGceRqd8V3P/gOQzrgvJRjj0er6XJ8VgL714EfE5HfJCI98PuBX/yM9vUbOm4IrWh5NF9SQAURh4hDESjLs00+9KsAooxpJOaEC4E+eDxKTolxHNnvd2SNnJ2v6TuH40AfMl6hdx4/CawJqP215+7UpGpZHXIRFKSsIIpm+4ETB8IkeIods5NWFGbhdc5Ngu3ElRWtLvs6CXFdlezmdSA6CXVWIWf7jXfeTBtNXO8u+fo3fp3d/pqsGe/ldtOsjM/EJFDVKCJ/GPh/AB74E6r6dz/NtqppcMe+jl7D8S0qIjdet7+7dR9SLOnpI11MjOBwUjQfaq+dI2smdJ7gOnJMiA+E1YqcYRhGdlc7ht2e3WEkq7DdbFmve4aUcZi5HIrAovZakKJdwakgyI3zqtfDbNPFu8V2LALYXpeiYVmsImXbC41bH9UWbbYx3dzLm9z2a/vQDDkpeKHrPEhmHAc++ugDhsMOzRHnOog3p6Edn5kNq6p/Hvjzb/r9VmgmgWju8mPb9dR37b3WCWHxneP33gTSU01UB3CeLNNarjgpTkLZr+Pi4gEAXd+zO0Rc6BizEvotH3zwAtFMzo79XtgfhMyasDrj7Owhw8sXOOcJXklFS3oR05hqy7ATE7h6znaDlGXelWtQji9rts9FiDkRghkSOWdccZRSqks7pJTwwZwnMI2ac5r2l4u9H4InjvW6lgVH2+uTyzacLfPiJw2bYir7ipCVyxcfc7i+IsURFU9PvtNt/s/N6VqO04f4Ou36qfbUbLM+b4V58XrSVLm8ZhKSlIqtCGR1xJjZuBVdtyZnYRgjqo6UBaVjjMLHH+0RlC44hiFwte+4PniG1LPevoW+3KFJcR6IivcBlUzKeVL1GUWl1YJMXr4TQcXOodWkpp+rEzufp10DJnu9niNakZTTNz/l3Sq8zkFOkZQSIQScE5yTYrcWBy4VM6KYRM6BZLh68Zy435MOB8J6xWxlnx73RGD/sx+tsN6mgW3k9lflM3vuXHF91MOYcNKzWZ/hfU/WxGFM7A8R8SvGKLx4PpJixnkY4oHrXeIwCFd7j/gznNtwGA6IB5VI6AMyjMRkSETCbiBxzuClxGy3qqLF1pxXHVds7ea87AdH56TTsl6/czc4aDdKzhmRYBhKVlJKdF1nN7UHRgosWI/LbhzbV8bnzO7FC1589CE/8uMeUSWOkbu8rn+kBRZuNxeWo2qaWUNVlCCOif1+JF4NxPEVKULOQgZiVPaHyNVV5MXLa843F1xfjewPO6JGcMowKFfXmaudIv7M8FdMQF3XIX4g58hhHNmyIQSPeIeKLOC4qiVVcyOwkzGzgKsXsF39bSvUr1nUqlbOk3PHQhFnzVTsWNX2r0CKidwJwTuyRtIQkXXm6//wH/LbfnvCdWIryB37vjcCewz/w03BqfZS6whVb7j5FWVNY56Q5YYFIaupp8lE0HlbMm2lOCsqiAqKw1GEJSljjOx3e66vRxgh7wbwG1y/IR6ucQIaRy5fvuTF82fkuOWjj19yvbtCRVmtAkrkepe42kVUejLdBO04J4TgOIyZMQ4oGecDLgTTsEU4K6CvArlAV1kUnC3FSDnPcvbVEUKrJp2Ft16muoqY/dE4rpoNHTmaJ7NxAXGgikdJUuMuZlOPKD5mnPfk7BmSmQvf/fbXuXr1EW+dXTBOcOHpcW8Eto5JcJu7V8o/Wu5VpcJMtuypzhdYyDdVRA0Y1ZcKkEDE7D61aA8KbrL3MjlXL9oDAU2OlIqwDiOHYWQcEkSh69akYSB3D5DtW1xdfoAQiYcXuLzn2YffYT8KL653OPGkmBmz4L2wO4yMWYhJyK5D4xVOhZQzITicy6R0QMmId/iuw7mAI2JBDDMTsmayZtQLSRN4IeWIiEddWZLFI5LIqV4TBU0IHTnb+eOrk+nMlRRwzpszhRZExKJXbjKpHCkriMMpBDJZE2MR4qgZxJMJpOwJLqBqSMnV5Ye8ePY1Hr37NmH1COR2sbx3Avv9jxN3p7QKttiBhnJOCllUyCmXpVUAjxdnWivCOEZ215HDIRLH1ETILES6PxxgVOIh8eTpe3z3W3+fvgvs9gfGNPLdD77DefLgOoLviDEh4ohRiNEEKCUlxqUz5BrbsmrEUDTsjKRYFG5ylSq09QbXSniT7928tseBlglzbTBgEVcCLy2KY6aCE0WS/e7Fyxd85zvf5os/GlHJJ/Y7j//CCawe4YfNIrf4K+rQaZ7tQgbfIdm0bU4WuTns9ux3I/v9yHBI5FQcCChLsgnsbhcJORKvIxcP3mFz9oRx+JCYBUR58eoZuj7DhZ4UwYcO1JGSEoIDHxj3EFOdbLMrXYmqpZQYYySmRB86vPM4F5F8vHroFMuXsl4cjxZhmPDcN5Tb44DCjJqkaf/iBMnl2Jv9mVDrhDDEnIjZMY4j3/7Wt4jDgbC6yyD4L6DAAs0MmiDqZNPOwxEQMLyzAPOqMAyR/W7H7nrHcBg47AdizOTkEEIxD8rWC/wz2bbZk3NH3z/k3ff+Mb76D1+gvmNI1wzDJe76OdvzhwxjpGeDcz0pJVKq4d0Vzo0kqnZlETIdx5HhMLDqepwXcMfCagC9VoEtSMEpWZTFNfrkw03h6SVUaFhxFWQzMbQIdUzJlEHO5BQRVYYYOQwHvva1r3L58gWP3np6J5R5bwS29dpPfn7L4lVhnPq8PpmiN2UZnZ00EzjJjhwz8RBJMaNJ2e92jIM5Uvv9oUBQATTg8Kg6VA1SqmC6FqfEO0dGEdmgbstbT7/Ed77364TujMQrkkZeXj5Hggf17PbKauXwIbC7PoAIIXi874hVAJwrmtQEI6VETBYK8t4jouRszmPFXnEOg23N4zHblnK8y4CJMuPKgmlFi4i5Cd9tvIhllK+5UyouHUKY7FnnHB6IDZKhmIKoGV4gxJTY7Xd89zvf4rvf/RZvvfUjd8IU90Zg6zgVRrUxe/JLoV4Kq0jCiUWdLL4P1dsV8ThxaFbSIZNiZtgnDrsDly8vJ7QgjhlHoOs94rqyLVecM0uBQxTVVCzHhHfgfED6M3J8xJaBp+/8Jrbf/Dp88DFJE+Nhj796Sddt0RxRPKt+i+88KSWG8TB55FMo1c9Lb3ttQhHYGolTzXjfFYHNJnTqcAJRU1n2CxRVr2ujFW31oCztfopsUQX6CGppBbdGIieoK9i1997BWJzgCrvVpBnnyMkQhRgjh/01X/u1f8BP/JafRuQHSGBvH7PhPkV4Tp1XGoGEOG+Tlr2B22qvdYQ4KMMucn29Z9gPZlOlEutWQVON1XvIxSZWKTavlpzQXOzFhGL7VA2Wo0qPhAsePHqPt558gW9+69tcX1uyS+KK9QqCX2HgjyOEzoIFqiRNk5DW824dr3qzOm8hVHFAWuY4qBq85Z2B8fP8L6NXNX81pYS6Nqplz8U5hJJj632xQee0z2lmREoodsaEs2ZyxWJpVtB6Dtk+t6fKMOz41V/5e7z4b3zvTkfwB0dgpSKkt5sNAMFD5xRNaXKc4hhJyUMOFjYdotmnhwPjGAm+g+zQaJgruWCB4ogap1yBnM2TL4ubgd9pRDkY2D/0xLFjTI4UPf36EW89+TwPHnyVF88vGeMVw/UOVc920+FV2R12yLBnvV7jO2FM0QTNuQqBLpyW6txYNKkItlQor4RBsx1rHzySU8FgtYH/zI6U8ntLR6wrlU7fkeZat1q2Lvl1tPZsNU1y81nNi2hvOoMtHYhHgTge+Pqv/yrf+savcpdd/YMjsM1os4uOZTenkeFwzTgk9rvEYZ+Jo5BTh5M13q0AxzCOqDqcBARHF1YQD5iTliaNmjUjvgpCJqVIjBGRjJLIOqJ6QEikCDE6YhIOh0zWwMXFW7z15F0++OADwnDJYRzY7weCH4EBEEIIpDSQM2jRsE6EBJPxqWqhzzQt+aYh52hWXXkNnjPB8XYDNpqzdY4EIHickxJwmL5FzT1o817ra+/9ZAYcv4aSrERdpYoZMAm4TgILgi9myDgqL18842tf/Qqqt0Nb90ZgBbMNa2pcrktXtd9QJFt0R9TA6+qjQybGgf1ux+H6knjYE4cDKUZSTKAdTs7AQRYHrIC1Lec5oQrb9Ya9Kvvra8gJzZmsHk0Z9SVkkRIaI5LrBc2QlayOhGVYpXxANSMI4yD03UMePXif8+13eXn1wrKVFMZhAHX4YLH3lJUQPIpnJ54ceiQmvCpOHTjPqGqJ22pOnpOE9zDEJmsKzL7OCSSzxkHMjAKjKK4T2644CwSII5cImfOuwHQJxDLRMpmklnyTVMEFsphtTEpTUrnDghWq2aJbzrZlKKMFJ7z3ZIQkjlEdK48d5ygm4Fn59V/7NXIab5WTeyGwFnBZQPtzZLWE9xyWc6pVlWgyodVEHA6Mu2t2ly/ZXQ+Mw0COB5yOaM446cE5xG2AzBhHkBUpmSc8pgFNieA9mhM52e9I0aJdZUnLKZFjbFAJ0xRJYVDQlMwLTuVGyI7gNzx48ISLB2/RP18Rxz1JIY0jIhadGscBnLB1GxCI4hDfIYmCcpiJkqWk4qjSBY8XcFIif85N182W8gxkOiBlJXklSQbvrRDC1SgeqAOyUiFsrcEVBySmyKLa2kMoAY08ZWNZ1CuWlMacM1qcLFeik6iFZG3CPVk8MUcc4DWQkmfImW9/49sMh8OtsnIvBBYoXrdOUJS9Z6ZVXfbqMlgDOyklxsOOw+6K/W7HcDiQU0TziGo0xMDZMhvjDucOdN2GJEpMQooR1UwaI6KJ/uyM4ANpjFMZh2pXMuil2MS5JHfMAjvmSCSiWcgj5JSJ0bSEIlxcPOS9997no2dfJaWBMSVDBYY9Xb9CRBjHHdckyxNdBUJBRbLZCaSUi2dtv+37juAtGifUOGuxVYvGrCUqVk1QVwWZkIg6vBPihNs2iESZhjZBqEayvPfkGKcEnJpDm3IipmRVESVXt8JpztsxVns3JiU4h6XkZlJWvvPd73K9298qJvdCYFsztEnRMPurCm3RH6ZlzZYcD3uur14x7HekcYSccWSc5AneKpeRLBHVHcoKH3pitBxOVxDelCCOka5bMQwjMR0Yhriw0arT09qBOWeiJhK5KH6LklEmKaWM9z1vv/Meb3/wHofhmv1wQFW52l0xxgPe+xLhMpswkcAJvmgrStQrpUT2npQtMXtVI15YsMEcIikmRi7OTpgrXatGrcdfvHXnzOGswlfnozpZWmGpeiNUDdxAYzXVMqdETskqd9tZbexSLefpcCieMWbUg2jm5eUV+909NwnKKUzPq4cqZMuUElsUnSg5RYbDnv3uijQcSONotmVO5rBIJjgDp50BJ9Tk5pSuYBC6/twyCSyViRxNEL06ttsN3h0sRVAth2DyfIuA1ix9LVos5UjSPJWB5JhAMzFFxDmSQr+64J13Ps8HH3yH/WFkverIJA7DgRgPxDzS9ytC1xFjpu/ChHGGEHCj5zDu0a4zcyUra98RpHrnBhN5qUncZbmearKWGGpdHaoc5ZQRynKeBS3Vl5MJ1s6WzjViNdRWE8ZjykWrzvDX/Hy+Yew6QlgHU0YC4zgQOm8m2y3jnghsHQ22B4YhipQapkwcDuz3O8biVOU0oimiyZZ0p8myk7CsIin1/6J2O3gZGcdX+KAEv6LzSooKKaExM7rIfj/gfYcTj3eBfdpNF73mwFbBrRc+5mRZUlqhI3PaigLDhzUpKw8fPuXJk/e4vN6TUmS7OcN5YRgG9sOBcRwYYyQ5x8Z7vA/EPLDqe/ywg2jXZRxHRKEPAY8lkmcFvEOdoFmImshZkVByd0tSTUoJsk7VABPQT57OsS77guK9LethkQ9gw4kzuz1V6IxpH1rs1Wou1HwD7/2kAMaYGGMmlOLDMStuHK3C4pZxjwR2tnWqzWr1S4qmSEqRYX/NuN8Tx4GcRrOh4oAWp8ns14hqQgrhhDlM5sVmIuRIHIXABZqUcVBScqSojOMB1NGvAiKOmHIB1vOMV2KvTcvqFC5VnXANWxYLiUWuAQjpWK8e8v67v4kXLy/54INv0jvHZnNG3/fkS4uwqULymWEY2KzmGqwahUsNFtu7YEWQFXKSJqhSILn6uxa8b//OjzoP8/I9VS1Mq5RVu04nWhyxKpSWt5DnaFbZ7rFNPGV0iRQUAovCAWNjcp0a90NgzZ2cPNXqeYqaxz0OIykOBaoa0RxNK2bTrprTDFHlEtnJBQvXYrNJJqcBLaFXYU9OMOwjOfeMoyPlVCZIEB+g5Nq2YP20nE52rBbcs3iCVXgKxANCVgcEhDUXF0955+nnubx8yX54BU5Zrzecq2O3OxBjZjdccTWObH3AF/vSlbKYWv/vxbEKgZruXEG+hGlDpBH0GnSRulLYL5zzJf+hxWrbeWnTAmvwoOYGVCGcbVjvHcN45JMUoVVmwc218NGDSi4QpivVBsJdBTrfl8CKyFeBV1h1UVTVnxGRt4B/D/gR4KvA71PVZ6/dlm2Q6fZNmZQTaYzEYSDFwRI9NIEWnDGbrag5z3+T4aqiSkF2TCu4QuYgFnnRdI2TDSmOjGMm5xWKY78zSMX3Huctpt4SRNTlbOF4Jds/AM7s8ZxLzixi4VoJeL9h1SeePHmPV5fP+fq3rthd7+m6jtXKsrf2u4HrtCcNAzFGuvUaHwKh6/DRk0sAAZTgfEFRqoYsAYCiLutSPaUCMqdG5qz4Eg6+EX1p5qQu5VNyDRSc2b5RBXEK3x7ZvNII9oQkpFTq0iDLVJj2Rhr2N4JI47+tqj+pqj9TXv8R4C+p6o8Bf6m8fv0QnVSi8TFZYkfOowlcwVwn7LPAJxYcsEdOI7FEouKYiGPJIY2ZHM17BUVzZBz3BG/FcLHAM+OYGIaxRMFqSfJSq6aUpu9X1CAWOy41OGxKqWQlmfMmIni3ou82PDh/xNOn7/LkyVPW6w2WpOLouzVdv+L8/Jz1ej0t3cH7Yh5JgcMGm3QKllqgInEyYaZgGHMNm87nkSe4TLVhillOhv17lLNR0QZtTAIax8qKHk9pWKkvqHkGtj2b81xon+aw8O3jszAJfhb4neX5nwT+A+B/fucvVEC7GRkwkAhNJoQ5HayaMqsleqSEZMWpQUo5Gf5qTljVwA1VDkrK4DIwjHhVYvqYcXR0foOOIGp4pkgkDQm3Cnht72cTVksYmR0uZSClAcEb3FNKriv+mFO0VSEroybEd3SrMx49fJvrq5fkMTLGPZ3zJFFCD+v8gDEqXcj0IeERNMJwcAg9Y/BcDQMP11u6EAhDxMVMECFFwFtUUIFIJnsIKOs0a19CICkIAYmCdzXXt5JfmO1tx2+vHUJnNd0leDMiklAiOHMsccIuKgFhI54uZyQlRCxwEZ0nu0A6KKvNhjGNaMl38L5s+w42je9Xwyrw/xSRvyFG7gbwrqp+uzz/DvDuJ9tggYqiabJU6t1zuUjznZiLYFZStmjEbLn+Jk5ar2rClA2YtxzSxDjsCb6QdKCEkpE0HAbDZH03aQhbOWtF6ny0cxaSLjTx/JgTU2y1NEHYrM94/OgJ2805VmcVCN5qtVTNJqyTaCmRuThdJRhdwqW+5B2IWojUbnqLMmVVy0elaNoCD1YNqvNTYMlbkMt+Jhu0YFKuaNHZdp0ZD2tSTDU7xDm0OKcWfMHK1YtGHw6DhYYLx4N3fqJAum18vxr2v6Wq3xSRd4C/ICJ/v/1QVVVuSW6Uhr3wS1/60uRsVY8050TOseCrWoTSBNSwwjQJaS6ZWRYSzbOQ1AtXj6Bc6GJ9MsYDq85i3ZqTOUeqU7jU+26RhVSdr5mJpp4MkyOhzTnU19X5mcgsshDCivOzR5xtH3G126FZLHuKhPcJnCOliHcrJASzIymMKepLtpPlH3ixaFVC8VKwWGaugBDMvnTFZLllPkp0TM3/rcfcOF7Vpq1z4kSKGVLhK9vPWD6vN41tv0YLEzkpgielSL/uGcq1rSbNXeP70rCq+s3y93vAn8GIjL8rIu+Vi/Ae8L1bfjuzF779drnT5+XUNGGpAq24Zk6TsFbBNVMgmnBPAqtzBWmN3rTevSqZEWUk5ZHQSRH+eSkahlg03Wz/VU2dc9H+ZWIqEtFis5WNpWqMGkHKSqnGDThZcbZ9zHb9EKEnJ4d3Pd6HJntfJttVVYlxvoGdZDpvAhqk1FEhk3AkteRoYGJkuW20ETAT9jxVLk8wGDOJXBXESUM2SAoU9KRmhNXd6vynbrtGEotMcKoGrR2fWmBF5ExELupz4L8L/B2MpfDnytd+Dvizb77VunTWJbwxCarwFWw1T0Jc0QET0Lrst4+cm7/loTogEsn5QAhMjp1WbDVWiGs+tqXQ5hlv1aVGrSbGjfdzQS6w+jDnerabB5xtHxLCGtTjXI+qErpA3/WIiDl5VZ1rDU4oaCY4wZMtFbyUYdclOmMmAczEH7ettq1z2Z5Hhbza8Gy96atTlksYuBgR1DL5CQ1gDjjYDVgWQIVhGHDeE0I4CueeHt+PSfAu8GfKHRWAf1dV/+8i8teBPy0ifxD4GvD7XrchxS6+uJI4Mg6zAGlNISz2ahXEmCbNmktYlpynMN+UtJytqhXmTCcAnBLzniAjPmzAWX6CeEiDIpIKf1aePO25OnQO0yJ5qhKt5kAdFX5qhbiEEop54+j7M87PHzPEkf3VMNtvCqv1GhFHSocSIYpTCqBqJo57vAfvhS7CISVw3sKmzgGemFMjeEWLiUWvqr0JpoH3h2Gek3Jzdl0gNxGuSjKnatxfY4rz+WWdTIKcM+oKX0FqqzNKTZwTq08TD9QEcMWHwF1O16cWWFX9NeC3nXj/I+B3fYotAtVWzdOkQGuTVmA1gyakxsupdpJOy3R1KyxQk4t5PGOOqdismQHnFO+lRLZKwkdh2ws+lIK/2Zadk0RqzoOB8SbEJcNKjjSuGkxXz6lGSwRH8IbD9sM1h7ifbrZKqhajhTTR1szIQMILdE4s6Yc5S6uaVtONRVuaPUNhVWMf27azTTu/5kjwoUQjZS5JJ6dp/865OUgwOaeUKwbVVqgQm1VQ3C0l9yLSVfKUrDgwmzdfQ3y5Cq7OQQKtNmKuwqvTdijevL2eL+4EkE9e8IBqIOWB4NRKkrUwnbhaOgKum3HMuq1aX0/V5k4WdVOTnawV46xCbqaNLYlzup+I0HUdIQR2Q5r2VzVgSrEpSZknGZQQxIiSxYiPteCySS3hOunMweWnkpo5TGoRsDlcKiKWANFEymo4B6rgNq8rMR01gpbm6w1zkgzzClSPYYIcUzLbuzDJ3DXuhcDWUbVrLg7XbAcWoZzsxQJpoZYgM21h1h6Upats2C5WbrSeTyVcOxpAWwyrXOQ6qxLHsdi3y4tusBjTvmopyAx/mR0+T1yjYUv5TRX4mhgSgjeit3IyPgTDhNNoDlfJTfDeBMQENuGdpwsBz0hwUnIXpHBvFY/gSMOaPVxDyO21m4F9VUcuxY1IPadyDRoUpK3n8kVDVmcq5UznpOiUoq1l3teUA5ETipTf323H3qNOiAZOV++6utSSKa51XerKA13c6baJUmEK0/JftXHVwpMzoZaNpBoxmykRi3BYckskxnFylGahnZdZrUCmzJNtCqh1uOY8g+n9EjVXEcRbCNh5T9d1dKHDZaVz3pb4ZA5XLuUmrUeNGEYbvMM5iw5aFUK1SEppegH9g1h4gyJMeboec+m3olMnm7qOVGdLmBOTqinhxOHEg7JYBbIykRfP0TKBqTuDOXHTwjfpk7IC3DLuicAKjg7RgGTBZ49L4BO4rISkuJxLCK9yAdRhlZdSjXd1hLaBBTLRsMMcKgwp4KIiHBC5woWBqGPhf5ZigoxAh0iY7vwpaTvG4jh5UFeEyRUyDMHs1LnTjJY0R8rEJIQsjoiQCKTc4WVD78/ps9LlTFdqobQkdOMg9K4gHUqWFQln7wfF6QHHiNeIy4rPjpQ6svb04tjkyKbYvSkp2Xns5yNOCs1nziSEKI4RZ2RuxSESUQp2NuXN2rUJ5Gw1Yc5j+RrJW9BCIriMlbT3QE9Wh0oqATQHrkNdIBVCvLugrXsisKdHu/TcDSc3v2kM/ro0HUNPNdfTrktNOGYCwA200AZ4D4U+/Rh0n7WqnNAKN6NezS/r8pvzvJ22/l8tm6oeB1psPXFTTmkNZmhZa2ftN8f9KdBWUp0og4TyuZba1mpT2ik10a9iTuh8fq0tv3BAy/NqIlRkYg6y5MmFeF1w4K5xLwW2Ck5FiSaH6U1/fDSm0Gx5TB6+zLal2Z9mPiyTsZfRHpiFrdqfIm6xj+VktnkHk5pfAPIVDbBQrDdegjLZqUBE9fdTy6XJKcrUpnNTsgpz0ktWnXFcYSohd9Xr52j1mWzySnJR9iuymINqG7eIjOVatJwFdrxQna/Z8f1Ec9qMeymwQJXaT3w3tsJVha2tm59sUcnUjDDVVHh426yhEqasWlDmkGwNQfoCeLfh27sejbxOAulkTv+zzxyr1arkEjBxDFTtapdGJ4fFOUfXdaVPmCyuQ/2usXoXjVdSJg0NKBq2LjYsV4sJEVE76MVM6Hy+NSgxha7L7yv+OmHiVQlMtvwnH/cGJTAnfYaEPrmo1g3JfAfDQpO1QzWhYkkweeLdpPlbtZ839usb2tUExUpKdCF0ME/2ErBfbhuYaq5a8yJ0AaKbJteOSgmhdKvR5jhESvDAT++Xex2oCW5mm6ov2GvV8EhBWcrNVG2ChrG7zouzk7ihEFTbujELithNYYqgXgPLQVBUmpUL4cYVeQ0Oe380rMyTPAPWLeD3mjM53lzz/bYXQH1dcwcM7zXcF6o5YN+r1JCtOVC1a9d1dF0/1UBVLTjGkXEcp1yI+ptyNsyhyeXxiEijrWttVSlHwSJGll9Q7M/mRlRVq/mXdoXJ03VNalq27ss5sfLwcnNLvTGOlujWzm5vZ1d+Vyt60Qb6Ust6mxvQNQLbmAKGcshC6O1w757n+yOw0xJTXnxWu5kuVo045fJ8tq/q7msSTqtdW1Og2o1a7MRxHBnHOEFjrVMyaTQ5gm2mbTOZB24SlJncTag/a7Km6vWSGQ9trNB6WckYK40KxJQseleqFUJxwlqfYVqhpF6SWZgXmvXE6rUwu5rttt+dlPmJ8Trm8HtjEkx38CS0n8E+Fhc7N0JbqhycVeiqswmvrSonjLLYayaspkUsZ7dxjJqJFKl0PdU7nxfAOs91ORVxk0NlkTOZMqCUkhDuPZQ6MddoPsGVlpielMzxqjdHFfiYIiJh0sLOVaoiO566n+rF13OumhMnJZGlXMca8i2akopVl1O0MO0cOHHO+nlZpFZnVOJoHK+Gx+NeaNjqMGp7i39m+2o1QFOpWA5kuuaNHV21VwhhCqFWDZdK31gzA1KBo+ZkGSnaL4TQCPJ8PG0JSz2+NuJUjyvnbELp/GL51eIQeT+jBzXcWrevmGaVchzVPKiwWd3HZPw2NuY8OUya3QIDyy7oy2AJk7mxtP3dUrWe8i1uydedrtedn/5nNOxGTkjJFzBhKTCQGOW40gqzLXS1DkwmN7f5HVUT2DYrR4Ej4zRB6iB2kJxtCsVSoKN1PxFr20PJGnPi6fs1IfTUzjWWhjgwjsNUHVEduLryV5u3ZihVQahTZbEfwamWsh/rwKIaGfLIIMpQmhsHPCsXpliR5SlYdNCqFir0ZPv3XnAB1GUOmlAXCKHHpcSKRIdxOMQaEYPp3IzJxaJkVZFqiUJlsDlxjjFXnlfBSSCP0PmAk0wCRvWM6iGD14RLAw4rCs0lYmnRNWucp+40xX0d90JgQU1YJ5uygT1m44120ZqytsqtX+27WVG0boLOQks2hu7sIQUkeSQ33jJKlmzEa1OIrJoCHZWSp2Ku42gCW3N26zG0CSwtvrmAc1QLtFTuvUlgFTQxamJEiWrh4Q5PkFkrmsBac5E5KSVP10hqMkrhrRqz4lyg846OhMsRxCJeSomcUAQ0Lx2g2VQrZoJAFhgL40xWMVr9BF4E5yxQEdVZYxIso8xrxFnMktwonUr3mVjawMfjnggss9d5pwHbaM7p1RtsWhuQbPJSwS5+2059ufu6NFcnywTWTdn0lSu22rG1JX1N4jC7zTfbqhPf2GnVTCjLOapT2cns7duEhxBsxalNC95g5JzLPafGGOPm7VTTwhVYzZU0SpHC3lKukUzhL52bhFRUZyoNypNztSCM02UEbMZkT9uqKeU75/X+OF2vKfOdzKsqfJ/UM9NZ0Gd3mKL1pOSxyvyRzLZXXdYr/9dcam3C2kJeRuVemrC5KqCzzSgyJyfPNm1N2jHbUJDSvKLU6QO+s/4Fkl1x1OZuNncNUUrroXINwFp/5kJ/mfOUnhuc8beGYLkBOpk21b6uC968WlTxyjlPubEp52Ivg46pENU15ztlq90c1cm9bdwjgX2dh9g6R/PFe7NtLx2r+p4UD3my0zJGhDav2TccotkUGKd6qTkx2voOODHKdOcqc3ZxpFyFowRxVjCoOue/1hNSjPsq5UyMdpN0fU8uGrxq+jdZY3wNRjiHD770HgB1gpeATBwMGde56XwqEUg1ySqp3nEAZTLWtJpmpmGdF8R5Ro12UzTDflds1aNTuAH7HY17YxLM4br5DBahzTwX9NF42lU7lRdN0scMRZUdLG6GsgpaVUFp8uZK1lEtV25xV9uPm+zWSmYBlO90xWwIpkmZAwDVganbw3Y9mUB1knQyNZQxpppVafahK1UP4uhWK7PiS12ZnUeezQvqim9phR6Z8gVSNvI6MeAX78N0PSupRi10XETuyr81Z2LqxFiLEivNVDNvswm0ZM1x3s3oA/NiKXK75q3j3mjYhXY90rKtEzVFitov3AJetxqhvSFEq9NWHCQJ5FzrtCxBBEAcExxVt2GphWmKYpnJYAJrqMCMfVoOtaEYNnlpPv7mJquqtWK5OWejrcxQPUoRNx+XBLLGkiObSySrsf9b2EwBFbqSUDOMI0kzwVtVrpkgZd+YAE45BMy5t6ZIlte5hehac66WCN0oh28n9GgS5+t5t6lzrwQWypJS3lvmFtwxJi18s6R7ijbVB3kWWKrDIMQxlz6v1oNWi/DVdL8azZpIPZgnrDpkdYhYOUoLsLcJMi14jxY+1yYrKmcmQuKMgqtMt/NvUlLEmzDbMenEK1BvAqXwFDhnFbhYT1wRwYeaczCHlW1FqL6frWpa2TmacYwZHysH4/Si5NFSyp4qcXKczrNixm1EMIS7F/17JbDTMtScPDAJ7W2jas/beAiqwFI8dNumJb5UGp5xjKBhsq1qbL/aZCklY4QpTlZd2k2jeoLvqGUxVDbu+sgl5FgduSIBc6JKWTarQEpN7dOCgZYKAAWH2ceSzeasN7qd55JIrTI59qFj3ffEGNkPg+VCrPolH0DBu+uogYvp0jeadMovKB/M19lK43NOOHUFcSgCmUp3nJIyWb1oi+5Vh7dmh913WEuZOUWZV4rjuPSdv1ednLFTWnbqcar1b560narBKZUeqE5K15vWnAR2nO3WNsXQe6tIqERAWsrK63cMNWhOjNlpqXVs9b0Z+jFan2pXtmiFa/rHjsMwnaPdTLRXEEHoQkcXAsNofXMrmZ1zHilmRuUFqED+MlJVtzffaHV+ZuVSEs3r+zT1XmUVoD2/hQPnplB3pUi6bbxWYEXkT4jI90Tk7zTvvSUif0FEfqX8fVzeFxH5N0XkKyLyt0Xkp163/XphTQ1FyGmOSGE08fYol6tk37tSp2RcsCaQZvRlMmXZThlJgowgyYE6NDvGDGiypTeuiekBQzwnyookCedGHHvWnU1ONQVStLIQNODdihCs75fVTemkTc2B6wl+RfBrhB40kLMHCYjvEd+BBLJ6UjbOcCSgOEa9Zsi7IsxY6VB09BrosuDGgZWDmC2wMIpwUGUUR/aupPCNOAbEKS4EY2a83tMDnQqHy521hBJftpHBlxRBzQSUHqUDSEZz6kQnQ8qiXQ58sFosFyxPQKy7Y0SJmvCdhbMtP0LxzpXIHgtHWIUSTLhbQb2Jhv23gd999N5tlJr/LPBj5fHzwB9/g+0vxjIk0Bx80aDz242ZMK29Fu6rrNhGuBGh0B1V4g3QsvwJEIyOM1f0xQD0LvR4Fyb7rpoCiwylsmzXyJNUAL7RrK4kpVTtvQTii6Z1HufDBNxP1QEl6KDZnlulgPFoOYQ4jlProVTOwWxC5jq2EsAaxpE4GhFyzQo7HA6FM7cEAgrjTrvaCaUnWDmP6ZhpErobKGrhd9QE8Zpa2JR8V+ez5R2riMNd47XfUNX/EPj46O2fxag0KX9/b/P+v6M2/irwSArP1hvsZ7GsMz1v4a4TS32p/Z95rXTiLLAS6YGsIykPxLQnpQPoQM5Wsy/eM4zRAprFBguhZ70+w7t+ShusyyjMqX0tO2J93cI49bwmzNLVSFLlza6Y7wy9GaesmReVKduwWsilh8PkwCUtkU0xOtKkOByiQhoTfeg4Pzsj58zhcJiiaVYw6BliIgv0fc+q70uijP2Xj4iFZxNmwqCmczxOMawmzVSpUe3h8rv6Heea3GDVxY182/i0TtdtlJqfB77efO8b5b1vczSkZS/84heBpe3JJKRH9mndQBXmhmzNnC7KI0NKRhNfqTjVPNSYBRFLYll3Xclksox97x3B96z6M4SOYbhcpA+2TCqnRsUaq2PSJjCjDnXOKFDLmdTmHyF0eN+Veq6A0SFVr98gtpwtQSgEBwm8OHCewzAy7A+2XogDJ7ic6UMHKuz2B8ZxpA/WtwEBxkRSGNMe8QHfBxCl6wqhSA25Mju1rQA7qTfTkp2xnmtUu8FlKt0xAdXGYZPSUbGGxRcr6i3j+0YJVG+n1HzN734B+AWAn/7pn9KTzlVj4zQ/nLUtNx2snIxtO8WIxoGcDmgap9zRVLBUdRucD6ylM2Jf55BcMdVA8D2a3UKztpNTx43gQknha85zfp4KlC82WdQbsMFiVSnNmKvAZkSsdLwE5vDemjxX8+Kw3zMcRkJnZowPDtevGMeBFy9fgWq5IQTXGYthzMbNcDgMqCTr5IKV/fS+s87mMSKic2i3Oee21KU6sK3TCHMy9gRhlfTCqmgs8lbSdcr8fFbML98VkfdU9duypNT8JvDF5ntfKO/dPSqcQcHwYOr1ZB8vbccac09xWQlbm5qlQiVPGslxKI09hpKm6NgPIxoc5+dnDKMna0maFhBvHnPf9Rz245TrOo7WO6pdGquw1kk6Lkhsy2fs2CvUo+bEOE/wwVpYSkmUmYgvTGhqwkrNYrPEGuurIGp47TBGur6n35wZcRuGHuz3O/OXVCE4Vv2KPnhyyVjL49xHbBgGKvN273tLEXSuMKBX9IHp3CrKUIdFAivU54p9b85vTV03jWv2/WEcWIXOMPFknb21Ihd3iMqnhbVuo9T8ReCfL2jB7wBeNKbDG44Z1qhLERxp0mmJmplgWsiqcslWp2sczGa9ujxwdTky7GG3C4TwkJh6cD0KdKtA1wdWqw7VzH6/Y7fbMY7jtLxXQax1XW1SdxXYyQRgFvApwaVmhxVQw4kzp6tq9mDogkXOqvAnxjgYDq8mxOaZOw4xgnO4rkNCQJ3jer/n1fWOIaVSKWCw2hAjKoIPnS3NCogUjZ1Lb4iRYbDQ85RlVVaPKSxbont1Xup5uuYGpqImdS5zJanOk4mXo3VM7LpuFtLXrNWv1bAi8n8CfifwVES+AfwvgX+V05Safx74PcBXgGvgX3jd9m8bC19kEtJ8025tBCkXQc0pkqJp1ziMjIeBmGB3OZJUud5FVg87xD1gHAPOdYiLhOBYrQKrlS/dZQ7EGDkcDlOiS6tJW1OgXQ0mAPz4WrrK7tcyIM7n6SY8srcAhlaTwNly7jAAXhQXPHFM7ONoHcq9Zz+O7IeRwzCQS/fsrlvhxVvbqDiyPxxYrVes1xtUPPvLK5JG/Dogkolj6QOWFcmZLtTqiZIHoArOEYJAtvMOLpBKks7MocCE3lTTLaU81atVbDaEQBeMKp5ir981XiuwqvoHbvnoBqVmMUT/0Ou2+Uaj0aTl5VLL1kBASYpZOkWmXeM4ksaROEaGgzIO8OLlFdfXkfcfn5NiT84BF3r6lafvYb3pcQ6udpeM437Kd8050/f9VM/VmgLN+QPLMHPrSc/CrNTcWZoYfU0Srw0yahKOC46umyNr3nnGcWA3DBxiJIlRyo85cciRJKClJqzzivOUqlozH2LKbM8cXd+z3SiHmBjiUDh3FS9+Eign1YM3O7bmHkC1oJfnv2DagelRvgGUZKEmr9iLo+86xmI23TXuTWh2HjJxUNXHFG2Z8NYKBTTPC5Bq/bsqC6IlqhibtzAm+ODDl4jf0vUXDNHCqk4E33WsVo71qielxNX1FfvDgWEYEBH6flUE1k/atcbl5mhQpR6y15Mv1cDFtU8DmPDlbLZzXXq99/hgzTm87+n7dWErTGhIBO/RnDgMA4cxkpISXSlHKXSlhuOW/NqcSZJY94Hed8QC0R0OezrZsN5syHsTVi04dlUOzltnnMqurZoLh25xsCgrjDNKUC9N3ZrWnNk6rfONa/kNljMxFqbz0PXFpLubNv5eCOzkSaeMz0C0LPgIJYZugik64jRCtm6ILkdCipAixAN5HGDck+MBYkYHSGNiP+7ZKzwfhW9fjazPzhnyOfsBzs4E8QOrvmPVWY3X9dWBmEDFmcDIXHXQph1Oy74Yz4HmbJElkWmJE1EylfeAiQrfhFnJar0WIBmg7z0u9Di3xbtzenfgEF+R4x6/7Yhp5OX1FcOQSMkxJnOykiazUVVKwznB4UAUdaV5SVZCBk8GdeRo2hagX61wIeOjMb14ih2KZXYFX5K0D+WUp+CJkpw5ub530/kH6ZuWoo2NW7Rwl5SIRR01KS6UfIY8cpchey8EFqB1Q6e4wRH2Z1+rwYLS2C3PyEBsSlamcGptZjFmdtcjL1++Yn0u7A97zspSv/KraZmvVJvOOfq+p+ua5hgy57S2aIFpziUpGsw5CPNxzw7knBvgyKlq2rLEKmw2a56/VA7DgfVmw2oV2O/3xJgszFoiV8ZiqAzZkr3F+akxh5kURskEhc4yNyTLMRMFomqhbzfqTsG24UVMMUjp1+sghFlrLhzKKYl9jnrdmOKjcw8l/9g+M2YbTbfTxcM9EtgJU11EtOb3qx01RbN09jbre5MQp2xt4BurIcbMq1fX7HcDfVgTxzRdeB9q4kWx8RaVBG4hjFDZU1qurtNpdm3g4Hgb0EJkDcaLlmXWvOfNZstq40hp4MWLF6aBXUdWiCpk541tO0O2OBdGQWrRBlVFUymqnID+ZKHgLuAy5HHkMFqYtlLY974zfgZNRqHpamJ4jcDdtNFp5ur0JKtBdiVtM7hQFIQRj4SCvIgMp3/PfRLYdrKnE16e/CJAUO3UibW7aZ+Z5oYalkGfGYfIixeXgKfvN8XBmR0boMlisti55b3KzeNjnqBKfOGUk6QaNWTbalvb/lysV0tpgAINBfp+xcOHjziMr3jx4kNrNdp3aAX7S//arJkxG6er0bf7mjlu28wKooivJB3O6sN8IIlYAk1Mk/uUUyblkZgUdUKo0aloLDjDMGdh1ZXmOHhzMghEXejN1p9QFmTCzZN3Zs7cETy4NwJrUZylx7nUsDPi0WrUVJsol5M2c8DMg1w0bYyZccxcvtohcgY6e/kt3ZAV0lUsMU/LdB2Vl7VdCkUE50t8vkneaCetFd45dGtedr2xqkkzxmhL/mHkcBgYhshwGEFgGEa8N6E1Cs1ATFbTb5BqoQAVgWwl7SVcYVlSIVjkKgRiVg5DZD9EhmEkakQwToHOBxwGYVW/MadEHEfGkSYVME9Cu4AWbwhsSbXL2Y6m2Bethq4JRq67WyTvj8CWasl64RuIYNa6x3dyLoGDgsum3PTQmuAu0CzEqAyHSPArtCQXV+Fr7WJXMrRae5NyTF03VxW0wmn4/pI0DmbuAjhKUMfuTSNJXtrEc3K3HaO1s7SivhA6q/ca43RsKadyJ9tNHUSMqEINLqr1XJrn8pchJsaUGVMqwl40aYWsFCrFkkUQLcVTmIW1rhzTcaRE3/fUjLSaxF5lVagmxLw6tatODe/mmutwy7g3Aku1XxsIaLm8tAJU7FyYzYJGcC2AUM0GwyTHwRyU7dk5fbeZ8NSbGnS5L1Wdvmflz/lGvgAY3FOjQAuT5UjztAIrYpiqls6HVZN1qafrevpuxWq9YbM5I6bDBNPZNSjWaiEdEbIl7ojBfA6lEyypXIWcMofDQBYlomRxRluvlDwDZ+Hscg2lMsGoltTDeW6Ox/G5zfPEJLT1qrZzWsmapUQAc864zojqbhv3RmCrnCitJl06XTQXoXrm0yM1z7XUN2VKDqb1utLkeHD+iO3mgvVqvQgEWKrfnDVfozsU77XCWpVluuaGmqN0M9JVR6t12xwECwDYzXRsYkyZXqr0fc92u+X58x2HOFpvgnL+TiA4QbJxF3Re6JxRHoVO8FS42nrTDkMkiTJoQkIgEwr2mRAMv0bdZEJQ8desIKdL8E9F9WqLe0RR6jnbxE3VE9TIXrnu0fDh7uKc0KUb+6njXghsixBUe7U1CRbfbTWsljDtVP5SGyfnUvw327n7/YgqPHz0mIcPH9GvVqVmayYUbi9+1bbWZMNPWrVNdDlOOzw2JVrN2gpt1a41apWrPTedZM0am50a86aN8WKqO1Nr3SkI4oW+8/iCMvROIGWSCnQdMY+WH4wxCZpZYFUXWU3oUcWXVF1z2BqyPNXjqZjGsS2ac7YE+YJPaskkt/mtc13o69FGywoPHzzg5f6eC6yo4opWNB0780OBlo6HVXbF6jMSpb1WKdhTa80etdTC5ozLCtmRUs/1XhhyR78+4+HDi6kvli2FMycWWvsN2LF1XZvQUvkBqtBhv8tzN/GcsmWR1ZBuixqw5IBFwbmA85kQ1qSopTBICc7ReQ9ZGQ6WfOMrCkBgiCMqsVQEWNSsK0wuwVXbN1nOQU4MKRqaIGJtM7MwliABNMA+DslaSPSsNMlq1MpDWuI4c+mUXMLMdiOlrGRn5TDZpN+2BeSiXcX50p4pQU7GvijC+++/z/de7G6VlXshsGD3X1lUyx1pzwVrmJMpy2dJgav9u7SiACkzpMzQ0Ee6rEjy5By4HjxD7hhiZrtZs1p1dJ3ZjsNguF/VtBYccAUvnLOv2m7YNzLF0iy0U2+wqv1LNKmu44Ir3LNCShHwOL8iM5LVgyab+pwtlDqOpjW7YMKQi9BpJfJweCdTfF7VWVtSAZwj5oEhRxKUvrFYkCC4WulOwJizQ0FCMtlq2BRUi9qVmWqz2p1ISYecig2zNWR2pSRTxEjf9Ai39c5aU2H5tL7c/DHGxXU+HvdGYF87tJY6LyNKqdBcThiozuRn1U+IKRNLWcjV1TUgrFaryQ61zc+IQY1mVVSgtS1hTm45rkJoE71bW/TYIalw2kQLX4Z9xfJKKyNLSqal1+seHzqudwcrHmyo7akrT1H7WQ3qAqsGjjFP+QXVT9B6jarmdIIrKZIpFRyW0li68IRN6S6yvHFdIZirwu6kcijIBN9JsWOnbC2ttKOlwNS+iK9kdbeMHxyBhQWsdSrzv82TpYYfS0KI5sx6veXy6ornL17y9N0vLsD/tpSlzRu4y9FoObZq7dccbTtdEzVDWDPp8fzwJT+0t0Zz3miPuq4jdMV5S1ZVHMSRaoJ4NvohR8ThiMkQESfOcN3aBM8XrcuMe9csrJQzYxpJajnEcYiWP1DpRkuC+cQY09yk1SyRUuHsS7BBwIIqhcZIyipQV1KDYxsNXY6lhQyPxw+MwCpMzCZTK0w9/aiaVYo9O4yRMSbW23PGMfLs2bPFtts0weNWRssQLAuBbPMWWhbu+ll7E8xmxZJxe8lvUOiIxKHijDjDedbrNc5ldvsdgrLqOpIoYxrJWkK7hQNWRUsGlIU6hzExJp3bcFLNHruqtWdX6Doqrqsovqva0cp5pBybZOuPG5wnZzPYalWtlKw5JybozlU0oFhDlEWg2LQ1U07d3NfhsN/PJtSJcW8EVienqwHrj8KiNdxoDmwJDDQaV6pTgJWf2JJWGmQgxj7tA8+ev+D6+pr1erMQHGDSgvW944hVK6zt87aC9hg1OEYfFrbckYaFkhdQJMx7z3q1Qonsri9xQB88UZVDDsXu1alPV+166JyzPNeUQEpDZdXiMNXrWWxUqbwIYg5k0ZrOmSB3DVoRHHR9Z69zLlqzpCHGRHYQVBjFHLdaTm/9FCw10jtXund7EoZdp5TwIZDGcabKPzHulcDOUYOTX5jA62Wka4ZKKMtJEs/M7MxUCkLx8q93e16+fMVbbz1ZaNYWeqrasR5bu8y3SyIw8WcdY5K3xddnm3i+KZeJJFbmLeIJoUO1ZxxGyAlyxEmPR+j7Hkp4F7GUxjFGUrYoV+WYNXPJVhtXroPmZCzbqoV93DgPxDk8Rje/6rvCGuMLhprofc9qtWoihLW8HdSBFyV4K5+f85ptH5othdILOC+sN2vGGBERxmFAus5ugvueD3tqFFSWdukHFsKSq9C2Ei5SCBlq4wjrTo04nAvgDHq5vHy1iIUvyNqa/dwmtItEmyYkfApIh5ZDVhqzwO6r2ES/JlpNDA3xzkMIiHasV2tISldWgeg7RDzjaHZqTImYCk1nLgnZBVbKSZHgcMHIllWk3NNFCYxW7yUOuqLVN5u1hctLrgYpo0Ti0NiZWsO5ilfLCrOuEFLCsnY9vXekFO0mE+P7euutx1xdXyNiN0hOVpakPwga9saYNFNrEszBhXbZXSLaFm70E25YbLyJncVsxlpk19qmx5lHLaDdCm5rsx5naJ1K/jiVM1rhsjbBZrpxxOCplBKabHler3r07Iwg5luP5RxHTDjHcSRluzERCwaoAb1We+UoqYnGcVv7Q4iYbRmcK6THjq6Qx+Uhopom+8RjAp7iaDRFzIgJUq6xKpoSY4o4KdssTDWWn2BWdN8HLi7O6ftuykMYhoHvfOd77HLHbePeCmyd83byp4jYDZOgcYqqQNdoUlnehzGShxHvcqGBnKtAgYmKSHUuzz7mG2jTEFuBXQQHjpGL8vpYw855pTezv6B47cWhUxJZRry32qdKPNH7QFTLEYBiD3s/lX+rWlohZV8++Gk1cmKt4j3G0t27MNmqoKRxnGieRIQuOKuuVQuMZJkb6rXnNwktyszWaNcilGR41MLdKUbW6zX7/R7vPavVClVl2P8A5MMa7aVFS8yLtXJoWx59iSbZ92zJyIgr9GGlcYWqoxs8brQspL0M7Dzso3K4SggjYZMJ/sDZdouog2zRozEOBvyTwdV2QLBxPd73VpznLMkELczXWrgQJlrMmoxdI0MZyxWAsj7igrdolXRWxy+JzmeiiwRnodU8HkjjnkIRQ0qZQxpJ6WAaTc0OXQdIg5K8Q7qOmEHFFUjLOsNkVRJa7HdnOHUWSILH04fAuusIwZWWmzLZq7mEg63/ggccqsG0LrUWrYMS7rWbNmKkoMlSFBG8eJxqicQlXIZNWOEUHpxtGfc7Ou+Iogxj5DCMt4rJp2Uv/JdF5Jsi8rfK4/c0n/1LYuyFvywi/8ybSWud4Pl1NQdMkFtIptqT1QFqmbtt6XEl51Kd1Ttd7w/kZIRpMY6sVh1n221J7yuEHDEbflmyrqYMMK3e/Zw7W/tyHZsD9dhnTVmfF4w1+CmRpqWSn2LuJYmnIiIWDetwrkMIJiwEMo4YM9dXV+x3OzRbceJ6tWK73rBarQk+lLxY02herK2nTuiKUdNXO3wYRw7jaFq9OGsTOR3KGDPDmDBeSU9SISYlZrW2R5SgmVjebTf1YbBZ60Iw1MN5uhBY9SucCNvNhvOLcyg5BTWD67bxJhr23wb+t8C/c/T+H1PVf20hdiI/Afx+4J8A3gf+ooj8uNY2Kp9izBCMTq/txBovnWIqoFP4sAqJamQ4DIwx0itsN1vefvttzs7OChRjoHoszNpawG9bRqv9iQmAc8B+MgdaR6yNaB1naFVst+uKwIaAk5kYTmoESrXcKELGg+twYY2TbJlXzlsUKiaSWkKMQV/GVKPiTbtmqw4Yx4hmpXMdXcnzzcVJpNzsJDMSpOTzirPIFtUZy5kuBJwvoV9xqNNyzayk3ovhs6C4YE6vK1lyko3N5ezsjMN+Z3kjzjGMA+fhAU/efkrSzOXlJYhwOByOfJLleBNegv9QRH7kDeXrZ4E/paoH4B+KyFeA3w78R2/4+7rXG7Zp1aqzozUd38IpQ4Wa3QZCTsrhYGl5280Z7777Ho8fv2Ve9jiSsi25NfHG4Mga7ap9ZcMEe+WcGZu6r9MZ9rPt3UbOQg0QOMtRrVhnjclTnEP7qTeOWbcq3/O42BFlQPVAVqF3hqvGpAzDiIrVak1BgdIppg+dsRWmsYHgSlpkifNTWzNpwYTFvHopq1YuyS0TebPLk+lAVrw3yEOLDdyiB87JtE0RJXQdY4x87r332J6fkTTzve99j91+X8Kytxcifj8M3H9YjLT4T0ghNOZ29sIbQ0R+XkT+ExH5Tz786KPFZ3r0ZBGOrQzNJ6A6hZaiAM3WCyDGzMX5Q9577/O8887n2KzPiiM2h1JzzgXEr9qwo+86uq6b6XegaNdhEZI91qzH6YQzX2x13MyenQV9Xg4t0lSqXl1A3BrvN3ThnC6cEbot3q2AUHhjTWPXygQ7nsLDFVwpX++N1XDSmuUYxYIG1tVQSAJRLWKWFPAdEnp8t0b8CnxfeGxDoVXqEOdLH4Y5j0FzNUFq1YWthKv1itAFQt9zGEfEOZ6+/TZ93/PgwQO0ZKTdNT6twP5x4DcDP4lRaf7rn3QDqvoLqvozqvozT588qe9Nkau6PLmKg2DXeyLcbYW5aozyeycB1FlJ9BDJSXn8+AlvvfU2m/UZ4Ba1VDW/1ZW/q5XxpXZ9T9d1E6Pe3FBu5hiYgfNZaGuJeE0QP2aL6Tpbwlv2GBFjapnYEkUQCYgEnOsBY+wOYU2/OqPv1lNkzJebrCIi1ko04hz0vd1wKc99Hmqnm3nYNQ4hmDmiELPZ/Iqw3pzR9Ru6sMZJjxOjBl2t1nSd0ZbWvrfiStJLscG7ECAZP+327IzNdst6s2ZztuWX/8Ev8/LlS9555x1SSpZsdIc5AJ8SJVDV706nKvJvAX+uvPx07IU3dsAy6DVbAG04YWEu1PN04knURGfPfj+Qs9D3a+uk4jwxKtEVb9ZVb9eqaH1n0SUfPMHXtvEWTTocDoW1Oi6iXi3G2lyX6f2qsX1XeblK364sk7ar55FzNh5b0RIAcaTsLGtKQtFASso9mRVZ4TAcGGIsvVspeGdZir31os1YACWrlo4uQh86Ol84WktY24ldO4en6wLbzTleerpuRV3avAs4Z9lccRyNCTEXak7nCOJKFpYwNiaTiPDg0UM2mw3jMPDy8pJvfvOb/MzP/Mxk5mmaldGp8akEVgrVZnn5zwEVQfhF4N8VkX8Dc7p+DPhrn2YfNQw7S2p5UTzqyUm5YUOaDStY7yyrmK2xfiWNiXGM9D7hnKXN1SW7X/WFk98bCVqwJA/NZiPu9/uJGC41CRq3Ceq03aKpfZDicLkCg+lU8Wt8YKVGP49lWcds23LzGd+WRZFSTtYvrKlE6EIwZywnVr5ntepBHDErMacpz8Bw1cBmtaL3DlHlkEdizLgCzYXg2azOONtcAEIfVuXq1kR2UI2k8WCdwnM0fFUcq64HSewP+3JNjM7Tcl0d7777LodhQLxnTIlf+qVfKqucR9P3yUsgp9kLf6eI/GQRp68C/6LJlP5dEfnTwC9hlvMf+rQIgcnkHNmaol71dfu+/aL5naE5xpISASFFZb8/cBgG1nkLzPSQXVm+TQvWXFXTvKrGinJ9fc319fWU7A3c0KrVzm2X/5aWUzyTxq6J32ZmjBz2h6lLjZJQjWStjIklGwoPGNY5jiPX1zuL2KmCd1akWOA+a3WfGXNkiJlDjIzZGMiD93Q+EMTh1aAvp5RMK4d3ge1my/n2nD70hIkZ3BVWb7ORVT2pWxNEGZ3dKF6EIOA6y39Iate/2vuIcPHwIe9ut3zzW9/iyZMnfOPXf52PPvoIUYy6Xq5vlYtPy174v7/j+38U+KOv2+6N38GRI9WEY+ew12zjHAttVcAl5FjruHb7gb5fW6/W3PR9FeOxsuU60PWdhRDFkkAozm5Mif1+4Pp6x/X1jhijCZCXqdwFzIs3NMFwyFoGU983evTmpppQj0RMY2lJZA6TYOdRMVkpUTsvHpVc9mMJ3mOMlqydLKXP5M+yt7JmxjhyiCa4NQvKi7NylZiI6FS7JWrwXd+tOd+cs91skexZrzaA0Wr2ocf6RtiNseo6gss4EofhQBxGSMrFxQPOL8559eqVVZAIXO2uecd7Ukqcn5/z4z/+W9jt9lzv9mYHp4i6SjF/etyLSNeU6FLj9fV4s6IxG0NzTPiYCCmXWnrrEpilpq8JkkD1gDpruDGy5XLvcOstbrMyv8XbflQs4uQ7b0u1V8QpEEE9kg3GOhzg8nLg1eWB610k5eokGRRWO804H/BhRhVas6A6XVo8aMhkjYx5z368Ysh7Rh0YdCQKkNal4UbEu0QuBGkCaPIEueB8Gxjyjv04sN9dmVAH34SbhTQqQ06MWYFE513pIgOhJFxbDm9Es91YfdhwsX3AZnVO79b40CHZ0fcrzrbnpEPAuT3IgZgjXbAbcLPesl094OWra/bDnuthpF8F/CZMx39IOz78+APefvEOOMfDi8f8+sdf59vf/AChsxswWSPo28a9ENjXj9NW+BQsmIYJicaEc1JoJQfWZw9Zrzes1mtC6MrDTZxaMxNLXX5rYoeZEZeXl1xdXRXtOqcetsneLRv3cW5tNQ2qMNUc2iosbS6tnW0i5QElIU7pgmOMhk5YKyUlDZFxSMSoOKyhhiYt7C6e3d7sR3wodmfR+AV7lfqfWBqj+EDXrTjbnHF+ds6q37LqVnjXFVrNwhcQBI1Gd6RjIEUlhJ6z7TnO9Th3xQcffZcUE36zYtVZWY9qog89H37wAV8Jv8z7732eVbfh6uoSkcw47FGU7WbDer26VRJ+QAT2jrHAPCmRLtMwu92OOCbWmw1n2zM2m82kAWdctKpzKYnJtgSP48hut+PFiyuurq6m7C7bj7HAtFTxbcj1OJmlFWBgwkuPk2im83AZ75Xr3TWH4ZqLiw1Iwnmj79zvdjx79iEvLy8ZDpGcYbVe0/WBIUWyjnhnU5tsNTaqomIKeFc0fi65DjjOtg84217w6OFD1qutFXviWBV0RQui0RUUZRgPDMOIuMDZdst6tcH7FcGdoQKX+w8ZDgOhs8LGmKz+brVa8ezZx2y3W/5rP/WPcfnyJc+efRfNe653O95//0t89LUlLt+OH3iBXQIENQfTcMHLyyuc9+ZAnJ9ztj1ntVrTd6sicFXQipNV4voxRa6urnn58hUvX16VhhUzAwxYb6v12rhj+9Lj6i5uraqZj4X0VB8wE1hwPnN19YKYrri4OANgvzvw8bNnvHj5woR1dJxfPOTp22/TrQLPXzzj5asXJmBkpCZxlyQ170rz5wSqjlW3Zr1a8+jB2zx58jYg7K/3bLdbLs4uoCT1iAh4O6/9YWC/P+B9z6PtmTmvrmfVbemDtzDuy5HnLz5mHKJFFeNgWWRx5MmTt9msVnzzG18lOIcjEsc9q87x9Mkj5Nd/AAT2brj46LvaGgLNL0sUxxK3Yb8/0HU9m80ZZ2fnbDZbMw1Wa9brnr6f4/vO1RZHFhy4vtqxu95PCS5Qusv0PTlnVqsVq5UtXa0ZUI/vVLphLVochoGxwDwpHRNtULzwzGazpu87nj37kGfPPkRV7diu94xjAgJvP32PL37xy/TrNeN4YL06p+/WvHj1jMO4w6e5zNz7jlActq4wJJ5tzzg/v8C7NSmaJj4/f4gXz3CIeAyhSNPNNuCD48GDxziXC7wWcbJi1Z8ZdJg3PH74BFF4efmxBRNWNkEpJV48e26fPfseq1XHMO7ZbHveffdzPH37CSn/yq1zf28EFhqtdOQk1uQWGtx1kSdbQ7dNabOWDt19tyoe6wM2mw3bjZkGq7VFmmzJMsdpHEcOhwNXV9dcXl5ZfF514UhVwrNaJt4u+W2FQntctWapJaqL5bWIEApWW1GDrlsVSC1zdnbO8xfPuL6+ZByNzdD7wIOLR7z99PN8/vNfQFzgMAyE9ZqtU7abLZtna15dPieOESeB87MLtmfnU4aaKzard8ESiqKYXe9CSScU0hgZU0SzCXLoOh48eETX26oUx4ExDnhXMOGs9P2KIe4JYcODB09IOXM4vEKCoJpY9SuyKi9fvsI7K5bsVysuHjzkp376Z3jvc++T/q9/5VYZuVcCuxxN+LDJZJpCsbkSGy9/paW8OcXMOIx0qwvOz84nDbtarVmtNjY5JWUQsaTkw+HA5eU1h8OBSnNUtWptRd86WXWZr8WKbVVCG9So36tl4DB/tyaGVLzWYK0NqJDiNSkK66K5urBhs4bHj97inXc+x+NH79CFFbvdwIiDrKzXHSF4Pn72Eat+w8rBxdkj3nnnXfreGjmPMTPGNFUoeBfot3YjSs0zyBnprbeCIKz6nr5f4UJnOcg54V1H160Zx4ED+zIfCe8CKa7ovfD2W+/x6qonxgObTU/WyMcff4wmGHLEB8cX3/siP/VTP83n3/8CUvuV3TLupcAKM1UQzMGCiStrSlhJUw7BHN4EcIzFKVhtLTCwWq1Yr9eWKxoC3jPZrinlstTu2O+NxH9VuLe8d6zX64X9WqGqY40KM4VkmydbBbZNR2xTEus2DXXorOWQBLbbTNetePz4bWK049pstmy3Z3jXgQZiVNarFcFvGeKAIxPHa5x4Nus1LgUenT9h25+TrOUjQQTf+5LEYplcQWr+SmkDV1ILKwbsin0/JCNclq40CtFECCbsFdXo+w7hHHGZfm2r0qvLjwid48mTx7z/3pf4+te/zigHVpuey+uB7334nPe/8Jutx6//ASyRkbIsAZOGnUpicp60bT4yD4AmAcTClrakBfN4+74U+uUJzqpJLeM4li4xFeyXYud2kyY9TnSp41gY2/4K1SSoiTIzZ0FBFJosMQDRQCidEn14jEgCcglt2nfGIRG8dRIcsrXm7PsNSQ+MaUfwHSkn+rDifHPButsSPYh4cB4kkNVRKYu9yxY4aYguci1/sUgGiNC7dUnstvyBlIfCmp0Z4x7vheBXrEKHC4r3meCFs+2aMe75wvtf4rf81t/C9773Xb7y9V+lW1sh5YMHD3n5as+P/fh/mX61vlUu7o3AynHRQcmUtzbqxX7VmXKn/ucK35ZkW85ELUVvyJmIciihz95bmp33jpkqSiw1TkBF6VYdtWW8K+HQvpsL90xTVs3YPnTK/oJljmxrHqQ0kkqjZlBCcMToCsQUijZzhUY9Tjm5xq0wIqE6Zo7NRcc4JA77K9brDd6JhUEFwuohV1fnXO8yZKFfdXR9j0uFf0A94gLgSx2YQ5N1tvHS4NLBwrtVUSCCJityFHEWcAEg4twK5xQhIXhCZ/3OIOK7cx5cPODi4Rlf/PIXefTkbd5+/0t8+Sd+gucvn6MK69XGmHmuo/UUu2XcG4GtQohaiDDnbPXyubAUljwCMLmeSmHUHq6Qw2U1z3UUZXCOHmG3G3BZ6MQmQl2ycu+SKyDeCuT6PFOaV4zW+5lCx+L/JmxVWFOK5MmeXmZe1TFXJSQgWRhUmFLyrPogF60vqKv1UAaXGW9Aj7pZW6MB1UzorCIAsZr/lBPbbs2ji7fweF6+fM6oA653SPKoBjQ7nHRMTIwO8P20orWmz/FwOVIZ5OyYtaxgRtWZ41gKESOaChmH6+nDiouLpzx990s8evct1udbnory8ccfMwwjIGw3Z1Nt3G3j/gjsYtRsLCYNlqeyjooIFPGdhGQ2H6zSoDJld4yjZVqpNrxPjYMExlVq5G9zzwNLUplJ4o4152yLLgV2EbVqHTBOCzTULC9rU0TRMMflNu2xWDNnLY7jHH8XWeM9PLh4gtAxjokXL16yWT/g/PyxJX+rNwp5cVOypnfdwsxp97s4Tj/PiX1eatMEvArq/Ny4OlriS18CLM57zs7PePvpO2iAmEY+997nePnyslT+CuvNih9I9sLJ0WowzcpeOHFs5fqcIrhQ1ndiNO6mEHpizOx3+8kBEu+KhjOIadaoxiOlRcOnnMhxJouDebmvmGqN27cC20Jvbd5s5UY4Ftq6f8W4V+vSfzyOS8GdE7ou4INVtIoEwOz37eYxXtZst2c8e/4B19d7thulD1bQmN18Q1pQpKkvK/s6VQzovSvzYnBXVS7mrHnwdmMmnxndAUNErDK5wnkueFwXSDmz3Z7TdeuSvnm4swAR7rHAApP2POapOvWYDWAr987JLlTwdopDqQjtdW7QW1P85jCt/abSxk8lOTo3oJihKRqn6ubS2R73FEQ4oWEXIVyxchXETY5m+91WwzpXv9PQdqqYbarKut+guePsfMv5+ZbDIaHZFXjMCC5MOLVsL9zQsP6ULemKOYSgufZPGC1xSDOilpREV/IayFbYWStwi71PsNLwcYzWwbzrCV3HvuZA3DLujcDW6JUt8ywQgqU3zkwJPwHzgJRu1+JArTsL6lmvN/R9j+bMOAyYaOscjKCyl8g0SSImoNIem+qEJACTLVknvTaVOI5uLZZVnYXuxmcwpTQen3PdXx0TxFYypWbSPFtdum6Ncz195xDZs9k4Vr0QRwh+Rdf1gJt3hq1Gx8hHC8fV45sVRLnumPYUMpQUSouQZ4PHxPIfQugQHwBn/WpTxnU9oNbAToR+vS50SfecblOnNNeiSeBGtMu+ZxdqFuw64XNSSU42aYfDQAg95+cXrFebKfTKCQ1XNfQctao1Zc5I04qWrGHaljhuTuKej6E93sWj0bCvuSKLV8d2Zfva7pfa+5ayvHeg0IUOnLXz9GLVE94bz4EdX8by62vvsNl+t+0sG8cZFGsM4IU+rsCPdsyC+Qg4LPlTTWidF4uOhVAa31mVsBQneJ5KXdTQnRr3QmBPjWmCjyZ5tldvhmetyZzZgtfXB87PLzg7u2C93hQWQMuKD7RCUDfQ9qCaObVyI6xt5Kr+rR1oqhlxHCQ4DmrMx3zC6bK06jKZS1vumPpzoYHFQH3nzI4306Zqt5KRph4Vh3d9cZLE9oVHNU0mwXTtdbbt2xtuSuEsz0VBvJg5QGHYdoKINYQWMaI35yuEVsjuCv9ts3beuCanxr0V2Hm1WlYWoHrjtERKlpbY8mgsL4m3nr7FdnNWIlwru1iYiWgwVfP7khsKDQkGtYPL7PW3WVmzF79EA05xbEnZ4bHw3qwHc0Xo3EJw6o2wYJip010y+qspZQI7fw8qaYfHubk/mUVAreRmYqFhaX/X46oojThrwqFaAgxlnrQePyWx2Bk8WWvmxNV9G1pgE1C5Deeb2CJmt497KrCNdrWXi/cnZ6wIsHMC3pGcGfIpZkLoefToUUmqXtH3K/OofbWPbDmVYpch85J77CTVx3FidtvlsD4q1NXmxdbfSKNPWm2ytB1lshXhqONi+z2TkPoBNtmzTS+uNjkxQRGsJsz7rmhOKeQXRllUNewEIbJsAg2lba23VklSHEMREHXTfr0I6jI4xTrylPZGbiZtFlfJk7VxWurNcbeWvRcCa4GA4kBMBq2iJFSSAf0kJEcjSCvEcZqtzMW6ndjtHAWuh8TF9ikPVp9j3b3FevuA1Ak5AF5w6lAn0w1haGLx1rUGJcoFZSalqzajmQ6mkeaK3DTZg0YCV+1iLb9nWv+qIMCxLW2CN0fzji+UTO03qzaaBV8QsWNytYGGABRuA3ElBIz9xhkiYfVpvQUs0EJUomgh4kCw6+DUSpZg3m8jXDXx3Y7MSPW880bxWcwBJaAlkpaL2VJ7rNVqXDl13s24FwILdYGTsrLNF23q2SWl20jxyF1hqYbW3jVZTlnZrM9Z9+ecbR6yWm1wncN1bmoMQSi1/kWL1uIRe15lq0JOy5ZHM4zVvsdCkOaUw5okkhsncd72wnTgyIprbUpmu3U2E46PYYnT2t/iTFVTRmZnbf6+mUmVWrOu6lLoQI24oNjE03E3gZGmgwJigi/Mx1LZxKfVQaTMo1iYvHF4pS57t4w3YS/8ooj8ZRH5JRH5uyLyPynvvyUif0FEfqX8fVzeFxH5N8UYDP+2iPzU6/bRXnZbfqv5Wp/fXD6rENV0vfpbswGzwVldN6UG1gZx7XZccQLqhTp2kkSOm2bMF7393qly79bWncyMxbZlITjTDqE4LbfDWqfKcCYs17kbf9tGIO3r5aP9zc3ttV1vjuEvO8n2msh0DsfnuXQWZ/Pq+BreNt6EqigC/zNV/QngdwB/SIyl8I8Af0lVfwz4S+U1wD+LEWj8GPDzGK3R3UOYtUlFBWapXTg1LSbYOkiq1ZY0LoLNxkq7Q5gbGy883smxovy+Zn/d9M6XNWDzhT0Wvvbzk4GDhSPWnvxS67lmom9cqvrZHUK7fJwW1vYmbM/tWIjnc7t5jrOWp1AUtR0jm2s1CesMg5WpvbEqvG68VmBV9duq+jfL81fA38MI3n4W+JPla38S+L3l+c8C/47a+KvAIxF57659LA5VmZf3xntcwkTz8noMbcUYGYZDyX9dFf6nuWCwmhO2X2m02TJmPx2bLMncjoXVntvfVqu2DliLcLRnfXOyilkkp7VN+96bCetpQTslnLON3h6T3NjXLKzzeVhF7nJbrt0ep4XyGKe+jQmyHZ+IDE6MdvO/CvzHwLs60xV9B3i3PH8jBkM5Yi/UqQDv5glWw/wGEN/APpVs2OqOYiFyM2fCzIK57kqL/VRb1rejrYxtJ6jVki2RMXWLjXddt9MeczUJ6raPJ2ban1+aLSeu20lz4ViojrXpKdQClrjw0hw6rfHm67602SeErdW6jVa135Y+EhREwbsbx/06TfvGAisi58D/GfifqurLo5N4M9R3+ZuJvfBJYS+ERtu2YLWwOCGb8NnGLNtbJKYIsCkVBn3f4/2xDXY80WW3eXmntz24lkK6tGNPvdcKxc3vnsiHOLG91y2XtwvgTY1cz79lU7xt2ze17Xx+p47thm+/NMvLGS+fyNEq8yamwRsJrIh0mLD+H1X1/1Le/m5d6svf75X3v38GwwqPqKXtocsLPkM2cySmEqkNw8B+byzZ2+12KsG+eTHkxjZVdaoCbXHVFrx/3cU9JZynBPu230w46msmzsz+pbAuPm8+azVYFdRq07fmyPy75W+Pnx9vt2rY4219FuNNUALBuLT+nqr+G81Hvwj8XHn+c8Cfbd7/58XG7wBeNKbDmx9Ys4wcOy+mnea7vTpLqlpY8kZevnyJD0YZecomFJjsrvpZjNHyOJu2nFVYj23AY+GvxwHcEPZyHW891zexHW+7WW4TzGNNeuw0nhLG+fVN7Xzbvo41bLtafRbjTXDY/ybwPwT+UxH5W+W9/wXwrwJ/WkT+IPA14PeVz/488HuArwDXwL/wSQ5ogsHdLASW1JLm8pTSbHeRSKzzfS3O8ez5c3LObPoViWQBA+etX6rU5AtBKL0MgDhGY8DWWnuVOOWM3FSWNzOwjm1s59xRa9KbGo0JAL17eb8xFoJUWyr54q17lnbkTXt7uan2eHQ6Vzvv2d5dHtNstomA1iXyxiHrzVevcbKOx5uwF/6/T+26jN914vsK/KFPchBWApLAJbLPjG4k5gNZrFDP44iqaDqgaSjtJq05mijG4Uomx4w4CCvHt77zDVs/XMaHYGUnoURdvMebqFr4UAKSjc8/j7bPHNUAvc6EoDoalkZY2/7M2UY1dl8FoYZuRWaHrQYclNqesnZxLBOt7uQELoXl6HqXfyzcWYXTCvvMzJlhJpEZ86yCOz3Pp7Zvx7WstKjsqbWhXHVSW7PBMXX/UawfgtRkefNLvPOTo/1JxvfT4+A3boh5jjlXWnO7y0Wl1T20RG32Xs1sZbp5nUDXBcZx4Fvf/qYFDYKn74PlRWstDzdBaWGoqaoh58n5ahuB1DquukObpOPJus3JYvqsTuQyjaeBtk4sx7dfupmUznt/ArA/bW+fskFPTMvJ418+7jy8W7c5OdSfcNwPgUWnpGzV4j3eKEQrbSZdBeXnk80l/u2c4arOQ4wHvv7rX6PvA6ErdPAlFTOECveUG0BZtJLPTRn5hPs2y6AIC3v2VKTmBgJw84xfO9m32Yyn7FUrTS8Vv7dEuepxfRKv/PTQW56X4z55zLPJUo/jU8jrPcklUC1xbHOEcumGWE35mqZS7+iJRAOd1kSbfCm8Aia43/vwu8Q0GuOJT1g82/hgqwwqOhUpDsNAHNN0VWos/ViL1otuNw+T5n2dhl1CWHbcp8ZsK99enXDsoFV0oY0ytdll7d+Fs/qJl+XGbl28Xhzc4ivS/luUeVZL+L4Bh71m3AuB1XLwXiz5OqmU8m0TGLBaoTomtGASVltjRSjUl0bxeNjvub6+YnO+Rf1c0pGzafSEsVzv9juur69LvZbitZY/i+V1yjwHrtBzt45TzpDS3dGcE2c9OSazjbr0sI+14l3Xz1aBOcnkFBpwCmo7XtqPbwJ7k2Km1WvYOGZSzuVoCFWrztuYbnYRqMkzp27aOzTvvRBYGzrpU8GEVYrhbrUfN2mB6rJaTQKwOqsQOjabMx4/fourqx3vhI6EJTU78aRkS3pKiXEY2V3vSneYRHDdNOEOQX3Jg5VyZJMNvZzkakt2XdfUei2LFqfjrgIiFG09n5sIU91YHbdpW3OaWtLkMPUiOIbgWlOg3ebi+jcoSEsSImVmaoRwiV7AsZatcSTD0u2Zl8ZsESnz8cnNkXsjsDkZY4jDg1q5sxZh1YIIHEeRyvSZ1nOe7DOoIyXh8eMnPH3yLtdXe1CP90ZElrMVKcaUyLFQFMVx8pir0+JdLfTLBO8mTVA1xjQpR3jwqeenhrRqexqzbX6sDRe/K2O2nxvbtfLcftKxgKFOmDMLm3uG607DV8tRb4SazwF8umPkngisNaCIxQEqmjUDk72XyXqqCTHzUlNst67r0ex4/Ogpjx49xfveboCcidF6y4oEVK1tfCUTBoOigrfGvqYJHIS56LBOUruU5pxPTthdDtckdDLnldbfHId+27+nAP/j7Uppgrx87+brUwI5AS7T36XJcHxOqjpBx6fG7GzZ89XKOvV8Cl9rGvdCYKfuhs64XYWyLGUtvADLoj5YOkEVR7QAg5EZv/XW21xcPGS9PiOOGdc74pgZx1QK5WyfKaWGJSbQ+ZLZVbphZ3+zvqpqwloenrQh+8jLyNxtWtZuMjf1+zK8lhvmQ5uM0/72phPWbPeECN0m5KfHKchKj95vKx5u32brHFprqerRvsFhnBj3QmA1ZxhHvOsKnBRBR9ARwbicZDIJIKsB4ooR4iK54LjCMDo2m8e8996XefjoLVbrFTFHenHFJCid/oR5ORfwXSAUFhXflcQQmFgM24pZqIGCajezCOe2/QrqWEaFDEGuN928BGtxcFjcINVcOd5e1ahzemD7nTnqJXITZbhpcsh0DK2GnZ1au17z8c5a+fgeEFUWtVkiZDJd3xWit0+vY++HwKaM7nbGjSqZrDsc1zgOCCMQQQzGygk0FU9fE+oizmdyDIjrGWPi6dvv8vDxu6y3Z9AJuBH1QtYdWSHFSO96FHDB069n6vfaYKPayB6ZJmpeGg0vtoSbSIqnOV/bpdzKwXO52YpwYqiDadZUbkBbIerv6t+q5et2TUgNpjM43VO6HaNUaMtPTl17PMfHpqrmjOZamt2WlFcBtW0zwXr188yxunQoTosjrA6VjALdui+kNrUM6QfU6co5sx8H1tWzREolptX755hJseYT5KKIqhtkdfw+eGQQVCNPnz5lvbbmwUbe0CavFDyhOCdzYrcskkWgTGqsQgg2cVZlOo6xPEaGYSxNk9MkTKcA+upvt3bwIm920linJ/I4kLDkw9LmOy1Ge9PuPGX7WhGi0TxVz1+1Cm7xEZDJ8/+kw3tP33VQtb1Uwf0BxGEzpQFaiqhay/ic1TqdJCBZ1xNyMtQgF/uWEsoV845zyey6uHhQlvGEZE+KCdRgn74X8ME4UVVvJDcfl7hU2pzWJm2J4GKMDIdhgq+OnaJjfqrZHpbJNp+HWDFgvnsS5+OsZSylzrcI6XF0q7V5j4XVOTc5jjNENRc52rEaoTLzffGJRwiBfrUqx5JLwe0dHttt2/l0u/+NHRNmWRygWjqtOSOFG9ap4BScGbFojii1VMa00xgHfPBsN5up5qluX5xxwHrnIQVUTABrHB6W2mdCJEoXlhgteyvl0hv2MBryMNaGFMtKhdvA/vnzuS1n1YgtenDXtZq/q9Nvncza9jhvuA2HnhJe+zsTNC+RkDSFqb8f29N7z6rvi0NdHbUfUA3rRAgONFpoNMeRPEZSeeSY0FQfEbIY2YkYGXFMxl6Sc8aHnn7VEwoljg+mTb33SNeTRFAcuWiRyV49tUxnRVOelvyaZ1BJ4VR16jQzaSq4YRIcw1XL6FNzo4ixqWiTWnnKeTuGt9rPag1X/f1sKy8LMFunbr6Baq6xUvsX5IZp/E2HOGeKRgojo+rU3ESnaJkdWr4lIHTbuCcCCz0ZiQMMEVIiDQfisGccD9bTahzQGCGVbC5NaDYnRUtuAaJTxMeiU5WzfwaunUAWP2mN2lwD5mV/SoJJiTwoh8OwsFGrRq3QVtVqxyU0rbNk24YqQK0wzghAXXZlovlcIhNLG7Y6Vsc47bHN2la/HjuF881i2rjy3OYbwto6YafHDe1ftqvYdQ6d8ZuJW4a2b1uNTo17IbBehBAPaBzRwWxCjZEcD6Q4WG+AOBY6ciALMY0kHUoiBSiBrJlK8+6cM9+4ODM5Z5yU5mrSMYxDYdibtV+1SQ+HgwloTKRDXgQX7HvmeNnmW1iK8t7SAz8dtdJJI07vi1QL54TQLRNZyqnN+6EVwPnzU3Jw2lSZn6smJvKPCX+tlKQ3t1f3OcFhBQUwfNxa2vd9X6pIanzy00Gx90JgyZnrD79HVCE7Ty4Gec4jmkZyHkl5JI4jcbREE82JjHHsU2CYmCLSaFhrezBrTZzQ+Y563XJppFH7yKoqh8OB3a7mFmQY50LEqj3mLjC1O4zBWy1C0N4Ix5oSzK6ctXsRzPLvXUv+/Hd2jmwf83eWv7s90nbqRpqYdhpBbXOAb/QfqHhsI8yGeMxpoJ0LCzK++p031artuBcCm1Nk//IFHzx7jvqOx2+/jfhAjgMxHohpIMWRNEbioCR1qNSlJReoJBPjSLdyrPoe13VonhEAzWUqHFMSSxW4utynZM3lrq+vTYiT4rJfCGgrsK5EqkxgZx7ZY9B/EgyZbcpjDTo9MEzUudsjZPVvW/mqhaCtoge23ZsBg+Nt1M8tB9i4wU7ZwK8XsCYy1qjbXGC62ohvOhrVmVP5E4x7IbBpjBxevELGyIcffshhuObd998jHnbE8UAcDsQhEsdMjBnnBecVZaTrPfshIbpBY4DtBdGf0YeeIIILxsDl1OOxsozMAA5850pXauvppQnGfUSSx2tvqKOkZqKW3nVdMitOq3rTBLCUv5nwDBELCWe1G8I5rKSkpAeqrRgiS21dx9wpUECt0EcKPNQe57FsTba11My20gFG82yrZrNh81QGc4y52vUwhXpT0iaTQCDWSJ5TrKPMiCtcaThzfNGa96DNNu+W4HshsJqV4Do2K+i7wK/96ldYbVaklLm+vGS/33PY7eldh/du0gSh9JESnPli2XP+4AkSVuB9gbkzIsFaJOHKhSmkwa4kNJZrllImR9NwwZkWT1nxfll6fROon7VVXeKrsM3IgWfueQW1DGi25ApCUITopsPWJv246W/VpnIksDdNhmZ5F6j1ZMrcTdK+1z6OhUfsxlrApze1rtrplICNbfT68orDfsf6wdYicd4j2TXyWSDKHwS6TUW52u+4Hg6MY+TVq0u+9Y1v0XUdV1dXxHFkf31N5wNnFw8JXY+6ROg7dsMBXMfV7sBqfcZ773/B7CVXiXfzQqhESqVAcXBCZ3ALGslpmJZUX82NmG6ERSsvbB0VIWghsbrP9rcxpuk42gDFQoOW26y1Y4+dr4qxHgcHXjdyCbZUt+fmzVAnRBefz/atnhDP02M6/tIZ5zvf+R5njx7w5R/9EegdSRPe9Y29TJH9u/fw/bAX/ssi8k0R+Vvl8Xua3/xLYuyFvywi/8zr9jGMke9++CH7ceAwDDx88IAHFxe8/fQpn3//fR4+fEjXdVxevuDy8qXBV96DeMR3pOw4DMqTd9/n4YNHE5dWTRNsJ38uHzEN24VA31tDYYNejMug6wyGMebDbkE8MSdMzzX/bVi3fd7mgB7zXB1H2No6s2O8ta0dO45ktUJyaixuigaBqE5Re6OllEg5T1lki9/rm5mc8/btdY7KRx98zNe/9g2uL/d46RAt3LNiXWb0NZq1jjfRsJW98G+KyAXwN0TkL5TP/piq/mvtl8WYDX8/8E8A7wN/UUR+XFWXaqn9jXP49ZqLR49470tfBrFQXmWyvjh7wLtvv81XvvL3+eDD57jQsX1wXgShY4ywPnvEO5/7MkPUKVVQybhcvdfl5GdRnAKFbGMcLB+3kphVbdKGVlsMs4WZ6gS1JdQw47rzZ5z87BgVWPj4DURW/7bLfFtWfmrcYE10tR/DUoNWDDml1Dhfx/b4fOztMd3YZ+GL1aw415ES7K9Hvvftj/jwex9z/uCBtaMy7Gu59RNOYjvehJfg28C3y/NXIlLZC28bPwv8KVU9AP9QRL4C/HbgP7rtB5uzLT/+X/oJu3DREkpevXrF1dUV3jk22y3bzZZ3332X5y+uGFMiZSFHJRG42o18/gtfpls9ZIylE4mrzNkUwV6C60K1FUucu++sN0KI1Lb2JmDL1vInrs+k7U6B8lVYYQbl2wmvyeHHkFe7ffvtnLNrqY+W5XUswMe/a58bmccySNKWsVdTZ2oel9PieE2gbuZLtCYQUPqNKa70a/AusLse2A3P+NbXv83n3nuPs4dbhjxYqQzlJtXXY7PfD3shwB8WIy3+E1IIjXlD9sLFdr1D+p4swjBGLi+v+Oh7H/Hq+UsuX13x6uUlz1+8JGUldCu860E6svbsB6FbPeLh4y+Q5RxlZil0kzlwUxs4L/hg5d+hC6Utj8OHmlACC9dClkklty3bxzblKUz1pnlyN0GxVVJ0k7BaKcxp2qF2HNug9t4RjNbYse1SPv+mda+W5MPtPhcrh+bJedIMmoTxkNi92vPdb33A1csrNCopR1QyWRrs9zWWwRs7XXLEXigifxz4V2wv/CvAvw78jz7B9n4eIzzmvbff4vnVK/Ihcri84tXzFwz7A6nE8w+HgWE8gMtsN+esto8Q3xNxjHHk0Vvvc3bxLi+ee4Y4F/CZ9sqTpj3av/314HNtKFe/Z9qlDR1WLWj9sPINrXKcR9BGp2aNGqZlt753cik/annUfm/e50zN2WrsVkCPy21OUYCeEl7RirtOB1S2vzymU8WV9jfjUANCsjCOid31gAuOZx+94Lvf/h5vPXmMbMXYfSqqVfdz84pM440EVk6wF6rqd5vP/y3gz5WXb8ReqKq/APwCwD/+m7+khxjJ48DuYPwAqkpOif1+z8tXr3j56gWb8w0PH77Den1GdoHDYcS5DU+efgHvzxiGgZdX1+ScJ6D6du+5udiNoNbHPJlLO/BYq7zOS19qVhO6tqr2JOXlCYG9uX25oY2OzYAbXv5ima9h6RP5CjILz7H4HN+o9TcLW7fZnygMRWA32zXDfuDb3/w2X/zy51mfrUyz1tXsDfyuT81eKEtW7X8O+Dvl+S8Cv19EViLymzDq+L921z5UDWwZYmK3H4hjxruO4HuC7xAsqz74wGq1xrlAzgKu49Gjt3n69D1iEq6uB54/f0XO1W7UCeq8gShOENeSPdp5VwjjllrpNm3UCvLx8tz+trafr3ZiXeZvp2tfPspRT4k8x9DUJDBNeLQ969uPfc4/qOjJTFnP4nHKRJp6fjXmkB4Zo5Y/HDnsD+z3A88+fs7zj5+TKxKh1NTw+vLW8f2wF/4BEfnJsv2vAv9iuTB/V0T+NPBLGMLwh+5CCOwIlXTYM8aRqArrNZuzC/rQE8dEWL/Ab8+J4YA7X5GDoHmFZ8Wjhz/Cg4svcHl1xdX1Jd/55ofkgyetRmQ1oj6SsiDao+IR70p392Kn5uoMGbgffEcaFRHPkldLTz5vJ+t42W3/1plp7dIKd90cFrOcldaRA6UmFNNlnTTejJdSAhCUdkRorTieUwirhs1Zra+Xq+Hh+p3SxmkSvjwdSnuTtPVmJugWwUopEvqefDUQ8x6JmXHfs39x4OW3L3n/80/pzzsGHXGdMsqIekVPrDB1fD/shX/+jt/8UeCPvm7bdThxXKzXrH1HUCGOCe8dY7IyFPHCxYMLZHNB3/fGDCOOEDqePHkHsnU/vL6+5urqilevrlhdnCE5l4vv50mtF1qX9mnr7R9roQr5VEGry2IrvHVbrcDW9+YxZ2e1Wvh4HHv99cY4Xt51EuQlMtEeSxs+Pr7h2odrTKJZ89YDWuq89pxumAPTd+YjM8y8ZMONkevra559/Izd9edYn18sbOYblGpH415EurwTerFElDwOHHYD1/mKlM3u6zY967CGkEECMQYUj/iet5484TAkUswc9gO76z3PPn7Ok3fPyvLp8IWcQyxLxqglTyEHxX47BT3d1CJzfulxVtYpc8H+LtlXWtuxHa3T1Dp87WdaYLl2v8f2dSu0p46rPZ9lKuF8I6hFGm4c211Dq7AXeK4Gcfb7A+M4cDgcePHyJa9eXfLw6RlT/q8HeY2Vei8Ednd1za/+vb/P5uwMFY934EMHziOhs0JCsLIYCWQf0Cxszs7ZbM+52kfGIZJjJg6Jjz96znh4l+3GF4pNh5YqBRNYyyVQEcg6L/0wJU7XpbsVnmPt2QrRQvOdmNRqEx4L10mBnZbseX9ioPAErmsjXO0Nc2w/t5RDp4512uekVWeTYXJCF3bx0bGeuum0mFjl864LrDdrrq+uORwGclaurq549vHHvPuFJyaFCiTb3/eNEnzW4/r6ml/7lV/hR370R3n81lP6EBAfkK4H74k5Q8p02rGPaneuWF6B73o0J8YhkkarsXrx/CX7/cBGN0xcs1A0hWL9VctCmq2CwPJZlxBRFdhagWCb0Mk8qN87Xq5PvZ6/lyaUoO1Xuxgy9wyrlRHuhKAdmyTHpoi9TrcK6ELjHqU+TpfrOBp1UjsfCXK5Metf7zyb9QYRKbnFkf1ux6uXl4xDpPfGBqMK5FMM5/O4FwK7WvUcxpHr3Z5HzrPebMnegw9EgJzxDrosDGlEVUAcZ+cPUKyNeUrKsB8I0vHy+SXDfiAeOvy6CgpoUnAWko0YOCtUhmqPpqU9KdVMaWzW+v5dpTD1PTv03Hj6Fd+10eKx0Gg/WSbSHJsEC4FqRrW32+9VTX08btihJ33zYg7cUKDL394Ygmn18ntxQtfPiEiMkZQzV5eXHHYH+nVHjgkXSlTxDh17LwTWh44n775HtzkznhfnURfAh3LTlwuXMpqlCKxntdmCeOKY0AwOj5fAOCR21wdS3OA1gKqlFwZKSHZ2WCY711uSRoVqrNzchLUF7VuyjGPNcio029q/N8u6l9p4qgkT886PBXapKaeA5g2z4NTf41G3d3O7p0yb19utt+1DSt1ZF0yLtoWc11c7dtfXPHj8AOd8KQy9e1/3QmDFOR6/+x5nFw/otue41caS4HxX+h8Uftg8IIWmyPnAerO1RGgFL4Htest2c8Z4GHn14pK3h3PWZ33Jerc8V9GZgE1hbvZWkjyrwFZhaEtj6gQfVxfcNm7awGkhgK1pMWVKpWS8XyecpGOBnXsv6A1NfHvApLnuC6GlbNuujGp1nGan6022Sb2aLS4NU1SulhuNw8B+t+fy1TXvKjgcBqPdvY97IbCh63nvy1+2PFexlvKKIC5YEZtmXM6IRGrtvfeB1XoDCH23ogsdZ9tz3nr8BO8yV5fX7HYHNhdrEMvOgoRgXLMqpSw7G/0Rugyvml+2tFXrctsKxbFHf0pwWu15yv5sl/+cMxT88zabtY5jas5TEai7BGCpYYUWJZi0bWMSnHSwTgyLMZT0+ZyJpMVv63nGGNldX5NTstLpN8hsuRcC60PH9tFbVqaCkAtpRs3Cl3phBcQ7SIrzgdVqg9BRs5vWqzXnZ2ckRg6HyGE3Mg6J0AuQSIoJLJUdkcJ2qEXz1gpczL511u37hkaeIjqtR38zelSduLkRyJJsA044P9NYRpVswinHPi/Vs/Zvflm+J8L02dI5au3mWlo+w1rz4+g42tfFNj3e3vSN2lAlG2eEpkRwjuQcmsCJRzMc9gMpKS4YVdJvWPLLZzq8x58/Iu4P5mAVqckxNdcvM7hEwhFF6UPHarVhd6VcvbpCk3K22XB1uQcVhgPsryGPgvQKEskYcpLVI9HIj3M0vgDnPJiZTMzFwhWHeEdORRuiEwEHYsGKmK20Q6YJv4l5VnOgjXKpzuQbrQ1qszyXvQCNsB6/t9RapzXgcVZVzaSqj2THL7PAvk4z5+JQSY0WLgIYNndenYV4s5LiiKZI7z1ZAi47XO5J0XG9G0lJcBqYymTuu9PlRKysBbH4csrkGE1wJm0kE0InODabLd47rq6uAOhXASSz2a7gYPbgfr9nOAx0qxUEu8SVc9by3qSJ8x/bizNRxnEeQX2v8mk5oZB5tHkDNwXo2Aw4ZXPWEpl2nFqGTbOeJnZrxxKFyJaDIcv37bPXO2qzbWpFkiyEdf4OaquWk/ac1bRuRWzKSpVKfkUn3XQcd417IbCIUQZpzmRJlkeVLREjWyC8aCRzmmIcOTs7R8sF6PoOGOh6h/PgvaDZ2tDHMZJiKIrLoQV3deUCVkdn1iwzZFSF77j3bP1b6YocGE/CCWG9K3d0Pv3G3uV2WOeGcJ8Q2Dal8aZQnjZD5u+11RJ3TljdoB3t5NnPptJkEWediPOq71EF34mbMO5aUTxr2dPjfggsNVPIg7Pkh0mralN3pEpSwXc9Z2cPAIcPHUkvGfOAC9AFSOpxLln1wjCS4sqWJxRNlraYC+VRSnNua9u1OxXyt5jipElVdRLe6killCZ/4TgKVgW2juPwaositBqWglgcj+U22+Wbabu3xfbLN8p1bCNgN/Mebvt5uyrMWLTifbVXWqjQMO6UUyH3y/gSofTO41whO0m5YdU5HSVsx70RWJsIMS0ojnRCC6RouQR9v+L8wSMyQtJMTKPBVj6z2gSSRpvOlDkcRuKY6Lw3Fhi1HM0xRqyic3aMjPCtsBGmPAlzPb72YtZIlaoWp5CTAtoK1G1RsfZz1Rq/v/nZ8jF3nzllux5r2Hrj59zwEGgbVKh26202pL1vm1wiCycdPuZ2p+NgAmvpm4KIn7rd1KLHrHna9l3j3gjshC0iC+9zFljIYqQTzq94+OgtVI15pes71ttojoPCYa+Mha6z5heEzpPrfzWUqTqZCCmNheqdSWiqcFSGw7qsVTt0EhLNRoDBaejnWNBh6STdFODjpf+2MpzbtXe775u28230mSWMfTKyVXS/NF9luc/JlCmf5Wy8DofDiCpFwyohdPT9ihCWVRSvc/bgHglstR8rTNTyu1qYz6CQISoXDx6wXm253JnGXK163Dl4UYgDXXDEmAvroaUodrFDKmFK9cinZT0SY53Eme7H6JDm42vTD1v6InMmlpW0x9GwYyy1vj4Vej0mfqv7bqtybd/HTtXNspeWF2zWqicmQE8Ii8yKY/5Rq1WLIC9+1t6AwlioSp3z4I31pu97I4crPcZC6diTpUYhbx/3RmDraL3VxfslopWB7fkFMSm7/QAIYdXhBTQPpEOi7wOHAYbDwO56x2qzous7Qm9L0lSX1diSXeeLEFSuKi0aomUttMBBda7qECeFr3a5hB+nHbbC1Mb8q+DfdKpuFiPeDKWycAjbKBywvLEWYemlSaKnBHYB2zaO4YRe3TRr5nlUUrKUz3GMpRKXwoK+ogs9Inm6CXNBZV6jYO+HwB4toPb/woExFpesBvSH0JEs3kq36nGSyaLEwbNadWw2aw7DniGODPuBw/5A1weyerqVx4USftVcbMVK/WNJMBR4LaaEpNPLd+uAWHjj9Rr1NoG1c5TFJThO6ZvCtjIHEaqGPRbWYy2+PO6mCuFTz9btsFf9LCUztQ6HQxHUjpwV33s263WpAk70fW+VF2XOuYUEr457IbCKtTJKWk7XqdmaCirevE/JxDyABA77K5yOeJTOe7q+Y8jg/EBYe7ptpI9rDq8SQ0wMQ2I4RBCLumw2K5zrrBxDawTKHJkWFnLqDLeEGwJQGV5SKsC7stCop6JZIlaGYskN2ZrcTaaP6SuRTMpzDwOKszTBXQVAUCn1/63TIwpkNCdUS+slKVxYWpankqU2j3qMdSZOa8zlbJWboF6bXFENKR9bWmOKSsrgXLBr65Wu83RrR1hlXCdsz89Lgoz1qKhh6dvGvRBYSjg2q8zO6gQ61zdcBfZ4/uxjLl+9YLt9wk4hqpVhhG5FWgl+HejHFW6/Z0iRwzCwGntc8HaXewEvprFz9X4t2nOs0Y4FtRXoSUCPAg/Hmq0+R0q41FvPhuyq7ORSXQEUje1KXZTSOD2tSVDkfhHnp3oBiayRGfoqt4O0wjj/PWnTNsd/CiGZ/85wXIWzAHI230EzU8aWOOjXHattR2lQyWZrASBQKw1/TWz2ExFpfKZj0kg6kRBPS2lxFFzxPD/+6GO+9tWvopoJnVHeOC/0q84Qg82azXbDZrsmq3IYDhxGIyjOWnoWFDC7Ct7tdVj18G7iqrefym0aqmLLNaWxK43ranZYaXDswwINaLfZHuNxFO77GtXBP4Hr1vePberbKn4rXDUMAwrTatSvytxs1maWdYHt+ZbQBcsTrtu/4zDviYYtUyk1KSU3gtpmQZk22+32fOUrv8qDR5/j7Xe/ZAZ9zvjOE0bHahVIqecinjdRqYEYA1ISiFGPa7zu1sYETua9HmvQ+h7M2rdN7D7pPE6CtgThZ2z1tAlyvI0lLHUzAeaTX39ZaOt2v7fhwadu8FqWM44WwQph7jDe9x3rzQrfe1wQNucbzi/OEW/wpGiLRpweb8JLsBaRvyYi/z8x9sL/VXn/N4nIfyzGUvjviUhf3l+V118pn//IG12wEzbfonguZxwQx4QgPH/+jG9+6xuM8YDvare9BF5x3hH6wNnFlrOLM1SUwzBwGEfGmBhLWLWGDNuQ6qnareoktWbCwiM/UeR3UktjzZ9zwronRiWOuaQ3OjRjfRWOuioeByCai0YNuFT6ok8zFvjqa+bnFHJxnNMbYySOZkN3XWeOVR9Yb9estivEK2HlOX94zmq7mpJpphq2O8yCNznDA/BPqepvA34S+N0i8juA/w3GXvijwDPgD5bv/0HgWXn/j5XvvcEownqUrlc1EVjkyosjFJKM9WpN33cWPXGAN6fGB+h7T9cHtmcbW4Kcm7oWxpimJnRtb9j2wtdJAm4IYivUNXGmbutY6I+FTvVmQWP7MAp6vSEYwEI4gIlpcaKKr1dSaoKKm4IwxwI2f6c4ctK+vwxS3KVhT93cw2FAs85YaxfYnm1ZbVZmCqw80jkeP32MOMgkxMvcD+yOWu/XCqzauCwvu/JQ4J8C/v3y/p8Efm95/rPlNeXz3yV3u53lSsAEac37nrWV1hIYx2G3J3jP47ce4TvLP5AARhCjuE7oVh2rdc96s+LBo4estxuyWuMOxGzFtkeXc+6GZgNOCuApbfy66oMZWjLhqNGeasea3Wp08K1QtL9vn0/LNcv3Zw7a+fn0cKeF8ZTmPLZdW5aXYzu3vS61X4R3gVW/YrVasVr1rNemXV0nqIPtA1v9xDvr5lOdwteIyZtya3ngbwA/CvzvgF8FnqtqRdVbhsKJvVBVo4i8AJ4AH965kzKZtvxr87exI9Ugm5wSq/WZ2T+uNKbrPUkj8aClB4JDnCepJXv74LneYXBLzriUFpPTVrDeugRzM8zaYpz1vePvtp65abI5otXavPZdo0k6lRjT7nf6K3PSZattKT730iZsEBcqjlvOVW/aq62mP84Ca8+5nkd9CFJIoXt819GtekLfEfpAzAl1mbeePGK9XeOCaVYh16P6/p0utWKbnxSRR8CfAX7rm/zuriENe+HnP/e5uqOSoHK0XJYk6dom0xeKTO8rrabQS4dqJnZjKY82xusudKCR9XqF88IYS0eaFKfJqUWGNZml9Y7nGq95MnPOC17XnCJZbxIctwI9O1XzubX1YuX0AV1ouHa/ZS7m92R2VO+4zu2r5tG+N/9tb4Y2Ate+f1yaXlemmnXVdR2rLtD1K3zXEfoOCc66hYuy2ax4+PghzkshP7b51enmu318IpRAVZ+LyF8G/uvAIxEJRcu2DIWVvfAbIhKAh8BHJ7Y1sRf+V37iH59h6/YOZta6OVfBtUoEVQjBkzVZE43OkzTQrTqiRvKYwYHrHE49nXeELjDGwDAerEyjaI06ASGEhcMHywk85T2b9vGInz+LMZ4UuFl7Goy10JSAiCVYOzdrrXafx7Y1zHj9MbpQr59M2Ks0+2yFvEanak5Aaxocl94sb5xju17VOh6u+55VFwjdCtfZ6qZO2acB18HFxRlnF2dTu3tXOttkVU7ziM/jTVCCt4tmRUQ2wD8N/D3gLwP/vfK1nwP+bHn+i+U15fP/l74BSJirJs3ZmiCL1XBFUQ5k9poZcByAK8BdbNDtiuhBPUDG5QhZGUqdFpaAiBAJTukcrLznfLVhteowebX2P0akYa1Abam8GZufW3fGG8Jj0RyPdSK3pda+YstzSkpKA6qWVWZ07PV5LvtVnFsmv1TT4LgA0vZZHCs8TgIiHahHsyenQI6eFA2VaLtvmhBTbh7FOQhdxrmED5nQZcRFlBGkPgZUh4XWbQW16zrOzs44OzujX6/p1hu6VUfwAnkgj9f4PNB7ePr0qSUzOZsbijngyr93jTfRsO8Bf7LYsQ7406r650Tkl4A/JSL/a+D/i1FyUv7+H8So4j/G+h3cPcoctDmoCxyUGr41Ws5+teLBo0cFyjH6dFWdfp9SQpO1jEwlyViEBexTO7zXCaglLy0yQKPh4aZmnb+3xE2Pa7bm7+ZG4+Up7Gvjpm3Y3ufHZkIV4jl7q/a5rZrU1a0yh56Ptet88VWXaIFds0r+UXyJ+osj56wGBlqGcEMtFM2RlEaSjobiiJlqZuu2WHJzLLeICbwZe+Hfxmjij9//Nax3wfH7e+C//7rtLke7nC0zj1L1QDWTVC2xW4QnT94mdB1I0c4xMRYbyhyoYkoU2MmxZKsOPixenw4SnCZkO3aIRGbmlGNM8pTHX393nEZYt3v83dvea2+GdHyTa4XHHCKemoAwR3NnG7g9puC7Imwt8pGoTfNcI6ztDdoKbb2ZVDMpF17cnKhU/OaXWA7GFIKvpsktzm4d9ybSVflSU5PvmXMmV4M+JWLOjFnpujVvv/02TrzlH1AmUC2PNgQrBddcSNSS4a7kmR7Id3bqx5AOtOl6mRpmbJ2Q1m6bttHYnHVC6/erxrFVfZn1tSAC1iVv1yntXY9PZE4sb/czL/VtX8xTQjDbqfNzR9eF8n0zkcCaa4ir58atbI5QIoSaiXFAUyKlgZxGVDKuD+RczC8KNT1tLd1d5T027onAFoqgMOOQ5W2r48qmaUeUqJknjx/z6NFjckyF2dCBt1CrjrOtOdEOJS2JJA3wP44GbzVgfKvpZg3oJg+4TYZZ5LCKm8iA63ZaQZw1p51UK6DtxB9r8va99nW9oeprEcEXYbWbrHXKqiV3c/GdbOAihOIc3tWONyXVUnXijrXrNy563AILO98eiZQjcTgwDDtyjvSrQIdHsYR5ocBqkwQA+huMEnyWIyXDV+twzi0UQ0ZR79EsfPFLX6bvesZk3ADeme1Ve7ROE+/mDXhny2KrPWOKkzDVVMF2qYZldGgqrWlNllKKQ14KbOuQVOSg4q/Hy/ApbLP9rI5jrd4+9yEghcLG+ybXQBuBbTR2tT1bO9Q+L2VBPqBuuZJArQRZHk+9mcESxodhb4/DHiVxtl2zWlvUK4SOmEZC8GbXSr3SbzbuicDePFyzc5oHcMiZzfk5j956Qs6FyEEx0FtBSiPiU1joje1TQ6E3tWabdeTcTOhWuyHeyJDKZiu32ziuSqilOMfkwqcEtt32cTJN66FXIbP4+/+/vbMJtW3L7vpvzDnX2vt83HPve69eqp5YZUVIJ6RVBIwgCoIQq6NdO0axoyhoQ7EKQSGQRkIQDARR8ANBtJHYqIZB/AKxYaFIGUuLSkzDVlWlPt79OnvvtebHSGPMudbc+5x77/Plpu65zzPgcPZZZ+2918dYY47xH/8xRkHV1TqpFZZTdcZTWLKI1YpJnWXgrOGFLcc1OHOyMOMQwdd5W1TqYlu6Y4xH6egYI4fDgd3+mpQOBGdEJMPM7bhSmo2IlFOdflivgR3s2+PDnoqVsHTp0KLMpfDo/IKrR4+Wsea07BgK3WjMtmR559A6iE1z1yug60vVgpXWZ6C3Ps6Fo5Rkn0RYrK8XJISjpfoUtzUFTkdB5YuwzNv+bsd6WxrYtle/UHqFV8y6HiMaTVbUo07xrgRvEZtmmHIbIdUqbjOllgy16xVjZJompmliv98TY8R74ex8YDOObDYDQ/DmK3dwodKmgtcHsTuXl+EEd1Nhe39I249abyzvajMGs6hqu6NUhr4Ug1cw/yunjLXYtxTg4lvqim82S9gv82BuxjhubkTE/UPhvZUst74ETXq/eHURjjkIr1LYJqcQWtvWHiQ7DxaFtX3XgsNV4Y8/r31mO7a1bIf696qcK0moHCmpEYrm5aEfx5HNdmAYPOM4MAxG6Ww9EOzwugdu+SVvlw+7ZGt0/V3qhJeslgIQhJy1XvjmSLXcs0EuTgR1DhlYemK1h1accQxKKXhdU669gqra4IhSLEVss8DWOvwG6yBi1Z6+LqnlpjLBquCqSkpxWXb7wXXNwh3xJuistLBkANtDDKZUy2dX690sJPQBW6+4vZVuig05t6DyZtIkZ6vNiimRUiTOkRjn5boNQ7BEjHdWEbsZCEGW1LkWo1AWLfjBkYqSiuK1+cOtPdOrPdm7obACOMH5euNVAI+qIyJEPAkMpsIc95IV52uXRjGlC6oUL6RsE0wlCN4FnLMmGYViNLZSFv1aS6etjY7gbU6YdxwOB2N3seKxfeVsG17nncPJMbwDLMFc82tbB5kQwkJu7qGy1aVQvG++cqlzGkpVbNtmFnzlPvQW+rgqYlXS40j+JuusnV/jCU/TdJLEKVC78jhPRXUMRvTeEQaPc4qEggZrUBywciBnLCXUeSZVJuc4d0NH0quzFYCX2dm7obDNAlYA/shPa1wCVVIuXF09IuXMGDamtLIGUGYV1+57rmZq1K8TvKEtiWtT4dYY2DmPoHWp9RUEv9lPq0XFDSR3TpaWoL0LEGNcgrR+RKf3nhgjwzDcUFgLptbeB2Dss1IRgAbIW+BzOwVx6eRdL25vMXs4rN/WzqlZ1R6aW8thAj60c1zP1/tKZ/Rr8WRbGJZjyIp42z/FSIkJDeGmt9o1UL5N7obC9mnJcuLLddipeM+j994FEcR7g5IQcml+V6E0AnQjcTi5cTNaCrMH9xvYruhyc1IKnU+oi89q0M28KJWlIG/OwWqp3qawLaJuChtCWPbpFTYEtyhRU9iUYsVZc3UFDCO+LZPWZ9uaop+6GkdXv64EPRJyGycWQFxDUlium+Ho7TWG3da2s2YzpPqvVlgpWWk3rV5dKszzUmWFO6Ow5t80aAi6AKYqYi6F8fySi4cP8eNoHAGxWQRamh9m2Gou4AVw3UCzlEg5Lyx9E1ksZCnV9+sUwG78McWut6BL4ANoyUdLbJ+8OMqIdQFUH/2vckx0af8xJWrv9/VBuInn9sGYfa+/gRS9TMmPcdfjJIgZgLUph2XJdAnOlgdC23esKyTYffJFGULAi4PWTHmJvJTTIXancmcUdrGsrDexBRjNJXDOMlrqWkt3qSdeYRmE1jbIAhsL1RZMVC2Qsptrwc5689YLZTe8LYP+6CFqr3ul0Joxa/5pznmxxu19LeXalLj5zitgvyqxalkDFjWMNeeEWxIhWpddUyaDko6HLLdjsXZAVnh5SlLvuQjtnJrS90p7415pY7Qdu1i9ONsRVaEYhoOINe/bbrYM3q8WdlFardvuuEugDZSuS3kfALR6qwIc5pkpRQ4xsR3OKdFKv8V5DCoBRBhCQPOq9AtUVV2H5meVoh1Zo0bSGFVOVeos2LIslX3tV1NKVSWnxDiEJRCbpunIfXDOLb/hGOpqn9VX75p70ixxoWimFL9sa6OTVC0qL6Ww2Ww6l2I9VqqL05Ta3n/88DRpx9KnlG/cK3rf+Hacv1/BygL8KD4EYs7W9cUZl1k6ZW168DK5EwoLraR7rUBtsNJSLgOEzRY/bphzwrlMcAM5qzWl6KCbZpFRKlurwUB2MUxB1mxR8yOdcwtWC0JKa8nJaYarT9nS8NjupyllXze2nK0eUw+bwprfamnLpuDiPCXlJQCEHvA3BRvHcfmOU2vexs23h6uH2W7LAp4mPE7v06mLeavL2aAqh/lmXsheUFFSyUTNtYqrcwUaPvAKZOtOKKxye7FfyS3bpag6CB51whQjwWXG8cz8x6SV4NosUFN0Fnqi3YieMKILtGRWxaCpAtUirsFY79P2Cru0K2JV4NX3PfYVexeiLc+quoygb5bRtoXVr+2+vz1w7XXjlbbmdrf52e2cT8k4bYVo0lv8pvA3pVfwdTW4bb/WsKcI1rRHC1KsBVXSggGPp922yy0PybHcjc4vuvqwK6R1jBvmnJnmid1+z/5gILY4i6BzzswxVmuywmB98HNa8dlgpwZV9QHOanVZ9j2NmI+zXeHIJ+25oW2/Pl3cK3D7X1PYRoJuo+mbf3xbUHVKzGnKf5Sa7nzb3l+Gm9m4fls776Oflktl1bPbLKwas4GEkuvPnBNTTmTDL1E5JZKX5b0vkzthYUEhZUptIpEqnTDV5QxVtCScTswp4jaOMhXwkaswQIowz7iixErP0FxoA7jU2QUsQ6EIZFU2peA95DjZHLBsw5Vd67WVE1Y7bkM3BJs6boGcvW5JC5Ueq1zZT6e0RRFqMGVAu7WgLDX618pmsqjeB0dahgU3hQvLimCeiFQ/3Ff3pbH57f/OmYnTnBnFI7U5oEPINV5wYqw4p1L7YEmFBNcHH4FczCI778zNqtrWiDMNlbLW/IJSKCIkJxxyZCozm2HkLATc4NAy46ipWlvGTBVeHOsBd0VhFcPlOmuaSrbqAmo0mhNBI4iS/cCzDLqbIWTGOFNKoiRlRq37X1E0ZjQ1Ake2jBEFvKJR8MFupqBW+ZoyuQCuoKJkzUhFAZpt0bb0AtWc0wcKfcTfW62WwTKl9Uv0DizbGlRUHzlacqOJqy1/SrEBe9DSsy2923xz279ly4oqLlgbftuZauXWqKk13VvOpO63ICRYyZFlIlec2xln0lyXmsxQLaiHHIQ9madpZiZx5Ue2g2XEKKl+hWHfa3H3ayjz/j2XBpq3flPd0+rrCQjUcUhmhQ9pQlOmzMq2KZYzKh3ZIneflcENaEq4IrgihBqgxZpDF7FRc1oKWajblVyj13C6LN6AoI6XsB63bErb/16DodX3bO9b0qe6UhP74Kg9zK2yoP2vj+zhmL+QnRC9BUA1DrXI3TsjCjalrNsUKF6OzqcUrZYXJNtwae38WcVWGbH8NOqE6GEfJx5POw5kwsb88uCDEWIq2YVqCrS6Cq/KHdwNhQVSbR5G0TXjInGFelRJ08TzZ085P3+fqYyVN5B4Gifmw0RMyrnbcOFGthVLjTEh2SpxQxF8traeUSqqULSmeA0RKGTjGXgbkXSb9JH4aXarxy97/LZBW80y9rBYk4Wn0E1WOY3mm6K3gKcp/VrVcJKc8FY3rK0aWMQCF+9sgrZUhEWME9F/lqqVx6gmglhVnMc+ozQkB62BlYAzSzyVyNPDjuvpwL5EwpnNM7BkT/OrqTgtNuGyKvDLPdg7pLAlJ1Llo3rvCc6jpdQe+YlSMlH3PHvylOG9RPYjGSWKgoenZebD62vOkufKbbk6P+di3LD1Dq+OUKwvFxjv01W4SLPWUaC1LDvVqoMlDdr1gdXj17217a3fqVuwWsKVN9CQgl7BWz+DxgPuPwt6X1hoBBgROSLSwHFq1orATRlc8zWrpU+qeAVn5W4ELyQFXwsOKYJ3Atn8ZYo9TM15V4HizGInUeYcmWJkVw48kwORgt8ORoQRrJC0Bcb9zW+KKvJy88odUlhRo+4V1drsrVrdONc28Z7s4FBJwrm2VE2qhHHAPbjE4bh+euD57jnf3j3nYrPharPlwg+MCOdhxIujaGbAQyk2EkmCTbDMmUEdMdvsrZIysZzWKx0XIoIpdmNutfRsrzRHy31Zy2Z669zjn72S9tDTqTQF7THW9t0L8hELo1gLfOcER8V/SyFkIGeznF7QmPHaBuWZrxq8J4O5UqrE4EhqSqtemLVwKIl9mjlkq5ObfSENzoZbe4f69aEtlU8b89hIeminqK+CtV6psCKyBf4TsKn7/4qq/h0R+afAHwOe1F3/nKp+Tewb/x7wRWBXt//3V32Pd66OIK/WKiXibF3wXA0GQghsz7ZszrYkhKhKcFZ7JGFgPDujaCAGm2vwPB749u45I6CHmfevHvLg7JyH5xeczYIET4p1Kc32nar22wW/cGtv68bdlvTe1+zl1G/t/czTVG+fiACWgOY0wXB8M2WB/noc9tS6e4QBR1KQUleGUmc7VB9e3Eq+cc66IKqAOMecIgUle8ecEpO31v5ZMvtp5vm0Z58jsbHihkAJkJ1Uv3dNv4qITUbMiayGIjSfVeT1uQSt3eZzERmA/ywiv1b/9zdU9VdO9v+TwI/Vnz8E/P36+4XiRCzFmCMpOqgBWMkZh2WLEorznrPzcy4vLyl5QGICLWhKkGGQgdlD8YU0ZFINrkrwfOM3vkkohXceXHG5PedH3/kMjy4ucaJsnLAdAmnKOPUUKWQKSSNSZMFqTwkip0t7y9+fWoneivbWuT0ETZbgKq9/n/rFKw78Agy0OzaowaRaAqHUxIg6QNySbVKp9L8gFFchKcANnpgLRR0xzSTJ7FW53u3YzXtizmTvkMGjwRI74gR1DTWgRmQNWailNTmtU9FbWt5O7nfvEqid+W3tNl8kfwr4Z/V9/0VEHonIB6r6rRe9QcSxGUc0RVIYVuhEZOlOKAJJM3OKxJQYwhkpg8YZzRCyoMWhIcDGJnCnlEkVoN6L4p1wMQaelMg3vv8tHk0P2DjPRRh4EEbOh4Gx1oCpZpLCtqyNIoZhOGJh2bHLkcWs1+zof70C3eYStPf07sPJPTj66b/zVHoFV7WgKGNcVHWW2581U6SgzgD8gjWBbt89l0jSwuMPv08Wy0z94MkPQISwGQ2L9VAGX4M6RTz2U+/X2HrXasV+a6FoKYWYErlSYlT1Fpfgxer1sdptqupXReQvAT8nIn8b+PfAl1R1omu3WaW14vzWyWd23Qs/XctXPN45qy6oEWrJ0RrejlY3n0vtkhcEV2cFIL6ygRwpJ0KGjR9IIbGPM0WEz37+80y7PcMQ+P0f/D6e7vdMufD8eseHz68ZUubBMDA6zyDCxdkZQ3CcF3/EYmrE7T6TdNr8rehNzvzqTqxK18uqaNbUuGGwpxyBdV/riXUqfVZK1SL4IooKddWwqowsMGtiipE5RXS2VPjusOd62pGk8INnT8keHr77iL2z8w6aGP2IZSbMrcKBOjFkxTm8KL6y4qQ0ptYKoaWSbwRdFTZ4lYH9eO02ReQngC8D3wZGrAvh3wR+9qN8Xv3Mo+6FGjwhwHYo6OHAqHt8OTCGgUkdxW3wF+/y6P3PUnBMh+e1IHQiucwc4EAgFUdJgmom5MSlgqbMh4+fkJPytBz4jvsBfvCMw4AbNsQC0QeuUyLNM5oyYb9n9J7PDBdshxE/CNvgcbKxJaYMULIVRDrHjKJDIAFuCMS5QnI0dKC2/6kQm1PF1aVySjNhM5oL4uxBzEVRZwHLXBVZGx+2RvpnBbLAlCPJQXGZnZvYbpzVXJVCFMjirdwF5fqwZ0rRfubZludS2DmlOFBxiHc470kXW+Z5xwOvTIfnRIGrywu2w4aYC6IDZS4EZ0orLuNcwTmlOCU4vzT2885bTdjgePz8GZ/6zPvsNVkGrvJqLfP2GhS2U7LHYu02f1pVf7FunkTknwB/vf7d2m026VtxvkDs8Sslk1MkzROlDTzGItaYMhcPHnL13qf48BCZKJxthsrKUrSWM4tbMyfjMJDjjJeBpx8+Zk6Fy6tHXD/fcXF5TnHme6Zco+3KtidYSvI6Jv7v9fcsC5cT58PIKI7LccNZGNh6q5alplxzMKhIMPBdvLM8RmrLnQMHOSakKGHwzPMEwUYgZY/5k856+omYhZyd1tYLa/cYpJBFmWuEHkWZcuTDZ485Pz/nMO2Ic2Q3JdQPTPNs0FIp1vVam6vgcGOwejqs2JPqKrhxIO4s63Z5cc52MzIf9pScyMmCveaD1stglrTz11sAaedvrsz1bsc0T5xvz2jZNVXFL0HpizXlo6AE7wOxKmtrt/nzzS+tqMCfBr5e3/IV4K+IyL/Egq0nL/NfqSfp6sG26XlT7ZOfciJmRxlH3v30B/hhy+7Jc2QIKAHRhEfwRXBZSMlSiMNgfWK9s1mmn/vc55hjZj8nLi4vOTvbLuC18V+1XnCx1CGQQmLyyrQ/kErkyWGqSYhseK0qQRwX45ZHZxd2Qb1jCFZB6n3BI2gNyqzXF4jzaM4kgSyhJisynA3s5wnxjkkzc5yYp8yUInOtaqX2pprnmVlny9pRkMEz58h3vvsdBu8RLVxcXjAlK7xw21oSLx7xBk21hLN4x4AsGUatyjZst+xDWHjDjapoLlBYXCLqg+gcdd6E4rqar1aZ4MSjKLvdjsePH/PwRzZwgjW/DpfgRe02/0NVZgG+BvzFuv+/xiCt/4PBWn/+I3zHktMuxboQ5lr/FGMhayCMGx6+9yM8O8wUCQxhi5MBEWsjL6mgUcmtkbGrYLk3jut+v2d/mNmcX/LOo3eIcSKmSOoY+A7IrEFW1sJBlDQ4/PacHK1zNxrqbNvMIWX284HrZ9NCHZT2GbQSGiu882JFk4MznzvFiWk6gIPn19dIcDx59ozteEHWwlwyUS1l3GbuBV8ni5OZR+vqOKdIToUYZ65d4b2HV3iUhLCLMxsPw2ZABWO5eatebSlVADevRJSmaC0hsd/vuDrf8uTxYzbjQM6FMNb0Lywd0luk76g+LTRKRN23keThu9/7Hu9fPiCcXRwnOuQWx7yT3027zT/+gv0V+Muv+tzj9/Q9r+pMVWcsolbSMgwjYXPOdVR82IAMeD8iuVBUcCWhMYNKTfGmWuQ3g8LTp0/5/odPePReYXt2zjgOSz+vftnyzi9Zo3meEWdRtAAJpdTeBuIdENCc0TGTk7kuOZqPOXiD4tQ5Si4cirkV8+HAUFGROB+Iaead994hpgPXhx2P52uuNlvEC0k86gdc8ItLoLUiNeaZgxRcGKB4pCTcILj5wH6e8RQeXTxgyGptSL0NchNXj73qU2skLdBIVzVlqlAKwxDYXT/l3atLpnliuxnx3rHZGCxfii4uVbuXR59Bc2WMmQbWt+vJ4yfsrnecDxvGcWy6U9sXvVjkRfDID1NE5LtYY+2XD+74ZMmnuD/fF8kfUNX3b/vHnVBYABH5b6r6k2/6OH5Ycn++H0/uRsXBvdzLR5R7hb2Xt0ruksL+wzd9AD9kuT/fjyF3xoe9l3v5KHKXLOy93Msr5Y0rrIj8tIh8U2xc/Zfe9PG8LhGRfywivy0iX++2vSsi/1ZEfrP+fqduFxH5pXoNfl1EvvDmjvzjiYh8VkT+o4j8bxH5XyLyV+v213vOp9S1H+YPViL0W8AfxEg0/wP48Td5TK/x3P4o8AXg6922X8BYbQBfAn6+vv4i8GsYnP9TwFff9PF/jPP9APhCff0A+A3gx1/3Ob/pk/zDwL/p/v4y8OU3ffFf4/l9/kRhvwl80N3gb9bX/wD4M7ft97b+YKNc/8TrPuc37RK8iDv7SZVP60oE+jbw6fr6E3UdROTzWDr/q7zmc37TCvv/raiZlU8cRCMil8CvAn9NVZ/2/3sd5/ymFfZjcGffavmOiHwAUH//dt3+ibgOtebvV4F/rqr/qm5+ref8phX2vwI/JiI/KiIjNvn7K2/4mH4v5SvAz9TXP4P5eW37n62R80/xETjEd00qL/ofAd9Q1b/b/ev1nvMdcM6/iEWUvwX8rTd9PK/xvP4FVscWMf/sLwDvYfVvvwn8O+Dduq8Av1yvwf8EfvJNH//HON8/gi33v47xo79W7+1rPef7TNe9vFXypl2Ce7mX/ye5V9h7eavkXmHv5a2Se4W9l7dK7hX2Xt4quVfYe3mr5F5h7+WtknuFvZe3Sn4HhA8/t7rWCLAAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 9.702122619817867e-26\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Re-Ranking 결과 ### \n",
+    "probs = torch.nn.Softmax(dim=1)(lgits)\n",
+    "import matplotlib.pyplot as plt\n",
+    "print(f'Input Text: {val_texts[0]}')\n",
+    "### Sorting 통해 text랑 image사이 거리가 가장 가까운 순으로 출력 ### \n",
+    "for idx, prob in sorted(enumerate(probs[0]),key = lambda x: x[1], reverse = True):\n",
+    "    print(f'probability: {prob.item()}')\n",
+    "    tmp = Image.open(val_images[idx])\n",
+    "    plt.imshow(tmp)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "791c1ae1-b60b-4e67-b477-699e8ee1e862",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 8fc9cb6373b736bdf7f44560a0d4a3d7747cdcad Mon Sep 17 00:00:00 2001
From: Joonhong Kim <30318926+JoonHong-Kim@users.noreply.github.com>
Date: Mon, 20 Dec 2021 22:29:32 +0900
Subject: [PATCH 06/26] add ) model.py with Koclip

---
 model.py | 540 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 540 insertions(+)
 create mode 100644 model.py

diff --git a/model.py b/model.py
new file mode 100644
index 0000000..299c0fa
--- /dev/null
+++ b/model.py
@@ -0,0 +1,540 @@
+from math import log2, sqrt
+import torch
+from torch import nn, einsum
+import torch.nn.functional as F
+import numpy as np
+
+from axial_positional_embedding import AxialPositionalEmbedding
+from einops import rearrange
+
+from dalle_pytorch import distributed_utils
+from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE
+from dalle_pytorch.transformer import Transformer, DivideMax
+from dalle_pytorch.attention import stable_softmax
+
+
+def exists(val):
+    return val is not None
+
+
+def default(val, d):
+    return val if exists(val) else d
+
+
+class always:
+    def __init__(self, val):
+        self.val = val
+
+    def __call__(self, x, *args, **kwargs):
+        return self.val
+
+
+def is_empty(t):
+    return t.nelement() == 0
+
+
+def masked_mean(t, mask, dim=1):
+    t = t.masked_fill(~mask[:, :, None], 0.0)
+    return t.sum(dim=1) / mask.sum(dim=1)[..., None]
+
+
+def set_requires_grad(model, value):
+    for param in model.parameters():
+        param.requires_grad = value
+
+
+def eval_decorator(fn):
+    def inner(model, *args, **kwargs):
+        was_training = model.training
+        model.eval()
+        out = fn(model, *args, **kwargs)
+        model.train(was_training)
+        return out
+
+    return inner
+
+
+# sampling helpers
+
+
+def top_k(logits, thres=0.5):
+    num_logits = logits.shape[-1]
+    k = max(int((1 - thres) * num_logits), 1)
+    val, ind = torch.topk(logits, k)
+    probs = torch.full_like(logits, float("-inf"))
+    probs.scatter_(1, ind, val)
+    return probs
+
+
+# discrete vae class
+
+class DiscreteVAE(nn.Module):
+    def __init__(
+        self,
+        image_size=256,
+        num_tokens=512,
+        codebook_dim=512,
+        num_layers=3,
+        num_resnet_blocks=0,
+        hidden_dim=64,
+        channels=3,
+        smooth_l1_loss=False,
+        temperature=0.9,
+        straight_through=False,
+        kl_div_loss_weight=0.0,
+        normalization=((0.5,) * 3, (0.5,) * 3),
+    ):
+        super().__init__()
+        assert log2(image_size).is_integer(), "image size must be a power of 2"
+        assert num_layers >= 1, "number of layers must be greater than or equal to 1"
+        has_resblocks = num_resnet_blocks > 0
+
+        self.image_size = image_size
+        self.num_tokens = num_tokens
+        self.num_layers = num_layers
+        self.temperature = temperature
+        self.straight_through = straight_through
+        self.codebook = nn.Embedding(num_tokens, codebook_dim)
+
+        hdim = hidden_dim
+
+        enc_chans = [hidden_dim] * num_layers
+        dec_chans = list(reversed(enc_chans))
+
+        enc_chans = [channels, *enc_chans]
+
+        dec_init_chan = codebook_dim if not has_resblocks else dec_chans[0]
+        dec_chans = [dec_init_chan, *dec_chans]
+
+        enc_chans_io, dec_chans_io = map(lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans))
+
+        enc_layers = []
+        dec_layers = []
+
+        for (enc_in, enc_out), (dec_in, dec_out) in zip(enc_chans_io, dec_chans_io):
+            enc_layers.append(
+                nn.Sequential(nn.Conv2d(enc_in, enc_out, 4, stride=2, padding=1), nn.ReLU())
+            )
+            dec_layers.append(
+                nn.Sequential(
+                    nn.ConvTranspose2d(dec_in, dec_out, 4, stride=2, padding=1), nn.ReLU()
+                )
+            )
+
+        for _ in range(num_resnet_blocks):
+            dec_layers.insert(0, ResBlock(dec_chans[1]))
+            enc_layers.append(ResBlock(enc_chans[-1]))
+
+        if num_resnet_blocks > 0:
+            dec_layers.insert(0, nn.Conv2d(codebook_dim, dec_chans[1], 1))
+
+        enc_layers.append(nn.Conv2d(enc_chans[-1], num_tokens, 1))
+        dec_layers.append(nn.Conv2d(dec_chans[-1], channels, 1))
+
+        self.encoder = nn.Sequential(*enc_layers)
+        self.decoder = nn.Sequential(*dec_layers)
+
+        self.loss_fn = F.smooth_l1_loss if smooth_l1_loss else F.mse_loss
+        self.kl_div_loss_weight = kl_div_loss_weight
+
+        # take care of normalization within class
+        self.normalization = normalization
+
+        self._register_external_parameters()
+
+    def _register_external_parameters(self):
+        """Register external parameters for DeepSpeed partitioning."""
+        if not distributed_utils.is_distributed or not distributed_utils.using_backend(
+            distributed_utils.DeepSpeedBackend
+        ):
+            return
+
+        deepspeed = distributed_utils.backend.backend_module
+        deepspeed.zero.register_external_parameter(self, self.codebook.weight)
+
+    def norm(self, images):
+        if not exists(self.normalization):
+            return images
+
+        means, stds = map(lambda t: torch.as_tensor(t).to(images), self.normalization)
+        means, stds = map(lambda t: rearrange(t, "c -> () c () ()"), (means, stds))
+        images = images.clone()
+        images.sub_(means).div_(stds)
+        return images
+
+    @torch.no_grad()
+    @eval_decorator
+    def get_codebook_indices(self, images):
+        logits = self(images, return_logits=True)
+        codebook_indices = logits.argmax(dim=1).flatten(1)
+        return codebook_indices
+
+    def decode(self, img_seq):
+        image_embeds = self.codebook(img_seq)
+        b, n, d = image_embeds.shape
+        h = w = int(sqrt(n))
+
+        image_embeds = rearrange(image_embeds, "b (h w) d -> b d h w", h=h, w=w)
+        images = self.decoder(image_embeds)
+        return images
+
+    def forward(self, img, return_loss=False, return_recons=False, return_logits=False, temp=None):
+        device, num_tokens, image_size, kl_div_loss_weight = (
+            img.device,
+            self.num_tokens,
+            self.image_size,
+            self.kl_div_loss_weight,
+        )
+        assert (
+            img.shape[-1] == image_size and img.shape[-2] == image_size
+        ), f"input must have the correct image size {image_size}"
+
+        img = self.norm(img)
+
+        logits = self.encoder(img)
+
+        if return_logits:
+            return logits  # return logits for getting hard image indices for DALL-E training
+
+        temp = default(temp, self.temperature)
+        soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=self.straight_through)
+        sampled = einsum("b n h w, n d -> b d h w", soft_one_hot, self.codebook.weight)
+        out = self.decoder(sampled)
+
+        if not return_loss:
+            return out
+
+        # reconstruction loss
+
+        recon_loss = self.loss_fn(img, out)
+
+        # kl divergence
+
+        logits = rearrange(logits, "b n h w -> b (h w) n")
+        log_qy = F.log_softmax(logits, dim=-1)
+        log_uniform = torch.log(torch.tensor([1.0 / num_tokens], device=device))
+        kl_div = F.kl_div(log_uniform, log_qy, None, None, "batchmean", log_target=True)
+
+        loss = recon_loss + (kl_div * kl_div_loss_weight)
+
+        if not return_recons:
+            return loss
+
+        return loss, out
+
+class ResBlock(nn.Module):
+    def __init__(self, chan):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(chan, chan, 3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(chan, chan, 3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(chan, chan, 1),
+        )
+
+    def forward(self, x):
+        return self.net(x) + x
+
+
+class DALLE_Klue_Roberta(nn.Module):
+    def __init__(
+        self,
+        *,
+        # dim,
+        vae,
+        num_text_tokens=10000,
+        text_seq_len=256,
+        depth,
+        heads=8,
+        dim_head=64,
+        reversible=False,
+        attn_dropout=0.0,
+        ff_dropout=0,
+        sparse_attn=False,
+        attn_types=None,
+        loss_img_weight=7,
+        stable=False,
+        sandwich_norm=False,
+        shift_tokens=True,
+        rotary_emb=False,
+        wte_dir=None,
+        wpe_dir=None,
+    ):
+        super().__init__()
+        assert isinstance(
+            vae, (DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE)
+        ), "vae must be an instance of DiscreteVAE"
+        image_size = vae.image_size
+        num_image_tokens = vae.num_tokens
+        image_fmap_size = vae.image_size // (2 ** vae.num_layers)
+        image_seq_len = image_fmap_size ** 2
+
+        num_text_tokens = (
+            num_text_tokens + text_seq_len
+        )  # reserve unique padding tokens for each position (text seq len)
+
+        self.text_emb = torch.load(wte_dir)
+        dim = self.text_emb.weight.shape[1]
+        self.image_emb = nn.Embedding(num_image_tokens, dim)
+        print(dim, image_fmap_size, image_fmap_size)
+        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>
+        self.image_pos_emb = (
+            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))
+            if not rotary_emb
+            else always(0)
+        )
+
+        self.num_text_tokens = (
+            num_text_tokens  # for offsetting logits index and calculating cross entropy loss
+        )
+        self.num_image_tokens = num_image_tokens
+
+        self.text_seq_len = text_seq_len
+        self.image_seq_len = image_seq_len
+
+        seq_len = text_seq_len + image_seq_len
+        total_tokens = num_text_tokens + num_image_tokens
+        self.total_tokens = total_tokens
+        self.total_seq_len = seq_len
+
+        self.vae = vae
+        set_requires_grad(self.vae, False)  # freeze VAE from being trained
+
+        self.transformer = Transformer(
+            dim=dim,
+            causal=True,
+            seq_len=seq_len,
+            depth=depth,
+            heads=heads,
+            dim_head=dim_head,
+            reversible=reversible,
+            attn_dropout=attn_dropout,
+            ff_dropout=ff_dropout,
+            attn_types=attn_types,
+            image_fmap_size=image_fmap_size,
+            sparse_attn=sparse_attn,
+            stable=stable,
+            sandwich_norm=sandwich_norm,
+            shift_tokens=shift_tokens,
+            rotary_emb=rotary_emb,
+        )
+
+        self.stable = stable
+
+        if stable:
+            self.norm_by_max = DivideMax(dim=-1)
+
+        self.to_logits = nn.Sequential(
+            nn.LayerNorm(dim),
+            nn.Linear(dim, self.total_tokens),
+        )
+
+        seq_range = torch.arange(seq_len)
+        logits_range = torch.arange(total_tokens)
+
+        seq_range = rearrange(seq_range, "n -> () n ()")
+        logits_range = rearrange(logits_range, "d -> () () d")
+
+        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (
+            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)
+        )
+
+        self.register_buffer("logits_mask", logits_mask, persistent=False)
+        self.loss_img_weight = loss_img_weight
+
+    @torch.no_grad()
+    @eval_decorator
+    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):
+        text_seq_len = self.text_seq_len
+        if text is None or text == "":
+            text_tokens = torch.tensor([[0]]).cuda()
+        else:
+            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)
+
+        for _ in range(text_tokens.shape[1], text_seq_len):
+            device = text_tokens.device
+
+            tokens = self.text_emb(text_tokens)
+            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))
+
+            seq_len = tokens.shape[1]
+
+            output_transf = self.transformer(tokens)
+
+            if self.stable:
+                output_transf = self.norm_by_max(output_transf)
+
+            logits = self.to_logits(output_transf)
+
+            # mask logits to make sure text predicts text (except last token), and image predicts image
+
+            logits_mask = self.logits_mask[:, :seq_len]
+            max_neg_value = -torch.finfo(logits.dtype).max
+            logits.masked_fill_(logits_mask, max_neg_value)
+            logits = logits[:, -1, :]
+
+            filtered_logits = top_k(logits, thres=filter_thres)
+            probs = stable_softmax(filtered_logits / temperature, dim=-1)
+            sample = torch.multinomial(probs, 1)
+
+            text_tokens = torch.cat((text_tokens, sample), dim=-1)
+
+        padding_tokens = set(
+            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)
+        )
+        texts = [
+            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)
+            for text_token in text_tokens
+        ]
+        return text_tokens, texts
+
+    @torch.no_grad()
+    @eval_decorator
+    def generate_images(
+        self,
+        text,
+        *,
+        clip=None,
+        mask=None,
+        filter_thres=0.5,
+        temperature=1.0,
+        img=None,
+        num_init_img_tokens=None,
+    ):
+        vae, text_seq_len, image_seq_len, num_text_tokens = (
+            self.vae,
+            self.text_seq_len,
+            self.image_seq_len,
+            self.num_text_tokens,
+        )
+        total_len = text_seq_len + image_seq_len
+
+        text = text[:, :text_seq_len]  # make sure text is within bounds
+        out = text
+
+        if exists(img):
+            image_size = vae.image_size
+            assert (
+                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size
+            ), f"input image must have the correct image size {image_size}"
+
+            indices = vae.get_codebook_indices(img)
+            num_img_tokens = default(
+                num_init_img_tokens, int(0.4375 * image_seq_len)
+            )  # OpenAI used 14 * 32 initial tokens to prime
+            assert (
+                num_img_tokens < image_seq_len
+            ), "number of initial image tokens for priming must be less than the total image token sequence length"
+
+            indices = indices[:, :num_img_tokens]
+            out = torch.cat((out, indices), dim=-1)
+
+        for cur_len in range(out.shape[1], total_len):
+            is_image = cur_len >= text_seq_len
+
+            text, image = out[:, :text_seq_len], out[:, text_seq_len:]
+
+            logits = self(text, image, mask=mask)[:, -1, :]
+
+            filtered_logits = top_k(logits, thres=filter_thres)
+            probs = F.softmax(filtered_logits / temperature, dim=-1)
+            sample = torch.multinomial(probs, 1)
+
+            sample -= (
+                num_text_tokens if is_image else 0
+            )  # offset sampled token if it is an image token, since logit space is composed of text and then image tokens
+            out = torch.cat((out, sample), dim=-1)
+
+            if out.shape[1] <= text_seq_len:
+                mask = F.pad(mask, (0, 1), value=True)
+
+        text_seq = out[:, :text_seq_len]
+
+        img_seq = out[:, -image_seq_len:]
+        images = vae.decode(img_seq)
+
+        if exists(clip):
+            clip_model=torch.load('fashionclip_fn.pt')
+            text_embeds, image_embeds = clip_model(text_seq, images)
+            logits = (text_embeds @ image_embeds.T)*0.07
+            return images, logits
+
+        return images
+
+    def forward(self, text, image=None, mask=None, return_loss=False):
+        assert (
+            text.shape[-1] == self.text_seq_len
+        ), f"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})"
+        device, total_seq_len = text.device, self.total_seq_len
+
+
+        text = F.pad(text, (1, 0), value=0)
+        tokens = self.text_emb(text)
+        tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))
+
+        seq_len = tokens.shape[1]
+
+        if exists(image) and not is_empty(image):
+            is_raw_image = len(image.shape) == 4
+
+            if is_raw_image:
+                image_size = self.vae.image_size
+                assert tuple(image.shape[1:]) == (
+                    3,
+                    image_size,
+                    image_size,
+                ), f"invalid image of dimensions {image.shape} passed in during training"
+
+                image = self.vae.get_codebook_indices(image)
+            image_len = image.shape[1]
+            image_emb = self.image_emb(image)
+            image_emb += self.image_pos_emb(image_emb)
+
+            tokens = torch.cat((tokens, image_emb), dim=1)
+
+            seq_len += image_len
+
+        # when training, if the length exceeds the total text + image length
+        # remove the last token, since it needs not to be trained
+
+        if tokens.shape[1] > total_seq_len:
+            seq_len -= 1
+            tokens = tokens[:, :-1]
+
+        if self.stable:
+            alpha = 0.1
+            tokens = tokens * alpha + tokens.detach() * (1 - alpha)
+
+        out = self.transformer(tokens)
+
+        if self.stable:
+            out = self.norm_by_max(out)
+
+        logits = self.to_logits(out)
+
+        # mask logits to make sure text predicts text (except last token), and image predicts image
+
+        logits_mask = self.logits_mask[:, :seq_len]
+        max_neg_value = -torch.finfo(logits.dtype).max
+        logits.masked_fill_(logits_mask, max_neg_value)
+
+        if not return_loss:
+            return logits
+
+        assert exists(image), "when training, image must be supplied"
+
+        offsetted_image = image + self.num_text_tokens
+        labels = torch.cat((text[:, 1:], offsetted_image), dim=1)
+
+        logits = rearrange(logits, "b n c -> b c n")
+
+        loss_text = F.cross_entropy(
+            logits[:, :, : self.text_seq_len], labels[:, : self.text_seq_len]
+        )
+        loss_img = F.cross_entropy(
+            logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]
+        )
+
+        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)
+        return loss

From c4b6c0790c42e913f55e056a885c4ea0592608b0 Mon Sep 17 00:00:00 2001
From: kimyeondu <yjookimcd@gmail.com>
Date: Mon, 20 Dec 2021 14:53:58 +0000
Subject: [PATCH 07/26] edit import modules

---
 dalle/models.py | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/dalle/models.py b/dalle/models.py
index 93101a5..c57627f 100644
--- a/dalle/models.py
+++ b/dalle/models.py
@@ -15,7 +15,6 @@
 from ..utils import always, set_requires_grad, eval_decorator, exists, default, top_k, is_empty
 
 
-
 # discrete vae class
 class ResBlock(nn.Module):
     def __init__(self, chan):
@@ -262,23 +261,7 @@ def forward(self, text, image=None, mask=None, return_loss=False):
         device, total_seq_len = text.device, self.total_seq_len
 
         # make sure padding in text tokens get unique padding token id
-
-        #text_range = torch.arange(self.text_seq_len, device=device) + (
-        #    self.num_text_tokens - self.text_seq_len
-        #)
-        #print(torch.max(text))
-        #print(text)
-        #torch.save(text,'text.pt')
-        #text = torch.where(text == 3, text_range, text)
-
-        # add <bos>
-        #print(text.shape)
-        #print(text)
-        #print(torch.max(text))
         text = F.pad(text, (1, 0), value=0)
-        #print(text.shape)
-        #print(text)
-        #print(torch.max(text))
         tokens = self.text_emb(text)
         tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))
 

From d40d23cb80f7150e7c09b8eb784da91759a57836 Mon Sep 17 00:00:00 2001
From: Joonhong-Kim <danielkim30433@gmail.com>
Date: Mon, 20 Dec 2021 15:05:24 +0000
Subject: [PATCH 08/26] add) generate.ipynb( koclip+dalle example)

---
 .gitignore     |   6 +-
 generate.ipynb | 404 +++++++++++++++++++++++++++++++++++
 model.py       | 556 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 965 insertions(+), 1 deletion(-)
 create mode 100644 generate.ipynb
 create mode 100644 model.py

diff --git a/.gitignore b/.gitignore
index d6d95cf..c19f7e6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,5 @@
-models
\ No newline at end of file
+models
+/dalle_pytorch
+/taming
+/__pycache__
+*.pt
diff --git a/generate.ipynb b/generate.ipynb
new file mode 100644
index 0000000..f6f5f00
--- /dev/null
+++ b/generate.ipynb
@@ -0,0 +1,404 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import argparse\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# torch\n",
+    "\n",
+    "import torch\n",
+    "\n",
+    "from einops import repeat\n",
+    "\n",
+    "# vision imports\n",
+    "\n",
+    "from PIL import Image\n",
+    "from torchvision.utils import make_grid, save_image\n",
+    "\n",
+    "# dalle related classes and utils\n",
+    "\n",
+    "from dalle_pytorch import DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE, DALLE\n",
+    "from dalle_pytorch.tokenizer import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "raw_text = \"아우터는 색상이 브라운 소재가 우븐 핏이 노멀인 재킷이다. 하의는 색상이 블랙 소재가 우븐 핏이 노멀인 팬츠이다.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from easydict import EasyDict\n",
+    "\n",
+    "DALLE_CFG = EasyDict()\n",
+    "\n",
+    "# argument parsing\n",
+    "\n",
+    "DALLE_CFG.VQGAN_PATH = \"/opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/checkpoints/VQGAN_blue.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
+    "DALLE_CFG.VQGAN_CFG_PATH = \"/opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/configs/VQGAN_blue.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
+    "DALLE_CFG.DALLE_PATH = \"/opt/ml/DALLE-pytorch/dalle.pt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
+    "DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n",
+    "DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n",
+    "DALLE_CFG.BPE_PATH = None\n",
+    "DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n",
+    "\n",
+    "# DALLE_CFG.EPOCHS = 20\n",
+    "# DALLE_CFG.BATCH_SIZE = 54\n",
+    "DALLE_CFG.LEARNING_RATE = 3e-4\n",
+    "DALLE_CFG.GRAD_CLIP_NORM = 0.5\n",
+    "\n",
+    "# DALLE_CFG.MODEL_DIM = 512\n",
+    "DALLE_CFG.TEXT_SEQ_LEN = 128\n",
+    "DALLE_CFG.DEPTH = 12\n",
+    "DALLE_CFG.HEADS = 8\n",
+    "DALLE_CFG.DIM_HEAD = 64\n",
+    "DALLE_CFG.REVERSIBLE = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[    0,  6164,  2115,  2259,  8817,  2052, 10424,  4642,  2116,  1469,\n",
+       "          2862,  1887,  2052,   766,  2149,  2179, 10224, 28674,    18, 19975,\n",
+       "          2259,  8817,  2052,  5676,  4642,  2116,  1469,  2862,  1887,  2052,\n",
+       "           766,  2149,  2179, 15144, 28674,    18,     2,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
+       "             1,     1,     1,     1,     1,     1,     1,     1]],\n",
+       "       device='cuda:0')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# import from huggingface transformers\n",
+    "from transformers import AutoTokenizer\n",
+    "  \n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n",
+    "# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")\n",
+    "\n",
+    "encoded_dict = tokenizer(\n",
+    "    raw_text,\n",
+    "    return_tensors=\"pt\",\n",
+    "    padding=\"max_length\",\n",
+    "    truncation=True,\n",
+    "    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n",
+    "    add_special_tokens=True,\n",
+    "    return_token_type_ids=False,  # for RoBERTa\n",
+    ")\n",
+    "encoded_dict=encoded_dict.to('cuda')\n",
+    "input_ids = encoded_dict[\"input_ids\"]\n",
+    "attention_mask = encoded_dict[\"attention_mask\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n",
+      "loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n",
+      "VQLPIPSWithDiscriminator running with hinge loss.\n",
+      "Loaded VQGAN from /opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/checkpoints/VQGAN_blue.ckpt and /opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/configs/VQGAN_blue.yaml\n"
+     ]
+    }
+   ],
+   "source": [
+    "from dalle_pytorch import VQGanVAE\n",
+    "from pathlib import Path\n",
+    "\n",
+    "DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n",
+    "\n",
+    "dalle_path='/opt/ml/DALLE-pytorch/dalle.pt'\n",
+    "#assert dalle_path.exists(), 'DALL-E model file does not exist'\n",
+    "\n",
+    "loaded_obj = torch.load(dalle_path, map_location=torch.device('cuda'))\n",
+    "\n",
+    "dalle_params, _ , weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n",
+    "\n",
+    "vae_klass = VQGanVAE\n",
+    "vae = vae_klass(\n",
+    "    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n",
+    "    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n",
+    "    )\n",
+    "\n",
+    "DALLE_CFG.IMAGE_SIZE = vae.image_size\n",
+    "\n",
+    "dalle_params = dict(        \n",
+    "    **dalle_params\n",
+    ")\n",
+    "\n",
+    "DALLE_CFG.IMAGE_SIZE = vae.image_size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'num_text_tokens': 32000,\n",
+       " 'text_seq_len': 64,\n",
+       " 'depth': 12,\n",
+       " 'heads': 8,\n",
+       " 'dim_head': 64,\n",
+       " 'reversible': False,\n",
+       " 'loss_img_weight': 7,\n",
+       " 'attn_types': ('full',),\n",
+       " 'ff_dropout': 0.7,\n",
+       " 'attn_dropout': 0.7,\n",
+       " 'stable': False,\n",
+       " 'shift_tokens': False,\n",
+       " 'rotary_emb': False}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dalle_params"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1024 16 16\n",
+      "torch.Size([5, 3, 256, 256])\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.8/site-packages/transformers/tokenization_utils_base.py:2233: UserWarning: Though `pad_to_max_length` = `True`, it is ignored because `padding`=`True`.\n",
+      "  warnings.warn(\"Though `pad_to_max_length` = `True`, it is ignored because `padding`=`True`.\")\n",
+      "/opt/conda/lib/python3.8/site-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
+      "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from model import DALLE_Klue_Roberta\n",
+    "from clipmodel import *\n",
+    "from einops import repeat\n",
+    "\n",
+    "dalle = DALLE_Klue_Roberta(\n",
+    "    vae = vae, \n",
+    "    wte_dir=\"/opt/ml/DALLE-pytorch/roberta_large_wte.pt\",\n",
+    "    wpe_dir=\"/opt/ml/DALLE-pytorch/roberta_large_wpe.pt\",\n",
+    "    **dalle_params\n",
+    "    )\n",
+    "dalle.load_state_dict(weights)\n",
+    "dalle.to('cuda')\n",
+    "input_ids=repeat(input_ids,'() n -> b n',b=5)\n",
+    "#print(input_ids)\n",
+    "#print(input_ids.shape)\n",
+    "#raw_text=raw_text.to('cuda')\n",
+    "# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n",
+    "clip_model = torch.load(\"fashionclip_fn.pt\")\n",
+    "clip_model.to('cuda')\n",
+    "images = dalle.generate_images(input_ids, mask = attention_mask,clip=clip_model,raw_text=raw_text)\n",
+    "#images.shape # (4, 3, 256, 256)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Input Text: 아우터는 색상이 브라운 소재가 우븐 핏이 노멀인 재킷이다. 하의는 색상이 블랙 소재가 우븐 핏이 노멀인 팬츠이다.\n",
+      "probability: 0.20085719227790833\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F79C42EEF40>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 0.2007923722267151\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4nFz9+dMsS3IdiPkSEZlV9S13v2/t93phowmAIAA2d4xhjDMjaaShbESZ6W+VmcZMIxvJONSQIEgQXNDo7tf9trt/W1VlZoS7H/0QWd+90O3u1/f7Xq2ZHh7u5xw/wb/4q38PEgITEAwipgCImJmZiQgAERERE4GImQBiWv+AwEQgZiJiYiJiBqg/l+4fz8Qs61P+xqP7Q94/tD+3/7W/MIOJiZiFdf2XIsTETDlxTjzd3SjZ/voK050vh+P129aWw+E2SOZaj/OymF/f3M7zrCphDkBIltbMDMS1LQCGcbDmt/ub41ydYmn1u2+/++j55/BYGt6+u4UqlFXS7vzs7auraWqAX1xeXj54+OzZs8cX28ePH/7gix94bZJ0Oh6fPHp6fj7szoaHDx6MWcdcKNxra22xsGYWESQ8jpuLiwsCwl1TUlVmcTNmEmEmtqXC/XB7bVaZqc7zi++/+/a7b1+/enN7d0ugw3Gq1b/7/sVYBknD2+vbt1fX4WwetXkwEWsQsbKmXDZDSinnVMrQqu33x2maa7OICHA1n+aWx6G2lrISkUe/ZQFAVM2asCCCmANBxCJchiLC3qw1G8dRmADaDMPuYvdP/+k//Cd/8icXmwfvrt9dPHhQhiEC/ekAiInX2KCIEBFhAYFALEynKFpjCWBmnEJx/R/exyoAZmZaH3OK2/VJALEwAsxEIBEmAhMnRIoepCAmof4yp0hd3w79vYiZgdOL92f12FyfsL73Kcr5wxdZvy/fv3xfT0TUlx33gCcmYgk6PZwYsq6WoCDuoR9EAYIFLdWbteP11eH2bcwH9RYEc0garLmxIOk0z4s3B5bjgghRCTNDBCgiNA9CHMRBHtCiw12b99fT2ebh7ZtjqEKZUmajIrkMmxQDXJMYQGaHd2/bQHKePvrJ3/vhdrd99PDRt9/+5sXNqwePypc//nsXF+dCJBQSYcsSiKxceJC0ZREWTZoIYNI0FmYl4kAwp359AsFJQTTszjBNh8OtuT15/vzp8+dhtsxTPc6a89XVrVk7THOt/u7tzctXr2+v7t68eevO3718JaqLt2hB0dq8LICoaEoksrRqSwuP2lyzLsdGiZpR3g5tseZOKq1FKonAMAcYHsxEHiAwgYxYwwNhJkzHaUkppaSHaWmI33735kdvbuX5zpO0CA0EgXvixOmmMyPQLxJEsK64+yhZg71HBp1SNK8JWfrSANYHnCJwXQ7A+hgiQqxRSqd4Z4oEBhGYIuR9bl+f2VfV+sr9X+AUtVh/XFfe/Q7RgxWnf9L73/TNggh0/3sinFby+xXHRLH+dc0GxP0bAkwghogQHHAVZmvt9ub65fc2z94ObDUJxdJCqC3V3czcmylJjQg3c7c5GOweosIsoqJJAxBKTBJC4aTjON0c5lbFdbvZFS3HZQohn3lJcTzuS8nK+csf/uiP/v4/evbw0ePLs4+ePxiHARWPHj588uTv/egnX1yeXwo8opEbmQv5kJJqERVh7YkgAoFghgIEDzh6jgQ8IpqZGzzMmrVZhErORBBhKnnYjG1ntbanw6aaX7gf5vnp55/+BDjsj9fXt9fXt1e3d6/fvbu5uZvm+e5wPByX+TjX5mR13GxKHpRSCxc2EHYbcRZWgcFBKeAcRQXuxExwJiYOgIiib9RhcG+iCkZEsAhgPbzN5O2L77775je7kndnFxLcWkucQESM99kRxCAwwHEfKfflBK1VhvTFcp81e7Bx/7droH8YVusK4ftYvX/uaUMgpgClU9DzB+H6fhnRfXlz+qj3UX7/GdfH3Nc6f2PJ/s1FzPefgfF+tbx/L+LTBeH1Ct1fBFAIAbAsLMwRpiBubTnub9++aMuhzUe0YxJu1czNA3NbqnutlSg8HBbuaM0j0JqZm7AM4yDBiVRYg5oh6txyKmTLPLdlWsZhizGYyK05HAbHPB8Ou/Hy4uLRn/7T/+p//L/83xITR/3+xW/evH1NjrHkjz5+erY7Ew539+ZkQewl56Qs69VmIgoiYXIACHc4PCw8IsIJ5O4R3vMbA0VzZiJEAAJmCiHFpshI1erhMHnky3HjARbB5SP/JOalTdWO87y0ujSb5nle6vFw2N/eXV9fIfDw0eVQhqurmzdvr16+fvvq5bvr/b4uXh3EjIgwziW7wyMsnJhTUoAAEEiFiclqS0pE5B6MoEgsklTd27u3715+893jp09SSZsxA+RYVNN9MPRwCMKpBOgVBn2wDk4JtNdNRKcipCdlnFLq+pwPfnW/S7wPyB51ADEBQURIWH8+PRH/f/F/v07fP2ZNzHRfva812ofP+fDPKap5jXswKD54D76vhe6XAfpbvN/AwAiQJWUiDyfUOtdp2h+mw+18OMKrz0sRIvNlqQHMS21WqxkYAAmzKBPHGkLu4dbczQ3YRiDlcjge53k2R4BAcBhYQ8QMHmHNOeBJGKwlH6b6Rz//8R//0c8//fwTHKr79OKb3/7iP/9nBn7/d3+23RSyxUzcGiFEMJYy5AQ3jgAD650GO8ErRYBAHuEW7gEAQECZiEiYWDgIQRwBIjh5T8MSAEKzpo3YtFQzIhYwM6lILlUH5mznqbQmkAHBDPLmcNRmRFSG0Syur68Px+XmMP/yV9/8u7/8ixevrubZmMlreFskae/iEIggEAKE8IAARBGApZxSTq22oCbKykmzXt3uf/X1V3/485+/e3e12Wx3u+LVOQvFfYu3riUQqawhfB9fOAX/fUivaf++b3xf4PRdhHGKY/6whlojDB/2BwBEODExUeB9dl7T7vruf7PpoPdN8Acxf79N9fc9dQbgdUPrn6xH8bpG3+f/08c9fUr0Fnq9BBAiiiAKIRcKtuCwsDYdD8e7/eFw16YprHmtSWDWLJq5W3Oz1swCUc0jgoiJBCRg7xceQc18aebm43aTamu1hbkbJOfEKpEJzVprmtzDnZRRPEVgm4YHDx988dGnTx88IFXOQqrPPnn6B3/nD1o9Xj68aHXp+WI+HkFxth1TLiIRFhatNQtHICIiAKs1whCBnvzdEQFAlVVYmEmIheHg/jWkZ38mYrgrcUqa83lWXeoyLwvMIURgIaPAJsHanISJBCJEQqK1moJSSrvtpoybT54+mlu9PUw/+tFHP/8Hv/vVV9/96jfffPvdd7c3h+ub27r4sYb23BRQEQgkaXS8RCUIHk1Yc1F3eJi5DONmrsuLr7//5ttvPvn0s9cv3ujHkjRbMxUFwgEVZhJQSA9iuU+hjL8Zg2vZhDVHY83/6GXOaef4ICJxXyytjQO9z/X3zbOknh7v0Zy1kehr7rSEPoj/U+V12mF4Tdn8wTP6fWK+r9JOnT4TxQrp0Io1va+BeF09AYQRESP6l2OCaggibAlv0/7W5vlw2Htr0/EgHmHVWkMzNwt3EnI3Dws3C7cwc7h7/zDCCkEu3LypsVk7LM0ihjI4hXsQEQuxaDCBEEF1MWEOROLxGEui/OnHP/onf/L3//m/+Bc//J2/VW/2sSzjGV/utj/64Q9qndwbMYiNIXnIgFv4PC3BsiwLwgjhEfD+H6+1eliYBZyAU6KAgwIU5L3po2AiEtYOiJGIiCozKZMwE+dcwMTM5oYIIigyIcBquZm5O9zdWjULJ2qt7vf7w2G/2ewIZA5NutNSHuTNT/LjB+d/8LMf394dX7+9+u1vvv7u1bvr67vjbOEQJguCQ5MS9Z2EJSf3AEJYETFPlZWLjPM8//qvfjGU4dmzR7e3N5txsxlHLQIERw/CHhMUER3xuC/y77PsCg6eiiKgY4rv+9FT+PEp4taC5YMinnu3sD6tA0dEqZcgTPJBG3FK3x+UY2sd/r7YOa2tNaz7S/OpBHtf14Di/Ua0rlruQFgPefC6j7FQIITAIEb0dCAUQiB3ilaXw7S/29+8i2pzncNM3DiCzMh65RDNzCPCvblZL6I9amvh4e7CLAzJWiuSakhimKMe9wc+F1VV1TAXFwIlTTMMgBhIhJru5zmV/JPPv/hn//v/5k//u3/8d37+B1TnyW4kfDkS0M4vt15TkEtSFSZwEDwC1qIu++Nc5yXII4J6HY2AebUKd7gTUcDDg+ArMhEIeG+4IvrdkA6QimjKmlJKUHiIsnljQEXCySIAsJAjCEiaOKAMTmJJwqOZm2SRCPO2TLZYBMo4ZEkplVCJs1HON/L8Sfvy07vf+8n3L958/e2rb1+8evvubn88uuP2cAzzQJSktZnXqimxCDNF38QjTKoK//Kvf72f5j/+4z/e/fjc3Vpra4AyM6RndD6hLIg1ozLz+57zfT1z2hBOSOR92X8qkLDG7H3O7jH7Hl4/rS+AidP9ernP8KeVcN/Rvq9+7n/+sB/vSNHax+MeOAIRB7mQivYNgSMQgLAoi4dHQFUgHduE9EQWkRIj2N0RFuHhVuvkbT7u98fDjc2TLYtFWF2IQB7ECGOLaObm4W7owDUogPBAwN07gaAphweRMwslkqISOteZD4fd+blqqosZwQBSZRYiCQIYcyze8OzJk//mv/2v/3f/5//hs88uMU37t69vl4OQjRtNFCyUhDyQOFQTExkoq4hmJK3BwmzmvfgheEQ4QzmTKoWbGXmACdFXRwTi9EPHzYUITAgm1SBEtDBhYu1BICIeCAhzr9pJkhI5M4+lMAuzWIUjPNCabZtP02wRRBwIcztOUw2y6nWZw0KHMpbx8eX52Tg+ffLgZz/70evru2+/f/3i1WtveHN1ezjM1iqBw0OwkgM5qTDVWtkln5W7u+vb/3I3TZOHffn5lyx3lw8fbIZRWEkCxJ1bADE6CCwr+bPW0+iwCN93vfdR+QECeV+FrzkaH7bE6xNPLQARg1j6rs73ewwxnTDN+xa1w/m8lijvu2UmCloxXXm/GwAQ7d2GgCEiYUYQIQIEILgHhwgrUVJyNPJArE2AimThRBqCanY43t3d3EzHu3meYUuts9Up2iIkrTVrFjAGk4iSeiAc5m7hxAjy4AgEUYhyonS6XtJqba2ae7RQEpWUJDfzw3Hajlswz9bm1oKhJc/zghBvQMPldvPDL3/8D/6rf/TJs4ec5O5w7WyZFxbPohzWDiZMAfdGoiQivVskoJSihTOEiDxYhImECBTJwwGYtZhnO+HOCGYmgRCCEIg1sdxj3h7wcGbrAUSMpEnAAKkwSyKGimgRdxMVVRFwBBCNrBfFqO5hdVn6xUR1n45HB40lb3dDWxbzatVylEHTo7Pt5Zk+efLok4+fvXjxiiVV0F//6uuXr99GRF3aVGdUN/e6VHenCBKepnmSmlO6uXrz7/7sz73Wy8uH0zQ9efz47PzCmlMg54QITcokvRZh4Y6wr2n+Hug8heN7tOh+DZz6y1Np3ddAXzWnyMeprCGKABGlCLAyg4Eg/uCNTs32iUjrwR8nHmHFZ3qaXS+nEgevHTYbHCzMROQOBIFTSlJSf2kWcW8CgvIKbFAwSTMDpNV2dzi8evH9tL9b6uRu5C3ICY1aJeLaGhFZbR4gkOrQcUMiCg9wDx8SIU2qLOFhHrWamS21Tssyz4vHqT1WUeLD4YAAs7TF0VxEVZnJgtmD0jA8ev7RP/uv/9sf/+AzVX7z2+/BDXHQjJQCVYlcOKZpdmvhDkJOCWEEUk1WBqFkZubu5uEBBAspMxAqqmVMmsfRCQEzD4O7h4U7yBEc7uFrdQBg7ZUjmIUlmJSJEZxUNauKCpOqapbmVZQIZG6t2bws1qxZHA/T/ng8HI5WLSUVTdHMFidlkrTJI7U4TvtDaznnpIVzAZlrGjg9ffwwnCrT7/zky4cPLspQWPJc2zJPt3f7m7fXN/u74/7QqoPcPMzazbtrUf7X/9/D5aNHDx9e/vSnv/Ppp7Q92ypJrbOQZtVe68uJ+40IEAkzsDYH/D7ET2mYVqkAVjLslPXpRDasdfr70F+bYQIRpfueoRfxf6Pc+mCvYV73k+icBBP1N1cGWJhCwETgYCGhDjuKJlIWRngLZln5Z5CHEVgBjwoL9+pmFD63GstMQcfpeH043N3dtmkG3NwSR0qCcER4AIhamzcDMZMAlUlA5GYOIwH33l5FVAAJQYsa8GWZl1oPx4OZt9pqrSllMG03Z63Zbb0bhk0QW0D6BxbyaoBolo+eP/zjf/zH2JXb+XqmJWGS0jSTL9PiTLBwwIPCa62tzdEcjCEPLKKaNQ0EYmJ37wVOmHdELKlKUhZWFRCRJIGEm0KjNzIWIhoKBLqaQHM63awuD2EiUpWUclIVYRERZknMLMLU+43WWq21NZ+O8zRN+7vjsizM5M1jWVprFsEsVqfJLUACkHszM6miGSxGtBhINIkuzYrqJx891VSSJmJxcwufl/nq+ubdu+vbu7v93eE4HeAIiulw8NrevH396NHjYRhLzrvpbCzD2dkGhNaYWESUhDrZSYCI8BrnKz6+/vMEEzGD4r4NoBPSfoJFiRHvG4f3iAsRMweQTs0y7v//Q8C/v4cIASRBYOYIMDHYKRi9j4dFhBMrxjETBxNza1nJmzW3ttTNUJIMrdphOi51ZpC7mVfAW2sRRkTeKrmTN7LYH/cWZMtEZq0toACjOSKI3Qxwd/e436LCol+MwIl7IojwuqsSORggc9TWWjMGMcuy2GFaIo6lDODkoGWuSwPnAYAZKIiDCOEthkF/73d/+uDsodTFHZtBk25KSbFUUlE3ErLeWggxzNviESIyz0dAPIgod/wiaVIVlTXLOTxcNJKwsjAI1EtpKFEP48QED0MLCFQpnXLkqk5Z4XQWZsQKr1BwsDOxuzkjjGq1eWpusOp1adNxqXONWIkPRyBImYXUarhWIsmaqFCrLYKMw0H7eTEPZyZSKXm7HZxlWea7/d57HKXEwpeXZ5ttfro8Ok7Hw2Ha7/fLbOattebLcjjc/foXv7Blefzs+ZMnj8byUU6JQJIHc5dAEmESVbLwtbFkFhBRfAjP9AUBivuOme+5U/qQGDhV6ada6F6nkHry7/QD0Uq23fNxICKBkxAHEQlRCClJcDCru6lyJlZSUXZYomBESbLUevfu9tXrV69evG51eXh29uzpU9bh7nCY6zzPR+pgSHhEdNBPiRIFW4vwudlSLcLhRgAYBjcYAgJiSR7WlU89WjyIWcKDoiMn0aIhkFPOaQBggDe4hVm0ZpJSO0y11WWurfnx6IfJiMXMiVoZYyglIqwaAa22xZaSt589f/75l4/v6svl9kDLQrvgIIQLRwvrahIdmFvOuRChWYsOyXNvBoAghC/N2UhZmjV3NzMAkqRoziXlnHLKol38ByYhkGZoqCfHCWnwE5TUU1pnQztJbORiBLZwY2VwAO7mbWmdHpmW6ThP0zyZNzPv+1IEmElTUk1BEIimHJLAbO6t1qUuAUJKEWFBm20+uzjTlKYW1WZWYmd3wwJRZpKiuezGi/Oz2tpirdY2TdP11e3xcDcvy/Xdu/ar+cXr77/88sv9zdVnn31Scjq/eDDkgRJRuIexaP9K0tGltYgHE5NIB5vQo/ak1aETV3Aq+t/jNR8wAERM8GDh9B62XMnn9xR033O4o/MkROGABId4BHEKLVoSawSWGRS1TXfXh5ubm+t3b61am+fX11f7m9vENF2ct/kwjBvJCfCwyay6N1qbOxahIJi7hIUHItxbswY3llXCaXBrTgAF5yHnlAJgYQeIJDyIKNALEcDgjrBmSiQ6L621djjOS2vONC/19njYT/Ncba4tAsm9mQ9lyJrNwm2pFhyRlM+GMYk8PN9dXIyHq3ff/OoXZ08fYJlSGmhkn2YZpS89ES2qLDQMQy6ZOHr7Go5wMovwaO51qa3Z3IwCrS2BMHMiPgAkVLRstsNm2JQh55xIhEX6JRIFgcLd3ZW8I2mdrQABEUy9v12pmIgmQaxibl5jnmpttixtmuqytGawgPnKiY7bsZQx5xKAt4iea8N6XcIhAgOxBGVJOadcBmEJQxHdjqM1Fw4KbuHmPcVGRFeh6iCsqYhyKrq/SXe3dz3PurcX3357/e7tb77+7eOHj7Omn/7sbz19+jFnAKhWw2IcRxVlps4Tsoiw8Pvulj/gfTsYuYb4e57g9Iv7mh6rMo4SsQBx6hFOa+XUXoMgHCfwh5nQYlGiLKnXUHGcGXj5/bffffv963dv5uPevZ1vz9wNZtXaoJIiaF6uXr8mZdaUkiRl5hBEwIkQwRbB7gJQWCAs2FoH68iW6uHNrXOnHAShxWopOacsosIcvathgq/LF8zuLcDiwaxmPk3HuiytWjWvHnWx5mEOFiUARmMeE2lmibBoxALVtN0VgO3OGrfvX3z31S//Q/Pmr1+OQzp7cB42H6flLA3MQ+e2oCQkpGkFgLjrVgEKJQJcXHLipIWHEJVwb60tS5um4zTNZvVI091RxmEcx7IdNymnkrNqFuGshVU4pYiu7GtWm7vD0Us/gNDhOQqAwisTSNncWnVrXqs1s3lpzcMCDiZNm814dn6RcwFLILxVQ4tgM2vV57nO87LUFhEsiVnSkPO40ZyJxMI8IKyiXKsHuKS8xhmzwREGq+ShJFmZU0kXF7vtZlmsAzjmbb9fVNTmebZ2c3f1xedfPnn69PGTx7vdWRQGU3izABGVnHtxEqtCuxNIdAL/cep6T+U+7omsD6TKvXgUBpBOHe5p/dCJrY3O3QqCGB5MBFZFGZKQEYyI6jLtr66++utf3FzfzvM0L8expHEo0RYmUuaLzRjuCiQmsEUQyOZqTC5MwlDp7IQQGHAnMJxYwSHKxBLNegZ16zcYK8siVI9NWUoehlxYVEQ6Vt75Y1A0d0QQqUdt7vOy1NaqWRCvYWNQUWZYa0ahAGdZrLbZw/3sbLcd8tn52eH60O5mKeUv/uzfvvv+ze/87pfby81HT59dXj5MhUBRPcLZGpjBzRILUTD3wJcVwycQc84plUQoHRH2CCbOg+exapEyllbn1izc5/m4398ikEvejdvtdjuOQxk3YxlSSiLKIkQSQQ5yMw9qbZVShId7A8hbIyEWNbNw6qWLOQcpOOkgypxz2Wy2aRjBUiNqq4uTOUWz2uz29tYMba5BlFIqJY2bbR4GTUOQBKjnJhJmKaym/AEFxaScScSpmpvVFhACRCinxCJhUc0AqrW5z4e7w+58d7jb/4f/+JcpDz/72c8+/fyzZ0+eBxM4zD1pAom7nSTMEoBQxAko7RHPpyRP7/+yFj/3iBD3ehGRENEBhNNGsfbXwaRC6K0kyQrUe8vC4TYvx+vbm9evXt1e3V6/fbUcJ0Q4rMFEhjENwiEgSaoloxorPBC01qFwW5FtWeUJHd9SVgFEgSBfG0QQcxCYhTnMHHC3AEWHYadlGVIexk2WnJJEBAVImCEMjuDm1Syq2TzN1hoC5mbVzJyINKlVY5IuzwtzCoI7PJTw5OnDYbO1uT1+fMkRv/zqq+vDzVjk4x89bXd12G0+/ehT1UyLA4wAE2ypISxCyh2KAjNLEoESREQ7Ee7uQUJsFEg5Dzmfb8/M2zLXZVlaXeZl2d/d3u0P0zwd9odcSinDZjPuNttxM45lUE3CRBGdFQZIVB3wiOYG99rseDggYhw2zWzc7Fg0sRB7HiVkHnNRSazCmlXTVBerbak2L3acpuPxWJdWl5lJiSUPabvbjZsxpSGCa4SFeURrbhGSBcxE2iUuayLqTBGiy4dCAXAiDpdgIjaLGEouqqo8HSYisqUd/NYsLOLm5vqLl1/+/u//weXFw1SSiIR7lYUtNPfKBR0dAjFFkMjaBxNRdBkZnzChtatlErr/AWDhdD/3dUJVBRTePz9CWJJQJ228hSgLY5r2v/36q3e3++mwP1xdk7XdWBCR0gbqzJHUMquyRHh4gJyMnALubgEPgMzd3W2t+CGiWXMR1T47xkIdJgELUQfkWYiEao1gePMg7326qc+Ll5zLUErKxLLy3iJuzVpbmk3z4hZLa0Gw5m6VIlQUFIgQgqSkQpqZQwGdzcumlFKS6lDSJJTHYbq52Q/p1fXL8+PmEIfzr8vl5WY7DMt8x8QCIzeIVAJgKYmKsiZlJdbTvs0iSqJEUOFEKsSsffaLwj3lWQrTESFxkS7G7TAv0zzVZZkOh8O7d1DJpZShDGe77TiMmkQ1EYFZRFJJmqRsVbImELVaEQFWAiMJBTWPZVlkmYvv3JxVvTV3r62Zxe3N3c3d8WZ/t9TqZh6hKuOoF5eXZSx5HEQEFs3aNC+tOYgjQlLiYOlydY8PNDUnLt6NECSM1tkniGiWVHLqiHbxNOQ8H491Wc42lzfLvrbYbfn66u3/9i//1/NHD3/8ox8+/ejjnERISEVEO5IMAUEJ0Tncju8HSE54Pu6lnetA2Yc6UybmxCS0IqWryu5+KSiLMHV9otWmSUWxLPOLb7++fvvKoGGWNEWd2zwpSRXb7JKqJIYywApayZcIMkSErUU/AbTKMiPIETCqZjOzBjH165PIg4QQ0NRjWpJmLgxiM7fW4CBmMhOx1pbWSmzGnJITPBoT3G2pbanNm9Xaaq0BsiDzzrB0xVmIUEmckmSVlNiMNNFQNGDHqbW2ZBW0auHTfFh8un179+jxxburm+s3r548eV6tKTNxNDMQAhHeFgYrpzSWYUyp96XkFBEQEZVV6MkgFlIWYgpODBIW5TSWIcyJMM/LMi/TNO33x8Ph2Ky6tWWZDoe9iGjSnDIxlVw06VCGYRjSUIZhTJpTKuFYlgqSpVX3aPMcaMJFqDnRPNe61Nv9zfW767nOVzf7aZpZNOdCwmUYHjx8eH5+vtmMLOLkS7PD8XB3e3APEQFJEumpnhgnjfMJfuH7UAMzZxAJe4ACQDBzUs29zCiRtXR6b1lmQmRREWnzcsDx3c3rZb//HbMvv/gRdQgAjkApAwuTn7aBtbjH/YgJvaeG3zPF950wE1FETx4McJ9IEGKwhKw0XHP3Vmtd4J6SWp0Fy7yfMmtdmi9VJY7zVOeDsG42WufQJBRDiPf2oXk0t9psaS3cVETT/TITIZASRddhhlWvDcJJxIMoqwZBhFHppA4BC+eUYigW1twkhJjQYMTm7oFcFIzaFiH1AMKZyNynaTG4kIQ7A8IEZnOwQCRp0aGUPu1BoM1QhOTlq9dW25Dz+cUZwKUMT54+efrok4ePHj+4PE+qL1+++uyzH7x74xfnQwsEUR/gataIICIYmojAgyXByQIRAbAmUZIVGSVSESYGghlJtZSSVDzc3TdJ0iaVbdmcby7n83lZlnk5Df1YVLNmKal7pJyJBCySy2YUVp2WpS2tLXac2/Ew1baYOassy3I4HI/TdLvfX99cvX13dTgeiXF2fvH06ZPd7pxFwFyGYbPdaM4gBMU01+urq/3+SCBW8WasSXJKXbFHLMruq9ydeR3nRjBxHzQHCysTqbojyJu5cJ8DFsmac3L3t2/fXpydjUOJVilUs7bwX3391/vpbpmPP/2939ekThBSZgUoyJkAKK3ADd1jnScwn7qSdNWErmIfdForrVqLrpkICibtAHsldwP7NO1TFgbm5WDTkbkOGz4cJreq4m2aGU2VVMgtJmucZaqRcybprLaA+/CtNWtGSJ5YJcL7MhRmUQ0Rt47UR/iM4E45q3JK6TSgv1J6KemYB+U08eTmAJpZkKNJ+GGu5A7ztt3s0Oe/rNa6sCBDqpmbUURKEk7OlLLmsYzDUHJhVkScP9gF4eZwmKdpsx0+evz04+ef7Ha7Bw8vn3/8/OHF2TiOQ5YQevb0MjhRyndTJSIKCVIHLBgUZFY93BqzIpjALRCgDtWdvAMAImESEk06lBwpdb2LgIVEtWQpTVx1SdJSGjaDmXlrdWkNHubemtVpEdGltPNLFskqC1FLOR2m6fb67jAv+9vj8XiE8HE6TsejI+Za93f725ubZlZKuri8uLh8lIaccgFxKTmVQVSXxSLicNwfjtNxmtxNRNCCiVVXmR4TU4QSBVF0wQbRSfDZRe19xgHMTCAR9Om3FggHBXEqbWnLvNze3u3SmEZw1HkxHXIQpnn/1dd3dT64xu/8rd8tw9iaOQzhQtoJQGDddxBBJ3EEn6L+fpys/7ojv0RIa/fL+h4NYmHihupu2804lGEoauYihEQ3b29y5mFILNTc97C7W5iFpOTMEYRwEhyrZ9WcSx44WCUxtRoBt1ZhuSizOoUwUsrMJEwEaiJB1vGenjZExJrlYeiT8X0NsEiQs8owlImqtxbSJ/ZcQsTpMM8p5VrdwqZ5ub09VLOsyfsuzSIEVW4IBinrOAzjOGYpIhzhdV6Weck5P7x89KMffvH3/sHPnz5/vjsblCSpKovmJMS7s2F7dnlzWFjKNNd5npVQcnLr7VfyqBHNW0VHFYhByizRhZ4AMSnxqowTYeNlmUEk0m+GC7MmFekTOUEqqWRWpiycRIbs5sljAIkIqw55IObm7bBM87G+fv321YuXh/3hbj9N8yIiZdysEyAEAGUcnpSnxMgll5R1yE5UayvjyCIeqHWuZof94Xg8THVxMy0aFsSioiACqGNZjlgVNX3InekERQqzgpmEw1tnZleNGxMQFgGQT8fpMDUzCtkfj3nQVNK4KZPVWm0YxuPd/qtvflsRRdOPf/K3VURysmUVxAUQXdO/gkCnlmCthLrHBCHuOwF04i8RkzBH/2mtlUBMFN5H3nebbW37nFRSmu72IlimY05ijkF0Sio5RzPXk3I4yAKEsIQGOhNlJVXNmk19meeIqM5JRVUlaYQLc59SPDVQXWUXANzMBRaRk6gqMfUlQUxE6u4UsObhZM2bWdcgsXMw7u72gTgel3muAVqWBUy5pDJI0zbNcxKUMS/VSknjOOaktbWl1qDYXeyef/T8d3/209/9w7/z8NHDsWxSUna9Ox6ISHLZjGPZjCTDdJiljD4t1/trm4+7zWYoMgzJW+vUnMOX40xEwqqaDQKPOAHSyswqQsQiKtxHfjtv0L9sDynVpKUkVS6Jeezah/AAsVkwC8AiaubzXPfHw+2rb4/H+e2bd999892b128P+4mTnp9fXD6i7WZMqmDu7QoBmlREWvg8LWUcttsN54Tg1urxcLi92y/z3Gf1WblVY5CmzEKMgEcgQBwexNFluEB0hK9/etFk4cwivBKDq7aShSVE2B11Xlqt7sFE4ahL3QxlSOLMyxJRq7svc33x4ru/+PN/f3F++cUPflQ90MzhuQwiggicZs3vt5oP5oTXLUK6CPdUDqVVzi/ShRMBIoYAKeU+iqJZEhdyX5Z5WmbrV12UQoKR8zCMGzdEMAWBxClAIIrm3qKJ6iglMWvOtNRegPaydRhyUM6RF3Jr5s3CwSQi6HJfEu7SN4/mzqoqLFI4pQQDUXT1EguH2UrsgCJoKOO0tMPhqKpWbUhlaW1yCwIpNwuKYMjZ2QjI/riclXFMuVpjxyanh5989Olnn/7wRz/87IvPLs7Ps3B4tWBQ2p1tyzimpCkNqtQIw+Zi8QWpeMjtfjKLhxfnpSQR1kFT4uPdtZkLghIisAR4LXyZCEGsARKRLmjqCCmCAdZ7rTuzNFqWpElTLmVISZlFlIM4kYA5AnVZbu/2b96+++77Fy++//71y7fXt7dJ8zwv5r4bz3SjTtZg5rEmOmEibmZ9fGKz2eQykqg1d4u5Lre3d8tcHeHR6/Z1HUPYCYhwqghiUOehiTgIhoCHRChSFqW12WdOTOEEA4G5FyHsbmEdibKyGc8c5OEBC69mopKE5rpEbcQUiN98/ZuPv/r08ZMnZTwDRSeGO4oNrEI1+kA28cGM8b1RCu43hiQqKy3ccSACgSNCBCWXnPvAXZqWY90f62EiEIFbc1YOc6IYSrFix2mxCIJSUIgwESEs2nxwBlFJAHJOVRKCgFhma95yLTk3EjZv4U5BWROLMkJEOsgTYForRgejRE5bQUBYgkhJVERZOXPJzOhT0qwpNuPG3DejStLBY2h1stbMa50ZNOR8dnbOzGUzBMmxLu7OoueXDz7+6OOf/uynT589v7y4GIdRsqioiCYtnIqIkBCIFwtCqJAFPCiPG0r5MC2QsGi7YRiHpKruHRMnX+acilJCH1gkJkYWVRIGcVAgwnsnH1360t2UwMzOomJAAO6kokTs4TBq5tbsME031zffvXz5/Xffff/i9e3d7e3dgZSePXn25OkTYtme7cbNoCmvCaaTt8RdBkcRqsqJqzULuPlxOkzzCob2IR4isAr3WS83hHS5TMDhwczax44BdO7Sm7tDk3bYt49vMhk7R69CKBwR0Vqd69LMhmE3bmg6TqQaREu1VNJ2syXHjLkgMNWp2n/5y7/89PnHX/7wJ0mISMKbO0ilbzE99tdhlQ/0/XSSEa2bLxOBUgQkKeKkFSISYpxwCQnmxCmpuy91DngfNmydlg2hCNWcy5AM5ot5BZhWihoEWlolTRHRpdApp3GzmRda5uV4nBFTSlqGUZMShXLurjgsLKGUiMNYOBwMdbPo8JnnVptyn9iiAIRZUrov4dxjyGUzbGqr1SwCSZh1FJR5nkVYgM2QOcJAqplBJefNZrx4cPnpp599/uVnjx49Oj8/LyWXcZA+SM5ElEiEVCi4RYRbwLImN2jK47i5vLy8vnp7e3t3vN0/PD97+vRBD5uzi/O21LocAi6S1jTFkpKydOcH6gNZ1qxHP4jIeR2mdgQzBTtH1tCBzVxEmdRh8zLf3Nx9++L777757u3V9e3N3d1hfzwcdrutlnx2tnvw9IGAh+1GU+rlsWoWEZzq9Wbm4cTk5s3RbLZmdVl89X7wALxL8wWyBpgDtgonmSniXke/WgACCDi5i4uIiCakdcoTHBThaNa8eQfKW2sEsnBOwiqcNUQiXKrlnIRlW4YGn+Yqjrub63//b/5sd3b20aPnLmweZiacV+O29+O4KxK0Kn3eD/SuLTozEtP9jsBEJEIRrkrC4lYraNCsSQJw97pUhPVJDKJe8nDO2cyGYQiLVt3NwHDmnJhAtXnQ0Vvquh3VPAwsKuFcFztOxyBsmo+bYRwKIYJYhDrMTCBmUYJo8vDoWl/ztiyLVSVJqVBXoXXEDSREBqikVJIHkXugzbUB4KS5lIvzi+04KtM83V1f3cxzTWV48PDxxcOHz589/fLLL58+e3Z+fjlsB2YJhmoJcjAJaypF0+gUMGMHSRIXVlZQpLTdbigulnk61na7vznMe6Cd73YpKVTACyjCnDKBVSQlodP6jQDMrLbaFXXEaQVQWIjJKcIR1pIkLgnVhAWMw7R/e3X19vXVty++f/3q7f6wh5OwjGUcy5A3Q/OgklIurKAsEFKRlLJq6gEBIjggTEbex0+bLdWteqx9OgjS9fjMXWHU5TJ9aHNVYfehzRPJ2sd0OkNLwcEsnLrqOqL3x31MNdzd+tfvKz0iwiKVzClDdFMKag1zcidGEh1KocD+7u43v/3qyX9+8ugfPNaiYOfuYsQOkg8DfpWKn2SiJ6UbTtpPpN4/rRUQem22QgQR6FY+AvHWgIi+Y4WBohf9/aE5l2ZexlJbczdbR/wYGs1qbew5e8JQsoiknJhpGL3WhSf2ZtNc+yfKOXW1MxEjeu12wo8lB4Uot1qPS+ubCSII3IVRbVUSQXKmxJPF7e2diCL6bi+ppO3F+bNnT3dnZ2H+4pvf3N0dzs7y5cNHn3/x5Weff/7J559fXFyM46iaJClAkphJwEmysqiIEglDQ5XYGYA4PMDQlBg8bOz8wYN5moKw7KevjsePnj57+vRRBgeYWRwmxEkyJ+m5HyAHWfPWWjgRiYgKq7AQC3pTADILZdWkRGS1Ho7Tze3dqzdvX79+c3V9vb87AMhJ8yaDJS3VYcSCFKUkyaysQx5UVDWxSNcOxqkvxCmgPbyaWy/hw4PQjep6+ewRH1hLnfz7uM/gBa0Z8W+4T62YCsBBFn08dJVZold9AQJ1Qk+ZVBPIRVVFhjJIODP3j2XLQipCiZOY2c3d/ttvvr/929ePnzwPC4SoMklXia5gf1+StJrSvheNnnRyREyJ+TQ400sjrLxd7437fQt4a9WqdfjOzVjEzUWFHCKMkJySB+VSrHlri7mHteYtwpMm8qCRiSnnrCl1o6hahpIH9zBv8wJ4lKxDzizEyqDTZBwTASmlxJuGdlyOXGOzOU8sIOps0VKbsLCqMep0yGWs1VqLcVs06/Zitz3bPXr06NnHH33++RfjZry5viqDPnj08Gx7/uyjjz759AeXDx9sttuchy5Z86CUUjCAoMRpyCJqHl3jy0LCupbyCBE1Zyixps12++jJYxZcv3l9/e4d4mUZy/mwI1JAQRwOKCmJnITMrS7N3Koxi4hQECkhVoeITuYIpNZWj9Nhmm/3h3dvr1+/ffv23dXd3YGAMpTzs/MyFGZZWtOUw4iZz8az3e5sWzYknEvps6h9AKPb4RJRl6OYVY++C7l7N8CCRR8/w316dDitM7iCXu2gr5DuKtJlf9wVacyd2pNuKvN+vcXqzOZdFQOoiohISiIsOYuysgBhrcm66rqRTARDk4YDrb57+/a3v/nt+fkjBMBQFmH2VeVwb87AJz7svvQ5of3dFuW0OHoPcOLJ+PQMIaJorS61tjaTkC0NoLVk9AATcwJXSSkZcs6tWPIwWGttavPq8kYRczfgIu7oWEqppO1u43CvYWZRWwwZHpEwDAXkqevf10/OkkUtlClvxqxiEc2aVZvmmkRJaDkutdmw3bXDZMDZ2dnlowfPnz05uzzbDLuLh7sHjx4/ffQUCJvnTz/9+MvPfrDd7S4eXGx2F2UYVdThSTIolSFpVmI2AgQsfVpL3KIPaQtTBLGScEKEpBw1RBNzGsezx0/IW1vqNJbN69fvbsrd2XbcqliDeQWEujUGUJfaLBBUm4NNJZlCgzSJsooka3V/PN7cXN/c3B3ubm/3h7v9cZqW1iyl9Ozpo1IKkXRjAXOPcE06DkVzyuN2t9uWYQAgrNT9RtEJ/o5WklmbazOrbh6gcCJO6HJr7/MMwT3drzEFZuouztGDH+sqXUPrpDvrw+JyP3PYdVdrUd7H8zsRzj2BE9ABLuF1ORnClkVEutAiAE4SAWWG6nE//fJXv/7ok88fPXyoKXcAakX776cB7pVJ3ROFwH0Bnh6VcF8X9efczxUgRFklucc8T3WuxBS1l0YrqdfH3kGhrE4QkZKzaeONhNuRYGZMEGJ4qAYHWImZU1IhHofRqm83Ow/Mx30wLdNCXeBLGIfRw1VlZa6Yw722peSNFnWn1sIDh+Oy1GXYbJbjcpwXQYLMwfr8k6e/87d+54svvyCWVislvjy/eHDxaBi2b16/WZo/fPS8pLQZx2HcjZud5hSOrErMLCyqmTO023QHsQiYyFnE3+/wLCQQjXBmEgYSCm9S5tKUEMN28LvpZn8z3x0Oh/3lZigqSzgyhVMuxT3coZIcPpQNE0kfXxf2htmn42G6vb19d3X97u27m6vb/WFfl8qsm3F8cP6gbMecsqh6xDQvrS3VQ4hLyeMwakl5HMZxzCWZuTCZh5mbezNzC0eYuZnNS23e3K1T0izEYDOPThf1Auk0fraOpcepiMbK70aAZWWaiMDBWB0VlJixGkL25YFY5/j6cympNrKkaSglpYLw1pp5tOZem/ZukAjEWRNras3D3Wz59uvf/vVf/Zef/71/mAax1shAqkxrKYRT+rxXO9979PefpUshgFg96XDvPBprAyoI85ur69pqWBC5uzdrIhRBEcQkcDii53VJUsoQrZWcRbgTnrPPOZVOgJBKd/9S0SRp3GwCvHi1KMs8KXNbGjmZO4mMwxBAStrt4o/LMi9LKbm5e6VgWZodl2YBOy63N3sV1SwJ+MlPfvhHf/wHFw8ev379KiV+cPnw2cefbLabnDM88pAfP35UxkxGTJJKSjmJJFHqVtFdOeJEiVVFnNzXu6yqzBwRFARJPSgczN3PS5gyC6VEW2hOZbP71bv/VPJo5G0+vJtvzrdD2Ww9wiJiaYZA0Hw8ugMUzbxZq2Z3t3fLtNRal7nOfRqlWYQPQ9ltNzkNueRcCov2Er1rQUVSIYhw0qSqOeWhbJImhhJHrE4qHXP3ambuCNQ+Je3WN2omJviaPX21V+qI7AlO6XRTV3quNSpOlSrfO/AwdY4V1KfISZiDVv4hgG4J3DUSopJEkrBAimoQ7Q/Xx3lZ5ilFqLKIECvM+purkHBi0N1h//W33/7kxzePtyOB+hQ/TmKHtYxZW5G17e+YaN/MsA7E3Lcs7xEiAgU8Qhnww/HQliW8JVF0i4IgpsTE0UULzCysSYpk5GhurN1oLS115oC3Oec8lLIssxB1/T8LD0MJR4tNmMED3tydjcE0H6eS8jCUrpNYrM7TAkJdWguAeKlxPMzmMS+LEB/nedxunn/y7I//+A//8Z/86eE4fffNtw+ePvr0o08fPnlExN15eWkNQB4yk46boYOwkor01pBYhLvmVrXTNx3r+uCCEnM3KCcBU0AcVURan88MTmVoy0Qhv/rlV99/88LZBWzLRFFvrmR7cTaOW8K+D2e12k2o6jRNtS5LrV2/2ayFR0pJVXNOm92YRHsxQMQBdBVVEmrW4RT0ccGuKyKhXFIumZm937Fo7t2uIlaJLtDMatf6xKm35ft2dsUGgdXJ+NQlghnoDS+9T7FYyw/crwjh9dMSEYLodKwJwRHB6EZlxF0DWyQQTCYozBzN6zTXOktOWXPJud87N+f1IzEou7XXr15+/+rF+ZMnQh06CSWJ08d7H84nr8MPoNAObPf5sXvKsfscKsEp3BHKQK3VI4TJ3IjvjWuxFvVBqspCBCFmzSamwlxSLiWbNbNGiNrQ4W3lJqI6qigJS8llpI23Sow2ITgQ6BzgcZokpZJkaW06HqtXNwfBCeaynyojenYsKZHKg7Ozf/BHf/fn/+gfXu/ffveb3/6tn/zs6bOPLh9d1rBlWg77w9Xba5iP2yFh2J6dj3lIrFAmkvBeaEkfuE6aerrw6BLzAPFq2nySOkZ413NuVKyLfFiHormkI/PN6+u/+PO/ePXiG+YU5jkprA7CKaXzi/OhlADd3N7e3u3vbu+WZkThQZtxOD/blVzGYcgplZx5lU2feikCiBXUwtkBo9ZsrnMnDVVVEjGRSmKSfrNqXaq5O5l5s+aIup4JE7VZBMydVhqVE2ciCYTDGdLFDO+5JP5wdZyUNqejWbplUUcYhT40sGKSVZIGIe6TAwHtnqYs3hoihpQvt+cppXmeN6W0MWellCSn7u+iSbtNmCdVdxdygk/T9Jvf/PKjzz97cvEgSIhIlPtYOGgVRODkCrouWn4PhiacUM/11Jg+PePcFR0i6s2sGvfi352pK0icCEppRV25x78wKIlmlW6WXfIw6yzKrYZQLEtlkdZq17dsN4MHNMvIBbtdAEqYj7NHc8CXKqrzNHnJrbbjssxLZQbCq/k8NU5lqdXdVZRUc0mPnj/iLN98+xU0f/bxD58+/2h7seHE+9d3b169nvYHN+vjJGfnu+1ukyghQiU5wMIrCCOiqve7/amXWpW9TB3K7lNzASFqzlkGZk4MI0Obr6Zq9d/9uz//61/9sh1bO045ybgdm5tY0yF/9+qNeySVlPNyrMdpIiaKGMfxfHu+HTecREhyTiQMpg6VuzsRDA5wwLvvtpC4UzMT4n4TmFhY+8AfAi3crJqHG7l7ANbW8VLzFe8kWovV0w6zqpG6M++9UVS/GOv4dWcBqHs98ckctqfa1Sj2/ROJuvRjhYAi+mVUEWH1sGoVgcvznShFtNrmza6kfAn2aZrDqsFVSRO7RW8hRTnCEyFsevvq65u33z0430gasLbfsa7J1TXmdEjMCuD2hp0CSDhxEPdqoUD0SUgOMJObzdOBKKJZVlnCgqLPCpOuzVHEOpKDQDBEuORUhswH5JzCGhCtIQS0zISxw2cEyinlUkTSWEbb1DnaMKSFwuaKiLqosLRW57nOdelLrNU2z7ND2nQE4F0ORWm7GRH++vWLs7PdZz/44XYzhtj55dl3X7949f2raT4oOI/l7PJie3ZWSslSmJlEu6mEqDCzcBI+7do9PxEBJAxEn5KAdik5wMIaqGTkCjJb6jLfLXU57A9/9u/+/Nf/5Ze7tN3L/qa25XoGrlXp8vKMmzEhp2IIay2X9GC8dPO+TwfCEEVSMBzBHZNjFQ6QBoxADustJbMixN373rt+bCYiahFqztYYYd7VidRdMmz1z/NYLcZWtbyI9BHCXvIwSzcLPJUR/cUDIJwaWmaEg5hFZPWF7hK3NdOuG4d0+dlJotxHWnhlhcPMAhhLURKrbVnqdLcvm0GYyjA2s8UWJU5jCbcpZianEBEiRM5isNu76xff//bTTz9WJqHsHP3SdcHI+w9yzwDQupKZKd2vi1WgByGCu4lqty6b62RWwz0RqGvuIpiFmL2fnEPsbj2mV3ZNU8mlpDKU0ry6JtUwmwngxguqqojKvMxBOZhSSimlzWYbzbo/WjjVatbs6MeAW3MWFqHDYXb3au04m8dKNorKgwcXrbWbq6vzy/N5WjSBEyFaneuLF9+3OnM4a96ebc+3m03OQ04BK1KIleM0Fs3CzOhZsBtFQrpfZKxgSNC9WJMgBLMmQJvnVuv+sLfD9KvvvvnX/+u/+uar39Q6v/z+tQ5l3tf9PCOMAAneXO5246CqQBBzz99rWgc2oDKUYdj0CY6ubAJTODMHQfqMbXAQeXcBAFa4hdejTWBoEmjQaMoEgQDhQe5hHoF+QI7T6VCsE9vQpxMAOrmB90r3lN1PgCd/0A/cB9hqv7baluOkx1zriw8snPvhGkyqiRxWl2VZxpLHlGutyzQLA9FvghJxKRmeRThxspJrawiEeDiFAYmF2dvy8vtv3r358dOPP7dYStloyImU6GzYOkFO97ro9cNwAvHKTa+XoHf40d1Vlzrt727X5SPkra6gaXAAQmzkstZAJ/KYSBKrc8m5lFy8eGvHw0zE7kGwlNTctZkUqbW5QZNm0ZIHbLfuOWsNgsVhWpZOR6aUCDTtp/BorSF6ixIiIOGHl+cPzs9v7vbNbZoP765e3dx+NJQx5/Ttb35b54mNOOmwHc5221JKHoozJWLrjZrwetuYopcR6/dhQvd5W0GBCIcFU7AQuy9tlujeNc1a3d+9+/q33/zP//J/+at/+x+vb+/2t0eoXpyfscowjks14uCcJakx91ubNHVdc611mVtfEkKCMElJJXkH2nrmEiJiBwlTAGBYBMPXtHyvgyFQhJhpa5SyMgMcnVSL6M55HQJ3d4+QbkyAtZTtRnq9JroP8XUprFSv3IMtH+bUVYncO16cpEHoU/EkgFOApa+NtWATX6wBMZQC5eM0t7rshoEYsGCVZZmYaUg5EBDSpKIMjwBIBOruPgxDa3Z1c/vm9etHTz4SSb2c9wATOVwo3RPUXaMB3G8ElETUo6McRAySExQGF+Fa6+F4UOUISirzPIPArJ0K8Ig+NiHKp9N6gkUI0KRJ0ziOi7dlnlkEgHkws1t4ChOwhxJH2FSXkvJAwziO3liZLTDPNi/eJ2jdMdelLm2Zm5uLCKmCMWyGoeRPnj8v4zgvjTgvtd7c3Lx8/fLjjz9e5nrz9q21mlI+vzi/uDgfhrHkkpIwFMRgAquQcOd1BEQCvr+3TLxqu6nXBEwkiHB2hDVuBgQ1C/ObN+9++9VX/+rf/Ovf/Mdf7W8Px9vZa4hCwWe7XZK8mJG0sRQdBxElYSj5OpqTN9s85FK9eXirC6DullNe2UgV6id4MmuIEyuSgyII0V0eFadtvsdvJ8gVAZJux2vRPTWwHpUChEfSPuokp7aW1zlNrG3iGsKnEmIt8U8QyimO7q1QTuAIMdGKkvIJGe0FcifUREWIzKO1OqbBLSR4nid1JJEKmLexjLWF6PoCYY4gFXFAVcBClAAXocxqFi9fvv7sB4fLy4cejUIDwcIRYO2h/X65glZqm1kSAkypL1micCJS6VeQmOY6z0vtsFqFxepSqkQU8M7n0UnhEd3vXtY3KWMZfCh1zimpClFPXWFmyRNS3wklADdfPAAoZRUW1ZRSNwkkgIn3d/vmPh8XAN2OvaQ0bLImff7Rk8uLs3dXdxSupUTQvMyvXr1gkcNxOhwPWvKDRw/Oz89zySWX1Ls2IVUFK5i8y5/6GjjZAhAFoau/og8msLCQOFxIzGfANXGr7bi/ub5596u/+upf/tm/+vUvfjlXQ2B3vqvzgpBhLGUswzjslAAHqAlS0pxTX3kqvJod0JjmiSimtiiUmDXVnkdFVUX1NEPPUEYIciAcAFFQnLw9WAjKFIjmzu6kHJ1liGDuhh/UgUoVNXfupzOcrKM68NX/9GovENwRsFNDu4oeCAALAwTtvp3E61kRK5p44l9BTGu6FKZ+Vk8g5jonTZr0uL/rEOf5ONS2eDgZhRt1tJMRsTbxYBZJxMQClVXXwCJm/uLtm5evXz958mz2ri90gfaVdzJ6648/NebEBKTTcXXvPaYBiCpFSykdXx1qW1JOtUvCuR/awxHMIUG+KttJZT1ALcihot3psi6plCKqOWVV7ey3sze3EplOzHMQW+tvYNtBGEyBpCnnEmBvHqzLXEEM1pLyZluKChfZ7baXDx4tSxyn43GaB8PZ9uJ4mJT45W+/OXv0OA/l0bMnu81OJCeoUIcJWbMKSxDsVO/yWgr2y9L7olhTWk/DRIArRXhrx8nN5un47u27b7756tdfffWLX/ziu2+/sWpDytvHjzjJfn8Ec8l5GNPZblCmFjWgA2wtByhp4o4FMYEDNGQLX3EmZl/61A/6cLVykhWeQhjCnbqejMJhfCItwiSUCOIwb01AK+cUfoKv0YvdgK92LCeTzT7Jtdox4fTnPmDonvqN3vK9L6Y7ZiQhK95yqvqxPrPrHuTUGTBzrZUCRbNZ3U/HZVqEKTvmu6Oq5KJCWKyWoiXnxNm59Y1JOj3f9+yi4UCAg26vrl69+P5HX/xouNjNx4WDIc7UNSIr0XVSLlFf9hFIay/Ti0yW7llBiCwJbM2ahwugSbyfLLKW+hG0WnVzv4LdpSfIw4RZOTGRppxSGnJJSUvJrTkxh8ObW0Hp8yysSbyGt2YcLZylnxnb1yFZM2fmnBMolVK2m01OBA8onW23xDjs9/vDscFSHrrv8+urN1999/WPzjZf/vBLIYmO1iVlIVbRxKoCgCHSM8zKhZz0XBGMrjKlCAOB3EPhZspR69xs2d9cv3r56le/+uVf/+IXX//26+k4MfnDxxfQrBBKcrYbERSgi7PtkIu1KizN3BkA2VyhzshJhMEq7GQdTMtJvaPR3Ug9wgByMg5pLJJ6Euo3k1bqqjuDcFAEe8Rp5YSzK/sK50bcd67cJ0ZWJf+a+CjWxB+nsF77V6ydJE6M6gkcptPI4Zr+cVIfd17sVDcxGOvR7J0+ai1EOKW0zJM1YyYRHlN2b+GW8mYsJecU5FmLsAQZECLMWD/6enaoKK2Kplqd3l5f39xePzvbUJBHCFik82urKoPeT8SsQHFiZqzn0pN0JC2IA6nIPNeolkXDq7IsDg6EWS+fuq0DVkCXIgRArIDymjc6Hqo5D+Nmqa2UWJaFu4m5NbPcVbCSM7dWffHaIihJMo9woi7bcvegYNnshrOzSwLcTcQ224FZ97eHu9u7OlctosTSiNlLyhcPdg8vL7ZlUB08qAybnt15ZTt4dY+7t0J63+j1AVcLdyFSIiK4Vw6S8P3d3Xw8Xt28+f6bb/7ql3/99a9+e3PzzlrdboekQyqjOZVNQYAHhDMjSklCSCWhAtq8tp5FllrdmwAlq0gKkLuDaCyqnDpQbMzSh2QI7gbWcBNao7azYsGxNm/UvbIRvQHs46Tc658enIDh/cp5D1TSKe8h1iF3WbM99c6cEGtl0zdG/gDVofcQYh87J3pPNHVZwj1qSsEwDxVJKdWl7g/7xJpyKqSJuPVxUEJOWoaUUyKh8G4JEEycWAPe72HnIIhZRbuN1f7mZn97++zjjywMgUSJ+8TxWvmvjS6fph+ZObHo2kitbtOi0gEQqsc6HScQqSazqsrVEIh+SjOtqeIE/rAzsTIHsbv3Y55AENJxGGzrh8OhlBzhtTY0WIpmzrXxqCkVKy7mXpejtcCioqB0nOda3QIppTKMIprK4AE311RK2raI+TDf7g/MPI4bVm3Lsr3cff7xRz/64svLi8ulxSi8PTtjSR7o9qEQD2FlJRICRV8DfWNEuHdfaWdgzRrhJal7bW2ep8Ob1y/+8i/+8hd/9V9evHwdbdEslxdb1aSDRFDRlEksKGfxClVQUICUwCUTObsu0QLOgvA2TSDBsBmziIW7eVEZt6W3KipqquDWD79ZwSg6sVX9ZvJ6EA/fszmE7j3hbkZ9Yoe6gKEL3ZiDhSnWGuaEFyL6TH7fAdY5i/cNMPUXWdvaU+yvRSOYVjeL0+/kBLd0YU4QkSOISFbssh2O+zpXFznfbDSpRDSK9SBDIQLykLvbaU9Ma/PKq9CaCOEr1zWUPBH2h8N3L777wY9/2Ed47j3z8Dccst4XaSBKCHAneBABFg4mSpqJrHn11uHGnjql14n9ZCEWWUXlK3ESfXCWRR0erbl5kGumMg652na7MY9hGNxhYfMyS9I+SjLmkjmJSLNYaiWQiDrV2nxulYlLKsK6WNOlEnF1kPB+noeSbm4PbWlnF1slEaeStl/+4Mu/8/t/9PjxMylbouQ5y7g1p+jnLLKranfuJuZgWTs6jt5uKZMjvDUK9wCHW63KNO1v312//fVvfv2rX/zyN7/+9dvXb5q1JJzyMA4l5aQlBQtrohZZOIvKqGbNqsGr5iFLBKegIKFmZBaBsLD98QBGpNy9kyaaOaXtuGFhFgXxUKRVQ+Jw/A37zR4I8kHJ0nXa3o9bFTeH0ZCFRQPey2+JzueQrcPA0TWQXQ5EIATHOgLZIy66Pvk9EtQFUutnIP5AKBeArDvAqoKgdW0KgShMRFSLh83LfDxOzZtKYQY1c5gyp5SSJLn3p+Ien315A0EiirCOXIl0AIoJSCrLfHzx8vtlXlIqfTDNw1X1dPzFielYC7YQlnSSmdCqCOpFIIOZl7kGXJW8GXMQM6uAqO+Jca+R6jgE+mwohDk8nGheJpHEDGFJOQ/jZuNx2B9ySWwER61VWGnTnZI4M0/uAC0e5EHE1rrTA0EA1Dov+2nJrNvdcHt9vLzczXNdaoy7nbOasYzj82ef/N7f/fnjZz+gNEK0bDdps13Qx7WZIigE1KXzIDKOYGIRCXNzV1CEUUTJ0uZqdW51qvNyd/X2q1999Yu//s8vX726fnc1T9MwpO12Nw55GFIZB02ShsGJSDRlZeGsEkHZZG8NwUymmsZxEGZVkcaaw8zMPMKn44yxU7M2V8OBVWQYRyZKqgEqQ4fm1tGrjmwgKAAnODmditIAwsERmjIFSNngGqSaen2LvvwjhLiFm1lQb2u539NYmzvQyhvRveEIn9DgLoY7oYqrFui9pgwrptQ9j5goWIUQLYj6sVqxzNXNWSTlwsHV5qhNwSXnLLK2Je4qanBejfMgXYLVD2IkFl4N1DwMXIhomuvVu7cfffQJc3J4hAsrVpprXcEnfcRpIIbX49nXvS0clJiAeZpyyq3OZlZKh6KFiFg4LHAyEuqlVRBodUxhsCDczLH2LqkMZbPZNLMuZw9MLazWpimn7oeL6D7bjtSsO+0Hg8OpmR/n2zq7EIvK9dLGYxpKSoeFI87Pd8JkIB0vPv3B53/6f/g/fvHDL6hkEPNGdXOeygBzKGlPnm4sQejWBkHuERFB1oxA1Vt0F4TaIto8H1+9/P7l999//+03333/zdtXr6dl5sD52WYYc06JWERZStKufqUsYy5gMKkqgdxstjbdTMay2Y655Jz0cISotGbCzKQeFuGtSpfNhzvRchBNKakm6sepsxKJ9vHDXo+vkEMQnFndo6fDfi5Tt/YgkpRUOQXAAJP0jN+dJ8AEgvVNPMDdumvVw6zGUit43rlUAoj0BBUQgVnXCFjroxNP0DlsEToNX/UkLiAm1LoKYRmUNSeV5ks/Ck2EhbOsogJPKff2W3vtRiuwyqB++CcRlNVJYKGZOeX97e2rV68ePny82Z4trTJ4xXXuKbs1bDt5TQlE/csR7j8tqTAial2WOicmkr4rdMUYn5RG/VyNdS6i91zMnCVDqGsGalu8tXF7npKmnFPOwzCwNkcBojV3a7WZaKnmy9LMvEWQSK1gEXjcHpfDdCQXDwgwbjbL0trU9NHu+rAMKmmRtEm7i8vf++nv/vN/8T8++fhTJ4RXHfspbJkZLhRufcSHSTrIo91vQeEW5lYS95NAqrfjcnj39t27169++5uvv/3mq3c3t3fv3izLosIlaU46lJI0aUop51QkD6OqaE4sQ0pFEUKcU+4sdxvbdFR398BuMzRVp5iPMyixMouZc7jDvafcIHLzCJ+nZXeWJel6NWOdO1gd0KK7BxERI6AsYHH3rFlV3cwCbBYJRk7CrTVCsGgnqLokJzyYONw6EkpERLKe0njKmb05fi/w4a6Sg5y0n6vkgXk9VIbfT96uYDKBRQiRJIV7nap5s8WIOGlioj56ycIdFZEkwpw0dbsh0HpmmsgqW2HqB83ySl4z+0m1uszTu3dXLWwgV04uwcLw05fjEzi7siGrNyijG2BAkjIJE/M8136IYtmMTNwBYmEWkeBTbwTqU8LdjIU/VM4GQLQszc0pL8XBhM0wIiBLFRI4CEYs87wEdROy2SKsoTF5iNc6TfVuf6iLM0SzLouZTQCstd28ubzYgC2SXj549o/+8Z/89/+n//7p82f7eS6SOe1KKf1MoQgk5SByq+IgeMCp1VaN3BAcEVaXZV6WZVnq9Pbl61dv3rz89puXL16+evnyzdUblYSoQ0nbszPNWWXVuuacSymaUx42nIRyEslJtXgocwSRUESMw1DyMPvUWqXNZshDBKwGqPE6XcnO0tiGXIaUDtOhVvcWNJI3y3mTVJpZtdYva9ewUbwHIIkgqgBEMzOLqlOIg1SJYG5Re2Jn0b4xkDVr1oio15inbN/9intKuycN1jXWq3+GrqjpqvTpob4CHh3kp5MirtMDEU6AOCUVj2hm8zJb9xh1d+nIGxGTJMlZu2dGH204jVaCmdx7ukY/jp7vaQg+MXBuQnp9fbUcpu2480DfQ/riva9Y6AMIK/VXZO69ekRAwUAcDnfNWhKNiFJyt60LcyVu3YvhfTNBRCsQREzNa/dQadZqq2Ee+2jJxjwScz+9M+U0jCNrdfdlmbvVsYWbd/dsEpG743w4ThbRgE1Owkwi1jEKUUPebC+WsD/+u//wf/i//vOf/+Hfz9tUj8uDsuOShSPIJQjuFG5YvHpbjkSIqMt8JGuZCN4Ox+nm+nhz9e5uf3tzdf361es3b97s7+4Ohzuvrdb6cLPZXZynxOOm5JRIRFM6+UyoSMq5aBk4q4iGUuJUFB0Sdlidq6oMZXBrVv1wPJyfXeSkZcisVOfapVeIKCl3beyWiGSC4Xg4imryYSgJYHM3s74d88moqBcXKecT3ykswiAhGTcF0Kkt89yEuQyDuZGv+drcT10tCyeSIFDQmuy7uP/UW59KnNOdJuGVXD1FVLdmWvlEgOWD6tiBoKAQkh4WbubNSioe1hGopAq3zjlwYk2iWbt6AP2cClEiJ+Z1CJk6rRAAM0JIJQklUWTzmOf57ds3lw8fUYBZ3G3VU/VSDpBVu8EgSiyyTqYhhDncVQJBba7LPDMhJQGio07oGl1REDiUHesYxEofOlE/ppH60b8IOGCtuZNHMK9H5KqmzSiiWuvS5hZhdWkA3MGscFRbWm3kJJDtmIc8tBaEttSqJJrkOB2Ph+n5l5/8zh/8/u/+nT8cH+yWxdJ4bqgEJ1/PnwxvAfNlqsvclno87tsyH+dDLMty3M/725u7/fXVzZu3b6+urt9dvTvs92E2lrIZ8mZ7npWGsci4MY5cUs9rojlr1pwBUk2DllI2rAQJYxflAkmkDmqNIjstNJTcat4fD3ZXiWi33Y2bkSepXPuyB1ESBqF5TVkLDcd6MMRgVuvi5uYRiGWpXVy8zi2IirBqQo89hZkz0VJbLnkYxtqsHmpdqqgsbWHm7jysqinl3t1GQLN2K3ly79LXwEkMt24wH7BaHS/pyE+vwIJWCun+3J7uNMvSLYGj61WJ3Cya+2JCosy97lIIk61H3gqraD8lM4kA7H3A1yAi1Mls5hXRAAWcQlSzcHKQpMThzf3N1bvPastD8bBOcPQufGXyQMR9El/Sif9ZN7XeBrWl3u3vAlFUw9HliCs+RAQ4hfS6J/p5EN3iotMzTBbh1cMhzELs4RYNCKYU/WR3sLAkVU+pSvNm3g21OIG4WZ2mKdwlpUQhQ0EIBEYc3YRVpIW9ub6iV+z1sL96cVZKECiEONpcPRZhG3IKW27evbm5eTMdDvU4Tcd9s3Z7fbW/uZnmw7S/nZa6P0yteatVCY8uzkvOSfhsNww5wZum7CU3hiZh1qxJUkqahZlZVFLWMuSBGcEuLKIpEQsEEQnaWn+cEjMQ01QDPJaBk3Dfcd07D2puZm0oIysxuJkDmKclglQV4NZaEMhdVFlYk6r2v60YjJuTkpmZt61up3kO0pzH6/10eHN1qBOBy5ARSDldnF9sNiMxRDl8rY2ZJCI61hSncyd6ob8iPcCKn584B37vrLaW110DEcx8T5n1GikQXZDXt68IIs5d1xBBvcZXJiVNQkrcB7sYTiAWkm5TJUTehVunGrxL2NmsMidhslZv725v7t59NH4cgAi5QfVklPKeAeSI6AMxvBpUOKkKE7daj4cjWbBISureiBD9jLq+/td9OxAI7zLD7gzK4Qj3xRYAqtrM0DVzBOKT31h4l2KyEwW7hQe1FqLaWpuWZVkser7NGgThaNYiTAS1mTjRgru4pbf+i7/+6vf/6M1u95AERTIXaW2/HA7LMgF28+71119/9d233yyH/d1xf331tk3Lzd27i4vz3Tj0+nB3MYhkd3ht1tq2lJKzCOo8a845axnKUDKENBcFiyShbjAvyilllSREQd0FvPPkK/PeXVaFiHPKyjItSw0bctpsd4fDEaCSSycHzT0ntVqd69QaAarZzEHzMG6aOQVyyiExljHllFWJRJipD3ISpZQCVFslUUd88+23LPrw4WO3dqjz4TCFG+1VmTdnG+U0jIWYsyZRqc28uZn3Nq43eX0+9IR1xirIXuN+BTzXPmTNjiqn3/O9WII4iRAovEWEmSWWZhbwIaWclBEWxMpJJKnmrCqUVTvE2QPOqXM4EgIgST9Wt0Og/QQvYQ0KtMTCXvfXr493N3j8jFS4z/GtdqvEsbJp/TukFRI4IVu99PPWjtNBe+VNK9TTY73XnQ5fY/kEG3cyNYQ43BDevPOanZmRHhfezN0sel/Sr3mXGy1LA/PS2rTMy9I8XISDSKWfMRO1NRA5SFRJhJnr3K7e3vynv/jLs135y48/2WyGTz76+PmzjxWx22204vZw9+bV6+t3V8f9/u76+vWr18t8dGu1zp/9+MeffvxkHIoIs6iHdIec4+EIYNofiGhI4m5JldMYmtJQuoZdVrF8MEs3YxLqk3Ak1A+zBQv3o6U6p7LZbKZ5au5ENKRk3t5dXfV+MZVUF1i4KFu1xSuCkqYyjgjUpXITYhmGDYPKMGhSZU1Je3fZvIWBGL256p5q42Z0s3mp4VSGI5xgSJI45ZRSKfnywUVJZbvdDTkHqLXG3J1duNu9nSwCevFzAjeAU3OM+wjvdX8fBDyJbFabyn7IEBORdHIx5mXBiVtWlpxS6tKegHSnqJxUVCRRd6aFd00MnRoe9ghGgLyPxHHqJ40oMbpTIZOEt3mabu/qMuVhE0HSDyhRxr133UnUlMy9n1mkzOROIUxsZstxOj/bhre1kYneIHVjMCaQMDv62cXh7twLU5CvRyCuWglzY1Dvm7qKISLC4SDzbrNr1lqAPDDX1f9DFH0AV5hYqR4XQpgZrfNonLI2ASNurr77s/9t/5/HMxklBZ4+/+SLz37w6eMnn3/5ycOHT588fVzr7XS8Od999OzZ46uXr+/m4+Vm/OGPvrzYjJwoEM2C+qAqeBhL1rzd7fbHfV2Uw3PJnMae6E+lJyMEIBCr6nraF0DUj750EJMQhNyt874UTKDWLKmOZXSzaa6lpCyJiJQwllKn5ThPtVWVnLe5aDlimdrSx7WGYZNLLmVIKt7cmpvV1jzCzax3XyrCIqXks/OLnPOD84vDtLx5/QpIDx9dDmXIQ9kM43a7yTkHsNkMRLy0mrKkMbdqy1yX2m1BCfCT1XMw9YqvpzECQU7oS68pVgn8qvWk91PD/QgS4e6nvEwzCOTRW1wVYo5Wm67TqNLV0dzPmrifyqB1nFg5iE7enySrxI07oA/AGCyiDIrm12/fohnSaqDhIMQq2+STf5cSpw4oU0A6ZIhgodaWlLTZMiR1N+qS0xN6GuGStLVVPtFVhIz7ESDqua3Tir2+6j6AvWkKD0f06e5mZk6dhFlsaa0tzR2r1ykrg6hNFW4IJAGTqObz3WY7bEqS7Ya3hevh7nh35+53Nzf8n/7T559+8rd/8tNf/eL8d//uH/zez372xWd/+uqL3/7Zv/03T548Pv/DP5gOh1evvrs+3ILs/PI8cWZxFm2GXMq0zFnzoInH4Xjcm1kSUR1UJSclorWlMXN3YhIJZhKRoOjaIQSxUpAbvIUZzNybG4i8eRCBY56WIQ8ivFjzFpoTgvZtJvhu3DBLF3tuynYfB3i0aq3aWEYRcY/jMrXqzaqAsWY9ELMDUauIHOdp3GyfPnuSrm9JZbPZnp2dl5I1pSSaSgZ1RFvDu4BFMsksC0DWZSBrE3zi+jvP2SuuTpj16Ov/PSlGAyAPZiYRRwitqa9WI9Bcl2pGEUPOOWsWZQmYIZwosqSSiop0IqBjNkFYI6/DvxGdZBDuD0AHSVdCoIPyZmUYm8fd/nhzc/t4s1XqdtwKAkg6fdURpyBKotJJXRENso5p0VpdEgnasogy4P0AjA7mrF6ofb5uBcJO9ORJVdn1xau9f//HSrEDThHRT3my1oi1eWugOaJGZVEzz4mZEGYE47BBZRiGkvPZMJ6fbx9e7J482OSib69u7w633CCSw1o9Hn55d7gcz5cH8+v/6f+xOxv/5J/8ycMnf3ex6lGTUxnyPE9v311f4TgbLs924ziAwP3AZVYS5ZIkkHIJIibJRTNLzrIig3FCEk46ujhVvdzHKEkD1E9yb82XNjcLi1ZK3t8d3rVrRjw627nBm90djrUuLLwdN8OwQWKr4YhpqWUQYl6aNzuWzaaUgZQjYj8fujCFhHJKOaWUEhH39hVMSnK5O0+aPGgYx5QLaz9PNXc/RnEEk6FGRBfUBcVaZoMYjO5ycCpp6P3x131+ntdvzGtHfIJDV2S1V8TUG5SAmcOxLK2Z5cSppCGnrGJWnbwfB5VUhSnnpNSPjGJ0yAfUFYCIbvWDVS3HvA7L8IeaIwGJexDk9vru9mb/4An6CKfIyhmC7jUMQkAilhDi7oPXkSkVZa3NLncblQgmj4bAepwOi6F7ZXSrl577O1F97x4FAQkgzL5enD4/4O7WM0qgG8O3YJ7r0iymVhcOY2bvvJ7AAI8iMg45l/zg4vwHn3/8g48/eXh+seWWvDnnV5vX+3lngcNil5vy5urtt9++UrRU4v/zv/y/L59cfPHZx8+ePP3oo+d3dzfvrt/MS63mXNJizh52ezh3z5qWpZq5he02SRRjGWJZwoyI4MhDUtUTDUohLtIdw7sLQp/9ZoDBSiQGt94LwaqZtapKu7Pdze1tmw3h+TiJqBG1sCDa6JDyEELWLbmNwqxxUynuhxY2TdNmt6Emq22b8DCUXjSv+ZSFiCy81laGIeekLeWciCggWdMwDH2qzCxaLM3sdKKUinAA5m7mHgaK7gBzLxvu2az/FwRh6XvIqQpiJpZ1N1ivEDMhHAEPA8fxeKx1ScpZtdMgSuQNtTYidNlI919d6yom5z5FA+qWSV1vzRInzcIaWZ0RYLAyHEAERTXXHG+urp4v9WxTqndJ3HsVN50IrNRq40FX0yuPnDQQS11ODICDoi5LB8bQiyh0X/hVXbgKxVcehE6nja1i8sTiYcwCxzreEWHWZ2oQTK15bW2u0atd88gOJrJo1Ii8bcby+NGjIQ0//sknv/PDH3z69OmgOk8Hbm2J1tq4GaQ2DNoebHdJytV+Pi7twfbJ2YNH/+HP/+P//Oz/9af/7E8vHz+4ubuph9bCdhfbs3a51DaknIkYEEZRXuZlmY6JYjM+yLnwZnRrrVmIg6j3WUzMJBraW6IVle7fmEWEQXBmCzJH/zrepbOay4Y1l9p8f1zi3f7y8gKUtucXYR7w2WYiEdUIqFC4WZU+5uVMU23H2jhloV56UcpJk2pSYvI+M77ON3OEz7Vas/BotZHqoKXv0mZobnWZV3cLkhNv07Ua3ROHRLVD+Pcb+onmOuX6DnX1BpnXRMC0Ao3K6uxwj2osxNbadPRWOWsexjKkTUlhbQ73tqgKgZmRcgJRSklFwcS+juqEhwhb7c0wRFjoXnSA9Yj67qfLRMwAJ+VW6/W7t/u7/W53QeHcVVIqa+1EYAgLJUJEsHaPE7iCg7C0CiL3EI5AWG2sqwqFyJlJSBrWQZ7gDs/c0+m9V1gnTYlIRDt2EB4e4T30QcEckMVsbjY3AyEiElPJyWoLDzHfDeV8LB9dXHz2+fMfPHv2/Oz8Iucx5ScpNZuujse7XbG7dlxmzcELbTfy088/juVwff394932xdt3/9P/8//+yaf/P7r+tEm6JUkPw3yJOCcza3m3u3f3oGfrngUzAAmCAEGKAmGSyQjKZIL0UR+kHyvRJJOMJhlpAAYzjV5u913fraoy85yI8EUfPOJkvnca1TPvrSWrMvMcD/fH3R9//PP/9n/zLw/7vTG20g7T/uWzV6flbKozAKmgQwgsS2u1NnSapoxmpdRaqzaXLMkTpxSxNgY7XMyCAbZxCwHVTRwbUAUQQAciIgXwpkQ07/brUgBIDUszTml3c6sGSz3VZQV1F8lEIA4QU2PIKZWyKlipFYgmHqNLhBAKA+iISsKIgkzmhs7H4/G8lKWsrcq0O0gTREbFJk001hEOdo+ZBY3R3W2w/d0RkXq5vdP+t5IoXPnRzROP0V/nWHxPVFszMBBfl1JaddOZ8jzlm/0ugmmIVcbDp2lCwJwSE4WmAyGYWJiVdTWHXpjCq+gTidmFfASQmcSxNX04Ho/H0xcIgiim5kpIXT7Mw29RIua+icKcicI4AWI6qU//NHNCQQ95CUI0B0UwB0E06tXi3lsAB3RiSgndCWOfjDmougEbqKorICC7ey8+t4qiCWBHVMVcWzYC1Cnj5y/ufvT5x3/w+Rcfv3rx4v7u7jDvGGe2RE5AeTfn+UClzXfY3j89HM9Q9JOXH//ib37Tll/up+RNvvzVV99++VWr7bDf7w6T6MoTHmhWaHUxUIvamqlJa60prVXaCnCTMicmJFBrtfHsU0hnBVPAwNW103bRtQusITmhOqomsSbhtMhMmyq47/a7ZZn3ao5eypo9zzrtMrvNmDwoOyAG5gykpgieHbKDN5F1TQAVbJonnmemFOVGA0cDdQEAQk6JRawsy3FZQ/EhePHSGiBFzzIIarGrIkBGUOeDZ4DDxMOnUkjcUgf94NipAEDdOtHAQQGZkFPCSAI0xsrovJ6Ox1MpNaeUp7ybc2YEsdaqaS9e7eddmnJOOWWGXm9S22byY1SnG5iPFzHy8JFrdpq+u4MRsZm2Wk/LYkBIfQCaiLa5BkRygBR43dzMGlMGQhOgxLvd3tWB4qyQqREY4sRgkNirYqg8uyE6EzhQ1AA8eoiAgIxgCChWxTz0KU1A1RRZwYvZuZW194HbROxqqAbNTOvtfvr041d/+Rc/+6Of/ujV7f3dbrrJ85yRzZpWkbqUciq1tFJN1vVcrWXyu89etJJ3u8lc1Olmv3s4Hk9tPZ/eT/P++f3zpjUjpt201AU1y9JjXbMo7YhoXZayb40J8pymmtZFTKXVOk2ZKBEAAtnokFrQqcFjwIIc0T225iIiESbm1pqpIiAT39zsg9pQS3W3BQhvDxMx5qmBqxpJZH9ABmIK6EggKk0arDBnJE/7FMwAEXewYKMAAmBmIjKpy7LU1sCRUi/uiQohm6lF1Q9wzPAigBu4uYxiP17ST4RR2wzluDgcaEAaebN3/g8ghDgmIqpbbQ0RVXQ9l3Up4DBNeZcyIyJS0xLkF2QEhJTSlNI055gfiOLiNt4QY1gxuQu95OOwITDo5dBIVgiBCZobIZjL6fxU6jlNMzldCT+OIwDh1N3B0BzELRkC2c3+bt7tz+enw5wQOfPUrJkIJedeEnIEcxdmAjemPo0KROKg4GIoZs1M3c3YTMxQzJuKA5qINFmX87qcl2XRVgm5rIUArFlmf353+6OXL3725z//sz/72ctnt7fzfs9I1iZ0bQ2Fz4ueT8tSGxShUthsckzzPDNhTve3+2Ztd7vPekg7tFaXp9Ocp/3NTX7gXZ4g0S7P51Vj1y04SFNVUTURLWWtdc05p8T7/V5qU7Pa2iyaODMR5litiaYa5Z9QB4msTVXNNSbMIdY7heqoAyDM826aK0rka1rKmQluDoc05ylRqVUBGBjMiUAWzZwqSkgPiGhK3CGveRMdamwIiMTxLN5aW2sxcyIOCCOiPKGouAc/a6OxdeQaG1is91sRrE+DDm0gAIzBMY81kSFc0Ct/HSqguoK5KZt7BFRtIq0Cwv4w73Zz2rGbiNXS6lqrgyVOOWdKNE0pMSVCJkLoQ23dqHuOieDBhIIr24eAQ0jkpk4emDQcssn69Pj9w8PrVx99AajIUwDwHkLciDC5q0swmVFNMOQ5bg553j+9f7CJDHiadrKGIiw5eWAoB0+cVAUSGYiqKZjGmmRHdTcFV+yKs+oI2V3U0dRV4bQs52Vdz6WWmgl2U35cyoS0S/Dxi2d/+MVnf/mzP/nJH/3Bzf5ml+l+l0wqJzB1UXuqy3ktp2bROVZxqzbl6Xxe17VS5iknUgTzOc/Ad0a4Vmmt3t3efwOAjGme0zQxri149Wq1NRGNPseyltPxdHNzkxJnzpy4LisWX5mJcLfbB2fLyF23iVA0B1NTtSaiGjVrYiJCyCn5NLVSYxx1zhOCTHlalrOonZeFCO+fPZ8mN0IHR3ViNCJskgAz71RdLQZWc7B/1F1FolwGTMxRp8LapNQmopwSMZt70wo0gYQnDatCHyWtKLDrhdfeOYlRBXXwYDZ3YANufYNrxxpI3lkSaG5eVBKzgXvfuaeIcJjm/WG3281TntyhFi1rKWvJnPKUKVFOac6ZsAsljd3bQ6mSEB3NoOPPmATrQYniZBC6UyjSuaoApZSwapNW3z2+ef7RR+wZEAxjiqLn9+aQEMliyRhSXIg5JzDeH27mm1t154SunnmuuipYFFIJcE65toqcqWdRoVhopobOCbi5ECYABhQPETRILsUdWqkm0k6rlTITgZrVdkPpdpde3Nz8Z//w53/xZ3/82ccfz4cb07pjyJPnPKmKWltFylrXta7ruqyrqkkTJI48TlS8LUEs68sVyb3V09Pp2bPd7f5VymRgKdNhns+EBlZaU21VtEozd2m2Un14eHSz3X6HTImTGyxSHbpyaJ4mjxUh4Graxbjda2tNVN0FzDFEbAicclZ3iK1qhJinIOGC+35dVzUptS3n5dnd7Yvb+xOluq5MDKXtJneiLPZUzqVIAs6YGBmRwQExdmvxnHNKycxEdVlXbWrmGSl0mtAAUfvIX9SqEC26VhERYsjMqfeHIJhNvbIFg0sMY580ArkDOiL3BlRTiROA5u5qfemeaavaWsppN2UmIHBkOp6PTeqxrXucnk33sceAmAAcySPWAKE7Bc/NKIhz7mgIGIrZvQHfy6YW5FQiFDU3o5RALSHVsh4fH6Q1SJicewrf61WECMlMQgBtLI6lEAy8u71f1tP54QkacMpsmmEqIm5ObkyoCIk50G9icuNO/vBY14AIgIxuIemhUUkT93U9r+u6nNbWKjiyqJih6vPD/tXd7T//J//or/7qz1599GICMjOkNE+JAdTBxKvIWuV4Pj+V5eF8bu6ltWZjrg/BxMxkLYspiDQinQ9za+14Wsp6ZuJE7AA55Zu7u7dv3jmAmUptpqqDCuZuInJaFnXPOQN0KnutNS3nnFNKOR5mam6uqh4Vz5CfBQPTcVMAEJlSSp4yJ2UXmKeJWKW2eZfNVBtq1Qd5dLePXr26u71dU3KFUqsTiaoBZM7zzZzyZA6tqTTb5zkfMiGKW7PI4FspbVmWCEfNzVSjmgMiQJjS5N7X+XTAZmaGnaILvc0V1AO34WB7rcUMEc0ZEwIaozZzkYsxuYtoWVdGEtMpcZUqrZlbZk6EiYiR17o8PR07TuC03x/miTmlzhPoNGoEjZlnVARFUHRzQQdgZGRmImYCxhhzxRhGJwjtvuCeuYqZmZxOT8tyfP78lYVu5xjaDHCV3AzIQrsFiVSVjU18f397X18+PZya1P00MU2QQB2qri7qAG5kFrtGmpoRYeYMQGawyipNETKaa9OyFq0NCaytspxkLcvxuC4lxaKkxG56fzP/9Eef/8Of/elf/tnPP/3k5c3uAFpFlEAQwMVU27osa1nPy6nV0uratJWmVao61KqA8bpARcxgXUtT3R/IWnJxWc7nYwarxCim+0POzK9385k41obWWolJWpunjIiuVks1t53NKaXEqZWmrqW1uSrdUJVqZgYqquIK5qrStHWr6pkpBmZlAgXImJxm4UZ5hyQAyIAEaS2LxB6RWtV0v9sDUilCacfemjUD3+13ecqxnBMIRGFdmnjLnFJKIiKqsSukrJUSISfTWPZCRAEdONhssecvBjPcAZ3sUr6OCbFLdTe6P50FB8CEQdyPCk3ojrTaAL20Zqqu1lzdVVATY0ppanDYz1POhFSlrmsxMylrYp6mKU2cpslDehLRiSEldicFaOomLhKgw62LMiIgB2nZOwfEOjV6rChDjE4cAbRayvl4Pr5/9fJVaY1SBo/tHb3QlYiw09tCQtpdzB10Snm33+cpr7XUWhDAHCiRGzrEjJl2NTgHAsTEJu5kwKzuTZUQXHxZ1mUphLiWej4eQRXNQJUdwTUl2Kf00csXf/5nf/aXf/ann3/+6Yvb3e2coVVtNRO7QLOqolKl1Ho+L02amBapWlrTWkVNwNFba+YY47MpMRAxQua8383Pn905eFlrKXWitNYlU9rfHu5u7h7T+ymnlrm1Zm5BqYQug2xhVciUUz7jEs6+qQAG91lMowrkKhrLl6JOl5DcnNNADmOCNSV2V8yQCBEmMUszgtsCBEiGeDwuiGwATeVw2JeaiLgpmLsBgQByQgBpFoPkjW2eoIqqtlKbizmiGnLiWBmDhEQJmK3PAZuoAKDHqhlAjBqu986e9XdwIb2DD3VBMjcgADVwg5QSA4pJrW2pq9RGDjkxE1LKN/v59mbPiUztvK4uVk1KWcUVHIlTnlL4GgBgTpyYEZlwyrmZsSo0UFWVpqKmGglHKIEidBEG6ryJ8RHUbHBpau45ZwRfSzmeHkUq0hQsDXIEADVAjBVJ0cZDMnQncvNWNRHv5t3LVx+/a7acj4lB1KechZpAa6KEBDzHLnYxISAk00WlSfKkZMxpLcXBEvpa1vP5vCyn4/FMiIyOE97tbu9vDz/58Wd/8rM/+vGPf/zpi5fP7m5f3d9bXc7tUW1xz7HDtjWtpS3LupZamjR1NYcE0NxUtbmBE5JIyymbQ57SQXeOeHd/8+KjZ7f3925tWde3b77P01Tfry4y7ejZs9vX07S2hAZIqM2nxBANuXA65mBArTGmYJME7DYFN3N1UY2yT6k11iaYSeyDICZABDN1J8fMyZMjiDmZGAEYKqGJSYwOi2M512YnAULEnDMnzkDqIFXdVMTUdIKJiZqpC7qpqxOySFtLdQei1M+uogNCIkAuYgxIBtGnVwVC1F6k6mTmMAMDj9w9ZgcppKItmhMCYlPKHhw1tFpEizRppvp0OoFaYry7eT7P6eZ2/+xuH0t3wDzvptPTcVmXJoLuc0ow5XmaDzc3TAmIPIbgp0xumLLV6gHFQ9HBDLtAMKaUmWM+CzsbG7yTtwdzG5HF1MRyYjU/H5fj09NyPu7vXpppZzc7oiIzp2AI9YBgEG891pthSofbu3J7VK21nDixghJhyCkBJzCniaGBNBXWUuR0Kg7QRAB4PdVa6npcy7os6/r0+KgqXhvN/OLm5sWL5z/58U+++NGnn3z06vbu8OLF8+w6JSA1qZIpu0+ttVaqG6joWqtI12RnZkRGDvoRulszcYpWbOxeQ8g4z7v7+/0Xn3328tktuL97/47m6dWz5wh0PD/N08397d3uMJ8XbiK7XXZtEU/7mB6CuYICLE6cUpqULLhnaraWUlpTE3WrtUYxCQZhnhC5EyTNpLkaO3AwJjiTrrUXVoDmzDMq8vvv3717eEw8fffmdHOz3+/nm8M+U2xAUnN/Op0ZSRLMc2pNSisgToycVjfjlICoFlETVVjKkYjzbpenDA7QdJ5mDBlRBUNoojY2BakIgPe8DgkT9e4Shz6JiTRpBmCqzbxVgSqqpZXj0qTtYmVlhsnx5YuXh33a73JKTO4KouYzc01pmng3ZyRMOU0pTdM05YkIKScmcuZIARxQm6poq9oDqgM6TNM0TYlT6gX30a2jIU+KEHUhBzA0MNNoHLTWHh6eSiuTCmMSMyCOvMXMEgCoDcXRPulDmJO5S5PdlA53d69ffyfmIIrsaIhAzZzMAGktqxvm3Syludq0m87n8/F4PD2d1nU9PpxaXdFd1VQauH366v7Zs2c//5M//emf/PGz5892edrvdoebWU2ylZtpymiOmlN2T0stUszc19pq8DnVzAmZUp6sVgPQwZQV8ZS5qklfd8e7w+72/v7Zy2e0nx6eHszb8fFxz8wE775/PaX5xd1HOXFCJoJpmrRJrRUJCUIlODjAqogIdjgcmujNfj/PWbWuZW21AaK01re2mEaJjYM8Gc0xCWFLUdCipbMHGKaUQDBzQuTTUmtbH87Hp/Oi5Zhyfjg+5Xm6uTnMmU2tlKZma6mMlHLOOalobWLSYj4YmfI0MZM5lFJqa7U2AyTm3e7AiYko8ZpzIqRopap5E0GHxIkQAFxUMZYdGhKhOVgR6NfWqmhrVVRabbVKqWIAVpQI8o73aUaGfcJ5j/tdSjOhGaInROaUMUGiaR+r6i0x5ymnlBCImQDYCdSgSWVAw3KqxdUMMebKKTMh7W92iRkQTTs0A8M+fBMsZAj2PcW4cc6TmiMjAp6Op7KUw6EaAQDj6F24Q3KHUZLb9mwbYkyryO5wuLlVQ9Jm+9tJRNRgt9+ttVUp6OyY0gy11aWU01Levn3fWu+bns7L6Xx0lx3xYUp3z199/vknf/zHf/LxJx89f/HiMM+EnNDmmVwKqGY2lypu2sQjlW2mAs1jLRkaEGJCBlBgVmIWBRWT0GVXrQpi1Ynub+9Ay6vnL+4Ph5/+5MdsLE1yZmn1eDoZQyu1LqvvfX84OL5JOVstKaUqFZCCG4OOxKhmU+aU8m6/2xEd9ntEPB7P61ocwNXcnZBCyxcAiICsy/qpBd0MAAnMZp7NTUABSKyZE0Jqzd8/Hn/zzVdff/26iickaMLMuKzvjkcUM4MiVQXMzcVvDrvdLkf7lQG1VkcHTHlKCOhIZrKU2mozc8qsbx4inE9pAsScMhMRJ2LKOdayR4/fOSUXUxISRkSR5gCttdiLW1WkttpqaVFwcmQENQaYSnr5LL346P7AsM80JZgIKPcV8cAUKpREoGNwGwBj76iLuUXxDWLasSwVFObdDok0ntudGKPmSkgpIyKZgYqpAESx24wgEmlQc0JUd4JQf/Fc63fff/fsxUcECkSds2fuRGnkOYBdI9ZjIs49CKCa8/727u4MtqytmeqyzjMmznVp6ZCxlvdvzt9+8/Xvvvv26999427SDBDmOd3f3f2DLz7+6PnzLz79fJ7Sy1cvf/TZZ7f3dyknJppy0qbulczQXUknRNdWrElrrch5XYJB3tSbi0iwzBGACIE5q4EjGfZhROYMACRkiYD88NH9/vnuxafP716++P7d95HXqer5dOKZmXk9n+rdenM4zHPeTXNZVwSY8xSSUpk5TRnMc6a7m/vb29ubmwNicpPjsqzrGsQ+MEMiFx1cceAgnAA4gMY8BwE6GRASuBEQMhDDjrMva/3m3eu/++WX3337bqkKwDlPSEhMhmCxOlmsFNXmCKAAdK6mvrvZ7eZJrWns7wRzUyKOpfaYs4spqIiauqmjQy0STVNmjg2qREyEhMgEmDCnzIkjJXD3oIWIBJzWmGrXUL9xUAMAC5kaMJumdL+/2SUjVBMR0AyZGPtf73RZoEQaRScEMlBQUGdmRmbmTJQSt1aned7Nc045Tfnx+KjqOacoW5lpSpmZQxZjntlVm4spR3NOVBOTO2oSGzy+dV0f3r9XbcAJrO9bAgdCSIjortHb7hULREQiQGSKUurL5y+slm+//+7x4dFNEzWpyvOUwR4fj3/3t3/7u999I6K1WimNVIl9R+mLjz76Z//5f/4Xf/7z589fJMaY6orpfTcl8URJm5kWUycATuBNoilbSjkvp/PaQ3mMO6m5umvvAMY4P2XOObGBIZGb7w+Hp6d13k1Tnl/c33706pNpmuvp5F5N8qKtIqWW9/P08Pi4z69v5sNhf3ecT8y5eJnmvKhMiedpcgdnP9zuXzy/u729Syk31fNZT8djLbWsKzgkTuDeibSEFDxx61VFM1Mfiv0Kim4NeN5NKa+tPi3rN2/e/fLXX33/3fviZpQIGTIHn2xiEncp1QDUQQEYyMGKuha5uc0575gm5txEunIxEjqa+X6aiPOyFmnNTdwMiPvkBqGpARgCEQMImCoG34sIxtgj9B6x9/15IQJnQMRIYO6dkUzex7QZd7vM3lQWMzstlRAP+/28nzKimDWtpaxOxJRDhkfdmTgRJcoxChykETU2kyYS9SQiipOXiNUkpYmYgoXOiTtVL1qvYG6WmB0BsHlwNhVba5j56elpWc/300Et9pkLeQLYliNFa2TstwkZvjxNDo4JX3z6sYL+9tuvT+vx2WH/6vmntZXleP63//ZvfvPLL7/5/vvz8XyzO0xMM/FhmqbEf/EXf/6v/tX/6p/843/86vmzpp39oSqmqi0me4URyVmdq1azWsVFpGk1xXNdH8tSTaoqIHTqKJiqNBEDFGuOnhLnaedIYQGAOOXd7nB3d7u7vb2d5/SbL//u28ff7GyXd/NDPXNiCp2Z2xsiep/ff/bF7bP7+6fjw+3t2kph9rvbOyWD5s3k+cv7zz75bJ6nnCap9XQ+v3/3/nw6t9ZcTUQheTT7EiIwagt9UwKiTlgkVrNqKuJ5yjiRqD0dH16/f/fLL7/6+tu3pYh5X9bkKTsmj+7BmB6nRIAMIAqO0AeNHEgdAQh3MwmroyNGETwncuJELZkt62IOOc1Afb11kCc3JnNkkTHeiW5RP4iJ/g6z1Xoxx9HBJCaEYVCpMfq/xggG1mpTLdmcTHjOYIYOEGDSyMzaWpnFHTjxNE9znlJCBkJ0kebuDJ7yxFPilNQaI97d3C7rIiJEkFIGQEICJlWLgTsCcEJwBXc15USAlHMyhCaG4rvdhMS1ltPDw+3dS+QEfbGLm3WGc4j+YA9VbmpABhR5vMG827148fEf/vSPExO4ZM5Py3GR+jd/+8vvf/ft7mafmJey+pQ///j+pz/+g3/+L/6Lv/jzv3zx7HCzm02KS5OySlvdIaeJQ6zLGBzQkS06lqAqMV8vQqVEgVPcY42MBelgtbrU0qSV0rpCBWYmDOKyA0xMh/3u2Yvb+/sXkM25llUe28lOT8G7SgmBAJ7AHJjyze3DlOf9ze1a6v62lbqmKe0SPenTfp5ePXt+e7gxUhU7Lcv7dw/LeTWNzrGgkWFlzHNmZjLTkHiy0IYBI2RgJtwTUMpcW11O53dPT9+8+f5Xv/jyaVlMGRMAp5lSzoTIOSH3pcXBWCdZKzNr02Gy5EScc55nQxNrlLOZAxE7EhMjuYOQ5jwxJwJTN1Z0IjDXUS53BwB1dwSkoDcjAUIQ+frUKwJRGhtiokk8hv4A3KLTTw5Ym5zKugOQosjICAlxmieecso7aCbZd/s9YQtSUUr5cLPbpyklAnUwEFcRMQNIypRdm0lrrZoamWttduGjOlBiYNUwHJvyvtZWW21VIusN7kczVbWUGYik1Kfj8bPIcqNZ5ujuiaDzqKEXROMVooI5oDZBwCqSUv7kix85+G9/86vf/Pab16+/taqJiRMk97vb28Ph8LMf//Sf/ov/4h/947/+7Pn9lLJLIfZpSu410qJeVnEgJAPrsloICckwhs1bbSIK4iaATskxVJBA1ZpKbVpKrVJLFUBHIkRMKSMhIWGi/eFw/+zu7nA43MxibeZ5PUstpbVGmHhKN/sDZ36q5fFUqtL9q88yZ07T7d3tPOVv33wNAjlNL5+/Srv55v4u5anUpZb17et3T0+Pqh6+v5aKRNlzzjRNM6CbKFOmlLyBRbEqTZQzQjKAh8fjd2++++qb73/z5e+ens5u4MyQ2JkTEnMO4YXYhkchGAquhpCBqm4uOzYbmCiAzSkxUgxhBJUAAQmpmSEzTpamqZRCsefYlYn6AG2fAx7Kxl3exnybh8E+mm8W21NwG42MAQjCviUxKDpNVcHUYZGSpmneTff3d7f7m928T3lqalOZ5zY30eDTQaiPuKY+x9KXkNdSlrbUlESl1NKaxDqLWoqY5inP05xy4kSJ04ESAJhJnvemh8fHh6OeVLWotKpIqIAi6o4J83Fdl6W0prs9qbqBATgBJujnuo/ToEWSGXOhhkiJUkgdTLR7fv/Rl/mrx9PT0+Pjt99+//hwIprvP3r1Jz/+6T/7b/7JP/sX/82nL15NrtlsPZ4q28zcmoKqC5BAqIJ1mEVUiriBiJgZQDYsTmxQkHJnOjkAAxGFNNBS23peahW1mJhzTpwogRMaI+Ge5pkPE+4ceF3bWsppXUvTWmRtorrimcoqh8NhkbqU8u60GKSPP/q81UJGu/3+MN2+O78Fx/vb2xfPX7rDWuvD49P7N49v37xrKm1pOTNzBhBpCqCzIWIGxCa1NHOjZq5OANQwgXhry+t3775+/f2vfvXlmzfvllM14jTxbjcrJkdCcyBKGDwXTMQx2pfAkiIycWZiDlGmUCUqWg90wMQTZ1cdSz5jYgSUkMHEDdAJyFQQMPpJHfbEMDcgxFBHEN76/oioJkKXOyQY7CDopXYHIHNkY4pWjDIubosqqGLC27vD/WG/3+8Oh/2cdznNas5UmKglBffWJCjZ7rouDQVaqaVqrTU6kJSw1koISJjT5ACaUna+2d/kKSMjYAR8nyZ2m50x5SmXnFuGClYaGHDmMafhy1pE7XRciJKKAwJzNnVETLa9tY0OEgOTY9TACVUtxp/yIf/kx38wA/0/3r/75pvvy9Pjx598+p/97C/+T//nf/MX//jPpjSx8AwuT8dm9S5NmRNKE2QEF3GpKiaUkhmqiKMLmCEZoAMQZ3J0zi6AnNPsZIAqblTkXKSVdT3XpYpFBzDm0SUYhAkTZ0rZwauKV/DWTuV0Op6Xpbp5baoK4u28Pr5595Rycubz+uT026e13e13+4kmStNuOhxuns7Hnc2hPLCW+s3X3719/W5ZioODQmk0ZUdMyATMAljV1G0thrRLc867ZADLup6Ox8fj8fXrd7/55nfv3j4dz6uIAybilDObJ4/IRaGmQsidPx2kUXduKmCeEJko5qcMFMBbaVob7w/EiEhqAtAVKgGMDTMSTnlFaq5IYGJD5q0PEsYw2SZv6+NoRILgQyt/WD1uM+i96RTbWUIYR7W10so6ET1/9uz+7i5PPB92h8MucU7MbpiJnlTZtBSBshIjM6uYiqxLWZe1iaoZE+acppRu51uIWJPIzNDVAZhjOaVHBARA4JmJmzRFy5ymPJXSaq3EnDgBOSIbUKtCnM3ATDO7mmPKqOBuKbpfPT/yAQ5DKLfLsyNE1i9+c3N3PD69fPWKMSPa/bMX/+K//C//j//m3/z5X/zJPrGc2j67uU5smpnJsZyLCKlZbVJLLYtjrIGIyUwFNyR3gtAQmna7nZuQUs57mI9rs1KWc1mlLev5XJemqip5zujkROCEiubExiKwrnau6+OpOKm6LcuK4ERMDiGALM1rKW/evwOmabdP0ySAx6U9vz188dHzF3Tb1kpM9/MdYF5bLWt9eHz83dffno5nUyPilOeJqJjOKR9ubxGTgy5VEtHhcFNFm1hrp/Na3x+fXr97++Wvv3o4Pp1P1RGIpjSZQdCCg7ai7IliAQbFxgFmjqkpMtXEhkJAyIyxTDEguISkvzli5uQxnqSkjurqTIhzBpGUGQnMnIaiw9UsrVOfZIXrwHA97Ds+egYQszFuDgiKiqESpiDruhzfr6fdyxf3z26fEwEjTTyRk6uL1ai9ToRq+vjw7nw8AgAzA0HoIADALpFjYoJp6KMDQBNpUps0VUdGMyUNka7eEwA3MXs6LUhMzA5eWz2v6zxNu90+58QZT+dKlBLz3d0tc0Kk0HOIka7Ul6T3ylePo51pZ9vWIzIMTYf0yWefgbc/+OKzXz6/+fzl5/+3/+v/5c//6q+8VRSjZNUKSjNd5oxWa6tSl+Jey1mX81K14DRNlmmeCQnVkDT6bn1CnxCYEGzOWRW5qLb6tB4fHt8dl3OtIq1xyl2mBhmBBJEIFZEQqmktrUh19CJVAdZW1vNS1rW0VkurUpelPD2dRBwSPnv+bH97k3M+7Ojnf/gPfv7HfxiknP3hoGt9/ebdw9Pj+/dP5nz77AUxI9I07URq5nQ4HDhlR3BVUX08PT0en56eTo+Pp/cPjw+Px3cPj+uyOrC6uwFOKTGrg4s6EnOKy8xMxAgUInMJE1HIxUVO667NUk41Yj6GhDmqqGrrOhRjspEAGVnJEckFOCcAIGYRDf+Nlx0XXXvEfbP1mIDB/hgf+zLiE3e/fB/6TjDvMmoiZqqJ/Nn98zlPd4d8e7vb55nA1ZSAmAhNEBqT6nou52OrikyYeHfYx46gKCW7k3oICwoiu0MttYkA4mHeJ2YOeh9yjHSaeRGppfGEHIrgYqZaS5W97KYJEOY8STMkfPbsJRFHdgXmBOyxImlEN+9BJ4ikfU10TBMTOGAihUbFPr57+bOf/Ylb+cuf/+ynP/lsQpN1JWTKOeqYGTkZNj+fzseyrGs5W/XH05ETkxui7ndzjBQzEiFwQiM01WbNHZCZOBWpD+XpVNan49PT+VRaq1Vi17xpQ+E8oagDcDNC9ImSiS6lndb14enp8XR+eHo8LsW0rUutpajBpmajapRY9YmPa87T55+8NAFQvptv87P90+PpP/7yl55SFVnX6uitmZvW1mpr8zy9evXR9O6U5qTqj08PT8v59ds3j4/H43kpa21FHUEVkDIY5pkNQBXUgZBzjv4QASGREwJnQiLmFAlwl+dHAHNOBOiJkMcQlIMjgZqcz6u8aDfpUOuiLuQ09vvGULkRMEDIaXoi72vqLlCm9/0HqoExfng5ExdI3FPVCD8epUg3i21hRGgVMkzunoh28/7Z7S0BEEAtdanr+nQ+P52rVGvaapHaai0ppdvdzS4zAMTeRVUDUHPvXShGYpymKS5HTkxj70AI2oo5mLYqSOAqzbHUGp6gtVZqmfY7TpkTsMFuzjc3u2lKrYq5oakZULBBP4x3vYHtvcwLimSEjOiewEVN9vvdz/70T1/M092zw8wZ1NSsrMeUqJZTBpiYXWotpZzfhyLA0/F0Kuvh5uZuekFMbkIcDZEYp40D567ASIA4U16trMvxfDovtZamtak6KoKJYvPS1lTNnDBNtVVARkRTPZ3Px8fTw+PTm3fvjqdzaSLqCKAGBpAYdrvJEBQxp1wcdK1+XA2EGR7Op/v721evPl7O5X/5u//4+HBc1tXUxRSQai1RSZ9282E355xKK2hYWjktpaqoOCInYndkJkzk6JxQANwQGRMnG7HW3ShYPAwp5jsSI6btBJg7M4BBZ2gTELKhAxoAKFpptZYGMRyu3StHNdPVmJKaMLGq9L/Wuzw4LL8LuQS+6YY9kNCwhS5ANWqEcBlFR+yYhJFTUgUk2k2H3d3dbt7VYsvpJGU9nY6np0epcl6Xl8/uQJzVRNaMeLObdpnQRN21qahC5+MTAVFiSpyJIRZlIE55il2XoiZSHUBFiVC0w8kmrZQCaIlTK0VdTS1NCEjMuNsdDrvbmMsiJDUzBUo9Aox3ePEHo1pDAIbuLjF7YJTnya0Rp08+++Rm4vPT+wnA2roej/ubw4yZAci0adNW3rx+8+7NewM/nRaaUssVGTgnYk6UxvychcxxKGCgs5i0pqXKcq7ndZXWV7p5UG/U1eS0FDVTSm/ffdfWstRqZrXUda211KVKrdU6R6pncMRIc3IiRNyllHOyRN6aup6e1l8sv/3d168z8s3tTStSpU7z/HBc17WpaTR4E6UpT0Amsnqvm6MouDMD5wkQEzG4k1sMKYRCGgIZABk6hrwNAABHgS8quYjImDDkbZnAMQUb1R0SeDEC44SkpORIYOoiUstZ5QV2OIwWFJbwK7H0GgGRYqeQWufT+wb3gQFsCwhD4xC76Q8NoO3bXf+hxwQHBwJW9eqKOb1/czx+dP7k1TMCWtbTsizv3rw2B23i7rs579L8cHyLGT55+dxUu8CiewiNu4MTEBInTjlU0hMjIHJKBIBpyojUBFxqE1FR8BDhSCmxGLTatGn4CwdnZAKMrU2EPs1T09B47m+RKZnXNCIdjhRgZAP9SiGgiQUJ3CA5BOGEiTGV1s7n0820SwDaijWeUiZwMDs9Pf76V7/5+pvvzNSa757tKE0vX7087A6ZJ0IKCbtgkqhYa9JcRJqBtSYFy+n4JNJi7soM1MIMwR20OBidj+evXr9+/e5xXdfSwGKbMkBwZiKmUxxoQjNXdWgaQy/OBuxsPu32hOAqra2wNpuxPBzNvdbmx8UdnZhTQnNwT5k4JUMC9MQUtswAfQE3oqixEyE400wc2wR7zdmjBQIUm/oQgTAzpRR0HAQarVXopG5GEsUpTSUtBsgZBdxbX1fRaluWRUEZGV3CDcYJiBn3oGVgqHbDEE6BSxsshl/ML6qWw9djcCWG/Xfo1PNnBOh6nKgQNDVYWnlzfvrdV989//j+7vbmeGoPbx602Dyn/XzglG4P2dW/PB9v5t20y+va5VnAUM0VHJnQgxKUUpo4JWIiAAJHSgH+MOSq1bSJqQESOqQJ3VG1NWkigtFFgagRkrtNKVdpUoq7iraUMjOadTXLtPn/KHX50L9zHCOtEOjRjUMdV1LTxDPMQo3evn2wUp49e0GepEmaD9q0tvqL333z3ffv3XCe98++eDEd9vPhcHd/Cwbm6Op9K1gTEW21LWVR02YqJrWKkaylinptJZZHmLlKl0kqreS0ezi9f/v+8fFUmkRTbbtL4ZsQYm+hAyBSCktAQIqRN1NIkIh4ymMllcfwNQEiplBa6AtG1VRNwVEMuiiIARIwI6YU2poaSlNq6s7IBkDIgBDwEYfWbJ8NQ2SmxMihiIlASMycmMPXUpfyhpxyoticS4lNWtdIVoB1rS6GmcHdY14fkAili7V4rMcydyKkviF9eLsYAhpXbFT5OwtoQ8HdFK7xsVPXQwIEJHdXd1F4eDz93fLl3bPnO6OZgZA9ZzejKT1/fr/fz21tr549M1VwJQy5rjF0hAiEjAwJgUMdZSRCGPTfYOdAKPJ3VRcHZERCdWtNTM0REvFutz+dV3OV1pBZzVWbaEuZAS3qxUAMChBbIq82/o5LhONSRGsM3MHFHVNSbzORVj3knXtS0e/fPapBdtznPXAK1tDj+fT5jz/ZH272zw7x8g93e/BcWzFpKtpETbSW1pos6yqtNZCQzlJ3abIsCxioQF3FmopYE1XzpnIujWevrmuVrs++vXTCriBvI6tHVEQmYiJg3Mg1iREzekJxVfUMuM9zjGTHdsGoMqoZuIm5q6WUUs7hwoMxJX2xNJl7kLmAFLSLFvcAFKIdA+tE5T8YfRD1n/hRbLdgCtsFACBnQiBipsTZILKR5mCJ2VRKKU1qzgeP9w1EhDaqdhZTa6IQ4oG9DDo8uG9PA93ku3PvMKd7xT5z1Cn0AIghfQUUkSV2LTNhq/VxrX/3y7/NUF+9OMyAiPh0Ws3mO3Nwopzun72s9byeFyAkiq5oB4LABMTIFCUQptj9EmHWmCg0y8HBvROAmTglAiSLkYsQEUs0Jc5zDg4lMrba1ro8y3ecYJ5SCw5N1DlHFejiGj5IA/rlsVBBYkB3Z0wOom6ipNAcuQo8nNdDnsi0Kp3Uadr95//8X6DXatpkJZCIKK1Ua1JqlWa1VRMvpbZaa2lqUrWJWdUqhqWu53OsinE1E/OoAlVRNTgVSU7ramuDqtcZfF+pCQSXpg5F8hakIkwpRWQlRiZGIuZYugUaGukqiAQA5E6hlQdEIBYFS+qoYMsFIShr7uQS4giQKKyJkIfMCBK4YwzbYOKExEBA5MwYm8I5Pqj7YTdHJ0JW0uB5MICix7p7ByAGM1jPZT/vCBmBEjOAO3rKqakQkJkSRSGD41L0lS2AoxK69X3hqv3Vi0Id8wSrb4sA4OBOSATsgJDMzZgzuNTWvvvu/YHTur56cXf46PnzU3kHRKKgQKp6uL2lhUyg6KoGYoYe7zxBYiLGhJBSsEGi4hOr7Dgl86ApgToIGBFhRsjsAM2lmqorEDqAMfE0OSLFAKermaY57fa70G4jxxq1JoHUC8CXoLeVQ+26A85xZESACIGQs4Az7murlqZFHVFhVX56mHc7mvN+f3teH5ueRdqcs7uaSmurSGutSrGoRtVu/1VEqlRHFNPqWtq6rMu6LtLUJRa8e6tS1UprDfD9u6f35/NS5cr2t0ProL0ciB0KMiEQIw7HglGCIQA3NKAua5nQjNg59tSF8pdpaIXHTjDqtr1p5wM4GCKBExAE1bQrltHIJDFqCeF8mQkJiKOWSEyYqG9gYULmFGfK0M1q3E1mTJQcjambZeRFyLaUZb/upl1GQDNnJgRnTqrm7trcLGTkjAhj6c6A9B1G9I7ARgPDUQ7a3iTCKAJdoAG5kYH24ECuDkzItDb53bevgRzhVd7vG6V3j6cXL+TmntPETFya4DQnRbP+PjkTpATESDH522udcbkcEYmRkzOoaQgxdDY2Z0RSt9KkNTVHpyQGRIApq7kkMncnoIyvPv4IOcXwIBKnIIMwpq33+0GB2OGS/o/6EAO6I5iasQEgsIFBmnDnpZ1qXc+tvnv3+o9/9rNV6vfH73xtTc67NFkrbupNW2ul1HUtsoqaS6tlbVKltSYqLYT7yKpKqa021eYuLiruEFuVahN3VMHHZXn3cNzMHrbXCbCJ2seBDlIRJybkkEclQkohsucBKwAYKJlDImJKsaEWwYkRAM0pMYQyWSiLQC+I9zJ5bIYxNELq1JKI7DD0Zwa3jHAI7eD2MwAkJkRKPQcgAAMlM2VAQYyKAzGiNCVCsFghDaZ+fHq6u7md5tnQwF0FDCwROaJI6F4pxNi791T4UuTrLPgu9BaZOfzQ9HE7JJuXif3Y7hJnhdzV1c3diGZ6Otc3j0vOp+lwy5CW5enxvHyR8pS4nJWIkRkI0zyROgA7Q1/QgoiAZA4UgzecKRE5cceKAhb7ZJzAOVAmillttdSKiTEmkEyjbyKlpikD+M1h9/LFK2Z2IPRoo3pUwFIMN8APz8D2WTw2qnfx5gMEUGVmDwkmqGVdHh4z07df//L+5fPG+tXX3+ynfDNn8UYiqtVKLWtptdW11CrSvLSiCpE0m7qYiKuBNbVSRWIesqe/FjVQM28ORdv5vMY83IcA6HIQ+h2MNR6BuzmWQRClaAgCoCEoI4a20qY7Dx4LOSMDRHCgxKGoGbbf+ZPoZkDRbeoayoBEo6CAPhYHIKBjrDbpkjTUBdqQGIMYg0ScYlkWOoPb0JVwQB75A3OsY2IicJPm5/O5lvr8eVIVcVEXcABHF2mtSGvjrvVSzyhn9ld1dfnwAwu4nM5hCwMg96uLDlvqhQBA6EYMU07VdCnrUtrxtNzMUwNfl5I47XIu9ojgmVLObETOEAkt9rjqCDGQTUDB1PBE3FtiFFQoREZXNgdkckZtVqqo2JwndXDtlNg5gVk7n5ut8uoPPj7c3Gaea6+WOQGF+GjqLqy/cf979oQAHh0462VtAqAQQWTAhOyARAmnJKUutb1+9+b27vZ8XrFpRkdCaa2V07oupbRlLbWKCai6uXaFE3WJbXwGzbVWqbWV2moLCRSqdW1qpq6ItUkpItVildPv/9jqfUhOdPFoITjJHOkWxqZHCK0ZQjAAcgMjAwB2dABTVbOcMlOKwkXc7zAd6go6SBxzSoNxNpqsMdqyzaOMhQFIDBGOIjtnJiTeTkXYKCImosAwURSZckqcDDXa+eDQVNdamBkJ1NREAhU0tVpbjH2EqV8qHYhbYQc3fNOv2fWR2OpFMYhj6HGQA53EAFrgBCcEB0INzY4sDg/HU56z3hyiswmdSIQABEi7addEzN0MInr0/nXgHaau+Y8ICEENJqJAld2/EAFRyJyJiqqqWQyHEBOo7nbzIm05nuta/vjlJ9O0lyI4ZS3KCD6IUQlDCGRrBMaIaS/8dpns3hDohz/06F0AxdXdc8o8zzt4VuiYDrdN3YmeTseT1NubH5dmpO28luV0rrWdl9UdzUmjVG0QOh6Bad2gNSlrqUuVpUXEaCLrUqrq2kTNOj1Kqm6ln993AqLChyEkS2PMk3oJhICxW300RSkQZ+z1pN4dMk45TJ0TIaKaKZAHB8XchhoH4PDRRMNyAOKSEow0GJF6OhDPGxO5FAvfcds9EOkHGkGnSyBCpF2ESCllbhXtItQJdS0iMuVJUJRMVVptpSxSm5tt9f84CVHbG+j6Qz/X4xaOQHBhz0VK3JvCHUE5erwjQjMgJHdncwNXJeJS6vF4ArHn9ztHxDypaIjvMiIkdgLRkD6noHNHoZqJOLGDYZ9bZoy+CTMkxJRABICt7zKgkN0QNBadpxkouSlSMkQwFGl5N33x8vMXz14BMDoljjDYxftTuIGtSdLv1tVdHESR4EONvTRIhBwKmGJihJgoH6b97d3rx2/vXtwcl9Pp9Xc/+fSTm/2+Bw+RWLtbq5iqG6h50O2QwJpXb7W2JrWutZVaa1GRWsuyttLaKmKG6lCqllqamtPoeP0e++87rhg33a+L+0PoilAWs0EUTs37sek3v3uCiKfMiZAcxMiCPqgIDGjdjBAIO2HnqpN4RS/zcSyj4hm+HyPhYI4RsCh7XzZwIUIijOGW3Dd5xQYhAkJPpKJIeFqWp6enZy/umRODN2ntfF7Oa60VGUPmdryXbuyxv8FDRnybhupndrSJt4OwVQevGdKdQkwbHAIMNXYDQlFxcXhQNL3ZMzBprHrs2p/daeSEYooe9UUgAuIe6ziEPpGQg5XswBG6LeWsAMYu7qZ1rdUcAtoiJwQ0msBkPdUiLc27Tz/+5Ec//oP9PIlAVSHkjmXBGDG5e5ADfbtN/e6NODAa3+MKerAjsNeFoyqHDgyQX3706Te/+ZvleEqYHh6eRGtKd2IVHVKamzmAc4I4tYDAwMqOFZu2tdRay7mWUmVd1traWutayiqt1iam1amqVZHzWgLq/X3Eth1e6hEdB/IP+E9E3Ef+IxiH1CCP2jdurrA7TQfsAyoEfTcjIlKocDkNp0gD0o86iw/PCQAQ63IBI+bEjR5dz4D/kUl0qN8pmJ0VzUBxSIZiDxIhJzYEVFHXZXn38G6e5sPtnhURYZV6Ws4ATt1Ro/po5vZDDe6X8b/hH7Zc9yobvOQEPXT038fLsbD+jgHdnBxC291MRVsTETWNHeuamBoBkrsqAIiHEpZzSvG2sOtIsEMoaXfd0mi3MGJCzEgOKA4mTZqs55URpzwZopnM8625FddzKU74Bz/6yV//9V/f397Fuu1W25yZAAwseibp2uB/jyFd02LjP71sNLYjBJ0BMeWsaIz++Wc/MfS7u7tpP5dSCUObkvY3e8xJalMoyQGCnuCAzQVMtIm0ta6l1LVUFam1lVJKjSFJ076C29ZSRFTsqkH5AXAdrrbXWSiqagE5GPshCPYBdlgysAvSBQtg0Cq6mWDkzmgAwIiAyTubzMGBuoY9dPNFSNC9bFwwjZmKUYNK0QGmILFziHx3FEYYrYyxFtTdAcmJ0a0LMCTi2FAZO/lM4Ph4Ot2cdruZEmNN2kyKqpiIEqKz9+TbB79ltPs/uMujLQaRLm9YoKcCW0zYyljdFOLyuwfxA/oMMSAmbqJNVJqAg4nMOYsmKbEKVBHZARJzjHYiADGlQIWUAMANCVzc43ISIbIDm6HVWqxplSqxqQRhLTU1Mi1x5feHm9vn9//0v/qv/+DTzwqY1BUxJ4rGV5TzHPG6EYaAjhY17x77fDsYeDklTqGG24MnIY3ahiVPdvfixZwwOzDntRR3RKaQu1FDFQAoQWoHBBQLYpNUrVXq0kqtZa1Ntda21ra0FiOQcQYiM9bQ6tiM/tr6R4EDKGiF4Ah9nTteii/9GPQ57yjhxDHprS3vwshBUjU15YREFCpruBXLw1qQYhUX9D3kCIBRSvWoW/TaozMxESZOPalDvCIXhFce6dd2/REgSnuIxMw5YyIbs+uxnWOt7fi03N1LmiYARiBpATiTmPIoxf7wOl3KPHi5dJdkoKebPamn0SzCcUL6pfcuN+GONEIN9HTCEZpZbSq17jK4WIputxqAAxohcfKU+i4pYmKmrs5roODmgGaZ2NAVICcWY0J3ayKtluKqEdL3u506NZMiLef5808+/au/+oc/+uhjzAlFOREYQmIAx8gfwBA5Xd54+PVx+UdPzLeisbsO1NPXKcNIlgEo9DNckRgBdLc7nNf16bg+HY/7/UTYdxOEgqC6RdorzdbSzuuyrrWsdVnLUstaW21SRJqqqIpBExOgtbRStYlf0t+BTX8QAUa/P14q9vI/0mbmkXoCOYIzUXgfxOsUNqgqGGzVVisCEHFO01CN6XUDd3BzoBisxVEo6Y5zSzoxdvlgB98eaVcfujAPKtwFZXtP26mP6iIFCwAoiDLgjJwYm1dAVLFW5bzIfdoz5tbUg6GBzkjo5DH/1V+OX12lUSG7eP/+9N2IL2gHNtmQccGjXnxBom4j9XHwCO+B2MxBjScw8K7sL5YYo+qZE+52oSrdtT3dQWNEEIjAE3vQvWOAJHVSq4kJIPKUpbhyYppBWp52N89efPbppz/72c//4Eef8TTH3EJo2E80Gdp2H4ggyqBbZ9yvUh2PMlB87v1ehUvcjn0IyDlQ1MSomVVRVZ0VltJ+9ZsvX7147nhLzGCGwO4ITuzURKS1WvV8Ph2Px9OyrGtd1lKk1iZrk1WauIl7Mxf30uy8llW0hFTWf8L3QySkMf4Rskk90btAzNAQCpoNogU1h4C2skhwTokZAMzBNWCou2lOXV5TTEa5zOO4hN/oMsXRSe6mD6OOj9BLPb2w0QOSdfC14e1wsETIzK4xVJVE6vCSREiKhoiJuJkCQJWh29lKjEXFk3W/hp3i4+Mub0EAL3d6WHLExe7+cESB7fpuGULkjx3/9CCz1Q8JyGnO8828S0hmjTGrg6kSdnlOJELGOaeb3Uy9/hiWHf07YAAiVgBGEBQ0I1dyI1cGnDjnjLTaEUtZ1mnH0zy//OTjf/jnf/nxy494ZjU0VRFxBWdIxkDBUQ8VUOp9gNEj2azpcqR/4MoiHHQ9XnQHA4r3bkAcd9yUEvNSTor8b//mFzf727/8s5/dzJOJo5MLYqjsNym1rms7L8tpWZaylCprq1WlqBaRoqrq6qCIzb2K1qqlNXOy/1TuO14/EToBQe8xhdYIM2PAISJkxn7oYzKWN1AQrGAkSAkRQUjNVUTcfL/fOYC6MxE7CWqvsaCb+0aT6PbWDyMEkycqUdTlCKlXfqJYG8pT4IOPgO5GREAxP0DBAiZKKScQp8TJQZqYKYz2bi1tLZJzfXp8XJfFrJPAA+kihv6DhXL7SPJH0ROu/tm+j9vjtkPTscBwPpdO2iiWjtAchgyW5zTv5ylFL8ZFxdzMnJjAnTMS0ZR5zsnNW6seZE91QtDebbdEaNjjp7TIbVzjbDphIkThmQ63h88/+9Gf/uznn376xbxLathZv2qOkGnuGpIeQ5EWWz23iTAfpQsfLNiw93h/7tjp7A6X/zrGkgwFMDDDkLaihJznw/zwVH77zeuX//G3X/z4xxPtYpmEiDTVtra2lnU9n9dyPh3Py2mtTaIn4N7UVpUiQfAjUWuqVW1t0tzNDZlcB2ElXi5euFvDzwfREAGAR5WxY+FIcYNESlGBi2geZe2455g4UrQEZrWpmtbaphkgdhiGA4w4GJqbFHRr2HomA/TTyEwwBr44MW29nV5XCtTrSDj2abiH7jNBnJYYOPRkc85B+2mCbhYZgkhdlxOTnc6n0+lsopGuiBu4Y0hfBkdkK/oNm7/y7f1HPr4YD8QRGBzDd16hou3vYrhG65NdLgbOOU2cJuYkBqIgANJFaZGIc0qMzDHs5tR1OoMDFzGrl+gtIbo5Melq6m5iTVVUOE03tzf7/f2rV5/85Ec/+fyTz9NusgCljmBIKQbhg9fuIY4L0GV3Us/xe8kaPpyKuPyLQYp1ANgagg7mCLHTDACDqwDNZJ7mJvWs7ft3737z9Te//Lsv7//yFh3YcC2lnNvpHItj5LyU41LOy1pExOkkramtTap4EzekptTAS9NmZhh76cDVLm4IxvmNqg8QQ6+1c0+qusxOH63r2veRDURl0rA3AC7mS4icOBQQ8jQZVHczk1ZhmrIjIGLGBIAeIzaAKecIAmEysZGKN+uHLmzG1Gs/mxYnXC49Do1u6u15ipVYiZndAIjJiVKaActaCFERAntL1ePT2VTaRhCMgi2wd9Ug2K7VMOnRr754etz62CMgDqDUbzlGhepChIreEIKbodNW/o1IkRhT4pDUrq1Wa7VVBxMzBGfvbUIkZEdCNOtHKJ45Bouj96RqObGUwKOAzoS43+X75y+ePX/5+Rf/4Pb2Nk17ZwwSuLpH8QuJrYOzgen7KXdETON++eV/3QX0M791iHH7QbQ0PCjVTt7J6AKQOKG5xOpQTob8zes3X37z9atXL17c386ErepSlvO6rGs5leW8rrXU2mRVLdrOaykmpWpTbw6A3FSLaDPXMNotS7y2f9isHwljSKKzPrlX2SMP5jB62jq2MOodV38wMr9Q5jFCN2fi3bxrrdogXyRmiHISdCcQTK4RgNDVU0qB+QM8jhp/H/vtH9QBOIwqGzgS4yZNgIbqhoQ5Z3ffiEBKzswOAEhI7uDq2qQeT62vro7RsNiJixC6Q1fX6troP7iQPUIMp9hbXAPb9Bd2cTzj314H6u8BIBJWnKbd4eZ2mndmsEhdm4gpIiFxjNM5EFACRIWY3LBQg3UAAicmcujqpW7E3ESJOPQhE3PKO8rTJ59+9tGnn6Q8i6Fhb9KCWUocC8/ABcbyMEcAw956Q7yMRF5qKfE+fMxPX9lbr/1Cb7AEXMUeHsDcU0pSVlOjnJGyATyV5Ve/+e2r589udn+aGM2prbquUlZZlno6l+OyLKWdrFWBc5OqWpuKgToAYTUsasVA1Q3wgv5xmwEb7nNUW7aX2mesEie+0luIKmaAIerF9A0cdYMIi8RYkmEAwISeU+AuM0fyPPALoWOQMwMBAAB06gT0omrAMAz3H1s+QyG5I4et1oBO22lEjAHW4NYxs6oCYMS3hIkxMREYEJOYOIKaETMjyQbz+nLO/gI3T3Ep/gBc1ztHaIj/DHv+4HRcCiUdG2zZYx9Mwl4kBGCk/X7e7/eJU7UKom6WKIZ+3MxUhZjcQWO7oXlrGgQSdIs1O2xo2Dfbl7UAoKgr0DTPzEkJiNPucJNzJidMXKtsqwF9hKPtE8BOaIMofPc+QATCEdSuqgGdqgAepfEYSPSe4wC4e9/nbQYIZoZILjbdpfPxLKWZ4+Pj8Wv47tfPn90eDj/+6POlrE/rclyW2uppWU816j5VwJt6Fa3ROgF0ZDNszWrTUooBxmh8vxXbTRkslVFlwV7vDPxD1/XP+Cn1ftP2JVzW38II/egYxYJe2gsrzOQW/9tGXsDjDyCMimX84W79kVTEJjccNICrmsrlxA5wDtEyG5QsD0A3TDrYFOwUI1lsbkZgEr/S4aqKmhomwpjDoctTbNj+w4+r87Dhog+bHdv/b37SAGBrCMShMCPifi/cU8qEacpZrKFN5p6mlBObujNAFTFpTWx2JDZ1NSNiZVdRB2PKaIwMoBKrN92siK5rQ2YiBsec8t2LV/PuhpA1eNA5JGhxsHYNgYZRd8fn/eWjm6UPTziMkIjjpF9fq14E6IW1QIS+iRwAMauJuCXitSzvHx4dfCn1zePjb776+qNXH03IUtan03lda2tyLrUsbSm1qQpSFWtiTUwVFNEJRbWolGWtnQ59qX9u/mzgf4DOaO8HgTYjxMtbwtF66mB3Q0JXzb/R4PTxK4gI5gYQ3N1+TswVzB0ZHQ0Vbfhyj0TWka+4ZBAe1R0ALcSJfvAGgnQBPnxwB6Pez0M/aWGrFCyoeJvsrgCx9dctdl73W9wLND6mEz44c92PD67jKH1gwBwaj+xt3RGitrfSN4WCAyFoMM9649AgM5JjQsru63q6298gc8YMRAiWMpp7YmZJZmYOpbaoThuaNRVXB9NqCSlhdvVEjNgAsFUhQABWUQTcHaYXz1/mPDmgxbokC2DI2B360H3rHm47wx0FpR+Y//iwLbvc+gMXu+vm1mdMIdoszOxmJghgYG/evlbXqlZEycu3b97++ssvQTSRndd1qXVZl9Oy1laqammyAqzqpVkVNe91JXFbYjmeKBBvQeoHRxV747T7buyV/m7/NP7XK9oflII2+48G1qjmXfiSIdwJjIx9c2Rv9au4ozoZcXK/kKlCgmEkF7i9viig4OAKDKTl3dfC4I16F06J37h+hRTLx7wfH6KYCLl0L1Qk5n/GUd6mEbbT3d/hpbjhfhUOBuTvRt6/t8Wry8XvSTH46DKAgxO4xrSuqTq5pzg/Tfcv5mD4KKqpMWFO2dFTypGslrJyYjErtUnUUsCRycSFRE0F3AE05ucpeZMmutvt3WneHYAYORG6yNhwD2YxgrqZbNSSYHu/8eq3/QAXclO8SxoOq4fBke1tycIwlcgBEdw01FJ3ux0AvXv3ttTa3NShAbw7nX/15TdoeH+3J/S1yulc1lLPa1mrmntFrOriIEgqVrQ1N1VvGvs7YoobPxhoAtiMGXvZM2YdOykTB1S7AOvLe4Wt8jvKo32iZYCObmqI3AsyGEdAhzmYj/YVDmAzaqjD72I/Bf3vA/kIPtijjmMMfoxy/HYGwQeq8w7VPHQYMHyZmykhipl2efv+pAhRnUAcTNjNnkP0nwb57cryR00ZLqh5OygX2tvVY6OI4hF9zMYKJDAzBkRzdEfw5DjlCRm1qbKoS5M640QAKc80Ma5raQWVJpvNTFybSg5RICBXOJfaYiOgu4mnlLXq8bzW5ozTzZ4BKOXJrFPrkGN0yS9ZzJX37he9vw8HgNTzmgvA20x8nJ3eQe83aazSAOjy/uoOjGhmCOointK6rqd1fff+EYCdSBTWKo/H81fffv903O3mqdZyPp+P66JqTRWQCsCqbg5mKOZFpVZRB2RCJpDQeIKLulmYOMV+ELyUJqjz/oMOtxUl+rBFt9MtkveEsJ+tEUTCOww00B+OEN0z6u3KYIdjX9fjHSkMqkCvYMc0DnzAt+wvHq7c/CU/3dywjRaDmXarD/gUN5f6rYkDHHFjkLEh0nEHj2UZ/Xj41jG5WDFuWGxYyVi4+4HDH+dl2FKvB7q7Ylyl4VDBALhz3FOi/WE+7KaEXtrazkuzZu6N5XB7w9lbKU+n8+vv37Ta9vvd3d3dlNI+7/M8m7uKiUutRcXWtQISUCKk9w+P5dwe1yIKNzfPd/OOQnIPu5iKgQVshc1guvscKBT7q0XE1E2737YejceBuDpAgyDm/e91rfpOS0QwMeKIgP79mzdv3r4rrQiYEalBdXh7PnPKRf3mVlz8VEQMxHFt3rQtZtVJAdRMVFszUTMARjQEmpIFqzZeFI3SxuVf8D6fhQAWReKQXe7DMN08Atp4ECMsvGmkqD6w1NV9jwMVRIUgO4K70xYNnSjGCfrc1fDBEEYIAOpGToiGzGFKNFoO40n6mM4gUsfrx1hXClEI6lym3iCAmMegId3fO0UxxtllMZAQgPqZHjyFzeEPFzBO7Rb8L87+GiLC1YPjQm/Ho3Oho3Ab50sVEmFOdPf82X6e5pSW8wq+NC3FxREY6N3TmQia+OO7h7Ws6L6bJ1X98eef73f7c63LaS2tggIRGpqoYcLMeVmPx+PpqYm7P53OSym7fAAlc6PENkY4tmmh7W3RBc9vlwwQMW1wcTRiujfwbcUejFgwPokrHFN7DBS+Dt3Q8Wbei9fT8fTNd2+ck1BqiIqQCc9q75ZTc1uEmak1bWqqVsWayrnKOehFSOauDj7mynPOiOReWrTBAMAA+OpGDmbqwP4D7m/M/3G/r1jSiDEEDL0BjKNtfEEj3fn1CowDQmgzG2AnjtKGWPCiM9Jxv/uWb3SUPCwKEYGIvSe8OIqUw1SDrhKWRqQWkLhjeUeHoLcxKrpTv5tO3gms2INXHwGLADUC5HAB20n4MAW8BH8fsHlrGUch0BEQbTsq3t8vMBOYolNwNd0zT7e7+2d3Bl6rqLayrgrijE9P58en4/m8ZMr7XWbG+9vb+/v7T1++3E/70qSei9QKTQBQEEoVA9Qix9P7t+8e3zw8nZvcP3sB7mK+FJlvEzb3vjQ7Lsg2u9JvpcOF2bEFXMToZcJgMoFfst4LghrFBB9RINRvXMndMQieDdTMbJdurdl3r9+9fXgsogV9IYfqNxOL27vjsjTJOYWCJhKq2VparVLUap8LsR6Ugq08xliQaJQ1ALDDdE68xfFoGCXudOUg2wf3ZsNIA8zBBf1fbBgupY/NTq9K3GEBgYsi543AEf/zTne9eMqe745+ydXLHnchHNSG0wa4M+g80QHUMADRdmCY2WuNoDZwoMKFuYCEFyyPlyS22/GVLxtwaDx9XF/fLGRciO3SdZTmA11iT18c3HqnFEPPF1Iq1p5qaVp9Xc/H97UsVWStRUpTNzCjA+2n248/fvnZJx8/u73NU5ba9HRi0RsmSFMFP6sYYkM8nk7vHx+//vrduS5pfyt1hZSOpxOBTzAtvjIwgKtpb07397e9iy3AXU67u6ftfIyLg96vDW7HHDGgIQykuxVpnInUXaUhUMIEjm/evvvu+9fvH04PpyI8iQKAno3QnV3rirkqMmROYgqGotpUSmygIcYOxz3cLff8kmi7I+PubMz+eHkcwjs4vPbgX/bb2RNPGi43sHsHh+N290/IO4LxGPe5MpyR6XZk3Xu5F5cPUQaNY9BzjjF9i9AP3PbHIlHtMWP7Xgyf9VZsZAFbWHLowndAMKhLOvx5vN6teDnCzhWd5/Kx+YEBeq7+SLf6cQB/8Cvbw6LDAQG3AwyhmiekjABmpdTvXr+eM8OyPL57L7W0Vucpu2kievbs9uOXH/3o849fvnoxTzkzuRmDwTw1LC2aSubaYFnr++Py7bffPx3Pp2XlOUuVKrrf7U/nh9Pp9PyFTjm5g3koWBr0zvzFXrb/hPPaShM9B8BL4fNyIXCkPR1kQqRgCuYIZqZo6s6M6CqUcp5yXfSXv/r1b7/87dP7B1ctIpAzFGtmjIAECm4EjCQRPdDUTSmWJ6MBJuxSGcQchkEUU/wbOOmulBAZiRMDAAOIBC8mrAZhcNHjHGxhAK9SB784xy0BHnUa2M7+5eThoO1EEjrmH/Fizdfl1QGeeg1zACIY2GG8kv664IKhupAixIor7Kw+HL4BhmbgyG1gHKqRo0IczU5euVJ2297qiKU/wLl4AUFXZuPjYSN37scDx11BGMt2GRDNCJDVl4en75eCaFhUpILrnJKD7/bz/e3Nq+f3n37y6tmzm0zEYOQgqqIGToa8Vj2X9bzqYy1vT6fv3jw+PS4WAupKOJOUtp7Xu/ubr7//7Rdf/IhSUhU1JUDzgfi9a3FEi9oROm8k0iMHAEgD+XcfFjeop78DK1DgkgjD5uCG6IMUbYbEnABBzd89vv/N73795vXbspSJ0lTWVq25T0bECUm7fgBEkAcHUnYwJwAPpRSIRVAQaemUZ0ZcSzX3kNMM18ahJ5K61hWMfs5mbDQQxRiB3Iyti9NeTOCSBl3cRAckOP7K5hsvuGAY7gDveDkOkWD0IwHe05mOobfcoh+KrlAbrd9+FqiXfcPYCJAIzehDBI8dw0RI2JDcBbz5sOkr5sqHmB82rDTe2njAyHfHRdmuAY5MaeBsIIAIUS7OhGTOiKhalwVbRYBY4jtPU9pNz57fvXxxd3vYf/zR8xf3zxKDqq5LK2tZWwMHQHJE5CTgj+3xu/cPb949FTVFcINVxEQnd3VY63F6n1tr5/V0c3OjakNlG/s+0nEze/Tt5xVGKus9CfZh9dv77vUgt5Edj8LQlXkghiywUAhEOJQq3759+/U3rx8eHpCpLiuoJ0NwYqDQOgLALkxtHvKtCk7mnBK4Q4hHkwMgI8dCTHRXjf5m5zXGJElOKaU0PBImThD0KerrVPxC8gFHGBTkcRD6zR7J7oeeb/MADnCVHl/QNF35+q13OpDxdjkBELYOXAzVbAnC2EO4mVkXV9ws0t3V1KLS7z0XsPBADqJi0Uf1K6vut9e6Y47u3MA6fu3BPwT6m/f74JBs1n9pagdq9GuXaejgQO7AwMQJPIjhYKDNAZwA826ab/aH25vd3SHv97u7O553zbyptta0iShUwSaubgpoUh6ejl+9fff24b2IFam1GRCoQ1NFrPO8m/f7p6fzr/7jL3/2s7/I846Q1I2B3NzRzS2CPHivVvtApldvGtKW6o5rEjnAVm/v79zG3YurZ+boKO5u1ppm5jTn716/+fWXv3r39q2I1rI2aeZK1BvQNP74xhuMahM7ABIjOJN1gQFMoRXCBA4iJiIxwx95KhFlzswcZcWOjLkrMxATYU/a++i8j4mt4bfDxnoV/1KtwSuP6B2+bBa9mXQPC5fsCuFCIxrl9p6JURe7NRyDv5cjhtDR/8VBw0gM7IL3ek4GhKjoLtYroDFaot6LRBcHFSG+G7eBoXuHfbgVAMerxetXcx0cNkd5/RH9yNEGikwNDTTK45iYd9M8M8xImQFDVBkREY3RkdJunu7u0/1NurkpClVbawUACHBt0tSfzmst7bQWEX14PL5++1TrIqLV1AEoETPPmQ29uZGgiLx+elel5szrWsHRWWISqIMCH+2d6/cVQdGjqxxfjR7BVcbg6H3Az4exhn+IhmiwoJVAaslprqKvX3/7N//h3x3Xp6UeS11NLMYxGcnR1OUycHO5itgtNcQG3ZkThYAU85Rzra1JQws9ZwIAZkqchoRax9MUot1bTQc7KEAY04bUKQzdti+bcbfcbrs0A01jj47YcQdubnQ46Kug4FcHo2P/zc4w9oHjMJvOGOo/8kuqvhGRuvvp2Gy7eV3CAgggOo+x+x0x9soPTw89Ge69iYGHL1i/D3Zs0X+cALi4/0vRHK7MwnF7QT1uofbLQ0AZ4GaabjIzI7qJSiZ2hCqyttYMIa9AJ8dcFmPw5Xhaa4mFOpR4Xdt5XU5rfff40Kq0UjGlPCc1T4njiKvGf/G0nJlw2s+Zp0hPiVGasvX0x0fNcIuDuHka75gIEBJipAo44mLH+r0WEknYgFFRFelnAMw7yxccYVnLN9/+7rvvvj2fTnWtJqHcEFi2r0G9ung+LAZ6F8WJ0L27ceCc7+/uzPS8FkJ0x0RsKDEmS93Ug8tJXbcHLkcgpGOjwN8pETYyQuuLwIfBIw6S4Lip8bp6dzPSpfFYGMnGMLUYaOlVBRjp6rW7QUS0rlN0QThhVpvp+0W4OY7W5eZdO69OtcCeisXp7GwUwO10xmiiexegvrxaGA2rwWq5+tF2DMbugGHw41Rc2EEbzusoEzxeWuy7QUJzR9Wck7s3taJtlaYiJ6lHKW+XZZoSmLZlbaU4Bs/Xm0hpUte6tJI5OwOYWrHEabTZwIIdTpB4muf9J598/Nd/+Y/2u/16Ppu5iOfsidK4guBBnbKoDcMPwrCZDWW4eHDcgQB50E0c3AM/RJPA3Q0MLKTdnYhS4laKmf76N797eno8HZ+WpUXZNHoHBDG35zFKF/h/0FYcwVPi4B5pbWLKKb28f3lzOByfTtrERoWhz4UScUrYAQQxk4XbjQ9GAEf0GAaIrkB3kZ3G4ebaYRkGAw6DNuwjcvQYMQwCBw6+sparEzGemS69NIDt+72T3JvUWz7WTd+MMHl/yRdPf6m9eii5dBPv99URiYOO7OZmtt3BYZ3dm0X2hr0ejtv34fpjOLjxm5dcb/tODyIfwqI+N+MAsXQKeaKUkEENXBG5NWvqYnJa2rnUCs6J3z0uDN/1N6jqY8LDO3cBiEnVV6zgME/55vbG3MVsTmneT3nK98+evXrx8u7F88+/+PFPf/LZ4fYm01RqBVQHNzdxjSsRbzsqwx66pIajvNnBQ9rqEg4fXIQO1N2Dio2IMQwQHtYYEmJTAyRVNZM3b958+9037989tFZbEwjFOOutwwE+gjDrQOPKIhKxO4hZYjbUlHm/3+92s6g6gJhG9RWU0QkJmRKNDlfQEDphfsSE4IoRIac8QJH3iIXuopg4jCH0h6PJOyyzf9IvxRjZurYJ7Ehjo9aOnyOAhww5jcd0hLPFVwTcEtFt6MovVhtP4ltdLvbhAURZywzcVWOmH7D3xyASnQ/mHuHS1OpHEoedb7beG1tX1Y3f87GhKtiOyXV/GIObDY5oiA2sxQ12V6lVpKiW1ppZAQcAjWX3SF1V8lpfmnpcAwBPyIgm5qS3d/vPPvl8OuwOu8PLly/u729ePH929/x+zpMo7KYJHda6uobCSgIKPZhRouivtVcRDEZs7LzKToXomNxHvhUN5YBMQauIN9/30JKzoKOKCnEqrSrAb7/66vvvXtdWAEHVOPXp2F4xuKKLjfQkHCQhACW0ZtpKmnh/ONwfbl48e/7LX/26iUgV5C6mTMiJOaVMQWnwrSyIsWNrq0wiQl+AEWXT3hmI7s04DSPxjaVcA5uPment4vUa/WZIcPGmFziDDgbWe+1b7xw7fh7ROB4KHch3aG0xVE8BzxBDcQbHL0TMI2Jyc1SKNit1TUsARAcdzbErJ9afux/0KzPeLLufNuxp1IdW3x89Akv/zqUFPLBRBCAEQEesKg9PZ0agBK4QsojNUSIKjl9Vt1CDRsa+Y6PLs6IDOqGrGSIQJ57+8Kd/+E//6T979eqVmSI7J0ZwMVWEfJiamK5KRCaOBMiEBm5uPN6HXQ3ZXYDvOMkUjbBRILoKkFeAcgBTiIgLblK1rTmhqMhyBoPXb15//dU3b9++ByAR2eZfo0cf6JwczB0QzXR0c9DMTC3jDGic0+dffP7Hf/SHH7366P/7P///VFstq5qSadexglDQJ+irkmEsA4RNmTMiAKEj2ugzATH6lhCOlIi2RDAmRjaAcA1jfLSMth/41U/HdYoq4dbSHfkA9qu6CU184Oev7kicUhiHc/TiEQe065xPInYkNLHw3jEk9eHf+qE778nsVuEaxYcNp33QGfAfvrUfnggYneaeLUXMc3NsaOIobuRuJSADuLtCkA5hBJERqCE2hTo4QGBSdUC1oCgyA4I4p93t/asXt3fPzFptEiGTQRIlBO56lZHV9Zqyxc62gbfHq9+GnGFcjKBC4MAnPVj0e4yAXYDaIaYuqNUGiCJNpGpbyZMTitjTev7yt7/99W9+I1Xn/U6Px7iJZu5gOLbsiZub9aKYKbjztIvl7SZ1mpl4+uk/+Om//O/+1e+++vr0eFqXNQR0AZATp5Qu3aZIVNA8dpV2hNoJ0ER901wPAxjfHLe1L8Lod9ABLptR+tW6MqP+fb8y3A27xbd6sRQ31w4Om8jEBvYvRSHo1avw7R0ebs8DcAkNF7eMyIjWw1vPxAGh6yLC4Pj/8GXj1Rcf+r4ffOC1pW8fVwfKt7ba9oPhMrsdeVdvFIVeN1HrbmVzPOiAOeKvRo+bHJiGLh4CD/szt9oAubEtaOcKeV1FKyX2pg4WasMoLaZeiDwgqcX8F26odLuMflX/we29EFGC0dToVb2ubmdRnesazoi1CaKbuZuRo8aiPLCHh6dvvvnmV7/6zXffvXZGNS0SOT0MAc8wAIxKZxQ0OXHv7hg6WEr5cHN4+cnLT169ev/u3dfffnla1rWsxAwOlHia58SsKiGo0CeVqd8aHCVRGLUt2Er7mxF2JwqXvDROyKiWDr8wPOUHVoGjlLZZ5JXpX56wuxq6eurtZ72D0o/vCFgXO+tPd/lPv4kYFd6okVloHOPoIcAA8rh1vH7ozq8sYfz5vxcn/MNfga3o01tofv0gv/oXuwA1UuSvsUWjx9aNNxLbZyMSakcaAB6XPt5R97QfnkIHQErTQRAKGDJRTmZspKjqwA6mZkRmYogMBMGijRszTuvWUo9K6JbFIfQqUL9vHlRzRIqNt4je95qDqxgBILOZcE5mwkju9vD4+Jvf/u4X/+Hvfv3rL5uoN1CzREm9ql2GRTCG91rsHYWxJRTJQF0RfH87f/Txq3/93//rw83hb/6Xf/fv/ud/X5fCmVWdEqbEiYEYmig5ROhEjIPZSWsBKAcVOkRKKGbiEJGBkEfZCTBEM4cxopmFXES/YmPwasuTkNB/YDEOcbWoZzG4nR/AXnoL1059BhL7dd9OG48T249SyAGNIDOMgQBtix59eUFne/eRGPwQw2xG/Pe+ch9W4b/nYVePG3YTX2xBAGAkDNDLo95XhPQIHOkhBIobiHGoUIXctY/37BCs1yslOcSYWNx+kZ0QlcnRXKtME9mqbs5Ag2cLTBzuZLv4mysaFxIGXh5H0kcxABF8bEjonfwRm4kxZD9dVaWBK4K32sBNa6u1mGszOZ2PX/7q11/+5lfHp8f1tCACkTHT4TDPc97tp2mXnExdIRbdMBAjIIipuxdpOeVPPvvoxz/68b/6b/+7//1//z98/vnnX3///ffff2d9B4vvdpmJnWI5UUQ3wy5425tcvdk84Onw833xEFFsiQk6UK9URvIGIXNNCA4a29UHVyE+Dfv0Hup/j71gjzoDnvT/6yY0IkS/p3CBQHiZ3++BqUM1i/b1hoJGPOjN/M4giU1ksOXmP/y4OhGjxAUjMbm8FOw2PV7ZBeH4Dz6J3lAgzzDbAY7BYzIEu4ZVnyLZCBq65Y9jJQOMzsz2LP0P2dUThh9zNssOGWHHRGLkQmYUzyFmNoqMl9nUvvDOx7HsPa1xkfCSAvVY0NWhBwoC6NP+KOKlNLXWpKK7SAMHVXM3k3Y+Pd7e3B12t69effLuzXum/el0eovvRMTcpDZlgKAzKgp4Jj77mjDtdrO661oRkRPd3O4+/fjj/+Ff/x/++M//sKp8/btv3nz3WtWdwR2i/hOnEcERLBRIkJzIw9ZoC3foSD3rwI1uESikh3K7Qt/dGW0dUhz+4YLuB5a/8s0DbGzmvzm/zcA3x74dhat/8bp/PdzSuCs+WDad89Tb1sNtdbzkHgVmJgo/AETjHn5gyMN2ewFgIA+4nIHx+A7w+hPhhvlxfAofPHygo8EnpBEaAnNdHo4OrlsUucpCYUvNt8rsYO1APxsOo0CnyRFg27EZYH3UIhABxwAj4rgKPmqOOGLkJQqOs98xY9rubpT+oxDh7uRKqK01MIlIRwlTTsyc0+H58xtk/vhHn37+45/81T/8y+9ffy8iX3/1zd/+4hffffv969evy7pK7C0jYwBKsD/M0gTIMxLvEgLcPb/74pPP/+V//b/+R3/9F/d3919++eX/+//5P9ZaiNFrrKNzNUtpynkmALTmaMFspi0CDCrkSDwDJSAhDQQE/ZIAIA5+VBg/DaWRETzDCq8uSNjnFTkUe7lnZILbZ306OU4JDVvFq/PTTd+HSsnlhPhl3nIcOBgJ1DaWYeBR0RIJKyLrRgoX1cIrKkP/d8wZ9K8/CBjbsRnn7ALDcTvW/gPgtIU/3wzp8sTxeb9449L4MG4EuALn2x/tT+nbn3YwV3AXIGC2CCh9zc6gJlyQjvXY4ra9PQtZxPiT41b5FdPE+9gVJSLy4SuJyN0UOnfF3VPOyXma8jxPxGQODMAECKZuRPz8fveTL35kBtKktPbmu9d/9x//7m//7he/+MV//O7b75bzcl5LWRdtzqDopkszwJTp5Ytnf/WP/uJ/97/913/0Z3+YNP3qV7/8v/+P/6+Htw/nVlqtpbQ0JQdMKXFwS6DrfIIjc8wCYG/zUld761y4ngyMRgGOUiYMnNdPSXTxt17+drE+cNzjbg0zGseDQgduS7u7nQ6s2aPKuNzBFut9NbjWQh9/G2HDpn5xvJs/37LpoesVURGjqNJHYHst6mp54IdvBS+Yya+Mur+Mv3c0tod9+MAtZG0DDOMRV5lSv554+a5vD7w86nJK/96zBO4DZOKUpkHVuYIwQBekCHi1kWc87+Vt9SbP5Ve3f6MTzEyqigPPsiMCMqbpkCnhYZ7zlM3d1DiFrqsTghkaGhEjIOfMzKb+xedf/Pwv//ztm9evX795//7dV19//e//5j98/933b9++/ebrb1VFm0qriPjRy4/+2T/55z//+Z/c3t68e3r6n/6n/883X32p7OV0KqU0sTlz5jlPU04cSpfIhOhA1Of/u/IpBQvhMvze3X7HEmMCnjbzHkJxw51fYvG4EdvNsoGaoobh48wMydvL3frg5sEWjfHqp0H7o0HM3H7RwahnLhtQ8UvhCBCxp8K4jTcQx44nAEDCi1rwBkBwi0EXUaxBBR0Tdzg4UT2fuDoDI/bgCAL4gX1vj7qY9d//iJB2wSXX5nf9K3j1yXYYCNEgBISZKBZG4SCzbMHKAdxt9NiccJQvAeCqmHcpx11iVP9ICO5gzGTe4R8yzTlNcyZOsbjDAQiZ2MxBmyCguwEZmrfWALCdTomTmTIlA3/57Pnz5/fL+bM/+uM/+q/+xT8/Pp2O59P7t+/fvXtrIoRgbnd39z/+8Rfg8P7d+1/84pevv//+7vmz12/fVhEjSImmNBFzTtwXZYIDbxXMYexhXxTzMdg9P3b3QUDbRBgOsBuFVAcAsNDkgWvm1LhbAzmOSza+059v3MxLwtsdcPe5o7QMhs6ABqHx13PxDwoVXQFiQA67WMGIVJ2th7FeYKwYQmZgAt169UOrbYMpw+qhM2E2uOzjJHwY5q7NeHPxG8b5e5a6FYCufhs/+Nov/374TB8Az5GW0NjB0r0RJQIgSmRuTKAWwnchetKlIwcc7c3WgcYGbLyKUBtw3V5/PHMi5ggfsZsJyREgT2m326eUoiSBXQUMyInypFrrWtVd1YgJgXJOzInTDhzMBADnNB9ub1SVEjMlB4RoYYqAKKOflqWcz4r+m1/++t333xnChHQ8Hl0N1CfOBJSYEcBNoxnXN0qE/cU2Tdo0+SNjDQr6kDsfWQFtSLR3mQZi7XNtHWhHxhC12m7NBAEuAcDMfEBuGqA+aivunWC9JQVba436VR8QeQgKqcbeX9wgNg6qZldi9guM6EkNEJGzMxMzWBrb09HJL5JnuLF3h0P14RRHJnhVEYUrS95MA3/Q9BhWdIXKcEtOrlrJF2O7duV++fRyduD6A/vvdN+8wSFH6jZJBo7IHvcC+2m/RKgLNPL++fbu3EcSMN5ov8RxtyCBA6UU0y79sru7IyG6ORhQQjMQCcHCsB4nIjVIiRz6ZuMg21gntdbMmVamhCDEAOrQ1lXV93O+2d2spUipT8f3j4/L47v37x/f71KGnGJD1P6wV4WogDOzu6kKIMSerDHxGKnwhQHR91AMbl/cub7QDvqmsA6KOyDZapAXX4EwNvRuaSX0ymjnjY67duVmcVz48Ye2F7DlG9CZaua9KxRLbGiz8u4EMbRcA6NsMCmKsx2wBIRLDARE0QU3JHQz69TKq0w33lxYVnRJgo8ysND23rdG2gd26ReDxe0dbzjicgV+cDFgq1xdXa2Lhf6+j23SxgAQPGiODo4qwkTmGtht+yM08qr+jUuBp7MDB7zb/uOXG9XvrCFS2m5qNBttqCGLCiHvdokwqTUAVwE1czd0IMQpc0QHNDBXUlZXcCDolojoOU/ARIDlfG5rc4ciQgrq2qR8+/VX3373+ul4evf9m1LXyel4PB3mCdNUazM3ZgK3AMGAHgIn3llxGPy3Lf0dDSnoYk0YdYBxgTef/IF7umCZH1QlaGOSeGxBGrDFN5PCgXSuvthQ/1b3iUDlFHbdzckd3FU1OtHeM+kLSnUAD4aGjzu4BSVEBOCt5QTbxr4r6/Wrt/n33P6W+Fw92fi9juU+NF344PMP2KPXkOKCFmFc3h/Anr8fCmBEq/FSuxmHh0cDVxGHLtKz+Xns9evLURzXDgbY+cHLv2TzV84BwYc04gC4SBy3xE0NGNUdXNU6xg3N9c7VjWFEpNgv5ADhcAFgzwnRY+03c6YEN3xQrXVt75fjV19/Vcp6fPf0N//+3z48HR8fH0pt4Ph4etTWfGjdTJwAKLiGYebh75kSUle7Jb6on/ZzMrYchUn11HdLLgHwUuWEYXQAAI69hYkbrQijIAyEdNkee1H/vKonbZC9P3G/5D0nGEyTkGTpiXXHut6ZGXHewvDDfi+G1vOXAO+mFu0PJI6/AO5w0YH8+7cegvoaRQP7oY1uEGgDyNuV+gAYfWDJPzgGHwSH/9RH3CX/wcPGvdmeEAGHDBI6AKiIqUHI6/XiWK9lXWO94eW3as/48urJLg7m6jWlgC7q5mMNpZtLFVcnRgIQBIudbd3EgAaYtLi4I9Be6MiMgKYOKtr0TBWL1HI+v3399nx8enj30Eop69rq+vT4/u3D2920f/Xq4+/ffm8AWtXJE+eUUjQkAIHGVhW6LNbCUYHEjoXGN8fCL9gogv2CbQXhy+X+4AbFy3fvrO+4x73QOpow8dihwdj/Uk95x56Cjlig/6nRcPA+nowf2gn2thNubYDxWnvRabz+HoBCEoYwJe6c7j6pe23xG3oZHi8qYtctox8Mylyb4shXrtH/yCt9FFeuw8RmctcfVxAqLM9/+Fi8vFAY5gvd/7ibmGWr0hz7XkaC6PR2B+aD3wUwuO0wUECE5at7NCCcd0LQ6MekTueOGwduZmCubmgo5ikJIYpIThlxw92A4BIpgjnh4Hvg6L7FhVJVk1XWJu10PD6+e1/O69vXr+uygNnj42Nd19vDvJs/5Twdbm++/f5bAk+JDXnK2bZpmo71gZkp1J/D83ZH3x17f/MXwcP+vq9dff+nm5KP2xBB8GLfCBA8l/7Oel4xggxsR2Ub57jg+G36/toWtt5l3IT4tV7R6jigDwNcWS0GNdrNt1oWABKxmzAyU9/iCuaY6NIyvsYaV64Wg0KzWfzG6xn++5L4bjXDa7Az0qKLfV2Z98Xof0+wuHzxAQbqVwavHjr+MUDGoQNirgaZAACZQa8C+CWh296OXz0Ldmu/tAg3uH+J2wnxwtVyM4tfI3ZEU21NmUnBqVdbOQWZ2wCtdQfrQ1QrkmQENFdrpTU3qdas1bKe1tPxdDyiyzzn5Xxa15UzY863c3bAIm0tlTDRBGYEXfsJwsNHkZMTu0PU4HnsXIn31PsCvcbuA4qgYQzF+sUYLlnQ1ZW/NuJxdLBrso/IGvn+RRyiR8RLFo1Dh/RCg4u/RA59JpUuAR+uXmYH9w6+8cHgotMxBqqvbZKRUwIEisLpD8z92souZnopS36QqV/y/e0aQK8wXtvv1ecf2Pz1x6XL/vebBp358SFKGwjmyl979zkw9m1AJDnmzmFiH3p3HF9saOj3xKOBATaQulXYEkDM4YBHdxMubhOR1VTNAJzAgMjRiTwF08AEx4uMXwsvFusCa5OmAiatLlLK8vS0no/aKoDWtVprKUElQ7eU5pvd7Vffv358/xAm74gOmBLFNCclBkQmJOKwfYhTsDltHBq4cHGiwTaj7uuv4O11KOgG0T8bUl9bQPQPDkPcmI5UhvROj3kw1Eq7JfasGbyv49uK1DAYLdCVevvNoyD3D9u/sjjfbghg728TuWOKPZM92I5WwLVLvraBnsF4T/eufP/l4Ti6qDgSyYvf2BgW/Zr/nlKmX/KJ339CLn+zo5cLWuudiqjEdI3RMMZ5mtU0QYIxm709PQIM0smwftxu5vUFjHJpt37YLjECIiU37eYDEYv7LzgCM4ObqiCRqLkBAzgzUmZ3w2Rg15ID5k6jMgFmaNbWuizLej4dj8dai6mVZV2XhZBymsBP7jBP+/3NnXz1TV0rxYgPECVyh4QE5GOjLjInByckjwrPNZjGUeBABIxEl/Dqx9ulw+tLsKGcgSovvc9ucSPo93Nkg0MSz3khWWyGdH39rytPW6ZH10nzsLfNeY4G7cWErt4iYPRHE6s6MVHinvdfPw5+35cwTjOOatAlAlxACv7gVz78g1ftg2vbvfqknx3/4Ec/eEmXM/DBcwFeuSl34Gj60/5wMDXy7WZs1KJxiq+yvO4rNky3xRjsrzkKSmC9mOFmfYcw9Gvjo3cNbuaM7qCurmZuToyUHcHZXdDBiQCs64LEEmNAVHUI4VytWhcpJ6kn1wJWrTZ0TUzaWk58e3trQGmapMlaShGBRIiciCixgbsjM7l3OfwrkHNpfw0ojxhOuFObut/qXa4BGi8lMuyXbnwx4uOVZULPqfud9XHvu73RVgIax29YwgWb4cVFDRMbcASuyDL95frWBUW4pHVXwAwRwU2i6U6IidLFZLt/9cvr2Gxus6vrE3f1xB9a4miD+Q9DygUh/ac+rvtnv+enHyKoq/onjCs8Akk8E6FjIkYiw35BHIyGxQ4m1vhDeEHjeHm7l9e1JT0wChWEmMx9kz7oETBeiIXkGKKTg7u6uhEbGJCRgcWycuq7lAaD28BM3K2Wcj6fTsfH4/Eosmpp1kRqFZFoeWCmw/62qKLCu6fHb77/DslTYqL/f2n/+iVLcuSHgT8z94jMrKr76AeeAxCAZkSttDxHu9pdnbP//x+wHyhROrsSySFnhpgB0N3oe29VZoS72X6wh3tk3W4MyUCjbmZkPNzN7fEzc3NzFiIqzCogWzfCro0BAMVmRR3ejMiJCUbE2QZoSN1k/pDlUMVUJwXbxZr5fM+QghzA4EEKTeeEM/kaXGURk0gX0rAzznoBdWV+dOJXbxHNVVLCguStXgWA61Is+ylchzvg+0oNR1jp7rAXTzyCDI3+4KOGIB8ec7Re86udgHOFrnw34mEjsk8gKHHtoqUsk+JiJ6QZ8FRiGblyn8oh1mfak6aPSIFQIQFnLf7q882+BzSzZxtasKK72oq0AyuT1UVF+r631nZV/fDhw/Pzx+vLS2vb7eXldrv2fbeVOSJKTLbn7lLOt9b//P2fP354LqWQrc8qlQEq1d18BSwcCRQKNzTSbwIt+kSM+E+aca9c8uuWQZxOY34AHoAb6h45szEizQqNjewIlPsyqZXOMnKboY4008CZib1SYikfbbBrjgZhijDmqJMvvAc7SFPUUqrVoSrF15bT1GK8YtlhaWLEg40PfK5pll6ZiFkM9PUp5GB95qChGsalYacRIDK3Twbgi+1ELD5ptJC4WiPnJ82e83s23nqTgHVYntQygO8RpvkEjT5o7gvkeREGQUFcqqtCJrJ5685dWuuttX3bdxHpfb/dbntr0lWaQglCUBRiKVi4qKArbEb55eXj93/+/sP331s7y1JBXJdqCxEJLDYZbIk7ZC5yxg+UHIzkGkfrMkOFoiqED8FAI2E+IweaJuhoQBFB5jF+wV+HGKemTg/fGY6BPGfUx4NHDWiXskhOt9Jl4Z++0s4OftxQQQqX3joRmEoti1WmG5DmhxGIxgCbgHmQR9PuRD/JWUbhQCTUgqHESWj+Ah469CEx3ZjBHQNzaGW45qoALUSVlEQEIC42Dxvhdk+RHnY7qR8td9WisRokNZmbhlK4QnPCQwMVIMYtYnIxDaIACmlX8tSDoipd29Zbb623Lr2L9uvLS2u7SJPeVDqpAL0yK6kqekNnAbg1gejzp5c/fvfNjs5Cy7rYHGctBQb17JU2Nw5HzQRPdIuF7olYBp8S2EFKcMdAPQei5xy+a4+A+68Yw94Wcwj2SJ+pgIN+8omig/GdflF/ElRNmyAjRzNgRfKLN5xAICGr1CqlFBFVVrY94VQ9gkT0KrEtnhj/8l3/J+ZLiDzczInNEyAfnvzqy0E8aD43SOkiO2bd6G44PNEdKMzrabXET9XOmMYTRHNPQ/OPyAKALBIBGhGToa1AxDXwJYY0xcNMErmQdhEoIEVZmuzY1rUuywLtre2iKtK77E120Saq2/4i6CJdtJuKXkolFu3aeuusaDZW3EU+fPzzp+8/sBARXc6nvXWqxZSndp92ZhQiW8yevc/oPmXMLqKeYVmZ5sGJQYksxgzSaIh/aOLJhA7VimGCodCs85SjgTGkI+qYpl0jwyZz8iyB1GGSJwPHa0JOplYTKROEmVRsCTTVsiiUieQHkcd0qNklnRnhNfv5T6qEA1of1sV79MNvufuLwZxT7ybmpfyJ1Eqk2OZTCkDP69KlVTohAljsy4t1ut+Nxlxf3jvnUb4x6ZnOMRFJ7zUY5tAhUVMVYoOoUcG5dbm1re1tWZ54LVCQNLHpOulEWmuV3iEooFKZ17VUkoZWtW1b1w4BbKkkFQZft/37P38UqACnuhTmXqCR1E8MIqvxZajCi9R5LpdFfiyqrr7qWgJ6W7QIlCtGhx50Gxd6KHzf4HU30pHg8LkBpmEmxxFugBlpqGdADD5OeUhz4TmaFG31MTsaINsuAYFBBcpdRFXF9wEatuJ+HO+brgr2uWJ1Sg5XwDlDoZ6M+kp5+I9HyHJPnXuC/egv46ymg64w2tsieSKqXODaREJZC8jWh6fvf+ffm/aKh6emAaBTxFl9TTBe9ZfyCe7hCQTSpffWG1qHsIAJYDTZlaQupVBRkZ0ERXnhFbUtHa0ASxERbFtvfdtbs4reeL493/b+/YcPqlq51KV0EQDau5CzPzNAtuWBjxszD0tHFH6wR4MPscBgCBflEbXXUPjqSnEMyYC9U5gzAE1EhhBBQn8exdsiCKVTasUUSh3DrqoWzspxsQ0QYFP3AWYtHOdOtHtNUCWVzsWqv1BkQecNPyQDBGR1aIdLsyINgzrpeWeUI1C6u/6OcT53RHgFqWSOt0+Mm1DRnVAGCtfFukkoyLmavD082EnxD4E1J89HcbpSI5jH6k9Ip8gbpCEyGhvME0jVyhqyEK7bbdtab3I6rUtBBUg7SdfWVlDRLn3X1qTvIr1Ll2Y7yvTWBSARennZ/umPf9y2vrdWl6W1rogq4RG5dbfXt76OSs9ERGx7aATwhUfEplzeCcpEDFTNvCNcMq8wEPEY9XfPulTzHj+t4SjnB8nQSYjmAVZQJCYho/mzLLjrEfjpHk/bW9Q2EbekCCIuzKXUWueRn6HNZ/4CWXokY7zjxzuaTcchJWjY0fznc79+/hhUDWqqKaM4q0QUS08BwrosDJQJmRG84oMrsMSNs4yS6zFTi/HW0A0B+e0RdUSc8y8FrUjJCs7ZCEAJrCLrZSVV0b61fSGcFtIb39qt71tre9v2tRCElWlnRbcacVoLs1Lr/XrblPbK59u2/fm77z5++rSeKoha76WWruobQ8OXvqpBBWZVeE7xFHyBjhRlgx9eKY+szYk/lYCRizOrHLzOUpl5iuYr4zvdMbpp1tAh07PcMuWTEjxFsM0+jjmgCHB5XqoExvXXmfNTSikdtVZfL+pVKF6rf5pMGiYVrHPc1i/wiQBjHXeEw6r80HH3Rvrs6c9ZpQG8ZrtBZNNQnYkhOK2nuq6ZdBIceuxq4pnEkODM1s6Y89BicJlWywZ19Z/NpCS1ndekgIplqVUupKQiUghKXfaOvhV0VUFvql2lby8v+3bbri+993a7tba/7PvLy/X20l5erh1cWdou12vbu1yWRUUY4MIqKFzNzHEpbEFgSFgghGdy8NLGHIaLfw9bQqpiQIpmNo/pA2CYXUoVD9C0Y4CZkLgUGd8ZDdAp4dBH1jy58ApSrfimSRO5o9G+owLMiFmGG3HYKCKbxfbdCkWk+DK4TMGN5ZQHyHL0Y0ltpw5KyDhA4RCJH+LvQxjtcE0y2sTeP/Qt3xmCPp7pf5WRi5jxcLlABSjF5koyG8LFM6r3vYJTBt8PIeusphn9B1CnUYwB9o46iLJyNI5T4bU5uWNhVtmp9ZfnD9vzs7Te9ltrTVrrbZftun369HK9Pn/69N033z5fP123RlxVadv1Jv38UD48P9+2Vrn2riCqtYBprcWsTaz0MgRAnhU4qYwRz50oS5NYOIuNBdQRBndRUA0EGFI/6/h5WjSGiuLrXexywOpkaW8R0RSAGzO85o+OFQYDtpLnfvrngGCQ0P9CQlAV5kiAtRQhcwVmY45UZ04ITOtFg0nuoz1IeUg8jBAwHcGU15ZmfNC7C/Rw9sCQSDYbkxOqUDCTJdeUWn0Lgiy7hPBpCSknGlgyTOjQZ/k2nyhKJleQVYY79mA0j1y7DKeMgFJL33ecFiJlhnbZb9dPHz98+PD9y/NL27btet2228vzp9vLy3W7Xa/P7dZf9v3jp08PD0/n88NyWanpvrVvvvlWIFqotw7mZa2lFtuNr8AXLgeIoXAL1PWX3plmDbacaB+UCbjhfdZYw67pFzn5h42cQLL9mhH0weR5gg5DfrjT2hxZwpq0dDMhUE60ManFmUkChvjdDBVUXjqw1NWsgBtGmTj5NTbRMeMxnh7eeqrA+c1+Hx3OjE/jgdNT7yQwe+MBlTs2U49O2AW2zt2nX1G4LGVhCu1iVWD9icYDU18Ik7KfpdCbFZcn+e0BUhP4KYIa1jkLqsR6AirMSqaDwWh7u1xObd9uz5/268un77//5g9//PT88eXjp5eX577v2+0qvXfpS6XTwlTWD58+vmw3Xk9vl7eylr//T7//9PFTE2IUEOpS61JhOy0rQKoUK84ElgIluXd0hrWC7537veBhTtdSgFl2h3XQRN2POHqd95prGsGhCqcwgiZfI/Rp3jGiHvm4rFXmao8LYib4Ff/kcjAabEgEVWYSVJK9l8q1LiBkcvaBu+5eTlOTdNgrGj8fbp6nwQ8SM/HceNOPpcmlTN9Z5zw/2XGXcohIKXw6n+FVYDEiDP5Ut+6pOQxLZhgwTHrYHY81zO1StwChBEcvQnU6poAqwAwS6YBSYa607dd2vX76+OH548dvv/nT7fr8/OH77Xbbt2vfN5Gm6AtT642IqSyXh9P1toO0kRTm6+32fNv21n1FI9simAooVLoSAUzUVdz8GimD8cm3yfDZrID+ySNs0cNIkrbum2TwNN5hOWlCUKH/DbzMMRad1EzqEQBR9J+UdFoHk21NUDRxv9FbY1c9wsBoEXpOhxih4ExLEooSsLd1WdZ1BSCivjQ1+fBO/cenFATv+xyvDUSUyCGaPxPgc/jn8NZXUOLQgjtrorj7V1yjGD88Pjx6aRyF+noVD3Ck7Np9cycQ6HUgJjq0OnUNIYrjJnYaDSRo7mujaqk1rETAZb1UZmnb7eXlw5+//fjtN9fnD58+fbruV5XGRbw1wntrLy+fQLw+PF0eLqiLre/d911a37e9dT0/PiInhBging9l/McoClUR80pj7T6sVQP9ORUw7ZgCc5pt5aSzG4INo8sIbHIYTaOWz8blRAHNhHPrYucJ4VUFpSMnQmMAMKu8aD9HWWODmve8E4pJrS/+ImZVZjAXrmVdF9sDJJ49JGZmrAOjxK+vNLjqsE4D0IV/e8+s4+b5c4jvuPSuW26IUu/GQ0Oj2K9W2/tyudSlqmpu9hPPHpLoOsgGJH3Y4/sQIpSXIiaWKibk82oAIjtAlEC1ViUpXBZmQHrbnj9+f335tN2eFZ2LPj6dte3SqO1727S31rsUpmVZYVs7ltIFRLRte+sNkKUutvuRE0wUo4IJEYHZZiHCUtK0Yp1sRb7rWJgiDJtu09Mgyh10gs9tV6uctQ2HIqcJQO6PqU+TDV7OtZQEILYfjLnbaUTDR/sMk/gaMd/0W8M+gOaHpDgpNIIisKB07N0s67I26Pl0mnT0ZARmXTzxw+DuUJGh4TCzfCKVZLTPsP2PhUfvs57tlmjdK+kMQ+3UBlS1lHI+X4jgaZE0KB++TJyKunfx0Azy6KwRQs3p3HJOOunhvzypolDPDMVie3QRZN+unz5++vP3+/WZtBPaw3lZmKr3ove+9d627dbalUhEd2attTw+PShkb1vvncHLcqrLorZqFiye9qQAClOhYvColELMZBsEc2AT088zbs9Jbgu9TMIwuuhRs2EkNagUaApp+b0xaVsP/w47cAcLRoxthhAO6Glcg+m3mI2h2NNp+BvkD8mijwrR7uBpWRcuxR4Uay1/AIZM7aGpYTncYzoqeu7B94w+RKt+5OnkVoBG0Cypcviudzf6iyNUpaLM/PjwmByt0Rg4OMl6qmmCjR28JvgILPhlhKCoPdE0F+Mzh7pFJLUyYiAVSG+7oEvftUvfb88fPvTtJvtOItRUWte+975LbyIiok36bdv2vbfWpHUoLXU9nx/QZb/tt/26nJZSaF0WggAqEOJR3lZNjZCXp43Nv3MTiwz9qzm4ktFDgGJT9RwxRZj2tJLDD/ROx/i7vYnwKA19MDMs5gGd1F3MqGcjXee59KWdcIMSSR6BU7MD4xU5qwkMxvI50fW0lGpbKEwR13vde2jm0BbRX1ca2bvgFBCGyCKExlgjXaT5mMwjkttSrUSHKCXleNBMCOC0rg+PD/P7Uy+FjtC8PpZnpI7wtO4kh2Iy3hRwgsgA1mdIFgPh6tSKlNjeIMxQkd73fd/6vknbWm/bdrtu1+vLS5fWe0dXUSEoet9u15VPhda1niDoot8/f+RawFROJLhxgbJN7pBHRgIqAAVRKtkLzjnm0OigBzA9CpKZ38xe2oRiQKP7Ggk4ekgvTUQf1I5Sc5RJlDRI6j5C6seoXeNfbRsXWK7JRM5g0bBd5uz6nQHHQqsl01rWXsSsCMS1qjIVWpcTuYMzw5jPHUO/m1APlyR+nCAcBpqa5CQVyJ0uf2UUokmTwrChokynHQglR8b7RuZwFi7n09nK9+sEYYcKcPfsFdojSqw6DalLxAjZEcErw+l0e0DdQfsATVbYGCq67yQie4f0Wvi2iah20X3X1nTbe2tNpYvobWsi0G3nRVCrlGVv/dP1Zd/bvvdaVyZqbVegcFXbSck6rMHobvpsfE0KNahuDKNKvqyTzDYS+TyhVR03Jaq+QaXrL2huZRWIWCl24QpodNC8zg2Rr0KYYSgAW0GaKjJcZA3mIURs2Z/nVSGMKSke5MDfXzTxpG9mBQIpMbN0ZXAppS5LQIgD5P38MWlemqcRQ+mr05K9Gkk+2JVIviIf9Lk3JWa6k44BJ92KzSKrUHfqFCrgSlxK/GQ3ZwWDUHUI/R2RztAm09j4QAKhJsZpQo0xcitNgyHuyKbmCkrvW9tenp9J2+PlstFNZXvCpdbCvEALcFXa+20jSF0v64WeHh7L+u7Nwxd8vvz540fpRbS83HZwYeIunaa6V6QgJVFVEpvYFxUIK6L6kDOop8oF7/oe3qZ4HD1x1vfMzWAA2CwjNJUxkseDEFEQCFZv3mQPSiV2uB9O2TwB56rCGqiRHWR3DPNOMR9GfpnzFMWs3Supc9hAMUYEZjYnal1Pp/VE8KU1P2IAknSD4Q6AJV8XCsC2PvIk9DsUMdHqc8eYUcRQHDxv3JuMr/nCaTJOQYTCtVZzKjEVfvXHe7mZFOG0qwhqhnM4kMKwABFOMgGY2hkPS1bzOrO23zV2aVCiD88vL1dVWta6lqfTytfb9vxyW0/b6eHp08vL8+122160yyPenyp/+eaN6Pn05kst5yb8p/J8uzUF7SIVhQCre8jukYo4zrfNDjjWuwzXfcixxjf1VBlAAbbybHGHC7eGCkklpiPQ63rHnxobvMaOkQTLw1dlSuATYML9jTkem+RMviXClEh/dCyDFdN+H3kJIWAE2DxDFKPhQktd1tNaCrVG7PtozDr9GIs5JOwQZVw/dIDBgjQFQE6OR3fCQw6w5iGseX4rekgJmOxKsYSu0bgUN+/m0L0GTtbFr8hQLCEmBCnvGfI01M1Q8tOvB9Kk4FTcDducUaiAbwKLQgxS6aLML/vt48dPQtubpYILlYvA9v/lskipS71s1/0s0itwKvTw8ABZ5FTX8+O1bUzcRVrvzBVExLb+K5RrpC+qQqCcG2kqwJBuin+yYmPcdBiyacBN1GPSYMwSEDBjDGc051iY85+GFhHfMMm0tOxQRaTD9QqVlrn2d1becFxk4tGUBmHvV8dRNGuhHB5rADOL1SoAwDifHSh7VrbTzwaenOsnTuDpkcGlycgeiUEQzT7kSt7sTCAcDVHJRuYQpEJXIMqeDz6dXG5HgDbzH7AWqKVYnYTwmC00rTRJbrxvGGHDAz5YfuaV1EVricuwAPOhYXZjkwlVYqitBQBQhCC7XrWvxRVcLVVWrdqXlVaixqqi1QrZL6soTutCpdTzIkWb9Ov1enl4UiibACS1InMBKl7kIQIzqYwI1FWGq0PhJlEop8GuYRszYK/TClpMCtdjjmRTuUKAKge2tInJfIi5FjY/Q8Hk4eGOpUkRGIkmOAMkYPKz/rNCh7RFXkPoLRPF4cBZhkAlVazntZTijOhTqfNITq+ZTCJRNlRn86oRFp64OBgVOrG1P2YyfNMx3jP2Aobmuu7QKxMViHxrD2sKA+be2Oyrer4OiNhHeMIFVuA5vaijWzwsDfkmk8jhYeYa1pxCn47cz5TfiMyqqvYudSmo63a7yd5EQaJkuwIoMYiFqWvZVAvXWtdKp9OKTuvpodWFb2Wty3a7SZe9tTNWU4WiQmTF0Dniz9HsVKmxC2DEfHzrgAwdhsIdVjtx+mQ2XPENpZhJs0YL4wqZmDVrsdjVmim4qafvAIAzu40ZUwposJSqim0NEMHcYQmODc7ypDbCatqYAC1EoM4Fl3U9n0/PL1ft5sDawtFQ+3OnhwxqFEg6YIe8gTDA8mD3ZPrDk++4n8ZfChkYt+s0Tt6rHIkM0ZjiKHXhUDRRpjjFlMINpFCNqX38xRMAnnyq4Al7n4hEJGLEp6OdPiyq4vtgGDt2EeWyns/LukBLb902rdAOAXXVpiK9EaEWPp1Op/VUCgspWGphLiTavv/wHci2fEYp1Vm8+6LmiPr0ICmZDjBZUG+et2d81tjrPZWqqorYhtgZh0l7PYy4/SO2l7mIqApUVGzeIRRwzD94DNHfqd4cRQSJDYk5LPIpFD8fOM3jmiGik3+MjI2G5We3TExelF0JgIgAiq4F5Xy+nC5n0Qgcm8xSphuE2p4FLC4KWzXSnPOiwQKDySd7cpCJ6ad8w7Alx0GZzR9CPDAUBDwTHuu6IgOoppeD6Z3f/TcK7g+WsOf6WJsMDSBA/lbXYqzDQoy2x9BCQwxEVb1YPitRPZ1OpwcFC7FyIRT4BC3UHH7itdSV61KKQLkyWEG9oPe+tb7ve1tqba0Xjnx9gic7+QRS4E7VlEVjUSdujq6GfkwZDyNifVBjZnH/N8sFDZKP94it8NfxXqj4BoIUBUfJeNndxOGKDOpls0yzJ/lHxp6P/zx0Pg45qmTVhWiMsEeC3KUWAERrXc+nE8PzoGJyM546bNJ4zeRnD74JhT4wYZrf6eLXx/FkEO1eIu4uPuRYU6gZF8AuTtFSq8Ki7xxe02GCywY5/vjh3IOwDgYN4/xQgIBCK+7izdmNSWHYyPpCRe19l6Jc1+Xy9CCNSDaupfRlqei7KvbCXGs5n9al1LowtNVyXpdT48KlgNC7qNg+L7TvnWzvr8KJwZhIGDUwtqH2CZqR7RUYsZuRxR0NpsmozWhaEYZfw3yETU/bmOaSBlcaGrFvGlcZbw9u8pBo+Ivx60AVdutwAN2Wm4KP0IYrsLAQCIhAgGpMbRg0YoLIwvVyOlNh6Z2UmKn3HOchmcgH5nYOM1vO9h+jHQe+oAmE3B9xnu59h+ORUSm9ezQiLul15UnJC2MqvIKNRNMxDDd02hHJeTrFT33hx8zHpoLc4SdPh8Yx9D+M0sRXRBTr8QqTEBesDBVWFtqvL7UupGh7FxFmXi5r4cpEpZRi+13XRbkSlVJLLeXauj+wteW0QNWiQ8wstseEq08iAjOpsiqUY9mTRud9+Cy+IrBMWoLblIA+9jRTFgjbEAOmvttTsLITzu0fbMmtCydgoVNNWQKQ5UWINEoGwUI9joQSeoX90Bw+z2IfgIz8RRbcTfPtERmFQgoVQadasUtZy8PT41IrmnZR29jTghdHOBNseghODsVgraMQh/HXP9Fwj+94+nDHjx8/dI1OQQkiBRPXutAU7R9TKRRhUY8eHccyupwxiXzx9MHT5MFRfW0ESQduo8NNNj2n4rBYiXkBF64reEEpCnAty3IyBFNLKUs1BLssK5XKVNBxquvTw9vCCzO31glQSO+NCol2YmQc0FjW0ooIxFzY98LzHUljiVDwdYB0AzHQUOZGNR5M5s9PZwhI7tdUfQ4xyzFdas6fCTwZWDG4IaervS0K8V2vYGn73dsIEe0HsGaAK3oRZ2aWiUVfRIZfmWjh5fHyuJ5OAPlGAfCXTwx2+OfIE7P6o8MvcIvm3GAo7AeNwOs3/PN+TslEBGShRFRrXWpNDBNGazLaFJx8MLPhN+Qjo/FByzD0RkMKwDzUxNyusNBpWITQFF1pF9FC4Lp1ECqUIUy11LKS0rqcKpelllrL6XwqKKUUKJZlfXx4ACDSARBx77Lvol20W84dpIt0EZHJZXX144zPtt/1IGnoPSQYTMgB8lBuqL/oXRiDCMSkXwGFhkMxVvcex49yCEKtBvY9HMP6TlEGilhI2HEKDAuE0vc4Vf5N7YcQFSihKzqgcjqtj4+PXEKBz/gt6PcZxkump89dNKm/GbO97uQ/+6DPtwNIEw4ARKqotSzLgnRzfZRtNmEQZ1qCN0eJg64exYcpphF/jn9VhHUKi842QCdIpTrcS4tDiIowUV27khBvexcLvwmWZWFGZS7Mp/N5Xc+negYxcy1lJS57lybSRfbWrHGtt9Z6196lK0mX3nrrEX2yUXf/17UjAii7aKhm9R0DMASg9zH7ghCOZHkd4zgtBg5A6ElWIK+zkEYj0X2kxw1bQ+nsagxQxnMS5mf0gmcenfrkrC6h9mK0Yk2EFSYAmfUWVWY+rae3b95avC6s04G7fgB3HH+7Z87U96H9/+Lxl9X/qysGQonCTQb0BMuySO+lVNsOOa9yBrd84WDPHFP1MLBBZ5KhP6aHxItEtUYTwhEgN8R2o1cC8FF3XOzbdWdGJsrelUUY2tCoUtUTVy5UlvVEnDMhRFxU0VtvfX/59Hw+X969f4dGgt5VZGtETEzSRVRYiarDabG105HQANvMz9o9B3s02ndwAe3lQ8M61gnFHWuQEWsSOUKZyeWp6Clc6ICSI2EsaatsNewnl5Gm4DPSH7CJjAKOrBsEss1njbcHCcnbzJYC1tBqWZnl7bunUuvebDvX4xqdCdEkxskuYJwYytOaF+2dGfaH5UD1B3/6kcOePy/VhNreFMu6UmyIGPrb7jgQRKPUxR2psuufuw0g2O6DrMH5gYCmHpvcEEJ81PcsCy2qHWU9iZIKkxf5KJbPX5d1vZyN43dpotqlEUGkibbbvvXeYuEATmWVrn1vvTdpMl4/guGFmTHgmvUwOSmpMdBgApujLEyBY9fQg2IBRn0KJc3ePLLpOcSoYLwLwXl0uDIIp2pTDC6unhDhcxyqNkEtgMWcrcyJjofraGNCU2aFtraXUr98//V5OdVaiJkLu8n5oWMIB3Bkaouaz9OhAakmSPQjYvCfe+To+H9qZr8wr8tSazFkWUvxoZsEGIPOlNZBHfiYq8gAK0jBmnHRbL+H3wiZ7ofovDdKVdUBqpiPaSikA8S2eLf4ci1q3bxXrrXue1vWcj6dtHeRvm03Ltr6BhZmiAoTttZu++12u3LBcjr13juk925QI71aRxCxCsyBiTXMG0xI2PZ5JTROD0B4pP/91XKQrBz6iFO4es8nTMqJAULMIiA9c81S8xFMtbX+ChFpIlZYvrdmpTQkcpbS0I0IiCbc0gor7Cel0MPj+XQ+uehbLZmYrQ5pxfwopMp8zcxO0ZS2mVLJqhPt/iv9gkOjnC+XdblcLrnMJw2XWVPC2JHT6+CDSW2ysBCsniJDGShASWQZ2FfCBisrDqpCkSX+RmDOxFLThAbwlS5dlJeliby8vPQuzFTrut228+lSl6V334GbiqXvAkTLsjJXFb1dt0/Pz4WXwr4kEoTCthm2FUKE2AZhh4FSQ/nhCoU9iOEy5g3n4ajED/5cKO1UPTnQpk10gjcHKEFDe4afmtSzU5O2nHVKOHAAbGpZesSs8gCURpvCYx4tN//BAiKsxWbXC5/W85u3T1QsMhZzfk6Kz1q6iMZ+TgfckWiww/zDxLKhgv+LbYPefSmlPD4+wjL0KKw9wVw9TdmlnH+F+1s0GpRh6AiARNwhlCjUZhYOPqBGc2aRj+SZ6T+LNCpR4Qpwa/3lelNRrkSVl2VhKiCxuraAiDSQLkuttZ5PKwh731+eX0SlixRwraVwJaZSbUNe2AZMsK54eNiNfzBsTISlEp6YMccowmeuS5Ies0xN8EIJvvokw295AwXedGM6kXc6wmekcM6gImLVe1zMsinw9KxwGULhwBe/W8Nyq2DbJpCJGQUAE5XCrHQ6rV988UUpkZxor58054G/KPuTFMv+YIDPsBzJE5PWn2Tjh8785YNefTAJR12W03oelHfXK6bVXQamLnIYRrvcK7yPHStdE9Dx1VkXiMb4+/f4c+x0eBYiCiZ4JnNn5r3vKujrQkzvv/iy1np93kS0Ft/Eh0gKgxnLUurCFgu/bbeX69USM5gKWT1cELM26QnYVDVGhJkhIhR5hQ6QTUEc/MUB6uIaIRryHhvcHxSZj3Q4kEQg5gk8pDrwkhEjSu7RtCGGzr2UhSXMgeoYu3zDSsAS5x2I3Se9XWHHXBrZKyczAGVlpVLKtjVbvfn09AbwOuvEvpYn+kWR3j2zH00EGEweX4d6uGdrvfsU9lHj7z/3GKxlWfehpLnWWmuJcJlohj5jiMOShu4OY5lNj8zBdLCNEshxMjLy58yWZZuEMIWLhrFInBEFnWwtOoEB3rfb8/Mzc/nq/ZcQ+v7j9+Z/GPjiSlQVJKWWy/kkIrfbbd/by/Xltm1GQo66vrb1tZW/1EACVgk53DvHw6EaA/3aVGh2BCADRZpditCZDtYdNHRDiim0qcmGmpgpcIXqFCOjJPOYNTogMH+vRFxsmub1Vf8YcIyyJT4MY+xhvoNtkwFDUlB9fHhYT4v/IhrbxhwHOB8XzcoI/BDz+N9MxjsG+cz3OxPxzzrCUGU/4fq3LtUTryhCyQBS3RxDY8hROWq0OBUq7fhq21VhTHNSMNGgxnQTDb8vHFEQcRHpAPPCy1pfbtfvvvl2u92eHh+v29Zv+7quVtSma49az3I5nx8eH8EM8O22GQ/UpZZSysLELJbCSaNCBFFOiiMBkeMw570cMJ1IawSIPHMPr8wMP+imiiisaNY0/G8HXJYl5wvkMo5JkeaQgSAX0YntHAQN+lKE0Syo4PN9XTOfjybDFfFJGutY8vnEtl+tEEhVzpfz05s3hkzZ82doDKVmc8LfufMLUvwUAf3SAP34MT3tP8sHmEIJQxcQqeLx8mCen++IAOfsSTIn9BnYfyihqS0mnQH6Rgs9kJbN0ExU9DA4MkYwawiK6wCyGhFKdD5f2i636+3Dpw/fffNta7tCHy4XLkWJqRAIS2UuwoXLUh7fPJ5PJy4kIq13VVpqXZelllq4gMiSkhlciAsXJ4QGq5r6CuUbLor/pqoi0lVFtEtX6CgX53u9q8cZnXM1/KhA7NPADhcpYpW5UZMp8xkvD66PYQprQemUTrha3aardQbBmRTe8MwWLurp5jGIoKxcarWUqYeHp/dv37EXUipDZg5wObhs8MbB6Y2zUxCXpmDRHX/TfPa/RALmD+lKl8LLUk+ncxcxlOFKxSV64P/RhDjmrui4Ijof1KMINvIE9iZMHU84KIoDhHCZVYC4nM6Polpr+fT88U9//Kc//ekfF164krQO7QBBiJbSSHtrl9PlzeMbJdr3vrcuIkSodS11WZbVR4+ZiEoptvs8yMtvpm4NvZxZznAIb5DAEYAOKhHlZEbQehxz1kWYWyRwojCyGkgfoUjtdUkwl5aINgTVNSlOWcHGRsWWP+RSARrLCcB6GBcfB02/m2yfZtKlLl2l79u6Ll9++aWFhWopRB6p4KQaAhEMCHS0h/mi11x1hyEObTu0EH/5iKffMZppcFWBXi4PtZZSbEqRgnXNBTpE2aK9NFsRg813uGdcm5bO/K8RIwxFNjlzaRptx2CXAiVSok4kzAooyVJ4PZ226/bHb//0T7//x7ZfC7NqMwkWNIFC6ba30+X89v2XNsUtXcLRobUuTFYTspRaS7G9C4wgCFQcitpKdrl5VDUuGlrCUYTfmHG0mVnhsoy8MfS/Rr8VtkQ/1umGLcaE3TFD+ST5ZDwhabvnyOwUII35DZ3HcMIlY8hSxKz5AhWtpdZaOnC+nL/88qvz5ULMkqhpqoQTocOZX+cA8wwZDhg49fPEsq9uuWOzHzvyuQcONbBqFYEeHx+XuiDCnH5TmMfA4KGN3LkdLhO96lj0dWq06aO7lkcDg2HsB0VaDyUQmMC2WIkA6Z1Iz28e9955Lar997//T3/39/9BtDMRVQhBoCq0bV06Tuvl8eFpWRZbK9hatyghCFyYFMS0LitzUVK1GSKJxQCK/HfAkJmnJ2oO+JFgH7aORQdvHUc08EwQJND90JMuIxbYSspRmILBJDqK2I1IggPLWFdjOj/c+PC1STl2LwApMs1v4HT1PHHbpZAgooUY0DdPTw8PDxBtrYv0CfNgsMbB/s2dG6xAmWkTvDcoeOCW46334vFDB736ECSz8BrT5XypS6Vgc6QTkKBykjRHNd70I+vTgQbjdKBeHk1NpDv1dRaZbIFtZUcQElHpzMorn87nl9v1/HBZy/LH7775T3//d999+912vequVIjrskt/uT63vS+ntZZSS1FRAnpvKiraexdbl2jb4TEzbGUhRbuir+bHSnc7JuGhqswKFAd1mVA+1U70ch41VYNDd9pOMx6fdKJB9mBsxDgNa6PZDsM1GvjVxtA2UaL8HiMDx5YEkAC++gekREKkTLZeBD4tQF26ApXL6Xz68idfLKeF2b0OLiwjL5pSxqODFLwTnHLgydcKPginr87ck/NHjgkyxotm61NruVwuy7pomPfIudKk+WgiDb+IZt7PLsz09evj7bnEJpkhLNvcmQz8ecFOU8Fet0SVChOxsAJMSqfLCtFvv/v22+/+9N2H7/705z9te+uiN+mfrjda1rZ3BUopqmo7/PTWVSC9q8baBwKbmnT9mwT2hTyatRA1PWDEgkZbxxx8F93OER5QbxDdMQrGptvTuJjw2II4iqAoE2Lh6aR9zDwc+cZfGC/QDDwOywAvLGcaUJBTe6qEEcsOfygaQVjqUssCqK0sXU/nn//8F8S1+N4/bBISAinTq8MCHrTjnUccIoK7c8fP/xye/5FjpgQpgdZ1efPmbS21FPawAEf2weTzUrYtwiKTog5zOncOY0ARwW1GbMQQCkvzitG+0BjTJJxNtSmrrdrmglrqoqqn9UQFHz58+PTpmajst/7NH7754x+/+fjN91Wrdnn5dDUGFVFm6q3t+01td2CiwoXMbWRin8pmBnMkbLBXCYuouVUxUQTTa8CU9F8njR+6dSbKBIg0M0Kt1wfYMERpeliY59D5+UgdInZMqotXUaC50FAK8uJIvv7VNJTNEBGBiJU8q9rcBvONbDcQX1nT5It3X9oqHBNXsI5cL8VYe+nvpQj2JkEionhkHj1+/czn/0phMIMGKkt5++bd05s3tYwoODRp7U2MiAgNkDsMWfo5MVg/8DpV5SO40xjL+x4lCg2NHP4no/fee9OCutDe2seXl8fL03fffS+uN3Hrt6UuvXdV3dv14/d/3tt2Pi8qXTuu19vLy9XLHJgWDzkXiIoQgdgntdkdZgJBtIuhn4TaCJDt/BsSYcsJRqwngX16ComOUlqQTlA+IV5id4rGvruSYEtc9JKW1pwYDRMqPzmxW5gIIK4IW0/ptlu61LT+zxWTp8GI7Nt1U+Dd49u6nnrrKrrW0/3o+xqvgRamyIAGxQagSbEPJpjY6Yck4Z95vGoYCF1VBY9vHh+fnnpXhRab/eS0otHyUCpJ5rkv4XINBXb3Wo1lg1mPDTFiwSAZKKNxZ7iA0Bh0UvTWoHw6PXBZP73c2r5dP72AsV1vosSlPj28X0/nWuu2b731l+tL5frw9LQsK1d6ef70/PxJVVrv3Zi0W2TGlJXXAjAjYOALammSBNtCDFOTh7OZ/T8Y9qHdiOb5dKMADXwwW0A9kDA4dWKTQeX0EBSjGFECsBlkuxHR41Nd8UcpIXKX2bEZeaYvAUJamAksJFzKUtYmjZnW0/mLd+8MnnH1kl53w09DAvXA4gefYD49NfFgIP4LGP94DDIrFLZW9M3Tm4eHB8QaLq9ZTCG1YcGGssnAMtIwzAAo8MzRzNk2tqOUzvgnQBR0Yg0Nz04jCqkpfaSEstTCrNL//P3H777/swAv1xcC1mVdlgr1fU5U0XpT6M+++unldOqtA/Tycmt7I6K+N9Vu2+JRbB1GVjTPQkn+bsP5ViLFc4aHaR8AaWiCbG7Yh4n8qf40bRtFT4dXZE+TeIz7taG/B70Hn09jMo036djrwQeEjo3CkL5UxrFbJjCyj8AoFjdY67qclu229XYrzF99+VUpzJFjZIsDwBl9gtJBtUWzvSlDJGeC3nP/K/3/X28ECMRUa33//v3pvNKYEjX6hhwAsYZhhAAAPhZJREFUg7ghsA7oY7JokpGp+bNlc/3oBXuH4Zials5aqNa0NCFQSkDUe7dKxcuybNvtdru1vfcutLAVstwtxKNqNcvXWr76+qvHt09UWEVa3/Ztc2hMTBolMr3bsXBHgu9DGK0fQ9KHUBoesYtnwxUcTaO3mp0NvJjO8xTUiek2DFLEvZMfRhQJiDFMR6pOVmdQOmbgD5IyIVr7lgA4hYsAdO1MtJS6LOumG0BlWX7y859czicAbW+xxILT/aVEfHNTJl4cfHZopn724rjhRw89fn4NosyxKayi5/Pp3bsvChdmjwZCZwF0nZKKI9R6fh/PTXqqY5n8LdVW1ogBzZw0y3hgraEpVdXyshVkBX+7qHS5PFzWdW1t3/veWyNYNVFhVZvZFRHmRYkvl6evvvj6qy/ee+p/x+22We4DmXuXmpaQjpDh3VH4KbqQhRsS3qWNym9h64LJ7lTszPaqoZN99/bjWCVVZvJAM25zVwT6gKVpelmOSrgMnpZHGIKafaR8haonLQUaYJBPL9ey1FKZ8cW7L86ns90nom7uk7En6HdkzIntDyx+EMW783d0+Myh09/X9w1qGv10Xdb3794VLhbUEJVUukQxE3x4ULIzYEvD5wGYyR+fhmGzdYzR+fs+pqeYuNj+Z2towVCIRd+IuK71cn6wYGFvfSncem8qgsK2gw+01iK9FQaBv/z665/97OfruhCRquxta63FWkTpvVsGCBOXwf2ampuAqBXoMGwoqYQuaqBFotQKkExGr1ggZGB0PpON4usIlqUlCQJPScyHlhwGKdxhDXszgBmixQOyIcy0mQczagKx5XkWRhOvVgaAcD5dlAHgzePT09s3vj2CBGsbg2g28gdEe3yepTXO/piy//FfkyCfP61qSw3Bld59+SVFTmLsjh2NpYhj243p9kbaro6QA03jPDqZ0mcltcNDGk9K9sixnwQJPhNArAQhiaWSUC4LL8vTm0dGfXx4OD8+Xp+v2NpCFeClrMt6Ol8uXFm6XK+f3r19+sUvfrGc67qu0vu+t9t2a21P5d1FAHDhWNcDM1NzsRQrER7oyOIb7ioAFvexZcfapRsYcnVhAyteIcwfK3BTlzCJPHIuU2TmbhBVba2G/5yNO17mWCjjDAkrp58msUr/L/wDS3i2CYKYgoBoJyqq0qVL03VdC7Eqnh4fn56eQGRAwthjskZDqpFwCDRag/myoRTueenu8+vjnlLTh1dEBAAlED9eHt8+PHFhZZ5f4ONCWQwZiDlEpCWHa5YDghtuQ4aRCFaJXpVV7/qXTT3CXB2yo5zsI70rStma7Hu7PDw+vntP6/L07suH82Xf5fp8q3XtWpSXpT6UupxP59OpQneU7de//uVPv/4SDCXiUnqT1oxd0cUSOpXJC+SZXhVV0S4iXUXQRcXW/nT1xVb+n40mDz8+cuPMg/eQqEzgnqDpOc8c4vAkEEyofVWvdTUKtxujYkw+HADGUDCvYIY6EsLQQC4hLo0SARI/IWEWrPI0SERFOkBt7wxS5cfHp1q49+41vUXBzgr3Ix7KdMaGNEb+h9D/ay4OLpu+/eiRLJmIm8pS3n/x5eVyMYSdkhGG0GO+KYtJQv+mr4DMpEg+1wCKaswI79EfeHT5vLXpgVCunQITCoNIlPh8Xi5v3rx/X9czqHahb779WGmBlMILUGSnutSnd2/O5zN1+clPv/6//Pf/3bKUWiugTLzvO4QKl1oKo0ChAlKmUjKjEkqxpJlUBT2i8JFlUIgqka2ItrCNRCKfw0xX+YKcYAkSEMJbCC8LFisbQRCKYYl1VoP5NfOy9cgeGkI4GVOCp2FH0MIx/WSkY1lkcqYAoyNEpXCp1fIHfdqwQLoS6fmySlxn+eQTzh22PfFzSgMl5058hnAektleIftAnK+P7M7dh1gW6hoLSuBlqb/57W8LExcoofr+FQFIdGoLJQEPDdPxYVbjdkcsIEYSPZPhMlxocbXUAaO5xo1WMEpJUQQ+N4WqwrQsivLVVz95evvFp5f9uunLy2277jv2Wk+g5dZw2xpzWU8P77/+auvt6e3bX/7yr56e3qynpZT6fH15ud66KBMXKkTUBb27Pwx7tWpTAah3hzfNVuarrYPqbipt31W1QqIUqf8GkAJvuAa39QGBwwWI9f+hESh+hNrS3iw/BeSagtkEHyC8fx58NQ8N3UWwB8Xvi07nxAJiCY5zNhFIiclSD21vShA9vX1bqlVHAZcJFHyGRccpCvZ6xb/26UdU+ixUn3u8vvqA4EPfIYWI6enp4Te/+u2yrAZbiSkKJsV9oUNM23/mhUPBDFnJF6dPnDQMAZjdQmO0wKr+N5+gCgUhS+dDpIOpcIXy23fvf/azX/Bp+ebj958+PV/367d/+r7gtODURdbLw7JellK++PL90+PT5Xz+F7/+zZt3j6roXZlo3/a2WyUJCzMRhC3KLwrPFCE2vO+dHRDWeE788EKmQmG57KfQ2JPaSzffwpQwx0ZCI7v+T2WlobIQJmKoJpDvqXc/HINLNBa2DmYL6XH654KjEc8GyItleNzCvQPfwkZVwbT1balVICBd1+V0PnUJA5h8QmHb0sal/UGC3WOLKVjmjtn0+OVz2t8f8dn/rBsKhalSLYXevX3z/uv3VChMLMJK31EyzC4m7TH+S/pM0juFS916MwG5SZ6OYFzOth9SkPM50VVODCpE4NaEudJp+e1v/5s/fvPt9fkmZfv++eWf/ukPO51+/ou/eihvaq1dd2KcH55659Pl8asvfvK73/71N3/8fm/7qS6ttdY2Ki6PhX3WyP5hIshoimIwrg9dCqqpbSWYo+zJYKqiHlUiCNsEhlvEwOFwOTONqxHUDJHjUX0/fTI7oQiHwL+rAjTNw9Lg8XSy/bEUGih+4RhcIiJSqClzm72kKTAKrxxDRFSodJVzKUr1cn54fHj8/k/fIaKhySYaJVaDHyYLYPJ0bHFkR92x9Z01GC365x+eUNajxlMpP/vFL98+vrWIH5eCCAaoRy8GQAzX60eMEjCrxxC6GbUpdPgA96jOw82TBRgNV0tDt0awKHOBSru1dpU377/4l3/z3/3uN799+8UXL7eXf/f3f//HP32jRAsVoSZtV0Epy7v376TJ27dv/pu/+euHx6fttikEzK11Jq8tRdECnwmODFATUrKE1FjkiLCUOut07ygBEJXeuy+SVMAXYpk/O6DidBvSEcWMXTHDXWPYhLcJWlzFzpRLZZ7Y2tvo0jTEF7kn7OApNlEgAMSRG+Ma3cSSCwEiokS6rqenxzcgtxqI1T7p2mkSakALh2YzC4zefO6g4cL+Zx4DBDKAUhigNw+Pv/j5L+paRAFWhqXfkldgeCVzabwi4hnh8jQE4WClXdAwgWkcqsa2e/fCOyy7zq923UVKYCUmAQopqTZS1sKlLudf/PpX7969/f1//Mf/+B/+9nm73rauQp1pbzvVBV0Kl3U9vTzvp3P969/9t3/zN/+//+V//Tcvt1ul0rWXUra+m6urXqozxie4Er6610fP41/WTHEg7csGEomLIMqi2P1JBVd1dFD8Y2pwntoat+jMGqrwGhwzNFUPTETbgvV1aNDXOMIqsI4aALYEiTHGMqw+Z+E0ICplWJlRPq/n9+/fL7X23tWXE+Sw2gfFZ1j3DrHNk6MOMV/dQ/40TUL+8OFK2NdbqEDJPTpA67r8+je/q2Vhpn3vot1K15gdj9jXPRyinAGYlohZV8a18WmGD0ZDqws0TIkJzqQYUmP4qcDeZkEFoVkKodRVdb9uN3Q+PTz99b9889VXX//jH/6xrm9EdVlKoQtBGsmyVi6F9Sat//JnP/+b//Zf/rt/+7d//vN3unDbu9l/C+JTqcQx16Dak3bRCbNPTOPsaLoCqjLK4oIHc9IR7MZMk3Ey+ZOjXIDvS2hG2y9QnqhtT+Tkw2l4suIV5ZNokobQsV5gwnza2VjYDWrmMExLbJLgOpiZCxcmKnUhRWEulb94/x4EEVGllPa8hxSxlG4WS+/OAIR5KO51JOWfz4d/7o8ka9KMQDGtqqA3jw8//fIntfLWrKSRulYiB5sG4I5NiE5lC2YbDLffk7cwtZ0IwweIoUeoLacPTSIFJNP4HyFFo+66UEil6ba3pda1rnVZfvbrh8u7d9LKcjl12YVEBGBVMKF2cKVyfnv+7//Vv/pf//X/8uHTx6Uuqqb9SKSzbYvhykpEe2+tteYBII2yOKpdUcxceoalhq1wcJHE18gfzJHwX4ziFPF4gwjGXqn1zZamSon0PuahYV8bah9oJF9PEoFxFlGVxbPBI6RtLYNqLEF1BAimUgsocAIRM5datSsTl1rev39fltpaI0Uj1S7wmooOIRPaTbxzkNaZXTwy8krF6+wq/nMO8j2DnZ4AmKjyZVl/9cvfnC9nFS1MXHmfFrIZsU2HTSSehtBXUg1NPnqXbvQ86sAxChSPjZVnGqBLoTGdbmMxgnhKkAKgGN8RKTEKauVaO/h2a7dbX08PfK4C4lpRKhcudVVFFy21UGFS/sn7L//mb/764fGhnNdSaLvttnO8IxyCqvjSYCsnbXHjwMbZXRuhsJRzYCvNn3F3YHOd0HDIUlROGSMsOWHm8En8Ms+182LO7pBMYVCkGUIESP1VeUZwt15xWqGVfmpgM5+6BkBM7EkoDoo44x6qzFxrfXx4uJzOpmRdynL9tCKB3X1yXpKMDt8+A5dGs6dfh7Kl4wWfu8M0vIJU375/+3/7f/zfay1WUZyoVJ42r7CHekZT0nZqYE7Gf64fk7FF4iSPwQJZsiYhQECmZPbhfGv8CY4BkecbCEAopdaTYlEtG3gT7F1ES4wsKQqoUlmICnPtre0v7eHh9D/+j//TF+/eQ+T6sjVpZakA2YJ491wVotptGYpYbXGT4IgTJwBy5s7VtxrbDjmv45hPMcY4YzjDXKTai6epexHxhAk3OBHjSWO8J6P5OpMCQ+7igTbYAYAc8YdEe+5oTsARYNYPhblypcLSBcDT27eXxwsXZqvFGB5OcESUcZ/N0T1FPvd96s7070Ad4y9NJ+/7bPQSbZ2AspRf/dWvfvcvfvtwPov0vrd93wk8wjMHFzgN8uHdA1pO7Tg46UMKxqiFRTm2UnE/ihkmCSXmfTBX1bZ6ExWoZaqIsBZmMEshFN60N9sWy7e5IxEtS2VmKuB1/ekvfv7LX/7Vcjq3vu+3xkQiure99w7Y+mA4XhhIn5i8hmLUigvCBN84Q6b/OPUOIeIZAdPIizB+hEasx3+nBF1+UsfVqfWzEcMOSAz5PHphb+YfMiBPgX5M/1v3/VId1/qSDiueA7ZJEqulXZjXZX16fGImsnliv8l5Jf43Y5EjehtYIn/9LDvf33D8MAUg745Y3Qemp6e3v/3t7+ppqcvaVZWo2+I6UWSzaQYslCN9ePDnYFgM94ybJgCRN6XFjWspKvAO8DAY39lfI0sGnoYGJaVpCzhVhdi6VZBtdcdUAZIuhZmoiPR2u50K//avf8ukXIpCS2GF+FRu6GpV9WoIsfTB2la8cKJDI6jGcnm/3mPUCnNiB9oZEeAId6rVKhlOREAke79HXGdKDysBwNVqrJ/01qTjHv8b/x0G1MxrMD9iDT6oUPgfPuxIEiRvMhVmkJg14EJM9ObpkZmt/NhUBF9GK0L0Zw6555/RzgmtfY7VfuDeDKkM+OVBLkVZmFTrUn79L36zb21vO6nUWpkjFjPUd+KWA/0PQjl1YZLCo2TGN/YtPTGap3dONrn4DfBwb2JozmfxEyo+VOzbGBT2rb54UsRZwrapbi/76fL09dc/t85ZAhyXAlDXLtKkty7dwL/pWVUS1T50trdHhn0AjYQCjUjwGIK7jua/PkpTr7zCoC9jD9SakqAjImkP12msJ40xQVD/1xWb78jncN6KJIN8FwcK9uaJglY01epwWNiJyUURzEUgzJVLeffFe+IyjVtwkU2iDDU6WGTo/SN5fgD3fJaM8wk6fNXjZxElBvPbp7dv3jwttdz23UorFFpAGEI76fqjoX312rBxsy6P184axwtsVei4evpDw3We7gruMqc31cZgBPtdSElHiVmNvaNVKJgCMeR1WUhZO8lPf/bTd2/ebbdWam2tM7irSJdOcC9TOkELcdce+b2Gacnxd+hsDDjv3Z1CiwfjjsAZTmW4qo2CZENJigmfc/lUCuVohvWwYmMiHXLDv6Szy1VGUdS/E9xzRcRY3O1y8XOf1ya5beFoyJ4o1yIizAWKtw9vaq2Fy23fYlvNEALJtWt6z0P3TX+lMII1Zj7U+d/DpZ+90/9lgGt5enz39u2XXXHm6lVtiFToSEkPmWYiJiWDEkUWAIX7GoxJTnnT3zRUGRQozHWAtLvhsleN6FK+AxjTI3azZk8tHsQ2fuoIixQMsj0MrfGqYFvpK1JqIVZp+7mUn//VLz4+P3dB2zuUmErrXURtE3nVNN72wtgnL5enz7b6AA1TVj33BDw2V/NnpJQitOQAU3bWcyTMdOoUk1ZYAVceNEb6qQ44idjNir+CSDmirO7thQ2NBBkGWYlQpQB3QGGiQlQMSZBPA7uJUO0MKEnvNxW+PJ2pFmLiwrZ+WqM9WbniPogZWusztEzq6GdYZib/dIRk5ytSicCGgy+Pj19//TVD17oIkXSBLVXJ5BzH4sE6x9fNzz787momI0CHcJeZTZ2zQTGJuk7f0yKHYXfVFT8OR3KgApfWXJnu9ZntTlJmcEGBUFchIRCT1Kf3b/+v/8O/+slPvl6WutRFQcwVyl209Q4JjECBBsDeKYEXbtN8VZIkUU0YxgyzA+EL+AevFqLRLdGxMUuG4APGB/fra/1IcbmDjnlwIgRKOGi3GSFSPMEoPkE3JipC3EBNIUCXTlE+zwpggcFEXGpvncAPD2/W00JkgDMgW2ByE7pUHDTxTPDPGPoDx/3I8Vlbks8aXx1dEujN4+OvfvlrCxVo196loPqkCKL4Iwi+BRg7WTAR6u5tE9IbP06pdfZdVAhTNujrxk86HUmZRIyH8fMT7p+oq1nnypw+M6ajMSOrC9VSCwNN91M9/dWvf/3u/ZellL1LXZcuMO3Y9tZ662IogicOVlV3xEckJqp/ZnDR2NkxUghtgrFpYGj4wkdiIWaI1JVKBpqGxj8Q0oUpwhfwS90O08x2/ixgjuECAX6g8GVgRJYNqkQ2vc1UVMxrJ4XvuUoMYhVRFFpOS6lFcsdljx0rpQimfjRN4eOXyu6Os+5PaA77gHY/cOmrn9MGPTw8/fQXPy9cLcmXUQLmDK6kQCKmuaf1kjzoZ00wA6WY7h9RpPwLwPJq5/UA3m2NUaVAQc4dwcWTvphFO/eWzqaQaycXVvsULqWSKnOtIFJibZ0V79+/++KL96fzpe07gS1xTXxX7d7a5puieHucl8eOMPZgDd4O9naxmGhyYNrZqOr8oHHFQJhzEDRh16AENDkofxrGUyM6pckArt0OSjalK/klHUDyDROUiLx2htgMiRHGUnypFOZCzILzaSEPmM5kOjJoEIsCM9BEmx/R+DT+jlU7AIbV8+5gMEzQ0Azesi7n0/nLL79QJlECSrCoZ30nD8NTdMmXLYVWGqZ+svnpoY02zu0LZ09FPc8u4EXiG7uaMpzi2YSpk6bxzk8juSYmvTBW1FCa81B2QgAL9bZrb6d1ReXL+fL48ATow9Nl3zcG9d7UqoCr9C4+zsOOK0CH3g72nHcIoNywdCJELp+e2CAg3wxs/BlpYl5f5o54QKexZ0GAK4RSI5roDX/qJHiD8YNWtiteYj9fE+wpR5MCUtgyUukiilIW6X1dTuf1UVUNEWU/R+QsoszR+KMOQNj0vwR8xmj/EEzyRMzUB6YYtZRyvpxrXawCnGi3BlLGQF1dTiJqehVArghDKg1n7STmRNM7G+W7e8VG2RMUTiw/6R1jtB8CP/620BYe2svBjPyhGHIjhoW4mJpI60pcVIRLebicHs6PxmZ7bwC6JbEoVNETyxpaoTFCzktHyczNiBxUBDVnCxAdn3rkXPpZQ44jv6b5M8d4DNVkOj2OPNSpBucNST0OGA7GNBICPJZVAMt4mz2H0LC2ak+tWGhd1/P5XEqhzG2dbI3L0PA6RtsmmgI/wtZ3mvC1PzRfSNM/lmDSVVTW88k2RFERgoW/9Y7Jpg7GW48nB7fFnxnF4AhBY+RoFA/TIes06+2htD6j848UGEfCqbz0XrNYa0gt2ZWYVNHb1iD98eltbnS+bW3bGgi9N2JnMum+Slyd28hrZ4xQKDJPYSrSExouksySwncd0+BmTW6ZMPGwAOFbwNcUqOb+y2MamKKRRlrKrPNht4etGMdQ+GxPiPJe9ibfZFtjm4G0BuQardsQUy18ebjYIDMzeA7Yhc7Sg2zOPJTcMmOdvzD4f+mYajYoiFT0vK5LrbEA7zAXRfPo3Udxwsn15fM0fqLPjG4q4Rxu+1Qpwqo5EHAdOYPmWemNxhn7USzFIk/odYjj71HFnTjDq10zUWctxFDuVqiB+e27d5ZX3JsSY9s2qICp1spEohBpAfOGifIHR4tH4u6I3QKzfRAl5rAYmVp30NlJ47sjcZUxdVjLiS4DM0w/haPolB3jEBoGlK8La07HB5OxrP2S6T3p3CGm74R0KUuXXpb69PhUl4X4qtnew3D8IBMf5CEDa/d300T3w8dJmWb3pifbSdVSCpel1qU3SxuYKjNybBIeZM+oDk3/z4UNwYzZlgMfzv0kWzxgRsDEP5QI5RXZ4x+i093KCCLYLt5T82ILowC+dlnsB0QKVdFKpVSPUjOhlNLaXkAKYSZA99a2bbtdX6QLkUoX6R1eA4wnvD0A0YBxIRI6aDl0LiLrfOCW0ZsYt3GtHkc3LMOEVYL8wzxP/kkEeUbDpsXeYXTDYTQxiqYOA+puNMWTUkLF4jy2p0LrzFSolFKenp7WZfGpBkt0DXMyRuWHDzpy1f1v0KOevP/5/nyyr1oIFMtS12UlgItV6DmUgjuKoQ8uHZ48wZOMKgyqHJpyd8ZM6DQPkEBYX92bhlxjCIDwpe5w7WCwROTDCk0td4lzhWaVSEibLks5ny8CJeZaqwhUtO/71vre27Y19fpoomHAg6FpYlGavKawEGma0gec1I3TZPqWIG74EAc74bYyCZTnpmMWNiBcdzo0a0ips1u4AJRWHokLQswIMFTjEUJLBPKDo6Q4ER4ul3Vd7bz3JtcgePcO6vk48HRnLY4//wXhmQjiPU1fx0CiBXa/+PLLfd+RCWN53VCmbvFxFxzD8GHuTiKMt9vG124rETEjK8O5+RgEHx1IRrK2zEiMZg80nn1gBDVOmjXn5Eqnp6xEKMtSwPR4fnj3/v3eugoKldNpsVDpfrtdX1627dZaI4bvveo22WJZ4FjhrKq2lfSI2mQJExcBy/GPkokYvQzPXYPDPzegd8Sezg8ZD84erDtntwejU7i2ufWFdSHH3C7WNMsEs54UsxavTD3FMBKBLw8Pp/VkdOHUjAM9IQMzOEr4a134OTqELE/m645A4xlGTlXb1o1AtdZa609/8pPem+0OOnPU/AzmQLVpmuPNzrGuO4zMoVGGlL7uiLOJq16K+/VwCVIchxsbpNZhGKYuTo4E8vpJbRIQ2yaKsniIj3WppSy1Nzldzg9Pj8TECxHjfD4vdQFRU932piCJNTH2wMLGOfm+OdqQKiAYcohDKt6JXvFHY6+lSbWnjzQjrPExnjoYIrg4yTAbDswqlHy2BJiHnw7KyLsTa5VziTFH4I9iaTwBha12H2qt5/VyOp+sxnJk1+ULPsdt0cR7FT8Geh7Kzx4zy89xuWOIlUBM5/Pl8nAppYpGEV9SQD0NjjIV0UMCqaURoztZaB+tqeX2s+SPQawh/bYbt6ZAHWzF+Dw9PqlhZ+4umlHONM0+a8bQWGKXCIl29QaJLnV5enx4enjSLkyFiNZ1UdsiSrTvrUv3MldEpVRitqnQEF/PVvCATK7qDTqEDXAoEMGc6J/pp3kQpwGb41o4iPZUvSnoQziokwBgVq4oSsVPMNIs0vjNLo4FCB7+UbdhGSWK+4lzPyFmLoWYBNK0l8rraTWV62V0Y2oiu0VxcozzQWs5Z3yWJD9Aqc/9/hnBodP5XIpvf9V6MweHIrvWljFE6guHYQtdf3RZZ6sw2eWo2g3AgXGAFVUoqt0eOmXY1GPHaKAkJ0wGj+yucRtylf5EQ/fnx1oyyzxTQESoa2cUbdK7Lpf69PQIoseHh+22daFSSi3FWnTb9tqpC4hQSjVRFnuxZEKbZY9pwgu1Qg8zfCNAAosdwIWXXiFXDPM/gZ2j044J7YwlMKovCOJiEZugAXGoGaetcXF4Sb5IU0kLccjhUMPDrhB79ooqQF2lUkkg6G0kWyAmBFLpIF3Pq3VQRLj4YodMjz3w78S6hB9YLTkdSRLCZ+Tg9TMxXWrmqxDVUu+MRkA/a8IM8mkK8BllOXkTU3guR4lCR0TkJ2CLC0oOTNZ3omSEY+sPn4MRUgo9QjdBS29FgEzy7Ka0HK7SCOqcqL0JGHVZHi5PdanMZV0XAknv63ouiyfKtt77tr+83FpvAHxZrXfCtIQrBKsO16WL13tMdTkumg1YIhkXpPtAZGCbSTFm4GD8CIWpasR2HmmjNZN0EdaTpv00conigezjDe4CKgWLmN0TzWHzol1WSEQZIros6/l8sSiQKYPoF3LAD/Z5vPeeqQ9dfHXuByHREWkakjOt00XI9oFkj4b4VnGmg141IFocQCj8WxpbByaVPN0pdYjfmJfEc6orQzcE1sRZW2fPFGOsJmUaimrEFqYLKBXmQfdOh4AYDDZsQMradT3VU13bttvipq5SiM7rur9cu/S2t158wSLOLqrkRptMpjsFGa0L0/xPbgM5FH6qsFTw7gqSo8ZIS7uLN+hYHaCHzwDFNq3kgfdoRDRWMm0gZUOBWLPrckVI+5VNJl+zBmiu5wtgpH4pKYE6gwkotT5cHh3qwsu2pN12XjkycBj6AbXVuSPIeoABs4b/rBlIDZGkBBQiQjb7S55Db0s6LUcmkkvG4VpJw8j7eJmqOmrx0fhX8CuSqkFQUSaqGGnozkID8Hy+Xz9g0kaacQCLjMs6yHIZ1BG/sFFmJnQFK1FhFWViUQFp681WWnaRUuqyrtg36V277LpBFaKXh7O9lakE8xKDfKO9UOtjMMeADBOgqWddDThZx0g7ZTSwBgImTRyTaM/5RfNrVDWleHwo89RKE6BMWSOKvzZpTzH7dTCxqQrdAgLo2iEdQnVdqur5co77bHQoVdpMmTHkgc30sFpgTFVMIGTegW/iEro/EfpkYCbf+lfVKuPXuqivuBi8m+QanEi+1oQwE39qevKk+iActZZzIFTcAjgwUt++iqKtFBrC8RW5c5nqYUDi8Q4NrXB/aAofQklOQqZKqkLMpbDZBBW93jZYMRxGoaIqa11IVLi33rXrpjuXsu2tlsJRmkcAmBdLMHjncsg0vVcVWsDZUNfT2VRF9kODZAN8YkKILsIjSpZ2woYqOjk9KyxOSF/EDexLxj9BISjkvSMi3yLSjQm5u1K8LfAiqmFVTLvw+XTiWoi80Gq+a9YEGgsPUl1rmO6IjAZvjWELfDHfRMhXTxypqR+DU1wNi3bvEE2EOnDOWIoaRjkixzlm4W+l2kkIY+8M+EV5k4FIFa0IYTnKrxPKDSxSkzoOGsyMsOVHaDNQxujJ3SVwBBwhDwDdQh2ipZTed1YrHFm0deZSahGtVRfs1KVr1+12g6LXYnM9zgeiAJiLk1hsNabC3W5TXLHeaLKSs2XwYUw1HSth3KnSeblqssiBgH73zOVT+mm4ueG5qma04gDRoylOYo2ZQ7hXVwqnzIW/SEzcpZdSVJSgp9Opluo+AIWvM3s/iTfoM53JJr9S/UT3l6UszLBBp7+hVW2LJ5VlWXvvhQvZbND9elINixjaCzFquZ7PucfV89DRY2hTJiLeqQAcg3E+ZTL4gYETGMyzhdPv/hI9nozX0uAQhLN8iCu4hiEQwExcSEVa28+nS6mFueytqYKJrVKeLW9d6nJa18qWPatb2/dt27Zt33fpYmWQbdd4A9DIxuYGUndaGcFe2b8gavYug6fAiCGkzMxjk191FJCPhylw2IlwfhvSQw0iakifRtlLm+L3ZZk0VsZ50RiLADBDVYiISxHRUuppPWV+IUcsfXQ4Bsip8YoBkU3EdEMqrbkjByrmxQlR8skZ57Gc1tH9ucZesk0m2TjeGBWfYihpvCieHEpk6s08k2PkJaYaLUv75cuxJcjhmmOMEyKvf+Kkw7LceGcK4GhMxC7CKCJsi4li6ztTefP27fl0WkrV0k2hgWx5vJTCvZMy13URUdGuXZt0YO+9+57EBObiIEN4MJ9nIoYWjJKHmvYUoaYHFozBGMG3jJBiGE4aGm+M9qyYB7HSZt+bwwH6MWqgM3s9HwC5EoqYwcxMpRQiK5pk5YCIawE4qqhDVWzDjFqrRaa4evdfK+/wEu5MWX4Y4AISgGSw9J19p8ExAylNXOiminvvy7LalaWwRN2E45NCUyLt7cR90Xj1vzo/IcaF5mfMvePAH+pK3FPUAv8hwVnwRAxiIM0DoQ5voPnUIUYUcDnjko4ORIUqEeHpzZNtLLzvjRS1VCXyYqXMTFSo1GUhkKU8dOnS+ta21ptGGc2IBJuQeh1fC5eIiC0g8RCMOwfDhk1AQL3BNhCZwKaqvhQZeSk8QqPx2dAp0mAG8vFzFA4thTNusM2FIVL9ve4XKaly7Jxp4svEpXIpXNi31LXPhbxgLlRL5dO6Rnwp2zDjcbguutP0Q6kfbRzNsjx3f5z4HG8M7WC32J4fBDUgF7Y4R8BY03dIm38ak46pskbTvHHpjM02JRoeZiKyaMj4xXzBycLfYYDp5CTV6R1gFvr8ks4UTSf9Y0o1iaqoFK4QZS5LWU7ryozWdlEtXHyACcyl1KWUUmsptVoJod7UZWBrqkpUmQhKQT5C1Ggw+UYsdjvoCkIKahiHMbLWzTEzexjcqAlqm5hiYrKgRQSalELXUhgeybnfeLFp73lKGOpLH2NiP1tAXhza6v+wVSVTZq6Ficq6nipX5sLMJvp5c+x85oY52WI6JjsYch8M8AoUTZ8TZc2n4j7NDhLR+eEBsJoaDucUkUR8AFU0/5dQBqG9JlP0A3fHxxw5awP7PXOWG2EejMkOuEAFWe5E+oi5MloQ5iIk4TB0FPAheEKJuXB5evu4ntbnT1cRuV5vIp0L11Jttwe2mX9wNWyr6NL23kW0t31vjWJ2eGKYMMqugZ1Q6juCaaiVoTjCKsxQPpRH2MEwHXT4dR75Efmx/7zkZzjkadbDIESZEwCRGpFGMh5FgNmBUrJyNUSgZLuAZBYguyUUr5yR4kQTcwzWGRyQuGvwRCrWPHM45vP0+uf5TIAghuLx4UFTRcK2LfREIMeVESJKmwnEOfudRtgg0FXSNsIGmExxtME4Y0pAnTQzAqKEoZjHdTgDONwzqYQYLU10FScnwo7+AI5kibhwWdflsj4SmAq21gGVLpWLWwFz5ZhLZa6FmcFQ1d7adtu7yL63223X2M7IUQR88DKdZtbu3sOIwyhSTJKkNCKR45LxN2HMEHPNGu5IpzZWPKkVfpRR2w52QUARsRpIvicMA5YoDzAZcojCCETEJFZ0icTSyJmLwiYZi/S+3bZtb72JO8EUICLHWmO4nRqaIxhqbKjUZOZwS4FhT4MyB0t/5JtgFWYrTAIiqsuS2Mxz3oJLKIxmsqG911XnZwJRqraiIADVrJgPIk4MoPrk4yh7RT5tGXG8CV0F5x8wldNH6Z5A+e4wUrOQehvEXk1amFSpFAKh7Xs98bJUJiZ0gETA1bxAYi5dOxEX05wVumst2NvWZJdb9/R3RuFiBFNAcL880uDHwbJBZxWnGCIBmnob01fxnIAPSYTPaECivEahubuGujaLmYRQU7FkSUBk60N8HkMBKlyZYgfsEJoIBzF7Shw16af1dL1d99627YbsXiynQWanUHqQr1qe5w4TnaMwnuu513x4d0SAyx6nqiJKoG3fTuezLf1vrVOwic/hTC6vMUzA2CGWaQqynXGXDeCBgeMWBUihhUq1js92VmPm3S6l+cbxd2akibNjTJygFN7jsd3GeWr5NgSvdtTFpO+0nt6/+eLx4WlZVlHlUrbbJqC+99lbZZByYRYDAqKlNUB1u26kKMxCwoWtlCIUSsq2As7boLHpyqCq7c1FYIUW2NZag7zw1IaEkQHWA1TZN2a2/Y1Fimt9qIpDG40ErjA3aqCOCFCZAJNJsWF8Yv9obRezBLbmy9MkPXyEygXMgBbm1hsxd+nOCLahGlPQwf/vwdnkPkxdHmNOBlL8Dkykg6pOYfnX8jCjBWNPZpG+LGVv/eFyUQjTstTqBtNgmu+hJ66dM5iRakqdTDoePD6m9s62iCpjDLlxXlWNEhuHFg8mDhG/437jhOm2iXzRliOnJFDTudFsXCUqXaWWpdYFhdbT6Xw5r8sCgnQVguxNuhV5sPDNKBxtmdGndWVqrTfLN+4igk5allqTdFaGzrnBkVFOepAzOMw/uzMGw2oE30/j6lLiBIkHKiDki/kpNM+whUhAG/EOBweizJqq3DSM7W0Zp0BEhakspXAYIkUpzEsptZJJIEzvdjAtVC2bwhoLvkMEE5+O4R1TX8a044we+R9OtCO/T18VDvCCjexNzLyuS2/9dDmpKpciHURWXtkpwsyqSsQR+uF8YnC/T56r+vTuzMaBP+LbsOBuX+o0wvNoH/7moI7goA2n5sxNjG6aH42irxRQOV/up234/Q1NpJBt+FPb1v783fd9b7XUJloLXm63rs3mJjyGHUsCCL6BnGhZAPFKKLJtWy1lKUUiUdloELzstDM2BZBm02gDd5KIoqAUuUVzno6hVZsEoRgAg4/mz1NkkJBFeMNFVlWAId3XsJGqCDGJgQOrDwIBuJCCyWqDVd/4mkRUoV2VRcFkvpG7UMratTApcReRrS/n04q19U7EIpogIvVlom1n6jl6rznQB46eOCVVXprQiUNeHTH7Dst8kdbPlwugxCS7KCkzq/SYalHO/PaBgoLyab4QlteeLcnoUN8pfRzpwVkaBjFVF+6wMrNriGD35PvhJ4Uip/nXUbPAtRQC5oRDQYOoZIiXCOgqXt8YvG37t9988//9P/+PP/zpT9u+myu8LFVJBL2LsvjuCbYnjQJd1FZPEHgta6duPjETQVmkGzs5L9vL4300zX2OhHHSqa+jQoYnlZAcZ7QHDnCeEM9tVJ9vZ6/ozKRKxCRCRFbJ0A09Yv8vH6UIiokVmWeLA/vfUhcLazIRcwFIBKTgSgqUUoBaC6l0LQs6f3y5irL0bmsHXF+nPddMb6EjfBmcQPdQMH6n42XAuGp2CnPVp1tDEBclrUt9eX5m5t59/ZL2dBeVwIJQPnMKklshCoGgsLeBum1cI7t8AHL3s7L1CuIKhCKcDOBQ+sMZpwOeivHSwGFp2ymUXiAo1zfjIY588kFgZgVL71zrbdv+4ff/8A+//4dvv/uWBGWtIF3WE5gaNha2FTQqrCTMBCWNCXReKqCQurV93wVquymJvcRerA7HBugdVtPBtHuXwy3WcFQARK3WVwouXGnn3ilBPS/2+pyua02XM1GprICtwAxHgUwemUkFvQmzwvf7BSm0i6h2MLATiInqUtFJRBu41MJUpJN2+cOf/vD3f/d3t9uNSqFAQJ6JOZoe2w5n1MPXyoarrBrG8/44OLcDYCBkLNlpkEmtGBRIVa+36/X28vay9q5MRagVK4JGqlCWWMLmtokQ2CsXOOVkPMhttqnfKeZ+j+/j/wTVqqrORvM4zh10gKfziTucZwCH8lcKWYhL1RFPuvXOLEarWmvvwsqqfe+3v/+nv//+u+8+fPpYmE+spNS7SBcYYzFIi2MHYoUULBZMtJfywgtDgVoKmFhLNso8VIpxc0oNYBd1CA9ICcHwES5zJe/9tNT+COIAaV0oMiXU7A6JShgD0uADkEoXu5HY5uGlA6rCzCrMpYhSa7tBO6LSRZdShUgVrTWDQKJaiijQuxB3A3Db1j58+PDtd9/crp+i2KBCSUWSB+ACl1k4aRMiNyniBkTmAR0EgeI3m16IPd2dLwjBsc4urmxFOrGC6/PHj9999927r96fHlcRLWBVJSZVYYWy5/87FFKounhkpbtE5JmynsjFHTpMyDvUncIGjqo5NKnn03KFxXH3Zgp7TWrChjmY37RkWiaMG+CxENs5IMWK4Av8iJdKV2mFlybyt3/7H37/j//AhKWW1lrloui9i3TbJrV7JXD7RwsYKha5scmjTkKndS21GL7eWzMIXkpBtBaASEfgNZ9ccyk2bvYcs5iOBTF5Vilbd8SXEgHqqUWkwN49vF2iUolRkZioidUsccBkURmTUFVm5sJQkKgwwV323bY9bdykL0Ahbi8gIhQqXAoITGWMAPGynPf91rqeT6d9224vV2lqW1UVJqFJo6lNMnAkdo8Ri6BWMAUC0ybEDj4fbqYhDA2LfzfxCU4s4GaoY9vaP/zdf3z/9RfvH79o2gsXgRChkA8nwRYThrZQgqp0yUUxHitCSITjugRCIce+NlIJHgpSFptMKr7XDiU5LPswzR+sQNXQ3PBXTDHWtHuzUwVYMW9rSjLC7GaY76jaoYwCpuv3n051hdZPz3/uK9ZT3boqtDATWIRBfds3cyyZCpGaU5jVyxTgYrOkLCTS3ERzxgtDHbl2MxsIiKh1NOON6QAhcpWcQ3xeO9wdBbw0FcIVVhCra0xfFenmpXUiKrbKOYhg1CTiWorhE6cnkSGnwqWUUkolMJdKhLqstdS6VKZC1NmPAqXb7fb88kkVre3Xl2ssuiteTjxWucW7jRr22sG20aOYCDBFmRb8FQYMj0BdJqafYrsUHdcp0LU8lI/ff/9v/rd/8+4nXy6/WbX30+VSbIEgkG3UzGJUFzcqGcqztvsrg7nC5Id3FlosdK+zdiFoDTVHwxB44z1STIeupt1k4kMkLHghLnJYEGvxHDD4eEINFrg27lBtjYjltj88PXzxxVei0mS/XtF1JaLr9UW7CASivfda2EMr6AyytbeT8vawk/KAOgRfTp7Ztz4XQ0Buy8UwbBDlRZybx4AS+VrGMKgCgR5kOm+xyou+lbBKOnfOp9UbPDl3IIZqLVwQiXD5q6gUKl1aKYuS1rqUUk/nE5daiAszW4FZEGndpS915cKWEvHw+Hg+n3tv2203TKKFCKTwOhnkr1AHfTmOU3IoTRzlGiWR4Rj0IQyzXEyWIBYmQ1Wx7/tHfPy3/+ff/uKvfvUv/up3IKzLYlvwRORQRXuY4nx7gFRvgFjUVFy7qiMOQ0OqgIpoKQU0bd2poqrFsmOpEDoi2JXvSUhD0TvXHGHUw9ilEwIgl6W7xQlv16RgSitm4wq2dBcCk7R+ejg/71dUrPX09Pj08vH5envRjufrs/QurVMBg3qtxtWVWZgLkRB1kbB+IqK992VZVD07RlXQlYi121j60IkIM6gbzozobGdQN3/YIb4NR0/lkopm2MkUAHMMyGZrJ6ITSKDaVaEk9mvk57sFoMql1sVkxPIWDOkxU60VilpX4mIl0i2yypULFyYbYIh05vL48ACgddn320++/OrvTqePn5p3BBYZ5nAqXWeHhQ4VqBmxsdmSjBGlLAegPnoFY7yR4ClPJ+OCQH1rssun9ft/+sfff3r++NW79wx0aRpKR11vB4lj2ih2F7cdEhzPJ1blUSHJy9WUyiAScfkGYPXGmakSE0SmzLaIWFGgWsqfkPcPdev/RMZFqo8jIBuCF+QyzSmiIJLeYvzk+nz99p/++PVXb0+39U8NW2+77ufz2nvfttt226QL3W7W1VorRTp8WUot1fuArpFtYBrOSgwxsb2dTZRVPADiQgtViCiKFCqBe9xbVSu7cucG5myfmRomEbXKQu6R+yaNfpPJbSml1lpKKVzGkiRVZl4WC3ES2wpR8m1hQHo5n1VBVIm4Nd27YJdlXbjYVhhAg0JqXctSmdBVt08fT6czaukELrygtNYMBhvfANME6VCBRAQvC0akYgjE2biwVTAYi9PMjufIOjkmKBVsQmnvLCmp907oEDy8eXO9vvR3b7slwDOpNSrhZkipDcoBfjmhYZMr5GBec98UCk3FZMLsiEQUy7LUWkts4JDXh40z3DVYenQxbaC6Zz/HdgaIGt0fSZl+ryaYUwVRl16ImZfb9fryct32dvt4U8jpXGupdXlU1e16/fjx0/V6ld72fbfM3mVZRKRpp203tuoqUK2Vm6dOKFOxl/bu86PCZJUomVhV+zRDpCq9k1Zj9/ATCImyko/HEISOsFXrXs1MUUus1XQF4nDMWDxXdGVpOy6l1ioirQmzkJgnrSBlQl9oqYsIo1SRXbrQqYJYlKRrBKC41BrbhREXbgRmfvP27aePnwqYuKiK7dPDxD5TZ41jD4Zar9mAJTMTLAARPWdASbuGk+AmFRosn6guLYEJ/8GPJAajMOMnP/nJ//w//b++fP9O97bxTVUq14gdGFEpVUyg5nhLeBQZGQIkXYdpaoYm5T+Yve97Lcy+LCYm3XwNFZvcKR/lDYGshlpP/wLHL/bMkTyTZituUpHGBCq1qIKJ931X6U3av//bf/f995/evn1zXh6XirpUMuZigLHfNoX21g0hANDeu/S+31ojBUGk996lSFdAS6mmVGxq0Ehhi61K8R3HBlBRAnvsLQwgiEhEPYSZARcyJK3MxmzMUcArzCyDSo5kCA4Rscex1aNJKlBCERg1arGKMLYFKoNIVF5u19u23/augAqISa4drLVWrqWglsLgBMKqolzAoutp4cLSmloWLRWqkeaknrNqASmOAJEYVmci8uycwmzVlZr2ZOQI6egoUef0VWQ4dGYfNnvCAqhoAWq9nNb1y59+/eW79x8+fSjLUplKqeLPGNNTzk1Kk0whOQmYGxDY1HXtXTrasNu9bdXNP3uAONF6Ahv1otoT/2Pgn7QX44JoYApC8lcgAa+8SQSFuIXvChZpoIX++re/+9/+9//922+/227XpvL+3dvKZiLoVBd9eGhcb6X23pj4dFoBar333nproioixLyeTstSRLT1TkRmuFU5bLcPnkBsfaFJpssAoTDXUoc7FexbPNhCvlefFyV3rG6xnVA5Br0cwTslwg82MTBMLA4FsdRSagGg2nsDCNo8JGU83UUJxTJKSYh4X3baO9GNmMuynh9Op66ltUZk7ncrC07n+ubpcV1Pfd9071SqKUtGKgQPV5n/aIuw7ZTYKVtCF34lPCzDswc/H+Q5/Pe+gbuAIrXWrtJa57q/vHxceHl4fAR4WUtvAs+OHNOpEWJ0A5XAw/ls+NmqBwbEcQO5nNWzoVcQVVWYKQuDkcuQJPtAwfGBhSJQSOPJB0Enn5IzYgTYjK9K5JWcQQJRoIt21Y7W+69+9qvtf2j/n3/9r//8/Ud0oMvtemuli8jL84tIh4KYSq3EYC5lWQDbQZSWpXZRkW6cKQLmcllW5jAUmrkQlDJZoi4xEUS1t86F12Wx7LESJXWs8b5C3/0kxzFJI5+fc4F3roVzViTiQ1uzqCWp9K4i4oXJpHdsN3i2n7ILCQAuhUstpKDirbEuqfaihQiQ3trtBV1URNFlM8x2vqyX88MX7798ePz9yyfet81QhEi3whhMrAVgQ6S2ljI2E4hwGvkkCfaO3hrUx8/3ZxD38V0zz9vg5EnK+SeoaldBVwMby7oKmko/X069dbX4nASCcTsT+jmn7d1BNpr6xDZlMwzNwWrGJN/m2iiCoqjSyhWeJJtZR5NYQUMxRDwJkSaT9Ykn3Z8WI94hlnKEbPGkKqwRntLZQIVa27s0Xh9++eu/+n//z//P5+cPnz6+iPQuIqpb27a2kSpzqaXWWqFrOqaVC4FURKnbKvr1vJbiJZEtAA+FRvHAYFayLTksfkJAYSynxXwpKFiZlDNC7rgGFiDwEEFGeNhQlozyIwwSke5a1KEUyBOEDO4b/jBIZhFTjhCoL3vxmVGVLlQY7pQRx+YgXlJZpO+79GaXGdpbayEpy7p+8fb923dvtTWGMJGWAlbuIJtC83k9Ms/cDJa1TQCRLq0T8db3hUpvHTFHFsmdEto5WCT0xREIqYMLxydCykxlOZ8uy1mgran2LiI2KW0ILXa3dYNgZw/udbzLlbSr9zlbK6biiSnCd0QkRLWUClbdrZ4gwJE9N+Y7FManaTo4XeJQaMH1YS8GiAKy3cjHUcoUlBiQrkwEtG1T6H57JsZvfvc3v/r3//YP//CH7fby8nK77i+QDunEVAoty0LMthtj7733RsyqIvDMn2VduBZ1P6NbTjkh53YpvBgBsfZmVSQU0C5aalEqlUQhKtKF1degiUhl5sIi0qRJlzCVAHBaV1XtIghTIA7FtTD79C4zM7fWSmFVE49uOT5Epom0k3BESG0jQRMvFbVUOLvYNIiqllpUtIl2UeqqopfzRZgqeFnXzr2jL6fT05s3+/N1IVKRXTsplUqqyoWJAYXrlVJsJJmLKXeR0nkXhXYI6UIkoGI1SbsqQUzNuT8w8X4AeFX1kr7iqoBMiIqUWt68e8ulMlHfnkV9osbnCjz/wbUyZRoDUtsf+B+56Ennf0yz+6xP/qAqQKlMCljgRNARONVDhFZhxutpGrBw1oX9JDrAXjoKFA6/dCFP+yUoumSZE5JujpAQgTq21sDSr9vWdy71cl5+94vfvX/8Qvvtuw8f/v3f/q0o9r311khpv+1mnPa9qUhrrZZibrAJ4sPpfKrrbbvt1731BqjtlEhMhUtYdvgEM1NhSQxH2jpzraUSNxFV7dKZmWtVEeVu6bo0ynhYCRYqlYm4inbpanls3ZJ/1HMZWgewLF6Nb12X3qU1KqF3bW6IgGVdisVPiS38UrlSpfPlvCzrtu/btnEpov10OX319XuA961drzdi3G6tXtaHp8fC5bTU3vp3f/qu9Z07MViVS63PL8+9tXJamCsDsBXUneq6npZVAZUOUTCJqrKS1tu2iRZRAVdDuArtKmYN1d0HRziJkIMPSckmo8W0sU8xlYpe354e1pMswMasrfe+k+WDMHmVYYJZcii4sAELslmBWOGizq5qbntG6cMztkx6m+YkAqgwdYju/3+/tvfj7JTUPQAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F7917130310>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 0.20067806541919708\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F79C44085B0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 0.1990816444158554\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F79171303A0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "probability: 0.1985906958580017\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4nKT9WbOlWXIdiC133985996IyKEys+ZCVWEuoDCjAQIEiRYGQhyaMqnRsoapSYoyiTLpQQ/SX9KDnmR6kLWaTRMHI9VsNruJAlCFmrNynjPme+85397uSw/u+zsnK4s0DYFCZETce8/5zt6+3ZcvX+5bvv3NPxXRoCAihKCAhIiIAABJUAAif23/iPo3EZCAkBScvkgSAhAEBUISYP34fKkgIwIgGQIEIyJAkkT+FiEirNdkkPlY+RcIBIBIRAAQNZLhAUIUJMLDw9WEhPuICBGqSlP1Hgy/2F+YysX+qkdfbw5vvfnWgw8e/Vf/1X95/9GTB48ePb2+6T7WsXqADNanRj4YUY8JEZx9nciPD4iQJGMuFk8rk8///8svOV9CwdmK8iPfBRHJtyQBqNT35fPW9pIqoqogcycBEUIEZioiCqhIa4oAhCDUpKkiCMT+Yt+aPfPMvRdeeO5zn/3cbmmf/dznP/npTx2PB7u4+PSnPnt7vO0en3jxpU9/5rOq1j32u521XfhordUj5zuLnC1NLp4I0oLyM5NkPeHZx8wfkNOyCOrfeDJZqT+KCMhgCKHNGKFAI5oHFKCo5hLp/AkCIgolILmD2xPPPUZMs55bXvtyek5K/U0AOkPq5QBCIEGAytN75rOTAqrMdyRBCAhhfU+AIiL1hfwBgKIQiICCYEA0RCCAqFJFoCpBhEHNRqhau1799vrm+vrw8quvv/zaa//dN752ubtYjxyjH48jMCLy1dKSJR8ySJJSp5x5SmutgxBhRH2ezWNAeFqlbb/wMdfwUXMWOX2PnO0nyrlge4Ht91ph2fxU4PQNJCW3mHUspfYi/wEKhIeoCKSZePfcbxGle1OhhwnWte92y+je+7oO1509PByeKF/65AvPPHtH714xXMz3l3dhuyEKIW0ZhFoLMXC+tWhucH6eWuGTi8W27IAIhJhGVusgnEfhfHEwba58Qa26CASKCFBMGQ0AcnOlHuK0GdNr4LSF8+vcnvP0ePyhTfzIp6jFBcm5ocH0o5FvEGVU+RDTG0yfiu1jzyeqf6FUmAoR0bLEPCxBISkEgWDuIkXCPZwe4ca+jnH0+x/cf/311//lv/rX333lu/B2e1zHCILYAa6QNH6qSMynFQEY5Y+kglW5KuEMVAIhAiI825cKmD9s8ecW/PEvzT9vno6Yx4H1DXK2C2nN2/vKaRfSBAiZryXlhAGoUAiBCKmYa6gVJUiaiChUNR/KI3o/Pn3C46Evu+XtN9/73vde/d3f/ev3fvaFuB0Xtm8Xu91u72tXbaqK4YBIUwQRAYAiGzyY3iIfSaYrrahVuy5lDhsskY9YXZpxfiLmaZmvPV9TTubslBYRE9fUUkG4RZQKPAWEtp8/e45yQoKPIKV6QZIisgWJ+RFl8z0sLJCooJypQCZCUCkwhNqk6RMEDEA5P41AVCAUMoKicPdg5MszPNFRhNNDiDFiv7TjcRxvb99974O/+POvfeub3379jddubm4Z4iBD2mJkEBRRAQWMDfzl858jmYxFJyCEBH4Vo+X0nJw2+DFDn79+eB03jzONeNrGFubrW2T+ZK5ymr9MGLpBifJCQEYGqE70KnUsGMEgVVWUEWgKEQtyeDRIM4EgwADH6Gv4nn2HCwh4w3/xL/75ux+++2u/+puf+fxn2l6hfvTDoheLtEFqvij7NHFh2c9m4vNTnn3oLYLOLxdWz88o0+jPl27zl/MrZ16EgDAimmk7LeCETycvewL1Z8u/7ZKU4WFGUJ6F8zPETJ6eZXv/7TsoZRZ10NLU5v7ODCR9LUMg+Xcw8oTnNyg0SDi0GeBjjHCqyrLsnAEs4WuE9NVDiQhtfHJ9/e7777/+6uuvvPryaz944/79D24O6zrGxeVVrL1dLFEYR4kA4Vts8iCQ8QrzWJ5/pNNmAgk26s+b9X8kqp+Zu3z0D9u/n0WGLR5ueylyeqVCWRVuzwLwDKenv0qdmWBhcJ25QzqSCHcPKNQ0JExNVZ35r9bMIAGIilB4OHZVvbq6FInrw+N/+2//zfsffPi3/87f+fmf/8U7F3fUDNZACFRUm7YxBhlyBvU510W2dPEj+U4+9vTpE4KfmSkm6JkRUSDA5qAqYOIUBlREVJtAyDgh01PyQEZa9oZBK1BuiymbyW9PeLbIJ3y7nWNMN5iPK8GYTqkixvzoM2AlUjq3rfSyKqRQVfIBA7FYQ7CPY7Nlv+y5YarV3d3HenN7e3NzLWA/9A/u33/y4Omj6yff+tZ33n//vQf3H17fHMbwy4s7KjY01j5EJMoRSSYa4ZFZ+8R/lAk+52cnctE5kUgCjJP7OF+sH9rds1X7eHz4ocOw7TkIzoxrrl39McHD9qNSDnTGj7kdjDRknhmcQoICZZAe0TuaarOmZo649b5TLmbCiIjWhOFPb26AuHvvXjMN53vvvPFP//F/PW6PX/m5X3zphU+M1UXl4s7dCAadERAEaQIGN+gzl1HqaStxPYtQlPPIN93/XJpKCM8A5/bdiTxEEAWrMqbLN7/xZ0nhnOLI2Rb8EFTdSJjTe57nBluut23WD/1LSDBy0xhnoL/+P4IBFnQIEDEDTUWD+nD5dXLzviEUNRWV1poSPnpf17Wv3v1wvL0+3L715uv3P7x/ux5vr28eP3isF+2nv/xzX//mN19/9dWHjx88fvJ0HAcU1pqTfUQyVCOcwUh3j3pszBAXzNxyC5nctqrWb0sLUAt38sw/lAOcL9OPPAA/7Ax/5JdOC/+Rc/Lxo3UeNKT+mv9VQUK0SHcUE0HVl81UnU7SVHdNFVTh0gyguN+5c3Xn7l3b7wB99plnri7uvfipT/3hH/zB53/sy3eu9rvlwhkQFTU1JUUUEUncqQABIsk+QFS0ANzZo35sIeQj/3g6MNz+si2Clm9lfjylQNrJs0x3wR+52jPLPnPxc7Nyr2eAOq352fEkUatIYeW+3EAzy8dWpjXjOAIEYsN9KoV/SAglfKRJNmnWtJkqMcbtusZ3v/edv/zLb779zjtjXfso0m14v7m5ffz48aPHTx49efT4wfWxr8OHqV3ur7qtx7Ufj90jMmnJvMHDI41epw2nayjXOzeF838fha4n5m7zw+f2/yPh/o/89XGYtAGBj8OFcpNyHqBOGGrGCU70islfZUomAlUIoFSKBxPsQFTSHahqOqThbKoQWQf3yyKi62GQ13vnbnfx8OHj924//PDRgycPHv/8L//ib/7qf/T8C8/try4u9pfOAKU1Xd1JmhmSUMzNlgxtSV4VJJsGKKc129Z5fsANjZaXOo+bG1jPUKeoiPCX3/gaQBH9EW6pjG0ir1NY3TJznra83meeI0K0vj5tmkIjgxKMNPyIisAAGYJZB4j8FBEAgkRmOqJaWa67GlSNMjSE9Mt28fDBw9vbp++8884rL//g7ffee/To0fXNzehrkG3Ry4tLCq+vj0+vnzx+fD36+MSLLz56dB3hJEf3w7qu69r7CMaIfDTkwxWXL4UTZXqBLbxt3n2CudqQwtNbqpDfFWdp8vlJ+KFj8P95BDj/6seQ0vkZ+PivdLJksQ31YgKFiFatIGLSEMki60wNAQFVpInsWtuZ7qT+RVTVTJvduXdnPfThXXe7n/zxn/hP/9P/2Ve/+ova2u7iUkS6+3JxAYq7u4eJjnCdeW0tYJKYuXaSTrRO+0wI5t9OZMNc/8wCJtN0Vlo4man85de/BiGgH42UJ8pi24vCSZh/+dgW5JucSlQ4o4rqZCpJIjxCgAiSHh4byxM+nCEzBCT4iXy4qMiRdqQCEfhYD4frH7zygzdef/PN1167fvy0D2c4iQAJxBh9DA+6D1W9urqi8Prp4eGjJw8fPj4OD0JFxDTI1XsfHowIMjw2pMVknDZiYvPhc4E2i9jQRa2+SBYQWKk7amuFcRZqtwDyHzbxHxk0tq/+0Be2A3ZmHz/i5yYfJTpD6xbTAK0Uns78q0At0wcG83MopJmqQkUa2Ex3zcQsGKDslmbLoiKk3H323kuf/Mwv/sIv/MTP/MyP//iX79291/aLaqPCtAUQ4YCoqXuIyVY+mjkhQRUFzphPnozs9DHPV+zEv81N2RKF+oZvfP1rIhTozB/OIrQIGQlPTtDxdP7rCeZ751+ZScbprzzBOEAZHhPrTxRN9wACou7OcM5ydL5LkBkammpla4QJ+6G/9uZr/92/+W9ef/0Ns7bIIhjCENW0YjjNDCZrH+u6rmOFiJqptfff/eC9D+8fD33kW+Z/gHyyQjiS7oakbJwPEzCcln7zmtPsJ7o7ORKWM6uF24AhP2bWH9nYjxr6fzhE/Pu++kNx40cenvyK1t5vH6MImulSpUCEzr8SEAVFRGeBzgAzFdDMEr6ToWr7i93Fxf7unTv7y4vLO3ce3xx++Zd/6fd+7/c+95kv0FQgFxeXIHRZRKCqqhYgIeGhKghChRGiWl58q8Ccr1mmFB9dl4+kBNjOzvTfZMPETFuwPk9wJ4m8LS0KCJ0t5/yqJL6ibP6+YpLMapUk2wRBkpFkVMQUbvm9VImJoI9upkq0xRhEuAgk4nC4ffudt958/Y0fvPry4wdPRGDwxUxC1sH15tDUlt0iTZzunaA0Nde2du/HFTxeXLSri4tmdnN7xBjUgMBINyHESYGKbjbAoGVqkOAI08yLHtrYzaKqtsL3R/iJqkhv66hleRNh/HvAz4+w1v/vvjo3foLj7dcpOuRZLz+nWxlPag+tjqwSCIgUYq4IWACdDMCDJlLnBTBbIDgc1rHG6NSnN/2dD8bw4/H4yiuv/fRP/tRnv/iFn/rJn/rkJz+12+8vRAFVkQinSIRbMxFxIcB8iMlhnckf5rGFyMkfzf9sKLVy3/yJ/JwCgco3vv41SEhFeNnc3NlubHHhtF78Ef9eKDKDxrbGUpKYrBlpOtmISCREctNPEDJiDB9Cz5ikqgIaZByP0X0d/dGjR+++9e67b7/+6OGT29unw7sZj7dr9AGKDw/Q1AiOKM4mqevhHhF9uLsn4AjCyafXt4fDYe19jEjphJMjIty5kTYsqU/ue2bJUYkK5NysSACqKrLBCzAiy78A3T31TxFRaFaFwRNf/f/PLzn7w9nrnfEk/NghmHuqsm0qzpCuCHSmAwgEQFEpwDCPfh0WTv8sIjDLLEDNzPLjp+ilmZotS9vv98d11f3+C1/4/M/9zFe+8pWvfOmLX3z2mefb3mzZydIUlhCsteYzEWF6lVOGI4woelTK/8rpU89c9fSHeWi2tfnG17+Gc9Ty0a8DG/zJP2nB2FN5YCaFM4vaEsGKAQASkbswSd+MAe5ABKGQ9K1wBALhIjTNMxtKDB9PHj9+4/XXX/7eyw/u318PhzH66N37sIal7WIdEdHJGAEwmC4cAbr7CI9wSe0dYoM2fUQEj+u6Dh+9e3h3Hx4+fIyI8BFp90EgTyzScKtwVMnvBGhFE6UtqapZSpXoEZHhAwAYHiNieHiiLam0v3ZAp9jlY3b87/11lkts6eEpo/3It3xUgnHu1HRmA8QmCstwpiqVDNQByPNAEpqmP7PL0yETmKqpmomZmkgepENfx3HdX1wuTW0xD0Zg1+zi6nLZ7z/zmc/++q/+8m/8xm++8ImXnnn+HqgQQpWgaCtVYTI4igiqysnJz/04mfkGfU4B4YeDowDzAPCsgnK2cqcgM53DObk5V1Y4qwv5CoLikLecI8mkAMIJBFQE4hwsrtEVAlEVRriJK+Dg4frm/oP7P/jud195+ZUH9+/7iOAABHD6UDVBlDVRA0oUZ5XEDcvT0z0tsPauNRHRdXg4nHFc19GHMwDpvR9772v3zIEnJYqAh3PSPKdFLkwvqtrMUJ8amjziLByoKiAekUEPkNX92DvHGGT3EZlTqp5lYGfrfEoPtjrnx3IAFodf3xCnI/ER9RHPfu4s8RCdAEhm9MLpHJpqnvVNEajz5esXiqyZVJgoICaWSBKRL6fNVBCROR5M9c7dO3na1ExMYKLaPv9jn/3lX/n1n/vKz371K181LrZTM2u7JUaWkiXIZPXTeDKKiqqQWU/Yzu8WoM5ygMlr5k5+4+t/CiQ44WboZ6wyz8HsyTFx+8/prFSQmi8eczUEGnUYoGQfXQR97Uq0ZukmhSEkww/H4/sfvvvhB++//vob99977/7DB/2wegQ8CJiJqTZRZA2hd49BkQGsVAiELphKzPnkwwdncq+muZ1B9IgxfPhYj334UNHwWH24u1ctzOcnRXfPl838tU4DORk/U7Paj+l1RFQAVamFUU2IyMDq3t27D4/ow4cPDgadtQ1nBvqxXz/in0/g54fKv2ch4CxQ/PC/nPYQZ6axYd1KiAtJFx25fcs8aLOusKE/mT5Tk3lXNGv5nSooGTalNbVmiQWgwoT7qi++9OLnP/e53/1rf/Xnf/6rzz/74sXVbr+/gMhwBxUCF41wERMhmUVTPZVrZs2Ym9mfg7vtAH/9L/5UZDsAH7Xvj0eAH8H7n5ZxwsICPxtoU5Ek9MOpmf1qSAhk7LW5D3o8evj40YP7b7759ltvv/HkyeMnjx4eDqvH0R1jHCkSSZAyWjMTFRWleV8TXx4jIE1MJOIj9K0UEALEmdwQlDFIFaWjx2BwDF9HD6fHaLZ46mBmshKRuUqlhol5EthkcUILFCAiRKAo3bWIWOYDpDMYFMmKdWUaYwxCVo/D2kfvvcBY1R5EZjSd/zk5Z1RHxEeoTUm0eRafIBt9S8ywcH4GPnaEzojuLepMW6kwgK0Csv3IFjaksFSBIkxeVURMRdSSMFWBzKCjQCa7QAgEpr0HEcuyXFzuIbLfXfzSL//C7/yV3/rZn/rZT7z4oraGBpUFogINST69NGMZRSc4LWuVj0SAiehzfb/x9T8lQ0SrxIPtzJ+vw+lEfdTyT78mJBJWIwZOhKgIIwzi7ho0Ee9Hwq8PN7dPb1977ZXXfvDKh++//+CDD9e++hhCqsJHbPaXGNK0lLsARdVgKmgGDw6BiAkklyA1oEDxqR4OIIJp1eQY7opmzTxrb87e/diPPlzNSCRoSgTPDfpMV+IR9JJHiCREnryQ5GZrZgKSyJlQFRPNNI1AgN3DYwTZPYazj3UMD0ZWHdydoEGQPGApZyTFySJIlUayUpllYEaPre6yObJtjz7ivz52eM6d2cfDiM5a3uQQz05O2rgKoDIVPBlBkkvLylqavqqmd9io/ojYWiWyJgeV4aGqCtlf7kzVdvvPfOrTv/Lrv/aHv/u7X/zCFwdid7lATMTcI5QmjQipE6DIbHO2bHz0c5abV7GCQJsW7+wbtwR68+nzHAgzp9xA0Lav2+mYjVCo9M4pFjF4edlw6N/53re/+73vfP9733vy6NHT69t903EcSo+gKuBOUlVMbQwPUlXCE+NqPo0rjWoipgyFavO0kTy0mVeKVRWBISIRTF1DcIzugNYnMQHhzuPxeHN7IBgh+QE293+CJUiBN08ijgIIpR1UkQRZqgXJg1SBmWLy1HmE1rUPdw8fnIaqtX1p2h6DESqZTupu2e12i2nS7jwPUNtZ9RFQieAYvY/hw71SmcAMX4BUb4TMlOLk7f9DvxLY/Ohetq1+tqGNaTWCaegCzXxJJN2BqpgqQCE26I6siFGamS4GwEmBLIsCtP1eAn/jj/7g93/v9z/7hS/tlmW3v9BQMbHWMiEjCGGMKGFTeeFtlU9xU2WDQJzcw0dQ/UcT55nNSpWYN0w0nzzLhrKVgrIpiybCoIwBoPXx9jtv/OP/5z9587U3nj55Gj6atiaIMRZIJgriVAOr0wdQSeZEUrJBZtKZfJxZxlejCENS2pB+NHMPihA0TAYTZIzeBx2sxC+dEI/9eHtz6B7uQaI86iaTLZJ3I3bnp9zSRwCEmaqq6STTCQhNLSFB1tkY0UcMH+FeHTaqrVnm6CSHe+8dRLN2sV92+/1+t7PWsHUTuY+I6lYRYXCQw31nTU0J6eFjeB997X24j54VcR8eTuZpzeNbcVo/FiB+uOY5d1nP2ZLNoc7cYa7nNOZTOiMTR82YoFI5rWhyIDIzWMIjRjgAE2vNRKFiEOy0yV7o/NSLn/rKV3/mT/6zP/n8Fz57dffeMdy7B0SbRoLuhPwfDXmnvxEQKlS+/hd/ClSlf0PxlTds9c3c//kKLN7nHARxLkaEKJEKyjzbYUK4XF20cXu8fvjon/zj//Jb3/rObX/qPcbx1mzHPhZr4WNEqGgzFcJBZoMjxKtiUKIlMVE1INlGRKYYCOUSLAlDnvdAcPYPxwlN+/CIQfdiYCLYffR1dO/eCz9tcZ7n9p7ORKYzmH5iWwiVbPkQSZ6iqHSTgkIEGRF9DJmCbUilESmEDXoETWS/3+13u/3FbrElzUoYZKReQ0QWMzX14e5jBGGTkxGFSASHR5B5yIa7R6x9jBE+Rncf6+rEiC0zOPm+j2ChzX63E/LDlQWcqWnkzMRO5jGXQhQiWnnC1rC1RYnSEakUzkxdDGRp1lpLdL9fFlHRZhcXu2fuPfs//+P/yW/+xu984jOfBHadzhGymFAJqknWg9KPzgNwooeEkjkAZ4Q4oR354YhWm5c4baaD3I7GXK0IEdTTw0w9QnxE9zva3r///je+/qd/+e/+7J133z0e1n48Hm6Pu/3F1W633y0a6FUt8YRO04GCgKmeYHjCRy1cTbrD6QHJXGrLQiSQkggHkaZAEAxnSKgH+xhr772PMXyMwSh1PCenFcFI2z3lUQX9ZpZfiYmIghRRUWySsUyBrSk9i5fZts/hPWlTFIiqTMk9PLyZLa0t1i4u9hf7RUQjvBD+JORS0AgACHd3FOpsJoQE4UTSuJxJaRpwIqPe+9rHsY+1j3WMql5udv8j3f9mN7OPHhX1Nywss5uxXK3M2FivWgWB7cknbsovzTqTzkSnSGRJCg3NDIAKTE0BU3P13XLnV3/5l//W3/3bv/jVX3ru+WcP4bXdEG2G4VtFH0UsnFl4QL7+53+6lZdn2rwxO3Lu/ecftla0uf/nHCk9RADxGGA6NbHG64dP+uPrf/nP/9mT++/ff/DhzfXh/oOHx+NRhNYWCdm1ZScagFclmbF51CQW5DS8QEUBUTNUB38Ewt1FTGaMZrXTMMjhTsKdHhGIcHeGwIbH2sdxPbqHj4LiPoICj8pxYgaTesFpIieSa7Z0ZCVlEwWlk2tmAra2iETThfQs+rr7sjRP1mhGmfAAYKpLaxDsd8t+v2uqmQ9sb6qZRUILpkUw3BHuTobmWaI4BZkiZ3Ikotqo5XszRPThh2M/HNfjcR2b8ruqF4KZSZ6LRdOL89TitHn8klJP/FCmJDM3zLfVKhbjDCoVWjyRrTOvqmR5GqMWlyAIOv3qzmUfPrhe7u888+xzf/SHf/A3/87f+synv4D90jx6gArvw5aWKFUyBuOsr5jSIBuu3RDgBl63OtYWAbYEZ3MPMvn+2A5LBjwAsXZrosSj+/e/+fWvffDeOxHH64ePR8d+dwFRDyc11NcxQiQ5GlpSB0klalTMYfpXxaQZIntmQgSudECCIuSQDZWn4ih9H0FVZnDMwq5H9DEqjywCJXNLZLsOtmoGQCZ+L0LmI6BongqZjR0TCmBdqZCLi9gtO0gohFo6b6EIdPSB7AsFTfRiv7vY7czM6a2pAs6gMMFB1BgFiZl7qGZkVwnOyrQ3bUAzkEBYlsATBGS/vpopiTDsxfYqd/d2e9yt3VcffTiAdXSOcFIB6mRgpxmc1OH5FqVX30JEKQVmSnpypJs6ZIYT2RBTVd5kRvcUXGjlUhlq0u2GSCjcMYKxcmcLjv3Rh/f/X//qXz989Pjv/72//+nPfc6rik81nWSyJEVcYonpxFuevBOa3WJT5rIbYuLm9qZ5bYYR8wDMz0anIMZYk/N4+ujmO9/65ve/9e3jze16ezMOR2nL8XDU3c5XQCTZGaQmItte1CAiYpWFV/90Zqu5m4UBSKcCwREOV2TpCqWtC+EIVzMVBNDMRtAFx/B19BgxPHyEOz2Y3P8Yvtl15tPbCTkDexs2rrbIXE3EDPOAEM1URLyPdfT9/mLfdq1BRcN9rL33tbUl03ITWUz3+91+t7TW1GBopprvnLBqI2yILAioiATogKejz3+EEAZBYS5RBZWSZHcuoQQ29kiAnUIv2t07+x5I1ZST19e3ax99XSMkQBONNsGlzN8Su3ATwBcBP0mmPCa6mVYdgDNELdVsMx2/ytzxM3uswKCpiA+EkELcPj0upmsPBvZ7f/2N199/9P7Fbvcn//C/eO7ZF0KwqIq14c4gxSUomro+FlcESeboowkPt8wPck6CnJ2Pk++jTPKZJFJEFhHCWL3voP2wvvnaK9/91rfff+/9S931p7cq6mRbWh/OPpwjkQDExExEqBIKBUQ5+QnmgZvvnkIHh4B0pWRZKgXNkKRoSUqgJNdjhEOGxmFd174eR7hjDO8eCbz7GMN7kIMhOa0IFdq2/dr245QKQBId1dYKkvNODNaHN1UIhoccjkOOTdtu0cUaBAw33V0se7PkOaUtbb9rS2u5SUH24ekSecrK0+rUUCkKySj9oZQ2mRohIZTS2oIAfFpUkOIElaKa8hCaCKlmYFMfripX++X69vbmqP3YGewe6lAzqLpHSOhW7Cr7ncXjJMlmcVgn+AF/2MywHQTZLF224E2QISGaXQcxNacaAoc7zXSMgCrItlw6+PTR9T//Z/9Cl/a/+l//o91uF8PdnXQzQ+hmxVJqboBoE/yf/BrP/+GMG92k0Sf/WL8HGMk/Jjjz4arkGC6yHm6//93vHY6H/bKI96bqERSYCAQ9fD0eSVETbaKtEVKcsEgqDwWzz3zrH5s1BkAzo2I2FYQCkqO/ss1MAW2LQlcfDAyM69trpYEyuh99rL27e5JudVR0eqCJXT8WHqeXmiURJPNcjqGUNzkyzIfn0jnclrbbt6XZfrdcQhSy7Gy/25spQbov+3a1vxAoI3r0adec7uWMnUNWKeiM4aPoJZGmAuRwpJxoxsIn+dxVLhiqpe5WKJSCQCgkmihBVfGIpvLcnTumqldX7n5zWPvhsHb36oxJ31+mkUy66bT6mXBPXZjIljLNIQxnwLFIAIg6IBI60/akISDiDMke3hn9AQ1CoUJR0dvbdXexu9R2/8GDf/5P/+nP/MxP/bW/9j8KjcV2wiVfwcOzEXnbXxJtA/7TrOpJZQ5l2BAwUBE4DT9Bc5B0J5kd5BDxMYaPiL6YHW5u337j9ffefWfcHvphpbv3IcJYexORiIaYZCnCB4eKNOGAGcQhjLPolB3anM8jmJSWTLWyVE9rqkFbS4maOjhuu4ita/fhVHjEcazHta/BCA7SS/g20S3nNlZGM6M0q9w/c8mN/UirzImCFckzFCioqktbri6W/W7fTKypkmBAdb9rOW5El3ZxcaFAHz5GzxLWTAcT0M13TUMKZvSqNdGsu6RLEJqiTP+crc6hBFIDBQTB0BBpyGQDWcgGhIh1wOzublGV3e4Ogjc3N+98+PC4RihElQGf7qi0fywWGJv5preteQflbGVSFJlZVzvIhp/PnA23FCH/KSqvBiCqiukcVfqhX+za6nHnYjne3Pzrf/JPP/3Si7/y67/x9PagAo6AWWttkpjlw0UTAs3gmh+mYsTJ0c4Ol4TEqFpgtbZG+n54wH3kfJ5wh0dbltvbww++/z0/HgyxgMfj0TPnQyMjwg2yWBNo0Y+p547yINSC1KI627VPxzUzVk7lnRAxH0yQvXsqqq0tAl7ur0g53B57H86xDj+OEZyeOmb8nbumyFSsSFed8BUnkI/6hlnSl/oiBGIqqYZvzZZmZmqa7eNqtZfhoBIIqtLURJQRw6P33kfPLZYJ+kHohMX1yQU1S2zTK6kgtcIb2Xe2swkvVMHQDFRJyqR1QoSiI6iKQARiwLmO7FZcdssnnr3zzJ19+Hj3/uPbQZLNlh6EwhL4JJZCbJFT02dlIBAxImYpUAouIYnC6WFmWIVm60jiyzRArQiIIHVWsTcKTU2zojPGuLPoy2+88m/+5b/68Z/8id3d5zl67lWz5jEICKslHnI+GIs4X7PNbfDEeUdOha3IlCRMgp8s3lAdUIiqKTAO/dVXvv/ogwfr7W1/emAE0lsFYVFimwznCABNRUUc9BhBQBQMTZSaQR0pjNnAlzBicGTdJF1JOmHNQ6MioLuLaTMb8IjR1/U4fF3HIEllGqVMKljmDwtU1GbRPgHumeOX+Y0iKk0mM0lRFZ1ynfMTYqqWbis/csBGg3K32P5i7xFj+Ho8eDBH2olmFVA3k8q3naNkygJmZpT8SERmuKKzTPkR909QRV1qQOwGAzwYiC6EGIIaFMHOGpWDgXCuh8aLl56/+8yd/X7/4Zv37x+Pg4hdE0IJT5mfzsZKZgdF1ie3Ma6qAExt0nj1UKemXgFA3biiGQMquBT3KjJxuInm8BYlFGL5uwqEx5vrb37nm3/+b//0N/76X7fd7rB2eEADhIkCQgmBRrBNRz+N/8T3nOe9E/lvlNCMBrPyGhRQGEm+BkWwHg+vv/bG48cPx+1hHG+tmTRZj6HZAiMSHCmW9GC2TWX0TArL6SKqZqaSCiCzlusrKuE50bTcgopYs5nhzAkzlAhGOEsIEIhsPKMSEhCVGQm1tZqIrCZ1hKa0NhVdWX8xU8yhYlmRSEFLvatslDayogmp/lWtjRbSPYgIM12WJSGQiIwxhvu6dhDaTLPh1iChQORJYpEOM/lKjzl5RJIBegSU81RkNN9QpIiKQSO2gWQJeJhDhB2iFZzY1Cxr2hDCr6+fvvDMnWev7nzx86ZLe//Dhw+f3nSnCGTRGaEoOTKltN9kaLK4iOz8rvlNwDbuqTL3rANuRYJ6Ym65FiYuPyUU+X0pxM14Kyo7BRm9j3c/eO+f/7N/9rkvf/FLX/7xlk3GItCMfukOhEA7IzhndxLLeQTTa4hMsj9XrSSIdRoIRPVZAUEXF+/r1cXuey9/7/333qaPcTgYybGyBo0ncVgIT8VAZisII9qyRFiMHuFARESoNqMoHNMT5Koo6LmEFUdybAE58XcwGE6G+3rsEQHhfr+o2o70AFUAVNMeEueIqjJK2q4iZrq0ZlPfkNxEmjZR48Wl/HP1BpjlYVJJFn9K1sbw3EwTtazt61ZqLHNNwRw9oGqmIFSY7cMpf0g5wMZuFecOTiqF9KBEzvQufk9m8lyZgoYoZUt4aihiAPVmZWEBAirNFAyNwePNAn3x8uruF+9ctv3R3+7XB5fIdpcYPVQbsKhm8KygI3CPMZweEgADHpQcOZw8RkWCbLX0KtJQqziMCXekQkOQORjTo6ma2G6x3bK7uGzhnQ3kaqY+1jfffesvv/4XX/jSl5JXoEfM3i2QWR5sReNgzgUq2o+TiargEHQBknCLSgRqbkhKxzITRQQVBjlc37zx6uvreoz11kf30QHEcIV4hFhDUICIUAHLsGrLmtmITifB6A6yN1vaopYMLraW6DxMCFCiktWqRlbcSpv2YDN1xZVeXl7uSSXhKHV0dv9aifh10UzxAJUmoq2pimSel8SUiRSVsdExrpJtMS1reOkmPPL1c9aENFOrHBGtmUG1mWrC4ixPh5pEhKgkrLeWbDDCw8qmKTMdL6mMCuJU4Q8Q7mK6Re6zAI6cgphJKJmfUiHNIBQhNCpPREqnJIjFNMwFj4+H7rj7zLN39xef/dTzR19fefu9x4fOwH6x7kMAVTg9p2e1ZiIw0WXRQIvUvmbBhV55l073T3qEZkdXtk9UZDDkadjUq2BrJoP7ZVkoF8v+4qI998wzbdHb9TB03KyxMtDl8aPHr7z22v3H95+79wmEy24HYnqGBF3aprXHxD2YzOaJDD2DR1seXEUJciYJeQQQBjPVp0+fvPX2m/1w67fHvh4NGD1doLFGviGDeswkKd9EFaLN3EIjh/SMMTS8xOjlCIRR9QESkBCK5MwJmWBZpDrQKNIExIIM9kKiD199aKKbRVsTFVOBQdQWyQE0s2VDJpkt1XEkMxFmDhASaYsVn5Zyoj48Itt+I9GSbnlC5RXSrJkqJEDz4Qox1RgjIiQAg6kjG54gJkqle2Gd+fEknTpkQ8pbmTqEKlouTCZ7okwIXuLPzDIVsCQWfc69IHIupSt6cKGAYLYVHQ7LYp985q4prMkP3nn3cNu9DxOoVo2dAMNj5aIqi6i2RSGt5XKN2QFXCq2kM5nLKzEjmiTfKhUct5KxCrUJFLbYbml3rq5e+sSzL33yRVF578N3P3jwYIDYL+zjeLx+//233nz55ed/4fkkxzRvAlAohISqtHKihXhmTjUT+bR7YQWeTQWPyoyLcN9yclONGDu1h/cfrusqQD+uRlGTwBh0E8vEWbb6HlJcFUGaZMuHLEsbw1MbkUxrXzt2mWjCI+eeiwOQwMgB9slKJoE7ZxLOcQxmWvffpLyoaTPFMlmL7NQnIKHhotL0tBAydZw5Nr8100meEEz9c4IIJ8foQYYz0bkmmZPgOBGXSiGkmekNH46ggoqsj4R7DIDgDqbNBGoa4TJRv5Aq6ohqBRQVQiGTHUIwFQysQLCN3khTMrEcUhaUvEYhC7YRcM9zxkj6S2P1ULgwwKN3PR6lmV3o3avLz7z4fES8+94HD54ch8MjpEngBAsdoQ5noLXFZGemprFr7rsxvLv7GNmigaovh1o28U5omAQViytVhWAxU21y7+7V83evPvvpT37+ky988pMvjnW8eG//g0XffO8dN4q1fnN88N77r3z32z/9Mz+/3+85BjPPhgFMvWJLLgHbAZuliw0MoRxtpliVJEe1ixS/hsgWQ1EJDdEYH7z/1mVbjkfTmlApPTjCQ3zLmQGqWuFpkXRMGa1TJp5SxmY6PIa7hau2OocxU3JJY6sJTSCp0JyzhRxiTxBLaxHc+l2pKPKaBIOeo1MGSdvZzlpbWt3egRwSN1vGMV1B5VQnFF8NN5612/wQTNU7p01oNoupmoiEgOhj5KSWxIcKyenBAMO9dwRB05aGLBMEJuNYQyW5aVUF4mQg68CSCw3MeWoiA65QVcuZZ6wcOAfpuQMhkr2YnjngGNaUIj1w2133y3GMZe3UG4g+c2H6qWdMfMWHT667J1Q0tXQqEaWrBdjHCEmapjVbTHyxyxHOJed2zF9FcA2yAkBiAxUyFLJrTUxVTS+a3t3L3Qs2DZXlqn36089/4YvPPf/C7uLb/dXX36Jjv9jx6cOXv/MtP97q1WXvTmtaiYkIEIEG4KRu38hj2RIkzBpA+rsoFkJOgkBOPlaqtcSPt4f7HzwQsIka1QOOldBsbZyDqMsUBFs6JkKJ8AAjBpCwMGZcYvehZpWJgiAHA8JmFiAiSnzsARV4al9yjA+FCIkc7Q/WGkrUnRxOj5xnJrosLYmKuXXYSJVMryEMOEnNFpxMGD105s3Izp4CmfmPMJWEVQm/IwIhffTV1wAiRjXiZ9uCMCdIKJ2EojlRMWNy/FsSXPnT9FbFzyIvcdnwUtZ2iojKkcM4/1+BNIIIURWERyEBlQAG5Dhit6c0uenr0gLh0vRykS986rndTr/7+nuPb324M7CGm8jSmpk21aaWlUFJfapDRRYz2zdqSjsZwRxIM8Zwhq+eZ6dqMISqLYsBxAjZwXRZ+/Hh0+HjluvT3TKev/jcM89cffmLn1YcmvK9tz+MkH64ee2N16+fPHn2pZeOx247iYikoRwUSIuIqebBXJQM/PM8zFpnOdxa54T+afWqivDYiRhjuL/77luPHnyA0fvhsJgN97XHYKioiEGIoJlljy83No5J+ngeLxVRMQW7d6+3jjFGDpIQ0ZGEgbALlGYaMWimEBEXUSEREtn+MaaaWVVNjdOGZk5ToF4scXXk1RDTpCafkx88MvXJRhNuSVIlpzVk8lTfB6SZmWjexEbSh2dc6msPupPdxxjD6QDoGWhYPY8h4tKsZeANL/aAFJOqHOZlFQV2RCgG5CQCarVezZNT1YTybRNtJ08LiEJDmSyuBINRqmsfocbW3doyGC0cvvoaFxf75y7v7Jbnjv347oePb67HbXdr2SDjC5qJqollPK5jYNakqQGoprZsGWqNwR7eR1zsUXOTMAlmyJzTFOMQTb2PcRSMW5Ob63V9vMPNT/3Ej+92+y989ouCZS/Lu+8/bBE+1vfeeftzX/ryYubuWaDJdFdUG+YEeNYB2FJLnDa3xsRXllXbmDLSihgCEKoS0m+PL7/88s319bg9Hp7eLmYMCUBFYxYgsvmV0wzztYe7QCOlS0AWAUQHB4IevXrjObiYZY8APScCDCJMrUE9qnYmFBWo5e2T7oNBqmpDphDUrqrZYKE2iX1RiZwIHkMgojlTvpxB0kt1ZFILUpMEim1nlgNERZjlxjxymTMw5yLNqZnVyi4c7sHIofuVHYmoaY6LTz5oHaFQL8YxY3AVgxTiKYMopkcgUpcfoXosg0y2MSNABuJN7kIgMaMoJikBMY3uTqdLU6FEZ/QsYCsCYSa9jzhG2+8Wky9+9vnn7lw+fXR49+H146eHQyeFB1/VtHlbTNvOdFZ6IjBIUwHQR4A1ux+EAvv9bgSHV4Ebta6SswKcwfA4eqyBJj3iw35c+7E/uY6un37ppWc/8dyLL750e3tj+93Tm8P9h7d9dG3KEWrqpBbpQjJSkhMTymzuDKW43DrFasMrL56/JTXKBVi9CziOh/cevP3OO29z+FiPQQ4ye55BIXKiP81mxSHflTmqYZg2kLRCwbNaiKRTOESQ+j2ZcaDmClJybigkwPDsrjXTSnEozgiPPrzrSG9iaq3BrInOmg8IQclKq+dg+6ylwqgy51wsmZIQINltE5ggrIh26ExNUMXR/EdkxA+mEi+yUSd9TREBgIhEJJUTdO9M0TinD0s3MvuoRPK2tyDDh3AOdKsYGx6YiHpObMcmWUbGdkGpcpIhqfgcqUnR1EmPHsu+DaeIiLWx+vX19d4unr939fzF1ePL26u7+zc+ePD48VFcb0dSuuzucaSauMDmCB5RaWatGYHB0AKcQveARM7x8MwVJQKqqoYFWsmFj13YAsXgKv6Ih29862UyRHh5dfXpF1+62N95650Pj972y95EIfRAyeemJq5tM/ums5/uvID5/E8VezKNnpUniHMI6ZoTA/X2cHzjtTcONzc+/Hi7mqiPgChUIyhiORVORNLfpSvTHNrDAII5NVHgNfCDqLascO/ZfRVBYlcizDwD4PAx57oCEKY+IhXRadngiCGUGluoMJFlaaomKSkNBMN9zLJRQDAyNZ/q3nzgLAMm83oOLgg4Q2Y7p0JSfJMISchA0Bkimfe5p+Ez701JSidIZaT0pzXDPIdkDB8gm5lu0wvz8g6p83nCaWcPBs7ZHChu/cSZsm6Byi1P6EOP+mFIPVuoqIKyBtbui5lajvVtDh47PFY56NXl/t6zV8vVsr/THj26ffr49uYo17fHdQTH6MmE7RcBe+QcK+lj4CBIpVTk/BilyHGEe9btZydg0tCqSyYViggc+xq0Zd9C7elh1cdPXn7lbbH2yU/Incvl8mL/wkvPvfiFz336xz7PDNFVAyk9hQCNpCjmlRSc8Igb5GH5hkqWsiAsBBmAavigWnBRjLG+885b77779li79yFMDWqEWOa8AkqWgHOkRG4eJRgepYfIFFBUwp3h5X0La0n2zbgERs+BlSbqpdxkyNQzZpE4YkhUoVhMVTSgAlHN6BYsRCYIp2QLbQQ0WwE3EUGt1RYcMbWMiagpBZSqACcl38oazjaOY55nAT3G8BhBASOrgRLMa1hTogmMsNZqgInkmkUCpKgJ8kqT8ziZrKXEJrtMfYlUYScS6OR9UpmUpg4BoCXJGJBQCa0pBAmictyAeEigI1ZBE1mudiEIgUNBXFjr4Ydj35ndWXZ2L65Unuysuz05rE9vj357PB76OtxXDk5ANvt9colN0w0Vz5V0S/jY0EZW/bqoNtlzUVNVOoOHDsqF7fpRPnxw++wHT4zCZ+/B9HOf+fyXf+rnPvmpT/XRW2vQNjxAqTm1YJuYVrbdLXByCgpFBE2R/bk2VwRqSDCn683T73znOx8++HAdh1jHrBYVgGaESg4t1GxbzmJqJKmZt8FE5KuGRw4nzD3KrU0hx4jAcIhBmFNlIBIRyXBnPpJmBtbAF87LvlPlo1klVQnGcYwGhJRuAmc1jnStRV9sSChXSOpU5XlNTZFsyfB8DNkqOuWFWROAs1LmTkk8G5OMzpfL2o+Q4aSIAaSUlJLBiNSUskHNlDkMALOmMbOj+SFkA6uz4EoFbRb6kMAx33Hj/MgRo/uIcGFU20yzCHHP82sIETUw+pEHlWd2dx1x8I7ujkDw3tUCtufu7Y/jzu3T68fX66On6+Ob0UdfYKLaYwxQEAp1MkdbpBYRUgyDyISg5dgYZI7DXKDWEulhRBzJttfrm8PT69s7F8ZY79y52j9z7969O7vd/tBjCNXmlTgzxlX9sjK6E+iZaRZAhFAx8eIEiRDR1PhFdBtopq+8/fr99z883Byl0z3a0vqhByhMRJwZHtxHvqOcKPUEhLV9sp2K+QVRSUeRhzKhdHm0SQZOT0fYRt+CQIDhKTeQVC0mwE22Onx0VndH0uJFYGYmWsu/1ZY35vzsggaRzQtncqkiFM8fzLcrvUYeguw9SA5JKqwmt5tHNK21wkk1ilILkmcBzjP5BqxUpwVgspDKGYVQvh+bbmtL5wKRRaUJx6U4jZyvlQKmcB8+BGJmBkOQlOHubOvwMBEnoIHR13GzrHeuLpzDu/s4ItCamlBN7ixtLJfPPXv3/nX09x/J9dqaxjoUYtYApVPCBz1n1quENTu14m8gve7JJaEDRsESuixFclHhFAfuP37ywgt3H99c01Sf3qx97HcX18enqfqVjeMBALTYEqGz7oPZlob689xsPfmzNK6AkOEp3n7jjbcOx6OAjmGLxRhQScl6sURzdlvZAyfEDzJFUZGXH21frbrIFtOZFUOhhJsZPQFJzC0ufgVV9izQTkF2ZjFiMIS6W5asz7oTPgJQSnZmARJRVLps9j2NPJ9DZfZ/QUhPXhk1zVvVtjnV5UgIZEo3chSp+8gbV2NeXbhxfbm2UgNFslt+C89qGhGsseAnB59Efx6kUs1MT46cYzd3PMm3HAceNVAWmWUKAFVETbeeHYggctqTOmB5BrqHlTApggwc3UWPS7NlMS4tfIT03l0aQyAurcF2ZhdXt4wHu6cPH1zf3B6bWtvtqGBCUNHiDqY7wJlJYqJMEaUWiglIBNTELK/SQAiurw+3N4dn7i3rcX308MnTp09y+bWpRAh9hnQBpE0/sSUAUhlXoR1MlyjTqorQgEh4iMJUYsT9px++/+774zBur4+LyHHtNpe9hufTq5iqNb+tmKZp50HJoksO1Ex7L/oV1QxWiB4cXv3nJyAeyOJmhMyALySgyIadTJejsE+QdeMUiCQ6qktw3rNAMlREtJmxEkpOIoizjzVNMP+imEul1VXMzAGS5xlj9OFCeORclgT3aWdRbNEMu6i/zImBUedatHLljNcBNrW5S5JNJFrrxlw4Yc4Th5a25uT/NkIj7ava15Na2gS/QF79ooRTR2B4DA8VMZUgh7tzxAo7tmd3V7u2cOdxCMDX1dsSJiJOVVtk97mXnkfw5snt00B3h7mwORIl5ANJTtHXrRRc/r0KelnlUxUrbwlQUBSKUm0lHz+5uXfvGZg8ur59/PTJcM/9yymxKsVMiKBxuv85M6isXzCXcINFKDhQIpc8knARjbV//zvfv310HRi7vaEHVNwjD2zUpRJg3Y3nNUhiGhA2f1Vzm9PcC8XWPMPcchaQlWwYQA46yRJL+uPslCoHnSiitrGwCFBDP2ENWiOrCgxkDwq2VSAFcPdMQk5KqHK+kXNuBFLQVWYPFznCBchmtzFG+n/WdOrUsWYLFbI95XRBbplyBeXMlYKnGaAAJMfvkX24LNJyBrQgAWMI1bQo9MKOzDK+ztAl5fOlaM+8F0csa4IhtXozq0eQ3UNUW4S7uDuspe+BEM4Rfns4Xl1etF3bLXshxvEYyFflIFuM4KHJ1fNXF+83WRRBeB/ZwZMGpZswZ/LLwgqOEysmpyh6Gr+vBJKVddFQCnBzuL25Xp55bk/Gk0dPpKJxdoxmW0Ueem2YnqKG79SHLqPkdHAsXkizpgURE3H4TnX0+OD+e6/94DUh4ujr7boTi3VAKKGRcxYoObxjhnPOe/JOv0BGFvBVUiwtFXjK5ApTA/QgOmlhWfGt2qumPK4OSvrL5H7BKSNVUYAxPBYnTcVgIVo5SVY6RIQRtEDeayBCMIUc51QPNgZ9TrzEXLnJpEne3jHcK9IEIR6bD54uJmaRFNMxb/EtD/HGSmBOVsvvLoUKZ90ZoaJNKwyeHZl8I243M+ViZiIMCDnyfi+y6o0xuQDZGKMgPQYxKB4ahAFqqkNdAKJ7v7m9bXqxmC6200WP4wgeAEB57Lc0F8eFxPP3Lq+f3BwH+giKUIkBU8zMc7LOuZhRj3oavsEw5qjklKlSTYDw4Z3Yt6X3cTiu7frWLp+9PtyEe4IeU+FkxnIhdPr/CfhO3nK64PofQEmKiqBCnSPG4ODh9vaN1954/ODR4ea6r4fLZddHP88mQgSMJGFlIij+0K96l3l7ZNk7ZsybllepM3Lq5RxhhS0PNlFOxFwsjWw4TtJUE/6OMWJ4hGueuhpKeTa6m2dWMwFZ+QHMDHcyXTNoMDX6ibzzyqWIcPee17WmCeaQzMkBiGiKYucHzVRtMgFFFydG0QTxwz1xbArJ6jzIqSc9YXTMtS0AN3cSgkSBtfebExSpVtKUBklSBZzVhURi4e5rH94HZz0kCxMcPN4eDrdHOtWsLbu2LNKWIdJJtXZxsbdGtXj+2TvP3LmwCbU5p3qhcqcN/kvtGWarabbGIelHk63sgy10JwtXmBPA4fqmr6tqMmebHxQIVLXJnPO8/cogMG31DC2CuTEacLoSJvDe33799Vde+b7fHtfjQZ0jw2GOAxGJbAaUbAAKUjdnxpl9zILNzDXmYDaeItL23ZyuGiNbvCD71ja8A0Cz1b1EjVXgxHbtVZx0o0GXMCptylC3bHJz7bJpyGoNNryYM4UT5Um5phmr8vCEpz6UNXA6GHQRy5dmFlQmvJRK2ieUwYzw81EAMZUI+pYhgduxAwtDwJm91Rv/efIhmEGLhX2iOumLihfOD4S8gYsT0QUoxRGUyYaHu3v2TEPEg2KIiOPtzaLY7y6bWWuXx84+RMTElMFlb+sYlxfthRefuek9DhyR3D8y1NZnneawxb0sUmd1OwmKpMVkIujahCAJDx7Xdbffq/cn10+HD9stI6hqBe1zegDZZtAp80J52NzE07YXGBIImNuqxsXa40cfvPz97z784IH7MdaBoELCkXJrMkQsU8Qz9olnH6w2JMVT5aFOnqpyXgFEFcE8GREhreVrBt1DWzGIBWCmxoXzHaQSx7Qe0Ba1LFNJacAAaPZrp+2KTF+Tty5s+GaCk4Sk023OACpIkrEQe5BzlAAzhVaenZBS6JVWQsHUjNTi12DbKbjabmBgjX2uZ/QI8wigLXPIzUm3Xs87HWolW0m2pvUnsK3PVBBzy2ss7x6Zb4v6vNk4EEHSNFVuyshbEH3tfHJ9M5zP3LmnakvbQ8V9rUAyaCoL5bk7l0+fu9fff+w+rYuK091mUgXwDVciO1pOqx8IFROUq54YNMOmAFh9XYibmxsfQ/cFTgGcX5vT0uNMpydFJHCu+OYwcvcAAkYJhlEU8sYbP7j//vvjeNiLrWPszYbnNY2Rkx2m7pDEVqcV4mwYAKAQT2HKxGIyP/O0/zr/IloD/VJUA4SibCGd5zRRrTQuK2yVrU0bgETdYQFRAttE86kNhZllS26a7bSBQsTATKOmdRSpSWG4iGaWETWLP2HqxP0x+ypyDs8sJJcMZ0sCydwan2OCc0h1MPLeyzHCVHdtoTM0xCwbZ6e/FNbhLicmkwEvO5Cqt6G0AZRUcUuRarVmqnAPhlAtq55ZSgsEFYA7BREedB+B6CHKYx8RMG2XF3sxVW1BunvOiFBFIy527dl7V0+vDwc/cMDhFUpwHqgKCE/3XtFWUeXV1BQkoFGIKaonhGBgv+wQ3vt6XA/t6k4mlGAyhpUKt+kptx1OY52ws84JQgKRdoVQNwUGH9x//63X3uq9G8VHb2KRXehTRpCDZh3O4BxGUwysxKxGY5NmbNBdvFo0hEVqJ2yhFps6M00yIKHqpDHZeMk1q3BD8MSKTwogh4lNeWRTk5l6aXXGM0c+gPScM7dBsXRVs+GsfMqWyeQcNvGMA1PqUZEon8HBYGhdNZ1nVbYpJtWvkB8gCEiEo7LW7bZWySMHYmhIhLpwmcZBDXoVBERjqrnSNVTCIjO7yvdXMTRI9iHVvGGzpmZ0JKuUHz3m1agZoIa7AdStWDm6UwImvD12tQNU9/sGVZEGSbQzEn4207sX7XIvuxscCJ2QFUDqEiuIy0RrExZmnCyR4/TdZDi9UU1F6KY7Bnxwp3a8XY9PD888p8FCnoClkQBoaY0bUzDhUBHUtXkEgBA0odPVYxHph9vXX335wYcfxHEdx9UC47iaafZVUSQQAQzlyNvDaZyTpCdzkS5P5gaJsiZGBBiA1+zLTAe3WJ7TpazGWUGCtFShoa6OzdBZwUTqc5UXqa/VACmpUf6UeTqalbAni7Wbjdci0KVY4HLdwXDO2eWcYofy0yHVvoPph8sJs/4MJSJAPW1BrvpcjxxZfjrwmPpWVjkLqY0YEQ0tXb8CTDyR+XSmqlbOcebsEzfkx038tUnPIjHlvN6TwZw7Vj4KgA6PPgbpzayZqloPHxFmCkj0YWsXu6VeLGaECJsiekj26S1N9oveu2g3e1mPHMwyq0y6YkuGM35Gg81tSOdRBztXJAQeHkqENl1MVWiiO+8Okfc+ePfTX/qyQ2PmW6xR39IK2SXxd7YHm6FM9iWFW+Jr3+139PHhe+9991vfWQ839HWnOvoaZMQoqjPzhUnCJcmX9/LEfKMq7oACMVUy+fD65ygnV4XoGqMh86o2QV64noOZXMUglCh1QR3fOttSmSq2XwSDYWhQePi8yxnZGUAyEO5ZB8uyQzamQYqyFgL08Jm0ska4sK46Bd2r/QxMuFybFyW9qqGCgawmR5GTwUxADFIrNPPd+WLs7hEx6KA2cDGlKgUe847ExFME5uC8aUsz5Kic8pjICXXbESOdqPTglEqdPYhubOG6OkxsrxSIqgvWcCV3TVTk0LsYpGm0lpdDQlRNfAxS1KnQu1cXD5/cgFkziag+6gJ9nLREBg1ABFYWM8epbDuazJ2cpVS+DjNfPY63x2bLoY+c7TH1kQTQpE7D5B3nPmEe9cQhBg1gIaDAOF4/ePz9V771+MF9sK/Xt5FD9rM7RbJwOFEH2FJTWw6seJ95gx9Pk1ILS8CZUq4tW+ZMoTmPQ4VFAZhVVVU1DYppuoPy4twomi0ZLHuYO+ohkl3vzFkJyVll13i+QkiUmQdFa5dSTzPlrZEsefZzVuI7J/mQ87Nv7husieWZVWZfvm4ICEDeEHXCwNsj592ZgACawmsnXeAiDiKitIflPGUGfWxEy9zZmTPO45WIQoFQyRYbNc05KVtSkhJuoQhkiJhG4k+p3CLfXNbVrWmwqwEHiSV2S8txkSrmWVIMLqaXF8tu0Z169h/1wgdzYkD5HIBkAKm/gATZRGbpZKY9WoGDQGtNbaFI0AHc3l6HDxUZEFiOABAwRKSl+JQnaz+1AJCoKly6nnA22ZutT29ff/XVN19/kz6E7mvPb1DRkOKlgw5mzWnuP2sWRbGhQJVXTuqkjE4K+Lmvrs2UkwCHrGn400GVoCkZgElb1hyv06GeQ3GS32EwpO7H6hI5NgMyJfhggO6p+ZWMEhmYWEC00GHiuUygowSlZFbz58Vkid2n7eWz5TuHzOuYMu2q3oFZ3J+op5r7a5C1s46KVtIYZGRPNE+UiIOq6n4CzxvI5rTXzJKyDVlEE4rmLHIkWVRdMdV+H6zGmqZVxxgBrVuBRNXUWroFDxfR0Ucz6wDIJW+1TVm6jOHexETFGmCgz3vqMiMvDrs2PAeHeAxIi0nzbV5MtPzHTFzZTIWhAh+jLRfXT5/ult3Tw1H3rWcSMamuVk54tnpw0lBk+kUXKEkV9NEXajAePrj/7W996/GDhzZwPNzCYzAoSNhAYCpRTt0ZrDHPstllzM+YT61npn7mllhhojYQxaiWY6ggna44gjOtK9dXWUPVyUCUHnXiHIzhIcG8UE3EZEoeGQBVxcygORA60VXKFVJrU1riYI2Qmh67Rp5qevGT898ygVL3JUwHY5MVcaNpAhCZPcEMCIXuc6DqjIPF2VQzJiaBwWxpr8BRZSHmuBGR8zA4/xhIyDVNiKbWh8+rLss/bYE6nzNCTEBFthCpWN6EnPUBE4VaBPpwFdHt7qvFBAqYh8NDQBOYwX3G7EkAVbZeN8tO0XeQQrTi4oqyIm2O2FKBmWVHeDKpu2U53B7Wdd0tzVURnrsEYYS3+eE2tEeZ10Mgi0pKcerCGiLi/M63//L25uZwfdgJNdjLtDDL7mW5G3VyeoO5wNPUuS1rGgU3suV0FMA5H29mJVlf43bgJT9QjvbT0/wQ1K11gnw+mWZIbFbJQt2kKgwq5j5yXg2AtmhrptY0+wmCKhbugJiJJ3Iq4ibHeHm1NmbHWymXI+Z+TnvPTyJbdPqI+nbSoQBENPk3z/YxVkIuVfXSTGLr7odUGmXLLeUjknKp+5V11vW4JZmEpMq34nQe55zjmRCv0Fs+8sxkEGTqXrOJh+pCI8JjuAeM3UE0HdKFABu0E6SbAUFV9fBjXyOPBhDuai2nPs6ax9ywUyRKjQfy8o/EZ6Xa1aoYm6kAQR997C8vILy+uV77UfZ3JWiqjpjVWWkJ8jeSKRGpqGTvIkUbeMRgHxfNjrc39997//VXXn/y4LEyLtry+MkNpTYm3SSrpSeRLSJ9vxTHL6iX5TTfXPdsfZogrNxMeZyJAz/CEDPymUWUwRDXbBlJu8hdOi0iTgXDeaxiIqQsUChyxzXnNrj7cD+sYarLrpnZbrcIJXLCPgCJQM4OAbMhp7p6M13Tkg1keyS3Oavl8NMQdYap+WE3FR823gb1QpVhz1KKCKApC0tiIBVG5QcrxmCCNKgUJVWBlpuvkSm7UBR2oqYmV2xObKil1Io6+ZORj1v+h9N2NrkE58srqxkjhriptiYCNG0U9kEf2/CurGRiAwvb7pGne/pIwrSovGp1khp0Y5LZdmKEqOAjx9vr4/Xtvl1R1AMBwayptQJa6TLT6+fbGyJSMx4KKnXZLY8+OHzzL78xjr3324vd8vTptTRNFXGPcQrzgtKJ82RzMUP/uasDzmQqMsMQZ7vAZq6bLqOMueSfZ9Fkgq55J/ZHXn87TzPO5LghEcCa5Kw4SVFhCCCmjhgRw1cIsMrS7GLs98tut+yRFpIypAgVpWN72Ep1Z2pStpyrLKjChqDqIKghSSclxZRvzMxMyHT/6d8rpc85ipZDcxI1BKuliNyWpP5bUDHTcYdMzSuBOSpiewrOC2AkgT2RXfn1Wvn0IlAU2wEir6ZMYk7ArMEl7Uc43WjDwwBCQxkBM6VQTftAd6qKkqw7YKaukFu+zhywVekwUteaU3xruZLSNpGl6WKWL2Jqy7JQZTAe3zz+5CdegLvINg4KloWwqDc5xV+BREjd8yUm4K6128fXL//gu2+98tbtzdO4iRu53Ykdfc3CskdQtIT2E9OcvA0rRmAiorPznUE98yiphLki3kb/FewkKmWU4hyQjuksK0q9UcUW6MdiKVjUeDpfBpAqKQoQns2YdAdUY8gYK4h1Re9j3ce+RVuWJWdZZzqevktAT0pWtkkRm4pczj9ulPpCKnpP/wqe6Ib8zCDr6r7IC96Rk0JZxLHO0rkwQU75UJ2pVj6jVKIyJZDFLaanTSICGwYqT1KdZmoiOTIg5OSlSlQNBOlOiIazTJQlWhGIiHUiBj1iD0WOdXHsmnhA6dH9dvUxxAmxJi5bh04lN1GSJqnlnNmkqJhlzlCeQwhQRXYtE4BQa4nKm+i4PcYYjIgeTKhQFzVIk9I+zeMkgjlVrRJbi6vdVay3H7z33p9/7S+O10843PtqizjEg2rizJ6TAE94EZNZO/npcpMTdGGzXJ1HBhOZs6Ylzh+oMLV50lOr4eRJgrODMSNzvu4JWGHLKzCLb9AgQdfSWQkCHnSQwPAkPIyK8DisY/jt2vziImLZZcUYUhPaMt6FB3HmqlEV3DTDbSjApLa1Pg1nVkJyolFAcmhmzJtvygNvCCFRUwRVStWDObuXm4OR9ClbbMHkglhYc74ZZivWfH0VUwXUIIMCUKV4Ecmie8zwEjlJ2nNl42zoHEFxUjnCEbvW1EzR65ZHrGM8eno8BFzNnU1Mz9wUJv9ZR6JwrGjNQJjqF0BMmure9GKxoqdAMQvy2FeHro8ePrj//guf/QLEGFQYI0AdjDbRzyRABQA0OS3QFQ1ojrfff+/P/+xrjx8+XJzivr9YhsfqfUQoJJv7PFfXGdlUlRuUjkurm2Ti8BnxCzTXu8vkSTELBfm3PEXTDKa4YDaJyyyTTXAtJiqVKW7ACidibapgONFXirxzvE75YIiowUlRzlJ0X3sfcezj6sIv9vtWN2NVbXMa8CzJYE574uammHcV5tCefK9SWEvFuGm6pTUga4Z7Lcvk2zmlaVKIMH26cAvoyD9xThsq4ujkZ+rPU97G7ccyLuTIIZYymmDev5m5do0STmVmHidnhq6s8tUdn7l0cIg0MQKghxjgPm5vD7370+vDsdNFCQ2B5tzmDcdt+iWZsUpIYETd6EGyqTToTuWiScvQJLTWBGqLkVj7uDk+fOu1137iq79k2tY+rC2rh8DYe1OrORqFVsvNUAlKLKK7pt7X115+9a233tSQ3lf0tUEFiDipAllxttrPpeLmFLiyIvCWE5y92wS2c9glqiw9v3dahUoVy2tW1GQXZ+pZCNuyWwozFZAZVjiLbxk/iILg08NMelIgzFoQBaXsUcvKrgeVfVzz2P3ycr9bDICSZql1ElCcHsWcn+YolRvOf5I6wWdVBZRZEpDiWKJ4UJYEIX+yYHv+MbOILROW8iCJavKj6OxtmSAsF55zWU9C18mlFIvHUECtLszJn85yRoCesxMFs6u0gCzm5KE8HJm95N6LwAcFrirD/fp2Xd17P5Op6FRzzU5ukfR2HmDm5Vrz6/J4qGqY2U71Yqcm0rLMQ5HShuwiKMaHDx5++Oghg1ySQwqUzElb4j2PecUC6yQPhvlYVGNdH7z73g9e+/7Th0/Xw+3dZX99vJbdchg+xmAJsOEiTNpxQl8WaGGBWWLmWdmYi5ysEKdi7UYC1xZvjTHTh8/AWsEqEVCeLynkkztJgjVUDWqJ9nVaDiZHMhFIImKdzyvlfKCsCaSCEnv5nBrk/Xg4jr6/WC6WXVMNRPaRMD9e/qeKETjjOWVKXU/PvNEPm12morozCOTEZtRNFjntkSxIktU7S/avYMx0DFnDy/Lv6dBv4TfxhWwVhVnYE5AIMOvx2kxNVc1jwDQfzAFDjifVycxU8BQR5OUcFWYN4iSGkMMhjD58DA+ua1AkQnpuS8t45kUHZtTRTOQEKSEJgamqeMAIU2mt7cz2iy1mOxMVaW3ZLWKSA3NwebEf0DvP3GtLW2xZuyNvc1yUhJo2DzcJ2byy5HAGF9KaLWLvvfPu1/6H/+Gd198E+iKy9lvVNmqeuKfPy6vmRE9ZC4qEnnic1ZxaOCFOY0XyR8G67ggVPmTrQoLU+ZnAORGFRqKApFtrfGdCMadAEaQGqPNKwCmFrBOgs2Z2Yki35pT0ZqQSCk11P4gm4lbljbLRmzjo2C+23y37pdWcItQhyBpNLkcSTdgU5iJTE1h0fHGdlexP2jOrXJmTFq9Qan4k4VdlbWEElCJWyddcukSMG8ecQaRIp+KQSgYoU6hbKVfphUWzSSw7maTocwIJG0sHwUzAJANEDrgT1Rwg351rDzLW48oII0IIGoSRlqpF7UNSJBUzsVcoMKJARGFEITkiLAwiarrfLZcXy850gemiqiKq+4s9CCfHiLt37n7us5+3nflNJyUYkiyHWvVSFYWVvwgjCdfA4ebm1Ve+++qrr3jvcK5rV+HqvS0WQF3YUPBJklyO1DTN+B7FemwsCLdVnpST1I+y/Hp55cLksoWAjfiUk6QGhDLzNU5MEZ48fJsRqHBWzFwa9aGru7pyICRdncUjqasl0i3HOWiYkQIRdHT33of03tbdcrFbmloOSpnUuQV9OuEtJYcXYMJ0Pdnp43k3dsx+l/CKowncs2bXpEmyM1X4Lq1ygjzO41Vxt8ZnVJ9kNe3PFD0PfGRnRfmCyXOK5L/XDIXwyMxAoYBO7JNiD9T3G1JY4TXgDEBQPMbaxxi+jpCAAtpMVaEa8JorMJkAmfpZgvl+oelAIbnmWhJJCr3Kn7K/aDuxBhOF+9hd7hazEHl6ffCO5z/3zI996ceE0rSt0bU4fhnhTc3KvFQDQboG2s4WbX6zvvvOu9/+9rfXw1FE2MfF0o5rB9DdPVxlNrNFpK3PIHuGY6a9VQ037aAIm+3X5uxLQJq+ceP6OYHrRGkszYZUqM3hQzNjyPfKjqeN1ph5HwkpQJm+BDU1hJWJkCx1Q+3rzGKKq610FQIThvY+VMSjr93XdVxd7BZT2KmskZErjdNjslP1SSQStQc9B1KhsB8hW3AgJ4uVqbwwcgIWyVShnnqKp3+Yi1rJw+Tocipe5OSj0nPINnYjNbXIm6AUSqbyrzKKoBhFNqwImWLzLASKpiJwOrkAQ/qIdY2+png3ZRfJm9NAM2PUiBFOLW++vFacgqm5e/q/vJDEBcGwCNXFM3iIiSpVeqeIeOD2uNp+h8HlztVXf+3XXnrp86OjZtHkiSIZ3iKiqRXtQTPwONa97KKvj548+NY3v/n+O+9yjcXksA5tOsYIoY+8liUJsKhpJFGh4EQ2bDPPgMlf56YGp9UnyoOwEAJO3njy6ZwB47SlhV6KE8lc0avAKpp24sHN881xFMyNqTgw+ZbNUOoEgQm+KQiVCJ23oaFCf6K4gKrCLMcmh7gjevjFYsuyyIkIreEpM73K0yuT+oz6laOyyh9sdJBmfWcSxpkFU0GdbXCQIM/KR0mlZlnlfP3zJedZz/BgKsxbxuYexdy7qrjVwGutTClyyp9sIIWT25gPrQAdMbq7DB9c17x7ByKamhAlJZQSQqiLlLyf86Vlhjwp3MekJDPClytiwCG9I/a2jjisY7lzsR5DIMtutw6/8+xdPw6/2L/46U/99m/87u7O3cc3R1KstYDkLFioZASIWRJEMJoKhBH81jf+8vU3XuvruhMdnnWiMaInWoxyzLkz9X8bSiFq4PeWeZYpV26k01HMSFmWV+59c2DY8mlMDuwkC0pAnNrF2t7Z4FKYJTENJItDmmNniU2IB0fMotAstFQWii0QbVEsaZINfQUYMRAwlQxdPcIFY2Vzmmlramoq1DkSvD6c5BCugndTLDtzi1rFOt2yHdVCh1Ai77Aozm+2nPHkdmotMZHmBKSMudoRrCE829STLWRoZSbNLMi8RUEE7i6QiHQBM6zmDWOsCjAhARnuwzHI4zrGmAAZ3HhKJIJjeqCKzSGpVKzbxJFXzqHk8SY63AF2euTm++rg3hubrmO9ucF+f7G3/Rhjd+dqvel6eXHv7r3f/xt/8/K559c8fKZekF/A0BxzpAAZRnPOrnP3+x988MYbr73z1tt7k+PtGnAz9Z67hyxLTsLk9P9M7169j5Ns3Dz2nAlcsTy/pBBInLG/nMzYJnKeKCAXbOtowJzlgDGTvuQL8ltz7iJlmJrNQmUAqMiP+W7zFzf/mwcxb04KIQTcUEsxPOkyUztTuWFl4JToY5iJDtu1ZmoyIkcfY7YyZ5GE2eW7WWvBinm+53/SfW+DrCCn8SATutS3l7AXFFWgBseLCHNYwRZaylmfZcsbIhWISESY5UT7yHygalcJz7T8QsWBbY5Fdnszghzh66i5AJlH57bnAw2nKVLrVELkj575DGACmCQvQwZU4UFCRTXc0Qm6rx3LPujh62IXQd577pkhHCr3nnv+f/y3/u4v/MKvjqa3t0NM8372SnWUZLSkTtKeVYSOi/2u3xxeeeXlN998U+hw+Fi1nc9s4AzWEixF+wzuWxNYHnuZyEU2KJzJ2bbhDEzF60S1KMAEnF6pQku+4MluebLfxBMzg0NK3EoJlkuMreg/Dev8R6toHamSYPk2ZSassQWdLSTNwkzmERUB012R6CN0cAw2czVVgUneEyx5CWOWTJ2bhO7sDBZfJTXAZRqmiswrsyp0WDmOEnRUOjfXeYOOcTpL9ZOQKUydCQZIRna71IepyIRZxqvqQolPkyNKEJzKibzhLCBjoA+OzpGZVGoKJtGWp9MJOaso19U62eFQQa+6EMvpCUMqX8/+8CyR9O4eaGbS9PpmvXd10btgv1zeu/hr//Hv/vJ/9JsQPRyOhChatqcAKvCMWg1A3t2ron10IfbL8uj6g1dfefXx/YdcI+D71kY4GSMiPHIoNsEI3651mGs5f9vyzrnmBX2KAJm2u2XIm80X9JsAq/5hRvdp/HGCnaV43goZkV5UwcCY7ecxUYKgrsyQ2Xld1oICNtsRnb+ist5T+AFx6vRlTfOqB1ZIQKMeMNYR66irUfNatBYmafeedzkyMe2mnhLILPXUB64SeXmUou5nCpVrlz4yucx51W5Fq1z+j7j+yCsstw9W1YJJxURkI1WO9KpwtRWc8yoa08lLczs+JEM4nGt493CeapRaDjNZXQKTxNoypKy8TIYW01lVaIFkmTgQnDyAijAQncc+em+7ZQG5XO36wCD+6l/5nV//1d+CtMPaxczEYoSIUhwpVmGA0gQW4GIGVYloinXt777z7vd/8H0BlwUYTLc+vOfN1WkyvhXPWSacViTUYjG2kJ2YcjLg5do2x3aGyPN/UZK6+V5zcWeWWvnZtJZTPosa8sXNPIUIhBfpUX4aeQdF6MbTzNfa9nG+4fZQUvTn9piBkz2dAgLrE+WhGTMFgrPHYO8GbaJLKzGdhqrOnKRo0uIsS941k1lsKuiKCpIT96Z1cAIRbI5/i3GVe5zSM2yISU4bgq1MXvlcVBV3olTknqraZHmSqNG5CAKVZNmDGlBKSPVZCbZ3mhl2qRRljgvMBHymwUA1y4qiSNpk7vL64zHogkUdOqgBvT30fVv2F3tQL+/d/cSnP/Nrv/Fb++eee3p9EMCWpQd9uBoVOf0pG8ukEbITo4qELNZM2J+uf/GXf/7+ux/c2+1v1uOd3Y7C4WO2fJNj5EpWrDy50JjzeLCVapNkn6xwoV3detjmOSl0lc0Q4RE5TDNmcerkvjauj5vNnvxzFeEwh5CSeUdVIGbaQaYkorq6yDlRr2JYuv4ZYQqUb8Fh8h5zbMZZZWFDHABUJOYIoWp6jhBgIByRIbtqpNMu8wUmFJ7/VB3igpqLOROBHBJbLnN2rGyBgVvFamZL2+ttfj6IkyXLLHttw6gjdOqTREp/n5Srx2I2rV9krr/ktebMGnKujHL68hnWJ7jDvLoSE+/PIOxBCKxZHcdMHgVVMgOrVBOOMDMTgVH3y24dYaHHwbvPP/cHf+eP7t55Lhy2az54PHa12ZjP2eFNQc42zQ3KeytMG4UffPBejH55eXl5sbOWFF5hHjK28V2bb56OWTfcspkFSUV2VWimf8WF5Kqde/NcrZygnDAqpJD2KTJuOQBOzcZzmvqERBPm1isWy16vW4ljHriYbh8TVuStWPUhqRqqIRIAVUKyZj7l+/VaFRaiiBCZlGSFolyFIJxZK8EI9GAnRw7MymnMOcoHeoIUgGz0yjz1aRFGWN25Xcsn05imWSIvJa4qsMiGJApPI0GTbxivRkXMlrqcZyqUVreZb2RdXs5npTvN8XVqhNLhnX04HeJRSKUC8nRiW5YrGTEKOm16pfRs54xwqqGyCJC1ZWR5DhSGGfrwY4/lzh2KtsuL3/ndv/pTP/kVNx5XN2kiSY7TxCqcV0gMkE3ETElQc5Sxc/R+tb9zcXllTdnluHYTRXB4sFjfKqZMf1OD3PP5PaK8WAQglgIhnTh0c27bclA4x8RGYN6Why1Q69SnEZjjc+q7c+cgebfWidPI46Mzg5yHYt6lLSiBwqTn5bzaBSE4ggGJHNQ+b2+fcLrcOk/J9Oaz69imr8vwz60APT+9CyLCq1dKF7UU9+JcNyois9iXzrkJtlEaOS+2emtYaYOUty/kzzNcWQzAhFOIkrcJtgpAdsMp6AyvW9sizKrZRPICZsCaAmJqpiBTAaUuGoEROK7ruibvD6BWABPwynxEmVFn+h/WAomQqDuhuLGFnE8IqIkQGoFQ4dLkzkUT0Viad738zCd+7Td/47d/83fHOlK9MTwiy0FBZ1TFY5ajSLbwYc2QnZAUml3evfuZL3z23bfe9n5UbUS/PR4BtmYeLjCm5DObtSeHQPgcEIKcOzrnurRkI7MN3sofyWzvDgbUNNyzD6QcwkS0E15XWbQA5faFYAjyKJx5fGyV4GmhhaPmDpysNeYRLtvG6YDOrDyKTKyhFuX1P5I8l83WEZrtLBXYp/NOKFvVBAKeHhLOQFNLtkpqSlOxoUJXaiSrS20qQIimJ4t54gsmzXiXxAydmBcx1G9bbXWzufq0UkvhwgEOj8gefEY2d7WcfFWKoamCJpSw1iDiwNrHcfix+8iB9DJv1zyDiaelrfeu3F82d4QCmZMFRGmxiYmCncj7FtWatAWAXFzsg+0oeOnOvd//wz86eISw6RIi4SMHmZX9ZOvJ9HUUNBVT1XBQRJuqiJveu3zuJvq4Pu5Vrdn1zc3OGkXMWjCvRlVq9X/koCiUC6bXnCVPPmaEi9jMDjUYZ35gbo3nhTHVqXrSIUwWY8t4N+tm9mUDBLzu8Z7oWbacnFU0EBFIFhEFyEPIeV8TZ+UzgnN5aok0y/On+XCY9zgk+YPJPG3OfXv/4oYnkzG/NGMNUK3yFDicoIlALMVpUmgyhcGBgGjp5NMPFlqgWM403V41ponlc8wYUOjyzPJzcBI21EQyIkQGai4WKRFgRM5Lz0uunREMquYEOG1KZOtc9DFWH8cxpOUcQwFmk9jmsLaMpDBagVueqOn0T6dtyEg+Jy6EpwZVUiKKEYhgWxp2Kvv9r/+V337hpc9e8+A3CA6zJjAxcgNUWVua48Jy3npprMCQGvohX/7KT/70T/zU4NhfXmCxy6u7YrZGHHtfPXrHOjynq5u1baApK8Mbnd2TxEkPX2uQt98aRCkKlYR6w72PAS12MhtpaHVI0vxT1ptdVwUmmSFRU5ASgoBQqycwVFwkBF7YHRChCnUG4KpCZrgpZvBkzmU+dRyrxRXcLIaYjqtAer1sHW1NMcZmlfl6Z98xg1EBszzGgDOccEQUxCKByCKhBNQJr8GwQoBaMDG/zFqfesGazZUISfWUI1esyqsEzE7VSTIAh7CE95aXUYY7GEszNcksJiKRDwFYq3KaB9fRBYhRJ42oK5M3KDbtpDzwdjQroM3uoMICk6SrB07xIgQSqebRpko0a4f1aLBf+YVf/MO/8UfH6LGKLS2XNDLmTtR12jmk2UrL7ugIqBlBeuwud8/f/US7uAjRJ7c34nE4HPeXbawd8DFi9C4iZouaIioTFagHnD4ikIVHBgBVo0KpGlC1QLhQRIMYEZ6j1IJN1YEBusBVSc5+yG2e4ylgE/Mcn0r4cjpmE+QQsnXFJIIRsnqG88fnMIP8PWbRhUTkBYDgRNIFzpVJz1VKk6RTPUu9cQGTib94evAZBhKBFpwna36GzjlyrERDAqUukEpEcjhzatVk+p08ljW2tg5Yhjqm26i8eFP4cV4DLwloJpjbKCFRCFum5NDhwyOamWXmC4pSLD11YUvP9HGWPyTLW2cNsbkKOSJkeoYi7hKcTLJnSxDmEs/yNQnNfsecU92Wi2UnCr3a73T37Esv/PEf/0/vtIvwoc3MbM1BzTFgrU74GXMIEFCSDUKPodqSjVrX3oB7zz33sz/5M9//9rde/t73ZLih9bFTMVv2Yz00W5ppwNOcRt1RMhKDMAn3s+TFgybR6vI7BERMRkifLE56iagmLKXmfLfSDFDoyCkkIqBWxiwJMkuuwzlcWOb/0r1I5JjNmQYjQ82MupF2n6G45paXggIEPcvbmdTPY3bCNfV6s09xBvs4bbqcABkmBJjYd4sMFARDPC/1ENNy59NI01JLCmGYd9iUFoHCbd7/TPEAUZWp9SxXy21uE4tbr8AkgGY7htaEbeTQjDkzHgy0prvdLmlwLUVo6W3Tl8WkzualS0V85w7iLBViqZfKCUwHnaUQAU75X8pD6XMgbN2+AwpN9HhcP/HJT+DoFy9e/c2//Udf+uJP38YaTkMO0VKAom3mE9vv29Zlj0e+3/Q8AtKkLcuv//ZvPnN57//yf/0/f//r3+5+COGu7aKvl5f73vsxVo/w4QJCVEOW1lR1CPZIHTlB8SgFiIY2KRZKJ5oIIkoBy0ZTZp9RQqFNmpmPnURl6uFPCWpKTyTTijx2ZfelMNTKqeYLzFWO2o0tPmxayTxcCbckIm81IkCtLDA9fJHswNaqPAO6lCqYU9t7ns2ffsnpvycFDIGcx0iK5fVqFNWNBTWoiigpedtgavxOmsNJrdXVV6KTSCpiYYYmMjzQuLHz6YncOUqKlEJRaHboCERVl7as6xGaXVmapY0UObiwp3lKOftinOpTq3AC7+3cFbuXcSiLeyobP1MhdOYtpvS8l4Da2l6109uycPV27+LTn//M3/6D/8ThIK2Ze3isiFCzOahqWxxWAM7amkhTVdRFa2xqurR1rIfj8RN3733lV3/lT1T/77v/259/48/j9ni93ni4R4jIYq01VXaYRu/Lvkmg9xWSXQlF02rKCSFGlxBP769zgJoHhAi21iTLvyOEeWjyphRxkLO1hszBxJbtlIUriyvLUR1ygiLCxIopwsnGl8CmcM9tATKlyk6/bMIlPJyi7s4qD+VDpNSlCjhla2dE0+Qt0qZnvWwG3UlGbcKbeYxnUlHHJ/+Umi8VQAZpFQUUqixePbQYwnyjwOyVy1Ms2/wY5PGZF0tJvd15BqLIQg+ZHZ+AKIyaagaZIsbWrO2W0buINhNCPDAinBhRzWtip1a+jV3AhKy18FIRopBqsrqVR+W/lC/g6cEIkB4wXczE9KItezY2efGFT/7v/rf/ezUJIR2TK1TRmUmfiWgqA5Pq0RZI83ABVVVq/jqix7oeHxt3y+XP//pXP/fTX/xn/4//+ut/9mcffvhOv/bHt48l4vZ4S8LMAF9am7feIjjoRg4TQSTtrmQMcgQpJpIjt1JY3aNGk8dw90EErdh7YqqRa6YWWTc+C3kqqBGMGWtlmhjqo9ZQlELLWyWt9IzIYWkwaAiS9ctjkJxDYLtzHhvbm4prMxFIcQubfkCK5RRClZEmmNWS+pb8/+yjpW4lApETdMHMKSJIuqhQhshiChgy488Sh3KeqDSzksaSGfVmxUSFZz1GuVay2cKs/rLmy7Bydc6aLmCzDiYiS1sYoURTBSTcg+Lew6OPMbm4enXZEOP22SomVBDNB8rRbmdl9MSMteFJ3VIg0ABV9Lj2e8/eMapeLX34f/bHf/xzP/FT10Ie3RaLQDionmMKptuppKgCJIsSiGAjo3ThwpoDZwaRPjzQj93V9bd+57d//Vd+Pdw/fP+Dr3/jG6/84Hvvfvh+v10Pvsbox74SvGit7RbD4pAYAoapLGoQ86AHQNdNThM1L12RanPmqA3kjUBFutTRV1UqGJqjOCUYmR5Wj0oSnRuVloyv1s0TE3pwnvicvi/IXvdQ0R4jKB4RgrR+n8kaPDbvIbNsLdkmKyrW5qUKtZm1zpgqMEnBUV5xkRirxtB69fpInd6JDia1j4l5JEQJyScUF2NoM1HJVAURqhDVrMxggvoZ71EDdeedDGmUVYAh8gYOF7BS2BBEDpf1PkSlzT7mMYJAE4WqBmVEW2xorBHHtR9739z+dogx88ANBMqMP5jMrZxlpRtCkrn5OQKuroMRNlgArTUZgLGp/eZv/ZXf+av/se8Q177sW/GZSlU9o6Arcdgyb54FqFbJH8akGCGqbbcopN/eArTd7vLq6mJ3sWu7lz73mR//ys/c3Fw/efL4jR+89srrr779yuuPnnx4eHqz9jU8QsWDy7InwiL6CDEMgHBbsr9UVNUzYXMRQVuWIFAd9gpmjcyZhRiBqlHETQMJiar8mcUvnsut6grKGh2So9NONfwyRRJ1tRTB3gcZoxr41ck6LFCWOQHIuquJmoiaajOB5oS9KKFY7aWQ9PDhYzgJaIZB1BmNql5UpYdFdeqMNMIaGVeEYfqp4UzlLUDV5gQHAUdMKJaqwSgrM2tUhrtHYbds6rdmOTfV3SMc0mfURMsUB0LVzLRELF1iTSkBRGTRJgzpXQWLSrRlXUeer7zJSetkftT/z7CWKeC8yGvSJCc8WBCRAKCEJ0dRQ57ITr9su7Zr+8tlKL78xZ/8h//w71/tGl1t30b34d6szUQwLT44AcBMAc5OW9bXNzoK9X3UHKC1X+h+ezw0VRDrejBTFez3u6urT33yU5/85V//lfX25oMPPnzztddfff21d95668nTJ4+fXo/1mLdooqmoWRPFrjULj8NxjbEOj3CMiCaqqqrW1zHGIYiUpLR9GyBXuIR0wiRUCUEzyVnsM/2anGNeYx0zp8pSUulVK65OhM4UUKtGhAu85zVECnHUgGGImgCNYiI5G8esmZmK5mVs6V9OHT6nMRMUxdr7YR0j6CPvcyntf/HSWZgjNRvYVDjbP00yJmZmurE8JT1j3qcUrlr3oAgZ7ji5WBHIGENEUpIGoMYLgRwsM88x47MKRREXTAVu0qWx4RSBMKgi1hbRuohOKfvWJORm0EdMlqxA1uZsZUtEyvzK5U+kI1WcSCpQsAUMzn7uTPJMbYzRRLPXdNntf+2Xfun/8H/6P37y2U8cY+23t7bb14U8CvEWUxzF8j7pNmdZvnJ1EeRoxOnqqmchU8GgUAEVU5UmuozwMHrvqtoZy67tdrv91cXVM898/ks/9su3vzZ6//D+g3fffueb3/7WW6+8ejg8vn1yGOm7zA5rb9qyahvEcrFr+0WCIYwIiOwudqQ6ovcRAYW2qkw4VbG6mALi+VG2kF56CNQgYwE2gTl1Xm/Hufg1kpEqDHhw9WxOLH2LiIpQzETUxAxommPydFma5tFAZcZbALdTG18FqF3TpS1ORIwxfHiMMboNhnefXIxsInkIxMykrogoLFfZo06Gqe4ATz08kLPbPH1rVQ8YofM68/B0FMW7R8A5MqYsrZkZIe7uEk1130wh63CPkTpWVTUzzWJAIOAjckCSmVprFJOm1vLKixE5clNOQEbLHZwlaIWLZGZF0zltdpkpEadgx9QcXKy54GK32G6BCBnPvfDiP/xf/r3Pf/JT3XscsN/tPaI1jchB3TmpQifmx0w+Ev5NzAWQbOckKMkaBCxCpSgR0tqSaaCphlBbI3x0Px76YpEY1Ifv7ly2sf/81Z3PfO4zP//Vr97eXL/7zjtvvfnWG+++8/D+g4ePHtxe3xx773BTabtdE/UxPLqJLqKwFqrRQ7RRZR1dgjFcU4Mk2DVxs3Sj7qy5TInNBQKqVM5alRQipUmVHcr01SqM6E6Hj+BIPRfRrMFMVE11MVVbDGqT7lGFqhpUwBSFZQRIgUA5skmvNLNsTaPAo8WI4R7kGMMj+vDh4T4KxyfvItYWZcDDs7vFVDPnz1lDKXlozVKWUw+KxGs1R8hnC2km97Tqj0x/MDImE6KyW5pZs6YIqOmi1pplO7KaASLZLW4GEyUi2If46M4Qybte2Fff7feXBoV4JksJrycZMRHOxn8Wb8WT/VXmW5XNmRIlRqWCYIyIhSamJmbWgDvPvfB3/5O//TM/83OHvo4eu92udwfQmgLmKcWujHISSnIWf7ZYJADR3HtirHz21BVrFkeyIB1q0ITNmhcgURTqeXuU2toHoMfOxVrb7+jr1dWdi2fuPf+pT/30L/58794Px/fee//tN9/6/g++/+G7Hzy5frQe+uH2sOxaFzsej6N3M7W2GxykX95pF7G0sON68O4UOvtwxHAxw2ysr9w0R1gCDdVPhFlX8SytiqhWXA4gwn04q0WAzcSJOW2PAl2WZdcaRI1qUzulhomRYVPCdEZrTPwuqgoTDaBZAWmn1BnZ7wjp7iM8qxbBcPc+cviiLbbkqkvK6wGBqJmVAhQ58rskwcWV6cR3nBwPgHmvOGZ5UKRwUK6OqpkBccbwwEizZczLja3l/RtQSGiAarIIuY7uFBcBxb3gXJJP04WXKW+Wdv7vxVmVF55PVzVgEPCgCsyUEJchmtctwaytT4/7l579q7/1m3/rD/+WEnmBFUMZTkUKEeT04hVLWb+fqpWc7h9AA07zZ+ZPIfMyZp1IZyJBCGpmmyiatJTUtqaJRdfw480thaKEd1ssRPXCLvfLl+7e+cKXvvAbv/2bh8Phwf2H9z948PY7b7/7zruj98Pt4dHTa3d/evPkWdu99IlnX3jx+Rdfegm+fu/bL7/x6msR/Z0HH/ToYBOEc8TgNpZViaUZ5z2Ukweui4qSB40pPwxyeIzhgxEMs9bUFlMR0ZzVlPrxqAJqcdsn5rDcmMpWP8YMrdnkB0AcmRKaqSjFmkEbgJxy28QWWPFz5LoejbK72LVlIYXhEMk7xTxcRS3vYq83opa6HYkupvnNvK8wD9SMc8hQGqfMav8GmaRuU9G8zaNaHUzbyUMjC2jBWJpZYAxiWeijdw+oUIbX9amzR4Qb3Y+JPyoOTMrrFKYTmiaMLREYWRMQTa36I0jevXdnce33+ieef/7v/71/sNzdPT0cQrAsO4C2LHUNGysOyWbgM/ScNnCejlzSpiKbDmyOBuTkpydxVved1MzLmlXDbAZOZj5ExLTRkt8EbFkDIq62g7vum5DLbtnffeb5Fz/54z8rh5vb4/V1JtyPnjx56523nv/Ec5/7wueiuyjv3Nm//YO3+xiPHrx/faA2szUcUBhVho2i/0kxVdOsnsUcsoxJ9KSM1z2cnggka7sAmqkutt8tOXNzjlnQpmY5FE3n5akQZKtaTj+trdTZPoV50Kq0qVBquQ81S2ZHRJPbC9IZPjwzzV1rbLa0nS3mI5LEoYM13WJqHmBe8tMQZAVGNk+WqU5sYCMLkVaFP4gUI5w3W5blmzVLL+KReJIK1qjFCWAIYYSI5uOqSrPFyU53JyKOHsn/11DI9AXbumxBiSfvLzMzmVEXgE0slExa5HWAiylVRJtZu3i2LXHxD/6Lf/D5Fz97bLHe9v2d/bp2UxFTCnLO16wpbnnFJsmYb8aCRokN28wQeDqbZ08PIkCrOoEkRNpIvZRlkRBaNmJL0bZg3sKoy9q7kuxDgGPvIFXVVG233Nk/l05nuXv1/AvPP/Pcc889d++dt99+/7233n+r/+B7L//pn/7Z7e3tzc1RqG23SIjlnJ3VfPRM9JwhnrezzWWeKC/jKecVE55sOKSZmYiY7naLaUvAaNnxYVp3rZXWMldka8jC5C2y9jxXYkp7AeZJYuiJ+zg7JSIiARMRs6CbWM7Nac12rQ3xnhfOMgCJYFIuiAhESyG0QCDho4akASBMszqWDioAhkte+14Nxql0JHMIcmYu2RfLyqgle/ZkFg1TE1VtT5xIwomGMDn4QBDL7qTPRUrs5AweypwZtDmJExjZ8gWKcIoRpDBG5voSgga7e3Glwov9nT/6/T/4vd//vWMb623oLtOiLCvVy22BUvHRK4Qwj99ZEQCEKFrehfFRs0F5kwxnlBziherRqCWrO4eDpzgMCKG1UPVKpq0uLRTESGwhaq0mTYoGY9fuYHdF3alcjAMefvD08ePH/+2//W+vb56KWNstS1yuh7VV7Zm+EDFGkMHh4WASE6pa1zMkoS2aA9eGJ9cDMrQtIoDaziwxDyhmzUQgSNajsgvM2S85RVY2TqO8XCVSMgeMFzGTGUjE5kpKnTH1pBBAVQnRINWapxZdZGlLthnlLBbU4NJIS95CelZ/WTEQqgbZKI9ysRubm/wipyY4w3lGNG4VxLptCWUznCMoiLw0LQO/qaZhWI4EV1nzlJjmDGGv+wRmOV62UcAzZZuAMj+AQCxHNebwYMInljJTiO6WZrZQw8V+/Md/8k/+5H+x7HfHw3GMcXV1BwJtSs8m1lOWUTtxCjy1ifMxULYsJNFABEKnOBCQmnggmOA3dQiY8wy3imIe05pWV++g9XMaWb2vg6eiATazoiRyLrH7GmGKDl8Eox+f3ly/88H7r7zx5vf+8juP7z+2tvNjD49F7M5u30dktWdRy9a4Qza8AWriUxBMzCMtEpDDurqnmkTaoirSdoupLdqaTUJxIj7ZhAUzbE7vOCHk/KPOf5YZFGptS/k4adFpuKwJcJE9Yapa9MzS4J6OsTXj0jwCoWTymDXVKG8OVwFUZ1Fzkuib76ulFsw7CE6TsPJAg6YpBZ+ky5RinllOdoUAmFeDsSySAlAZIRRr1oPrGLvFLu9cHvoYw2UO4FBUBp8c7FlB9sx20g638kGmO0SIu3OMuNgvd6/uHEcn/XOf/vL/5h/9o7t37t66U3TZLRTtY2xU+OkTTLjzQ5ltfk+clYMzVFVeNNtwefIhJwCwpQ3535xwllMdannjvP5xduKYJ32iuxmxwcjZUCTggdF7uPXu773z1r/7d//u+9//1uHxU1X2o/e1V5ewwLS0yiKirYVTdHjmeR6IsMQfAJich4/wkQ3XqVYKkaUtu10C/SQ16SkoBWqWlmxHFFMqM0uzRTClh6l7tMqE9AxnyqmIsy1rvUMCrmxVDFE1SI4rzPYiAFz7LKrmVcE5sxYJEaqkUywFJsAu13rCXNWMVdqk3KwMDUUQz92Q09jsjNmFiM42kzIhnpj2NdR0v1ysNzcurnq5NF8WGyMvewcr3EwTOjUFzNrs9uBSw9RIkp75jWnbNVMBnccxri4v7j3z7H/+n//xz375J1wdh7i83B9ub+krSWkNswOVCJk9EQBkm2NzZniFkGY1ThRtqxCwyJItYs6wNSN/1LERImo62HzNmWOX1acfmvQgkLXMyfE6A3mvslYXooN37lz2p+O/+e+/9r1vfRPhfaxr785BDgZFqi/GUwbHyPb57gzA1AYDkOF969yN8DIXEGoqEDFbWlssSTeeRGxzSEbF/23F6pE31bpqji7DRvpx4wmq1paUns5rC8pHqCSIRE7Cl7mmhbbSfYi01iAyhucBks0UZXvD+WMsu6rTyLAsd2xHUJTlBU+JaRG5srnGqc5BCh8KPs7oN7UK86VUDRAxMTVdAkJf/TqermNwErFyuqQVlR1MZj+BV7YoSQAmNrOYXMUAFHqxNBVjxFMe2nHty/LVX/r53//93390vLZYdhcXClFtETRdqseh1A5alpxYvGzvPNBM+DP9OYGGU3Iidf5PkWNGl8RANQOTpz/I9iOcFbZCE9l9hJKHnbKP6n/IBv+UXYRfGPzJkz/9iz/7+p//W+tc4xjHQ4yB4aW9chWlQNXDAJ/LS0hUf31Ivk14USEe2lo2GWl1BKqoZg7T6Qokek3GPWGDJulyutFANtmuJV9efPDJq6notuMTC8r0C0jSdIKp08uloaX9GTRKyiGtmZmNfnKgJyEdTmANm4utx5kTeOo9iurYHC2q2F3fjOkQN7yXtj7b3s9tp9Za5vTpnEak2pa2c/bj8Xg4rjmnP6U75QZYIUlnGNgCzjbeiimVN4twMblYdk6OiKbCJb7w4qd/8gv/b8r+u9uS5LgTBH9m7hH3vZc6S2YpiEJBEgRAsEGtmmySLc5Mn57hTO/szG7P2Q+we85+p9mdOds9y6ZowSanp8kmoUhCFEBoUQCqAJTMzCfujXA32z/MzN3jZRa5cyvr5ct740a4MPEzcxPP33n2zm/+5q/vEp+VusiehJYipYidyNiplEsEhRWxbuDK98g9++0/R6Q2r6wWfiWN3F05UJMlfpfGOmhrTRFF1DYY7fbsI6BGTMFnMAkgikQMOd5Ny9nhm9/+5pf/6q+xr6ss6+FQ14Wqn64j6kVYkjf5VgirJlARS+LWUDqssLdYxZJvBFVSIk6aMzKDPEmYADF/vztDXBYGjbUN1EZvagcOTG5kOaljWBh4VEKbdMgiVzHcfvPCzFxJvJgGM4hyKiUxqVVm99IKXt6BKDS26wBFVLPSQUugmtcudjvAlx32uukedE8dRLCbhuQkHApGmoQ3GS8qUnbzrqruLw5SqxdCCo1i0U1OPkYXEquiECCBybvMg6sc7Y6YKTOJlAmpkty5/cS/+Bf/4hd/9VeuXLty7623Xr97Ph/tTq5cL0tRpZSTZ0B71pGZHIgxdvRGaLjfz6HRKBogohzAnoKag6aDvN2I0q7pKUwIxJFMI4JmAyIEZ7fClCCC7Ok4RUoCJ4bulx98/7tf/Pxn62Ffy3Jxfl6XBcW6pKDW6uDCBIuZV1BCgiqTJPLALivhAVjPErJW2Hb4y0SElMmSRYlhR91hGhCohWW55Gu2mkdatE/tzLhH/gTLoxV1JrIjA6/5YOHZRDDDQMmq+jvYsLQNZYHUWqHIOaWcEmeV2vA84kRTq8F105/aGuPFuMP9AkIrIRTecY3RuppoWktdhNk/JDyYwd4mxOyrImIly4XBPNEkkyKiNTlVLRZEYc919hMN5WGRrhagopwoIVnL8VXWRARMx9PR9evXTo5O/sf/27/41V/61euP3WDlw1plqQlgkWQH3MylrqUWR6DhjG4LYRN1INmOLG2ypO0agDIFiNemst3tG6uOLt/Dgzu+/PyuS0DnNQ0AauKL7C0rflCTahXaZb0oP/rRq3/6H//3s7N7r/741fOzc06qRYquTKlKCW4Kp6Ka7jAALHlKa2Um1FrMDrLTibA81EQsEVJKU07ZjeQoCAeFBVBYi3LLP6QwZgiG+xuZm6JoWLuDbKia5unpaGgIHREpoE5o6pwUYUScEtXqpg5zzjklrg08hxNBHUF70aUAUYN0czaEi6dG6QE/4bC1KXX3ayOIPWSd/xd6DyYNLdwocWZQzrSUdU7eB6QWIaaEBPVyC8pQJRFrJOkuwpQYBKakSky0S5OFPBzN+drNG3duP/7+j3zoHc8999GP/8QTjz15fOX4cHFY9gX79fjkWLQelrW6ToSVlSJPbmk0SYhQokBwrsuNOCyOoRExE7KGX5iabRxBjtoSD0O8wFUbO7inUAnGh80p1fGzmeUhmpihUll2wjRPcnr+2uuv/sVf/Ond1167WM7qxQGLFK2HZUUAbutALA3GgURFqmUNE1NKiWE9LhEqP8jbID/bKQFbdWEzuzjY0ZrEWwKVHeERQc1mCI9+KIaGPLgttq2LLQzMWeKU1nkEhkXMpW8iRgkWYa2wY0Gqha0gBHsdQiau/TFNChH6jmgon6asHOz4UlD3wBoUGHyFcGYyFlBEj3EV7eaLM7GTDgHwxhxMqHa8lvlot7tfSq0156xMdRXrkQfinMyRpdXAigKUodDkFQYWaNZ8cnz87Lvf8bEPfuSf/fP/6uknniYvnc77Q027VCHpaEpHmVdaykpW5UCVmCbKDdM3lm7LEu6bgF4EWJggwq9BEJXmBh31YYMsI6w340BjCyhECXXQ4/zXUJGSJ9RaYD5ZWJXuSzqeJ8EPXn/1C3/1ue9+/TsEPb17T4sw6VKLdSurIqVqsci17qYlD223Y92gEsfdIexUEb5IVQZIqdVJZNgRqSC6upL7B53LwiXUD7jUjQDjBtPnLdaxE1VcbZgKYUrSsJTWHKxVBmd1LZBSMtxk5T5TSiyVLLZOtHqELsURlTOybayn04aYN8xpSKyZbbFHiJou5gjzoEm1WBwxqdKVIwW6sDJfSlrJ0pDARJxYieZpznxRmCnzLvG+Ln78gFbY0WRlSpknzlUrQXe73fFuPtvvoeX6res//dGf+uf//T9/7NFH5unocFiWWpXkcLafawY4MelaqiU6c7SIDqGsXeJ2YNM2xfFzk87UYLlDnOwb41mgXVi33WyYCO42RLN5tT3OCCnBlU8YjDCvD5IJo1VrtvjK/fLm+emLX/7i1776lVrW07tn637VIkW0wmvTllqqSlC/2ySGK43PRUVqK7GoxrpEsbtwh1wmOyTORmtMXr/akC4huoi5wUYE9f6j3bQJFauaOIHYC6gA6P0dunCF5WTa2sVOYVDCRrIhN9z+iBqwvjlEYItJUsAK+QTCNBsi2CtUvMJzWrod30IBBjNupAN/O/qums7outa3v2kRWy+risXEKaVaNWVKKRGXWuqU8jTndS2WG21hSFUqCBmJmZDpKO84MQTKfOX6lRtXbv6ffuef/zf/7e+cnBzdu3t2oFMi2u3mVWR3vMs51VJVsRQhj6lCqGDR8CCHDdDc8Q20xhoFFOyyinwlo2qKKjrf9KNGIOJd4yGBoMlqNnnydbc+vPoSwX3wSlCIxVPIUumEj2l397VXv/j5v/6bF798vpzff+uu1gJAUDkxqlYRYVQp1RnKCd9ubbmB4UsM+5TZQ8XCQ0hOYeTZfp4IZXHd2kG+nZZwEKL146HA982cj0V0YN70XKCTZjagHf+7B6WxZegFsoR2kylM5OxGQK1FqstNJmJKzFI84csVkm2VDdL2waJW4Itj8XrR81RHHypcv4Wr3toQkg8u9P5WgvbfLc0oUiSIPVEhp5xSZjpwzqWWeZpsFZa1iggT5TRNk0V642ieMnJKkEwnxyeP3rz9//h//t8/8KEPzUfT+f6CZkZlTtgfViJKZi0TKbyws1syYQ0auDQYJ5f893GcM8qlRqPB0CBQ7gZUk2kmP7y0T7xjsr8bCy58vGFHJwmC6xKTQ8mwCJRnkUJrrqhl/d73vv31r31dpNRFiDljWtZlzlOpID9CUGXVGuLL4I2hBPP5uOR1tc6AWHatDVxVwYksqM36qPe8LRcSAYCVzDhgZkpxoKuO+RAowhUCoQmDRlDBa64urUy6+TQdo1KoXjQtoyAwg7z8qN1ZQCoU9XGZKSkzWZZtsAlxsKRzj+FBVXhJ+AqTS4mSapuF8zC7B8qdhYyWKRTmM7p/iJoEtOFbQEt4BC0EmHOa5+l8n1RUKmqmtNuJVCZLI3BiscDaWqomSUfHd2498Vu/8Zu/88//2fHRlTylN9+4uzs+mo9mkVpWKVoypbUqqDJn5qQNoMAPBanrqYaHtk6aQOUBDeMoos1PCdAcSi5w+7jBA09pUxGjRHGWDMq30D8lOwNQO5hgwDyUGUc0odT7b771pRe/vN/vz+5d3L939+Tk+PytU85sZZkqQbSKQcjQbkRW18bSdVQg5h21p1snNg3o4WGaqmp5fZxSopkndsTha8ZWdidiGqx7F3WYCP/YD8jgdXco7EYimCPfFpXbasVdHToD8GOHWHk1h2jDVlKt9g4recImEVkJftZEzO6wtbK+hPBpQEEStY7arrjBZQf2EcLADv3cPdf6S6OhQQ4oZUjS3FNolgbITTgwJXgfNOE0TdM07aY8cS1SIVjXq1ePl31Z17qu5ejKUV1wURYptUq9dvXo6vVHfv5jn/id//N/9Z4XXrh1/fZhXc73Je1molRXkaqiOucJIEW1MXrJSnfuhNjrEL1Ro/YlHhghSDtkuVp8jnGAJT+EnkdA7f4VDz9BmEaxwc5C6qo9lA25PvDjPwGEiERLXY+Ep5wu9mdffPELr/34tbtv3F2Xw5WTq2eHc+RkVeKKiKoIc5XanhKBjgoH/2g1csVcc2K9okEtt41QbS6ULB3MmitIFRAs6Mpmks0wsOacIUB6gph6AeG2sBp5Z22JY9GJLSefrH5Vsmqv1prZZAHMqQq3Pd1egaWVkvtgVUmJiBOjiJAKUxzQmvsiPALGwF5QuO20NK4jVWUrweD1zKMmvgkrDv4jij4bbLVm/M6DndAoIZkrwVbSdC/RxDzlLKVSEq2VFMyZsUx5zpTyDlwpE452x8+/+/n/8X/4v/7Sr/8y1ySH9fT0LO920zxBrCWnOHDgdnji0V9GCJGXFVwwgDYENjLp1YBnR3+jPG8mtEpuHyLu1m8Y5iwRRgOZ2gWNs7p91tlMCcJQMDiJFqt5+coPXvn2179z7+7puu4JfHbvTLOnFAFaaymwmjysBFayWnDVI/vcWIWNybbL2sN4qKpQIoYQWBVVZJWFaVIlqYfMnLJxSJqmoB+tArYOzgol8iQYK2hH7vJxzEBkASwsEfqhUC9IgWTpg8YUQgrUBpU4JIZ6lqZGOwMVQKz2G5OqWiOqKlLUQlilutkKkIqDwqia3yRS2w/2PQkIE0F9QSkGlWxSYv1VuWX2mB/WTPL4r+UZkxOWN+RzO1MB5ZSIWVEmIk18OKx+rp1ICl2Zjk5O6JHHHnnq2af/2//6v/mVX/35aZqX/XqhxEq81LUclLMVMOJ2iNZGPJBcA6VBtCN5o5tmDen0yisaAh1w49UHn8OXH6w04BsvRR9+g4B+Lo06JxizUjMR0AJeyCocV50JSerF+dkXXvyrt15/Q0uZeL64OCcGCZVlEUWRUosUiipzzvhuUg+VJe1pIc6a69dxuKMTgiqkCvYHyVymPOmcVVLOGUyqXsCcHQKxZYhQmwkhYEwQrvGcV+dX6x1DiFQySyiJs0QCtywnL2tmw242hjOP43brtIAEFam1qgrE8Z5ZPY6wzO+gEXQAeMpgnMB4sWfjBQvd69Thagvq5YEZlhHZmjJFKb22pA0BkzouAnPnIjCz9V6b0nzQBcSVaFkrFZ2QEmjZH2rmR24/8fGP/sx/99//znPvfjbJVIoqeHe8y8TVImIy19Wzc6wzYj+Xcpo0Qaz9tHbkhCaO/c3u+h9ZpMN4BxQgTrl5hzqmaj7gfuOgC8BixEPyefi/u33snFSh5CCFKpgrVBLzxenFN7/2tVe+96OLw15qvTjfM5OUItXyYF2Hubq3wo5EVaSZXup6xUWbktd0bSoBCNBKyswWRK+iay2lyrIszDzlNOW8m6ej46MpcU6ZoNkxAGl0tOWBVq0ggy9TdV+S+4+a0QBlAdmJUthVTv/mpWFTXureOu251lGcsy5lzXUWtdo8SAkZlDiT9VNIZt1b2VBOKdkhdZjAQSNmXxPllN1/r+L1wQw2+iGme4UjVLDlULUzFZ+aixb3EvuT2PxuljLAlHKizPv9KqpHu7mIyFoffeTxlHbPvvNdv/YPf/Wf/Rf/eD7isuqZ7HUlLbo7mlcVqCbmKtLYu2kvbdJ4BGMhF21gGyrfEGzjgi2HOIyNp0Gz/8PYPLyf1E/GGvOQZQPFsqB5By39XGG5YBopbbAuTuuyXslZ6vrmaz/667/87MX9Uz3Isj9YVoGUWmottVjbWvdr2CjYa0iZ8eO+FNde9tMPRAIiIA6x1MiLEllJYXIfktZa13XhROf7NB8uTo5Pjnfz0W62wld+GFuFPfGftIoXhbbTH6aoXhAY2kt8Krk3zFrognlSCwoaFLVI5cQQMZuZiFIib2ApqGststZlLSJSCshIkxJxYoseh4hUNeLmlLzsu8Cq58aKqBAs5dF8Rj2aSSEiDM/iSgL1crtkNW/Ijek4cbEI+ERszVwNDqsCkAQokdTKoEl1pmTmXyYui0x5ZsLjjz3xf/kf/ruf+ZVfnk7S4bDUuuOJ8jzVWikJWKhqhZCyWjnWwfzsXvxGf1txjqbxm2xHcOpGG2y/MsAKg9A5xGZP5w8w0Sm9+0c3L5O1biRHWXyvUg7SjFyxJCKSOkn6/Oc+f/rWvcP5RV2Wo2k6PbswDKIiHoYImINbzDyRgG8KAapUE3VeydkSudFOBdHEsfGlqmpVkOcCMLNCUasyiqhKVaJSTu/dp6M8Hc2746NdTnlOKedEwlYIiBOsmDRTsvVoaJkQ3glSEk3JoTETJUCsviixlUgxF5X1lxBjFCiJMrIBRyTmlcpayrQqSKvkKXNi8rh7L3Eo1TzrVqGPVJWV5mT1LQ0JqTDHCZdlXri6MIFpTlRrWZgTw/p9qChpQrYebqpVVcFWSJusXmX4fYkiFhBSSGjKrJU5ZYIVZCUGWUGnH5299vjjN9//7nf98K3vn9YsDKisy0pEaXLC44CNnuAzCGsEFt3IYm3/h8OdHqDyy2RqsM4ViOk4ctiCHNc0W8Dhe2PG5v+hjUZpvjg06C2uuJL5G4rqTKwkdT184xvffOXll87vn6HqNE/7i4sYmTWp9L1SS+2yGgfV31Fv1NV4XVW1VqsbUFUi2NcXpa2RVXtwt7cld0cpf64QWddVAMKC/Sndzynv5nx8dLw7mnd5l6c85SmnxNnDLYgoJS6OyZWZIZQnhiixqrMoKRGnrCC1Gpic2LJvTSsqPIaziiosZdmQdSlFq0KQM6c8cU5gkDJyLlpFpEBzYgISk9XeEtHEFg5rtYYNURBbjTRlk0dW88TMiWYVMJl+S1CqUgFB8mMQgYJVFZawq4BY+wywSIWdnhKmlHQCJ5ZVd4scHx0fDrWuFYkYVKSWi+X0dH9Q4XQlzwfKBGsJhApwtU5C4daIYkvdkRnUzN0GUKdgY0gzFtE8wGGv+BfbTah/oGhfdv7KHfG0SwJMN6jTAZHZUGblangL3UrxZA8lmBI1uTFPu3tvnH7lS1+5/+Z9Wes85fP75xAGrEMiqRInVqFq/XzV7Ydw7YuoVlPtroZbK5ewWX0dglPNNLShNPAKqCpzCj5PVrpBarUy6KWW5aLcO9+nRKyUpjTnPE3TnKd5nqacmVMimqfJ4QgkpSQRc5YTMSdSdm5U8pg9Nrem26AgIVCeMqdURaRUO4utJFIx5SlPU8pJk4rWWqzzNJgsWiFV8WAhayRu9ob9TlZe2+o21spMSmpVCNx4sBR/L22j1Q/UAdFkaRNlRTIUSGo+Ig10EAX2klotb9Nhlm5Buzkh5XTKBHBiAJShC/b7/WtvvX56flbWNRFZxzgiZuJGcC4YwuoGNpQYGMc9GwNN64B6fNe128cNy/fTkSCN7kS1/zICx4Scb0xjppyMHOSkH4PxyzxHosFiEhIUKVKOaZLD/lvf/er3v/v9sj/IUjUrRKpFuhE5kCEgsVkNiqogqe6YFEHrt6dGC4CIWi1/c8xq4MH4i8IkRCxji2+NmuomfJQs9KFXVSJYujIOcnFYCRfmCMpMecpznqYp7+Zdtko+TDlPBkgKiEGJOeXElKDEc/az/G6g205q4QSCFtKJJLEAVSXt5gLdi07qooUTJZr8QEOUpGb1Wg/o8abNe6cm9iSKnaCqVbM2r6v11XZPfwXnZGckqgoSJiEkcLZdFg8a9kcQxzlfCohJgMqKKotwYgghu9ug1pqQQVQL3nz99fv3TqerifaoUgmVkMSjVlyYupCF119pdnfQPZtLvxFuMAyFQRv8EsdVGmigRSy64Hf3ZGMEJVCmhu6CY+xhPkZnjMEH2bwNI2u5lDVvGRElJEUFC5/f33/xrz+/Hs7rvpTDgWoiMkdLDJ+c8szvr0pWrF3EDMhmC5DtriJyZIlq9LaBn9+1qC5nC/WVkabTYvP8wIzEKsgmx/RtgbdYchXFxQpd7e6JQNY5lFJKbLVm55zmaZ7mKfFkziVXtdrMFzXzmcm6OoEI67LaSOc8A3RyklJOxKzWBSOxFSArspYiecrKSWqptVrmgIf2hTfMaqVUEQJVqLV6sBgPDVsxM2m2+vsifuScUgIAEfIS65wIkCohXIjIuoUTRDkxQSkliE4nSarqaqdoLn2UmBhl1Vdfe72uOq201DVNGcIVwkohsZuvURp1tZfGufXGAo3jrh6+4PDczd+t92bcQ9q8QzAnQXbvviMh19Mbt3sD2B4rqOQFM0P7EAGefQMFG8SD7Ihq2b/4pc+9+dprh7Ozw36fCGVdwdaRwDlZI9S5EbrDHZPlHttFIC93aF6+REmslWOsVDAyxQLh0kGJQgfVEP48Zya7RQqncP/RxJEHwgIAqsJMRajoCugBIRqYAUVO5oZPLngM4IrvDid3qlK8RDGldHL16kJ1QSVOVCVPnFNaaxWxdgOKdc05A6ilgsmKKzUiYAocCjvXZiGKCoMOrU0ZiohVv7AMNbEGsiKG4DS6JIgZT+Y1SgmktVRSqovUIkoiKrvMa9V79/eHsvCUln1RrSI1EarIKz94+fz03tG122ROIouErdq0onb83Fy5Ac9HIm40Tf2i8WW03xej7fbmSw4ImmpQ9LIowWUbPgmfttcRaNeoucKd7WIvPUOToCoTz5oWPV2/+uJXlsP+4v75zGnxUre1iSv7qogoRAhVdZVS3TRkjVbYQaBW+a6ylbRbPMGnH711LUnoVZmGuQViipoxalHGGhB9UKlt9TlCm2HxSe4ohJemCnUDtXq3AAi1AlWhxQ2TS9u1rtt/g4Cc+aIUfutuzqmKtOBfG4Y1ekk5EdG6Fq/yH2tviW9+lOenWZwS5TxN0+QiPOwhMy9KqVIrWd3BeVZrE1OqiAeYi5/EAaqU7MgAoqhrAVBEiD0qUQRUU5WilHki0olTpqpV6M3TN374+o8ff/qJJZVa/QjCSDVi8MwpNa7QoMVHGUTUowv7snbOoIfwRSdm3QZLt+siFgiNDQw0j+MI3NRBD7WDYI8TIovgYvc3VNGku5xfev3lt+7eO793XtaSdqRVS62qUhWitbTedzYZhlZr5lCl1tjiQLfh3DToYgEuiVk1qfWFg/fEC29ygzoNyg2qimMySh7W6PThPkqEbyH0U1+LYSk41jO4QuNfDfXbMjru7B7mYKkAY4qqqqXWWmmv0h7XdxAAsDyEc7aqfSAfG6JNGp6zrAP2xEAKtH3csPdEBDBZQHKcwJgst7p6TIxKUM6lVmsmomy6g1798Vtvvv56RiayJoMSGSjNuR4eygcd/UAAd9+qCEMcyDB+s1lt4E9X3Dr+e+PLVDsHsGVgGljKrYGIg7MRBsiIIWz4xFdLEyXNRFKU6OXvf+/8/llZll2iuhQxB4+EF8HLFTqukerNfEwXKlSq9QAiuLogqZWZy1qqRUWbY55Vi8Hfxp6b1YyzRWAo2GbzJ3jmmP9bAyZ1N4UTjHGEH/9SKA5qCppCX9Jlz7Q2rtG+C6MQIxAopQSiBK5SKXwZ2uhR20wGTKwe8jFsu+2Yk4nl4BoNiZ22EvfbKeD5nww1/8Jmgxtx5WxlxJwezfQiQsqZzV9kVT4SKdjaRonSlNLde6df+9rf/NZv/Xo9KCkrEyurVhpxyAC+h00Lvz3Cb4OIgxtcRgYTXOsjNKKPmzq3vM1LVXOjb786RtHtaWpr4voWESQXmzqAMiIiypS0Llnwne98MxHJWqrqUqoyVxFL+JKQ/V4SRCGkRWpVVYYowbPBYDVb1StrePCFiEit4VfjxFwHomouMmKKdQ4VML7CjcoNJW3y2n0bDPi4K9LWq2mF5mdwtumis4nXLlE0ak42u8CUlJV1LuFwtiMoH6B1VbZoq6ahhz1uD4jZ+JG9BWI5ZIuz4eB8IoKSaE3EAAt7N1tLNQDQSjgSiL0jqqgqgRMx52zplkV81bWlKzBpVWFRrEh0drH/zne+fdgf7OQw2ak+qcNK91IEzT0MvwSh9r3TgKu+AYFfyAWar0X8VAwkHrvje0vMOYi7Rx6FPmxkPoq0vuJx5myRAGYPqFY1Zw0jU6K79073y0We+HB+UZWrFHGKZw3/jXGVF/JWa4JlChMKQMznAiGtRTRRWQ7QzB4VoRNn5lSToLJIJY66O+bIE4nVCIkebO6uxF5RPMywXk4nSKw5/siVIrqJBruTlwugJqEQoWdtX4M6O080heVoMlY1gsoRag2NUNoGw6Ed+rmOLSkRUQqHtJm/au7RfhDoO8tc1Q7dRRXVzhCMBd1fBvuS9TIzH5vRMFsyT7LwD7Vwa0siKEqJIInSlNfTi++//P17Z/doOjYjO8BlU/NOgIFUtkxAnZypXWZnZoML6dJr6/4fYVN70/aNyPoDtDrDgxpyUjAlQAPvxHpS00zGIEYgHnxPmua8Pz+7f3q/lLquAqCKriLKJN6JGlXFCoeJaK2igzbzkzCCEpKdrioSp4NYQ7aaUsqku7yTIsq42C8RvwbfJOoh4RqVeTa019djsyIauMcoy2J8bJ4N4ERljUbgjNBNLoZGVWAIDvCU+MHf0YwrdSInoBfU2exX99YFafTlD3YNfK7mhrSk3GHrEGHOTSDGSI1DHI9QmxMAt1ftfFPgZxDme/AIGCb2Sm/EgHLO9qtQrYQfvPKj13702p13vXNZisXbeGFgQC/5VzosokG0tw0dPm/L0hz3LZIN28VrrqHGDvGK0CgE3bhj2sVdk3ntD4UqaLxnGJyYvUITk8XxqzDxdO/0/I17d5dyWJYVTCK1kiy6LlqLVuu3USFFpFjneD80ioEDUFjZbgasHhlVy2JOKfOtmzevX79aanFNbZwkgnDxoBH9uJaDJrWVdU0UT+3ztzl5kZIIk4cFObhPigEGsScxKiyhUeHvk6eMDfIUsba62Sm7cfSKfMirnde44UPjDvk9NcYes2rJ837WEkF4BJCqZThbb7UEJD/miivUg70BVYiKkHqYL6kQCdnWJAKBXYSaEJWcklRKRDnh/tn5t779HYjYUXD26qoSYiBgB5rk7agymN5/ds7ttN63cbte2j508dAYX11IeKJpX16KhaROPxTah0At7r1tafhNCH0HogAM5Vdfe21/vl/XUhWrSFUSRQVVQMgb7yhIQapYq6xSFynFukqDyQIhQUkSFdRF60WdU5JFsioT3vPu93zwAx/KOS/LMk1zzlOA+Y30DTQYZnrwr08KRJ7kRVaQmYmIkn3kVXribbvQQ/kREE7NnnHLSQkGCNVXupM8kQdngPrh32bDfLu2kmogkrBZmlRqnr240B9ht7MNaiVN4xjfmdxc82AlKzLJijD6Wp4DwhUXj0KAJEsVIm+podHFySpWWSOcUisSH5bl69/4mihACdEh3H62/5ueatQfq+LrHHQc+qrxSyhzbTh9K+dizI19BvUR/N3WmBq9NAyrbZVjFZoycsZr44OKkqhm4hnEa737+utlKQRAaSmSTIwyY0o18UpYRVapVaWqCKRAiskZF612Sk9CupSipSphfyhVKTHfuHLzt377t37tV34155mRrLYxJw4RZrkbTMNaDMvYl6Edz/orcmOM8hsaMnomApOxRGppNJzYf6fkzW+G28CCaxzVkKMhUWOjzV5L4JzRvvDP+jYAA037DmnfodjK4Avj0jYE/xvBmQhGDQ+V/do+8Le93Q31ZWrLBwURm33ABpagtUqeEkQS1eVi+eu//ksizJwgZAwSt46AiybbA6MN/i8MmKNhyo4VwqbYbq2Low6U2q3aqhuh57Dq/K0uZpp5MhBQH2enqfBtK2C9QUUSMWde9uvh4kA6H8y1k9mqsxkaripVq9RVFKRs1cM9qFdqAnu2i6iKkGKthYgmnubddHT1+M477jz9zHP79Xx3dbcs50spa1kST7BgXYcqgCOTYXoB4JvRRZES2BZ1U9YKCsv3hVqZUTiWjxc1XmVPHSVfmKZqAOtZDIIXDri0joDbd4CORlzbc3+fRsIN1NGPPE1cq/arqG1Oe6ILxbiJ2ZPmHtbmSnSfSJS2pgjEpJgeeXmekNhKkbmsiWstu10+P1uvHE21HL7z3W+Xw3JyfLTqakCSOIJA2VG6zW309rR5Bu426dD3beSbB17G/Ze8QrrhCUMaQfCbnwDgQDdiSIbzg46REMLTFTsDlBIxi5ZyfnGmqkqiqkJYpRRElL8dgFWoKqqS6MQ8MU2J58Re6tt6BYn5PxSgaZp30zwfHd26cetD73v/6d23qObHbj9uiSYpGqyHnPMd1E1Ux0BRaCLGYJi2nOxmDnXo4moljAF2dWYXcLwBL2yYPBQ7cJbCmxAgwEsYGhzkvtn5zavpII2jcwu0NZQTdtMDVoHLvSYgoYA6dQdIAnm1w3BBDewGVRqoiwJl2DmCZdKw2RFGZ57CiZxS4kTWJHPKc57eeuPsxz/6YZ4SrNuT99fRzj1NC1F/HoaR9rVo4LVL562PZ5iDIc2uHoi6plPnB/OXxWZ4QRqKelGdDoLqw4LaPs7hEUKJE4PpcFhVSFSJuRjKL7Ws5bAcLvb7w2EppfjJGJSJd2k+SjmDEoiqoAhKNZ2ageNpQrUWxXjvB977/ve/bzk/u3bt6LHHHlGFiuQpJ7Yi/gPea57z0FUaut3xm1ikqYWqWRSAhA+20Y7BRWd1I/wBA9nP4Ikhy5h6zrFzD0XF0UQAgZNXOgE6HMBWDIZCQWdv1BEAByxB49xA5i6lmvW80eWNUIiGNRqoKaQAtzJ5FEQxbH9XNiG/M6fMCaRTnmQtJyfH++XiG1/92roUTua61WQNetyy6kCneYmbdyzQ44bC468urjbU2C7XgT7hILZ/plARj1/vjBQKgobXJTaMQTTc0PdHiYRECXlK05R3R0cpZbFMx8yqqAQFU2JKPM3zLu+meUo5EaAW8FLEQC0xl1LXdV2XNc+5qq6lSDlMx8ePPXH7zpPPPvfud83z0fWbt4gTpVSKqKh1nxuH6naKDzOYAHEs5e4Y5Y0XwC0eou1CUGAn7TCys7+7KqhrS6NycyWBiD27MafEFoerBFh2gZNQG/VgICuaLA7vakPkTTB1CTWKTfXgzE4Qps06yrd9N11pqm1EAk2lxHz8P7vKWHVcNsAaPpJqxXw0r0VLLaTpK1//2sX+PLHXjm8qqh+F2bJ2YDbCNupmTCM2dRO6+/BctEcVIThVh6ojoKN9t4igcQaqox7116ACgw06/QeNIFwN5lJjJoXIcn5xeuPGtavXruwPXi21rLIva1lXVUtvrCApKErIKSnpWldRSSkdzbtpl1JmTjTlNO/SsizrYQFkmqf3vve593/wo089/fju6OjoeJ4z746midn1XcspGsSA0qBfqe0jBVD07iaACqLIWtiMzi3NH+H6wJ9hu+4FbU0BeCGhVod0wCYgslqlTClz5iQWVuCQgnOexgV2UjcmNbkbx9PBhDGzxpNmYpiYVe1+n/GWA+d24UYRcdIJQtUWRD3d0k1JCl/IwG2DyNEqpVYBcDRPlLgcFgB/9defuX/3jDiVWs1Q1CDhSClvj+1rgIZV+l4GwQ92fRttP2HpXxhENI2TB4iYOXccFtxxqYWUb4CfN7bAMmhkcfajVQJUKxMJ58zXbl1fUaaJ96fnSLSWIiRrkSTMnOdpx4mKKAPMvK7rnI/mOWuVpa71ABQ9OpqnlEsVqcs0p2k+/sBHXvilX/zlDz7//P2zMy3IOe9285znteyNEjglX9th1zVCqjRcMYNFE1BSjXTIUgktBSPglAer0Lgm3pR5RBUICuoowZWGoqkVqFaCd5dOQCUGYc5Yqra1FKjHlQ5HP9z/YYdlo1RyeeRic4hliq0fqMEWwI8++38gBziq/kU/p3J1GOYKhWRtWsYD2jSiJwCVKmut8zwnyhdnF9/45rd+8IPvP/rEI6TClCM7wuu0upBp8KPDqsuWkYYw9nIJAx7bnOQG/nPzrW+09l+h8AYZNNIDFGrdYUNmuSshBkV+21jwqI5LpEqcK5XpKHMRTpOIpKOJ9qkKRHU+2k0TwCRV1lJQLbeVhMGc8pTVqmxwnnbImShxES4qmIjTdP3q9Q99+IPvff97f/jWK6+9+sajj925MaUbN6+nFOgfqe8Uwl3fgUocn8epoqIjneAWahOkvvYPGGed5DWkh5sURIiQOWrvQwFLBFRSsEoVUcokVQmSjvK14+s73b3+xo9UU55zWRcZfNfxQKI49W0yK4TRdmiNihpdtAs0IFtzDW5n1ETxMP2uBdsXNApxN9kK1wlGCUkh67oycZ6ntJSzs/NXf/xjq/LlJawR8sZXcdQi4++DkNG2BMHRrrY2Aw1XW8S9xPY1L6YZxkSkIrlNySbs8IxiEB3MNsqJk/7YCeM3H5UqJdYq6ehomnNO6d7+fl0FieY8HQ4l5+ytPThV0VrBCVabVsDrup4cz/v9oVa9cvXKfDQnnY+vXFGm3W7+2Mc/fKLHf/lXn10Peu3WddRcVn38kSeOjnbn+wtRQGrK2TI4vFtwnLX7eBsvAGj2fSgF8+NEgGcPPSN3mflWb0jQ9yVuS/Ekiywg3xDbhqqkIjwRk0A0M62VAH7y5hP/9e/8syr4V7//e9//1vemaVqWAwAia0w9UkAntI2YDHnXBXTH2Q1KUfwDfVMvvWgw6ULbmaxu0lBDVXa2c2rsz/BaHwJMXItaFdGXX/6BiFWKlHDIWLDLxk3n2zT65jshhkKjy6uwuUMX9fF5YFnE2qj/pbkRgw4UMij6/nCPzmj6JZCgSVsiwHusrKWUkuTmI4+88z3v++Jbfz3tSiXNadJaBHz1+DhP+crJlceffGKadtdvXrt27dqrr//49R+/evXqydWTqxf782VZbly7/uwzzzz+9J11KT/68WuPP/rIk088fVovLk7v5el4XZc3797T1+Vo3l29fu2NN9/KiYtUeByE9KXoTpA+H20SLlzfjRtCSoRGHi1eCvjUCHEjewZCjaMedXmlEBKtykiSkiSp4GmaZk68PP3sO37zH//TW0/cfPXNN/7w7u/vzw4+4ERa2foI67AHsTk8qH/EXGKfB23vw2ObVasI0hgDsauX9/6SknC3Om81TRBsu061haRqYlaRnLMq/eCV76mAc5KqlLSJecOHDuibGN4Mqf2jcUfgzbaf40ub5NcYUXOtDXwBWDRo46ZhYn394JSOEH6DOgWBoD31ytq2pQkk8+7KI4/e+aVf/tWrR9fefOON24/cfvyRx3WmnObrN248+vgjtx995OTkJHOWWhT65ptvLodzUV3LWtfVbJvj412apnVZn33m6aXi7OJc1nLl6jWVRJyuXcfM0/nh3snRUV0LMeeJiNgLaD4o3zSEuaEctDNac/WxQ9sANR0t+N3cNRfL0aZMjVh6FlV7Ins7QWscJKWoKicqsvICYZo5PXXnzo35+MY8f+Ijn/jLz37yK1/9ZpCfWuC1i/Omln0qio5vhyfa321YxuyxqcBDTpq7JNCIHwxUSO0cccSEao0WFGYwdRpqEhFQVJVSClR3R/P9uxfff+n7PDEJilRzObUzMPMGdUBjz26y/TLHaUOwLo/6FZevjiXRWIn2sc8mx68OcALyKJwvO54eacEfZeorWomqVlZ4zallpZk+9PGffMczT9+8efPKtStrEa16fO1EwbUWAoM4JVrXer6/SPfvz3QsUjnlfPVkWYqKUOKL/TrvJlFe1uX84kIhKCBwKYe1YpX1aDpKKaUpSVHAalGhUgfoMeQNHAwZjyg4oIASUkC8UKxtknEO63KQmqDsBpbE4od6hQIqykAVsRTCxFwFIjpRppqoyNHx9MzT75h2x0q759/73luPPAr5xpSo1nbqq20oaGZfY4ZRzI+kOJI3BQ5o/osNeQTVOdkNR69NyjXM0QVfnN85hDFQRBvoCBKtqJCqSPjha6+dvXXvxq3r0JVTomLFcVpMtIWhN83sDDZOrCEsDNh0hHXaRFQj/FDThJH6u9zIthjh98BlFR9CRtseDKDLF8DLfdvYVFfNKUHkcLFOzHeee0YkC6omCOu+iEJqLSJwf2gt+4vDYV3vn50ezs8A3e2OYHXQKlR1f1hVpQqmaUaG1KoCxnT1yqyL7sv6zHNPf/Vr36i1TEfT3uKija05aPvySxt0dXvIT8Qb+Xpjh+YCAKL+Zs+gjEVxBoEqqlavVd0frNXVSVXVqsRCOaVKUJEV69HJ4089cWeeZ1n2V46vPP/O5z/1qc/UtaqX6hw2gZwAfSO7hETHBwMuoyDYLU5qe4x2j5AVoSoa0B6sm1g43XwfToISA3TyiwKZJAmkYNrlfHr39JUfvXLzkZspJVISEqbUm8CEgnbZ5HJ3kGNme/bJRPC3b0pwa5NcGxKOTaHuFFCAASuL0jHX4AZAx1qjznfmH/1p7TMjHoGmSkiJj06Oj45PDoWgFWshghAJQZE0QSqBRKA1USWAiHMiVjueTikjoWolYtBkaY8AEhWtFSoTzTKTrOszd95x48a1t964v5YCspYErAMlNqk/ICCTX5Gm3T37DfYMggZQkPoBjoJIq4akUBCiuDpUrYXpGLIz6lTY8WetamFLCfLME4898fgTIlpKuXbr2gsvvHB8cnxx75wTASBOXtOlaRq0vYq4hgfBXpDqCGba7jUeIYM4Lkipi0XHI+KL5nXkR5KypRQLIeoeYLMEIxybFMpa18orV5Wz/cW3v/Gt97zwAgi1rmTVBqwfkJWBjXG2QqCD9DL/S9/KwWPVDbpB6o8XhLTryjFEemv52RzK1AQHxfv9Jn6Lrc+K4jjF+0oksjMsTpzXpSyi0FqLRbuxCtTCPhfVVepapVStlYjsIAmqh8N+XZZ1WaSWuq5rWaWsIlVr1bpWXUSrqBZdy7Ik5Wfe8cydp57inOpaQ340HK6O6hXuJacmIhptUkhQ9WzCYbPVE6akz9kpS/tdVFuylWV72skXkVXyIiamiRVEAlJksqKHAuDO08/cuHWj1EpV6lqeeeadx9evEIHA3m87ZuEj7+SsxpgBRS4fDG3FtqkvE+0BnpwpVC2QB/28lTrhqJNF+xNU2nhqeMUNjB5aPhojT/lwtnz9m1+d5rmsxbp4RF/A0LXuatW28o0J2gT6Q1vQHtEQ1N+WaHPWrXGMGfeKlyhDO5l32t/O6hITEPUvUNBPs52sBWldqqhM80xEylxVrOIGqzJZBp0qpJR1ORzWdVVRqaJaa6m11qUupaxSayJGLcuyL/t9PVysF+d1WbWUTMkOKwRyNB+/593vIyJKLHAnaxPoiE3VqPYRjSWD22M+zXwlP0KwU1BRq4DtORyuF9QKjbebD8vEQZ9mOCRiJpo4M1u9cl5VS5WCykhPPnHn5OREVJeyKuojt27fvnozc1JRtvpLgf4R1IiR9LRTRIgsap7XgQdg++0tN2zQ0kdNl4grSMwJp9v1DVh1GsNIp+TvxJkjcUoqOudMzN/8xtdTypQsdrqVSxqUxyhoGyAx+WKr7UVOffDe8S8Ee/B+o9rgV21qrxOzKbfs4nD0/8YcHtStA7OEy7idGLpgFT9ZI93tdsS0LIXBiROSncuLH8+TgUMC4F2ApNqyp2QtAVVQtWrVWqVqbLI9RQhUoFITUSnLlZOjUg4emwDyYjWQMOZjbqZItUk1Gnl9OBG0h2j3p1GbcWx2W2RfjYAUI8j0tWUE94BIoBPYKsReObry2ONP7I52Aiznh3Q0cU7XblyvgKj40vj3Bmp3p8kDWj9+a1vk72h0maLY2vD3iwYG6O74HghADRz1PJRwVLYhjTDBkx8a+tNSK1Sl1IPqlPmHr/34rTfe2h3vtEZ9lz4T9XU0nqfRPtkYug42G86Bh8Bs6bTt5QbYNOYlvyt5qYABLG2YxP/Z1V0TLa31SJusKS8vR55yYrJCG6JaYVLfcIwJ+VKrFKvwTJaLRUhMiaOLp0JFRCuIvIsjUmQheksJItrNExE988zT0zQrRWs9ajkb6pLfOMoc9KOeRSdO9cQTxy8DcqSQCm11ndbbK6Cgq8NQk465hUis7YACoAoipAnp1u1bjz/55O4o11pKWYj4aHd0dHxkkafWPimkd8cBA3HT+M+gIGrYpeE8D4prMw+gEjTUkO8lmdCoWxsK8ssGOBD0FlQYjlF4tUlVVU487eZ5tytnF/OcYFURbOVpQ31AtJhjd2SMesHCd+FxoA7btiR+6W4DGbfpuu3Wc4KJ4LXr2qqGeUREZtEHOKJRoja0FOtmyE6EraAqGdmLSrQ4rQJxapRSaylSKyklWKvGBAs1jDzEZEX1mZJ1FY1hAVJRQEyUpmm6cf3mjWs3mFmtmxCiuEkwcJcGGsq0ixF34rSkz5hM3GFw/nnVrI2edeAXkZToAiPkcWQBUUrZ0yzA03z8zDPPPXbnUUaqpSpx0Tqn6erxlTQ0pxoJ/gFhFdTTw/nV/8Qlwbu6WYj2Y8NR492xeVI82Ei9sb8PMjRNX20jKiYC55xSSmAmxcX5cv9wZlkTan3+gsxG/EPOY33m1NVv5wbHNgS0nI+t7B4updGcNUltOcFZVU3m6hjxE9on8mY8LOyyV02H/2I8ltObZqujXVW1ip96xDqpqQWFKIQAQIiVmVq4Lnv0WcDEjvJsbAwiVkZOEKjS0e745s1r9+7fA3hdVoXH30u01xsHHsswOBv63UPIbTo2dFxjFO0HIO14qr1l/0fxLTglIBq1kMVLgUSlzvPu2Xc8e3zjhlAl0TxzLYskunb9KrwCEbW6dAPcadAjAAPChbiFrRs5HrqIYte65dhl+WaBmvfI3aFbbxLRwJ4DIHNS1eZkENWkqlSFwW+99dbdN+9qVUo0US5WnNcThvy0KfyxlwW4NkdazKBP5YFoff9oGPHGG9dY37xy6nJg88xwBTRFPrxtw1DX+6FbVBRapRaxUhkQSBUVWDNn/2OFG6wBKLwnSZSNNSGa4C5gIiARM3GinGnKlBNn4kRsioETUU6UqBLqs+94ej7aMfFuN1n1rb4og+LYEEc3vdAO+4Zwgg2uaYvQ2GkAAj2BgwIaAURg66bF1kFPCUqcUhXinK/cuPmeF959cjRbIpmCIMhMN67fsORm4oZAOubdQNI2Ghpx0Uj63asHx4V9HcJRFWBJqO0SAnY1id5oKIRxW8IBGwQm9AVQ8yGoWB5wIqL8la/9zWHd16UYCBCpnklGHnXdCbYhNnuo9i2kYJBBXXdt3ea3MfCorUXDOFCotSpo7VdcuGgcOOpmBTovtLXRyMoxqS2iopUzw4r/+I5J80M1fxQUpEKwWkkKdpPLU6icO72qSLJm7pZbgsyYgASCSgUkcQal97/wE1evXKm11vB1wIvQcPOPhGoldx82ZQ14fbq+BzQs5UBHwf7Ebd2pM0gTRYoxtQSA8bVSrVyYK2c89eRjz77zKZ5naNHkh4MpTVeOr1gCTYcwRBQtr304AzjaxpJdfsVO+b4FvIhGHoEHHE3RhrtoFBA9ROhhaMNXwqsLWHKGwh1ZKTEpS5V1KZ/+5H++d/80TVPREiQXp5EBEWxsOqwqKKZp7wQj0zAe6rGqXVv3YXZuDiJXwCoZha4Sy+YJUBmsstVG3XZq41LAQ6TIAa5h8cTMHKkm9mwr2qMEqwxaay01shKV1Mv6BNCwDfK4QRVVIc/2EXMjW3sgJq3l4rHHHklTyolECidGs8vbiEMJNuvVooHEilqrVJFu6PkSk7Glm9HNdHDJ1MVdqJhmBtg4VUSERFVQFQwGT5yJcs7T8+99x43rt7VIFanuNpR13WutIhY/rm13fKjtdG+c0N/26n4jbZZ0G15YZvaRtSzScY9p4J8QfG0BHoCUbVgKkJJKlWptX6sQo9Z6WPaf/8KL3/vGSxBls/pSgjeC0FHrhNwdVmDAo/62b6en9dpn7dXAKcb3ArY7GTD1DeuXYEMp2zsOA4EvRsOk1nRo3s3TlJjAIWVIdeRk64ELVa0Q0Sq1SlVVYiYQ2MC5f5fV88bbUThBSEVQDSSkxAxVkqOjdPPqMUhqqQGdqW39sBSXwCFU7QgCMH+zR7QMPoBQs6Hr2jo6ZTRhZHq/iecmMQXQpLWKsAhXmiQd0Tuee+7RJx9B1kWr1mqBk6VUK60DuA7piCXgStsHGnZ8g4He/qXDX9TkpM9OL103Wpa+ht3hqKBgK/cn2K/GUdIIw1y6UlUV09F0ONQv/c3nSq2iIrWY1PBWZlvKMs3Q36ROgaMuRAtE3cjpcdJ0+XenRVKRnkE7IKnYy+4WpMAOiJr1DirJDyKUmQh85ejoypWTKc1EbCV/BKIRd+kuSWv4JcHBSsQsAGB9Q6OfgzoujSFx15UgRvJqJkogsOaj4yvPPPNOBucpRzWr2MjmaYjlvbRIng4PHSIcbHANPNmTHUCE7DDKgJrny9svhSLvi0qAsjIrkldak5zTo488ssuJoNWy6MzHV2tKyaiyqWMEdKSA59tdps1fw8AfoIDApM0UbBKPgigu0cLwMCNx5/7QABR2IIVZGPcktMoZdlyVoFVL1b/45F/cPzub5yPmvNZiMdbOhPGjexdsuM1vbRMYD0EeUEQDzm44fXNBaGdVVW6LN2xYF+59OeNPoEgXfe79A9VSQbQ7Psp54kScKE2TddrxdVc0wawaRTQUsGRxXzP15VLdwFQa/lhdDhIrouxYivTo+OTGzRvT0czagwRllCoBqKPfVdtyjxD2anVivSfd3xwL4DUMOIYVlDEaNk1ta6NcNq1gKUoM6/4E1Rs3rl+5fiPtZlUwyGAPlIhTSpnSJdMO6AkK47sbcLDZ5Q1ZDBe0vI9h/mh4e5CjGoAHTRw3irIffQyNG7S5f5oTBQAzubUrykw/fvXNl1/6vtnkDNJqsLdhBHMTIk7fNsvgDkH/Gfga3XzfEvuwXM1yH0QDW08/IITb8IXx3xToKX6nxpswuGflWEk5GfhhTsyw/qHq/n/zBYh4cM0AqE2ZUihSa5zYMSUA92BwnBoblyR3BzARUEu9ee0mq5ZaKKWqgqh5aJNQ56QIg/KHy/CQNioJve/PDtMu6gG6lO/h4wMG6VLQ1tyxrSiIklAihvLtW7eu37yhpSTiRGx1eQEl0sTJqdFro8drI6Jo+9DNK+BD+1IoWzT1F1ZM/7rfUIOFOz/7BDz2tRHFlvlC6sf7FEBRVatYBXgl0jTnt968+1d//dnDxfmUZkRtZj9focYCXteUGsOF7qLhsX6thlQPCtImgpz0g/yHBSMihYQBQUH0gxev84uzm7bFiHHZB5JTIlCtuh4Oy1KW/VIW88aIVK3FSL+KeG9Yr8LTRhlNUU1AUXjgA2yA3YGn1M63qI/XoLJIuXLlyvUbN6pWFUnkNUhCHtv+Sd/MDXAgM7O9MFAUaNYN5HCxFy4gCk8BEOhk8Nv5lhnCNS+Oemi0EMvtxx6/dvU6zMohP602zJZzdoHkwWQGUWKs8URQAxw6bGts+lZyPsgiDUIMkNZRni399gtN3PU3RlzlgKLDi+Zjcw3LxGKAuMqyLp/59KfOzy44c9WSODNsmRL1fe/kGn+HUyCmGEqJhu3pw6T+xb6FGL5rk3Bf3eiy6warC4PL6+e2oJ2cghIzMalU1UpEtSzLYX+xP7s4PT1c7GtZVYpKNS+DKzsFIGQi3esuGY2q8VKY3x4qqN5Qw//zF6qGxyhPE0A3b9x+5NbtOc/hvmH0vicmklshsA4S1R9NvnZeG2ugtkYjsdUbZBk/46KA0Z0sTQuachNVVZLnnn72aJcZDGIROz4gqcIpzdPMlDoJkd8DLTAm3g1ya7/01wNZX10ntH+6YOz72+T3NjghiH+0yDFye6sO2D8idCK26upqrThT5pzy1775nZe/931RNdBQVBIl8gBSjdZwbVWH4YzPHwaiw46Er2Lw22q/frwh+SnYaPQF1o3q34PBHa4+80aYd8argFvJfKblcDi7ONsfztf1sNa11LXURaR6CEQ7sQ9YSRH4Qw7tXYdthF9UrKHB70HNG2noK1EtMu3ynaeeyJnhRy8dj45Qx96lTjNd0LinA3BF1zpK9P0ewpIH6gmD2JUa9WnKiFyYkDKOj4+fe/q5+eSoLKuqJPf6u1Ke51nJBDw1EmhuqK28a170h8h4xeXXIBTDQbChjT6RzdFC3F7bXqBNMdYKaKjWzQYNXGKtBL0VBw7Lmud0sRz+t//0H1SUpywiSZmYpEUMKlkLLahCooroqIbGnzHsrZfDj8p8WQfWHRdGVdlnx170vkOLQdkiXF7tPQazeUK8xDYDkFJPz85O75+uyyqi1LqSayERVIF4+LoItMJSYzSkIxOlRGYHu5TXiEdWh0nNOy6wvvEkWrUqQFLL9Ss3nnzi6XQ0KXEiKz+XumyKcIam/eOnk2jYNcORDzU2u2RWbmgqtKqtc4AJBKZQgDQhMbMoAenq9SvveMc7mDngluMGK6c15ZQ5jtloJO+NAOyo5e0J4/KQidCoaViLUDYN9Gl/ZqOA/lDn9bjepS9FtMTlIcbw2plKXQpW/da3vvvyK6+QwFoiEyASRxLd0UleAtvBj7bN8gX3XzDyrC+Cqtv2JnW1vRkfq8IaygK21Y7cBOL1wJp4ASmS2SUipIJqx2bq11UVqJrvhEGqImUta5G6ih2GaBVolbJKWeqhaiE2s8gX055FyejVkHrLB1dEnDP18GSPPVPAehIiJcl46sk710+uZ6Y0zZCoUGt71ds9Nik/7FXTod2tg+jjqrQhgkYHTfirI66OENpOmkOKQODEpErEV46PH7v9hKkpsqaa9kCCAtM8W71x80KN3qBRyA1/HsqaD38Nht3G69Hu2rXEkOnXPm9CdaBE9zIoQUb/V4cmUI0wdQVxQmLK9O1vv/TpP/1zZKpMVdYqJVmzDaTBY+OLon6yPGAwujQ06zxtPOnaSLzrov+M3YwbMGlEgweSJLUuFoIqrOp0riHJLVyERBlIqqxKRAkgKDHnnOdp2qVpLoKlyFplWeSwlIvDYX9YlrWIqAMThC3glr9Fgxp9uC8yMI9BecShEIdTJnqvmKm9ClWdp92t24/euH3LxupRqNry7nyqCC+OQYyQfi7rxeNXBos/cMKwu47lCK6y0KiiIxRXWw1RSfE+lo8//riScHJvvHRuFyYoydHRxA0VdpuMtsQ3umEu8eeGJR78oEnDAQBthX4H0AOaaVIYOmAhDTOxO8VCPVD/kqKKFCkMUtHdbnrr3r0/+IPfreWQNLMSKbOlEVu4AHk9Jz/50+BO8yw0bNgXgtqDXDa5ROuL5Fsc1pXjDlXldtgK9LMvmyM52FdioqTeUIetQrcIi5IKO7kKw7mCiZOZd6K1SK1aiawTp1TUCilSBFXsbARSVWGNsksVVauYGdEZNUIkQkkTcSJmSpnSnFJmzVL0QCiU6PYj146PZkFJTMSJvLtbbwVCzefb+eASlfgi+ammNBfH+GrUMsasNSpohqn25YS3v37s9mM3b94sS/H60RYnByJlERwfXUlptnRbZ/n+rA2+aJxh1PawsV0e8KBHLsnS+GWEMQ1zbc9kN9/ugLmhow4nKbaMSJnYdF1dVUXzxF//7kvf+85LnEkyA8pEpCbirDlNV1R+/3DehXMubN+wfwcPZrOIB2QTCqBLMSJmTggtzYg63srt6CtZ0L2Xv29OQJuYO/ZNJDOnlKaUpml3vJtP7JdpPqZpArMQWWxodzgRM3Oa8pTTbp7meWp9tTIzkSartJ2JEymJQMDIOeWcE+eUM3NKOU+7Kc0JCXvZX7kyfeC9779167r5a4AKduXmgDHWkPouasj6LuJHc7bL8wEj+fL3tBMNstCmHyIIVAGvEW1o6rHHHxGqChQpCgACVCIIxIhkmnZiR4HNOxGHCqEGgsX8fPAheGbLDQ8i80ueQXQE1EikT7a/Owj5/tUNRqROnep5V4QwPkSFE4SRcq6L/skf/fHZxelEmQQiUJUebDCu/oAY+mSo/za4TBzPdOUwfqkNyb9GGQBSUqDnvJjZ3tx5fm30YmCy9tYkrecDRDRZ/gszMUotlGmiWbRWqfPRXNZS1lrWVatXXrJ2FEzIOaXMwlmK8m5OUhddwvwI7avKQJqSQqOpkipbiRK1HkXHOaVSaJfe9fRTjz/2yMsvv5zTdLGsBjF4E+mylX3hbmmLYB8FPoE7nClIxM1cBVoNHGfo9gBbZQIlIu++CCS21mhy88YtkVpL1QolEdValQDWRJplKSIrwdLBvFfBloijBmIb0UC8iv7PUWYPgxsJmdDyHdu0fMqb2nOb+3QIZVgk4te3lznUIGUitbh3Jqm1cGLV3ZTno/yXf/WZf/Abv/XC+98vLGuRxImJikic4KDNw2WTp24aWGpP2kBTf5sdL+pDVkJDBmgmJq0eiqytFGWLg/UpoIl5qJISE/tpdOsOB2JiFgKSapVSUkqlrGDd5SnvqGReE6SIStH4CgBVKdXMamF4B+wq1YCe1GrFM+wUzSZrad3EUJGqsiY+rEvO6ezsbJ6mt956fTfz0W4H5Zy4CqJBrro5BneutBXUtrWOAtrYtpi5OR7aFsP8FA5Mw23dy3SoFcFUIZAVDU9MR8cnomJt4avxhAizVlWuut/vLy72Ck8W8Z1yrdWF10iUIey6744eIF299J3NP6nLxT6f+Gz7aKMobRkb7fZG8rZt2gmIAFWwWHokiYIIInLYL9M8v/zK65//wufe/b53ZWSlokxLWZlIJVBhpO7TuA0u5c1R4LAu8tIHRKuDntoIPRuUY40MkgqBJDPULZJmOKeFeyKFehGs6hTFTLVWM1pTzhVa61pKMX4iLbJUEOfMmdI8U+G1rFpqVTEOVFKppSyHZb+/2J+dLof9cljWWqyNpYoUqfa7BQ2Lx/pDtNZSDnUFCwQ8oVbdHR0flv2t67d203R6vpeqtkrks9qq+FiLBlxIAd5aCNpqIDWh1piAwvl2iSqpQSaD/6GtzajSKc+qHlQFl8hka1yrHNbDuhYzjZsMYrculJQG6fdwQu/P66S/pf9BZWzAE20mErLXg901tE0werdIgVZsvY1DjR08zlbsGECnlI111qUmgoj+u3/3b37t1//+nSefPhxOqQiLYmKt4gcHFA9GbFRInhha34xQYHppru2f2tSJqRLVTIqUZ5ZqZ6wk7ngTKEQtSgWJRJRIyKSuwOQTE6tKTlCmRMwJBC6g3TTZQXFdLi4O51yWw7oeLi4uDhfruu73y7IcqiigtdRlXWqttZTD/mBuU0NTKXkgWXf3qifLWKIMMaPmY5o5ExKVWqaUhfh4Orp35+LmzZunp68QXHOFam9wp2vyLVHYW52obLmoA6W24+GV7qdBTmka3nb7EhMqgKoW4pZySikTPCyDAnbZQ6XKfjnUWn246tmk2obbtlZ1lMAjfV+S9A+8hrQd+5ffnfqKXIYMGnTnuVN+pt5ZpBu8FG2nI2DN3B+spCRSRUupRJhT4nmqS/nmt77/6b/41G//o99OYCISFogCrFqHgShoAKj+aBdZiOEPE9Q2L+3sT4Ph4xPJRHR2761ESQmkIt4sCDkTE9Vapa72eGNlZmawwgulmSFc1yLkcGu5uChSal045bPT05deeumwP5ye3q+lFK1llVJXEWFOABJ7l8Bwmss0M5CZOU+J7aDapDdxoowWXmved1XOpJkrKZcl5ylpOtflmSeefuapJ19/481yfmCCAGRtHnVAP7GksaDqFlKo/0bYvt4aolB1KAhsVwTh+K50+mnOE/MkQDBNeZqyQpW0Sk2JVBQMVP/Wfn+BSEfaAq6g+E4IOhChbhw48aX+6ijHl7S9P5BQjLYDjsHp2K5Uder2tdk8c3CVtntAUUOrOOVVocOhHM35sC7//o//8Jd+6ZePr1+tWEQVlkgVw7RK9xSRdhGQHTPS/qRhLroVFYqo+hsC0Ik5c1mOjiZUlLJani5BBVgvVqkFgCVu1VLsNGE9LMuy1lpUsa6lrItUrbJKlVqLiuwP+yp1Laus61qKkqroshxs1RKnxAyyiP2xohcsU4wJiTMnjnqD6s0ZEyfOIDBzIgaYTYOyWlX0eZpSzgCOcXRld/TMO971N1//ut7fV1YRD7DzOmSCIc4pRMXgFFGNhe1kFIglsIVu1L1xiHQIQaTRjpWGw2EVEPHJyYkUBXnTDJu9TVdEyrpKlRGFhrbqkmx88iViH0XhFh09aAXEF/XyG51y4bKSmkHa9MXIhhj+EV0siPon6vVqmMBaiZnTlKRWCIjSt7/7ype+9Dcf//mfQrW1o6UuIOueJtaAazPD/rTuqmtybTMtZ/XRAmgYlgDkb37j60S1HEolqWtZylrLWksRqWVdl3VRqGW3rGuJQxtVT/Jic6+KVIIESK4KIbU6CJYDieNdIiaYvatIUx6oH1Hfi0iFTGALTSkplEjZjodbU1JiFSIiKQ7jWk/rWjUTI7ESnnryzu1bt9+6d15rlZCo3o2ue9MiBtk2lDZsgIb7nQX8SKwRQdDBIB2jnua4HeYOUlhjLIjWnGeQqvQmK2bTqEJEDssiItTPgAfKjX3ru/4AeV/SAKNkpIA57UJ68LINZxvBdKU5YKbB0g/udLTa/h0bPEAuFRGAmLhUUdLDIsw4PT//vd/7Vx/56Z+cpp2se5WSORetgBAl1RqIJXpUUp/URiwMXs54ZEN17YO+qyqav/Li51ZeZj4uUlCl3drjNwFO5AjAJ+dpXcRJ4am3DAtdshGaw7cSWUe4pIpVqpQKaJ6YiEyZGGnYsnFEiBJIiXJiJobl2YtASTxYKKWk3qSGWGqtqKBkGFWkChNJTQnHR/Mzzzz50ss/3B8WbwNNZsk4TFVpStL4wc3kkZy6Zu2Bz+3Ny5LFYKJtOcIesMMUYxHTQqb+iEhCPWgAZmaG4OLiohqLu9o25xM6xNFOjJ2uLzPCQCIN3dhI+hUdKbubx7CBOcEGfO8Xe1hCG8PGCNG4Bh09NiZz7RmUSlUEijwnqSUfzVrk05/9y++/9P13vevdiUiVOWUUkQrOIE3Nkx+DGvJ6Ai4iHu1b1P0T+uCKtO/wxcX95d5pObtHZZ+pJC2sJcmaSRLJxJIhCZqgCUIqWlfUMgEzY4ZOKkeEHdOOaGKdVCZIZp0SpoRdpomRGXPm4+NpnlNiJGCX09GUdpl2meaEOfOUeUp5nnc576Y0pzQBbK7VxJPFttmZ8LLWQ1kPaz0sayl1KUupS5UKIHMmUsqpSL1+8/p73/fBKXNKBPH8MpixEY5kqHa5Ti5LAtv2o08TALFqISDa4VnnCrdjtMGEYd1T8tDanDNxAqLfDtlEoWQxGro/7KGRn46m+mncRO3yT9uI/45X85EOrDyCHyNNGuZK/S3qN2jmQaxTX6UtPotvbz4yCUrwcinLIuu6CurZ+eHf/9t/e3Z2muYZLJ5SZU0XbNQWquMLG+wWhvawBTowoE/j8u71eAjwyZyvXb1CGVLqYb9fl6Wsh1pKLavUolbDv5Za7ShrYdJpIk5aZRGsSmvVpchSsCqqJhXWotUKOq9ai0rVKloBteNib8INAkiIqleJrqtWc5oIaVUpagGlZKBJwUpW+Vb8CIGIEyfKTAkMUS1SmZK1jJ+n3SO3H7t29XopZZ7ylDIzJWKYY25oQN9kVzj9O7zpL+27F5wTZBDfi8OwkNNG4PEVqR7pOM/z0W4HkAQDqiqBm3VYaoFKCNuBBRohj6dODWe8Hd0/ZCYdx1/6wAkjbtdOQXTz7ZgddZ7yr4/6MVZrCJPWy7JBkTMrwMRzmv7oj//opR98jxRSdC1VBRL9yf1EoS10MJfpKaLQMY0DR4wYSmvYyL6A+bAcRMsu5cSUs+kWJRKTlsx27CtQD60Me0S5V04jiaUxZ3biBAXAJBRnGdTC21SlksAyI4kUIhYXAWWIGatVipJonWyUFqFhaVLkxGIzp8SkUAviaFXMRZQn3L51453vfu6VH7+yrDUzqULZU7VkWI9Be2pbvfHcuL8LNFXegTP1SxzKmJ5RRVTKV1ECMZOozvN8cnIiIpZ5Y6WZyJ0SuaxrKZYc7IBqNMdtOJ4eMQDfGMaA2Eam2crk7dtG9uSqa7i88YgGdQ+3IgDdD0a49MC+siMYEiAOciGq7sKAZIgACa/86NVP/tmfv+Od7z7aHZ0f9pl5QmJOKpXF5AMBgiiUENtEMWcN/TRGiMemAdqO8+w+IAA8TXScMzMoqpYnslA8tbqFLUFGVKvUUqWIVEWpWkWqonodDEtYZCGuREJUoUVllbrWYvWdV5FSi7QCp07NOVmtc2jBuuqiXMkDmR1Smw/I7ILEiZg5M6dEKfM0c5qmtEsppzwRk6jSnCA4vnLthfd88GS3o3CtQMxLTb19xoa62mHo5Z30d31MoQQGRGnHPg+hAwDeA8Xu76Vo1E/CCFEi2wpsVJH9fk89S64LvAELhQQeKXmg7oY3Ll0x8lEDcB3DNYthg/7QRS2NDwkEGSBSQzl2gNj+FboFTQG5GlZhLUuRWo+PjtZF/tN/+o/7szNSyZwyZ0//lhiU+RhI0cqlu0+mT2Gj1vpeKCLYMzbO2Tybf5MAsSaPgDDDmhqKrFJtdzTCi80jSxyeexDsiybEAcArjLSFc7ENiypVYoYoc1SJ9YrNlYiBZC5PG6kxIjNb6rKF1yhT5tSq5QJcSQAmiEUixebJxcXp8+967tbNG2fnB1BaS6Wo7CBQphSRPoGBYOfpBiJ7vE0DziN5gUJyAm6UUew8APXFsL0J94EQiBNbOUAvaUAkXtDXG4YfDntTGra9NIquh+7uYASPGmCjNfpXBh6lzQeuVVyDgaM+a8zCH/VwgKj9YyUdjh5jNRo/wzqs+7RYSRItixCfH185+u5LP/jMp/7iH/yD3+SJUVVrrWwIQqODbbOH2yDatnR51DFr27oG+vzUyQ0/rrUiIv5FpUgttRQLYVaI1FKLmZgWC7QVBqZ1PO7eEsqJrGk1ERFzK6UAIkrMmVMiSikxp5RTSgxmSsycOLlwtzRLYk7xIgM9bPUmCImUVFiFTX4ygKR200SkU55285QTbt268aEP/8TJ8QkRjndzTkmDT8VasXsenBfCCmCvYeRKxKIoQnR0DaBBNg8gah3u4Z+GjZFzrtWKRloJaOsP4d039vuL87NzEeE4Tg0zcqCzy69LUHwcRacIuvTh5uVWBYE8D7Z9QP2S9k8i9KyEh92smUihGUZLwIqmi6ohCNGioFqrZKazi/3/+3/5n7/6ja8zZWillhnnhwp9BR4AXJcXZyP9MTokHJzZwrrsNkoNavCqB/6TmJg92JkTW1y0Rh69Ap4b6Y+xjGYjWUNjVtBESWGnoWQwRCy4l1kTB8eQKQkl0wXx8I5vDSwQWTZzhShpSjwl5pSY2CSnpWExpWk3//wnfv6JO49NUyJKUK3WR0xpsAQ7YKC22lvKeRDX9DXuXxkJrovWcdwAEqcIo3CneEAOIuD07PTs/LwBtEiTDe6h7V6OMGczRNq+9fDhb65vGCGY15viSPQdp5HRaPgDuAERxkLAvQYSG1AxFSNeDdljqAVa17qWstsd7eb87e++9Kf/4U+WslCelUSkWJkkU2sxhLYa6BKC+tpQY4nYB2qq21+GxYRbXi8RWYHaRGyE7iJ+5Av2UnBwWxlElDAQqA4c1paqFZUiBM/FP8kSYb2REFNiSq2ibSB1K5LkzgD7qmdLWTFFJkIyO9gTepJxNy0X+6efvvO+931wt0vr4WCjY7hk6XJV9dIqNezaV2tLRtp+XgLWjQ5G/Qx3Z4QMJI3mEQYwnRSq3Lt3/+zsjNhgzxDpFRJwfBw95Le/9fX2vOxIJ2Q1mrh2KNEVY0PSly4LayAMAlOcATf6od6Qv2CXM5FApOpa1pMrV87PDn/8H//kcHqWQQxm5KoCaFRfaAgkkGhwZrxFIdsGDg1d7BaAO+ZU3QBLfqlaDgdbSxaDB5Z6awklgCd2eHpHYs5sloOhfIqyVcRAYq9lnolmTpk5EWencU5eNJwokaGjxIaJuCsEK5knXg3L7QwihjHoUP0Q4vGwwJQyuQuyJqKi+jMf/6knHn1SUKGaQDyFxxLbJbR40eZVG+Xr30lX/XfbCIq/OJzofuRUamHm8FeRHfOZHpAqr7/1+v7iENCJ3Lc6kL0+8MTNGw9w6kO49u2GPnJvXO6s2Uh9iBLuUm+801bIStSoj283gWJeAAWBkZiTkByWdT0crlw9/tGPX/vW179R6qpMipKZSZsQbgsbv4+T2xjzbSbjtKmrOWgAH0rWyC1ZSTfyE6jM05S8zmaixEQpMTMl98m4LDfhYSwRbV2MwK3SfxRKNR5DNJ0eWpCH32qYTPMiEER7OqRvCilgJrAlMauqikgRv5YEUiUzC2RK6amnnn7Xu96Rc15rYSItQBzHwssnBgahDl+0C7zLkOLSrj9IVzb6BidVVaqdfJNnuARRwCwNKKBlLT/68Q+XZYkDBeU4R7r0oJaKdHlIl6jy77IDLkOZ2A8bXqP9AXxfMnWG73X1EsK+g6oARX5fE/9Sq9SiIkJEc54TUSXNUyZOv/+Hv/fm/TfMaCROQuLV9rXFiHW3U4h0BLCJ9/tqEOmGXwzyqIeUWQxv1ByMXyjEvymFdtAD6o0QJQS/XeyWblzZ5YiXwfLC/74ApF4IKVIuh3LIDuID07QKXoYtxQtNqDuniufaO2StZVlrWQFKTIdloVl/+uM/9dw7nsoJpVTzUzVR0bXzhqJc0mhXqANjPEBe/ZdB1IXaheExwOWWVOmPsrMCUQXWWt568956WA1nBubT+GUgtocCIUTeYdvj8VMfVOjMBmocsOnmfuFraXs+CtPAEhoQbiCs7Tj7CtviBm6qXjC+VC1FqxTrbwsrK6hSvvjFL3/ti98UMCWuWkhgGVghDAPaBw5CczQr+rzHHaX+u3MCAWqp4uIhQK0ybFUr4+buOm3mrDcAgGpLP2oJ42SwyI8NQEBnJC8Phk5KjXM7lqOuCsyGRvBxeFVhHATA3WKxn0RQUuMlQ/dmZJWy1nKo5+Wd73zhPe953/HJUWKqtWSinBMTWXyabWKcWrks6Tbh1hTA9vdGEsN3+yQdV7fuG6IqUktpOMOkiahkTrWUN+++UeoKhtdKQXhU+p3ja6GsNoPaOD/9043cu/R7mEKBKMjHTW3aHoRI/e+NH9C4wm9hexequmuuBl78vFugYpKWCYlZoEtZDutilkOaplffeP33/+D/q3VlZBVKKan11dYmUnzVY5xhnMSqbGTTBiH6t0zGsKpSal/RKJFcG68xEzfL02pCmK8GrVp4L//vlgopk/qJkyUKk1p1Q1MFcTxgC+eCxNenmzkUBj5FTUUfHiBEyoBFlAFBWXFSQhaGx8pgTrTKXmj9+Z/9xNNPPK4sOU01KsdZqF8zf/vmxrvohldfx9HviHGxYx/arvRL/DhMq4j1Q2jILUL7eL/sz+6fe6+auK0v9gh5tdPZdiCD/nqA4OOb3T8Zkj+YKHDmAJS0HzM1ABoj78iji7GBBqmxv7FRf9mJkDMwqagQkfmcmEmUqmhi/vLXvvrKd3/ARIpqgdPqMsq8qG0nRuK2sfctROifpvFHXSciXNVycRmcAaY0WWlzTpnTlPOcUuIpc0pgNhmr1gqH7SyWiTMoWYxEJSvYSdHk0trERAbLID6IvHcWtXgPF1fN7crhDrLbhBcJrB2amkcn2FOJhQALuycos3XQYM6cnrpz56c+9vGbN28q6tE8TzkRw2IymzdDPYp/IKHu4Wgqa0PxbfmDnAZZPbruotr7uq4uLY04CFpVpBLTYTlc7C9ih0aUMz6P+gAfQuCX36Ltx3hw5JuP+1+B5AZJ2ono8sQxDNkVtGegujsi1nhkwBABqKa6LNXQ7Lo05fv3Lv78039edBUAgiJRYpOabKJhtS+7rkc2jmFurjRpmY+OTrpcC5BDjeVdRKuVgYOSHXXlzE2Eqxo/upeDYI5NAy0KNTPQoj9i3AidSH0xiZgUUQ/HL9MQwW1ryXMHoKrElNw5BhG1uuUUYElqFSgLTTlBJc3pwx/9ye98//tf+MIX14OWQ6lVKbVcJWiz1bvm9im2zR70/AOk1HRtR75+F2ayzteqJN73wveIiJVEVEC0LEtZCxSUOCKF2p62X1peKwVjdAHcx0ob4r10l3YP9F3u396okbBkeyhz0IZg5HSQOOU3bKWjhaB25OFWTVspArVDMiIqkCqKojlNAvzxf/yTX/jZX3nyuTuaFha2hvHUU23E8Q65TIpfe751vDlKk5i+gpmZ0qR5p2lHPFM+onzEaYc0a5oqpQIqiiIogiosyMQz5Ukp2x+hDM6UJ06Z0kSUNSVQAidwUiQhFiULgzcHpgEl++Nl/sFEGcrEyUs6U/ul+79UEOvlmCGK+AYhwCPUszcXJiZWiFQ5HA5lX+489uRPfezjzzz9RKml1mqGuCkXOw8c8hzR9EKQhKsA37cuaQZo7G81LWLvhkeZCNBSilrFUy9VZLvFqnpYDsu6oh0XdIEdFHMpvmHEuZeEfwjjh2uLS0Z0c/yM0IvaM8Nic0RkelIe1IMU2u7SI9yCDHcfDQvWFjZWU80CPez3y+Hw8iuv/cmf/NHZ6d0kicxWpbZH2p4xIHu/FW0S+lwkXl4HJgB5mnYVBK9awVIB8lrVmSGw6jtuiDXJQyArIQiCingJJwKIVLmSh5NCpXmTXO/bXjrf+vFec6baPOwyhTWVg+kQJwYmCCilPjH1BdVISiYiSslC+mC1LIhIqkiZb1z76Mc+8sabr37vBz8+XFSiSSDrWi2jDCwRbuI07BAlnhVkMfwWJDSs9SiOg/gIYC+yI6qlFKIm+cDgVZac8v3796VW9RPi2K6OK2Jnh9cIUDb+lwdeI0x/u0tGFdB0usOWgZ7f7u7DZY1IXe3HdoN6YnIsWshjIliBeEBr1Snzvbtv/cG//le/8Vu/cfXk5rKcktI8zaIAi9bGnS1mEgNLtMDPJr6GgcUgVDUfnVypNdwU/YvkgK8RYwA546MonWltllS1tixxP2UN7Wfh+U5GHCPqhWqVrRGwSxihjoDCMvAQZrVaSSlnEIhYAVIWrcREymoBqyDApIRVGpUEd7UqFLXupt1PfvDDn/vcl7/8pRcTpTSxZhBIVLWaFGWCRAp135tYSQqd3gizR+eOcAm+ZrAab+SFjMz/XbvvBVBS5lTW9f7ZvWVZA9y4jpNNRfLNzj74wP775ZE87P3xLsPXt5eMjq2ebbjh/gboIttw5LTLNrTdrZGskpLAw+f8e5bRwTmpynd+8OqLL37piTt3SBPb3qowGKihqSjYrzvY/b1InRvFiI4hjKCsYLUmJVYgUWGuIXN/RdliF/PsyYUAKBkcE1eLEbYUiyEG+iEiBWLai4Sa3WLJ8uymsTl4rPqQKpA8FsyWXwhWVxAWBm3hSAQIiGhmTmZMmUOdGMyJiZSQOSBTShBcnF/sTnZPPvP0z/7cJ3786stvvXGWpiRL2GfO5BJuH6eHAAOiYdJdoqj2ywN0GayiCCjtRQYM9EutxGzyqJR69627y+HQwcdAg2G4ITT5wHTavf8D5b0NBzycXS5d0m5OCpM0CIIBHgBiFJzp7vE2zMYvcb+uNXt+J6IzTiRjqooKVaxUUybO6d/+uz/42Ed/6rGnnljOzmupCuGUlTmqtcUzddwY09/uNaLxwdj4UVlAAIlVhVaImhsHxGxnURZwk1JOPKWUDMR7GJBloHt0hDUMsJ5XbBFFoIh/TxZKF9DPnD/MlAbsYyRELgzUTW+rTYvosQEFiehay1KKiHJKDDuoNicqm4FM4Zlij8FWYTkczg4XC9X0Ux/5qeeeekZVDvtDcueaWEiHO4LD1AgCDmMwVtHpu7kT2+q6UA9KorhLUI3UKirWDtaWxy6va33tzdfWpVBETUk4GV2wNO8QhatyjGFDhy4PUvdlUt/aOpdeAZcpZDRcCNovzYs+4ByNn+1+4R+NU4xA6K4LBidp+IZIe0d1VYYVXDuej176zvdf+t73tJRpMgLiqhZKog6tu7TpS6WGN4edCUaMMatCNZdq1jsRpSZHrFyhAX0CUkp+IOpFvC2FSbUKmfuFwAJiVhF49i0rRBmwytdkUN8UEFGgKgLM7QlFcgPDk7IVau9LFIcK+EFWMxre3HRhSrUWpmw3F1RSAqqhI0UFc8qZkeaj4zRhXfY3b137lV/95R/88NXXX3sVTFi1ikw5EUGFFa0YHIWE832zYWwc8oFYwnsWUChAJ7lZwbZQFjduMouJLHjDWPutu28BWmsl5kgHSGYTN7suHIuWLbEF5m8j0fGgOoishy2a2XBEswG6gAoyC3Gw/bIGzu8AG2QT9GVQf9dH7/CPnGSt067n9zFR9Uii+sNX3/ijf/uHH/zQh66cHF2sZwkJVSsqK/HAZAA0uka2Afi4g+00Ej5iOYjRnfMb4aHWhQUAoYpIlWiFq7ATK7hUM+QlKqWWIrWWWqvYTxVIVfMCqcsy6xjlXiAlVmKJnVUQyJ1IRO4v8gMBKxXNyZRJnibOKU3MiSkhTZkT8cSalJgog1hTmkStD7ltVM1zApRYlv3y0x/9+PPPP3/9xlUGVZXJ0hFAbt4orASqRYnD5zn+vdn6flhmi+5dYN3RDZgb0K6mWoutsbuGvQEm2VEheXFG4z3bgWbPjafpl7wwb/uvh9H5oCz0gS/0KxpZ9APCB7msmwgBbxukjCkE3nHBQCYIjBQNRNv9jTsEWlW1aik1Ja5a/tOf/ucvf/GLa6kEmnKq5toICB7UbzREgVljjqGCfYgNZlgskK2kN3lWVT9r1aBueG8tstU3Z4sdCkDtHMlN8ZY7Sf7HkJLFrHlHmbFFpFVdIQs4r6JrFSVr3G3a0GCPFlHrGFBrrVEZV6y2CbEIqZAztoKVEiWCJd9gl/MuTXPKIBQtWgsVYiVmPrp59Z/8l//4maefBosb6gl+EGIOK4tbagd47uhsJ/3NS2qD9VE17oHjOAm9qebqUrVe9t4FCqoiFSrMVjDCurBGO+SQLwjF0109RFuifoAvt589RD3Q8HP7F22u8FPdwX/f6F4fcmMdf3UpLG2xADg0kc4oBPUOSSLWHN0Cvooc1iVzevP+6e/+/v96cX7BOZdaVMQsXPf4j4BsmACRn8cOPt1mLjj0cgDKXeUTqZ8uJTBArX9bd3MDRh7MFETSUEHfBvumv+98sTWFKDp+2WE/c7WUNJFgMAdJAmsQZl1GpHiWBqQKoKXWqg4ilahCFCRk/YpzmrwKHadMc9YEJAK0HupzTzz78Y98fDo+rrqiYj2sKpViGcz/RQOe98i4Rva+xrTZgw6HqRVJAmBwzlaqipgbFK27vCLxdHJ8lRk2Q5WIdhqM4ib7+88tMf8trwf2Z/vqInvklkadNFgew0j8/VHqPxyHxZoGfcYz4qkuXxv6tYsMFKXEZVk//Zm//PznPqdFuWqilGmCdz1pq9zPL9tzNtzYEGoblWeIu0ANJ3drS0P9sBGB8dCOeVwHOTuoZ+K3sBUPEWIL5u/tfngQrQbAONS9NaLxxpEeYRr14DxqIljY+3owS+hUq19mrlrfiDDfTDizd8JhBmkph4sDuP69n/vE8+95/ihnSjLvJlGiFAAy8GTElmgjx37eY4qgif+wePuKO7lEQBxAIGbvDk1W+UuttEC9evU4palqtVIX8Nrg/X6+vQidFBZBuIsHQfg2ZPj2iiA2dXwrHvtgMk7DQy44o2DHA7dvojGoJjTHiPEa6naXh4I8EJqWUkuV3fF8frH/i//9P5ay8DRXEkHNKbXeLBTCmGio2rpBi4F+NlNTbgC2kYoiukmrJTjDj5Q8WtKPAMCephWggT39cTwh8pDrsHgwLNuwZ4BGtWFjHza1AIqKlIGpiNj842ZhaagvVVUViQAUEMCoiOgDsBiurNBacsp5zoJlXdab12/85q/8xjPPPC1V1qUkYMqZvbdkJ+AmiJtM2bg+1Nd6UOk+OQ+MjZn7+Rfcj2CqHoAUnebdnSeenifOzALKKWdKFFHUbRWCUJuMdtJp+PzhErjTbSe4DZU09zS2TBxXO9sPBNskjPkb+1I8wIL9RAeeBwiKZuM+hKZAiNwBaHKFSJQJ05yr6P/2p3/2xS++WOuaU8qci0hFJKz77AJmNf08SAYXoDEBe6DZAM14cSFja0AN8AKwMjYK7yBt/no3ywBw+MYiBcYtPzUcEd0OSL3liUeGE0KzUEPNPcxR/f5GWzGD4BmXuE0QN2wXP+H91gBVZSGG6KowDcEMzjOXsr7/J57/xM/8zM1HbwKFmeuyilRzPmlQiDb6a7rfAWGwBQLcNTs1lt58Xwo1wFZVlsOSmGsVFSGQSE05LWX/xBOP3bp9O2UDXypssaIhxrYSuJt2XYJ3bDlQ3yViHP8a5W9o/wC6D/lSrEioet8t37zRN9bh2QZMMcWCGn7miLHukdYEgkgtZa1SS10VKEUP+6WW9f7Z6e//3u++8ebdPO9KXRMRieVTtp66QKSih27eTMhYLAiJ0VrHYVxkY2Zu7GT6XRrIjbcFBI33qa8SAD+L6zwX7KfdWxjnbvBDhFAfFGHjsGBZw3gWTspqhg2g1toY0UwwxGMwO1kNdzKetaGnhAyiUquUlZJ1GshXdtd+9ed/9T3vfs/xyZw529EEebGuMAa66Rs0QSFgqK+5OmXSuCCuTMiQjwK4uDi3dazVHGzmHePHHnn8wx/6STOoMxJbuRRpsh8N7LYdvgTJY4venvRDnMTPLaWGEa/byerwp+N2h+7xc5AN20d30OhNB7Wqqmp8Rw0M+61dsUZfcxuJiGTiUupnPv3pr375b9ZlmTipIiWOEMs27YGG/RaXYKQ924jQu0CFAlXQEAyjgIdvIFCQDto2vuIDH/XLsLhNr5jebwrcZXxnvWYtwuW6C5uYnGUEQOFJjL2QScu/GVbBiihCCEJUW688oUScKfE8gSClkpSy7G89cfOf/tN/+vSTz6guxpOU4SdwDReqmks79rctO8FMlMaDQHM3Bwkw4I1pSbHf7wHUWjRqWAC6ruuV61c/8uGfvHHrGqkgaZ5mA5lWOsWS87St0pbOtprAQe3mpZd+veRFbTphzO94yHc3esPpNUTu8P7wtQbA7bFoiym6ca+r09q4xJ4qDRBNiXI63y9//p//7HB+kaepSJEiKfJOpCf0Xz7oU4fIjb/b88BBpB0Iqva0cDT9EYPfUnmI3tj5tn7G12pXWHrXxj9LYUc2LdhvSy4yHILFSg787bdxjg0B1PRbIOZmJhJASdDKonOqPjeeqKrupt0H3v/+j3/048fXrhctLJIpcWQNx7L57l8ShE04o9lRUA+WdI51UaHVl35ZF6sOr+qWbpWyrOcJ9O4X3v2Lv/DLV66f1EMlYDdPU07EreJuR3lACPJLVNeo7BIQou2nAVQ2yqPN5RLzbF4bpRO4IEi2vwtsSSXWC8GgaJCrOxhjVBRTIsCLCC11mjPn9Oef+vQPX/mhaXJVFaZSRUrxcoYOvgdbbDOXQTMACuXxfR2fjWFcsSiN95tQH6cejO4pXn2FVDt+Nu1tfhrnk6bLJSRF32BsODGeG0bKCAEum4EMWHVdCMMO1RSkjKSQysJqTZ1IpV5cXFCWv//rv/YTH/7Q1ZPjlPK0yzllDGetSjarWKLLqj4cWQMwAswKcvHnZaBKWZfFlAaYpCgSpCpVqpCrV6/++t//tQ+874PTSSprseLyCgDi4t9QaAyB+uMbWXXvUP98I5JHITa4DsemN5fg0+bVQVZb8C2Qit+7bdu3c8PGCAXbqLJ9v9tWRAJOXKseDguB7p6d/v4f/P7p6VmeZ85MIJVaLcvbDeh2OqaNx+NhTZL759zWpL1Et6PRvuEhX4OxQgyF42CQCv4jjGOn0Pi+EUk3WGUgn8YPhkVMe4R3x50ztCGDWLEQ/tQccu7BM7xgblmLKCcSc/8KEpNo3Z8eHnv0iX/8m//o6afuHNZlXQrBtEDoKPURcD/sG5ZukDgDRgjP6SbJhy725+Tmk/XNqiJVyFIF+PFHH/v1X/61WzcfEZT1YimlkII0GU/50x8ANHb7CH98KEEGQbXfKQbpH9F2An8XE/Q7DtQ6XhN6IOIvvdxv391uoXYbYqRWvzxBqiYmqNZ1PT89/9RnP/OFz7+47PdJ2TJtiFkFrWlpeFk3Y+kMrj57HTvBNrsoZFcL1Qzf5Oge6BLF39Vhu2NJ4l8IHBiYqFGN3y7Iu+nxUMUdEqovZdMRA1TaiDG3sZ0BNULsHK2xEpTUze6UrJu8KlTX/WH/nve/+xOf+MTx1V0tRYplDguntq2h4bRvZHDauCyxTOpZ3OYUMF4SkbLWWhVEIlb1OGocFanrgYk+8JH3/+Iv/sLVk5OUbdlVk4hU1jbfJttpoJ+ubdB+2YAk7b93ZWt/R6ZL+3mZeYDxy5s7dZQfvwxYow9ijIuwoK9BBm6Gq0FOqhrN9aCliqhywve+94N/9T//TyBaiQ7rgaDzNIVUtXvIdgYN/McgxZOduc1k0KYedTXgnM1GG21q4yMapT/UvUOx5GEl6XAHaGvxMcLE0a4zGaHNhb5ROsE/IXvQl9huYofQ3B5B0rIlEYa9wgJ9SdVykGtdEugXfvrnnnvmuaNdnqcpJ+bkOUgOLCg83saDwxJ3aKHDTIMVQs0r57Tfn6tY8rL13FRVEaCigmopcuvmIz//sz//nnc/D0KRQkIzp5ySFU7V7g7wQz+E12BjE7zNK7awv7Z6oRlPf8v3N9f7t3QQuSNBbC90qRVuH+on7RiWsz/fcqEsRD8xK7A7OqpS/uxTn37pW99hKCMRUhULneP+oEszaG4ajYGAoJ6svh2zDpauht/tgRV1Ia1B551r4759GX2Fm1VhD+XtOndwFXNvCnaAXtR0DuIMW7sIae1JAZgrLc4gumJsA1IlVSumRUgpKXhZ18ffcee3//Fv37p9q8haVilFkZTgOAjx+G6sjCcPbyM4m86HgKClFChElZnti7VWqDBSFREpF4fl6efu/Mbf/83rt65PbG2WWa1UqPf8dq/YEBz3kGPYh76oya1YdF+x4NphSg95PTC19u23s8g3F44CMXRHe3YA8z4E+19M+iigRaUKcz6U+vt/8HtnZ2fzyZFIqbWQN9HiSHF1JNPIL9YpNpCA0QjubswOKIYVgf/na9DAS5+Mf1cRPtNh4l04tRm2VevKov+jrZa589ozXAb7nWW4QUiUzdoPGAXazXAiRLtphRORVAWJ1jpR/sgHPvzCu98DQpVKKnWxIp7sMv+Suo7VC/V+CSV2BxVgR0FcRUpdmUjUqp0pCCJWl0mJsVycHc6XD37oJ37uZ37h5MqJNTInL9ikTOw9Q5pI6Yq6LXNf2AdfTasHBbolNqCgjWl66bvazggvvf42q+HBQWxlhW5WtN2PQPCzUYUqEtZSEmHO82c++ZmvfPUr5bDOU5qnHadUrQunRx02F0Zj3GZzOxmaylDVMcypfaPReox04ItWh8sHutn24Jb2o8ntUUsPrma/0OPf7IYOOPxT6n/in00TUPi/girDDwsP6+/BQQSFnQ2wVRYippR4sgIviUmlXFwsN29e+8Vf/KXjqyeJFSDOtgEyjHsA4dsd1MbX8bs2r5Uvt6xlGaSJVi+WKIDkKSXKRWpZD3nH/+Sf/KP3vvBCPs5VBImJAQglx3hDKkxXj514Bm26kc0P0m7T0JtNHWcS84o7PYQzHvLvh71oGBa1R2/oAY1ULWCAfQOtiIOStdrWl374yv/nf/p/nZ2eUZpXPUBVe7iwRsWoCLh0go9Rqpu7rIoQ/gM6GZawhb6FGh8cbNruBx0xTIeosc2NFcLb5hvTZSPaiaJ9kUJCUeyGxgDQTQO7ZnMIgzhFbpeRBZ4NmwDnJ2cSAlWtFjwKFCJ+/j3ved8L79sdH2VOOWWCs2cc3MdtNktFo/oCyOOZLIbchRiIeLlYDvu9ayQxIAQI25gtRYZTEpWbN2781m/8w0dvP8asEyUbL6qSEidrt7Yh3o0MDgE0oIlLmmtYtQeF9yUaH7T2oN3wkLv97a+Qxf6zieaRVASwmDOBAipWNovsWJKURJHmRMAn//Kv/vIzn61QVBCRFV/uDpMYZDte0DbVANdR5FO9zVcn1C6Yx6kPQi50KAUdh5xwWRj5eiGDKBRP86K0RdRLj0C7+bBqWy/1oLJoeGMI25Wm6JwfQ2mRWuqJqkjVoiq1FqlFFSwstQqV3TT/zE9//MrJ8VpWESVKlLqUaqds/UezTEJcuA4mD1qg+EVVzi/OylpUNZorK6kqqnibEWEiZpKlLof9e3/ifT/z8z97+/YtUJ2nCaBoRNnXpEmDjRiPU8Dwk/0thu3lF21/6Ss8yKjY6P9jr0sA0cF5k7tt3dDOdXwNxWvqSVWRUkVlt5vP94d/+a//l7N7Z2meKVHOrLC6CkMXY0TUZh+6wsB1OwcI/7qNoWnP7mCMIwY4BLGizD7YbhoNa+wxbU3ux/TowWV7qFyKJWj/fBB2UifJxgJEal3X2xmjL3qFR7n6BeLaxZ2jloWxyiKQ5WKd8vSBD/zE4489xplVa7MYolC1Onpuyo62w2r29kaGOL/sL/brupqyhkKtCJaqkIgFB0EVqFqXtRzPR3/v43/vg+/9iRW6lDVbHyuFiicv98k3B2kvlNREdpO7WyYYj+6GY5og+QCiNK5zW9KHwfa/66WXf/eR6kbYxeo2gQUQsQVQ2Pl8LQLFlKYvf/FrL774oqzrBCIwI4mgZVoP/KbauKI/U3kjF2iYI7VvBhSKP6RqJT4bMWylT7sNEcDKHeHocEFTJyFWrIVYqCEds0liIca5AJ1DurwjmEnZB2PK3xZR1HJrSISg3BSPQJLlg4GJWKVWyPHR7j3Pv3ueMlMS6bENG7YyDtdQZuHX8hSfQTH4UEShOCwXOeVaKkRrrVphoTFe8ZIoIdn3pZSllCcee+QTP/uJZ5991srK5TSBmZIfzhgqcwTrWq5HhQclP4hv3xbB0MhUG2XQKOP/sEp56GsgG+okgcjDdu9di8JXqBJRpkxESy1F6tFxrpB/87/+y/OLc867okW1zDnbfUK2B4M79TcHlBUlCOS6XYwm2mj80P6IDaibs4QBAIz/wSriOriTljrYwDdiSOq1cz09WOFtpPz+AeZtADUQrXoCryhUev0Fpz8DHBEwYapQPUCa4oRYU/g/quERJuLEtS6Z6Z3vfOd0NBPRlFLyo0DjA/Hopj77rXbXMHTUNqKDJoDKUpeyMFOVqtoKcSgQEwJEKgEp03LY16LvfeGFX/zZX3jyqcehWotApNnk8J6TfnpFbyOUL+Pby7TbsOtlJfE2lKsPuZge+OVvv8V47WWWRQg4pxpymvBa3iSaKKWcofTXL37pLz/1mcN6PqU85UmgFeJrq0Nggz5QzU7BgdvjsRY+06G+PTt+75I7VtQyBSyhk9qEvM2qmtBrDw6Rb1wo7k8bgswRVDuwoobxZgJbnAktfML1ioQw8xDRNpJwj2gXMHDXgNXCC4BASDCYI8qcSInn6Zmnnrt984Z13giQ4XLLq1+HyG8isZ9Mt4MhicX1imF6enZ27/S+jUhEaxUFYp1EVS35OeVElMu6lPUiz9Pf+5mPP//Ce3fHMxFyztbkoMertpz7DjG34j7OxIcVGRTlRu9vP3kI6QIDdOqfDPdsH7/d9/v+NmUaSxuwq6lTqEJIrWmjqJUU4LLWi4u9Sr17dv93//Xv/uD7r6R5riJqOVA2S1tQkcgzQaM/oykO2nZhi+7C73Al9jiaVHgdwrjExHdAIgm2U5d+GnJTOojynVKwU+1mcA9bdvUqFdQutJt0pourVAXiRwRdzqCZ+QIVq0bmhKCOmYNdVSy0SuTateuPPPqo0RdH6wFq+q2RPJrY7aIiTFVP9Ba10hqikFLr915+KaXJHyO9ToBClKIYkkitK0iRWGq9fuX6Rz/4kZu3b+aJpFRKnHrN7MbcFMS5XTzEmXHX2yNFPlSMv+3r4YQ9+JgGc/FhO9lV5uj4gwt37Rq0L7NXik1WahwAGMpSRaaciegLX/7yH/+7/3B2/z4TQ2G5sj5b1fas0YKz53KPGxNV9bi6NtAYGaEhpSBYZ4zBzxYerEGH9aCkB/Yk0B40UlpGKdQourNDlMlVkIItzUw90uryBm2G34iiv8tKZIfEAS8BIVXyXjgg1SrlaLd713PPpcxkbV2CY7v6A4J/ux5wIRYSt0mSNuVlKYeLfVlWQKsIEfvim7oWT70QFQZNecqUSllU12ff+fQv/+Iv3rh+E4QpZyhRbqPpf186E47ArMuyom/v5vpLRPtQcTR+tPHp/e0XXnozWEUl4jcDH2uvI9HNYeeGKrVqNacBgZWZOC3L8kd/8u9f/dGPp2letNRStGp0PyG1OibuU6dgCFIFjzZsLBf1x/ouawO6XhLLXQ2dz4O9wvnkGkWD8s3mQNdwiL7a1CN+uo8F4aLtjBO2gSVlDh4PF/Y9WEIH5dBRV98LgkZefts6k8BNF1MCKe+Oj1544f3H84mUytaGu5Wq85VCPFDHh/UFbQtHUFVKJFKXpbz6+o8pcS2V/TZ9i3ufWesnar08oOsqTz7+5E988CPPPP30tJuLVKhoBdz5SxRFEh4Aug8jUBr/evDn5eu2r44mh3f+ltflT5vH3NYn5N8gJduhEnWKinWMwF5WItRSlTTl9O3vvfzJT35ylRUAgaodHTn9ayTp+uANq8DdoBrukEvo26cfvvxwITjO3UQmWgJkdzJ0tORykYcmX6xWiKVBRjP1RSns3A4lQ0s0vTBAsn5Ba54Rh8c+0IFz/XrHXKLuFYW2BSIKjUhW0RY883PPPHvtxtX5KEesRayNQiNct71J4yLFAKOrlHWGZwKJyN03765rsbcdBoQshEKrVUyplusKgQK1FiS6efPKc+989uTKLll5ex48agihc/k16tQHKfrvxjzjK+7ejyxj6n/LayNi+626jFftdOjySoNcGyRql9jTRKBAWWtZqxWT/fd//O9ffumH03SkrGw7YxglOm+oWOspl/CIaiUb3B0f+q99K7Vhsu18XJwHlGyiuG1KDyxtU2vCMrRDS+SRsI8BgII3SWVYsDAx1FzoCHPf2juFI0WjvJB/qQWjSxg8TTq4QLfsClNW1uoJJ7vjZ+/cSSlJm4G2PR3lwojER7WjiohUYsegIvrmm6/nPEkRDmjmmjZcTAJz2MYTCMxc15J5eubOc6KglCgMeVvRxpvtHVfEGoQULlvtQ+1Iru3/ZTp94NXWbPijQTgPA/4P8OQlNRlE0sHzdiCbNzWuB0FVmKGq67Jqle/94JVPfvLPz0/vJoliDSkPDkOrI+xa25aHN8AlZBiZvo6DERtEGH/UGKFdEI0hHT/FlEjVwr+6a8SRgP3kHstI7VFEDb00LaludpAjd/TzXrdNXAyLXxnrRw2MQYHAmthsli2+04ZGP0qA2NrKy/PvfcF6NZP3RPbBBV5rBy5NL12WtgSvb2LMS8C6LOu6pMkSIyVcFAjdonFjX5tEnHIqtXDGtetXnn76SSaLJ01mmSC4LYSoGeJwfWqjatvWB3cpe7aP+f+v1wO0PvjU2zX6oH6IVRqH4967rs/G07xGVdQf04ZghQyZcf/evT/83X95cX6heVq1kAp78e1xk5uiETLRRI2UA1yolTuP8UMDaQMQ88gGX4UXy01gd6MoVM1qtON/1zJqVSAhVpHXCvlodwo1VEPUZFTTR96ng3wwGltstWPhuqMpVKdzV0jduIJGWNsGTtlsPd5YiFPKaRKR45OTd73j3Tllmzua6Q9tIqDJGLSHDAQSQLY5BpVAy7KmZA0HFXZcOLCAEbBnUnnFD03+dX726WefeurZlDKsvFxbtOGXwMqDqN8SLg0aeCDLB8j3wVeLRbz8wduALBp/pf7FLZC1O2vPLdlGfG1W1G0ABIsnMIA8T6r40je+8+IXXiRUVmZK6hU4PT7UAQmAsNu43bXRGQjMHvgyqgDE97RtDnl3l2FxTPa0OAkoosxl1z3wRpMAvASaz7MpoF5kE2SkH9q7GUVBLerVrRuK0+6U0DamRgcD5Gwj7qtLNmDyrBoVpYkfffT2tetXCFrdQRpfbhFuemnTB1Kg/iEx/PyQcbG/0CrEVHszmHCqBWptyG0ta62liDcmOr565dFbt73biDugAncGtbiSHHdmEPADaekw5IeS/ihrm0J+KFvpZuqbt10CinXybEvYdFEcn4y8AA+A7CXTm84O74v7URQiRWotTFxk/cN/+3s/fOXHR9eu1FrWZYXWROQN372+oMNKgnI7HmkQhgeK3sC6WDqKcsYcdB0WRZNzHJ29wCYhzeImir5fgEoiIoXXQlQlIMH7EXiejisi7VrbOiZ1QRJbopXGk7HmfB1VbBM3MRtunqAYYYjGZlQIKW5eu/3Io48pkK3ZQNupsIQdYWpQHvrzyFGI75eIgsm+tJSl1hqLbI7/2G8/PaiiVbW6xhNZ16UspSyrauXW1zw8DKHZWgDeSIZd8o7gXcNcenu5T8NvW2H8sFen0cAHUQuoy41L6iO2ull3kUbaEEaHPu0R/Xcn5URVlKFT2n3jq9/6yle/UvaHPDEzT9MsDMPpzBz60afSa3VpyGftXNZWclR6ttuwyuYAa/tjJQ1BAlJ4kXKrch6WIMGCKpWIUjtLJbBXxxrKhIKIOAFElBwDMsWEWUMTwXCL+XRCn2rDQDysePdbBF9TOx7qsJIAIg/KUGBdCyV+6s6dRITkPcBTSsyhtmJrus4JFEejDiLfbKkC4rqW9bBa4Gf3dGnTVsNeqEvOUlfmBKb9Yf/m3beWdVXVUqsfJPcY0TE58SHUOo55S4sPSu+3fT3sUrr0/rDkrpc7lQdEUEVAvAGcb5+iAXcDDys5qo8NNxIis9Lwozde/71/9S/v3z3N05FSVRUtspRllVVULP7NaEc1OqvHqx34B3Dt2i7yAuA4xFrzQkntBCn6+7p1qGBl1gQhVJAyicnoqJmsQFW2m1DUP1PKnJnYAoOauz0RM7NVXDT/TKtLDY0ayjoKjVjEdiStjZos/9ZRXyx5s2BMCPsKEVEtNed8+/YjarUNdQAc4cBBCJXm+R1kpetvaYqCCKoicrE/9yZUESUVNzV3g6eDOAugwhlKynK4e/eNdVnynBIzeQ9io4zm+h2Ov0bcjYHFcAnKjNzyd1kCHb5s3g1cOt475LheujIIZVRATTwPyiaEQNw2zLi2saLW5FHLWiizqn7ui1/+/Of/SqHVergQWMl6qwcbegWJLF79wZ5E0OgX1rx7l7UVwyraePsWECjFoRUTccoIFCQW3c7W2lpySmMGgjORS2wNPxOxKuVkIt/UvLoTs5J11PMzhFgfgFS52U8E60jTBG+wcAs7YnCEcoQTSRXiSoCYCAkMqgIrlvj0nTvzNB9QTFz10wbXSA+IRH/fR0je4UYBZSYWWpZFSgXY8iDhBhdYVRne8pJYCKqe/yWo61IAnnfz2fn5NOVSK6BEDFWxtuAabAIHYOENeGBY1FkXD6Hlt9UG7RuDs214KDZDcKrZ3pIiTlH7tWwHSW6a9sOU6I4TNw7KNPXh8JKUmFmZZa0idZ7z6dnFH/yb3/vwRz52/daNWtZEhEQW/tLWwNiMTew1OaXhdVFrQ+Tyuc2ttZJ2K0jUxQAAIGlJREFUfM+eH6VSaymrZaxmZnNxQFFrraVqlcRG+saGGvibEpHVt4ZCqlgQmJF5Imv4RSrRjBUh2AArOhSCgayUvxq99aG1UuwU/Tu8Iry7jcSNCiuQYg1phGDca13M8pSffPzO0dHRJWE5aIFYP/s1hFYzaX3X1XYURFSkHtY1Ja5SqxT/oqi3dTUxg+gXYp8SVCVlVKmZeZpzrJr1SlBtTkK3KXnQAiFXqX/s8qZR5yU6RddozUHYYV/ID6eGy8rvMtOEHuqHRAAGY9wBUthDMsSGuIpoCxw2qT/d0VAAGSaGEFX9m6989W9e/FJdlqQKJUai1BxlAUgV2eRv42IK/kJY7hGQbQJMbLZKarXK4IEcspYVisqsKkyJqLJSKeWw31tR2GmaU04NEFvvdBfCIoA3k2JOux1Snsy4gxdI9sUwjmjj7EC7ebnt5inc9dYNI2Sdm9/K6g6lcLgqAO89ya54QKqUskmmk5OTq9dO7t07pTgG0UbqLsRG35N2QvGWtBQ8oCpatKaU9ufnxiI2KsuOsQruAEhZLf7PV0mZqEoB+Pz09GiatJZ1WVPiqB0oJp+CyNT+p/7oxrkDYTpvhohtex9UGTbNAFJM5KJZz+SqePvdS6+uHi5hq34KEJfZvYdgy0ac/R5NAbsbjECcACQ5lDKldHTl6Pzi8Nm/+POPfeJj83y8Hi4yJKdcqwR4cE9bFpFEPt2BzxWAqEhVIg87UoBgfX4sbICIzDgrRHYaoSpSSiFSEZGqIlXhvfRKXWstpRaTjQRKnCgRE4sIMWkVEOUJayllrVUqIvFVqogIJyLx6CJy6Nsyr/q6MxFp4OktkGNOAETIucFrWDiY8RMMgqKSUK2VszWxuZinfOP69Zdf/rEKOBExeVPXsB/6Tru4Ruj0ULhERBAVJtIqaymH9aBVmbhKJUHV6kpAGntVVS8pD9JaiqjmqsvF4Yknnvzm1795fn5Yl5ISg1kEHgvUJZoGkQzL0+UFutxrdsE4kQeIuL+/xewPgKAH0VCn5Ebul5mljYqGDWvfComiPc+rhSAilIZo1PnhnET0zz71F//wpX/6/LvfZcpivywKaW00bADZjyZDFjY55jfV2GV7ywm9TYQUUM88UFi2rQqxpet57qbZ2qye6uqQBmodhFcLbyM770VZy24nxMnqlKyiCmOk0MVG+t4f02aD9gsAZg4t3zVjXFDImg0nK5Fot/NGfCBPO1KlqqJKyiqQWnQ+3j3z3LNf+8a36lLVHS4mVBsguHQGql6MFCGOiYiUiWspmdK6rBcXewkdYjkxpBDxpCBTuRUl1IvUUphx/96ba7n44Aff/+IXvni2Xy7O9jbfpKyet6kEkgHfNwU5EGocv4xQ/e2JfkOLNuEHL33Il2n42R4RUuGB69vJ2MNUSOjSzrRDVL2oNQ5T1ZymdRUqhZjfvPvWn/7p//bUU0+meTosh5wSEqvloYq3rsgEct+EBpEQtwJMbhm0hJOAHxv3oXhADnnQEZF7S5iYySs2QqoqgcPRbvGs1jkUamfPnDilzKJgacFL2pJ6RE0gMiAkTBoKayhZpYCHgvtsYPTtcpGsKnSFwp3ClIiUOTMh58yZSaGsrB58BAUzROnWrVuiktj8alGLlQMKNEk30lEnQXUmIWEiUqqlnJ2fqSiJ2G1VPbyL4nSnqtppl+HrUmtZyltv3t3tjk6OTp555pnDQV5df7QeqjKHQhsYvov81jp9GNbWPv47SP+SZgit54t++ZKHv/oOuQtB+5fjDvTAV3pKRxPEHX0BaL44NSytVVLiUmlmXpf66U99+iMf/uhHP/4x4qpKCVyxqsQYVLKZ1ebZh7etrYGoyWUSnAdshbu/PeBvjFNit9gbnIHtWACG5VWqIk4ciIiT8YhAtRJz4kQKiOR5UkElMTgDsDoTQlTctPXE5yYH1HMgqpOQF0wlWddVRc1FZeE8PjcQyGqQCIGWdRFRqHBKpGTe3ZQ4KSHla1evzDPvL7yPeLgjgrSaBQoTkAGVyS0GE5lW2laqrqUs60FEpinhUAEwW1pdlWJ1MwhQ6yJTpCyHfam1Stmfnh3OznZXr9y+dfv0znkth1dfe71oVYFF1/mG2kD8sKID25C9FFHx0Ea7D5DwhmVC9I7YaZz036lBfDF67gTCkeT+AeMqGpliQLd6SenQ5veYL9vJOhHlOa9Vv/+DH3zpi1964X3vOz7e7fcL8ayiFcICYojU7KQZto36bm7hoc2Nm1DFxsyrSMkqPrWDKhicIFI7a/bIOhtpr1pBoQkVIfShmHKqIkW0oWfjTkNldhgEpZbPGG1ItdVIcEHP4nKZwcnLAKvIanMK481XX7yJCxTEVmlGhKAiTADlupaUMqRMUyqLFbVVO5jY7Ic2UjGZ1a1sFTV/gEhNnM5PzzlxWYtaEfdoosdmQlUppRRZluVwdn52sb+42J8f9of9fi8q9KO8XFw8+djjF6cXa61vvXW/inlxKTMLabR4dq95DFF8C3wHHwQyGyruNBaNw3Ukw0tfDkg1EC3gfszxfoPGCDDdHJ/NK+EgbesVtV0LZ1ubRLu7b6nZ6MuhpCkdSv3MZz/793/7N47yY0tZQMQEVa1SjWwyJ1YJEUZNpNqEWUWMJkApqFaDiE2wV+/PIiAmCfPLrT2gCUsDzNQYn+xLApCQU2EVmaZsgpw4goPVmoqZR5yUWui0abK+oBEo4W+rqkfaCFSK+1vco0acuNXQs0kRYKVqzdMlUM8TVhRFzjklFhVS1ubTHGRT23j7O4Sjaic0FQWnRFXm3VxV18OSWPf7fWZe6orihnVZ1v35/uz8/P7Z/cP+4uLi/LAclmURElbOOSutFTLn/OQTj+52+WJ/uLjYp8ScSKRa/CP5mQqkdu92U9+N1LVp0ZBdth6d1GLHQrjZhg63cCp1jdC+1LHVBun0VxNBzZrqRN/u4QAnPFIPgLHGpoZEoARBnqd1KUyo0G9861uf/uSn/sk/+S+zTqgiKsrWrKGkRFlEidhTUhyuA1AlMJSJlbRKDSJWdjeQRc1DJZyhlidFSOys2AUy4vAN1hgURp5eFjnwtLia4GmXo3h12OB2L1X0sGJVdGGAriF9S3wiHaaRQBqxMltNSAlHuCcuJ7NujDVZVdVwloocn5zMaSaQ1KhQazvYY/lcWjXZNmyQBnqAVJmmTODbt24dyjInXqVUpcPFQdb1Yr/fn+3Pzk73F/vDfr/Kuq6Laq21VlQI3P+ElDhp1Snvrl29/sjN22/izVJrqSpVrTmIpmT9MweDIMitD08vvxXLGeQ4InENpWITUkSYcL/BA1RpnwV70ObDt4VMGy2xIf34JBZ087LriElEEoNzKku5f//+n/3nP/25n/uFmzdu7MtFlZVTUqkiJaddzlMirWupggqBW8HEChVdDXIQAyIGa8SdRQpSCEQqIMyW1QoimF1rtjnaAajPVkSoMzlZu1CjIVeWVWvynEPTSw42hhlTWOgR0eBnIX0HYNqAorOQCxZz7hu3Ctj8RQobMxTayvmYsLPHJosxSczzUU6JiigzRCxclDpgVAxykSgCNTsRAO4pVjo6ytO8I6Gzi4uz/Zms9ez8/nJxcXp2tl4sh8Oh1lLWWlFVJSVSVU5MClGsh4U5q+gqEFlzTk8+/ThPdHp6fnp67nCRVWolpE5njdooTDx186Sd5g3UF8bDg1TZiXAU1fSwC0fSNFn4EMI1dYXgm4HrTMfqg4S+0SkjO9pHSiIVoFIkMZdE3/jGN777re/e+OmPFKllKWn3/yvs2nYkOY7rOZHZl9nZi0hJhPVqv0iWaBh6tv0VBuwPtiHJNiBYBgRYhi+iSEokRVLc28x0VcbxQ0RkVe+u5SaW2ztTXV2VFZcTJy5JapixNeuRZW0NzRoIdw4fw4cgSkGUKMoZtFWZkFmnHoUJpBkiL+vzatis8nceW2JNhiJq/ggTZWyRmAp/EndxOB7WywKiWQ/vwaqHazHILdjKtC6YcUuE2iW95ZoxD2A4ldYM3Jg4C9NEQhrRjCUOF4waTpe7nj158vTptz777ZfyTF9vcGAC2GnqA+XV88xnFDSNGVzn4+Hh5evPvvjk9YvXz18+Xy4P96/u4LmT6ljzLhptuJYx6MVcQEb68GVcfGj4MPSTHZ49fnI+nH3VNy+f+3A2awazLPhyr816MBOn0/hPP/BW9Hn9s12Jwrul/I+83nn0Fu/ufdRbbkFbQu8drzKgeYQKRxng62qHBuLFy/uf/OQf/vT7fwZXt3awnhbX1AE+PDwUPUKSx35A9K96zl7SrHwM6B9PvlmzXcrFhJi2kJLRAjLJ3ek026L/wnOlD5Tkw3M/IjM4fBkMVU4NUlKbnuXzqiAU2dzslZlKcl8JnTRVdtp+I9d1mHGCl3SdyFQDKphP1FvzHB7fPgLJzC3P7El5p02wNrO1YY2MqggJhnWsX3711f1yd/fy5au7V7FdvBngNCHiE5drDFHN5O6rj8zyJgFL0NhiqNc4nw926M/Gk/v14eH+Ys0isM7ECdMoENGOPeU/OSMlrbELN+ff15k1FomZNMa7ZHKqFvdTdjiFJ978X4FB+okrIak3V5+aWG13GeHeaIaIAFf21pZ1+dlP//Fv//7vHj95ev/quXnrjcIgen/x/BvQY+JuoL35HBUb2GbSIEXJuMHwuCBBYx0VCTL2VoyDfR15GzlpIpCL04xAKRBX97EMGvvhYLR1icwaAnhIAbQwsVPuGlI0P7lZ/ABg1myzKQXyFR5EcKLT4AVSCIsIJFQxd7iR0xwraJDIJsfheIoiJZdHwIydvG+V/8CEukUVBj3hUMt/007H48PD3cP93bhcBO/oUXMy5OsSHyNJwbV6GhMNhN8McB/PrSagnfrx0fn28fnlWNZYi0aLVAs5c537IFXzglEIPY57h1CivNvMymKnRxVraC/k20H/z2sXIHCLiOti4zQ7o6Ir8KWrw1Jj49YgH6MfDo383e++/P1nv//gO9+9f4llrFFh7O79k08+7Z2NB1E+XACrqDAiW9tbhVxKEcgRXKAQ+/xsRzSzodwDPY5hFewSiPpQIHj6jKEFuqv3njdIE2SpboyyvBluWc/0xcxXbEA7+nWsobQzGlAIG+6WHcpRRRy7RMJggNxHSKv7gIGCW2ZUDRTa6XQDGYHhQ6AcIYmoJd+9EvPMJxp/Qtzc/di7NF49vDgdmvsCG80aXdIIbrdoccRXRTwRaiMEz6Hk3YRGAx00Nj6+vVnee8+B+/vLkD88LO6yDmsNvkl+QrKSz73QbVZ1fz8zstnFzW+8RcKPTd7377cPqIz8hk7zC4v2qCCzTliHaH+iuvoNyIXCFKiAQDMbq9Z1bccms3/+l59+/0ffP9/crGNtrV/Gg8m6MIBTzGXNRJIPkMGSxjQ/zpAEyP5EAETW0gjWbN5uHJ4bOJCxrxNjQ7gCJCm+E2hkMazcV4DuaoHKFcHpBiYU9M66hrXSZhdi8VQeYBsUWMtMwpzBu45mjSC4zpuTx1htCk4iGxtMglZ3dwyNh/Uud3IlKu7ela7MB649IbgJm9Gg3L+Exm++/urJ41t2dLbYLj4NEOZgyWj5i4grUuv7GDH2LtOI9JnW6IK9OZ+ePX7q/vz+4cEAGExpEtNrRwF89LZtGZ8ZoL0BwitwqpvbjtskMQ0z8pm+HVK8Kbh/9LUX9EyjTMoZ8/avDp3mNZ+KQxCssTU6pNV58V/8279++dVX33n63su7Fz6kIQn9/WfvRxLdS4E1y1CFWnQkopJImJlLUbpcSddY3GsmOOY5ukcu+VjWXVX/iKnvJIDWmruP4b01CWMdKJItKH8jXd5bh8oEM7MJU0PjAWybGYXauIjIZMDd1zHcWuvdaCJNjFmcWycVAYO72BJ0DXEsi4PLGGwcQ8rZwhUGhU3YGLu9ZJReCJAz9gjzcXf3uht6A+kEhlPQiJxHGduYQlEFdnOFGcN5I8yxiHVoWIfTja339ujmxjV8jHV1ZpdSikjBi8LYV0nNvIudF6hfEOnMNzF8Q8jLDv3frySd9n7jLS250sDKk25eJW3v/mMlbZU1C0waRW7RYUHJTb/+6OOP//s33/7x+zCuvgowoNuhjyXWKDlvMwTvFl8leZASrfWM4YBOqkuQhgILmVmC4jQBpKE3kyLRJlXheqjpnrfX6hFLyNVIo1kjeotbiz4tgpI35jXEp0f2dqUXJyuoGCPXj4zec5BjDMGNrZn1blnGIzkpeFGiKQJOz4xRM7gRWtbl/uFuI85DhLgrKdsyAGUr41xbPBAFDyNqZtfLghtd1gsk0d1pMES7T0ppdNG7hqjQhKR1gxVIa1c1rG7AKiOf3D4ZQ6/uXruDja3bug55PN9N6nZQXVNL561xClf82R7XW6+dHL/lQK5ftWh8U86JXZogUkUJI+NCWdf7jtB5W22l9kJZfwZSQx574b18+fqffvaTH334574OuVozwHpvpxjPIyr8fkRK7u5Vymk0O2xRrCvoulgqdrN08VvHGWLOcfQQIrQB0Spv2IjnUl6rhW4g6B4Fpgl5iQnEjMaQCWALLeqxaZphYCMSzGy4S4NAby0UeF0d8KSHokkAcPeWc39osDFbDwCKh3bwZemGy7Iam7toEWvlcTmOmHPn0vwrVLeQr5vRFevcljEa2vALjXIMi5IrZWifnhxQ5C9iE6Ws7xCwBYOEWSOgjpN1rbo5n86X08P9w7J4VOtesy6l6ilp6fyuotr5fEJ5wy2Ecupaznf6/rb0v6ESu1KHzY5Plmn70u2bZ9WtKvEobvnmaXuK0gvtyUwljOZRDdkwxvjVr/79+TcvDufj8PvmHa4e9V5jDMXYG2kdMY9SjdZ6V84n8JRjgm5sqQnKQWxC2tvQ15BOgczigpBzxpbUQcdwU/O695TxJgiYXghETgogoqSNtQrpwRkBhKLPprIWsbIjNtk0M5TAWiOQ1XqV5Y/eMJdb1iqV283F9tYPj25u5YADEVYSgIGObWzFzlZiI3zrMcfFyhogrsN9hNNs8PpkqXSwUhGbJekT1igBYylGxvmMyhGLzecNh1M/HY8gnJ6bg1RL3U5mt/PUzzZUNAGN9oI8xWyqxBviPnO9E4DupBXbj/enrrjnLeOuQL+KB/KmosTbCvFqjWeDDrLPCjFc0tUO9vGnv/3o1//zwx99+Hpde2/rWHs2IuVuOwowoxg7Jo3VSUYgMKJS0iwssheUT+4kicvA4V4e1JtZuuv0ciDbnrshWcSjaNHBaIVPLYEuBMAj7kurHdiu4LanUsWKVyRGztUn3D3+Ge1irD5dFW6sh+IC6FS1l4zYc8fsfPNIqIuMj1jEzDNiqjNqyjL3IjSRdMJ6D0OQH8iMosLix/iZVmO+A9dqk6qExmn6BPoYQCNNDVoVSfRobM3Lyso9Vfgw+YwKcyvknKhGuz/xclTScSKfkvhN7ivHfCXldanvAErbQ37XS5tzmjJTyrCPuifQrKuCIJnZGG6AGe/u7z795Dc//PDD1kgJ7n2MNbt1MzZx327aAY6xVU8ToU6i0ZUTEQXFzmUho3QyO0tgO0FHGcdyaCEnIpgTcSBIzfo0QPliPcds/vdW7iNFI8w8GLypFcs0F4OkGEMEFd22mUHQJGpywsb2vSXLvgxmk6Td3jxqZj4CT3C4N0Xh5TSJaT23AkhOoCIltwY2tMyIJY8U8+yjzHt7oFFNC+Y4Pot5FZjDnbLmJO7XODzaLb2xr0OXZU2ZJn1sVWX1l3a4+QpPlCjtpC8welji7YkqAfPeBldFsbbYB7u4Y5r/vU8Ar79y9+P8yp22zavfWjCm/u0ULp/tjHbMONwf7i9f/+Gb20eP7u5ewTTW0StFFffHEGPBI46mWXA+ZZVC/6QSlYgVNt5nY16A8OOhOWaQB6YHanwip8cqeKdIL+RK0nJwnWcvzQBiar7JMykcJRWFYwiIZgStzdR/AJqYvCISLeAymf2GImpIauTCsxIpKzuMlrMJHt3enE7n1e9IG2PZNAhJCtWtazN22j+fzFJ32vl0JtizpUEgMBKoBP6EIA5kCZNZJKlijk18C6O6We4j2psMtoxFrtX0+u71clkeLhd32aGZpAATOS4ctfzX5n2WQqXNDdyBshN5sM14a/7mLb0pWdhZv6sX3/HurQOm1r7xq6kwu7hjR+QGVCuIHI/FB1qXQ5988pveejMOd63e4+GYUW6iLJlUc4qecZNqDcLy7FCXQMFgMvcxNU5vLEg2ElisaG7+ZcnoJQGxLbMjwElMTQwjE4lGyzrNxAxblr08YFmjMP9V2QYw9Gq4owcAn4MFE5hN1otAzNkRczaESGv9QMOjm0e98XTq64ph1BqIbq5F/G/yyZsJYk6Dg9EbaWa3t7c353PAtuHe3BR0PlD+cCI6UO55Q2VSAndqjQV0d/fVjO4a0HJ39+rFy1ev7wJVEgaLJPKctxurwitdnca0zOaG1wtIBu+1sZITH5U9fPPnUxbqVt6WdM1qxt1nub3dDptCv7+AXSZmjxoSNqW5iEVG89U/+/zzl6+fH4/Hy6vXQ+pQZGQF7v4LQ8EBlj1DCkpKSVYW5Mzx8mm7jDmSyspcceLf3SrHV0I1NTxju+nbgzidmVYQtRmQtAHbcDDTZWwHsOpJUTOoc0MY0n0MrKFYIQXWbA7MDaPrAs0CmDVr1mwd7hqPHz+5//pro6jUaDMgY5UknIM2ynYsUyZzGOQqM5w4no7Hg3yVYAjcPzcIqs1r544dYdGiRSEQfOwYIEeOKo4GjN5b1+C6+P3dQ7DSGnIMVZ1inKdidhpMs2K6JEgq+Z0asBnxPVG0i8ZLOCOICPWvYKykd5POKwWYiYm3f3+Vc0jWY1O0wp3aPqIJ2BjePvAoDXIbq7Pz89998cWnv3/2wVMHNLwnF2KQz4yIaNY0G4GLEdnnrpmjqkBkcQos+L4yB5YBQI0/KfpHHuUPyPHoqSupP6wl5BwR2ZhN7qmKxoxSdrxe1G9nlT+SiS2kQAhmLfveEAJRooBsWi5fUcFoQO2CSIQ1w9Pbp6eb08Pnl3VRC0o2x2QFBAJlsAQw5TOtNQPQITg1BKEZh8YYg8zy1WaGWgSU185YMuSKGWSMnW1VYUhADWZs3pqGHtblYVnNjObDne6F4utZg5nRTzpgE/SrYHSTdUCQqZZzmrCURtYPd3I+4fsOB3J3uu3su89cPVVun8xfogxtGT5tniERkyDIYGn/IuiKEjBrvoxXd/c//8XP//pv/mpZlmUsXYF/pjhwKkFUhELx+Tyi1KyyTkxxMViM3NnMfOFGMdm6pDtq+K5NShjX9YZZfQMyAHgZgohBzKJh3VAzwxIdKOqY0wDU+jN5+ZiVQAx4i0xxGlgKGFKkMcyaWQurQeJAC7ofWNfFj4fD4/O5w1wrBTNDC2yTDTuh50aLRHVitzEcUZwEubNHdteXy30zmiH759KcMFndHbDAJltlPizYzsQvBhNdWDmo4WO9+FikGLjkSNsEBSWquE6vko3pEkIvKpFxJZgAJnVVDr6A0cR/vDoc2BzY1YtTVOfR13oyz8TdqYSdbiQeL/C06Ug9A2YKxX0YjWIzjmU14tXLF7/+r//8yx//xbkdWU3xYOLU5JWVrLPnCaXCKUhDnu4o/z3fQajhU6rB1rkxUH4adfpQVNbtQIXFq39PyWBsu75UZ3EREluVEOcppWhsyO8KPmoqS54zMymhPc0i6wuFwiUTI9RxTnEZ7uNbT56899571m3cSw6aWqdAj8LZSCU3i0ISI8wYvVnUcKg344Gn4/F8Pp2PByMhN+s+PPvhoJkImFY5nwiKNGOUlqv8QuJHH5LR19XYmx3kWscQSOWwbU8bMrWKE27uikZCqnfy+C75ZdqTPUDHfCzvNu1XcdK7FQyFvLZv2dWzTLFnOY9i1/ZOALlGmlCMQ9IAgMOhX5YFjo8+/uhyt5xvj61ZD/23FEAA2emygfu0DkV0oOZJWZTjTn+W4ezWjw3MswZjwzpfPuIi4+tGkP/wehxym/GOWCzm1NZt1WLpy6UkDszNyJKrhaQeLQeMqxSB1juy5i1ODknR3COyMVoZbGjAQOP3vvvB+8+eYv3DZblMVGpVmBdxc9X8xwxrRFqPrR+P/dB4e3O+PZ9aR2QBfDi4ZaXn6vhmEYTMGxZO85K20hXBY3/vxd2xno6H1ptD6yoSaEAOd0HVxZXhsYlM3sQb7xT++VD3rmmDSW+L89VZr/DNO89bKH9TBADYLi9Vb/u67TK2OMWYcN6BBoB0ODySqE0+Pvvi8xcvXt7cnFf33g893IWP6H9XynrWGrRpfpKUnAGxA5yTmWNRuLv3Ce6v/FhhzinWhRMLllLIoiQpA1gAItwZkztBh3wU+tr8cDotZ8azCefMynFUhJHBRd0RtjHU7k5khUUoihnlY10Wgf3Uv/O9D37w/R/88pe/fP7Vc2rA2hhjrQHDTBcmwDuMaTVg1g7H3nu7OfZnt4+MsGVl776MKO2WZNbEae+RGZKY41A577mQQSPnTRozFSGTpHXtrd2eznfjDrqQB9bQu5hJUWfRxFU2zei1dX4Dqr+JcOKV8V1Bl0QHu0O0fSSHx6QCcvvdBgTmMXtS5+1v5tUPdmgx5TbuS4DJAAwBMMeBw07Hy+Xy4g9ffvvbj5f7uw4i6sl7D0zPQcWMkNaamXmQc1HEn3jEAbRGwspzT8s+0ZGNMVrLAW6KSjjVxRpIVp97PEcEgTJcvTERniT31mwMZ49NEY0EB7JpMzUcNItImkZ5EUrJpQ4GYM6FIRlTeEU2ihJ8LK01RrOLY12Xfuxmsm7D/XK5rBqn4/n20fH29CeGwzdfv7p78R8+VpA+iLE0Vs/D8IO11g7WmFWoZLP2/nvPWu9jXU+PzuvD8rCO21OP9F3vzVcfPnpr016GFLTWVFG91dCbWJBw0mbWmjlp5LqsPnwssNZ7Ox9vuHqLMUrBrwbH4DUIinslmHJ7BW2mj9lUY2/DQ4yL8MJmwPeWnm9+agND17+bNOC1Zrwl9G+cqW4M+2IDEsGSedoUZDR6aIcb6vD61YvDoi+/+eZ/AdsbIj/AKHq5AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F7917130340>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from torchvision.utils import make_grid, save_image\n",
+    "from PIL import Image\n",
+    "lgits=images[1]\n",
+    "probs = torch.nn.Softmax(dim=1)(lgits)\n",
+    "import matplotlib.pyplot as plt\n",
+    "print(f'Input Text: {raw_text}')\n",
+    "### Sorting 통해 text랑 image사이 거리가 가장 가까운 순으로 출력 ### \n",
+    "for idx, prob in sorted(enumerate(probs[0]),key = lambda x: x[1], reverse = True):\n",
+    "    print(f'probability: {prob.item()}')\n",
+    "    grid = make_grid(images[0][idx], nrow=1, padding=0, pad_value=0)\n",
+    "    ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n",
+    "    im = Image.fromarray(ndarr)\n",
+    "    display(im)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[6.5843, 6.5758, 6.5837, 6.5846, 6.5733]], device='cuda:0')\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(images[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.5 64-bit ('base': conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/model.py b/model.py
new file mode 100644
index 0000000..22e9c5d
--- /dev/null
+++ b/model.py
@@ -0,0 +1,556 @@
+from math import log2, sqrt
+import torch
+from einops import repeat
+
+from torch import nn, einsum
+import torch.nn.functional as F
+import numpy as np
+
+from axial_positional_embedding import AxialPositionalEmbedding
+from einops import rearrange
+
+from dalle_pytorch import distributed_utils
+from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE
+from dalle_pytorch.transformer import Transformer, DivideMax
+from dalle_pytorch.attention import stable_softmax
+
+# from clipmodel import *
+
+
+def exists(val):
+    return val is not None
+
+
+def default(val, d):
+    return val if exists(val) else d
+
+
+class always:
+    def __init__(self, val):
+        self.val = val
+
+    def __call__(self, x, *args, **kwargs):
+        return self.val
+
+
+def is_empty(t):
+    return t.nelement() == 0
+
+
+def masked_mean(t, mask, dim=1):
+    t = t.masked_fill(~mask[:, :, None], 0.0)
+    return t.sum(dim=1) / mask.sum(dim=1)[..., None]
+
+
+def set_requires_grad(model, value):
+    for param in model.parameters():
+        param.requires_grad = value
+
+
+def eval_decorator(fn):
+    def inner(model, *args, **kwargs):
+        was_training = model.training
+        model.eval()
+        out = fn(model, *args, **kwargs)
+        model.train(was_training)
+        return out
+
+    return inner
+
+
+# sampling helpers
+
+
+def top_k(logits, thres=0.5):
+    num_logits = logits.shape[-1]
+    k = max(int((1 - thres) * num_logits), 1)
+    val, ind = torch.topk(logits, k)
+    probs = torch.full_like(logits, float("-inf"))
+    probs.scatter_(1, ind, val)
+    return probs
+
+
+# discrete vae class
+
+
+class DiscreteVAE(nn.Module):
+    def __init__(
+        self,
+        image_size=256,
+        num_tokens=512,
+        codebook_dim=512,
+        num_layers=3,
+        num_resnet_blocks=0,
+        hidden_dim=64,
+        channels=3,
+        smooth_l1_loss=False,
+        temperature=0.9,
+        straight_through=False,
+        kl_div_loss_weight=0.0,
+        normalization=((0.5,) * 3, (0.5,) * 3),
+    ):
+        super().__init__()
+        assert log2(image_size).is_integer(), "image size must be a power of 2"
+        assert num_layers >= 1, "number of layers must be greater than or equal to 1"
+        has_resblocks = num_resnet_blocks > 0
+
+        self.image_size = image_size
+        self.num_tokens = num_tokens
+        self.num_layers = num_layers
+        self.temperature = temperature
+        self.straight_through = straight_through
+        self.codebook = nn.Embedding(num_tokens, codebook_dim)
+
+        hdim = hidden_dim
+
+        enc_chans = [hidden_dim] * num_layers
+        dec_chans = list(reversed(enc_chans))
+
+        enc_chans = [channels, *enc_chans]
+
+        dec_init_chan = codebook_dim if not has_resblocks else dec_chans[0]
+        dec_chans = [dec_init_chan, *dec_chans]
+
+        enc_chans_io, dec_chans_io = map(lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans))
+
+        enc_layers = []
+        dec_layers = []
+
+        for (enc_in, enc_out), (dec_in, dec_out) in zip(enc_chans_io, dec_chans_io):
+            enc_layers.append(
+                nn.Sequential(nn.Conv2d(enc_in, enc_out, 4, stride=2, padding=1), nn.ReLU())
+            )
+            dec_layers.append(
+                nn.Sequential(
+                    nn.ConvTranspose2d(dec_in, dec_out, 4, stride=2, padding=1), nn.ReLU()
+                )
+            )
+
+        for _ in range(num_resnet_blocks):
+            dec_layers.insert(0, ResBlock(dec_chans[1]))
+            enc_layers.append(ResBlock(enc_chans[-1]))
+
+        if num_resnet_blocks > 0:
+            dec_layers.insert(0, nn.Conv2d(codebook_dim, dec_chans[1], 1))
+
+        enc_layers.append(nn.Conv2d(enc_chans[-1], num_tokens, 1))
+        dec_layers.append(nn.Conv2d(dec_chans[-1], channels, 1))
+
+        self.encoder = nn.Sequential(*enc_layers)
+        self.decoder = nn.Sequential(*dec_layers)
+
+        self.loss_fn = F.smooth_l1_loss if smooth_l1_loss else F.mse_loss
+        self.kl_div_loss_weight = kl_div_loss_weight
+
+        # take care of normalization within class
+        self.normalization = normalization
+
+        self._register_external_parameters()
+
+    def _register_external_parameters(self):
+        """Register external parameters for DeepSpeed partitioning."""
+        if not distributed_utils.is_distributed or not distributed_utils.using_backend(
+            distributed_utils.DeepSpeedBackend
+        ):
+            return
+
+        deepspeed = distributed_utils.backend.backend_module
+        deepspeed.zero.register_external_parameter(self, self.codebook.weight)
+
+    def norm(self, images):
+        if not exists(self.normalization):
+            return images
+
+        means, stds = map(lambda t: torch.as_tensor(t).to(images), self.normalization)
+        means, stds = map(lambda t: rearrange(t, "c -> () c () ()"), (means, stds))
+        images = images.clone()
+        images.sub_(means).div_(stds)
+        return images
+
+    @torch.no_grad()
+    @eval_decorator
+    def get_codebook_indices(self, images):
+        logits = self(images, return_logits=True)
+        codebook_indices = logits.argmax(dim=1).flatten(1)
+        return codebook_indices
+
+    def decode(self, img_seq):
+        image_embeds = self.codebook(img_seq)
+        b, n, d = image_embeds.shape
+        h = w = int(sqrt(n))
+
+        image_embeds = rearrange(image_embeds, "b (h w) d -> b d h w", h=h, w=w)
+        images = self.decoder(image_embeds)
+        return images
+
+    def forward(self, img, return_loss=False, return_recons=False, return_logits=False, temp=None):
+        device, num_tokens, image_size, kl_div_loss_weight = (
+            img.device,
+            self.num_tokens,
+            self.image_size,
+            self.kl_div_loss_weight,
+        )
+        assert (
+            img.shape[-1] == image_size and img.shape[-2] == image_size
+        ), f"input must have the correct image size {image_size}"
+
+        img = self.norm(img)
+
+        logits = self.encoder(img)
+
+        if return_logits:
+            return logits  # return logits for getting hard image indices for DALL-E training
+
+        temp = default(temp, self.temperature)
+        soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=self.straight_through)
+        sampled = einsum("b n h w, n d -> b d h w", soft_one_hot, self.codebook.weight)
+        out = self.decoder(sampled)
+
+        if not return_loss:
+            return out
+
+        # reconstruction loss
+
+        recon_loss = self.loss_fn(img, out)
+
+        # kl divergence
+
+        logits = rearrange(logits, "b n h w -> b (h w) n")
+        log_qy = F.log_softmax(logits, dim=-1)
+        log_uniform = torch.log(torch.tensor([1.0 / num_tokens], device=device))
+        kl_div = F.kl_div(log_uniform, log_qy, None, None, "batchmean", log_target=True)
+
+        loss = recon_loss + (kl_div * kl_div_loss_weight)
+
+        if not return_recons:
+            return loss
+
+        return loss, out
+
+
+class ResBlock(nn.Module):
+    def __init__(self, chan):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(chan, chan, 3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(chan, chan, 3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(chan, chan, 1),
+        )
+
+    def forward(self, x):
+        return self.net(x) + x
+
+
+class DALLE_Klue_Roberta(nn.Module):
+    def __init__(
+        self,
+        *,
+        # dim,
+        vae,
+        num_text_tokens=10000,
+        text_seq_len=256,
+        depth,
+        heads=8,
+        dim_head=64,
+        reversible=False,
+        attn_dropout=0.0,
+        ff_dropout=0,
+        sparse_attn=False,
+        attn_types=None,
+        loss_img_weight=7,
+        stable=False,
+        sandwich_norm=False,
+        shift_tokens=True,
+        rotary_emb=False,
+        wte_dir=None,
+        wpe_dir=None,
+    ):
+        super().__init__()
+        assert isinstance(
+            vae, (DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE)
+        ), "vae must be an instance of DiscreteVAE"
+        image_size = vae.image_size
+        num_image_tokens = vae.num_tokens
+        image_fmap_size = vae.image_size // (2 ** vae.num_layers)
+        image_seq_len = image_fmap_size ** 2
+
+        num_text_tokens = (
+            num_text_tokens + text_seq_len
+        )  # reserve unique padding tokens for each position (text seq len)
+
+        self.text_emb = torch.load(wte_dir)
+        dim = self.text_emb.weight.shape[1]
+        self.image_emb = nn.Embedding(num_image_tokens, dim)
+        print(dim, image_fmap_size, image_fmap_size)
+        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>
+        self.image_pos_emb = (
+            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))
+            if not rotary_emb
+            else always(0)
+        )
+
+        self.num_text_tokens = (
+            num_text_tokens  # for offsetting logits index and calculating cross entropy loss
+        )
+        self.num_image_tokens = num_image_tokens
+
+        self.text_seq_len = text_seq_len
+        self.image_seq_len = image_seq_len
+
+        seq_len = text_seq_len + image_seq_len
+        total_tokens = num_text_tokens + num_image_tokens
+        self.total_tokens = total_tokens
+        self.total_seq_len = seq_len
+
+        self.vae = vae
+        set_requires_grad(self.vae, False)  # freeze VAE from being trained
+
+        self.transformer = Transformer(
+            dim=dim,
+            causal=True,
+            seq_len=seq_len,
+            depth=depth,
+            heads=heads,
+            dim_head=dim_head,
+            reversible=reversible,
+            attn_dropout=attn_dropout,
+            ff_dropout=ff_dropout,
+            attn_types=attn_types,
+            image_fmap_size=image_fmap_size,
+            sparse_attn=sparse_attn,
+            stable=stable,
+            sandwich_norm=sandwich_norm,
+            shift_tokens=shift_tokens,
+            rotary_emb=rotary_emb,
+        )
+
+        self.stable = stable
+
+        if stable:
+            self.norm_by_max = DivideMax(dim=-1)
+
+        self.to_logits = nn.Sequential(
+            nn.LayerNorm(dim),
+            nn.Linear(dim, self.total_tokens),
+        )
+
+        seq_range = torch.arange(seq_len)
+        logits_range = torch.arange(total_tokens)
+
+        seq_range = rearrange(seq_range, "n -> () n ()")
+        logits_range = rearrange(logits_range, "d -> () () d")
+
+        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (
+            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)
+        )
+
+        self.register_buffer("logits_mask", logits_mask, persistent=False)
+        self.loss_img_weight = loss_img_weight
+
+    @torch.no_grad()
+    @eval_decorator
+    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):
+        text_seq_len = self.text_seq_len
+        if text is None or text == "":
+            text_tokens = torch.tensor([[0]]).cuda()
+        else:
+            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)
+
+        for _ in range(text_tokens.shape[1], text_seq_len):
+            device = text_tokens.device
+
+            tokens = self.text_emb(text_tokens)
+            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))
+
+            seq_len = tokens.shape[1]
+
+            output_transf = self.transformer(tokens)
+
+            if self.stable:
+                output_transf = self.norm_by_max(output_transf)
+
+            logits = self.to_logits(output_transf)
+
+            # mask logits to make sure text predicts text (except last token), and image predicts image
+
+            logits_mask = self.logits_mask[:, :seq_len]
+            max_neg_value = -torch.finfo(logits.dtype).max
+            logits.masked_fill_(logits_mask, max_neg_value)
+            logits = logits[:, -1, :]
+
+            filtered_logits = top_k(logits, thres=filter_thres)
+            probs = stable_softmax(filtered_logits / temperature, dim=-1)
+            sample = torch.multinomial(probs, 1)
+
+            text_tokens = torch.cat((text_tokens, sample), dim=-1)
+
+        padding_tokens = set(
+            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)
+        )
+        texts = [
+            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)
+            for text_token in text_tokens
+        ]
+        return text_tokens, texts
+
+    @torch.no_grad()
+    @eval_decorator
+    def generate_images(
+        self,
+        text,
+        *,
+        clip=None,
+        mask=None,
+        filter_thres=0.5,
+        temperature=1.0,
+        img=None,
+        num_init_img_tokens=None,
+        raw_text=None,
+    ):
+        vae, text_seq_len, image_seq_len, num_text_tokens = (
+            self.vae,
+            self.text_seq_len,
+            self.image_seq_len,
+            self.num_text_tokens,
+        )
+        total_len = text_seq_len + image_seq_len
+        text = text[:, :text_seq_len]  # make sure text is within bounds
+        out = text
+
+        if exists(img):
+            image_size = vae.image_size
+            assert (
+                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size
+            ), f"input image must have the correct image size {image_size}"
+
+            indices = vae.get_codebook_indices(img)
+            num_img_tokens = default(
+                num_init_img_tokens, int(0.4375 * image_seq_len)
+            )  # OpenAI used 14 * 32 initial tokens to prime
+            assert (
+                num_img_tokens < image_seq_len
+            ), "number of initial image tokens for priming must be less than the total image token sequence length"
+
+            indices = indices[:, :num_img_tokens]
+            out = torch.cat((out, indices), dim=-1)
+
+        for cur_len in range(out.shape[1], total_len):
+            is_image = cur_len >= text_seq_len
+
+            text, image = out[:, :text_seq_len], out[:, text_seq_len:]
+
+            logits = self(text, image, mask=mask)[:, -1, :]
+
+            filtered_logits = top_k(logits, thres=filter_thres)
+            probs = F.softmax(filtered_logits / temperature, dim=-1)
+            sample = torch.multinomial(probs, 1)
+
+            sample -= (
+                num_text_tokens if is_image else 0
+            )  # offset sampled token if it is an image token, since logit space is composed of text and then image tokens
+            out = torch.cat((out, sample), dim=-1)
+
+            if out.shape[1] <= text_seq_len:
+                mask = F.pad(mask, (0, 1), value=True)
+
+        text_seq = out[:, :text_seq_len]
+
+        img_seq = out[:, -image_seq_len:]
+        images = vae.decode(img_seq)
+        print(images.shape)
+        if exists(clip):
+            from transformers import AutoTokenizer
+
+            clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
+            input_text = clip_tokenizer(
+                raw_text,
+                padding=True,
+                pad_to_max_length=True,
+                max_length=128,
+                truncation=True,
+                return_tensors="pt",
+            )
+            input_text = input_text.to("cuda")
+            text_embeds, image_embeds = clip(input_text, images)
+            logits = (text_embeds @ image_embeds.T)
+            return images, logits
+
+        return images
+
+    def forward(self, text, image=None, mask=None, return_loss=False):
+        assert (
+            text.shape[-1] == self.text_seq_len
+        ), f"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})"
+        device, total_seq_len = text.device, self.total_seq_len
+
+        text = F.pad(text, (1, 0), value=0)
+        tokens = self.text_emb(text)
+        tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))
+
+        seq_len = tokens.shape[1]
+
+        if exists(image) and not is_empty(image):
+            is_raw_image = len(image.shape) == 4
+
+            if is_raw_image:
+                image_size = self.vae.image_size
+                assert tuple(image.shape[1:]) == (
+                    3,
+                    image_size,
+                    image_size,
+                ), f"invalid image of dimensions {image.shape} passed in during training"
+
+                image = self.vae.get_codebook_indices(image)
+            image_len = image.shape[1]
+            image_emb = self.image_emb(image)
+            image_emb += self.image_pos_emb(image_emb)
+
+            tokens = torch.cat((tokens, image_emb), dim=1)
+
+            seq_len += image_len
+
+        # when training, if the length exceeds the total text + image length
+        # remove the last token, since it needs not to be trained
+
+        if tokens.shape[1] > total_seq_len:
+            seq_len -= 1
+            tokens = tokens[:, :-1]
+
+        if self.stable:
+            alpha = 0.1
+            tokens = tokens * alpha + tokens.detach() * (1 - alpha)
+
+        out = self.transformer(tokens)
+
+        if self.stable:
+            out = self.norm_by_max(out)
+
+        logits = self.to_logits(out)
+
+        # mask logits to make sure text predicts text (except last token), and image predicts image
+
+        logits_mask = self.logits_mask[:, :seq_len]
+        max_neg_value = -torch.finfo(logits.dtype).max
+        logits.masked_fill_(logits_mask, max_neg_value)
+
+        if not return_loss:
+            return logits
+
+        assert exists(image), "when training, image must be supplied"
+
+        offsetted_image = image + self.num_text_tokens
+        labels = torch.cat((text[:, 1:], offsetted_image), dim=1)
+
+        logits = rearrange(logits, "b n c -> b c n")
+
+        loss_text = F.cross_entropy(
+            logits[:, :, : self.text_seq_len], labels[:, : self.text_seq_len]
+        )
+        loss_img = F.cross_entropy(
+            logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]
+        )
+
+        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)
+        return loss

From 6faf3c7ff8460f1449b5de7979c4897f1d58822b Mon Sep 17 00:00:00 2001
From: kimyeondu <yjookimcd@gmail.com>
Date: Mon, 20 Dec 2021 15:05:25 +0000
Subject: [PATCH 09/26] edit gitignore

---
 .gitignore | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 141 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index d6d95cf..ea76db1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,141 @@
-models
\ No newline at end of file
+models
+# dall-e generation outputs
+outputs/
+*.pt
+taming/
+wandb/
+dalle-ds-cp/
+*.out
+/.github
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.ipynb
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# Visual Studio Code
+.vscode
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

From cb9137a4317b05dd640ea7769518e1e069a4d5c7 Mon Sep 17 00:00:00 2001
From: Joonhong Kim <30318926+JoonHong-Kim@users.noreply.github.com>
Date: Tue, 21 Dec 2021 00:06:05 +0900
Subject: [PATCH 10/26] Delete model.py

---
 model.py | 540 -------------------------------------------------------
 1 file changed, 540 deletions(-)
 delete mode 100644 model.py

diff --git a/model.py b/model.py
deleted file mode 100644
index 299c0fa..0000000
--- a/model.py
+++ /dev/null
@@ -1,540 +0,0 @@
-from math import log2, sqrt
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-import numpy as np
-
-from axial_positional_embedding import AxialPositionalEmbedding
-from einops import rearrange
-
-from dalle_pytorch import distributed_utils
-from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE
-from dalle_pytorch.transformer import Transformer, DivideMax
-from dalle_pytorch.attention import stable_softmax
-
-
-def exists(val):
-    return val is not None
-
-
-def default(val, d):
-    return val if exists(val) else d
-
-
-class always:
-    def __init__(self, val):
-        self.val = val
-
-    def __call__(self, x, *args, **kwargs):
-        return self.val
-
-
-def is_empty(t):
-    return t.nelement() == 0
-
-
-def masked_mean(t, mask, dim=1):
-    t = t.masked_fill(~mask[:, :, None], 0.0)
-    return t.sum(dim=1) / mask.sum(dim=1)[..., None]
-
-
-def set_requires_grad(model, value):
-    for param in model.parameters():
-        param.requires_grad = value
-
-
-def eval_decorator(fn):
-    def inner(model, *args, **kwargs):
-        was_training = model.training
-        model.eval()
-        out = fn(model, *args, **kwargs)
-        model.train(was_training)
-        return out
-
-    return inner
-
-
-# sampling helpers
-
-
-def top_k(logits, thres=0.5):
-    num_logits = logits.shape[-1]
-    k = max(int((1 - thres) * num_logits), 1)
-    val, ind = torch.topk(logits, k)
-    probs = torch.full_like(logits, float("-inf"))
-    probs.scatter_(1, ind, val)
-    return probs
-
-
-# discrete vae class
-
-class DiscreteVAE(nn.Module):
-    def __init__(
-        self,
-        image_size=256,
-        num_tokens=512,
-        codebook_dim=512,
-        num_layers=3,
-        num_resnet_blocks=0,
-        hidden_dim=64,
-        channels=3,
-        smooth_l1_loss=False,
-        temperature=0.9,
-        straight_through=False,
-        kl_div_loss_weight=0.0,
-        normalization=((0.5,) * 3, (0.5,) * 3),
-    ):
-        super().__init__()
-        assert log2(image_size).is_integer(), "image size must be a power of 2"
-        assert num_layers >= 1, "number of layers must be greater than or equal to 1"
-        has_resblocks = num_resnet_blocks > 0
-
-        self.image_size = image_size
-        self.num_tokens = num_tokens
-        self.num_layers = num_layers
-        self.temperature = temperature
-        self.straight_through = straight_through
-        self.codebook = nn.Embedding(num_tokens, codebook_dim)
-
-        hdim = hidden_dim
-
-        enc_chans = [hidden_dim] * num_layers
-        dec_chans = list(reversed(enc_chans))
-
-        enc_chans = [channels, *enc_chans]
-
-        dec_init_chan = codebook_dim if not has_resblocks else dec_chans[0]
-        dec_chans = [dec_init_chan, *dec_chans]
-
-        enc_chans_io, dec_chans_io = map(lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans))
-
-        enc_layers = []
-        dec_layers = []
-
-        for (enc_in, enc_out), (dec_in, dec_out) in zip(enc_chans_io, dec_chans_io):
-            enc_layers.append(
-                nn.Sequential(nn.Conv2d(enc_in, enc_out, 4, stride=2, padding=1), nn.ReLU())
-            )
-            dec_layers.append(
-                nn.Sequential(
-                    nn.ConvTranspose2d(dec_in, dec_out, 4, stride=2, padding=1), nn.ReLU()
-                )
-            )
-
-        for _ in range(num_resnet_blocks):
-            dec_layers.insert(0, ResBlock(dec_chans[1]))
-            enc_layers.append(ResBlock(enc_chans[-1]))
-
-        if num_resnet_blocks > 0:
-            dec_layers.insert(0, nn.Conv2d(codebook_dim, dec_chans[1], 1))
-
-        enc_layers.append(nn.Conv2d(enc_chans[-1], num_tokens, 1))
-        dec_layers.append(nn.Conv2d(dec_chans[-1], channels, 1))
-
-        self.encoder = nn.Sequential(*enc_layers)
-        self.decoder = nn.Sequential(*dec_layers)
-
-        self.loss_fn = F.smooth_l1_loss if smooth_l1_loss else F.mse_loss
-        self.kl_div_loss_weight = kl_div_loss_weight
-
-        # take care of normalization within class
-        self.normalization = normalization
-
-        self._register_external_parameters()
-
-    def _register_external_parameters(self):
-        """Register external parameters for DeepSpeed partitioning."""
-        if not distributed_utils.is_distributed or not distributed_utils.using_backend(
-            distributed_utils.DeepSpeedBackend
-        ):
-            return
-
-        deepspeed = distributed_utils.backend.backend_module
-        deepspeed.zero.register_external_parameter(self, self.codebook.weight)
-
-    def norm(self, images):
-        if not exists(self.normalization):
-            return images
-
-        means, stds = map(lambda t: torch.as_tensor(t).to(images), self.normalization)
-        means, stds = map(lambda t: rearrange(t, "c -> () c () ()"), (means, stds))
-        images = images.clone()
-        images.sub_(means).div_(stds)
-        return images
-
-    @torch.no_grad()
-    @eval_decorator
-    def get_codebook_indices(self, images):
-        logits = self(images, return_logits=True)
-        codebook_indices = logits.argmax(dim=1).flatten(1)
-        return codebook_indices
-
-    def decode(self, img_seq):
-        image_embeds = self.codebook(img_seq)
-        b, n, d = image_embeds.shape
-        h = w = int(sqrt(n))
-
-        image_embeds = rearrange(image_embeds, "b (h w) d -> b d h w", h=h, w=w)
-        images = self.decoder(image_embeds)
-        return images
-
-    def forward(self, img, return_loss=False, return_recons=False, return_logits=False, temp=None):
-        device, num_tokens, image_size, kl_div_loss_weight = (
-            img.device,
-            self.num_tokens,
-            self.image_size,
-            self.kl_div_loss_weight,
-        )
-        assert (
-            img.shape[-1] == image_size and img.shape[-2] == image_size
-        ), f"input must have the correct image size {image_size}"
-
-        img = self.norm(img)
-
-        logits = self.encoder(img)
-
-        if return_logits:
-            return logits  # return logits for getting hard image indices for DALL-E training
-
-        temp = default(temp, self.temperature)
-        soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=self.straight_through)
-        sampled = einsum("b n h w, n d -> b d h w", soft_one_hot, self.codebook.weight)
-        out = self.decoder(sampled)
-
-        if not return_loss:
-            return out
-
-        # reconstruction loss
-
-        recon_loss = self.loss_fn(img, out)
-
-        # kl divergence
-
-        logits = rearrange(logits, "b n h w -> b (h w) n")
-        log_qy = F.log_softmax(logits, dim=-1)
-        log_uniform = torch.log(torch.tensor([1.0 / num_tokens], device=device))
-        kl_div = F.kl_div(log_uniform, log_qy, None, None, "batchmean", log_target=True)
-
-        loss = recon_loss + (kl_div * kl_div_loss_weight)
-
-        if not return_recons:
-            return loss
-
-        return loss, out
-
-class ResBlock(nn.Module):
-    def __init__(self, chan):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Conv2d(chan, chan, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(chan, chan, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(chan, chan, 1),
-        )
-
-    def forward(self, x):
-        return self.net(x) + x
-
-
-class DALLE_Klue_Roberta(nn.Module):
-    def __init__(
-        self,
-        *,
-        # dim,
-        vae,
-        num_text_tokens=10000,
-        text_seq_len=256,
-        depth,
-        heads=8,
-        dim_head=64,
-        reversible=False,
-        attn_dropout=0.0,
-        ff_dropout=0,
-        sparse_attn=False,
-        attn_types=None,
-        loss_img_weight=7,
-        stable=False,
-        sandwich_norm=False,
-        shift_tokens=True,
-        rotary_emb=False,
-        wte_dir=None,
-        wpe_dir=None,
-    ):
-        super().__init__()
-        assert isinstance(
-            vae, (DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE)
-        ), "vae must be an instance of DiscreteVAE"
-        image_size = vae.image_size
-        num_image_tokens = vae.num_tokens
-        image_fmap_size = vae.image_size // (2 ** vae.num_layers)
-        image_seq_len = image_fmap_size ** 2
-
-        num_text_tokens = (
-            num_text_tokens + text_seq_len
-        )  # reserve unique padding tokens for each position (text seq len)
-
-        self.text_emb = torch.load(wte_dir)
-        dim = self.text_emb.weight.shape[1]
-        self.image_emb = nn.Embedding(num_image_tokens, dim)
-        print(dim, image_fmap_size, image_fmap_size)
-        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>
-        self.image_pos_emb = (
-            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))
-            if not rotary_emb
-            else always(0)
-        )
-
-        self.num_text_tokens = (
-            num_text_tokens  # for offsetting logits index and calculating cross entropy loss
-        )
-        self.num_image_tokens = num_image_tokens
-
-        self.text_seq_len = text_seq_len
-        self.image_seq_len = image_seq_len
-
-        seq_len = text_seq_len + image_seq_len
-        total_tokens = num_text_tokens + num_image_tokens
-        self.total_tokens = total_tokens
-        self.total_seq_len = seq_len
-
-        self.vae = vae
-        set_requires_grad(self.vae, False)  # freeze VAE from being trained
-
-        self.transformer = Transformer(
-            dim=dim,
-            causal=True,
-            seq_len=seq_len,
-            depth=depth,
-            heads=heads,
-            dim_head=dim_head,
-            reversible=reversible,
-            attn_dropout=attn_dropout,
-            ff_dropout=ff_dropout,
-            attn_types=attn_types,
-            image_fmap_size=image_fmap_size,
-            sparse_attn=sparse_attn,
-            stable=stable,
-            sandwich_norm=sandwich_norm,
-            shift_tokens=shift_tokens,
-            rotary_emb=rotary_emb,
-        )
-
-        self.stable = stable
-
-        if stable:
-            self.norm_by_max = DivideMax(dim=-1)
-
-        self.to_logits = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, self.total_tokens),
-        )
-
-        seq_range = torch.arange(seq_len)
-        logits_range = torch.arange(total_tokens)
-
-        seq_range = rearrange(seq_range, "n -> () n ()")
-        logits_range = rearrange(logits_range, "d -> () () d")
-
-        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (
-            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)
-        )
-
-        self.register_buffer("logits_mask", logits_mask, persistent=False)
-        self.loss_img_weight = loss_img_weight
-
-    @torch.no_grad()
-    @eval_decorator
-    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):
-        text_seq_len = self.text_seq_len
-        if text is None or text == "":
-            text_tokens = torch.tensor([[0]]).cuda()
-        else:
-            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)
-
-        for _ in range(text_tokens.shape[1], text_seq_len):
-            device = text_tokens.device
-
-            tokens = self.text_emb(text_tokens)
-            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))
-
-            seq_len = tokens.shape[1]
-
-            output_transf = self.transformer(tokens)
-
-            if self.stable:
-                output_transf = self.norm_by_max(output_transf)
-
-            logits = self.to_logits(output_transf)
-
-            # mask logits to make sure text predicts text (except last token), and image predicts image
-
-            logits_mask = self.logits_mask[:, :seq_len]
-            max_neg_value = -torch.finfo(logits.dtype).max
-            logits.masked_fill_(logits_mask, max_neg_value)
-            logits = logits[:, -1, :]
-
-            filtered_logits = top_k(logits, thres=filter_thres)
-            probs = stable_softmax(filtered_logits / temperature, dim=-1)
-            sample = torch.multinomial(probs, 1)
-
-            text_tokens = torch.cat((text_tokens, sample), dim=-1)
-
-        padding_tokens = set(
-            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)
-        )
-        texts = [
-            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)
-            for text_token in text_tokens
-        ]
-        return text_tokens, texts
-
-    @torch.no_grad()
-    @eval_decorator
-    def generate_images(
-        self,
-        text,
-        *,
-        clip=None,
-        mask=None,
-        filter_thres=0.5,
-        temperature=1.0,
-        img=None,
-        num_init_img_tokens=None,
-    ):
-        vae, text_seq_len, image_seq_len, num_text_tokens = (
-            self.vae,
-            self.text_seq_len,
-            self.image_seq_len,
-            self.num_text_tokens,
-        )
-        total_len = text_seq_len + image_seq_len
-
-        text = text[:, :text_seq_len]  # make sure text is within bounds
-        out = text
-
-        if exists(img):
-            image_size = vae.image_size
-            assert (
-                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size
-            ), f"input image must have the correct image size {image_size}"
-
-            indices = vae.get_codebook_indices(img)
-            num_img_tokens = default(
-                num_init_img_tokens, int(0.4375 * image_seq_len)
-            )  # OpenAI used 14 * 32 initial tokens to prime
-            assert (
-                num_img_tokens < image_seq_len
-            ), "number of initial image tokens for priming must be less than the total image token sequence length"
-
-            indices = indices[:, :num_img_tokens]
-            out = torch.cat((out, indices), dim=-1)
-
-        for cur_len in range(out.shape[1], total_len):
-            is_image = cur_len >= text_seq_len
-
-            text, image = out[:, :text_seq_len], out[:, text_seq_len:]
-
-            logits = self(text, image, mask=mask)[:, -1, :]
-
-            filtered_logits = top_k(logits, thres=filter_thres)
-            probs = F.softmax(filtered_logits / temperature, dim=-1)
-            sample = torch.multinomial(probs, 1)
-
-            sample -= (
-                num_text_tokens if is_image else 0
-            )  # offset sampled token if it is an image token, since logit space is composed of text and then image tokens
-            out = torch.cat((out, sample), dim=-1)
-
-            if out.shape[1] <= text_seq_len:
-                mask = F.pad(mask, (0, 1), value=True)
-
-        text_seq = out[:, :text_seq_len]
-
-        img_seq = out[:, -image_seq_len:]
-        images = vae.decode(img_seq)
-
-        if exists(clip):
-            clip_model=torch.load('fashionclip_fn.pt')
-            text_embeds, image_embeds = clip_model(text_seq, images)
-            logits = (text_embeds @ image_embeds.T)*0.07
-            return images, logits
-
-        return images
-
-    def forward(self, text, image=None, mask=None, return_loss=False):
-        assert (
-            text.shape[-1] == self.text_seq_len
-        ), f"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})"
-        device, total_seq_len = text.device, self.total_seq_len
-
-
-        text = F.pad(text, (1, 0), value=0)
-        tokens = self.text_emb(text)
-        tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))
-
-        seq_len = tokens.shape[1]
-
-        if exists(image) and not is_empty(image):
-            is_raw_image = len(image.shape) == 4
-
-            if is_raw_image:
-                image_size = self.vae.image_size
-                assert tuple(image.shape[1:]) == (
-                    3,
-                    image_size,
-                    image_size,
-                ), f"invalid image of dimensions {image.shape} passed in during training"
-
-                image = self.vae.get_codebook_indices(image)
-            image_len = image.shape[1]
-            image_emb = self.image_emb(image)
-            image_emb += self.image_pos_emb(image_emb)
-
-            tokens = torch.cat((tokens, image_emb), dim=1)
-
-            seq_len += image_len
-
-        # when training, if the length exceeds the total text + image length
-        # remove the last token, since it needs not to be trained
-
-        if tokens.shape[1] > total_seq_len:
-            seq_len -= 1
-            tokens = tokens[:, :-1]
-
-        if self.stable:
-            alpha = 0.1
-            tokens = tokens * alpha + tokens.detach() * (1 - alpha)
-
-        out = self.transformer(tokens)
-
-        if self.stable:
-            out = self.norm_by_max(out)
-
-        logits = self.to_logits(out)
-
-        # mask logits to make sure text predicts text (except last token), and image predicts image
-
-        logits_mask = self.logits_mask[:, :seq_len]
-        max_neg_value = -torch.finfo(logits.dtype).max
-        logits.masked_fill_(logits_mask, max_neg_value)
-
-        if not return_loss:
-            return logits
-
-        assert exists(image), "when training, image must be supplied"
-
-        offsetted_image = image + self.num_text_tokens
-        labels = torch.cat((text[:, 1:], offsetted_image), dim=1)
-
-        logits = rearrange(logits, "b n c -> b c n")
-
-        loss_text = F.cross_entropy(
-            logits[:, :, : self.text_seq_len], labels[:, : self.text_seq_len]
-        )
-        loss_img = F.cross_entropy(
-            logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]
-        )
-
-        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)
-        return loss

From df6635f023e98a36585cdc99f44dbed4a6417c27 Mon Sep 17 00:00:00 2001
From: jjonhwa <jjonhwa@naver.com>
Date: Tue, 21 Dec 2021 02:20:17 +0000
Subject: [PATCH 11/26] add skip_sample in TextImageDataset

---
 loader.py | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/loader.py b/loader.py
index 431d74d..bb6d18c 100644
--- a/loader.py
+++ b/loader.py
@@ -1,16 +1,14 @@
-from random import randint
+from random import randint, choice
 from pathlib import Path
 from typing import Tuple
 
-from PIL import Image
+from PIL import Image, UnidentifiedImageError
 import torch
 from torch.utils.data import Dataset
 from torchvision.transforms import transforms
 from transformers import AutoTokenizer
 from preprocess import remove_style, remove_subj
 
-# -*- coding:utf8 -*-
-
 
 class TextImageDataset(Dataset):
     def __init__(
@@ -72,14 +70,20 @@ def __getitem__(self, ind: int) -> Tuple[torch.tensor, torch.tensor, torch.tenso
         text_file = self.text_files[key]
         image_file = self.image_files[key]
 
-        image = Image.open(image_file)
         descriptions = text_file.read_text(encoding="utf-8")
         descriptions = remove_style(descriptions).split("\n")
         descriptions = list(filter(lambda t: len(t) > 0, descriptions))
 
+        try:
+            description = choice(descriptions)
+        except IndexError as zero_captions_in_file_ex:
+            print(f"An exception occurred trying to load file {text_file}.")
+            print(f"Skipping index {ind}")
+            return self.skip_sample(ind)
+
         # ADD PREPROCESSING FUNCTION HERE
         encoded_dict = self.tokenizer(
-            descriptions,
+            description,
             return_tensors="pt",
             padding="max_length",
             truncation=True,
@@ -93,7 +97,13 @@ def __getitem__(self, ind: int) -> Tuple[torch.tensor, torch.tensor, torch.tenso
         input_ids = flattened_dict["input_ids"]
         attention_mask = flattened_dict["attention_mask"]
 
-        image_tensor = self.image_transform(image)
+        try:
+            image_tensor = self.image_transform(Image.open(image_file))
+        except (UnidentifiedImageError, OSError) as corrupt_image_exceptions:
+            print(f"An exception occurred trying to load file {image_file}.")
+            print(f"Skipping index {ind}")
+            return self.skip_sample(ind)
+
         return input_ids, image_tensor, attention_mask
 
     def random_sample(self):

From 5313b12e8020b1a869cfccb9c0c9f513567a5128 Mon Sep 17 00:00:00 2001
From: jjonhwa <jjonhwa@naver.com>
Date: Tue, 21 Dec 2021 11:06:30 +0000
Subject: [PATCH 12/26] upload vae

---
 vqgan/config/dvae_config.yaml |  14 +++
 vqgan/train_vae.py            | 217 ++++++++++++++++++++++++++++++++++
 2 files changed, 231 insertions(+)
 create mode 100644 vqgan/config/dvae_config.yaml
 create mode 100644 vqgan/train_vae.py

diff --git a/vqgan/config/dvae_config.yaml b/vqgan/config/dvae_config.yaml
new file mode 100644
index 0000000..9a8a5fd
--- /dev/null
+++ b/vqgan/config/dvae_config.yaml
@@ -0,0 +1,14 @@
+dVAE_CFG:
+  IMAGE_SIZE: 256
+
+  NUM_TOKENS: 16384  # codebook image patch tokens
+  NUM_LAYERS: 3
+  NUM_RESNET_BLOCKS: 2
+  SMOOTH_L1_LOSS: True
+  EMB_DIM: 256
+  HID_DIM: 256
+  KL_LOSS_WEIGHT: 0
+  STARTING_TEMP: 1.0
+  TEMP_MIN: 0.5
+  ANNEAL_RATE: 0.000001
+  BASELINE: False
\ No newline at end of file
diff --git a/vqgan/train_vae.py b/vqgan/train_vae.py
new file mode 100644
index 0000000..702ea85
--- /dev/null
+++ b/vqgan/train_vae.py
@@ -0,0 +1,217 @@
+import math
+import os
+import argparse
+import yaml
+import wandb
+
+from math import sqrt
+from pathlib import Path
+from easydict import EasyDict
+
+# torch
+from PIL import Image
+import torch
+from torch.optim import Adam
+from torch.optim.lr_scheduler import ExponentialLR
+
+# vision imports
+from torch.utils.data import DataLoader, Dataset
+from torchvision.utils import make_grid
+from torchvision import transforms
+
+# dalle classes and utils
+from dalle_pytorch import DiscreteVAE
+
+# dataset imports
+import sys
+from os import path
+
+sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
+from loader import ImgDatasetExample
+from utils import set_seed
+
+
+def save_model(path):
+    save_obj = {
+        "hparams": vae_params,
+    }
+    save_obj = {**save_obj, "weights": vae.state_dict()}
+
+    torch.save(save_obj, path)
+
+
+def train():
+    global_step = 0
+    temp = dVAE_CFG.STARTING_TEMP
+
+    for epoch in range(args.epochs):
+        for i, images in enumerate(dl):
+            images = images.to(device)
+
+            loss, recons = vae(images, return_loss=True, return_recons=True, temp=temp)
+
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+
+            logs = {}
+
+            if i % 100 == 0:
+                print(epoch, i, f"loss - {loss.item()}")
+
+                logs = {**logs, "epoch": epoch, "iter": i, "loss": loss.item()}
+
+                k = args.num_images_save
+
+                with torch.no_grad():
+                    codes = vae.get_codebook_indices(images[:k])
+                    hard_recons = vae.decode(codes)
+
+                images, recons = map(lambda t: t[:k], (images, recons))
+                images, recons, hard_recons, codes = map(
+                    lambda t: t.detach().cpu(), (images, recons, hard_recons, codes)
+                )
+                images, recons, hard_recons = map(
+                    lambda t: make_grid(
+                        t.float(), nrow=int(sqrt(k)), normalize=True, range=(-1, 1)
+                    ),
+                    (images, recons, hard_recons),
+                )
+
+                logs = {
+                    **logs,
+                    "sample images": wandb.Image(images, caption="original images"),
+                    "reconstructions": wandb.Image(recons, caption="reconstructions"),
+                    "hard reconstructions": wandb.Image(
+                        hard_recons, caption="hard reconstructions"
+                    ),
+                    "codebook_indices": wandb.Histogram(codes),
+                    "temperature": temp,
+                }
+
+                wandb.save("./vae.pt")
+                save_model(f"./vae.pt")
+
+                # temperature anneal
+
+                temp = max(
+                    temp * math.exp(-dVAE_CFG.ANNEAL_RATE * global_step),
+                    dVAE_CFG.TEMP_MIN,
+                )
+
+                # lr decay
+
+                # Do not advance schedulers from `deepspeed_config`.
+                sched.step()
+            wandb.log(logs)
+            global_step += 1
+
+        model_artifact = wandb.Artifact(
+            "trained-vae", type="model", metadata=dict(model_config)
+        )
+        model_artifact.add_file("vae.pt")
+        run.log_artifact(model_artifact)
+
+        save_model(os.path.join(args.save_path, f"vae_{epoch}.pt"))
+    # save final vae and cleanup
+    save_model("./vae-final.pt")
+    wandb.save("./vae-final.pt")
+
+    model_artifact = wandb.Artifact(
+        "trained-vae", type="model", metadata=dict(model_config)
+    )
+    model_artifact.add_file("vae-final.pt")
+    run.log_artifact(model_artifact)
+
+    wandb.finish()
+
+
+if __name__ == "__main__":
+    set_seed(42)
+    device = torch.device("cuda:0" if (torch.cuda.is_available()) else "cpu")
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--dvae_config",
+        type=str,
+        default="/opt/ml/KoDALLE/vqgan/config/dvae_config.yaml",
+        help="",
+    )
+    parser.add_argument("--save_path", type=str, default="./results_vae")
+    parser.add_argument(
+        "--image_folder",
+        type=str,
+        default="/opt/ml/DALLE-Couture/data/cropped_train_img",
+        help="path to your folder of images for learning the discrete VAE and its codebook",
+    )
+    parser.add_argument("--epochs", type=int, default=20, help="number of epochs")
+    parser.add_argument("--batch_size", type=int, default=16, help="batch size")
+    parser.add_argument(
+        "--learning_rate", type=float, default=4.5e-06, help="learning rate"
+    )
+    parser.add_argument(
+        "--lr_decay_rate", type=float, default=0.98, help="learning rate decay"
+    )
+    parser.add_argument(
+        "--num_images_save", type=int, default=1, help="number of images to save"
+    )
+
+    args = parser.parse_args()
+    if not os.path.exists(args.save_path):
+        os.mkdir(args.save_path)
+
+    with open(args.dvae_config, "r") as f:
+        dvae_config = yaml.load(f)
+        dVAE_CFG = EasyDict(dvae_config["dVAE_CFG"])
+
+    # Image Dataset
+    initial_transformation = transforms.Compose(
+        [
+            transforms.Lambda(
+                lambda img: img.convert("RGB") if img.mode != "RGB" else img
+            ),
+            transforms.Resize([dVAE_CFG.IMAGE_SIZE, dVAE_CFG.IMAGE_SIZE]),
+            # transforms.CenterCrop(VAE_CFG.IMAGE_SIZE),
+            transforms.ToTensor(),
+        ]
+    )
+    ds = ImgDatasetExample(
+        image_folder=args.image_folder, image_transform=initial_transformation
+    )
+    dl = DataLoader(ds, args.batch_size, shuffle=True)
+
+    vae_params = dict(
+        image_size=dVAE_CFG.IMAGE_SIZE,
+        num_layers=dVAE_CFG.NUM_LAYERS,
+        num_tokens=dVAE_CFG.NUM_TOKENS,
+        codebook_dim=dVAE_CFG.EMB_DIM,
+        hidden_dim=dVAE_CFG.HID_DIM,
+        num_resnet_blocks=dVAE_CFG.NUM_RESNET_BLOCKS,
+    )
+
+    vae = DiscreteVAE(
+        **vae_params,
+        smooth_l1_loss=dVAE_CFG.SMOOTH_L1_LOSS,
+        kl_div_loss_weight=dVAE_CFG.KL_LOSS_WEIGHT,
+    )
+    vae = vae.to(device)
+    assert len(ds) > 0, "folder does not contain any images"
+
+    # optimizer
+    opt = Adam(vae.parameters(), lr=args.learning_rate)
+    sched = ExponentialLR(optimizer=opt, gamma=args.lr_decay_rate)
+
+    model_config = dict(
+        num_tokens=dVAE_CFG.NUM_TOKENS,
+        smooth_l1_loss=dVAE_CFG.SMOOTH_L1_LOSS,
+        num_resnet_blocks=dVAE_CFG.NUM_RESNET_BLOCKS,
+        kl_loss_weight=dVAE_CFG.KL_LOSS_WEIGHT,
+    )
+
+    run = wandb.init(
+        project="DALLE-Couture", entity="happyface-boostcamp", config=model_config,
+    )
+
+    train()
+

From b5e3b335a94fb2a32a1ba9925f29af7aad45aa93 Mon Sep 17 00:00:00 2001
From: hyeonsookim <shawn.khs1208@gmail.com>
Date: Wed, 22 Dec 2021 16:58:55 +0900
Subject: [PATCH 13/26] update: clip final model

---
 clipmodel.py | 115 ++++++++-------------------------------------------
 1 file changed, 18 insertions(+), 97 deletions(-)

diff --git a/clipmodel.py b/clipmodel.py
index 2012d56..72dc604 100644
--- a/clipmodel.py
+++ b/clipmodel.py
@@ -1,43 +1,13 @@
 import torch.nn as nn
-from transformers import AutoTokenizer, RobertaConfig, RobertaModel
-import torch
+from transformers import RobertaModel, RobertaConfig
 import timm
-import torch.nn.functional as F
-from torch.utils.data import Dataset
-import albumentations as A
-from albumentations.pytorch import ToTensorV2
-from transformers import DistilBertModel
-import cv2
-import os
-
-os.environ["TOKENIZERS_PARALLELISM"] = "true"
-
-
-class CustomDataset(Dataset):
-    def __init__(self, texts, images):
-        self.tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert")
-        # self.tokenizer = AutoTokenizer.from_pretrained("klue/roberta-large")
-        self.texts = texts
-        self.images = images
-        self.transform = A.Compose([A.Resize(224, 224), ToTensorV2()])
-
-    def __getitem__(self, index):
-        t = self.texts[index]
-        single_im = cv2.imread(self.images[index])
-        single_im = cv2.cvtColor(single_im, cv2.COLOR_BGR2RGB)
-        # single_im = Image.open(images[index])
-        im = self.transform(image=single_im)["image"]
-        return t, im
-
-    def __len__(self):
-        return len(self.texts)
 
 
 class ImageEncoder(nn.Module):
-    def __init__(self, model_name, trainable):
+    def __init__(self, model_name, pretrained):
         super().__init__()
         self.model = timm.create_model(
-            model_name, pretrained=False, num_classes=0, global_pool="avg"
+            model_name, pretrained=pretrained, num_classes=0, global_pool="avg"
         )
         for p in self.model.parameters():
             p.requires_grad = True
@@ -46,28 +16,23 @@ def forward(self, x):
         return self.model(x)
 
 
-from transformers import DistilBertConfig
-
-
 class TextEncoder(nn.Module):
     def __init__(self, pretrained):
         super().__init__()
-        # if pretrained:
-        # config = DistilBertConfig.from_pretrained("monologg/distilkobert")
-        # config = RobertaConfig.from_pretrained("klue/roberta-large")
-        # self.model = RobertaModel(config)
-        # self.model = RobertaModel.from_pretrained("klue/roberta-large")
-        # self.model = DistilBertModel(config)
-        self.model = DistilBertModel.from_pretrained("monologg/distilkobert")
+        if pretrained:
+            self.model = RobertaModel.from_pretrained("klue/roberta-base")
+        else:
+            config = RobertaConfig.from_pretrained("klue/roberta-base")
+            self.model = RobertaModel(config)
 
         for p in self.model.parameters():
             p.requires_grad = True
         self.target_token_idx = 0
 
-    def forward(self, input_ids, attention_mask):
+    def forward(self, input_ids, token_type_ids, attention_mask):
         output = self.model(
             input_ids=input_ids,
-            # token_type_ids=token_type_ids,
+            token_type_ids=token_type_ids,
             attention_mask=attention_mask,
         )
         last_hidden_state = output.last_hidden_state
@@ -75,22 +40,13 @@ def forward(self, input_ids, attention_mask):
 
 
 class ProjectionHead(nn.Module):
-    def __init__(self, embedding_dim, projection_dim, dropout):
+    def __init__(self, embedding_dim, projection_dim):
         super().__init__()
         self.projection = nn.Linear(embedding_dim, projection_dim)
-        self.gelu = nn.GELU()
-        self.fc = nn.Linear(projection_dim, projection_dim)
-        self.dropout = nn.Dropout(dropout)
-        self.layer_norm = nn.LayerNorm(projection_dim)
 
     def forward(self, x):
         projected = self.projection(x)
-        x = self.gelu(projected)
-        x = self.fc(x)
-        x = self.dropout(x)
-        x = x + projected
-        x = self.layer_norm(x)
-        return x
+        return projected
 
 
 class CLIPModel(nn.Module):
@@ -98,55 +54,20 @@ def __init__(
         self,
     ):
         super().__init__()
-        # self.image_encoder = ModifiedResNet(
-        #    [3, 4, 6, 3], 0, 2048
-        self.image_encoder = ImageEncoder("resnet50", trainable=True)
-        # self.image_encoder = ImageEncoder("xcit_tiny_12_p8_224_dist", trainable=True)
+        self.image_encoder = ImageEncoder("efficientnet_b0", pretrained=False)
         self.text_encoder = TextEncoder(pretrained=True)
-        # self.image_projection = ProjectionHead(
-        #    embedding_dim=2048, projection_dim=268, dropout=0.1
-        # )
-        self.image_projection = ProjectionHead(
-            embedding_dim=2048, projection_dim=512, dropout=0.1
-        )
-        self.text_projection = ProjectionHead(
-            embedding_dim=768, projection_dim=512, dropout=0.1
-        )
-        self.temperature = 0.07
+        self.image_projection = ProjectionHead(embedding_dim=1280, projection_dim=512)
+        self.text_projection = ProjectionHead(embedding_dim=768, projection_dim=512)
 
     def forward(self, text, image):
-        # Getting Image and Text Features
         image_features = self.image_encoder(image)
         text_features = self.text_encoder(
             input_ids=text["input_ids"],
             attention_mask=text["attention_mask"],
-            # token_type_ids=text["token_type_ids"],
+            token_type_ids=text["token_type_ids"],
         )
-        # Getting Image and Text Embeddings (with same dimension)
+
         image_embeddings = self.image_projection(image_features)
         text_embeddings = self.text_projection(text_features)
 
-        # Calculating the Loss
-        # logits = (text_embeddings @ image_embeddings.T) * self.temperature
-
-        # targets = torch.arange(len(text_embeddings), device="cuda")
-        # tttt = F.log_softmax(logits, dim=1)
-        # texts_loss = nn.CrossEntropyLoss()(tttt, targets)
-        # images_loss = nn.CrossEntropyLoss()(tttt.T, targets.T)
-
-        # texts_loss = nn.CrossEntropyLoss()(logits, targets)
-        # images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
-
-        # images_similarity = image_embeddings @ image_embeddings.T
-        # texts_similarity = text_embeddings @ text_embeddings.T
-        # targets = F.softmax(
-        #    (images_similarity + texts_similarity) / 2 * self.temperature, dim=-1
-        # )
-        # targets = torch.arange(len(logits), device="cuda")
-        # texts_loss = cross_entropy(logits, targets, reduction="none")
-        # images_loss = cross_entropy(logits.T, targets.T, reduction="none")
-        # texts_loss = nn.CrossEntropyLoss()(logits, targets)
-        # images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
-        # loss = (images_loss + texts_loss) / 2.0  # shape: (batch_size)
-        return text_embeddings, image_embeddings
-        # return loss.mean()
+        return text_embeddings, image_embeddings
\ No newline at end of file

From 0a112d37fb2b1641301b40527e143f4ae0d88b90 Mon Sep 17 00:00:00 2001
From: hyeonsookim <shawn.khs1208@gmail.com>
Date: Wed, 22 Dec 2021 18:50:58 +0900
Subject: [PATCH 14/26] add: clip training files

---
 clipmodel.py => clip/clipmodel.py | 12 +++-
 clip/dataloader.py                | 44 ++++++++++++++
 clip/train_clip.py                | 96 +++++++++++++++++++++++++++++++
 3 files changed, 149 insertions(+), 3 deletions(-)
 rename clipmodel.py => clip/clipmodel.py (82%)
 create mode 100644 clip/dataloader.py
 create mode 100644 clip/train_clip.py

diff --git a/clipmodel.py b/clip/clipmodel.py
similarity index 82%
rename from clipmodel.py
rename to clip/clipmodel.py
index 72dc604..f2e6f9e 100644
--- a/clipmodel.py
+++ b/clip/clipmodel.py
@@ -56,8 +56,14 @@ def __init__(
         super().__init__()
         self.image_encoder = ImageEncoder("efficientnet_b0", pretrained=False)
         self.text_encoder = TextEncoder(pretrained=True)
-        self.image_projection = ProjectionHead(embedding_dim=1280, projection_dim=512)
-        self.text_projection = ProjectionHead(embedding_dim=768, projection_dim=512)
+        image_embedding_dim = list(self.image_encoder.parameters())[-1].shape[0]
+        text_embedding_dim = list(self.text_encoder.parameters())[-1].shape[0]
+        self.image_projection = ProjectionHead(
+            embedding_dim=image_embedding_dim, projection_dim=512
+        )
+        self.text_projection = ProjectionHead(
+            embedding_dim=text_embedding_dim, projection_dim=512
+        )
 
     def forward(self, text, image):
         image_features = self.image_encoder(image)
@@ -70,4 +76,4 @@ def forward(self, text, image):
         image_embeddings = self.image_projection(image_features)
         text_embeddings = self.text_projection(text_features)
 
-        return text_embeddings, image_embeddings
\ No newline at end of file
+        return text_embeddings, image_embeddings
diff --git a/clip/dataloader.py b/clip/dataloader.py
new file mode 100644
index 0000000..c81f1a2
--- /dev/null
+++ b/clip/dataloader.py
@@ -0,0 +1,44 @@
+from torch.utils.data import Dataset
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import cv2
+import os
+from tqdm import tqdm
+import re
+
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+
+
+class CLIPDataset(Dataset):
+    def __init__(self, texts, images):
+        self.texts = texts
+        self.images = images
+        self.transform = A.Compose([A.Resize(224, 224), ToTensorV2()])
+
+    def __getitem__(self, index):
+        t = self.texts[index]
+        single_im = cv2.imread(self.images[index])
+        single_im = cv2.cvtColor(single_im, cv2.COLOR_BGR2RGB)
+        im = self.transform(image=single_im)["image"]
+        return t, im
+
+    def __len__(self):
+        return len(self.texts)
+
+
+def get_dataset(text_path, image_path):
+    image_files = [
+        *image_path.glob("**/*[0-9].png"),
+        *image_path.glob("**/*[0-9].jpg"),
+        *image_path.glob("**/*[0-9].jpeg"),
+    ]
+    text_files = [*text_path.glob("**/*[0-9].txt")]
+    texts = []
+    print("Extracting text information!")
+    for i in tqdm(range(len(text_files))):
+        with open(text_files[i], "r", encoding="utf-8") as f:
+            te = f.read()
+            te = re.sub("스타일에서 스타일은 [가-힣]+.", "", te)
+            te = re.sub("에서", "", te)
+            texts.append(te)
+    return texts, image_files
diff --git a/clip/train_clip.py b/clip/train_clip.py
new file mode 100644
index 0000000..1be4335
--- /dev/null
+++ b/clip/train_clip.py
@@ -0,0 +1,96 @@
+from torch.utils.data import DataLoader
+from clipmodel import CLIPModel
+from transformers import AutoTokenizer
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+from torch.optim import AdamW
+import torch
+import torch.nn as nn
+import wandb
+from tqdm import tqdm
+import itertools
+from dataloader import CLIPDataset, get_dataset
+
+
+def train(train_paths, val_paths=None):
+    device = torch.device("cuda")
+    model = CLIPModel()
+    model = model.to(device)
+    text_path, image_path = train_paths
+    train_texts, train_images = get_dataset(text_path, image_path)
+
+    train_dataset = CLIPDataset(train_texts, train_images)
+    train_dl = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
+
+    if val_paths:
+        val_texts, val_images = get_dataset(text_path, image_path)
+        val_dataset = CLIPDataset(val_texts, val_images)
+        val_dl = DataLoader(val_dataset, batch_size=8, shuffle=False)
+    num_epochs = 100
+    params = [
+        {"params": model.image_encoder.parameters(), "lr": 4e-5},
+        {"params": model.text_encoder.parameters(), "lr": 4e-5},
+        {
+            "params": itertools.chain(
+                model.image_projection.parameters(), model.text_projection.parameters()
+            ),
+            "lr": 5e-5,
+        },
+    ]
+
+    optimizer = AdamW(params, weight_decay=0.2, betas=(0.9, 0.98), eps=1e-6)
+    scheduler = ReduceLROnPlateau(optimizer, "min")
+    tokenizer = AutoTokenizer.from_pretrained("klue/roberta-base")
+    total_vloss = int(1e9)
+    scaler = torch.cuda.amp.GradScaler()
+
+    wandb.init(project="KoCLIP", entity="happyface-boostcamp")
+    wandb.run.name = "dev"
+
+    for i in range(num_epochs):
+        print(f"Epochs: {i+1}")
+        epoch_loss = 0
+        model.train()
+        wandb.log({"Epochs": i + 1})
+        for steps, batch in enumerate(tqdm(train_dl)):
+            text, image = batch
+            text = tokenizer(
+                list(text),
+                padding=True,
+                pad_to_max_length=True,
+                max_length=128,
+                truncation=True,
+                return_tensors="pt",
+            )
+            text = text.to(device)
+            image = image.float()
+            image = image.to(device)
+            optimizer.zero_grad()
+
+            text_embeddings, image_embeddings = model(text, image)
+            logits = text_embeddings @ image_embeddings.T * 0.07
+            targets = torch.arange(len(text_embeddings), device="cuda")
+
+            texts_loss = nn.CrossEntropyLoss()(logits, targets)
+            images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
+
+            loss = (images_loss + texts_loss) / 2.0
+
+            if (steps + 1) % 100 == 0 and steps > 100:
+                print(f"Epoch {i}, step {steps+1}, Loss: {loss}")
+                wandb.log({"Loss": loss.item()})
+            epoch_loss += loss.item()
+            scaler.scale(loss).backward()
+            scaler.step(optimizer)
+            scaler.update()
+
+        print(f"Epoch Loss: {epoch_loss / len(train_dl)}")
+        # wandb.log({"Epoch": i, "Epoch Loss": epoch_loss / len(train_dl)})
+        # vloss = evaluate(model, val_dl)
+        # wandb.log({"Val Loss": vloss})
+        # if vloss < total_vloss:
+        #    total_vloss = vloss
+        #    torch.save(model, "fashionclip_fn2.pt")
+        #    print(f"Model saved. Current best val loss {total_vloss}")
+        scheduler.step(epoch_loss)
+        # print(f"Best Val Loss: {total_vloss}")
+    # wandb.finish()

From 0761b8377b547e9402cfe766ffa10820b81f1981 Mon Sep 17 00:00:00 2001
From: hyeonsookim <shawn.khs1208@gmail.com>
Date: Wed, 22 Dec 2021 22:38:43 +0900
Subject: [PATCH 15/26] add: README

---
 clip/README.md     | 1 +
 clip/dataloader.py | 2 --
 2 files changed, 1 insertion(+), 2 deletions(-)
 create mode 100644 clip/README.md

diff --git a/clip/README.md b/clip/README.md
new file mode 100644
index 0000000..682b96f
--- /dev/null
+++ b/clip/README.md
@@ -0,0 +1 @@
+### CLIP
\ No newline at end of file
diff --git a/clip/dataloader.py b/clip/dataloader.py
index c81f1a2..a4daad3 100644
--- a/clip/dataloader.py
+++ b/clip/dataloader.py
@@ -6,8 +6,6 @@
 from tqdm import tqdm
 import re
 
-os.environ["TOKENIZERS_PARALLELISM"] = "true"
-
 
 class CLIPDataset(Dataset):
     def __init__(self, texts, images):

From 447d2ff91d3eb6b267133dc8a2115a322079ea59 Mon Sep 17 00:00:00 2001
From: Joonhong-Kim <danielkim30433@gmail.com>
Date: Wed, 22 Dec 2021 14:04:30 +0000
Subject: [PATCH 16/26] sty)tutorial

---
 generate.ipynb | 68 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 48 insertions(+), 20 deletions(-)

diff --git a/generate.ipynb b/generate.ipynb
index f6f5f00..8a7047f 100644
--- a/generate.ipynb
+++ b/generate.ipynb
@@ -1,5 +1,12 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to generate Image with our dall-e model"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -33,9 +40,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# 생성하고싶은 이미지의 설명\n",
     "raw_text = \"아우터는 색상이 브라운 소재가 우븐 핏이 노멀인 재킷이다. 하의는 색상이 블랙 소재가 우븐 핏이 노멀인 팬츠이다.\""
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Settings"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -43,6 +58,7 @@
    "outputs": [],
    "source": [
     "from easydict import EasyDict\n",
+    "DALLE_PATH = '/opt/ml/DALLE-pytorch/dalle.pt'\n",
     "\n",
     "DALLE_CFG = EasyDict()\n",
     "\n",
@@ -51,22 +67,15 @@
     "DALLE_CFG.VQGAN_PATH = \"/opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/checkpoints/VQGAN_blue.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
     "DALLE_CFG.VQGAN_CFG_PATH = \"/opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/configs/VQGAN_blue.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
     "DALLE_CFG.DALLE_PATH = \"/opt/ml/DALLE-pytorch/dalle.pt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
-    "DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n",
-    "DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n",
-    "DALLE_CFG.BPE_PATH = None\n",
-    "DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n",
     "\n",
-    "# DALLE_CFG.EPOCHS = 20\n",
-    "# DALLE_CFG.BATCH_SIZE = 54\n",
-    "DALLE_CFG.LEARNING_RATE = 3e-4\n",
-    "DALLE_CFG.GRAD_CLIP_NORM = 0.5\n",
+    "DALLE_CFG.WPE_PATH = \"/opt/ml/DALLE-pytorch/roberta_large_wpe.pt\"\n",
+    "DALLE_CFG.WTE_PATH = \"/opt/ml/DALLE-pytorch/roberta_large_wte.pt\"\n",
     "\n",
     "# DALLE_CFG.MODEL_DIM = 512\n",
     "DALLE_CFG.TEXT_SEQ_LEN = 128\n",
-    "DALLE_CFG.DEPTH = 12\n",
-    "DALLE_CFG.HEADS = 8\n",
-    "DALLE_CFG.DIM_HEAD = 64\n",
-    "DALLE_CFG.REVERSIBLE = True"
+    "\n",
+    "# Top-k level\n",
+    "DALLE_CFG.TOP_K=5"
    ]
   },
   {
@@ -99,11 +108,9 @@
     }
    ],
    "source": [
-    "# import from huggingface transformers\n",
     "from transformers import AutoTokenizer\n",
     "  \n",
     "tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n",
-    "# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")\n",
     "\n",
     "encoded_dict = tokenizer(\n",
     "    raw_text,\n",
@@ -119,6 +126,13 @@
     "attention_mask = encoded_dict[\"attention_mask\"]"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load Model"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -141,10 +155,10 @@
     "\n",
     "DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n",
     "\n",
-    "dalle_path='/opt/ml/DALLE-pytorch/dalle.pt'\n",
-    "#assert dalle_path.exists(), 'DALL-E model file does not exist'\n",
+    "DALLE_PATH\n",
+    "assert DALLE_PATH.exists(), 'DALL-E model file does not exist'\n",
     "\n",
-    "loaded_obj = torch.load(dalle_path, map_location=torch.device('cuda'))\n",
+    "loaded_obj = torch.load(DALLE_PATH, map_location=torch.device('cuda'))\n",
     "\n",
     "dalle_params, _ , weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n",
     "\n",
@@ -195,6 +209,13 @@
     "dalle_params"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Image generate"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -226,13 +247,13 @@
     "\n",
     "dalle = DALLE_Klue_Roberta(\n",
     "    vae = vae, \n",
-    "    wte_dir=\"/opt/ml/DALLE-pytorch/roberta_large_wte.pt\",\n",
-    "    wpe_dir=\"/opt/ml/DALLE-pytorch/roberta_large_wpe.pt\",\n",
+    "    wte_dir=DALLE_CFG.WTE_PATH,\n",
+    "    wpe_dir=DALLE_CFG.WPE_PATH,\n",
     "    **dalle_params\n",
     "    )\n",
     "dalle.load_state_dict(weights)\n",
     "dalle.to('cuda')\n",
-    "input_ids=repeat(input_ids,'() n -> b n',b=5)\n",
+    "input_ids=repeat(input_ids,'() n -> b n',b=DALLE_CFG.TOP_K)\n",
     "#print(input_ids)\n",
     "#print(input_ids.shape)\n",
     "#raw_text=raw_text.to('cuda')\n",
@@ -243,6 +264,13 @@
     "#images.shape # (4, 3, 256, 256)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Display Image"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 9,

From 8c1ca5f38b541f97b853cbf85e1a2c82479682a0 Mon Sep 17 00:00:00 2001
From: hyeonsookim <shawn.khs1208@gmail.com>
Date: Thu, 23 Dec 2021 23:42:07 +0900
Subject: [PATCH 17/26] edit: train file

---
 clip/dataloader.py |   1 -
 clip/train_clip.py | 118 +++++++++++++++++++++++++++++++--------------
 2 files changed, 83 insertions(+), 36 deletions(-)

diff --git a/clip/dataloader.py b/clip/dataloader.py
index a4daad3..c76d810 100644
--- a/clip/dataloader.py
+++ b/clip/dataloader.py
@@ -2,7 +2,6 @@
 import albumentations as A
 from albumentations.pytorch import ToTensorV2
 import cv2
-import os
 from tqdm import tqdm
 import re
 
diff --git a/clip/train_clip.py b/clip/train_clip.py
index 1be4335..a653810 100644
--- a/clip/train_clip.py
+++ b/clip/train_clip.py
@@ -9,23 +9,45 @@
 from tqdm import tqdm
 import itertools
 from dataloader import CLIPDataset, get_dataset
+import argparse
 
 
-def train(train_paths, val_paths=None):
-    device = torch.device("cuda")
-    model = CLIPModel()
-    model = model.to(device)
-    text_path, image_path = train_paths
-    train_texts, train_images = get_dataset(text_path, image_path)
+def calculate_loss(text_embeds, image_embeds, temperature=0.07):
+    logits = text_embeds @ image_embeds.T * temperature
+    targets = torch.arange(len(text_embeds), device="cuda")
 
-    train_dataset = CLIPDataset(train_texts, train_images)
-    train_dl = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
+    texts_loss = nn.CrossEntropyLoss()(logits, targets)
+    images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
 
-    if val_paths:
-        val_texts, val_images = get_dataset(text_path, image_path)
-        val_dataset = CLIPDataset(val_texts, val_images)
-        val_dl = DataLoader(val_dataset, batch_size=8, shuffle=False)
-    num_epochs = 100
+    t_loss = (images_loss + texts_loss) / 2.0
+    loss = t_loss.mean()
+    return loss
+
+
+def evaluate(model, val_dl, tokenizer):
+    val_loss = 0
+    with torch.no_grad():
+        model.eval()
+        for step, batch in enumerate(tqdm(val_dl)):
+            text, image = batch
+            text = tokenizer(
+                list(text),
+                padding=True,
+                pad_to_max_length=True,
+                max_length=128,
+                truncation=True,
+                return_tensors="pt",
+            )
+            text = text.to(model.device)
+            image = image.float()
+            image = image.to(model.device)
+            loss = model(text, image)
+            val_loss += loss
+    print(f"Val Loss: {val_loss / len(val_dl)}")
+    return val_loss / len(val_dl)
+
+
+def get_optimizer(model):
     params = [
         {"params": model.image_encoder.parameters(), "lr": 4e-5},
         {"params": model.text_encoder.parameters(), "lr": 4e-5},
@@ -36,16 +58,28 @@ def train(train_paths, val_paths=None):
             "lr": 5e-5,
         },
     ]
-
     optimizer = AdamW(params, weight_decay=0.2, betas=(0.9, 0.98), eps=1e-6)
+    return optimizer
+
+
+def train(model, device, train_paths, val_paths=None, num_epochs=100):
+    model = model.to(device)
+    text_path, image_path = train_paths
+    train_texts, train_images = get_dataset(text_path, image_path)
+
+    train_dataset = CLIPDataset(train_texts, train_images)
+    train_dl = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
+    if val_paths:
+        val_texts, val_images = get_dataset(text_path, image_path)
+        val_dataset = CLIPDataset(val_texts, val_images)
+        val_dl = DataLoader(val_dataset, batch_size=8, shuffle=False)
+
+    optimizer = get_optimizer(model)
     scheduler = ReduceLROnPlateau(optimizer, "min")
     tokenizer = AutoTokenizer.from_pretrained("klue/roberta-base")
     total_vloss = int(1e9)
     scaler = torch.cuda.amp.GradScaler()
 
-    wandb.init(project="KoCLIP", entity="happyface-boostcamp")
-    wandb.run.name = "dev"
-
     for i in range(num_epochs):
         print(f"Epochs: {i+1}")
         epoch_loss = 0
@@ -67,30 +101,44 @@ def train(train_paths, val_paths=None):
             optimizer.zero_grad()
 
             text_embeddings, image_embeddings = model(text, image)
-            logits = text_embeddings @ image_embeddings.T * 0.07
-            targets = torch.arange(len(text_embeddings), device="cuda")
-
-            texts_loss = nn.CrossEntropyLoss()(logits, targets)
-            images_loss = nn.CrossEntropyLoss()(logits.T, targets.T)
-
-            loss = (images_loss + texts_loss) / 2.0
+            loss = calculate_loss(text_embeddings, image_embeddings)
 
             if (steps + 1) % 100 == 0 and steps > 100:
-                print(f"Epoch {i}, step {steps+1}, Loss: {loss}")
-                wandb.log({"Loss": loss.item()})
+                print(f"Epoch {i}, step {steps+1}, Loss: {loss.item()}")
             epoch_loss += loss.item()
             scaler.scale(loss).backward()
             scaler.step(optimizer)
             scaler.update()
 
         print(f"Epoch Loss: {epoch_loss / len(train_dl)}")
-        # wandb.log({"Epoch": i, "Epoch Loss": epoch_loss / len(train_dl)})
-        # vloss = evaluate(model, val_dl)
-        # wandb.log({"Val Loss": vloss})
-        # if vloss < total_vloss:
-        #    total_vloss = vloss
-        #    torch.save(model, "fashionclip_fn2.pt")
-        #    print(f"Model saved. Current best val loss {total_vloss}")
+        if val_paths:
+            vloss = evaluate(model, val_dl)
+            if vloss < total_vloss:
+                total_vloss = vloss
+                torch.save(model, "clip.pt")
+                print(f"Model saved. Current best val loss {total_vloss}")
         scheduler.step(epoch_loss)
-        # print(f"Best Val Loss: {total_vloss}")
-    # wandb.finish()
+
+
+if __name__ == "__main__":
+    device = torch.device("cuda:0" if (torch.cuda.is_available()) else "cpu")
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--image_folder",
+        type=str,
+        default="/opt/ml/DALLE-Couture/data/cropped_train_img",
+        help="",
+    )
+    parser.add_argument(
+        "--text_folder",
+        type=str,
+        default="/opt/ml/DALLE-Couture/data/train_label",
+    )
+    args = parser.parse_args()
+    model = CLIPModel()
+    train_paths = [args.text_folder, args.image_folder]
+    train(
+        model,
+        device,
+        train_paths=train_paths,
+    )

From 093a21e693520c8b15502d0136082e46967ed66e Mon Sep 17 00:00:00 2001
From: hyeonsookim <shawn.khs1208@gmail.com>
Date: Thu, 23 Dec 2021 23:43:59 +0900
Subject: [PATCH 18/26] edit: train file

---
 clip/train_clip.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clip/train_clip.py b/clip/train_clip.py
index a653810..c50f19b 100644
--- a/clip/train_clip.py
+++ b/clip/train_clip.py
@@ -112,7 +112,7 @@ def train(model, device, train_paths, val_paths=None, num_epochs=100):
 
         print(f"Epoch Loss: {epoch_loss / len(train_dl)}")
         if val_paths:
-            vloss = evaluate(model, val_dl)
+            vloss = evaluate(model, val_dl, tokenizer)
             if vloss < total_vloss:
                 total_vloss = vloss
                 torch.save(model, "clip.pt")

From 513b837fcb0f64a10a721016cdde366bbe7a70e2 Mon Sep 17 00:00:00 2001
From: hyeonsookim <shawn.khs1208@gmail.com>
Date: Thu, 23 Dec 2021 23:45:45 +0900
Subject: [PATCH 19/26] edit: evaluation function

---
 clip/train_clip.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/clip/train_clip.py b/clip/train_clip.py
index c50f19b..fea3116 100644
--- a/clip/train_clip.py
+++ b/clip/train_clip.py
@@ -41,7 +41,8 @@ def evaluate(model, val_dl, tokenizer):
             text = text.to(model.device)
             image = image.float()
             image = image.to(model.device)
-            loss = model(text, image)
+            text_embeds, image_embeds = model(text, image)
+            loss = calculate_loss(text_embeds, image_embeds)
             val_loss += loss
     print(f"Val Loss: {val_loss / len(val_dl)}")
     return val_loss / len(val_dl)

From dcaf9f7d9942b121ca1a37e06a5802d9746dbe12 Mon Sep 17 00:00:00 2001
From: Hyeon Soo Kim <64349347+shawnhyeonsoo@users.noreply.github.com>
Date: Fri, 24 Dec 2021 16:08:55 +0900
Subject: [PATCH 20/26] edit: model.py

modify clip tokenizer in function generate_images
---
 model.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/model.py b/model.py
index 871aef1..efcd398 100644
--- a/model.py
+++ b/model.py
@@ -462,7 +462,7 @@ def generate_images(
         if exists(clip):
             from transformers import AutoTokenizer
 
-            clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
+            clip_tokenizer = AutoTokenizer.from_pretrained("klue/roberta-base") # clip에 사용된 tokenizer
             input_text = clip_tokenizer(
                 raw_text,
                 padding=True,

From 17d151aab338943af0c33ef57fcea90e551caeb0 Mon Sep 17 00:00:00 2001
From: JoonHong-Kim <danielkim30433@gmail.com>
Date: Sun, 26 Dec 2021 16:44:47 +0900
Subject: [PATCH 21/26] sty)generate_images_clip

---
 dalle/models.py | 24 +++++++++---------------
 model.py        | 20 +++++++-------------
 2 files changed, 16 insertions(+), 28 deletions(-)

diff --git a/dalle/models.py b/dalle/models.py
index 3ef2f49..62cb2ba 100644
--- a/dalle/models.py
+++ b/dalle/models.py
@@ -13,20 +13,7 @@
 from dalle_pytorch.attention import stable_softmax
 from utils import *
 
-# discrete vae class
-class ResBlock(nn.Module):
-    def __init__(self, chan):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Conv2d(chan, chan, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(chan, chan, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(chan, chan, 1),
-        )
 
-    def forward(self, x):
-        return self.net(x) + x
 
 
 class DALLE_Klue_Roberta(nn.Module):
@@ -201,6 +188,7 @@ def generate_images(
         img=None,
         num_init_img_tokens=None,
     ):
+        origin_text=text
         vae, text_seq_len, image_seq_len, num_text_tokens = (
             self.vae,
             self.text_seq_len,
@@ -256,8 +244,14 @@ def generate_images(
         images = vae.decode(img_seq)
 
         if exists(clip):
-            scores = clip(text_seq, images, return_loss=False)
-            return images, scores
+            #from transformers import AutoTokenizer
+
+            #clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
+            #origin_text
+            #input_text = input_text.to("cuda")
+            text_embeds, image_embeds = clip(origin_text, images)
+            logits = (text_embeds @ image_embeds.T)
+            return images, logits
 
         return images
 
diff --git a/model.py b/model.py
index 871aef1..6ca3810 100644
--- a/model.py
+++ b/model.py
@@ -408,6 +408,7 @@ def generate_images(
         num_init_img_tokens=None,
         raw_text=None,
     ):
+        origin_text = text
         vae, text_seq_len, image_seq_len, num_text_tokens = (
             self.vae,
             self.text_seq_len,
@@ -460,19 +461,12 @@ def generate_images(
         images = vae.decode(img_seq)
         print(images.shape)
         if exists(clip):
-            from transformers import AutoTokenizer
-
-            clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
-            input_text = clip_tokenizer(
-                raw_text,
-                padding=True,
-                pad_to_max_length=True,
-                max_length=128,
-                truncation=True,
-                return_tensors="pt",
-            )
-            input_text = input_text.to("cuda")
-            text_embeds, image_embeds = clip(input_text, images)
+            #from transformers import AutoTokenizer
+
+            #clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
+            #origin_text
+            #input_text = input_text.to("cuda")
+            text_embeds, image_embeds = clip(origin_text, images)
             logits = (text_embeds @ image_embeds.T)
             return images, logits
 

From 856ffcfdb4b06af9cb7bd07fb81c3e79ed785858 Mon Sep 17 00:00:00 2001
From: noopy <young_ahn@yonsei.ac.kr>
Date: Sun, 26 Dec 2021 17:06:28 +0900
Subject: [PATCH 22/26] remove: text generation function

---
 clip_reranking_example.ipynb |  13 +++--
 dalle/models.py              |  69 +++-------------------
 model.py                     | 108 ++++++++++++++---------------------
 3 files changed, 57 insertions(+), 133 deletions(-)

diff --git a/clip_reranking_example.ipynb b/clip_reranking_example.ipynb
index bc2d4c5..1f4d4c5 100644
--- a/clip_reranking_example.ipynb
+++ b/clip_reranking_example.ipynb
@@ -19,7 +19,8 @@
     "import cv2 \n",
     "import matplotlib.pyplot as plt\n",
     "from tqdm import tqdm\n",
-    "from PIL import Image"
+    "from PIL import Image\n",
+    "import torch"
    ]
   },
   {
@@ -201,7 +202,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -220,7 +221,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -239,7 +240,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAH8AAAD8CAYAAABemXtlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAACLI0lEQVR4nOz9abBlWXbfh/3W3vtMd3jzy7mmrq6qnoFuNBogQEEgIIsESAmQzEmUCZJBm+EISSGGHbZkf/IHO0L+YlsKR0jBsK0gHXQwGLQcpCxSEgWSpjiAZKNBAkQDje6u7q45K4c33OEMe1j+sM+972VWZlY2hmCWgFVx692877x7z91rD2v4r/8SVeV35LenmH/RN/A78i9Ofkf5v43ld5T/21h+R/m/jeV3lP/bWH5H+b+N5bdE+SLy+0TkayLyDRH5D38rPuN35Dcu8pvt54uIBX4N+B8BbwH/BPi3VPWrv6kf9DvyG5bfipX/JeAbqvq6qg7AXwJ+6rfgc35HfoPifgve8ybw5qV/vwX8wMMXicifAf4MwHQy+b5XXn118xs0Bpb37rA+P0GsEEIChZ29fcQY2vUa3w+EFAkpIoAxgoiAKpAQEZJCSImYQBMkBUVBBWdg3lTMdnYoqpI0BIah53xxzu7+AZPpDqYscc6hKiD57pT8VFU3LwGQUkRTwjrHZk0J+fNU8yOlxNC1LM5OaFcrhhCJmu8rjwlYa5Dt3+bPsQJNXVGVFa4oKYoSsQZQYogkVWxR4FyBa+o8higo/PN//st3VfX4UYr6rVD+U4mq/jngzwF8/vPfq3/nb/8tUINq4uTNr/Hl/+KvsH7/W9y+8wZvvfU2n/7UFzi69hz1pOE7v/ZrfONrX6cl4KoCKzB0LV27QlVpCkOIyv1Vz51Vy6JTgtQMfaLQwNFeyZe+9xP8xO//N3jt81+iqhz/9Gf/W77yt/9bUlPxE//Wz3D84ic4uPExMI6EIYlgBBDJigwBo4oRYd2u6bs1850diqIGLFl1jEqPhOBpu56+77j/3tv8ys//Pf7hP/gHfOtbr3P/5JzVoCxXK8race1wl8ZCjIG+a3nu6jGffuXjHB9d4/DaCxzdegFTF2gM3H7rLWxTs3N0jcnsgKNPvEpRVCRVNCVefOW17zxOB78Vyn8beO7Sv2+Nrz2VKIKbznjti1/kV//BksU3v8He/lU++YUvUk/3Wdy/y97xMeuvf41l31MGT2kNpbM0dYMxhjD03F8sub8OtKEkpEDneypreel4jy99/lX+lZ/+N3n18/8y8/kB3/6lf8LXfvEX2J01fPwHfjd7z73MzrUbGGtRDEbyKiPFfI8pocETYqTrOwRhvrePKSoEgxEhkVd6niwC1uKcQaVm7+aLfO+k4cbHXuM7X/8qX/3n/5xvfftNvvXmm9w5OWe57rhy8yqFKKWFV19+hb3ZjNneAZO9A+qdXXwKpJjwfWD3cAIxUbmC6CPWCehm/3i8/FYo/58Ar4jIS2Sl/1Hgj334n+VtW4yl3r/O8Yuev//f/A2ih9/9wz/K8QuvUe8eouZ1vvLPfpk3754RRTmaTimKgpCUEA0heBbLjrtrz2kvnHcRq5GdxnLtYMYPff9n+Ymf/P3c+r7fQ717ncXb3+Hv/5f/Hw6njquf+T4+9cO/h/rmy0hRkxTE5AHUpEhKqCZQxQ8DkhLTuqEoCrSoiGJHZae8ZY97t4qQxCCScAQKA2m2x/EtQ9FM2D++zse+8zq/+NWv8ou//FXQxLVbz1Fb2JlUHF99jhQC5XyPancfV0+xElm0LSkmJpMZgwpl6UgxkMSgoqjGJ474b7ryVTWIyL8L/Dfk/e//oaq//OS/kvEwVUwKTDG05ZzvvPUuz7/8PC9/9jNU0ytMp3vwnPAr33yX9SLiJoZuGNDU40wJNNw/b3nvpOWki3gMhTFMC8fxvOIzr77I7/5XfpJb3/NjzHaPOb/9bf7Z3/h/cWvuKZ57hVd/9+9nevVlKCY4gaSSb0sEawxGSkIIoImqnGCMwVqHMUJCMJvznXzqy3j2qio2JRIFCUE04Iylqhpm8z2SjzhbsHt4xLWrh5iUmE0qYhyYNDtMd/dZL86YTRr25lOcKwk60PctRWUxzRTTt7jKIj5iVYkkJK2fOOq/JWe+qv514K8//R9cei6ANYg1zHZ2kEIwzYxeexrx3D69y8IvGMISuoKuMPSmZrkM3L39JomAojgjlNZQCRzPS164ccyP/MiP8+rnvoTdbVi++zqLr36Z+cxSvfz9vPiZH6Q5fglcjaohqUFM/MBtGmtQa7LBJ9kQTOPcZVQ85NX+sBhjcM7l4wDd/rusaqpmzp4t+MxnJ5zcuYuzSog902aXSV3huzWzvX3q2Q5iS1Lb06/WTKdTEIsRixGHpoSEgUIU/PDEYf8XZvA9KHl1GJOt5AS4quSH/qUf5u//138VbTsmOwdMZjt8/JVP87t/94/w3y3vsVp73j/vuLs6gQh7zjGZTBjCQNKEGItoYn/e8IlPfoqPf+bzFM2UtGoJy/ukEm59+vuYP/9Jir0jQjHBasKSSCJbyz7fYd7GFSGlxEa36dJ32MiTTlqRfLx5n3cQEcEVFlsaQhDmu/usli3er2nmu0yne9jkKYqS+d4h6rI1LyHSL9dcu3mVFJWiqLHWEQETBgwJ5/0TR/3ZCe8KjI4RqgFXGL7vB36IV1/7DL/4c/+QKg6UZcXu3lX+7T/2J/ns93wf95drTvtISoYrh/tcv7LL0V7NwazgcHeGNYamrjnYP+CVT3yW+fE1yrqkjNnFmr/8aXZe+hyTneuYsgEBEQVifuiFm5a386xgMZLP9s3joa+SXbT8pfKPjQEYUU0YZ/ChJ8VATAFxBiyY0hKjZzqfYkSpJhXldEqKUJY1zWSGsSWgrM9P6Ps1s509og8URQUiCAlCi0ue2jzZ4Ht2lE8CUUQ0n5QC1eF1fvwP/gzPf+ozfOubv8btd9+g9T27x9f40R//fUxnU1ThcDbncDYjGEc132e+s0/lagyWeVNw7epVXnjx4+zsHpLEEJ2wd/UW84PnKHcOoXTYZKiSYpIAFrmk0a3yR4dcNjaKKjzk72//BiWxiS0ISSMpBDRGXGGJsYPkUU1EEbAlzhUMQ8+krqnFMp3OMMUE3ynNZAfjHEYVDYE7d99lZ38HN50T/YArC1TAOShsonKKsU9W7zOy7eftEEBUkGiJ4kilobl1k89c+b04VVRKEAcC3/dDP8K/9KM/zv/3v/yvqCyslguCRqpiQukmrIdzUGVSOq5cvcL+tatIVSOiFJM5FgNliS0K0rh3byLdm5D30wa+Hx0iH61+1bxTJCX5gHUWK4Y4eJJRUogYoLSOQXs0KmITosKknpEwLM5Puf7CJ4liMQb80BOj4eYLzxGzZUlZllhrcc5hbXYzRdMj7utCnhnlbwdQQAkYiRhRRCxa7RF1dLWiJ2Jo9o/4mT/1P+Wtb7/Ot772a/gIQZTVasnKlZyvzpkWidoZdvZ2KWYztCxxotkwwmELQ0pKSuQAzqWt/WF1ykMG3ObflxV/8Vp+h83vDIJRCIOnsA6LEH1ArZB8AGuoXEE7eErn8H1HaR2xT1RTh5HIwfEVonVo9JSFw9qa3YMr3GnPKIqCsiwREYwxaPLEGAkfYvA9E9v+Zvjy4Gl2+RSsGoxYrFgslmwYZIUJhhdefIU/+2f/V7z66mvEFPFecyRtvcL7AWNgWpfs7hxhpMSIRVwJrkAKi1hHSjpqS8cz/0LJ8oQHl+55+9jeoWJUEdVNoJWE4KMfw7KW2HekFEGhMJaqLEjBUxWOfrmiqCvWqyVCZH58BVNWJE1gDbEdmFVTUlESFwPTqsG5AmMUIVxEFX3/xHF/JpR/WZQcnTJqAYuKQUSxJMw4tEYFSYp1JS+9+in+jT/0R6ibCc5a0IRJA5U1WCkordCUDYUpsRh0nEQigqZESlk5ij614h8VO/vA70flZ0Mxeweq2Q1NMZGGHjSCJqwxFM6SUqIoHDGEvH2j+L7j8PoNElBYQ0Rp12sOjw/xISBDYjqZYqzLoxcDJir4AOGjYu1zkSzZ+M95KW5+Kw/8gOw3l5Mpn/me7+fWrRcpS0NpE5ULVFZpXI0JCdEekYhiEPKkErHEmEaf+7fgu/DgkWCF7NqlSAqe5AdSGCBFrAhiDCKQUiKmRLtY4SJojOzt72+DTSlF+tDTXNkhrJbgBFPXqLGIOEigIaEhXmSMHiPPlPIfFlW9dPjm9SmM59q4qmxZsXd4lR/7sX8VK0pplFljqJ1Qm5LY9tx+9036fj0OoBkfNm/5XGzdD3z2ox6q2+cP3eiFtfio3wNCGhXuScGjKVv+RnLKURCKsiSGiLGGd99+m0IlZ/KcwxhD3/dYY3G1wxfQLRbUsxopS7Bu+73UChQW11RPHN9nTvn5fFTSOKBW802qGDDmItY+pkgxiXLW8GM/+fv4wpe+CDGyMznicP+QmM6JGljcfZ/Fe7eRwefzeEzS6KVVL6PPnvig8h6eBBsxbMK4bO/p4rGJWAuiQrSW5BPae/q+RYOSkpBMSZIC1FBXDX3fIyK8/867aGGp6ooYIzpGBL33zPYOiIsVPvQ0kykUFpGAJWAlUhqYTKbM9x6ZyX3g/p9ZuThD5dKuP7qEIsQYiR6MLTi6eoP/yZ/8n/PxT3yW0AfKMHA8K5jPaowznLcnqOkRAhCIsSOlgLV2G1ncrl6R7eOysrfPx989vFtclhzU2cQFxr9JkTT0dOs1KeaAjyA5/YpQ1TW9HyjrnJJNKIP3GCMM/cCkbtAQmUwmnJ+cYquKop6MkciEcwZnDaW1lK7E2OKJ4/tMuXo5xDsOPGzdrocln3151cagSKGYsuSlVz/HT/ybf4Sv/v2/iz+9S1k7Dq9d4dXv/Tw3P/4JirpiE72JMcBo5G2VuAWDPFqepOwPfqEHv5cVxRlIwdO2awwJjQGjCdVIUIMtCkJKNHXFZDYjokTNQJZJXUNM1GXFarlguV5z/eYLFM0cVxqMKNaCE8GJYJxFrH3iLT4zyofNmSqYETCRd3595KBba0c9eULscYXDNQ2f//7fRff++6zun/DCa5/kxmsvs3/tFs18HyP1uB0rKZoL9M8jZIOk2f7+8qR4KAi0XdmwDezomM/f/L1RsCIMfcvy/AzRHLPQ5NFUElNOZok1KLB/dEDURD2ZYMRQVxV93xOGgfV6xfGVKxwcX4VqhrMRowFrNPv4qhATwpNTus/Mtq8qqBgSFlWL6sXq3qxOY8zW2NsmVzSRfEKiwRlhsn/Ia5/5Xigqdq9eZe/WCxSH1zDNnGzlCzFEVDN24PI5b8gKMuNnbp/ziGTNxgBIIAmIaVT85pcub/3jc+NLsAXD0NLdu0NUcM7i1GPiGqsdpYObz91kd2+H4xevYgqD1URd1cSQiFE5PTvn6Pp1rj//MYpqQimGIgZEYwaRhMTgPWkYiMOT/fxnaOU/EDrBiCGOkSpr7EX41+RVH0LYZgK99wzDQF3XWFdw4+VX+PLPf5m+bZEUMSb/naAkTSSNGLtdrONHXmz5H9gN9NLZ/QHZWPoCyYz5KYMkRVLMuYoYScnTzCZI6tg72mfvYIItCnyKhJRnkiss02tXSNFz/eoxwxBISWn7cxBD13Zcu3JAZScMfSTZFWIEJ0rROLwkoh9I6yUYCx+V2P5WNsevyVu/9x5n3dYoU83Kcc7R93lmO+cIIeDH8Knb3eO17/0CJ++8Reo6bE6xgCiaIpCw1sL4Gduw7EO3sjmvH32f47LXHBk0mLzOVXPmTgccHUYFDYGkkWZeUdYHNPMZkroRcJEwwTO0HT4ouAI1FrUGXPZMhC4nnLozvvPm6zTTQ4ppw3R/j2LSUE/nCEIMgRg8y5O7+LYjfFRi+5uhFx23WWMoq5K2bRmGgaqqRnfsQhlFUdD1+VxzzhFTzKvbFnz8k5/mK+++jV+vERJic/BjY+hBnggil3aVS6DLh29NxxjDNsc/5gKyXa9oGkAvMkRGBqzz44YSUbGkBMkIUhZoH0kpYqxQYFDbE0NCNOTrxsFQIsRA7Abi8pyzd99kWbxDs7vHannIi698kqYoUVFizDvg2fKc2++8w6r9F4Dk+XWJAjHDlI0YVBLGOZrphDgEwhjy3Gbcxp9FVeaoWIyEkIGatJ5CHDtXrrG6f86ejgpPQlKLsQ4ds27WmtHA3LiUWb2qCVLabvUP+/KoktQDEdWAxJAjdZJjiFmKrZ1oDAgOJBHwDKo58SIxHz/WEvohp41Nwph8hMQIQQM+9Nw9ucN777/Lwd4MykiqhGZSkgqLGYEhXYjEokZ2duGjc+ZnURjNUJPPe2upapet57znI2aTAxi3W1WszbFx7SH1PVEjR/u7nL1/n5trT2GUGMZVOoIszSXrOkfgs7KzXZAg9jkxoxu3M25Xft4J0pgMGoNEejkusPUX8ve6FPwZX9gmYIyAxoQZ7Q7R7PEgBieGIBaDYXf/kMX6FzlbnHKFm3zpc99PNZ0Tbcbvd75jNaxpwxLvz0dL9PHyzCkfMo5GRLHOQko5nbsxuZU8CUwebNGEc/lrFEUBZU3seob2lGZe8P7tNX17hisdKUasRDRmTLs4RwqjW5kSkbgNKSuKGdGvxgiCjAbiJvPIaMmPcT7RfCRtInuysU/yd9KYPZTLjxADmwKT7AoaNEZSCtukkIhgrcGakmk15eaVG/zcL3wZme1w5ebzYAucKt73DOsVoe3oFkva1ZJenqzeZ1L5QB5fYZvwgKx0SWCMI2qGWqkarDUQPH27puuXSEqIDDS7Na987mVUOlarOxgxCHGrxBAvooWQjUwzJpVkO9u4NPEuDoG8prcJXNg4jOPcyPtCTukaEQRDSiHvTqPRmUJANeZJlCIac8Anqo4Zv9GW6QOxHVjeP6E9P+ezn/00P/qv/WsUzRzBoL7Ddx1+vaI/O6M/WeD7wK3PfM8Th/iZVL4AVvNDADUypvkzuCNp3rpLcZAC3eKM9fKE0sG8Ht0tLMgElZrRg0cFkvlg1OtS7i3vJpfCupefX/b1LozCmBVFGu1IAyokGbd5UYwVRC1DDIQwoH1L9B0xDIQQ8uQYcfZRPahk/IIqeI8qdMsF77zxLU7P7/KlL/4oxzefA1dCDAxhoPUt627B4vQO3focN5lx88VXnjjOz5zyN1vdJkqW6+/y70SEYBVrDOWgxFXL+uwNVAZ2dieYwoIWW787L+gEGFTN+H4bkKg+FJnLAJHLUb3LVv/DzyWn+S69tjHRc8IG8v5gjJJCIgxrwtCRwkC/WhCGFh8jccznS8ouIgLOWBwmG5yqmKSUceDeu2+jtuATX/gBrGtQVWLo8X1Ht1pycu8ui8UZbUjcev5lqvnuE8f6mVL+doA3FvWYz0l6EYMvMMjgWd+9TdeeMp07ynonBzSMIaX8lfKK3WyfZtyAYeObbzy1rRWfxjiAPlrplzN2wKiUfE0aPYO864+7x3htlIT3Pdp1EHti37K4fZvQ99iqQAuLlCUim3CzyfF8YfREDDp0LM/v0sc1P/lHfga3d4RKgfqB4Ne0qwXnp/c5Pz2hXa9Irub4+Y8z8FGJ7Y/nqpLTt2ogSSQHWB0xCTZFUnfC+uwuziX2jidgC9JYTydkT2Ajmsjb8HYWcbHHb4Jy4wrWqKiki13nIV8/n9VZ29koHI8iRuMxZvBEUiUpDLFjGDp87+nXa8L9E+7evs3J3btMyorJZMZ0PqWY1SQBXElMSlk4wCEKloRaIbQD907v89kf/kFuvPoJknE5oxkG+r5nWK9Z3TuhP18QNTK7csT04Ij4kTH4LqVQNzWGCc0IVI1ojKwXdzF+xXRaYuuCbK8ZNqe8PrwVpxE9u83NpC26JZ/H+bM2WDtUx2LMDNN+ID+/XdlZkuYS8GyohZyuDZ445Edoz2lXK07unrA4XRA00a5bJs0MUfjKV36B1157hZ3jPYrkqcqGwlpMUMRGkCLP0/aU9vab3PjYazz/pd8FrspBnxjwvqdrO5anp7SnZwztGq+Jg+vXwZXjwnm8PDvK38ioeMFAsll5oWV1eptmYqgnE9ARhzf+yYdt02mcBGgGcm2uSbpRdMpn7lh/oyllo3IbzMmTQTa7yEbG+H30HSF4fN8RVh39YsXJyT0WiwV1PeXarReRsoHKMZ3OcDFy5+yUYjqjnu+z6Fv6xSm71QSqiHERigqPpVjcp5w5bn3hB/DNMaIr8JE49Pi+pV0tODu5x3p5jk8eKRyumKDGZZf4CfJMKT8rZWOMCaoOomdx9z2aUilMRZTiIiGTcmBGU7rYzR9zRqeURkVeuoYAGjFKBlVqHK8ZV/mldO4GPLqZDCmMKz0M+G6N73uWZ+ecnZ4SBs/04Aoff/nTTOY7uTgzCDqrqSYNxRA4funjuLJhfv1jTEziF/7e3+Vv/Nzfot6ZcePWDZ67ssO0StTNnJd/+EdgMqOKnkGUlALR9/TdmvOzU1bn53TdmkTEVZNsD2BIH5LSfXaUPw62JEVM9pCNBpYn7zJ0Z0wnB6gaJOUkTa6qys8fmOCbfPrmQUKTjnH//EGb34mOE2c854lj9A9DEpBkwAhJIJEgtWgf0T4Q+4EwdLSrFcvlOavWUzUzDm+8wP7BEfX8mKJuiCnQdi1FUVFMG8RZpEpcv3ILv1rgipLZbJ/PfeF38bM/+3f5+Z/7J3zm5df4nk/exMdz/tif+fdwO1dzfDF5UoJhULo2sTpfc3Zyl9XqlBg9aqCoGjQpLsXHQGEu5JlR/uWcudlkSVPk5O5tdiYQo8/IlE3oLOnFmQ7b1RrTRV49pYhejtptMnHI9hqSksYVnnRjcAopKTZFCLk8KnpPCGt8O9AvO1aLJUPwFM2UnePnuLF/RDWZ48qaom4QW5BQfLsgOUvRNFRlDUYIEpnvH3BneUokIs5yfPMWn/vBH+AXvv4NPvXJV3j1Uy/wyqdf4eqt5zPUCyWqknwE3xO6Fef3bnN29x369QqTwKrgAqRhk2T6iJz5l1OrMiZZNESGdYtWjuSHHPa1BiFj4kmalc1ojWsacXMX57xqvHDPTFZ6hkiPMPFNLBby4I5FHDEEUkgkHwhdT7duWa47Bh+pmglHN19kurePa2bYaoYtyrxbuQJblIgmfLcixIQtHFXVYK0bs3VQ7eyh1jLEgRgHbFHygz/yo/z1v/E3eO7mES+8/ALPvfwK1hZbQ1ZDJHqP7xasF/c4v/8e/fpsDHdbJAisBuK6JSaPmo+KtT/KJqWLKtEH/DAw9JGqGhBj8tasKc/pMe4fUyTGtDXUsozn+oZNQ0Z4GJtMXQaAbiZKivl4YETlJB/oW8/5cskQApPZnKMbLzPb36eYzTBFTVKLdbk+bhObMEUJYsEHUj9gFeqiHAEpNk9csVRVjTOW1HWI9xhX8fytF/mhL3yBSiIHR4dIWedjKGakcQqBOAws12tOFws6H0giBBsBiwxK0Q2E9Wo0Zj8qfv4oCQhGkagoASsG34GfJkzoINmc5owDKQZQP+bo5dLqT2Nq1VAmQzSJaCLhUgg2JdCUy8IkRogRHzxtNzC0uey73Jly/PzHmO4dUs92KYoSawuSCiEpYg3W2OyWxpiraI1kNyy2eO0RJ7iqhMKxCWQIiaJS7LRGYgZ1JvU0ruTHf8+P89Wf+1tUZYk3o40TQkY1DR2+XdCen7E+u8fQLlGfEK0w4iiNQfqArjsImZ/gSfLMKR/G1T+mP624nM9fe4rCYFIgDZ7gO/qhI8R2Gw3cxP8BrLEEoN+uto2/L6QkxJBInScNni54hhDB1kz3Drjy4hVm+weU0wm2qFBXIsbmoIsKGhVrBVPYrSspI74QRhatfkBVKMsKa8stEGTrgRQl9XSKb4ec6NGECrz86iv80s/9LMSApEQkoGEg+J5utWBxdsrZvXssz8/o+z4HuGzm46kKhw6JNg6oRpCPiLV/gabJVa2jxYa1BUYcXRsJyw4XB/puzWq9oG1XsK1qsWAMwWxy74LGRBFy2jWGhPeZay9tIn+FZX54wMGNF5jsHlDUc1zVYKoSKQuMbFaObPP1abQRcu37g0Ufm1qCYRgIPmJtgbUlxritoZpSIilEU1I1M/rVXXw/YOsANlDNp1y7dZ3l+Sn10TU8oL5naFuWizNO7t5hcXqPrl0TkmJsnphFPUGDUDQlxc4+zlUMl0kGHiHPjPIvSxoTGr7r8xnuLMkIwXuGxYL18gQk4coCF0rEw3qZo13dcokxlrKqUGdJOxPmB3uU0zmTomDHOaqypiprtLSYqqKoZtiizvgBAMk19UZHMkW9gHqoMMJy5GLViyAmHzuDHxiGAcSMyncY47ZGaRqLQxOWsplizAmqiRg8Eh2mtLzw8Zd55ztvsHP1Jt5aQtuyWpxx/+4d7t97n251nq83lmY6p3ANPsRsULqao1sfQ9wUCE8c52dC+dnq1tGnVgajuKQMp0sYBsQ6TN1gmxnN7i6zoUPRDN1aRdSvkb7FtAHXTDm6dg03mxLLAjOZMpnvUJR1toiNxTqXAZxktMwGFr69H5ExyLRN7GYEn4zOkzy44o3JGcMQPH3foSQKV+BsgTUugys3vmxSiDFXHRcTiqLBRI9TpYiGgGX/xsf45pd/iWsvvINMpvhVz8npPe6d3GXZrvChIxGp6z32Dm8SQkLvneGakjSr2H/+Jr0rMgbsCfJMKB/YuluC4BDs0LO4ewcniUIM1jgKV2JNQyxnaEq4oiDtCsH39MtzivMV9WFk/8XnUVdgrMOWFWXV5Fr8S6lhM67ey2VXl39u7QgejBo+/HPzXilGfN8T/VgCZu1FEYbkay+HjAUwzmGrkjh4/JgfkCiUzYwuwdd/+ascP3+T0A2cnt3PvAN9xzBEqrrm4OgarmyILmAmBeoKDq89Rz2bMhAfDH49Qp4d5ZOPeSOCjUp794S7b7/B7HBKvTunqEpcUSBSYMRgbDawko9oUzPb2+Xtb3yNo+MbuINjEEuRZFRAgViXo4ekMX1qRizgxQg9nNFT2GbyLpdypzQCLEW22MGh7wne5xykycq3ZQE2Rws1bc77jTcCxuZK2lV3hokZeVxmKjIObzzHV3/+7/LxsMQaYd31tP3AEBKmajg8vs50vkeMFU1SkhV0MuXqS6+QjMHE8IHM5MPyoRU7IvKciPxtEfmqiPyyiPz74+sHIvI3ReTr48/98XURkf9k5Nr/RRH5wocqffthbMEUKUVme7tMduaYssQ4hysKqrqkairKSYWpC4ppTbO3Q3O4z/TqMfvXbmKKejSEHEje6hE7KixX+n6gSusSYkeTojHn6DXl4yWOilOyJ2GNxVmLxsjQdXTrlhQSzjiczf6/GIOKEMfEkMZEijG/XwwkIkVVImLx3ueCi+CJCY5v3OLk5JS3vvkN7t99j9XqjGGs4D2+douDo+uQDLHtWL73PuvzBQdXr9PsHaEbD+c3YeUH4H+pql8RkTnw8yLyN4E/Cfysqv5HY0OF/xD4D4CfAF4ZHz8A/Kc8gnX7YdFN6TXgBZprhxyaT2Q4l3U5KFK4HPGyhmjy34SyxCjEdqAsdjBVvS34CJpGgETCSBiNsrydq1yc7ZvP3W7JY/Rws1LjmO+zYnDGYDfWf0yEfqBvu21dvSkKpCgw1m7RuJoShIiGmBNISUEiMeU4RlnUBN8jXUuyubyoms/YuXqVO3feJBrFNVNcMeHw8AqH+8f0i5blvROG9RqSp9jd48pzz5Osy0EtLFF+gySMqvou8O74fCEiv0KmVf8p4EfHy/488HdG5f8U8Bc07zk/JyJ7InJ9fJ8PlxF3YeqK/VvPozFTpiNCFCFmlEOeLCYbYikpfQxM93ZHf1seOJc3FvlmqwYurPRLW4DmPyCGmFe9jk6jzfSrdvTlJUGMEe89Xd8TU8KMkT5buBzssWZbTbwBbV4cHYqqwWJI1mEmDWkR8DEhIRFJ+KC89Mon+cfvvUm96tlxE5qmxibh5I1vgwrOFuzM5xhnsUdXmOzuEiTHIjZj+ST5rs58EXkR+Dzwj4CrlxT6HnB1fP4ovv2bjBPo0ntt+fZv3bp18foI2w1iiNZiygyJ2kwK4IOGk2aw57RuHqi8NcZcivHrByhYLp+JaZPDT2mscM1irQU3EkOQ7ZI4unRt1xHGFW+txZUlpnAjBwsPfO7mzN9g95MqRi1qLKkq0a7AD4oMAZxj3fVce+5Fdq/cpDGR3ckOTdlkvsCmoprMKCZz1Ja42Zyjj30CqXYy/2/OZV5CPDxanlr5IjID/t/An1XV8wdWjKqKfNgJ86DoJb797/3e79WL1zeG/6ZqVzMlGzCmYvKWmyKXzHHqqqIwhm0i88H72743ScaiTbaZvQ2AJ46oHCVDpvPZnattN5nBTHHm6bqeEON2xRdFtklk3I22kK/xrN9kIC9/zw0pg7UFYi1RPIMfcJoYfEdTVnzv576f5e23aQpLPZlSzvapdzK1XLWzy3T/gMnxLWw9yyzhKdO6boBJT5KnUr6IFGTF/0VV/S/Gl29vtnMRuQ68P77+6+LbfyCrN0b4zPbuDR+w0MRcQuSANZJz7sglt/HByJs1GT+PXkC7QgjEkEEeohFjBFMWY5zebJUO2fIPIdAPAzHFPEHGh7F2izSWsXJjA/96GBMoY5Ipje9pUGzhCMOARI8fAs4WLLuOw+vP0w4RVxfsXDlmfnyd+dE1JvMZblKTrCXaZpxIuoWlwWaxPF4+VPmSNfJ/B35FVf9Pl37114A/AfxH48+/eun1f1dE/hLZ0Dt76vP+u5TNlj9WTY0bXl51G6XbkZ3iYvBz8icETwieGHPe27mS0pVYa0hGHjAAISvJe5/j6SlRji1YNrQucvlv8gduawg32/3l42iDVtqIKRymcMTocWKZTubcOblPc/M63/d7f4L53iGmqsFa0pga7skFZONGmefoh5zzl+VpVv4PA38c+CUR+afja/9bstL/soj8aeA7wB8ef/fXgZ8EvgGsgT/1NDfyXVGeXP67kHJmjksuIxewLfNA4CYbX33f4kOPtYayrHMkzhYjVCsrfGP8bd7Le08MAWMMRVFcKF0eLOParvKNizgqXzZx/XFCeO+JKaAaCCmOcO0M2gjqqSqLi4H18gRTvoKdHzBgEMJ2RYuC1Y19MjKFKR8C3rqQp7H2/x6Pn08//ojrFfh3nvLzL//dI1+7XEAhIoiyrZqyuqmmFWIfSCmAyWSEwXu6tuXevXvcvXubz37PpygKx9D1iCTqnT2KcpInTtKRNQtURjSwQmLIu0SMaIpUThCxeZjlgnZdk+Y+PLr5HprTtCPLdjYiIQ6eoW0Z+p4+dIQQxnRuRhylqISYCCHRhw7ft3A/cX56j52rN9Dxs80mVKnbwHP2SpQHd58PkWcmwrdF2zzCUHtgAlyahxojopF+sWR1smA9BM5az7u37/LLX/s633nzHd57933mk4o/rju8+PwN9uYV890MkvAhoimf9SIZyJk/L9tMcUQPb4oxvdjxdzlryAbenTbGo5JiZBg8RiN23N7bdcvy5A6n9+/Qrs7xw4BGmwNHKWXq9ZCjd7YoKVzB3bO7rN59h6Mr12kXS/AD1lVbfoIH9DsmQb+bLR+eIeU/reRSK7ZZsv7klF/5ylf47//hV/jyN95mkQo8DtfMObh+i/JzLyPW8pd//tu8+NaSOrU0tWDSmltHxwztwL37d3jhpeeZTSdM6orKGQoLsffbs91YC6XLxlQcjxrDlhfQoGgKrFZrEDjY22dxuuCdd97h5P59CIaidDT1HlUNbXD0XcuyXbPslqzOe07PF5wtVzgg+AXdu2/x/bN9hi7nDMTV2ZZ4wsJ+ykUPfMSUv135klda8J53vvkWv/rPf42f+6WvsTh6gdmNV7mys0dVVTSTCT7lBIe1jq+vOmJ0LN8+4/ztb/NHf+ol7Ez5z//yf8X3fcmyOD/lYy/cZKcpaYpcGlaNLFgiYCTgolKZDJyIsSfGRFWVTKdTXOFo25bj4yt85Re+yde+/g1ijDhn2Ts6ZHUy8NY7b/P+3fu89/a7LPqWLgW6rkMUjCup6gkuJRrXMTtv+US3JhoYSFjJ1rxJH1zi22TUZbvjQ+SZU/6H3fgmQyYIXQqsQ8vrq8SVL/4YV3cPKdyUOFa4VkBjC86HQEggpiJJoJjvMblynbutknRJdXyLpd1Hd3c5d3t88+13OTw4ZG9nwrBU3nr7DmoSTVHxiRs7nJ0s+NrXv875ndtMrxyxf3zAXlVycnaKKRpU3uWXfuXrlLu7VHXB7W/+Mr/nd30fbav846++yTv33qNS5eDwmMKW7E6m3L37HhAwxYzgE0s9w+3scufsnGgcrpogyeZ0sjz5XH9Uoemj5JlT/ncjRVHiiwZ3eANJU8p6jqpwerZiZz5HbUE0JdPG0q3XaNvnkqgC5leOSVEYfEIoWZx37O3tc3bWcr7oQdb4KLzxxjvcO7nP8y89R6E1y2D56htvce/8hG9/7Z9yRT/DPanYn1p29m7wxnfexhjH4fUXWAw9q65j2QekqEjrDhHhuRc+RtPM6Nqe4CN3TpfM944YuhXL5Zq9nV2CHyiakh/5yZ/itc99FrU2h7l1pI99SK+/Hm/pmeHhezin/mGzVkSo6ooXP/MyV1865ujahOvXJ1ydK6/emnNz3/DClSm+X/HNb/wqk9qxXp3Tr1tK62jKCmfz3C/LMlOedWtSCrz40vM4Z1gs10znu3zyM5/F2IJ337vNaoi06xXnt7/N9TpiTt5l4mFYrLnz7ts0dYkrK+6dnVOakmE9oGJ599597i/v8+Zb36HrPOpqbFlnVrF2xfnpKclnvvx7d9+g7dasBih2jyibZrul8wjF/3rlI7XyZcySyda8VWbzQyazY2Yp4bCYaYEfAp333D8/o0wLjncruvU5MQyUrqQuLLfffpOXb+ZS52694Mbzr+JKAXq6/oxmWhKiYaeasurWnC7u40qLtdCQuDlTbu0ETru3Oazf4+aLn+Zs6Omk4Rtv3aNpKvzgST6xs3dAOZni/cDHX3mFeucK909P8e2ae++8xXxasbq/4P66pSwji7P3KcoJaf+An/vyP+Yzn/3Y6NLl6Kc+IpL+tO7dZXlmlP8wSuax25jkgklRMHgGjZynRNAp98+XLNuOFAOlNahGFh7ElPi+Y7Y7Z1YXtO19zlcL3r73DhOxxNbznTff5ejKnJ1ZiTWGnVnFehmpS8Ni0TKpJvg24hzMjg94//SA90/fIxrlbAh0p4FBak7bFW53zl4yLJY91w5eILQLZpMJ0Sdc1XPn9vucvf8Wfn1OWJ9zdp4p2UpjsMmwN53lXgI28dWvfZ1hSEhpUaMYNaNr+mAcZDN221I0kf/hnPnbySEZmKFGgZo7Zy22bIgxMKRIUU4Jvsd7DzhUprS9ZwgBHQJL09H1gdUi8a1vvUNJpPdnHFQtV/cOkRSZugl1MJyvTll6z3e+8w7VZIdusWTV7rB7dI133j7l23fPmR4esnAvUA5T2vMFwfccH9X0qzP6VUvsCxoHu3VNf35Ot7hNtzghdfcxaSBT4jv6YEhJsEVJXU9Yrxecny8QTUj0OM0laUbNuOtfKP1pFP0oeWaU//Asftw1oIjxIye/4+17LX0wtO2S5XqFDytSCEzqElJAuiVHO3uonROGyGJxn5P7C5y1fPrFF3j/3bfpVy1337yNNYkbN68iLtGnltn+lMWq5erBjNW64+TsLmk4ZLlasVisOF8qnSZYvIMr3uHGtQNmdcE8rZgdT1jNC1brNaVRdndqTs8Mi8Upi8UK2AHHWCeYMHVOKfdA5z2u3qO0iQFL1Axn1+3joiPJw1HQB8fqyfLMKP9pxWhmpLTGkJJFFve4WrQU88DMgaohRcPevIJoCHFGh+Obb92mDRGpS649f5V56NjbL7m3dJjDI8qD53jj7pq37r3D8eE+Bwc77OxUYB3D0LI4vU/s11RiuL884+6db1NNLaULGF1QWEfwK0K9yzoJQ2/xpuD2ckGF5zNVSd1MWK4DyTRMj/bwPhBTJKRA6XILqQzn8tjSEcXzxnv3OTlvOZpMcoNkLEYfhGQ/UJX8QHbnI7LtP83Kh9ylCrWQCpZrz3q54t69M96831HZhqIquH9+hhjD+bvvcPP6Lr/6+husZMp8/4CVD3SrJR97/pDz+6esFz3Xrt7k8Ooxs7091m3PetVxb9mRTMV7799jCAV25ybr0zf5yi++ybxZMnQ9yzZROfAWprOagGUxCOVMKYqAlhW9WOJyybe//gaLszN839FqiekTTqEoHEVR4iRDyctKc7LKKiEtaYee2+/e4cq1fZSE2bTmfmjbf/CnAeIDFDWPkmdG+Q/Dph9O6Gx+lxEwmcz8V15/k9dvn7EcBDENHsfJ2YJmvsdZ3/Gd9+9BPeHN2ye8+Mmb7O3MmbaetSSME4KW7B7dQPYMXe85Oz1hOp8TY15hwUQOrh7x7vt3uHd+hpvv8c79Ez796iHB7dBc2c0NrDTgaks3BJzzTKuGq1cOWbU9hMDefEZZNOzsBW49d5VUHyDF3gOp3mG4wNuZmAj9CvG5N/evvv4Gn/38p7Ajk8jDQfyHjeWHX3+cPDPKf1pR2cCplHfvnrPQii4Kxjp8SlTNAarCet1j3Jx7Q2D/+nOU5Zz33jvj9nvvcf/uW7Sv3EJSpJ7uk4oJQ4iIOBbnLc7l1ZV8Lhg5PtinLAru3znDFgXHV25w7caLnA+5lPv67oxSM8BjsnfAfHefRT9wet4So+XdwfP+e99iWL7N7TffoQ1nFAcHTPb22JnsYFSo6wZB8MGT8CRRrOQE7utvv0MMUDoZaZ4fMS4PgUXGV584ls+88h8O9xrNVKWJxBADSeHkbAXFhEFz5W7pHEYHjo6mmEnDmY+8/tadfFyYhpvXn6cqJrTtikXrIQZICWNyVi2mRFHUFNbQD544DOzNpjAk1n6NiFLXNVJbzpYLzs7usV9nQuctrbsrKOoJofMMgJESXMO1G7c4PU1o01AVdQaoxkhSgxVBU8CYTOYcY6ByBV//9tu8/ua3efWl5zOOWDblPw/KBrOgmkaj8CNYpfuwPIy0TQJRDF4SRVkx6JpV21FPLF5z2XRRV0znJe++c8o3f+1dpN4l9C0vXZ/xwo093nvvLaScoOJQtfjB41wkatiCNbAOW8DEOvq+48rhAb2LiIWr166w6nu6fs2V67couyV7+/uY+T5DNKy6TI6oKVG6gmgds70j4mTJOp3jmhkqRQ7amATWMgw9RjITiDUGbAnOsOwC/+yrv8jLLz2Xi06eoNS8TnIUUD7k0H+mlH85QPE4iaK5aBMDruEbb7zBe3fP2Tm6gh8CYgIxBDT1dO2KZXufyq44mDQcXT/g6pV93nnnDZSKLhmMTdjkAUNMmd8+xphxfz5b1UVRUBYFtTN0scdZxdmMA4xxIEYPxhAVTk/PGJIlJsWHgIoZKWUKitKxP5uwXnUs/ZKEsuoCQi49E8aqHeewVYNpGpCE0iPG4VKGmD2N/A8qyAMb429MSERYLTr2m4rDl6+iBkIXqYua6DPgwtWWHee4cnhE6DuWZ3e5c6fjbNmylglm7ihTwPrcDEFjpCmqLYu3k9zIUGPEWqGe1Bwf7dFUlqIQtI1YZ0kaOD07497pkvrwCtgaK0IcAhjD4DOatlOl0sjN68f8s1/9NagBVxH6QBw6nBF6PzBYBzYHsmxpqKcFL3/sFZxaxgjHY8doQ1n0NPLMKf9xs3XrBaSMwI3JczR3pDTh7vt3CTFx+/b7NHZGiMqdu3fY2Z2RgmftFayj9bA4vU83eGZ7UxqxpJBXm7WZY8/7YazfFFqfcX6JhFHLuk0M68jztmTZrlgtFvSrJTqdYJyjrickcYQQiSJ0g6ca27kNwXMyJLp1h2PJp158nvfP1iyHnlYyvQrWYChZdUv8sMI6R3QlMVX8wq+8zmde/hjWJEQvQKkfDPF++Fhu5JlR/tNG+EQzXdqb777Lvft3WSwNJ7fPcbaksjsMYYRV1yWLtiOoMEQhRGWIDqkmud1q3WBiVnLUAFFzU0KXy52KomSIAYxQuEyH2nY96+Uaa65R1hVl2VMVJYIdEbm5OKMsStp+wDqHai4+dc4R48CdsyWVdKxOTkkpsDef8uKtfcpmytmyxVUNvku0yyUorIZE7wN/7a/+PT73wkt84QuvwRNW/ncjz4Tyn+as3yYrUDCCq+ekYpdQG2a3cuFkWifUJ3zfU8wijbNE3zP4QNcPaNtni59MVaQp+/uZNzmNzFdjU6cRlu29RzWfw82k4Hj/OcqypCwqhmHAWkPTNLTDIjd7qEqSmq2BukH++hDx/RpbVcRoWUewxtP1A7fffYuicHRDYLqzR2lKdhphMq2Ig7JcJRZ3T/nG67/EF7/wEqp2W1r+QfDLRwzJ8zidP/oLJFQsa58YtOR0tWBnkunKUquk6KlKOxI6JYqqYjKbMnQdhbW0bVZGCgmxIyOXKtbm/j3WWsqyHNk2zPb8V02ISYQwsFqx7flz48ZNjHF4V9BMJvRY2nWPtRYZW6YWRYlIonAZVZxCTbAVQQPJCb5vacRR1DnWEEOk9z1DWjOcrYjDCmHBvXt3kOjGpNZm7C68oO82ufNMKH/rnpAyNPqBBIVgrYBENI0ujgbWZwGi48rODpoiRhzFrmIPpnR9S9f39IOnTdD1LTFmQgMxcL5cMGjExFw5Y11JRuxllJSxBkmCD7mvnWpCo+IkEf2KM2OZNHNEFpy1awxwfHSdbt3TNCW98SQrTKfNuKPkPoDG1AzeU5YVy1VHGGvo3XSPunAk7+lQWr8GamSVO25NzMCw6tmZTnMV06Vy8otxevCVpwmVPxPKz6IPGCsX2+aDXyoh9Kq8d7Jg7Xv6OJIfmYLClWj0OGeZmgZjDC4qNka8Kq0PlEXJ7s6MkCIh5Lq74PPqL6zLZAoxW+feh7EOr4KUKKua3b0pqbtP13t88CxX51y/esRs4tjdnTGo5f5qQe8DMhZ4GJcrcsNY9IHAbNZsSR76rsNZwZQlhbXMd3bpuzWhX9Fb0GhorHD1+ReJ9sl+/mX5sAnwDCk/y8ad2zzPP2FTB2qMpfeJdYSQPINviQECgXW7JsXcsWoDZtfocTjEWmxTZm6cPlCIpSMSQ2bpTAm6PlCOAZ5NqZeqMgwDhbO8f+8OzbVjTt6/zzfevs+9eye8/PGP89KNq+iwJhaG989WrPoh9/dwBuMcGgLFpSMkN0zK3T9SUrQwiCqTqsQZCyiSHH2ytJJY94lGHJ1PmQwKflOgXM+E8h+coI/7Vvkim4TYQ/BwvLdH72v63hN8ou0GzoKy7gPr9RpnLSZ6RCxgMAaMiTgD1SSTPagmkuZtGS4Ytoy122CPcw7rHC45Bh9o+8jB0XWWy4STCV/76jdI3Rnz68/xzqIHSpppQUyBqImyqCmdyx28YiaAjsEjIpSuwEpBWTiaqkZDpO+6XINjoGxqnDVY73n3nfeQwLYEHB5lJD89kPOZUP7j5HK2Kvu2mVMneGHdtiy7iHFQVhVVBZNpwxWNLFdFBk60Pb0UuY1ZGIg+UhX1WOtfYI0ynUzougHfR5KBfvA5vOtyFy9rDUgiRJ8bP6Ckak63HvAu8sadb/Oxq1e4vzrDDYm6nlHaUT+uIoZIZSz12BBSXS65ijFRuSLnKWxJVOgGT9TEevB0XST0EL0jhUBizp1FTvqoNIAgGh6r6qex+J8J5X83RqpKJKaBqjashoH7Z2s670GhKAvqusA54erVfa4qDF5Zr9e0XUtC6IbIarVkWEf6kDCuYDqd4FzJarUYd4BcSWttAUBZlBibywA19CxO77O7f0z14nPszSd09+8S/JDtEwNVVVGOW3vS3OzZuew2bqqGUSGGnJ5NIZJU6XxP7wdi8hjxTBpLKgtir6g6TpctXVQqt1H5hkj68hR4+sF8JpT/KHk4R70FdpJbnxpjOTw8ppi0tF3P2dkZXd9xtlgQvKe0BYW1NGPzIjcycqnJZIViBG07umHIpM0qlGU5lm6HcUA9k0lNiLDTTJhaiwTPS89dp5rucv/shMrBsl0xaSqqqmLtc7OGwubCkRQDgiEE3doPeYIpkjKFujOZxLF0ORlTFNNcEeQH2vWCKMIQPPdOzzlb91ypZxnG9QQU90cutv+om708qzMjB4QIq5Wn9WcogWlTMzk+ZOgHFuues8WaVevpfKINHVVZ5rPWJNre07Ydzub+fD5kQoZM41pSVxXrttsGe3yIlFWB9wFjE5VLfP2Nb+EmB4TkuXX1kBvXr9D2A76asl4FuvWaasP1q+B9xIdubBAplM4iJlK5krIoLsq3UXrviUERHF23Yr3s0ehZ92uSDdw7WXH14CBXFY94vseBOz5MngnlX961Lp9Vj3JV1AT60NGFgbNl7k2np+fbAM1k2rC/P+XgIEftMh17JMYxdj+sKUzCWUs/JKw42q5jCAGLUjcNdT3ZlkoPg8fYi5btjSzZbQrMfI/awcwoQ11w3w8YA5aIAYZhwBiLMUJTN0xcwjW5UKQQMC5PLhHoh0jrcyPo9bodXULJ0ck4kIbMym3djG9+6y0+87FrSMos3sKDTRUeh+p5lDwTyn8auZgQMHhPXdfs2iqTIITEMPQMg2d9thwHPp+zroDKOcpmQtf16NAhIfPWFDGze5aTgs4rZ23L8mRNU62piwbrHCKZikVToqwKpvUOlnv48zvs3Tikqg1niw5FWK0XJA3UdcG8qnNFkEBdVUgytH5gvV6SBg9lbo+2Xq1HRg3J3H6moKwdTVPQrhSjJd4mjObrv/yVr/Cv/vDnqMtMP6Nqvgv7/kF5ZpR/cUY9+qtcjv2nlGvguz4gPuKMozSOZlKhylhVKwxhwJNIAXz09IPHFCVxiLTrbB90XYuzlrqsONrbJzXC+XrN2eqMST1hPp/iw5CDQUViue4xGmkKRa1l6eH+aWTVwnSvwcfzXDo+BLzk1bxYrFi3Hcu+RRWcgimKHD8oCnZ35uxMG6y1rNt1nsSLNZqUvdkew2TgvD3H+YLXv/UWd+6e8NxzV0fUjmUT7/uwXfNheWaUf1keOOdha9Xk54IrKhBh2XacLldYV9Cu1xRliRGh67pc1ZaUpqy3FGxt19IPnnWbLXNv86rq257l6SndYs3NF57nYG+Ps/Was9NzJtM6M2kC86LEho6yKnCzPe63ytvv3ub0ZEVRTBnCAkykHXru9mcMw4D32XUsSjClpapK5pMJuztziqIYu3Qk/NCzWJywXC5BLW07EL3nfoq4yoGz1Lagme6OBupYuScfdOuedgI8c8rf3O/DNy5jjaIg1M4ixMypU5QwBmI2bdFns1lmzeqHi4yhMXRtD+S/WfctmhKFcUhj8caySgPfevstZrMZTdOwuzPnfHHOfG8XjEFDxs7dWbYsl/doh5FpqxAGHQhtRDUiJpMsV3XDzu4uOzu7zCclVeXY29uhKBxJYLVa0fcd54slq3XLYrHI9fwW2uCJKVKWJR6DDIH373+TT1yfcby/iyRhY1Fu1L7B7T+MgH6cPHPKvyzbo2BkmjICVgP7s5rdSQHGsbc7QwXats3bbZeTMRSGUpQUlHXXUZYlu5OaEBKd7wmj0VU2NYOP+MIiWmMEhrYn9APiCoyz9Os188MjVsbSnfX0lKir2dufZ6SPJlKCuq5xzjCZ1BTRYC/RxRWuoKpKhgDnqxWroePs/Jy+72nblrqasLN/Bchxjyp4Yog5rTy09It7zGvhf/Yzf5jZdHLJxdt0F7uwiTabwEfK1XuUZPKjfKolAcVgnOVssaJLxWiIlTSuzETIzUhyjDIMHo1K3zfjzqB03cCqXRPSDNWQS6Q8rNqB2A107RrfdcSYsGXJZD4jDJk9Q6c71LMJz9UzVrFh2fXYKidskibq0lFVZW6T7hUSW7++qic4l0PMSSNiLZOqYlpXmP19JGUFZhc0MQywWg2cn57QLe6yOrtDk1a89967fPqVF/mwMPhHzNqXS4+HZHPmj+dcGzz3zxZItU/se87OlqzblrKqcvWLEazNHHWkzJIVQ6QfhkzChILm2jhbOIgDvV8zpMCqa1mv18Q+YEtL0sh0voPvPffPTymGFUU9y0WTCQoqOjKolKg4FQpbUJcZxROZEmKiKjPCB9g2dkgpM3ivu46u6ygECutYrVasFwvWq3NCu4Q4MG0mxF75i3/tv+Mzn36FK0f7bBA9einL91uy8iVnR74MvK2qf0BEXgL+EnAI/Dzwx1V1EJEK+AvA9wH3gD+iqt/+kHcHLvPZXarg4eJnLtaAvvOEEPGxxUl2waS0RE346FEvdF2i14QfW6aVNtsEPga6LtOckhQRT+ezbZBIVNMag7DWJZo867NzfDfgxNIuWia02GLJOpZEX1KaiiH1JAd7e7t0bUddlnS+oywchRFKq0ga8Os1bTtkt7DzxJAji5mA0WIQnBh8UIp6ykTAFRbVKaKRdrXkW3dP+P/99z/H//infj+yoaXVy4qWp7L04btb+f8+8CvAzvjv/yPwf1bVvyQi/xnwp8n06n8aOFHVj4vIHx2v+yMf9uZPW6snaunXnhQUFc/peomrSprpBBWDdQoeRCy+D0SjlGWBphw9EyNMphNcb9GYsGPjhaIoSMtzoo00e3OMEYb1mvW6pe97vvWt1zF0HE4LdmcTMBU+NfS6JoSOED3d6X00euqqyN23SIR+zdCuWPke4wqaakJRNSRTMp3OMabI9koPs2aS08sqOfDUtUTf03Ur/NBRWstsOuWdt2+jaUMGfbkv/HcnT8u9ewv4/cD/AfhfjJSsPwb8sfGSPw/878jK/6nxOcBfAf6vIiL6IXvQo4gGHq7fAzA4uuWA7z22qZnODjk9X7Dq1jSThklpsaoYq0znBdYIZVEQ+oHaZjLlvuupKpPpC42hqEp6P2DNlMFHxBT4GBArDIbxtWztn648k9owrZW2P6X1iXZ5hl+v8f0AKWAFitJQViV1M2Uym3Hl+AqT2ZyybKirhqhgjWO5bAkpUk+q3HgxKQ7lbH1GuzhB00BYLYl9x1nXYkmcXC1QzZFEvcxK+UG9PVGvT7vy/y/A/xqYj/8+BE5Vt7XCG1p1uES5rqpBRM7G6+8+dGMfoFx/GhCnWk8yljjWtbnSYpylW7eICXhvKZ3Bmdx/l+iRSY2kRFMWVGWBJeSQr4JxFmPzexnnqGxBjLlNawLKyuWmDl3ClqBUnA+Ovf2KaYzcfv82i/MznK2oJ3OqScX+0R7Xrh6zO9/BmoK6biiqEh9GUmXnSCm3aSuKirKuMCI5lWwsXXsOGrKV362Q4FHR3BXbD8wOdsaI7uj/Ig8skM1YfZg8DfHyHwDeV9WfF5Ef/dB3fErRS5Tr3/M936MPK/6xwESBECP90GFtSYiBqi4wVjAmEVKiqhtEE4VzGC1p6horKZdAIdR1TQiBVdvmdq0+EUKksI6+9yxOF7SLJd5Hgg6IKajLiqFfk9vpBc7un1HX+wQado922d3bZ7a3z2RWUzYldV1RzmY4EXbmc5wEur5DppLtlSGhGFwhuaWbXvTxCTEQYsgGoa0oq5re9zigLCpe++Qnx7G54Ah+HHb/SfK0xMv/uoj8JLnGZAf4j4E9EXHj6r9Mq76hXH9LRBywSzb8nlqexCujKjhnqGpLUAF1KH5E1iquKPFDJPoBIWI0tzmLmqtuNnDqEDIQwlhLGkIOpvjIermkXa0Y2g7vIyoRW1qapkaDJ3RLFutTbLOifu6Qoxc+zsHeEdNJgThDXRUEP2BtRUo5qjf4HlcZqqoYkUGG4DtEMhlD0oAVi4iO4eAz2vUaa0tKV6OSxjS0Y+YsH//4K9txQnRbk/dwpe6Hrf4PpWJT1f+Nqt5S1ReBPwr8LVX9t4G/DfzB8bI/wYOU639ifP4Hx+s/dC4+6Xh64EthqOuK/b0djLH4kKjqEiOgibGBYY74lUWJMZbgI8a4MVfuthU51o1xcVXa9ZrVcpWDOwqTpsFZgxGhcgXWGCbNBIuyuPc2q/PbVFPH0Y3rTPZ2EWswks/reV0ycZYCpTSRaZ2Tr0WRe+2WZUFVFUymdQ4IFTa3ijUwDC3tekmMkaaZUpYTMEVu2lw12LLhm6+/nifu2DBq4x1vaGueVn4jfv5/APwlEfnfA79A5uRn/Pn/FJFvAPfJE+YpJPe7zciUBxscbn6q5sBJx5BXvAQSAZMq5s0ud4czhhhoSsuscEjymKaiqgqMgcLZ7FQapVSH94G+94gKBsOknkNyGJNDrSLAABRKcNlaD4tz9N7r9G6PNFj2xOJTi4qhsA7nCqqiwNhEYQURJUWhcJbCWCK5CKSZVFt8YOEq+j6Q+oR2a/AtzaRGjcnNFsVSmhmxEqwOfOvNt1GNWDQnkJUH9vrfkqINVf075EZKqOrrwJcecU0H/KHv5n0feocPvPJgokfpfWTZesS4sblxomkmuPUih4JjoGhKmqJBjMU5kylNxiRIURR4n5stAFhnKYqSxapjsVrlvID3RI2UdUEi4YcWp4F2fUbwHW3r+dbr3+IFt4c2BUkdwUFh51CW1GWFpkAxwrmsGDRlu6MoitxuTXOnLY2eZA3LMLBaL3FlwWxSk3D0qyXiLIezPbwLxLP3+cLnPnXRsEE/iOHfjNlHJrx7YdzBpuToslyezUkM33zzXZrJlNnujGRDJkyoCtquH1cZOJO7WOesUALDAw0QjDE46xgC9ENiCAGxhugTprAwKIPviXikLiEkjPX4ocd6yS3VCyiaBtUStCfGXCIevCIasWVNXZRojLlmz9hM3qSBFAW1MGtqNKwzyFQi050dfLKEZAmDR5JnZ2fKcjhl0I5PvvQcoiaHuuWi39/GCNzI5Raxj5Jnhn71Qj6EeNlAwuCqCb33qCR8HDhbnmGL3OiwKh03b1yjLCyqmR5dYyQMfqzAUYzk83Lwnn4YWK3X2MJlOpTCURQF9WSCooTo0ZS765VNhThHWTXs7OyyM5tRFsUIHnFMplNCDPRdT4oJP3iGfgDNzN+FK0AV3/cYgaooKJ3DmYwS3tndYTKbURQVrhgbMVtH267o1ktMGqjHbqIqcunsf1Td3pPlmVn5D8ujvoiI4E1iWjqOD/Zo04CqoQ1KG3ogV8RGHwi+Y/dozv27SypTEpNBnEVDLtSIcWSzs7k1a06meFIIxH6gMIbkGlbxFO17wDFYSzJTtJggVclktsfETFnb7GKKwDp0VM7QDQNIgVNHnxQvkTIo2Hz+u6JByejiXHOQ6/smbs4QlMJ0JN8jgDMTlstz1l3PzekUNSU62kcPGnsPunm/YWv/X6Rc7oO3bZiUEnu15WjmmDnDcN6T1kpqlbCKDF3AB8Pde+cc7h2A5oaLCUVD7m2/KczYfEaK2ZVKScdKnbG6JgfN0bHJosTE0e6M7/2ez4ArSNZSTh3OwXTSULoi970h4/Y2dXoZeTTQjsDQFDMOwDlHCGELF6/rmrIsty1cN9/bOgihY71aUZYlxo6t3T/EQ/rIKP/ytnX5xj+w+tUwbRoKq+zv7NE0zbY5sTGG2AfWPdw/WWOTYMWy7ju6rieN+fHNRHLWUriCoizGbFjCOktVXYRaLbltqsaEQ6hN5Kd/+g+wc3RMNAZxkbIyECNubLdqxiRV0zT0Y8dNEckdOLuOwQ8PTL4Y4xaytEkBG2PGRg0OHzpW63OMgbKskBEnsPkel5E7l8EwHxbefaaUn7/UB3/3QNjSOOoyB0vu3DtFSiFZJVklmpi5cVJi3Xa8/fa77O80RI2ETVvTEZK9+UxNuQGStdkYs5IJnWIMWJdbsKvmBI1qpCTx+c99kh/+XdnRGTSRYmbN3NgSSGbxEmupqpoUFcFQWUfoBmKITKezfDwNHu9jrhS2RY76uYI4snTFGBm6Fh9DHhvdRCofvbqfNp0Lz5DyYexw/SEMUlGE2kXmk5LZfM7gM/AipYzqHUhE7eh9x3t37vHic1eorKWua+JY3bJpe562nS4zKVJdFJTG0ne581VUJRVl5nNIS1wBcVhxNC/56d/7L7PX1PTJYqlyHR6as4kpG6WDDwwhUlQVKsKkmbAzm1I4Q1lalqslMaRc3x+VmARsQUy5yqcsK4yxDOuegKFwBa4w274+D0f0sjzqtceN+DMojzuvNlucMYbZbJYNtZjGbTv3zSVFjLG4csLZqqeqSm4c71MYKMrqolyKi8Eri1ys0TQNIkIIga7L27WzOVI4dB06LNnZaZjWFZ984SZfeO05KiXX+aUHt+yNXZHP+pZIQKoCVxqmdWJ5/j7n7YJglagDhoSzQmGzzbE5njbMIK7InTubbeOFy+7xo43jj8yZ//BZ/zjZ9JArioLVap1z4TGf5UVRIJKrcAYVugjf+fZ3uHlln9i3GZo1Mm9syq83vvBGYRvEbYhhm2kryoIUA6lfsr8/pXKWnSLye37wFSYuYm1myMq8O9m4K4tc52dG26KyEIaBeVPyqReu8vL1A0praMqSWVXirEAK4yQw2/tLKW1dPu89YZwMv142jsvyzCgfHmHcXQrtbp4bwIjhYKcmhZ7pZIo1BucMZemYNHV2pYwjJcf7Jy03rl+hrgpUcgNmg2JNZuXQmDCSo25d143ceYAIxgoIVGUNSenP7rE7KVGbQRSvPX+VV2/t4Yyyale5uHN0JzXmMLUikCAFpWs7/DDwws0b/MCnPslP/egP8drNK7xw5YD96STDvqIQUqQdBjofGGLAuGwL+bDOINZLLWIfpfyPVLnWRp5mq9qcYke7DXXpmMxmrNY9vfcYm72BFBPOWYwIp4vAnfsLbFEwrFtqV+GMYRjPRucsJFgsVqQYKcuCoc+8OCnlWvpiTBCVtBztzYhkhpDaGl6+dcy377b445p132OcZVo3dN2aoI6qzC5kyujTXPtXN0yc4cUbu+zPLSf3z6nrmtfffIcQDSHGbYdtsQaNOfdvrXJ0sL+19h8nT4vbf2ZW/sYSBx7pwlyIwRI4mDXEkEkYlsslIcZMgTL2uE0pYQAfAr/8a98iaI6xMxZ1bBC3xtitn22NRUMao8HKsG6xItjCYktLGNZcOdxHdEMJFzg63KWURGHNNl1sraUoK/rgWayX+BQJQTHiQA1+CDlVbAJ784KP3Trk1pUd9mYVKWYyRlQpjMusYZoIPscD5js7T43R+zB5ZpS/kYehXJefi+Rt2GjiaG/K/t4eZVUxeJ/z4qPblmK26kOMhBhZdIGymVAUFhnTvcbkyWCMEILPKy0l0sjOZYAMqZQRIFJROOXWzeuZuAlQAkcHO1QWKpe3Yu/zhCyqkqquMpGijvn4kSFEjCAm98kpKClxPHdtjy994bOUhSH4YRuSFoWh61HGQtTJ5AP45qfx6R8lz5zy4UEwx+VzH8AQUFMwLx2v3dzFGeHK/oyJVfouomJwZZUrbExgGBstV9YhOlbtohgzcvclKIuawpU4l5m/NtZ26aBv14QhUhRTyqLm6vUjNDlQwaphXjmO9meUxmB8oBClT9D1nlk1oRm7c3d9pE2Rs/WaoY2kYImhIKpBBawoz1+ZU8RIChHnLgI2RVHQuJLGFkzqZjtOj1b600+EZ1L5T5YNmbjy0o0j+tUCZ7KyUgwMw3DB4GVGbGtMo+U+cu05R1EWeesf696cK3Aj2AIyaZIRwY/um7MlV65cY393FzRzX4uCI/Hiras4k91MyERMfZ+7fO3M5zhrCdHj/UDbD9y+f0YUg7Gg4gmaLfhZU3Hl6GgEoWTQh2z+y4VLVGX5gdKGhw2/p90JnlnlP971G+vQNHDtYJemzHwpXg1mzJFvqtectegI2dr4zQ9/xub8b9v2ote9MLJ05HM2jRVAh1eOmVYNqJJEUUkYCTx/45C6hKoqQAUlYJ3StitUI01TgdV8lhvHr37nbdZRcov1kbQppURZltRVvQ31qjLy9+T78oPPKOLH2Ho6fv/L/36SPEPK/3DrNV+12f6V+aTkYGdKHwKL5Yq+XTP0Q6ZcH6+3LrcqPzs93Rp2wFgQ6bbJlZTy7mBMplOFHDFUTQiKsYaj4yPq0X9PIzmTkDjYnXB4MKOsMumyMdD3LWJguTwHUaazBiMZvPnO/VO+8Z07DH1i6CKQUbshhkwe2Q+IGGLM9DDKRcDID0NONumjO258N/LMKP9i1uaZ+/BZv7UDFKx6Buuo6pLruzPEGNAWNWSSI02IJpwpKWxBHyNn6w7EgRhCTNuaPzFkSJQFRLFOckHl0I+cF4nCJNDIlStXUOPwNuIYsMkiyVI55aUbhxzuTtjb26dw9dhFI0O4FuctlViaQsHCaZv48i/+Ku/cP8e4GptKFId1hmbaIKbBSIVzlhg9MXkES+VK6jLiNJ8BD9Mvf7dUrM+M8jcY9Efd8we2awFEKSwcHczQFLhydExdVTmYkyK+74h+GFuYKCGOhA5dj/dhu42WRZFh1lXmxymKAjGydT11vA5ycOWCTStPoIhFUuS5q/s0TulWi0zobB1DSAw+MQyRs8WKoiyzEaeJZdvzy1/7Nt944z26FBGJlIVwfDhhUmd7AMnjkeMESlVWTJqaDVY/D84HRuupR/yZCfJcrPTH485FsqGVNOb6fDzXru5QFQ5DOdbfQ1MWOEMulhyLL4RsxMWYt37VfJbGlBBjMrJn3PJXy3Z0B3PMIHqPGrZx9nGaEhESFtGe43nN4azidU5BSigrrCuIQyCqsO4Gpp2jrguMiYg1vPX+OYNPdD7w3PVDTFlgXIXKQNIMaN20fNExw1dVFQ8r+FHBsY8UM4fqk8EJ23y/yAhfUoTI8dEOk7Kg68nbtU+gSlWWWdkpZcvdmjF8Grfx/KIsiDFiVXJoOFUszlfEsWgiXgZ8hBFfAIjKaNjBpo1R45QXb13ljfuB+6uBIeUAkqlsDgip0g+epsmwbSMGSYZln3j9nbvcPW1Rsfzdn/tnnC2WiAgx6Za9Y+g9iURd15d0r09Ean+EDD4BDKoPnvEf+AKaGwtKKlAVZjPHtb2ahIWyRMqSJNkPFwLGKCll3ruMs8u5chAGP7Bcn5PCmtp6mkpwTlGJYAUpSsTkTpcMA1YNQSyiBQGHyIAj9+w1JubVK7m3TmmFwiiGAHicS/hkOF8F6qahqQqETBLd95G2D3zt9W9jnWU2m1KUJa7IJeIkxceeJCFjDWQcLX1wnC6DOT5SSJ6H5XGRvtELGn8BtY28eGuPwg00TYHiGXzH+XqJR3O4d8zfX87iZaJFQ4q5orcsSgQDKoSQMgBjRP2G6FHNlCuQRqKAi+rYcbqyP284mteU7mJYnXMjTkEu0DxtN8Yj4phDSMxmM/wwMN+Zs7uzQ1Xm4JBBKMe0cubp/aDKfr3h3mdW+U8rLiWOd6eUFrp1z+JsQYhKH03m5h2Pi+wrxxzkGX3+zK1b0DQzClfTtl0mcQ4bbjtFLGQyzcRkUiOiiGwmAA+cVbVVbh7OKU1Wei7ITCOVq8WNqOAQcvu2DYmiSG764Ao3gkwidVFhEcyYRzBJtzkFuXTmb/H7H9Xw7uNgx5eBlg9fv32ujqOdXfAeJUO8FENUy3oVWC67fL4qY+88l637EbdXFjm3f7ZYEqIixlIWGUEjCs7kfECImRP3Ium0CSaN/1fBoDQFI6OmUjhLXTqMpJwddIbC5chhiuOkcI5+8Lz59tsURWYWybDy/P1DjNs0s4xcAg+P0eZnHpfLLvJHaNt/lJ/6YWdXxLA/m7HTFESJHOxVVHVOf4oKq3XcsmdvQrnWWozNPfGqqsiGncnWvliDWAEjWAwaDcY4kJw0QnNaJ420LgrjeGdGzKqEMAQQQVLu8yMp4/5T6imLjNXPqeKMRbRFgbgCV1ZsAnRRlZEjnoiiRnJU0X6wlO3ycZbFkGOST27E9Mwo/+F49MNn/uMmgAGqEvZ3GzQGNDkKwGr27/sQWa5birKmKKstgNNaR103VFWFMXlFhRBGStQc6XNjvXxOESvrtt3u9I9ONyd2dmbM59PxfI+gJhdgODdSueetPXi/5fM3kgkknLU0dU1RlmPouUUEXDH2+XNuixB6XPx++9pThP+eGeVflscZe4+8VhPORK5f36csHNbUNNZSGhBrSBjOFiv6EDG2GPl4s/s3nU4yUHPEyCM53VtXdTawinw9o53QtusHtv2HbgQkMZk2FKUhhlwynquKJ7ixgZOO0blNvH5DFZtSZuvebt+quRzM2owIJuvTXMIgXh6rywvkcszkSfJMKn8jDxsyjwpkbCztF453cSkSxCC2QpMQg8+UbCH3zCF4CIlpM6dvAwaXmygBKRnKoqKqSpyD2TRTuiSyHWBHgIiqIiZt27HlQc+TUDFMKsfQLrfBoPWQA0/WGKIPmQfIWMzYvcPHzAC2bFcMwxiRDAFVQTFoUpCML5hVFYXk1zP15gX/3uUxGZ9l3p4nyDOr/McVan7A7Rt779w62uNw1uA18c77dzk5zbz7PnhsUdC2HbvTCYUOpPUJxi8xqWN3WpFCt7UFBKUsDIXVDMVKMU8AzW6aIIiM9KeXJqeoAoZpVfDc9SMEJaFETXR9Tz1Srzib4WWK5jy+czk3IZKp4cZoY4iKDwnvA34YkJRwIrix86eoeYBv/4PYB9nGTB4nz0yEDx4czKdxXzZWtiBMKsfx/pw3Tu+xM99hvVxlQEdKDD5w/3xFaYT+7D1+8Htf49rVF6GccHa+5NvfUV5/52SbMdygeDMDpiF6tluyohgjaHxoco5/W1phWuYSLSOGYRiYTuoHDLJNqdZGNsdODh/nLV9kLMCEnMRJibqqc+PGS99fhC3/7uX3fxp5ZpT/OEU/Cs3zgCdAHgCLcrQ3Q+QeVVWhMdKngA+BmCzrIfLm7RMOmooXbt3i+pVDghVevH7I1d1d3jv5x6zOO4qiGI2tfpvICaNvPQx93oYBHZMtlyWHfiOTIrt93ucGjxuXtSiyZ2FT3hc2hmW6VE20MSU2u5wZd4KkiaZpsObSmT/aDxtQ2cNj82HyzG77l+Xx1r6AGlzKee8bRzuY5KmcsDM3eaU0E9QHNChDUtykZrZ/wHQypSlyV6urV69w7eAQo4mqLBmGhCsajCtIPuGMEDWONXWKUG+GensnyRhEsztWNzWVzUmaKAUhKX2f6d5dOTZcMHarMmWTaArENCBmLN4g4/wy778ymY5FmgIqCRXNQaDHEFp82M75zKz8x8mjXKpNUGgT09Ax0HLjeJd5VRC85/277xKZYesKi5JCzPn+IY5JpIATQIXSGA5nU0prCTGOvrvLtfFjIsnY7ArmLTmzZz08Ic14Bs+mk4wDKKpMoRY9fZeIGqEpM9NmbhY2eg1jOzcj9P1ACBFrDKIZjDoMmUVkE9ndBJcQHW2ND8pHqlBzI5eVvdkuH7eFbVZfFENC2Z+V7M9KQlQOr15nOptw/XCX7/v855jOpogUODfl3umSNiqJbDRZo9y4ecx0muHg7djqxHufXavRGLs4ZnLodxN9lE2WUSOGxGxSQ4rEoSMOHXY0Si9XA/kQ6Ieeru8Jl878jcLSWNkbgt8Gc2fT2SUPJ1cvPSr//ZEGcD51CVL2sUgIKtC4XD8fFbBl5sIhEYaevusR63CTOb/4te/w5a++yTffep918AxE9q/sc3zlmJQS5+fn+GGgKFxukSK57Gpzb9sq2XTJtx6VL6rs7szZ3ZlROAuati4nOrqHKb9HWZRU5cgWrhem+8YG2GL3QsAaw3w+y597eQh+A+P8zGz7jwMkXC7geNgDEBFyQ+kM70IsNw52+PnwHnFQTu6esW7XzPfmqMnI1/V6RTyecPtkyVe//k2uHB9zcn/Jug28++7baIxYAqJQFSVnbSDGAZMiGhUrFiMW1IweQM4OahyrCLWgKRxlXeDPB9REoCQlk6HhWFxVA2DGrKHVjAiykgtIRLObNoSAST2VqyB27M2mYOwYvB09DLHj6v/up8Ezo3x4+u3qA5Pk0vNrV/apSkNyluOjI877Bat1brag5OTOnbv3ONrbpa5nvH/nlLffeg8fFD8MdH1H166JCYSBYehzPX/KhZhGMvWZwFganqOFkDF1CUPplJ1pkXl0CwdRRjaNPIFDCCiZps1aMCZTtcRgMKbYNnAwAmVp2T865PzdBR9/8RY8VKr1wC7wtDvmKM+M8jelTh/q2z9i9V94A4njwxmzScFp1yM4JpOaXGAvqEacq3C2pF13zKYzJpOSg8OB09NT5rM9FEGN5e69E1bna/xIx76hcUspV9HKxkXTRLbbE1FyTZ1j4HBeUBgIKhi3MRYjhS2J8aIKNweXDCJKWeZKXCQRkyemQF2XYCI7U8vz1w63R/zlUXp41/xNrdUTkT0R+Ssi8qsi8isi8rtE5EBE/qaIfH38uT9eKyLyn4jIN0TkF0XkC0/zGb8ZIgK7OzUv3DpGFKaTCUaEtvXkrpoZyZMSGOsQY0eodI9IboM6mTTs7O5grcGPeL/NGDqXO3EimwFPlwyuyxCziKQBCznGH3OT5qqqELEj+WNPGgknc/kWJA0kzT31nLU4J/RDz3p1hjORuhxX/Rja1YuU4kPWvV56PF6e1uD7j4H/WlU/AXwPmXf/PwR+VlVfAX52/DfATwCvjI8/Q6Zh/02RJ5UjyxjqakT4/CvXqKTi7vIc7XuCpmwQlg4kgBG8Jvo45G4czhKAZbvkdHHGar1kSJ4oCWsTkrJ7qJJBm9EOiLWYmNAUgEjaHAeaiGox1YxBlT55luue6DU3eQiJPiqrvqPre7quJficXLI2u5fOOAoxOGMJWPziHIMQxAGb2gNDhr1dzL9NDl914yH9BpUvIrvAjzDSq6rqoKqnZF79Pz9e9ueBnx6f/xTwFzTLz5EJmq9/2Oc8Lpz7pLz+oyaDEHj++j47jWM+m9A0zbY9ekwRHYsmrbXEkSVr0+DY2oKirHCupCprCmfQ6HOqOEaqohrPe8HZDeomPWLLlW26dvPYdPuKMY0on5zeNcaO4eSc4t2EfnO0Lx8LnY+susBqPSDkgI+yqXF4sNnCxa385kT4XgLuAP+5iPyCiPzfRGQKXFXVd8dr3gOujs+3fPujXObiv1CSyJ8RkS+LyJfv3Xs0KfcHU5QfYhBKLrLYqeHG8RzIbNobwyx7yHnbjiEgo5I2RljfDfgh4lyJJiH4Ad+3aAwYgaacYNQiI8vXRVj24XvTvLUPfa4AjinHDDaYgcFTlrlGYBOr3wA7zAgqcc6h5PvqorLsPH/v7/8jREeKOBIZV5geWCDfjdX/NMp3wBeA/1RVPw+suNjiNx/6XfsaqvrnVPWLqvrFw8PDD7v2ka9vlClituBLUJwkXrh5TAp9Prcln9sxhryVhkTXe1brlsHn8uykOQu3XK44P1swDAOkOJZsR6woVVWy7eItlg028CK3nwHlihCGljBkkkiQ0W/PNYMh5JLyGEMmgJDcFTwHfDKVqjEWZy+oXZLAz/6dv8ditczdNTaNBh+K6X838jTKfwt4S1X/0fjvv0KeDLc32/n48/3x9xu+/Y1c5uL/TZUcEwc2K3qEf/tkOT1f4axS1BVD8GP6C/wQ6DuPD7Bcd/iYadqGEAgjxSqq1COWDs31eBCZ7jSII7N62Vxrn6N+l5G8Oex8vNdQWUMM+XODJrquZ+j7bXAoc+0lYkwMIaIYxORGUVHJ3ThCxPgeHzrevn/GN9/89vZ7itgcat6Mhz664ulx8jR8++8Bb4rIa+NLPw58lQd59f8ED/Lt/8xo9f8gcHbpeHhqedJMvjj/L+DVSD7/VAxnXeS9+wt2dvfylxSTe+HGuK287ft+u20PwwCw5b7rh+wBXFTpZpcuV8s8eBRt/gbN9XxCQjRytLebSZYkG5ZBFZ+UIUSiClGFISRCUuJ4bGxII0LI4d/MMKb0QVj3SqTkV7/xnQ/EdJ4I53qCPK2f/+8Bf1FESuB14E+RJ85fFpE/DXwH+MPjtX8d+EngG8B6vPZD5VERvg+XjSI2BiMkCu4tenp1uEJpT08zc9dymcOt5E5bebDz6t2kVX3w2zDrBeTakIYMsdr0xduAJUSyEZlj/IoR3VbvzqcNk6birh9IJkHI2/8GISzWoWKxzuSzO4VtBxDvPXELL1PUFFT1LqVazpb9aGNcGMlP8oKeJE+lfFX9p8AXH/GrH3/EtQr8O0/zvo+Th2ftE7+IjOftNj+q+CHmLdFmjr5111MUJUrMysIyDD1RzUjo4DOCd1Sm9z3B98Q+EzHrWHpVFJCII72qwMY3TyM3bxIkgaqndjD4jhTS9vZyd+0e1wqGgG0qghpS9KzW6xz502wsgiImYwfreoYW4FzFdDLDSCQJMKJ5Hhy7C4v/wybAMxXhe5RcBjV8MPYPqNkY8DninZTaGqLvafGsu46+y9u6Ky3dMBDJ/XZiUlQFY0uSerqhp+86Vuslq+U5vu9JYcCY3AZNTCCRRkClQQpLCB0xZbZOEbsN9BROKKcT0kmHKwowShwizWSaO3FgSCGAMVgRqqrGuY3nEYmpxfsuI4dEiGKp6im702ku9RhzGhnQ/xi396OUz39SmPLR25s88FPH/XBnp8Fq4PTOfZarwDjG5DRsruHPTJmCqGZXMELXDXRtdve8j7mmbwwebXz6vL1cEDcPw4bCVcYMY0K1xAdYrbsc2k25NrD3gfPVGgVitKjmmoCisNvt3nvPer0eO2z3Y+AoE0Ce9y2/9q2GIX4RtwnoyHfHsX9ZninlPyqr97jgz8VrF8WdG5hD0zgmlSX1gaFPlEWN2EyRSoIQMmNmYS1iLH3f0/e5m1bfedar7mJHGXH1m/fOuLq82jY1gCkpMWVUb9IIWnF23oItUNvSdxFRk7N5AiEq0XekZGm7FVWZM3Nd1+G9ZxiG7YT3wROHnr4/ZUiWL3/lhNd/7Id47cUXgUg06ded130m8/kbeVR074Oz/FLAg0QSTy3CvHFMduconnbwxKRAtsqNEcRYhq3VHwhhoD0/p1ucE/tuzM1ncEUUg3eWRRcwSRB1JMkQbFUhpUBKPaK546eRyOn6nPN7CyQ5KuNwY/YupEjQhC0sIYGxJYPPPX1CgpByencIiXa9InTrkdE7se5OuH3nPr/wi1/DkLCEHEfQi6TTZdf3w0isn5mV/0hw5mNW/eXrsrt3mWceigRNVWT489Ch1hJWA1Ia6qLCh0QfBqwITqAffO5lv17hh35sUZq7asaMr6ZwhvNFOw6uQSSODRlGiz96kCoHf0ZCpp1Jw1un50hKqM0Ye2sNQ/CUtiCFnC00knejDNdW2s6zbnv8EAjDkPsGI0yaAjuETPQ0xhbM5ks/MC6bmMeT5ZlR/qPksivzpGrUy6+bZDAS2d+dU9hTZs2c87ZDg2c1JHSS262IdZmiPUW6wbNYtUQ/AAlxJpdO44hOqKxQoayXS6LkSjgDYHK174YXP5rMnC0Cs8qwPH2fECRPiLihehGaqmAYAt2qIzUlImO0L+ZJ0HcjB0/V0K9XqOTyssZUmNjxsReukiQjioULYqbLdtEmRf4keaaVf1metAtcXEQuZhDPfFqzXrR0644QOkpb4HA5kpYiZVXhQyQGT+8DPm22ccW6zH8rrsK6jJDVtqOpa0YK3VydJSN3f8z2hKaEmhwhPNibsb874e7dc8QYYpJsbMaI4ClF0SS0bY9qP0K2cqwoxtzedUMQ6f1AYUvqwvBDX/wBvvTFz+Z60ZF+Ljwi4PM04/XMKf/h7f+7E0VN3qprAn23opxaCNNMvOgc6hN93+K7Nb5r0ZDQGKmLGk0mEzHEhDUO0whiFNr7aDzj+tEuFksikjRDOKy4DPhIY99dFYyxTErHZ1+9yfvLni4lktExDmAIfSQQx1g/oIYURupYjfRhwPcDYizJOWw9IcbIpCr5Qz/9r1O7mjSCuYSLgM93K8+EwbfNZn0I3PipvuB4yd7OhMIpe7s7NFWdOffKkmgFcYa2W7NerfDDsOXr1zFpk5SRjEly/9yhxVnlxeduseFl2BhUxhjSmBlMKRNA5C8FL710HUkBkQo1FjWGSCJqyNHglMZMYgBMLjCJkbZt6fo+1xFuwnkIy3XH2XLNQzieX9eYwzOifHh8kOJpo32bbc5isMD+7owrR/sMXc/QdlgxpBQJMdCu1izvn7I8O+fk5ITlcpm7ZCRPkgQWbGnQ2BN9S/QddWm4euVKZslg3PuRLftG3E6AfM4atbx49YDXnt+nsppxfCo4IzgDhTHURUmRaT8eyP/nGL+QYswTjIwi6nzkn3/tG2Ns//EL4cPO+o08M8rfyJMiVU8Cc6jqxsEBMvDxpRdusL+7x97OHoW1xH5geXLC2e33Wd87yRW78znz3V1ms3kuzIgDIQ2suxUp9qD+/9/emcRYlmb1/Xe+77v3viGGjCGrKrO7eih1Y7kNksGAEDbgSQghS/YCS16ZBXsPbIzkBWssy0iWvEFigSXLtmSz8MYLY9hYslt2IwymW0UX1XRVduVQOcTwpjt83/HifPfGixcRmVENTUaq8kih9+K9+967955vOMP//A9OIocHe7x5+43szvV7viklDbM+DX8uCrtB+Dt/44e4u19QIZR42vmcVNc09WrA5K/TrCS1si5EiGtAka5LTLdv8dGjJ0TN5HIvKMR8kdw45ffySYEcItJ7/HQoyXm+9OY21XRitCYxcnL0mGePP2S+PGb3cI+333mHNz73OapbtxAfiKdz0mxGWs6hXYDWOHH4UPADf/kH2JpO184tR/sk0GmiTQ1KR9IcopUEyfH2/pSf/YkfYTK12d20K9rY0VITpaOjRZ2tJn13r9hGylAac1iX0ORoGmWxbGhjRFyHT4JLZzy8n8TQ6+VGGnwDWcKaXNegMR/d4RXu3jYufLzh5xanS1IbmO7ts33nDmU1oV0uqJ885ujRfer5sUGk2mTNkxW8L83AUmfJlPyXyblx3mfGzjjEJlJSnFeSs2KSt+8csr815eTpEUpEsWxil6ww04mwrFeIGG1c1IQ4yxGk7OaKVyKJP3rvWzx9OuNwv4IeRHrVvXjBPbuRM3995F6F3bss4tfz0Dj1eJS9rYJCIqt2yZOjZ8xmCyaTHQ5vv0U13uLk9Ijv/Mk3+fjeB8xnx8QQ0KJCQoUQUKw7dhuFk/nK5rqs42eM2ds5f+bq9ZE2IskZl/7IRw52tujqlTVL1kgH1G2kQ2hiQkXoSBSjClcE8J7xdEIxtpZwBDMUP7r/hK9/44+tBlA60mZab+0evUhujPI3sfiXGXvrGP3nh3wNReslUQRrtTJfzijHY/YO9pmOxuhqxbPH91ksTwnjMcWtQ8L2HsX2AWGyhxRTQlGCC6gU3Lv3gOVqiYpa35v8O875TOtq6WJLHmVsHRZ3L3zicG/HikGi0natNXUKxsRZlSXjiZVfJ00Dv2/MhSLVKPMGBY+4gm/fu2+wbytUe6GXdJXcGOWvy/Nm+mXHDheu4NQBiSSGnJmvamZHCzS2jLe3mBwcknzBsl6QcEwP7jDae4udvTvs7h0SJtsQRga40EhyEfWeBx895cN73wFJxoWX+ogjGQzS8/xFkkaiRpzW+ORICk+OnhE1klJFURaUIoyCJ6gFkYiJKhQEcRR4gjqLC2AuZ+lLJHpOlwvqroWo+GgbyGX37DpyI5Xfy/Os/M3VoUfX9J05+2xfvWpJSSiKiunWNuqU+WrOycz299I7ysIoVkUTZfB4BySLBHo6NEVO6si7f/xtXHRWHzgst5Ijg2lY9jUlNBp+PgqcLiPvvn+PTq06p/BnLdeLorBybBFLOGX3sSzPUEMqYhXFvuD2m2/RpkRCDOenF1Pd1x0IN0r5ly3zl73ey2W5f3CWjlWHquPx46dogul0h+3pFqle0S7mdMslXb1iOT9leXpCig2iyYIymnAkM6a6BlA6V/LNb91DkhmTtrzbzPeZYsV8/XwamX0jOeGjj0949HRBmxJlVeDED1j+dSJoyf39xMnQ/NE5h/MF4gvazNPz7PiUqELq+/ZtbJmbntJVcuOs/V5edOKXj+6z2QiQojKuRky3Er40WrX58SmL2Sld2+FDz8HncaFAY0NqO5wXImBFkRFx4KuCB48fkzTS4SHTqghCkIBTQXsgZwZxavI4SXz48CnLuiUU1senKisLDHUdKUbajO5FNXf78LSNdf6L2SOoyoJOW9qu4XS+pOkaitJ6gF11717JxM76jL9qyb96dKesewVJ7GxNqY5X+KpiuVywWC1pU6SabjMajdYMN0dswHnHKrWk4EkdGOFTIqaa2emMpB2tlBRiMxUVgnh8EiQmiB30cOrk8aI8enqCYmxfIRSZ4z9TtqdEmxJt3ka6pqN0Hk2acYMFXas0qzkpWRr5wcOHLJYztqqtjBb25/Ac1wXD3kjl93IVpKuXy63cfrQbrHuxnFHXS6bjMaDDPlsUBSGTIENmwsi8eGANFr0PdJiB550Yh3/G/wt92xcZiJxTdvMcWEdtFIfSxI7x1sSQRF5yPx9nwI6e3SNX8sYY6ZISxPrxIJKJnzyCtXdv25rlokZ3twEHcjWK93lyY5S/nn9+Xjx/8wJ7iHV+F4vxmc9fFJ7PfPYOsxR49Mzan/TNk/qBY4UTuSVa/z2qBuvuPCRHTB1t15K6iEcy8WFWvpNMq3aePFrFziShhKogAaEskOAhWuGHL4uhGVSPWfDek7pImxIxtnY92ody++7cymrVZPBmD1u+eD9fmT3/ypKsK5b+9ffO/od+vxeE4JTdUcFysRwIFopQEWM0/hvvzzhwVfEk2rom5lZs0Re2jHcNlTi2RyNwilelt7PEKQSPem++vioFCacOSYpzZgOE8YixryAZMaMT6FDK8ZimNZJFK+UyChbvXHYbbQVzzrB/Td2g7XJAJKeekWttq9y8L1fJjbb2P/lnbHbkDkw4EZrFnNOTk1zLB13uq6PkVSMzYvrcU7fN1bIpKeqDlV5LbqvadsbJJ4I6+w3F2q7hAypCzNU9ZnYYtvCN/T3GVUXIwA/Ny74guZ+vG/j/enLmngPQO0dZFZRVgTizScaTqQ1meh6y8/GO697HG6X8q+SqbeBFI1tEmE6n7O3vD6xa52IEzpbMvrdev/SCdeKICriAhAJ1gen2DjhPGrrpmhhR4hl7mIV3E9ElkiR2x2NGCkXh8aVRrA3NmzMCuEcF+ZziDXkAJNWhq2ffI7htW+pcYvanSOffbOVfDOK8WOGbVm9VVVRlZcAM1eEGiwir3EWz/97e4NJkx+WphvMFiCOqoNm31rVbJ+IGX79Xfh9lTCRoGlzbIblli8jZLD1ncMpZctfqCvJqlWsGRawDeNPUVj28ee1r2+ErtefD8127632BPQz2vjN869HR0vDyXSSm2vh0YiKEwvDydU1MkU4EypIgoF1L7IxDT73QRqVuO1xUNJh90P+gc1hjJtqMw1OiCr4rSUHZ3R6ztX+LR0fHrJY12huU/b6sCtmyJ1l6tw8V97WALitze3uboolI8CQUl8vSr7KDnic3buZfZ8SurwLnoN6pB3QMpCVsb0144/AQJ9Ysmby8llU5MGD04ImeAbufxQ6G5bxLicVyma3z9UyiQb98rqVXNRyeknIJvYJGUGiWNURFEoRMu1L6gKNv00bm/DH3zqp/Ga6vLxgJ3lOEIl9p7rm7MeuvIzdq5q+zbV7ltz7vdRGBdDaiRZVRKRw9e0xsOoILiKThWO8cMZdEQ5+gMUCnZnRu23Y50+aYzU6p65rpeJrPN29JzlGECieBAU6iEZWIoITCSsTLYB2zVJVRWQEMy3kUHUrCJNO7xWgM3yLO2rTEjtNlTRtnjMYjNMO/3JrCP8kguHEzv5fL9q11kOeVaV/MzZMciNm/NaXwgqZE7OJgWIHNsv5/5xyx6wjeuPbKsjRPoB8QyVi0m9xV0wi3LYnkxON9SQZ4WYYvdvS9gQ0RHPFiHoiTHArOA60qDbVjcXw/dPMcjUbZ+vdDHKRerSiCMYO+6H69SG7MzO8DLpuRvM1Z3h+zmdMfYFz9tYvtvbengS++fcj8A2W+XKBRabtmwNv320TqOgoV2mjtV40dwwo1c3sD6rbNOBxj1/a5aNNq/ANWNGtFn06NSqVIxuTpfKKNNa1a86QYbel3ztGsavutpBQZm9eqIqGnY7fPqNo2tl21jAqPEVOcdeJa91Ze6Zn/PATPZQOk74XTs+Kg4BCqUFCFkDH2G37wmuvX+/3WSYO1dqo6zLo28/fYZ2Hdt3C5emc4x34LUzs4pWQNm9ZCwV3m1l1XXN+NQ5wYojhGnJMM/giZszdQrs386xp4m3Jjld/LdZaxcy5hZmhxCpIUL4LGRNe053z8vqMWcC6s3EcJXY6yibhhkPTuYP7Vc+fW5+TBVhxru2YKqaqK8WRiWbsc0ClC2IjKGf9P0nTufGywnG13IQS2pluMR6M8UM/iC59UbrTyN427zeeXjfZ+lvTxt6Io2NvftcROLqoUweL1bZN77DmKIhghkxh8KuUoYFxThKoMXbg3h2TfJ8fcN+u5RzLbIHhHVQZiMghXXecu2aytRCK0XUfbdvn3sxez9n7CfmJra3LG1acX8yGvHJhjc0Y+D8Vz2fP+/578OAkkr6QgFGXHbH6CUtjN9ELUBiTZHq2mdDcuacRQss653AypADX6FU22B1tcf7PFmeECzNg0Ni3RSJICJx1CizhrvlCIZRN7H75PAJmClVXbDL59KAqr9cPRqnJ88hSRDocxjTvh0vv1yvn5V1nxm3v9ppzz9c/9JRyRg60Jd984sFXBBfOLUyZUimeESinpsMTHaNU9qmde/TALhxNee5ot9f61oQdPjiqG4IesXVGE3CCxREQoQpF/x7aFyWRiLOF5m3KZ7zfGxGKxYDQa2UrTn9Tavdu8J8+TG6X8y+RFEK71i7Sl+dxReCJ744oCi5hpsk6XqsZj19/gmGnaBAsGlUVpbp87qyPsmbI3z0PVEDi9Czm8nqyBY9+6XfK2EHMGr2f+SJoyJbsFlXq7wqp1z/AFRQiMx6Oh65bqWSPGzXt1HVvpxrh6n0Set7SJwNBDVq3O7XDvFrQd3WpFhyfGFhFwRe9TZ+OvqekaSNKzcxnuPkaDZiQV6ja3Uc9ZwrPfNSu9RxSkFI2fB6u3K4IpOYijTZHUmvchGJqndI5QWot0Y+nIxRti1ksoCkQLitGYqizzoAEMH/K92/NF5J+KyB+KyP8TkX8vIiMR+aKIfFWMWv0/inH0ISJV/v+9/P4XrnUmV//2J6rgtcee/iwAnt2dbfZ2d3JaFbyzm95byD3hYsidM4uiQLzD+XLodC0+kPAslg2I9cjdTCKFohhiDdrDuOlwdGyPLWjkM/8+ea+OffBHFVIyatbY0iZjkYqKGaKqeOcZlRW+31owI3RzO7puoOc6rNufAf4R8MOq+v0YYvAfAL8C/Kqqfgl4BvxC/sgvAM/y67+aj/uuZPMiNkd0PyCuNArFAJbTEg73Juwf7J4bTKjN6n72h+x+9fn83gfv9/6UEqvVqv+VC+drTRPsexO51WlUgsJWOaLpWtrsCWxGLs/29zODdz1g02Uvo4vdEGXssSvnev18ghXgunt+AMYiEoAJcB/4mxgPL1ykXP+N/Pw/AX9LPknMMcuLLuI6K4EtAkopHbvbJW1szlnGzrvBZXLOGRVa01DnLN9w3FpMoF6tLtM7AD43S069vx6jtUGNsFONUZRG17tnng2Cs1QwQy7/7D7YtdZ1zenJ6WCHIGR38bzirxvqvQ737neAfwl8gCn9GPgacKSqfcRjnVZ9oFzP7x8DF2i15RqU65sXsn5x14lqGTuXtU25fbgDmf7cAjce58Mw232OqXsfcC7gJBgu33kL3QJ1PeP4dA4IpDikZO08bFkW7ZfwzJefzIofhURwAe8rkoALnpgHwyp2kLcWEW9tW7pIIY5CrEhEOyN9cs4GV0xrWcON+3XZ88vkOsv+HjabvwjcBabAz7zocy8S3aBcv0yZ68refO2y4y49f2fAi4ODXXYmYyajKu/3mhsWNhdyCkJPjmgWfwjW2z6lllXTWqEEF3nufbDOW6JqXbWTVftGEqORowjeMn85XNx0livAO5quo++aGHxgVJSUufOmE4dzkhHERgNDDmGjF13c4Tr+DGL7fxv4lqp+rKot8JvAX8U6aPTewjqt+kC5nt/fBa6e2mvyopO9Kg6wvj+evwFYFY5Gw+8XHo1dLuKEFLth1vdwKpcrZfoYPGIZwV7q1WqAiG6ed58dBHLYpsugjI5QuNxKLWJdtfxgZ8AZDYzPTB89xJz8bQBlWVKW5dDgcb1Y57uJ719H+R8APyYik7x395TrvwP8XD7m5zlPuf7z+fnPAb+t1zir587eF+xhVwaEtO9yqUzHFVuTMVuTEcEJRTgzpno0rxNj2fben3HiiwzBmx5dy8Z59PbF+iA0kIUp3hoqGJGyYpDspmkscZNbwJgizR4pioKhmWIuAVdVZrMZxyfH1uhxgIpfb5ZfJtfZ87+KGW6/C/xB/syvAf8M+EUReQ/b0389f+TXgYP8+i+y0ZXjk8hVkb3NwM76sec+B3ROiCKUwbE9HjFbNDSxQyXhHMQuQt/h0nt8AonWLk1jpHKBUTmGYoT6gvnJ/KxQU9Z/1yEUeFcgYlFE4+nvSNpSlY5SO7x3BC3OGXux66BLmTMosmgblrFDCo8rHDEzhDXLFamNjEdjs3tgYGa5zDN60YC4LuX6LwO/vPHy+8CPXnLsCvj71/neF/zm8HdVnH9T+r37XIYr3x1PYmdrRAiCrNT2Ue+IVpVnDZO6OIA3emJmdUIIFa6e07Ydi6W5ehZh2/x9K8daKcPMNHcx4VxgazzmqJkjarX5XTSOfe8DwffQ8o42RdRZx862rm1LEMfWdIuiiwYly6tSb/P1xSvXUfpwvtc66iXIVUv9Za+tp2rP+fHYfDQsXsfhwTa3dsZUZciz3Z9z41zhaZMNB18EXFngJyO6FElNS3CeumtJOanS//bZuZ3PRPbKTylRhJAh4i0hGIbQ94UeOYTb5gKSruuM7FkhpTi4dUVpQaSemJnhXlxcIS+Lf2zKjVU+XG+vv+p9yQEeUcGRIHUc7G2Btpk+VdC0mSK20Kx4hysCxagiecPpumTtypetdb0WvSzDmEu3lKFurz/GBplQlhXj8cjAJjnRY3x7tlolVYrCYFziHEVZWXTPexbzOU3TnM1u1U3z48I9eJ7caOU/Tzat/UvdQXEkZ25ZoYHd6YjSCzvTHUAzv465gkktn66AKwOuDKgLEK2VmrpEqzVPnn5MG9tcEbg+APrCi4oe5dNnDzV5Cu0I0tF1St0ZlNwhBBXGVUUKjtYpblQQSsPzxQRtNAhXUy8gtYhz1H0vAE2wFozanPmvjPKva7FuBnvgcvtgeLREKYhjWhUIwul8lpsiy2BJp5xpK8tygHIbwNNcwpgigqPrEk2TLfQs6zd9syNIvx8bCKSHidt7sTNodtu0w/e0bWtsXnn7SmqdN4qiYGt7yyJ9jTVa7iFm63KZz3+V3BjlX1eusv4v8wD6EukkAcQxqQom4zHb+7fMlxd34bNlzpiJgHNK29bUzZKUOkQ8x8enLBc1xny8EYjKYeJ+ywFyF09TUj+wmqbJmMDGqu3y4OuZOPrysTr3+e3xg/VqRdd1FBkHkC/ywgBY326eJzcipfsiH/957111kWcKUFTcQLXinHA8m9Mualwfi08WjRN3BrhoGmW5zN00XY63a8hM2atzhRsmtucPq9HatqCqmWrFZcxAtg0mEzzCcrXCe09VVlY51PY2gFKEQBcb8MKjp08Y+TgEf5KaHQJn5eV/1hG+77l80sjU5tJ/Wex/8IMRvBpFWvCGwVvMamazOWQ0LP0A6BS1boZMRhWFBFxGBVvBfSK2MJvPSRhZsv2muXMKuCIQnZEzWFm9ZG78hBPrzqlRc7lYQJ2wc2uXcTVCU2K1WLJaLYixxYtY+lYjKXUDUZN4R4FDg8P1Q/ycYXl+VbpKbsTMh/Mj9rL3Nkdy78tflQ+48F1qla9VVbG9vcOoCAOipp9JiqFnLOrXobHDOygLjzZC2yVOFw2Lur4Y5YOhYMT26owqUs1oXmvN6rPP3uXoXb/y9BE/HbaOwgJN+RzVew4PDliePhl8eiem/LhxH66b1bsxyr+OX7p+7FWZvauCHP1nRqMRTk45OTlGyspCpX1INaaznvYiRsyQOlJnfPoqBvCYL2s0VwUpuaunrrN0nA0GsCyc2ZzOgCPRgBp9J09VHapyB9ZuJ5mXx5119Wzb7EFksIpz+AxFW78X1wG/wA1S/vPkecqE8yies9j6xZi/iKMsC6pRwe7ONqd1d7aCYO975zEIfSKEkqZd0rUNsYs4V+CLxNGzo5xUM0SPcBbPN0PR6FwsxJzPcQ0cIiIDH1DXddQ5xi9iXT59KK2rVldnIEkGmCrWgCF5CI7gAoqjCM44e2OLOMMN2mB8RRosbaYjXyT9zO+P7evb19/fPN5hMf4iKJNJRUvIAEtTZFmUdF3fw75iydJ63WajMfiK2fIpy+UCpymTPFd5CxgA2Djn8S6YmSBW39/X8ztnLB49hCuEQNu1SAZodDEaFKzr8QIR7TqWswUnT59ysLNFESZEp5QEs9qSslrMOT55TF1baxnrxDl67j28Mcq/QIq0JtfJ5q0PhvUtZP0Yh7K3NWVUlBytjuiioHoWz09rEb8Biu0E8R5fQBlKnDoePD4mkvd46VscSQ7oCMEXQ+w/ZdBI0vPxh36wnisBI6eFsergrq4hdYbxQ9jd3qYqC0LwqHZIgtPjZzx68IDj4yOgs1C29Vpl9oJd9MYoHy4P1vSvXxbFWz+uV+C68je3BQdMq4J2VfPw4WP8ZIfJ2IgYm7YmeVNpD7FKQ1WEGItWKFnNa97/4COWTc2kKtez+tn3dxmw0WPyTPkRw/iFEKw/r57t51VVssog0qIoiJpIYoRNdb0CB+PdbbqV0HYNXYq0zZLTJ0d8+OF7eHGMy4oYHU29Zke07XPv941S/rpcZchdlezpHzcjfOe/JLG/M6EIibc/c5ePT2sLtOgZXi4l8wpWyyXSKRqFIhgGIPmC4tYtFl3i2bMTJm/cJjpwmkAF8ebLS26R4gg4rFdum0NO3gllUdBqIqaIyxZ/sWYDdNEenTc4d6o7RM09RBOn8xnvfePrLE9PGRUOHMznM5qmpYstq3rO7OSE2cnxc+/xjVH+VVb6xeTJ1dvAejp33QjsH53CrZ0tqtKzuzPlyawxg6kscJEBtdtH4iQmimpCs+iIbY1zgcn2hIeP7/H1r7/L23fesoSwWnWQak+53pFSh7V5DTgiqy6wWrXEzuDZKe/v4gRxDs0Gn81YI1/qmhWiCXIHMO0iDpifPOXZgw9w3rE8qlnM55zOZsxmM+bzGYvlCW29RPQib8+63Ajlry/1mwped182ARtXfXb98+u/0UfNvCtJ2lCUnq6zmrgIw6wPIVCLgFcIBUU1ZrU8YfnoKbfdm7x1cMi3PviQGBPeGaZPxa3F8a1cYzyuKIsJReF4+iwRwsTan+vqnIHaN1Bu23YI0mgyzEHbNMS2w6lSt5Gd7RHd4ph3f/9rLOsVtG0mZzqDfe+UI9x4RAiviLW/qbxNJW+yc15m2duynS58x7AdKNR1w/37j1i2Ee9HqFoJtJE1dDRNw2q1omtbuuWMZqX4FJHYsjupuDUa0a5mHM8WFiRCwZckFZwodV3T1DXjaUGRsYAqcHK85ONHR6RkNKp9C7a2bQd42FAn0HUUIRjyWBXEM18u6GJksrXDyem3WG1b6ncymVKEYKuX83hX4KREguCKV0T5cDFLd5nlfpVBeDGbdjEAlCiYzxb8xXfe4r33P2T7oGQ0mhKT8icP5qxii8dRCewd7oHsUFSBQlv+8GuPeHJ0Sv34Iz5/e8r3/4XvM9YslZwXMCzgo/vf5n/89m9x+/Yeu7u3mE53SFGZtRWff3sbd+q4f79GO0dKrWEFJRpfULA4geAIzsAlTguK3Qn7socjEds5Mezw5hfusDuKODe20PG5lTGHd93l22MvN0r5vWzO+s3XNxW/jpjp3788wuXo2gUxLYku8fGzBV4it7cLqvlj3hxvIU7ZGVfsbQcePzjhwaMTfLUF4YDdKvKld77A3/vpn+CnfuT78ZIJlgcsX2I+O+XuW29ycHCLoihwTkjimS2Ee3/yPp/73Bf5zNtbfMyUb3/7Hg+fziyhFDzOC8vlgth1FN7TrJa09RJ/CoULfObOG0xvTThaHtEkYXvnFiIjyxeo1QdIBoOuhRivlBul/KvACOt7+uYqsC6XxQjWP++JfOVLbxMd3Ll9yL0PPubhk2fMVspxs0XFFidHRzwOHXu3PKHwHB5use1W/KXtCe1imx//ye/jp378yzi6XHsvRsSXc/HL5ZK7d+9iUV4BFdQ53torubu/w0ePjjhZ1XzuTsM7h4EdnTKZbOf6go66LlgtV2xNp8xOjjg5arh1uJ9pWVqePP427fwZZfVZRlu7SPJYfFIvrHwvkhul/D4TR87H2fmf55mz484+o6rDABfkbMDL2fv9o1Pl9qTiJ3/gy/CVRFMrx6sFs+UJv/c/v8bjD+/DPlTjQFW17E/HvPnWXbYKoT56yr2PIs1H7xEXfwUm+0MmT6NZ+UdHR1RlSRWEpG2efQ5RYdct+Os/+Hm+c9Tw/sOn3J8lPn4649nxjNHKiJjbtqYoPPc/esBn7t7l8aNnHD15wqqF1LVMRsqbb9zi7t3P8oUvfpGyiEirmazJSCFV06Vb3mVyI5RfNyvm9SlFWSHOE6TPhufkRiY0ijHhvUXU2tbQtUVhFGiacpvDlBMtZHIe1tC8IuC8uU9eGE+FYlJwUG8RPrdD2u+YbE0oyjHT7W2Cc6QwIqnwsYeHD79Dt1jx+KN7HH55C3yA2DE/Oubhw4948uQRB/t7mZGrDzSBeFA8pdR8fh8+u7dP04348H3lgw8bYlFxEoVlDKDCOB1QjYV0a8Rutc+du/u8fbDNO7d3ONgtCcGYuFJyaO7y3V9jz/tryZ/nr/vySXPp3wsRkVPg3Zd9Hn8KOQQev+yTuEI+r6q3L3vjRsx84F1V/eGXfRLfrYjI/3kVz/9GIHley8uR18r/FMtNUf6vvewT+FPKK3n+N8Lgey0vR27KzH8tL0FeK/9TLC9d+SLyMyLyrhh123ddy/+9EhF5W0R+R0S+LkZH94/z6/si8t9E5Jv5cS+/LiLyr/P1/L6I/NDLvYLnyGZt15/nH0br9sfAO0AJ/F/gKy/znC45xzvAD+Xn28AfAV8B/gXwS/n1XwJ+JT//WeC/YuG1HwO++rKv4aq/lz3zfxR4T1XfV9UG+A8Y+dONEVW9r6q/m5+fAt/AGMf+LmeUc7/BeSq6f6sm/wvjLrrz53vW15OXrfyBti3LOqXbjRMxNtEfBL4KvKmq9/NbD4A38/NX5ppetvJfGRGRLeA/A/9EVU/W31Nb7185n/llK3+gbcuyTul2Y0RECkzx/05VfzO//LBfzvPjo/z6K3FN8PKV/7+BL4uROJcYp+9/ecnndE7EECW/DnxDVf/V2lvrlHM/z3kqun+Yrf4fA47XtoebJS/b4sSs4z/CrP5//rLP55Lz+2vYkv77wO/lv5/F6Of+O/BN4LeA/Xy8AP8mX88fYITVL/06Lvt7Hd79FMvLXvZfy0uU18r/FMtr5X+K5bXyP8XyWvmfYnmt/E+xvFb+p1j+PycUnNkug2uJAAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -258,7 +259,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -277,7 +278,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJEAAAD8CAYAAAB3skanAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAACoT0lEQVR4nOz9aaxtW3qehz2jmd1qd3f69t6qe6vIYpEUSVFiqAiUFVu2kIBxEqhxEguGE+aHjCRIYFjOn/iPACFIYsAJbFiGZVtAHEWJJEsxBFuyIkqJOpIqFUUWySJv1e1Ov9vVzmZ0+THGnHud25/bSKeoGgfr7L3XXns1c37zG1/zvu8nQgh8f31/fZYl/2m/ge+v7/31fSP6/vrM6/tG9P31mdf3jej76zOv7xvR99dnXt83ou+vz7y+MCMSQvyLQohvCyHeEEL8iS/qdb6//ukv8UXUiYQQCvhN4J8HHgC/CPzREMKvfe4v9v31T319UZ7oJ4E3QgjfDSF0wJ8DfvYLeq3vr3/KS39Bz3sLeHfn5wfA7/qwBx8dHYX79+9/QW8FCBCIHlcAIYC1hu22ZjKZIKUAAt5ZVosLgjNkSpApsMZgraM1hrox6Lzg8OoNymoMQoAQ9N5cCHH5gs+/PCCGe52Pf6oICAJtveWdt9/CO4cPnhAAIRBSQgDrbPw5Pb/3AbHzepnW5EXBwcEBo2oU7xcShCQQ32P85B7Bp1u//MvfPAkhXPmg331RRvSxSwjxc8DPAdy9e5df/MVfRKQT4r1HSrlzUj756v9++NsAhIC1lkxrgvdsN1t+8Rd+kStXrvH6V19HhIAUhvX5MX/rv/4v2J6+w5dvzJhow/L0Ke+885h3H53wWw9OWLuSr/+u38f//H/5bzI9uo5DEAQ478iKAikEAg94CCCkxHkIUmO8IIhA1wU0Fmlqzp+8zf/l//An+Yd6Q1NvqdsOj0RmOaPpjIvlgrPFBVlZEYQgKwrapsUZR640WZZRZhk3rl3np3/6p/nDf/iPcHB4BZlVkFVYMkyQ6LxEus2nNqJrVw/e/rDffVHb2UPgzs7Pt9N9wwoh/OkQwk+EEH7iypUPNPDPdSml8N7Tti3bzYZnz55y5+4dtM4IxJOttKKsKgB0ltN1Fms9ddNincM7z2RU8Uv/4O/xp//9/yvHjx4QnIHgUBKCUITkAYZDG8Jwy2RAC6hCjbIbtotn/Of/yX/Er/3jbyCCheABEFKjsxwhFZ1xOA8eMM7TdgYhFUJKOuew1mOdY7lZ8Y1v/iN+6Ru/xKbeYJzB2BalJVKCsd0Xdmy/KCP6ReA1IcQrQogc+CPAX/mCXusTreA93jmElPzGb/wGr73+OuPJBO9dPOdCIpRG6QzrwVoPQqJ0Rtcagg8UmWazWqJw/N2//Tf5T//j/5DHD95E4vDORKeXXk+krQrvEDhksCgCwRqysGH95C3+0p/9j/jm3//bjHOFDB4pQCmNzjRKKdq2RQhBnueYztK2HdttjbEWIeJm2JiOzhrW2y1Pnj3lb/6tn+eXf+WX8TgQgaZZAx4p/Bd2bL+Q7SyEYIUQ/wbwXwMK+DMhhG99gr/7It4OIQScj/HA+fk5TdPwg1/7GkEEvA8opSC4eMKKAikVnfFoKQlBkGUlQtRIBKMiY9UZMiH5r/7L/4Jv/fq3+MP/43+Fn/ypn2KajxFSEnCIYBHBQQjpSjV4J6gXC9761t/j5/+bv86vf+tXmVeata3BO6SUZJkkKI2SMZ6Zz+foJuP0Yon3Dh9idIPOIQSC93TW4DYO5wy/9mvfoihKrl2/yf0vf4XgAyEYQpAgJSGETxUmfNT6wmKiEMJfBf7qp/nbz/VDivh8QgisMXznjTe4desW8/kcKQVSpjgsBLTOQCiUjluJ9wLnBTrLmU1nPHpyiggS4TxaSUoV+PVf/Uf8m/+bf8CP/PiP8T/8V/5n/MSP/Q6uHh1QZiBEQIhAV9dcnJ3x4J0H/Oqv/DInv/4LbDZrxlmgEArbSAguGmlV0jnBeDrl1t076Dzj5OKCN995h/OLBevNBmt93EadJ89zvA9Y11H7+Bzf+MYvsTff44/+T/4YRzduAS4G5oDfMaL3JwSfbv1TC6z/ia0d79Y0DXVd87WvfW3IrNKDYvYmBHleYIyjMxYlAs6DUhl57iEEtAjo4MgzwcJ3FDqwqQ3/n7/+8/zKr77B/+hf/u9x8+ohB7MRs1HOcnFOs1mxXq5YbzaE4JkoD5kglwWruqNtGrz3jEZTahuYTCa89tqXuXrtClIpDg/2mU/HnC0WPH12TNu0LBcruqalbTtUphC9V2q2LK3l7/x//xYHB4f8d3/2f8DBlesEAl4KtNZ473HODRfXZ12/LY3ovQcmpMD2ze9+l2vXrjGdzRAhPi4QYtxLvDVth7EW70FqRdN0aJVTFAKtFBKBFh4RLPNJxfp0y960JMskwm559N3foLQ32TzxSNdS5RJvOjIpmWIpygLfKpxVKKVYrGs2dY3OMox1FEXFvbt3uH7taiwxeEuVS25dv8Lh4T6v3LvDerUGD8uLBZvVmsbFlN+ZjtViwWa95unDB/y//+Jf4HD/gN/3+/8As70D2uCx1uK9J8syhBB4/9ljpd/WRhRCMpAQuFgsWK1W/PiP/zjBOoKUaBlSTSYakA/QdR1KaZqmZW9eYl0gywq8h1FV0bSGqshxSlIKgRIeLyVKBdx2ydmTd/nqnUNE27A/LSkVmGAQPiBzgaDBZBqoWG1bVusNbWvwSISS3L51i9u3blJmCkKH8wa8J5OCrMrxwMF0AgGeSviB177M/PAaVVmRa0lbb1mvVrz55ju89c4D/uKf/3+iZc4/98//C+jZUap4xC3NGPOpSym767elEe2u6GkCJ8fH3Lp1KwXOEu/TNjfsaPHnoijJi4LV+oJrswqtM7wG0QmqsqTrDGWR0XiosoKqLPHWUWhN42u67ZoMh8SyXZyhq4xcgg+WUpcgBN5naKFpLlacnp2xbRrK8Zwbt29z9+7d6FWcQ3iDkgKhFF6AVIqyGtHUDZv1hul4xGRcMaoqxtWIcVWSHR5ACHzl9a+yrVsePXnGL/z9v0tVVfzY7/3vMJvPETsfOx6j54+YeMFq0ktjRLtZw2e9Mqy1AMlY4v5ftw1Xb9yPJ0QKvPC4voTjBT4IBDGYlhSXt5CBXyNwlFnBVhgyWeKdp5A5B/kMVy/IyJCzEaNRifAOaVoqLZAuYJF0usKP5gSVE2zOZrXm1959xjsXK/LplMM7d7ly5y56PCLLCqSQCJnhQ6DKMnzwaJ3FommWM5kqDu8fkuc5eT5CKwXSY0PMNnWumOaK12f3uP/KDR49+i3e+dYeP/j1H0UXFUKNkDrDhVhJl3igzyS/R42oX33V+rOsvmLdG2Pd1PgQGI1GKK2G1+lfKxCLkTgJQZAXJe3GI6SiGk3Ybk/Jy4zZ3ozjkwuyDIQNOGeZz6YsNktknqOd4GA+RXiP8OCMwQpQuiDTGcEHbLCsly2/+Z3vcHp2zrXr1/nyV3+AoyvXyIqSTGVIoTHGIKSkzAuC92RKkmUZq+WK2WyPoiioqhHee7TKkPKy5BcPn+jTBUajMa+99hpnpyc8ePctXv3K12i6lrya4F00nve4oxe6kF86I/o81vMHNLBarZhOp2RZBlwaqkg1nEBAKY1F4oWIFWGVo/ISoXMa01AVFVker3BjO/I8pzYWKWF/f0bdNpR5yd54ROg68C7Wb4yF1tCEDavOUlvHxcrigK/8wA+g8liXElJRVWMUCmstk9EYT/QqImWN6/WK0WjKeDRDa43o/wnxXGyjlEJKGT2S1nRdrFZPJmNOT04YzR5y/fZ9tvUGqfMhS939/0XWb0sjUkrhnAOiQbVty97eHtAH2yF97xFCJq8EbWewHlReMts/xKuM2jha22G9wwZLUeVsz9eUWYYUju16xXw2IYSOSmlka1idnyO9QTgTe2XWs2oNy6ZDZDl3X/8hRpMJj4+PeXp6RhCSdx48YTSecP/OfW5cu568Zp48ZaBtW9rWcu3aEUqp1CMU0QCFQAiJlBIpxfB7ISTOxUzMOY/1FiUlD955i7wasXdwBRt8LERCrKl9iuP90hnR51G13m3iKhW3r753luc5XdeRZRnBxy1DiLgFtJ3B2EA5njKejOhcQ+vAy8B6vWRcTkEGhAxoBXmuyBSUuebqwR5h29JtNoRW4LoG8LgQYkO1rDi6csCVazc4vHufR0+f8uTZCSovcAFW6yVn50suThd8d/ImV46u8PpXv8Z0OqVrWy7OV1TVBO9E3N6yDCkUAtBaDZ8zfv5oXHmes91uARULktZgnaOQgjff+DavfVUzmu6l8kaszkdLerFz8FIYUe8ddlPzzxJcSynJ83wwprIsaZqG/f19jDHpSo2d9hB8iqEUm6ah6Qyz+RTpW3zr0OUU4zwXyyV7e1eoRiPaxmG6FqU1s8mITAmkymjWDVIKrl65hlACoSRZUTE/OGI8neOloihHHNc1SM3R1eucLRacnZ0TEBR5xd78gK7tWC7WLJfL4aIqipKiKBBCkGVZShgMo1EFadt778XTdR3OObIswxhDCI5MKySes+OnfHO95nf97v82WTnGC4lxDqVe3CReCiPq1+fV19n1ZlJKptMpDx484ODgAK31YLRaRByRUgpjPE3dsXdwxO3bN5joQL04wTpH9rji6Pp1WmNQWU41GnF+ekGhNZPRiCBjMF9Vo3gCiwpdFpTjCTfv3uP6zTu0nWW13tJ2HcZt0HmBzgvqpsMHKMqKm9dvsjfZo9nWfPnLX+bK9WsIIWiahq7rhmpz/7niEkihCB68B4SMHkoovHPxfhd/VxQZUkmc7fCm4fHJCd/MC772wz9OOdlDSY1zoLMXOwe/7YH6QgiqqiLLMh4+fLhztSogHnkhBEorxtMJr331B9g/ukJQGUHmqLxCFxX3XvkSs70DqmrMZl3HPpuH2zdv89Uvf4VCZ8z39qiNRZUVejznla/9CK9+7Ucp9o6o9q+iJ3sUs0OMh2cnpzx89Ji2M2R5wc2btzg6uorWGffu3efenXvszWfkuUZKUEogJWSZQimB1hKlBCG45IXixSOFREqFFJKu6zAmVqiVVEgl6doG09Z0zYbD/Rl/+S/8vzg/Pca0LVKI+LlecP22NKLd9N25eJBv3ryJlJJ3332X5XLJZrPBOYe1JgWtHVIprHU8fXbC8ek5QudM5wfM5gcImaF0js4K6qalqiYQBLPpnC9/6ctoleEC5NUIXY55/es/zJ3XvoItKqgmWF0wmh/x7HzJW2+/zbsPHpEVBePJhHv37nPr1h2qasT+/gGvv/YVJpMZrWnY1ms60yAlSAVFmaEziVQglUAqkbIxhVIapTRCSNq2o227IeiOyYbl9OQ44paCIziDMx1/46/9NZSQMTby/oXj0pfKiD7P7n2f9kJ0/VVVcefOHa5evUrbtjRNTb1eU9cN9XbLarWibRqatqWzlqKoKKsxLkBRjthsG4qiYjabk+cRwaikZLtaI0lZjZTM9vZ59fWvcOPOfWQxQhYVXuUEnfHukyf842/9Gk+fHXN4dESeF9y5c5dXvvRlptMpo9GIV155helsRggBYzqMMUBApeC5/0wxNtLkeY6UGiEVWmfJkwi2my3OefK8JMtynA+cnZ1jTEfTbPHOoYTg/r27/OIv/AIPH76LsyZl+6IHhF42FT9ivRQx0Xu7yZ+nMfVZS/+co9GIyWQSm48GAp71ZsXq4inb9ZJxUVDmklE+JjiB0nsoZqjguTI/pDAnlMEh2zWzquTZo7c4v3WECJbT2vPK669y7ytfR0/mtEFh8CyW5xw/fcjf/4WfZ3F+zL2798iygvFoxmy2j1IZgcBsNuPK9WuE4NlsN7TtEudahFBoLchzjRACZwMqFSURGpspghfJsHK26zXb7RqVKVQGKhecn5zz7rvPGJc549wjrKWSgesHY37Dr3jwxi9z++YhSlXUKnpZBWgE6nvBiHbXZ61Yf5Ax9gF7X7iD2JvyAdq2pd5sWS/XjKsR89kUU7coAda3eDoaC5P5Ifl4RjhfUUxmdPWW/ekerbd8+8138bKgbbd8+UtfZjqZYrTmfLHm22+8wRtv/CZPH79LkQl++Id+GEL0GFeu3EAqTb1tqaqKo6Mj8jzjYnGBcxbvYozTv+/Y70vxnIxFUaUzhIqw3DzVx7abDcYYskwxm814dnzMO2+/DUEzGU9o245MZ+gs4+rVq+zvHfDgwYPhuIXw3sLjR1/UL50RfVFrN/MzxsSMp+1otjXNtuHG0S1msynvvvVdcgVeeWbTkmfPltgg2btyg3fffpsyKygmcxwKUY65c/06v/yr3yIIyVe+8gO8+qUv45zn0eNH/M2/83f5pX/0j7h58wZf+dLrXLuyh+laAoqDgyuAZLFYcnh4hYODA7I8o2k2tHVN2zQ454eqsyC1aLxH5BE0p7OMTGssoDNNpjTLzYaLiwu01oxGI7xzvPPOO6yWS65fv01RlrSbFdPpBKEUKkBRFpyeX8QgXxcRi/oC658pI+pvXdfRNDXNdoVEMS4rJuWE86fnLI7P6dolr79+G+fW+LBmb3+f9XpD27bM9qbsHx2yXC5Y1zX1w8dk5RjjA7/jx34SrXK+8Q+/wd/7pW/y7pOn/M7f8eN85auvU+aa7WaByATTvQOkVLSN4WD/kIODA8bjMcvVguVygXeGrmvAe5TKESJSh0TCgQsZq9N5WVzShwJ0TcPy/IK6rpnNpoxGY548ecKTx49RWrO3t4cUgslkTFWNEAKq0ZjpfI/OOlrryOX3eJ3oi1x9R7+/OeuwpkWhY5+qs3SbmsXpOednD5hPAwdHFdasyBU8efSQMhfszUZUGWTac/z0Ee8+esqte69y9cZNjk/PeeOtB7zx9ju0Tcs/9zO/j9e+8hWcc6yWF2iZM9ubI8uctjVIrbl+8ya5ztluN2zWa9omVrqF98j0Dw8o0tam43YjJUrn2LZFKYU1hs1yyWKxQAnJ3myOFIK333qLrm25fe0a49EIb1omidEiBFjvOTi6wvm6pShH2Mh0es8G9tHhxT8zRtR7oZjWW6xzCAJVkZMpWF9ccPz4XbaLU/amI7pmw8nxkrZpOH/0GNusmV89ZLs8pswCufSsFyfcvX2dH/r611B5xRtvvYP1cOXKdX7qB36QO/fuc3p+TlM3aJ1RTWcUec6y3aB0xvXrV5nO5jTbhu12gzUdgoC1XcqPBMF5CCLGQESUgdQaITVZnrPebpFeYNqW5fkFy4sF165eYT6b8fY7b/Pk0RPKquDu7TvkmUZkiuAN1ge0UCAks/ke1X6JygqQ+jnOXs94+qj1z4wR9ctaS9d1BO8TGjBD4VldHNNuT7l6OGYyyelczeMHT1muztmenNCsl/zGr/xDfvC1Vygzic4ks70ZP/47fxJdTjlbbBjND9jbP+DLr73G4ZWrHJ+e0jQNUmqKckSW5VjnkFozn+0znkyom4bVckHTNDhrwXuCixQkGRQEkMRaj5CxHiSlpByN8Aik0qzXa5rNlsViQZZljEcjTNvx+OFDvHPcvHGT2XRK03R475AhIIXAOY9zHbP5Plduv4LMcozvQ+p/xqEgH7Z8KqRJKSnKkhwP1mDsGmcXzCeCcVnRdi0P33mXN995BxcC2/NThDfcuv8aN+7f4/TZE/Rkxp4a43TFcmOR1R63732JO3fuIqTg3cePaJoWqRWTyQylMuq2xQbPdLbHfG+P4AIXFws2yxXWmESNJhUDPTKoVIGOrQwpIsFSZzlVNcJ6hw+BZluzWi7ZrNdcPbrC3mzO6ekJJycnTCYTbty4EVnAxuC9JVcCpTU+BEKQjKcz7t5/FakzpJcEIT62NrS7PpMRCSHeAlaAA2wI4SeEEAfA/wO4D7wF/KEQwvlneZ3PY/XsV+fc0JzNrEdmAnxDkXk6WVNvlrz78Aknz865e+tLvPraVxnPS06fPUYLQ1dfIMYNNjvn4PAIW8yY7h9y4/Y9bty9hdaaJ0+eULctWZFzeHiE84HNpiZIyfzwkGqscT6wWCzYbrdDu0KIgA8QfEjkR4a4SAmJFBLnPYXOIj3bWozz1HXNerUmzzKm4zHOOb77ne8gheD2rVvszee0XYdMW6IPPnpjIRGZxnlPZwxZIoC/YBP/c/FEvy+EcLLz858A/kYI4U8lXaI/Afxbn/TJPi8C48CpSm7ZWktT17gEo/DOoYLCtC3bizNaU9M2G46fPkXKnB/6+o9w8/ZrjKcHuAKm+0csTh+xvJC48yUUE+R4zvToJlduvsqNW/coKsnTp09YbTfM9vbYm88RUrJabZE61mhGozGejtUmtl5CCOR5Rtda8AHvHc6bAQ/Uf4YeL6SygrKqcM7RtS2r1ZLVckldb9mbTlFacX5+xsX5BXsHe1y5ejX10UzsGQpJSB5MZbFM4HxgWzfMswzTOj5YkOLD1xexnf0s8DPp+/8M+HlewIi+iOWsY7Nagw+YpkUm/vq6cQTvsH7EKhyw0oLx3bvM9/cpRzO6fEw2meB9S9cZqukhJ08ek6uSQhcE6zm8eoVrN6+jRyVniw2LrWe0d4Wjwz2kgsX5OU46JtMx49EEaz2bTU2z6VBodK7x1gBgnCEET8Dj8bgMLJ4sE8hcY6WkyHNGeUZTb3Hrc/ziFG/WlIVHZh0yb3jw8E3E2DM9nDKZz3ForNWI0OFFwCPweEZliSgLVJCUSiCbLYUDpxQhhURexNtHrc9qRAH4a0KIAPyHIYQ/DVwLITxOv38CXHvRJ/282h69NzJdR1PXKCljz0sphJAUszGZVpimQkuoyhIAFyDLcqrxCOscbVMjA7RdF5uwOqOuG3Q5ZTqZkBcF3ns2mw3TyZTpvCJTsNksAdib75HpgrbpqOsWa02Us1ESfEBlmrYJKWbrG6CJlZupQRomz3NGoxEhBOrtlvVyyXq9xDlLlikmkzFt17FYXMQWytWrKK3pGoNSkuAEzlmkFuRZiUy9OGvja0dBiQiPES8Ac/ysDdjfE0L4MeBfAv64EOL3vuckfmj7Tgjxc0KIXxJC/NLx8fFnfBvPveZzEFjnHdvtliaxTPvGbJZpqqpEysi/8h7yvKCpG0bVmDwvqOst23o7MEacC4wmE4wPuCDIypJpasg2TcN4PGI2n5InEJh3nvl8D6k0bdvGOCR4pBToRBiw1g6EQu9cbMf4QAgiQXwvT1FR5JRlTtu1rNdL1ps11kaUptYxNT8/v8A52JvvM5/v4X3AeTcgO03yen23X8meEWs/dSjxmYwohPAwfX0G/CWiQtpTIcQNgPT12Yf87RcqLdMbkrWWuq5J7ycag7+84pRWFEWJ1hprHZPpLPWpXMQrS0FRlugsYzKbMd07ROqCYjzhxu17VOMpQsnYQJ1PKYoYtCupGY+ngEwIw2g8zlm8N1gXiYnOG9q2ibGQ8zjnLzlxyRVIIdGZJs+zWLhcLVguL2iaTXJSgbIqEUJyenpBWVTM5/sIoWibFq0zhADnOoK/xJ5rlaGUTlx+S+h1lV5wfWojEkKMhRDT/nvgXwB+lSgh88fSw/4Y8Jc/6XN+3kE1gHcuslrTlRqr1ZYQPEpHUJeUkSZU5BXTyZzxZBqBXgR0JqNBqVjrkSpD6IK8nHD33qvkRUkIUFWjtBX5ISA2xtI2HdakSnnwIDx1s2G7XeOcRamoHxRC/H3wPdFHoJVOUFdNURQJ5tqx2axZb1a0XQM4iiJHKcVmvWG5WHFwcMR8foBzYK2jKLLhvUmVmCHIyG+TsQLuXVQwEZ9CguazxETXgL+U4hcN/OchhP9KCPGLwJ8XQvzrwNvAH/oMr/GpVm8sQgg6YzDGoJVCFMXwGCll1CUi1o2qokKLBD8NSfjAWVxwaK3RUmO6htW2ZWsc12/f49bde8i8xHSWLNNYa4aKuDcOZ/1Q7TWmw1qDMR3bbcQxTaoxSI3SEiFl4oCR5GA8IIc60aiq8N5zcnrMarWgrjcIHEpnaK0IPnB+vkQpzXx+QFmMWSyWVFUscgopCLhUrFT4EMizAksU5Gq7DqkilfxF16c2ohDCd4Ef+YD7T4Hf/2mf97OuXRat9z4V2DykmKCHx/qE7hvUyYRCiKhhJKXCheithIS8KMAblpstWVFxvljze37P70HnFU4opAp4BwhPCC7FT54QBN5HjcU+7nDOYGz0IN5bBIFRUWHaFgR4G40PEQYWSlmWFGVJ3TSs1ytWqwXOGTItEDLWkxCwWCy4cuUaR4fX6DpLCKB1PMXe76buASl1NCYTt8+6riOOO89f+Ji/VMjGz2O9t1vfdWZQG+tRgV1CDMZ0+nIJZEQJppaATsE3IXB+viAIQTmeoPOS/cMrGA/Oe4YQK3FOo8exOBfSLfXrrMHYjq5r8cHFuMg5ijIny2KgbazFueiF8ixuYaPRmBACi8U5m80qkg6VQCnQOsZL5+fnhBC4euU6VTWmqVsIkjzLU9PZIQRJ5BS00iiVDZ6nbVo6EwuSL0o++21nRP3y3j/HktgVBBWIKAIaHwl9b2rAZkcyY55rIHB+fs5qtWI8ifShw6vX0EWFznN8iGAxa+xAmAwhYI3DJq9irX/OkHxweGcHQ47oSzE8JhDIsvj+sjxHa01d12w2G5qmTsySAiEFSkm8szx79ozDw0Pm831MZ7E2snqzZEQhBBBhEPVSSkdcuHUIRLywuo5/ooH1F7k+jwDbpYC65131KfCAdkz/X34VSbHDgyA9Pm4Rx8cnjMZjZvM5Uilu3roT+VlCYH3UgYyaRm7QzfI+GpH3npBKBDEDc8iU/YWdLcaHvozgEEKidcycylS7Wq2WbLbrQQ6m556F4Fmv15jOsL8fcUmdiVhppSLDI8ZXz6ugSCWRSkZDxifvaaIX7AHWu7ePWC+dEX0uGZoP+M7g2i7ihKUk03rwSK3pohqsV0iVYUTASoNVHSEzeNkgVaDdbDl9/JSqkBzsTdlu1qgsY+/KFUJesmwsbRA0XuBkhu8cudA06zUSj203eNcQXIszW4JtCKZGe4vyFhl8rFaHqB3ZGYdxIPICr3JUnjGajLBuS705x5sNrtuiEOTZBO9HWDvh7GzD1au3ODq8DkDXNTjfUVY6ZlvC4kOHDxLI0XpMDIcNLiwQcoOko6steZgiY0j23O2j1ktnRJ91CUhMiXhl9TIzEL1TX3S8ZJH2rv5SyygyLKIX2tZbjg6PUpU7eiit4/fGdIQAdb3Fufg62+2G5XKJFJHeHFwMoL1zw7ZymbFdsivW6zXOpUww3cbjcQTtbzZst1vaBECrqpLRaERd10ipqKqKGzduxGKiMXRdN5QGZBL7fF4RTVAUBW3bDZ43EKG3uxWq3dtHrd92RtRzp/pK8C5I33s/HOAocuCGanGvrtE/3lrDYrFgNp0xnU1jvCMEUkmUlJguxhDeWpp6gxKxkbrdbqm325iWlyVChGE7i9lZ3PZCiEYopcKYjvV6nWKV2IrIdMZ4PMZay2q1oq7rYSvLiwJrLUoqNpv1ZbNZCOq6SRpGGXmeXRZYk0YjxPJFnuds623MQCEB9l6ccwa/DY0IwBuLd7GNgA+xPyUkwXmC82RK410s7PUeCyJQi2Rwy+WS5XLJbDZDENsTsm8dmIiBVhJs19DWNVpJBIHNeoXpOjbJKIq8QCtF8A5nOmyK0/oKtdaK5XIVn1/K4QSPJ2OEEGw2G1ar9dCuyPOcsihp25a8KHj8+AnWWto2Mkb6GLAoiij0HgIuXSi9akhRxl5fvd0O1fEe9Rk+RaHopTWiT3pF7Kb0Q8PVmFiV9iFuI6kaa62NSEEp6do2peP2UllNKZy1w7aXZRnT6RQHIGWETThH2zYE7yiLDGtarKkHzequa4FAvd3grKXIYzGwl9CLwWs0ICFAScV6vQIYmB2jasTe3h5d17LZbKjrOgq5JzEHKUVq+K55+vRpFLrSz/fAsiyLmZv3UcNbXMrQFEWBSQjPfm8N4RK090KINF4iI9qd6/FpFU2HmMM6cB4t5BAYBufjZBbvyaTCtlH4qW3btKWFQU0jhMgWHY/HZHmO8x41FO082/UG1xkUYJoajAFnkCLgraVrarq2w5oOpSVaikhb9haXPEovmxe3oDrFabG9MUmCXNttzXZbI2UCo6XWRwiBsiw5Oenht2mLNWYwktFoNMjzxdgtJARDfI24tbqYl6amtLUWIXelmT/ZemmM6NOsXW81dO3T1b47JKav3+wKX/Ueof/bGKcEhJTUdZ3gFdlz6a33nma75dnTJ0Pa7KzBOwvepdjHpq0qFhbxDq2iQoc1sQpuug7nLJPJmG29pevMEAhPJhNGo4qmadhsNgmNaYepQlrrBHRbcnp6MsR1Knki7wNFUZDn+eBRrY1ezHnPdDodDLf/ZL6HnvjfZtvZJ12XqmeXsrrWWpx1SVolwUyFGL5mOhbZ+mAzdvvd8BwRshrjj7jEkLUtFgvefPNNTNeCj7QjZzuCMwji9imIdSJvbHo9HU+2MwQf4axaa6bTGdvtFmsNZVkyHo+Zz+dRm3G1iqITNrUvUq2rZ8OenZ3x7FmE0PTbnLWxoVuWZfReqaDpUmYYX3OKNZZ6Wyc2R0jbPQnh4F50N/vtY0T9MibpJPYyKz3oPMRSf39fSMLg/XMMeJrULokBbpEyMj3AU0MILC4uYlpvDd50eGuwpoPeiETcPq01yRuGZGgRQeC8Zzab4b3DdGYIhKfTKWVZRihv09A0NdbFgqRWl2powXtWqxXbzYaiyKnKKnLIrB28kBCCruto23YIqmezKUrJaJwpZOhDiBgf/jPiiaI99HCJ5y+aEAKm64YeUFkUqLTXO+djpzz1kWL2drnl+ZTe+hSg9/Ug2Xs3Ew1OK4UPEe3YX+HBe7yNz+mcSQAzgzVxOpGxlx6hN9DxeMJqtcJ5z3g8ZjqdRoaqlKxW64S/BpXitDy1P/qT3mOm87ygGo0IyZPErEwPXrk3ojzPmU5nGGvZbi9xSD23LHrbBEdJ9bL+KIePcU3fc0bULwc4Ap4kWgV44zh59BjTnqDDhsK1TIQkR+GlwmhNHRzOWzQeaQwjqVDGEqxB+FjyN8ajiwJVVHip2V5ccHFygujioLppOUYFCQ68DQRPNNLQooXDtU0ajRWQQuMs+JBhLHTGM5pOycuSs4sVShcUxYjpZE6Rlzjj2KyW2LaJ26LzScZGoYREy5hBdm2LklHAQRczECVZUaGzHKVkbGN0EYQmvKTKxuSTOYvtBhMaCDUyGHSQZBRokaE0OLHFBp+ObeykuY85F9+TvLPL6yJmFRIR60EhoKTk/PyCLm+ZZBOkyDBC015cIEqN0uoyFtqRrnM+eqa+GFmWFTrFMj20tZfydelxfmdLsNbhnUwlBBFjsdSrW63WBO/ZbLZY57hy5Rqr9RatM4qiZDyeMJvNCd6yXK3YrLepiRq3MqWiV+zfjzF9oB1Hd2ZZnvBBcYxnX18aKFJFxGY3dbODXthVzhfPbWti5xgLwcfGSN+TRtSvkHxxzx2XUjIeT3j2uKFd15i8Q6Jpg4BRxd7VoxjkJrk9l0oCSilsd1nhVqmi3W8Ls/l8SK+VjKKhXdfFgBRSAbLDOT0cb+ctUgms7fDeDttKpnO0LlktzplM5lTFmP29qCV5drbg7PSM7bbF+4iMzDI99P2UUkOsFNLnrUajIQEoioIifd+/nveesijY39/nZLOM3qlvqu6k8j2O/EWDavge3s76FVKGQWK2TqaTKJ+SxnS2TYO3Bp/47Vol9TR9CVJTKiL9+qpxz4Log2JBFMeSMmJ3+s56bHb3eCGXCnb9z4Ys04kosEFrzXZbc+vWHbwTlOWEyXjOfD6nqiratmO9WkVvZe2ActRao9NEINLr9R4mhEBVlkORsleXtTZBSnxI1e8JUspI1R7aHzsHkGRE3n1s/PNB66UyohelCglETN1lL0AQUs9pElsVpsWZBhESdVjEEZlCCJTUz/WcQl/kDDET6kc5WeuGMZo9U7UoyiHV3q2WR8EFhl6V1jIF2o7lcglBcOPGLcpyzGQ8ixSg8RhrDScnzzg7O2W73Saw/qWknkpgur7uU9c1ztohZRci4rGzLBsuBmstbddSliWTyYTVOlK1P9hEIorAf0Dv7JN0Dl4qI+rXJ255pH8CQVTGjN4jLwryosB0Ld4ZvGkR3iLTlau1RqX4YqhyE1Nk5z1FWaSqrhs651pFo3PekWURWtpvoUMTV6gByRiCI881bVtT1zXb7Zb5fI+9+QFFFofAaJ3hrGGzXXJ+ccp6s8K62MeDmCH2aAMQQ3W9z7qAeMGIqH6b58XQ54uxTyw8Zjpjs9lGzNNzzVgiJiqVOqL32snOdlpJH7VeGiP6XAiL6UMXyVCcdZi2xZsO0zYQPEWeIYRCJjGn/oD61PnXWqOV3kmTYzDdu/k+CHfOPveeY6EuPqZtY81IZ4q62dJ2DW3bcnR0hNYZeYqvvLesN0vOL05ouw3et4AF4RDCDy2OWM2WQ8GzbTuatiXP88j0SDFcnsfJ2l2Ke7Is4/DwkPOLc0zXfQSkIyI5Q/JIL7peGiP6LKuPiUJqNpZJfT4Ej2ma1CRtCN6SZzpejakA18Mr+sAyz/MhqI4iEN1zxiKlGgLq/oQNhmgvQe9SSbSWdF1D20aY7q1bt1mvNyilYhruOlbrCy4WJzTtGh86pHJIGVBaUBQ5IFLfTgwexiQo62QyoawqRBrLSXo/bdsAcHh4GKc7LhapaPnBa5AjSkTHF13f80Y0BJx90c85ZJZRVRV5luGcwXYtrutotpu0JfkkjBlbBbsUoz5A7YH+Q9U5XaD98JldMoBzEafsnMfaWFAsigIINE3NarXk4OCAPC9YLlZxEJ4AazuaZkPTrOm6DQGDVNGAslylgFmhlcJak/pgdngf8/mcIs/J82KodK9XK4wxUSV3PObs7OyyFPGhxy/eeoju92zb44P23t09eff7RKx4nxCTDz5OWyaOdsqLmO5GYauWerMZYCEBduKNywBbSpmamSGlybGAcLmdJWB+Mr5BdN1H7xar45Y8zyDAdrtluVxx+/YdVqs1znt0lqG0HILfzrRxTGcC0kcWhxqMOo6NMENtSipJlmeMxqOEoQ7RQ6bkYDQas7e3R9t2bDabOLtWfLhs1a4y2vMIiueR6B+2PtaIhBB/RgjxTAjxqzv3HQgh/roQ4rfS1/10vxBC/HtCiDeEEP9YCPFjH/f8H/aBLrEtH7xUf/MgfOy+RyiDRDOiKGfkszkul9S2xnc1brMhsxEg74hTpgF8cEjp8KHF+ZYQHCDoWsAXKJkTgkDrnODF4IH67KvrGhAOmXU4vyUEy7Sc4hpo14GuVRxcu8PaQi0VQWToYkxrDG3X0pp2oG1rmaFkQaZKCJZMgnAG39QI26CEIcsCqhCE0tPIFoKO04eCRumC2XSPsqzYbDaDl/XeoYNCBYUKEhUEKgg0gkJJhDPI4AlthwoB1V+8MnysKsgn8UT/KfAvvue+XoPoNeBvpJ8hCju8lm4/B/wHn+D5X2hFxxv/xSqjGFL04MMAOsuLIm5pRRErzCYW/C4uLijyPGZtaQszxkRl/bpOV/+lBq+QPREyZl095Waz2WCdHYw9wjwCnTEQQGlF27YsVyv2D/bJs4zVanmZ0XUd9bZOWKIwCHpKqcizGAtlOk5U7Lp22H6z1P2fzWaJ5iQHDJGSitl0xng8pmmaxLq1l1SltOXvZl42gfAivckN8Jj3HfSPWB9rRCGEvw2cvefunyVqD5G+/vd37v+zIa6/D+z14g5f2AqBIMQlEJ4eG+MpyorZ3gFeRFJgELBarwgh1ouci03RJoHCyrJKdJ00iQg/BN2ES94akGAa7jlAV9d1bLYbggCVadbbDafnZ9y/f4+Li3O0krE1kSnq7YZ6u6Gpa0iAuDwrklpHhHaUVTmk5HEEQ8FoNEGrjCwv8F4komNESAZicdGnLr9JFXiZJIt75u9uozkdws+0Pm1M9GEaRLeAd3ce9yDd9771eUnL9Aeir9XEA+Sx3qPznPn+PqPxjKcnpyyWS7quZbtZomRIV11ILFnFZDxLnfNswBbp5FGEFEMMpKSKOKCEDhRCDCenh3YonXGxXLBcLbhy5ZCm2VLmGSJ4bNdwdnocDcgFpFAoocl0htqJhUII1E30Vk3TslqtePbsmMePn7Bc9NVtNwDS8jwKO/RISa0ulWDfGzBLcfl5Bj7eIBr5YuszB9bh04By4999LtIyfXrvd9y0dS4Gr1lOUY3YOzrCI3jw6BGPHz/k+NkTtAApw7B19ajAmOH2rI+A0lEapt82IBL/uq7DGjugKH3q2htj8SHQmY6TsxP2D/bi8xDwtmNvOqJeLTg/OaZLwluZytAqJ47j1Ogsx+PZbjc0TcNiseTZs6ccHx9zenrGZrNls6lZXCxpG0uvR9mn+XErM0NALFIR9rKpumM4AUjFxYG0eHl0L4/xR6xPa0QfpkH0ELiz87jb6b5PvD4oG/uoJdWlEfS1EOccUkmK0QiZ5cz3D7l5O9ZoTk9POHn2lK5d40NE8sV2hiIEwWazpevRkc5iTDuUAqJhxRNSVdVzSMMQYsN0u60pqwqP5/T8jOu3bhDwdF2NEp5RlnF2eszy4hSIGopKZmRZiVIZSimyLE6jPj095fHjR1xcXGCtYzyaMqrGKJXTNh3Pnp7y7OnJwKVTUrHerGma5rkLCy6FHeADPFAqNiIue5G9UX2RFesP0yD6K8C/mrK03w0sdra9z7R2KdDvXS7FI31c5JzDhQBCIvOCYjTmyvUbzPf3OD09Ybk44/z0OBEMJW3bMBqP6VpD03RRHDOEmHUFnzjvapDJk1Jy9erVyA5Jr5lnWaorWSbTCavthrPlOddv3oiG6j2ZlARrePr4XUxbU+qMUVmRZzlS9KOmchaLJW+//TYPHz7Ee8/h4SG3bt2iLEs225orR1f4vb/3Z3j99a9SliO0UpRlyXa7xXQmgul2msj9UZNJbhBIVXc3xJD92i15fNLt5WOhIEKI/ztRyPNICPEA+N8Df4oP1iD6q8AfBN4AtsC/9gnfx6dfIQxGlCXGZ20NUoBSEoREZTmT2Zw7d++xXi5YLi54+vgh+9duJJEpiTWOYjym6TqsjS0HnWla03Aw24+SfdstR0eHw0SgnpQIUFUVIsQa0HgyicRAoChzuk3Ndrvm1rWrbFYLjp8+geDJMkWZILjeBzKds1quePfhA5qm4ejokCuHB0ghePb0Cb/2a79Oayw//KM/wXTvkHuvfgUXBEdHV5hMp2zWK4qioB4ysT4L84iEc0IIpAiRBSMEPjzf6vjA7Oxj1scaUQjhj37Ir96nQZTioz/+wu/iM64+JvDKPbetKR9B80FIRuMxV65c4dnRISfPnnB2esJiccHe3gFlWfLdNx8wm9VMZ3M2mw3FqGBUjXi6WhAIrFYruqbh4GCP8XhMVVUDSG2gIvs4yzUAm7pmOpuxXK0ipQhHVRa8/d3v0mzXHB4eMplMcd6z3mypxhNWqzghKITA/fv3mY4rms2Gp08e8eDdB2y2W37oh3+EsqwinajzFOWI0WhE17Zs6y3WdkMV3XuX2L0pXk6VcilEBPIR9ZB8rwSSsOYDQOsTrpemYv1Rq++yv/e2+zu45K71GjyuT2UBIRVlVXL79m0AHj58l3feeQulFAeHB0wm46HzXSdJGvCJ6mPI85xJwuVMJpOh2h1ZFZekxNFohBRR9Ww+m9E0NZ3pmE1ndF3Lw4cP05SfyFY1nRmKl6vVijzPuHb1KmVZcnF+zptvvsmzZ8dIqbhx4yZf/vLrfbiM94GbN29TFAVdqmhbYynLYjhCPT6q5+UPFfYdGZvYuI5/sVuxFv3/3wvIxg8KovsT1KfacKmcM4gMCAgiGovO8/hZlaSQDhckNmick3gZi5Gi1IwPDEc3bvGb3/4WZ0/exTWvMdm/wuuv3+X4dEHdbXHbFmPqWBj0EWo6n83QQlBkGeNqRKYzRJAc7O2RKcmoqHj8+BGZ0swnM+r1lr3RDFdbNk3Da6+9xsNnzzhrWm7MDjEo8qzAGEteRW69IMZO8+kex8+ecfzgKUIrxpMD8qoiSE05O2KWj1iva2aTPa7tX8N0Dca0FEUsR1jT4kMHgjTOQQ1K+iGEKGmTEgqEiEP3EoM3hpIxDnRICOpj0/6Xwog+1UpW1PPX+9S+KAqkaaN1eQlKIULshFssB/uH3Lx1i8eP3uX8/JzT03OK0Zym6RBJ02e1XLEVgqOjQyBWo3uskVRw7949jOt4/O47nByfIJXg9PSUR48eDR6qRxvWdZ0IiSPW63WkYBOzyqZpmM/nbLdrtqk5PJ/POTs7Y7vdMB7HITDVdEJjHePZHtVohJQF83nOrZu3o1q+6eiZrMYY6vRc/aA95x0ieJyIPjweugjou+xGikRwdO85xs9984Hre2I769f7ZE4GD5ZwPE0UV9hua5o6guv7yT0Ej5aSalRx48ZNXv/KV3n69Ji/+fN/i21dU1Qlo/GEsizRWnH1yhWOnz7l8aPHFEXB06dPefz4MWdnZ5yenvLWd7/LW2+9laSLLY8ePcRaS1mWOOdiyyXBSo6Ojjg5OUmV4ygLvFqt0shxw8nJCV3XcXh4yGazIYLzFdY5ZrMZVTVitd4wGo2RKiMrCq5eu06WZTRtlFfWKRtzafvd7UH2Ejq7wXavgtI/TiRdAGvMC5ewvyeNaNeQgvNYYyMkIsuw1hBCFEG3XUfX1NSbDc1mQ9s2LC4u6DrDjRs3uX3nHo+fPOXBg0cIFNPJNMqreNhstxHIFeDBgwc8ePCAb3zjG5ydnfHuu+9yenrKdDrl+vXrAyj+8PAwYam3dF1HXdfs7+8/pzt0797dAa+ktR7mtR4cHPLsWSy3jUYj6qZh/2AfnWc8fPyErjUcHV3FB8loNGYyndJ2XRyep/SAbepx4sMx6wtAolfMlemreE/ZJMrmxDjpxdb3znb2QVdHwjM32+3QhGybAOjY3QekE3gZ0lAUk65SyXxvn6//yO8gyJyAohqNsdYjguDmjZt4Z5iPKr5jDPv7+9y9c5srBwcIIRmPRxSFZj6ZAJ4qTTLsAfx9mty3IDabDQcHB3jvmUymhLJgOo3kRWsNh4eHdAlkJmWcaV8UBVIrTk5PePDuA+59+XVm8wNGk1nSqA6JnQsuSeT0xivfw/ORMgWPUhK3M5/gNInWRJ+1ySGbS4VskF9cxfpzX7tZwceqggwpWpzhtdlsWK9WtHVDcB4pFFmeo6QizzWF1pSZptAZ8+mM8XhCVU3wQXBwcIWrV6+xXm84P18ggMl4zKgsOTs94+b161RVxWQy4f79+zx69IjNesN8Pmc0HvErv/IrHB8f8+TJYzabDV3XMZ/P6boucr2aiDI0xjAej7m4uGA+n7FcLlOvK7JH8jxjMpmwv7+PtRFUFj1Sjc5zvv71H2Fv/5C9/cNBL9ITMNY81/oZCowp5lGJft0Lq0v5nvHx9GQDoqp+2FVocaiU3HzUemmMCN5v8e978zu5fX8Y4vCXhu1mO2gxG+sxXaqRhIAWARFicGmNReuMpjUsVht0UZCXFZ1xnF5cMJ3NI9d9uWQ+nTIqqzhkryiYTCYURcFqtUIpxXaz5eLigqOjo6E8cHR0xKNHj6jrmixVsfutres6zs7OqOuGEALr9ZrOdFG4qqyeO7lVVcWzIyT37t/n3v1XmUxmgMKFFBCLRFSQkrZtB2mZfu1uVbGlEfP43sCklIkdcvl31pqB3QKXKIGPWi/tdtan9rspfr92f+oPiEsUaJSiaTskoIWg7TaYuh6k54xzFFXB6cU5TdOxf3CIEIqmaVFKM51MWJyfM5/O2K5XOGso0/SeKs+5fv0aT588pm1b1svFwAgZjcbcvn2bcYKkHh4ecvXqVYwxnJ+fDyQA5xzrzRopROp5OZQSae6HGwgD1tqodWQ69suKLC8RMqNrDToIlJRoFfHitm2p6zo1YUXapvotKUDwMSfb0agWMpYbfYipvs40MvUBO2MoKlK25kmjBz50vVSeaHd9MDQ2vC/ZVDKm0kpcqoKBwLuAt47VxYKnT55w/PRZlMDznqbt2Gxidfrq1esp3BJcu3YNEMynsyjvslwM2o7GRCGGq1evUhQl1lg2mw2z+YynT59ycHDA0dERb7zxBlVVMR6PyfOc/f19qqqiqioePHjAl159lf29vQgpSVtNZG2U8QSmbTCEwHK1xKShx95Hzr81UblD6SwGwi4qiPTEgyh4pZ7b1np/7hNVvJ9v0us+xlkkYfCmu3/zSSrXL60n6lcsiPV46kusc7/6sU9WSXwXi2lOhKiUpjV5kSUe+pb2rEHnBeV4xGQyRmc5s/kcIRVFWTKdTME5TPC8/fbblFk2bBcRYRjbHErF2sx6vWY6nbHZbDg6OuL4+JhtEv0UQiCVokxB99tvv03btty5c4cnj96lruso7OkseZZTjSqM6WjbGGA3TUPbNEwmU2azyJLtkqqtTGyRLoQB9aikTDEWEKLCR9z+RRyAFwRSibSluSQIEqcLQfRMWupBpa2PrKUQHzvv46XxRD0mMc4dDAglQaYDIGLj0AlwIlauA4AMBBlAOAIW5xsCHZ4OG1o27QapFbO9OeVohPOBk5MTnjx6jAygywpd5Egtmc1GCOnYdhseHT9mbTtMnrOVClHkyCzHCU/T1GgN29WS1XrFdG+fH/vJ/xavvP41nj15hDUtRVEidYbKCoJUZEXJkydP2ZtNyRQDY6OqKgjQdRaCxHQeJTO0qpCioKquIsSIm7fupyB6CzTkmQPfgG8JtgW/QYkOERKzxcYhN0IohJQgwQtHhJ7Em5ARL+WCj3VZBEEqpnt7qfofszjpO3RoP/LcvVSe6L1e5rnAWgwPes7F9vWWHq7RP1QKgRQM4p/j8TjSeIRgtVknhGJUFeu67jl5uqZpGCWhhP4mQhy+V1UFs9mMB2+/E+lD1nJwcEBRFnRte5k2py2hqkapbyUYT8YD7UcIMbx2BL2J4X1476lGI4SMaIKDw8OBidHjossiSgG2bTtILvcc/d2tcjgmCbDfT7qOYKEYDhgXK+wqIRB2umafaL00nui9670x0UdWwFKm0QtBZToj19mg4tEfjKIouHX7Nnfu3iXLcw4ODsAHZpMJWim6po2KZFJGurVU5FlGnmkWFxf83b/7dzDWcPzsGZ1p8M5xenrKs6dPqbd1TOfTCRQpNda6n/AYKT11XQ8tkSzx43YhrLtCDXleIJViNpsNAll9I1VnWRpv5Viv1kONaJd8MEgP7uKsfOTdOR8hxDG1j3WtUYrlekrW+7rdH7JeKk/0QWswpA/FJwT6FnRUS036O4GkPxTSfh/TYAkcXblCZw1VUUZJXyE5OzuLyrHOU2Q5uc7i0N6ywnSGx48e8eTxY9556y28sxwdHfHw4UNOTk8RQlJVJW3XUpQVWaaHugyQWiAZm/Wa+XQyvPNLDr8YqtqbTaxBCSHJMsl4NIpKsk0zGGUv7L5cLLm4uKBeLwCGC6kPsHs1XEherMer7BhFZyOcVwjJ3sEBSmf4F/QtL70RAe9L8/veD2IHPxziLHmXVFqtMYgQkD4aU+ccHjDbDaPZZAiWe5ZGD8doE8e9h732FdyzsxMyrbHGoJVkNtnn0YOHLBcL7ty9B0SEZS/z2wPu+xNZFOVzirX98/e3nsJ9cnIyNHGzrGD/4GBAVZZVNKjz83MWizOePnrAZrOm1HIwrl5DYDc7iyyPyIoRIWZicQm8t0ilUTpjPt+LMRS8EGD/pTCiwGW1dWC5pg/fX1FwaTw+Tfbp+2hSKXyIhcUQ4qTm4D250jjnaZLcbmcNxajCWMt0PouTqE2UrmuTdk9T1xHrY6N4qCD2pC7OL5hNJxjT8eVX7rFerxEiTv8pixxnDW3XMUvGcak8Gx3lbDZjtTwf4po+luuNrE/11+t1+txxfsj+3t4gzF4UBWdnpxwfP6NpYha4t7ePxg5SOH21/1JfieHYOR8Tlxgzxj6as3Eao9JxPKn3ENSLMT5eCiP6oPVcPLRzX0zUYr/HuxhM9p6qx1hrpeLeb10a0BJFP6VS7O3vY6xJ0jJ+GAYDUR+xp9m4JJ4ghKCuNyyXFxzMp+zPZ3RtiyCwXCzYbtaURUGvAV2kQHw8Hg/C6kLEpuqzp4+G5+x/l+c5TdPQc82ioZxx48YN1puWyXRGVPjIB6Pb25vj/SQKsEtBMPUlurOnTe187WMtE2KyIaVES5CBaERakJclQkXDuoSHfLL1cgTWOwyD9wXUvBe01rvqHhbbDR6jP1g+6fD4pLcTiYGxc16WJcZairKMWj6dIVMafOD87AzvHLnOmE6mjKsRVVFyfHxMWzfszeccHOxzfn7Go0cPefz4EQKYzSY4Y6JKvfdcuXJEldolkTQYh+D1vbU+qO7jIIifRWvNaDTi+DgiGfvR65HRmw+qIM7FsaRKKUaj0RCc91tzmyrYka/WDN39flS6EBKhNEiJdR4hFePROHmnOMDvBeLq7w1P1HsacdlfHmKY3kgCvUhTGKYJShn/ot8uQpBY75CZRmUaby8pNVF4YcmVK1ei9mFRDFScp0+eYI2hKkvapmWxWPDowQNWyyVXr15jOp5wfBpHJKxXKyaTKVWqWPfq/FJKnLVst1vG4zEQ+WG97DAwZGsPHz5ks1mTZZMUTxWAiIC2EBiNRmTZlEJHw1lv7VA2yPP8OU/ULyEEjRMoCVpdanKHECnco/EEhEw5yottZy+HJ4IdvtOuAb3/9z3IKsrgdQkOoVIdxYEIaKVjap5Sfq01PkSGaBzxXQzP0SturJbLKKRZlUBk0TrvqJuat996ixA8Bwf7UbUjVa+V1ly/dg2dZVjbpXmrIcYw6bWapsUHhtR8s15jncM6R9cZlIr0aKX7uCijbVvOzy/wIaDT5zDWJhjKmNFoRFnEskHTJLljf+mpd7O4yyV24rB0vFzEy/SGGuhHNPA8eOtjbOolMSJB1DuM89ql0MP3wQuCF0ghyYREB4UMEmsCPigQGVJqpIKu3aKEoyoKqjwnUwKBwdkt2+0Fk2mJd5ZM57Ed4CVa5GADrjOM8pwy1ygNQVtaUbNyK87PzpjPRsznOZ4tnal5dnJOns+498rrdL7DhJZJUaHQBHIsIzamYNNlSD1BBEmBwK1XLJstGxNwYkxgTFZMUFri3ZpMOUqtOX16Ri0KbDHFZRXGRYPqty8lNZttR2cC1koEGimzZKwZEFGU/fw0gNw7Sg+582jvcG1HqTVZHou1HvceXH6/mX10J//TSsv8O0KIh0KIb6bbH9z53b8torTMt4UQf+BFzQk+GLjf/xiZCn2jNWZ2zsUtLdM6qW4IrLO0ice+rbdD1rJZr6NKfSr+9ZXepmlTUVAmpdUornn87Bl13XB4eDjQhOqm5umTJxwcHDCf79F1ljwv0JkepP5C0jDqpYu1Vklzuuf5p6xMR6/ZU7L7OOn09ASdZUOhsScjaq2jcEQaYbWt60QJ6rOx95I8L+GvQsQ2Ukh3xNln1RDUSxlxSi9abPy00jIA/24I4UfT7a/G9yV+EPgjwNfS3/z7Qgj1AX/7vvXeoPqD7rvk2scBMAAibWOSuM24XtBqu04TfNqYTSUQW9d1MXtzfgB3BWA2m3Lr1u2koOoxbcyijp8dk2c5e3sHUUpvu2WxuKBp6oRwLJBSDiquRRHnjAlJqmP1mqQSrdVQDNSq754DiCh21UWyQFVFXlld10ynU/pJkWUZa02miyjGtmujmNYOkrE3oD406O8bJksS03wQsQibRdatVBkhCNIO90Lr00rLfNj6WeDPhRDaEMKbRCbsT378n32w8ex+H6kuSfEj8eTjFSiGuWauM3R1Q71dU9cbjGkJLtJwirKIMUAIifFqCSIQRCz7V6PRIAYVee2xpfD0yROqaszBwQECWCwveOedtxiPK/b25uztzSmLiu22SYU7OVCRVcqu+vmxzlnath4kcPr0+3KsOSkri8iEfnw5kOpjfvjbvqWRZX0gHXYCaj8c194pXRY24/2I6L0Cgul0jkhaBN4l2hCfOCT6TDHRvyGiGtqfEUkpjU8pLXNycgJ88Db2/Lo8UIMuDwKtFPg4HMa0LdZ0OGfAO/phdePRKNaMYsUNUg9JaYXO47zVzWbDyckpF2fndG1Ls605OzlhMpkxmczY1nXk8i8XTKZjqqq8HJOZdKcjuCwaeSBmSD1/P6ILfZoM6VJ7JqQemH9OGng6ncapjzsN1T697+tBfXU6Mjj8pTrJQJ/eqbMJElIyPLelgWA6myGVjtnZzqBBEUK8fYwhfFoj+g+ALwE/CjwG/k8v+gRhR1rm6Ojofb9/3i0nDHHCFA/zKVJGIhEE53CdxbYd3pvUI4pSvt4a9uYzCBHrrLWOqmnLBavNhvV6zdNnz3jw4AEPHz7k7PSU87Nz6s2W9XLF3nyf8XhMXW85OT0m4MiLjCzPUsZnh5gkeB81GJ2LUAtniR5hN0gNA4hMSXnZwhnaFIHJZMrBweHw/IPwVkgV+FSodGk01i7DYxdH/T4kxC5QTQh0lqN1jtYF3ksGk3hvavwR61PViUIIT3dO9n8E/Jfpx08tLbPb7njvfZAAVMakoSkxZdZSEKwFH7Bth+s6hA/4YCFEASvTWZRWTMZjnjx7l0wpVss127ql83GCT64U1WjEqCxo2zqehADr1RrvPHfv3CPPClarJZvNGqUEWkeJYYhbkHNRt7qncMcZPbK/2OM93uM8aRJihLEEkmiojcKh3vdDYWQaaX7ZN7Q2SteYNDZLigi8b1JNqO+ZQS/I/v6ibW+83gc6ayl1Rl5WMRaSKuKQ+rlCH1dlTOtTeSLxvITevwz0mdtfAf6IEKIQQrxC1G78hU/6vB9Vrd6tE/V7e+jFCgJ0bYu3ce5rBF/Fq9+7uJWZrkOruG289eabsbIdIld/b3+Pg4MDDg4P2dvbi4zVqmK1XIIPXL9+E4jaRREmG6WBI+ddIIhGFKvLaW5YPw40KcLGrSyONe8Lg7HR2g/ai1jxXhsyBJhMJpctHe9THGQu53hI8dwstf5Y+Z0JR7u3GO/1Gk5x24uEzSoJuasBT/0iMdGnlZb5GSHEjxJt9S3gf5FO+LeEEH8e+DXAAn88RCnWT2RAfTd+975dw3reS8U2h5JxTGXXdjsfOuwmLOzvzfHBsVwsGI/nHF2/DVKzcSbOEMvziKx0aS49goBns14zHo+ZTCaD5F0f90gpGI1GAAn/HP+WdLLiNuOSZnVMm713WO/QO01SnzA9l7CNMIy5ipXquIzphoa0KvJ44Zg2Svb1HihdZDF2fM9xJWCTSgrEZCLLM/b3D2Jq70VCOX6iZPq59WmlZf7jj3j8nwT+5Au/k2GJdADej3L0g7tPetKxNkbbdXRdRPh5PAifdHfi12o0inrOWUZZVcynU1rnybIx3jo60+G7jtDjjQe6jOPqlasURcHi4hTTtclI41CaoiwjiDTElLmPS1wKkqXsywgkTxSzywEDRSRVihRwxxePjWKdZckw4t8NIugyCjNYE4fiee+R7/HUPolqhRDFS0X8UHiimlqvllIWJZPpLOKJkkELqXZczyfbz16i3lns2+xypfq0OAqDS5xtCKEjIJDCo3TAecNyc07nGpyMIwuctUitWK9rsqJAFVOauma1rbl2e4zKQOEpipyN3dClac5BQJDRhXnrWK0bDg6voPIaZ5cUPlD5HC8UQs4R1QGdzLHEWELpCq0rkDlCZAhdILXENBCQ2BCQ3uG9QUlLJiy4gBYORcAgEKqCfIrPpmACSiuCd8gA0vmkHuJxpsGblkwKhI71Me98KmnE6ZIxmI9eKPiAkhl4ReNAljPUeB9ZTYn+yVIIAANBvFCx6KVoe8Q64Ps9D+zgYtKvpZCEpHa/2cSmaYRKxPkXPW6oruuoXq8ve095USClityzNEWoD0Z7GnLTtIySdtBisRgqxm0b5Vt2/yY2dS/fsxBih+sun/MkfXXcJJ3rPk6BFNvtIBGV0oxG4wGs1lebnXcDkC42ThNqMaEXLnUlSe0ONZQX4uCb+HOPjJxM4oSioUotLsOBF1kvhyfa2b/fu/qDbaxhkZqSPiS4p/PIEE/AgINJNZW2jWjFajRGKknbdIBAZxmZjrCQ1SqKfLqEU95sVjEQH1dxPhlxyIrzkaDYy64oJYdxmnEbuoxxIkFADie+Jwf2czOCMYOYAjAE9+nNDw3R6WSaRE3jllfXW7x3ZFpjDMkYNF3XDgY0GLiSkaTQb530F2PKvoKAIJhNZ+9pkXy69XIYEc8H1gNbIhlVRBw2rFdrhJD0NVytFHnScJZKpW6+Js8EbWfxwTOf72GMpelix78oK5TStG1HnaAe/ZgnKafDjPiHDx+ytxel9SIfrEmvGoYTmGV6KBhCSDqPWTqJ0ck/B8kIkfaslEqBth9k7y7bFtEbTacTlJIxGHexlaNSUK+UguAGpfxLD3SZifUzSHbvh2hMwXryIqcoixfvcXzAemmM6MNWbLi6SO3NIlzB2CQbPAThkOUleVHSBY91EQTqXHTZnXVJAKsiS1vbtmmGIp1SirwoGI0qMq1wzvLo0SMm00gzigTBLqbIwadZIGlgcDIgRN+a8bgUrAsREYRAKihGQJhO25BzDiHVzomXKBmNbDQeA5Gc6BMeSUpia0XGSdzWRn2j3YHIMRPsPfp7PHvqZzjnqJLgxXv5D2H3sZ9wvRQxEVwG1Lv0mV0mhHcOfEzDc53HUeE+YKyj7Uyk0CgVjSdlK0pnTKZThJB0naWajEGIiOdJ2OIBYyPkIHLQdR3rzZq9vT2m0ynberNTKY+GlGWagEepGIj3wDchIzu2bdrBQ9A3jhNTtR/90K++XQGXHjly0tqYXQlSzHc5MToO84sGvOuB6O9NSIFdnUaIpQKVJIv7KUyfdb00nuiD6kT9/f1BFsioNShC6idpBB4yjaQkK0qaJtZztnXNeDIhIGi6DmMdo2pECFAn8Yb+Na21SaIlUm5MZ9BKc/v2bayNgLWui9OHpIoTenar07Gw6MizbAcE//6LwjqHjg7psgRBrCuFnc+qEyRWaQlODeFSHEXu8c5elgsEMcYiPSi+o/dtU321GuJ2WFVVHEn6OZy7l8YT7UI631utHuKKQBRqcD7WiZWK1VlibSUv8qRsITHWUo3GkSZkLFIpxtMpcVaZQ+nLCc+96mos5kVYxmg0Ym9vj+12yybNSevfh/MR86OkjCc19N31OF2oLEukkJcN1ZRZXWZ2KsJ4B1KhTd4qNlX7+SAx5nI726knhBgj+dDXzPqhNTu15fe0jp5vxl4WMj/NlMUPWi+FJ/qgFJ+d+/qrKLi+6RpSrBQNQuKRBLKkkdiraEwmU6zzGGMZT8YopbEJ4OXTNdizJELwCTzvOT09HWTy1utNPMkiSvjF1kHfykhl8VQcjTpGJXmeszVdhKyOyuc8bBxRrofz3ENC4mPi4D+Rnne9Xg006QgPyWiaPpDujY/dQOa5YxeD/ssLs2stUudkuWAyifjtz8MTvRRGxHCVpJPS1y363/kAftcjxX6Ts/HxIQSCjED3LM9ZrZaR7JdEOLuui/0h5/E2niRrTBSP8B5jOjKphq7406dP2Z/vYTozwC4IgeDjSdsddxALpHHbyosizlLzjnpbI4sKCJdVbhENQSuVtrv+IumNJ/b27t2/F3lqzRZCzPqsCYCDcDmzrI+Pwo4h9wetN6IeGiJEryZyyXEbQvAUcDOcgRdL2V4OIwKEz+KUP0iGY6NQlRSIziI7S+fjXHdrLUFKhIc8U3gTx5V7Z5lUFdbUQExjpVR4ISmyWFx01oKzKCVxWkfvEmwagxlP0na54tU7d7FNR7ep0cYgnIs6kCEgdWxUesAZRy4LcpGTV4qsyNhuFrjaMMo1ubcEH7FDXiooCnItyTOJkCYaD2B9jg8SnUtefe2rlJOKZROVOUZFxbo5xZoGYQ3CW2zXXhoQcUbHkM6nlk2/jRljYwyUko/JJHLZhlluIqIWpEjUK14sVnqpYqK0r+3UVRhiB5cQiqFH7qUrLWJtskin8SHirFOwXI0qnPc0bTtAS62Jhth3ywlxwpCUUcih3RnWW9dbukTTSW9tWL0OYk9yVDpukevVmuVyBUBVVvHKTu972IZ7hGLo6eCxCCiF4LXXX2eUiI9SXgozCBk7+U3b4hIKoO/VXYLR/MA9Gzh4OyziWOGWlyPfUxz33PHmk3bMLtdL44l6+GsY6iopFgp9u8AOwWvw/VUTkEJibRSfklLy7MkTmqbFeSirEY1xKKXj0JbNdmC5BiL7U0iBlmoYFNM0cYRnSNucsyby2HsjSO9X6dhYrbs2FTIlbWtouxpjA/P9KWVZJsC+wfsYPBM8LiUHQUIQCWxnLFdv3OTKtWtIpTHO0dRbwKd6UJf6Y+6yHuX65rEZoLZDJpuMrBd58N7jggUZsVNZXmDDZb8yBJIYFs99zk+yXg4jCj3faRdcnoJOt9Nz8nHAb4yhBCKdlK5tKbSm2Sx5660309zVw9QT65L6V45164iA9AqVCoWSiC6UIkIp6u2WotB0XU1I6EQf/CC+1bdWdJ5hnGO7idOHgmlp2w4foByNmUymgxCDTa0VKQIqBeQRoRvhp957lNbcuHETJTXWx1myVVVGgFhwONMNGZq1lqZtqduWpu0IpnuurtbHPFnirI1GI4SQnC1WZEUcjeV8hIYg9VBw9CFGSUG8pwL5MevlMCIYWgJ9oBrvY+g5ee/itGQgAWKJeGU/QClOT09iTcdYRuMpPnCZ6qfUPnoYB5mOZQIhk1pG3HbaZouSgrbeRu+UKtFDFypl0lIpjDU0XYtxBpyLkx6znNlsn2o0SuM9Y2sieIcSoFLKTwLJuxCFFqbzOZPZLM5QS1jqECyr1YJgW7xp6JqYKTZtE8d6Nh2tMUNVvAerlWVJWZaDyINKIyAQkiwvyMsyXayXxckhqUkX6YvE1i+NEYVkRAMqTzIEIZFL7shT4Ce1RGkFIUSILIJmu+Hs9JSubTDGsre/h87yqMeYlzTGEoRIVe4YSMc4SGOFGRCJXdtgTUvX1YyqCu/t4CWdH3zRgBrQWUYxnZKJMSFYirJCZyUIEWfL4jBdB97HVomI/TFSbcdYh7OeqhohkLRdx7aOJ3y5POfxw3fRIjAZFZi2wZqOtuuot1s6Exm8wbtB0a03IpUG+unUW/zOd7/L3uF1rt+ao3Uewbta42L9Ma0+O36xc/fyBNZcAvIhDHTevnfWNg3eulQRjnJ6OlGPz0+jwEJTx5S47Tqq0SRCT71HpvkbvUZPSNvh8HohxlZKCNbrVQy68Fjb4lyXqsMpbRYMnkQpSVEWKK0jhysvEEpfUpqFwFmXxl210ZAEUdLFeZxPVB8hmM7mtMZQNy3RuGyskItAhPsSDaiO2+d2U2M6g5KK+XxvkBPs6dM9kL9XZ/vlb36TJ0+fMZ/vRy3MEI289/59QB3oj8/7BTY+bL0UnqgHTfVBpvCgVUxTXZoHX1Yl0tdUZYnKM0KIW4q1HcvlBcfPnmGaGiFiW6MajSKeKMtRWU633g4qqH3LQaKIBO6YzdWuY7lYJH5Yg3fyMjZLQX4gwpATmgKdZ5H+YwM6K5BK4z34ZJ9t2w5xUfAuVmakjEVPEZ9XqYzJeJLqQUkWWGsmo4pFkbNdLfBlRvAxkO4FIvKiZH9vj9G4HFTXeqGGPn3XWvPtb3+buq65fvMG48kEKRWdcwidE0Jf6Q7p/xcvP74URgQMvaA+OzPGYpoW4T3jyYRxWZL5DUJqlusVF8sVIQS0FokWDeu2SWwMmUSmBOPxJKW7aXQTsQGrnCOXOjUpY6BN8Jyfn6FEoGtbgpeMRtUQBPsBwioGJRKtNEFKvBBD6cBajyPgbAS69Q3k4CM2yPtoSP32Pa4KsrLA+8DFxYLOORASu10gRHyetq3Zbjd0TRsFqZIK/2g0Ril2CAyxFBAHEkdF/9PTU37sx36MH/76j0Qad4L0aiGwfbWdy9T+RdEhL48RDd/03WYTMTwuQkPxHiU9m9WCN99+myfHzyJ9eTJmPqlihffijGZbx7gkzyN+KC9YbZvLBi+xYeqdJB/nEKKKh9cCpWC5vGA+HSPEpe5jX27odz+BfE7lzCuFcBJjLEJ4nI1VYtu1mLZF9JgjEadm0Z/wtHXkeUkIgYvlBc+eHWNDxDrPq1g72mw3iBBjqx7FmckocNp3Xnq2SF8W6Zu4q/Waa9dvcP/+K4wnU6RM+Cup4jAZnfep8KX1fMz29d710sREMeNKHXLvUcYSmi3jXLJZniBFR9cZuralXi9RzjDWgmmhmI9LyiTJcnxyhi8K8tmMDjAObOcJnUE6h7Qtme/QvoHgqNsN5xfHnC2eYt2G1foMnYtB0rjrLJmSBGNjxdpLhFVgFdJpgouKbc5aRNsh2hZlW0KzwjdLJJHT70RGUBO8nqE7R+ZA+MjwCkXBsm3ZtDUeg8BSqIBWGXle4Ag0rqUJBkqJHmWU44K80lF+eGMJbUCjk6E5gpSs2g4jCw5vfYnr938QNT6gEzmNBeei0LkKDh0cCo9IRdwXP3Mvw9pt/aSbtSZqStc1zrmk/LXl4uIsCUAprl494vbtmzhnWS4XnJ+dst2uObpyhTzLE6y2w5g28eEjI9V7TxAisUS6oXveNi15XjxXY9FZNhT4fKowCyl2elZhcKMDgK5LxUHnuOyPPU/jCSEMtOi+Z1dWFVmWJx7a85OhYzYpGI/HSSU36jR6FwcRexcSU0ST51UKnB1ta/nSl17nytVrfZPvEhL7QcHze+77JIH1J5GWuSOE+JtCiF8TQnxLCPG/SvcfCCH+uhDit9LX/XS/EEL8eyLKy/xjIcSPfQIbet+b77np2+0WiKJNUokoiBAsOlOUZc5iccaTJw95+uwx23rDfG/Gtes3BsSgT+0SQmS7KhnT6yhcEKK29a1bXLlyhSdPnlAU+XND7WLrIeF3dkD6w7jw/jglfHRfDPQ703mGz0UPILvEGSmthqHC/fsZjcYJkaDThGkXNZikTuzZOChPK0Xd1CiVUVYjdFagdYlSBc4J1puGe/de5fqNW7gUbO5CjweBiPcYy+duREQS4v82hPCDwO8G/riIEjJ/AvgbIYTXgL+Rfgb4l4jM19eAnyPy9j92DR+gbySmqTtRAFzhnWOzWbBaL8hzRVXlGNvy6NEDTk6PWa0uKArN4eEeeweHWB/1mr2LI6r6toMUkWAYhKAoIkRUJ+zOyckJoySTF0JIOkDbOGM19byEiCr0PlyOwuxXP3wFuJxsyOUJ6x/bD2TpT6YxJjZIk6bkaFQRQhyjvlwuKYsSpTRVNUYQ+1+xAu9wziBUqoB7ULoEkVM3jpu37nH/1dexDpTKGKBrPQLyIwzpRdYnIS8+Joo2EEJYCSF+naj08bPAz6SH/WfAzwP/Vrr/z4b4bv6+EGJPCHEjPc/HvdYldUVE8fIyj/Jw5xfnNItzNpsVRZGjtWKzWXF6esJmE6cHHRzux2xnPL2sdbjIy1dA6Gk1QiJ1NuCCrDH4NK1nMpnEtkCqTW3W26iqmvpVfa8pbsHPQy+eA8wPSOcw/L5/eOzNBVxwtJ1luVxy9fqNmJY7h3cZmdYsu5rDw0Py7Brb7QYRAm3b4KzHhi4yciGWPIjzOYRS2AB7B1e5deceCIXKilgoFQyG2x/v/mv/vj/NeqHsTAhxH/gdwD8Aru0YxhPgWvr+w+RlnjMiIcTPET0Vt27eTp13FweYJI2fKEglkCYOm9OuQ+sojpllOZv1krKqCMEzGpUEZ3nnwYNY1k/A+BD80HNzzmKcjcJOeZEYn9GItA50pmMyrgiEGINtt/gQyFWP57lMpYetiT6ttzsnQgyZTs+OtdYOAuh9DLbZ1EgZxy70A4m11gQZK+fj8YiqPGC9Wg9yylmWE7yjbWu6NsZ6nW0IIlBqjUSjs5zbd+4xms6xPtB0JnLQ1HDsL7fl3RCi96IvaEyfOLAWQkyAvwD8r0MIy93fhR53+QIr7EjLHBwcDlDNEAKb9ZqT42OAlCHFzAwSW0LnaRiKTyS/iChcLtesVxuyvCQQIbLeWSQB08WWQUQWFtgUc/WV7LZtMV2cxNxvo7saQH1UPADyd+OKVD/qe1W7PDDes02IxPjot+nJZMLe3t4QS4XnXj96xzhV0eMcOBvoOovpbDqSHh8MnWs5X56z3KwZT6borMA4G7d1KQjig3UXdw3og2Khz61iLYTIiAb0fwsh/MV099N+mxJRJeRZuv9Tyct4FwNfUpW37ToyHScLrtdrrDEUoynBQ9sYhAg0tWE8LuMguRA4OT5DCo1Kw1NIOtbBO7w1ZFmOyDKQEiGjomxwHq0kmzqSE0NIYlkJd6SVvjzQ4VKV9Tlemb/cFi7Vz/qYh52rPAyeKMAAmB+NRmnIb4SzXOZkUXbY2gTJJbYqXILGSBlZH623jMYznJe02zXGWYSSGOfwqc3iQ+K4fYjBvJdt8yLrk2Rngijg8OshhP/zzq/+CvDH0vd/DPjLO/f/qylL+93A4mPjIbETUIuoxVzkOePJhMl0ytHREa+8+ipKZXgPs9kezgayrODs9IK2taxXW05Oz8jyAiGTwHisFiII6CQMCuCirBlAqnprjDGDAESdgGkDP8xfqtJLFaGxSl8aEom/tjslaNBIDD3WOUZQPUvFu8iqHU8mlAkk1gtZNU2cL6bSth4BcFm8QFSG1llssHrP2dkZJ2fPODl9yqZe4YJFaokbFF8DHocXfqBb74LYdg3/o7zRR61P4ol+GvifAr8ihPhmuu9/B/wp4M8LIf514G3gD6Xf/VXgDxL1GrfAv/YJXgOIJ0tlknJUsX9wgMShlcB0Gc5ZSqGYTeeJxOc5PT3m+OSUtq2ptxuMcdy6dXeQv/Mm6vxkWscRBM5FIKnWGGPR9MPjxEACDEm2L57E2MgMScfR+RivIfpxVDtX7w5mGnrv02/RPBdYt6ZDypyqGnF0cEjXdNi0jQUfwXZlUdC1qzRDTWJtIioEHxu/RYG00UCdM/jg0HmGVpcXBKq/aJImUWro+R2yAzCQH32qeqcP9YkztU+Snf3/+PB2yu//gMcH4I9/olfv/4aAlQ4kNEQgmBpX1OsVorOoEJuqbSeYjGc4WzOeTXl28oTJbEJYC56drvnyD/4ufudP/wEKkaF8QKIJaHAG08bAVsmAdwZBoPOGqiwgeGzXIgRYE+k5WiqC9ygJkiWOlkYonB5R5FOULpDeIVyDwGG9QcmA8R3edelzxRPufKwROSFwUtFUILuOud5HrR31doHTCpErQjCIeotwFts1kGaByNAlnenkEaUg04HZbMLEj6lGU0Q+wgRFYyxOCPBgk143STS1r1NFcS2fYsaeuOITQkWliyIZ/8dscS9N74y+uRmIwa2xaCGRIsqlyBBpM3W9IdOex48eYG1HUeTUTcsP/OBX+cnf9dPM5gfUPZMnpAp1jyyUMnoS0ixZH4a+GERgW5wu1KfhPoLxUxAOsfSQZUWaqNjrNIZLWZfdtJlL1bPLkVqeYKP4aJllaCFjtiZUFCUXgiJMMPWWuq2pshwhYWNamqYm+JjBGW/JMs3VwwOsF7ggaGykEblEuAxERdj+PQ0AOx/V2pw1sRibjHIyHkcsks4TGeGTeaOXw4hCQO5MqxUEyjQAz7Ytrt7i2xrbiZiCh3iVmq6hH5fwE7/zpyjHMzprCcPIyniTgtTCiB13az3WXcqwkOpTwcf7Raps97i/EETCJsV3V1VxKqL3sVIdscwKY+v3aSXuSgLHrTEgnAcT2J9MmVUli+U2puiqIhAvFmMNpYQsK2KB01u0jxI3BDBNR1M3tFJAXuCCoPMCKzKM6eLkbdFL36RRX96melaH6TqsMUBgu97gnOHa1avs7x+QF6DJkirJxwfbL4cRAZcjj2OGZrsGU28QpiUPhuBajMzIdeDpk2dkMjDKNdumZn9vRlHlcaiwSpjlnfZCAHQW2RwmBALROwTvUiiTILbeYboYhAsREj06eg9r3JDy7+3tD3WdaIiRX78bnMLz6fNuxqZcoBCKvfEY3zScPH7EaH/G4eEU07X4psZtt4hgIgvWB3IETkmqyRiBYJznOGepm4Z118XtSxZDBjYej0AofBDD+5CiBMC5yCBxSYXXW8vTp+fkWRx5OkkK7llqEfEx3ujlMKIAIiH8CESVfGs5ffKY9ekTtGtwXYOcX0H5lmZ1gbQG7S3bxTnfuVhw5foNjm7cxjgHKgfRC0sZrGnxTc98FVgh0oTBJEUXeriHx3QWmWdxK3OJE2bdIE6V5wXz+f4QvIfUg+21tXdTecKlaOeuEdG5OAory9heLFiePgVpEfYawTS4piaYFm87VD8Z2hp802J9ZOoG0+GtRVof54KkgLzXTirynCBU8qBhyPKApHyrcVkCuo3Gg5BF07ZUVU/Tvpzg9FHr5TAiSDFRLzoZqKqSG9eu0OWe88fv8Btv/AZvnPwi9+7e4vrVQxQes15QL855+/EzXnntK0wPDvFC4rxBC4UxbRzL0NQEH4FerbGYAFlRUBWRrZppmYTTPc50iEzGWWk9EtKHNBGopCwqxqOIh7bOolSG7Tq6Nl7Vu0XIvrJtTCwaDuKcnWF/MkUGx3Z1wcXpM6Z7I7p6iTUdi7MTNhcX6FJj8jjTY7M4p6lrrHORQ9cZQgCd5Pi8Czhv0blAAkoSCZ4iQOiNolfsj+8DFUd39SwSANN1dMaQ++fF2T9qvTxGRB+MxlZC13V0TU0mA4V07I0zVr/xlPUo5+qrd/G2pT63PPjOG6BzlmcnBG/QeZmakS6JU7WDYGfkXgEqahDVW0tVZOR6FF1820GI4zyDdSgZa0HOOoyx5JVif3+f8WSKEArn2uiFQkjN0J773rcPIhDNOTfIBFsX55BMx3HQ3ma1YLO+IHhDvV2yXq1YLc7YLJfkVuNdl6AlNhUaHRLYbLZx7ocgojKdxzuDsyam/NaBSrwyYowXFUg8vZajVpEu1E8j6idou/RZhPQDQ/aj1suBJyIkXldMznzoO+grgjco4cB1mPUCX6+ZFRnaGioCy2fHTIqcR++8TbNeY5M4g/c2qWe4dAxCUnzNmYzHjMYjmqbm6ZPH1NtNqkg7vLcDFkgQC3791EKtM/b29sl0BsSDH2ecgenS5MXnCnphMKCe0++dYzwaM51OaOqa09NnbNYLhHTU9ZrVekHXNWzWS5YXZ6yW55yfnrBZLWjrDVKAaRu2qzWFzqjyOHpd9T27tA33oyF6cXWpnu/c97SnfpRV/7Xf+naFID5uvSRGFNnkDoZb7PcEmrYmeAOhY6QV40xTEBBdR6UkNw4P0QHWFxd09RZCX4W93FJiv0uSp2EtpIA7qqBF4HvwSV0/y1EqYraFAGcNXZJ6GSVSIjBgekDQNPXQa7sczsKQ4tskkCVSLDaZRpTBer3iYnGG1gKdCdp2S9dtcd5wfn5K09ZYZ7DesNluCATKqsDYCP8oyjJqCCQhrL7kMBjBIEXs46yO9wLS/OV77TNSeB4e8knWS2FE4bnv4z+Va6rxeMDyjEdjtJII7wnOxq/Wce3oEAW89uUvM5vNkEMxLer3RM8Q+ek+VZH70ePz+ZyDgwPKNG48+Ngm6QNiIcVAgMzyIo5uGI2QSieBq0DT1Gw3m3jF77ahk6EOLQUXhdG1lBwcHCGUYl3XnC0u6LyhKIt4suOfst6skVkq+glouoa8zGNLwzuqUYXKNY3pEpMkwWgShmo4sElRpS9nyAGLzaAJ0MdD/RP0x827Xkrno3WMXpKYKCCCR4eO4AVOBowSZAf7bNenaGMZzVqu3LoFeYbIM/JxxSg4dFkwqcb8wNd/BJWPqRMtuvEWj2fTbQldhxKx9uGtpyxzSq1Zedi/egPvO7x1lBJk4v57pfBZgRVgfUleTMiqOfl0D68VVjhQlu3mFNdeoLEIr3pSXNTDlmLQVlTBIr2hxJKVh6y95jeOT3ljsaDdLvl9RUl3cY5yoDyMyxGj0TTikpxFBsPhfETbNATXoPMJzhvqro34b5ljiYRE7yUIDSqj9yzBO7SOW3oIKs4SSUVU4x0WixMWrwTQEGyGzAUqgCL7yLP3Ungi4BKvPNwRkFIxne2RFQXj8Ywf+NKXGGc5dtsw0jkqQCEzDqcHSAe+NeREFKQzBmsigN6nhqtPeOY8z5MQVpyX0Q+siz2xqD1tjE1CDJ5eY3EymQ7QECEEbRtVZfs4KMZdl0N6u6T037ZR7s/5wN7+EeVkytsPHvLoyVPOF0sWq9Wl2lof2FpLZywIybZumM3nkWfnPQ8fPcFYh0kCXp11EfIhBHXbJJJB8pbhErLbc9Mi/zJuazbRvC/hvDtN1xD4JDvaS2NEDA3KEAfgpUyqGI1BFQSVcziZMVIa6TzzyZRRMQIvMK3lu7/5XYSBLEQmq0jPKYhSxVnqkhdFgXWW5Wo5nLSYgUXFDbuT1vZqJDqLYzf39vZ2huBJNps16/U61mCkTBLIkfPfB7XehyhEKhTVdI8rN27x5sNHvP34Me88fszDx0+QWvPs+JjVeoUxLdvtmvV2RV03tG3HarWhLMc0jWFbtzx++gyhFBeLFXXX4YWkdQ6hIhM3bsnv78i/txh6eeh7DczdKdWXf+93YqcPWi/JdhZrMZdiFPFKInhUVlFO9+jWW4qy5PDKFWyA8/WW802NFZrJfJ/bd+6jdRygiwt4Y7GdGWIRQWRMGGtYb2pcgDKJqIsghqu0n+8hZZwt6wMURUWe58znsyEVbtuW7XYbg26tURLwqd/m3ZBrGmvpjKfuHFkpeHRyzulmybe//Wt8543vEJxnb/+A9XpNKePI8XW9pjYtrXG49RYXwAvJclvz5OSE8XxOOZ2zaQ2rtiObzkAqXJoZWtcNXdciddQi0CpL8BND1LZ2Q3+wvyD6DO0SvvJ8lvZR66Uwoksscg8lD1H6JAQ0Aj2a4fU5G2MwWcY75+esVhvOFgvcaMIrX/9hrt65i9MFxnvwMsImnEvTA6MWkbOOpo3Y5NneftQYCiHpTpvnWCfeWqRQKJ2h02j0oigH+GtdNzHgzjSZkATbxdpKypKinnX0ZEFIvM5xsuDRyYKlUbz98CHFeMLXfuQHOZpWHJ+eMa1yMgEXmzUmeOoujvvcbGsePj1mvV7x6MkTbt99hbP1hpPzBd99+23uvP5VDo+uRKiHihMet9sNOnconaN1hlASiRwC/R7vdAn9iP/tAvA+V2TjP4klSPIufXqjBN4KvMwQqkBWMx6ua7JMU05GzK7cYC/L2T+6yt7RNVoHxnt0UYLpCDbqXkvimASl1HMqr855cqlS+yMybqGHPiRGqRRD2txrP0M/y7WFEFILokl9tRxEjDMEYI1FSEVjHDYoyCqq2SH/6B9+g03b8KM/+Br37t/G1yuenRyzyiW5Umw7g8syTpYrrDU8efqMx2dnnBwfIzPNlXtf4rfefZdvffu3ePvdBzztPD/1Uz/FZFzEupYzMZjXeSotqFjbEjaB56Ih9cC2OHRG0M+e9TZeAJeZ2/dEdnbpjUSAIBJDU+dY5xGq5OD6bb42+5kIvMozvIjzuYTKMCqjq1s8cdZHcD5SlfstMkSx8q5tMc4nAmDSa3QgvI9BuHPI0NfMd3J1iLLCUuC8x9iotNF1XZz8mPpiWvSzziJIDBHLAwGByAqq2SFPz9c8evaYa9ePuP/KPcChtGa2f4CzDa1zUI6odEEQGdpnvPXoMYLA1evXaK3ll3/zN3h2doETikYIvvPOQw6vv80P/9AP4ZyjyiIbRkqwzsdplcIipR+8j4dBv3sgdKYtrq9Q9/d93HppAuvdjIAEJfUhgqpMUBhyir0biPEhnZ7QyBGtHNEGTW08IUR1D2EdwViCC4nmE2/ORu8RgCzPB2JArxBirNnh3F/y7iEiHIuiiN16oK7rKFy1U8BTShH6ulAP0vdJ/EdqyvGMkBV8+7tvo1Tg1VfvkGVx4B8EpNaovEIWFUbnbJFYqTBSclHXrJ1FjUeoyZhvfvu3+M7jR/iyoDo8YN1Z3nrwkCfHp2SpYZtlmjzNTOs974ArStXpCAuxCcN9OfV6Fxv+SWKil8OIwuXX4eSJqCImVIbKS4LKEXqKF2OMLzA+w4ccQo4KGYXM0TagbeqYD+qpPp3YmCkVRYGxFpvGPvUGZLpuAI0Ng+3SEsQpizKJb3ZdSy+c3ssRx5OyY4T+Em/tA4wmU1abhpOLJUeHexwd7kWAmRJY77He0zhP48DKDIqKkGd4pXFK4rVmYy3zK0fsX7/CxhqeXJxx7d5dvJQ8fPqM77z1Jsa7hC2P8jJZMiSfssYeOvv8CLAdIxF9+t8H158PA/afyOqRgH1W0498ct5jnCMISWc83gukyFEyj2zQOGgRrEdYTy5k9AB9ySBBS3YVVLu2ScySMEww7Lo4K6PHQu+akAv9bDBJ27QDTKT/egl036Ezpt6ZD9Bah3GBR0+e0HYd927fRMkoBBHLAyrim5WOmkFSxUaxkFELQEgsHplppNbcun0HpOL09ILNtubu/Vcw1vH2Ow94+OgRQsjBWERPgQu9smzUSrpk6qZJ1uLy8/abuU87wsftaC+NEYHHCo8V0ZCUtWTOooMB2eF0g1QNSrZo0ZC5Gm1r8mAiLMRbXK5Zh0BrO1AyjakUeCTGpCG+psH5FmigqaHdoukw2wsIHQIHIhCQeJGBrvBZgR6NkULhmhbqjsx4tA1gAwSFCxIbQzEyBMF6rFN0Ysyjs4ZV61ivzilly63JjLLzlEGhggKRgUjiWKZDmI4ieIrOI6wjKzKciDGMNp7rozn35keMkTx79wH3799AKThbnPPWg0dsjaM2nqbtoma368i9Ba/ie3U+TmaUgYg78z1jKZVaLCJYHIEORS2/JyrWYccT7bjPYW8LhN09T6Rb/xDStpW2r6EK63svYVPsEYFn7Gxz/XNEBm7iqfF8WD0ajxmNRpedeO+xzmA6MzRepVTD+44C6zFBWG83nC8usNZQ11v292bkWZ76V+k9962J5Il7RKZPBcI+ThEiBvZlWXJ0eEQIISq7Wcvdu3cxXcc777zDcrnEWEtdN8NzRBpT3GatMdguIhtt10XpQqHiiND4atEb+zhLhI8pNr4kRrQb0Ib3/Rw+1K2me5+rriboh2AnRY+PVUqm548nrWkajImjPnuD6g1xNy2pyhFlWQ2vYWyXJh5eMlaNSQKhIop5WucxzvPk6TGb7RYfPG1TszefDapsEV9kcd6mZujlyZYiXkDOufdxbZRSHBwcIISgrmsevvuAu3fvxoHHiwWPHz+JwbR3tF1H07W40B+rRIFybtD07mWeQ9ip1KXH4R3yYxqwn0Va5t8RQjwUQnwz3f7gzt/820la5ttCiD/wca/x3vWBBa7+IOx6pHSLwWvEEPUnIgaWqRdGFC8vilhH6edqdMYMxMWmbenaHs7B5esLwWQyRSYiuzGGerthu90kdqrFuYCzsXcllYzcNiHxQvLwyZMhRiFYpqNy6F3FWbHgReSGuRTQC5JHSBI2A6MkxXrGGmaz2aBecnp6SlkUHB4e0nUdb771Jj54yvEI6xyN6di2NbbrUgGW5JE6NpsNeNIMORXfTIRBgLMIZ5DefOT5+iR1ol5a5htCiCnwD4UQfz397t8NIfwfdx+cZGf+CPA14Cbw3wghXg8hfD5zkQDwg1EFSJH15fAY5yzWmQEG4qzBug6pBR5HZy1CCYIbsze5NpT7+1msuwYshGBvvh+hE87TtnUUBU1ZkJIyqZTEoBhvcAEaY1jXluVyTTHfp2k2SBEoC41PYxUQUWTdeZtERSNbVxAuM7500fSjqay12DSrY1SNWDYt5+fn1HXN/fv3OTk54dHjxzx6/IjxeIpNz+1NRDKoVGD1/rKPttluMV3HZDpHSo9WKWtzHuEs6rMaUfhwaZkPWz8L/LkQQgu8KYR4A/hJ4O993Gv164NwvSna6N/TJRZyiIliT6gfxhIfl2aDOcv/v703+5EsydL7fmZ2F7++xL7kWrlnVnVVd/XG3maGHDVBYMh5ICVID3whAQ0gPUh/AAE9CRQf9CAJECBQmAEEjUhIFEFA4nBAUWo2KXWLmN6m9q7OrMp9j4iM3Ze7mZkejl13j1xrWNNdUa08iUgPv+4R4X7vcbOzfOf7tFGMRgU6UpR1xebaFrbKmJ/pMBqNxvihBnPTvA6tNDMzczgnWh95PqKsC2pbMtPtBdZXqQwXztEf7AoDm3U82t5hkI/IFpYYDfukcUQaC8E6MluIdZbaWRzyupV3GHl4ikwitG3cZP6tLEsWF5e4v7nFoN9n0O+zuLgkSEvv+ejqVU6fPivyXLUNq5ql9jV1brl9+xa7u3vs7u5y+fJlsnab3/3d3xXZUJejFbi6glph4udvWJ+GWuY3gP9UKfW3gJ8hq9U24mA/mvqxhlrm8d81ppY5evTogcearvITW9q4rhHqOOOaTBCQC9uaBKphQC8E1cp52p0MHSns0JK1W2g/M2ZD00pJF5yJvLg2OrDTt4WWpqqo6pK6LsmylG6nLZR3zuOspyhzRnmO9WBRbO/3Ka2jtuIgWjk0Ukl3ymN9jfU1NVYkH5wTNSNtiJpuupu8p2ZLq6oKFSWkaYJSnrIoWV/fYG5unrSVUuQVDx4+ZFjkRFFM2krZ291n7cEdbty4wa1bt7l37z5FUcoQQH8ojHGvnOJb3/omPS0fQI3DeEu+v/Ncv/jETvQ4tYxS6u8Df1euJn8X+K+A//CT/j7v/e8Dvw/w+hde949vIU86EONgd7qmJKuuiMgJGF+kNF3YHrTWmCQmisQxBoM+ta1ZWloiNgvjqq02BufUgUxIa02vJ8AwayUQHw4GaK1otzPSVoqzgq8uq5q8FK0NKVt5tnZ2Kaqasq5QYcZNK2EoqXGUzlK4itpLT8thMXiMgjgylNVkPt97UXy0TnibYh2RpAkmiqgqz/r6OpcuXWJ5eYUb129y9+5dtnd2SJKUK1eu8PMPPuT6zSsUeYE2RrgKmrBSK0ZVxVvvvcsXvvRF2u0YbE2sPdob+vu7z72W/9bUMt77tanH/wD443D334paZtrG81kHDsp/446/bwLgBsbpxr2tSetB0noTpjuKKhcVoUg4npWX7KYqqzFUJNIGi9RkYudpt9uUVU1ZyOSIdZZOp0232yGKDEXDKVTbMfCrto5RXrC1s0MVgPqxtxjtm1lUWTUbJUekd6e8x9DMxT+JAZoubKq6JjLCZ10UI7a3t9nc3CQKLY28LPgH//AfsrW1xd5+XyojUcj+rA6gNYNSMmodmYi7aw+5/PFVVt+4RKw1kfakUSRTts+xFzrRs6hl1EEKvX8X+CB8/0fA/6yU+q+RwPoC8JMX/Z1m5XnqKjT+ox7lG+ZWJrCN0KpQXo8lnKpKajg4i9UK52ryYkRpazppIkFr7UnThDpNAn8PVHVF7RQqDPj1ZkRgLs9HeO8Dp2IbExnqACERzJBUgmtnx5Lpg8FQmpu2JkAUAB/aHFa2RldReyFWMGghVneOGov3wivUVNFtaKHUXqAqKEWSpChdkBcFH/7iF4BiMBqiIsPO7h6jPCdrtymKCmMUcRRkq1xgw/VOSFABWzveeustvnnxDFEai+Mp0U95nn0aapm/qZT6MnJqbgL/cXCGnyul/jHwIZLZ/ScvysyawHh69XniPuCtTCNoJXTCzldgg1qgrVFoyjKXVN/XgMMjF9hai0cRmRZaZeBSosjjqbCuwPsar+Rk1taRtltESZu41cXbknw0xFpHpytw3do5nHLUCgb1iNIVuHJAXRRUKmJzf0DpLMoWzGYaWwil8v6oglShlZf2i7NkXsD1WkswjY5wOsa6EldXKKdwzlAQsx+FuftRji0t2rSYWxHVgLXtXUkKlCLxHqsVNZ5RWQi2Wkc4pXEmwhmZWHHWk8TNNG/Nndv3uPdol1PHVog15KMR5aj/6ZzIP5ta5p8/52f+HvD3XvS7P8HffuzIpBA2HR81tHbT5E0wmcNvKPA8GhXqPVJzUdS2YDQcjWMOpSZZURwLHjsvK0yc0IkTWkFLvq6FDAFXQ13iqjyA4TV5WbG9tYWra9I05dKl1/jZj/4NzsK773/IkaV5jiwvYUJ7xCBFPu88VWWJlSPSUHnolxUWhUUohXO7jvOaYX8kJXHMeDzae6l9jeM8rcfEWY1K49RZBJChRmtRThbLssi5eesGp46tgA6aJ6Phc6/TocETPW5PcyDPhF12GjpS17WsVFOOBIwzGfykNGDCyaxruTTaB736KAqYIhe4eRRpS1R7ylyRJJmMLCEifbaqRf2xrtCuRjsbNEFG1DXUZYXG8PWvfZWqdgxGJeVwxCjXDPMRiytHyKsC47UgDpwlSVokSYtCGQZFyfbeDo/2B6hWG11VDIoKSosxCWDGMA/VCABqKWrK9puTpmlQ2LbBmdykTSRnRP53jgiNiRS2ghu3b/LNr79Jqg2uzlHRp9/ODomFyYMm6GyOeh9Gk4MSUHCcyaokM/Y6YKkbCIS1NUZHgCYf5cJE5puBR+Fq7HZ6KKXBG/CiS+Zsja1EqsHWBVUxohgNqPIcbyTgV16xv7vH2dNn6O8NaLe7HD9xmt2dTWZnutR1zsbegL2dbZbmZ9Fhix6MSkY7A3b3B/QHQ/ZHfQmsdUSUpaA0SkXj6rjRMqJUa4sa9wH9WHekGd5semdjdjeFwIYlnR0H8ihRd7p56wYP1h+ycP40M705cvXpK9a/UntWUD0+HBxJTT3fBS7FpmZU14H4XGup0DYknV5NqtPOkaUp3pWM8py8yEkiWYG00kRRTKfTAWS0uK4d3tXgahQBlx1GhqpSio/DvKSqKzY39+lkbQb7A85ePMnO9h6vnDrLO5tbvPX2+ywfWeTnlz9iptcha3cZDvsMBwOGo5xhXlI7wBiiNMEboa6R8yLjTFEco1FhzEehmDRIp7ewKrR1xsmKF+fxyG3TWDVK4WyFtxBpTX804uPr1zlxdJG59hwqMjzPDkkD9uBy+XRHCttXmG6l6WqHT1mD1Guww3gOkBTAVL8qIPeqqhZ2DQcKLefUi3a91hGdbm8syWCaeTJktSuqksrWUvbUCq81Ok4orWdvf8D83CKzvTnaaZtHa49QTrGzvYtznhu37lLUnrLydGbm2R/kVF6zG27jdg8VtygcWGVwyqB1HBg9ooD/UYJQHPcCxRrVRRAiiQbGK9t6cKTmXChCI7gKU65SY6uc4+e/uMLO7j57/QG1f/52dkicyB+IZ57o4E87VdPbCnWT2trxNtaM/dhwrIGtNp/MxsnkeXYcOGttaLTkQRxKMNXSADUK8FaYxvDSMFUwqiv6ZUHhPbU2DGvH7iDn4cYWWdbla1/5Ou+89Q5HV46w/WiThfl5zp4+jfKaLM0YDnLefutdRqOSlZUjxEmLKGlR1lbY8cMqqsOXQQcSKyQu1OD0hHG31WqRZZnM1tU1g8GAfr8vRdKhiMh4N0bRBEfyvHLyBK04kjqWcpi4xYONR3x09TrKJGNdkGfZIXEinuo4B78mz2tuq7riAJVdeCyKRNZAtrjp6c+DWvFNx17wxyIa4wKlXquVoZA5Ne9KbOiX1a6iqCv6oxHDqqJUitzDXlkyqqHC8GB9i83tXdbXNsiHOavLy1y7coULZ07TzTJSE5HvD1DWMT87x+rKCkZJbGZrKwVDpcfYHhHxIuB9CL03j9ceH5CJcRyPBYSTJBkH2EmSkGUyNydjU4Kpllspsr7xxhc4f+EsBGZadEJVw9vvfchuf4hXz496DocT+Sed6KlP4qATjdV8/GQl8170L4qyoK5k7qsJtP1Uh15rg7WeunIBAtIoAAkEo9PpYowEsdaWWFsC0k4pypIaT601ldb065r1vX3eu/wRt+8/JE4zLl56jbW1dY6urLK1voGvaxZnZ3l47y7Kecq84OSx45w5dQrjFXvbO5w6cZJu1sZbJ3q3zqGd8Fkq69FecEZSCvKgxZGm62nNlt3pdJidnWVmZmaiTp3ExFGM0QajNJFE1ty6dZMvvvE6WbuFtRVlKVLn9+6v8dHHNzAmfe7lOzyBdYh3JveffIpSAonQIZsYk3t7h7OMZ6VsUBaahrIZYzCREGE2uByZOPaCggyivdoYTBSFqnSEslYoi4PqtXUVo6Kgn4+4de8Ot+7cZv3RI/b29/AuZnlplSpoj+3u7XHq5Cv8/IP3OX3qFe7dvUe71eLNN77Ie++9y727d9ne3AAteKfX3niD7b19yRwjofxDubFOvcKDl1jGI9MskmwZ6a9BUMyWiRYTPlQKSOKYSMUhJpSKdRMW3L1zh9cuXGRubo7bu3fI7YjSO3SquPzRVd587dJzL90hcSIvGYZXAYXYQMUn7Q2Q4U6jhGmsrApsMUJ5i7YVyiuUq4iUJTIawuxZEkXSIfeeKBIlRW8VSjmq0TpGQ5FvU9mcOImplMLFMZ25eQrn8EYzzD27+33urT3k3voad+7f5879++QjAe3HJsaYDmXp6XaXiNM+gzLn/qMHnDp/ir28z4XlS1y5cpkvfPEb3L5xBVtV7I4GtDvHOHfpPCaJqLVjWA1wOInBiATagiWNNdiSyHliHeGtJ45i5hcW2RnmbGzv4KKEWkVUXqSpUJYYT+QtWEutHQ43RjI2W/va2iZLK5dpz69Q3n5ApuV9WRfx8+s3+fDB5nOv3iFxoqbNARMHGj9wYAvDg8ON+YQankQItHZlYDlzwopalTl1Q0A1GuG8otXpTWbFbBVEYtz4r6ZpitaaurbkRc2f/PjH/PStP2VYFpTOUeMpa4syTToNeVFQVxBH8XirtdaytbVFp9sFoN8fMDs7y9b2tgxPeoGvbm9v05npcnLlJMvLy6ytr1NXNUmkcXVJnBiBZWhYmJsjS1NOnz7Nl978MkePHeNHP3uLf/69f8nm/oBsdh5X1ESRxlbSiPbOgnUUdkQZJn2bmLBBKly7dk1iqyRBhwQjiWMebW3y4eVfPPfaHRongqen9tMO5JwLAnhu3FHHiXQDTFg8rBVIhVCq2HHjtLKW/f6IYbGFjmIWZ1pUthoPMDrrcMaRJi20NmFWq+bWvbtc/vgj5peXMK2UsraYOKas6jAyrUFLFTxO4nFcV1UVH330Ea9/4XXu37/H3Nwc+/t7ZO02l159les3r9Ptddnd2WF9c4OHaw+YmZ8L9MY5xlckBhLleOXYUf7CV7/M669eDA7qWFpZYWZmlgtnT7O6NM+oLBjs7xK1MkaDvoyRe4ctKsoipw6vKU1Ter3euCjZyFI0pmPJCivnqLzl7ffffe51OzRONA1Ea1aWAysQBHo4Se3zIg8sHg4dWOmna0aNs3n8eOZMOUdR5Gzt7GGdJ1FL2EokqpQKDCFKk2WZBN6CvSXJWhR1xfrmI1aOH8OkMZV1QmSlzHh70EoRGY3zdRjF8SwvL9Lrtnn/vftcvHiBhw8f8MqpU/QHfaIo4u7du5w+e5qvfunrrG+us9/f58jKKrdv3+L0sSNcunCOYrjPb//Wb3D8yArXr10Nw5WK3kyPstVieWGe2W6HCEcx2KceDqi8IolbpEHHVqZGJmUPYNxPq6pqXAqpqgpRh/PUzhK3WjwMsmHPskORnU23MJrbx1elJs1voB+ScU1qS5PUfboqLUwgTS+pKEtarYy5uTk63U4gNvCTJNpL0zVrtceFTOc8WadNb3Y2yD4piqoSvgAvJ9qG2lHTVnDOjdWIzpw5I4LIuagobmyss7yywsajDZZWlml3Omxtb/OTn/xYaI+dIzKGyBjOnznNb//Wb+LKiiyJcbZmf2+PxcVFjp08wfbuLv/H//kv+O//4A949733efhwHYUnjSNmux3aWYs0aZG0MlpZhyRJabWE2aQsAz7K2lAr0wwGA0ExOEdZW3QUYxHE5/PsUK9EzXGYwhl5aTnko5w0aXTh/ZiJA5TwMtfVOG1vUn8RqWuRZG3iJEVrQ+29VH91JIE9mk63i3MeK90TOp0OeVlQVhX9wQCTtmQIIPSmdIjjTKyIYo21FVqDMaJFcvvWLV597SLrGw+pbcVgNGBUFBw9doSNLVFJOnnyBB999DEXL16gLitmujPcvHET/xd/i/mFBf7pH/0zvvSlN4giw//9w3/DW++9x/qjLYqqoq48cZowNz+PihOcVpikhbWiLOSczBVL/DYhsmpokcswQq6UkhgqVPqbwYUG+fAsOxxO5J90lqc6UvheZMjlmLNOePGnipGKJj4qheRKhTFqE0mXHqnwOlsFVrPJ3zZRFAYRG7IGQ6/XI40T9kcD9vf26c4ZobGJYpRnTFGMwJ3G9HtpK+X999+nripOnz7NBx98wNGjR3nw8CHnzp/HujrIp8s28lu/8Zu8887bjIqcXrfHrd0tfvzTtzlz9gIP1tb4J//7H7Pf7zMsCqK0hYtaWB/R7s0APiBDdNBiE75I7+W4NhpcPd7am9W7uT/e8pWiGlMRTGfLz7bD4USPFRKn0Y3T25pHxnxHAWXYHGucriFkKJpeEcg4T2hKDkYjRnlJknUEjO9NUAiygQ1WkaYt4RxqIEveM9Pr0Wm3hem1KAInZI2rHWkcC7ykdgxHA3Z2twUtWZd8/WtflcHI2pJlLUajIUePHuHqreucPHWKD37+Pq2WHL916xZ7ezusrKxw5/ZtyjzHlY7v/z//L8o7Nrc2iOIIHRlMewYfJRR1TXthkbIKK6HyaC3I86qsqKoGn21wHpkkCdzV0zKkB66E9zTSOMq/yH3EDokTHdzO4OmOpJCtaXpiFYIIXAiky1IIGvCeJEmJI40PFMTNJ89ozWg0IjNGCD4bwiulaWftINYrDmuto51mdLJMCMeVosoLWllGUVRUviI2USAht3x05TLr62t8//vfJ0tT+WSXJd1OlzQVEqyFxUUerj1kfX0day2rK8tkWYvZ2R7OOb72ta/R399nc3OPnb0dwJHNLKC1onQWbyJ02iJONf3Kok0WoDAVtsrHADnvHSbgjnTo/jdO08SSjTBgc8x7j1FxaHCD8uqFnnRonOigTXplTdFxfM87qrIcV6ObsWfv7JgJVoUOdxRFOF+Tj0YC4PeCHDSJJU2kFmQbwnCEGiaOU6IoEZ4GL8QHSRSJQ3ipHA8HA5JUiMhdXVM7TzvLcNrwYO0hcRRx9uxZFhfmpZHrFT/+8Y9YXl6mv7+P957rV69x4cJFbty4zuLiIv3+PsPhiF63Q7fTIc9zTrxyivfe36GddahsKTCQVoYFBsMcnbbwylDWDu9rXFXg6hxvS2KjMEpjogijo6BT68e0MzDJ0hpiqybLmuJzn1yC59ihcaLmE6JCP6eZLZOtWeKcCEVe5ZSl0O5ZV+OQ0n/tHKOypKhrUi3z9zZMU9TKU7kaZ710xr1HW5k03d/bwVHhMTgfEcdzaDNHVeUQW7wb0VOa5V6XljHUxpCXFYOiIGtnKA3D/j7dnnTfk25KVZTcXb/LxvYao8FIemVFgceytvGA3UGBMhGzs7MsLS1TVpZz5y9y//49urNz3L7/gL29PRbmLAvzs+zt7eEVtJIWtha5iLZW1PmQ2lrhy7a1VOiNIZqCg9CcRQM+4JGalcU/Xtdl7F+PAbieb4fGiQ5uZ02Kf5DpvbYiPV7XNUYHfTFbB8xQIN3UApsg6JVNl/e9Jwwq6nGNpGlYNt93ut1Jc1eHVN1qVlaW5XUFBpCyLEmzlvAohZ/vdDoopchHI9bW1rB1zcVzF2hnGWkUs7y0xC8uX2Z2dp7RaMS777yD1pr1quK7f/m7vPfeezx6tM6pU6fodrsMBoMJJTCQ5zmucYCpcxYZjTHJ+L00gfPBExxuHx/FemKr8s84/mw7FHUimFSkJ/RuT8JBGv16gXQ22Zl8Mt2YOlgyDEF+unEa2wDamnFpEAhIXQfKmZCu97rdA7NeDSpydWV1nLUZLaIxZVGglSKOY/b398c9Oo9wNdbWcvTYUZIkYXt7m2vXr5OPRizOL9Df26e/P6C/3yfLMrJWC62kbTIajjiysjoGlDUjUAfgLoGItGkUN2rW0yWNX5UdipWo+VRNH/EHKO/CtmZryiIX5SACxDN0sqdlM52XreqAxLiSGlCzangv0x1jmIiBOI5J03TCrKpk1t85R7fXJctalEU5XvLLqqKViFrhsN9nv9+XbWuqRPGzP/1TlIduu82RlVXOnD1Hvy/Y6V6vy8zMDMsrS+R5Tpa16fU6LC4u8u6779Lr9UiShN3dXRrtsbiVjpGNLsR5KtIHoDBNT+xXZZ+EWqallPqJUurdQC3zn4fjZ5RSPw4UMv+rUioJx9Nw/2p4/PQneSHPwhON73sfhF6K0FQUEH6DrxE5cgHl+3Bypz+RE8KGSXYCE0JMrZQE2wGr3YjLNSuaMQ2PtWydWjVTI1J7abVa9AcDEbXLWrS7HdqdDqN8hIkMu/v7PFxfY3d3l5luN5CSOlppyqkTr3D1o4+Zm5nl5rXrDPb3ibTh1KlTHDt2jDfffJM0SVhdXR2fk2YbbXadpsRhTJjufeG29ednn8RdC+C73vs3gS8Dv6OU+hbwXyLUMueBbeD3wvN/D9gOx/+b8Lw/g6nHbptgT2GrSjRSbU2SCPmC1hrbIBx9w5g26aM1kFjRtGgw1oGsM0x9NFtQ2kzGhu1Uio9SS4mjiCRJUKFw2YzpuIBniuOYJElI05QoSSR1DtlQXdfs7+9x9949Pr76cZgk6XL+3DmqsuR73/u/uHf3LufPnaPX67G3u8dg0Oftt9/mzp07bGxscOHCRbTWIhATquxj2O8UOeezQX2/PC96oRN5sWYEMg5fHvgu8E/C8T8E/kb4/q+H+4TH/7J6GlfMgT8yvZ1NrRwNsYISuYOiyIMskwNnheeHsKqEjj7BWZhaiaZXIyH/1BMQPwGwFlaTx957SI1BaU2WtcbtE62aZgdjtg7vPWUdZLHwMpVhDFmnTSvLsM6yP+jz4x/9CFvXbG9ucenCRb7z7e9w6eJFhv2BZKHGMD87RytN6Xa7dLtd4jhifn6e1994g/n5eeqqYjgciiM9JX58/Bz+Mu0TbZxKKRNGqNeB7wHXgB3vfR2eMk0fcxy4AxAe3wUWn/8XnvwUKTXlWCHmGQ2HQaus2d5kYtXZekzq0JAeTKv2NMt8k/01Jf88z8lD4dIDWbs9ZgUJL0geCzHGzMzseN5rQuEbfp9zREk8jpXyoqAoi7BqTXFGW8vm1iZ1LS2PH/zgB7z7zjv0uj1GoxHtdpv5+flxe+fq1as8fPiQm7dusbu7O1lZvR+L/j0rFPhV2ScKrL3M0n9ZKTUH/G/Aq5/2D0/zE62urk6l+NBUoZsKsw9d+yIfCVR1qsWB9/hxAO1wrgow0QnB93RfCMLKwYSStzn5rfQglliCb3EQozXz8/PCRh+2tAbINhbMMwaCo9ZVha1qZntSha6sTIoorcmSjNFoxNLSBU6cOMHGxjqbm5tsbm5y9OhRNjc36ff77A36xHHMzMwMZ86eoT8Y8GB9jeFwSNZqMRyNhJdbZp4OvO5f9uozbX+m7Mx7v6OU+tfAt4E5pVQUVptp+piGWuauUioCZoEn8JV+ip/o1UuXGt8JXfmDAbWsNsIx6EOpXk2dNTvetlxogYj2axM7aB2cM5CXa2OESCo2aKMwRChliOO0WRPD/z4E7D6A99sHalnjaVwvK1JVFGPyT601FmRqJGRTSglrSSdr851vf5t33n2bJJWxpdNnTnP33l0ebdrxh0YbQ1XX3Lp9i7WNdeI4ZvXYUbIs49q1a3Q6HUEqRqIu9JRz/NgR9fgTnviZx+qPn8g+SXa2HFYglFIZ8FeAXwD/Gvj3w9P+NvBPw/d/FO4THv9X/gVrrEdRo7A07K2eyCtir4hqR+Y1Oi+p8yGuKogU1FYarM5DaT1ORxRWUTioyXFUQmGHBxVBGABUOpLAG0vut8ntCEuEiXqk7XmEzqXG+UJWNecwKGI0nbSF9hZNhQtMIjJhpDFRPCZbd86OHanX61HXNUWeY7Sm2+ty6uRRdncf0Zvt0JntsJPvsbb7iJ18nxt3b/PxjRts7e5g8WQzXeaWFjl/6SJLqyvcvHmT7e1tFhYWwkqtniwg8hQHCj7/tK8D15swlvTY1/Psk6xER4E/VEqZ8Pv+sff+j5VSHwL/SCn1XwBvIxxGhNt/oISrcQshAX2B+fGnwo/5qUPNB09Z1cL140R/jKaKG1YErRQuFORAioES+8hvHweXakJ8oJU+cKKbLa/5201x03sZ1VEKsqxFFGlqBdr7AEFpYLtQB6reOIop8pw0FXbXvd1d0jQdFxBNFPHhLz6k1W5T2Jqs22F7e5vtrS2U0tiqwmjNoL9PksQ4a7l9+zarq6t859vf5v6DB1y/fp1utysV+aetKFMN7PGxx/sczfEXX6Dn2iehlnkP4Wl8/Ph1hNDz8eM58B/82V+KD5+WyaCP1EFCkzPwQlvvx4HqdBA+HQBPl/0nGZk5EBcBY/y1R+TKIxNNNjLfcEE6dLhttVLa7Tb5aBDAaOFlu4Bs1JqqrMSpnaOVthgNh5RFQSdr86UvfYmf/vgnoCBttZidn+Pqjets7+2A1ugokpUvirBVhcUzGgw5fuw4cRxz+8ZNbl67zsLCAp1WhqukXiZ9sYk91YGaM/uUPeFp2K0/ix2atocsG40mhwelZZuzInQ3GOVhkHDiROO0OsiSKwV6nOk1DiTd/On59GagUUBrEhwnSUycJCHGERjIJMOz1HWO1rAwPyd80FMxG14JVV6IeaqyBCfB9fb2Nq6qmZubo9vuAHDkyBGMMbxy8pXxhIVzjlaWSQkDj45E2Whmdpa1tTXquuZrX/saZ86cYWdnR6ZFwnb2+GV/miM0ZYBfhh2Ktgde5s5kJ5Od2gVhXjx4JZ9S60NLQwnIqkmbi6KgLgtUwND4ZomA8Sok6bgSartACFHXNdZZtA4r0Zj9olmJQvtFOSloupputyNlBmMAA6pRHVeysoVVC+/p9/so51lYWgQvlC+RNqRZi6quuXv/HiaKKG09xnTHaYqtBJdrq5okijl37hzXrl9nY22dldVVFhcWyFoZm1ubIr/1Av6gxvQz1oznOdcncbxDshIJd+D44oV/znmiOCFNW8zNLWDiFLQBpYNcgcLWwk2kaKZBJ6UCNc7MJrWcBqDeTM9WlcydtdvZOJvzfgJxbdgzlHLYuiRNolAtbzTmdQD6T1oORgmljQ+Cx6dPnUahKIuCJI4ZDAYkacL9B/dJMylwKhMyOK1BC1mM956d7W3W19f58ptvcu7cObY2N9lY36Ddbo9lFZ56Rj/lqjO90r/IDsdKBEw3W0EE6AQn41HGMDs/z2l1hr39PXCWfDQk0kacBnEe2Q5ly2u2G8E/NydFfn0UmVC0m8RNSZKOY4mmXNCcyKocURU5WnmyVkocR7g6xGNNWQKkxGAF4ViXFQrF0soyx48d59a1Gwz2+1RVxdraGkVZ0h8McFqRpCllXcmWrpBfqBSxEVKH7UebvLW9zbFjxzl+5ChFUZCYiCxJ2dndhZZ5aob2aaxBPk4nHM+yw+FEnrASNaApaZMrramdw5aiTT+3sEgry9jafES9vy8z7FqFWo4Ls+qeqqxDXSZ0ul3QM7XSqTfh06vCmI/WIq1grQ2SBRPuR3EmO+bwSZKI2BiKWjLBRpEHJWRRRmvq4IytNMFZKVTa0KIxWnP/wQPmlxYhlsZs7awAxLQa9/WUAlfLyvnqq6+iteb+/fvs7Ozwla98hTt37rC6usooz6lfoNHanGP/RPREOA8HA+txBjuVrT7PDs12Jo7UBKoTOhmR227EWUSY1zmPNs2EgsIYaUamcUyWJrSyFmmahGBaTlAURaStNPD3JIEJ342zt1aWAUw5kB/fhhQMW1cYpUgT0f9SU+dWeykbRMYQmwijBa+dj3KygDTc2dlhdXWVnZ0d7t27N+ZTat6LDFBOmElMGCa8cuUKRVEwMzPD/Pw8S0tLDIfCgl9VIvb3yc7yJ3zeVO/NhRDgeXY4ViKYSj9lY2pUF31zzHsZjQ6gexl5VmAn/TFBNGqUEbEXY8KKFmpCkYmIokYAzgWWNKkztdIWxkRUdbP6hJbKeEUS2IdSWmb194ayeoQL45QQnSuCxEPo/Od5TlWUJHHMxsYGZVly8dIl7j64T54XxEkss2/yNg9YbWtBB7RSHjx8yP7eHm988YvcunWLLGtTVTWtVkbtBOM0dhKlDlT0adoBTA9CTDLYadSCCnGlDf1I2fI/ByuRR1E5RY3GmwivFNZbUA6lHagaVEVEhbYlrchjlMMgfTOU0MGoKIEoBjRGxSRRRivu0Io7dLMZ0jglTQxaVXg/QltPrCJik5AmbUTvVIJqZWsib4ldTWkVtTdUhSM1Kb2kS+SFbMppTxk5cm0xXhGjMCi0k5Rfec/Ozg5z8/N0u122t7fZ3d/j6LGjQuAeKPya2ljz5bzHx4bc16g0ZmZpCeIYTMTNu/c5evwkG5s7LK8co1VBx2miGgwKnPxG7SFyEFtIagA1Rq6LjIUD6sC0UoEt8HVO5CrcqI8d9Vme7fDVN77w3Ot3aFaixiaN2MeaiOHsllVJXpQCBkuSQEnXNG4JmONYMial5ZKGLK2sSlwpHX6tNWUpQndRnIy3FAK+yLkpQTsr7B1RHKOdZ25uBnfbNRl+IB6NqJ3FaIHLttvtMWPZ2voaWZYxHAy49OqrXLtxne3dHXRksM4SxfFkClWHjDJgyAEePXrE1qMtVlePcOfOHbqdLlmWMRrlHD16lLU4Ji9LvFZoE4tzBviMczJHprXBVhVRHIFr0I+yHNW2pi4FkZkmKe0s49ULF7lw4QInT55kcXGRf/HPnklbfric6HEowwGgFchMuBLn0EGbQvh7lAzngYQv1gIu4KNl4tV7S1UVUvOxJc7VlLVDmUhUFZG5epF4CLASP0ECuDAc4F1Np9OR7K626ERwzVFk8GWQhMJy/MQJyrJkNp5jbX2d1eUVtDFs7+xw/vx5HqyvMchHeER2qgHDaaXx2oiDKkVRyAhU2moxGA7RXvHGG1/kwYMHgRGty9KRI1Jzig3DPCdKk3ErRvRO5EPRThJsXYUygiEfDgBPbDTL8wscObLKKydPcuaV0/S6PdptUVF6Vn2psUPjRI+vPNP3m8pwFVSdLYqqdlTVCGM0tfN4ZULX3UpTdBwHiBPVdQVKkSYJ2mlqW+K8fHKTVktm0upqIt85Lh2IavQkTnBERtNKU/plicdJDIQ4cW0tOjLMzs3x8P59rHVUdU2722V7a4ter8f9Bw/warJ1JUkyrkmpgDRoenJZlqGAMi+4cOEiM50eN2/eZHd7h29845vcvn2bh9sb1EA1ykmzjDwfBaBd0+oB7xzDvT2hLnaWdtbi5NFjnDx+jF6vx4kTx+h2OmStligYxQmJMWFLfv61O1RO9KyVCIJP6IhW1mZ+AdrtDnVdUeY52hjqIAhT1hUmisKyJFVqUDivsLYKeqthJbLg0OgopmHWdHWN9zYULzVeCUGEx4XJEgmgu50Og6oclyacrYnCKFFkZIhxfWODhbl5irJgv7+PMjIsmSQJWzvbJG2ZXC3qCUZKKw3agZfRb4Ayz5mbWyCOY65fv86rly4xPzvHo0ePOHnyJPt2xN7+HsYb6rIkCnpptq4pQn/QKMVMu8PS0iLnzpzh3NmzLC0u4Kxle2eLNI5JjCHRhgiFryqs90SplEWeZ4fGieDJ7Wx6JfLeY71DRzG92XlmZsLK4KRFoEKGMRwOGeU5NLmSMhgTMRjsMxz22e/vUJdSl1laPsrunpBOeQUmUoxycTCUH3NAglwEjScyBmM0M70Oa1ubUp8KLLVFaUmThLIsebS5ydLyEnEUk45aPNrc5OgRiWkuXbrEXn9/HE81Wq7yXgkg/snURqvdZm9vj8uXL7M4t0CcJOzu3ieKEgaD65w7f5pbt26xvrZGlRfEkfAn4T0LCwucPHGCEydO8Orp0xw/foxupyvyEWXF/v4uERApRYTCliVxJHKkSRQRKTVm63+WHVonOrCVBXOBdkOhwnagEIWwQM7sfeizSYaGA6Ulc+v2Zmm1M+bmZ9EGjNEUecn+fp8kidGRIS9yUI4kjcnzmuFwFPQ8/ETBUUEax8zM9IijSJSEtBZ6PJMIgtF7VldXaaUpt2/dYqbbI89zOr0uaMWDBw9QSprLHonhmukUxaTfR/i+CZCVUuzu7vDxxx+jPJw7d4HLly/zaO0BthhCmTPbSol1xMnjJzh39ixvfPGLzM7NStAcSaG1rgoibYjbhn5/d9L0pokr/ZNfz7FD40SfBNLZvE0XaiANdflYtkD54FiyjXlAe4X3CpqipYoQ+l5FnGbMGhmvcTgR0fSeRtVaedFXM0qLBJR34+p01mpJdbrIiY2wpZW1UNmZyEj33jlOvvKKKD4XOffu3eP06dNcv3qNpJVKk9mogBgIlWKlUAG5qZSI+rUDwfnJkyfptbt8fOUKSZJy7949CX6Vo9jf5cTKEkcXlzm+epTlpSUW5uY4Mtej1RY+pWFZS3E2TtAIymBawjx86g5ck2kG3mfZoagTNfYisLn1CuuDXrMPK5FqapSNjrPIKzg/EYyxrsn/NdrEmPCJjOOUJM1CDCUBbdqK8XgGgz7bW1tsb2+xv7cn2mRKJjGM1nTabTqdbAxuU0pih7Is5bUoOH/+PPv9PhsbGyyvrjIYDgAZt46iCG2EiaSpnAtwbrIKCylXlzyX9PvWrVsMBn2++Oab9Ho9rn78MVVVkihoGc3r589xfGmRuaxFL4poKUXqPbG16Lqi2+uSpikgoUGTDXh8QIGG4iPCWOuVSKB6Pifb2XglCp/0cPDAc8YjOlPpfFPh9iGbau6P17QDo0cNRkgcVSFOBmCiWAJZV2NqSz4asb29RbfTZa6T4YFRnjMc9tkdDtGtFnFkaNA8WmnyukQHRFMURVy5coVur8uZs2dJk4RHSsmMvneiS6ZARRJjNe9pvJ3g8bUgCZLI4J1Uwh89esTe7h4XL1xkbn6Ba1evEvmM5YUFKUOYiFhBrBUmJAFxJAWt0iMlCCtS6oL9fuwE04QJk9LK813oEDmRHifUoSflpjo9YV/WTWm+wQSF3prARkI9SBlBP4YropSlBiIdyXOt4ICE5MqBiqiAyoc5Ml/hccRRwly7xWwnhtqjioLI5qRuQNeUqChiebbNo81tLKJ/USVhgipWqMTQymY5fvwku9s73Lt5k4X5BQn8KSCWd6t8hXJysbVz2Dpo2lpLz2vm5xc48cor7O7tEbVazMzPc/36DT748F2OHjvGt3/z21x5/x2MKrFO6j9JlkKsKY1izzlclGCNwtT6wIpdU1MpRe09EUrOu3W4KKZ2SvqBXsMLtD0OjRMBEhgz6ec8q2705I9NgvHHn/IETPRx6Og07FgFzp5I5utRUOQF+f6Q/mCfQd6nqAsK54gwzHVnSfUGhYMoTnBhADJrtWjFCUlkuHvzJuUo5803v0RdlNy8dRNfyijUhOgzoigKjNIkUcT84hLLy0ucXz3GuXPnmZmb4733P+D2/fvs7exy6tQp5vp9rt24waA/4uzZs6zfvx+mdFOcF67GeCreeVZUM+65yTfjFWj8c58vPNHEplsfzf3p2+b7p7/Byfb1tJ97wV+WmopWpGlCmqQYLLPdNknkybII6x1Wa+LOLCs+5s6dR2zu5bTbPVqxFzGWKMJoRaQ1uYk5dfYY5bDPrRs3ZT6uqGRGzTlibei0Mo6fOcvRI0c5srLC3OwcvV6PubTF3Nw8RVnxjW/8BY7df8BHV6/yo5/8lNNnz/Ktb3yT99//gCuXr/Cl11+jNzODdY5Ob4Zut0uatYmTBO8JtMVPI/D0YaFvgugnnehF5+/QONHTXujjdaKnrUSPlwUeHxv+pJ8mefLEgZNEYCPGV8RVhdEtslYMWuNURNabx+oWZ48dpxjeJvYQRS0iDDGGSEl0pMqS65d/gbMVkdGM8pxeb47l5WVOnjzJqVOnWF1ZZX5ujjRJAx48QHqrCmsFKhInCa+99hqvnDqF0oYf/PCHZO0OX//KV9nb2eAv/qW/xOriAlmcoMKQgDcKokg0ZOunY478uLLP1E4goTZBzehF2dmhcqJnbVfTiMPp5z/tZ1SAQbwQmD5d1Jw6LKTpCmM0cRJjHCTKE0UhXtMRTgQ3aactzhw7xvqDR+z2ByijqIscZUxI3WvK/h6RsywuLpC1Ei69+irnLrzB7Mwsc3OzoW5TTaZSlADzbFERGwU4kjih000ZDEd02m1Wl1f4zre/w3vvv8+P/uRP+Pf+xl/j9KlT+KpGeWi1s4CFAl854d9uVplnOMR4y1Pj9GX89SIc0uFwoqe0Oh6HZD6+PT1e2W6grFEUCSF5Qxmj9VN/VpoVIY9TElROeI0kH2m1WlApYuXAGxGhURp0hFcGvOPs8WNo4PJH11gbDCirksgpacYCZ48fZXFxniOrK8zM9Dh//gKd3krzwsGDGY8qQdNJbsa0dSBsKMuCyBghCl1e5oc/+CHnz5xlY+MR58+dF6A/TTuolnfXlD/wY99wPqgWKfBTWCEP4+r7AQfyjhct5IfDiZ5iTwusn/b99P0GXPU4uutZK1IDzG/abHjGaEmtDZGJcLZC6yhkjUo62lpWIoclS+DUiWVmuilbgwGD4SCMXTdbYos4iomMgUa9ehzwEtp7kr4D4xqTEljQVLkjnBMUx48d4/XXXuOnP/kpv/3vfJfFhTlAnLGoLVGUjLkJUAFH/pRz4JlCcgZCDKsc2k1Di18M1j+0TgRPD6hf9JzgF088/tyfV0HjUBEu5mTgES0FSkL1WtGwfIRygKuJtafXEVTlbNYljmJKa3EOWmk6wQMoTTtORLhX/vpBlw8j0WN/OoBPlGe62pKlGZcuXOTOrTucO3OWyERYW5MkGVVp0V7KHuMfVvaZYc3YiZRUzr1qWizgnMY5FTi+n23q046W/HmYUmoDGACPPuvX8hnYEp+P933Ke7/8tAcOhRMBKKV+5r3/+mf9On7V9uvwvg9V7+ylfT7tpRO9tE9th8mJfv+zfgGfkX3u3/ehiYle2ufXDtNK9NI+p/aZO5FS6neUUleUkKf/nc/69fx5m1Lqf1BKrSulPpg6tqCU+p5S6uNwOx+OK6XUfxvOxXtKqa9+dq/8k9tn6kSBwu+/A/4q8AXgbyqlnj9u+fmz/xH4nceO/R3g+977C8D3w32Q83AhfP1HwN//Fb3GT2Wf9Ur0DeCq9/66974E/hFCpv5rY977HyDcldP215kQxv8hB4nk/ycv9iOEoffor+SFfgr7rJ1oTJwebJpU/dfZVr33D8L3D4HV8P3n8nx81k70/3vzk67x59Y+aydqiNMbmyZV/3W2tWabCrfr4fjn8nx81k70U+CCEtmrBOG8/qPP+DX9KmyaMP5vc5BI/m+FLO1bwO7Utnd4bRpH+1l8AX8N+AgRnfnPPuvX80t4f/8L8ACokBjn9xDBnO8DHwP/ElgIz1VItnoNeB/4+mf9+j/J18uK9Uv71PZZb2cv7dfAXjrRS/vU9tKJXtqntpdO9NI+tb10opf2qe2lE720T20vneilfWp76UQv7VPb/wesgM/lIibH4wAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
diff --git a/dalle/models.py b/dalle/models.py
index 62cb2ba..cf75985 100644
--- a/dalle/models.py
+++ b/dalle/models.py
@@ -14,8 +14,6 @@
 from utils import *
 
 
-
-
 class DALLE_Klue_Roberta(nn.Module):
     def __init__(
         self,
@@ -107,7 +105,8 @@ def __init__(
             self.norm_by_max = DivideMax(dim=-1)
 
         self.to_logits = nn.Sequential(
-            nn.LayerNorm(dim), nn.Linear(dim, self.total_tokens),
+            nn.LayerNorm(dim),
+            nn.Linear(dim, self.total_tokens),
         )
 
         seq_range = torch.arange(seq_len)
@@ -123,58 +122,6 @@ def __init__(
         self.register_buffer("logits_mask", logits_mask, persistent=False)
         self.loss_img_weight = loss_img_weight
 
-    @torch.no_grad()
-    @eval_decorator
-    def generate_texts(
-        self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0
-    ):
-        text_seq_len = self.text_seq_len
-        if text is None or text == "":
-            text_tokens = torch.tensor([[0]]).cuda()
-        else:
-            text_tokens = (
-                torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)
-            )
-
-        for _ in range(text_tokens.shape[1], text_seq_len):
-            device = text_tokens.device
-
-            tokens = self.text_emb(text_tokens)
-            tokens += self.text_pos_emb(
-                torch.arange(text_tokens.shape[1], device=device)
-            )
-
-            seq_len = tokens.shape[1]
-
-            output_transf = self.transformer(tokens)
-
-            if self.stable:
-                output_transf = self.norm_by_max(output_transf)
-
-            logits = self.to_logits(output_transf)
-
-            # mask logits to make sure text predicts text (except last token), and image predicts image
-
-            logits_mask = self.logits_mask[:, :seq_len]
-            max_neg_value = -torch.finfo(logits.dtype).max
-            logits.masked_fill_(logits_mask, max_neg_value)
-            logits = logits[:, -1, :]
-
-            filtered_logits = top_k(logits, thres=filter_thres)
-            probs = stable_softmax(filtered_logits / temperature, dim=-1)
-            sample = torch.multinomial(probs, 1)
-
-            text_tokens = torch.cat((text_tokens, sample), dim=-1)
-
-        padding_tokens = set(
-            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)
-        )
-        texts = [
-            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)
-            for text_token in text_tokens
-        ]
-        return text_tokens, texts
-
     @torch.no_grad()
     @eval_decorator
     def generate_images(
@@ -188,7 +135,7 @@ def generate_images(
         img=None,
         num_init_img_tokens=None,
     ):
-        origin_text=text
+        origin_text = text
         vae, text_seq_len, image_seq_len, num_text_tokens = (
             self.vae,
             self.text_seq_len,
@@ -244,13 +191,13 @@ def generate_images(
         images = vae.decode(img_seq)
 
         if exists(clip):
-            #from transformers import AutoTokenizer
+            # from transformers import AutoTokenizer
 
-            #clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
-            #origin_text
-            #input_text = input_text.to("cuda")
+            # clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
+            # origin_text
+            # input_text = input_text.to("cuda")
             text_embeds, image_embeds = clip(origin_text, images)
-            logits = (text_embeds @ image_embeds.T)
+            logits = text_embeds @ image_embeds.T
             return images, logits
 
         return images
diff --git a/model.py b/model.py
index 24d409c..007827b 100644
--- a/model.py
+++ b/model.py
@@ -73,6 +73,7 @@ def top_k(logits, thres=0.5):
 
 # discrete vae class
 
+
 class DiscreteVAE(nn.Module):
     def __init__(
         self,
@@ -111,18 +112,23 @@ def __init__(
         dec_init_chan = codebook_dim if not has_resblocks else dec_chans[0]
         dec_chans = [dec_init_chan, *dec_chans]
 
-        enc_chans_io, dec_chans_io = map(lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans))
+        enc_chans_io, dec_chans_io = map(
+            lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans)
+        )
 
         enc_layers = []
         dec_layers = []
 
         for (enc_in, enc_out), (dec_in, dec_out) in zip(enc_chans_io, dec_chans_io):
             enc_layers.append(
-                nn.Sequential(nn.Conv2d(enc_in, enc_out, 4, stride=2, padding=1), nn.ReLU())
+                nn.Sequential(
+                    nn.Conv2d(enc_in, enc_out, 4, stride=2, padding=1), nn.ReLU()
+                )
             )
             dec_layers.append(
                 nn.Sequential(
-                    nn.ConvTranspose2d(dec_in, dec_out, 4, stride=2, padding=1), nn.ReLU()
+                    nn.ConvTranspose2d(dec_in, dec_out, 4, stride=2, padding=1),
+                    nn.ReLU(),
                 )
             )
 
@@ -183,7 +189,14 @@ def decode(self, img_seq):
         images = self.decoder(image_embeds)
         return images
 
-    def forward(self, img, return_loss=False, return_recons=False, return_logits=False, temp=None):
+    def forward(
+        self,
+        img,
+        return_loss=False,
+        return_recons=False,
+        return_logits=False,
+        temp=None,
+    ):
         device, num_tokens, image_size, kl_div_loss_weight = (
             img.device,
             self.num_tokens,
@@ -202,7 +215,9 @@ def forward(self, img, return_loss=False, return_recons=False, return_logits=Fal
             return logits  # return logits for getting hard image indices for DALL-E training
 
         temp = default(temp, self.temperature)
-        soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=self.straight_through)
+        soft_one_hot = F.gumbel_softmax(
+            logits, tau=temp, dim=1, hard=self.straight_through
+        )
         sampled = einsum("b n h w, n d -> b d h w", soft_one_hot, self.codebook.weight)
         out = self.decoder(sampled)
 
@@ -227,6 +242,7 @@ def forward(self, img, return_loss=False, return_recons=False, return_logits=Fal
 
         return loss, out
 
+
 class ResBlock(nn.Module):
     def __init__(self, chan):
         super().__init__()
@@ -283,16 +299,18 @@ def __init__(
         dim = self.text_emb.weight.shape[1]
         self.image_emb = nn.Embedding(num_image_tokens, dim)
         print(dim, image_fmap_size, image_fmap_size)
-        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>
+        self.text_pos_emb = (
+            torch.load(wpe_dir) if not rotary_emb else always(0)
+        )  # +1 for <bos>
         self.image_pos_emb = (
-            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))
+            AxialPositionalEmbedding(
+                dim, axial_shape=(image_fmap_size, image_fmap_size)
+            )
             if not rotary_emb
             else always(0)
         )
 
-        self.num_text_tokens = (
-            num_text_tokens  # for offsetting logits index and calculating cross entropy loss
-        )
+        self.num_text_tokens = num_text_tokens  # for offsetting logits index and calculating cross entropy loss
         self.num_image_tokens = num_image_tokens
 
         self.text_seq_len = text_seq_len
@@ -341,59 +359,13 @@ def __init__(
         seq_range = rearrange(seq_range, "n -> () n ()")
         logits_range = rearrange(logits_range, "d -> () () d")
 
-        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (
-            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)
-        )
+        logits_mask = (
+            (seq_range >= text_seq_len) & (logits_range < num_text_tokens)
+        ) | ((seq_range < text_seq_len) & (logits_range >= num_text_tokens))
 
         self.register_buffer("logits_mask", logits_mask, persistent=False)
         self.loss_img_weight = loss_img_weight
 
-    @torch.no_grad()
-    @eval_decorator
-    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):
-        text_seq_len = self.text_seq_len
-        if text is None or text == "":
-            text_tokens = torch.tensor([[0]]).cuda()
-        else:
-            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)
-
-        for _ in range(text_tokens.shape[1], text_seq_len):
-            device = text_tokens.device
-
-            tokens = self.text_emb(text_tokens)
-            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))
-
-            seq_len = tokens.shape[1]
-
-            output_transf = self.transformer(tokens)
-
-            if self.stable:
-                output_transf = self.norm_by_max(output_transf)
-
-            logits = self.to_logits(output_transf)
-
-            # mask logits to make sure text predicts text (except last token), and image predicts image
-
-            logits_mask = self.logits_mask[:, :seq_len]
-            max_neg_value = -torch.finfo(logits.dtype).max
-            logits.masked_fill_(logits_mask, max_neg_value)
-            logits = logits[:, -1, :]
-
-            filtered_logits = top_k(logits, thres=filter_thres)
-            probs = stable_softmax(filtered_logits / temperature, dim=-1)
-            sample = torch.multinomial(probs, 1)
-
-            text_tokens = torch.cat((text_tokens, sample), dim=-1)
-
-        padding_tokens = set(
-            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)
-        )
-        texts = [
-            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)
-            for text_token in text_tokens
-        ]
-        return text_tokens, texts
-
     @torch.no_grad()
     @eval_decorator
     def generate_images(
@@ -422,7 +394,9 @@ def generate_images(
         if exists(img):
             image_size = vae.image_size
             assert (
-                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size
+                img.shape[1] == 3
+                and img.shape[2] == image_size
+                and img.shape[3] == image_size
             ), f"input image must have the correct image size {image_size}"
 
             indices = vae.get_codebook_indices(img)
@@ -462,14 +436,14 @@ def generate_images(
         print(images.shape)
         if exists(clip):
 
-            #from transformers import AutoTokenizer
+            # from transformers import AutoTokenizer
 
-            #clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
-            #origin_text
-            #input_text = input_text.to("cuda")
+            # clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
+            # origin_text
+            # input_text = input_text.to("cuda")
             text_embeds, image_embeds = clip(origin_text, images)
 
-            logits = (text_embeds @ image_embeds.T)
+            logits = text_embeds @ image_embeds.T
             return images, logits
 
         return images
@@ -547,5 +521,7 @@ def forward(self, text, image=None, mask=None, return_loss=False):
             logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]
         )
 
-        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)
+        loss = (loss_text + self.loss_img_weight * loss_img) / (
+            self.loss_img_weight + 1
+        )
         return loss

From 769952eb0de2e0095f2341d68fe905d11bfa3d1f Mon Sep 17 00:00:00 2001
From: noopy <young_ahn@yonsei.ac.kr>
Date: Sun, 26 Dec 2021 19:06:55 +0900
Subject: [PATCH 23/26] update: inference

---
 inference.ipynb | 824 +-----------------------------------------------
 1 file changed, 1 insertion(+), 823 deletions(-)

diff --git a/inference.ipynb b/inference.ipynb
index f78d79c..48a8d29 100644
--- a/inference.ipynb
+++ b/inference.ipynb
@@ -1,823 +1 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "%config InlineBackend.figure_format = 'retina'"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Random Seed:  999\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<torch._C.Generator at 0x10bddb810>"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from __future__ import print_function\n",
-    "import random\n",
-    "import torch.nn.parallel\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# https://stackoverflow.com/questions/12984426/pil-ioerror-image-file-truncated-with-big-images\n",
-    "# ImageFile.LOAD_TRUNCATED_IMAGES = True\n",
-    "\n",
-    "# Set random seed for reproducibility\n",
-    "manualSeed = 999\n",
-    "#manualSeed = random.randint(1, 10000) # use if you want new results\n",
-    "print(\"Random Seed: \", manualSeed)\n",
-    "random.seed(manualSeed)\n",
-    "torch.manual_seed(manualSeed)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from easydict import EasyDict\n",
-    "\n",
-    "# constants\n",
-    "\n",
-    "VAE_CFG = EasyDict()\n",
-    "\n",
-    "VAE_CFG.IMAGE_SIZE = 256\n",
-    "VAE_CFG.IMAGE_PATH = './'\n",
-    "\n",
-    "VAE_CFG.BASELINE = False"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from random import choice\n",
-    "from pathlib import Path\n",
-    "\n",
-    "# torch\n",
-    "\n",
-    "import torch\n",
-    "from torch.optim import Adam\n",
-    "from torch.nn.utils import clip_grad_norm_\n",
-    "\n",
-    "# vision imports\n",
-    "\n",
-    "from PIL import Image\n",
-    "from torchvision import transforms as T\n",
-    "from torch.utils.data import DataLoader, Dataset\n",
-    "from torchvision.datasets import ImageFolder\n",
-    "from torchvision.utils import make_grid, save_image\n",
-    "\n",
-    "# dalle related classes and utils\n",
-    "\n",
-    "from dalle_pytorch import OpenAIDiscreteVAE, DiscreteVAE, DALLE\n",
-    "\n",
-    "# helpers\n",
-    "\n",
-    "def exists(val):\n",
-    "    return val is not None"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from easydict import EasyDict\n",
-    "\n",
-    "DALLE_CFG = EasyDict()\n",
-    "\n",
-    "# argument parsing\n",
-    "\n",
-    "DALLE_CFG.VQGAN_PATH = \"/Users/noopy/Downloads/500k_VQGAN.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
-    "DALLE_CFG.VQGAN_CFG_PATH = \"/Users/noopy/Downloads/500k_VQGAN.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
-    "DALLE_CFG.DALLE_PATH = \"/Users/noopy/Documents/KoDALLE/dalle_500k_vqgan.pt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
-    "DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n",
-    "DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n",
-    "DALLE_CFG.BPE_PATH = None\n",
-    "DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n",
-    "\n",
-    "# DALLE_CFG.EPOCHS = 20\n",
-    "# DALLE_CFG.BATCH_SIZE = 54\n",
-    "DALLE_CFG.LEARNING_RATE = 3e-4\n",
-    "DALLE_CFG.GRAD_CLIP_NORM = 0.5\n",
-    "\n",
-    "# DALLE_CFG.MODEL_DIM = 512\n",
-    "DALLE_CFG.TEXT_SEQ_LEN = 128\n",
-    "DALLE_CFG.DEPTH = 2\n",
-    "DALLE_CFG.HEADS = 8\n",
-    "DALLE_CFG.DIM_HEAD = 64\n",
-    "DALLE_CFG.REVERSIBLE = True"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "input_text = \"하의에서 기장은 니렝스이다. 하의에서 색상은 화이트이다. 하의에서 카테고리는 팬츠이다. 하의에서 소재에는 우븐이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 서브색상은 레드이다. 상의에서 카테고리는 블라우스이다. 상의에서 소매기장은 반팔이다. 상의에서 소재에는 시폰이다.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([[    0, 19975, 27135, 10653,  2073,     3,    18, 19975, 27135,  8817,\n",
-       "          2073,  7482, 28674,    18, 19975, 27135, 17748,  2259, 15144, 28674,\n",
-       "            18, 19975, 27135,  4642,  2170,  2259,  1469,  2862, 28674,    18,\n",
-       "         19975, 27135, 17107,  2170,  2259,  8482, 28674,    18, 19975, 27135,\n",
-       "          1887,  2073,   766,  2149, 28674,    18, 10346, 27135, 10653,  2073,\n",
-       "           766,  2149, 28674,    18, 10346, 27135,  8817,  2073,  7482, 28674,\n",
-       "            18, 10346, 27135, 12296,  2485,  2290,  2073,  7555, 28674,    18,\n",
-       "         10346, 27135, 17748,  2259, 21300, 28674,    18, 10346, 27135,  8696,\n",
-       "          2015,  2121,  2073,  1121, 31286,  2062,    18, 10346, 27135,  4642,\n",
-       "          2170,  2259,  1325,  2357, 28674,    18,     2,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1]])"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# import from huggingface transformers\n",
-    "from transformers import AutoTokenizer, AutoModelWithLMHead\n",
-    "  \n",
-    "tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n",
-    "# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")\n",
-    "\n",
-    "encoded_dict = tokenizer(\n",
-    "    input_text,\n",
-    "    return_tensors=\"pt\",\n",
-    "    padding=\"max_length\",\n",
-    "    truncation=True,\n",
-    "    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n",
-    "    add_special_tokens=True,\n",
-    "    return_token_type_ids=False,  # for RoBERTa\n",
-    ")\n",
-    "input_ids = encoded_dict[\"input_ids\"]\n",
-    "attention_mask = encoded_dict[\"attention_mask\"]\n",
-    "input_ids"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "DALLE_CFG.RESUME"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n",
-      "loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n",
-      "VQLPIPSWithDiscriminator running with hinge loss.\n",
-      "Loaded VQGAN from /Users/noopy/Downloads/500k_VQGAN.ckpt and /Users/noopy/Downloads/500k_VQGAN.yaml\n"
-     ]
-    }
-   ],
-   "source": [
-    "from dalle_pytorch import VQGanVAE\n",
-    "from pathlib import Path\n",
-    "\n",
-    "DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n",
-    "\n",
-    "dalle_path = Path(DALLE_CFG.DALLE_PATH)\n",
-    "assert dalle_path.exists(), 'DALL-E model file does not exist'\n",
-    "\n",
-    "loaded_obj = torch.load(str(dalle_path), map_location=torch.device('cpu'))\n",
-    "\n",
-    "dalle_params, vae_params, weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n",
-    "\n",
-    "vae_klass = VQGanVAE\n",
-    "vae = vae_klass(\n",
-    "    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n",
-    "    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n",
-    "    )\n",
-    "\n",
-    "DALLE_CFG.IMAGE_SIZE = vae.image_size\n",
-    "\n",
-    "dalle_params = dict(        \n",
-    "    **dalle_params\n",
-    ")\n",
-    "\n",
-    "DALLE_CFG.IMAGE_SIZE = vae.image_size"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'num_text_tokens': 32000,\n",
-       " 'text_seq_len': 128,\n",
-       " 'depth': 12,\n",
-       " 'heads': 16,\n",
-       " 'dim_head': 64,\n",
-       " 'reversible': False,\n",
-       " 'loss_img_weight': 7,\n",
-       " 'attn_types': ('full',),\n",
-       " 'ff_dropout': 0.0,\n",
-       " 'attn_dropout': 0.0,\n",
-       " 'stable': False,\n",
-       " 'shift_tokens': False,\n",
-       " 'rotary_emb': False}"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dalle_params"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from math import log2, sqrt\n",
-    "import torch\n",
-    "from torch import nn, einsum\n",
-    "import torch.nn.functional as F\n",
-    "import numpy as np\n",
-    "\n",
-    "from axial_positional_embedding import AxialPositionalEmbedding\n",
-    "from einops import rearrange\n",
-    "\n",
-    "from dalle_pytorch import distributed_utils\n",
-    "from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE\n",
-    "from dalle_pytorch.transformer import Transformer, DivideMax\n",
-    "from dalle_pytorch.attention import stable_softmax"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def exists(val):\n",
-    "    return val is not None\n",
-    "\n",
-    "\n",
-    "def default(val, d):\n",
-    "    return val if exists(val) else d\n",
-    "\n",
-    "\n",
-    "class always:\n",
-    "    def __init__(self, val):\n",
-    "        self.val = val\n",
-    "\n",
-    "    def __call__(self, x, *args, **kwargs):\n",
-    "        return self.val\n",
-    "\n",
-    "\n",
-    "def is_empty(t):\n",
-    "    return t.nelement() == 0\n",
-    "\n",
-    "\n",
-    "def masked_mean(t, mask, dim=1):\n",
-    "    t = t.masked_fill(~mask[:, :, None], 0.0)\n",
-    "    return t.sum(dim=1) / mask.sum(dim=1)[..., None]\n",
-    "\n",
-    "\n",
-    "def set_requires_grad(model, value):\n",
-    "    for param in model.parameters():\n",
-    "        param.requires_grad = value\n",
-    "\n",
-    "\n",
-    "def eval_decorator(fn):\n",
-    "    def inner(model, *args, **kwargs):\n",
-    "        was_training = model.training\n",
-    "        model.eval()\n",
-    "        out = fn(model, *args, **kwargs)\n",
-    "        model.train(was_training)\n",
-    "        return out\n",
-    "\n",
-    "    return inner\n",
-    "\n",
-    "\n",
-    "# sampling helpers\n",
-    "\n",
-    "\n",
-    "def top_k(logits, thres=0.5):\n",
-    "    num_logits = logits.shape[-1]\n",
-    "    k = max(int((1 - thres) * num_logits), 1)\n",
-    "    val, ind = torch.topk(logits, k)\n",
-    "    probs = torch.full_like(logits, float(\"-inf\"))\n",
-    "    probs.scatter_(1, ind, val)\n",
-    "    return probs\n",
-    "\n",
-    "\n",
-    "# discrete vae class\n",
-    "\n",
-    "\n",
-    "class ResBlock(nn.Module):\n",
-    "    def __init__(self, chan):\n",
-    "        super().__init__()\n",
-    "        self.net = nn.Sequential(\n",
-    "            nn.Conv2d(chan, chan, 3, padding=1),\n",
-    "            nn.ReLU(),\n",
-    "            nn.Conv2d(chan, chan, 3, padding=1),\n",
-    "            nn.ReLU(),\n",
-    "            nn.Conv2d(chan, chan, 1),\n",
-    "        )\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        return self.net(x) + x\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class DALLE_Klue_Roberta(nn.Module):\n",
-    "    def __init__(\n",
-    "        self,\n",
-    "        *,\n",
-    "        # dim,\n",
-    "        vae,\n",
-    "        num_text_tokens=10000,\n",
-    "        text_seq_len=256,\n",
-    "        depth,\n",
-    "        heads=8,\n",
-    "        dim_head=64,\n",
-    "        reversible=False,\n",
-    "        attn_dropout=0.0,\n",
-    "        ff_dropout=0,\n",
-    "        sparse_attn=False,\n",
-    "        attn_types=None,\n",
-    "        loss_img_weight=7,\n",
-    "        stable=False,\n",
-    "        sandwich_norm=False,\n",
-    "        shift_tokens=True,\n",
-    "        rotary_emb=False,\n",
-    "        wte_dir=None,\n",
-    "        wpe_dir=None,\n",
-    "    ):\n",
-    "        super().__init__()\n",
-    "        assert isinstance(\n",
-    "            vae, (DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE)\n",
-    "        ), \"vae must be an instance of DiscreteVAE\"\n",
-    "        image_size = vae.image_size\n",
-    "        num_image_tokens = vae.num_tokens\n",
-    "        image_fmap_size = vae.image_size // (2 ** vae.num_layers)\n",
-    "        image_seq_len = image_fmap_size ** 2\n",
-    "\n",
-    "        num_text_tokens = (\n",
-    "            num_text_tokens + text_seq_len\n",
-    "        )  # reserve unique padding tokens for each position (text seq len)\n",
-    "\n",
-    "        self.text_emb = torch.load(wte_dir)\n",
-    "        dim = self.text_emb.weight.shape[1]\n",
-    "        self.image_emb = nn.Embedding(num_image_tokens, dim)\n",
-    "        print(dim,image_fmap_size,image_fmap_size)\n",
-    "        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>\n",
-    "        self.image_pos_emb = (\n",
-    "            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))\n",
-    "            if not rotary_emb\n",
-    "            else always(0)\n",
-    "        )\n",
-    "\n",
-    "        self.num_text_tokens = (\n",
-    "            num_text_tokens  # for offsetting logits index and calculating cross entropy loss\n",
-    "        )\n",
-    "        self.num_image_tokens = num_image_tokens\n",
-    "\n",
-    "        self.text_seq_len = text_seq_len\n",
-    "        self.image_seq_len = image_seq_len\n",
-    "\n",
-    "        seq_len = text_seq_len + image_seq_len\n",
-    "        total_tokens = num_text_tokens + num_image_tokens\n",
-    "        self.total_tokens = total_tokens\n",
-    "        self.total_seq_len = seq_len\n",
-    "\n",
-    "        self.vae = vae\n",
-    "        set_requires_grad(self.vae, False)  # freeze VAE from being trained\n",
-    "\n",
-    "        self.transformer = Transformer(\n",
-    "            dim=dim,\n",
-    "            causal=True,\n",
-    "            seq_len=seq_len,\n",
-    "            depth=depth,\n",
-    "            heads=heads,\n",
-    "            dim_head=dim_head,\n",
-    "            reversible=reversible,\n",
-    "            attn_dropout=attn_dropout,\n",
-    "            ff_dropout=ff_dropout,\n",
-    "            attn_types=attn_types,\n",
-    "            image_fmap_size=image_fmap_size,\n",
-    "            sparse_attn=sparse_attn,\n",
-    "            stable=stable,\n",
-    "            sandwich_norm=sandwich_norm,\n",
-    "            shift_tokens=shift_tokens,\n",
-    "            rotary_emb=rotary_emb,\n",
-    "        )\n",
-    "\n",
-    "        self.stable = stable\n",
-    "\n",
-    "        if stable:\n",
-    "            self.norm_by_max = DivideMax(dim=-1)\n",
-    "\n",
-    "        self.to_logits = nn.Sequential(\n",
-    "            nn.LayerNorm(dim),\n",
-    "            nn.Linear(dim, self.total_tokens),\n",
-    "        )\n",
-    "\n",
-    "        seq_range = torch.arange(seq_len)\n",
-    "        logits_range = torch.arange(total_tokens)\n",
-    "\n",
-    "        seq_range = rearrange(seq_range, \"n -> () n ()\")\n",
-    "        logits_range = rearrange(logits_range, \"d -> () () d\")\n",
-    "\n",
-    "        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (\n",
-    "            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)\n",
-    "        )\n",
-    "\n",
-    "        self.register_buffer(\"logits_mask\", logits_mask, persistent=False)\n",
-    "        self.loss_img_weight = loss_img_weight\n",
-    "\n",
-    "    @torch.no_grad()\n",
-    "    @eval_decorator\n",
-    "    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):\n",
-    "        text_seq_len = self.text_seq_len\n",
-    "        if text is None or text == \"\":\n",
-    "            text_tokens = torch.tensor([[0]]).cuda()\n",
-    "        else:\n",
-    "            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)\n",
-    "\n",
-    "        for _ in range(text_tokens.shape[1], text_seq_len):\n",
-    "            device = text_tokens.device\n",
-    "\n",
-    "            tokens = self.text_emb(text_tokens)\n",
-    "            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))\n",
-    "\n",
-    "            seq_len = tokens.shape[1]\n",
-    "\n",
-    "            output_transf = self.transformer(tokens)\n",
-    "\n",
-    "            if self.stable:\n",
-    "                output_transf = self.norm_by_max(output_transf)\n",
-    "\n",
-    "            logits = self.to_logits(output_transf)\n",
-    "\n",
-    "            # mask logits to make sure text predicts text (except last token), and image predicts image\n",
-    "\n",
-    "            logits_mask = self.logits_mask[:, :seq_len]\n",
-    "            max_neg_value = -torch.finfo(logits.dtype).max\n",
-    "            logits.masked_fill_(logits_mask, max_neg_value)\n",
-    "            logits = logits[:, -1, :]\n",
-    "\n",
-    "            filtered_logits = top_k(logits, thres=filter_thres)\n",
-    "            probs = stable_softmax(filtered_logits / temperature, dim=-1)\n",
-    "            sample = torch.multinomial(probs, 1)\n",
-    "\n",
-    "            text_tokens = torch.cat((text_tokens, sample), dim=-1)\n",
-    "\n",
-    "        padding_tokens = set(\n",
-    "            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)\n",
-    "        )\n",
-    "        texts = [\n",
-    "            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)\n",
-    "            for text_token in text_tokens\n",
-    "        ]\n",
-    "        return text_tokens, texts\n",
-    "\n",
-    "    @torch.no_grad()\n",
-    "    @eval_decorator\n",
-    "    def generate_images(\n",
-    "        self,\n",
-    "        text,\n",
-    "        *,\n",
-    "        clip=None,\n",
-    "        mask=None,\n",
-    "        filter_thres=0.5,\n",
-    "        temperature=1.0,\n",
-    "        img=None,\n",
-    "        num_init_img_tokens=None,\n",
-    "    ):\n",
-    "        vae, text_seq_len, image_seq_len, num_text_tokens = (\n",
-    "            self.vae,\n",
-    "            self.text_seq_len,\n",
-    "            self.image_seq_len,\n",
-    "            self.num_text_tokens,\n",
-    "        )\n",
-    "        total_len = text_seq_len + image_seq_len\n",
-    "\n",
-    "        text = text[:, :text_seq_len]  # make sure text is within bounds\n",
-    "        out = text\n",
-    "\n",
-    "        if exists(img):\n",
-    "            image_size = vae.image_size\n",
-    "            assert (\n",
-    "                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size\n",
-    "            ), f\"input image must have the correct image size {image_size}\"\n",
-    "\n",
-    "            indices = vae.get_codebook_indices(img)\n",
-    "            num_img_tokens = default(\n",
-    "                num_init_img_tokens, int(0.4375 * image_seq_len)\n",
-    "            )  # OpenAI used 14 * 32 initial tokens to prime\n",
-    "            assert (\n",
-    "                num_img_tokens < image_seq_len\n",
-    "            ), \"number of initial image tokens for priming must be less than the total image token sequence length\"\n",
-    "\n",
-    "            indices = indices[:, :num_img_tokens]\n",
-    "            out = torch.cat((out, indices), dim=-1)\n",
-    "\n",
-    "        for cur_len in range(out.shape[1], total_len):\n",
-    "            is_image = cur_len >= text_seq_len\n",
-    "\n",
-    "            text, image = out[:, :text_seq_len], out[:, text_seq_len:]\n",
-    "\n",
-    "            logits = self(text, image, mask=mask)[:, -1, :]\n",
-    "\n",
-    "            filtered_logits = top_k(logits, thres=filter_thres)\n",
-    "            probs = F.softmax(filtered_logits / temperature, dim=-1)\n",
-    "            sample = torch.multinomial(probs, 1)\n",
-    "\n",
-    "            sample -= (\n",
-    "                num_text_tokens if is_image else 0\n",
-    "            )  # offset sampled token if it is an image token, since logit space is composed of text and then image tokens\n",
-    "            out = torch.cat((out, sample), dim=-1)\n",
-    "\n",
-    "            if out.shape[1] <= text_seq_len:\n",
-    "                mask = F.pad(mask, (0, 1), value=True)\n",
-    "\n",
-    "        text_seq = out[:, :text_seq_len]\n",
-    "\n",
-    "        img_seq = out[:, -image_seq_len:]\n",
-    "        images = vae.decode(img_seq)\n",
-    "\n",
-    "        if exists(clip):\n",
-    "            scores = clip(text_seq, images, return_loss=False)\n",
-    "            return images, scores\n",
-    "\n",
-    "        return images\n",
-    "\n",
-    "    def forward(self, text, image=None, mask=None, return_loss=False):\n",
-    "        assert (\n",
-    "            text.shape[-1] == self.text_seq_len\n",
-    "        ), f\"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})\"\n",
-    "        device, total_seq_len = text.device, self.total_seq_len\n",
-    "\n",
-    "        # make sure padding in text tokens get unique padding token id\n",
-    "\n",
-    "        #text_range = torch.arange(self.text_seq_len, device=device) + (\n",
-    "        #    self.num_text_tokens - self.text_seq_len\n",
-    "        #)\n",
-    "        #print(torch.max(text))\n",
-    "        #print(text)\n",
-    "        #torch.save(text,'text.pt')\n",
-    "        #text = torch.where(text == 3, text_range, text)\n",
-    "\n",
-    "        # add <bos>\n",
-    "        #print(text.shape)\n",
-    "        #print(text)\n",
-    "        #print(torch.max(text))\n",
-    "        text = F.pad(text, (1, 0), value=0)\n",
-    "        #print(text.shape)\n",
-    "        #print(text)\n",
-    "        #print(torch.max(text))\n",
-    "        tokens = self.text_emb(text)\n",
-    "        tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))\n",
-    "\n",
-    "        seq_len = tokens.shape[1]\n",
-    "\n",
-    "        if exists(image) and not is_empty(image):\n",
-    "            is_raw_image = len(image.shape) == 4\n",
-    "\n",
-    "            if is_raw_image:\n",
-    "                image_size = self.vae.image_size\n",
-    "                assert tuple(image.shape[1:]) == (\n",
-    "                    3,\n",
-    "                    image_size,\n",
-    "                    image_size,\n",
-    "                ), f\"invalid image of dimensions {image.shape} passed in during training\"\n",
-    "\n",
-    "                image = self.vae.get_codebook_indices(image)\n",
-    "            image_len = image.shape[1]\n",
-    "            image_emb = self.image_emb(image)\n",
-    "            image_emb += self.image_pos_emb(image_emb)\n",
-    "\n",
-    "            tokens = torch.cat((tokens, image_emb), dim=1)\n",
-    "\n",
-    "            seq_len += image_len\n",
-    "\n",
-    "        # when training, if the length exceeds the total text + image length\n",
-    "        # remove the last token, since it needs not to be trained\n",
-    "\n",
-    "        if tokens.shape[1] > total_seq_len:\n",
-    "            seq_len -= 1\n",
-    "            tokens = tokens[:, :-1]\n",
-    "\n",
-    "        if self.stable:\n",
-    "            alpha = 0.1\n",
-    "            tokens = tokens * alpha + tokens.detach() * (1 - alpha)\n",
-    "\n",
-    "        out = self.transformer(tokens)\n",
-    "\n",
-    "        if self.stable:\n",
-    "            out = self.norm_by_max(out)\n",
-    "\n",
-    "        logits = self.to_logits(out)\n",
-    "\n",
-    "        # mask logits to make sure text predicts text (except last token), and image predicts image\n",
-    "\n",
-    "        logits_mask = self.logits_mask[:, :seq_len]\n",
-    "        max_neg_value = -torch.finfo(logits.dtype).max\n",
-    "        logits.masked_fill_(logits_mask, max_neg_value)\n",
-    "\n",
-    "        if not return_loss:\n",
-    "            return logits\n",
-    "\n",
-    "        assert exists(image), \"when training, image must be supplied\"\n",
-    "\n",
-    "        offsetted_image = image + self.num_text_tokens\n",
-    "        labels = torch.cat((text[:, 1:], offsetted_image), dim=1)\n",
-    "\n",
-    "        logits = rearrange(logits, \"b n c -> b c n\")\n",
-    "\n",
-    "        loss_text = F.cross_entropy(\n",
-    "            logits[:, :, : self.text_seq_len], labels[:, : self.text_seq_len]\n",
-    "        )\n",
-    "        loss_img = F.cross_entropy(\n",
-    "            logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]\n",
-    "        )\n",
-    "\n",
-    "        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)\n",
-    "        return loss\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1024 16 16\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "torch.Size([1, 3, 256, 256])"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n",
-    "dalle = DALLE_Klue_Roberta(\n",
-    "    vae = vae, \n",
-    "    wte_dir=\"./models/text_encoders/roberta_large_wte.pt\",\n",
-    "    wpe_dir=\"./models/text_encoders/roberta_large_wpe.pt\",\n",
-    "    **dalle_params\n",
-    "    )\n",
-    "\n",
-    "dalle.load_state_dict(weights)\n",
-    "\n",
-    "# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n",
-    "images = dalle.generate_images(input_ids, mask = attention_mask)\n",
-    "images.shape # (4, 3, 256, 256)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "하의에서 기장은 니렝스이다. 하의에서 색상은 화이트이다. 하의에서 카테고리는 팬츠이다. 하의에서 소재에는 우븐이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 서브색상은 레드이다. 상의에서 카테고리는 블라우스이다. 상의에서 소매기장은 반팔이다. 상의에서 소재에는 시폰이다.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=256x256 at 0x140412E80>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "from torchvision.utils import make_grid, save_image\n",
-    "from PIL import Image\n",
-    "\n",
-    "# https://github.com/lucidrains/DALLE-pytorch/blob/e1d10b9163ce78bacb5d8b42126255a0a8cdea35/generate.py#L93-L130\n",
-    "grid = make_grid(images, nrow=1, padding=0, pad_value=0)\n",
-    "ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n",
-    "im = Image.fromarray(ndarr)\n",
-    "\n",
-    "print(input_text)\n",
-    "display(im)"
-   ]
-  }
- ],
- "metadata": {
-  "interpreter": {
-   "hash": "546ac3bc9ff8ae035b2d532deb5ff1f925751c91c859447d340e61cadcd4cd28"
-  },
-  "kernelspec": {
-   "display_name": "Python 3.8.5 64-bit ('taming': conda)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.3"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{"cells":[{"cell_type":"code","source":["# install torch fidelity for FID, ISC score \n","# https://github.com/toshas/torch-fidelity\n","# https://torch-fidelity.readthedocs.io/en/latest/precision.html"],"metadata":{"id":"kH3FIMbaeurU","executionInfo":{"status":"ok","timestamp":1640501127635,"user_tz":-540,"elapsed":13,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":1,"outputs":[]},{"cell_type":"code","source":["!nvidia-smi"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"SaxqLs7gCaEU","executionInfo":{"status":"ok","timestamp":1640501127636,"user_tz":-540,"elapsed":13,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"3d0df665-6575-42cc-bd36-5ca290fa7847"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["Sun Dec 26 06:45:26 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}]},{"cell_type":"code","source":["!pip install dalle-pytorch --upgrade"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"HZWvvcctdl0L","executionInfo":{"status":"ok","timestamp":1640501131760,"user_tz":-540,"elapsed":4130,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"6291e994-9a23-43ae-b378-5853495a9c48"},"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["Requirement already satisfied: dalle-pytorch in /usr/local/lib/python3.7/dist-packages (1.1.6)\n","Requirement already satisfied: youtokentome in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.0.6)\n","Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.10.0+cu111)\n","Requirement already satisfied: rotary-embedding-torch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.2)\n","Requirement already satisfied: DALL-E in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1)\n","Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (6.0.3)\n","Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.11.1+cu111)\n","Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (2019.12.20)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (7.1.2)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.62.3)\n","Requirement already satisfied: axial-positional-embedding in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.2.1)\n","Requirement already satisfied: WebDataset in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.103)\n","Requirement already satisfied: einops>=0.3.2 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.3.2)\n","Requirement already satisfied: taming-transformers-rom1504 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.0.6)\n","Requirement already satisfied: tokenizers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.10.3)\n","Requirement already satisfied: g-mlp-pytorch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.5)\n","Requirement already satisfied: transformers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.15.0)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.6->dalle-pytorch) (3.10.0.2)\n","Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (3.6.4)\n","Requirement already satisfied: blobfile in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.2.7)\n","Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (2.23.0)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.19.5)\n","Requirement already satisfied: mypy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (0.930)\n","Requirement already satisfied: xmltodict~=0.12.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: filelock~=3.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.4.0)\n","Requirement already satisfied: urllib3~=1.25 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (1.25.11)\n","Requirement already satisfied: pycryptodomex~=3.8 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.12.0)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->dalle-pytorch) (0.2.5)\n","Requirement already satisfied: typed-ast<2,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.5.1)\n","Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.2.2)\n","Requirement already satisfied: mypy-extensions>=0.4.3 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (0.4.3)\n","Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (21.2.0)\n","Requirement already satisfied: py>=1.5.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.11.0)\n","Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.15.0)\n","Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (8.12.0)\n","Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (0.7.1)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (57.4.0)\n","Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.4.0)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2.10)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (3.0.4)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2021.10.8)\n","Requirement already satisfied: pytorch-lightning>=1.0.8 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (1.5.7)\n","Requirement already satisfied: omegaconf>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (2.1.1)\n","Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (6.0)\n","Requirement already satisfied: antlr4-python3-runtime==4.8 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: torchmetrics>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.2)\n","Requirement already satisfied: fsspec[http]!=2021.06.0,>=2021.05.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2021.11.1)\n","Requirement already satisfied: future>=0.17.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.18.2)\n","Requirement already satisfied: tensorboard>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.7.0)\n","Requirement already satisfied: pyDeprecate==0.3.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.3.1)\n","Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (21.3)\n","Requirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.8.1)\n","Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=17.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.0.6)\n","Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.17.3)\n","Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.8.0)\n","Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.1)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.35.0)\n","Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.37.0)\n","Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.0.1)\n","Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.42.0)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.6)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.3.6)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.2.4)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.3.0)\n","Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8.2)\n","Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.6.0)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.8)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.1.1)\n","Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (5.2.0)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.7.2)\n","Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.0.2)\n","Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.0.8)\n","Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.13.0)\n","Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.2.1)\n","Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.0.46)\n","Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (7.1.2)\n","Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (1.1.0)\n","Requirement already satisfied: braceexpand in /usr/local/lib/python3.7/dist-packages (from WebDataset->dalle-pytorch) (0.1.7)\n"]}]},{"cell_type":"markdown","source":["### Restart runtime from here"],"metadata":{"id":"MUGz_NZE_qCV"}},{"cell_type":"code","source":["from google.colab import drive\n","drive.mount('/content/drive')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kpnzNia6eQjO","executionInfo":{"status":"ok","timestamp":1640501154315,"user_tz":-540,"elapsed":22561,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"7ea129c7-7bd2-4cea-840b-15a1f6535f26"},"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}]},{"cell_type":"code","execution_count":5,"metadata":{"id":"FsftdmCPETVT","executionInfo":{"status":"ok","timestamp":1640501159438,"user_tz":-540,"elapsed":5133,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["import torch\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","%config InlineBackend.figure_format = 'retina'"]},{"cell_type":"markdown","metadata":{"id":"vy19ZEl9ETVW"},"source":[""]},{"cell_type":"code","execution_count":6,"metadata":{"id":"6XbxsJr9ETVY","outputId":"78a39e9b-a28b-4c2d-866d-841792cef975","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501159439,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Random Seed:  999\n"]},{"output_type":"execute_result","data":{"text/plain":["<torch._C.Generator at 0x7f6fa0868b10>"]},"metadata":{},"execution_count":6}],"source":["from __future__ import print_function\n","import random\n","import torch.nn.parallel\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","# https://stackoverflow.com/questions/12984426/pil-ioerror-image-file-truncated-with-big-images\n","# ImageFile.LOAD_TRUNCATED_IMAGES = True\n","\n","# Set random seed for reproducibility\n","manualSeed = 999\n","#manualSeed = random.randint(1, 10000) # use if you want new results\n","print(\"Random Seed: \", manualSeed)\n","random.seed(manualSeed)\n","torch.manual_seed(manualSeed)"]},{"cell_type":"code","execution_count":7,"metadata":{"id":"HRY3CzvqETVZ","executionInfo":{"status":"ok","timestamp":1640501159439,"user_tz":-540,"elapsed":5,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from easydict import EasyDict\n","\n","# constants\n","\n","VAE_CFG = EasyDict()\n","\n","VAE_CFG.IMAGE_SIZE = 256\n","VAE_CFG.IMAGE_PATH = './'\n","\n","VAE_CFG.BASELINE = False"]},{"cell_type":"code","execution_count":8,"metadata":{"id":"IvtOi_BfETVZ","executionInfo":{"status":"ok","timestamp":1640501160387,"user_tz":-540,"elapsed":952,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from random import choice\n","from pathlib import Path\n","\n","# torch\n","\n","import torch\n","from torch.optim import Adam\n","from torch.nn.utils import clip_grad_norm_\n","\n","# vision imports\n","\n","from PIL import Image\n","from torchvision import transforms as T\n","from torch.utils.data import DataLoader, Dataset\n","from torchvision.datasets import ImageFolder\n","from torchvision.utils import make_grid, save_image\n","\n","# dalle related classes and utils\n","\n","from dalle_pytorch import OpenAIDiscreteVAE, DiscreteVAE, DALLE\n","\n","# helpers\n","\n","def exists(val):\n","    return val is not None"]},{"cell_type":"code","source":["import shutil\n","\n","vqgan_best_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue_e7\"\n","shutil.copy(vqgan_best_path, \"./\")\n","\n","vqgan_best_yaml_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue.yaml\"\n","shutil.copy(vqgan_best_yaml_path, \"./\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"id":"TubuiCYeeNbz","executionInfo":{"status":"ok","timestamp":1640501173523,"user_tz":-540,"elapsed":13139,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"4e5b5306-57ea-4342-ead4-48448bf96bbc"},"execution_count":9,"outputs":[{"output_type":"execute_result","data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./VQGAN_blue.yaml'"]},"metadata":{},"execution_count":9}]},{"cell_type":"code","source":["dalle_best_path = \"/content/drive/MyDrive/K-Fashion/DALLE Models/dalle_vq_blue_e7_final.pt\"\n","shutil.copy(dalle_best_path, \"./\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"id":"FuW7cjLdmVuV","executionInfo":{"status":"ok","timestamp":1640501267325,"user_tz":-540,"elapsed":93806,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"811d2f3f-6b91-492d-8cf3-22423e5a36e8"},"execution_count":10,"outputs":[{"output_type":"execute_result","data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./dalle_vq_blue_e7_final.pt'"]},"metadata":{},"execution_count":10}]},{"cell_type":"code","execution_count":11,"metadata":{"id":"hs5_QzNpETVa","executionInfo":{"status":"ok","timestamp":1640501267325,"user_tz":-540,"elapsed":8,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from easydict import EasyDict\n","import os\n","\n","DALLE_CFG = EasyDict()\n","\n","# argument parsing\n","\n","# DALLE_CFG.VQGAN_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/last_51485_step.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_PATH = os.path.basename(vqgan_best_path)\n","# DALLE_CFG.VQGAN_CFG_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/2021-12-15T16-24-36-project.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_CFG_PATH = os.path.basename(vqgan_best_yaml_path)\n","DALLE_CFG.DALLE_PATH = os.path.basename(dalle_best_path)   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n","DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n","DALLE_CFG.BPE_PATH = None\n","DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n","\n","# DALLE_CFG.EPOCHS = 20\n","# DALLE_CFG.BATCH_SIZE = 54\n","DALLE_CFG.LEARNING_RATE = 3e-4\n","DALLE_CFG.GRAD_CLIP_NORM = 0.5\n","\n","# DALLE_CFG.MODEL_DIM = 512\n","DALLE_CFG.TEXT_SEQ_LEN = 128\n","DALLE_CFG.DEPTH = 2\n","DALLE_CFG.HEADS = 8\n","DALLE_CFG.DIM_HEAD = 64\n","DALLE_CFG.REVERSIBLE = True"]},{"cell_type":"code","execution_count":12,"metadata":{"id":"URMpwTL5ETVb","outputId":"d81d234b-16ce-4982-ae64-6f0d1ba34ac1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501267326,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":12}],"source":["DALLE_CFG.RESUME"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"6aPRTq1GETVb","colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["b737a3077a5844039a6be0f7027b8529","789520acf8c6443c87eb3159ee5a94f1","a092a22fbef44f96a3818b46b07eb83b","bdb5685a0b414e65a82b1778930e3747","b5649869ea9f461a989a58b5aae78608","de92258c01bc4f21b78e1e74efff9063","71b99fb5f37743558d660aa4ac53e587","682c5233b6bc4c96a2e75bd0c5aeb02a","fce9b529a2c8491a96b1a82b8de634dc","83f744eab718483f9c9e604e67f365cd","056f5acf9bd34054868b95e06b35350e","cb36498cf7db4aa0b4f601f05d088a8f","b64b4eb7046f48cda8b98661ac77b3aa","355e86971e0f4f7aa134fe70bd3ac8b0","98af5a89118243d3b1dbd71fcab90395","4755a06ad8dc4f14aeb1363052a576d7","e92c525df9194f9b82d3c0607bfb3f97","a44149a8e39048acbd184036aeffd52b","e75ea3ec61524e9c9f9a12a449866aac","b46403218cf942d98715083a75dcad87","e31f637aaa114f3e9d4e8036a85a75a4","1b257065d0ef40eeb4f43c5a22ec91d2","cfef0fae7f0849ba93242651ce3d9dee","4e857c5654f3406fa4b49dfb45348a02","f33abf69f5924492a6f50b75b60cef4d","14ef623da96e443e8d985870052a59e9","39ff2b3eb62348fa8884d2f64d829dad","fa6f0f6b0bab4ab6afe48f52ccc0f218","bbca27254b1040e69ed0c824239fa250","f20fd195724b4d979e7e202e7e422ba6","d9fed9c7866849d585db5cc936b58d57","ea58905965844e06b6f9b8344cf1cb7b","4ea034953e6e4c9f8739a0d811513532","b3ccc40ffd8f48fe81957f480f6e6815","b1b9d3f604104dac97e57ff73489d32c","71039a160e29436b928f22c477db2e41","db1ff5fe3e3d4af58593c5573bbc6f75","9addf47d6953415da7dbabf730acfc16","7cbc74df100d439b82f3be2c0e2c3b54","be3d477b33484cbaab304ca97cf63378","cca1beb5ef98445e8db63224a8783011","cce09cfcc961488aacf95f26158480c0","cd346231832d4029b8cbccfd444fb805","4b603c2753094e05a024429d00ca4cf1"]},"executionInfo":{"status":"ok","timestamp":1640501279436,"user_tz":-540,"elapsed":12115,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"b9896041-3caf-4f3c-8c49-058e96394de2"},"outputs":[{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b737a3077a5844039a6be0f7027b8529","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/375 [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cb36498cf7db4aa0b4f601f05d088a8f","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/243k [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cfef0fae7f0849ba93242651ce3d9dee","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/734k [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b3ccc40ffd8f48fe81957f480f6e6815","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/173 [00:00<?, ?B/s]"]},"metadata":{}}],"source":["# import from huggingface transformers\n","from transformers import AutoTokenizer, AutoModelWithLMHead\n","\n","tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n","# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")"]},{"cell_type":"code","source":["!nvidia-smi"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"YZXRsVJ4BWeF","executionInfo":{"status":"ok","timestamp":1640501279437,"user_tz":-540,"elapsed":19,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"e3dac17e-17b5-47ce-e8fc-0111e7099cff"},"execution_count":14,"outputs":[{"output_type":"stream","name":"stdout","text":["Sun Dec 26 06:47:58 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}]},{"cell_type":"code","execution_count":15,"metadata":{"id":"a08tUVpeETVc","outputId":"830042b9-8796-4d50-83a1-5e20b5d5f338","colab":{"base_uri":"https://localhost:8080/","height":171,"referenced_widgets":["bfa7edd8caff48f7be2fe4ad34f62ac1","fa6e1babb7ea4a02b1379d1f293184bd","0f682f4dc3284534b6be9e10ea619d2b","eabb6eea5950458ab41116a1525acedc","d1f42d328f674043a71b4d7406843511","3a5ce6f768cf42359be9b1edef7fc272","0a3039e5606b4eceab025c42b99b79ed","008bfb9186864298993ef2303659d3ad","92046bf3cbe54ba5a3adad249c391129","fdecb696460a41d09ef2b92d195151a7","d6da336731144c97a9964d79edd69d5a"]},"executionInfo":{"status":"ok","timestamp":1640501338487,"user_tz":-540,"elapsed":59054,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n"]},{"output_type":"stream","name":"stderr","text":["Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"]},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"bfa7edd8caff48f7be2fe4ad34f62ac1","version_minor":0,"version_major":2},"text/plain":["  0%|          | 0.00/528M [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Downloading vgg_lpips model from https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1 to taming/modules/autoencoder/lpips/vgg.pth\n"]},{"output_type":"stream","name":"stderr","text":["8.19kB [00:00, 79.8kB/s]\n"]},{"output_type":"stream","name":"stdout","text":["loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n","VQLPIPSWithDiscriminator running with hinge loss.\n","Loaded VQGAN from VQGAN_blue_e7 and VQGAN_blue.yaml\n"]}],"source":["from dalle_pytorch import VQGanVAE\n","from pathlib import Path\n","\n","DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n","\n","dalle_path = Path(DALLE_CFG.DALLE_PATH)\n","assert dalle_path.exists(), 'DALL-E model file does not exist'\n","\n","loaded_obj = torch.load(str(dalle_path), map_location=torch.device('cuda:0'))\n","\n","dalle_params, vae_params, weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n","\n","vae_klass = VQGanVAE\n","vae = vae_klass(\n","    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n","    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n","    )\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size\n","\n","dalle_params = dict(        \n","    **dalle_params\n",")\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size"]},{"cell_type":"code","execution_count":16,"metadata":{"id":"dDIPEJORETVd","outputId":"750b7ca1-df18-4a95-9fff-b7ebb772ddad","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501338488,"user_tz":-540,"elapsed":9,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["{'attn_dropout': 0,\n"," 'attn_types': ('full',),\n"," 'depth': 16,\n"," 'dim_head': 64,\n"," 'ff_dropout': 0,\n"," 'heads': 8,\n"," 'loss_img_weight': 7,\n"," 'num_text_tokens': 32000,\n"," 'reversible': False,\n"," 'rotary_emb': False,\n"," 'shift_tokens': False,\n"," 'stable': False,\n"," 'text_seq_len': 128}"]},"metadata":{},"execution_count":16}],"source":["dalle_params"]},{"cell_type":"code","execution_count":17,"metadata":{"id":"FJhjwhNsETVd","executionInfo":{"status":"ok","timestamp":1640501338488,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from math import log2, sqrt\n","import torch\n","from torch import nn, einsum\n","import torch.nn.functional as F\n","import numpy as np\n","\n","from axial_positional_embedding import AxialPositionalEmbedding\n","from einops import rearrange\n","\n","from dalle_pytorch import distributed_utils\n","from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE\n","from dalle_pytorch.transformer import Transformer, DivideMax\n","from dalle_pytorch.attention import stable_softmax"]},{"cell_type":"code","execution_count":18,"metadata":{"id":"1zGbTpHEETVe","executionInfo":{"status":"ok","timestamp":1640501338489,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["def exists(val):\n","    return val is not None\n","\n","\n","def default(val, d):\n","    return val if exists(val) else d\n","\n","\n","class always:\n","    def __init__(self, val):\n","        self.val = val\n","\n","    def __call__(self, x, *args, **kwargs):\n","        return self.val\n","\n","\n","def is_empty(t):\n","    return t.nelement() == 0\n","\n","\n","def masked_mean(t, mask, dim=1):\n","    t = t.masked_fill(~mask[:, :, None], 0.0)\n","    return t.sum(dim=1) / mask.sum(dim=1)[..., None]\n","\n","\n","def set_requires_grad(model, value):\n","    for param in model.parameters():\n","        param.requires_grad = value\n","\n","\n","def eval_decorator(fn):\n","    def inner(model, *args, **kwargs):\n","        was_training = model.training\n","        model.eval()\n","        out = fn(model, *args, **kwargs)\n","        model.train(was_training)\n","        return out\n","\n","    return inner\n","\n","\n","# sampling helpers\n","\n","\n","def top_k(logits, thres=0.5):\n","    num_logits = logits.shape[-1]\n","    k = max(int((1 - thres) * num_logits), 1)\n","    val, ind = torch.topk(logits, k)\n","    probs = torch.full_like(logits, float(\"-inf\"))\n","    probs.scatter_(1, ind, val)\n","    return probs\n","\n","\n","# discrete vae class\n","\n","\n","class ResBlock(nn.Module):\n","    def __init__(self, chan):\n","        super().__init__()\n","        self.net = nn.Sequential(\n","            nn.Conv2d(chan, chan, 3, padding=1),\n","            nn.ReLU(),\n","            nn.Conv2d(chan, chan, 3, padding=1),\n","            nn.ReLU(),\n","            nn.Conv2d(chan, chan, 1),\n","        )\n","\n","    def forward(self, x):\n","        return self.net(x) + x\n","\n"]},{"cell_type":"code","execution_count":19,"metadata":{"id":"DQ9_4vpxETVe","executionInfo":{"status":"ok","timestamp":1640501339003,"user_tz":-540,"elapsed":521,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["class DALLE_Klue_Roberta(nn.Module):\n","    def __init__(\n","        self,\n","        *,\n","        # dim,\n","        vae,\n","        num_text_tokens=10000,\n","        text_seq_len=256,\n","        depth,\n","        heads=8,\n","        dim_head=64,\n","        reversible=False,\n","        attn_dropout=0.0,\n","        ff_dropout=0,\n","        sparse_attn=False,\n","        attn_types=None,\n","        loss_img_weight=7,\n","        stable=False,\n","        sandwich_norm=False,\n","        shift_tokens=True,\n","        rotary_emb=False,\n","        wte_dir=None,\n","        wpe_dir=None,\n","    ):\n","        super().__init__()\n","        assert isinstance(\n","            vae, (DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE)\n","        ), \"vae must be an instance of DiscreteVAE\"\n","        image_size = vae.image_size\n","        num_image_tokens = vae.num_tokens\n","        image_fmap_size = vae.image_size // (2 ** vae.num_layers)\n","        image_seq_len = image_fmap_size ** 2\n","\n","        num_text_tokens = (\n","            num_text_tokens + text_seq_len\n","        )  # reserve unique padding tokens for each position (text seq len)\n","\n","        self.text_emb = torch.load(wte_dir)\n","        dim = self.text_emb.weight.shape[1]\n","        self.image_emb = nn.Embedding(num_image_tokens, dim)\n","        print(dim,image_fmap_size,image_fmap_size)\n","        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>\n","        self.image_pos_emb = (\n","            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))\n","            if not rotary_emb\n","            else always(0)\n","        )\n","\n","        self.num_text_tokens = (\n","            num_text_tokens  # for offsetting logits index and calculating cross entropy loss\n","        )\n","        self.num_image_tokens = num_image_tokens\n","\n","        self.text_seq_len = text_seq_len\n","        self.image_seq_len = image_seq_len\n","\n","        seq_len = text_seq_len + image_seq_len\n","        total_tokens = num_text_tokens + num_image_tokens\n","        self.total_tokens = total_tokens\n","        self.total_seq_len = seq_len\n","\n","        self.vae = vae\n","        set_requires_grad(self.vae, False)  # freeze VAE from being trained\n","\n","        self.transformer = Transformer(\n","            dim=dim,\n","            causal=True,\n","            seq_len=seq_len,\n","            depth=depth,\n","            heads=heads,\n","            dim_head=dim_head,\n","            reversible=reversible,\n","            attn_dropout=attn_dropout,\n","            ff_dropout=ff_dropout,\n","            attn_types=attn_types,\n","            image_fmap_size=image_fmap_size,\n","            sparse_attn=sparse_attn,\n","            stable=stable,\n","            sandwich_norm=sandwich_norm,\n","            shift_tokens=shift_tokens,\n","            rotary_emb=rotary_emb,\n","        )\n","\n","        self.stable = stable\n","\n","        if stable:\n","            self.norm_by_max = DivideMax(dim=-1)\n","\n","        self.to_logits = nn.Sequential(\n","            nn.LayerNorm(dim),\n","            nn.Linear(dim, self.total_tokens),\n","        )\n","\n","        seq_range = torch.arange(seq_len)\n","        logits_range = torch.arange(total_tokens)\n","\n","        seq_range = rearrange(seq_range, \"n -> () n ()\")\n","        logits_range = rearrange(logits_range, \"d -> () () d\")\n","\n","        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (\n","            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)\n","        )\n","\n","        self.register_buffer(\"logits_mask\", logits_mask, persistent=False)\n","        self.loss_img_weight = loss_img_weight\n","\n","    @torch.no_grad()\n","    @eval_decorator\n","    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):\n","        text_seq_len = self.text_seq_len\n","        if text is None or text == \"\":\n","            text_tokens = torch.tensor([[0]]).cuda()\n","        else:\n","            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)\n","\n","        for _ in range(text_tokens.shape[1], text_seq_len):\n","            device = text_tokens.device\n","\n","            tokens = self.text_emb(text_tokens)\n","            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))\n","\n","            seq_len = tokens.shape[1]\n","\n","            output_transf = self.transformer(tokens)\n","\n","            if self.stable:\n","                output_transf = self.norm_by_max(output_transf)\n","\n","            logits = self.to_logits(output_transf)\n","\n","            # mask logits to make sure text predicts text (except last token), and image predicts image\n","\n","            logits_mask = self.logits_mask[:, :seq_len]\n","            max_neg_value = -torch.finfo(logits.dtype).max\n","            logits.masked_fill_(logits_mask, max_neg_value)\n","            logits = logits[:, -1, :]\n","\n","            filtered_logits = top_k(logits, thres=filter_thres)\n","            probs = stable_softmax(filtered_logits / temperature, dim=-1)\n","            sample = torch.multinomial(probs, 1)\n","\n","            text_tokens = torch.cat((text_tokens, sample), dim=-1)\n","\n","        padding_tokens = set(\n","            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)\n","        )\n","        texts = [\n","            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)\n","            for text_token in text_tokens\n","        ]\n","        return text_tokens, texts\n","\n","    @torch.no_grad()\n","    @eval_decorator\n","    def generate_images(\n","        self,\n","        text,\n","        *,\n","        clip=None,\n","        mask=None,\n","        filter_thres=0.5,\n","        temperature=1.0,\n","        img=None,\n","        num_init_img_tokens=None,\n","    ):\n","        vae, text_seq_len, image_seq_len, num_text_tokens = (\n","            self.vae,\n","            self.text_seq_len,\n","            self.image_seq_len,\n","            self.num_text_tokens,\n","        )\n","        total_len = text_seq_len + image_seq_len\n","\n","        text = text[:, :text_seq_len]  # make sure text is within bounds\n","        out = text\n","\n","        if exists(img):\n","            image_size = vae.image_size\n","            assert (\n","                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size\n","            ), f\"input image must have the correct image size {image_size}\"\n","\n","            indices = vae.get_codebook_indices(img)\n","            num_img_tokens = default(\n","                num_init_img_tokens, int(0.4375 * image_seq_len)\n","            )  # OpenAI used 14 * 32 initial tokens to prime\n","            assert (\n","                num_img_tokens < image_seq_len\n","            ), \"number of initial image tokens for priming must be less than the total image token sequence length\"\n","\n","            indices = indices[:, :num_img_tokens]\n","            out = torch.cat((out, indices), dim=-1)\n","\n","        for cur_len in range(out.shape[1], total_len):\n","            is_image = cur_len >= text_seq_len\n","\n","            text, image = out[:, :text_seq_len], out[:, text_seq_len:]\n","\n","            logits = self(text, image, mask=mask)[:, -1, :]\n","\n","            filtered_logits = top_k(logits, thres=filter_thres)\n","            probs = F.softmax(filtered_logits / temperature, dim=-1)\n","            sample = torch.multinomial(probs, 1)\n","\n","            sample -= (\n","                num_text_tokens if is_image else 0\n","            )  # offset sampled token if it is an image token, since logit space is composed of text and then image tokens\n","            out = torch.cat((out, sample), dim=-1)\n","\n","            if out.shape[1] <= text_seq_len:\n","                mask = F.pad(mask, (0, 1), value=True)\n","\n","        text_seq = out[:, :text_seq_len]\n","\n","        img_seq = out[:, -image_seq_len:]\n","        images = vae.decode(img_seq)\n","\n","        if exists(clip):\n","            scores = clip(text_seq, images, return_loss=False)\n","            return images, scores\n","\n","        return images\n","\n","    def forward(self, text, image=None, mask=None, return_loss=False):\n","        assert (\n","            text.shape[-1] == self.text_seq_len\n","        ), f\"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})\"\n","        device, total_seq_len = text.device, self.total_seq_len\n","\n","        # make sure padding in text tokens get unique padding token id\n","\n","        #text_range = torch.arange(self.text_seq_len, device=device) + (\n","        #    self.num_text_tokens - self.text_seq_len\n","        #)\n","        #print(torch.max(text))\n","        #print(text)\n","        #torch.save(text,'text.pt')\n","        #text = torch.where(text == 3, text_range, text)\n","\n","        # add <bos>\n","        #print(text.shape)\n","        #print(text)\n","        #print(torch.max(text))\n","        text = F.pad(text, (1, 0), value=0)\n","        #print(text.shape)\n","        #print(text)\n","        #print(torch.max(text))\n","        tokens = self.text_emb(text)\n","        tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))\n","\n","        seq_len = tokens.shape[1]\n","\n","        if exists(image) and not is_empty(image):\n","            is_raw_image = len(image.shape) == 4\n","\n","            if is_raw_image:\n","                image_size = self.vae.image_size\n","                assert tuple(image.shape[1:]) == (\n","                    3,\n","                    image_size,\n","                    image_size,\n","                ), f\"invalid image of dimensions {image.shape} passed in during training\"\n","\n","                image = self.vae.get_codebook_indices(image)\n","            image_len = image.shape[1]\n","            image_emb = self.image_emb(image)\n","            image_emb += self.image_pos_emb(image_emb)\n","\n","            tokens = torch.cat((tokens, image_emb), dim=1)\n","\n","            seq_len += image_len\n","\n","        # when training, if the length exceeds the total text + image length\n","        # remove the last token, since it needs not to be trained\n","\n","        if tokens.shape[1] > total_seq_len:\n","            seq_len -= 1\n","            tokens = tokens[:, :-1]\n","\n","        if self.stable:\n","            alpha = 0.1\n","            tokens = tokens * alpha + tokens.detach() * (1 - alpha)\n","\n","        out = self.transformer(tokens)\n","\n","        if self.stable:\n","            out = self.norm_by_max(out)\n","\n","        logits = self.to_logits(out)\n","\n","        # mask logits to make sure text predicts text (except last token), and image predicts image\n","\n","        logits_mask = self.logits_mask[:, :seq_len]\n","        max_neg_value = -torch.finfo(logits.dtype).max\n","        logits.masked_fill_(logits_mask, max_neg_value)\n","\n","        if not return_loss:\n","            return logits\n","\n","        assert exists(image), \"when training, image must be supplied\"\n","\n","        offsetted_image = image + self.num_text_tokens\n","        labels = torch.cat((text[:, 1:], offsetted_image), dim=1)\n","\n","        logits = rearrange(logits, \"b n c -> b c n\")\n","\n","        loss_text = F.cross_entropy(\n","            logits[:, :, : self.text_seq_len], labels[:, : self.text_seq_len]\n","        )\n","        loss_img = F.cross_entropy(\n","            logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]\n","        )\n","\n","        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)\n","        return loss\n"]},{"cell_type":"code","source":["import shutil\n","\n","roberta_wte = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wte.pt\"\n","shutil.copy(roberta_wte, \"./\")\n","\n","roberta_wpe = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wpe.pt\"\n","shutil.copy(roberta_wpe, \"./\")\n","\n","ROBERTA_WTE_PATH = os.path.basename(roberta_wte)\n","ROBERTA_WPE_PATH = os.path.basename(roberta_wpe)"],"metadata":{"id":"6LfuuBVcBGfq","executionInfo":{"status":"ok","timestamp":1640501344480,"user_tz":-540,"elapsed":5478,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":20,"outputs":[]},{"cell_type":"code","source":["from google.colab import drive\n","drive.flush_and_unmount()"],"metadata":{"id":"kCdxwf1jrdZd","executionInfo":{"status":"ok","timestamp":1640501347773,"user_tz":-540,"elapsed":3297,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":21,"outputs":[]},{"cell_type":"code","execution_count":22,"metadata":{"id":"yjbIh82bETVg","outputId":"960190b5-8a0a-42b9-f274-1e85b98972b3","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501353503,"user_tz":-540,"elapsed":5733,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["1024 16 16\n"]},{"output_type":"execute_result","data":{"text/plain":["<All keys matched successfully>"]},"metadata":{},"execution_count":22}],"source":["device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n","dalle = DALLE_Klue_Roberta(\n","    vae = vae, \n","    wte_dir=\"./roberta_large_wte.pt\",\n","    wpe_dir=\"./roberta_large_wpe.pt\",\n","    **dalle_params\n","    ).to(device)\n","\n","dalle.load_state_dict(weights)"]},{"cell_type":"code","execution_count":27,"metadata":{"id":"ylw54NgWETVi","outputId":"c33f64cf-7153-4a32-811f-d9bd7c17f31e","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501449158,"user_tz":-540,"elapsed":8757,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["CPU times: user 8.51 s, sys: 0 ns, total: 8.51 s\n","Wall time: 8.49 s\n"]}],"source":["%%time\n","input_text = \\\n","\"하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. \\\n","하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. \\\n","상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. \\\n","상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\"\n","\n","encoded_dict = tokenizer(\n","    input_text,\n","    return_tensors=\"pt\",\n","    padding=\"max_length\",\n","    truncation=True,\n","    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n","    add_special_tokens=True,\n","    return_token_type_ids=False,  # for RoBERTa\n",")\n","input_ids = encoded_dict[\"input_ids\"].to(device)\n","attention_mask = encoded_dict[\"attention_mask\"].to(device)\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n","# 12 minutes for K11\n","images = dalle.generate_images(input_ids, mask = attention_mask)\n","images.shape # (4, 3, 256, 256)"]},{"cell_type":"code","source":["input_ids"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Hvd5nC5vvZWR","executionInfo":{"status":"ok","timestamp":1640501363505,"user_tz":-540,"elapsed":29,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"f2036fd9-0aac-4f0a-ad4d-886125cf355d"},"execution_count":24,"outputs":[{"output_type":"execute_result","data":{"text/plain":["tensor([[    0, 19975, 27135,  8817,  2073, 11150, 28674,    18, 19975, 27135,\n","         14346,  2170,  2259, 24631,  2128, 28674,    18, 19975, 27135,  4642,\n","          2170,  2259, 13859, 28674,    18, 19975, 27135, 17107,  2170,  2259,\n","          8482, 28674,    18, 19975, 27135,  1887,  2073,   766,  2149, 28674,\n","            18, 10346, 27135, 10653,  2073,   766,  2149, 28674,    18, 10346,\n","         27135,  8817,  2073,  7482, 28674,    18, 10346, 27135, 29952,  2073,\n","         10727,  2600,  4893,  2062,    18, 10346, 27135, 14346,  2170,  2259,\n","          9742, 28674,    18, 10346, 27135,  8696,  2015,  2121,  2073,   646,\n","         31286,  2062,    18, 10346, 27135,  4642,  2170,  2259,  1469,  2862,\n","         28674,    18,     2,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1]],\n","       device='cuda:0')"]},"metadata":{},"execution_count":24}]},{"cell_type":"code","execution_count":28,"metadata":{"id":"7Qr2RZ8gETVi","outputId":"6fb9c672-bbd6-4801-e2e1-fbe70339d0e1","colab":{"base_uri":"https://localhost:8080/","height":345},"executionInfo":{"status":"ok","timestamp":1640501462251,"user_tz":-540,"elapsed":1160,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. 상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\n"]},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<PIL.Image.Image image mode=RGB size=256x256 at 0x7F6E48437A50>"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["CPU times: user 38.7 ms, sys: 0 ns, total: 38.7 ms\n","Wall time: 40.2 ms\n"]}],"source":["%%time\n","from torchvision.utils import make_grid, save_image\n","from PIL import Image\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/e1d10b9163ce78bacb5d8b42126255a0a8cdea35/generate.py#L93-L130\n","grid = make_grid(images, nrow=1, padding=0, pad_value=0)\n","ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n","im = Image.fromarray(ndarr)\n","\n","print(input_text)\n","display(im)"]},{"cell_type":"code","execution_count":26,"metadata":{"id":"53_I9cG7ETVj","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501363506,"user_tz":-540,"elapsed":14,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"e444fbe5-4274-488b-ab81-42dbac003667"},"outputs":[{"output_type":"stream","name":"stdout","text":["Sun Dec 26 06:49:22 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   39C    P0    39W / 250W |   9279MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","source":[""],"metadata":{"id":"eu5cjiEzwaVf","executionInfo":{"status":"ok","timestamp":1640501363507,"user_tz":-540,"elapsed":9,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":26,"outputs":[]}],"metadata":{"interpreter":{"hash":"546ac3bc9ff8ae035b2d532deb5ff1f925751c91c859447d340e61cadcd4cd28"},"kernelspec":{"display_name":"Python 3.8.5 64-bit ('taming': conda)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.3"},"orig_nbformat":4,"colab":{"name":"inference_blue.ipynb","provenance":[],"collapsed_sections":[]},"accelerator":"GPU","widgets":{"application/vnd.jupyter.widget-state+json":{"b737a3077a5844039a6be0f7027b8529":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_789520acf8c6443c87eb3159ee5a94f1","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_a092a22fbef44f96a3818b46b07eb83b","IPY_MODEL_bdb5685a0b414e65a82b1778930e3747","IPY_MODEL_b5649869ea9f461a989a58b5aae78608"]}},"789520acf8c6443c87eb3159ee5a94f1":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"a092a22fbef44f96a3818b46b07eb83b":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_de92258c01bc4f21b78e1e74efff9063","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_71b99fb5f37743558d660aa4ac53e587"}},"bdb5685a0b414e65a82b1778930e3747":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_682c5233b6bc4c96a2e75bd0c5aeb02a","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":375,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":375,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_fce9b529a2c8491a96b1a82b8de634dc"}},"b5649869ea9f461a989a58b5aae78608":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_83f744eab718483f9c9e604e67f365cd","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 375/375 [00:00&lt;00:00, 5.61kB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_056f5acf9bd34054868b95e06b35350e"}},"de92258c01bc4f21b78e1e74efff9063":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"71b99fb5f37743558d660aa4ac53e587":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"682c5233b6bc4c96a2e75bd0c5aeb02a":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"fce9b529a2c8491a96b1a82b8de634dc":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"83f744eab718483f9c9e604e67f365cd":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"056f5acf9bd34054868b95e06b35350e":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cb36498cf7db4aa0b4f601f05d088a8f":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_b64b4eb7046f48cda8b98661ac77b3aa","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_355e86971e0f4f7aa134fe70bd3ac8b0","IPY_MODEL_98af5a89118243d3b1dbd71fcab90395","IPY_MODEL_4755a06ad8dc4f14aeb1363052a576d7"]}},"b64b4eb7046f48cda8b98661ac77b3aa":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"355e86971e0f4f7aa134fe70bd3ac8b0":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_e92c525df9194f9b82d3c0607bfb3f97","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_a44149a8e39048acbd184036aeffd52b"}},"98af5a89118243d3b1dbd71fcab90395":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_e75ea3ec61524e9c9f9a12a449866aac","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":248477,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":248477,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_b46403218cf942d98715083a75dcad87"}},"4755a06ad8dc4f14aeb1363052a576d7":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_e31f637aaa114f3e9d4e8036a85a75a4","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 243k/243k [00:00&lt;00:00, 311kB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_1b257065d0ef40eeb4f43c5a22ec91d2"}},"e92c525df9194f9b82d3c0607bfb3f97":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"a44149a8e39048acbd184036aeffd52b":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"e75ea3ec61524e9c9f9a12a449866aac":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"b46403218cf942d98715083a75dcad87":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"e31f637aaa114f3e9d4e8036a85a75a4":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"1b257065d0ef40eeb4f43c5a22ec91d2":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cfef0fae7f0849ba93242651ce3d9dee":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_4e857c5654f3406fa4b49dfb45348a02","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_f33abf69f5924492a6f50b75b60cef4d","IPY_MODEL_14ef623da96e443e8d985870052a59e9","IPY_MODEL_39ff2b3eb62348fa8884d2f64d829dad"]}},"4e857c5654f3406fa4b49dfb45348a02":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"f33abf69f5924492a6f50b75b60cef4d":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_fa6f0f6b0bab4ab6afe48f52ccc0f218","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_bbca27254b1040e69ed0c824239fa250"}},"14ef623da96e443e8d985870052a59e9":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_f20fd195724b4d979e7e202e7e422ba6","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":751504,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":751504,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_d9fed9c7866849d585db5cc936b58d57"}},"39ff2b3eb62348fa8884d2f64d829dad":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_ea58905965844e06b6f9b8344cf1cb7b","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 734k/734k [00:01&lt;00:00, 1.06MB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_4ea034953e6e4c9f8739a0d811513532"}},"fa6f0f6b0bab4ab6afe48f52ccc0f218":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"bbca27254b1040e69ed0c824239fa250":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"f20fd195724b4d979e7e202e7e422ba6":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"d9fed9c7866849d585db5cc936b58d57":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"ea58905965844e06b6f9b8344cf1cb7b":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"4ea034953e6e4c9f8739a0d811513532":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"b3ccc40ffd8f48fe81957f480f6e6815":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_b1b9d3f604104dac97e57ff73489d32c","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_71039a160e29436b928f22c477db2e41","IPY_MODEL_db1ff5fe3e3d4af58593c5573bbc6f75","IPY_MODEL_9addf47d6953415da7dbabf730acfc16"]}},"b1b9d3f604104dac97e57ff73489d32c":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"71039a160e29436b928f22c477db2e41":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_7cbc74df100d439b82f3be2c0e2c3b54","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_be3d477b33484cbaab304ca97cf63378"}},"db1ff5fe3e3d4af58593c5573bbc6f75":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_cca1beb5ef98445e8db63224a8783011","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":173,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":173,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_cce09cfcc961488aacf95f26158480c0"}},"9addf47d6953415da7dbabf730acfc16":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_cd346231832d4029b8cbccfd444fb805","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 173/173 [00:00&lt;00:00, 4.96kB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_4b603c2753094e05a024429d00ca4cf1"}},"7cbc74df100d439b82f3be2c0e2c3b54":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"be3d477b33484cbaab304ca97cf63378":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cca1beb5ef98445e8db63224a8783011":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"cce09cfcc961488aacf95f26158480c0":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cd346231832d4029b8cbccfd444fb805":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"4b603c2753094e05a024429d00ca4cf1":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"bfa7edd8caff48f7be2fe4ad34f62ac1":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_fa6e1babb7ea4a02b1379d1f293184bd","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_0f682f4dc3284534b6be9e10ea619d2b","IPY_MODEL_eabb6eea5950458ab41116a1525acedc","IPY_MODEL_d1f42d328f674043a71b4d7406843511"]}},"fa6e1babb7ea4a02b1379d1f293184bd":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"0f682f4dc3284534b6be9e10ea619d2b":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_3a5ce6f768cf42359be9b1edef7fc272","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_0a3039e5606b4eceab025c42b99b79ed"}},"eabb6eea5950458ab41116a1525acedc":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_008bfb9186864298993ef2303659d3ad","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":553433881,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":553433881,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_92046bf3cbe54ba5a3adad249c391129"}},"d1f42d328f674043a71b4d7406843511":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_fdecb696460a41d09ef2b92d195151a7","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 528M/528M [00:10&lt;00:00, 191MB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_d6da336731144c97a9964d79edd69d5a"}},"3a5ce6f768cf42359be9b1edef7fc272":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"0a3039e5606b4eceab025c42b99b79ed":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"008bfb9186864298993ef2303659d3ad":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"92046bf3cbe54ba5a3adad249c391129":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"fdecb696460a41d09ef2b92d195151a7":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"d6da336731144c97a9964d79edd69d5a":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}}}}},"nbformat":4,"nbformat_minor":0}
\ No newline at end of file

From cee7f4c48ff9b224ebb97bce166aef4f8f3826d3 Mon Sep 17 00:00:00 2001
From: JoonHong-Kim <danielkim30433@gmail.com>
Date: Sun, 26 Dec 2021 19:08:00 +0900
Subject: [PATCH 24/26] delete) class block

---
 inference.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/inference.ipynb b/inference.ipynb
index 48a8d29..b79b15e 100644
--- a/inference.ipynb
+++ b/inference.ipynb
@@ -1 +1 @@
-{"cells":[{"cell_type":"code","source":["# install torch fidelity for FID, ISC score \n","# https://github.com/toshas/torch-fidelity\n","# https://torch-fidelity.readthedocs.io/en/latest/precision.html"],"metadata":{"id":"kH3FIMbaeurU","executionInfo":{"status":"ok","timestamp":1640501127635,"user_tz":-540,"elapsed":13,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":1,"outputs":[]},{"cell_type":"code","source":["!nvidia-smi"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"SaxqLs7gCaEU","executionInfo":{"status":"ok","timestamp":1640501127636,"user_tz":-540,"elapsed":13,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"3d0df665-6575-42cc-bd36-5ca290fa7847"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["Sun Dec 26 06:45:26 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}]},{"cell_type":"code","source":["!pip install dalle-pytorch --upgrade"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"HZWvvcctdl0L","executionInfo":{"status":"ok","timestamp":1640501131760,"user_tz":-540,"elapsed":4130,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"6291e994-9a23-43ae-b378-5853495a9c48"},"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["Requirement already satisfied: dalle-pytorch in /usr/local/lib/python3.7/dist-packages (1.1.6)\n","Requirement already satisfied: youtokentome in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.0.6)\n","Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.10.0+cu111)\n","Requirement already satisfied: rotary-embedding-torch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.2)\n","Requirement already satisfied: DALL-E in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1)\n","Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (6.0.3)\n","Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.11.1+cu111)\n","Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (2019.12.20)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (7.1.2)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.62.3)\n","Requirement already satisfied: axial-positional-embedding in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.2.1)\n","Requirement already satisfied: WebDataset in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.103)\n","Requirement already satisfied: einops>=0.3.2 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.3.2)\n","Requirement already satisfied: taming-transformers-rom1504 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.0.6)\n","Requirement already satisfied: tokenizers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.10.3)\n","Requirement already satisfied: g-mlp-pytorch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.5)\n","Requirement already satisfied: transformers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.15.0)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.6->dalle-pytorch) (3.10.0.2)\n","Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (3.6.4)\n","Requirement already satisfied: blobfile in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.2.7)\n","Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (2.23.0)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.19.5)\n","Requirement already satisfied: mypy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (0.930)\n","Requirement already satisfied: xmltodict~=0.12.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: filelock~=3.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.4.0)\n","Requirement already satisfied: urllib3~=1.25 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (1.25.11)\n","Requirement already satisfied: pycryptodomex~=3.8 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.12.0)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->dalle-pytorch) (0.2.5)\n","Requirement already satisfied: typed-ast<2,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.5.1)\n","Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.2.2)\n","Requirement already satisfied: mypy-extensions>=0.4.3 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (0.4.3)\n","Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (21.2.0)\n","Requirement already satisfied: py>=1.5.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.11.0)\n","Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.15.0)\n","Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (8.12.0)\n","Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (0.7.1)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (57.4.0)\n","Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.4.0)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2.10)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (3.0.4)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2021.10.8)\n","Requirement already satisfied: pytorch-lightning>=1.0.8 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (1.5.7)\n","Requirement already satisfied: omegaconf>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (2.1.1)\n","Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (6.0)\n","Requirement already satisfied: antlr4-python3-runtime==4.8 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: torchmetrics>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.2)\n","Requirement already satisfied: fsspec[http]!=2021.06.0,>=2021.05.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2021.11.1)\n","Requirement already satisfied: future>=0.17.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.18.2)\n","Requirement already satisfied: tensorboard>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.7.0)\n","Requirement already satisfied: pyDeprecate==0.3.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.3.1)\n","Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (21.3)\n","Requirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.8.1)\n","Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=17.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.0.6)\n","Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.17.3)\n","Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.8.0)\n","Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.1)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.35.0)\n","Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.37.0)\n","Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.0.1)\n","Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.42.0)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.6)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.3.6)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.2.4)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.3.0)\n","Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8.2)\n","Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.6.0)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.8)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.1.1)\n","Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (5.2.0)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.7.2)\n","Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.0.2)\n","Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.0.8)\n","Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.13.0)\n","Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.2.1)\n","Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.0.46)\n","Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (7.1.2)\n","Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (1.1.0)\n","Requirement already satisfied: braceexpand in /usr/local/lib/python3.7/dist-packages (from WebDataset->dalle-pytorch) (0.1.7)\n"]}]},{"cell_type":"markdown","source":["### Restart runtime from here"],"metadata":{"id":"MUGz_NZE_qCV"}},{"cell_type":"code","source":["from google.colab import drive\n","drive.mount('/content/drive')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kpnzNia6eQjO","executionInfo":{"status":"ok","timestamp":1640501154315,"user_tz":-540,"elapsed":22561,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"7ea129c7-7bd2-4cea-840b-15a1f6535f26"},"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}]},{"cell_type":"code","execution_count":5,"metadata":{"id":"FsftdmCPETVT","executionInfo":{"status":"ok","timestamp":1640501159438,"user_tz":-540,"elapsed":5133,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["import torch\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","%config InlineBackend.figure_format = 'retina'"]},{"cell_type":"markdown","metadata":{"id":"vy19ZEl9ETVW"},"source":[""]},{"cell_type":"code","execution_count":6,"metadata":{"id":"6XbxsJr9ETVY","outputId":"78a39e9b-a28b-4c2d-866d-841792cef975","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501159439,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Random Seed:  999\n"]},{"output_type":"execute_result","data":{"text/plain":["<torch._C.Generator at 0x7f6fa0868b10>"]},"metadata":{},"execution_count":6}],"source":["from __future__ import print_function\n","import random\n","import torch.nn.parallel\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","# https://stackoverflow.com/questions/12984426/pil-ioerror-image-file-truncated-with-big-images\n","# ImageFile.LOAD_TRUNCATED_IMAGES = True\n","\n","# Set random seed for reproducibility\n","manualSeed = 999\n","#manualSeed = random.randint(1, 10000) # use if you want new results\n","print(\"Random Seed: \", manualSeed)\n","random.seed(manualSeed)\n","torch.manual_seed(manualSeed)"]},{"cell_type":"code","execution_count":7,"metadata":{"id":"HRY3CzvqETVZ","executionInfo":{"status":"ok","timestamp":1640501159439,"user_tz":-540,"elapsed":5,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from easydict import EasyDict\n","\n","# constants\n","\n","VAE_CFG = EasyDict()\n","\n","VAE_CFG.IMAGE_SIZE = 256\n","VAE_CFG.IMAGE_PATH = './'\n","\n","VAE_CFG.BASELINE = False"]},{"cell_type":"code","execution_count":8,"metadata":{"id":"IvtOi_BfETVZ","executionInfo":{"status":"ok","timestamp":1640501160387,"user_tz":-540,"elapsed":952,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from random import choice\n","from pathlib import Path\n","\n","# torch\n","\n","import torch\n","from torch.optim import Adam\n","from torch.nn.utils import clip_grad_norm_\n","\n","# vision imports\n","\n","from PIL import Image\n","from torchvision import transforms as T\n","from torch.utils.data import DataLoader, Dataset\n","from torchvision.datasets import ImageFolder\n","from torchvision.utils import make_grid, save_image\n","\n","# dalle related classes and utils\n","\n","from dalle_pytorch import OpenAIDiscreteVAE, DiscreteVAE, DALLE\n","\n","# helpers\n","\n","def exists(val):\n","    return val is not None"]},{"cell_type":"code","source":["import shutil\n","\n","vqgan_best_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue_e7\"\n","shutil.copy(vqgan_best_path, \"./\")\n","\n","vqgan_best_yaml_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue.yaml\"\n","shutil.copy(vqgan_best_yaml_path, \"./\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"id":"TubuiCYeeNbz","executionInfo":{"status":"ok","timestamp":1640501173523,"user_tz":-540,"elapsed":13139,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"4e5b5306-57ea-4342-ead4-48448bf96bbc"},"execution_count":9,"outputs":[{"output_type":"execute_result","data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./VQGAN_blue.yaml'"]},"metadata":{},"execution_count":9}]},{"cell_type":"code","source":["dalle_best_path = \"/content/drive/MyDrive/K-Fashion/DALLE Models/dalle_vq_blue_e7_final.pt\"\n","shutil.copy(dalle_best_path, \"./\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"id":"FuW7cjLdmVuV","executionInfo":{"status":"ok","timestamp":1640501267325,"user_tz":-540,"elapsed":93806,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"811d2f3f-6b91-492d-8cf3-22423e5a36e8"},"execution_count":10,"outputs":[{"output_type":"execute_result","data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./dalle_vq_blue_e7_final.pt'"]},"metadata":{},"execution_count":10}]},{"cell_type":"code","execution_count":11,"metadata":{"id":"hs5_QzNpETVa","executionInfo":{"status":"ok","timestamp":1640501267325,"user_tz":-540,"elapsed":8,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from easydict import EasyDict\n","import os\n","\n","DALLE_CFG = EasyDict()\n","\n","# argument parsing\n","\n","# DALLE_CFG.VQGAN_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/last_51485_step.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_PATH = os.path.basename(vqgan_best_path)\n","# DALLE_CFG.VQGAN_CFG_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/2021-12-15T16-24-36-project.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_CFG_PATH = os.path.basename(vqgan_best_yaml_path)\n","DALLE_CFG.DALLE_PATH = os.path.basename(dalle_best_path)   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n","DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n","DALLE_CFG.BPE_PATH = None\n","DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n","\n","# DALLE_CFG.EPOCHS = 20\n","# DALLE_CFG.BATCH_SIZE = 54\n","DALLE_CFG.LEARNING_RATE = 3e-4\n","DALLE_CFG.GRAD_CLIP_NORM = 0.5\n","\n","# DALLE_CFG.MODEL_DIM = 512\n","DALLE_CFG.TEXT_SEQ_LEN = 128\n","DALLE_CFG.DEPTH = 2\n","DALLE_CFG.HEADS = 8\n","DALLE_CFG.DIM_HEAD = 64\n","DALLE_CFG.REVERSIBLE = True"]},{"cell_type":"code","execution_count":12,"metadata":{"id":"URMpwTL5ETVb","outputId":"d81d234b-16ce-4982-ae64-6f0d1ba34ac1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501267326,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":12}],"source":["DALLE_CFG.RESUME"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"6aPRTq1GETVb","colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["b737a3077a5844039a6be0f7027b8529","789520acf8c6443c87eb3159ee5a94f1","a092a22fbef44f96a3818b46b07eb83b","bdb5685a0b414e65a82b1778930e3747","b5649869ea9f461a989a58b5aae78608","de92258c01bc4f21b78e1e74efff9063","71b99fb5f37743558d660aa4ac53e587","682c5233b6bc4c96a2e75bd0c5aeb02a","fce9b529a2c8491a96b1a82b8de634dc","83f744eab718483f9c9e604e67f365cd","056f5acf9bd34054868b95e06b35350e","cb36498cf7db4aa0b4f601f05d088a8f","b64b4eb7046f48cda8b98661ac77b3aa","355e86971e0f4f7aa134fe70bd3ac8b0","98af5a89118243d3b1dbd71fcab90395","4755a06ad8dc4f14aeb1363052a576d7","e92c525df9194f9b82d3c0607bfb3f97","a44149a8e39048acbd184036aeffd52b","e75ea3ec61524e9c9f9a12a449866aac","b46403218cf942d98715083a75dcad87","e31f637aaa114f3e9d4e8036a85a75a4","1b257065d0ef40eeb4f43c5a22ec91d2","cfef0fae7f0849ba93242651ce3d9dee","4e857c5654f3406fa4b49dfb45348a02","f33abf69f5924492a6f50b75b60cef4d","14ef623da96e443e8d985870052a59e9","39ff2b3eb62348fa8884d2f64d829dad","fa6f0f6b0bab4ab6afe48f52ccc0f218","bbca27254b1040e69ed0c824239fa250","f20fd195724b4d979e7e202e7e422ba6","d9fed9c7866849d585db5cc936b58d57","ea58905965844e06b6f9b8344cf1cb7b","4ea034953e6e4c9f8739a0d811513532","b3ccc40ffd8f48fe81957f480f6e6815","b1b9d3f604104dac97e57ff73489d32c","71039a160e29436b928f22c477db2e41","db1ff5fe3e3d4af58593c5573bbc6f75","9addf47d6953415da7dbabf730acfc16","7cbc74df100d439b82f3be2c0e2c3b54","be3d477b33484cbaab304ca97cf63378","cca1beb5ef98445e8db63224a8783011","cce09cfcc961488aacf95f26158480c0","cd346231832d4029b8cbccfd444fb805","4b603c2753094e05a024429d00ca4cf1"]},"executionInfo":{"status":"ok","timestamp":1640501279436,"user_tz":-540,"elapsed":12115,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"b9896041-3caf-4f3c-8c49-058e96394de2"},"outputs":[{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b737a3077a5844039a6be0f7027b8529","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/375 [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cb36498cf7db4aa0b4f601f05d088a8f","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/243k [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cfef0fae7f0849ba93242651ce3d9dee","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/734k [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b3ccc40ffd8f48fe81957f480f6e6815","version_minor":0,"version_major":2},"text/plain":["Downloading:   0%|          | 0.00/173 [00:00<?, ?B/s]"]},"metadata":{}}],"source":["# import from huggingface transformers\n","from transformers import AutoTokenizer, AutoModelWithLMHead\n","\n","tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n","# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")"]},{"cell_type":"code","source":["!nvidia-smi"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"YZXRsVJ4BWeF","executionInfo":{"status":"ok","timestamp":1640501279437,"user_tz":-540,"elapsed":19,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"e3dac17e-17b5-47ce-e8fc-0111e7099cff"},"execution_count":14,"outputs":[{"output_type":"stream","name":"stdout","text":["Sun Dec 26 06:47:58 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}]},{"cell_type":"code","execution_count":15,"metadata":{"id":"a08tUVpeETVc","outputId":"830042b9-8796-4d50-83a1-5e20b5d5f338","colab":{"base_uri":"https://localhost:8080/","height":171,"referenced_widgets":["bfa7edd8caff48f7be2fe4ad34f62ac1","fa6e1babb7ea4a02b1379d1f293184bd","0f682f4dc3284534b6be9e10ea619d2b","eabb6eea5950458ab41116a1525acedc","d1f42d328f674043a71b4d7406843511","3a5ce6f768cf42359be9b1edef7fc272","0a3039e5606b4eceab025c42b99b79ed","008bfb9186864298993ef2303659d3ad","92046bf3cbe54ba5a3adad249c391129","fdecb696460a41d09ef2b92d195151a7","d6da336731144c97a9964d79edd69d5a"]},"executionInfo":{"status":"ok","timestamp":1640501338487,"user_tz":-540,"elapsed":59054,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n"]},{"output_type":"stream","name":"stderr","text":["Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"]},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"bfa7edd8caff48f7be2fe4ad34f62ac1","version_minor":0,"version_major":2},"text/plain":["  0%|          | 0.00/528M [00:00<?, ?B/s]"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Downloading vgg_lpips model from https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1 to taming/modules/autoencoder/lpips/vgg.pth\n"]},{"output_type":"stream","name":"stderr","text":["8.19kB [00:00, 79.8kB/s]\n"]},{"output_type":"stream","name":"stdout","text":["loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n","VQLPIPSWithDiscriminator running with hinge loss.\n","Loaded VQGAN from VQGAN_blue_e7 and VQGAN_blue.yaml\n"]}],"source":["from dalle_pytorch import VQGanVAE\n","from pathlib import Path\n","\n","DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n","\n","dalle_path = Path(DALLE_CFG.DALLE_PATH)\n","assert dalle_path.exists(), 'DALL-E model file does not exist'\n","\n","loaded_obj = torch.load(str(dalle_path), map_location=torch.device('cuda:0'))\n","\n","dalle_params, vae_params, weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n","\n","vae_klass = VQGanVAE\n","vae = vae_klass(\n","    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n","    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n","    )\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size\n","\n","dalle_params = dict(        \n","    **dalle_params\n",")\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size"]},{"cell_type":"code","execution_count":16,"metadata":{"id":"dDIPEJORETVd","outputId":"750b7ca1-df18-4a95-9fff-b7ebb772ddad","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501338488,"user_tz":-540,"elapsed":9,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["{'attn_dropout': 0,\n"," 'attn_types': ('full',),\n"," 'depth': 16,\n"," 'dim_head': 64,\n"," 'ff_dropout': 0,\n"," 'heads': 8,\n"," 'loss_img_weight': 7,\n"," 'num_text_tokens': 32000,\n"," 'reversible': False,\n"," 'rotary_emb': False,\n"," 'shift_tokens': False,\n"," 'stable': False,\n"," 'text_seq_len': 128}"]},"metadata":{},"execution_count":16}],"source":["dalle_params"]},{"cell_type":"code","execution_count":17,"metadata":{"id":"FJhjwhNsETVd","executionInfo":{"status":"ok","timestamp":1640501338488,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["from math import log2, sqrt\n","import torch\n","from torch import nn, einsum\n","import torch.nn.functional as F\n","import numpy as np\n","\n","from axial_positional_embedding import AxialPositionalEmbedding\n","from einops import rearrange\n","\n","from dalle_pytorch import distributed_utils\n","from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE\n","from dalle_pytorch.transformer import Transformer, DivideMax\n","from dalle_pytorch.attention import stable_softmax"]},{"cell_type":"code","execution_count":18,"metadata":{"id":"1zGbTpHEETVe","executionInfo":{"status":"ok","timestamp":1640501338489,"user_tz":-540,"elapsed":7,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["def exists(val):\n","    return val is not None\n","\n","\n","def default(val, d):\n","    return val if exists(val) else d\n","\n","\n","class always:\n","    def __init__(self, val):\n","        self.val = val\n","\n","    def __call__(self, x, *args, **kwargs):\n","        return self.val\n","\n","\n","def is_empty(t):\n","    return t.nelement() == 0\n","\n","\n","def masked_mean(t, mask, dim=1):\n","    t = t.masked_fill(~mask[:, :, None], 0.0)\n","    return t.sum(dim=1) / mask.sum(dim=1)[..., None]\n","\n","\n","def set_requires_grad(model, value):\n","    for param in model.parameters():\n","        param.requires_grad = value\n","\n","\n","def eval_decorator(fn):\n","    def inner(model, *args, **kwargs):\n","        was_training = model.training\n","        model.eval()\n","        out = fn(model, *args, **kwargs)\n","        model.train(was_training)\n","        return out\n","\n","    return inner\n","\n","\n","# sampling helpers\n","\n","\n","def top_k(logits, thres=0.5):\n","    num_logits = logits.shape[-1]\n","    k = max(int((1 - thres) * num_logits), 1)\n","    val, ind = torch.topk(logits, k)\n","    probs = torch.full_like(logits, float(\"-inf\"))\n","    probs.scatter_(1, ind, val)\n","    return probs\n","\n","\n","# discrete vae class\n","\n","\n","class ResBlock(nn.Module):\n","    def __init__(self, chan):\n","        super().__init__()\n","        self.net = nn.Sequential(\n","            nn.Conv2d(chan, chan, 3, padding=1),\n","            nn.ReLU(),\n","            nn.Conv2d(chan, chan, 3, padding=1),\n","            nn.ReLU(),\n","            nn.Conv2d(chan, chan, 1),\n","        )\n","\n","    def forward(self, x):\n","        return self.net(x) + x\n","\n"]},{"cell_type":"code","execution_count":19,"metadata":{"id":"DQ9_4vpxETVe","executionInfo":{"status":"ok","timestamp":1640501339003,"user_tz":-540,"elapsed":521,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[],"source":["class DALLE_Klue_Roberta(nn.Module):\n","    def __init__(\n","        self,\n","        *,\n","        # dim,\n","        vae,\n","        num_text_tokens=10000,\n","        text_seq_len=256,\n","        depth,\n","        heads=8,\n","        dim_head=64,\n","        reversible=False,\n","        attn_dropout=0.0,\n","        ff_dropout=0,\n","        sparse_attn=False,\n","        attn_types=None,\n","        loss_img_weight=7,\n","        stable=False,\n","        sandwich_norm=False,\n","        shift_tokens=True,\n","        rotary_emb=False,\n","        wte_dir=None,\n","        wpe_dir=None,\n","    ):\n","        super().__init__()\n","        assert isinstance(\n","            vae, (DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE)\n","        ), \"vae must be an instance of DiscreteVAE\"\n","        image_size = vae.image_size\n","        num_image_tokens = vae.num_tokens\n","        image_fmap_size = vae.image_size // (2 ** vae.num_layers)\n","        image_seq_len = image_fmap_size ** 2\n","\n","        num_text_tokens = (\n","            num_text_tokens + text_seq_len\n","        )  # reserve unique padding tokens for each position (text seq len)\n","\n","        self.text_emb = torch.load(wte_dir)\n","        dim = self.text_emb.weight.shape[1]\n","        self.image_emb = nn.Embedding(num_image_tokens, dim)\n","        print(dim,image_fmap_size,image_fmap_size)\n","        self.text_pos_emb = torch.load(wpe_dir) if not rotary_emb else always(0)  # +1 for <bos>\n","        self.image_pos_emb = (\n","            AxialPositionalEmbedding(dim, axial_shape=(image_fmap_size, image_fmap_size))\n","            if not rotary_emb\n","            else always(0)\n","        )\n","\n","        self.num_text_tokens = (\n","            num_text_tokens  # for offsetting logits index and calculating cross entropy loss\n","        )\n","        self.num_image_tokens = num_image_tokens\n","\n","        self.text_seq_len = text_seq_len\n","        self.image_seq_len = image_seq_len\n","\n","        seq_len = text_seq_len + image_seq_len\n","        total_tokens = num_text_tokens + num_image_tokens\n","        self.total_tokens = total_tokens\n","        self.total_seq_len = seq_len\n","\n","        self.vae = vae\n","        set_requires_grad(self.vae, False)  # freeze VAE from being trained\n","\n","        self.transformer = Transformer(\n","            dim=dim,\n","            causal=True,\n","            seq_len=seq_len,\n","            depth=depth,\n","            heads=heads,\n","            dim_head=dim_head,\n","            reversible=reversible,\n","            attn_dropout=attn_dropout,\n","            ff_dropout=ff_dropout,\n","            attn_types=attn_types,\n","            image_fmap_size=image_fmap_size,\n","            sparse_attn=sparse_attn,\n","            stable=stable,\n","            sandwich_norm=sandwich_norm,\n","            shift_tokens=shift_tokens,\n","            rotary_emb=rotary_emb,\n","        )\n","\n","        self.stable = stable\n","\n","        if stable:\n","            self.norm_by_max = DivideMax(dim=-1)\n","\n","        self.to_logits = nn.Sequential(\n","            nn.LayerNorm(dim),\n","            nn.Linear(dim, self.total_tokens),\n","        )\n","\n","        seq_range = torch.arange(seq_len)\n","        logits_range = torch.arange(total_tokens)\n","\n","        seq_range = rearrange(seq_range, \"n -> () n ()\")\n","        logits_range = rearrange(logits_range, \"d -> () () d\")\n","\n","        logits_mask = ((seq_range >= text_seq_len) & (logits_range < num_text_tokens)) | (\n","            (seq_range < text_seq_len) & (logits_range >= num_text_tokens)\n","        )\n","\n","        self.register_buffer(\"logits_mask\", logits_mask, persistent=False)\n","        self.loss_img_weight = loss_img_weight\n","\n","    @torch.no_grad()\n","    @eval_decorator\n","    def generate_texts(self, tokenizer, text=None, *, filter_thres=0.5, temperature=1.0):\n","        text_seq_len = self.text_seq_len\n","        if text is None or text == \"\":\n","            text_tokens = torch.tensor([[0]]).cuda()\n","        else:\n","            text_tokens = torch.tensor(tokenizer.tokenizer.encode(text)).cuda().unsqueeze(0)\n","\n","        for _ in range(text_tokens.shape[1], text_seq_len):\n","            device = text_tokens.device\n","\n","            tokens = self.text_emb(text_tokens)\n","            tokens += self.text_pos_emb(torch.arange(text_tokens.shape[1], device=device))\n","\n","            seq_len = tokens.shape[1]\n","\n","            output_transf = self.transformer(tokens)\n","\n","            if self.stable:\n","                output_transf = self.norm_by_max(output_transf)\n","\n","            logits = self.to_logits(output_transf)\n","\n","            # mask logits to make sure text predicts text (except last token), and image predicts image\n","\n","            logits_mask = self.logits_mask[:, :seq_len]\n","            max_neg_value = -torch.finfo(logits.dtype).max\n","            logits.masked_fill_(logits_mask, max_neg_value)\n","            logits = logits[:, -1, :]\n","\n","            filtered_logits = top_k(logits, thres=filter_thres)\n","            probs = stable_softmax(filtered_logits / temperature, dim=-1)\n","            sample = torch.multinomial(probs, 1)\n","\n","            text_tokens = torch.cat((text_tokens, sample), dim=-1)\n","\n","        padding_tokens = set(\n","            np.arange(self.text_seq_len) + (self.num_text_tokens - self.text_seq_len)\n","        )\n","        texts = [\n","            tokenizer.tokenizer.decode(text_token, pad_tokens=padding_tokens)\n","            for text_token in text_tokens\n","        ]\n","        return text_tokens, texts\n","\n","    @torch.no_grad()\n","    @eval_decorator\n","    def generate_images(\n","        self,\n","        text,\n","        *,\n","        clip=None,\n","        mask=None,\n","        filter_thres=0.5,\n","        temperature=1.0,\n","        img=None,\n","        num_init_img_tokens=None,\n","    ):\n","        vae, text_seq_len, image_seq_len, num_text_tokens = (\n","            self.vae,\n","            self.text_seq_len,\n","            self.image_seq_len,\n","            self.num_text_tokens,\n","        )\n","        total_len = text_seq_len + image_seq_len\n","\n","        text = text[:, :text_seq_len]  # make sure text is within bounds\n","        out = text\n","\n","        if exists(img):\n","            image_size = vae.image_size\n","            assert (\n","                img.shape[1] == 3 and img.shape[2] == image_size and img.shape[3] == image_size\n","            ), f\"input image must have the correct image size {image_size}\"\n","\n","            indices = vae.get_codebook_indices(img)\n","            num_img_tokens = default(\n","                num_init_img_tokens, int(0.4375 * image_seq_len)\n","            )  # OpenAI used 14 * 32 initial tokens to prime\n","            assert (\n","                num_img_tokens < image_seq_len\n","            ), \"number of initial image tokens for priming must be less than the total image token sequence length\"\n","\n","            indices = indices[:, :num_img_tokens]\n","            out = torch.cat((out, indices), dim=-1)\n","\n","        for cur_len in range(out.shape[1], total_len):\n","            is_image = cur_len >= text_seq_len\n","\n","            text, image = out[:, :text_seq_len], out[:, text_seq_len:]\n","\n","            logits = self(text, image, mask=mask)[:, -1, :]\n","\n","            filtered_logits = top_k(logits, thres=filter_thres)\n","            probs = F.softmax(filtered_logits / temperature, dim=-1)\n","            sample = torch.multinomial(probs, 1)\n","\n","            sample -= (\n","                num_text_tokens if is_image else 0\n","            )  # offset sampled token if it is an image token, since logit space is composed of text and then image tokens\n","            out = torch.cat((out, sample), dim=-1)\n","\n","            if out.shape[1] <= text_seq_len:\n","                mask = F.pad(mask, (0, 1), value=True)\n","\n","        text_seq = out[:, :text_seq_len]\n","\n","        img_seq = out[:, -image_seq_len:]\n","        images = vae.decode(img_seq)\n","\n","        if exists(clip):\n","            scores = clip(text_seq, images, return_loss=False)\n","            return images, scores\n","\n","        return images\n","\n","    def forward(self, text, image=None, mask=None, return_loss=False):\n","        assert (\n","            text.shape[-1] == self.text_seq_len\n","        ), f\"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})\"\n","        device, total_seq_len = text.device, self.total_seq_len\n","\n","        # make sure padding in text tokens get unique padding token id\n","\n","        #text_range = torch.arange(self.text_seq_len, device=device) + (\n","        #    self.num_text_tokens - self.text_seq_len\n","        #)\n","        #print(torch.max(text))\n","        #print(text)\n","        #torch.save(text,'text.pt')\n","        #text = torch.where(text == 3, text_range, text)\n","\n","        # add <bos>\n","        #print(text.shape)\n","        #print(text)\n","        #print(torch.max(text))\n","        text = F.pad(text, (1, 0), value=0)\n","        #print(text.shape)\n","        #print(text)\n","        #print(torch.max(text))\n","        tokens = self.text_emb(text)\n","        tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))\n","\n","        seq_len = tokens.shape[1]\n","\n","        if exists(image) and not is_empty(image):\n","            is_raw_image = len(image.shape) == 4\n","\n","            if is_raw_image:\n","                image_size = self.vae.image_size\n","                assert tuple(image.shape[1:]) == (\n","                    3,\n","                    image_size,\n","                    image_size,\n","                ), f\"invalid image of dimensions {image.shape} passed in during training\"\n","\n","                image = self.vae.get_codebook_indices(image)\n","            image_len = image.shape[1]\n","            image_emb = self.image_emb(image)\n","            image_emb += self.image_pos_emb(image_emb)\n","\n","            tokens = torch.cat((tokens, image_emb), dim=1)\n","\n","            seq_len += image_len\n","\n","        # when training, if the length exceeds the total text + image length\n","        # remove the last token, since it needs not to be trained\n","\n","        if tokens.shape[1] > total_seq_len:\n","            seq_len -= 1\n","            tokens = tokens[:, :-1]\n","\n","        if self.stable:\n","            alpha = 0.1\n","            tokens = tokens * alpha + tokens.detach() * (1 - alpha)\n","\n","        out = self.transformer(tokens)\n","\n","        if self.stable:\n","            out = self.norm_by_max(out)\n","\n","        logits = self.to_logits(out)\n","\n","        # mask logits to make sure text predicts text (except last token), and image predicts image\n","\n","        logits_mask = self.logits_mask[:, :seq_len]\n","        max_neg_value = -torch.finfo(logits.dtype).max\n","        logits.masked_fill_(logits_mask, max_neg_value)\n","\n","        if not return_loss:\n","            return logits\n","\n","        assert exists(image), \"when training, image must be supplied\"\n","\n","        offsetted_image = image + self.num_text_tokens\n","        labels = torch.cat((text[:, 1:], offsetted_image), dim=1)\n","\n","        logits = rearrange(logits, \"b n c -> b c n\")\n","\n","        loss_text = F.cross_entropy(\n","            logits[:, :, : self.text_seq_len], labels[:, : self.text_seq_len]\n","        )\n","        loss_img = F.cross_entropy(\n","            logits[:, :, self.text_seq_len :], labels[:, self.text_seq_len :]\n","        )\n","\n","        loss = (loss_text + self.loss_img_weight * loss_img) / (self.loss_img_weight + 1)\n","        return loss\n"]},{"cell_type":"code","source":["import shutil\n","\n","roberta_wte = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wte.pt\"\n","shutil.copy(roberta_wte, \"./\")\n","\n","roberta_wpe = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wpe.pt\"\n","shutil.copy(roberta_wpe, \"./\")\n","\n","ROBERTA_WTE_PATH = os.path.basename(roberta_wte)\n","ROBERTA_WPE_PATH = os.path.basename(roberta_wpe)"],"metadata":{"id":"6LfuuBVcBGfq","executionInfo":{"status":"ok","timestamp":1640501344480,"user_tz":-540,"elapsed":5478,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":20,"outputs":[]},{"cell_type":"code","source":["from google.colab import drive\n","drive.flush_and_unmount()"],"metadata":{"id":"kCdxwf1jrdZd","executionInfo":{"status":"ok","timestamp":1640501347773,"user_tz":-540,"elapsed":3297,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":21,"outputs":[]},{"cell_type":"code","execution_count":22,"metadata":{"id":"yjbIh82bETVg","outputId":"960190b5-8a0a-42b9-f274-1e85b98972b3","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501353503,"user_tz":-540,"elapsed":5733,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["1024 16 16\n"]},{"output_type":"execute_result","data":{"text/plain":["<All keys matched successfully>"]},"metadata":{},"execution_count":22}],"source":["device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n","dalle = DALLE_Klue_Roberta(\n","    vae = vae, \n","    wte_dir=\"./roberta_large_wte.pt\",\n","    wpe_dir=\"./roberta_large_wpe.pt\",\n","    **dalle_params\n","    ).to(device)\n","\n","dalle.load_state_dict(weights)"]},{"cell_type":"code","execution_count":27,"metadata":{"id":"ylw54NgWETVi","outputId":"c33f64cf-7153-4a32-811f-d9bd7c17f31e","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501449158,"user_tz":-540,"elapsed":8757,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["CPU times: user 8.51 s, sys: 0 ns, total: 8.51 s\n","Wall time: 8.49 s\n"]}],"source":["%%time\n","input_text = \\\n","\"하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. \\\n","하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. \\\n","상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. \\\n","상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\"\n","\n","encoded_dict = tokenizer(\n","    input_text,\n","    return_tensors=\"pt\",\n","    padding=\"max_length\",\n","    truncation=True,\n","    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n","    add_special_tokens=True,\n","    return_token_type_ids=False,  # for RoBERTa\n",")\n","input_ids = encoded_dict[\"input_ids\"].to(device)\n","attention_mask = encoded_dict[\"attention_mask\"].to(device)\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n","# 12 minutes for K11\n","images = dalle.generate_images(input_ids, mask = attention_mask)\n","images.shape # (4, 3, 256, 256)"]},{"cell_type":"code","source":["input_ids"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Hvd5nC5vvZWR","executionInfo":{"status":"ok","timestamp":1640501363505,"user_tz":-540,"elapsed":29,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"f2036fd9-0aac-4f0a-ad4d-886125cf355d"},"execution_count":24,"outputs":[{"output_type":"execute_result","data":{"text/plain":["tensor([[    0, 19975, 27135,  8817,  2073, 11150, 28674,    18, 19975, 27135,\n","         14346,  2170,  2259, 24631,  2128, 28674,    18, 19975, 27135,  4642,\n","          2170,  2259, 13859, 28674,    18, 19975, 27135, 17107,  2170,  2259,\n","          8482, 28674,    18, 19975, 27135,  1887,  2073,   766,  2149, 28674,\n","            18, 10346, 27135, 10653,  2073,   766,  2149, 28674,    18, 10346,\n","         27135,  8817,  2073,  7482, 28674,    18, 10346, 27135, 29952,  2073,\n","         10727,  2600,  4893,  2062,    18, 10346, 27135, 14346,  2170,  2259,\n","          9742, 28674,    18, 10346, 27135,  8696,  2015,  2121,  2073,   646,\n","         31286,  2062,    18, 10346, 27135,  4642,  2170,  2259,  1469,  2862,\n","         28674,    18,     2,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1]],\n","       device='cuda:0')"]},"metadata":{},"execution_count":24}]},{"cell_type":"code","execution_count":28,"metadata":{"id":"7Qr2RZ8gETVi","outputId":"6fb9c672-bbd6-4801-e2e1-fbe70339d0e1","colab":{"base_uri":"https://localhost:8080/","height":345},"executionInfo":{"status":"ok","timestamp":1640501462251,"user_tz":-540,"elapsed":1160,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. 상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\n"]},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<PIL.Image.Image image mode=RGB size=256x256 at 0x7F6E48437A50>"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["CPU times: user 38.7 ms, sys: 0 ns, total: 38.7 ms\n","Wall time: 40.2 ms\n"]}],"source":["%%time\n","from torchvision.utils import make_grid, save_image\n","from PIL import Image\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/e1d10b9163ce78bacb5d8b42126255a0a8cdea35/generate.py#L93-L130\n","grid = make_grid(images, nrow=1, padding=0, pad_value=0)\n","ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n","im = Image.fromarray(ndarr)\n","\n","print(input_text)\n","display(im)"]},{"cell_type":"code","execution_count":26,"metadata":{"id":"53_I9cG7ETVj","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1640501363506,"user_tz":-540,"elapsed":14,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}},"outputId":"e444fbe5-4274-488b-ab81-42dbac003667"},"outputs":[{"output_type":"stream","name":"stdout","text":["Sun Dec 26 06:49:22 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   39C    P0    39W / 250W |   9279MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","source":[""],"metadata":{"id":"eu5cjiEzwaVf","executionInfo":{"status":"ok","timestamp":1640501363507,"user_tz":-540,"elapsed":9,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"}}},"execution_count":26,"outputs":[]}],"metadata":{"interpreter":{"hash":"546ac3bc9ff8ae035b2d532deb5ff1f925751c91c859447d340e61cadcd4cd28"},"kernelspec":{"display_name":"Python 3.8.5 64-bit ('taming': conda)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.3"},"orig_nbformat":4,"colab":{"name":"inference_blue.ipynb","provenance":[],"collapsed_sections":[]},"accelerator":"GPU","widgets":{"application/vnd.jupyter.widget-state+json":{"b737a3077a5844039a6be0f7027b8529":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_789520acf8c6443c87eb3159ee5a94f1","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_a092a22fbef44f96a3818b46b07eb83b","IPY_MODEL_bdb5685a0b414e65a82b1778930e3747","IPY_MODEL_b5649869ea9f461a989a58b5aae78608"]}},"789520acf8c6443c87eb3159ee5a94f1":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"a092a22fbef44f96a3818b46b07eb83b":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_de92258c01bc4f21b78e1e74efff9063","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_71b99fb5f37743558d660aa4ac53e587"}},"bdb5685a0b414e65a82b1778930e3747":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_682c5233b6bc4c96a2e75bd0c5aeb02a","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":375,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":375,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_fce9b529a2c8491a96b1a82b8de634dc"}},"b5649869ea9f461a989a58b5aae78608":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_83f744eab718483f9c9e604e67f365cd","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 375/375 [00:00&lt;00:00, 5.61kB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_056f5acf9bd34054868b95e06b35350e"}},"de92258c01bc4f21b78e1e74efff9063":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"71b99fb5f37743558d660aa4ac53e587":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"682c5233b6bc4c96a2e75bd0c5aeb02a":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"fce9b529a2c8491a96b1a82b8de634dc":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"83f744eab718483f9c9e604e67f365cd":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"056f5acf9bd34054868b95e06b35350e":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cb36498cf7db4aa0b4f601f05d088a8f":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_b64b4eb7046f48cda8b98661ac77b3aa","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_355e86971e0f4f7aa134fe70bd3ac8b0","IPY_MODEL_98af5a89118243d3b1dbd71fcab90395","IPY_MODEL_4755a06ad8dc4f14aeb1363052a576d7"]}},"b64b4eb7046f48cda8b98661ac77b3aa":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"355e86971e0f4f7aa134fe70bd3ac8b0":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_e92c525df9194f9b82d3c0607bfb3f97","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_a44149a8e39048acbd184036aeffd52b"}},"98af5a89118243d3b1dbd71fcab90395":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_e75ea3ec61524e9c9f9a12a449866aac","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":248477,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":248477,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_b46403218cf942d98715083a75dcad87"}},"4755a06ad8dc4f14aeb1363052a576d7":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_e31f637aaa114f3e9d4e8036a85a75a4","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 243k/243k [00:00&lt;00:00, 311kB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_1b257065d0ef40eeb4f43c5a22ec91d2"}},"e92c525df9194f9b82d3c0607bfb3f97":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"a44149a8e39048acbd184036aeffd52b":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"e75ea3ec61524e9c9f9a12a449866aac":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"b46403218cf942d98715083a75dcad87":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"e31f637aaa114f3e9d4e8036a85a75a4":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"1b257065d0ef40eeb4f43c5a22ec91d2":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cfef0fae7f0849ba93242651ce3d9dee":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_4e857c5654f3406fa4b49dfb45348a02","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_f33abf69f5924492a6f50b75b60cef4d","IPY_MODEL_14ef623da96e443e8d985870052a59e9","IPY_MODEL_39ff2b3eb62348fa8884d2f64d829dad"]}},"4e857c5654f3406fa4b49dfb45348a02":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"f33abf69f5924492a6f50b75b60cef4d":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_fa6f0f6b0bab4ab6afe48f52ccc0f218","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_bbca27254b1040e69ed0c824239fa250"}},"14ef623da96e443e8d985870052a59e9":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_f20fd195724b4d979e7e202e7e422ba6","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":751504,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":751504,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_d9fed9c7866849d585db5cc936b58d57"}},"39ff2b3eb62348fa8884d2f64d829dad":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_ea58905965844e06b6f9b8344cf1cb7b","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 734k/734k [00:01&lt;00:00, 1.06MB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_4ea034953e6e4c9f8739a0d811513532"}},"fa6f0f6b0bab4ab6afe48f52ccc0f218":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"bbca27254b1040e69ed0c824239fa250":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"f20fd195724b4d979e7e202e7e422ba6":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"d9fed9c7866849d585db5cc936b58d57":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"ea58905965844e06b6f9b8344cf1cb7b":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"4ea034953e6e4c9f8739a0d811513532":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"b3ccc40ffd8f48fe81957f480f6e6815":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_b1b9d3f604104dac97e57ff73489d32c","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_71039a160e29436b928f22c477db2e41","IPY_MODEL_db1ff5fe3e3d4af58593c5573bbc6f75","IPY_MODEL_9addf47d6953415da7dbabf730acfc16"]}},"b1b9d3f604104dac97e57ff73489d32c":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"71039a160e29436b928f22c477db2e41":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_7cbc74df100d439b82f3be2c0e2c3b54","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"Downloading: 100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_be3d477b33484cbaab304ca97cf63378"}},"db1ff5fe3e3d4af58593c5573bbc6f75":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_cca1beb5ef98445e8db63224a8783011","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":173,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":173,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_cce09cfcc961488aacf95f26158480c0"}},"9addf47d6953415da7dbabf730acfc16":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_cd346231832d4029b8cbccfd444fb805","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 173/173 [00:00&lt;00:00, 4.96kB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_4b603c2753094e05a024429d00ca4cf1"}},"7cbc74df100d439b82f3be2c0e2c3b54":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"be3d477b33484cbaab304ca97cf63378":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cca1beb5ef98445e8db63224a8783011":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"cce09cfcc961488aacf95f26158480c0":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"cd346231832d4029b8cbccfd444fb805":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"4b603c2753094e05a024429d00ca4cf1":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"bfa7edd8caff48f7be2fe4ad34f62ac1":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","model_module_version":"1.5.0","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_fa6e1babb7ea4a02b1379d1f293184bd","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_0f682f4dc3284534b6be9e10ea619d2b","IPY_MODEL_eabb6eea5950458ab41116a1525acedc","IPY_MODEL_d1f42d328f674043a71b4d7406843511"]}},"fa6e1babb7ea4a02b1379d1f293184bd":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"0f682f4dc3284534b6be9e10ea619d2b":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_3a5ce6f768cf42359be9b1edef7fc272","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":"100%","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_0a3039e5606b4eceab025c42b99b79ed"}},"eabb6eea5950458ab41116a1525acedc":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","model_module_version":"1.5.0","state":{"_view_name":"ProgressView","style":"IPY_MODEL_008bfb9186864298993ef2303659d3ad","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":553433881,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":553433881,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_92046bf3cbe54ba5a3adad249c391129"}},"d1f42d328f674043a71b4d7406843511":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","model_module_version":"1.5.0","state":{"_view_name":"HTMLView","style":"IPY_MODEL_fdecb696460a41d09ef2b92d195151a7","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 528M/528M [00:10&lt;00:00, 191MB/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_d6da336731144c97a9964d79edd69d5a"}},"3a5ce6f768cf42359be9b1edef7fc272":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"0a3039e5606b4eceab025c42b99b79ed":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"008bfb9186864298993ef2303659d3ad":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"92046bf3cbe54ba5a3adad249c391129":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"fdecb696460a41d09ef2b92d195151a7":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","model_module_version":"1.5.0","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"d6da336731144c97a9964d79edd69d5a":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","model_module_version":"1.2.0","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}}}}},"nbformat":4,"nbformat_minor":0}
\ No newline at end of file
+{"cells":[{"cell_type":"code","execution_count":1,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1640501127635,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kH3FIMbaeurU"},"outputs":[],"source":["# install torch fidelity for FID, ISC score \n","# https://github.com/toshas/torch-fidelity\n","# https://torch-fidelity.readthedocs.io/en/latest/precision.html"]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":13,"status":"ok","timestamp":1640501127636,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"SaxqLs7gCaEU","outputId":"3d0df665-6575-42cc-bd36-5ca290fa7847"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:45:26 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4130,"status":"ok","timestamp":1640501131760,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"HZWvvcctdl0L","outputId":"6291e994-9a23-43ae-b378-5853495a9c48"},"outputs":[{"name":"stdout","output_type":"stream","text":["Requirement already satisfied: dalle-pytorch in /usr/local/lib/python3.7/dist-packages (1.1.6)\n","Requirement already satisfied: youtokentome in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.0.6)\n","Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.10.0+cu111)\n","Requirement already satisfied: rotary-embedding-torch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.2)\n","Requirement already satisfied: DALL-E in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1)\n","Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (6.0.3)\n","Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.11.1+cu111)\n","Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (2019.12.20)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (7.1.2)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.62.3)\n","Requirement already satisfied: axial-positional-embedding in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.2.1)\n","Requirement already satisfied: WebDataset in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.103)\n","Requirement already satisfied: einops>=0.3.2 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.3.2)\n","Requirement already satisfied: taming-transformers-rom1504 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.0.6)\n","Requirement already satisfied: tokenizers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.10.3)\n","Requirement already satisfied: g-mlp-pytorch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.5)\n","Requirement already satisfied: transformers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.15.0)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.6->dalle-pytorch) (3.10.0.2)\n","Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (3.6.4)\n","Requirement already satisfied: blobfile in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.2.7)\n","Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (2.23.0)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.19.5)\n","Requirement already satisfied: mypy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (0.930)\n","Requirement already satisfied: xmltodict~=0.12.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: filelock~=3.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.4.0)\n","Requirement already satisfied: urllib3~=1.25 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (1.25.11)\n","Requirement already satisfied: pycryptodomex~=3.8 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.12.0)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->dalle-pytorch) (0.2.5)\n","Requirement already satisfied: typed-ast<2,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.5.1)\n","Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.2.2)\n","Requirement already satisfied: mypy-extensions>=0.4.3 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (0.4.3)\n","Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (21.2.0)\n","Requirement already satisfied: py>=1.5.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.11.0)\n","Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.15.0)\n","Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (8.12.0)\n","Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (0.7.1)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (57.4.0)\n","Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.4.0)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2.10)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (3.0.4)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2021.10.8)\n","Requirement already satisfied: pytorch-lightning>=1.0.8 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (1.5.7)\n","Requirement already satisfied: omegaconf>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (2.1.1)\n","Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (6.0)\n","Requirement already satisfied: antlr4-python3-runtime==4.8 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: torchmetrics>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.2)\n","Requirement already satisfied: fsspec[http]!=2021.06.0,>=2021.05.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2021.11.1)\n","Requirement already satisfied: future>=0.17.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.18.2)\n","Requirement already satisfied: tensorboard>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.7.0)\n","Requirement already satisfied: pyDeprecate==0.3.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.3.1)\n","Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (21.3)\n","Requirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.8.1)\n","Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=17.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.0.6)\n","Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.17.3)\n","Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.8.0)\n","Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.1)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.35.0)\n","Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.37.0)\n","Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.0.1)\n","Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.42.0)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.6)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.3.6)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.2.4)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.3.0)\n","Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8.2)\n","Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.6.0)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.8)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.1.1)\n","Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (5.2.0)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.7.2)\n","Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.0.2)\n","Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.0.8)\n","Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.13.0)\n","Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.2.1)\n","Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.0.46)\n","Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (7.1.2)\n","Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (1.1.0)\n","Requirement already satisfied: braceexpand in /usr/local/lib/python3.7/dist-packages (from WebDataset->dalle-pytorch) (0.1.7)\n"]}],"source":["!pip install dalle-pytorch --upgrade"]},{"cell_type":"markdown","metadata":{"id":"MUGz_NZE_qCV"},"source":["### Restart runtime from here"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":22561,"status":"ok","timestamp":1640501154315,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kpnzNia6eQjO","outputId":"7ea129c7-7bd2-4cea-840b-15a1f6535f26"},"outputs":[{"name":"stdout","output_type":"stream","text":["Mounted at /content/drive\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"code","execution_count":5,"metadata":{"executionInfo":{"elapsed":5133,"status":"ok","timestamp":1640501159438,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FsftdmCPETVT"},"outputs":[],"source":["import torch\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","%config InlineBackend.figure_format = 'retina'"]},{"cell_type":"markdown","metadata":{"id":"vy19ZEl9ETVW"},"source":[]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501159439,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6XbxsJr9ETVY","outputId":"78a39e9b-a28b-4c2d-866d-841792cef975"},"outputs":[{"name":"stdout","output_type":"stream","text":["Random Seed:  999\n"]},{"data":{"text/plain":["<torch._C.Generator at 0x7f6fa0868b10>"]},"execution_count":6,"metadata":{},"output_type":"execute_result"}],"source":["from __future__ import print_function\n","import random\n","import torch.nn.parallel\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","# https://stackoverflow.com/questions/12984426/pil-ioerror-image-file-truncated-with-big-images\n","# ImageFile.LOAD_TRUNCATED_IMAGES = True\n","\n","# Set random seed for reproducibility\n","manualSeed = 999\n","#manualSeed = random.randint(1, 10000) # use if you want new results\n","print(\"Random Seed: \", manualSeed)\n","random.seed(manualSeed)\n","torch.manual_seed(manualSeed)"]},{"cell_type":"code","execution_count":7,"metadata":{"executionInfo":{"elapsed":5,"status":"ok","timestamp":1640501159439,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"HRY3CzvqETVZ"},"outputs":[],"source":["from easydict import EasyDict\n","\n","# constants\n","\n","VAE_CFG = EasyDict()\n","\n","VAE_CFG.IMAGE_SIZE = 256\n","VAE_CFG.IMAGE_PATH = './'\n","\n","VAE_CFG.BASELINE = False"]},{"cell_type":"code","execution_count":8,"metadata":{"executionInfo":{"elapsed":952,"status":"ok","timestamp":1640501160387,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"IvtOi_BfETVZ"},"outputs":[],"source":["from random import choice\n","from pathlib import Path\n","\n","# torch\n","\n","import torch\n","from torch.optim import Adam\n","from torch.nn.utils import clip_grad_norm_\n","\n","# vision imports\n","\n","from PIL import Image\n","from torchvision import transforms as T\n","from torch.utils.data import DataLoader, Dataset\n","from torchvision.datasets import ImageFolder\n","from torchvision.utils import make_grid, save_image\n","\n","# dalle related classes and utils\n","\n","from dalle_pytorch import OpenAIDiscreteVAE, DiscreteVAE, DALLE\n","\n","# helpers\n","\n","def exists(val):\n","    return val is not None"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"executionInfo":{"elapsed":13139,"status":"ok","timestamp":1640501173523,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"TubuiCYeeNbz","outputId":"4e5b5306-57ea-4342-ead4-48448bf96bbc"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./VQGAN_blue.yaml'"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["import shutil\n","\n","vqgan_best_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue_e7\"\n","shutil.copy(vqgan_best_path, \"./\")\n","\n","vqgan_best_yaml_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue.yaml\"\n","shutil.copy(vqgan_best_yaml_path, \"./\")"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"executionInfo":{"elapsed":93806,"status":"ok","timestamp":1640501267325,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FuW7cjLdmVuV","outputId":"811d2f3f-6b91-492d-8cf3-22423e5a36e8"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./dalle_vq_blue_e7_final.pt'"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["dalle_best_path = \"/content/drive/MyDrive/K-Fashion/DALLE Models/dalle_vq_blue_e7_final.pt\"\n","shutil.copy(dalle_best_path, \"./\")"]},{"cell_type":"code","execution_count":11,"metadata":{"executionInfo":{"elapsed":8,"status":"ok","timestamp":1640501267325,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"hs5_QzNpETVa"},"outputs":[],"source":["from easydict import EasyDict\n","import os\n","\n","DALLE_CFG = EasyDict()\n","\n","# argument parsing\n","\n","# DALLE_CFG.VQGAN_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/last_51485_step.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_PATH = os.path.basename(vqgan_best_path)\n","# DALLE_CFG.VQGAN_CFG_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/2021-12-15T16-24-36-project.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_CFG_PATH = os.path.basename(vqgan_best_yaml_path)\n","DALLE_CFG.DALLE_PATH = os.path.basename(dalle_best_path)   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n","DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n","DALLE_CFG.BPE_PATH = None\n","DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n","\n","# DALLE_CFG.EPOCHS = 20\n","# DALLE_CFG.BATCH_SIZE = 54\n","DALLE_CFG.LEARNING_RATE = 3e-4\n","DALLE_CFG.GRAD_CLIP_NORM = 0.5\n","\n","# DALLE_CFG.MODEL_DIM = 512\n","DALLE_CFG.TEXT_SEQ_LEN = 128\n","DALLE_CFG.DEPTH = 2\n","DALLE_CFG.HEADS = 8\n","DALLE_CFG.DIM_HEAD = 64\n","DALLE_CFG.REVERSIBLE = True"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501267326,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"URMpwTL5ETVb","outputId":"d81d234b-16ce-4982-ae64-6f0d1ba34ac1"},"outputs":[{"data":{"text/plain":["True"]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["DALLE_CFG.RESUME"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["b737a3077a5844039a6be0f7027b8529","789520acf8c6443c87eb3159ee5a94f1","a092a22fbef44f96a3818b46b07eb83b","bdb5685a0b414e65a82b1778930e3747","b5649869ea9f461a989a58b5aae78608","de92258c01bc4f21b78e1e74efff9063","71b99fb5f37743558d660aa4ac53e587","682c5233b6bc4c96a2e75bd0c5aeb02a","fce9b529a2c8491a96b1a82b8de634dc","83f744eab718483f9c9e604e67f365cd","056f5acf9bd34054868b95e06b35350e","cb36498cf7db4aa0b4f601f05d088a8f","b64b4eb7046f48cda8b98661ac77b3aa","355e86971e0f4f7aa134fe70bd3ac8b0","98af5a89118243d3b1dbd71fcab90395","4755a06ad8dc4f14aeb1363052a576d7","e92c525df9194f9b82d3c0607bfb3f97","a44149a8e39048acbd184036aeffd52b","e75ea3ec61524e9c9f9a12a449866aac","b46403218cf942d98715083a75dcad87","e31f637aaa114f3e9d4e8036a85a75a4","1b257065d0ef40eeb4f43c5a22ec91d2","cfef0fae7f0849ba93242651ce3d9dee","4e857c5654f3406fa4b49dfb45348a02","f33abf69f5924492a6f50b75b60cef4d","14ef623da96e443e8d985870052a59e9","39ff2b3eb62348fa8884d2f64d829dad","fa6f0f6b0bab4ab6afe48f52ccc0f218","bbca27254b1040e69ed0c824239fa250","f20fd195724b4d979e7e202e7e422ba6","d9fed9c7866849d585db5cc936b58d57","ea58905965844e06b6f9b8344cf1cb7b","4ea034953e6e4c9f8739a0d811513532","b3ccc40ffd8f48fe81957f480f6e6815","b1b9d3f604104dac97e57ff73489d32c","71039a160e29436b928f22c477db2e41","db1ff5fe3e3d4af58593c5573bbc6f75","9addf47d6953415da7dbabf730acfc16","7cbc74df100d439b82f3be2c0e2c3b54","be3d477b33484cbaab304ca97cf63378","cca1beb5ef98445e8db63224a8783011","cce09cfcc961488aacf95f26158480c0","cd346231832d4029b8cbccfd444fb805","4b603c2753094e05a024429d00ca4cf1"]},"executionInfo":{"elapsed":12115,"status":"ok","timestamp":1640501279436,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6aPRTq1GETVb","outputId":"b9896041-3caf-4f3c-8c49-058e96394de2"},"outputs":[{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b737a3077a5844039a6be0f7027b8529","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/375 [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cb36498cf7db4aa0b4f601f05d088a8f","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/243k [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cfef0fae7f0849ba93242651ce3d9dee","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/734k [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b3ccc40ffd8f48fe81957f480f6e6815","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/173 [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"}],"source":["# import from huggingface transformers\n","from transformers import AutoTokenizer, AutoModelWithLMHead\n","\n","tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n","# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":19,"status":"ok","timestamp":1640501279437,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"YZXRsVJ4BWeF","outputId":"e3dac17e-17b5-47ce-e8fc-0111e7099cff"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:47:58 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":171,"referenced_widgets":["bfa7edd8caff48f7be2fe4ad34f62ac1","fa6e1babb7ea4a02b1379d1f293184bd","0f682f4dc3284534b6be9e10ea619d2b","eabb6eea5950458ab41116a1525acedc","d1f42d328f674043a71b4d7406843511","3a5ce6f768cf42359be9b1edef7fc272","0a3039e5606b4eceab025c42b99b79ed","008bfb9186864298993ef2303659d3ad","92046bf3cbe54ba5a3adad249c391129","fdecb696460a41d09ef2b92d195151a7","d6da336731144c97a9964d79edd69d5a"]},"executionInfo":{"elapsed":59054,"status":"ok","timestamp":1640501338487,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"a08tUVpeETVc","outputId":"830042b9-8796-4d50-83a1-5e20b5d5f338"},"outputs":[{"name":"stdout","output_type":"stream","text":["Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n"]},{"name":"stderr","output_type":"stream","text":["Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"bfa7edd8caff48f7be2fe4ad34f62ac1","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0.00/528M [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Downloading vgg_lpips model from https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1 to taming/modules/autoencoder/lpips/vgg.pth\n"]},{"name":"stderr","output_type":"stream","text":["8.19kB [00:00, 79.8kB/s]\n"]},{"name":"stdout","output_type":"stream","text":["loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n","VQLPIPSWithDiscriminator running with hinge loss.\n","Loaded VQGAN from VQGAN_blue_e7 and VQGAN_blue.yaml\n"]}],"source":["from dalle_pytorch import VQGanVAE\n","from pathlib import Path\n","\n","DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n","\n","dalle_path = Path(DALLE_CFG.DALLE_PATH)\n","assert dalle_path.exists(), 'DALL-E model file does not exist'\n","\n","loaded_obj = torch.load(str(dalle_path), map_location=torch.device('cuda:0'))\n","\n","dalle_params, vae_params, weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n","\n","vae_klass = VQGanVAE\n","vae = vae_klass(\n","    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n","    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n","    )\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size\n","\n","dalle_params = dict(        \n","    **dalle_params\n",")\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":9,"status":"ok","timestamp":1640501338488,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"dDIPEJORETVd","outputId":"750b7ca1-df18-4a95-9fff-b7ebb772ddad"},"outputs":[{"data":{"text/plain":["{'attn_dropout': 0,\n"," 'attn_types': ('full',),\n"," 'depth': 16,\n"," 'dim_head': 64,\n"," 'ff_dropout': 0,\n"," 'heads': 8,\n"," 'loss_img_weight': 7,\n"," 'num_text_tokens': 32000,\n"," 'reversible': False,\n"," 'rotary_emb': False,\n"," 'shift_tokens': False,\n"," 'stable': False,\n"," 'text_seq_len': 128}"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["dalle_params"]},{"cell_type":"code","execution_count":17,"metadata":{"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501338488,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FJhjwhNsETVd"},"outputs":[],"source":["from math import log2, sqrt\n","import torch\n","from torch import nn, einsum\n","import torch.nn.functional as F\n","import numpy as np\n","\n","from axial_positional_embedding import AxialPositionalEmbedding\n","from einops import rearrange\n","\n","from dalle_pytorch import distributed_utils\n","from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE\n","from dalle_pytorch.transformer import Transformer, DivideMax\n","from dalle_pytorch.attention import stable_softmax\n","from model import DALLE_Klue_Roberta"]},{"cell_type":"code","execution_count":20,"metadata":{"executionInfo":{"elapsed":5478,"status":"ok","timestamp":1640501344480,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6LfuuBVcBGfq"},"outputs":[],"source":["import shutil\n","\n","roberta_wte = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wte.pt\"\n","shutil.copy(roberta_wte, \"./\")\n","\n","roberta_wpe = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wpe.pt\"\n","shutil.copy(roberta_wpe, \"./\")\n","\n","ROBERTA_WTE_PATH = os.path.basename(roberta_wte)\n","ROBERTA_WPE_PATH = os.path.basename(roberta_wpe)"]},{"cell_type":"code","execution_count":21,"metadata":{"executionInfo":{"elapsed":3297,"status":"ok","timestamp":1640501347773,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kCdxwf1jrdZd"},"outputs":[],"source":["from google.colab import drive\n","drive.flush_and_unmount()"]},{"cell_type":"code","execution_count":22,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":5733,"status":"ok","timestamp":1640501353503,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"yjbIh82bETVg","outputId":"960190b5-8a0a-42b9-f274-1e85b98972b3"},"outputs":[{"name":"stdout","output_type":"stream","text":["1024 16 16\n"]},{"data":{"text/plain":["<All keys matched successfully>"]},"execution_count":22,"metadata":{},"output_type":"execute_result"}],"source":["device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n","dalle = DALLE_Klue_Roberta(\n","    vae = vae, \n","    wte_dir=\"./roberta_large_wte.pt\",\n","    wpe_dir=\"./roberta_large_wpe.pt\",\n","    **dalle_params\n","    ).to(device)\n","\n","dalle.load_state_dict(weights)"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":8757,"status":"ok","timestamp":1640501449158,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"ylw54NgWETVi","outputId":"c33f64cf-7153-4a32-811f-d9bd7c17f31e"},"outputs":[{"name":"stdout","output_type":"stream","text":["CPU times: user 8.51 s, sys: 0 ns, total: 8.51 s\n","Wall time: 8.49 s\n"]}],"source":["%%time\n","input_text = \\\n","\"하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. \\\n","하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. \\\n","상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. \\\n","상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\"\n","\n","encoded_dict = tokenizer(\n","    input_text,\n","    return_tensors=\"pt\",\n","    padding=\"max_length\",\n","    truncation=True,\n","    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n","    add_special_tokens=True,\n","    return_token_type_ids=False,  # for RoBERTa\n",")\n","input_ids = encoded_dict[\"input_ids\"].to(device)\n","attention_mask = encoded_dict[\"attention_mask\"].to(device)\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n","# 12 minutes for K11\n","images = dalle.generate_images(input_ids, mask = attention_mask)\n","images.shape # (4, 3, 256, 256)"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1640501363505,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"Hvd5nC5vvZWR","outputId":"f2036fd9-0aac-4f0a-ad4d-886125cf355d"},"outputs":[{"data":{"text/plain":["tensor([[    0, 19975, 27135,  8817,  2073, 11150, 28674,    18, 19975, 27135,\n","         14346,  2170,  2259, 24631,  2128, 28674,    18, 19975, 27135,  4642,\n","          2170,  2259, 13859, 28674,    18, 19975, 27135, 17107,  2170,  2259,\n","          8482, 28674,    18, 19975, 27135,  1887,  2073,   766,  2149, 28674,\n","            18, 10346, 27135, 10653,  2073,   766,  2149, 28674,    18, 10346,\n","         27135,  8817,  2073,  7482, 28674,    18, 10346, 27135, 29952,  2073,\n","         10727,  2600,  4893,  2062,    18, 10346, 27135, 14346,  2170,  2259,\n","          9742, 28674,    18, 10346, 27135,  8696,  2015,  2121,  2073,   646,\n","         31286,  2062,    18, 10346, 27135,  4642,  2170,  2259,  1469,  2862,\n","         28674,    18,     2,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1]],\n","       device='cuda:0')"]},"execution_count":24,"metadata":{},"output_type":"execute_result"}],"source":["input_ids"]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":345},"executionInfo":{"elapsed":1160,"status":"ok","timestamp":1640501462251,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"7Qr2RZ8gETVi","outputId":"6fb9c672-bbd6-4801-e2e1-fbe70339d0e1"},"outputs":[{"name":"stdout","output_type":"stream","text":["하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. 상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\n"]},{"data":{"image/png":"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","text/plain":["<PIL.Image.Image image mode=RGB size=256x256 at 0x7F6E48437A50>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["CPU times: user 38.7 ms, sys: 0 ns, total: 38.7 ms\n","Wall time: 40.2 ms\n"]}],"source":["%%time\n","from torchvision.utils import make_grid, save_image\n","from PIL import Image\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/e1d10b9163ce78bacb5d8b42126255a0a8cdea35/generate.py#L93-L130\n","grid = make_grid(images, nrow=1, padding=0, pad_value=0)\n","ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n","im = Image.fromarray(ndarr)\n","\n","print(input_text)\n","display(im)"]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":14,"status":"ok","timestamp":1640501363506,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"53_I9cG7ETVj","outputId":"e444fbe5-4274-488b-ab81-42dbac003667"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:49:22 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   39C    P0    39W / 250W |   9279MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":26,"metadata":{"executionInfo":{"elapsed":9,"status":"ok","timestamp":1640501363507,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"eu5cjiEzwaVf"},"outputs":[],"source":[]}],"metadata":{"accelerator":"GPU","colab":{"collapsed_sections":[],"name":"inference_blue.ipynb","provenance":[]},"interpreter":{"hash":"546ac3bc9ff8ae035b2d532deb5ff1f925751c91c859447d340e61cadcd4cd28"},"kernelspec":{"display_name":"Python 3.8.5 64-bit ('taming': conda)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.5"},"orig_nbformat":4,"widgets":{"application/vnd.jupyter.widget-state+json":{"008bfb9186864298993ef2303659d3ad":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"056f5acf9bd34054868b95e06b35350e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0a3039e5606b4eceab025c42b99b79ed":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0f682f4dc3284534b6be9e10ea619d2b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_0a3039e5606b4eceab025c42b99b79ed","placeholder":"​","style":"IPY_MODEL_3a5ce6f768cf42359be9b1edef7fc272","value":"100%"}},"14ef623da96e443e8d985870052a59e9":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_d9fed9c7866849d585db5cc936b58d57","max":751504,"min":0,"orientation":"horizontal","style":"IPY_MODEL_f20fd195724b4d979e7e202e7e422ba6","value":751504}},"1b257065d0ef40eeb4f43c5a22ec91d2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"355e86971e0f4f7aa134fe70bd3ac8b0":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_a44149a8e39048acbd184036aeffd52b","placeholder":"​","style":"IPY_MODEL_e92c525df9194f9b82d3c0607bfb3f97","value":"Downloading: 100%"}},"39ff2b3eb62348fa8884d2f64d829dad":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_4ea034953e6e4c9f8739a0d811513532","placeholder":"​","style":"IPY_MODEL_ea58905965844e06b6f9b8344cf1cb7b","value":" 734k/734k [00:01&lt;00:00, 1.06MB/s]"}},"3a5ce6f768cf42359be9b1edef7fc272":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"4755a06ad8dc4f14aeb1363052a576d7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_1b257065d0ef40eeb4f43c5a22ec91d2","placeholder":"​","style":"IPY_MODEL_e31f637aaa114f3e9d4e8036a85a75a4","value":" 243k/243k [00:00&lt;00:00, 311kB/s]"}},"4b603c2753094e05a024429d00ca4cf1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4e857c5654f3406fa4b49dfb45348a02":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4ea034953e6e4c9f8739a0d811513532":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"682c5233b6bc4c96a2e75bd0c5aeb02a":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"71039a160e29436b928f22c477db2e41":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_be3d477b33484cbaab304ca97cf63378","placeholder":"​","style":"IPY_MODEL_7cbc74df100d439b82f3be2c0e2c3b54","value":"Downloading: 100%"}},"71b99fb5f37743558d660aa4ac53e587":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"789520acf8c6443c87eb3159ee5a94f1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"7cbc74df100d439b82f3be2c0e2c3b54":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"83f744eab718483f9c9e604e67f365cd":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"92046bf3cbe54ba5a3adad249c391129":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"98af5a89118243d3b1dbd71fcab90395":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_b46403218cf942d98715083a75dcad87","max":248477,"min":0,"orientation":"horizontal","style":"IPY_MODEL_e75ea3ec61524e9c9f9a12a449866aac","value":248477}},"9addf47d6953415da7dbabf730acfc16":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_4b603c2753094e05a024429d00ca4cf1","placeholder":"​","style":"IPY_MODEL_cd346231832d4029b8cbccfd444fb805","value":" 173/173 [00:00&lt;00:00, 4.96kB/s]"}},"a092a22fbef44f96a3818b46b07eb83b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_71b99fb5f37743558d660aa4ac53e587","placeholder":"​","style":"IPY_MODEL_de92258c01bc4f21b78e1e74efff9063","value":"Downloading: 100%"}},"a44149a8e39048acbd184036aeffd52b":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b1b9d3f604104dac97e57ff73489d32c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b3ccc40ffd8f48fe81957f480f6e6815":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_71039a160e29436b928f22c477db2e41","IPY_MODEL_db1ff5fe3e3d4af58593c5573bbc6f75","IPY_MODEL_9addf47d6953415da7dbabf730acfc16"],"layout":"IPY_MODEL_b1b9d3f604104dac97e57ff73489d32c"}},"b46403218cf942d98715083a75dcad87":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b5649869ea9f461a989a58b5aae78608":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_056f5acf9bd34054868b95e06b35350e","placeholder":"​","style":"IPY_MODEL_83f744eab718483f9c9e604e67f365cd","value":" 375/375 [00:00&lt;00:00, 5.61kB/s]"}},"b64b4eb7046f48cda8b98661ac77b3aa":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b737a3077a5844039a6be0f7027b8529":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_a092a22fbef44f96a3818b46b07eb83b","IPY_MODEL_bdb5685a0b414e65a82b1778930e3747","IPY_MODEL_b5649869ea9f461a989a58b5aae78608"],"layout":"IPY_MODEL_789520acf8c6443c87eb3159ee5a94f1"}},"bbca27254b1040e69ed0c824239fa250":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bdb5685a0b414e65a82b1778930e3747":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_fce9b529a2c8491a96b1a82b8de634dc","max":375,"min":0,"orientation":"horizontal","style":"IPY_MODEL_682c5233b6bc4c96a2e75bd0c5aeb02a","value":375}},"be3d477b33484cbaab304ca97cf63378":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bfa7edd8caff48f7be2fe4ad34f62ac1":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_0f682f4dc3284534b6be9e10ea619d2b","IPY_MODEL_eabb6eea5950458ab41116a1525acedc","IPY_MODEL_d1f42d328f674043a71b4d7406843511"],"layout":"IPY_MODEL_fa6e1babb7ea4a02b1379d1f293184bd"}},"cb36498cf7db4aa0b4f601f05d088a8f":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_355e86971e0f4f7aa134fe70bd3ac8b0","IPY_MODEL_98af5a89118243d3b1dbd71fcab90395","IPY_MODEL_4755a06ad8dc4f14aeb1363052a576d7"],"layout":"IPY_MODEL_b64b4eb7046f48cda8b98661ac77b3aa"}},"cca1beb5ef98445e8db63224a8783011":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"cce09cfcc961488aacf95f26158480c0":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"cd346231832d4029b8cbccfd444fb805":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"cfef0fae7f0849ba93242651ce3d9dee":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_f33abf69f5924492a6f50b75b60cef4d","IPY_MODEL_14ef623da96e443e8d985870052a59e9","IPY_MODEL_39ff2b3eb62348fa8884d2f64d829dad"],"layout":"IPY_MODEL_4e857c5654f3406fa4b49dfb45348a02"}},"d1f42d328f674043a71b4d7406843511":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_d6da336731144c97a9964d79edd69d5a","placeholder":"​","style":"IPY_MODEL_fdecb696460a41d09ef2b92d195151a7","value":" 528M/528M [00:10&lt;00:00, 191MB/s]"}},"d6da336731144c97a9964d79edd69d5a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d9fed9c7866849d585db5cc936b58d57":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"db1ff5fe3e3d4af58593c5573bbc6f75":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_cce09cfcc961488aacf95f26158480c0","max":173,"min":0,"orientation":"horizontal","style":"IPY_MODEL_cca1beb5ef98445e8db63224a8783011","value":173}},"de92258c01bc4f21b78e1e74efff9063":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"e31f637aaa114f3e9d4e8036a85a75a4":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"e75ea3ec61524e9c9f9a12a449866aac":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"e92c525df9194f9b82d3c0607bfb3f97":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"ea58905965844e06b6f9b8344cf1cb7b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"eabb6eea5950458ab41116a1525acedc":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_92046bf3cbe54ba5a3adad249c391129","max":553433881,"min":0,"orientation":"horizontal","style":"IPY_MODEL_008bfb9186864298993ef2303659d3ad","value":553433881}},"f20fd195724b4d979e7e202e7e422ba6":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"f33abf69f5924492a6f50b75b60cef4d":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bbca27254b1040e69ed0c824239fa250","placeholder":"​","style":"IPY_MODEL_fa6f0f6b0bab4ab6afe48f52ccc0f218","value":"Downloading: 100%"}},"fa6e1babb7ea4a02b1379d1f293184bd":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"fa6f0f6b0bab4ab6afe48f52ccc0f218":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"fce9b529a2c8491a96b1a82b8de634dc":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"fdecb696460a41d09ef2b92d195151a7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}}}}},"nbformat":4,"nbformat_minor":0}

From 09bfba08cc492bcc52572f8e40e29cdc2e3d0ce3 Mon Sep 17 00:00:00 2001
From: JoonHong-Kim <danielkim30433@gmail.com>
Date: Sun, 26 Dec 2021 20:08:47 +0900
Subject: [PATCH 25/26] sty) package

---
 inference.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/inference.ipynb b/inference.ipynb
index b79b15e..1885015 100644
--- a/inference.ipynb
+++ b/inference.ipynb
@@ -1 +1 @@
-{"cells":[{"cell_type":"code","execution_count":1,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1640501127635,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kH3FIMbaeurU"},"outputs":[],"source":["# install torch fidelity for FID, ISC score \n","# https://github.com/toshas/torch-fidelity\n","# https://torch-fidelity.readthedocs.io/en/latest/precision.html"]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":13,"status":"ok","timestamp":1640501127636,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"SaxqLs7gCaEU","outputId":"3d0df665-6575-42cc-bd36-5ca290fa7847"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:45:26 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4130,"status":"ok","timestamp":1640501131760,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"HZWvvcctdl0L","outputId":"6291e994-9a23-43ae-b378-5853495a9c48"},"outputs":[{"name":"stdout","output_type":"stream","text":["Requirement already satisfied: dalle-pytorch in /usr/local/lib/python3.7/dist-packages (1.1.6)\n","Requirement already satisfied: youtokentome in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.0.6)\n","Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.10.0+cu111)\n","Requirement already satisfied: rotary-embedding-torch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.2)\n","Requirement already satisfied: DALL-E in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1)\n","Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (6.0.3)\n","Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.11.1+cu111)\n","Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (2019.12.20)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (7.1.2)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.62.3)\n","Requirement already satisfied: axial-positional-embedding in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.2.1)\n","Requirement already satisfied: WebDataset in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.103)\n","Requirement already satisfied: einops>=0.3.2 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.3.2)\n","Requirement already satisfied: taming-transformers-rom1504 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.0.6)\n","Requirement already satisfied: tokenizers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.10.3)\n","Requirement already satisfied: g-mlp-pytorch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.5)\n","Requirement already satisfied: transformers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.15.0)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.6->dalle-pytorch) (3.10.0.2)\n","Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (3.6.4)\n","Requirement already satisfied: blobfile in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.2.7)\n","Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (2.23.0)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.19.5)\n","Requirement already satisfied: mypy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (0.930)\n","Requirement already satisfied: xmltodict~=0.12.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: filelock~=3.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.4.0)\n","Requirement already satisfied: urllib3~=1.25 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (1.25.11)\n","Requirement already satisfied: pycryptodomex~=3.8 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.12.0)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->dalle-pytorch) (0.2.5)\n","Requirement already satisfied: typed-ast<2,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.5.1)\n","Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.2.2)\n","Requirement already satisfied: mypy-extensions>=0.4.3 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (0.4.3)\n","Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (21.2.0)\n","Requirement already satisfied: py>=1.5.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.11.0)\n","Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.15.0)\n","Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (8.12.0)\n","Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (0.7.1)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (57.4.0)\n","Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.4.0)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2.10)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (3.0.4)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2021.10.8)\n","Requirement already satisfied: pytorch-lightning>=1.0.8 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (1.5.7)\n","Requirement already satisfied: omegaconf>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (2.1.1)\n","Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (6.0)\n","Requirement already satisfied: antlr4-python3-runtime==4.8 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: torchmetrics>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.2)\n","Requirement already satisfied: fsspec[http]!=2021.06.0,>=2021.05.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2021.11.1)\n","Requirement already satisfied: future>=0.17.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.18.2)\n","Requirement already satisfied: tensorboard>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.7.0)\n","Requirement already satisfied: pyDeprecate==0.3.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.3.1)\n","Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (21.3)\n","Requirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.8.1)\n","Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=17.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.0.6)\n","Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.17.3)\n","Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.8.0)\n","Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.1)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.35.0)\n","Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.37.0)\n","Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.0.1)\n","Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.42.0)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.6)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.3.6)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.2.4)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.3.0)\n","Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8.2)\n","Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.6.0)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.8)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.1.1)\n","Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (5.2.0)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.7.2)\n","Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.0.2)\n","Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.0.8)\n","Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.13.0)\n","Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.2.1)\n","Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.0.46)\n","Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (7.1.2)\n","Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (1.1.0)\n","Requirement already satisfied: braceexpand in /usr/local/lib/python3.7/dist-packages (from WebDataset->dalle-pytorch) (0.1.7)\n"]}],"source":["!pip install dalle-pytorch --upgrade"]},{"cell_type":"markdown","metadata":{"id":"MUGz_NZE_qCV"},"source":["### Restart runtime from here"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":22561,"status":"ok","timestamp":1640501154315,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kpnzNia6eQjO","outputId":"7ea129c7-7bd2-4cea-840b-15a1f6535f26"},"outputs":[{"name":"stdout","output_type":"stream","text":["Mounted at /content/drive\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"code","execution_count":5,"metadata":{"executionInfo":{"elapsed":5133,"status":"ok","timestamp":1640501159438,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FsftdmCPETVT"},"outputs":[],"source":["import torch\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","%config InlineBackend.figure_format = 'retina'"]},{"cell_type":"markdown","metadata":{"id":"vy19ZEl9ETVW"},"source":[]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501159439,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6XbxsJr9ETVY","outputId":"78a39e9b-a28b-4c2d-866d-841792cef975"},"outputs":[{"name":"stdout","output_type":"stream","text":["Random Seed:  999\n"]},{"data":{"text/plain":["<torch._C.Generator at 0x7f6fa0868b10>"]},"execution_count":6,"metadata":{},"output_type":"execute_result"}],"source":["from __future__ import print_function\n","import random\n","import torch.nn.parallel\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","# https://stackoverflow.com/questions/12984426/pil-ioerror-image-file-truncated-with-big-images\n","# ImageFile.LOAD_TRUNCATED_IMAGES = True\n","\n","# Set random seed for reproducibility\n","manualSeed = 999\n","#manualSeed = random.randint(1, 10000) # use if you want new results\n","print(\"Random Seed: \", manualSeed)\n","random.seed(manualSeed)\n","torch.manual_seed(manualSeed)"]},{"cell_type":"code","execution_count":7,"metadata":{"executionInfo":{"elapsed":5,"status":"ok","timestamp":1640501159439,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"HRY3CzvqETVZ"},"outputs":[],"source":["from easydict import EasyDict\n","\n","# constants\n","\n","VAE_CFG = EasyDict()\n","\n","VAE_CFG.IMAGE_SIZE = 256\n","VAE_CFG.IMAGE_PATH = './'\n","\n","VAE_CFG.BASELINE = False"]},{"cell_type":"code","execution_count":8,"metadata":{"executionInfo":{"elapsed":952,"status":"ok","timestamp":1640501160387,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"IvtOi_BfETVZ"},"outputs":[],"source":["from random import choice\n","from pathlib import Path\n","\n","# torch\n","\n","import torch\n","from torch.optim import Adam\n","from torch.nn.utils import clip_grad_norm_\n","\n","# vision imports\n","\n","from PIL import Image\n","from torchvision import transforms as T\n","from torch.utils.data import DataLoader, Dataset\n","from torchvision.datasets import ImageFolder\n","from torchvision.utils import make_grid, save_image\n","\n","# dalle related classes and utils\n","\n","from dalle_pytorch import OpenAIDiscreteVAE, DiscreteVAE, DALLE\n","\n","# helpers\n","\n","def exists(val):\n","    return val is not None"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"executionInfo":{"elapsed":13139,"status":"ok","timestamp":1640501173523,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"TubuiCYeeNbz","outputId":"4e5b5306-57ea-4342-ead4-48448bf96bbc"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./VQGAN_blue.yaml'"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["import shutil\n","\n","vqgan_best_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue_e7\"\n","shutil.copy(vqgan_best_path, \"./\")\n","\n","vqgan_best_yaml_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue.yaml\"\n","shutil.copy(vqgan_best_yaml_path, \"./\")"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"executionInfo":{"elapsed":93806,"status":"ok","timestamp":1640501267325,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FuW7cjLdmVuV","outputId":"811d2f3f-6b91-492d-8cf3-22423e5a36e8"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./dalle_vq_blue_e7_final.pt'"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["dalle_best_path = \"/content/drive/MyDrive/K-Fashion/DALLE Models/dalle_vq_blue_e7_final.pt\"\n","shutil.copy(dalle_best_path, \"./\")"]},{"cell_type":"code","execution_count":11,"metadata":{"executionInfo":{"elapsed":8,"status":"ok","timestamp":1640501267325,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"hs5_QzNpETVa"},"outputs":[],"source":["from easydict import EasyDict\n","import os\n","\n","DALLE_CFG = EasyDict()\n","\n","# argument parsing\n","\n","# DALLE_CFG.VQGAN_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/last_51485_step.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_PATH = os.path.basename(vqgan_best_path)\n","# DALLE_CFG.VQGAN_CFG_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/2021-12-15T16-24-36-project.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_CFG_PATH = os.path.basename(vqgan_best_yaml_path)\n","DALLE_CFG.DALLE_PATH = os.path.basename(dalle_best_path)   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n","DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n","DALLE_CFG.BPE_PATH = None\n","DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n","\n","# DALLE_CFG.EPOCHS = 20\n","# DALLE_CFG.BATCH_SIZE = 54\n","DALLE_CFG.LEARNING_RATE = 3e-4\n","DALLE_CFG.GRAD_CLIP_NORM = 0.5\n","\n","# DALLE_CFG.MODEL_DIM = 512\n","DALLE_CFG.TEXT_SEQ_LEN = 128\n","DALLE_CFG.DEPTH = 2\n","DALLE_CFG.HEADS = 8\n","DALLE_CFG.DIM_HEAD = 64\n","DALLE_CFG.REVERSIBLE = True"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501267326,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"URMpwTL5ETVb","outputId":"d81d234b-16ce-4982-ae64-6f0d1ba34ac1"},"outputs":[{"data":{"text/plain":["True"]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["DALLE_CFG.RESUME"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["b737a3077a5844039a6be0f7027b8529","789520acf8c6443c87eb3159ee5a94f1","a092a22fbef44f96a3818b46b07eb83b","bdb5685a0b414e65a82b1778930e3747","b5649869ea9f461a989a58b5aae78608","de92258c01bc4f21b78e1e74efff9063","71b99fb5f37743558d660aa4ac53e587","682c5233b6bc4c96a2e75bd0c5aeb02a","fce9b529a2c8491a96b1a82b8de634dc","83f744eab718483f9c9e604e67f365cd","056f5acf9bd34054868b95e06b35350e","cb36498cf7db4aa0b4f601f05d088a8f","b64b4eb7046f48cda8b98661ac77b3aa","355e86971e0f4f7aa134fe70bd3ac8b0","98af5a89118243d3b1dbd71fcab90395","4755a06ad8dc4f14aeb1363052a576d7","e92c525df9194f9b82d3c0607bfb3f97","a44149a8e39048acbd184036aeffd52b","e75ea3ec61524e9c9f9a12a449866aac","b46403218cf942d98715083a75dcad87","e31f637aaa114f3e9d4e8036a85a75a4","1b257065d0ef40eeb4f43c5a22ec91d2","cfef0fae7f0849ba93242651ce3d9dee","4e857c5654f3406fa4b49dfb45348a02","f33abf69f5924492a6f50b75b60cef4d","14ef623da96e443e8d985870052a59e9","39ff2b3eb62348fa8884d2f64d829dad","fa6f0f6b0bab4ab6afe48f52ccc0f218","bbca27254b1040e69ed0c824239fa250","f20fd195724b4d979e7e202e7e422ba6","d9fed9c7866849d585db5cc936b58d57","ea58905965844e06b6f9b8344cf1cb7b","4ea034953e6e4c9f8739a0d811513532","b3ccc40ffd8f48fe81957f480f6e6815","b1b9d3f604104dac97e57ff73489d32c","71039a160e29436b928f22c477db2e41","db1ff5fe3e3d4af58593c5573bbc6f75","9addf47d6953415da7dbabf730acfc16","7cbc74df100d439b82f3be2c0e2c3b54","be3d477b33484cbaab304ca97cf63378","cca1beb5ef98445e8db63224a8783011","cce09cfcc961488aacf95f26158480c0","cd346231832d4029b8cbccfd444fb805","4b603c2753094e05a024429d00ca4cf1"]},"executionInfo":{"elapsed":12115,"status":"ok","timestamp":1640501279436,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6aPRTq1GETVb","outputId":"b9896041-3caf-4f3c-8c49-058e96394de2"},"outputs":[{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b737a3077a5844039a6be0f7027b8529","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/375 [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cb36498cf7db4aa0b4f601f05d088a8f","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/243k [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cfef0fae7f0849ba93242651ce3d9dee","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/734k [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b3ccc40ffd8f48fe81957f480f6e6815","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/173 [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"}],"source":["# import from huggingface transformers\n","from transformers import AutoTokenizer, AutoModelWithLMHead\n","\n","tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n","# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":19,"status":"ok","timestamp":1640501279437,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"YZXRsVJ4BWeF","outputId":"e3dac17e-17b5-47ce-e8fc-0111e7099cff"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:47:58 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":171,"referenced_widgets":["bfa7edd8caff48f7be2fe4ad34f62ac1","fa6e1babb7ea4a02b1379d1f293184bd","0f682f4dc3284534b6be9e10ea619d2b","eabb6eea5950458ab41116a1525acedc","d1f42d328f674043a71b4d7406843511","3a5ce6f768cf42359be9b1edef7fc272","0a3039e5606b4eceab025c42b99b79ed","008bfb9186864298993ef2303659d3ad","92046bf3cbe54ba5a3adad249c391129","fdecb696460a41d09ef2b92d195151a7","d6da336731144c97a9964d79edd69d5a"]},"executionInfo":{"elapsed":59054,"status":"ok","timestamp":1640501338487,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"a08tUVpeETVc","outputId":"830042b9-8796-4d50-83a1-5e20b5d5f338"},"outputs":[{"name":"stdout","output_type":"stream","text":["Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n"]},{"name":"stderr","output_type":"stream","text":["Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"bfa7edd8caff48f7be2fe4ad34f62ac1","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0.00/528M [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Downloading vgg_lpips model from https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1 to taming/modules/autoencoder/lpips/vgg.pth\n"]},{"name":"stderr","output_type":"stream","text":["8.19kB [00:00, 79.8kB/s]\n"]},{"name":"stdout","output_type":"stream","text":["loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n","VQLPIPSWithDiscriminator running with hinge loss.\n","Loaded VQGAN from VQGAN_blue_e7 and VQGAN_blue.yaml\n"]}],"source":["from dalle_pytorch import VQGanVAE\n","from pathlib import Path\n","\n","DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n","\n","dalle_path = Path(DALLE_CFG.DALLE_PATH)\n","assert dalle_path.exists(), 'DALL-E model file does not exist'\n","\n","loaded_obj = torch.load(str(dalle_path), map_location=torch.device('cuda:0'))\n","\n","dalle_params, vae_params, weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n","\n","vae_klass = VQGanVAE\n","vae = vae_klass(\n","    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n","    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n","    )\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size\n","\n","dalle_params = dict(        \n","    **dalle_params\n",")\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":9,"status":"ok","timestamp":1640501338488,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"dDIPEJORETVd","outputId":"750b7ca1-df18-4a95-9fff-b7ebb772ddad"},"outputs":[{"data":{"text/plain":["{'attn_dropout': 0,\n"," 'attn_types': ('full',),\n"," 'depth': 16,\n"," 'dim_head': 64,\n"," 'ff_dropout': 0,\n"," 'heads': 8,\n"," 'loss_img_weight': 7,\n"," 'num_text_tokens': 32000,\n"," 'reversible': False,\n"," 'rotary_emb': False,\n"," 'shift_tokens': False,\n"," 'stable': False,\n"," 'text_seq_len': 128}"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["dalle_params"]},{"cell_type":"code","execution_count":17,"metadata":{"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501338488,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FJhjwhNsETVd"},"outputs":[],"source":["from math import log2, sqrt\n","import torch\n","from torch import nn, einsum\n","import torch.nn.functional as F\n","import numpy as np\n","\n","from axial_positional_embedding import AxialPositionalEmbedding\n","from einops import rearrange\n","\n","from dalle_pytorch import distributed_utils\n","from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE\n","from dalle_pytorch.transformer import Transformer, DivideMax\n","from dalle_pytorch.attention import stable_softmax\n","from model import DALLE_Klue_Roberta"]},{"cell_type":"code","execution_count":20,"metadata":{"executionInfo":{"elapsed":5478,"status":"ok","timestamp":1640501344480,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6LfuuBVcBGfq"},"outputs":[],"source":["import shutil\n","\n","roberta_wte = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wte.pt\"\n","shutil.copy(roberta_wte, \"./\")\n","\n","roberta_wpe = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wpe.pt\"\n","shutil.copy(roberta_wpe, \"./\")\n","\n","ROBERTA_WTE_PATH = os.path.basename(roberta_wte)\n","ROBERTA_WPE_PATH = os.path.basename(roberta_wpe)"]},{"cell_type":"code","execution_count":21,"metadata":{"executionInfo":{"elapsed":3297,"status":"ok","timestamp":1640501347773,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kCdxwf1jrdZd"},"outputs":[],"source":["from google.colab import drive\n","drive.flush_and_unmount()"]},{"cell_type":"code","execution_count":22,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":5733,"status":"ok","timestamp":1640501353503,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"yjbIh82bETVg","outputId":"960190b5-8a0a-42b9-f274-1e85b98972b3"},"outputs":[{"name":"stdout","output_type":"stream","text":["1024 16 16\n"]},{"data":{"text/plain":["<All keys matched successfully>"]},"execution_count":22,"metadata":{},"output_type":"execute_result"}],"source":["device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n","dalle = DALLE_Klue_Roberta(\n","    vae = vae, \n","    wte_dir=\"./roberta_large_wte.pt\",\n","    wpe_dir=\"./roberta_large_wpe.pt\",\n","    **dalle_params\n","    ).to(device)\n","\n","dalle.load_state_dict(weights)"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":8757,"status":"ok","timestamp":1640501449158,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"ylw54NgWETVi","outputId":"c33f64cf-7153-4a32-811f-d9bd7c17f31e"},"outputs":[{"name":"stdout","output_type":"stream","text":["CPU times: user 8.51 s, sys: 0 ns, total: 8.51 s\n","Wall time: 8.49 s\n"]}],"source":["%%time\n","input_text = \\\n","\"하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. \\\n","하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. \\\n","상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. \\\n","상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\"\n","\n","encoded_dict = tokenizer(\n","    input_text,\n","    return_tensors=\"pt\",\n","    padding=\"max_length\",\n","    truncation=True,\n","    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n","    add_special_tokens=True,\n","    return_token_type_ids=False,  # for RoBERTa\n",")\n","input_ids = encoded_dict[\"input_ids\"].to(device)\n","attention_mask = encoded_dict[\"attention_mask\"].to(device)\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n","# 12 minutes for K11\n","images = dalle.generate_images(input_ids, mask = attention_mask)\n","images.shape # (4, 3, 256, 256)"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1640501363505,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"Hvd5nC5vvZWR","outputId":"f2036fd9-0aac-4f0a-ad4d-886125cf355d"},"outputs":[{"data":{"text/plain":["tensor([[    0, 19975, 27135,  8817,  2073, 11150, 28674,    18, 19975, 27135,\n","         14346,  2170,  2259, 24631,  2128, 28674,    18, 19975, 27135,  4642,\n","          2170,  2259, 13859, 28674,    18, 19975, 27135, 17107,  2170,  2259,\n","          8482, 28674,    18, 19975, 27135,  1887,  2073,   766,  2149, 28674,\n","            18, 10346, 27135, 10653,  2073,   766,  2149, 28674,    18, 10346,\n","         27135,  8817,  2073,  7482, 28674,    18, 10346, 27135, 29952,  2073,\n","         10727,  2600,  4893,  2062,    18, 10346, 27135, 14346,  2170,  2259,\n","          9742, 28674,    18, 10346, 27135,  8696,  2015,  2121,  2073,   646,\n","         31286,  2062,    18, 10346, 27135,  4642,  2170,  2259,  1469,  2862,\n","         28674,    18,     2,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1]],\n","       device='cuda:0')"]},"execution_count":24,"metadata":{},"output_type":"execute_result"}],"source":["input_ids"]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":345},"executionInfo":{"elapsed":1160,"status":"ok","timestamp":1640501462251,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"7Qr2RZ8gETVi","outputId":"6fb9c672-bbd6-4801-e2e1-fbe70339d0e1"},"outputs":[{"name":"stdout","output_type":"stream","text":["하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. 상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\n"]},{"data":{"image/png":"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","text/plain":["<PIL.Image.Image image mode=RGB size=256x256 at 0x7F6E48437A50>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["CPU times: user 38.7 ms, sys: 0 ns, total: 38.7 ms\n","Wall time: 40.2 ms\n"]}],"source":["%%time\n","from torchvision.utils import make_grid, save_image\n","from PIL import Image\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/e1d10b9163ce78bacb5d8b42126255a0a8cdea35/generate.py#L93-L130\n","grid = make_grid(images, nrow=1, padding=0, pad_value=0)\n","ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n","im = Image.fromarray(ndarr)\n","\n","print(input_text)\n","display(im)"]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":14,"status":"ok","timestamp":1640501363506,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"53_I9cG7ETVj","outputId":"e444fbe5-4274-488b-ab81-42dbac003667"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:49:22 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   39C    P0    39W / 250W |   9279MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":26,"metadata":{"executionInfo":{"elapsed":9,"status":"ok","timestamp":1640501363507,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"eu5cjiEzwaVf"},"outputs":[],"source":[]}],"metadata":{"accelerator":"GPU","colab":{"collapsed_sections":[],"name":"inference_blue.ipynb","provenance":[]},"interpreter":{"hash":"546ac3bc9ff8ae035b2d532deb5ff1f925751c91c859447d340e61cadcd4cd28"},"kernelspec":{"display_name":"Python 3.8.5 64-bit ('taming': conda)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.5"},"orig_nbformat":4,"widgets":{"application/vnd.jupyter.widget-state+json":{"008bfb9186864298993ef2303659d3ad":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"056f5acf9bd34054868b95e06b35350e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0a3039e5606b4eceab025c42b99b79ed":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0f682f4dc3284534b6be9e10ea619d2b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_0a3039e5606b4eceab025c42b99b79ed","placeholder":"​","style":"IPY_MODEL_3a5ce6f768cf42359be9b1edef7fc272","value":"100%"}},"14ef623da96e443e8d985870052a59e9":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_d9fed9c7866849d585db5cc936b58d57","max":751504,"min":0,"orientation":"horizontal","style":"IPY_MODEL_f20fd195724b4d979e7e202e7e422ba6","value":751504}},"1b257065d0ef40eeb4f43c5a22ec91d2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"355e86971e0f4f7aa134fe70bd3ac8b0":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_a44149a8e39048acbd184036aeffd52b","placeholder":"​","style":"IPY_MODEL_e92c525df9194f9b82d3c0607bfb3f97","value":"Downloading: 100%"}},"39ff2b3eb62348fa8884d2f64d829dad":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_4ea034953e6e4c9f8739a0d811513532","placeholder":"​","style":"IPY_MODEL_ea58905965844e06b6f9b8344cf1cb7b","value":" 734k/734k [00:01&lt;00:00, 1.06MB/s]"}},"3a5ce6f768cf42359be9b1edef7fc272":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"4755a06ad8dc4f14aeb1363052a576d7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_1b257065d0ef40eeb4f43c5a22ec91d2","placeholder":"​","style":"IPY_MODEL_e31f637aaa114f3e9d4e8036a85a75a4","value":" 243k/243k [00:00&lt;00:00, 311kB/s]"}},"4b603c2753094e05a024429d00ca4cf1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4e857c5654f3406fa4b49dfb45348a02":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4ea034953e6e4c9f8739a0d811513532":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"682c5233b6bc4c96a2e75bd0c5aeb02a":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"71039a160e29436b928f22c477db2e41":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_be3d477b33484cbaab304ca97cf63378","placeholder":"​","style":"IPY_MODEL_7cbc74df100d439b82f3be2c0e2c3b54","value":"Downloading: 100%"}},"71b99fb5f37743558d660aa4ac53e587":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"789520acf8c6443c87eb3159ee5a94f1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"7cbc74df100d439b82f3be2c0e2c3b54":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"83f744eab718483f9c9e604e67f365cd":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"92046bf3cbe54ba5a3adad249c391129":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"98af5a89118243d3b1dbd71fcab90395":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_b46403218cf942d98715083a75dcad87","max":248477,"min":0,"orientation":"horizontal","style":"IPY_MODEL_e75ea3ec61524e9c9f9a12a449866aac","value":248477}},"9addf47d6953415da7dbabf730acfc16":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_4b603c2753094e05a024429d00ca4cf1","placeholder":"​","style":"IPY_MODEL_cd346231832d4029b8cbccfd444fb805","value":" 173/173 [00:00&lt;00:00, 4.96kB/s]"}},"a092a22fbef44f96a3818b46b07eb83b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_71b99fb5f37743558d660aa4ac53e587","placeholder":"​","style":"IPY_MODEL_de92258c01bc4f21b78e1e74efff9063","value":"Downloading: 100%"}},"a44149a8e39048acbd184036aeffd52b":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b1b9d3f604104dac97e57ff73489d32c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b3ccc40ffd8f48fe81957f480f6e6815":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_71039a160e29436b928f22c477db2e41","IPY_MODEL_db1ff5fe3e3d4af58593c5573bbc6f75","IPY_MODEL_9addf47d6953415da7dbabf730acfc16"],"layout":"IPY_MODEL_b1b9d3f604104dac97e57ff73489d32c"}},"b46403218cf942d98715083a75dcad87":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b5649869ea9f461a989a58b5aae78608":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_056f5acf9bd34054868b95e06b35350e","placeholder":"​","style":"IPY_MODEL_83f744eab718483f9c9e604e67f365cd","value":" 375/375 [00:00&lt;00:00, 5.61kB/s]"}},"b64b4eb7046f48cda8b98661ac77b3aa":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b737a3077a5844039a6be0f7027b8529":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_a092a22fbef44f96a3818b46b07eb83b","IPY_MODEL_bdb5685a0b414e65a82b1778930e3747","IPY_MODEL_b5649869ea9f461a989a58b5aae78608"],"layout":"IPY_MODEL_789520acf8c6443c87eb3159ee5a94f1"}},"bbca27254b1040e69ed0c824239fa250":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bdb5685a0b414e65a82b1778930e3747":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_fce9b529a2c8491a96b1a82b8de634dc","max":375,"min":0,"orientation":"horizontal","style":"IPY_MODEL_682c5233b6bc4c96a2e75bd0c5aeb02a","value":375}},"be3d477b33484cbaab304ca97cf63378":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bfa7edd8caff48f7be2fe4ad34f62ac1":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_0f682f4dc3284534b6be9e10ea619d2b","IPY_MODEL_eabb6eea5950458ab41116a1525acedc","IPY_MODEL_d1f42d328f674043a71b4d7406843511"],"layout":"IPY_MODEL_fa6e1babb7ea4a02b1379d1f293184bd"}},"cb36498cf7db4aa0b4f601f05d088a8f":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_355e86971e0f4f7aa134fe70bd3ac8b0","IPY_MODEL_98af5a89118243d3b1dbd71fcab90395","IPY_MODEL_4755a06ad8dc4f14aeb1363052a576d7"],"layout":"IPY_MODEL_b64b4eb7046f48cda8b98661ac77b3aa"}},"cca1beb5ef98445e8db63224a8783011":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"cce09cfcc961488aacf95f26158480c0":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"cd346231832d4029b8cbccfd444fb805":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"cfef0fae7f0849ba93242651ce3d9dee":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_f33abf69f5924492a6f50b75b60cef4d","IPY_MODEL_14ef623da96e443e8d985870052a59e9","IPY_MODEL_39ff2b3eb62348fa8884d2f64d829dad"],"layout":"IPY_MODEL_4e857c5654f3406fa4b49dfb45348a02"}},"d1f42d328f674043a71b4d7406843511":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_d6da336731144c97a9964d79edd69d5a","placeholder":"​","style":"IPY_MODEL_fdecb696460a41d09ef2b92d195151a7","value":" 528M/528M [00:10&lt;00:00, 191MB/s]"}},"d6da336731144c97a9964d79edd69d5a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d9fed9c7866849d585db5cc936b58d57":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"db1ff5fe3e3d4af58593c5573bbc6f75":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_cce09cfcc961488aacf95f26158480c0","max":173,"min":0,"orientation":"horizontal","style":"IPY_MODEL_cca1beb5ef98445e8db63224a8783011","value":173}},"de92258c01bc4f21b78e1e74efff9063":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"e31f637aaa114f3e9d4e8036a85a75a4":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"e75ea3ec61524e9c9f9a12a449866aac":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"e92c525df9194f9b82d3c0607bfb3f97":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"ea58905965844e06b6f9b8344cf1cb7b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"eabb6eea5950458ab41116a1525acedc":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_92046bf3cbe54ba5a3adad249c391129","max":553433881,"min":0,"orientation":"horizontal","style":"IPY_MODEL_008bfb9186864298993ef2303659d3ad","value":553433881}},"f20fd195724b4d979e7e202e7e422ba6":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"f33abf69f5924492a6f50b75b60cef4d":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bbca27254b1040e69ed0c824239fa250","placeholder":"​","style":"IPY_MODEL_fa6f0f6b0bab4ab6afe48f52ccc0f218","value":"Downloading: 100%"}},"fa6e1babb7ea4a02b1379d1f293184bd":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"fa6f0f6b0bab4ab6afe48f52ccc0f218":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"fce9b529a2c8491a96b1a82b8de634dc":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"fdecb696460a41d09ef2b92d195151a7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}}}}},"nbformat":4,"nbformat_minor":0}
+{"cells":[{"cell_type":"code","execution_count":1,"metadata":{"executionInfo":{"elapsed":13,"status":"ok","timestamp":1640501127635,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kH3FIMbaeurU"},"outputs":[],"source":["# install torch fidelity for FID, ISC score \n","# https://github.com/toshas/torch-fidelity\n","# https://torch-fidelity.readthedocs.io/en/latest/precision.html"]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":13,"status":"ok","timestamp":1640501127636,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"SaxqLs7gCaEU","outputId":"3d0df665-6575-42cc-bd36-5ca290fa7847"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:45:26 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4130,"status":"ok","timestamp":1640501131760,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"HZWvvcctdl0L","outputId":"6291e994-9a23-43ae-b378-5853495a9c48"},"outputs":[{"name":"stdout","output_type":"stream","text":["Requirement already satisfied: dalle-pytorch in /usr/local/lib/python3.7/dist-packages (1.1.6)\n","Requirement already satisfied: youtokentome in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.0.6)\n","Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (1.10.0+cu111)\n","Requirement already satisfied: rotary-embedding-torch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.2)\n","Requirement already satisfied: DALL-E in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1)\n","Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (6.0.3)\n","Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.11.1+cu111)\n","Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (2019.12.20)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (7.1.2)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.62.3)\n","Requirement already satisfied: axial-positional-embedding in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.2.1)\n","Requirement already satisfied: WebDataset in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.103)\n","Requirement already satisfied: einops>=0.3.2 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.3.2)\n","Requirement already satisfied: taming-transformers-rom1504 in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.0.6)\n","Requirement already satisfied: tokenizers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.10.3)\n","Requirement already satisfied: g-mlp-pytorch in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (0.1.5)\n","Requirement already satisfied: transformers in /usr/local/lib/python3.7/dist-packages (from dalle-pytorch) (4.15.0)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.6->dalle-pytorch) (3.10.0.2)\n","Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (3.6.4)\n","Requirement already satisfied: blobfile in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.2.7)\n","Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (2.23.0)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (1.19.5)\n","Requirement already satisfied: mypy in /usr/local/lib/python3.7/dist-packages (from DALL-E->dalle-pytorch) (0.930)\n","Requirement already satisfied: xmltodict~=0.12.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: filelock~=3.0 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.4.0)\n","Requirement already satisfied: urllib3~=1.25 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (1.25.11)\n","Requirement already satisfied: pycryptodomex~=3.8 in /usr/local/lib/python3.7/dist-packages (from blobfile->DALL-E->dalle-pytorch) (3.12.0)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->dalle-pytorch) (0.2.5)\n","Requirement already satisfied: typed-ast<2,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.5.1)\n","Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (1.2.2)\n","Requirement already satisfied: mypy-extensions>=0.4.3 in /usr/local/lib/python3.7/dist-packages (from mypy->DALL-E->dalle-pytorch) (0.4.3)\n","Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (21.2.0)\n","Requirement already satisfied: py>=1.5.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.11.0)\n","Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.15.0)\n","Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (8.12.0)\n","Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (0.7.1)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (57.4.0)\n","Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->DALL-E->dalle-pytorch) (1.4.0)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2.10)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (3.0.4)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->DALL-E->dalle-pytorch) (2021.10.8)\n","Requirement already satisfied: pytorch-lightning>=1.0.8 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (1.5.7)\n","Requirement already satisfied: omegaconf>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from taming-transformers-rom1504->dalle-pytorch) (2.1.1)\n","Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (6.0)\n","Requirement already satisfied: antlr4-python3-runtime==4.8 in /usr/local/lib/python3.7/dist-packages (from omegaconf>=2.0.0->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: torchmetrics>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.2)\n","Requirement already satisfied: fsspec[http]!=2021.06.0,>=2021.05.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2021.11.1)\n","Requirement already satisfied: future>=0.17.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.18.2)\n","Requirement already satisfied: tensorboard>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.7.0)\n","Requirement already satisfied: pyDeprecate==0.3.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.3.1)\n","Requirement already satisfied: packaging>=17.0 in /usr/local/lib/python3.7/dist-packages (from pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (21.3)\n","Requirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.8.1)\n","Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=17.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.0.6)\n","Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.17.3)\n","Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.8.0)\n","Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.6.1)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.35.0)\n","Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.37.0)\n","Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.12.0)\n","Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.0.1)\n","Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.42.0)\n","Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.6)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.3.6)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.2.8)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.2.4)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.3.0)\n","Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.8.2)\n","Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.6.0)\n","Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.4.8)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (3.1.1)\n","Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (5.2.0)\n","Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.7.2)\n","Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (1.2.0)\n","Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (4.0.2)\n","Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (2.0.8)\n","Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->fsspec[http]!=2021.06.0,>=2021.05.0->pytorch-lightning>=1.0.8->taming-transformers-rom1504->dalle-pytorch) (0.13.0)\n","Requirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.2.1)\n","Requirement already satisfied: sacremoses in /usr/local/lib/python3.7/dist-packages (from transformers->dalle-pytorch) (0.0.46)\n","Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (7.1.2)\n","Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers->dalle-pytorch) (1.1.0)\n","Requirement already satisfied: braceexpand in /usr/local/lib/python3.7/dist-packages (from WebDataset->dalle-pytorch) (0.1.7)\n"]}],"source":["!pip install dalle-pytorch --upgrade"]},{"cell_type":"markdown","metadata":{"id":"MUGz_NZE_qCV"},"source":["### Restart runtime from here"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":22561,"status":"ok","timestamp":1640501154315,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kpnzNia6eQjO","outputId":"7ea129c7-7bd2-4cea-840b-15a1f6535f26"},"outputs":[{"name":"stdout","output_type":"stream","text":["Mounted at /content/drive\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"code","execution_count":5,"metadata":{"executionInfo":{"elapsed":5133,"status":"ok","timestamp":1640501159438,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FsftdmCPETVT"},"outputs":[],"source":["import torch\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","%config InlineBackend.figure_format = 'retina'"]},{"cell_type":"markdown","metadata":{"id":"vy19ZEl9ETVW"},"source":[]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501159439,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6XbxsJr9ETVY","outputId":"78a39e9b-a28b-4c2d-866d-841792cef975"},"outputs":[{"name":"stdout","output_type":"stream","text":["Random Seed:  999\n"]},{"data":{"text/plain":["<torch._C.Generator at 0x7f6fa0868b10>"]},"execution_count":6,"metadata":{},"output_type":"execute_result"}],"source":["from __future__ import print_function\n","import random\n","import torch.nn.parallel\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","# https://stackoverflow.com/questions/12984426/pil-ioerror-image-file-truncated-with-big-images\n","# ImageFile.LOAD_TRUNCATED_IMAGES = True\n","\n","# Set random seed for reproducibility\n","manualSeed = 999\n","#manualSeed = random.randint(1, 10000) # use if you want new results\n","print(\"Random Seed: \", manualSeed)\n","random.seed(manualSeed)\n","torch.manual_seed(manualSeed)"]},{"cell_type":"code","execution_count":7,"metadata":{"executionInfo":{"elapsed":5,"status":"ok","timestamp":1640501159439,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"HRY3CzvqETVZ"},"outputs":[],"source":["from easydict import EasyDict\n","\n","# constants\n","\n","VAE_CFG = EasyDict()\n","\n","VAE_CFG.IMAGE_SIZE = 256\n","VAE_CFG.IMAGE_PATH = './'\n","\n","VAE_CFG.BASELINE = False"]},{"cell_type":"code","execution_count":8,"metadata":{"executionInfo":{"elapsed":952,"status":"ok","timestamp":1640501160387,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"IvtOi_BfETVZ"},"outputs":[],"source":["from pathlib import Path\n","\n","# torch\n","\n","import torch\n","# vision imports\n","\n","from PIL import Image\n","from torchvision.utils import make_grid\n","\n","# helpers\n","\n","def exists(val):\n","    return val is not None"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"executionInfo":{"elapsed":13139,"status":"ok","timestamp":1640501173523,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"TubuiCYeeNbz","outputId":"4e5b5306-57ea-4342-ead4-48448bf96bbc"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./VQGAN_blue.yaml'"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["import shutil\n","\n","vqgan_best_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue_e7\"\n","shutil.copy(vqgan_best_path, \"./\")\n","\n","vqgan_best_yaml_path = \"/content/drive/MyDrive/K-Fashion/VQGAN Models/VQGAN_blue.yaml\"\n","shutil.copy(vqgan_best_yaml_path, \"./\")"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":42},"executionInfo":{"elapsed":93806,"status":"ok","timestamp":1640501267325,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FuW7cjLdmVuV","outputId":"811d2f3f-6b91-492d-8cf3-22423e5a36e8"},"outputs":[{"data":{"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"},"text/plain":["'./dalle_vq_blue_e7_final.pt'"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["dalle_best_path = \"/content/drive/MyDrive/K-Fashion/DALLE Models/dalle_vq_blue_e7_final.pt\"\n","shutil.copy(dalle_best_path, \"./\")"]},{"cell_type":"code","execution_count":11,"metadata":{"executionInfo":{"elapsed":8,"status":"ok","timestamp":1640501267325,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"hs5_QzNpETVa"},"outputs":[],"source":["from easydict import EasyDict\n","import os\n","\n","DALLE_CFG = EasyDict()\n","\n","# argument parsing\n","\n","# DALLE_CFG.VQGAN_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/last_51485_step.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_PATH = os.path.basename(vqgan_best_path)\n","# DALLE_CFG.VQGAN_CFG_PATH = \"/Users/noopy/Documents/DALLE-Couture/models/2021-12-15T16-24-36-project.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.VQGAN_CFG_PATH = os.path.basename(vqgan_best_yaml_path)\n","DALLE_CFG.DALLE_PATH = os.path.basename(dalle_best_path)   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n","DALLE_CFG.TAMING = True    # use VAE from taming transformers paper\n","DALLE_CFG.IMAGE_TEXT_FOLDER = './'\n","DALLE_CFG.BPE_PATH = None\n","DALLE_CFG.RESUME = os.path.exists(DALLE_CFG.DALLE_PATH)\n","\n","# DALLE_CFG.EPOCHS = 20\n","# DALLE_CFG.BATCH_SIZE = 54\n","DALLE_CFG.LEARNING_RATE = 3e-4\n","DALLE_CFG.GRAD_CLIP_NORM = 0.5\n","\n","# DALLE_CFG.MODEL_DIM = 512\n","DALLE_CFG.TEXT_SEQ_LEN = 128\n","DALLE_CFG.DEPTH = 2\n","DALLE_CFG.HEADS = 8\n","DALLE_CFG.DIM_HEAD = 64\n","DALLE_CFG.REVERSIBLE = True"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501267326,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"URMpwTL5ETVb","outputId":"d81d234b-16ce-4982-ae64-6f0d1ba34ac1"},"outputs":[{"data":{"text/plain":["True"]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["DALLE_CFG.RESUME"]},{"cell_type":"code","execution_count":13,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":145,"referenced_widgets":["b737a3077a5844039a6be0f7027b8529","789520acf8c6443c87eb3159ee5a94f1","a092a22fbef44f96a3818b46b07eb83b","bdb5685a0b414e65a82b1778930e3747","b5649869ea9f461a989a58b5aae78608","de92258c01bc4f21b78e1e74efff9063","71b99fb5f37743558d660aa4ac53e587","682c5233b6bc4c96a2e75bd0c5aeb02a","fce9b529a2c8491a96b1a82b8de634dc","83f744eab718483f9c9e604e67f365cd","056f5acf9bd34054868b95e06b35350e","cb36498cf7db4aa0b4f601f05d088a8f","b64b4eb7046f48cda8b98661ac77b3aa","355e86971e0f4f7aa134fe70bd3ac8b0","98af5a89118243d3b1dbd71fcab90395","4755a06ad8dc4f14aeb1363052a576d7","e92c525df9194f9b82d3c0607bfb3f97","a44149a8e39048acbd184036aeffd52b","e75ea3ec61524e9c9f9a12a449866aac","b46403218cf942d98715083a75dcad87","e31f637aaa114f3e9d4e8036a85a75a4","1b257065d0ef40eeb4f43c5a22ec91d2","cfef0fae7f0849ba93242651ce3d9dee","4e857c5654f3406fa4b49dfb45348a02","f33abf69f5924492a6f50b75b60cef4d","14ef623da96e443e8d985870052a59e9","39ff2b3eb62348fa8884d2f64d829dad","fa6f0f6b0bab4ab6afe48f52ccc0f218","bbca27254b1040e69ed0c824239fa250","f20fd195724b4d979e7e202e7e422ba6","d9fed9c7866849d585db5cc936b58d57","ea58905965844e06b6f9b8344cf1cb7b","4ea034953e6e4c9f8739a0d811513532","b3ccc40ffd8f48fe81957f480f6e6815","b1b9d3f604104dac97e57ff73489d32c","71039a160e29436b928f22c477db2e41","db1ff5fe3e3d4af58593c5573bbc6f75","9addf47d6953415da7dbabf730acfc16","7cbc74df100d439b82f3be2c0e2c3b54","be3d477b33484cbaab304ca97cf63378","cca1beb5ef98445e8db63224a8783011","cce09cfcc961488aacf95f26158480c0","cd346231832d4029b8cbccfd444fb805","4b603c2753094e05a024429d00ca4cf1"]},"executionInfo":{"elapsed":12115,"status":"ok","timestamp":1640501279436,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6aPRTq1GETVb","outputId":"b9896041-3caf-4f3c-8c49-058e96394de2"},"outputs":[{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b737a3077a5844039a6be0f7027b8529","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/375 [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cb36498cf7db4aa0b4f601f05d088a8f","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/243k [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"cfef0fae7f0849ba93242651ce3d9dee","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/734k [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"b3ccc40ffd8f48fe81957f480f6e6815","version_major":2,"version_minor":0},"text/plain":["Downloading:   0%|          | 0.00/173 [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"}],"source":["# import from huggingface transformers\n","from transformers import AutoTokenizer\n","\n","tokenizer = AutoTokenizer.from_pretrained(\"klue/roberta-large\")\n","# model = AutoModelWithLMHead.from_pretrained(\"skt/ko-gpt-trinity-1.2B-v0.5\")"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":19,"status":"ok","timestamp":1640501279437,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"YZXRsVJ4BWeF","outputId":"e3dac17e-17b5-47ce-e8fc-0111e7099cff"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:47:58 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   32C    P0    26W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":15,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":171,"referenced_widgets":["bfa7edd8caff48f7be2fe4ad34f62ac1","fa6e1babb7ea4a02b1379d1f293184bd","0f682f4dc3284534b6be9e10ea619d2b","eabb6eea5950458ab41116a1525acedc","d1f42d328f674043a71b4d7406843511","3a5ce6f768cf42359be9b1edef7fc272","0a3039e5606b4eceab025c42b99b79ed","008bfb9186864298993ef2303659d3ad","92046bf3cbe54ba5a3adad249c391129","fdecb696460a41d09ef2b92d195151a7","d6da336731144c97a9964d79edd69d5a"]},"executionInfo":{"elapsed":59054,"status":"ok","timestamp":1640501338487,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"a08tUVpeETVc","outputId":"830042b9-8796-4d50-83a1-5e20b5d5f338"},"outputs":[{"name":"stdout","output_type":"stream","text":["Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n"]},{"name":"stderr","output_type":"stream","text":["Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"bfa7edd8caff48f7be2fe4ad34f62ac1","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0.00/528M [00:00<?, ?B/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["Downloading vgg_lpips model from https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1 to taming/modules/autoencoder/lpips/vgg.pth\n"]},{"name":"stderr","output_type":"stream","text":["8.19kB [00:00, 79.8kB/s]\n"]},{"name":"stdout","output_type":"stream","text":["loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n","VQLPIPSWithDiscriminator running with hinge loss.\n","Loaded VQGAN from VQGAN_blue_e7 and VQGAN_blue.yaml\n"]}],"source":["from dalle_pytorch import VQGanVAE\n","from pathlib import Path\n","\n","DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n","\n","dalle_path = Path(DALLE_CFG.DALLE_PATH)\n","assert dalle_path.exists(), 'DALL-E model file does not exist'\n","\n","loaded_obj = torch.load(str(dalle_path), map_location=torch.device('cuda:0'))\n","\n","dalle_params, vae_params, weights = loaded_obj['hparams'], loaded_obj['vae_params'], loaded_obj['weights']\n","\n","vae_klass = VQGanVAE\n","vae = vae_klass(\n","    vqgan_model_path=DALLE_CFG.VQGAN_PATH, \n","    vqgan_config_path=DALLE_CFG.VQGAN_CFG_PATH\n","    )\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size\n","\n","dalle_params = dict(        \n","    **dalle_params\n",")\n","\n","DALLE_CFG.IMAGE_SIZE = vae.image_size"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":9,"status":"ok","timestamp":1640501338488,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"dDIPEJORETVd","outputId":"750b7ca1-df18-4a95-9fff-b7ebb772ddad"},"outputs":[{"data":{"text/plain":["{'attn_dropout': 0,\n"," 'attn_types': ('full',),\n"," 'depth': 16,\n"," 'dim_head': 64,\n"," 'ff_dropout': 0,\n"," 'heads': 8,\n"," 'loss_img_weight': 7,\n"," 'num_text_tokens': 32000,\n"," 'reversible': False,\n"," 'rotary_emb': False,\n"," 'shift_tokens': False,\n"," 'stable': False,\n"," 'text_seq_len': 128}"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["dalle_params"]},{"cell_type":"code","execution_count":17,"metadata":{"executionInfo":{"elapsed":7,"status":"ok","timestamp":1640501338488,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"FJhjwhNsETVd"},"outputs":[],"source":["import torch\n","import torch.nn.functional as F\n","import numpy as np\n","\n","from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE\n","from model import DALLE_Klue_Roberta"]},{"cell_type":"code","execution_count":20,"metadata":{"executionInfo":{"elapsed":5478,"status":"ok","timestamp":1640501344480,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"6LfuuBVcBGfq"},"outputs":[],"source":["import shutil\n","\n","roberta_wte = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wte.pt\"\n","shutil.copy(roberta_wte, \"./\")\n","\n","roberta_wpe = \"/content/drive/MyDrive/K-Fashion/Text-Encoders/roberta_large_wpe.pt\"\n","shutil.copy(roberta_wpe, \"./\")\n","\n","ROBERTA_WTE_PATH = os.path.basename(roberta_wte)\n","ROBERTA_WPE_PATH = os.path.basename(roberta_wpe)"]},{"cell_type":"code","execution_count":21,"metadata":{"executionInfo":{"elapsed":3297,"status":"ok","timestamp":1640501347773,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"kCdxwf1jrdZd"},"outputs":[],"source":["from google.colab import drive\n","drive.flush_and_unmount()"]},{"cell_type":"code","execution_count":22,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":5733,"status":"ok","timestamp":1640501353503,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"yjbIh82bETVg","outputId":"960190b5-8a0a-42b9-f274-1e85b98972b3"},"outputs":[{"name":"stdout","output_type":"stream","text":["1024 16 16\n"]},{"data":{"text/plain":["<All keys matched successfully>"]},"execution_count":22,"metadata":{},"output_type":"execute_result"}],"source":["device = torch.device(\"cuda:0\" if (torch.cuda.is_available()) else \"cpu\")\n","dalle = DALLE_Klue_Roberta(\n","    vae = vae, \n","    wte_dir=\"./roberta_large_wte.pt\",\n","    wpe_dir=\"./roberta_large_wpe.pt\",\n","    **dalle_params\n","    ).to(device)\n","\n","dalle.load_state_dict(weights)"]},{"cell_type":"code","execution_count":27,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":8757,"status":"ok","timestamp":1640501449158,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"ylw54NgWETVi","outputId":"c33f64cf-7153-4a32-811f-d9bd7c17f31e"},"outputs":[{"name":"stdout","output_type":"stream","text":["CPU times: user 8.51 s, sys: 0 ns, total: 8.51 s\n","Wall time: 8.49 s\n"]}],"source":["%%time\n","input_text = \\\n","\"하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. \\\n","하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. \\\n","상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. \\\n","상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\"\n","\n","encoded_dict = tokenizer(\n","    input_text,\n","    return_tensors=\"pt\",\n","    padding=\"max_length\",\n","    truncation=True,\n","    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n","    add_special_tokens=True,\n","    return_token_type_ids=False,  # for RoBERTa\n",")\n","input_ids = encoded_dict[\"input_ids\"].to(device)\n","attention_mask = encoded_dict[\"attention_mask\"].to(device)\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n","# 12 minutes for K11\n","images = dalle.generate_images(input_ids, mask = attention_mask)\n","images.shape # (4, 3, 256, 256)"]},{"cell_type":"code","execution_count":24,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1640501363505,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"Hvd5nC5vvZWR","outputId":"f2036fd9-0aac-4f0a-ad4d-886125cf355d"},"outputs":[{"data":{"text/plain":["tensor([[    0, 19975, 27135,  8817,  2073, 11150, 28674,    18, 19975, 27135,\n","         14346,  2170,  2259, 24631,  2128, 28674,    18, 19975, 27135,  4642,\n","          2170,  2259, 13859, 28674,    18, 19975, 27135, 17107,  2170,  2259,\n","          8482, 28674,    18, 19975, 27135,  1887,  2073,   766,  2149, 28674,\n","            18, 10346, 27135, 10653,  2073,   766,  2149, 28674,    18, 10346,\n","         27135,  8817,  2073,  7482, 28674,    18, 10346, 27135, 29952,  2073,\n","         10727,  2600,  4893,  2062,    18, 10346, 27135, 14346,  2170,  2259,\n","          9742, 28674,    18, 10346, 27135,  8696,  2015,  2121,  2073,   646,\n","         31286,  2062,    18, 10346, 27135,  4642,  2170,  2259,  1469,  2862,\n","         28674,    18,     2,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n","             1,     1,     1,     1,     1,     1,     1,     1]],\n","       device='cuda:0')"]},"execution_count":24,"metadata":{},"output_type":"execute_result"}],"source":["input_ids"]},{"cell_type":"code","execution_count":28,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":345},"executionInfo":{"elapsed":1160,"status":"ok","timestamp":1640501462251,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"7Qr2RZ8gETVi","outputId":"6fb9c672-bbd6-4801-e2e1-fbe70339d0e1"},"outputs":[{"name":"stdout","output_type":"stream","text":["하의에서 색상은 오렌지이다. 하의에서 디테일에는 플리츠이다. 하의에서 소재에는 실크이다. 하의에서 프린트에는 무지이다. 하의에서 핏은 노멀이다. 상의에서 기장은 노멀이다. 상의에서 색상은 화이트이다. 상의에서 옷깃은 셔츠칼라이다. 상의에서 디테일에는 레이스이다. 상의에서 소매기장은 긴팔이다. 상의에서 소재에는 우븐이다.\n"]},{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4nFT9aa9lWZIdiC0b9jnnDm/y2SM85sixcqgpK9nVZLHZA9Vio9kNCI1GS1+kf6SPAgihG/pGAQK6KUEi2CxRZE2skZlZOUQOEZEZGYOHz2+4wznbBn3Y5z6PciADnu7vXb/vnm22zZattYz+7N/+r4FEIDNBOPzKBJAgAhEiE5kAIQEC2lcmEpmZyPYNSUwZ8/+PSGLK9isSSGLOzIgkQrZ/gYgAEBAwd2XNCPMgTg/zuv3xT7//xt37f/MXf/H06dXjzx9mso8W4ev1qgxdURx3w2KQ48WiqBydrLTr9+P+8nxz8fQcEcvl8v4rr7z6xus3b90mVu26rutAyRluFrUSEamKFAcDxMxAUoS7ESGsBhxAtfmnSre622WEFrq4uLi4urjYXH7w05+PNv36o0/RDc/Pt1xKGbrdbn+12/V9T0DdV1JN0FQjA6UrTJwAESEzMwoLgdbr1WLZm09hNu73Xn2/HbX0/XqYpnGs1cy8hnuEuWeEEAisWkQE7J6RERkJRGRGEIiYwIwEAfPTyUB7QkTtqWUkAGJiZiISoshgkAgzIzwS7akxEyNTREg4MzIShK4rQAqh7wsitAz9MPzOd//+/+af/tOPHn5+cvM23KVTikAmM2cEC0XkfIpAmcFE7dWA+Z21w9Xe5PV5pMN7vj6oRJQ5f8X8J+3vCIcXfHlSWfj6XyFCEgSiBs8k4vnoEgNJOJx0Igok2qtxgttnBgDg+ZVByEQiCZmc87dTJuYISQYSEd6+s538pERGOECICAJVG909IqpXcFw8PR9kpSzpePjxZxcvLjvphkVXWFVYmbvSL1f9opSh71YLJfOx7ixj0Q3ru32OtRfuOVH324tz6UvP6xRiIc4EE3XKEYFIAhGDKJOoxTEr0rhIuGeC+g6R6Q7IsFzCa53q+uhsdev+3cw33/zaJ7/8OaP78FcfjbvtIrur3dXJjRskxd1g0WtJkookAimYCcj5XQghJM2HfrD93gsTZSYWy+W4GbNDMiOIWIoSgsHG6U4ghgHMGgFWyUhmiqBsSSozAy3K2nMV5kRme6AZ7Snk/AADRARy965oZBIoMoXgcxqERzIFEZjIzUUIRIkUovAsIuFuU3SdcAQRffbRh88+fxaGabcXVZ0ckhQR4WAKAwiRwSSZQZlByIz5ZNIcoS2vtnzbjnE72YffXwfB4Uvb//iQjuewyDkKiLIdy2zHHwC5u7Y8nEFMh5M/n9EkbhGKJCIKIqJEZIuy9k9cx0k77C1Q4/r9tL9novZQroMqcw4kYiRAxETgkCAX4Yys6Zvt+etv3//X/8u//MUvfr67GG+cHfWlH5a9e2jfnd6+AavTVBednB0tok4iyomemXvtmCRRp4jwZ8+engBDHmduT4YVAqKcmZwJMCcYRMSAgEDMBAQZUpIoUpDEYBClSkhwgmqhHJ3IU0Zzg9x45fU/eOXBb11e/fxnHzx+8tnnT56O+2k1DKWsM2LcjQEeJyN2qyZCwhLhzJxhrEwgwIl5t92u10MgOLDsi4I22z0PWC4GN5uInYUAN9/VicxEuVqkh4owMXO6BzIc5AAymSgSLa7bFccgaskJmYRMSsrIaAfGPVR4fnQRRMTtYTEhiRIRQUyUYCbwdcHgmZ4EVbXJe5+enT///g//8hu/9btTHdedTmk9NEAJMCgoCYSkzGzHAjFH7uHwHY77nFYPqRzzMWsnEKC8rljaoW8ZjK4P/suahtoJzMORRRISRMoEtyDilg9awg8kJxHToRRCJjISOeePl694CMHIL1yo15USru8ffLFYOmSg+W1mJoEOF02YTRebF2enyz/6f/2rv/2b719cbLokK8PxzVWf7II6TvDpqF/urvb7etXdu+tWlbLvOu56FuUAe/YlzCeAxu1VJ4UX/ebqsl8OyUWDEpLwREatEDBnKwKYQGgXIogFkZ7BRETMEALAxGQ+mbKtCvbVQERSTpYn3/7Wt8fxy/tx/+z5488ePX5xcTHupiK83U0xdNvtVoYyjdNiIQxOQLsS1ZNQzRalTOM07UiLhrkQ951Glv24X+owdKUTGfcTEtQXNdlN01Rr10l4WM3SlSKsQh5ETkIwDxXxjFaOWkQklaLKUs0SEGH3TGaAqntRFeUwV5E8JDAWzQwwuTkAFfZwR7JIK5YsPZ2KSETuRxMit8n3208+/Nk7776tR8cVfZEyVlMitGtjPhnzc7+ut9HS7RwKCdAXEjmoZe92XmIulOjlMXx5bWQevpFeRkh7lcikOXlTAEypmcncMkQS5nPIh1hraZ1BQZQZcyn2haibyzLMr9uKsnb+QTRfJch2cYEPP/rhBeaGoiXBJCLKjHHaUZcXz5//0Z/+2VK7Zel+77e+ffvujf3e97vd0xdPnj15uq/7O7fvPnr4+Lu/+fXVYr13P1520RWSYi7CpCwUHu6RIaUgbDy/WN3ufByFxRJFmIhFOObwdAIxCVEmE7O0ay/c2y3BLO2ZIMAgkhrm6bUvvUhh8CQmYxXRToehW9y4de/i8vzZsyfPXzx7/OjZrpq5RKAbeiLmAqs2jVZYzD3CqSYoL3dXJ3TEzO0Zq0rJdPcigkCvOk1WVAIJAhP21YqII6MaVEBUtHBWPyQbAhHSPYgQGWZeVIroVC0BFWmZiyk9gp1bbp5rQ2UQMXFGuydAIEpKi5R2lUCIkWHufVGmhMc4ZtL+0eePLp4/vHt0FD5ZUmk3K3HrUNrJpC8ehfk0/52Uff07HLJ9S6PzobtOtXNTk4fa5mUA/d3zn4cudn5BYlLkF1+pHUm6LrrmYoUoX9b+L1vg64hDa0cIlJQ0R8XhX0kC4tBDv7w3DhddZiAlKBjEYAcLS1e69z/+7Jtf/6qf77/7+3/v7s07lxdXw+lqmsb/37/5t+cvLj755Mmnx0+PTk8++uzZ73znt188zH7QvUdCu4UyChDpzKxCiSQl1aKx2/frlbiBlJJBEpmRICICh0dwe/tChEwDQAwNMDMlUSsiOGq7tEWY1GGF2KoV56TsJHOpwDDWemu9fvXs1jjtdrv9Z5998rMPP3x2ce4pdXLWIiLOHJn9cri82qSDhcLp+WZ/vByUJMyZRDm9BnVUmMaxClNGqDBTyUgk3FwAFm5XaJgzCyeBjIg8gokJEZncSm8LIVbm1tszOBAEIDLSAQixsLTfm7swE0hYPP3QP0RGgKm1qe2/npFGg0oit+NO6uLD9z84vXlroXdFyZ2YQJktBjIORcyhoskE6AsZfT5BX2x4D2n+uli6vjHmc0gvrws63C5fiDAAhxahvUhmks7XCtEh5Jgp55eKAwwEIOm6hp8rskONFQc4g0DZvgAvD3cmkq9LtgQT/HD2mSiQhKRIT1IOokyWvuuG7pe//Pjpw8ff+ca3771y7+rZePfVuzksZcV33n/rvV/8Yjgdnj/ffPb4/ONfP/rKl7/y6u1jN2OKrpSQQomkjgVMYJLMBGWkZIRPlblVMiWCiCXTab4r081ZREnnuymphXQmhISohTYzMUBgBlK0mFnflU5lWBSrtVpNB3eSZt2gCx2Ouno8LF999dXHz59+9MnHj548vrzcj9spuZgFLRaL5TDW6ixRyGrkflxqIVBGlKLMNE7Tcrns0sdxAqGULjJYOlXe78fwloAIyJivX3RFkBDhFtfVg+aMFqySBspEC2sQJYFb/0mRyUxIpAerAmAhECOTmMKt9ZqUYOY4gDMAefUQ9EM/Xe3N89efPnr3ahP8YulShgVFiJCFERNJpidxy4mUFMChT8UcCXl9AxxO2qHtPNwJBwiIDmXNdaOQ11Hxd47/fHxb3d1eV4kO5/z6RIPQSqQWrUiAmJBMBGrgzxfqtrlPv+4w5gxPB7Tp8I8zHSCkdk9xq8ha5FKkeRIxlcS4m5589uzejXv/x//uf3+0XH/+yefvfvOGAE9fXD57sv3St7/0r//Vv0a6cfaLjrr4t//uT/+3/+l3790829sOgb4fEsTERCzMTExJjmRiMKVIJiAZcCo9gym5FX4NA5O5VE0ChIVIIwOZqsrEiQx3FnR9CfcMTs9SimcQEBEsUtBFu1kirE5madNeC4v1/fLk5p37L86fba92H77/wcPPn27Gunl+IcuFqOw2Y4gU1Rq5M1Nir1HNh66IyrjfF+bSaZ3MpsqiAlaRvnRjTC1bkxCIzI1iTmZzY+/zpZDhCXgkiIQYCRJikJBAKMMzIsMtQpQjMiKZaYZRKBoGQqAMWIYKA2h3S62mQtXCd7X03X57dfmifO+v/vq7f+8fYvCIygx3Jka6ZwgI7K0hBg5IYruLkXMmnaGhOQVflyg4IKRzmFxHwd+tY16m/y/CpgcMqP2H9LodwRfKpsz2U3G01D6/KB3eyRyF8bIuakja3J3MP8XLkqwBrF98s0CLpfY9YcwpWoPj8acf/fK9nz55ev7Wm29tN7XGeHbvLmm33U7Ht88++P5PpPc79155+PDzJK8eCv3188d//Cd//Q/+wXdOj4+qxZApECrUAE5iZmYBZ4tBsGegZsI1A4wkKNgbwkUcCfJWkoKFqeFyhATNwAELQZVb9kj3QASHC3Egwz0igoKS3Csbi4e68tShugZ0WpbV8Vjt9mtvPvzs009+/fEvfv7BxW6HPS0WKwf2U+37wqpoHXogqq+Oll2nTGmeIgAj4QB1RYRZVap5VkumAASS6RnBJCAIuKYraZ2mcJAQgViIBWENFRTtGYQ6JTEARAT5nESZyBv0quxmSLAwgAabtNwZ4XMNrjRN09AN47i/evr857vdzeXpH/yT/3ozTVw00skyQeAqXAL+d/rYdrpivhRakk5ktpnS3KPSIde2w06JRHyhZZjT+8ss3QKA8rqWua7bkJmabQown+nrOutwTONwhczzsBkF+sKF0TDRQ1OOwAyszu+BEgAnxfzCCSKKiHYJZIYwIWFmNtrVxYsff//702X9zm/89te/9a3stArlNKVlv5Lz88v7925+9snDu7dvPntxrm4T+7aG2/Zvxvdr1v/8D/7j05tHlaJDEBVEQgjM0WIyE+D0DIC4/dajJUOlCAfQqprWX4Kuh0cEQEgSSRlxaP1FmZJU0tzT5pwqzJnpYQCrkqgmyNy478jRBeu47cJqjWmqomW9Wt84Ofvlxx9tL3a7cX91tT9ZLi93expyOSxk6Hbbfc20zW6Rw9HQ9V2HiP00IUO7AmZmEpbM6hmTmZYOjG6xtFop22FK7XgczYmJg0W7oh4RHiCyOpFECrtnKSXCo3q0nEyo7pHRq4qKjzXa4CAiay1aSLjhJMTMlCDUmqXv3HJROq8VFe/95Ef3X39w68Gb3dlxzSRGRCqLt7YgEnzI+C8L+Vba0zWUeKjr/25DkF8EQmcYlA4Y00sUKLPhRjwHRraOlokzUw+FFCWSmCKSEhBCIuNQc7XvlkMabAd/nljknMVpvl7mrpeQka0wbYXU3OITkGDC9dgj0kEJgo3jk4ePj0/P3v3aG+986culX1jaovAeIgPX6jFVFj69ebpaHPfrgcYdzUgck9VffPr47t/+7He/+00mcamsPRAswqxEosKREJagSEowGULaXPMQpgQOJCKZuOUL4iQiQbZhABOZJxGItOWmNlEUBhQifEhMKanpGSAuHgA5ZaUMjgAxtFplLySaxovl4v6d27dvPfn86ZNHjz/+9NPdfrvuy3acJi3Doier027cm09XXhiLIsOigDDVanUSLYAWFVWmPUrH1UJESNBRcXOzmpFCvFx0Q6+73c6sWk0RJYYDnOzuHpZgFGUwSbJwq+gQ7sGuyQkidH2ptbbk5uFwAs9D5PDqYSgqSaJIRB1r35cnjx+/9+P3fu/uvafP6mJ9DBYGj5MNfWe1ikprRiOj3UwZrR+YQf02hcKh9HiJb+YhZTc0/YCnHyqZl5n+kNDnbruFCDEFghLavqgd3pcAUx6yfusNW3seh6SYL1kQxC2YqP3ZoUs4wKCHYJ4nFHMLkgnmTDR8XQpRPHt6/vTJE5XFg1dP7r7+Di+W1BMFecwzHJv23XKoO+Ou3HvzlV98/hGePYWQ1TSvlaJU+/DJZ3d/efLOG2+iI5RC7URSKiE5uWE5CSY51IItK8w/UWvs5uhGzK07tYAFAo6X9zAAEOc8F2RWIElaTRwNwqQktrQMhwcTFUISWLik9MyVkqrKcrnq9fJq7O5qX7pbZyd/+96Pt6Ov+v5qv4MyVF2mIBjicrOdlIPWwtC+oHJEkDhIkdR3OlUkTwS3mgkauq4UqmOFUCmSQendFDUBZZB242TZChp3MIU7E7PK3NllAiTC6THaqMIqXFDGau2GqGYg6lSYKBuJIDPCp+Ai0i/77W6vXf/LX/9i+6+23/n7/5BYFssFicigFQ6hlnEIbeKWTHMBdCA8tJzOlBl0PW6dW+cvdrlzzn9Jp5jnfNe3yaEaykMaBhLErOlBLK3Qb7fBfLJxfZ0cApCIGpyWBxpPa4qQbYA6dy1Mh2snr3vgPLQGHtF6hXQnRBIrx8WLy8vz87q349Xxg9dePb55pkux7RTVk6gTQmbX9wgf93vCdHpydHR8lKD0ZFHP8LAK/vzp5S8++uS11x6M+1zKvvQLYpfMEOKZfkHJycygaPiTe4AgpBGREaBk5mTKsASCkomYNCNaWRDhc2sWCSZJSiQTBwJIkFIb+SOYBQ2USWLiTsU9SZAiwQ5gRPAwmNBuu4uFKKGu1nS6frf6+x98eFXreljsdpOqDkN3vtlK6T1jGmMr+8XQqwoLgYMSXo1ApSgLi3HdT5SpqqJCyW4Gz5RcLBZKQpkMdYCIlovOwsexNppWpgURwMyESE5KN/fgviDS0ymJmYpIA07a9wSEiVQajQIRmBxgWiy6UoqwXj2/2ly9//z88j/6T//g1dfeLerKZB5E6pHKwszhzqLIaLOgPFTZ8yAbc5a6bnuvG+YDDHUYuOK6E8jrXH494DrgSInDqysRRwQfal+aDzq9jIF2ByWSgcg2CAfN2D7PFJq5ZWHwoZKjGfaZ2+jGUZkrfiZOhu+8G3h7flmvtprl3s17d+7eOz5bpWJ7NSIrc8ZUAyzal0H3uyxd15EvVqvbt2+1Mj0ziNMT2zoxx88++nRVvveN7/5GXu6XqplFAx1HBolqEGy+KSM9mQMEPwC8zEgKzwx3Jgi30o09LRMBSo82XEC0qTg1EhXpXK16OIGJiEgy4TFzBtqEvLWb3NBDDylasmOhJFDflQ0F5WYzvvbmK0X5Z+///HwzHg/9FEmBpei029piIcq7vVXPxdAPfelI62QIhyRlZEanJTXCLMNrnRb90GvZTrucsI396fE6wqedzxMaYhHqO8oIn5uCNplhyiRkMCXSzbQoeUQG4oDDJxpImOZBqapKgMynsHrymEUZwNlqbZ77i/O//MN/t//NF9/41rfHaS9Sklm6BRgerehp9fah74wWA3xNX5iHwV8o+mecMb6Y46+P+eH7rjEeOhQ5CQIiEgSlmatzmF61dE9JiTjwJQ4RNSPieZjbYq4QgkhaMdbInnO9RimH12Uiz2Bps0LPJDfLtDBkNQ2+c+N0OayOloOm1KudDhw197vJ01ZHR4V4nKxfLqexqkkn/d1bt4QLcu81WIRUwmCZF6O99/FnN1+7e+v0Fja7QroshSkpWxOVRAfmETKygjSjfYaNDZiNCBAZVEEqiZjpAOE5X3recAkQ2mz8QG4EZbb8CcAzQA1PAkgZSAYRCbNlEoFDe5VxPwolTxNH30ey8LPL3e0Hd672l9OHH4XtOu5Gt75woc68RrcMWNQk4qIKOBORCiG8migTY1h0NGG/Ga3apdWT4xOS2G+nIK41loshbccI93BPUeHCiW4cp4bIJwUi5kovKAgQikY/nRvPxhVDNKAtI5Ge1PiVIGSAmYLCkjJ8Chm6XhLj5fl/+Is/+ekPv/fNb337na98RddnFqnSPv8MM4okImFqxSrNQ7q/k87x8oC9/LNWbDcCC/+dwugaRAVeNsh0qGGg1wd6hrxyvilyfl4NO5l5THMb0BgPQCQjk+bpGhFSiEAUEUzUiEWUlAQnksLk6WaUJEh4dv3Qq3YnEkubzForjDQC2TiNu61ZHJ2sC4vX8GqZOQxDrVPXl9s3bty//+pPf/6jriy8zrE+Ve+SH1+8+OmPf3r6naP9JqClJgkHGJwmUGa2cG5R7hFsJCUjGykmGY1GRpmsQDixogFZB+ytNfwH6lVkkBMiU5jnwgCZmY5AkrcBSFAbGjEzIVlLRnLJiOASCKckTrBDCEtSs/r2l78mrB99/CuSnoS3u1G0xDhN+wki5o6pcuZ6uRAhAaWnECycAsRSSocl1V2tkZtxZEgK2zhtkm7cOM6rDc+wVlIEQEUEXTdVI4pIbWNPRCRlm4DPZ659BkqtcG+QV6JNPBvnKITY2zUSRMxMPI7GxJ0W4ZJGV+fT//cP/90P/va919985zd/57soDpVEdJ1KEScgs2Zywxsz23D+OkcT2pAmGmWhZXg6YER53Rlcp//rlu3vRMMBBiWawSSeyZ/USM9MQu2WZ7oOu5nrcyCsUmt3E3wYJDuCAWEJtNFitC6RlasZo0qRnrWOtlz2vYoAElSTPLxb9KVwRu52U5Cb5XI1dH3xiqAoXTGzDO+Gspi6blh8+c3Xf/TjH/YlApnEkTAiI0jyT97/9av3Xrn3yu2yWE+YtHScahxhU9GOHETMRDk3MeSUiTBHeraeXgjhDrqu39jD2siauPH23NIZzKKIJOJMAsg9EBmIQLK0pNmab1JVpmwfdkQKI6ySO5lQOqU4YZ9hBGIuy+UrX3p7Z9PDTx4v1kuw7Hf7ftlvd2MRJS3jfuLIjDhar8AkygL1OsIBSi6dJqdnjpYesuwBh5AjdtM0LIfddp/ELddGy2RCgCJzssZUzUxYjZohECHyzPSYB+TEyEimiCgiqqzKlCTaZBVIphRypCh1LDWiTlPplaGJKCovnj49v3jx85/+5N6rD9790pcevPFW5ITUBIcyEUeGcKuyhWbCyhwEXyiKWiU+t79fwO9bXBwaggNl7eUXHfBUBRO8ZSaae2dCo8FSENGhMQBFBMk1wtSSdWCmT9JMz2q3v3sqE5iCGUnuvhu7wsvFMWX4OHVKyhQRADyMO1ovVtNumqrsdiMiUbjv+75fCHUTKhERS6EkzcH6qdt3yd/8za/9z//i/90J2+QEcIAZPgV3crW9+vjTX3cLUh2Oz85ovy/DkMGMzDAVRcDDKJvmY0okt18EuEOUqSQiAx7V05GKAIEjX7ZQrcs3c5WSxB6RESICyuRMYotsN4NyoQCLIG2uapmYBbD5eUTW0dxDRBZdz2FXV+OiX7zy+uvE+ujzx8LUlbIdx6Hv3D0oILSP6pHT1cXRctEL9ypD30e4eRB71w9HQ3nx4nJy8xFhWSdPwma7P10vx6m6ZTblAPLQ7gXm6Xwiss2/+k4Asmoyn59gkoagRSQDwkQg96A2Y2dAGJ5mpiqevOfsRCJR66SizCgqmdwlxKYnn3745JMPVqvVW29/6e233715915EGCUTRwLhLHQYLbUe+0CvnNuql2jQPLS8niTQ9cz20B7EIUYOPZAecMnr8bFzwzGjXTrceqsG7SPm6fqMkDEOZKacAwiUGarS4kh7ruM47XfTeHV6fFbC4vCxTvtaOgkiVqnVpnGSIt7iQbSTMrm7J7O7G3KmawMki3KDTv12LZVXJ4usPrOoW6gqLm2MTn720Sdnt25zPNKuI67Jlui1MDBkDYdIginDGe2nSE9QeFAgI1GIIckZgfCkdDZiIWEO+MwqZAaRgBv4B8/M+dbHzMhlpjbwAzUEiZKQgfDISEvEWMdMy2psriLMxNpRet+vp/24XKyZ+wSdP3txPk4CCgtlnswgnEQVWc3zanvUdzl0g3JEUJKPPumYLOvlYrPdsfAUueq7vVcPHydX0bSagBJlIBEcwYgkKLU4iK7wVH2qlh5ShDI9gIS7HYY/XETcPZCdCAsRI8LMkgAScgSnJMdoFUylSMRkFl5p0fVD1yGrELPkuHv+g7/+sx//4G++9hvf/vJXv3p273YlUk0P8UhKEpK5s0xvRXk7n43N+gXwHzzPAq4roWvQ54u5fwZUtcFJ1+3FXMrEDJdGqwGYwoOvRRBt7MAUhIwAWu7zItIpmDhH4wwtMl5tfDeq0J3Ts2G53m12PsOzKR2PZo1/1QbDfdezyLBc7bY7lyhayJEaSPTto80GF4h3cevk9uX55Tff/tJ7H72fyJ27EBcpk7k4HS+OiOz8yePX7tzYnD9hWlOtvO5ghdKhQyZSmBycxsws1IiU7UfP5HAjBYSIIEzwJJKMyARkhv4hnK1GniWThET4DASwwL2BoDNmJu1fIbi7hVut++0uJpvGEQ6fkghd6Um7UpRIRMbeYvnOejH0Tz799JNPP37y5EWtkZnLoR/NXXI7TUNXqvtmtwVRrble9u5OluluCSWRRmhjqubVnJk8PbNRQ+aKgpnRmuJMd2cRm4yZOQluCuaI8GwDDQR5BNxJOET6RQ9PRkaNOlYWFmESFkHpSDiZkwlCFFFLp8pFlKbNePWiimBYlDZTX3X9bjf+9Pvff/bo8wdvvf3uN76mfS+qIl2mBBIexEyESI9oeE3SgYGGw6T473S1B0Lz/DeHCGgP7DAJbg+0DXmp5VJioggcJhMJZOvvKdgt20BnbnuTSdBrp0rqHm5SWBDj5mrcbolo0Q2l9O2mEGInT4s5l0QiUkWkL13fg+BupchUp5LgTjNIiIipkCZSCWOtyBx6qYL/7r/5J//n/8v/eO5XFBnIvZt57YmevTi33X7z+Ok33nnrzoPb4cbFxm0tiyFGFM/CJNwhWmmHA60pMpKZCY5GWHSIEIOBcLPMDAQY3ClBZhisfcLRaF2UGZRkmeEpjTSaERREHBScqFbTza2Ou900jeNuY9W2272yqpTFetX1S1KpZv1qcXF+2UFfe+3145P10a2TH/7ND87PN9vNSJIgCBGLmGeGR+Z0cXW0XFyidkVVycwyUeHpWcOlaJoToU4+8hQRbMnCqoxMBplbAokonYxTLZ0wkYgIdev1elgOCI+Im7duXe3Hq4sLi5imsVZfrRaU4VZrrXU3Zca0rel+tF57IN0JYIJIGy/0KcUrd6UrKsxsZqxdv+gJfDIcTzvbXlz+4r2fffL5w7e++qWbt++uT0+b/kC5w8ue2Nvo7UCYIJopPfmFc35oBegLLUHTSLTONklfcnquG4U2zA0impkNIpxEooWT61SZVaUjERZwLywMRHidtlth6rQE6vbFbrffll4ouB/WXddZZnIbtxx+CoYnhEVUutKJFiJUMVAVkWojEZiJPEDhMGH2iPQqxF73bnF2fPLNr3z5vZ//AvZstCiiUzKz7mB3Xr1xVnRx887V1Xh8dgR3gTNCGHCP2Dk5k3oIQEbOAuZG5aGGlXoikdUCAY6QnEWjoCAKOtyikUBkms/ccWaBgKn9eGFBlEHBypOHEiV5HaftdrOfxrDqFEFpHkm5Wq5Pb9wyz0zSHrs6rW6c7a+uVAjMulgwl7/5i7+OxDjuLDKFi3J6JKMpti42V70v+shl4SJi1R1NBp9m1uCaoARTRGY6PF1mhNrd0lN7psi7d05vnp1evdjJsHjlra9/+/d+d1gsVMt6tXZ3EgWomvnkWqhW7xfF3fb77ebihddp3I9dzyh5sX0+7rcXz549f/So7nf7q52bK6nVKNqFwzxLN4z72G/3ibTpfDUMpetXi4Eyf/WT93/9wcdvff1rD958Y7+ZjOvq6Mia2qeZKxA3Khy/LHQOY51DFFyLyg5dbsvorXVOxbW48gCfHuLEWSSZhZqQjJgoPYdhGIYVJZdFLxJOmRlm0zgaZZCwm+0ud9N+30hzfdctFz0gZpOwmNUwIEiKhKdQimomSREWzkRDe3yaGGx1YmFl8jpJ3wcSMOlk2u9ZCH3uqr/7zuu/+PHPeicV6oYhlqv7r97/L//JP/793/ud46Obr71274Of/PBn7/3Nk4cfl65Mm6rj2HVQ9qAgFkHX+MKBRl5SzyAGcZmpAOnmDouOFQhmBme6H8aBjAgPo5xpwxluCCM0RlE0LTWxBxnlZL7djl7NPfY1QKUsFsdnw917nQcSfHJ6ZuYgqmli3ThVLWJTLf0Ql3pya/rm7/3OL/72R5989mmXZOEejgAX8YR7gmmcJmLipFRlYU54DRCUxWfqrU/j1Oi7RARmiIxjTUdXtOv65aJ7/c1X9pfbG6frd77yrZPX3pDS9X23Xh8To5ehjQ1XrXtijjYXIHAE3XlF0CheFMzOGRTkgRjrfjeNu2pWp/1+v3vx7PmTzx8/e/L46ZMnu/GKnDKDQZdXm8ur3eZye3LzbFgenZ+/eH7+4vz589feeSt2KVqkzCpttGI9X3KcWx00Z/KY4arryewXYmLmghJI56nA3KcB7cEluDClUJKHidDxyamKChclYS6cRBzTNCpbpO83V9N+p8o51nG7sRqNrV6kW6xWJF14hqdbJjHgJBSeotpG211ftJRZiQcqXXG3cHcPrxOYW34CZbgHBVNO+7EoZcaXvvKl73/vRx/95S+1P7p/5+x/+D/9H772G7915517Tx+fb1Kebfz0tS/99r1XP/3lz//DX/zR5x9/8u6779btVIsMlDp0EENzhnAiljQHCG6SI7E2IaA094LwzGg+FpRBMC2FWASZYdzmA5buURYqpNVjrBFJRZlJiSnD97u9h4UZCbq+mywWJyfr5TKrPHjl3r5ONlnX+W6snFCFg5CKRDDf7Lvd5cWd27eG3/kt+j4++fhTeLDwbj8GOlZhnbGaaaoDy1RdXYoKgRCZEZ2IMll6mjXaGXMxr0TknvC6WA1p+dqrD0i6xVl/ujper1dnJ0end24wqHRahBPCwgmmBFFkUwUQN5JLa9Xah0SlaazbsKxwv+4iJwtmtcg7b+PL8Kh1s3nx2Ucf/vpX73/+4Ud1v9u/uCJWFFqvltvd9sWTZ8PR4ur88S9/PL769uv98oZFTqMBhFI4EZQSRDkPBRxB+ALz/hr+PxQ6rR6a5zgg+tM/+cNWGx10D0lE7iGiSPE63rh1a7VeFtVpP2lXyKFFyWmcxggTie3u4sWz5xnWidRx8qmGgwhdNyyWC+mLFI3w7dV2P44EQQa1XAkCkYCG5WIxDOFR62TuZtVqrfvRfWJpTgRltRrCPNFYDO5WA3W3q5vLzSefPrt8fvWlr337q9/5jaHrwSWcmUpZKsCYduN2zAge9L0f/tVPv/fXnOONo+NVN1BRFkY4q1BS0Y6IKcFSWDVZI2chj3jwbCmTURJCBBYWRArTtN13vXYiImTuwWlNF5o0JRF3nBTjuB+3Xsdxt61X+7IYjk+OTcr9t97abezW/TvLxfF+nPbjNiMndw+r7tWdBDaOUe1qs9ltr86fXSDqZ08fvfe9H3780a+q+zTWKUBSRFWAMOfMVaFVL9WjLwXgGklEEDL3i/MLFUkiIWaVrrBV7wRZ67iZ7j145e2vvBtCi6P1ql+/+vrry5PT4fi4K4t+GA7sCUEbpYCID3JXQgbcjcHMYuZJnNSogYhqYPKaEcnap3AEwCQMpEfu4dPVi2cPf/XxT3/wt++99x6QD169v+gHle7k1unJK2frs6NxZ/fuvro8OoGIR4aoMGcSe2gemBSZbdSfhxggEHE7+l+ocAgJCEgjErMp0oxjgMAiIhTgG8d3z27fQoTXWkoJCzBlIHxKc2Gy/TRuxrRQRow1J1cSo9Ru0NJx6UnFyc29IoSViNt1FYDKnB1EdVgMu90umiCjdR6cylKjehiFb/fZFxl3U7foyDM5reZo3q+Pv/V7X7v7yutYDKSSmcrZRZLIdDURqxD1XdnVWkd6/a3f+uqXv/azv/nTv/nLP713+/7pyVmGJTnMRTW9gku2UX5DyAFKcg94ejRcNpDChRjKHWti2u4jWUs/IjcX5xCs10fKvr/cCBWCrlaLCEvURNSYiCNRH//i15dDz4vh01//6u/9o/8C1FcHKcEYZJkOIhbuDB4x9IttbI+OT4TAnWxebO+w5LdBoPfff7/vC4P2+xqBBAmDPCezoZdA7GsVURaJmZ6YjbIqREQQISZ0QqtFVzPWZyerYbU+OZsou+VqGNYyLEgYlG5jZD9IMXOCH0TSLQICiQZ+iZaIJJa+0wQFo92ZqZqgUCBBonAOidIph80jlNThbnd0dPrlr3799x8+tZgmm4ZhcXZ60q906+PDhw+346NPP394FyiylEVhocx5Wh2ga03BF2D/mSd3LUGem2B6yeZXIWrGbZi5EDTzNoE7t+8shr4TcQoCjTvPzELFq01TJYSPVutodUJG3Y0iVETcrO/7IMmiqZwUNSIyVRQMykYiDCEkcUaUruuKoon0RdwakyADSRnpISThte4nQmHmaVchKZCpjovl0a2bd9a3H4h26EtkdkWRBBu9VpZEibofx6uddoNoqopv891vfee1d974xQ9/XEcLpEQjvhuExJNYg6VxpRhEEXDzyDQLZHhYADXFKYdBui4CpPHJo8fPXry4eftGUd1NtWcKy/12c3l+9fHlz3/44x/t9pu+Uy3a93J6crxe9k/3F+//6Hu3Hrz9j8px6RdJMo3VHHUyv2Z6kfYKj1gtV7VaN6ygvaLLCz09qq+8/taLi/PnT59R0qLJiwu5Za01BZe7abXo61QjvCcVbtpX7limyalQ33esrcfzWmu1ul4Pw6pstpfD6cnJ0amQDkMvIiwFiYxK2hdlRES6soBIVRtjPTLNvZUczeVDhJIpM61aIlkVSh6NHItqGTEBkYGsnog0Q7hT3H3tdlJsNtuxWkViIimrB6++de+V17b73bStzJF701QRZc7rmqdpWg4oZx4A0mxNwnV8JECRSYhMPThFzNRpghIlMa8Xy5PT49oE7ITwaPodq6NPwUBmeCMPmEetjOi4MzNRQSSXRrrPDDAzCrEIg+BAzBYdAWKiMhRt5QNTzWs6djLIaoSZNZ2uT3WfGaF90dTdWIflye27r5wc30RZBTeJwzzCbCit1f10vq9emdtcnREY1sv9uB9OHvzuP3rj0Scf/fpnP7k8vxwKh0XSSH2R5IRlEFMykjx8rNQ8E8ItkoRLYQ3y3e7xZvP0+YsIuvnag5H5W9/9+6r0H/7s32+m8fLF5Xg1htWe5Y0333r6+CkLprpLiifPzj9/4s9fXH7nO7//5W/93hRMQN3vwZTeBp+NRkvung0HVq3ViZiIumFxZ7HqteOIcXP13u5HxHn14ooIlqnKHjLaSMIVlMy1GrF0XWEAQQomJYsUIhEa9/u+1zruj4/Xd2/fvvnK3RGmbpzWD4sMsFCEq5RMeJiygIkT1U21azRDZnJ3IWmOdI1WQ0BaTUoGkXIL6e4waGqsRIAzw9HSebfgdbp7RN/JZjtG7Eu/Xh8fJ7NTylRLv8SRbzc7M4swLRTeyJh8AG/+TqWTM5Nh1jNeCz7aVzKxNsETuMkRZmHM0enxjeMbDOb0CEsHwJExjhNFUlAw6nYsytNYPZKEhTQZ3PUU8AQ3Yl1AlKgIX2PoSgxBRiYHqBv6TkuznSIWMOcU7ubuaEoxICJrHd2MeHd28+Y02T7H+w/eunnrJspCSJxYM5NSwSwUiAjajtu6HYNgdSKijoUiuTBRLyqOnIhvvf2V4zv3f/H9v3r40a+Ojo8xTuOuipAyORg5dcTptVmlZZjVtAzKhKM61YgX5q99+be/892/1x3dON88t+3Vrz97//PPny0KT5l61Cu07rdD198qZ2YV5XgYeu1W5nF888bXv/p1Xp10x+txHLWUcGMRFtpPE0GSgkVZOI0IWAw9IbVqKb15cpaO+/1++vzTTy/Pn6+W3cXFhkQ82tPEVE32kxJ5hFRLFUoIkqnRNiHMlFBiBrTvlquuXxfWXJcuY4LXhQq5U9OBCiLiwAvjpEAmzV4sEdHoAwRGRIg00oIDKaCgeFlhE0mjfyYSaebMTJAksAiIiDukp8rNO3efP3+q/UBEcDS4CkAy+vUy92OdjIxZhaPZ/M2yw5nzez0Py5czgMPYAHkwUdEIb5wtntt6Xa76s+ObxBqN+UTMkjZFnSzDmEubChHD3aJZKQQ3boFlIy2wp0mocopoQDxNqE0IM1p1g5DCylK6gggiZlBGmrtFhCd5ZE0O5mmCFg6edtOvPvrk9t3Xfvt3v2tl4MxqMSvdE+RABjN7xDRN+6t9P+g01ppVQpBRhFhLMlMKo40g0B/d+vY/+C9f//iX3/v3f5STn9w4lkQVKUJCHaZq1dMMgYiaNarVALr1kpLRL+/dv//aV779/CpvrIj6E396/uuf/PTZ4yff+MbXL/fbhOV+n7TQdLN9WffQIaUrx7feePDG2a3bWgYDpUBYY7Lq1QF4qhbkTC0OCynad912s2Uty77PIBAPK0nHrTuvfuU3vvH9v/jzjoG1P9+NRYvXECkJT6DJEzwCCFGFeaver4eehYUJnZblctEPA9ykKDNPl1exOMZqWc1QCoWLFs+ZIw9po1InVouYzTcimalpbVsZxMJN+ztTeQ5EAhzULKIcFtS+q/kXgCkqnJm69eJk2o2GKqUIg5mrWSZLYChd4ZLI9ExYY1/N3lsH2tC1vKX1w18UFRNRZBKTNjUagoKziG5321fevLsYFlY93aNWVgHBvWZEeDI7MswnJhgCCp+ISpdCZh4iTcggRFO6QDrSRjoCpbAkkpNJgiCsCpZZDJFhYebV090sMuCWYZHBSvuraTeO27r/8pe+/LXf+p3UwiTmIxehTMpoNFgCMLrt95uLy74vtp88kojNag3hsmDhCkKnHLAII/Rgr7k6e/CP/9v/4cXnn/7kP3x/lFivj6ftdsyRpjHCCUjJyNxO0zT5g3fePrrz6uro5PjmDT6+Ld1JX4Q7dGP86tEnv/jpz956842Lq2fUqwIYCjtH7BbD6f5qh76885XfvHnngZblWKMGdYtSPbJGZATBvSnmkkWadZkoAFDKclgJ7c0tRep+mto1GXF8fHL/1fsff/DzrnC3BxBdp/sMy2bxk8qC8GpOSRwBEAuDWZiJMO3HjmgxLJedLlRKYVTzCi77y+fPdNkJEzHEwV3v5hBQsxgGCQgR0sSQAQJgoUVbtvcks6qqBHIzEWahaLR3AjFHIDNV1ayKCqsgEhmSBEQNZ6HSy36/j91lV7puGEQoI2a+CrO5eUaj4XMiWbLVV3yA/q/dUQ5tAA7kOSJkpBJRIypSslncvn1ntTyr1dtwX/sSETZVd4swKdy4XMSE9NZea99brUQCmTUnYEoiJjZvYA+nV2IoSyRSEgHJKMrCTIyIRi92JMIiqkW4MqNjm+p+a9Vc++V/8Z/857pYoCwCntQa+6BMz2i0dBsNyKurLTNFhFc3SjC4V0dGHBgpSYloCHWdbDGUiBwrFme3f/Mf/sFP//Zvf/nhBzdvnWbNy8vNolcKJuFuOFqUk1dv3Lr/7pexOlutVlrKpH0Whup4dRXT5od/9edLyLLAiGFThouwlCz9yaMnL268+vZXvvqtxfGdyZCE5Zpzcncnd1EQAxOaZ5eSAFAWgKtNwzCUTrebbT8MGjHubblYSDFUO755Wrfny+XixsnJo0efDypjdSnaqSIgTAKoUCbqOJYFB1DDhQkMiOx2u6Li077jZU+gcIwjoTSD+l2Y9Hl0/35ncDfvtRsWnmgu50JCgcajaPzwTDSTAWKKiMgGpiMimDUREdmE2jPC0R4boRu6tKQ8yGXTPcLqaLVWr4mYduP58+cUtDpe9/3ARQVsk/ei+xgBZ+1mzk9LF3Ggex6UzYfE3+b3DeukNgluJriUoMJ8+/YdZYJQGJqJfViYGYEJLNQ8rts2ASbKQgoxhjZBJMKb3p24SYzJkUIsokCAD+RRgmgRJQYHI8PrVM1qhiM9Ce5mWZFxtdlFyHB0+lu/89vD6V3LMJIIoHFvKNsnmSCbqplN0xQZnDnWMZusiYmJF31XPXpSVmLmCE6SrK5D13x8Jh8LM1H/9W995ytf+/rF1bM//+M//r3f/4+2V9vV0VEZVlz06nK/XKzWN2/lcq1cEsGlz0yz9Mvzv/rTf3N2enzntHv6+bOb94+4qDkxk0i/s7h9/8E773xjub4RrixZlD0BpWaWBkbdGTFRcjbjQGawhLsW1aJh0fcDAbv9rh/66giWxcITpvfvf/jz94ZVv1wM+3FSFrAwKGowSJi9tjyQ7pZCKeSN4s8CIjM77sqi1/SEWxmKioZ5wuHT7sUTTz+6c/v49EYdr5iI+oGTpaFHlJlw96aObZrr5pMc4fPFfKAP46AWJKKMSA0ioqLClDVA4ebhWWu1ahbV0kmYkus4WnpRqdN4/uwJAl0py+PjofRSpBep4dVNSACAk5KpYZszBERfpIO+7JUDkVARQYJZiLnrZLVaTFNNBDGHNwloI5umFsnI8AwPIuamhGMWaMupTJo1Epi5Q1JY0KzRweBWazVXXhFV4gxCwDPNax2tWibCoo4T0kqRy+1eF0NM9O5Xv9Qtjz0jJcJqNhqCEHtmhoikGYSypkWN9ASYENxcfCAqgFISOBKipXF2M4B0ckvRHp4Ro0++81wfn9xcL/+r//6//8nf/uTG7XuenNq5kx51q9Ob/TAYSUSkCmWQRR0vPvr596ZxG6jmfnrruI5jx9CyRLJ0i1fv3jm6cbdf3kimTFdhQmoT4qYzZR0rBEysOsvrGj+FiBaLZVEJmU23uOnOAkLUFZ1GIZbV0dHnH9tMhEcQcd9rMimRCiexTVPRDioh5JEIlK5TZpumqGOwcKKOY5bT7EuSJKfvLcJpynp1sZ92OU33X3uT04FoohhlZlDrZjOTmgeTCEAezW88I4ODm0yCWSIzwpkkESodEbFShFcfp/0EkFeLyHD3dBKezKwadaqUQbTsSk51e3W122+naVz1R8NqWCzWFUYCZ6KgeYgDIJ1J8LIXPlB+XvYAISxazfp+aJzS27fvEjGzuJPbBCahawqqgCCKyNnanoMbJxHCqRLhLNR13TTtZrowMbPMLUakNzQzk4hEFZlJDkLdT1Ztv9vbNE11iogGH9hUb9y4dXLrznq5qnWIQuG2u9qqCEAoUiARSTn7ls2tfSMeE7x5G4qwsEA6la6U5oAFdwQpIYUaQzUiWDhSSxGP3Xa8UNFh0Ft3722u9uujlUCkk361kKGvDQMhoYwSVveXjz98/8XzhyrbF1eXbFR67vrlFDrwcHLz1unZDR1Ognrqi2dqs8SMyPQ2a6tj9QhQsIqwSlECzL0URYKFM2DuIjxV8wSDI00ZU63KCas+tt0iLkJIsMKQXVcoEghz73pdL4cxLIowU+6mpTLcitLVZuxunJROrra7vrqSUinUFdKK6hZJXqexvnjx7PTmrSGUpGNKCKP11umtJJ6TIc3wIpiU4OZNQorZujTaXdB1nWipPvnet1ebcV+FMhrLORHuEKrjBEol9nRiJiYiXqwKU26urhR49vCzqdZXHtxbnJ3UrtSonJLNuC7ADd5MIp7NG5Pi4E84s4GQ0OVi6aORKhOO1kcZIEb7SpqV8xyehLY1gIpqmoW5w5m4CWQQwSIIkPCwXNXJMpotfYqwigZgbpFBDElwGhExUGutZm7TtBvNDZFWbbPZLY/X9x/cX5+cFlnUwGKxuHixKX0nRfb7/aB9VFgmqyBm+0ghUmFjdkCIWWcZXXrKIKV0M3OwkIWTkyqzsseMFQdASSmk2lmdSMMMR6sjFkkHMaTT0vfJIkTJ3WSp5DFdnH/6yxef/TrrzqYpRi+Loe9Xo/mD199YHd9cnp1QCJVOmN2qCAMUnkTJRBZRx0qSIlTHrOmUmcRD32kppetsqowG7AYTKws0PQDkNNWEZdTt5mLcXymnUrbbmZgBUik+jtU9KUS7YdVbpUwvhWyfhVGnfdSxCK/WKwNB5MXzc16sTs6WpZMQTTUfDebayebqant5OXQr214poag2ywyLaBxwmXVSmZHcXEfb1qlA05cDFA5RKV3f92W7uxqn3W4/TtPU5NR24CuziKc3TMdqvSYzB2FClsVg55eecXJ6/MuPPvyzP//g5r3b737tN3R1TBRIyUwGEzei+8siaJbK8BdQIU+NBKuCgrlIkVqdgNkrRZiZsxopKElYwoyIRBTp4W0KfdAMtO1IAWYtRTJjMjfzcZxcvM2WiVqf3DaXxOTm5uN+v9tsdrWyYKq2r3Zy4+SNt97R9VGQTM6QmNyCw+Bkk9m4GetiWDB3Nk6tqG/DMyQJy9B1VisBYHASFVERiyycxNwsARuNByChJOXqZGHai42VVZilWhtbsEhn7GAtfV9KB2GQeCRBxOrVw4cvPntUx6vNxWa7n9ZHR1oWZbF4/e6Do7NbPBTiQQcBS0QkIt2SuRSpZhFh05SzxwKXUpi4mrlXc1WiJkqu4WkhIqpMJFG9VstMkhTF+ZPL8CnCxv1GlcyyKyWVRTswb6eRkNrpctlBICEdSVmUq50XlW2dBGQZw2Jxtdv0fWHY1bMnx+sj5tIVNWahkj4KYqr12eOHq9VRWcp4tQmSblhONhUtB0+kBIDD8i/CzCVpJnMkku5SuO97YTWv4zjud/s6VS0cHjbVJM5IZklkeiTSRmtYjRDrMNRxgjNElycnl88vKuWD198+PTvL4n/zl3/85a9+8+a9+1TEwwgcSemtDEFz+J2JozlHQauUlFhVqLot+oFFMBkJw0NEKTMZompWIyoAJvYwYQ6Sdo0kDnbaM5+oSagEiWGhnfYkbNXNxswGWAHZHi2QOe53+3F0ShvHGjEshtdu3Lr72qsWsg9M5kU5iSii41In6/uurMuLp8/tcjzmU9HOw+Hohn4yb8NuFu6oN6tt9ieFPbNTJuKaUTOFKTySgxiihVkw0oS9RXBR84mj8Ws5w0m5QIS075YICdHMxnWmZ589vPr88+3mchoNyev1cemHs9t3j0/uHp2eQRREWgrN/ttEScnibkzIzFo9qemQ0j0Is1C4AW7mYja2H0eKtj6OGPAAQoRtomk/RYQyzl+8WA7908vL5XJxtauLoyGDahgDfdHIWK1WrFx9x8iivOoHhDX1X1+61XrBSBVWkRjHq88fLl65D4i2xOvBhank82dPWIaT0xsnd1+lOqHrD6xK9kCTlIo0DgAzKDjTU0SQaeFtLDDux6LuUes0ZYQwKGPajwAig1vaTgSioXbIWbBOwcSS4Joope9Wi91204mubtxIttPN1Q9+8FcPnrzzxlvv9qslszE0OnVv9qA+r3Y6MOSahpIBjQiUTpm6vnOPA7caiWYQRgJQID0TUCYV9TBRifAW5M0iTYQbEMzCDXXS0nfDIkmkc5rIxz0okUGUZpWVNpvtfj+Nu3E/TQbce+XV49OT5XKg6CIsAsIlLTxCKDNDkOZVihzfOHnx5PnzZ49OT282CqdPVUnMRubmlTWPHlU5PaVwJiKDIsl9djNTQqJ0YBLu0rqy2+1QVFQbJNEEMho5TTYc9aX0CSJWq06wq6dPnj9/vN2cbzdXnrQ6Oev71dHNGyc3b7B0NLAnhClZMiKbRbOZpyFzt5+YwI1GRtKpONLNGwuLVQ6mi4lAdaMOfdeFR51sP1ZWHbd7orBxqtP+0eNH5jbudl1X3P3oaEUqpZSLi6mTVKGuXxBR6bo7x6txswH41v31h+9/AGRHPBwvJg9SuX3vzrNPPu96se3m4uFnZ/fvZgPYlaZxWp+up/PtT3/0/Ts3790fx5sPXldQWazHaRLhZFYRygz3FDBT21gZCU6KyDpZRgZiuRhYaLebvFYhROQ0ThmOmbOsoLbW5+BHIkxtbEDM1Hu4eySoGzqz/eV2c7RY9MNw4/aNR08//fl7P3z28JM33n77/oPXsFinhUthMxU0aUbOM7qDclJElUWLAm2NaYCvDTJfesmpik1gRvN1I2GAHQiiCNdSSCUDRCzKIhIWXVeYNMEsHCDOkjYRZ4zGHKqYJrvcbcf91A3L26e3Tm7eEBUz1FBi4l55rG6WnKKA+TRW7YWcp2qkdHR6cnlxcXl5OXT9YrmKDGbmItNukgYmIg6YF4GSCQlEreGuonNXll7rfhj6XtUWCzOLzAQzc6ItjJA6TmW5HhZHLBoWua9Iz+ni6snH588+3W+vZDmsF6t+WC+O1sPRCZUuRZ0CIuapGUSREZPbVCciCndhNnfVjrmots1L6IvUmGaX9kzPEBZIUsDdJ6thXutYlPfTSJS11ohc9P3zp0+9jgloETcMw8KEKcFJJ0cLiyDIcnW0XC3CalkcxWgl4+Tk6Mnj85OTRUL22+nr3/oaEz9//EyKFpZqdvni2fp0aZU6kWHR+RgKvnN2Nl5dPPzlr07OblQZSEvpSp1qWQyIADPSbLLW83CDUJAZZnVKyn7oiWm321arXV/G/VjHad7Ap8zE5t7IOIEURgZmeR4Jt48u2dMoA8SL1cKi7vYjqxyfnq6X69jEk0efPHr4yf1XHvzu7/9nZejdphRUYfLIDA5haqL2gyJMSkEyKZj52iyHRFrzQggiEmdPU4ibEzGYJQStQpg1D8wMiDSxPjGhaIKSYElM4NJR2LjfspKlRY291X5xdLTul+ujbiho9kmlrfPJBIai+5iiQYXViRnJwiwqEQHCYrW23X60qV7aarlyECFK1427raq0DRlBnJxo/Vpz7AIinZLC3ZKEHMMCQl2nYymCiMgAyCUg1WxYLZdHp0JcPZAQwMft888/e/zZR9txx1JKX5ZHx7JYl8UgWoibJ5Q0b70pRo5s2h6aDcea/bYos3mYZ0ZYRN9pEwGoiJlFRFkqApvdrpSy2+6IqU6jjbVbDJvLq77viDFNu48+/qjrdX/lnZblqteh67W/utweHy/Nqu/Gm7fOjo6PhCmYJJw63Vxc2FQ7pvV69fzF5atvP6iiRHLrrbcf//pT7jrhmKptr3b9cnBiitjXzdANpe976j765OH61ifvfP3Mzbuu1yZ8QYYbkOnpEULSaMcuMU41CYF0jzHHyGDCfrNvx8mmKsptptOeUTQHzpnNGaKF2mBJ2SME7MGSGShHR8dj2V9td7I8vnHvtZKfHw3DBx988OHHv/z0//HP//E//d8NRyeeVp0LicyEJKZEu3EIrAeMk6lxgZrpnTBR8cic9khYmKrWan3RdrAqOTEx2vZZEtEECAoGKBltvEbcemOAIiHSLXofd5vLqh0fHZ1Bj5mVhNxrNeeSmW7OGclCGaGMyaNtEmmOm7MAtw26k0g1w+pULy/PtRsISHcSGSdrm/+IWUthcIQnqLoxMzssoxnldtoxId2QWC0XHpkeNWpoqcgcuqFfBAGo7AAwbS6ePX34/PFj208FyYvF4mTNi047YU6zPYVUAzOk9I3S4I65XDyU8UTELCzMaFbDCLdqmRmiBIJXJ6ZxrGHNFSYTQUGZUa3GLrmj3fZqGq9+/sHPu75/8eR5PyzBVJYrIvWIo9ViM47gUoqc3rpBkVo6uGhOk9WrzYY7vXHrKINu37l16/6rz84vlsdLTrr94NXNxaY08iAwjZkc07Q7OTnNsBinRddtdy/ee+/HKOVr3/zWuM1+tZjXimeoCrdZb0YCrLrb78fRpGmPmAKw9rwj3X2sI7OYz/t1QJQZLDLj9kzSTCYaTgefR6fMYcagpLI66gDab6pyv1idHi2WBv7ww/drt//D//Vffvc/+YNbt+5E23MhhWbvAzDDMxOh6S6dsrCKtLHRF+YFIaXsN1uAPbNtS3F3KfN6tmaAjBmkFZC060UEQiKiyQKWJAczJzI4gkrR4/WqKyuj3oAW8EJZayBDhMAUbhRRp7a+IjotrUPKbGZEbG7al8hG3c+63+12++OTI+kLRUAYkcLMXckG5npKs0VnznAiEEd4umatNtURRMOwkIRndOiCYjuZMgHZiVutaTZuN88eP9xuXmwuny4Gkb6DDEwdSKPG6BZedzGzMVl3pSuZwiJtpEgCIW1TWKZMZMOCiKRpvCmpmhGsGUoLw6IGok62WAxXl1fU3MfdhGU77Tfby8cPH+2222E5kDurkioRd6ThUaRcbHb3X72nUqRnEHEBkTz9+OkYSYp+MdQR73z5HZtsdXwifY9Q525VVhmV0zLdE4Jcny4iUxLd0E/bq4sXT4+X/Q9/+IMHb725Pj6bxrHXTAUlR6QKk7BZBKWb7cdJRCBUhhKAT1OdalTLCA9n4QwXkdl7KtsmSTDLzJ7jl0oVEglrvjOpXbFaJTKTh/WxwyPFy367m85eub1P+8XPfqkL/Zf/4v/5H//BP3jja1+PKTwsUWafEwDEGdDSFRKeOdMZxG3LQ6ZHRti8adQpoarVXJUjo9Vlee1HQQxSAoNSNLWBT806pXBk+Bge5EHDYrlYrxTs4Nb6III5qzkTgdnDExBGIMxNinqkCmNGTNIjk0JKcXMRcc9h6G2a3PcXz86Pbpz12jmCZd7dAKB1BKQ8I+qRAIwAIhGxxjwx8/CiBcoOCg9FqJR0n84vPSq5Xzx+dPXi6eXlBYR0MahqkDAD5jUsYpZaZ1Dp1apHBETIhJuMrgarISAhqmJhGTG7TUa6ecIzIxwsRMT7cdrtZjbedreNsHDPcOWyvdqyqu19e3VlVlVCwOv1MsEZkMJpMe7txunpjdOz/W5/enJ6fnFx696tj37xs+1mV4pSFtJln3n/watPN/thOUyei+XghnI6EHO4j/td3V+4TUZRVJzGpcjT/W672a23uz3ypz/9yTe//lv9csFD70mUGUaGVAaJ2DgmQCRd30M1QeM4xjRFzBbCrRFjbiuf4nBHNvEJZ6Q00XgGmvl1RHVvria1TkTERQCkpXC3WOmSRZ7j4vz87PT0zo2bnvZic/7v//hPxtG+/JXfIAIXD2ZJyswMJ7CKKiJwvbKmtYfhgQCReQRht5+EKRisB4Uxk0jbvjjf523bAEuIECKQUOGi7G51nNo8ejksmNM9w4NVMjkmz7Z+hRkZtVrTCZsZefR9FwArX7fkMe8x4MYZZUYEUrE8XhPz1eXFi2fPbt6+JZ26jZTi7d6IbNu+ZtAKYG4jQxrN2MNsBmesC3YFSAicjprTfmu1IuzF46fPHj2uOZHSarnsuqWWIZWnycw9LJJQqwtzArF3IjEOLQUIYSLWRLhn+sHTo6G0zW5MiAAPt6mqihQ1t2kc24eDhPu8g6lQYaWMyFofff6QKRXotaxKESIDdavFfjPWvS+Hcu/+rbR6dnq021+9+ub988ePXjx5rhQ9y7A6Uhm+8ZtfM+6GlTKpKhtQhoF1INEA9WcOvzFdvqibS0tfd91+v/3wV58zSeysbs8/+slPNPm7v//3Ly8uhsXSgoQig9JnD1Qw98oiAhFrMo/WZWa4exsRMJM38+K83owxDzHdPIWYSZSQGWFomgBihbp7mIt2RcnMBRSqJzdui+onn35GjNv37z787On6ePlH/+YPOfjd3/gNdwTcg4pKW4SsESHNrdm98UyalKz5+zPDrAqxMLJ6IFkZKUhvHjitAhJhpgIWsCBDS5P/ZLhP474fukSGC5i9RiDm9dSeLMggcyekRzSKbtvK2JgxiACRMLtHEnNbVZ+ITC3cDMHNTIgWRyvu5Pnzp48+//To9LSB2k7BTsiAGVk1MyahlpEzqmXXUcJnn/OINJhHEieHWhUlCbu6Ot9uNpuLTRKKdsOyH9ZL4Y61j5qrgcPDzEHh1ab9aG7hKQVEmW0k7gBH26PTWCiNJxOeTs7zokbebrYkgqAYJ/eY6sRMZk6EtgVDhMdxyp35NFLdZ73avXjes9w+Pd5vtpy0GEpbDRbp9+7f7UtBYNBuNXS9188+/GWnEFmsh/XZrdtnd252Jycvnm+H4yWCquewWHI3oHSUPEaY166TxTElslg9Hrof/OBXjz55LEX2l9uzs3W+OP+3/59/8fobbx0fn3lndbLS9QzJTOZMQnh0fU+gaarjOILbTsGDDRVROOZ57UGp0yaq7qEqzX09Ijy8ieRIKLytIyMiDiCQQsIMQrgI0eJ0xXELH/6HH9dtfff1r73yyu3xxfbP//xPb92/vz69IYK2qoilvU+eHf+IBRDEbDjXLGNm86q2L5OIQOHZ0nuTTbCKiKJ5g2YywCKJGKfR4B62XA2qghnjJlIKZPW2es6JMtMIEe5eG2+kjRHhFla9VrfJYt6ig5ZYwl0Y6ZCZcURJKczD0J+enFmOV5cv3HZEYEKEZSI93GyWvGXWalYNicbJbZVSZFo1d+OsFNV8f35+/ujzR8+evthtR/e6Plqf3LhxfHZHuxOWZdHFarXuy7JIPyyWw+Ko9Avteta+Wy26oRctaNAaMzPMpsjmPx4eBkSTpiR8GsfJxkgvQrVWUU5KdwsPEeYkILuuaCmlaCL6kruL58+ePOq67uxsjcyuX4AFKAkeaz27fVJKb4bV8XFw3rh7+4d/+5Ptfi9SRPpX3nnzzluv0XCyT+2OT5J6ksX65Ob6+Ea/WHe6KMNiMSyXq+NIleFIV6dc+ocvzj/8xWfjGH1ZSGEiRI3t+e7Rp59oP4w7m3Uczb1sqpGpRcK9uo37fWbYZFErMWa9KeDZJMHhrYQEZoNCAgCRduK81jpNNZFhztJ29TITi7CwEouUTkpPoixknm+98trN2yd//pd/fHRWuvXqxt2bn33+qz/79/+OI2uAmGuNJl3WTBBxkw20jVfM0uZQBEiyaonwMBehZgbSsNE6P1kiIhFmzrZhJTI2281qddR3nagi4NVYZUYGMqlZaBAFwiZLIvcID9ZGK8qMICJVTVARMWsuxvOWlRa4B1k9xWxymdWCIhbrVbd4fX91ebXZeGC5YNGWdrJ0Ep7unpFaips3nIoZ2ZwO4OFeSnH3cT/6OAVyrBaEilid3tBuGJYLj4SosDZliSSJdmaewGrd9/1iP+4IadWTI6MNzSMiCAirNYKZgNIkG8KaMQ/8CTyOU/vQGNSVjokjMuEqpXHbG9/R9purzfPxastp/XBsY5UiSpRMm30ulqu79x8sFsvSlQSKlA9+/sFmnIbV+vjo9LW331qenE4OXXRSVJiL9othoaWPZGeyCAJJhHsuT04vX7zgnR8dr378F3/98NEjLgJhYh4n65QZ9PMf//Crv/mdy6vN8cnKkVIokEBqpywcnl69aSkjg0Uo2m6OUBHRDA8VcfcMZDaf2BSR5p7Z1sUwIyO8zZWB9Gh8SItk5swIQhBUNYyy0zfffn1xdERBDz/8FdJzMhj90b/7w3/6T/5bZUkgVQJJTlqr9V0HpBA34UCj0TfRJKuo6jRmRDSLTDApixNA0pZ3zDwfRkpk5lTrMAxD34H4UHBzdQPa0iF4WGamp5lnIjOQ0VYNuhmIrBoTiCXdK0BM7u7VtWirnQ5zvNY4BTORKJCWySGcuTw6JS6bq8t0rJZLLQWcjceB8CIaGaBMc6g1CmmE1/2UFOy0vdpkBDwQUbqBpSxUl8uldh2CZR7/N2G3sghnNCDBbVLRrgwIV0ame3i4ZUKUxt1I3BSxyHQkgiijFhUpYnXSIl7NzU1NmMHc3DsCBAYciahu1WrCXzx7sdlenazXQpGMvu8s/HIzkfI7X/7Sar3e7y2liMijR48ePn5y98691fHx3fuv6HKlOhz1PQknpfR9p4VYkAjnxtkU7jgsOGzardzuvHPvf/xn/9PH772PGoujvpr3qy4oL6caRKfHt6c6DctBSq+qSAbQlY6LpoOLVMCdImKmCFGjaSFoZswRqLlNRoK4sUrJPSMSCO0KKEECi2ZnZGHMTCyUNRNmEYxwSOHdNJ2sV59cPP/xhx90w3qf8b2//pGP0Vcs9ej88kW3Olofrfct3pBaVBo7rW16mQlD0ZTlJCBmIhEObxz1WivPk4LrFfNgmeGqalVUFosVmMKTlTx8Hu8FPJ0YLBzmaMxF5owkknCbPakjZlejCI9IgBnhbTV06xO4kT8bAY6YWdnblEo1PBkcjrJYHGs5f/7U3Y8XxzoU8wxAirgZsyIgyhkelM2TiwhJWfdjWwSYYGEuRQuo9IN2JZNDkqPNEEmEVdjiMGgmIlKRKAkPanFNzMkcYVZrc2mOCOJmQJ6iyIR7OFJV3UJEQUj3yJiqj/up7wsThyczIsM9itLzJy8ePfxs1WlfCB5DX5LSIlC6Bw9eGY6OximH1bJIv93ty3L1zd/+vfuv3IF205iL5WKxXM6ODI0y3G4fkDE65qzOObHX2I+yubh9svzn/+yf/+qHH5aMiJiAk74Q6Gpf90ZvvP7Gb3zz24tlPxmBGCJAFtFm/cDMyBSRtnFeS6EMj9lNOyKJJOE56xeJ5drBFkRgQdPtpqNxabVIu3jdA+Ygdve23IKZ9/uJDKH1//4//c/nz59/6e23N1db7ctyKU9f1FdvvbI4Pt5ejKUbte+ckyIUzDic40OhDRzs44i5GZaQqIc3PVd1byo7aqQIasMxbrzwxTA0g3zi9NYdZqOBh5I2tFCEazVw+6kTmdyWpzQ5HYAGASPDfR7ZiaDZwkc0oyNKWGQpmkghafRvSLoHCUmARI5Pb1y9OH928Xxhi+VyRUi3oCS3ys1vHuEWFk7cLKAdmUyk3bIxpLUUJBpFNIH2/omk7VNqRHNWTnBGcqEI61XMBE3j5I3kS1pkGmtE8w7JRrZtfsxuNaZGHmFlSaSygLjrh8XgYQ5QIgJp1Sp57MbHnz0UN0aI1WG1CsKmxnbK5Xp1evteKYt+QYt+Uff19Ob6/ukbGaYkpSuLnqUxt5hT2MNEOFvlGskJ225ze6lCyq45fvb84R/+L3/20w/eXy/VPZ0ZXUavF/upPzp698FrX/3q11a3b5kHqOuG3twpMhAiks2/mVD3NRBNFDYvGQUlsUh6I9JnWgYBTOLm2e6JNk0RZrDDZy1v2+seYJAQR2ZzTwaBmdyj1v2f/Ph7f/KXf5n78fRLx4+fXDx449XN1ebqav8P/qvf6cpiXFYQW60kysya7loKvTSPaN0vZiXYjBgSCSMswxPk6QwmVW7sN+aDM0P2/VKkayaeIHjr8Oc1Nk27mOEpszn1LFWLiACEmRsNmwjUIMNkZhZpwv6wQEdEBPdp2hMJMXlGWKpozn5bTJxEDEjYVHQ4u1F2m81uuxeWbhhACHPtODxw+LjbID+CKEU7VVWALBu5V0SIwI1fxCKByOYDElBVMPkUAFglG5wHEskASZtmQbxWkJeOmWHV3a1fDHWsyQFk24Vcq4uQTZMoc2Gm9HQtwqpmbp51qgl4+sX5s6sXVyVzebruVI396mLcuJyc3Pza7/2e6xAWvaiPdXlj2fc9DzpO036/J0+mYEi4AVynWjqZtlO618lZ5Pzxc582WffPxu3l9vLJp5//8lcfb55cdQAEV/vKRWTKo5A3v/TWnfuvfumbXxuWN0hLKUNNTDWoKQcTjfWBCGJJpLlHRHqCk7INwEOE28LMxr11d5bmv4SMoNY3UpK0rpg8Q4KIWydADTCN+fJnN1Jh6vkv//hvhD2X3Qe//OzG/VuXV5eTx/rm6Te//k1dropvmEQ1p8wEtJSCVme0JnhO/zQ7DBExQ6QRtdmsvcVsRr5NlNt8UZrAphRFhrcTQggLMCJnI4ymH52lfrPqldORnHBnJjM0eZeqgiNq0z5Sk5iKMIFsrNM0gYgYbialI8zW11okfJalurkwR7qKLtfHwNV2sw33buhFJT1ahhZRR0YGJTKi67rSSSZbRiaEhZi0dDSTO9jDWQSCxskgTmSKAJluNq9JjiDi1r5T2yMkolqm/eQR3DGCI6BD1/xGw6JaLapevY389+PUlY6V3S3AtdbJbDKLmGw/pufyeCg4LpLPnj2XRU9Df1rWD955t4ZONQGJKfvSl6GPyGmzd47t1fbKLzpVUV4tl7Vav+hePL3Y7/ZCdHWxnfY7m0zVnz97dPn8YrPdnF9cVgsuPPTHlOXO2e318frk5p07r9x/8MZr/epYT072UxSjyZKYtAhIIh0BgjnQldJkqY2NBjQl98xaz4CHq2q4E0PBB3QysvklcBsxNdPFBvs0BTt7OCV5xIzDZFokZ/7VX37vyZPPuQaQi9XR0WLYXu0CfHZ29Porr5/vN5iCh8xIVU5L9QhtTkWZkdly8HwVtBXQxMTkNTOh2qAXBJJ5rpOIEiIWPqyWBA6PTGdhDwdnxGxK1xZqiIiZubuqwODhredudI+5EFROpHmAU7tCoHEfoCyimVHdMjIpI7KIthSdkcIH5Rpg1aQwkjjIzVV4uV6Bc7cdESh9SWp6a1SvSZyZnlG6wtxq+qTG7+U58TRIGNdTeiJqvVdkeCPWY+7OQSxqU01KkdL2jBK4VmNR7cgsDOCiaItXCeDoVH0yZs1mvCXwyDQnQJmnsdaoYUFCpet02euwev7sYjn0qzv399v6lS+/uTq5RcOZ94NHshZJ6QsxXIDtuOuY5ITH3baOttvurra7aT9ONhaR7WY3bidEFC11mqb9VrpheaZXk63PdL8Z77377ptvvdEvVmW5CvPF2THQLY5OvevCczGoqBJBldvGevcU5Qh0RZEYa23O2sQUjkhvJbObM5N26tW5UVSQ1EgASRlg4bZhKiLcQlQbbxRMQUHM7i7cOjIQ8TTtbq2HH/3gxwy4qkSujxdhUck3V7s7r95ZLLqnl4+1zDJ4SoGkNtodgRoPeE76DJGMRGtXRJRK5ORN2t/GsRkgociEUFJ0fcekbu5maA11Uttj04h3jSvuZp6RHiERCa9Rrbb6q+MCAjVrsXllHSMQmSzz7DYcbk7CM4WoYxb2SGagucoi3V2E3aOZ9qkyMWXN1dERk4zbrZEfL1eOdG9iG48kEWl0wPBU5QyQzD8GIi2cml5JNd1ERUQaYw+giBmMTSA8k0JVMHe6INWYIpnTM8AQdGVh5uHUBEoikppCmpFpFYBNRkyskuae2Ry1RRmqq16LoGM9Prlpdbp559bq+ASpl1c74xIzKK1FhajBhbxcrKbwZVn0urTB+mWp06Qdj9PIlNurrbK4RXoQkRSYTRn+jWZhoBLBpRtUmqtAOhWzKGUQ1nnJprCKCBMDXqdMTGMtokTi7gd4vdkgcwai4QbMc6pinb08o9EEKSNISIRrdWby8ObwRgFSrtVUdHKTog2u4Egzo2l89uzyZz/+6f3XTjeXu34xROTott9PV1dbcyfWOk59UU4wIUCO1EZSaJr+yGQks7SVTORtVhlEhxopMzMp08MoKlFBg01ZREtGzCM05mj8Lxy8Gg+7RTPbgrF2DYaHMcM9W19oZrWasDQLI1HOhJu1KS03qqkQz3EfbQZHyHRYNWK0MG7syzY/zeSckplgGPqBhaf9frPbL5YDM6c7cUsyMVlT88CriygsErXruvYUm308ZRscNAerJGHKcGKEM1F4MnNLEOGhoixqZp4oRWo0qhWHGauywKbaMgWDPDwT2nVWTbtOhZIiIMqy4AXrNNUaSHeWcnR2d6l3hEVYink4aFls8uoZRYQOQsDS9ZRUa2WmMEenquJEulok0HVdeKz7RbjbaLM2k0hp9mcFYE4izGUg5QyKmIikGxCcwqA2i6K5cEfCzTNSRDLZZ+5SWxfrHpHmbespobHGk0UbmYATntUjGIIgFg5DIy9yCDGEhWavA6oeJNz2g2lRq7672ty5d/P/9s/+r8uV2M64zIfVxnEap9W6311ePjt/HFPVTlONqpJkRGi4k3BmQDkjkrkZDDUlWUaYO4tkuBat6fMwhjg8klOUPaPXXogj4AdEKV9uYorwnCGaeWTQ4ByOMG5cCG32m2jDEW7unElWnYXDXbWAYG42eSbMmgFm21MdLOJuoMZOzbbRvT1y1ZIZpEyEalWKdtSL8H6zG3f7YdFB2MPcvLlKmCerpJNoCItoqdVExM1FqO3LaN6mzX9v6IZp3Id7sxXWbnaOyQOdMZu9AMMtWVSL1lqlK46M6qzCQlGjTkYsyhQeol1YDWK3eU0VC/fcix6qJoAhdR/OJItFQTAQ49jDCZ4ewhT/f67+rle37DoPxJ7xMdd69z7nVJ2q4jctUnRkWW1bQluIAQewG0j6A+gOEqQ7jSQX6Yu+y7/ID0h+QJDbAA30VaMDGEnDuegEcWzHCGzLttqyRMkSRYoiiyzWx9n7XWuOMZ5cjLl20V0ESFadc+qcvd+15hzj+Sz6Zr7q/bTA0JjzVJM1ZC8DprXxTrfe7anqwkvJA7GiuvnwFVmVTpAqrq5CKSBCh6vqPM5uTW0W3zZfgI8KwZ57BVoRKtrVqkhUdVdSrjlBIKD5gLCISrYKsl0yVGFWsWDOVlYVYqaJbnb78R//8J/8s9999ebx5x9/YRtfvR5PT0++jUJt7k/n/Id/7+//5r/9l5mZ9xIFJ7exubm3QbJBqqHeU2++SKMhDRObeWpUQJAAuv9NRM1dfO9yROECKkWtBfks8SFANd3bJ78IWCmQrHDThoRrNV5fYSrKvGK1iapkx+sJNWbYCsGRiNJu4ybFdEE5ItXwM1NFSygFU6tMEaj47dXD/d3T/XmaS4mwUkxzhm0DhWYa5gwC15Ummenm1ZG9RFW5dU8gSA73Yneqpg+XlZ5D2wZnARj7wDVstQBY1bqWr1DqMDWglRNMGWD1Mp8QCGEwVRE16hmMcntwXdJeqTmHjYgygZhm1r5ZSwtKSAXr6jKSBcKbSy95shLCsyop1UsMRK1158BVGYqWO2K5N6l9yogWmcexuBMAKtahidnCWyaz1S5jCNRy5ug8DoGZd7LTGcnLOeIOFnJGpxwpaO5V2QGSIhqVoJjo5HTRZLniv/2//TevH/aP/+Qnrz5876NvvX++O9//4KNPP/6pAPcv4mtf3//e/+u/fTXlL/7WXxwPj+rSpPVVjSTLCiWq9ZLeptLSBa5vgjY+yEILhIQQseGbYIg4Srh0HL36iwiJ6sK9Yve7SGX1d7UTxSqZURmxdmAwZgLMypW4JBKRmanWScaAiA+3MWZMURZTFH2pyhKgMaMFzhWRq6e0qQWImpiP/fHhjOPpfs/zEEHOaDa01d2VpWqdgXecJ0Qq2ZHuogqBuXcUc6LMTKwxgZVrWwUTH8NZLLLb5CE2xlCoqquYsCeBHgiV7cIEimLuompjiHklY1YFmawgisPVDVkBcAwZZpsbY3oHAlYyc56BKkDjjJwlgjHcNxOxbp86z4qojhHTkm1st/02fHRpi6t1A6iCpnDTYdJeFxX19epD2vCfhWrIGKImYjasM0iKK0UrItWWzUQFGdWCSzUFeyFWVYVwnfYtVtdlkq4qUEo7j3q1ZGeVjwH3OM937z75J7/7u4j4a7/xvb/9P/rt3/i1X9/ffvD2q28/ucfDq4fXb/d49/Tz50/+6//H//2DD77+6c8/f3p3jxaYqaxg9fbKrC+Jyzl/jSwXXa2mpiIsBsjzPFUV4iQre+zu8j4CLXCrtvlV9R3WMZHa6cRS5QLvb3lWf2ACMe36gpUtwyome5FisXHfjnqppEiLQ3J1T0ec59mZqVlZq1ApCekc4eIKilcdD6/fDPd5hgogCpa2d7gb7wQttjKRiGiKsANdxK2wjI6V1aYJkRZwSDMevqsOLSaAxSInml42H8zqJGQUVGSMzc3IJh36FjRVUzEIbBhEZlbLGPOcwngw8LwzJuuEhEoVKjLPSAgiwsZovNg3h3TmgkHEvHslxMwBrP21oGgzvbubimxjjOHbGGYmVf2RdkqCaD/ZyL5kalV/irxEqAtRWdmb07oZWhLVu84K45SKalOtaD8ezZRxuSKvM6sfwxbe9MpEoTdOVyXz+Mf/33+wvR4AHz567yc/++RPf/TDQf5n/9v/7M2r9xl4/iI++eycvzh/+tnP/4v/4r98+/p9lO77Ns9TI9sZcmnw1gMvECDb6K6tQwOgZuZGIKtmZlUNG8MNKJWe+KWVmwsmb8GcrdbVzskSE7LinA0gFBmRYjK2YUsDaK2P9THMDYCYmCtbHavqo68CVi4WvQUmy8nTF7SqtMGUbLq/jRAqKpDMLJaoj+1m2ziPMBXb3M207TxmNlxE2+BVnds+C03MtZ9DpVg2XN0Imqm6toLWHaLIzA72QBdmiwiEScly9eHuw8bwJrmt6dnhPgZExj5smA1VMxJZJSJz1jmjRKrqiMM2ZB2QmudxzKNQWaUq5qbmx3G6Dx/egxwgZubuupzVgxRTl1UK1Dfrpe0SLnpfpSuVWqNfSRQrq39I0VWlYmY9DLub6KI5tbHmPqdaMaBiuh4JFQVoo0/PIqmmw7xB+UYGxrDlaurY5SSzVAUKNxNh5eR5zKdPn5/evX7Uj37lw59+8vMffvzT3//DP/nk8+P/+ff/P//e//TfuUM/+uZXtve2sFTiH/yjv//HP/xBBZ6fns9jqplXVR+o1jAKl6OXQP9hcQUCC+DupjZ8qOrt4cH3HapVayzmir6+/g19DBfnjDlnZqvja56RoAjmGcRi31jIatly9JoMcM55zNmvqA3r+PnMXMiM6fJSVUGZmcdxJ3gec87ZEz+rqkpUdenu+yDvxvEyNXfLDEY97DfzDdDO/hW29k8qmpZnMousYkSe80ySpKn5cDfXLnyb0SHIMZNkB6E2DNbDVQ9v276pGqN8G9u2CdR8bLe9XwFrBg5qYr1nqVi1KE6VLApbc37G+Xw8B1M6k1gEHYC6ytqVgKr2QVakuksnjPQtMxxQMRM17ftupRy0HGXlavAlKKcfTkF/6FUhCjdTgbm5eS82M87IIKqqIs+qpCD6RhaqW78Pl6UQWZVVEC6nBJgkiYIA0lEoDYaqCFiSyAhJiAgcKvL7v/97oH72i0/K+fDgb96+fnjUf/7/+/2/9T/+9779za8+n/He/vrh4b2Z931sf+fv/F8r4uMffvx8HDrnueB/9De3H8d2p/Vm3sPLlXcnoqaRMc/56vGVioCN/UG159oWUEjriDqgtCpbB5GZNTs1QEAZ7oBUvw5KHyai1Xr9LEAjEsXznMcx54wCzaxzTRpoWlYE0zizhdMQVHUA3Jp2MpMkCw0b9w9hRZeluT+8enU/75998tm8HyDH2ExNAB8GgQ9fYwmUnWCF9eG02Ks/RRaqYG5CjkVbap5RmaLibr7ZCksT9HQIESYB2W/DTFuWds6ZHee/9GGmKpUpos03g8zI9o5WVGSqKkB1VVW2Ls8VLp3g2XiA9PWtau6dhmPWk8dK3VkOkDX8oVHptkn5RVPmunK1srOwmC+KRWExIStz6joyIpvoVOtDR6AstjNOBH0+LphfVN0oQrJviPaIsgtZ5Jov1Cg0SKGyMpK/+/3f31+/Gvv41rf+wnvvf4X68I1v/cpv/fZf//Cbb/7193/wn/yv/tMPP3j9HOdXP3z76uFD1/rpn338r77/+w8Pt/u7092siqakLEcrv3z7CcJMRZVZFFzXgovabZhvow07a5MGOy+bZFUKxIa7V0SQGMMLBOU47v1Th2mbhgBJRkzlhaIQyCgR3m47BXHMrMzIzV3UIiNmqkplQWEqXcPW8kNR8QaeyL5YWz7egTuZcV1v0niIUkB57/V7Krrd9uOMPHPftyKqytzYYLZqgUK22gj9vIJF1kxVkyEiFDHfdjVtvE5dm6hgx1goMohMdDqxmblV8n6eriAlY/Y5N2eY63nOqhK9RFMQs+6AyAWRd4qdirlV0XzYdXqbdXyOd1hNxKr3Mu3jjc2xLAaQS+pSLHdDMUkmoRKZDS4n08R6kstF84iYVkdsEES6i5qgtHNQWnHQ12bnLrPDWIF+owiBUkwrCypaGgvphQgqSg1V2e8XSsyMweFOYcxzPh+2269899di8p/+i3/6TuX+PP/n/5v/9duvfvSNb3/7z3//T56PL77+4bf/8//8f/df/53/8vd+91//W7/xqx//2Sc//OGf/ON//o9/5Tvf+dGPfyzf/6M/Itk9ql//2tfNvM/wrIoMIV31/vSUNRklQgVjnp8/Pb1+fHz/w69AtaCtXi62pLtaqESUqWXmnGcrQBoPJquIytSs/o16ie0gtswU4DyjQLcO7cI8T5KRedtvRCcjpKhyZlSqsjKryEyYCdHsQWSwhZyQMVykMxc6w3GtDe6aMStSRdV9jK3NwTDebo/d5YTCkgA1bKEaFazGp9fEu1QrhUVDmc45e+ETQM3inK2wUrf+42XWvm8+/H4/z+Mu6hBWJJkRAaKYx/000/OcZJlbb/R9QatK9irVkkG1YpoPVc1MULZ99NwiZM7sjrbeWzozpqogrUXjgiiEYsKMzgeRFSfF3gZap7jw5cze9RvtgIiZgaVm2np6YUa9mJlaH+U+BBIZANy9gaQ+hqJlvyoZ2WJgsFg0k0bMASg0sxtupMiYU1T2h8dtGwxRt8/e3b/yK1/9yU9+riWZud/GJvzsiy/ef+99kH/37/5Xv/OP/9m3v/HNf/5P/8VZ/p/+J/+Lx4++4jHDfKmwuXwmnalOVa0IAc0sc/ae1zzT7ba9fvOeiHYtcVX1lFgNHalIoShC9N3au2lVZqaZKTgjTD2rO8HYFXFyjd9ZIaoZ6cNBmFoWh2t3e1UW+79BAZrpJGjDsn8IiKr1AUfaGGukW+ll7DhTM8vMFmYpWtdUUIMJycw0986UHvuY96kdOgz01xWV7rY8SkBmDXeCx3kCyExAxrDOzYZg20ZWmYlCj0hVcOEEVoBZF02nmw73zJxHqiArzaSoGSnykkWAzGJS1cwtI9WkQiJSvT+vmhH9XTVo77RcJCez1t7Zve4i+oIl9ItxITn4cnlvGIilolWpphEL54YY0HIQJgNNglz/qMUBTQdau1dFO/CHjDOrA62LRLsC9SUUS1QpF0OlqsVy82QWJav8trtvD68eMjVMlba/ef3Jj+9vXr2Pms3t1Hm+d3uvMpX4D/79/+Vv/NW/+nf/q/8Ggaz40Y/+9Bvb5mbKJUbGegk6QJcrl2U90CIiUlkN3j/cHtRcVZOIKCGSxXVn9b9IOvfCREw9ebbUIbNyprr2SdANvKqakVUFLTPNjLGNLGgtVYxZxzlfTpV2VJUwOXOaSVXfwqQIM7XVG2YKycy1vJCduUmDyAIBBaBIZcC8uuIMtT/czCWOGfPcth3Wb5GZqC5utx9HVCZ1LSSN9F0oLYAOGh09WN5uDyJEMc6ElrupupmbqLk+PDxEZiHNDMiY0RgrWy3jzuo2Eu0n1IaJWKBEzFYpQHcdQs0ysj9KJrexMVuAXqREhnXkVT/ZKgyUrEah5ksaz7sm8+t5aMlliZiCVZEdOyPdjbR+6WWtzWwUxNyaumKloBUuPV0X0UsaG6IF0cJh07Ue9x+lhY/SbWLq3UUzox5ePdweH6RLdxUmAtDn6TcqD5UlNHdR2Z0ZwXz07X/wq7+1/cf7/+X//H/apv/OP/md2+09rZ4H26/ARQf0GcnVZblOcYAd2SdmYq7u1RYtASW72KIv94qoiqsqlkDFEdIxj8C+uwMmbB2oilDqMgpWFVXNWhMHznN2h3NmRgQhERVVRT0jCymXUXatvX1M9nAikuTYxhKHqZqpu49tG9tQU6wMpDT356cnVSmmP2xiKrbZPqA4nu4VIcMJJqoEbto1yegs71WUI6oSc5LsdDR3N3eSMbNQfb7MdQGKiPSfRVXb+TB8IxhxtqqmmCxmxNhGaz6EaFdhE+cguh6q2mI713XEorQjUaTXodbM6EXlVFPWizFsaAWs6uOgdUR9UUTkepUb0Em2Iuzlp6Eg7AGYq4kZwqukdCnH1qhvq/qr61HJbkJaGpYeLZtek6YCslXwbPhExdSDhCBY+6v99vgKapQ+HMVEDDWcwyBVzBCDqNRSLpuKH7if7+7f/d6v/e//D//Hv/k3/9a3vvftN292x0X3L/2TXAtIQ8MCcjVtSdvP3LJWF8jiQdYt1m6ZpV6pzHlO9g7dAIWIQLvSvpLzTDGrmmLaCkqK5Cy0ZzJrbH6eMypMLY8wt4ouloIKzmNmU8ogsqzRmAYaTQsVc1LgZmMblTUjM2rbh0pHBIGQnFlkniGeEMx57rf3VTQqjDRz3eQ5n488tpPmoyGT4zjJ6kybjICbiWU2FiJ5Bkcvt9ZdfayMICAmut/25oN6nDjnuXDGqqgzIzIyoirZ1JtWN62nD4+MZgJF4GYkfIyKWVUA3FwgFaUmOoaasiQj6CMimCmuZqbIFmn2baqywi2JIrM/e1Z1damZQjvug8VasefAxciVuwEgNZCXeABFwAQUVkWRrE4G7ANOTU0slpl7YT1L16KtJKCAorrS0tmJQEwpUcvMsY1Xr1+xCim9voMAozM4+2xZR1vmwsW03EbNkocI6tOnX/w7/8H/5PXj/+xPf/CHzhZqF31oRm5jtJcFZDOblaki5p6R7qP7X33bq5H6TDBkAf/dItum8U4ZrZwZFX3JiWjlObYxUeYolA1f5geuL3+MAQrrzHkI6UaR1rDk+teTlcGaa1sXCDSzzBWAEWZ2nme7KFl8oRb7Qp8x2/bcKL0CSR7vTnXrFjoQYzhUmDAb46HO5/P5uG+kb/uMqaLCVq2pqlbw+lqXWbKKxRBC3Vr+NIaziq6uGhEZNfatH0EkIyZJ9HpqULXJXKCTae+4zZ+CcG9estt60Y4qEVVf/Vwd6tn62ayEirnPyhlRVk3cRuZS16ogeZ0d63+viUCXkI1sEJwLv6Eszcr6j5oorKJIQCEilV1EJPxyyOkVk2bIllT2q6PobQGdEC3IXJCMFCD9CaGEosicj69e79teJIrmlryEOyAv0rkVTSR0mEj/jTJnoTbZFfXw+nHMrMJ3vvPdrmRbWVzNiPUI1g2b9kLgQCBim4Mytq2IJGfkOaOIrAtyh+hVQKtLLBAAVJRVGQnBec6KbCaksvrcejkDRKUYbSEtpqjUshZHSQmqKoqJPgGMEGniLDOiKjKiQlTURFA+FIKIJETMRHUbuy89B1VlnnEc88x5HNNUx9i0SzYhakbB0HF7fFDXd+/eHc9PLBLZpc6VzEob1vJXVRGImQrWmr5mjFrkakUs6632eJZVpCySToB9jB5UdJULsTnUhdITHQIASGbe7+f9+ejXoi8cZgsWlMk8p5m5j1bRCBAREXmeE/jS+sfk+rb3ScJmfqTZ7mscvxrXyYaPyNbxNCrfSHCJdldKk969PbTLvMWOvZZJVmWy1vHaPYHLM0AWsw2x3Z+2LLTQ5mHx+Pj48PjYnQPqowghFsfcd/r6J6orVVRBaGGt6qasmsljJpNqdZzTK9OGLyasP7SeiIoitNYfoGJOISoB0W27QS1mAoCu04itsWkMrNnXrG6sjFmdfBbnWe0ska5QHn2E+2hpJECpLEIqKjKKNO0hTaouJN6s3aAZhVol41jhIciiRLWxSwUoMEtFKyFJGaZuKtLtDMxixrbvnrbfbiJmYsnquEJK1RJbiuoYW83z2F0V3ptPf0CAFJbUYs08pK8sbhHRFhr2g0ic7UGdMbPISjc11+O+UhAzYx4hIp0eKNohSOzdsZ9jEanIljyYmpibm4pmUb2X0hSBqbQ0t+lVNe33o9Gt3jSkRX5dVt6ZxD2dEKbd61jXGyJsyKzWcdjPStVVVHvdCK1nq6J1yH4Dqv0x8VooOqLz0vwAuX5YlExBk9YkLTKqCNfHx9f7tmdSV3R/9VZ5XUXEitRqm24jST3Id6ZbI709Yi9d0cO2+yK/Lpnl9SK8fNe5RLyQtjjdtl1EE1wRctX3YV+LTaVhbamqQpznBChijNnjiA3JIwUSET0CCVDMmqWupjqPKJaZIjMzxvBeN3oTjzOSyaoOyHOzWOWCUHAMd++1rBtiPFmZ3Ma2yFxyztlL2v04WmeyPTxuYwORSFWLCNORZ6nynLG5b/twt+O4H8/3/XYT0choCsBMMqoTLjoCo1WQUGOVuzdNW4WOSFiCBVIhCSGQEVUEa87sWg8RYbDDZqqzRFVZyQSU2jVsplWc52nDrXsZTTNrzrleEnYlwmk+1K3OliJwuDdYLJBaIi6trIxq20nzJz2zVPOfUHJdZKtfRfpPtQCa3ozRvbRoYrRFREYtbXQOUhHN7gpY7ShSKNCB9xnVx11limHJ1FVNdb897tsNoKtmXrgQVnDqRdxCBKil2lgq54ZTGyFEK7OqAlC6etynm3lViltVtiLvBfbCkmewK/LqDFV0mlJzG0xxU7Kk+kJT6dBxoA3prQJVFVZCltkyJwE1l8zq/o/IRH0Zv54Zqjrn2cjizFBoARFTqZmxCJTqCiqqWkco9yICrGQ7u5wGZpqs4WZuFWEiFDzf7yqirq1fUDcAkbld0A0ZkRzDzhnuJiJj3wUScw4bDw8PTSVlptj1iLRkUKWyxIRFHW1q65Eot21XlZiRWY1gAJkZ6lKxIoMuGQkarRdTVrFKIMUyrkRLiIpx23dzm+esKlK6ZcBWZl+vnSQrsnLVlSIyG+Koqk7cqEZbZo5tiKiKi1HUehRq1GgRVZDW2wkvJk0kqyrTvMuMrhVFpWPO5PqHAFhL44WeAvsoSKJzbuxyM7kUWVFirmK3/dUww4o27vlKIOjdsJ9YCIXdIbAef66soZVDfJ0+/SmlUKoIU89IaRy9UUiugrhOaWlHg4qcketm77VJlv18IVTalCAhbfdsUHLp/wGDSs6ZVaaiJnm0utGicnOX5TbQzKpoTX8uYR6razh6yIqMqmIre9ceVaamRiyPWON3U0w7lqt3uId9U/Xu4aqqQklnchRxTY+VWZKC0GXppEAyaSaZ5SaWYrf9uN+jYqvGILIKLr0iSkvLKWJuAMdtKU2WLphWK33lQtWqqjJmQBer2pO3qkKFwayqKHT5DrFtW69s7EoFAKZ9nEMkYkZlZ2d04n5k9PrRwV3qWlHSVxLBNVsv4biYEJwZKIp63wyoHuv7rz6wrwj9llh3pYXKglQFAN2UIp33UkVIFRpKBIB+pXuHANk3eb+ZRZjL8ooIXO3h8fWQjWuUKkG3/SyyFiDax76e+GuMWWjtNfeQgCiuhRnat1ZbIsN0kBRDEyi9ymOtz9CG2CsXh0FkA9fWYXJipky2/F9WsV+3yC8mcV1yuvyRitFJTKrM6lwvbXqyU75MbZ4psIxz2wa5UkH7AzDRjNbr+5mTRSj8IrOHKSnbtkVkTpqbai2gebFv08zyDLSlp4WTPho9hZqojc3v56GJqpMp/Wsjy8xYGNte5/n8xdN+uzVDlxmmo3KNmkzCdEmOexvKTr4wheTMpRcGdQnIqAAVM6siVZvwh5lXnT0CzblEdeg7rSEjEXd317YzNVfQLxK1GY4CwFrqe0ifo0U3JuVaPavY9eMdzKRDxVcHCquY2Ws6lmK+w5SLVZ0NaCLRQ3RfCoUS0TWKAz1btz+tGYYoEUrDe40aLXZfzJEzKRDT237bHl6bbOQSIK41/ZcVaxd6tZ61S0UkLzcBr//uyHWQkNZ09OHoXbklIgqN1icWO4NdLrHXnLM/kuFKac4MQMf6C3rJLph5Fx10P0C19lX6qIvMXkuvSF0IBEbN7GQYVmV/jRWUkmIO9/6tcpUD0qxNashWRxaae5LFxuWdheJ+u7XXDkCrH7fhhGSluh1P76Ci1CLc3X2YjjZiSQuQfOg8S6mwQGS098grKICrYdsn53kct9uDqm5jzEzRLnrRqzINIgIzwZrmFWpmKWmmNZNAa7arqCZxBsmxeVWNdTMrsJllRIgwM5vYNtN2pM7IiEUm+nAxHar93ZBrNjb3Pl/d/TynqrCEUe52lSW0mh8NYUFXTr+u3DUzpwCV0nF8lw53na0RU8XYs2a9TB9987fybT0v1T9KNGyVEWj+vjXqJjUjEj0j3F6/2u1G2653mJSSngX6rwW29xuxiOwX4vpKXF8Mw7/xcnQQaGOybt7PpaCfa6pK9IhAduYHsG4GH24uMWcUVa1IJWW4EFmpgn7WKUsJ3sJMSFZURrIPJAEHRDUjsqAqCo1Ikudx+HARI6pLnYplsKokW4eHjOqKxcUaKpJ00+O4u/q2OelZYb2PQ8YYRGtKBCg3zDhF2LC6mtkYai4CUyOKIgVCoSYzKs9JEUAy51I1qzNLqcP9fs8vvni37dvtdjN3iNRSdjQIgcqkXGHDBBRQZBRE1KVqMidZbisN0kxFDfmlCKXzyEQUjH3b+tNUlXPOIcPdcmaDjPPSX4DMWT4Mq/rXRZBSEenuHUxGIrIaCxbTlttDxOF9tEeWyiUu6X8rWGSUAO3Oaatjadu7e8m8ns4+yxpc6lthbaMCaXdL2zkWvs5mKqniNiB4/d4bs2GdH6vAegy1fwO5Hvl+13DRALwO/YvSWH/fC/P6+S9Er6z3RV9mpjWeri+1ap24SqaZbmMQeH4+5zGH+7oTGzMXcXMCc7ZKnRD68LE5yZzMyrZYdCxMRr4Q3y0GzIzRHhFp6fK6wYSXpa7Y5En/bevkAJp0F5i5DTUz28x8jF19qPl+uxXp7vtta8sH+zarFEDV3NxE2l/PZWPvQb6PLqI9mtqPYlVkVXRwJIDhXpXznBmzql+fBZE0swORjGr+X/oxPaMPoxlxfzozq2YaDCVLRFA0VzVtJmvsDkhGst0/EDWLqGWS1pWa1lYWKPqKq8qMnOcpWK2spgZoLbWL9ve2NTysbpTF2myJ6C9G11RRaEUb+igk16hdsbygaE1Utf2u2hhRMXEJGUygCxSiSoHZ50OBxbqf58yMzHPORL56855vG+kJqQRynd5tXNCXo743JtELuRS5hv9eBAh0ndB6MbhujXUTEKZSKF8fNEkgZkCWDKp/kyxEFER6Ok+Wj3H9dBUxYlFWbk6mikQyZqhpw5Y9J8ac2e3wwmK5mZufnDkD1wALSCtDpf037dli98Uslq39ln2W9H47fLA4xAEqKK4xQwTDbc60joG8zsbjfmdnj1JE4ZtBvBWZqILCzLwzWrIq2DA8ABVrtDuJjgAabqZaqHnOec5924roCQ2Xpa76Sapllo1I39xVM882S4lg7BtQglLAfRRTIC0QNLM2u5gbyYiqCHVbLBErZlQjrc0bRKJqHoc2AgPM83x8fHXRCDT3c95bxtPVG1jxBT25aTN63j4ZAILFRzXcKGtxFJOcyYqGejomkwtDITotvCXuvtp4wLUg5ezAEbIDPYtuJqKl9er1e7dXjza2CHnZbAVrF63rzH+Ze3CdXLguqbWDrW21IaI1rv3SjkDgyqkivcVtfZssuuBiukUVlQKecwohatu2jc2707LL+hK6b5ZRS4ChELaqu0QQrTmpImkqLa5i1Txh1pRxdeEFCVWZRYBqnlHN0HVfRk/UMZcz3VRajm5uSGQkqiAaWdYfRXGi1LSn220MZB5nVlVDASKybVsnfyx8ePG43re1mo9boB9gIFrNs15IcYGYU7Btm4jOc+J+3247ykw1smyoqjDLRGXgPENExKQyZ5SYZEwSzMpKUT3OiVqawvZsHUeYrEo2c1s6wZbumWmmiETOyNAUNYnMlqH1RpcZakuqrR28LXIep7lllqyrDdWnCEs7H7L6XwIVRGVGEdIQCK7dkmwiPiHss6ZYPca091lVussRjQcQVTTXOZkxFdJ8uI9NKTcfZi62v337INtGIEr6CJA1+bQvEi2x6V24H7K1+/ZL8LKWNpW76OrV+dJvSKMpvaxj6TjVAfCK8F0L9pdTUlUxm/pjtT1K4ZCiGHiJ8gkV66tPljXEUHO9SCIdEB5L8KwkwTQ3VrDJlKoZk6ixGSHznGC1+VVUxDSOAKhm7Ohdoigm0kehilTWtpkAmdlEmK1SZL29ej3PmRG5nB8AOIZZq/upgf4SxEWGe6unRCHd3WLCKDGzTZEoZkVBtLuNWDQ3AWfkecyHm4uZS223fc6YPBQKERuGzKUV11LRWTQVio3NWY1ECUTbopBZw0e/qa4L+I9IMyXEh4JQ0w5zjzlV4Gb5YrnIvrTLGm0vtrtosnPaWu685oWWUosIURkEYYZKRiWzOn8gWYVFeL08bU2rkcvju566jBJl95+y4iSByjpPQiRnDndVszF820AZPmbw8XH37eEEGuDu6oy27bX66+WA7p2E1dFy+FLEuR7fJvjwMgu1X+UFJmqUtu+Cno6cPQ3063NdfM0gsBfpdamDWVQSlSh0U2Gyxzhz7XrDzt4Yhtm8x5x9A1Qku8GmCmr90PsYFFFIJo77oaYwqQr3kcGIO1O2be/Rn10iqwJdwNrqAVAVYBvDxmh1SpOOkXm7PYxtm+dUc0Zk3ht88MugWrCguO5ADTNb+QsQcPhmptGrtFd/+Wi9niMioqiAdLKxezzfz3MC8vrVK7MN1U+9kFmZWDorqErOPCpMLTJNBLTKAGE+zK1APqNY5q6KmzkUeOZ5nKpCtZYguFuDGORoWCZjrh2D9GFKTZbAWKXDEVmVTZkpLCMEy7GxnBIr47usp58OHhGZER2+jyvtgOCcV8GZCYuMBKpxT2rHbFdn4vb0VZcvys3HtmkzXpHJglIhxzxtG7BtKeGKomtfedFArcN/SfYuLKine1lAJ3C9CHJNPOvhX8vy9TPYQ6OKOHsRXpPPqjHsr5VtdDDVqtaERE5Lq0wMWffN8jTKKh4VbZGZqnSz35x9+6u37QiiKsXKGTrg5iKi2aK3tQmQ7IyujMicZj4jMrkaRQF0C48CRES4DYr08CD9g6SZ+TbUDFXMcz4/1TEhtd/2Jkq38RCEuJoYVIaKjdF8W1YVyFnu3mFDx32uTGEVEfXNu7j55Y7db4/v3n0+z/OT+/HBRx9u+4ObRlpUVpz3L57GsBnHPCsjKMqKDEKVjCWbilA3gWy3ERVKGdtGMs6oQmW1J0JNuZaBZWgplooJK84DIjArIiL2bRSTHJ0wqQRrmumcU2RdlS3z6ampVADW2toooAraD7yeM1UV5EUjVRYBZLGobjHPqAQ7z5cLzjZ0spKNTW2ISMssqooMqKBUt+24f7E/PKh3yICIyPo9F7EJXJadtfHylx7/F/Cp0Ve5OIMv3xFe4oZ1kq+LQbXyguAuWrdaOtXLswAi0r2N/UduIU3npa1Nz/qNbOUgKnnOCUFExoyr8EyVVizmYq5bSHUe04dv+xgyzjmxItQl10LcVr3GzbSb+XqbXN8TQkzcfYyxOGBpNXL5Nvbb5sMb3Tmfn6tCHZkUlSxsm1OICkjLlkdvRgSiIuY5Z8QZLXWMiGHepGkDyRFFFkdLCLIq1MbtdhMiUZ99/pmZbdtt9CUuut+2eX+eZ7hrHw3mo3JmpY2ldLBt6w0joiLn5qPDEjFIGedxmInoqEox4WTMdu2XitSyj7GiEmmqCk0WEnceImJjg9Ld7kdcH2Z201n2JANKCgBTzVXoJuZOJKgiSmbr+zOSLEiarnfJNptzPs8zc7J4qR8wdmsXkpvRTMRB2K5mMs8z51RVUwihwP3p80d0qko2G7QewQVgCl9O93WUt67nZQlYKqs1DKGpoUUJ4OXFwAWhNkVN+MuAcVF8VO0fTgBmWglckSyNiblpi/tFqSLa0+02IKouRj3PM+ZUkyz48MoAhUyicoa6S4f8QExVCqA8PNwiMzOlihUmsG0TaaI+t7FNIGZ0fJ6YVoa5q4qqq+kFCyhFfHPfhi26KOc8GdNc5r3MbCbnDKoVTpASVQoy3beeoWdEzsxMKGOmXDE5nUcpPYwqyGz1TiuDVcTHSGJXnRHPT/cxhqvv5iE4oiKoajOiyefMHilIsAvGixymFdX7z7Zv7hYZzZXfbvtxR8eNzmOqNYiIjChbYHHMgxSYd0MRiGQIxc1EYTYSYjKprBmm19yOpWesKlUhqpUsqqOBQ4Ukq/u9FQymiqCQZ+SMAkXmcT9XamrBNlVVG96aYh3e2lJAGlA2NQzvvtQF7JvMOc95N9uh0kkdFzB87aXS4W3rYG789+Le17R/YTxfvhQtROhf+EtUWFuNqar+slhUIXo0tJV+0wsS2aosQjrlIilG0kfHoLX4j5XpW0e+5LolVNoDl5kggJoz2u1VrNGFQdUzRCnQ1p2Y0eUu1mqfhWa1AVytu8movm0m1ih2Q0gsVFcZqAgxOjuo0Ma0GdFKcWQ97NsY1vxIP0YRszaRSDefxzQVUz1nrmFxQUG4buGGs+Bm7qbQrHQf3nWDZjeRzDxjVqa6oWiKbRsZU3so6ugXlTiDwLDRvTjhWsVOhVG1OeM850te/HbbRPDFZ1+Iirsf93PFzYvEeUamtHVyTh2jJElkhKpFouv53GzsPs9koDI7Fr7hZVkJsC1/IIRqTflKZCzyoGqeUVKqStRx3iMzIyMyIny4bTo27z619oZpNy00GCLCopkJ1G17ruc8Uoa7mYmmMCtfPY4jkqzmp9Zzy4vzakyzgIsIvuZ6rD12XQK1cNz/3mJwjTqLJxOQ8Cqqre14QfWdA6BrASfaBoFubmqcvheFXpEF6C47XTnNbD9PTkTEjLlSeFgtCqeQ0UcPQYp5zoZW2rQxpfOHDQAyQ6RnhqUoLBaYDlsvpBk6rchU3MQks169flQ3Be/PMytbzdhVqm3VXX/+Vq4QVURMd38+Z8eYsOsrllBrYWxtZWQlrPtEYOaR1SYgQsa29bUpom52Hmc+P7eyVVVlbBPTIKyAUKEqmmfqJhCJGUWamD0MW3aTKubKTgzUcSapZhXz6fmeLfFEnUcyqjIgJWpqQ5eh+uJzGppTq0wVq6jW+XZEWH95ejk/2mToapfiP19it2OeEKhinsfxfGdne4Gmenv94NsGkbZ4qZqIiK+dVVTdt6K0nY1QEkmTzkiu0mGuRsSsZ7NRVVmwS/lzcb4E0O6ifhjbhC919SpePB9bmbM2hPVPXgb9Zr3Wpkt634NrQSAgUpXaqLWiv8mZHQmVWIfCsg+04CAjY8bYrbW4AMfmOOt+v2emENCWZkF7dEiqas703bYxsnrWTzeN2V8RobJ8qmC3KDcMp2rDvbWEjWSpWUvokxhiAhvDTBREZJzzVOB+zl5RRDvdVwVL6IqqmCFm8zz7O9B+AHeXTe5Hrr1KpLhOjgKGGSC320N7c2dOXf3lABuoLYgTmBFuWqw4ShTdT9HJQVnUYb45IFoFBwAbGpFS0tGDEWkqbsNE7eHhPI/nZ0aLpUxQlTOJqpiFUBEmqDbP2cG6rJxzYtuKpVRzqwp11bLznKvqqVIgXWogsnSbBDKrSyKgaGp5IQRHxjwrA7G6z8a2ieqMQGcBWpsz17lMMqugwxb5VDMqM6EeMZVkleY0cQXmPIa3F/pSPktTdWvLfTHiXA/xy2PNF5mQXH+7jGJt2FqkcX9F63oA4HKphWTBn3IZnfq1q1pe6coO7O2hVxRt5SzMebZrsYO72hhdhd6EKJ1PJpS83lECXb+F85hich5HVUG8hZPqttKeCTdvAbMAly/Zk+VE5YpakIINrSVkmg+Pr30MoM77aYr7cah2MibMpDF+sgrMmV8mQ4pkFIvKDl4VFgx+zhMC00WZi8jt1l0V8LG1ETnvhYL4UrPenw9RLTarhRknyFyYsckKx+gJSjOqquKc221bCBTpZhGzikKomg/r4EGSVcsL9vx8b1VmIdGN0UvCu1idmcHkrhXzPG1ARNHMqx91d7fs63qxvB27CbLch6pVVYcjotHnGXEckE5wTlHVB3N3NadYFbfbzWyId1XSNaN3up5SYMJLIMiuhYR5K8qickASQBAqTjGBQq1Y3SN4SYnkEjWskeYaj77E/hfR20LO9bMXKVZfzkjr6zBVXxom4cuI1brFmCkr8uV64V5GqXVULKlTJi/Qql85VYiJcHOeZETWFLibZof0rz1cojVYVZmpZuc8SPjmFdEWClVx94hQs/O8c22gGO4NGZl5P0pVEHckXz887tvOqmTe77NigkIyZ0CUBiHmnI2fsmjuZFWGqov31tMHmfkY4ZOKOKe5smBq6uamuawC6a4VyMzjfqhZVSfMabEwOc+oCrJkWDBz5j3z9vBQEWO7uQsgnUXQWZwCTZYQProuu8bmYwxCMvM8Z2W5WUmdB9z9PIKEqM3jLmBmjm1jZNdhtCZ1fay9OGa5230ezUJswztnDpDqHK/2IvdCLFUZRCrqeDpihogwAsJt8wkVdRGT7gzYtAubYH61HLAxPNfBKretn83M7CAqdcsAkOyuINk67SA8zARitXCCfoB5ndEUSEM78kvP/JfvwWINXu6Fl+GJLd6W6xe23NDxS391b5tixeX1UlUrP0NeuIZrB0BVnfMsBiBk+bCOMyFL3TTIOltmGBGq1uR7TznB6NkU3UmQeZ4hwJBh7mAdx0ExtTLTLNnGllX9MbcFVgFzUbWizMpNx3nOV9sbd2dGHPfKiYtbENUsziM4ZIwRPUwj24sE0axCwBpS1HB6ZmRyv+3btlVS5SVTEWgMQEXVqNHfIwUzkkZJnOcUlZghUjmnwLLTIKru57Obz5gE3bs4A9u2xzm33Una8Izs5j9TK5JxskgGBOqaU0jJTIiM3e9Pz42HCpCR6loRQL8DXXgpcZ5qtm1OyL7vVUkufCkzq8MkZwgENAhF2cMVwOM8ZpyZMY/zdhs2bMYMMYWIQyAwUUUTzLLsS13oqKa4kqg7vLFMpTIgrBCaCIQZpZpxim+iMs8DG9wV6iR5+Q9FZXnu5IUdwwvrJbjeAVxzEReXe10W10VR5HXdAfC1TBMXWoTG00X+jVmoSDW7MCYBkcg4z0oKVFViZom4Wsxp5mo6xCPsOA+yCESUuQm1rd/NnZmPlmjMiOHWYveqyujQ4GRZXqN5jyWqDYdBzarQuiNzM5PXb17ftq2Xv6cvnlisSEFneXcyBbYxKMp5llBXicHaeBJLNnbOKeYtY978pkNCQq7od1W42/ChZosrgY4xzCxmVubRYdSz5kyREsF8PjKqdR9xZind2laCMYZkbttmZmMbx/3o8yXnOYPm7vDjvoTiMc993IAyt9325y9qxizynLMyDJJWVqBAza0j/lmVmDExF+cHNGYwjvsdHVVR1XIjoNMuqxJqYNZ53OM8M86csT36nPP+xVFmE8i6b/u+jf0mq/cGIoBCyegpeVXNAoJl3NJCqagOYW153NWcGWpaxfaIq3YP5NZoSrFLptHY5TXirA0YsvD9FU+wHs7rIlhiiYUZrSRvEE0Ci4LwaxsoplAJAYMvziNpQ0QbNLluFbCzZWJhPoK8muryTB9uZrKGKjHViBIgK5F9j3kJ3d3ksh+AHawi6uuNIy9dA3rYwKLAQFEK933vsD8Aorhtu5g9vHoUKJlPn34mka1rdfcCIIZVbrAt6rSVW6L9xhMUtct3p5UJldt+s+GVnUColRybd4qemEYEg5mpLpgvkEZrPzOWcpis+vJCULiPrBTRmQeJzBxjdD0MID68CThpv2aRWmMMNXUfchNRzPTGjX04Ks6rZDNrtVx2gGl/XL3q55xj39sEDJXh4z6niUQUK1W0E/UaR0WUuVbG+XzMec7zFGVkxdMhlHHzeZ4iuruhZkYdWhMR4K5DXcYlUdal9gdAMXF1skw2Fc0M7II2r/qWceoqlkzAgCxmttl2/dmWaAMXE7Y4LS6kvP+ndQRyQT0vXuSurlsLyPrV66n3l2GKoMoVgtgN9GCTkVnVCX4XPU2gFrsmqGXeFjFNZJR0KsDY9zNPnd7xaFIQonWDfX+iA9Ei5nmqadyn+TAbR0wzYclo86ioDVvfNcqXYg+RDBZq229F3HwYDMA8zs4CAcvVTE0K6CfDDH2SK3AlHWibktDZyAp00Yttm/k2VA2MydDSMVwgkVSRVvbPOEU0WoQWdX8+zWV5IAmAkcnKVQoq5NX6KmIohEyBBdqBJaiKc5qbiNQ5q9Vsujp1uqkoq1Acw2tmR4OquaIjLleXjPdEIOwG16ySFciTZoaEDbPpGTMrrkRuyUgRyqaiYOY87pHzOI7nd89kPb9797OPf6pqH374wbhZivgYAheh7pv7Pvdz2hjjFupqw9VUtohUVQja/lrLVrBUZr4N987X2BaFrNaL7Tnn9rBlslMw8IIovciAelh5ocEAXBjRwoFwuWKAtTlct8R6/Isi4tfGYyD9ZiIdf9JJMmYQkYUfiSk6kFkAFYPW6n4MQVfXA5BGRc3N3YTmptkfh6Aixb0qzQeZ3WJxHCcrx9hDpR13pjKPIAkzrNiwtZuCiJgd+ZaC4abbBjFz2x9eqSlyHs/3LijbxmilB9t1vwKoJCqvSVFEFNlvf7esNg9iArgP6Qgasg0M5pqzTJWozDJbdUmLScwEqqi1cptlZXxGEe3y6UKDAjDP08eoiiwgJCPGvuVMUYnZpAfMXc2ysmZReNyPIsfmoKptcoYOd8j9i6e+MaS33RXzU9oYOVfAWEUcgI9hLuxgDRU3Y4+InVJUhVSDZMx5znkcGXm7jU9+/ukHX/nwt/+Hf4NaP/34ZyX553/2g+//wR+M/eHXvvdrWsLzgFvD81N0+HYP6ps3qoOg9qopy8DEK2xNSqULtnMWqEBJZ3wUCzmn+MgIXSLNRcbImoGWFPRCZa5r4cKIVjDQtSILvkSLrr+jiPrFb7Z/1y6YaV01XOFOAqD12d3ooSQolZkZmWU9XOqyg9zn8Xp7A1Vz1bAxtvM4G3XOKnbsSbP3Gawys4Z63IysPvm6/a4VOFlsM7uIbPuupkiStIchamr26vVrMWHh/nTvhcQ7nVN0kV2kWNuQSGBsIyKajljrItEBEKLGLCjcOy9MriYVdBNxLvoVWewg0cya8zjP2RziStNo/eyVXyoAs2L2Aa+CipgCzSRwunuB1roLRVX5aFNYVXHGuW37NrZiierYNqjOmCjJ48l3n6dsw6szegqQUrHq4k2wMweKhYxzzhs2VJk7Tum3ToupK6y5jqOG5nGqct8Hz5OQb3/3O9/97vceHt5P2JuvfPfd51/82q//tb/xt89/9A//33/vH/2D916//kvf+0sDMn3QEoXn+vzVm8fzmQ+Pb8CtYrq5vqgu2ySkMtQbny/TiAmy2eciCUbMoSuIuMUA16r7gn4uQPmS91xgTqM8feYuvlgvgfOyiC0gEvCM6E5jux703gqu1BZZE1NSFDCt1oHBIBUx5xlSoqMXndZ+WM5QQFVN166n1hVrKe6d+m7u8+moqs7NjWSe5/b6NTtqBZgxBYLsg3lhwCR8dCx7uqmZZ9bt1c23TYhgkJVZvVt3eX0JsVyO1fooWR3nPV+JiLTY1dx7bIAZgUzq2Kpo202yNCRirixOU1VUprpKaSuuxubznJnZAyIqG7gXEUxSKKQCNWNsG6SppoQhC6wcZsFpZbrk4pKZNajSx7aNbUTMLG77iKjbdjvOd7q5P5uI5JXfwUIBBqqZWwv9oWjRXh3nYWOYu7DMPM5DoTNPFBrKY/GMw1W34ec8xsP+7vn48KMPbm8/nBSlmoz3P9iP57n549/62//x3/rb/+Gf/eCP/8U/+0cf/+wX3/zqN27b2HarnE9fzIfHRyj2xweV/WQ4hhGsOmeoYLPBRY8IIG5jzlNUmdlFZayqGaLaKvqXQ/xCZbqgRlfIC6+tt3M48UJF/PIwJO2C7mmpS518ceC8FujFHnPdE0I1EUhbp5lZxPPT837bG0cH4K4qUoLIll65ADRhUkT2hxufn2PWPAIsA8e+pWpGVNbyzqoT3G+7u8YZdoXk9Fco7Xmtjh5UUS2B2crYuT3ctn0YQcFKfa1UE3OHiYgyKyrVR+uUoIZlVuwGlG5KWq9ZD0erKYEFiLstaQdqRj7c3Lcx5xQgSK+C0IaKjuoI8Zir8aFPrOwPprpSoB3PGVPc295aEBQKccxD1QiawGENKxMVyW1s/dFX8X4/hvvYhhojNM7yzce+59MTRVRtzdnSV86lFbXCVN/39uzXErRiZu3DLa2EQ/XMYjv6VJ7v94jJrPc+eN2HmKhHUGYpdPORVRoQjm9+/Xvf+ua3f/iDP/z+7/3+zOdbbMMg2J7eHaQA6SN9WJaCguys2OUuUxE3Ia1I90GhDY0sVgkFVia6euTXHMRasD+Als++yBPx33sTXi6E/hEsBPVliWajQGuGWlAjKSrMNTlVXUwhICKRNfahl02u/VDt5IOIq8KWwA8JmEC6KW+oniLT3LJ68RehUqVnwPZqmQ0W5pwZJYD1CGQKgkWBjG3LSBVxt3nmtu9jG1Bz3wWM4x7nCeEYXhmi/X1kBGKWskRETdyNKsuqx16bFngCokc5ETEbrlYzIGbD3PSsUkWyRLXTitQqYs5j9ooZc8YMCETlPE41rQzpKFeRiOiyraFWBKNKqOqMEhExQzHm3bcto7iNfduqChOr8khwf56+qbtnhI2NHLeHB2RW1Wb7M5658ixXiNy6dGypCebM4nmDnc8npdn8YXoRyMUC1ZVdCLYwW0vii8+ePvjatzWCQ4Z7taa9YMPAXJ1f3H7le3/l69/6zg/+4F/99Cd/+vHPPnn7wVvXXQdwR0Q8usFK1CFCZMEWTaX9DZOW9ESmyGXPl456XREkL1vscgVfySyXGmKpOn95Jmos9Br9rwvkej2WGrQPJ1xvR4v+13tDVmZGFoFKgmPY5t4+9WrbRJGgiVMFJu1br8zjuKsJQTMbbnkbbnqeRwd9xDGlNR7tc2/Nv3QccvkwRpn1MNAYVJeZtg6Rs7g97GNsmfn6vUdR1qw54zxPU3RtoZAR0QH1nY0jkMYZ2tYt0Aq2TEOwypP6m2ywHukyMhiP/kgliiye8/D22l64c5NxQoBRoVUBhZkysw+W6nLoKhVkx5IIFqlSJSokzueDg+oaGSZjnieAbWxVZe59vJl3ZTSskxx3U6l8jPt59/32kI/Pz8+2SU2wqkAzLVYFVdTM5GrYQVYp3MfayaX3nP68VYSuDgGyImi38fOPP37v1ZttG2ewE7kZBRBpa0eSvSQk/ba9+bW/+pvf+Yvf/aM/+Je/8zu/M2d+6+vf+uhrX314vd2fngTn/viAUh9OxrV89offXK+YLgA4uhejGJE+tJWkLQVdB3ITONB1kq8Xg22HwiXwWSsBua6IixdrnwkI/2V1w/ULlmW0Z6jMKSqkZORt38SsvRGycNcXlu16HWQR3RDZxlYZKWbwI6eZZ0TNKWCX2ESWukk7xkQic5irmmg3wvcfQRqOGq4iGpmuum17RDw8Pqo5o855zoh+QFRNzFjpvpVGzchsEAhqRtTFchRa8aq6tiQVtKlNGxJft25lIkVN99vt+X6PSqGoihoYTVMwq+Zs1SQYhEh2X85ZkUtOI4WYqbu9IBVscmOZnAkyJ2Hhw+ecAjG3eZ4c3qMtCPeB6mCY6dvYalfYw26Rk+A8jhaMmFrjurCXEI0agsqMCLRY/xoPRFcVvJiYGNqUIk4is7ZX277fYpaat3RF1pITJRA1sVJYZZnAsD/c3v7lf+u3v/rVb//Df/AP/uRHP5jAV+588+F70MBz+Rh1GNQ2W41JololamChKJ3WJRfsXuwcioW2rfjLPglwaSWu5klZINH1LAsEyqpleia7xY7ycjvg8gNwaST6PupboLJW1k3H3PZsiO42YnV8QKudzFiCVSaCYT58uBnUqd0s5hMyczWlCND0sK+oc2QUO64Zola25KDwMazY8LCY9YK7bZsAr1+/UjdGFTGPs8N6VoYfSdFiKLQNPiLaN4CaZTIrVa2zQ0jq4m5A0Gx9V9tyFsepXv1WZL/2qCPO1qXEGWOYKmKyC+RZllJMXsVeMFVCu09J1SJKFSgjytrlY8ZO0SJUJJlIEciRh2+j/2yV9fDwilJuShOUlvYSwYdXD+d5Pr5+FK04D1mFfxBYzxFtAUMhEKqaboKKFaOckVzeedEC0QFhJgxAWRMfffS14bfqw249av24kAR7iyopRZYMUHUY9Ktf+86//x997Ud/8kf/3b/83X/9ox98LT56vD3uD4/u4du+7TjPQ9V9G1XX6GWUEimI6DJ/rt+uQc5OHX7ReF94/7UXf0mP9Sx0TT0LysGSZl8Son5/0FTZOope0mBelKUEza31eI1dVDtYq9X8yAg1WWHpsiy/5qqufZCzEbhMoD0W2c6LzjvJlZrWqzbM1uzBqjG8O9OXzMpNRNz9dtv6/8PcdKjJeTyJgtIwji4Rx4obonVxJ2U0+oFO5ELHdclKLZRrkFRZNKxWcp4HwZjnu3efV6abdjoWigrMcwKcEZXsLIZ5HCsXvr+qLIFkpQh8GFmUGn4ZAYlcotnFz7d4R9WO+71YM2dmRM55nuZ+HE9mOmeKQFV8d1WlYmybibvYq1cPt1cPKxieyEw1NDPcAaOszExWsqLOCeYYQ6CVyFp/AOm+CVVS3PYkvvWt7xUMrpWLMExU9dYgLIkSiEPUoEIDVQJZkM33X/ner/+7/+5/9Nd+8699/uknP/7zH/70pz8+7wfnnPe7m6iRZ7S+GK1LJVoI3ioeVRGRyOin9koyfnn6sY6p60ZYa8H1M8g2CYC/1IG3jvn1nMEXUARQJCL7xml6oTOKkU2ViLkqGkevfs5Yae6slWLV1UpqpmIduVOB8+ymC6jqeZ5qFjm34eu72SE0i4Sii8NWsUCP+O0MrqJvjqUN3joaejMrkfM4K6pWzp7girFf73M1wy1Q9bGiwEU0M7vDGEDfDaooptuQZq+uAqzzPG24ijw/P48x9Gqh6wmH7cQXUTOJ6OCWnkHHtt3jmVVj2xiVyYJgLU0gmBFdoohEVFrjccDxfPfhz0/P+7ZnRHOLFNlsPD3d3Q0YhcojiNr9dp9Pr16//vwdFfL46tU5z/M+UVBbwHGxXK0qzQSsiDCM4mnDL9dFZ9pz4WwNHbpHxPb42rbHFW1IsNjfaqC/rb3hy+XbrW5ygtjMUgrUxnj49V//ze9973t//Ce//3v/6l9++keffu2rX/va17797rMn97E/3PqkAsAsNcxMsLRj2dkrulamqYnKWgT+zSH/2njlGuev875WckI/Feu94HXKkyrqqpZd7E1yRSNCFIwVhj5l7cvzCB2+7pgqsgTSfR7qfQnRNxfREqQZgKhKZiGoVUx3nTN233K2FNRaRtG/XiAuSutDSAH04rvuL3aczGiBx+12o8m831lFqUUtrnjDdm5wubYIMe+FqRk3NtJFioq2/6ZeROFMirBELSNnTAFqRok0Gp0RaCIn2byTuzK7VnyKKrPEtcteReDboFSi3F1O9CUWEevQaf5flDnLC9CKUJOIUEpkiA6gTViTA8OdJfenZ7UBoWmrO18d5/H48Po47sPw4Ye3T37+s+cv3m3bFplXkwQhXXXS1TbT1ETA3mYWZdQ2nlaZQNRm5e3N48P+GFUXDUN5mTAWMXW51pd9AaIQiqn17Dnvp9FNHr/7q3/lL3z3L33/D//lv/6DP/rTH//g29/6lffefPiBfWXbzEgxJTDnKSrqNmfIssMQQEGveV+68unFGSMvR/4v/X+gTQfXPHO9oi+rLq9RySNCh60Po93xkMtyxRbxaTOlyNXffbHFHSMDCEvE0BE95qbqUAUwW24SmclY0jyZkcO6urAugTGrklFiiqL5MFeoRLFzbTs9b+ybDWdkS+Qr6jxm96v217RSFDspgETHPEhbYVzNOyu6VpQAzKwb5hr+WNrDSrV2LzUOkT5GZk9rYe5VIZBAqoqaRWXMmdEEtqpJZgsl3D0Zkcn2JJirYxShZsmyZZtCsToMj75SHiLaB4yIaeZJCDGfE7e9MtUH43lsm6kBLKFt436vbWyzwmW8fe8jFu/Pd5WO5250lO3rjQhtH0U2FYjkYlJFWdXLjMRM0frgzfuUTsD98rgF0WwDO0G3WSPTpQuraNdgUVCgSymNZimg/cav/du/9qt/VRSfffLzn378s598/KPXr96+efPesCGiYOVMFVVIZAoI6ti8eqa8aod+6Rl+4a/Y/sQFy/S0v47zCxltQuflDWgmWFbtGcw0o9k1iC4RTktZ+nGpWibFflBAVlGtxFyvLpYx1NQolKyomMddmS6VdVrLJwUuVm08UGClM4EEVVU9K9zN3DNKG2AUUXH1YWOImO0O1TjPzBAlgQ7Z7aFv0b3XxKeqrXwzH63KyiQux0YfwK2kb+WCtRaj58A1VLK7c8g5J8bOYpq5ssMpOjS3iiUmYwxWzfk8fMCEdzSHIwoxk6yqqW5YIMNyVsR56jAmZkVjaipQB6rUlUwtud/P7WGPPFi+uVREmKKx0Uw1uW3juMfD9nAcx6tXD1XvF/j8xTtQdIhkEFBKMK28kGflpu1QTbkwwnUJautc4vXrx/fevO6mXdEVH0RZ8ZPoZD3UpS5ozX5i5V9SqWrScg92kStDYGaO1I8++guv3//a/en501988vT5U8zpbq9ev9nHOM+zKq13VmflIaLt5Gb3yVBWBvz1+Auus5tLQXwhnl9SAF9SBLjigUBfExPZlj0VeWlHlksc4W4Rse2j0dI1bLeLglTRJFUwxvDh3REpUoxofWpknUcV0tTATJa7k2Qk1zyBlxSIbuASUZgAUHdSxm03H83U2bCYc0aex/12e8iYqgplRb2YJFQsmSqqalguAhPTAhjVt0NH8HUDfcsiOpWIlIxwtT6QzDwyVeU4TnOd70JE3ApNe0CYlRVjG0JkponNM7ZtN9WD4q4FzLO02w7dqtKta1hLoJkxtq3Bn9bsccVrpqqyQqhpPdBXTiaKQjerDELiDFGtjIpyVYLbPgi++eCD5+N8/uJJVFQ6JY5FmlkhFSsvoxOb+whoWIcGFtuQ+vWvfGO4QwXZjtgma+rlcbqAYogQolUl7DorrIzRfoi01dpV8AzJyEIOUdVxe7SxPVTMyvri00//9E/+dNzGN77+jTH8mHPOu06xbRMrRImaDc1o8QSlO22u8PkL6uk/0RUEdG05wBpneibs+UehrQalqXb6R5OCHY8JudrnBJ3MkTl1ITtsvmmYuw+QIuZjM1vPDZMzJjoDbh6i6Do637Y4JxdgCQgqqrUuIDqxnCSh5rAxCOzbEHNCOs/wfH4u8oy7ua+h05CZHdLY4kcttCrSzLMK/WdzySrd9qzamlJnFUvdLjS6rhS0VtWWiB7HIQJVzYr5XNu+zzgXF1tVxHncRUyq/LZJ8TyOsbmKi4iZiG6ff/7F4+MDwApuY5szeMWZdE86yZSKzIhUM1T6br0uzyN8G3WmmnFWq5twVJrvm6aEd3ZiAqCPgY5CiiMDH374ldu2/+yTn837k2+j/XTRIXy1JnXEtYWosKimneCb5H4bj69fzxnamsBlKV+BU+257f7fF6ixQ9UbQemHrTqyW6VEUepicBGRCGa0GgcKi4oh/vbtBx988N7Hn3zy/T/8/qvHh4fHx8fbQwmD5fAqUHIkICKm7C7sNe2LoFBCvbChdfD/Uh76l/iQvFBnECixtJCil5Fy5aayspMtU8X6y7osYt3+wI7LLHBmudm+76bOKBANXUXE0/M9zvYM9ndFxCxWzBxZ4mP4suAOHw4s1fsYW5F+28VdCm6ubjEjk3FOobq7QnwMkKYmF3KlomgpmHcGyhhmtuyxK7nf3ZoZthbfEkyqqKq3XS4i5hmsFBV3u9+PiiQSKBVRhaIyS6ojjKCqnPV8vxPo4U9Fho84zn0bcZ4i6m7qaq4NeYmqmqsZCwLLyL51EgRWE4JpQ8zrQlBZyiIBY06FZEYcJ8kxnMwZUdpx32mbPr55/fbtW7gt5m/pwghc6KCgBTmNxkXWec4zs8Cvff2bCag72IKDJY4UadwMYgaBWjsCO8lFBWpQpQpUxRQKqrTPXFBSEDEzM+n0IAhEue0eEnTC/Stf/erf+Bt/41f/4q+K4U9++CczQkqOM4MZUbNbXYuSAi594Uu46TXdc72P8vIuLMoPFyVwbQvivfJ3wFl1R1gzZpeITkyYHNsALmB2eFaaWzOmIPbb7tsuakAq2hEST188tegfQu3qHrRDldVdUX1zmkXxZtpXBEABHva9RLZ9h3kVt82hJSUxj6ysoo/FDGTM/jDrwgJEJePLbEg1bbdDVpGY52k+GmGrLL3C8lesKLNzoJZAYHOpPOd5nu2DFdUJQobM4zCzI1KtW3FKirfb/vTFk/sgEJnq7mMkEqWZMWe0JLvjjDKru9jEVUz2fVPXKqpIRJquaTNn2Ghoht02GWdvZUWWD6/M7bZD2o0fapaoMbbzmFZ47817Cv7kJz/OZtwUUXPbN6D994KVfdDxcv16azFvr18TFDGKinC9fPjSmAJCIaAMEYhEXcYikX6pOjftAme6yKPp1VQUoBnZLCxJNY2YtloXsL969a3bd/axff8Pv79vN9uGiL333tu3b9/IUjuEqEn1gg+0n6AjRInFi1WzaA2Pr7zpSwy6VOuulxCg+V0WO7B/gQaslujsY+u9MDPbHWCm6o5kEW72EtAZM7LyftwzyhRzhq1mq2FiMCnQdWSkb5t1QKlbBwhHhHmHMslt3+lWQhsDKnnkeZ4RaSIqNbbROfRNp7V5vzXjXb2aWSKSVa6uqmLaAX/bthFYvVCq1TBu9x6CrR3qLhmQQmRWdEGdYN83Jttape7HuyeFQMVMs8rFTpxm6sNXYAS43/bn+/047zac6C66doZS0XU4wJKtaz871+bVN7NEZsd2x1whRaw6jnOM7fnp7rfh6vf7uQ2aWRfCViQgvhmpIF69fv8j8ucf/wQiFWGjsS9WG3mJBeeQasKSIL729W8ONaoxVahc2eg9Di+jrVyiMqgrxdjO0k4WkvZQCIVIgSgklTULWpVJlDAhae5LjcdNVOeM4zjMztvDDYm3bz/47b/+1z/79PNE/eLnv/jDP/r9zfQ7v/oX37x9I7ZX0Tu9s0ouY5K8nHyXTXi9DvICD10SOUIIZ6PEwq6/qwZQirUqvFG5LPRNsbOKy4mjEWmqm5maUYTJ47gDqIyMU7WOefQtYfBt35oxmWQe0YMJi+Zq7o0oA8iqYf6w3WTsZ5y3x4fMqiNU8XTeb9t+zuO274Rlp1yYMWKl5zaVRGKFvGZm2XJ9SlUlaWpkiVjndiitMlW1aZC2K6loZJhb7ynznKrKyrYstnPKc0hDzSXSlDfSZUshC8M3oTYzsFoqgC6nAFb6mnTEQ6WZRQaZoOUlpdaVD94O17LhzFzTnVucOXGa6jxO2ampsVZAVi5XHegVCaaZv371xtU++eRnR+TmAyJZsyLgpmK9dnd854x6+/7br7z5OgGaka3bE0r1kN8OG+00CwGAVgMqJXNSxE2/xKEFLPT9X7UcO4JarZFSxSDab7ToyH0bUXkeB6B9a22Pb3b3t28++to3vv6zn/7045/++Gcf/+xrX//Ghx99ZcZJlqx1oDnMvhu7N1jWQQbp7zku3KiBKhF1uVLL+zYm60WixzVPsX+Oipl6SvZuD4qZ3Pbbvm/bbRfYcRyicp7ncb/HzGS0lGk8PJipindclplt25aRcHWTtVeJRFQBJrLtWwsEH/aHbucm+PTZOyudxznGYMnY2p4bUmy78Iui6YVkxfXGi61lqDJfciDFUEFIt+W0qqXXaFBrrU8sAdw05jT3PLvuIBWywotaL3iEmklH7Bd9mI/BVRMvT8+533ZRjSSZqot2botTCwTVhC/qcHkZzoFlaU8zq6I7str1QCVKqhff1n1EBpbL3qHCs8TEdcz7fey7u0H4+Wefnfd31kO7Ic+Q0eWwAhEW92087LsPP+ZEdoq4rI6lHh1UtUMYWw3AMjMhqsJEadpSYYi0+UGhIFrRASGWayJ6+2oNokNhRqGYznMC6W4ZWRlECfl0nA+3h7E/vPfhhw/vvfr+H/3xp3/4r/8S7L3332IFrukKOG3/zxqlLxZgGcr6yceLagiAd8zOJSDlajRukhAQwDozB6DQXHFijUnA2Ie62RikUBKVx3k/jmdVZZ5uOqu2fZPuP1GdEe2sBRbJRFV3X2s3qWZqVuq23UwVKMyk1fMX7xwKpai5DnN1NVYZkYT7yEwWI1NyKT148evtA4jGjgURp/ZrsurHsOZZueDsl54vSNfeAAamic6aK4dAhYWocNWCiMq+75Hdc7qxktT+acEy7aoiHnK6b5GThHSmIy+fXdUwnw3pClpc6aI0Rna4mggls3pKdLPKtQBUKJkiHd6RvntmSYkqxKySY9vnnEi8evVqmH32GZ/fvUOUmPmmZLdUCbsI3ZotOXOeJrdlWMMVQUJKlag1Adr0CSux8pWzuFKUI9fhGRkZWZki3XOemSmqiSCxDTWgk4Nmd1nGFMW7d/f78VQxM2rfN1M7np9suIBD/esffvBHf/zH3/+D+Mu/8VfH2HwoSErBTDIv/J6rF7iFXo1+9k1Tl4RI4NbbFgByZp7Hue1jgUEduAy4G6pxQ0B1zjnG6PLpfdtNjOQ8z/v9mTVZPM5nQOeMbb/JcpFgqD483qogsrYRFsU0UQKZZ6jp7XYz1f1hN1NmIWdWHE9PGVQt89GslptzRu/3lYWVl9RHMAQUqqoUgtcPi8JEI9nzNqua9QNXflpWSvu/OmW/SrSGuakOMxmmKm6ameoWkSq6GPQsU5/zFLV5nBR1t3g+VWXfdym5Pd6O5/voqhvH8G0e5+L+sNj8yhz75jJY1fECZpbMSsbsetOKWRCqKDMbf6+VQ8oqnmeYaTcpCcpUZZWvkVKdE1eF2+NrGFT16fldnqdMKebmA452yLAkGU9P746Zu/imG0gKStb32ESKPVnU1cebQsyYKpXg1dRURMWZwVmzRKGF+3F3V4H4cKjbCjeoMaSqzvsxGRFx3O/ncUScHVr0xdOTFNRtf3jYzHz4mzfv//pf+cs//fOf/vlPfnh7eHz18N6b14/opbDFbRGr70gvOhjypYS1X2aAhLcVECrIFOHz89PDqw/rZX3uIIjLIWwN1Ku56Zzp5ipeZM2Z5zMY5/mcmRCtin3bzYxqUNm2se83EURnrFqZdjoaWKwoM73dbmKmqqIWVXqeQJ7zOGeIirh3qIltDoGpdvJ6HzW+dKDLh052uZGy3UYqoj7jbmZVs64owm5kgWhlZdQLqJWVZpqRc4YNp2DGubLjIVHZ37SMENXFjauaShBVwUJUDd1mRhdvmjnB7XarrgkUEemkiAWMjW3rz0QULYsRFSkrntvm5zlv+1Y1fRgBt23OqKKT4tLUtUFIzjndvXmeYRozmCVuunlmgichm+9vP/jIh//8pz/Lc7568+bM2rzl0fQh93iu56xgixt0mLpJKz1ZGdXbOVaObqMHrMrIWQx2GHdER8WQCfDTn35221vFqOpDKSqGagiJc57347jfj7Pi6YunTv2tMyCli7DXPOLT+6dvXj2+1tdJu23v/9Zf/+4Xn3/OM3/68U/yfP3++++bb72mtJjl5ZqHvMjn1lXWaL7IyqtoHYiitbu9JKgoJGOyGDXbnUVg24aqzDP227ZvOwiS53Fmxf14bim+qpi6uJkNUnQzH4OUysjMHqyTZWPMc2aUqN5umygcsu87UMWcGc/PT/NI30Qg29gv0wpABCsz54zOxW+uqsHgxkJFBbk0BwJA6Ob345mFypJq6bWs9wOVzaFltV4NAkZkhrYBReQ8wxRVVNGqBKy/sde4hM7zjYhWRGdmZp7nebs9jG0QGD5SJLJMraIqu0mOu48ZbafUyk6rF4hUzr5yt30PpoiIWbc3rhNMRIq50rySpIleEtfBrEZ70EEvSqFLZYqNbXt8hZj1s49/qs938S09XZWZR56u+vz0eZ55f3734YdflXAMb8WuSisUo2+AmKnCiqysGVOrEhlnzHlGZEYcx9Eg3T62qOAM982JJEbBXc/7AUOeMed5v98jk3NSed6PiBSRKrjbMN8et72qKj/79PPabKgcT+e+vbq9Gm76ox/+8edffPLtv/At396cWUBZOQQKzcbYgLZfNs5/cZ1w7U3u6lZnsYMM1iHViw7IAqypIkSyqtQ0sxQ4nu+sMyuqYyZBIcVt2zaUmov5GDrUZIbUrLWhFskUilmnHysTvg8KGBl5PN/fVbEws3zfHgRLNyQvu21VVC7muIOnq0w7eF8BdJBRk+YkM6NYqIycNkxeOlJVRNyM2VJ708yqTN+sbwZC3C1S4zx5yYFFyCyYflktbMKZYMOXy5GxbztZSVHRsY06UgpZmRnD/VrHxMzOM1yhw5pKUxeS+76dx1S3OKOFgzBt8LENVZ2ZJaoiyIxekqRDgqrUwZSYYUOoKmrSIseszbavvP3K8PHnf/bjN+/fXCXPU03VGMd5HCdQTzOV8vbthzmfbRuiWqLHM0VLQVR6e6VmsDLPOI/7OU8zzWJGxAwX092TAsgXnz+/fnzVZ5lvYxtbVBYzYx7HPSLO84iIzJmR55w+hphuw0U1WMhpohW1bba9eu0+MMsYZ9Xt1Zuvf/Mbf/bxj37v937vG9/+1Q8++FoDO2RBr16ZNfPjBbxqW6LXKiRtyURFhKiyqKJQWsnMRQpLsLVlplImZibCGbNYlXx+ehZX5nRzH95CW1sVZFBXgrnqZpGZ6jrPgJqbqrgqb7e90/HJevriOWdmhttQcx8u7uySV11ZppFhqo3c1hpJi7CL5ev/bgJuvQM9YbtbzDRVmgIYLtRyeMtg2RymeXccb5saRGLwfocKo9cpbZjA3YWIpJvNeR7nae5LOTpF3SHIqJpz2PBtdBF4FccYwupIDx9eKe6xkpnBRlXN7Zyhbmo2ZH1BalIEGrrVrmtPc22X0lKiMdpRHbO7eSQzWGLqqhAORgTTfLz/3kcV8nT/DLAxLGKiGPdpKjNyxlFzqvL127dx3ksMKBEYQKNWPj9PZj0fRxzzOA5UNggpptu+j3HLNgyKPd4ev/q1x9ePr0SHiKwnIc4zsu6TDHLCqubMjKq83Ya5swFHChXW5EKVmYpqRoki4Eya5e77N7767fubp3fvDtNPH28PYqDAYIvfeDHMr+kehPbeb1XdAUMAxzwUMqtEuDpuVaNUyKz0MQTIVZJNsmoGc96PJ1c78zQfvWNoO6sLVBqk6/finKQUaaoVJDBcBZIRt4fXtlmeU1DH/V3VTIS6mdvYNlgLz1Az1UjgOO4CdIhAVa2Qw7ZDgivlAWIu/aUxGRFZZWp5hg/L5IAEKytNrbQAm1U5o030YNxuu5pXBgqmojS6dPisqmkIq7b9xkoA9+dDVIopZf1W1jzbGGmuxW7zggBiKqx5zNvDA9EHUPap0Yz22EZr80mM4XNOc8fSXbIyxzbynCpSKDURI2d1m2BVtOOnxbwQaQV4W51b6KKqUkZCoG/f+yAlM0I33s85TNU8a7oMuHzx7vl+/9k39/02Xh11H6oVOaWKgcj7edTM7ByEyl5HfLiaJ4WUfb89vn718Phq228iJjCs7wzP8zlrfvHpp+D84vMvMus4ZkTebpvfRhWOc6p34NRq42GxFObOVVVRT198cRwH1BznNrZ9e8jK53f3N69fLSKrLrKPX6rlWLycv2sHAF9kdIWsBhYKVxq0mSazo+DcrCr2bYMgzpjnnDlBZIWJ5cwxBklBC3KEgAxXalb0i7fKfwTmVglRvnp8HK5VzKoZ5/kcM0I6zMAcy+UrdREZrEL3T2SpadXL038pw1EAza21+Iv9u8B90XZuYkaKa0Soq6lqp5iSzeyaeacUNGALSFRydo5CQqSAPOe+3zILmqw0XwE+/6azQuAqk7K6vis7D8+9Ms27GZsmNuMc21ZzZpS7U9OdBLZ9r8yiZJYPbVtzC7lZXE8GYZDznMNHVYXEtu1Ebu5Q7eUbwpgzazm8m+wXt4f98ZA7MR8e9s8/+cXtdnOx0hw6Pvho+/inP//+v/yj3/rt37J8Nc93IpLJp3fPx/G07w8tJxMzlzGGjc3dhm9jbLfH14/7/qDqJCIlz5znQZaqPN+fjud3n332i89/8YvK+fTuyUyzYG7TREMAdfc4Q90Xcciq5DaMVQAz8jjPBB9eP5iIiZYIKm77w+2925V3g2IZrVfBxvhby3QRZHBZylVBnyfsyJ80l44Xr1qPPsAMbJsPDqByzswDddZ5ZM0qEYP6CoRvgVLrDBWgMs7U1sXOEoqrJCQyHrabDhMqOQUx708N16iquurYXKVdkSTVVj98VMqLwlvEzK5XWpaoXVQVhfRhak33ylojIDNSzRXMCBHB1oH2cDc1jTPYoTHmVRzbHhGrx45p6kLNNgxAqlLdq5igkVllCuvydKbYEEjNVDUbygKThspIEv6wN2iDrg3naGTRTM2lzoVi94rjw0qlqlQAV04C1BZXAVAmU0Uip/uoLKLMTUyW2mXYCp2HQLpwu/WIqczhOstc7c0H7z19+jnUdDhUVcf3vvur757vf/4nf/q9X/+17e17n3/26aeffWr74+O4zYj9cRvNoO37vg83M/Wx75vv4+FBuiSD8OHTc+wncx7PT+dx//GPfvTu3ef3+73mSeH5bsac++3xVebYt23fAHqH3bdUJ4uCM2dBdN7jHuL26vERYp3e36bmYT7GaPFzKzLX+E/qFRb9pfeL4n059ENThApmTBOtoijqclMLVJQ+nMuqyfOM85zzOKqCTFUXdjWMqw5dIMXlDp8Zs6XU1fFbECtyDPfhXSqYZx1Px3mcBiUxfPNtt/anE5VRaHkPYs4l0jYjllRbsGwKREekCYsKdXO5qLHe8nseACgqDFJwnOe+7b2c+BghYWaVjAzXzbzvIjtz4mXBJU3E9iEiM6aK7tsmImouRM60IUxmJAu2me0mwHkeFJkZtmylvbozwRUHAIhoobo+wQR96/bZwSWjAAqZ5e6pIKQiSHQ5TdOhqsjIWZHhIiG9GRVNlcxWv4oRS8wBlBgUVFd5/b4c794dz4ePHYP3J+77wMDjw+14zqfn+PCjb3ZoflbGPKGdDtiCPQ7fumSJRFXacBUTHbo/yLzP892cqq5v335gKq9fv3569843nff57unp3fPz8Yuz3aTb7dWb99+89957r169/uzzzyrSR+8P57t3zz72N7dbsQwmq/bdKNVdWP30Yun2IK3hu6TSa1AAIHDBZR3rxwc87vfHh0cRYa0oWQE6VMfUIyPuZ0me571iUoJXwIGZKdRUW1PHmGPbGnbqAp5qQEQoouZaSRsdQY6cx/O7z+b9GWBJ3R5etYdruWZJXsB5Vix9Exum0oVE6srbkyJEzb0im1jQ/r2jKqt3/y4+MxE1JQtVMc9tbGZ+oZP9M9vh76JahKp3Wq16S+JFrcvWVUT2222eMyJVIQofFn10s8a4KWX1GzCHezxPVT1n2FidQhkJEVMTqZqVkdu2FXNGdp67UNxHVRGMCLPF2cGg5irIGf0VocSGZiSrqJmRQ4eJR6W5ZhDZpx1EkCigqvN0q8Nt9sfX9nR/ihCmzEqRfO/9tx//5Cc/++z51//SX5nAPFJBE7k9susimCGovq5JmZFuBSl2g9mJd/MLz6x4vt+P4be3H4yHV2/O8/76g7NzMt9nxjnnccQ8jufjeZ5//qOf/t5/9/1v/4Vv/eZf+62zjl/84lMVBfzx9cPxPI8ZN/dkCJr+SlNXEXT1ZSeCd1LJC/D/sgs0G1v0F4VQw6Mi+vT0/N6b9wuUrkQWaT7VoGKCrELOyJbDo1iVbobsATuJYQI1UbiJLpvBsN6eu6sAqsfz5GZvHh/cNCLv9/P+fCLKhg7bzMy6d9Fatilu3glScSZ0sRa9vOBK2+45hpm+D1UrJrP0YUU78uW1f7HMGVzHnJPEeZ6ihg64AEQ9cjaE3sJXuZxAolZFM6Oom2dVg8ImaqaRuYILihUlm1aQM7s3wlQq2JNNE/NZtZxlFzeDTpyJ2PebogmJs+sY+/jKKjEX6b1ARUVN5xnuLiI5093dLGeoCJG9N1cGKo3amTGLTwG0md1iy70KnSXtt/31u7oXcUYex/H58/P++Oo3f/NvHoUgbHOBlXTwAr3VnZztAS1AVeac9+PokUP3G9TmeczzUFVVjaINdbuddzBBTYH5trnveZ7bmG/dv/kN+eEPfgjRP/zjP/zis8/322POMNM3b9++ffvhLz77VMDbw84khZsPQrtDCFfWU/eNdpZE/7XcLxdB5D36yHJYEqw5p6z6oI43MxZRSMl5npnRrLWAAqkoH16RPcYo0SYHNxciKk20jQAQqqCKY/fI8iG3915TLWbNOD7/9BM1s90J3F4/qhnLhFC34hKKigpQjf2RtU5fFTVfrKoAxNh82wcK2XlKgupA0j5GW/bTF16hVWGRqZcj7AJL6OYR8bA/dEoHQRuWATJVB4nWTYj0gNRWKNnGyJiU1bNrJVl092Hj+flZxfI8jFoLeZaMsn0092Kmnc3gLRIkIWqmxcFicYVJZmTXS7mtGE2Bbr6pSTsPFayZjXhntIozq8LN5jzQ8VsooEX81Z2ctpmKNQ3OSBEb+y3Os4M/ns8Jn+YDM4ebpKKoY9OljC7kRIrYrOxc51TvhHeqyvn0xfPz85zz4fHRVOZxdjlisdwUw+YskjpEse2bn8dxznK37/zqd376k5+B/OgrH8UxJ+uY58d//uOa5/5w++znP+N7r/fHVyYaKVAMF6LV0a3l5MuTQS6HpFwjv0CucNzLJdayGqjkTOuZQlsDCF3aJ8nMFgUk6e6Fy00rAtFEdR+wqs45mVZYs273pcVkxAJ6AVD57ot3biMZxXx4eBjqBSEzCxUwyDlnZKySbVJNMkXFRERdK0tUOnC3WO5mphS5n/fHx0ftU7lorhFdq0QRZV2oEJbjKTKYJMRM48yxeyWyys1BPD7cnp7ebft+zgmSTMD64jEbIArFpJnRWFURMbbBSrkEKWY25ymkqBows9plkjMgbL9Lv58dltmFLizebv9/rv6t17IsOxPDxm3Otdbe5xIReatikc0GLTYskU02m6QkWg+yAQOC9GD4hxiGfpNf/OIX+8GA4TZkwAIkq6VuqLulFlls1i0rsyozbufsy1pzznHRw1j7RLZOFTIjTuwTec5e8zLGN77LpMOIcLgLS53QwUGDCjNAmGVJmWisCJZaIgAVd8k8ESL0bRirZ+Mb6eSEZloIPTzMwsPR1QNxt5wlqiwIROSIUtSMEcpcPRCFC5UQDAPPQTqRCIGLDtWhgfqSLOjuo7etXTHg+eO7WotIRQz1xKaISJjCh9quFgUpC4ojIUV8/tUXbdvOl8s8z7VOdYzet/PzM6CLlO18tjGO9w+Fi5uj7LFXsHe5+/JOtDMv2YibXiophHuJdNsIO/s/44mSL5BDtMC0FlPVbKbTiDFyv+VoQYiA0ikt/UnSQQAzJA8CAbZtOx4P82GBoOF6eX7GYBfFYDQq84RVUMHBzR3BgFDdEMFSrmJOIsS0D0le2A6B4D7NVYTdXE3d3BU9doG2aRCSJZUrAAmzUYaIMgkAqmq2yy9iAGGCCGGZ5mlbr8y8ra2WMoYCopoxACEHuaWiN4fvjn0oCzFzG5ZgHBj23iFrDfNMoU7fX3UjAtdIYqIOZSZk2kM7iYiY2fsYkDYQgbq1pE2HAzGHOgq5mie1LnIqqBDF1HFicABwBIJ0dgBQU4BAlt5WVTVziQhwoOyhGdK5OeGsYexxOBxCnWcJw1KKEGhYYIAHAQITmCBRrRPRMB2QTqTmAGqmBblbd/PL6WJxzlA5D2BMyRIWljE0m2nwyGyYRC4fHh+QaIwhU5kP1W2+nE7r9VJKqbXGCHgOeU3MDIYoiMCRPnP+YucSP9gCN9VMREbj7qq13TYFP7mXQQAxBSVYjhHQRwdEkkQcKYAz+ZSJI/OvmSDlOJ4CXAQicwMCItnaejjWw/HAQh1Ce0/21DRNrjYfS61TBCDt4SsAqDusCQAoTIF5wAPeCjdkYhZizHSCJEgmQytlHA5g7tnziUhCou7hBgHOhSNumiFGQPRhILhemxRprdV5StpjnUrE3FtnYiLCjEXnnGAMBJAi2Y2UUjiDFwCOh0NO39J2hQhT08vCGIC7D6HvRkBDIV2MCIdaKTWJHpY+rcQ53S91SieTmpQvd1N1jyKSbK40rAc3JhagEcPddR/1+K2ZIfS4nlckAEjRY85SMMjT2YTSJYzEIRQQxa2NOpVUAFAYRSBlPGAegjfifSInjkioXdGBCoQiULYdrtptKCCouzMDUKklre0ZMUXbbt57v2zrdFjKPBOLqRlSrfz45tX79++HNrUxTxXDLs9w93ivySK5jcx3MUD+vIg3oOfTUEzwpg2IFwIoUVJe1cLdJBggXf3C1N0tCxzcmTTJmg8IKiJpKBQArobpTL97vzEJm45aa5kPgGSBYdabylRgoKuLFCBRR3AbqjbcAXVrST5nYENLeVHSNjGAhcMTg9sPX0QyVwxY24bM0zyv6wYReWu5WopjUu6YoY4QkPLcgBhdiTTXMYSJIFNFABFZDofT84cEJc1czQpzRPQxRlcIdwi9KhfBHU1AHRoYw7R4dQpgNHf1yG/XzYrIrjslDHQdNlSJaGgXFiJINpYO1THKVAnJVElEhCHcbXfcZ4TeVylEguSk7uYGCCzFwwxC1QAhzIjJM+Z7p/QOczf3IhMhOyI4JVuGAATACAMFYWJysPjtb779ye/9AQqnLC4rUdcBAYjpZJHFdiSDIQnbFo5VxnW4x27dt1/tlHLEjITb1pa+TGE2L3Nyaqhw6+35w8fDYallqlOBCLcohe8f7nq7Xq/r+XIupWxtG6HH5Q6ZpDKgEIKag3/CP+N2A6QEKgBkB4d2oHTP4M7DfS+NCXO1tK3NcxWXUFO3nWMDyCymI+G8hMRSX8fM+zkUCHs3RvO8iHAghkffWmH2MAICDEC0YUS0baknFu2dGCPMB5RFCDKWAiHS+pOS9UCUGaMwbBQCgLiuV1MVIjNlpG00RAo3JGJEzY6S6aUURiLAYOQ8HFKsxCLuUArtNVN4rbX3ZhlpkYRldzczHaUUIuzamMjdPRUDiHOtETC0r9cNCdvWTNVvOJSZYfqGRFiAmzETOFiSTyJadGa2PcMU008JAMwM3E2tTLWIOAyIcHDBQgVAPRwBGBhgQG5+EYLAiFuKKoKbbeuq4eghtaoD7H44QDuIkiJ+JCpo5gHvPjx9+aN+4Ps2mlP00Qn3HLcAhdjdQ9LZI+GGFAMK8TwXZnLf9QKtd1czs2zkzBzM2hhmHmZr7x4wTVOtheo0QXw8XZi2aZ7maS7Z7zhMZYYDeWKrm5rZurZHs7t7rJWRKY3rUsCU+N/eCucD8H0D4O7qBSjISZ9Lh164uaqbKSIBUS1Tj877dD1CMRCpFBYJC/DIkpUoRdGeXJ2cNpRJWDiQLTMAd3N1zwhedxdic0/sX3eaHRIC4S2ZC3EnoxGmeW2O9zAgO91tbAbpSKZ5z6kb7IgLpC8m3hwyGAk5A6J318xUWkUEUzq0I+bEyqHWqfUVAJhI1bhwTqbMlZjdPZcX3k6b3rsI63BE8mbhyQ91Jo6wm94MXuitSACWbNwQLohAxL4HEgJR5oM4IpKw9S4kwOhqwOIROSjQMXJkkfz3pOl7pHvNTgLw/fbz0br24R5TmUhS/ouRk1EKBOSIoADAUGDiggGIP//l3/3pH//50+kjlfT288QAKed3sMO4CcARkYFyIeBi4ILkSoQUIYDkomN0Vxs9M6cxDd8cWYRb09F6RhFJqa/uZWu9XdvldKkF7w4ToBFRrcVNiKm1EeDX9ewOHvj4SipN6lpY7FPEWHy6DgAAMic4O2QEdNCI+zrn03pBj1zdNFhc+xCphdkdTDDAk4DOWAjJwIjSUo0TWck5Wto8SOEiBQEBw1z3R5HstDHSJQEYTdPpIWxYhpBCABUKiDDnIrlUkPZLKr9F2z2tYOiotQyPsJimAnDTpyaServ50lwNAZEpkueUdxARBkgpTLxPsQLMozI7oIgQs4dlgiUEeEYJMYV5QExTQULvliUE7J4PoF1LFTVj4iBwi6GDEBDdLS0li5uZGTGlY9CO98fO/CdGVwfJ6EMABxAU4G1r84zMnKr5CA8Id6XEdsKTVbWTuwJTPABh4b6tW4QxYak1ED1tBdMMdscVEuF0oPBkBHusH9fv3v0GiUfTfZpuHtGZCyLH3mp6QFBKEQIIog8NC8xGDCkwapHunp+ZSolaxjCWhG3QwwEZiQOAOEothFiX2c1cdevX0+VsMaZSpXIppdQqtRKTO27NWm/J7xHmvA1z1rIDN7E3BpgNs+/TAc+GYTkst5aBWDjfUxECxDGMULmIUNE+AkLVGCHV3xFpjrSPb7UPDxcRQCTmUisIBqbD/a4zRqTeN04IFQAidhpjtmgIkexCyqwH3MkVeCMcAUSAmyNCIJoZEw21iERUyM0B94DKJOElLUqYw6NMxT0cPNzMomazQaWWgkBDBxNGhOnAcmAqgFBrGQGYTjoQqSMLd0qHdCIfhjckJyON3U1NydDVUmwQbhiGSLsZAgBg+B6648Sc7vLuBpCmEgGABiZC7vvchkncLHt/QmIidbfuJLeBjjrkUAM8zAMACMDDhhKhjvS3IwgiFrcgyi0Nu0IaHGO3/slBEga6Kbn9+md/V+fjJOWzrz5zC56q2uitpXLc030s9nB1tdG3oTF2XD5Tjva8TpzmmqE15lDnigTuAUCqKmVKVdc+7MgTBxlQCosKN10D3FWHOyulspmICrG2kfl2sGtZdux/5yjeGgLENKrLpjBHGsSlFszxEWEoZP/kARjORK0PABcpEZGEFmaBcOIJwohI1T2XlXmphVkQIKXxAWGm2Zinm1cfLd+miChT8TDPuieQiTxCRFjoZezwaSfQjjXlFDZJFkDkEL0PIVKPSohMY4xsFSINXtJFGElKReKMsY4ALszCOrxOzIUxyMKIRVU9IKk4jFymCRJUMcvaNsKRcwDvYVamggMCsog2fHGeBPQIgYzTU0cPc6F6IybnI4CscNzVAjyAGcwVCSK8lgIApgNQigjYQAQp0nufai212ND0aRNCNZPCOoaDuUU6n5qaq3q45hWJAQAsHBAJzgDsMFC4A7iH7yIqwnQ/19Hd493b75bDw9393et4dTgeSykG3kYfrQdA7zbUehs61MzMzbM89cA9fSNPMSSk3XSAGSnUw4YBIDMJM2UaXUR6HzIiIiXrjVDckBq2to7kVJmiu0ggAk8VgkkkTVyYxd2S7bxbW+Tiy4ywRK0sHA0Q4TAfMgEuX2DDiGk0z94uwTIMGVs/3B3M43h/jwFZMPToZra1JkVGH/MyEwsgSSkkBIBuAQ4sEmYpaWREN0taGxOjwchcIwiLSMMZ2Os3oDT/EoJAd3OiiEijZ3BjJNWR2IWOPtUJGFM0bGpE6LutJQByBEiRgLAwHYoiGUCG6FyqayA4EdnoCFhSXABMZZbgbmbuIgK0m/ACQlq9u/kLMGuq6e2RkEBEsh0ijU8odo0EM6eduichNI8tD1OjwhAxtlanKoVHV1UYQyXHBaqOgOFlKjaGhxERUek69iIjz4lA1U5MSYTOgIwwMx1ZpdepRgQEucNupYCxuyCEhVHhQoRumD03AnUq8+F4vH+clvsyTW6Zo6VdR7tczX3rujfbghIcBcO8ry3U8rouIpm0SExpEQeQ6hN2c3N190jy6k1bJ8SctouA5mAGLPVYJDBMzbT3oZfratB+9OXvvnr9uZAQkw0FcrzRHLL8iX20ixEgO0EoGyCDw2HBgP0YJs5eWYq4KkuGe4GalioOWAtTRt07AZgP31oHBFVTC66l1pkyXj1yyyEikbuFo4U1yw5dRJj51p5DtlNyi7Pe4zKynkTM+Qyklj9nGuaFSHUUBDUFN+sdaiUqQ3vCvpaJlFlmAdS5WoAHqu2oSAQh0XKcX2xiVW20gczIFBgeSFDdkwVlFlGr5NzLPdSNKEPAGHBkM6qmquru01QhgISRaLQeEYGOhAHu4OlTjTliR3QzQiJBIsySQCY2S96oMmcOdBg4OZSpSGFVBUJVc/NID7kEtj0AQfIIjAgzgHSosm7KLMeHo6OE7TrZwGR2gJmnvTYCAwqiILlMCZHTq9fTw2evaxUSCcQIB7dw//j2/Xq69N6TWpJT1DILIQPTXCtwMqfcer9cN4CoVQiRmShA0cwiwExttJ49JOxaFfJUrqZzCyMQFZ4DydzLhPMRDgSFmbBMZakiSGjmeBv7fAJBbzVQGpsLwJ47EG6AWKTGrh9Bd410NyLkIkTo5sjIRQjQIjKtilEIQod366lJ17DDw2E+zm6Ykb/gEXkRA0VYuOnoObJkEiESZlXrfYxtRESpgsjJIfJwB0JiKuQsqhq2U9bAghmI0bqCm0eMbQukWqsnFTkACBnFzZBTMOVpAYDE1jYRQRRTr7WmdF3bIEEz670FhvYmlUfnwIlxEjbKPFUCsAgERtY0sM+77jZWF2azcDUkTmIcIKQb5CB0hey6R7dpqh6o6hTAU6aw0n73R2QT5WqmISWrhhwkBwIVYQYeozmYIHZz5J3pBpY5emzZJkEwkbbBQuZRpC53By6Tj5ut/H6egOvtnld9eLh/uH9dl6VM096SRhSRfKY2POnEVGRczsIiU1Uwvfb1dDqfLwh4OC42bDkeyjQzEXPawEWpuK19vQ6pTJ/STiOZS0ThZniLefFAcAxUM5BSe8fD8a7IHBBzFeES6BluSKVgmtzs9nC2R0X9APl5AesifKdC+B7ymKLshCHYDBAo3KhwDA8PSZEvAwDiMAh3sz4UDHrfCFkmbqp383T3ePBATwchRAMId4xABnRwjfQLibQ4Qxy6W1eVqWCGMBN5ShF260XQ7Fch70RGBJZ0ODUIJ8Jt6/mzCREXsXB3dw28yeSTA0eYERVeSgUMHTYvU50qAkRW9sTbtvV1SEEmIhS1gVTnUnoDICy1ZqebfG8RyYaYOdmIVEtBRB1BRFKYiZw9y151czXEKHNtbczLzEXQHGkQcy0FmUzVhtVpMh31UCeZho/CyMxg0XUgIRdmIGEcY0RCPikYIjIf4dlC7GYHA3xc+zDFgkUIrSBoLTMYwgvYkwxhxCIyRgfi3/mdH3/x1Y8xAFmSVxaMmLiCmZnNtZQiqna9rqpwfHhVpC7zcndv4ZZeMpfrer1c1Mf1w6W3nsLoaZogYmivpfQB81wZJScPQFRKEg0CgMDD0wJ6x65j9E3mozBLERbJsGIAhuS3pNEgoIPzft7dih+8sYJ3mlwkGS6HmIjoSGhdM8EuEVOZxUYGSEZhMVc12AXjEQgUzYQ4i4JURz083JVSASWGptW4mYVpQABTIDj4sEZCqkls3kl2FqZhkLP+3KsUYXsHCRChHpT7BNLHOKMI3BwIWuuqHm7EGbGDe1DM7qKALJRsyiRvUmZWmgujlEKA6eQBhGq6tW2n6hAHhvYxzXcAtyw+BGLCAebKxJkIVqq4m6unz+EYam6liHuSx1j7yDk85gu6soiruzikaUqKDTDCgIJyFmEjvAKyhLsOQ4JAL1WQwM3WsY2u7rZLn2+Oe6ojLf3QIQIEBcsEDO3avv3Fb4+vjo/3j1KqjYjwbBmSOSbCGrHcP/z4Jz85znfhhIzpHEtETbsOBfDQwcK9uY7BpVqEQVig1Br79vCpzLP54fjgb3ToQLTT0/VyOW3X9cP7dyWdhocCYtsaC7NwLRIQfotNgNv4KiBtGAFpZwAu88xIEQaRlLmUZaQOAAH3MwFuysS4DQJyI78QIGTnBeTBSHRdzwF6mA8aXmrpm7pHb1oQr2OrpQJC6mwdsQha8os5ploVrM6ViQER1RCg1Ophru7quzoM0TrYCNzHv7tM3JM9nyRdJEDKWjsCMlPdNLkryAhCwiSUE6r82BNILONWSylOCcQBIpqluT4HEwFykcQWdZi5FSmS6DtiFPFhW+/JyjI1mQURPNIGinIF78mQIrfI2J39EoAeVsuMMHrriJi9BFGYGTEDAeU5hwGIQmSeJo5JRLoF9iLyVCIiPGRmdBeWABsaGEGEbpE0L9tdIXB0Cw8u4m4WhgWAgDQYER2f1+ExALHr+OyrxzodWNiBHAYimxsSEDILGcDD56+/+uILN2ytH44HG57vz7purW+lsJkT4hgjzT0lTLgU5tFHYuGFSdhcPQR8OAAXATA5HnhZjkBxPV3evX2vOJIoOXZt+UDG0ccyT8wYELWyW6AwBDghAIWjmh/up5Ieksw73T8jxxPl2zGe9EN5qe8y/mIn/OzgqocAUuyx8OQOEHE5X3sbNux4dyh1Chuu6oCSxKjUNzANC3UnwoyW6KAFCYN8WKRBJwFVcQVAz6spSyYdDRHBIjvgtIbG1JIF2PBwgCAMN9NaZkJK83diDnNJohkRRrrLg4eldtnDAXguFTDVtwYOxBmwLkSIzBiRDrThAZDqfrThQZGeKH1sbevE4B6FJCDJHRRZorEQcXgIkYWl7liEVUP7qNPMUnIEmtNnUyNAQmxDS6mp1sxWCgF12DTNHOR5FOQaRAQPCjQLZhLhVDgCYzgOHQBmrtMymXlbm1QZQx2CBcyGDcUwXlgGqEcAnC+dhbzH89Pz68/eHB4f1fT08Tn2RCYjwbDgggH0+Pjw+WefpcMDIL7//h0FHI93Y3Rzr1NC3rsErzAB4Bh9rM0hlnlaL9dwH6ovNTcyoxkGciFk2rYWDse7u/m4bNdLb8Nct8s2Rh/dGDnCrtsqTO7WGolIDCIRBHTHaVqS45RmAolZ5YlPLynXyabcwZ39dLpB///WPyNAdqNJhyCLwLW1WqqpDbeP75+GKTGzUIq178sxKCnPGBBqHgoTF1MXICmcrRmiOwQqxrolaSV95ghwaBs2mAgoaE+k8TTCVtPWupkxCxcJAAyiTFowzwhbh9hd2i3x7OFuvesYI6WuYJEDh9z0xBQQt4wYNNsDkXLKXacJKc0RfJj3NixyLO+pJqGCwmI2tOk8E5Iijn0AzZTzKiIGD0dThyLMPAU4dEMMEvKIea6tdSIqhXcRRuXsf2qpQjTUay2BME2Vd3WRpMULpEueDyKOGPvDZAyHrW9ISDUyW2VsGsgQgQWoFDR7tlW3DsMdY13bT//mF7//u3/vyx99aT02EqLrelnnYw3HsGBGFgGH+9dH3VytuYMPdzNGDjwdDgsYpBvZ7raUYyYIyvGquZrVSa7riIDRe3oPA6GZM5oBtOEsggG9Nw8odUl3/ft7M9Xnp+dtXTEICcyGpKbP3TBgAACRFIAgpMKCSBkzGDfmcuxs1NsRn7hW7IEYu9xldwfa9TGImMl7njGPjJTnqJnrGCwsRGvr5AmXxnjfpioMWIineXbEQKIiJgIY6hrujKjuTIQIrp4xGZCDUwT3AaEQO+UmIBQRCdu2qWqEEyJDgBlEUKQVtzOhMJs7gtPue21m3a2buo0WEa6GTEB7daeqRJL6EmZKeUMWkmNokUKcWWaOiCM/tJv5rk+0nWbnZr0pAjANt6HaRGhsqn0Ic2TShHm4L9NciJmpt6FtW+ba+pbTVUR4eLzrQ9WtTsXRt63NLKEGxIQhhZNOo13dfa6VCdRNPZAAKdp2KUUYPSjMQm0Qk3W1kSYDUALYAhhH6OV0Xd+e7x+Wg6y//PUv/9V/99d9WHn1+V/8b/4Kp8N6eZa5TPPc1lWbciEWZghr+uqLV4UXd2AWjAB0EgYMM123TU2ZCxERWHYOiRuljRKpruum6gQcriwCquZmwwFBhzFC31pmDS7zUkUAPJgtwhW4ymefl6GtrVvrrbc+Wuvdh7rMEoCZvyilijCxmO9Q736c3Q71FOKBJ94Bt6Z3/+NbNxw7l3kXxACEAyMCgnu4aThkPjQTyVwg8TiIGGO0FXsM04F+fHyNywFDASj3DGVehAgijKGxB3BT3AgoI2Pvs5zLUFlXjOhjN0wmQhKMnRpARMjCcTM6zZ7I3c21tR5uOkYEuHoONTmpfRG0jxxip2nsLRFYjvUpAnz0kYjhtjX1zAI2TP9oAhSyMLCIcBRxuHk1iAwaORYECtgJsJxvtw31cPMACkxjFncpO3FsnqahSk51Kj4MiZABHYUxkLKH3bn/BknhHD7UQd262rj2Opd+bVTJIxSsk4X2sY2xdaFy9+rVw+vPHpfr13D6v/1f/y9f/w9ff/OrX3jh7aQ/+f3f+z/95//nX/2bb6RQQGEWEnIf6AUwSp3W8+U43VWaO6qqM4AUypGjuZpreKz9QsjCIsKQxxxl1U0BXGqxdVVXKTRUkYGRE54uVSBiWQ69bZfLdjlfpJapTrWWUgoxZmQhgpS6EEmRGsvcddPhGkEgyQBT1TdvXk215km/D3bhNtx6KXBwF2K9VEU7222PzdiFMRGZE+x74HEOldJuDTL42pPxFUSEjIRlcvTT6en77z6++42U6fj4+svf+/3jV181hK7dEOs0G7qpp99oRBBGbslM2glzzCGQ7dOZWyvsKadBAnBDCCaszAEYts8OmEsyym2YdUV0MA9zCK/LtEdmoqdOCgAlDRwd0tw9wz4gbmQNd0ioVTXMCD0yP9GCK2NExqcTQKhBGCC7KhciplDzGIV56GBiVUvpWYCHGrplclRgjKEgmOKjCBdECqxcfIRUxghmSpuecFDtTAiqkGWFBhD5tQE5WEwF+/WkZra6ts0sSp2mSY4C9fXy9P7dP/1//xf/5P/1T8a4UiwE1K/n2Y2a/t5PXs1HXt++50rM7IFSq+iw7mFxPB4u5/XueN/XcZytSq1Z1oFZqKG57qz6rPf66JozIAIinuaJMG0mhUvtQ82ScpOBIeAOzZQhAnk53HmcW2ujj9E6As7LXApNtRBgERQiY5kmdrfZa+9jZJi5Y1d789mbIjPcbB4gfojq70EvyRt6+ePb/XBjAe3FESBDWEg20REOu+GaCzIRRy4OQAokgAgEAwhFjWIxhS1mPk6X56e//vWv/vAf/ePpR79TWEb6AmE4oZNr85oAk7tTDHWDYGEmTJ/05Cebeik8NMIcRMDBLZhLqQWJ81jUPnBPHqQ+RtfhkdO1MI95mRBRDZZjZSoBwKWGZ3OJOayMzM1OU7QXp8j8HswiBbgAECBT3ekisPM981ZR6zxNFiMQRwQhKRJQSZ45Mo3wcFVXdaOpUM4iwHOqaOgziZpJLUgwwgJB3es8+UTq4BQjCCG4oqsSoNrwpm0MdTNtY9v6ddw9vppE1m397dtv/+U/+2ft6fntN7+9fjxDqEA5TGXwvD2vZkrm4O6Vruemd22q/Gq+W0/dJMSZhcfm83Lctn5///ijH/0ogvrQZZ4CAjlrVnI0vEUIEZODMZB7mk2AjzF0HJZlXuYYBh611ogYvTsisrBYb6M1IyEzQ4rD3aFOpY9hqmb29PycRWDvY54nThvM5BcK1TKTuMgEAPfMy3LME90zDzu1JrEv/r3zy2XuALv71W0bpK4DsnBLDiXJfpUkXpTKvxwOZ6kdAUgOwACwu6/42q6Xp2frzVX7NmDiv/2X/3z+/revf+8P6PimyoTkDoZZagCYK4Cb5ryBXEMjXCM0HJA4YjgEooVQAQswrHUCCBEyHxoxxnALEfbeDAJdrV0hgjGwZIsro40qS633gZAtDUpCRLtrLgK4RUSEhZNHhLWrpOkVeoBBQCkMmP6bjoChBsMBEZIcDdHXMxcWRuUIpJFxSRYeYTq4lAAHcBTSPlIbAoFDR+XJPNa1YQAXRiIplQtvW+9NATmA+rU7AoVfvbs1a71UbE9nZFhqOV2eP37/2/Pz0z/9L/7NL3/6t9frFbsfj8cZ5LX64zw1xL65jRN0WhY3FQ8nmVRQ0bbz+e9++fO//yd/vG3O7DwYEaci6vFw/+rHv/MjphoQrTcAJUpkEEVqILs31ZEWlIiZ7UdunnRo92it9z5Y5P7x4fnp2VTrPJl5hGOwOxzmR1N9/+FZVaVKkQJAhhQc4eE6tA83W69XJhTJwQwRIEshLMdldiBEJuHI6B+E22K+TchynnebcO3D5bwYEG/Klp2uvevBICRJcvusKCBFsbdKym8UOgKKbjYJDu3np6cxVkSLGIUNiYnh+vT26XqJ6fj7/6s//OKrL7AQIqOHW/Q2iGwMNSYLnOaqral7gAdSAGgEFSKuuw0XC3AxGwNMI8JBwxNrcVUmMO8YgzDqVDzAg9QjsMh8B1gzgd7BS6GwPSkJsi4HymCYcHcbDjbU3QkJHIIYDDK9PZk36urogIx1rs17N1NrFDi6Zw66GgjtGgYSum5de8u2TBWAfXSzcBbpXVt2nCwOREYGLE49CBDBY4xtuEVYP18PS4UY6+n88Hhn1i4f3v7z//K/+um//uve1Ns41gnNH4LLVCkgrFUCF4mu3R2JSiFAp4oI0tEBUd1Hj29//e2/++d/eeLVhyHCVOvpfHr9+vj69QMiWyiE97aB67wciFjKJMJTuC3TGKNvvfVu5iQZSUS38Anb2uYRr1+92ta1TqWFu7sIg5O5l8NROE7Pz9M8HXhSdfeYZo6QtvWFDr1vtl3dIlw9qOnANVi4TiKkKFSnKYMM82zOxbuTpHcRPXz6SKHuDvvkgPtG74ldGZCtAwKKqr4AqO4uLLiPynbdAEIQgpqhAweezk/Pp6caNtSGeWEnstZ6Vzfcopz++v//m79B+Xf+139y9/pNfXxl2hA0Rhf1GADEIKJAZm5mGE5VQDi4KroOQ3dhJoB0LARh1QgPYNQxhFLIt42+yU4s4YDoI6blHnn2vBoJMSzMwZwAs9sGAHAFCyaC0LBmY0MAEFYPdUPgrJaSmh9uoRZEhSXc0QJV+2ktQugIAFGYAkKtZDipm/kwb4zJkcawhhS6bT7Qhlq4d4ppCpyQmFy9qbemji5sI4ilCPa2ffPzn37/za9Guz69f/vh7TteG4S/htowYEEEhwipBMiqFmbBgIA8cUUzIHd0ECbyHAdZKEAf+rd/9zf/CQsSEUMJPF+u9w8PyzIXKaOvgdG2pmMI1yJHJ/QkIlN+DZVSZltGVx0jSX7olodFlSqTrNc1V+UuHCWsVZDJza7nDQCOx6ODi7pqb20Q4lSqFwc34+oepm7dAAMI2jaSYYjCU60PD6/cYQ9+g4DsAn5Actv17hj5Bt32QlY3eQje+oF9d0BECCG7GSIROqTTzW1QnF0gUQRhqC7C/en987vvAobCMDYkcq5GABzoym6wXiVwqP/Nf/P/q3fHP/yH/7gcj6rXGooOd9OiwjqwZ1Q8gCFykXBsat4ViMBIUIaCQ/TRGKYAIqExNDzUo+tQVxQ0dhfQoQDMdeZ5GQokGMHuamjFoVZ0dQM3inAID3XvQ8NUdUNQ044iDjwiTB0iwB0ZMyrGCDLuAfpGaqobTDaGt+uGiDxqDINuXR2IuDCis49aCxGN0SCcHR4Oy+nDRwSoy3zdxrheHo7H7brxdonrdbKBpmPo99999+7t9x++e/vdr37FFLa2WSgsJncCFwZFQ4oi1XTARIau4SjARcDBwMMj09cVAAgMiBDEyNyWUojkZ//6b1hDwtd1W9uQIof74zBf103NbCgxFaFkeGlnKiBSAAncMvAdieoktU5hlmkSgOBuvY/1uqaHX4QTc9fuGl17ALhaFUogO09gkUJEvfc2NE2+lrvFL7toOcJTqhbhQ20SRkI1BxRmihvV9QZzZuUTL1LfiHRho08z4NhvDdyDlm+NMYLkAC3JPxFKVGGnBt3snIi31sW0gJ0/vKfWIXNeAuA2DEp0kgnIXbWPp7Y2+/jhuz/6o3/PW4fRdVyhaRDjPOPxHpQFmAqFa6xRkFFk3a7TcXECGo2ZzEdhRHcEcPWCBAh93SxcJnGB0QYaTIUvz70cprT6JxJPXAVL3zYY4U4QMdTc3TdFJvAYbXVvap2EKoGZYgQqQISpQYS1TkSIjKS997naenp3/vD049/7UQSO67kUGU8frs8nNFufTx/ev39++hjgEDq2tRTZ1tWGXp5PCHC+ntetS+FpPhDXx89eu9v68ft2Pi3zAkVGU7c4lNKeT3NvCD6VwiSAHAxdSXs3IJnKCDdBJ3AFlAR0cyUQUnoCA5j5zTkvIoAoiGdarn5pH59haBsrEc93xwBZptm0M/NUJyLorfcW67XXabk8n1x1XhZiBgj3nV7IzECAjqUWD4CBTHE4HMN9VyMQiJXRxtCxbhshKJEQS5EUK7sHIKVMemwdIJD4eDxI57ZtvW1uDoxplQhYDsfX4IhAN2k17dqWG96TtJrb77Mh9peB18sNkf/YG4Zkg+pQJIlwQEAS4hKmuy4TnBQCYiLBtm2nj+Ny1rG6tgHhqQBk3JvtIA/iMNfh/Vq4/L3f+V1r61yWpr2g6RgE7Xp+7m/fdpqK1GmeACkguvnDmzeFCcaKBgTKVMnVCex6dXMmCofr6eJhj69fuatufagD6lV7qfdzLX37OFq4FBSiiuodyQDZtI2h67oJc7sMjIihrq0uxBFju7aPJnU6HpZ2PZGat3ac62jt/Xfv2qZSp3a9HJa4Pr//5le/+Of/z7d906G2LFPb1vV0AbdICwhiU5sqQxi4g0ct5UDkZv2iBViQaw8m67/6DTDQejkSTOq9bwQhRD6urx/qx/cbRhymEgAa2FSRqB5qDzcPNIzM+SycDxcZ0/iDAyODk4HUI4ACvAh3DUCcD/P33303rJdjwY0oSq0Lc4UIkSlnp9s2EJkZ9rhx9Kfn5+fT6Xg4llrN3Hy4GQJwFYwEex0AS+U+VFXdVIchk5A4u+rYZ8TqqzoXLmVCDEl1OFiEAqi5hToxFRE5LHOduvbrZR0dAvnu7j6cmFNDs0+zMGMG4Vas5KUQWdmnADIiHAP8RgVFQExlyW1oTEiyX0y4U4XTuRn3jrg4KQFXt/B+vpxVV9zfagdAQk46g6oTkVr40HVrDqiqVJlEtt41XdM8l8UQJtRgcbtuEW4I23W19cPh/ji6ITMaekC5O8pyCNc0OYhAHtt6OvuETAJiGEjXFRx1nGJm8aF9VeW76bBdW7gurw/9uvnWtTcZcb1c0JAcTk9Pz2+/k+r3hwMJhdq333w9FS6FL8+nb37xs3a5AmHbxujWt7Vtlxq+Xc+V50lK0w5IvNQAr+ZSEQSYBSCwEpGbqoGnT8DozdVqCSSoMyEDons3Bw0ay3FCxBJsiKqjNe1mcncgxqtaBCI7lRKIPgyJGTzlSrQ38sGlgCMwBgI6SRTkcIuK3i0A2BxhKhbeWzv95nI5ffTlON8/iKXzPBG+aAw8dULooO5szlImpKHWWkMEYhbCNqy1Di0ZVcRE7qbDAHH0bjoYd8FFrYw4uWkaoES4DdB+AYDDYXa3bV33UEcCQzTVAMqs6ImL0NK6ItPDw2sCTtvtXLo349TbkR+RDcCtG0agvSa6rf29od3ZuLf9gRQCEEgBBjnGAKAdAPUIggguWMTb9XIa29nH4AgLQ3tR2kO4E4anZGMoRITEuOjDZ58baoYWggUhRwwMJwehiKHqHqYAUcDZDbdtnFdXZaYxrJ8KUaFaGGm7Xs/ncx9jbdv48N3944MxIkqs629+/fUXv/f7fvqsFvjw699CmL96882vvvn6Vz/7yU9+gghDx8ePz8hoTT+++56JPn744D58NPFxOV3R8Xi3XJ+eH++OpUg4QBtNV039g9qreUZVP965R7e2MNzdLwDQuqs79ICgOu2Ogm5uGhlEGQhzrXLgtm3ddFemhTMiGAoRMau55kFGRHMhYRTuXaFwyv49AD0SFzCLLKVzATCzMCITSrpUOCo6BUUClWMQ2Ooyy6bbttl/+Fd/8cXv/eS770+z1ECqswBy3LKUiGgXvxOkAU1mYTm4q8cKLIQQ5q6u1pN2ncZKJMJJyaYqOobpyPwQET4eZybsHdx5jJFU5229qKq5yc1AN6nOSakNB2J0psNhXpZZGB2MGCF9A27I5qd5V5bzmBbD8dIX79hOjn7xRo3Amw8i5iQYwE1vckXepz8QgLeYJB+2Pmu79q0JQXMfw3ejFfc0hgMEH7shqAVemzrFfHc0t/BghPDILpuIDWHXgxIy0VCFCAGwMSrT9dpAAAxgU6UVG3Y1gmjv3l63M1OpTN2258v66s1rPz/95n/6Hx4xtg/fXs+XYvbu++//1ffv19YovL7/5vzhrToYpF09X65rCd/W6/3d4bjMVfhUYl03PLcj4+PMQcRCOlEb0YcW5sAiIgTgqjqMWwsCkRJIUymkOmwgM9aJadeXkiEPNTMqReYllRu6bTLVl7imoQF0R3d3tq0EkO43EUqyIAtLzzE5QabpoqNp77v/IVEElbkKc0bHpqQYAEGikGiAQCwgdroc7suH0/W737zfov75q8+MZpiezOcys4UTpDbdhRgA2T0wKRmBCEJF2SjCQ4d2pArhY/S0Xc2SwzIgy5iLRLhpz/FW7y2S1y1MjPNSVS0pTOGm5pmTt/WBKPRSlENQRgI6TkKQ+Yi01+uAN6wnKSgpvXuhfALEzQl/72JfiKDxAn4C3FZsCkYkZ9zZHzhTrtFwJQI3Y6mo1207t20VjNHNu4IbBAQxBPnQfdAQaIFhotDd8bldYS6qI8MohChcU4cFWYel3DUihcaumt2cEPTrmKZSGAApHaKr8F0lPembzx4OE299u2N8QPj4dHqEeEB/+/1bgfjqzeP4Ln759S+Q/D/4kz97Pn18fHx4/vCsrvVuQZGTjXU7Hw5lruXV6/sYgaZ3ZV57K5PcHQ9dh5SyeXOAYChFPKIsxcyDARhLpa4jpJBwH0PRnIQEB8O0sA31nZxCadIdhTSM7qb18kSUuSkeiBooRZqbEeeBZjE8ANKN0811EDIWHENHG0O1lsqAh8OESMyCBIisZuBRqoS5AzCQgc+BRmS6LofaIYSWz3/0k3/wJ3/0J3/5l+/efoc4UWFVWw4z+l6DIEQyXsDBI9LdiSgKpeSbhqq7iUjBau5mloVI2tiMMUgZg0SAmUYfiJS+627uHsLExEUkJHqL2K+IYCQP9whEjohkQoYDEk3zxKXeBlSxk9r2Ye8OUu5qr0/TsE8v2XtiuhGB8lOxt8MA4OapCXaC9BdnxNjxf0SLYJJCPtbn7XrS0RxsdG3b0BSNAsVu1GDu5kaobqax9svT5avf+YzVBQA1EFPGjUAAlv61gZhmr+Tuw7RWwQgkNFNEr3M117AREXkx9tEQoxQZfaj2IER3Yd8uT2h9KiKHyRHmqfzmm28f7uvr1w+//vab16/q8dUDE22qQPjqzcP6zVqkoJTgot6hokJos7vjAwiba62yTAJXur7/sCxMtVApqMoiXqNtDVSX5eBhKASe+UZRkR/m+Xk7AYIDOnILnYhqRCBwgHhA1wgtcz1fVoZ4dbxbty4INlTNyCPGuGfeWuPeQ9VwUIh1RY/H4xEBrTAilToBgJm5WUkuGqIGFCZ3q0UQwTc/1OXby/M24j/5P/6nf/9P//S64eH1Y3d/fDg0MyhTihMiPM9NYtiXHiG4u0c3pX09kRBnxkIaKO/VkVmqdojBhgGYWWDahiIxR1C4moerGQUDYM6zzIIZ3WGvfZA0fUvdMot6nudaSlAunLgV7fADkCdnvpAvoE9Xwae9ssOjt3wKemGG3lQCASARnl6I+AM+BEG4aakC63k9PY2+eoyx9a1t6sPB0IVIwTkiGLCru7p3xd7ietneffh3/sO/tK7ExoQ+BroFJEkgkSlHZA8Nw7hxuC1sN+9nDMy4UmIm691ytCHoAuBOMzOSgWHh67rxXBcmC1jXdTpOVLHOSz0uGuFCzIJIImgRSEgzUy3z42IFuUyCqriuH9uX97MHEjNNAog0uqGXpSKT6ii1qCoAchG7KjIwcTguh3m7XCOsFBIRIqilMHPrgwhUHQJrEQ0/3t+dnp7ffPZa1ZlwWQ5uLozgyFUOvPz6228eHx+69iAY6qfTeTkcCsFSJ6TgWhFJ1xUBS5HsvdIjNSymQ71FJiMiuqoQGtLx8Oo//t//x//4r/63eH94BFYFM+hDp2ViFgr0wJtlRzCxZux8AHMAIxqbWpqcBwYXgYDehlrGD8dOiGMAgD7G6APBmcjMxlApkvY+kr7/FhnfUkodYxAxhKYyw8OZyT2xnQDEnD+kqhUC/Ac0ftj9ZQCJYje6w52O9YNr4DYE+EQOjV2Vlbtmt4ijPhpEqk6QchBGCOjoyNsW67Nuz+69j36+nBxdow9TI1fzoSNvw/D0tXTro7f+m7dfT8scFOqKECnqMDdLENZv7G0PzKAuTDU2eBvTXG8DDRCWnHkTydp6OSzI7Ag1rfwYNo8oleaqhEQ4go4PD6dLL/NxU2/CjoWmGaTIPDvQ4e4xuHiA1EUdgKWU+XC4V1UBgoCCghoUdDcfvNnEhRwFmAPFSQxx2KFMlRjVJVCQhMWHh/vudxIwhhIyJw4PEW5ja21rU63rZV2v13mqkGhL+LZeAuPDx6c2+rt3HzJEKMCmIlOh4/3h+LBwKW5GCEIkkkNqzacGASLpEoKIwIRELpUw/Lq16bD8e3/6v2t0Z3qgmGeZjmXSddXrFts2V2ZEx0xUK4BIQJEGHMSQTXaRUso8zfO0zNOUBT0RlKkCYHoo5vQ3+YIRoapIKMK999aaqhKjFJ6WWiurKgAgsQ7DPbsPmCSnbGk+mVp+d9NMRNs7V7it6b3pfUH4bxDoS41zW/S3hbTrIQMAPPYIAEj/QrkVUgi4m4MRBkaIgD5v2/m0Xa5mLTVNl/MZiIgoLIIcHCmdrRzVRmtrv67ruj4c7+p80ABzVLQIxyz9I1l66Y5884UNgNS2ugEAs4RvkaGWCKm4dYDRx3y3aASLBLO7jQhjHqEjLE3tyiLrGPVYr7o9rWesPMCJdu9OmUQ96jK1a3MAFvYALBMTcZn6MM6QVBZEynxJNWMpAE5AVMjd1oAiAgBTnQJRh8WULYwLl2U5EgEitT6Qudtq1+t8WIZaIS5zff54QoZ13WqtbgwBJAUBp7ne6bG17oFVityXLsVv/FwEnKaJiaDG2jYRR0ARQSRbV9z9rZEINnME7L0T4OFwfPjq90K4cAkM8Qh3JQD1d7/5dlkWVJvuX41r665EJJxzTbT0DmBE3/WGjpAE3jG09wEA7pZppEktx0J4s8WGZM8SiLC5q6kqRJhIycctIofj4m6jD3DKAzJN+ZO6U2tNEIaQb65oP2D74Mu/4oXv/KJygRfa8w8+ds3YbbF5xhYQRrh4WAQBRmC4azip6ySIw6+X5/H0zBjNrY/RrtcxDGl3gIoIAHJktQGO3ce6tej9/Hz6yU9+jIwOI7l0NzJpRApNdhXzbSxHAdn4ALBk4ClgcpU8Ix8Bw/tohQXNuRQYQY6EqF2lFHIUc+Es3jJJGMZlrUygwRUy4ABJyKKidNvYnQyR2EyLVAbyoYXSWiPLiFimRYfuD8bT/5CYyDwQ0C1DD7C4tIDW1vAHZkIAM0MERphLeT5fKnNloumIBKWWMZpaX+ZZ0raPmIQh8LAsp+dninsRSqsDV2PGCKhzNbP9gHO3MebDstftwph9GAKk9QsCMzDIddMf/+4fnC7n1/cHMAwiEkGzIGytnZ6fr9f1/s14/er1uPSrtlqFmJgLMffepaby1yN2SsLoo/eeKiWI9CuBDF3f9ftS0oB76HD1CBBmV1M1FipMtc4xh5v10R0JK6SXF/OtpnPkIoy7m0uOuva+94bn7JyeG59nX0hwa4Rf1vzLv270oZfbIAsiRADMpHgCR2Aic3cY4QbB/dr6ebXRIvpoQ4f10c00vbCLiEgOI9zd3Gy9NqQ4b5dfffvtH//FPwY3cVDPkbLDbp3pHkAF3Y2RspNDR3fXocyICOkZD2l2IuHhGKBdMQA9MAIMkEICsHU0m8vkQ5nJ1QtRRCzLIcKBcKp1bFdcjgBIlEt2B1kIKXs9ICQiKeJu6XKeV3kp0nt/oLsIZOI0jxg6lsPy9u3bu+MdEpcqaAYi8zx/ePpAQqCBhESEagoxz/P7Dx9RcJkXM+fCyzT1rWkoIDKXCNi9i4nqVIkZGSKACYVppBeTMOKe+r2bwkEwc0aDCbOOzkzpA0KZGkvCXBgAKJZ5ihFMgegUlHz3eZqvp/N2OXeNgnS8f7STtq2J8IDBIkK0bS3dqm0MZNIxxm4LmyGZJGlGgvu5emsM3N1kVB0DCQFgjDEjJpRsGUl7YwS9MBh2Uw10YiZhILr52t6OdNxvwthJz/4S/vWiA7s1k/BSNN00wrehwQ9+mVy6MJcxOiwl7w5hNjcixOHteurXpwlNw0Ithlm39EaVAlQqBIDZcDVz651ibG0bW1vb9Ysf/dgZyQMDYjgFIZBgjN3EKrKDIQgbA4iE2cwy2i1DInKop0PDo4i0rSFilYK7zZy7dkIitalIFT6v2zzPZsaIYDovMwUsZX768JEeANBRCAKYmADDDMy5FCJqrQPj3fHQ2jguXmrJE8bNp3kabTweD0QyRofwqVYK3K5XeOO1TuEQ5pWpHO9Oh+N2vh6WIxBAUKADMZJUInLACDclhMMy961d1kEBjKhutUjrQ5AAaZmm0bXwhIBETEBujqWEObNYaNkdTCHMiTkjoUDVzUgEg4QpzJACAJf7+3O/7G2kqzXgRdKP/vXr10Tx4e1Hhu277377BcJhWU5XHX0Ik4EZkpohwBju7gXLGAMIUpHHxCyZK2URMUYipAyIrgEeTCiHGQF1aMomE0uyMfq2qelNbeKQBg6IACCpZGIhSk8H3PPsdsgnKf4/0HV5QGbk/qDnvW0GvFn/JMoCLxtpZ/5nV0xIKKQB5uGjE1qEF8T2/PT0/i1o09H69YrdXLubmbqpuYaZhTsB+DB0G2uzto3rVWNgifp40HBzw4jogwwoZ32WSV+5Fz2rIoQg4bRHjd2aBGP3+fF0yh86CDH2EN+d7ZFVL7iFOSESQcZXeoQUVreplt6bh5MIIrKQuc3LrJa5QxYQZWI1ff3Zm6enJymSPsw6hoWVUkjYIzwciYcOdzOIL7768unjRxEWoXmZADMLkZ8+fEinyyI81ZKgxfHu7nw+h1stFSKEudY6ldp7C0/v16hSiMkh7h8etnUlchQQYSnc2wYRmRlfhBGxFNGuSbskBhHmIggZLUFVBAOWeSESQvizP/mzfj6RNbfhoBBYiEoVQHz9+RdvPn8DoX09vf/+N+ZtnkoVhLDQ0ba1beu6rTqGm10uZ4hgQuudEKRQuLlruG/XVfuICFVvW+utpyeKq/XWErUZXVNw3bRv1ruOdW0pLUiDNbcgJABkprQwD4d94eKu+QLwlz43dj1LfGqAXz7gf/kiiH0knCr+lz2U14NE5AzLAYH6EHQkfX56u56eHmbyEWHYerdhoWbbZkBM7JZFHzuiJiKs6q29e//xD//BH5XlOMShIxGEIwn42LczEe1qTsAwyxWf+bgZ+XxpZylsZpBBLwToYKYewUS3Hw/S283MWEqEMxMjgcfQtsxz29rWtsfH1+6wbeucoAzL6FqEA8PDp3liJg+C6IUZAfsYlQqLeNhNMIl9jFoREaZpAUJWE2IpRXV3fQwupnp/ODyN4WaJREoprCM8rX+LBxA4MUcEM0kpCXBlRmVSAAqxAszz5IHQlItMdeqtuxkXRESW0lsvUnRouBMJEDLhcOBKyBgeXJg6hMHhZ08DggAAiMhJREFUMMVyYJDlcVFTRLBhLLDcHcLMVQnLq9ePTv788en0/EEKvnr1WoS23vs2hu2eahrBzEA4hqpCKRIRvQ0zA4R23RxCRHSM0dTcwo2JMtapVBm9W7p1BGxb69Z77zbGXrATg1CkEIuACxEAZIgg3tZppEdBNgV725tQ+g9K/X0j/AAE+sQAjVuhtstoftAYIxItddLe0ZTMKAK6rx+eT+8+iDAAuoW5gg6wgarX8+ny/DFSQStSqDBzpLR+01nw+6+/+/f/6j+iaQrztO9nRoeMGNG0iwII2TWLgYhMlNb16VBiw4R55PsdQUiIlI+QmGyYu+XUgogiE9XMIcJMWdDD7x8eRm9F6rRMFjF0AKbyMpCwlHl34R0DM92YqEy1TlXHSPugtCWbl7mPjRDWdUugmhm5pu3wcM/AQpBCJDQtk7oO1XyrzbSUkqorHc1dEYAZdx8hCNpvczezPY6ZUYowko5WasX0kCNQ7Tcpc0hlYWbCtm0oREQsTCK5hrK9Q5LdhszifH2qVZCRCIGwbav2YarC2Ntqpof7u+nuEAgf3r1/+9135+dnAhACJjBVAE//+rSjA4Ddf0/N1Nq2GQZQbNt6va5du7sREwCYGjFmQEAieKfzdeut9U1HQ4JA66O30cfQfBvzDfFbywsvQyzYOQv7nvn0/4D49Cl8Wdnxgn6+HGI/3CHwMj9LAQCBW4kQV+xaW+D5Mp4+Wt+IsHmsZmvfdDRvV90u/dovT5frenWQgWUgoYiH+7BCOK7jYqfp9WemAxiB3HQQQ67QoYZIrg6REa5hZruPSYDpIOIMjkai3nuiQUnMMvVaKgDukx4iABThoWPnZEUQMrOwlLvj8fl0ykDeWsv5cjVPXRwyi4ig0NCRFXx+CSLd3x1Pl3NEmLmU4mkmx2wRaQSbsawiMs1zV1VzBHBzZpFSaqlFyvlydjcISM93kVKKsJTRDQDMnIhFiIgxkIj2IMUASNunUvI2iJykihCmd6IxsQcISaklr/IwD/e9l8fb8mdkIUSE0DA9fXgbXXdPu0BTdw0EAodSqimgwutXrx9fv0Kmta3P5/Pz00lVEaAIm5q5Qhr6jRGmo4++NQAngtGHjq5t9NYT1E7pIUKwcBtja6MPXVvb2jDTCHPzOlVEsK5IiLw7rZpFV0AuAWh7XeM7EngDfW6/TX3vCxUTMPYi54Yf5mcywnrfEvuGwZetgDuVKILCTApVLocoZetxvuj16XEiCR1Du3rTbMD98uGifSME1G42qDIwDdNwX7f1erp+ePv+x1/++P7+EQlNaQxPDBTADS3TtPddaODm2pWS4boH8oWppsOpjkH7fCy/45R3JLUbIAKZ3APSLSJ/bAxGQIjj3XHb2lTr2PpXX33x/PTEiMNtmorpKCLzVK/Xa5gmXlmrIOHDq8fL+XLLqEMRJkQmJiRkaK25RUb5LvOCiFu7xo5NBzOVeZqX+Xw99z4CM/IEmHmaZkDwyOkPAUApJafdCUVnahMSEQEx11K7jgAQZmEWEY9Ez6IUQYwipRZRG7vY2X1ZltitVxEBM2AJKTzGr375U0C9fHw/+rZt1zbG6XRqvWdQVTIfGHk6zHWe1bxvbVvXrTfzEZDjbSICprxcgAjUtW1ba81MbegtXTyfouvIfqDbGKCK4OiRqWbrZR1tbOft+ryO4Rlww1KZeOcMBRAS+ksN/6mwSRM1972sz6RD3LGjW9HzMhb79Iu9yMzT8NPtAZBBcwFA07IUmWu9Iy/X82W9PB0FiwC46nbtrXV1G+N6ulwuV6aYa+ldAyw8Qp0cImLbdPT+9v3Tn/7pn7t7kFM4IWCmRxC6eQR4sp4gO9U8KQETDKl1N4mPXV2bVPXYmZKeCjeAYGYW3iNKI9Q9ECjtgwAt4Hg8AKBDjDa++PLzoWBDwcPUACkY7+/u1+smSEyYKxICjsfjUMviIam5pRZzrVMhrG1tAd61M0mp5e7ubru2W0o9ZVbX3f1d23oyyd08E+O4yHI49GE/gJ85/bRFGNPDNNk2JMwswjmHCIe8W/Ym0NPqmJFwmmcI7L3n+cBCLJzu8+BpHRkQwIhP774/vf/OxqZtMzfX0Xo7Xy+bDkMjYRboQwXK3fFumitgALj2vq7X7Xox7e6DaR8wE4aqaeuttW29miqmfQaCDdOhpjZPIgw+BoVJRXc1bQG9jw6Ean69NvVApuP9cZ4XAkKLWgoHwLBIQ6GUtmQr/FK5JBK0Yzt7AZOU1FzWiJ+EjggJ/8fL4CBuNdONKpEtdVBvQ+rBlNXt3dvvpyoYHsNQFTW8bdY33drlaRVhAmaAN/cPYuzrKt5xbOPpJEDruP7qt1//g3/3zzgQNpMA6AMCIp2zHdKnjZgCI8LNlHcfN+i9l1p2+BbB3TBTQ3g3OVq3LdMrEPOmxdFH/mg6OgKkWg8iTMcXn30uIqfzk5rOdZ5rvawXzixyJnC/vz9++PAeBcIRg7I9YuLj4XA+n1L9LUhTreGkfRThw2F5/+5dRtYgwWdvPn96fgICAFQb8zyP0e+O96131aGmJAIRpTJ43N3dtdY8jAulLS8JA1IEiLCammtO6ploXhZ1NdM0yZ2mCgDJItahiFCYRQQZx+hZPzCzMCOCWyBhBJRa3DXCbNt+8/U31lTbsKFubjZ6W7e+QZCamiJ5SCnHu/vHx9fTfETKwDVVG+v1fDmfLpeTeY9wd02rrPRgRwxinqaSNpilyDwXdx+9I0OZyEYD72X2YDcb29Z8eC11ORxev3qzTAsjFuHlMJdSKJNFw7Ospx3mv7HUYnf3jx3NfHF1ip0QkX1x7g1/uQNeWt/blPgHaFFWTlS5uAGW0rWd2iVm3sbwMB+9bVu7tuvp8vbd0/P5TOjrtq59A45pYYHYer9cN7XRt/b22mQur16/9hgwnA3SpzN57pC/gHQo9EA305x9A4DqIEJXUx3zPG/rRoTmlk1iQJiqFDHV/ctTBstg5kjc+yAggLwTYDrMJPzu7bvT82la5gSL9sB6xD76w3JUtfPzWXsLDAeY6hwYP/rqq6ePz7XIGIp5O2AExGGZ6zK1PkbvAV6quI5Xr149fXy23sNja5tFINOPf/Sj58uFkXvbAIFEgGme5zpXHUbBOfUBj+x2mJlFxlBAYJZ0h56nuY+eCAQLHw6LWXqYAjFZRCllkrpXBh4eXmpxAwvb2Y4E0+HYe5uJvv6b/6lCJkMGYPaw1q8n02FDTTsRhlt4TGW+P9wVqQAUDqY6uurQ6+VyfjqN1rZtM9PCMh+mw3GZp8qYcd3KTETgbhFOQqa6bm0MVfS1tet1NXMu893jq1ev3zw8vqq1pt0gSwFCIpZaMvsyAm5DbwgA36uYT79/Wel7H5vj8fCXiwH2zNFInyuAGy3UM182a4WsioCmeWlmisHzvLYxhkGADR1b0zYAwrqbjyJ8fTo9n042DB0FgtBBtxhjXNq6ffi7n/3yP/3P/g9xQA/rbSNECkq2eFLGWTjAHcxS14OImKWRt7VN05TcIGJsvSfKmbmOOeO4BVNARJgaIZra4XBwMyBQGwCQeWXM8nD/+N1v3x7uDh8/Pv3ox19dz9cIA2AiMnUqhVjWds1Bvo7OEhhw/3D3/PSULo1hLiK1TL331jsB3R2Pz89PjNy3Ps2Lmi7z7BGqpsMYyVQfHx6ul2uakoWHDSsiiHhYjuf1GuAihQsRiw7Nn6UUGSN7xMhkq3mZex82hhRBhKlOqsMhcq4EHsQ0LVOoIwYLQfhUCgIwUdsai5jB6GMuMxlc33/EtsV2sTZ666CZodaup49mgwMIKbrbdfOhh2U5Ho+8E4sQwMMNEYb2db2O1iCiTFSrlMok1EfvrWOAmZlF8iN7a32MADDQ1sYYGgB1mh8fHpbjgafCkuRnBuJwj+RIJvHLwRHMbZiaeRY1iDcy3KcCBuClpf0B7n9DeXAnkd5mw9n1Buba378oWwhyc0d3QQV//PLN+bKl/kdHj7FF6wDqzVprz9vm4PPDzLMYqOkwHeN6cQsb/enp+7//x39igMFeuNgYRRiBIiL8Zci1ZwBDBlll2xYxxmChJFYxs/aeeScAe1jMuq7MnFsgwpNQhAhmRkjp4xAe5iYkan5/v7TrulTpbdzd3ZlavhuIIFIA4PHx7rpupqZmyJiZ7IUYAK1r0tYN/Hi3XJ7P4T7VWqfJA9b1AhHEeH+8+/jx47QsqsNMSxFzX6YZAc/n895nEbAIs4D7Ms+tD3cLQBGxMPMAQGY23+f05s4itdZdoAS4m/sij9H3Th+CEmKqAgBCbOpIkArdsbWg/ZId5kVQwn77618JQGtXoejr1tZNu/bren06b9ftej576DD16MN6eByPhxw4EmBK4MEi5Yht28y9tXZ+Ol/PFxFmgqTThymAIXMIB+L5er1c2tPzhag+3L8+Hh+IBTHzjwGJ0jcOEIMgiy7Trr35GDvpKfNPd7rb/wLyeVnu/xbS+WlLINza4rh1ybcu4tZYQ7iHk3rnMI9NHg53n78i5vN1rM1O5021m45iwYjk4DrmaVrqDECQRUxr4BFDv/9wfnz47PMvvySAMGzbKlWyTU4Mwy05VQh5WqhGABPnEux9QESabgBGZgwyMSXB0HxdV9l5ctkgZgaPT1MdYxCzRwCkb70R0ps3n334+LT2rW9bRNRpjnAkNA8Rsog3bz57/+6Duw0bgNRHkypNBzDuMweisJin6XK9RnhQiPDd/d35cgIIYpyXZVs3ISpT7X2Y2VTLCHt89fj+/fvMgS61ZD/z8Hh/vV6WeWZmRkzlMYLnUkaA0TsiFClho5ZapYzRAaMUAYiMnYWI1N2aWS211KK6v8bday37erLIAZyqmo0yT7/42U8DxvVyaW1lwnBzG24aPq6Xp+t6evrwft3O2vX08clsMNPxuGRY31SrDzM3REQGADg9nT+8/XA6X9etbdfNI0YfZkqCXHiEXa9t25oZANCbx9eH4z0hu++E7biNt/J0Trpz0gyFC8vtVSm92YkcEbca6IUQ98NbYB93RWSKuEOEObx8YXwClfZR2g0Jggialsm9g3VgOP7oi+nNZ8/mT61brTALVaIaZWKZSzDyXGUqQOCqqr1pb9umfVzPl//gL/7S0Fh6dK1TsWG7h2O471i3mQ4pBRLn8sg/C7U83c1Ux0gz2hxyRYCp5Y9HxGa+J2FFiIia1Vq2bYXwtO82VWEZOu7v79zDhrrD5bre3R3MQzKuK+Lp3YfP3rwWrlsbOrRvjZkBYKq1lmq++2MNNQSsZbpczu3ahGSaKknJXCZVBYzESUV4r9qHffHZZ330xKxMrZaKAPOUuE0LdzMvVaSWrpYOTWnQDRBjjAAW4VIyhwZ0GBJVkVTQElEiySRUS0XcvX7TtbNIIcB1WwFh9JtGx111vHv3XgjWy9ZG0z7A3XS4akS4etfuw9R1moqp9t4g4HB3mEpxjVKLkOiw7drDvZZyuLu7uz+KFPMYXcdQwFiv68cPz+t57X0A0GE63D28LtMRQtwJENI8L3Dn8MSO29+60X10JZhHHxKmaBBuIKvHrq9MRfluertfnrllsmT65IuYnKB9qJzM5N1cLjcSImQ1hqUI11KP8/3v/ugnf/gH07IEmiAzoNymgAFRy1RKBQc3t2ExRjoY//qb3/zZP/oL72s1KGA+BlKWwa57f7JDP8BATBlXGgA6dOtbqcVURxs3ioFksztGz5HGPM+7qfutuckbcZrnMZSLqFlADo+IiO+OD0PH23fvSuG2NWERkvAIxLY1B7xb7iLwuq7tsiKgqftwQHp8/erp6aRDAYiZAuOzzz//7rvvIZyFheRQl9E7ERUubRsBJsKllDFGuNWpMEmR6cPH97UKEQM6IEgp82HZtg0Qhw5Emko1HZnVN09T6xsAugMTINGyHPvoifmGW635npu7MwojcNDhcOi9ExGREJCbIdMyL7r20XoG2Iy+lcIY8JvffBtJPVR1cx0GhqNpgAPGVAsyXs7X67qqWqaFhMc8z8eH4+F4OByP0zyVIqaurffWxtaFaJpqrUIMrfe+btpb752ZpRaeihTxSE/W7NU9AkI9XkoSh3C8UXgAIfPqb9DcS5sbEVkvvbwu9uW7D79vXIdPHwFuhntjnHvFP0GiiaRk6lsfg0VIihRhrlxqebh7/OoLMwNVJAdy4WCB0XU6LEFgKRk1jdDo43q9brj++Mc/EeEYPQmLmcac4ShqmrPu5FTmD0VEGWDf1o2QMuZOmLRnZMw+Icqz2dXwxd3opvXJG3TbVlN1d+0jZ40IcTwsj4+Pp6dTlbJuq7uzECCKSI5pDf14d4DA0ZoP0za4EAJ98ebNx/dPU602jACFy93hCMjrdbM2wF1YRKbLx/NxWZC5NwsNYRapppnhCneH5Xpd0cFU0XdZ2HFZttbAokoNiKnWJEQSYJViGugO4YQ0uha+HfXuEECAmXDDgdpbkQIR5FiojD4owjJhlliKAKCphZvpqJNou1aJ97/51kfbLpcxhhDCCNfBBGB5jiIGMKKrhZuwiAgTJiJs7lxIhAVpnmSptQJUJsZYT2cdW9+2drqOoQiyTAuzsHAmfRBG0j1ecJwA2A35I+U2+xqNNCx2z+eeOpv9iI9bwHm+3G9jXAeINPLcV/gN9UlnAoTUlaV82V/Qz5fCCSOzW0RKWFh3M4JSl8cvfvwHfyiHoxMguhCNYefLJRAKCxKF56zKdOug3nWVqdL9sq3XgIgwwoDYgzuBwPfnYTndgFvvmyErQ7WUEm7ZL25ty5+dbh8Q0Ecn4Vy72V0ioamRcAa1uDsAhIEwMXOZplLk6fmJmdQy9wUBgAjKVCL0erl++eUXAdDatq4XYmZiM7073H98+qhjBMZ8mM10WZZlnk+nExIFYCkFk29PZarThw/vRFhKZQIzA8DweLh/uFzOAUEsQFGESGhe5uv1um1rqVJKqVPJNkZESq3utvXGLAFBDCQCiK13JDJ3YmHmPloyLBIEIyap5Xy+KBgzlamkdpkJPWwEsDCBF6YY3bf15z/964c39x+fzu6wroNBIiDCpEidapmmOk1SSpkmKhIAbbTLdW3bFh7rtW1r703dggkJYLRVxyY1ruu1bdeujQizI06G7j4QdA+I9H25nfS+m/DvsGae6jnR8h/gnZBCvBvtP37Yzb5oBdJF6La04yaJwRtFOgAA3OB2b9xQ9E8EIXp8eIVBEGhqquaOA9C4Gs/Icx+qalzQTKXUOi/IhDnbVoVhwrRul8+++l1bJoAgV3TPN2LfaoFmhoiM6KaZxBF+k3SAu1qtslPcINws9g3rxAQInoHdOSXBfc7qZomBqI1t24TJzADcLBXH8dmb123dWmvLMmUoNwIQMZeCSKcPH1+/fhUYqrZtzc1G75nsNC+HbWuM3FuLQAs7LMvW2rZdTUcGA5dae+hnrx/X6woOAV5K7a0zwbSUqVZCvpzPCI5AHoFBU6nH5bCj1mZEVKSYKTICRK21j4HghOTmCDCV4pl27QHgyzyFQVrSQoY4AQgJIZtaarJS3z7Pk/Xhrh7uFhQu7gv5b3/xs/fffq1t23qvU5WlGAKVUosk1dzCgQAQRh/bdR1dh421pUY5QFjRL9f16fTco4H4Zbt8fPp4vZ4dnauAEGKG7xhA1tq7gZft2c8/xHAgctXvwynYAZ8b0yHn3vsyTfCDEgnfdYSwi2Pghv8g4EscWETs0l/44Usi+Zcv5AmMCHKNFOqEYxiYeuH69O7pIEcdLkBlmXQbY5hwkSIBnLP5cOhm13VT8//or/59RYoANc8iB80gghFT3oxhagPRIy1W8yhwDwjVQbTvSN+HXLcuf2dPON3ERzYsX5nxj4EopfQ+1ssqIuYR4czsDj/+8Y/Pl+vQPi1z78PD894oIkXK6Xrdu0mA3lc1ZRHVTsiHw3I6n9xUShVGgFgOx1rr09OzuUUAF4JwCnh4fPzu++/NNN9SIjL3sOBapZR3H95DBCJOtQCE1HK8O54vJ4Dd43ue59HVzQHpcFi2bQWErbdShJjqVEcbw0aZq7kzSeuNi7iDm7spMokUJGx9y+ueEQCjThMxba2NNgjR1XTtC9AS8N3XX98dp9ZWPpR0qifJgiJxNe06+ta262amqqq9j967moZbWDCVw0QTfzw9f//27fPp5GBcmStnh6Z5FgO6ZZGdNbxjINwqGoSX4dRuBb1PAeJ28O+8nz26O0v9xGRfEKCd7nbDdPbKaj90b5gp/gD7zP908rpg7zpSFE+ZBbMr5REDoG+jgFw/fKimlZK/6QC4HO6Iyy62cWAEMTrcL+3p4+/+zt+zfqaKHAYRe46qGUZgRKQrYGYFmUc4UcYmhdnNOzGCiLIvDHd8KQPdAUF15MzzJukJM8VAU3t4eEDM9FxgZkRGRCny8Pgqbedmrm3r4a5qYRHhUuVyvvZte/XwwGmx77GuVwJygi8//+z09FyktvVKiKOP++MyL7O5WVcAMLdap3wM0zRvbQsPITrcHbbWI7yKfPH5m8t6IRRTDQ8WyezHMVx7n2otUqa5DlUbepzmeZ56V3DkG+CQsK+rgYUwCxE4bOsKabPHHBFEONV5va6uxpkmqF6ESyneh7uPPtxBCCN0EXn67rc82v0yBQdIACMxIYYN1d5NB7iBWy1pQmqARhxlZh/t8vzUxvXj6f03v/76/PQU7kxJkeOUK0faakXcYqdTZR4e4JlgC5/W445z7od8Bh68HMwAAJhl9M23MfaR962MipdlH3j7S19WvAMA3e6N3eNhv19uaBHdCENASJzNN+VgLIA9VPvYVh29r9cYHSFC4dXrR1PL7tPAgMIPcuXgh8evvvyiogJEd7vx7hzz1sr5RRi4J1HxxnDycNtXf16DbgDIxPutRzR6d7cUhe27Nn3skNLVfYzxxZdfDh1PTx8jPNxzGCzM83IopXz3/XfLYXm+XJI+qaZDLf8T5nY4HqWWbV1bb4SMHG52//BwOp/X7ZK58EVkOi7TNEPA6XxCAASCcCmCzPM8Pz0/6xjEQkgQIcwB/vjw6OqX87OUQixMkDyfaSoWHuGqNpVaiAHDIUTqJKWPbZ4mInZ3Ji5S+hiEKEW4FBI5X67gTpxnoe9BIoGuylyykgGGeZrJYrQGhAFOjG5RmKvUf/O3fz0fqG+X5TCzMO4XsTmkwo7DQ7uGBroVISS/nD6+f//98/Pbp++/P719D8OJGBzAwRXoxk/Lxwlwg30gdtF8TicgwndOg7vv89Af1P24965xm+zml770yjdwJ0/2G0k4XnYM3HoB3//3qZcggJcLBG5782WjBfAuML6B0ooSjigEHlUKKXoUYJF59u5hqWzEER7kl+fuGn6o3VbLQipJ7m5463Iy5s6GC7AOBfc9ThtRx0iXkbyDiVIpr7eDcHc80jEgQlUJOW8k050pdHd3LEW2dUuUcPQRERkTdn9/dzpfljpJKW3LCG4GgFrL/f19750I5mlCgPPp5KYY2Ft/PB4Ly7ZuQgxI7g4Wh2Veprm1ntpwTvMaoa+++OLp9DH9I4SplGlrHQJKqcu0bL2DWts24UJIU63LNLe2FS7ggYR3D3fn89XNIvywLGNYdjhCEhBTFbAM6MNwn6q4KhO7R5qEAsRcSmExVR2diJkrGFQuU6nabLj39Bxt6qYMsZ3P73/7/Vxou1xrrchAt0NYhLbr1vpwtXANtHfv3n79q1/+6uc/f//999p7mLNwCAWwOqpDGnyEv5zoEB47rrNXOui3kdS+RveoW/jhcnypUvZj3XecM240hxvr57aq4wdV/MutcDN1z13lOwf6xlnHlw2xtwMJPJEmSXi/oRwBHFyOCwSY2+idIC34JDtUUE3fmNFsqH94et5gIwfNZ2fuecCbRTgRBDgKjT7CjTm1+LGT4BHHGKkLdbdaaw73+kg/FeAimLpHpogQYbMBFEkKRYY+xvHujlm265pFZvItGUmKvHp8dT5fuw4gMLPEJAgxIpZlvpwuQjIvc3i0rZlqRExVqJTD/d2HD+/HaGYqzEywzHOpFcLP53OtJQDmqYjI/f39etnO51OdiohMlWm/nvCzz95c14u6C4uNscwTFz7e37W1b+t1OS4sUkTy0RaR5bCM0fdOj4KJ6jQDU2vdw0j4/ngXDut6QUIWyUNWpioivaVlA0y1uBkLzfMSCNeR0lJgwdEaWEezn//sb5aDqLahbQxvvfeh1+v69OHZ1IjkdDr9/Je//OlP/82vvv7188dnNStFEBkR3DGc9pA6IvPwtH2KnX0TefZ6pN9tVrMQkVfNftl/Ov5zxccngP+lPQCI3UEtXsr+vVj4VPa/FEy33++F8ifQKHkan2bCt322f08IlL98+U+He7BMd8cAkJmDUJsOHYc6wTp4KHaHPuI6wNzP6yRwefoA/WptAweLcNW8trJ/MVcmNFNAIKGekELeDZ7HR5gbYlrcgKneqqa4dfGoZon1+r613T0YSIfO8/R4f+8Wo2/hBhDuDkRA+PDq7nK6iNA8L+t1TaMxQOhqh+OhD0WmZVlKLWYGSDpG7reHu2NmGqT/T3KwqwgRn8+nInKDdHGepvv7+7Vt2gwR6jTl6BogDtM8tjHaWiqbhZsT0GFaRIiY3NxMmbiW6jewHwJsaLpz6TBhKsyBXlisjyJSa0Vga+ZmROIehFRLHTZ4H6FAqZMPnSpznfowQ2itBbiwzCw8hl4up+9+c6xltDVGs2uDtjGRuX14/v5f/ct/9rc/+9fv3n+3bhsjc5mQqwapodqOFAWFZ23zciJ75mFnAKG9nHEvC/W2/OxWvu9Vb9x4O7fP3I73iJsgDPFW7NzaB/hBRQ/wsn/2vwpvZQ/Ejfz56QbYX/DyyqBdFZJfFZiSq2lZSCoAbV03VwtkpghNlz8b3VsfW+/NtPk/+od/Tq66XqyvgDRUA1G7RQQQIiMXTsZYKiGTZBhuCLC3vDn6yivUDfYhX+yza4yp1iR8vyjEiFI/g6UUJJ4P8+l8DvPR1c0yGvv+7hEAr9t1ueEtQ0cyzonw/njn5lJknpfe2+V8YhFmMrc3bz7b1vb08UOEI1HClGWu8zy31lrbWCQzTkqtU50ul3MpjEQQwUjMBIB1med5Pp0ufWtEVESEeKqTSDmfLwliTvPEzB6eKh8AMHeirLAkIqZp0mbmTiIBWEvp2ogpqyAWcbNlXmy4qbJQRDACClEhFhYA7yN/azAcBnOM6/Wbv/3px29/URDEhoR9/O1v//pf/Pf/9L/6L//mf/wfT89PbgMzXsnRNch5fzaQVG6Lm6PHreje13EAJHs04GboE3tFhLcy/eXA9l2T8nKk33bB7dU7lvNid4UBkAsgPv1t8cJ0+ESFw306nB2Eh/tLmPytB88yxBIGJAOAm7QmwHOlHR+X1h2Iu7sJmVB3DbQgHb5u1tbWoMA21j/643+YKkbfWluvpmqmhED79QKMbKpmzsw69EYJdEAg3NGMvcPd0QLMesYyRB5RStmH4TvpP/ahKwECzvNcmJ+fn1jITLkwEgPgvEyllOvlMhXpY5il3pKk1ghg4YBg4sPh4BG9Dx3qZhFwPByIKZnh4GHDCHGu02FZ3FyHurvqkFqA8c2rV33tvXffDSPEI0Ltblnu7u62tkYEAagqIE5TPSwHVyNEYUbAeZ7M3N2KSJXS2sZE6a3i5rWIFNahVSQg5nnyEaZKhAgwWpMiRDRPc46uhw5MwhDiPM2MZF0DwsACoQ/V3qC3X//i5+30/P/9f/zff/ov/sV//U/+P//yv/mnv/35L149LvVQaCYvYAgKYbg7vaeaInYS160E/1Rhv4ykzPP8jxvS/VJ4eNyMcHYw57au8wXuL1si2f0vPS3Ey92QjfG+kPdPfIKFXrqIfGovmCrs1u9ZOHiSMtIBDVKymCLrfaslMgbx+tWb9XIdvZt7EAehMW7oV+iXsLP11fXa3HTMd7N3A4tEdVJyYR4BkdNBkn18kQQeQvREQuEmcs73wAwJmdhd42Vnp+snoUcQ88sg44Z8p5YWv/jyi3ffvwsPIEpDCohgFi7y4ePHeZrH6L03U9vhZwSAYCQgvDveM/HlcgZAYiaEaZ4Px7vet+u6UuEIKEWklHleLOL9+3eUeYgYDPj45vVwba3lPVZrtaFcBJnmaSbkD+/fSWFETAbAPM9Fyvl8zonossxJ3ZIi01xba3mallIiAgCrVB3D3EuROs0OrqbuoeFE3HsDjOP9YetbH52ZzUfelsREwoCwbl0dmZkJgcDc33/38Z/9t//t0+n5v/+v/7tvv/7Vu++/Z4LetffugACSmZAQ4BAWFoT7Ms2p6r6g46VMzYtgP6VvS+zlKH8p8fHG8fzBob/DmHFbsj8ojm6Fza38+bd33ssVtB+eLxDSLWoyxw67UHJ/Fd5edRujERDHp+8p58sYDvMyAZKq2v9c1Z/syJptaWLYavb+G+u8O23092beylusYmUKhYIACpAmmgiEQAgC9AAaSIAGJDjUM6iBJtJAY72FBIkUiyhRBRZFIjPvzdtGH3H8HG/Mzexv9l6NBnv/5ic9AhF+/Libm7vtZq1vfY0kAxNCJUxos2k2T26KuH98ygaW/XB4MgMMcUymSrnYYqmrOBacD0BEDOp9WUKrza0IvkTE3ZGIA5dhU9myVTNefhgEM2MOqmbgZQerO3MA91evX949PJippERMQFjIU13XPD0eLi62Yi4iZYMCYGEEOoCpdX3btt00zVmSigGQqmzXKxXNaQ6IZuVW9LZrAoVxGtGxJLqpet+0q241zQMTqVqMAYmKVP/ychc4zHMixJyTgyPBbrtu21ZVJWUGjDE2XWuiDLBa9fOUkZCAwL3rOskSIxGzm1nB+LkYtTsBqQlxAITATEiSM6CBl7sFEKBvGuYgDuM0AzM2EZBySo7+/dffvf/pp5SP7okILCsTx7ZdLl4Dr5V0gTCX47qq0KxwfatDqIN7JWoua8sq6OlL6VRhoo9W47KHnpf1cqovX3geD8Nzw7s8j+cbxBfA9fmyWIZw/+hLYOm7y34pa4yYuLYGtdkmMO/7PsaOmojIRAzmgKDo2SCpTUlETVVPwzCcTl//6evTYUxDyklNcRpnySIKHKKZEgGSR+ZyJYbAgI41d8GRiIlt4fq6WQzRwQHRlmqQEOrgCZF5GfaVG8SRAxHz5eUVIo3zyDGUX3IbmxAiArnjdrtlwjzNZR0XqxURCYGRqGma2LTjMGppRgmRcLPZEIdpmsqQuLIOibfbzf2HewAvpOmmCdyEy+vLh/t9zqk4jTIzIKRZ+r5vmtbUHh4fQgiFnRWaplv1kvI4nJq2iRwjB0IQd0JuYhzHIYYQ2xiYy1iFkMpKiG0Tm2YcJjNHRkJWFXOjGGLbjPMkuWroXJXQKHLsGkQQ0+yeVEr0Uumdgnseh9P+YCl3fWeqliUEwuKPVwCVsioLgracsMvZD16b4aWYd/eq1LBaDyysFiibZSlcys4pAs2Ptgr4UrvUZfqPeuPlrIeF+QBLQV+vEli6hmWzLf3GGfU/kyscHAiLuyEYIECZoRKCkzu5haYxUZOMquTojqZgJabTQLKlJKGJkuTdz+90zuCGhSYtnqdkKSGipRyI0CEwFfPD+qOLOHjxhXUwKZIucCtYp6iqACwUN4Sma3LKDs4cimFT+RkNQd0AEJnWm804Tnmc85wR0MCJqXijz5p2l7v9/lDEh0wUm5iy5JRV1ME363XXdfd398U+cRrmtm2b2KiYZCXClDMTMePN5ZWq5jxzZHfMWcDtYrvLOTFxxFCzvRBF1EwvL7Zd087TVA7PMgZZdW3fdSpmooi+WnUOmFNGgu12PZ5GWvxwAFwlr/qmDC8l59jEkkQZiEXFHXISJuz7vkQhM5GCAQGIBcImxqbtJEuaB1UtzKsQuVgCx8jdqq2YnFpgMvHKxIFnIs2yNr10i2ZLOb2UKs80/Tq/sjMMrwjqrmaqpqZV1b1wf0q5sgyvzlXQRwf9edGcj/wFVFqoD2dgyJ/BVTzviGotgQvfpv4tVqSxGDGeqRiIQGAYQlAAbuKcc0rJJAMYmcWslBOrurmohdAg+ul0mMfZVcGcETQlTXNKk1t2FUIPhLFpTMVVm7YxNywaatUCn8/zSKHYRTsxpzxTsZCoJCgqhNYij0IqdGsFh1C7AkLmF69evr+95RCW2B9ipm61FpGHu/uXr1/McwYQJFa3JsZ5mpGg6zqOMbQNx/D0dAghZFEiJMbL68tpmk6nUzlr+nXnROvt5uk0HJ4OhYIWAgFgbNoQ2sf9A5CHGADRzBjRTLe7Xb/ZPD7uT4dDbGLbtGYWm5ZjGKdhnMaygCKH8uqu1+vD4Siqpt5EXq3WqmaOTWREHMepa9qu68ZpmuaJmREBGVWNmJvYppxSzg7FUsbQwAlLwsV0mi1piBGA6/zfNfRsZBDdUYFMzRWKmKrKOBYxU3V1rrNdPwMplfFTGtyylpaNUXEVe651PipTlqmta2mAP65VyhH9PLNaboBlNHxe6AvpYAH1yzew+rxgeQa1x1w2zzPM6sUn3JgTgpWxcDlciSn06zQKApgImDdInUGbNEzZTwOIqsHFxQXHOE0pEKVpdlV2c51VEqrKPGqaXRyRwKEkulFlH5WGymMIRXtRSsgzViAiiMU9CsEdCQMHBygO/cXDEBBiEyUJI6n5brv98O69q2jObiVniQLzNM4hxOvL66Zr94fj6XAA877rkBkcVE2SxMB9101pTnlGxBhC4YYAgqhASeVwsGyAeHF5eXd/X16k2DSSlRnX684UihyRAN20X/dpEjBfdW1DTc7ipoioooTQd10T2mkaTRQB+75r2lazqepqtdo/PnVtyzE0bSSknObqehciB2piFFGs6lZDoJwlMDdtnKdUyKRmzoHBFB2YKK5aL7ofMwdgDqGJjrXcx4YUFc0Xoge6LWSGM9fYajPgWMdbZrUwKQ2vVxqbQbXxLDNP9TIE8eeNsCxy92J4X5L6oC7Zkhu20H9KZ1FssxYZi39MNa23RjGCPmvMame9gFBlwLXQMOvTseKrN40HtxlIBTWjKzo2VPCENCcTd6A+hIBGOZEruQcHUWeO7XrDIWzWa2BWF0kjQlKdT4dHs0xQnqaCe4ihMPiL0oNKKGcgAI8xFIjQVM00xJBzYi6mUaXZJVERlfI6EPO5Z2KiaRoxEDBdXl/fPzwmrYPtkhu03e3maTaHpl+9fvP64eGRCcUgxAAA0zy5Owc299V6lVJ+fHx0cGQqYRaxacZxnFMqr1CIYUrT9fUluOc8i7upFljh6up6GE6hCcxMTCKuohwo59z3q83lZpzGYRgRIYRQCHnr7ep0PM3z2DRNaLiJIUsqSYxd17o7OsQQYtOIak45BCp6eY4BEVOeS1lbVoK5NU0rauM0mVtsgoObq7urWwyRIpuJlvAXJmSKsaHAwJxViyaJED/qTRdGTfVW8FL8qJ5Lecczim8F9tDi8brU8F5Bx4WXUOmNdb/U8/28TOsnqhV7Fa+Tq6Vp8I/eKXvobPq/fOh8zhcR2rlfWLqJ2irUQZO7O1Cajy6jaS6Xx5hyZj2eHj/9xRdTnqc0pTkTUMhCkjyPZHP2nCyLy8PTU8r54vJKANRB1bMkd5U8p3kap9ERVNwJAbzrurKbicnd6mZ10JIz7mZmuLjBoVf9KzioynqzmoYxxqjmTRPPHTMSFhfjPKftepOTjKfjNIxExDEg8W63Pc1JskxPw82LS4KYc55OA4Ajc+nlJaembdq2DYGnaUbHnHMobg7uRJxzLno6Zl6v15cXl+/v3keObm5gbdeZGKK3sZMkABBCAIQ5z23bFR7Hql+ZVIUnuoND17QxRFFFJBUr5VzfrTSLSW6bqFqjOpoYGYsemsonNzE2scmipaF1MGKWXGYLdQRqYkSoFbJEc+z6lVNQK5FT7ByUGTgougCaI1Ko683cAMxLiwVqrmX65eZQNLVljWqtR6zEPZZqxrTmAKu7lpYBax/sUHLR6uK0RcRVlrWdKdRLkfJ8fPtSMdlS8BtWIndpiP3jsuqMnNZOuewK/Ed7ZLm+6OHh0ZFUs6moCDAkS+/2J+utXW+Q6GlMq67VNKtlRTuZKgAzSYS//9M33/zwrqFeJdcyyx0JpynNKU/DNE8pzcnVCJkQi5oWAZiodIruJdrJvSSVm3LgnJJXooQVr0hwnOa5KOWLRmy5lx0dDRyZur4zxMeng5QSUC3GsF6t+rZ72N8D83q969tuHMfiWxgDpzQjAIcYAofQMIe7u7vYxELXCiG2bTtOo6rOeSrOurGJq351Gqbj8Vh0ZMTYdq2KT3kKMRIxEhLzPE5qGtuGmFfrdb9aP+2fUkocQwhMhF3XtbE5HQ9MGDgG5q6NTdOOc5KUETyGyMxt1zZNkyWLCBM2TeRCeFYtBHGzpeZF6NfrufCCiq0JgKoxUM45xrZtWhdzt8DETOAYkAOENItTMASxpep5RiPL71oLR2Cx7q8FeF2T5T0rshKoHHirRz/o8+zpvEjNzMQWwMjM5NxV11V8voc+7n3BcfGjPEOmdlbZntFVLxsEa2NtC+RYh9VeMT1wd6PNek3OIprzaZr3x6e78enxr/7Zl6fDcL+/ezjOHNbHKeUQBvCHac5ME9i70/APv/t2znPfNYB6msaUkrmLuqgioeQ8joOa1MYfLQQuMT71JCgwv3uIwcTqOVKeH1FB/UtoOSESEZUALwBENNUilSMmcEcAU2+aNgQ6Hp6g0q4MkGLbbi+342k+PDwS4du3r+Yxges8T9vNajpNAK4i6IhM63U/HIfIPE+pIL/rzXqak5sxhTxnJFDz9WrNzMNw8qwABZHlElKkWQA8xtjEmEVNrZTGgUPfdznrOIzlsFO1GLjr2uNxcDPNGRyKKVATwjCNCOhqgQMThxiYeJ4SLva3IQQHUDXNQlQdVB2QmSmEJGLiBo4cJYu7dhxRrQ1NExsXJZOISOYkxklJbZomCqxlkZmhCZiCGbqCSUEAyY3MsQoPF2frRY4LBRV1AzUwA1NUQzcAw7oBSqB9dek7jxOgNsdFCqzwkSa4rvKKtJZ9B+cestZLpUFQ+0hUVh/h3LrbMgleEK26NRCRPv/sVwF3Iaz6bnO1vfjk9c3NZvV/+z/9n/+3//F/evP5q9h2CTCH9l7sgP0TtX/4cPzvfnf7t3/39bv3T3cfTrf3T8bR3YqLfNnP85RyyuNx0KwpZSxTYARDL3WOL7huiZEttxUQiAoxdU0rIuXXU3b8Zr2e5wmw5mpyCDmnIghSN/XSWvB6u7m/exBJakohlNjDV69e/uGPf2z64MiffPpZv1onkTSnm5vrx/1T8ZIog94mtk/Ho6jUnC+i2DQiMqdZNANTaIKIbLZbjs3TcMiaOcZyTXV9dxxOxfuNiLq+m+bpeDqs1qvS/6xWa0R8fHiIIRQvz9g2IUZEmKaRAxf9c4h8fXP1+PDgYMDE8cwM4pRnNeXACNi1HQBlSSEEM1fVEtKIpX1BEHNAcvcYGhMzNXQnhJZDREL3BqlBRLUASFo88rAsnFpnL+VMrVmKbZOV1VbrkoUGZAURWgoXc9U6PvCyNA2WR16WPFTE5lzqfFTs26KXP3cjgAWeWfaK23mNnxHQpV0vT8vKPi3tR51Wl2vNzM2XcZyF/Y8feEaL08Nw//D44fuvv/36b/+7/Yf3W2z+/t/+t37IL2+uf7p/eKfjh7vTPJxoVpU5mQICtXE6QBqTXzWW2SS7g6szkZvNaQbwLJJEAjfEwQ1Skq5YGSOVIjJwsOKBL+rqxSLZVMvwnZlNjQLP0wwOro4ExOTmyCSiTYh10pzl9euXf/zdnzSrqpoKc0AML66vZNbhOAbk9vpiu90+Pj4Mx/Hly5uu64+nYbPhcqZtV+uuXc1pRqCS0NH3Xdu2KQsizvMcAsWmjV1zfXmVxqwCw3Fo2waZYohN6My8aItjbCI385hcPauCQYh8dXHx8PhoFQ0HQFu1/YkOKaWVr4hYVZsYoVupgysomoojc+AQOGbSeU49RwcMTSxVUC7jPEA182IqFMI0TwRcdDZ5nkuTSsxqxsykjuAEToAInrOGEBnIi3nVwsHFGtBFXvxTaUlWLOe9GzotrH8E9FBnnYCITu7uaGiVYkPuDo5egnWfGW7oZsQMZ7IdlPoECoHt/HnmvsywSj+7zMHOJX4dbn00OiiedtUNyNGhmPHUEYu5uSEybTEeH9/9/f/33/7X/+//7N/+P/7vf/dv/svD+9utOeXTfDwJ6J9/+O5PP/787fuH23lIABpACCEGawNjCC1sr7c6J5cZKwpgDphVU8rTNOeccpYsGYgxBDUpVTIv4QgANR/c3TiwqHZ9N04DLsHLCNCEeDwdCtkGiAKFnHM5UUQF3QOjqLx5/eZpf5imEQmJykln6/UFEt0/3F/cXE/Zrq4uIwUF4xjcobgecKAQeLPbiuk4jIhYIqKJ+eLy8uHhQbNUhb+7mr16/er7H7/ngByjI7hZ17UGKpo4RAqEAF3f7vePseGmaYpMsetXJZ8UAWIMCLDerJAp56RqDh5jAKQQI3N4eHpAAo7BTGIMIYYQeE5JTUpG7arv55QqpQXRxREA1Ikoi2QV5GLCHmCpu8uUmokCUTVKqmcuoIOJltnQR2ALLqSH+uHqSLKU8fVEdyuAH+hChDtXs/VPBX8sJ/HzSQ81k7MAm74IaJfJcR0xn3GpZ/Sp3gv15/IF0zco+8TdzReKktYvBzMXdyuWCr4o0ehf/+v//D/7L/5fv/vt3//+D394//5939DL7brbBkVo160xOIdMJq6GkNQnNaEQmg4hUBeRQ991gY1NSOeaoVN9vHSaZwdI48RIAE4EOWeRjIiFPKyqTRMBwbQCWWLa931OeZnDg6gRMVMQkbL/iclMwWs+imQtbev19bWaHY5HN5Riz2YUGC4ud999+93x8TA8HdsQ1puNzDqN0263mcaEhGaAjma+6vv9/omJRJSZ1ezyYvf0dFQTAHRAYso579ZbDuHp6clEXOqRs9luj4fBTUEdGbfrTcp6Og6gRkx5zuu+69tuGEZGMlVXZ6a+69Ocy1FXylqOYbvZjOPk6iKCQOIWYyj4b87iBoDQdh0aJckFagYCJHJwcGQOYp6S1DKXQgE03azgsIjEMQBTVsWACA5WI0ieu8jawy6zKFAvdPSl4iij3fIpVnfEcvraR6u3EiXM3XVp9rQELlrBVV1ticiw89ZYRsVLfXNGVs/fv+6Dcz9cIdXC1v6451YtVaCdAVY712P0h3/42z/99N33P/2YVTZ9g5L2jw937x7GeRrnLFqgrmroFgIhIxE5MsfGMHITnbTtoiYBK1C9ExMHNrM0z+NpLMxnd12vVsMwMJeEIiuik3oMIZg5MpnabrMdxtHJkdBNiUo2m5lpWSWEuDQ/df8TAjJs15cU8PsffjBToAgAsQ1Nv9rs1neP++NwoMjAtFr3oeEpzdvddhrH8tuNTSTG1bo/Ho/mCoQxMgCu+pUbnE6DZAEHIKRAq+1aRKd5LCkvHNjA1+vVOJ6atnVGcA9Ns96s7+4/hCYicds2EPji8uK4P2TJVAYd4KvVeqFYa1EVg9uLFzdTmkWzuRXSKzKVII9xHBE8xEiB1pv18TggAEcipDRNYMWlK+YsOUkpTwq/19QKMbjUkDFGLkyvcucEKjX3czGyVPQFeihnui0MrYVA+RED7aPmoA7BTItFSoE07FzxL7fH8yTLP/rj85Ff+g6va/n8plq8c+qit0WJaMsiL5+hYqZ1wFoWvam7FYdFVSmfQLc//jjvT4zSkQ+Hp/vHh0kyRHA3MRV3RUdDNCVRVCVCMyfUJsLwNGx2u/3Dk+aEpg5egnvMHYu1peg8T1lzmhM6mgozFbTHzPlMia7GieUQ8n7V5Tm5maoSsTkQUWza4rngXitAES0GkyKiBhxCs24/++Sz+/f3Ms/MyESatYmxDU0bw+HpgA7m3nVdw2Eep1XXT2NyL4C1N22/6vrTaUCscfAO2HZtaOKcUlkXgTnP0rfderO9vX2f59nMchYOYdWvxnEq8lEzCIE36/XpNKJDTinGwMQXu904z25gUifWbROYeZxGIhbJfd+reRsbJk5zChTQSwY1Nm3DxEVMPE8ZzLe7jYiISs7JTIhIVRCNqLjJu5qpZwqAjOZinoEdsGRb2MVuReBq6iaByd29XKWA5/J6GVwZVLsec6jMtkUGsBzDZWNYPfzPZ1NZkLWQN6+uCYBuUBAMMDhTgnwZElToBs7A6Edv5ZDwsror8+75jijbQhf5JTigualmqXY+7stQwk2Ffv7uz4ene5RhfnpI04HY3VWSiKiLmYm6GCiqB/esOs0po53E7k/zqOlyFdE0P53GMaec1cARidkBkCnlnEWmcc5pdtMYYko5p4QEasKh6AVQJBMWH1xEhybGlJO7E5KDMyE4tG1jZkWHxcRIpJIdrNRFKpmZkeLV9dUPP/6UNUlW01I50Ga7zVl//PknByDEGONmtxvGBADTPIskCtx0LYJfXl0+PuzneSrRFTEEQOy6/vHh0V1zymZWLCQvry5UsiOIWmRCgrZthnEyMwNfrXsiuLi8uLu7m6YxtE1sIhK0XV8UAm3bhBBcFAm7vj8djpozh2AijNh07fXN9bvbWyZwgrZpzVRFm64V1ePh2DShSFpDw09PewQgRg6lywQOAQmzSfbsDIaKwZ3MXKQYObCbSRMoBIyRYuAScLdklsGyBapgvpCjF7aNmZmrPftQlRKpzJwKT6FWN6amDuDoNSel6rSsruGCmbiBKSxT4yIoqb2HFiaFwYJjLhuswKnqWvFTqO1IQX0MwM8XQVFoOai7WMkJNFWVlFLOQikP664xFcsZ1SyJijgaYLmzAAwoGw2JhimKXGy63Zo8j4f9iSA/Pu7H4RBizOpJTLRiMKV4VDVRBfB5mkVERYhBJFcn9CXxqEDaZeOqe2FJz3NJSkUAIg5N26pImf4YeCHf12kMOBAj+jzPv/zyF6GJP/7wIwIFCkBkgBcXOwCdxykwazYAaNuIWBx+omQrdr8cQt/1QJhSRiDH4mNk291K1Ji4uhIRi+nLly8f9ntTJUBVBccYYtd2qh6QwaGEP683m3GaIbuqMgVmXK/602lkYmIuQysi6Pu+mA2UX4qabtabOefTMFeGSChAKbZtmySbmYga2Xa3FTMRKUzcgkUiAUZW8wJFOCIwUQylhDdwCoEoIGPXdYxEgQKHQlCoJOcFb6msyYV6bBXtBEBcOKHnEXCtU1TFz5PdUp6oVWBV1d2qXNHMXRaM1RZHwLqgsQJNsLTjVQ+OUHtlNAB7HoKVNgLcwBXMVa1SkbJIyipZsuQ5pWnOc05zyimbiKpSnkZmA9RIRUoOFDCLJMnZVCTP8+h5XlPesfatDcfD7U93Mtu//Of/9H/1v/lfJst3+/1hdlXK2cGckd2BKCCSueVUvncGxxIWNk8zInBgdytmRCLZ3QnRvLgJWNu3otkBDI0Y3HW73WSVEGNRgxGzFZ+flE1VsiCgub189cIRbt+/CwxTzgzgpteXN5L14fFhmkdHoBDatl+tVqdhIKbTcGzaJsQQQuj7tTvtnx7dDADbJjrA9fXN6TgqKICpORPKnK4vrmKIp+FobqGJKSciart2TiMgFE5oyar56d0PsYtlVsYhbna7x4fH0+nUdW2xlUaoAeBM5GAhsKl1Tbvd7g6HfQgBgRCQAxNTscQaxyGE4OZd38WmmabJzYtyV1VKwksRmlblqSMjE4U6hstakJGiCCXipAa0kCEXMLGIVyusAtXfpIxSl+FsKd8NvIjia4VSNkZxsLTnsgVq61lqGzAA1GcdTQVoyr7ScxNsBu5l53htK+zcnLiZi5kUZyPQrCo1SVpERLKZap05i0jpOrOKqKoXj8rQ0nh4sFlSUs/u4pYkALQhciAIGLrQrOMEeJjy497GA3zx6V/+q3/1P/gf/o/+x//Rf/Q/++WXvxDNh2lMrtOc85xVcuE2xNBIUled51zuthL8mFNGgPosVd09xiaVnAszNchqL168PByP7gYKIobETdvN06wlXN4hMItoYJ7n2UyL2xeHcPP6TWD68P5uOBwJaXG8wlXfmfg0TCbqZiHQmzevDodj28TpNNUIGSIgWK3baUrFdyjGME3zbrPGUiyL5SQ5J+SwWvdt25m5Zk3zHDg4+u5iezoNIppTZiJkv77cjccJzfOUENFdmfD65uru/R0hxCaC2jieurYtbQ8h5iwIxE3YrPpxmtOUzJUIVbyaNAOleXZTBwghoIG5S8omSoxgYKJEVMhOjoW568RMzETs4EAVUCFGjlRSikq9/hHaDgsz58zC8Y/a3jJmda8+oFZb5NIR+PP+eJ4BezlBpKzFM8pUXBkXFc0ZzVzagIUXYefW+fxW/r7cLW5S+TilwJFzH15KpzMm689bTMwtXF7eqOr93VPTN6s+YIOaLWc7PB6Pp9HcmthdX199+eVfff7l559/9dWv/skv37x5oxB31xcbg272Vd8VRoAkabtGxTgEgmJtBe4+nE7b1UqzBCQwOE2nq6trQi6wOkdGwuIj5EZNE3KWq8vL23e3ri4sXdM6eBGPI5IDlOa43CE5Z0mZGzWz1bqbTsM//fWvb3949/B43223TYwi0rTNar19fLzbH/a7i22Jn+naPsZ49+HOoA9NCJFd1AAuL67u7u5++cu/dDOOIcYmT6M7iGoLoKpd18zT3HZt03ZPT/vrqxfg6KBu1DRtnmcVIQocSLOtN5vH/T7lOTYtobsxc2iaJolM49TGuFpv3t/d5y6ttztTMPdQAm/MN5vt7d2HJDkiBYYYOWdDwhDiOB5ySqHvzWS16t+/f7/qXjg4mhf/4FJYElV+AhoAOSEaExsV5wRHcAMr7OjAWb0AU6X4L8sfq0UxLnBFYRgB+HMMUZldubmXXqQUTuXIL8m3RuAKjki2OHcSARUCvpsBUvn6khJtVq22ioPbkqUFDlBMFvEjsfEyU6iYYdFHwcKERQQTczBkNleTRWNVIA6gcP/wdPGiv3l5PUq+Px72+8Px6anvd5+8ffOv/oNff/Grv/j8qy83Ny+yN0aM4m3XTICx7WeDZvLVav3h9vbyxRVwGFQ1p6ZtkRAAS0pK2W+SkiYpWONhypozmIUmhhjdPTCOw7zd7SRL0zYmFtvAFLJoDNHUkIkpiImqEiAymSsSgUNOWTUjoiMxsBp8/tnnv//N797d3r59+6WxA5GK7bbrw+Hx9HRMaWYOTYyIfnV59e03321gbeKKxkQ5y9Xl7vHhHgwQCcyJqCRjEyARA/icUmENdF0sJEMODAjzaZ6nabPZZJGmaYjRRRoOm832eDhdXkUnNIf1enX34cPN9RU4noZxvV6FEA6Hw253ZWCEJUbW1Wy16kFtGE67XSzDVCfEGGHKRVBYGsQQg7mdxmGzWZs5IpmpGkYOJgYOkjIitm1XMXqoaqGcMhEqOjWBAsPCL64h0mXuu6QpojlxGY05kJ0HsWUG6372GnAzB3SkMtooi7eQGo2Awb0sDSk1PSEi+RIfrWbkQFT5keA1+PX8TwGivfbpXgcVCIVOX1lvqkVHhYhqoF4ZEHUgUfArg1JtBwk4zj6Oh4nizcXLf/HX/71/9jd/9fLVJ82mR+6IAjUdARsRGmDn4lnRGtK77//8229+ut8/vt5ejftTdxMnM8dG1doIYM6RmNk0C6RxGO3C3KRv2zSlnFNs1+4WOQzD8OLFzbdff/vpZ2+0xoSBO67Xfcpz33dI6GZt2yAUN9YSFUyuEJowTZOkrKqaJTSsKq9fv0XmH3/84a//5l+KALgC4dtP3v7hT384HI9ep+1uANc318w4DCdALy4pIfBqtT6NQ9bZfYXEbdOYCIUwz/NqteYY0jR1TQfgN9c393cfHLwwEbq2OR5Pl5cXpfQMsWlCcIVu1T7uH25eXDshpFyIPWrKzDKM3rW7i903X3/z6WfujkgsYoRgaqHrue32j4fdxaWIlPwEV8EQmMPxeLps2qyWRI0oZZ2SIJK7FEgRmcgRkYo9vSsgIZgTcsURgAyUIzM1yqzmwAFdq6ik7ASDKkhGQiuuUdU6pzjPgmo1Vl5ufKsaLKp+DOWxHBCLF4HXK6K8b1TuDK8BKFAy8wiX16lshNrcY2kboLqCoIMt6RiFYO/ulTXhBgbVA0rVy14CBPAlaAIRDcLf/Pf/5durX7z+xdUnf/lX274H8iQ2zbMVS/8QlXkSyaYC0GPoAlDXPpyOX//pT3AcXCRLauNOkiQSog1EEsC2rFNHNXPENM3oqqoELFlzyjmlEBtDCLGxNDugqjt48fJXk81mPc1ZRa0JIBabQCG4GwBBmWqYNTES4pznDbioB/M55812c311dXg6upqodk1Q1euba0LOaR5Op/Vmaw4cQr9e9f36dDoUuBgA1Wy73YDB8XharbYxBgNou7aJcbnrUd1FhSGs16vbn2p0MQL0q1XKKTADhtLLFQTx008+/f3vf/cXv/hLM0Wiou0S0aLHPw3jqu1F/Xg6dv262A9zaCSleUpXV5cPd/c5KxN7yhgjIRMQIpnCME6OFLru8ubF/u6xAyQAL2wbVc8aiBxqYDMBuBsjuTuFqLO0bZhEOAQPbBwKlBKpnMeVZY8IAGf7+hLGUlqEAuY7IoI5Epgi0RkWBXAgfEZSy+IsFGVmRPMzvcelQF+GJd3LykVCsKx7WNAo148o/r4w/LUKxN1LDg0s4GzNJi3wgJkh0TJ2qo9BRPS//o//k//J//x/+u/9i7/ut1fe9NRsIUbuYkYTydM0Hp/2qN4S9hFTOr2/v/v93/32D7/9jTf8+HT61T//1c8/v0+oIhPYLJpEVcSImJEZiaDYoNswzVmSaOYAw+lUvCwJnRnbtp2nNM8jARVOBAE2TZfShIQm6gAEyIhpTpLV3HKhAaP3m9XpcMpplpxMpW3btu/79fo0DA+P90g0p9nBm7Zt+26c54fHx2I5UfTyr9+8fnh8dDBX44BNjH2/BqbqAYoQYwSifr06DQMjFuvpeZ7maWxiw1ymeYBEpta23dPTUwhkAItFCl5dXT4+7HOaHCA2AUrC5DQbQojBHSkGDnF/OIhIaStFcpmXX24vAfj9+/fVAcWsCsAQzH3/uC/jTGY2gCymDuoOQFqRljNM70UL5oWU5rWDZY4OQEzZ1KkSgeosuGa2Vz1VKavrN6+ldy3BF68Fq4f1R7Oqc+dqi5KxrOvivYDutESDoQEsicFesq5qi1xRI63I6VkRaa4KWun+lR3tzwM8W3T4JW/PHcpEoeBg4LVJDSqbYThIw4qeRNymnIen/cOYspm7Y2D+/vf/TQa52F2HwF2M3BJxb3lI6l/+8tf/+v/5b9QEQyTJlHII6CrUKGOIAbNAmmZ2dPesHsCJeJ7SeXwyT9K2cb1ZHw6n3S6oSN93hbrSd/04jJvtCpwcIbatiLSxK10Rc2CmJoTTaSxX8jIYt1cvXh6eHm9vf768uXLH4jp6cXExjeM4jKUtdqQsebNZhxjneerXGzBTh6aJgcPhcEgpc2RmkixXFxcfPnz48nOQrE3biOR5Sgi02W2H09g2sfza+1WXUi6ESskaYlD1rmn6fjWLthwM3R1DjOo+T3OMMYRgrqv16v5hf3X5IqXctE2pekVkvd4EJgXNWZOc2rZx8abBnCOlZOJpnlnV3AOim4KTmSHXNezuSFg4QgULQcCSLYJEZh7beBLDptCGCQCs0DwRiGq/iksrUIuQ8/Sr8I8KLaIohdmhOhlU+zLA6vQPAEU3R0CVhENcXM/KlG0JG9Z6+dQ/Q30wgArIWvHNPdNJz0bTy/+W3QrPH3cC9oV4WW+TIhVCCn/889fm0yw6maKTSf7w/udxOpZFY+ie06bt//JXv/zp/gMYOCJkyi6eAPtumsNjyh8Oh+7FNgLQnJGzISCpUeaIeipc4iSqDZghEJf0ITN1D0YM6nbz4uqbr7/+F//+lRebIMRCKMqSCUlEXLmkAmsrABw4ZJSc9e0nn/7dv/tv3U1S8q5lJnF7+eb1dz988/7Dh6+mqXg3TMP85Vdf/rv/+r95fNqLiolCVADbbDYl+TlNc9OHJrKZX1ztPry/m+fBwC4utiJwc3P1/XffM1EGJ4IYYkppHI9tjIxMhKJuZBfbi3c//ciRAYE5gKOZAjYXu8vDcGi6FqkSzmKIwzBc7C6ZSFSuLq9+fnd7Go6r7VbVzTVwJEAR2W53T8en0/G0vtiOp4EjOyISEhMV2ZCbuRcvsLJWyoFnrlgCN0quVNkkFd+s8SoA4OoRQsbiIljzR2rt7YBIrgZlul9qdXUnKJFVZwgHYQkwBDuHV/vZ9b8W9F4oGuCOZbuW9YtYA9V9WcZexAyLfRuVPeS1iT9X/Pj8pGExJPUSXrR8si+y5meKdRFjla9Wo9sPP84iLplNPA3D+NTG5i+/+OUnr9++vnn5ycXN25uXr65e3f68B+/JI3kEZAA0ckVs17vDnMacpnEkMzZAKX2RIQMFLj5nOeeUUpqzqhUj8mmcSkAME7n7uutOh+F4PAC4qGr2EEKgAAaiwsTqvl2vTZyJzR2RJAsAbHfbaU45ZxWVnJlwntOXX3zBzE/7p4K4AYASvHr1MquYeU5ZHRxQHTabTdf14zRyDIxBzU1ts9kch9M8JcmqIki0Wa2TiJe2CnBJtrOUcojsjkyk7uvNKichwHKBq2lo2uz28vXNeBxNfJ4SIiOhmFKJbGoaM2iahkPYH4/jOE7zBOAKwjHkLOtVn3NKmgxMSvIXmLsXNpRoSWUAETU1ES1nGxK6AZZmH5CJTSpzk4hskTiX4qQAmCUlq/p/Fui80N2q5quQK6FStypSWdZbGZCVW6YOpP8RF60+WH1Aq/vRK1MZfLEdLTtKHaCQGBZTe30mwlVmW1Ho1z+e1TpqrovQshAp/NmzCBzBi0ITvLrQItLu9UXoYtw164v28mb1+Wevfvnl54zchmbVrdb9ZtNvU8q7y4sQmZoGKCKwGxVbh5MmCHA4TpLNLPiYMQmqiRVneIsxlui1lGZVEZW2aSSLZFFRVY1NNNGSNTSNo6moKIARAhGFENI0cyQ3X+/WS9XrzBybJoutVht3Oh720zSqGgA0TWz75uLqcjgNohJiDCF0TdN1K8ZweDoO41Bu87Zpmq7jGOfCViLo2wYQduvt6TjcPXxAgBADuK/7NQKO4wRmCECETYyxbY6nIyKIJI5MjE1sTuOpOKo7VFa6qb18+eqb775pu1gmUF3bF2GgqJkbOIYQu75/eLhXsyoozGVSI/16Bcxq/nB35wRJRDSXQF1A0CLs93qO0BKw68tstbBBFQwYa+6EA3EJ1UNzzyoxFE2fV0QSvN4Bdh5o+VKN1Bra62R3kcRUJtsy9j2LJJ8LpooVnRlrC4HuuVp5ruHr9GvRASyeKHUQ9vFzqoV0HYxBbRh8oceVlsorL6I0QOU7UvVopPV2iw03MYbAMTJHALDd1Wa9ald97PsYWt7dXHgACowMGNkIkQCdQtc6tymEk8B+UAp9y01U9yQmUgrBEBgczDSlrKLzlJApi6aUcs6IKKIOOIzjp5+9/en2XYGuy+YueUdlRI4OjETIRWNNRAY+p9T0LccwDpOmlOfZzZiDA11dXLrb8XBgDkhEIRjA7mJt4CqmNT0W1OziYvv4tC/SZCDMSbbbDRE+7Z/AqWidiXG720zTWGJj3NHA1/1qmicgKKFG5hA4EPM4jaV6SCmHGEpZstlcnIaxDv/BKNA8pzIhjTEi03q1mlM+no5znrOIkRk4hzCnabNbm3sSQcQ5ZVGvKSXu1fNZVdEUPJuq2TMcA0DFb+x8wkKJ70UOXMhjUEL7rEYyI9NH5XO1XqDFpH8pjLz4jwNAsby3c+tckZ2lFi/jNl+2TB0sLwNZtLpbSruJy98VOpDD8tkLvFlcVCqi78/T6boDloerHy2qZrfCD9Ly38pvPbfNxARNYGYMxEyBnLgBQokNxkgcsW0iBHCC2DfcRK7EQUCAINZRe7O5RKPDbIOxAACQqeVcaaqhaUII5WZ08JRzG5syHU/z7Igq0jQM7r/8xS8OT8eHh3svCelqhRwKyADuDgjkAGpiJhC4icEdELnr+qf9U4hUuIeBKaf5k7efqvrt+3cABXuk0MSvvvpliPzwcLder4YxNQ3nnL/84os8ToToCIxIhJeXV0zh/ftbd0XkyMGRri6vDocnInSHGJiJmqYNHEVykSm7QWhDbNpcEmcLCcwNELq2m9PMNT4GgYhDmKbJEQCJGUMTLq+uzHwYxpzzMI71sEU319g0DkAEp9MACHPKojqbZDNRm+Z5TNmRigFVLvorrJmkpUiu+QuI548UZk8uKD6TFeWuLvyzcjQvq345tEsxY8uqBHMvpB04x0+cV+B5aVoFIuF5i9QmtfI/q5dWKcaWiqsyIKw4cnk9BtVAHavwHgAADfBsqqXVV2vBoKqc0+uzPhtII7iZavEYDshEULoTL1MmJmCkQByYAyNTYGIGRg9IMVATsQu+CdxAHh/e/+rLz4bHp9uHx9HwlHRIMzInMVU3BUZqQuMOOUua5jTPyATuOaW5nNngxQ697zsweNg/ypTUBBxCYAAA9eKMaaZX1ztRz6qWpYnB3af51PctGMicZZ4Lry7EeHm122w38zCDuSMykZp99dVnIn57e8uA8zg6eGzizfX1w+EpzzMji2m3Xqnrbrs+Ph1zSvM0EoOBX1xuT4cTIbhpYHaAphjxIiKSqXBgEbm43D08PhaHWgpsWDfgZrt92O9L/oWoxBjUPM0JCULT5GwXu23bdsfTQbJIzsM4Olhx/0TApgnukOZcHK5zFhFzRGQWq1QwCqEUHnV2W2AYWg7k6m9VGlWoFoIARMEJ3YDqtNmrqYLXt6UxdnAvtL3yOHWBFqugWmucWWpwRjCtgrZQHrj2EnC23YJnwBTO22Cpgs5n/ZnB727VarcgucV4VGscfHWbcFm0+3ruOUoZVfBUrdWdipKKlLwtCI7szuDsQIBc8v+IiRg5QGg8NBwickReQbPh+NWrt//qn/17/4v/8D+8fHE16/yUTtBSQh1tFJV5TkiASCXxUysnqs7kHFxSmlNyB1Hp+mac01dffbHf7x08hDicTu5VEaE5U0BVu7y63t89qCQgatuWgNzh6ub67sMdkE/zJGJMSISb9cX1zfUf//S7vms1SWxi17UXN68E9PB0Og5HQyxD9a7tGePhsDdVQo6B+27Td6vbD+8Ll668jlc3L54OhxAIiR2NKRBTbIJkmaeJQwH1fHdxMQ6zm2ctFb4xYTZ98erF3d1dDEHcurYTNUcb5ymrqWpoAkZuujZn3++fioQoq6gYogNY07ZqhoRplroB3BypLDIxLee8AwFS7SkRz1BPWTGAUPRZBUWxYrvEqAWOLHAmVHescvoDYAFPzth+eRw/s/CXRLvlO1ERbsPHiS5LrQ9LZ33eimeX3CIVOJf4y3VVh2q+1EbnTbZQ7OpyfvYHqldRmVhr/amqzsZqdgSUPHY1M7q8ughA5Rtp+RbkSi6uRmpYdDECKm6JVdrgq1Xs19Sv4q7ru+32L/75rz/75NMkehpOWXP2PMmsmsEUHFSkbZpC+J5TUsnDOHII4DhN8zSObsqEzOziL6+vHXQYTsenfdM01SORwFTBzUXX6545AqLOeU4ptjHN+fJqp7WmSlmSA4C6k7968YKoOTztu1UP6hiiud1c35jqh9vbvu3HecqiTddsd5uUsqYyVgFR+fSTT7La3f0dcSAKxsVFGE+HY+AyVRFDX23WOWWOcZ6zO3DTdn33dDhQCKXlM3MOwREuLi8e9ntiVlEgaLuuxByoiYMX07vr60twm3JKUx5OQ5qzLrAHATJSVi2eA0klSRZTQFzEJ174MAs5DNyhRrXBR4nUQOal/FAo3HliJXLi0gks8sGlXigrbrFcgGWoViFUWyQZ7meqzbnNrS2ELpsHl6dWlyc8f/FZylIf1s8MaT+rwwopur5vVRxzFso8Uz5huWvKB3Vpzcv2KDztipWZGVkymUYdJhmzJcljkmP2USJCQAgEseWuC13A1oVkyvuHw+3P0/1dPp5++OG7w/v3q0232fWr2LlkcogRJScVLeHWDkhETdN4cXt2mOepbVsgBLN5mkxB1cCNCJtV//b1Z7/9w+9++v7Htutcwc0RIU/J1E0MDdoQ05yzpMCh61vRvL3cAQJGNLecRCVTICd49fKlGZzGkztADKu+EbNf/5N/Ms3zn/70p9AGd+JAovD6zet3tz81DeckgQmJ3n726TDp+4eHeZ7VNIawWm1MfRgHyW5uTWzylNqmYSpWF4ToaZxurq/TnN3M1JHJvcDkuGp7AkLwtu9LRW6uWcTMRZUYTeTy4iqEZh5nMctZhmEy83nOAEilNHV3t5RzGa4vw6AaI1JYY4RQ+mOkGsNQmGXLDMsIi6OVEwIVQbOD13zusoKsZrFh9ZxdVu3SYy7v+wKxwzkLbCmdSjVTWmmoixmKxMoW3AYqUL9cUriAOvCRu+4Z0TpvlrJTFgjVz4+2yB3L5PijDbk82ecO3FWl7NSgw/SXL66///BBoAgb0C2rzPvHfUrJ3LKhqzFYGwITEjqDHZ+evr99vL//sNtc/l/+D//7X//Lf9+Vtv2KIzKzqkm2eZqwbaiQrZpoagbGIaRxbi4iIpDTPE0mGWNULeIYePvm9Z9+//vTanja75EQ1CJ2BqDTHGLrZrvd5ng6EKCqBKI5y2rVqrmJN20zjaNs+ja0yfTtJ58ExsPT04vXbwiDmnGML16+cofT8WQ5n4bh8sVukvzq9cs/PtzP09SsexMFoqvrV8Tw4e5uGMfVeiXmK4opyTCM65zWq81pmImIEd20CY2KIrM6AEJs25RzEzrwAnSWQtI3lxfJjBxCjF3XEfJpOG0vdsCcc+bYdDH06/5wysfDYb3eDMNIHLsYTETNCFlkdnQM5AAiwhwLcbM4RxGiozGSuZ4lJmAF769mAg5IhGqCJX2BiTjkgpmYl5ByL/dG9c4HQFCzOsHyJfgNsZKu3YCp4BOVIleajwX4B6/24F6bXSuaY6w4EtZPq5O0BTatRP+6fc7z5+ee5FxAQe1YcGHDLfUWgFfyBJ9NtmqXXCorJKTwf/3f/R9v73+/ijtlJHVRc1EKwA0iIzhI0UmoigqKgRO4NTE03Cjhz9/8OOXT07/5r0JL49MJL9dt3+zlKTCZek6ZI2LXr1arp/1BRYEpiwSObkrBT8OYs3CIABCagITtqr24vhqn6btvv766vmnb1t2YwuR+2TZmGmIExDlNTbsDBEIExvVum1X60ExzGschXjRd25Hiy09ef/vtN1/+4pfUxsiRY3Dxq5vr2/e3CKBJirju6upmSrOquKMhrNfd8WF4/frV4fHwcPew3a4v1mvKnt33h+OrEOecYwzg2nbtfJpVc2x6qr91pMCn04kvGqJoi90mUFiv1nOa+25FDk3fdH233z+ehtMmBHcMBLPDxeXlh7sPCaRpGwxtlhQCIiGqAjkRilk5yIp3ooqCo6mW156QlvEQIBMR1SqjVNVUqZOFJc9Nk9WKxMzMS4JNXZO+AJ0Odd0Cn5dXXeFl6lyuibMnORgAQfF6qpNpLL1cedIABdIAInOvKrTlDYvXRJUC4PONsPzxeYUvd4GVvVTLPqwz4OcBARhiMWxwrx3NAvO6CVj45k//AC3LuDcIfYjEFAPHyECF0o1MYK7AoccGiz6XORIB+DTM/+o/+OsgsD8cttvV/Q+32UzMCGAWiaoIjqTmtt5u9g8HJAT0otHkGALSPDxOw6ntGhOIIZKHQP75J2/+9je/ub/7cPH+/V//zd+M09C1LTFmk+hI5E2Maq4qMQR3YCQmAPXYNOM0zXNyESO0DL/+9V/9m//y/2MurgAMSAEYf/2rv/w3/9WH4/GpzOCMgAAur67e3d7+YrcxBUBr2/azt29/99vfno6HJjbiCkjZ7PE0igMzlYs8xjjYEGNTDiIRHadptW7nafaVQqAQis8zzZp3F5vxOPXNChxCCDFGMysz8m69MnMfZbNauTugJdWGeJhSYCrr3qQaKuQ5z7nyCNxAXWMTnVBEQmieywlczJ7NKznH0cCLDx5VuoQxBai8BXetiZ1Q/VGKcgYKmAjFIBeej2NYoNJl6ZeHrrbpQOWcLf4a4G6FjFnYP4V6tBwatQCrf/Klc/ZlU8CyD+ruWP7e65d4vRzqZKMARoiobgSIfuZagC2EU0I01UAR267vWt5utwQI5rHhwORogA6GAsqBwY3cCalpmoJ+gEJgdkCZ0ouua7pmF+NwPIUmMBEQm4K4Aouo9qtVjFGyxIBZFYteAYADnk7Hi6srMQ0qxICMrz/79M9ffz1N85+/+/Yv/8lf9Zt+niZHXHuvRgbGgWWaJUuIHAKLyMvXrx8e9jevX212u8fbn1/c3DA3btOnrz9r2/7w9HTZ9OgtgRPhp198OfwX//nxeNhur9VgtWpPh/HNm5fv331A4knzZtWM4/A3/+yvf/O3f//1t9+++eVnX1xuj+PQvrh8dzh5CPOcdpt1mub1qt/f702EYwAEJjCHFy9u3r+7e/n6DTAhUVkErrBeb3779//w5tO3oiqTtN0qq4pkJlYtlB6jyLFtp2kaxrHZrCLHKU1d1xaApgLkAOZGSFIm7gYKFkswOWLpEgt1HgHVHNEcnJhqJYEQkM3cDEWMgRzQa2pbgXxKBrPDIt9yh8qqcQAuP1Hl9yMVrxkELJ4t6FXMXjJwDQkXT9qFjbo4guOSBAe+gLalTfGl8T5/4VLLL135GdvyuidgwVk/KoLqJlz6hQq5lm+pnt3AkT559faLN2/fvLppQmTHtmti2wAXhTyX1wOaBilQ0zZ9z7F1DnNyMU+m5h7agBGmlLwNGGMWaPs1AgODueeUJaXYhtg2AKiiKjLPkyMAeWAeh0GlUCCRiE08J/n8y6/Qfc7pm2++Pg0nRZ+naZynlBNiwWXZ3dsQi2v3er0Ska5tN113eBqG4ZDT7MjNqu3a5u7DXcBQFGSIuN5sVpv199/9EBBzSu4QkK9vXj88PIKaZ805I8B2sw4YDofT/Ye703i4Pz7x5fbH/dP+NIGoaUb0btUWB0IClJyJGRy2281wHIggJ0ECMwscOHAgChygupZhEwIAgJVo8eLd6WbQd52pF3OKJCKqqRJH3JepjzmUc0Sy2FKu+BLhu6wN86Wwto9WBTgwIBmCsTlo2VoO6IYAdMZwikGtGZqTYwlRR6DCKDUH1cpDAycEYnA0JTcCx9JUm5WqnCoNpzJKn5cvwlKaeIVsCoOoNrhnzHNZ589DiNo01I1Y+UlnqcJ5rVuJ7Vi+ts4YzFQkFwIRffrZq/UqBgyrLl7s1ut1xwFDw00X2i7GJnJkIuSGS1hvGTRQKEUczFlOczpM8zHPhzk/zOmbd/frq1dZSrKLidicEyKuVqtAwd2zaGGjmcl63e+fHtM8ZhV3M4IYY4y8u7ncXl2+uLz6/rtvf/7+hzROIjqNo5mBCwETkopOKVGAeZqvbm5u372XLO2qPw6n0+kUiTmEpu1fvH7707ufVHOaZkLs2pjNvvziiw8/vwuBskKMzE1gbkK32j/tnZw4xAYvdhc31zen4fTHb/4sgMT888PDKeen0yGLlgM5hNA2jbupaQihxNd3Xfuw3xMTImNpGsEQvem7w/EYYyw0xr5b5STTfEIAV1PTVd+Z5IuLC2aSlOd5dvBidKDuIpqzlFDFcg+IaS60d9VCyPTFfqoU8QCLiwi4u1bOMVhRL5Yxjz4jOBXNRwCso1uHkqVea+aCXWKdIy1z4hoKUCdTVkt+U8CFu79AqAUtqkbQvsyBy51lC6PfF5RzUc1/NJTz+hPBMlU4Y0XLVO3c69aH1jOtTkVNpfzP6vxEhDRnN2m7GJqIkZwIm4htA7HxEJ0ZmA1R1MSBmIGKKgqsqI6XG2ae89NxkKxPh6MAxKYp+9RUc86qrmDr7TZQawazZFFBsLYJxLQ/7NE0a1IVUzEnz/DLzz9/8/aTx7uHv/+73/z0w4+P93eadZrnyslEZCYvyl2irm13V5dONJzGl29efPPnb80hSZry/OrNC1Oc55EDJxGiaDn/+te/evf+FhFc6+2uhNc3V8fTCR01zQAI7K9uXhDgw/7pz3/4Y9N2337zvand3r4zN5kTA0Dg0DWIBFoKXzfHQMFMj4djsXotLAlVlyyIlkUlZyLGgG3XplwNiwIzIzKHVd+XLD2dU5omEc1i05QrwWGpRMxdC1/OAYphC5TZ7lKWL28igpUZUVBSADA0V3NELCHY1elwaTDPS3ThTwOa03m1fXQ4e2HqAyzxGeDlKsKq5XWsS8QX8B+9epS7GbpVTHX57/NaP1Mcnuse9+qwaJXlaaKmzzEUxfSwLPkKnJq7FTcvl3+cNWbmZoQBYtdUxnjBfMvPsTwjROBqCYCqoGKSxMSzWRIdU87uDiWSiBSVIk/j0LUtqAYmNx9PYzVKIGqaGIhPT4OZqWrsGlF7fHgsjJpxnMyAHNouNpv1q1evgeP+/nD/4dFM333/DsynKRW3V+YwTxMSlvig9Wo9T7No+uzTT29//lBgPSe4urwxyNM8zGlGREQPTVz1O+b2cDxQDK7ATBzjm88/f3d727S9uneRY4xffP4ZI2TE9w+nv/37348HYY8Pd4/D8QjqATEAN22rokys2cgRXImZIs9zUteFMVzBu6Q2jRMxYWAg3my3h+PRC/ShSoCRkQOt1mumMju3YZpTzupetpC5q6o5IJG5ieuZGkBEslgFAkLRoZfTveRNladhJZ8KAcADh2KfW5GW0jxTqS0AoDj/e8FZz+VKpUB7Xd5QYJ0yE8ACN/mZHFTQecRlOgvLRA7PtX/9ZpWttIwblnHB4grnfka0lrdaN9WRV+VjLENfq8oxMLfFeEXNRTVLOS1cVAkBBaohhVcPX3dRNyNHAgAxNGcK7qiqc85JZErznGYpN7JqLv5zRIrEMeY0d01DUPojmLOlOYcYQohtbNu2GyZRdcl2Oo3rfj0NWeYM5jlnIEQOhKEJ/Xqz/ezNJ8Dw7vb2cX94fNw/PR6meR7nkULZAzHPiZER6dWbN8MwoJFknbIMp1HmaRrmzWbbt+v9496Lg5p7VujaHpCPw0RmnrWNrTE37erp8ZSniQzBXXP65NVrdpxH/fq797/97XfmNExyPMg8pXQcAi3agBDdNIbAzEwhT/nTt2+Ox5PkJDkX3gECEsJ63Y/FvR0xe97uLlLKZiZZCABdmNnUV30PACLiZgYwZUk5S5FZLHPPQkOrIvWlwi+i24Ii+oLWlxXvDoUycxaai9bxWb3Ey/Hgle9QdxEutvsL4lIW3nMLuqDtNbscFr0kVn5zGZYtsA1iaX/hLNyp+OkyLqutxtIgLNdRLYQWTcBiCFrI2OX2grpP0BxEVMw0Swl99SWHxktuDRhY0U44KQIzOyEsLoVlXrvQiADdAb2w77TcilgUGXVTqy8CjWKCvFkJYogNUonfppzl6XBa9Stw44jb9caSzsMMGJgjh/Z4Op0OoyeTlDUlcgfgNsbQdm+++qrvtsdh/voPf1bIH37+2c2GYQJ0cRXJxc0KkdfrddM2k8mcNUn6h9/8hinGtmHGq6urhw8P8ziknNMwIAEgXd68eHd7ayaSZ0dn5q5fn3K+/XD/cHenmlWmftV8+ub1PObH04nX/TzraZpvH55m0eNpUMlo1lBgjkyhvCjM5IivXrw47A+EpKYFUnQz5mhgKc05JWRq2xaJjOBwGpFAUrISpWoWmyDuBqju5QIQWzzEl9S6gtCU06+Q28sLAYQFd6rDJj/DoLCoEKGcyVZ2JkLZMxVVrAwcOIOLcC5Dnk/tIkIvT+G80CsttLxVlQ0+n9hlEde6fgHuz+TkZ3vn5ZPKf+r21PrOUh6dW4JScJ33RW18K5RaFDCLtEbOxnNaJsHg7uTo2UoyU2mO3N2rE5KBa/UqdSgboDTTC6vjfBCUAy4QBvYQsqqDh6YlYnNXx8PTKYQwjyOUiNymydMMhlm1CdHVnw5PQGhuU5rVlImaticIr1+/uX71SsRPaR6HdHd///72J7V8nIYyAklzKsYabdu5QZ4kA6w2u2+//4HBIYubvbx5tX86IpDlZJa7Vfc4HF+/ff3h3V2DqJpdJac85dRt1t/99DMwnR6PTND1zVeffaYmSCyOGc0ApiTv3j848ZTERBkB3ZmYKbhZOT761er+/l6LW6U5AIQQcs6vXr46noau680sqXX9yhGTZBPnEhWhXoqYYhGlZkBhzqXqqcDDsm68OJZixQsL51HPkOECrgNAqZeWurzAGFRBdS8z5I/5/stq9aV0r9tjKeat8GoW4UChURRR1vlLixbAF0ViBaDKNfUsknmeItQVtaD69Tl8/G6tipa7qF4u9Yd9xkeXGt+XMXC5OyqnankAgHIfarHMcAS0GjhWJfdoBqZgJUtn4XsTIlZgoxTxtf82d3XQWvXNrkbmDNQxx+Cup9PJTDAgorRN6CLP4yDggNz0q+PpOAzTcBwQIQ+jZQEKiLhe9xn0r/7pr8Utq/54+zMF/v7r74fjKc+lY1YwsCxmHstbFwnw8vryd3/8IxM0TUC0y8sbh/B4f0dogTmniYl3V5d/+PZrwTTMU3ZhgjlNn33x1f4wfHh/l20KAQjyp5+8Ccaax6fjU1kLSdJP9w8JfBZH91AmRQRIwBzKebjqujnNTGgGolLZmQB9v7acC0LTNSEE6lerOafTOJYMIkDIknNOSGQAOWURcQBRFfWsJqZiCgDmJlkMHAhDjBUQ+ZjzfCbDVPrNEk+KRRaIZRhUmwire+Z5dZa6rYJBlcBzRhm9rHgt1VI5dCucWYhJ4LDY6FZkquynpXQ5/6HW62dfxdpdlP1R7otlf9QWxc/7ul4EWNHVqvupHYEu6sy6Y+yMRTm6qTkYEZGoqoNq6XTc0XxpgxzcQaXGHNSfwso7gI5YA0OKLA6LkTNk8Ow2pCl0jYKHPgKSqRyPjyGiiMSOm6aIfUEQpywcmvv9g5iWymzOExI6McTQdet+vf7y88/M/Hgc3t1/SKq3P/18Gk7DaZpzKkA7ByakGJrddsdt6LutA//08/c6jWrebTbO8Xg45XGe58HBTzmF2E1J7j7cm/k8JyDP0/z2zdvbdx/GIe8fHyQnI+v6brvdpjlPw2huyU1c3909Po3jnMTdI9WmLzA7VOQ9MK9X65SzqyAU6iVQoL5rCyzNQCK6Xq8AEAmnNIvkrJJV5iziBoTMBAhFWVOyAAGh0uAQ3EFMwKGQr4gQEM285CBBlVcVoJwqUl5RnDpm8hLj4LZQdRY1Oy7GDnWe7Hge1dbXuy5Mc1cTX96vchasXUH5hnbuXJfzu8qaCyb0j/5dDujzYlu64eX9Wsl7RU0rM9SWvWUV6C/S5oJTWqmM1L0k0VjJCgBHJJFcVFRWPdfKbVlagXKdLIUfAlChRoAvsK8Tlpw1JIDFs40RaXbZD8dsgBxj08RIBrI/PDEGdSOC2MSUEiACRScMsXl6OJyGIxMCwzAcc5q9DdS0fWzM9Vf/9K+6thWCuw+PU86HYbj/8P54eHLzeRZCNLEmhMJz3G133Xodm/iHP/8RUdQ9m17cXB4PR1NxdXAlgBi7pl/d3j2KG8aQs8QmEhBT8+c/f6tO3ERwa5r2zcvXZjbPEyEjkJpNYh8enkQtT3MTCZkR0BGXCEbnEN1sniYVEyvG6IQATWzmaSrRXV1sA1LXr7NoVsnmU5Y5J0BUMHN0Q9FidWgVDKmiESgpsWfGY4jBAcyMqJp7Lpi+uTvzYlVSYtlq9wngQFxEdg4OgGfj2wpgLufucyl1hnDIz1ItcK2XAhYMRs/l17KpykMt5Q6U9tHKVKDuy7pBix+Kw3LYF1F+XW/lV1D/6+5nEfB5kFC7gtpHINAyEzkPQ55p0iJaPL9qaVUuC6xWFFglFYuHHIIT2CKxrA/xMSsVsEjtvfTHD09PKgKOkWnVrdBxOqWUpYlNzomYCoDjaoG4b9s5pSGlcc7KPs6SLSmiQhEs8eX24qu/+FWEZpjn25/fG+D+8bDf7x/299kkS3ZXIu5iqymL2Hq97VerP/7ujwQw7Pce4fXrT4YhHw8ns+wiCMwhbLa7P/z5++MwTdPoMscmDKbri+37+8Pdcbo/DoruPv/FV585BCQAM1Md5nTK8s0Ptwpukhg8EINjETKXHlHNLi53qpZTctWSP0ccQowiauAq2d0jhYikmo/D8HQ6JVUD8sDq6IAKrqpnHWO54athlKOaFQSzMIQQERzNzdXNXUTrLaFSbufzCQxIpfqozfBSL8HzCLVWTdV54dwC+1J8IFiphEtTQfWc9PMlsZzRXg0mHAAWjv95ZyxYEp6/tk63noHO+pGlPIKlGFv+2tyLBWKtnszMrAKv5Vks2GupnM5DNwBHV8kz2UfL3aHEaFguJZKDAphjnYeogzsBnBWmy4aGenqUV0GUOabkhmTmJr7erNu+f9wPSQwohNDOcw59N6eRGdHl5urlPOXvvv8hOXDoHP10Gi2DZmiaZn25VcKbV69319eEcdT8x6+/hkgPT/vH/eFwOqmYO7g6c8MYwOHFmzeff/6L23d3f/e3f7e+vDgNw/biQqj98PAkjlnybtXknG5ev/nj19/f74/zMDQBQVPb968/+/z++PTvfvsNdrs0J5nnlzeXZf0UrEWyjFm///CYCE9jsqwRMFBYTEshhiBZXry4uf9wj4zTnHQZWsUQ2tigExEHRgS72G01a07zKHmSPOWsi+sCICqALrAfnPFCBHBDAFHFqrD1UoUz8Zkc8Nwp+nLCQ/XwKeWMVm5CrZRgAXWWRsI/qrbrvXEujGrFDyX9pS74BRc9v1NOyXok19lSxSyrJNM/PlU/7gQ+WtAf/ySLzrIe/CWYbCmEbLGDK/vCzVRUn+cJUDe5gpUxsGqiZQeWa4fBWYvSGNCBENirBUfplh3OLBFALL5juAhjqXDEIYkoN6cZ2m6rAhhj063Rw/Fpklk5tjH2p9PUdd349MTMIYb1evtw9zQlmUW69cX+w2M+DQFRzSl2MXZ903/66VtHbJvu8TD8/O5ulHS/3+8Px8PwJJpzSqoZA626DWT54pNPmubyz9/dzqOISMuRm/bhmIdRQI1c+67ZXV5PAu8fHvN0lPEpMKqkVy9fIMcPD8efbvfTOBHztu8u15cYeL1ad00TQxDxx2m+O5yc21mciAyLq0KhARsSdW07zalU26aCYOgQmyZnMajW1uDexogAIoohzlmmIpXWYlRYDxaDcyK6YbGaNFOzQOwOZdoIBrj4t3ld71goEuWORkSgpdaoowOsCKMZEfsSTgoLT8LPyxwW2K8e7wZqKEpmDCV2rAbxAsAiP3w+70uxf25ybZmiIS7TtRJOUzb4uUYq7yzlT71cliHagk1VvgcUfmedwi2U05KcYC5qolVACef+BmG9XtHzNziDBIVSUnBPs+LdBb64tpcLFaFKMJcuAatVBDIQM82k98PxMKfJcJhTiBz7ePfhgyFO09yvN0Z8PB26VTvPE8W4Wq9u378fxgzUmXNOMj7eB1MOzBTWXU9t3O2uPv/ss/E0MeLd/rHQLu7v7kTT/uFDzlMIMQBpngnk1cVNu7n4//3uu6NCiCHl05uXLw/Hcf90cre244Dy+atPAPAffvPbPkYZR0szm91cXnR9GMfxH/7+dxzAIXuefvXVlzrkMhQiB1Edc74/jaecxlncgAEAgIiJuLShm812PI2OXrysSxmCak0bS0oPMYbATKWSAHVX9znnEv20YPFULRSQzgsCyyRWlZAYkZEr7ex82ZfFXQqbOg0oy3GpNsrAlgiZzIyosH/A3eoGqX2qOZaW8gzXSGkrEQzRwA3V0I3KlvFKmK4g7FIMlXVfR00OtOA5z0c71vtieSs3XllljqXmgMqGLWVQnebV1e9wDo0svXjRm9bbo6o7KxgKjuRILpLXq56Wp1cwVMNifVZhowqrLffvcggQFqdyJDiXQuUvERGZKESKzSEPT8NpnGdRt4Bt16jaNE5iGjh0q1XOWVNiDkp2eXnVNv333387DNOYpN+unx4/yHQ0zW0TmOImdgz46tWr7foCiYdTejyepjTfvvvwsD+MMg3jYZyOHIinudHcNrRaXyZtD8dx2O/zdLy+uQrN+uHuiI42j/2qa9t21W/2+9EGjRCb2JLBKtD15SWIvfv5dtXtxiQpp7cvbxoIbGY5M2IgRqKH/ckwnuYsJoQOKgUyjk3DITR9+3h4CjFmVSQAU3RXhPV2k3IOVBAFYKRQKMVZpUperXj7lHKgCMztozXopTfwCsKyQWSmegqiLy0oOoAamFcPTndQQbOlpGc3RAqEzIAuCku9VFGaWi5r/cjSTBZGPQCAITmW+CZwdMNa+pSTVMvCO5N9cLkZisMvmNYhU11+BTc6i2zqNBtq81CwHDfXKpQxL+lj+tGWKaZw5XZ0O09/ddn+1cMUNKukzAFevHxRg2nP36yiq8UO6dkKdTnpS5FbYO8FIa5DCPN69liJ8XBDXG372LVZ8iwCBKFpj+OYVJ0gYEAI86xejNZWbWzC3fu7w/EATMzs5ofDY0CCLCH4quubNjZd9/rt68K6fHw4OIbjPH/300/qdBwmSTIPIzE5mlq+vLzCQL/7wz8Qo0Vz18uL3f3DE1ODyA3jRd+t+k1S+oc/fWseVKEPFNEvNjsx/PHD/X6aBXl2W6+3fReYPMYYArmqqt4dnmaXWbNV02NHB1NnIgoYKXZN5+iapRCNkcBS3m42Liaq6O6ujNDEYCLzPJnmnMWkfDaj1xGyV5m6e9VYurszcyBEr0N8JwAuUx0kYgIkAEJkL4duuREcXE2ViBEJOQCREywtqj13n3YuN5YSwZeX2uHcVpzNq8rd5Mu8o3YmVS3myxJa5rSmSySeqZwHV3U1VbBz6WLguQcoF+Pi2VKVcSUqr8JWtSTx5agu9UpBZhHM1dnMlcAd6erquu/XJcWAsN7TUM4bpFLiVHXN0kacn+ryM5W4mWJITwvORtUNwYHEvNu1TpYky9Iml8iwGAIYuioBmUPbrna73X7/mNM0HU+KDsjDcJymkwckjhTo4vKCgF68vL65uokUx2ne3z8A+MP98aeffz7m8SjDqMMsIwUw1Nevrld9d//+Pk2Tp+wsLy52WejpeCJwJheZvvrkDRn86esfxklcXUG6ptleXAGzQnP74TGrTC6hC5vLrRoSMxNHZnfYH4fkPmpSy4hOgARExEAEwMTYdM00zCqScwLV8mtrmmYaR1XjEKRMMJgBXHIyKVZm5cAsLxqAAjkQMCADkoAnMHVijpEjAwVmcDSA5KaIusw5QQTFsG4e4wJRO9TJaGHzE39sN1gvgcVEFqCSINFL8HAhMdUyDHBZlRW3sY/7SX/GjeqSXiplosWla4lxeUZK/SyRr120n6fX4O5Y7iYHAPwI1/JlPrDs4OU7Ln1zBZIUTN0VONCqb7abXdeuycyWIt8BwNFqr1+9Awyqj+LyU+NCJi+AQgUGyhwBvWp8kBxV82QJI2GL4JpVs0sWdYZsKYYA5klURJoYAPTq4jpgeP/uNpsjoGjOeZ7mSWSGaBQ5BO63fYjh5asXDXMbwuHpdDoeD8NpnKcP9/fH4SSoxzRknSHAxc3ldtcfj8fHpyME5GCbbaest4d9QjaC1Sq8eXO96ug0jt/99C6pNZEJ84sXLxzZPX/7889SMjvIr663RbZCSKCG5ofTmCxnqXczkAEZMnEgBwPktm32T/sYg6gWqyw3iTGWiDhHEJFAzByQQxYTEXcoWAJUkNuxplOYgyku9n5lGFVs5ZDFtMhN1ctE08DR1JCQiAFrOWxopaAHhEKkNihOQvTcydXDe5GtnDHIZXdAHWD5GZgpzag5lNq+6lOw9rVY6EcLeATn1VkwoQo81YT60mx65SY/o6heMX+HZb5gVTdmS+lSoH+ti9aK8GCpamzBpkCBbM7p4uKqazoHoBDKDKXMzeokbYG+yuZf+lxYGuDnsQotc4NlNOEFVzBESlmGaUwqyMVx3s01axYVAwV2QBZRd5AsTdciQt+t7u4f55RnNWc+ncZ5PipKthxaQPLtqmuaeHN9udtdqBgRnU7jnOz+8Xgap4f90yRJEMc5AUBo8fVnr2eBx6cBAQA0ROw33c8fHhyAAMzly198Os+TpPzt9z8gR0czxtV23TbMhD/8eDvN2dXB5cXVDSA5uy/uZcM4T1mmNCWZS/S3gyOjO3AI8zxvt7vD4cgcCqEKzMtynueUVRgZCKc8UiB1UzVArGG5DupmSytWwPhS6pZmDpmK0mNBPF1Eymtc9hkiFBAQCQsvDQHAUKV4L5eTtSgTwcTpfHmfz76zfwmcf2RbGsIzPurL2V2AHbM6UDJzL/XKcko/VxC2cBSWB1yQq2dZy7JVvDTntbx8/m7n2cFHjfTS+tvSBz9X7gam2VSdkYiBGa+vL7qum8ZEpQQ7j+MWdKlefcv38PpLRESuV8HHn3+etAEiEHlxWEIa53QYhhCbyGyqQJ5SRvBiR8eB5impFGMCvbm6QcLhdBzGaZ6VYlSz4XCynNDNVJsmNG3su3a1WX3yySeETMTjnO73e+Kw3x8fH/bzlNwgz0rMiPbZm09d9d3dPVLTNC1C3q1X++MpubtD0/Cmb26uL8Y5f/vzB+EOgMz15vJFF3u0vH86HQ5jCBFSer3bdCHUdYoERLPCaZocQbXq65JmMXX3JkYTu76+PD49dW2Tc17OvkJnsGLtpuZYrMDdsoh6xdzUTVS9qmMLdefsVIWGVQzg4Eg1wWuhs9Ur2r1YozhVM4dCWCxnmxMVz/2aolUXwFLVl0FCXYVnhgDA0vMtxzvUTtsBllyuWijXEsaW2nnpFc/LvD5i+crzRKmWfQCLpmfZDef2dJG5lf76WbfgC/ZbQsPqo9Uy3R0NyrBeRdXo5etXsW0RKYuU5q0Spyrzo/yL1cmxtv+w3HnnCm35KrVKMyr7E8yZqIBkWSxPc0RedR0TSxaxnOYUCI2Mm+gAWbOqIHG37UJoEPD9h3f74cQhMsU0jtPhSOAUMMTQdu16vW4xvnn58tXbt9k4KWTHH9/dxdg83B+Oh6OKELiluY3x8uWLpuv3jydJ6pL7vrnYXiiEMQs4gAoFvLl5OY3pNOXbuztxUqJmFV+9eU3E05x/vHugtkOw7aa92O3AMYMLoxAnyYfjUDytwEsEFTkAMJdBV9d1w5SIGYlFFAHUgYjFLKUEDqrKMXgVG6l75Zz7WcWLqMs5XQCYYscs1eAecWFcl98/lsPbSmjjM4uhMu8Xc5GyVkvNWqCg8q3NXJYJ7nnhI9Qh0PmhygfLOit+QTXvtAJMtpQ0sKxmx6Vc8jKwrlimlW9b/whuYAqlpKzYTp1qeWU6lB66Xkqg52IJlhoesNLVlq1Wl7WZkyErbTfbi91LnR2Q5nkmd0cCK/7xuFxbtOwGBMMK29Yxx1IJlqbofAxU7K2S5M5kJk/jCGYNh64JCKYpT/PkyIQEROo+TJMDZlUKYbfbrbp+Op5OwwjcILDPNg+jioJq7GJo2s1604Q2hubNyzfXFxdX2wtNeX9/0GzHp9P+4eBmU5qRKCA0TfPqzZv9/jBMY2w7QrzeXc0qpyFzbNpVExl++cUXADgP09/+7je27ie1brX68rO3HQMQ/vm7W409Ydht1l+9/rQRD0BuaEBzzk+PjxhR8kSEXji0bgBerErMkQiPx5OBapaSd51VCWk4TSoikgkQig92PdgWNHKZGC2EL3MHW+BnUxVVBywHuYMhIyCZu6Nrya7GWjidJ7u+jHvLOY3LonavWUXntnc5+iv+XiH+srorRlSqEqyunA7n8sYc6ki3DpaqgrlcOIaVe6rLfLgMQNQX9N5NvfD/9Cx/LC3TUo8t/tRLf1DIQXiWMta2vHgEuLsJmBugu7q9eflJx507iYGIUhlWM7GXRIulaShvWAdccB6gAMKzoWm5kpZ/noEyA0cXdEUv0S2Stes6sJJyl3KaiJBDMEQBV7fi73Fzc8UOmNJwf+ci3WZ9mOb948HMDGCaM8aGun672zYU31y9fLm7enFxcdl08zzefng/Sf79n7+fzEaTOae2a2IMb1+8YrQ/f/t1yzwN49vP3lLofnj/PjYtqjvozeV22zSI8ruv//g42ZyALP3iy0+2bRvBh2n87ocfLICa/vKzVytiVDEwRxS1p8MeGcc5GQIAgRMQ5STEQQH6vg+xnXJqYztOiYhEJIaQJTu5mmdVMQEq0RXuC7Zd1mWdBy3InlkVfhAY5Fx8rMS9nFAi5mroTlCCEwFtGdY4lOSLWsUguLmI0uIp56ZYpewOvvAd8aNZ1UI1KBWF1zPewZckvfIsvExIl4N+mR0txXKtws5Et1o1g9Vj2pe++QxHlWw88GWn1sUJi5E0LCBs3WJublqHGKrlwlBUhJK8pV+8+azvVsixKG8dgYi4lOyFT1sh2JpwWfVgiAjoxWmyTuaeyzOnpWQsn4UApXxCQlcTQHMUNzWLsXGR6TiRmltuArSMmBKKdkQ6jhfr/mq1adymw9NhHrUhauJplPfv7hkayMZmgNJv2n4T+g29/fRmt2qury4i8mFOkfvTft6/P3rm+Ukxe+/25ury5Wpz+HA/PQ1N2x0f7z57eeWDTqfkxia6WsUXV5sNeH4ajg8DZRwf79Yxv9rtOiRM5mMaHg+etW/x4rJHZmduKEbF6Wk4PR4hhHGYkWtEA8do2WJAdLi52M3D5K4MkCUz8zQeN31vWcd5BA7JHBmtON4X/AzQCQ0rAl7INGpWjmhxV0Qp+BBxeY0QsSD7DmiAQKjFGmgxZy6rv0J6wA4QmNRMAb08cp38IOD59FuQ9HMPsGCAz93nUtUvHTPYR4CPn5cQLi31+aGf+Z/uXlBcq6YW8LGLxEIyKCcwLgVPldY/oy5VOQzLhNndyZFAQJ1cLalrCP2L61fBAEwJEQODA6nqsq/Kr4DwDNiWw+OMBVT2IZ17ooIR6dLslDGflkNCjRzNfUo6aKZ1N+fc9f1wUh0UXSQnVl21jc+qp7lDiiGgw83uUoUg2+Pj/eQ2E6Q5Hw/D3e2HddfM8zEyJJ+2L3ZN316/vP7s00+2u93F9up4zMMoaO3vf/OHq/XF4/6gw7F1uV43by8vx/v09Dg1iNjkHQe/O7K45pTntN5t1uvtlpt29p//8P2KQp4GG6ZfvP0EJuhmhkPW2YfDqd+FzeUlcm8eW2jxqCHTww/vXTlnyaIMYKoqyUA5Rg4U2nY6Tut2czhNTJzS2MaoU4qM5Dgeh9i3Wc4OCI4AyEsUKqJbDc0udbepoDuboyq6hUCGrtXTteYqErq5EYF5ZbmfkRRzjYFVBMiTZGICcDMriaVIBUKCet4t3Z5VjGRpAmun6OdlWtbnopWqq79KcSsAb0snfCaf1sZcl5SvomYsnUS9CKodi9ffTpmLYy3hSt/tZlhJHMuwoBoDF8WQMSABxICS0+tXL0PbqInkrKopZTMhJwpM4oJMQO4MjlB+p1YmXbwIBAiBwNCd0Gjp2JGKB3yhM1kZwANojcdy1TxIphjDuunaSDnn8XR63LOJwdxHaAnldMrzuG66SHh9sW2zo/n+p1uZjhfXl49PtzrP0/5uGvcNz8xT4JmDXr7YNh2//PTNm1cvtv16ZZzSOA7z+PD0dP9Ep5McjxGmBo6fXl9eWdD9uH96XLF/ttnl+5/T/imIEORtx2/W8aKHt13/+PU3T8OesuTh4eZqc900Hcjp/gPnLJ4Y/M3rF5GwF2rAG4d0HEzh+OE9t5iGR45gNqELUo4hb1bcGsE0yTw3DpYzk7pOIWhAnaYTRBBJgcFMyqSMuECQ1UbTAUQNGZGwsv9NzBUQwQ0JtSCF7IbqVNKAHOqVTlykBeDlhSOmLIKRTD0AcFhy1lULXoLAvqQrLWu2ovZmVjFx9/PStvP7tWCuONJSLz2vy7OkwewZMvQlvOt53CuKWKt+rZi+Fx1LXd51iFyNf2pB5M9k0+JZJFbuTDQzyzrPdtGuX9y8ZnRTdTFEmIcTIVFWTqoNBp0yGqA6iIJWdTa6uX70jnoJSqd6Zxt6PT+KTPIcxUTooBrI5imZ2DiM3eV28+IqtP3P7x9ubx9ltn61a2iVTzplReIOuW/6btVtNrvbn25/+vHnGELD0SW+++6ndx9O4E2EHWp/cfGatOljt1ntWuJXn795+/ZNmvK3f/pm2N/dH8cffv5+zuTcMHQvPv9sd3X9/v74zd373fVVGn11sc24+uHxPhk1/UUM3V/+9b84nPjhw9PD4QHRU4KbL75wCBzWU/Ifvv3ZwLcXN87Nm0/fttAlyePhMKc8mY6z+GqzWvUyh4Zxzb0MEDAG6rq+X8d+zo5gnoGQKFMbQsu9TBaRIYELdKHxbOAQiTwZu+uUXSQwohqpBgRQJ3PPoiJNIFTngA0TJGEAVGRHm40BygvEVKolb4AgGTuQOJmyewvAopp8HRtPiZEMvWjWVMTFXL0QRy3rEj3hhGRiVHsIQkA3ICA3QCB47oUrxxqLLKv80ZEAveQvWcVJETBQKP0CIVeFAWBRG3IRxS53GGHpOEqVZEvzAG5ehpKuim4uGhBdlc1RDVQCEqqvY+OIq22oMwfAeZ7HIYWO//8u5CbY/FGptQAAAABJRU5ErkJggg==","text/plain":["<PIL.Image.Image image mode=RGB size=256x256 at 0x7F6E48437A50>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["CPU times: user 38.7 ms, sys: 0 ns, total: 38.7 ms\n","Wall time: 40.2 ms\n"]}],"source":["%%time\n","from torchvision.utils import make_grid, save_image\n","from PIL import Image\n","\n","# https://github.com/lucidrains/DALLE-pytorch/blob/e1d10b9163ce78bacb5d8b42126255a0a8cdea35/generate.py#L93-L130\n","grid = make_grid(images, nrow=1, padding=0, pad_value=0)\n","ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy()\n","im = Image.fromarray(ndarr)\n","\n","print(input_text)\n","display(im)"]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":14,"status":"ok","timestamp":1640501363506,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"53_I9cG7ETVj","outputId":"e444fbe5-4274-488b-ab81-42dbac003667"},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Dec 26 06:49:22 2021       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   39C    P0    39W / 250W |   9279MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":26,"metadata":{"executionInfo":{"elapsed":9,"status":"ok","timestamp":1640501363507,"user":{"displayName":"gaemin kim","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"14575069786534506494"},"user_tz":-540},"id":"eu5cjiEzwaVf"},"outputs":[],"source":[]}],"metadata":{"accelerator":"GPU","colab":{"collapsed_sections":[],"name":"inference_blue.ipynb","provenance":[]},"interpreter":{"hash":"546ac3bc9ff8ae035b2d532deb5ff1f925751c91c859447d340e61cadcd4cd28"},"kernelspec":{"display_name":"Python 3.8.5 64-bit ('taming': conda)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.5"},"orig_nbformat":4,"widgets":{"application/vnd.jupyter.widget-state+json":{"008bfb9186864298993ef2303659d3ad":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"056f5acf9bd34054868b95e06b35350e":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0a3039e5606b4eceab025c42b99b79ed":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"0f682f4dc3284534b6be9e10ea619d2b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_0a3039e5606b4eceab025c42b99b79ed","placeholder":"​","style":"IPY_MODEL_3a5ce6f768cf42359be9b1edef7fc272","value":"100%"}},"14ef623da96e443e8d985870052a59e9":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_d9fed9c7866849d585db5cc936b58d57","max":751504,"min":0,"orientation":"horizontal","style":"IPY_MODEL_f20fd195724b4d979e7e202e7e422ba6","value":751504}},"1b257065d0ef40eeb4f43c5a22ec91d2":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"355e86971e0f4f7aa134fe70bd3ac8b0":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_a44149a8e39048acbd184036aeffd52b","placeholder":"​","style":"IPY_MODEL_e92c525df9194f9b82d3c0607bfb3f97","value":"Downloading: 100%"}},"39ff2b3eb62348fa8884d2f64d829dad":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_4ea034953e6e4c9f8739a0d811513532","placeholder":"​","style":"IPY_MODEL_ea58905965844e06b6f9b8344cf1cb7b","value":" 734k/734k [00:01&lt;00:00, 1.06MB/s]"}},"3a5ce6f768cf42359be9b1edef7fc272":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"4755a06ad8dc4f14aeb1363052a576d7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_1b257065d0ef40eeb4f43c5a22ec91d2","placeholder":"​","style":"IPY_MODEL_e31f637aaa114f3e9d4e8036a85a75a4","value":" 243k/243k [00:00&lt;00:00, 311kB/s]"}},"4b603c2753094e05a024429d00ca4cf1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4e857c5654f3406fa4b49dfb45348a02":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"4ea034953e6e4c9f8739a0d811513532":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"682c5233b6bc4c96a2e75bd0c5aeb02a":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"71039a160e29436b928f22c477db2e41":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_be3d477b33484cbaab304ca97cf63378","placeholder":"​","style":"IPY_MODEL_7cbc74df100d439b82f3be2c0e2c3b54","value":"Downloading: 100%"}},"71b99fb5f37743558d660aa4ac53e587":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"789520acf8c6443c87eb3159ee5a94f1":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"7cbc74df100d439b82f3be2c0e2c3b54":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"83f744eab718483f9c9e604e67f365cd":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"92046bf3cbe54ba5a3adad249c391129":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"98af5a89118243d3b1dbd71fcab90395":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_b46403218cf942d98715083a75dcad87","max":248477,"min":0,"orientation":"horizontal","style":"IPY_MODEL_e75ea3ec61524e9c9f9a12a449866aac","value":248477}},"9addf47d6953415da7dbabf730acfc16":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_4b603c2753094e05a024429d00ca4cf1","placeholder":"​","style":"IPY_MODEL_cd346231832d4029b8cbccfd444fb805","value":" 173/173 [00:00&lt;00:00, 4.96kB/s]"}},"a092a22fbef44f96a3818b46b07eb83b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_71b99fb5f37743558d660aa4ac53e587","placeholder":"​","style":"IPY_MODEL_de92258c01bc4f21b78e1e74efff9063","value":"Downloading: 100%"}},"a44149a8e39048acbd184036aeffd52b":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b1b9d3f604104dac97e57ff73489d32c":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b3ccc40ffd8f48fe81957f480f6e6815":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_71039a160e29436b928f22c477db2e41","IPY_MODEL_db1ff5fe3e3d4af58593c5573bbc6f75","IPY_MODEL_9addf47d6953415da7dbabf730acfc16"],"layout":"IPY_MODEL_b1b9d3f604104dac97e57ff73489d32c"}},"b46403218cf942d98715083a75dcad87":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b5649869ea9f461a989a58b5aae78608":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_056f5acf9bd34054868b95e06b35350e","placeholder":"​","style":"IPY_MODEL_83f744eab718483f9c9e604e67f365cd","value":" 375/375 [00:00&lt;00:00, 5.61kB/s]"}},"b64b4eb7046f48cda8b98661ac77b3aa":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"b737a3077a5844039a6be0f7027b8529":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_a092a22fbef44f96a3818b46b07eb83b","IPY_MODEL_bdb5685a0b414e65a82b1778930e3747","IPY_MODEL_b5649869ea9f461a989a58b5aae78608"],"layout":"IPY_MODEL_789520acf8c6443c87eb3159ee5a94f1"}},"bbca27254b1040e69ed0c824239fa250":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bdb5685a0b414e65a82b1778930e3747":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_fce9b529a2c8491a96b1a82b8de634dc","max":375,"min":0,"orientation":"horizontal","style":"IPY_MODEL_682c5233b6bc4c96a2e75bd0c5aeb02a","value":375}},"be3d477b33484cbaab304ca97cf63378":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"bfa7edd8caff48f7be2fe4ad34f62ac1":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_0f682f4dc3284534b6be9e10ea619d2b","IPY_MODEL_eabb6eea5950458ab41116a1525acedc","IPY_MODEL_d1f42d328f674043a71b4d7406843511"],"layout":"IPY_MODEL_fa6e1babb7ea4a02b1379d1f293184bd"}},"cb36498cf7db4aa0b4f601f05d088a8f":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_355e86971e0f4f7aa134fe70bd3ac8b0","IPY_MODEL_98af5a89118243d3b1dbd71fcab90395","IPY_MODEL_4755a06ad8dc4f14aeb1363052a576d7"],"layout":"IPY_MODEL_b64b4eb7046f48cda8b98661ac77b3aa"}},"cca1beb5ef98445e8db63224a8783011":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"cce09cfcc961488aacf95f26158480c0":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"cd346231832d4029b8cbccfd444fb805":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"cfef0fae7f0849ba93242651ce3d9dee":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HBoxModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HBoxModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HBoxView","box_style":"","children":["IPY_MODEL_f33abf69f5924492a6f50b75b60cef4d","IPY_MODEL_14ef623da96e443e8d985870052a59e9","IPY_MODEL_39ff2b3eb62348fa8884d2f64d829dad"],"layout":"IPY_MODEL_4e857c5654f3406fa4b49dfb45348a02"}},"d1f42d328f674043a71b4d7406843511":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_d6da336731144c97a9964d79edd69d5a","placeholder":"​","style":"IPY_MODEL_fdecb696460a41d09ef2b92d195151a7","value":" 528M/528M [00:10&lt;00:00, 191MB/s]"}},"d6da336731144c97a9964d79edd69d5a":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"d9fed9c7866849d585db5cc936b58d57":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"db1ff5fe3e3d4af58593c5573bbc6f75":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_cce09cfcc961488aacf95f26158480c0","max":173,"min":0,"orientation":"horizontal","style":"IPY_MODEL_cca1beb5ef98445e8db63224a8783011","value":173}},"de92258c01bc4f21b78e1e74efff9063":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"e31f637aaa114f3e9d4e8036a85a75a4":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"e75ea3ec61524e9c9f9a12a449866aac":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"e92c525df9194f9b82d3c0607bfb3f97":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"ea58905965844e06b6f9b8344cf1cb7b":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"eabb6eea5950458ab41116a1525acedc":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"FloatProgressModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"FloatProgressModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"ProgressView","bar_style":"success","description":"","description_tooltip":null,"layout":"IPY_MODEL_92046bf3cbe54ba5a3adad249c391129","max":553433881,"min":0,"orientation":"horizontal","style":"IPY_MODEL_008bfb9186864298993ef2303659d3ad","value":553433881}},"f20fd195724b4d979e7e202e7e422ba6":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"ProgressStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"ProgressStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","bar_color":null,"description_width":""}},"f33abf69f5924492a6f50b75b60cef4d":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"HTMLModel","state":{"_dom_classes":[],"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"HTMLModel","_view_count":null,"_view_module":"@jupyter-widgets/controls","_view_module_version":"1.5.0","_view_name":"HTMLView","description":"","description_tooltip":null,"layout":"IPY_MODEL_bbca27254b1040e69ed0c824239fa250","placeholder":"​","style":"IPY_MODEL_fa6f0f6b0bab4ab6afe48f52ccc0f218","value":"Downloading: 100%"}},"fa6e1babb7ea4a02b1379d1f293184bd":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"fa6f0f6b0bab4ab6afe48f52ccc0f218":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}},"fce9b529a2c8491a96b1a82b8de634dc":{"model_module":"@jupyter-widgets/base","model_module_version":"1.2.0","model_name":"LayoutModel","state":{"_model_module":"@jupyter-widgets/base","_model_module_version":"1.2.0","_model_name":"LayoutModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"LayoutView","align_content":null,"align_items":null,"align_self":null,"border":null,"bottom":null,"display":null,"flex":null,"flex_flow":null,"grid_area":null,"grid_auto_columns":null,"grid_auto_flow":null,"grid_auto_rows":null,"grid_column":null,"grid_gap":null,"grid_row":null,"grid_template_areas":null,"grid_template_columns":null,"grid_template_rows":null,"height":null,"justify_content":null,"justify_items":null,"left":null,"margin":null,"max_height":null,"max_width":null,"min_height":null,"min_width":null,"object_fit":null,"object_position":null,"order":null,"overflow":null,"overflow_x":null,"overflow_y":null,"padding":null,"right":null,"top":null,"visibility":null,"width":null}},"fdecb696460a41d09ef2b92d195151a7":{"model_module":"@jupyter-widgets/controls","model_module_version":"1.5.0","model_name":"DescriptionStyleModel","state":{"_model_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_model_name":"DescriptionStyleModel","_view_count":null,"_view_module":"@jupyter-widgets/base","_view_module_version":"1.2.0","_view_name":"StyleView","description_width":""}}}}},"nbformat":4,"nbformat_minor":0}

From 15bb139a1e77a38604e6834517eb5487757b4628 Mon Sep 17 00:00:00 2001
From: JoonHong-Kim <danielkim30433@gmail.com>
Date: Sun, 26 Dec 2021 22:03:56 +0900
Subject: [PATCH 26/26] sty) change model arguments

---
 .gitignore      |   3 +-
 dalle/models.py |  25 ++---
 generate.ipynb  | 263 ++++++++------------------------------------
 model.py        | 287 ++++--------------------------------------------
 4 files changed, 81 insertions(+), 497 deletions(-)

diff --git a/.gitignore b/.gitignore
index abb7cab..7bcbf7e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,7 +15,8 @@ __pycache__/
 *.ipynb
 # C extensions
 *.so
-
+*.yaml
+VQGAN_blue_e7
 # Distribution / packaging
 .Python
 build/
diff --git a/dalle/models.py b/dalle/models.py
index cf75985..03879ff 100644
--- a/dalle/models.py
+++ b/dalle/models.py
@@ -2,15 +2,14 @@
 from torch import nn
 import torch.nn.functional as F
 import numpy as np
-
+from einops import repeat
 from axial_positional_embedding import AxialPositionalEmbedding
 from einops import rearrange
 
-from dalle_pytorch import distributed_utils, DiscreteVAE
+from dalle_pytorch import DiscreteVAE
 from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE
 
 from dalle_pytorch.transformer import Transformer, DivideMax
-from dalle_pytorch.attention import stable_softmax
 from utils import *
 
 
@@ -126,16 +125,18 @@ def __init__(
     @eval_decorator
     def generate_images(
         self,
-        text,
+        encoded_text,
         *,
         clip=None,
-        mask=None,
         filter_thres=0.5,
         temperature=1.0,
         img=None,
         num_init_img_tokens=None,
+        img_num=1,
     ):
-        origin_text = text
+        text = encoded_text['input_ids']
+        text=repeat(text,'() n -> b n',b=img_num)
+        mask=encoded_text['attention_mask']
         vae, text_seq_len, image_seq_len, num_text_tokens = (
             self.vae,
             self.text_seq_len,
@@ -146,7 +147,7 @@ def generate_images(
 
         text = text[:, :text_seq_len]  # make sure text is within bounds
         out = text
-
+        
         if exists(img):
             image_size = vae.image_size
             assert (
@@ -185,18 +186,14 @@ def generate_images(
             if out.shape[1] <= text_seq_len:
                 mask = F.pad(mask, (0, 1), value=True)
 
-        text_seq = out[:, :text_seq_len]
+
 
         img_seq = out[:, -image_seq_len:]
         images = vae.decode(img_seq)
 
         if exists(clip):
-            # from transformers import AutoTokenizer
-
-            # clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
-            # origin_text
-            # input_text = input_text.to("cuda")
-            text_embeds, image_embeds = clip(origin_text, images)
+            #encoded_text = encoded_text.to("cuda")
+            text_embeds, image_embeds = clip(encoded_text, images)
             logits = text_embeds @ image_embeds.T
             return images, logits
 
diff --git a/generate.ipynb b/generate.ipynb
index 8a7047f..8550f40 100644
--- a/generate.ipynb
+++ b/generate.ipynb
@@ -9,13 +9,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import argparse\n",
-    "from pathlib import Path\n",
-    "from tqdm import tqdm\n",
     "\n",
     "# torch\n",
     "\n",
@@ -26,17 +23,17 @@
     "# vision imports\n",
     "\n",
     "from PIL import Image\n",
-    "from torchvision.utils import make_grid, save_image\n",
+    "from torchvision.utils import make_grid\n",
     "\n",
     "# dalle related classes and utils\n",
     "\n",
-    "from dalle_pytorch import DiscreteVAE, OpenAIDiscreteVAE, VQGanVAE, DALLE\n",
+    "from dalle_pytorch import VQGanVAE\n",
     "from dalle_pytorch.tokenizer import *"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -53,23 +50,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "from easydict import EasyDict\n",
-    "DALLE_PATH = '/opt/ml/DALLE-pytorch/dalle.pt'\n",
+    "DALLE_PATH = './dalle.pt'\n",
     "\n",
     "DALLE_CFG = EasyDict()\n",
     "\n",
     "# argument parsing\n",
     "\n",
-    "DALLE_CFG.VQGAN_PATH = \"/opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/checkpoints/VQGAN_blue.ckpt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
-    "DALLE_CFG.VQGAN_CFG_PATH = \"/opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/configs/VQGAN_blue.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
-    "DALLE_CFG.DALLE_PATH = \"/opt/ml/DALLE-pytorch/dalle.pt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
+    "DALLE_CFG.VQGAN_PATH = \"./VQGAN_blue_e7\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
+    "DALLE_CFG.VQGAN_CFG_PATH = \"./VQGAN_blue.yaml\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
+    "DALLE_CFG.DALLE_PATH = \"./dalle.pt\"   # './vae.pt' - will use OpenAIs pretrained VAE if not set\n",
     "\n",
-    "DALLE_CFG.WPE_PATH = \"/opt/ml/DALLE-pytorch/roberta_large_wpe.pt\"\n",
-    "DALLE_CFG.WTE_PATH = \"/opt/ml/DALLE-pytorch/roberta_large_wte.pt\"\n",
+    "DALLE_CFG.WPE_PATH = \"./roberta_large_wpe.pt\"\n",
+    "DALLE_CFG.WTE_PATH = \"./roberta_large_wte.pt\"\n",
     "\n",
     "# DALLE_CFG.MODEL_DIM = 512\n",
     "DALLE_CFG.TEXT_SEQ_LEN = 128\n",
@@ -80,33 +77,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "tensor([[    0,  6164,  2115,  2259,  8817,  2052, 10424,  4642,  2116,  1469,\n",
-       "          2862,  1887,  2052,   766,  2149,  2179, 10224, 28674,    18, 19975,\n",
-       "          2259,  8817,  2052,  5676,  4642,  2116,  1469,  2862,  1887,  2052,\n",
-       "           766,  2149,  2179, 15144, 28674,    18,     2,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1,     1,     1,\n",
-       "             1,     1,     1,     1,     1,     1,     1,     1]],\n",
-       "       device='cuda:0')"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from transformers import AutoTokenizer\n",
     "  \n",
@@ -119,11 +92,9 @@
     "    truncation=True,\n",
     "    max_length=DALLE_CFG.TEXT_SEQ_LEN,\n",
     "    add_special_tokens=True,\n",
-    "    return_token_type_ids=False,  # for RoBERTa\n",
+    "    return_token_type_ids=True,  # for RoBERTa\n",
     ")\n",
-    "encoded_dict=encoded_dict.to('cuda')\n",
-    "input_ids = encoded_dict[\"input_ids\"]\n",
-    "attention_mask = encoded_dict[\"attention_mask\"]"
+    "encoded_dict=encoded_dict.to('cuda')"
    ]
   },
   {
@@ -135,28 +106,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n",
-      "loaded pretrained LPIPS loss from taming/modules/autoencoder/lpips/vgg.pth\n",
-      "VQLPIPSWithDiscriminator running with hinge loss.\n",
-      "Loaded VQGAN from /opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/checkpoints/VQGAN_blue.ckpt and /opt/ml/taming-transformers/logs/2021-12-13T16-23-29_custom_vqgan/configs/VQGAN_blue.yaml\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from dalle_pytorch import VQGanVAE\n",
     "from pathlib import Path\n",
     "\n",
     "DALLE_CFG.VOCAB_SIZE = tokenizer.vocab_size # refer to EDA, there are only 333 words total. but input_ids index should be in within 0 ~ 52000: https://github.com/boostcampaitech2-happyface/DALLE-Couture/blob/pytorch-dalle/EDA.ipynb\n",
     "\n",
-    "DALLE_PATH\n",
-    "assert DALLE_PATH.exists(), 'DALL-E model file does not exist'\n",
     "\n",
     "loaded_obj = torch.load(DALLE_PATH, map_location=torch.device('cuda'))\n",
     "\n",
@@ -179,34 +137,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'num_text_tokens': 32000,\n",
-       " 'text_seq_len': 64,\n",
-       " 'depth': 12,\n",
-       " 'heads': 8,\n",
-       " 'dim_head': 64,\n",
-       " 'reversible': False,\n",
-       " 'loss_img_weight': 7,\n",
-       " 'attn_types': ('full',),\n",
-       " 'ff_dropout': 0.7,\n",
-       " 'attn_dropout': 0.7,\n",
-       " 'stable': False,\n",
-       " 'shift_tokens': False,\n",
-       " 'rotary_emb': False}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "dalle_params"
+    "def get_n_params(model):\n",
+    "    pp=0\n",
+    "    for p in list(model.parameters()):\n",
+    "        nn=1\n",
+    "        for s in list(p.size()):\n",
+    "            nn = nn*s\n",
+    "        pp += nn\n",
+    "    return pp\n",
+    "def count_parameters(model):\n",
+    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)"
    ]
   },
   {
@@ -218,32 +162,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1024 16 16\n",
-      "torch.Size([5, 3, 256, 256])\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.8/site-packages/transformers/tokenization_utils_base.py:2233: UserWarning: Though `pad_to_max_length` = `True`, it is ignored because `padding`=`True`.\n",
-      "  warnings.warn(\"Though `pad_to_max_length` = `True`, it is ignored because `padding`=`True`.\")\n",
-      "/opt/conda/lib/python3.8/site-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
-      "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from model import DALLE_Klue_Roberta\n",
-    "from clipmodel import *\n",
-    "from einops import repeat\n",
+    "from clip.clipmodel import *\n",
     "\n",
     "dalle = DALLE_Klue_Roberta(\n",
     "    vae = vae, \n",
@@ -253,15 +177,19 @@
     "    )\n",
     "dalle.load_state_dict(weights)\n",
     "dalle.to('cuda')\n",
-    "input_ids=repeat(input_ids,'() n -> b n',b=DALLE_CFG.TOP_K)\n",
-    "#print(input_ids)\n",
-    "#print(input_ids.shape)\n",
-    "#raw_text=raw_text.to('cuda')\n",
+    "#encoded_dict=repeat(encoded_dict,'() n -> b n',b=DALLE_CFG.TOP_K)\n",
     "# https://github.com/lucidrains/DALLE-pytorch/blob/main/dalle_pytorch/dalle_pytorch.py#L454-L510\n",
-    "clip_model = torch.load(\"fashionclip_fn.pt\")\n",
-    "clip_model.to('cuda')\n",
-    "images = dalle.generate_images(input_ids, mask = attention_mask,clip=clip_model,raw_text=raw_text)\n",
-    "#images.shape # (4, 3, 256, 256)"
+    "clip_model = torch.load(\"clip.pt\",map_location=torch.device('cuda'))\n",
+    "clip_model.to('cuda')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = dalle.generate_images(encoded_dict,clip=clip_model,img_num=DALLE_CFG.TOP_K)"
    ]
   },
   {
@@ -273,96 +201,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Input Text: 아우터는 색상이 브라운 소재가 우븐 핏이 노멀인 재킷이다. 하의는 색상이 블랙 소재가 우븐 핏이 노멀인 팬츠이다.\n",
-      "probability: 0.20085719227790833\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F79C42EEF40>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "probability: 0.2007923722267151\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F7917130310>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "probability: 0.20067806541919708\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F79C44085B0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "probability: 0.1990816444158554\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F79171303A0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "probability: 0.1985906958580017\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=256x256 at 0x7F7917130340>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from torchvision.utils import make_grid, save_image\n",
     "from PIL import Image\n",
@@ -381,17 +222,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor([[6.5843, 6.5758, 6.5837, 6.5846, 6.5733]], device='cuda:0')\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(images[1])"
    ]
diff --git a/model.py b/model.py
index 007827b..1371885 100644
--- a/model.py
+++ b/model.py
@@ -1,262 +1,17 @@
-from math import log2, sqrt
 import torch
-from einops import repeat
-
-
-from torch import nn, einsum
+from torch import nn
 import torch.nn.functional as F
 import numpy as np
-
+from einops import repeat
 from axial_positional_embedding import AxialPositionalEmbedding
 from einops import rearrange
 
-from dalle_pytorch import distributed_utils
+from dalle_pytorch import DiscreteVAE
 from dalle_pytorch.vae import OpenAIDiscreteVAE, VQGanVAE
-from dalle_pytorch.transformer import Transformer, DivideMax
-from dalle_pytorch.attention import stable_softmax
-
-# from clipmodel import *
-
-
-def exists(val):
-    return val is not None
-
-
-def default(val, d):
-    return val if exists(val) else d
-
-
-class always:
-    def __init__(self, val):
-        self.val = val
-
-    def __call__(self, x, *args, **kwargs):
-        return self.val
-
-
-def is_empty(t):
-    return t.nelement() == 0
-
-
-def masked_mean(t, mask, dim=1):
-    t = t.masked_fill(~mask[:, :, None], 0.0)
-    return t.sum(dim=1) / mask.sum(dim=1)[..., None]
-
-
-def set_requires_grad(model, value):
-    for param in model.parameters():
-        param.requires_grad = value
-
-
-def eval_decorator(fn):
-    def inner(model, *args, **kwargs):
-        was_training = model.training
-        model.eval()
-        out = fn(model, *args, **kwargs)
-        model.train(was_training)
-        return out
-
-    return inner
-
-
-# sampling helpers
-
-
-def top_k(logits, thres=0.5):
-    num_logits = logits.shape[-1]
-    k = max(int((1 - thres) * num_logits), 1)
-    val, ind = torch.topk(logits, k)
-    probs = torch.full_like(logits, float("-inf"))
-    probs.scatter_(1, ind, val)
-    return probs
-
-
-# discrete vae class
-
-
-class DiscreteVAE(nn.Module):
-    def __init__(
-        self,
-        image_size=256,
-        num_tokens=512,
-        codebook_dim=512,
-        num_layers=3,
-        num_resnet_blocks=0,
-        hidden_dim=64,
-        channels=3,
-        smooth_l1_loss=False,
-        temperature=0.9,
-        straight_through=False,
-        kl_div_loss_weight=0.0,
-        normalization=((0.5,) * 3, (0.5,) * 3),
-    ):
-        super().__init__()
-        assert log2(image_size).is_integer(), "image size must be a power of 2"
-        assert num_layers >= 1, "number of layers must be greater than or equal to 1"
-        has_resblocks = num_resnet_blocks > 0
-
-        self.image_size = image_size
-        self.num_tokens = num_tokens
-        self.num_layers = num_layers
-        self.temperature = temperature
-        self.straight_through = straight_through
-        self.codebook = nn.Embedding(num_tokens, codebook_dim)
-
-        hdim = hidden_dim
-
-        enc_chans = [hidden_dim] * num_layers
-        dec_chans = list(reversed(enc_chans))
-
-        enc_chans = [channels, *enc_chans]
-
-        dec_init_chan = codebook_dim if not has_resblocks else dec_chans[0]
-        dec_chans = [dec_init_chan, *dec_chans]
-
-        enc_chans_io, dec_chans_io = map(
-            lambda t: list(zip(t[:-1], t[1:])), (enc_chans, dec_chans)
-        )
-
-        enc_layers = []
-        dec_layers = []
-
-        for (enc_in, enc_out), (dec_in, dec_out) in zip(enc_chans_io, dec_chans_io):
-            enc_layers.append(
-                nn.Sequential(
-                    nn.Conv2d(enc_in, enc_out, 4, stride=2, padding=1), nn.ReLU()
-                )
-            )
-            dec_layers.append(
-                nn.Sequential(
-                    nn.ConvTranspose2d(dec_in, dec_out, 4, stride=2, padding=1),
-                    nn.ReLU(),
-                )
-            )
-
-        for _ in range(num_resnet_blocks):
-            dec_layers.insert(0, ResBlock(dec_chans[1]))
-            enc_layers.append(ResBlock(enc_chans[-1]))
-
-        if num_resnet_blocks > 0:
-            dec_layers.insert(0, nn.Conv2d(codebook_dim, dec_chans[1], 1))
-
-        enc_layers.append(nn.Conv2d(enc_chans[-1], num_tokens, 1))
-        dec_layers.append(nn.Conv2d(dec_chans[-1], channels, 1))
-
-        self.encoder = nn.Sequential(*enc_layers)
-        self.decoder = nn.Sequential(*dec_layers)
-
-        self.loss_fn = F.smooth_l1_loss if smooth_l1_loss else F.mse_loss
-        self.kl_div_loss_weight = kl_div_loss_weight
-
-        # take care of normalization within class
-        self.normalization = normalization
-
-        self._register_external_parameters()
-
-    def _register_external_parameters(self):
-        """Register external parameters for DeepSpeed partitioning."""
-        if not distributed_utils.is_distributed or not distributed_utils.using_backend(
-            distributed_utils.DeepSpeedBackend
-        ):
-            return
-
-        deepspeed = distributed_utils.backend.backend_module
-        deepspeed.zero.register_external_parameter(self, self.codebook.weight)
-
-    def norm(self, images):
-        if not exists(self.normalization):
-            return images
-
-        means, stds = map(lambda t: torch.as_tensor(t).to(images), self.normalization)
-        means, stds = map(lambda t: rearrange(t, "c -> () c () ()"), (means, stds))
-        images = images.clone()
-        images.sub_(means).div_(stds)
-        return images
-
-    @torch.no_grad()
-    @eval_decorator
-    def get_codebook_indices(self, images):
-        logits = self(images, return_logits=True)
-        codebook_indices = logits.argmax(dim=1).flatten(1)
-        return codebook_indices
-
-    def decode(self, img_seq):
-        image_embeds = self.codebook(img_seq)
-        b, n, d = image_embeds.shape
-        h = w = int(sqrt(n))
-
-        image_embeds = rearrange(image_embeds, "b (h w) d -> b d h w", h=h, w=w)
-        images = self.decoder(image_embeds)
-        return images
-
-    def forward(
-        self,
-        img,
-        return_loss=False,
-        return_recons=False,
-        return_logits=False,
-        temp=None,
-    ):
-        device, num_tokens, image_size, kl_div_loss_weight = (
-            img.device,
-            self.num_tokens,
-            self.image_size,
-            self.kl_div_loss_weight,
-        )
-        assert (
-            img.shape[-1] == image_size and img.shape[-2] == image_size
-        ), f"input must have the correct image size {image_size}"
-
-        img = self.norm(img)
-
-        logits = self.encoder(img)
-
-        if return_logits:
-            return logits  # return logits for getting hard image indices for DALL-E training
-
-        temp = default(temp, self.temperature)
-        soft_one_hot = F.gumbel_softmax(
-            logits, tau=temp, dim=1, hard=self.straight_through
-        )
-        sampled = einsum("b n h w, n d -> b d h w", soft_one_hot, self.codebook.weight)
-        out = self.decoder(sampled)
-
-        if not return_loss:
-            return out
-
-        # reconstruction loss
-
-        recon_loss = self.loss_fn(img, out)
-
-        # kl divergence
-
-        logits = rearrange(logits, "b n h w -> b (h w) n")
-        log_qy = F.log_softmax(logits, dim=-1)
-        log_uniform = torch.log(torch.tensor([1.0 / num_tokens], device=device))
-        kl_div = F.kl_div(log_uniform, log_qy, None, None, "batchmean", log_target=True)
-
-        loss = recon_loss + (kl_div * kl_div_loss_weight)
-
-        if not return_recons:
-            return loss
-
-        return loss, out
-
-
-class ResBlock(nn.Module):
-    def __init__(self, chan):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Conv2d(chan, chan, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(chan, chan, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(chan, chan, 1),
-        )
-
-    def forward(self, x):
-        return self.net(x) + x
 
+from dalle_pytorch.transformer import Transformer, DivideMax
+from utils import *
+from tqdm import tqdm
 
 class DALLE_Klue_Roberta(nn.Module):
     def __init__(
@@ -370,17 +125,18 @@ def __init__(
     @eval_decorator
     def generate_images(
         self,
-        text,
+        encoded_text,
         *,
         clip=None,
-        mask=None,
         filter_thres=0.5,
         temperature=1.0,
         img=None,
         num_init_img_tokens=None,
-        raw_text=None,
+        img_num=1,
     ):
-        origin_text = text
+        text = encoded_text['input_ids']
+        text=repeat(text,'() n -> b n',b=img_num)
+        mask=encoded_text['attention_mask']
         vae, text_seq_len, image_seq_len, num_text_tokens = (
             self.vae,
             self.text_seq_len,
@@ -388,9 +144,10 @@ def generate_images(
             self.num_text_tokens,
         )
         total_len = text_seq_len + image_seq_len
+
         text = text[:, :text_seq_len]  # make sure text is within bounds
         out = text
-
+        
         if exists(img):
             image_size = vae.image_size
             assert (
@@ -410,7 +167,7 @@ def generate_images(
             indices = indices[:, :num_img_tokens]
             out = torch.cat((out, indices), dim=-1)
 
-        for cur_len in range(out.shape[1], total_len):
+        for cur_len in tqdm(range(out.shape[1], total_len)):
             is_image = cur_len >= text_seq_len
 
             text, image = out[:, :text_seq_len], out[:, text_seq_len:]
@@ -429,20 +186,14 @@ def generate_images(
             if out.shape[1] <= text_seq_len:
                 mask = F.pad(mask, (0, 1), value=True)
 
-        text_seq = out[:, :text_seq_len]
+
 
         img_seq = out[:, -image_seq_len:]
         images = vae.decode(img_seq)
-        print(images.shape)
-        if exists(clip):
-
-            # from transformers import AutoTokenizer
-
-            # clip_tokenizer = AutoTokenizer.from_pretrained("monologg/distilkobert") # clip에 사용된 tokenizer
-            # origin_text
-            # input_text = input_text.to("cuda")
-            text_embeds, image_embeds = clip(origin_text, images)
 
+        if exists(clip):
+            #encoded_text = encoded_text.to("cuda")
+            text_embeds, image_embeds = clip(encoded_text, images)
             logits = text_embeds @ image_embeds.T
             return images, logits
 
@@ -454,7 +205,9 @@ def forward(self, text, image=None, mask=None, return_loss=False):
         ), f"the length {text.shape[-1]} of the text tokens you passed in does not have the correct length ({self.text_seq_len})"
         device, total_seq_len = text.device, self.total_seq_len
 
+        # make sure padding in text tokens get unique padding token id
         text = F.pad(text, (1, 0), value=0)
+
         tokens = self.text_emb(text)
         tokens += self.text_pos_emb(torch.arange(text.shape[1], device=device))