From 44cc94220ffef06ff1e348bd5f11d11c04055bdb Mon Sep 17 00:00:00 2001 From: tsgil Date: Thu, 30 Nov 2023 08:22:32 +0000 Subject: [PATCH 1/3] [Add] notebooks --- notebooks/debug_relationformer.ipynb | 1954 ++++++++++++++++++++++++++ notebooks/show_region_full_img.ipynb | 172 +++ notebooks/spacenet_inferencer.ipynb | 496 +++++++ 3 files changed, 2622 insertions(+) create mode 100644 notebooks/debug_relationformer.ipynb create mode 100644 notebooks/show_region_full_img.ipynb create mode 100644 notebooks/spacenet_inferencer.ipynb diff --git a/notebooks/debug_relationformer.ipynb b/notebooks/debug_relationformer.ipynb new file mode 100644 index 0000000..da9ec1f --- /dev/null +++ b/notebooks/debug_relationformer.ipynb @@ -0,0 +1,1954 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import yaml\n", + "import sys\n", + "sys.path.append(\"..\")\n", + "import json\n", + "import numpy as np\n", + "from scipy import ndimage\n", + "from scipy.sparse import csr_matrix\n", + "from scipy.sparse.csgraph import connected_components\n", + "from skimage.morphology import skeletonize_3d\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import text, patheffects\n", + "import matplotlib.patches as patches\n", + "import matplotlib.gridspec as gridspec\n", + "from monai.data import DataLoader\n", + "import torch\n", + "from torch import nn\n", + "import networkx as nx\n", + "from dataset_road_network import Sat2GraphDataLoader\n", + "from dataset_road_network import build_road_network_data\n", + "from evaluator import build_evaluator\n", + "from trainer import build_trainer\n", + "from models import build_model\n", + "from utils import image_graph_collate_road_network\n", + "from models.matcher import build_matcher\n", + "from inference import relation_infer\n", + "from losses import SetCriterion\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "\n", + "# %matplotlib widget\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class obj:\n", + " def __init__(self, dict1):\n", + " self.__dict__.update(dict1)\n", + " \n", + "def dict2obj(dict1):\n", + " return json.loads(json.dumps(dict1), object_hook=obj)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "config_file = \"/nas/tsgil/relationformer/configs/road_rgb_2D_gil.yaml\"\n", + "\n", + "with open(config_file) as f:\n", + " config = yaml.load(f, Loader=yaml.FullLoader)\n", + "\n", + "config = dict2obj(config)\n", + "mean = np.array([0.485, 0.456, 0.406])\n", + "std = np.array([0.229, 0.224, 0.225])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_test_sample(image, points, edges):\n", + "\n", + " H, W = image.shape[0], image.shape[1]\n", + " fig, ax = plt.subplots(figsize=(12,5), dpi=150)\n", + " gridspec.GridSpec(1,5)\n", + " ax = plt.subplot2grid((1,4), (0,0), colspan=2, rowspan=1)\n", + "\n", + " # Displaying the image\n", + " ax.imshow(image*std+mean)\n", + " ax.axis('off')\n", + " \n", + " ax = plt.subplot2grid((1,4), (0,2), colspan=2, rowspan=1)\n", + " \n", + " border_nodes = np.array([[0,0],[0,H],[W,H],[W,0]])\n", + " border_edges = [(0,1),(1,2),(2,3),(3,0)]\n", + " \n", + " G1 = nx.Graph()\n", + " G1.add_nodes_from(list(range(len(border_nodes))))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({i:(pts[1],pts[0])}) for i, pts in enumerate(border_nodes)]\n", + " for n, p in coord_dict.items():\n", + " G1.nodes[n]['pos'] = p\n", + " G1.add_edges_from(border_edges)\n", + " \n", + " pos = nx.get_node_attributes(G1,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G1, pos, ax=ax, node_size=1, node_color='darkgrey', edge_color='darkgrey', width=1.5, font_size=12, with_labels=False)\n", + "\n", + " \n", + " G = nx.Graph()\n", + " edges = [tuple(rel) for rel in edges]\n", + " nodes = list(np.unique(np.array(edges)))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({i:(W*pts[1],H- H*pts[0])}) for i, pts in enumerate(points)]\n", + " G.add_nodes_from(list(range(len(points))))\n", + " for n, p in coord_dict.items():\n", + " G.nodes[n]['pos'] = p\n", + " G.add_edges_from(edges)\n", + " pos = nx.get_node_attributes(G,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G, pos, ax=ax, node_size=10, node_color='lightcoral', edge_color='mediumorchid', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " \n", + " plt.show()\n", + " \n", + "\n", + "def plot_val_rel_sample(image, seg, points1, edges1, points2, edges2, attn_map=None, relative_coords=True):\n", + " H, W = image.shape[0], image.shape[1]\n", + " fig, ax = plt.subplots(1,4, figsize=(20,5), dpi=150)\n", + "\n", + " # Displaying the image, 인풋 이미지\n", + " ax[0].imshow(image*std+mean)\n", + " ax[0].axis('off')\n", + " \n", + " # 인풋 seg\n", + " ax[1].imshow(seg)\n", + " ax[1].axis('off')\n", + " \n", + " border_nodes = np.array([[1,1],[1,H-1],[W-1,H-1],[W-1,1]])\n", + " border_edges = [(0,1),(1,2),(2,3),(3,0)]\n", + " \n", + " # \n", + " G1 = nx.Graph()\n", + " G1.add_nodes_from(list(range(len(border_nodes))))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({i:(pts[1],pts[0])}) for i, pts in enumerate(border_nodes)]\n", + " for n, p in coord_dict.items():\n", + " G1.nodes[n]['pos'] = p\n", + " G1.add_edges_from(border_edges)\n", + " \n", + " pos = nx.get_node_attributes(G1,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G1, pos, ax=ax[2], node_size=1, node_color='darkgrey', edge_color='darkgrey', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " nx.draw(G1, pos, ax=ax[3], node_size=1, node_color='darkgrey', edge_color='darkgrey', width=1.5, font_size=12, with_labels=False)\n", + "\n", + " G = nx.Graph()\n", + " edges = [tuple(rel) for rel in edges1]\n", + " nodes = list(np.unique(np.array(edges)))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({nodes[i]:(W*pts[1], H- H*pts[0])}) for i, pts in enumerate(points1[nodes,:])]\n", + " G.add_nodes_from(nodes)\n", + " for n, p in coord_dict.items():\n", + " G.nodes[n]['pos'] = p\n", + " G.add_edges_from(edges)\n", + " \n", + " pos = nx.get_node_attributes(G,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G, pos, ax=ax[2], node_size=10, node_color='lightcoral', edge_color='mediumorchid', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " \n", + " G = nx.Graph()\n", + " edges = [tuple(rel) for rel in edges2]\n", + " nodes = list(np.unique(np.array(edges)))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({nodes[i]:(W*pts[1],H- H*pts[0])}) for i, pts in enumerate(points2[nodes,:])]\n", + " G.add_nodes_from(nodes)\n", + " for n, p in coord_dict.items():\n", + " G.nodes[n]['pos'] = p\n", + " G.add_edges_from(edges)\n", + " pos = nx.get_node_attributes(G,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G, pos, ax=ax[3], node_size=10, node_color='lightcoral', edge_color='mediumorchid', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Debug Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def image_graph_collate_road_network(batch):\n", + " images = torch.stack([item[0] for item in batch], 0).contiguous()\n", + " seg = torch.stack([item[1] for item in batch], 0).contiguous()\n", + " points = [item[2] for item in batch]\n", + " edges = [item[3] for item in batch]\n", + " return [images, seg, points, edges]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25036\n", + "(tensor([[[-2.1179, -2.1179, -2.1179, ..., -2.1179, -2.1179, -2.1179],\n", + " [-2.1179, -2.1179, -2.1179, ..., -2.1179, -2.1179, -2.1179],\n", + " [-2.1179, -2.1179, -2.1179, ..., -2.1179, -2.1179, -2.1179],\n", + " ...,\n", + " [-2.1179, -2.1179, -2.1179, ..., -2.1179, -2.1179, -2.1179],\n", + " [-2.1179, -2.1179, -2.1179, ..., -2.1179, -2.1179, -2.1179],\n", + " [-2.1179, -2.1179, -2.1179, ..., -2.1179, -2.1179, -2.1179]],\n", + "\n", + " [[-2.0357, -2.0357, -2.0357, ..., -2.0357, -2.0357, -2.0357],\n", + " [-2.0357, -2.0357, -2.0357, ..., -2.0357, -2.0357, -2.0357],\n", + " [-2.0357, -2.0357, -2.0357, ..., -2.0357, -2.0357, -2.0357],\n", + " ...,\n", + " [-2.0357, -2.0357, -2.0357, ..., -2.0357, -2.0357, -2.0357],\n", + " [-2.0357, -2.0357, -2.0357, ..., -2.0357, -2.0357, -2.0357],\n", + " [-2.0357, -2.0357, -2.0357, ..., -2.0357, -2.0357, -2.0357]],\n", + "\n", + " [[-1.8044, -1.8044, -1.8044, ..., -1.8044, -1.8044, -1.8044],\n", + " [-1.8044, -1.8044, -1.8044, ..., -1.8044, -1.8044, -1.8044],\n", + " [-1.8044, -1.8044, -1.8044, ..., -1.8044, -1.8044, -1.8044],\n", + " ...,\n", + " [-1.8044, -1.8044, -1.8044, ..., -1.8044, -1.8044, -1.8044],\n", + " [-1.8044, -1.8044, -1.8044, ..., -1.8044, -1.8044, -1.8044],\n", + " [-1.8044, -1.8044, -1.8044, ..., -1.8044, -1.8044, -1.8044]]]), tensor([[[-0.5000, -0.5000, -0.5000, ..., -0.5000, -0.5000, -0.5000],\n", + " [-0.5000, -0.5000, -0.5000, ..., -0.5000, -0.5000, -0.5000],\n", + " [-0.5000, -0.5000, -0.5000, ..., -0.5000, -0.5000, -0.5000],\n", + " ...,\n", + " [-0.5000, -0.5000, -0.5000, ..., -0.5000, -0.5000, -0.5000],\n", + " [-0.5000, -0.5000, -0.5000, ..., -0.5000, -0.5000, -0.5000],\n", + " [-0.5000, -0.5000, -0.5000, ..., -0.5000, -0.5000, -0.5000]]]), tensor([[0.7266, 0.4453],\n", + " [0.7266, 0.0391],\n", + " [0.9016, 0.9531],\n", + " [0.9531, 0.4531]]), tensor([[0, 1],\n", + " [0, 2],\n", + " [0, 3]]))\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n" + ] + }, + { + "data": { + "text/plain": [ + "['015102_1739_1677_108',\n", + " '003920_1677_1553_28',\n", + " '006194_314_5_48',\n", + " '008076_872_252_59',\n", + " '005848_1553_686_39']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "val_ds, file_infos = build_road_network_data( # 이 함수는 폴더에서 셔플해서 ds 생성함\n", + " config, mode='test', loadXYN=True\n", + ")\n", + "print(len(val_ds)) # 테스트셋 전체 지역 패치: 25036개, 훈련셋 지역 21: 631개\n", + "print(val_ds[0])\n", + "# ((3,128,128),(1,128,128),(14,2),(13,2))\n", + "# image_data, seg_data-0.5, coordinates[:,:2], lines[:,1:]\n", + "\n", + "val_loader = DataLoader(val_ds, # 4분 소요\n", + " batch_size=config.DATA.BATCH_SIZE,\n", + " shuffle=False,\n", + " num_workers=config.DATA.NUM_WORKERS,\n", + " collate_fn=image_graph_collate_road_network,\n", + " pin_memory=True)\n", + "len(val_loader) # 783 이터레이션\n", + "file_infos[:5]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# iteration = 0\n", + "# for images, seg, points, edges in val_loader:\n", + "# print('Iteration:',iteration)\n", + "# plot_test_sample(seg[0].permute(1,2,0).cpu().numpy(), points[0].cpu().numpy(), edges[0].cpu().numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Debug Trained Model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RelationFormer(\n", + " (encoder): Joiner(\n", + " (0): Backbone(\n", + " (body): IntermediateLayerGetter(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): FrozenBatchNorm2d()\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): FrozenBatchNorm2d()\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): FrozenBatchNorm2d()\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (6): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (7): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (8): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (9): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (10): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (11): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (12): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (13): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (14): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (15): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (16): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (17): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (18): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (19): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (20): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (21): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (22): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): FrozenBatchNorm2d()\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d()\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d()\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (1): PositionEmbeddingSine()\n", + " )\n", + " (decoder): DeformableTransformer(\n", + " (encoder): DeformableTransformerEncoder(\n", + " (layers): ModuleList(\n", + " (0): DeformableTransformerEncoderLayer(\n", + " (self_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (1): DeformableTransformerEncoderLayer(\n", + " (self_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (2): DeformableTransformerEncoderLayer(\n", + " (self_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (3): DeformableTransformerEncoderLayer(\n", + " (self_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " (decoder): DeformableTransformerDecoder(\n", + " (layers): ModuleList(\n", + " (0): DeformableTransformerDecoderLayer(\n", + " (cross_attn1): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout11): Dropout(p=0.1, inplace=False)\n", + " (norm11): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn2): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout12): Dropout(p=0.1, inplace=False)\n", + " (norm12): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (self_attn): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout4): Dropout(p=0.1, inplace=False)\n", + " (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (1): DeformableTransformerDecoderLayer(\n", + " (cross_attn1): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout11): Dropout(p=0.1, inplace=False)\n", + " (norm11): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn2): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout12): Dropout(p=0.1, inplace=False)\n", + " (norm12): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (self_attn): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout4): Dropout(p=0.1, inplace=False)\n", + " (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (2): DeformableTransformerDecoderLayer(\n", + " (cross_attn1): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout11): Dropout(p=0.1, inplace=False)\n", + " (norm11): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn2): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout12): Dropout(p=0.1, inplace=False)\n", + " (norm12): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (self_attn): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout4): Dropout(p=0.1, inplace=False)\n", + " (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (3): DeformableTransformerDecoderLayer(\n", + " (cross_attn1): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout11): Dropout(p=0.1, inplace=False)\n", + " (norm11): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn2): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout12): Dropout(p=0.1, inplace=False)\n", + " (norm12): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (cross_attn): MSDeformAttn(\n", + " (sampling_offsets): Linear(in_features=512, out_features=256, bias=True)\n", + " (attention_weights): Linear(in_features=512, out_features=128, bias=True)\n", + " (value_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " (output_proj): Linear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout1): Dropout(p=0.1, inplace=False)\n", + " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (self_attn): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", + " )\n", + " (dropout2): Dropout(p=0.1, inplace=False)\n", + " (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " (linear1): Linear(in_features=512, out_features=1024, bias=True)\n", + " (dropout3): Dropout(p=0.1, inplace=False)\n", + " (linear2): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout4): Dropout(p=0.1, inplace=False)\n", + " (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " )\n", + " (reference_points): Linear(in_features=512, out_features=2, bias=True)\n", + " )\n", + " (class_embed): Linear(in_features=512, out_features=2, bias=True)\n", + " (bbox_embed): MLP(\n", + " (layers): ModuleList(\n", + " (0): Linear(in_features=512, out_features=512, bias=True)\n", + " (1): Linear(in_features=512, out_features=512, bias=True)\n", + " (2): Linear(in_features=512, out_features=4, bias=True)\n", + " )\n", + " )\n", + " (relation_embed): MLP(\n", + " (layers): ModuleList(\n", + " (0): Linear(in_features=1536, out_features=512, bias=True)\n", + " (1): Linear(in_features=512, out_features=512, bias=True)\n", + " (2): Linear(in_features=512, out_features=2, bias=True)\n", + " )\n", + " )\n", + " (query_embed): Embedding(81, 1024)\n", + " (input_proj): ModuleList(\n", + " (0): Sequential(\n", + " (0): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): GroupNorm(32, 512, eps=1e-05, affine=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): GroupNorm(32, 512, eps=1e-05, affine=True)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): GroupNorm(32, 512, eps=1e-05, affine=True)\n", + " )\n", + " (3): Sequential(\n", + " (0): Conv2d(2048, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (1): GroupNorm(32, 512, eps=1e-05, affine=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = build_model(config)\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "model = model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "ckpt_path = '/nas/tsgil/relationformer/trained_weights/runs/baseline_road_resnet_def_detr_final_dec_4_10/models/checkpoint_epoch=100.pt'\n", + "checkpoint = torch.load(ckpt_path, map_location='cpu')\n", + "missing_keys, unexpected_keys = model.load_state_dict(checkpoint['net'], strict=False)\n", + "unexpected_keys = [k for k in unexpected_keys if not (k.endswith('total_params') or k.endswith('total_ops'))]\n", + "if len(missing_keys) > 0:\n", + " print('Missing Keys: {}'.format(missing_keys))\n", + "if len(unexpected_keys) > 0:\n", + " print('Unexpected Keys: {}'.format(unexpected_keys))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['./data/20cities/test_data_region_8/', './data/20cities/test_data_region_9/', './data/20cities/test_data_region_19/', './data/20cities/test_data_region_28/', './data/20cities/test_data_region_29/', './data/20cities/test_data_region_39/', './data/20cities/test_data_region_48/', './data/20cities/test_data_region_49/', './data/20cities/test_data_region_59/', './data/20cities/test_data_region_68/', './data/20cities/test_data_region_69/', './data/20cities/test_data_region_79/', './data/20cities/test_data_region_88/', './data/20cities/test_data_region_89/', './data/20cities/test_data_region_99/', './data/20cities/test_data_region_108/', './data/20cities/test_data_region_109/', './data/20cities/test_data_region_119/', './data/20cities/test_data_region_128/', './data/20cities/test_data_region_129/', './data/20cities/test_data_region_139/', './data/20cities/test_data_region_148/', './data/20cities/test_data_region_149/', './data/20cities/test_data_region_159/', './data/20cities/test_data_region_168/', './data/20cities/test_data_region_169/', './data/20cities/test_data_region_179/']\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "folder_list = ['./data/20cities/test_data_region_8/', './data/20cities/test_data_region_9/', './data/20cities/test_data_region_19/', './data/20cities/test_data_region_28/', './data/20cities/test_data_region_29/', './data/20cities/test_data_region_39/', './data/20cities/test_data_region_48/', './data/20cities/test_data_region_49/', './data/20cities/test_data_region_59/', './data/20cities/test_data_region_68/', './data/20cities/test_data_region_69/', './data/20cities/test_data_region_79/', './data/20cities/test_data_region_88/', './data/20cities/test_data_region_89/', './data/20cities/test_data_region_99/', './data/20cities/test_data_region_108/', './data/20cities/test_data_region_109/', './data/20cities/test_data_region_119/', './data/20cities/test_data_region_128/', './data/20cities/test_data_region_129/', './data/20cities/test_data_region_139/', './data/20cities/test_data_region_148/', './data/20cities/test_data_region_149/', './data/20cities/test_data_region_159/', './data/20cities/test_data_region_168/', './data/20cities/test_data_region_169/', './data/20cities/test_data_region_179/']\n", + "folder_name = [x.split('/')[-2] for x in folder_list]\n", + "print(folder_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "floor_divide is deprecated, and will be removed in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values.\n", + "To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor'). (Triggered internally at ../aten/src/ATen/native/BinaryOps.cpp:467.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 1\n", + "Iteration: 2\n", + "Iteration: 3\n", + "Iteration: 4\n", + "Iteration: 5\n", + "Iteration: 6\n", + "Iteration: 7\n", + "Iteration: 8\n", + "Iteration: 9\n", + "Iteration: 10\n", + "Iteration: 11\n", + "Iteration: 12\n", + "Iteration: 13\n", + "Iteration: 14\n", + "Iteration: 15\n", + "Iteration: 16\n", + "Iteration: 17\n", + "Iteration: 18\n", + "Iteration: 19\n", + "Iteration: 20\n", + "Iteration: 21\n", + "Iteration: 22\n", + "Iteration: 23\n", + "Iteration: 24\n", + "Iteration: 25\n", + "Iteration: 26\n", + "Iteration: 27\n", + "Iteration: 28\n", + "Iteration: 29\n", + "Iteration: 30\n", + "Iteration: 31\n", + "Iteration: 32\n", + "Iteration: 33\n", + "Iteration: 34\n", + "Iteration: 35\n", + "Iteration: 36\n", + "Iteration: 37\n", + "Iteration: 38\n", + "Iteration: 39\n", + "Iteration: 40\n", + "Iteration: 41\n", + "Iteration: 42\n", + "Iteration: 43\n", + "Iteration: 44\n", + "Iteration: 45\n", + "Iteration: 46\n", + "Iteration: 47\n", + "Iteration: 48\n", + "Iteration: 49\n", + "Iteration: 50\n", + "Iteration: 51\n", + "Iteration: 52\n", + "Iteration: 53\n", + "Iteration: 54\n", + "Iteration: 55\n", + "Iteration: 56\n", + "Iteration: 57\n", + "Iteration: 58\n", + "Iteration: 59\n", + "Iteration: 60\n", + "Iteration: 61\n", + "Iteration: 62\n", + "Iteration: 63\n", + "Iteration: 64\n", + "Iteration: 65\n", + "Iteration: 66\n", + "Iteration: 67\n", + "Iteration: 68\n", + "Iteration: 69\n", + "Iteration: 70\n", + "Iteration: 71\n", + "Iteration: 72\n", + "Iteration: 73\n", + "Iteration: 74\n", + "Iteration: 75\n", + "Iteration: 76\n", + "Iteration: 77\n", + "Iteration: 78\n", + "Iteration: 79\n", + "Iteration: 80\n", + "Iteration: 81\n", + "Iteration: 82\n", + "Iteration: 83\n", + "Iteration: 84\n", + "Iteration: 85\n", + "Iteration: 86\n", + "Iteration: 87\n", + "Iteration: 88\n", + "Iteration: 89\n", + "Iteration: 90\n", + "Iteration: 91\n", + "Iteration: 92\n", + "Iteration: 93\n", + "Iteration: 94\n", + "Iteration: 95\n", + "Iteration: 96\n", + "Iteration: 97\n", + "Iteration: 98\n", + "Iteration: 99\n", + "Iteration: 100\n", + "Iteration: 101\n", + "Iteration: 102\n", + "Iteration: 103\n", + "Iteration: 104\n", + "Iteration: 105\n", + "Iteration: 106\n", + "Iteration: 107\n", + "Iteration: 108\n", + "Iteration: 109\n", + "Iteration: 110\n", + "Iteration: 111\n", + "Iteration: 112\n", + "Iteration: 113\n", + "Iteration: 114\n", + "Iteration: 115\n", + "Iteration: 116\n", + "Iteration: 117\n", + "Iteration: 118\n", + "Iteration: 119\n", + "Iteration: 120\n", + "Iteration: 121\n", + "Iteration: 122\n", + "Iteration: 123\n", + "Iteration: 124\n", + "Iteration: 125\n", + "Iteration: 126\n", + "Iteration: 127\n", + "Iteration: 128\n", + "Iteration: 129\n", + "Iteration: 130\n", + "Iteration: 131\n", + "Iteration: 132\n", + "Iteration: 133\n", + "Iteration: 134\n", + "Iteration: 135\n", + "Iteration: 136\n", + "Iteration: 137\n", + "Iteration: 138\n", + "Iteration: 139\n", + "Iteration: 140\n", + "Iteration: 141\n", + "Iteration: 142\n", + "Iteration: 143\n", + "Iteration: 144\n", + "Iteration: 145\n", + "Iteration: 146\n", + "Iteration: 147\n", + "Iteration: 148\n", + "Iteration: 149\n", + "Iteration: 150\n", + "Iteration: 151\n", + "Iteration: 152\n", + "Iteration: 153\n", + "Iteration: 154\n", + "Iteration: 155\n", + "Iteration: 156\n", + "Iteration: 157\n", + "Iteration: 158\n", + "Iteration: 159\n", + "Iteration: 160\n", + "Iteration: 161\n", + "Iteration: 162\n", + "Iteration: 163\n", + "Iteration: 164\n", + "Iteration: 165\n", + "Iteration: 166\n", + "Iteration: 167\n", + "Iteration: 168\n", + "Iteration: 169\n", + "Iteration: 170\n", + "Iteration: 171\n", + "Iteration: 172\n", + "Iteration: 173\n", + "Iteration: 174\n", + "Iteration: 175\n", + "Iteration: 176\n", + "Iteration: 177\n", + "Iteration: 178\n", + "Iteration: 179\n", + "Iteration: 180\n", + "Iteration: 181\n", + "Iteration: 182\n", + "Iteration: 183\n", + "Iteration: 184\n", + "Iteration: 185\n", + "Iteration: 186\n", + "Iteration: 187\n", + "Iteration: 188\n", + "Iteration: 189\n", + "Iteration: 190\n", + "Iteration: 191\n", + "Iteration: 192\n", + "Iteration: 193\n", + "Iteration: 194\n", + "Iteration: 195\n", + "Iteration: 196\n", + "Iteration: 197\n", + "Iteration: 198\n", + "Iteration: 199\n", + "Iteration: 200\n", + "Iteration: 201\n", + "Iteration: 202\n", + "Iteration: 203\n", + "Iteration: 204\n", + "Iteration: 205\n", + "Iteration: 206\n", + "Iteration: 207\n", + "Iteration: 208\n", + "Iteration: 209\n", + "Iteration: 210\n", + "Iteration: 211\n", + "Iteration: 212\n", + "Iteration: 213\n", + "Iteration: 214\n", + "Iteration: 215\n", + "Iteration: 216\n", + "Iteration: 217\n", + "Iteration: 218\n", + "Iteration: 219\n", + "Iteration: 220\n", + "Iteration: 221\n", + "Iteration: 222\n", + "Iteration: 223\n", + "Iteration: 224\n", + "Iteration: 225\n", + "Iteration: 226\n", + "Iteration: 227\n", + "Iteration: 228\n", + "Iteration: 229\n", + "Iteration: 230\n", + "Iteration: 231\n", + "Iteration: 232\n", + "Iteration: 233\n", + "Iteration: 234\n", + "Iteration: 235\n", + "Iteration: 236\n", + "Iteration: 237\n", + "Iteration: 238\n", + "Iteration: 239\n", + "Iteration: 240\n", + "Iteration: 241\n", + "Iteration: 242\n", + "Iteration: 243\n", + "Iteration: 244\n", + "Iteration: 245\n", + "Iteration: 246\n", + "Iteration: 247\n", + "Iteration: 248\n", + "Iteration: 249\n", + "Iteration: 250\n", + "Iteration: 251\n", + "Iteration: 252\n", + "Iteration: 253\n", + "Iteration: 254\n", + "Iteration: 255\n", + "Iteration: 256\n", + "Iteration: 257\n", + "Iteration: 258\n", + "Iteration: 259\n", + "Iteration: 260\n", + "Iteration: 261\n", + "Iteration: 262\n", + "Iteration: 263\n", + "Iteration: 264\n", + "Iteration: 265\n", + "Iteration: 266\n", + "Iteration: 267\n", + "Iteration: 268\n", + "Iteration: 269\n", + "Iteration: 270\n", + "Iteration: 271\n", + "Iteration: 272\n", + "Iteration: 273\n", + "Iteration: 274\n", + "Iteration: 275\n", + "Iteration: 276\n", + "Iteration: 277\n", + "Iteration: 278\n", + "Iteration: 279\n", + "Iteration: 280\n", + "Iteration: 281\n", + "Iteration: 282\n", + "Iteration: 283\n", + "Iteration: 284\n", + "Iteration: 285\n", + "Iteration: 286\n", + "Iteration: 287\n", + "Iteration: 288\n", + "Iteration: 289\n", + "Iteration: 290\n", + "Iteration: 291\n", + "Iteration: 292\n", + "Iteration: 293\n", + "Iteration: 294\n", + "Iteration: 295\n", + "Iteration: 296\n", + "Iteration: 297\n", + "Iteration: 298\n", + "Iteration: 299\n", + "Iteration: 300\n", + "Iteration: 301\n", + "Iteration: 302\n", + "Iteration: 303\n", + "Iteration: 304\n", + "Iteration: 305\n", + "Iteration: 306\n", + "Iteration: 307\n", + "Iteration: 308\n", + "Iteration: 309\n", + "Iteration: 310\n", + "Iteration: 311\n", + "Iteration: 312\n", + "Iteration: 313\n", + "Iteration: 314\n", + "Iteration: 315\n", + "Iteration: 316\n", + "Iteration: 317\n", + "Iteration: 318\n", + "Iteration: 319\n", + "Iteration: 320\n", + "Iteration: 321\n", + "Iteration: 322\n", + "Iteration: 323\n", + "Iteration: 324\n", + "Iteration: 325\n", + "Iteration: 326\n", + "Iteration: 327\n", + "Iteration: 328\n", + "Iteration: 329\n", + "Iteration: 330\n", + "Iteration: 331\n", + "Iteration: 332\n", + "Iteration: 333\n", + "Iteration: 334\n", + "Iteration: 335\n", + "Iteration: 336\n", + "Iteration: 337\n", + "Iteration: 338\n", + "Iteration: 339\n", + "Iteration: 340\n", + "Iteration: 341\n", + "Iteration: 342\n", + "Iteration: 343\n", + "Iteration: 344\n", + "Iteration: 345\n", + "Iteration: 346\n", + "Iteration: 347\n", + "Iteration: 348\n", + "Iteration: 349\n", + "Iteration: 350\n", + "Iteration: 351\n", + "Iteration: 352\n", + "Iteration: 353\n", + "Iteration: 354\n", + "Iteration: 355\n", + "Iteration: 356\n", + "Iteration: 357\n", + "Iteration: 358\n", + "Iteration: 359\n", + "Iteration: 360\n", + "Iteration: 361\n", + "Iteration: 362\n", + "Iteration: 363\n", + "Iteration: 364\n", + "Iteration: 365\n", + "Iteration: 366\n", + "Iteration: 367\n", + "Iteration: 368\n", + "Iteration: 369\n", + "Iteration: 370\n", + "Iteration: 371\n", + "Iteration: 372\n", + "Iteration: 373\n", + "Iteration: 374\n", + "Iteration: 375\n", + "Iteration: 376\n", + "Iteration: 377\n", + "Iteration: 378\n", + "Iteration: 379\n", + "Iteration: 380\n", + "Iteration: 381\n", + "Iteration: 382\n", + "Iteration: 383\n", + "Iteration: 384\n", + "Iteration: 385\n", + "Iteration: 386\n", + "Iteration: 387\n", + "Iteration: 388\n", + "Iteration: 389\n", + "Iteration: 390\n", + "Iteration: 391\n", + "Iteration: 392\n", + "Iteration: 393\n", + "Iteration: 394\n", + "Iteration: 395\n", + "Iteration: 396\n", + "Iteration: 397\n", + "Iteration: 398\n", + "Iteration: 399\n", + "Iteration: 400\n", + "Iteration: 401\n", + "Iteration: 402\n", + "Iteration: 403\n", + "Iteration: 404\n", + "Iteration: 405\n", + "Iteration: 406\n", + "Iteration: 407\n", + "Iteration: 408\n", + "Iteration: 409\n", + "Iteration: 410\n", + "Iteration: 411\n", + "Iteration: 412\n", + "Iteration: 413\n", + "Iteration: 414\n", + "Iteration: 415\n", + "Iteration: 416\n", + "Iteration: 417\n", + "Iteration: 418\n", + "Iteration: 419\n", + "Iteration: 420\n", + "Iteration: 421\n", + "Iteration: 422\n", + "Iteration: 423\n", + "Iteration: 424\n", + "Iteration: 425\n", + "Iteration: 426\n", + "Iteration: 427\n", + "Iteration: 428\n", + "Iteration: 429\n", + "Iteration: 430\n", + "Iteration: 431\n", + "Iteration: 432\n", + "Iteration: 433\n", + "Iteration: 434\n", + "Iteration: 435\n", + "Iteration: 436\n", + "Iteration: 437\n", + "Iteration: 438\n", + "Iteration: 439\n", + "Iteration: 440\n", + "Iteration: 441\n", + "Iteration: 442\n", + "Iteration: 443\n", + "Iteration: 444\n", + "Iteration: 445\n", + "Iteration: 446\n", + "Iteration: 447\n", + "Iteration: 448\n", + "Iteration: 449\n", + "Iteration: 450\n", + "Iteration: 451\n", + "Iteration: 452\n", + "Iteration: 453\n", + "Iteration: 454\n", + "Iteration: 455\n", + "Iteration: 456\n", + "Iteration: 457\n", + "Iteration: 458\n", + "Iteration: 459\n", + "Iteration: 460\n", + "Iteration: 461\n", + "Iteration: 462\n", + "Iteration: 463\n", + "Iteration: 464\n", + "Iteration: 465\n", + "Iteration: 466\n", + "Iteration: 467\n", + "Iteration: 468\n", + "Iteration: 469\n", + "Iteration: 470\n", + "Iteration: 471\n", + "Iteration: 472\n", + "Iteration: 473\n", + "Iteration: 474\n", + "Iteration: 475\n", + "Iteration: 476\n", + "Iteration: 477\n", + "Iteration: 478\n", + "Iteration: 479\n", + "Iteration: 480\n", + "Iteration: 481\n", + "Iteration: 482\n", + "Iteration: 483\n", + "Iteration: 484\n", + "Iteration: 485\n", + "Iteration: 486\n", + "Iteration: 487\n", + "Iteration: 488\n", + "Iteration: 489\n", + "Iteration: 490\n", + "Iteration: 491\n", + "Iteration: 492\n", + "Iteration: 493\n", + "Iteration: 494\n", + "Iteration: 495\n", + "Iteration: 496\n", + "Iteration: 497\n", + "Iteration: 498\n", + "Iteration: 499\n", + "Iteration: 500\n", + "Iteration: 501\n", + "Iteration: 502\n", + "Iteration: 503\n", + "Iteration: 504\n", + "Iteration: 505\n", + "Iteration: 506\n", + "Iteration: 507\n", + "Iteration: 508\n", + "Iteration: 509\n", + "Iteration: 510\n", + "Iteration: 511\n", + "Iteration: 512\n", + "Iteration: 513\n", + "Iteration: 514\n", + "Iteration: 515\n", + "Iteration: 516\n", + "Iteration: 517\n", + "Iteration: 518\n", + "Iteration: 519\n", + "Iteration: 520\n", + "Iteration: 521\n", + "Iteration: 522\n", + "Iteration: 523\n", + "Iteration: 524\n", + "Iteration: 525\n", + "Iteration: 526\n", + "Iteration: 527\n", + "Iteration: 528\n", + "Iteration: 529\n", + "Iteration: 530\n", + "Iteration: 531\n", + "Iteration: 532\n", + "Iteration: 533\n", + "Iteration: 534\n", + "Iteration: 535\n", + "Iteration: 536\n", + "Iteration: 537\n", + "Iteration: 538\n", + "Iteration: 539\n", + "Iteration: 540\n", + "Iteration: 541\n", + "Iteration: 542\n", + "Iteration: 543\n", + "Iteration: 544\n", + "Iteration: 545\n", + "Iteration: 546\n", + "Iteration: 547\n", + "Iteration: 548\n", + "Iteration: 549\n", + "Iteration: 550\n", + "Iteration: 551\n", + "Iteration: 552\n", + "Iteration: 553\n", + "Iteration: 554\n", + "Iteration: 555\n", + "Iteration: 556\n", + "Iteration: 557\n", + "Iteration: 558\n", + "Iteration: 559\n", + "Iteration: 560\n", + "Iteration: 561\n", + "Iteration: 562\n", + "Iteration: 563\n", + "Iteration: 564\n", + "Iteration: 565\n", + "Iteration: 566\n", + "Iteration: 567\n", + "Iteration: 568\n", + "Iteration: 569\n", + "Iteration: 570\n", + "Iteration: 571\n", + "Iteration: 572\n", + "Iteration: 573\n", + "Iteration: 574\n", + "Iteration: 575\n", + "Iteration: 576\n", + "Iteration: 577\n", + "Iteration: 578\n", + "Iteration: 579\n", + "Iteration: 580\n", + "Iteration: 581\n", + "Iteration: 582\n", + "Iteration: 583\n", + "Iteration: 584\n", + "Iteration: 585\n", + "Iteration: 586\n", + "Iteration: 587\n", + "Iteration: 588\n", + "Iteration: 589\n", + "Iteration: 590\n", + "Iteration: 591\n", + "Iteration: 592\n", + "Iteration: 593\n", + "Iteration: 594\n", + "Iteration: 595\n", + "Iteration: 596\n", + "Iteration: 597\n", + "Iteration: 598\n", + "Iteration: 599\n", + "Iteration: 600\n", + "Iteration: 601\n", + "Iteration: 602\n", + "Iteration: 603\n", + "Iteration: 604\n", + "Iteration: 605\n", + "Iteration: 606\n", + "Iteration: 607\n", + "Iteration: 608\n", + "Iteration: 609\n", + "Iteration: 610\n", + "Iteration: 611\n", + "Iteration: 612\n", + "Iteration: 613\n", + "Iteration: 614\n", + "Iteration: 615\n", + "Iteration: 616\n", + "Iteration: 617\n", + "Iteration: 618\n", + "Iteration: 619\n", + "Iteration: 620\n", + "Iteration: 621\n", + "Iteration: 622\n", + "Iteration: 623\n", + "Iteration: 624\n", + "Iteration: 625\n", + "Iteration: 626\n", + "Iteration: 627\n", + "Iteration: 628\n", + "Iteration: 629\n", + "Iteration: 630\n", + "Iteration: 631\n", + "Iteration: 632\n", + "Iteration: 633\n", + "Iteration: 634\n", + "Iteration: 635\n", + "Iteration: 636\n", + "Iteration: 637\n", + "Iteration: 638\n", + "Iteration: 639\n", + "Iteration: 640\n", + "Iteration: 641\n", + "Iteration: 642\n", + "Iteration: 643\n", + "Iteration: 644\n", + "Iteration: 645\n", + "Iteration: 646\n", + "Iteration: 647\n", + "Iteration: 648\n", + "Iteration: 649\n", + "Iteration: 650\n", + "Iteration: 651\n", + "Iteration: 652\n", + "Iteration: 653\n", + "Iteration: 654\n", + "Iteration: 655\n", + "Iteration: 656\n", + "Iteration: 657\n", + "Iteration: 658\n", + "Iteration: 659\n", + "Iteration: 660\n", + "Iteration: 661\n", + "Iteration: 662\n", + "Iteration: 663\n", + "Iteration: 664\n", + "Iteration: 665\n", + "Iteration: 666\n", + "Iteration: 667\n", + "Iteration: 668\n", + "Iteration: 669\n", + "Iteration: 670\n", + "Iteration: 671\n", + "Iteration: 672\n", + "Iteration: 673\n", + "Iteration: 674\n", + "Iteration: 675\n", + "Iteration: 676\n", + "Iteration: 677\n", + "Iteration: 678\n", + "Iteration: 679\n", + "Iteration: 680\n", + "Iteration: 681\n", + "Iteration: 682\n", + "Iteration: 683\n", + "Iteration: 684\n", + "Iteration: 685\n", + "Iteration: 686\n", + "Iteration: 687\n", + "Iteration: 688\n", + "Iteration: 689\n", + "Iteration: 690\n", + "Iteration: 691\n", + "Iteration: 692\n", + "Iteration: 693\n", + "Iteration: 694\n", + "Iteration: 695\n", + "Iteration: 696\n", + "Iteration: 697\n", + "Iteration: 698\n", + "Iteration: 699\n", + "Iteration: 700\n", + "Iteration: 701\n", + "Iteration: 702\n", + "Iteration: 703\n", + "Iteration: 704\n", + "Iteration: 705\n", + "Iteration: 706\n", + "Iteration: 707\n", + "Iteration: 708\n", + "Iteration: 709\n", + "Iteration: 710\n", + "Iteration: 711\n", + "Iteration: 712\n", + "Iteration: 713\n", + "Iteration: 714\n", + "Iteration: 715\n", + "Iteration: 716\n", + "Iteration: 717\n", + "Iteration: 718\n", + "Iteration: 719\n", + "Iteration: 720\n", + "Iteration: 721\n", + "Iteration: 722\n", + "Iteration: 723\n", + "Iteration: 724\n", + "Iteration: 725\n", + "Iteration: 726\n", + "Iteration: 727\n", + "Iteration: 728\n", + "Iteration: 729\n", + "Iteration: 730\n", + "Iteration: 731\n", + "Iteration: 732\n", + "Iteration: 733\n", + "Iteration: 734\n", + "Iteration: 735\n", + "Iteration: 736\n", + "Iteration: 737\n", + "Iteration: 738\n", + "Iteration: 739\n", + "Iteration: 740\n", + "Iteration: 741\n", + "Iteration: 742\n", + "Iteration: 743\n", + "Iteration: 744\n", + "Iteration: 745\n", + "Iteration: 746\n", + "Iteration: 747\n", + "Iteration: 748\n", + "Iteration: 749\n", + "Iteration: 750\n", + "Iteration: 751\n", + "Iteration: 752\n", + "Iteration: 753\n", + "Iteration: 754\n", + "Iteration: 755\n", + "Iteration: 756\n", + "Iteration: 757\n", + "Iteration: 758\n", + "Iteration: 759\n", + "Iteration: 760\n", + "Iteration: 761\n", + "Iteration: 762\n", + "Iteration: 763\n", + "Iteration: 764\n", + "Iteration: 765\n", + "Iteration: 766\n", + "Iteration: 767\n", + "Iteration: 768\n", + "Iteration: 769\n", + "Iteration: 770\n", + "Iteration: 771\n", + "Iteration: 772\n", + "Iteration: 773\n", + "Iteration: 774\n", + "Iteration: 775\n", + "Iteration: 776\n", + "Iteration: 777\n", + "Iteration: 778\n", + "Iteration: 779\n", + "Iteration: 780\n", + "Iteration: 781\n", + "Iteration: 782\n", + "Iteration: 783\n" + ] + } + ], + "source": [ + "from PIL import Image\n", + "import json\n", + "\n", + "model.eval()\n", + "gil_path = f'/nas/tsgil/relationformer/gil/test_data_region'\n", + "if not os.path.isdir(gil_path):\n", + " os.makedirs(gil_path)\n", + " os.makedirs(gil_path + \"/patch\")\n", + " os.makedirs(gil_path + \"/seg\")\n", + " os.makedirs(gil_path + \"/graph\")\n", + "else:\n", + " if not os.path.isdir(gil_path + \"/patch\"):\n", + " os.makedirs(gil_path + \"/patch\")\n", + " if not os.path.isdir(gil_path + \"/seg\"):\n", + " os.makedirs(gil_path + \"/seg\")\n", + " if not os.path.isdir(gil_path + \"/graph\"):\n", + " os.makedirs(gil_path + \"/graph\")\n", + " print(\"The path is already ready.\")\n", + "iteration = 0\n", + "for idx, (images, seg, points, edges) in enumerate(val_loader):\n", + " iteration = iteration+1\n", + " images = images.cuda()\n", + " # print(images.shape) # [32, 3, 128, 128]\n", + " seg = seg.cuda()\n", + " h, out, _ = model(images, seg=False)\n", + " pred_nodes, pred_edges, pred_nodes_box, pred_nodes_box_score, pred_nodes_box_class, pred_edges_box_score, pred_edges_box_class = relation_infer(\n", + " h.detach(), out, model, config.MODEL.DECODER.OBJ_TOKEN, config.MODEL.DECODER.RLN_TOKEN,\n", + " nms=False, map_=True\n", + " )\n", + " # plot_val_rel_sample(images[0].permute(1,2,0).cpu().numpy(), seg[0].permute(1,2,0).cpu().numpy(), points[0].cpu().numpy(), edges[0].cpu().numpy(), pred_nodes[0].cpu().numpy(), pred_edges[0])\n", + " # print(images[0].shape) # [3, 128, 128]\n", + " # print(images[0].permute(1,2,0).shape) # [128, 128, 3]\n", + " start_idx = idx*config.DATA.BATCH_SIZE\n", + " for i in range(len(images)): # 0~31\n", + " file_name = file_infos[start_idx+i]\n", + " sample_id, x, y, region_num = file_name.split('_')\n", + " # img of patch\n", + " # NumPy 배열을 PIL 이미지로 변환\n", + " image = images[i].cpu().numpy()\n", + " min_value = np.min(image)\n", + " max_value = np.max(image)\n", + " image = (image - min_value) / (max_value - min_value)\n", + " image = (image * 255).astype('uint8')\n", + " image = image.transpose(1,2,0)\n", + " image = Image.fromarray(image, 'RGB')\n", + " # 이미지 파일로 저장할 경로 지정\n", + " save_path = f'{gil_path}/patch/{file_name}.png'\n", + " # 이미지 파일로 저장\n", + " image.save(save_path)\n", + " # seg\n", + " image = seg[i].cpu().numpy()\n", + " image = image+0.5\n", + " image = (image * 255).astype('uint8')\n", + " image = np.squeeze(image, axis=0)\n", + " image = Image.fromarray(image, 'L')\n", + " save_path = f'{gil_path}/seg/{file_name}.png'\n", + " image.save(save_path)\n", + " # gt node edge\n", + " gt_node, gt_edge = points[i].cpu().numpy(), edges[i].cpu().numpy()\n", + " # pred node edge\n", + " pred_node, pred_edge = pred_nodes[i].cpu().numpy(), pred_edges[i]\n", + " gt_node_list = gt_node.tolist()\n", + " gt_edge_list = gt_edge.tolist()\n", + " pred_node_list = pred_node.tolist()\n", + " pred_edge_list = pred_edge.tolist()\n", + " data = {\n", + " \"gt_node\": gt_node_list,\n", + " \"gt_edge\": gt_edge_list,\n", + " \"pred_node\": pred_node_list,\n", + " \"pred_edge\": pred_edge_list\n", + " }\n", + " # JSON 파일로 저장\n", + " with open(f'{gil_path}/graph/{file_name}.json', 'w') as json_file:\n", + " json.dump(data, json_file, indent=2)\n", + " # 정답 사진, 정답 Seg, 정답 노드와 엣지, 예측 노드와 엣지\n", + " print('Iteration:',iteration)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-11-21 08:33:04,647 - Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABV4AAAJUCAYAAADtgT1jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABcSAAAXEgFnn9JSAADhZUlEQVR4nOz92bNk2XXn+S0/5/h45xtDRs6ZQBKVAMkmE6yqHlRd1l0ylUxlaFnrTaZ/px/1J+hFjzKTzOqFVjJZU62uYrGL1kUCHIEEMpFzRsZ45+vjGfQQIBHrtxbi3gKdSL/E9/MC2x77TPvssz1wwvO3el3XdQYAAAAAAAAAWJvi6z4BAAAAAAAAAPiHhhevAAAAAAAAALBmvHgFAAAAAAAAgDXjxSsAAAAAAAAArBkvXgEAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1owXrwAAAAAAAACwZrx4BQAAAAAAAIA148UrAAAAAAAAAKwZL14BAAAAAAAAYM148QoAAAAAAAAAa1b9XTbu9XrrOg8AAICvXdd1X/cpAAAAAPgHgl+8AgAAAAAAAMCa8eIVAAAAAAAAANaMF68AAAAAAAAAsGa8eAUAAAAAAACANePFKwAAAAAAAACsGS9eAQAAAAAAAGDNePEKAAAAAAAAAGvGi1cAAAAAAAAAWDNevAIAAAAAAADAmvHiFQAAAAAAAADWjBevAAAAAAAAALBmvHgFAAAAAAAAgDXjxSsAAAAAAAAArBkvXgEAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1owXrwAAAAAAAACwZrx4BQAAAAAAAIA1q77uE8i8+1u/FT4r5BVx0eu5dtXvh216RenaTduFPo0eR/ZrZtav/DANhwPXHkjbzGw08uczHsU+VeUvqiiv8R48uQY1Ho9c+xtvvhb6/M5v/7ZrD5Lxe+Xe665d9mU8mzZsc3F56dp/8Af/Y+jz4OFDv58uXtNQxuvN195w7X/xz/+bsM1yNXft/+F/+L+GPh998plrJ5dti8XCtXXIu3jZptOmKMvQ52B/17UPDw9Cn//+v/vvXPtf/Lf/W3+c5N9KOktOSLRt7dvJmM8XU9f+yUc/dO1Hj/x9MzO7feuWa3/rG/HZ3dnac+0yGZvkdJym1SfVrCz8c7lYzUKfP/rj/8m1P/v809Dn8GDHtUfjoWv3kjXh7NTP8+WyDn30OrP1p5MLj0eK64I+Yz/96Sdhm9Ozc3+c5FnVIZ3P4zUcHZ249mKxdO1+8gDpZ00d751ed9WPX0X6ma7Dg36cR6twrPi89Pv+s1Gyft+565/N8cgfu06uabH0Y7y9sxX6lKW/w2WVXHfl+8znfsy3JuOwze6Wn7NFGWfSauXvb7yCOI+nl/6ZWsz82mhmNtmauPbF2UU8du33e++lw9CnqPz9fHp05trnZ359NzP7f/0//9/hMwAAAADYJPziFQAAAAAAAADWjBevAAAAAAAAALBmvHgFAAAAAAAAgDXjxSsAAAAAAAAArNlGFtcaTibhs1qKc3RaO6SKRV60OMvWIF6uFgbRok5msfBUX4qAJLV3rKm1mFHso9prdNI35VlZpYUUUZlJQZxn/LFmSdGUx08fufa9e6+4di8pBVT2/Bnevn079Blv+eJf5xexGMu3vvm2a7/91jddezr3BYbMzJZShOb1N14NfR49fuzag2H8t4eJFFeay/jN56uwjRYLyiyXsl2yje6nkzlxOfdFk8zMmsaXydnZ2Q595kt/fx8+jIWydvf9drOZL7b18NGTsI0WGSp6H4Q+3/rmu669tbUT+uh1llIYr9Dqehafu2w+6jMV7kHy2dn5VHrE+1TIPM+K++nj3LTxaS30nJO1RD/qtFBaE4ti6bOga5ZZXEO1IKCZ2d6uXx/nC3/dq1VStKvzc6I/yO6dXlW88EoKRA2kKFZ/EK9JS0ZVSQEu3e94lIxN45+X+YUv7JQV19L6ZYsimTelfpYUy5M1YLny87Pfi8e+NH+/s2dB57l+T5jFonv1yh/r5Diu1ZcX8rwkS6Hu9+jpWeizkPM7PfXHOruI31EAAAAAsOn4xSsAAAAAAAAArBkvXgEAAAAAAABgzXjxCgAAAAAAAABrtpEZr/deeSl81kmOYSk5fcORz+U0MxsMfGZhmeQc9is/BF0SUBfz8nyftkny/mrfp8iCYHtyPr0sJ9R/pudSZjmhcj7Jka0s/XWXSYbmw4cPXPvu3XuuXZRxz7s7Pr/z9957L/S5/+C+az9+8ij00WzOWvIIs2xbnRPf/vY7oc/JiT9WmeQwap7wY8kj/Oqrp/Hgen+T+6IZi/Mkb7Tt/JV1cqXn5zHjdSn5rePkWWglX3Q6ixm5f/L9P3Xtv/yrv3LtR4/idQ8kR/mNt94MfZ4+OXXtt96Ifd75hr9XjTzvn33xedjmlVd8hm8+z/0z9uZbL4c+97/wub9/+Ic/cO1Rkvv83ne/5doHB/uhT1e/+Nk1M6tbXSeSHFiZ1/osaPvZwTUzN8m/bXwfzVA1Mxvf2fPHWvrM13PJPjUzu7j0n+k6bBbno7bNYharZrqOx3Ge68pQJv+0OB76Obu7HfczlDzw5VJzsuPz3dT+eZ5dxGztUjNnQ1i5WSNhsX0dvybudzX328QM3Zg7fnkS81p1PmrebB3GIa5JmgtsZiHw+PQkrn21zMfZQtbLeZZVDgAAAACbjV+8AgAAAAAAAMCa8eIVAAAAAAAAANaMF68AAAAAAAAAsGYbmfH6r/6P/zJ89slHH7n2owcPXTuJ1EwzH38pkpen+XllcqSq70+oSTIMdT9ZDGwnGYAhJzLZr+YlDgcxo3Jvb9+1d7Z2Q5/ZzGf3HR8/ce1Bst+nT49c+2D/IPRZrXxW31tvxszPsvBZiIWENY6GMZdxMtpy7W9965uhz2J57Peb/NOD3pe/+ms/9776yl+jmZlpNmsX70td++zd6TTmY2q+7Hw5c+1bh3E8e3IRWZ7wqBxJn3jh//O//SPXPjo6ce3sfs9m/l7+yZ/8Zejz45/48fu97/5u6DMe+1zIe/d8zvPh/n7YppL81rqJWaeabVolOc8PHvrs2qdHPvtyMolzbbGQHOXs4U1yQJXOvyzmuWt1bsnaUseMaTVfxExNzRLtmmSNWvrr0nW2TRZezXTN5o2e83S+CH10HdNI6SrJrd0e+2OVScjrttzP0TB+Dc4Xfl7XMjaz5Hx1AS+TZ0yXa80uf7Yfv1283/E+9SUGVrONzeJszDLPZ+fTF+5Hc7TNzAYyxkM9GYvj1a/i2Czle2ElebK9NAMdAAAAADYbv3gFAAAAAAAAgDXjxSsAAAAAAAAArBkvXgEAAAAAAABgzXjxCgAAAAAAAABrtpHFtQbbW+Gz7X1f/Onp40eurYVizMxMPsoK4ITCNdkJ9XyfVnpp8RMzs1aKK2nRpOx80rfgcso9LdiSFHHSszk6OQl9FnNf2OnW4a0rD/6jH/+Va3/zG+/EY3f+OrPiNm+9+bY/l8U09NFiNluTbdcuyjh19bNbh7dDHy1M8/goFsrSe3ciRaa2tnyhKjOzldzf4TAWFCorX3RmNIpFm84vz1z7s899YapX7r0WtplMdvy5JAV76pUvrnQxvQh9ZlJQSIsFZfM8PlKxz/TS398/+Y9/Gvp88tEnrv1f/hf/1LX/q//8vwjbDOWaFlKIzMxsubz6up/K/e3kGtomFq8Kz25apU2fzWT8wn7jfkKBPemzs+ufDbNYFGk2i8Wgluava5jMx17P70enQHa+J2eXrn1xGZ/vfuWf1eEgFnrSAkxd6w9eJ/dFaz+VyX1ZydpSXy5Dn+lM5pLsZ5kUuCpL/3zPFlmBPT8fe0mxqqbW89HnMF7TaKnfSbFwn65RWXG/xVzXb38Ny1Wytmhxt7P4HPYKf7+ze6cF4BrpUyTF1AAAAABg0/GLVwAAAAAAAABYM168AgAAAAAAAMCa8eIVAAAAAAAAANZsIzNes9zS7R2fY1lKRuBqGfPqCs0fTDJeVZrnqG3dTxbvqBul4bFXHMjMWsmg1cjC9Irkw4tpzNy7mPocxqIXMxZ3d32u7mrlswdHo3HYZjSauPaToyehz2zmMx8vL2Pu5jvffNe1hwM5VvZPBq2/d4NBzGJdTn2fn/7449hHs0NX/uYd7O+FbY5PfDbrN995K/Sphv58sszh+48euPb2xz538/atl8I2Q7nu+TRmaj556u/DYBAzaF959Z5rX1zIHEkyFvWTpo0TXXNBqyrevGXrx/zf/Yf/xbU//PinYRvNJe7a5Nkt/H63t+OSN730a0fIfU6ybXUssnvZC6OTjY3/rCjic6h9etJnT/KvzcwmEz/Xjo/OQ58Lue4sr1XzO2czv81yGfNRB30/xqMk73i18vvtV3H8qspfZ09ya+skZ7Xp+bEqk/32WslrXcbc0sVK54BvV1W8Jl2Ulqt4v1eNP59mEY+t3389WfRnyX413LZN5uxy6cdclrln5yP5sZeSf3uZ5MJWmic8j+tPKXO2P4jPoWa6rsL95d+JAQAAANw8/D8ZAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1mwzM14BAAAA/K379+/bgwcP7Pbt23bv3r2rNwAAAPh79uDBA3vy5Indu3fPXnnlla/7dDbSRr54HfRiYRAt5KSFk2YXsYBU1/PFOcoy/sB30JeiH9Uw9NnZ3nJtLTr1008+D9vUnRQ7KWIhmE6K7WQFeopf4kfJWtRnMV+EPk+fHLl2/VYsTLS3e+DaT54+cm0tQmQWC8EM+v14gp0f46zmWV8K9NSNL0JzeRELcjX11X32Dw9du6jiI7C49HOploJRei5msfBYVtwmihe+XPqKN/OFv3cPHz8M2zx+8ti1Z9N43T/64Q9d+7v/+J+EPnfv3Xbt8uk1Krl1ofRc1klacWxCISqZFMcXsTjU0dmp30Qrz5nZq/f8/a5PY3GgiwtfDGg08nNiezsWaRuNfHGl7NmNYp9QPuga00aLENWr+Ow2TffCtplZWfpns17Fed3IM34pBbm2tuJ6+eqrd1374jyO+fGJv59aRPDZsX17UPj7km2jtICYmVlZXv21t5TCTlrvse3iWNUyxsNhHJuVrB1NHe9LJd9JlaxRWqjKzMzkOzOpT2myPNrqGnNia+LbWqDLLBbPSxd0+e4tknuwkkJuCyk8puMA/Lq5f/++/ft//+/NzOzDDz/8ms8GAADA+/DDD+2f/bN/xsvXBFEDAAAAwAZ78ODB130KAAAAL8TfV3K8eAUAAAA22O3bt6/uBAAA8DXi7ys5/ts9AAAAYINppuu/+lf/ygaDwS/oDQAA8PdvuVzav/k3/+Zv22TQ5zbyxeveZDt8Vtc+z/E1yY14+VZ8s354sOfau3s7oc+DB/dd++wsZklWlf9h8Jtv+GM/fPwkbHN6fOb3keTL1pJRGHIun33odJ3mZSZkmyy78dETf86rZhX6bMt9qCT/T8/FzGw+8+O3TI49mfj7cOfWy6HPYuozU2dTn9X48FH8Cft87rNZtySb18zs1ddec+0sN7Av91sTFc+PYoZqr+e3ybIbwydJEKPm5i4k43XQj/8nayh5o5pJbGY2nfoc09Uq3u+YUyrtJFMzZNkm+Y663ywPNeS+SnZskeRadkmmayBd+lXMHJ6MfBbnm2/6L4u33no1bHNwENeoq2UZzip7ouWZD2OeZH4W/lizebzflxf+mUpzia+YAqPk//RvTXwm7nIV543mbbdtPPYqZNf6ZyGbRz3JOs3WVM1oziJJ6zpmmT6vWWbn6/ebrY/6PdBUyQxo/bFLybbVjF8zs9nMf5bF32rWd9vF/ZSFfz4aCdotkmeukLlWlnE+xnU2y5ctX9jW3G/g191gMODFKwAAwA1A1AAAAAAAAAAArBkvXgEAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFizjaxW8erLb4TP3n5NCgh8xzeb1hcOMTPTuiXT+Tz0+cmHH7v2/YdPQ5+29oVpbt+65dp7+/thm7NTKcDUxkImnRaUSV6DxxIkWgkm9gi7SarHPD069qeXFMHauuWLkw0HvgjRybkvIGZm1peCKMtlrPKyPfHT7uTkNPbZ2XXtQakFzt4K2/y7f/v/de033nwz9Hn1VT+3RuNYiOrJkxPXPj2/dO1Y9CcWf2qT+5IV2wn7kfEr5N51Fo89HvliRkldHfvywUPXPr2IBcKaWooOSdGcrs2KGfl21yWVikz7XD0OpkWSrrFJeiwZjO3tcehz+7afaxfnF9KOBfd2dvx+BoOkwNUVtcrSD5ML1eHqSzGVwSDOicsTf84nJ/F+6zzWgleZsvLXOZS5Z2b29KlfFxbLuLbodS8WsY9MP+v3dYzjWGkBpiIZdC3KlRVuW0qflTwbq2Uccz12lRSZ6smxiiJZv7WAlZzLxWX8HtNiYMNhLCKnz+ogKSwYvyukMF4ynlrIazKO+9UCXEktNRvI94uuE7OZLxAIAAAAADcBv3gFAAAAAAAAgDXjxSsAAAAAAAAArBkvXgEAAAAAAABgzTYy43U4iPl0o77PEhwMfPtiFnNC23rp2mPJkDMz+2//+T937f/fv/t3oc+HH/7UtY9PfYbhznbMOQzRjb34jrtXxJzA4Dp5mLqJtDVfz8zs9Mxfw9HJcehz96W7rq25q+//5P2wzW+8845r72zFsbl9eNt/kGTQDvp6r3yQ4HK1MvV7//if+n1IFqaZ2d7evmu/dO/l0OfLLx+49nzhj5XfEp/d2NTx3l6dzhvzHYdDP35Vlssoey6THMaFZPg+/vyz0GcWMpAl4zXJKNWcYs3PzHQaChkPFbdJDq73ITt22/j7MJ/OQh99Po6P/FqyXPh1xMzMJL/z9dfiPOrCHU7yRq/TR9cS+feyToNszWx64fMwF8k16Fxrk+BNzTadjOW51DxSMzs59ZnITROfhbr2x2q72KdpfJ9h68d8shXX84HkwJbJ2td2Mn7ZdTe+z3wu3yXjZM2Xe9ck81yfzWwt6fX8Ncxn/thPjmLm8HTq+2SP4Xjk147d3ZhvPRz6NVPPb76M82jQ99/XXXIv25APnS0m/jPN9G3bjfzrCgAAAAC8EL94BQAAAAAAAIA14yckAAAAAADgxuu6zur337flD35g7empFXt7NnjvPaveffda/3UeAKwbL14BAAAAAMCN1nWdzX7/9231/e//7Wfto0dWf/CB9b/7XRt/73u8fAXwK7eRL15LyU80M5tK/mS/8vl+VRkvZaE5m8l+D28duvYbr70S+jx8+FCO5fdz+3A/bFNVmk8X8/56mo+YB/5Jn9gl7vfqTTTP84uvvgx9fuOdb7r2nTs+m/Xk9KWwzeHhHdfulzFntZRMQB1Ps5hjqZmARZKP+9JdvXfxyovK7/etN98Mff7sz/7C70XzRZMva80JzXJ1VdZDczcryTksshxTyfgsesl4yqQYDWJG5XIoeaiSC5pls8Ypm8xzOeck7jjmtV4jX1b7ZOra5/OenS9Cn9Mzn5nZK/0JLiUf18zs7MRnJJ/v7YQ+q5Ufi6ofs6v7Yd3Ksi99U9eSbG0ZDv2xDg62Q59a1sfFIl7ncun7aH7nmeRdm5nNZn6MmyaeX1H4OZqtAUXfj4XmOhfzZGXr/HhqTuyz/fjz6ZIx7ySTtJb9TKeahxxlud5lyMTNsov9WGju6kt3D8I2T4/8fTg7j+c3l3vZO7+Mfeb+3uk1ZPdSr+ByGueRPt/ZmDe17ttvVMUpAgAA4NTvv+9euj5v9f3vW/+dd6z/7W//is8KwK87Ml4BAAAAAMCNtvzBD/5Ofw4Afx948QoAAAAAAG609vT07/TnAPD3gRevAAAAAADgRiv29v5Ofw4Afx948QoAAAAAAG60wXvvmVleOuX5PweAX6WNLK5VZIU3pNDGvPaFf7LiWlb4Ptl+e1IE6ZvfeCf0ubi48Oey9IVLhoNYQGprMnbtlRb6MrNSivi0SeES1cm3iLaffebbWeHGuvHn8/DRo9Dncu6Lr+zsxAI94dha6KefnJ8UYCosjl/kLyIrxjNrfPGderUMfaZnM9fe398PfYZjX3hKi9ssl/44ZmadFLhKBz18lBXW8eO1lGs4PY/FjLT40+HhrdBnUGlBuHuhz+zTz/y5hB5ZMSvf6zpFxUKxsmzXMn5ZUTEd8uxZ0It4+eU7oYvez48+uu/a02m835Mt/yxkz8Zy6e9LHYoHxXPW9ehnn/qWFivL7kvPH2t7Kz5js6kvpNR1cQ1tW/9ZXwpeNXV8xkL9qOTf97T44HgUz69u/PjNZ76d3e/FSp6f5Fmdz/05axE0s1hUqt8fyJ8nRe5av6ZqYTczs2IoRSGrqyvNxXOJxx4N/XienyffJTJcq1XyhMt16bHGY3/+ZmZ17e/Lcnn1PK+qWGiubbWPnNs11hYAAPDrrXr3Xet963fMfvLn4c/63/2uVe+++zWcFYBfdxv54hUAAAAAAOC6er2edf/4f2cf/MHY7hx8YsPhzHZ+864N3nvv2UvZ7McxAPD3jBevAAAAAADgxmuWnR2fv2rH56/a6Hbf/uv/yz/6uk8JwK85Ml4BAAAAAMCN1yx+Hl9UDnndAeDrt5G/eG2TdMlhXzI9JU+vSDJeK8lQLYuYC6rBd4NRzJ77/IuvXPvy/NS1D28fhG32D3zFxOPT89BHsxnTvFZta58017J3ZR/95OnJcehzfHTi2tuvv+ra/UHM+1stfX7iYBj7tJIJuOrFLMTF3OfoNpL3eJScr0Qh2unpSejTl2zJydY49Ll757Zr67wZDOMcOTk+DZ8pHfPsP3RpJSO3k9zDXvJvJZqNaNo2s1YyfYfDUehTSjhnOL8kY1HPL0uG1T2lU1YCW3sxKDTZ5urnR7NiJ9tboctbb/l5/ejhiWs/fPQgbHMp+ajZf7ak49n2kuzLa/3nTi/O0T09jbm/jx4+dW19Ls1idvFwkGWxjqTtn4X5zI/Dsz5+P6PkedF71TRxDVit/Gd63Vm2dl37/V5ezpM+kjGdfC9orqr19B7EbZYyxk0Tc711/IoyztlGrqG39Net42Jmtpj79VHXETOznsy/thevQa+r39fv1bhfvaZsSusaVSTPd1X5Pjofyyr7/gYAAPDaxc//vlIMiRYA8PXjn4AAAAAAAMCN1zz34pVfvALYBKxEAAAAAADgxuPFK4BNw0oEAAAAAABuPJfxmkRpAcCvGisRAAAAAAC48Zrlc794HfG6A8DXbyOLa21P9sJnVe/Fp9p2sZDJqvHFTrqkMIjKig7t7Gy79sWFL5T1x3/8g7jNvr8GLbRjZtZIgZkuKUwUixeJpJJJ+CSt4uT3e3QUi1W9/8H7rr21NXHtnW0/LmZmT46PXLsMxVnMjuVYk0kscPXw4UPXfunOS649X0zDNrdv+6JYWcGjxdzPiadPH4c+QykItrU9lj+P17Rc+P1mxw6fJMWgtOhMWfrCRHt7+2Gbne1dOU6cawcyH8ejWPRMixfFa4jnGy8zKcAVPom00Fw+aV987F5SLEiLdBVaNMliIaJbdw5d+4sv/Zw2Mzs58sXU2iYpnCUFw7RtZlbLvepfK/9fLzz2ODzwc2K5iEWmGi3clqxRi4UUcpKbmRU8Wix8wa1FUlRsrIW9RrFQVrXw56NrYbY21rUW5IrXNBzqOSfPqjwL8TLjNZWyzWgUv0tGY3+dXRu/t7To2f6hL96YFZFbzPz9nTyNxf50nmcFwkp5PgopeJWtWfocDgZxfWylEF7Ri/spC78maXEyLdoGAACQaefPFdcaUFwLwNeP/ycDAAAAAABuPPeLVzJeAWwAViIAAAAAAHDjNXNevALYLKxEAAAAAADgxmuWzxXX4sUrgA2wkRmv4/7kyj6t5CX2uiy/xX9Wr+psT75Vx8y9euX7/PSnn7v2+fll2ObV1++59sF+zEPVmLuYc2khfjDk+7VJtmRxdV6m5nfO5jED8kcffuDah/v7rn1XclfNzD795C9de1DFKVbJZ2UZ+2im62LlM1TPTn3OrpnZD//6x679048+CX0ePPDZsYvkuscTn6s6GPgsRM1CNTMzzUaMPcL9zTJ9W7m/bevnbJbV2Y63XLvfj9mNv/fd33PtmeRwmpn9xY/8+F0jEjlmpia5m9f6JAbgXtUhkYyn5oImGZW1PPNjyRz+7f/sO2GbvuRN9rLsWMmd7rJr0BzY5FnVnNLB0M/Pey/fDducnPiMz7PTuN+m9nMry/xU06mfN02yXqos33qy5fM8B4N+6LPs69z37dkirudF6a9haxzzo02eX83DNTPrS6jrSsaqX8XzbXQtTnJMBzJvRknWci155ruy7m7v+OfdzKyR9fHx/Yehz2zu82+bJJdY56PJ+tO02XeoV5ZxroU1PsnA1ud3tdTzvXquAQAA8ItXAJuGlQgAAAAAANx47XMZr8WQ4loAvn68eAUAAAAAADdes+AXrwA2CysRAAAAAAC48XjxCmDTsBIBAAAAAIAbr1lQXAvAZtnI4lpaOMssFvHpumsUden5AinzZhn6fPHFl6797/7wP4Q+f/EXP5Tz838+3o7FTrRwUiyzEusFacErM7M2FM/SjbIdJ58p2U6LEJmZzWe+kM6XD79y7f39w7DNZOILoy2TgmZPnhy79meffRH6fPK5/+zhw0euPZvGgmYmc+LO3Xh+r73mP3vy+Enos1r5oi6PHp9Kj/gFXkkBoe2D/Xh6V7TNYuGuKhQeS4pD6bxOihl99eCBa5fl1YWUwlS7xvxMU5S0YFhS4Cru+xrPjxany2pXSaesQE9d6zPmx+//9N//H8I249HItf/0z/449NGCTFnxKq1DlD/OL545WWGqgZzfYB7XPpPiVdn91QJRRenHZrmIXyE6xoNB7FPKet7IM/esjz8fnbN7u7Fw1kru5WqZFIOS75cimV19OeVK7l1VxXvZdnJN1yhe1dTJdUvxtKWMTVbQrJJiX5PkO6k/8seez2OBvUYLWq302Y3H7uSalsvYR4tyZevPWK77/NIXErxOITcAAAB+8Qpg07ASAQAAAACAG691L14prgXg68eLVwAAAAAAcKN1Xed+8Vrwi1cAG4CVCAAAAAAA3Ghd07lkJ6IGAGyCjcx4XSxm4bO+5BjWjc+iK5JL0YzSP/2TPwt9/u0f/pFrnxyfhD47uz4vrz/w+XRllWQYShZillHZkyxOzU80y/Mw3X6TGMHr0OzLzFxyIU9PT1z78WOfG2pm9ulnPjP3X//r/0/os1z5/Y4no9Dn1u1d1/72d1537a3RIGwjsZG2u7sd+mgw6M5OPPb52YVrP3zkM2kXizjopYR1bu/vxWOrJFNTs4yLUrMlY55nL2SHxnv70cefuPbu3k7oc2UucTJn9CPNe/zZGfpWct36Uadpp+l89X1iHnLMzNV1xMxsNPZzoD7x68af/9lfhW22tn2+aH7dKsu29fe7LOLY6KVXI7/NIMsblbGolzFL9PJiKtsk2aGSMVyN5FhJNvTZwj/f0+k89JlJnuegSnKT5bqKwm+T3e9OPqv6cWx65j8bj+KcGMr5LeSaBoO431oySJPhtELGs5/cu2ro17ZCv1+S/2JOc9GzuN5Cvm8Go2Hos5QNG8kpns5iZm7Mio33ZSVj09cQXTMbD/2auZKs2FmWUwwAAPCcZu7/bsqLVwCbgJUIAAAAAADcaM3S/wMwGa8ANgEvXgEAAAAAwI3WzH/+4rVXmhXJf1UFAL9qrEQAAAAAAOBGa5/7xWs54FUHgM2wkRmvJ+ePw2e3D+659kpyQj+7/9OwzQcf/sS1/+P/+r+GPl3nM+tu3dkPfTRnM+SjJoF618rHDL2yfEcN0bx6vybnm2Vqdo1kAia7qSXX8OLcZ0L+9fs/DNucX/h81JdePgh9bt3yWX6vvnI79NEMxXAJyflqnybJgFyt/Ge378TzG4999qHmES6TvMyY1Rm/6MP9Tq5Bs0JXK3+suo4Zi5r7WoXM1zgWH33ycehzcXnp2jpvrhGzmn0QZTvqdLsQ+prtyG+RzHPNSG6bOCf0/r77G99w7e+8+zthm5PTp679yacXoc81Hu/wWXYN2kdza4dbMaNU86KznFXNJN3b3w19PvzgM9fuJLhUM0DN4jWskuewbK7IEzaz80t/zoOB389sFjM/+5KHurs7CX0033iU/KW8lDVUM0qzPO6x5ML2Cs0+NWuaJPhVtJoV2/nr7O/GfOZ65Y81PTuN+5VnoRpthT59zZeVcbjIclYXfg6sVvEadfyGSdZyJc/hcODb80UcTwAAgOc1i5//facg3xXAhmA1AgAAAAAAN1rzXBFkCmsB2BSsRgAAAAAA4EbzL14prAVgM/DiFQAAAAAA3Gj84hXAJmI1AgAAAAAANxovXgFsoo0srvWjn7wfPvsn/5kv/NJKNajHZ0dhm2XPF/QYbY1Dn8a08EtWBEto4aSscFZaicjrSdWcrLCOFm3S4ktZYS+TYjZhGzMbjXwRldtS8MrMbE8K0/Qrfy7zpNDK3t7Itd94/U7oU1VaOCuO1SoUsLq6kJKOeVrIRsZT74FZLMCkxZd6vVhcq58UiwmHlnaXFmV7cZGp2TwWSTp66gs93boVi5W1jRbsiXPiF1Sw+oXnYhbHPBtP3W1671rtdI0Cdt01CsStfOGf8/PL0Of81BfG2try23z8SVyP6toX+mmaWGQqzNlrjE2bFKKKRc6kYFgb/1JZyxxudXwtFqIaj2IhqrffetO1V7V/5j//3BffetbJPx9lPxZ7MymctLsTi9xNL2au/e1vf8u1t7djkamnR/574OAgFgy7PPeFp+azOCes889LWfrnO6nRZoXcl4kU6TOLa1JyW6yVuXR8dObaB7f3wzZarGo0StYjmX59+Q4wM1tI8cFez9+n7Z3tuF+5puUq/rVCr7vfT4oPytzXYlt1ffV3KgAA+PXWPvfileJaADYFqxEAAAAAALjRmsXP/6GWX7wC2BSsRgAAAAAA4EajuBaATcSLVwAAAAAAcKOR8QpgE21kxutPP/00fPbqy6+79r2791y7LGKO4HDsMwvHWzGf7nI6k09ijlxP3k93phmq2TbX+Be2q2MsrSr9hyEKMwm21PzWqoh9bt/ymYov3bsV+pydnbu25mXu7W2FbQq5D20yNk2jOYKhSxib4oqcy+z82jZmvPaKqzNeDw59LuRvfOst1/6z7/8kbLNc+FxLvUaza6UHW1H68xsM/L0sini+i6Wfw1l+ayn7fel2zIHtzOdjnp/7/TZ1dk16DcnNDOG2SZeQm3zVceKOsx6N5EbOLvV5N3v02GfkHmjG7zCuLX3JLc3mWrjwqy8hpdfek7mfPQuaFatZ0WZxfdzZjZmpOzv+WbiU8Xvy9EnYppb5V45jlqju9+3X3g59Hnz5pWvvS370b/6mz3w1Mzs7n7r24UHMjv2zH/zAtR8tF6FPoZmunX++q+Q57Jnk/CbfSaOhHwtds8ziGnp+6c+vSvbbH/jPhsOYL9uTNWA4iZnn/bA2+78i9Mt47MeP/PNzcR6fsbbx4zdOMmhv7cl83PHfLw8exhx3AACA57kXrwNevALYDKxGAAAAAADgRnPFtUa86gCwGViNAAAAAADAjeaKa/GLVwAbgtUIAAAAAADcaC5qYERxLQCbgRevAAAAAADgRmuWZLwC2DwbWVzrIhS8Mvvos09c+/bhoWtr8SAzs6Lyl7e1E4trPX3si8Nk9W+0eE2oFZQWkJJiO20sTLS944ubbG9NQp+xFGMZ9rW4STy2Fv7JCnC1cn7zWRzzkxNfXGsxn7v2y0mhlbLyRVOSoQmqKu5H9aVPNuZahEgLK5mZhaFIKnsNKl/EZzLxhWoOb8ciRJ38G0aZXFPvGgXC4kf+GrYmcY7s7flnoSriYz2UeTQej0Kfx0enLzy/UADLzDotKvVL/sOyHiuMTTaR0qpsL95sZy+uAd/a8WN6duGfheVyGbYZT/wcqJPCY2Y6Nlc/DGkPqajXym0okrGpSj8Hqireu6rSeRLHs5D9jEb+WZhNfdEkM7MnD89cezCMhZQmpV/7em0c48nEz9nT0xPX/vDDH4dtzi/9GvVRck2rlS9WtbUdiwS2WkxLxior5ti1Vxf3G0+06FW8d8uF30+98uei64iZWSefFVUc81KuISu4Vpb+fLSY33wevyeePD72fRbxXur3zfl5vIbdXT8n3v32W669sxvXrD//sx+FzwAAwK+vZv78L1558QpgM7AaAQAAAACAG61d/vwfkQt+8QpgQ7AaAQAAAACAG8394nVIxiuAzcCLVwAAAAAAcKO5jNchrzoAbIaNzHitlzE38KuHX7n2oyePXLuX5XnKP3Lt78Z8zAel5G4m51NKn0J6nZ5chm26zp/P4X7Mlnz99duuPRwNQp+4Y7nO5IQbyRbUfD2zmAnYJeM36Pvp0TW+rfl/ZhZiIntJxqLelyzrtG38+eg9qJJ82ZgLGk+vk/Mpkv2MJUd1Itm7Bwd7YZv50ucyZtcUzyX57IrtsnzHLHtVvfe777m2jq+Z2adfPXjhCWaRqno+WW5kT3akWbxmZm374oMVWb6stnUfZlZIFmfVj9mXK1lvjo58tvHOtuZymm1t+TzK/L5dfd3xfiZ9NNNVxiK7L/psDgZZ5rA/1tnZSdxR5/ezlLzRZZL5OZWM3LaO1/Rw9di173/5KPRZyDPV7/vr3kkyu1V2VyZjfz/H43Hoc++ez03WbNvskSt6fm7Vq3hjRiOfU1ok6+Ppmc9Mnc19Zmpxjbze4VbMrS0lrzdbN4rGH6szP2/6/fhXht/5nW+59mtvvBL6PPjqoT+XkC9sduvA38+R/OeBhwe7YRsAAIDnNQtevALYPKxGAAAAAADgxurazmW88uIVwKZgNQIAAAAAADfW8y9dzXjxCmBzsBoBAAAAAIAb6/mYATNevALYHKxGAAAAAADgxtIXr8UgKYQAAF+DjSyutVzMw2ez+dS1f/zjv3LtchAv5XJ64drtYhr6fOOtO649GccCV6UWg5JCVIvFImyjhUv6g1jUR+tZaVGsn+1JzkWrV8UvFC1ElRW40gI9XRf7HEoRqdXKF5nSYi1msSBOmxQd2pbCRFmftvaDM5v7MS6S69YCM1kFHB2LMimupeO3koJCjx7EQkDDiS8MUw7iPNLrbJOCZnXjj1XXMieKeL5N48e87MdiUNs7O36bVZxr5RVFm64uFxaLyj3bkfRJimBZmAN+ozbbr2lhr9ijKP01lWWcE2cytx4/9sWNqsoXwTMzm8sz37vGv2Hlf/XT5zmOTbgvYV5nhcf8/c3muT5DvV4c46b2c8taX3wpLdpV+Guo21gssWz8eriq47G1MJqO8eVl/J7QIm3h+TGzs1NfDDErMrWz44tTDeR5zp7doazxWQEpvd+rpMjdhx987tonp/57LC1yJ2PVH8Y1wEKRxXhsnX36PTGZxEJku9t+7RsM43Uf3vKFsW4fHoQ+WxN/zo8f+YJcTcO/EwMAgF/s+RevxaBnvawQNAB8Dfh/MgAAAAAA4MZ6/sUrMQMANgkrEgAAAAAAuLHci9cBrzkAbA5WJAAAAAAAcGM1i5+HJpUjXnMA2BwbmfFqq5jd16t9/tsnn/zUtWeXMb91OPSZe5NRzFm9fdtnXw6SEO5Gcvh6ksM4Gsf91rXmeYYu1pOwPs1yzMQczni+GpfZJn1quaaHD5/GY0mG60t3fS5fdk0nJ0eu/eTJcejzG++84dqDYcxD1etqJAOyaSV70swKybEskzzUmLQZx2Y+9zmWn37ypWtPp3F+LiU+cfdgP/TRbNMse7fSXEvpspwnx64kWzLJ3v3y8y/8cfqxT4wP1vOLN1yfhSwruEsyfCMNgu1e+MfPjq3t2Ek/yaJiNcdyKtmhxyc+E9TM7O7dQ9fuaxD0Nek5F1kWVRgaPzZNyO40a2rtE+9BV8p8zLKWZcDCvUxOdyxZnVnWskQZ23IVj/1P/vFvyrF8n48/+ixsU8uiVJ/H7wVdt/pJ7q/el5AfnSYeX50nrPf3chbzby+nkh8c1oTsGfMXtUpyx1czP4+z75tqPJJj+T9/nHxP/PVffeg/SL7GhgP9LjkMfb71zquuvb3j82QHSY47AADA32iXPuMVADYF/xQEAAAAAABurGb+XNQAv3gFsEFYkQAAAAAAwI3VLMl4BbCZWJEAAAAAAMCN1cyfy3gd8poDwObYyNC0t1/fD5/1JZNyteUX05NezDnUOMetrWHoo1l9q1XM3NMgw67VYyUZgZI32ksiATU/r83yMa/Yb8jCNLOebFUkWYPnJ+eu/Sf/8Uehzx3JdL19a0d6xPNdzn2m4tHjmAn4vozxm2+9Fvrs7vlj9fv+Grou5re2kltb9OJ1LxY+v/X07CL00WzGL7/01zCdxaDQYjFz7Z39vdAniWYM2k4zU3374sLfNzOz07Mz13777W+GPh9/8olrT7ZGoU8j4ZfXSWbV87vONhm9VSFK9BqDpzmX2Wddcob9ys+l7Z2Jax8e7oZttrd9/uRyGdeNXh0SZkMf/SzL/dXnTDOnNRPUzGx66T+bz2ehz97+lmsXyfn1Qqa0b9cabmxmi7k/9mAU113NWV0k2cV/+Ze6Jl29Vg8lL3q5jGMTziVZQ1crnyGt+aJZjnLIcO7F+dgf+PO7fHQS+kxnfo3qa7Zp9ix0OjbL0KWV762qimto2LOuP8lcWyz9WFVVXHcv5Xw++/xh6PPaK7dd+3DfP3f6nAIAADzP/eJ1SMYrgM3BPwUBAAAAAIAbq30u47XgF68ANggrEgAAAAAAuLH8L155zQFgc7AiAQAAAACAG6uZ8+IVwGZiRQIAAAAAADdWs6S4FoDNtJHFtbquTj7z7ULysrOiOVrspNCNLBYcKSwpONLTwk4vLjjzs0+lz9UFUbKiKYV81u/3/S60So39ogJh3vn5pW9fTEOfwcAfaz73BVKqpGjXjhQmGo/7oc+nn3115fm98xtvuvZw6ItB9ZJ7uZICR6tVLPyjRV3OTmNxLS0yNZNiQW0y5lqEqCx+uUIwde3PuZE5vLfnC56ZmY3Hfsz7SeEfrZrzxYP7ocvFNBY4euFOzGJVrPaXLK8l81yLTGXPjz7zWQE7vVdtE+eEFsu7c8sX9bl1sB22aXQ/SYGm67hOwbVwnYWuR1fvo9SifBavu02Kk2mhuTB+yQW897vfce1xUlyrJ/td1dl98RemBcymF3G+NjIW8YpiwbWyF8dGi6c1jV/7BlIky8ysqHQs4jXpvHn85CT0GY39eL3+xj1/7H5cU/XIo9E49LGh3y6beqFYnrSzomJF6febrY9l6Y+WfHVYp3er0O/HuA0AAMDf8L945S8OADYH/xQEAAAAAABurHZJcS0Am4kVCQAAAAAA3FjNgoxXAJuJFQkAAAAAANxYvHgFsKk2MuM1y4jTbMHuOhmqmo2Y9NF81qxPIfmIuk3Txiw/zdnMskT/4i8/dO1vfvP10Oellw79sTXoLsmX1ZjNqoq3WXNBx+OYCXh27nNfFyufvVuVMWtwe8vvdziMWYjbW/5YT5+ehD4a6PfSy7dde2s75m7qHFmuYlbwo4dPXXt6GXMib9/Zd+2hZN2ulvF+qyyDVueW5ieaxTzPuvHXkD0bQ8lzDHPE9EmIWbI/O6EXbpPtNzw/msto2XUmoaRX5ZRm8bL24jxKszheIZvVkn99kjzPo6PjsM3ZuX+e79w+DH1CXmboYRazoNNOsh/Jrk42mkx8JvKqjjmmrWRpZ/tZNZoD6//89p143S/d3XftXcl9NjNr5LqLLIxVrnO28M/qk8fxvixWfr87B3uhT1jjk1ziUgKDi+KKrFszqztdm+N+B5X/bHo5C31eefWua//eP/0t166SjNeF5FBn97KT88ty0eME9O06yQ+vJUu76sdjv/qKX7/v3N0Jffb3/ZquY/5LxigDAIBfE82C4loANhMrEgAAAAAAuLHcL14HFNcCsDl48QoAAAAAAG6s9vkXryNecwDYHKxIAAAAAADgRuq6zv3itRjwmgPA5mBFAgAAAAAAN1LXdNY9VzOAX7wC2CQbWVwrKwzSk0IbWhek62J1ltHIF3bqD+Ll9itfdKaukyovUtVDt+kldYr0dB88ehr6PD32BXruzRahTymFscq+XENScKSQolJJ7Rgbj4euPRkNQ5/zSymaIhc1GMZtlgt/Da0WnDGzXuHHbzaLBa6Ojs/8fqTIy2QSi9KMpKBQXcfiWgMp9jUaxkI1b7/1smt3UqDpgw+/CNtowZ78q/7qQkqVjE0lRdoWq3jds5kvgtaNYjEjrcn18t17oc+joyPXfvz01LWbZDz1urPiX3qZXVJ06KoUpi6bxLKfvMCeVydFkc7PL137icy9xTw+uy+/7udIdjPDGV+jOtB1igSG57AfC2fVcqimi9fd62RtSQqjaYG6xcIXVzqRsTIzu3NrVz6Jc6KQE8xqa2lhuYWsE/Nk3Qj19OpYNFDXkqLMnlYpGifb9AdxzBcLKeSWPAuTrS3XPjzUsTKbzqXoWXF1AchQaC4p+FjojLxGMbVOvtyy6XnvZV9gbTaN92U88d8Vt5KiZ/ponp37/fSK+P0IAABgZtbM/d9zSn7xCmCDsCIBAAAAAIAbqVn6f/AuRxTXArA5ePEKAAAAAABupOfzXXuFWa/kxSuAzcGLVwAAAAAAcCO1zxfWGhbXiiADgF+Vjcx4tV7Mz+vJZ48fn/j2E59HaWZ2+86+a2fZsZdTnxv353/+09BnLNmhv/Wbb7u2Zr6axWzW0XgU+uzt+5w7zVM0i5mURe3bZZJPGPJGk+seDK7IjjWzxcrnOU7nfqy2Jj4v1Sxm7faT/Ek95XGSvbu95bMZF3PJljx5ErbRHODLacxD1QzV3/zNt0Kf3/hH/rO25/d7nmTx1ku5dxrya2ZpIK9oZfx0PMsiZtLev3/ftb/x1jdCn+1tny2pmYtmZidnPq9TZ02vF6+p667OgAzZtkmia3dF/uk1ok9/QSd/zlmG84OHPsN1NvNzra5jXuZKsk7bJINWo2yza9SPslHQ8SpkDvcH8Tk0yeNdJRnYZeH3q5nYZmZ147fTscjWrK2dHdfe3omZw3rhRRnXAM1o1uueTZdhm6k8m+Nhsq7VmmMa501fMq/12MMkE7uq/FjNF3GdmEv+6SoZv07WfM1WzjJpW831TrKM9Z9ZizRZ2Xdq5f4Pkmzbl+7477GiuBX6zGQt/l/++Iehj0bidjHIPWwDAABgZtYsfv73hHLIb8sAbBZWJQAAAAAAcCM9HzVQDvm1K4DNwotXAAAAAABwI/kXr7ziALBZWJUAAAAAAMCNxItXAJuMVQkAAAAAANxIvHgFsMk2s7hWUkTj088fu/Yf//Ff+00sFv34x7/nC1r1Xo55Lz0pmvLqG7EwUdNIkSkpyHV4sB33K4WItrZigZktKTpT9ZMiOTIUTVY0Ray0eExSWKco/XXfub0X+iym565dL3xhmNll/FIrpGDP9vY49Dk/vfTtpFjVcuGLxcykeFVWWGcpfap+PL+69dudnE5Dn8tLf53joS+kc/v2Qdhmsbi6IFOQxA9pAaamkWtKihC98fqbrj1I5tHv/vZv+/NrYlGfz6VIl9J7a2bWtjLGaQEp/1laQEoLHIVDJc9uLP+VHNu3s6JI3/zmG7KXz1x7lszP/X1fQCorYKfXmRfXkmJqyTqmew4F18osx8rvp07mTV8KJWX3V++LFsu79/KdsM2tO/752NmKhQVbqaQ0nc1Dn5U8QtXA72drbzdsM5j453BrO667YynU2CRjviUFFWeXfs1qan8cM7PhyG9TFPF+61zK7tzFuS8U+elPP3bt3T0/98zMqsoX3Vslxd70ke8sKea40u8Ov59BFefRgwe+0OH2dvw+PDv34zdN1u9SvpN6Mh+zQpIAAABmZu1zL16LAX9nALBZWJUAAAAAAMCN1Cx+/o/F5YhXHAA2C6sSAAAAAAC4kVzUwCD7b4oA4OvDi1cAAAAAAHAjkfEKYJNtZsZrkpfY1D5r7jvf+S3Xns5jDuNsLjl8vbgIH97y2aZlFbM5/+RP/tK1RwOfa3jndswIDFmnWzFbclRIbun5Wegzn/u8xOWFzyTNsiXPzy78PhZxbHS7u7e3Qp/XX/1N156MJcMwyZbUGMvZNB77/oMj19YsPzOzi5m/dwPJWR3049RdLHxu4PlFPHYlOYKPHjwOfT76qc8oXEnu4WoZ8x27RrJZY6xuGJsk8jPM/VKyGzuL83Mi+cFV0Q99Hj565NrT2WXoo7nEveLq/NZeyKTNsm2vym/Ntri6U8iOTbKM287f7za5MaOhn0t3JaN0ayc+GyPJ88wuO+T1JuNX6ukk8+aqfx7T22RmVkqma13H56WUDbPx07uwJevYOMmu1mcsexYWkuGsbTOz03Of+3p+PvP7TQa93/dzf5rk85aSU7q7vx/66JKkz0aTZKhqjunDh09Cn1bWie2dmIE9mfjvl0KyWFdzPw5mZrPWf/b5549Cn9Nz/92xXMR1bClr22Dgx3MyivnRC/l+OZPvn2f8gB4exHxe/U5qZOIMR3FdAwAAMOPFK4DNxqoEAAAAAABuJFdcixevADYMqxIAAAAAALiRXHEtXrwC2DCsSgAAAAAA4EbyUQMU1wKwWTYy47UsY2bqq6/ec+3Pv/I5co+eHodtmpXPiFsuY47gruT9FVUMJPy9f/xPfJ/C5+nNZj6L0Mys6Em2YBuP/fqrPsvv8dOT0OfLz++7dl3HXD7VrOKxVC35iKNRzKDt93225fmFH/Pl3GeqmpnN5bN5kr07GvtjzZMcxv7Q5/lpBuRw12dsPjtfP2+yfMdWwhuzPl9+4fMRLyRXd5FkIzaS3bhzsBf6XEeMjvTnW1UxY3G59NfQlDH78tPPP3VtzWU0M2tqP8ZtK89CkkkbYkuTzOEYbpt0ke00H/U6ma9ZH/2kTXJBW+m0d+jv3aAfx7zr/Ea9XhbO6vsksaBhKLLcX/1Mc3WLJORVTi9kTpuZDeQZ65ITbGS92dryz93jo5jn+ed/8WPXPjjcv3K/B/s7oc/00q+rn3zs18Kqit8TXevvb8+SNX/XH0vzcM3Mdnb92jca+T5VkjF9eXzu2hdn09jnwn933Lod14l7917yxyr02Qib2Ink327vxPE8OfXns7UVs4vnsxPXnox9Bu0oyVnVjO7F46PQpw0nHS9CM8PLys/raiP/tgIAADZBsyTjFcDmYlUCAAAAAAA3UjPnxSuAzcWqBAAAAAAAbqR2+fP/mobiWgA2DasSAAAAAAC4kch4BbDJePEKAAAAAABuJP/ilVccADbLRpar0MI6ZrHY0rfe/aZrv/mNN8M2n33yoe449FkufAGXvd1YlGQyvuXan3/q9/vVA1/0xcxsMfeFTNomFt9pwmdJcRvp0+tdXbBHiyQVSbGyft+PZ72KBaO+/PyBa5el/xJr6lioqJOCQv0qFmO5d9eP5xdfPgx9VgtfpKsnBXDG41jwaDbzY97vx3/t1EJEOp5mZk3jx+/s1BfNOTuPxdRqKUQ12Yvz6DoFosqePz8dv+zZUG2b3RevbmNhtFquuydb6b392QnJNkmfrOBW2I3sR4tBJdcdxuIahamyQlRVJQXXpFDRk8enYZt7L/vCeF1y8OvdK1kDevFZDUMq41mUyV8u5TqHw/gcquUqzomr7l0vucSjJyeuvUqKGkodJRsN4nWvFv4+nJ/6+zBLivvNZv6z5TKua/2+H5tsXn/zN1537eFAxi+5bl2Lq0EsWNh2/pqaOu7o+MSvNxMpRlgWcawWcp2xmJXZYKDF1OJ3kl7naOKLa21N4rq7tT1x7b297dBHizcOkvutU21n2x97d3c3bPMH/+Mfhc8AAMCvH168AthkrEoAAAAAAODG6drOZbzy4hXApmFVAgAAAAAAN87zL13NePEKYPOwKgEAAAAAgBvn+ZgBM7OC4loANsxGZrymOYdiV7JYLy4uQp+7kiU6lQxQM7OzM5/POhxOQp/Jls/0fPr4sWtfnvtMPjOzWvISSw01NLNasljLJItVuljb+S8WzWo1M6uqUvrE27x3sO/a04vL0Gex8Fmh462R//NZzDq9kP2sVrPQZzrzeYQXF7GP9fw5b23JdSbfp23jz7dI8ilrzaVN+uzt+yzBh49PXDtL7uz19N8wYn6i3rvs3z20i+YwLpeLZBt/RoNRkucpfY6OjkKX6SLu2x8oyTHVHNgkXzaMcT6AcqhrZMdecZifbfjitpk1jT/W2ZlfJ06Oz8I2t+/4tSWNc+1pM8kTlvvSNnFHheTdLlea5xkPrRmaq1W8L3qdvWTOjiRLuZN5nq1rt2/tu3aVrFGjkX++J6OYhzp52Wd8avbyl/efhm1mcz8281nMgd2a+HVs/2Av9Dk79WOjOauTSTxfXc/rJo55X9bmsh/XfM2pXSz8frP1fDH3z26W2b1c+M8GyX62ZY3Xh7Ws4vl2smjt7sTx3Nn136vjUcyKnc/998Bk7O///kHMzQYAANAXr+WA35YB2CysSgAAAAAA4MZ5/sVr0e/FIr0A8DXjxSsAAAAAALhxnn/xSr4rgE3EygQAAAAAAG6c5rniWrx4BbCJWJkAAAAAAMCN08yfixqgsBaADbSRxbUuzmOhp6L0hUEW9QPXHo61KIjZlnz2+cefhz5LKRBVJq+iV/Unvk/pC44sFrHI1HLlQ761OIuZWTWQAiOhQJNZIcWKeo0WHYqVdRopIFUvY6EVrfxTVLEATt35PheXvoBLlQzWYOiv88nTJ6HP0Ym/v8tVHfpUUnRmvvAFZ85PYzG1nhYnS8az1/Pj1TSxoNDjp6euPZ36Y2tBpGf7vc6X/NV9QrEq+fPsfD/59GPXfvvtb8Qda9ZRcr6VFNvRglF6bmaxYFRXJGMu7Ww/WkAqq1V11X5jgbPsvsTrXklRpFbGWAt9mcVnKsy9Zxv6ZlYFS065beP97bpC+vj9aFGnn23lWsfHsQDg6al/DkdJUbay9HOibf2xFvO4tsyl0FNvEfv0zK8TRbkf+sxmfj+DoV8vx8ma39R+/JpB/IqbbPuiTdljOV/6Nb2u/TWcnsX15/zcF+Q6S4qyNVJwaytZm3U/WqQrK4o1lu+X5SIWFdPvCi3cZxaLpWkBxdOseJ7st03mYyeF22bT5LtO1g4tKqZjBwAAYGbWLokaALDZWJkAAAAAAMCN8/wvXnnxCmATsTIBAAAAAIAbp+EXrwA2HCsTAAAAAAC4cZo5xbUAbLaNzHi9/8WX4bOq8vl+oz2f/zfqx3zCvvmMuGWSNbiUjL2qiot13UhmXc/nOSYRpbaSQzWD2Gcxl+xQPY6ZLZfymcREjicx57CWg2tGoJnZxeXMtS9ncWy2dvfl2P7gXz19GrY5OPDbNF0MUJzN/TVl+agaq6n5nZr/ZxazYpMIQxsM/DwZVDGbczjwn7368qFrf/LJ/bBNLbmgmrNrZiFLMk98lQxayUus+nEivbJ/y7WLXrymUsbv1v5h6DNb+fl4/yt/f7Os07ZLBlnJ/c3v94uzbbNMWp0TWXas7jfLUNU5sL+/49plkqmpma7Z2MSPsuRaf13ZeGrGa8iK7cX9LmStu7iYXdmnS46tz4vmbJ5dxDxuzYJOBsJGYz+PTyXX1Mzs/DTu+3llkjGt55f1GQz9NR0dnYY+mpG6lCzbNsv9lWe+TPKOdW0+O43ZuxcyFn3JAh8OYl541/p5dHoS97taaXZx6GK9ws/1i6nPeK3mSXasPJrbW+PQp1/5/WoOsJnZSr7rNJO2rbOscgAA8Ovu+V+8FgOKawHYPPyTEAAAAAAAuHHa5zNeR7zeALB5WJkAAAAAAMCN4zJeB7zeALB5WJkAAAAAAMCN0yz4xSuAzcbKBAAAAAAAbpxm8VxxLTJeAWygjSyupYVMzMy6gS+0cfHlZ65dJ4U3tqTIR1JjKhRgyopr9aS4zcWpL37yNCnOYibFd+pYcKSSAj1ZtSUt0KJ1dZbLWOxEC5eEYjxmZlKYSAtTmZktj45lvzLGScGjp0dnrn10HIu8jEa+OExW8EjPuNVrKOKxh8MXFwIyMxtLUZ+7L90Kfb7znbdcez7zY3xxEQsBraRIW1lcXegpG7+kqpjfb7LN9ta2axc6r8zsd373d1y7reP9/g9/8h/lXPTcwiZBdkkqK0QVJv8vUbTrF5Uru+rYUykg1EpBuEFSuK+RYmrZ2ISCYen4+Q/TKwhzwjdPzy/CJgt5Vi+nsZiRrgta7M/MbNr3RbnGE1nHkgJST+WZ75JCc7v7W6798EEs1DeXc9478EXPXn3tbtjmXIt0LeOxS3k+nj46Dn10TSplvamzyn1ymxbJuqsFzMqkyJQW6ivl/ldJQcDLqb9PTR3Pr5Br0MKSZmYrvVdyDb0qKYwnY1Eki8Dpsf+ODM+PmR1Jn/HIr9XLZRwrAAAAfvEKYNOxMgEAAAAAgBunfe7Fa0HGK4ANxMoEAAAAAABuHH7xCmDTsTIBAAAAAIAbx7145RevADbQZma8Jnmjmue4Wvhcxn6Sw6hZjXWSudeufK7huezXzKxr/Pmslr5dlnEYsxy+SDIgs9hAicvryTar1dVZfprnambWSlDk9s5O6HN+dunal5c+R3BvN26j92kynsRjy4VeXFyGPsORz5LsyX41J9bMQhbmcDgIXd584yXXfvW1l0Kfg8Nd13700OdP3jrcSw7tr2mZZED2NKoz+XtBTzIzdV7ruJiZ9eRe6j7MzLZku7qJz1hZ6n40dzU532vkquqcyLaI+bdX7/aKw/zNjl1zsYg5pl9+/pXfRPKZR5M41+4O/H3pZc+YzIEuGUAdv/DsmlnVl7xomWvTC/9cmpk9PfI5q5eXcV1rJWdzNIrPy2Rr5NqLhc/ZPDuNz274LAm3Xcz9/KuTzGF16/a+P7fxKPTRHNhpkm27lDmwSHKy9fwGA38PyjLe70LmQDbmOs+bJP9WvzsmYf4lXxQy15osc1jud5vcl0LmqM69xTK5T7IfXavNzApZ/JareN3b2z6rWpYjK671nQoAAH7duOJaQ4prAdg8/JMQAAAAAAC4cdwvXoe83gCweViZAAAAAADAjeOKa/HiFcAG2sioAQAAAAAAgEzXdVa//7594+4f2qCa2nI1sd791rq3fjuNPgKAr8tGvng9O7sIn+3vaXafzzUcDGLu3WxxdaZd1fNZc0WSj6mfDSQLcTiOGZBtq/mt8diNZO5lXxB6yrVs02RZotKezmLOoezGijLu52Lqsw/7fX+dbRdz+qz2J7y1HXMYp1OffbizHXNgNQBVz/cwyVktSskATEJzd/d8jqBmN2b0Xm7tbIc+s0uZs8l9Ucl0DFmXs7mf5yEL1czKvn+Me5Zck0zroot9iqKUtp9JnQYOWzLP0xxY6RO7xKxYzYVNnw09dtxz1/kLz57vl1/1Ob8ff/SFa09nMavz9uGBa+vUM8uuM7l3MsZZNrSec1X5+63ZmGZmT499zupsGq9B1596FbNO+5Lxqds8fngUttFj9fvx3p2fnbm23iczs8mWXxcePjh27UJDQM1sPvPXkP3moZYM8VWSKV43fm1bXPj9jgYxU3wgudOLRdyv5vM2SdbyWPbTSGDr9DJm+jbyHLZNXJt1vKpenGtTGb+erVx7lWTS6jqxXMTvm3v3/PPy+NFx6LNs/b6Xkr3bdjGDGAAA/Hrqus5mv//7tvr+923/Z38VnozOrP2Df22zo09t/L3v8fIVwMbgt/gAAAAAAOBGqN9/31bf/376Z6vvf9/q99//FZ8RAPxivHgFAAAAAAA3wvIHP/g7/TkA/Crx4hUAAAAAANwI7enp3+nPAeBXiRevAAAAAADgRij2Yr2P/5Q/B4BfpY0srjVIiqZowQ4t8pLUrrIqFBSKfUYDKZQ1igU8ylIKPUnhkqxwlhZsWS5XoU8og5UUB2qlSJO2V6u4zUKO9fjoPPTR617V02Q//hoqKeKkBV3MYqGVqorFWBYLXzQlK4qktalGky3/QVI4q5CCXFqoysxsKcc+O7sMfcaTsWt/ef+Jaz/46mnYpq79/NTCQGZmnRZXSq5bQ+BLKXjVJNc0KLXQT3x+Vo2fE1oUKz0f7ZLk08fM+rx0luuRFh6TYlrSbrP7XfynF+DK+mgxo9nMj/EiKU63lGdjPMmKtOmxk+JaL64p9mwvst6sQtGhrHCfP7/BIC7106m/rqyo4cWlL5Q1Hvtiebo2mpn1B/6zYVLA7vJS1/N4Dfcf+OdsLvehLOM17e74Z3c8iYUP65Ufz/n86rVZz2+xitssZM3XAl3P9uPncVawruv8dR499b/YGCaFvWp5puaLWChtb8+vofN57DNfyHXJ3CqS+VlV/nzm8/i81DJeWVHI2aX/DlrKfcq2AQAAv54G771n9QcfvPDPAWBT8ItXAAAAAABwI1Tvvmv97343/bP+d79r1bvv/orPCAB+sY38xSsAAAAAAIDq9Xo2/t73rP/OO7b8wQ+sPT21Ym/PBu+9Z9W776b/lRsAfF148QoAAAAAAG6MXq9n/W9/2/rf/vbXfSoA8EIb+eJVM+PMrs5qLJPwOe2T5bcOKs2WvDovUbMbB0mG4WjksxCXy3hNp6c+X3Sp+Xpm1sqxNE/25DRms1rPn0+WIziTjMosu2809PtZSoZh08Wkiq705zebxfOra5/VVxRx/DS/sV/5PqNxvJejsc9zPD+JmYCa1xrvrdlIciwfPfRZk198+TBsU8hQvDKI55elvqqrMl61ne0lZMk+2/OVxw77lWcuz6O8+l+Tr5Ozqno6IbNMWt1NL87HcKjk0Pe/fOTaDx8eufZE5oOZWZNkzl6l0EliZj35LBsbzVKu5TmcXsacYh0+PY6ZWdv6DM3+MM7Z+dTngI6Gfo3qa5C2me1s+fEaJvu9lHxZzcw1i7dqa+L3k+UUz+c+kzbLedbxzLJOGxmbnqyp0xhjGvJQe8kcaUN2bNxNb+k/nM78+WX77cm6kN3viwu/Fq+SnNqm1hOSfObk+Wlq/+FXD2IG9kpyx9M1IGR0+200cxwAAAAAbgIyXgEAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFgzXrwCAAAAAAAAwJptZHGtrDCImS8oUlb+1MsybqPFoYaj2EeL0FTZsaWGi9bwqfqx4JEWDyl6sc9Zb+baTVJpRa+rHPoiXV1SLUiLsbRtUoxFNqu7WKhmsj127eHAj7kWyTIza6Xwy2qVVI+R9/1tk52ffubbVXK/Gzmfi/NYdOjkzH82mQxDH9XqfUnGqmmuLlZ1HVovaLXy93K5ilV99LOqiI/15fm5a19ML64+Fy3sllz3da469EkK6/S0iI8eK6nFo4XmekV2NvLcJdWBzi78c6iFnm7d8s+BWSy41aWFlLwiuYjrFBrT5zcWPYvXPZKCVqcn8VnQ9Wa5TIpMaZ9VKX8ej92X9bAqs5snBcNCUScz6/xnlRTY257EeT5f+HvXz77han/syTgWPmxaf6yF7He5ive7k/tUdPGaOr3fSUG4UIRNH4WwNsa5NejHMW+lkGDXJt838gw1rd9PVtBsJc9LXcc+Zxe+6NlwGMd8Pvf7WcmcKLIKkAAAAACw4fjFKwAAAAAAAACsGS9eAQAAAAAAAGDNePEKAAAAAAAAAGu2kRmvaXKkxNoN+z4jbtDPMl79Z1WMWQ1Zc5o1+ezDnvTxuuR8Q+RjksM4HPgTKstJ6FNJlm2v9O3hic+nNDObLVaunWXjaUZqk+T97UjG6/aWz0M9OvK5oWZmC8k+7Pfr0EcPtapjn1KyOYdyf2ezJOtUrvv8Mo6NRiy+/sa90GclWZer2u+3SzIWS81VTaZwlmx6lVbmzWw2DX2+evDAtW/duhX6/OTjj1z76ZPHoU8huZCaNdkmc0THM5nmMcc06ZPllF4lRGEmOavWk/uSZKrWKz//tMcgCQqtSj8/6ySfWfeUxblqNmcSd2yNfKhdhpLnamZ2cnLmt2niM6bjlc3G4eDFc+DyMj6HOm+KIi68q5V/pvSZM4vrdU9ysjVL1sxsNPRrVJncu8XSH3s2S44tX41z6dPJmmCWzL9r5BJ3WcZrT8fPt3thBsS81qoYhT4DyeiuqniCpXxXTGd+3sym8bo1njfLPB8M/Pdsm2Qtz+Z+3zo0l9M41wAAAABg0/GLVwAAAAAAAABYM168AgAAAAAAAMCa8eIVAAAAAAAAANaMF68AAAAAAAAAsGYbWVxLC6+YWSjIs7XlCz/t722HTYrSb6SFqszM+slnqtbqIXqcpHiVlj9J6svY3r4/56y+kNRisdNzXzBqsYpFc7QYS7/qhz6NFAMqk/Pb3vFjPJJCZONxLHZyduELbrVNvKiVjKcWODMzG438fXn19buuXWgxq+Sz/b1YhGY88UVnduQazczuf/nQtV9+5SXXPjr2hYvMzBZzX3ynyQo9qayelE6CMCniXDs/9+ezv78f+jRSwOxydhEPPffH6nUvLipnFi+hlxQL0mvIitGFwlNhx9m/EUmnXrZfv+NsDbj70qFrX174Z+zuPf/nZmaFFqdLnsO4CGTnp8WrYp9GnqF65Z+f6TUKza1WsYDUUovIreI6pwUAm0YKzSXzvJWPFot4fm0nx8oK1kl1rUrWtWy9nEvhrFFS0Wx/d8t/kOzoTNZZXY+Gwzgfl8v6hW0zs2bhr1sL2pnFQpF9KRCW3UudR/1+XFO1uFap1enMQlXIpcyJ8SQWctN5M5nEwl49+Y5czeNcqyotNnl18UEAAAAA2HT84hUAAAAAAAAA1owXrwAAAAAAAACwZrx4BQAAAAAAAIA128iM1zLJ5etJ/pvmj/b7MaRU8wezfEd991zXSS6f5pRKs83COiUfM8/zvCrY0qyV/MGzs0u/RRZ0KOom5umtJJNyb3cS+hQ9HRu/nyzFVPfbNLHXQHIjJ+Nh0sdnFB498Tmm1TBmDU4mfk60yRlWlb+m+188CH2Oj/yxJlt+bL7x1sthm+mlz4Rssn/TkHmd3Tv9THuUyRx+/bVXpU/Md9Rn4ez8NPRZNnp//Tb5+fp2L8lZDeGwafztVVm21zh2kkJbyHZZrOXtwz1/ejKHtzUT1Mzq2meJtm18xnS8wjpi8dnMMlMbCU2dS37rw68ehW1ms7lrl1W8cM2/bZNj9yQ3WbOhM62e7zxmvDaylqySPNRa7oN+LSyWcb/b2/5e9ZPw6jBHk+vWTNei5/ej2admZtOpPx+9b2ZmhdyHqoz3RfPAdc6Ox3Gt1oxXHQczs9HQX9NsPg99Li81X90P+mQS15Zez+83m8PLub+Xi2XMcdccWL2mMhkrAAAAANh0/D8ZAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1mwjM15XSRZiX3L5JA4uzR7UTNcsY7FtfPZclmOpWYiaW9ol2ZKah1qVSW6t7reNxz4+ufB9at9nlWQNao7pYpGFavo+l9OY9zeXDMDhyOeqlkl+4mjkMwA1t8/MbCT5rJfTWehzdj517ZMTn227f7ATtql3fW7gMsmAfLpYSJ+YNTgYjFxb7/f+wW7cZuS3OT6Zhj5tq3mjSe6mzKVOciJXq3if+n0/noWGRJpZJfeqX8Vc3e0d/9nRsZ97Ol/NYp5nCOK05JrykFenkHmjY/dsv1d/ots1dTz2dObnxMeffO63SY796ms+5/f2nduhT5z68fxCpm+WoyttzVGeJRmqnZyzziOzuCZNxjE3We+DZp3OZjGbdTZb+uMk+dv63HV1XMdkqbPLC/9M7e76TGezOP1Ozy9Cn+nCP3dbo3jdu32fo/rw8blr63pkZjaf6fdCVFZxDqha1vSxrC2jUcx4bSSbXDOyzeLYaM6umdlSsnY1pzaLFJ/N/FgsFnFN1Wzqqox/9RjL/NPvMb1GAAAAALgJ+MUrAAAAAAAAAKwZL14BAAAAAAAAYM148QoAAAAAAAAAa8aLVwAAAAAAAABYs40srnV8HovF7EjhDS14VDexeExPinMUXSxsokW5suI2odCPdCmq+P5aa2lpoZCfnaFrnZ3EQjCfffrQ71cLPyV1inqhiFO8Ji3K1bbJ2ITxknZWaUWK71RJMRkdi6TGVLiw8cQXi9na8eNgZqb1WsrsmqQwUZf828PF1BfxGU/8sU7PYmGdTsYqLaETCillXbSYjW9rwTgzs07K+GSFqHSQtyexQM9wosWKsvJAf3dZka5Q/EkOnWwSOnXZfqXPbB6Lk33+2ZeufXwqBe2Swn39vp+P+wd7sU8lheZCDzOTooHZkLdy/Kb17TJ5gGrZJiuEt7Xt50BWaE6Lp2lBpuxe6rHHW/FZHY18Ibe917ZDn53tLdeeTPzcX1zG9fJCCvVtb8XCWbVc52AYC1Hd/+rItR9Jca1kSljX+THOxqYn6+NyGXfUlH4SVFKsrFfENaCUgnraNjObzf3YzBfL0EcftPncj9VqGQsh1rWcXy8eWwtQJjUXzXr+XmmBuPk8OV8AAAAA2HD84hUAAAAAAAAA1owXrwAAAAAAAACwZrx4BQAAAAAAAIA128iM17PzmKE5lhy+QnINi158h6wxcprVahZzIZMYWOvJsary6vfVen4hy9HMWgn5rPoxa7DX91mIR8c+17CufWapmdlE8nCzYw8GmgkYr+nR42PXvnt733dIskSHQ3/s+SLm9baSWzpMMhb78tnevs+AzG7BUvI7e0nO4VzyHVerGJJb9f12Teu3aZq435Ax3EserZD5mGXk+j6azVmVMbMy5MJqXqqZFXKs4TDmbmp+rGbFat5ncrppcK3O8yLLvpR7lWUtK31We9mx5ZwrDV82s1syr49Pzlxb86TNzPYOdl27X8U5obe3tbifuk7CQkXIWW38M19mx5aDN1nur+y3n+QHr2R9mdeasxn3W5a6Nscx35KM4eEgzmvNoC17/lzOVzGTtuv8eG6PY5axTfya+sFHD0KXJ0/8OqvzMbttepmDQZLHHJ6hbPwkB1ZyqXvTLJvVN+dJlnEl82SRZLxqputc8mWz+dqXHG/N2jYzq/q+z2gU77d+hy8W/lyy728AAAAA2HT84hUAAAAAAAAA1owXrwAAAAAAAACwZrx4BQAAAAAAAIA148UrAAAAAAAAAKzZRhbXOtyNBVG2pCCKVhNZJoVWtNpJkVyu1uTqJUW6tB6K1mzqZe+vpeDRKilKsqp9n+Ojs9BHi7r0+/4atNCOWSxKkhXfaVu/Xb+KBa6WKymssuevISt1Ukmhlb3RdujTNVef32zpz0+LiF1ezuLBZaxGI50zcfwW82no0xv68xlIoa/LpPjbIynGc3BwEPrs7Pvzy+ZaILV3lstYrKzTIlhJwR4tENVlhb1Mz6/3wrZZrKWVF8XSYyfXLdeQn9+LdcmM1HOuyjjXXn3ljmsfPTly7cUiFsW6e9vf36xY0GLpn5eujcfWolfZM6Vj2jbyHCbF83Rqdau4/ui8ydao+cw/d4uFby+XcRu9hl56VX5MF8v4PLeNLwA3moxdu+nieJ5P/fkMBnF91OJ+bRfv3e7evmtfXpz7Y7dxvyYFCpsm3pe+FDVsl3FuaQGuwVCLJcYxb+VYXZEULJR1tq6TIoG1L8qlhft0fTczm2z57+vBIB67qgrpE9fmrtP1xl9nKFgJAAAAADcA/08GAAAAAAAAANaMF68AAAAAAAAAsGa8eAUAAAAAAACANdvIjNfBIGbPaQxo2/r8t/kyZrwWEsZaajirhRjYkFlpZlaU/v10IQGKWbak5vu1bdzxSs55nuQwamKi5tz1kzy92VRyQCWr1cys3/fbpRm5cuzHT09ce9SP00fz/rJMwNb8fVgl191I3uRUsk17ZZI1KBmQ21vj0Ge5WEqfUehzdulzXy9lPKcXMWdVo3bTPMJr5KGGPE9pN22SqVn4seiXcU70JNv05Pw09BkuNUtSd5ImkL5wk2dd9NPkIbuqSxb5GjJorzq7/Dk8Pvb5vI8f+7H54sunYZtq4Mdqb38vOT0dm/QiXKsoYx+JN47X0MWc0EJzX5Mc2FZyf1ermFu60mxg2Y1mJpuZjUb+mdqaxAxVla3NuoZqHOr+7dthm8HYP/OzacyOffTYZzRnGb79/ov/TbJnWTarrLNJnrDmmGb/9FnI86zfh6NhzEddyhqqueRmZpcyFotlln8ra0nfH7sors5wznLHy9LPgbqO3ze9QuaSDFWTXRQAAAAAbDh+8QoAAAAAAAAAa8aLVwAAAAAAAABYM168AgAAAAAAAMCa8eIVAAAAAAAAANZsI4trDZPiIX0pZlNUvoDQOCkoZFLgqEmq72gRpKw40FIKzDRSlKTXi++vpT6KtcmeteDRthSmMjO7f//ItRdSkCsrthQKHiXXXcoJVkmRnOnMF4s5O/dFpeqkaM5oR4pVxfoycbySoik7O75ITiXXPRrFY1dalGaY/LtCz19npzfKzF6/5QsllTL3PvzxZ2Gb5czPiSop/pVXnhJaTEvuZVZe5rPP/fncuftS6KPF6M7Oz0OfUR2LkflTSwrraKGnbMhl/um5/KyTfvDCc8klz5i0Z4tYaO5HP/rItT//8olrT7VYnZktF34+Zmcb6oVl46f3NxmaVp4PLTKkc8QsFi+6TK57euk/GwyT53ni19VKCg02TTxhvUwtTvisj65Rsc9y6fe9bHxRrOOnx2Gb+Xwu7VjEaTb345etj7OZv+e65nfJmGstrX5SU2ww9MfKCntpsTwdmlUT72Up6/dqHgtcXU79dllRQ6XF/XQumpk1cj6DQbzw1qQ4YvLETCby/afFtWqKawEAAAC4efjFKwAAAAAAAACsGS9eAQAAAAAAAGDNePEKAAAAAAAAAGu2kRmvZZIJqNmmZeUD9Q73tsM2Z5LTN53GbDzNH8xy5DRTcTz0w9ZL8v66xn9WJ9l4tWTHLhYxS7LXk8zPRrJEk2zWrvPheF2WyycfTc+nsY8cazyR7N0su1HOt0gyVJcyxlkGpB6r7Gu2ZDae/nxnyyxTU/JGk9TUV17zGalbE59b+/TR47DNaeHnVpPmeUp2Y5ItqX06ac+XcY7s7uy7dpH8e0ohAZQHB4dxP7s7rn3/gb/ObB715Drzy5br7H6J/NZkrNLhU3I+2SYLye/UbNFsK82+zC9c9pKer45NspZo7q/cB11HzMzOpz7rdDaLWadF4efEchX76KM5GPjM16JOcrMllFS3MYvZsEURr3tZy3otx7q8jGvWxYX/LImgtZXstlclN6aT85PM5iIJr66G/rN+sjYfHPjvqYvLeegzu5z585M1tEhyszvz5zudXoY+C5nX9TUyXpOZHz4Zjn2m6yjJ/h70/UnP5/G7uG1raeuc4N+JAQAAANw8/D8ZAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1mwjM1739nfCZ4+eHLv2SoL6yl7MnhtprlwS5Tef+1zD+SLmHG5LZl1fMvc0s9TMrGk14zXm6YU4xyTfsZRszk722yX5jprFqRmRZmYzyZNtVnXoo8duZb9VP4YNxtzSqzMge4PYZzIZ+2Mt/bH0/M3M+oW/T3r+ZmbL2l9nEj9pTx49de2nklt7cGsvbPPK6/6zp0/O445VEguqH/Vk/IZ9ydk1s7t3fCZtVcWMxcODW/44SV7rbOGzJfU+VVUcT50T2RzWa7Ay3m/dTHvkCaq9FzbNYpxsm+TLlj19xvyfF0VcJotSPrtG4GynO7b4bGa7WSz8WjeVDNDZND4Ll5IdulzEYw/kudO8XjOzppC1pPJzoj+Ic2IuebJVHdc+zfwsq/hvgJq3rRm0o2Gc55odmq3nIV829DDT26uZ4vpsmJnpR3Udx/Pxo9MXnotZXEP1ERuP46J1OZPvwyQ3ezT2n02TiFedomU4VJygA5kDewcxb70sZM1PJrre73B/rxXqDAAAAACbhV+8AgAAAAAAAMCa8eIVAAAAAAAAANaMF68AAAAAAAAAsGa8eAUAAAAAAACANdvI4lpFrNdiZ+dT/0Hvjt8m2c9YCsMsk0Iwq5WvMNJPirxooZKVFAFpkkJFjRSUKYq439Z0P7HaSSXH1oJWbXt1MaM2KU2kxU2KZNArKYK0v7Pl2rs7k7hfuc5sbFaNFLhKCtVonZ/dXSlode6L1JiZVZWfzluTeH5azOjiYhr6aBEpLa40ncXCWdNL2U9SqCjWUot9tFhVmBPJNrUUDAuFn8zslVdedu2d7Tg273/4kxeeX5eVuLq6vlXYLi+UpfvRYjzJfuXDrGCPftbvx7F56y1fnOzRoyeufXYWi1dpcajsOQzjl82JUFwrKUYnz1QrBfXqpEBTJ0XE6lVWSckXniqLeOxqIMeW8x0mRZz6ff9Z3cTCffqMZYW9tJhWI9fdTyrjhSU0Lj/h+6Xqx+vWeaL3Nxkq60zHPBb2arWwV/Ks6tgspUBYVjhrPvV9kuEMxd36sTZZeNB0fu7uxMKXWmCt14sHHw59n34ZC3BdTn1BuNJkHU6KOQIAAADApuMXrwAAAAAAAACwZrx4BQAAAAAAAIA148UrAAAAAAAAAKzZRma8np7G3M3TM5//9uV9n8N4e8/nj5qZTSqfV3cwiZc7kty4+SrmEUq0oNXyQZnkMnbySjuJGgxZl9tJ7uZy6c/nYjrzf56cr0m+Y1MnOauSP1iVMT+v1M/khPvJNpoJ2NTJ+ZlmVMYes5nP1RwMh669tRUzArcmvs920uf84sKfSZI/WVY+O/Lo+My1p9OY+ak5kZp1+4ze8aszSXVqLZb+OTAz6+QaVot4fp99+YVrf/7l56HPYOCfjyw9OBxbMmnTHNgQBJtdt+xXd5NlqBb6WRzzngR6ZmfXSjDoK/f2Xfv2rThBDw/93NL8zGc7lqN1WQLu1QZDPx9HIx/OGZ5TM+vk2JoDbBazoJs0w9fPCc2Brfvxuqu+P9+6TvYrt2qR5KFOJfOzXvn9ZGvqbO636WW5tZLfmkRMW6XPgma8JpnYjTyHw17MoK1ryd9O5nUh91NzYLM1v5bPskzkRsZ4shW/b7a3x/785EE82I8Zr8OhP78imefHZ37dHSZ5rWWpa5+/MYMk0xcAAAAANh2/eAUAAAAAAACANePFKwAAAAAAAACsGS9eAQAAAAAAAGDNePEKAAAAAAAAAGu2kcW1hsNB+Gw08qc6lkJK86Sg0KQ/cu2iF8uxjAY9acdj96T+yeXSF9tZJMVjLk98EawmKaISqrokXSZb/hq0sE69itfUSPGvrM5TLGQSC6Islv6ETqToWZXseGvHF2fJCqKUUtymSaprzRdL194LYxUHazTyx14sl6GPXuftO7dCn/MLf50zKab16OFx2EaL7dy5ezvp468huYRQh6qQ803/pUQLCCWdlis/Fidnp6HP7k4sRuZlJ+xl8+jqkmJZn+6Ff/6sz4sLkT3b0G85k+J0ZmaPHz117Xrux6pr4/w8O/bjt7e7G4+thb2aaxTXSutQSUGm7urCWSspytc1ccetFCfLikzp3erJ5FrMY1GsUAQrKbY0X8p2SXGyqpB1ovPP4enpedhG71VZxSJOsYhcHJtKij+1enrZhJRpUpRxQIelXw91TXj2oT+/wchv0x/EbVpZ8+fz+H2o640WDDOLz9Srr9xx7TopRqhlzs4uY3FMfTi3tsahy3Do93N+KYUE0wUTAAAAADYbv3gFAAAAAAAAgDXjxSsAAAAAAAAArBkvXgEAAAAAAABgzTYy47XtYqZiX6JC+5XPjNvbniQ7yvLovKbxx5onmaljyZy9lPy8oZ6cmR0fnbl2ljW4s7fj2lmE3ULyJhdy7NEg3sLlyucnVmXSR3NBk9DCheSsDvo+l29LcnbNzErJLBxU8dh9Gc9VEe/3bObz/R589cC1t5P7vbXlzyeOuNl85jM+nzw5Cn10TqxWmmMZMyub2s+bpWZYmlknN7jXi2eoe9bx7A/imA/6/jO9b2ZmDx89cu3Ly4vQJzx3IRQybBJyVbsswVV3c41sWx2rbMw1T1bzKc3MOgnnHPbjfNzb9c/hxbFkh2bP5cKvLb0kz/OXiaSM1x0zXTWTNIuP1vmoc9rMrJR1IbuGWvYzMz+3wjJiZm3tP6yS9bGV/a6SPOa28n1auZdlGZ8fzS0tk/VHc6ezbGDNXtUo1p4Gf1t8NttkzPWz8XgU+lSVP79S8mZ1TTAzmw/890JvkWXbhoc1uDj3+awPza8b4ySbter7/TZJJvJo6Mcmy781GZtwW9IQZwAAAADYbPziFQAAAAAAAADWjBevAAAAAAAAALBmvHgFAAAAAAAAgDXjxSsAAAAAAAAArNlGFtfS4iJmZm+8ds+1d7a3XLtJC9lIMY5efM98dOGLLX1xPxZbev2Nl1z7cuYLmQyy4jGdP/ZiGovHWOcLcDVJYZ2FFJna2fLFWKaX/lzMzNraFympkiI0VenPb2sSi7wcN76YjRYzKrMCKXouWbGg2hcmWi5jETQd0939bdeukqI5jex3d2839BnJde7tx2NrAbPlUgriTOKYNysp6pPMNS30lFUmaju/nZapmc2npmYLP0e+evAg9PnT73/ftes6XrcWztFCWXr/zcy6Tj+7TgGc5GHVClFaOOsahXW06FRm0I/Pwmjsr/v4zK8JF5d+fJ9t5NefIrnfjfn7nZ1fL3yWXcOLr2uVPD/Llf+srmPBo4GvcWf9pPDYUopeNa2/D5Ok2FK/8mNRZRW4RL2KfRZybJ0iRbLfnqxrWZ+6luKDSeFDLXxX6TVV8X5Xsh4u61hgT9fmrJhaWWrRON8nK0Q2HvviVVmhuZl8V4xG8XtLp/FMijtqoS8zs1uHt1x7Mo4FKo9OTl27bpLCl3KDe1pYMBlzAAAAANh0/D8ZAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1mwjM15ns5ipOBn7bM7TM8m61ABAi9l4RZJ1upAsxDsv3Q599FjHT8/lOHEYNVtwtYoZiychqy/JQ5XrGkjuXTuM19R2/nyyvNFh6fP9+klm6lgyAEu5potLn4VpZtaTnMPBJMm/lWuaTeN+bt85dO39fZ/XmkQj2sWFv09tex76DEc+CzHL/NT84P0Df+zj04uwzarn7+8gyU8sJbs4yy0NeY4LP0d+9JMPwjYfffaVa5+cnIU+x/LZ2Wkcmz0Z411pt22cw9fJdL1GPGvMk71GLuhV2afPju33k21xenbp25c+m3M6jXmU9UpyLLPTlbzemOd6vVxa1Uj28nIZs0RDBvIwdLH+wJ/fVpLXun+w59qaSap5qWYxwzm7Rt2PnouZWT33+9FM6eEo5lLrPyWGXGWLGc5NEhA+HvsA3OHIj6fmj5qZtXJfyiKuLRqJ3E/WH51Lw4FfN2LCtMUFsYvPatv58ZxsbYc+k61kojynSB7mmWSezxYxg1YfZ80gNjOrZEwHAz82WzuTF54bAAAAAGwifvEKAAAAAAAAAGvGi1cAAAAAAAAAWDNevAIAAAAAAADAmm1kxutgMAiftSHU04fG1U3M8msk369MsvxWkkdY13E/mjc5nvhswTbJEez1NMMwZvn1zH+m52tmVsh1VpV/V15WSX6rZAJqpqqZWSl5t0lkoZWFz9RrNZ+witc0kGzEQZIdq9eZ5d+Whd/u8ODAtS8ufC6nmdlZ6zNezyXz1cxsOvf5g3Ud8wgHMqaa5zgaxflZVf6aNJ/QLI5xdl80EFVjVe9/+TBs8vDRj1x7uYz5ifGfWGJWYy3b9eSZ01zOZx9edRyznhwr3U+ylWtdK/I1y1CV8Uw2m8ucWMkaUCbzvBrIvE5OsAtHi0cPY9FL1hJpb419DufOVsw61TWgzjI15br62Voy7L+wvVrGPO7Z3H+2WsRjL+Y+G7av42lm44nmMfvnTjOnzSzMv0WSN6pZxb0kA1vjWTUreDFNklblfIoyya2t/bGzDFq9L52MTZXsV3N/bx3uhT77+z7TdTCM61gnY7OQ/OCVZhubWV++r6vkvmzv+Nzs7Ninxz53ei5Z74tRzAIHAAAAgE3HL14BAAAAAAAAYM148QoAAAAAAAAAa8aLVwAAAAAAAABYM168AgAAAAAAAMCabWZxraTwhhZy0mInjVYhMrMqFJCKRT+06FWhVVXMTCsIHez5IiUjKThjZnZwa9e1Hz45jntttYBQUixGC1EtfbGYsozbaCGyLik8Vkqlp1i8zCyr/fS8vYOd8NmOjE22i5kUpun14pjPF76oS9X3Y7x/6IttmZmdnPtiWsNxUhRJ5sRqFeeadf7YWshrMonFjPp9XwiokvbPdvyC1s8+k/vwxQNfTGuVFOM5PNz3HyTzvHfVzTSzTgt7yblokTEzs05ORwtpZbJpHua+NLNnN8zZdEB9c5kUelpK4Sl9NrRwkZnZcOTvrxbBe3bsq+93mBNd3E8h57Mvz9gr9w7DNhdTX4houVqFPvqMxWJgZo0Un2tL7XN14b5lL67NeuuygnBaSLCTwmOr5L504TLj+VV9/7VXJwWjLs59Yad+31+DnpuZWSlzYJUUNNNpnhWa06Jc+uj2k4KFZjKHkwJc+l2XLQkzKXqmz+VgEL/rdOqnYyNzYmsc19ClFLmby3fdbJ4UNAMAAACADccvXgEAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFizjcx4/a3f/lb4rCd5dDFvMgbWaf5kqx+Y2RdfPHLtqWQjmpl98xuvufZo5HNBk/hJaySL8/bdW7GT+dy7LO+vrn224Pn5uWt/+cVXYZtOjt0mYX710mf51auYwziQLETNvhyPYz7qrVv7rj0ajUOfL7967NrV6Tz0KSu/77lkc2bnW8k22ztboc9EsgWTiFybjP11//BHP3Xtx08ehG36fX9+h7eyjFevS+ajZirqrUtzVuWjLGVV712eNyrHDucWt9Bc0GQKh2vqZRm0IftS23HH8Xyu/nekheRGmpmdn/sMX82jfOW2z2s2M/vG26+4dpVkataNXPeVZ2fpIOsnW1t+Xu/sxnnedPJ86AJqMQdUs2SfnY7/rCcPTLuK+x3L+qi5ymZmA8lsrpuYh1qHjFR/LM1CNTNbNRryGs+vX/rnu61j/m2ha1+pGeNhkzCvy148v62JXxeyTN+QDaxzP9mkH8Y4m0f62TXunWSrV/0sA91f5/ZWnI+dzMflMo55Jdm1I8l6z/LMAQAAAGDT8YtXAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1owXrwAAAAAAAACwZhtZXGt3byd8VhZZUY/nxcIbWrzo8jIWzvrhjz517aaJBUe+85vvuPZ44ot+tE0s9FRKgauqH4e6lWP95MMvQ5+HD49c++WXD1w7KzK1mPnrTE7PBgMpMJNVRVJS3ORCihKZmT1+/GPXvnX3dtxN5QvrrJJr0LovWuhrNIrFq0op/KLbmMX7MBz0Q59BX4qITSa+Q1JZRwuYpUWwwieR3oa2TsZGjy1zPyv2Vl+jQM9VZ5hNEb1uLdhkZlZkJ3SFOMRJcS35d6Os4FGQXMRg4J/noRRXe+Otl8M2o6Hvk46cFhXL1ii7uo9+1uv5tWV7W+anma2kMFXTxEJuy8LPrTItelZIH9/uJ+uyFkGapmuL366MtbWslIJgS3kWtODVs8+uUTBMxrOs4jrRr168Pi4Wi7BNW/sxXiUFwwqZE1rszywWo9Mxz2abrn3Z8x2ezTbOidnKF73SYlpbk1gsUdeAJrlu/S4+P4vfHVtbft+H+76o3bW+owAAAABgw/CLVwAAAAAAAABYM168AgAAAAAAAMCa8eIVAAAAAAAAANZsIzNeiyKeVidZg0XpsznbLFdOIuxms2XoM5/7TLsiyQ0M+YidZC4WPiPSzKxnks3ZrkKfuvGf3f/qaejz+MmJa999ac+fSpYvK9cwHMXx1OzG2TSOjWYLVrLfopdkDUrm4/nJWegzk/zJeXLs1dJnKNZL32cyidmIe9vyWS/JBZbsxn4V+2zv+MzM//qf/TPXfvWV18M2f/2jn7j2owfxXvZHko+YRBZqBuT+vr/fd+7EzNxasiWzzGHNnO1dIydSIz/13MzMzi99VuNJkt3YSTZjlsUa+/yn58JeJwJyOIzP6utvveTax2enrv3Jp5+FbS4u/Lz+9rvvhD6aHZvlboac2tgl+dB/ME5yQlWWu9mb+2esX8Z1Yjjy16CnkuVuVrIGVEmG6nQ6d+2Yvm3Wtn4e92Rea26omdli4a8z5qOajcc+H3o4SPKiJQ91JmOl2admZqWsN2Xy9ap5x70kV1ezdvU6s216kqvb78fs6lYyXXtp3rHfTscvy3Cu5NiLZfyu0++OrZ2YS9zp96xcp+buAgAAAMBNwC9eAQAAAAAAAGDNePEKAAAAAAAAAGvGi1cAAAAAAAAAWDNevAIAAAAAAADAmm1ktYr5PJZa0eI7obhWmxSPkdohy1Xso4VfsuI2CymsMhn7gjNNUuRFz6drYsGRWEAoHn0pRaW6Vi6qF9+dL1d+m35SUEiLDJXVPPRpan8Ng1DUJZ7vYu6PXQ3iFBtI4ZednaygmT/26akveNRp8TIzG2vxql7sU2nBqCr5twe5nzLV7O133gib/PjHH7n2V18+Dn1quaasGNTW1pZr/1f/+T917f/9v/yXYZtCivros/KsjxTsSYprzea+MNaTJw9d+/bBnbDNX//kx679P/3hH4U+WkUsK4oU5lKn55sUFJKPrlOOayrPspnZ0dNj19YiRLNZ3KaRQk+Hh3uhzyv37vnzS57VsK5lxZakeFHZ889UNY7P92joC0YtFrGAXSGFk8ajWKRrJPvWNauu45payHWOJ7F4VZyi8bq7xndqZZlYJsde1f6+1F1cA0LBsGTi9Ae6PvqDa7Ets3gvy+QZq8J6E5+FTuZ+KHKYFfaS7zGdwz/bs2tlhQVH+l0hX6Lz5Lp1bVku431p+/78Bv34vXCx8N+RSynSpUUjAQAAAOAm4BevAAAAAAAAALBmvHgFAAAAAAAAgDXjxSsAAAAAAAAArNlGZrxq9mCmJ1mIveQdsmYqtk3M+xtt+VxDzRV89qFvriRbUDMNn20jeX9VHOp2qTl8MWxwOPTnN5Qc07If8x2PHxz5PoN+6LO1JfvR8FMzKyXcdCkZfFm+7EyuaZzlEUomadmLmYCa8bpaSe5qmpcp45ncyp5k7SbRwDY79/NkIRmfl7OYh/vw/gO/3ybJbtSM1+R+z6Z+3/fv+5zV93/0ftimldxfzQU2M1ut/HUvFjGr8ezc5+g+eOKv6Vvf+GbYZq55jkm+bCufZZma4bPk3oX9yhhnGa+aSZplqOpMKkv/SZZHubfns3hv37kV+lSyXVNnFyXXkAxOKec8lCxWzQDN9rO/vxv6DCTHdJDkMWd5wc/TjOxMo+uGmU3GE9cuq7hGlZWsbedT3+7FeV7u+bUlew71/pZJzrPmieq0GQ/j+bYyaZvku0TzegsNIjezovBj2pd5tL0Vs3i1z9n5Reij8zjLHNbnI+Qdz+OYV0O/3929mOl7nfzlvV3/TGmeeZVk0gIAAADApuMXrwAAAAAAAACwZrx4BQAAAAAAAIA148UrAAAAAAAAAKzZRma8NkkWayNZff2+f2e8WsWwTs10bZvYp5MMuy4Ll5TX0/O5z+Hsuphgt5QMTc0VNDMbDHwW3tbOJPTZ3tt37clk25/LMp7v02Ofhbg1GYc+vVv+fMbjmBs43vaZe3oFFxeSuWhmy9bn8A3H8Zq6xo/NYBKn4VgyaDWzUnNDzcw0LjGL3u1JpmbXxrlmmgEpObVblR8XM7OXX/EZn+NhzCNc1ZqzGufjqvbn9/mnP3XtJ0985quZ2cWFz3McDmPGooaoTqfx3mmGYiHbfPX5l3G3hd+mGiZzTfIy09xQzYGV3FI9l2ebyGea8WsWwiW3RnGev/X2q659dHrm2otlnJ9vvOG32dvZDn30XrbZ+ckJZkOjUaFhzcrmuebUDuN1l6XPUM3ui2YtL0J+8NWZ2LNZzBPWnOws23Yka5LmrjZ18j0hoc118l2iR8rW5nrlr7ORMR8k2dW1XJMl2bv6SZEce3dnx7W3ZBy2t+MzNpSc1dEwZn/rGNfJ9+FSMpvnCz8Ok3FcWzRjuJ/k/mp+8Ch5DvX7UOdjtgYAAAAAwKbjF68AAAAAAAAAsGa8eAUAAAAAAACANePFKwAAAAAAAACsGS9eAQAAAAAAAGDNNrK41sXFLHy2WvnCRL2e77Na+j83iwW5qjIWRPnG26+49mIZC8HUsp+zc3/so6PLsE1Z+MIgr7xyJ/RppTjQweFe6HN66ve9kmIxXS9ekxY8Kqt+6PPGW2+49tMnJ6HPfOWPtTXxBVHuvnwvbPPk2Bd60gJnZmYDOeVVrQV7zLRW2s6uL1407Mepq7VXsvutBaSqrBCMFKfqS6GvqoqFaw73fcGtQRkLKYXaMEmxmEIK1dx75dUXts3M/vz7P3Dtb/6j3wh99Gw+/ODj0Odw119DT6okaUEkM7PZzD93JxdJkTutv5TUY9JnQQulhYpI2UdJNbVer5V23I/++9N8JvN+OxZTe+Xll1w7m2vNKiumdYXs/OSzRu5DU8fjLGU9nIeiWGZF7+p1Qq+rLwWQ5vO431qKXk22dkKfpjmX/cxDHy2m1ZNJ0XTJXNN2G8dG14CUTKVB6W9CVcW5VhZ+Lcnui97LwSCOeVn4TlpIUttmZhMpwFWVcV1rOn2e49r8wU8+cu2TE//9k53vQgpw7R/shj5vvuW/Z+/efSn06ff9vmspRqjfwwAAAABwE/CLVwAAAAAAAABYM168AgAAAAAAAMCa8eIVAAAAAAAAANZsIzNezy9jxmsneXmXU9+nKGI44mg4kk9in9u3fB6dZiOamS0W/rOHD49c+9NPH4ZtXn75tmsfJlmIut9Rkt23Gkq2oPlcvr1dvUazfuW3qZOc1cXc5yNWYazMpqenvk8l2Y2TmPd39/ahP3Ydsxs1O/TL+09DnwcP/BgfHB649s6Wz5o0i/moWX6r5jsWRZKRK1mh07Opaz99Gu/32Zmfj8tlHPO+5tImeZ6FxBhqhmbbi/ttJET15OQ09BlLTu14PA59RiOfXdus5NhJxGIl2Ze9kLJpMdO1iyGvRchn9X26ZJsQmZv0kdOz5So+3x98+IVrz6aSLVnHDOenT/0Yv/5qzKzUQNleEjDbddfJrZRs09bPgcUiPmPLhc+qXixjHqoudV0yIYcyJ4YD3764TJ5veQ7bJt4XzXCezbKMV78fzT7VPzczMz1WMua6XZH0GQzkWZW5NRrG9adu/IBmc9Y6Oefk/s+mupb4e6n3xMzs+NRna690gM1sPl9Jn/gsTC/9sR49PPZ/PovbaCb2LMak2+7+vmu//Y1J6HNw4DPOO1lw2jSfGQAAAAA2G794BQAAAAAAAIA148UrAAAAAAAAAKwZL14BAAAAAAAAYM148QoAAAAAAAAAa7aRxbW0uJGZmRW+UMnp6blrDwax4MjWzrZrV8l+tVBNWcZiS+HYJ77YzmIRC5loAZR+P+63keIh/aQY1N07B9LH7+cbb78Strl16AuGpdfU89f06PFx6HL//mPX3tp6Q84lFtfS8ez14rHnS1+06fg4Fi/SYkCtFqHJCjRpUZ829tHNkro61rb+2EePT1z7z//iw3hsmVv9USy+08m/cxRJMaOefHZ86sfmUAp9mZlJjTb76U+/CH3e++53XPv27YPQp1n6Akdtd40CV3IJr0pROTOz0UgK6STPYSFztKr887O7ux+20aJTq/lF6HF6+si1Ly7i+F2e+8/6/f4L22Zm29tb/oNsHkk7G79r1B0LO69l3ciK53Wy58UiVjz68QdfufaTx2ehT7p2yJGuOrZ1yTyXj8p+3M947OdAVV39fBdSOKtfxblWS9G4xfLqIli1FKuaz+N4yvJju7vboU8tRSJnSXGy83M/j7vOH/uv/vrTsE1Z+u+ObK7VtcyTpLBXK3OpbuJ3WyA3M7kt4XtgVcf9VlKkq5QCZ0VyLwEAAABg0/H/ZAAAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFizzcx4LWImYNv4z86nPqevO/dtM7ODW4euXQ6S/UrmXvYqenbp8/xOz2auvVrFrDzN8styLcvSn0/IRjSzuvGftZIcWSYhpVtbPluwSTIgV43fz/l5zFlVpWTQLjUzMDnWSsfBzM5Ofabm6Vk8tua19vQ6szkimYW9NC9TJeGcko94fiGZvnN//83MenK+qybLgPTH6if5ma3kYU5laGZ/FY99duo/K/vZv6f4sTk7OQ09Ls59xmfRk/FM5tpyKXmjSSTkaulDaBfS/tneXatpfftgP+a37u6MXHswiDf89q0d1y6TSTGSPN4TmZ+3bvnMZDOzO7f3/Pkmz1gyRQPN9M1oXmcrz13XxmPreE6ncX08O9Ws6rifnsyBrtV1LY5n01z94OlUGo3is3Ch66zMmyLJxN7e9nNiNIp9NBN3Potr1GzqJ7Lmo2oOtFnMeD16GvOEOw1ATb4XuivyrOeLmAur62WWFdyFrN3kYZX7W8jwFVW8T3ovW50jFp+Pvb34TJW6bz3dazxPAAAAALBpNvLFKwAAAAD8uuq6zur337flD35g7empFXt7NnjvPavefTf9x3AAALCZePEKAAAAABui6zqb/f7v2+r73//bz9pHj6z+4APrf/e7Nv7e93j5CgDADUHGKwAAAABsiPr9991L17/Rmdnq+9+32Z/+9a/+pAAAwC+FX7wCAAAAwIZY/uAH6ed/8xvXx/+PP7JP/2+V7XxjbLtvj5797zfGNjyo+CUsAAAbZiNfvDZNLM4xX/jiMAsp6jObxmJGuk3ZG4Q+de0LtpRJwaNazmexkgJSyfleXkphmKT4jhZXKsv4A+TGpKiL7CerY6MFrVZJEayLC1+g5eQkFrhaLvzYzGZ+jLe3435bKfSTFR06OTl/4X7NzIqeH5tLub8H+1thG/2LphacMTNrpeqMFi4yM9Pb+fSpL0Q1HPoCPmZm4/HYn0vyW3I9VpXMtUAqNIXiPGa2v+8LSO3t7YQ+g6rv2h/99NPQ5+mTI7/fPX9NWckkLTRXxkfBhgN/7MU8Ftear/xn51M/PycTfy5mZq/eO3Dt119/KfT55jtvubYW0jIze+P1O67dSHGgN998JWzT7/ulM5vn16H/3ygriqQfhppD6f/BkoJM81hcq5IibP3s26CnzasrHtVakCvZra4TWWGvRtatnlR66nXxIZtd+uvUNcwsFq+q63gNPRnzfv/qZzXeh+TKdTfJDdePmsZvVCT3O3yU9tHxisfuD/x3ZF/miBYRNIvfmVUZ96vbzeZxzd+R8ymkGFiXfM8CwD9U7Wksgvq8QX9qi+PaFn96bk/+9Od/rx7slbbz9rOXsDtvj2z37bGN7vR5GQsAwNdoI1+8AgAAAMCvo2Jvz9pHj37hny9Xk/zz08ae/tmFPf2zi7/9rL9d/u1L2Ge/jB3Z+O7AegUvYwEA+FXgxSsAAAAAbIjBe+9Z/cEHv/DP7/yf/zc2Kd60s49mdv7RzM4/ntv8afyvPMzMVheNHf3lpR395c//67ZqXNjO30QUvP3s17Fbrwx5GQsAwN8DXrwCAAAAwIao3n3X+t/9blpgq//d79r4937TJr2e3fnuz+Ollmf1sxexH8/t7ONnL2Rnj/KXsfWsteMfTu34h9O//awcFrbz1ujZr2O/8ezXsVuvDq0oeRkLAMDfxUa+eM2+3o+PfS7o0ycnrp3lwh4fX7j21suHoU+h/7KbHHwqGaSrpf9LTJsErRYm2XiWhH7KwdKkxiTTU3pkG7mmZiWamT1++NS1z86moY+ez0Iyc3vJsXvmj61Zt2Zmjx4du/Y8yWGcbPmpuZJc3fm8DtsUYz/GRRHPT+I7rUtGXe/nxbmfR8dPY+7Wp5cP5DhxPmp2Y5Yvm332vNuHu+GzvX3/2aDfD300L7Gpk7zE1o/fWLJsF0lOaC1Zy20yicfyWRaXqRGpe1s+i7VfxR13slGW6auRZlnE2Xjs59pIVsWH9++Hbe7c3nbtsoxjHs4l+UzvQvZM6drWddfJk/VHe/nl26HH1o7PAv7k469Cn3PJ8NXpmQx5ON8mmRRtd3Vep64l18m2vc79blq/dgzScFt/YeHZtbj+mNyXl1+9E7rsbPus4pOTi9Dn/NyvxZpfXlXxAao0Hzy57rrR3NrY6c6hn9erxl9nlhfeyndUk6xhy6XPbL44i9e9f2vPtUdjydK+6qsQAP4B6fV6Nv7e96z/zju2/MEPrD09tWJvzwbvvWfVu++m34GD3cpu/+6O3f7dn3+/ry4aO/9kZmcfzezso7mdfzyz6Vfx73NmZs2itZMfT+3kxz//Hir6vZ+9jB3/7QvZ7deHVlTZ/68BAACZjXzxCgAAAAC/rnq9nvW//W3rf/vbv/Q++tulHf7Wth3+1s//Ya2eNnb+yc9/FXv28dwuv1yk/8DVrjo7/WBmpx/8/B9ie2XPtt8Y/qyA17PM2O03RlYO4svYruusfv/9a788BgDgHyJevAIAAADAr4FqUtrBd7bs4Dtbf/tZM2/t/LP532bGnn08t8sv5vofc5iZWdd0dv7x3M4/npvZs/+KrVeYbb0+st23Rz97GTu27TeGtvyDf+PiEtpHj6z+4INncQnf+x4vXwEAvxZ48QoAAAAAv6bKUWH735rY/rcmf/tZs2zt4rNnL1jPPprZ2cczu/hsYV2dRGW1Zhefzu3i07nZ/3xiZmYHu1/ab7z+fessJuCsvv9967/zzt/p17wAANwUvHgFAAAAAPytclDY3jsT23vn5y9j27q1i88Xdv7xzzNjzz+ZW7uKL2Pv7H9iZnnGvZnZ8gc/4MUrAODXwka+eNXiS2ZmP/nJ5659cR6LQak/+/77rn30eiww863feMW1P/3sYejz8cf+s8XCFxzpFbHYycef+mJLEymqYmb29pv3ZD/xryZaSTQUeUkKey1X/vze/+FHoc/9B36MV0lxsqLn9/2TH3/i2lVS5XQw8GPxF3/+YehzceELrXS9mAl1ce6L+vz4fX/s4SAWM+r39107K/yzquXeJf+JkxbG0sI1S60EZWaTHV+U5uBgP/Qpk6I4V2lWUsitTYr6SCjX2fll0qOnH8Q+Mrm0SNJyGYug1TLXRsO4pJRa+CcpyDBo/NgMhv7+VoO4375U6UoLKTVXF3v76gv/fM8v/fhdnPnCfmZmP/7hB6795ttvhT5F3xcI665RXSurHxQKAGpRvuzC5dkN98CSQlTJA6MFmdRqFdcNLbaU7UE/67JCffrfN3ZSsDC5bC2olx1bi+d1XXymej0/t8J+evG6e3JfxqO45o8nE9e+vFiEPlr4bjLxRab6ZVxHdF1YruKzqtdUJfs5uOUL9V1c+O9ZLbCYyUq/jUcD1x4MB6FPIwUUu4Ef9R6FXADga1dUhe2+Pbbdt8f26r949lnbdDb9cvGzX8X+7GXsx3Mb9F/8/9Xa01isFgCAf4g28sUrAAAAAGCzFWXPtt94VmDrlf/m2Wdd29n5//371n1+9ou329v71ZwgAABfM35CAgAAAABYi17Rs/F/+Xsv7DN4771f0dkAAPD14sUrAAAAAGBtqnfftf53v5v+Wf+737Xq3Xd/xWcEAMDXYyOjBr768lH47OTY5yxmmYVKojrt0aOYJfTyy7dc+9NPY8br5dTnQpYSLthLkgTnM59Xd/T0KPR54427csKhi7WSUak5sL0kH3VV+2M/fHwS+iyXvk+vF6+hkNkxu/TZrMdHcTz393zW6eU0Zhh2cqyiiBdeynXOZ/7Yi3nMGqylympZxLRBjeNtumTQw/3051LXMRNyMPA5jGWSR9jv+wHNsjm7TnNV/fgdH8W80ZMj/59x3bl7K/SZL/x+Ym5ozLY9P/PZXGlupIzNYBSzd8u+H4uyiH0Gktmrebijic9LNTOrdDyTawrnkuQx72z73E19Di8vYkbZoPLHHmWZldpOMpE1szmrQJGtL8+ryjieJs/UfB6zbU+OL1x7MU/yg6/I/W3aeG46j/LT1yzWrEKy30+nma8Zza1N1kfdb74fPZZkbSdzrZLPmiQLWvNvLTm/+dKf3+oaeeY65m2YWPGZv/2Ne6HP7t6Oa5+c+TmS5VuPZe4XFp+xsrx67esPk3nsNnrxHwMANkuv17Px975n/XfeseUPfmDt6akVe3s2eO89q959N8+oBwDgH6CNfPEKAAAAALi5er2e9b/9bet/+9tf96kAAPC1IWoAAAAAAAAAANaMF68AAAAAAAAAsGYbGTWgeXBmZp1k42msYZVkajaN3+b8/DL0ef/Hn7r2LMkObSXXbm9v7NqTJH9ytfJ5iYN+zDHSM85y+fSzSjIByxinZ/1Kxy8eu2n9+W1N4pgPKr9dUfhjX575bFEzs8XU5xEu5jHjVXZj2/uj0Gc48Bc2KAcv/HMzs07GatXEzMqqlYMn+ZOlnGAR8oTjRk8ePHph28wsRFklx9asy1ryeptVzKcs5HmZXsZMyOlMPktitdqVP9Zi5u/dYhnHs5ZnQ/OPzcyGI/986H0yMxtKXutgeJ08XJ2fcU4Mh/7Y+wdJ9u7gDdf+6KOvXLtOIkEPDg/9+Q5ixutS1gDNLTYza3Q6JmOjub9ZHmo49sKvY0+fHoc+J6f++Z1O4/q4Wvn9tJ2GqMZ1IwxXG3NBwzWl1y2H0jmQZcOF3SRjJZvp857tuid9uiSbVU/4088fhC47Jz5POMvVnUqWto5VnnXqP+z343zcP/DHfusbr4U+/WQePy+J9LWFrEmTccxq1Xze+TSuUZrj3d9/8bkAAAAAwE3AL14BAAAAAAAAYM148QoAAAAAAAAAa8aLVwAAAAAAAABYM168AgAAAAAAAMCabWRxrWVS4Gox94U3xmNfKGR3JxZoWkmxoPOzWDzmTD5bLlehTyMFhLSg0DgpJrK3v+XaO8n5hcJYTVKAS4u4SAGXsozb9KUoVtvEazK5hqqIU2Fnx4/xoPInXCaVvRqpRNS1sTJRf+iLpoxHsYjK1sR/VhV+jFereE1L/WwVK8E0K73uOH6jbX/db7z2smtnxZamUiSnWcWiOXrvtPibWSzqs7er89y3zeJ92NvfD30OD/f8cdIKPf6zWNAqnq8WXCurOCe0T5EV4Br7IliVFDTTImNmZk3jb0RWgKustEhX6GIXl/7D+w+euvZiFufaZNevG3sHybohc3+VFCeLBaTi+fV6vlPR82OshYvMzGazmWvPF/H8dra3XfvJo1gsr5HCTnrs4TCuGyt5QFbJGtAL15DMrVLXG5lHSTG1MHzJeFZ9mbNpcS2trhX3o/QSlsv4PfbwKz+35rNYfLCUQoKFrPFNHeeRFoDsJc/qcun3+2MpLGlmNhz6sZgv/PmF7yMzq4Zyn5JCl7OLc9d+8CAWHhtIwcRV8l0MAAAAADcNv3gFAAAAAAAAgDXjxSsAAAAAAAAArBkvXgEAAAAAAABgzTYy47XpYobd3dsHrj0e+czP4SDmhJalz7176e5h6PPSy/6zs9Np6KPZjIVpVmeSdSrxdJfncb+aHTvox6xYzRoMOYdJ9mBfMvZevncr9JlLJmm/H3dUScZi0/htBqN4vq+85o9Vt0nuZum3q5JZqNG1teShrlYxN3LQ9zmhXRf7dNZIn5iFqFmmReHby0ufV2hmITO3TLIQNS9zkGTk9uSG9lqfbbyaxzzPWo5V7Mcc2NHA96n6ybHlMz1SNUiyjCc+u3hvZyv00Tmbjblmuuq81n2YmbWt5h3HPpovu1zGY3/2xUPXPjn1+a11Mtdmc/+AL5I8yiJcd+hiMTw06XRF3GjXXZ3Xm42N9tHsUzOzxiSLVcZ8OIzrbtX349VmmaQyGG2yTmifnrSLZEA1Y7jfTxaXcJlJBm3cSjok2dqSd9u0Waav3y7LqS0r7aPzKB67kQzk1Spmx15c6LMQ++zs+ue5qf281nMxi8/hcBjXibnk3T5+/DT0GY/Hcmz/51mGMwAAAABsOn7xCgAAAAAAAABrxotXAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1mwji2vdvRuLQY0HM9eOBWaSHXW+oMf2OL5nnp5J0as2FlrZ29n2x5YiH1mxoOXCVwZZJsVttGjPoMqKDvl2IVWniqTgSClFmyZSAMnMbDSS84mXbZ2MxayVYiy9WBhmIIVVJpNx6FP2YvEVtZKCPFrkpU3uUyEVmYoyTu8u1KZKivpIIS9tj5LiMV139TXprcrmrM4tvabFIilU1GrhsdhH53WvFw8+GMi8Gft5Uy9iMZ7x2BdX0vPNVDqpLY6NFhmrssI68lkvuZc6bxbJNTx8dCJ9/CQZjmIBqcm2H5vRON7/5TIWQlOtFFwrkmvoSTElnfurOhb2amTOnifF/fT8esU1CntJcaWeVsEzs7EUOlzM56HPSo8djxw+1T7Z+Q6Gfm5l66MW7UqLk4WD+aYWHny2Y98sk0JUe/u++Nzl+Sz0qbWqlBRc6yWF+/qVPIfZ6dX++7BO1uGFFF3UQ+n3j5lZ3fgLXyzifNTCbZeX8bqPTy5cezTwRQKHI188EQAAAABuAn7xCgAAAAAAAABrxotXAAAAAAAAAFgzXrwCAAAAAAAAwJptZMbrZByz3M5PfCZcIeFzbRJSWpj2iZmLT45OXbtKckEn463w2ZVC/mR8x61peVkmYAy/1HzZLJxVMgGzDEP5LHsD32jeaLimqAjX8J+en5j38fvNcnXb1t/fMrmX/YHPNSyzvFG5hsPbB65dJRmvq6Vk0rZxrs1mfg4PBjE7tN/3+5b4VlstfE5jdqzt3e3QZy7bNXWcNyPJMh30ZWySHFu9D3UTr1ufQ82FNTMrS72//s+z8ZToy3Qa6ZzIaEZuI5mV2XM5GsZrCPuV/WRzVnNps3VCL0z3ouf7s4P5XSRZp2NZZ+s2ZgMPaj9+Oh/LJJdaz7BI8q0788dKM7r1wiX3V59ls7j+ZFnQ+bG0j+9UVX4tKZMs49OzS9eeTi9DH83bztbvLcnFrvr+2Fk+6nzm71OWW9t1fmyWs3jstvEZyJ1pXmscvFLGZrmM82hry1/TahWP3bOnrr2zvStH5t+JAQAAANw8/D8ZAAAAAAAAAFgzXrwCAAAAAAAAwJrx4hUAAAAAAAAA1owXrwAAAAAAAACwZhtZXKtexQJCWtWl1VfGXXyH3EpBmTYpvzMe+aIf/TIWW8rL9lzxp1oQJ6sxdY0iU1oIJhboSQrrXHEuZqFOTe7KIjRZAZf/5J2k+4n/JiBFkpJiQT3dpEiKGWmhpGvcl50dX6xqJylepQWOumTHi/nctQdJgSYtRKSFn54+PgrbXE59sZ3ZLD4/85kvmnMxnYc+AymSEwucxfGcSdGu5UqL8cT7MsmKa0khr06rOCVFiLRLpcXAzGwohdCWSVEfvVAtyKTFjczMDm/t+z2EyWfhIbtWUadkjLU+VN1o4ax4bL3O2TzOibKS4lp1UjhJ1sMyFOWLY97IsYte7DMejeST+LxUAz/u+mwMB8nXl+4mG/Pr9NFN5F7Wq1hAajTSopBxrl2c+4Jbq+S7rpEiZ9vbfr15+ZXbYRtdF87PYgGuTq6h7eI19GSZ7WRwkvprVksxrbNeXAPmsxcXKzMzGwz8WNy//8i1Dw58kUMAAAAAuAn4xSsAAAAAAAAArBkvXgEAAAAAAABgzXjxCgAAAAAAAABrtpEZr7+MLKYvZComuaBbE8mbTPIII8luvEZIoOZGPvusu7JPJ9m1mjVYaGapmVWV/6xIrrv5JbIQez3Nd4yWS5/v1zRJbmQ4dnr3ks9+4ak9Ox+5deE4ZtZJ7qJe07PPfLuuffDhcuHzUs3MPv/8S99nHjNUV5ILORz1Q5/+wH/Wytjcv/80bHNycu6P08QgxuVCPtPBMrM7+z5LUvOOV8kN78ksWNbx2AMZUB0HM7NGxjjclWvkFGf3sipDGHTo08l41bXe3+R85RrqLDRZnu98msuHyX70sgrN6kyesZnMv36SqVlV/v4eJ9nAemzNk63KOIfr+upnbCDZu8Oh5qOaDSf+s1KuoUnyhBvJAh4MYp7wFZHdz8hSPJv5zNTLy5ihqmvdaBjHZnfPP2PZs7DUzNQz/3zP53H9GQz92AySHOX5TNakdH30c6JX+Gsosr8xyPOTxDFbK184bZJlvFr6NeDpkb9u/S4EAAAAgJuA/ycDAAAAAAAAAGvGi1cAAAAAAAAAWDNevAIAAAAAAADAmm1kxmsvyS3VPDrtETJLzZI4x5gr9/Krt1x7Po+Ze5dnPvtQMxaTiMWY3Zjk07WmGZBJ/qT00QjIsoxZnZoTWoacyyR7NRm/XqcfynW38Xzns4X0aUKfpr06A1LHT8cmy8vs5Jq6XhI2KNeUjnm4d3oNcZuF5L5eXk5Dn7bx+6nKuJ+i8J9J9KldXsT9Xlz4vMnJ9ij02dkZy3FCFyslG3gwkLnVizmcGgK6SnI3xyOfN1kmB+90LkkXzTb+2acvbJrF8atXcT6OJA+zL/GYT49iru5f/vX7rv3G66+EPvu7e/JJMh+vkRetj0fX+jXq4vIybKOZpJNJnBNlz1/o7DJmh7by/I5Gfh5VSZZoITmwqzauqfqM9bJAZiW5oP1+XPu6pe/TNPF+h7zbLJ5X5l8pebhFsqZ2sk7UdXwW+hL7WlYxB3Zra+LPRe7B2Vm83+dnp649HMX7Mtnyx6rK+DwvJWdV1+pVE6+pkzFuk5znWh5ozc1+diyf6Tqc+kzaxSIeGwAAAAA2Hb94BQAAAAAAAIA148UrAAAAAAAAAKwZL14BAAAAAAAAYM148QoAAAAAAAAAa7aRxbWygiixoJFWnEmqLWlVml58z6yFp65R4sW0DtA1yv6kb7hDQaGsj1xX22qRqXj0Qq677WVjI81rFLgKu8iK0mgxrWwfUihJz9fMrGlfXNhLi2SZxfHUsTIzK7WIT1pcy7dDEZ/kugspGJUVNBsO/OOmxazM4tyfXkjBo2Q4d7a3fHt/J/TpS3Ggy6QgU9i5DESVFMXSGm1a6OvZ+fliQYNBLCikdDyzZyUUiMvmhDzz2dqyWvkiPqOxP79VHYtiHZ+eufatW4ehz+6Ovw/J8pM+v6rt/PHrxhcvapJCRSbbZNXUZotYTCvy57dY+EKDw2Es2jUe+8/qOs61UFwrWQPKvn9etKhhr433pZK5pYWfzMx6WqjvGmufFo3LCnuFvSS11GrZTy/uxoajFxei2tmNhbP29g5cezyOX+2zuT92kRTLG0hlubNz/zw/eXIUttEnMyu6aOl3uldLUa6FnG+T1aYDAAAAgA3HL14BAAAAAAAAYM148QoAAAAAAAAAa8aLVwAAAAAAAABYs43MeM2jRTWU9MV5lD/78OpjSbvqZ0Picw31UL0s9FNzVrMs0Su2+dmG2umqvVgh+aKjYcwEvJB8x3T0rh6+oKo0xzSOZ7jK9DiSAXnlTszKkLMaAxT1/Hpp8KYPE9Q8Sj2OmdlA5s1Fli/blzzh5H5rLu1yWUuPq/e7WC5Dn67zY1GvdL9mncQwtisZh2SsJpIve3jndujTH/hjZ9M8DKnmcF5jMmZ99Nnc2Y35t6+/9rJrX0j+7TzcA7O9vV3XPjjYC300p1azWs3MepLxmq0lhcxj7ZNmYsv6uDWJWayLxdS16zZeZ1+el5h3HK9pIWvLdDYNfTTnd9zFvNFGMj9ryXTN0nH1mc/6NDL3r5Morvmy2jaL2cBdyKk2m0tuaU6eO2kPRnFdGw/9sbe3Yo7ygZ5Ok2VM+8+Oj32WcTKFTUe5rpNr1EzfZA3Vx7dZ+g/qYZyfAAAAALDp+MUrAAAAAAAAAKwZL14BAAAAAAAAYM148QoAAAAAAAAAa8aLVwAAAAAAAABYs40srnXvpVigZ3bxwLW1OFBWsCcrXqT6A1946vAwFt85Pf7Mf3CtolNaDOzqc9HCSmZmJ+e+0E8lxWMOD7bDNpOtiWvffelW6HNxdt9/kFzTVWec1TvSYlVadOrZhlePxVWuU1hHixvl4kXofdCiTYNBLFZ2eHjg2qcnZ6FPUV09JzopIKR9+oM4nqWOcRH7aEGhRVIwqpLxuljM/bkl91uLpx0cxOdnJfuZLmPxnZ2dsWsXUj+ormNVn1ZmQVZMTQ2TQnNvvu6Laz18+Ni1z84vwjYv3/Vr1HgUi1ep9HnRdjIntI5TJ1tdXMzCNk3tS0Zlhb10uEbjODahYJ3M4cUyHns+13JVWWFBfz5Hx0ehz2zq50m98u2qTIq9jf19yOaEFiOrmzg2nYzXcOTHZjCM+y0r/1mXXPf2lj+/5SqZ17IGaEGzfrKm6mVmj4JOrWw/R099IbTT01M9UtimkIc1+x5rerLeJIXHevLvwD2Z+FlRQwAAAADYdPw/GQAAAAAAAABYM168AgAAAAAAAMCa8eIVAAAAAAAAANZsIzNerZeFIepnmhEXtyk0AzJJBp3PFq49my5Dn5DV19P31UlG4JXna8kpx2v44vOHrj0Y9F17f8/nuZqZrZb+mto65nlq3l+WP3nV6dUrzXI0e/z4xLWLJG80iWYMijDmkruajJXmY2bXVEv2ZVXFk+nkBHW/WQ7n4a1D1z5OMl6XC5+fmGW8Np1kc7a+neYc6vRLnp9Gchc1K/hZH3+sgeRaLhcxm3V26TM+x6O43+UyPlNqa2vo2prPO1/Efczm/nxeezXZcZJtqvSZGlS+PR74/Fkzs2Hfj02WJ9xqLm2SbXyduGPNJA1ryTWe3Zmsc2ZxHu/tboU+A8nEbWWyPbz/JGxTS25plonck4dzkeT+6nzTW1kk6+7FhWRiV3H9mUz8XBsnuclLOZ/h0N/fg4M4Vq1c0+U05t/qP3Xu7MRs4JVk2Y7kORzKfDUzK0t/L4fDOLF07Tg9mYc+Dx75TNcw9ZLJ1rTx+0X15K8aRXJf2lZz2/1asqzjHAEAAACATccvXgEAAAAAAABgzXjxCgAAAAAAAABrxotXAAAAAAAAAFgzXrwCAAAAAAAAwJptZHGtpOaQpRVkrhKqK8Udf/WlLw5zfn4Z+ty+dcvvpeeLunRZFScpZmTF1eefFuiR/RSFLziSHXo+94V0suJGeig9XTOznn4o163nZmY2u/QFUCaTWJiolGvoZcXUCn+v9HyzOdKTbepYGcY+++wL13715ZdCn+GdfdfW68wKe62kgNmtu7dDn07O5+j4OO5n5fc9GvviO1UZr6lu/X0pksJZ/cp/ViXjt1j4YjtaXKsMReXMBgMpipXcmFLOp0yqq3XybLZSdUrHwcxsMJQiQ+m6IR8mc02LTOn5ZcWMJtt+XmfPbiPzRK/p2em8uIicmVlPrkHv5c5OLPTUSCWqi8tYSOn0zBd/ml7GAly7SXG857Xt1UUDp5fT0GXQ9/ut+v//9u6kSa4zS/P7uYNP4TFhIkFwyspiVoItdamI6m5Vm9Wm1bLeiJ9Cn02rWpeVybSSmdSSzCQju5WdKuZMZjJJEMQQo4930AJkMs5zDhlgwgE6yP9vQ16P907vfe/1wOsez4l9PJYCUeF508d7YS3Puq6LBbgauVeHo6wAl7++V6/su+UrV/bCOqdS2KsqLy9wtUoKH07G/p7anfoCitUgjjUdf1VyWc7P/HX4+NOHoc3pue+/qpLrknxU20tRvnqQFFSU7cSCcfEZb+b7Zr2+vEgfAAAAAGwbvvEKAAAAAAAAABvGxCsAAAAAAAAAbBgTrwAAAAAAAACwYVuZ8Xp4sBteayRH7rP7R75BjIyztayj+XpmZm3vc+QGSThe1/psufVioQ3iviW78eXXXwltdqc+R7CuY87h62/ccstjydQcjfzyFwfklm6+fDW0mO763MAsHlNz+B4d+QzDjz68G9aZzX3fZH1+65bPP716LeYlam6uLtd1liNYfuOymdnNmy+55Z2dmB3atn5f68b3wyCJpF03l+f+7h8cuOXROObfLqX/Pvzdh265KeJYG4/9uBkOh6FNIZ+x3E9yf00ySGvN9xxmmZV+eTaLWaLLtc/9HSXH17adLPvzbJuY1TmZ+LE/n8dz0jzMLPuyHfnM1MHAL0+TnOJrV/y1PJ/HrE7NOk0jaL95lZTeU9kYXsgz6uHD09Bmdrq8tM3x0ZlbLuWCr5dZfrTvvyzPcyCZvYMkF9Tkcdj3eo/F52XT+LG2XmdZonp/r0ObleSJ7k79vg4OYp9P5Troc8MsftI5sfj81kzkQq53mQziECeb5G+fzvw5FXW8D3cP/L46uS+bpD91T32y707GwGCY5FAP/PFoPG+f5QkDALZS3/fWfPCBrd5/37rjYysPDmz4zjtW374dsvUBAPi+28qJVwAAAADAi6Xve5v/4z/a+r33/vRad++eNb/6lQ3u3LHJu+8y+QoA+EFh4hUAAAAA8NSaDz5wk65f6nuz9Xvv2ae/umLNtb+0wV5lg93KBrv1V///xX+rUcnkLADge4OJVwAAAADAU1u9/376+pfzqPUnP7ff/l+H37iNoi7cROzj/6+/+v8vfyavVUPKlwAAts9WTrzWdfKmKZmZp2cz/+M0QdG/NhjGTMDV0uccDsqYJdlKBuCre77bfvJyzKT9WPITf3x9J7SZ7vjjabp43leu+izJQcgtjXl6q5XP0/vNh5+ENmfn/vgODqahzY9ef9ktV5LD+OtffxTW6eV4miTrtGl9f9ZJFuv+ns9L1E+9mzZutyjktSQwc3/fX6ssg1ZXWzc+v3M+jzmm+wc+p7brYn92kvmYfZJfSFijZp+uVzGPsln741svY95op/fPySy0OZ8vw2sXZdmsmm+8auP900nmY5tkX2qna0Zuts5cjrfrk3tXsiWX69g3hez88NDfc1euXAnrVJIxrDnQZvFeyDxR7qtsZijPsZ1pfLacnPrrq7nFZmadhGgOkwzf0cjn20p8q83DGmZDyerMxvlg4M9Bs2PN4nNBt1MUMSdUx5o+C83MCtnVaBS3M5n66zvd0yzW2J+1ZLOWuiOLfb5K7mc1ku3qfszMRkN/vMske7eW5/dwFN8Pdyb+NX2WZNnVba/5zPF6r1eNtEmeUXLtOsl0rXTwAQC2Und8/I0/Hw7i76Cqb3pbHTW2Okoy9L9BOSr+9C3a4V5l9W4ycbtX2XD38c+Ge7XV08rKmm/XAgCena2ceAUAAAAAvFjKgwPr7t372p9X1w7ttb+8auuz1tZnja1P2y/+v7V2Hj9E/za6ZW/LZWPLB99uwraelI8nafe+moz9cuL2qwnc2r+2U4UvTAAAkGHiFQAAAADw1IbvvGPNr35lveV/2XPlf/g7e+ntW+m6XdPZ+qx7PCF71n41KXvaxtcuTNx2q8v/yuibNPPOmnlni88v/0uUPynMBlOJQ/jim7X17uNv1X6VXftVJEI1Ib8WAH5omHgFAAAAADy1+vZtG9y5kxbYGty5Y/Xt21+7blmXNjosbXT47f6J2q46P0F7cXL24mvnfjK3T6KYnlhvf9rHt1FU9lVRMc2x/XKSNnmtHBZM2ALAC4qJVwAAAADAUyuKwibvvmt/+M/7Nj76wIaDmQ1uXrGD//DfWn379jOZPKyGpVVXSxtfjfnlX6fve2sX3dd+izZ97cuJ1qeZr23NVsetrY6/3YRtOdCCYzJxu5e/Vma1UwAAz9VWTrxWZTyst9/+sVu+8dJVtzyZxAIzjx6duOVf/+bj0EbqPNlbb70e2uxJQaYbO77Ix9VxPN5SipLsSPElM7PVWoqSJMWBOilW1Mgf7ZRJgZl794/c8s9+9rvQZraQE09+gfj/9j90yz/5K/9nQdeux3P66COf6fTwwaPQ5vjIX5dPP30Q2vyrv33bLR/s+yI/1idFcy6vrWV9p32etnJLlRSzWSUFmsq5LzOUFXLTAkLTpChSK4W8YkGhpBiYjJusyNS9z4/c8vk8/imVHt9o5IskpYXIpP8GSeGfceULE2W//hWVP89OimINai1uZFbIL5JVFfv89NRfl0cy9szMbr583S1fue6Xz85jCal9KSClhYHMYt+k/87Q65s00Tb1wBeeGybFjLQvsufjeOzHQFY4qaqlYJSMES3+ZmY2Gfvje0me1WZm5zNfGC0tMiWHs5b7bpwUxTo8OHTLy1UsMqXD+JVXb4Q2y/mZW96d+nMa1HGsaf9VScGwwUCOORkU45Hflz7rsvtHi3ZZH7c70QJcSf+pUq5Bq/sxs3G47+K+Z3N/1ItFPAsdS9qfo3FS3A8AsJWKorCz/g37/e+vmZnZ2//+ll1/O/4+8F0qisLqSWX1pLJJ/FXga/Vdb83sQhyCi0RIXvuiXXP+lPm1696WjxpbPvp2+bXVqHw8Eeu+RSvfqt3zr9XTysqKb9cCwKZs5cQrAAAAAODF1DVffYBW1t+fSbyiLP40YfltdG1vzXkSf6CRCBeXT1trl083YdsuO2uXnS3uf4v8WjOrd8r8W7QXM2tlMrfeKSk4BgAJJl4BAAAAABvTX5h41b9s+iEqq8KG+7UN97/dP7+7dZd/i/Y0/2btl8vd+ikLjs06a2adzT/7lgXH9Fu0F5ez13Yrq8bfvuBY3/fWfPCBrd5/37rjYysPDmz4zjvPLM4CAJ4GE68AAAAAgI3p2u/nN16ft3JQ2uhKaaMr3y6/tlv1PvrgT9+iTV67MHGbpLk9ud7+9E1d+/TJVyuqwmfVTmP8wcXJ3Hq3tO5//5+t+U/v/2kb3b171vzqVza4c8cm777L5CuArbKVE6998sS/efPQLb9y84pbXi1jlt/1q1O3PJufhzZHD33W3Jt/8Wpoc+umz3ys5VPb8yQDcipZeOdJNl6z9J8gDgfxDVXfNDT3LmT7mdmRZNtmmaQxADVm7j06mbnljz6665ZvvnQQ1ikkX7RoL9/3J3+MGa93X/OvXbnis3fLJNdS31/TPNSwzuVvyqFN8gHyYiGZlev46bBmxWaZqYOBvyVffd3n6rZJlqjJGCiTP/G58Yq/lr9N8o41mvGNH73mlseS3WlmVsg5lMlfXQ1qf06as2uWH/NFWYaqXvDJdBqatDKuxzuxzem5f3bcf+TzPT/71OcWm5n99Kd/4ZbT7xToKV0eJ5xmfhYStKk5q3UdO3266zNdd3fjtTuf+edW2yfZxZdcl9EoPrOGQ398u9OYz6snvlrFfes11wjarDuHY388WS5oJ+8voySPuej9ekPp4+xZrc/iLDN3oc98zXO15Hr2+vP43NC+6pJrOZRny36SMb1cy3tvK++ryXYLzZNNxkzb+O1qdrmZ2aDWcV184zIAYLtdfLvlG6/PV1EUVo0Kq0ZDG1+/vP2X+r63dn7xG7ZffYt2ddZaozm2X07cnj9twbHeVkeNrY6eLL/2yt4f7SdvvG99H391Xr/3ng3eessGb7+drwwA34GtnHgFAAAAALyYXNQAH569EIqisHqnsnqnsslLT77e44Jjra1OH0/Ofvnf9VnjXztvbXXafDGB21oz//Pya29c+fCL481/vnr/fSZeAWwVJl4BAAAAABvjoga+XR0qvGAeFxyrbbD7LfNrm95Nxq4uRh9c+GbtlxO3X8YhDAezb97u8fHTnA4AbBwTrwAAAACAjelbimvhm5V1YcOD2oYH325K4ux/+k/W/ubka39eHsQ4PAD4LsWwOAAAAAAA/kxEDeBZGf3tHTOL+f9fGr7zznM8GgC43JZ+4zU+RftOinNIESctmGJm1sg600kstLIY+S7omssLzOjRrZu477jOk/zCEc+7k3PQdxgtZmVmNhz6cxoNksvc+fNskuJF45Hvr2bp9zU/jUXF9nekWMwk7rqRwljnq9h/p6f+T0jaRo4vCfVppW+q5GOFQq5DlTQKNa+0oFnyJt/LtWuycVT48xyO4nWp5G+xrl+/JvtO7o2v+63jgv3Dfbcc+tPMrl49dMvTXX/xiuRzGh3nebGyy69dI0V9litfhGgyjgWa9J7KCo+dz3zRsz4p6lOW/jUd9y+/7K+BWaybVWRFqGRYZ9curJZsppQxUUr/ZQWkdnd9EbGiin/jV0oRp6yQlh6yFnHK1lk3/todn8Q/9xoO/fXUwk9mZksp5KSF3OpknUHlX8vG43Di+yZ7No9H/vj0faFPxpoWPcvuS33erJaL0KZt/TlMpGBYdrdX9eX7Lgt/vZvVMrTRQpH6Pttq8S0za+WeqpJib528R2b9V1f+PLWvppOsSBsAYFt1zcWoASZesTn17ds2uHPH1u+9F342uHPH6tu3v4OjAoCvt6UTrwAAAACAF5GLGuAbr9igoihs8u679ov/ZWxXR7+14WBmOz++bjt//6+svn37a74IAgDfHSZeAQAAAAAb44trMRGGzSqKwo7nr9n9z14xM7N/8z/+2AY/2fmOjwoAcmS8AgAAAAA25mJiEN94xbNw8YutT5C8BgDfma38xmtVxcMqJOewML9c9dkc8krWifmO7dq3ufvpvdDmxks+43EiWbE7OzHIdL32OYdZBq3mQmZ/FhFyK+VdpU4ySl979SV/fJL3aGZ2euaz/JZJzmon2X1D+aVpcXYa1rFCs05jn88Wfl/tfB3afPThXbf8+uv+nG5cvxKPV/Jw+yRnVTNeiyIZa5KFqO/jfZKrq9mXmntoZjaQTMrsF4QmWe+y7eq+uy5r4/smuy6l5IC2rd9un4xhzZLM+iZkuibnvZJM19APRXZ/++1qP2SyX/tXS7/vUva1t7sb1km6+Alkx/fN+dFmcZy0rdw/ycFk40QNa5+puUyeuyt5LlRyLQcDv43H+9b7Ll47fcYnEb4hZzWOz+T+lgs8mcZn80qezat18tyVNkPJZx6NY//2vd9OnWSdTiSndDaLGa+95G/3ve8rfW8xi9nQy9UqtNFbMxsjOpbWa38sq2Xsc33eDOJjItwvo2HMJdZz2Jn4vPDd5H0WALCd+r73UQN84xXPBOMKwIuBb7wCAAAAADZCP+wr42eRAAD8YDDxCgAAAADYiF7+aoqoATwTF4cVUQMAthgTrwAAAACAjegamXglagDPgpt4ZeYVwPZi4hUAAAAAsBG9TLyWfOMVzwCjCsCLYiuLa2XFYrRqihamyor66MN4OIoVXCY7429cNjNbLX0BlFo+tZ0vlmEdLToUqr6YWVn6ee+ssJL+qU6opZV8ulfVvtGNa/uhze7ujls+PYvnsDP2fTHd8cPlt7/9KKxz78GxW35wPxbgWndSpGseC8Fo8afTE18M7NrVw7BOrwWusqJD0l9FEyvBaJEXLYpVJ788Fvr3Lcn1jr8dXF5sSQuulUkxtbb1xXbOzmehzXDozyErRHXZB8VZf3b6p2TJRznhpWQ/bbgM/rybdSzqo1vODr+Tk9LiUGZmjexc+7xITqqXvtCxl0o6uJdidCEUzcw6uRdW0jezebx3l0t/T/XJs2U49M/DQRULPbVy6gMpGFUlBaRGI184qSpjAa5G/kE2GMa3oloKcNUj2U7SV9M9Xwjt7DTeC0ef+WfUYBiP7+DAPx9HO76vVuu477W8NkiqTE0mfl+7u0nxLyk0pwW4srGm93NWtEv1SbHJkV4HGftJPbNQuK9MvtU0HGiBsLghLRm2WtWyHN8nAADbKUQN8I1XPGN83xXANuMbrwAAAACAjdAP5vnGK54JMl4BvCCYeAUAAAAAbISLGijiXyoCG8HEK4AXBBOvAAAAAICN6C+k0BAzgGelIOUVwAtiOzNeY+BjiEfUqMamTbJOK58/uCf5f2ZmtWQUFmXMLKwkA3Aw8MuayWcW81vLKm5X8/OWSe6d5osO5VgKi321ku387Oe/C20+/vhzt3xyErMQx2Of1fjm6zfc8pXDaVhnsuMzC5fNUWgT5vuT3E3Nqe0kU7NM1qkr3zdNETMMl5KH2TQxH1OzJVsZW8NBktcrWZ1ZFuJQzknzMrN9nc99tm2b5Duenfo2s1m8lppjeX4+D21Waz+Oh0N/fA8eHIV1TiVDczqNmZUv3zh0y1lmqn5Mrb+kazbv41VkTCRbDZHISRvNx6xqzXi9fJ0sMzfG/ibZwPJanxyhrtZKXmv2/Dk5OXfL83lso7nJ6ybeL+OQ+enbVIPY63Xp18n23ZnP6wzZoma2Lv1NdDiRTNokm1WzQ89Oz0KbuTwDsqF1VTKklzOfVb1cxgzVopBn8zD2zXIpz+tVfFBonvGq8ctVcv+0mlXdZxnTfr0sM1VX00jpMB7MQgdmeesDGSfZvaB5zG3nz7vptvLXFQBA4mLUQJb9DWwaX3gFsM34xisAAAAAYCMuRg0UfG6GZ8VFDTD1CmB7MfEKAAAAANiI7sLEK4W18MwwtAC8IJh4BQAAAABsRH8haoCMVzwXfOEVwBbbyj/+GA5H4bVSslf12VonWYNd5/MnmySH8eGxb9PGeDp79fVX3PJgPHbLu0l+ays5fVl2o+Z1ZrmlvZy3ZuNpv5iZrSVT8ZM/Pghtjo99vmOWuTeb+QzAD37xsVv+yY9vhnWatc8abJqYYagZn1VS6fQnb73mln/0pr8GWXXUSj5HyGI3W8mKzf4qpZWMwloazc5jNuL9z31mruY0mpnt7e+45R//+PXQppF8419+8Gu3vFommZCyznIRc2sryZOdz+I51PKNhJ/+1Zu+QdJZGmo/kXvDzGws2ZxZHupIrktVaR5lPO/Lcp/NzHo5Pr3+j7ejGZWynA2kcB9mzx9/XbJ7TJXJR/ca6dlIput6Ha+l7ltzTc3MGnnYaXZ1th39rG46is9qfa6tkuPb3fP3wsFhzN/W4zk83HPLR0cnYZ2jh8duebQTj+/wyt43LpuZDSSPeSmXZb6IubVV7c97NIn9ORj449GxZmZWlb5N2/q83raJ65zN/HUqk89UByN/PHUV88FPznwmrmZt7+3H/hwu5F5dxr4ZjvyvGnUVt/PwSPKsGz9umjX/cAeAFwUTrwAAfIVvvAIAAAAANoKoATwPF7/TQMQrgG3GxCsAAAAAYCP4xiueC4YWgBcEE68AAAAAgI3oL6TZMPGK54JvvALYYky8AgAAAAA2gqgBPB+MLQAvhq0srhULupg1jRTseIIiU4u5L9ZxehqLsXz66X23fHj16uUHKM94LW5kZtbJx25F8imcFlbpksI/4bzkvLV40ON1/Hz6eDQMbarSFxW7cvUwHqD2sfx4OIqFlEYT/9rf/du/CW3uPzhyy3/46LPQ5vj41O9bimnVdbzeXe/bFEmlNO3zrChSVWhBM//znZ3Yn/v7vjhQVo9pMvHrZR/MauGxq9f9eDw78YV2zMzWa39vZOe0s+OvS1GchTYHUrxIC1otF7FIkvbFJCko9OC+L3i0XCXFd6SQ0mjoH01a6M3MbC7HM92ZhDb10G83K2akr7UybpZZaJQWxkueP3otuz4+J8LdmxTg0kJtKy3clz03ZDuDKj7qu6E/vvUqFuBaLvwzdDT2RZGapJBSPfRjorV4fGcz//yZTGKxpcHAH3NR+j7f3fUFuszifbdIju/NN2+55b/48a3Q5lgKd2kBs4P9sIqt5D2q6+N92DS+L7TolJnZ2anv808+eeSWHz6K72Prtd+uFrQzM3vl5WtuOStwVRR+DCxXco9lhfGGfuwnj59QUO98toiNCimwJ8/hdh3vHwDAduovTLwWTLziWbk4tAh5BbDF+MYrAAAAAGAjugsZr8ln0wAA/KAw8QoAAAAA2AiKa+F5uPgHXnzhFcA2Y+IVAAAAALARRA0AAPCVrcx47fvsDVryRjXrtI85gkvJqDw7jRmGp2c+a64sY37e0ZHP1ZxKXmb2EZvmLmb5rZolqctmZoUG5mnXJF2lOYwvvXwltDmSDNXdvZiPefHPhMzMRgP/t0KTaZYd6w/oxs2YmXv1qg9I3JvGrMZ9OR7Ne9TM18fHK8tJHmFdyd87JZ+OVpX0uWbxJtc7ZOQmx6eZn2fnMX/y9NxnX3by2ch0PwmXlDaj+Sy0aGRsDcZxrGn06m8+vOuWH3zus1rNzK5c9bmwiyQH9ujI58lWSd7oSy/5Mar3z9GRH69mZufn/t4tkj7fHVz+9206lgq9/m1yf8uNF8aMmTXry/+hUchzLFujlWfboPb9V+1Owzrrxh9znfRDK8/Z+TyOx4Hkd+5Kpu9S8mbNzPYmfozeHMUs0fncX7vT05hdrDfntas+R3k8jnnCZ2d+nWEdr8t0x683SMbN1UO/L728q2V8Zuk5zeexbzS7Wq+lmdmndx+45c8+88tZfrQ+kqokD3W28O9/mqtsFsdx3/vrn64j3bdq4r6XkrW7TtqETF+5G7rkPR4AsJ181AATr3hGGFoAXhB84xUAAAAAsBFEDeC5I2oAwBZj4hUAAAAAsBFdw8Qrnr2LfzlGxiuAbcbEKwAAAABgIy5mvJZkvAIAfuCYeAUAAAAAbER/Icqb4lp4ZhhaAF4QW1lcK1OWvsiHFqXRYjxmZq28dnIcC7iMpejM7dt/EdpcvXYgx+Lnqwd1LDgih2fNOivQ42VFm8I6UkEqq0OmfXXtRiyutfOJL9hyfhYLMmmxr4WMlv39OHwOr11zywf7u6HNZOwL9Lz+2kuhTaG9E4qVxb7SIdAn/VlfUsAlW0/HkbVxnbVUplq3sVCRXpdkyNrZ+dwtn898QZxRUqhIVWUcj+cnvjDWapUUwJFidLO5FOMZxu1qMa2suNZKCuscHMaibMORFE8LRX7itSylcJI+E8zMRuGYs3EjY0v3pQXuzGwtfaXFyx7vSff1JL8dxuOrZNxUcp7LdSwaOJn4AoATLQhoZvOVfx7WdSzAtTvx42009tdpnRTX+uTTz9zyMCnstZD7pSpiH0+G/jzv3/vcbzcZj0P5c8bRICt65u+xe/c+C2329nzBsh0p5FVYPO/x5NAtdw9iocblPX/eWtzRzOxHb/n3oH/x1/+1W/71r38bj3ffF7kbDeOzuVn5e/O+FO0yMxsMpKCVPiaSt6jJxN/PWZG7oYzhs1l8Tszl+PR2rrQwIgBga1FcC88dWQMAthjfeAUAAAAAbETvMl6/wwPB99vFOX3mXQFsMSZeAQAAAAAb0V/4xitRA3hWGFkAXhRMvAIAAAAANoKoATxvfOEVwDbbyozXpon5mBrbonmOWT6qvrS3Pw1tdF83XzoIbSR+MmTlzecxp2+gWaJJhqGZ5EImv5do1mkh55TF2fSF3+7BwV5o86O33nTLVZLveHJ06pbbtT/vahCzOvWczs/mocXszGdSLlYxo3J36jMp96aaUZlkdUoeYfZrXi35g9l10bEUsnibbKz51zSX8/G+/L6rYTzCqU3c8nwhmZCnMad4ufT9t7MzCW00r7XLMkl734HTHX99ZxZzGR898NmxWQatHs9onGS8DjXH1C+PRjHPc7zj97W3F8+7lm9ZZNnAq8afd7uWbONlfB4NNLc0yesN+8pvVr+YjNqJ5KyOJdt0z+J5a16vjiOzOCYm4/h8nEimq+YS7+7FcT4c+UY6rjKavWxmtiO5tGMZN1euHoZ1piHLNvZnKc+A5NFnY8nI1Uu3XMV74UyedUePjkObgWTOahavmdnbb/+VW57u+uf3Yhnfb3760x/LOnFM/PPPf+mW738eM161u7reX8vTeXyeW6l53HGcL2T8rVYxI1ef3/oIzbJjAQDbyUcN8PzGM0LUAIAXBN94BQAAAABsxMUvKZREDeBZufilFiZeAWwxJl4BAAAAABtBxisAAF9h4hUAAAAAsBEXU4aIGgAA/NAx8QoAAAAA2AgXNcDEK54RlzSQ1VIAgC2xlcW1qioeVln6OeK2lUocybN2OPBFaA4Pd0KbvvUFZu59di+0WS19wa3DQ1/sJCuQogfUNLH6jhZ5qYrsF5Nv/mUl/6l/9UpSXOvatRtuuR7GPv9ciq8spIjYo/uxr05PZ275s8/PQpvff/SJW84KcL31l6+65X/9r9/2x1slxaukyEtWjKXspLhW8tHDZUW6qjquVJa+/3qLxWOC5HovOl+EppdqRqcnsbjWSgr9rJexWFnT+ONZLuPxadG4a9f9uD899sXWzMzu3z/xL/RxnI/k/pg+jAW4tHDSjhSU0iJZZmYHB74Y1GQn265/LSsy9dkfPnfLJyd+zJ4cyTma2Vs/8cXppuNYzCj8ApjV1tLuSgo9hRpd8vM6qw619oNYC7uZmXWt74sbLx2GNnodllJoLNuujq02efbVAz+OJ5NYcO3gYNctj6XQ115SQGo69a/NZrEQ1f2HvujV1SuxoOL+yI/ZTu7DrM9nM3/ftU0sKqbrrZLCgv/b//p/uOVCqky1Xbx3FzM/Znt9iJnZ7EzbxOvStf56amG586SQ5Nm5f343q7jv1cIf83gUr3cpz9VSHs5NrGcGANhSPmrgOzwQfL9RXAvAC4JvvAIAAAAANsJNvPKNVwDADxwTrwAAAACAjSBqAACArzDxCgAAAADYCB81wMQrnhGiBgC8ILYydaeq4nywZglqpmaT5OkV8gTu25iN10oe5icffxLa6L6vXt2XY4m/UGgGbRbfWuo5JY0qzYHVvsm2K5mAZRnfierSn3fZx765tu9zDpsd3+ftImZ+fvih77+f//PH8QAlu0/P0czs6JHfdisZpWWS8arvuFmfa15mu07yCOW1SnIZs0/ui0LGWhfb1JJhOJnEjMr1yp/nydEjt/zo/lFYR82T6z2Q/jo5j1mNOs5PjnwW5lmSxRvyPNu473PZ1+lJko8p+ZM7Uz/2Bkmu7t6uz3h9+ea10ObmKy+55aOTWWjzxz/cdcsnx/5YijLuWzM/+z/7tz2/Xpfc0Nqna3nW9X08Ps0bzbKBw3azbM7KvzYa+dxszd42iznPw1HMwJ7s+LG/M435vIOBPPtkVw8e+AxqM7P7D/w57e3thzaf/NFn+n7yccyqHsu92fW+H1aLGDh6eur7vNEccovPpOFwENrMZr7/NB98tYo5xQ8/f+iWb1zfDW2Wst5iGe/nUJdC84X1AWpmq6U/z65NMn2H/p7PcrLjrv0riySXGgCwndw3Xpl4xTOS1RoAgG3EN14BAAAAABtBxiuet/DhMQBsESZeAQAAAAAbcfEPRZh4BQD80DHxCgAAAADYCKIG8Fy4jFe+8gpge21lxmvTxAw7fZRqHqpmLpqZ1QM/rzwcxDy9yY7PH1w3MUeuW/s8v06y+9rk94leMyD72KiXN4jC4jnom4hG2WQZi9qmWcf+XK/8vqokM3UtWX1r6Yd1st35XLJYi3h8Ve2HneYnmpktJet0KfmT9TCsYhp4m2Xm6tVtkkzSIgvOvfjz5MeVfJo/HsfMyvHIv9Yn+9H11gufG9muYjarnvcyyTvuZbtZtm0lt8di4a9/WcS+Gg39vtdNPCfNZ9WcUDOz2bnPm7x//8Qt7+3thHVaGSPTaWyzOPT99+jRSWiznEse6qnPQz28shfWOZYc2N2duG8Lub+xSRgCSYamZnz2cl+2XbwPT898Tuj5Wcx4Xch5f/RhzLceDv29elX6IsvjXkiW6Di53uOxv4E1w9nMbLnwr8njJ923vg98dvZZaFPJM+n4NPbNB7/4g1tu5PjqOj4vK7mBsvxW7c86eU+6ctX38Wjs82b1XjEzm8/8c+HBo5i/3cpzIcsm1+zVupZM3yrm9eq10/2YmdVyrVareL0LyW0v5DqNJnxODAAvCh818B0eCL7XiHgF8KLgXzIAAAAAgI1w33glagDPAV94BbDNmHgFAAAAAGyE+8YrUQMAgB84Jl4BAAAAABvRk/GK54GhBeAFwcQrAAAAAGAjOpfxyuwYngOiBgBssa0srlWW8bBKLaQiQS5V8mnqbunT3M/3pqGNFiEpkoItr77+mlsejmLhJNVKoaw+KR6jtNiW2eWh4V1SjKcotG9if4a1kv3UlRbB8msdnfgCPmZmZ+e+YE+Z7DsU11rFc5jNfYGeoxNfUGZnxxecMYt9ldUy0oJHdfopvH+tkA1nhXVGUiwoPT5ZTi6drWScNFKoZroTi9s0UihLi9KYmc2kkFLbxt55+cZVOT5/LKcnsajP2bkv6tMmxcq0qtSgivfCev3N5312GsdaGOfDh6HNFTmnZp0UcZJiUFqoqOtisaDr1/flYEITK6SgXp/9RhiK513+jxN9RiWHFwoAjkfxPtzf82NpFmtMWdv6/jqTIl3DYRxrWjBqvYrjppWCYfNVLBC2v+uPbyDFEtukquFS9tUlxd706bfqlqGFPra0OGKdnPdQrssgazPy21klfTOb+dcGQ398WSFJLXCVFR4zKWKozw2z+Lyu5D2gKrMillIgbBDHmg7rIikK2Xb+uarPgKT+IwBgS/VMvOJ5uPgLBhOvALYY33gFAAAAADy1vu/dZ31EDeBZuTiy0i84AMCWYOIVAAAAAPDU5A8s+MYrnh2GFoAXBBOvAAAAAICndrGwlhkTr3hO+MIrgC22lRmv2XOzlbw3k5y7NslHXSxXbvlc8ijNzD7//MQthyxZM2tlXyFLNAkTzfJaVci9S7I5NfOxTLLxLtt3meRGhoy9rI28tDj3J/rZZzFTU3Ngf/ov/jK0Wcz8dflv/uVfhzbn8zO3fO2aZqY+wbtrllsr+YNZXmsZVpQs0WSMTHd8fnA2jvS6NIuYLXn00I/H0djnCfdtzGVs5LUst7br/Xlmub96vSdDn914b+mPzczs7NxfS83CNDMrS/9am56D3GMyPpskO/bs3OeCLtdxPB5cveeWx+OYz7xa+XPQnNrVIuaPVpXkWl4e35r/CVShObDZdnzfrNd+uUyeG6ORHl/s890d3xeTyTC00YzXWv7x1CTZ1TqO2ib233yxkleSMSv7nrea+RnPW3NgmzRH2W/ncH8ntLl59cAfi55TEtAsh5vmKGv2rr63mJl1A9l24dtk510V/tq1XZLrLWHAq1Xct47rQu7dvk+ut+n7TWgS3ttGw9h/a+nkpeR8Z89UAMD26eT3KKIG8Mz4rAEA2Fr8SwYAAAAA8NR6mXgttvJrPgAAPD9MvAIAAAAAnlonf25SEjUAAPiBY+IVAAAAAPDUwjdemXjFM3Ix3uoJUv4A4DvDxCsAAAAA4Km5idci5oUDG+NmXr+7wwCAy2xl6k6XFC558NAXW/r447tu+V5S6KmVYiK7k1hY5+x87tvsxkIrXSiA4o8vKxakxWKqKhZx0sJZSb2jsB1dJ12juHydSooXpb8UaTEoKZLTNklxFjmJN998NbQZVL7Nv/t3fxfaPHr0yC1/fu8PbnmxOI2HK4dTJAV7tNBT1pvaRguaVVVWmMr3VVZc7dHDY7f8X37+i9Dmd7/52C1Pd6SoWFK8qihlbHVxPA4GvmjOah3bzOa+2JcW6Dk7i8XpGhkDZTLOOznmVazPY/oZUBiOyYVqpEhSKBhn8drVdWyj97fW8MmKYmlBIX3WPN6374siu3Z6rz7BP046GejNOhav0gJhWqTNzEzryi1XcTt9q88S//MqOV69LoPkwdbW8m2YZDujkRb7urzIXdP6ol1aoMssFnraGcaiYnrM2ufLpM8HQ9+hbRuPbz6X94Uyq8zoj1nHSJV8cyi8tyXPn7X0xWgYx2wnBa6GUmCvSX5l0AJs7Tqe01wKKmoxPTOzgexrMPT70vcsAMD26fve2l//wv7qjf/ThoOZrZodW/9zZfXt20/0bxjgSfV9b1P7vd144wMbDmY2/C9Xbf3Kv2GsAdhKWznxCgAAAAB4MfR9b/N//Efr3nvPDvcev7ZjJzb7h3+wwZ07Nnn3XSbEsBFfjrVb9p7ZF2PNHp3Y7B8+ZKwB2Ep8hQQAAAAA8GdrPvjA1u+9l/5s/d571nzwwXM+InxffTnWsnQBxhqAbcTEKwAAAADgz7Z6//2n+jnwpL4cS1/3nVbGGoBts5VRA8fHZ+G1//gf/1+3fP/+iVsuipgZpzmbITLQzAYDn8v3+psvhza7+/t+X5LdmGXu5bmvnv4JRF6N8ZuzQzXDMnutknxPM7NCsjizrMZezkHzWydJbmSllUz7VWjzxuvX3fJvfvufQ5tOskPXq2VoE/l9x2xes8ok2DKLttV1pK8Gg3jbrNc+5/DkJI7hn/3Mf/r6+w8/CW3uP/LZtfc+P/LHlpyTjok6yVk1ybUcjpK847OZW247f07rJuZaWqH7ih2q16Es4piNGZ867uOudehnbTTn9+qV/dDm2pVdt6xjrUnu5aW06ZKd61lmvxxKNHDeRrOgy8uzL/WYyyTHdDL2r40mcWxpfqc+E9omZqjquNHMVzOzodxDiyQzdTb3z479vam0iL01lFzQ5NFnneSL6rGYmZWSH1tUvq92k7HWSG7yfBYzkc/O/P3dJnnmTSNZtnJ5h6N4vKOhv5+7Pnn/kUdxGe5dCw+/SjORk2xW63ybPnkvHsvzZpmMG83Wjs9ZqmYAwDbrjo+f6ufAk2KsAXjR8I1XAAAAAMCfrTw4eKqfA0+KsQbgRcPEKwAAAADgzzZ8552n+jnwpBhrAF40TLwCAAAAAP5s9e3bNrhzJ/3Z4M4dq2/ffs5HhO8rxhqAF81WZrwCAAAAAF4MRVHY5N13bfDWW7Z6/33rjo+tPDiw4TvvWH37dsisB/5cjDUAL5qtnHg9PjkPr62WvjLIaOyrpnRdLCaiRVQmk1hp5bXXfKGnV2+9FNr0UixG6xutVrEwTCPFQyqtkJLQIklmZo0Uq6oqLa4Vt9NJwZYi6ZuhFMrKjq6RAi21FD+Z7MT+vLaz49sM4pZnUmBGC1OZxcIvWi+qTeqsaJ2a5SoW9tLCU3URzyHUSpM376qORWnape+re/fuhzanR/6854s4bjopVKPn1CfFeLTI0LqJxW20nlVSZ85aGSdaU6osk/NutaBZPL4wrss4Hqvej8c+/L6UbVdeyAqlaaPsFzE5rVoK7jVJQbP53BdO6rJiepWcU149z7dJXtMCR50Uq8p+udSCW8OkytRo4otVZYX6VnIPhTGyjvdYKQX1svvb/GPC6nncznLp74+VFK/a3fNF0czMRiN/num+5RyGw6TIlBQwG4xkX30cE7OZL7i2WGSFx/zyYpUcnyjkukz39kKbnT3foU1SrKzv/fEVyXjsZWxp8UktNGhmZlKnb5UUQtTLUK3jWNPbbCnnkBWxBABsl6IobPD22zZ4++3v+lDwPcdYA/AiIWoAAAAAAAAAADaMiVcAAAAAAAAA2DAmXgEAAAAAAABgw7Yy43V/P2b3/cu//olbPj09u3Q7TeMz4vo2ydyTNr/6xW9Cmzd+9KpbfuXmDbec5VqqJ8p3THIDCw2glBRIzZI1i1mNVZfk6cl5d0m+Yy9Bm6Vk7I3qmLm3ms/c8h8//mNo8/k9Hwp4cr4Iba5fv+qWX33FLxdZZq5GiSbZl4Xk1D7ZdfHL2fVeS87vo4fHoc3n90/c8mwecxiL3l/vXoIPuyRvVHM2iySDdnfH31PjySi0WS3nbnm58NelTz6nKQrJCi5jn4cuTvq8k7FfaDRrlkcpr2XXUo9nuYz5k3M5z04G0iDJANWs0+UyZpSOhtLHWUSlHF82ZksJ6K2Gvk2b5JhqNqtmJps9Yf6t5vrqKlXMji31WmbPKMkKnezE8Tif+2vVav5oMs5Ho7HfTxmviz7zLekbk3Gt912rYa1mtlz681ysYu7vUvKXswxazVEdSB53k+TCnp37e3exiOM8vP0l98tartWgkbzwIp73QHK82xjQHLKLs1xifQua7oylxeXPagAAAADYNnzjFQAAAAAAAAA2jIlXAAAAAAAAANgwJl4BAAAAAAAAYMO2MuN1b28SXrty4DMqNcc0y/zUjMqPf/9JaPPRh793y/PTeWhzdu2K3/ctn8E3GsW8uvX68vxJzbnL8v468zmBk8n00u3qa5qfaWYWIgrT3E05L8manE7jddJs00efxyzeteQc/vHuSWizu3/PLV/593/rlneSfXdyUm1yTpX0eZY1qK/pVgaDmGt5Itfuwb2Hoc35uc9d7GIEZNi3xlj2mrlpZiY5wGUdb+tKNtQmWbGN9J9mi5ZV3O5o5LM5NUPXzGwlmZTrdTzxVgIoC80XTgJSC/PHm2Ukl9JfN64dhjY3ru+7Zc2GTuI8Qx5qkWQk67XUZ1a2nUwvB1BUT7COjP1Rkumrx1wlx6c5qiHDt05ydSWneDCI+w7DbxnHxHjk77NaxrXmKpuZ1QP/WpWMWX2OFWW8n2u5x7Vv5rOYHbte+33Pk5zVRnJgs7zo4dDvqx76czg9PQ/rzGZyf7dxu41k5J4n2dq6r0Gly3Hs1QN5rUyyWMN7SXyO6fDTfT1JljoAAAAAbBu+8QoAAAAAAAAAG8bEKwAAAAAAAABsGBOvAAAAAAAAALBhTLwCAAAAAAAAwIZtZXGttolFUzrzxUyGUgSkSgqkrGU7dR3nmae7vmjX2VksODIej91y3/kCKX0ovxQL/WSFdbT202AYz6FMipB4sdiJ7ns+i+f0JIV/6oEMDyluUlXx2LRgzyoppHQ280VnlklRMZNCVMuF3854khQD0+IrWY2XpODWZdvRHs76qpNqQVUy1kotALeKfdNJwahKCtXUdRwjYV9JgSvtCy20Y2ZWmBbokYJXSdGcuvb7Gsm98ng9fy21CNEXe3NLnQ6J5P4uQ2GqrICdf+1gbye0eeXmy27507uP3PLxw1j8bVj585xO43ZD4ba0Jta3LxhUyjpdsmEtRDWdxONbrvx16ZOCa2WhzzEtGpiNNXluJB/vlTL8miru+8qhHLMUxcruZX3vGI5iYa9anltdd3mxsuXS99XJSSwaqIUFT45OQ5uVPOvCM8HiebVSXG2xiPdPWcl1SQpRNXI/z+bJe50N/fKeFM9L3o7a3l/MMhlH9cBvNytqqO9bWRE+AAAAAHjR8I1XAAAAAAAAANiwrfzGKwAAAIDcarW6vBEAAMAzxO8jT4aJVwAAAGCL3b171y3/0z/903d0JAAAALm7d+/aG2+88V0fxtbZzonXJPZQs/BKyfvL1qkrf3pZluiJZLqOxzELcS15mE3jt1PXMfhO80/zbNFvzhJ9zOfead5fRuPzNO/x8fHokcTj04xczQhcJ4cyW/oXj87jJyDXrl/1y5KxaWY2HPpMwMnEL7fJzvU6dUlf6Wt9ki2pubp6XdokH3Wx8OepOaFmZvO5b5PEMFoh11vHTfaJUj0YfOOymVnX+u2cnsTc0uVct+37Ic+t9W0Wy3nSxq+3Mx2GNrOZX0+jQzWr9Yst+8Ukb3S59Od0dBxzN4+PfF7n7NSP87OTmKk53dF8zCxf9puXzZ4scziOAT9Gzs9j3ujx0ZFfZxnzPPvWj+Ps+DSCNGZzxntBT0mfl4/baFZsvA81r7WQZ36V5B2b+X0dHR2HFprhnF0CzUidnfv+OzmN4/zo2F+Hc8mpNovXrkoyXpvG9/Fi4beTPX9G8rzM3kwaud5tG8f17Ny/VsqGRjvxvaSQjNeRZoObWVdoLno8wJVkPzfh/SfLhgZ+OO7fv/9dHwIAAMA3un//PhOvCTJeAQAAgC128+bN7/oQAAAAvhG/r+S28xuvAAAAAMzM7NatW/b3f//3dvfuXbt+/Tr/sAEAAFvh7t27dv/+fbt586bdunXruz6crcTEKwAAALDlbt26xT9oAADAVnnjjTeIF7gEUQMAAAAAAAAAsGFb+Y3XMikMUkpRl1AcKqlUpPVaPrv7MLR5+ODcLU+nscjL4ZU9t6xFXnT58WtawOXyIjp1UrxoHQqO+CIlZdJZZem3k223koJby2VSeEwKypyd+r6691ksIDWb+WJGL718PbT5m7/5qVvWQlqZUopONUnhrEI+Ryir2Dda9Kwqk8JoslrX+X1p0TEzs4UUvZovYhs95HxMaDE1v51BUjhLK+n0XTYm/HnWVezzfiRblSJj40ncdyFjbb2K10XHX58Uwarl+Fop2FNVsaBQIeety2ZmJ1Lw6N79o9Dm4UNfaGy5lAJDVRwjoXpRUhxKnwHZ8fVZRSvRyvg7PTlyy59/+llYZ7H0BZnOTuKjfjj017NMPoar5Pj0eaP3xuPj9ee9Tooa6mujURyPOm46Ke7XtLFgmPbVqo3jRs9Jlx9vx5/D8cnMLZ+dxX0vl35f5/P4DOhknGjxKjOzpd6rUryxKJLCgmt/vbNniz4zs0KNWnxQ32+q83gvdNJmujMObcZjf3214J5ZLPBYD+VZnbzPAgAAAMC2418yAAAAAAAAALBhTLwCAAAAAAAAwIYx8QoAAAAAAAAAG7aVGa/jcZIlWWhOpP95m2T5rSV7bjgahTaDge+C0ThmDc5mPs/vl7/+gx5dWOfll6645SuHO6GNZl02bcxC1Fy+mOma5Xn6185ny9Dm408+dssf/u7T0Obe/WO33Ekfl0XMEdTM1CRG0D78yO9rdjYPbXamE7f86ivX3PJwlA1dyfxMMgErCbLU7GAzMz0rvQZ1clKNZFZm6a1hX0m8p65X1X48jodxDJfV5bdx08iWs31LE8107ZMcU8397ZJ8WZPczTrJTC0ku3ae3M9hnSfIUT6RbM7j4/PQJmQMy2bqOvavvpaNNf1cq++zc9JjjuewXvn79/zE35dtkjlcSYZmliSrz8zs+ahnpfnRRdLnvdwLWYxtI/teynUyMwsxoLKhIsm3HtSa4RzbdNIb+j5hZtat/fHNFz7DWd8TzMwWC7+dVZJ3rJHSVZLZHHJqZ36743G8f/TWbJMc5abRkOkk41XG6GLul4siedYUvo2+p5rFnOSyjeNmOPJtBrLOOjleAAAAANh2fOMVAAAAAAAAADaMiVcAAAAAAAAA2DAmXgEAAAAAAABgw5h4BQAAAAAAAIAN28riWgMtdmNmlRTa6LSYSFKMp5GXJpNYPObwcNctz+axUM0vf/lHt7xc+kIrXVJg5sb1Pbf83/93d0Kb6a4vIJUVwEk27ddJClypX/9Gi4GZ/d//zy/cclJfJhSv0eJFRR/7amdn7JY/v/cotPn00wey3Xjmw4H/TGD4b/8rt/zGGy+FdZrOX/BOi8mYWVdLwaMyfvZQVP54tNjNeh3Pez73Y6LVwWdmk4kUJkr2vVj6bQ8Gftxn6zSyLy30ZWZWS9GhNi3kJgWFZr7gUVYkqe/98XRJ4bGu8+OmST7uaVvff1rIq22T85bxOEjuBS08psXVzMx6GTdl6bejRX/MzAZD/1p2n+pr+b0s91jSx63cnLpcJ8WMskJjgV6XZNwMksJiF8Vif2aFDJSsONlwKOOkzgon+e2stB/0TcDMyl72lfRnqdclGdgLuaf0vmyT/tXCVFWdFPbSPk+LyGlRNn/e8+Q9SotXJV0TimBlxbW0eJpuJ7l9bFD7AmGDYSwYNpTXumR4at8s5JnapycFAAAAANuNb7wCAAAAAAAAwIYx8QoAAAAAAAAAG8bEKwAAAAAAAABs2FZmvDZNzLDTTEqNp2vaGBrXSCbgeByzY6dT/9ondx+GNsuV31mluZFJRuB65Y9nuYzHN53Ka0keYSV5o5qfmEU56nmfns5Dm77zc+51nWWH+utQyr41d9fMrJaczdNl3HdZ+azdLI1yufJ5hMulP6dhkgNclP46NeuYCVhJ3mRZJZmfmrsp2Y2rVRyfDx6eyLHE7Y4k47VN8lCHvWSHSq7hYrEI6yyX/viK5POULANZFbLaWsZRl2yj62RMJOed5cmq3vQe89spq3hzhOuUjKRSxmOdbOfll6+65ePjc7d8N8kpHkmuqt4bZmadXLs8I1dyk/UimFkpt1kl9+pAc00tZq82yVhTk3HMwNbnjT6j9By/WMkfS3KPDaX/NN/TLF7PoW4n2be+0icZtFHSRs6h0Gddcp10PFqWvy05q1lObVX5PFS9/tlzTfeUHF7IgS2K+PwO93i43vFeblu/ndUqtpmM/NjSzFez+H6j72N6/AAAAADwIuAbrwAAAAAAAACwYUy8AgAAAAAAAMCGMfEKAAAAAAAAABu2nRmv65ihGbIGZc5YsybNzJZLv535LOaNzs/P3PJ4GLdTSNDddLrrlrNcy6rWnNAkj1ByaYskozJLtvTbzTIM/b729iahxXDs8/KGwzgU1pJtO6p9Lt+wjvseSA5jkYTQ1rXPZ+00xNBiZuF47Ped5ct20hdNE/etWadZtm28DP6FdROv5cMHx77NOuYcFoW/Dnu7MVNT82MXkm07TzJeNQsxu61bvT+SwNFarq9JHq51MeO1lGuXZXVqDmif5nlK/qRc3jbJcNYcyyzvuJX7bpBkS7bSf2+8dsMtH+6PwzoD6ZsuyaWuBpJlnIUZm2Y4J01kxVryUeOz0ayXTNck2taqge+LLjlAvX81O7bMMn073xfrJBNZ81mzrNNWb0TNw02yYzXStcv6Juw7yQfXoa6HkjyZ9RTSR3PIgU2yoOXZXErm63wWnwGdXO/0XgjPreR9S56rtbwfdqFj4jM1O77JxD/zxzvx2WeFH9eNdHr2zAcAAACAbcc3XgEAAAAAAABgw5h4BQAAAAAAAIANY+IVAAAAAAAAADaMiVcAAAAAAAAA2LCi7/OSL0+0cloJBgAA4MX0FL8WAQAAAIDDN14BAAAAAAAAYMOYeAUAAAAAAACADWPiFQAAAAAAAAA2jIlXAAAAAAAAANgwJl4BAAAAAAAAYMOYeAUAAAAAAACADWPiFQAAAAAAAAA2jIlXAAAAAAAAANgwJl4BAAAAAAAAYMOYeAUAAAAAAACADWPiFQAAAAAAAAA2jIlXAAAAAAAAANgwJl4BAAAAAAAAYMOYeAUAAAAAAACADWPiFQAAAAAAAAA2jIlXAAAAAAAAANgwJl4BAAAAAAAAYMOYeAUAAAAAAACADWPiFQAAAAAAAAA2jIlXAAAAAAAAANgwJl4BAAAAAAAAYMPqp1m57/tNHQcAAAAAAAAAfG/wjVcAAAAAAAAA2DAmXgEAAAAAAABgw5h4BQAAAAAAAIANY+IVAAAAAAAAADaMiVcAAAAAAAAA2DAmXgEAAAAAAABgw5h4BQAAAAAAAIANY+IVAAAAAAAAADaMiVcAAAAAAAAA2DAmXgEAAAAAAABgw5h4BQAAAAAAAIANY+IVAAAAAAAAADaMiVcAAAAAAAAA2DAmXgEAAAAAAABgw/5/niHrDctQSZUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_test_sample(images[0].permute(1,2,0).cpu().numpy(), pred_nodes[0].cpu().numpy(), pred_edges[0])\n", + "# 정답 사진, 예측 노드와 엣지" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def match_name_keywords(n, name_keywords):\n", + " out = False\n", + " for b in name_keywords:\n", + " if b in n:\n", + " out = True\n", + " break\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "param_dicts = [\n", + " {\n", + " \"params\":\n", + " [p for n, p in model.named_parameters()\n", + " if not match_name_keywords(n, ['enoder','reference_points', 'sampling_offsets']) and p.requires_grad],\n", + " \"lr\": float(config.TRAIN.LR)\n", + " },\n", + " {\n", + " \"params\": [p for n, p in model.named_parameters() if match_name_keywords(n, [\"enoder\"]) and p.requires_grad],\n", + " \"lr\": float(config.TRAIN.LR_BACKBONE)\n", + " },\n", + " {\n", + " \"params\": [p for n, p in model.named_parameters() if match_name_keywords(n, ['reference_points', 'sampling_offsets']) and p.requires_grad],\n", + " \"lr\": float(config.TRAIN.LR) * 0.1\n", + " }\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/show_region_full_img.ipynb b/notebooks/show_region_full_img.ipynb new file mode 100644 index 0000000..c2c6f4e --- /dev/null +++ b/notebooks/show_region_full_img.ipynb @@ -0,0 +1,172 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:22<00:00, 22.69s/it]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import json\n", + "import numpy as np\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "from tqdm import tqdm\n", + "\n", + "\n", + "def scale_coordinates(coord, image_size, x0, y0):\n", + " return int(coord[0] * image_size[0] + x0), int(coord[1] * image_size[1] + y0)\n", + "\n", + "def to_img_and_seg_from_results(filelist, rootdir):\n", + " p = 5\n", + "\n", + " # tot_img = np.zeros((2048, 2048, 3))\n", + " # tot_seg = np.zeros((2048, 2048, 1))\n", + " # tot_dat = np.zeros((2048, 2048, 1))\n", + " tot_img = np.zeros((2762, 3977, 3))\n", + " tot_seg = np.zeros((2762, 3977, 1))\n", + " tot_dat = np.zeros((2762, 3977, 1))\n", + "\n", + " for filename in filelist:\n", + " img = np.array(Image.open(os.path.join(rootdir, 'patch', filename)))\n", + " seg = np.array(Image.open(os.path.join(rootdir, 'seg', filename)))\n", + "\n", + " x0 = int(filename.split('_')[1])\n", + " y0 = int(filename.split('_')[2])\n", + "\n", + " # print(x0, y0)\n", + " tot_img[x0+p:x0+128-p, y0+p:y0+128-p] = img[p:-p,p:-p]\n", + " tot_seg[x0+p:x0+128-p, y0+p:y0+128-p] += seg[p:-p,p:-p,np.newaxis]\n", + " tot_dat[x0+p:x0+128-p, y0+p:y0+128-p] += 1\n", + "\n", + " tot_dat[tot_dat == 0] = 1\n", + " tot_seg = tot_seg / tot_dat\n", + " tot_seg = tot_seg.astype('uint8')\n", + " tot_img = tot_img.astype('uint8')\n", + " return tot_seg, tot_img\n", + "\n", + "\n", + "def to_graph_from_results(tot_img, filelist, rootdir):\n", + " image_size=(128,128)\n", + " # blank_image = np.ones((2048,2048, 3), dtype='uint8') * 255\n", + " blank_image = tot_img.copy()\n", + " for filename in filelist:\n", + " with open(os.path.join(rootdir, 'graph', filename)) as f:\n", + " data = json.load(f)\n", + "\n", + " # if filename == 'data.json':\n", + " # continue\n", + "\n", + " x0 = int(filename.split('_')[1])\n", + " y0 = int(filename.split('_')[2])\n", + "\n", + " nodes = data['pred_node']\n", + " edges = data['pred_edge']\n", + "\n", + " for edge in edges:\n", + " node1 = scale_coordinates(nodes[edge[0]], image_size, x0, y0)\n", + " node2 = scale_coordinates(nodes[edge[1]], image_size, x0, y0)\n", + " cv2.line(blank_image, node1[::-1], node2[::-1], (255, 0, 0), 3) \n", + "\n", + " for node in nodes:\n", + " scaled_node = scale_coordinates(node, image_size, x0, y0)\n", + " cv2.circle(blank_image, scaled_node[::-1], 5, (0, 0, 255), -1) \n", + "\n", + " blank_image = blank_image.astype('uint8')\n", + " return blank_image\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + "\n", + " # rootdir = '/nas/tsgil/relationformer/gil/test_data_region/'\n", + " rootdir = '/nas/tsgil/relationformer/gil/spacenet_test_data_region'\n", + " # rootdir = '/nas/tsgil/relationformer/gil/test_single_data_region' # test-single\n", + " filelist_p = os.listdir(os.path.join(rootdir, 'patch'))\n", + " filelist_g = os.listdir(os.path.join(rootdir, 'graph'))\n", + "\n", + " # region_num_list = [8,9,19,28,29,39,48,49,59,68,69,79,88,89,99,108,109,119,128,129,139,148,149,159,168,169,179]\n", + " # region_num_list = ['05JUL15WV031100015JUL05162954']\n", + " with open(\"/nas/tsgil/relationformer/data/spacenet3/data_split.json\", \"r\") as file:\n", + " split_info = json.load(file)\n", + " region_num_list = ['-'.join(x.split('_')[1:]) for x in split_info['test']]\n", + "\n", + " for region_num in tqdm(region_num_list): # 22.61s/it\n", + " # print(region_num)\n", + " tmp = []\n", + " for a in filelist_p:\n", + " if int(a.split('.')[0].split('_')[-1]) == region_num:\n", + " # if a.split('.')[0].split('_')[-1] == region_num: # test-single\n", + " tmp.append(a)\n", + " filelist_p_region = tmp\n", + " tmp = []\n", + " for b in filelist_g:\n", + " if int(b.split('.')[0].split('_')[-1]) == region_num:\n", + " # if b.split('.')[0].split('_')[-1] == region_num: # test-single\n", + " tmp.append(b)\n", + " filelist_g_region = tmp\n", + " # print(len(filelist_p_region),len(filelist_g_region))\n", + " tot_seg, tot_img = to_img_and_seg_from_results(filelist_p_region, rootdir)\n", + " tot_graph = to_graph_from_results(tot_img, filelist_g_region, rootdir)\n", + "\n", + " fig, ax = plt.subplots(1, 2, figsize=(24,12))\n", + " # fig, ax = plt.subplots(2, 1, figsize=(18,36))\n", + " ax[0].imshow(tot_graph)\n", + " ax[1].imshow(tot_seg)\n", + " save_dir = f'/nas/tsgil/relationformer/inference_plt/{region_num}'\n", + " if not os.path.isdir(save_dir):\n", + " os.makedirs(save_dir)\n", + " plt.savefig(f'/nas/tsgil/relationformer/inference_plt/{region_num}/result.png', dpi=400, facecolor='#eeeeee')\n", + " # plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/spacenet_inferencer.ipynb b/notebooks/spacenet_inferencer.ipynb new file mode 100644 index 0000000..2c1ccda --- /dev/null +++ b/notebooks/spacenet_inferencer.ipynb @@ -0,0 +1,496 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import yaml\n", + "import sys\n", + "sys.path.append(\"..\")\n", + "import json\n", + "import numpy as np\n", + "from scipy import ndimage\n", + "from scipy.sparse import csr_matrix\n", + "from scipy.sparse.csgraph import connected_components\n", + "from skimage.morphology import skeletonize_3d\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import text, patheffects\n", + "import matplotlib.patches as patches\n", + "import matplotlib.gridspec as gridspec\n", + "from monai.data import DataLoader\n", + "import torch\n", + "from torch import nn\n", + "import networkx as nx\n", + "from dataset_road_network import Sat2GraphDataLoader\n", + "from dataset_road_network import build_road_network_data\n", + "from evaluator import build_evaluator\n", + "from trainer import build_trainer\n", + "from models import build_model\n", + "from utils import image_graph_collate_road_network\n", + "from models.matcher import build_matcher\n", + "from inference import relation_infer\n", + "from losses import SetCriterion\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "\n", + "# %matplotlib widget\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class obj:\n", + " def __init__(self, dict1):\n", + " self.__dict__.update(dict1)\n", + " \n", + "def dict2obj(dict1):\n", + " return json.loads(json.dumps(dict1), object_hook=obj)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "config_file = \"/nas/tsgil/relationformer/configs/road_spacenet_gil.yaml\"\n", + "# config_file = \"/nas/tsgil/relationformer/configs/road_test-single_gil.yaml\"\n", + "\n", + "with open(config_file) as f:\n", + " config = yaml.load(f, Loader=yaml.FullLoader)\n", + "\n", + "config = dict2obj(config)\n", + "mean = np.array([0.485, 0.456, 0.406])\n", + "std = np.array([0.229, 0.224, 0.225])" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# 시각화 함수 2\n", + "def plot_test_sample(image, points, edges):\n", + "\n", + " H, W = image.shape[0], image.shape[1]\n", + " fig, ax = plt.subplots(figsize=(12,5), dpi=150)\n", + " gridspec.GridSpec(1,5)\n", + " ax = plt.subplot2grid((1,4), (0,0), colspan=2, rowspan=1)\n", + "\n", + " # Displaying the image\n", + " ax.imshow(image*std+mean)\n", + " ax.axis('off')\n", + " \n", + " ax = plt.subplot2grid((1,4), (0,2), colspan=2, rowspan=1)\n", + " \n", + " border_nodes = np.array([[0,0],[0,H],[W,H],[W,0]])\n", + " border_edges = [(0,1),(1,2),(2,3),(3,0)]\n", + " \n", + " G1 = nx.Graph()\n", + " G1.add_nodes_from(list(range(len(border_nodes))))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({i:(pts[1],pts[0])}) for i, pts in enumerate(border_nodes)]\n", + " for n, p in coord_dict.items():\n", + " G1.nodes[n]['pos'] = p\n", + " G1.add_edges_from(border_edges)\n", + " \n", + " pos = nx.get_node_attributes(G1,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G1, pos, ax=ax, node_size=1, node_color='darkgrey', edge_color='darkgrey', width=1.5, font_size=12, with_labels=False)\n", + "\n", + " \n", + " G = nx.Graph()\n", + " edges = [tuple(rel) for rel in edges]\n", + " nodes = list(np.unique(np.array(edges)))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({i:(W*pts[1],H- H*pts[0])}) for i, pts in enumerate(points)]\n", + " G.add_nodes_from(list(range(len(points))))\n", + " for n, p in coord_dict.items():\n", + " G.nodes[n]['pos'] = p\n", + " G.add_edges_from(edges)\n", + " pos = nx.get_node_attributes(G,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G, pos, ax=ax, node_size=10, node_color='lightcoral', edge_color='mediumorchid', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " \n", + " plt.show()\n", + " \n", + "# 시각화 함수 1\n", + "def plot_val_rel_sample(image, seg, points1, edges1, points2, edges2, attn_map=None, relative_coords=True):\n", + " H, W = image.shape[0], image.shape[1]\n", + " fig, ax = plt.subplots(1,4, figsize=(20,5), dpi=150)\n", + "\n", + " # Displaying the image, 인풋 이미지\n", + " ax[0].imshow(image*std+mean)\n", + " ax[0].axis('off')\n", + " \n", + " # 인풋 seg\n", + " ax[1].imshow(seg)\n", + " ax[1].axis('off')\n", + " \n", + " border_nodes = np.array([[1,1],[1,H-1],[W-1,H-1],[W-1,1]])\n", + " border_edges = [(0,1),(1,2),(2,3),(3,0)]\n", + " \n", + " # \n", + " G1 = nx.Graph()\n", + " G1.add_nodes_from(list(range(len(border_nodes))))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({i:(pts[1],pts[0])}) for i, pts in enumerate(border_nodes)]\n", + " for n, p in coord_dict.items():\n", + " G1.nodes[n]['pos'] = p\n", + " G1.add_edges_from(border_edges)\n", + " \n", + " pos = nx.get_node_attributes(G1,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G1, pos, ax=ax[2], node_size=1, node_color='darkgrey', edge_color='darkgrey', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " nx.draw(G1, pos, ax=ax[3], node_size=1, node_color='darkgrey', edge_color='darkgrey', width=1.5, font_size=12, with_labels=False)\n", + "\n", + " G = nx.Graph()\n", + " edges = [tuple(rel) for rel in edges1]\n", + " nodes = list(np.unique(np.array(edges)))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({nodes[i]:(W*pts[1], H- H*pts[0])}) for i, pts in enumerate(points1[nodes,:])]\n", + " G.add_nodes_from(nodes)\n", + " for n, p in coord_dict.items():\n", + " G.nodes[n]['pos'] = p\n", + " G.add_edges_from(edges)\n", + " \n", + " pos = nx.get_node_attributes(G,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G, pos, ax=ax[2], node_size=10, node_color='lightcoral', edge_color='mediumorchid', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " \n", + " G = nx.Graph()\n", + " edges = [tuple(rel) for rel in edges2]\n", + " nodes = list(np.unique(np.array(edges)))\n", + " coord_dict = {}\n", + " tmp = [coord_dict.update({nodes[i]:(W*pts[1],H- H*pts[0])}) for i, pts in enumerate(points2[nodes,:])]\n", + " G.add_nodes_from(nodes)\n", + " for n, p in coord_dict.items():\n", + " G.nodes[n]['pos'] = p\n", + " G.add_edges_from(edges)\n", + " pos = nx.get_node_attributes(G,'pos')\n", + " #pos = nx.rescale_layout_dict(pos)\n", + " #pos = nx.circular_layout(G)\n", + " nx.draw(G, pos, ax=ax[3], node_size=10, node_color='lightcoral', edge_color='mediumorchid', width=1.5, font_size=12, with_labels=False)\n", + " # nx.draw_networkx_edge_labels(G, pos, ax=ax, font_size=12, label_pos=0.5, rotate=False)\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Debug Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def image_graph_collate_road_network(batch):\n", + " images = torch.stack([item[0] for item in batch], 0).contiguous()\n", + " seg = torch.stack([item[1] for item in batch], 0).contiguous()\n", + " points = [item[2] for item in batch]\n", + " edges = [item[3] for item in batch]\n", + " return [images, seg, points, edges]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "val_ds, file_infos = build_road_network_data( # 이 함수는 폴더에서 셔플해서 ds 생성함\n", + " config, mode='test', loadXYN=True\n", + ")\n", + "# print(len(val_ds))\n", + "# print(val_ds[0])\n", + "\n", + "val_loader = DataLoader(val_ds,\n", + " batch_size=config.DATA.BATCH_SIZE,\n", + " shuffle=False,\n", + " num_workers=config.DATA.NUM_WORKERS,\n", + " collate_fn=image_graph_collate_road_network,\n", + " pin_memory=True)\n", + "len(val_loader) # 이터레이션 수" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Debug Trained Model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = build_model(config)\n", + "device = torch.device(\"cuda\")\n", + "model = model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "ckpt_path = '/nas/tsgil/relationformer/trained_weights/runs/baseline_road_resnet_def_detr_final_dec_4_10/models/checkpoint_epoch=100.pt' # 경로 수정하여 사용\n", + "checkpoint = torch.load(ckpt_path, map_location='cpu')\n", + "missing_keys, unexpected_keys = model.load_state_dict(checkpoint['net'], strict=False)\n", + "unexpected_keys = [k for k in unexpected_keys if not (k.endswith('total_params') or k.endswith('total_ops'))]\n", + "if len(missing_keys) > 0:\n", + " print('Missing Keys: {}'.format(missing_keys))\n", + "if len(unexpected_keys) > 0:\n", + " print('Unexpected Keys: {}'.format(unexpected_keys))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + "To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + "To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + "To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + "floor_divide is deprecated, and will be removed in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values.\n", + "To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor'). (Triggered internally at ../aten/src/ATen/native/BinaryOps.cpp:467.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 1\n", + "Iteration: 2\n", + "Iteration: 3\n", + "Iteration: 4\n", + "Iteration: 5\n", + "Iteration: 6\n", + "Iteration: 7\n", + "Iteration: 8\n", + "Iteration: 9\n", + "Iteration: 10\n", + "Iteration: 11\n", + "Iteration: 12\n", + "Iteration: 13\n", + "Iteration: 14\n" + ] + } + ], + "source": [ + "from PIL import Image\n", + "import json\n", + "\n", + "model.eval() # 인퍼런스 모드\n", + "gil_path = f'/nas/tsgil/relationformer/gil/spacenet_test_data_region'\n", + "# gil_path = f'/nas/tsgil/relationformer/gil/test_single_data_region' # test-single\n", + "if not os.path.isdir(gil_path):\n", + " os.makedirs(gil_path)\n", + " os.makedirs(gil_path + \"/patch\")\n", + " os.makedirs(gil_path + \"/seg\")\n", + " os.makedirs(gil_path + \"/graph\")\n", + "else:\n", + " if not os.path.isdir(gil_path + \"/patch\"):\n", + " os.makedirs(gil_path + \"/patch\")\n", + " if not os.path.isdir(gil_path + \"/seg\"):\n", + " os.makedirs(gil_path + \"/seg\")\n", + " if not os.path.isdir(gil_path + \"/graph\"):\n", + " os.makedirs(gil_path + \"/graph\")\n", + " print(\"The path is already ready.\")\n", + "iteration = 0\n", + "for idx, (images, seg, points, edges) in enumerate(val_loader): # 이터레이션 만큼 패치 배치에 대한 파일 생성\n", + " iteration = iteration+1\n", + " images = images.cuda()\n", + " # print(images.shape) # [32, 3, 128, 128]\n", + " seg = seg.cuda()\n", + " h, out, _ = model(images, seg=False)\n", + " pred_nodes, pred_edges, pred_nodes_box, pred_nodes_box_score, pred_nodes_box_class, pred_edges_box_score, pred_edges_box_class = relation_infer(\n", + " h.detach(), out, model, config.MODEL.DECODER.OBJ_TOKEN, config.MODEL.DECODER.RLN_TOKEN,\n", + " nms=False, map_=True\n", + " )\n", + " # plot_val_rel_sample(images[0].permute(1,2,0).cpu().numpy(), seg[0].permute(1,2,0).cpu().numpy(), points[0].cpu().numpy(), edges[0].cpu().numpy(), pred_nodes[0].cpu().numpy(), pred_edges[0])\n", + " # print(images[0].shape) # [3, 128, 128]\n", + " # print(images[0].permute(1,2,0).shape) # [128, 128, 3]\n", + " start_idx = idx*config.DATA.BATCH_SIZE\n", + " for i in range(len(images)): # 0~31\n", + " file_name = file_infos[start_idx+i]\n", + " sample_id, x, y, region_num = file_name.split('_')\n", + " # img of patch\n", + " # NumPy 배열을 PIL 이미지로 변환\n", + " image = images[i].cpu().numpy()\n", + " min_value = np.min(image)\n", + " max_value = np.max(image)\n", + " image = (image - min_value) / (max_value - min_value)\n", + " image = (image * 255).astype('uint8')\n", + " image = image.transpose(1,2,0)\n", + " image = Image.fromarray(image, 'RGB')\n", + " # 이미지 파일로 저장할 경로 지정\n", + " save_path = f'{gil_path}/patch/{file_name}.png'\n", + " # 이미지 파일로 저장\n", + " image.save(save_path)\n", + " # seg\n", + " image = seg[i].cpu().numpy()\n", + " image = image+0.5\n", + " image = (image * 255).astype('uint8')\n", + " image = np.squeeze(image, axis=0)\n", + " image = Image.fromarray(image, 'L')\n", + " save_path = f'{gil_path}/seg/{file_name}.png'\n", + " image.save(save_path)\n", + " # gt node edge\n", + " gt_node, gt_edge = points[i].cpu().numpy(), edges[i].cpu().numpy()\n", + " # pred node edge\n", + " pred_node, pred_edge = pred_nodes[i].cpu().numpy(), pred_edges[i]\n", + " gt_node_list = gt_node.tolist()\n", + " gt_edge_list = gt_edge.tolist()\n", + " pred_node_list = pred_node.tolist()\n", + " pred_edge_list = pred_edge.tolist()\n", + " data = {\n", + " \"gt_node\": gt_node_list,\n", + " \"gt_edge\": gt_edge_list,\n", + " \"pred_node\": pred_node_list,\n", + " \"pred_edge\": pred_edge_list\n", + " }\n", + " # JSON 파일로 저장\n", + " with open(f'{gil_path}/graph/{file_name}.json', 'w') as json_file:\n", + " json.dump(data, json_file, indent=2)\n", + " # 정답 사진, 정답 Seg, 정답 노드와 엣지, 예측 노드와 엣지\n", + " print('Iteration:',iteration)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-11-23 10:06:12,625 - Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_test_sample(images[0].permute(1,2,0).cpu().numpy(), pred_nodes[0].cpu().numpy(), pred_edges[0]) # 0~31\n", + "# 정답 사진, 예측 노드와 엣지" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# def match_name_keywords(n, name_keywords):\n", + "# out = False\n", + "# for b in name_keywords:\n", + "# if b in n:\n", + "# out = True\n", + "# break\n", + "# return out" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# param_dicts = [\n", + "# {\n", + "# \"params\":\n", + "# [p for n, p in model.named_parameters()\n", + "# if not match_name_keywords(n, ['enoder','reference_points', 'sampling_offsets']) and p.requires_grad],\n", + "# \"lr\": float(config.TRAIN.LR)\n", + "# },\n", + "# {\n", + "# \"params\": [p for n, p in model.named_parameters() if match_name_keywords(n, [\"enoder\"]) and p.requires_grad],\n", + "# \"lr\": float(config.TRAIN.LR_BACKBONE)\n", + "# },\n", + "# {\n", + "# \"params\": [p for n, p in model.named_parameters() if match_name_keywords(n, ['reference_points', 'sampling_offsets']) and p.requires_grad],\n", + "# \"lr\": float(config.TRAIN.LR) * 0.1\n", + "# }\n", + "# ]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From a91c47362a57a5500eeab4e21101e6b2d0b766ad Mon Sep 17 00:00:00 2001 From: tsgil Date: Thu, 30 Nov 2023 09:54:50 +0000 Subject: [PATCH 2/3] [Feature] Albumentation --- albumentation_aug.py | 53 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 albumentation_aug.py diff --git a/albumentation_aug.py b/albumentation_aug.py new file mode 100644 index 0000000..76e3427 --- /dev/null +++ b/albumentation_aug.py @@ -0,0 +1,53 @@ +import albumentations as A +import numpy as np +from PIL import Image + +class AlbumentationsAugmentation(object): + """exapmple: + dict( + type='AlbumentationsAugmentation', + transforms=[ + dict(type='RandomCrop', width=256, height=256), + dict(type='HorizontalFlip', p=0.5), + dict(type='RandomBrightnessContrast', p=0.2), + ]) + """ + + def __init__(self, transforms): + transforms_list = [ + getattr(A,item['type'])(**{k: v for k, v in item.items() if k != 'type'}) + for item in transforms + ] + self.transform = A.Compose(transforms_list) + + def __call__(self, img): + # gt_seg = results['gt_semantic_seg'] # seg용 + + # 리사이즈 기능도 쓸거기때문에 seg도 인자로 받을 수 있게 + # transform 짜기 1개 받거나 두개 받거나 가능하게 + # augmented = self.transform(image=img, mask=gt_seg) # seg용 + augmented = self.transform(image=img) + img = augmented['image'] + # results['gt_semantic_seg'] = augmented['mask'] # seg용 + + return img + + def __repr__(self): + return self.__class__.__name__ + +if __name__ == '__main__': + transformers = [ + dict(type='RandomCrop', width=256, height=256), + dict(type='HorizontalFlip', p=0.5), + dict(type='RandomBrightnessContrast', p=0.2), + ] + aug = AlbumentationsAugmentation(transformers) + img_path = '/nas/tsgil/dataset/SpaceNet3/mmstyle/img_dir/test/AOI_2_Vegas_22.png' + aug_path = '/nas/tsgil/gil/test.png' + img = Image.open(img_path) + img = np.array(img) + new_img = aug(img) # 이미지 어레이가 들어오면 어그멘티드된 이미지 어레이 리턴 + print(new_img) + Image.fromarray(new_img).save(aug_path) + + From cf25b16c5d9320b647414b95f46141c8b33df50f Mon Sep 17 00:00:00 2001 From: tsgil Date: Fri, 1 Dec 2023 05:48:16 +0000 Subject: [PATCH 3/3] [Feature] Albumentation with img and seg --- albumentation_aug.py | 61 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 50 insertions(+), 11 deletions(-) diff --git a/albumentation_aug.py b/albumentation_aug.py index 76e3427..9bbb656 100644 --- a/albumentation_aug.py +++ b/albumentation_aug.py @@ -20,34 +20,73 @@ def __init__(self, transforms): ] self.transform = A.Compose(transforms_list) - def __call__(self, img): - # gt_seg = results['gt_semantic_seg'] # seg용 - - # 리사이즈 기능도 쓸거기때문에 seg도 인자로 받을 수 있게 - # transform 짜기 1개 받거나 두개 받거나 가능하게 - # augmented = self.transform(image=img, mask=gt_seg) # seg용 - augmented = self.transform(image=img) + def __call__(self, img, seg=None): + if seg is None: + augmented = self.transform(image=img) + img = augmented['image'] + return img + augmented = self.transform(image=img, mask=seg) img = augmented['image'] - # results['gt_semantic_seg'] = augmented['mask'] # seg용 + seg = augmented['mask'] - return img + return img, seg def __repr__(self): return self.__class__.__name__ if __name__ == '__main__': + palette = [[0, 0, 0], [255,255,255]] transformers = [ dict(type='RandomCrop', width=256, height=256), dict(type='HorizontalFlip', p=0.5), dict(type='RandomBrightnessContrast', p=0.2), ] + transformers = [ + dict(type='RandomCrop', width=256, height=256), + dict(type='ShiftScaleRotate', shift_limit=0.2, scale_limit=0.2, rotate_limit=30, p=0.5), + dict(type='RGBShift', r_shift_limit=25, g_shift_limit=25, b_shift_limit=25, p=0.5), + dict(type='RandomBrightnessContrast', brightness_limit=0.3, contrast_limit=0.3, p=0.5), + dict(type='CLAHE', clip_limit=2), + dict(type='Normalize', mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), + ] aug = AlbumentationsAugmentation(transformers) img_path = '/nas/tsgil/dataset/SpaceNet3/mmstyle/img_dir/test/AOI_2_Vegas_22.png' aug_path = '/nas/tsgil/gil/test.png' + seg_path = '/nas/tsgil/dataset/SpaceNet3/mmstyle/ann_dir/test/AOI_2_Vegas_22.png' + new_seg_path = '/nas/tsgil/gil/test_seg.png' img = Image.open(img_path) img = np.array(img) - new_img = aug(img) # 이미지 어레이가 들어오면 어그멘티드된 이미지 어레이 리턴 - print(new_img) + seg = Image.open(seg_path) + seg = np.array(seg) + + # 이미지 어레이가 들어오면 어그멘티드된 이미지 어레이 리턴 + # new_img = aug(img) + # if new_img.dtype != 'uint8': + # # Assuming new_img is your input array + # min_val = new_img.min() + # max_val = new_img.max() + + # # Normalize to 0-1 + # normalized_img = (new_img - min_val) / (max_val - min_val) + # new_img = (normalized_img * 255).astype('uint8') + # Image.fromarray(new_img).save(aug_path) + + # 이미지와 세그 어레이가 들어오면 어그멘티드된 이미지와 세그 어레이 리턴 + new_img, new_seg = aug(img, seg) + + if new_img.dtype != 'uint8': + # Assuming new_img is your input array + min_val = new_img.min() + max_val = new_img.max() + + # Normalize to 0-1 + normalized_img = (new_img - min_val) / (max_val - min_val) + new_img = (normalized_img * 255).astype('uint8') Image.fromarray(new_img).save(aug_path) + + # new_seg가 0과 1로 이루어져 있어서 팔레트에서 찾아서 색을 보여줌 + pil_image = Image.fromarray(new_seg).convert('P') + pil_image.putpalette(np.array(palette, dtype=np.uint8)) + pil_image.save(new_seg_path)