"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "fig, axs = plt.subplots(1, 3, figsize=((9, 3)))\n",
+ "\n",
+ "for curve_idx, ax in enumerate(axs.ravel()):\n",
+ " approach_curve = unknown_approach_curves[curve_idx]\n",
+ " contactpoint = unknown_contactpoints[curve_idx]\n",
+ "\n",
+ " ax.plot(approach_curve[:, 0], approach_curve[:, 1], label=\"Approach Curve\")\n",
+ "\n",
+ " ax.set_xlabel(\"Vertical Tip Position (µm)\", fontsize=12)\n",
+ " if curve_idx == 0:\n",
+ " ax.set_ylabel(\"Vertical Deflection (nN)\", fontsize=12)\n",
+ " ax.legend()\n",
+ "\n",
+ "fig.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c3bfa000-3e82-4ba7-b64e-0b972915c2aa",
+ "metadata": {},
+ "source": [
+ "## 2. Anomaly Detection of Approach Curves"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca8d26c9-013a-4ea5-91e7-2c33f13a65de",
+ "metadata": {},
+ "source": [
+ "### 2.1. Data Preprocessing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f2acb9ef-5e35-4503-b8c4-4994e7aaaa5a",
+ "metadata": {},
+ "source": [
+ "For the approach curves, resample each approach curve to adjust its length align with the shortest approach curve ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "47f795e6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Calculate the length of each curve\n",
+ "approach_curve_lengths = [curve.shape[0] for curve in approach_curves]\n",
+ "retract_curve_lengths = [curve.shape[0] for curve in retract_curves]\n",
+ "\n",
+ "# Calculate the minimum length of approach curves and retraction curves\n",
+ "min_approach_curve_length = min(approach_curve_lengths)\n",
+ "min_retract_curve_length = min(retract_curve_lengths)\n",
+ "\n",
+ "resampled_approach_curves = []\n",
+ "resampled_contactpoints = []\n",
+ "for approach_curve, contactpoint in zip(approach_curves, contactpoints):\n",
+ " # Resample each approach curve to adjust its length to the shortest one\n",
+ " steps = np.round(\n",
+ " np.linspace(0, approach_curve.shape[0] - 1, min_approach_curve_length)\n",
+ " ).astype(int)\n",
+ " resampled_approach_curve = approach_curve[steps][:, 1]\n",
+ " resampled_approach_curves.append(resampled_approach_curve)\n",
+ "\n",
+ " # Determine the contact point for the resampled approach curve\n",
+ " resampled_approach_position = approach_curve[steps][:, 0]\n",
+ " resampled_contactpoint = (\n",
+ " np.abs(resampled_approach_position - contactpoint).argmin()\n",
+ " )\n",
+ " resampled_contactpoints.append(resampled_contactpoint)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1be32414-de9f-466f-a243-f3793ba930cd",
+ "metadata": {},
+ "source": [
+ "... and normalize each approach curve betweeen 0 and 1."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "4897dff1-07cb-4b95-94dd-a66f43f4257f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Normalize each approach curve according to its max and min values\n",
+ "norm_approach_curves = []\n",
+ "\n",
+ "for resampled_approach_curve in resampled_approach_curves:\n",
+ " norm_approach_curves.append(\n",
+ " (resampled_approach_curve - resampled_approach_curve.min())\n",
+ " / (resampled_approach_curve.max() - resampled_approach_curve.min())\n",
+ " )\n",
+ "\n",
+ "# Normalize each contact point according to min approach length\n",
+ "norm_contact_points = []\n",
+ "\n",
+ "for resampled_contactpoint in resampled_contactpoints:\n",
+ " norm_contact_points.append(\n",
+ " resampled_contactpoint / min_approach_curve_length\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cdf62f8-cefd-484d-bbff-426b39cbc111",
+ "metadata": {},
+ "source": [
+ "### 2.2. Define the Dataloader"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "26ef0212-7711-4256-9d17-ca92c5651323",
+ "metadata": {},
+ "source": [
+ "Define a custom AFM dataset ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "efe7d626-8e0e-44b7-8224-ea950b84cc49",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "\n",
+ "\n",
+ "class AFMDataset(torch.utils.data.Dataset):\n",
+ " \"\"\"Dataset for AFM Force Spectroscopy.\n",
+ "\n",
+ " This dataset is designed for handling Atomic Force Microscopy (AFM)\n",
+ " force spectroscopy curves along with their corresponding contact points.\n",
+ " Each sample consists of a force curve and an associated condition value\n",
+ " (contact point), which can be used in conditional models such as CVAE.\n",
+ "\n",
+ " The dataset returns the input curve, target curve (same as input for\n",
+ " reconstruction tasks), and the contact point.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " curves: array-like\n",
+ " Collection of AFM curves. Shape: (num_samples, curve_length).\n",
+ " contactpoints: array-like\n",
+ " Corresponding contact points for each curve. Shape: (num_samples, ...).\n",
+ "\n",
+ " Attributes\n",
+ " ----------\n",
+ " curves: np.ndarray\n",
+ " Stored AFM curves.\n",
+ " contactpoints: np.ndarray\n",
+ " Stored contact point values.\n",
+ "\n",
+ " Input\n",
+ " -----\n",
+ " idx: int\n",
+ " Index of the sample to retrieve.\n",
+ "\n",
+ " Output\n",
+ " ------\n",
+ " list\n",
+ " [curve, target, condition], where:\n",
+ " - curve : torch.Tensor\n",
+ " Input curve.\n",
+ " - target : torch.Tensor\n",
+ " Target curve (same as input).\n",
+ " - condition : torch.Tensor\n",
+ " Contact point (conditioning variable).\n",
+ "\n",
+ " Examples\n",
+ " --------\n",
+ " >>> curves, contactpoints = torch.randn(10, 100), torch.rand(10, )\n",
+ " >>> dataset = AFMDataset(curves, contactpoints)\n",
+ " >>> curve, target, c = dataset[0]\n",
+ " >>> curve.shape, target.shape, c.shape\n",
+ " (torch.Size([100]), torch.Size([100]), torch.Size([]))\n",
+ " >>> len(dataset)\n",
+ " 10\n",
+ "\n",
+ " \"\"\"\n",
+ "\n",
+ " def __init__(self, curves, contactpoints):\n",
+ " \"\"\"Initialize the AFM dataset.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " curves: array-like\n",
+ " Collection of AFM curves.\n",
+ " contactpoints: array-like\n",
+ " Corresponding contact points.\n",
+ "\n",
+ " \"\"\"\n",
+ "\n",
+ " self.curves = np.array(curves)\n",
+ " self.contactpoints = np.array(contactpoints)\n",
+ "\n",
+ " def __len__(self):\n",
+ " \"\"\"Returns the total number of samples in the dataset.\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " int\n",
+ " Number of curves in the dataset.\n",
+ "\n",
+ " \"\"\"\n",
+ "\n",
+ " return self.curves.shape[0]\n",
+ "\n",
+ " def __getitem__(self, idx):\n",
+ " \"\"\"Retrieves a single sample from the dataset.\n",
+ "\n",
+ " This method returns the curve, its corresponding target (same as\n",
+ " the input curve for reconstruction tasks), and the associated\n",
+ " contact point.\n",
+ "\n",
+ " Parameters\n",
+ " ----------\n",
+ " idx: int\n",
+ " Index of the sample.\n",
+ "\n",
+ " Returns\n",
+ " -------\n",
+ " list\n",
+ " [curve, target, condition], where each element is a torch.Tensor.\n",
+ "\n",
+ " \"\"\"\n",
+ "\n",
+ " curve = torch.tensor(self.curves[idx]).float()\n",
+ " contactpoint = torch.tensor(self.contactpoints[idx]).float()\n",
+ " return [curve, curve, contactpoint]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "588dd135-04c2-4b7a-b644-fff44a312f33",
+ "metadata": {},
+ "source": [
+ "... and use it to create the train and test data loaders."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "c3fc6142-8d6a-41f0-a60d-55f2d7e688f9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import deeplay as dl\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "\n",
+ "# Extract the good curves after normalization\n",
+ "(\n",
+ " good_norm_approach_curves,\n",
+ " good_norm_contact_points,\n",
+ ") = label_separate(\n",
+ " labels,\n",
+ " 1,\n",
+ " norm_approach_curves,\n",
+ " norm_contact_points,\n",
+ ")\n",
+ "\n",
+ "# Extract the bad curves after normalization\n",
+ "(\n",
+ " bad_norm_approach_curves,\n",
+ " bad_norm_contact_points,\n",
+ ") = label_separate(\n",
+ " labels,\n",
+ " 0,\n",
+ " norm_approach_curves,\n",
+ " norm_contact_points,\n",
+ ")\n",
+ "\n",
+ "\n",
+ "# Randomly select the train and test data\n",
+ "(\n",
+ " curves_train,\n",
+ " curves_test,\n",
+ " contactpoints_train,\n",
+ " contactpoints_test,\n",
+ ") = train_test_split(\n",
+ " good_norm_approach_curves,\n",
+ " good_norm_contact_points,\n",
+ " test_size=0.2,\n",
+ " random_state=577,\n",
+ ")\n",
+ "\n",
+ "# Instantiate the dataloader for train data\n",
+ "train_dataloader = dl.DataLoader(\n",
+ " AFMDataset(curves=curves_train, contactpoints=contactpoints_train),\n",
+ " batch_size=len(curves_train),\n",
+ ")\n",
+ "\n",
+ "# Instantiate the dataloader for test data\n",
+ "test_dataloader = dl.DataLoader(\n",
+ " AFMDataset(curves=curves_test, contactpoints=contactpoints_test),\n",
+ " batch_size=len(curves_test),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4264b351-c330-42ae-a7ad-8111554b1620",
+ "metadata": {},
+ "source": [
+ "### 2.3. Define the Autoencoder"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd969b92",
+ "metadata": {},
+ "source": [
+ "Import the conditional variational autoencoder module and instantiate a conditional autoencoder (cAE) with dense layers by setting the beta value to 0 to ignore the KL divergence terms ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "f8d791df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ConditionalVariationalAutoEncoder(\n",
+ " (encoder): MultiLayerPerceptron(\n",
+ " (blocks): LayerList(\n",
+ " (0): LinearBlock(\n",
+ " (layer): Linear(in_features=1558, out_features=512, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (1): LinearBlock(\n",
+ " (layer): Linear(in_features=512, out_features=256, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (2): LinearBlock(\n",
+ " (layer): Linear(in_features=256, out_features=128, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (3): LinearBlock(\n",
+ " (layer): Linear(in_features=128, out_features=64, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (4): LinearBlock(\n",
+ " (layer): Linear(in_features=64, out_features=64, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (fc_mu): Linear(in_features=64, out_features=2, bias=True)\n",
+ " (fc_var): Linear(in_features=64, out_features=2, bias=True)\n",
+ " (fc_dec): Linear(in_features=3, out_features=64, bias=True)\n",
+ " (decoder): MultiLayerPerceptron(\n",
+ " (blocks): LayerList(\n",
+ " (0): LinearBlock(\n",
+ " (layer): Linear(in_features=64, out_features=64, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (1): LinearBlock(\n",
+ " (layer): Linear(in_features=64, out_features=128, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (2): LinearBlock(\n",
+ " (layer): Linear(in_features=128, out_features=256, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (3): LinearBlock(\n",
+ " (layer): Linear(in_features=256, out_features=512, bias=True)\n",
+ " (activation): Tanh()\n",
+ " )\n",
+ " (4): LinearBlock(\n",
+ " (layer): Linear(in_features=512, out_features=1557, bias=True)\n",
+ " (activation): Sigmoid()\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (reconstruction_loss): MSELoss()\n",
+ " (train_metrics): MetricCollection,\n",
+ " prefix=train\n",
+ " )\n",
+ " (val_metrics): MetricCollection,\n",
+ " prefix=val\n",
+ " )\n",
+ " (test_metrics): MetricCollection,\n",
+ " prefix=test\n",
+ " )\n",
+ " (optimizer): Adam[Adam](lr=0.0001)\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "from cvae import ConditionalVariationalAutoEncoder\n",
+ "\n",
+ "# Instantiate the cAE model according to the data properties\n",
+ "cae = ConditionalVariationalAutoEncoder(\n",
+ " input_size=min_approach_curve_length,\n",
+ " condition_dim=1,\n",
+ " channels=[512, 256, 128, 64],\n",
+ " reconstruction_loss=torch.nn.MSELoss(reduction=\"sum\"),\n",
+ " beta=0, # Set to 0 to transfer cVAE to cAE\n",
+ " latent_dim=2,\n",
+ ")\n",
+ "\n",
+ "# Configure the activated function\n",
+ "cae.encoder.blocks[:].activated(torch.nn.Tanh)\n",
+ "cae.decoder.blocks[:4].activated(torch.nn.Tanh)\n",
+ "cae.decoder.blocks[4].activated(torch.nn.Sigmoid)\n",
+ "\n",
+ "# Create the cAE application\n",
+ "cae = cae.create()\n",
+ "\n",
+ "print(cae)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20550671-1117-4315-b33a-d32e540e20d5",
+ "metadata": {},
+ "source": [
+ "### 2.4. Train the Autoencoder"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "75c3f5b8-cb6c-4d79-8e7a-9ccd266acc34",
+ "metadata": {},
+ "source": [
+ "Instance a trainer with a callback to monitor the validation loss and save the best model ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "c11ec507-1683-4a91-beb2-138a03377a6c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "GPU available: True (mps), used: True\n",
+ "TPU available: False, using: 0 TPU cores\n",
+ "💡 Tip: For seamless cloud logging and experiment tracking, try installing [litlogger](https://pypi.org/project/litlogger/) to enable LitLogger, which logs metrics and artifacts automatically to the Lightning Experiments platform.\n"
+ ]
+ }
+ ],
+ "source": [
+ "from lightning.pytorch.callbacks import ModelCheckpoint\n",
+ "from pytorch_lightning.loggers import CSVLogger\n",
+ "\n",
+ "# Save the top-1 model according to the validation loss\n",
+ "checkpoint_callback = ModelCheckpoint(\n",
+ " monitor=\"val_total_loss\",\n",
+ " mode=\"min\",\n",
+ " save_top_k=1,\n",
+ ")\n",
+ "\n",
+ "# Set the logger\n",
+ "csv_logger = CSVLogger(\"logs\")\n",
+ "\n",
+ "# Instantiate the trainer\n",
+ "vae_trainer = dl.Trainer(\n",
+ " max_epochs=10_000,\n",
+ " accelerator=\"auto\",\n",
+ " callbacks=[checkpoint_callback],\n",
+ " logger=csv_logger,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ee0ff57f-0f63-4a32-903a-05c3d09575b7",
+ "metadata": {},
+ "source": [
+ "... train the cAE ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5b4e405d-b4df-4aa9-8ce1-5bb6a6ab8b94",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "vae_trainer.fit(cae, train_dataloader, test_dataloader)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4e2873af-aae9-4893-b00b-28e2ac5d798b",
+ "metadata": {},
+ "source": [
+ "... and load the best model from the callback function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8cbb1ef9-5f05-4c0e-b1ea-17a7ee65298e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(f\"The best model is saved at {checkpoint_callback.best_model_path}\")\n",
+ "\n",
+ "best_cae = ConditionalVariationalAutoEncoder.load_from_checkpoint(\n",
+ " checkpoint_callback.best_model_path\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4bd27db2-cb4b-4cca-a511-0665e8e5a94d",
+ "metadata": {},
+ "source": [
+ "You can also load a pretrained model by uncommenting the code below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "f77d6742-1965-49d2-880a-71cf35e6b9c4",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loading the model at /Users/iluvatar/Desktop/Bruker_QC/personalrepo/ASAP/tutorials/quality-control/models/epoch=5753-step=5754.ckpt\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Uncomment if you want to load a pretrained model\n",
+ "\n",
+ "#pretraiend_model_path = Path.cwd() / \"models\" / \"epoch=5753-step=5754.ckpt\"\n",
+ "\n",
+ "#print(f\"Loading the model at {pretraiend_model_path}\")\n",
+ "\n",
+ "#cae.load_state_dict(\n",
+ "# torch.load(pretraiend_model_path, map_location=\"cpu\")[\"state_dict\"]\n",
+ "#)\n",
+ "#best_cae = cae"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e06fc9c9-beab-4145-838e-b0ce1e1a8ddd",
+ "metadata": {},
+ "source": [
+ "### 2.5. Evaluate the Trained AE"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1ff1c8b8-57a3-4268-bcd1-0a8dbcaf3ffb",
+ "metadata": {},
+ "source": [
+ "Evaluate the trained cAE using both the train dataset ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "8f44e391-85b2-45b7-82cd-68a984176903",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b089efd0d0f84709a4eb199eda514a24",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Testing: | …"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃ Test metric ┃ DataLoader 0 ┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│ test_KL_epoch │ 10899.814453125 │\n",
+ "│ test_rec_loss_epoch │ 575.435791015625 │\n",
+ "│ test_total_loss_epoch │ 575.435791015625 │\n",
+ "└───────────────────────────┴───────────────────────────┘\n",
+ "
\n"
+ ],
+ "text/plain": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test_KL_epoch \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 10899.814453125 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test_rec_loss_epoch \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 575.435791015625 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test_total_loss_epoch \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 575.435791015625 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "└───────────────────────────┴───────────────────────────┘\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Evaluate performance of trained VAE on train dataset\n",
+ "\n",
+ "_ = vae_trainer.test(best_cae, train_dataloader)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "afe57e06",
+ "metadata": {},
+ "source": [
+ "... and on the test dataset."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "7ea0ece5-70f1-4a4f-b4fa-7543c2dfd2c8",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "3f095d4149414bd0bc64db26bf348abd",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Testing: | …"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃ Test metric ┃ DataLoader 0 ┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│ test_KL_epoch │ 2784.658203125 │\n",
+ "│ test_rec_loss_epoch │ 147.9930419921875 │\n",
+ "│ test_total_loss_epoch │ 147.9930419921875 │\n",
+ "└───────────────────────────┴───────────────────────────┘\n",
+ "
\n"
+ ],
+ "text/plain": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test_KL_epoch \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 2784.658203125 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test_rec_loss_epoch \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 147.9930419921875 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test_total_loss_epoch \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m 147.9930419921875 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "└───────────────────────────┴───────────────────────────┘\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Evaluate performance of trained VAE on test dataset\n",
+ "\n",
+ "_ = vae_trainer.test(best_cae, test_dataloader)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "da654f88",
+ "metadata": {},
+ "source": [
+ "### 2.6. Reconstruct and Denoise the Approach Curves"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "01a5c2d8-45ed-4a56-930e-88415a355105",
+ "metadata": {},
+ "source": [
+ "The trained cVE can used to reconstruct and denoise the approach curves."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "974c3c17-57a1-4dc8-b18b-a5e4332cbbf9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABKQAAAEhCAYAAABBZngcAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuEVJREFUeJzs3Xd4U3XbwPHvSdqmu4XSyWrZe29kK0NEUVQUFFDEh8ctisqDIODAyauIIIiAiAsVUYYsRTayZ5kdlEI3pXsm5/0jbaC0haa0PU17f64rFydn3inN3Zw7v6GoqqoihBBCCCGEEEIIIUQF0WkdgBBCCCGEEEIIIYSoXqQgJYQQQgghhBBCCCEqlBSkhBBCCCGEEEIIIUSFkoKUEEIIIYQQQgghhKhQUpASQgghhBBCCCGEEBVKClJCCCGEEEIIIYQQokJJQUoIIYQQQgghhBBCVCgpSAkhhBBCCCGEEEKICiUFKSGEEEIIIYQQQghRoaQgJUrk2LFjjB8/noYNG+Lk5ISTkxONGzfmP//5DwcOHNAkpmXLlqEoCuHh4SXaf8eOHTz88MPUrl0bBwcHPDw86NGjBwsWLCAtLa18gxVClAnJRUKIyig/D1z/8Pb2pm/fvqxdu7bMrxcYGMi4ceNKtG9ycjLvvvsunTp1wt3dHYPBQGBgIE8++SSHDh0q89iEENqRXCRsjZ3WAYjKb+HChTz33HM0bdqUF198kZYtW6IoCqdOneKHH36gc+fOnD9/noYNG2odarHeeustZs2aRY8ePXj77bdp2LAh6enp7N69mxkzZnD27Fn+7//+T+swhRA3IblICFHZLV26lGbNmqGqKtHR0cybN49hw4bxxx9/MGzYsAqPJyQkhIEDBxIbG8vEiROZOXMmrq6uhIeHs3LlSjp27MjVq1fx8PCo8NiEEOVHcpGwGaoQN7Fz505Vp9Opw4YNU7OysorcZ+XKleqlS5cqODJVXbp0qQqoYWFhN91v5cqVKqCOHz9eNZlMhbYnJyerGzduLJOY0tLSyuQ8QoiCJBdZR3KREBUrPw/s37+/wPr09HTVYDCojz76aJler379+urYsWNvuk9ubq7aunVr1d3dXT1+/HiR+6xfv75M8oXJZFLT09Nv+zxCiNsjuUhyka2RLnvipt577z30ej0LFy7EwcGhyH0eeughAgICCqz7448/6N69O87Ozri5uXHXXXexZ8+eQsfu3LmTAQMG4ObmhrOzMz169GDdunWF9tu7dy89e/bE0dGRgIAApkyZQk5OTolew6xZs6hRowZz585FUZRC293c3Bg4cCAA4eHhKIrCsmXLCu2nKAozZsywPJ8xYwaKonDo0CEefPBBatSoQcOGDfn0009RFIXz588XOsfrr7+Og4MD8fHxlnVbtmxhwIABuLu74+zsTM+ePfnrr79K9NqEqC4kF10juUgI2+Ho6IiDgwP29vYF1s+cOZOuXbtSs2ZN3N3d6dChA19//TWqqhbYLycnh9deew0/Pz+cnZ2544472LdvX4muvXr1ao4fP86UKVNo1apVkfsMGTIEZ2dnAMaNG0dgYGChffJzzPUUReG5557jyy+/pHnz5hgMBhYvXoyPjw+PP/54oXNcvXoVJycnJk2aZFmXnJzMq6++SlBQEA4ODtSuXZuXXnpJui4LUQ4kF5lJLqp8pCAlimU0Gtm6dSudOnXC39+/xMd9//333Hfffbi7u/PDDz/w9ddfk5iYSN++fdm5c6dlv23bttG/f3+SkpL4+uuv+eGHH3Bzc2PYsGH89NNPlv2Cg4MZMGAAV69eZdmyZXz55ZccPnyYd95555axREVFceLECQYOHGhJcmXtgQceoFGjRvz88898+eWXPPbYYzg4OBS6kTQajaxYsYJhw4ZRq1YtAFasWMHAgQNxd3fnm2++YeXKldSsWZNBgwbJjaAQeSQXlYzkIiG0ZzQayc3NJScnh8jISMtNzahRowrsFx4ezn/+8x9WrlzJqlWreOCBB3j++ed5++23C+w3YcIEPv74Y8aMGcPvv//OiBEjeOCBB0hMTLxlLJs2bQJg+PDhZfb6rrd69WoWLFjA9OnT2bhxI/379+exxx7j119/JTk5ucC+P/zwA5mZmTzxxBMApKen06dPH7755hteeOEF/vzzT15//XWWLVvGvffeW+hmWAhhHclFkotshrYNtERlFh0drQLqI488Umhbbm6umpOTY3nkdz8xGo1qQECA2rp1a9VoNFr2T0lJUX18fNQePXpY1nXr1k318fFRU1JSCpy3VatWap06dSznHDlypOrk5KRGR0cX2K9Zs2a37Cazd+9eFVDfeOONEr3msLAwFVCXLl1aaBugvvXWW5bnb731lgqo06dPL7TvAw88oNapU6fAz2D9+vUqoK5Zs0ZVVXOXmpo1a6rDhg0rcKzRaFTbtm2rdunSpUQxC1HVSS4qSHKREJVPfjeZGx8Gg0GdP3/+TY81Go1qTk6OOmvWLNXLy8uSc06dOqUC6ssvv1xg/++++04FbtlNZvDgwSqgZmZmlug1jB07Vq1fv36h9fk55nqA6uHhoV65cqXA+mPHjqmAumjRogLru3Tponbs2NHyfPbs2apOpyvUreiXX35RAXX9+vUlilkIUZDkIjPJRbZDWkiJUunYsSP29vaWxyeffALAmTNnuHz5Mo8//jg63bVfL1dXV0aMGMHevXtJT08nLS2Nf//9lwcffBBXV1fLfnq9nscff5zIyEjOnDkDwNatWxkwYAC+vr4F9hs5cmQFvdqbGzFiRKF1TzzxBJGRkWzZssWybunSpfj5+TFkyBAAdu/ezZUrVxg7diy5ubmWh8lkYvDgwezfv1+aigpxC5KLrpFcJIT2li9fzv79+9m/fz9//vknY8eO5dlnn2XevHkF9vv777+588478fDwQK/XY29vz/Tp00lISCA2NhYw5xyA0aNHFzj24Ycfxs5O+3mJ+vfvT40aNQqsa926NR07dmTp0qWWdadOnWLfvn08+eSTlnVr166lVatWtGvXrkDeGTRoEIqi8M8//1TUyxCiSpJcJLnIVmj/GyQqrVq1auHk5MSFCxcKbfv+++9JT08nKiqKe++917I+ISEBoMhuNQEBAZhMJhITE1FVFVVVi93v+nMlJCTg5+dXaL+i1t2oXr16AISFhd1y39Iq6jUMGTIEf39/li5dysCBA0lMTOSPP/7gxRdfRK/XAxATEwPAgw8+WOy5r1y5gouLS/kELoSNkFxUMpKLhNBe8+bN6dSpk+X54MGDuXDhAq+99hqPPfYYnp6e7Nu3j4EDB9K3b1+++uor6tSpg4ODA6tXr+bdd98lIyMDuJZ7bswxdnZ2eHl53TKW6/NOs2bNyuolWhTXhfrJJ5/k2Wef5fTp0zRr1oylS5diMBh49NFHLfvExMRw/vz5QuPZ5Lt+fDshhPUkF0kushVSkBLF0uv19O/fn02bNhEVFVXgzd6iRQvA3O/4evlJKSoqqtD5Ll++jE6no0aNGqiqik6nK3Y/wDK2iZeXF9HR0YX2K2rdjfz9/WndujWbNm0iPT39lmO3ODo6ApCVlVVgfX4iLkpRgxPnt66YO3cuV69e5fvvvycrK8vSXxmuvb7PP/+cbt26FXnu61tiCFFdSS66RnKRELanTZs2bNy4kbNnz9KlSxd+/PFH7O3tWbt2reW9DuZxUK6Xn8eio6OpXbu2ZX1ubu5Nc0G+QYMGsWjRIlavXs0bb7xxy/0dHR0L5Rwo/oasqJwD8OijjzJp0iSWLVvGu+++y7fffsvw4cMLtGDI/6JhyZIlRZ4jPy8JIcqO5CLJRZWRdNkTNzVlyhSMRiMTJ04s0UxSTZs2pXbt2nz//fcFBoFLS0vj119/tcx25eLiQteuXVm1apWl+g5gMplYsWIFderUoUmTJgD069ePv/76y/ItPpgH6rt+sOGbmTZtGomJibzwwgtFDkyXmppqGWzP19cXR0dHjh07VmCf33//vUTXut4TTzxBZmYmP/zwA8uWLaN79+4FvhXo2bMnnp6eBAcH06lTpyIfxc0mJkR1I7nITHKRELbnyJEjAHh7ewPmmyc7OztLK0WAjIwMvv322wLH9e3bF4DvvvuuwPqVK1eSm5t7y+ved999tG7dmtmzZ3PixIki99m4cSPp6ekABAYGEhsbWyDHZWdns3Hjxlte63o1atRg+PDhLF++nLVr1xIdHV2giwzAPffcQ0hICF5eXkXmnKJm2BJC3B7JRZKLKiNpISVuqmfPnnzxxRc8//zzdOjQgaeffpqWLVtaWhT8+uuvALi7uwOg0+n48MMPGT16NPfccw//+c9/yMrK4qOPPuLq1au8//77lnPPnj2bu+66i379+vHqq6/i4ODA/PnzOXHiBD/88IOl2v3mm2/yxx9/0L9/f6ZPn46zszNffPFFicc0eeihh5g2bRpvv/02p0+fZvz48TRs2JD09HT+/fdfFi5cyMiRIxk4cCCKovDYY4+xZMkSGjZsSNu2bdm3bx/ff/+91T+7Zs2a0b17d2bPns3FixdZtGhRge2urq58/vnnjB07litXrvDggw/i4+NDXFwcR48eJS4ujgULFlh9XSGqIslFkouEsAUnTpyw3KAlJCSwatUqNm/ezP33309QUBAAQ4cOZc6cOYwaNYqnn36ahIQEPv74YwwGQ4FzNW/enMcee4xPP/0Ue3t77rzzTk6cOMHHH39syXU3o9fr+e233xg4cCDdu3fnv//9L/369cPFxYULFy7wyy+/sGbNGsssWSNHjmT69Ok88sgjTJ48mczMTObOnYvRaLT65/Dkk0/y008/8dxzz1GnTh3uvPPOAttfeuklfv31V3r37s3LL79MmzZtMJlMREREsGnTJl555RW6du1q9XWFEGaSi8wkF9kArUZTF7blyJEj6hNPPKEGBQWpBoNBdXR0VBs1aqSOGTNG/euvvwrtv3r1arVr166qo6Oj6uLiog4YMEDdtWtXof127Nih9u/fX3VxcVGdnJzUbt26WWZ+ut6uXbvUbt26qQaDQfXz81MnT56sLlq06JYzW11v27Zt6oMPPqj6+/ur9vb2qru7u9q9e3f1o48+UpOTky37JSUlqU899ZTq6+ururi4qMOGDVPDw8OLndkqLi6u2Gvmx+jk5KQmJSUVG9fQoUPVmjVrqvb29mrt2rXVoUOHqj///HOJXpcQ1YnkIslFQlRGRc1s5eHhobZr106dM2dOodmllixZojZt2lQ1GAxqgwYN1NmzZ6tff/11oVySlZWlvvLKK6qPj4/q6OioduvWTd2zZ49av379W85sle/q1avq22+/rXbo0EF1dXVV7e3t1Xr16qmPPfZYoXy4fv16tV27dqqTk5PaoEEDdd68ecXObPXss88We02j0ajWrVtXBdSpU6cWuU9qaqr65ptvqk2bNlUdHBxUDw8PtXXr1urLL79cYDZTIUTJSS4qSHJR5aeoahH9BoQQQgghhBBCCCGEKCcyhpQQQgghhBBCCCGEqFBSkBJCCCGEEEIIIYQQFUoKUkIIIYQQQgghhBCiQklBSgghhBBCCCGEEEJUKClICSGEEEIIIYQQQogKZad1AFowmUxcvnwZNzc3FEXROhwhRCmpqkpKSgoBAQHodLZZX5d8JITtk1wkhKgMJBcJISoDa3JRtSxIXb58mbp162odhhCijFy8eJE6depoHUapSD4SouqQXCSEqAwkFwkhKoOS5KJqWZByc3MDzD8gd3d3jaMRQpRWcnIydevWtbynbZHkIyFsn+QiIURlILlICFEZWJOLqmVBKr/5p7u7uyQ6IaoAW27SLflIiKpDcpEQojKQXCSEqAxKkotss3OxEEIIIYQQQgghhLBZUpASQgghhBBCCCGEEBVKClJCCCGEEEIIIYQQokJpXpDavn07w4YNIyAgAEVRWL169S2P2bZtGx07dsTR0ZEGDRrw5Zdfln+glYTRaCQzM1Me8qgWD6PRWGHvLclFQojKQHKREKIykFwkhKgImg9qnpaWRtu2bXniiScYMWLELfcPCwvj7rvvZsKECaxYsYJdu3bxzDPP4O3tXaLjbZWqqkRHR3P16lWtQxGiQnl6euLn51fuA3RKLhJCVAaSi4QQlYHkIiFERdC8IDVkyBCGDBlS4v2//PJL6tWrx6effgpA8+bNOXDgAB9//HG5JLuDIVFERsXQvJ4PTeoFlPn5Syq/GOXj44Ozs7NNz54hREmoqkp6ejqxsbEA+Pv7l+v1KnsuOnEpiVOXr9LI24n2gT5lfn4hROVQ2XNRaFQcp0Iu4O3hQpfWzcv8/EKIyqGy56LLVzPYfT6eGgYY0LpumZ9fCFExNC9IWWvPnj0MHDiwwLpBgwbx9ddfk5OTg729faFjsrKyyMrKsjxPTk4u8fWU35/hvuS/2d34VZqMnlb6wG+D0Wi0FKO8vLw0iUEILTg5OQEQGxuLj48Per1e44iuKU0ugtLno5T10xkR+Q17fEfBM/NLH7gQokqp6FyUsO0rhp7+gAMufaH176WOWwhRtVR0Loo78Bv37XiOs/bNoPXu0gcuhNCU5mNIWSs6OhpfX98C63x9fcnNzSU+Pr7IY2bPno2Hh4flUbduyavouXYu5oWslFLHfLtycnIAcHZ21iwGIbSS/3uf/z6oLEqTi6D0+UjVOaBTVByMqbcVtxCiaqnwXGRwBcDelF76oIUQVU5F5yLF3gl7xYizmnZbcQshtGVzBSmgUHc1VVWLXJ9vypQpJCUlWR4XL14s8bWM9uYPXrps7W8CpZueqI4q8++9tbkISp+PcuzdAHDI1T4XCSEql4rMRYqD+Yu6zLSStzYXQlQPFZqLDO4AOElxXAibZnNd9vz8/IiOji6wLjY2Fjs7u2K7sxkMBgwGQ6mupzqYbwJ1OXITKIS4pjS5CEqfj3LziuMGaSElhLhOReei2CxztxsXMknLysXFYHMfJYUQ5aCic5HOyXyP5qxKQUoIW2ZzLaS6d+/O5s2bC6zbtGkTnTp1KrZv8u3IL0jZ5UhzUCHENRWdi3LzWkjpc7TrPiyEqHwqOhelqo4AOJPJlbTsMj+/EMI2VXQuUhzNLaScSYe8llhCCNujeUEqNTWVI0eOcOTIEcA8ZeiRI0eIiIgAzM04x4wZY9l/4sSJXLhwgUmTJnHq1CmWLFnC119/zauvvlou8SmO5ptAe+kmI0SVVtlzUWiyOV2rGUnlcn4hROVQ2XNR/zZBALgqmWTmGMvlGkII7VX2XKRz8gDADhOmbGklJYSt0rwgdeDAAdq3b0/79u0BmDRpEu3bt2f69OkAREVFWRIfQFBQEOvXr+eff/6hXbt2vP3228ydO7dcphMFUJ1qAOCSm1gu56/Kxo0bh6IoKIqCnZ0d9erV47///S+JiRX7s+zbt68lDoPBQO3atRk2bBirVq2y+lwzZsygXbt2ZR+k0Fxlz0V/R5tnHAxUoiEno1yuIYTQXmXPRd55XW9cySBDClJCVFmVPRc5O7uTrpq7+r25fGO5XEMIUf407/jft29fy4B3RVm2bFmhdX369OHQoUPlGNU1Rvf6ANTKib7FnqIogwcPZunSpeTm5hIcHMyTTz7J1atX+eGHHyo0jgkTJjBr1ixycnK4dOkSv/32G4888gjjxo1j0aJFFRqLqJwqey5KcPAnLssDbyUJLh+G+j0q5LpCiIpV2XMRzrXM/yhZZKenAJ4Vc10hRIWq7LmoXi0Xjqq1aauEkhB2FHigQq4rhChbmreQqvRq1APAXU2CrMrTbU9VVdKzcyv8cbM/TEUxGAz4+flRp04dBg4cyMiRI9m0aZNlu9FoZPz48QQFBeHk5ETTpk357LPPLNuPHz+OTqezTBebmJiITqfjoYcesuwze/ZsunfvftM4nJ2d8fPzo27dunTr1o0PPviAhQsX8tVXX7FlyxbLfq+//jpNmjTB2dmZBg0aMG3aNHJycgDzH96ZM2dy9OhRS4ur/D/Gc+bMoXXr1ri4uFC3bl2eeeYZUlMrz++LsH0Odnr2m5oCoEbs1TgaIUS15ehOOuYWm6bkyxoHI4Sozs6pdQBookRqHIkQorQ0byFV2Tm4eJKsOuGuZEBKFBgaax0SABk5RlpMr/jmqcGzBuHsULpfm9DQUDZs2FBgYEOTyUSdOnVYuXIltWrVYvfu3Tz99NP4+/vz8MMP06pVK7y8vNi2bRsjRoxg+/bteHl5sX37dss5/vnnH/r06WN1PGPHjuWVV15h1apV3HnnnQC4ubmxbNkyAgICOH78OBMmTMDNzY3XXnuNkSNHcuLECTZs2GApYnl4mPuv63Q65s6dS2BgIGFhYTzzzDO89tprzJ8/v1Q/KyFu5OPuyMG4Jtyt34d6cT/FT6AshBDl64reC2djJEkxF4CuWocjhKimPOq3gcjtNNdF3HpnIUSlJC2kbqGmiwPRak0A0uMvaByN7Vm7di2urq44OTnRsGFDgoODef311y3b7e3tmTlzJp07dyYoKIjRo0czbtw4Vq5cCYCiKPTu3Zt//vkHMBefxo4di8lkIjg4mNzcXHbv3k3fvn2tjk2n09GkSRPCw8Mt695880169OhBYGAgw4YN45VXXrHE4uTkhKurK3Z2dvj5+eHn54eTk/lb4pdeeol+/foRFBRE//79efvtty3HCVEWpt/TgjNqXQBiw09qHI0QojqLyDbPbrV212GNIxFCVGcxbi0B6KA7JzPtCWGjpIXULTT2cWWbWosmXCI5KgTnZndqHRIATvZ6gmcN0uS61ujXrx8LFiwgPT2dxYsXc/bsWZ5//vkC+3z55ZcsXryYCxcukJGRQXZ2doGBw/v27WsZ52nbtm28/fbbhIWFsW3bNpKSksjIyKBnz56lej2qqqIo19qa/PLLL3z66aecP3+e1NRUcnNzcXd3v+V5tm7dynvvvUdwcDDJycnk5uaSmZlJWloaLi4upYpNiOsFeDoSrvoCUCPrEjk5OeUyjbIQQtxKbN64UT7KVU3jEEJUb71634UxWMFPSYTUGHDz0zokIYSVpIXULSiKQqx9AAD6q2EaR3ONoig4O9hV+OP64k1JuLi40KhRI9q0acPcuXPJyspi5syZlu0rV67k5Zdf5sknn2TTpk0cOXKEJ554guzsbMs+ffv25eTJk5w/f54TJ07Qq1cv+vTpw7Zt2/jnn3/o2LEjbm5uVv8MjUYj586dIyjIPIX13r17eeSRRxgyZAhr167l8OHDTJ06tUAsRblw4QJ33303rVq14tdff+XgwYN88cUXAJbxp4S4XXqdwmW1FlmqHQYll+837dI6JCFENRWrmmcgloKUEEJL7u4eRKreAOTGndM4GiFEaUhBqgQSdOYpjvXp8RpHYvveeustPv74Yy5fNg+EumPHDnr06MEzzzxD+/btadSoESEhIQWOyR9H6p133qFt27a4u7sXKEiVZvwogG+++YbExETLdLS7du2ifv36TJ06lU6dOtG4cWMuXCjYTdPBwQGjseA01wcOHCA3N5dPPvmEbt260aRJE8vrE6Ks2Ol0mNBxNm8Az8hgGdhcCKGNGNUTAF8lUdtAhBDVmqO9nnDV3Coq/MwxjaMRQpSGFKRKIF0xd7lSslM0jsT29e3bl5YtW/Lee+8B0KhRIw4cOMDGjRs5e/Ys06ZNY//+/QWOyR9HasWKFZaxotq0aUN2djZ//fVXicaPSk9PJzo6msjISP79919ef/11Jk6cyH//+1/69etniSUiIoIff/yRkJAQ5s6dy2+//VbgPPmDlh85coT4+HiysrJo2LAhubm5fP7554SGhvLtt9/y5Zdf3v4PS4jr6PIaJx43NQCgiVG+CRRCaCNOWkgJISoBR3sdoao/AE7JIbfYWwhRGUlBqgTS9ObuYA4pMqVoWZg0aRJfffUVFy9eZOLEiTzwwAOMHDmSrl27kpCQwDPPPFPomH79+mE0Gi3FJ0VR6NWrFwB33HHHLa/51Vdf4e/vT8OGDbn//vsJDg7mp59+KjAL3n333cfLL7/Mc889R7t27di9ezfTpk0rcJ4RI0YwePBg+vXrh7e3Nz/88APt2rVjzpw5fPDBB7Rq1YrvvvuO2bNn38ZPSIjC8rvLHlPNBamA9NNahiOEqMbyx5Dy5qqmcQghqjdFUSwTvmReOqFxNEKI0lBUtfpNSZCcnIyHhwdJSUklGrB6wJRF/GWYTI6dK/ZvXqqACAvKzMwkLCyMoKAgHB0dK/z6QmjpZr//1r6XKyNrXkPgG+toqYSxzjCVJNUZjxmXwcpx3YQQZa+65aJ+Uxaz1fAKqaojEf85R4sA23zNQlQ11S0XAdw/5VN+M7xFjOqJ91vh6HTyuUgIrVnzPpYWUiUQrdYEwD43FbJSNY5GCFGdnVXrkqXa4aGkkxUnzdOFEBUvNm8MKVclkwfnbtY2GCFEtXZGrYtJVfBVrpIQe1HrcIQQVpKCVAmk4USK6mR+khqjbTBCiGrrs0fakYMdp9R6AMSd/VfjiIQQ1VEaTqSpBgB8ZGBzIYSG0nEkLG9gc338GY2jEUJYSwpSJZT/bSDJMnuaEEIb97WrDVwb2NwUeUjLcIQQ1VhM3sDmvlwlJE5ajwshtNEywJ0Lqq/5yZUwbYMRQlhNClIl8P1TXS0fvExSkBJCaCx/YHOijmgahxCi+orLG9jcR0lk9eGKH19TCCEA9DqFCNUHAF3cSY2jEUJYSwpSJVDT1YFozONI/fXvEW2DEUJUe/ktpDyvnoTqNy+FEEJjgV7OlpbjPspVMrKN2gYkhKi2UrNyOZs3054h6oDG0QghrCUFqRJwc7S3tJCKjJBBhIUQ2gpRA8hR9bgrGUyYt1rrcIQQ1YydXmf5XOSjJBJYy0XjiIQQ1ZW3q4E9phYAGBLPgUkK5ELYEilIlYCXiwNReTPt+SlXNI5GCFGd+bobyMGOUNUfgJyoYK6kZWsclRCiOlGgQAspk7TUFEJo5MMH23BB9SVLtUdnzIKrF7QOSQhhhVIVpE6fPs2jjz6Kv78/Dg4OHDpkHlh35syZbN26tUwDrAwc7fXE5BWk/KUgJYTQ0HdPdcXHzcCZvObpLZVw0rJyNY5KCFGd1HBxIDa/hRRXeXttsMYRCSGqq/peLpjQEaIGmFfEntY2ICGEVawuSB05coTOnTuzbds2+vbti9F4rVlkamoqX375ZZkGWFnkt5DylemNhRAaauTjxr6pd3I0bxyptroQ5mw+q3FUQojq5MMRbXDzrgOYPxflGKWFlBBCW2dV80zExElBSghbYnVB6o033qBNmzacP3+eb7/9FvW6ZtpdunRh//79ZRpgZeHuUw8Ab+UqGKU1gqhYiqKwevVqrcMQlcgxU0MAWunC+E1muBJCVKDAWi68/didgLnLnhBCaO2syVwkz42RFptC2BKrC1K7du3itddew9nZGUVRCmzz9fUlOjq6zIKrTPxr1yNX1WGHCdJitQ7HJowbNw5FUVAUBTs7O+rVq8d///tfEhNtp5VZeHg4iqJw5MiRCrnejBkzaNeuXaH1UVFRDBkypFyvvWzZMsv/l16vp0aNGnTt2pVZs2aRlJRk1bkq+udWHZ1SzUXyAOUKNUjWOBohRLXj6guAu5KOI1kaByOEqM76NfXmfF4LqeSI4xpHI4SwhtUFKVVVcXBwKHJbYmIiBoPhtoOqjLo29CEWT/OT5ChNY7ElgwcPJioqivDwcBYvXsyaNWt45plntA6rzGVnl++g0n5+fhXy3nJ3dycqKorIyEh2797N008/zfLly2nXrh2XL18u9+uLkru7UxPCTeYbwua6CI2jEUJUO44eZKr2gLmVVHJmjsYBCSGqqzHdAzmrmltIuaWGgcmkcURCiJKyuiDVpk0bfvvttyK3bdiwgY4dO952UJVR16CaROeNI0VypLbBAKgqZKdV/MPKmXQMBgN+fn7UqVOHgQMHMnLkSDZt2lRgn6VLl9K8eXMcHR1p1qwZ8+fPL7A9MjKSRx55hJo1a+Li4kKnTp34999/LdsXLFhAw4YNcXBwoGnTpnz77bcFjlcUhcWLF3P//ffj7OxM48aN+eOPPyzbExMTGT16NN7e3jg5OdG4cWOWLl0KQFBQEADt27dHURT69u0LmFt/DR8+nNmzZxMQEECTJk0s17qxa52npyfLli275etZtmwZM2fO5OjRo5aWSvnH3Xje48eP079/f5ycnPDy8uLpp58mNTXVsj0/vo8//hh/f3+8vLx49tlnycm5+Q2Doij4+fnh7+9P8+bNGT9+PLt37yY1NZXXXnvNst+GDRu444478PT0xMvLi3vuuYeQkBDL9uJ+bvv37+euu+6iVq1aeHh40KdPH8ukCMI6M+9txUm1PmAe2FwIISqUopBu8AbAh0Q+3CDjtgghtOFgp+Oi6kOWaoe9KQuS5Is6IWyFnbUHvPjii4waNQoXFxcef/xxACIiIvj7779ZsmQJv/zyS5kHWRm4Guw4otaiA+cxJkag1zqgnHR4L6Dir/u/y+DgUqpDQ0ND2bBhA/b29pZ1X331FW+99Rbz5s2jffv2HD58mAkTJuDi4sLYsWNJTU2lT58+1K5dmz/++AM/Pz8OHTqEKe+bj99++40XX3yRTz/9lDvvvJO1a9fyxBNPUKdOHfr162e5zsyZM/nwww/56KOP+Pzzzxk9ejQXLlygZs2aTJs2jeDgYP78809q1arF+fPnycjIAGDfvn106dKFLVu20LJlywKtA//66y/c3d3ZvHlzgbHUbuZmr2fkyJGcOHGCDRs2sGXLFgA8PDwKnSM9PZ3BgwfTrVs39u/fT2xsLE899RTPPfdcgcLX1q1b8ff3Z+vWrZw/f56RI0fSrl07JkyYUPL/NMDHx4fRo0ezZMkSjEYjer2etLQ0Jk2aROvWrUlLS2P69Oncf//9HDlyBJ1OV+zPLSUlhbFjxzJ37lwAPvnkE+6++27OnTuHm5ubVXFVd04OeoJNgQzV76OF7gK5RhN2+lJNnCqEEKWiuPlBwmV8lavsD7Od7vhCiKrFwU6HET2hqj/NlYsQdxZqBGodlhCiBKwuSI0cOZKQkBBmzJhhuakcMWIEdnZ2zJw5k2HDhpV5kJWBs0FPpGr+JvD0qRO07KlxQDZi7dq1uLq6YjQayczMBGDOnDmW7W+//TaffPIJDzzwAGBuWRMcHMzChQsZO3Ys33//PXFxcezfv5+aNc0t1Bo1amQ5/uOPP2bcuHGWboCTJk1i7969fPzxxwUKUuPGjePRRx8F4L333uPzzz9n3759DB48mIiICNq3b0+nTp0ACAwMtBzn7W3+P/fy8sLPz6/Aa3NxcWHx4sXFdmEtyq1ej6urK3Z2doWudb3vvvuOjIwMli9fjouLuTg4b948hg0bxgcffICvr7kbV40aNZg3bx56vZ5mzZoxdOhQ/vrrL6sLUgDNmjUjJSWFhIQEfHx8GDFiRIHtX3/9NT4+PgQHB9OqVatif279+/cvcNzChQupUaMG27Zt45577rE6ruou+LoWUot3hjGxT0ONIxJCVCdGVz9IMM+0F6ZTbn2AEEKUA31e/glRa9OcixB7EpoM1DgqIURJWF2QAvjf//7HmDFj2LhxIzExMdSqVYtBgwZRv379so6v0jDY6bmk1gLg8oVztNQ4Huydza2VtLiuFfr168eCBQtIT09n8eLFnD17lueffx6AuLg4Ll68yPjx4wsUSXJzcy0tg44cOUL79u0txZsbnTp1iqeffrrAup49e/LZZ58VWNemTRvLsouLC25ubsTGmgen/+9//8uIESM4dOgQAwcOZPjw4fTo0eOWr61169ZWFaNK8npK4tSpU7Rt29ZSjALzazaZTJw5c8ZSkGrZsiV6/bW2fP7+/hw/XrqBHvNbgOVPZBASEsK0adPYu3cv8fHxlhZrERERtGrVqtjzxMbGMn36dP7++29iYmIwGo2kp6cTESFNq0vjhMncNbKRcpn/HTkvBSkhRIVy8qoLF8BXuUItt6o5hqgQovKr7ekEwAXVx7zizJ9wx8saRiSEKKlSFaQA6tSpw/jx48sylkovv4VUHSVO40gARSl117mK5OLiYmkBNHfuXPr168fMmTN5++23LUWMr776iq5duxY4Lr+Q4uTkdMtr3Djbo6qqhdZd300w/5j86w8ZMoQLFy6wbt06tmzZwoABA3j22Wf5+OOPb/naiorlxu5714/bVJLXcytFvb7rr5/vZq/ZWqdOncLd3R0vLy8Ahg0bRt26dfnqq68ICAjAZDLRqlWrWw7uPm7cOOLi4vj000+pX78+BoOB7t27l/ug8FVVHJ7Eq+7UUpIxRQcTl9IXb7kpFEJUEJda5tk+/ZUrSAMpIYRWfN0duaeNP2dPmAc2J0UmoBLCVlg94MjatWuZN29ekdu++OIL1q9ff9tBVVaXVfPNuK9yReNIbNdbb73Fxx9/zOXLl/H19aV27dqEhobSqFGjAo/8QbHbtGnDkSNHuHKl6J958+bN2blzZ4F1u3fvpnnz5lbF5e3tzbhx41ixYgWffvopixYtArC0gDIajSU+T1TUtT+C586dIz093fL8Vq/HwcHhltdq0aIFR44cIS0tzbJu165d6HQ6y+DqZSk2Npbvv/+e4cOHo9PpSEhI4NSpU7z55psMGDCA5s2bk5hYcOyQ4n5uO3bs4IUXXuDuu++mZcuWGAwG4uPjyzzm6uL7p7oSbDK3TL1Xv5t+H/+jbUBCiOrF3TyWpZ9yhexcmdVKCKEdo0lluymvR8TVCMhKvfkBQohKweqC1LvvvltgNq/rpaWl8d5771kdxPz58wkKCsLR0ZGOHTuyY8eOm+7/3Xff0bZtW5ydnfH39+eJJ54gISHB6utaK0atAUBNJRVys8r9elVR3759admypeX3ZMaMGcyePZvPPvuMs2fPcvz4cZYuXWoZZ+rRRx/Fz8+P4cOHs2vXLkJDQ/n111/Zs2cPAJMnT2bZsmV8+eWXnDt3jjlz5rBq1SpeffXVEsc0ffp0fv/9d86fP8/JkydZu3atpaDl4+ODk5MTGzZsICYmhqSkpJueq3///sybN49Dhw5x4MABJk6cWKCl0q1eT2BgIGFhYRw5coT4+Hiysgr/no0ePRpHR0fGjh3LiRMn2Lp1K88//zyPP/64pbteaamqSnR0NFFRUZw6dYolS5bQo0cPPDw8eP/99wHz2FReXl4sWrSI8+fP8/fffzNp0qQC5ynu59aoUSO+/fZbTp06xb///svo0aPLpNVYWbKVfATQuo4HEXnN0xsoUaRm5VbIdYUQ5c8mclF+QQopSAlRVdlELgIiEzNIxJ041d28Iv5MuV9TCHH7rC5InT59mg4dOhS5rX379gQHB1t1vp9++omXXnqJqVOncvjwYXr16sWQIUOKHVNm586djBkzhvHjx3Py5El+/vln9u/fz1NPPWXtS7Gan48fWWpecSFZg/GbqohJkybx1VdfcfHiRZ566ikWL17MsmXLaN26NX369GHZsmWWFlIODg5s2rQJHx8f7r77blq3bs37779v6dI3fPhwPvvsMz766CNatmzJwoULWbp0KX379i1xPA4ODkyZMoU2bdrQu3dv9Ho9P/74IwB2dnbMnTuXhQsXEhAQwH333XfTc33yySfUrVuX3r17M2rUKF599VWcna+Nu3Wr1zNixAgGDx5Mv3798Pb25ocffih0DWdnZzZu3MiVK1fo3LkzDz74IAMGDCi25aI1kpOT8ff3p3bt2nTv3t0yuPzhw4fx9/cHQKfT8eOPP3Lw4EFatWrFyy+/zEcffVTgPMX93JYsWUJiYiLt27fn8ccf54UXXsDHx+e24y4rtpSPANwc7XFucy8AjXWXKuSaQojyZzO5KK8g5askkp1bspbEQgjbYTO5CDDYmW9rz5nyuu3Fni73awohyoBqJScnJ3XNmjVFbluzZo3q6Oho1fm6dOmiTpw4scC6Zs2aqW+88UaR+3/00UdqgwYNCqybO3euWqdOnWKvkZmZqSYlJVkeFy9eVAE1KSnJqliPXbyqnp/WVFXfclfVkK1WHXs7MjIy1ODgYDUjI6PCrilEZXGz3/+kpKRSvZeLY0v5KN+uk6GqcbqHqr7lrnZ4/btSnUMIcXuqbS7KyVJNb3mo6lvuavvXvy/5cUKIclFtc5GqqqO+2qPWf32tunTqg+Z7tXWvWnW8EKLsWJOLrG4h1bRpU9auXVvktrVr11o1hk12djYHDx5k4MCC03IOHDiQ3bt3F3lMjx49iIyMZP369aiqSkxMDL/88gtDhw4t9jqzZ8/Gw8PD8qhbt26JY7yenV7hgmruEnXh/MlSnUMIUTnZWj7Kl2vnSpjqB0ArXfhtnUsIoT2bykV2DuQ4msfX9FeusD9cxtgUoqqwqVwEOOjNt7UHTXn3ohF7S3UeIUTFsrog9eSTT7J48WLeeustYmJiAIiJiWHGjBksXrzYqpn34uPjMRqNhca98fX1JTo6ushjevTowXfffcfIkSNxcHDAz88PT09PPv/882KvM2XKFJKSkiyPixcvljjG69npFKLyBjbffvB4qc4hhKicbC0f5VOBo2pDALroTt3WuYQQ2rO1XJTrYu7O7atc4XRUcqnOIYSofGwtF7kYzJPHn1QDzSsSzkMpZ5cWQlQcqwtSzz33HKNGjeLtt98mICAABwcHAgICmDVrFqNHj+aFF16wOogbp7BXbzKtfXBwMC+88ALTp0/n4MGDbNiwgbCwMCZOnFjs+Q0GA+7u7gUepaHXKZaBzb2RbwGFqIpsJR9dH98hU2MAmioXUVX1ts4nhKgcbCUX5bqaW2j6K1fIkoHNhahybCUX5YtQfchBDznpkCJj/gpR2dlZe4CiKCxfvpwJEyawYcMG4uLi8Pb2ZsiQIdxxxx1WnatWrVro9fpCVfbY2NhiZwubPXs2PXv2ZPLkyQC0adMGFxcXevXqxTvvvGMZeLk82Ol0xOIJgJ+SePOdhRA2xdbyUb6gWi6Wmfba6MIImrKOlf/pQZegmuV+bSFE2bO1XKRYBja/wjvrTvFUrwbldi0hRMWxtVzkZG+eICgXOy6YfGmkuwzxZ8GjTrldUwhx+6xqIZWRkUHt2rVZs2YNvXr14t1332XRokW8++67VhejwDzjWMeOHdm8eXOB9Zs3b6ZHjx5FHpOeno5OVzDs/BnKyrtlgKLA5bwue96muHK9VlFM0uxUVEMV9Xtva/koX30vF/oPvI9cVYePchVfEhm3dF+FXFsIUfZsLRe5edcDwF9ajgtRpdhaLnp1UFPLcgJ5raz2fVWu1xRC3D6rWkg5OTmRkZGBi4tLmQUwadIkHn/8cTp16kT37t1ZtGgRERERlqadU6ZM4dKlSyxfvhyAYcOGMWHCBBYsWMCgQYOIioripZdeokuXLgQEBJRZXEXJNalEqt4A1MyNAVU1V6nKmYODAzqdjsuXL+Pt7Y2Dg0OxTWWFqCpUVSU7O5u4uDh0Oh0ODg7lfk1bykfX696sHuf/rk0z5SLtdCFszJbWUULYMpvKRZYWUtJyXIiqxpZyka+7I6ffHkyzaRtIUx3NK8+sL9drCiFun9Vd9gYMGMCWLVvo379/mQQwcuRIEhISmDVrFlFRUbRq1Yr169dTv359AKKiooiIiLDsP27cOFJSUpg3bx6vvPIKnp6e9O/fnw8++KBM4rmZGs72XFJrAeBkSoeMRHAu/xs/nU5HUFAQUVFRXL4sfaFF9eLs7Ey9evUKfeNWHmwpH13P1dGOraYmNNNdpKPuLBtNnSv0+kKIsmVTuSivIOWnSAspIaoam8pFgGNet70vcu+jv/6IeaXJBBXwGVIIUTqKamX7ycOHDzNixAjGjRvHAw88gL+/f6HWOjVrVu5v55OTk/Hw8CApKcnqgfMm/3yU107cg7eSDP/ZDv5tyynKwlRVJTc3F6PRWGHXFEJLer0eOzu7YlsE3s57ubIoq9cwderLvGu/hL+N7Xgy5zXC3y9+imUhRNmq1rko7ix80Zlk1Ylu6jKCZw0uvyCFEDdVrXNRnsA31qHDRLDhCRyVHHj+EHg1LIdIhRDFseZ9bHULqY4dOwIwY8YMZs6cWeQ+VblgckfjWlw67o23kkzulQvYVWBBSlEU7O3tsbe3r7BrCiFsQ4ZHI0iHprqLgMy0J4SoIO7mQYrdlQyUrFSNgxFCVHdDW/uz7ngUZ9S6tFVCIeaEFKSEqMSsLkhNnz69Wo9f5OxgR6Rai3aEcPjYMTq3vFfrkIQQglNKAzJVe2orCTRTLpKcmYO7oxSvhRDlzOBGtp0rDrmp+ClXiE/NoparQeuohBDV1BtDmrHueBSnTfVoqwuFmJPQ4j6twxJCFMPqgtSMGTPKIQzb4eygJyRvYHOSIm6+sxBCVJAUk4FdplYM0B+mh+4kUVczcfeTgpQQovylOXjjkJuKr5KI0SQtNIUQ2jut1jUvRJ/QNhAhxE3d1ghvmZmZREVFkZmZWVbxVHpujnaWgc09s6I1jkYIIczubO7LEZO5SXprXShh8dJ1RghRMVIcfADw5wo5RpPG0QghqrP8jjynVPPA68Qc1y4YIcQtlaogtXv3bnr16oWbmxt16tTBzc2NPn36sGfPnrKOr9Kp5WqwFKRyEqWFlBCicnh9cDNC7BsD0EYJZeKKQ1xJy9Y4KiFEdZBkb/5c5KtcIccoLaSEENqp7ekEQLCpHkZVgasR5ocQolKyuiC1d+9e+vfvz7lz53j66aeZNWsWEyZM4MyZM/Tv359///23POKsNAI8nYjM67IXoMZqHI0QQpg5Oej59OUnAQhSonEnlXFL92kclRCiOkjUmz8X+StX2HkuTuNohBDVWf5Yx8m4clatY14Ze1rDiIQQN2N1QWr69Om0adOGkJAQvvjiC6ZOncr8+fMJCQmhdevWTJ8+vTzirFQsXfaUNMhM1jgaIYQwc/DwIczki05RaaUL51hkktYhCSGqgSt25s9FfsoV3l57SuNohBDCLFQ1zwLK+S3aBiKEKFapWki99tpruLi4FFjv4uLC5MmTq0W3vTScSFRdzU+SLmobjBBCXOeSvXnMhM7KGQC+2h6qZThCiGqgc5vWAAQoCbSq7a5xNEKI6m5EB3PLqIuqr3lFzEkNoxFC3IzVBSmj0YjBUPR0vo6OjhiNxtsOyhbkt5LiqhSkhBCVR9NOAwDoqDsLwLvrpbWCEKJ81a7fBDAXpFwMVk/gLIQQZeqlO81jam4ztTGviD+jYTRCiJuxuiDVtm1bFixYUOS2hQsX0rZt29sOyhZYClLSQkoIUZk06AtAG10oYB5cOCu3enxRIITQiEdtAGooqWRnyAyfQght1XBxAOCIqSEmVYG0OEiV8e2EqIys/hrrjTfeYPjw4bRv357HHnsMf39/oqKi+P777zly5AirV68uhzArl/cfaM3lP7zMT5IvaRuMEEJcR/FtQbaqx1NJo7FyiXNqHb7dc4GnejXQOjQhRFXl6EGuvSt2Oal4ZMdoHY0QoppzcdADkIEjEaoPgUoMxAaDax+NIxNC3MjqFlL33nsvK1asIC4ujsmTJ/PYY48xefJkYmNjWbFiBcOGDSuPOCuVrg28iFZrAqBKQUoIUYnYG5w4aGoKQFedubve4YirGkYkhKgOsp0DAEiPl+nVhRDayp9pD+CMWte8ECtDGAhRGVldkAIYNWoUFy9eJDg4mB07dhAcHExERASPPvpoWcdXKdV0drg2a0O0DJInhKg8XBz0HFIbAdBcMd8YrjsepWVIQohqIMfV/LkoQInnQkKaxtEIIYTZGdU8wDmxcs8mRGVUooLUa6+9RmRkZIF1qqrSrFkzevbsSbNmzQpUoqs6ezuFC3mzNqjJlzWORgghrrHT6xgz/B4AOutOkz+OlBBClKccV/M4UgFKAscvJWkcjRCiuntzaHMAzpjqmVfEBGsYjRCiOCUqSH3yySdcvnyt8GI0GrG3t+fQoUPlFlhlZq/XEat6AqDLTITcLG0DEkKI67i1HESWak8T3SUClWitwxFCVAOefoEABJCgbSBCCAE81MncVS9YrW9eEXMCjDkaRiSEKEqJClKqWvgb9qLWVRd2OoWruJKl5o0JnyI3fEKISsTJE4Ni/tA1Uv8PAKeikrWLRwhR5dnVMLdC8FcSyMoxaRyNEKK6M9iZb3PDVD+uqi6Qm2kuSgkhKpVSjSFV3Zm7JyrEqjXMK6QgJYSopOoq5mmOh3y2g72h0nJBCFFOPK512XtvvQweLITQVn5BChSOmhqaFyMPaBaPEKJoUpC6DdHkF6RkHCkhRCVz33zA3Foh38s/HdEoGCFEledhHjg4QEkgIS2LlEzpGiOE0M714xsfyZvshUsHNYpGCFEcu5LueObMGezszLsbjUYATp8+XeS+HTp0KIPQKrdFj3ck5sea5ifJMoOVEKKSCewJQBslFCcyycCRXFP17WothChn7uYWUk5KNp6kkpljws1R45iEEAI4nN9CSgpSQlQ6JS5IjRs3rtC6xx9/vMBzVVVRFMVSsKrKXA12BOd32Uu+pG0wQghxI8/65LrVxj7lEu10IewxtcQkBSkhRHmxM3BV8cRTvUptJYHMnKr/WVAIUbmtfrYnw7/YxUlTkHlF/DnITgMHF20DE0JYlKggtXTp0vKOw+YY7PVcUmsBkHvlQskre0IIUREUhdzaXbE7vYouymn20BJjNZ6MQghR/py960PsVfPA5rlSkBJCaKtdXU8A4vAkTvXAW0mCmGCo21nbwIQQFiWqo4wdO7a847A59nqFi6oPAFlxYVKQEkJUOg4NesLpVXTSnQEjGI1SkBJClB+HmnUh9igBSjzJmblahyOEEBYnTYH01R+Fi3ulICVEJSKDmpeSSYWLqjcADqmRGkcjhBCF6ep1A6C97jw6TDKGlBCifHnUBSBAucID83drHIwQQlxzTM3rthe6TdtAhBAFSEGqlOz1CpF5BSn77KuQmaxtQEIIcSOf5uTqnXBVMmmiRJKRYyTHaNI6KiFEVeVhHtg8QInXOBAhhChop7G1eSHmhLaBCCEKkIJUKbXwdycNJ66oruYV8ee0DUgIIW6k06MP7AFAD91JAA5eSNQyIiFEVeZRBwB/JUHjQIQQoqBgtb55ISUK0q9oG4wQwkIKUqWkKAr3tPHnnGr+8EX0UW0DEkKIIigN+gLQU2f+RtBeL2lfCFFO3M2fiQKkICWEqGRScSbT1dytmOjj2gYjhLCoFHcm8+fPJygoCEdHRzp27MiOHTtuun9WVhZTp06lfv36GAwGGjZsyJIlSyoo2ms8nOyJMJkHNidDWh0IURXYaj4qVsN+AHTTBWNHLiMW7GbF3gsaByWEuBWbzEV5XfZ8SUSPzLInRFVgk7moGBEODc0L0ce0DUQIYaH55HA//fQTL730EvPnz6dnz54sXLiQIUOGEBwcTL169Yo85uGHHyYmJoavv/6aRo0aERsbS25uxc/m4ulsTzweAGTHnMGhwiMQQpQlW85HxfJpCU41ccm4QhsllENqE95cfYLHutXXOjIhRDFsNhe5+pKLHjvFiA9XK/baQogyZ7O56Dqv3NWETzafBeCPGG9etQdC/oYez2sWkxDiGkVV1VtOu7R9+3arTtq7d+8S79u1a1c6dOjAggULLOuaN2/O8OHDmT17dqH9N2zYwCOPPEJoaCg1a9Ys0TWysrLIysqyPE9OTqZu3bokJSXh7u5e4lhvtGh7CAc3fMtCh/8jxq0Fvq/sKfW5hBDWS05OxsPD47bfy/lsOR/d1MqxELyaj3Ie5gvjcADC3x9aPtcSohqSXHRN7KzG+JhieSBrBqtmv1zq8wghrCe5qDBVVWk+fQOZOSZaK6GsMbwJdk4w5SLo7W/7/EKIwqzJRSXqste3b1/69etHv379CiwX9yip7OxsDh48yMCBAwusHzhwILt3Fz1d8B9//EGnTp348MMPqV27Nk2aNOHVV18lIyOj2OvMnj0bDw8Py6Nu3boljvFmans6E63WAMApS8ZLEMKW2Xo+uqnaHQBorQsr/2sJIW6LreeieL15KAMZR0oI22bruSifoijc0cg8M/oJNRDV0RNyMyB8Z5leRwhROiXqsrd161bLckpKCs899xxNmzZl1KhR+Pn5ER0dzXfffceZM2f44osvSnzx+Ph4jEYjvr6+Bdb7+voSHR1d5DGhoaHs3LkTR0dHfvvtN+Lj43nmmWe4cuVKsf2Tp0yZwqRJkyzP8yvvt8vf05EEzBU/p5xEUFVQlNs+rxCi4tl6PrqpwF4A9NMdwUA2WdLBWIhKy9Zz0RU7b8iBACWeM9EpNPVzu+1zCiEqnq3nouu1DHBny6kYVHSYandCH7LFPI5Uw5I3pBBClI8SFaT69OljWX7mmWfo3bs3y5cvL7DP2LFjefzxx1mzZg333HOPVUEoNxRxVFUttC6fyWRCURS+++47PDzM4zfNmTOHBx98kC+++AInJ6dCxxgMBgwGg1UxlYSLgx1XVHNByl7NhswkcPIs8+sIISqOreajmwpoD66+GFJjaKOEsl9tVrHXF0JYzVZz0RU7cwspf+UKgz7dLt2DhbBxtpqLrvfkHUF89tc5AHKcfdED/P0u9HyxXK8rhLg1q2fZ+/nnnxk9enSR20aPHs2qVatKfK5atWqh1+sLVdljY2MLVePz+fv7U7t2bUuSA3NfZlVViYyMLPG1y4KHkz3pGIhRPc0roo5W6PWFEGXH1vPRTSkK1O0KQCedeWDPQxEyM6gQlZGt56IUB3OMtZX4Cr2uEKJs2Xouup6b4VobjCP5qcmYVfTOQogKZXVBKj09ndjY2CK3xcTEkJ6eXuJzOTg40LFjRzZv3lxg/ebNm+nRo0eRx/Ts2ZPLly+TmppqWXf27Fl0Oh116tQp8bXLgp+HI6BwypQ3W1VieIVeXwhRdmw9H91Sve4AdNKdAeCB+btJyczRMiIhRBFsPRclOeS3kJIxpISwZbaei66n011r0fViWPdrG7LTNIhGCHE9qwtSvXr1YurUqZw4caLA+uPHj/Pmm2/Sq1cvq843adIkFi9ezJIlSzh16hQvv/wyERERTJw4ETD3Kx4zZoxl/1GjRuHl5cUTTzxBcHAw27dvZ/LkyTz55JNFNgMtb28Obc5F1TxQnhSkhLBttp6PbqpefgupM9hjnn5513m5YRSiMrLlXOTqEwhcG9TcaLrlZM5CiErKlnNRcWKoAW4B5ieRB7QNRghRsjGkrvfZZ5/Ru3dv2rVrR8uWLS2Dmp88eRIvLy8+++wzq843cuRIEhISmDVrFlFRUbRq1Yr169dTv7651VFUVBQRERGW/V1dXdm8eTPPP/88nTp1wsvLi4cffph33nnH2pdSJs7HpuKqmputqpH7kSHNhbBdtp6PbsqvLUbHmnhkXqGdcp79ajMmrjgo47sIUQnZci56qH93OApeSgoGsknPzsXNUaZWF8IW2XIuKp4CQb3h2I8Qth0a9Ln1IUKIcqOoqmr1V1exsbHMmTOHf/75h4SEBLy8vOjXrx8vvfRSsX2KK5Pk5GQ8PDxISkrC3d39ts41a00wwXvW8aPDOxhdA9C/eqqMohRC3EpZvpe1UpGvIfXb0biGrOWjnIf5wjgcQApSQpQByUXXUVXSZvjiomTRL+sTfpryGD7ujmUXqBCiWJKLihf4xjrLcvjIq/D7M1CnMzy1pcyuIYQws+Z9bHULKQAfHx/ef//9UgVX1bg62hFq8gdAlxYDJiPo9BpHJYQQhTk37g0ha+mqO8UXxuEoCsSmZOLtaih2xhwhhLCKohCletFIuYy/kkB6tlHriIQQgrtb+7H+eN4A7fXzxsC6fASMOaCXVpxCaMXqMaTyJSUlsXHjRr777jsSE6vvbE1P9gwkHg9yVR2KaoTUGK1DEkKIIumC7gCgl+E8bqSjqtDl3b8ImrJe48iEEFXJZdULMM+0l5qVq3E0QggBkwc1sywfT/MEexcw5cCVUO2CEkKUriD19ttvExAQwJAhQxgzZgxhYWEADBgwoNq1nPJ0dqBTYC0uqbXMKxIvaBuQEEIUx6cFeDVGyc2gt+6Y1tEIIaoqD/NsWrWVeJJlNk8hRCXg7HCtB8uKfy+CX2vzk8j9GkUkhIBSFKTmz5/PzJkzGT9+POvWreP6Iajuuece1q1bd5OjqyZHBz0RqnmaY5lpTwhRaSkKNOwPmGfbE0KI8tCyhflGrzbxXEhI1zgaIYQAR/trBamfDlyEwJ7mJ+E7NYpICAGlKEjNmzePSZMmMXfuXAYOHFhgW+PGjTl37lyZBWcrnO31XJSClBDCFtTrBhQuSMnU7EKIsuJVpzEAdZR4rqRlaxyNEEIUbCEFYKzfy7xw/i8NohFC5LO6IBUaGsqgQYOK3Obm5sbVq1dvNyabo9cp0kJKCGEb8gpSLXURuJBhWf3dv9LdWAhRRjzNU8LXUeLIzJFBzYUQ2rPXF7ztTfBoaV5Ii4XUOA0iEkJAKQpSHh4exMQUPXB3eHg4Pj4+tx2UrVl3PEpaSAkhbIN7ALgFoMPEIN21cROm/35Sw6CEEFWKZz0A/JUEjlyI1zgYIYQo7OxVHapPC/OTkL+1DUaIaszqgtSAAQP48MMPSUtLs6xTFIXc3FwWLFhQbOupqqxj/RqWFlLGBJmpQQhRydVsAMCzdr9rHIgQokpy9SVHccBOMREWWv2GchBCVE5fPtbBsvzY1//yr669+UnEbo0iEkJYXZCaNWsWFy5coEWLFrzyyisoisK8efPo0qUL58+fZ9q0aeURZ6X2+uBmXFS9AdCnx0JOpsYRCSHETTS+E4CGuiiNAxFCVEk6HdmutQFzt73oJPlcJITQ3uBW/gWeL43I6+FyUWbaE0IrVhekGjVqxK5du2jevDnz589HVVWWL19OrVq12LFjB/Xq1SuPOCu1QC9nruJKmmowr0iK1DYgIYS4mTaPWBYbKpcsy9fPmiqEELdDV8P8ebCOEsepqGSNoxFCCLPBLf0sy4dM5gkYiA2GzCSNIhKierO6IAXQokULNmzYQEpKCpGRkSQnJ7Np0yaaN29e1vHZBB93R0AhQvU1r0iQ5ulCiErM/do3hHfr/rUs5xilICWEKBv2Nc0FqQAScLAr1cdNIYQoc6brvnyLwzNvzDsVLh3ULCYhqjOrPyFs376d8PBwAAwGAwEBATg5OQGQkpLC9u3byzRAW9G2jgen1LzWYTEntA1GCCFupfkwAJrorrXo/POEdOETQpQNOw9zlz0/5YrMtCeEqDQ2Bd8wOVedLuZ/pdueEJqwuiDVt29f2rZty6ZNmwptCw4Opl+/fmUSmK2JT80mzJTXBPRKuKaxCCHELXUYB8Aw/V4cyQLgxR+PkJiWrWFQQogqI68lpq+SSK5JWl8KISqpunkFqch92sYhRDVVqjbUgYGBDBs2jGXLlpVxOLbr0tUMy0x7XL2gbTBCCHErDfpaFnvoTlqWp/9xsoidhRDCSm4BgLmFVK50BxZCVFLR7q3NC5H7wWTSNhghqqFSFaQWLlzI008/zfjx45k1a1ZZx2SzLuYXpBLDNY1DCCFuSW8HQb0B6KY7ZVl98rIM6imEKAM1GwDQWInkaHisxsEIIYTZrPtaFni+Ib4W2DmZBzWXcaSEqHClKkjpdDo+//xz3n33XWbOnMmECRMwSUWZi6o3AGrSJciRKY6FEJVcx3EA3K2/NrA50pBBCFEWvBqSqdrjoBjZsEdu8oQQlcOY7oEFnuvtDdB0sPnJ6TUVH5AQ1dxtTXvyxhtv8M0337B8+XKGDRtGWlpaWcVlcx7pXJc4PIlTPVAwQdQRrUMSQoibazwQFB11lHh8SAQgND4Nk4z3IoS4XYpCZN4XdXUVaSElhKic7HUKBPYyP4k6pm0wQlRDtz0P72OPPcbatWvZuXMno0ePLouYbNIrA5sCCudN5llluBqhaTxCCHFLBjfwNTdd76YLtqz+67TcPAohbt9FS0EqDlWVQrcQovJJzcoFv7xxpC7shpwMbQMSopqxuiBVv359DAZDgXV33XUX27ZtQ1GUMgvM1jg76AG4RC0ALl84q2U4QghRMg0HANBHf9Sy6kpallbRCCGqkPyxNesqsSRn5mocjRBCmLk52lmW31l3Cup0No8jZcyCmOCbHCmEKGtWF6TCwsJo27ZtofXt2rXjzJkzhIaGlklgtsZOby7GXVLNBalzZ2SmKiGEDWhkLkj11R1FjxGAszGpWkYkhKgi8ltI1VHiuZKWrXE0QghhtmfKgIIrFAUCe5qXZWBzISrUbXfZu56bmxv169cvy1PaDHud+UcZmVeQqpUbo2U4QghRMnW7gcEDLyXF0m3v651hhMVX3zEBhRBl445OHQGor8Qwf+t5jaMRQggzV4NdgefZuSbLzMOcXqtBREJUX3a33gVmzZrFU089RUBAALNmzbrpvoqiMG3atDIJzpbodAoLRnfgy+/NH7gCMs6iqmq17sYohLABdg7QZBAcX0kv3Ql2mczjKBy/lERQLReNgxNC2LI+3bvBUXNB6ueDkXz0UOEW9kIIobW9oQn0bnQXbJ4OkQfAmAv6Et0mCyFuU4neaTNmzGDw4MEEBAQwY8aMm+5bXQtSAP2b+/CaGgBADSWFtQfPcU+nJhpHJYQQt9Dsbji+koG6/bzPowB8szuce9sGaByYEMKm1QwCoIaSigep5BpN2OnLtHG+EELctvRsI3g3A4M7ZCVD9DGo3UHrsISoFkr0qcBkMtGlSxfL8s0eRqOxXAOuzBz0OlJwJll1AmDfEZk6VAhhAxr0AxQa6KLxIRGAgxcStY1JCGH7HFyIVmsAEKhEs+NcvMYBCSFEYSZVBZ0OAnuZV4Ru1TYgIaoR+ZqqDOV3z8ufVcYn+5KW4QghRMk4eYJ/GwB66Y5bVp+JTtEoICFEVXFB9QXMBalso0njaIQQwuz6YQmMJtW80KCP+d/zf2kQkRDVkxSkysE5tTYA/jkRGkcihBAl1GQIAHfr/7WsGvTpdq2iEUJUEWEmPwAClRiycqUgJYSoHKbe3dyyHBKXN7twk0HmfyP2QrZM7iJERShRQap///4lfgwYMODWJ7zB/PnzCQoKwtHRkY4dO7Jjx44SHbdr1y7s7Oxo166d1dcsT+dN+QWpCxpHIoSwVlXLRyXW6gEAeuuO4U6qZbWqqlpFJES1VlVy0QU1ryClizbPZCWEsClVJRfdTGhcXvHJsz64BYBqhMuHtQ1KiGqixGNIqapaoofJZN2HjZ9++omXXnqJqVOncvjwYXr16sWQIUOIiLh566KkpCTGjBlTqgJYeTuf30IqW1pICWFLqmI+KjHvpmR7NsReMXK/fpdl9dc7wzQMSojqqSrlojD1WgspKUgJYVuqUi66kYPdtdvguJQs84KiQF3zuMlc/LeIo4QQZU1RNf76u2vXrnTo0IEFCxZY1jVv3pzhw4cze/bsYo975JFHaNy4MXq9ntWrV3PkyJESXzM5ORkPDw+SkpJwd3e/nfALCXxjHQ2VS/xlmEym4oTj9ChzchNClLmyfi9XtXxktTUvwcGlrMztw2u5/7GsDn9/qHYxCWEDJBcVb+eOrdzx13ASVVdWD9zJEz2DyuzcQoiCJBeVnNGk0vB/6y3Pn+3XkMmDmsHeBbDhDWh0Fzz2S7ldX4iqzJr3saZjSGVnZ3Pw4EEGDhxYYP3AgQPZvXt3scctXbqUkJAQ3nrrrRJdJysri+Tk5AKP8jLz3pZcUH3JUfU4qhmQLAObC2ELqmI+sloj8zeZA/UHcCTLstoytoIQotxVtVx0R1dza4MaSioZSTLLnhC2oqrlohvpdQqfjmxnef7F1hDzQlBv87/hOyA7vUJiEaI6K1VBKicnh6+//ppRo0YxaNAgRo8ezdKlS8nJybHqPPHx8RiNRnx9fQus9/X1JTo6ushjzp07xxtvvMF3332HnZ1dia4ze/ZsPDw8LI+6detaFac1ejT0Ihc7y6wyxJ0pt2sJIcpOVcxHVmsymKt2tfBU0uigO2dZPXv9KQ2DEqJ6qXK5yMGFOGoAsHFH8TexQojKpcrloiJc323PwqcFeNSF3ExzUUoIUa6sLkglJSXRvXt3JkyYwJo1awgNDeWPP/5g/Pjx9OjRo1RVbeWGLm2qqhZaB2A0Ghk1ahQzZ86kSZMmJT7/lClTSEpKsjwuXrxodYwl5e5kD0Co6m9ecSW03K4lhCh7VSkfWU1vD35tAHjX7mvL6uTMXK0iEqLaqkq5KNRkvqGtr8SU2zWEEOWjKuWiG7kYiiiaKQo0zmsVdm5zhcUiRHVVstL1daZOncqZM2f46aefeOihhyzrf/nlF5588kmmTp3K559/XqJz1apVC71eX6jKHhsbW6gaD5CSksKBAwc4fPgwzz33HHBtwHU7Ozs2bdpE//79Cx1nMBgwGAzWvMxSc81LbJYWUvFnK+S6QojbUxXzUWl4BraDyL8J0sUAKqCwL+yKxlEJUX1UxVwUbvKjq+40QUo0OUYT9npNR4wQQpRAVcxFN6rt6VT0hgZ94cDXELa9QuMRojqy+hPB6tWrmTVrVoFiFMCDDz7IjBkz+O2330p8LgcHBzp27MjmzQWrz5s3b6ZHjx6F9nd3d+f48eMcOXLE8pg4cSJNmzblyJEjdO3a1dqXU+byK+0nTYHmFTJDgxA2oSrmo1Lp/aplsaFy2bKcmWPUIhohqp2qmIv8G7QEIFAXTXq25BIhbEFVzEU38nS2L3pD/Z7mf+PPSCspIcqZ1S2k4uLiaNOmTZHb2rZtS3y8dQNWTpo0iccff5xOnTrRvXt3Fi1aREREBBMnTgTMzTgvXbrE8uXL0el0tGrVqsDxPj4+ODo6FlqvpYbeLhyLbwCAGn8eRVVlpj0hbEBVzEdWc3CBRnfC+S3cpTtIiLE2YJ6NRghRMapaLrqjSxeI+IJAJYaMbCMeTsXcBAohKpWqlotuVGwucvG6tnxxHzS+q2ICEqIasrogVbt2bXbu3MmAAQMKbdu1axcBAQFWnW/kyJEkJCQwa9YsoqKiaNWqFevXr6d+/foAREVFERERYW2Ymmpfrwar43zIUfXY56SZZ9rzqKN1WEKIW6iK+ahUmt4N57cwUH+AL433ApCda8Kl8vY0FKJKqWq5SFerIQCBSjSJ2TImnRC2oqrlohvd2H149/l4ejSqZX7S6xXY8Qkc+Q76T9UgOiGqB0VVVau+9p4yZQpz5sxh9uzZjB07Fi8vLxISElixYgWvv/46kyZN4r333iuveMtEcnIyHh4eJCUl4e7uXubnT0jNouM7W/jT4XWa6y7Cw8uhxX1lfh0hqrvyfi9XhEr5GpKjYE4zTKpC16wviMOT3k28+eaJzkUOZCpEdVcp38dWKtfXkJUKs82tLed32cIzd3cu2/MLIQDJRaUR+Ma6As/D3x9qXgj9B5bn3b/9LwocnMs9FiGqCmvex1aPITVjxgz69evHq6++io+PDwaDAR8fH15++WX69evHjBkzSht3leHlam5GcMhknmHCeOmwluEIIYR13P0hoAM6ReUu/UEAtp+NY9vZOI0DE0LYJIMrMaonABt37NY2FiGEuM64HoEFnidl5JgXgvpcWxkheUuI8mJ1QcpgMLBhwwb+/PNPJk+ezJgxY5g8eTIbN27kzz//xMHBoTzitEnnVPO3gfHhJzSORAghrNTsbgAe1m+1rPrj6OXi9hZCiJsKV/0AqK/EaByJEEJc0zWoZoHnm4PzcpSiQPvHzcshWxFClA+rx5DKN2jQIAYNGlSWsVQ55/MKUi7JoRpHIoQQVmozEv5+h3a6ULy5ShyerDp0iTkPt9M6MiGEDQo3+dFVd5ogJfrWOwshRAW5cewa0/Wj2QT2gsPfQsTeCo1JiOrE6hZS10tPT+fKlSuFHgKm39OCEJN5gHfntAgw5mgckRBCWMGzHgR0AOBu/b8aByOEsHUXVF8A6utiyDGaNI5GCCHMTDcMp+zsoL/2pF5X87+XDkBmcgVGJUT1YXVBKj09nZdeeglvb2/c3Nzw9vYu9BDw5B1BRFODNNWAzpQDieFahySEENZp8zAAQ/XXvhnccCJKq2iEEDYsLK/LXpASzbvrTmkcjRBCmLWp7Vng+Qs/HCYr12h+4lkf3PJmkD/xa8UGJkQ1YXWXveeee45vv/2WYcOG0bx5cxkz6iZUdISq/rRWwiH+LNRqrHVIQghRcg36AtBFdwYPUknClYkrDl2bgUYIIUrI0kJKiWbZ7nBm3NtS44iEEALqeTnz54u9GPLZDgBMKnyzO5ynezc0jyPVbCjs/woOr4BOT2gcrRBVj9UFqTVr1jB79mxeffXV8oinyglRA2hNuLkghdzECSFsiE9zy+Is+2W8mPOchsEIIWxZ/qDmNZVUGrjKMAZCiMqjuX/BaenPRKdee9Kgr7kgdSUEVNVcpBJClJlSjSHVvn37so6jygrNG0fKePmYxpEIIUQpeNQFoLYSr3EgQghb9sW4XsSqngA80lAKUkKIysXL5VqvH/31d8iN7wJFBxmJEHOy4gMTooqzuiD1wAMPsGnTpvKIpcqx1yvk5DVC0wev0jgaIYQohUd/BKCDco6amAf0TEjN0jIiIYQN6tfMhxg78+zDJIRoG4wQQtzg9cHNLMt63XWtoOwM0OhO83LIXwCExadxOloGOReiLFhdkPrkk084cuQIkyZNYsuWLRw6dKjQQ5h1a+DFeTVA6zCEEKL0fFtCrSboFJVH9H8DMPW3ExoHJYSwRQbfJgCkR59h6+lYjaMRQohrmvq5WZZ1N3bLa9APgPM7fmbZrjD6ffwPgz/dwdX07IoMUYgqyeoxpDIyMsjNzeXTTz/ls88+K7BNVVUURcFoNJZZgLbsrha+fHSuxbUVSZfAo7Z2AQkhhLUUBRoPhPiz3KU/xHzjcDacjCbHaMJeX6pe30KIairDowFchobKZab/cYIdzfprHZIQQgBgsL/2mebIxasYTeq1llJBvQBolHmce9ccAhwBuJCQjovBjvQsIx7O9hUdshBVgtUFqfHjx7N//35eeuklmWXvFkZ1qccXW89zPjOARrrLqKFbUdo/pnVYQghhnXajYM882ioheJFEAh4cuXiVzoE1tY5MCGFDsj0bAtBQicJoVDWORgghrjHY6S3LJy8ns2h7KP/ta85ZeF/rzjdYt49Vpt4AZOQYuWfuTs7EpLB3ygD8PBwrNGYhqgKrC1Jbt25lzpw5TJgwoTziqVLs9Drub1+Hf3c1p5HuMmHH99BAClJCCFvj2xL826GLOsJ9+t0sMQ7ROiIhhA2KNdQDIEiJQq9IQUoIUXk42BVs9b14x3UFKb09fxnbM0B/mI66c5aC1COL9lr233omlke71KuweIWoKqzub+Hm5kZgYGA5hFI1qaicU83d9M6cP6dxNEIIUUp5xfTp9t8CsOFEtJbRCCFsUNcOHchW9Tgp2XirMnOnEKLysNMVHDcqIa3g+FAbTJ0BuE+/q8jj9TccL4QoGasLUmPGjOHHH38sj1iqJFcHOy6ptQBoQRhGk3wjKISwQc3usSy2UkL5emeYhsEIIWyRq5MjF1Q/AHyyLmgcjRBCXOPsoL/p9r2m5gC4Kpk0UC4X2p6da2LGHyfZG5pQLvEJUVVZXZBq27YtW7du5f7772fx4sWsWrWq0ENcY7DXsd/UFID6ulhy0q9qG5AQQpSGuz+pTubWnq/a/axxMEIIW2Sw0xGSN/uwX04kmTkyCY4QonJwc7Rn4eMdC6x77ZejxKdmAXBR9eWCyQeAh/X/FDp+wT8hLNsdXqAbnxDi1qweQ2r06NEAhIeH8/vvvxfaLrPsFeSg13EVN6LUmvgrVzBGB0OjnlqHJYQQVgv1G0KbsMV0150EYHdIPD0a1tI4KiGErVAUhRDVHzDPtHcmOoW2dT21DUoIIfIMaulH36be/HMmDoCVByJJTM/hqzGdAPgk9yHmOnxBX91R3mdUgWMvXc2o8HiFqApKNai5KLm7W/szY00w50y18ddfQbm4TwpSQgiblNFhAoQtxqDk0kYJYcI3ek7OGqx1WEIIG3JHt+5w4A8aKpcxqjKMgRCichnbPdBSkAI4HHGVy3nFpt2mVgA0USLxIZFYamgSoxBViVUFqczMTDZu3MiIESPo2LHjrQ8Q+Lg70qq2Oweim9Jbf5wrp3fg3O9lrcMSQgirdWnVFH41Lz+g38GM7IbaBiSEsDkZHo0AaKS7zEUpSAkhKpnkzJwCz+NTs+jx/t/mZTwIVoNooYTRU3eC30y9tAhRiCrFqjGkHB0d+b//+z/S0tLKK54qaUSHOhxUGwOQE3VCBjYXQtgkRVFY1WIuAPfrd2JHrsYRCSFsTZanuZDto1xFybyqbTBCCHGDrFzTTbfn1rsDgAH6QxURjhBVntWDmjdv3pywMJldyVpnTPUAqK/Esv/sRY2jEUKI0ul25wjiVHc8lHR6646RkDfYpxBClITq4EZk3uzDhitnNI5GCCEK0inKTbcHdR8OwD36f9FRdPFqzibJbUKUlNUFqWnTpvHOO+8QEhJSHvFUSV2DvIjHg3jVHZ2i4px0XuuQhBCiVAJqurLdsT8A4/V/8uKPR7QNSAhhU+x0Os6ZzDN2Olw5p3E0QghR0D1t/G+6XQm6AxzcABii21fkPnP/Pk9sSmaZxyZEVWR1QWrp0qWkp6fTvHlzOnXqxLBhw7j33nstj/vuu6884rRpLQLcAThtqgtA9Dlp4imEsF21B70EQHddMGHnT2kbjBDCpng42XNGNX8eCjkh06MLISoXR3s94e8PxU5XdEspe3t7CGgHwBddEoo9z/6wxPIIT4gqx+qC1LFjx3BwcKB27dokJCRw4sQJjh8/XuAhinZGNXfbu3j6gMaRCCFE6dWs3YhdxpboFJUR+h1ahyOEsCGtartzwhQEgF/aaY2jEUKIon0/oVuR6+11Ouj9qvnJuU080aNekfv9cyaWzBxjeYUnRJVh1Sx7AOHh4eUQRvVwOu8bwW66YI0jEUKI0mtQy4X5xj701J9kkv0voC6GW4y5IIQQYJ4c4VTeF3RNlEgwmUBn9fejQghRrgx2ReclnU6B+j3BwRXS4nirC2w750JoXBp1azpx8UoGAD8fjOTng5GcnDkIF4PVt9xCVBvyCaCCPNqlLqfzBjZvqbsAmckaRySEEKVjp9exxdTh2opzm7QLRghhc8JVPzJVe5yVLC6EnNQ6HCGEKMROX/iLtpouDuYFvT3U625e3v4xm17qzbEZA/mhiFZVhyOulmOUQti+UhWkcnJy+Prrrxk1ahSDBg1i9OjRLF26lJycnLKOr8oY0srfMmYCANHStVEIYbtScbYsm7a+r2EkQghb8+FDHTinmgc237t7u8bRCCFEYZ7ODoXW7ZnS/9qT5veY/z21Bju9DndHe+z1hW+tXQz68gpRiCrB6oJUUlIS3bt3Z8KECaxZs4bQ0FD++OMPxo8fT48ePUhOtr7lz/z58wkKCsLR0ZGOHTuyY0fxY5KsWrWKu+66C29vb9zd3enevTsbN260+poVrVfjWmRjT6jJD4Cr/36ncURCiKJUh3xUFga28OW1nAkA6KIOoabL4J1ClKWqnIvq1nTmlKk+ALXSzmocjRDiZqpyLrqZ2p5OTLunBe8/0JougTUZ1jYAg911xaUWeRN5qUa4aJ5tz9fdsdB59MUMji6EMLO6IDV16lTOnDnDTz/9REpKCufOnSMlJYWVK1dy5swZpk6datX5fvrpJ1566SWmTp3K4cOH6dWrF0OGDCEiIqLI/bdv385dd93F+vXrOXjwIP369WPYsGEcPnzY2pdSoZS88VUOq40B+PfEGbJzTVqGJIS4QXXJR2WhbV1P/jD2sDzf8uOn2gUjRBVT1XORh5M9waq5IKWPPaFxNEKI4lT1XHQr4+8I4pEu9Vg5sTufP9q+4EanGhDUx7x8YIll9eFpdxXYbdPJmPIOUwibpqiqqlpzQJ06dXjllVd4+eWXC22bM2cOc+bMITIyssTn69q1Kx06dGDBggWWdc2bN2f48OHMnj27ROdo2bIlI0eOZPr06UVuz8rKIisry/I8OTmZunXrkpSUhLu7e4ljvV2Bb6yjt+4oyx0+IMLkzamHdzCwpZ+lWCWEsE5ycjIeHh5l9l6uTvnods3ZfJa5f51jrH4jM+2/Ma+clgB6GbhTVD+Si6wTn5rFs+9+zk+Gt4lUa1FnZki5Xk+I6kJyUQU7+Rv8PA6cveC1UAAyso00n76hwG7h7w/VIDghtGNNLrK6hVRcXBxt2rQpclvbtm2Jj48v8bmys7M5ePAgAwcOLLB+4MCB7N69u0TnMJlMpKSkULNmzWL3mT17Nh4eHpZH3bp1i923vB00NSFH1VNPF8fMFZt46w8ZzFOIyqA65qPbkd/C8y/Tdd8YnvhVo2iEqDqqQy7ycnHgVN64mnWUeMiQLr9CVDbVIRfdtsaDQGcH6QkQvhMoena+zBxjRUcmhM2wuiBVu3Ztdu7cWeS2Xbt2ERAQUOJzxcfHYzQa8fX1LbDe19eX6OjoEp3jk08+IS0tjYcffrjYfaZMmUJSUpLlcfHixRLHWJZ6Na5FGk5cVL0B6Kg7y/I9FzSJRQhRUHXLR7drdFfzrKGRqg+pat6YCSd+0TAiIaqG6pCLFEUhGVcumsyfh37+TYrZQlQ21SEX3TYHZ/Bpbl5eOQYAXRFjRv2wr+gujkKIUhSkRo4cyXvvvcecOXNISEgAICEhgc8++4z33nuPRx55xOogbuyypqpqibqx/fDDD8yYMYOffvoJHx+fYvczGAy4u7sXeGhh2RNd+OuVPkTmFaQe1v+jSRxCiOJVl3x0u+rWdObrsZ0AGJE9w7zy3CaIP6ddUEJUIVU9F7Wt68kuU0sA4oK3EZucWaHXF0KUTFXPRbetw1jzv+kJkJVS5C4z1wRXYEBC2BarC1IzZsygX79+vPrqq/j4+GAwGPDx8eHll1+mX79+zJgxo8TnqlWrFnq9vlCVPTY2tlA1/kY//fQT48ePZ+XKldx5553WvgxN6HUKDb1diVRrAeCjXAVgyGc7pCmnEBqrbvmoLDg5mGebOaPW44ipoXnlzv/TMCIhbF91yUVzHm7LUdWcN9ooISRl5GgckRDietUlF922DmOuLe//GoDfnunBy3c2KbCbTGYlRNGsLkgZDAY2bNjAn3/+yeTJkxkzZgyTJ09m48aN/Pnnnzg4OJT4XA4ODnTs2JHNmzcXWL9582Z69OhRzFHmivu4ceP4/vvvGTrU9gaJC2nzCrmqjqa6SHxI5FRUMj9KU04hNFVd89Ht6BJ4bUyIVcY7zAtHvoOrks+EKK3qkotqODtwNK+Q3UYXhskkN2tCVCbVJRfdNjvDtdn2trwFQPt6NZjQO6jAbhnS+ECIIpV6OqRBgwYxaNCg2w5g0qRJPP7443Tq1Inu3buzaNEiIiIimDhxImDuV3zp0iWWL18OmJPcmDFj+Oyzz+jWrZulau/k5ISHh8dtx1MRcgw1iKEGtUmghe4CsaYaZOTIBzEhtFYd89HtsNPr2PFaP3p9uJWVxr7Myp9t79PWMCNJ2+CEsGHVIRe5GPScVeuQqdrjrqQTdzUM/NtpHZYQ4jrVIReViV6TIGybeflqBHjWw9mh4G12Zo4RDyd7DYITonKzuoVUWRs5ciSffvops2bNol27dmzfvp3169dTv359AKKiooiIuPZt+8KFC8nNzeXZZ5/F39/f8njxxRe1eglWi03O4ripAQDddOY+xalZ0lRdCK1Vx3x0u3zcDQBkYii4ITdbg2iEqBqqQy5y0OvIxY6TaiAAmeH7tA1ICFFIdchFZSKw97Xl3Z9bFn3dr302ik3OqsiIhLAZiqqq6q12atOmTclPqCgcPXr0toIqb8nJyXh4eJCUlKTJwHlfbQ/l+Iavmeswj+OmQIZlvwfAj093o1sDrwqPRwhbpfV7uSzY+mtQVZWgKesBqEEyhx3N35rS/nG4b56GkQlRcWz9fQzavIbAN9Yx3W45T9pt4Jvcuxj7jszUKcTtkFykoe8fgbN/mpffjAM7Bz7dcpZPt5gne1kwugNDWvtrGKAQFcea93GJWkjVrFkTLy+vmz4MBgMnTpzgxIkTZfIiqrIxPepzUjV/s9BEicQRc8X8sy0yO5UQwrZcP9NOIu7scehufnL4W0gp2bTQQojq61+Tecr0XrrjGkcihBC34e4Pry0f/R6AUV3rWVZN+U1ynBBFKdEYUv/880+x23Jzc1m0aBGzZs1CURRGjRpVVrFVWQY7PW+OuZfLP84mQLlCV91ptpnaotfdegpVIYSozB5LfoYQxz3mJ5+2hmlx2gYkhKjU9uYVpBrooiEtAVykpbgQwgZ51oPaneDSAVjzInQch4+bo2Xz1XQZnkWIotzWGFI///wzLVq04Pnnn6dt27YcPHiQb7/9tqxiq9KcDPZsM7YF4I68bwUVqUcJIWycET10GJv3JBsSQrQNSAhRqSXhyllTbfOT0K3aBiOERtKycknPztU6DHG7Br9/bTm6cIuoEoyUI0S1U6qC1D///EPXrl0ZOXIk7u7ubNq0iY0bN9KuXbsyDq/q0usUdplaAdBPdwSAHefiNYxICCFK5/NH2xdccc//XVve+l7FBiOEsDlbTe3MC+E7NI1DCC3kGE20mrGRlm9tJNcos27btNodry0fMXfbG9O9vmVVjlEKUkLcyKqC1PHjx7n77rsZMGAACQkJfP/99xw4cIABAwaUV3xVVru6nsR7dwOgke4y7RXz+FFJGTn8cfQyGdlGLcMTQogSG9Y2oMDzXFWBx341PznxC5xep0FUQojK7uOHzC3F95uamVeE/gPSgkBUM1fTc1BV86/+iAW72XAiivfWn+JqusxWa3N0Ohi10ry8dz7Ensbd0d6y+af9EcUcKET1VaKC1MWLFxk7diwdOnTg4MGDfPrpp5w6dYpHHnmkvOOrsuz1On54aSi/GXsCMNZuIwDPfHeQF344zKy1wVqGJ4QQVhl93cCdJy4nQ6M7oUFf84ofR0FmkjaBCSEqrQc71mHHa/3YbWpJpmoPieEQc1LrsISoUNcP2XE0MomJKw6xaHso7WZt1i4oUXqNB15bXjKQR6/7fDTt95NM/vkoX2w9r0FgQtxaenYuD3+5p0J/R0tUkGrSpAkrVqxg4MCBrFy5kp49e3L8+HEOHTpU5EOUjKIonPW/F4DeumPoMbLrfAIAP+wruoJ+JS2bxTtCiUvJKre4jCaVlQcuEh6fVm7XEEJULe8Mb2VZHv7FLlIyc2Dgu9d2eL9eEUcJUTG2BMewL+yK1mGIIni7GUjHkZ15wxjknlqvcURCVCyjSVoFVimKAk3vNi9nJlHbsWBLt58PRvLRxjMaBCbErf166BL7wq9U6O9oiQpSWVlZqKrKn3/+Sf/+/encuXORj06dOtG5c+fyjrlKMdXpCkBNJZXeumMFthVVdHr+h0O8s+4UE5YfKLeYftgXwWu/HKPvx/8UuT3XaMJUxB/PzBwj52NTij1vjtHE3tAEzsWkFDmoX3kM9JeZYywy1vJ0IPwKPx+4WGBdbHJmqeMwmVT+DU0gOdP62Tlk8ERRUZQbZmVoPWMTV92bQLvHrq08trKCoxICLl/N4KnlB3h44R6tQxFFcLTXA7DZ1AmAnBO/aRmOEBUu5ybjRu0Lu8K8v8+RmiUDntuUkd9Brabm5d8mahuLEFbIzq34cezsSrLT0qVLyzuOasuoM1iWH9RvY6vp2uDAnd/dQn0vZz5/tD1t6ngCWFpQHbl4tdxi2na2+GnaD164wogFe9DrFELeu7vAttGL/+XghUS+GtOJu1r4Fjr2ww2n+WpHGABP9AzkrWEtLdum/36CrWdiWfdCrwJ9rW9HfGoWXd7dQq/G3nzzZBfL+uxcEw52hWuxcSlZ1HJ1KHRjba0HvzTf9DTwdqVj/Rr8fTqGJ5eZC4iz7mvJmO6BVp3vl0ORvPbLMZr5ubHhpd4lPi4sPo1HF+3lqV5BPNWrAdvPxrErJJ7JA5tip7+tCTaFKJF2szbTv9k4lhj+gKxkWDXBPC1yvW5ahyaqqGW7wkjJzOVUdDIPdaxLSFwq76w7pXVY4hYe6FCbTYc68o7dEpwSgiHuDHg31TosUQpGk8qbq0/QObAGD3Soo3U4NuFmLaTyC+lX0nKYPqxFRYUkbpdOBz1fhN+fgfN/EegwjPBsD62jEuKWrr9HTsrIwcOpbO7Lb6ZEBamxY8eWdxzVVg0XB6bljONt+2UM1e/j1ZxMMnC0bL+QkM6983YR/v7QQseGxqVSt6Yzu87Hk5ZlZGgbf8sfNb2ucFHl4pV0HOx0+Lo7FtqWazSRnmPE3dGeS4kZxcY7YoH5D6PRpKKqKoqioKoql5MyOXghEYCf9l8sUJD64+hl1h27zMaTMZZ1S3eFs3RXOB892IaHOtVl+Z4LAKw+fKlAwWb5nnAMdjpUFZr5u+Pv4Vhk/DdasjPMMg7X9QW2dceiePb7QzzZM4gpdzcjM8eIm6M93/8bwf9+O46box2vDW7Gw53qEJOURT0v5wLnXX88in/OxPL28FYY7PQ3jSHiShrrj0fx9c4wy7rpv5+0uiC1+vAlAE5HF9/6LJ+qqizZFU4TX1eW7gonOjmTd9adomuQF2OW7AOgfk0XRnWtx/rjUaRk5jCys7krVa7RRExKFrU9nThxKYlXVh7l+QGNuKdNwM0uKcRN/X06lh/u2cSjW/KKUEsGweQQcKmlbWDCpplMKj/sj6BzYE2a+LoB5i7tM9ZcG39x/fHoIo/TXff30WRSWXPsMu3r1iiU70XFmfNwOwIPXeIfUzvu0h/EuH8J+rs/0DosUQrrj0fxw74IftgXIQWpW9h2No6xeZ/NbmXJrjCmDm1e5Od7UUm1GwXrXoHcDJYHrKJ3+BNaRyTELW07c+2++X+rjvPWsBbsDkng7tb+RTboKAslKkiJ8vNkzyAmRzwEYcsAGKzbz2+mXoX2W7n/Ig93rltgXf9PtjGwhS+bgs2Fnhd/VMjNK0jNGNaCDzee4YEOtRnaOoCZa05aChpn3xlCbEomOkUhwNOJ/9t8ls/+Ms/y9/PE7qRnX2sW/MGG0/RqVIvQ+DQycwrO/JeebWTjyWj+OhXLuuNRlvWXr2aw9XQsa45eZtbwVrzww+FiX//kX47RrYGX5fkXW8/zcKe6fLkthPb1ajD998KDm375WAf6NPHhp/0RDGjuS92aBW8ikjNzih0U/tnvzWOcLdkVxpJd5kKRg53O0jwxJTOXaatPMG31CQCGtvFn7iPtScnMwdPZgWe+Mx/f1M+dsd3rY1RVvtgawtnoFD57tF2BIpWCUqAYdb2opAySMnLYcCKaT7ec4393N6NlgAeKAhEJ6ewKSWD2A61xNdiV+MNHSmYOoxf/y7FI8+DRdzS6dsM/bN5Oy/Klq+mYTKrltdSr6cL8f86z41w8AK8ObMLHm84C8Nz3h4lNzuKv0zGEx6fz2uCm3NeuNhevpBOekEavxt5A4Zs8Ia43ZW0o/Ub+hN/vI80rPmoIr18AJ09N4xK265eDkUz9zZynw98fyv7wK3y9o+h8e72m0/6kRYAHM4a1oH29Gvx6KJLJvxyznEdoa4XxTu7SHyT7wAqc7poJ9rf+AkpULonXzQx3+WoGX+8MY1yPwEKf1aqz/C90S1qMyifFKBujKPDUZljYh3rRm3lEX58fjf0tmwPfWMfXYzsxoHnhXiWl8c7aYA5cSOSn/3S75ZfmQhQl12hiy6lrDUjWHY+y3ONfvJLO8wMal8t1FbUaDjKTnJyMh4cHSUlJuLu7ax0OAFsXvkK/qMUANM5cTk4RtcKPH2rLqz8fve1r1XJ1ID7V/IFh6ROdeWLp/gLbnez1ZNxQfCqtB9rXZlVeC5+S+k/vBizcHlri/X+Z2J1OgTXJzjUxb+t5WgW48/S3Bwvt982TXaz+43+94e0CWH3k8k33eeqOIBYXU4TKd2jaXXR4+9Yzp3i5OHBw2l2MW7qPf/Kq1a8ObEJYfDr/nInl8e71WX88ihrODnQOrMm8Es6G0Kl+DZY80Zk2MzaVaP8bBc8aRIvpGwutX/5kF3o38S7VOUurMr6XrVUVXkO+++bt5Ghk8bPpbeh6jGZH37c8T3ghlJo1at52N9nSWn34ErtD4nn3/tbY39CN9dLVDDyd7HExlOx7m8wcIwY7XZm9ltiUTPSKgperodh90rNzee2XYwxp5c/QNv5lct2K8sO+CL7aHsqyJ7qUqmXSG78e48f95rH6wt8fSuAb66w+xy8Tu/PdvxH8lvc3avvkfqVuJVUV3sdav4bAN9ahYGKX4QUClCvk3P1/2Hd5ssLjEMUzmlSikjKoU6P498m3e8KZdsOXibU9ndj1xrUb8etb2F+fM2OSM3F3tMfJoXLdTGfmGC1jnd2uFXsv8OGG08wf3ZHHvv7XqmNLUjTX+n1cFqrCayhgw/9g7xekqQaGZr9HuFrw73VZfRmS/3fws0facV+72mVyTlF1ZWQb+WDDaQa29MXLxcAP+yLwcLK3NFK5kbVDx1jzPpaBZCqJbg++ZFn+n913Re5TFsUowFKMAgoVo4AyK0YBJSpGOVBwsG5rilFgHrPpxKUkmrz5J3P/OmcpRtmTC5jrrXWVGH5c9jnupPG8fhUtlTB0mDCQDajUU2Koo8TRXLlgicmNdNxJw4UM8/Pjy3hG/zvv2S2moXLJcm4ABRMBxPPrzqN4kYQ3iXTXnaSrcoo6SixtlfO4kc5z+t8wfdyMp/VraK5c4G7dXtxJozZxGMhGh4n2yjk6KGeplX6e0f97nw4hX/CO3de8bPcL/7fpFL8eiiQhLZtPt5wjJCaJA2FxfLn1NAB9dYfpqJzhGf1q6iixNFIi6a7L/2Co4kAOBy8k0H3G70X+LBVuPZBdUcUogDFL9rHhxLWWcvndR40mlc3BMSSklt/MkKJyWDKuMz0beRW7ffC/bTgb9LjludfcBqz45stbnvfGAV/jUrKKHeB13t/nmHvDH9PrJxTIyjUSlWTulvzST0dYeSCSRxbtLbB/REI6Pd//m5ZvbSSsBLONno9Npdm0DQRNWc/WM7GWGHeeiy/VxAKZOUa6vPsXHd/ZctOxRRZtD2VtXjdkME+oMHbJPkLjUq2+Zmlk5RpZc/QyV9LMf1Osea1TVh0nND6NmWsKt4K93sr9Fy15JT07lwsJaaiqamkNnL++NB78co+lGAWwOyS+VOcRZUdFx4+55sJF6j9zofp9Z3pTuUaT5f12oxyjieDLyaiqismkkpRx84lQzsemcPJyEm+uPm75fDnv73M8umgvuUUMsh2ZmM5/vj3IHR9sJfCNdZhMKlm5Ru6dt5Opvx2/6bUuXc1g2a4wTCaVBxfsJmjKegLfWEfQlPU8umgv2bkmLl3NoOt7f9F21ib+u+Igf5+OYdWhSJ5efqDU7/HrZeUai/y7cfJyEt/uCefiFfOXfTfmsU+3nKXZtA38G2oewzXXaOLRRXuZ8cfNc1dRTkcn8+bqEyRn5hZbjKovXYernjvfgjqdcVGy+MfwCtffP9xKYlo2k346wp6QBMu6gxcSORWVXOwxOcZbn3/VoUiW7wkvcRzlbfGOUPp8tNXy+UwUlJljZMXeC1y+WnY/n4XbQ1i2O5xRX/3LkM+2s2x3eLHFKDAPHXNjb6myIl32Kgknr7qE1R1O0MXVPGG3kfm59xJHDa3DKsCOXGqQUiAuR7JwI4M4PNFhYqDuAAFKAkuMQ2ioXKKRchkTCk5k01V3igOmJjxitxVHsmmrK1h4CjX5UVNJwVO59Q1gIV9BuBUt+1/hF+uvcZ1Rdn+X/mAV/mf/A/CD1Ye+aLeqxPu+RsXOaGZUFfS/qGRffpnsBoMY+ONV7qlvpG7d+kzbEEGdGk7sfL3/rU8kbJaXq4H/9G5omXyhKANPDWGk3pEP7L8C4PHwN+CfZNQ+rxVqXaSqKs9+f4j1x6PZ+mpfgmq58MTSfWzNazHYwNuFD0e0oVNgTcBcSMrvbpqWncuIDnVYuiucXw9Fsm1yX/w9nBg6dyfnY1PZ8NK1rtEHLyQSl5KFt5uBlMwc/jh6rUjR7+N/6NfUm89HdcC1mNZSC/4JsSw/sXQ/4e8Ppe9HW0nLNvJ4t/q8PbxViX5+qqry9c4wnB2uXSczx4iLwY7leTdMvZt482/oFV6+qwnx1xV5d4fEM+or8w3Of1ccYuPL5m+x9odfYee5eFoEuLN0VxgfPdi2xF1nUrNyuf+LXfRv7sOUIc3JNZrIzDVZfg5zNp1l4fZQmvq6MbFvA976/SQLH+9E94bFFyVvlJlb8MNNfvff7/+NIDPHaOl+/cdzPbl33i7Lfg28XSzLxRXJrSWlj8phqXEwk+x/oUZ6GGx4A4aU/1hSqqoy/psD5BhNLH+yi2atNvOlZeXyyaazDG3jT8f61z5zPff9YTacjGbTy70tY6fle/2XY6w6fIkpQ5pxKCKRjSdjWP9CL1oEFP5mWlVV7pyzvcA6Zwe9ZTzPuX+do4G3Kx9vOsPCxzuiUxSGfLajwP6no1OIuJLGscgkjkUm8e79rQmNSy32S8UZa4LJyjVxIG+80Xx7QhP46cBF9oVdAcwTz/x5Ipo/T1wbA67F9I2sff4OWtU2Dwq9+3w876w7xXsPtKZdXc9if46qqvLgl3ssY5wqCnw3vitLdoUT4OnI7pAEzsfmF/DNBaZ2dT359b89LN3jPt1ivkEbuWgvM+9tSSMfV/aEJrAnNIHxdwQVmU+zco2Fukyt3H+R1349Vmjf6/0woRst/N3ZG5ZASmZumX0RLTRmZ4A7Z8Ayc0uo1Q7TGZ79tmXz8cgktp+L4962AYV+n95Zd4pVhy+x6vAlwt8fyqmoZEYs2A3A/ql34u1WuBX1rWb1NppUJq00/24NbOGHn4f5Bio718Sy3WH0buJNM7+KbZmWP/nIRxvPMOfhdiU+7vt/I6jv5UzPvGFKElKzOBOTQvcGXiXO41vPxPLxxjN8+GAbWgaU7cDz52NTmfvXOV4Y0IhGPm63PqAYn2w6w1c7wqjl6sCBN+8qsO3/Np/lUEQiS8Z1LtTa/2YirqRblks6EfwHG04z9e7mZT45lnTZq0xNQTOuwgf1LU8DM78DKvJDkYo7aTyk3840+xWkqE64KVKpFrcvS7VHhwn7O6dCl/+AnSPob78eXmnfy1aoCq/hekaTSsP/rb/lfg/qt/Gx/cIC617IfpY/TD15oX8jXryzCZ9sOsP864o9xQl/fyi5RhONpv5Z7D7dGtRk4eOdaDvT3FW1R0Mvdl/3jaO9Xrnlt4qPdqlHckYOcalZLBnXmUMXEvHzcGTg/xW8sVvz3B0Fxm1b+/wdHItMYv3xKJ7v34gAT6cib2J2n49n1OKC35p/MaoDNZztC62/GZ0CjvZ6xnQP5MtthX9+Hz3YhkXbQ/lqTCcCa7lgMqmcj0ulsY9rgQ9wS3eFMTNvkPDp97SwFIe2T+6HvZ1C99mFC/NuBjuOzxwEmGc6dXO0Iz3LiL2drkBB7/oudvndFRbvCNV0Rrw7m/sy876WpGTm0NTXzaqiRFV4H2v9Gq7/nVjtMI12urzf3SmXwOBartdOycyhdV439j1T+uPv4VTiY40mlYkrDtIqwIMX7yx6fA1VVYlPzS5w87j22GWW77nA3Efas3R3GHtCElj5n+7877fjrDp0rSie//64PscNbePPF6M6WPbJyDbSfPoGADyc7Au0jvr7lT7sD7/Cwm2hLBrTkQa1XDGp6k3z5Y2a+7sXapGx5rk7CEtIs4wTWq+mc4EbnPIwqKUv9b1cWJRX9LLXK8wf3RG9zjyu6YWEdJ7p29Dy3h311d4Ceb6k3ru/NXc298HH3bFQd+Bmfm4FJpm5cbiCDSeimbjiIO3qejL+jiAaeLvw26FLtxzOAeDPF3vR3P/ae+/Ga0uXPRv3zb0Qtg0Ak6rQIKtwj5jBLf0Y0bEOlxLT6dXEm9d/OWYp4v79Sh/6f7LNsu/QNv68ObQ5Z2NSCfRyps9H/wDm399RXeuRmJbNzDUnebhTXboE1eTv07E42uvpWL8GLd8yf5GT/2UfmL9c+2CDucdFcb9rcSlZqKj4uJWsFYDJpKIo3PLvaf7v+oBmPnw9rnORx99Y6D0ckcj9883FubPvDOHJZfvZed7c0nnR4x0Z2NKv2OsZTSo/7b9I58Aa3JX3Ga6+lzPbJvcr9pjT0cl8/vd5Xr6zCY18XJm2+gSZOUY+eqgtYG5tuet8PE/0DLIUhlrP2EhKZi61XA0cePPOm/4MirLm6GX+Ph1boDX3jf83+T+76+PfeS4eJwc9gV7OZOQY2XAimnlbzzOwhS/P92+Mo72ezu9usToegDeHNuepXg1uuZ8172MpSFW2RLdhCuydD8BnuQ/wf7kPlunpXUmnlS6cifo19NXLNy8lccTU0PLB+IQpkBTVme56841ZnOqBt1L0mDn7TE3JUA300R/joKkxHXXFN4PMd8pUjzjVgyAlmro6cyuQeNUdO4yWlmN7Tc3JUu3pozd/02ZSFXRK8W/j/aYmNFCi8FJuPUufJvQGmBIJdg5WH1qp38slVBVew41UVSVoyq2LUp2U0/ximFVo/Zs5T6C0fohvj1wt0fX6NPEuMJumrfhlYncOXEjkl4ORvDigMfGpWZYCUEXpUM+TVrU9WL7nAq8NbsozfRtZti3cFsLsP08XOuaFAY1ZsjOs2G6Tf7/SB3u9jl4fbsXP3ZHo5Ezg2oeok5eTGDr3WsGuR0Mv/nd3c+75fGeR59PCW8Na8ETPoBLvXxXex1q/hutvvr25yn7HZ8xPGvSFMeZu5kt3hVHTxaHMx0dJzsyxjKu4+43+eDjZs/54FB3r1+B0dAp3Nvctdnahv07FMP6bA0DRN3FJ6Tm0nWU+95ePdWBwK/P4Mfmvt309Tw5HXAXggxGtef3Xgt3fjr41kO//jbDcKIK5wP7j090tzzu/u4W4FHOLyevHCb2RnU7B2UHPc/0b8d76wu9ta/Rv5sPfp2Nv6xzlIb9AdD42lTvnbLv1ATfharArNs9d79iMgQCcupzMyBu6gFtj9xv9CfC8VgyVgpTtvoYimYwwq6bl6WZjRybkTKKkjQ/uauHL5uCYW+739vBWPN6tPmOW7GN73mej8XcEFTnRUv7YiTd+blv3wh20DPDgfGwKd87Zzkt3NmZk57qWL6Im9AoiKimTYW0D6BbkhYezfaFz5xpN3PP5Tmq5GljxVFfLeqNJ5UJCGmOX7mNkp7o8179xgd/1r8Z04q4Wvnyw4TQL/gmhV+NadKxfg0+3nGPVMz3oUM/canTtscs89725IP7u/a0sE50AjOxUlw8ebGN5np1r4qf9ESzeGcbScZ05cCGR134p3GLRzWDHj//pRssAD1RVJceoWnJ/67c2kpKXDxY+3pH/5A0R88dzPbl4JcMyfMLMe1sytkdggYJZfoyju9bnVs7GpKDXKXy65RxrjhYeu/jo9IGExKfy474IXryzCT3fv/bl4CcPtaVfM59bjlUc6OVMeELpvkBwsNNx9p0ht9xPClK3UOkT3U+Pwak1AGw0duI/OZNu63S1iWOC3TrG2ZVuEOvbscp4B7mqnlNqPTyVVB5ukIurg8Ivp7NYahxMrOpJJg54kYy3kkQm9hjREal6U0eJI1N1IFCJ4ajakGzscCeNUb1b8uX2C4CKGxmkUJLuJyreXMUOE65KBufUm09F7EQmRvRkUzjBFkfBxHDdLg6qTYhQrZsxw57cIgeyr7xUDOQwXL+LZkoECir7Tc3opDvDI/qtOClFfxi+qTF/QIM+Vh1S6d/LJVAVXkNRHv5yD/vCr5RgT5VfHGbSSXe22D1OmuozNWc8J9VActBjjxEjOkxVbBhEBRPqDa/JQDZZ2FNRrWW/GtPJPGaKnzu/Hoos1Tkc9Dqe6hVUZOu26z/EVWbWfptZFd7HWr+GG2++h+l287nDPPOTViM42+szS2vE/s18+GJUB5wc9CUacDq/FWAjb1d0OoX41CwiEzNoFeDO7pAEgmq50Ov/27vvqKjO/A3gz51hGNowSO8IKCLFAihiYo9EozFGk5hojGY3xRR3bZvoppi20V+y6WqaMW2z0TTdJBqNGjVGsZdYsCKCCkiRLmVm3t8fI1dGZoYiZcDncw7nyJ07w72v3IeZ733La5sAGK+Bh7/YY/L86UO74L6+wXjyv/vw15vDTBYRWLn/HGauMN7ge+2uHujb2R2dPa8OKTVX2H1xTDTmm5mD6MGbOuPTbelWz6XGhIQgrNiT2aB9byTeGjVeHBONx66sJNwa+od7IPNSOTILmj6qQAk9Ugdsh/3u9wE7R+CWF7BaORhPfH81R1mQav+ErhLSK94m27pUfAFdM34GmNq/MxI6d5KLNdbMvCUCp3NLsSMtHxdLrk4DoFRIuCsu0CRjLC16pVRI+PuwrpjcLwSdnI03l4UQeHbVYXy1MwMAsOuZYfh6ZyYSw9yx6LdTck8mALi/XzD+syPD5DV7BbnhQGah2WMeGOGFD++Px9+X75dXmjdn1zPD5J5cYxdvk1/PW6M2OVdzhkf5ICO/HMdzSjA+LhALx8eiawN7lUb6anBPQhDeWn9CLmDVdmbBbZAkCTnFFbj9vT9wsaQSnz3YB4O7eZvcHGkKjYMdFk+MwwPXsYgXAAzo6omnR0RavFHY3FnEgpQtBt01Q/cAoGfFRyhCw7usj+jiiMXS61Bmbq9/52tUhw3D5Nz7cTRXBzWqEKc4iVI4YpshBjUfiuyggz10KIcajfmgVPML/NraY8gqqoCniz2WbUvHv+/ugYQQd4xdvA35VybsdHNSobDc2O385i6ecnilLxyFHw9ekLuJ24JxcQEmXewB4OkRkSZ3NOtjLXyvlyQBY3r640ROqdWJEFuGQKiUjR7SafRVHEekcwniKy0E5ZSfgNCWWcHBVnWEc7BECIF7PkzB7vRL9e8MgXdUi3GHsvGZ1RhnDd4IUdjeXX1qeU9WTUcpHOCCCqSKYOihwGWhRj5coYeiTjFw+SP90C+sYfNhdYTruK3PwdxKid/ZvyAXq4vduiMue578wW1yvxC4ONjh/c2n8debQzE7OQIHMgrx86EsPDuqOxzslFBcmQfojV+P473fTuGvN4fiudFR6PrMGlTrRYN7+YR6OiPM0xkbr+x7ZsFt2Hw8F2sPZ5stCtV+s157GMxVpm+9lTBAD6W8uImvdAkSBHKFG7RSGXKF9sqzJFRBBWdcRpR0FgXQQA8FioUzSuGIKOksUkXwlQVbAG+pEEXCBVWwwwTlJgRKeVhviIcLLqMSKqhRjZMiAM/bfYlq2CFN+KGn4jR+1/dACZxwXnjCAAmXhAalcESAlAc3lOIW5V6cE95wQCVK4YgBikNQQY+f9Yk4KMIRIOVhp6E7xit/hx8KcAEe8MElHBPB6KM4hiLhgol2v+Fz3XDkiE6wgwHFcEKm8EKEdB4r9TchUpEJFXTIEN5IVKSiQLjiuAhCT8Vp9JWOIUyRhRX6wXBHCdSoxhERgktCgyjFWeQKLQ4bQhGsuIgwKQuHDKHIFW7QSOWogD36SMehhwLZcEe5UOMSXCAgwRkVUKMaflI+KqGCDnYIli4iXLqAXYZuOCpCkCCdQCkccVG4QQGBccqtkCBwXnihmyIDxw3BcJeKMUKxW+7p/qFuFB61Ww29kFAIl0b1WH9bNw5v6+7C0gcScEtU/Tc72/o6bg4d4Rys6Tz3Z+xUPwEfqVDeFl/xPvLRvPMXtbbufq4Y3cMP5VU6LN5U/3QLreX9SXGtWqCuj5O9EsHuTogN0OLbvU278dfShkf54OMHEixOw8GCVDNoF0FXehF4Nw6oMv2jNbXqKfxhiDGppGtQjmUjHdFn06QGvfRxu0icDb0b+i634u8rT6MKdnC2t0NZlbHqnb5wFNJyS03GKV/LQaVARXX9K7Jdy9wvcO27m0IIHDpfhE3HcuGlUeOfV1ZuSV84CttP5yHEwxkBbo6o0hkQ8ezVSnVXbxecvFj/ylLj4gKwM60A582sUtCncyezH5xrd6H//rEkLPsjHasPZZnsk75wFPJLKxH/inE87tanhiDI3anOG2yN2g5fPpQIdyd7nMgpwUO17sImhXlgRIxvnbumSybFIdJXg//syMCybWewdsYAjHjbdHJRc/qHe+D526NMJiYUQmDyJ7tM7kz0C3PH0il98NPBCxjSzRv9Fmys81r/uLUbii9XN3oFRGuWTU3A0Agv/PjqfRijW3v1gcdSAJ+oBr1Gu7iW69ERzsGaimo9Fv5yDJ9tT2/wc8Kl83jSbhXuVG6rf2eiZpQrXDG48i2UwThspqHLcXeE67itz2Hv2QKMfz/FZJsSeuxSP17nA/zEqn9iuyEatW+IjY8LlHv1xQZokZ5XipfviIY38jHv2734t+oDHDaE4kHXPcguMxZ98oUGHlIJCoQL3KXWWZ2SqEn+kQY4118gb+vruDl0hHOwpvPc1VBBhx3qJ0yybbs+ClOq57azERPUEd0T44rXVB8BqT/K216vvgcf6UejGnYsSDWHdhN0eh3wbi+g6Pq6ZAuFHXbcuR39YiIsTipXMwljzd1DAMgsKEfyW7/jcrUeKx/vj+5+rkjLLYODSoFQT2c8+uVe7M8sxM/Tb8b203lyl3UA+OD+eIR4OGHG8gM4nmMM24be3alRpTPgsf/sRWKYOx4ZGF7n8R1p+fJy7WcW3Ibn/3cEX+4wrhCz77nheG7V4TqFo6Mv3YqsogoMq1Vs+3XmQDiqlPB2VaPbs8bCyF3xgYj01WBCnyBoHFRYujUNZ/LK8MrYGLkNC8ur8MGWNIyLC5BXuymv0kFtp5RXZ6kpSK18vD96B9ddNfHXI9l45MrwlVVP3IReQW4m3f9PvDLS7LwV6XllWH0oC6+vOy5v6+ajkdu6pk2sTSIY+dwvqKg24B+3dsMTQ67OG/PW+hN4Z+NJvHF3T4yPD0RRebU8NnxPegHu+iDF0ks2yr/v7gkJwOxvD2Kn+nGTO0V4dCvg18PSU2Xt5lq2oiOcQ0OY6/3QUFFSOnoo0vCAcj38pTxUw87i3G1EzSGu4gMUwLXeHK3REa5jWzgHczmhhB5fqBbiJmXdIW5EHUVO9EPwGfAg4HtlVdaDK4CVj5juNOMw4BZk9XVs4Tq+Xh3hHKwZt2Qb9l2ZN+4e5Sa8dmXV4dper74HP+gHIA9aFqio1dijGiccpljd59/Vd2PWyx/LPZAtYUGqHu0u6M5uBz6tf/KwOiZ8BXQZBqgatlpMQVkVOjmpTN586/QGFJRXNWg1hfc2nsQb609gUIQXPv9LXwDGHjmLN51CTIAWg7t51/MKjWMwCMz85gBCPZ0x45YIAMB3e89BbzBgQp9gVOr0WLLpNN7ZeBLTBoVj1vAIubiz6fhFPPjpbgCmd8B3pxfgl0PZmHNrhMnS6031y6EsnMkvM5ko+FpCCJRU6uDqYCz6bDmRiylXxv5aq0AXlleh10vGSeu+m5aEhM7uWLE7A//dlYmlDySYXQq2tsyCcmw/nYc7eweaFL3MrQZUw2AQCLvSdfO9+3ojJS0fv6VexD9Hdcfb608gLa/M6s+0ZopyHV5UfX51w7O59U503u6uZTM6wjk0xNe7MjDvh0P179hIwyK9oXVS1Rkya4kaVQiXLuCo6Gz28X/c2s2k0GuJufme2pICBhggoTFDqB1QiQpYzwlbdXd8YJ2u7sdfGAx1VRHg6m+6s74aqC4HqsoBQzVQcAbY8wlw9H+odvFHjl0A8gry0Uth2gP0D3003g18A59O7QNntfW/Bx3hOraFc9iYmoNnVh6WJ8KvLVw6j49UbyJckWXmmbbrknDBfkMXOEsViJLO1lm9+GPdbXDBZdyi3IdM4YU9hm7y/HiOqEC+0MJeqsZ54QklDEhW7MElaJApvJBmMM5l5SqVI1N4oQL2iJDOoa/iGD7U3Y5eilMoFk4ohwMEJBwXgbgs1HCQquCAKnS/MgdkPlyRYoiGARL0UMAV5eihSEOm8IIG5YhSnEWZcMRJEYAS4YQseMAF5egsZQMAjojOcEU5qmEHJQxwQCUCpTycEgHoJmXAAAWOiWC8eV8fFFYIzFv5JwQkOKAKnlIxioQztFIpfFEACcahht0UGdhniMARQ4g8lClMuiAPH6yECp1QggApD8dEMAQkOKISrihHOdSIU5xEkXBGHrTwQDHiFCeRIzqhEir8YYiFHfTopziKUyIAFcIeAVIevKRCXIYahwxhCJMuQCEJXBAe8EMBHKUK5Ah3XIY9nFGJUjggWLqIg4ZwVEOJy1DDDnr44JI8HNAV5SiGMyQYoIRxVIEeCmhwGX8uvKf+Xx4hgBfdjP92CwEe217vipO2cB1fr45wDtaUVerkVe4A4/uS3erH4FrPyuZ/GkLxpu5upAk/ZAifK3NMNn5BILqRCQRKecgXGiQqjiFSysBo5Q7EKNIb9SrFM9Lg6ma9xyYLUvVot0FXWQrs/xLY8CKguxpapWEj4RKVDESNBZzcLT+/hekNAnvSC9Aj0A2O9tYnGG1N1XqDvPxmbav/zIKniz0SGzhHSGsRQuC1dccRG6DFbbF+VvctLK+Cg0pZ74SuzanmDvb3jyUhPsQdBoOQq+TJb23BiZymD3tId5ho/MfY94FeE+vdv91ey7V0hHNoqNqrTTVWvzB37EgznSQ9KcwDXz/Sz+IY94YIcHM0GcK7YFwsVu4/j11nChAboMWh8w3rifXowLBmHdJ6I0uZN1ReycecId288OmDfXEwsxB3LDYO6/z0wT4Ych03PWpy7XHlKjyl+kbe/nL1JMyZ/169f9M6wnVsS+dQX4/KWCkNz6i+ggsum30jXS2U+EQ/EhWwxxFDZxQIDTKEN7ylIpwUAY1asIQaz9XBDsUVdSfzTV84yuSm241q2qBwzB0Z2bCdhQDO/A4ExNdbjAJs6zpuqo5wDtaYX4lYIFo6i9dUHyJacbZVjqNCqOAgGefq/V5/MyKlTPlnZ4tOcEOp/HiNcqGGk3R1QvBTBn90UVzAen080oUPBir+RDfFOewzdEGc4hTyhCs8pWK8UX0XzgkvPGi3FoXCBQOVV29QphqCAQDbDNHQwQ7T7IwLe1UKO6wz9MEl4YJuinPoLGVjnT4B9yo3oxJ2+N3QE7lCiwft1qFcqPGLoS/2GiLgiAr4SQUoFs7QQYHuigxESWfhKFXCBZdxXnhhnSEB+w1dMUqxAxWwR5ziJI6LQOQIdwRLF+GCyyiCM8qEGpnCB/5SHn439EBfxTE4oRIbDHEYo9wOR1QhX7giQ3jjlPBHX8UxVEEFfykPeqHERkMczgvj58xQKRv9FKkYqtyP7/UDcNQQAgUE/KR8qKAzee9R83+QIzqh55WbZd/oBuEeO+MInzX6vrhN2bAcrf3/3CgTvwEibkVJRTVyiisw9a3v8Yf678gVrlA8sAoe4fFWn86CVD06StD978B55JVW4a83N3xpaqLrFfHML6jSG3DohWRoHEzf1FdU61Fepcdt72w1e4e7IUK0dtgy79YG7dsRruWOcA6NUXulk8n9QjB9WBdUVhvkFa7M2Th7EII6OZnMGwdcHeYKABeLK9D31brzn1kzoKsnvvhLX6w7koNp/zEOnd31z2FwdVThz3NFiA/phJX7z2POt1eHI+96Zhj6/sv059grFTgwfziinl8Hazo5qXCpvOFvCmYPj8Ab6y2vPljj3j5BWL67/qHdfUPdseuM9ZUPI3xcrquoPH1oF7z326kmP//RQWGYN7K7xXkMv3ooETd18ZS/P51bioyC8usqRgGmyzl3lc5hvfopAFfefD91FHD2tPb0DnEd29I5vPLzUSw1s0Q5Nc4t3b1RVqlHSlp+o57n46pGTrHlVai+eigRvYLcMHbxNrPzdx57eQQin7s6N2SopzM+fiABXbxdTObbbIhof1ccudC0xVieHdUddycEQZKMdZ2eL5q/IRLpq8GyqX3w9a6MBuXXjFu6olJnwPtmVhK15vHB4fjHrd0aNAy4qWzpOm6qjnAO9bnvox0Wr0sJBoxW7EB/xRGMVW5r2srVRE0goIB09zIg+s46j3WeuxohUjayhAdOLBxb72s15jrmoNR27I5eAW19CHQD2v/8cFTrDXWKUQDk3lqrnrgJ645k445e/tidfqnOEtrWnC3S4eiFYkT5d8w3ITe6J4d0wUNf7MGdvQPw8tgYq/sOivDCB/fHy71TXhwTjX//ehxLJsXB3dke0f5XV6TxdjUdVvzz9JstLldbY8mkOEiShBExvjj1r5Eoq9JD62j8ve4bauxteld8IBJD3bFs2xkkhnqYHb48d2SkxSG+vq4OsLdT4MU7ojGkm3eD59Ia0NUTfx0QWqcgtfuZW3D/0p3yfHE/PXkzYgO1CHJ3sjrUcOG4WNwVH4jiCh3iXl5vdp/XxvfA3QmBZu7cAs5X/g9qFr8wZ0g3L8xO7oZ7EoLw3m8n8c0e0yF1vq4OdQrVv84ciOS3fgdg/NA6b2R3AECYlwvSXr0NizedQu/gTrj/k50AIM/PVyPcywXhXg1fgdaSNyf0knPqpAhE54qvMN/uC6zWJ+K7eopR1PymD+16wxakpg0Kh6eLPV5ZnXpdr9M/3ANLp/Sx0BvDunkju2Pv2UvyvJwv3B4FR3slunhrUFJRLReF188ahL7/2mCyhPo3jybV6bW9YdYg+dr1cFEjZd5QvLI6Fb2D3FB0uRq70wtwILMQ/m6OGBHtiyVXCj1/PD0EgZ2csPdsAXaeKUBiqDsuFldaXTFrzd8GwEujRkZBOXoHuZmd5yQu2A1vTegFraMKdkoFHOwUsFMqMDu5G6L9XWFvp4DW0R7j3zeu+vr9Y0n4YEsa1l9ZYl4pSbgp3LPegpSniz3ySo3FBDuFhMlJIS1ajKL24+tH+pm8H3j3vt745w+HMDLGF9/uPYefDP3xk6E/Fmv+hnG9A/Dub6dgj2r8PtUHPkeWQXd4FTbrYqFGlUlvo7ZULJzgKpWbfaympxS1vsOGznJP4oXV98JRqkQnlKJHgAsc4yZAFXoTPk/JwP7MQnw7LQlqO8s9ws8K3xY5RhakiKhR6ptLBQB8tQ6Y0r8zAOMd2uQoH3hp1Jid3M3ih+Habl/0B06/etv1HirZoFuifLBj3jB4XzNHmbdGbfKhBgAWT4ozGSo1pX9nTO4XYnEixXAvZ5zOLcPIGF/EBGhx6l8jUXi5GgpJwvP/O4wJfYLw9a4MrDmUjcUT40yKqnZKBbSO5ueECnJ3wvzbo+Xvd8wbhuFvbUFJhQ5dvF1wd0JgneccnJ+M0kodAtxM5/B7595e+PvyAybblAoJi+7rbfIha8mkODhe86HORW0HL40a62YORElFtcnxPzGkC97ffBqlV3r51O6NFeXninv7GrvEuzvbmxSBavPVOkCSJGyaMxjzfvgT/ze+B7KLKhDk7gR3Z3tkF1VgQ2oOxvTyx2+pFzG31pxgx14eIX8IDXJ3wv+N74E7egVgy4lcfPR7GhxVSuz457A6K6RG+Giw99lboBeiTrFPoZAwfVhXk21OLTQcfFikNyJ9NTiWXbMwhIQXddYn9qSWU7OQRkP8bVhXvLvxZAseTfObkBCEFXsyEemrwSMDwzDrm6u9MO/vF4zATk5mC1INGUb834cTkVdahUFdvQAAkiRhTnIE/v3rCYzt5Y9VBy4AMC7yMuj1zeju54p9Zy/BIATKrxScfbUOmJPcDeVVeoyPD0D/cMtFWXdne5Psrinmf/xAAh7+Yg+i/V3rFJL9tI5YPDHO7OsJIeCrdUCkrysCOzkBAOJD3BEfcnVKivSFo/DOhpNYcygLr46LkVdnDHJ3lG9mmZsHc2r/zvhsezqeGhGJEA9nsz9/RMzVqRK+frgfgj2cEODmiI8fcMfc7//Er0dzMDExGO7O9vh2WhKC3Z3w3d5zdW4ILJ4Yh5u6eGDhL8dwV3wgYgK0rTq9Atm+B5JC8EXKWcweHoExPf1xW4wv7JQKrD2SjZIKHe6KD8TckZHILqrAu7+dglbjAt/IJCAyCXbjPkJipQ5vrDuOn6r0eHlsjEmvxNnDI3BLlA9GvmO6KveTQ7pg1vAInM4tRbiXC3acycdPBy/gu73nUK03DppKXzgKeoOQr1shhFxItXZTLTnKB79eKdpa0ztIi8OZ+SaTtUd5qXEqtxQKGNDV3ws//SXSOAeyygmQJHS+UlR/4fYoONnbYceZfPzfuBioJOC297YjNbsICgh5LjkdlFfm1xLo6uWCCE97ODk6ori8Ap6uzvh2VxpU0KH8yjyaapUdKqt18Ec+CuGC58b0xHM/HoUOCkRKmcgUXiiDA4Z3dcNr9/ZFr5c3wBVlKIODPHddATSogD3UqEYlVJAg5NfbPncoei7cDiUMcEUZ7KBHLjrBHcWYOaYfnvvxCKzNAVp7TuGR72xFalYxege7YUxPf4zu4Y/H/rMX3q5qzB3RHZ4ae5y/dBldfTTy/5e5vx3pj119zRfvsH6DuKVxyF4H7QpKZKv6L9iIC0X1D+dr7iVFbVVHOIfmkF9aicMXijGgiycuV+sbVPi8VnZRBX46eAH39AmSezpdS28QuFB4GUHuTtd1vObmpjtyoQifbD2DWckR8gcpS2qGvv705M2I8HWBvVKBuz9IwZ6zl/D2hF4Y29vYA/btDSfwy6FsBHs4YcYtXU16hV3rYkkFnlt1GJuP5+LTB/ugsLwab60/gUUT49DNV2Oy7+JNp3AgsxBv3NMT3+05hyq9AY8ODGvU3fvab0wtXa9VOgNW7T+P/l085DaZ+PEObD+djxHRvvhgsvU5CGof77lLl/HqnTEt1sNAbxCYseIAfjp4wWQ7s6htNLQ3YfrCUZj9zUF8v+9c/Ts30MgYX/xyOLvZXq9GvzB3PDGkCxJDPbAhNQf9wjzg7myP51Ydxpc7zuLRgWGYd5uxl+Dfl+/H/w6Y/i5G+bniaJblXgafTu2DIZGWh68KIfDHqTx09dbAV+uAar0BdgoJlToDhABS0vJwMqcUjzQiC07mlGDEO1uhN1z9MFtDbxCQgHpXY7peK3Zn4EBmIebfHm216COEQGmlzmwP74bS6Q2wMzMvqRAC207lo5OzChcKK3BLd+826Q1la9dxU3SEc7geF0sqcCyrBAO6esq/Q6culsLHVW31dzct1zh81s3JHu7OxsnOj1wowqh3jb3FHVVK7H9+uNlrZNS7W+Whsdb+5q07ko053xxEQCdHzB0ZibJKPZ747z5MTAzGq3fGNii3Xx4bg+dWHQZg7L0dG6hFiIcz9qQX4O0NJ/HaXT3k1ctr3L90J84XXsa6GQPrrD5eUa2Xi3GPDAyDSilh8abTeH50FO7rG2x2DsjaxzmgqydeGBMtr8B+UxcPfPWQcX7SqZ/uwtaTeRgXF4A37+klP6ffqxvlHt+7/jnM6pQRa/42AFH+rmbb5ufpNyPCR1NnSgrAWDzMLq7A3JGR8HS5WmDPKa7Aqv3ncU9CEDo5W5/U/q73t2PP2Uv4150xOHqhGF/tzJAfa8h7m9oa8p6vtnY3h9SSJUvw+uuvIysrC9HR0Xj77bcxYMAAi/tv2bIFs2bNwpEjR+Dv74+nnnoK06ZNa/DPu9GDjqgtLfzlGD7YUv+8C231IZB5RK2hoKwKFwovIybgaoGp5s/x9X6IsfSBqbl9/Hsa/rUmFQeeHw43p4av9FNUXo11R7MxMsb3uj4YtpTab7qc7JU4+tKIep/DLGp+jSlINWZ/S3oGanHwnPEO8q5nhmF/RiEe/XKvyT5v3tMTI2J85fniFk3sjZd+Olqnd2eAmyNKK3UoulyNRweF4UKhsVi+9akhZovhBoNA5qVyBLs7yde/EAKLfjtlMmz3vw8lYuLSnfL3s4ZH4M0rjw/o6okv/5p4XW1wPVb/mYVgdyfEBloumlPLYxbRtWqy8fW7euDuhCCz+5zJK8NLPx3BE0O6IKFz4xbIyi2phKeLPSRJwqtrUvFRrQVeXhkbg2dXHcbckZH4bFs6gt2d8N+HE/HR1jQkhXmgd3CnBv0MIQQMou6w/RqLfjuJ/RmF+HByfIPe/3y27Qxe+OkoRsX6YfEkY2/Nw+eL8Pn2dMxO7gZf7dUe28UV1dCo7Uzem20/nYf7l+7Es6Oi8JebQ6HTG/D2hpNYtMk4B11SmAe6+Wow//aoOr3Lov1dMX1oVwzu5iUXBy8WV2Dqp7sR5O6IA5mF0OkFtj495LpXfC+v0iE1q0Qevnw6t1QuvLEgVcuKFSswefJkLFmyBDfddBM+/PBDLF26FEePHkVwcHCd/c+cOYOYmBg8/PDDePTRR7Ft2zY8/vjj+PrrrzF+/PgG/UwGHVHb2Xu2QO5eP31oF3y9K0OeY6G2tihIMY+I6J4PU+TJ3701aux65pZ6n8Msan5HLxTjtneNw01G9/DDz39myY9NSgyW7/ReW5DSOqrwyMAwkyFUx18Zgb7/2oiiy3UXFXjpjmjcFR8IBzsl+i3YCLVKgc1zhsgffE7mlODej3bgscHheGhAGADjh5H9GYV4bFA45nx3ED/sO2/ymgeeHw6VUoGD5wqRGOoBhQRU6gyNHrJVXFGN0e/+gWHdvTEnuRuc1XaYteIAfth/HgvGxeLu+ED0emk9Sit1eOH2KEy9iYvc3OiYRXStvWcvYdeZAjwyMMxiQac5fZGSjuf/dwSAMZ+LyquhdVJBpzdAqZBsYh41IQSO55Qg3MvF7ErsDVGlM5j01qo9X9+GWQPRxdu0l9fSrWlYvOkUlj+SVKfX+rXHpjOIJh9XfbadyoOni9rqMZjT66VfUVhejXAvZ2ycPbje/dtVQSoxMRFxcXF4//335W3du3fH2LFjsWDBgjr7P/300/jxxx+Rmnp1bP20adNw8OBBpKSkmP0ZlZWVqKy8evequLgYQUFBDDqiNpKaVQx/N0doHVUmHzpqa4uCFPOIiHR6A7o8Y+w+H+DmiG1zh9b7HGZRy6jU6XGxuBL+bo74/UQu/N0cUVhehb6h7vh2zzn0CnaTh3bsSS9AalYxJid1BgD8cTJPngw/feEo/N/aY/Ik1N8/1l+esHrl4/3lu/Q6vQEA6txhrz2HyrWKK6rx1Y4MjO7hh5X7jYWpv10z99n1MPezaw8ZvlB4GbvTCzC6h3+rfNgk28YsorZW0/sIaHwvnPbuWHYxLhZXYmCEl9nHrf0tsXWnLpbgwy1pmD60K4I96p/2ojFZ1PJ9+q2oqqrC3r17kZycbLI9OTkZ27dvN/uclJSUOvvfeuut2LNnD6qrzS+nvWDBAmi1WvkrKMh8d0Uiah3d/VzlOX6i/F1x6IVkHJx/9bpOCGlYF97mxDwiIsBYjIi+MjHy2N7+rf7zmUVXqe2UCHJ3glIhYUikN7r5apAY5gFJknBPnyCTeUYSOrvLxSjAOA/IwnGxWPl4fwDGHrlPj4jEhlmDEBfsJu9XewidnVJhdriHtQ8Qrg4qPDY4HEHuTvjbsK7NWoyy9LNr3zn3d3PEHb0CWIyiZscsoqboEeTW1ofQZiJ9XS0Wo4Drn5KhLXXx1uD1u3s2qBjVWG1akMrLy4Ner4ePj4/Jdh8fH2Rnm59MMjs72+z+Op0OeXl5Zp8zb948FBUVyV+ZmZnNcwJE1Cw0DipoHVU4OD8Z70+Kw38eav15MJhHRFTjP39NxPuT4vD3YRGt/rOZRc1DkiTc2zdY7v3kZG+HxwaHo4u3CyRJws/Tb8Z305JMJosloquYRdQUccGd8Plf+mLznMFtfSjUTlzfTFnN5NpqYX3d2cztb257DbVaDbWabziIbJ3WUYWRsX7179iCmEdE1MnZnlnUwdVeUICILGMWUWMNstJLiOhabdpDytPTE0qlsk6V/eLFi3Wq6zV8fX3N7m9nZwcPD48WO1Yi6tiYR0RkC5hFRGQLmEVE1BratCBlb2+P+Ph4rF+/3mT7+vXr0b9/f7PPSUpKqrP/r7/+ioSEBKhUtrd8NBG1D8wjIrIFzCIisgXMIiJqDW1akAKAWbNmYenSpVi2bBlSU1Mxc+ZMZGRkYNq0aQCM44ofeOABef9p06bh7NmzmDVrFlJTU7Fs2TJ88sknmDNnTludAhF1EMwjIrIFzCIisgXMIiJqaW0+h9SECROQn5+Pl156CVlZWYiJicGaNWsQEhICAMjKykJGRoa8f2hoKNasWYOZM2di8eLF8Pf3x7vvvovx48e31SkQUQfBPCIiW8AsIiJbwCwiopYmiZqZ5m4gxcXF0Gq1KCoqgqura1sfDhE1UUe4ljvCORDd6DrCddwRzoHoRtcRruOOcA5EN7rGXMdtPmSPiIiIiIiIiIhuLG0+ZK8t1HQKKy4ubuMjIaLrUXMNt+eOnswjovaPWUREtoBZRES2oDFZdEMWpEpKSgAAQUFBbXwkRNQcSkpKoNVq2/owmoR5RNRxMIuIyBYwi4jIFjQki27IOaQMBgMuXLgAjUYDSZKs7ltcXIygoCBkZmZyHPM12DaWsW0sa862EUKgpKQE/v7+UCja5whk5tH1Y7tYxraxjFlkill0/dgulrFtLGMWmWIWNQ+2jXlsF8vaKotuyB5SCoUCgYGBjXqOq6srf2ktYNtYxraxrLnapr3eAazBPGo+bBfL2DaWMYuMmEXNh+1iGdvGMmaREbOoebFtzGO7WNbaWdQ+S+dERERERERERNRusSBFREREREREREStigWpeqjVasyfPx9qtbqtD8XmsG0sY9tYxrZpOradeWwXy9g2lrFtmo5tZx7bxTK2jWVsm6Zj21nGtjGP7WJZW7XNDTmpORERERERERERtR32kCIiIiIiIiIiolbFghQREREREREREbUqFqSIiIiIiIiIiKhVsSBFREREREREREStigWpeixZsgShoaFwcHBAfHw8tm7d2taH1KJeeOEFSJJk8uXr6ys/LoTACy+8AH9/fzg6OmLw4ME4cuSIyWtUVlZi+vTp8PT0hLOzM8aMGYNz58619qlct99//x233347/P39IUkSVq1aZfJ4c7XFpUuXMHnyZGi1Wmi1WkyePBmFhYUtfHbXp762mTp1ap3fo379+pns01HbpqUwi5hFzKK6mEWtj1nELGIW1cUsan3MImYRs6iu9phFLEhZsWLFCsyYMQPPPPMM9u/fjwEDBmDkyJHIyMho60NrUdHR0cjKypK/Dh06JD/22muv4c0338SiRYuwe/du+Pr6Yvjw4SgpKZH3mTFjBlauXInly5fjjz/+QGlpKUaPHg29Xt8Wp9NkZWVl6NmzJxYtWmT28eZqi4kTJ+LAgQNYu3Yt1q5diwMHDmDy5Mktfn7Xo762AYARI0aY/B6tWbPG5PGO2jYtgVnELGIWmccsal3MImYRs8g8ZlHrYhYxi5hF5rXLLBJkUd++fcW0adNMtkVGRoq5c+e20RG1vPnz54uePXuafcxgMAhfX1+xcOFCeVtFRYXQarXigw8+EEIIUVhYKFQqlVi+fLm8z/nz54VCoRBr165t0WNvSQDEypUr5e+bqy2OHj0qAIgdO3bI+6SkpAgA4tixYy18Vs3j2rYRQogpU6aIO+64w+JzbpS2aS7MIlPMopXy98yiq5hFLY9ZZIpZtFL+nll0FbOo5TGLTDGLVsrfM4uuai9ZxB5SFlRVVWHv3r1ITk422Z6cnIzt27e30VG1jpMnT8Lf3x+hoaG49957kZaWBgA4c+YMsrOzTdpErVZj0KBBcpvs3bsX1dXVJvv4+/sjJiamQ7Vbc7VFSkoKtFotEhMT5X369esHrVbb7ttr8+bN8Pb2RkREBB5++GFcvHhRfuxGb5vGYBYxi6xhFtWPWdQ8mEXMImuYRfVjFjUPZhGzyBpmUf1sLYtYkLIgLy8Per0ePj4+Jtt9fHyQnZ3dRkfV8hITE/HFF19g3bp1+Pjjj5GdnY3+/fsjPz9fPm9rbZKdnQ17e3t06tTJ4j4dQXO1RXZ2Nry9veu8vre3d7tur5EjR+Krr77Cb7/9hjfeeAO7d+/G0KFDUVlZCeDGbpvGYhYxi6xhFlnHLGo+zCJmkTXMIuuYRc2HWcQssoZZZJ0tZpFdE87jhiJJksn3Qog62zqSkSNHyv+OjY1FUlISwsPD8fnnn8sTnjWlTTpquzVHW5jbv72314QJE+R/x8TEICEhASEhIVi9ejXGjRtn8Xk3Qts0FbOIWWQNs8g8ZlHzYxYxi6xhFpnHLGp+zCJmkTXMIvNsMYvYQ8oCT09PKJXKOlW+ixcv1qm4dmTOzs6IjY3FyZMn5ZUcrLWJr68vqqqqcOnSJYv7dATN1Ra+vr7Iycmp8/q5ubkdqr38/PwQEhKCkydPAmDbNAazyIhZZB6zqHGYRU3HLDJiFpnHLGocZlHTMYuMmEXmMYsaxxayiAUpC+zt7REfH4/169ebbF+/fj369+/fRkfV+iorK5Gamgo/Pz+EhobC19fXpE2qqqqwZcsWuU3i4+OhUqlM9snKysLhw4c7VLs1V1skJSWhqKgIu3btkvfZuXMnioqKOlR75efnIzMzE35+fgDYNo3BLDJiFpnHLGocZlHTMYuMmEXmMYsah1nUdMwiI2aRecyixrGJLGr0NOg3kOXLlwuVSiU++eQTcfToUTFjxgzh7Ows0tPT2/rQWszs2bPF5s2bRVpamtixY4cYPXq00Gg08jkvXLhQaLVa8cMPP4hDhw6J++67T/j5+Yni4mL5NaZNmyYCAwPFhg0bxL59+8TQoUNFz549hU6na6vTapKSkhKxf/9+sX//fgFAvPnmm2L//v3i7NmzQojma4sRI0aIHj16iJSUFJGSkiJiY2PF6NGjW/18G8Na25SUlIjZs2eL7du3izNnzohNmzaJpKQkERAQcEO0TUtgFjGLmEXmMYtaF7OIWcQsMo9Z1LqYRcwiZpF57TGLWJCqx+LFi0VISIiwt7cXcXFxYsuWLW19SC1qwoQJws/PT6hUKuHv7y/GjRsnjhw5Ij9uMBjE/Pnzha+vr1Cr1WLgwIHi0KFDJq9x+fJl8eSTTwp3d3fh6OgoRo8eLTIyMlr7VK7bpk2bBIA6X1OmTBFCNF9b5Ofni0mTJgmNRiM0Go2YNGmSuHTpUiudZdNYa5vy8nKRnJwsvLy8hEqlEsHBwWLKlCl1zrujtk1LYRYxi5hFdTGLWh+ziFnELKqLWdT6mEXMImZRXe0xiyQhhGh8vyoiIiIiIiIiIqKm4RxSRERERERERETUqliQIiIiIiIiIiKiVsWCFBERERERERERtSoWpIiIiIiIiIiIqFWxIEVERERERERERK2KBSkiIiIiIiIiImpVLEgREREREREREVGrYkGKiIiIiIiIiIhaFQtSZLN27tyJO++8E8HBwVCr1fDx8UFSUhJmz54t77NkyRJ89tlnbXeQRNThMYuIyBYwi4jIFjCLqDlJQgjR1gdBdK3Vq1djzJgxGDx4MB5++GH4+fkhKysLe/bswfLly3Hu3DkAQExMDDw9PbF58+a2PWAi6pCYRURkC5hFRGQLmEXU3FiQIps0aNAgnD9/HseOHYOdnZ3JYwaDAQqFsXMfw46IWhKziIhsAbOIiGwBs4iaG4fskU3Kz8+Hp6dnnaADIAdd586dceTIEWzZsgWSJEGSJHTu3Fner7i4GHPmzEFoaCjs7e0REBCAGTNmoKyszOT1JEnCk08+iQ8//BARERFQq9WIiorC8uXLW/Qcicj2MYuIyBYwi4jIFjCLqNkJIhv00EMPCQBi+vTpYseOHaKqqqrOPvv27RNhYWGid+/eIiUlRaSkpIh9+/YJIYQoKysTvXr1Ep6enuLNN98UGzZsEO+8847QarVi6NChwmAwyK8DQAQFBYmoqCjx9ddfix9//FGMGDFCABDffvttq50zEdkeZhER2QJmERHZAmYRNTcWpMgm5eXliZtvvlkAEACESqUS/fv3FwsWLBAlJSXyftHR0WLQoEF1nr9gwQKhUCjE7t27TbZ/9913AoBYs2aNvA2AcHR0FNnZ2fI2nU4nIiMjRZcuXZr/5Iio3WAWEZEtYBYRkS1gFlFz45A9skkeHh7YunUrdu/ejYULF+KOO+7AiRMnMG/ePMTGxiIvL8/q83/++WfExMSgV69e0Ol08tett94KSZLqjGceNmwYfHx85O+VSiUmTJiAU6dOyZPzEdGNh1lERLaAWUREtoBZRM2NBSmyaQkJCXj66afx7bff4sKFC5g5cybS09Px2muvWX1eTk4O/vzzT6hUKpMvjUYDIUSdsPT19a3zGjXb8vPzm++EiKhdYhYRkS1gFhGRLWAWUXOpOxsZkY1SqVSYP38+3nrrLRw+fNjqvp6ennB0dMSyZcssPl5bdnZ2nX1qtnl4eDTxiImoI2IWEZEtYBYRkS1gFtH1YEGKbFJWVhb8/PzqbE9NTQUA+Pv7AwDUajUuX75cZ7/Ro0fj1VdfhYeHB0JDQ+v9eRs3bkROTo7cJVSv12PFihUIDw9HYGDg9ZwKEbVjzCIisgXMIiKyBcwiam6SEEK09UEQXatHjx4IDAzE7bffjsjISBgMBhw4cABvvPEGSkpKsH37dsTGxmLq1KlYvnw5Pv/8c4SFhcHBwQGxsbEoKyvDgAEDkJubi5kzZ6JHjx4wGAzIyMjAr7/+itmzZyMxMRGAcUnRoKAgaDQaPPfcc3B2dsaSJUuwdu1aLF++HBMmTGjj1iCitsIsIiJbwCwiIlvALKJm15YzqhNZsmLFCjFx4kTRtWtX4eLiIlQqlQgODhaTJ08WR48elfdLT08XycnJQqPRCAAiJCREfqy0tFQ8++yzolu3bsLe3l5otVoRGxsrZs6cabJaAwDxxBNPiCVLlojw8HChUqlEZGSk+Oqrr1rzlInIBjGLiMgWMIuIyBYwi6i5sYcU3fAkScITTzyBRYsWtfWhENENjFlERLaAWUREtoBZdGPgKntERERERERERNSqWJAiIiIiIiIiIqJWxSF7RERERERERETUqthDioiIiIiIiIiIWhULUkRERERERERE1KpYkCIiIiIiIiIiolbFghQREREREREREbUqFqSIiIiIiIiIiKhVsSBFREREREREREStigUpIiIiIiIiIiJqVSxIERERERERERFRq/p/YoZZ7kV+GQUAAAAASUVORK5CYII=",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Put the model under eval mode\n",
+ "best_cae.eval()\n",
+ "\n",
+ "# Construct the dataset\n",
+ "all_dataloader = dl.DataLoader(\n",
+ " AFMDataset(curves=norm_approach_curves, contactpoints=norm_contact_points),\n",
+ " batch_size=len(norm_approach_curves),\n",
+ " shuffle=False\n",
+ ")\n",
+ "\n",
+ "# collect the original curves and corresponding reconstruction\n",
+ "with torch.no_grad():\n",
+ " for indx, batch in enumerate(all_dataloader):\n",
+ " x_list, y_list, c = batch\n",
+ " y_hat_list, _, _, _ = best_cae(x_list,c)\n",
+ "\n",
+ "# Transfer them into Numpy array\n",
+ "y_list = x_list.numpy()\n",
+ "y_hat_list = y_hat_list.numpy()\n",
+ "\n",
+ "# Extract the good curves and corresponding reconstruction\n",
+ "(\n",
+ " good_curves,\n",
+ " good_reconstructions,\n",
+ ") = label_separate(\n",
+ " labels,\n",
+ " 1,\n",
+ " y_list,\n",
+ " y_hat_list,\n",
+ ")\n",
+ "\n",
+ "# Extract the good curves and corresponding reconstruction\n",
+ "(\n",
+ " bad_curves,\n",
+ " bad_reconstructions,\n",
+ ") = label_separate(\n",
+ " labels,\n",
+ " 0,\n",
+ " y_list,\n",
+ " y_hat_list,\n",
+ ")\n",
+ "\n",
+ "# Transfer them into Numpy array\n",
+ "(\n",
+ " good_curves, \n",
+ " good_reconstructions, \n",
+ " bad_curves, \n",
+ " bad_reconstructions\n",
+ ") = (\n",
+ " np.array(good_curves),\n",
+ " np.array(good_reconstructions),\n",
+ " np.array(bad_curves),\n",
+ " np.array(bad_reconstructions),\n",
+ ")\n",
+ "\n",
+ "\n",
+ "# Plot the comparison between the reconstruction and the originals\n",
+ "fig, axs = plt.subplots(1, 4, figsize=((12, 3)))\n",
+ "\n",
+ "for curve_idx, ax in enumerate(axs.ravel()):\n",
+ " if curve_idx < 2:\n",
+ " # good curves part\n",
+ " data_apporach_plot_raw = good_curves[curve_idx][::-1]\n",
+ " data_apporach_plot_reconstruct = good_reconstructions[curve_idx][::-1]\n",
+ " data_label = \"Good Curve\"\n",
+ " else:\n",
+ " # bad curves part\n",
+ " data_apporach_plot_raw = bad_curves[curve_idx][::-1]\n",
+ " data_apporach_plot_reconstruct = bad_reconstructions[curve_idx][::-1]\n",
+ " data_label = \"Bad Curve\"\n",
+ " \n",
+ " ax.plot(data_apporach_plot_raw, label=\"Raw Data\")\n",
+ " ax.plot(data_apporach_plot_reconstruct, label=\"Reconstruction Data\")\n",
+ "\n",
+ " ax.set_title(data_label)\n",
+ " ax.set_xlabel(\"Step\", fontsize=12)\n",
+ " \n",
+ " if curve_idx == 0:\n",
+ " ax.set_ylabel(\"Normolized Force\", fontsize=12)\n",
+ " ax.legend()\n",
+ "\n",
+ "fig.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1bf35d60-428a-4de8-a884-45900f6f1d70",
+ "metadata": {},
+ "source": [
+ "### 2.7. Detecting Anomalies from the Reconstruction Error"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b44c224-09bc-4f56-bd93-525197e62e2b",
+ "metadata": {},
+ "source": [
+ "Determine the threshold for reconstrution error based on good curves ..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "cb7dcbcb-afe7-43eb-a9e8-2fd7ca6dee2d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " The threshold value is 0.01599787175655365\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Calculate the reconstruction errors\n",
+ "diff = abs(good_curves - good_reconstructions).mean(axis=1)\n",
+ "# 95% quantile value as threshold\n",
+ "threshold_loss = np.quantile(diff, 0.95)\n",
+ "print(f\" The threshold value is {threshold_loss}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dbd9e567-29ff-4c89-b884-50d0646c1794",
+ "metadata": {},
+ "source": [
+ "... plot the histogram of reconstrution errors, highlighting the threshold."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "cdc57564-5463-4aa7-9e6b-083357a45afd",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}