diff --git "a/LAVT-RIS/angle_vis.ipynb" "b/LAVT-RIS/angle_vis.ipynb"
new file mode 100644--- /dev/null
+++ "b/LAVT-RIS/angle_vis.ipynb"
@@ -0,0 +1,802 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting easydict\n",
+      "  Downloading easydict-1.13-py3-none-any.whl.metadata (4.2 kB)\n",
+      "Downloading easydict-1.13-py3-none-any.whl (6.8 kB)\n",
+      "Installing collected packages: easydict\n",
+      "Successfully installed easydict-1.13\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install easydict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'utils.dataset'; 'utils' is not a package",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[3], line 23\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39measydict\u001b[39;00m \u001b[39mimport\u001b[39;00m EasyDict\n\u001b[1;32m     21\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mfunctools\u001b[39;00m \u001b[39mimport\u001b[39;00m partial\n\u001b[0;32m---> 23\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mengine\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mengine\u001b[39;00m \u001b[39mimport\u001b[39;00m train, validate \n\u001b[1;32m     24\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mutils\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdataset\u001b[39;00m \u001b[39mimport\u001b[39;00m RefDataset \u001b[39mas\u001b[39;00m origDataset\n\u001b[1;32m     25\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mutils\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msimple_tokenizer\u001b[39;00m \u001b[39mimport\u001b[39;00m SimpleTokenizer \u001b[39mas\u001b[39;00m _Tokenizer\n",
+      "File \u001b[0;32m/data2/projects/chaeyun/VerbCentric_RIS/engine/engine.py:14\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mwandb\u001b[39;00m\n\u001b[1;32m     13\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mloguru\u001b[39;00m \u001b[39mimport\u001b[39;00m logger\n\u001b[0;32m---> 14\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mutils\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdataset\u001b[39;00m \u001b[39mimport\u001b[39;00m tokenize\n\u001b[1;32m     15\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mutils\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmisc\u001b[39;00m \u001b[39mimport\u001b[39;00m (AverageMeter, ProgressMeter, concat_all_gather,\n\u001b[1;32m     16\u001b[0m                         trainMetricGPU)\n\u001b[1;32m     19\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mreturn_mask\u001b[39m(emb_distance):\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'utils.dataset'; 'utils' is not a package"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "import os\n",
+    "import sys\n",
+    "import cv2\n",
+    "import json\n",
+    "import time\n",
+    "import math\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torch\n",
+    "import torch.utils.data as data\n",
+    "import torch.nn.functional as F\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import argparse\n",
+    "\n",
+    "HOME_ = '/data2/projects/chaeyun/VerbCentric_RIS'\n",
+    "sys.path.append(HOME_)\n",
+    "\n",
+    "\n",
+    "from easydict import EasyDict\n",
+    "from functools import partial\n",
+    "\n",
+    "from engine.engine import train, validate \n",
+    "from utils.dataset import RefDataset as origDataset\n",
+    "from utils.simple_tokenizer import SimpleTokenizer as _Tokenizer\n",
+    "\n",
+    "train_set_pth = '/data2/projects/chaeyun/VerbCentric_RIS/datasets/anns/refcocog_u/train.json'\n",
+    "val_set_pth = '/data2/projects/chaeyun/VerbCentric_RIS/datasets/anns/refcocog_u/val.json'\n",
+    "test_set_pth = '/data2/projects/chaeyun/VerbCentric_RIS/datasets/anns/refcocog_u/test.json'\n",
+    "mask_root = '/data2/projects/chaeyun/VerbCentric_RIS/datasets/masks/refcocog_u'\n",
+    "\n",
+    "# ORIGINAL MODEL CONFIG AND WEIGHTS\n",
+    "orig_config_path = '/data2/projects/chaeyun/VerbCentric_RIS/config/cris_r50.yaml'\n",
+    "orig_model_path = '/data2/projects/chaeyun/VerbCentric_RIS/exp/CRIS_R50/best_model_miou.pth'\n",
+    "\n",
+    "# NEW MODEL CONFIG AND WEIGHTS\n",
+    "new_config_path = '/data2/projects/chaeyun/VerbCentric_RIS/config/cris_verbonly_b64_nopos.yaml'\n",
+    "exo_name = 'ACE_hp10_m08_tmp005_b64_v1'\n",
+    "exo_name2 = 'ACE_hp10_m10_tmp005_b64_v1'\n",
+    "exo_name3 = 'ACE_hp10_m15_tmp005_b64_v1'\n",
+    "\n",
+    "# /data2/projects/chaeyun/VerbCentric_RIS/exp/ACE_hp10_m08_tmp005_b64_v1/\n",
+    "new_model_path = f'/data2/projects/chaeyun/VerbCentric_RIS/exp/{exo_name}/best_model_miou.pth'\n",
+    "new_model_path2=f'/data2/projects/chaeyun/VerbCentric_RIS/exp/{exo_name2}/best_model_miou.pth'\n",
+    "new_model_path3=f'/data2/projects/chaeyun/VerbCentric_RIS/exp/{exo_name3}/best_model_miou.pth'\n",
+    "\n",
+    "# IMAGE MIN AND STD \n",
+    "img_mean = np.array([0.48145466, 0.4578275,0.40821073]).reshape(1, 1, 3)\n",
+    "img_std = np.array([0.26862954, 0.26130258,0.27577711]).reshape(1, 1, 3)\n",
+    "\n",
+    "\n",
+    "os.environ['CUDA_VISIBLE_DEVICES'] = '3'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'/data2/projects/chaeyun/LAVT-RIS'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pwd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import utils.config as config\n",
+    "from utils.dataset_verbonly import RefDataset\n",
+    "from utils.misc import (init_random_seed, set_random_seed, setup_logger,\n",
+    "                        worker_init_fn)\n",
+    "\n",
+    "from model_ import build_segmenter_original, build_segmenter_pos_rev2\n",
+    "from model_.clip import build_model\n",
+    "\n",
+    "from .segmenter import CRIS\n",
+    "from .segmenter_verbonly import CRIS_PosOnly\n",
+    "from .segmenter_verbonly_fin import CRIS_PosOnly_rev\n",
+    "from .segmenter_verbonly_ver3 import CRIS_PosOnly_ver3\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 129,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'dataset': 'refcocog_u', 'train_lmdb': '/home/seunghoon/research/VerbCentric_RIS/datasets/lmdb/refcocog_u/train.lmdb', 'train_split': 'train', 'val_lmdb': '/home/seunghoon/research/VerbCentric_RIS/datasets/lmdb/refcocog_u/val.lmdb', 'val_split': 'val', 'mask_root': '/home/seunghoon/research/VerbCentric_RIS/datasets/masks/refcocog_u', 'clip_pretrain': '/home/seunghoon/research/VerbCentric_RIS/pretrain/RN50.pt', 'input_size': 416, 'word_len': 22, 'word_dim': 1024, 'vis_dim': 512, 'fpn_in': [512, 1024, 1024], 'fpn_out': [256, 512, 1024], 'sync_bn': True, 'freeze': True, 'train_text_encoder': False, 'train_visual_encoder': False, 'num_layers': 3, 'num_head': 8, 'dim_ffn': 2048, 'dropout': 0.1, 'intermediate': False, 'workers': 4, 'workers_val': 4, 'epochs': 50, 'milestones': [35], 'start_epoch': 0, 'batch_size': 64, 'batch_size_val': 64, 'base_lr': 0.0001, 'lr_decay': 0.1, 'lr_multi': 0.1, 'weight_decay': 0.0, 'max_norm': 0.0, 'manual_seed': 0, 'print_freq': 100, 'metric_learning': True, 'metric_mode': 'original', 'exclude_multiobj': True, 'exclude_pos': True, 'loss_option': 'ACL_verbonly', 'metric_loss_weight': 0.1, 'hn_prob': 0.0, 'hn_celoss': True, 'margin_value': 20, 'temperature': 0.05, 'exp_name': 'CRIS_AML_verbonly_pos25_b32', 'output_folder': 'exp/refcocog_u/exclude_multiobj', 'save_freq': 1, 'weight': None, 'resume': 'latest', 'evaluate': True, 'dist_url': 'tcp://localhost:7024', 'dist_backend': 'nccl', 'multiprocessing_distributed': True, 'world_size': 1, 'rank': 0, 'test_split': 'val-test', 'test_lmdb': '/data2/projects/seunghoon/VerbRIS/VerbCentric_CY/datasets/lmdb/refcocog_u/val.lmdb', 'visualize': False}\n",
+      "CLIP FROZEN !!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-12-10 01:09:00.796\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmodel_\u001b[0m:\u001b[36mbuild_segmenter_pos_rev2\u001b[0m:\u001b[36m19\u001b[0m - \u001b[1mBackbone with decay=325, Head=124\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "parser = argparse.ArgumentParser(\n",
+    "    description='Pytorch Referring Expression Segmentation')\n",
+    "parser.add_argument('--config',\n",
+    "                    default=orig_config_path,\n",
+    "                    type=str,\n",
+    "                    help='config file')\n",
+    "parser.add_argument('--opts',\n",
+    "                    default=None,\n",
+    "                    nargs=argparse.REMAINDER,\n",
+    "                    help='override some settings in the config.')\n",
+    "\n",
+    "args = parser.parse_args([])\n",
+    "\n",
+    "cfg = config.load_cfg_from_cfg_file(orig_config_path)\n",
+    "cfg.metric_learning = True\n",
+    "args = EasyDict(cfg)\n",
+    "print(args)\n",
+    "original_model, original_param_list = build_segmenter_pos_rev2(args)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'dataset': 'refcocog_u', 'train_lmdb': '/home/seunghoon/research/VerbCentric_RIS/datasets/lmdb/refcocog_u/train.lmdb', 'train_split': 'train', 'val_lmdb': '/home/seunghoon/research/VerbCentric_RIS/datasets/lmdb/refcocog_u/val.lmdb', 'val_split': 'val', 'mask_root': '/home/seunghoon/research/VerbCentric_RIS/datasets/masks/refcocog_u', 'clip_pretrain': '/home/seunghoon/research/VerbCentric_RIS/pretrain/RN50.pt', 'input_size': 416, 'word_len': 22, 'word_dim': 1024, 'vis_dim': 512, 'fpn_in': [512, 1024, 1024], 'fpn_out': [256, 512, 1024], 'sync_bn': True, 'freeze': True, 'train_text_encoder': False, 'train_visual_encoder': False, 'num_layers': 3, 'num_head': 8, 'dim_ffn': 2048, 'dropout': 0.1, 'intermediate': False, 'workers': 0, 'workers_val': 0, 'epochs': 50, 'milestones': [35], 'start_epoch': 0, 'batch_size': 64, 'batch_size_val': 64, 'base_lr': 0.0001, 'textft_lr': 1e-05, 'visft_lr': 0.0, 'lr_decay': 0.1, 'lr_multi': 0.1, 'weight_decay': 0.0, 'max_norm': 0.0, 'manual_seed': 0, 'print_freq': 100, 'metric_learning': True, 'metric_mode': 'hardpos_only_ver3', 'exclude_multiobj': True, 'exclude_pos': True, 'loss_option': 'ranking_embed', 'metric_loss_weight': 0.1, 'hn_prob': 0.0, 'hn_celoss': False, 'margin_value': 10, 'temperature': 0.05, 'exp_name': 'CRIS_AML_verbonly_pos25_b32', 'output_folder': 'exp/refcocog_u/exclude_multiobj', 'save_freq': 1, 'weight': None, 'resume': 'latest', 'evaluate': True, 'dist_url': 'tcp://localhost:7024', 'dist_backend': 'nccl', 'multiprocessing_distributed': True, 'world_size': 1, 'rank': 0, 'test_split': 'val-test', 'test_lmdb': '/home/seunghoon/research/VerbCentric_RIS/datasets/lmdb/refcocog_u/val.lmdb', 'visualize': False}\n",
+      "CLIP FROZEN !!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-12-10 01:09:02.415\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36mmodel_\u001b[0m:\u001b[36mbuild_segmenter_pos_rev2\u001b[0m:\u001b[36m19\u001b[0m - \u001b[1mBackbone with decay=325, Head=124\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "parser = argparse.ArgumentParser(\n",
+    "    description='Pytorch Referring Expression Segmentation')\n",
+    "parser.add_argument('--config',\n",
+    "                    default=new_config_path,\n",
+    "                    type=str,\n",
+    "                    help='config file')\n",
+    "parser.add_argument('--opts',\n",
+    "                    default=None,\n",
+    "                    nargs=argparse.REMAINDER,\n",
+    "                    help='override some settings in the config.')\n",
+    "\n",
+    "args = parser.parse_args([])\n",
+    "\n",
+    "cfg = config.load_cfg_from_cfg_file(new_config_path)\n",
+    "cfg.metric_learning = True\n",
+    "args = EasyDict(cfg)\n",
+    "print(args)\n",
+    "new_model, new_param_list = build_segmenter_pos_rev2(args)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define dataloader and util functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 131,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "init_fn = partial(worker_init_fn,\n",
+    "                        num_workers=args.workers,\n",
+    "                        rank=args.rank,\n",
+    "                        seed=args.manual_seed)\n",
+    "val_data = origDataset(lmdb_dir=args.val_lmdb,\n",
+    "                            mask_dir=args.mask_root,\n",
+    "                            dataset=args.dataset,\n",
+    "                            split=args.val_split,\n",
+    "                            mode='val',\n",
+    "                            input_size=args.input_size,\n",
+    "                            word_length=args.word_len,\n",
+    "                            args=args)\n",
+    "val_loader = data.DataLoader(val_data,\n",
+    "                           batch_size=32,\n",
+    "                           shuffle=False,\n",
+    "                           num_workers=args.workers_val,\n",
+    "                           pin_memory=True,\n",
+    "                           drop_last=True)\n",
+    "\n",
+    "train_data = RefDataset(lmdb_dir=args.train_lmdb,\n",
+    "                            mask_dir=args.mask_root,\n",
+    "                            dataset=args.dataset,\n",
+    "                            split=args.train_split,\n",
+    "                            mode='train',\n",
+    "                            input_size=args.input_size,\n",
+    "                            word_length=args.word_len,\n",
+    "                            args=args)\n",
+    "train_loader = data.DataLoader(train_data,\n",
+    "                            batch_size=32,\n",
+    "                            shuffle=False,\n",
+    "                            num_workers=args.workers,\n",
+    "                            pin_memory=True,\n",
+    "                            worker_init_fn=init_fn,\n",
+    "                            drop_last=True)\n",
+    "# detokenizer\n",
+    "tokenizer = _Tokenizer()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 132,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([32, 3, 416, 416]) torch.Size([32, 22]) torch.Size([32, 416, 416]) torch.Size([32, 22])\n",
+      "tensor([[    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1265, 11688, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1960,   320, 31777,  8172, 49407,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1312,   536, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  7435,   320,  3101,  2972, 49407,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  2862,   530,  2184, 49407,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  2862,   525, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1265,  9729,  1952, 49407,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  4919,   525, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1171,   874, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  2862,  7619,   531,   518,  1823, 49407,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  2862,  1131,   531, 49407,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1265,   530,   518,  1112,  4657, 49407,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1401,  1074,   320,  3470,  1063, 49407,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1629,  5084, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,  1265, 32025, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [49406,   530,  7860, 49407,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0],\n",
+      "        [    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\n",
+      "             0,     0]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "for data in train_loader:\n",
+    "    img, word_vec, mask, hardpos = data\n",
+    "    print(img.shape, word_vec.shape, mask.shape, hardpos.shape)\n",
+    "    print(hardpos)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load pretrained models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 133,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "device: cuda\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get current device\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "print('device:', device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1173351/383024302.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  original_checkpoint = torch.load(orig_model_path, map_location='cuda')\n",
+      "/tmp/ipykernel_1173351/383024302.py:11: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  new_checkpoint = torch.load(new_model_path, map_location='cuda')\n"
+     ]
+    }
+   ],
+   "source": [
+    "original_checkpoint = torch.load(orig_model_path, map_location='cuda')\n",
+    "args.start_epoch = original_checkpoint['epoch']\n",
+    "best_IoU = original_checkpoint[\"best_iou\"]\n",
+    "best_oIoU = original_checkpoint[\"best_oiou\"]\n",
+    "original_model = torch.nn.DataParallel(original_model)\n",
+    "original_model.load_state_dict(original_checkpoint['state_dict'])\n",
+    "original_model = original_model.to(device)\n",
+    "#original_model.eval()\n",
+    "\n",
+    "\n",
+    "new_checkpoint = torch.load(new_model_path, map_location='cuda')\n",
+    "args.start_epoch = new_checkpoint['epoch']\n",
+    "best_IoU = new_checkpoint[\"best_iou\"]\n",
+    "best_oIoU = new_checkpoint[\"best_oiou\"]\n",
+    "new_model = torch.nn.DataParallel(new_model)\n",
+    "new_model.load_state_dict(new_checkpoint['state_dict'])\n",
+    "new_model = new_model.to(device)\n",
+    "#new_model.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# similarity matrix calc\n",
+    "def calc_sim(embeddings):\n",
+    "    # embeddings : (b, c, h, w)\n",
+    "    print(\"embedding shape: \", embeddings.size())\n",
+    "    if len(embeddings.size()) == 3:\n",
+    "        b, c, hw = embeddings.size()\n",
+    "        embeddings = embeddings.view(b, c, -1).mean(dim=2)\n",
+    "    \n",
+    "    # cosine similarity\n",
+    "    sim = F.cosine_similarity(embeddings.unsqueeze(1), embeddings.unsqueeze(0), dim=2)\n",
+    "    return sim\n",
+    "\n",
+    "def draw_result(imgs, preds, masks, texts):\n",
+    "    for img, pred, mask,  orig_text in zip(imgs, preds, masks, texts):\n",
+    "        # drop zeros of text\n",
+    "        orig_text = orig_text[orig_text != 0]\n",
+    "        orig_text = orig_text[1:-1]\n",
+    "        orig_text = tokenizer.decode(orig_text)\n",
+    "        img = img.permute(1, 2, 0).cpu().numpy()\n",
+    "        # unscale using image_mean and image_std\n",
+    "        img = img * img_std + img_mean\n",
+    "        # and clamp to [0, 1]\n",
+    "        img = np.clip(img, 0, 1)\n",
+    "\n",
+    "        pred = pred.cpu().numpy()\n",
+    "        mask = mask.cpu().numpy()\n",
+    "        plt.title(f\"text: {orig_text}\")\n",
+    "        plt.imshow(img)\n",
+    "        plt.imshow(pred, alpha=0.5)\n",
+    "        #plt.imshow(mask, alpha=0.5)\n",
+    "        plt.show()\n",
+    "\n",
+    "\n",
+    "def return_mask(emb_distance, positive_verbs, negative_verbs, posneg_verbs=None, verb_mask=None):\n",
+    "\n",
+    "    assert torch.sum(verb_mask) == torch.sum(positive_verbs + negative_verbs), \"Verb mask does not match the sum of positive and negative verbs.\"\n",
+    "    assert len(positive_verbs) == len(negative_verbs), \"Positive and negative verbs do not have the same length.\"\n",
+    "\n",
+    "    B_, B_ = emb_distance.shape\n",
+    "    positive_mask = torch.zeros_like(emb_distance)\n",
+    "    negative_mask = torch.ones_like(emb_distance)\n",
+    "    hard_negative_mask = torch.zeros_like(emb_distance)\n",
+    "    positive_mask.fill_diagonal_(1)\n",
+    "\n",
+    "    # print(\"positive verbs: \", positive_verbs)\n",
+    "    # print(\"negative verbs: \", negative_verbs)\n",
+    "    # print(\"emb shape: \", emb_distance.shape)\n",
+    "\n",
+    "    if B_ < len(verb_mask):\n",
+    "        # Considering only verbs that pass the verb_mask filter\n",
+    "        positive_verbs = torch.tensor(positive_verbs)[verb_mask]\n",
+    "        negative_verbs = torch.tensor(negative_verbs)[verb_mask]\n",
+    "\n",
+    "        # Exclude hard negatives from both masks (diagonal)\n",
+    "        for i in range(B_):\n",
+    "            if negative_verbs[i] == 1:\n",
+    "                positive_mask[i, i] = 0\n",
+    "                negative_mask[i, i] = 0\n",
+    "                # Set the entire row and column for the hard negative, except the diagonal\n",
+    "                hard_negative_mask[i, :] = 1  # Mark the i-th row\n",
+    "                hard_negative_mask[:, i] = 1  # Mark the i-th column\n",
+    "                hard_negative_mask[i, i] = 0  # Ensure diagonal element (i, i) is 0\n",
+    "\n",
+    "        i = 0\n",
+    "        while i < B_:\n",
+    "            if positive_verbs[i] == 1:  \n",
+    "                if i + 1 < B_ and positive_verbs[i + 1] == 1:\n",
+    "                    positive_mask[i, i + 1] = 1\n",
+    "                    positive_mask[i + 1, i] = 1\n",
+    "                i += 2 \n",
+    "            else:\n",
+    "                i += 1\n",
+    "    else:\n",
+    "        # Exclude hard negatives from both masks (diagonal)\n",
+    "        for i in range(B_):\n",
+    "            if negative_verbs[i] == 1:\n",
+    "                positive_mask[i, i] = 0\n",
+    "                negative_mask[i, i] = 0\n",
+    "                # Set the entire row and column for the hard negative, except the diagonal\n",
+    "                hard_negative_mask[i, :] = 1  # Mark the i-th row\n",
+    "                hard_negative_mask[:, i] = 1  # Mark the i-th column\n",
+    "                hard_negative_mask[i, i] = 0  # Ensure diagonal element (i, i) is 0\n",
+    "\n",
+    "        # Apply the positive pairs logic similarly as above\n",
+    "        i = 0\n",
+    "        while i < B_:\n",
+    "            if positive_verbs[i] == 1 and i + 1 < B_ and positive_verbs[i + 1] == 1:\n",
+    "                positive_mask[i, i + 1] = 1\n",
+    "                positive_mask[i + 1, i] = 1\n",
+    "                i += 2\n",
+    "            else:\n",
+    "                i += 1\n",
+    "\n",
+    "    negative_mask = negative_mask - positive_mask\n",
+    "    negative_mask[hard_negative_mask.bool()] = 0  # Set hard negative indices to 0 in negative_mask\n",
+    "    # print(\"positive mask: \", positive_mask)\n",
+    "    # print(\"negative mask: \", negative_mask)\n",
+    "    return positive_mask, negative_mask, hard_negative_mask\n",
+    "\n",
+    "\n",
+    "def infer_result(model_in_use, data_loader, vis = False, trial = 25):\n",
+    "    with torch.no_grad(): \n",
+    "        sims = []\n",
+    "        pos_masks = []\n",
+    "        neg_masks = []\n",
+    "        iter = 0\n",
+    "        for i, (imgs, texts, target, hardpos) in enumerate(train_loader):\n",
+    "            # data\n",
+    "            imgs = imgs.cuda(non_blocking=True)\n",
+    "            texts = texts.cuda(non_blocking=True)\n",
+    "            target = target.cuda(non_blocking=True).unsqueeze(1)\n",
+    "            hardpos = hardpos.cuda(non_blocking=True)\n",
+    "            #print(hardpos)\n",
+    "            #print(\"shapes: \", imgs.shape, texts.shape, target.shape, hardpos.shape)\n",
+    "\n",
+    "            # inference\n",
+    "            # preds, tgts, loss, embeddings = model_in_use(image, text, target, hardpos)\n",
+    "            preds, tgts, loss, sim_matrix, posverb_mask, negverb_mask = model_in_use(imgs, texts, target, hardpos)\n",
+    "            verb_mask = posverb_mask + negverb_mask \n",
+    "            positive_mask, negative_mask, hard_negative_mask = return_mask(sim_matrix, posverb_mask, negverb_mask, verb_mask=verb_mask)\n",
+    "            # print(\"mask shapes: \", positive_mask.shape, negative_mask.shape)\n",
+    "            # print(\"pos mask: \", positive_mask)\n",
+    "            # print(\"neg mask: \", negative_mask)\n",
+    "            # print(\"similarity matrix: \", sim_matrix)\n",
+    "\n",
+    "            # calc similarity matrix\n",
+    "            #sim = calc_sim(embeddings)\n",
+    "            #print(sim_matrix.size())\n",
+    "            #print(posverb_mask)\n",
+    "            sims.append(sim_matrix.detach().cpu().numpy())\n",
+    "            pos_masks.append(positive_mask.detach().cpu().numpy())\n",
+    "            neg_masks.append(negative_mask.detach().cpu().numpy())\n",
+    "            preds = torch.sigmoid(preds)\n",
+    "            if preds.shape[-2:] != imgs.shape[-2:]:\n",
+    "                    preds = F.interpolate(preds,\n",
+    "                                        size=imgs.shape[-2:],\n",
+    "                                        mode='bicubic',\n",
+    "                                        align_corners=True).squeeze(1)\n",
+    "            # overlay image and preds mask\n",
+    "            imgs = imgs.detach().cpu()\n",
+    "            texts = texts.detach().cpu()\n",
+    "            preds = preds.detach().cpu()\n",
+    "            \n",
+    "            #masks = masks.detach().cpu()\n",
+    "            # texts to numpy\n",
+    "            texts = texts.numpy()\n",
+    "            \n",
+    "            if vis:\n",
+    "                draw_result(imgs, preds, tgts, texts)\n",
+    "            # draw_result(imgs, preds, masks, texts)\n",
+    "            iter+=1\n",
+    "            if iter > trial:\n",
+    "                break\n",
+    "        return sims, pos_masks, neg_masks   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sims_orig, positive_mask_orig, negative_mask_orig = infer_result(original_model, train_loader, vis=False, trial=100)\n",
+    "sims_new, positive_mask_new, negative_mask_new = infer_result(new_model, train_loader, vis=False, trial=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_1173351/1865868274.py:13: RuntimeWarning: invalid value encountered in arccos\n",
+      "  sim = np.arccos(sim)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHLCAYAAAAz0mdEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvcUlEQVR4nO3dd1gUV9sG8HvpTVC6WBDFAoqI2LBX0Bi7sSvWRIMaQ6LG900sMZHEbqwxGjGWaBI1MVZQsWNDsWtEsUQFK11gYc/3hy/zubvALgjsIvfvuvaKe+bMmWceJsvDzJlZmRBCgIiIiIgkBroOgIiIiEjfsEAiIiIiUsECiYiIiEgFCyQiIiIiFSyQiIiIiFSwQCIiIiJSwQKJiIiISAULJCIiIiIVLJCIiIiIVLBAohJRrVo1DB8+vFi30bZtW7Rt27ZYt1GayWQyzJw5U9dh5Orw4cOQyWQ4fPhwsW9r5syZkMlkSm0ymQzjx48v9m0DQGhoKGQyGe7evVsi2yusefPmoXr16jA0NESDBg10HU6xKMnjjkofFkiUq5wP8ZyXmZkZatWqhfHjxyM+Pl7X4emd7OxsuLi4QCaTYe/evboOR6fu3r2rdOwYGxvD3t4ezZs3x3/+8x/cv3+/yLY1Z84c/Pnnn0U2XlHS59g0CQsLw5QpU9CiRQusW7cOc+bMybf/33//jTZt2sDR0REWFhaoXr06+vXrh3379pVQxO+G9PR0LFq0CE2bNoWNjY3S5+4///wj9csp8t/8f6xatWqYOHEiEhIS1MatVq0a3n//faW2lJQUzJgxA/Xq1YOlpSXs7OzQoEEDfPLJJ3j06FFx72qpYKTrAEi/ff3113Bzc0N6ejqOHz+OlStXYs+ePbhy5QosLCy0HufmzZswMCjeejwsLKxYx8/PoUOH8PjxY1SrVg2bNm1Cly5ddBaLvhg4cCDee+89KBQKvHz5EmfPnsXixYuxZMkSrF27FgMGDJD6tm7dGq9evYKJiUmBtjFnzhz07dsXPXv21HqdL7/8El988UWBtlMYecU2dOhQDBgwAKampsUeQ2EdOnQIBgYGWLt2rcafyfz58zF58mS0adMG06ZNg4WFBWJiYnDgwAFs2bIFnTt3LqGoS7dnz56hc+fOiIqKwvvvv49BgwbBysoKN2/exJYtW7B69WpkZmYqrbNy5UpYWVkhNTUVBw8exNKlS3H+/HkcP348323J5XK0bt0aN27cQGBgICZMmICUlBRcvXoVmzdvRq9eveDi4lKcu1sqsECifHXp0gWNGjUCAIwePRp2dnZYuHAh/vrrLwwcOFDrcbT5ZZCamgpLS8tCx1rQX65FaePGjWjYsCECAwPxn//85633Rd9ps38NGzbEkCFDlNru3bsHf39/BAYGwsPDA97e3gAAAwMDmJmZFVu8wP/HbGRkBCMj3X30GRoawtDQUGfb18aTJ09gbm6u8f+prKwszJ49G506dcr1D5QnT54UV4jvnOHDh+PChQv4448/0KdPH6Vls2fPxn//+1+1dfr27Qt7e3sAwEcffYQBAwZg69atOHPmDJo0aZLntv78809cuHABmzZtwqBBg5SWpaenqxViZRUvsVGBtG/fHgAQGxsL4PVfj82bN4ednR3Mzc3h6+uLP/74Q2091TlIOZfwjhw5go8//hiOjo6oXLkyLl26BJlMhp07d0p9o6KiIJPJ0LBhQ6Uxu3TpgqZNm0rvc5uDtHTpUtStWxcWFhaoUKECGjVqhM2bNyv1efjwIUaOHAknJyeYmpqibt26+Pnnn7XOyatXr7Bjxw4MGDAA/fr1w6tXr/DXX3+p9Rs+fDisrKzw8OFD9OzZE1ZWVnBwcMDnn3+O7Oxspb7Pnz/H0KFDYW1tjfLlyyMwMBAXL16ETCZDaGhovvucs61q1arlG/e9e/fw8ccfo3bt2jA3N4ednR0++OADtbkxef2sCsPV1RWhoaHIzMzE3Llzpfbc5oLcunULffr0gbOzM8zMzFC5cmUMGDAAiYmJAF7PG0pNTcX69eulSw05x1jOJYhr165h0KBBqFChAlq2bKm0LDebNm1C7dq1YWZmBl9fXxw9elRpeV55VR0zv9jymoO0YsUK1K1bF6ampnBxcUFQUJDa5ZK2bduiXr16uHbtGtq1awcLCwtUqlRJKZf5ySloatSoAVNTU1SrVg3/+c9/kJGRoRT7unXrkJqaKsX+5jH3pmfPniEpKQktWrTIdbmjo6P078zMTEyfPh2+vr6wsbGBpaUlWrVqhYiICKV1ci7Rzp8/H8uXL0f16tVhYWEBf39/PHjwAEIIzJ49G5UrV4a5uTl69OiBFy9eKI2Rc0kpLCwMDRo0gJmZGTw9PbF9+3at8nT69Gl07twZNjY2sLCwQJs2bXDixAmlPsnJyZg0aRKqVasGU1NTODo6olOnTjh//rxW21Dd3u7duzFq1Ci14gh4/Qfm/PnzNY7TqlUrAMDt27fz7ZezPLefm5mZGaytrbUJ+53HM0hUIDn/Y9nZ2QEAlixZgu7du2Pw4MHIzMzEli1b8MEHH2DXrl3o2rWrxvE+/vhjODg4YPr06UhNTUW9evVQvnx5HD16FN27dwcAHDt2DAYGBrh48SKSkpJgbW0NhUKBkydP4sMPP8xz7J9++gkTJ05E37598cknnyA9PR2XLl3C6dOnpb+a4uPj0axZM2mSroODA/bu3YtRo0YhKSkJkyZN0rgPO3fuREpKCgYMGABnZ2e0bds217/MgNdzlQICAtC0aVPMnz8fBw4cwIIFC1CjRg2MGzcOAKBQKNCtWzecOXMG48aNQ506dfDXX38hMDBQYywFcfbsWZw8eRIDBgxA5cqVcffuXaxcuRJt27bFtWvX1C6hqv6sCsvPzw81atRAeHh4nn0yMzMREBCAjIwMTJgwAc7Oznj48CF27dqFhIQE2NjYYMOGDRg9ejSaNGkiHQc1atRQGueDDz5AzZo1MWfOHAgh8o3ryJEj2Lp1KyZOnAhTU1OsWLECnTt3xpkzZ1CvXr0C7aM2sb1p5syZmDVrFjp27Ihx48bh5s2bWLlyJc6ePYsTJ07A2NhY6vvy5Ut07twZvXv3Rr9+/fDHH39g6tSp8PLy0nhpd/To0Vi/fj369u2Lzz77DKdPn0ZISAiuX7+OHTt2SLGvXr0aZ86cwZo1awAAzZs3z3U8R0dHmJub4++//8aECRNga2ub57aTkpKwZs0aDBw4EGPGjEFycjLWrl2LgIAAnDlzRm0i+KZNm5CZmYkJEybgxYsXmDt3Lvr164f27dvj8OHDmDp1KmJiYrB06VJ8/vnnan/U3Lp1C/3798fYsWMRGBiIdevW4YMPPsC+ffvQqVOnPOM8dOgQunTpAl9fX8yYMQMGBgZYt24d2rdvj2PHjklnZsaOHYs//vgD48ePh6enJ54/f47jx4/j+vXran/MaZLzB+HQoUMLtJ6qnKK7QoUK+fZzdXUFAPzyyy/48ssv8/yDocwTRLlYt26dACAOHDggnj59Kh48eCC2bNki7OzshLm5ufj333+FEEKkpaUprZeZmSnq1asn2rdvr9Tu6uoqAgMD1cZv2bKlyMrKUurbtWtX0aRJE+l97969Re/evYWhoaHYu3evEEKI8+fPCwDir7/+kvq1adNGtGnTRnrfo0cPUbdu3Xz3c9SoUaJixYri2bNnSu0DBgwQNjY2avuXm/fff1+0aNFCer969WphZGQknjx5otQvMDBQABBff/21UruPj4/w9fWV3m/btk0AEIsXL5basrOzRfv27QUAsW7dujz3+c1tubq6KrUBEDNmzJDe57ZvkZGRAoD45ZdfpLb8fla5iY2NFQDEvHnz8uzTo0cPAUAkJiYKIYSIiIgQAERERIQQQogLFy4IAOL333/Pd1uWlpZKx1WOGTNmCABi4MCBeS57EwABQJw7d05qu3fvnjAzMxO9evWS2nLLa15j5hVbTj5jY2OFEEI8efJEmJiYCH9/f5GdnS31W7ZsmQAgfv75Z6mtTZs2aj+fjIwM4ezsLPr06aO2rTdFR0cLAGL06NFK7Z9//rkAIA4dOqS0n5aWlvmOl2P69OkCgLC0tBRdunQR3377rYiKilLrl5WVJTIyMpTaXr58KZycnMTIkSOltpzjx8HBQSQkJEjt06ZNEwCEt7e3kMvlUvvAgQOFiYmJSE9Pl9pcXV0FALFt2zapLTExUVSsWFH4+PhIbarHnUKhEDVr1hQBAQFCoVBI/dLS0oSbm5vo1KmT1GZjYyOCgoK0ypEmvXr1EgDEy5cvteqfc7zdvHlTPH36VNy9e1f8/PPPwtzcXDg4OIjU1FSl/q6urqJr165K+1O7dm0BQLi6uorhw4eLtWvXivj4+CLZn3cFL7FRvjp27AgHBwdUqVIFAwYMgJWVFXbs2IFKlSoBAMzNzaW+L1++RGJiIlq1aqX1aeYxY8aozcfIWT/nLMXx48fx3nvvoUGDBjh27BiA12eVZDKZdNkkN+XLl8e///6Ls2fP5rpcCIFt27ahW7duEELg2bNn0isgIACJiYka9+P58+fYv3+/0nysPn36QCaT4bfffst1nbFjx6rt7507d6T3+/btg7GxMcaMGSO1GRgYICgoKN9YCurNn51cLsfz58/h7u6O8uXL57rfuf2sCsvKygrA68sUubGxsQEA7N+/H2lpaYXejmqu8+Pn5wdfX1/pfdWqVdGjRw/s379f7RJoUTpw4AAyMzMxadIkpRsZxowZA2tra+zevVupv5WVldLcLhMTEzRp0kTpGMrNnj17AADBwcFK7Z999hkAqG1HW7NmzcLmzZvh4+OD/fv347///S98fX3RsGFDXL9+XepnaGgozWlSKBR48eIFsrKy0KhRo1yPtw8++EA6DgBIl9OHDBmiNIesadOmyMzMxMOHD5XWd3FxQa9evaT31tbWGDZsGC5cuIC4uLhc9yU6Ohq3bt3CoEGD8Pz5c+nzIDU1FR06dMDRo0ehUCgAvP58OX36dJHc8ZWUlAQAKFeuXIHWq127NhwcHFCtWjWMHDkS7u7u2Lt3r8YbaMzNzXH69GlMnjwZwOvLvqNGjULFihUxYcIEpUuuZRkLJMrX8uXLER4ejoiICFy7dg137txBQECAtHzXrl1o1qwZzMzMYGtrCwcHB6xcuVKaJ6KJm5ubWlurVq2QlZWFyMhI3Lx5E0+ePEGrVq3QunVrpQLJ09Mz31P6U6dOhZWVFZo0aYKaNWsiKChIaR7B06dPkZCQgNWrV8PBwUHpNWLECACaJ5lu3boVcrkcPj4+iImJQUxMDF68eIGmTZti06ZNav3NzMzg4OCg1FahQgW8fPlSen/v3j1UrFhR7UPO3d0931gK6tWrV5g+fTqqVKkCU1NT2Nvbw8HBAQkJCbn+/HL7WRVWSkoKgLx/Ibi5uSE4OBhr1qyBvb09AgICsHz5cq2PqzfH0VbNmjXV2mrVqoW0tDQ8ffq0QNstiHv37gF4/cvuTSYmJqhevbq0PEflypXVLomoHkN5bcfAwEDtOHJ2dkb58uXVtlMQAwcOxLFjx/Dy5UuEhYVh0KBBuHDhArp164b09HSp3/r161G/fn2YmZnBzs4ODg4O2L17d64/16pVqyq9zymWqlSpkmu76v67u7ur5alWrVoAkOczqG7dugUACAwMVPtMWLNmDTIyMqRY586diytXrqBKlSpo0qQJZs6cqbFIzUvOnJ+8/mDIy7Zt2xAeHo7NmzejWbNm0uR6bdjY2GDu3Lm4e/cu7t69i7Vr16J27dpYtmwZZs+eXeB9eBdxDhLlq0mTJtJdbKqOHTuG7t27o3Xr1lixYgUqVqwIY2NjrFu3Tm0idF5y+5+5UaNGMDMzw9GjR1G1alU4OjqiVq1aaNWqFVasWIGMjAwcO3ZM6a/D3Hh4eODmzZvYtWsX9u3bh23btmHFihWYPn06Zs2aJf0lOGTIkDzn99SvXz/fbeQUQXlNUr1z5w6qV68uvS/qu5dkMlmuc2u0OeMxYcIErFu3DpMmTYKfnx9sbGwgk8kwYMAAKTdv0vaDVxtXrlyBo6NjvpNBFyxYgOHDh+Ovv/5CWFgYJk6ciJCQEJw6dUrrSeJFGTOAPOdqFOcZJlV5HUO5HQe5Kc75JtbW1ujUqRM6deoEY2NjrF+/HqdPn0abNm2wceNGDB8+HD179sTkyZPh6OgIQ0NDhISE5DqpOK/9fNv9z0/OcT9v3rw8H46Zc/azX79+aNWqFXbs2IGwsDDMmzcP33//PbZv317gx3zUqVMHAHD58mVporU2WrduLd3F1q1bN3h5eWHw4MGIiooq0GNVXF1dMXLkSPTq1QvVq1fHpk2b8M033xRoH95FLJCo0LZt2wYzMzPs379f6Tb+devWvdW4OZcMjh07hqpVq0ofGK1atUJGRgY2bdqE+Ph4tG7dWuNYlpaW6N+/P/r374/MzEz07t0b3377LaZNmwYHBweUK1cO2dnZ6NixY4HjjI2NxcmTJzF+/Hi0adNGaZlCocDQoUOxefNmfPnllwUa19XVFREREUhLS1M6ixQTE6PWt0KFCrn+1arN2YA//vgDgYGBWLBggdSWnp6e64PmilJkZCRu376t9giA3Hh5ecHLywtffvklTp48iRYtWmDVqlXSh3dR/rLPOXvwpn/++QcWFhbSWb8KFSrkmp/c8q1tbDkTZm/evKlUTGdmZiI2NrZQx2Ze21EoFLh16xY8PDyk9vj4eCQkJEhxFJVGjRph/fr1ePz4MYDXx1v16tWxfft2pdzMmDGjSLebIyYmBkIIpW3lPGwxrzs8cybSW1tba5X3ihUr4uOPP8bHH3+MJ0+eoGHDhvj2228LXCB169YNISEh2LhxY4EKpDdZWVlhxowZGDFiBH777Tel54xpq0KFCqhRowauXLlSqBjeNbzERoVmaGgImUym9Nfz3bt3i+Tpwa1atcLp06cREREhfWDY29vDw8MD33//vdQnP8+fP1d6b2JiAk9PTwghIJfLYWhoiD59+mDbtm25fiBouqySc/ZoypQp6Nu3r9KrX79+aNOmTa6X2TQJCAiAXC7HTz/9JLUpFAosX75crW+NGjVw48YNpVgvXryodktybgwNDdX+6l66dGmxng25d+8ehg8fDhMTE2n+Q26SkpKQlZWl1Obl5QUDAwOl+RGWlpZFVtBFRkYqzYV58OAB/vrrL/j7+0tnLWrUqIHExERcunRJ6vf48WPpDrA3aRtbx44dYWJigh9++EHp57F27VokJiZqdTeoNt577z0AwOLFi5XaFy5cCACF2k5aWhoiIyNzXZbzRPmcS4c5OXxzH0+fPp3n+m/r0aNHSj+XpKQk/PLLL2jQoAGcnZ1zXcfX1xc1atTA/PnzpcvAb8r5/yw7O1vtsqCjoyNcXFwKNX/Hz88PnTt3xpo1a3L9/MzMzMTnn3+ucZzBgwejcuXK0mdkXi5evIhnz56ptd+7dw/Xrl1Tu9xbVvEMEhVa165dsXDhQnTu3BmDBg3CkydPsHz5cri7uyv9AimMVq1a4dtvv8WDBw+UCqHWrVvjxx9/RLVq1TReZvH394ezszNatGgBJycnXL9+HcuWLUPXrl2luS/fffcdIiIi0LRpU4wZMwaenp548eIFzp8/jwMHDqg9X+VNmzZtQoMGDdTmROTo3r07JkyYgPPnzxfott+ePXuiSZMm+OyzzxATE4M6depg586dUixv/kU8cuRILFy4EAEBARg1ahSePHmCVatWoW7dutLEz7y8//772LBhA2xsbODp6YnIyEgcOHBAeoTD2zp//jw2btwIhUKBhIQEnD17Ftu2bYNMJsOGDRvyvXx56NAhjB8/Hh988AFq1aqFrKwsbNiwQSpqc/j6+uLAgQNYuHAhXFxc4ObmpvRsrIKoV68eAgIClG7zB15PQs4xYMAATJ06Fb169cLEiRORlpaGlStXolatWmoTjbWNzcHBAdOmTcOsWbPQuXNndO/eHTdv3sSKFSvQuHFjrc60acPb2xuBgYFYvXo1EhIS0KZNG5w5cwbr169Hz5490a5duwKPmZaWhubNm6NZs2bo3LkzqlSpgoSEBPz55584duwYevbsCR8fHwCvj7ft27ejV69e6Nq1K2JjY7Fq1Sp4enrmWoy8rVq1amHUqFE4e/YsnJyc8PPPPyM+Pj7fM9wGBgZYs2YNunTpgrp162LEiBGoVKkSHj58iIiICFhbW+Pvv/9GcnIyKleujL59+8Lb2xtWVlY4cOAAzp49q3RG9vDhw2jXrh1mzJih8XsQf/nlF/j7+6N3797o1q0bOnToAEtLS9y6dQtbtmzB48ePNT4LydjYGJ988gkmT56Mffv25fkU8/DwcMyYMQPdu3dHs2bNYGVlhTt37uDnn39GRkaG3n5nY4nT1e1zpN9ybkU+e/Zsvv3Wrl0ratasKUxNTUWdOnXEunXrcr3lOa/b/PMaPykpSRgaGopy5cop3Vq+ceNGAUAMHTpUbR3VW95//PFH0bp1a2FnZydMTU1FjRo1xOTJk6Vby3PEx8eLoKAgUaVKFWFsbCycnZ1Fhw4dxOrVq/Pc76ioKAFAfPXVV3n2uXv3rgAgPv30UyFE3rdO55avp0+fikGDBoly5coJGxsbMXz4cHHixAkBQGzZskWp78aNG0X16tWFiYmJaNCggdi/f79Wt/m/fPlSjBgxQtjb2wsrKysREBAgbty4UeCflaqc27RzXkZGRsLW1lY0bdpUTJs2Tdy7d09tHdXbre/cuSNGjhwpatSoIczMzIStra1o166dOHDggNJ6N27cEK1btxbm5uYCgBR3Tk6fPn2qtq28bvMPCgoSGzdulI5nHx8fKZ43hYWFiXr16gkTExNRu3ZtsXHjxlzHzCs21dv8cyxbtkzUqVNHGBsbCycnJzFu3Di1277btGmT66Mr8nr8gCq5XC5mzZol3NzchLGxsahSpYqYNm2a0i3yOeNpc5u/XC4XP/30k+jZs6dwdXUVpqamwsLCQvj4+Ih58+Yp3davUCjEnDlzpH4+Pj5i165darHn9ZiInGNE9dEPuR2fObe179+/X9SvX1/6fFJdV/W4y3HhwgXRu3dv6bPD1dVV9OvXTxw8eFAI8frRCpMnTxbe3t6iXLlywtLSUnh7e4sVK1YojfP3338LAGLVqlUacynE69vv58+fLxo3biysrKyEiYmJqFmzppgwYYKIiYmR+uV3fCcmJgobGxulz0LV2/zv3Lkjpk+fLpo1ayYcHR2FkZGRcHBwEF27dlV63ENZJxOiCGa2EVGx+/PPP9GrVy8cP348z0nhRPR6jlG9evWwa9cuncYxZcoU/Prrr4iJidHr796j3HEOEpEeevXqldL77OxsLF26FNbW1gV+Si8R6UZERAS++uorFkelFOcgEemhCRMm4NWrV/Dz80NGRga2b9+OkydPYs6cOUV+6zoRFY+8HlJLpQMLJCI91L59eyxYsAC7du1Ceno63N3dsXTpUowfP17XoRERlQmcg0RERESkgnOQiIiIiFSwQCIiIiJSwTlIhaBQKPDo0SOUK1euWL/XiIiIiIqOEALJyclwcXHR+H11LJAK4dGjR3k+PZmIiIj024MHDzR+GwMLpELI+ZqKBw8e5Ppt5HK5HGFhYfD394exsXFJh1cqMEfaYZ40Y440Y460wzxpVtpzlJSUhCpVqki/x/PDAqkQci6rWVtb51kgWVhYwNraulQeQCWBOdIO86QZc6QZc6Qd5kmzdyVH2kyP4SRtIiIiIhUskIiIiIhUsEAiIiIiUsE5SEREZYRCoUB6erquw9BbcrkcRkZGSE9PR3Z2tq7D0UulIUcmJiYab+HXBgskIqIywNDQELGxseC3S+VNCAFnZ2c8ePCAz7jLQ2nIkYGBAdzc3GBiYvJW47BAIiJ6xwkhYGNjA0NDQ1SqVKlI/rp+FykUCqSkpMDKyoo5yoO+5yjnQc6PHz9G1apV36qIY4FERPSOy87Ohrm5ORwcHGBhYaHrcPSWQqFAZmYmzMzM9PKXvz4oDTlycHDAo0ePkJWV9VaPItDPvSMioiKTnZ0NmUxWqp9bQ6StnEtrbztHigUSEdE7Lmfekb7OGSEqSkV1nLNAIiIiIlLBAomIiIhIBQskIiKiItS2bVtMmjRJ12HQW+JdbEREZdSi8H9KdHufdqpVotvTle3bt78zE+KTk5Px1VdfYceOHXjy5Al8fHzwzTffoG3btvmut3z5csybNw9xcXHw9vbG0qVL0aRJE2n50aNHMW/ePERFReHx48fYsWMHevbsWbw7U0A8g0RERFQEMjMzAQC2trYoV66cjqMpGqNHj0Z4eDg2bNiAy5cvo1OnTujZsycePnyY5zpbt25FcHAwZsyYgfPnz8Pb2xsBAQF48uSJ1Cc1NRXe3t5Yvnx5SexGobBAIiIivdW2bVuMHz8e48ePh42NDezt7fHVV19Jd+ZlZGRg4sSJcHR0hJmZGVq2bImzZ88qjfHHH3/Ay8sL5ubmsLOzQ8eOHZGamqpx25rGzolt0qRJsLe3R0BAgNT+5iW25ORkDB48GJaWlqhYsSIWLVpUqMtwx48fh7GxsdLXxdy9excymQz37t0r0FjaePXqFbZt24a5c+eidevWcHd3x4wZM1C9enWsWrUqz/UWLlyIMWPGYMSIEfD09MSqVatgYWGBn3/+WerTpUsXfPPNN+jVq1eRx11UWCBR3iJClF9ERDqwfv16GBkZ4cyZM1iyZAkWLlyINWvWAACmTJmCbdu2Yf369Th//jzc3d0REBCAFy9eAAAeP36MgQMHYuTIkbh+/ToOHz6M3r17a/WVK5rGzonNxMQEJ06cyLNoCA4OxokTJ7Bz506Eh4fj2LFjOH/+fIHzEB0dDQ8PD5iZmUltFy5cQIUKFeDq6prrOnPmzIGVlVW+r/v37+e6blZWFrKzs5W2BwBmZmY4ceJErutkZmYiKioKHTt2lNoMDAzQsWNHREZGFnSXdYpzkIiISK9VqVIFixYtgkwmQ+3atXH58mUsWrQIgwYNwsqVKxEaGoouXboAAH766SeEh4dj7dq1mDx5Mh4/foysrCz07t1bKiK8vLw0bjM1NVXj2ABQs2ZNzJ07N89xkpOTsX79emzevBkdOnQAAKxbtw4uLi4FzsPFixfh4+Oj1BYdHQ1vb+881xk7diz69euX77h5xVKuXDn4+flh9uzZ8PDwgJOTEzZt2oSzZ8/C3d0913WePXuG7OxsODk5KbU7OTnhxo0b+cahb1ggERGRXmvWrJnSw//8/PywYMECxMTEQC6Xo0WLFtIyY2NjNGnSBNevXwcAeHt7o0OHDvDy8kJAQAD8/f3Rt29fVKhQId9t3r59W+PYAODr65vvOHfu3IFcLleaoGxjY4PatWtrt/NviI6OxqBBg5TaLly4gAYNGuS5jq2tLWxtbQu8rRwbNmzAyJEjUalSJRgaGqJhw4bo06cPLl++XOgxSwteYiMioneWoaEhwsPDsXfvXnh6emLp0qWoXbs2YmNji2R8S0vLIhlHk+zsbFy5ckXtDNL58+fzLZDe5hIbANSoUQNHjhxBSkoKHjx4gFOnTiErKwtubm659re3t4ehoSHi4+OV2uPj4+Hs7Kz9DusBFkhERKTXTp8+rfT+1KlTqFmzJtzd3aX5PznkcjnOnj0LT09PqU0mk6FFixaYNWsWLly4ABMTE+zYsSPfbdaoUUOrsTWpXr06jI2NlSZ3JyYm4p9/CvaIhZs3byI9PV3pclhkZCQePnyYb4E0duxYREdH5/vS5nJfzgTzly9f4uDBg+jevXuu/UxMTODr64uDBw9KbQqFAgcPHoSfn5/2O6wHeImNiIj02v379xEcHIyPPvoI58+fx9KlS7FgwQJYWlpi3LhxmDx5MmxtbVG1alXMnTsXaWlpGDVqFIDXxdXBgwfh7+8PR0dHnD59Gk+fPoWHh0e+29RmbG2UK1cOgYGB0jiOjo6YMWMGDAwMCvSdYdHR0QCApUuXYuLEiYiJicHEiRMB/P/jBXLztpfY9u/fDyEEateujZiYGEyePBm1atXCiBEjpD7Lli3Djh07pKIoODgYgYGBaNSoEZo0aYLFixcjNTVVaZ2UlBTExMRI72NjYxEdHS3lWh+wQCIiIr02bNgwvHr1Ck2aNIGhoSE++eQTfPjhhwCA7777DgqFAkOHDkVycjIaNWqE/fv3S3OMrK2tcfToUSxevBhJSUlwdXXFggULpInX+dE0trYWLlyIsWPH4v3334e1tTWmTJmCBw8eKN0dFhoaihEjRuR5d110dDQCAgJw584deHl5wdPTE7NmzcK4cePwww8/YMOGDQWKSVuJiYmYNm0a/v33X9ja2qJ3796YMmWK0oMwnz17htu3b0vv+/fvj6dPn2L69OmIi4tDgwYNsG/fPqWJ2+fOnUO7du2k98HBwQCAwMBAhIaGFsu+FJRMaHOvIylJSkqCjY0NEhMTYW1trbZcLpdjz549eO+990r301RVb+1vN63Ihn5nclTMmCfNmCPNkpOT8c8//8DDwwMWFha6DqdA2rZtiwYNGmDx4sXFvi2FQoGkpCRYW1vDwKD4ZqCkpqaiUqVKWLBggXQ2asaMGThy5AgOHz6c6zoBAQFo3Lgxvvnmm2KLSxsllaO3kZ6ejtjYWLi5uak9okDT7+836efeERERvSMuXLiAX3/9Fbdv38b58+cxePBgAECPHj2kPnv37s33cQEXL17U6vEEVHR4iY2IiMqc+/fv5zvZ+tq1a0U6F2b+/Pm4efOmNIn52LFjsLe3l5afOXMmz3Xj4uIQHx/PAqmEsUAi7eX2NO0ivOxGRKQqr0tOb8vFxUWa+JxDoVAgJSUFVlZWhXqQY158fHwQFRVV6PWdnZ21evI3FS0WSPR2inGeEhFRcTEyMlJ7GnRpmF9DJYdHABEREZEKFkhEREREKlggEREREalggURERESkggUSERERkQoWSEREREQqWCARERERqWCBRERERKSCBRIREVExaNu2LSZNmqTrMKiQ+CRtIqKyKrevDypOZexJ+9u3b4exsbGuwygSR48exbx58xAVFYXHjx9j27Zt6N27d57Ld+zYgZ49exZ43NzWe/jwIaZOnYq9e/ciLS0N7u7uWLduHRo1alTEe6mMZ5CIiIiKUGZmJgDA1tYW5cqV03E0RSM1NRXe3t5YunRpvsuXL19eqHHzWu/ly5do0aIFjI2NsXfvXly7dg0LFixAhQoVCrwPBaVXBdLKlStRv359WFtbw9raGn5+fti7d6+0PD09HUFBQbCzs4OVlRX69OmD+Ph4pTHu37+Prl27wsLCAo6Ojpg8eTKysrKU+hw+fBgNGzaEqakp3N3dERoaWhK7R0REBdS2bVtMnDgRU6ZMga2tLZydnTFz5kxpuUKhQEhICNzc3GBubg5vb2/88ccfSmMkJydj8ODBsLS0RMWKFbFo0aICXf7KyMjAxIkT4ejoCDMzM7Rs2RJnz55VinH8+PGYNGkS7O3tERAQILW/uY23jQMAjh8/DmNjY6Snp0ttd+/ehUwmw71797Qep6C6dOmCb775Br169SrU8sKO+/3336NKlSpYt24dmjRpAjc3N/j7+6NGjRoF3oeC0qsCqXLlyvjuu+8QFRWFc+fOoX379ujRoweuXr0KAPj000/x999/4/fff8eRI0fw6NEjpVN82dnZ6Nq1KzIzM3Hy5EmsX78eoaGhmD59utQnNjYWXbt2Rbt27RAdHY1JkyZh9OjR2L9/f4nvLxERabZ+/XpYWlri9OnTmDt3Lr7++muEh4cDAEJCQvDLL79g1apVuHr1Kj799FMMGTIER44ckdYPDg7GiRMnsHPnToSHh+PYsWM4f/681tufMmUKtm3bhvXr1+P8+fNwd3dHQEAAXrx4oRSjiYkJTpw4gVWrVuU6ztvGAQDR0dHw8PCAmZmZ1HbhwgVUqFABrq6uua4zZ84cWFlZ5fu6f/9+geIoKTt37kSjRo3wwQcfwNHRET4+Pvjpp59KZNt6NQepW7duSu+//fZbrFy5EqdOnULlypWxdu1abN68Ge3btwcArFu3Dh4eHjh16hSaNWuGsLAwXLt2DQcOHICTkxMaNGiA2bNnY+rUqZg5cyZMTEywatUquLm5YcGCBQAADw8PHD9+HIsWLZKqfiIi0h/169fHjBkzAAA1a9bEsmXLcPDgQbRu3Rpz5szBgQMH4OfnBwCoXr06jh8/jh9//BFt2rRBcnIy1q9fj82bN6NDhw4AXv/ucHFx0WrbqampWLlyJUJDQ9GlSxcAwE8//YTw8HCsXbsWkydPluKaO3dunuO8bRw5Ll68CB8fH6W26OhoeHt757nO2LFj0a9fv3zHLWgcJeXOnTtYuXIlgoOD8Z///Adnz57FxIkTYWJigsDAwGLdtl4VSG/Kzs7G77//jtTUVPj5+SEqKgpyuRwdO3aU+tSpUwdVq1ZFZGQkmjVrhsjISHh5ecHJyUnqExAQgHHjxuHq1avw8fFBZGSk0hg5ffI7xZmRkYGMjAzpfVJSEgBALpdDLper9c9py21ZqSIKcYJRy31+Z3JUzJgnzZgjzXKmGQghoFAopHaZECUah3hj2wXh5eWlFLezszPi4+Pxzz//IC0tDZ06dVLqn5mZCR8fHygUCsTExEAul6NRo0bSGOXKlUPt2rXV8iH+l48322/dugW5XA4/Pz+pzdDQEI0bN8a1a9ektoYNGyqN9eaYBY0jP9HR0Rg4cKBS//Pnz8Pb2zvPMcqXL4/y5ctrHFubGMQbx0x+/RUKhdb7lN96CoUCjRo1wjfffAMA8Pb2xuXLl7Fq1SoMHTo0zzGEEJDL5TA0NFRaVpDPCb0rkC5fvgw/Pz+kp6fDysoKO3bsgKenJ6Kjo2FiYqL2Q3ZyckJcXBwAIC4uTqk4ylmesyy/PklJSXj16hXMzc3VYgoJCcGsWbPU2sPCwmBhYZHnvuScAi696hR8lT17CtS99OeoZDBPmjFHeTMyMoKzszNSU1OVfkGYvfGHX0lI/98flwWRlZUFIYT0hynw+g/ojIwMaQ7q1q1bUbFiRaX1TExMkJSUhJSUFACvz+CojpGZmanUliM5OVn6d17rZ2VlQS6XIykpCVlZWTA2NlYbKysrS9pGYeJQlZ2djStXrqBWrVpK/c+fP4/33nsvzzEWLFiARYsW5Tt2ZGQkqlSpojGGHK9evco3Zk3LtV3PyckJ7u7uSm3VqlXDtm3b8hw/MzMTr169wtGjR9XmIKelpWkdi94VSLVr10Z0dDQSExPxxx9/IDAwUOlasi5MmzYNwcHB0vukpCRUqVIF/v7+sLa2Vusvl8sRHh6OTp06le5bPI8tLPg6rYI198E7lKNixjxpxhxplpKSgjt37sDS0lLpj0CZqWmJxmGSy+elJkZGRjAxMVH6rDUyMoKxsTEaN24MU1NTPHv2TLr8pap+/fowNjbGjRs3ULduXQBAYmIibt++jbZt2yqNK4RAcnIyypUrB5lMBuD1GQsTExNcunQJ9erVA/D6mIuOjsYnn3wCa2vrXGNUjb0gceTl2rVrSE9Ph7u7u9Q/MjISjx49QrNmzfIc45NPPsnzbEuOatWqwchIc0mQcwbJ3Nw835g1Ldd2vZYtWyI2Nlap7cGDB6hWrVqe46enp8Pc3BytW7dWmqsFoEBFm94VSCYmJnB3dwcA+Pr64uzZs1iyZAn69++PzMxMJCQkKJ1Fio+Ph7OzM4DXp13PnDmjNF7OXxhv9lG98y0+Ph7W1ta5nj0CAFNTU5jm8kFibGyc7weypuV6T1aI0+EF3N9Sn6MSwjxpxhzlLecXn0wmg4HBG5fO/1cElBSZQeHuC1KNWyaTQSaTwcbGBp9//jk+++wzAK9/mSYmJuLEiROwtrZGYGAgbGxsEBgYiKlTp8Le3h6Ojo6YMWMGDAwMpFeOnEs7b26vXLlyGDdunLR+1apVMXfuXKSlpWH06NFSP7XcqsRekDjycunSJQDA8uXLMXHiRMTExGDixIkAXp+tymsMe3t72Nvbaxw/PykpKYiJiZFydPfuXVy6dAm2traoWrWqtDzHvXv3lJYDwLJly7Bjxw4cPHhQbdy81gsODkbz5s3x3XffoV+/fjhz5gx++uknrF69Os/9NTAwgEwmy/UzoSCfEXp1F1tuFAoFMjIy4OvrC2NjY6XE3rx5E/fv35cm5/n5+eHy5ct48uSJ1Cc8PBzW1tbw9PSU+rw5Rk6fnDGIiKj0mD17Nr766iuEhITAw8MDnTt3xu7du+Hm5ib1WbhwIfz8/PD++++jY8eOaNGihdqdYPn57rvv0KdPHwwdOhQNGzZETEwM9u/fX+Bn8WiKIzQ0VDpzlZvo6GgEBATgzp078PLywn//+1/MmjUL1tbW+OGHHwoUS0GdO3cOPj4+8PX1BQB89tln8PHxke4Sz1meM4E8ODhYaTkAPHv2DLdv38513LzWa9y4MXbs2IFff/0V9erVw+zZs7F48WIMHjy4WPcXAGRClPAsvXxMmzYNXbp0QdWqVZGcnIzNmzfj+++/x/79+9GpUyeMGzcOe/bsQWhoKKytrTFhwgQAwMmTJwG8vj7boEEDuLi4YO7cuYiLi8PQoUMxevRozJkzB8Dr2/zr1auHoKAgjBw5EocOHcLEiROxe/dure9iS0pKgo2NDRITE/O8xLZnzx689957pfsv2sI8ZVfLJ+W+MzkqZsyTZsyRZsnJyfjnn3/g4eGR77zJsiI1NRWVKlXCggULMGrUKKldoVAgKSkJ1tbWWp3RKeo4ZsyYgSNHjuDw4cO59g8ICEDjxo2lCcu6UNI5Koz09HTExsbCzc0t10ts+f3+fpNeXWJ78uQJhg0bhsePH8PGxgb169eXiiMAWLRoEQwMDNCnTx9kZGQgICAAK1askNY3NDTErl27MG7cOPj5+cHS0hKBgYH4+uuvpT5ubm7YvXs3Pv30UyxZsgSVK1fGmjVreIs/EdE76sKFC7hx4waaNGmCxMRE6XdCjx499CqOvXv3YtmyZXmuf/HiRYwcObJEYiU9K5DWrl2b73IzMzMsX74830eZu7q6Yo+GO6natm2LCxcuFCpGIiIqfebPn4+bN2/CxMQEvr6+OHbsGOzt7XH//n1pCkZurl27Js2hKc44AKjNoX1TXFwc4uPj4eXlVWSxUP70qkAiIiIqaj4+PoiKisp1mYuLC6KjowG8vnyUkpICKysr6fJRUT5AMb84NHF2doYezYgpE1ggERFRmWVkZCTdOV0a5tdQyeERQERERKSCBRIRERGRChZIRERERCpYIBERveNyHj7ISb5UFhTVcc4CiYjoHWdoaCh9uznRuy4zMxPA6+P+bfAuNiKid5yhoSFevXqFp0+fwsTEhHdo5UGhUCAzMxPp6enMUR70PUcKhQJPnz6FhYWFVl++mx8WSERE7ziZTIaEhAQ4ODjg3r17ug5Hbwkh8OrVK5ibm+f7nWhlWWnIkYGBAapWrfrW8bFAIiIqAxQKBdzc3DgPKR9yuRxHjx5F69at+b1+eSgNOSqqs6QskIiIyggDAwO9/aWmDwwNDZGVlQUzMzPmKQ9lKUf6dwGRiIiISMdYIBERERGpYIFEREREpIIFEhEREZEKFkhEREREKlggEREREangbf70WkRI8YzTblrRjEtERFSCeAaJiIiISAULJCIiIiIVLJCIiIiIVLBAIiIiIlLBAomIiIhIBQskIiIiIhUskIiIiIhUsEAiIiIiUsECiYiIiEgFCyQiIiIiFSyQiIiIiFSwQCIiIiJSwQKJiIiISAULJCIiIiIVLJCIiIiIVLBAIiIiIlLBAomIiIhIBQskIiIiIhUskIiIiIhUsEAiIiIiUsECiYiIiEgFCyQiIiIiFSyQiIiIiFSwQCIiIiJSwQKJiIiISIVeFUghISFo3LgxypUrB0dHR/Ts2RM3b95U6tO2bVvIZDKl19ixY5X63L9/H127doWFhQUcHR0xefJkZGVlKfU5fPgwGjZsCFNTU7i7uyM0NLS4d4+IiIhKCb0qkI4cOYKgoCCcOnUK4eHhkMvl8Pf3R2pqqlK/MWPG4PHjx9Jr7ty50rLs7Gx07doVmZmZOHnyJNavX4/Q0FBMnz5d6hMbG4uuXbuiXbt2iI6OxqRJkzB69Gjs37+/xPaViIiI9JeRrgN40759+5Teh4aGwtHREVFRUWjdurXUbmFhAWdn51zHCAsLw7Vr13DgwAE4OTmhQYMGmD17NqZOnYqZM2fCxMQEq1atgpubGxYsWAAA8PDwwPHjx7Fo0SIEBAQU3w4SERFRqaBXBZKqxMREAICtra1S+6ZNm7Bx40Y4OzujW7du+Oqrr2BhYQEAiIyMhJeXF5ycnKT+AQEBGDduHK5evQofHx9ERkaiY8eOSmMGBARg0qRJucaRkZGBjIwM6X1SUhIAQC6XQy6Xq/XPacttmd4SxXQyMY8clMoc6QDzpBlzpBlzpB3mSbPSnqOCxK23BZJCocCkSZPQokUL1KtXT2ofNGgQXF1d4eLigkuXLmHq1Km4efMmtm/fDgCIi4tTKo4ASO/j4uLy7ZOUlIRXr17B3NxcaVlISAhmzZqlFmNYWJhUmOUmPDy8AHusa3WKZ9g9e/JdXLpypDvMk2bMkWbMkXaYJ81Ka47S0tK07qu3BVJQUBCuXLmC48ePK7V/+OGH0r+9vLxQsWJFdOjQAbdv30aNGjWKJZZp06YhODhYep+UlIQqVarA398f1tbWav3lcjnCw8PRqVMnGBsbF0tMRe7YwpLbVqvg0pkjHWCeNGOONGOOtMM8aVbac5RzBUgbelkgjR8/Hrt27cLRo0dRuXLlfPs2bdoUABATE4MaNWrA2dkZZ86cUeoTHx8PANK8JWdnZ6ntzT7W1tZqZ48AwNTUFKampmrtxsbG+R4gmpbrFZmi5Lb1Rk5KVY50iHnSjDnSjDnSDvOkWWnNUUFi1qu72IQQGD9+PHbs2IFDhw7Bzc1N4zrR0dEAgIoVKwIA/Pz8cPnyZTx58kTqEx4eDmtra3h6ekp9Dh48qDROeHg4/Pz8imhPiIiIqDTTqwIpKCgIGzduxObNm1GuXDnExcUhLi4Or169AgDcvn0bs2fPRlRUFO7evYudO3di2LBhaN26NerXrw8A8Pf3h6enJ4YOHYqLFy9i//79+PLLLxEUFCSdBRo7dizu3LmDKVOm4MaNG1ixYgV+++03fPrppzrbdyIiItIfelUgrVy5EomJiWjbti0qVqwovbZu3QoAMDExwYEDB+Dv7486dergs88+Q58+ffD3339LYxgaGmLXrl0wNDSEn58fhgwZgmHDhuHrr7+W+ri5uWH37t0IDw+Ht7c3FixYgDVr1vAWfyIiIgKgZ3OQhBD5Lq9SpQqOHDmicRxXV1fs0XD3VNu2bXHhwoUCxUdERERlg14VSFSCIkJ0HQEREZHe0qtLbERERET6gAUSERERkQoWSEREREQqWCARERERqWCBRERERKSCBRIRERGRChZIRERERCpYIBERERGpYIFEREREpIIFEpW8iBDg2MLX/875LxERkR5hgURERESkggUSERERkQoWSEREREQqWCARERERqWCBRERERKSCBRIRERGRChZIRERERCpYIBERERGpYIFEREREpIIFEhEREZEKFkhEREREKlggEREREalggURERESkggUSERERkQoWSEREREQqjHQdABEiQtTb2k0r+TiIiIj+h2eQiIiIiFSwQCIiIiJSwQKJiIiISAULJCIiIiIVLJCIiIiIVLBAIiIiIlLBAomIiIhIBQskIiIiIhVFWiDduXMH169fL8ohiYiIiEpcoQqkH374AQMGDFBqGzFiBGrWrIl69eqhUaNGePLkSZEESERERFTSClUgrVmzBk5OTtL7/fv3Y/369fjwww+xdOlS3LlzB7NmzSqyIImIiIhKUqG+i+3evXvw8PCQ3v/2229wc3PDypUrAQBxcXHYsGFD0URIREREVMIKdQZJCKH0PiwsDF26dJHeV6tWDXFxcW8XGREREZGOFKpAqlWrFnbs2AHg9eW1R48eKRVI//77L8qXL18kARIRERGVtEJdYvv8888xaNAgVKhQAampqfDw8EBAQIC0/NChQ2jQoEFRxUhERERUogpVIA0YMAB2dnbYs2cPypcvj48//hhGRq+HevHiBWxtbTF06NAiDZSIiIiopBT6OUidOnXCokWLMGPGDDg4OEjttra22L59O3r16lXgMUNCQtC4cWOUK1cOjo6O6NmzJ27evKnUJz09HUFBQbCzs4OVlRX69OmD+Ph4pT73799H165dYWFhAUdHR0yePBlZWVlKfQ4fPoyGDRvC1NQU7u7uCA0NLXC8RERE9G56qwdFPnz4EL/++iuWLFmCf//9FwCQnZ2NFy9eIDs7u8DjHTlyBEFBQTh16hTCw8Mhl8vh7++P1NRUqc+nn36Kv//+G7///juOHDmCR48eoXfv3tLy7OxsdO3aFZmZmTh58iTWr1+P0NBQTJ8+XeoTGxuLrl27ol27doiOjsakSZMwevRo7N+//y2yQURERO+KQl1iE0Lgs88+w7Jly5CVlQWZTAYvLy9UrlwZKSkpqFatGr7++mtMmjSpQOPu27dP6X1oaCgcHR0RFRWF1q1bIzExEWvXrsXmzZvRvn17AMC6devg4eGBU6dOoVmzZggLC8O1a9dw4MABODk5oUGDBpg9ezamTp2KmTNnwsTEBKtWrYKbmxsWLFgAAPDw8MDx48exaNEipblUREREVDYVqkCaN28elixZgqlTp6JDhw7o1KmTtMzGxga9e/fGtm3bClwgqUpMTATw+rIdAERFRUEul6Njx45Snzp16qBq1aqIjIxEs2bNEBkZCS8vL6UHWQYEBGDcuHG4evUqfHx8EBkZqTRGTp+84s3IyEBGRob0PikpCQAgl8shl8vV+ue05bZMbwjdfg2f/H/bl+cVhz7nrgSVimNJx5gjzZgj7TBPmpX2HBUk7kIVSD/99BOGDRuGOXPm4Pnz52rL69evj7179xZmaIlCocCkSZPQokUL1KtXD8DrB1CamJioPULAyclJeu5SXFycUnGUszxnWX59kpKS8OrVK5ibmystCwkJyfXJ4GFhYbCwsMhzH8LDw7XYU12po+sAAADhKbVyX7BnT8kGouf0+1jSD8yRZsyRdpgnzUprjtLS0rTuW6gC6cGDB2jevHmeyy0tLaWzLIUVFBSEK1eu4Pjx4281TlGYNm0agoODpfdJSUmoUqUK/P39YW1trdZfLpcjPDwcnTp1grGxcUmGqr1jC3W6ebkwQHhKLXSy+gfGMoV6h1bB6m1lUKk4lnSMOdKMOdIO86RZac9RQWqTQhVIjo6OePDgQZ7Lo6KiULVq1cIMDQAYP348du3ahaNHj6Jy5cpSu7OzMzIzM5GQkKB0Fik+Ph7Ozs5SnzNnziiNl3OX25t9VO98i4+Ph7W1tdrZIwAwNTWFqampWruxsXG+B4im5TqVW1GiA8YyRe4Fkr7mTUf0+ljSE8yRZsyRdpgnzUprjgoSc6EmovTu3RurVq3CnTt3pDaZTAbg9WWn0NBQfPDBBwUeVwiB8ePHY8eOHTh06BDc3NyUlvv6+sLY2BgHDx6U2m7evIn79+/Dz88PAODn54fLly/jyZMnUp/w8HBYW1vD09NT6vPmGDl9csYgIiKisq1QBdKsWbNQsWJFNGjQAMOGDYNMJsP333+Pli1bokuXLqhfvz7+85//FHjcoKAgbNy4EZs3b0a5cuUQFxeHuLg4vHr1CsDrCeCjRo1CcHAwIiIiEBUVhREjRsDPzw/NmjUDAPj7+8PT0xNDhw7FxYsXsX//fnz55ZcICgqSzgKNHTsWd+7cwZQpU3Djxg2sWLECv/32Gz799NPCpIOIiIjeMYUqkGxsbHDq1ClMmTIFDx8+hJmZGY4cOYKEhATMmDEDx44dy3fycl5WrlyJxMREtG3bFhUrVpReW7dulfosWrQI77//Pvr06YPWrVvD2dkZ27dvl5YbGhpi165dMDQ0hJ+fH4YMGYJhw4bh66+/lvq4ublh9+7dCA8Ph7e3NxYsWIA1a9bwFn99EhGi/CIiIipBhZqDBADm5ub48ssv8eWXXxZZMEIIjX3MzMywfPlyLF++PM8+rq6u2KPhLqi2bdviwoULBY6RiIiI3n26fRgOERERkR7S6gzSyJEjCzywTCbD2rVrC7weERERka5pVSAdOnRIuktNWwXtT0RERKQvtCqQ7t69W8xhEBEREekPzkEiIiIiUlHou9gA4MqVK9izZ490hqlatWro0qULvLy8iiI2IiIiIp0oVIGUkZGBjz76CBs2bIAQAgYGr09EKRQKTJs2DYMHD8aaNWtgYmJSpMESERERlYRCXWKbOnUqfvnlF4wbNw7Xr19Heno6MjIycP36dYwdOxYbN27ElClTijpWIiIiohJRqDNIGzduxNChQ7Fs2TKl9tq1a2P58uVISkrCxo0bsXjx4qKIkYiIiKhEFeoMklwul777LDfNmzdHVlZWoYMiIiIi0qVCFUgBAQHYv39/nsv37dsHf3//QgdFREREpEuFusQ2e/Zs9OvXD71790ZQUBDc3d0BALdu3cLy5ctx7949bN26FS9evFBaz9bW9u0jpoLjl70SEREVSKEKJA8PDwDA5cuX8ddffykty/nCWU9PT7X1srOzC7M5IiIiohJVqAJp+vTp/CoRIiIiemcVqkCaOXNmEYdBREREpD/4VSNEREREKgr9VSOpqanYtm0b7ty5g5cvX0pzj3LIZDIsWbLkrQMkIiIiKmmFKpAOHjyIDz74AAkJCXn2YYFEREREpVWhLrEFBQXB0tIS+/fvR0JCAhQKhdqLd6wRERFRaVWoM0j379/H999/j06dOhV1PEREREQ6V6gzSPXr10diYmJRx0JERESkFwpVIH3//fdYsWIFzp07V9TxEBEREelcoS6xtWnTBosXL4afnx88PDxQpUoVGBoaKvWRyWRqT9kmIiIiKg0KVSBt27YNQ4YMQXZ2Nv79918kJyer9eGTtomIiKi0KlSB9MUXX6B27drYtm0batWqVdQxEREREelUoeYgPXr0COPGjWNxRERERO+kQhVIjRs3xv3794s6FiIiIiK9UKgCaenSpdiyZQt+++23oo6HiIiISOcKNQdp8ODByMrKwsCBAzFmzBhUrlw517vYLl68WCRBEhEREZWkQhVItra2sLOzQ82aNYs6HiIiIiKdK1SBdPjw4SIOg4iIiEh/FGoOEhEREdG7rFBnkHLI5XLcuHEDiYmJUCgUastbt279NsMTERER6UShCiSFQoFp06ZhxYoVSEtLy7NfdnZ2oQMjUhIRot7WblrJx0FERGVCoS6xzZkzB/PmzcOQIUPwyy+/QAiB7777DqtWrUL9+vXh7e2N/fv3F3WsRERERCWiUAVSaGgo+vXrh5UrV6Jz584AAF9fX4wZMwanT5+GTCbDoUOHijRQIiIiopJSqALp33//Rfv27QEApqamAID09HQAgImJCYYMGYINGzYUUYhEREREJatQBZKdnR1SUlIAAFZWVrC2tsadO3eU+rx8+fLtoyMiIiLSgUJN0vbx8cHZs2el9+3atcPixYvh4+MDhUKBH374Ad7e3kUWJBEREVFJKtQZpA8//BAZGRnIyMgAAHz77bdISEhA69at0aZNGyQlJWHBggVFGigRERFRSSnUGaTu3buje/fu0ntPT0/cvn0bERERMDIyQvPmzWFra1tkQRIRERGVpLd6UOSbbGxs0LNnz6IajoiIiEhniqRAOnToEDZt2oTHjx+jTp06+OSTT+Dq6loUQxMRERGVOK3nIM2cORMWFhZ49uyZUvuaNWvQqVMnrFu3Dvv27cPixYvRuHFj3L17t8DBHD16FN26dYOLiwtkMhn+/PNPpeXDhw+HTCZTeuU8hynHixcvMHjwYFhbW6N8+fIYNWqUdMddjkuXLqFVq1YwMzNDlSpVMHfu3ALHSkRERO8urQukiIgIdOnSBfb29lLbq1evEBwcjPLlyyMiIgLJycnYsmULUlJS8M033xQ4mNTUVHh7e2P58uV59uncuTMeP34svX799Vel5YMHD8bVq1cRHh6OXbt24ejRo/jwww+l5UlJSfD394erqyuioqIwb948zJw5E6tXry5wvERERPRu0voS2z///AN/f3+ltvDwcKSkpCAkJARt2rQBAPTr1w8HDx5EWFhYgYPp0qULunTpkm8fU1NTODs757rs+vXr2LdvH86ePYtGjRoBAJYuXYr33nsP8+fPh4uLCzZt2oTMzEz8/PPPMDExQd26dREdHY2FCxcqFVJERERUdmldICUkJKBixYpKbREREZDJZHj//feV2n19fbF+/fqiiVDF4cOH4ejoiAoVKqB9+/b45ptvYGdnBwCIjIxE+fLlpeIIADp27AgDAwOcPn0avXr1QmRkJFq3bg0TExOpT0BAAL7//nu8fPkSFSpUUNvmm480AF6fhQIAuVwOuVyu1j+nLbdlOiEK9TSHYiX/X0zyt4lNX/JbjPTuWNJDzJFmzJF2mCfNSnuOChK31gVSpUqV1OYVHTlyBOXLl4enp6dafwsLC62D0Fbnzp3Ru3dvuLm54fbt2/jPf/6DLl26IDIyEoaGhoiLi4Ojo6PSOkZGRrC1tUVcXBwAIC4uDm5ubkp9nJycpGW5FUghISGYNWuWWntYWFi++xkeHl7gfSwedXQdQJ7CU2oVfuU9e4ouED2nP8eS/mKONGOOtMM8aVZac5SWlqZ1X60LpFatWuHnn3/Ghx9+iMqVKyMiIgLR0dEYOnQoZDKZUt9Lly6hSpUq2kespQEDBkj/9vLyQv369VGjRg0cPnwYHTp0KPLt5Zg2bRqCg4Ol90lJSahSpQr8/f1hbW2t1l8ulyM8PBydOnWCsbFxscWltWMLdR2BGrkwQHhKLXSy+gfGMkXhBmkVrLlPKad3x5IeYo40Y460wzxpVtpzlHMFSBtaF0gzZ87En3/+iRo1aqBy5cp48OABLCws8NVXXyn1y8rKwvbt29G3b1/tIy6k6tWrw97eHjExMejQoQOcnZ3x5MkTtXhevHghzVtydnZGfHy8Up+c93nNbTI1NZW+lPdNxsbG+R4gmpaXmMIWICXAWKYofIGkD7ktIXpzLOkx5kgz5kg7zJNmpTVHBYlZ6wkgrq6uOHfuHEaPHo1atWph5MiROHPmDNzd3ZX6nTp1Cr6+vhg0aJD2ERfSv//+i+fPn0tzo/z8/JCQkICoqCipz6FDh6BQKNC0aVOpz9GjR5WuQ4aHh6N27dq5Xl4jIiKisqdAD4qsUaNGvrfgA0DLli3RsmXLQgWTkpKCmJgY6X1sbCyio6Nha2sLW1tbzJo1C3369IGzszNu376NKVOmwN3dHQEBAQAADw8PdO7cGWPGjMGqVasgl8sxfvx4DBgwAC4uLgCAQYMGYdasWRg1ahSmTp2KK1euYMmSJVi0aFGhYiYiIqJ3j17d3nTu3Dn4+PjAx8cHABAcHAwfHx9Mnz4dhoaGuHTpErp3745atWph1KhR8PX1xbFjx5Quf23atAl16tRBhw4d8N5776Fly5ZKzziysbFBWFgYYmNj4evri88++wzTp0/nLf5EREQkKbLvYisKbdu2hRAiz+X79+/XOIatrS02b96cb5/69evj2LFjBY6PiIiIyga9OoNEREREpA9YIBERERGpYIFEREREpIIFEhEREZGKQhVIqampGDlyJG7cuFHU8RARERHpXKEKpPT0dKxfvx6PHj0C8PrR3e3bt8eFCxeKNDiifEWEKL+IiIiKiNa3+bu5ucHPzw/NmjWDu7s7hBDSd7DJ5XIcPnwYL1++LLZAiYiIiEqK1gXSxIkTcerUKcyfPx///vsvZDIZvvjiC3Tr1g3169cHALUvrSUiIiIqjbQukD799FPp31evXoWXlxfs7e2xdetWTJ8+HTKZDFOnTkXHjh3RvHlz+Pn5wc7OrliCJiIiIipOWs9BunXrlvTvnG+9/+yzz3D58mXcuHEDQgi4uLggIiICffv2haOjY9FHS0RERFQCtD6DVLt2bdjZ2aFJkyaoV68eZDIZsrOzAUA6UzRx4kS0b98e6enpOH/+fPFETERERFTMtC6QoqOjcfr0aZw5cwZ79+6FEALvv/8+GjdujKZNmyoVTGZmZmjevHmxBU1ERERUnLQukOrXr4/69etjzJgxePbsGRwdHfHFF18gJSUFBw8ehBACXbt2Rb169dC8eXO0aNECAwcOLM7YiYiIiIqF1gXSm3LuVmvTpg3at28vFUzTp09HVlYWTpw4gQ0bNrBAIiIiolKpUAWSoaEhXF1dYW5uDuD/C6bmzZujffv2AACFQlFEIRIRERGVrEIVSOXLl0dsbKz03tjYGG3atEGFChWkNgMDfs0bERERlU6FKpBUWVtbIyIioiiGIiIiItI5nuYhIiIiUsECiYiIiEgFCyQiIiIiFSyQiIiIiFSwQCIiIiJSwQKJiIiISAULJCIiIiIVLJCIiIiIVLBAIiIiIlLBAomIiIhIBQskIiIiIhUskIiIiIhUFMmX1RLphYgQ5fftpukmDiIiKvV4BomIiIhIBQskIiIiIhUskIiIiIhUsEAiIiIiUsECiYiIiEgFCyQiIiIiFSyQiIiIiFSwQCIiIiJSwQKJiIiISAULJCIiIiIVLJCIiIiIVLBAIiIiIlLBAomIiIhIhV4VSEePHkW3bt3g4uICmUyGP//8U2m5EALTp09HxYoVYW5ujo4dO+LWrVtKfV68eIHBgwfD2toa5cuXx6hRo5CSkqLU59KlS2jVqhXMzMxQpUoVzJ07t7h3jYiIiEoRvSqQUlNT4e3tjeXLl+e6fO7cufjhhx+watUqnD59GpaWlggICEB6errUZ/Dgwbh69SrCw8Oxa9cuHD16FB9++KG0PCkpCf7+/nB1dUVUVBTmzZuHmTNnYvXq1cW+fyUmIkT5RURERAVipOsA3tSlSxd06dIl12VCCCxevBhffvklevToAQD45Zdf4OTkhD///BMDBgzA9evXsW/fPpw9exaNGjUCACxduhTvvfce5s+fDxcXF2zatAmZmZn4+eefYWJigrp16yI6OhoLFy5UKqSIiIio7NKrM0j5iY2NRVxcHDp27Ci12djYoGnTpoiMjAQAREZGonz58lJxBAAdO3aEgYEBTp8+LfVp3bo1TExMpD4BAQG4efMmXr58WUJ7Q0RERPpMr84g5ScuLg4A4OTkpNTu5OQkLYuLi4Ojo6PSciMjI9ja2ir1cXNzUxsjZ1mFChXUtp2RkYGMjAzpfVJSEgBALpdDLper9c9py21ZiRD6X/fK/xejvDhj1VX+i5DOj6VSgDnSjDnSDvOkWWnPUUHiLjUFki6FhIRg1qxZau1hYWGwsLDIc73w8PDiDCsfdXS03YILT6lVfIPv2VN8Y5cw3R1LpQdzpBlzpB3mSbPSmqO0tDSt+5aaAsnZ2RkAEB8fj4oVK0rt8fHxaNCggdTnyZMnSutlZWXhxYsX0vrOzs6Ij49X6pPzPqePqmnTpiE4OFh6n5SUhCpVqsDf3x/W1tZq/eVyOcLDw9GpUycYGxsXcE+LwLGFJb/NApILA4Sn1EInq39gLFOU3IZbBWvuo0d0fiyVAsyRZsyRdpgnzUp7jnKuAGmj1BRIbm5ucHZ2xsGDB6WCKCkpCadPn8a4ceMAAH5+fkhISEBUVBR8fX0BAIcOHYJCoUDTpk2lPv/9738hl8ulH254eDhq166d6+U1ADA1NYWpqalau7Gxcb4HiKblxaYkC463ZCxTlGyBVAr/hwZ0eCyVIsyRZsyRdpgnzUprjgoSs15NVklJSUF0dDSio6MBvJ6YHR0djfv370Mmk2HSpEn45ptvsHPnTly+fBnDhg2Di4sLevbsCQDw8PBA586dMWbMGJw5cwYnTpzA+PHjMWDAALi4uAAABg0aBBMTE4waNQpXr17F1q1bsWTJEqUzRERERFS26dUZpHPnzqFdu3bS+5yiJTAwEKGhoZgyZQpSU1Px4YcfIiEhAS1btsS+fftgZmYmrbNp0yaMHz8eHTp0gIGBAfr06YMffvhBWm5jY4OwsDAEBQXB19cX9vb2mD59Om/xJyIiIoleFUht27aFECLP5TKZDF9//TW+/vrrPPvY2tpi8+bN+W6nfv36OHbsWKHjJCIionebXl1iIyIiItIHLJCIiIiIVOjVJTaiYqf63XTtpukmDiIi0ms8g0RERESkggUSERERkQoWSEREREQqWCARERERqWCBRERERKSCBRIRERGRChZIRERERCpYIBERERGpYIFEREREpIIFEhEREZEKFkhEREREKlggEREREalggURERESkggUSERERkQoWSEREREQqWCARERERqWCBRERERKSCBRIRERGRChZIRERERCpYIBERERGpMNJ1AEQ6FRGi3tZuWsnHQUREeoVnkIiIiIhUsEAiIiIiUsECiYiIiEgFCyQiIiIiFSyQiIiIiFSwQCIiIiJSwdv8iVSp3vrP2/6JiMocnkEiIiIiUsEzSESFwbNMRETvNJ5BIiIiIlLBAomIiIhIBQskIiIiIhUskIiIiIhUsEAiIiIiUsECiYiIiEgFb/MnKi58FAARUanFAomoKKgWQ0REVKrxEhsRERGRCp5BItKEZ4eIiMqcUnUGaebMmZDJZEqvOnXqSMvT09MRFBQEOzs7WFlZoU+fPoiPj1ca4/79++jatSssLCzg6OiIyZMnIysrq6R3hYiIiPRYqTuDVLduXRw4cEB6b2T0/7vw6aefYvfu3fj9999hY2OD8ePHo3fv3jhx4gQAIDs7G127doWzszNOnjyJx48fY9iwYTA2NsacOXNKfF+IiIhIP5W6AsnIyAjOzs5q7YmJiVi7di02b96M9u3bAwDWrVsHDw8PnDp1Cs2aNUNYWBiuXbuGAwcOwMnJCQ0aNMDs2bMxdepUzJw5EyYmJiW9O0RERKSHStUlNgC4desWXFxcUL16dQwePBj3798HAERFRUEul6Njx45S3zp16qBq1aqIjIwEAERGRsLLywtOTk5Sn4CAACQlJeHq1asluyNERESkt0rVGaSmTZsiNDQUtWvXxuPHjzFr1iy0atUKV65cQVxcHExMTFC+fHmldZycnBAXFwcAiIuLUyqOcpbnLMtLRkYGMjIypPdJSUkAALlcDrlcrtY/py23ZSVC6H/dK/9fjPJSEGuRKcTxoPNjqRRgjjRjjrTDPGlW2nNUkLhLVYHUpUsX6d/169dH06ZN4erqit9++w3m5ubFtt2QkBDMmjVLrT0sLAwWFhZ5rhceHl5sMeWvjuYueiI8pZauQyg5e/YUelXdHUulB3OkGXOkHeZJs9Kao7S0NK37lqoCSVX58uVRq1YtxMTEoFOnTsjMzERCQoLSWaT4+HhpzpKzszPOnDmjNEbOXW65zWvKMW3aNAQHB0vvk5KSUKVKFfj7+8Pa2lqtv1wuR3h4ODp16gRjY+O32cXCObaw5LdZQHJhgPCUWuhk9Q+MZQpdh1MyWgVr7qNC58dSKcAcacYcaYd50qy05yjnCpA2SnWBlJKSgtu3b2Po0KHw9fWFsbExDh48iD59+gAAbt68ifv378PPzw8A4Ofnh2+//RZPnjyBo6MjgNdVsLW1NTw9PfPcjqmpKUxNTdXajY2N8z1ANC0vNqWo4DCWKcpOgfQWx4LOjqVShDnSjDnSDvOkWWnNUUFiLlUF0ueff45u3brB1dUVjx49wowZM2BoaIiBAwfCxsYGo0aNQnBwMGxtbWFtbY0JEybAz88PzZo1AwD4+/vD09MTQ4cOxdy5cxEXF4cvv/wSQUFBuRZAREREVDaVqgLp33//xcCBA/H8+XM4ODigZcuWOHXqFBwcHAAAixYtgoGBAfr06YOMjAwEBARgxYoV0vqGhobYtWsXxo0bBz8/P1haWiIwMBBff/21rnaJiIiI9FCpKpC2bNmS73IzMzMsX74cy5cvz7OPq6sr9rzFZFkiIiJ695Whe6yJiIiItMMCiYiIiEgFCyQiIiIiFaVqDhJRqRYRovy+3TTdxEFERBqxQCLSFdWCCWDRRESkJ3iJjYiIiEgFCyQiIiIiFSyQiIiIiFRwDlJpl9s8FiIiInorPINEREREpIIFEhEREZEKFkhEREREKlggEREREalggURERESkggUSERERkQre5l/GRd55DgDwq26n1qbaTkREVFawQCLSZ8cWAqjz+r8yxes2fl8bEVGx4yU2IiIiIhUskIiIiIhUsEAiIiIiUsE5SET6RO279fg3DBGRLvDTl4iIiEgFzyBRvt685T+HPt36n9tjCoiIiN4WCySi0kb1Mhxv+yciKnIskMqg3M4K5damzfq5nbkpygdN8gwRERHpAgskotJObWI3eFaJiOgtsUB6B+nTV4VoOgN05u4LGIhspbaijJlnoIiIqDB4FxsRERGRCp5BKiMKMseoJLavkBkCPKlTdnGiORHpOZ5BIiIiIlLBM0jvOF2fOSoq78p+lEm5TSInItJzLJCIKHfa3B3HO+iI6B3FAonoXaTLOT48Y0RE7wAWSKWcvtzGzktgeq6oCiYWP0RURnCSNhEREZEKnkF6R7xLZ3CKY1/06eGZekHf5g7xtn8i0jMskIjoNV4+IyKSsEAqJRaF/5Nre7MSjkNf8QwREREVJRZIpUyz+6t1HQJR8dO3S4CF8S7sA1EZxgJJD+V1tkgfvUtzn4iIiHKwQCIiKgrazOHiZHSiUoMFEhEKP4cptzNonANVTMpKcVFW9pNIz7FAIqJ3lzZndfTp8QZFtQ6LKqK3VqYLpOXLl2PevHmIi4uDt7c3li5diiZNmug6LHpLBZkXlVvforwjjnfXFaOcQkEYAKgDHFsIyBSFH+dNmgoMPhKB6J1XZgukrVu3Ijg4GKtWrULTpk2xePFiBAQE4ObNm3B0dNR1eESkS6W9AFKNP6eIzK8PwDNPRG8oswXSwoULMWbMGIwYMQIAsGrVKuzevRs///wzvvjiCx1HR0T0P0VZrBX2LNu7hIUhaalMFkiZmZmIiorCtGn//z+FgYEBOnbsiMjISB1GRiWhsJfgci6RFfejDd4cv5Gbg1r7m5fqivsSnqbxC7N9XnZ8eyX2JdVlZb5TYS7Xvgv7TfkqkwXSs2fPkJ2dDScnJ6V2Jycn3LhxQ61/RkYGMjIypPeJiYkAgBcvXkAul6v1l8vlSEtLw/Pnz2FsbFzg+DJSEvNclpyeVeDx9JFCJpCWlobk9CwYiGxdh6OV5ymZADT/DHL6qfZ9sz0/quukpaXhuSxTan/b8QtC0/hFsX9vSy4MpBwZl5GzI7kdC/nROkd/zyp4MIVZRxvNx2vuc3KZ5nVU++SjQMfS87L5DLi3/f2ma8nJyQAAIYTGvmWyQCqokJAQzJql/iHg5uamg2iIiMqCmSW0TmGV5LaoqCUnJ8PGxibfPmWyQLK3t4ehoSHi4+OV2uPj4+Hs7KzWf9q0aQgODpbeKxQKvHjxAnZ2dpDJZGr9k5KSUKVKFTx48ADW1tZFvwPvAOZIO8yTZsyRZsyRdpgnzUp7joQQSE5OhouLi8a+ZbJAMjExga+vLw4ePIiePXsCeF30HDx4EOPHq5+iNTU1hampqVJb+fLlNW7H2tq6VB5AJYk50g7zpBlzpBlzpB3mSbPSnCNNZ45ylMkCCQCCg4MRGBiIRo0aoUmTJli8eDFSU1Olu9qIiIio7CqzBVL//v3x9OlTTJ8+HXFxcWjQoAH27dunNnGbiIiIyp4yWyABwPjx43O9pPa2TE1NMWPGDLXLcvT/mCPtME+aMUeaMUfaYZ40K0s5kglt7nUjIiIiKkMMdB0AERERkb5hgURERESkggUSERERkQoWSEREREQqWCAVseXLl6NatWowMzND06ZNcebMGV2HpFNHjx5Ft27d4OLiAplMhj///FNpuRAC06dPR8WKFWFubo6OHTvi1q1buglWR0JCQtC4cWOUK1cOjo6O6NmzJ27evKnUJz09HUFBQbCzs4OVlRX69Omj9iT4d9nKlStRv3596eF0fn5+2Lt3r7S8rOcnN9999x1kMhkmTZoktTFPwMyZMyGTyZRederUkZYzR689fPgQQ4YMgZ2dHczNzeHl5YVz585Jy8vCZzcLpCK0detWBAcHY8aMGTh//jy8vb0REBCAJ0+e6Do0nUlNTYW3tzeWL1+e6/K5c+fihx9+wKpVq3D69GlYWloiICAA6enpJRyp7hw5cgRBQUE4deoUwsPDIZfL4e/vj9TUVKnPp59+ir///hu///47jhw5gkePHqF37946jLpkVa5cGd999x2ioqJw7tw5tG/fHj169MDVq1cBMD+qzp49ix9//BH169dXameeXqtbty4eP34svY4fPy4tY46Aly9fokWLFjA2NsbevXtx7do1LFiwABUqVJD6lInPbkFFpkmTJiIoKEh6n52dLVxcXERISIgOo9IfAMSOHTuk9wqFQjg7O4t58+ZJbQkJCcLU1FT8+uuvOohQPzx58kQAEEeOHBFCvM6JsbGx+P3336U+169fFwBEZGSkrsLUuQoVKog1a9YwPyqSk5NFzZo1RXh4uGjTpo345JNPhBA8jnLMmDFDeHt757qMOXpt6tSpomXLlnkuLyuf3TyDVEQyMzMRFRWFjh07Sm0GBgbo2LEjIiMjdRiZ/oqNjUVcXJxSzmxsbNC0adMynbPExEQAgK2tLQAgKioKcrlcKU916tRB1apVy2SesrOzsWXLFqSmpsLPz4/5UREUFISuXbsq5QPgcfSmW7duwcXFBdWrV8fgwYNx//59AMxRjp07d6JRo0b44IMP4OjoCB8fH/z000/S8rLy2c0CqYg8e/YM2dnZal9V4uTkhLi4OB1Fpd9y8sKc/T+FQoFJkyahRYsWqFevHoDXeTIxMVH7guSylqfLly/DysoKpqamGDt2LHbs2AFPT0/m5w1btmzB+fPnERISoraMeXqtadOmCA0Nxb59+7By5UrExsaiVatWSE5OZo7+586dO1i5ciVq1qyJ/fv3Y9y4cZg4cSLWr18PoOx8dpfprxoh0jdBQUG4cuWK0pwIeq127dqIjo5GYmIi/vjjDwQGBuLIkSO6DktvPHjwAJ988gnCw8NhZmam63D0VpcuXaR/169fH02bNoWrqyt+++03mJub6zAy/aFQKNCoUSPMmTMHAODj44MrV65g1apVCAwM1HF0JYdnkIqIvb09DA0N1e52iI+Ph7Ozs46i0m85eWHOXhs/fjx27dqFiIgIVK5cWWp3dnZGZmYmEhISlPqXtTyZmJjA3d0dvr6+CAkJgbe3N5YsWcL8/E9UVBSePHmChg0bwsjICEZGRjhy5Ah++OEHGBkZwcnJiXnKRfny5VGrVi3ExMTwWPqfihUrwtPTU6nNw8NDuhRZVj67WSAVERMTE/j6+uLgwYNSm0KhwMGDB+Hn56fDyPSXm5sbnJ2dlXKWlJSE06dPl6mcCSEwfvx47NixA4cOHYKbm5vScl9fXxgbGyvl6ebNm7h//36ZypMqhUKBjIwM5ud/OnTogMuXLyM6Olp6NWrUCIMHD5b+zTypS0lJwe3bt1GxYkUeS//TokULtUeN/PPPP3B1dQVQhj67dT1L/F2yZcsWYWpqKkJDQ8W1a9fEhx9+KMqXLy/i4uJ0HZrOJCcniwsXLogLFy4IAGLhwoXiwoUL4t69e0IIIb777jtRvnx58ddff4lLly6JHj16CDc3N/Hq1SsdR15yxo0bJ2xsbMThw4fF48ePpVdaWprUZ+zYsaJq1ari0KFD4ty5c8LPz0/4+fnpMOqS9cUXX4gjR46I2NhYcenSJfHFF18ImUwmwsLChBDMT17evItNCOZJCCE+++wzcfjwYREbGytOnDghOnbsKOzt7cWTJ0+EEMyREEKcOXNGGBkZiW+//VbcunVLbNq0SVhYWIiNGzdKfcrCZzcLpCK2dOlSUbVqVWFiYiKaNGkiTp06peuQdCoiIkIAUHsFBgYKIV7fLvrVV18JJycnYWpqKjp06CBu3ryp26BLWG75ASDWrVsn9Xn16pX4+OOPRYUKFYSFhYXo1auXePz4se6CLmEjR44Urq6uwsTERDg4OIgOHTpIxZEQzE9eVAsk5kmI/v37i4oVKwoTExNRqVIl0b9/fxETEyMtZ45e+/vvv0W9evWEqampqFOnjli9erXS8rLw2S0TQgjdnLsiIiIi0k+cg0RERESkggUSERERkQoWSEREREQqWCARERERqWCBRERERKSCBRIRERGRChZIRERERCpYIBFRqSCTyTBz5swiHTMlJQWOjo7YtGmTxr7Dhw9HtWrVinT7urRv3z5YWVnh6dOnug6FSC+xQCKiAlmxYgVkMhmaNm2q61De2pIlS1CuXDkMGDBA16GUuM6dO8Pd3R0hISG6DoVIL7FAIqIC2bRpE6pVq4YzZ84gJiZG1+EUmlwux5IlSzB69GgYGhrqOhyd+Oijj/Djjz8iOTlZ16EQ6R0WSESktdjYWJw8eRILFy6Eg4ODVpem9NWuXbvw9OlT9OvXT9eh5Cs1NbXYxu7Tpw8yMjLw+++/F9s2iEorFkhEpLVNmzahQoUK6Nq1K/r27ZtrgXT37l3IZDLMnz8fq1evRo0aNWBqaorGjRvj7Nmzav1///13eHp6wszMDPXq1cOOHTu0nu/z8OFDjBw5Ek5OTjA1NUXdunXx888/a7Uvf/75J6pVq4YaNWrkuqxevXpKMeVGoVBg8eLFqFu3LszMzODk5ISPPvoIL1++VOs3c+ZMuLi4wMLCAu3atcO1a9dQrVo1DB8+XOoXGhoKmUyGI0eO4OOPP4ajoyMqV64sLd+7dy9atWoFS0tLlCtXDl27dsXVq1fV4rpx4wb69u0LW1tbmJmZoVGjRti5c6daP0dHR9SvXx9//fWXVjkjKkuMdB0AEZUemzZtQu/evWFiYoKBAwdi5cqVOHv2LBo3bqzWd/PmzUhOTsZHH30EmUyGuXPnonfv3rhz5w6MjY0BALt370b//v3h5eWFkJAQvHz5EqNGjUKlSpU0xhIfH49mzZpBJpNh/PjxcHBwwN69ezFq1CgkJSVh0qRJ+a5/8uRJNGzYUK09LCwMffr0gaenJ0JCQvD8+XOMGDFCqVDJ8dFHHyE0NBQjRozAxIkTERsbi2XLluHChQs4ceKEtJ/Tpk3D3Llz0a1bNwQEBODixYsICAhAenp6rrF9/PHHcHBwwPTp06UzSBs2bEBgYCACAgLw/fffIy0tDStXrkTLli1x4cIFqaC8evUqWrRogUqVKuGLL76ApaUlfvvtN/Ts2RPbtm1Dr169lLbl6+uLP//8U0O2icogQUSkhXPnzgkAIjw8XAghhEKhEJUrVxaffPKJUr/Y2FgBQNjZ2YkXL15I7X/99ZcAIP7++2+pzcvLS1SuXFkkJydLbYcPHxYAhKurq9K4AMSMGTOk96NGjRIVK1YUz549U+o3YMAAYWNjI9LS0vLcF7lcLmQymfjss8/UljVo0EBUrFhRJCQkSG1hYWFqMR07dkwAEJs2bVJaf9++fUrtcXFxwsjISPTs2VOp38yZMwUAERgYKLWtW7dOABAtW7YUWVlZUntycrIoX768GDNmjNIYcXFxwsbGRqm9Q4cOwsvLS6Snp0ttCoVCNG/eXNSsWVNtf+fMmSMAiPj4+NxSRVRm8RIbEWll06ZNcHJyQrt27QC8vu2+f//+2LJlC7Kzs9X69+/fHxUqVJDet2rVCgBw584dAMCjR49w+fJlDBs2DFZWVlK/Nm3awMvLK99YhBDYtm0bunXrBiEEnj17Jr0CAgKQmJiI8+fP57n+ixcvIIRQig8AHj9+jOjoaAQGBsLGxkZq79SpEzw9PZX6/v7777CxsUGnTp2Utu/r6wsrKytEREQAAA4ePIisrCx8/PHHSutPmDAhz/jGjBmjNHE8PDwcCQkJGDhwoNK2DA0N0bRpU2lbL168wKFDh9CvXz8kJydL/Z4/f46AgADcunULDx8+VNpWTg6ePXuWZzxEZREvsRGRRtnZ2diyZQvatWuH2NhYqb1p06ZYsGABDh48CH9/f6V1qlatqvQ+5xdxzvyce/fuAQDc3d3Vtufu7p5vgfP06VMkJCRg9erVWL16da59njx5onG/hBBK73Niqlmzplrf2rVrK8V069YtJCYmwtHRMd/t57Wftra2agVaDjc3N6X3t27dAgC0b98+1/7W1tYAgJiYGAgh8NVXX+Grr77KM643L2Hm5EAmk+Xan6isYoFERBodOnQIjx8/xpYtW7Blyxa15Zs2bVIrkPK6dV61KCkMhUIBABgyZAgCAwNz7VO/fv0817e1tYVMJlObTF3QGPJ7yKSDg0OhxzY3N1fbFvB6HpKzs7NafyMjI6V+n3/+OQICAnIdW7VQy8mBvb19oeMlehexQCIijTZt2gRHR0csX75cbdn27duxY8cOrFq1Su0Xe35cXV0BINdnKWl6vpKDgwPKlSuH7OxsdOzYUett5jAyMkKNGjWUzoa9GVPOGZs33bx5U+l9jRo1cODAAbRo0SLf/X5zP988M/T8+XOtC7ScO+0cHR3z3d/q1asDAIyNjbXOS2xsLOzt7d+qoCN6F3EOEhHl69WrV9i+fTvef/999O3bV+01fvx4JCcn53obeX5cXFxQr149/PLLL0hJSZHajxw5gsuXL+e7rqGhIfr06YNt27bhypUrasu1+foMPz8/nDt3TqmtYsWKaNCgAdavX4/ExESpPTw8HNeuXVPq269fP2RnZ2P27NlqY2dlZSEhIQEA0KFDBxgZGWHlypVKfZYtW6YxxhwBAQGwtrbGnDlzIJfL1Zbn7K+joyPatm2LH3/8EY8fP86z35uioqLg5+endSxEZQXPIBFRvnbu3Ink5GR079491+XNmjWTHhrZv3//Ao09Z84c9OjRAy1atMCIESPw8uVLLFu2DPXq1VMqmnLz3XffISIiAk2bNsWYMWPg6emJFy9e4Pz58zhw4ABevHiR7/o9evTAhg0b8M8//6BWrVpSe0hICLp27YqWLVti5MiRePHiBZYuXYq6desqxdSmTRt89NFHCAkJQXR0NPz9/WFsbIxbt27h999/x5IlS9C3b184OTnhk08+wYIFC9C9e3d07twZFy9exN69e2Fvb6/V3B9ra2usXLkSQ4cORcOGDTFgwAA4ODjg/v372L17N1q0aCEVXMuXL0fLli3h5eWFMWPGoHr16oiPj0dkZCT+/fdfXLx4URr3yZMnuHTpEoKCgjTGQFTm6PAOOiIqBbp16ybMzMxEampqnn2GDx8ujI2NxbNnz6Tb/OfNm6fWDyq36gshxJYtW0SdOnWEqampqFevnti5c6fo06ePqFOnjsZ14+PjRVBQkKhSpYowNjYWzs7OokOHDmL16tUa9ysjI0PY29uL2bNnqy3btm2b8PDwEKampsLT01Ns375dBAYGqj16QAghVq9eLXx9fYW5ubkoV66c8PLyElOmTBGPHj2S+mRlZYmvvvpKODs7C3Nzc9G+fXtx/fp1YWdnJ8aOHSv1y7nN/+zZs7nGHBERIQICAoSNjY0wMzMTNWrUEMOHDxfnzp1T6nf79m0xbNgw4ezsLIyNjUWlSpXE+++/L/744w+lfitXrhQWFhYiKSlJY76IyhqZEEUwY5KIqAg1aNAADg4OCA8PL9btzJ49G+vWrcOtW7dK/PvYEhISUKFCBXzzzTf473//W6LbzuHj44O2bdti0aJFOtk+kT7jHCQi0hm5XI6srCyltsOHD+PixYto27ZtsW//008/RUpKSq535hWlV69eqbUtXrwYAEpkP3Ozb98+3Lp1C9OmTdPJ9on0Hc8gEZHO3L17Fx07dsSQIUPg4uKCGzduYNWqVbCxscGVK1dgZ2en6xCLRGhoKEJDQ/Hee+/BysoKx48fx6+//gp/f3/s379f1+ERUS44SZuIdKZChQrw9fXFmjVr8PTpU1haWqJr16747rvv3pniCHj9TCYjIyPMnTsXSUlJ0sTtb775RtehEVEeeAaJiIiISAXnIBERERGpYIFEREREpIIFEhEREZEKFkhEREREKlggEREREalggURERESkggUSERERkQoWSEREREQqWCARERERqfg/o9v3N7w323cAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "angle_vals = []\n",
+    "\n",
+    "def get_posneg_sim(sims, poses, negs, combined=False):\n",
+    "    rad_ = 180 / math.pi\n",
+    "    pos_vals = []\n",
+    "    neg_vals = []\n",
+    "    combined_vals = []\n",
+    "    for sim, pos_, neg_ in zip(sims, poses, negs):\n",
+    "        #print(sim.shape, pos_.shape, neg_.shape)\n",
+    "        # make diagonals to 0\n",
+    "        pos_ = pos_ - np.eye(pos_.shape[0])\n",
+    "        neg_ = neg_ - np.eye(neg_.shape[0])\n",
+    "        sim = np.arccos(sim)\n",
+    "        # append, except for values with <0.05 \n",
+    "        pos_vals.extend(sim[pos_ == 1].flatten())\n",
+    "        neg_vals.extend(sim[neg_ == 1].flatten())\n",
+    "        if combined :\n",
+    "            combined_vals.extend(sim[pos_ == 1].flatten())\n",
+    "            combined_vals.extend(sim[neg_ == 1].flatten())\n",
+    "    \n",
+    "    if combined : \n",
+    "        return np.array(pos_vals) * rad_, np.array(neg_vals) * rad_, np.array(combined_vals) * rad_\n",
+    "    else : \n",
+    "        return np.array(pos_vals) * rad_, np.array(neg_vals) * rad_\n",
+    "\n",
+    "# pos_vals_orig, neg_vals_orig = get_posneg_sim(sims_orig, positive_mask_orig, negative_mask_orig)\n",
+    "# pos_vals_new, neg_vals_new = get_posneg_sim(sims_new, positive_mask_new, negative_mask_new)\n",
+    "\n",
+    "pos_vals_orig, neg_vals_orig, combined_vals_orig = get_posneg_sim(sims_orig, positive_mask_orig, negative_mask_orig, combined=True)\n",
+    "pos_vals_new, neg_vals_new, combined_vals_new = get_posneg_sim(sims_new, positive_mask_new, negative_mask_new, combined=True)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "plt.hist(pos_vals_orig.repeat(10), bins=100, label=f'pos_orig, $\\mu$ = {np.mean(pos_vals_orig):.2f}', alpha=0.5)\n",
+    "plt.hist(neg_vals_orig, bins=100, label=f'neg_orig, $\\mu$ = {np.mean(neg_vals_orig):.2f}', alpha=0.5)\n",
+    "plt.xlabel('Angle (degree)', fontsize=12)\n",
+    "plt.ylabel('# Samples', fontsize=12)\n",
+    "plt.title('Pairwise Angular Distribution of Samples, CRIS')\n",
+    "plt.grid()\n",
+    "plt.legend()\n",
+    "plt.show()\n",
+    "\n",
+    "plt.hist(90 - pos_vals_new.repeat(10), bins=100, label=f'pos_ACE, $\\mu$ = {90 - np.mean(pos_vals_new):.2f}', alpha=0.5)\n",
+    "plt.hist(90 - neg_vals_new, bins=100, label=f'neg_ACE, $\\mu$ = {90 - np.mean(neg_vals_new):.2f}', alpha=0.5)\n",
+    "plt.xlabel('Angle (degree)', fontsize=12)\n",
+    "plt.ylabel('# Samples', fontsize=12)\n",
+    "plt.title('Pairwise Angular Distribution of Samples, CRIS+ACE')\n",
+    "plt.grid()\n",
+    "plt.legend()\n",
+    "plt.show()\n",
+    "\n",
+    "# for sim in sims:\n",
+    "#     # get off-diagonal elements\n",
+    "#     sim = sim\n",
+    "#     # arccos\n",
+    "#     sim = np.arccos(sim)\n",
+    "#     # append, except for values with <0.05 \n",
+    "#     sim = sim[sim > 0.05]\n",
+    "#     angle_vals.extend(sim.flatten())\n",
+    "\n",
+    "# angle_vals_new = []\n",
+    "# for sim in sims_new:\n",
+    "#     # get off-diagonal elements\n",
+    "#     sim = sim\n",
+    "#     # arccos\n",
+    "#     sim = np.arccos(sim)\n",
+    "#     # append, except for values with <0.05 \n",
+    "#     sim = sim[sim > 0.05]\n",
+    "#     angle_vals_new.extend(sim.flatten())\n",
+    "\n",
+    "# plt.hist(angle_vals, bins=100, label='original', alpha=0.5)\n",
+    "# plt.hist(angle_vals_new, bins=100, label='new', alpha=0.5)\n",
+    "# plt.legend()\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cris_new",
+   "language": "python",
+   "name": "cris_new"
+  },
+  "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.9.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}