shopee-pytorch-siamese-contrastive-img.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.9","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"!ls ../input/shopee-generate-data-for-triplet-loss/train_triplets_imgs.csv\n# !ls ../input/shopee-efficientnetb3-128-siamese-triplet/efficientnet_b3_128_fold0_min_val_loss.pth","metadata":{"trusted":true},"execution_count":85,"outputs":[{"name":"stdout","text":"../input/shopee-generate-data-for-triplet-loss/train_triplets_imgs.csv\n","output_type":"stream"}]},{"cell_type":"code","source":"import sys\nsys.path.append ('/kaggle/input/timm-pytorch-image-models/pytorch-image-models-master')\n\nimport os\nimport gc\nimport time\nimport math\nimport random\nimport datetime\nimport pandas as pd\nimport numpy as np\nimport seaborn as sns\n\nimport torch\nimport torch.nn as nn\nfrom   torch.nn import init\nfrom   torch.nn import CrossEntropyLoss, MSELoss\nfrom   torch.nn.modules.loss import _WeightedLoss\nimport torch.nn.functional as F\nfrom   torch.nn import Parameter\nfrom   torch.utils.data import Dataset, DataLoader, RandomSampler, SequentialSampler\nfrom   transformers import AdamW, get_cosine_schedule_with_warmup\nfrom   torch.cuda.amp import autocast, GradScaler\n\nfrom   fastai.losses import LabelSmoothingCrossEntropy\n\n# from warmup_scheduler import GradualWarmupScheduler\nfrom   sklearn import preprocessing\nfrom   sklearn.metrics import accuracy_score\nfrom   sklearn.model_selection import StratifiedKFold, GroupKFold\nfrom   sklearn.metrics import accuracy_score, precision_recall_fscore_support, matthews_corrcoef, roc_auc_score\nfrom   sklearn.metrics import mean_squared_error, mean_absolute_error, explained_variance_score, r2_score\n\nimport timm\nimport albumentations as A\nfrom   albumentations import *\nfrom   albumentations.pytorch import ToTensorV2\nfrom   albumentations.core.transforms_interface import DualTransform\nfrom   albumentations.augmentations import functional as AF\nimport cv2\n\nfrom   tqdm import tqdm\nfrom   pprint import pprint\nfrom   functools import partial\nimport matplotlib.pyplot as plt\n# from GPUtil import showUtilization as gpu_usage\nfrom   numba import cuda\nimport warnings\nwarnings.filterwarnings (\"ignore\")","metadata":{"papermill":{"duration":6.115871,"end_time":"2021-03-29T06:13:02.423924","exception":false,"start_time":"2021-03-29T06:12:56.308053","status":"completed"},"tags":[],"trusted":true},"execution_count":86,"outputs":[]},{"cell_type":"code","source":"class CFG:\n    device       = torch.device ('cuda' if torch.cuda.is_available () else 'cpu')\n    num_workers  = 8\n    use_fc       = False    \n    model_name   = 'efficientnet_b3'      # ['deit_base_patch16_224', 'vit_base_patch16_384', 'resnext50_32x4d', 'tf_efficientnet_b7_ns']\n    n_classes    = 512                    # not 11014 since its embedding size\n    margin       = 1.0\n    fc_dim       = 0\n    dropout      = 0.2\n    ls_eps       = 0.0\n    pretrained   = True        \n    size         = 128                     # [64, 128, 224, 384, 512, 640, 720]\n    isTrain      = True\n    isFreeze     = True\n    lr           = 1e-5\n    epochs       = 3\n    warmup_steps = 0.50                    # if float: these many epochs are with frozen model at the beginning, if int = actual steps\n    eval_steps   = 0                       # if float: these many epochs are with frozen model at the beginning, if int = actual steps \n    lr_num_cycles= 0.5\n    epochsNx     = 1\n    # criterion  = 'dice_bce'              # ['dice_bce', CrossEntropyLoss', 'BCEWithLogitsLoss', 'SmoothBCEwithLogits']\n    weight_decay = 1e-6\n    max_grad_norm= 1000.0\n    seed         = 42\n    n_fold       = 5\n    train_fold   = [0]                      # [0, 1, 2, 3, 4]\n    print_every  = 100\n    adam_epsilon = 1e-8\n    train_batch_size = 12\n    eval_batch_size  = 12    \n    model_infer_path_prefix = \".\"\n    model_train_path_prefix = \".\"\n    img_triplets_csv = \"../input/shopee-generate-data-for-triplet-loss/train_triplets_imgs.csv\"\n    train_path       = '../input/shopee-product-matching/train_images'\n    # train_csv        = '../input/vinbigdata-chest-xray-abnormalities-detection/train.csv'\n    # test_path        = '../input/vinbigdata-chest-xray-resized-png-1024x1024/test'\n    output_dir       = './results'        # output directory    \n    max_steps        = 0\n    MODEL            = None","metadata":{"papermill":{"duration":0.051644,"end_time":"2021-03-29T06:13:02.512003","exception":false,"start_time":"2021-03-29T06:13:02.460359","status":"completed"},"tags":[],"trusted":true},"execution_count":87,"outputs":[]},{"cell_type":"code","source":"def init_logger (log_file=CFG.output_dir+'train.log'):\n    \n    from logging import getLogger, INFO, FileHandler,  Formatter,  StreamHandler\n    logger = getLogger (__name__)\n    logger.setLevel (INFO)\n    handler1 = StreamHandler ()\n    handler1.setFormatter (Formatter (\"%(message)s\"))\n    handler2 = FileHandler (filename=log_file)\n    handler2.setFormatter (Formatter (\"%(message)s\"))\n    logger.addHandler (handler1)\n    logger.addHandler (handler2)\n    return logger","metadata":{"papermill":{"duration":0.046379,"end_time":"2021-03-29T06:13:02.594867","exception":false,"start_time":"2021-03-29T06:13:02.548488","status":"completed"},"tags":[],"trusted":true},"execution_count":88,"outputs":[]},{"cell_type":"code","source":"def seed_everything (seed):\n    \n    random.seed (seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    np.random.seed (seed)\n    torch.manual_seed (seed)\n    torch.cuda.manual_seed (seed)\n    torch.backends.cudnn.deterministic = True\n    torch.backends.cudnn.benchmark = True\n    return","metadata":{"papermill":{"duration":0.047319,"end_time":"2021-03-29T06:13:02.67797","exception":false,"start_time":"2021-03-29T06:13:02.630651","status":"completed"},"tags":[],"trusted":true},"execution_count":89,"outputs":[]},{"cell_type":"markdown","source":"# Image Augmentations","metadata":{}},{"cell_type":"code","source":"def get_transforms (data='train'):\n    \n    light_transforms = A.Compose ([\n        A.Resize (CFG.size, CFG.size),\n        # A.HorizontalFlip (p=0.5),\n        A.OneOf([\n            A.CLAHE (clip_limit=(1,4), p=1),\n            A.HueSaturationValue (hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=1),\n            A.RandomBrightnessContrast (brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=1),\n            A.augmentations.transforms.RGBShift (r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, always_apply=False, p=0.5),\n        ], p=0.5),\n        # A.augmentations.transforms.ChannelDropout (channel_drop_range=(1, 1), fill_value=0, always_apply=False, p=0.5),\n        A.augmentations.transforms.GridDistortion (num_steps=5, distort_limit=0.3, interpolation=1, border_mode=4, value=None, mask_value=None, always_apply=False, p=0.5),\n        A.CoarseDropout(p=0.5),\n        # A.Cutout (max_h_size=int(CFG.size * 0.2), max_w_size=int(CFG.size * 0.2), num_holes=2, p=0.75),\n        A.Normalize (),\n        ToTensorV2 (p=1.0),\n    ])\n    \n    valid_transforms = A.Compose ([\n        A.Resize (CFG.size, CFG.size),\n        A.Normalize (),\n        ToTensorV2 (p=1.0),\n    ])\n    \n    if 'train' in data:\n        return light_transforms\n    elif 'valid' in data:\n        return valid_transforms\n    return valid_transforms","metadata":{"trusted":true},"execution_count":90,"outputs":[]},{"cell_type":"markdown","source":"# Dataset","metadata":{}},{"cell_type":"code","source":"# see image triplets\ndf = pd.read_csv (CFG.img_triplets_csv)\nTRAIN_DF = df.iloc[:(df.shape[0]*9//10)]\nTEST_DF  = df.iloc[(df.shape[0]*9//10):]\ndel df\ngc.collect ()\nTEST_DF.head ()","metadata":{"trusted":true},"execution_count":91,"outputs":[{"execution_count":91,"output_type":"execute_result","data":{"text/plain":"                                     anchor  \\\n30825  e6cacdc399322158ca9c980a9ab42aee.jpg   \n30826  e6cd3179799b0caba2e1c57a08c5af59.jpg   \n30827  e6d0ca2b793deb5eb4d7970562bbae7e.jpg   \n30828  e6d2fe7f2b3c65f56b3fae0f1150751f.jpg   \n30829  e6d692b7106bc7ef5cf401e6e7de76f7.jpg   \n\n                                   positive  \\\n30825  260791f572b37106e450d3e2f0dc3913.jpg   \n30826  8a11943162871a5ed71ba4c189de89c4.jpg   \n30827  e58796b518c5fca3ca8334c257895270.jpg   \n30828  b8f46bbdeb234ec709bbaafe7cc9d614.jpg   \n30829  25bf5187ef525acb1e92f03b65f745ce.jpg   \n\n                                   negative  \n30825  4f79e786a57476a6ef4375db3e56d4e1.jpg  \n30826  9d396f45de57830007f23fd15864e414.jpg  \n30827  1ff53e5c857b0a268ada8c653887cf2b.jpg  \n30828  cc496b883895b6b13189a151c068991c.jpg  \n30829  ed31b2cd62b26f810121c81b97c61f0f.jpg  ","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>anchor</th>\n      <th>positive</th>\n      <th>negative</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>30825</th>\n      <td>e6cacdc399322158ca9c980a9ab42aee.jpg</td>\n      <td>260791f572b37106e450d3e2f0dc3913.jpg</td>\n      <td>4f79e786a57476a6ef4375db3e56d4e1.jpg</td>\n    </tr>\n    <tr>\n      <th>30826</th>\n      <td>e6cd3179799b0caba2e1c57a08c5af59.jpg</td>\n      <td>8a11943162871a5ed71ba4c189de89c4.jpg</td>\n      <td>9d396f45de57830007f23fd15864e414.jpg</td>\n    </tr>\n    <tr>\n      <th>30827</th>\n      <td>e6d0ca2b793deb5eb4d7970562bbae7e.jpg</td>\n      <td>e58796b518c5fca3ca8334c257895270.jpg</td>\n      <td>1ff53e5c857b0a268ada8c653887cf2b.jpg</td>\n    </tr>\n    <tr>\n      <th>30828</th>\n      <td>e6d2fe7f2b3c65f56b3fae0f1150751f.jpg</td>\n      <td>b8f46bbdeb234ec709bbaafe7cc9d614.jpg</td>\n      <td>cc496b883895b6b13189a151c068991c.jpg</td>\n    </tr>\n    <tr>\n      <th>30829</th>\n      <td>e6d692b7106bc7ef5cf401e6e7de76f7.jpg</td>\n      <td>25bf5187ef525acb1e92f03b65f745ce.jpg</td>\n      <td>ed31b2cd62b26f810121c81b97c61f0f.jpg</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"cell_type":"code","source":"class TripletImageDataset (Dataset):\n    \n    def __init__(self, df=TRAIN_DF, \n                 transform=get_transforms ('train')):\n        self.df = df # pd.read_csv (img_triplets_csv).reset_index (drop=True)\n        self.transform = transform\n        \n    def __getitem__(self, index):\n        \n        triplet  = self.df.iloc[index]\n        anchor   = self.transform (image=cv2.imread (f\"{CFG.train_path}/{triplet['anchor']}\"))['image']\n        positive = self.transform (image=cv2.imread (f\"{CFG.train_path}/{triplet['positive']}\"))['image']\n        negative = self.transform (image=cv2.imread (f\"{CFG.train_path}/{triplet['negative']}\"))['image']\n        return (anchor, positive, negative)\n    \n    def __len__(self):\n        return self.df.shape[0]","metadata":{"trusted":true},"execution_count":92,"outputs":[]},{"cell_type":"code","source":"def plot_imgs (dataset_show):\n    \n    from pylab import rcParams\n    rcParams['figure.figsize'] = 20,10\n    for i in range (2):\n        f, axarr = plt.subplots (1,3)\n        for p in [0]:\n            idx = np.random.randint (0, len (dataset_show))\n            img1, img2, img3 = dataset_show[idx]                         # ;print (img.size()) ;print (label)\n            img1 = img1.byte ()\n            img2 = img2.byte ()\n            img3 = img3.byte ()\n            axarr[p].imshow (img1.permute(1, 2, 0))\n            axarr[p].set_title ('Anchor')\n            axarr[p+1].imshow (img2.permute(1, 2, 0))\n            axarr[p+1].set_title ('+ve')\n            axarr[p+2].imshow (img3.permute(1, 2, 0))\n            axarr[p+2].set_title ('-ve')\n    return\n\nTR_DATASET = TripletImageDataset ()\nplot_imgs (TR_DATASET)\ndel TR_DATASET\ngc.collect ()","metadata":{"trusted":true},"execution_count":93,"outputs":[{"execution_count":93,"output_type":"execute_result","data":{"text/plain":"20"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1440x720 with 3 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1440x720 with 3 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAABIQAAAF3CAYAAADU7JAmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8+yak3AAAACXBIWXMAAAsTAAALEwEAmpwYAADEwElEQVR4nOz9d7xcV3nvj7/XOTrqVrclWa5yw8bGgCkGTO8ltIAJEDohuSGE3FRy7/f+Um76TUIIBAiEmkAcmxJMtzHYYIwNtnHBvcuWVaxqSUfSaev3x7P3mT0ze3afmT1zPm+9Rmdml7XWXnuvsp/1FOe9RwghhBBCCCGEEELMHUb6XQAhhBBCCCGEEEII0VskEBJCCCGEEEIIIYSYY0ggJIQQQgghhBBCCDHHkEBICCGEEEIIIYQQYo4hgZAQQgghhBBCCCHEHEMCISGEEEIIIYQQQog5hgRCQsTgnPtT59x/9LscQgghhBBCCCFEN5BASAwNzrnLnXO7nXML+l0WIYQQQgghhBCizkggJIYC59wJwDMBD7yyv6Vpxjk32u8yCCGEyE6gJfqn/S6HEEIIIUQ3kUBIDAtvBa4GPgu8LdzonPusc+5fnHPfdM7tc85d45w7KbL/sc65S51zu5xz25xz/yuS5nzn3OeD825xzj0pct7pgUbSnmDfK1vy/Jhz7lvOuQPAc7t54UIIIbqPc+6PnHNfatn2IefcPwfflzvnPuWc2+Kc2+yc+wstCAghxHCjsUEMOhIIiWHhrcAXgs+LnXNrI/t+BfgzYCVwN/CXAM65I4DvAd8BjgZOBi6LnPdK4AJgBXAx8JHgvDHg68AlwFHA+4AvOOdOi5z7piCfI4Arq7tMIYQQfeIC4GXB2BFqf54PfDHY/1lgChtLngC8CHh374sphBCih2hsEAONBEJi4HHOnQccD1zovb8OuAcTyIR81Xv/U+/9FCYwenyw/RXAVu/9P3jvD3nv93nvr4mcd6X3/lve+2ng34Gzg+3nAkuBv/HeT3jvvw98A3hj5Nyvee9/7L2f8d4fqviShRBC9Bjv/QPA9cBrgk3PA8a991cHixAvA37He3/Ae78d+CC2ICGEEGJI0dggBh0JhMQw8DbgEu/9juD3F4mYjQFbI9/HMWEOwLGY8KgTrectdM7Nw7SJHvTez0T2PwBsiPx+MHvxhRBC9Bvn3DcCM+A9wAeAD4S/nXPfCA77Ig3h/5torAAfD4wBWyJp/CumRSqEEGKIcM692Tm3P/h8G40NYoCZ1+8CCFEG59wiTC1z1DkXCnAWACucc2d3PhMwoU0RCf3DwLHOuZGIUOg44M7IMb5AukIIIfqE9/4V4ffQobT3/k9bDrsI+Afn3DHYavDTgu0PAoeBNYE2qhBCiCHFex+6qQDAOXckGhvEgCINITHovBqYBs7ATMEeD5wO/AjzK5TEN4D1zrnfcc4tcM4d4Zx7aoY8r8E0hv7QOTfmnHsO8EuYDbEQQoghxXv/CHA58BngPu/9bcH2LZhfuX9wzi1zzo04505yzj27f6UVQgjRCzQ2iEFGAiEx6LwN+Iz3fpP3fmv4wRxAv5kELTjv/T7ghZgwZytwFxkignnvJ4JzXgrsAD4KvNV7f3vZixFCCFF7vgi8gIZJQMhbgfnArcBu4EvA+t4WTQghRJ/Q2CAGEue9LFuEEEIIIYQQQggh5hLSEBJCCCGEEEIIIYSYY0ggJIQQQgghhBBCCDHH6JpAyDn3EufcHc65u51zH+hWPkIIIQYPjRFCCCGS0DghhBDdpys+hJxzo1gI7hcCDwE/A97ovb+18syEEEIMFBojhBBCJKFxQgghekO3NISeAtztvb83iMh0AfCqLuUlhBBisNAYIYQQIgmNE0II0QM6huQuyQbgwcjvh4CndjrYOadQZ0II0QHvvet3GSom1xgBGieEECIJjRMaJ4QYFEZGRli3bj3r1q3FuWq6rgMHxnnwwU0cOHCgkvSGkU7jRLcEQqk4594DvCfyux+lKH64j37tPP5056oyplo286zDaphPkWE4tk7jEupQ+bO7Yy62V+WJq+e0S0gjqewpVVFd4ilkve9Zkyxw20ulTeOxKXu78pKnymZmZrpYknrTNk6MKA6CEEK04jVOzI4TIxonZgm9ghSVkg2bhFHUh0WLFvPe976X3/u932P+/PmVpHnttdfy/ve/n6uvvrqS9KL0RUxRMUnvE90SCG0Gjo38PibYNov3/hPAJ0ASfZEFj4YmIYaG1DECNE4IIcQcRuOEEEL0gG6J0X8GnOKcO9E5Nx/4FeDiLuWVE9f4OPJ90vAxn64Ql1GJDLtd7qz117NrSKi/snWQdG7SbWsre0U3JfdzXFUFxKczW4QetZXMj14MZYvYs+5gMKnxGCGEEKIGaJyoiLLzICHmOt43NO6Gka5oCHnvp5xzvwV8FxgFPu29v6UbeYlWKtKkqeqhr51SzxC3ZiEGBI0RQgghktA4US0OzYCFEPF0zYeQ9/5bwLe6lf6gEO18+yUb6dkgkHaBpSug9Sq6UaNxdywmnw4uhMrVc8rZLmN+BdwbdZUwwyK3K62w3XD+U5GLpW4VYVjQGCGEECIJjRPliPo98V5CISFEPPK8NgcY3s5/eK9sKNHtEkIIIYQQQojaIIGQEEIIIYQQQgghxByjb2Hn60CZaOkDQZq9WpFw4VVVVmWV3uOA4f30iRSGD+1HGSrKs9RtL/M8VlX+lPD1XchSCCGEEKIS8piNaR4jxNxAGkJCCCGEEEIIMQeQoEcIEUUCoaFD3fwsc7wq5vjlNxFXF/2sH90bIYQQQvQLzUOEECFz0GTMR74NeneYo/xFbHXiokNlzLK6yFtFiBR81i6we6VoSjnRrKlsGbLZjA3EU13E/Ctr9XUwlUyql6bntYAtaZFAalmPHVqTViGEEEL0hNC0vYvTYSHEgCINISGEEEIIIYQQQog5xhzUEIpQZFl/YCnhfDnNOXXCKdVWbU61ktKrIDEJpHl07tezVJtnOKUgSY9hF9TKijhOnFUQ6q+amxCl8DEPrYs86T5mmdjFeUcfANKuNfncdgazFoQQQgjRTaJTpwGdMsUiDSHRVap7jx6iVieEEEIIIUQf0cxaCAESCAkhRDk0oxJCCCHEEKGpjRBzh7ltMpbTsKmsBclQWKh1Vb++Kje7Nahh3/FH1YkHmzJ6Ty6aT5h+oUZQ4KHJ6ti5omstdIdSqjzWcWPMgU1VKtM0UYLo47PYw/HAcjzbcTwITKVZdAYPYNR0LM60LKSTiVnSOXnSyUyBLqbh6z/mZOdyX0MewuttHiby13MSeUwCs17roJoUCiEaRJtxbPfXu6IIIWqCNISEEEKIIWMd8Ft4/hl4I54lXcijKqFJN4UvRahbeYQQQgghusUc1xAKKOIgKk5Toqti9SKJ18xdZhEPv0XOT0y0otDvWeOZF6aq8g4oJZSKCmVToJpzujgXoqcsAk4FzgFuAEYTjh3BB6tDjumWfQ5bORrBMwPB/vanPypEcUF+LkWw4p1jBpghn0ZLbykyjiZPCnyH/aOAC+p5JrK/k4AqqX4cjXtHkF56/+SDe21MA176AkIIIbrAzMwMk5OTlaU3NTWlBZ2CSCAkhBBCzFEWAM8EnghsxvM9HNsj+9cAz8dzHHAjcAVwKCXNY/C8wMNRKcft857vO7h9qIQOxSajRwEvxLMBuB74EXC4RCkcdk/Pw3MIuAzH3SnnzAOeDjwF2AFcCmwuUQYhhBAijsnJSa688kqcc4yOJi1ZZWfz5s08/PDDlaQ115BASMwxHNLjEEIIYyHwYuA9wDXAzdAkEDoSeAsmNPoM8FOSBELWtx7nLb2zUvJ+CHjYw+0u2icPk3AoO+uAtwFPBT6B1XNZgdBTgD8AdmN1nSYQGgOeB/w2cAtwOxIICSGEqJ7JyUl+8IMfcOWVV1aW5szMDBMTE5WlN5eQQAiICghC9ejUKWmcTCGjZnn61HcIJsQlZC5lnXcnnx0q0mc5Nj+zhl5NFzEE9zOguntTgJiG07OazeygNiWdNPNS2aGJHjMD7MEEBtuBVuVthwmNlmDaRK7lIV3qPUdhwgSP/XcCsAIzW9sF7KT5MV6BCZqWYY6vT/PMPvszeB7BsbeCa6uGLiwiBMlFLb4msfp/CLsfMzjGgKPwLI2cOg3sSKgfHynrPkygsxc4SItZXzTzyMA1FvibWkSymaEQYhho79syvwcJUZLJyclKTcZEcSQQEkIIIeYoB4Ev4/gpDcFQVpxzPM57fh3PWhoRa1YCG4Ap4DvABTQETQ54GfCO4Lh3AC+NpLkf+BzwTfonC3VtUcaiQqEijgbTeQj4EI4VeB7EcQhYDbwLM+MK2Qd8GvguyfUzg5n3bcbq/vaMJXZtW4QQw0wnkXdETi+EGHIkEGqlagfRNfPrXDuGoC6G4BL6QExI+077Z+lCTWd849Q9FsPKFCYsiAoMkp53R7N2yVrgWcDx0SYd/D0M3AN8DzgcnOO85wRgAlgKPC74hOwBvh/kMxOk1KqV1AtmQ8P74oKgaD2lObrcB/ys5fxFwOOBF0WO2wlckpSQD/94NgGb2gIUtF+HazumcWQ9HHsLIYQQ9cLHaPsOKhIICSGEEHOM44Gn4JkPXI/jtgrT3gb8BDOB+jk0Ry5zjju854vA4sjmEzD/OYafo9GtmoU2+4HLMLO7kAPAHXSWZa8GzsVzJHAbVv8LMH9CxwP3YoKn8YpLLoQQQsxFvB98oZAEQkIIIcQc47HAHwHLgb/BcwcuCHVenvuAfwZ+gQkeplr2X+Mcv/DNIp9XAKdhvorkNsuMNXYB/w5cGNkzQ7Iw52jgN4BzMNOy2zDTvLcCLwG+GtxrCYSEEEkM+PutECIHEgj1nW52uXO9O+90/UnmSHV7FemrG+cGcVWZVGVdLnZPnuxIJnHWHoVWA3rtDFuIDsxgmjszwBHAejyHcDwKTKaYN8XtncHMnsaBrZh20I4OQRUOBp8RzLH0ouB7+5GD2VJGseta6C3k+6O0aEllZAZ4NMarzzLMMfeE9zwKTLV0RtM07i1YTc5ggrn5WIh7H5x7EAZ/aVMIURA5kBZCSCAk5hx1E/gIIUTvuQX4KxwrgFPw/A1wJ57P43ggRzo++Bx08FXMX9A24OEM564A3oyZih2LabIMQ8DYlXh+FXgScA3wBUKzr/IOqZfgeR3wHOBWHJ+nua43A/+CYw1wJ3AoyPszOC7FczTwPjxTwAU4rshxXUIIIYQYPiQQEkIIIeYYDwaf5cD/Bd4IXAVcjOeBAuvFE5hvmv+EGNOz+PQWA88EXteSzqATXtdrsEnWVzKfmV7v8zF/QG8Cvo/na7gmgdAu4NKWcyaAHwbf3wi8H1gIXBts1zKJEEIIMXeRQKgP1Fs1s/9h0YZhctpkMdUTa7TWEMl9pula0+zHqqmYfhoCVpVP1nhrQpQmMBOa8p5f4PgGnm3AE4Bj8NyD466CSa/CcRYWRexu4C4aQiIHHAecDqzHfN6E21sKWDD3bHSzbziICVvGgOsxLZ2qcDFBoke85xTgZMxs72Zgl4vpd72dW4MRQghRB+rqLUEI0VMkEBJCCCHmKAcxDZbvBUKc38RzDPBvwP0ZznctH4CTgN8HNgKfwJxMRzV/no7n97CIWGuIc2Ez2CKL3Tg+A1yERQrb24U8ou9vY8DLgHfjuQv488AhdTztAiUhhBBCzF0kEGqlB/PQZl2OAho5AyHRz3hdha6hGzep2spMTy3tiOLX2E1dodhS98zvdfuVdSW7jO0rrp6jL7ZFdO1q3aTFUBE+izMOdmCftd6ifB2J/e30vEa3T2JCj1HMMfQRwGo8x2OCoXWYWVqoJTMCrAU2OvMZFE3nEKbhMhmbU31wMU6YfcQR9xTmWLvpuBhH3amjQJyz55h0HOZb6EhgJyYgandFbTlOYnU8QUNI51OciAshhpOBeJ0QYgAIh9FBjdEggZAQQggheAD4KLAKuI6oYKYztwH/iAl91gB/AhyDCYJGMefHS2iOsnUWFlksyq3Af2OClJ+iF5QkotpYYPfpMhx78OwENiWcezPwD9i9uQ4fmPIN6AxWCCGEEKWRQEgIIYQQPAxcgPmpCaOHpXEPcB+O5Xj+DHgPDW0hMAfIT2o5x9EeZv4e4LPAgx30ZkVnpoGrgWtS7pvHIo/dHZiNzTTtkVBICCGEmIvUXCDUM1uUUlSvcpli9NPVqsg4KSw0d+yCw+rMld+b5ycxlz48zmE2TbUca4bQ9qVlf0ZdyFSvyL1VUE7NpczjF0k8dByuVypRR9ZigplHvOd+zDwsFgczrU+xb/8Zmhg5ZwKIaWACx314foqFkz+RhtlZq/An5DDmp2gncDtwENekSVSqeUbMoNJMvGLPD/7Ow5xgr511xuyazLbGMR9Jj2L1fByeaeB+HDvTCzn7dQlWZ0fg2YrjQWCe95yAaWxFj9sP/AQLMX8asAx4KPid1heF92sejo14jsJ8HN3fctxS4ExgpkM97QjOmYjmNai68kIIIcQcpuYCISGEEEIUxQFPwwQVDwMfAi5pcyxc7EXe+0bEqkPAl3FcATwR+H08p6acvwf4DI7LgN3Bpw5Ea2YxcD6e1xLvuewu4O9x3AA8C/gNTGDzQeAHOfLcALwfz+OAi/B8HMcRwLvwPCdy3AHgv3H8JyYMegeeVcCncfw72cz8wAQ+bwReiZno/QNmrhde3TFBefZ3OP87wIdw7ED6RUIIIcQgU3OBUKcJa/e0Cyqf1KQkWEpnpiYKVPFKIWUCaKfUSlzSPauLmJXmuMPSbmyilk5a3uU0rWKPDDb2zrdozP2sKvOYZPIsXMeXIn+dF+lLFHZeVIXHnBtPYv59op9OuNj+zTOFaYJMB7+b2699n8Z812wCFns/67g4iQNYWPrrIunUTbAwiglrziJe08kcOtvf1ZhWzV5Ma6fpuEgnFKedtBDPScDjgKuAETzzgROCbSG7MKfQ12EOvI8LjjkqKF/cPYwrwzxv0eQeh2n7LAx6GtP2gvlYlLhO3AKMRZ4FCYWEEEKIwaTmAiEhhBBC5GUncBGOn0dEintx3DH7K9vr+07gQhzX4vkZbjZaWBIPAZ/DsT5FnLkXx52ZStE/DgHfw/Foh2WOLTgewgQiNwAfDuro7pz5PILjAuAqPNfgmMDM0L4G3BWpx3EcNwX5bQI+i2MlnmtodtydxkFMU2wnnnsC87Yp4Eos+uloyvk34DiQIz8hhBBC1BNXh3CjzjkfG161+ajI9y5qCGVUJWiuNh+zLUywQBmyJtBPDaEUhZ34xyprBXW6mIyOWjLnXYSYzLNeQmUxx/NrUGV9DFP7gyI+IlJjK89mnjnJsJ1mvdWFNIRi2nhLqm1fu7FCPjMzg/d+zi++O+e8G+nkjUZA81M64k3DZLRl/wT24h9H3PjnIumEmkI+4fho3ml3KyzPdEnfM2n9Vl4fQqFvJGhcf6fVsxnsGmaCY8aC7RPAVCTfpuE6Ju8RmK3nyeDjIttmzw32TUXOcZFtmTu7yHWFWkE+KP9Y0nkBofbZTGRb1vmTqB6vcQKwcWJE40RuavAqKMRQUOdhMOl9YoAEQk1nBH+rf8nPMZeK/upSadK39pwEYUPH6090WFxSIFRKiFKEEgKhmHOaXxIKFikvCcKL9P4gRRKYRtIjkCPvZL/Y+SVC6ULNbGlKINQ9JBDKR1xbruqFvUzasX2Mc4ntP0+5q77uQrL9LtZ9P+lCWAhRERIIGfY+MRL53cfCDBA1eBUUYuioW/+T9D6h2bUQQggh+ofeRoQQQggh+sKA+hCKDabdsi8HNZPgxbvSLh8RphLSlghb97uOPwaIjJ7BHdkfv+C4Jjlt6cc568FJ15OmfhUJ5ZzVwXYXSOoBEk/IcFL8NWTUfkjZP6gtQIi5hkRURrOiZEl7XCF6QuM5jX9k9cwKIUQUaQiJ6pjrM+i+Xv9cr3whhBBCCCGEEHkYUA0hMTBUJqfQio4QQojuI/G6EINLUvvVTFIIIdoZcIFQnB1IHo/Dru2MblJZkKn8BjM5yGsTBtX7MSxk01MgTU3728jRfAo9hXEeyKuwdGtKOsfzU+bRLWAf1s2WK0TP6MIDPBs5sKQ/IZmDCCGSaO5jgvcAdRtCiBLUxLFLYWQyJoQQQoj+UbPZU82KI4SoCI+WAoUQohUJhGqMJqViblHNE6+VPiFqjNrnQKHbJQaP9KdWgiEhhGgw4CZjUYp37XWJDJQ/n7opqKWZm/U67zT6aEZWh9uVSor9WEyktDiLsHxVmlAxOR73UCjU3WjWKc97Qt5NlzIQz4IYOLr6XJVMPDHQYT0aRD1KUQ9m66Im90aIdGJnI234wMg8OleQ2akQogrCfmUQuhRpCIkuM6RrMAPQuIUQYhBw6lCFEH1C2kJCiLlOYYGQc+5Y59wPnHO3Ouducc69P9i+yjl3qXPuruDvyuqKWzGO4i/2jnLnV46P+URwMZ9Y4g7okGbusqWUp+f1GXddcQXqULdlyltqBpJyr3tGkLdvfMqVJu66OlxjmHX83gaz96hDmgmPZuIz2vG+578n3sd8cqdST4ZinBhQXMy/6tIu3m2nlauvQ0JFOOfaPkKIeKoeJ5r7j7CPyd6jeO/bPkIIkcQgz1mgnIbQFPB73vszgHOB9zrnzgA+AFzmvT8FuCz4LYQQYu6hcUIIIUQStRgn6rLUJoQQvaawQMh7v8V7f33wfR9wG7ABeBXwueCwzwGvLlnGLjGoMjwhhBgMBn+cEEII0U3qPE5IKCSEmAtU4lTaOXcC8ATgGmCt935LsGsrsLbDOe8B3lNF/vnorSAoxS1vjtKkpZRCjGMrn5Z55myKlye2AkpeajHiCpTRK3CUbH4Ms6fTl7qII+OFJd3X0sR4lY5sCp9n135UatVldSzvY7dmSSEnQzgLHaxxQgghRK/p1jjRPFrnH7vjzMZkCiqEyELdQkDF4craxjrnlgJXAH/pvf+Kc26P935FZP9u732i3a9zzveuY40JiZT9jFmaoyj59m0x5/ZeINSeepNAKO30yu2mY662n0KpWLLWc4eC5xUI5Unet30pmLZLz6JjNhlFJ4VkJXmuq/OzFHtdHZ/lhJNicutcP+VadxLez+B9qvi21lQ2TowoDoIQQrTiZzROBMd455LHCZ/wK7WMzXnlOrfOyE2SEF0kv+ihK8wkjBOlZtfOuTHgy8AXvPdfCTZvc86tD/avB7aXyaN6IpbBGY2E62FLHLVqTnNb1Xl/1HFtOlV7fk5w6tvpU1svXSmOj2PLnXaxyc6O60HaDSlT8JI3OzHrip7jjs4FhsEVbncYzHFCCCFEr+jlONE8Sucbu6ND/6zTaWo8ZRNC9J8B6CTKRBlzwKeA27z3/xjZdTHwtuD724CvFS9eN6nxXRFCiCFg8McJIYQQ3WTQxom2twep1wghBpzCJmPOufOAHwE3AzPB5v+F2f1eCBwHPACc773flZJWD03GmnJu+pPxaKAfJmNxZ5VMsZS5VjdMtFJ297w8BdKMe44LmXolmV7102Qs4wG5bBNzpm0ZZMp6NrXiyTXt7se8b5BNxiofJ2QyJoQQbQyyyVj17xPZx4n4Ib2AGVnCvGoQkExLiN7QT0vTJJOx0j6EqqB/AqHZEmTa1JGMAqHqyVXIbOk0CSDyXlGRZymjyCxVTlNEHFekPBnPr0qQkyhgSt2YmGZtBEKJfpdSfP+kZD2bigRCA48EQkIIEc8gC4SqJK9AKA4f8y013/iylCpHL6nBq6AQc4K6CoQ0uxaDgQYrIYQQQghRMwbARYgQQnSkkrDzg0+0C3cdNw0vkYuNi90de2zsekh6+rn2teRXSjMmUQ2F7NfTx+G+KpOxBFxXU+9AqfvaflzpRdKYrGeTLKtAFlKkqQghhBCiqzRmi+XmgApVL8TcJu6NOewW6tYVSENICDGL5BFCCCGEEMXQPEoIEWUQ+gQJhEQ8tXt6e+TEWgghhBBCiIL4lo8QYm5T935AJmO1pCq7FBGPhELdo5t1O6D3bUCLLYQQQsxV4g3Gis3PfZBeaEYm0zEh5h5hP1BHpCEkhBBCCCGEEF1C2kJCiLoigZAQQgghhBBCJFDX1X0hRP2pc/8hk7E24kIMxR3XzdtaPMJSdXnX8bHtZtmqqssgnbKRrlqS6w8lMu94atyOGjxrWYPddSPtGly+EMNGXISfqpC5hxBzlyqikEX7J/UnQgwnSS07OkWpQxcggZDogBRbhRBCCCGEqIro7LoG74FCCCGBUJUMX8feWAepJp0ogypwqqpOhBBCdB29fQkhukBV4V+kLSTE3KYO2kLyISQ6oEFJCCGEEEKIbiBH00KIOiCBkBCFkMBMCCFqjd60hBBCCCESGXCTsapMkbKm00kIkOg2KsfxNXW425UyVJVmQjq5Ho8i5cl7TjeuucDzntk3dz/ve9XHCSGEEEJUj4v55nPMz3xwZmg+JtMxIeYSjb4iNB/rdR8gDSExt9AYK4QQcwP190KIAUHmY0KIflEfDaE4SZjv+CPm/PCwAjPAWE2SlHTSspktbuTAvmhk1IiqRrqMmj8da9NVW5yeE/E+5tu+tP0IiKxfOR8c1b6m5eJPKVVX3XApXlVLSYxMnafpVkVcNziwD6qYq1TdX5SiH8NqmUYrzQAhhgIXdD55NIWEEAJ672xeGkJCDDqZ5hqakAghhBBCCCGEaCCBkBCDTC45j4RCQgghhBBCCCGM2piMFXOTGzmyiKlY1aSZ7YRl7EZR0/xR55UFVFRGc5JXtBAdiE0me4EzFyfmdnXTFCL1FnrffFwek8qm4wrc3BL+zqOnVmbqVVl6CfUW6VOKNN3EO5JmAVuD7kyILCRbXXpWA2uIbztTwFZgX5Mj1uj5g4Ovyrazx2riQoju4mL7t+T+otfmIkKIehA3B4qbX1TdL9RGICRqRkG5QVwydaJu5SnM0FyIEGJYmQe8BHgjMD9m/yPAx4EfVjXgCCHEgFPdgpcQYpDp5QJZbQRC8atrJS9/VrTWlFNiPmV8U6fjOxehqTgVZZ5ZaNChTioblfJJL4o9Ce1nxTlNLkJVDpCzppNa1poJg7rhNDrrQ9BrbYJO+dXslgjRVXzCr2i7GAU2As8DFsak8yDw1dlzOvfhejESQmQlo/J3X2jMB7PPIBSKXoh60dpiO7XM7O+z0Sg+8VGSWpfNqu4XaiMQEkIYWisXQgwa84EnAWfQ6L/mAedggqE4lgDPB1ZEth0GrgVu60ophRBiMNBcUIj6ESfk6VVb7WY+EgiJDtRrKKpXaYQQQkRZCLwSeCfN0SoW0XmisRx4E/C6yLY9wF8CtyPNOyHE3EbmY0KIKN16H665QKikgUYeP7vh1zhHwln1T5tOymsoFF+eQRgFsl5p2cl9bpOr6H3NnFKKXVLCYQmbK6LEM9VjBuCxLUbHZypgaC9czHWiz/sonuU0m4EtB9YCq8kevnQUOKJl2zxgHXA0cAjPXmAypmGpqQkhilCZ+X5lZHu/6Yaj6frPJoXoH71rH/ldqzQcTje2l+kWai4QEv1jWKfbGv6EEKIMy4G3AOdGto0Bj6P8yLEIeC1wNnAr8FlgU8k0hRBCCCGGhao1hYZEIJRSJY4+ygH6mnnGIlRTxhpcaa3JWj+pDXwIKrrqS6iz+DL2WofgHoq5yyLgacD5MfvKtsX5mN+hc4ArMKfTQggxTOSdAshtghD1JWvbrLoNV9kvDKhAqMDlZw0f5rMdFndOeuYlKPPymOnc4mWM2jh3JeJUHelwUXHPjevwvRQVWCR2Y3KRZl2XubgZC9f7CVKnK3Add0efiabbllD4oWwzYqBxeI7HnEavB46Z3d6NvIw1WISykyIt4lHgJmCnXo+EEDE4fI4xtHM/0u1oZXmncV0RCmmyIURpOnl66fUspYz52IAKhIQoilQzhBAiLw54OvAHmJ+gVXR/snNykN9kZNvtwJ8BO7uctxBicNFMTwghslNzgVAXppuF1BXSyOmkOMfuRtIl3eBlXYooUeW+44/ukVjcjupKXXyNSdAQyXyrI7jUI3pEVc9FVSfHKOR09eU05SJCSXyaA/rMzVnKD6ImhGvtDnMAfSwmEOoFC4ENLdsOBPkvwzMBHAJ80GDUbIQQ+Sg+f88RbySR5teS5Ml6qCUUOpiuyrm0EKKfRE0JqnnXy2sNkjUYiBgYtCYihBCieuowuqzFQtv/OfBLmD+jkDqUTwhRD1zLZ1hQPyeEqJqaawgJIUSdiFFE1wqdmAPU5SVkNfAqYAZb0boUGO9riYQQg8AwmZHJybQQokpqLhDqZBBSwkSryKElHPjWrseuWXmKFMfHfI9Np+P9yvn8lPWU7Zv+dE4zZ3p1JK2plGlKTZQwzSuVSXSt0cUcmfL41PjWCRHLEmAjsALz6TOW4Zy9wD3AQcz59LFUqI7sG2nNplmzcU0I0T/izKh8ZnvuaEJVGYVlpzFH0sxBiH5TVaCkPD1JUg8Tl47vICtxiS/I7dRcICRE1VQ0sA7TUpMQQnRgHfBbwFMw7ZzFGc65G/hb4H7gHZiJ14IqC1UkGqgQYs4jMYsQQrQzQAKhunXdGcvTT+exdZ4sx2nNlEkuo2JPVbhIBt1wph1f9sr0ayohqX4L1X1fLqt4nRaZWNbrDgqRzkJMM+jxOc4ZB+4F7gQeIXjeCyzQh7hOrU12E0KIDES1hqIL54maQz2LWtFOVkfT0fLLwbQQw0Ox94TindYACYSEEEIIUXeOxTSDHgGeAYx2KyO9/wghSjArapHWtxBiiMi7XiaB0NChGXIyGvWFEKKbHAu8C+tp5xGZaBTtejWsCSG6iENCISHE3GUIBUKR3jxQn2xSvczq2anQoJA1oQKOr1PLU4MZc8cy9t9QxqfkXcb8yXX8EeZdPO30Gitep94nKSK3Utxj83DNrzo4b4vZm0Qeze7hqj8xCBQyg40806PetILiAgA0n1Jw8K3BcCeEGEya52z2K5wPlRUKdcPKrJOj6Zw+YxtnalIxy8jICGvXrmXlypWVpXngwAG2bt3K4cOHK0tT1Ic0dxFxfUA/pyxZ2/sQCoSEEIlE9AjjOq7WvkPvXkIIoK8+NeKoQRGEEENE6B9ykIQmcqVWnMWLF/P617+eV7ziFZX5YPr5z3/ORz/6Ue6///5K0hOiF9RIINRH3/+VaQMVyDCzN+QCWkUFqOoupGnkZCmjy1iIToeklsG3f3Wu+jeeIqnk1irKkknrcn14raHyj28c4yM7PI1jXfR5rWgGUkp/rPriZCZudU6TMjEMuEhrnG2frQ00YXm6WDtI6gHay+Pid6f3+y0U0dKMc+SadexUlCMh6keT02lvikN5+xIxeIyNjXHaaafx3Oc+l5GRkcrSXbJkSWVpibmFb/vSgdSJls8lLK6RQEiIBmcATyY9VPHDwFXAroryHYSVFofVz5OA+UcATwNOSDlpCrgeuAmYiWw/M0joEPATcPfDXcDVWKSgWQahYvqEqkYMGyPA2cATMH9ARxd5LypqzzDkqL8QYjCQSyEhxFxBAqFhYwhmmg54KvC/gDSr3iux8MZVCYSg/hN2Bzwd+ABwxErgLcBLU046CPwDcAsNgVCY0B9hFfj/AffDl4FbaREIQf0rRghRCfOA5wL/E1gCLE46WP2CEGJIkVBICDEXGEiBULKb5rhvXaAyR9QF8kvzU13Sj3VRotmOelgOLCqQzgiwHlgDrEg59kjgaGBvJPNJYA8wkeOaFwR5zfOwz8E+mLWR8K5Hz1QqjYtcCKwClnngMCbwSeKgs4qJ4hoJTc3A3vmWzASdH2XvfcQhcsW1kadNJTjv7tk9itrQVGR7LkRdWIT1MQuznhBjgjv7I655OFIddWRvVXGZZ2ufnYbL2JKpzQsx9IRNO2zuzf1B/xyppTqzjTFlFULkp8xrdO/eQarNcCAFQqL+rADeimn65MUBJ5GyKh1wMvD7mAAoZBPwGeC2HHmeDLwdWAf8t4evObOyqtuQ2ha1Zxd2sZeknDiFqf1Mx+/eCXweuBarv73liimEEO2Eb1au5XfccaUotzojjQAhRJS6awrJQlcIUYbSAiHn3Cj2HrnZe/8K59yJwAXAauA64C3e+4my+VRGl3r1KsJVziaUKbOc51SUdVYWYa5tXlcijSzlORJ4Ucu2m4Bvkk8gtBZ4MSYYuhP4evDSUidrCN/yF4ADDn5c/oE+APwYuLh0SsWJbT5xG3t2Q+o+BRwcBm6cEPmIdJSprcY1/ek4nmVejWvLcHDarHoYIRrUbZxwzjVp3eQ6t+KyxKWvvkMIURVVaAi9H3v3Xhb8/lvgg977C5xzHwfeBXysgnxyM6vu2dozlwpr1CGvtrQzJt6qA5r15bfC0aZQUp3MAyqkaLrLgWdi5g5ZOYvGA9xWDu8jLy+9kUbke4wK2i964B7g67B4H5y7BUZT0pjGcYeHux3MdGxgxR/P1vN8mcQqIVtnkXV1rk/WnHWgtuOEaGcGuAP4GvYmdjYmfE+i43PsEn/Obuy0vZW9wI3AI8ANmIlrKlkHkzxd6WwoonIjYGIPk9DHCjGE1G6cCE2v8gqGerGYmFcoVLKrEkJ0jRKNsyIFkVICIefcMcDLgb8EftdZz/k84E3BIZ8D/hRN9EUPWQ/8JuZaJyuhT54OFlW10hTKRoapwgzwQ+AmWD0N79gFv9KSQivjwL9gjrynOxwjRBSNE4PHFHApcA1wGvAnpAuE2uhS57AF+CgWCXE/6e7ThBD1ZxDGCWnlCCGGlbIaQv8E/CFwRPB7NbDHez8V/H4I2BB3onPuPcB74pNNXpVPnme2n+N95IzoyYmrgd1cy++UTkyePiHPXjmSjtEGcpgj5oXxh7HMOcayJlqgHEnMx3wBFcliGrumFcDhFv+hDtOKOUiLf+aKnE7HWT2E9bwgkvqIM5O8jnn56F1K4VH7jGFmc4D9aM1gCjgIB2c8a4HlHg45x2FgqpuOVnM4la6cpvaVoimUUOVp1iyxTXe4JG3/RFfGCdEtPI49mG+2pXgOtezvNHSGTumjByzE+q+4c2aCcyZpdDsjKWWbALYCD6QOgD3Ae3zclaW038QeOtKfhgENXD/7QSF6wz9R63HCzf5fD6FQEVOHOayjLEQOKnuXS0ivY8st08GU0BYqLBByzr0C2O69v84595y853vvPwF8IkirHv2ryMwoFpb4RdhEvvUGLgUe2+tCVcA84PlYuPsmbaHAOmAX8BXMVKHbw6jH6vYFQZnm0dBUehw5ov/k5Wzg1ZjtXcjtwJdgbBu8ENMWuN/Dl5xpC4VoaiGiaJwYfNzsfy20TDwOAt8AfhTZNQ/rL8JxopW9WH/6c+DxwGvJZ+pbD7r4khWapQkxxGicEEKI/lJGQ+gZwCudcy/D3k2XAR8CVjjn5gVS/WOAzeWLKerGCHAO8Gu0CyZ85JhBYxR4EnZtrTgPDzi4HhMIdTOqQ5j2KPBkbOlrfrQsXcoXgFOwEHFHR7ZdClwGo9ssctxTMA+PP/Jwr95XRGc0TgwBHf37RGxpJzBh0McxzR8wzaAVmEA7TiC0HwuQ+CVMGPQiBlEg1GUGz15ZiLwM1DhRHy2hZqrRVRdCzEUKC4S8938M/DFAINH/fe/9m51zF2HBpS4A3ob5pcySYuR7FzuzlGgmyZYhecqY0dQrlYTVx7QRKWNxs6qteUxp5CRMg+ZE7AGKF/ykFC7vaNqj8a1Z0NJeyMXeNJ924tgRaMccjjid9jEPVeai+8afFTTq+QSsnkc7n1KQDsv+jwA/A9ZENv8CGG+c4bAZ2+OBeR4edvAAZj7maJg65Mm5SMm7Oikra9VYxkdcHWebBah+nBC9INo+x51FbpyH+Wc7ARiLkYbPc9ZnPYOGQGg+cByd2/sCzEfRM4DHEJrGdpMemUykme1mHMJnk+toPq8XPzH4DMI4EU5p6jw2N2THkiIL0S2KdAE17jZmqSLKWCt/BFzgnPsLTBP8U13IQ/SAuAf4JOwGnwYcRfyqb88K0wdWYmEuXgdc4uEfHGynuuE3vMxTsXo+CfPtEycM6hrXAv+H5pu7D9jWfNhxwP/E3BBd4OFjzlwNaSoiMqBxYkDYijmSPwLT4nkfzdakIYuwfvE5kW2O5HFiBfDOIN3lWP8qWlGPKuYsGieEEKIHVCIQ8t5fDlwefL8XsyipEcmqMumuqxM8wXaapyXN3/oh3Igrb4qD2xHaH5CV2EruWRUWrddMY4KLODpVz2jwmY+tkAPcDSz15nh1OviE3j9dxBl4kl/w1rxHsXpfBZyO1XVcebqHY3oPTO1pLldc7vMwgdUMcBWwyMNkIBSa8fFNILc7jJTj4+5Xj3QNRU7qP06IOA7huAdweM7BIg0udO1ai6OYTccxOdKO9qdxzNAQModM0i4iqcl6gRCiJPUfJ4I5HtF+J36m0U23AlnxdVZpEmJOk8fMJyR/EIuss6VuaAjNLYZ48e5UzKdDdDX4BGzFd5C5A/Nb8WjMvrhm4zC/Qs+l2V/SY7Dw9tuAy7DlqzJD70IsxuoTgI1YiI1+cCvwPUwpqNkmvfnq1gMvwcJ+PAn4HUyb4BLgToa6aQgx5/CY77QPYVqLL6L7gQM2Ad/BtDBDtgXbhRCiHmi2I4SoH3l6JQmEREdOxQQex0W2xWkNDRq3AR/FYphmYQRz6vx02gVCJwM7sehjPy9ZrkXAS4G3Y6vt/arnW4GPAFtoFZA1C4WeCJyJaQQ8GfMndG/wuXP2HE2ThBgWbsDciW0AjgXOoLvtexNmI/KLyDaPaQkJIYQQQojy1PTdvpsqjr79a4/CuqY7wi1RjrSwwAUYxQQgiwolmXYtvVVjncC0Vx51cD+m/XIo9Sy7hhFgqzdByWpgHeZQOTQjW4K9HJ0J7POWz6FI5FMXYzMWf/WeMazO+xktYho4TKf6aZRnD2Y2dwRWL0dhTmGT/B3lVqHu8JiEVdrV2oltU8lOYkvnI+1uUVM8jinMhGs/nvsxQc0yTFtwfsK5zemYAH0b1reup1kLdTrYtwu4BwtNfyimgeVrcjVrWHWwJRFCDC2tlmLNpvTqeITIQndmDr2dj0RFHEkWpDUVCAlRLbuBz2BhkbdhwoyseOBKB5u9rYz/JnBeZP9i4A3AMzEtoY9gQqcieAZHq+ZBzHxkJfBqTLNJCDH87AE+B3wb6wt/EzMjy4IHfoxp/iwC/gfwLBp93jhwEfB1TCi0papCCyHEkDMo80chRL0YQIFQuy+T5GNJP943y847p9Pp/GylyepcuDLS8oupHpe8uzq6oNGUxCFsNfsHCUXo5L7LAQ8Dmx0c7+H1LceMYVHXTgt+L2XWt7Sl69qXg12MmNZ1/FGeOIfLnfIPhVJpmiv7gOswjaDHEjjVzljwtFudmkrGFfaqFuJd25fsJ1UVil6IfhJ99A/jZs24luMZpxFqPnp8p+byMHAl1le+lkifg2lz3oH11TNBCtV1h3pVEkKUoGm5PeXQ7pakIyYU8k2/RWe898zMtI5g5dIToipS38Uz+p5OYwAFQmpo3WQJ8DQsetTjsQn7MLAUeCFwZIf9m7FV612Rbaux1e/14QZv0b9OTMjnaExgdC6mLXQDoaCkvTxPb0lrCRZZrBuTiGlMeHMj7S9urfwMW6UXQog07gO+SMMJvsf6wWcAa2KOd5jvobdjvoDuBf41sv8gcAsa6YUQ9SbP8nSvkaZQNg4fPsyVV14JgKvIfcgdd9zBrl270g8UIoF5mH/Ws4BHsHfU7YlnRCjQAQygQEh0k2XArwCvwnxCLEo+fGBYAbwJeF2H/T/C/OFEu/B1wLsxAVk46o9gJmKd2Aj8NnAA+CBwM/ECoRXAm4GXRbaN0L36ngQuBf6FdIesh5FASAiRjVuBv8c0BcOXo3BRIU4gBBZH+ixMU+ivsEhiIR4TCgkhhChOXYVVdeLgwYNcfPHFfPe7360szampKcbHNYsW5ViABRp6D7aY/wA5BEIFGHKBUJHuMItRTUGq7p07FSevRV2EEUx7ZVWxEhUoRIQu2qiNEphyRbZFszkS8w/0KGYK9Sgw6s1hcp66GMMcpC4gTrjTyLFRz60XayU85M3v0VRMZcStSqUtbByk4ag1USDkOtVQMvsxk7qdVPMylzXnVGvPmPTKtGJNsIRobkOTOPbS3DYewbOZZmfRcezHnEY3r6V206V+RbrVQog5Sa1jQMSaKrnYr8Lw3jM+Pi4BzhBTZtTvZ3t3DhYtg1VHwLIJmLcHmKjqbaadIRcICZGNk4HfA3YA/w18rWR62TqOuKNMz+9uzAn2QzFHxAqEUnKawlby47SVMpGQwQymYbUb89V0a9E8hBBDwX3AP2KakEmMYytfQgghhBAiYAHwS5gpyb3YS+E93ctOAiEhsJDpL8YEGndiEW7KkiwUStrr2YbjO8BtRTLOYtgeF4ewTc0om4W8x+rsrkBqFCu/rv3KVOu19qnAdXZKIEQC0Uf3ERyXFHqQq3YiLYQQQggxYMwDzsZ8nVwHXIwEQqK7RKftB73nGsykKY41mLPpI7BIMLeT7qQ4lj7M+OPMqlpFABPYNXlgr4MrvDnzykuYTtG4BUcBL8Iil92OCVwS04pcyHzgTOAEzN70RswMrvn4mJc172NCnbW8oGW4b317mcto7dn5sJaS+9iv1SMBkBgSmq1+8/UEEgIJIUSVqFcVw8X8+fM588wzOeGEE3Kdl7Tcu23bNm688Ub2799ftniVMjUFN98MX/0q3HMPdNtPuQRCook9wOeBL3XY/1TgTzGHoaGT4sO9KFgGEoe+jOOix/wHTQFbgI8509rLZEfqG3+i6RThFOAPMUHOhzGhcFbh0hLgfOANWGjnPyNGICSEEDVBry1CiEFESr1C9I6lS5dy/vnn8/rXv76yqHBXXHEFf/7nf147gdDhw3DxxXD55TAxIYFQH6ja5WwfHLrlzqdR7mnMj05rcgsxwcgBGoKJw5ig4VCRMnZhBD2ElamqpCdxbMtwnA9zTJkZ5Jk4LAo+B7FoZyuD7+Ok+wFywbnLMOHQaMY8k9JLJNU8raLMuzHr6qIjcyHmKv3UEhzD+j+H9ZkTWU6a/Zpc8nlB2iPYWJNt7JMjayGGmTq35oremYWoBaOjo6xevZrjjz++MoHQUUcdxdjYWCVpZSOu3O3zBO9hzx77JJ5bURuXQEikshB4BfBMLBLXOuzBeS4mdCiqBVMlU8AlmNZSHcrTSnt7zSYeGgNeAKzGQg5ehPkWS2Icc4x9B+aUukyYQs0lhBADQdCdPhZ4LbaA8XXgx1Qn792ImfOvwcab75E23kjSLIToFdJXEkIUQwIhkcp8TBj0G5i2SSgkOAd4Yr8K1cIhLOT596mnQCikebhOH7xHgacATwZuwKJ5pQmEDgGXA1fQMF8rwrALgzR1EmL4OAl4C7AU6yt/XGHaGzBT3JOAXdh4I4QQQggxyNRIINSj1880E5SMxYhNJvbtMkYdPSWPrDVRPIZLvvOnMB82V1JfIcEEsIkOfnYKFLroda7AQtgvwjR6HqRVABTiY7Y12A3cjZnohdyF+SWKJcYfcifHrpmvLcXasezz19uTU5Ks64NNvP9vIUQ8bg2MnATzF8KpwLPp0FftxzrZvcDRwIk0BrsdwJGY5GdB45Szd8PSu2FkvGyXETqci09lAxYUYCoo4s5SeQkhhpeKXmqEmOPM9al2jQRCoq4cxJxM/6DfBaHz0DaDmUa1+depSPiWlVOADwDHAP8GfBaYLJDOHcDf0qwNdBDYXLJ8Qggx1DwB+F1YvB5eDzwv2NzW19+JdbLXYyqw78Uk8H8PXNZIh3WNieLSn8L6v8OkNF3CBcX5LWwB4P9Rj7FXCCGEEMOJBEI5mKty9hlMEFFaGFFRBbqUhGL3FhAMJUqLO+w8AluVPglYm55tR/ZjQqHbCp5fmBwFTtKumeuSdiFEn1ju4AwYPc5zDCacD2nuqpzZlTnMKdCZmARmRbB7BXAG+GMjp+xwsLDVmXS1vV1YnMdiUT+XV5q6EEIIIXpL/bX3RvpdACGEEEIIIYQQZXAtf4UQIh0JhIQQQgghhBBi4JEwSAiRjxqZjNVfnSpawnqVrIUkDfZaFzwbPtZNcz0ubD/m/Pkg5tOo+VZkNy1YiudUmhvoQeBhYDzXtbbnmfx41KMeh520J0F3QYhkos7W5wPrMPOq4/bC2G2YvVUSd2E+gzzmtfmW4PfeYP8ezGZ3d+Sc+4BD1j7XAmdhAQ1yswRzZD0feCT4BNczEuwaJdJPtHYYrmW7Ogwh5hQ+5ltzP6BOQYh6U/JNoOImXiOBkBCDz53AX9OIMjYVbPfkC3N+KvDHwHhk213Ah4FfVFJSIYQYDlYA7wSeBRx5A6z8M5qig8USRhnzwI+Ah2hEGQP4OfCnLensBrbAGPAyzO1QbGTLNE4F/z5gPfAFcBdY3uE4sQFYGBzaMXip3veEEEKI0sjvae0FQkO6jl5S1Sgtun3uc3MdXVGdJ8XSdh3yiDnHu9al0g5aQykrqUlXmqfO9gA/67AvTzqrcDy15czlJDgY7ZT47EXEPXSd4sp3Wo5OzzLt6RimBe1C15/1IRiGChKiJInDROT7Im/CmedAQ+MmphF1TG4zpn4ZPWg2nXZGsLDwJ0RK0hr8OXGYXwE8CdgIXEmL8X7z0SMx57swExfkFXNhnYZRIURv6ar9Q4fE1fyF6BdlxUv9sZiquUBIiLnKBuAZWNyy64EbKLgWHUO4vOyw16hzwB8GdxVwf8LxQghRH87w8BTMXOzEMgk9FktoArgKMw0rwf4gmXuxiJNPx6zEZnkYuAgLJ3Y9MB2fzhHAizDztDg2e7jSNVu1CSHmOJqyCSFyIoGQELXkJOD9wPHAPwA3U51AKMRhryp/BOzCXivurzgPIYSokMji2VOB/w2swsx0CzECnBsk9CjwfygtENoDfAH4BvBqTN7UJBC6B/hQkPchOgqEVgBvBs7vkM8VwJ0eduvlTwghhBAFmXsCoRRzrSJmQpXhY/J2TX+KJdhEe0pRR8JRh82LgJXYnHUPtuq5AM9KzIdCLEsxuyaPyRcOmjPk3cB0JJ8FQdrRdCaD4w5ntquBBX4BK1nJGPN4NPjnZ7OJSSfqf69Vx7/zoTE4q6vCD0raidPAODPs51EmeBTYChwOzl2KvSy40XmwciUsarwOzczMsGfvHg4cOJChfAuClKaB+R2Pn63TtHsTVuqQWns2UX8/+EIMHD7SxyzEeqexmLY2grngWQUsL9LwxrwNQosiCY1gjp4LpNc6tViIBQdYGKY2go2NS1tOmsGEQjF5jrYc3sqRmC7peCTzSReOo5HyqF8SomsMTMCZvr7gCCG6QprLkIzMPYGQyMxZwNuAxcAFwCWYy4N3YnorbTjgacAbMcnF54Cr4Wrg88COyKEnBekcF9m2Cfg0cGuOMp7MybyDt7Oe9XyVr/I1vsakn0yX9pQcthvCoGz+dvJzF/B3TLKEb3MbFzPNDmzh2gHPBN4ALF69Cv+2t8OTnzR75r59+/jiF77I93/w/XxZel/z2YwQYi6xEXinbx4noGERsZESmkFHA+/A1HdOChLaUzSxZlYCbwdeCByDCbVYDLwOeAGNfnYC+CrwNRoRCHJwCvCHmGJTyH0ePu3gjiIFF0LkQrIVIcQwIIFQQKzTRgZICSBPCKuMbABeji1qXgtcirk8eCHwuE4nnQS8Cgvfe1mjaBe1HHZkkM5ZkW03A1/PWcYjOZIX8kJO5VRu53a+PptCWmWUNLLu+ixgG3AJ01hUsa/QCG88gr0IvApYvmQJPOPp+Fe+cvbMnTt38pOrfoL7gWvS+GpG05i+0IV2KsSwcqRvHydCSjuoXw48O/iUSqidJdjaSBPzgXMwoVCY1yHgdvIPfAFHYT6GovwcuNjDHbWcqAgheo76AiEGiOiLQofG24U2PTwCobjKyfjilVSvA9WP9lAdtKlelgGPx6Q8y4HvAPuwML450lnOMp7F41nDGswd563YI/o4YAMP8RA3cRMHOdghLdf0y6hIl46oKUP3n4owp1FsAfs1mIbVDQQORE8Kdqw4APdfhfvyJBxLIKnbh+kSJT0Iea8h20PVyzqqI5lUxyUU6gk+xrzRyXZmcPDYmHI2zeEV9wI3gNsRd1I8jwA3Bqc2pfNDYId1p2cA83dgEcdKEtu8JzAH0l+m0TlMArdRqXu4FZiMa62He5yNolNzu1sWomdkHdqLmJn5jj/ynCiEqB1tbbR3gqCQ4REIif6xHvgfmGPOi4G/wqQWOUOfrOdo3st7OcxTgP/AhBpLMMO1l/FNvslf8BcdBUIQCoVaBUPlzbr6NZ6OAS8DzsM0hf4E2D0CPAv4XWD/Tvjwp+HK/4RXYo5R583Q8uojhBCDQ9jhbgT/+8DpkX23YR1hDoHQ3cD/w5RxZtkC/AuMLIC3WFbMn6bikF2R8WccU5X9dmS3x+y9CpiLdWID8D7Md9/nPdznbIlACCGEEHODvG+6wyMQKvHGXh+HcFmdQHc+Ou3cuOw6mxU1UlmM+UVYhmmtNDESHHAEtuK5mUK+GEYYYRGLGGMpzLridJhzh6UsZGGLFlCH8ib4NU7U2uhADh/XXWE+VrWLidT9EZhzil3TsH+HOWB6GNiJ+Yk+HB6Ypv/WrSe+Pq2qaxS4LPl0rB9xmkRZSdM4KpN2V5gNUlC/NhnWVdjjLwCOWAij62l2IrQP0xxaifVzB0ltUOai3wIjzDIBbLfh6zChEXF7vUSTngzSmcFGqFmH0RlwMyQulPjI3/CywrF3fsY8CI5dG5RxJeB8IyhA/e66ECJtthTfvZXQgE1zsSlETZmZmWF8fJzdu6tbudm/fz/T0x1CfQ4oRZThh0cgJLrGQuAVwInAuuDTxDbgU5ip2C2QoMCTyDa2ciGf4i6+FUloCvhP4Bru4R72VqL5UsR/kG/53hu7n0nge8FnK/BA0sE3AX+HSY2uQwO9EIXI0nCKvlp3st3J2yfFpZPdRNTjaykUAhMG/RLmOH8DMePNOuBdwEuAH2H+d8aT09yIac3sjNnnMOvbLM6p7wW+hJmgvSj4JE+iinXCV2Mh6xcDv4xZzeXFR3Mv6TJPCFFz1L7FHODAgQN89atf5bbbbqsszU0PPsiOHTlUjmtOUc8Ic1cgpM4zM/Mxk6Xzgt9tVbeLZqeYBQURO9nFxVzMFU0JHcbim4Vb0hLvxo3tn2RlCvgp8Ekaq9gjnQ6+G7gn+C5hkBAFyOMBoio/XL7lb1q6rcLpPHnXf+Cb700Y9B5itFHBwsO/kobfnUtIFQgdDbw+Jd8sNfMwcCHWza7GAoZVjceWQz6NaficQzGBUDQ9IYQQYtA5dOgQV1xxBVdccUXicUkztLgxsXba3H1giARCOeOBVblilvk5ipmUZzw316OaZJdS4JnPZFhUUVvysSKfLjXUnI9M+snJFNUp8ti7T9O5DwE/xvxP7Gw5OFfKYUJ7SXbKIWOnVtJ0MwbnFXw4CdXnowN9kUF/tTenw2PA/UR8Drsyk4hOA1CRp6XRszhvvuWPpyE49sBWZ9otUz7It64PpQfmgTsRRtaDOxtzIxclOiDluI4sh6bdzRWYgGYdVsed00xOqbE3PoX1wNMxy+DVKWVKy88l/BJCVE1MW4yda6aYG1dTGCGGjqR5V9xy2WC8vZR6IY0lbxCVIRIICQHtjaoeXUD0/aV0iWaAKzAPqdOYc9SYvLIldDm2Hj0Nbkvy4UIMPGneGtpb6JnAH2LaGv+CGbDOgDkXc63plPGdldkbDe1THds2DzNjeg/mgycs0Vc8fMhFXM3X2YRoEabO83pMInJ0f4sT5RTgA5j7oSPpoMFUEofFDDgtSH99iXSEEEIIIdKY2wKhvi3hZxcJlJJsdsFx3Azm18Zjk9V5FKu+GWxSfSiybYL80XdnmGGCCQ5xiKm2UC1VSVwjHjlrolY4tRMO74z4jo5wCJMTASkPkMe0gh5pbOogUZ5NJrvHw3iG9C0ldzsd0nqoNa1t1wVuhF3r3XNNK1BLMP9pqwmc9AafsSCJaeeZxnXQbMxyo1t0OGI0m9LOaZwLqzycTMMnzgzmZHi0zkKgKKMweRQcOgVGQonLoZjjooNRiQGuWQSYnM48mv1bT+TMpz2X+DFqKbA0sqX58rNd6wxmclyPEUsIUZpuzD+TJi+9cZUpRCHyGszXjrIFq/jC5rZASOTmQeBbmBjhPMzXQ5GHaBPmh3ptZNu2YHu+dDbxKT7FalbzY34cIxSqGOf6LhTymM/oD2IOv1sZB26kta9IehMchLdEIXpJo03c7Twf9+bg92fYi/YG4GXAUcBPPPwQz2RbM2rd0O125pjG8xMHf+9NYAXWD1xPYV//PefQIbjkUti1C1xHh2nYhV1LvFRc4DH/c6oeIYacbg0ttX2TFkJUjQRCIhebMGeXd2JjxdMoLhD6NO2rppM503mAB/g0n8bhmA7+DTvhe9ANCftzi8UkExLDTJwQN6PGzN04Pu7AeT+rcXEM8HbMnOyDwE+Aya5pnHaalbdnNIPjJ8BPW7QZpynQJ/QDB4cOwyWXwGWXZTh+YC6sP8xWj/p3IWqPmqkQol9IIFRLSg4LJaT68zCXDcsxp5lj2KRyK+a7+G7Mj/FBLOLKL7AoZElsol3Q48mqbp9k9+bwgclYdJuLfK+CqBVVdcpBZXRxHdPQWfSV4qu2TLjpuHN9wq/2vKuhevdr1VCHMogY4jT72swjXeyuGe+th3GNNnvQW7+2AOsXO5m65nXql53OZmZThEKAavT940zXunddxtSUfTJTs4Y35s33z3IgvAfhOLoLaDJDbqNR32PexuNlBcrgsWdzGzAzKOaCQgwTCd1vVc2x232xEHViKJTWYi8ipR33oJlLICSaWAm8A3gOsAaL8HsQuAj4GrAbi7IzBXwHuJWEMOgBjwTnlaeqqDwlaZIQlUqobAJCiKxUMnG2NO538P8w/0IPkl+zsUieVZ6b+yUiFArp5SMTq4B3A8+M9O/7gE8C3yB7r786SOe8AmWYAb4KfAY4UOB8IUQ6Qz2LG+qLE0JEqblAKI9X5BIT1TKBYbpC2QIl6U8k1+N84DGYbyAX6IMcwjSDfkjzSvgDwacQJV4ssmq45Mkiq1PgGP+z+OhZiQnEPc+dCllXHZh2muu5nmUUc48kp8xRgUjace1Op01L8vq2DJPL4CKf6Cm+ZX90W1x5YwnyiebhiU+rrVx5OkrvB1Mo1OEWJ92PjidkYAFwOjaOhuwCvp7t9KZ0zmhJJyszwE10JxKaEKJBLrlJXfvPuOlpdmtlCY5EV+nu41X1+1Ye2UVOulgRNRcIiV5zALgUm7xuBJ7R3+IIIUTf8N5XppJ/AtafRs1/tgBXYv3t44FzMGHTjzHNo7yMtKRzJfBQwfI2EZrc1fVlpgCrMc2baFT7fcBVwL0l094PXAJsj2w7ANxGvvncPuC7mKlZXmaw5yhPJDQhxAAxPN2xEB2RrLE3lBIIOedWAP+G+db0wDuBO4D/wua/9wPne++rsRgSXWcvcAHwFeAVwGOBI/paIiHEINPfcSKjtmWqf6HyPMZ7fhe74JBrgHudYy9mpvu73rMJEwA8WKAMo8BzvOf3sErdAjyU6IYtjxrlcL19rMPMsaKLHg8C/x/lBUJ7gC8CF0V0Bzz5I73tAb4AXFiwHIcJQtYP160TQ4jeJ3KiNi2EaKHMNC3N/UsaHwK+471/DHA2tgD2AeAy7/0pwGXB7wy4mE+e/dWQqjLeJ7p71Q08FrZ8D7aiOYM9JCuBY7Ewy2OdTp4LxD4gvbo7GfExnwEj7hLiLqdmNZ+ZuN5sUK8lAxWOE9XgvZ/9dDgg5liCT+N7HqYwzZF9kU/Yx4K9vIfbpjqWIf4TpS2dFNLSDs3mop9hYAYb66L3Yz/VBC2bcXDAwR4He5xjj3PsxTGRqYU3eoIZ5zgQnB//of1D45NXACVEH6ndOFGamMG90BgfM+C40KlD2mSiGxOMAZ1XisGiu49Z1hekyHE+5lMjbGpWvKG7JP8JyRm75Vjk640+kohz7g7gOd77Lc659cDl3vvTUtLyzpWVTVWEa/qTicbVV/9wxE2+U3OJvaedveT4Dj9eg4VUXg/cgq2a3gp8ioK+gyp6j8gcJasLPoRi/YQ0/Yg5wIXpu9njj/eeDwKvTsloHPgr4O8heJkoiIt+TUinw65evwJmbUnD8WqazMzMDN77gbzUyseJkezjhGWX5qtr9uBsibrmH3kiEK73nscBSyPbdgA3BRpCpwKnec84cCMRc6NYAUzzdYVHjACn4HmMN4HQDcAjuTWEWtLukQCo6FwkW+Ltm5Zjb51HRrYdAG7GAifEUqYqMrspyDX7yJXPsAjzRDte40R4jh/JMU6UobXL8pH/O5F1/po2r5xty92440UmYPV6NxZDQO/9BkWJeSuMHVvTGmDGMTqNDC+pDYFQ9HczSe8TZUzGTsQCSH3GOXc2cB3wfmCt935LcMxWYG2JPOYmZSdtiedH32DCLb51UxPzgScEnyOBL5UrnUikYBeYOjAP5DxRDD59GydaB0eoYEEnQb4Udrud8tjizISrE7cDtzva22+b7544obPtn/ae23Hc7jJeaGLanr70G93INia9vVighKZ8Oxybi8R0spgw+pZ0Mhao48Otvl/UnoF8n4hfECgvJem7bCVpnSDPOVnOEyKGejw2KcKgrOdm2FwmySj9MhmbBzwR+Jj3/gnY4lqTOqdvXqJtwjn3Hufctc65a0uUQfSYNcALgddi0U9qotc1JMSsAvWhFEJUiMaJWarXbOwufRIGhX97NSNszatovqnptEn6MqaToUCRY1YAzwF+GdOAmleTqbUQCWicCBiq1jpUFyN6QS+H/mQiCzNVCIPKXljKuVUo/5Z5n38IeMh7f03w+0tYh74tUO0k+Ls97mTv/Se890/y3j+pRBlEj9kI/D7wt8BLmOP+hIQQaQzGONEzU5pW++7WfCOOJirNR8wVNgDvw8yMXwMs6m9xhMjCYIwTQghRI5yrbvpaWCDkvQ8CobjQnvf5mIuZi4G3BdveBnytVAlFG5VN8wskNIpNMJdipmSV4hM+TYc1/lWddSo9eseaxMJG78GixPgsmQYX4YDFmCPwpYSNvFGZ3aq7DrerEN3wgyh6T3/HiZxPUTiyJn5ak8meR7tDZte2r2l/xyQ759WUzuwhHdLMmXZfyDgmjHjPEu9ZGfwd8S0HxzmDnE0nRw9WIp34fjn+ohfgWYFnOeGiS3olLMS0g9YAR2NBIFYk5iNEPRje94kSM5myjmuT+s60Txxxl1IkHSFimEuPzAiepXhW4lmMb3LbUoSqAn6UCjuPLUR9wTk3H/M5/A5s/nGhc+5dmO/h80vmIWrE/VgM0E3Az6kmIksmPLV5R+kF92Chhh8CrscxnXZCpD9ZjDmrfgbml+RCzPheiD4xRONELzWJ6pxevVgOvA7zc3c98GVgd19L1M4irF8+D4ulfSHxPqUc8DTgl4BxPF/CcWNK2mPAizBz7rXA8RWVWYgeMkTjhBBCxLMGeD3wWOBq4KtYlNM8dEOpvZRAyHt/AxCnovn8MumK+rIF0+W9ibkjze0HDwMXAbcWkB0vBJ4NvBOL03opEgiJ/jHI40Scj+fUc5xri5il6E7dZSkmDPllbHz6LvUTCC0Engn8GvADrF/uJBA6E3sb3g1ci+fGFIHePODJwLsxzV0HzFRVcCF6wCCPE0IIkZXlwEsxtysLsflKXoFQNyirISRKkzzR85mO6nBSTDZx8Q+ihy8ATgaOxHNm8HsKx71YKN6bsAe328KgozF/RdEH9BEPdwOHo5EdgpLEhvKMFrLM+1iOi10BnIKtBj+AaVIVqSsPzOQUBh0FnBT8PRpbWpu97IrqIrY8Cc9bleiVWpSliGCmyHOXlE9aGaoSHrm4Tn+ICa0YjsI0bI7H1AweLpKY9xyJjYULIpt3Y2PQQeC44DOO5y4salnWMs4aj8T0yx4ba3+MjbU7gvK0p9T4Mw3ch0VNC/36zQB30UMtXiHmNEmztWzz/DT6srDQo/mdmDv0T5mgQM6pz3pKmjG7x4GbMWuOO4CJgmWquj+QQEg0sQJ4O54XA8uAVdjDexFmKraf5NDJVeCwldT3BWUIuQRzlFlnbZdTgT8GjgE+CXwG8weUn/wN/Rzg9zBhUK1iswohRI94AvBnmCDlnzGNoSIT0Cdi/em6yLafAn8DPAi8DHgXJoj5ayxOdhV44ArM3HeaTuNtsw31JPAN4JrIVg/swoRXQgghhOg/jwAfB76ALTLVQTsIJBAy5oC0O/YSY2bJ8/Csw7RcwFYZx7EJ8C10WQ09MpNdjmkIrcQzhjmzvgszDVgQKbfHMQXMOB9JpuobGr9E4mP2L8VWlUNNnXwlKVfu5cBjgA2R8ozgWECo6WUvGEXUznzbl+FHC2NC9Jg8NnreM4pNYhZgYwRYH3wCtpiwPGNSYTpgwpWZSDrHBvtGsRBHC4NirsV8AMzDFlIWYP3r1OyFtBQ3SPtQJI9O7Ao+yTSEQt45tgflK+yEVgjRdSpvnXm0v6PS4iqIy0/dj6gdRR7KrLP9zBOW2W+TboSH581jZMRCPozSmL9kKY5z7W+509PTTE2V0weWQEg08Sjw38CdkW2HsdXPXvXzHnMM+kFsdfbFwBmYsOO9QRlD7gO+DWzrUdmiZawnzSU7EfNZsQVbdb4K0h1UCyHEAPBEzMHIWuA0bM50O/AdTJP056T31Q7TrnweNtZ9FwtvdBvwL9gY9HzinZuACf5/FXMW/TPMb9vhmOMOBuXajgVn2JF+eUIIIYQYIlauXMlLX/pSTjnllPSDW3GhbKjZAcwNN9zA9773PQ4cOFC4XBIIiSb2YXE9v96yfYreCkGux/wVHYcJNc7AJvwntRx3BXAtvRcI1ZP2O3QC5mj0APaScjUSCAkhBh+HmYe9HwvlHk5mbsfUsTeRzX+OwwRL78cWG+7DBEK3Y/6CVgWfczqcfxTwpiCvT2C+f+IEQocwYdOlWE8t3z5CCCHE3GLVqpW8/vWv58UvfnEl6Xnv+Y//+HeuuuoqCYSqpPcmIcmGKYXKk+RfOVWq42oxUZ3BHG3tx3Evnpsw9f+jsSgqIStprAxvx2wzZ0JH011wwBc1E1sBrAfGInW6Ec/CtrOylWMKW9XehTlDjXupCFmDrYo31Aw9yzGzuriV50NkMUHoTGvUpFbCK0yr89h0Ys6pq2lWVX7KhRDxjGJaOasxQfZm4FAH04Q9WJ8X9TV3n7NxY6L14A54zI7/riC/0J4/HIPGMeHSTVi/fCjYtzXYNj9y/DaSBO4xY2vcdZUdtxTRTog+UFG7K2PyWWbVVt2GqJj+WlKUzb177dA5x9jYGAsWLEg+MGt23jNv3ljpd14JhESt2Q18CsfX8DwHMxmLOkw+BXPivBv4D+CL9C7c7hOA38RWiEOWYy8zRbqSA8AFmHPQ3XR2nj1CI6z80mCbx7zW/z3NJnUhM9hLjbSDhBB1ZhFwPvBKTODyIUwQ04oHfoT5t5udyDjYgYsJOd/ZOVGYTtg/3tty/DgWUOGHmADqYUx4/y2sz41OwR5GTpyFEEIIMVjMbYFQXSXikRUC79qtBePPidnW6+uLi2lfMp3D3lT3HY51eA63JL0CzznAIW8T9hGYXSGNaqPESk6bnFO3Fzit+o4EzgU2BElF474cIq4K4iqlsW0K8930I8xZdhwOu8YNWGjl5bN5Oh7GfGY8TCOscViupjQySpHTtIKajqXaxy3q97p4MNcKqUP7EmIOMA9zzP/M4PeSTgc6xxaSol5GvTAm9VDWd7aHp7fjpzDTsbtb9j4QfDL3Dan9RdVOLIukLYSoDt/0py8U6osKHJvWD9bX8aaogP7c3po9VInFcR2+14e5LRAStWcp5qzzJEwjZ2ny4X3hMPATzO/EBuxFZhFZmny+zmwN8CzMTG0Z8O9YdJvzMD9LIQsxYdHpwEOYgKl9xXwwqFl3L4QQQgghhBBDgwRCotasAN6ImQ+MQYx/nu6RVRgxDlwMfA4TzpyGOXOuJvUGR2MRw54MfB74f5iz0zU0C4QWA68G3gJcDtzB4AqEhBBCCCGEEEJ0BwmEqKvyVkCocRrVfm/5Gzkslai10KxZjm/fVoguqHPMYAKXvZigYz6BWVhA6Cx5f3BMpyKE1k+57nVMYvMwR9aLMEHMaHDYOOZf4gDV+OlZiJ+NnLMX8ws0imMpJiQLP0fQ3og95sdib4XlyUrU1CuenK2t0w2tQaONWtQlWeFlCXstxDCR0Xd8t0sRs60LZllqwEKIuUhaNxmdEHbTIlb0hHrcmi46Xa/IxNEFQX6WYYEpdgETAzBRkEBI1JrdwGeBSzAzqLdjgpiQu4FPYaGC76D7oXxXBmUIfQetwIRBVXMK8C7MgfaXgK9F9o1gZmlrMK2pM1vOPYA5Qb0Gi7y2rQvlE0KIRNKlwzUmzXuZEEKITFTtZFKIGjMfs2p5BRak4t9o90FYR+aeQChG02YgiEyuY/vWjBcTP8Vtcb5Zo3nwQWeCDYBR73gDEHW5/AhwGXBzVkfJwd+i934RcC6e186m51oEQtU8VUcBL8RMz26mWSvKYU5XT2q5mvDXBOZc+udNxYq+4CSMziWF762pzmpmJVRLuKtGj11lZLmmNqff3SiIEN0kc8caVUd1LefkFcKkZZa39bWm1++eqcp89UYmxMDSe/XK6knqauOOEaKNAg9InlMqev7mYQv1rwauB75STbJdZ+4JhAadYF7XteldjTvkh7CQ7OuBszBH00UpXn9+9v8HgRvxbMdxL9VW3TbgO1gks9sw07lGCRo5HQBuwLMZxzUkhTxuLV13XxBaTUZyBCwbGopesl7dxCCxwcPjgcVjNDrmVtmOY3aD93DvvXDzzZ7JiehgZvsngOuAi7AIk3u7VvLe9onZaZRrMVa3GzocuR0T/D+aOd06XJ8QYk7TuoAwB+eHIg9dFgRVzBRwIzaHuR/Y2b+i5EICITEw3Ig1rtXAHwEb+1oaK8+fA5vJOiFPJxwf7wL+DvNRtI/OpnA7gU9jJnWh3yAhhOgVZwH/28MxC8G/GngrsyqNcTo/MzPwxS/APXfD3olgY+Sgg9iK2ncx4dBcdoi/CngH8OIO+68E/oTqxh8hhBBCFGcCU164HJhkcOYwNRIIZdEnLMiwLYr5pj9GzDVm94+VIkot62irTP1H8pvGXhYOEiMgKeM/tCDjwJbgEzKJCWV2YeXM48Ms+v0wLpPvn2lMKLQ55R71zJ+fb136yV6QuF2+j203z2OfuL/As6kFM1Fnohp/o5gp7WLnWbQCFmwAN9r53JkZWLESRkbi93tnDvr35CvR7Lf53sozGmlkk1h/PV02qkAMo5gmzzzgMNn6/fh0PIsxv3Ahq71nHXBMh3PWOFenSZwQc4pUzeci89IS87dUqponVzVB0USnVtTvdmQsUc0K7nHsZfAW6DWXEAPDmcDrMJOxp1BPOd89wIcw7/I/p1cRvupYE0KIocfDLZg241GYI8VnZzitmz1WOE6simy7A7gQ0+bMRvYZ5jrgVzBLuR9iAQA6m+52Zj3wBsw/XMgRwBkF0hJC9JaavZMKIUQu5qxAqL+v0IpgUoSNwBuB4+j3/evMw1hUMNAdrgK1FCFqStAw78NMeVdgwoxnkdw/d7vvjo4TIZcD3yOPQCg7q7FoIs/ANFe/TTGB0Grgl4DzWrbXdawTQgghxHBQU4FQ9+ySypjOVDsxizWQyXhuzHFNFnf5Qo6l5tpBhfX44HMQuJO8Kv7RlFrza2S4AAvBfhS28ruI5ohbISP42fIcwHzw7Ek1+kmpp4jDuw3ARjyrga3A97EIZ08Ktt+DCYPAJdZnFcKN+FInX2u8QWbc1i6LX+Ie3RRzxzIly2OyJ4TIQURa64GJKbjjTvjBDxrmYJ0iD95xB0x2coxWASPYmNAoqmsUaHZj/ta/EhuPlvqGa/+TMG2kEeeS+5OYzmjENcbRU4L0O1jSCSGGgozzzkGjzCuNELMM2kPTB38lXaKmAiFRd+YBLwF+DdgE/BXwsy7ksxJ4JxaCfXnwu1N5XhYcez/w18C1FZVhBFv1fh/mI+LzwEeBpwG/i/mQ+BCmGTRoXZkQQhQmIq09eBC+9CX4/vc7HBNh924YH285ZgA6z1OAP6bZrGshZu5VhDHg5di4dUSJdIQQQgghijJEAqEYZ7Zxyic9KUsanRxoJ6hKlC14xRfuMOHMiUHiy7GJcTS7SWAGl5y3i+xscVQ6D5sknwA8lnQzhJWYucAUpkmU5qfcx60gd9i/Cjgdi+YyjvkKenyQ32JMg2lh0zmOKcyHkCeuChytRQR7QVgYnDcZe545LAv3HyYMSe8Z8Q2HpGHeWanu8XBNfyzx/BJ0n3ZOHQTwFZWhgI9JIfpKVLkmbKozM44tW2DLVojt8eI0ciprx42EpvEcAg5hY4j5t87fB41g/Wn0qFWYUCjOr89Mp4QSGrDDxo4zgPmxBySXcRTTol2I9fldVLoSQrThI/+XSSbNk3QdJjwR8moDlQ1MIyqh3lU/SKHl612TRRkigZDoJdNYyFuPTZqfiWnRhOwFvgPcEms0kM45wPMxh52PyZDCFObQcwqLuvVA7hzTsA5gGfDLmIDqjOD3GPDSoKxhNzGF5wocV5JdMLMoSGc9JnD6JmaWFleSn2Fma1sxcz28lenFWKO+FLieYe22hBC1okbvK7cDH8H64xcATy6YzhlYf7o8su0EYE2eRLrcAZ8AvAeLdHkF8GN6FchACCEyUuw1QAjRQyQQGjYK+EUowjRwFXANNnH+O5oFQg9izkZvKZC2w7RvfhvT+snykE5jk+GrsbGnWyuly4FXYc4/wxVkgBdhLx8hB4EJPD8JtHmysBB7AXkhJuy5ms4CoeswM7W9NK71dOB/YCvG27AoZxIICSHmEndgAvWVmPDmSQXTOQ34DZpDvju6M2kq2k8fD7wL01qdwMYMCYSE6B2aYwkhhoHhFggNj6+nFiq2Vekwoi3HswETfGwFdrTkPR18prAHaUHk3KWYOdXZmNBiM2bilJXdmObLasyh84rYgjdfQ1ieQiTWRfPGsZa9LrJtH3atezFNJd9xaSTeiCxskGOxRmwNVmEvLPsi2zZi9T6CmRL4MNHYnKrH5Um6i+0wwy3MXY4yctY4p9kdj9XsUgwY8W2jSIPJaR/tbXxYT2gWFiQRFGiZ9x19ziUmGjCCmXEt6LA/mmVelmLj2nJgbcE0wAIohOPNjtjSCSG6TqoXiBq/ePTqPUmdU9+ob9UPkplYlsyzvOs5Dh8+zL333ssNN9xQTbGABx/cxGTJSB3DLRCai1Somnk28FvY5PWTwH+TvS2GzqBfCVyB58M4tmc812PmaA9ik+bfAp5NrYfUWe7ENHfuwcpfvHl2vpEjWH2cQLMA7EjsBWMfdR4AhBCiPA4zVf41zNcc0NRtzsP6yDqOG6cC78cilB1D8YnYHcA/A/dSdrwRQhRCky0hREacgx07HuFf//XjXHjhhZWlu337Nvbv35d+YAJzTyBUIg51Rx/FiQubNZmOZnYC522RFRMwPAUTMnwLW4WdnnWbHOeEucF8Gr5/tgOL8YwEIdl9p5MibAk+x2JmU60OO2dD88b4Em+kGeOwupOqR8pz4THhy0yQdxgUp7VcuzFzrluTk8tIvFDIYYKyDTFHz9BwZJ0/r+4QdSYbd2s6nNSt4gghakn+Pmg9cC6mMdmempvtE2fC1DN0K+H4lzX8e5GecwXwRMzvWxn2YOPNbSXTEUJUREUaN8k64jko0kElzqsjaJqWmV5XX73llIOmGVQthw4d4tZbq3lLrJK5JxASiSzBVl1PxjSEjsCEO8/CJsgPYc4rd+ZI8yTgLZjZ2dXAzTnO3Y85p94a2bYAC/l+Zo50yuCxMn8KiwjzTMw8625Mk2l/5Ng7gV0xaVQVLC6pjHcF5dmGvSAMUf8phBC5OAz8BPNj16lfbuUI4DxszHoCph1bZ/Q+JoToGnIGLerAkLzMxEZarRESCIkmlgPnA6/B/OIswsaDl2POjq/C1NSzCoQ85nR6IzYh/wtsgt4xRG8Le4ALgC9Htq0E/g/lV1ez4jHn2TcCx2F+KzYCvwD+HvPhEDKFOZSO0mpS3q2+7aZIeQ51KQ8hhBgEDgJfBz6LOVxu7ZfjWAH8CmbqPIY5+s/KkMxZhRB56OakTggx4LiBMXgYQoFQnp455i5l9WfZqxtcYqApcqoDFmOCoXFMuDCDCWGWYyumozlTn8SxF3N8eTjhzDFM2LIA84OzJ8h7PObYh4H7Mc2hicwlKc5E8HmUhnPsCQiuqxsPQ/40J7HyPJqaWpw+cEXE3NxSc6UUZ9BxZpxpWs51YxDKKISP8Xje3xWvDkbcvvHnIDaOJI/XjXSi418isTbjBYjzIh9JbgrHLuLHQIdpg7YGa5iPmdAtiCQ95cycOYtQTAhRMdF2HvaZcyGCRJHJWLfV6WtEGTOyTufWt9qyB4uoF9UUqO7aQTCUAiFRFTcDn8YimbwZeEmBNBymufJpTIiTZMp0NPBuTKPou8AXgrxbGQe+BFyLRVbZUqBcmZkLg3YF1L+rE0JUjfe+XhOdPs6Iu1ELu7Cx85oOeW3HhEJRNmCOth8T2bbdw6cd/KwLZRRiTqMpoqgJehTrRZ2mRlmQQEh05GFMMLMX89lT1B/35iCdB1POX4b5b3gWpvlzES0CoSCDScx868a0gpRV48rqJHzQVFJiCB0Y+gIXUJnzw24yAEUEcjh/F2LYyLk03Jc2XW2maUPHOCYM+lqONFdgfu7Oi2y7D/h23sIJIaonZZGxqwL2Mkm3nhuNEBN64m+9tDIOrYeMrFO74bn8QXUcXZVGUPh3UF4+sgfSEEIIIYQQQggBg7PYVCVxgp9avMyLejC3hUGDigRCQgghhBBCCJEDF/43FwVDQoihYY6bjOX1clbg1CFjHqaSviqybTnmEDqN0GHngg77s6bTRF6vbB39kPpgU/KoPoM5vN6FhZvPGi2tCqYwh9E7seg3YQS4kPmY8++DmKnB4ci++MvuUBlziKrda8/RbkEMMFFn0WPAEsLAAcY0Zro7hfXdi2g4bI72MUXyG8XGhPmYk/4D5OtTD2F9cdrYUoyk1lyuxwgDAESjdYZ1MQ+7roOYI+isQRMWBZ9wHFVfJESXCcxBHPFO95NPnZtzrkFmwYIFLF68uLJ7NzMzw/j4OIcnehEap1sMqjZQlDIFGp52PMcFQiIvJwK/TfNEdhUWhj2eRmNZCLwK8xEU14RWBemnJNNX9gD/AfwYuJf4iF6teKop/sPAxzF/Es/FQiMviuw/G/hjzMnoV4ErK8gzjZrcFiFEWbzneOCNwLGRzQ8DFzjHHcBTgNd4zwRwkXNcVzK/ZcD5wDnA9cCFOHZl7FQ8cDXwf4H1wOuBJ1JVn9TdGes9wD9hAvyQY7C6Pwn4CdbPPwLcmiG9MeBFwIuBtcDxFZZVCJFOvSM8ibI453ja057GK1/5ShYvXlxJmrt27eLCCy/k5zfcUEl6QpRBAiGRi3XAa2K2Z5mELwCeDryLzraKdR9U9wPfoz+CkJ3AN7CV5EXAS2kWCG0MPjuwl4gfU++6FELUhGB1O+zfz47sugX4IXAnFrnqVzENxOuCTxmWAM8DXodpnn4Tz64cvettwO3AccCTMYHQIPAw8OWWbWdjgv6NWP/975gWUZY+fB7wJOAdmLZVG5LcC9F96j6BFYVxznH66afzlre8hRUrVlSS5qZNm/jpT3/KDTfcoMdG9B0JhEQusptKN446Cot4Mo6tPI+Q7LyqqWOsLIJXzMlNFlNZomy52fJ0v/OON2bymElFnA+/8MheOwaLas/m1JoOEiiRd8b9GmyFgAXecwqmRQJH4jkV090E8JwJHEFzuzqCAzyROxllN6d7z3zMpAnv8c7FNvqVwKlBWg2WBltX4v1DwN0cyRRrKeiCw1uI9ZOADXiOBMBV19YzmiPvB+7ATNfuwEzrsiffSHCfMwHbwSCdyaYixNfOSjynYfV9IrZY4JJPEUJURC0CzPajnWfNc8gmXs45nHOMjFQzy46anvU+wGwPbk6t73/WuNl5/ZIMLhIIDRs1fE7PBv4U80URTv4Hh8EqbS9RzQgxWKwA3uo9LyUU//wRJlYB8CzGzK+irOMe3uv/mgNcw0rMz82sqWwoDGrxqbDRe/4QOK0lJXgvpstyEZ4PMcajrKNYX+KwhYb3AWuC1KMGuqUC3+Q48WHgw8C1mFDoYMEsNwMfwuo3azqnAh8ATgaOpNn3kxBCCCFEFmokEEqbEvZY9aBQ0jmcH+ROuwt0UX0imuSy4JN2WTPYqugU5kjTtyQ0ip91Oj2JCZgqq6ymVe6WNDtkMUrgBNs3yjMSlNFh1zFVZRljSE15VtGo2jK4SJrNj49v25a2CpKeUXk6JeNb/pbNsht3utaLLGKgGMU0Nk2bZAljHIfjeKwni+qXeMIebIzDrGMhM9iEIV3o4FmIiZmafcKNYeKmjZgIp7HKOk58nz9Lh4a1CjNjWxW/Oz+pja3R501hff4ezCdQ1NeP840ajfaJSePWIRz3ZyzkGHYvVgGnAKfHHmV5TWEaXdOZ0hZClKIbakNlJhb9VHDovdrLUJG9+mpQqTUoQmdKBJAq0lgGdLW8RgIhMdfZjvnIuRdzMHqoZf9jML85C4BLgZ92rSTZ3ECfHpRnLCjPz4ATgJdjE/UrgB8xfBPxbohuhRDdZx/w385xJ3C6v5OX8RFWsBZ4AfBUGq17GnNLfwU72MI3uJ/7MD89L8yQzybg3zDhU4NHMJf8PyKuh7+dbE7668A05lfpR5iG0KaW/cuxseGxkd5wnMY4UYZFmAPpc2iI1jrxM+AyLNDAnSXzFUIIIUQKVUUS6jESCIna8AjwX9hEe5p2QcppwK9jnii2Y5Pd7gkf0lv0acBvYBP07ZjJwHGYY8+N2Ir3VRQTCPVLqJLmE1HCICEGl32Y0P1bwCvd3TzD38sKVmAi7KdEjpzGYl19kJ0c5EKmuAILCPDM1kRd+5L4Q8DnaO0vdmA9/AhxPfwM2f3v9JsprG//ICbWai33MuDVWFTNkF00xoky/WQoEHoHpoHUSWPLY2K3D2NaTMO2MCGEEEKIaqiPQChVmhZzQDdNr/qoZllEy7JI0eLSnATuB34O3IcJNYqlF+8UOe38yYQ8H8VWORcDu7MkWEB112F+jtZi5l9J556ERclZGBhdPB7z6bAMi/SSaFqxADgac+oRMoUtN+/MVtZuEW8NmXAfk6up3sT5Gg8udQAF/EK04z2rse4m2icdyxHMZwMmDFqNPfH7gYeYYS/beYhtHOZuJtmN9ctbgZuAacZYzjE8nhXsZS+b2cxEpOf2zvrypv7Uh4ZWDSYw3zl7IpLoUcywbM1sadq1RbvFBDbu/TzDcWG5JiPb12D1fAxWo9GIX/OJcfif0snMx7OB5mFiOVafsem1MB2UNSyj+jQhekg4byoUbaMqauYUV6uKpShkhTcn6zTPRWtkhDoJhEQt2AN8FltF3okJXhYmHJ9OdbpzN2DOqUcxoVU3+rgx4GXAm4PvSazBJuojwBuAZwW/12XJaBXwbpqX2/cCn8Aqf8A68AErrhBzBgc8Dfh171kW2b6as1jJ+zDxxfHBkfcAH2KaO7iEzfx7IAy6B2vjV2Ey69Ws4KW8jV/lefzQ/5CPuI+wjW20SuHnAS8G3kJ8OPTtwEeAyyMdyCLg9Zh2zU3AP2FmxEnXVxW7gU8DF6foSs4AD9Is3nJYd/5rmDBoYwXliRsm5mGmyZrCCiGEEKIKSgmEnHP/E5uveOBmTIt5PXABNie6DniL9z6PokmOAnQhzTn+ZjuB+XKIEhUIhWHPoUOo4OjG8MBYbaGshkl+NsldwSfc37o6GucguJFknIZZ+5EjwLHAuZgSTxwjtJpWeU7GIr2EpK5oLwDOoHmmvxO4OO3EZjL6QM2BS/vayHuQNYOSyK/cJhLo+zghWIv5/1kNjMz2qEcGW4+n0bPvAa7HcyMPAlfTiHY1AmzHsR3HMSzirZzOeZzHDnaw2C9mxI0EQd9DJ8qOed5zHHCus3Ek7DtDHgzKNhopwbygPz0vSGNJ4avOvzJ+2EXHv+xBIkawa9iACd+Wp/WKiUk3xrzFtA8TcSn7yCdkJmabEHVl4McJ52xeGG1wZRpfRZo0sb1gHZxd50lTnVgiLqbS/JyttDIOpOc2hQVCzrkNwG8DZ3jvDzrnLgR+BVOw+KD3/gLn3McxtwMfq6S0ou88DFyOraQ+Kfg0mUadic2IJzGPm3eXy28ppnlzcspxU5hvhuso5ythCnNW/THiG8cybHJ+Uok8hJgraJzoPx64BXPyvJalnMd5nMqpwFnAEdgywE8wfZx7gB2MYqKi36DZJMrcJD+dFazjZE4BYCMbeStvZZffiuMn4G4Gb6sBDhOWfBJY4+A53vSRQpZiGkRrsaHih92ogC6zBng2dl3nEa8JlQcHPA5blAhjsqUxjfnUu47GOozHhuB6vj0L0WCYxonZxcK5+j4uhBhIypqMzQMWOecmscWsLcDzgDcF+z+HWfnUugMX2bkf+ChwF/A7mN+cWYGQw94i/hg4gKnzlBQIrcDMsV6Zctxh4B+BG8kjEGqXEE/h+T7w49i9pj20BgmEhMiBxok+cx1wi3Ns8MtZwes5lddiRrGLMFfT38JERhPAQUYxIce5RN9rHLYE8AEcq1nIQhyOMziDEzkRzx7gL3D+5tlzJrCb+tc4NgLH45sEQsuB84HXYMqRN2F+gwaJtcA7gWdgNVrOxNpq+anA/8LGv0UZzpnCool9mIYAyAffe+V/SYiSDM84IWGQEGLAKCwQ8t5vds79PRZx9SBwCTbv3OO9D03rH8K0qNtwzr0HeE/R/LNQme+yjJpl2TUdk3P2vpFSaOnUK+W2UcxvQaim77A15GXB92lswr6XDhPN+cHBo6Q74cnATJDfrqBMqzGTglYOAQvy1lK892QOYwKmOJOy5bSumAvNfkQnBmGcGFoi/dcCYIX3rGCG+YG0PpTZT7EPC0y+l4WMsZp1zGc+C9jDAvYGZmBhKw87+MXB2fsZI+zq92E9scfEIqs4zHwce9nLXvbjmQr27sO0TB023iwPUnRYn78DW3zYQi80XMrNFEaxsWlZntAPKWaph7D6yRp17TDm8HsPGp/E4DEM40TYlCsz1fHRr+1pxpkJ9Zwil5q12JpWliL6fAyv+ViPr2vIzRnLmIytxPw+nojNQy4CXpL1fO/9JzAXujhXmUWrKMkK4K3YamfIGObHoB/Dz25sWehS4OnA2zHPF/FU58BaZEMNVyShcaIenOs9vwocxR7O5PPA9/kF5kB5O5M4bgM8p3MS7+bdnMgxwFeBLxEvYtgDfB7TpQyZBG7FeoWNmDuQY/B8BfxXCEU7oXPqL2CCqndgfXvIQeDLWMj0nZhQKDuu6dsgjgYzwJXYtWddU5kG7kCh5cVgonFCCCH6SxmTsRcA93nvHwFwzn0FkyOscM7NC6T6x2BRZXtGPyeAqb5oCwxTXfVvG1OehZjV16sieUYdKGe+hA4Htm5Ou66DOH4afJ+H5w0d0vFN3zqn6nDZpeWJodYHbc6R8UnK8KD5mG9CdKCW48RcwnnPCcDLgVUcxLytXcsWbBn+gUib3+FX83qei+cxOG4HRvGxAqGDmNea/+6Q6xrM2uMxwG20diz3Ad/ENGte3HLmJI6bMPOx7MR1XNk1cuLJOk4kHV5k5HbcS1JkNfW7YujQONElaqFJFMW3a6y4pLl2K1lj04hZ4urXD9w7TEgNtII67Y8p2iDFqCkjENoEnOucW4zNDp+PzTR/ALwOiwzwNuBrZQs5aAybnsoENjm/C5va70k6+C5sefcwFkImQlXN+HBQnrsjM/EJ4Be4rq+QjmOOOg8DxwFPIIOPh1o9EOUKk/ce1uayRb/QONFnvHPc4z1fxsx/Q34GjLc00Ed4hO/wHe7gJs7gZs5gmv2Yts424CTu4XF8hQWMYu9nb+QhHuR6fs4kEzyOx3Eyp+A4HdM3NRyOvcD3scAE1wITzjEC/NibyOmnWP+ah3C4OQrri4/NeX5RRoDHAqdjKg2dtVatAfwceARzqTeo03AhushwjRPNYWhFhG6Y1AlRN2r12peRMj6ErnHOfQmbK05hc55PYAt/Fzjn/iLY9qkqCir6x0HMeODzmG+DPbSHfAesBVyNWQ3MYI6GulSer+D4D8KIKtbs9pHuc6HsYLQbq4eLcLwCz0ayOf0cRjQeizQ0TtSDa5zjNu+bJiiHnOPRluPu4z4+yAdZyjz+B/s4lUm2Af+KmXm9ias5mVtZwDrg/cD/5Ga+w1+5+9nHo/yhfw0n8VYcCzGB0Izl6RxbcXwcmO89485xEBtP/t05LvKeQ+QbMjwWG+0WTDT1JzQLhMqFXE8+cwx4EfCbmJbT8oRjbwL+AhOEdWlIFGKg0TghMjFob9hCDBCloox57/8Em4dFuRd4Sv7EIt8LNPrK+omKEiriTLoXFC3BFKYVM5GWxoHg00R7pU7iOECzz4M9BN4qUlTwZoJjN2Or3+34juemWkxF05tNppHQNOZKFWArjkeA+XgWY/4wMj8+M8CjmPfUkF1UEhLGYeGcVwMT3m7HdFUNJKFqk8ozUAxcgetNpeOEyE7Ql3nvrVvOoJY/wWEeYTt7MSfFOzDNloeBzQ72+GlmZkeCEWAhBxljK469OPYzD1gQ9O97OcBhxjkIWN++I1KukF3htgL9dTjczIMglwYjWD+4Bhu7WsebIoxhAqAlWHSxDTTCzHschzAtp6ia+Das/vL5QgpJEUx5K8tokG9THagfEwPE0I0TObSE0pxG187sq2rSHGjnMSkTmQirtKm2+/+K2kJVBeqPUMEDLjoZqDllw86LOcBCLOz7ycCdmO7u9ozndhoT7wvSiRqE7wq2Dwo3A3+LmSu8GnhmnpN3A/+BeQ8NOYTZcZTsAxcDr8VMGm4F/ouiLyNCiDlFMEucxmw19mBy63sJX0qeggWJHwN+AfwIx/049uCYwPF14G7ux/GfwANMcxM3MZUlXlbFZhaLsH75NOB2rB8s64BkI/ArmLnw2ZggJsrVmE1LaPrmgHugTROrKk4KyrMG+BbwXeRYWoh+M9uVyXRMCDEgSCAkUhkDnhZ8foQ5Is0qEOrEFuArmFAlJPu4WQNRq4N7vQmwVmGuU3MJhPYD34vZXsHkYQFwXvD5HvaSUKVASPMbIQYH51xuB5IzwA3AjUS1XRy403H+VzFdlN/HggFFuQq4iq2YmXHoGDpz7hW+QC3AvNI+Hbgci1RZViB0NCZsPzP43arMehtmUry3ZXu32IA5WDkB00L6HhIICVEHJAsSQgwS9RQIZe1FY4KIdNhdY1JKGZroRA7r9XVF81sJnItNRE+igy+hCD7yf2uq+X08JJiH5amVrA9LsM1FKr9JnTWwcpjwjtvwfC+SzGFsVX2mUxkWAqfS7I10EvM6ujn9ajZhLzlrYpJxsd/LPTX5I4sNRusTYi5QVOW+VZ18M5u5nB9yBIdxbAM8NzkzlZoCbg/6wVswn262Su4ylWFWaJW1qE3SmMY4sB3PnTRb327CcSZwpPfcBzwAzMyenz1szW5MC2hby5EO6+tvw7pxH92RLensxKQzD9PgfT6maXs78lckRF9ocjsgkVArhczf0kzKujjfDHPz3vPggw9y+eWXs3Tp0krS3r59O4888kglaVVC0itW16k6oz68gwz4a089BUKitpwE/CHmQWI1WR6gmq2TdKEo48CFOC5pEZvsIGG1dhXwLmwGH7IH+CAWNiehnDPAD7GXj+OADwDPLVb0rjLgfaMQIoLHcxVXcRd3MYrHuW2AYx8mKJkGvgRchvWJ2/ri98FzA/B3NGtFngm8A1gHfBLzTDtRIPU7MTPhBR3276bdl1EvmAe8DFusuRX4S8wDrxCif9Rs9itKMOM9P7rySu644w5GR1uNhfPjgcnJSbZv21a+cEJUwFALhMp0xFUt7FW2QBiVkIeaK30oz2LMj0Jcmr42IoC4Cmr1htx69TFlj6mguJWIaefZAmzBZV8RGsNC4pwR2bYTU8FKw9kq8C7MafQ+2u/rJA1H4K0lKuTjLLMz6VAbIE/iuYqQknOFGdXlcRaiBng8u9nNbre7abuLOK/eijmjbt3XSx7FwtE/iHWz84Dj8ByLadGsx8Yx562fnMlRxHFM8zOWPvYXI5gvu6OwPn8lsMjbGNAWqEEI0TWyzrF7rekyKJSpg27X6e7du9m9ezdxdzZrPp0MFJIiIEfTLneNcecml61E0hWQVWWp5D3uarMbnBeKoRYICZEZzyC010yMY36ersNeXnYkH145Q1KNQogU2gQ+LodQvMssxELDPxnzsXMUNuF5FiYo2gx8A7i/P8XrGuuAtwLPwczbLsOEREKIeuPxEgrNQZKEQUL0CgmEhBgyDmKOpD+LmXFkiO9TGZrKCCG6oiKYk4XAC4F3Y9HARrH+6RlYgISbMKfZ9/epfFXRWtNHAW/C+v2PYYEsJRASok/IbkwIMQDURyCUprfWo/llgm/hNgebWU5uOizrJDlt8BgcDbSAEgXNbOOWdkNi72K2ZLLvzs6Eg3u8qfGE7CWizpOtzg5jYY2jyezBzDYOA0dglmnzvZm1bQd8iZe11NWrEuaMQoj60sn8a4WHYzCzpYeBR/osDFqJ4yxgHM86YD6N4AczWB+4DdMQ2gA8wXt2YGWfLlL0yKBwJBaJbBp4CNiT52UwolkVptPwVBFv4nwKJvhqHelGgs8o6ouF6DsSClVGrzWoshotxUbyjIyFruVvWnrpabefn1YzXX0E81xY7LFFokmIKqmPQEiIucQu4N+w2Mwhk1j4mxy99k7MSepXYpIBOA14P+Y343PAf9JbjSEhxHDzOOB9wBKsL/oq/X33eTzwJ5jw53iap4+TwLeAL2JBEX4J+E2szJ8E9pfI1wHPBH4tSOfDwA8LVIQDnoXn17A6jccSXgGs0wRZiNqScSlSzGEcTmZjQ8ogeSORQCgDdW2mrWFvc1PRSBUfkrzuTaCH5YsLb3zIw+3lS3EYCzHcieXA2ZgPjUubS5DrbtXAAqSZHmgRlnVi3UdFRyG6SvTZXg08CVjuHd8gWAx37cflefZDLZdOec/EbJ/BNHNW4nkS7Y44ZzBh+CbgGkxYfjzwdMx0rMxkKNTG2YBF+tqLafmMNpXXz17X7Dbf3iM7zA/Qk7H+e2RkpKUD9o1PkNAgjbxCzBWiDvdb3avJV1D15KnTpPld6nw45ohYgY6PeTuKmUy7jmm2f4vfZD8yK9kUpapJbUSlyTlnY1xFL9ree2Zm4mYILaj5tSGBkIhlzrWVIb3gh2ishl9H/IuUEEKUosJVkwWYj5+ziO+WdwBXYCZfIfuA72Ch5k8BzsPMZUM2B+c8gglkfg3TmtxQQXnXAM/GzObOw0zUjgBeGqR/F/AjTDvp6cCZWL98BaYo2orH/Bt9EjjqiCN41rOexcaTTooccQj4MXCLhVLrlJAQQghRU+bNm8eTn/xknvjEJ5pQCErPJbZv384VV1zB1q1b0w8WTUggJOYW0WWaIRUCRbkbM10YwbSJpvtbHCHEkFG1Bu1C4BXAO4nXEroFM4mNCoT2AhcAXwZejQmTogKhe4F/wfrD9wL/G1gU5FWWtcC7MGHPfEygtQD4FeB1mDnajZiz/1cCb8cERLfRWSB0DXADcPzKlax505vY+PKXR47YBfwZcCtc4eFWD7vmwGAmxIBTO01rIfrI2NgYL3jBC3jfb72PsbGxStK84YYbuPfeeyUQKkB9BEJxOs8+Zf+wktmR8qDQfhGLcBwDHIhsm8BWfw91SOUA9iKwDM98YCMw7h07gYk8I22symagchmWNaraG+MYzkP/witHsp2Haf9EfU1MY68M+zAnqdE6BnMwvQZ7aXkU2A3MBNdY56aV1iwq97Uumy8h4olpGyNYv3IiMI75N5uI6rBnbDsOE9YsI14gtApzlH8ikf4LE7gcDPI2u/1GIccwfzurgZVB2guCfWWF5NOYQGonJoQKnVgvDvYvCq5pBvMttCM4fjoo44qgbBNBGoeC7xPA7ulpHnr0Ue7dMRttAAsbYKPkor2wetryDBmKKYMQQ0R0Dunbp5iaVtQMn/AL4s274oIuxDqDjtlmgV4Seu42k+GEw33bl2hCmTblotCAE5hHO8fCBQtZtmwZ8+fPTzknG0uWLGF0dLR5oxpYJuojEBJzio3AH2AT+pD7MTX5WzqccyPwf7HJ8znA3wO/wPNvuFknypXgMwzV/RIGtbAKW0l/amTbo8Dnge91OOcYzGTiNOCbmKPp8S6WUQgx/CwCXgs8AbjFwyddd0K6r8e0fM7HzMS+QLvQu5VTsPFmP3Aq1U58HgY+gvkMegnwZuKdQY8DXwJ+hgmFtgbleCnwGsyM7BOY5lDIrt27+cxnPsN3vv3tyNaJ4CjP2Y/Au7eagEwIMRjUY/Yo6kNVDnSqSaZn+NAfnqgDEgi1EKdlEOt7Ocdq52zac0rjIFlfYw3wnJa9N9EcdKspGWzi/TC2wvtcTP1+OXBhhxIUUrTqIOhJdO7WMdcM2ZVMYQkmDHplZNtOzK2EI3I5EVO5FZivi3MxjasqOoHWauu6anS/2k2OZb2hbdpiztKx93Mw5i3i2OOwPvq/uhReYxnwDEzj5mHvuYioQCi60trIfA02ZkSpahr6KObRZwTzGTRF/JxhEseN2MJGyEI8j8Gind2GmbxFy31wfJyf/fSnHfM+ALyh7AUIIXrInHoRqC1xNZ51TEiKCBbVHsqsNZSaeczOMhdQ9pxC9FDw41CTKoAEQkI00T6V77X8Ok9++4EfYqvPx2Gr8/OBpwTbtgDXAwe857HAYzCtohux1fvrMWenpcorAb8QQ0/uZt71iCeeU4BfBrZjfdlDzQckFmJPcM5WzOH+RHdKGcta4ImYVtGZmDBpBfACTIPzLmyBJK1v3gp8C9OqPQPr30cTzxBCCNEtPD5/BDnNoUUNkEBIdJlu93TdeuvohXg5xW44A7uAz2IOVV+F+dVYC7wec8z6Q+D/hwWjeRnw68A9wD9gTkvHMWfTQghRJb1QEnw65kD6IeBPgYfa+tPOQqEtwEeBn2D94MEulTOOkzETttMwv0PzMO2i9wbl+BxwJ6ZV1BnPXcD/C9L4bcw0TgIhIYQQ9UeqPHWingKhbsoQMlr85ClCrElZN3HN+VbJDOaMeAemabKE8hPMw5gmiw/SW0h82edhJmBrvLnMPEB8nc7g2I+FEN6DqejH2fLkux+BU+VIwWZVO6MqMJVXerkEQwfS0HCuGq42r8CcqIaNfARzrgpmVrYlv7/XJrK/egkhBpU0DcDQGfISGv37GGY2toaGo+eqM3eRPCcwH0Zg483OyG/wjOFYio1l48FnO6Zhs6Vj3vZfmM9CaAyK8xzmNnoRMA1+PyNMsvQguHHwPrknXIBpB63HMY6NtyHziYy5ick4JrBxcL+3cVsLzUIMHnIwXQ/irbDy22bFBadJyaRjSh0TSO3s+/kkaSQaROopEBJ941Ec/4nnakyl/XxMqFAcxy/wXIgJeV4DPLvDkeuA92CaLVdg/oTiXiQOAv8N3I5N6BVcMJ1J4BLs5WcXVOuEm0b3L6GQEHOLXwB/BxyFhXx/DnAC8D5M6PIdzKxpqsvlCPugXwB/CyyN7DsNeCOmPfm9oEzbsHD0iYlhYp9XYeOW24jFk98wD3gBnpdgI9B/4mbu5PQrYOFXyaxuNAlcGpQnrB+P+RPqFG0zCfW9QgghhMiLBEIlGYYJmMPNSrQPAN8PTJl2YWZG5QRCJnz4L2wF8zHAs4ivt5VBfjPYiu+3iBcITQBXBZ9hpMwzFecMHUyT6NrgUzVaCxBi7vJA8FmBCV6ejQn3X4Np62wHvkv3BUIh9wWfBo7nAi/GNJaux8xsswpcFmBOrN8JjKzHLuysUTxPAN6OLU18H6bvhAlw32RWIJTWN05j/os+S3nT3WGYiwghxGBTwBVEee8RQpRm6ARCVTleL5JPHEUik/WjYwidoDW85zu24/kRtop6MubsMu0SHgLuBubhOBVbkfU4WoMLxqXjIn9d0oFx9dMNndu4Trrie9Nc1EbiqzD/GOuxl5v7iaiudgifthXzGbQe8yVxdEs692IvbinWDNmpQ9i8GhRBiGEj2rSXYoKelSnnLHVudozYg4lJdmM+y2a6UcgOHEUjtPzdmF+haDfRGIvaO4qF3s49CtMgMj8+di2XAat3w2lXw5JtMzjuBb6PeWjbYxd5O02SL4eNgc/CImTeDWzGtDR/Epw5gmlV7QHuCP6WQd2fEEJUQ7xLkIp62ULvE3Wd9BZxtCLqxNAJhER13Aj8GSZUeD+mcp+Ex8Lv/hOmZv+H2KrsQNMnyf1pwB9jIY3/Ffg06RFnrsccSB8J/C4WfecxkXQ+hq1El40qJoSYO6zDnB2fm3LcCNb3OEzw8beYfGQXvdMOAou0+IfYGPRPwIWpZzQL4t8JvAj4NuaweXuQxiXAuXfBH/8NnLJgEtNhvQbTWQ0Ml3fTZi72RGwc3Ql8ELgIEzT9NeYM+pcxk7t7gL/A+nEhhBBCiF5RT4FQmpdm33JckbST0q8jJR0AF2F/4Lx5B57dZPMPsx9b9VxKsiPRaWwaHbdyPBN8FgGHvB037XJIZsLl7YiH6GKPSqA15XwXn5X4hBcDGzGzhvWEjlNDR3WOSdoFO48Gn13YS8wBrIGfGKSzZvbI9tqYbVIVaVp120lizx25xyBHkGLYiFP6G8O0XI7D+pP5tDzvEf+Zk876/VAz6I7IYXkUZCewdMacYz4mbGqUsb2QDjPtWoxpMh2D9ZmhH6EZrA8cJ1kgPor1k8dhwq1RLIhB6Ktu7QHP3vtgHI+5gt7RdP5Y8Ile67LgswozqyMox32Yo+op4Fisv14I6kyEGGrUwAeRfK+OcZF/isxWs850y7wUlyXrdem5rzv1FAiJgcRhq6G/j02KT6dzF/AA8A06O4QeA34TE3B8E7jF+/72J13RFEpPcB7mk2MhJkQLz/oJ5hw1zu/EQaxuH8RMx15Bs4NVIYTIyiPAf2Dan0/GtGcWxxx3CHOQfA2wCRNKF+EQpp2zDROK/xKmpZTEMkzT5kxMwPI5TOhyPdZf3g98AhPKXEVnjaW9wJeBWzDHzo+27A/TOTLmXAc8FXgh0QhnyUxhARQOY6KlTRnPE0IIIYSoCgmERKWcjU3KHcnh6h/CzJd+EbNvBHgXZv60H7gLm6D3nT6Yj40C52F+gEKmMfOvH9FZIHQJJjB6PvA0eisQUqQxIYaHHZiZ0yhmTvUs4gVChzGPOv+KCTqmY47JwmHMX88PgrzOJZtA6JVY3/NV4H9hAvGwDA9iQiIXbOvk0+hR4GJMoD4Tcw2bsHErrn8bAX49KHMegdCVmIDfx+QnhBg+5ENYCFE3BlsgFNOj5nKYm/OtdU685JYwqQuFQJ0EQdPYhPp6zLfEPszEoDW/cLAcw148TsI0j3Z7c8g54WJOii2rj3yzc+JOTbwgwEUeKl9qGM9x7hHAseDmw+hWGN3WOH0Uz3rg8Zhfioewle3ozZsOPlOxuVbklC6szH7ObLrZKNOeFdmMiSGg1YH0scQLNBywAevfo+fswfqgXcAWOpsC5yG5/4ovWziZGYHApLa5327TCprVxncciTnhH43JbQpzCL0DG0emoufSKOAIBQQ6rmEiXRXjmADsUey+SMgkRP3oJBTqp/GPyEax4EUxZ7m4l9jqcqyevHnqKR4kBlsgJAaKccw55w+xyerDGc5ZhWkLvQZbff4IZkow9JwG/A7mQOhzwBeZtXNwmBnZRmzi/yFslbm9s1ZnLITIzknA/8RMTeNYS7t20I3Ah50J6zcxeCvfDngm8B5MDt9K6Nj/awzGtT2EOa++CRPQHUw+XAjRJ6QpJISoC8MtECqhCFFl5PJWUgeAOEFyBWXpRFTrxfkw7Htj2zwaTj2zOwZtrHOM0NAauh9zphlLxH9aqD4/ioW8BxN+zIfm5elQSyVO0p5axmRik4yqGEXKMUJY/Ma2mdlfBZ6C5Vi4nBMw+4mIV1WHyYnWY74sVnVMxONxsyvtM43NjYRav+Z50CIaXf1CIi8hshPtdUZ8o1uZDvYdgZn9Pj725KjGZajZ4ngEuA54oAsBG8JxoFW7p9HfNo6LfkxT1Tf6YBffU4Rj0wbgKcAK3Ow5Lti/G/g6Ng7OmpvFaQd62zcVfEYI6zfrRCSP2+3G1/AawrP3Y6bYP8mYmhCid8wqVksSJOLIPI72avbrZ8fbcNxPRzPzQWS4BUIiN0uAZ+GbVogXAWdRvImfBLwdcyB9FbZymcbNwCdpXo2+ATMzqwWR0XwB8AysjkKmgZ8C11KtOUBeHgS+gAmNrutzWYQQ9eFETNNwAdn75ZD9mKbnncDNrt35clVsBv4Tc7wcshp4DhZJLGQf5lPtbixa1y8Hf3+MjSVxrAnSORbrvxcE6fwwSOcUzB/QguC4+ZgG1BWYqW4rnsa4dRRWtyd3ef3/2KBs6zCH30l++4QQQog8LMT8mD6Wxvi3q68lEt1CAiHRxDI8rwdeG9kWhvQtJhDynI5jI7bS+n+x1cskwYTHhCk3tuQ5hUWgqRuLMYemb6dR3kPA32NCrIm+lMq4BzOzG8GctcqfhBAC4DGYedhy4C/pLDiJ41HgIgdfxTOJ61q/fD/wUZrDzj8WE2ZFBUJ7gQswh9CvAP4P1i//OTbexIll1gHvwCa787Ex7kHgvzDzsNdi2lIbgjRfjE2Gb6OzQOgarM8Pw9afHHNclWwEfgu7lwuQQEiIQUNmY6LOLAZeBbwFuBy4FQmEhpV6CoS66bc3oyPYjP6GOx5blQuwXiveOUwj6AiaNOFn8QuxJdoFkXMmMI+bHd4KxvCMYQKdsdadcV7AXegUlByVFm/K1bbbxziG7uB6x3faH7AEq4rVeI7C6ix8cRmjqYrycxB7OwHz2tpahmXAKhibhnU7YeO4rdrvDEzEQuYDK4O/hucwjh3A4ajlQWgfF7XGa3HK2gkfCSvmOphmDBSu6Q8QeUw1cxMDRrQ7nIdpCy7FBCorsK5kPSZcOJpoX9F+/j5sMrgZ6/L30aELr6gbmMY0faLsdo4HgXsjBQudPu/DussdWP88OyRFzFtXBJ/jsP77CEzAtRXYEqjHH0mjPw/HxEXAYlxnoUtk3NrvO4e2r5J52L1c1qE8Qggh6krKxLJv885m8/B9wCPYwkvnReX8A87MzAy7du3ivvvuY2ys7e2wEJs3b+bQoT6rDgxowJl6CoREfTkJ8755QmTbA5iefJ4l5j6RKgwKt2XoiB+PObxej63QVtru7wT+BhPP30Xz24XDbBneDKv2wbv+DV7+UzN1+AzN0vtT8fwaZloQcg+eT2Ir3bP4IOEkIamP6+UUE0OIQWE58FbMifJ6TDg0hmnDPDH4vaHDuR4zLfs8Njm8lf7IRx/GtB5XR8p1MCgPmIbOn2PaMrfTXMZ5wEswk7LV2HDmMaf8/4H1Yk8N9h+NCdOFEEKIuch+TGv2KmyhZWuFaU9OTvLNb36T22+/vdhicswpe/fu5YEHHihfuKqIvk/WHAmEIuTxiZl1f5M6aEZVoiK+OdOet8om7qsw5wiPa2Tsbwa+Eq/6mt4O4sIu5mg9PrL0m3SRsR78Em5Ihgo7GngBDdOFStv8Dkw/Mw6HLee/BBbvgid/wzYfwPxtRDkSeC5wemTb9cCXYxP2DcEQDa0hh4upvlbBmje1gCGVD82Kv4bsukR9yNxHJ3SyjmRnpYuAc4Bfaj6Ns2j2gRaXj8dMuL4L7IpzSN8j9mGT005qSFu8Z0uHc0ewAI4vp6HBOYMFOvgOpmnzWswEOLz82OrMfNEux9ibd5RuDHpSXBRiEMk/Yxb1pFxMhZSzuxCwIZ72xCcx9x03dixQcaanp7n99tu5/fbbyyWkZlMJEghF6IYgb/AmaimSle3At7Dl2McGnwCPOeO8AXuwnggcHzl1Pub48tEOOezBnDBvL1LskhW9FntROgLPrcCtLaZXcWwC/hvzRfF4zF9E9ucno+X4KFbHZ2D6mtdiwqI7gIswKdBD6clMY740bgPuxVb4s5JkLtZAPbIQRSnVfUUGrk7Wsidh/nDW09wnZylQ2O1sAX4GHB7gpj6DKbJeQMN82WPX1+rrbRMmPB+PbLsFG6ey4iPpbMfGx+rmBI2UpoOy3Ur+/l0I0Q/S1NOFEKJ3SCAk8nEf8I+Yg4b3Aqc2dnks1O1fB7v/BDjO9EsAW51+LaayHzcU3oY5A80mEIpbWSk+1T4Z+H3MEu7DwB34iEAofoC+EauO1cAfYy9d+YbyDGUeA14K/A9MCPT/YbP9H2GStxlaQvzEpzcJfBv4OPaCszcx0xg1H3k+FGJgeSrWR63BtGDy9FPbgH/FzKoOOjPPChk0n2GTmIbTj2k2eh2n+bo81r//JWaiFnKY/BHVbgT+AvO71K0omWH//jGy9O9CCCGEEA3qIxAqYvPURTW6qpxCDwbJFdm0N3Qg/Sj2prADCx82aftnMHc3U7MpeVMNWgojI+bDYjnB8ftp8lC2g9ChaaMMI5hwaQE2GT8Q7F2ChUNsJFPu7izAXpbWWVGb6VA9h4LPFM2ryJ2JSyjDQzyCtdR5kcPH7ZPq6mgMWAp+BPaNw5aDs7eqOiIvhQNnMZazoANzXWLw8dbHLSHDc+dbepKoc3hnYdBDn0Ftp6Z0nZOYX7KtkXZeazlQSuH2B584ZrxjHzYWbce0oprMz5KS7lCPB7GhcluZdFLqO3T8uRWYiD22zjdMCCFEfxjeN9ueM+BVWR+BkBgspoDLMG2VfcA9DYecf4LJIc4imIaeBbyB5reRO4EvYMumCawITj0HU+u/EBPCvBpzZXQn8MX0ZErQ54l0uKT9MGarcH/O808B3oipMX0jSCtr7PkwfJjeJYToC0/BtCrbhNRJtExKHKbIubhgGdzsf8PPbsy59JWY6ZU0bYQQQggx7MxdgVBBh+YDLgCsjhnMZOmGxiaHRdt6TOuxxwPnY3F+Qy7HdNxTJDlLgOdhUV+OAL6J3YOnA+8ArsCcgXZPINRnpjEHFNcXPP9o4DWYLdwm4FKyC4TaUAsQoleEgpw3YdqLScQFLpgjMpxKOQB8v9POqiq0shuj/liIgcW5GPVM9dpCiP4wOAKhtH6yR/1oVlOyWFOeispYJJkyJnB5ppxhPocwlzdbgbUOTnOwyMUcWCDtSczf0KWYg9BO6v9pzJsHp5wCxxwDT3DBKvw05hjoPjJf+CTmzPOSSBknsBXmmaYjs0Y6y07a2Tt3wY+vgrvvgXvvTzcP6USoJeAz23YOxsRmMEophp1OhqObMdn5spTzV2LRs6LHZTEza8/RmMFxP9YN3ouZjNXaTKwqSl7jsZg/ug2YmV5lacf2256dmD+ke7B71TzezIUbJsQAE3Sqzku0O0ykunLIdHaHFAolnr8k69at49RTT2XBgoW5z41jcnKSu+66i82bh3b5fuAZHIGQGCh2A5/BtHdeBHwAcypdBeOY6dglwfdCUcmAJUvg/PPhDW+AJc4ijc0cBj4BfJLMznYOAP+FWWOFeGAnZlnXme5PAe64A/76r2FsDHbshKm82kF6pxCib/wEuAsLNpjEOcD/Jl1wlJUprD/7V2Cfa/F/I2IZAZ4J/A5mHX1kD/K8EwviMEaW8UYIIYRI54lPPIc/+IM/YO3atZWkt3v3bv7xH/+RL3/5y5WkJ6pn6ARC/Xh/TcqzbHl6cz3xgom84gqPTUgnMZ/TmzAtoTOnYGoc/AHTnJkCRg/B/BmbRKeleRgT/BwOfs8Q46SzACMjsHIlHHusLdRMAYcOwWTOMDwzuEh5uqF3lZdG4ccPwH33ddidy3mpS9idLTC9EHON1FgIcQuAYQh5zG3Ynpb9o5gAwGF97RQmfDhEh/ZZsHHuBO50li6d0q4ho0EcgzzlnQw+ZS9yJea2bXnczqz9bY5gGePONIPiTyrgnVoI0RPSmnl0m1rtXKKq2bRnPvaSP429e2VP2bFs2TJOPvlkNmzYUElpHnnkEVasWFFJWrOoYVTK0AmERH+5DltZ3o6ZUYGD2z38MxxaZvuuAU7cBL+03SLfJPEo8CXMNOx28of8bSNit33wEHzr2/Dww42XsKkpuPpqmC7sZ0cIIbrHacDLMSfRl2JaRN1iEOdbp2P1syLj8R64GtM4PZRybM8ZxBsghBCirywGXgw8GTMp/jrFrSnE3CBVIOSc+zTwCmC79/7MYNsqzErmBCzu0fne+93OOQd8CHgZptTxdu99UXe4oi8Ul0574Cbgo5jPiVmZyl3APXDIWWCyTwLneXjaVDaB0NcxZ9IzlPCHHMOhQ3DZ9+AHLV5Ep6dhZib+HBGP3JvObTRO9I6TgXdj2ig7MGFGNxhUWcSpwK9h/nyyMIOZxv2QGgqEhBgiNE4I0RsWAi8E3gn8APM1J4GQSCLNYgfgs8BLWrZ9ALjMe38K9o7/gWD7SzGN6VOA9wAfq6aYYlCYJjRjcA0HxDPM2pJNT8LkpGnimADBpX6mcUwGfy0MevvHRT7J6dE4z5vwZ3Ky+dMqDHKRf6nF7ZRnL4lk7VrqxrnI1UTrLPwk1Vtb2qFmVQ2uWfSbz6JxoieMYCs5Y6T7FqqCRjsfDEawupmf+nHMx3WlHsv0gs3jTcxH/a0YXD6Lxgkhus408BC2SH8v5nIjnQEYTzTsdY1UgZD3/oeYwkeUVwGfC75/Dnh1ZPvnvXE1sMI5l6YEIoQQYoDROCGEECIJjRNC9IYDwAXAbwMfwSI+C5FEUR9Ca733W4LvW7EATWDRVh+MHPdQsG0LLTjn3oNJ/cWA44PPNK1hb43Q1GuaZLMih0koR2k4j55LhNfsSRCCj8RsDE+KTTOjY9Ek77aRdFzkMD9IagOiHwzsONFNd7ytzkLDT9iPxjXFOML+ch7mSNm1pR49Mi73+LKFwQEGqv/1ja5xpLEptmsMj3NdNHKN5p23HkuXSr6kxWAxsONEdajRipykDOtTmGbQvbkSEnOZ0k6lvffeOZd7DuO9/wQW4Jsi54v6sBO4HIsq9hPa/TDcA3was2m9ic4T3tXALwNnB8f9mKxqjt3C9bSvPARcCfwC83/xHKxOZjkSeB5wdGTbXuAKrJKBbhc4FFYJkQeNE/EcTaOdX4c53M8aOnw+8CxMwHEi1YQ5fxjzN7AFuNoNThjzI4BnY7YlZwe/D2P96c00xpx5mJPNJ9PdiBr7sDHxbuAGYH8X88qEOm4xAGicEEKI/lB0TrTNObfee78lUOEMfVVtptmX4zHBNjHEPIIZhv8I8x/UJBBycKtvSKnD0PFxrAXeHqTxaeB6ui0QasyQW5Vd+jGjOIg50P4c9nJzJi0CofWYh7hzI9sewNbU7qECFOhUVIrGiRSOxZa1zwD+GevzsgphFmJONp6PaVUurKA8m4CPY0KUiRxl6TfLgfMxG5N5WF3sxYIRfIaGls5C4HeBJ9BdgdAezEvu17E6lLNqITqicQIF5hBC9Jeic6KLgbcBfxP8/Vpk+2855y4AngrsjaiCVo5eWfuHxya9u7GwEDuBfZE7MopnDbDU2+roTppfLg7ieBALjRiX9j7CSXzMENm0qbOhRNOyaNzDkvAAuQ4HuJht8WZZ+fHYi8M+rL7ux7QAVgQfN4VVeCRUwORO2HnY7IW3EURhixRnMSZUmodnD449gJ9dQCvZglpsW5rqTLIlUZNxIo7YFpvSjH2Lb/VcaXfYMQosAZYB64CNRIQHHRJahzlNdpiAI10Q1EhoCotM1kljZROO3cC+jNdaFxywCNMMCssb9qeP0qiBCRwTs2dV02/P97AGu49rMI0tjwn49+WqvLjxpp20Z3c+jjXAQjx7sSFjoMz/xFyjtuNEr5FQSBQiOui1bWzbEbO/5tS5qEPUYLOEnf9PTKt9jXPuIeBPsI77QufcuzAdhfODw7+FhYi8GwsT+Y4ulFnUgCngu8BFmPDi7pb9KzFtn/Mw069PYZpEIXcDf4dN4ON4AJtQ56e1dQ6mrvydWCNbjTWu1wLzHsLUCFY2jtt1ED51i4WefhhbFY9iIZg9a4H/wvNVXMKqfzgdGbz6Ev1F40Q55mEhYk8kEOomsI4WzcEc7AE+j4VYj2MXsFnNPxdHA7+OaXSegAmmdveyAC1D3jFBeR4DfAP4AtbIhOg3GieEEKKepAqEvPdv7LDr+THHeuC9ZQsVonlpfZnBhBbfImrW1ZiZLgLOAV6OrdJ+seX8XfiOLyXF10k6neMbu2IdITt8rFPlwJFy9Jy4LHzHHxR9infguAJYhOeJBCu8j4K/qjnVceBnmGlEI/9GnmvwPBt70byO0JFqUpk67YvTmRoi0bgoRT/HiZ5RRLEutb9oJHkynpObks+R0ewKYfyqYPjtIGaW9k2itKsD1dpffKlup71OSuXnTLvr6Zg/p6pJdTAes395UJ5zcdyHaZNpMiXqwJwYJwqhBjqMZA/nIET/6aYZvRhCtmMCiEcwx8+tquinAI/H3N0cF2w77lh4zZNgyxjccAPceWdaLo2uczHwJMyQfBMm1BhvO9YxOgqPPRPOOANGRxp777wTbrgRJidIoENXXYmyTLlEpjCnpF8kvrEeBE4C3oyZmF2Pa9Ks2orjG3iOBH5RMq6OpixCULhJH4MJyZdGtp0KrJpNtDt4bIn955i7sfvjDpqDjXsPNpZtDf4mDhGd6MMsfwHweA8ng6mLPQl7qH4B3ArLZuxe3wtcC0zMwXsrhBBC/P/bu/dgScoyz+Pf9/TpPn0Du2mkGxpQFEQZcdRRB5xFHBkFHUYNNXa97AyOus5uuKE7zu6MhMbOJXZiAp1VnF0vYygKXsDLOMqCcm28jQJKi8qlm25oG1r6QtP3cz+n3v3jyTqVVSezMrMqqyoz6/eJqO46WVmZb2ZW5Zv51Ps+r6SngJBksgO4Ergfy0MxG3rNYfmOL8duco4Ppp17Llx+ORxYDVdcAdu2pR9aeS3wx1i74Ruwi9zFzd89o0sdr3wlvOc9MLbMptZqcM01sPWhpIBQ87KaDfZqehbrmvejUEnC96OnAH+BJaH+FpZbOhwQ2gb8bxyjWG6ipO4ocXRPIdKdc4AP0AiUg+UIO77H6/XY6GX/gOUPOlJ/Yci/1I8D/wz8GKtTOuui3CNt6seV2GicbwXcmcB/x34x+TiwFbbWrDv2vdh2DXakThHJQnmEpGP68EgXCh0QSvpcD/n1bM/NYEGfcBBhLzYk8Z6YxpAjWKJUhwUgjgYT3SiMjgZdETKetEawD+qSiNeWYj+OrsKz4Tg4eQMsGYVjR2F6GkZGkjpBtW5B+sLllUy6PdfYjxGW4pmlZf+E+nvMYDeByauJ/za52NmiEmyLFF9kst4M7bsjA9qRiR0blnsbGv6UptX4hbdMYjfw4bevwJIVhxo9pi7QHHb+nqZx3o7ObbP4vdEB+/hRGctkHGvhuo96XZbeUjyrsXPtRPCYCxJx76NxvCKF9mm93hpNuooZCWYca0xaizUMOhlwa4Fl4EdhYsQ+QzUsF1R4u8p8vESqrikrQZtxVPQ1lkSJCaalaxW90Sl0QEgG6z7gWixpdF39xiKKx5Ib/w1N16+2oH+AmaWweXO9wks3Ts8h4EvYkPa/Dv4Oeyb2S+nTgOdhH+jHd8NXvgJbtthjcjL5ZJgU6FhcwmKcEQ7guBrPHcAOXOPX/5yoGhHpvXlgE9YKst6Y0WF5ad5IfPL9dvZiXU3vx1oKLmpZOYQjAc4Bt2B12GGsxWkWZwJvAdZjeZi+Eyzrn7EhkX4fGwAgzXLeCmxsM48Hi/68BXhhY/pyrOshsFBBzh6Fm38BN81bYOrXMDTHVERERLqjgJDE2gl8I/g/ra3BY9GCwgvxSVeqjVY648AdbebcALwWeF7o5ubgAbjpJvj+99NeEZe3neUxYFNM+Tu5HwgvSfcTMkwGeRbwWE62L9EI3Disgr6UzgJCh7DuprdHvehc80/RQ/Kln8e6Ut3b4fs3AK/HfojYBdyEtbr6LtZqaAV2vNIu57diXl84MquBVwQzt3BgB/ezMP+A5Q36IkEXsYofRxEREcmPAkLSVrowg4t/KUqq+VxcAZocAH6MZ3c9c+qt8MguOHCgZSULRVw8ok5iofp0l7gUu0G4GOvm9SAWEFsksqjpxyZK6NkSfYR1gyFDIGGwrvZC823EEkZ7YAvWfWcfNtz7toi3zgXT51u+Z495aznUSZ6hncCTDpq+0fUgkPechA1NviJmG5onWLhsl7PRJWcX5itGN7IpLMgTTth9FBuIIFFkPRB90A/g+Dc8O7B8beFBFWrB+m7Hztt7W967FBt04TTgt0+A1c8BVkc301p4djyW7Ojmxlwz2GdlF+DvBXfMgkAP09y9W+dskTJq1x9ZZAgNYWvmQVBASEptO/BhHGNz3n6mvRumZxx7W6/GS2AV8B+wgNBPgL/HLvJFpFzOB96PJYX/MNa96D7gfxEMA97CAwdcc5J+gDsdbPfR+dOSTDsLQsU5FxsAIL7bkg+Fgzwex9c8fAzrbmUv5DIUY9cOAp/HWrTWzWOB9c7i+dHtxbYBV+BYhudJmgMwHuvavCWY3rrvVwL/PnisOgtO+gDBUGFt7AM+B/yfxqQJ4KvYtvoJm8djwb9OBw0QERGR4aWAkMRagl3ErsR+lZzL8uZejm8een2CIF+Cd5bs6MnId5TCCJYy4jgs0BV14xivsVOadn1UhsKI/eu6+Dm5nJ3tROJFNRpJGhnRYaOGjWLf443YeXNl8PoxZ10826zJpoTWdwg41PFXs9HaZTQoW9iJWDzidKJEJJoGTsXOTzPBYz4UD2rePxFtS/NqshKxmDlvDWmyvCda+/PlhA/qm5gFHmJxnru6+vn9VMAth7n1MHdaQnGCDNEu1A/7KNY6aGu4tOGGr4OPz4lIruqDD6RvCS7Sjbm5OSYmJhgfj+ynkNnExASzs60/eUmRKCAksZ4DvA9r+n4zljBaN/+9M4HlpLgbu+l4olcrKsaP+iKVciKWz+wsrAvPJ7Gb9/sGWajAC4FLfCM4BVbONRmW4bBkxv8D6wJ3I5b3SNKZxPbZLoAdwKexD007h4GtzafrSSxfkM7hIiLSC/fffz9XXnklq1evTp45hcnJSX7+85/nsizpDQWEJNaZwBnYL557gbtQQKgh/xS0U8BtwFVY0/+eNv9XUEgkVydgI4JdBFwN/E+sy9Kgu/E44FwP/wUrI9jXf4TsFwDnYnnOdmHdpxQQSm8Kyy90B8BjwDUkn4M9zYmKsMawtciZRaQKyjvMiVTFli1b2LZtW24te733zM8P+mpI2ilOQKiDPGpKvdZb9VFulmI3D6bNcDR51WB9qgmjPitJq44cbr6TBLQx5rE8IpkX4z0nYAlLw13NjmCJTqcS325r7Ojkry+iDIHwV8MvetJI7LsOS+g8RUw326gumwnrS1G6RVP8QgJpO38vJa4bavqzzZNYMGg/tp0vshXFzu+BPc6GZq91c45J0q/zTbuc0ymSUy8E+j3BhyNlwWNmU/cwkapxwb+RV5tSUkmDuSyeM93ceS5m2bJlnH766axZs6bz9bZ48skn2bVrF3NzmZKOxBtkgumKfyGLExCSwvJU/ntQCb8D/FfgqaFpdwNXUs97ISK9shfrJvZlLBfw4nxBA5DbidvhgR8Dn8ICTK8FLktY3SzwJW+NYWZsMdJK+0RERAZs3bp1vOtd7+KCCy7IbZm33HILn/jEJ9i/f39uy5TeKHZAKMvFbLpRykuhONeHjkbboBqZ9m6apvBZi5J1eU2JNiN+Qc9YhF5oLUO9G8c8KbsFhBawDgsKnULjaB0mGFa6Bx+qpCS7IlXlFj2BSQ8PpnpTv3XThK95vn1Y/pqVwDuA8xLWOQ38AGuZNI/LfE6LKUa7iTELyFknTXOSWoYVp+IXkQEJDyog0k9jY2OcffbZnH/++bksz3vPI488wtKl2YbISb+CiGmqRztW7ICQDNgzgd/Hxqf5N+DegZam6pZj+UdWY11ONgEHOljOFHYTdh/wEKUeeE1EeiJ7EjGH5RD6M6xGOCvFe5YAv4u1XNyDndN2ZVqriIiIiPSSAkLSRn2csacAf4elEB1QOsshSIK8ArgUuAT4HvArOgsITQD/D/gi1mVjOqfyichw+x0sKAQwlmL+UeBC4HzgAWxwLQWERERERIpDAaEC6qSlaEexksQVTWPpQ6exMEOGkvWruWsv17OQk3XxSlxoj+eV+s9hrYTAgkMjcTOGVjeK50SsVdEG7Bd5j7USOgr4hXJ2F02LSqJb/yM6x1vFo3ciLdL2Iup/TwDHYTyP0BxgXh2cO0ab5lysXgtMYD8NrKPNuSnCeLDe/QR5hNqU0/7zi3dSpqbhBTj3hMq7Ghtd3mGtNY8AOZ2WRWRItRneRQosW67n9KmopUeGaNcrICRt/BJrGbQU2MJAvxlZa70i1ZI9bN20Dngn1i1jI3bDNt6bVUUaonOlSPkE4xffieND+KZRxs4D3gWsT1jEHuAzWG1wMZZIenXK1c8BNwNfx4Ih2zIUvSqej52jx7Dk2jcNtDQiIiIizYYvINSLJFSDuiuOGAY526b4yKcNe4JHD+IZ3SwwaX/Xf2iOW0mFohgrsKGfLw1NiwwIRWUodOH2PI0hqiNmjFx3hXajSN/0b4R0W5PH8yjwaMuaR/G8leZ49eLvtOcojp9g3VhPod7KJxhCvmnOxprrr8xjecy+Q6Pratz2Z06m2oO6PPH32KgZ2pbXcQqei7BE3N9jIUbXMR+xg8KDJiS9Hppx8bQsy2l9uUg/wogMiUGOwi0loYZGksLwBYQqrqPGKKGTxATwQ+zi/XQs2LAMeAnWBWkP8FPgYNclraYNwIuB47AcQPfT46xLq7GDdBqWoOMeYLLx8sl4XoxjVVCeBzoqzxAkcBKpqpiLwceAf6XRnSnOb/DsCeZ4CPga8FTstPP00Hyz2AhkD+EXuqrOAb+g83Pgeux8ujY07SBWB+3tcJm9dDbWImjZwhTPeuC7NIJjlbgmj9oIVRMiueo2eCwikpYCQtLkMPBl4F+A12DjjG0EXge8CvgJlhS0tAGhHteuzwTej90ofRzraNfTgNBarA/HxcC3gO00BYTOAt6P53TgY8DWtEM/i0i1tNysP4DjCu9ZkvC2OeBIEOS5CwsqbwT+BnhaaLGTwLeBq2mc8zzWYnE2Yv1pPAP4c2x4g7oHgQ8RExDKKSjRyY3YCPBS4K+A40PFuRX4KPZjytHui9ZYcJ2CMCIiItKF4gSEenlRk3RlV9YQfMxFYTebUwMOBc8P0riwHwlW0UgmmrLfVhbRmYuzLy+cDDqUp7SxnMXJkNuJ7XoWYQz7xX091nin19fqNQeHHewdabT2P0BTTGjh2LWWpePuhQvv152ISGEldJ2d8p6pRW9of1acDB5LsIDMvtBrR7Cgx+6opWQ6VTR3RBuhOYn1siWw9jg4aVlQmGMw7+EYQbe0dpuQUI7EOiE0wypgZaOKYQRYvwI2rILjPQsFWo7lT9pHPkZGRli1ahUrlq9gZmaGY+PHmJubW3h9KVb3LPWeSecYj9muRnXrFyoPF5oxvJwJ55gAagn9+VQniOSk/p0k3H1TkeDhlC0V9VDLK9v6EO7m4gSEpLCmsF9+N9G44O+/LD/9hnMjuZa3xXzLe5Fbqq18GgMfOADXXAPf+x7wCHDEbop+Fix9O/BRHKuxpLDzXa9RRCpjUW6ZdHnX6i1JfxyaNgNsXjxrZ+fR4PS4A7iS5i5jq06GP3gbvPFZ4O4AvglPTsB1WI/ZflgKvNJbK9qFiygHzz4flr8BC1Rdi+2QnK1cuZI3vOENvOyCl/Hggw/ylWu/wuOPP77w+inAW73nmVid/S2afyCIFAoK1W0E3hIs5/a0yxGR3KnrmIj0mgJCkmgGuJPmrgDlEQxhnHZM6J5qrdbjqvn0ZT12DDZtin/9cRzfSr20OLocERlqLaeACeD7wSPxfV2sc4+3HyPCzl0Lb7wELrwAmAR3Izw6Yd2Z+xUQWuItV9AfY61CfVBengO8FYuY/ZjogFCXVdHY2BgvfelLueztl7Fp0yZu/M6NTQGhE7BA1XnAMe+50bn4QE6bFj8n+MZyjnrPd9otR0REREqrOAGhLPeb7S6oSn3f2kVwIKcWLmPYNe0G7JfGO7Gm8DtjVtEfnYw5Hyptl8Egn1t3qegl1c1gSUd3YclZj3WwhlTqo/m0LU19nsa/Ua8nrEJECipy5KkIC90VmmZ38cGEptELo6e3LVd43c4trniOgrsL3AR2krwQVkzBC7BAVaQDWPKhnJL4LFsCZz4DRp5hBXZgFeUq4PswecizZa91q7uXoCtbaMPy6lq1sJSIFj5R3YQ7WnYUn1/9KiKLqZNQ9fV98K9h+lCpd2VmxQkISSGswXIUvxr7xfX/Yt3E9tPP80ce317X9F/z9P6fCdN0eJvARvD5OpaINZ+cE23OihHDBle9jhCRnPQrENB6yt4NfAIbx/3VwIdgzWr4U+BNccu4C/h7LJiUYdVx50M3CusugdH/RGNIsRo2nNjfwcFDcNUTllD6KI28fHnpNtjTlYQ8QiIikp7a4EsRFCgglOHr0JQguE/rHJguyuiz758lWJPzjdh17k5seOIOVt7Vy+mbgaX8lbvdiuN+6G7/coz48iQ14qphvyjnNzRxj6sZRd1FKi9tS6L8Vhh6HpEgsjYNU4/BuIPRC2DZSbB0rbVoBeyqZhnNmaj3Yr92rMqpjMuBk4FnBeubAT/rmQNmH4HDh+FR4KGmVkHE/JGR90xPTzM+Ps7U1BS1+ebMcDUs799Cku0OzQfLGcdaryoOJFJseeXTlf7rS2uhYT2HD+t2Z1SggJAUwRFsyPn7scDE4YGVJG3Qp918vuXliOWU/kSRVPV3f2mgiwsRKYp9Dq728D3gd++Bi/8RViwPzXAu8Ic0Z6J+OvBnwBM5FWIUS65TH27teuBh+Nm9cPOUTdqS06paTUxOcsONN/Loo4+yc+dO9u/f3/T6HuDzwM1Y1+OpiGWkEV7OZmC67/0bRKQTWYZgEREBBYSkxTHgRuA7WKVSjFGp0lZvSa2SWvIs9PPCtiQ1tMMt5BYqQXFFZMjsB77uLBbz7l/Ahb+CFeEZ3gi8jOaA0KnAn5DvOX8keOwHvgb+h3BvDT5Zsy5ivao7p6amuO3WW7n9ttvw3jPf0kJoH/BVGu1DOx0IYm/sctTBQaTf9K0TKaES3UiVPCCk02N7KfdPcxbPlBeyg9z37arGDD9jplkM+SUA7XqXRRZj8cTUpY2ZcWF747o7iIj0QWSjTm/Blhqwuwaba3A8jdPrCU/AaffC2O60KwFOwoJG81hfrwPt31LDsxtLZ1TbDhyE2hzswFrkzKXdmA5475n3PrYPV9MPOcE6Y9fs4pODewfzPjRf8xub/hOR3mu+ZG3fQUzdx0QGrGRfvpIHhKR6OhnHqqXqcxmWU7IvrIiImB852OntQqZeC7ziXnjvX8P6sZQLGQHegHUpOwZcBdzR/i1zWCvaLwKzE8BOW/8+Ql20el23tAswZQk+ZV2O6kwREZG2ylZVKiA0xLprsNLDC8WE7MtNoSCfbsVRrV664mOeZzECPpz41MNIDUZbUh/V6LzZf2Yd7B8f+8fiZZbtBCkixbIQo/AWgNnX0sjl1AOeiQMxrXTCy8ExArgR4PnAFPgJqG0Ff1ewghgzWEOiu4PnwQJZ9LQHCbnzSvKdtJzcWsaKSFfq31XvvbqODb0ukrmlGHZ+fn6e2dnZ7MuOUav17e6lUOrVa98H5eiCAkJSPWVoK3s88HLgrMak5ZNw0Q9h9a8a02axEZN/Sh+DQiIiZRK6Rt6GJUNeE3o56tr3qcArgFM98Avg03B0Gr6/3QZUaGcOCwYVI8eeiIhId44cOcINN9zAjh07clvm5s2bGR8fz2150jsKCEk5dJKUOfvo9P2zBngzcGlj0ooD8EcTcMl9LJR9CvgwNlrMDMWX0EBIRKR3HDwIPAyM+Pa/oT4XeAZBQOinwC/gsIevTcO3E3599ViwXgEhERGpgoMHD3LdddcxOppfaGB2dpaZmTLcvUiBAkK9uG0c7oaVnWz9KHAicFxoWg0bSCVxCPqOAjAp2jB2K8tHK6IIcaU6Ds9TW/JXrMWG6/VYXtK4987Nw+MH4aFQ4tMlh+DECXhKaL6lwCnAmcBsxMJm8TwBjIeaJXazF13Mm9MsU8EgEembmK6oc95a8PiEquUgnp3AerDoziw8jtV1xzKsuzFJfWNFpFiK/LuoFIv3nqmpqeQZpZKcjxlhoq+FcM47N5I8Y2aD37ZB6mTr13l4F3BBaNo4cA2NoehT6SYglDmHUPL6U+cQShMQ8vbPBdi+Whea/BvgR8AT2K/UD0cvkhUr4DnnwIb1jWnHzcBlW+HixxrFrAHb2yxnL/AZ4K688kq0ea2Tz1Nrfm9dkGRXq9Xw3g/9rnPOeTfSi3pCKiWoFKLP2w3HA+fQOH8DTAIPYEH9thQQkoLxqicAqydGKlpP+MhzW/pDPvQfjhJIf53d5f3tcN8e91xRcwi1u58oTguhqOJ1/YHtyUKrKdgty4EXAK8JvXQY+AHtR2mPW173My4+hr79y+3XErM61yYSFJfC7WQsB8XG0LRNwD9hNxXtTE7C5nuap50QLC/cO24EeFbwqE8Nl3UHcP2iwnUWumndlYlL0UBuIlI0UUOte7/oRHQUy88WuYjklWSZWURk4MqQXlNEBqM4ASEZnNCd/wTwQ2AaOB14EdZt6SXYBXTaUMM4cA+wM8di9tJ64MVYl6/wRrbb3pcAK3tZqBRWY7mpj89peQ54BNiMfRZERERERESkmhQQkiaHgS8B38BaCT0TawHzeuBVGZbzOPDX5BgQ6iSpdNrlYjl63g88O36WRZYTHYjp568va4HLsPzUefkmNlJPtwEh/QolIiIiIiJSXMUOCHV7Rxl5J9+v29Rydk2rYUGhw8Ch4O8RLPBxPOkTB88DGwgSdnYl1Mg18y5N/4b1wWNDaNoscIT40b2msVxBYQexhKad8MH69gJj2P4eXTQHhPf4KEGrpi7NYS3ApnNYFjT6z4qIDJxOSCJSEc3pG1Im0hQJi8uFIUOr2AEhKa01wNuA38uWeaiNXjURMifTHAwC2I21ltqa8N5wqXZjAZ1OTGCtc36FJTv9j9gIY/1wALgW6yq2AwtMdUqXISIiIiK9kdeVtYgIKCAk0JOaZSVwYfAIy7KavAMLWYffPAjcjCXU7odp4CfB4yLgj+hfQOgocAfw7S6Xo2CQiIiIiEivKCQo+ap2QKjfd6edDH/Vm5WnKkFkcUMT92JBgnC3r6QuY6cBZ2OJqFvfMYu1tnk0oVxxy05vcSnTdnUL24G1nIl8l+vBiTi0yCex5N47WVz2yBHRurQbH7Rsyj56jov4Q4EhERERkXyEh7CuD0HfiU6uh6WI1O9L8uOSTirOuauAS4F93vvnBtM+gjVgmAEeBv7Ue38oeO1y4J1YGpn3eu9vTiyEc96NjHSxGQUx0O9k9pVHviM0cTVwIuHgTnsOS278fuApEa8fBj4GXIflJsomS3XV2YFoXcM0sA+YjJrLdb6eWKHFrQROApblv5ZIs1g+pHEFhAqnVqvhvS/0LlU9ISIyOF71RH0dfmQI6gnvfcK1YbaPQqE/OEOks+v9Lu4SFEvqiXrs1hUsf2G7+4k0AaGXAceAa0In8FcBm7z3c865KwC893/lnDsHS0XyEqy3y23As7z38wnrqOwJvNtIfE+/qwkRoaSAUSsHvAMbXWxNxOuHgb8FrgJqPa1+Mu41t/BPISvFyPZOmT8YUVsWsZCIk1fiPomYoYj7saxKEhDqSz2hgJCIyGIlCQjpfiIneQeE8nmndCv9pX1Od4cKCPVEGQNCiV3GvPc/cM49vWXaLaE/7wTeFDx/HXCd934a2OGc246dzH/SScGlgBLiCvcAH8GGZG81BfyMHp9/orrVFuv7mFlkT+Ect6nku0cKQPWEiIi0o3pCRKSY8sgh9A7gq8HzjdgJvW5XME2qLNSN9ZfAfcTHjbJ3FctYhpbyVCXa0av0cRXZPVJ8qidERKQd1RMiIgPQVUDIOfdBYA74cgfvfTfw7m7WXwbd3nD39IY9YuE+NDH1uuuRCmdP27bnzbrsjkQksslphYNMFd7BkUmQ/xJFWqmeEBGRdlRPiDRfi/elN1ffVyhF1XFAyDn3diw53EW+kYjoN9hAU3WnBtMW8d5/BvhMsCx9DEVEKkb1hIiItKN6ojMaeFykYEr863pHmdecc5cAfwm81ns/EXrpeuDNzrkx59wZwFnA3d0XU/rFdfJwJXh0um0tj37Lq9xF2y6pPtUTIiLSjuqJDgUXt/HXbz7ikU62uSUPUUdL1+fl5MI3nyWS2ELIOXct8HLgROfcLmwQqcuBMeDWIIP2nd77/+y9v9859zXgAazp53uSRgQQEZFyUz0hIiLtqJ4olwql4Sw0Bd+qo8zfl8Rh5/tSiCEZJlJEJKsyDDvfDxp2XkQkWhmGne+HYbmfWLhzC+7h0t3JZf94DP0Hqg/ijp1r+3oP7t0HHw4oPVfvNlP/e3BFidTVsPMiIiIiIiIyeO2DBfmJWn7RbnJFiqSs34/qh9FFRERERERERKSJAkIiIiIiIiIllK5VgtJFV4eGhZF8KSAkIiIiIiJSUgoNiEinFBASERERERER6SMF8qQIlFRaRERERESkRFxoRKP0o0aH58sejqi/W4GM/ETtS3Xuk35SCyERERERERERkSGjgJCIiIiIiIiIyJBRlzEREREREZGh0nkHsKguTepG1h11E5NBUQshEREREREREZGsSh4NVQshERERERGRodRdommRoVaBr4wCQiIiIiIiIiVWvy9V1yOR/qlAPEhdxkRERERERKqgCjeoImXgKvJlUwshERERERGRknKhO1Pv+9tGqCL3xAMXtR+Tj2RO7cLUvKwrruSRoaIEhPbXarVxYP+gC5KjE6nO9mhbiqtK26Ntifa0nJZTdvu96oki07YUV5W2R9sSTfWE0f1E17JHBDK8Q9/fYqrStkAft6cee+1hELYv9YTrdxQ5jnPuZ977Fw26HHmp0vZoW4qrStujbZEkVduvVdoebUtxVWl7tC2SpGr7tUrbo20ppiptC1Rre/q1LcohJCIiIiIiIiIyZBQQEhEREREREREZMkUKCH1m0AXIWZW2R9tSXFXaHm2LJKnafq3S9mhbiqtK26NtkSRV269V2h5tSzFVaVugWtvTl20pTA4hERERERERERHpjyK1EBIRERERERERkT4oREDIOXeJc26rc267c+4Dgy5PFs6505xzdzjnHnDO3e+ce18w/QTn3K3OuW3B/2sHXda0nHNLnHM/d87dEPx9hnPuruD4fNU5t2zQZUzLObfGOfcN59wW59yDzrnzy3psnHN/HnzG7nPOXeucW16mY+Ocu8o5t885d19oWuSxcOafgu36pXPuhYMr+WIx2/KR4HP2S+fcvzrn1oReuzzYlq3OuYsHUuiSUz1RLKoniqnM9USV6ghQPTEIqieKRfVEMameKI6i1BMDDwg555YAnwBeDZwDvMU5d85gS5XJHPAX3vtzgPOA9wTl/wBwu/f+LOD24O+yeB/wYOjvK4CPee/PBA4C7xxIqTrzceAm7/2zgd/Gtqt0x8Y5txF4L/Ai7/1zgSXAmynXsfkCcEnLtLhj8WrgrODxbuBTfSpjWl9g8bbcCjzXe/884CHgcoDgfPBm4LeC93wyOO9JSqonCkn1RMFUoJ74AtWpI0D1RF+pnigk1RMFo3qicL5AAeqJgQeEgJcA2733j3jvZ4DrgNcNuEypee93e+83B8+PYieIjdg2XB3MdjXw+oEUMCPn3KnAHwKfDf52wCuAbwSzlGlbngK8DPgcgPd+xnt/iJIeG2AUWOGcGwVWArsp0bHx3v8AONAyOe5YvA64xps7gTXOuZP7UtAUorbFe3+L934u+PNO4NTg+euA67z30977HcB27Lwn6ameKBDVE4VW2nqiSnUEqJ4YANUTBaJ6otBUTxREUeqJIgSENgKPhf7eFUwrHefc04EXAHcB6733u4OX9gDrB1WujK4E/hKoBX+vAw6FPphlOj5nAE8Anw+arH7WObeKEh4b7/1vgH8EHsVO3IeBeyjvsamLOxZlPy+8A/hu8Lzs21IEldmHqicKR/VEsVW1jgDVE3mrzD5UPVE4qieKTfVEl4oQEKoE59xq4F+A/+a9PxJ+zdtQboUfzs05dymwz3t/z6DLkpNR4IXAp7z3LwDGaWnOWaJjsxaLDJ8BnAKsYnETw1Iry7FI4pz7INb0+8uDLosUi+qJQlI9URJlOQ5pqJ6QOKonCkn1REmU5Tik0c96oggBod8Ap4X+PjWYVhrOuaXYyfvL3vtvBpP31pulBf/vG1T5Mvg94LXOuV9jTW1fgfWZXRM0K4RyHZ9dwC7v/V3B39/ATuhlPDZ/AOzw3j/hvZ8Fvokdr7Iem7q4Y1HK84Jz7u3ApcDbgkoJSrotBVP6fah6orBUTxRbpeoIUD3RQ6Xfh6onCkv1RLGpnuhSEQJCPwXOCrKbL8OSJV0/4DKlFvSJ/RzwoPf+o6GXrgcuC55fBny732XLynt/uff+VO/907HjsMl7/zbgDuBNwWyl2BYA7/0e4DHn3NnBpIuAByjhscGadp7nnFsZfObq21LKYxMSdyyuB/4kGCHgPOBwqDloITnnLsGaR7/Wez8Reul64M3OuTHn3BlYcru7B1HGElM9URCqJwqtivVEZeoIUD3RY6onCkL1RKGpnii4gdQT3vuBP4DXYFm0HwY+OOjyZCz7v8Oapv0SuDd4vAbrK3s7sA24DThh0GXNuF0vB24Inj8j+MBtB74OjA26fBm24/nAz4Lj8y1gbVmPDfC3wBbgPuCLwFiZjg1wLdZfeRb7teWdcccCcNhoIQ8Dv8JGQxj4NiRsy3asb2/9PPDp0PwfDLZlK/DqQZe/jA/VE8V7qJ4o3qPM9USV6og226N6orf7XPVEwR6qJ4r3UD1RnEdR6gkXLFxERERERERERIZEEbqMiYiIiIiIiIhIHykgJCIiIiIiIiIyZBQQEhEREREREREZMgoIiYiIiIiIiIgMGQWERERERERERESGjAJCIiIiIiIiIiJDRgEhEREREREREZEho4CQiIiIiIiIiMiQ+f8MQ85TkhsszwAAAABJRU5ErkJggg==\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"# Model","metadata":{}},{"cell_type":"code","source":"class ShopeeNet (nn.Module):\n\n    def __init__(self,\n                 n_classes=CFG.n_classes,\n                 model_name=CFG.model_name,\n                 use_fc=CFG.use_fc,\n                 fc_dim=CFG.fc_dim,\n                 dropout=CFG.dropout,\n                 pretrained=CFG.pretrained):\n        \"\"\"\n        :param n_classes:\n        :param model_name: name of model from pretrainedmodels\n            e.g. resnet50, resnext101_32x4d, pnasnet5large\n        \"\"\"\n        super(ShopeeNet, self).__init__()\n        print('Building Model Backbone for {} model'.format(model_name))\n        \n        self.backbone = timm.create_model (model_name, pretrained=pretrained)\n        final_in_features = self.backbone.classifier.in_features\n        \n        self.backbone.classifier = nn.Identity()\n        self.backbone.global_pool = nn.Identity()\n        \n        self.pooling =  nn.AdaptiveAvgPool2d(1)\n        \n        self.use_fc = use_fc\n        if use_fc:\n            self.dropout = nn.Dropout(p=dropout)\n            self.fc = nn.Linear(final_in_features, fc_dim)\n            self.bn = nn.BatchNorm1d(fc_dim)\n            self._init_params()\n            final_in_features = fc_dim\n        \n        self.final = nn.Linear (final_in_features, n_classes)\n    \n    def freeze (self):\n        \n        for param in self.parameters ():\n            param.requires_grad = False        \n        for param in self.backbone.parameters ():\n            param.requires_grad = False\n        \n        for param in self.final.parameters ():\n            param.requires_grad = True\n        if self.use_fc:\n            for param in self.fc.parameters ():\n                param.requires_grad = True\n            for param in self.bn.parameters ():\n                param.requires_grad = True\n        return\n    \n    def unfreeze (self):\n        \n        for param in self.backbone.parameters ():\n            param.requires_grad = True\n        for param in self.parameters ():\n            param.requires_grad = True\n            \n        for param in self.final.parameters ():\n            param.requires_grad = True\n        if self.use_fc:\n            for param in self.fc.parameters ():\n                param.requires_grad = True\n            for param in self.bn.parameters ():\n                param.requires_grad = True\n        return\n    \n    def _init_params (self):\n        nn.init.xavier_normal_(self.fc.weight)\n        nn.init.constant_(self.fc.bias, 0)\n        nn.init.constant_(self.bn.weight, 1)\n        nn.init.constant_(self.bn.bias, 0)\n    \n    def forward(self, x):\n        feature = self.extract_feat (x)\n        logits = self.final (feature)\n        return logits\n    \n    def extract_feat (self, x):\n        batch_size = x.shape[0]\n        x = self.backbone (x)\n        x = self.pooling (x).view (batch_size, -1)\n\n        if self.use_fc:\n            x = self.dropout (x)\n            x = self.fc (x)\n            x = self.bn (x)\n\n        return x","metadata":{"trusted":true},"execution_count":94,"outputs":[]},{"cell_type":"code","source":"class DuetModel (nn.Module):\n    \n    def __init__(self, embeddingModel):\n        \n        super (DuetModel, self).__init__()\n        self.embeddingModel = embeddingModel\n    \n    def forward (self, i1, i2):\n        \n        E1 = self.embeddingModel (i1)\n        E2 = self.embeddingModel (i2)\n        return E1, E2\n    \n    def freeze (self):        \n        self.embeddingModel.freeze ()\n        return\n    \n    def unfreeze (self):\n        self.embeddingModel.unfreeze ()\n        return","metadata":{"trusted":true},"execution_count":95,"outputs":[]},{"cell_type":"markdown","source":"> # Loss Functions","metadata":{"papermill":{"duration":0.052832,"end_time":"2021-03-29T06:13:08.081563","exception":false,"start_time":"2021-03-29T06:13:08.028731","status":"completed"},"tags":[]}},{"cell_type":"code","source":"class ContrastiveLoss (torch.nn.Module):\n    \"\"\"\n    Contrastive loss function.\n    Based on:\n    \"\"\"\n\n    def __init__(self, margin=1.0):\n        super(ContrastiveLoss, self).__init__()\n        self.margin = margin\n        self.pdist  = nn.PairwiseDistance (p=2)\n        return\n\n    def check_type_forward(self, in_types):\n        assert len(in_types) == 3\n\n        x0_type, x1_type, y_type = in_types\n        assert x0_type.size() == x1_type.shape\n        assert x1_type.size()[0] == y_type.shape[0]\n        assert x1_type.size()[0] > 0\n        assert x0_type.dim() == 2\n        assert x1_type.dim() == 2\n        assert y_type.dim() == 1\n\n    def forward (self, x0, x1, y):\n        self.check_type_forward ((x0, x1, y))\n\n        # euclidian distance\n        # diff = x0 - x1\n        # dist_sq = torch.sum(torch.pow(diff, 2), 1)\n        # dist = torch.sqrt(dist_sq)\n        dist    = self.pdist (x0, x1)\n        dist_sq = torch.pow (dist, 2)\n        \n        mdist   = self.margin - dist\n        dist    = torch.clamp (mdist, min=0.0)\n        loss    = y * dist_sq + (1 - y) * torch.pow (dist, 2)\n        loss    = torch.sum (loss) / 2.0 / x0.size (0)\n        return loss","metadata":{"trusted":true},"execution_count":96,"outputs":[]},{"cell_type":"code","source":"def get_criterion (margin):\n    \n    # criterion = nn.MarginRankingLoss (margin=margin)\n    \n    criterion = ContrastiveLoss ()\n    return criterion","metadata":{"papermill":{"duration":0.062338,"end_time":"2021-03-29T06:13:08.439577","exception":false,"start_time":"2021-03-29T06:13:08.377239","status":"completed"},"tags":[],"trusted":true},"execution_count":97,"outputs":[]},{"cell_type":"code","source":"def load_state (model_path, model):\n    \n    state_dict = None\n    try:  # single GPU model_file\n        state_dict = torch.load (model_path, map_location=torch.device ('cpu'))['state_dict']\n        # print (state_dict)        \n        model.load_state_dict (state_dict) # (torch.load (model_path, map_location=torch.device ('cpu')), strict=True)\n    except:  # multi GPU model_file\n        state_dict = torch.load (model_path, map_location=torch.device ('cpu'))        \n        model.load_state_dict (state_dict)\n    return state_dict","metadata":{"papermill":{"duration":0.061166,"end_time":"2021-03-29T06:13:09.161427","exception":false,"start_time":"2021-03-29T06:13:09.100261","status":"completed"},"tags":[],"trusted":true},"execution_count":98,"outputs":[]},{"cell_type":"code","source":"def getModel (fold, isTrain=True):\n    \n    model = ShopeeNet ()\n    if isTrain:\n        \n        # model_path = f'{CFG.model_train_path_prefix}/{CFG.model_name}_fold{fold}_start.pth'\n        # print (\"loading\", model_path)\n        # load_state (model_path, model)\n        pass\n    else:\n        \n        # model_path = f'{CFG.model_infer_path_prefix}/{CFG.model_name}_fold{fold}_maxacc.pth'\n        # load_state (model_path, model)\n        pass\n    \n    # torch.save (model.state_dict (), model_path)\n    \n    # Warp as model for triples\n    model = DuetModel (model)\n    \n    if CFG.isFreeze:        \n        model.freeze ()\n    else:\n        model.unfreeze ()\n    \n    return model","metadata":{"papermill":{"duration":0.061008,"end_time":"2021-03-29T06:13:09.273719","exception":false,"start_time":"2021-03-29T06:13:09.212711","status":"completed"},"tags":[],"trusted":true},"execution_count":99,"outputs":[]},{"cell_type":"markdown","source":"## Trainer Helpers","metadata":{"papermill":{"duration":0.052281,"end_time":"2021-03-29T06:13:09.38012","exception":false,"start_time":"2021-03-29T06:13:09.327839","status":"completed"},"tags":[]}},{"cell_type":"code","source":"def format_time (elapsed):\n    '''\n    Takes a time in seconds and returns a string hh:mm:ss\n    '''\n    \n    # Round to the nearest second.\n    elapsed_rounded = int(round((elapsed)))\n    \n    # Format as hh:mm:ss\n    return str (datetime.timedelta (seconds=elapsed_rounded))","metadata":{"papermill":{"duration":0.059421,"end_time":"2021-03-29T06:13:09.49086","exception":false,"start_time":"2021-03-29T06:13:09.431439","status":"completed"},"tags":[],"trusted":true},"execution_count":100,"outputs":[]},{"cell_type":"markdown","source":"# Trainer","metadata":{"papermill":{"duration":0.050869,"end_time":"2021-03-29T06:13:09.718636","exception":false,"start_time":"2021-03-29T06:13:09.667767","status":"completed"},"tags":[]}},{"cell_type":"code","source":"class MyTrainer:\n    \n    def __init__(self, fold, model, train_dataset, eval_dataset, criterion, \n                 checkpoint_path=None, isResume=False):\n        \n        self.fold             = fold\n        self.start_epoch      = 0\n        self.model            = model\n        # load checkpoint\n        if checkpoint_path is not None:\n            if isResume:\n                self.start_epoch = self.load_checkpoint (checkpoint_path, isResume=True) + 1\n            else:\n                self.load_checkpoint (checkpoint_path, isResume=False)\n        self.model            = self.model.to (CFG.device)\n        if CFG.isFreeze:\n            self.model.freeze ()\n        else:\n            self.model.unfreeze ()\n        CFG.MODEL             = self.model\n        self.train_dataset    = train_dataset\n        self.eval_dataset     = eval_dataset\n        self.criterion        = criterion\n        self.isTrained        = False\n        self.device           = CFG.device\n        self.optimizer        = AdamW (self.model.parameters (), lr=CFG.lr, eps=CFG.adam_epsilon, weight_decay=CFG.weight_decay)\n        self.epochs           = CFG.epochs\n        self.set_dataLoaders ()\n        self.training_stats   = []\n        self.modelFile        = f\"{CFG.model_train_path_prefix}/{CFG.model_name}_{CFG.size}_fold{self.fold}.pth\"\n        if eval_dataset is not None:\n            self.minLossModelFile = f\"{CFG.model_train_path_prefix}/{CFG.model_name}_{CFG.size}_fold{self.fold}_min_val_loss.pth\"\n            self.maxAccModelFile  = f\"{CFG.model_train_path_prefix}/{CFG.model_name}_{CFG.size}_fold{self.fold}_max_val_acc.pth\"\n        else:\n            self.minLossModelFile = f\"{CFG.model_train_path_prefix}/{CFG.model_name}_{CFG.size}_fold{self.fold}_min_tr_loss.pth\"\n            self.maxAccModelFile  = f\"{CFG.model_train_path_prefix}/{CFG.model_name}_{CFG.size}_fold{self.fold}_max_tr_acc.pth\"\n        \n        self.min_val_loss         = 9999\n        self.min_train_loss       = 9999\n        self.max_val_acc          = -1    \n        return\n    \n    def set_dataLoaders (self):\n        # Create the DataLoaders for our training and validation sets.\n        \n        if isinstance (self.train_dataset, torch.utils.data.IterableDataset):\n            train_sampler = None\n        else:\n            train_sampler = RandomSampler (self.train_dataset)           # Better use RandomSampler\n        train_dataloader  = DataLoader (\n                    self.train_dataset,                                  # The training samples.\n                    sampler     = train_sampler,                           \n                    batch_size  = CFG.train_batch_size,\n                    num_workers = CFG.num_workers,\n                    pin_memory  = True\n        )\n        # train_dataloader  = DataLoader (self.train_dataset, batch_size=CFG.train_batch_size) # TODO: comment this\n        validation_dataloader = None\n        if self.eval_dataset:\n            validation_dataloader = DataLoader (\n                        self.eval_dataset, \n                        sampler     = SequentialSampler (self.eval_dataset),\n                        batch_size  = CFG.eval_batch_size,\n                        num_workers = CFG.num_workers,\n                        pin_memory  = False\n            )\n            # validation_dataloader  = DataLoader (self.eval_dataset, batch_size=CFG.eval_batch_size) # TODO: comment this\n        \n        if type (CFG.warmup_steps) is float:\n            CFG.warmup_steps = int (CFG.warmup_steps * len (train_dataloader))\n        # Total number of training steps is [number of batches] x [number of epochs]\n        num_training_steps = len (train_dataloader) * self.epochs        \n        lr_scheduler = get_cosine_schedule_with_warmup (self.optimizer, num_cycles=CFG.lr_num_cycles,\n                        num_warmup_steps=CFG.warmup_steps, num_training_steps=num_training_steps)\n        \n        if type (CFG.eval_steps) is float:\n            CFG.eval_steps = int (CFG.eval_steps * len (train_dataloader))\n        self.train_dataloader, self.validation_dataloader, self.lr_scheduler, self.num_training_steps=train_dataloader, validation_dataloader, lr_scheduler, num_training_steps\n        return\n            \n    def test_iterate_dataloader (self):\n        \n        for step, batch in enumerate (self.train_dataloader):\n            print (step)\n            print (batch)\n            break\n        return\n    \n    def save_checkpoint (self, epoch, path):\n        \n        checkpoint = {\n            'epoch'               : epoch,\n            'model_state_dict'    : self.model.state_dict (),\n            'optimizer_state_dict': self.optimizer.state_dict (),\n            'lr_sched_state_dict' : self.lr_scheduler.state_dict (),\n            'training_stats'      : self.training_stats,\n            'max_val_acc'         : self.max_val_acc,\n            'min_train_loss'      : self.min_train_loss,\n            'min_val_loss'        : self.min_val_loss,\n        }\n        torch.save (checkpoint, path)\n        gc.collect (); torch.cuda.empty_cache ()\n        print (\"saved checkpoint\", path)\n        return\n    \n    def load_checkpoint (self, path, isResume=False):\n        \n        epoch      = 0\n        checkpoint = torch.load (path, map_location=torch.device ('cpu'))\n        self.model.load_state_dict (checkpoint['model_state_dict'])\n        if isResume:\n            \n            self.optimizer.load_state_dict (checkpoint['optimizer_state_dict'])\n            self.lr_scheduler.load_state_dict (checkpoint['lr_sched_state_dict'])\n            epoch = checkpoint['epoch']\n            self.training_stats  = checkpoint['training_stats']\n            self.min_val_loss    = checkpoint['min_val_loss']\n            self.min_train_loss  = checkpoint['min_train_loss']\n            self.max_val_acc     = checkpoint['max_val_acc']\n            print (\"Loaded model, optimizer, and lr_scheduler from -\", path)\n        else:\n            print (\"Loaded model from -\", path)\n            \n        self.model.train ()\n        return epoch\n    \n    def train (self):\n        \n        seed_everything (seed=CFG.seed)\n        step             = 0\n        total_t0         = time.time ()\n        scaler           = GradScaler()\n        for epoch_i in range (self.start_epoch, self.epochs):\n            \n            avg_epoch_train_loss   = 0\n            total_epoch_train_loss = 0\n            print('======== Epoch {:} / {:} ========'.format (epoch_i + 1, self.epochs))\n            t0 = time.time ()\n            self.model.train ()\n            for stp, batch in tqdm (enumerate (self.train_dataloader), total=len(self.train_dataloader)):\n                \n                # Print Stats\n                # if step % CFG.print_every == 0:\n                #     elapsed = format_time (time.time() - t0)\n                #     print ('  Batch {:>5,}  of  {:>5,}.    Elapsed: {:}.'.format (step, len (self.train_dataloader), elapsed))                \n                if ((CFG.max_steps > 0 and CFG.max_steps < step) or \n                    (CFG.eval_steps>0 and stp==CFG.eval_steps)): # or step==0):   # TODO: rm this comment\n                    \n                    self.save_checkpoint (epoch_i, self.modelFile)\n                    training_time = format_time (time.time () - t0)            \n                    if self.validation_dataloader:\n                        \n                        avg_val_loss, avg_val_accuracy, validation_time = self.evaluate (epoch_i, avg_epoch_train_loss, training_time)\n                        # save this model if the eval loss decreases from the minimum so far\n                        checkpoint_epoch = epoch_i\n                        if stp==CFG.eval_steps:\n                            # don't count this epoch in the checkpoint since this epoch \n                            # has not completed. Hence, checkpoint at prev epoch\n                            checkpoint_epoch = epoch_i-1\n                        if avg_val_loss < self.min_val_loss:                             \n                            self.min_val_loss = avg_val_loss\n                            self.save_checkpoint (checkpoint_epoch, self.minLossModelFile)\n                        if avg_val_accuracy > self.max_val_acc:\n                            self.max_val_acc = avg_val_accuracy\n                            self.save_checkpoint (checkpoint_epoch, self.maxAccModelFile)\n                    if CFG.max_steps > 0 and CFG.max_steps < step:\n                        \n                        print (\"\")\n                        print (\"Training complete!\")\n                        print (\"Total training took {:} (h:mm:ss)\".format (format_time (time.time ()-total_t0)))\n                        self.isTrained = True\n                        self.model.cpu ()\n                        self.model.eval ()\n                        self.save_checkpoint (epoch_i, self.modelFile)\n                        try:\n                            torch.cuda.empty_cache ()\n                            self.plot_train_stats (self.training_stats)\n                        except:\n                            pass\n                        return pd.DataFrame (self.training_stats)\n                \n                ########################################################\n                # Train\n                ########################################################\n                # self.model.zero_grad ()\n                anc_imgs = batch[0].to (self.device)\n                pos_imgs = batch[1].to (self.device)\n                neg_imgs = batch[2].to (self.device)\n                with autocast():\n                    \n                    # same imgs\n                    Ea, Ep = self.model (anc_imgs, pos_imgs)\n                    target = torch.ones (Ea.size (0)).to (CFG.device)\n                    loss1  = self.criterion (Ea, Ep, target)\n                    scaler.scale (loss1).backward ()\n                    \n                    # diff imgs\n                    Ea, En = self.model (anc_imgs, neg_imgs)\n                    target = torch.zeros (Ea.size (0)).to (CFG.device)\n                    loss0  = self.criterion (Ea, En, target)\n                    scaler.scale (loss0).backward ()\n                    \n                    torch.nn.utils.clip_grad_norm_ (self.model.parameters (), CFG.max_grad_norm)                    \n                    scaler.step (self.optimizer)\n                    scaler.update ()                    \n                    self.optimizer.zero_grad ()\n                    self.lr_scheduler.step ()\n                    \n                total_epoch_train_loss += (loss0.cpu ().item () + loss1.cpu ().item ()) / 2.0\n                avg_epoch_train_loss    = total_epoch_train_loss / (stp+1)\n                step += 1\n            # all steps of an epoch end\n            \n            # Measure how long this epoch took.\n            training_time = format_time (time.time () - t0)            \n            print (\"  Average training loss: {0:.4f}\".format (avg_epoch_train_loss))\n            print (\"  Training epcoh took: {:}\".format (training_time))            \n            if self.validation_dataloader:    \n                \n                avg_val_loss, avg_val_accuracy, validation_time = self.evaluate (epoch_i, avg_epoch_train_loss, training_time)\n                # save this epoch's model if the eval loss decreases from the minimum so far\n                if avg_val_loss < self.min_val_loss:                    \n                    self.min_val_loss = avg_val_loss\n                    self.save_checkpoint (epoch_i, self.minLossModelFile)\n                if avg_val_accuracy > self.max_val_acc:\n                    self.max_val_acc = avg_val_accuracy\n                    self.save_checkpoint (epoch_i, self.maxAccModelFile)\n            else:                \n                training_stats.append ({\n                    'epoch'         : epoch_i + 1,\n                    'training_loss' : avg_epoch_train_loss,\n                    'training_time' : training_time,\n                })\n                if avg_train_loss < self.min_train_loss:                     \n                    self.min_train_loss = avg_train_loss\n                    self.save_checkpoint (epoch_i, self.minLossModelFile)\n            self.save_checkpoint (epoch_i, self.modelFile)\n            # 1 epoch end\n        # all epochs end\n        \n        # just get the best class thresholds at the end\n        if self.validation_dataloader:\n            print ('At training end, threshold Adjustment (last row of the train summary DF)')\n            print (self.evaluate (epoch_i, avg_epoch_train_loss, training_time, isThreshAdjust=True))\n            print ('<: avg_val_loss, avg_val_accuracy, validation_time')\n        \n        print (\"***** Training complete! *****\")\n        print (\"Total training took {:} (h:mm:ss)\".format (format_time (time.time ()-total_t0)))\n        self.isTrained = True\n        self.model.cpu ()\n        self.model.eval ()\n        try:\n            torch.cuda.empty_cache ()\n            self.plot_train_stats (self.training_stats)\n        except:\n            pass\n        return pd.DataFrame (self.training_stats)\n    \n    def evaluate (self, epoch_i, avg_train_loss=999, training_time=999, isThreshAdjust=False):\n        \n        pdist = nn.PairwiseDistance (p=2)\n        t0           = time.time ()\n        all_labels   = []\n        all_pred_prs = []\n        # Put the model in evaluation mode--the dropout layers behave differently\n        # during evaluation.\n        self.model.eval ()\n        \n        # Tracking variables\n        total_eval_accuracy  = 0\n        total_eval_loss      = 0\n        nb_eval_steps        = 0\n        correct_pred_count   = 0\n        total_pred_count     = 0\n        # Evaluate data for one epoch\n        for batch in self.validation_dataloader:\n            with torch.no_grad ():\n                \n                anc_imgs = batch[0].to (self.device)\n                pos_imgs = batch[1].to (self.device)\n                neg_imgs = batch[2].to (self.device)                \n                \n                # same imgs\n                Ea, Ep = self.model (anc_imgs, pos_imgs)\n                target = torch.ones (Ea.size (0)).to (CFG.device)\n                loss1  = self.criterion (Ea, Ep, target).cpu ().item ()\n                \n                # diff imgs\n                Ea, En = self.model (anc_imgs, neg_imgs)\n                target = torch.zeros (Ea.size (0)).to (CFG.device)\n                loss0  = self.criterion (Ea, En, target).cpu ().item ()\n                \n                dist_Ea_Ep = pdist (Ea, Ep).cpu ().numpy ()\n                dist_Ea_En = pdist (Ea, En).cpu ().numpy ()\n                \n            loss = (loss0 + loss1) / 2.0\n            total_eval_loss    += loss\n            correct_pred_count += np.sum ((dist_Ea_Ep < dist_Ea_En) + 0.0)\n            total_pred_count   += len (dist_Ea_Ep)\n                    \n        avg_val_loss     = total_eval_loss / len (self.validation_dataloader)\n        avg_val_accuracy = correct_pred_count / total_pred_count\n        print (\"Val Loss: {0:.4f}\".format (avg_val_loss))\n        print (\"Val fuzzy Accuracy: {0:.4f}\".format (avg_val_accuracy))\n        validation_time = format_time (time.time () - t0)\n        self.training_stats.append ({\n                'epoch'         : epoch_i + 1,\n                'training_loss' : avg_train_loss,\n                'eval_loss'     : avg_val_loss,\n                'eval_accuracy' : avg_val_accuracy,\n                'training_time' : training_time,\n                'eval_time'     : validation_time                   \n        })\n        self.model.train ()\n        print (\"Validation took {:} (h:mm:ss)\".format (format_time (time.time () - t0)))\n        return avg_val_loss, avg_val_accuracy, validation_time\n        \n        \n    def plot_train_stats (self, training_stats):\n        \"\"\"\n        Draw Classification Report curve\n        \"\"\"\n        \n        accuracies = eval_losses = tr_losses = epochs = -1\n        epochs = len (training_stats)\n        if 'eval_accuracy' in training_stats[0]:\n            accuracies = [e['eval_accuracy'] for e in training_stats]\n            sns.lineplot (x=np.arange(1, epochs + 1), y=accuracies, label='val_accuracy')\n        if 'eval_loss' in training_stats[0]:\n            eval_losses= [e['eval_loss'] for e in training_stats]\n        if 'training_loss'  in training_stats[0]:\n            tr_losses  = [e['training_loss'] for e in training_stats]\n            sns.lineplot (x=np.arange(1, epochs + 1), y=tr_losses,  label='tr_losses')\n            \n        plt.show ()\n        print ('accuracies :', accuracies)        \n        print ('eval_losses:', eval_losses)\n        print ('tr_losses  :', tr_losses)\n        return\n    \n    def get_trained_model (self):\n        \n        if self.isTrained:\n            return self.model.eval ()\n        return None","metadata":{"papermill":{"duration":0.126789,"end_time":"2021-03-29T06:13:09.896626","exception":false,"start_time":"2021-03-29T06:13:09.769837","status":"completed"},"tags":[],"trusted":true},"execution_count":101,"outputs":[]},{"cell_type":"code","source":"def free_gpu_cache ():\n    \n    # print(\"Initial GPU Usage\")\n    # gpu_usage()                             \n\n    torch.cuda.empty_cache ()\n\n    # cuda.select_device(0)\n    # cuda.close()\n    # cuda.select_device(0)\n\n    # print(\"GPU Usage after emptying the cache\")\n    # gpu_usage()\n    return\n\n# free_gpu_cache()           ","metadata":{"papermill":{"duration":0.065307,"end_time":"2021-03-29T06:13:10.015641","exception":false,"start_time":"2021-03-29T06:13:09.950334","status":"completed"},"tags":[],"trusted":true},"execution_count":102,"outputs":[]},{"cell_type":"markdown","source":"## Train","metadata":{"papermill":{"duration":0.051834,"end_time":"2021-03-29T06:13:10.119642","exception":false,"start_time":"2021-03-29T06:13:10.067808","status":"completed"},"tags":[]}},{"cell_type":"code","source":"def train_fold_loop (checkpoint_path=None, isResume=False):\n\n    print (f\"========== training ==========\")\n    fold = 0 # fold is not used\n    criterion      = get_criterion (CFG.margin)\n    model          = CFG.MODEL\n    if model is None and checkpoint_path is None:\n        print (\"CFG.MODEL is None\")\n        model      = getModel (fold, isTrain=True)\n        model      = model.float()\n    elif model is not None and checkpoint_path is not None:\n        checkpoint_path = None\n    elif model is None and checkpoint_path is not None:\n        print (\"CFG.MODEL is None\")\n        model      = getModel (fold, isTrain=False)\n        model      = model.float()\n        \n    train_dataset  = TripletImageDataset ()\n    valid_dataset  = TripletImageDataset (df=TEST_DF, transform=get_transforms ('valid'))\n    trainer        = MyTrainer (\n        fold            = fold,\n        model           = model,\n        train_dataset   = train_dataset,\n        eval_dataset    = valid_dataset,\n        criterion       = criterion,\n        checkpoint_path = checkpoint_path,\n        isResume        = isResume\n    )\n    metrics = trainer.train ()\n    return metrics\n    \n    # To plot lr uncomment this\n    # lrs = []\n    # for i in range (CFG.epochs*len (trainer.train_dataloader)):\n    #     trainer.lr_scheduler.step ()\n    #     lrs.append (trainer.optimizer.param_groups[0][\"lr\"])\n    # print (lrs)\n    # plt.plot (lrs)\n    # plt.show ()","metadata":{"papermill":{"duration":0.069432,"end_time":"2021-03-29T06:13:10.24463","exception":false,"start_time":"2021-03-29T06:13:10.175198","status":"completed"},"tags":[],"trusted":true},"execution_count":103,"outputs":[]},{"cell_type":"code","source":"def train_main (checkpoint_path=None, isResume=False):\n    \n    print (f\"========== train_main() ==========\")\n    if CFG.isTrain:        \n        valid_scores_df = pd.DataFrame ()\n        for fold in range (CFG.n_fold):\n            if fold in CFG.train_fold:\n                \n                valid_scores_fold_df = train_fold_loop (checkpoint_path, isResume)\n                # valid_scores_fold = np.array (valid_scores_fold).reshape ((1, -1))\n                valid_scores_df = valid_scores_df.append (valid_scores_fold_df)\n                \n        print (f\"========== CV ==========\")\n        # print (valid_scores_df)\n        # valid_scores = np.vstack (valid_scores)\n        # valid_scores = np.mean (valid_scores, axis=0)\n        valid_scores = valid_scores_df.iloc[-1, :]  #.mean ()\n        print (\"CV Scores :-\");  print (valid_scores)\n    return valid_scores_df","metadata":{"papermill":{"duration":0.061261,"end_time":"2021-03-29T06:13:10.357409","exception":false,"start_time":"2021-03-29T06:13:10.296148","status":"completed"},"tags":[],"trusted":true},"execution_count":104,"outputs":[]},{"cell_type":"markdown","source":"# Single config training","metadata":{"papermill":{"duration":0.050971,"end_time":"2021-03-29T06:13:10.459841","exception":false,"start_time":"2021-03-29T06:13:10.40887","status":"completed"},"tags":[]}},{"cell_type":"markdown","source":"!mkdir -p /kaggle/working/Output/\n!touch /kaggle/working/Output/train.log\ngc.collect ()\nmodel_names = timm.list_models (pretrained=True)\nmodel_names = timm.list_models ('*resnet*', pretrained=True)\npprint (model_names)\nLOGGER = init_logger ()\nseed_everything (seed=CFG.seed)","metadata":{"papermill":{"duration":0.051612,"end_time":"2021-03-29T06:13:10.563247","exception":false,"start_time":"2021-03-29T06:13:10.511635","status":"completed"},"tags":[]}},{"cell_type":"markdown","source":"valid_scores_df = train_main ()\n\nvalid_scores_df","metadata":{"papermill":{"duration":0.051001,"end_time":"2021-03-29T06:13:10.665748","exception":false,"start_time":"2021-03-29T06:13:10.614747","status":"completed"},"tags":[]}},{"cell_type":"markdown","source":"# To train, uncomment these","metadata":{"papermill":{"duration":0.052916,"end_time":"2021-03-29T06:13:10.770432","exception":false,"start_time":"2021-03-29T06:13:10.717516","status":"completed"},"tags":[]}},{"cell_type":"code","source":"gc.collect (); torch.cuda.empty_cache ()\nCFG.warmup_steps = 0.5\nCFG.eval_steps   = 0.5\nCFG.num_workers  = 8\nCFG.size = 128         # [128, 224, 384, 512, 640, 1024]\nCFG.train_batch_size = 88\nCFG.eval_batch_size  = 88\nCFG.freeze = True\nCFG.epochs = 1\nprint (f\"***** Training for size={CFG.size} freeze={CFG.isFreeze} *****\")\nvalid_scores_df = train_main () \nvalid_scores_df","metadata":{"trusted":true},"execution_count":null,"outputs":[{"name":"stdout","text":"***** Training for size=128 freeze=True *****\n========== train_main() ==========\n========== training ==========\nCFG.MODEL is None\nBuilding Model Backbone for efficientnet_b3 model\n======== Epoch 1 / 1 ========\n","output_type":"stream"},{"name":"stderr","text":"  2%|▏         | 7/351 [00:21<07:57,  1.39s/it]  ","output_type":"stream"}]},{"cell_type":"code","source":"gc.collect (); torch.cuda.empty_cache ()\nCFG.warmup_steps = 0.5\nCFG.eval_steps   = 0.5\nCFG.num_workers = 8\nCFG.size = 128\nCFG.train_batch_size = 16\nCFG.eval_batch_size  = 16\nCFG.isFreeze = False\nCFG.epochs = 3\nprint (f\"***** Training for size={CFG.size} freeze={CFG.isFreeze} *****\")\nvalid_scores_df = train_main ()\nvalid_scores_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gc.collect (); torch.cuda.empty_cache ()\nCFG.num_workers      = 4\nCFG.warmup_steps     = 0.5\nCFG.eval_steps       = 0.5\nCFG.size             = 384\nCFG.train_batch_size = 24\nCFG.eval_batch_size  = 24 \nCFG.isFreeze         = True\nCFG.epochs           = 1\nprint (f\"***** Training for size={CFG.size} freeze={CFG.isFreeze} *****\")\nvalid_scores_df      = train_main () # (checkpoint_path=\"../input/vin-manual-torch-trainer-fp16-cbamresnet50-gradcam/cbam_resnet50_384_fold0.pth\")\nvalid_scores_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gc.collect (); torch.cuda.empty_cache ()\nCFG.num_workers      = 8\nCFG.warmup_steps     = 0.5\nCFG.eval_steps       = 0.5\nCFG.size             = 384\nCFG.train_batch_size = 8 \nCFG.eval_batch_size  = 8 \nCFG.isFreeze         = False\nCFG.epochs           = 3\nprint (f\"***** Training for size={CFG.size} freeze={CFG.isFreeze} *****\")\nvalid_scores_df      = train_main ()\nvalid_scores_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"gc.collect (); torch.cuda.empty_cache ()\nCFG.num_workers      = 8\nCFG.warmup_steps     = 0.5\n# CFG.eval_steps       = 0.5\nCFG.size             = 512\nCFG.train_batch_size = 80 \nCFG.eval_batch_size  = 80 \nCFG.isFreeze         = True\nCFG.epochs           = 1\nprint (f\"***** Training for size={CFG.size} freeze={CFG.isFreeze} *****\")\nvalid_scores_df      = train_main () # (checkpoint_path=\"../input/vin-cbamresnet50-384-fold0/cbam_resnet50_384_fold0.pth\") \nvalid_scores_df","metadata":{"papermill":{"duration":0.052836,"end_time":"2021-03-29T06:13:11.505308","exception":false,"start_time":"2021-03-29T06:13:11.452472","status":"completed"},"tags":[]}},{"cell_type":"markdown","source":"gc.collect (); torch.cuda.empty_cache ()\nCFG.num_workers      = 8\nCFG.warmup_steps     = 0.5\n# CFG.eval_steps       = 0.5\nCFG.size             = 512\nCFG.train_batch_size = 17 \nCFG.eval_batch_size  = 17 \nCFG.isFreeze         = False\nCFG.epochs           = 1\nprint (f\"***** Training for size={CFG.size} freeze={CFG.isFreeze} *****\")\nvalid_scores_df      = train_main () # (checkpoint_path=\"../input/vin-manual-torch-trainer-fp16-cbamresnet50-gradcam/cbam_resnet50_384_fold0.pth\")\nvalid_scores_df","metadata":{"papermill":{"duration":0.051632,"end_time":"2021-03-29T06:13:11.608811","exception":false,"start_time":"2021-03-29T06:13:11.557179","status":"completed"},"tags":[]}},{"cell_type":"code","source":"print ('Done !')","metadata":{"papermill":{"duration":0.109165,"end_time":"2021-03-29T06:13:39.505776","exception":false,"start_time":"2021-03-29T06:13:39.396611","status":"completed"},"tags":[],"trusted":true},"execution_count":null,"outputs":[]}]}