From 099f373a633623a3efc013e22c5302746b4a8c86 Mon Sep 17 00:00:00 2001
From: JessyD <jejedafflon@gmail.com>
Date: Sun, 5 Feb 2023 16:08:33 -0500
Subject: [PATCH 1/6] Add tutorial for FID (WIP)

---
 .../realism_diversity_metrics.ipynb           | 1100 +++++++++++++++++
 .../realism_diversity_metrics.py              |  229 ++++
 2 files changed, 1329 insertions(+)
 create mode 100644 tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
 create mode 100644 tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py

diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
new file mode 100644
index 00000000..508ab0f5
--- /dev/null
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
@@ -0,0 +1,1100 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "393fe9fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO: Add Open in Colab"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80769612",
+   "metadata": {},
+   "source": [
+    "## Setup environment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9d28a4f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/mnt_homes/home4T7/jdafflon/GenerativeModels\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd /home/jdafflon/GenerativeModels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "629c60fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MONAI version: 1.1.dev2239\n",
+      "Numpy version: 1.23.4\n",
+      "Pytorch version: 1.13.0\n",
+      "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n",
+      "MONAI rev id: 13b24fa92b9d98bd0dc6d5cdcb52504fd09e297b\n",
+      "MONAI __file__: /home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/__init__.py\n",
+      "\n",
+      "Optional dependencies:\n",
+      "Pytorch Ignite version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "Nibabel version: 4.0.2\n",
+      "scikit-image version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "Pillow version: 9.2.0\n",
+      "Tensorboard version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "gdown version: 4.6.0\n",
+      "TorchVision version: 0.14.0\n",
+      "tqdm version: 4.64.1\n",
+      "lmdb version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "psutil version: 5.9.4\n",
+      "pandas version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "einops version: 0.6.0\n",
+      "transformers version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "mlflow version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "pynrrd version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "\n",
+      "For details about installing the optional dependencies, please visit:\n",
+      "    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import os\n",
+    "import torch\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from monai.apps import MedNISTDataset\n",
+    "from monai import transforms\n",
+    "from monai.data import DataLoader, Dataset\n",
+    "from monai.networks.layers import Act\n",
+    "\n",
+    "\n",
+    "from monai.config import print_config\n",
+    "from monai.utils import set_determinism\n",
+    "\n",
+    "from generative.metrics import FID\n",
+    "from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL\n",
+    "from generative.networks.schedulers import DDPMScheduler\n",
+    "from generative.inferers import DiffusionInferer\n",
+    "\n",
+    "print_config()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f0e0b019",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def subtract_mean(x: torch.Tensor) -> torch.Tensor:\n",
+    "    mean = [0.406, 0.456, 0.485]\n",
+    "    x[:, 0, :, :] -= mean[0]\n",
+    "    x[:, 1, :, :] -= mean[1]\n",
+    "    x[:, 2, :, :] -= mean[2]\n",
+    "    return x\n",
+    "\n",
+    "def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:\n",
+    "    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))\n",
+    "    return x / (norm_factor + eps)\n",
+    "\n",
+    "def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:\n",
+    "    return x.mean([2, 3], keepdim=keepdim)\n",
+    "\n",
+    "def get_features(image):\n",
+    "\n",
+    "    # If input has just 1 channel, repeat channel to have 3 channels\n",
+    "    if image.shape[1]:\n",
+    "        image = image.repeat(1, 3, 1, 1)\n",
+    "\n",
+    "    # Change order from 'RGB' to 'BGR'\n",
+    "    image = image[:, [2, 1, 0], ...]\n",
+    "\n",
+    "    # Subtract mean used during training\n",
+    "    image = subtract_mean(image)\n",
+    "\n",
+    "    # Get model outputs\n",
+    "    with torch.no_grad():\n",
+    "        feature_image = radnet.forward(image)\n",
+    "        # TODO: FIX ME\n",
+    "        feature_image = feature_image[:, :, 0, 0]\n",
+    "\n",
+    "    # normalise through channels\n",
+    "    features_image = normalize_tensor(feature_image)\n",
+    "\n",
+    "    return feature_image"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52dbd59a",
+   "metadata": {},
+   "source": [
+    "## Setup data directory\n",
+    "\n",
+    "You can specify a directory with the MONAI_DATA_DIRECTORY environment variable.\n",
+    "This allows you to save results and reuse downloads.\n",
+    "\n",
+    "If not specified a temporary directory will be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e0b189f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/tmp/tmpzmzorzlg\n"
+     ]
+    }
+   ],
+   "source": [
+    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
+    "#root_dir = tempfile.mkdtemp() if directory is None else directory\n",
+    "root_dir = \"/tmp/tmpzmzorzlg\"\n",
+    "print(root_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d79c501",
+   "metadata": {},
+   "source": [
+    "## Set deterministic training for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "39c4b986",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "set_determinism(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38e5a5d1",
+   "metadata": {},
+   "source": [
+    "## Define the models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b2bdf536",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using cuda\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Using {device}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "195db858",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "autoencoderkl = AutoencoderKL(\n",
+    "    spatial_dims=2,\n",
+    "    in_channels=1,\n",
+    "    out_channels=1,\n",
+    "    num_channels=64,\n",
+    "    latent_channels=3,\n",
+    "    ch_mult=(1, 2, 2),\n",
+    "    num_res_blocks=1,\n",
+    "    norm_num_groups=32,\n",
+    "    attention_levels=(False, False, True),\n",
+    ")\n",
+    "autoencoderkl = autoencoderkl.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b951da77",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "c2424564",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "unet = DiffusionModelUNet(\n",
+    "    spatial_dims=2, in_channels=3, out_channels=3, num_res_blocks=1, num_channels=(128, 256, 256), num_head_channels=256\n",
+    ")\n",
+    "\n",
+    "scheduler = DDPMScheduler(num_train_timesteps=1000, beta_schedule=\"linear\", beta_start=0.0015, beta_end=0.0195)\n",
+    "\n",
+    "inferer = DiffusionInferer(scheduler)\n",
+    "\n",
+    "discriminator = PatchDiscriminator(\n",
+    "    spatial_dims=2,\n",
+    "    num_layers_d=3,\n",
+    "    num_channels=32,\n",
+    "    in_channels=1,\n",
+    "    out_channels=1,\n",
+    "    kernel_size=4,\n",
+    "    activation=(Act.LEAKYRELU, {\"negative_slope\": 0.2}),\n",
+    "    norm=\"BATCH\",\n",
+    "    bias=False,\n",
+    "    padding=1,\n",
+    ")\n",
+    "discriminator.to(device)\n",
+    "unet = unet.to(device)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f05d9e13",
+   "metadata": {},
+   "source": [
+    "## Load pre-trained model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "76e684de",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cwd = Path.cwd()\n",
+    "model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_aeutoencoderkl.pth\")\n",
+    "autoencoderkl.load_state_dict(torch.load(str(model_path)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "0b7ea4c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cwd = Path.cwd()\n",
+    "model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_unet.pth\")\n",
+    "unet.load_state_dict(torch.load(str(model_path)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c187146",
+   "metadata": {},
+   "source": [
+    "## Get the validation split for the real images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "bd4c90f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2023-02-05 15:10:35,962 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2023-02-05 15:10:35,963 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
+      "2023-02-05 15:10:35,964 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2614.70it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "val_data = MedNISTDataset(root_dir=root_dir, section=\"validation\", download=True, seed=0)\n",
+    "val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"Hand\"]\n",
+    "val_transforms = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.LoadImaged(keys=[\"image\"]),\n",
+    "        transforms.EnsureChannelFirstd(keys=[\"image\"]),\n",
+    "        transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),\n",
+    "    ]\n",
+    ")\n",
+    "val_ds = Dataset(data=val_datalist, transform=val_transforms)\n",
+    "val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e2e2332",
+   "metadata": {},
+   "source": [
+    "## Get features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e9ded5b8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in /home/jdafflon/.cache/torch/hub/Warvito_radimagenet-models_main\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "ResNet50(\n",
+       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n",
+       "  (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.01, affine=True, track_running_stats=True)\n",
+       "  (relu): ReLU(inplace=True)\n",
+       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+       "  (layer1): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "        (1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer2): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(2, 2))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2))\n",
+       "        (1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer3): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(2, 2))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2))\n",
+       "        (1): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (4): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (5): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer4): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(2, 2))\n",
+       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2))\n",
+       "        (1): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "radnet = torch.hub.load(\"Warvito/radimagenet-models\", model=\"radimagenet_resnet50\", verbose=True)\n",
+    "radnet.to(device)\n",
+    "radnet.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "1b48d18c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:01<00:00, 15.06it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "real_eval_feats = []\n",
+    "\n",
+    "pbar = tqdm(enumerate(val_loader), total=len(val_loader))\n",
+    "for step, x in pbar:\n",
+    "    real_img = x[\"image\"].to(device)\n",
+    "    features_real = get_features(real_img)\n",
+    "    real_eval_feats.append(features_real.cpu())\n",
+    "    pbar.update()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "136340bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "real_eval_feats = torch.cat(real_eval_feats, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5676aa62",
+   "metadata": {},
+   "source": [
+    "## Generate synthetic images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "a34810f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.31it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.66it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.59it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.42it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.37it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.41it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "10\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "12\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "14\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.31it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "15\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:18<00:00, 54.16it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "synth_eval_feats = []\n",
+    "unet.eval()\n",
+    "\n",
+    "#pbar = tqdm(enumerate(val_loader), total=len(val_loader))\n",
+    "for step, x in enumerate(val_loader):\n",
+    "    print(step)\n",
+    "    n_synthetic_images = len(x['image'])\n",
+    "    syn_image = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "    syn_image = syn_image.to(device)\n",
+    "    scheduler.set_timesteps(num_inference_steps=1000)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "\n",
+    "        z_mu, z_sigma = autoencoderkl.encode(syn_image)\n",
+    "        z = autoencoderkl.sampling(z_mu, z_sigma)\n",
+    "\n",
+    "        noise = torch.randn_like(z).to(device)\n",
+    "        syn_image, intermediates = inferer.sample(\n",
+    "            input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100\n",
+    "        )\n",
+    "        syn_image = autoencoderkl.decode(syn_image)\n",
+    "\n",
+    "        features_syn_image = get_features(syn_image)\n",
+    "        synth_eval_feats.append(features_syn_image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "7701d943",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot 3 examples from the synthetic data\n",
+    "fig, ax = plt.subplots(nrows=1, ncols=3)\n",
+    "for image_n in range(3):\n",
+    "    ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap=\"gray\")\n",
+    "    ax[image_n].axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "17d7e059",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([1005, 2048]) (1005, 2048)\n"
+     ]
+    }
+   ],
+   "source": [
+    "synch_eval_feats2 = torch.cat(synth_eval_feats, axis=0)\n",
+    "print(synch_eval_feats2.shape, real_eval_feats.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "c075646c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fid = FID()\n",
+    "results = fid(real_eval_feats.cpu(), synch_eval_feats2.cpu())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "3ed40388",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "nan"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results.item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "341e539b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[0.0000, 0.0978, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
+       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
+       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
+       "        ...,\n",
+       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
+       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
+       "        [0.0000, 0.0000, 0.0347,  ..., 0.0000, 0.0000, 0.0000]],\n",
+       "       device='cuda:0')"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "synch_eval_feats2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "09462ed2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7f2517d73790>"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(synch_eval_feats2.cpu())\n",
+    "plt.colorbar()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "d57a9267",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7f2517c5bf40>"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(real_eval_feats.cpu())\n",
+    "plt.colorbar()"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
new file mode 100644
index 00000000..ef00b278
--- /dev/null
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
@@ -0,0 +1,229 @@
+# +
+# TODO: Add Open in Colab
+# -
+
+# ## Setup environment
+
+# %cd /home/jdafflon/GenerativeModels
+
+# +
+import torch
+import os
+import torch
+from pathlib import Path
+
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+from monai.apps import MedNISTDataset
+from monai import transforms
+from monai.data import DataLoader, Dataset
+from monai.networks.layers import Act
+
+
+from monai.config import print_config
+from monai.utils import set_determinism
+
+from generative.metrics import FID
+from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL
+from generative.networks.schedulers import DDPMScheduler
+from generative.inferers import DiffusionInferer
+
+print_config()
+
+
+# +
+def subtract_mean(x: torch.Tensor) -> torch.Tensor:
+    mean = [0.406, 0.456, 0.485]
+    x[:, 0, :, :] -= mean[0]
+    x[:, 1, :, :] -= mean[1]
+    x[:, 2, :, :] -= mean[2]
+    return x
+
+def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:
+    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
+    return x / (norm_factor + eps)
+
+def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
+    return x.mean([2, 3], keepdim=keepdim)
+
+def get_features(image):
+
+    # If input has just 1 channel, repeat channel to have 3 channels
+    if image.shape[1]:
+        image = image.repeat(1, 3, 1, 1)
+
+    # Change order from 'RGB' to 'BGR'
+    image = image[:, [2, 1, 0], ...]
+
+    # Subtract mean used during training
+    image = subtract_mean(image)
+
+    # Get model outputs
+    with torch.no_grad():
+        feature_image = radnet.forward(image)
+        # TODO: FIX ME
+        feature_image = feature_image[:, :, 0, 0]
+
+    # normalise through channels
+    features_image = normalize_tensor(feature_image)
+
+    return feature_image
+
+
+# -
+
+# ## Setup data directory
+#
+# You can specify a directory with the MONAI_DATA_DIRECTORY environment variable.
+# This allows you to save results and reuse downloads.
+#
+# If not specified a temporary directory will be used.
+
+directory = os.environ.get("MONAI_DATA_DIRECTORY")
+#root_dir = tempfile.mkdtemp() if directory is None else directory
+root_dir = "/tmp/tmpzmzorzlg"
+print(root_dir)
+
+# ## Set deterministic training for reproducibility
+
+set_determinism(0)
+
+# ## Define the models
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using {device}")
+
+autoencoderkl = AutoencoderKL(
+    spatial_dims=2,
+    in_channels=1,
+    out_channels=1,
+    num_channels=64,
+    latent_channels=3,
+    ch_mult=(1, 2, 2),
+    num_res_blocks=1,
+    norm_num_groups=32,
+    attention_levels=(False, False, True),
+)
+autoencoderkl = autoencoderkl.to(device)
+
+
+
+# +
+unet = DiffusionModelUNet(
+    spatial_dims=2, in_channels=3, out_channels=3, num_res_blocks=1, num_channels=(128, 256, 256), num_head_channels=256
+)
+
+scheduler = DDPMScheduler(num_train_timesteps=1000, beta_schedule="linear", beta_start=0.0015, beta_end=0.0195)
+
+inferer = DiffusionInferer(scheduler)
+
+discriminator = PatchDiscriminator(
+    spatial_dims=2,
+    num_layers_d=3,
+    num_channels=32,
+    in_channels=1,
+    out_channels=1,
+    kernel_size=4,
+    activation=(Act.LEAKYRELU, {"negative_slope": 0.2}),
+    norm="BATCH",
+    bias=False,
+    padding=1,
+)
+discriminator.to(device)
+unet = unet.to(device)
+
+# -
+
+# ## Load pre-trained model
+
+cwd = Path.cwd()
+model_path = cwd / Path("tutorials/generative/2d_ldm/best_aeutoencoderkl.pth")
+autoencoderkl.load_state_dict(torch.load(str(model_path)))
+
+cwd = Path.cwd()
+model_path = cwd / Path("tutorials/generative/2d_ldm/best_unet.pth")
+unet.load_state_dict(torch.load(str(model_path)))
+
+# ## Get the validation split for the real images
+
+val_data = MedNISTDataset(root_dir=root_dir, section="validation", download=True, seed=0)
+val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "Hand"]
+val_transforms = transforms.Compose(
+    [
+        transforms.LoadImaged(keys=["image"]),
+        transforms.EnsureChannelFirstd(keys=["image"]),
+        transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),
+    ]
+)
+val_ds = Dataset(data=val_datalist, transform=val_transforms)
+val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)
+
+# ## Get features
+
+radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
+radnet.to(device)
+radnet.eval()
+
+# +
+real_eval_feats = []
+
+pbar = tqdm(enumerate(val_loader), total=len(val_loader))
+for step, x in pbar:
+    real_img = x["image"].to(device)
+    features_real = get_features(real_img)
+    real_eval_feats.append(features_real.cpu())
+    pbar.update()
+# -
+
+real_eval_feats = torch.cat(real_eval_feats, axis=0)
+
+# ## Generate synthetic images
+
+# +
+synth_eval_feats = []
+unet.eval()
+
+#pbar = tqdm(enumerate(val_loader), total=len(val_loader))
+for step, x in enumerate(val_loader):
+    print(step)
+    n_synthetic_images = len(x['image'])
+    syn_image = torch.randn((n_synthetic_images, 1, 64, 64))
+    syn_image = syn_image.to(device)
+    scheduler.set_timesteps(num_inference_steps=1000)
+
+    with torch.no_grad():
+
+        z_mu, z_sigma = autoencoderkl.encode(syn_image)
+        z = autoencoderkl.sampling(z_mu, z_sigma)
+
+        noise = torch.randn_like(z).to(device)
+        syn_image, intermediates = inferer.sample(
+            input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100
+        )
+        syn_image = autoencoderkl.decode(syn_image)
+
+        features_syn_image = get_features(syn_image)
+        synth_eval_feats.append(features_syn_image)
+# -
+
+# Plot 3 examples from the synthetic data
+fig, ax = plt.subplots(nrows=1, ncols=3)
+for image_n in range(3):
+    ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap="gray")
+    ax[image_n].axis("off")
+
+synch_eval_feats2 = torch.cat(synth_eval_feats, axis=0)
+print(synch_eval_feats2.shape, real_eval_feats.shape)
+
+fid = FID()
+results = fid(real_eval_feats.cpu(), synch_eval_feats2.cpu())
+
+results.item()
+
+synch_eval_feats2
+
+plt.imshow(synch_eval_feats2.cpu())
+plt.colorbar()
+
+plt.imshow(real_eval_feats.cpu())
+plt.colorbar()

From 6227a172b938851426ba759e70299edb8a0b5927 Mon Sep 17 00:00:00 2001
From: JessyD <jejedafflon@gmail.com>
Date: Mon, 6 Feb 2023 20:20:34 -0500
Subject: [PATCH 2/6] FID returning NaNs (WIP)

---
 .../realism_diversity_metrics/FID_test.ipynb  | 407 ++++++++++++++++++
 .../realism_diversity_metrics/FID_test.py     |  82 ++++
 .../realism_diversity_metrics.ipynb           | 346 +++++++++------
 .../realism_diversity_metrics.py              |  86 +++-
 4 files changed, 776 insertions(+), 145 deletions(-)
 create mode 100644 tutorials/generative/realism_diversity_metrics/FID_test.ipynb
 create mode 100644 tutorials/generative/realism_diversity_metrics/FID_test.py

diff --git a/tutorials/generative/realism_diversity_metrics/FID_test.ipynb b/tutorials/generative/realism_diversity_metrics/FID_test.ipynb
new file mode 100644
index 00000000..7f33538f
--- /dev/null
+++ b/tutorials/generative/realism_diversity_metrics/FID_test.ipynb
@@ -0,0 +1,407 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a03242f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/mnt_homes/home4T7/jdafflon/GenerativeModels\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd /home/jdafflon/GenerativeModels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8653918c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "from generative.metrics import FID\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3343e510",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def subtract_mean(x: torch.Tensor) -> torch.Tensor:\n",
+    "    mean = [0.406, 0.456, 0.485]\n",
+    "    x[:, 0, :, :] -= mean[0]\n",
+    "    x[:, 1, :, :] -= mean[1]\n",
+    "    x[:, 2, :, :] -= mean[2]\n",
+    "    return x\n",
+    "\n",
+    "def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:\n",
+    "    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))\n",
+    "    return x / (norm_factor + eps)\n",
+    "\n",
+    "def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:\n",
+    "    return x.mean([2, 3], keepdim=keepdim)\n",
+    "\n",
+    "def get_features(image):\n",
+    "\n",
+    "    # If input has just 1 channel, repeat channel to have 3 channels\n",
+    "    if image.shape[1]:\n",
+    "        image = image.repeat(1, 3, 1, 1)\n",
+    "\n",
+    "    # Change order from 'RGB' to 'BGR'\n",
+    "    image = image[:, [2, 1, 0], ...]\n",
+    "\n",
+    "    # Subtract mean used during training\n",
+    "    image = subtract_mean(image)\n",
+    "\n",
+    "    # Get model outputs\n",
+    "    with torch.no_grad():\n",
+    "        feature_image = radnet.forward(image)\n",
+    "        # flattens the image spatially\n",
+    "        feature_image = spatial_average(feature_image, keepdim=False)\n",
+    "\n",
+    "    # normalise through channels\n",
+    "    #features_image = normalize_tensor(feature_image)\n",
+    "\n",
+    "    return feature_image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "aa1aee60",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using cuda\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Using {device}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b08e78b5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in /home/jdafflon/.cache/torch/hub/Warvito_radimagenet-models_main\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "ResNet50(\n",
+       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n",
+       "  (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.01, affine=True, track_running_stats=True)\n",
+       "  (relu): ReLU(inplace=True)\n",
+       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+       "  (layer1): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "        (1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer2): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(2, 2))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2))\n",
+       "        (1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer3): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(2, 2))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2))\n",
+       "        (1): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (4): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (5): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer4): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(2, 2))\n",
+       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2))\n",
+       "        (1): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
+       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "radnet = torch.hub.load(\"Warvito/radimagenet-models\", model=\"radimagenet_resnet50\", verbose=True)\n",
+    "radnet.to(device)\n",
+    "radnet.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e015ccd6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(-0.0041, device='cuda:0')\n"
+     ]
+    }
+   ],
+   "source": [
+    "image1 = torch.ones([1005, 2, 64, 64]) / 2\n",
+    "image1 = image1.to(device)\n",
+    "image2 = torch.ones([1005, 2, 64, 64]) / 2\n",
+    "image2 = image2.to(device)\n",
+    "features_image_1 = get_features(image1)\n",
+    "features_image_2 = get_features(image2)\n",
+    "\n",
+    "\n",
+    "fid = FID()\n",
+    "results = fid(features_image_1, features_image_2)\n",
+    "print(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "46581b20",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(7.2366, device='cuda:0')\n"
+     ]
+    }
+   ],
+   "source": [
+    "image1 = torch.ones([3, 3, 144, 144]) / 2\n",
+    "image1 = image1.to(device)\n",
+    "image2 = torch.ones([3, 3, 144, 144]) / 3\n",
+    "image2 = image2.to(device)\n",
+    "features_image_1 = get_features(image1)\n",
+    "features_image_2 = get_features(image2)\n",
+    "\n",
+    "\n",
+    "fid = FID()\n",
+    "results = fid(features_image_1, features_image_2)\n",
+    "print(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "091c4758",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([3, 2048]) torch.Size([3, 2048])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(features_image_1.shape, features_image_2.shape)"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "ipynb,py"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/generative/realism_diversity_metrics/FID_test.py b/tutorials/generative/realism_diversity_metrics/FID_test.py
new file mode 100644
index 00000000..9b33d18e
--- /dev/null
+++ b/tutorials/generative/realism_diversity_metrics/FID_test.py
@@ -0,0 +1,82 @@
+# %cd /home/jdafflon/GenerativeModels
+
+from generative.metrics import FID
+import torch
+
+
+# +
+def subtract_mean(x: torch.Tensor) -> torch.Tensor:
+    mean = [0.406, 0.456, 0.485]
+    x[:, 0, :, :] -= mean[0]
+    x[:, 1, :, :] -= mean[1]
+    x[:, 2, :, :] -= mean[2]
+    return x
+
+def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:
+    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
+    return x / (norm_factor + eps)
+
+def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
+    return x.mean([2, 3], keepdim=keepdim)
+
+def get_features(image):
+
+    # If input has just 1 channel, repeat channel to have 3 channels
+    if image.shape[1]:
+        image = image.repeat(1, 3, 1, 1)
+
+    # Change order from 'RGB' to 'BGR'
+    image = image[:, [2, 1, 0], ...]
+
+    # Subtract mean used during training
+    image = subtract_mean(image)
+
+    # Get model outputs
+    with torch.no_grad():
+        feature_image = radnet.forward(image)
+        # flattens the image spatially
+        feature_image = spatial_average(feature_image, keepdim=False)
+
+    # normalise through channels
+    #features_image = normalize_tensor(feature_image)
+
+    return feature_image
+
+
+# -
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using {device}")
+
+radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
+radnet.to(device)
+radnet.eval()
+
+# +
+image1 = torch.ones([1005, 2, 64, 64]) / 2
+image1 = image1.to(device)
+image2 = torch.ones([1005, 2, 64, 64]) / 2
+image2 = image2.to(device)
+features_image_1 = get_features(image1)
+features_image_2 = get_features(image2)
+
+
+fid = FID()
+results = fid(features_image_1, features_image_2)
+print(results)
+
+# +
+image1 = torch.ones([3, 3, 144, 144]) / 2
+image1 = image1.to(device)
+image2 = torch.ones([3, 3, 144, 144]) / 3
+image2 = image2.to(device)
+features_image_1 = get_features(image1)
+features_image_2 = get_features(image2)
+
+
+fid = FID()
+results = fid(features_image_1, features_image_2)
+print(results)
+# -
+
+print(features_image_1.shape, features_image_2.shape)
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
index 508ab0f5..e3fc6f7f 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
@@ -54,15 +54,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MONAI version: 1.1.dev2239\n",
+      "MONAI version: 1.2.dev2304\n",
       "Numpy version: 1.23.4\n",
       "Pytorch version: 1.13.0\n",
       "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n",
-      "MONAI rev id: 13b24fa92b9d98bd0dc6d5cdcb52504fd09e297b\n",
+      "MONAI rev id: 9a57be5aab9f2c2a134768c0c146399150e247a0\n",
       "MONAI __file__: /home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/__init__.py\n",
       "\n",
       "Optional dependencies:\n",
       "Pytorch Ignite version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "ITK version: NOT INSTALLED or UNKNOWN VERSION.\n",
       "Nibabel version: 4.0.2\n",
       "scikit-image version: NOT INSTALLED or UNKNOWN VERSION.\n",
       "Pillow version: 9.2.0\n",
@@ -101,7 +102,7 @@
     "from monai.config import print_config\n",
     "from monai.utils import set_determinism\n",
     "\n",
-    "from generative.metrics import FID\n",
+    "from generative.metrics import FID, MMD, MSSSIM\n",
     "from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL\n",
     "from generative.networks.schedulers import DDPMScheduler\n",
     "from generative.inferers import DiffusionInferer\n",
@@ -111,7 +112,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 3,
    "id": "f0e0b019",
    "metadata": {},
    "outputs": [],
@@ -145,11 +146,11 @@
     "    # Get model outputs\n",
     "    with torch.no_grad():\n",
     "        feature_image = radnet.forward(image)\n",
-    "        # TODO: FIX ME\n",
-    "        feature_image = feature_image[:, :, 0, 0]\n",
+    "        # flattens the image spatially\n",
+    "        feature_image = spatial_average(feature_image, keepdim=False)\n",
     "\n",
     "    # normalise through channels\n",
-    "    features_image = normalize_tensor(feature_image)\n",
+    "    #features_image = normalize_tensor(feature_image)\n",
     "\n",
     "    return feature_image"
    ]
@@ -169,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "e0b189f4",
    "metadata": {},
    "outputs": [
@@ -198,7 +199,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "39c4b986",
    "metadata": {},
    "outputs": [],
@@ -216,7 +217,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "b2bdf536",
    "metadata": {},
    "outputs": [
@@ -235,7 +236,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "195db858",
    "metadata": {},
    "outputs": [],
@@ -256,15 +257,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "b951da77",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "c2424564",
    "metadata": {},
    "outputs": [],
@@ -303,7 +296,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "id": "76e684de",
    "metadata": {},
    "outputs": [
@@ -313,7 +306,7 @@
        "<All keys matched successfully>"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -326,7 +319,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "id": "0b7ea4c3",
    "metadata": {},
    "outputs": [
@@ -336,7 +329,7 @@
        "<All keys matched successfully>"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -357,7 +350,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "id": "bd4c90f9",
    "metadata": {},
    "outputs": [
@@ -365,16 +358,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2023-02-05 15:10:35,962 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
-      "2023-02-05 15:10:35,963 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
-      "2023-02-05 15:10:35,964 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
+      "2023-02-06 18:56:04,150 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2023-02-06 18:56:04,151 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
+      "2023-02-06 18:56:04,152 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2614.70it/s]\n"
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2566.55it/s]\n"
      ]
     }
    ],
@@ -397,12 +390,12 @@
    "id": "6e2e2332",
    "metadata": {},
    "source": [
-    "## Get features"
+    "## Get features for real data"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "id": "e9ded5b8",
    "metadata": {},
    "outputs": [
@@ -592,7 +585,7 @@
        ")"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -605,7 +598,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 13,
    "id": "1b48d18c",
    "metadata": {},
    "outputs": [
@@ -613,7 +606,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:01<00:00, 15.06it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:01<00:00, 14.44it/s]\n"
      ]
     }
    ],
@@ -625,16 +618,8 @@
     "    real_img = x[\"image\"].to(device)\n",
     "    features_real = get_features(real_img)\n",
     "    real_eval_feats.append(features_real.cpu())\n",
-    "    pbar.update()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "136340bb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "    pbar.update()\n",
+    "\n",
     "real_eval_feats = torch.cat(real_eval_feats, axis=0)"
    ]
   },
@@ -648,7 +633,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 14,
    "id": "a34810f9",
    "metadata": {},
    "outputs": [
@@ -663,7 +648,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.31it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.43it/s]\n"
      ]
     },
     {
@@ -677,7 +662,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.66it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.40it/s]\n"
      ]
     },
     {
@@ -691,7 +676,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.73it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.77it/s]\n"
      ]
     },
     {
@@ -705,7 +690,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.59it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.75it/s]\n"
      ]
     },
     {
@@ -719,7 +704,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.61it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.62it/s]\n"
      ]
     },
     {
@@ -733,7 +718,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.46it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.63it/s]\n"
      ]
     },
     {
@@ -747,7 +732,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.42it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.50it/s]\n"
      ]
     },
     {
@@ -761,7 +746,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.34it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.48it/s]\n"
      ]
     },
     {
@@ -775,7 +760,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.37it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.45it/s]\n"
      ]
     },
     {
@@ -789,7 +774,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.41it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.43it/s]\n"
      ]
     },
     {
@@ -803,7 +788,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.36it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.44it/s]\n"
      ]
     },
     {
@@ -817,7 +802,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.34it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.45it/s]\n"
      ]
     },
     {
@@ -831,7 +816,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.35it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.42it/s]\n"
      ]
     },
     {
@@ -845,7 +830,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.35it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.41it/s]\n"
      ]
     },
     {
@@ -859,7 +844,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.31it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.43it/s]\n"
      ]
     },
     {
@@ -873,7 +858,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:18<00:00, 54.16it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:18<00:00, 54.08it/s]\n"
      ]
     }
    ],
@@ -906,13 +891,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 15,
    "id": "7701d943",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 3 Axes>"
       ]
@@ -931,7 +916,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 25,
    "id": "17d7e059",
    "metadata": {},
    "outputs": [
@@ -939,30 +924,19 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "torch.Size([1005, 2048]) (1005, 2048)\n"
+      "torch.Size([1005, 2048]) torch.Size([1005, 2048])\n"
      ]
     }
    ],
    "source": [
-    "synch_eval_feats2 = torch.cat(synth_eval_feats, axis=0)\n",
-    "print(synch_eval_feats2.shape, real_eval_feats.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "c075646c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fid = FID()\n",
-    "results = fid(real_eval_feats.cpu(), synch_eval_feats2.cpu())"
+    "synch_eval_feats = torch.cat(synth_eval_feats, axis=0)\n",
+    "print(synch_eval_feats.shape, real_eval_feats.shape)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 35,
-   "id": "3ed40388",
+   "id": "2867fc55",
    "metadata": {},
    "outputs": [
     {
@@ -977,99 +951,213 @@
     }
    ],
    "source": [
+    "fid = FID()\n",
+    "results = fid(real_eval_feats.to(device), synch_eval_feats)\n",
     "results.item()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
-   "id": "341e539b",
+   "execution_count": 34,
+   "id": "3d0e67f4",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "tensor([[0.0000, 0.0978, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
-       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
-       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
-       "        ...,\n",
-       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
-       "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
-       "        [0.0000, 0.0000, 0.0347,  ..., 0.0000, 0.0000, 0.0000]],\n",
-       "       device='cuda:0')"
+       "nan"
       ]
      },
-     "execution_count": 36,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "synch_eval_feats2"
+    "# Even when passing the same image, it returns NaNs\n",
+    "fid = FID()\n",
+    "results = fid(synch_eval_feats, synch_eval_feats)\n",
+    "results.item()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
-   "id": "09462ed2",
+   "execution_count": 36,
+   "id": "c075646c",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7f2517d73790>"
+       "nan"
       ]
      },
-     "execution_count": 47,
+     "execution_count": 36,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
-    "plt.imshow(synch_eval_feats2.cpu())\n",
-    "plt.colorbar()"
+    "# Even when passing the same image, it returns NaNs\n",
+    "fid = FID()\n",
+    "results = fid(real_eval_feats.to(device), real_eval_feats.to(device))\n",
+    "results.item()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ba4e62d",
+   "metadata": {},
+   "source": [
+    "# Compute MMD"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
-   "id": "d57a9267",
+   "execution_count": null,
+   "id": "12706705",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate a few samples (the 45 for the last batch)\n",
+    "\n",
+    "n_synthetic_images = len(real_img)\n",
+    "syn_image = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "syn_image = syn_image.to(device)\n",
+    "scheduler.set_timesteps(num_inference_steps=1000)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "\n",
+    "    z_mu, z_sigma = autoencoderkl.encode(syn_image)\n",
+    "    z = autoencoderkl.sampling(z_mu, z_sigma)\n",
+    "\n",
+    "    noise = torch.randn_like(z).to(device)\n",
+    "    syn_image, intermediates = inferer.sample(\n",
+    "        input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100\n",
+    "    )\n",
+    "    syn_image = autoencoderkl.decode(syn_image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d571fe41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mmd = MMD()\n",
+    "mmd(real_img, syn_image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d4dee40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "real_img.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3bb8bb87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "syn_image.cpu().shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d98f914c",
+   "metadata": {},
+   "source": [
+    "# Compute SSIM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47c47947",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_range = 1.0\n",
+    "mssim = MSSSIM(data_range=data_range)\n",
+    "mssim(real_img, syn_image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "051070a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "real_img.max()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6785ec74",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image1 = torch.ones([3, 3, 144, 144]) / 2\n",
+    "image2 = torch.ones([3, 3, 144, 144]) / 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09c54917",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_range = 1.0\n",
+    "mssim = MSSSIM(data_range=data_range)\n",
+    "mssim(image1, image2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "004fae2c",
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7f2517c5bf40>"
-      ]
-     },
-     "execution_count": 48,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGOCAYAAAAZykA4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e6xmyVUejD9V+72cc7pnxpfIMyAbBylRHGPMxbbMyPmhCBw7YPKBsKIgmZuFQEFjgrFEopGQI0zCEJQASXAMWMR2BMQRUYjAAhvLgK0vvmAGEZlLnEQh8ShkZpLP8cx09znvZVf9/qi1Vj2r9n7PXLrnzEy7ltTq7vfd795Vteuy1rOetVbIOWd06dKlS5cuXbockPhUN6BLly5dunTp8vSWrix06dKlS5cuXc6Vrix06dKlS5cuXc6Vrix06dKlS5cuXc6Vrix06dKlS5cuXc6Vrix06dKlS5cuXc6Vrix06dKlS5cuXc6Vrix06dKlS5cuXc6VxVPdgC5dunTp0uXzQc7OzrDdbm/IvVarFY6Ojm7IvR6LdGWhS5cuXbp0eZLl7OwMX/zCy7j/wfGG3O+OO+7An/7pn16YwtCVhS5dunTp0uVJlu12i/sfHPGn974Qt95yfQyAhx9J+OKX/Q9st9uuLHTp0qVLly43m9x6S7xuZeGpkK4sdOnSpUuXLhckY04Yr7N845jTjWnM45CuLHTp0qVLly4XJAkZCdenLVzv75+IPPOwkC5dunTp0qXLhUpHFrp06dKlS5cLkoSE63UiXP8dHr90ZaFLly5dunS5IBlzxpivz41wvb9/ItLdEF26dOnSpUuXc6UjC126dOnSpcsFyTOV4NiVhS5dunTp0uWCJCFj7MpCly5dunTp0uWQPFORhc5Z6NKlS5cuXbqcKx1Z6NKlS5cuXS5InqnREF1Z6NKlS5cuXS5Ikvy53ntctHQ3RJcuXbp06dLlXOnIQpcuXbp06XJBMt6AaIjr/f0Tka4sdOnSpUuXLhckY8YNqDp5Y9ryeKS7Ibp06dKlS5cu50pHFrp06dKlS5cLkmcqwbErC126dOnSpcsFSULAiHDd97ho6W6ILl26dOnSpcu50pGFLl26dOnS5YIk5fLneu9x0dKVhS5dunTp0uWCZLwBbojr/f0Tka4sdOnSpUuXLhckz1RloXMWunTp0qVLly7nSkcWunTp0qVLlwuSlANSvs5oiOv8/RORrix06dKlS5cuFyTdDdGlS5cuXbp0uSmlIwtdunTp0qXLBcmIiPE67fTxBrXl8UhXFrp06dKlS5cLknwDOAv5KeAsdDdEly5dunTp0uVc6chCly5dunTpckHyTCU4dmWhS5cuXbp0uSAZc8SYr5Oz8BSke+5uiC5dunTp0qXLudKRhS5dunTp0uWCJCEgXaednnDx0EJXFrp06dKlS5cLks5Z6NKlS5cuXbqcKzeGs3DxyELnLHTp0qVLly5dzpWOLHTp0qVLly4XJIWzcJ2FpLobokuXLl26dLl5Jd2AdM9PBcGxuyG6dOnSpUuXLudKRxa6dOnSpUuXC5JnKsGxKwtdunTp0qXLBUlCfEbmWehuiC5dunTp0qXLudKRhS5dunTp0uWCZMwB43WWmL7e3z8R6cpCly5dunTpckEy3oBoiLG7Ibp06dKlS5cuTzfpyEKXLl26dOlyQZJyRLrOaIjUoyG6dOnSpUuXm1eeqW6Irix06dKlS5cuFyQJ109QTDemKY9LOmehS5cuXbp06XKudGShS5cuXbp0uSC5MUmZLt7O78pCly5dunTpckFyY9I9X7yy0N0QXbp06dKlS5dzpSsLXbp06dKlywVJQrghf56o/NiP/RhCCHjzm9/8uH7X3RBdunTp0qXLBclT6Yb45Cc/iZ/92Z/FS1/60sf9244sdOnSpUuXLje5XLlyBW94wxvwzne+E89+9rMf9++7stClS5cuXbpckGhSpuv983jlrrvuwute9zq8+tWvfkLt7m6ILl26dOnS5YIk5YB0vUmZ5PcPP/yw+3y9XmO9Xk+uf+9734vf//3fxyc/+ckn/MyOLHTp0qVLly7PQHnBC16A2267zf7cc889k2vuu+8+fP/3fz9+8Rd/EUdHR0/4WR1Z6NKlS5cuXS5I0g2oDaFJme677z7ceuut9vkcqnDvvffiwQcfxFd+5VfaZ+M44iMf+Qh++qd/GpvNBsMwPOozu7LQpUuXLl26XJDcmKqT5fe33nqrUxbm5Gu/9mvxqU99yn32xje+ES960Yvw9/7e33tMigLQlYUuXbp06dLlwmREwHgdeRL0Ho9VbrnlFrzkJS9xn126dAnPfe5zJ5+fJ52z0KVLly5dunQ5Vzqy0KVLly5dulyQ3Eg3xBOV3/md33ncv+nKQpcuXbp06XJBMuLxuREO3eOipbshunTp0qVLly7nSkcWunTp0qVLlwuSp4Mb4olIVxa6dOnSpUuXC5KnspDU9Uh3Q3Tp0qVLly5dzpWOLHTp0qVLly4XJBkB6ToJjvk6f/9EpCsLXbp06dKlywVJd0N06dKlS5cuXW5K6chCly5dunTpckFyI0tUX6R0ZaFLly5dunS5IBlvQNXJ6/39E5GuLHTp0qVLly4XJM9UZKFzFrp06dKlS5cu50pHFrp06dKlS5cLkoSIdJ12+vX+/olIVxa6dOnSpUuXC5IxB4zX6Ua43t8/EeluiC5dunTp0qXLudKRhS5dunTp0uWC5JlKcOzKQpcuXbp06XJBkm9A1cncMzh6efvb344//+f/PI6OjvDKV74Sv/u7v/tUN6lLly5dunT5vJOnrbLwb/7Nv8Fb3vIW/P2///fx+7//+/iyL/syvPa1r8WDDz74VDetS5cuXbp0eUIyItyQPxctT1tl4Sd+4ifw3d/93XjjG9+IF7/4xfiZn/kZnJyc4F/+y3/5VDetS5cuXbp0eUKScuUtPPE/F9/upyVnYbvd4t5778Xdd99tn8UY8epXvxof+9jHZn+z2Wyw2Wzs/yklfPazn8Vzn/tchHDxWliXLl26dHnmSM4ZjzzyCL7wC78QMT5t7einTJ6WysL/+T//B+M44vbbb3ef33777fhP/+k/zf7mnnvuwQ//8A9fRPO6dOnSpctNKvfddx+e//znP2n3TzeA4Hi9v38i8rRUFp6I3H333XjLW95i/3/ooYfwRV/0Rfj/Df8PlssjpM0WYbFEGALSdg+kEcOzbsX4uYfLDxr0IQwD8jgiDAPCYkDOQN5u6wU5l9/kjHjpBHm7Rx5HII3zDYyD3RNptN+G9Rrx5BjjQ48AOQEhIsRQruN/5wzEodwrjQjLFcJqgXS68c8MAQhlIoXlAnlX+hrWayBlhOUAhIB09Zq/Po0YnvNs5GvXkPcjcsqlPTQWTnJGWK6Qd1uERZlGk2u0/Xov6W/pQ5Z+Jeub9tWeJ+2ydxMi4tEK6WyLMAxATsj7fR3fGMr/+V1KO3VsEQPCaol8ti2/VzwvJ4TFsjx/uYDifGE5IJ2e2fuOJ8fAOCKdbeyZGIbyyBjLtdR3AAjrlX9PMhes/fTOuL9hGMpvr52W+0m7wtGqtOHaaZkTdN/h8gnStVPEWy5j/L+f83NmvUbelHYjJ/9eQ0Q8Xpd3v9sjXjoGdjuksw3CYuHfB4Dh1luQt1vkMSPvd+VeOmbDYPPC+pczwmJR1tKYgRj8egIQVqVfeb8vv025tlHmoo3rMJR2rhblfgDyflfW4y2XkU/PyjUb335b17HOkXj5BOnqGaCfybVuLtI8RU6Ily8hPXKlrIH9DsMtlzFeuVbGdbUq607nXBqtDWEYynp/5Io8+xLydlfGImfEk+Myv7WPm02Zd5cvIYSA8co1tyfoGIflqs7dcURYDAiXLmH8/z5rc6MMn6yx1Qp5u0Vcr8p+qHNP55P009aczOu4XtW5L8/KKdc+NvM5DEMZ13G0uRYWS4TlUNbhdlcefXqGsFqVz07PDq7rsFqVvWO3Lf+X9xOPj+rak3XPfbD5A5RrdQ/RNTpEbK89jP8Xv45bbrkFT6YkBKTr5Bxc7++fiDwtlYU/9+f+HIZhwAMPPOA+f+CBB3DHHXfM/ma9XmOtBxHJkBeIu4CIBZAi4moNrBPS2RmG5QlCOC0X0oEEAMhAWB+VzXmxlIlYhks3CL1wWJ0gpw2wANLZGSYikzqsVkinZeMvz8uI60sI62PEYWOHalwfI52e0mYeUOZGkEMrIq5PEIYBY97VNreLNANZF8suIx4fI6zXSFeuIoalbeLIpd/DsEYeEtL2tG7+OSGEAVknpy1AIIQlcsgIYWHtVAVCGlFcQANksZfflO9y2QzHUQZ7QIgDctohnlwuyoy2nZWFsEIKGUgo18coYzIAKQFxZdfqJhPXJ8jbHcJqWcZluUDaZIT1EunaNfp9LL/LQ2nralkUgDCW8Q8Rw+IYWA8YN/+3NDssEBbyzGFAQjno9D3k3RY4S4gY6ntCQFyskXNGHjcyVHQg61VxhYAFUtiXDXYhyt8OAAbEuCrvKe/tHmEHxLhGXJ4ghKulXzoeKSLHVTkoNhsghTKnRHmJq2Nk7JDzHnFxhJwXSCEBKSAslnaAIo0I2wykBTAE5H0ubV1LH1JGDhkYAdj7lv4MC+S0R4gRCakeTiEgxhVyKGMSwgIZIwIGFFUgWh/L5l/m9nB8C9LpGeLJCcbPfa6sx/UlpLMRIS6QYi7zN5R5EsKyTPfFqh60u4CIAWG5Lu/76jXE9bqsQQzAUMbQFKu4xHB0GeOVDcKwAoYV4rBGCDsgj4jrS0j7a0AeS38xIsQlEIoiES/finB1B6QRMS/KfNzlsh/kBRJGIJd5mEMZo2FxBCwW5XdZB7SMaQ6htHOxRIgROSeEEBFXJwjhkboW5WDMISLGso7i6hLSTg2HiHh8gnTtGsJC9rgQMZzcivFMlMT1ZaRRFduyR+bdHnm3RVweIY1nfh9CAHIEFkvktJX7XRKF5QQ5nRWlBQuEsERIA3Jc13WNgBCXyLIHDCe3IG93SHtRTMMCGQExrJAXMMUFZXsFEEtfdlUxDWko7zssgVTeSenOUu755B7EPYPjDZTVaoWXvexl+NCHPmSfpZTwoQ99CHfeeefjuldYLsoi0QN7sUASbZY3ZhPRQOPR2mnDcbWs18QgKIVsIrs98n5fteHJPcV61cOZnp2326qdy7PVaiifEZOFD86cZ61o5ASk0u6JpZ8S8mYjhxK1JQ7lz3ZXn02/dfdRDV2viWydhrIo1ZqV32Zm44zFcnWfhyCWLo2JjfWAKEqgWVTWFBofsZTLGGQbA4Rq1ZgFN47FouCxpb6FoSAQebMBdrs6tmks1rS+Z9oU8zgin5WDP+/3dfwVRWgk7/eGXiCEiaKg91QFJywXYn3KHNntp+9J2pX3O0AsUnt2KJaqWqPuu5xKe3d7ezdwY5utPYoshMXC3pc+M2+31aKWa8oYqaIZ/HxV0XEkP7GhCjxHQkWpiiI31DafntbfyjzWdZ5TFmRmhXC0tnFOp2eCItQ1BUYTAFNoDd3T8RIrVp8PPaQAmwf2bB27EGWMdm4dub/lkCyK7q4+b7cvz0weFWHEBTkh67va75HJcNGx1DWTx2T9tbUTQjFmUFEa5FT6k/V3o83vgpoka4MzlBS5UgRRxy+NFanbyVpMudnHklubYbmwPSVdPS3jHUmBCwHpbCNryqOshirSHIK+WzFG8nZb+tHlXHlaKgsA8Ja3vAXvfOc78Z73vAd/8id/gu/93u/F1atX8cY3vvHx3Ug3CtlwEUNdbDnZJA0LtYBiXZwKm61WZRHLtfH4aHIYF4i1AWpmXBvumhAQQhAXgSw+QgncpgBZNPR9HkfEk5P5DVglDvVgiH5xW38unZTPYoCj2erCY6VCxwiKXijM1yo2hNTQOJePQu0PSdps6uK1zTQhbTaymcWyUbhBoY1eNrxJW5dLOxD1QJq4VgSxCTHYhgugbKr0rHC0ru8wxHJghlDev/ZHYf4oSlDz3hBi2UT3pLS2igtQxt9cV6m4OwSGZViVlTO1klThCoPA9iGaxRSGwZAucxHE5v2wcgyYdW3zabko49Qqb6jKpRtfmeuIsRz0pKiwOAWG+0nzSw+s0h7awsyV09xTLWpRaOw5qtQcreuhlooiEnTNiPIwkVxdLopWheWqfp/oQFIlXt/DpZP6vlPy95c57BTsnGs/Q0A8OamuPzUYYvOboSIi2nc31qp0brdeSbV5Wve76loIMpdlzgyxoGOp2R/cOMn85/kTQ1WwpO3mghpH126gmUf6/3ZetO5fdVHsK/JqBp4aFera07VwQaKchev9c9HytHRDAMDf+lt/C//7f/9vvPWtb8X999+PL//yL8f73//+CenxMYkeFNutn3j7vbeaeKGAtPHNBnm7lcm3R7py1S28sFyUg27yXLIcU3aHkG4iOefityOfov1WNiv9f26eEYahwOjyjLroU0FGhgHpkUeKdUs+07BYOlhOrbJiQZCloudH5k2fJmme18ZLH6rmH9dr5DEV37ZCv+qzJkUkHq3FR76sG0Kohx1ysmsmEgdvDcMrBGWjKMpS3u2RTk8LYqFjQZySECqfIvC+lXPxrZLCl3NGaA5FAAXG3hbrzNobqpKUd/vqDtDv2oNzWTZQ3chCCHK4RCAP9cCkjTLrJnh8DGx3poAhp9KeEJA2xQpjqz0ncTTFgLzLwJjKodsoeWZhM5+gfGn8FF0n+tz2sM37vVn09q61HTTHy/31R6O1AWEp7q3i9w5nQ0EMFE1ZLoryL3MsJ7HUR5gynHd7U9rSlatVoRjT/J5QB6H8dXwEXLtWlRo1LkIoh+g4TA8wOQjzw1cqfwTwvnadr8MAYKhIXUr2XTo9mygTebcv/Q4BGXlireteVt5RUSrzKDyD7c72g8LPYgU5lvluCqC6BuU9irKUBfHIua5VO6jp/cbVEnmUObxeA488YvylKEpklnmqB3p5sLQpBoS4qOij8sZOTgwVKYrMYP9Wpbyu6cHWmyJh6VTcJxcQkphwA9I99zwLXt70pjfhf/yP/4HNZoNPfOITeOUrX/m475H5sFU4jNwHJsmTEx28y26GQBtmYw1mXqCtlp0TsNsRoU4ti4x8dlY0XCbsAc5qm3ZM4GRth1gvdrCydZUKJJt3urgbuFuUppxzPZiG6uO0PukYpXpAmKiyI0qJ/imHQSKSZpxYDjY+emCKRW7Qv1jhPDZBESJW7HZbdz9zqehhHaNX2ADinsCeq1aYohn1oaTIhWBuCUA2UYKQtY0OIRIEQRXPFg6dWLAxlPumjLTdFc7Ldlfek0L8rex2ZWzWq9pWtm7loLfn8njEaKhFPj2tB6e0mQ+odHpWP6M+uncirh6bD/t9eRcM6xOCpO4DGyvA1kV9rdWiLS63bBZ7hcoLehbI1aZzvPS5/InHRzJviuKkyEvebqvfWq9vDy1TtKobyvrOa4fE3ESnp/X3SrKLtCcpaiFIld0rxmotp3oAW7vUINE2js240bsx46KdczxXSNkz18Nu5z4LrZLrDKK6FnTupO2uEkl1varrdGZPRU7VhQFCchp3blivXd+svXQN0miKlbp5GXnocr48bZGFGyZpLAQwgn+xl8NjxiLkjaHCa6Eyqo1lW/3++aySE6sS0ELcoVrUvLbGEWG38/7r7dYfTCrEfC8wXmPZkw87bXcItFnYRjGOFVrXzVTuG0IwBar6Sxt/Ij9OxyPouM3ApxxxIO12MCK3fTPzXoAaISCWdTnQc20/4O+nJExuJ12Ty4CY5a/fOeVR5wqa98h8D51TgprYZXooqJ86zbSRxyVnANInbX8qim1WNEzcMeYis981EgsJkaNdzNKX/xvaop/rO9ztqjU9DO6wsfdA7S/DFJBTPTDLffUS6l8Uy3ZQpToCeazPo/FCLgppBoC9KlLBxkGVgTyOSNeuIW+3SA0vptyvKiJzc7hF6nKzfsyFJu+Hx1J/y9Zz5Yzs/TrQMYCs2+XCFNu8nXEPqNKyq/MokNLVHsj2z/3OEAOE3ERvJXlPY31uGku0SAzIGOYVEMDtR3qgK4qSxzqPvVt2OeVN6TiOI7LML0MqgPK53qdRBuwWTQSNfU6ogvWB5pK/WBW+0a2H2fX0JEi+AdEQuSMLT4KIP9n+OwzVCr58yX9Omq1arkH9aYD7jgliYbUq181ZzNoG8Yu1/r24WiJcvjRZaG7Sq7DrY7Usvs/mOWyRtQgCgGrJUH/svsrr0PGgtvtnBH9NGRQam+j6yM8o7RoE3lza/cJiUVGN1QrmM2WCHFD4B/Zd0z8KEwTxP+JqCQtxXK2Kz3cYEI+P/PDF2i/9E1dL95ywWBTIW8dPfLLx+Lj44qUdYbUyv3iIwayaOhyeJ6D3tvZrl9Zrm4NxvZaws4UnLtoNQiVEnhzXzZ6h7ZztHVd2v/T3+NgIwWG1qhwMnb+EZoT1ukZ9EDJiPmF513zwhOWitG+58HwV6a+9J+2OuMwUcavvJQrBcjB0wL1LW5fLOn/Nb135JurXj8dHtn6jECBr36PwNGI9JKOML8+V42Pjc+j99P3pGCOW+RQvX7J2xOOjGk4s41qUq1DXKY23Qeg2QQbfjlDJ1+Gk7g/tHqXvpu5tTJQkGD9EWo/RxjkIyRt8z0XlubBBYPNC585qVfp9ciwutUqIjeu172NOHv0YBjde5YceyWv3hvrO/b6l42ntuyC5/uyN1+/GeCJy0ysLYVHJVGEovk23SavGPDZaNcqGrvBkayk4iFoOIkewa/92vwvuQAiLhecqsLSasv5GCEGz7g6GtLV/KZeNembDCXPtto06Y4oW0P8VgubNhu/b9GMSoaHwsfq/2YXSWlA5F5/9cgqIOTKcjgP/XzeFxQLQzcMhS3J4KIw8CHlxGByyEVYrQIlsIVSFh3zKIVaEBuLacRtWbpj+gIUmTkTbNBaY1hRAJng5ZUrapjkPFlW5ckqDHoCtxc0oiHIW2Hes7V2tgOWyWoGqmCRyc+i46rOEUzLZmM11F+0g0PEqbojqSjDuT6OoZhqHwORMRnY04iJEQwtNSeV5K75/nUPusGMOjd0zVCKkwNzV2q7oRiFYR0NZSp9lPpCrocyn6hax90Hk3INonygaYYh+HFLzDpvxs4OeDAdDfGYsbmv/OLqojXI7ckutalixE22LGQ4LcxO69d3Ou2FwpFZzc5jhU5FdUx54/18Q2VLX+mrpx6rLrNz0yoIxoIXoYi4DAHlDBDvzSdaNzywwZefTwZt5kehG6MKr/N/uN2xh5lxCqdgPR5q2c0cwp0IJZKk58OQz5Sc4mH27c4TJ8ptQoWhuf8rTg70V9keSJc8WrSlCagGxMjYSRChEyHLfWBe6todY+BbhQpaE+sed8GYnvvW83QK7bXkPFOFi/m+F+Zk7Eus45v2+EOlkDJVLkZWPgaqY6UGZTk/r/cwltXObYt7vDihSHk3Ko/jiGXnh+fTII/XdhOjdSSoaEcP+ae2bXZMriiPvikNV8+lpJcQyoqUWcePzd0gXKVb8npCSJ/tF75LTuTTrsz7yKJEpocSJMAVIRThM40MP14gTQMKLKzHTwf+5idKIwciW5bnN4U9KtIboGUcJqK4GPXxTwyPhLg31XbTX5JQlOZgaP6mGToZQLXjeWwBDGjlUlNtVlCU/DzUhU97vXCQBozZ2v4ZQavPW1puMKc095w5s3ZXK9aG9GDmXvYP3cPquuqXGSq5FPRvy1vOhnmx5pkZD3PTKAoCpBaWx4nPaJFnWENKSxWYTycbui6pMOAvcWQW5bnItRJ+yxYvb5UwGOuRHS5z9L9R+cchWsyHbZuMWY3YhXxWaDk5BmvRJ76MbY1J/sncBmE9TDyQimQU+VIDK6dh5pr71jchr3H5FJg6JugPyfk8haNGz3XMlO9khkXP1KTNPgUIkw0KY+Q373PJZ5FRDFNsxbNEs7hdtqNbOHfnELQ7eoy8aBljv3Wz07bho3/Ww1INDN+VcffVOlktPLAQwQaD430neXSI/tfmV9eAl+F+e7xQU+b9bK8LpMCVJx1XnoutwLO3W345J0BohJArfw8IS57gm+n/lJ+xEUZTcHC2y4H4j87dkLlRyH7k26f+ZuUU6fm3YMDC/3sextGVX87CY5a3r8vS0tOds43JjGCJFaKE+19ooxkhYLF27LK8FKTOmUChCJ+1j3okjhs8YKA5h2e38lzI/k6639jttD6/fGffpRVZm6m6Ip6uoBSr/Ln/PuwgA1Em+q4l13GICZiZls+BnpMCzaWpxAIUVPJcmut2kmoPVkIDGLVCb1VgfOc9r0Gy9smVh0D+hEey+kMPeLXZim1timUk/IlihAOCiKBynoukfs/LbZE+T90mbnb3HlCzsjxPpWLvQHEpmfSsiQImwNPmVQL9GmHPWbEs0o74wytO+Q3lXLiqHLWW+lrvs2jwz7kCNfiHSo8G5yhQ3YmWuygTL3MYsCrMdaqQMtZEqtd/z68odUMEfpHbIsLVPY+gSS7Fo9MqEyxHr/RK53Vq3Fo+jHqqqVGm0ETCJ4NC2l+il5NuVUlX87f7BKzuKiM0hfaHubYXdv6/rinlY0i/LgWFIl2+nfd+uLVMo6R3o2iZuQmlKsw6Zv6ARPrtdUbga8vN8mxjViC5ipFyQ5w973ZdXK7d32XPYjdzlUeXmVxbQTHyg+pl1AinMuVwZacsR2+YOY4LxARSf+yHLCqiWyyENltth8HqDiLScBT64FzXLmeMxTHzSabqR6aXHx0WhWSzAEP+EF9GgJnG1nPQXUI2eFAPzTZNPUzaYtN35Bc+oBv3Nvuyp75tQG2pPGCLiel3Ia7EqBHYtPTNEIagJCa/NQhgWC+Rrp3TvwRSPcHxc2xHKM2sdCD8+SrK0fgl50SVYUrKXHm5SpyEcH3syqLuxhNcRKmWbuHAVrIaDzJmwWBoaEY+PjMRpmR6XK8QjGT9t22KBSVpcQWUs2ymvH0VKhDOgyazcnFYFTl+HHuDq00Y9iCxpknJrBKED6tw4SNYVDog9L8aasCf6uT1xUwKlH3rPGPzfoSBjyivI0q54clLXAyNajQ+ex4LbH2Tutrkf4vGx3zeA6npi5JQVWMha1/V0YD/QfhdkVdxaxJNqeTYFmSOFWl1E67W8p4VTWDTs1Yi3mgeFkAme/zZeTfvKdcX9aq6QSLwORhaAkoRO67pQOw7xQG60aG2I6/1z0XLTKwsuXwBQYdac66GSa3rVYnUl+9smoxGAGgKObiZjk4a1tfgY3nPti55wEweyCBr/JS8a3ezMRznW9iZajK3rhNjqkzZazgAf0nbIQlVCZ+IkKu116m7gvihiY0hC9Q1PnqH3JUa6Qq7t9QyT1s8L7Ji2O2fhazbP6lOuCYK0uI2Fw7HVysiCIQzJiurUwZQkSHqwRD/meVO5M86ST3VuOu6EcAEsa6JagIxahOI/z+Noh3FLpOR0weoeynvJzaBZ9BI9I5eiPcW3uzXFKTfzyixSHTPA83NylrmZPBJAUSIuIoiVSfZpt+4tO1ySCyuuyBChF4rytAfnSt/7tih9QhBk5bTOk2bLbOehHHqO+JnGWhMGqG4sHZeUfJ4FfQ6FJBbYn6JP9HWKO8GSLuk1KZurhMXeVxuCOOfu1LFuLX56Zz4yJ5IBVqNj0umZm8sWMSOZMk0Zbt6x9t01k9J6c5t0D6ouh7p3mytLx9i4NrEqIzM8kCdLuhvi6SymfaqPljaLhijT/i7EUMKkiKSnUQhqaZmPkjeSGWZ7HseJJdimzNX7Te4RwtT3zazs1mUAzGrLHA5XrqFQJIXUrSGpbgCA5FlvnqHX8TPUetPNm/kHxEy36wjKBFDdBCAlDaRoMYGK29BaHQqh6+GlhwspLbMKjv78kLtJQwKJB9ImwcpjTRNsYZR8K4JmJ6JWD4+zQsByCDo/LLXPwmk50mI5PfAcWZD6PclESuuD3RLKKnfhucpbYYieOTX6fOczJqQu1WgPW4/NOjIftyo8opBND2xpmyIpimzRs6uS0biGgkZXNPsGaA7OvLvz3JD2vTyPr+UIgEImrP3j/uTWILEbhzoeOh8eDVpXRVDcFhOlCKxYSC6J4KOswhAnyboA1LBb2z/onk2/NF20JVVaeh5ZQU5oTabp2Lh2ty49+s5FsTR9vUjpysLTVdiqGMcKXwKzmreDRiV7IDSKQDXgJgmJFati6Jws1nrrMD2AnN+aiH9tm9QvR5Zay6WYdMWFLpZNKl099TBoJqJkjD4rpC501cgFZmzbbnCkWP9G7FuuSBnI3srTNul3jAzw59b/6qfWQ64dJ7Z8nfBmpn1UEt+cMMelOdiYFKhjZ8V72LURaonjWV9zexDOKJeu4BMTVPl+LWIxZ3mxH5qQKJc0R/qiylnJpkioi8XVH7BMibBoTP8Zwu+ccqzvzEIL2/azNIqqRp2oy4d/VwiVo59P2iYLh4wORfSWZiXgObdCy7cZhvKsOeIc/e3CDTn6YYa8OPn/ODpy7uQ5ikpJewIr5nRdy/dxSqvufVRCvdyvKvTMs2mTT0XJa9H2UXM8+A5lI+xq+nPkVLJnsiLFKfoVMWB+krpgWnec7jUhWJSVIWl2v1gVmpn118XLzT9CvKjntG3WTBt2tuYkMHY4WRpBYqsBIGhiFda8WXSDNa2/XhNPToDlCvHoqFraEyQk1wyS5Du3AkWMEixXXuEBaBMIJSHMek1afzblIVBCFFcUh7V2u19w8enOL26dC5X7we1erar/W34fKQeEi7V31vByEhPPnBFGQYxrETVnwmC55+1g4GRdC2/RhCDcBUFz2sQuzie7WADLpfPha4IhRTOcIgkgtqF+LGSdc3rs4rcuh2ps0tuata/vgL/XPk2SQHluQTjhpEwzsee56YcgUTpXLBlQozAbZyNIMSuC2F1CnJQ8sTHOFF5bLGyu6JiEpSTK0ufpWtSkTG0OC4XIj4/L71dLmVvlD1u6oVEAgs7poTm4te0hlPsy2Y+UzDJXal4Vl/wK8DkBOOpGcnW4cGOWwY9VzrnmE9G1ZwpSsIM9Xr7sxkf3tjBU5caiwYgTpDkqhlsv174pZwd1f7JQZ2lHHkcbcywXNV+MIIOWB4EQLU7uFddrrxjo/qF7F7dP9wTNT6FGBvNNBIGay93yZElHFp6mwpqzhSOplr3dzfygYT2LRcJWvFlliQ5/QS5cAhhgak038HPebgGJ63aJWvRv5iS0/l1l87PCwNYAJTfK4oM2VjW1y0q7qhsiVzjY9UX7w/dkl06jVFhYmd2noBe6sbp3I2GNyuh2rG3zU4/ub2ub+OrtGSyKnGjirFTfoWNIj2SBMldBnuHcTMwIV9/+buchVPXLKvrACJI2feI2ofETstbkPaiVK8/i/BI5ZSmIE42PweiB60Mmopn2g0oPO1dY6/bJ2XIRaFIeR8QcVdmmpF6NwjxB2PTWWvQnFeLsXEIgxDiN6tHMh0A9yKVWx6zLR9eG7gkxuAiBdm9gq3TWVRdpXLltdmBVZKXC+pXzYu07OC772e/s/afskY05Nx2vUUarmMcliqqLQNDQZ+KOhMWi8IAolJnzteT9vpbvZr6HcDRczhf5fDaTorqJFJlUhUJdgrpX6noL1X2n712NLFc6HqjlzXktXIB0ZeFpKuanUgsDdUMKTbpfR2RL9fCfbDYGacqkOysEHo5NnqSt5UntHpkL0UfYvArFAZi4HSYQuyoTrEQk76d3h9NqVVAQtQDYCgd8/YD9vm5E7UY74xNs62gAqJnwaGxVYTOInqxzdjEYPKzQo+SQUItFs2ta/gVz4/CYVRcHt8GaTQqDpoNW10NYLMomvtvZs22cKfrDyFoAxc4n2yzV4ncREbkUhnJFrIiQpWKbsW5wumFvt1KMaPQHU04Ynv0sIFPiJtd/gpJ1XNnlJC6TvNuWtaFjKgqpY6kfHxuRLwyDJZVyoa/WkaqUtIWHjBCZJQeBrNGS9Gdf+8HzLlQ3VD49A8YR6bOfq8/TMdk1bjPxs5dbCeKjbqIkmVpVOVVlKzVzCeWQAR2a5dZUvpn3C1Hys9T1QMoVsVGffc41IZk2lYnPueRmgLqCqE+OWLrb23pz1rcpUUSejrEqRTP72yRkFwCCpHuWeVfG/7S2QavXkhLqXHri0sz7fUFxjo6Qrl6r7s05Ny0pWjxmreTT02oE6TM0bT59rkqJ2yMuMMfCM1luemUBgC30UmilSYGqopo+5VrXzbWykGWjNPiWFQLv33aLTXx75r9uJ/swIJ2dVbhQFro7TEjZKV8WC8Vp4m3lTLKcy6JIyNdOMT70sG8790f5DOp+kWdxO0y4L6o4cXKUlGtEAEHXAAii182OUBsuP1surpuJbQqNAjOOU6vE3mmJU+fS1hY2JxB+3u/rc9UyUj6CKmn6h5LlGBKSKT2vbFDm557jxigixP1sozhyMjg4LEspYVNM2I9Lkq+VzTufndnm7Pqcc9nwW797DNWaDuUQdhUQKTSwtLWiBxPFlBEgHTPqb1j7MExddxahAhhxLjWFlvI4FnZ9g5gwVK2olSU1c7+XNT0MZa6ebSTPwc7CTm2danuZGKd/23sQy1rdLw1ywuRerXNRIl20kFSpQGrEUkGM0mZTi4EpGkEcAHuvrLRqP2Mo76ctlKURLUBNyrSjvckupDWdk0QPKAdAlC1VqngOcQZH+b7wiKqyV4i7WSIkdsWlRFETHIUjA+hRkpR8Yat9TQhV9x2PQDryJimrFgHERN8LkIzrD598KtSbm15ZMAtU/3+oBLRajbqpsb91DlkgUYvEJQvhAzZOyXj1uRk4PascASZhNfB/3lF66pQQ1utpWmKOL+Z2hJo/n/PtA6gJc8ZRCFej8zPO3g/wB5f6zZtskJMCW/obvj+PBW9AavXyeA+DoSfuEEgHoEQZT/MBawZBtXoaa1XHitvKbdHSzK3bB0xA0/ZI6KAjEqpwZUy17NtxDrGW11YoVX36FMrr7ysHm4XQeTccgiSPos+NmDiQu2VyyDaKo1rF42i5GpRj4qIhGqRHE4NN70cuHf0tUHk5KsojYIKgto8OTuMWaMhtfTHlZ2ebOhc5G+M4eiUdMBcE/x5NOKGVsKd2cj/UWEGIJQkbpz9PFVHR9+3yVQAUjimHZcNb4CgOcyE1ByDD/JY/RHKeeNdeoxjy3qXXqcLTKhA6JqbsVtTJ2gkIV6O6mbRQmOWSOCRRyKzNvK+IJO1X+q4pPTujrjllC5c9VM3yyZDuhni6i1lEB3SyCZNaFt/M9S0vQcOsDioE5226QLF8d2RNK/np8SYKaTgDLmkOIw5zaWMBaCGXyb0OMYVnFrWOm7sHSUt+48PCWNePJQStJXHOPOvQs+3v1iXU9kdCFZ0rxyI2ztHtQ3Wl1JvPXN9Y9m6zI9eI/a3/JmXWdyCTOyybFTu5hudvq6wBMDTtHGsrcIx8mnE9AP6zEDwJj5VFVlybSCPv8w5GvrP2L5e1vdxN498048TEQ1XimFfQRAs8mqhy1RKQrdvW1macmTsQqYYH5cBgt2D57pykbnxvAJO06Af6NMnDAUwMnoNWd6B9iu/P7lx2SZSLDflwdU74nu28bGTCgwIaI+JAf/QnTYKvx7J3dPk8UBZcBTSxLm3ya6iPbszEog0LKpe7JJh+hkhn/krHnOaNkqzlmYO3EKzIquUNSxfscjWDGswdGKkuOLV0ib2MGKUMb7ORA4XPwMWr5LtJsqnorRNlU1uEBqMy8JuUVcVT5nzL4GaLrO2vgzzp/QQqtau/YXRIrNNJeJteL/d295S5YhkNuUJhpANALN1I5YAhfbS2LZY+uiR6q1HHyL3vOctaeRUk7pCMRBATpa1VWuwdRVI8SgOK73xVIk7M0lMXgUaicE0T0HsSgp2W0LZrdL6EaPByIIW4Nix6y1dZ+W14rD1X5gkhQjV7X7DogRoBEN3aUsXFlVwWZnyr7HpFTsZ0VQmmeSycBPORE0cpi69cy4u3a8PeCfXblCKd0xw90iB1ui/UxGfVFeGKazXGDLv9HLEwRFgOmcBzeFFcTsrBsUgsmlsUvWFjtVj698rK9m7boHfCoWjKuTtRHpE+c+J6pP1ZlI54dFT3bkl6x5FDYbGYlr1+EuWZiixcXLzIUyQ5ZWSMBj85LsGVq35S5oRsX1cEIGv2NS1VbIQtsX6228m93X3TiNzCmPRMl9BHP5NNUO/icutDFvtZk0BH/esGD1dfeMaAfO0a4notVsccSaj6qZ2V0D4DAu+xTziNpWuKLChzWjaynCKQS54LLiIDAEpsiosFchqBNLhqiZomFoBZg2FoUBp9bvNuABjEGFYr8ftTlkJ9H/qOjKMQxUqnGgkhFPiZn5vHyrOg0DI3ZE2lUX1/YblA3jSWl/1mX9xMalmPMLIjb9JuzqUR6do1ciUk5H29b+EX7GoUTayKXR5HYLst72e7RTg5oaiZERlAyNXfm07PCB2SdbOXSo2J2ibzxUiro9bomPIzdB2VW+YpPA45nHN9d5bUR8asvO/Sx7zZEElWxl/XxFj6pDyNQNYu0oiwXNnYeTSwjKml/A4RwIiwWkqWxuAQN+1r3gtpeLnyiYzGEYnyFRgcPjTF5bZbU1JdhUYlUGbNgxEQUNw5ebP112k/dRxEccu5zUKZkK5dqwdvJLLxVsIf9V6MmraZHnX+MblRfgvZBzJzUoz3saDojMaNPDbrhHgJWl3YX5CLG8LQEtlfOKIpZYTh4tCFG3HYdzfEkyCsiYflyuXk57hgubj8NQwWxx4Wi/obWzzV4gJAyEMDp7X3VutF6zioRb9cTHyQANyim3AHYoCVWHZ/JPJD4pvV+o/HRz6+mDRwZWJrpkqX36CtM0E+YHMHtL7CZgycz5e/Zqs3RJ+yFahQZrtZKIpBzHDlR8yOv7iT8nZbxmW59Jac9NOsukX9vk20E4YIDtMsURPZogP0fRm3QFCHmv+C2sUkxUAx/crcJh5EWCyq0hrDhPxq/5Q5rdcWLgH7vgffNxr/aqEvaayDs3yt31I7ooX/9V3MfqbRAMPgOTqKpqxWNf8EuQKdiBJnCpO6K7Y7u2epzVAVqrbmBpTAKwrJcOvl2l+ItU6ogl/X5b4WSWXKZuV6WCIhRQiUPyI8lXC0rus9lvk0KXbHrgFRihAKKXhuzO1AVmV6sah5FrSdrKArf2VMU+VD55+2ZbebuI8mIbltc2Te1bwNg9sDNBrFENmm8q7jErUo1MxewuTcubYAME6XqxkSYiXWPh6X7+eh3PTKgm4MAFl4ugiaiAW9Xv2FBiVyFjHyg1b3RqyLlZ8L1M021lwA7l5CRpukWxU48xAkF9frcrgbCbDxrQdJrCJhaem01La31MNEIjQC0HZnVrwlanHEzmybDoC6CdJG2UKt8WgNzgVgKYJZ4ci5JnABfIIU5jjkEkIWNCZekQCI1TxHIpTf1k07GDei3XQ9pB9q6Ce3FZiEnoYh+jwLIfqkTLqxtnwQHlfNFsp9VsVS2OXh+Li021w/tQiP9jcMkqL8llvsWS68Tg/tECpqoS6A4yNwzLmmHp6GDpeNPudsZYntQGghZ1NgoylbbU0OBx1TlkLn0uDXKsmpbIyGAfHyJUPf4vGRITfab8cREKUlHpUCR5r3oCTvijYmuhdoexQBcUXWlDhrfJJQk5vJ75xV37hMgiYKa8i0baIgTUZUCIP1UPVjXZXonH2uFHOt6ryRNMrqZpu9n76H42NT3DSazAqZkSLpCoi1yh67K9brokBfvgRDYtJoijwnZZr8drlwLj9r7xGPeXPo6/tSBFR4PS6HiYz7Rcgz1Q1x0ysLBnuKcPicCy2MpAEDdmjmVON6zT+r8BiTsNrQMjr0LV+DuirkcLB2bJr86goxaz16gVHZQsz7fYkxn3SY2NmUrlfva+FTafTfAUX50JA/9n8eIDj6qAKJzmD4UMbeIQPbXSUo0QZZ4NosG2W18quCkl2ho2l6V1bU6Hcq5MvP2111Q5CkzcYpkmG1ssPFLOFhQLpylcZglAOWfKlZyFuiJCb1wwJVwTjyGRit0qcVzCJUiaFzTb7DCph1YCxtC9FCJ1mBUr6OciNMOROkIj18pbZD+yR8hTZDoIa4qbKic9z4OzZAda5bjg1dj5KZUBVNjGNdn2oJ74jkp8+hqInShmguLwA1CVdqFJw5YSb8UhGVsc5/5hiIUpXHEVBOh86jNuJF+yQRAeFobXMuXT2tbgd1+7FVHYIpYXqvvN/7sGR6p4zGWf6OxtrXKA+L0JE9oL2fRcxYDpNk/BUL31V0B2UP4Gfru3NE1UCpz3MJA82np8hXrpZ3pWtT3kVbgtq72pKrX2J7y25XwznVCNN3Rwo/AHsXGpZ7MKHbkyQ5hxvy56LlplcWANSDB8UqsaRMWrQFsI21WmG1RoOFhEmmw1q2uFrnvHHaZyoEs/IBoc8NyoNombxqOSscT9CzbZgzRMWJNdgoJ05yjbHWuO68I+Ul50komWuPbnS5+IhZGGXgPpUKdLuaxRGKMBSLN51tHE/AiJIU3pSuXfP8kzaBFbdTNiHbzEQZ0TA+bZeJIAIlYYxu5lvbsCMl81LFxtj32p79DunsrLpH+D3lXJPRaDvVAqXkT0Wx29UqiropX7tmY+3D9YKQE/1BYwqkVP5z4yljoIdBunbN9aFYYttpVkuxhutaGkwxSi2XBgBXu+TPTHEVVGHOIud3CYA4I2XNps3GKcBhtSzve7OpFqU9syqySaoPaiRDPttAE0P5+VQrW5q1TMq/vhtd/yWHgOQzkOvSlSuGNMVbL9f1yGgP4MKabRx1fBTZIKVNq07agUwEbi6lbuhRs5ZMcWbUK+c6Z3O2gzhvtwVZoHwuNme1nfIsVrRsT6UkaznnggaEcDhCzZpe500ek3eJyTPTZiMuQWqLjiMr6wDSlSsVyVDUMMwo30+S9BLVT1MJaoXpv+nvkj/ff+f8aspAnon1BrOLW0buwcYED83qvbgIDm1urZ+YZZIjvX3UYuktwRCMJT6B+eyS1jc4s3jY1bGojPCJ0qKbQvIV9pgpPhlX/fmE4awQcK6/b+Pn9bkzopukxnGr8ueeIxuuuoviallrEDD60o6pbjYcZaMKmM4t9vk72J3ar9A39UMteutDqHUhJrUqtEkCgXMWzarUNuiLjitFt+hBGVZLn1WweSfW3+YdcASDhRISn0bdJKCxcm4XjXJQS75RMCyMVCMdRAF3nCL+juewuqAC1QgIsRxaAkur/9pxCLQdfKASXM/tMOU2NnsNubLCktYmz03up7o3rN0zqZDp/m3kSBhkX+Fxo3ZE2fssSR3POfeA4PcLigRSBZHRWRsfGrc2mgQ6Xg0fSmu4TN65c5PE2f12di/UPrl3SdV7Ff3I81khu3i56ZUF9U+atASzAxC7+rfsZ067VWtRNluFO/X//Bw+HPR5DJE3cCca9q8Tauu5iUv0mr0nDBViZZj22903TQ/dAwuJ8/i7TV9/o1ZM8lZhrbhXx8H5hukgN9iX70ubUO3C+Zq2kSwTRRQwTE0bV61fkDwJ0a6lzcciTjyU7OowANM+8DuX61uCpqFHBBdbNMkcmVYQriyRAAVRmiJcs2iPIQdqDTbXnDffiIvjkqARV6E+J01/q+1KybsC2nbLmBS3n/AJxPWjmRABeLfeHMTMylMUkl8St0tq5qMgIjnR/G64PBoN46JeGquaEQGG7hVZsLXKSaZU2TKUSXOx1H3G4H4dd30HrRtOkAdbsxIRZbUedOzmyKkzqePdMx+PaMK3lGpablEuLLGdM5LidM7sGqQT8PuKNXDq7oSSYgVdMsPlAsmNnbPwNJVJZj9ObELw1ISApuxlTDdOi60m/3x94MyEnfO/zSkpolhMkpwc6psjELUH/MymzByCTEoBxYT7wkUzE5KVn0mDGqUsHTicuP0zBxi/szaSgiFbx4U4qGCFg0menDWR6vMUrq8HKClDkTYvUUTtnc6xtudcI3OoSE7TTVktWGFw5zGRIsOEW3Z/NGXLWSnh/Bh1ENxhzePtk99odkdVDJLbbF3K4DlFuLnXrIyjPwjU983Ijliek/Ls7LbQwkztnNCDh38nnAfOi2DJpoQ9Pxlr4lKYksculHb89Z86b1pY/cCaYvdAzrkSaHmeNWRrQ1lSrmnJ2zahzp/2kHSokPZZ/w7h4PX+5sXtqfwYm1O6hnKqaZ1bdOoQ98u+jzgXBZjbm1r+RssPe7wKz3VK5yw8AySrRqsTkOD/tkCLI2kZctC4HZhhPdn8ybJRBWAYiOjmyXcO/pvbTPl+3EbmJbS/a+G6llOhXAq14uUw5M/OUw5aqH32mraM9gzMaPdSSLbZMIwLEigMzX7oFaz2c22bjb+UfA5DnCag0qgJhv4VsqT71hDJsglafvkDroEWreEkYbWt0Y+1uDIskmaxsKyJxtifE52L+m5oDvgoEw/x2/grq36Iru92oOqcWRBZEqjlv/kVcFIhTQymBZEaeN7azr9nVwW120XULJcC7ZP/2ZIDBXd/u64RDcU0AqiG5yp6NXF3xUmZZBce2Vzr+hIiQoz2vg1W12dQynCeH1yB9Dwr2OZmDL5EtboFZJ/REtUWzaHCrlpto0VqZUASerm+kyvEngdURYZdYTpWw1ASW0X//sNqZbwSe0Tzzty6JTeatdEubBUfJqtqIr6LP3SfqXLTKwu24JmZrL72xeCtoPID+ZsmvC5uvWfj39OMdBOrXCFWncCxbiaBNvNSW0LjhAnaPnQgADWPgvO7VwsurFazFov5sucOd8oq6Kx+HhNWMujgniUKqgXG7WqsRFvQDSRpz1QIXjY8s5x1k5L2cCnrc2UYyiaqmyRvSjyWrf+crplEmag1zGF/xpGY+lcn1r/02xFkrR0VCSvV+lY1/LWVmUPEMhwS0lN8+ckUCpsLYukFgeYtKVOQREjcH+adZIXwm/lCyaFK4qACk7t5mb0iVZnxRHxt4f9xrEptCBP00A5//h1QUQpdY6p4sNKtvnM6oMJy4Q/CnGoZbBVzR42OyBx4jPVwGoa6JhSRIHLm5JDTfmnWxXbOklLIc8uHTkZ3Ty1FDyUo6xgRYuKRGzmUNUpC3g0/Y4Lu2bvPFr5oSbUAYEzQcNWwXJRn73bTnAeJ5oiWt2bRsOO2vfK3RoyYIdIqCMyhuQDpboinqRgMRodNhbgbeFTgM4RoFR1LYpFYiziFOtltMfNCdQ9v0ABCNSx8bRgcQ72FVp1wKWqBpGdzC4RgddonB74cYsZMhjCqgeJD5DF5FO6CZbtTq1o3Ymr/xNrQtoj1Wi2qwTZ+I881yIf+W4s0effS1KLjUK06huUd5M3Gf66HjmxshrKwBSO+Y09yjFVJMBjcu1DyjrI7MlrS+mZnuDV5szVlN67XheXfRILY9UyiOym5IKwaH82Vkn2RolhUiThaV4ViiB6KVq6Azl+p1qh+dd3wJ0S8VBWOEAKwXHouCIs8h/vv5pMSZtt8GErcFcUjSBx+zg0PpHWHxKJAaQ6SWqehhPGqEnKwloqMNXICdntX36XNlJj3NfNnZlfLMLjDX7kELq1zq2iTIm+uConG4LTFtc5Ltuguh2qZQZNcVIv2y9AFnd8zrjKnuDQkyryXqri5vm8Nr0WMwGIhEVFlPUZFGloliQ2U1aooVM2+5si2atRQO8vYUtitzPusWUvnKsM+SdLdECL33HMPXvGKV+CWW27B8573PHzTN30TPv3pT7trzs7OcNddd+G5z30uLl++jNe//vV44IEH3DWf+cxn8LrXvQ4nJyd43vOehx/8wR/E/jpf6ASq5sxljgjWhP2kTEzfPPVx6TWHhJEFfgZQN2zmP+iGPQet6z9by0afY+GWjeUqNehdiuNmwSlxzJ5NPtr5fpXNWYlt7to5RUZ/pqS9xsJWUpaRxbTPqjg4a3MGim9Rjbl3ksmX28D+9nshiBl3gX3Hcwdd66ZqxGXEbBXNycXzSJBVRFRy4xzBMY31QOE0xu0jyHo1S5nEnuN+RK4XvY4PIxsvSt+rqIEq6qoM5OR+OzsMuvk3B7xZpklCm5lk1/A3ShOyU7JNUvZ8E6BWXdW2t/fh9m4ruTcsFg6etzmj99T+yzMNcQHq83R/YU7TAZ7BQWnRUadMkzIMVOX3wJ7qrk117nJOgjZXCadQPoSOGMK027n9183H1h1Fa8JSOk8MmRrqPnnXo3//udlfHSrW5aDccGXhwx/+MO666y58/OMfxwc/+EHsdju85jWvwdWrNZHND/zAD+DXfu3X8Mu//Mv48Ic/jD/7sz/DN3/zN9v34zjida97HbbbLT760Y/iPe95D9797nfjrW996+NujwvlkpAwhhxN2s9UIwaIhVythYkFpfC5/X9m02JCYqaF5RpcN+85S9Pup0mAGh+dYzU3CzUESqXcugMAZ0nPXecOV70mkytErVtpU9TEQ4RUJErL6hIGCSmr+korpO/ySdBm7hCHOQRDLU2F8vUw0I2zQRYMCZFDyHzryW+6aP3e0nZ3v8l7JatHD48dWWktEZCVrWFwSZhmMyrmbGS8PJbCRnZAMftfrp/jAzBL3yWqUTcbKx5M6FN4mq1RwD+bx1Bcb4AqUnV+GNTeHuQ8JhwBoAcOzxFVQjUHAI85j522V5VdRUq07bym9QBsyKlhGAp6c3pWx4dJuGrF7rbFcs5JEDxCbXZVwQoS0jhJvtS4yKb7AUXMrJZljHg+KvLQoKAt/8Hl6GAfP6Oq+u5aBWSivPPeFG2O2hg3xosqk5yUye0t0nd2m/BeOTdfJmgni6KPrQv5SZZ8A1wQNwWy8P73vx/f+Z3fiS/5ki/Bl33Zl+Hd7343PvOZz+Dee+8FADz00EP4+Z//efzET/wEvuZrvgYve9nL8K53vQsf/ehH8fGPfxwA8Ju/+Zv44z/+Y/zCL/wCvvzLvxxf93Vfhx/5kR/B29/+dmwfb91xOnjCMDQHBMPMdIgrQ1ZJTkdrp0woXM6bjm1Ec9YlwZKHYogNFsx1g3VpZVurKUmOebm/irpcOEYfgMGTBn/zIaEQZAi2kGf97U0brIaAMsINQRFXyLbUu2eCVDxaG+HJxfFnKayk/s05iQTdNxuAHUy8yeihpe1SgqOMreMs6MZhbpFwmN/B71k31NWybji8QanLZSZSYpbIaYfzUBUlOSCt2h/3v3lHymcIly5Nhk/vb9kW7XlKfltUFxDD4MAkE2cQC7DOX4KPmc+gbRU3E6eDrso3KS60Tto8F5VESGOpfugG3QmLZUkLHH0eA+VwKOfHco/IvSYEP2nLhCOifVMelGYvDUHqhAz2PrSPjlfDfeJxFsvZ5aKwcYp1TjTGiHGxsobNJsdBqiiNJ/kxz8b+DtUY0sgvpyTxmqH8IkbStkN4mM20qn2uhGAibjZG2ATRgSpDXjGIq6WfV7qGVBFnN92SCZLK5TjMD7vRklG30if858JaW+VJV6ceeughAMBznvMcAMC9996L3W6HV7/61XbNi170InzRF30RPvaxjwEAPvaxj+FLv/RLcfvtt9s1r33ta/Hwww/jj/7oj2afs9ls8PDDD7s/gNe4zf+ok54z0gF1gtHv3G/kTamvvsZGy6Yzw7R2wnH9bgOgiRtq4pjJQnFWc/aWqT2jbiTtZg/A/LGHxJj7jT99/uJkipBjHHMYYhsqKmNgJDp2hQiq4qza7FMWM8TLYXWOhAZSYIB6P+23paod60GV/PvOu73LnmhDMcPWrpY9jZMpI0nS7O79tTMolMuk12Y8lHHIu71PAGUNU98ztdfQigaF0H+a60t4HJrVT+PdKX+IHZi8PrRKZJIsioycAbW6pFnZBQ2zbJfiN65Z9xrLHnAwuVtv8Iq3HUq5ZlZMm42R38z1xTkOhJuSt21F13Fiaeb2nduDWbmshGfnhuC2xqrMWJ943Jr+6zOMHCqcnVZZrYeePK9NHqbzZ6Sxzpx5ktwv6g7c+7lfFCNSKlpyOLsU1d3E+60b0LJncj4I2w9adyK7K8ZxSnAEYCHxbHDpfYbB31fnloyHRRh1OVee1BFKKeHNb34zXvWqV+ElL3kJAOD+++/HarXCs571LHft7bffjvvvv9+uYUVBv9fv5uSee+7BbbfdZn9e8IIXAJha8qVh07j4yebLm2wD+05Yyttt5S0cOthTkyWMeQIKF88tmvZQ4jYc8PcCKAcUb4LCfnduGG3KghLhKCGLoxgOcBYMYtV+TyxFv+hLu/YV9m18m+n0rG6M2l/+w/dqYXveCOUaHqPqXiB/ucLUrlOVCGabK9fxcGOqh10yBcPazUpmG2EDzDw3+88EAUhUD0DL+Ro3gO+j/VQ31m6KwLkD7JACodUyJa+DtktJpe55DXnYEmix4qjXGgrXENgcx6XC/iGGWQVECYV26MtcGrncfKJ1y5yM1oU2ksIvbgu1/tnSnLh90mh1WSyMVa9RHkDjSsz7fX3WalnTQaviNCfNOLqsnNa45uATRCTnPOVkheo6MnePplzX+cN7gY4dvz+C/y0nCSvv1F6b0w2iYQZJCJSLxffjkEzyZIho6m5Wtm2Pbdas/a1K8n5/+B08CdLTPc/IXXfdhT/8wz/Ee9/73ifzMQCAu+++Gw899JD9ue++++w7HzdfU62G42N/sNGGrSWqEaIv+qP3iwSjLZdT7bn5f4jBwe7O0ogBsxsr34NKWgOo5YFbt4cswgnbHjAG8sF0zwzXPob4Y3ctoyMWBrYiRYhcAYApL87lMvdcHudcchow3KlyMHsbf59yictfryTmn2PlqyugPKNA8vFo7e4TQqjwLo2zC7djN1UaheVd/b7aL0c2izNunxBrGJ48YxIXT20HUNoWosXYT3g1wIQwaof9agWLbNFQP31Eg2ZY3L8eAgKbT3I3ODda8uha04ewWta6G7r2NMqhvVwjaVoXDmDlo1uY234HVDfjYoF4yy12iFkhLLNCR6/w5VTmpDwj7/eT53D0hMuVsCyoVCA00dJW67gtqZoo8Uo0PHvCReJ5SyHXYRhcdVQX3WDjFyp83+wHVnUWaCpi1nfBz2u/A+DnNPNYlPO1XNYcDJJ4bFIOvXl+GKKrOjlts0fjdGysDaQ81hD6xYS78WRKj4Zo5E1vehPe97734bd/+7fx/Oc/3z6/4447sN1u8bnPfc5d/8ADD+COO+6wa9roCP2/XtPKer3Grbfe6v44UXIU50xoLYaGwGfkyMmh65O11EQz5FI4QHCbsoOz90GyC2DuHmwdTSxuf0D6eHb5TqD1WWn7OSczi4qJbO1hURPbNK4A5YWQBWabGbkQJlahwNizBNPWpdS2l5QwV3EUoPGP1VWiG3aLmLSZFmP0LgjtuyiVWt3OfkMcFrs+Nm1peA4abuaIoNo/bruiD5ut/7xpW+VFyDxWuFct083Wu6v0HasbQtwu6ifnTd5D143Sxte2c0nDFoESdhfD5GC0yBsZM5tj7J/nfAQMR6Na1Ja1dKzul1IXovXh+xoINVa/9rVl08/VPAmq7HGUEZP2jCtU9wmXPlyQnHY/4pBr5/Zrw8KHwVntViBN0bG5/UnHzaqpThXwuKpKhUss1zzbl4kWV9FuJ/NQkDwlNh5yewJujpSHRltPswRHfT4ZM+wytTX+WPa+GyQ9z4JIzhlvetOb8Cu/8iv4rd/6LXzxF3+x+/5lL3sZlsslPvShD9lnn/70p/GZz3wGd955JwDgzjvvxKc+9Sk8+OCDds0HP/hB3HrrrXjxi1/8hNvWbtD5bOPgrwpRJaTtTpjJDWwK1JArdlNg5vBWiUPdjFnDhigaYuGYtH5+aZMnEUqegqYYC1sDjhMAlIM200HcuAvyZuMJhI1y4trUEtwmBL66UN3hoRaobSCkZNCCd6mF3e9j9ds2UnM9NO9ZfbCqmPFhr9cHdj2oVZkm6YfD0RpYNqSt1FjMSsKTg2pubNoDNbfWYsvVGCtR1FnVB95RWK+mn3N7W9JlkOQ4xBthBMPmu4Pjk1naynPgtM8Twi+T2vQw4znOyXd0/jEZl11KqFYqQrTcCvLF/L8BT8jTwzs2OS744Bd/vqJj5hbRaAJCCCfVWZvnW+goUJGmGN3ccajEBGUjZKFVBOl9liqaTR2OZr3oWjlYjE4PUmBakIufR1ExVvJ8GBCWglK1KFjOgtSG2n9VALX9g5/Ts1Z/k7WROSvz/SEOkyo1Oh8P7dtdnNxwZeGuu+7CL/zCL+CXfumXcMstt+D+++/H/fffj1NJ/HPbbbfhu77ru/CWt7wFv/3bv417770Xb3zjG3HnnXfiq77qqwAAr3nNa/DiF78Y3/Zt34b/+B//Iz7wgQ/gh37oh3DXXXdhvV6f9/ipyCZo/xUUAECpNscQIm1UcbWsrGImAAHGoJ6DOU3muAsMSeqGt90hLIYK1bcHiba7OSAt9Ky1SA/wC5SZHCQtryM16WJfryeH43RDn/FZA/6Q5/626A1g/IJJONhcf3RTImusplsmSFStM1745McvybVkc5C0yQ51Uah/KfC6Rk00m6kjV0VyCcTm0FYrzpSuaL8xmDl7BcONh8Lw65UpUlZyOcb6bpjQGouLpIQDej/3ZB7SAchjqUWVWmmh4XB0VBIsKUGR3x9tysbSD8HXA+B8HuoGWVbXkEVk8HviA0RcJsbjuHrVHwKsyCpiFTxxWMsduygWdfOIC0nRFhc5AtRUygC0GJVzQzRrK49a2n46d5ngyEhB7ayE/6oiwXsVoRx6r6yZERltiR7NMsNmt6vRIfx+FwtDHGbDqKUd6WxjSpKW1Gb+lStBrXNtt7P1EmjMnVLAylCbEppLUeu8ZbS0mTN2X0Yj1RBhg+GCpKViPdE/Fy2PQt9//PKOd7wDAPBX/+pfdZ+/613vwnd+53cCAH7yJ38SMUa8/vWvx2azwWtf+1r8i3/xL+zaYRjwvve9D9/7vd+LO++8E5cuXcJ3fMd34G1ve9vjbk8eR6S0s3/n0zMiDs0nJVGmvm0q250sZt2gJYMgE2gOhfzlDOQRGQOCxlOzJRkD8ulpjQfPktWRasYDmLQzb7czkBwdfuPooTVFNnKuLHUVtmpjs5nNcSJkgRn5j/zxJfa6XJquXjMLxZQJhlbZct5Volk8XslhhrJho27UxtSHV0xMUbD21feVR8lQJ78Pm03ZUGN0h2Xebqs1qyiQjq9uLrvy+9LBEhFgNRTyfHvySOM5VxukHQ+ZMwgB6ZEr5aCBbOB6OPIGruhYyna9Wp9J20qwd7lHLuOjbRpWRh7T9+XyizTtzY88Mgk3C8tFXQvaH5rX5v6RHBBunODT+OZxRMhhNkQsp5J1kQmOIaWaQVEPKzmE7fDK2cbP7qVRH0xwbA/HCXEWPqHQOHpkifcBnuNGUN3V9yFonx16+6oQ+PmdbG0yCqqhlnqlvYO4KsYO9xOo65PcETllhKxW/YAsBNKJi1bHVsdhn6oSlhvSd4PA5F1jPCk5WrNlKrlaf8vjzQTF3c7PCXn23Hoov697fBv1YvPkAl0QpUnXzzl4KjgLN1xZeCys0qOjI7z97W/H29/+9oPXvPCFL8Sv//qv37iGiTXn/HZnZ/XrYbDJn/d7cx2YD5t94sYQJv/fYyAEFii5MqH1uVgSZMwbs7bBXA8DRXJIu/ia5rBqrcG8oyQofC+Vxk9atXseR9kYcrbPTbnRsWj96O7nFZ5nzoL6YvN2O40v1wPHdaY5qBR54cNYFIawXFD0QN0ILXTSiH7RXBE2dik5VCceH7n26UEFoCacEgUqrBZWOjnvpxtv+bypiaHfK6oiKXHDYoFwtEa+eiobdK7vgcYk6Bi6sRLkgeeecRUq611TWaftDiE3Ka2be2G5REBNuW3vTV0w1iea14LIpavXEOIMApYqdK4Jf9wzZcxqPZViueacKrIjh0NxOaU6rraG6NDL4tpRHlOMgIaPNuiKD52sB6nNi+UCYVMO4jAMdqCZu1HnDPvPhTNQ+kCHqSpyjQvRWdjNoWg++5QLwqL9b77PSfkFC3OLhkho0hwyyTwO2ufieu3S509EFKuS+wPI2+TWFRJFXYlRECQElfdInn8u9FXbyzwxHjNnOMD2nbheVx6RICcTUmWXiTxpBMenjbAVIVZDGz7krst0AMv/J1Z96/8T0ln5zxQydb+d8B9SDXM7z50BeKTBiEwNOVL97+oCaMSIdzOoRd7va8ISg10bq7JlQ09Iauxj9huqg3Gb/jlfrNsMZpRPIirOfq6/k7FRxIBTBQMAnHKRD96LCVHZhduVAycLeuGY7+aCkZDD1tpJM+6mhgQJwMLw8n6PfFbDKCe8E72FKnv6/uhe1dUwWtvro2udkhZCV5eF45GcnlblqDSo/psPeTd/s3dzuYZnZ83OuUJs3Hb7+mwjxdJBMVKOitY1x3NLeD0OQRGDghn0lrPDwdty6Ap87w4xbdOk/YJ2EP9kIsrzIDKpSVLjZcpZMJIiR1YxqtEoAxOjrl07LTfF/l2fmxQhYt4Ro5t6UJMRUrgJ0ZNZU0UlgZk90rkbG66NPCc2EWv2HeDJlTmXuaN5Vfa7eU7EkyhPRTTEO97xDrz0pS818v+dd96J3/iN33hc97jplQUOKarhhjK519Uf3abFVX8rQgnfipKGFUCZmLGQeABUti8w1Wy5LZo4SHzodihLm8zqHsivzRsUhU9q6J8j9dFiCYtF4SBwlUugbjjtfTU7IsWozyb+4b/Zv8p91fu1BL8846qhzcXqIBDjnZUf9UNzdjnnx3ZlvklxWq+rRapZEIfB10ggdjuHrRmjnuK2oYhEpAqmGjqp702Jd4tFfdfsR3X8hFB9+yqZkAydEyhzz/mim7GPl47dPIhHRxaVYfc4PvLzC3DjU9tdOTnm15Z7x5MTysZJvnCCk908IIlH62kmzqDRRNMoglpGXsp1D4Nn4cfgDz9dt0IADgvKBNmiH1EyLsZSTKjyW2Ltt6IcOhf494LUlZLnxM04wB2y6pPa59XK812I++EOxaUUWWpQNn2H8WgNq5Whz295CDTHgq2raHtcvZCeq4iLERrrPFYO1KxVTvtjVbbKflDyj4TCx2mKj9laZaF5msdEpc9DfcYkJX+dN26sIu0jsq9fZI4F4KmJhnj+85+PH/uxH8O9996L3/u938PXfM3X4Bu/8RsPJjmckxvuhngmiEGnm221vthaFda3+Tp3O/P3A9V6Mw14V8IRD0YEWJZAYlWLtZk3G7P0TVtUi1QtwDigQM7eerKwJ7PkK6yetjuEIdnmUghWxWes/nsuzGTJhfbUN+YAtH3icWBFizazsFh6+B3wm1kmxEbT4cahFovRsVOXQcjIp9Xq4OgQcx1xO8k6L8gFqmXECknpBI11Kj7WnNw4IZWaC0awsveakUapHKrvTe+dRpfuejLfSkdkLjW+8lz9+Hm3p/wITfSEvf/KR8mnp9WK0v6J1VoTD5HvexwLBJ/qeDKPBBh8qKu685hzoAAM/c4Rc+f8/dRfh+ApREwRBuriCrIc+N3G1QpZ5r4WIsujHE77GWRBuQ4xVMQmZTtg835fof3WBQmUSCodN+mzrWl+N+qeU/7EZoO4XNrYG8eD53F7j5wrt0GUGXuW/r3dSn+IaHm2oXvo+9H2CIeDOQtx8Otff7fd2v5k90wjMPry4Mw/Kf+v79F+o1ynLep8ZTSp4ZRMJCcjUs6O9ZzrkvdTbpfwzCxK6iaWv/E3/ob7/z/8h/8Q73jHO/Dxj38cX/IlX/KY7nHTIwsAnBUTVAMHEC+dkGUjfk09QNmqWq3cwaJQmIUKHR+btVovmvHVL5dThQIAmgiPc+Fpvd+lE8wRz/T/Zt1Se8LRGvH4aMplUP/tamVhUmYlHVAUrE/6tyhYbEmWBFjLqdtGf0dcDbVaOT+B9sMs7pys/ZP8F7Nj4f3FQdCEcPkSZbP0SFC5ZiV1CThJUIWfw2WquyAx/mG58IxyHQ+xZh+LT3TuGrXcoj6jvYbbH4cSlkYogr0b1M189jmxlnkOg5Q6Nvg2wxIw6ZhevuSs0bhe1wRSek9GSgCfUGpoFDvIOqIaJjYX3DuKbh3XVN713cdbLpe/VxUdtJ/rWtPoi8UC8fKlOvcEeTJlSMfD1ahY1jkga8WNKSlh7G5QqDxeqmGehnQpanki67rdP3RtArP8KFtjOm6rlY2D/Z7HItb5DKAqRYQa2DqmvpU6OaSIK4mV7sUJnewd0v/jalnm9fGRR6tkjrf7KM+zsFrVNVk67sZy1m3ZoFhqZFiNmqP14RDSJ0HUQ3O9fwBMShxsiNR6SMZxxHvf+15cvXrV0hU8Fvn8UBYoRtqlJz07O6jFmu92hrOgaWgn9RZG0mbdD8bKLmflxP19DqzEnAT9SHNEnOP28L7jVFNSK3piN6tWxqw4WJLawNAs9+UA89y+k2tb36Rt0KH6JdWvaPeXTa1NWsO+U3/TPE33utnUHPMN5KrvqbDPG5+/CpEStYbExNqn57mQuTkhopW1Uca1kjHlwNcEQi0JVG+13TlFlvkVxtWRAl/cJkWWABlzGSNn8dLz8rVTGafS5rTd1cqG+u72u3oIAT4lN48VW4BjPXjmQvZqyHGxpM1NFGlOcz4TRgYyWZBiWWaeHzH4sF7te8svUasUekAV3spEOWrEJUSyDyl3A2CI0OT9jFJ+PESHREwORx3jJFEX9DmPH0c1cFsqCtCgXypNBNIsb+lAv8vjKrKna0bdjlnHoiEw2pgA5z/rEGeB7gVFY/k+bZ6UJ1nKVLxezkK51wte8AJX5uCee+45+NxPfepTuHz5MtbrNf723/7b+JVf+ZXHlbfopndDlElIkFobTtTAi05jbg9VEQ4FBDBlnwPTSAPAQ99cn4JCyYBiZefNCAtzai184PDBTn3wn8VaIGmGcGf93m4PKgfus9xsntwn/ViImyVJTG0HAIGS/RgaC7qBrsv15TMlJ80SL3mzYKIVXcOuk7BUP2qzOSlcqxuz3VcPbM5ol4BMmzj1sVwzIl275jd3RRswli7ofbQtat3FYBkrERhBCAVNbt9NTiVcFahtscRbNPcGDQ2Ff5YdFo1iC6BFh7Lk4mdSZB4BBM6+SRs8u68SXYO6nlj5UAUxp+jekUHtAiUrkTSslsC1a+79zK2RyoKXGikp1veZMnJEDYelQ9z6IzA6R1JZ6KZWb9UcBUmV3zI/LDLmGh1+qSTAsmiisSrTdYBCrS2RRmTnwqpjW7kVxcAJHKbMZF4Wed/1v0KeUwVLeR7qntuS69bmMarbJqG6OXMq7y9XF1Vpg9SfkPHQkFWNljgYXSHPmYvY0ige1zZy2c6KKa/LWbTmmSD33Xefy1Z8Xh6iv/SX/hL+4A/+AA899BD+7b/9t/iO7/gOfPjDH37MCsPNjyzk5Jn/qVpY0yQ4wX1usG9K04V2wGVxUEKTpVFhx/XakuQoqamQoIYpzE5tBOC0/Enb2g2l/d61TRZWSgWmzXToNRY7uwkmLpUQKgmTCX0ssZCqjNU8Y7mH1dJbLMRIn5SX5X+bG8RDrM4NRTBnaBUOa0Alt9WPyvhrUivf3pW4RyrMOSFg0niEYahWon4HzEdmELksrJZT/yqTVbnNSoKkqo+zVmAmBWIYKuFstfJERW03k1ppbD3pNLrfmbTumKB5OWaULPk/u1EmxDtdU8PgsmoqEXKCePGt9T0qHyZTRUVBYabvP0zvN2i6aXq+ECZ1XOxvbi/0UdmHRHIbeWy1fsEcaU//Vohf73/e+hSXA/dZx85dz/sWEW2ZaGyfSS0KRpcKZ4eTQ8nc0jnW9mXGZXfIjan3K3/PREk0pOKqRFSFTN21z9TaEG2Jg/OUhdVqhb/wF/4CXvayl+Gee+7Bl33Zl+Gf/tN/+pjbffMrC8GHIMXVslovE5iquisAUGpWf49aaW9q2c36zOzhzYQGxOr0pLEspXUnIWjsM9ZsjG37uY3MddADY7mYbuIqBAEW9CHVP3pfsnDKDZuc7AT56ibXptLN+xL65uLoiWGetdqgfK4HBiesmfRZoxU0rIz6bJZIrG3VVLXuPoJOqNJWIexUrTphzGvfFS5Pp2c2n1xEAECci/p9mvMtti4FCilTl487BFVh1f6msXICGreBkxkIWnNwFPSpQZd0HKnUtm74bXieczuwRCFIpuT6w6GaFlGgw9H41Z0STO8o7/bO0rexs/mfbL1GWTN5s6npqSn8Udvaliav4aZT2N/cYzq8165VVye5QM3iZ/6DWtL2f4rwaN0W6mohJXnqyiNkYjb8tKxPizzS8WeSqUH10cbKlE5NDKUuBK24CzhCpYtmEkNI/51Oz+q7TKQIsrLLrqe56Ii2W4razuzp1V1KaIM8X5XvNsHYkyn5Bv25XkkpPSaOg8pNryyolacsYqf1H80TZTAh1XhiYjxaSziWbGxt8RnXgGAbPkKoBwBPeLWKms3IJSZpQtC0sNCh2hDOYuN+zKAbmoEwHM1opdymWQWJntFYyuarP8ALMSKjjg/7Eg+MZUuYcn3h58S66egBYT51tSpbd4oqJmThzIaULaulZWlqyY+NnGvpX8DCKN3YDEPlYjCSQ23hwz8sF+WgpfDS2fGREuSWsc+IbaEeeHHGQlVES9CZtgyyU1IAI17yoajXuLaZn10UKEFK7J2YxRcLAbidg/pbkpzqYWebfus+I+vRIQyagEmVQnnHZmGKdc7RANZ3DZeNZJHLNRxZMkk2JtdoJVsO2ba9QH8rVSedsgM4xZbfja0hfef8m+Y6XjdWN8YQj6VT/CcIkt2HiOCC+LloCFRFwaEzIXolXkO4l76CbHX/Zv9MRuV07XL7DuTl4L3WiKoy7ow0uvf5JMtTkWfh7rvvxkc+8hH89//+3/GpT30Kd999N37nd34Hb3jDGx7zPW56zkKBGun/urABH14TItQn7SwuJQWqnxfwEzWEw+SYhgwY9DdGaqKNlDVfPliIUxGGQfyJqtXvZMOeDx9S7kPtH6pvEcPsIX5Qw2YOQOsG0D608zdGqa8hv4mD34wOkUvJKmmRGLXaQ26UoUYpKcoSfZYT8l4KziQp+TtHgIJsbmKptOhNGAYfkub6y5Bn5VCEMJO2OERY6GikWH7+PeBrEADl0GgLhGlfcrZDIJ2eydyU+SRcghJCK1khjW9QrC9NshMGSAhmo0gNKP5ynaMhTOdYVn/16MYAgLQlHd6YGytTw33d3BN+h4XDtnyhZs05oQM8DLGEVMayfguBMCJjRgmj308gclUSWPls9w9tUyz8iEKslrYxiTNncN0TDpEsvAZpP80nI2OGCKQtEBcVymc0tFUuFS0S3oBGgBxak4Y8zJTfttBUdW0QImQkSLqP7oWast7uJRySOf6AzlUjNst+rTwnZ1hxm2eNDnWThcn7vFnlwQcfxLd/+7fjf/2v/4XbbrsNL33pS/GBD3wAf+2v/bXHfI+bX1lI2R1ipXATpRNVWH8oh4tu2nlXshkGTBdageJ1U5RlKxPPkQeddqybQd2gEUIJA4qDs8LLRlb8oEzI9AdMCR/LZxuvVFD64jAMJfZcFY3tbhY94M0nDBF5HOpGr2NnhMwakleK22QZu+aaAKTTUzlkah2JeHJCbh401lN5WFwt7eCy6AhGEyxiIpnyVJUDTxDMI6rff7Ww3+eca70Fi9+X7H06FstFGX/amDTVsEnKwHIo/lrJW88WjJV9RiVfFX9vBOLaipVpGl4ThYrZWh2CHdAAbCN2MLagP8OtlzE+fMWuQxoRjk4Ks9xevLfYNH1vOj1FvO0WhGHAuNvWd24RFjtzFU0OLkHbTIFlJdeQhWCRQz4PA//NGTEVfg+TiIN4coK02SAeH2HUOgn7fb2v5bmoqd5VYZrwLVZLg6Tj8ZG8eyk/H7IdiqyExPW6XH/LZaSHHkHebREvX0K6ctWRpMNqVQ7m5aIgibpOKU01gEq2JDQkLAT1WK0QtJokuSPzZlOSGa3X0MJMeb9vsrTXNOY5B3MhxcuXCylW54isB5tbKdZEXcoZInSl7EER6eysKjf6vpSHtVhUl2+IEkIqiubOk1BtjvGYkGu4IKrk+hTE1p6t84cNukjVU1Mu71ZJsKZsXRxn4Yb4ER7n73/+53/+Oh/4+aAslFOs/l/rPIAWJqqFoNEHytI10Q1ZIOZ67/r9eSxeezYjFDljvHIVgz6/tWom/shx8p2DP3NVjEqCk21FMvaCQkjIWctDqNB58tEGLQFRWdv6c/bfu8aSRc+UBoXnVRkhP34QeDhpoSM6+DUiIORQx6r5/exYZQqNG8eyxobiP8/wqZvrHBDlQxNt6RjutmVzsnK41DfH9+CkR6koJcOAvKvfT5JIMTpEfcrC7TDFiMNRBS2Z63cNuaTvaBzsO/esbU3Kc+3UzfO8r0RACBkWHGmkz9DDArBDw3zG5leu754P1Ln1455J/QsoyqOVxh5ISdfkZ3oPnu/N+Nj7GMcSlaTW8qYmXbI5R4dWG3GRNxTJcbYhPznqHAwRAfIc5tOQJW0RWqGMu0Y/5G1V1Aw1SLXYl87VHKKFjhqPg9EW3S/0byluZ/fhBFqCzBWOQZkvWVMlQ4wPSnPtEkXp+weAPfE/0oh0elqVSg1z1XnSKA/lN9UVmgRNBcY6rg2fq9yYkFpxb+o8SKdncEnVdA5elNyAQlJ4CgpJ3fScBQCTiWA+tbn87Apd8W8m9e49tO+gLLbw9X6xWDmZJi5bdC0D2CkALHyghIBwfOQVFjq4zd+uFoikvI2XLxXNntrKlp1FG7Rj0I4RUDdWIkMxI75Y2E3CGuOQaPpYZVdLGlqyXtoxDlFS80rSlzb8rg5grn+kneybVo6BQwjUauV0sMuFjw6xS/1zlbfg/KFELp1UBm1T0ebsP5NrtK3mc1UlxfzJzRwJAeHkRFCUmsjK5dyf5UdIFA4lH9NEU/qcwM8UfguXdrb0xOoHBjzvQTg3YYieoHaA02Ioz1zKYi0jbrfwG2eQNNSG2vH3/GxdIzrfm3Y5Hzxb+sNQ1h4/84BlOgkj5ecC9p5qOe3ynJK4qOFNSSpkRYr4vvYci8LwyZ+ga1HXmaavjxFtEiXjd+m9NHFSqJERHKUyIaJy/5cLd42mPw9HaxtDRXvi6gBnpeWLHc2sSU5PDtR3CkwUCZdM7kC7u0zl5kcWgKrFK0td/p8kLhsAjLMgECjiAnkrC7L1URtEJvdRyHxPcb4uEkEsZNZgxa9rLGlm8mp6Z4WJ9eBzHIaMdOXq9MAg+JfzPxStfwCuXjuXl2Bs9xic1T3tO0yrD4vqfnEWPdQC8AiMtalVitS6ZAtTU8SqBW1oibeaJ+2ktprVRf5h3aD4t1bGehzt3wrrA7DD28ZVf6NRFHSAmQKmUQDNfGijRFz7dM7EhWtnkJwLalXX+9d+pM89JO+mWtq132WOWzQLcQHyfo+kqcclrS8nYjK0Rdw+6eqp66dlAR2GmsvCxknXH2ysbDxcit46TnpAu1wo8t5CDkjNtXxUaz4RhdadLkKIXMCAnKplH0KAFoSazbQaglnVbAHbO9L20Dw0QvNiWdf5OHqUh96RJd9qEjelq6cldNaQGM91sM9TJTlazg1FQ4lDYmiiIo3Ul/J9LaPNyokSSX0Kb5mfzF8BBPmoEUb63LBeF0SD1lUeBTVQxIe4Wn4/SJjLszCp2kn7s0XtJD/WwFTRvAhhO+Z67nHRctOrVM4fmtPER0YXujegBDDVbCchayTx5KQy3ueuaaxk91uxLKKmbwZpvi0RrH3uOTG1bAXYz8cRWEoKY74XWSnqJ3eaOlu8/AixymyjAuqYEcmy/iDUGOsmoiFIylVFI+webCGEYIzy+qdcY2lymzFox8OiSHKuVqW2TUlWsqlawSNmasdo8eQ2ZsfHk3dlabVlM52Q7RqZ+95i2XU+XDqRA3meBAagpoe+dFJj6m0IQn0Wu48EyYgnJzWXQ5SIIEvq1CiY5JOunILDSBsjTk5Ro2JcQN3IDUHg/AZyr3hyYvkEwmpZ/n1S30mdR4T06N+Kakl67rBclCiZ5aJEYywXE+TQKXpt/9RiX9aCYe6dLRd175EcL5qATH+vbXbPCpFSU0ukUhTujkMYPcKiacoxDC7qonAHKsqnhfEsVT1dV/9T3pcV0SM0jPkkhnwp6mBF+CrHhCNYwmpVoiBWpZS2cWqWixqxxXsm97ENGXfrP1ajihC5idD9Cmfh8Hp6MuSpiIa4EXLTKwvu8FKSDhGbyj8C+OABUK0AuY79nlZtkrV08slNhCzPiTUdC/yZrl6rvkiF9y1m+oCVM/d//Tv6/1vI0VhyAsz+dhiE1FUtLPcc1t4B50t0FqGKFl4ahqpOH4Br05Ur3kJjJn1OBmMb+YpdN8L9YKXC4OcgoZMG08qBpooDbxzmnpINTlM5a9/FV+9IgrFGR9RqeFHCNGO1qtrDluD68t8p90OJXTnlEs53tqmHzEyuhOp+SaVIWhuNwPOeXQvymZZwR061IqfN3cGNr9UOCHGaeIf6qO1SpECrc3K9D/Nx09rM+13lOPBzYyg5LZQZP0pkxLVTG7vCslfFwFfX5IqQytMI63X5fFczMLraGjzOGtGj707fw2JRFR1W0nUNDUo0bio8xmjRKfyOCrrV5BVJ0/2gTf5k5OsZ5dPSb4Os691umuSL/+ZrtX3sGqTS0LXo2dYMCFurGu0TQn3mfu/rnSgvhPO46F5gfSCkyT7MNTdLrHPbpZamceNIkbBYHkZauzi56ZUFN9lyqux3d43EiDf4kE1iPZjMTRBs4yrQJFlZrbDrgPPXZ1r4O02XOzr0Y5KWufFzp82mWo9N2/N2W4mCgNsk2jAj6+eOIjxaKJCeW10iqf6tfeHrlK9BSkeWGgJcTdCJHixujKKNr9Y1MFcBtdH5h208Szhh3u0dg98Y2m3Yqd5LUQZ4a8vBnaSY6aFl1ymJEfAuJvt+5zaxSUQAuzsAx4BP290kmsfdexyNoOcOeU3sNFTluf4owaqOCvxvrgzeuPWZiUIgQzAUwLlNeD3kVKMh2nvNicyDVqFnFxFCLBEoqZJT7bdK1gzRjy0fgkK2dYqHJmNKdOCwEqqKhircur8wUZYIfTYHlUCoboY21K81Moi8aKJje+AgrwqZzN1ts8bYPUoH8zSskt1mqZIhNXojp6IQpFwrdgJEbGz5AmJ4qRtAlWCKSNA1YNVVWSGiJFYWOmlfluek01OZw0QynuHCGBKakylw5XcXiOvncGP+XLDc/MoCSfGN0QRiUiFPFj1g1R+NZlFyieqcjYswKVBC9wJQE5HwM7a7afpgDhnTa/lQ5uvSiNkNl+DBSTsOZXAEqgU+kBLi7ushYWtne/DwODCMOER/PWv78n9/6Nc6Ankcq2XT9jvE2Xfo2144CDlrjYns++OUHWJ5c94HIaT696qoEkUppGwb5CQ0Sze+xkXmx1AOSs2YN9ZS1y6G3lw1frwVqnX+Zq23kP1BNhE7IMiiUyufFVLjbGQkiQBgCN7ljTgkh75TZEgPAD2sdF7rHJGkPvH4qM6ltnDXAcXXQiZn2mBKiWYuNCVa31XTR8CMB+cTbxEXVZoY6WgRPOl/VfLkGiYGt+1V5JPcoXPcCfu/KaXRlHHtt32uovO3mcOOZwN4xCQRCZPbrDwgoMzRVJV8e6/NOm7RhDYhFgDE42PfZvmt9d0Plu3bE8PkAsSm0XX+uWi56ZUF27RFm2WmPfs5ywfBtFjnGy83qpctadMGJvDunIQYysbWWuExlMQ7ZBVxYpbmJq6tk7SnM/Ck+3pB2QZnNkj2xR/mdkwhQGsrE9fUimssyCybrfpXtd2aRtkOY36EHTqxbCQS9uTg3gautM02hIaVH2ukw1zOicYXy9az/s1RAuU34mLiDU0hdUVWJkrXfGrbtt+6sWruiVn/KqE9lVy4qwpHo5CZG4LZ4Dq3FEVb+myfxo4P9ZB2kRrsFnL9nJln6sbg9gO+boIjJU/va8/VQ1sT9YgyCKAqPOxinKyZWA/hIRrnw0qmM2+EDkx7PnOVRKHgmiOOg6F8neNjPx+WtVS68Wh4PhP3xDJt2oFLZd4Xy0oSzclzFpo5a1UzbX4/ylHA70jmm0N+dLz1XraXzrg1dIxCLH2X8VfUz7XTeCZ13F2afnOBzCRlsktC3Y9C9GMm43mRJaqfNvmeH6d8XkRDGIu7Ofjzlav1Il7cpJWHGKSq3Uqy2jX+vRAmVticWN6DIExmWrQ1HprY6ocsLrX25QBybhWyjouvsF5fKj+2ygctIqD6rOPg+8ML11wqTWXInFGjSdD8lizUNiUt3b/WnZixBMQ6MZdGnklkpGMLuPdUXRcoB60oJhajrX0jdCJEZa4TO1uUGvcbABazP+E/lDbE1RJ530SXZKoeOIccaR8FTk1SejqrAnYAxi+JsrauHobyEQpxkdxCOn9zAnKwnAXm7iFkwEVqAJbYiu8xhbO9G8lbcmzZwvpqSZ7m3FHy7zzCXHeWA8BKyhfIn+tPuFAJixqokTtxKCF8abtDWNb+TRCSnG1tGHQ+jkBQt4fC6tO9oERfyL+J82JRG/p/nZOmIAmMr5B9yj7SRdN6a9KlSJErm+30vtSe0iVVGoY6H00xjvXZOteZr0PvhO+p9yv5TBo3RxqBsbzjfE14WuryodojTtrxaVGj5tmuD40Cr9Eo5aea1TSVdR7CU3IIP1PkpkcWeBPTRDuHryWYUUhlGIbqJ1OLXJGKnYQOioU6l1SmPDhUS7M9KGNAWK8Qb7mlfieWn7GQtW0EvYfVCkEy7jmrl63HGaQjXjpGvHy59hWovsbdrlg9CveqBm6MeLpXIpQmxEosWq4KAVQt4qMjZ9lpXY3WHYM4FKJZHGoeCB2+RYXU46WTasXS5qahafX/i2qBCaN7uPWyjE1J/MQWGkOlalVGidd3OQYAX5cACoGTxR9iiYaI9cB3c0NQkUqInLoo9P2H46PyrpclRwaEdzNrCVH7huc+uygGFBpX6m+w9ebn4vDsZ5Xwt5RLPo5Lx15BbNwS9rdY55Y/w3IIVIa/5vkorH4PNTMKltTPLvUpJhULB4nakPcSb7sFcb2WsSlKV5SSvfFoPVF8OZ9BPFoXxOb0zPIyhNWqJD5iAmejrJTfy3zXyAuZs9pHzhtiP93vy30Xi7IugAn735Ck46MS0SIKWbx0XN5Hy40iF0s8WpdIEZmPDlnQ8ZfskcOzbyt5V46Pyj4n94mUn0P7aWML1FoOHBmh75tJq8KbcW01UuGitPNZtxnfK48j4vFxebdNNITLF3N8XMm3+sw4lD1N9xSqkgqgKnaOOJmh7sKLdEGURz8zoyFuemShaK4oh7tUfDPm9wQa9uiDZq2bhCvx9Tmb1u/SSLMoZDdXQ0Ks17l6A0ZQbDR9tZ7aVLEAKSzii83u8xHpNEzru5sPOyFIWmKnWLUWL7ddM6Gxhi9tLGmehZg4yjg0bHTXDK3saCQuIllpG3bVwrL2mB+5oja2CeRcCIj7PfLVSsozaNL6MkLTwmYinE78so1PGokqSJr17StkTgiOah074t3UEkrbHWI881kHBfU6pPTmUfgSO8qix0roOIIrB/KzLS4/jYW4RhYsAFMGjJwprpS831UYOMTaXrJmLc8H5zEgFGzakWR1C3isMwZgszGrENtdmWOEfGSt+rjd1jwOhF7ZI4h7FLKsFSI06lytRMdQrW19nkUV1KydIXFWQ59KPG+3lo7Z/V7bpO2kbJIF6anvc5ZfJWTDsBzr+BOyoAdjiIUDkq9eM5JhbuZcRX3g1mu5INm7AABwymZ2bwpi5N6tonM5F3Rvs4EV9so7pLMN4qohgOcmX8zZBj7jpRQQk0yUnHfEcsbweKvSAHhFlHktFyHPQATjpkcWzK9GFrLL4OgO4kbLlM0w3nKL8xtq8qU2vvjgocpcgqYt5oOOzSGs1wLesjNLPM5mF7TnJckYSb4+tS4m/klti1kVVNWP28EHGiMCraWjSIP83xjlbMWrD5fb1xIBaSOsVkM97DksNp6c1PE3Xga5iQAbYz1QC6N/cGPgxmq58D5u8Z8a10Heo1r+Na6/krjMEmzcShP/fkv6lPll70vv2c6xpupoOFqX5y0WnpOAeni7DdzcEbEcBMQRsGyeJMq/sBwA5qKJ9l4dh0fG1lCHGR+54z1wOKkhE17RCotFtYC1j40f39rRjrvW7LD5SxlFh6ESQ/mAat1iIXq+iyIrlnOCFKzlqhoL0iZH0Iue6zIb8qg5Cg4gQqUJVJEV8HkW2AhSOcCXqZkgCZFhRUmjWXQ/dBErwtkg3omRSIkwHWgfcNEzy8dgu1J4rWv/UtBKVQ6JX+LWFeq+X5XBaU6aLlO56ZWFCjWR9anSVhTkQ18ncsrFT+fIRmSZAZ6lP9uGhgjEm4OgA5Wg1RDq2AXQ3H+W1EOKBbO8i79aSXdhuqCAkip4uURYrjxk1/ZDNgpbbKK02Pi1TOj2YBTlyOXA0HGEbPYzB6xTOJgIl7XKYuPaaBS/8my/UZfvaAzEdRCGcjizQmibXut3p0gF7b+G7c25CxTanaQytveibS1WWN7vqkI5VOUEmNlg2b9LSEfpw7IqT/peGh5PPDmZ3ldTT69WbkzbTdaKC81s5jb/XMlv4qHY2JGizOgRKVBAOew13DEM0eoh6LiV4k8EVVtfJNeKU+BFAaX9wNWw0PagHqZBSkkbcqPcoTRWxUHHNQiZV1EXtXS1T1oaXMdd+UDsPh2nqa/L9avaXsBCP136cZJJ7gH9DSGS3E8bT3XTJfXtq1HQKLDlxw6RmaRhZoVS32nO9r4nqC/Np3h85AnDqpwpAhIH/x3k/ern7DrSdkium4uS7oZ4ukp7wPLGxJMyS1GexhVRf6jXjTTxCIpU8pbB4t5CKKxu2hgpfapTUnIpi5x3NSzNJPkFPtk85lAGPjhTOVQn7Hztx24raX53Uk2vEoFcP+y34hLRojtNDYSy4XIVuuwsp7Q9rejBOCIOy4LOKYRu5CvKEqmWccp+Q2vGp+2/Qs3OOlO4WAmHCRV9koI1ATAIGSGWiASHfpTNM2023g+/WBRIdz+1AvM41qqEej0T8oykmT0hb7ublI42CNhcYqJAqmuEeQbsIktSVEvdWhjKepA2lWI7vDaSf/ejJkTysfxKxPTjr6FqwciHZfxHaProYqXW+ylBtyVEOpeOoC1pvwfGZX3/sh6THT41/t8ORiajatGt3b4SJQ0hUJcZDCFATlZm2tbItWv1HVDugfKc0bgYIQbK0ZCN1Gl9Sqm69rR9KSNIeesWLnch3Y0bLF87rWPXHOiat6MlFNZ8EKO9F3PLpVi5ojp+TFrVe1hBqaIQZRu3XJXVcSwK1ox7rnVdsMstt7kjWsI5E38zue84JfrZBlZhczvWwnAXRXDMuP7nPAVujJseWWit2riqBVKw9AQgVhQs85hacmxBWbElsnKHQYhC82/RQp7sA4LE1uu6QbUuC76eQ6gUIm+tb6C2IdL9goSFrWhTtXv5jJQAEc3O8+Oxb5fbeQjaBCpsLKS32uZU/ZcMkarS0TzLrGJWBtz4quUcSgEezeg3FCJlWCwrdGltqzCuZn1UnkBVXIZK8tIxEGuF74MYa/jdDNEU8BYv50NwY9L+ZqIgUsQBUKxWGi9One3S7TYcCXN5SN+K9VVhZQsf1ENM4HRH5FPrk8eUEDK7f+OCquMWJ8hDWzwNElXh6m2gWKh2P01OxOOviCBb8KJAK6nTwmrVHWLFryh9M7s9dNyWC4STkzp3Lh07KN6u072EU1OrpT0jLocDuesOhZKGWEre2ztn5FR5V9z/9r6oc8O5BNmtclTdT9afmWJfXBiNETqep4Y0NSii2xeCdzuooeD2T9AeZIpki4zU/VP7llNdt4fWaJcqNz+ykBNCHMyCMS0XqFnX4LVyg0dlQ0pCqDJxVkOqyMIhNwTEOjDrmK2BhNAcEpb5ryUHtaGJmuQp+8PfowZNuzW9LFmJZh1RWJSREnVM+P60weRG8XDavT5frCttQy06BLPGzCqWUC1niWheBYGPczs2QCW/8f/VyJCwwQBiRefk3UvSz7wvm2BSK44PLCXdtTU3dvtCcGNWPxFWp0lhtPAPfa5zibggrkCSEr2GQSywBh2SNhZrqZaannXFyL9duJySMhXOFeQAqIrzpA9ksSp5zkJ2MX1HBi+njJz29f2iXu9IuVqYjYirNi6xPDdJVs602VRLWPuQmKgodx1WAEaKEqG1uN06JMfGhUJ07V1y9sERyGdn9p2hd9pnAHlX5k0622BQ/oGMYRhH93+EmpgsJ3o3+vw59r66W7e7WsaaUYOxriENkUUINs+1j1q4i3ObOMSCwzb3u6JQGgHX/10QOVihPZ4HQdu0q2TZ8ptYDRWVmZwxk72rDcnWuWUuigxdTIoshWGghHrnRMndcAkAZvr0uO9xsXLTIwvGA9CNRKsWAtOYYXUfEBMewCS3uG16xmMoDGXb3FrR2GzjTTTX7PYTfzAACwuaUwJad4b/oVpY9VkhBmPtW2IVu1kTGqb8A7ZO3fg0bpaWK+D6sHD3D0S84008LFc+1FPHSQ4I2wyVjBYp02MIJRTtgFKjJKywWpV3oO4H5lOw+4n6PVfIaJp8qUkoA0wsy8m4sF/b7sPvOjmCZU651jAYqPjSzHwLQ81K2EaFAHIozswbT6gM1dcLGH/H+pOSHPrsqmjSKzMiE+u7KNfSgaCWcspIknOk8lm88qnJvCy18WpV3tMcGVLaVX9MCi3qO9C1rj72mkqbmP+kVAFw8H0QMqEjhNocqsWs8p5yWFAb8kgom64JRV9UDnGeGm6Q44ywu6px21kpbCp4pu1p+xCVSK0KvaJUIeK8ugqsZBoqJZwO5QlY/g/6fMJXYnddCLPcjag1Ktq1D1UOgoWeW39ln2eS5YVIvkF/LliedGXhx37sxxBCwJvf/Gb77OzsDHfddRee+9zn4vLly3j961+PBx54wP3uM5/5DF73utfh5OQEz3ve8/CDP/iD2M8l7HgUsYnAC0AXqqse2FhgqlErLM6+Qj48aDN0UBZP9olfjQ5bgcddKNxQN+iD6ZwBT9bj+2uX6DkGuYUwXeBmdVXiUfXdzhCY7HfJ+j6534E2Z90IF94FwPCi5TYwP64n6pllTc9L211jOdfDv8DphaNgVSeFnDW3SbQok3unDWkxS9RJsdJn+jynIKprpXmm88erRSQhYWYFARMI3vVZrUKFoGn+OEKsWeDUDuqDbcjt/JtRmMoPoimCk+JL6r8WyN4hFTn79UHKSUEFp+Om4bhuXlBYcs2wSsrfhGcSHXFP60vEhvQ8OYB0fOQ647Nsd1SyfUGPonGSInHhaO0VoOWiKk86LqOvgWDuigmZsCreeaREWcMwIXBnUu5sb2A+gY27zK/WBWRkTAqBbt1OjTi0QRFCGk82Hozg2IYa8/2IJ+Ik1blmTWbXR2toEXpi1Ue7nCtPqrLwyU9+Ej/7sz+Ll770pe7zH/iBH8Cv/dqv4Zd/+Zfx4Q9/GH/2Z3+Gb/7mb7bvx3HE6173Omy3W3z0ox/Fe97zHrz73e/GW9/61sffiOwnkZsUY3OIA+5wNK24td7aiIXGIpuVQKFv6j/je7e+Z2CyUbrbzTDOJ4901ogUqOJiVq3wRtf6CVVcqN5MfxvrvoZNirXK/aVDVC103Yicv3Yu3LPpu6vs2KAT6nrKY6qhazl5YhkhRXzgqXXNyXxqIaZQ78MhXbMHOY2VWjdtn/h36mNfLi3hFIfrubh/+7CgJjUlMLWzbUur1Or8VAt0JlzwPKmhiqSMN3NUeQWu7zy2ywVaxbNVCn2K6iAJemKJ5KH1WC7P7r2W580gMQvvv7c9oHHbKDqpJaDLQ1KNMNIx1YMUZFFrO4TYN5EZ5YvbXRTSZt9xl/vQSTe3tR18vSIIjTFQuDoUpZTTYVSDkTkUlMLa3vaFP9NIEuBwFIJTrmlPPLTXtVFHpFRMQrL1N3Nr8CKkIwterly5gje84Q145zvfiWc/+9n2+UMPPYSf//mfx0/8xE/ga77ma/Cyl70M73rXu/DRj34UH//4xwEAv/mbv4k//uM/xi/8wi/gy7/8y/F1X/d1+JEf+RG8/e1vx/acHOCzQpuS80UCTvNWQpMRkQQC1poOPOEi5SMAUGBthXn58AEOb9bQywiy1U2WrAW60JGGKtv6UXxXZhEsrd3TuHE5GFfLGmf/KIoU5IB01+jh1Vpx+reNV65Ih/qh1Sqy2zWbm1gwWXzTChnXx2S/AbYbVINGFBePtxr13bs8HARV6/3y2casMgBTYp5zUXlinT5rUnXzEBqjLhOBq9uN27lRgKoYbba2GXIeA3tvgd045NvXcSbOAq8L924ZRcDhjZzbps/j+ic+iiZO/83zT8dSx1MO5nztWv3dbu/gf3dPO0BkL4gN0tYo2C53QdDU2b4E9GQtzhxCQWvNKGLGB6DLSKh8hjRpd97ti8uF2ujDQhllmHF3svKhFr/yCeK034awbrcVCWxcZTZngGqQ0bybjF8M06RROv80uVeDZrmID+Jb+N8SEmoXE3orz6/KanU/WZsvSnrVSS933XUXXve61+HVr361+/zee+/Fbrdzn7/oRS/CF33RF+FjH/sYAOBjH/sYvvRLvxS33367XfPa174WDz/8MP7oj/5o9nmbzQYPP/yw++NENxjeaFoCkPqwJGTNytXuiHAH1IWom6BO4Dl4jF0BDKvzZsewN2+ec5Ynox4GGTbWsVrnu719b4dTov63TT3bWBiZa3tqlBb9W+E8ysvv7t34edUFohCmway6ObC7yHWbMjKKMuJ88fIMx4i2d50rO57JXfp86g/75XMqrg1HttT8CW37xtGHy829M35PfDiztK4rtUQBCZ3cVheE+c6bqBX9ftQS3qlCz86NQfAzv2/9nVNUk++HtZE4C4C925boZqJzPSdaQ40rysZihgczA0Hr+3GZGXP2CkCLOGlbtZ+k8DgioSgmzNXQMbMQQxvbND24tE9ptJobFg5L33M4oBII1S3SjkXe7/yYU6ipy5eQky9R3SovDfLAY2cuWHrnOpcmCmHK1X2gY7IrB/6ED8D9ypKcib9nw+6QqAHH6KE+e4JohPodu100JF3fbePyebKFmnJdfy5anhRl4b3vfS9+//d/H/fcc8/ku/vvvx+r1QrPetaz3Oe333477r//fruGFQX9Xr+bk3vuuQe33Xab/XnBC14AABUlENHQqFlpYEuDRZeNH9MOLSEAnZxM/fYMaarV2lo50h6slt49wjBuqymTzzQcH/mFRaF/hfRFFosSqZYLX3OCnlfuIQtxGNCy/iczVEOkHD9gcP8OiyUdStkIWK1FHBYLs74C+/TFGjGY9WhNNRUaK7TxTbYuHa0XYeFSTEhT61nCuayN7Xtl4pkgNnpdzZG/cPPMk8a0vxTCK26pyfsOEeHSiYX5xeMje8586OFQw/bWvr6GSc6zmRlLjZJ1tQhXqzp/GksYEGIcrytKo22cASHo2pwQV0VbW4O5IJzdMCxlTpCyGaSd1lYZZ00mBaDyCTSTo33hKyHG9drP8RhtzioJbk4BDItFWXvWdyEWKmLDz9Vxs/LaUdpNpbW5dD1ZurVSpCQ+m4PNea25+RY9ZyGGmpUUKHytEEqthWWzJ2afeZEzk1r7aN6b8JqOtA+pi45qNljIuB7+sYSeh/W6ukLkmVwrpow9hZ7KmgnHx1POGCMdQA2d1HBf7YO6JrucKzd8hO677z58//d/P37xF38RR0dHj/6DGyR33303HnroIftz3333lS+IeKi+Rpv8XLAEqJNc4TfOhqYMXTrIampU2oTmtGLV1GeYvpbvXzI4hkMTlxYgALNQJj5eJQmuCK4Mgaw9z8fgf7uDWDfJthS0jZE8N401koNSPANls55stsslXOa/QJwA9UlzZsVQQ7dMgUg19t9xFriNrPQN5JKIldjmxkEUQHuGHHqWTVJcQHpgW9uBSpzkegzWFi3I9RiXmvjFi4IZyxyd8DeCHz8W7YP0h6MmJkx3hm3HgprUnANNhk31XdMmDloXabszd4l1ReenjVN2tSnKbehdzPmVG16JKZ66lvQPKQF5KxkvG6sWOVd0T/NuLJfN4a5RIHWcQtRCZTSn9D3MKfkhGFxvh9mSop0YGWrIxrPlp0OU7JCpHrx6vbneGoUfKFkmVXROKAqw2fjvRGwfWi0nSI/Vi1GloTEojJNic064QYsFONOjczmKImoEYZ0bjFAmP08xU2PH8cFYtEAdSKGyvAvBFKOLzOD4TOUs3HAK6L333osHH3wQX/mVX2mfjeOIj3zkI/jpn/5pfOADH8B2u8XnPvc5hy488MADuOOOOwAAd9xxB373d3/X3VejJfSaVtbrNdZz1tQ4Iu03dmCGkeJ4yZdc3QzElNZ9RsN7TFOt7GkApSjLXFw7IBuMhu4QHBqH8rmyjiWneU6xlqNtOQucn2G7FSiV4DN6djo983Ad5NAcx5pDQH+mUCbB8g56bY0rzT7JvkMZO810N2m/bPrp6jV/sJvbZDC3kJVJ3sv70HvlXH349Fv3vbWF21Eg5zxGRKDmaWj85Rafru82leJfNTVvRDo9q1ZsGsXnLTdQn7E8y/pG4brabjemOWNSdAclMVZ85EqZt8tFzaqoFm+u46PtsWdp/Py+zjkHobe5PVIuhZfIRZQ3m3qdjEt1f+z9ugioMDsdipYVNWcbq0xx99aPIC4iVWYlxHCSuyQng5zzOCJdPS3jffVqPchDQNKcFCHOJrtSl04YpDCXuiMoFNSuTRFAdZGZ2yPX7IJZlaUsWVIJ6lb3SRhK/o7h+LjOu50Ucmpcf3ksxZ5s3bNrh/JzaJinrmHl3IRh8KWw9xotRGtX1qPVU9B+5+z2IFsrmsExjcibym3SeWtFqHRP03Lo1giZr6o0igKk81nb7KOCvAspj2maHydnJC0e1u4Bqbp57J3oOxa342yBvydTbgTn4GbgLHzt134tPvWpT+EP/uAP7M/LX/5yvOENb7B/L5dLfOhDH7LffPrTn8ZnPvMZ3HnnnQCAO++8E5/61Kfw4IMP2jUf/OAHceutt+LFL37x42pP68fWMLfymfd5m7uAQ79yqn5+RhZUIwWEsX4OYx9iAXAOcoqPrheJZULw4/RG0rbGvVI7XKG3sPbwnQs7ItKYIQsET08y8TVttGvU99jcE+KPRPbhbzXZTK758lV0c3fKBG0ADC22eQlaYuUhWS4NdXGICfMJ+P0LCVJhabNguCjZDMPeJNZU0ZP+NNK6xzTrpJGw1OpVl4uz4khpCxFY1gJUrVgkhT6Hw9dsbbCLIDg/u/2GoW+dLzQWUUqO6zhQx8gFQ2hcSlXhShQPr21Qd8ViUbMz6hzid69tUUWBi4SxG0hdJ+SqszBbGkvvNovWf0NWdO8gpJH7ysXWyjv17Q3Nu7B9iNd3mtmf9P1AEQbvwnEZapu5ZZECamW3c5LGwBkkHK7d7E8HScnEbbF2mGuA5/N8QSeuGCk3pi9zvd8csjBBf/SdUX8vGll4hsoNRxZuueUWvOQlL3GfXbp0Cc997nPt8+/6ru/CW97yFjznOc/Brbfeiu/7vu/DnXfeia/6qq8CALzmNa/Bi1/8Ynzbt30bfvzHfxz3338/fuiHfgh33XXXPHpwjpTFRZkG0SgQjdgisoMv1kOsJeyppFSJeyFiaorLfZVIE5RVrQQ/tb5S/b/9kDZt/n8D+U76k5MnTqWMuKgQf7HuQj1cgHK/LSWWmmRnDLPJfMzyVi4HozVGlpI+qoWKsbGoUsmElzICmn61G4BaOe2in722KgFWCEctpRz8b7TtSaHnBSWfqbkBXK55hXZzQggLqbdQLG39PixaSJfGivoE7rcgAUHItXERgOVSSpOHUlJ5n/1cjkNFr+Z87VEK0KiSrMmuZN7G1WCM+xbqtaQ+auFtt568Jv54i9gQ5KGO0wjERUXsTHlq11JVBplk6FC9PLUG3YFmvvuIvPfvONN8V8MhLBZl3qdU18c4s19Ie5X/Y2iNvq85gmsMwF7m6zKUrJLc1qUfaw33LC6chbsuhIDEiqeMu+03ioIIMhTmDvMQkZNY8ZoIKcl8TbR/KQoRatZUpNG5J+358P12Yc+kFOY0ipEQi8tOlSYZI5v/c4nmZIz14LfEWbqH6bg0JcndezHXG+3tIETygiRkuOStT/QeFy1PCavjJ3/yJ/EN3/ANeP3rX4+v/uqvxh133IF/9+/+nX0/DAPe9773YRgG3HnnnfjWb/1WfPu3fzve9ra3Pf6HMQknxGLtiLikTEqOI59mXK+L3/r4qG5YOZfPSRvV+HefKIYOea7a14j5RycHx4ywS0FJbu5mARbTrWQqFkn1bFEHumkqo17dCkJwnPAvmkUVxHLM+30Nl2LS23JRM6tJuxyqUwat3lCtg9gQHFuSmlpXjI5EsrJnRImLiFHIXdM6BFbfYLUshCnNWy99V5g8kGVY3uvS1VUwslarZEpbuU3275a8pvc/KnNQ4+x17tXIhtHdL1ySGgWLReGTLMmXryx0qYNi1q4QveKtt9h8DEdE/ssZE6txtarrIFJpZ3HflPtSDRXhWYTVypMjdd0BZfx4TJZUipo5OymXw1N5JcoZ0vso6qHvmZAG9lvrOBraqKG0gepJMDI2Q/QMuk8QStaSfCskrv3kmjQLb62zEmSHXCjlpueqThLiERZLxKN1XQfMbVh4tDIcFZJzPD6qKJ2Mubs3c26IK6Nr0CXY0j7L+7CMq4BbM1guy/N1L9b5slpa1VtW4NtMllwd1OZ24r1F93CaL4z86JgO1YDoGRwfXS4kbdXv/M7vuP8fHR3h7W9/O97+9rcf/M0LX/hC/Pqv//r1P3wUiwaokzuGsmba8DCgHkaB4q+t/K36HxOs1gBQDln6vVnRrcbKYYszB4PjCzyK5Jyr5dAiBGpFEXnKlBv9s99Xi0StiRiArR5C2f12NmRQQ8SY2MhjmrQGALl7aAy4DgBCrKWT+fN2PBS29IMh7aEqnTMuiTxK7YHW+la+RYoIUZGHjAzZZAlhqfkBxDKXw8By/NuzzveDqm/ZtZXmRs0qmGo+AOWUHPCxcuplKNpzzibIIZUhBuRN4cGY8hrpIG+VHuNN1LHMrFTw+qExCbFJrdtYkWGxqOS7cazzwPgZg82zTGF7pgCrlQlMS7gTwS5gAEIzD3lchwEYZ8LxdNyUtyN+8sD3p/0ga7tm2mH/bmu8AF4ZBgry0SqUzT35fcbV0rk3JvMxUVu1nYAP49b70j6Waa2p4mXcLQrjtHZyaKm+w90OGUu3XuTm09BuHR8Ayvtyu6PuJUSgtHngCKWEAsW6P2r9lYM5QrqYPCXIwoUKW5+ixddJQ/5S8ikXP7TCnxVmdpY9W7tiVbhDjX3U8n8XoqSbSc7eZ8z3nvPN2TUz3ymxyCDbeo0elGp1TSzcEHx6Wf6tuklapKFJisS+R7vHDPfBiHYzTPCSHMvDrGyd2T1b9IUt1EZ89UHKpNn83izCGM1H7EvolnkRjo6A5h6BCKyhaV84Pp4+b0Z8zoLRxgSxQMFhtYIlAJs7NNhn2/p+G5++s8KMxEgb/BAPKiXSSWtzcW9ktO4zq1Mwx51o4ezm82rN0ntlxYV5BE2b1G2kiAhzjMzCNlRlUSMqdH4sF5TfYlqCuV2rFn63mFq81m7Nm6HPUWmimlyED69x4oZwRJUd0PIeOHVxTYIlSi775hVFjRUNaMfQiR7KyvOQ9+oURhoT/Y0qDqHlaQwRYb12JcGNS9Qipor4sNuInxWCf0e8ZgOldCcjBahK8oVLT8r09BdXVU//b4uA/cVFm7UDsNXoiYRV/nFgoqroRkEJSTgMcLamAOA2hZkv/ebcPLvNiAhl/kuVvqmvX/pnPtsDB8Wh9qhipX/s8un1ppy0G02MldfhPg/VWhBrcoK+MMIx117duCS6oRalIqveOCPlQJ4Qq/RRux3aDck3JUvGReFGTCzcXDkA/BuVVA86PfQzWcyT9073hb63OWVClbhA2eu47fs9tCjWxBV1zqY62YyHOoc4qsYdGI1rSRElm386BxoXjiOU8jxrCrEZvMzRGQyTiyKY9/uSkZNcJ5bcSBFC19nkEQ2bV/ScSJB3ix7xbyHvNTaGhswPF17IaErLWWjaaJyKuVo67dxRhCFN+2oH/QxKmiWSxLkwFjMZYtWtyC5eaV/ebCbutxp9MT/H83YrvB3P7zmX7M2hnCHauIZWcbsoeaxuhkf7c8Fy8ysLajWIcP4B9nNOsscR0UmrxdnXYlWaBr+tYUuPJhOffQwIUfMwyOHVRgOUhzYLJNVDdK7bK6rEF4L5qc0C5HsNAyxfgm4esxDhzCJ2MHUGQ5B5v5+Wm9Vr1ZLX2+gmYVZI3dgN8VAFIzb+RzQbVPs4tUTErxmWxbcL2pTcphWpbY1ikHf72cOaY8QtpS35yB91bnB0jbxrzf6nfUibjbStcQmoxKEiCkIAm1hhwPwGSe/M7iXtAiBoAylXq5Iu20iPcpDNvgchntkmTb7vyaVtEaYWBVtK3gmapzmV0Lnq6mrcHHpIyFrW0MegLsfjY2gmRc01YYewch6oLyUx1Kq2URUYamurQCHXuiue39Ac9rymHdKUDitsOddU7rt9VU55LDO1kwnLrq1e4XG/nVHEtSjcJENo1vokUtek3UvGUVDEpXHKdJ3PoUWsPJRxiNUNpC4QzbZrv6v9tERUFFXE76PLY5ObX1nQmF7V1s9qMpJ89Wq9jkO0AJ/+U9M9y2GeNAVwy3ngDbyJJMipxLdPNlONp+YoAvUjzlnPzEfQuGJe/AZP7huffHmWhd+5ttbvqzVD/r85UaWGLfPgN1X27To2OjCB6tndY1UF3fNEgSAC3cSSdGNVrTItzY2o6Z53cuinqqDJ9+YjPQeCdwltmKeg6W4bxVMPNGvXxFpt+qNw6zAUPkzKkvMgk+Lk+SkAyljvyhwrRMzB/uZ2cUphQJVmGXdWNti61vejcnoGpHo9h+KZX5vHQWPy5UC2SB32je/rQWek25mDRg/9ct8ZTsHZplqQDR+E0axCWB3r+xROU97tXfhyTXIVKpdkR0pwTsBu7/KU1K+y9V8TV6WHH6nvpEkTr+/GJWdTX72sC+bm2H3UNSXtC0OsqJ4qc4baZT8XGsvexHgHtVaE2z/bFMm0Hicpsgm50L0pn22KMi7Km76Pyb7a7IMTpC5IeKRGQkyQQL+f6rzIo+QTmXGJPqnSkYWnqTSHXqZNEnNWV/s7oG5IXA89EVFL/56z2HjzaDITAgKfrpbnH3x6H4byUprGxLdyiAjH9wEdIgS7W4w74MeCNyA+tNm3LG4XCz9s3ThExnL9M3Z1hWUnrgpql/PxH7JoQe9Wr9HkT2pJ5VpLQ61O3UjOFVLCALjoGmu/FseZNO18n6MqGIy4KErmiITtuydmec3Dn5p56DdUhrZnXWKqqLXWJiuXbIHzvFAXHPmlXYQS90EORHvmHBmY+ukOlpm156No5H5zhE8+XMa6ricoYM6T+WicCEYez8m5MsnlADiFx/aU2PBl5srR8/WpJn4qTZ3hBBEi57gbZOhY1kjuJ1Wq1SgKW9+EmrWuXJ1/PFeV35HHEeCEWNIHc7XURnsXQwxO8dD7lu9mOCx8f+ag8f9neBdPqnRl4WksepA1h1566BH7t2ZkM7grUShOahQOtXr0MNLNoYXBVNpKkdSWdLZBvnZKbWyg3IMcgewtXG1PqKTN3CgEeb8vVvbswRpqP8VKsTDTQ0TLuQXGPlQNe7LDIkyfTWMY2PKgvpviQqzmGjvdXKPuGhq3dLaxDb0cvk3RKW0rox2yGboN1+BhRnjGsvmRhThJnNOOVQPflv4vJ75e24y1NsR67ZGVydiHqpjQBtnOp7nS3HzwluyJuwo/8/dkbRY4OLtNmnMvmK+YkBMLsx0peoGHiQ9q5QuxxaoHoiofQg5ml5sebqbsqdICOP5R0FTa+kxWoA4pirrGEu0TCqHLO0+nZ/O/lTncFh3jA9Xa4KxrKro04Rz4g9AdzrQ/eALyYcXGns+KkmYxTaNVXNX56pCaVNeSQ0rHsRIxLdNtBrY7WCp9wEiYjuQZteJrHZ8JuVvndCs8NnS9ITNMar5I6QTHZ4AYs74cOlZ/vSWrpdEfUI1Wr5PZQYDA9ECwf8+RKMUCXC4QTo7rs1um/iHOAreXn8Mbo+s6Wfnt7+Q5tuHKcyx961ySFEYYQpwuTDmE0tlmooiZMErQWKlmDfOhpo/WBU4Wc02IRe1NdPAAlbOwWNQ8CDx2fO9BY8x9UZuSGW/plAw7AJnvQRuRZ8kHO9QdwXG/O8jDyLs9WWON4tmKfV/mAiNEkyRWrbInSg/Hx7sxpAPAFaOyJD+0AQMVwVAkTdEL6Q9UGTE3ULUiW4tUx9opl+JWAiApoGv/XMZAOiBrDYFi1fr6H/WwskMKqL53N1aeZGg1NXRsmrFVH35O2fI/WJ8HypuxJJIgkSMdH4DnbbMnON895aiwnBLqWlLXrPKtpH9JSsA7ZUUP6xBq+/T9ME+FkUhpJ+e4MOH5RWhrLYlO68KUQzJ82v06t5Vv/T7jCI5xmL7Lp4ro+AyTzx9lIdIhqROXK8dZAhkN06nREEHdBM2m5co+A+dOuHNhZz5s9f/AQR+cb3Mb4kSbJfsJdUGTsmT3oQPINlPmYMw9vz34G74Ck8PCpGCXWPHMehbWNVuNet9ZFwNfMzs40caODyB7t4wucH8UbmffuJH8GgtUrCKzdlo4Wa293dQNMUGQ2v9rHxu4/tHiwTWBmBHw2IJln237u2EgH3fyPm/5zLHUh8HB07OSaOOWOhqawMgUU52LrcWr/Sar0sZzv3MRBHWuE+oB1MiOelOHFClvRbNRWpvpeh1DW+vNd4GUuFk4Xp8lSk1YLixhlvUPmBos2aNfRtLT8EdS1OpDigFUFNdcI2Oyd5Nwe+z/htQ1kRZ0bwA2r2q2R3LJNMaQutI4uZaloB/HosxojglS/q2ktLahzXCZpgrBeWjsxA3BSs1FowqAZXC83j8XLTc9HbSEIAmrXEhWJpraWDfqnIE8+skmsOHkcGyt/5x81tMG6tXkH/a7WHgPGEdjrlfSUqi3d5aghy4LEW/mwNPn5MaSVKWgJQzpRqh+TvPNnj8j/SKkawllcFYHK2FNzn6FqCdWintgxqSQVPtM7r/2ScPwlCC5XMAS87T9CRkuzW5jwafTU8TLl2t7lEjHG1jOcIWhWth/TgGM5EZh1EILQjVEuNl3kzOyQOB5DgrX+/PBkEebv6oYKTHSQcbtrWRNVKKhpKAexzpNGWWSsczbraQHj/479R23zPr2wNL1Ku+0KmXBoyA5FWTMoVSjZUF0PB1dF8QtcSGXrDQrEnZ2ZvcJMRSCo5EGt75fes9xRMhhWgjJ7k0Hpc4Huy7Z3A8zB1zlyOytTU4hOIRENX3UhHWOoMj72IbGqFGgJvMlZwAydzXcXIvEjSPCmAwBQ07AMFOlNhOPBYAV/9JHn4fq6lpqsurae0oZyLtzM78+KZLlz/Xe44Ll8wdZAOqGmGijYMuHfZbjWLVnwH+3b8LpiIzWXuuevd3Of0+RFgw5Pmpoz2wIXOULTEQUjIPJbNrsaeegGgBZEu0ByP58lZaPocV1qL2WPKdFYSiiYlKhT9tCpX35edaOEBFXy3IInm2mz2BUoyW4tX0mJnze72rGQE5qxRD6AfRnNsRPxxKoSoL2WRGtluDV9qF9js1hsZTb33MhJw1VI5eHg8Gt3/sa7x4Hb53PidyjVqqcKoOuGqr6lBXGlnsolGzCh77e5/Sscj0sdFLceIkiTWbGBoAjCh60PBvEpiYXCs7yd+9DEjzlzcb3gZX3BgnhzzXiod1/nCSaK2yR6+c6vtw/srDnMrU6N8RuHmEp/w7+33GYfq8KXqrVWG1PGMdZrkjL7ziUl8Y9p21L2z6gKkPEs+lyWD5/lAXdaIbBFqo7YHRiK3y+WCKs1+bLNNJNrAQc+3u1Iv/0wh1U9fnRk6vagyhVP3dcr6uLgSb+JGaeuRTs+5W2Wf+o6h1mFob6n82XSn69SY6AEOp9tf+U695p9ZB8D6QUqB/T6jBI/gfjiQA1e5+OWxwkX3yFxl3/9Lp2LORv5Seoj9pqOACuMqfxHuwDDZtrlJImw6S9U2Vt21yKfuz5HjpXqM1O+dI+CmcirFaS3TJ4vkWTnCZp+edY55mNKx+87XPlN1rLI0i6YFcLgOZB0HUiCpbWKgmLZe2vviMZp7BYVn5AuQmtRcl9UR9QeRB6baDaDkRwBGB1SqAuISUhqqtIx4C4Bfw+4tHaXCOunzxmpPjZ3GsPX6AoJAvmugSrd1DrWCSE5aq6sPSdr+p1/I50n2lddDp/i3IktUy0jTO1aOy3uge0c3NZ3UNlbUb3DF7zk1oU5qqgWjnyt0smFUqukCBjbutGFbzGFeIIj+1etFwBcUA8Jt5Xo6DH9drvjRrxofMpNpUpu8zKTa8sOGZ6phLD8n+b4G3cP1D9oLxptdfkbOxcB/01Wqz6ts0vp4t1GCoRTLRug4B1Y1ALudH6fRw2uQ1a61vvMwxlgTaKilmvYwlb5LBQi32m/hoiIwepiyzQQlYy9moNVWXLcygMyowDbfLJvTO7TsimlbTGY0Px4skf+opGVEVDN9MloT1EwpJDLqzXxddKB3KbZKow8ZeFKBfq5tim2vbIlE/yVb9IVTmU9tj81fmnVqwdYA2RTjc/OcyK1UtMdEIz4tG6znsheZlll/yc41wDZexW4GyPIUhWxEbhci4jeYYWlOJ5mve7aahvTpUsyO+ZCWmqpBMXJxyti1uECg7VjKnVug6y9vJ+j3S2sXa1OQIqSY8U09XSKw/kPgri5kIazXiw+UkKYd5ti+JKBoxJu28dyFDoXCeMiMTgSJjtIRxPTsrBGfw6K+G5xVjQeWM5FlI2JdTWI70zy7mx3dr1qijw/moKewjiSm2UN+ZkaJtsTyElW+dP0mq+XtF3pE0WjvrR+XoowuhJkABcP2fhwlpb5aZXp/I4UtlgH7ucx+ojdptcTgCIoSxw2azPC6ihUHN+M/0vE47sGeWgzgtyh7BftIVraUNKZ5uq6Tmugofe9TPbZNt2TsYr1Y3rPLivhabNn0xjmkqxrQqBZhf+5cMXq4I0gaOR7P6V7d3Ahg3Zyv1eyYpCtsJWxpY3EYZid/tSRGqZCdYVSySGyQaNTQnNVMvYKVitb17GDsMwyb/gfiN+eLtXyBafXzbfRNeyO0MUTmW1o5k/NDbp9LTeI9XMlCEGpM3GJ4DKUv5Y27otRadKEiYfYmr9aAisxlnYzShLuRZo0+vLmqEx0nUhh1Fx7YkiRPB1PttMETRxM6qiW9tIt1c+RU51SNOI3JZMz6lwQhT90GfxXqKXsoIvbqVMFv9kDmjSJO1j8/lknsv71/1HoX2kXDhZ7vf1d5rxcsIzED5R1mvT6A9bfachTAwJl3hMuF95RC3RrsaEzAMr1qcGFIe6EhfBuSaGoSb0asfXDWQ2YrEhVInXJKXOZldIl4Ny0yMLAEFXTERTohdZwUhj5TOM9d8udEetPhKXSOaQtIe++2562APwaIHCZ3qLQ9EV7I4gSxCAbKCHy7EmrRsxIQtSm0iRcNa/KjKZxhfwCAlw8NnlNrnel/3UjjBlF9fv0bwjvVYVJyOvJneIsIuhrS0A0Aar91JXkUHrokCIGypriW/QnJtLkQ14Epxep+1OY41jJ86CJRTLTD5sFD9KU15cRhx5kKdj2bQtDLEy923dJFQFpl4flotqTe62k6gPO0AF+dKohTm+iLoP3JzisbebEhI413/U9agH1ORAUZi/US5NWWlQK9+WqvSaEt6OLVD3EeWH8OE3k6RrIqwUyL2Tcm0aC3ryPOn7xLffrgl9DislnEOm4c9M59pM0Sf5vHUP1oRdlQtjCo6NUZrueYN346XTs2lkin3ZrDXdg4SnUveknX+3wARtfVKl51l4+opLfrNcGFTOm/7Ejx8D4pGEVjIslvMEEoyXjieT2l+gUClZmbzpBfrD7eXPs0/CFFarKXzJbdTv3eKJj+qbc/XsLZyU+sXpm/X5WRZjHIq/kvkKwjXQRRnXa79RU/vi0drGyn3P42AJXDRZkWx+u20Ts0/cFIVWh7K5xcuXyvu9dGJ9YUvOkiEp3N0SpJZL525Ry8faI6WrS3z+wrXF+pSz40vo+7FLBOYNR+viH5a2m89+Dv1RWDfUhFpZSWPUhnh8PFFYQwyIx0eGLClEzwedg4eXJexNXSJhuSrvWgmqIXglPUhFRK1+yJwU7UOTzySu12UN0howPo3cI56clLZfvmTPicdHBenRuci/V5eFcoOYiyFj4LIcMklPlcPFAkHmTlgs67i0fBp635rjJAxDeYZyLTT3iRomlGba++5rv9x7Uy4G3d8+o3ds+57NgSOvoBnBml0XqzpeKi0xkrgITrkk8eGrNEZDqcth471aId5yi/E7DKWheRePjyo/ge5XvmzcF+wO3U3J5WGguXReaPuNlnyD/lyw3PTKgpGbZDG7iTtJ+hLcpl4tLNG+zUpqrYhc/ahziZMUPtVDnJ8zNNq5EuLs0CQtu2X8T3y8mSyN7A77sjhjjQfXjYPIVKw8GSlpMqAeqVC/rFm8ZDGn7W4aXqVQqioutHk4GJLHu4GyzRpxSqAQ5/SwVktIlRplYSuiFOIkkU95BPVvkNwD2hZRFINyRIKS52L1U2v7dTzE9TGNQPElwd24slWmboWUy/vWd6Wk1PZQ4rnEVh0d4s7d0XAp5op06Zx084E5N7nkPnA+85y90su/AUhxbtAvUiLSdlc5Ii2qpOOrCpsq0oIkWI0KnW+NaHgolF+iiFHjz3YpjUUpzinXVPEyr5zSodfo2goydkNNXOVcNe06VqWE50zOxtdhwjC/S7bUjYzIwm4IDbHl96T7ByMvtm7a9iRRlJhYTKgakVEdX8J4Rcn6b2TucZTCbYRghehrbrDLp+U1aB90DHU4da1ouxY1sVS5lM6ILgflplcWAFSoabF02rbX3D1hjDf+vD0ANbbXzglp65qy1bdpAQzRa+Vkadhz9TkzkPYh4XYrOckOP3W58Gah6XvZN9puEq5vAnkzJ0H7zLD9Aa3d+Zl5XNgi1cOfn6l+xjacz0hsI/Uh13A5qYBn7gXdVPkeTWifS8rUtlX/L/5WV7iHYVciGer4zI5pAzu7OaGuh4YP0FptnPfAbfY8HjKOLcqk6Y8dIVPfI0iRChQG2RLLQO9hzo1AY6btsHnEfvXcZAA8JKlRLKV95Ts+sKPNIzdm4poD5N2zW0r6wpwEO5CvCd+DlQR+to6d/i0uMAAuYqH93exeogr/DAJan1VJzPZ//ppDcIGq/LCbgT7XvgOgQmNesck0dvYM7YNez+RcyS1jz4x1HtV7NvyBPBNKDRzeB0OYfG88kJnETY8pFPNGyzMUWbj5CY4pI4cM8y/G6pt2tRU4z4IS2dT/t/Mscu/XG8sha9bfjL8/j0AskQF14y7PSteuIapf9TzNtpnQBpu3zwsRhRCofmZaNEowazecXLV8vla/Y/4cb4B2TZOjwvk60wjERR2rybNpQxVkoCVjFStP2zlMNkJrbzsWTXKosAxCylOmdlMjghJyKbmu5UI44pmOgSkXwr6PhJJEIsqqEkUuqJww/94NHZlaxj5hULNrCNtfqxeaspprFsIQArISx3IGUMiL5g8OJRlUG98+eV6IZQz3+/mDuCFfGsm3hdizP4Dcv2euzak8V+d3HkcEUApuXYt5V9+RuTpk3Un1RHcQ6XpPuZCadR9oiLg2zqjzoSqZUtlW95jUrJcQka5crRwD5T+w6HMyHXy6R9gaaPYDW4s0VxtyJc+FaugQH4Paa3tZCI5QOG3rDKm4DGwdn6atabsriupYIpRyiEDaln0iBmDP9/SHvEvQZCjieC5xu2balTHX3wZps82XizmBb0QGxqcig+PnBbIw8aHq55cu1f807gOOL4+Xjj1sLzHUdl+FDc/xe6kfcy4ZjPmu28nakiIZWtP45Ba+Jqu6hfk1Fr6Fnw26trY1Y6VtneNH6Od8MNEzDYIlJrIednG1rPfRe8fGUmt985qfoeWITOBsGi+93zhaLQ6DaRs3j8Km1X0VJ8iG1RSR/sbVUvzf8+GMmuqW+RdtqufWP20KDuc5WCx8SF37HnKWkLRoft7Z99hKLqRDhYs1v0Pg+dDUR4gnJy40UceMkQKbfzofYqhWtSMyZrs+ct4AHX99t8Qf0HwNZsVuNvU58l1ZIyvfb+mT5aoYSjix9WGI9L4awiONYaCcEGG5QCCug6tA2eTeCMsF4q23+vEnDgfnpZiIJlRrOFTld5ITQefgMNTUzPR9+U+zbtrPUNduKxOSNfOL6heobi/heCyavUhdaLHMBZvbIUxIk6EZT553Dt1t3LbtPtS6Xet3EZ2z8Ohy0ysLPrFL9H7ig2E3NXyvMtIbNrDmImCNnxd4W+Bl9Fa18QSWxQ0x8cFJe+sNvOab1dfnHkIWPceih+KXVRb2rLUMoK0FMJHGNeKS/TT5FaoPVaMban8Li37pM2jmZFwA44jIM7WvvImYH1+HSt0M7fiF6nO28WKrmfkBqsiw9dS+9xk2e9ZDmtuih7q6D/RZPEbuJs38kXHNrCQp6gLd/AnOZuXP8iz42gj6zEnuC1LyCslRFE7aQKuVL8jLdlssTnIhaDy9HZCjny/2TIamSbnMYw3Tm2TzJDRG+S3GkQix5m0AKulSiG02P5mPpJB8olwFwwDEwpWYrq3k/6Yx1SgY5SnEkxOKhqntLq8plFTRSr7VhG6NYWDvUN9tCNBCV752Ql3vkxTPjfFhydBASgm7/KidVYmIlptlyruR5EpcqEl/G6Jbn/aMEIjfFQyZKzlAMhDjlMtD66LdR6uStZwxGBqehAopQnOITJd5uemVBZf/wKxZtZT9Bkv/aVjSsR6wTAJq/d08iRtIXJn15vukJDtooLXQKg62oXuNeJbDwFCs1rTIJbNfaBeI3kv9s0x8a9s+044234QbhwMWi9Y4sCQ1ZCEpE9+g0dqAyuqnzxx83fICWBSap7GakA6ZA8EbXWvxA+Bc+XbgnG187Y3c+l5J2SM+iBujJoc9t1391UYWMz6Ad0dkLcetbpk5y09j6XfTGgZ5u6vKXaOMTZTXJtGOKuY+P8NUybXkX4Kg2EFFa0pRg9Z/bfdo3w2TBGVtuEM8NTA1udnUJ+/SeMuarHNfFXpVYj1sD8pXkDUEOYTJ2Oeci8Wv77pJn2x5I8bRJwATvkDebufRIm0HKx7N2PF4Gpx/kCNBB/9uN03OJm08WEws17TyOTV8AYX8kxByLeqmGfMZmVeyQ11P5CKsaf2peq65OTPcGuzIwqPKTa8smMUpvq+amjkgLAkG14mmm6sc7grJtgxc3jzDel3h4RZW50M+RrQHMXIqyAJtqlrMaZ6PoP8OUzcEP1ejH2gcIH2xdtmt2FUhGjotSseWJqhPw7GMOd20RUPTJhaGKWMMWa88s7qFZakf9mcu78RMCJgyvvNuX+6nFfA0NbdrU3FDlDS2C5/xMpf5w24Ig+wZGk2jcx84pUhdDGPN91DHc1WvkbloORxyCQUMMwcQj7uGheoGzKmOW5Kl/uENOKyWzftRt090xLxwclxcBrqWxGJkZKH8htALfX/6O9cWsWApLK5a3RWNUaY/pwguHffuIr6mhidz2fCFj0QK0Sz3qOsdqJEOapFrdMR6Zu5NyNG5WrFBUmk3nCXL4KjvjyvhEqoSVitguax5M1pjQp+r4xNCdZWEijRpxFDNYipuGuachGjzAOrS0rGl6peG8CTaD8RlpftoXElKaPrO9q2cqpKn7yTRAW7PmUEGWBS1IuWV54Jmq1R0yRRSdTnORSs9ifJMrTp50ysLLYScrl0zTTNfO6UDmq3hWLPNjaNkayPWtjHBC3xpENqcn5H80fls4xnuQJn4212NLQZtNuyvb5QHe6YjnNFimWH55u2uHJhLPiRDhX6JbGVRE4d4FCH4MEZgwiNIBFM7DT6ShU6WqQnBpY64yP1vkAY7ZJSzoe4D7lMs+RTypmQRnKSBlf7Ze5ffusJLTXramvApe3eDPk+UAlY4qtI1JYTVaygTIyBFm0IJR2WLW9+RHsg6d8RX7yp5att4njOBLFZio2UzlDFJMnfMWttsnVvLIiNIJpk4qU+VgFkV9Hy2QZasks4dxOsil/LZtl5blxGq8uvQhhALmqIZDrmdWqEzlPmRNpT8SFGtBknIO0qFrI9QxaktHZ8L6qWkyny2qd8nQTR0j6D0484NoRKDZV+0PhN5ksXuJagdr00LOeVwZe1DknknEVOWnjzEinwoktcqrrSmSySJEGl13NpQas0UmjRhnEcVJwhLqkgUi9X80LWQU1WA2DVDqextjJIoLTMcjS5Vbn5lAYDmO7cCTSqkxQPwBzJvAhRTXTe4UA9zDhVqfX/yO0s1zLCm/pYJcCQHiWyQRT0hOE6JWPZb9S8qyZH7zBuXWHIuZNApXPMoA0BKjlqfjmlOSgjDkvRs29Da75kPsVi4sEB79llz8DfwtyVYkvDRc6HORa3z0ELlXNIY0M21CeOU8VNOhhZnsvs9mvA1ZAXl7W7KzWhcF+HkuIwdIy0szJng96vWpB4ax8eHi6JB30P0/A1VHBs/PVuuE3cGo2cxOkSmoAiNS2yxLFB+40N3fnytJzEnAx0gkrtiuHxJ7rGzZ1RXD40Ru31mc5CI8uUON1ovehlzGrTgFyvLWfeKpu8h1ARbdC0wVdRbpKWF6dXV6bJmoipDchEUeTJFzdyGaYIaWuhkqlk6NUW5W0OK1jTJldTKnySecoZEnPJJ5Nl+z6VMoeyuDcHfD0VxMjT3IqRncHwai1inabMxchcAQC0KYCbsLhtphjV0E5qMDoLWrw+QJ21Tc/5TShjURgOQT9/JMEyRBdAG3RzwJWmOWM2Tg3VGGXgsoiQs9U/OWczapsbfH2Jw4U6JLBbXpjT632uoYiNtquE5qRu0vDdOcpVq/Qgr5KXWbTsmBDMzAlHvTy4oAOn0dLZ9fOjbhiz31flVlZaioFrs+gHJ105N4UI+EKM+NOGc1C+znOfmb4PSWfigxeMv/XVzKJoWcmKEqkXMUBVPZ1XKutFDs7gVS5XLeJkim4IW0KL4+mZ9s+8+nZ6Z68YpUYeUb8CKNLFFX9cwHb4tJ6BRQoIQF+2gZeWbFTE94FruBa+LUFn9s/kYeNxVERk0usIr+G3+DkPPmNcz1qRVdn/5W5ULh4Qp4qZjlCWzpZJ3x3HqzgUm632ub06pZLSYr1fOwlzxuM5ZeFS56ZWF8wqEzG6IBmE1FfRmLBUmKbrY90PCCWToHk4ZUZhMiVmtm0FFSEdNg2xRTlj9gMDLM9ChXZAPbDIHxpD87nOJeCysbUJuOlyfYu67lihYc1U06AlZD5MxVuKduBH4MLHfWPsPcwJ0k3QyIXBRkZrYKBBO4fRwq5M42NzgpFemZM1JqHUd0BZMku+r+8gjRO3ccG6IOaLelmB4JoqB3pc+R5XjGdeYG482kyEwUXZcEp9c8knklKsrASgFlJo2uTnRsOvtMEuZFMbR+8BpDHPKPpIqpzp26vaaI+uZG2brDzKqhGlwPbt0BK2YJXbS/qSuOVOo21odPE9V0VP3UWoOVr03zynAJ5VTLlBLLGYeEIdXEicrn23KOCivQ/uepmXhncxlrdV7qkLSGliHUD1d64SGdTksN72y0GaAY4LYJDc/iy74nITxm/2BAjiXhZFkVHsmqMz5NZvNz/IfLJvrGUZT4QUU4+zman1bLibxynG1LHnp2+Ivet9hMGvbiE/A+dB5ztWijB5idnCu3keJo4uG2LVaGtO/5M5vYqnJDWH5LTiaxV1PriJUiNbqEii0P9cvsiStlK72DcWCCZJXX9tm8ClttIEtwTkuCxolqLUYkyAVy6VB94FqA3AOBPe39k3rbLBrjcbRvVNBIMJ6bWia1RZRJYytMBvmXJUiOhyt7+38CZRB1AaqsSL1Y3UztLyZUPKSMMFRcyqYKElT83jQuOr613j9eOmkzg/OLQEciDaSsZK6MXY9uYdKfZQZgq7MKRcaLKRKu17Jt03opKYUNxIstaf8TYidElKZ80BkPnuuunPYkrd2L23/s3ZEyklBe511T+ee9l/dW4o+KCF4Wcil2j6NWglC9J4gC7zOj4+9e0bXuL67GeMqNm7eNprE3skFSSc4kvzP//k/8a3f+q147nOfi+PjY3zpl34pfu/3fs++zznjrW99K77gC74Ax8fHePWrX43/8l/+i7vHZz/7WbzhDW/Arbfeimc961n4ru/6Lly5cuXxN6bd4Dg9KWvMbaW0ZkPzC9dbi3mzmWQBcyQaLXvL1px9mWCuDt04iSDk+9LAm6zAuE7mSQ519fXOEdF4A9LYeSOCtfenzd2jCdIPy26pqVx3dcPPuWrxmUrPhkLcS5L5zkLPuD/iojFLuxkf66tKovERlKjUqtiX8LM2Jn0yho3LRrPZjakSY+Xgy2NJYcvKB/dtGp8+p6TMjHNOgiBJzo+r1+wwmIeJKxs/X70mim4zr/kRzYafW8KnzucDybgs1FHQo5opT10ZOxsjIzi21h7g1wNFbtj9yK0TYhCCpFjNO4G5ybWWT8+M46EHoj6H3Rp5symkY/GTq/XO+QgmnA9FYTZUpjxlZ4TMuddszTSEQux27nqX+phdEmebiho4NwQpJewG2O99OOdub2HLAGz87J6tQuvcpGPd67blnaqSyBwUW5eyd7BLx7JbEjE5n505/pCGZ06QBZrr6ZFHvBtV99vNps63RsGzPZ8jpaQPIYpL66L4CgC6G0Lk//7f/4tXvepVWC6X+I3f+A388R//Mf7JP/knePazn23X/PiP/zj+2T/7Z/iZn/kZfOITn8ClS5fw2te+FmdnFUp8wxvegD/6oz/CBz/4Qbzvfe/DRz7yEXzP93zPdbfPhRPOcA1MZLKrJlwtqGyhRBaaNUO4mVgkurAAf4AMg1NgyqMVKhznDxGI5cWhf20/VysiI+Xij22UEb2fHjyVRT4Dd3K/BF7Xw2auBLCDHlnpsLC+aEiC+aJtfGYsT0YsNHytyZMx4XroxqHhYDoGQpJyoZeLpXu+hdZxWJWOtTKnA5HDYnSJmaL40mfbZGPZcDsWNazVOAxLCmEDHOHRtUnbLVarFlHiNhgio2x9+ePCamMoIZG7esjp4WnvS+8Rm/oSIbrDbMJh0MuU6DunNHFuBy1U1NyPsyq2aweA5XGwSovWVyompO9vJuum3V/b0azbsFoZKdncCeryCaG+M/fbaOPIBMiK4PjrJ3lFiODqxlLnn/6OicFkBIT2+4ak63gHgkTYeCjxuEExAExz1dD+5NrJ81VdaYnKrut1k/0uTkIlfYh1w9mwdk0V9NYlYnuoEXEvkLfwDJQbXhviH/2jf4QXvOAFeNe73mWfffEXf7H9O+eMn/qpn8IP/dAP4Ru/8RsBAP/qX/0r3H777fj3//7f41u+5VvwJ3/yJ3j/+9+PT37yk3j5y18OAPjn//yf4+u//uvxj//xP8YXfuEXPvYG5QSgbu6W6yDPHMSlgYDkyjerSZi2dig2ljGT9mbpADZRm4p/EOvs6AhQS5DuE5YrT4xrIbaJxaob34h0JuFfqnnv9iUl7cmJJEWqVgdUp5BNNrMLUkhIbfgRgOnzgcqQzjU1rWXA1PHmcELtM/u+Y3D54R35b7mshFBu5jmckVJNMLn4/3TqCyApAmJWTi7WovORA0XpOj4Gzs5Q5tXS2mezSREIIdaZ1adoRM4IQ0BOMg+BetBqe3Tz434OJcwWMUx82jIIcqtQ8gA84sdF0SiLdMnlAMijTAEhzab9FsOzngWcniLvcq39kMi3rVYg1VDAMEzrixAqpG6uvNnUVNvtGuQIipyQaR7k/a7Gxsu7icdHSNdSyYUiayUcH2N86GEJEfa1TcIQBbXYV6VqHGv8P8T6J/cl++RLUikYOdoUMYuYypNES/pu8lgUnnjrLUgaItq4OkxxFwUiU+nqMAwYH3nEQlX5+rzbW4RBCdGOE1KnoVJSzCkL9J+2I0qnSm6UdHbmw5JXyxKu6fop61uivPKGEIFmn3NJ3fiQPj4CHnq4zOd9dgpo3pLrMQQzpMPx8TQkNo+VjL7XNZbsOwuV17FergGdv/sduVwuyFy/EW6EmwFZ+NVf/VW8/OUvx9/8m38Tz3ve8/AVX/EVeOc732nf/+mf/inuv/9+vPrVr7bPbrvtNrzyla/Exz72MQDAxz72MTzrWc8yRQEAXv3qVyPGiE984hOPr0FklU34ApyUif3qED8XMYddrL35Bf1G4dwGbbpnhtYYMp5BICpTu7oRJt1aLqZEN+qDS1qk1uEgMdTtJi0HuR7utb10yMyJHe5DHQ/2+WsYnAuhzO6dOAtO+AicyY/Ho73nhNMxB23PITMcFTED0Tv0ify1ACYFayy5TWjuZXNnmPZXfcgN1O2sL4KXLR++bKQu9JP7p9Y2E/D0HTVjOpuEZrevSaj08Gcki63R4yPJ+U/rJBGHAXLAzaUkl2utz9qHhtuTU3ZWdx3zwVAcd7hqSuch1vlPFr1aqVxHwfqlBEGOamGErUEawsmxjW9RIGaiS3T85R5xvYa6CNiHz2hfZD5MHYzJGMzxBXLKFaKPxFngdqhC2daDad0m/GziCEzcSHOE20lbCcEJobo+VOHRvTXK2mjdEDxHJM/CZF7pfGE3BBsi3C6ae4Zeza2HJ0u6G6LIf/tv/w3veMc78Bf/4l/EBz7wAXzv934v/s7f+Tt4z3veAwC4//77AQC33367+93tt99u391///143vOe575fLBZ4znOeY9e0stls8PDDD7s/Ku1h18bjIgTLNmgH3lA3eReLzMqFHjaLRSFd8YRrQzH1t3pY6Eczk3S4fKkenAtf0KfCbmmaJ4IfZQdMXShJfLSTLHK6iNZr+9wg5+gzJXJGPgubZEIbw7nCD+D88wp1t3HWGjY1p3AZdByDJUxyBbFUOaLCRSUjJL1LAFaIR1wM8fhoStQKNWuiEk+Z0xEWC0mqI1aaVAvlTI9KTtNMkMbpkEPBLDIdV7UeNWOiZMWMR2t7x0HdBDJuLkbdBjEhn55WAhm/O91gxZrMKc8WNgsnkl+ByZqLisjY+0+5KC9KSlut7PC10NTBpyRXhSqenLhCTDbuy0V1Q4TWxUGZAfVdxlCQshBrrhKgpE/nsFPA/NMADEGz+8hv48lJOaxzQmjnlY6hutFIqQ4xAESODJqxUMY/LBaIl06KkiBrzIyHlpzJfBxGGrV8dgPLG6mSx174Ng7SV2VCo6X0nSzrPqPvzLlYhwHh6KiuJX0XMgacuyY6cubS9tTiemS3l9xHMqRGmQuGfDm+Uqo1SIi7osiKZYbkecz/l75bFVfd26K2S4zD88juN1qeocrCDXdDpJTw8pe/HD/6oz8KAPiKr/gK/OEf/iF+5md+Bt/xHd9xox9ncs899+CHf/iHJ58XeFnSPSv0yEQcwL6zBUp+dIQ4sZhsI9UFv9tOc6fPEG1qhEVdEHm7nXAnSqlgKVkdyOevB+Ze6itcudp0trhQSqjV1lks5e/Bh2A5omWWjG2CJigMmcbGLcHhfnV83HdKBkxazKeS/Tj3fWijOdqwLSkxbBtgihXq198yoXRfoX4XzqVkz5zKYavjp/kUyg1tI8vbbd1M1YWQhOSlVlbOQB6Rc0DIlG8ecoCgHpazoWCi+NTuBgrlFOh8u0XQ8dIsersdcuLiVBH6zsu88iQ7Lqlt0LW867ynMuz7HfJ+AVw7LdftyKUgriHLuKl9YZeDleQOFTbm95tG5HFAAJD2ezuMaz9kPhnRj+HhBuHSZzCC0pRaBkDZGhU5AIK+o31J/Z1zLq4dUfzcfVX51XnMBEYyGnKKtTiZzoVxlLUjBa9UGdbyzDxuGm2l76YR+72uZxf6mvw4Ji2/fg6BN+e6ztVdlnWeyZobg/0/iwsC+k7p/XOIbea1GLIRiwMG5HFb9768QBwGYLPxSatSBgZFSbzCwO4v15VdEyKsz2h4ENn29VTdourqWy0mBmWXqdxwZOELvuAL8OIXv9h99pf/8l/GZz7zGQDAHXfcAQB44IEH3DUPPPCAfXfHHXfgwQcfdN/v93t89rOftWtaufvuu/HQQw/Zn/vuuw8AJhkLXfKWOdGNdbevoZXrtYO9lRxnlmxLOgMmB3GIoYbBtc9jf3sbQpfrQWDQrLahRRYaS8IiEMSqLGPRlKoNwUpF57ONJ8bFuiG6fukfPcR325pbgNpRLTKC7VfLagXRd/GYYF3yL7rUuUpMioUT0CZSYRifQz/tADXOSvBZGuW38fjIKwnBW5EGORsiQ9A2v4ucoNkNNfIiLFeVUa7x8BzNQVafuglmc4TEaNE3AGrUh7QnXr5UlVxUy1Ofa31zA1cqB4b1uhaiyrlu/qJ4OZ6EoGlYLp0laocfUAmfioiJFR1vuVyRBa7nEBorm8MHQa7BcYQWdyuH1a741NlVoOuSiIOR0Jh4+VLhpQjKZGiCkhBVmW/zhwCTEtHFLbIwRdX9TtEMtvRVCYm1Gqp7J63CkCsKZK5CvpfMQeeSEURAx79db6accOQCaA2Zi3UJ5xYb6hyGEEynUVvR0LM4QZBE0SPlyK0pzjmhPyGrX5GamrdkGoGin1tb2SVHbQRQ95ALVBZ66KTIq171Knz60592n/3n//yf8cIXvhBAITvecccd+NCHPmTfP/zww/jEJz6BO++8EwBw55134nOf+xzuvfdeu+a3fuu3kFLCK1/5ytnnrtdr3Hrrre4PANHwFVpfSV716mNVMVRBDus8jkhXr3rf2l5ymAu8rtkY08NXfKjijOSUxSqUw4j95sy4J3JQ0ANfPxfCHCCLVcKYZp+32zvLNY+0yar7RA99oP6b+sCHl7bBPa91Z1hCKTmkt1s4FEMRHCPHVes/nW2klgCVBJcxz7tt3YAU/ldynUibJtZy2zulLZV3cHqGnH0iH21PsQQl2c9mg3T11JO9Wl+xWvtXrlJYXEaiQzesVpIoh8eiWkvWNv0uVVKlzrN0tnGoUCWQTTktRsqU57i0y4awBTDUrb50s+Rls7c2jZqkSD7bbEqdldNTIKeSpXJfUSMAVufB2iX1OPKVq2Xsc/N8zlgYSlZDtiTTptRU0KRJPIdKjn957mZTUaOc7PqSSVM+U3fcWAiomtgpXT2tSoaMhT6rNFMSZT3ySGkUcVk0OsmlSk9+3jNSolll07Vrde4eOLTyONb+M4q127p5pHUzQgglfFben8taKO/C1vucGHFya0RA3yBSonTcaZ0okqfh0PYbHR8lgWroKKNfjavW7RNXr9k+7JrDCou5anl95apYAa7N5uLpcq7ccGXhB37gB/Dxj38cP/qjP4r/+l//K37pl34JP/dzP4e77roLQNls3/zmN+Mf/IN/gF/91V/Fpz71KXz7t387vvALvxDf9E3fBKAgEX/9r/91fPd3fzd+93d/F//hP/wHvOlNb8K3fMu3PL5ICBa1GF1dBM+4lwaWv4ic5aAvsijs4NcKhbqZzhES43RDt+eGihjMkpnOkwOkPiYrAqhM8WF6fyvHy9UAA7Gpm8U+acJiada6Xa/jbdwPGVdypzDj3K5tQ56kP66PxgEg4lWTO8IOUbUWaTycokbPq3H9lXAXlHOgREXmRugc0Pz+5E6y0E5V/pxVEyoj3D6b8mKCPj/EEoopaEg4Pj6MYglBj+9tc0390IdIeFTxr1j5y+n75o04MQK09H1o26ZEQyGyOSs7emu2fDyvBLukT4ChVHG9ruOmXJpJPzNcaCm5FWtSJiJDkzXtQ2DV/67+72Yeh+AQHQA1URHzoaStE/96226eL63VrXwacZNq3Yycsyc4tnsKKZDTvjGHx6M7umasLdReh15kdW+k2me9n0OPGvLoXBg6tSUerWfnvu0zjHzqfZVMquGftO5dSvUu58oNVxZe8YpX4Fd+5Vfwr//1v8ZLXvIS/MiP/Ah+6qd+Cm94wxvsmr/7d/8uvu/7vg/f8z3fg1e84hW4cuUK3v/+9+PoqEK5v/iLv4gXvehF+Nqv/Vp8/dd/Pf7KX/kr+Lmf+7nH3R61KgCYxu0mEZdmBfwBlARiTAS15VzJY0YiWxKB57DC4MQg8rH6W8tDK6Q7k87Z/XdGw2YXgVOAhJiWybc60cB14RhfoyFA6r1cP9r/+8O/DWlUv7Sm19Xv7BDIaVJ4ycWes5LVSqP8GbSqB7Ye7KslYO92hvHeoD+cL8BV++S+R0qL6zbbWCNArJ2ysY8zyAJ3RyzfKMRGg7RPT/18pGcp90Y5Kw5tMV4BHYjaT35vq5UgGk1SJL5OIzMse2eomfLY3aHziTNZppqcqY3ft8qMEpJnfeQxS8SGXy7LtVR6PrMSZ/MoiiuIDmnK0Gnp0ZdLn/pX/dzsA18uykGca7IjQ9HkMOQ1haCEUCGXbnd+3dI8VMKoc+vpfXRc6IB2vvo0Ghw/KWXeRA9ZWXrJPMrcFes3iSm/ybfN7adt9AHzpRixVFeVRUEQ/0PDomleG7FW15zlOQlVWWLEpjRsul+OFU2YhJXO7SdPluQb9OeC5YYTHAHgG77hG/AN3/ANB78PIeBtb3sb3va2tx285jnPeQ5+6Zd+6brbEoYBIRTCzIT008CwYbWS1KOetKcHj5Fk1FKMC2CfCqzNcPsh10ALicNbeTZhx9Fb2HrtYlnhbCFM2WY848PLgDHrLQZe3BA5oWrlEidt2vZ67aF3zh8RIoxlOAxC5IslHr8heBr72yxQIhmGqtAYRGvvRR4mDGaN87f3oNEQ2621q4zdUMuGs0I0DAhxb/fOp2eVsb9YmOXvDk0lZ6WalVIt2DZHRRYIOgyDW8NhvSYCHn0hCqaNiY5rHXAgj7Y5p+0OYRC0JpZ0x9juypy29uc6tso+zxlhMZRH5KJ0pE2qELS4GgohTvggy0Xxr1++VPJZaG6DIRoPA/bOd9C8HHm7RZY5WvJk7GuJ8oC6mS/XNWuiHTTKv9BKhuIKNOVmgPJ1anE3qcWQinKdNtXtY0W9UjlA49GRlNje1kNXlL6QEmDhopy5tBBs20MkrpbyPqJxNfJ2WzgrUjraZV6UPpT8DnvkYUDkAmZKNrTDPzmrNyfU6Bnzwe/82t16t5G6AiOne05+fbrw6RDds5wbheelIhYUYVUQg8b9pOMve05Yr0XxbBSoGPy60EiJnNx+44ivXINjRiGoxpoqMONEWR9uvYzx4ZINWEmuF4kt3AjOwU3BWXjaisBpWX2vgCfIqV9PJ18MpkEbCQdwWrX3He6rVt7C9cY3yA7CBmApiAFUf75o70HaYL4+grONtKfPYWJko5RMojQcQSpYbnZsNtAKeMaX4L7HoT4nJ9uASlREA0XSvfOeLClRtvJ+56wxVo4s1lutUdkUOB2s829rPynVtPuKU/zKgWvWoPr22ToyC4qsd/G1Gs+BuQIpG99Bry8+8pLcxqxe/V1O4rP3hKwaJ14PDEvLuy+IkHIXbB5wMawsiaRSJrZ7ne9J0jlrWlyb71b4qlZzNM6L9mWzKYmEZJOuUS1q5RFSplanzV9pi/r7lW+Scz34cnaHAoehGodDlQix0gGUuaTRBzqeQljUA9EhPnpdi7jQOnE5RlJ1NyIEG8N09VpV2kMsKcD1fuSn57G3cRXuQSUZUkr0XbNW9B1D5i4TLXV+KM9Hf9P8zsaZ0TNRMB2iKsXLJogirbl8tqnvQeb4xKLXcRPDa5K+PQmHQ7hBzmjT8SdxSIMjHM8USuP90NVESfZZunpq/Kq09YrOzSr33HMPXvGKV+CWW27B8573PHzTN33ThFv4aPL5oSywNYHpZDRRP+JMopHZJDj2JS2uc9wPc2lKJ5+7ZzWvx3EBYmWdz/r5p3XfNeSytZaUa6EsfTswW/KcI+Rlv4itidk2pTb2+aCInxV8QLR9Vh8xky+5D5z6mrgbAGAJW3Kqfv/Gz6zWpEuwkytcbqIMfYLRw2rp/N3sOgEwZWqbYkLt5M+Y+Gfch2jQMrtj6u+lr2sq9NPOCxnHSZIa0JgrwqIwMVmR1R0jqESMcKgGj6XevykuhjRTIC2SO495Cy003Cik5ptvRbkX7DrgZ3J7ZA1lUg6r+yx75Zih8dDM0Rmegr1XOcRqciheU6mOOf3O8mroI4yMuZxd786dA8zygdg1x4TKgriSkqLvV/qWx4q6WZsa14N9pmuVjS6a2+wadBwna/d0z2uTus3yGlq+DK+JQPtk6yKk+16oXLAL4sMf/jDuuusufPzjH8cHP/hB7HY7vOY1r8HVq1cf/cciT4ob4ukkYQiWYjaPI4aTE4xqlTqNdXDWBCeICUNEVhgfEMiO4PxIqaH3M28yl/S+iBEQS8A2PtWUZ9wXrjCKbjwKWyvhiaE4vge7XLJshAy1sgyDlTQucCmqO6a1Goj4qP33LpiZdxBDHZcYAAx2mVlzAnc7X75swC7dbuOjV0mbjXuH1k71F+cEwPveJ6mtI23uApGGYUBWRAV0SNC7ygpLL5cFnQH8uIE255zrOzSkJgMgwmao7pl4coKkEHQsCaPKPBxqLg5WOvRgk8PDchXQuwtHJ8UVIPMYlmNiQNZ3TkiaubL0PllSgEMP7EQHbALCTE0IcYkYv4dzRVAOC3XlaKy++efVCk8ZwIiQiwIY14uC3iyaqp/qNhk5pDe67/MoboyjNXBa3n9Yraw4VaucGFMfKKGSei8Jo7ZCXKZ45fo+SMmNly8Vl4WmwI6xpn8mZZERMRvz3b66DVlCBHJJUx1ymFjrCFGiimqfsrhe0+lpWWe7bXUD8ftT44n4VHVuqSI+1na1yg/8XhHXJa0zRvnNbg/nimK35yExbhW5Xvjzdu/KlGKd2mRuiAusOnlDOAeP8/fvf//73f/f/e5343nPex7uvfdefPVXf/VjusdNjyzkvQ/R49A+HNBQbbMUrdaFIdJENLKd+N8C+yLdPc+xqtUCdJX9yBKfs5wAS4jiwiutfcHCwhgebiMkbOPXZ6lFCVQIWdujQujCJAbd2uzJRg4FkHa1xXr0OS3Zrrp25BkGI3trXZW11v0DoGaj1PEZR+EkJP9uuD8CP0+iLJZLn8NC779cwhLWNG6NxFXymrbVjtLmrqgNjyfF/k/GlO+xb+Bohe2bcTErjN/nWOFlRzzjZ+rmrNk5ZczdgUxKt4ODtY273fQ96ZpTvsqc5cqWva7dFobWQ7lNktb64FUByBnpytV6wIlbLbDiiGa8SZlyVi4hHnNjpt8FtZ7VjUFyCDlziAu77TLN2dhEbbQIW0tGzHneKAC8pa18hxDLnin7xiSckhRiQ7/UZdSMTXXrej7Wo4UwKvdj+nmDtsyEJbv9StowW4js80AeeughAIUb+FjlplcWnLUmVpmxwKk2hIU9ip+cNwFL5csuAIJzteyz8x+z6GdCzmthaqusxz7F2fvQxF4uEY7W/lBp3Qa0CVifGZrTjV/7FZpCV6pMHID3nLuEDzbph0H/DL2yBcoQpSIKOUmSqEj3Vmt/qGm1D7hebOzaHAvcfh17zhsgbbdUzVY3IJLSJH5+tmIcKbXCncwvsZTPzfh5+JU2enpHTiFVpMuVI276qGNF79HevbrjJCJmkkuffu+rlgpxkto3cZ2Ju4SVPXvvjt+R/EHO/J4ZV5RTKkOw9MR8DSDIkhyAVhOidWul0RAXiwoaR8TLl4gQmWx9Tw6ZGaklqGMtLOcQDjrUFbHS/wOGspho0rAD7Py835Vn0pzU5xcFP3kr28Y4ubnQrtm5PlZ3DykYtMeFxdLVODlo3ScxSGh/CasVsF4bDyOPo4UHTxtCxoO6RJwLzyvSru+o78/QMXLDPRVchRuZlKktcbBpy8zPSEoJb37zm/GqV70KL3nJSx5zu29+ZSHSxtZorpkWqQuNiiX8ynLR88YagiQPogUmltpcXQP9HgA4jt1if4WAVS3jKcmrNLCxDolBPdns5f4ujbQqKgq1suVP1TM5FGqSA6KRNk8A1K9NCsoEjrTMl37qxdUSUZQfR94kn6Wx/A+0ZcIrUQtIqobWolDB2sKwrCbn4bz55XpvxdkcUsusHWv+bc7G8nffD8PBA8FdsyyZN3PORWkNNDe1j6wgqpJzcuyVPLupuiqyWc9W++FoXRVXXSt6b+ZdmNI81EOHOQ+uVkgzb6U8OGjttIqE/jYMQw3H1PsBNU0zUJTmGHxuf13zw+AtTB6nKIqHROt4NGtvYzQramGDFBHlI8ShWUOMdpQERPlsU+t0aL0PyT1gHBDhwtgjhyjo5dKt3bk5pEpuWC4nn5syJuHJgcOUD/WVMs8aGVpdfm1IqT7fatuQYsvGkIyZSRJle259c3+15o19V54fV00NHdcFUjxJyXAI0KMgGjdU8g36A+AFL3gBbrvtNvtzzz33POrj77rrLvzhH/4h3vve9z6uZt/0nIW82yMR0SiEgETknrkNgRndeg/eKMOgPniCjdsDdc7pRtZUZYPvEbjk8ty9ZjuWSwbH1gWhtSGMIS4H3HZbwv7GNOUstO1LCtMreY2sQBKzqhxUzNaK8joIvj7bUPhnsN8mYvhPuprU+gDCbufub23ZbGr7Wv6HKnajHABbUQCV3Q/UKBSgwK7ItT4AHzgzxNeSJju5wlDZuZuzt6QB7w7TNo7w1+x3yGfRuUJqxMU8spA3Em1w7dT8/gy78vyqhF8UNGS7s3HMynNh5ZrdIJpfQEuo6z0TVT5kNEUlJQk9bGB0VZpDqJwFa3OyccVY1q/mByjhs/RuAUBY7kHcTI6Iy2sfQFIOgD6H3Q5tODL9O3P2z93e5S/J+3Zeax+r+9NSam93RUnSkFTpP8YRid+71QjZ1fBGHZ9AtVDM7Zjqe9B7jKNRA/KpRAS074rniv5/rBlFq1Uv85Xnl0Xu7KuCpOMt0SyFW5IQsAO2C3P36Xua1ItpJI8j8mmjAOZMe9HMfs7uhxB8PYlG4bkIuZGhk/fdd1/NVoySyfg8edOb3oT3ve99+MhHPoLnP//5j+uZNz+yAJj/nUNlAJTDVoVISAc17ZZMozI3wdtNnCxWJ+zLY2jwMci0vDVb1E2bQiF0GQu5gd+1H7M+vDmUBGRVEfzvQ6QKIuPcEHOMcGlDDdckzoO6FPg5bbtRUZD63QE0hDaxuRSxAKq/dcKpELdDi0jlmlJYr3OoygGl1N+7Qu2uT7FY+oyuuEgO53YKwgdIztJ3SNH8oNR26hxs5njLMTHrW5N9SWinY9y399BDh/g+9cvsDqXzhOddrZlAFjzP4Uf1gRckoBKNU+X3nCcURREUyXCo4Tlb62bjUB+HdjbISvl3w1eZGbuwWBrapAiiQw/nOBAz7iRu91w0iksbHaJ7325OKvrU8l72ex/+yG4ZduUd2AfZHWe/wwwKSPc4910y5+MZKP//9r4+Ws+quvN3zvN+3HsTkohIPlrEaDtolY+KY1ZaRS1ZBMqy2DozYrNG6lBoLczUsaOUGQGlOljoogyMg+1qLXaJ1XatQjvaoYMgUiUNGkxVShl0ojgjCVNpEpLce9/3fc6ZP87Z++x9nue9CebmJvdyfmvdde993+fjnPOc55z98dt75yUOxgkL3ntceeWVuOuuu3D//fdj/fr1z/leS15YyEl9dtlU8sVNtZT5RZjgdnJCTMDkMyfzlUzTaletDOaxnDxIv6PJ18aCVAAamo7UoNRim5uZCVXVbiGIpl/T6YYyxoLkx9nahOTP5xgTzI2xqBQvVm2CB/VLmBvpGorbESeuMv/lhDT6k6I7bLbw2ApWZPakjH3kVydIlxD/lr7wcBDQ7cKuOCGVj24Mn1FzxKoCUbFf0n1hDUy/r9LQKr89pdAW5XUBhOfDJuwqmVGjVcR0o9992TLYyclwj8mJVCCrrQQ6EJ+5hSyeRRwP0uDs5EQi1Yr5aXpddnuEZ5H4BpIrACCUmRZl2cM5mYm80xXPgzI+dmD7/VTOmAt2VSFKQDyrNleNd6KoErnU6JnQ85mYEBu4mJuxJDKnpqb5Y2OlRprPotqlsXmZ+OBq44J0pFVLImweiRCfO3NxyCUY+y/ni12+LL1zYq2w/T6b31W6ZEFYDEKO5YJZsow5u7ToedFz6XaToI4kiFA2VWovh8DaTJiwTb4Ah3eaVAEzF27pXFmQjwvdtbguea7GfvD7RPlIoquRI6Dk2GTKCa1rNB/NOK7E0cI8uiEOF1dccQU++clP4lOf+hROOOEE7Nq1C7t27cJ0Vr9lLix5YYFzBwDhhRIJUxpseKHZc0IdKRkLP6YMyfIHp5ux9HyO1hp4U6MsbeSLlNpIrrFz+7TQYKemxkrgAJpFYsQL0rAsZLwHyXQeJ5krQiRfKrkAuKJd9OUCEGGLlSI4suXFheyMfI53cDMz4RybvfB5rgVJfAJUXDVrjs6l50XHiPN9XQft3KZ5oDZ655uWAhb8kgmXNLZGwqCW+cPFyaTriyITDh7k1MsuZgoN/uievnf8m83Z/SwNrkvE3ka6YZELwVSxpLgVqb8BbXUAEtFTkkSpj5LwRpwFwfwPKX2b5m43PdNuEqb7EjdoNErWHbqmFJxnZ8MGI+cakdmGw5gIynE/KVwvtD0WYsqqneaRFT66w0wnpptmnoZRPABpBeHMj0LR8HWta7iQW0C++/E94yRHbUqCtOgQB2mUvZuxXLZaM4YtSYniPG91hyoelUvCFSDS1A/ZAqa4XILLASDMO3L5+pQ6O58DnJ45um0pM6dsLxeSYwumaKdUVshyCSQu2mFEYcwrjoGwcPvtt2Pv3r144xvfiLVr1/LPZz7zmcO+xpLnLMwFPzMj/vGg4H/vQmnVkF/fZtpwC/M2bnrB/NdOqvLOA0r7SAunkf5BpJfdWJP82NzGuDiTqXwccnKbi/5RS0V0hIXDWACBBd4Iz8s5FJLcRwWoYh4LjrWPLGhKn63aKa9POSd4qAy8SVkEWbMRzwVRAPF1JsRIn7/4jPvuPAzqpLUhbcg5PJlEDeViENUtK5sWFiJ/1rHKnzB/U+le5aoRDUykKzpebkZxLhqR+4BiwmPmOwYRzXLLzSALa6O2ysgCml9x7MgvTgLDnAuo5DVEt4Xqb+yj9yY7TWQT5HEZYwKWfnQ5Z2lTdCLrajekwGbBS7xT1Edqs2L5U84H55W/vJHALb4jyLgyJIwpAayOiY7ocuTmQFRQZmaSoiFzTcTx4fEj/kIcb6Ux++aaIZ8nUOlxncvMzkKR4G14lzb6/J0F0ncyNbS4ngrVdqN03Tg+fjAIrzWRY/NQUAlyEbOgnXFhcsG91Q0r3D5iXSMyO4C4do8fpsWM+RCGlrxlgSGkWiWBioVfpgdlsk5dq3jyNgmVCJBGsq/lcfGaQFNLZ7ObXDxztGixOWGu0VfnU9x/fCFZK6UXT7aNSJGUUU5mo2t78YS/M1hosjAkqQEpLcmm/ubhW7QINKw5sU3dkH2Rn2MWotYaPeK94EmEjZ4tTQ3fb4vgkC9M6su0OTZexjaiGDc2tuVQxCovykbXdfqR/mgpKERXUrqPmO9AMtO2RKkAYPO4j75jkwuUNMclx6FN8BJkR0XuiwRjaSVibkcmALOVJ4exMe4/zovYXyPfX+Jc5Pe3FecM4M26wasQzH2yiqlnF8d0NvPdkwuNeRNx84+hhilBWuQNkcAi6zdQP+JxjcgAmZ+BG5yerUxT3SCnqvBBaX1rs9jF9M70LHrJZWaEoNbgLIm5zoqDvD8lNqPIjzguqrCTyQipQMprki7GwoPiP+Xvr1wrpRAW3RjcRvpZIN7CfIZOLiSWvLCgFiPvUtiN941wN/o8npjIh1xeVrww0cfGfvrDDIPjPAsdEVpHL0gmKPBi28JbsJMTzAlohU+58RE1QPKZcrGaOVwY47RuxQWIXA4fNSl+eWlzJ7+y3Pyt4doQqtysdH3kghCNi/McKpdft5WQyE0m02T0W09OpHA1Hl+bfpznKo8pxjxqI57KHAuLUWxbI3ySBJScSBm160YK4lzrp3YgbSqU/6BVWIyWEAAhw6CrEzeCLUhpvHgDiceEnBJhUWcLCs09InFSnD1xTIT7gsMXpSDTspBLl5vk0JhOpxkqKcdFgjeveB1hmk9chOS6YFdMS4l2Lq4mBcv82WSQbh52qZHQLQUQ4cLi8Z6aVEKRLgEtnpFKBGdSWKtsRyeFqap1SGrrgJ5rGfT8FO6TKDCxdVA+z/z+4ly6ponvOvVTnTc5CTMxEbgYgmzJ3BjJdRE8JB4vEgRojZRuMi/WTdF3Jej6YEnlZ50LUUcTfp5+FhhLXlhgmGbu9lDApf0lUhaFulYvG2slMgSHGfRpYqvrRU1fSuZ0H7ZSEKHKZgusNJNx+6L1oy05kWgTv1RDEdYkjgPEi2zTxpg2mOwlEi8kZSZM7gfhn4wbCpO52K+fruVmUoGZBkHUCw2PPqI49TH+1HFuGXIJsLYVa2Tw84rjr0im5LdVfReCodDoqL1ehG+xZuZqXXJbtku5d5yySvkREbbEJh1TdZMlB0D78wdSSWDhb2dhjMaBLUqD2F4RhSKfI7mi5EYV/bzkUqDzG8+GF+648dA95NxueQcbIZM0LpkQ6wdDJVRx28TzlvOPkgCxcBD5CXw8ENrK/IqMb0Juh2hZSGG92szeBmWFIrcDFTOT8yN3/eVQ60BqZ4rGiRuseNf5OF53NE9JJVYymZVCWun4gtGiNBjyvJL3p3mncsiItvjZWUBmAY3j4qZnsrEQ9Vnis2yt3iuVr9Sp8Dtfc3ndTrlyzJh9oCBh6QsL5BNVG2icYP2MVWyTtpSbtVs3ojbXQu5+yE/JzdLEJZDft4Qs8UIlCGb5S6ja1Okq0yiz8l22ACO9RLlJlIlv8kUS5kITtVe1yQohIxDzBs2wRjm+JmmGvEBKt4xM6yxcHbmmpJj4ZDWRDGg6XoSHMjlLaCDM8PY+uT1E1ACXuKaxi3wF0++r8K2QjS6wwvM8HWTJaPahw+1usLPls2sTKKk9gyze3skETiTopTlCc16axYkbQXwE0w2EUxkFoqxsNL4k7OahdOkhJMuHZMeLjVzyMTh5mLyn8H0zsY40WGLG+2BFY5a9nH9OFC0T5EhjDWdqzd1bqh/kdqDIBCZRxnXGVilihawaufVRKildzcTPXXnUb1NVqTqlHH+hANE40IZqRLQPrxU+zSH5jqh1yYsIBimUSsVBWFAaLi2qFguIqBrbEHL8YBCtVxZk/Qw5JLLcFLngJAiTrHzJyqKyHeL4hislKoFt9V6OKopl4fhEg8UsNAC//0CalDGHfaMULtD0R4uy0XSPhubVovF5qbELvoAhqwdpcbLcbDgx/SaNts23p24W+0os4sEgSPPk8877A8AdPMj34ZDIPERPmvnyhU1aQOIiQDnfG9oCjZcUbmizHecCiUldTORfNBNhiWcp/bUjIu5F03pMiRvKSmuSpY++bk46JMYw3CLTYklDydKsciIm10JEjfMgN/9Kq0yeURRRiKT2NeYG9ZuY/WRud7XO4Z+PS2wftZFKpks3B1seREl24gSMdVchLc7hOo61RJWTIkMKKezqfsrryvTDgsOShHeb+iAtC4K7QxYFVFWKRBkOG4Kdzwl82QbE/RoMY5tr5T5gMh355gEmA6fnMEr/08ZWVcoFlq9jucVQrld0HZmUicmtcazYZZRZTdXx9H5KLpZUJKRFTj0go9oI+bxdzZwNSr+fhI5ANlUht1LAAVKoZTYuvF5llkAgzSmeD7Qe0DpC0TkL5IYonIXjGJrRLCAXfSldcjW4qAGSBJu7AxokSXH9ljh4lY6UtKBo6uYKk/K4trZRn3KzYN7nOtuk5AaUv9wcxlmxZucoI10bcn+9eKG1+dKlapLSDBn94jKkilwMDROs3Axs1WC68zVH411K5CZh7cPGtNRqM/PN69JCKK9L1inZPrYSifOGSdNpaKdxDBJBjLRe6a6pM/eWVZtMMvlm7i7qB7HzZVgka5MtG7DwL/PcHPf8AU0ETBdRgkAjwgNoEsmyOSzN4V70nY81NtZG0PeR74OPGVFTyLQQtoU5njZwsmAELo+wRsm8H/xhdO1E4VCFBap+tZCC2aLZT9EWg4HioKgoDukyFG6lxnVBwoWYZ0SKlRDnumgd85kgInOr8FyT3Amh5Ehegbq+sH4EV0RMFCYjPugeMoxUZqWUQq0kSg4GzXllTBL4jH6nG21tQyaQFLTjeSEsSMiMZSq5CZAWVu+06cra5gLLpDijNomx97Vig/VpwWRiWfgnJssxTYEkJxYZw1nYlMldEM7IDEt9U2FCakyisEDkMpsEpXyz5ntI8640V/KCkX3O90pJgsLxmdBjjBaq8jGUpLycNJULf9R+Evyqik2O3I6MPEX94zHpSvKZ4GCkRiWyn7h/I9Oi1I6IyJdzNHITf6cb2P7GcrIkMoGrdgn4YdBSaUFWY5KNT9M9ZDhRlUqW0+3p+WSMNsPLRRlpriuTObleqHZF3v4olCsBVP6m+0oXjBCCmgK2yIAo3VLiHOn2Ik1eEW5J66Y1QY6VtAy4YPLnlMhE/JRzi+rMGKtcAIkD0zJ2mcuBrXVynpFrqDGXLCAI0MptJdYKFjAyhUeGQbdW02V3TNL09fuUrs33iEoSm/0j14RJqs43ojNU2wnS6iYIntJFlbs9U/+MWn/GusyOJubDBVEsC0cHPCFIWictWJqOiXRE0i+Rdlw04UtTLmmA9LsrsvFJMx03gPzvWQVG8R2ZMDl5jUsRBq0EIyD6Sdu/azNTc/a7TEgiU6Y7MA2ustgW3ZH3m66fuROUuyTfFGQ4WG5eJF9vTuwUnBMTMx3m5XHZ3ZFDaJNpkXJROxWmx1zgoYVHXjM+G1W0iOZSLTS56MZhC0rWLtaExfGpI8KHL/gZbno6aKTRfaIIiOLcKmYWpCyUfjhIc1rWlRAmcuq/megnMzy5OxDmhx8NkxuC2m6jRchmlhtqjtWbHLkhTKejLC+srYu+kKbMvAVy0cU5nN1IV4kloaJqCmpqzlFW05jFrs1qldySYk7LzZo0+uEoRk2ZtOF5z8KUeg7TM0nIilpxQ3EBlLldRl7JceYaMzFiwVTCajbUyZs4JbTXkTuNNUnOKe+gUjBnHBU/GGi3aebSa4TAMmfCApMT8LOznIKf+5sLsbIPxsAuS5kpyQphiCPURpzNiJrkHuTzF1JQAIob4rhFNIWrDIIRptdNWgeTG5NGTKZi3sToPEFEg4mFhJzX2k3m52R3A4dDRmmafGbDQbqe862WBU2EcnD7D6R7CB8igLS4UztdzQuUm5lNn9O5COGYIXysCoJUW5ln6QqJpn+98GXugIwd72Zmk1mSLCkmkSHVuOVuHoDNjZQ5L41HzovwyRUkzJzSN+kk0YzmCcDXbYQnxsVSbYrinvJzN4ihkdJKI85RWrSEXOQANruaqoLbf0BriIAWSombUtdwe/aGTagrUlO3VPsk4cSPhnD79qfnYkwSRm2VNkW+lU9kQSKhZiZ7Tise51+4nYETtRFYuATC9SgLILkhOFdHsizInAUk/Nf7D/B76WZDlI3LyJ7yb0425MJGzD59cvmM06pN4ENgOExCzijyPLKNO4zBkN/dUESpTgRSY1KBKEp2FO/n6xqOUvEaE9wGZNLPso7K+cDuIRIq6Vk4H9sZ7xffbyYWi/WI7s9zgfO1WMgspbnVTPIn+L7DQSJhivfODwbwz+4PY0zCCpEeJTcme36+dqj37RdzwnJ/cgVCCXdivbb9fuZ6Hc+7OSooloXjFGQGa0lkgkgAY6KOMIGSn71VWyUtlKwCImmJ0rjVKWasMNEo5hK/z8McFemt0rURcm3cVLG8L2lE0b2hEqBkbfSDQfIp2zGCT8tL7HMtV1gE2JQrxkFv6klrJKGssYkKwYb7LHyqjTbSObJvUWih0sXGGm31kO4bafbMtZw2cl4cM/k8pJm7QX4l/3jW5oYpXfp0yYRP7PJx/Y5uCy50JNtKFisZ1dAGsjwon68wnwOwy5eNZdtzdE03s2BFgdlSZE7WvhBdI+a41eHOKtGPmEd5GDKNl6U6J/m7Js+T7zjl4cj7kjH5YSuYE06A4rm0WeK442K9yT7nJGl87TZrSKyySW4I4V5UfCxP4YrDRpva3D7yvETcrMXncVyFcJasDLY596RwL10CLRsxuV8aeS8yflMYE9M8V94HYwT7MVCkVdof5np+BQCeD8KChMn81A3zW8aIJYGAJnB+LJA2uca9tC+Yr0MfVUmyzRejUMSlReiQbbA2FX2Sx0nuQu5Dr6pUNCW/LpD8j7TgjkvByn5/Yc0QRbbUMdI3TPyBbqexKUsNjjXgFn4F3TffgBsbLdDQdE23k/gFQOO58bOI5m87OaE1au8BGzUT8Xx5TKWlRvSv4XOlTWYu8yfNGcGXMb1ejM5ImmCD70FjODXZ2ChTauF8nofnRuZdtXiS5UG4JcI1fOLqGKOFGvJhCzM6/c9jn5uIqY0yGgJIyXJke8lFQVY/BLcL34e5N2Jjy4fXikJC7LaouLBSalAz90metIkLb9FYUMEopDlG2mu+MbH7TfSt1d3R76sIhlaeiBEhyfFd5/PjM+Z1Z6Kf2irHJa4N0jWhCqflLlSjeR5h3KskcOXcgCj4oKp0IT8vCoRlArq8p5noKyFVCvmtVjOQUNiuxIU2ziE4Hw0Uy8JxCtYOoslwKBKgSHNXg0wkissMh3rzyoQKPz2NRjiY2ozjd8OUP76h8UkmcR1Z7OMS7sTzG+Y6iEXWu6YZkhLAZGA2MrXTCtOcdFfkJDGRyVC2K104sxIIc7M6Npo9pWk0t5SwNhj5I3noYVt4oqpAR/cl07axqfaHPC1GZbiZ2dgeJzYwKpQzUnPBD4bN0Ks6C6cV7gXJAJftZbM9WVpE3LypbDCvj4YxXW26lryGm54JbZodJKFPLOLhML3RJBN00Aa5v9QWWnTl85qeDvOLfPJE7hNRFe7gQS3ERl4DhWfyuLREX/jRkOcs3z8mqvLDUTKfR4HF5M+Z3nUSZuOYusEwrQl1DJWWVg4nrAkAc2FS3+P4CL6TH47SnPA+zBvSeNm90NVrBPWZcg3QtaLrQVlRaLyjZagRvRDbRUKMSjBFQ0LJq7L7tEIqHBI+FSoL/ztlGZAChnTLkgtEXWowCAXdqornsqrHITZ3J9exmdn2tmfCieKY5FbfHC3jdTRh5ulnobH0hQUj2LVkSo3IJ76cYJyJjkzGgF40hdZG+RMa7HJug1js8mqB3ukkRLSQyWRE4hr8AsgNXByjiJk5scgIk6fMY08vinNJM2WrgX5xZRgkbS6ppK8WDJR/ncY1EujkgkzXZaGujQku49tbXRUtLOh4bb6nDLFjEp8IVaNri/A6OeY0Lip5lTDHUkZLZdomXy/nnjAiB0CLn1RsrpJwl5IkWUUq08KZIPXR5eR92LecZfGkvg9FuOxwmOZ9y6LLgqXwcfu2ZyOETT6+0WdNOlTIhbnM7M5Fm+okGKoQPNF+fVmxJpCLz4nMmXL82O0ozsnbMRyidZNlU/4wugWDeyOFiFIl3Hg9scHKa8jiZcqHL/rKuTCo3eo5axeRzP8gLZuci4DXhKjkCKGRrwfKyyG4IfTe+5ZCahIijFu2uVHpdy53GbVPXq8tZJ0sMsSPksIIEKNglv5WeKR4XoyQmhzSJ7psKh0kCYwZaUjVB8iOBTKtpk16ZfNob8wG0fRPqnbQNaQG4n0ws46Tlr1rLLxcZY9Jac0XjFLR8uIrLQtIiwm3m4QaOTbCApELUck07fR5bH4Mvma9YFh1fv58wiGmnZBJ46iExjGLOj/vxPhWlSRpMc59qJFHoNwqUqjixVTcv+Hyyl1iYXGmuUV8iwbnQzXEplDLNheVHKvsXhR5wJaIzBzfCGczsSwwWRRanolMzkXXaEYyZJsBWTXIzdBiIlZmb+kiou9FFtY8m2fjesTjITC3RfRHztXMR87Po9tNyYTEM5K8DZl8iXkdtLbkLjOrXXragtSiRNC/sbZCW1gx1wmhMWzZ/Bs8IGN0cbKsuFVbeLCyYMgQdOpnJLKaiQn4OglO7LLJFAHVJuF6yqGIjAIc9SbXByHA5plDjzp+GJdD288CY8kLC/mLQ+FSAIC2F5A2uRjXbvv98QsnLQiTk2nhkpo73zNObifvYdK5/X6qHxDNtfL66UJiM+r1UrpqsfnRC6N8oSYSxaoKZtky2MmJ1pdK+ZSlr76FTQ5jUqgYaSbGNBebfNEi3kLcnHicnAcV41E+SbpOtGAEn2rLwibH3hjlxuHY/uhbpuuT3xZACimNpEK7bAp2eRwr0Q4iSKbhMMlnLf2nNH42+dfDNeLiKbPUyWdH7TfJh87nM3mxvWokc1KqCiaeJ7VGvjY9R5pvlNsjpqw2VQXT1/NHnQOEdtEmFq0JxDVRYyaeH70jzEmheUnjJrVmEtjEuKo+Up6H6P9W84z6MNEHF9MiwUHwUuwJJ4RCRlS8iEiv9JxFn5XAa00oRhbbaaqYOyBunDK0tqGxSl6HiSmmhQDM96mqNI4mhLWaqSkdPULHU5sEQdRUNnECaE0TpGi7bDLwVLiQkxh3yW+IgifzCSI3h8IwlUtNPoN4PTvRbwi4ZqIf0qNzSm5BLm7LvyFz48SoEpq3ptuLv9sLWqn/KeqL3n8SKskidygrxjxhsYZOtmd2WUII5jnh8xKuhxC6Y5pae10DdXgBPdDwDyXtOkje7H/NY/LpeCq2U8fNk3zTQDDxDTrJXNxCPGzt18xsM07fO4R69j6Y99gsHlP21jWs90FoEeZzlrIHQ23GFOQp7+JxsqjPYJi0La/93Qz23ZM5dpS0DYh459GQNw43PSNcPTQeoW9ueobdNB5VOqbBF9HEPsWiH0RTuTD/+rrm5+xmZoDZWR23LSHcE76u4WaT+4GvReZ472B6k8FFkT9bYxEeGGJ4rWx/tCYI1wD9bTy5akTcfXRB+QMHw5yfmWk+i4YpmPzw8TkdOBD970P4/QeUGyLwJtJccAcoNbgY51gHxGfjESwX0VUxLULy6LrWwI90ngbmlczOqnaH7JRgwdLPzDb8zTQG4PwJwozO5mqfQo+jn99U6d32tY628dkz93QuuSrJTSTTPQOiZkEUqFCn1M/ewx2Y1mNIPItsXnnh4goWmxixItwQJnu+/Iziu+4GtfhuWoWmmqoKyiq5kkTmVbf/QCxkVjE3g61lPnErjInrJbmFfAzT9i7tbj4WwIsuKckH8YMBC19eWHIUZ2EwhPf0LsX1zgmuiffpneK1PY4vpbWP7yLzVyR/pmAslrxlgWFSRj2e3FR6On5PGRyNTZnsWGsxIuZa+i9JU6xafLXydwQTtqQkb40mk0lz3hhp10z0W5PTyL+VRN7txeJG8RwyyYl+mKnJxBCniIyMh6D6R+Zsod3IdiheAt1HMNnVOBKfxDuRnEmYDMmlQZpz1nel4eRjFjUWLgzFY6Jj6Km9dmIiWJWWTcJOTQltJmikiusStU4jxkFf3zb9sNRe6RaReT4Eg5yKG5luB2ZyMjzDXi9FCdD59Le1WlME1KbHYx0tKJzZk96JiT5bpVhbExYAFlxIe+cy35aPIe1Vhj1yzpI4JjkZjsZEtVH9NslK002RF23aLI/Z5CQLVDxGVj9/0+uGMFAyhZPFzSYeBvveiYwZNX01zyTBzgpBnKxL0WIBY3UUSa+rSs3nWjSNI2n6uVJBVkvpNqFMiJbcrC1WUY6CiC6GFK0R3zPKYxItJalWjAg5JMuC4F/I70io4fbnUVhx3UvuA+HOkNaT/Jnl6548TuTNUeuhsK7ZZVMp/0lsb37MUUVxQwTUdY1rrrkG69evx+TkJF72spfht37rtzTj13tce+21WLt2LSYnJ7Fp0yY88cQT6jrPPPMMtmzZghUrVmDVqlW49NJLsX///ufcHl7Q2kB+biBp2pGc5iL7mDRtxb6Pk5lf0Oj3UhuCIAWmydhiPqboA9q4pam3TauVFon8WnR8i9mZ+ApthZBSP1xaDPLryOvlvvW6ThpujrY+kKCQLwLUf5npUlkXoCIB9DVbprKcc7EwFKV81tkFhevJxpTYzscoh5boFbFJczsbPmKrNF4tSFr9mdR+lADgUt6LcEIiFma5BfjSMfEPeikddvKPV2MzSgbXQ18Rzrgd4t0ghLDSSJiNmwJvZHIO0TMUSZl4o5f9nsv3LvkC2XziuasijeIxIoKBBdM8gsZmmzOFqgprmBTqWICiDZ6sbxQu6Z0OnYx9pzTcsCa52STviNeITEiidsZzVfZQgBMhsXuOnjlFetB9TMZ3ofsMhylJWtS2w7gIpUVYRyR/IXexcNpmUaiJ22uTBZYFa5UJ1af1cZwbAYicIck10pwidlnmnKdYhC7MgTSPghAWFcEWcuRRwyITFICjICz89m//Nm6//Xb81//6X/HYY4/ht3/7t3HjjTfitttu42NuvPFG3HrrrfjYxz6Gbdu2YdmyZdi8eTNmZlLp3y1btuDRRx/Fvffei89+9rN48MEHcfnllz/n9kiGMAD1EiCXUIUmrXyp3ZS6l19sk4q/8EZRNTfp2AgocpckSsUEIdxGV6fNUGrXWftgrdZwJTijXjqfTJrGxKxxbRYLIvuMRtHS0SQsqXaoULeMeY1Mo5X9INOj3OgkESp3r9BmROZbcm2IY1RYaGYRUcIBEKwDcl4QqTMLpaQFN4XFxeqCpJURa5zGQo5HLTbPHE6YmLmRwoWTZZ6U10z/ZNdlrkzsqywExlEQyeQMFjrq1DdZGVEKDaQR01gRbAjnzBfoVrKYnG/5Qi61cCmAZ7k0eLxdEkjYjG0FCTZGHVAkA1XXVMRcEsSiu46jA+osRbFL1oXgehtw+7g9xoZ0zzHjJYWvhiZnQqII4wbAGTfZrC/7Jd05PkRlucGwtVS42ojF7wbEfdushhwFJRUjkwpCSQGBw2BJcBVkVw595dwenjV+n60d1A9jjK76mbUZEBYR0Wb+jtsuqgfLPtMzk24NUgaKC+KQmHdh4aGHHsJFF12ECy+8EC95yUvwL/7Fv8B5552Hhx9+GEB4KLfccgve//7346KLLsIZZ5yBP/7jP8b3v/993H333QCAxx57DPfccw/+4A/+ABs2bMDrXvc63Hbbbfj0pz+N73//+8+pPUk7EZtgLrkCaUKyWV4kY4mSKV+TCVpRmIiJXQ4Zq8vhZZkbYpAkezoOgJZ0c40+07hDm+PGRcc5vdCqvuYcjdiW1g1+Du6E7IsWhkhDtrzg0ILAGRRlsheR5rdxi8ySwILbXBDmfNKWGlq4IkUJDTpqVkQAAxH5SMhrM4PKYmNSEyf/bpsG7fXm3xh7ElYkc558vdJaQF2oqrQQVrbxfeO+0sRvdCZBWeK5zQLAFjdFzBNjIJG7FFw2F+WhDTdR5o5qm4vkUsnmtHL10DVpXMiVA6QyzcQBISGPrXIVf8/tyu4PCIFcaMcqqoIUFeL6AMnFRW2n411mGRA5JVR+FbJSkf9fVFZVyK1xbJki8ikJHVnKZLp//JECpAqNFG2RllwO4RbWIR6TWPkybeZNy5EaE+pXbtkEdMRGBkXEjtweRAurIiMvEBYrwXHehYWf+qmfwn333Yf/9b/+FwDg7/7u7/ClL30JF1xwAQBg586d2LVrFzZt2sTnrFy5Ehs2bMDWrVsBAFu3bsWqVavwmte8ho/ZtGkTrLXYtm1b631nZ2exb98+9QNAL14mq7rYajZvPgVOlkMgjUz8zylE55JQeeHINCYZDijarNLl5vwBa5u+O6v9glqrMSnPQJsPm4iatGjUaYNXkNeMiyKREYmslo4Vm1LefkATwQYDtcC15TgIAsAcJsgcZOHodmA63RDnzl02DX+3SoQTNWsmkMk5kD/jaNpUZlkpTErTqtDg8mfeljvCSHeC0NiTFq+tMLoKX5ZrgzY7Msfmro9uIto22gckKwr1CS3jnrsKvBDsrNH+/Bx1zX3k2g0yzFO6zGwKy2VuhNS2jU0CD22G4v1PljwxR4UlhnkzRuSQyIV5iGc7JkJFWTWjAAPBHWJhSwraCBucnaBoCLIatbgnyb0Tx4HDX+U1ubHSh98u+KiMkwTBBVIRUvR+ZXMxlbQW+STk++xiGvOpyRSd4mNoMKUCl0KjXIOca7qOjIm5INqtbcHS47V1CdREnyydCwU/Tz8LjHmPhvjN3/xN7Nu3Dy9/+ctRVRXqusaHP/xhbNmyBQCwa9cuAMDq1avVeatXr+bvdu3ahZNPPlk3tNPBiSeeyMfkuOGGG/DBD36w+YV3YGZ81J54nA9zgiRrRNQUJfGQiH7x+qzxE9OdFi7nYcjE6Wr+3hgDxLC9pMklH3XWED3Zx5QpBsC+eT7aiBChqoLPr0WmQWW9iBaVMRYNzX5GktaBtEhbA8hhtrZ13LnITlU1hRwy9bqaXQqeIgLiGNteF24mu26+qedaieIhOMB2UluJtNjSzlYBqqpSjoAYhif7zRElfLvxwo36n03xVYpiicSwVo4IucyEZqzaCaFN5tYO1qyh+kPtlSz1ZKlxLDDOpZ0FvoQHjIvPWvIaQlt89Fun8QoRCo1h8j7MMZeSFeWcEuLA+HxcRVQMC9bsw84tIHRNrX0DCPyeeB2+LvMihBCrhLXAGSJtli1HxEkYjdK5zgPdSl1nXFnydJDgizhdxVNxXxCEAo4+6MYqoL5md0EY/2yOCJ4Rf19Vysrkc4tfVQFulN5ZCSMSj0VBztS1XregheRA4M103MzKwsTKyKNS0VzUTuE29N6Pd9scBcyHZWBJWBb+9E//FHfeeSc+9alP4ZFHHsEnPvEJ/M7v/A4+8YlPzPetFK6++mrs3buXf773ve/pA4hoJJKAKHOo0D4kAU1lQsw214aPVloWZLEm1qxsoyoj+e84+x/Hgv8Qk9cJX77zjeuEynjDhjmeh6DTaW5AbW4bqaVlhDk/TGZzlZFNukbimEptzc3MJAuNIvWljHAwhn28isTkva4gGT/jqAK2ltSJW5CPce5HdSF8TpP94uJ4UKSbJd94XWtmOZloqXzzIdwr45ItUaVSipYxuRVKHluLSoN5siQIQScSe1ViHh9TRNuM3xEGsPmZtDC4ZFFi/z6Ng2gbw2pyK2uoxqQFPI5fKy+nTinBA08gC3McDJl/03TVpc2YK0Vyl3zabCPxWM1/KZhQf4QLj98rm6I96LeN5cUBBD6JcCUE99EgXluQWRXXShNmCcqSFIURTxaaTBiWzwbDYWPMeXxyi5QTbZKWH7JA2TSHeHyoPdn7k6xkNfyoFoW70vun0qmL61K72zgHdJwkKnoxl6R1SmexjOtR4SwcEvNuWXjve9+L3/zN38TFF18MADj99NPx3e9+FzfccAMuueQSrFmzBgCwe/durF27ls/bvXs3zjrrLADAmjVr8PTTT6vrjkYjPPPMM3x+jn6/j37GFAbi4mXiomFi1jlaICYngGef1do8wVgYm3LIK6k8ali8OESNz1S2fbNtNMqjNbm39JnnL2yOUv1EZgAAVC1JREFUuoZv4zcKQpKpLfcb3gEVJYeiz7w6B90OzGAQrFwcR+0hcxY0rA2kjbp4XDZO+bgy8U+OT2wjvdSGzeFNS0dDIxX38sNsvKSQNhjCoAramiDRqUUk147j4uOHYpy8Dwl5Dh7k+4YNU8TCA8klo1wxydLE1gK+VTYH43gYJ0y5YoNqjQ03ifTKOTCMDWqIr5vjTudTm5xjPoTNrFLcfx7bZlttL2miwaBX63tFN0RDAKA2UHZRWSNAWkAkSDOvxQZFzaksXBTYGjAWQKy3YTu8wYbzMlegH451t6jNRbohY1t89g5T9kY/HGnOC5nVqQ3dTiAH1rVWH+saPgpmQXPONkSab87OaeHh9sdaJm52lrX/5jhFWLGOAOK35QgjyFwmkuMlXReuDtY7QptlzOYh6JoH42uX8tQIC24iFAt3B12i24GfndXWyxFVFjZoja46mpgPN8JSsCwcPHgQNiPXVFUFFxeX9evXY82aNbjvvvv4+3379mHbtm3YuHEjAGDjxo3Ys2cPtm/fzsfcf//9cM5hw4YNR9Q+tWCSL0sdkMyUfGzWn7ZNXJGL2q4XhYsU8y3ISkxwFG6O1sanz5V2Q8gEE05mQhoWRQBk5mcmgA6GaRFsI6rFfvA1aUGUhMOMn5AITvH/UYtvkc9zasOjz3NWP/8tOQu12JgyroWqDUHPiTaaTPtUVpFc46C2kLYkrCWNCADv5niOTvdrHLxjgiNXmyRXh6xPIcBRLESGayOs1XqjYbeCKAYl608orbSND0PH1G6sFQWRHOeHo2RVyg9pPU/zgJjwKTRk7zKGex76Ge/fcPGREkAWxKzP1Ka0CZq0eTn9vRIU8wJvJDSQ0DcjoiXqmKQoq80ACMsTnU/CbauLKUXf8DOXSa5yYUcKnkMt6KixBwQHwac6EbxeuRbhT/OdcmsTv3+jkVoz6Rm09ktdW5Be88J8bcpZZunywwH3Yew7ehRRCI4Rb37zm/HhD38Yn/vc5/Cd73wHd911F26++Wb8/M//PICwmL373e/Ghz70IfzlX/4lvvGNb+Ad73gH1q1bh7e85S0AgFe84hU4//zzcdlll+Hhhx/Gl7/8ZVx55ZW4+OKLsW7duiNroJwcuQSeLYBMnHJ6I2jml7fNz/LrEoFujAtAXa43ntnLbRhnsRBtVD5OSulL+SLkhi5NqjKEsTVqpLmx8vUzCw0LBsLfy6l381A8IpUB+rkQv4P6JarcqftLtw8LPEKjNSl5EifQUkxuYUqVxERpwnR1Q6tngYLY7nRePnZZ+9QxbWb+eB0WClpY5w2Q399YnVskJ5qS2VfeKyfoWaGh5psX9RFpcwtJeAR3B2gQ7DilcoPcGcfNGL1Zk3sh48yosep2Y9uFdh7Jia3vpIzMkONIzz0bZyYLUlImapcYX74//S+TfUmtOOZayCM+pOnctJwHQK8dKkLEtv9uuQb3A8KKkln/2qwSjbTfEupdFoqEbF9OegXC/CLyruBBNEiZPou4EMfLNpm2d5kuUWdrgxBiSFgsODTm3Q1x22234ZprrsGv/dqv4emnn8a6devwK7/yK7j22mv5mPe97304cOAALr/8cuzZsweve93rcM8992BiIuWUv/POO3HllVfi3HPPhbUWb33rW3Hrrbf+UG3ShDgxacXEVLHVAPvamYyUQ5rlyEdnTbtpTfrryRwdXyY70QcmJ2AOHoxmV6G10bHj+tVWlEdo6PLeJpLiTK8HB8DPauIVfB1imJ2DH4kEVCZmc4sx+vJFtL0u3Gwwk9PY5eNIm6IfRb90ZYM13rpIjkLaSOM9bb8PV9fhmRHng8yZ3W6wxHA/oy+fkhFJM2Q01yrClM0EAVuxQCLdJkxSFAuJ6fZUdAKPa6cD9HpBy5X99jEdrSDHhjakjH7egYUO5arINwUAptfl8F8aT3UOkPraF4l/xBzwDqpYk9JkOx3AhVh+2+sqbU1l3CTXG7WZ3E81UgjsbDMXBo2xG47C8+f2Rw02bgyBjCY3P9GOTosgXVWJvBo3dOJ2+OnpViE9bVIxadu0S0Q/AKbfhz94EN5J4UJuWmIeAaEo3WAIwMH2+6gjYZDWHm6D7WhiMglDNA+pn1WV3JpUd6XXC+1rq6wY60KE94uIfhknRvQjXNtEN5u0NlpxfHAvhoRuMdx5oh9SoVO/jYl5S+q0TkhhqKoAhLHm1NJUS4XeWcH7aETLtJGMGy4yF10pvnmuVGAi8dH2+6IcdiIMh+Mbt5t/LFI3xLwLCyeccAJuueUW3HLLLWOPMcbg+uuvx/XXXz/2mBNPPBGf+tSnjrg9pJ2RC8BOTqAWOeGJ1KcWExMX0tEQMB62ygrjVBUMMbhHo/TC1XKhN2px4vPsCMzM9SF3eiUmLwCgbtOIhDkVSL5fucgI+LqGrbqQbHFDJCu5SUqIxZ1y+QNIpMzMH+ho0yY/s8z46D3s1FQk3SXTYnKNOB5DIGov8X5c/yFu+MHXG5IumeGQn00ja6QU4OI9QvsprNUklwEJVMS/8C75MWN7fF3DTPTh9w/TOFB+CCCRUQFNlKtrwI9YeLNxk+fwS+ESoWfL8030w9d1KPgzJNJnML+7WizuWbSKmZwEBkO4ffuSgBXHgN0MnU7TrUAWkpZ00UlwSQKP6fUAIpsC6XgSnEECVyc9A2ojRSoIPz+1C4LBzs9QzDuqsxKEGRsENMqOSIITEQY7gnDK4xw3U0r+RVEfHNERvvOzsf4ANUPxPawaN3gHzzkDsqRMgrvAm5Q0mWcuNtqMNcFQRAkRj4aTHYXnnzb8bhJ0hTJB0Szs6iQXHHEdUKU5Gectl7unGgo1+DyOjhFchaRQWOZWsOuV5pogKVukjZ8UHz8cNZQkGSnGQle2vpJy50fZmkvKDq0XsQ9eWFCJc3Qoi++8YZEKC/PuhjjuQAxe8lHVIhfA7GyTKCYXXlpsMmsBFdthbSNqAW3mXb5WHm9MCyqlL5a+dmVKHOPeqGJVvdy8pzTjlhAjYqLLRZraRt9T+/INQ/5GdJdQ5kOhoVO73fS0ePk9n9NmpmeiVA5ZLps2ZybRicWiJuKXGH9hDueKlVWoqMjVD6lP0uRcxXoOOVMccXEjwSCm8SX3TTLXkvYW2uryeUYbbt5f6ZYgljm7RGwqhd3N6mBIs68Plh47NcVjxFYfWpBl9A6NT9Su3Mws+5WTSXyM+Zna6D23S3EWaDPJ8pQ0+i3nFrn8mDQr7m+SO4lJiZQ6WaTwpfTj7JrITfSRryAtc0x8I26IsSmaRnAH+H/xnemE+g5toY0pB4RNZEIRAaDqzQDMd+ANn/rdFfVJFPkwXodqbpDFw6Ty5rpBybJAaxf1n91jpI3TveSzk1wgGkOpudP4SveAEghD9Vvb76c8C8JKYScnoKKnRNtoLLgeiXg2so6JAruORHKo2Ka5EsEVNLHkhQW5eLEm1eLf49KrLH0LwYKJTWJiZsQ70+uBS/Y2GhF92yMRRigWam6LicVZ5KIjNxb54pKFQH4mFxHpDiBNgf7PFmGWsvs9/bJJ0iIPVBJqqJ6F7fd5geDsaOkBqHsBAGwo1JVHH3CqWlrwuiLDI3EdxHioc3s97beke5sgNHE4mbUxnj25BNLhgoNAixCVse32wkLX7SaTtyhGY7odnaxHCQ6ZCZsWcsHbUEKsMNuz1QtIGySda7O6J8Ymol/cxPONOSX/iXO220ua4WgEu2wq1emQWfGyDYHTa1PfXNjolSBDAlxWY8Rn48TJx2hOIWmKuVCpfO5CMDbLl+m25CBLoHS50FiKMbKTE/z+N/3s8R2kqITYF7KeJTN7V7tLbJUKgAEAabZGkKizbK2KxImg3ScLWSboiz4nkmmTZ8VRFl4Qd3PuQ7RcULl2GmtK+uSFBZH6RM+bC1fRWpaHx8b1gS0SMzMq2sQNhtqqSCBlgcahYcUTFgf5rKIwRgXFqC9w4r0wtjnXjzIWK8FxyZeoZhgDOJHPAFA+Pc79rjL1OXhnYUgiFQtZCmEKTGhZKjb8McfTlOZy9XcwhXO7FFlQhAtJyEUmi1QwnU5MShPNqcSmt9l1SFOfntHhhG2aiTwvjpmKuiALAI1X7j6hywwGiuvAC7nsM5k1fQ0fNR0z0U/EJJn1qM585OK+ahERjPLgkhECX1xwmGRXVWFM6LkAMENhQfKRVxFN2UY8R1XbICea+RiylhHs2D+OOI9MSFITTglhlHAe3sZ7uDpwPsQ1eKOJwi9bwCjUbjSKQphN9QFM9N13OmGxHg3hq0pFFaT8HZoMy5vPaMi+chVumCf1AlIfAM1+l/5rHo86tZ9dcIkIyaGTB6fTBh4VAp/P8fhe8DEkJGPIY07RGmGzj9EFNH2EGR1YFs7tBG6H6fVgKG+DFYK5NcCwhhuABbTUJrEp0rvNm58eMxMFCzKp8yVI66aNnapbWhOiLvgCFkYp/sH8r9xh4pmld0m4zIyHXTYZwobJjSQgLW5hHlpwci0SXiMvhgpJuT17OSOu6faim0hr+jpzaLTAIINzWmBg4WSUStH7UAae3DiGxg9doJ7Nr3j0UNwQxz/CZJRM+2wxMZnwgCi5d7vNBV+cY3o9qI1K3VSb8FpDmETYF8Qi1tBIpY+urjFviUSEv7k1kc1hX8ewBietN9KsSEmoxoXPMdpITt5l8f3ZM1GC05hr55nt1C21OyKZLD3/NBLGGJuel9BW+PwW7b69j+OZ6wC0b5uJhWjyTigyRwpwdLsoKLE5Nm+O5B8Yo4Rpbg89C5lYKfqFm3UYdDSFen7yfSEh3IuwYUW0owuadC5ZHWLoZB6xFA7X5mxlgVNaKI1lFH7mijDIzieLEHMReMNvdw9yQin5FXEukISf0K42Yb3Zz9QskZr6MBn+ea2c1rmaz714HFlLVSK4rK15/Qi2enivLXzkGmE3qFg35fnKVSrcN+xak2s6WcyGjWtSW7hfc4xrQcCSFxZ0IalUOhVA82XMTXK0YEWrxFjY9tA3vqaJ30s/s1yAup0ULjnmJWn0i3yy6kOr/24p28xFr1QbBRtdLhZtAlKrtSG9qCq8rq2QD7t0mmVkjdyIWoUzuVBoIaQ1MoTghA/YWhba1DgYmyIUyCUgnxf9ripd+Q5IZnvhR8394WP7w3+LBUu2S2rpNC5W+JzzPtCckPNJLoSNZyyelxSSSGhVVrb5EU65jeTKkVFJMoyOnoG0NuVt6Ea3nawXkI2J+h37QuOoWPqVVZp5OHbuPptuJ6UGp8iG/P2m63jPXBk19+Vcsy3PQ2Ic3wNhbIzk4vCFTBKuqF00Xpk7j09R7bPpXHksWfvy9ZTcNaJdLIB6l/g3bS5bYM601srVK/qeivuZ5PbK3bMkWMh5Lb9fIBjv5+VnobHkhQW5gPKLpDbtfEKlxYoWSHYBKL87sa9zASOeH0PXmFQWTWmNHAoUmSBBL12DAKc34tbP8/K1wlfHZEpa1DLYqSnl0w6/c23Bp+vGdtrJyVjSWyx6gpOR4sPjZk2Lsrz3BI1Xd2zfSPtQi610ObQJMoibE1kMovkzhZKJzSku8naiz2loLYUgRmGAannoG5iMIxIzTRKvIF/AbSR4iUJhzMmQl+10OFQzMbZdw8/Ox4sNgclwbcjC5BiTE/w5E/biJsd9IIGo102bsrAmNfoqj4kCrE4WlqxQJpvfTKCTfYxCMpNRo/CrBI6pSRYMKRW1yd8p72AnJwKhrtMJbe529bipTKWC8NjtwIgw71QlVmxe9I6pEOTYVlEgyvT74MyOdB49g7zvFDqZc4iofQBHO5nKpvuQW7ISwmTkQEnuh7qmtAxOpr4ymZnmpBQqsrXMVBVzYNRx8bzwjgkBpqralRlp+Vg2pea+eo8ln0Wek81HnjtECiXy6ELBz9PPAmPpCwsxvJE299ZUs4gTR27acsLRiyHJhlLbqV3ahMn0RWl3M7N1YsUTYSxMcJfHLgMpE1wuqMTrpAQ2nqV2lb0u11ydCwQhCgsjCDeEm55J9yI3i3ohm26cwJ4PxEYeXxMSH3G/4mZLTPs8+sFNTzOZTz0jT1pJZMHPzOo+xmM4jFOCNI34vPi6xC/JTPS0ifnhKJjEqeokbWYU2jc9o25Dz1gmKiLyJlk08jbn5XiV75jmUO0iH2aYQv3IF88CWBJSfV3DHTwYrnXgQIpOofZLIbHhLrPw+w+k/AQimyH1m+4DgImURpD9ck2dya5k3YhzkK08cVNiM7F45yg9cpiP2h2XUvs6jrbgiBmAffVaeBMugviZm56Bn5kNBDiad/Tc2iwEUbAJvIbMnaLIfM1qn6bTBZFnqX4DvA/vIiByjbj0LMU8o342LHWdrJJq7Lf3PtT64Kb7WKo9WhFjbQ2O1PEt/aBzFc8rPp8otCjhykYLrJzX09OR/Crcm8QNmZlR7izqoxuMIUkDcPsPhGvSV+QOim4gCrPmCpMtigRFycjMrguJQnA8TuGdDyn4XSDJsXQOwFO+BSAje0H4VOOCLUlAzPhPfkj2d1IIodqMjd6sxH38cATEzVuVQwZ01r+8X5JQJ68pCHvcJ+iFM5kEx8w42oRirgAV9mdEe4jnobgfYnOQZj+C4CrIDZR8oLSAhf/T2IU+QG0mDUsC50yICxOR+kTcuhGJk5r9jm32Dn5Qg61SRGaN9821EEpjnEIxY3tHwpwvtTdX6zbwZqo1U1/H+h50n7hJGm9C7QNxLzV3ITZzQSJVBXRUB+LcHSD54KngWOxzwx/tnE7VyxqttrDwO0KCIo0Fbx5izEejtHGQ60Y+U6T2Mbc1chaM5D7UTjPm8wgduo438MaGEGrnYVDDR8GCz5H1SWI7g9AaBZKYhIjXCB9ypzDZkoTo4SDkORmO9LpDpE4SpnnjFsRKQgvPh0jAKapC5K5Q7icxJ41JawOtWRReGD9nAS5mLWXSIvXNxMRgcrOld0yEvYbnrTlZ3vvAqbEWVI+E7x2jmlTTc8Kj5HXQc3V+7KZvDEXZhD66KKBR3oX0fcFcWPKWBTY9R/OT9KNzjLaETws7xVAHU2VX+MLIXxw1tuhakFqWzN1PJmbT66W2RFa0nejDLJtKYYJGZ0/UnUn/26kpmBNOaHyn4rZz/kFVwS5f1vS5S7OeGBPT7TU2IcndoLApGQIpNQ1lxierTDT5MpeEx7CnQ7TIr5jxMOzkRDR/ZqZG+kxaYuKPcil0uynPgnJ3WCbpmV4PdnIyuEa6XRYASdvlMTIht4CdnNChccZyyuEwjh0dShetNdqVYtWcIWKYiS6eYL7us8mU75VZiOyKFeG8E5Y33FtkHbO9pqvHWBPmRnyedvmyEEaYW7XoOS5f1kgDzHNB9tWnuWw63ejiEeHB3qd3pkqhoPwssuJwphv6zimdJ0R+A/EOhARskzwuPBfkPOv3mftBz910O+l5WTHPSHCh5zs1me7V6YbnFK0lcnxzQrWpKthVK9P7PzkR2hHHjM/r9dg1Bx9DAOM920DvlO11we6gyXQ8r0FxDlQrVwQX2eRk4z3kMaMxFRYpG10SfI7kPAjLGodT0vPupfXNdOI7s3wZWyrCZ5PhHZUWMHqXuB8dboN65jJkl54bRatJV7FJWUDnquB6VLFI3RBL3rKAGMYW/vQqO1qrhAogmS0dYHwqiywldtKyAaWF8eVk/QAKXyMtQpjr/XAUTGvSBN3ueldt9NPTWRy81hpJc1LjENuVKhKSdSO2hdplMsb8GKmbwszC/ZAEHaFVcepZdkNEbcT5EMoV7+FmZkGsctPvB81RWAcCotm0hW3eaK/QRtlHXjvAD5I2I60r3gE+tn8wCM+LTP/SrJoz2QeDxM6XoWN1sog0LAu5mTren0MnSbN0NrgV4jhaILiKiLCZW4e8gz9wIPYhZd1TY2RMNPOSRu9V7gR+HgcPZgWRsvE+OC2Im3V6Z2gsc+R9bvTfN60BxsIge6+GwspBVj+Z4RLiGbVESFAJdVNBWF9s0vDj+a2biHSbzArTPLlDOFxSjIV0E8U++Wf36+qgzjXXJGlFIM13eobfEdUm4V6hXAy+rpW5Pje3U5bJ4G4aiLVgxMITzR1lQaJ2xzmtUkVL6yv9LUrKhy+SBRUiaZsfDcP747RFtOFalVFg0pI2FFl4fcucideSVhMVRr+AmA83wpIoJHW8QaW19S6y2alUsw6XZC2KLAsyJhoQGor2oTIJTYaWSU0/NCSlwpVWCdIUBZtXJZ7JNTsiWfV6DQsBkekAsIZBPAOWpitigVOuADHraHGlyICcXSzHyMaogFyLlhEKLUxrynTJrHMxDiDrgOyrGE/WjqwoRkTaSlf6TsV3sU1EvDMmEN/If5wSAmmiVbhlJD1K94Dy38usj6JAkCCAhZjuTJi0QetVGlNOuiVSofIJh3bbiX7KYqfmrxWRHFb3iZ6NOJaeFcfCk+Ut/mbN1goyHLWPakNkjPhGIiWa61bwN8RGGDRzncWQx5OtgpbnQopqicd3u7C9brKCyLG04n0SfnUTo0lMr8scC7Y2VOn9go/8iowQaqqqnckvBAMi/EqhQfaJNW1BuOTfcSzIYpLIrXEtU++jIDZmY2eWLePPUkSC4N/Qsd2e7htdN/7YqanGM5XrjDqH+krzIVpNVJSU4n8lzgK9W7bf1+urPLdtTQaCtU9YkOTakYfwkhWSni2TpheS5LgIseSFBWXupY2NFqpJwUruJvMkjI2pjKMGl21uvBHHc1kLzbUR8vfTwk85zoG0KAAhzE0yqeVCohYgbW71g6FYaE26LoKVICyIvfR5HbIYKoKmDeZY2mDJzM9apnjxaQz5esJfqL4TwtRYUx8R+nzyoRohKAHpJacNzNe1TgMsFwEyfUphT7p8OKzLqvTGDb+uIJ5677VJ1FbB/J65h1gAIhM6XTtuDLbfdHflZZRVng7S9q2BielvaeOoli8Lz4uEpEygTGb8cDwLFjQO3nOmPRLyWMDohQyV3vlU7IdM9G2pjGVkEQnLcex4PGlOuJrHiNw2ytTc6bLwGU6N49Hmh458neCm6AULW7+vNzSeC57nsHy/uSaE83E80yaa5l03RQ3QxkIcEKqzEcfJ9Lop0im+eyxg2YozliKOs3r+Io+LcrtQGWwS5E5YLlwN6f0CwOb74LbqJAIhoJQImi9cJ2RqEsTDkNdTljoiLsq2WlHUS54rhc/IfckFeRXNMDkZnmVVhXczS5lOz4RdtEzEDAKHUk6kUCjnHq21MUxXpqg2nVg/x2QWm6OJ4oY4PsEER/pfMmlnBQFQZEWDsYmxDMAwczaYuDgbW6cLP6wTASwjqUlzOJk5A1tXmOsGAxhRXAlAupcgFrH5jv4eDGAm+nA0wcmULBfZyUn4/fvD/1UvuUFk0RRXww8ct9FPD1NKVjI1Kk8AaUpx0YybAJv4fNoAgOReaHsuLABEn6yPfeSoAkneiuQyYtMTIU1dUxDZvHwe0e3AFfSYaOeV8OYd+aaF20BoQfAukNNosXM1PKpgxp6ZhRf9TFXtvK4ySM/ZdoR5tOl6MtEF4mcHod0mzGM3PRNqMChzMM0z4S4ZBlcDm1q9h5ueDs9tehpkglbnTM+kokGjETAc8hip5nkfNo1YxCkJolFgkyZ4WrStyAgpSXpMWB0izxvCQkwca+Zy0IbmAuPfR/O1yuAIsKspkf+iu0SWTs/mpjt4kAUoNs8bqwl7gg/kB+H5VBO1iJAI7rIg9IWN1s2kjJ3+4HSYw7HokScXXO41yYRsvz+4mFRmRpc2Okkc1injwzvcmk784DSPNZ0bvkpuCAwFmTjOK07HDavcN/xOxTEzNs5B4br1M7NBMOx0Qp/IhVPXwW0xGul1hkifJhAsQ4XNOrXbyHe6xQXGfY5rmRhXPxqGdVwmxjvKKG6I4xR5PD0tBACCViIhOQHSFyc1cXFsw+9sWoYzaolsphZSLp8jTZ3iunkoXeNvRZ7K/PjG8mIPEnaiptvK/DUmpYIGUm74cSxhOVZik5ZkKZW9jTZx4V9toC3nBN+EtBybhBgZjkX+dzke3FTxuc3TAAuLTmaFUrkT4rFcXwJIc8qF0FkVOknsbFdnm2MS9uZK9MWhlC2WKNqgJDmQNeipySQwynHL+5vP32j2VlE/gtPD/aHnnFuy4ibKbj8gmZvJnE8Qc8KPhlpQFy441hTFu9EQPIfDGPaYrhFSCnuo5F7Skpe3I2rRUigl333j3cv988IVxX3K+E8A0nOqYxp2znqoXRwcEiu4ViEaJ7jPlKsTUaD2YszzPtK4SSslHReF78YmS3OpisRewSWRRZwo3Lg1CiFbj9QYCbeDFHKocNvY5F9kLc3dBbGgm3I3+KxPsm/EG2sLey0YiyUvLLAmQIuWKnTTsoDQcVWVfG0ZUSrnJtCLl28sre1pIbZJTTe70fiOWdu+6YoNXpdvjsl8nBu7oITuiA0w41fEA/SYZRyN1AbHi33j5c9dG4Aww7vm5irb6FxzwwBpGC1tAZLbqbLN/puWdpDw5vIsj8FXnjZKIQA53+AyKAuJ133Kk0+xoJJxEDh6R5puO+NZ3KQppiJjOppE9UVyVuS4Exk3M/HKezYEjRZ+ihY8RNGwltBNhiDopo2e2pXcNckcLTgv7K8mq5dwK1FTqyTI0v2olkQwh0vujR0vvEohBOCwVgCqTDfDtgg/JnFpGhubEUItzQkSIOW1ZRKk6DpL7iApxLj0E3k7QZGxUOZ7vm72Lnk97ppXlZ0rBXhxbOC6iDkxGmn3FZCiK4Ryp/trG3OPr8cC3NybP60V3Afx3BcEh+tmONTPAmPJCwsK0qc+9hh6CSz7HfnFUtwA8VKOWbgbkClppQafkds0R8C0T35j2hddJiXmfvUKeSW6xvVEKuU5447jPVTIJZXzpk2K/m7cRrRNLjQZiYwXNZ+up1wtLQLH2H7RdS39ZAudPIZQibLj0rcunxW1kwQMCVqA24RR+l5cq1FbJNOig5/VByJXVpdBYTgM53WaG5Aioon5LEPfpDBt5Pjnc7yuw0bDvvCYmTPnnMj2RYGjVRPN5oG2RGTXqZO1JpVtzua7FRuiBJH/4vW9uJYqlxzHj4Q4Jch5l9Jpc19tmrNsFREKRc61kXyAqkpuqxbBKbRTvA/qvhX3l2pCcG2IloghnwniKcOqIFjSGIcLN7hBcqxNT5AXJcEwE3qbVg2fLB5kgRK8n9RoN7fmL8dxLuRKj2wboNbmhcBiS8gEPF+EBWmClItVFmevXBVkThRagNLEpBsh/m7dvKQvWU5YNk+6REBq26Dpng0TassCToJG1HQb9QnieT4XfGRbY4pcJnfm5jxjU9IpYXEJYWFa0AlM6WxcrG1NoBIIoHEBZg3MJ806amQcDdEiDHEf5G/yGwOpvfJYmeWQ+snmyczE7KK2SmmPSTMkrUQy0tnlFLVTma+eNHfhZmq4y2yVrBxxM+GKfbKNuRslK1kdjtEbQaorkb3+VTre9LpJUJLWL7q0SCtO4XxUHjlFIxjkGwWM4XkR2iIEgW5X1cJggZ393ZatLJzyWwrd0hVlrLYICkGPhU0jiJvS5SaEZXIHSdeKqSomOKpNUFpeZARWdLekSA5hhXHRWpbnZcg2SU6RnkX6SNBcVGndZf9FmXf5rjWsVOTuoj7LPBbxfHY7DYaZ20tbFWCsFkZojakqGAr9Fu9Bg2RobCI4xvMb/af3MFeyxrgolXB8uIpewdInOAKIEzdmphOxtX5mJk0iVU8eWjJn0180OXL2wIqT9TSECr5J2FS8S+WGw+fJfGmoFDP5s8VLSuTDBkjCp4yRsZ+UzIiZ13IMhNnNU9tkO63lPAshxwCSVtTCFPZywaRFUYybIvlJXz2dIxeZqoox5zXktFRmV7kAUe6KeF3T6+r0wrJ/8hox5TURCMNnRJ4Tm6uz8KiFT5k2ce3+CbwMyyls03Am877MGho2kFjaOh/PjGtAxCtOS1vFKBUp2Iw7n3zGLAjV/DxcRuZiQtr0TNJMAfXMG5kD61o/X+9gOpbDU/0Q+lkDIh9CYqor8upw2NSmCeTqc6HUMuVL8MOQ9VG9g1n7KYLB1wibvHcg1nMIgzRMsuNS0EjKQLJCpHGgdYTcKykFtW8lcKZ1xnPGSNoc5RzPU2zT805VFV3KDErjB4hCVBYYjoIwIMcykpb5PiK1Oa2PzTanNYrn/3CohEQJn1kd0uXEZ5ErY3tdTvvO64NzzdwY3qn09Ex2zNeunPvhXbKaqMaQAOs16ZnC6BdCa8/b/8NeY4Gx5C0LkmDnnVcZ3xTBsaG5J8lcmdqARpEeGfIl/auNdnRTaJXPFhRaMJQ/OudASP/k5ETyrUvzaDy2PceByAUA8PU4B4MxKTua0KZ8LuTQYpFlXVSx+UCrWVGNnQxVpJfWmJQISRTu4YUrLjam11NFuVQNARYqTNKGZJsmJtAwrYtNgTP5dTrqmfE5rHEns7K0jARimE/abBthK2p6DahF0HEODtvv89ix1t84V/jN4zioeRtzStheF9qaEUMLJyfSXCeNjpurTfEqDBEIeSO6HZU0x3S6Sbs2lrMjsotHtBvGxmyZ2m3RNi7kyqI2wwlNGWAXDIWYKosItdk7bV6P/BTOzkltltaIOGbGGtgVJ/C4cJsEeKzi+6LmPWUhRVg7bL+fKuLGfvjaiY1RVGrMoNYK4mmQ8CSsVSHvQ/ZeADqXA/fTpc9oHtAGF107ibOQ5djwybLEIdoksAr3JZWptpMTyXIRQydz/kCewVHxd3J+g1hTWHiTz4KebWyX7XWTlXaBNuDFWhtiyQsLVOEM0uQYYSYns6gEkZSmEiFg0tcL8EsrM6yxfzt3T8j7tXEPrAn+zziBWdJFWqD4HtIPGrW0nImdCEwmbWqx79xuqoiY+/t63fSd9KtmnAGW8mN2NrWZS+a0MYfOktZC6mSBydXNzTb65LmYT2aGl5uTel7eBSsOmWjJpy0FLantxnBL5ROX1iPxTPKqh5LdT6F+mg2eRddkG5p0maErmP0AbwTM1pduF2NTchphlqV5I11RjXvSYimtMCL6QfrzG3B1GjMjS42LTZIItvRu5fwJxI2n7R3JQC4Z73zMyhnJqLnwJaMhpNsPYFY/5UiAd5xDQLoCWIgn60Lu/pEmbZFGOK0N0k1huY8yVNELTZOJmt6JdpBbLJrbhQuooTnH9yW4WFqE0Xg9tgrJbJ4Qwo+az9EFZpNA7COhtz2yyuqx63bYnWQ63WRBINdLnLtUuC23YjYsFjnBUZJ0aSzlukm5R0hQlO4iskTKteBow8/TzwJjyQsLfjhKccDDkTJ1hopoMYzSkpkz5hugUEMTY+hV0ZyMhCXD6VhTziY0mfJz0lmvF1Lzxs2NGM3qWvEaeQXLdE1hzZDfD1NII1fVY/992gh4g68zM2C2gDQquZE2Mibcqa1KHgD2qwatWSSNot82CSccQghwGeFwjcxqMkYLDa6PuHlbE5691MLEYs73oUVQLLasmQ2HDX+1J23aZhtT7JObmeWcEfQ5h6aK9vJGQdcg8p0khGZhifmGwn2N7gSZwdREfznFw7MFQY4LVRUcjdQCmm/iao6SH5mfm+VzOHyUznEhLFEWuiLhydcOim2fE0cFZ4GEwjR3a138yIjS9GSBk8+IqjsOBqH6ZOy/nxZprHN3DwvsQkN3Xt9fWrJ8Ss6EquKqj/7gdBq3rK6Fqs6YucCYHyBDWKNCIF1HNB/9UJQC5zEQVoN4D+9E4SgSliIhM0TBpHEklwQJ7Oo9FOuBmiuDAa+ZlFiNeB/EdeHwUGRKEl8krTutgrlNLtjwvxAIBiJfi9fpo1VOm2Ng2l9MeF5wFlROdJKkATU5VF5xEyuqEeRmCaRKctHv7Gdnm6Wv5cbtavhhtuDStaanYaamkt+8Ti+y6fVSnvRMyJAlrVvvW9eAKDbkKb6bymm3jdMs5dmvAVfxAtsQBGhjypJHeQf9krq08HOe+Xh8SLec+V6zBSwJXMlqQVpCG6M+DxVlWAO4WOJaJo6Rc4Ha6ag09TAthq6G5w2vA8Pktcg9iOVxpZDga4gNKntOxN3IrE86J34NVD1+Jn44gqXNV3qFWHAxTMDkDVqS9mjMvIdHpf/3BqZCEDCitciaiVDZMp7vZmeVFkc1MegayoIkfd2SZFbHaptRKA9/pufM5bi5b1nZceIaCAGSruFk2fVoSncHRMIh1e4afhSfmzCZq7wWdD8vNlKaN6jhDhxMmzAJmZ1uEApVyGjYCP1s/EwW0EJ0n1EEka+5ImI4RLx3kQjJ/ZFj5D3CO1JBRRtJbkoWcsnvQRQa6f00lYWbHUb+SpjfsvaNoXFwmbAGNGowhPeDBJ74zpgo0PYAMzmhyY+AFpCihUDxfWgOEYiPU0dO2iitucyTGmoly1ThuFQRdIEyN9L9Xfg50mssNJa8ZcHY5K8zNnNFtIZwGW2KpL/zfOzCN85JeNp803RNxJefzxUm5MhyjgepIlPjpF1lytUdTm2SAkyureTX4r+jibqFjMl9EX7rnJWcX5fT48qFvK0/nW7qd4sFhvswFBrpXJCmSKFRcFKoFjeR7Cu7ojKGtVqMaQ6waVpwRsQxOrWxEdEvcpFsajYNDW2udLTSnBqjF1IbhbUCEP70MfM1biINc6+ASpXNJY7jZpZzXZSQnEXC0KJO1yVhUFpQZB+pLRmvRwniJEwwp8e2z9PoMuH0v6T1Kt7EGF82k2NjX4VArxK6CdeV6QROB2J69XQPHfPP1glJUBwMhPWy/bkFK5yYU5lAJa10PBeydzYnv6YLxPcpWz98/jwh1gVZsZNvQM/FszCT57xgd2JoYPNdb1ubyLrZRrBk8meV1ja2hlXJLblQKG6I4xOezIO0aCjGeDbi+USjicuCQ7YZssVBaP6sGWpTOPtVW3y1ntKhxnuw71VuJl6/CK3SsBfauMmSIZng3mB/dxuc09pg/ltI+9w+0rb4u9RmLqAkF+vMtcKCVK5FSlOvuD+bWfONNF8osk2S5wGFqknTdOxjSuCV3FE5yZSrdsb/pftK+UKFb7uRMdI7LUDl7U0XYUtPSBPeYjnJz4nCVJhT2YabbebpmXjWzr2LqbcpSyQd13Y/8tOTfz0jmKl3wmWhl21uIynkUFtHevPKnwtXWcwrI+bvurRgib99tAp5sfkrkh+5SVLD1TjwHB8OUxtE3xpRJC6ma5aRG2LDJf4CWbeo7b4W6blNy9hJJSGOT4NPIAU6qryYZ2BsEdKV1Ug+H+HKUrdpU8IIxnDkEKfJp/Pi+6mraup1jN0WGRoWCrFupGcr3jlat2jOzdXmAgDPA2HB9nspYRBpGzS584I8gJr47BvLMzhSbnoKzerGmvbS55yBvwfSpmor2KmpwOgW/ufkx8wej/zfmmZYH/0dtdlq+TKWpikSoi0fgQy/ClXgKqUdKBY2awxpHBux/cS/IMIXxXKTxkTRA7So2lBsyUZynun1kvYr2hqiLgJhzvb7Suvk6nfy2Pi/6XZS5Ea3E4itdJ9YuMd0OjFKwKlnwAWVYjsMRSVE+LqGmZxEtWJ5en6dTmB5d7opokOSTcnS1RXj1iI4GPE8AMAum0rtilUNkUctUD+XTaUNTWjpHLFCzyc+Tzs5ATs1hWrFco5i4cJA9LxUQSAiolo24dPGwYWzImmY5gtVh7RyDG0aMzM5yZ+lhFn6fZSZJE1VcREoJv1F64pdNpWiU/IN38aCS3Fe+PjuhYJqmpfA/crn4fJlPN4wNvxP/Zya4rHNqxky2Y/+p7wI/OiFlUUQNk23A7t8Gezy5Wrey/cbQBhfmt8TqVBeqkJruQ88p0RUCxM/6f0zNlxzYiKM/0Q/zQmqEhnH2crvqlQd1qrojx5H+FDFSboXRULkUR8NXkQeEi4VLPG5LKZG8zAQWnvcN+rHQlacLNEQxyl87dnsxUlrSAIVMbtMFJTx6YgLLZl2CcTyJTZvp6N8l+FDvYH77DvyhYe68j4dI9wQzSQjwr/e6TTNkrSBS00kN29LgSGem8x00bwr87o7oXUJDkY4XizCuW85mhtpI1FETBlrb2w81qZ8AtFvDnbbCNJd3LQ4Pp1uORo1tUY5nsSJMCZl3zMmxHDT8bGIlel0lGAl++9Ho+R3pkWqrtk/zteanU0WLTHWoa26cBg/T7UxRoFiclKR0ShZFvuqM62a+6aIkMnXzfkE8mvEcXD7DwSuhrQ6EHOe+CxAqFYoxp3D7IgEJ+/NFiiXkjdJawLNfReJn4IcbCf6TQ0xRlnwuxmfBb3LZmoS7sBBnnNS6yRBRnIuTK8XNP7BEBSxkfI/CM3di3lL7gcqqCSsTe7ZZ9PYurS2cGZFKSR2Q3SAegdp7PJw7bqGo8JwEjkvpK5DCGw/cZYc5RaR1wOaGnXuUohRQ252Nrk5vHA91DW7Lshtqvgo3sU1Ls7BOM9MpwOQwC9dIt2uTsLkNcfKmCzxGPOC0tpH/B0ZcUJrmrRK2V53vOv4aIKss0f6s8BY8sJCCt8yqSwtTU6ZZ6HN1Ii0YUuNXIVFSR/2GCgtOjMFsybPpVkPz3cWNKEUQtWwLliTsflDJIGZ6KdcCnl/yVIRfY2tBEqxMNFmIM3jrH0aE+Pfe3o85SIox8051lJbwxVju2TFQaXxiUWn4S6i/ASZn7vhk5cLdncOS1Hm9+US5pIbQJYNxEXQaMHOVFVjoVJpc5kPkOYXhX2ydiSux9cgrV4IHyruPbafXS60yRobMjhSO3tdra3nVi4Z/SCJnSL0txXRWqJrbtjULmnlUtyQbKMT35uqmTSMNFou4pbzjoCwoUbBEIDelISfu0nwTRuYDMdjS4wU/JS7xXGYMVvdKstWGt1+q9/TmFujbd6o+xDXIXNzmThvyAqgnq0aa8tjLO/FwqDKvKmjftT4iHuypUZmMrUGuRWFLAs6GVc2V8jaBiTFR1gzeK6O4y6QkheFV44+W+B0z4sRz48REhJmKq2KzJfs+OVRfmggaTE5UYek2ijRx4s2bi99v40X3dpg4eDFO21aFMHQ4AoAibzYxpGI4CRHANDtBrY5+SjltSghTJVC0hQxrI0MKH2niqjnOXSNSJZsBqbxpWtKX2TtVCrulDNBanaOF0LFJaENeC6hjbQKIMXmZ7U6DD0f59j334AToZjSApMJVjJ9r6f7Gb1xNJBxCwCEfBoAOOzTCQ5EC89BhYlCaOPib4pAUJuoNcBoBEqy42cHOtsppSume45GYZwy9522LGTzxrtwTr4wyzGkNspwN9YYo/+atEO5eclxiBE/HJLHlpk6ERHpGtHyRCZzT5Yon+pCSCRXYXJt0vvD2RfJjSbbZdLz8PsPKKEINEf4JnSscDPWLpaKHjN29K+0uGVh0JzCHnHtM0FQUQnYYvinKowVz6dwyXDbOI5SaJDtINJ3vsbSvZ2wpgLww0HiMChrnFNjo3gOwopB9+T7SBeWVNCcJoG2Jp47ynjeuCEefPBBvPnNb8a6detgjMHdd9+tvvfe49prr8XatWsxOTmJTZs24YknnlDHPPPMM9iyZQtWrFiBVatW4dJLL8X+zLz29a9/Ha9//esxMTGBU045BTfeeONz7x0QTY1xU3disQSA2SxhELkkssgGMp3lJn0V29zCCm6gZWOXplUy36s44Dy3AmtBNiwgjXvEvtbCxQGEnBIUM50LFsI/y+2TmvCYyIRGqCJZAuh39pJSu1JqXKeuzebufKES/ZIbnor2EAteQ7AibkkkV7F1Sda2IFcJ0iLt5bHhAmmBjP975wO5TbLVARbKmICXC2g58U2SrGgORk2b0iQr8hqH1MrF2Kc57RL5LE8QZIQgIYl9NFaeBAF5XTUfosAU28ZkUeqHHHdqIwmIse167nh+hoycoBsGLf0dXYM8zvmGEkmHAGICr2w+kWAQI2RovNPmbhvrgOyfP3CQx5IFCBpXGU4oc3JEAdlM9JPgFd0v6vq0qUuB1be/M/y1jMAAoPIs0NjlRL74mQpTJjcmEY69i+TNYXI3AcnMLyx8DXdlFO55ngmLGQtldFw83w8Gcxbm4xwosg/U/9R5JcgnAnY2R2ksSQBdKPh5+llgPGdh4cCBAzjzzDPx0Y9+tPX7G2+8Ebfeeis+9rGPYdu2bVi2bBk2b96MmZkZPmbLli149NFHce+99+Kzn/0sHnzwQVx++eX8/b59+3Deeefh1FNPxfbt23HTTTfhAx/4AH7/93//h+iigAnpjJXJzWR/Z6Zvn73MABomTSpIY4kwmSMywRVZKrbH9HpAZJ/TZ/ydIOwxsVAgJM7R7hMVBtlJIZkyPImKV0nCFhHDKAtlesEz90beP0lkFJaBdF3N9/DRv8ghlfyFSxsWC1BVCsuLzydnSqfTxwg15KKge7d8n/MFQDwAinAQ4X2K8AiwTxdOLO4cOZAsM21JpJSZvU34imOYkn/V7OZpEFUBzoXv65rrD8g0zZJklu6TjQmZdSktetzoKQcF368OWjpzUmrKsy84Es4nUhm5n8jkLl0jNj2fxtjKjUxoxfn8tMsm1Vh4wapnMzhtzsgsEXQMgEbxMPVdlYQIurb0/dMc6gpODD1T7xKBllxF3nPUCiXtYktiLgCJBEiqfUIAZNJir8vcC2oHjwlp9BQtY5okzMR9cll/hNBMJFRBBlUhikJg4DksuGAYDkMNC3IRUlgpkCwH/O6Id5PaLjg1zFmQ0U3CHWH7gfdCc02lOe/EYnd5tcuCBp4zBfSCCy7ABRdc0Pqd9x633HIL3v/+9+Oiiy4CAPzxH/8xVq9ejbvvvhsXX3wxHnvsMdxzzz34yle+gte85jUAgNtuuw0/+7M/i9/5nd/BunXrcOedd2IwGODjH/84er0eXvnKV2LHjh24+eablVBxWPAOgAOR0VQynNxsTRNNTCjvgv9aJjhhCV9q5M7DzyXu+ZDu1kvTmA8bt+mEEDRpgvejlHkvtU28DOS7y82QtKCTa0SS6KLJkwmbkjjmg6+ZyUAytbN8MW0FxMRVxhiEpCuCCJj7MeNioTRr4QcNfdQapZ3ot6aJNlWImnDTM+DCYLL7xjauxfd3Pi2gYmOAsUnoMhZAreZHQzhpEZaCxmW1SZ77HxcyahYvYlZrYjTeYmM0nSTomSpupsYA3ao1/NU7D9vrAdMzKYU4xHOUWpgUir0DfDKb8yxu2VB5eMllIAQjxUeJZNGgkcZD6LyszSwYScFH8lqoWJpJeVJMVcETm53M+PH5c8r2XlcLpKLdnPq7Chu0O3gwjr/jDcoPQ1E1VWCM+trvAc+iPfcFJRWj50oWzehqUyGd3W4qCueFhluF6CU/jPeLab+Vdk/PxEHNOeqbJKnKMfU1UuG1zNpAzzhcN/EXWhH5BF69c1GwRNU4Fqj5fURVwUxNwu97Ngjnzqc6DbV4d0wm5Md3zQ+FUEBCq7FQa6Qg1oZ/41yreloxsQZzODDnHfPhRlgUboi5sHPnTuzatQubNm3iz1auXIkNGzZg69atAICtW7di1apVLCgAwKZNm2CtxbZt2/iYc845Bz0h7W3evBmPP/44/umf/qn13rOzs9i3b5/6aSD6MZmNLpMe5VopbSJAY9NNC7pT3+c+vvR3G0ci/O2mZ5JVwdU6+iCHPH84RCNpE0UhkOYlTMApTW5T+06mxZYSsXlfxGYWsmH6JHhEv6aW8K0WFEgLJfNnm8/fudQXcV8/GkGy6Bvj5Fr+916baKNgB+8Uu5+ux+ltSauVG7qr2fwux9wYE+LVc4GSIgcUV0GYSHnzyXzjwsKVXCPhWm4wDOmjRQy+6i9dJ6YQ1+6VWv2WbfLRXedkumjWipvz1pCwKMzL0mUCoCGMU3ZMR5lCxTOiRT356W3Th03PkobJmnCt0TBECdCzpPlFLH3x/nIdAmExlO8lj5Xsu3iveCxkxU26R+TZhCqJ2XtGpv14Llv6oumdk1HJe2Qp5Nuen7Rc0HglHoCuUcKuELoHjXnuQiUuQJyjXPVRutPi326Q8kv4YcwKKZKqpXTjQjmJ0UlePs8WNxZ/nnObZARMBCsXpNwI15mKPiKBjNZZcpUsZBZHMf5H9LPAmNfg0l27dgEAVq9erT5fvXo1f7dr1y6cfPLJuhGdDk488UR1zPr16xvXoO9e8IIXNO59ww034IMf/GDj8+FoBt7GBXp2CDs5ATeqAV/D+wFqTy+USRPNjWC7PfjKw7shLCycE/5xafr3NazthnLGxsHXJGBIfyHChuANv1CkcQQrwjTqwQE+3PT68LMDfY0MxtkoRGf34b8dzGgE70fhcwcY60L3BiO1sRrn4f0I3tZw9QDeU7Emyrsv7iE0JWM8PGoYH36jHgJefA8DPxqohcJ4n/zNkiQ6iMxkV8OMHGDj4lcPtTXj4L60YNHnsb90jPKRe5fGfRhC8YwHHD0vGr/4jOAtDH1mLMxED25/4H4Ek+kIZjQN54dxvCsY1EHsNj5crx6qhcwMp5tsfZhwrPd8HR4Laktdw9YOzo9gex0AQzgvNtnGpDCo9/4TvBvCzXq4ejbOVRLmwnjxs6Wxis/SxX7ZyT7qA3ujkFWn52YsPIKAWs/sj9a0GqgHMN0eTOXha0qjW8OMfNI6vQ/HWA9vXXjd5LwyBtZa+FEd5iwt3sNMYKmHMKYDP/Dx/enD+yHs1CTcwemwWcX32ngX2ieF15khP8vaeWDkYSf7cH4IAxesg26YLF7GALDBLMLPx6W1w41gTAXjADcznZ6tE/54snZ0LPxoBtZ3UNfBLWv9AOgC7mDgbNluH252BMxKYQWoDz4LU4V1yHQ6Os03wMKLcUEbrwcOdqJK65sbAZ6Ejxpm9gC8H8FaC8cCRx3Jv3V4t+Mcs+jwfLeuCn+bCnDDWH49CFPUruAOG8HISBIuq23CXK5nYA46+I5LCtzMkJN8eUdtAhDXawCw1gL1KL1/TP52qQ+0DrowV01F4yXGyvvQR+9howVvRMLlUd6IF6tlYcnUhrj66qvxnve8h//fuXMnzjrrLHwJnwNIyPcADoqTpPHBZ79nxHcHoJEr5/n3bfAApGWdrjEEsCc79hCFGg/rGIdmO8edQ/uYNNqMk1PkNUfZ7/z7tmuME+Ble/Pz5PMbdy95DP2mv+X1ZqCfrQSdM64Po/iTP8cWqoQS3Nr6PK6PeVuorePanJ9D16Xj28ZoKI6XbaR2ts3nvA/5XBqi2af8nLZjCLKvedvmagu1Q7aZ3uu5novs71B81nZ83haH9M7SnJTnDrNj8/vJ90yuRwDwbEsbAD3e8l552+R3P8iOa5uT+bxy2feAHtuD2XFt7WpbF2Q76Hptc7ptfsjnmJ/jW47Jvxtl/yP7PHsGzz77LFauXNlywec35lVYWLNmDQBg9+7dWLt2LX++e/dunHXWWXzM008/rc4bjUZ45pln+Pw1a9Zg9+7d6hj6n47J0e/30SfiEIBTTz0VAPDkk08uyge/b98+nHLKKfje976HFStWHOvm/FBY7H1Y7O0HFn8fFnv7gcXfh+dL+733ePbZZ7Fu3bqj26A2AfSHucYCY16FhfXr12PNmjW47777WDjYt28ftm3bhne9610AgI0bN2LPnj3Yvn07zj77bADA/fffD+ccNmzYwMf8p//0nzAcDtGNTNx7770Xp512WqsLog02+rVWrly5KCc4YcWKFYu6/cDi78Nibz+w+Puw2NsPLP4+PB/avxCK5WJ1QzxnguP+/fuxY8cO7NixA0Aw9+/YsQNPPvkkjDF497vfjQ996EP4y7/8S3zjG9/AO97xDqxbtw5vectbAACveMUrcP755+Oyyy7Dww8/jC9/+cu48sorcfHFF7NE94u/+Ivo9Xq49NJL8eijj+Izn/kM/st/+S/KzVBQUFBQUFCwMHjOloWvfvWreNOb3sT/0wZ+ySWX4I477sD73vc+HDhwAJdffjn27NmD173udbjnnnswMZFSl95555248sorce6558Jai7e+9a249dZb+fuVK1fif/7P/4krrrgCZ599Nk466SRce+21zz1ssqCgoKCg4HgC1Qg50mssMJ6zsPDGN75xTraoMQbXX389rr/++rHHnHjiifjUpz41533OOOMM/M3f/M1zbR6j3+/juuuuUzyGxYTF3n5g8fdhsbcfWPx9WOztBxZ/H0r75xmLlLNg/NGOEykoKCgoKHieY9++fVi5ciV+atMH0elOHPqEOTAazuChz1+HvXv3HhaP5MEHH8RNN92E7du346mnnsJdd93F1IDDxfOjkFRBQUFBQcFxAAP8UIWj1M9zvOehyjQcDpZMnoWCgoKCgoLjHvORgfE5nj9XmYbDRREWCgoKCgoKFiHysgZ5vqH5RHFDFBQUFBQULBCO2AUh8jSccsopWLlyJf/ccMMNR63dS1JY+OhHP4qXvOQlmJiYwIYNG/Dwww8f6yYBCPUr/vk//+c44YQTcPLJJ+Mtb3kLHn/8cXXMG9/4Ri7SQz+/+qu/qo558sknceGFF2Jqagonn3wy3vve92LUVgDqKOADH/hAo30vf/nL+fuZmRlcccUVeOELX4jly5fjrW99ayMb57Fs/0te8pJG+40xuOKKKwAcn+P/4IMP4s1vfjPWrVsHYwzuvvtu9b33Htdeey3Wrl2LyclJbNq0CU888YQ65plnnsGWLVuwYsUKrFq1Cpdeein279+vjvn617+O17/+9ZiYmMApp5yCG2+88ai3fzgc4qqrrsLpp5+OZcuWYd26dXjHO96B73//++oabc/tIx/5yIK0/1B9AIBf+qVfarTv/PPPV8ccr88AQOs7YYzBTTfdxMccy2dwOGvnfK09DzzwAF796lej3+/jx37sx3DHHXfMSx8Yfp5+AHzve9/D3r17+efqq6+e37YKLDlh4TOf+Qze85734LrrrsMjjzyCM888E5s3b26kmD4W+OIXv4grrrgCf/u3f4t7770Xw+EQ5513Hg4c0Mn4L7vsMjz11FP8I1+4uq5x4YUXYjAY4KGHHsInPvEJ3HHHHbj22msXrB+vfOUrVfu+9KUv8Xf//t//e/z3//7f8Wd/9mf44he/iO9///v4hV/4heOm/V/5yldU2++9914AwL/8l/+Sjznexv9Q5KQbb7wRt956Kz72sY9h27ZtWLZsGTZv3oyZmZRIf8uWLXj00Udx77334rOf/SwefPBBlbdk3759OO+883Dqqadi+/btuOmmm/CBD3wAv//7v39U23/w4EE88sgjuOaaa/DII4/gz//8z/H444/j537u5xrHXn/99eq5/Nt/+28XpP2H6gPh/PPPV+37kz/5E/X98foMAKh2P/XUU/j4xz8OYwze+ta3quOO1TM4nLVzPtaenTt34sILL8Sb3vQm7NixA+9+97vxy7/8y/jrv/7rI+4DwXg/Lz9AykpJP0c1PNQvMbz2ta/1V1xxBf9f17Vft26dv+GGG45hq9rx9NNPewD+i1/8In/2hje8wf/6r//62HP+6q/+yltr/a5du/iz22+/3a9YscLPzs4ezeZ6772/7rrr/Jlnntn63Z49e3y32/V/9md/xp899thjHoDfunWr9/7Ytz/Hr//6r/uXvexl3jnnvT/+xx+Av+uuu/h/55xfs2aNv+mmm/izPXv2+H6/7//kT/7Ee+/93//933sA/itf+Qof8z/+x//wxhj/f//v//Xee//f/tt/8y94wQtUH6666ip/2mmnHdX2t+Hhhx/2APx3v/td/uzUU0/1v/u7vzv2nIVqv/ftfbjkkkv8RRddNPacxfYMLrroIv8zP/Mz6rPj6Rnka+d8rT3ve9/7/Ctf+Up1r7e97W1+8+bNR9zmvXv3egD+9W+8zr9p0w1H9PP6N17nAfi9e/c+53YczvNvw5KyLAwGA2zfvh2bNm3iz6y12LRpE7Zu3XoMW9aOvXv3AghJqiTuvPNOnHTSSXjVq16Fq6++GgcPprJoW7duxemnn67KgG/evBn79u3Do48+uiDtfuKJJ7Bu3Tq89KUvxZYtW/Dkk08CALZv347hcKjG/+Uvfzle/OIX8/gfD+0nDAYDfPKTn8S/+Tf/BkaUlD7ex19i586d2LVrlxrzlStXYsOGDWrMV61ahde85jV8zKZNm2CtxbZt2/iYc845B71ej4/ZvHkzHn/8cfzTP8kyiUcfe/fuhTEGq1atUp9/5CMfwQtf+EL85E/+JG666SZlPj4e2v/AAw/g5JNPxmmnnYZ3vetd+MEPUtnHxfQMdu/ejc997nO49NJLG98dL88gXzvna+3ZunWrugYdM6/7h5unn+eAuco0HC6WVDTEP/7jP6KuazUZAGD16tX4h3/4h2PUqnY45/Dud78bP/3TP41XvepV/Pkv/uIv4tRTT8W6devw9a9/HVdddRUef/xx/Pmf/zkAYNeuXa39o++ONjZs2IA77rgDp512Gp566il88IMfxOtf/3p885vfxK5du9Dr9RqL/OrVq7ltx7r9EnfffTf27NmDX/qlX+LPjvfxz0H3bGuTHPOTTz5Zfd/pdHDiiSeqY9avX9+4Bn13uAXcjhQzMzO46qqr8Pa3v10lm/l3/+7f4dWvfjVOPPFEPPTQQ7j66qvx1FNP4eabbz4u2n/++efjF37hF7B+/Xp8+9vfxn/8j/8RF1xwAbZu3YqqqhbVM/jEJz6BE044QZnwgePnGbStnfO19ow7Zt++fZiensbk5OQRt1+6EY7kGs8FhyrTcDhYUsLCYsIVV1yBb37zm8rfD0D5ME8//XSsXbsW5557Lr797W/jZS972UI3swEZq3vGGWdgw4YNOPXUU/Gnf/qn8/IiLST+8A//EBdccIEqSXu8j/9SxnA4xL/6V/8K3nvcfvvt6jtZRO6MM85Ar9fDr/zKr+CGG244LtL4Xnzxxfz36aefjjPOOAMve9nL8MADD+Dcc889hi177vj4xz+OLVu2qHo+wPHzDMatnQXjcagyDYeDJeWGOOmkk1BVVYMBu3v3bqxZs+YYtaqJK6+8Ep/97GfxhS98AT/6oz8657FUtvtb3/oWAGDNmjWt/aPvFhqrVq3CP/tn/wzf+ta3sGbNGgwGA+zZs6fRPmrb8dL+7373u/j85z+PX/7lX57zuON9/Omec835NWvWNAi+o9EIzzzzzHHzXEhQ+O53v4t77733kClsN2zYgNFohO985zvcxuPpubz0pS/FSSedpObN8f4MAOBv/uZv8Pjjjx/yvQCOzTMYt3bO19oz7pgVK1bMnzI0j9EQC4klJSz0ej2cffbZuO+++/gz5xzuu+8+bNy48Ri2LMB7jyuvvBJ33XUX7r///obJrg3kY1q7di0AYOPGjfjGN76hFh5aXH/iJ37iqLR7Luzfvx/f/va3sXbtWpx99tnodrtq/B9//HE8+eSTPP7HS/v/6I/+CCeffDIuvPDCOY873sd//fr1WLNmjRrzffv2Ydu2bWrM9+zZg+3bt/Mx999/P5xzLAxt3LgRDz74IIbDIR9z77334rTTTjvq5m8SFJ544gl8/vOfxwtf+MJDnrNjxw5Ya9m0fyzb34b/83/+D37wgx+oeXM8PwPCH/7hH+Lss8/GmWeeechjF/IZHGrtnK+1Z+PGjeoadMy87h+UwfFIfxYaz5kSeZzj05/+tO/3+/6OO+7wf//3f+8vv/xyv2rVKsWAPVZ417ve5VeuXOkfeOAB/9RTT/HPwYMHvffef+tb3/LXX3+9/+pXv+p37tzp/+Iv/sK/9KUv9eeccw5fYzQa+Ve96lX+vPPO8zt27PD33HOPf9GLXuSvvvrqBenDb/zGb/gHHnjA79y503/5y1/2mzZt8ieddJJ/+umnvffe/+qv/qp/8Ytf7O+//37/1a9+1W/cuNFv3LjxuGm/9yFC5sUvfrG/6qqr1OfH6/g/++yz/mtf+5r/2te+5gH4m2++2X/ta1/jaIGPfOQjftWqVf4v/uIv/Ne//nV/0UUX+fXr1/vp6Wm+xvnnn+9/8id/0m/bts1/6Utf8j/+4z/u3/72t/P3e/bs8atXr/b/+l//a//Nb37Tf/rTn/ZTU1P+937v945q+weDgf+5n/s5/6M/+qN+x44d6r0ghvpDDz3kf/d3f9fv2LHDf/vb3/af/OQn/Yte9CL/jne8Y0Haf6g+PPvss/4//If/4Ldu3ep37tzpP//5z/tXv/rV/sd//Mf9zMwMX+N4fQaEvXv3+qmpKX/77bc3zj/Wz+BQa6f387P2/O///b/91NSUf+973+sfe+wx/9GPftRXVeXvueeeI+4DRUOc89PX+J95w4eP6Oecn77mh46G+GGx5IQF772/7bbb/Itf/GLf6/X8a1/7Wv+3f/u3x7pJ3ns/1qD0R3/0R95775988kl/zjnn+BNPPNH3+33/Yz/2Y/69731vY0J85zvf8RdccIGfnJz0J510kv+N3/gNPxwOF6QPb3vb2/zatWt9r9fzP/IjP+Lf9ra3+W9961v8/fT0tP+1X/s1/4IXvMBPTU35n//5n/dPPfXUcdN+773/67/+aw/AP/744+rz43X8v/CFL7TOm0suucR7H8Inr7nmGr969Wrf7/f9ueee2+jbD37wA//2t7/dL1++3K9YscK/853v9M8++6w65u/+7u/86173Ot/v9/2P/MiP+I985CNHvf07d+4c+1584Qtf8N57v337dr9hwwa/cuVKPzEx4V/xilf4//yf/7PaiI9m+w/Vh4MHD/rzzjvPv+hFL/Ldbtefeuqp/rLLLmsoKMfrMyD83u/9np+cnPR79uxpnH+sn8Gh1k7v52/t+cIXvuDPOuss3+v1/Etf+lJ1jyMBCQtv+Klr/LnnfPiIft7wUwsvLJQS1QUFBQUFBUcZVKL6DRvfj07nCEtUj2bwxa0fOuwS1fOBJcVZKCgoKCgoKJh/lNDJgoKCgoKCBYJx4edIr7HQKMJCQUFBQUHBQmE+ohmOAXugCAsFBQUFBQULhfnIk1DyLBQUFBQUFBQcbyiWhYKCgoKCggXCsagNMR8owkJBQUFBQcFCYZFyFooboqCgoKCgoGBOFMtCQUFBQUHBQsEDONLQx2NAcCzCQkFBQUFBwQJhsXIWihuioKCgoKCgYE4Uy0JBQUFBQcFCwWMeCI7z0pLnhCIsFBQUFBQULBRKNERBQUFBQUHBUkSxLBQUFBQUFCwUHAAzD9dYYBRhoaCgoKCgYIGwWKMhirBQUFBQUFCwUCichYKCgoKCgoKliGJZKCgoKCgoWCgsUstCERYKCgoKCgoWCotUWChuiIKCgoKCgoI5USwLBQUFBQUFC4USOllQUFBQUFAwFxZr6GRxQxQUFBQUFBTMiWJZKCgoKCgoWCgsUoJjERYKCgoKCgoWCs4D5gg3e1fcEAUFBQUFBQXHGYploaCgoKCgYKFQ3BAFBQUFBQUFc2MehAUUYaGgoKCgoGDpYpFaFgpnoaCgoKCgoGBOFMtCQUFBQUHBQsF5HLEb4RhEQxRhoaCgoKCgYKHgXfg50mssMIoboqCgoKCgoGBOFMtCQUFBQUHBQmGREhyLsFBQUFBQULBQWKScheKGKCgoKCgoKJgTxbJQUFBQUFCwUChuiIKCgoKCgoI54TEPwsK8tOQ5obghCgoKCgoKCuZEsSwUFBQUFBQsFIoboqCgoKCgoGBOOAfgCJMquYVPylSEhYKCgoKCgoXCIrUsFM5CQUFBQUFBwZwoloWCgoKCgoKFwiK1LBRhoaCgoKCgYKFQMjgWFBQUFBQULEUUy0JBQUFBQcECwXsHf4Qlpo/0/B8GRVgoKCgoKChYKHh/5G6EEg1RUFBQUFBQcLyhWBYKCgoKCgoWCn4eCI4lGqKgoKCgoGAJwznAHCHn4BhwFooboqCgoKCgoGBOFMtCQUFBQUHBQqG4IQoKCgoKCgrmgncO/gjdECV0sqCgoKCgYCljkVoWCmehoKCgoKCgYE4Uy0JBQUFBQcFCwXnALD7LQhEWCgoKCgoKFgreAzjS0MnihigoKCgoKCg4zlAsCwUFBQUFBQsE7zz8EbohfLEsFBQUFBQULGF4Nz8/PwQ++tGP4iUveQkmJiawYcMGPPzww4d9bhEWCgoKCgoKljg+85nP4D3veQ+uu+46PPLIIzjzzDOxefNmPP3004d1fhEWCgoKCgoKFgje+Xn5ea64+eabcdlll+Gd73wnfuInfgIf+9jHMDU1hY9//OOHdX4RFgoKCgoKChYKx8ANMRgMsH37dmzatIk/s9Zi06ZN2Lp162FdoxAcCwoKCgoKFggjDI84geMIQwDAvn371Of9fh/9fr9x/D/+4z+irmusXr1afb569Wr8wz/8w2HdswgLBQUFBQUFRxm9Xg9r1qzBl3b91bxcb/ny5TjllFPUZ9dddx0+8IEPzMv1cxRhoaCgoKCg4ChjYmICO3fuxGAwmJfree9hjFGftVkVAOCkk05CVVXYvXu3+nz37t1Ys2bNYd2vCAsFBQUFBQULgImJCUxMTCz4fXu9Hs4++2zcd999eMtb3gIAcM7hvvvuw5VXXnlY1yjCQkFBQUFBwRLHe97zHlxyySV4zWteg9e+9rW45ZZbcODAAbzzne88rPOLsFBQUFBQULDE8ba3vQ3/7//9P1x77bXYtWsXzjrrLNxzzz0N0uM4GH8s8kYWFBQUFBQULBqUPAsFBQUFBQUFc6IICwUFBQUFBQVzoggLBQUFBQUFBXOiCAsFBQUFBQUFc6IICwUFBQUFBQVzoggLBQUFBQUFBXOiCAsFBQUFBQUFc6IICwUFBQUFBQVzoggLBQUFBQUFBXOiCAsFBQUFBQUFc6IICwUFBQUFBQVzoggLBQUFBQUFBXPi/wNXbAUp+P+h/wAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "ename": "RuntimeError",
+     "evalue": "The size of tensor a (138) must match the size of tensor b (3) at non-singleton dimension 5",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn [27], line 9\u001b[0m\n\u001b[1;32m      6\u001b[0m image2 \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mones([\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m144\u001b[39m, \u001b[38;5;241m144\u001b[39m]) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m      8\u001b[0m mssim \u001b[38;5;241m=\u001b[39m MSSSIM(data_range\u001b[38;5;241m=\u001b[39mdata_range)\n\u001b[0;32m----> 9\u001b[0m \u001b[43mmssim\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage2\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:332\u001b[0m, in \u001b[0;36mCumulativeIterationMetric.__call__\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m    315\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, y_pred: TensorOrList, y: TensorOrList \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    316\u001b[0m     \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    317\u001b[0m \u001b[38;5;124;03m    Execute basic computation for model prediction and ground truth.\u001b[39;00m\n\u001b[1;32m    318\u001b[0m \u001b[38;5;124;03m    It can support  both `list of channel-first Tensor` and `batch-first Tensor`.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    330\u001b[0m \u001b[38;5;124;03m        a `batch-first` tensor (BC[HWD]) or a list of `batch-first` tensors.\u001b[39;00m\n\u001b[1;32m    331\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 332\u001b[0m     ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_pred\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    333\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(ret, (\u001b[38;5;28mtuple\u001b[39m, \u001b[38;5;28mlist\u001b[39m)):\n\u001b[1;32m    334\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mextend(\u001b[38;5;241m*\u001b[39mret)\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:73\u001b[0m, in \u001b[0;36mIterationMetric.__call__\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m     71\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(y_pred, torch\u001b[38;5;241m.\u001b[39mTensor):\n\u001b[1;32m     72\u001b[0m     y_ \u001b[38;5;241m=\u001b[39m y\u001b[38;5;241m.\u001b[39mdetach() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(y, torch\u001b[38;5;241m.\u001b[39mTensor) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m---> 73\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdetach\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     74\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my_pred or y must be a list/tuple of `channel-first` Tensors or a `batch-first` Tensor.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/regression.py:82\u001b[0m, in \u001b[0;36mRegressionMetric._compute_tensor\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m     80\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my_pred and y must be PyTorch Tensor.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     81\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_shape(y_pred, y)\n\u001b[0;32m---> 82\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_metric\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/mnt_homes/home4T7/jdafflon/GenerativeModels/generative/metrics/ms_ssim.py:125\u001b[0m, in \u001b[0;36mMSSSIM._compute_metric\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    123\u001b[0m mcs_list: List[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(levels):\n\u001b[0;32m--> 125\u001b[0m     ssim, cs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSSIM\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_metric_and_contrast\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    127\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m<\u001b[39m levels \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m    128\u001b[0m         mcs_list\u001b[38;5;241m.\u001b[39mappend(torch\u001b[38;5;241m.\u001b[39mrelu(cs))\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/regression.py:368\u001b[0m, in \u001b[0;36mSSIMMetric._compute_metric_and_contrast\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    366\u001b[0m cs_ls \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m    367\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(x\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]):\n\u001b[0;32m--> 368\u001b[0m     ssim_val, cs_val \u001b[38;5;241m=\u001b[39m \u001b[43mSSIMMetric\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    369\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata_range\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwin_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mk1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mk2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mspatial_dims\u001b[49m\n\u001b[1;32m    370\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_metric_and_contrast\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munsqueeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munsqueeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    371\u001b[0m     ssim_ls\u001b[38;5;241m.\u001b[39mappend(ssim_val)\n\u001b[1;32m    372\u001b[0m     cs_ls\u001b[38;5;241m.\u001b[39mappend(cs_val)\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/regression.py:379\u001b[0m, in \u001b[0;36mSSIMMetric._compute_metric_and_contrast\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    375\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m channel_wise_ssim, channel_wise_cs\n\u001b[1;32m    377\u001b[0m c1, c2, ux, uy, vx, vy, vxy \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compute_intermediate_statistics(x, y)\n\u001b[0;32m--> 379\u001b[0m numerator \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mux\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43muy\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc1\u001b[49m) \u001b[38;5;241m*\u001b[39m (\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m vxy \u001b[38;5;241m+\u001b[39m c2)\n\u001b[1;32m    380\u001b[0m denom \u001b[38;5;241m=\u001b[39m (ux\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m uy\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m c1) \u001b[38;5;241m*\u001b[39m (vx \u001b[38;5;241m+\u001b[39m vy \u001b[38;5;241m+\u001b[39m c2)\n\u001b[1;32m    381\u001b[0m ssim_value \u001b[38;5;241m=\u001b[39m numerator \u001b[38;5;241m/\u001b[39m denom\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: The size of tensor a (138) must match the size of tensor b (3) at non-singleton dimension 5"
+     ]
     }
    ],
    "source": [
-    "plt.imshow(real_eval_feats.cpu())\n",
-    "plt.colorbar()"
+    "from generative.metrics import  MSSSIM\n",
+    "import torch\n",
+    "\n",
+    "data_range = torch.ones(1, 3)\n",
+    "image1 = torch.ones([3, 3, 144, 144]) / 2\n",
+    "image2 = torch.ones([3, 3, 144, 144]) / 2\n",
+    "\n",
+    "mssim = MSSSIM(data_range=data_range)\n",
+    "mssim(image1, image2)"
    ]
   }
  ],
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
index ef00b278..5f17e6db 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
@@ -23,7 +23,7 @@
 from monai.config import print_config
 from monai.utils import set_determinism
 
-from generative.metrics import FID
+from generative.metrics import FID, MMD, MSSSIM
 from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL
 from generative.networks.schedulers import DDPMScheduler
 from generative.inferers import DiffusionInferer
@@ -61,11 +61,11 @@ def get_features(image):
     # Get model outputs
     with torch.no_grad():
         feature_image = radnet.forward(image)
-        # TODO: FIX ME
-        feature_image = feature_image[:, :, 0, 0]
+        # flattens the image spatially
+        feature_image = spatial_average(feature_image, keepdim=False)
 
     # normalise through channels
-    features_image = normalize_tensor(feature_image)
+    #features_image = normalize_tensor(feature_image)
 
     return feature_image
 
@@ -106,8 +106,6 @@ def get_features(image):
 )
 autoencoderkl = autoencoderkl.to(device)
 
-
-
 # +
 unet = DiffusionModelUNet(
     spatial_dims=2, in_channels=3, out_channels=3, num_res_blocks=1, num_channels=(128, 256, 256), num_head_channels=256
@@ -158,7 +156,7 @@ def get_features(image):
 val_ds = Dataset(data=val_datalist, transform=val_transforms)
 val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)
 
-# ## Get features
+# ## Get features for real data
 
 radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
 radnet.to(device)
@@ -173,9 +171,9 @@ def get_features(image):
     features_real = get_features(real_img)
     real_eval_feats.append(features_real.cpu())
     pbar.update()
-# -
 
 real_eval_feats = torch.cat(real_eval_feats, axis=0)
+# -
 
 # ## Generate synthetic images
 
@@ -212,18 +210,74 @@ def get_features(image):
     ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap="gray")
     ax[image_n].axis("off")
 
-synch_eval_feats2 = torch.cat(synth_eval_feats, axis=0)
-print(synch_eval_feats2.shape, real_eval_feats.shape)
+synch_eval_feats = torch.cat(synth_eval_feats, axis=0)
+print(synch_eval_feats.shape, real_eval_feats.shape)
+
+fid = FID()
+results = fid(real_eval_feats.to(device), synch_eval_feats)
+results.item()
 
+# Even when passing the same image, it returns NaNs
 fid = FID()
-results = fid(real_eval_feats.cpu(), synch_eval_feats2.cpu())
+results = fid(synch_eval_feats, synch_eval_feats)
+results.item()
 
+# Even when passing the same image, it returns NaNs
+fid = FID()
+results = fid(real_eval_feats.to(device), real_eval_feats.to(device))
 results.item()
 
-synch_eval_feats2
+# # Compute MMD
+
+# +
+# Generate a few samples (the 45 for the last batch)
+
+n_synthetic_images = len(real_img)
+syn_image = torch.randn((n_synthetic_images, 1, 64, 64))
+syn_image = syn_image.to(device)
+scheduler.set_timesteps(num_inference_steps=1000)
+
+with torch.no_grad():
+
+    z_mu, z_sigma = autoencoderkl.encode(syn_image)
+    z = autoencoderkl.sampling(z_mu, z_sigma)
+
+    noise = torch.randn_like(z).to(device)
+    syn_image, intermediates = inferer.sample(
+        input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100
+    )
+    syn_image = autoencoderkl.decode(syn_image)
+# -
+
+mmd = MMD()
+mmd(real_img, syn_image)
+
+real_img.shape
+
+syn_image.cpu().shape
+
+# # Compute SSIM
+
+data_range = 1.0
+mssim = MSSSIM(data_range=data_range)
+mssim(real_img, syn_image)
+
+real_img.max()
+
+image1 = torch.ones([3, 3, 144, 144]) / 2
+image2 = torch.ones([3, 3, 144, 144]) / 2
+
+data_range = 1.0
+mssim = MSSSIM(data_range=data_range)
+mssim(image1, image2)
+
+# +
+from generative.metrics import  MSSSIM
+import torch
 
-plt.imshow(synch_eval_feats2.cpu())
-plt.colorbar()
+data_range = torch.ones(1, 3)
+image1 = torch.ones([3, 3, 144, 144]) / 2
+image2 = torch.ones([3, 3, 144, 144]) / 2
 
-plt.imshow(real_eval_feats.cpu())
-plt.colorbar()
+mssim = MSSSIM(data_range=data_range)
+mssim(image1, image2)

From 4c77b26e979c4112ecf16e114e6f02f526bbb258 Mon Sep 17 00:00:00 2001
From: JessyD <jejedafflon@gmail.com>
Date: Mon, 3 Apr 2023 22:39:36 -0400
Subject: [PATCH 3/6] Compute FID, MS-SSIM and SSIM

---
 .../realism_diversity_metrics.ipynb           | 986 +++++++-----------
 .../realism_diversity_metrics.py              | 256 +++--
 2 files changed, 559 insertions(+), 683 deletions(-)

diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
index e3fc6f7f..49f002f8 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
@@ -2,43 +2,64 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "393fe9fe",
+   "execution_count": 1,
+   "id": "c6161aec",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# TODO: Add Open in Colab"
+    "# Copyright (c) MONAI Consortium\n",
+    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+    "# you may not use this file except in compliance with the License.\n",
+    "# You may obtain a copy of the License at\n",
+    "#     http://www.apache.org/licenses/LICENSE-2.0\n",
+    "# Unless required by applicable law or agreed to in writing, software\n",
+    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+    "# See the License for the specific language governing permissions and\n",
+    "# limitations under the License."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "80769612",
+   "id": "0e837e16",
    "metadata": {},
    "source": [
-    "## Setup environment"
+    "# Evaluate Realism and Diversity of the generated images"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "9d28a4f7",
+   "cell_type": "markdown",
+   "id": "7dcfe817",
+   "metadata": {},
+   "source": [
+    "This notebook illustrates how to use the generative model package to compute:\n",
+    "- the realism of generated image using the s Frechet Inception Distance (FID) [1] and Maximum Mean Discrepancy (MMD) [2]\n",
+    "- the image diversity using the MS-SSIM [3] and SSIM [4]\n",
+    "\n",
+    "Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID.\n",
+    "\n",
+    "[1] - Heusel et al., \"Gans trained by a two time-scale update rule converge to a local nash equilibrium\", https://arxiv.org/pdf/1706.08500.pdf\n",
+    "\n",
+    "[2] - Gretton et al., \"A Kernel Two-Sample Test\", https://www.jmlr.org/papers/volume13/gretton12a/gretton12a.pdf\n",
+    "\n",
+    "[3] - Wang et al., \"Multiscale structural similarity for image quality assessment\", https://ieeexplore.ieee.org/document/1292216\n",
+    "\n",
+    "[4] - Wang et al., \"Image quality assessment: from error visibility to structural similarity\", https://ieeexplore.ieee.org/document/1284395\n",
+    "\n",
+    "[5] = Mei et al., \"RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning, https://pubs.rsna.org/doi/10.1148/ryai.210315"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80769612",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/mnt_homes/home4T7/jdafflon/GenerativeModels\n"
-     ]
-    }
-   ],
    "source": [
-    "%cd /home/jdafflon/GenerativeModels"
+    "## Setup environment"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "629c60fc",
    "metadata": {},
    "outputs": [
@@ -54,6 +75,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      " missing cuda symbols while dynamic loading\n",
+      " cuFile initialization failed\n",
       "MONAI version: 1.2.dev2304\n",
       "Numpy version: 1.23.4\n",
       "Pytorch version: 1.13.0\n",
@@ -62,22 +85,22 @@
       "MONAI __file__: /home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/__init__.py\n",
       "\n",
       "Optional dependencies:\n",
-      "Pytorch Ignite version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "ITK version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "Pytorch Ignite version: 0.4.10\n",
+      "ITK version: 5.3.0\n",
       "Nibabel version: 4.0.2\n",
-      "scikit-image version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "scikit-image version: 0.19.3\n",
       "Pillow version: 9.2.0\n",
-      "Tensorboard version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "Tensorboard version: 2.11.2\n",
       "gdown version: 4.6.0\n",
       "TorchVision version: 0.14.0\n",
       "tqdm version: 4.64.1\n",
-      "lmdb version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "lmdb version: 1.4.0\n",
       "psutil version: 5.9.4\n",
-      "pandas version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "pandas version: 1.5.3\n",
       "einops version: 0.6.0\n",
-      "transformers version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "mlflow version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "pynrrd version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "transformers version: 4.21.3\n",
+      "mlflow version: 2.1.1\n",
+      "pynrrd version: 1.0.0\n",
       "\n",
       "For details about installing the optional dependencies, please visit:\n",
       "    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n",
@@ -102,17 +125,26 @@
     "from monai.config import print_config\n",
     "from monai.utils import set_determinism\n",
     "\n",
-    "from generative.metrics import FID, MMD, MSSSIM\n",
+    "from generative.metrics import FIDMetric, MMD, MultiScaleSSIMMetric, SSIMMetric\n",
     "from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL\n",
-    "from generative.networks.schedulers import DDPMScheduler\n",
+    "from generative.networks.schedulers import DDIMScheduler\n",
     "from generative.inferers import DiffusionInferer\n",
     "\n",
     "print_config()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "620df5c6",
+   "metadata": {},
+   "source": [
+    "The transformations defined below are necessary in order to transform the input images in the same way that the images were\n",
+    "processed for the RadNet train."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "f0e0b019",
    "metadata": {},
    "outputs": [],
@@ -124,11 +156,11 @@
     "    x[:, 2, :, :] -= mean[2]\n",
     "    return x\n",
     "\n",
-    "def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:\n",
+    "def normalize_tensor(x: torch.Tensor, eps: float=1e-10) -> torch.Tensor:\n",
     "    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))\n",
     "    return x / (norm_factor + eps)\n",
     "\n",
-    "def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:\n",
+    "def spatial_average(x: torch.Tensor, keepdim: bool=True) -> torch.Tensor:\n",
     "    return x.mean([2, 3], keepdim=keepdim)\n",
     "\n",
     "def get_features(image):\n",
@@ -149,9 +181,6 @@
     "        # flattens the image spatially\n",
     "        feature_image = spatial_average(feature_image, keepdim=False)\n",
     "\n",
-    "    # normalise through channels\n",
-    "    #features_image = normalize_tensor(feature_image)\n",
-    "\n",
     "    return feature_image"
    ]
   },
@@ -170,7 +199,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "e0b189f4",
    "metadata": {},
    "outputs": [
@@ -199,7 +228,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "39c4b986",
    "metadata": {},
    "outputs": [],
@@ -217,7 +246,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "b2bdf536",
    "metadata": {},
    "outputs": [
@@ -236,7 +265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "195db858",
    "metadata": {},
    "outputs": [],
@@ -245,9 +274,8 @@
     "    spatial_dims=2,\n",
     "    in_channels=1,\n",
     "    out_channels=1,\n",
-    "    num_channels=64,\n",
     "    latent_channels=3,\n",
-    "    ch_mult=(1, 2, 2),\n",
+    "    num_channels=[64, 128, 128],\n",
     "    num_res_blocks=1,\n",
     "    norm_num_groups=32,\n",
     "    attention_levels=(False, False, True),\n",
@@ -257,16 +285,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "c2424564",
    "metadata": {},
    "outputs": [],
    "source": [
     "unet = DiffusionModelUNet(\n",
-    "    spatial_dims=2, in_channels=3, out_channels=3, num_res_blocks=1, num_channels=(128, 256, 256), num_head_channels=256\n",
+    "    spatial_dims=2,\n",
+    "    in_channels=1,\n",
+    "    out_channels=1,\n",
+    "    num_res_blocks=(1, 1, 1),\n",
+    "    num_channels=(64, 128, 128),\n",
+    "    attention_levels=(False, True, True),\n",
+    "    num_head_channels=128\n",
     ")\n",
     "\n",
-    "scheduler = DDPMScheduler(num_train_timesteps=1000, beta_schedule=\"linear\", beta_start=0.0015, beta_end=0.0195)\n",
+    "scheduler = DDIMScheduler(num_train_timesteps=1000, beta_schedule=\"linear\", beta_start=0.0015, beta_end=0.0195)\n",
     "\n",
     "inferer = DiffusionInferer(scheduler)\n",
     "\n",
@@ -283,7 +317,7 @@
     "    padding=1,\n",
     ")\n",
     "discriminator.to(device)\n",
-    "unet = unet.to(device)\n"
+    "unet = unet.to(device)"
    ]
   },
   {
@@ -296,48 +330,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "76e684de",
+   "execution_count": 10,
+   "id": "ddc61384",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<All keys matched successfully>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "cwd = Path.cwd()\n",
-    "model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_aeutoencoderkl.pth\")\n",
-    "autoencoderkl.load_state_dict(torch.load(str(model_path)))"
+    "use_pre_trained = True"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "0b7ea4c3",
+   "execution_count": 11,
+   "id": "0e81539b",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "<All keys matched successfully>"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in /home/jdafflon/.cache/torch/hub/marksgraham_pretrained_generative_models_v0.2\n"
+     ]
     }
    ],
    "source": [
-    "cwd = Path.cwd()\n",
-    "model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_unet.pth\")\n",
-    "unet.load_state_dict(torch.load(str(model_path)))"
+    "if use_pre_trained:\n",
+    "    unet = torch.hub.load(\"marksgraham/pretrained_generative_models:v0.2\", model=\"ddpm_2d\", verbose=True)\n",
+    "    unet = unet.to(device)\n",
+    "else:\n",
+    "    cwd = Path.cwd()\n",
+    "    model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_aeutoencoderkl.pth\")\n",
+    "    autoencoderkl.load_state_dict(torch.load(str(model_path)))\n",
+    "    cwd = Path.cwd()\n",
+    "    model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_unet.pth\")\n",
+    "    unet.load_state_dict(torch.load(str(model_path)))"
    ]
   },
   {
@@ -345,12 +370,12 @@
    "id": "9c187146",
    "metadata": {},
    "source": [
-    "## Get the validation split for the real images"
+    "## Get the real images and syntethic data"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "bd4c90f9",
    "metadata": {},
    "outputs": [
@@ -358,16 +383,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2023-02-06 18:56:04,150 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
-      "2023-02-06 18:56:04,151 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
-      "2023-02-06 18:56:04,152 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
+      "2023-04-03 21:36:16,283 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2023-04-03 21:36:16,284 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
+      "2023-04-03 21:36:16,285 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2566.55it/s]\n"
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2483.21it/s]\n"
      ]
     }
    ],
@@ -385,17 +410,131 @@
     "val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "1b48d18c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:00<00:00, 58.77it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get the real data\n",
+    "real_images = []\n",
+    "\n",
+    "pbar = tqdm(enumerate(val_loader), total=len(val_loader))\n",
+    "for step, x in pbar:\n",
+    "    real_img = x[\"image\"].to(device)\n",
+    "    real_images.append(real_img)\n",
+    "    pbar.update()\n",
+    "\n",
+    "real_images = torch.cat(real_images, axis=0)"
+   ]
+  },
   {
    "cell_type": "markdown",
-   "id": "6e2e2332",
+   "id": "500601a2",
    "metadata": {},
    "source": [
-    "## Get features for real data"
+    "Use the model to generate synthetic images. This step will take about 9 mins."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 21,
+   "id": "c8843bc9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.07it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.07it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.05it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.04it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.03it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.02it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.01it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.01it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.00it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.01it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.00it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.00it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  2.99it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  2.99it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  2.99it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:05<00:00,  4.32it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "synth_images = []\n",
+    "unet.eval()\n",
+    "for step, x in enumerate(val_loader):\n",
+    "    n_synthetic_images = len(x['image'])\n",
+    "    noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "    noise = noise.to(device)\n",
+    "    scheduler.set_timesteps(num_inference_steps=25)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        syn_image, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
+    "                                                  scheduler=scheduler,save_intermediates=True,\n",
+    "                                                  intermediate_steps=100)\n",
+    "        synth_images.append(syn_image)\n",
+    "synth_images = torch.cat(synth_images, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "f0b3c3bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot 3 examples from the synthetic data\n",
+    "fig, ax = plt.subplots(nrows=1, ncols=3)\n",
+    "for image_n in range(3):\n",
+    "    ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap=\"gray\")\n",
+    "    ax[image_n].axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5676aa62",
+   "metadata": {},
+   "source": [
+    "## Compute FID"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98452f3f",
+   "metadata": {},
+   "source": [
+    "The FID measures the distance between the feature vectors from the real images and those obtained from generated images. In order to compute the FID the images need to be passed into a pre-trained network to get the desired feature vectors. Although the FID is commonly computed using the Inception network, here, we used a pre-trained version of the RadImageNet to calculate the feature space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
    "id": "e9ded5b8",
    "metadata": {},
    "outputs": [
@@ -585,7 +724,7 @@
        ")"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -598,567 +737,250 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "1b48d18c",
+   "execution_count": 24,
+   "id": "ef279c00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get the features for the real data\n",
+    "real_eval_feats = get_features(real_images)\n",
+    "\n",
+    "# Get the features for the synthetic data\n",
+    "synth_eval_feats = get_features(synth_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "cc974e37",
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
+     "data": {
+      "text/plain": [
+       "(torch.Size([1005, 2048]), torch.Size([1005, 2048]))"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "synth_eval_feats.shape, real_eval_feats.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "17d7e059",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:01<00:00, 14.44it/s]\n"
+      "FID Score: tensor(12.9081, device='cuda:0', dtype=torch.float64)\n"
+     ]
+    }
+   ],
+   "source": [
+    "fid = FIDMetric()\n",
+    "fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))\n",
+    "print(f\"FID Score: {fid_res}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ba4e62d",
+   "metadata": {},
+   "source": [
+    "# Compute MMD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "d7270a66",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "split expects at least a 1-dimensional tensor. `data` should be a batch-first tensor or a list of channel-first tensors, got <class 'torch.Tensor'>",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:207\u001b[0m, in \u001b[0;36mCumulative.extend\u001b[0;34m(self, *data)\u001b[0m\n\u001b[1;32m    206\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:  \u001b[38;5;66;03m# d_t must be a mini-batch of values\u001b[39;00m\n\u001b[0;32m--> 207\u001b[0m     b\u001b[38;5;241m.\u001b[39mextend([x[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43md_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m])\n\u001b[1;32m    208\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mAttributeError\u001b[39;00m, \u001b[38;5;167;01mIndexError\u001b[39;00m, \u001b[38;5;167;01mRuntimeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/torch/functional.py:189\u001b[0m, in \u001b[0;36msplit\u001b[0;34m(tensor, split_size_or_sections, dim)\u001b[0m\n\u001b[1;32m    185\u001b[0m \u001b[38;5;66;03m# Overwriting reason:\u001b[39;00m\n\u001b[1;32m    186\u001b[0m \u001b[38;5;66;03m# This dispatches to two ATen functions depending on the type of\u001b[39;00m\n\u001b[1;32m    187\u001b[0m \u001b[38;5;66;03m# split_size_or_sections. The branching code is in _tensor.py, which we\u001b[39;00m\n\u001b[1;32m    188\u001b[0m \u001b[38;5;66;03m# call here.\u001b[39;00m\n\u001b[0;32m--> 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtensor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43msplit_size_or_sections\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/torch/_tensor.py:786\u001b[0m, in \u001b[0;36mTensor.split\u001b[0;34m(self, split_size, dim)\u001b[0m\n\u001b[1;32m    785\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(split_size, \u001b[38;5;28mint\u001b[39m):\n\u001b[0;32m--> 786\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_VF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msplit_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# type: ignore[attr-defined]\u001b[39;00m\n\u001b[1;32m    787\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: split expects at least a 1-dimensional tensor",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn [27], line 4\u001b[0m\n\u001b[1;32m      2\u001b[0m y_pred \u001b[38;5;241m=\u001b[39m  torch\u001b[38;5;241m.\u001b[39mones([\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m144\u001b[39m, \u001b[38;5;241m144\u001b[39m, \u001b[38;5;241m144\u001b[39m])\n\u001b[1;32m      3\u001b[0m mmd \u001b[38;5;241m=\u001b[39m MMD()\n\u001b[0;32m----> 4\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mmmd\u001b[49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:336\u001b[0m, in \u001b[0;36mCumulativeIterationMetric.__call__\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m    334\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mextend(\u001b[38;5;241m*\u001b[39mret)\n\u001b[1;32m    335\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 336\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mextend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mret\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    338\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\n",
+      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:209\u001b[0m, in \u001b[0;36mCumulative.extend\u001b[0;34m(self, *data)\u001b[0m\n\u001b[1;32m    207\u001b[0m         b\u001b[38;5;241m.\u001b[39mextend([x[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m torch\u001b[38;5;241m.\u001b[39msplit(d_t, \u001b[38;5;241m1\u001b[39m, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)])\n\u001b[1;32m    208\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mAttributeError\u001b[39;00m, \u001b[38;5;167;01mIndexError\u001b[39;00m, \u001b[38;5;167;01mRuntimeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m--> 209\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m    210\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00me\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m. `data` should be a batch-first tensor or\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    211\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m a list of channel-first tensors, got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(d_t)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    212\u001b[0m         ) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m    213\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_synced \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n",
+      "\u001b[0;31mTypeError\u001b[0m: split expects at least a 1-dimensional tensor. `data` should be a batch-first tensor or a list of channel-first tensors, got <class 'torch.Tensor'>"
      ]
     }
    ],
    "source": [
-    "real_eval_feats = []\n",
+    "y = torch.ones([3, 3, 144, 144, 144])\n",
+    "y_pred =  torch.ones([3, 3, 144, 144, 144])\n",
+    "mmd = MMD()\n",
+    "res = mmd(y, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d0219bab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y = torch.ones([3, 144, 144, 144])\n",
+    "y_pred =  torch.ones([3, 144, 144, 144])\n",
+    "mmd = MMD()\n",
+    "res = mmd._compute_metric(y, y_pred)\n",
+    "print(res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b671b2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y = torch.ones([3, 3, 144, 144, 144])\n",
+    "y_pred =  torch.ones([3, 3, 144, 144, 144])\n",
+    "mmd = MMD()\n",
+    "res = mmd(y, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0d92309",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mmd_scores = []\n",
+    "autoencoderkl.eval()\n",
     "\n",
-    "pbar = tqdm(enumerate(val_loader), total=len(val_loader))\n",
-    "for step, x in pbar:\n",
-    "    real_img = x[\"image\"].to(device)\n",
-    "    features_real = get_features(real_img)\n",
-    "    real_eval_feats.append(features_real.cpu())\n",
-    "    pbar.update()\n",
+    "mmd = MMD()\n",
+    "\n",
+    "for step, x in list(enumerate(val_loader)):\n",
+    "    image = x[\"image\"].to(device)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        image_recon = autoencoderkl.reconstruct(image)\n",
+    "\n",
+    "    mmd_scores.append(mmd._compute_metric(image, image_recon))\n",
     "\n",
-    "real_eval_feats = torch.cat(real_eval_feats, axis=0)"
+    "mmd_scores = torch.stack(mmd_scores)\n",
+    "print(f\"MS-SSIM score: {mmd_scores.mean().item():.4f} +- {mmd_scores.std().item():.4f}\")\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "5676aa62",
+   "id": "d98f914c",
    "metadata": {},
    "source": [
-    "## Generate synthetic images"
+    "# Compute MultiScaleSSIMMetric and SSIMMetric\n",
+    "\n",
+    "Both MS-SSIM and SSIM can be used as metric to evaluate the diversity\n",
+    "\n",
+    "Compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "id": "a34810f9",
+   "execution_count": 29,
+   "id": "eb2cd8a6",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.43it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.40it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.77it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "3\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.75it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.62it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "5\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.63it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "6\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.50it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "7\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.48it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "8\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.45it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "9\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.43it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "10\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.44it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "11\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.45it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "12\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.42it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "13\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.41it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "14\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:25<00:00, 39.43it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "15\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:18<00:00, 54.08it/s]\n"
+      "MS-SSIM Metric: 0.0012073 +- 0.0101628\n",
+      "SSIM Metric: 0.0059797 +- 0.0144561\n"
      ]
     }
    ],
    "source": [
-    "synth_eval_feats = []\n",
-    "unet.eval()\n",
+    "ms_ssim_recon_scores = []\n",
+    "ssim_recon_scores = []\n",
+    "autoencoderkl.eval()\n",
     "\n",
-    "#pbar = tqdm(enumerate(val_loader), total=len(val_loader))\n",
-    "for step, x in enumerate(val_loader):\n",
-    "    print(step)\n",
-    "    n_synthetic_images = len(x['image'])\n",
-    "    syn_image = torch.randn((n_synthetic_images, 1, 64, 64))\n",
-    "    syn_image = syn_image.to(device)\n",
-    "    scheduler.set_timesteps(num_inference_steps=1000)\n",
+    "ms_ssim = MultiScaleSSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)\n",
+    "ssim = SSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)\n",
+    "\n",
+    "for step, x in list(enumerate(val_loader)):\n",
+    "    image = x[\"image\"].to(device)\n",
     "\n",
     "    with torch.no_grad():\n",
+    "        image_recon = autoencoderkl.reconstruct(image)\n",
     "\n",
-    "        z_mu, z_sigma = autoencoderkl.encode(syn_image)\n",
-    "        z = autoencoderkl.sampling(z_mu, z_sigma)\n",
+    "    ms_ssim_recon_scores.append(ms_ssim(image, image_recon))\n",
+    "    ssim_recon_scores.append(ssim(image, image_recon))\n",
     "\n",
-    "        noise = torch.randn_like(z).to(device)\n",
-    "        syn_image, intermediates = inferer.sample(\n",
-    "            input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100\n",
-    "        )\n",
-    "        syn_image = autoencoderkl.decode(syn_image)\n",
+    "ms_ssim_recon_scores = torch.cat(ms_ssim_recon_scores, dim=0)\n",
+    "ssim_recon_scores = torch.cat(ssim_recon_scores, dim=0)\n",
     "\n",
-    "        features_syn_image = get_features(syn_image)\n",
-    "        synth_eval_feats.append(features_syn_image)"
+    "print(f\"MS-SSIM Metric: {ms_ssim_recon_scores.mean():.7f} +- {ms_ssim_recon_scores.std():.7f}\")\n",
+    "print(f\"SSIM Metric: {ssim_recon_scores.mean():.7f} +- {ssim_recon_scores.std():.7f}\")\n"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "7701d943",
+   "cell_type": "markdown",
+   "id": "30ad94fd",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAClCAYAAADBAf6NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACP70lEQVR4nO19WW9jSXJ1XC4iRW1VXd0e2MA8DOBX//+f8sFPhj32dG1SSSLFneL3UDjJc48il3tJieppBkCQvGsukREnlsysttvt1k50ohOd6EQnOtGfljrHLsCJTnSiE53oRCc6Lp3AwIlOdKITnehEf3I6gYETnehEJzrRif7kdAIDJzrRiU50ohP9yekEBk50ohOd6EQn+pPTCQyc6EQnOtGJTvQnpxMYONGJTnSiE53oT04nMHCiE53oRCc60Z+ceqUX/sd//IeZma3Xa1uv1+H4drs1b92iqqqsqiozM+t0Osljeh+o0+mE/3pdCeEd+u4YcT3w+/n5ueg9Jc/n8nQ6neh9fF3s/dx++N3tdmvXbLfbcP/z83P479WTCeXR+2PlibVzt9u1qqpsuVza09OTbTYb+3//7/+59XlN+tvf/mbdbtc+fvxol5eX1u/3rdfr2Wazsel0as/Pz7Zer+35+bnWJ71ezzqdjp2dnVmn07HRaBTuHQwG1u12rd/v1/qA2wnPRJvzWOE25m/up81mU7t/tVrZ8/OzLZdL22w2tlwubT6fh2O4Rt+7Xq9tu93aZrMJz9YyaTn0eCnleAuk41plhDf2vbGi1/A7cQx94rW9nuNrqqqqHZ9Op0VtcEhSXtT+0Wv526M2a8wdYl06LlPJ85rI+za6oSkp7/CxpvcpKe/y/yZt792XkttKxWAA5AkNfREzbVVV4TwPeL6Hlcl2uw0DgO/D8VSZQCoEtGye4Ihdj+tSnar188qiddYy8fUsoGLMwOWJtQ0LdDyTgVwJ6f1eW2u9AAKYITebTaP3HpqUX/VbB0232w2/UfbNZhN4EwoX/5lnoXj1N5fDEyo6iGMgotvt2na7tV6vZ71er3YPFCnei7p49S4BA3ws17be/xQ4SCl2PucpuZw8UEVeUh6vTLnjr01eW6Tq7h3ntuDfTcpwyIVqD/2816R9ylnK+974KeG3EqDRhIrBwHg8NjMLgi2mfEA5BO+da9LwTS0Q/E55InLvSd1X2iEKGErRfM5TAU+D3uf9hwUcK3tb5oJngj0D3W7XFouFTSaTInT6GjSZTKzT6dhwODSzXR9sNhtbLBY1xal8BasMSli/tc6qzFnx4rjnScEzuR/xXnyfnZ1Zt9u1i4sL63a71ul0XpQp5VnzeC2lPBQQeAaAB1wVQLJnA+2Oz2q1ss1mY/P53LbbrS0Wi+B9hEdjtVrZdrvzcKzX65qXwwM2OWOF+4s9Ed5YOKbiGg6HLthkUm9GjmIgLwWamngbSmR8DsiVUClYLb2mbTlilFP4eo2eLwXhsX5jj2UJFYOBxWJhZlZjRmZSFKRUMXPBdcB5AoiP62/vf+z9OYsjV+bceX5mqkzeAIqBopwVp/c3Laee88I6sb7jcyxkzX4qM4CB2Wx2NKG6WCys0+nYcrm0s7OzoKRZ4SgYYG8Bh1+UfzQ8wMRKMSYw0Wb9ft/MLIQkYPUjJAEw0+v1bDgc2tnZmZ2dndn5+bl1u10bDofW7XZrwIWBAgMHVnwarlMB5gFRKOKYMsa1OI/rEcLAZ7Va2Xw+t/V6bU9PT7ZarWw6ndpqtbLFYmHL5dLW63UtFKLvBqW8HuyVYuAEioUjD215tSHwBQiAQAnKK+cxiMkP9abocY9Ufpd4K1IKcl9qqhPanG8iYw8BUmI8mAMCuKcJ7xaDAXXzKrLW4yWIOqb8YsyVY6RSQOB9e+8oeU6TZ3MZvTqi81TRpkCA9369NmUJegrf+/aQvVd2Lj+XE67qYxA8WSnljPKhTpvNpqYkVOkr4o6BAg+dewN8vV5bp9OxxWIR7uFckKqq7MePHwFgQfEDPOBYv98P9+KDvAb2NKhHAee89+K/Zz3zsdiHwxpQzviGpxGgbLlcBgCBc5o7of/5mWh/AA/kVmw2mxDaAchQMKjfz8/PNVB1DOr16iLa83SAYvKDv1OUMkZi15cafyXv31c+tLm/9J62ZUvplxLdo7IiZXCX6okYFYMBFoIpCx/kKQ/vHiYPYJS8SymnLGP3N2XelLWdK5sHdjwrjZWY935v4LKyy7UXC+1UnfSduftAUMSa3PiW5AGAGIoGf3POACv6XChGKYXO+V62oPUDhaVWL5cXn36/X1Pi3W635m3ANXxMrwGAALDANXg2P0dBCAMN78NtwmBEwxwKPFK8xkocn9lsZsvl0pbLpU2n05r34f7+3qbTqc3nc3t6egreB/4GeOj3+8FVfwxiMFBVfpigRMF44N0LV8UAgVIb+Wjm51WBDhlGjIVjzV6OuxJieZoDS15/6LcX1i0th8p0fCMfjL1kTXLEisFADG3EGlkL7iGc2H2xY6njuWtyKDb2jEMLgRyyix3LocHYPU2QLyt6PZ4rp9nLvmWLvGn7vwZpiCt3rfe7CZWCwtx9AFIMBrzkRTwP5zjUUVU/kx7xvVwua6EDgAAci3kU9Fq9D/eCUrMCGIBx7oUCMwUOChi07aqqstVqFfIR4AkAYICCx0wRnHt+fg5gAOCs1+sFoHMM8vjVk6UxJR5THN61HhhoI/9ihhZ40rsuJxObliOlp1Lvi53fFwyAwEcpD0+Tcmkb6qcJtZ5NEDunysNzm5Y+23te005UijFqCZUg8NTzcoAq17be81Ux4FgJM2iZVVjzQPSO4RvZ68zorLTYk3AM4nfzjACdxWJWT4jT0Fgq6ZKfEaOUIFGlzu9Q/vBAtp7j+sA6yAHwWN1S1qY3RTjFqzqeWbEzac5DVdW9HvBQALAMBoPwrSEPzqMAAMB1PH3UzML0Te6XYwEBs7SB5bWt3tcWgHM/NQHyKSBQcm0byvFr6btScjjVnk3aOFaOXPlSBljMW9kUcDQGA0qKSvdV1t61bTvAE0qeIi4VjCkrjgdoieWv13v3ee3qWe+4pqmCYiWda2O9plTwtEGohyZPGAHAeOWLtYcXJiihEsEcs4BiIFP5xitzrI+88pSOMVUSHmBJ8X+Mx7WPeB0OBgP8n5MsZ7NZCHeotwJJeOzpAEhggAHLNWa9HoNKLOMUYNgHDMT4KncfyPNcpDwc3nNK2t8zGGOegFw7lo6j2PmmZW3zDCX2wJq159liMBCzGkEsWEsVQKxh9Jomx5tSTDjl3sPCQ++NMXwMDMQUPJ/3ysOJXV5ZGRmqMmCLDC5aLROXm93N+hwGFWY7dzaEeVOEemhiT4DnEYiVDV4EbWecS61Zoe2dAnp8zz5WjQqEQ1m0ugiWuudzglcVU5M4LT8bbe7FQWNTA3GOQywKKhgwgDh34vz8/GiggMdvrM1LFH+q/KWGhVKJ4VfybO9YibUfoybAKXa+BLg3KUtKUafGUupalR2e8famngGPPEuWiY81Veo5lKaUcv141za9rpS5vP+5e2OM4QmGHGhSQZxC/dp3nvXJfQwF4SH090BQEqwgS0DovuWPgeOUZZDrD6WY0GTLOnavRx6AULAZU7hmdUUfm2GhgNQTWspfIF6/gc9540rbH+sVIMkRdeH8CJSJEysvLi6OBgZyCj7GNyl+y8nEtmM4xR+lICBXnqbXxoBp6rn7Wv8l5Wp7jXedZ1A0McpBjRMIPXdMTuDt62oq7ZxYGZlSjFoyOFLXp8pdAgq0/LHFnTjJi+/V6VW41qsvk1r9amEqIPDqGmuDpn3/GqQKg+fLe1MFNTmPj+t1/Hu73boK2ANS3Lf8niY85NVRPTcpagIQlCeaPCPF+6AmFkzMW6PP1jZHXoDn2eA+YA/Ser22yWRyNDCQoly7enKlrRwuOc4UAyAllnEKVHj3xa4vBTUleuPQz+HrVD7E6s26tqRtmnoGD5Iz0OTapi6c0ueXCM0SC1qvzz0P52NoLXVOz6fuAXkLxoBBdHqVWsKeBWbmg44S1Ix3qNLU5zTxzrwGeYrRawe0EdzKXp1iC76g7c128/O95+MZunRwTFjmQGfMMmSgqPeWKHMWTKkk4DZgIHas9HkpfgN5Mw1SxEs387jBugTHplSdmb+b8ErJeGwzZpVnPUWXMiBK3h0bF56xWkolij51rETme/VTQ0spJj+9NtBnNAEEe+9NEDuesiLaItUUeYo5hxhzDRk7FhtgbQVjyXVeJ7MFw656Xhe/lOG8OuTuTT3LAwnHtq7UvbzdbmuLDbUZSLqmA96B/vFQv4I0UClQLuHTmPJoyqM5IZgCuk2e35S3cvd4Hp/UM3VZaRDPNHgvpDzFx0soJwuaGEYl/ZR6RxuZ0EbB5+S4d01TcNCmfPrMFJB6bWqcQGhWBghKlWOssrlGKGHOnDDMIbFYOVKWbozpSttCn8sMws/gBV5UaWHFNXy4XwActHz6Hk+JeRZsSiCz4jsmEFDPANef5/Cb7crPiyTFNllSj4CZhTnqyFQHsXJmq72JEiwhj7/1W9sj97up0ikZLwqiPQAfa4sYkPKsT6+vvbLps80s9OMxwUBKYaPO6hlIybUY33kAr9QAKLHGc/VIlaOUUuUoATFNDbUSxd0EHKfuT/XpPnVh2itM4DFKqTUeY5gSxZl6D6gpU6UY2Bs4HuO1tcS8ezzBxoSkJ6xVz0p+NpuF5ViRNAWFBuWsXoOScnNZSoDQMQFAjNR9zgra7CUo8M7xvVghDu2J1QJ1hbFSiyrHa0o5PvH4skR4e+8pFbYpsMzXpJRNE1Cv5fGAbOx4qv46zfCYVDq2dIyWyGhtu9S1peVsev2+x3PXNZXNpZa/Bwj2eW/ufanj2ucK+nPUGAzkGjDXGDnlzcwUa+hSwNC0/PswcOkgaOJeQht4zxwOh3Z5eWkfPnyw3377LRzfbDZ2e3trT09PtlwubbFY2Gq1stlsVkukgwXrvZ8tL61Xroz6m93wb+XuUsJ7MSedF0JSRZ9S4JyjgdXpsNgNjmMZXIA0PFvDNkqa9OmBEs9qKFGeaknjObG8CFwT8xiklKhnoXrX63/vdw7YpKywnJeA38/AzfOaNd32+7XIa8eYfMA5/Z2TnW2NFzy7DTUpT1Pl2hZUlNapFEyXvrf0ek8us1EKfn+1qYVtGCVHJRamHksJhNxzmr4rRvu4s3LP5A6NCUZeNAVKh5VUr9ez9XptvV7vxa5t3rdSSsFreXP0GnzTlmLCxQufYIBpGAY5Ad1u9wUYQL4GT1/Ds2LhBn6/5oF4ZfXcil4bx6ZRar1iyZSgnCL3nh1r5yZuzxLDwgMpnuUfs5ggNGNKFde+Jx5uQm3LHTPEmtyzb9naAIES0LOP8o55+Nrog7ZjLFdGpdI+aZUzUPJCthCaFsy75lDWZcqCKkGDTZGi55LLvS9m8ZnZizyB5+fn2p7w6/XaxuOxTafToKywFj12YauqqjY1Uafe8VSylHvbE6AeEzd1Vx2aeFnafr8fNqTBOdQDXgxdSEr7CVsJj0Yj+/TpU7hvu93aeDy2xWJhi8XCnp6ezOxlchojdm5z9jygPHyNN30wpsRi6/YrARSkLIgUCIldEztXogBivOeVXd/B5cN5DpHhPtQb70stPX1s/lUqlbUl95bcd0hjp4nCK7k+FtbQ61NAIiXjUuUprUeO9tGVMSrRZUqtcwZKX9KkgqWAI6Zw9VkpK6REUJa+P1WO1LlY26QsI6zZzooCiYLz+TzsBb9arWo7zPGWrLA8ofhiwj1XX68+McvwPRC3m64Z0GTwAAhcXFzYzc1N7Zndbtdms5mNx+MABtDeeH5O+MTariSvIfcMPs/laOOJaCqsSniDeT/2/Jw3UYWrJwfA+7HZBnyu7TLUhyItd0kfpIynfaz3JkZNyTubyopDyZaUUZi7Jzd+Dwkcc560ttd61NgzwMyYsgJTVsu+1ESRx67l71xn6uCLXV9S1yZl5bZWgYRz2F2tqiq7vr4O2e2z2cyur6/t+vra7u7ubDKZ2HK5DLu5pdpFrdTSuuXoWNYV+pg/vLOf2W5+OSvuGI1GI7u5ubEPHz7YX//6V+v3+2EGx3w+t+VyaY+Pj3ZxcWHz+dweHh6C96YkVKD/PZ71hHEOAMfahb0TTB7o8ABBCfAwS3sy9FqtF1MJyOcpn95GXh5PgLz+P1YioTdOPYvX64eYwdRETnl9kAIhbWRj03Ox62PXpoyrfSinJ1KUqleJp8LjXXzHpjXnqBUYwLd2dA6x52jf+2PP4GcpCMiBAW1QbVwehKXuJu9ePc7v1bbudrsBBOBzdnZml5eX4f6zszP7l3/5F/vtt9/s7OzMPn/+bLPZLHgPODatCYOsEFMuSE8peO11bOI+9vYliFnV2q/4j/DAb7/9Zn/729+s1+vZ09NT2PFus9nY/f29XV5e2sPDgz0+PtpmswnnvZkGHL7RcmvbpxL/ckpNScGGegtwTewdTQRz23M63U+3O2bSsek9h8cXr2QYa4djerpiyliPgTxglyq/x18eD3nv9DwvJTKwiZwsAQOpuuVAzSHIk5E5r6+WM0YpIK6yGgT50hTANl6O+DVJmalNZ8UUUQxBl7giU50cQ14lQCBXHgUafA/i3ggF8FKrmE44m83s/v7eJpNJ2LMdiW+pNjF7uZiOV24tp37Hrj8m5Vzh+O3xDhTGZrOx9Xpts9nMfvz4Yd1u1xaLxYvloC8uLuz5+dk+fvxog8HAJpOJLRYL9/0xIeXxRuk+ADn3tpc5r7+bCBTl0aYUAwLcR6nZHqXWaqzNS/rgrSmmTD25ELsmRTnjKVeWNtQWKJaUqYliPQR5+iqnD0rffQjvXxNqDAaaDsDYfSWKOkcxqyCGnFNKN0aHEmql7Ra7Fh8kn81mM9tutzadTu3h4cEGg4H98ssv1uv1wrXfvn2zb9++2dPTk83n8zDTAKgxNtUqZXmmysmMCsGtno1jEJcBH02wU6XHFrqXADidTgMoUEu/qiq7uLiwT58+2eXlZeiv//3f/7XHx0dbLpdhulpq5Tu0Z0whe4peQUFOmcf4su19TQRhjMdSsyByZfRAnedBgEXlnWNC/xwzZ4ApJ4djICElk9pYqylPYSmVyJgmwKGJxyBGJXWIGa2lSjrX3iWAmnWcV2/PK5KjVgmELFRjCll/lzwzdjxWmaYIKWXB5sq0DxrLtUMTEMSgYLv9mTyItdNhnaKcWHhoPp/XhMM+FkOuvY5pReWoCSiJeQfMLLj8q6qyp6ensGQtLxG93W7DtM7hcGjb7c+tc/v9fm1vAvY66LvaCq2UImceOPRY/WcjDiH8UagJf5dep8aaAvwUHzXh4ZwXpCnpvVx+fl9JW8TGjXd/CijFLPsm9XwtGbuXZyBm/Zco0ZwgUiuzSRn1/pJ7chYLDwK+pmRAxMrYBgRghTtkxmNq4Wq1MrP6Rivz+TwABIQOtLyKLGMgz6PcNQxatO5vSToV07MYuYyIS2t8H9cul0sbj8fW6XTs4eHBer2effr0yYbDofX7/ZrXodPphHUgrq+vzcxsOp1GrVIth2cxlCj73Dm9riQckLo/NeZjgtDjs5TiLbXamlKqHDHPwjEoZTDFrokpvCYGSkqGlzxH722ihLUsTUnlXEp/5crtgQu9Rs/lypa71ysv18d7l4K1UtprOeISy7ptR+7TmN79HiPHOrppmQ+h5FLl4WO82x2OIVY9n89DGKCqKlssFiGc8Gex5jwqFeZoX7Of1j8AAZ83+6k44eaHxa85GQyEcMzbT0KT43L87JXHu86j2CqHqfZoclzP5candy6W57Av/+6jUN4DECih0n6JnUsZbDFPUq5fPJnaRrbHlLP3jpgCLQUuqWubjrnYtSmg3Oa5h6BWuxYyI2gnt2GYtnSoxkt1zCEEor4Hx73203NQKFAUWEbYs7oXi4Utl8taopu69bSvdNDl3MeKsFPI1qvPMUjXZWDCf97+2cxCW7OFz+57KFOEYp6enuz5+dnOzs7CMtCYzjkej225XNrd3V1tLQjPO+CVh0NCel0T4rp5UxxzAjjFFyVjPaWQ+XibaXypssaIV3wExdaeODYgKKlPyhuaco+3UeyllFJ2/Excq/IpJZty72taVu/6EqCUohJjlb1knvdMn6PPjNXV84akqBEYUKFeIhA8tMaF9e5vck1pRb2G8o41eWauPDFlz79VAZnthCG3HT5QEt4gQaiAXZspoKb9VSL0uTx8LNUe7wEMaEKeljm3jjeHC7rdbpjSyas/mv1U4v1+36bTqZmZrVarkDQ4nU7DSpAAagoIYmDAbBfiSLVjqQckdy7Xp/q7KWguEVIpIVf6/jbU1u372pTqe0+ZeFTqSdXjpUqlifJJ3at6IwZmYnK8hLeajgM95/1v46nOgc0SIJADgiW099TCUuHTFlnHhFPuf66cXpm8+/axwLz/JUzASDFWdl4QxrP++ZMCcFqOHBBI1Tl3/ljEyjY2nU6tQ924iBP+PNAwn8/t+fk5WPxQ3JiCyEtCs1KPATHdetoD4jFB5Xm6Um3jUYmg5N9NFIV+NyW9N6cgc2WK/Y+Nv7emHAjI3dumnb26e4ZArjw5YJICGzFeVv6LyfFSL1fKCGzSfofgk1KZG6tzCZiPUSswsA/6a/Mu71wJAEg9O8Z8Tcujz/TKeQjyLHxWUAwQcD0rQdyrjJ9iIr6nKRDwhMaxAAGSKnPELmPE/Zk8JQiwMJ1ObTabBfc7rP/tdvti/QF+hiek8MmtA+B5FDwl2caa8CjG09rXbYRiiQDn56fKov9j/KuJnl75jz2TIAa8csoz9YwSgJSrd4p3Y3JwX2Wpdc55jrzjuWOx87l2LWnTUuDWlmJTbQ8OBvQF/LuNddHkXTE0GHt+Scd5irFNuVOMVHJf7p5YPUuEYMn7FJ2XlClVLr2/CTO+FuXAjEdemRFjZkWP6wACoMQZBKSWINb3eUKW66G/c2MvxZ9NAXTpb+/+nBfDLC/s+X9u/PM9OSDA9x3bC3AoaqNY2IDg5bmZ2LPFOUv6bv3t9W3KMCu9Budi78+1Qcnz9Zm55zS5z3tOU2+Wvgf9V7peDKhVAiG+UyjQKyQKyudy7g5+F1NsZ7kmdfAEao6R2gIF71jqWTEhmVLqnicgFgfna1NWQKpd9Z05i/FYpKvYpQjnlb9A2PAJMX+Qt4iTJvzFlDu3k/If8yg+yF8oTUBkz4S+q6R/Urynx2LlMUsvbav3xbwBsWtSwInfr++OTfH0wMIfgdqONygQzHg5Ozuzqqqs1/upIniWDZKY8c0hLZQhttKnAjqv7N41MbDgffN5fUYT8NyGYqDAKxdflyunyoHYO7fbn7OX+v2+mVmYUl5Ce3sGXoOaWCwpxokJJT0Xu6YNuo49q+n5ptfGBlcJczK9pgA8lnBNARaPPPe8DmBMI8RxtZKagD6vbNxWrLB4O2azlysYos8hrLnsmpRYVbv8h1J+LQXrJe0QG185YdmGPCCgv/na1Pm3ptcC1aoswVu8Myp2PcX7seIm8w++deaT9z7UJyWbS61177nee0p5J2W8tdUlbyF3lZ97vV5YidYLd8Zor3UGzMrd0Xq+6SD3dlTLvRvCM1f2WFk9ZjyUcEgxF1PKE8DXeGWFEGlTZr4vhrxz5cf7D4W625LO5VelG2s/vkcJgAAEIejxG9qNNyOCFcaLRKnCxzmgfCxoxGsV6HoFEMrr9TrMdFgsFvb8/Bx2VsSaCOv1OgAGDnOo54ABgx6LrXvgtSWvjsltgzorz6msKFXmSrl8AFaGsfcck5oAWb3Ho5gXBytknp+f2+XlZVgwi0MG8IyBn7bbbVjqHPyGZNntdrdIGt7JHjT0cQzs4J05uaObbaWu5Wv0WKqdDyW7UiDJK4t3jY4LyI5+v2/dbtc+fvxo19fXNp1Ow4qnJbQ3GHgrKnEzMZVYOrnBHrO2DwkIPEVUikI91NuGaVN1Khlk70Vo5igleMzKLRHOHYidY2IlAyXf7/etqqqaO1a/ARr4WoABLC7Fu0+a7cIYq9Uq7IEAYY1vHOcZDp5nAf9VaKOOORCVOu6NK+2DHF815bvU9bH9EP4IdAhFpbw5HA6t1+vZaDSqTc3lsABAJRbdAl9hrRNe5yS2EmnOOxWTcSm5rL/xHL1+X4rJ3jY8lJO/sXcwYIJcOD8/t6urq7AK7auAgTbI1LMwvd/edbxy22AwqLn6gEBZQDFqVcaLlSNV130UYBP3UIkyLjneFrjELK/S9nrvgCC2010sLly6/WeTTHMerMPhMFhcUPCw+uGahVBm3gcAAEhgQYB6eJ4BCAR4BrB8NYOBxWKRtPq9/2hPvoevVY8CP1eTLBWked6DUn7Ufon1sVpgsecfc0aBJ8fwfSilw/VWHozxHJcDchdgYLVa1XgOwBN8qbNsdLZNTH7zt/5OeRFyQCBlhecoxZMxfZcrUwr4gG/RN1D+vV7Prq6ubDAY2F/+8hf75Zdf7P7+PujFEnr1LYxLFYw3+CEQ+/1+QDoYmOqKen5+DgzIoIATvbbb3W51ObeR1ruJom3CTCnLvlSRpyzdJlQiGPV8iQfm2MR1iLn89brYWgOpZzOh3qx0GAxcXl6G3woKeFvqbrdbAwMYFzHXNytZCF4ofIADBQMIJTC4ZuXsKWKtt66dgDHIViGOcZgCIARjmRWBgp0SJV2iDGIzCUqv/SNRSXvgGD7sIQCveV4pDnGZWc0zAP7C3ijz+TyAAvQ/tvPmUBXzSQw0gjyA8Fptpe+A3E4pfO9YipdiIIV1BIcEBoOBDQYDu7m5scFgYB8/frTRaGT/+q//ar/99pt9/fo1rHFSQu8qTKBCgBFpv98PaLWqfsauzs7OaszT7/dfxK6QTRmzavC+JmXTYyCv82LXxp6vz2pyzz7UVOB5gwHPSVl4x6CUZZgiz93PYYAcEEgRgCoEI1tcmBb0/PwcEoFY+LLblseKVwYFD5yrwPsv8DtZsXMfe94IFZYaTuBncfY5gwEG8lAoCgpKKTZO9+G99wBo21DTdkPfYLlsWJRIQmMe4dwVBrs4Dr4eDAZh507OU2EgqMofgNHMat96Da/pEfMYNKGU3I49syQkUUoY/14ukeYFDIdDOz8/DyCg3+/bhw8fbDQa2dXVlV1cXNhoNLLhcPj6YODQA0QbnT0Dg8EguEIQywJDoKGen58DCsKyr/P5POw7r1MswISIfcbKogo+pbS57KXtk7ou573Yl/m893n1zT0/ZzXi2DGFas51nAoNeJ4lkOfZ4edA0ep7VqtVEGIAt51Ox5bLZS2bG94CFQzqJcA1OM7eNfD42dlZKBML/u12GwSzTpHk93KeAgMTDxSyFadggAX+YrGw1WpV28dhPp/bfD6vrdiIcmt/xrw3Cti8fvL4m8fUsRcc8ojLzL+beBRj41CVRq/Xs/l8bp1OJ8hfeKzYqwV+4FAu9wf6Ht/gO2ytzgab8gnuY6+D5rt4QKEkD6FJ2+TkdBP5FgMcPM40WRhtOxqNrN/v2+XlpV1fX9twOAxg4Pr62s7OzuzTp092c3Nj6/Xavnz5Epapz9HRPAMeokopZZAKOTQergFDMzOmElk8QRBT6jmLP+ZS8ij2nPfiknwv5TgENY3tp4BfGw8OEyth8CIn4+lMg06nY6vVKihhVsbsOYO1xlMevXbg4xA28Kp5YICTFBWkeBaMggB8x4Q+gMzz889NnlB+bq/lchl+p9rVo328AscGsEylZdnXA8JKmPfPAG+hDOodMHs5BRY8Y2ZBRsMrBGXHAIFDAryeB4w+3AMwgHKg7LyxWEyX8O+mStx7lllaT+T4T4F7VVU2GAxCWGYwGIQwIvIDBoOBXVxc2OXlpQ2HQ7u4uLCzszMbjUbBcB4OhzYYDIKRUEKNcwa8SqcaM2UtplAYmBKoBtvzskWE0MFgMLCqquzm5sbMfi4NC1fXbDaz1WplT09PIbMaMVPEKXVRFq/8qWOM1Eut6BILv7Rt9Tmxa/R3zKJP1SN1POYuS/HAW5DWhy3y2PX87Z1TylkObPGs1+vaOgGqoLm8MeXP8VtONmSQjOez94ATEVEf3tUR5eX8HJRDvRE8Dx31ULCND4cHcA75DNvt1i4vL22z2djl5aWtVisbj8dhg6fxeFxzCXM/xojDOR7leJFB1nshT+k0oZws0YWqqqoKngEoI3gGMAWx1+vZxcVF8BTAk+vxHLe5TnGFrIe851kxnPwKTxI8C5wgi7wEnGePBOqfk7ulXoOYN8lrV+95DOzRRqPRyHq9nl1eXgYPwMXFRQgLoM1x/PLy0s7Ozuzq6irc1+/37ebmxi4vL202m9nV1dX79wzkiAEBBChcrHC9ssuUXaVVVdlyuQyCcrVaWVVVL7wGYPrUgPc6OoY6U4ykSLGJkvfeWUolyDR2vI0l0sQ78la0LwhJJRDyO7TOfJ+GIcCTaonjPgYk4HV20zMIqKrdtEMGA3wtrDAofc07UMWpoEJBAIMB9hBofdQTAE+EmQUvACw/9iAAOHQ6naAA2I0NwBLrk1JvUAz4sXVbmo19bErxuTceVW6hr3AO/YnnrtdrOzs7q3lbARDYo4N8FDaQwCf4r6EqyHR4iVjOs9eL+4VzUgAszKx2P3gkBaI8+R1rr5h843tVV3hGGOrBMzeGw2Gw8C8uLoIHAFM8AbhwDZQ/rrm4uAiAgT0DpbK4MRhApT2LM6XoYlZrzH1jZrVEEqA+KHq4UjabTS1LGwzF9wNhbjYbe3p6CqhyNpvZcrm0x8fHWuYrGAsfdX2Whgv0fFNrO/e8EipVhDGvQImbNYaIwfBt3XGHJHZj7/MMJY2v87v4P59XBQZQqsdSz9WwATwNnNQFawyeM4wPjB1vxgJbcmr1c4IY3qPrJKj1xe5fntUAxaOZ5Ofn5/b8/GxXV1c2m81sNpvZ3d1dbStoAAOM1aZ9yLzOoUYuP7yOfxQgYNYcgHsWscpg1B+hKvY0gZ8mk0nNhQ3XNWLbPP0Ns8OqqgptDHnthQrgEYAXoN/vBx5Awjj6idc74GmO7GFgAFGSeKjHMHYVRAKc8rhnkM2eEtR5MBgEJd7tdsOsAHgGzs7Oaooe7Xh2dhYWhuK1IOCRQfIgwgilwLgYDCjyKWW8lAvFuw6/gfzAjBAkQJ1cLqBSFlRgMDwPTIAkw6enp5Bg2Ov1gjuSF2sxs9q72O3pKUlG0TkEWeqCLgUQ+yi5kr5pAwhKnv0WxC7wtuRZkBAATCwsYoNQlT+7M1kYaxKUlkEtL/2G4IbCn8/n1u12g9Bmq4K9arBWNPTA3gic5ylnXB+tG1t5EN6cXIm6D4fDAAqWy6XNZjPr9Xq2WCysqipbLBY2nU5D3Dg1W0jLouDMA1O4HlnbZi8T6/5IVCp/+VqWYwruOBdgsVgEzytk6NnZWchg55Uz+ZtzT5iX+f0AA+CVqqqCMcieKIwjXIOywCMAEKFjzgPkqTZpA7Q8zwiAOGL7SPyDex9ACmAAih6KHyAL3gOEydlLNxqN7Pz8PDz/4J6BfWJV3j0eoPCei05jBQ3LAN8soICawDAMChhM9Pt9W61WdnFxYefn57Zarezh4SHMRoBrElOfdIEMRpY6YLg+6nriY6kBWqpEc2EJ/R8DESXK3HumIuHUO98DMGhLXr9x3T2l47UHhBSma3FSlt6rHoUcv5S0r4YQ1G3JOQr4QMgAVMC606xnD/ygjgABHBtmFzHnEuBaCE4onOFwaIvFIsw0YC+ejkEdc147amIkX49zi8XCxuNxtl3fipoode9Y7P6YfPe8tXDZ4/9sNguJfZiBsFwug4zt9/s2m80C+IR1OxqNat4ogE48G+MN/xkMAPRysmFVVcFbDJmOKY083ZzXu1APQUq3eSCcPzrDhscFe68VDEDBX11dBW8AJwNymAD34Bw8Ajz+8S58SvNeDrprIY57AlKZMeZW5+dzvGc2mwXkB2vn7OwsTE+BuxLuTggxHGdBbLZLYEF4YL1eBzfk/f19CCHwohmMWPmjTOUlImoclevtMVkMLOTCETnlHTvHVq43IFLPipVFzx8rTBDz0pQSBGBJqAc8xu5oEFtCOkBjigrCBaTjC89R4ODVlYGA981WF8cyMaZ4gSQWNpyvowmRDHjgIeBpYrPZrBY6UAG72WzCNKlff/3VNptNAOusCDDjgElBu/aHhlrQLzyOn56ekp6H16aYfM0Bn9z9OKfP0Xby3sMy1OynoVZVlU2n05rc7ff7IYTAyW4XFxc2HA4D6GPvFIAByoZZCBwSQBig1+vVEgUHg0GtDRBm0HAxh5hYfnv9zF4kfLPrn3me82fYKwePAPICAHJZ0Xe73dq0QY7/AwTw2AMgqKrd3iW83g5/SumgCYSKrlLehBjD4b9a1IwS2X0KhsH8bHyztcHok4WlIkxOkEFsCrkKQFgs2BgM6Dn1GrD1kmoXBgqpgen957aK9Q/XX3+XgIDSc02ueUtKAYJUQlrqHrOX4YEUUFOBoteolc7X83PYavKsXQgmTyBBWHuKXT0GXK6cB8I7z94QCC9uo1jmP+7D2Ov1esETiMVsOOtceb+q6klmWk6vH6AQWH5MJpN3mzugslb7SNvVAweq5Evfqc/QZ6PP2cuC45CpkL9QWjGlzJY2v6vT6QQDkfsZ/MJlwXtZbvOCRyqbuR11Ci2PEw6jcdiJZ/nAwwWvCD6s8L3ZBBizHArgEIuXA8N91ET+HgQMeMg0prgY9bElAGKl7wkWTihEw9/f31uv17P7+3s7OzuzHz9+BHR1fX0dGpg7h6fJgGkuLy/t+fnZPn78aIvFIkxNBChgpmHFzy4oDl9waEERKgsyL5ElBgSadG5KyWsfqeDnYzkPg94XA37HAgYYIJprwoR2UuUOinkHVOhqgpGWg+Od4D8WJGxVaKiL4/pQdOAntlwYUPB9OjWQ3w9hxeVgIMLP5Gd77cgKCO0Fxf78/By8darM2XXrPRv3wzJkxY3/KqAZpMf6Q9sNimu5XNq3b99C3PmYlPIEMM+h7uye1jHMRonnudH3gXJeCshmbsfpdGpVVdnj46N1Op0QJhiNRvb4+GiDwcA+fPgQvAawgBWYMj+enZ3Zer0OuQkIDbA8Ze+OWV0G6FRyDlFpXXnBL/Z6cdsyoOExzN4C3mdEk3fhcQMAQMyf5QCvy4D3c/vgGPoUfanjMUUH8wx4Vi+fi/33EGUMUOg9iuKRTcquEXQAlD8LDBV0mNbCMRh4HvBezR3Aezn+ibADK33cDwGFqWV8LgWmtG1KgULOm5BT4HrO81jE6L14BRiMpDwDpVRS/9Q1EBKc/IPBzuvB8zEGDAoGmDzXv7ozWbjxjAMWeDr1kPkE446Fk8aSuR34W70dyOFh74EqN303BCl7CpEoxeVXD2HMO8DvwQeu2Mlk0mjhlrciT9ayTGMwoN4nVoSq0Bk4NZVFKr+qapf0pwq109ntqIekUbZ+wd+aAKcKkEElJ5NyToPZzrJncMiKU0nbkccDnsdggNtawQADBaygy0Ac9QYYwEZmzJ8Mbkt4g3milBrNJtCXsYWvhdB7Y0rHzF4IEI7xeVaYCglcPx6PraqqkKyCDWGGw6F9+PChlqyBBkfCBgtLdCoEwnq9ttFoFJS4N+0QTMauKAYDSHjixTOwABLipvAexDwtWudcP3ntVnIP3htDlDELQY+Z7dBqKTp9DSqpN1sRMVIFaGYvFE3sOWyB8iphV1dXgR8BCsB7+CAhVi0P9SjFlJseYyXA5/AMvYatCxam4PVOpxNi9mylKDDBebb84AoFgFfrFNdrP/A1rAi4fdhS4j5KjRG0KScp/uMf/3BzEt6CcmCe+wgxYsxP5xARSHOX2IqEbPMsa30/lwPXaniU3wHjB9fBcEKcfzAYhIQ/TE+E8oQ3gBUugAI8TXiHymYPWAIUKBhQI5Hbj71qOtvGA+0aJuAkXAUY+NbNoFgPsvwAxeQ2gz3vuhi19gwwmkxZ+p4iKmHw2HPwm4WW2U5ImVmIK8JdPxwOzcwC4zHaxH+2mrjxzSzEKtmy5yUxUQ51t3GcCooeaBgMAC8CwgxmL8GRZwXoMQ9saZuVMocCEP1dSjoA/xlI49sxEKA8zAoMQoIXFUGWMAMBCA4kGKmw8YC1ertwTIGkhjN0DINvte9yCoJBoFpHbOXg3RCusISgjNj7wGMz1u4AAypg9Vq8Vw0Z/MdqbchDgrX2Hknrw8l7nGnOAJblJUgTOxXw6TsVCDA/cTI1k/IbwAuAF5ID+V62tDUejzAy+hyyWZO6dRziGeoZUN7Bh3cMNdtNOcX49cAAZtowmOC1FTjkwUYoe004xJUKPXp9w58m1AoM6EDi41VVvVi6kiuh8RovDo9jfB9bAmolazn4mev12mazWVjOmD0DmL5xfX0dkjvYlYNOMbOQWMidBFKEzagT/yGseP94xD6xsRLmTyNpkZmaY6lcZ09x8zXoKx6EHmCIndc+Z8HCwAnnzHboFe187HnannutKTjhZzAgiAlLPq6uPkyrwg5jCBewBeJN31OB4ln/Gkv0Phy60jGkVqHHczHQzG3KrtIYKOTyoo44rjyKeqt1B9DCYADPhXLxQDDfz+OEczDAv+8BDHj9AOL2GQwGNb6CZa19h9/cz2zZazwd79X8C76PtylGf6hLnr2u4HWcWy6XNX5iD4CZ1fpT+dzMgoeA+5zrhvsUVPIKiACvGGMMxPENvaYhPs670ZwNlQHcd55xweSFRrg/cT+DIgZOpaCgERjIPZTBACydy8vLUCEMXDAJfnPyEKMh7lh1n3vlQWOxhT6fz62qdgksnLmJUMF4PA5lRbIhQggYTGBIFZAoR2yKigIeXYcbqyGuViv78eOHrddrG4/HtXUONO/A648YOIv1YcyT4IGBmEXGx/gaBlDD4TAIhqZI9VCkA66UPIAFKgEBXjtC0ACMguc0uU9DBZpJrG5GvZ+FBwsLM4vyE86pQkCdNL9F24YBiCf0PPCgblUIUZxn4Q9hi2dzng6mGHP9IRxRR+UBbgfUC65meBaPDQZKxgy3I1zsV1dXteQ0bgMGTGZ1QwvfbOBwWdiDCYJMw5RPnoWlm1MxIOZwF+Q+EkFxLZ6PsYM6KIBma5+tfzwbIR/cj/rDMGMDkzP9EW7hrH7MwuGptp1Op5bzwCAg17est9TTEvPu8RhUMMH14xycHDUCAzmrEoXgmOjl5WWtsOo+Z9TGGwexy5yv8RhWP2zFaYPjObPZrPYexGjgyUAZAQSYWRjp4flgAH4no2IIHpSNhXi32w3lwHxZXfQIHgX1noBUEWkfqRL3lBwLYfzHgGSrX11umjmLNsIUmcViEeZrvzfyvAYgVaYpwrUseGFtoI+xBzmAJgSG2W4FNX4n+AZeMk6K4sEOq5AFI5/TMevFdUF6TusGYqHD5WZlrO3GvMTAU605lStMXC6Mzc1mE6xC7TO8I+f58uqMMd1kFbf3QuA9kMpoTYjDNdrmapQxgFJ3+2g0CmuzQL7q+iwcS4cy5e2RFfQqqARgM9sl8YGYv2ARsydDDTnUF+FjEOdeQPmjjAAJGiZg7wGPAbxH+Uc937gObcpK3vOuMRjQ8aLyudQQ2mtvAh1oaITRaGQfPnywi4sL+/DhQ81NhWd47kiefscZojhmVnfJ63QS9TCw8sT7ATiwiFG/3w+egel0GhYyuri4sKurq1B23omLBQXKpELRrD6NheNyXEdW7B8/fgzoGHkG8Azwim1wxbHbGoPEU2wYFNx+6AcuP7t1mZHY0tT4LaNgXgSj0+kEMDCdTu329rYpq70ZcZgjhaJLBhUPcihmhJ2ur69ra4YDePIYwH0AjgABLNAYIKBveIogC1O+Bv3sWf1cfq6DJ2wYGCo/wOKLCSEe+ygL10fHEa7XcqNeSCJj4R8LCcW8PAyK0NYcM4bQfw/kgTQ9Dx7xrGW0Gb7ZsGFlxl4VfNiI477HN+QWlnnHbrFsmXvxePAuey84fwbPN9t5IdhzwPtjMNhg+c//WRZy/fFseFc48RyJvggTMPDW6cGsG0Ea5majwSPc7wG6EjDw6mGCGDEg0ELp4FaLmr91QHsxczQqFCIPYM+KVjcVCwt+N4MHZhqUAWCEO4fry4OCj8NNw8IY/9lLwse63W5A0fBYoK6oo65joGBA+4SBQ4wAbvCtykTriP/eoOh2dxtmdDqd4Ir7ZyEP1ZvVAQMnEcG1yMrabAcewJ/qRmelD3cp+BPv63R2C69gGVgvnKDuVA8YcjlidcRvBb/qyoy1meeV8LwUsbbW61Lv5Ot0THjvYUDI3rtj827u/QwC2D0PJci8YGY1r1QqtGT2kreVn9glDhBitnPv86JtKIOXXMdKXhUuG2LKRxgLkJsaBmEgzffjP8v05+fnoPDZM8RAgL1v6gHgsul3iseZUuDVU/wl47SEWi9HzP/1A2acz+dhMwvdYpURorqs2JJhJmcwoElQiBtuNpvaUsLT6bR2TlegYpeqDiZ2d4FBeWoIyszeAgY6vIUkMy6UOd4zm81qzMJ1xG5haA8vv4LXN2Blzy4275vLyoqe78NAUSZkFM9CEx4CJN+cn5/bZDKx6+vr4tjVW1NJuTywa/ZySVJG5FjfAvkzV1dXtTUvzOxFohX6G5ZazNPE7lvwHgMxtcDYHcuC0qxu4XO9PC+QBwK4HTXBTN+FejDwwX1qJMTaXO/3SNsI9fQMEbbkWOFU1c/48eXlZfGe8K9BMeWhSo73UYG3BJtTsaXN8pfHO0ArrleZwPKZk8OReI3zkP0sk2CgMQBhfkI9ABhwXDP1QbCsEYqAZwJGCHvKzOyFZ5m9zcrL8AYhzM1T0jVsoQYXG5baVzEAG/OgeaTy1yP1+L0aGEiRKm9ucM/1yAiRGY5RK5C6ZqWyAIGihOLu9/uBIfEbzwFTgnHwDgYqXB/2ErB7hhk3Jrg4psUDF0If9WVGZUJdGNFreIRXQAT6xrN48KNeMYHuDXxFvVpGCE+2FCBAAQYwZQzhjmPQa1l1DAYZ5KINePlfBpLM3+yxAl8x+EP5GQjyh8EAjyl2sWKq7fPzcxCSLHDZOvOsCk+JqmeBvV7c7nwfiAEDjyn+KFDF89BmfC+f43drObzrYlaUArtjeQZyQID/Q0ZB9iHkib5ny9lz8+MZbMWzgaMucG4jBY7q7UToy6ye8Kggjz1h4GuzXcgNdWWexD3sPebymVnNKMO7mLjfPU+A5gLE+JXfr/2jYMB7P36XKvBDUqvZBJ7rw2wn2GazmZlZiBMhe18RKidWMUPxKk2cIALihocgw/ufn59rcXXM49dpe9gTm1EUZ4XCPcTLFTM4YKaAEPT2/PbKb7aLCyPZkq19jouB2Ioys5olCUWrcTLe1EL3rWewpe5kBgPsGfAYli0LDFj0MZLlHh8f7eLi4l16BpqWSQUgTytCW/OMAeZvCBi8t6p28+o1f4SP6aybVNwTApZ5l/dE17gnys8CFs/VZzOvow04qdHspfXNIQ3mn+12G9oICgo8CsXl5R6oMFclzwqA68Bl4770wC271bEo2bGmx6pSUBDFxDwEr+d0On3hbmfFze3Lu1LiNy+ZyzIZ8ovDoCgrDBSvzCxjGAwwkFSZwjzIhL7S9oHcxzhUz5eCTPxmzyaH9uCFYPnMRpLnUVWDS61/5Wuz+tRJHYdemb3/XD8uRwm12sLYK6TZTsBhtS7853minETCyl5dnLheLRhtZCg4rjAUKbvip9OpbTYbe3p6stVqFcIIjKg1dsbCXuvMQo69HrDIUScuMzoH51igw6W22WxqVrTex+0PoWW2i8+x1wDTX5ANC2udFTx7D1BXlJdj2+oh8AQKJ+9AgMDlxgrsmLQPIFGrkdsIih+hISg6CBeMAwhP9RQxzyKJFC5WgAD2DMSWIWbvDD7b7W5JbQg4AAL17qi3iuvMSWkc/0W5uSyco4INanTsQhbgty7kpYKVvV6eJ4Kv9fraUyZq4HAZwdPw8LxXUl7i8CLm7rNs05BQjHcQ4gKwh5IE/7Ai5LYED3Mf8rtZ/nM5WBcw2PaUGctbyDu8C/VnwIT6g3fYa4vnKRhijxl4HkmS3G7gDfa6qbxkMMP85fEfexrU06b1j/FCG9orZyBWIAxsULfbDUypSy6ytcoWJdyso9EoCFJ8s5LlBVg8ZsJiQdgy8+rqKngGGOlxfVQw8ABShM1Agd1cLAx5MDLD8GCAwN5ut3Z+fh6epYiQhSeYHm49jc+xqxgKiuPWWibd7hnneVBzu7BS5PbAOfQhvEXH9Ayw5dq0HBoOwiBlsIq2ZmXLVonyDMoAZcruTpC6IlU54homVgz4MGBTYYzxo7MAPBCu/cueI/WAqQWvcgMeOLQTt42WI6aIuTz6Xu47VXx8jo97bYy2USvurUjHP/d7ykpkDwHAHY9bz2LkNmeZ0OnsZsTwRju8yiHzidkO6HH4Cs9Dn7OHyeylgaE8p+2goA/yEoAboFo9DOqZUI8mJwmqMQQ+V8DIz+Hycp24vb3/sbGs1/E5vlaNc31Ojlp7BhjB6Hl1YXvWo2dJ8qpPsCixraNu5YhrYa2wkGNXmCoztcB0HwE+57lnFOkpQsU7Op1O8EBA8LGngRUJl03bDwiXwU9VVWH1ws1mE1ytAAMIhaDN2VL99OmTnZ+fB8DFgEEHNTO2Il389q5Bu8H67Ha70WmPfxTShBy2eDjrGAAI85C5PdEWyldsaWuiE4NCtkJwjfIMAwt2u/IY0XAGjy+OzSqve2OKj6Gd2NphbwIntoHfoGQ8QKCAW2UOW3esGPj9aG++JmbQcN34HQDPx6aY8aXXKF+YvVxYiJ+n45LHNIed0N689S7LYpbt4BeePgjZfn5+XlvpkfOYWPkyP/JxVsRcZ8htEGQijCzUgz3QvV6vtniQ8rjHMyofGQzovWpEeXoUxEAe7+ExHCMe8yxbYuAgRq3BQO4cWwZoBJ4K1+nspqHwClPd7s+EJyiv5XJZE1bIiIaC4zmmZvaCKVmYcLmY+TTUwUpNY6GKXPEsdsUys+B6dAwraY+pcT+XEaTeBLQdKxEMBrS7mdWUFFa+AxhgpOwll3llYlJkz2VAG6J/jgUGSt6rLrnS53oJfZ4VbPYSQOI/WzOwTvkccgaUF/h9msUPoY1QEfqfXcDeIile+ZTnvW/ldbQPC1OAAjYGeKzqOFVQwxSzkJr0XYy0rXUcHos8b4DymqcAvGu8c3xM5XdV7fJb4HGA9c8Z/+hLzksBj+F5vNAb+KKq6jkDCmJUTqZkMYjlP9fJM0yVn7TNGBzqe1E3D0TwM7z294ivYUAQ6yMttxoFpeHZvcAAF9pTqF5WJTwFirrY8mCPAQQXLAhMG8GiEIPBICwIwQlSbAEBmXJnsfD2GI0FrScAmcFVGaogYyGJ8ARicIx6meHgWcBMARBQLMcHES4Yj8e1Nsc5uPTOz8/t119/rS16wwqIp39yG3Educ840YrPaS4EEHlbwX0s8tx0OA6BiJAMT2EC8GHAqQIo5l4Hf+g68Tw+ONTgTbnlEFG/3w/eNWy6wwCQwwTq5VEhGwsTqEBEG8UsFhDvTqe5Oagbj1EVwtw2IB23nsD0rGQuM37z+47FuyWKXMucsj71f0o5Qb6YWS3si/vAI/hAVqNf+/2fO75ibPT7fVsul0G24D7wK4Ni9iCxN0y9Up1OJ3jgMO64/wFIED5lIKzyl5Uulw/yS4EH2iEWxtL2iulLr19QZryTw888pvhZ/A35hAT6EjrYokOxY6lzisZQYfYcgFE4bgsmQ3IgOt1s59ZjMMFeCO44TUhKoUIWijwA+Dysdu4wRrbc2Z4FycIHZYWiZoWgDIw20vCGoneNZ/PsAx3YniXkeQVifYuyxTwKx6JS6z9lPaFv2eJgnmUlxvdqW3A4i5+NflYwzUlbLDRRL5SD81TUDcouWc8bAPL4Xq2v1DXes2Jtr7yvbaHyQj0OMdJz/P6YfFIgobLhvVAOCBy6vGp5oj8ZpIKX2EvFskTlpYK7GB8psPSUrz4TcpPHl/anx6t8XHlB36Hv13ZS0KDXl3gI9NnaFlr2N/EMaAG1sFz5VCPoca/xUUnMl+UOYDcUXFFq+cBjAPTn5RqwtaYhBbV0lBnM7MW1jEJVoDHxIIGixjG2svDBTAzOzgUa5pj/er22p6enGhqEZwEKgUMEaB94FcxebkeKY7F+4/ZBnZRiVtoxqMn7U8oGbcL7SVRVFTK4UWf0Dfcbnon/bKl3Oh13WinamK148AUDDAYD3D/gZd53Q5/v/da2y1mgfI0CYvZi8PUcKjDbrdrIyth7PwMerqOGTri/+L38TB7jLIMAwjUWfSzStktZhiW8rgrXO+7JdFWMkHsIQY1GI7u+vrbBYBCW82VACi+vbvSjni8GEuwhAh/hHMYfy1aW6XwOi7zxDDKebq2AXccS3ltqMGmbpSjWnzymeSzpjDP24na73ZAzUbpgVustjGPHchVOISSPmVUohILTfNfpdBqSU8B4cFPxXG9OEuFEEk1gZNetukrVZegBlVgMCwLKG9T6DjAlx9X4PIAOvjn/otvthlwLtg5xPQtgfjcLTc8yUuStx2Lu1/dAhygTP8MDBGYWFpMCQDPbhQJgSWFQM3hki50VD/MTrxXBApTJCx2Y1eOZuk5BSZ11nHqWkN7H3orttr4NN5dDx3hMSeG/BzBVdihwiNUNHwZqem8sb+EtiOuZAqh8fQoMeEodxz1AkLNuWe5BrnB+Ci+4Bd7V0FQqRMXyBmXWccReOrOXYMCsDk4B2nWxt5jMZjmnnmoum/72+ibWZ3o+xtcKrlFf1FGv5em6OTp4mCAmKEoZmb9Z+bLFYbZDS7CAO52OzWazWuwKTNjpdF4sAKNMyYCB8w44OQYoGIKZY1pw0ytTaywVHcmLz8B6V4WPOnggiS1OKB/MKZ9Op2GeOk/pxLNYgekCIWY7D0WujxUhawIhtwOj7remmMLi854LOUcMCBDr51CBWX1tDQAALBAF5ciCkXlfLSXmSZ62yISwmRcCY8GqwA1l1MWM+DcLaAYxKC/zAoerMFaxfgZfC55F1jcnaHF5VSGwUsD7uP/4o1Z9TGFyWVG+xWIRljI/FnH9Pd5Ua9a7TttU+5PvVxlmVpc3nkeA87mwydvZ2ZldX1/XklU5XIlljOGxKiF+P+sElUkoG4ePUQ8eN8oL7C3Gea9tYm3q9R3KqH2Y+gYvYmE8Xoae1+RQY2y73QbdNplMbDweh3V/ctQaDOTQTKziqU5XZOpZorhOXZ1M3KEQMAABPF+Wp1V1Op0QbsBa8nB7sSsJzAUFzoIcApUHC0BEzJJiBMf34l2DwSDUia0rtioBRs7Pz4OARYgFYRZOxNEplIwc0dYqKLRv+aOAx+vDXN+/NuUAQSlxHgT+Q7F2u90wrRPtBNDHoSQMcl6G26wuhJkX2MrhaYx8L8YHz9pQZaj9yaCAc1vwn8cdKwZWFJzkxHVQCwYJXLofCHtUAJK5zqrYuEyaPKgywqu/9pkaGdx3VbWbwnusFQhBHv+yrOD/HhhQq5td6Nqv4FOznfJkYwiyBHIPM7yQmKxr+rMcZiPt4uKi9myW6zpVFhTrOx0zqB9P5eb6a9syj6t32GtHHkte+2u/6bu0T7068lLzGB+cYKzTzpmHz87O7OnpySaTyeuBgVhFvEprYzDK52NNiBWLPgvHPaSmwi2GslU581Q9FnxsQfHg8urHA4//48MDBd88NYeVBMeKMThRF5SZF2JiRcNonsun+RHssuZ20fZnxcLX6uDAsWO5WtuSB2A9QQK+wiInzCdA9uwZ4A9v5MW5LBzK4Vg/gwkV/mzZepYsXJxYrpvvw3tBHohTC515WgVgTCHF6sg8XtInWi5PsGo5GETwh5UQ7/OBcBvW8zgGabuyQuNp1TyOQToOWfmzTPK+WfnDk8oyiuUM5wDAgAJAgLeV5Q+HElhRsxzT+uMce89QN/WgqccWgCOmyLl8eKaSem31OpWX2ndcB62X8iCUPZbPh1zRb/XoIt8Ibfzlyxf7/v376+YMeLEJrTwjPRYY6ExPYavyUSHDHcEUAwCqsCAkq6oKA549DLD60HjscmVhCcEOT4CZv4IZz4bgVRbxDaXP0x85hMF5DYrQWdApmsbghNDX/jLbeQfwbG4//Oe+SClydquiLbg/1YI5FrE7MUYeiNVBrXzF1ifCPlhwCzkt8Ep5AlX5Asd510POA+HwkSdIGIzwswEWOY7IY1L7R70UHD5ipcqKnNuXxy9bMDwFTcNxnuWW6wMzf6VD7U9ei4MtL/yG5QUPRb/ft6enp5BwdgxSZcgA8fLyMrQjtyuPNwYC2r7sSoehwSFHtv6Rj6W5VZBtLKNUCbO80jwmBiXsJVJrNuYJjoEB9dpi7OEe5lGeNsgeFLxXjTmvDJ7xyf2H67w+5UXmNpufuzAChGIZffAgZAvkC3veOJxVVZX9z//8j/3Xf/3X64GBmMVv9nIPbFWO/PFQmjZWqvH1t6ds+F1gEDAuL74Cocs5A2yhq7tJXW2aV4AyeUjc8wiwG5jvUQTLH1YCDLy4/VRIs1tVgZoiXs9FmyJ1n6f67J+FPKuN3e2sDBlIsjWioIDjsNhZc7lchhwD5hm8lxUzfvOzAUghMCE8mDTZUMEg11FlgPY98xTfA/Ct3i4PeLInSWUEA1q0ecytrFNtGTBBqOI3wMBmswnKcDabHXXHTSXwCK8foUnRqtQY4KtMioEBlpPdbrcGBjwQoe/UPtaQzj6k8l/fxdcwjyqveQCWrwcxf+eMCR0fKj95jKo3Cnw2n89DvtdsNrP1eh2+MVNssVgEgAB+BnAA/fjxwyaTyeETCL0KemjKU2TceMyManHofcq4fAy/mTzLFAOBN55QVxKjRxbIbIVB0XMWt7qgNMkGnc7WHe/NoCgcCF9dawomer1eLTObESasHGZyDEZuO24/9m7wN7tSQXzO4xEeDF7fHIs85aYCIEeoMys+BQQcg4dnCYR+5PdrbJYFNFtnLKBxHs/w2hb3n52d2dXVVS03xvtwiIvHJNdRAaXWywM5IE6iZCsVz8Wzma/xbAZIaFsOh7Blr2ES5mHEWzkOC08AW2WIuXa7XRuPx/b169ejhbi0jeARuLy8tH/7t38LuU0sG9D3ai2rZ0A9BAxMwSu8URE/w2w3fjgHidubvY4gtvB5a3n2HvA1OK6Z8yzrNfTJ7cVgEONNwwI8ZuGh8Axbj+89A5cVPT8DdQbvQfljR93JZBJyvTAlEAp+PB6Ha+bzuU2n07DpHjwCuAbve3h4sM+fPxfzbivPADcMK0FV3p7lr4JDBaKZDwL4Gg84oCzc8DwYoGg1lsRWWSxui3MKFHSgsZBji4XdVvp+VfZeu3GdeCCzYGarVBW4tgnaGNMRU+9rwx9/FMqh/JL7mdgzw+2v4IPf7QFi8AI8A7D4kF+gvMPEYwqKcTgchvcx76pFxGCAy8v8ocIP52MAg+vqWWcstFEmz2vBAhnjiq0idffzB8d4V1CAghQYQJhgPp8fDQwouGbPAC8vzXKFF1tj2azyCc/na2DcwFvK67RAznn9F5M9fFzrxR4qBQN8XJ8FQK1tw7+996re0OvZ0FUvqicb1SOmxplXNnX1IxSAdWKWy+ULMLBer208HodVZmezmU2n0xp4YDCBMgI4vBoYAHG2/eXlZc1agSWjiLSqdi4l7hgWYHwthJZe6yleM99TgGvUha8KUIWsoj0FPJykp/F8tqrwft4RkI9zLEqtJZTTbBfn1DqjjRmN8iYg/K4YqSJgoatKjWOzGs6JAQFF+29NsbLtAwT4fn22CgEF0DiubY127HZ3cf2qqgLvsDvWzLdMOKkL55fLpW23u621NadAvU46vpjneUx4QFjHKwt3/FeXvoJrfQeeCatnMpkEtyknVLHiZ4ELYQnBiqm3+OB6uGwBoIbDoc3nc5tMJkfjXR1jUPa6Xoh6Y5S3Y8aZmQWjgN9nZiHnCPwI+a7l491SOTG109l5W1U5qpdUQSnzKB/X8nc6HZvP5y94UvUP75sAQ4rXuMAzsU6I8jHKg2doG6gng2Ue89V4PA6zvKbTqa1WK3t8fKwp8+l0atPp1ObzuT08PNhqtbL7+3tbLpdBwWPKq+a7AMh2Op0w7kuptWcACg7TSLjhOTGI142GYIspXJ47jW9NiPHOgUkVpemzcRyk7m+2dFiBqOWG53kAgYUXMxVbSXimomxmdM/qBJqGYFcLDffxojNap5K+9a5j1IvysELDAGPSgXws68ps1977lCEGqLgNNJGN6+0NTE9I4hkQxGhn9eRwuVjI8foZam1BsLF1peNLATcLVFXSOgaYL83q3hI+xsd5bHiWHAg8h3jpYrEI1r6Cgfl8HlyxiJvCrQqByklYUGIYO1ipkwHDeyCVgSpLWdaAdDx749vjUbXAkbSq90EpMRiARxQud5UfMTCg5fTkptZDp6OCTxg0gy8ZhHrWO/Mby2fmXwX16sVQHQOwCSCKpFQo/8fHR1utVoE/n56e7OnpyabTqd3d3dlyubS7u7sa7wIIcx3Q9pABTafDFoMBtkTNLEwfOT8/DwtLoFN1Dj8rSt03Hc9WSwWdq5nunqLV0AEzNjqRmUoZE98xxclWEaNPz8XLIIKtPR1EjOC1Lbh9+v3+C/cVysrMifvA0B7Y4Pp4QgOE96kXQNtLB0XqWe9FmMbag6mtFcjWLz+b+8Os7oXycgbYs6QKl8cIiO/hjb1Go1EtZ0DzVbwZC+zV4zLyOFPwoG0I3oH1BYULxa0xZSgLeDS4/RAOwP3r9TokRsGlCvc+hwBms1mwoAAGZrNZzVPgLTOMd8P6ZqPiGKSeAdSx1+vZeDyuzUZC+EA9NmYvc1I8I0TliVl9Rglb1Gz5MqBi+QRjUN8LXtJliFXZejJK9QMDFvacMXDB+9A+sdwHBdiq3D2DiL9ZKYO3wJdQ9Pf398Hyh5fg/v4+gAJ4ohCewhLzutQ8y2MePyz/SwxApmIwwA233W4DGLi8vAzrT0OwYSlgTm5hTwG7trgRWZkCiSpw0Ngqf3CO44U62LXjWOmpggVxXoEyIgsKtYhQF7aEVFF7A5Tjf4j96rxwVVgxcMV9p+diTM5tFmP4mPeAj/O9XpnfmpoMjH2eo9YEA2gIKijdWGIr84eCAXYHg9QdOhwOw+JZo9HohYKIgQGeJublAmndOc7P33DRQwlDmas3jr0fCHcxr/Bqaw8PD7ZYLOz29jasrAZhi7AB4q684Mp4PK4BBQ1/cRujnrz/Q0mfvxbpmMLc86qq7PHx0Z1NoB5JT97ElD/LApaNIPQrAz5ehwH9yF7iqtolRYO32GsMXmYQrMafWT20ivrys82sFjLlZ6Gd2KOr+gfE44s9I2ro8YefgZkAcOsvl0t7fHy05XJp9/f3weqH8r+9vbXFYmHfvn2z+Xxu4/E4AFhY/xr6VVCuAA7XsJzP0cEWHUKjAD1yI8FlxJm//Dx9JncCK1RFciAgZpAHBlhJ6ztjSS78bBbsscHFjGvmx+oVzPAA0TCJ5+byzqGMjJKVMbQPtf+0/b0+1mtigIDP84A7Nhh4K1LLBv2KjGyO+eoGWgoG2DOgq8Cp4GR+wqIu8BIoaIYC1ClkHvBNWRmctQ+hpWCArXsvlKR5KRiT4GsssAJLfzab2Ww2C1Ov4FpF3BVJWYjJshubx3+sThqq8GLlb0VaPshPAB644hkMsEeAPTcsd/jZ6tXhD7cX+lUVIY6BwOMIebGiZotdw1UcBuPycN3ZWGSgpLKFgbQ3g4DlvueR0GOqcFnncWgEoBf8ySBgsVjY3d2djcdje3p6qh1bLpf28PAQcgnm83l4pspfHZOx9vL+p6j11EJWtlDucP1phypjdrvdmkXAncL3edaJFyZQhccuSrXONHnJU1KMLGPoS8+x5YXzrLhVmeO9sM546U4lRsGekMb7NEak4AR10wGlAlqBEl/jeXH42fp+bdNjECucHIBhigkatda897Bivbq6Cju4wVqHpcLueVbEbF3xtFYW+ngnl1GtKLV6+RzHbRUwaBvwGOAxxICfFS6sdi8ej/KyksA7+Do8Bwr+x48fNp/P7e7uLlhVEJz39/ch6xq5BByWMLNa38Q8Hdy37CV4LwQvCIAWysdeJU9eMX94BoJZfRts3MP5K3oO5eHVWcGnAKJYGOni4sL6/d0mcpB9ZnVLlvuI38NyWuugMpx5ezQa1cYXv4OfpeND5asHUgB0eX0AANPpdGqz2cx+/PgRvFmz2cw+f/5sP378sMfHR/v+/XsADLwAFgMdfa+nk5g8YFdKjSCvCn4AAV5XHGiPFQUGd6fTqS312e3W92xXqxqMxiDACwsow4M5uTHAXCVKyfMEKDhgJmFLxlMUqkD5mNYJCiXmJYn1iXZ6bMDjWhXmOeK6ed4hXBN7X+l73gPFBlhJ+dVFB+sbybbwDgAMwMWp7nkOFWm+Dbs6tWzcF/joOGGvQ8r612czINSwAHsC+XcMcKfaWD0DkDH6AeDAN2KqcNGqxZoj5m9VGDHefivS9sEUNfYQsvdUczlyYxTXaJ6Qgj21UqEUId+V53hhKO2LGN95ypjLXnKOn8GyMFYG1EcNHFzDChreEAAyJE4CDGDqH6b/YVYAvh8eHmqhAIS6FFQpteXBUrlbDAbUHTifz+3x8dEWi0UQehzD8dbQxze7xrmw3KH4Zosax9hFrwBFLVm+h8vD8VfNZuWYEl9vZrXyqDvXY24OneD9sIrgLuZpLxhA7IaDaw3thzZTdxkLe76Gy4H28FZs8wAEnsvP4cGB93iDmful6TSXQ1MKHDF5YEf50junvwEChsOhXV1d2XA4tI8fP4bNWcB3AAG8VDG7+9nig7WF2KcKMk8Ro+48bry+U4uE6+O58fk3vxdCzWw3VvQeHlcoH+rLiuf5+TnEUOH6R1LVeDy26XQa8gju7+9rCVveKovad3xecwhQDs/6OhZxOWCRVlUVdiZlOad9qCCRj+F3zFBSWeP1v5m5spoBLnLIsJ06lk1X+ZuSJRgLmiyJ8YF3YByB/zhcBWJPAY8PlAHPhuufn4EQFTw1m80mzA6YTCbh8+XLF5tOp/b777/bdDq179+/h9kDnA8QGxcxLx23v+cd9MZ6jlqHCdAgVVXZdDqtJUOhglwJNDyUGRQgk8fI6sJRK0fLZOa7+TXMwBYY3ICarMJl8WLy+mwVulo3vY8BB7eFCnWEVNgL4YEB770q8BhAeYM7JvjAWKosVaB496cEzR+dUqAAvMHJtDy1Vr0ACgKYNzh0wABWFTaH7JQU2KkyVyGMa9jNrv3tKVavHfj9qI/XfjyWeZVAWPrsJUAoAN4BzuLOCUAP3KIcCqa4Pd4DaZurrGPSPscxfZZZfTO22Du9Pld5zceYh/nDeQWpqYXKQzo29KPnuW7ctzpe+T9AKX/AW7w+Be8bwOtXYOvg8XgcZg/c3d3ZdDq1+/v7sG6Fhl49/eD1p97j8XobANs6M4anDIEJdL4nk1r2rABjAiUWy8kRMw4QIu87wG5ajVuBEfCbl4StqvpaAqin1tsrt87VHo1GwX2MuCrugeJUtA+mxLu4rFoHMImXg6BtqAKZmdQTPGo5MxjBc7ifYeFpZvJbUhsgEuM1b/DpMQx2FhqDwSCsEIa2YasG/MnKn68BL+K/Vz8PCOtsBLYolC/ZolLLwgPKKAcnN7LwhEuVwbonG/BsrAQIpT+bzWozBOBqRVY2lmD1prepQlf+ZutJwT7KwGD/GKSyLwVyFKjhvhwQ8IwCJS/Mx/zV6fxMkMXWxNfX1yFPBvlQ/X7fLi8v7eLiIsTzWWlrORQMsLLnPCoAbN6oCV4qeK7xDgYDLLPAx6xjILcwnRXgE0AU4xqyjUMB9/f3Nh6P7fPnzyHPBfezztS+0v6J5Tql+DEG2HPUGAxwQ/GHO8orVMzqj7mg9FpFct516tLnzYguLi7CFCqgUryPGUxdLQAPABM8N5aZEr89MMSAAfNu4dJia18TAGMeA66rZ82xIvAGMN/P/RRzB3sxYO1jRfBcDrjZjgkGXos8AMvWLRTVdru1p6enWhswr4BP2WJisIlvBpzeuEE/xfiTBRArf57iyAl9eKaCXeZNPEetq253t4DSdrtLGFPFwmOFd67DTACeOYB52FiFEFYZQATexWNF+4f7DvwJ0AqCZ6LT6QRQcAzy5CWDHQ/Ys7ewxEMSCw14z+X3Mhjodrth3Zmrqyv7+PFjDQxgzQuAgW735+ZHXH7OSwCpR1XDZx5o5nYC+OaQAMtQ5WNud3i/keQH/lsul7WNgnj9i9lsZre3t/bjx48ABhg4aDiK2zrlkWHyZK1eWwoAmFqDASYv3siFyrmvVJB51/G7VeEow5jtprcgLoWsUoABKOPBYBAyvHmuNc4BBCDbmgW1MqV6Brh83uqKjFa5rUCKmvnbI7YO+Rk5q1gTv3RQ6vQWJZSbXdf43+v1wgIbxwIDqfq3GTSp53If8PK5sJh5mhoDSE+ggY9wTnnM89Cw1Y9nq1eLPWe8zgCPC47lcjnYQtO8GeV58B6AN65jI0LdtzgOKwqZ2Vg8COAAghkgIAUE1HNVQuwtQBmPTarkY0rBk5eecve+vXfys9jggiyEoXV9fR0Wofv48aOdnZ3Z9fV1kK0ABbwODctAgEf0H/MUv1dlLMrJYWL2qqp3J9Z2bLwg7AQgitkBDEx1Zcu7uzubzWZ2f39vDw8P4R7efCumC/k7ZsDpea8enlfg4J4BbTR+GYRezCvA5LkdcdyL1amS5//qOsI1PL8aLimskghwMBwOwxQYuLDYfcWAgD0CHLNV4QjrX8sOy4vPQejBqvEsbDAxCzcGDp41g2twXq0JLRsGEQTwdrvbUpMFq7p4FcyxsFUwcH9/b9+/f2+8POZrUW5wpCwqz4viXQM3OVyKnU7HJpPJC++TCgZ1STMgZKWrii0WYmMgqqt/Ympjv9+3Dx8+BBcvQDAAAgAx+JHzHJjnVXjjHRDsKAcnYSGJCjzLKwhCmHKSIP4/PDyEGK56KL3+illfnmBFe4JfvVDbW5OWz+MdJc+QMvMXXmOjzQMIOAegCHnZ6/Xsw4cPNhwO7cOHD3ZxcRE8AwgLwJhCaJa9UPx+5IR4+UXszlfjT41Jr9xergGey+AVniDkqiBJ/v7+PiSvApg+PDyENQSWy6V9//7dJpNJbUfB2WwWPHU6bmN60OtXvQb1VVDEYLvEgGTaazUNFZox9Bk7FhugMcWvncaWORgO1j8s/qurq9qSrGDKwWAQFD7PhcU16gHwkgQVrXKsnuuRs0i0TbRdvYGvAAEKCIqbFbQHBthKA3KFYAUoYCHNizfxh5lO0Sn65fHxMQjvY9M+noA2pEleXiiIyetrtbzV88TEngFcq3kBHJrAxiYQ1OhTBrAxV2VM2Wg9dMzgPPMeeJYXGIIXALMI8M3LCbNHgdsbbYFvr51iwABlS1373qmkvJ6s4jHMfcVeJnhcLy8vg2zFrJmLiwu7vLy00WhUmy3D8lR5gdvaU3r4XVVVTQ5xHfibr2e9wcmiXG+W5bifDTUAegaok8kkAAV88yZCpYmsTE1lk9fHJTo4RgdZWsvLKtXCeOf0mJ5ThV9VVc1ShxAD40GZw7oZjUbBTQWEylty8jadbDl51hkDASVFnIps2bJGm5SgNrW28S5+LpgW1hQSWrAgCZhfQzCMqvEcrHqli19ofbi/OGGLrTu4/brdrn3+/Nn+8z//86hgIOUuOzRAUB6BwtOVN/VaPhZTwN63mbmClYmFL3u3kMT6yy+/2GAwsF9++cVGo5H98ssv4TzexYLVA77e+EW9WKGwRw3tAhDw+PgY5mfj8/Xr17BSG3IG5vN5rX4xa1ZJFQy7pzF2NTT3HshTfjEwkzvmKUy+lg0cTsDGIkKj0chGo1EIBeD75uYmAITz83M3dOp5cr1ycbgA55TfVYHrom+4ToErG0oAyZyPA37kMNXt7a1NJpOwguDDw4N9+fIlLHft7RuggEr70OsnBZ4e0In1vcq4pvz7KutsetZtzM3FSgkuVLa41aphdxNc/QwGEJcCGABz4hreI4FRK1tCbDUz42gncT1VcSr61AFXAgZS7jsADEy/YmZELJUFrpe8omCAV4/ThEEv3o97kaTDoALTIbvdrv348SOsEPdHoBxAa4r2daByv6beG3uPJxSUv7zn4HruGyQ5DodD22w2QYhDOWOeNfM1A0u2tkraShUDysehA0wXZO8A71TIALSk3iBW9AABuI69AZ6L9T0CgxLyQCcf957LipRnsvB+NPjm0BKAAucDqMKOlV3HScwjqdervMa1qoNi3h0FCrgW8pU9A1hICPteYGXMp6enYJRpGbTsnjGsfVICCFL36+9SOigYUDeNonRV9Opeh8UAVxQnACIEAKWOZS2h6AECOAGQ3VS6XabuXuUJVT6mGcewaFAXvjeG4LiOscHI4IKnN0GpY1MQDBbehQ3Z6liTXZOyGGkrMTNzuAEfPgYAwIMF9/H7UXeg6GMlEOYA12tTiRWX8hSkPBqe4IiNQxxDX0HpQ+Ejvj+dTsMzzs/Pbbv9ORNgvV6HPBqsfqeeu1j98V6z3ZxvKH7EZGH9Ix778PBgk8nEvn37FpK4ODzgWZeptmKAj3J0u92kN6CJ4n0NSnk6Yn2swDP1TH4O9yUMLoRXb25ubDAY2PX1tV1fX9twOLRffvmllmsFWQvyZA0DQZznKagMCDnkyXqDPQx8DNfFkgVj7cuyrqqqEJICHz49Pdm3b9/s4eHBvn79GtYMuLu7q5UR7Qqdop4BfqfqAA/U5vrOAzz4VlBVQnuBgVTBPIJQ5Jg/W+aw2pHUhG1YGQTA6mcwgBAAZgOwy0eFlXodYnXykBwLDZ4vDmbgldcUEaN9EIrgJD+2krgMnG0NQcaLXyC+zzu28VatUM6cDKUgjd/J1/K7eOoWvgFAeE94lAnJM2BGZNimku7+mSiF4GNWC86VCjFc4wFufib/9pRAVe02iFkul3Z2dmbb7TYkED4/P4f54wANeBZ77rieCoZZ0TIPMC/DCwC37Hg8roUMkGyoXgkv50Lriuu43eEZUGssZ0m+NeV4CdfE7o3xBxN7AtCnWCUQ1v/NzY2dn5/bzc1NAANIOoVshiyD8WD2EhB47c7yhhNLWW5xCFaTcPHNSjgGnGLtxHzNS11DvmIhocfHx8CXCKtqOfjjgf6cnsR1fH0pxeR7CTWeTeChEJzX+Axb3TyfGQynm6TwND4oet1nHUCBcwZ4QSF2izPaY6VqVt+m0uwns0HBa8PyfbGELxZ6GifTe1FGPJs9C/wBaDDbzcGFosXiF95KWBCearXHQAEGA67hcAGvvw0woOe8XbtgdcEC5Ok1x6C3fLen/GPXxQY731ciDFgYqWcgRdr3yH7Gc87Pz0OS4Ww2q4XneEVE9cAxGNf6MC9jhgDP0Z5MJmF6FkACe8N0PHkC0FNCXl6FKhccU/l1TCqx9GNKPgYKuX5shEG5w/WPdQIwYwD5AryvhpnV5ArkBJdN+85sJwc5p4ZXnWQZqQtteXoHx9F/ZvXNl9DPXCYAFy4jthcej8e1TYXu7+/DYlc6A8zjkZRi9jyAMQAR60/uS73O8xrlqJVnwAMErBA5A1+FBWeZIhyAczzfH+cRw2QwwQlQYGZWxprJyWAAjaNgwGy3ihozEASHggD+j3ezIPSmsrBrjJ+jYQr2ZqAsqBMUPea78oIWUMLIbuWd26DEeTU4HhQMAiB8kXsA8MHhAngIODmShf12uw2AjS2FYxBbkkolKP3Y1EQZNbUi8I2wAaZOIfdkNBoFj8F0Og1eOSTfItyG5F0oCoT5eAyC3wAOebnW29tbm8/nYe12CGO2ElNhgZTXKeZJ8LwBHPPlpEsd/29FnjJXStXday82QjqdTpC719fXIc8KiwZhNhZWFGQjDMmlKBd7IyFv2GvKipjLrTKOjRaUMdYWABReu7Fe0kRElntcVoTJMAPq9vbWHh4e7Nu3byGENZvNwjvYeONyecYyf6vHJkcKHjwwUfqsGDUGAx7SgAXICXmceMKJf4jv8zaXusofx/y9RDdWPsoM7BXgssaSAvne2HxiBiPs1uffHmLj96YsjJirSevMa7Ozi14TB3lxFih2CFQFA5wcxlY/vwe/OfeAp3WB2GJD3zBIfK9K960sP08gpLwDqfJ5VpYeb+Ih4Odut9vAW2YWxiryBtDvnFyIHUsReuMV/DCucB9WcQMYmM1mwfX6+PgYAAmvQeCRFyaI1YctRa89vGfxmH2PIa5Yn3pKk8cmLG3IZCh8rBNwcXFhNzc3IQ+LZTS3h04LhbcSlj2DApYdCgbUiECfc8iXc61UB6knzjOwWKayV8DMwkZPKDP2FQAgwKZYOK8ggJ+dUtqxY0o5A6Xk/jYyrfVGRSBY5mAqxPp50R5mPFgOyOZnRcsK12znymeBgI7TzoYAY0XFrkV82CXEDIrnsALDIOC1CHQdbEWu2jac5MLHPWTHwAEhAh5UWMQCngF4BbAL1ng8ttVqZd+/fw9Zr8gjQHyL0TcDDQZQep7LiHbSbw2T4Jvr817BwGuRCmIlbUe9twlASLkp1fr1noX7mQcWi4X1+31brVbW7/dtsVjU5pPzokUYLwAGXogAfAWw+vj4aN++fbPZbGZfv361+Xxut7e3tUTBXJuyko5ZiHofKwQGAPwsb4rxMSlVNz3mASgOCUD+QuH/+uuvYVdNzAi4urqq5VohJGS2mzXExgMSh3k+PpKbOQzFMlJlCtqaw8iXl5c1IKKufr6fc9F4SW3cxzyOOnDOF0Do169f7cuXL3Z/f29///vf7enpyX78+BE2GGLPCtpW+yQl6/RcE29BifGQe1+M9p5NgEbhDuQFfZAPANch3Exs+XNHseBiDwD/VuSDDuKkE86CN9tZJZzYxuEABgI6cDg+yvWNxfpxjDsCcSx2WXHYQPMt+H71EPBiGLynO9Arpr5gUHLCIa/wxc9UbwF/a39zP3lKKcZ870WweuSFcA5BWufS93A7tm035jfuL08IM5gDKe8xwObxg+NVVc/N0fwUjMunp6eQlIXfvO47x2PbUMrqVyWi5732+6NQSslC1iLMAyCHxYOwWityBXiatVk9z0nDqNPpNOSAIMdjMpnU8pjUKGPAorIPHuXtdhtCETzzQ8eFyk02KD3rXT0R4F82sGBIgT952qDX7jmPgEf7jOvXoFbLEeM/mAzMg5WoLi4uwip+SBjkEAKjKnbXgNiVz1aFWX1xFXafM+PBzc3JIfzNLi6zXecBlHDYAlnVWJTlw4cPwaOBuvDaBQpuWCBy+ZVJOQ8Cz2Ohy9tmQpBiP3dYV9++fbPFYmHfv39/MSebF8NAeVIoHeQlTHq84QlOBV3HJB3IXllj5/QaT3HG8hGYYvHnHDgoAQXMV/z+7fbl9Ca2itmbw0oDfIwcHoBhDY/BMwYem81mARRwTgnPQEFIYDwe2/fv38Oyr5yo6tU1ljfAbeRZxbjXCwPGBLfXx++V2ODg+nBy4OXlZZgdgD0EkBfw6dOnsC4LyzYOKyJkwzOMIG+xLO/Dw0NNoaLP1Zjj8pq99CRCbwyHQ1sulwEQDIfDUC9W/Cw3WY5yO7CHU39j9tWPHz9sOp3a58+f7R//+IeNx+Ow4BVWZeUxwzJD5VvMiPIoxc+p/laDU2V7ybuZ9l6OGEoULiV0CqxpjvmwEOFCM2pkawPv4ONsdfBCJev1bj9pWM2c8KZKkZMD2T0F9Nzr9WoJMbooi+YkMHMqClUG1OuBur1juAd11b3cAQywZvt8PrfxeBwGqib5gTxm48HjeTn4d4lyV0vgvdNreQc8Ygs95qpu0tbe8/EdA/JQ/mYvBbLuwcHjN8XrAL+aTMbKAzHY8Xhsk8mktlYGxnkqxyZGMSBQeq/H5++BUmWJuaXVyMDy7EgQxOqsAAjw5sIjoJYury/Cy/MiPIkcEA4VINSk8k+NMJa/VVWFZbKfn59tNBrVjDjPuFC56eVpKSDAB7wHjyovKAS5ymu2eP3RRPGnSL12Ocp5IJrKjcY5AyAuBMeQOp1OWCq02+2GxWeUyXihCHVTc8d7iNJsl6DEyXGc8a5Kn11bDC6YIJQ5hwHegfl8bsPh0NbrdZhutdn83KMeVgcSIFVocnsxc7LrDcwK4QlGxYyByWQS1sFG9vXj46Pd3t7aP/7xjzA9a7VavZj64jFNLG8BZYyVPcZgniDODZq3Ii8sc2hKPZuVfQ5Y6XPU+ogN/pirG89k0I5j7MXSa9jS4jU+EMflRGAzC+MO3ijwLfJVEB5AgitvR8y5KR4A1Xb02sET+tpu3JZee6mw5wTJY1HM62bm50PAqocsur6+DsmBWCfg5uYmrB2AWVyoK2fKw9sKzyT6F8mdyFG6v78PoABJzByW9Ma9Z72CB5fLpXW7XZvP52E6+Wg0MrP67Cvkb2muAPiXDTHIfTYSIWt//Phhi8XCvnz5ErwBWOiKt8bWXDXthxSVePc8yz7mBeB7cp6FUrnbGgxoAdHx3W7XlstlECxw+WElPa4AK0C13tmqZ8WNb84J8Kx+L/5t5u9sFXOp9Pt9m81mQeEj1rZarYLnA/XDYNKkOS+B0MxCGADnUU8ILZ4tgBWxsFb209OTPT4+2o8fP+z29ta+ffsWBCsvEKSxM6YUU3sKS7+99vPacR/r9i2pKSr3KOdW1nb12jtXhtQ4jJVJQS7zpC7GxeEBfKAsAAAQa8b92+22lkSGPBZYVXAZYxtrxJahXHL18do1BggYWGubeSBBfytYN9vlLh2DYh4eT4ZxrhPWDEBY85dffgnbCwMMXFxc1MKdmA3A8hz5AOhLXiYaicv4RgKezt3XunD5FQizlY+p1M/PP6c7A3xyGJV1CT7gcyh/Ngo5zMGGFm89fH9/b4+Pj7V6pPpBSa/n6/hcE8s+JRc8gFByn1Kr2QT4hiKHIADyx7xkdIyZ1ZQeqKrqq1V51jwrcbxXlbwqfg8EKOqKCQL+zUIAiXjYrhLnz8/PQ7b1arWqrTHASYdmu9kFYHreX95rG6yFzSEALMqCZTHv7+8DCOAkFx4cWt9Y/6YYO3aOy+s9ry1jvkfyFHhTt17uWMoroGXhc8w/GmJSkKpTf9n65BkyPJ8cycE4BkUJ4AkefHx8rO0pwBnl8BBAYcSUrLaxKnHP06JWf6rNvXdpWzYZO29BXjnAj+g73rgNqwPyKoFI6ka9FotFAAFmFix+Du3wbCTkAOA6Pqcrnip5StHTKXwt9z+XCe9gvmXvAJ7FUxtRL16sDfkNWOMCmxAhdKVJj14/NOEvT5bGjKrYc1Myd18qBgOqqLiR0DGwRnk5YE2a0sUnYAWrMtdG0o9HnuUVE94lg5xDEc/Pz8H6R9hgMpnYxcVFmIKF6YeoPywrZm4IVk3UQvuxhwMrsU2n0zBd8O9//7uNx2P7/fff7e7uLszR5jpym6MdUpmwnmXP55li1q8iXu8d70Go7ks6mGN1TrmWIYxT13jtVWIdABTwf3jo8G4kZ8GdzPyJhF8GrPACKH/DC7VcLu3u7s4Wi0VIwkIYANdgnDO49+KwHj+qNcagh6/LtWfKvathA8ix98C7niXp8SDyAq6vr+0vf/lLbQVBb5tqrDYJeQPlyPkArPDZooZixTF2vXtyl8lTsLE6QR4ul0vr9/vBdc8glr2wGFte2IpnsiC3aj6f2+fPn20+n9vXr19r573wjDdum+qdlJzk9snRPoaJR3tPLeSCYxWz7XZbs0TMXgIIBRPcyNqY/D+FOvl/DEGVoikVFPjwIjwAAZxpa7YTUhwKwIcXWuK8CeRcmO3mwWI9bCzbitkDyBtgtx7qdgi0mFM6uXc0cXv/EWnfkEIuBt3k2crnMUuD+0QzsBlE8r7znDsAXgVohbCFpQgXMaYJ8sqB7LmL1a+JhcWKAmPNa9OmfYTnob14fL4nPlZwgA8nfOr6J+gDEPqFw7EI8aA/Efbh0CO72dUF36SNPBmidWG3v65oy4mt7HVmA44TU/GNWVgMBpCPxZ6RWHlzsq+JEm9yTxtq+tzGYQKvMdB4UIbo0FJXR6qBPWSl5fCewYzlPSfn+laUBiAAhT2dToPg4EWVBoNBYExeQQuLZ8Bth/KwKwvfSMy5vb0Ny7N+/vzZptOp/fd//3dgZoAQr74xiz+FRr1rUu0cu47PvzdBmiKA15KEsRwa5+d43pQ2SWnsFvYI57jdlS/MLPAr7/3B8WYWvPAksAKG0JxOp3Z/f2/z+dx+/PhRW+sCVqJHuRh8qn56TSoPwPuvxwEA+HmoP0J/UHjHotgYZ6Oj0+kEzwBkUafTCf2AKX64nxOukfkPAwNhHrjXzXY7C7K80BBuKuOeyQsDoD4IVWHBOiRwY08E7JtweXlZ81ShrvAGAJBClo7H45CAjc2wHh8fg1cLIEjDHNzmOra8fuI25r7zro95qnKeFe+9Sk1CZaCDbWEcs0hyBYEATlnz+nz8L7WCPTdO7B0scFWY6hQwDmt4sxTYhaWLLkG48EBCTIwX7nh8fAzfsLrgwsMzUm2Vs/JLrjmEt+G9UImyP8Ssg9T9r5mdXuq50WQr9hbo3h8cxoIHDEoDrmWAU3xYgeYSK0vqVFLPlOLXcZ2jmFx6b6TKipUWLOWqqgKoQZuxtYyYP+QOVjplucZxelCJ/PCMMD3H3mPlQ16gjleEZe8Hg4rtdlvbGpvDHbogG09rheyNjc2cgduG9nlWE7BQSo3AgGdta6F0kKYsen5mybtTZfKIy+IxYew3FDwLTI6bIj8AKByJOSxwEBLA5h+fPn16sRgGBiqQOnZu+/79u00mE/vy5Yv9/vvv9vT0ZN+/fw/TsjBdk92AjNS1fbxB66FXbjdtj9xASCHlY3sH1BvkuZabDvTYtV4fHEr5l3h6PM8Ax/95PjknAyLhF9MHIXzBV0gAxFQygFT2CHB+TUmdPb5IWVDKvym+9Dx8pX0MHoHCaeoCf0vivkZsfDqdBkWJb16XBUnf8Ahwbgcv5W62a2fO3PfkrSdnY8c9bxU8At1uN6yFMBgMwsJIkKNXV1d2dXUVNrPj/Bte9wCJrLe3t7ZYLIIH6+HhoQYC4P1omr8To5SHtO393vNUNpd403LU2DPgdSK/VNGpXpd6XtMBl2LKkns9BkU5ttttDaEi1o8pOwABvFOhPh9TfDBPFolcLKTZM4Dlgx8eHsKOWbe3t2E2AYcUOCbIZVaKKQ6vzVOgIGaJxZg/Vab3QofwALwVlVhhMQI41ZirztGGB4unDUJYwjqEEOXlWuEpaONKL1XOhz6XI/aI7PustyD2BKCPWC55m5AhLwAzBTT27xkcnuKJAQHvGF/LVj3kJWQtVn6FvGUAi99ezhVPxUYoQMEA6s3TKM38tVdSnjY9FzO8+HqPvHcegpoaYq12LcwdK1EGpYOsrTvEswTUq4Fvjr0xk7KbClu0YoMWxFyxtnev1wsbf2BZZqBZXlELgw2Dj3dq+/btmz09PdmXL1/s8fHR7u7uQlwrFY/Ttswp/di1sefH+ggDSd3A2v/vCRSUWIfHBAjaViXjJyWEOQmQ16XnxEBeLhz8blZfSAjLzc7n87CvO5IH2ZLUUBqTxjFTgpbr7vVZUy+OB2g93mVwhFg01++tScvs1Rvtivg+ZnjwbC5NAFSQp8YcKPab/+e8u3odZKyuyYIZLpeXl3Zzc2PD4bAmU8G/8MLC2wGAg+WQHx8fa1tjM+/Cu+UBHm4vr848Ntng9Y4x8TUeqIrpVH5W7NqUMdaUDjqbAKSNhOtwjv8rpdx+pZapno8JA2ZMKH9OouKtW6+urmqrsfFGTFD419fXIUlwNBrZ+fm5XVxcWFXV12o32w1OhAAYDHz9+rW2+AXnJsRcbLE29Y6pB6TkHr1fGdy7X4HAHwkQlDzD7HB10jYqVX4pYY1jbHHx1FZOlOOpZ9iqWGcMYBYLZrTwBlhMcN3GgAG7nGPlTlldJVTiMVBBz/85+feYYABl4/GvPIJYPjLhO51O2CMCdYJngBM79Tkxq1/f6RlYXv/w83g9FXiqALbAjxcXF0HWwqDCAkmXl5e1KbFVVYWwBpZDvru7C/yJrbEx5ZUXZMMCeJyrYGY1T1CJtY5rwNs50KbyMOVxwHcJyCq5toQOlkBodphkhtwgLnmHZ1F48WFlCN4oA3kCcO/DdQpXFQtPAAPObAXx4hhA4c/Pux2+7u/v7e7uziaTSWBmLHzB+2fH2ugQis0jz6vS5hmgYwIBb/Adqt3eS/vHgACHB3iJYT7HghruUyRhISMb080wkyU1WwACL5WMpb9z4EoNi5L2SHnSYhYWZAKUVFXtVgd9z4T2Rt1YQbHcSeU/cLvq79R7U9apgj7wGk9d5ZlYPIMAXixe+4JnXUGxPzw82GKxsIeHh+BpxTbZzKued7Vk/DKoUYs+peA94NTE+Mope89rxIZaU7nUetfCJpQrVGpwpxrTs/ZjCNbzDqhQgqDErotIZIEbtdPphHAB3K5Y1pOXbUWcjldXxLvBnF+/frXb21u7v7+333//3SaTif3f//1fQLbY1EVRrOduUkoxeEk/piw2LkMJHQIgvia9l7yB1EBvCspglcPbBT5FHBbCla1fAGHMBkC29Xw+t+/fv4fdMAEGNN4Kguu9dJqZ1w4lXpGUoo/do+Pdm+UAYc/AHkrnGOR5A2Pjmz2IXkgGv/EM/uZr9XdKieWAAAAK+JFnCwAEICkb2ydfXV2FZZThkdXpgzCkMAWbdx3kmQJIkmQwwODXK7dnLDKIYY8Ae3u9Rd7Ua1BqIJWCspz+awIKGq0z8JqCveT5KSSUauSUAgVT6EIsbOmz0IQghbuKp7mwBwAoHOsS4BjmYT8+PoYPdvvi9QNS01xibVLS6U3RYm7A5+i1LOdD0nsBBDkqcRl6Fq8u3sKJgyBdApynsWL6IPNlyvI/FB2Tb1hZHNsz4Bk2sev0+tx9pXI3d66JPNDpg7znAE+/hvcVoRpeVGg6nQbvKaYN8sqXvNZFbjaIZ/XHfussm9gSzKyXSoxhrzx8vonubeMVMGsYJvAK1RQgpBooVenUe5oyJKNDKHZGqDc3NzYajWw4HAZPgF4DZgWjdLvd4I6DJYFdHJGxu1wu7du3b2HPbOwzgLgWEG4uNID/MRBUatGXgoiU8PHAmDeIjkkYqDzjI1XnEnAQs8zaktc3Jfwc83KxKxZglgUvTyvcbrdhdzqsJDgej0PS1cPDQ23GACtHb5pmbiEgLW/smhJSnk95xFT2cAKhx8PgF15s7K0p5unUc3o85jHk60u9TDnS9Qdi90PuwqvKOQJIHMQSyp8+fQpy9/n5OewJ8/DwEIwnTGvFwkJYLZE9AZofEdNf7L3Afz3X6XTs6uoq5IFVVRU8ErzaIT+b9UIOoHH/pHRhzFNY4lFL0UFzBkophzSboiBPIeWIO5g9AoxKecELJF4hPwDntePQ8axQwKi8dvv9/X1YVwAIF1N8uIwphsgpaTwjdu17t9gPTU145JDeghKrJHau1LrQe/CbP+yq1cVaAEJhWT09PYXELOxcV+qtakMlQNbzCqb+70PqGXgPswmaegGV2sjJWFm8c3hHSTl4lovKXeQN8NRI7IWAHVsRTsXaK0hmZU9szE3uAQIPTPO1+IZ3mHUH9vfABnZeW3lj2AMHKZ7Waw9NBwEDTRm0xA3SxENQinDZWuJkFez5jcxVZLJiNgDWF+h2uwHNcqYx4qdgRAhWTsS6v78Pe2ZPp1O7u7uzh4eH2uIfQI/efFetS2l9X1vhv9V7DkE5PmnCx16dcwCixM2v748JcM8joAQlxlnUulnQarWqLWaFKVlww+IevAuWjr6nCXntXNo3Jf+952Nc8XkOlcTez214LIp5VlLWbk4BtqE2PMheKijOi4sLOz8/Dx6B6+trGwwGdnl5GaZqD4fDIFMXi4V9+/bN7u/v7fv372Fa63g8rk2RZN7OjWU24sDTMSDNz4HXDMshdzod+/XXX+35+dm+fftms9nMxuOxjcfj2jPhgUt9SoFUrt9ThmKK9gIDynSxQVjyHP5OXbMv8fLAWNSCE1j6/X7Y7hPrYHe73QAGOEkQO7fp1svT6TQkryCOhW0yESZArgDvmR2z6Nsq232sgBTFypOyDt4LYDhkOUqf1fSdseub9iXc+ev1Oix4hWN4B0ACclmwMRaWGmbhootc4R1N6lVKTQVkm3eUkhe2OyZ5ADFWvlIjK/YM7/q2Xlh4YGGIIZmV5S5mEfT7/RBeXa1W9vDwYHd3d3Z7exvc8sqfzDOpJbA940rblJ/DshgG3/n5eZha/vHjRzP7qVsAUJ6entx25BkdGDs5j0vOk+G9pw29epgg5R5JuUBK3SOlwgIeATAgkN1wOAwZq0CqmE2AVQZ5+hU6EQKCl2LFDABNaAEYWK1Wtf3eAQJQRg8U6bEYI8far6kSakIeU76GMP5noH3apakS5W8I1Ofnn7tgeluIwzMAL5UX+4yVp0k4JWWl6fNTHsAmHoUSynlXjr3OgFlzAyt1f9P72oxx9gjAEwuFjzVYIIt1lcGqqmozBp6enl7s1sp8jHfFVhJMld1z6zMIQF4JwAWWkJ/NZnZ/fx+ACxLIoU94wS4vxKbjNGbNl/L3IYycxnsTmLVDhilLUp+v50rQbOxedCRi/1jX+ubmpuaeQgILkCrPFuBn8WpfiPNjARaOYcGygpDFNBieMohpg7qUcUm9vTbgtlDmOoTSjgGW2LX7vOuYpPzqJcnxtSBYz2+VZR8D2p6AQQiA93dnMIBz8BDk3MwxQOCFOHL1iFEKEJQeLz3vXYv24VDJW5MH9vcdT028td71KSvWbCdzeQE37CXACwphKiESB5GXZWaBF798+RIWZEO+FXZgVOsdZcCxlOHk1Q/yDV4MDqfxVt8cVgOQwSyz8/Nzq6rKzs/PbTab2Y8fPwKwYUCpHl8YmbwuTa7PSmVxKe09myBFTdBKibLynpdzmaBjwWi8oAWQKKx/zBhgpAfSqYJYlQ0xIkwXxFQX3tUNeQM8DYVXYUsBmjYdzWj5UKGCNsKUy/OeKOeRKnE1xp77FoAgN670PIQQlqtV8Kmb1Oxr6Tcpq3d903P7CEUFNd653NS0PxrtM5ZT57gfMH5ghOmurby3ALczz92HVxUAtXSmVeyYV069R70Dz8/PoZyYUmi2W2WTFT3vlQA9MhwOa+MKK3ZyqIBDBk09Gjlg1oRa7U2gVl8TwaTnUv/5WKryqkTxTkypwnSV4XBonz59CnkC2HVQ9xaAa2u73eUBYDVAIELEVrEWNkIA8Bbw9EKsn82uWW+udqxuTSzyNm2ce673DEbmKVfiexKiPMC1vGz9e3VqAmoPAQhKxhV/x6w3CKzNZmMPDw/W7XZtMpnYcDg0MwsCDgLNmzFQUvcS74lXRs97VWLlM+CNXZM7llMKXO5jhQnaeNhKQwqlz2sqMwACdLogkrThiQU4QH/yFu7Iq4JnACECBQMsQyGTYmECbUtdyM3Masof13Q6u109MR2X83Fub2+tqqqwSi1WToQRCr2xXq/Dzoq8lDfLUS9ckNMLbQC0R0eZWmh2WLee3seWHScMMkLl9dh5NzcWarzlJyx7WP1gTngGcI73B0/Nd2XKgaWmXgJPgDSJR71HRf6aFPM4HTo23YRK2z5Xbr4OoAB10cVcYnHL1HtVaTalUrCau+816M82Djxq0z/gCZa7kL26L4aZBaUKAhhA/gpkr3po1LPapm7eM3h8qB7RxeXMLIR7MaWc7wVQYdDT7XYDEMC9alh5Mv+1+XHvLYxL73kt0vLwb94OEwgVGavwCvA0QShwMB9c/VD+sP4x3xUrs2FqINbM9la9iinjVNukYl4lyj3WLvsK3BhyzVnSb61QPWLvQIqaKEa9D5SylvX6XNs1jdt6wg11An9XVRVitHy+hGLWSml+RazcJdc2oZLnYlzxIkSsyI7Nt+oZ9GSAKpCUAaE8so/h5ZWT12xBTB0ztBCu5cV4kHkPq3kymQRj69u3b8HbqnkbKetf+52nkLIy99oV4WSUW9sKZUc+GfgGoWd8ZrNZqBumqYOnHh4e7Pv372ExOu2LEjl/aL5slUCYon1Qy77xbW0kRnO65KV6A4DseLVAXiIYq10hFMBrtCNbm0MAKEcT5Z0SXKl2TQ3qphbuIRmsrUJ973SoOpVaObH3NVXc3B+eBdJ0nYQYX8FVq9R2DYY2tC/vQXa0MX4OSa/x7lJrOgU8UtfzToTe0u6a8AcjCsnWvPolu9VjyXVahlx9vGfwMegGgIGqqoLCVsALjxsvooRQQlVVIcfs6uoqzGLDqorwKHP7xsaYGnOvwRetNirylHaJsjo0pawjr/E8Rliv1zaZTGp5AcyIYFDMGABCZQb1Mo33Rd36nNizPO9DUwu9qftJUXXquvdCJfOONfboKa8SxRxTeilFjzYt9QqUlCPV9ziH8BXWIUhZW95xzxOh9+DcvnkUJZ6WHGn7KDgy2wEjtmD/2SjFQzkeiPV1ihdwDSdhc6Igy13s3MrTtr1cAX2/V6eY3vIAKxT4+fm5ffr0ya6vr+2vf/1rGBvb7TbseYCYP/IAzMyur69DLg6/G5vfnZ+fB8/0eDwO13FCIcqFnLWczNc672NQHyRnoBQIlBQ01wApF0kTFMVJIMhUxYqAmMICpkSHc4KVx3SewmkDkphhvUFYiuxTgzJ2LOdWLWW0PzoQSF2rv5lKAERO4ZfyTAoM4zvVD15deRZNW+WtwtkTwK8JCkrHhs6cYD6BZ6DpjJJDE3twYuP/kGCljQva4+/YOELWPRtW2IJ4PB7XZhDwgmwlC/RwHRTceZ4w7z6sMvvx40f77bff7N///d/DsvPwXiCXAbMcHh4ezMzCVPXFYlHby6LT6YQF7DCdcjAYhPpwzo6WLWeoHbLvW4MBKBEd7Hxez+1jSTZlzu12t2kQYk5mFjZkWa/X1uv1wmJBAAO8MNBisahtztK0rDEgknMJpaipkm1zfROvhgqPEivyrYljwa/9nhS1AXCp+0rBdY5igHPf6ZGH7O/S/mvi3co9h5N/X3vtiBJieZKyglXxpZ6X+l9KCkwgXxFC3W5/xtdXq1UIH2DNFchbeGixfgsvyMb1Zb3TpC4xBcveYvQ5csVgDPJiSJhVANDc7XbDwkI4hlwCLECEKYZnZ2dmZsGrgNydEo/uWxhXjcMEXqOa+a752LkS6yb27iZeCKBPM7PxeByQ6GAwCC4hIFLEqng2AFsOnIDCvz0EXDpotdxtwVKTNiyhnDUZG2gxHnkPbtYUIFD3ZqzMKZTeNqSgzy6hGABPXR+7X3mY26mNACopTxPF6pWFLcXUe5vyHo91KLRUKPCtSPtL65VSdKn6l8iTFJ/puME39mpBXBzyFEqyqqqaZQ0vABK4Ve7mPL0x+ZO6lklzALDyYVVV9vnzZzs/P7dff/01LKHc7/dtsViEhYXAH8gX4FlryD+4ubmxwWAQVp/lj64xsI/RvA8dbWphig7pIUBHLRaL0NEY2J1OJ8wMwDW8NgALSf2Ova9pGf8oVGKFmuVd18cmVSRNLPHcudx725xv+j6PT0v4kvtXgdMx+RllKeW/Q72Tpxa/90WHciD2Nd8ZO4f2AzDodDo1QMUzBHQaNuRuU1nSlEdi4TSAwMViEfLJzs/Pa3yBWWS8tDy8A5yQzqsYYr2ZxWLxYhEl9lKUlLv0uibUCgxooZsKVGbalEdB/8caIfYuZqz7+/taHBDneEGg2J7TeBY/M+ZaTZUzV97Ytd6ztA31nN7f9J2psjTxzniA6piky+bGLEy9LnWNR7E6H6IfSp+T8gjE6uXxsOdRAR+8hfucAQH+o4ygNm2FUAhbZJxHhKnD2NnxGKRjrqTOpTwWA4kpcFHSzrygGvqOV+fDOQAFLzmQgam+t6S8OSDB1+kHy3NjVtlgMLDHx8ewWV2v17P5fB7CGg8PD7bZbIInACvc4j3Ii+j3+3Z3d2fj8di+fPkSwiNevkCp/swRy98cvcrUwvdiGaMRgFAZxIBRvQWBYghNFZt2SkyYemVKXXNoyimBps8oObePEnwtioG41PUxKlGCr1HnfXlGhSrzcU6Ysuv2UEDAa6PUu737eFy2DW3E5IK6rd8zHXpsN+G1WH9gPQt8s4Gm3te30hsKCFTuY1bNcrkMK86ORqOw+2e3260tNgfvAaYUol5VtdsjAaGS6XQadgVVIJAqa8r4PBTtlTNQKvA9JFOqWFJWdxPrSGN+Oau1pC6pwZIqIwvf1L2x/6ny8bkSBsq1oXd9zlvD7fOePAMYnJ7bN9VP3vkmWfGekt2nLVL9G3tv7nnKk3yf1jEXZuH3p95Zci4n8FL9yJaoVy4FNN4Wzfh9LN4t9cA2HdelVDJOclY9l49lgje2SmRiDqR4/V3Kb3wMXuPn52e7u7uzXq8XZMdqtQqhZ3xDvkyn09piVVVVhQRE3h7c8zLnqKQevMzyq3gG9o0FH8IyxXNiz4gxFQ96ZVy9FsdTg6uJkGWKhUO8ch8C9XnPTQ0UvSZmKcaemwItxwYCmohWaunl+jo1/U77O8Wfbd7NSjxVfk1Q0t+55+sx73+q72O8V2oglJSzKYCIeR/0Wd6xY5Inv/D7NSzrnPL3jqeAZE4elFq9el2pZyNmbIKYVxkMTCaTsIwwZgDAqvf2rYgZC7ifDRIP6JTomFj92src1gmEhxgcTWIfuL6UYkzlKS9PCcbe7V0TO9d0cDZBv22f+xqkSsn7PrYwLZlemFOq3vkUEGgClFOAgMuW4k2l3BgopRjo2KdPY0qmBJh7z2hSp9S1cBFzv76XMMFrKfzU+zxqKrfbPCNV17b8q8e4HCyr1EOEFQZ563l+hmcQMIhkQ1QTUks93m3a+9U9A97Dmyp0TxGXvl8p1XAlVi9QWMk7c4OxtC76nFTdvHY6pGKNeVza1sV79rGzsUvqpeXjAR5r+5yCSHlaYtfGytXGDRwDuyXv5ffE3O05agMiSi3DppQa5/p+r7zHBrNKXKZS3sjJrzZyfB9SvkwpSL1HKSbLvbGvHhUkkUJRI+GRgQHuwUJImDFQVbuNjFTpm9WXLMa7PPkfK3cTAOh5BF4FDOgL970vJiiYPCGcUoqxd8TK3cZyP5ZQ2NcKa+o6bWqFpNo+ds1bEcqR8gxw36Zcm/taiG28YTHejYGcpoDjEBQD3bFjJc8rVd5MTTwnEOQlaxYckw4BzEvufY1rS0gNxH0oBfxLyq18DMUP4lllIA0JsEUe+2j52tb/UO1m1gAMKNowiyfo5O5PHW9jAce8A54g3dcT0VSwpQT2vp3YBjWWWAalrqucNevxzDEIO/MB8adc+zqzJOcJKGnXlKu/iYWf4mXts7ZeAL2+qVX8Fv3cBkw1GSc8a4I/x6ASDyJTEy9MKeXkQGl5YAGXeAAOQeBd752xMprtwkJVVdVWGuTrcY1nRKXGTO5ciSekVJY3Hbuv4hloi+qb3Jsqiwry17SISqnU3fVHoaZhnmMTBDqsQd2ARlefYyWyr0CN8fk+98euiYF273/u+e/FQt5XWeTuVe9AzNJ7L/QaZYm18WvVu01/NvVUxoya2Hjwxg5kgTdmPC8Bn095KdpQDtTEqLQPi8EAZ0wqWm1rfccoNfhLLakmjfYalo9aJK/B/IdQyDm3as5DwgOFBxXqjnY4ZgIWFgDBXurYrwLl5LnlXH5emMpsN7+e63Mo70gKMOzjeVNqYmmWeDsO9b7UeD20kvLkF/iV479Yn4STxt6acopMf+c8eTkezBktbcHxvnzXJPxT+r5UW6lBwItT4XzpomNeG3oAwyuvNy5icj/mdTk4GOCXNEXqbZjnNV1HbZ6bqkMMaZa8pw3oeS1rvKn3QplahZa2y7GsK3gEsPoktqeFokemMA8mRv3wIrBAaLr73j7u1dL7S3k0557dByQ0uWaf62MUA+BteI8XHHoPswnMDgsMY/e+tbevDcBoA0ZLyRt7vAImjqUAVw6stS1vbLzGDPJXAQO877lmWCq9pnuVSd+RQnqx5x8Cheo1h3IJHepZpZRym2m5mMlyZTy2MH18fLROp2Pz+TzsTe7NDVZ+4H3FzV6vL3LxaK/tmmwvrGDMS5iLjRnPW7IPHQIYpsrrAYAcH3Pst9fr2WAwsM1mEzbSgcfgGNREvqVA0GvIJk8Bpdq65Jm54008DE3e4xHXRRdQYh0XA+7scdIyeP3qeQv0fwpY5DwKOSoGAxxT9QqnhXwLK7AJSk41Kui1mavtO7xnHKp9PWbNCU/+TpUFg6EJOn0Nms1mZmZhVTAepEgQUhCAc2a7QcqJZLqIkdevMd7jndi8+3KzHrx3lLgsOTmSf7NC1OfhWvaiMA80AQcqJFOUsuqb8JK+S70iuppir9ezfr//Agy8tbXM1KStmpzblzxejHlJS8pSquhKnlVS7xxfsWyLecZV/jG/seyLjelc+8TkSgo8NTHUmFqtQBhzgTShQynj1DNTSop/l3gUUu78UlSbe0fqvrYIOccUMaVUUifUvQTNHtMzsFwuzWw3TYgHCyt1bQsGA7i2jYWlgqCtlZYCCU29B6VjhXMjNDTitVmOYh6GJsKrCbhkYe2NGW5TrDtvZmFd+sViEUJKxyAPtPA5s8Mp/EPLXz7W1IBJeSnVMlfyjqcMHu+3Kv021ASQxN6X8jqUPFfDGykqBgMcGsAqXUopVOgVNHa8aQekmDD3zhw1QbZ6bVPF77VfTNG2cZd593gCPWYJpe7X5+ixY4IBeAZAnjLx2vlQXpwSaqLcUse8vsR3yUcXUzGz6DeTAie+zgs1pDKxY/eDNNkzRWrFxcp4dnZmnU4n7EmPbc2n06mdnZ3Vppa9NbHnRo+b7a/Ej+VZ8EgVoldHDwjEFHfM0POUahMgEAMjMbniydacDIqV2ytbrO5NwlutlyNuS2+BsEvfUYL81HNQwiBNqMnzSzwGJedy1lzqvCqeHBDgqXrHotiA4nNa59K+LPFwlYLiNp6pfYGACguswOYJ3xhpyIT/s4vUi7uWUCpZs8lzYs/1BCYr4EMBw30p1g/7goLU/ftax23K0UYu87EmMjX37PdKHmiKyetiQ2N7LP/XiU50ohOd6EQnehd0nBTZE53oRCc60YlO9G7oBAZOdKITnehEJ/qT0wkMnOhEJzrRiU70J6cTGDjRiU50ohOd6E9OJzBwohOd6EQnOtGfnE5g4EQnOtGJTnSiPzmdwMCJTnSiE53oRH9yOoGBE53oRCc60Yn+5HQCAyc60YlOdKIT/cnp/wMol3CXhvpMfAAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 640x480 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
    "source": [
-    "# Plot 3 examples from the synthetic data\n",
-    "fig, ax = plt.subplots(nrows=1, ncols=3)\n",
-    "for image_n in range(3):\n",
-    "    ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap=\"gray\")\n",
-    "    ax[image_n].axis(\"off\")"
+    "Compute the SSIM and MS-SSIM between synthetic and real images"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "id": "17d7e059",
-   "metadata": {},
+   "execution_count": 30,
+   "id": "7be636ef",
+   "metadata": {
+    "lines_to_next_cell": 0
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "torch.Size([1005, 2048]) torch.Size([1005, 2048])\n"
+      "MS-SSIM Metric: 0.3681146 +- 0.1401891\n",
+      "SSIM Metric: 0.1698659 +- 0.0763002\n"
      ]
     }
    ],
    "source": [
-    "synch_eval_feats = torch.cat(synth_eval_feats, axis=0)\n",
-    "print(synch_eval_feats.shape, real_eval_feats.shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "2867fc55",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "nan"
-      ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "fid = FID()\n",
-    "results = fid(real_eval_feats.to(device), synch_eval_feats)\n",
-    "results.item()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "3d0e67f4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "nan"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Even when passing the same image, it returns NaNs\n",
-    "fid = FID()\n",
-    "results = fid(synch_eval_feats, synch_eval_feats)\n",
-    "results.item()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "c075646c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "nan"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Even when passing the same image, it returns NaNs\n",
-    "fid = FID()\n",
-    "results = fid(real_eval_feats.to(device), real_eval_feats.to(device))\n",
-    "results.item()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5ba4e62d",
-   "metadata": {},
-   "source": [
-    "# Compute MMD"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "12706705",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Generate a few samples (the 45 for the last batch)\n",
-    "\n",
-    "n_synthetic_images = len(real_img)\n",
-    "syn_image = torch.randn((n_synthetic_images, 1, 64, 64))\n",
-    "syn_image = syn_image.to(device)\n",
-    "scheduler.set_timesteps(num_inference_steps=1000)\n",
+    "ms_ssim_scores = []\n",
+    "ssim_scores = []\n",
     "\n",
-    "with torch.no_grad():\n",
+    "ms_ssim_scores.append(ms_ssim(real_images, synth_images))\n",
+    "ssim_scores.append(ssim(real_images, synth_images))\n",
     "\n",
-    "    z_mu, z_sigma = autoencoderkl.encode(syn_image)\n",
-    "    z = autoencoderkl.sampling(z_mu, z_sigma)\n",
+    "ms_ssim_scores = torch.cat(ms_ssim_scores, dim=0)\n",
+    "ssim_scores = torch.cat(ssim_scores, dim=0)\n",
     "\n",
-    "    noise = torch.randn_like(z).to(device)\n",
-    "    syn_image, intermediates = inferer.sample(\n",
-    "        input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100\n",
-    "    )\n",
-    "    syn_image = autoencoderkl.decode(syn_image)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d571fe41",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mmd = MMD()\n",
-    "mmd(real_img, syn_image)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0d4dee40",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "real_img.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3bb8bb87",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "syn_image.cpu().shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d98f914c",
-   "metadata": {},
-   "source": [
-    "# Compute SSIM"
+    "print(f\"MS-SSIM Metric: {ms_ssim_scores.mean():.7f} +- {ms_ssim_scores.std():.7f}\")\n",
+    "print(f\"SSIM Metric: {ssim_scores.mean():.7f} +- {ssim_scores.std():.7f}\")"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "47c47947",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_range = 1.0\n",
-    "mssim = MSSSIM(data_range=data_range)\n",
-    "mssim(real_img, syn_image)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "051070a5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "real_img.max()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6785ec74",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image1 = torch.ones([3, 3, 144, 144]) / 2\n",
-    "image2 = torch.ones([3, 3, 144, 144]) / 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "09c54917",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_range = 1.0\n",
-    "mssim = MSSSIM(data_range=data_range)\n",
-    "mssim(image1, image2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "004fae2c",
+   "id": "e127a4ce",
    "metadata": {
-    "scrolled": true
+    "lines_to_next_cell": 2
    },
-   "outputs": [
-    {
-     "ename": "RuntimeError",
-     "evalue": "The size of tensor a (138) must match the size of tensor b (3) at non-singleton dimension 5",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn [27], line 9\u001b[0m\n\u001b[1;32m      6\u001b[0m image2 \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mones([\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m144\u001b[39m, \u001b[38;5;241m144\u001b[39m]) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[1;32m      8\u001b[0m mssim \u001b[38;5;241m=\u001b[39m MSSSIM(data_range\u001b[38;5;241m=\u001b[39mdata_range)\n\u001b[0;32m----> 9\u001b[0m \u001b[43mmssim\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimage2\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:332\u001b[0m, in \u001b[0;36mCumulativeIterationMetric.__call__\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m    315\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, y_pred: TensorOrList, y: TensorOrList \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    316\u001b[0m     \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    317\u001b[0m \u001b[38;5;124;03m    Execute basic computation for model prediction and ground truth.\u001b[39;00m\n\u001b[1;32m    318\u001b[0m \u001b[38;5;124;03m    It can support  both `list of channel-first Tensor` and `batch-first Tensor`.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    330\u001b[0m \u001b[38;5;124;03m        a `batch-first` tensor (BC[HWD]) or a list of `batch-first` tensors.\u001b[39;00m\n\u001b[1;32m    331\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 332\u001b[0m     ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my_pred\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    333\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(ret, (\u001b[38;5;28mtuple\u001b[39m, \u001b[38;5;28mlist\u001b[39m)):\n\u001b[1;32m    334\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mextend(\u001b[38;5;241m*\u001b[39mret)\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:73\u001b[0m, in \u001b[0;36mIterationMetric.__call__\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m     71\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(y_pred, torch\u001b[38;5;241m.\u001b[39mTensor):\n\u001b[1;32m     72\u001b[0m     y_ \u001b[38;5;241m=\u001b[39m y\u001b[38;5;241m.\u001b[39mdetach() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(y, torch\u001b[38;5;241m.\u001b[39mTensor) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m---> 73\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdetach\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     74\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my_pred or y must be a list/tuple of `channel-first` Tensors or a `batch-first` Tensor.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/regression.py:82\u001b[0m, in \u001b[0;36mRegressionMetric._compute_tensor\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m     80\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my_pred and y must be PyTorch Tensor.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     81\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_shape(y_pred, y)\n\u001b[0;32m---> 82\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_metric\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m/mnt_homes/home4T7/jdafflon/GenerativeModels/generative/metrics/ms_ssim.py:125\u001b[0m, in \u001b[0;36mMSSSIM._compute_metric\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    123\u001b[0m mcs_list: List[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(levels):\n\u001b[0;32m--> 125\u001b[0m     ssim, cs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSSIM\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_metric_and_contrast\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    127\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m<\u001b[39m levels \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m    128\u001b[0m         mcs_list\u001b[38;5;241m.\u001b[39mappend(torch\u001b[38;5;241m.\u001b[39mrelu(cs))\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/regression.py:368\u001b[0m, in \u001b[0;36mSSIMMetric._compute_metric_and_contrast\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    366\u001b[0m cs_ls \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m    367\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(x\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]):\n\u001b[0;32m--> 368\u001b[0m     ssim_val, cs_val \u001b[38;5;241m=\u001b[39m \u001b[43mSSIMMetric\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    369\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata_range\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwin_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mk1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mk2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mspatial_dims\u001b[49m\n\u001b[1;32m    370\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_compute_metric_and_contrast\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munsqueeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munsqueeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    371\u001b[0m     ssim_ls\u001b[38;5;241m.\u001b[39mappend(ssim_val)\n\u001b[1;32m    372\u001b[0m     cs_ls\u001b[38;5;241m.\u001b[39mappend(cs_val)\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/regression.py:379\u001b[0m, in \u001b[0;36mSSIMMetric._compute_metric_and_contrast\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m    375\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m channel_wise_ssim, channel_wise_cs\n\u001b[1;32m    377\u001b[0m c1, c2, ux, uy, vx, vy, vxy \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compute_intermediate_statistics(x, y)\n\u001b[0;32m--> 379\u001b[0m numerator \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mux\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43muy\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc1\u001b[49m) \u001b[38;5;241m*\u001b[39m (\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m vxy \u001b[38;5;241m+\u001b[39m c2)\n\u001b[1;32m    380\u001b[0m denom \u001b[38;5;241m=\u001b[39m (ux\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m uy\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m c1) \u001b[38;5;241m*\u001b[39m (vx \u001b[38;5;241m+\u001b[39m vy \u001b[38;5;241m+\u001b[39m c2)\n\u001b[1;32m    381\u001b[0m ssim_value \u001b[38;5;241m=\u001b[39m numerator \u001b[38;5;241m/\u001b[39m denom\n",
-      "\u001b[0;31mRuntimeError\u001b[0m: The size of tensor a (138) must match the size of tensor b (3) at non-singleton dimension 5"
-     ]
-    }
-   ],
-   "source": [
-    "from generative.metrics import  MSSSIM\n",
-    "import torch\n",
-    "\n",
-    "data_range = torch.ones(1, 3)\n",
-    "image1 = torch.ones([3, 3, 144, 144]) / 2\n",
-    "image2 = torch.ones([3, 3, 144, 144]) / 2\n",
-    "\n",
-    "mssim = MSSSIM(data_range=data_range)\n",
-    "mssim(image1, image2)"
-   ]
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
index 5f17e6db..7ed94bb6 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
@@ -1,10 +1,35 @@
 # +
-# TODO: Add Open in Colab
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 # -
 
-# ## Setup environment
+# # Evaluate Realism and Diversity of the generated images
 
-# %cd /home/jdafflon/GenerativeModels
+# This notebook illustrates how to use the generative model package to compute:
+# - the realism of generated image using the s Frechet Inception Distance (FID) [1] and Maximum Mean Discrepancy (MMD) [2]
+# - the image diversity using the MS-SSIM [3] and SSIM [4]
+#
+# Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID.
+#
+# [1] - Heusel et al., "Gans trained by a two time-scale update rule converge to a local nash equilibrium", https://arxiv.org/pdf/1706.08500.pdf
+#
+# [2] - Gretton et al., "A Kernel Two-Sample Test", https://www.jmlr.org/papers/volume13/gretton12a/gretton12a.pdf
+#
+# [3] - Wang et al., "Multiscale structural similarity for image quality assessment", https://ieeexplore.ieee.org/document/1292216
+#
+# [4] - Wang et al., "Image quality assessment: from error visibility to structural similarity", https://ieeexplore.ieee.org/document/1284395
+#
+# [5] = Mei et al., "RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning, https://pubs.rsna.org/doi/10.1148/ryai.210315
+
+# ## Setup environment
 
 # +
 import torch
@@ -23,14 +48,19 @@
 from monai.config import print_config
 from monai.utils import set_determinism
 
-from generative.metrics import FID, MMD, MSSSIM
+from generative.metrics import FIDMetric, MMD, MultiScaleSSIMMetric, SSIMMetric
 from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL
-from generative.networks.schedulers import DDPMScheduler
+from generative.networks.schedulers import DDIMScheduler
 from generative.inferers import DiffusionInferer
 
 print_config()
 
 
+# -
+
+# The transformations defined below are necessary in order to transform the input images in the same way that the images were
+# processed for the RadNet train.
+
 # +
 def subtract_mean(x: torch.Tensor) -> torch.Tensor:
     mean = [0.406, 0.456, 0.485]
@@ -39,11 +69,11 @@ def subtract_mean(x: torch.Tensor) -> torch.Tensor:
     x[:, 2, :, :] -= mean[2]
     return x
 
-def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:
+def normalize_tensor(x: torch.Tensor, eps: float=1e-10) -> torch.Tensor:
     norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
     return x / (norm_factor + eps)
 
-def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
+def spatial_average(x: torch.Tensor, keepdim: bool=True) -> torch.Tensor:
     return x.mean([2, 3], keepdim=keepdim)
 
 def get_features(image):
@@ -64,9 +94,6 @@ def get_features(image):
         # flattens the image spatially
         feature_image = spatial_average(feature_image, keepdim=False)
 
-    # normalise through channels
-    #features_image = normalize_tensor(feature_image)
-
     return feature_image
 
 
@@ -97,9 +124,8 @@ def get_features(image):
     spatial_dims=2,
     in_channels=1,
     out_channels=1,
-    num_channels=64,
     latent_channels=3,
-    ch_mult=(1, 2, 2),
+    num_channels=[64, 128, 128],
     num_res_blocks=1,
     norm_num_groups=32,
     attention_levels=(False, False, True),
@@ -108,10 +134,16 @@ def get_features(image):
 
 # +
 unet = DiffusionModelUNet(
-    spatial_dims=2, in_channels=3, out_channels=3, num_res_blocks=1, num_channels=(128, 256, 256), num_head_channels=256
+    spatial_dims=2,
+    in_channels=1,
+    out_channels=1,
+    num_res_blocks=(1, 1, 1),
+    num_channels=(64, 128, 128),
+    attention_levels=(False, True, True),
+    num_head_channels=128
 )
 
-scheduler = DDPMScheduler(num_train_timesteps=1000, beta_schedule="linear", beta_start=0.0015, beta_end=0.0195)
+scheduler = DDIMScheduler(num_train_timesteps=1000, beta_schedule="linear", beta_start=0.0015, beta_end=0.0195)
 
 inferer = DiffusionInferer(scheduler)
 
@@ -129,20 +161,24 @@ def get_features(image):
 )
 discriminator.to(device)
 unet = unet.to(device)
-
 # -
 
 # ## Load pre-trained model
 
-cwd = Path.cwd()
-model_path = cwd / Path("tutorials/generative/2d_ldm/best_aeutoencoderkl.pth")
-autoencoderkl.load_state_dict(torch.load(str(model_path)))
+use_pre_trained = True
 
-cwd = Path.cwd()
-model_path = cwd / Path("tutorials/generative/2d_ldm/best_unet.pth")
-unet.load_state_dict(torch.load(str(model_path)))
+if use_pre_trained:
+    unet = torch.hub.load("marksgraham/pretrained_generative_models:v0.2", model="ddpm_2d", verbose=True)
+    unet = unet.to(device)
+else:
+    cwd = Path.cwd()
+    model_path = cwd / Path("tutorials/generative/2d_ldm/best_aeutoencoderkl.pth")
+    autoencoderkl.load_state_dict(torch.load(str(model_path)))
+    cwd = Path.cwd()
+    model_path = cwd / Path("tutorials/generative/2d_ldm/best_unet.pth")
+    unet.load_state_dict(torch.load(str(model_path)))
 
-# ## Get the validation split for the real images
+# ## Get the real images and syntethic data
 
 val_data = MedNISTDataset(root_dir=root_dir, section="validation", download=True, seed=0)
 val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "Hand"]
@@ -156,53 +192,35 @@ def get_features(image):
 val_ds = Dataset(data=val_datalist, transform=val_transforms)
 val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)
 
-# ## Get features for real data
-
-radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
-radnet.to(device)
-radnet.eval()
-
 # +
-real_eval_feats = []
+# Get the real data
+real_images = []
 
 pbar = tqdm(enumerate(val_loader), total=len(val_loader))
 for step, x in pbar:
     real_img = x["image"].to(device)
-    features_real = get_features(real_img)
-    real_eval_feats.append(features_real.cpu())
+    real_images.append(real_img)
     pbar.update()
 
-real_eval_feats = torch.cat(real_eval_feats, axis=0)
+real_images = torch.cat(real_images, axis=0)
 # -
 
-# ## Generate synthetic images
+# Use the model to generate synthetic images. This step will take about 9 mins.
 
-# +
-synth_eval_feats = []
+synth_images = []
 unet.eval()
-
-#pbar = tqdm(enumerate(val_loader), total=len(val_loader))
 for step, x in enumerate(val_loader):
-    print(step)
     n_synthetic_images = len(x['image'])
-    syn_image = torch.randn((n_synthetic_images, 1, 64, 64))
-    syn_image = syn_image.to(device)
-    scheduler.set_timesteps(num_inference_steps=1000)
+    noise = torch.randn((n_synthetic_images, 1, 64, 64))
+    noise = noise.to(device)
+    scheduler.set_timesteps(num_inference_steps=25)
 
     with torch.no_grad():
-
-        z_mu, z_sigma = autoencoderkl.encode(syn_image)
-        z = autoencoderkl.sampling(z_mu, z_sigma)
-
-        noise = torch.randn_like(z).to(device)
-        syn_image, intermediates = inferer.sample(
-            input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100
-        )
-        syn_image = autoencoderkl.decode(syn_image)
-
-        features_syn_image = get_features(syn_image)
-        synth_eval_feats.append(features_syn_image)
-# -
+        syn_image, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
+                                                  scheduler=scheduler,save_intermediates=True,
+                                                  intermediate_steps=100)
+        synth_images.append(syn_image)
+synth_images = torch.cat(synth_images, axis=0)
 
 # Plot 3 examples from the synthetic data
 fig, ax = plt.subplots(nrows=1, ncols=3)
@@ -210,74 +228,110 @@ def get_features(image):
     ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap="gray")
     ax[image_n].axis("off")
 
-synch_eval_feats = torch.cat(synth_eval_feats, axis=0)
-print(synch_eval_feats.shape, real_eval_feats.shape)
+# ## Compute FID
 
-fid = FID()
-results = fid(real_eval_feats.to(device), synch_eval_feats)
-results.item()
+# The FID measures the distance between the feature vectors from the real images and those obtained from generated images. In order to compute the FID the images need to be passed into a pre-trained network to get the desired feature vectors. Although the FID is commonly computed using the Inception network, here, we used a pre-trained version of the RadImageNet to calculate the feature space.
 
-# Even when passing the same image, it returns NaNs
-fid = FID()
-results = fid(synch_eval_feats, synch_eval_feats)
-results.item()
+radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
+radnet.to(device)
+radnet.eval()
+
+# +
+# Get the features for the real data
+real_eval_feats = get_features(real_images)
+
+# Get the features for the synthetic data
+synth_eval_feats = get_features(synth_images)
+# -
+
+synth_eval_feats.shape, real_eval_feats.shape
 
-# Even when passing the same image, it returns NaNs
-fid = FID()
-results = fid(real_eval_feats.to(device), real_eval_feats.to(device))
-results.item()
+fid = FIDMetric()
+fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))
+print(f"FID Score: {fid_res}")
 
 # # Compute MMD
 
+y = torch.ones([3, 3, 144, 144, 144])
+y_pred =  torch.ones([3, 3, 144, 144, 144])
+mmd = MMD()
+res = mmd(y, y_pred)
+
+y = torch.ones([3, 144, 144, 144])
+y_pred =  torch.ones([3, 144, 144, 144])
+mmd = MMD()
+res = mmd._compute_metric(y, y_pred)
+print(res)
+
+y = torch.ones([3, 3, 144, 144, 144])
+y_pred =  torch.ones([3, 3, 144, 144, 144])
+mmd = MMD()
+res = mmd(y, y_pred)
+
 # +
-# Generate a few samples (the 45 for the last batch)
+mmd_scores = []
+autoencoderkl.eval()
 
-n_synthetic_images = len(real_img)
-syn_image = torch.randn((n_synthetic_images, 1, 64, 64))
-syn_image = syn_image.to(device)
-scheduler.set_timesteps(num_inference_steps=1000)
+mmd = MMD()
+
+for step, x in list(enumerate(val_loader)):
+    image = x["image"].to(device)
 
-with torch.no_grad():
+    with torch.no_grad():
+        image_recon = autoencoderkl.reconstruct(image)
 
-    z_mu, z_sigma = autoencoderkl.encode(syn_image)
-    z = autoencoderkl.sampling(z_mu, z_sigma)
+    mmd_scores.append(mmd._compute_metric(image, image_recon))
+
+mmd_scores = torch.stack(mmd_scores)
+print(f"MS-SSIM score: {mmd_scores.mean().item():.4f} +- {mmd_scores.std().item():.4f}")
 
-    noise = torch.randn_like(z).to(device)
-    syn_image, intermediates = inferer.sample(
-        input_noise=z, diffusion_model=unet, scheduler=scheduler, save_intermediates=True, intermediate_steps=100
-    )
-    syn_image = autoencoderkl.decode(syn_image)
 # -
 
-mmd = MMD()
-mmd(real_img, syn_image)
+# # Compute MultiScaleSSIMMetric and SSIMMetric
+#
+# Both MS-SSIM and SSIM can be used as metric to evaluate the diversity
+#
+# Compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL.
+
+# +
+ms_ssim_recon_scores = []
+ssim_recon_scores = []
+autoencoderkl.eval()
+
+ms_ssim = MultiScaleSSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)
+ssim = SSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)
 
-real_img.shape
+for step, x in list(enumerate(val_loader)):
+    image = x["image"].to(device)
 
-syn_image.cpu().shape
+    with torch.no_grad():
+        image_recon = autoencoderkl.reconstruct(image)
 
-# # Compute SSIM
+    ms_ssim_recon_scores.append(ms_ssim(image, image_recon))
+    ssim_recon_scores.append(ssim(image, image_recon))
 
-data_range = 1.0
-mssim = MSSSIM(data_range=data_range)
-mssim(real_img, syn_image)
+ms_ssim_recon_scores = torch.cat(ms_ssim_recon_scores, dim=0)
+ssim_recon_scores = torch.cat(ssim_recon_scores, dim=0)
 
-real_img.max()
+print(f"MS-SSIM Metric: {ms_ssim_recon_scores.mean():.7f} +- {ms_ssim_recon_scores.std():.7f}")
+print(f"SSIM Metric: {ssim_recon_scores.mean():.7f} +- {ssim_recon_scores.std():.7f}")
 
-image1 = torch.ones([3, 3, 144, 144]) / 2
-image2 = torch.ones([3, 3, 144, 144]) / 2
+# -
 
-data_range = 1.0
-mssim = MSSSIM(data_range=data_range)
-mssim(image1, image2)
+# Compute the SSIM and MS-SSIM between synthetic and real images
 
 # +
-from generative.metrics import  MSSSIM
-import torch
+ms_ssim_scores = []
+ssim_scores = []
+
+ms_ssim_scores.append(ms_ssim(real_images, synth_images))
+ssim_scores.append(ssim(real_images, synth_images))
+
+ms_ssim_scores = torch.cat(ms_ssim_scores, dim=0)
+ssim_scores = torch.cat(ssim_scores, dim=0)
+
+print(f"MS-SSIM Metric: {ms_ssim_scores.mean():.7f} +- {ms_ssim_scores.std():.7f}")
+print(f"SSIM Metric: {ssim_scores.mean():.7f} +- {ssim_scores.std():.7f}")
+# -
 
-data_range = torch.ones(1, 3)
-image1 = torch.ones([3, 3, 144, 144]) / 2
-image2 = torch.ones([3, 3, 144, 144]) / 2
 
-mssim = MSSSIM(data_range=data_range)
-mssim(image1, image2)

From 522ca6db19f7e42686538e331f4545dfe3ea1701 Mon Sep 17 00:00:00 2001
From: JessyD <jejedafflon@gmail.com>
Date: Tue, 2 May 2023 09:39:04 -0400
Subject: [PATCH 4/6] Fix the MMDMetric and add description to the metrics

---
 .../realism_diversity_metrics/FID_test.ipynb  | 407 ------------------
 .../realism_diversity_metrics/FID_test.py     |  82 ----
 .../realism_diversity_metrics.ipynb           | 390 ++++++++---------
 .../realism_diversity_metrics.py              | 163 +++----
 4 files changed, 277 insertions(+), 765 deletions(-)
 delete mode 100644 tutorials/generative/realism_diversity_metrics/FID_test.ipynb
 delete mode 100644 tutorials/generative/realism_diversity_metrics/FID_test.py

diff --git a/tutorials/generative/realism_diversity_metrics/FID_test.ipynb b/tutorials/generative/realism_diversity_metrics/FID_test.ipynb
deleted file mode 100644
index 7f33538f..00000000
--- a/tutorials/generative/realism_diversity_metrics/FID_test.ipynb
+++ /dev/null
@@ -1,407 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "a03242f2",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/mnt_homes/home4T7/jdafflon/GenerativeModels\n"
-     ]
-    }
-   ],
-   "source": [
-    "%cd /home/jdafflon/GenerativeModels"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "8653918c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
-   "source": [
-    "from generative.metrics import FID\n",
-    "import torch"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "3343e510",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def subtract_mean(x: torch.Tensor) -> torch.Tensor:\n",
-    "    mean = [0.406, 0.456, 0.485]\n",
-    "    x[:, 0, :, :] -= mean[0]\n",
-    "    x[:, 1, :, :] -= mean[1]\n",
-    "    x[:, 2, :, :] -= mean[2]\n",
-    "    return x\n",
-    "\n",
-    "def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:\n",
-    "    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))\n",
-    "    return x / (norm_factor + eps)\n",
-    "\n",
-    "def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:\n",
-    "    return x.mean([2, 3], keepdim=keepdim)\n",
-    "\n",
-    "def get_features(image):\n",
-    "\n",
-    "    # If input has just 1 channel, repeat channel to have 3 channels\n",
-    "    if image.shape[1]:\n",
-    "        image = image.repeat(1, 3, 1, 1)\n",
-    "\n",
-    "    # Change order from 'RGB' to 'BGR'\n",
-    "    image = image[:, [2, 1, 0], ...]\n",
-    "\n",
-    "    # Subtract mean used during training\n",
-    "    image = subtract_mean(image)\n",
-    "\n",
-    "    # Get model outputs\n",
-    "    with torch.no_grad():\n",
-    "        feature_image = radnet.forward(image)\n",
-    "        # flattens the image spatially\n",
-    "        feature_image = spatial_average(feature_image, keepdim=False)\n",
-    "\n",
-    "    # normalise through channels\n",
-    "    #features_image = normalize_tensor(feature_image)\n",
-    "\n",
-    "    return feature_image"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "aa1aee60",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Using cuda\n"
-     ]
-    }
-   ],
-   "source": [
-    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-    "print(f\"Using {device}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "b08e78b5",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Using cache found in /home/jdafflon/.cache/torch/hub/Warvito_radimagenet-models_main\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "ResNet50(\n",
-       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n",
-       "  (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.01, affine=True, track_running_stats=True)\n",
-       "  (relu): ReLU(inplace=True)\n",
-       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
-       "  (layer1): Sequential(\n",
-       "    (0): Bottleneck(\n",
-       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "      (downsample): Sequential(\n",
-       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "        (1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (1): Bottleneck(\n",
-       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (2): Bottleneck(\n",
-       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(64, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "  )\n",
-       "  (layer2): Sequential(\n",
-       "    (0): Bottleneck(\n",
-       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(2, 2))\n",
-       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "      (downsample): Sequential(\n",
-       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2))\n",
-       "        (1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (1): Bottleneck(\n",
-       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (2): Bottleneck(\n",
-       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (3): Bottleneck(\n",
-       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(128, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "  )\n",
-       "  (layer3): Sequential(\n",
-       "    (0): Bottleneck(\n",
-       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(2, 2))\n",
-       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "      (downsample): Sequential(\n",
-       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2))\n",
-       "        (1): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (1): Bottleneck(\n",
-       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (2): Bottleneck(\n",
-       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (3): Bottleneck(\n",
-       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (4): Bottleneck(\n",
-       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (5): Bottleneck(\n",
-       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(256, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(1024, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "  )\n",
-       "  (layer4): Sequential(\n",
-       "    (0): Bottleneck(\n",
-       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(2, 2))\n",
-       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "      (downsample): Sequential(\n",
-       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2))\n",
-       "        (1): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (1): Bottleneck(\n",
-       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "    (2): Bottleneck(\n",
-       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn1): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-       "      (bn2): BatchNorm2d(512, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1))\n",
-       "      (bn3): BatchNorm2d(2048, eps=1.001e-05, momentum=0.99, affine=True, track_running_stats=True)\n",
-       "      (relu): ReLU(inplace=True)\n",
-       "    )\n",
-       "  )\n",
-       ")"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "radnet = torch.hub.load(\"Warvito/radimagenet-models\", model=\"radimagenet_resnet50\", verbose=True)\n",
-    "radnet.to(device)\n",
-    "radnet.eval()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "e015ccd6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(-0.0041, device='cuda:0')\n"
-     ]
-    }
-   ],
-   "source": [
-    "image1 = torch.ones([1005, 2, 64, 64]) / 2\n",
-    "image1 = image1.to(device)\n",
-    "image2 = torch.ones([1005, 2, 64, 64]) / 2\n",
-    "image2 = image2.to(device)\n",
-    "features_image_1 = get_features(image1)\n",
-    "features_image_2 = get_features(image2)\n",
-    "\n",
-    "\n",
-    "fid = FID()\n",
-    "results = fid(features_image_1, features_image_2)\n",
-    "print(results)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "46581b20",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(7.2366, device='cuda:0')\n"
-     ]
-    }
-   ],
-   "source": [
-    "image1 = torch.ones([3, 3, 144, 144]) / 2\n",
-    "image1 = image1.to(device)\n",
-    "image2 = torch.ones([3, 3, 144, 144]) / 3\n",
-    "image2 = image2.to(device)\n",
-    "features_image_1 = get_features(image1)\n",
-    "features_image_2 = get_features(image2)\n",
-    "\n",
-    "\n",
-    "fid = FID()\n",
-    "results = fid(features_image_1, features_image_2)\n",
-    "print(results)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "091c4758",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "torch.Size([3, 2048]) torch.Size([3, 2048])\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(features_image_1.shape, features_image_2.shape)"
-   ]
-  }
- ],
- "metadata": {
-  "jupytext": {
-   "formats": "ipynb,py"
-  },
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.15"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/tutorials/generative/realism_diversity_metrics/FID_test.py b/tutorials/generative/realism_diversity_metrics/FID_test.py
deleted file mode 100644
index 9b33d18e..00000000
--- a/tutorials/generative/realism_diversity_metrics/FID_test.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# %cd /home/jdafflon/GenerativeModels
-
-from generative.metrics import FID
-import torch
-
-
-# +
-def subtract_mean(x: torch.Tensor) -> torch.Tensor:
-    mean = [0.406, 0.456, 0.485]
-    x[:, 0, :, :] -= mean[0]
-    x[:, 1, :, :] -= mean[1]
-    x[:, 2, :, :] -= mean[2]
-    return x
-
-def normalize_tensor(x: torch.Tensor, eps: float = 1e-10) -> torch.Tensor:
-    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
-    return x / (norm_factor + eps)
-
-def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
-    return x.mean([2, 3], keepdim=keepdim)
-
-def get_features(image):
-
-    # If input has just 1 channel, repeat channel to have 3 channels
-    if image.shape[1]:
-        image = image.repeat(1, 3, 1, 1)
-
-    # Change order from 'RGB' to 'BGR'
-    image = image[:, [2, 1, 0], ...]
-
-    # Subtract mean used during training
-    image = subtract_mean(image)
-
-    # Get model outputs
-    with torch.no_grad():
-        feature_image = radnet.forward(image)
-        # flattens the image spatially
-        feature_image = spatial_average(feature_image, keepdim=False)
-
-    # normalise through channels
-    #features_image = normalize_tensor(feature_image)
-
-    return feature_image
-
-
-# -
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(f"Using {device}")
-
-radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
-radnet.to(device)
-radnet.eval()
-
-# +
-image1 = torch.ones([1005, 2, 64, 64]) / 2
-image1 = image1.to(device)
-image2 = torch.ones([1005, 2, 64, 64]) / 2
-image2 = image2.to(device)
-features_image_1 = get_features(image1)
-features_image_2 = get_features(image2)
-
-
-fid = FID()
-results = fid(features_image_1, features_image_2)
-print(results)
-
-# +
-image1 = torch.ones([3, 3, 144, 144]) / 2
-image1 = image1.to(device)
-image2 = torch.ones([3, 3, 144, 144]) / 3
-image2 = image2.to(device)
-features_image_1 = get_features(image1)
-features_image_2 = get_features(image2)
-
-
-fid = FID()
-results = fid(features_image_1, features_image_2)
-print(results)
-# -
-
-print(features_image_1.shape, features_image_2.shape)
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
index 49f002f8..82a7a368 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
@@ -32,11 +32,13 @@
    "id": "7dcfe817",
    "metadata": {},
    "source": [
-    "This notebook illustrates how to use the generative model package to compute:\n",
-    "- the realism of generated image using the s Frechet Inception Distance (FID) [1] and Maximum Mean Discrepancy (MMD) [2]\n",
-    "- the image diversity using the MS-SSIM [3] and SSIM [4]\n",
+    "This notebook illustrates how to use the generative model package to compute the most common metrics to evaluate the performance of a generative model. The metrics that we will analyse on this tutorial are:\n",
     "\n",
-    "Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID.\n",
+    "- Frechet Inception Distance (FID) [1] and Maximum Mean Discrepancy (MMD) [2], two metrics commonly used to assess the realism of generated image\n",
+    "\n",
+    "- the MS-SSIM [3] and SSIM [4] used to evaluate the image diversity\n",
+    "\n",
+    "Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID. So we need to transfom the images in the same way they were transformed when the network was trained before computing the FID.\n",
     "\n",
     "[1] - Heusel et al., \"Gans trained by a two time-scale update rule converge to a local nash equilibrium\", https://arxiv.org/pdf/1706.08500.pdf\n",
     "\n",
@@ -46,7 +48,7 @@
     "\n",
     "[4] - Wang et al., \"Image quality assessment: from error visibility to structural similarity\", https://ieeexplore.ieee.org/document/1284395\n",
     "\n",
-    "[5] = Mei et al., \"RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning, https://pubs.rsna.org/doi/10.1148/ryai.210315"
+    "[5] - Mei et al., \"RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning, https://pubs.rsna.org/doi/10.1148/ryai.210315"
    ]
   },
   {
@@ -63,14 +65,6 @@
    "id": "629c60fc",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/jdafflon/miniconda3/envs/genmodels/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -114,7 +108,6 @@
     "import torch\n",
     "from pathlib import Path\n",
     "\n",
-    "from tqdm import tqdm\n",
     "import matplotlib.pyplot as plt\n",
     "from monai.apps import MedNISTDataset\n",
     "from monai import transforms\n",
@@ -125,7 +118,7 @@
     "from monai.config import print_config\n",
     "from monai.utils import set_determinism\n",
     "\n",
-    "from generative.metrics import FIDMetric, MMD, MultiScaleSSIMMetric, SSIMMetric\n",
+    "from generative.metrics import FIDMetric, MMDMetric, MultiScaleSSIMMetric, SSIMMetric\n",
     "from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL\n",
     "from generative.networks.schedulers import DDIMScheduler\n",
     "from generative.inferers import DiffusionInferer\n",
@@ -213,8 +206,7 @@
    ],
    "source": [
     "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
-    "#root_dir = tempfile.mkdtemp() if directory is None else directory\n",
-    "root_dir = \"/tmp/tmpzmzorzlg\"\n",
+    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
     "print(root_dir)"
    ]
   },
@@ -233,7 +225,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "set_determinism(0)"
+    "set_determinism(5)"
    ]
   },
   {
@@ -328,6 +320,14 @@
     "## Load pre-trained model"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "250b1304",
+   "metadata": {},
+   "source": [
+    "Here we will use a pre-trained version of the DDPM downloaded from torch. However, users can also use a local model and evaluate its metrics if they want."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 10,
@@ -357,11 +357,9 @@
     "    unet = torch.hub.load(\"marksgraham/pretrained_generative_models:v0.2\", model=\"ddpm_2d\", verbose=True)\n",
     "    unet = unet.to(device)\n",
     "else:\n",
-    "    cwd = Path.cwd()\n",
-    "    model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_aeutoencoderkl.pth\")\n",
+    "    model_path = Path.cwd() / Path(\"tutorials/generative/2d_ldm/best_aeutoencoderkl.pth\")\n",
     "    autoencoderkl.load_state_dict(torch.load(str(model_path)))\n",
-    "    cwd = Path.cwd()\n",
-    "    model_path = cwd / Path(\"tutorials/generative/2d_ldm/best_unet.pth\")\n",
+    "    model_path = Path.cwd() / Path(\"tutorials/generative/2d_ldm/best_unet.pth\")\n",
     "    unet.load_state_dict(torch.load(str(model_path)))"
    ]
   },
@@ -370,7 +368,15 @@
    "id": "9c187146",
    "metadata": {},
    "source": [
-    "## Get the real images and syntethic data"
+    "## Get the real images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2b42415",
+   "metadata": {},
+   "source": [
+    "Simialry to the 2D LDM tutorial here we will use the MedNISTDataset, which contains images from different body parts. For easiness, here we will use only the `Hand` class. The first part of the code will get the real images from the MedNISTDataset and apply some transformation to scale the intensity of the image. Because we are evaluating the performance of the trained network, we will only use the validation split."
    ]
   },
   {
@@ -383,16 +389,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2023-04-03 21:36:16,283 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
-      "2023-04-03 21:36:16,284 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
-      "2023-04-03 21:36:16,285 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
+      "2023-05-02 01:39:22,365 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2023-05-02 01:39:22,365 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
+      "2023-05-02 01:39:22,366 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2483.21it/s]\n"
+      "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2474.62it/s]\n"
      ]
     }
    ],
@@ -407,99 +413,25 @@
     "    ]\n",
     ")\n",
     "val_ds = Dataset(data=val_datalist, transform=val_transforms)\n",
-    "val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)"
+    "val_loader = DataLoader(val_ds, batch_size=180, shuffle=True, num_workers=4)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
-   "id": "1b48d18c",
+   "id": "c814c33d",
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 16/16 [00:00<00:00, 58.77it/s]\n"
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 26.53it/s]\n"
      ]
-    }
-   ],
-   "source": [
-    "# Get the real data\n",
-    "real_images = []\n",
-    "\n",
-    "pbar = tqdm(enumerate(val_loader), total=len(val_loader))\n",
-    "for step, x in pbar:\n",
-    "    real_img = x[\"image\"].to(device)\n",
-    "    real_images.append(real_img)\n",
-    "    pbar.update()\n",
-    "\n",
-    "real_images = torch.cat(real_images, axis=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "500601a2",
-   "metadata": {},
-   "source": [
-    "Use the model to generate synthetic images. This step will take about 9 mins."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "c8843bc9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.07it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.07it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.05it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.04it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.03it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.02it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.01it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.01it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.00it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.01it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.00it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  3.00it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  2.99it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  2.99it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:08<00:00,  2.99it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:05<00:00,  4.32it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "synth_images = []\n",
-    "unet.eval()\n",
-    "for step, x in enumerate(val_loader):\n",
-    "    n_synthetic_images = len(x['image'])\n",
-    "    noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
-    "    noise = noise.to(device)\n",
-    "    scheduler.set_timesteps(num_inference_steps=25)\n",
-    "\n",
-    "    with torch.no_grad():\n",
-    "        syn_image, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
-    "                                                  scheduler=scheduler,save_intermediates=True,\n",
-    "                                                  intermediate_steps=100)\n",
-    "        synth_images.append(syn_image)\n",
-    "synth_images = torch.cat(synth_images, axis=0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "f0b3c3bc",
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 3 Axes>"
       ]
@@ -509,10 +441,22 @@
     }
    ],
    "source": [
+    "# Create some synthetic data for visualisation\n",
+    "n_synthetic_images = 3\n",
+    "noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "noise = noise.to(device)\n",
+    "scheduler.set_timesteps(num_inference_steps=50)\n",
+    "unet.eval()\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
+    "                                              scheduler=scheduler,save_intermediates=True,\n",
+    "                                              intermediate_steps=100)\n",
+    "\n",
     "# Plot 3 examples from the synthetic data\n",
     "fig, ax = plt.subplots(nrows=1, ncols=3)\n",
     "for image_n in range(3):\n",
-    "    ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap=\"gray\")\n",
+    "    ax[image_n].imshow(syn_images[image_n, 0, :, :].cpu(), cmap=\"gray\")\n",
     "    ax[image_n].axis(\"off\")"
    ]
   },
@@ -529,13 +473,13 @@
    "id": "98452f3f",
    "metadata": {},
    "source": [
-    "The FID measures the distance between the feature vectors from the real images and those obtained from generated images. In order to compute the FID the images need to be passed into a pre-trained network to get the desired feature vectors. Although the FID is commonly computed using the Inception network, here, we used a pre-trained version of the RadImageNet to calculate the feature space."
+    "The FID measures the distance between the feature vectors from the real images and those obtained from generated images. In order to compute the FID the images need to be passed into a pre-trained network to get the desired feature vectors. Although the FID is commonly computed using the Inception network, here, we used a pre-trained version of the RadImageNet to calculate the feature space. Lower FID scores indicate that the images are more similar, with a perfect score being 0 indicating that the two groups of images are identical."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "id": "e9ded5b8",
+   "execution_count": 14,
+   "id": "a42c4e9c",
    "metadata": {},
    "outputs": [
     {
@@ -724,7 +668,7 @@
        ")"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -736,139 +680,141 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "ef279c00",
+   "cell_type": "markdown",
+   "id": "b9faca46",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Get the features for the real data\n",
-    "real_eval_feats = get_features(real_images)\n",
-    "\n",
-    "# Get the features for the synthetic data\n",
-    "synth_eval_feats = get_features(synth_images)"
+    "Here, we will load the real and generate synthetic images from noise and compute the FID of these two groups of images. Because we are generating the synthetic images on this code snippet the entire cell will take about 6 mins run and most of the this time is spent in generating the images. The loading bars show how long it will take to complete the image generation for each mini-batch."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "id": "cc974e37",
+   "execution_count": 15,
+   "id": "1b48d18c",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "(torch.Size([1005, 2048]), torch.Size([1005, 2048]))"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.08it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:13<00:00,  1.86it/s]\n"
+     ]
     }
    ],
    "source": [
-    "synth_eval_feats.shape, real_eval_feats.shape"
+    "fid_scores = []\n",
+    "unet.eval()\n",
+    "\n",
+    "for step, x in enumerate(val_loader):\n",
+    "    # Get the real images\n",
+    "    real_images = x[\"image\"].to(device)\n",
+    "\n",
+    "    # Generate some synthetic images using the defined model\n",
+    "    n_synthetic_images = len(x['image'])\n",
+    "    noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "    noise = noise.to(device)\n",
+    "    scheduler.set_timesteps(num_inference_steps=25)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
+    "                                                  scheduler=scheduler,save_intermediates=True,\n",
+    "                                                  intermediate_steps=100)\n",
+    "\n",
+    "        # Get the features for the real data\n",
+    "        real_eval_feats = get_features(real_images)\n",
+    "\n",
+    "        # Get the features for the synthetic data\n",
+    "        synth_eval_feats = get_features(syn_images)\n",
+    "\n",
+    "        fid = FIDMetric()\n",
+    "        fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))\n",
+    "        fid_scores.append(fid_res)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "id": "17d7e059",
+   "execution_count": 16,
+   "id": "1bcc49bd",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "FID Score: tensor(12.9081, device='cuda:0', dtype=torch.float64)\n"
+      "FID Score: 18.1120 +- 1.8559\n"
      ]
     }
    ],
    "source": [
-    "fid = FIDMetric()\n",
-    "fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))\n",
-    "print(f\"FID Score: {fid_res}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5ba4e62d",
-   "metadata": {},
-   "source": [
-    "# Compute MMD"
+    "fid_scores = torch.stack(fid_scores)\n",
+    "print(f\"FID Score: {fid_scores.mean().item():.4f} +- {fid_scores.std().item():.4f}\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
-   "id": "d7270a66",
+   "execution_count": 17,
+   "id": "2b50e92f",
    "metadata": {},
    "outputs": [
     {
-     "ename": "TypeError",
-     "evalue": "split expects at least a 1-dimensional tensor. `data` should be a batch-first tensor or a list of channel-first tensors, got <class 'torch.Tensor'>",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:207\u001b[0m, in \u001b[0;36mCumulative.extend\u001b[0;34m(self, *data)\u001b[0m\n\u001b[1;32m    206\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:  \u001b[38;5;66;03m# d_t must be a mini-batch of values\u001b[39;00m\n\u001b[0;32m--> 207\u001b[0m     b\u001b[38;5;241m.\u001b[39mextend([x[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43md_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m])\n\u001b[1;32m    208\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mAttributeError\u001b[39;00m, \u001b[38;5;167;01mIndexError\u001b[39;00m, \u001b[38;5;167;01mRuntimeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/torch/functional.py:189\u001b[0m, in \u001b[0;36msplit\u001b[0;34m(tensor, split_size_or_sections, dim)\u001b[0m\n\u001b[1;32m    185\u001b[0m \u001b[38;5;66;03m# Overwriting reason:\u001b[39;00m\n\u001b[1;32m    186\u001b[0m \u001b[38;5;66;03m# This dispatches to two ATen functions depending on the type of\u001b[39;00m\n\u001b[1;32m    187\u001b[0m \u001b[38;5;66;03m# split_size_or_sections. The branching code is in _tensor.py, which we\u001b[39;00m\n\u001b[1;32m    188\u001b[0m \u001b[38;5;66;03m# call here.\u001b[39;00m\n\u001b[0;32m--> 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtensor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43msplit_size_or_sections\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/torch/_tensor.py:786\u001b[0m, in \u001b[0;36mTensor.split\u001b[0;34m(self, split_size, dim)\u001b[0m\n\u001b[1;32m    785\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(split_size, \u001b[38;5;28mint\u001b[39m):\n\u001b[0;32m--> 786\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_VF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msplit_size\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdim\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# type: ignore[attr-defined]\u001b[39;00m\n\u001b[1;32m    787\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
-      "\u001b[0;31mRuntimeError\u001b[0m: split expects at least a 1-dimensional tensor",
-      "\nThe above exception was the direct cause of the following exception:\n",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn [27], line 4\u001b[0m\n\u001b[1;32m      2\u001b[0m y_pred \u001b[38;5;241m=\u001b[39m  torch\u001b[38;5;241m.\u001b[39mones([\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m144\u001b[39m, \u001b[38;5;241m144\u001b[39m, \u001b[38;5;241m144\u001b[39m])\n\u001b[1;32m      3\u001b[0m mmd \u001b[38;5;241m=\u001b[39m MMD()\n\u001b[0;32m----> 4\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mmmd\u001b[49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:336\u001b[0m, in \u001b[0;36mCumulativeIterationMetric.__call__\u001b[0;34m(self, y_pred, y)\u001b[0m\n\u001b[1;32m    334\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mextend(\u001b[38;5;241m*\u001b[39mret)\n\u001b[1;32m    335\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 336\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mextend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mret\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    338\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\n",
-      "File \u001b[0;32m~/miniconda3/envs/genmodels/lib/python3.9/site-packages/monai/metrics/metric.py:209\u001b[0m, in \u001b[0;36mCumulative.extend\u001b[0;34m(self, *data)\u001b[0m\n\u001b[1;32m    207\u001b[0m         b\u001b[38;5;241m.\u001b[39mextend([x[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m torch\u001b[38;5;241m.\u001b[39msplit(d_t, \u001b[38;5;241m1\u001b[39m, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)])\n\u001b[1;32m    208\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mAttributeError\u001b[39;00m, \u001b[38;5;167;01mIndexError\u001b[39;00m, \u001b[38;5;167;01mRuntimeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m--> 209\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m    210\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00me\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m. `data` should be a batch-first tensor or\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    211\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m a list of channel-first tensors, got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(d_t)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    212\u001b[0m         ) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m    213\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_synced \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n",
-      "\u001b[0;31mTypeError\u001b[0m: split expects at least a 1-dimensional tensor. `data` should be a batch-first tensor or a list of channel-first tensors, got <class 'torch.Tensor'>"
-     ]
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "y = torch.ones([3, 3, 144, 144, 144])\n",
-    "y_pred =  torch.ones([3, 3, 144, 144, 144])\n",
-    "mmd = MMD()\n",
-    "res = mmd(y, y_pred)"
+    "# Plot 3 examples from the synthetic data\n",
+    "fig, ax = plt.subplots(nrows=1, ncols=3)\n",
+    "for image_n in range(3):\n",
+    "    ax[image_n].imshow(syn_images[image_n, 0, :, :].cpu(), cmap=\"gray\")\n",
+    "    ax[image_n].axis(\"off\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d0219bab",
+   "cell_type": "markdown",
+   "id": "5ba4e62d",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "y = torch.ones([3, 144, 144, 144])\n",
-    "y_pred =  torch.ones([3, 144, 144, 144])\n",
-    "mmd = MMD()\n",
-    "res = mmd._compute_metric(y, y_pred)\n",
-    "print(res)"
+    "# Compute MMD"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0b671b2f",
+   "cell_type": "markdown",
+   "id": "0fa01253",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "y = torch.ones([3, 3, 144, 144, 144])\n",
-    "y_pred =  torch.ones([3, 3, 144, 144, 144])\n",
-    "mmd = MMD()\n",
-    "res = mmd(y, y_pred)"
+    "MMD (Maximum Mean Discrepancy) is a distance metric used to measure the similarity between two probability distributions. This metric maps the samples from each distribution to a high-dimensional feature space and calculates the distance between the mean of the features of each distribution. A smaller MMD value indicates a better match between the real and generated distributions. It is often used in combination with other evaluation metrics to assess the performance of a generative model."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "id": "e0d92309",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MS-SSIM score: 0.8309 +- 0.0127\n"
+     ]
+    }
+   ],
    "source": [
     "mmd_scores = []\n",
     "autoencoderkl.eval()\n",
     "\n",
-    "mmd = MMD()\n",
+    "mmd = MMDMetric()\n",
     "\n",
     "for step, x in list(enumerate(val_loader)):\n",
     "    image = x[\"image\"].to(device)\n",
@@ -876,7 +822,7 @@
     "    with torch.no_grad():\n",
     "        image_recon = autoencoderkl.reconstruct(image)\n",
     "\n",
-    "    mmd_scores.append(mmd._compute_metric(image, image_recon))\n",
+    "    mmd_scores.append(mmd(image, image_recon))\n",
     "\n",
     "mmd_scores = torch.stack(mmd_scores)\n",
     "print(f\"MS-SSIM score: {mmd_scores.mean().item():.4f} +- {mmd_scores.std().item():.4f}\")\n"
@@ -889,14 +835,16 @@
    "source": [
     "# Compute MultiScaleSSIMMetric and SSIMMetric\n",
     "\n",
-    "Both MS-SSIM and SSIM can be used as metric to evaluate the diversity\n",
+    "Both MS-SSIM and SSIM can be used as metric to evaluate the diversity.\n",
+    "\n",
+    "SSIM measures the similarity between two images based on three components: luminance, contrast, and structure. In addition, MS-SSIM is an extension of SSIM that computes the structural similarity measure at multiple scales. Both metrics can assume values between 0 and 1, where 1 indicates perfect similarity between the images.\n",
     "\n",
-    "Compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL."
+    "In this section we will compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 19,
    "id": "eb2cd8a6",
    "metadata": {},
    "outputs": [
@@ -904,8 +852,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MS-SSIM Metric: 0.0012073 +- 0.0101628\n",
-      "SSIM Metric: 0.0059797 +- 0.0144561\n"
+      "MS-SSIM Metric: 0.0017757 +- 0.0110144\n",
+      "SSIM Metric: -0.0090123 +- 0.0118101\n"
      ]
     }
    ],
@@ -938,32 +886,60 @@
    "id": "30ad94fd",
    "metadata": {},
    "source": [
-    "Compute the SSIM and MS-SSIM between synthetic and real images"
+    "Compute the SSIM and MS-SSIM between synthetic and real images. Note that here we are regenerating some synthetic images."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
-   "id": "7be636ef",
+   "execution_count": 20,
+   "id": "7e189159",
    "metadata": {
     "lines_to_next_cell": 0
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:13<00:00,  1.85it/s]\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MS-SSIM Metric: 0.3681146 +- 0.1401891\n",
-      "SSIM Metric: 0.1698659 +- 0.0763002\n"
+      "MS-SSIM Metric: 0.3694367 +- 0.1433250\n",
+      "SSIM Metric: 0.1711924 +- 0.0788519\n"
      ]
     }
    ],
    "source": [
     "ms_ssim_scores = []\n",
     "ssim_scores = []\n",
+    "unet.eval()\n",
     "\n",
-    "ms_ssim_scores.append(ms_ssim(real_images, synth_images))\n",
-    "ssim_scores.append(ssim(real_images, synth_images))\n",
+    "for step, x in enumerate(val_loader):\n",
+    "    # Get the real images\n",
+    "    real_images = x[\"image\"].to(device)\n",
+    "\n",
+    "    # Generate some synthetic images using the defined model\n",
+    "    n_synthetic_images = len(x['image'])\n",
+    "    noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "    noise = noise.to(device)\n",
+    "    scheduler.set_timesteps(num_inference_steps=25)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
+    "                                                  scheduler=scheduler,save_intermediates=True,\n",
+    "                                                  intermediate_steps=100)\n",
+    "\n",
+    "        ms_ssim_scores.append(ms_ssim(real_images, syn_images))\n",
+    "        ssim_scores.append(ssim(real_images, syn_images))\n",
     "\n",
     "ms_ssim_scores = torch.cat(ms_ssim_scores, dim=0)\n",
     "ssim_scores = torch.cat(ssim_scores, dim=0)\n",
@@ -976,9 +952,15 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "e127a4ce",
-   "metadata": {
-    "lines_to_next_cell": 2
-   },
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84531415",
+   "metadata": {},
    "outputs": [],
    "source": []
   }
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
index 7ed94bb6..d1d8bf90 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
@@ -13,11 +13,13 @@
 
 # # Evaluate Realism and Diversity of the generated images
 
-# This notebook illustrates how to use the generative model package to compute:
-# - the realism of generated image using the s Frechet Inception Distance (FID) [1] and Maximum Mean Discrepancy (MMD) [2]
-# - the image diversity using the MS-SSIM [3] and SSIM [4]
+# This notebook illustrates how to use the generative model package to compute the most common metrics to evaluate the performance of a generative model. The metrics that we will analyse on this tutorial are:
 #
-# Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID.
+# - Frechet Inception Distance (FID) [1] and Maximum Mean Discrepancy (MMD) [2], two metrics commonly used to assess the realism of generated image
+#
+# - the MS-SSIM [3] and SSIM [4] used to evaluate the image diversity
+#
+# Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID. So we need to transfom the images in the same way they were transformed when the network was trained before computing the FID.
 #
 # [1] - Heusel et al., "Gans trained by a two time-scale update rule converge to a local nash equilibrium", https://arxiv.org/pdf/1706.08500.pdf
 #
@@ -27,7 +29,7 @@
 #
 # [4] - Wang et al., "Image quality assessment: from error visibility to structural similarity", https://ieeexplore.ieee.org/document/1284395
 #
-# [5] = Mei et al., "RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning, https://pubs.rsna.org/doi/10.1148/ryai.210315
+# [5] - Mei et al., "RadImageNet: An Open Radiologic Deep Learning Research Dataset for Effective Transfer Learning, https://pubs.rsna.org/doi/10.1148/ryai.210315
 
 # ## Setup environment
 
@@ -37,7 +39,6 @@
 import torch
 from pathlib import Path
 
-from tqdm import tqdm
 import matplotlib.pyplot as plt
 from monai.apps import MedNISTDataset
 from monai import transforms
@@ -48,7 +49,7 @@
 from monai.config import print_config
 from monai.utils import set_determinism
 
-from generative.metrics import FIDMetric, MMD, MultiScaleSSIMMetric, SSIMMetric
+from generative.metrics import FIDMetric, MMDMetric, MultiScaleSSIMMetric, SSIMMetric
 from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL
 from generative.networks.schedulers import DDIMScheduler
 from generative.inferers import DiffusionInferer
@@ -107,13 +108,12 @@ def get_features(image):
 # If not specified a temporary directory will be used.
 
 directory = os.environ.get("MONAI_DATA_DIRECTORY")
-#root_dir = tempfile.mkdtemp() if directory is None else directory
-root_dir = "/tmp/tmpzmzorzlg"
+root_dir = tempfile.mkdtemp() if directory is None else directory
 print(root_dir)
 
 # ## Set deterministic training for reproducibility
 
-set_determinism(0)
+set_determinism(5)
 
 # ## Define the models
 
@@ -165,20 +165,22 @@ def get_features(image):
 
 # ## Load pre-trained model
 
+# Here we will use a pre-trained version of the DDPM downloaded from torch. However, users can also use a local model and evaluate its metrics if they want.
+
 use_pre_trained = True
 
 if use_pre_trained:
     unet = torch.hub.load("marksgraham/pretrained_generative_models:v0.2", model="ddpm_2d", verbose=True)
     unet = unet.to(device)
 else:
-    cwd = Path.cwd()
-    model_path = cwd / Path("tutorials/generative/2d_ldm/best_aeutoencoderkl.pth")
+    model_path = Path.cwd() / Path("tutorials/generative/2d_ldm/best_aeutoencoderkl.pth")
     autoencoderkl.load_state_dict(torch.load(str(model_path)))
-    cwd = Path.cwd()
-    model_path = cwd / Path("tutorials/generative/2d_ldm/best_unet.pth")
+    model_path = Path.cwd() / Path("tutorials/generative/2d_ldm/best_unet.pth")
     unet.load_state_dict(torch.load(str(model_path)))
 
-# ## Get the real images and syntethic data
+# ## Get the real images
+
+# Simialry to the 2D LDM tutorial here we will use the MedNISTDataset, which contains images from different body parts. For easiness, here we will use only the `Hand` class. The first part of the code will get the real images from the MedNISTDataset and apply some transformation to scale the intensity of the image. Because we are evaluating the performance of the trained network, we will only use the validation split.
 
 val_data = MedNISTDataset(root_dir=root_dir, section="validation", download=True, seed=0)
 val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "Hand"]
@@ -190,89 +192,87 @@ def get_features(image):
     ]
 )
 val_ds = Dataset(data=val_datalist, transform=val_transforms)
-val_loader = DataLoader(val_ds, batch_size=64, shuffle=True, num_workers=4)
+val_loader = DataLoader(val_ds, batch_size=180, shuffle=True, num_workers=4)
 
 # +
-# Get the real data
-real_images = []
+# Create some synthetic data for visualisation
+n_synthetic_images = 3
+noise = torch.randn((n_synthetic_images, 1, 64, 64))
+noise = noise.to(device)
+scheduler.set_timesteps(num_inference_steps=50)
+unet.eval()
 
-pbar = tqdm(enumerate(val_loader), total=len(val_loader))
-for step, x in pbar:
-    real_img = x["image"].to(device)
-    real_images.append(real_img)
-    pbar.update()
+with torch.no_grad():
+    syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
+                                              scheduler=scheduler,save_intermediates=True,
+                                              intermediate_steps=100)
 
-real_images = torch.cat(real_images, axis=0)
+# Plot 3 examples from the synthetic data
+fig, ax = plt.subplots(nrows=1, ncols=3)
+for image_n in range(3):
+    ax[image_n].imshow(syn_images[image_n, 0, :, :].cpu(), cmap="gray")
+    ax[image_n].axis("off")
 # -
 
-# Use the model to generate synthetic images. This step will take about 9 mins.
+# ## Compute FID
+
+# The FID measures the distance between the feature vectors from the real images and those obtained from generated images. In order to compute the FID the images need to be passed into a pre-trained network to get the desired feature vectors. Although the FID is commonly computed using the Inception network, here, we used a pre-trained version of the RadImageNet to calculate the feature space. Lower FID scores indicate that the images are more similar, with a perfect score being 0 indicating that the two groups of images are identical.
 
-synth_images = []
+radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
+radnet.to(device)
+radnet.eval()
+
+# Here, we will load the real and generate synthetic images from noise and compute the FID of these two groups of images. Because we are generating the synthetic images on this code snippet the entire cell will take about 6 mins run and most of the this time is spent in generating the images. The loading bars show how long it will take to complete the image generation for each mini-batch.
+
+# +
+fid_scores = []
 unet.eval()
+
 for step, x in enumerate(val_loader):
+    # Get the real images
+    real_images = x["image"].to(device)
+
+    # Generate some synthetic images using the defined model
     n_synthetic_images = len(x['image'])
     noise = torch.randn((n_synthetic_images, 1, 64, 64))
     noise = noise.to(device)
     scheduler.set_timesteps(num_inference_steps=25)
 
     with torch.no_grad():
-        syn_image, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
+        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
                                                   scheduler=scheduler,save_intermediates=True,
                                                   intermediate_steps=100)
-        synth_images.append(syn_image)
-synth_images = torch.cat(synth_images, axis=0)
-
-# Plot 3 examples from the synthetic data
-fig, ax = plt.subplots(nrows=1, ncols=3)
-for image_n in range(3):
-    ax[image_n].imshow(syn_image[image_n, 0, :, :].cpu(), cmap="gray")
-    ax[image_n].axis("off")
-
-# ## Compute FID
 
-# The FID measures the distance between the feature vectors from the real images and those obtained from generated images. In order to compute the FID the images need to be passed into a pre-trained network to get the desired feature vectors. Although the FID is commonly computed using the Inception network, here, we used a pre-trained version of the RadImageNet to calculate the feature space.
+        # Get the features for the real data
+        real_eval_feats = get_features(real_images)
 
-radnet = torch.hub.load("Warvito/radimagenet-models", model="radimagenet_resnet50", verbose=True)
-radnet.to(device)
-radnet.eval()
+        # Get the features for the synthetic data
+        synth_eval_feats = get_features(syn_images)
 
-# +
-# Get the features for the real data
-real_eval_feats = get_features(real_images)
+        fid = FIDMetric()
+        fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))
+        fid_scores.append(fid_res)
 
-# Get the features for the synthetic data
-synth_eval_feats = get_features(synth_images)
 # -
 
-synth_eval_feats.shape, real_eval_feats.shape
+fid_scores = torch.stack(fid_scores)
+print(f"FID Score: {fid_scores.mean().item():.4f} +- {fid_scores.std().item():.4f}")
 
-fid = FIDMetric()
-fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))
-print(f"FID Score: {fid_res}")
+# Plot 3 examples from the synthetic data
+fig, ax = plt.subplots(nrows=1, ncols=3)
+for image_n in range(3):
+    ax[image_n].imshow(syn_images[image_n, 0, :, :].cpu(), cmap="gray")
+    ax[image_n].axis("off")
 
 # # Compute MMD
 
-y = torch.ones([3, 3, 144, 144, 144])
-y_pred =  torch.ones([3, 3, 144, 144, 144])
-mmd = MMD()
-res = mmd(y, y_pred)
-
-y = torch.ones([3, 144, 144, 144])
-y_pred =  torch.ones([3, 144, 144, 144])
-mmd = MMD()
-res = mmd._compute_metric(y, y_pred)
-print(res)
-
-y = torch.ones([3, 3, 144, 144, 144])
-y_pred =  torch.ones([3, 3, 144, 144, 144])
-mmd = MMD()
-res = mmd(y, y_pred)
+# MMD (Maximum Mean Discrepancy) is a distance metric used to measure the similarity between two probability distributions. This metric maps the samples from each distribution to a high-dimensional feature space and calculates the distance between the mean of the features of each distribution. A smaller MMD value indicates a better match between the real and generated distributions. It is often used in combination with other evaluation metrics to assess the performance of a generative model.
 
 # +
 mmd_scores = []
 autoencoderkl.eval()
 
-mmd = MMD()
+mmd = MMDMetric()
 
 for step, x in list(enumerate(val_loader)):
     image = x["image"].to(device)
@@ -280,7 +280,7 @@ def get_features(image):
     with torch.no_grad():
         image_recon = autoencoderkl.reconstruct(image)
 
-    mmd_scores.append(mmd._compute_metric(image, image_recon))
+    mmd_scores.append(mmd(image, image_recon))
 
 mmd_scores = torch.stack(mmd_scores)
 print(f"MS-SSIM score: {mmd_scores.mean().item():.4f} +- {mmd_scores.std().item():.4f}")
@@ -289,9 +289,11 @@ def get_features(image):
 
 # # Compute MultiScaleSSIMMetric and SSIMMetric
 #
-# Both MS-SSIM and SSIM can be used as metric to evaluate the diversity
+# Both MS-SSIM and SSIM can be used as metric to evaluate the diversity.
+#
+# SSIM measures the similarity between two images based on three components: luminance, contrast, and structure. In addition, MS-SSIM is an extension of SSIM that computes the structural similarity measure at multiple scales. Both metrics can assume values between 0 and 1, where 1 indicates perfect similarity between the images.
 #
-# Compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL.
+# In this section we will compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL.
 
 # +
 ms_ssim_recon_scores = []
@@ -318,14 +320,30 @@ def get_features(image):
 
 # -
 
-# Compute the SSIM and MS-SSIM between synthetic and real images
+# Compute the SSIM and MS-SSIM between synthetic and real images. Note that here we are regenerating some synthetic images.
 
 # +
 ms_ssim_scores = []
 ssim_scores = []
+unet.eval()
 
-ms_ssim_scores.append(ms_ssim(real_images, synth_images))
-ssim_scores.append(ssim(real_images, synth_images))
+for step, x in enumerate(val_loader):
+    # Get the real images
+    real_images = x["image"].to(device)
+
+    # Generate some synthetic images using the defined model
+    n_synthetic_images = len(x['image'])
+    noise = torch.randn((n_synthetic_images, 1, 64, 64))
+    noise = noise.to(device)
+    scheduler.set_timesteps(num_inference_steps=25)
+
+    with torch.no_grad():
+        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
+                                                  scheduler=scheduler,save_intermediates=True,
+                                                  intermediate_steps=100)
+
+        ms_ssim_scores.append(ms_ssim(real_images, syn_images))
+        ssim_scores.append(ssim(real_images, syn_images))
 
 ms_ssim_scores = torch.cat(ms_ssim_scores, dim=0)
 ssim_scores = torch.cat(ssim_scores, dim=0)
@@ -335,3 +353,4 @@ def get_features(image):
 # -
 
 
+

From 765dcba24e43cf593c28f7e1e580114e09ff2cd9 Mon Sep 17 00:00:00 2001
From: JessyD <jejedafflon@gmail.com>
Date: Tue, 2 May 2023 15:31:06 -0400
Subject: [PATCH 5/6] Address PR comments

---
 .../realism_diversity_metrics.ipynb           | 189 +++++++++---------
 .../realism_diversity_metrics.py              | 119 ++++++-----
 2 files changed, 149 insertions(+), 159 deletions(-)

diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
index 82a7a368..a5e59863 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
@@ -38,7 +38,7 @@
     "\n",
     "- the MS-SSIM [3] and SSIM [4] used to evaluate the image diversity\n",
     "\n",
-    "Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID. So we need to transfom the images in the same way they were transformed when the network was trained before computing the FID.\n",
+    "Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID. So we need to transform the images in the same way they were transformed when the network was trained before computing the FID.\n",
     "\n",
     "[1] - Heusel et al., \"Gans trained by a two time-scale update rule converge to a local nash equilibrium\", https://arxiv.org/pdf/1706.08500.pdf\n",
     "\n",
@@ -103,25 +103,23 @@
     }
    ],
    "source": [
-    "import torch\n",
     "import os\n",
-    "import torch\n",
+    "import shutil\n",
+    "from itertools import combinations\n",
     "from pathlib import Path\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
-    "from monai.apps import MedNISTDataset\n",
+    "import torch\n",
     "from monai import transforms\n",
-    "from monai.data import DataLoader, Dataset\n",
-    "from monai.networks.layers import Act\n",
-    "\n",
-    "\n",
+    "from monai.apps import MedNISTDataset\n",
     "from monai.config import print_config\n",
+    "from monai.data import DataLoader, Dataset\n",
     "from monai.utils import set_determinism\n",
     "\n",
+    "from generative.inferers import DiffusionInferer\n",
     "from generative.metrics import FIDMetric, MMDMetric, MultiScaleSSIMMetric, SSIMMetric\n",
-    "from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL\n",
+    "from generative.networks.nets import AutoencoderKL, DiffusionModelUNet\n",
     "from generative.networks.schedulers import DDIMScheduler\n",
-    "from generative.inferers import DiffusionInferer\n",
     "\n",
     "print_config()"
    ]
@@ -132,7 +130,7 @@
    "metadata": {},
    "source": [
     "The transformations defined below are necessary in order to transform the input images in the same way that the images were\n",
-    "processed for the RadNet train."
+    "processed for the RadImageNet train."
    ]
   },
   {
@@ -149,10 +147,6 @@
     "    x[:, 2, :, :] -= mean[2]\n",
     "    return x\n",
     "\n",
-    "def normalize_tensor(x: torch.Tensor, eps: float=1e-10) -> torch.Tensor:\n",
-    "    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))\n",
-    "    return x / (norm_factor + eps)\n",
-    "\n",
     "def spatial_average(x: torch.Tensor, keepdim: bool=True) -> torch.Tensor:\n",
     "    return x.mean([2, 3], keepdim=keepdim)\n",
     "\n",
@@ -291,25 +285,11 @@
     "    attention_levels=(False, True, True),\n",
     "    num_head_channels=128\n",
     ")\n",
+    "unet = unet.to(device)\n",
     "\n",
     "scheduler = DDIMScheduler(num_train_timesteps=1000, beta_schedule=\"linear\", beta_start=0.0015, beta_end=0.0195)\n",
     "\n",
-    "inferer = DiffusionInferer(scheduler)\n",
-    "\n",
-    "discriminator = PatchDiscriminator(\n",
-    "    spatial_dims=2,\n",
-    "    num_layers_d=3,\n",
-    "    num_channels=32,\n",
-    "    in_channels=1,\n",
-    "    out_channels=1,\n",
-    "    kernel_size=4,\n",
-    "    activation=(Act.LEAKYRELU, {\"negative_slope\": 0.2}),\n",
-    "    norm=\"BATCH\",\n",
-    "    bias=False,\n",
-    "    padding=1,\n",
-    ")\n",
-    "discriminator.to(device)\n",
-    "unet = unet.to(device)"
+    "inferer = DiffusionInferer(scheduler)"
    ]
   },
   {
@@ -376,7 +356,7 @@
    "id": "b2b42415",
    "metadata": {},
    "source": [
-    "Simialry to the 2D LDM tutorial here we will use the MedNISTDataset, which contains images from different body parts. For easiness, here we will use only the `Hand` class. The first part of the code will get the real images from the MedNISTDataset and apply some transformation to scale the intensity of the image. Because we are evaluating the performance of the trained network, we will only use the validation split."
+    "Similar to the 2D LDM tutorial, we will use the MedNISTDataset, which contains images from different body parts. For easiness, here we will use only the `Hand` class. The first part of the code will get the real images from the MedNISTDataset and apply some transformations to scale the intensity of the image. Because we are evaluating the performance of the trained network, we will only use the validation split."
    ]
   },
   {
@@ -389,16 +369,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2023-05-02 01:39:22,365 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
-      "2023-05-02 01:39:22,365 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
-      "2023-05-02 01:39:22,366 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
+      "2023-05-02 15:26:19,174 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2023-05-02 15:26:19,175 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
+      "2023-05-02 15:26:19,176 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2474.62it/s]\n"
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2743.21it/s]\n"
      ]
     }
    ],
@@ -419,19 +399,19 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "id": "c814c33d",
+   "id": "0e6facbe",
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 26.53it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 26.12it/s]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 3 Axes>"
       ]
@@ -684,30 +664,33 @@
    "id": "b9faca46",
    "metadata": {},
    "source": [
-    "Here, we will load the real and generate synthetic images from noise and compute the FID of these two groups of images. Because we are generating the synthetic images on this code snippet the entire cell will take about 6 mins run and most of the this time is spent in generating the images. The loading bars show how long it will take to complete the image generation for each mini-batch."
+    "Here, we will load the real and generate synthetic images from noise and compute the FID of these two groups of images. Because we are generating the synthetic images on this code snippet the entire cell will take about 6 mins run and most of this time is spent in generating the images. The loading bars show how long it will take to complete the image generation for each mini-batch."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "id": "1b48d18c",
-   "metadata": {},
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.08it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:13<00:00,  1.86it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:13<00:00,  1.84it/s]\n"
      ]
     }
    ],
    "source": [
-    "fid_scores = []\n",
+    "synth_features = []\n",
+    "real_features = []\n",
     "unet.eval()\n",
     "\n",
     "for step, x in enumerate(val_loader):\n",
@@ -721,19 +704,17 @@
     "    scheduler.set_timesteps(num_inference_steps=25)\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
-    "                                                  scheduler=scheduler,save_intermediates=True,\n",
+    "        syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
+    "                                                  scheduler=scheduler,save_intermediates=False,\n",
     "                                                  intermediate_steps=100)\n",
     "\n",
     "        # Get the features for the real data\n",
     "        real_eval_feats = get_features(real_images)\n",
+    "        real_features.append(real_eval_feats)\n",
     "\n",
     "        # Get the features for the synthetic data\n",
     "        synth_eval_feats = get_features(syn_images)\n",
-    "\n",
-    "        fid = FIDMetric()\n",
-    "        fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))\n",
-    "        fid_scores.append(fid_res)\n"
+    "        synth_features.append(synth_eval_feats)\n"
    ]
   },
   {
@@ -746,13 +727,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "FID Score: 18.1120 +- 1.8559\n"
+      "FID Score: 12.0831\n"
      ]
     }
    ],
    "source": [
-    "fid_scores = torch.stack(fid_scores)\n",
-    "print(f\"FID Score: {fid_scores.mean().item():.4f} +- {fid_scores.std().item():.4f}\")"
+    "synth_features = torch.vstack(synth_features)\n",
+    "real_features = torch.vstack(real_features)\n",
+    "\n",
+    "fid = FIDMetric()\n",
+    "fid_res = fid(synth_features, real_features)\n",
+    "\n",
+    "print(f\"FID Score: {fid_res.item():.4f}\")"
    ]
   },
   {
@@ -763,7 +749,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 3 Axes>"
       ]
@@ -793,6 +779,8 @@
    "id": "0fa01253",
    "metadata": {},
    "source": [
+    "Because the realism of the LDMs will depend on the realism of the autoencoder reconstructions, we will compute the MMD betweeen the original images and the reconstructed images to evaluate the performance of the autoencoder.\n",
+    "\n",
     "MMD (Maximum Mean Discrepancy) is a distance metric used to measure the similarity between two probability distributions. This metric maps the samples from each distribution to a high-dimensional feature space and calculates the distance between the mean of the features of each distribution. A smaller MMD value indicates a better match between the real and generated distributions. It is often used in combination with other evaluation metrics to assess the performance of a generative model."
    ]
   },
@@ -806,7 +794,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MS-SSIM score: 0.8309 +- 0.0127\n"
+      "MS-SSIM score: 0.8291 +- 0.0169\n"
      ]
     }
    ],
@@ -835,10 +823,19 @@
    "source": [
     "# Compute MultiScaleSSIMMetric and SSIMMetric\n",
     "\n",
-    "Both MS-SSIM and SSIM can be used as metric to evaluate the diversity.\n",
-    "\n",
     "SSIM measures the similarity between two images based on three components: luminance, contrast, and structure. In addition, MS-SSIM is an extension of SSIM that computes the structural similarity measure at multiple scales. Both metrics can assume values between 0 and 1, where 1 indicates perfect similarity between the images.\n",
     "\n",
+    "There are two ways to compute the MS-SSIM and SSIM, and in this notebook we will look at both ways:\n",
+    "1. Use the reconstructions of the autoencoder and the real images. By using the metric this way we can assess the performance of the autoencoder.\n",
+    "2. Compute the MS-SSIM and SSIM between pairs of synthetic images. This second way of computing the MS-SSIM can be used as a metric to evaluate the diversity of the synthetic images.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd139cb5",
+   "metadata": {},
+   "source": [
     "In this section we will compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL."
    ]
   },
@@ -878,7 +875,7 @@
     "ssim_recon_scores = torch.cat(ssim_recon_scores, dim=0)\n",
     "\n",
     "print(f\"MS-SSIM Metric: {ms_ssim_recon_scores.mean():.7f} +- {ms_ssim_recon_scores.std():.7f}\")\n",
-    "print(f\"SSIM Metric: {ssim_recon_scores.mean():.7f} +- {ssim_recon_scores.std():.7f}\")\n"
+    "print(f\"SSIM Metric: {ssim_recon_scores.mean():.7f} +- {ssim_recon_scores.std():.7f}\")"
    ]
   },
   {
@@ -886,7 +883,7 @@
    "id": "30ad94fd",
    "metadata": {},
    "source": [
-    "Compute the SSIM and MS-SSIM between synthetic and real images. Note that here we are regenerating some synthetic images."
+    "Compute the SSIM and MS-SSIM between pairs of synthetic images, the results of the MS-SSIM and SSIM can be used to evaluate the diversity of the synthetic samples."
    ]
   },
   {
@@ -901,20 +898,15 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:13<00:00,  1.85it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:12<00:00,  1.95it/s]\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MS-SSIM Metric: 0.3694367 +- 0.1433250\n",
-      "SSIM Metric: 0.1711924 +- 0.0788519\n"
+      "MS-SSIM Metric: 0.3235 +- 0.1347\n",
+      "SSIM Metric: 0.1563 +- 0.0668\n"
      ]
     }
    ],
@@ -923,51 +915,56 @@
     "ssim_scores = []\n",
     "unet.eval()\n",
     "\n",
-    "for step, x in enumerate(val_loader):\n",
-    "    # Get the real images\n",
-    "    real_images = x[\"image\"].to(device)\n",
+    "# How many synthetic images we want to generate\n",
+    "n_synthetic_images = 100\n",
     "\n",
-    "    # Generate some synthetic images using the defined model\n",
-    "    n_synthetic_images = len(x['image'])\n",
-    "    noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
-    "    noise = noise.to(device)\n",
-    "    scheduler.set_timesteps(num_inference_steps=25)\n",
+    "# Generate some synthetic images using the defined model\n",
+    "noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
+    "noise = noise.to(device)\n",
+    "scheduler.set_timesteps(num_inference_steps=25)\n",
     "\n",
-    "    with torch.no_grad():\n",
-    "        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
-    "                                                  scheduler=scheduler,save_intermediates=True,\n",
-    "                                                  intermediate_steps=100)\n",
+    "with torch.no_grad():\n",
+    "    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
+    "                                              scheduler=scheduler, save_intermediates=False,\n",
+    "                                              intermediate_steps=100)\n",
+    "\n",
+    "    idx_pairs = list(combinations(range(n_synthetic_images), 2))\n",
+    "    for idx_a, idx_b in idx_pairs:\n",
+    "        ms_ssim_scores.append(ms_ssim(syn_images[[idx_a]], syn_images[[idx_b]]))\n",
+    "        ssim_scores.append(ssim(syn_images[[idx_a]], syn_images[[idx_b]]))\n",
     "\n",
-    "        ms_ssim_scores.append(ms_ssim(real_images, syn_images))\n",
-    "        ssim_scores.append(ssim(real_images, syn_images))\n",
     "\n",
     "ms_ssim_scores = torch.cat(ms_ssim_scores, dim=0)\n",
     "ssim_scores = torch.cat(ssim_scores, dim=0)\n",
     "\n",
-    "print(f\"MS-SSIM Metric: {ms_ssim_scores.mean():.7f} +- {ms_ssim_scores.std():.7f}\")\n",
-    "print(f\"SSIM Metric: {ssim_scores.mean():.7f} +- {ssim_scores.std():.7f}\")"
+    "print(f\"MS-SSIM Metric: {ms_ssim_scores.mean():.4f} +- {ms_ssim_scores.std():.4f}\")\n",
+    "print(f\"SSIM Metric: {ssim_scores.mean():.4f} +- {ssim_scores.std():.4f}\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e127a4ce",
+   "cell_type": "markdown",
+   "id": "bcd99f0d",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "source": [
+    "# Clean-up data"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "84531415",
+   "execution_count": 21,
+   "id": "a2bd7167",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "if directory is None:\n",
+    "    shutil.rmtree(root_dir)"
+   ]
   }
  ],
  "metadata": {
   "jupytext": {
-   "formats": "ipynb,py"
+   "formats": "ipynb,py",
+   "notebook_metadata_filter": "-all"
   },
   "kernelspec": {
    "display_name": "Python 3 (ipykernel)",
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
index d1d8bf90..8f71c4eb 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
@@ -19,7 +19,7 @@
 #
 # - the MS-SSIM [3] and SSIM [4] used to evaluate the image diversity
 #
-# Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID. So we need to transfom the images in the same way they were transformed when the network was trained before computing the FID.
+# Note: We are using the RadImageNet [5] to compute the feature space necessary to compute the FID. So we need to transform the images in the same way they were transformed when the network was trained before computing the FID.
 #
 # [1] - Heusel et al., "Gans trained by a two time-scale update rule converge to a local nash equilibrium", https://arxiv.org/pdf/1706.08500.pdf
 #
@@ -34,25 +34,23 @@
 # ## Setup environment
 
 # +
-import torch
 import os
-import torch
+import shutil
+from itertools import combinations
 from pathlib import Path
 
 import matplotlib.pyplot as plt
-from monai.apps import MedNISTDataset
+import torch
 from monai import transforms
-from monai.data import DataLoader, Dataset
-from monai.networks.layers import Act
-
-
+from monai.apps import MedNISTDataset
 from monai.config import print_config
+from monai.data import DataLoader, Dataset
 from monai.utils import set_determinism
 
+from generative.inferers import DiffusionInferer
 from generative.metrics import FIDMetric, MMDMetric, MultiScaleSSIMMetric, SSIMMetric
-from generative.networks.nets import DiffusionModelUNet, PatchDiscriminator, AutoencoderKL
+from generative.networks.nets import AutoencoderKL, DiffusionModelUNet
 from generative.networks.schedulers import DDIMScheduler
-from generative.inferers import DiffusionInferer
 
 print_config()
 
@@ -60,7 +58,7 @@
 # -
 
 # The transformations defined below are necessary in order to transform the input images in the same way that the images were
-# processed for the RadNet train.
+# processed for the RadImageNet train.
 
 # +
 def subtract_mean(x: torch.Tensor) -> torch.Tensor:
@@ -70,10 +68,6 @@ def subtract_mean(x: torch.Tensor) -> torch.Tensor:
     x[:, 2, :, :] -= mean[2]
     return x
 
-def normalize_tensor(x: torch.Tensor, eps: float=1e-10) -> torch.Tensor:
-    norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
-    return x / (norm_factor + eps)
-
 def spatial_average(x: torch.Tensor, keepdim: bool=True) -> torch.Tensor:
     return x.mean([2, 3], keepdim=keepdim)
 
@@ -142,25 +136,11 @@ def get_features(image):
     attention_levels=(False, True, True),
     num_head_channels=128
 )
+unet = unet.to(device)
 
 scheduler = DDIMScheduler(num_train_timesteps=1000, beta_schedule="linear", beta_start=0.0015, beta_end=0.0195)
 
 inferer = DiffusionInferer(scheduler)
-
-discriminator = PatchDiscriminator(
-    spatial_dims=2,
-    num_layers_d=3,
-    num_channels=32,
-    in_channels=1,
-    out_channels=1,
-    kernel_size=4,
-    activation=(Act.LEAKYRELU, {"negative_slope": 0.2}),
-    norm="BATCH",
-    bias=False,
-    padding=1,
-)
-discriminator.to(device)
-unet = unet.to(device)
 # -
 
 # ## Load pre-trained model
@@ -180,7 +160,7 @@ def get_features(image):
 
 # ## Get the real images
 
-# Simialry to the 2D LDM tutorial here we will use the MedNISTDataset, which contains images from different body parts. For easiness, here we will use only the `Hand` class. The first part of the code will get the real images from the MedNISTDataset and apply some transformation to scale the intensity of the image. Because we are evaluating the performance of the trained network, we will only use the validation split.
+# Similar to the 2D LDM tutorial, we will use the MedNISTDataset, which contains images from different body parts. For easiness, here we will use only the `Hand` class. The first part of the code will get the real images from the MedNISTDataset and apply some transformations to scale the intensity of the image. Because we are evaluating the performance of the trained network, we will only use the validation split.
 
 val_data = MedNISTDataset(root_dir=root_dir, section="validation", download=True, seed=0)
 val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "Hand"]
@@ -222,10 +202,11 @@ def get_features(image):
 radnet.to(device)
 radnet.eval()
 
-# Here, we will load the real and generate synthetic images from noise and compute the FID of these two groups of images. Because we are generating the synthetic images on this code snippet the entire cell will take about 6 mins run and most of the this time is spent in generating the images. The loading bars show how long it will take to complete the image generation for each mini-batch.
+# Here, we will load the real and generate synthetic images from noise and compute the FID of these two groups of images. Because we are generating the synthetic images on this code snippet the entire cell will take about 6 mins run and most of this time is spent in generating the images. The loading bars show how long it will take to complete the image generation for each mini-batch.
 
 # +
-fid_scores = []
+synth_features = []
+real_features = []
 unet.eval()
 
 for step, x in enumerate(val_loader):
@@ -239,24 +220,29 @@ def get_features(image):
     scheduler.set_timesteps(num_inference_steps=25)
 
     with torch.no_grad():
-        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
-                                                  scheduler=scheduler,save_intermediates=True,
+        syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,
+                                                  scheduler=scheduler,save_intermediates=False,
                                                   intermediate_steps=100)
 
         # Get the features for the real data
         real_eval_feats = get_features(real_images)
+        real_features.append(real_eval_feats)
 
         # Get the features for the synthetic data
         synth_eval_feats = get_features(syn_images)
+        synth_features.append(synth_eval_feats)
 
-        fid = FIDMetric()
-        fid_res = fid(synth_eval_feats.to(device), real_eval_feats.to(device))
-        fid_scores.append(fid_res)
 
-# -
 
-fid_scores = torch.stack(fid_scores)
-print(f"FID Score: {fid_scores.mean().item():.4f} +- {fid_scores.std().item():.4f}")
+# +
+synth_features = torch.vstack(synth_features)
+real_features = torch.vstack(real_features)
+
+fid = FIDMetric()
+fid_res = fid(synth_features, real_features)
+
+print(f"FID Score: {fid_res.item():.4f}")
+# -
 
 # Plot 3 examples from the synthetic data
 fig, ax = plt.subplots(nrows=1, ncols=3)
@@ -266,6 +252,8 @@ def get_features(image):
 
 # # Compute MMD
 
+# Because the realism of the LDMs will depend on the realism of the autoencoder reconstructions, we will compute the MMD betweeen the original images and the reconstructed images to evaluate the performance of the autoencoder.
+#
 # MMD (Maximum Mean Discrepancy) is a distance metric used to measure the similarity between two probability distributions. This metric maps the samples from each distribution to a high-dimensional feature space and calculates the distance between the mean of the features of each distribution. A smaller MMD value indicates a better match between the real and generated distributions. It is often used in combination with other evaluation metrics to assess the performance of a generative model.
 
 # +
@@ -289,10 +277,14 @@ def get_features(image):
 
 # # Compute MultiScaleSSIMMetric and SSIMMetric
 #
-# Both MS-SSIM and SSIM can be used as metric to evaluate the diversity.
-#
 # SSIM measures the similarity between two images based on three components: luminance, contrast, and structure. In addition, MS-SSIM is an extension of SSIM that computes the structural similarity measure at multiple scales. Both metrics can assume values between 0 and 1, where 1 indicates perfect similarity between the images.
 #
+# There are two ways to compute the MS-SSIM and SSIM, and in this notebook we will look at both ways:
+# 1. Use the reconstructions of the autoencoder and the real images. By using the metric this way we can assess the performance of the autoencoder.
+# 2. Compute the MS-SSIM and SSIM between pairs of synthetic images. This second way of computing the MS-SSIM can be used as a metric to evaluate the diversity of the synthetic images.
+#
+#
+
 # In this section we will compute the MS-SSIM and SSIM Meteric between the real images and those reconstructed by the AutoencoderKL.
 
 # +
@@ -317,40 +309,41 @@ def get_features(image):
 
 print(f"MS-SSIM Metric: {ms_ssim_recon_scores.mean():.7f} +- {ms_ssim_recon_scores.std():.7f}")
 print(f"SSIM Metric: {ssim_recon_scores.mean():.7f} +- {ssim_recon_scores.std():.7f}")
-
 # -
 
-# Compute the SSIM and MS-SSIM between synthetic and real images. Note that here we are regenerating some synthetic images.
+# Compute the SSIM and MS-SSIM between pairs of synthetic images, the results of the MS-SSIM and SSIM can be used to evaluate the diversity of the synthetic samples.
 
 # +
 ms_ssim_scores = []
 ssim_scores = []
 unet.eval()
 
-for step, x in enumerate(val_loader):
-    # Get the real images
-    real_images = x["image"].to(device)
+# How many synthetic images we want to generate
+n_synthetic_images = 100
 
-    # Generate some synthetic images using the defined model
-    n_synthetic_images = len(x['image'])
-    noise = torch.randn((n_synthetic_images, 1, 64, 64))
-    noise = noise.to(device)
-    scheduler.set_timesteps(num_inference_steps=25)
+# Generate some synthetic images using the defined model
+noise = torch.randn((n_synthetic_images, 1, 64, 64))
+noise = noise.to(device)
+scheduler.set_timesteps(num_inference_steps=25)
 
-    with torch.no_grad():
-        syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
-                                                  scheduler=scheduler,save_intermediates=True,
-                                                  intermediate_steps=100)
+with torch.no_grad():
+    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,
+                                              scheduler=scheduler, save_intermediates=False,
+                                              intermediate_steps=100)
+
+    idx_pairs = list(combinations(range(n_synthetic_images), 2))
+    for idx_a, idx_b in idx_pairs:
+        ms_ssim_scores.append(ms_ssim(syn_images[[idx_a]], syn_images[[idx_b]]))
+        ssim_scores.append(ssim(syn_images[[idx_a]], syn_images[[idx_b]]))
 
-        ms_ssim_scores.append(ms_ssim(real_images, syn_images))
-        ssim_scores.append(ssim(real_images, syn_images))
 
 ms_ssim_scores = torch.cat(ms_ssim_scores, dim=0)
 ssim_scores = torch.cat(ssim_scores, dim=0)
 
-print(f"MS-SSIM Metric: {ms_ssim_scores.mean():.7f} +- {ms_ssim_scores.std():.7f}")
-print(f"SSIM Metric: {ssim_scores.mean():.7f} +- {ssim_scores.std():.7f}")
+print(f"MS-SSIM Metric: {ms_ssim_scores.mean():.4f} +- {ms_ssim_scores.std():.4f}")
+print(f"SSIM Metric: {ssim_scores.mean():.4f} +- {ssim_scores.std():.4f}")
 # -
+# # Clean-up data
 
-
-
+if directory is None:
+    shutil.rmtree(root_dir)

From 1fcd0928556af3975163cc1ec3489f81ba120e35 Mon Sep 17 00:00:00 2001
From: JessyD <jejedafflon@gmail.com>
Date: Tue, 2 May 2023 16:31:05 -0400
Subject: [PATCH 6/6] Address second round for PR comments

---
 .../realism_diversity_metrics.ipynb           | 282 ++++++++++++++++--
 .../realism_diversity_metrics.py              |  31 +-
 2 files changed, 264 insertions(+), 49 deletions(-)

diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
index a5e59863..c197f1aa 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.ipynb
@@ -63,7 +63,9 @@
    "cell_type": "code",
    "execution_count": 3,
    "id": "629c60fc",
-   "metadata": {},
+   "metadata": {
+    "lines_to_end_of_cell_marker": 2
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -104,6 +106,7 @@
    ],
    "source": [
     "import os\n",
+    "import tempfile\n",
     "import shutil\n",
     "from itertools import combinations\n",
     "from pathlib import Path\n",
@@ -127,7 +130,9 @@
   {
    "cell_type": "markdown",
    "id": "620df5c6",
-   "metadata": {},
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
    "source": [
     "The transformations defined below are necessary in order to transform the input images in the same way that the images were\n",
     "processed for the RadImageNet train."
@@ -147,11 +152,12 @@
     "    x[:, 2, :, :] -= mean[2]\n",
     "    return x\n",
     "\n",
-    "def spatial_average(x: torch.Tensor, keepdim: bool=True) -> torch.Tensor:\n",
+    "\n",
+    "def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:\n",
     "    return x.mean([2, 3], keepdim=keepdim)\n",
     "\n",
-    "def get_features(image):\n",
     "\n",
+    "def get_features(image):\n",
     "    # If input has just 1 channel, repeat channel to have 3 channels\n",
     "    if image.shape[1]:\n",
     "        image = image.repeat(1, 3, 1, 1)\n",
@@ -194,7 +200,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "/tmp/tmpzmzorzlg\n"
+      "/tmp/tmpfa_a4r00\n"
      ]
     }
    ],
@@ -254,7 +260,212 @@
    "execution_count": 8,
    "id": "195db858",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AutoencoderKL(\n",
+       "  (encoder): Encoder(\n",
+       "    (blocks): ModuleList(\n",
+       "      (0): Convolution(\n",
+       "        (conv): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      )\n",
+       "      (1): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 64, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 64, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (2): Downsample(\n",
+       "        (conv): Convolution(\n",
+       "          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2))\n",
+       "        )\n",
+       "      )\n",
+       "      (3): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 64, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Convolution(\n",
+       "          (conv): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+       "        )\n",
+       "      )\n",
+       "      (4): Downsample(\n",
+       "        (conv): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2))\n",
+       "        )\n",
+       "      )\n",
+       "      (5): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (6): AttentionBlock(\n",
+       "        (norm): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (to_q): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_k): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_v): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (proj_attn): Linear(in_features=128, out_features=128, bias=True)\n",
+       "      )\n",
+       "      (7): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (8): AttentionBlock(\n",
+       "        (norm): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (to_q): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_k): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_v): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (proj_attn): Linear(in_features=128, out_features=128, bias=True)\n",
+       "      )\n",
+       "      (9): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (10): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "      (11): Convolution(\n",
+       "        (conv): Conv2d(128, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (decoder): Decoder(\n",
+       "    (blocks): ModuleList(\n",
+       "      (0): Convolution(\n",
+       "        (conv): Conv2d(3, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      )\n",
+       "      (1): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (2): AttentionBlock(\n",
+       "        (norm): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (to_q): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_k): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_v): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (proj_attn): Linear(in_features=128, out_features=128, bias=True)\n",
+       "      )\n",
+       "      (3): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (4): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (5): AttentionBlock(\n",
+       "        (norm): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (to_q): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_k): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (to_v): Linear(in_features=128, out_features=128, bias=True)\n",
+       "        (proj_attn): Linear(in_features=128, out_features=128, bias=True)\n",
+       "      )\n",
+       "      (6): Upsample(\n",
+       "        (conv): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "      )\n",
+       "      (7): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Identity()\n",
+       "      )\n",
+       "      (8): Upsample(\n",
+       "        (conv): Convolution(\n",
+       "          (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "      )\n",
+       "      (9): ResBlock(\n",
+       "        (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+       "        (conv1): Convolution(\n",
+       "          (conv): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (norm2): GroupNorm(32, 64, eps=1e-06, affine=True)\n",
+       "        (conv2): Convolution(\n",
+       "          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "        )\n",
+       "        (nin_shortcut): Convolution(\n",
+       "          (conv): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+       "        )\n",
+       "      )\n",
+       "      (10): GroupNorm(32, 64, eps=1e-06, affine=True)\n",
+       "      (11): Convolution(\n",
+       "        (conv): Conv2d(64, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (quant_conv_mu): Convolution(\n",
+       "    (conv): Conv2d(3, 3, kernel_size=(1, 1), stride=(1, 1))\n",
+       "  )\n",
+       "  (quant_conv_log_sigma): Convolution(\n",
+       "    (conv): Conv2d(3, 3, kernel_size=(1, 1), stride=(1, 1))\n",
+       "  )\n",
+       "  (post_quant_conv): Convolution(\n",
+       "    (conv): Conv2d(3, 3, kernel_size=(1, 1), stride=(1, 1))\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "autoencoderkl = AutoencoderKL(\n",
     "    spatial_dims=2,\n",
@@ -266,7 +477,8 @@
     "    norm_num_groups=32,\n",
     "    attention_levels=(False, False, True),\n",
     ")\n",
-    "autoencoderkl = autoencoderkl.to(device)"
+    "autoencoderkl = autoencoderkl.to(device)\n",
+    "autoencoderkl.eval()"
    ]
   },
   {
@@ -283,9 +495,10 @@
     "    num_res_blocks=(1, 1, 1),\n",
     "    num_channels=(64, 128, 128),\n",
     "    attention_levels=(False, True, True),\n",
-    "    num_head_channels=128\n",
+    "    num_head_channels=128,\n",
     ")\n",
     "unet = unet.to(device)\n",
+    "unet.eval()\n",
     "\n",
     "scheduler = DDIMScheduler(num_train_timesteps=1000, beta_schedule=\"linear\", beta_start=0.0015, beta_end=0.0195)\n",
     "\n",
@@ -365,20 +578,40 @@
    "id": "bd4c90f9",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "MedNIST.tar.gz: 59.0MB [00:00, 130MB/s]                                                                                                                                                                                                             "
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2023-05-02 15:26:19,174 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
-      "2023-05-02 15:26:19,175 - INFO - File exists: /tmp/tmpzmzorzlg/MedNIST.tar.gz, skipped downloading.\n",
-      "2023-05-02 15:26:19,176 - INFO - Non-empty folder exists in /tmp/tmpzmzorzlg/MedNIST, skipped extracting.\n"
+      "2023-05-02 16:24:48,981 - INFO - Downloaded: /tmp/tmpfa_a4r00/MedNIST.tar.gz\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2743.21it/s]\n"
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2023-05-02 16:24:49,097 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2023-05-02 16:24:49,098 - INFO - Writing into directory: /tmp/tmpfa_a4r00.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:02<00:00, 2657.67it/s]\n"
      ]
     }
    ],
@@ -406,7 +639,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 26.12it/s]\n"
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:01<00:00, 26.71it/s]\n"
      ]
     },
     {
@@ -426,12 +659,9 @@
     "noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
     "noise = noise.to(device)\n",
     "scheduler.set_timesteps(num_inference_steps=50)\n",
-    "unet.eval()\n",
     "\n",
     "with torch.no_grad():\n",
-    "    syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
-    "                                              scheduler=scheduler,save_intermediates=True,\n",
-    "                                              intermediate_steps=100)\n",
+    "    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet, scheduler=scheduler)\n",
     "\n",
     "# Plot 3 examples from the synthetic data\n",
     "fig, ax = plt.subplots(nrows=1, ncols=3)\n",
@@ -681,7 +911,7 @@
      "text": [
       "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
       "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.07it/s]\n",
       "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
       "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:23<00:00,  1.06it/s]\n",
       "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 25/25 [00:13<00:00,  1.84it/s]\n"
@@ -691,22 +921,19 @@
    "source": [
     "synth_features = []\n",
     "real_features = []\n",
-    "unet.eval()\n",
     "\n",
     "for step, x in enumerate(val_loader):\n",
     "    # Get the real images\n",
     "    real_images = x[\"image\"].to(device)\n",
     "\n",
     "    # Generate some synthetic images using the defined model\n",
-    "    n_synthetic_images = len(x['image'])\n",
+    "    n_synthetic_images = len(x[\"image\"])\n",
     "    noise = torch.randn((n_synthetic_images, 1, 64, 64))\n",
     "    noise = noise.to(device)\n",
     "    scheduler.set_timesteps(num_inference_steps=25)\n",
     "\n",
     "    with torch.no_grad():\n",
-    "        syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
-    "                                                  scheduler=scheduler,save_intermediates=False,\n",
-    "                                                  intermediate_steps=100)\n",
+    "        syn_images = inferer.sample(input_noise=noise, diffusion_model=unet, scheduler=scheduler)\n",
     "\n",
     "        # Get the features for the real data\n",
     "        real_eval_feats = get_features(real_images)\n",
@@ -714,7 +941,7 @@
     "\n",
     "        # Get the features for the synthetic data\n",
     "        synth_eval_feats = get_features(syn_images)\n",
-    "        synth_features.append(synth_eval_feats)\n"
+    "        synth_features.append(synth_eval_feats)"
    ]
   },
   {
@@ -800,7 +1027,6 @@
    ],
    "source": [
     "mmd_scores = []\n",
-    "autoencoderkl.eval()\n",
     "\n",
     "mmd = MMDMetric()\n",
     "\n",
@@ -857,7 +1083,6 @@
    "source": [
     "ms_ssim_recon_scores = []\n",
     "ssim_recon_scores = []\n",
-    "autoencoderkl.eval()\n",
     "\n",
     "ms_ssim = MultiScaleSSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)\n",
     "ssim = SSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)\n",
@@ -913,7 +1138,6 @@
    "source": [
     "ms_ssim_scores = []\n",
     "ssim_scores = []\n",
-    "unet.eval()\n",
     "\n",
     "# How many synthetic images we want to generate\n",
     "n_synthetic_images = 100\n",
@@ -924,9 +1148,7 @@
     "scheduler.set_timesteps(num_inference_steps=25)\n",
     "\n",
     "with torch.no_grad():\n",
-    "    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,\n",
-    "                                              scheduler=scheduler, save_intermediates=False,\n",
-    "                                              intermediate_steps=100)\n",
+    "    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet, scheduler=scheduler)\n",
     "\n",
     "    idx_pairs = list(combinations(range(n_synthetic_images), 2))\n",
     "    for idx_a, idx_b in idx_pairs:\n",
diff --git a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
index 8f71c4eb..addc7aad 100644
--- a/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
+++ b/tutorials/generative/realism_diversity_metrics/realism_diversity_metrics.py
@@ -35,6 +35,7 @@
 
 # +
 import os
+import tempfile
 import shutil
 from itertools import combinations
 from pathlib import Path
@@ -60,6 +61,7 @@
 # The transformations defined below are necessary in order to transform the input images in the same way that the images were
 # processed for the RadImageNet train.
 
+
 # +
 def subtract_mean(x: torch.Tensor) -> torch.Tensor:
     mean = [0.406, 0.456, 0.485]
@@ -68,11 +70,12 @@ def subtract_mean(x: torch.Tensor) -> torch.Tensor:
     x[:, 2, :, :] -= mean[2]
     return x
 
-def spatial_average(x: torch.Tensor, keepdim: bool=True) -> torch.Tensor:
+
+def spatial_average(x: torch.Tensor, keepdim: bool = True) -> torch.Tensor:
     return x.mean([2, 3], keepdim=keepdim)
 
-def get_features(image):
 
+def get_features(image):
     # If input has just 1 channel, repeat channel to have 3 channels
     if image.shape[1]:
         image = image.repeat(1, 3, 1, 1)
@@ -125,6 +128,7 @@ def get_features(image):
     attention_levels=(False, False, True),
 )
 autoencoderkl = autoencoderkl.to(device)
+autoencoderkl.eval()
 
 # +
 unet = DiffusionModelUNet(
@@ -134,9 +138,10 @@ def get_features(image):
     num_res_blocks=(1, 1, 1),
     num_channels=(64, 128, 128),
     attention_levels=(False, True, True),
-    num_head_channels=128
+    num_head_channels=128,
 )
 unet = unet.to(device)
+unet.eval()
 
 scheduler = DDIMScheduler(num_train_timesteps=1000, beta_schedule="linear", beta_start=0.0015, beta_end=0.0195)
 
@@ -180,12 +185,9 @@ def get_features(image):
 noise = torch.randn((n_synthetic_images, 1, 64, 64))
 noise = noise.to(device)
 scheduler.set_timesteps(num_inference_steps=50)
-unet.eval()
 
 with torch.no_grad():
-    syn_images, intermediates = inferer.sample(input_noise=noise, diffusion_model=unet,
-                                              scheduler=scheduler,save_intermediates=True,
-                                              intermediate_steps=100)
+    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet, scheduler=scheduler)
 
 # Plot 3 examples from the synthetic data
 fig, ax = plt.subplots(nrows=1, ncols=3)
@@ -207,22 +209,19 @@ def get_features(image):
 # +
 synth_features = []
 real_features = []
-unet.eval()
 
 for step, x in enumerate(val_loader):
     # Get the real images
     real_images = x["image"].to(device)
 
     # Generate some synthetic images using the defined model
-    n_synthetic_images = len(x['image'])
+    n_synthetic_images = len(x["image"])
     noise = torch.randn((n_synthetic_images, 1, 64, 64))
     noise = noise.to(device)
     scheduler.set_timesteps(num_inference_steps=25)
 
     with torch.no_grad():
-        syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,
-                                                  scheduler=scheduler,save_intermediates=False,
-                                                  intermediate_steps=100)
+        syn_images = inferer.sample(input_noise=noise, diffusion_model=unet, scheduler=scheduler)
 
         # Get the features for the real data
         real_eval_feats = get_features(real_images)
@@ -233,7 +232,6 @@ def get_features(image):
         synth_features.append(synth_eval_feats)
 
 
-
 # +
 synth_features = torch.vstack(synth_features)
 real_features = torch.vstack(real_features)
@@ -258,7 +256,6 @@ def get_features(image):
 
 # +
 mmd_scores = []
-autoencoderkl.eval()
 
 mmd = MMDMetric()
 
@@ -290,7 +287,6 @@ def get_features(image):
 # +
 ms_ssim_recon_scores = []
 ssim_recon_scores = []
-autoencoderkl.eval()
 
 ms_ssim = MultiScaleSSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)
 ssim = SSIMMetric(spatial_dims=2, data_range=1.0, kernel_size=4)
@@ -316,7 +312,6 @@ def get_features(image):
 # +
 ms_ssim_scores = []
 ssim_scores = []
-unet.eval()
 
 # How many synthetic images we want to generate
 n_synthetic_images = 100
@@ -327,9 +322,7 @@ def get_features(image):
 scheduler.set_timesteps(num_inference_steps=25)
 
 with torch.no_grad():
-    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet,
-                                              scheduler=scheduler, save_intermediates=False,
-                                              intermediate_steps=100)
+    syn_images = inferer.sample(input_noise=noise, diffusion_model=unet, scheduler=scheduler)
 
     idx_pairs = list(combinations(range(n_synthetic_images), 2))
     for idx_a, idx_b in idx_pairs: