{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/usnistgov/AFL-agent/blob/main/docs/source/tutorials/building_pipelines.ipynb)\n", "\n", "# Building Pipelines" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we'll go into more detail on the Quick Start Example from [Getting Started](getting_started.rst). In this example, we'll build a pipeline that \n", "\n", "- standardized the input compositions to improve the convergence of the Gaussian Process optimization\n", "- uses a Savitzky-Golay filter to compute the first derivative of the measurement\n", "- computes the similarity between the derivatives of the measurement data\n", "- clusters (i.e., labels) the data using spectral clustering\n", "- fits a Gaussian Process classifier to the data.\n", "- chooses the next optimal measurement based on the entropy of the Gaussian Process posterior \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup\n", "\n", "Only uncomment and run the next cell if you are running this notebook in Google Colab or if don't already have the AFL-agent package installed." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# !pip install git+https://github.com/usnistgov/AFL-agent.git" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below are the imported modules used in this tutorial" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import xarray as xr\n", "import matplotlib.pyplot as plt\n", "\n", "from AFL.double_agent import *\n", "from AFL.double_agent.plotting import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Input Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Okay, to begin, we'll load in a pre-prepared `xarray.Dataset`. These are powerful and flexible data structures for working with multi-dimensional data, and `AFL.double_agent` uses them for all input, intermediate and output data.\n", "\n", "The dataset below contains simulated measurement data along with the compositions that this simulated data was generated at. It also has the ground truth phase labelse along with a grid of compositions that the agent will search through for the next optimal measurement. \n", "\n", "To see how this dataset is created, see [Building xarray.Datasets](../how-to/building_xarray_datasets>) page.\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 164kB\n",
       "Dimensions:              (sample: 100, component: 2, x: 150, grid: 2500)\n",
       "Coordinates:\n",
       "  * component            (component) <U1 8B 'A' 'B'\n",
       "  * x                    (x) float64 1kB 0.001 0.001047 0.001097 ... 0.9547 1.0\n",
       "Dimensions without coordinates: sample, grid\n",
       "Data variables:\n",
       "    composition          (sample, component) float64 2kB 5.7 1.36 ... 5.104\n",
       "    ground_truth_labels  (sample) int64 800B 1 1 0 1 0 1 1 1 ... 1 1 1 1 1 0 1 1\n",
       "    measurement          (sample, x) float64 120kB 1.915e+06 1.479e+06 ... 1.885\n",
       "    composition_grid     (grid, component) float64 40kB 0.0 0.0 ... 10.0 25.0
" ], "text/plain": [ " Size: 164kB\n", "Dimensions: (sample: 100, component: 2, x: 150, grid: 2500)\n", "Coordinates:\n", " * component (component) " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from AFL.double_agent import *\n", "\n", "with Pipeline() as my_first_pipeline:\n", " Standardize(\n", " input_variable='composition',\n", " output_variable='normalized_composition',\n", " dim='sample',\n", " component_dim='component',\n", " min_val={'A':0.0,'B':0.0},\n", " max_val={'A':10.0,'B':25.0},\n", " )\n", "\n", "my_first_pipeline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Going over the arguments to Standardize one by one:\n", "\n", "- `input_variable='composition'`: The data variable to normalize, in this case the 'composition' variable\n", "- `output_variable='normalized_composition': The name of the new variable that will store the normalized data\n", "- `dim='sample'`: The dimension along which to compute statistics for normalization\n", "- `component_dim='component'`: The dimension containing different components/features\n", "- `min_val={'A':0.0,'B':0.0}`: Dictionary specifying minimum values for each component\n", "- `max_val={'A':10.0,'B':25.0}`: Dictionary specifying maximum values for each component\n", "\n", "\n", "We can view more information about the pipeline by printing it " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "\n", "Output Variables\n", "----------------\n", "0) normalized_composition\n" ] } ], "source": [ "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can add more operations to the `Pipeline` by recreating the context" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "\n", "Output Variables\n", "----------------\n", "0) normalized_composition\n", "1) normalized_composition_grid\n" ] } ], "source": [ "with my_first_pipeline:\n", " Standardize(\n", " input_variable='composition_grid',\n", " output_variable='normalized_composition_grid',\n", " dim='grid',\n", " component_dim='component',\n", " min_val={'A':0.0,'B':0.0},\n", " max_val={'A':10.0,'B':25.0},\n", " )\n", "\n", "my_first_pipeline.print()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can run the pipeline by calling the `.calculate` method and passing in the input dataset `ds`" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5e6b3e09a44b4b2a8326f6c9df390e19", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/2 [00:00\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 205kB\n",
       "Dimensions:                      (sample: 100, component: 2, x: 150, grid: 2500)\n",
       "Coordinates:\n",
       "  * component                    (component) <U1 8B 'A' 'B'\n",
       "  * x                            (x) float64 1kB 0.001 0.001047 ... 0.9547 1.0\n",
       "Dimensions without coordinates: sample, grid\n",
       "Data variables:\n",
       "    composition                  (sample, component) float64 2kB 5.7 ... 5.104\n",
       "    ground_truth_labels          (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    measurement                  (sample, x) float64 120kB 1.915e+06 ... 1.885\n",
       "    composition_grid             (grid, component) float64 40kB 0.0 0.0 ... 25.0\n",
       "    normalized_composition       (sample, component) float64 2kB 0.57 ... 0.2042\n",
       "    normalized_composition_grid  (grid, component) float64 40kB 0.0 0.0 ... 1.0
" ], "text/plain": [ " Size: 205kB\n", "Dimensions: (sample: 100, component: 2, x: 150, grid: 2500)\n", "Coordinates:\n", " * component (component) " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig,axes = plt.subplots(1,2,figsize=(8,3.25))\n", "\n", "plot_scatter_mpl(ds_result,'composition',component_dim='component',labels='ground_truth_labels',ax=axes[0])\n", "axes[0].set(title='Raw Composition Data')\n", "\n", "plot_scatter_mpl(ds_result,'normalized_composition',component_dim='component',labels='ground_truth_labels',ax=axes[1])\n", "axes[1].set(title='Normalized Composition Data')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the relative data positions are unchanged, only the magnitude of the axes is changed. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 2: Savitsky-Golay Filter" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have the composition data processed, we can move on to processing the measurement data. In many cases, smoothing and filtering data can help remove noise and emphasize features in data that you want your agent to focus on. \n", "\n", "Here we'll add a `SavgolFilter` operation in order to calculate the first derivative of the measurement data. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "2 ) measurement ---> derivative\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "2) measurement\n", "\n", "Output Variables\n", "----------------\n", "0) normalized_composition\n", "1) normalized_composition_grid\n", "2) derivative\n" ] } ], "source": [ "with my_first_pipeline:\n", "\n", " SavgolFilter(\n", " input_variable='measurement', \n", " output_variable='derivative', \n", " dim='x', \n", " window_length=50,\n", " apply_log_scale=True,\n", " derivative=1,\n", "\n", " )\n", "\n", "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "Let's go through each argument passed to SavgolFilter:\n", "\n", "* `input_variable='measurement'`: Specifies the data variable to filter, in this case the raw measurement data\n", "* `output_variable='derivative'`: Names the new variable that will store the filtered/derivative data\n", "* `dim='x'`: Indicates which dimension to apply the filter along (the x-axis values)\n", "* `window_length=50`: Sets the size of the moving window used for filtering - larger values give smoother results\n", "* `apply_log_scale=True`: Takes the log of the x-axis values before filtering, useful for data spanning multiple orders of magnitude\n", "* `derivative=1`: Calculates the first derivative of the data while filtering\n", "\n", "We can run the pipeline on the dataset and plot the results." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "f82802c51a6e44d3baae14cd7202b0cc", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/3 [00:00\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 407kB\n",
       "Dimensions:                      (sample: 100, component: 2, x: 150,\n",
       "                                  grid: 2500, log_x: 250)\n",
       "Coordinates:\n",
       "  * component                    (component) <U1 8B 'A' 'B'\n",
       "  * x                            (x) float64 1kB 0.001 0.001047 ... 0.9547 1.0\n",
       "  * log_x                        (log_x) float64 2kB -3.0 -2.988 ... 0.0\n",
       "Dimensions without coordinates: sample, grid\n",
       "Data variables:\n",
       "    composition                  (sample, component) float64 2kB 5.7 ... 5.104\n",
       "    ground_truth_labels          (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    measurement                  (sample, x) float64 120kB 1.915e+06 ... 1.885\n",
       "    composition_grid             (grid, component) float64 40kB 0.0 0.0 ... 25.0\n",
       "    normalized_composition       (sample, component) float64 2kB 0.57 ... 0.2042\n",
       "    normalized_composition_grid  (grid, component) float64 40kB 0.0 0.0 ... 1.0\n",
       "    derivative                   (sample, log_x) float64 200kB -3.82 ... -0.4063
" ], "text/plain": [ " Size: 407kB\n", "Dimensions: (sample: 100, component: 2, x: 150,\n", " grid: 2500, log_x: 250)\n", "Coordinates:\n", " * component (component) " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig,axes = plt.subplots(1,2,figsize=(8,3.25))\n", "\n", "ds_result.measurement.plot.line(x='x',xscale='log',yscale='log',ax=axes[0],add_legend=False)\n", "ds_result.derivative.plot.line(x='log_x',ax=axes[1],add_legend=False);\n", "\n", "axes[0].set(title=\"Raw Data\")\n", "axes[1].set(title=\"Derivative of Smoothed Log(Data)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The data on the right has more flat, constant regions than the data on the left making it easier for the simlarity and clustering analyses below to separate. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 2: Calculate Similarity between Measurement Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have preprocessed our data using the Savgol filter, we can calculate the similarity between different measurements. The `Similarity` component computes a similarity matrix between all pairs of samples based on their filtered derivative data. This similarity matrix will be used as input for clustering in the next step.\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "2 ) measurement ---> derivative\n", "3 ) derivative ---> similarity\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "2) measurement\n", "\n", "Output Variables\n", "----------------\n", "0) normalized_composition\n", "1) normalized_composition_grid\n", "2) similarity\n" ] } ], "source": [ "with my_first_pipeline:\n", " Similarity(\n", " input_variable='derivative', \n", " output_variable='similarity', \n", " sample_dim='sample',\n", " params={'metric': 'laplacian','gamma':1e-4}\n", " )\n", "\n", "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The Similarity component takes the following inputs:\n", "\n", "- `input_variable`: The variable to calculate similarity between ('derivative')\n", "- `output_variable`: The variable to store the similarity matrix ('similarity')\n", "- `sample_dim`: The dimension containing different samples ('sample')\n", "- `params`: Dictionary of parameters for similarity calculation\n", " - `metric`: The similarity metric to use ('laplacian')\n", " - `gamma`: The scale parameter for the similarity metric (1e-4)\n", "\n", "Let's execute the pipeline" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "200f79473aba43d68d893247f7564ce2", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/4 [00:00\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 487kB\n",
       "Dimensions:                      (sample: 100, component: 2, x: 150,\n",
       "                                  grid: 2500, log_x: 250, sample_i: 100,\n",
       "                                  sample_j: 100)\n",
       "Coordinates:\n",
       "  * component                    (component) <U1 8B 'A' 'B'\n",
       "  * x                            (x) float64 1kB 0.001 0.001047 ... 0.9547 1.0\n",
       "  * log_x                        (log_x) float64 2kB -3.0 -2.988 ... 0.0\n",
       "Dimensions without coordinates: sample, grid, sample_i, sample_j\n",
       "Data variables:\n",
       "    composition                  (sample, component) float64 2kB 5.7 ... 5.104\n",
       "    ground_truth_labels          (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    measurement                  (sample, x) float64 120kB 1.915e+06 ... 1.885\n",
       "    composition_grid             (grid, component) float64 40kB 0.0 0.0 ... 25.0\n",
       "    normalized_composition       (sample, component) float64 2kB 0.57 ... 0.2042\n",
       "    normalized_composition_grid  (grid, component) float64 40kB 0.0 0.0 ... 1.0\n",
       "    derivative                   (sample, log_x) float64 200kB -3.82 ... -0.4063\n",
       "    similarity                   (sample_i, sample_j) float64 80kB 1.0 ... 1.0
" ], "text/plain": [ " Size: 487kB\n", "Dimensions: (sample: 100, component: 2, x: 150,\n", " grid: 2500, log_x: 250, sample_i: 100,\n", " sample_j: 100)\n", "Coordinates:\n", " * component (component) " ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG2CAYAAACDLKdOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAn31JREFUeJztnQeYVNX5xs/MbGNhAVEBNYI9gIVeNVaUABasSEAQCCiKjUSjqNhiiX8lYEJACUXAAtJEUYmiaJS+FEWK2I1KUQSGXXd3dub+n3Nx13veM3MOs7uzM+y8vzwT9+zcctq9nD3f+32fz3EcRxBCCCGE1BD8ya4AIYQQQkhVwsUNIYQQQmoUXNwQQgghpEbBxQ0hhBBCahRc3BBCCCGkRsHFDSGEEEJqFFzcEEIIIaRGwcUNIYQQQmoUXNwQQgghpEbBxQ0hhBBCahRc3BBCCCFpwHvvvScuuugiceSRRwqfzyfmz59vPWfJkiWiTZs2Ijs7W5xwwgli6tSp2jHjxo0TxxxzjMjJyREdO3YUK1euFMmGixtCCCEkDSgoKBAtW7Z0FyMHwhdffCF69uwpzjnnHLFu3Tpx6623ij/+8Y9i0aJF5cfMnDlTjBgxQtx3331izZo17vW7desmduzYIZKJj4kzCSGEkPTC5/OJefPmiV69esU85i9/+YtYuHCh2LBhQ/nvrr76arF7927xxhtvuGW5U9O+fXvxz3/+0y1HIhFx9NFHi5tuuknceeedIllkiBqO7OjvvvtO5OXluYNJCCGExEL+vR8MBl3Tjd+fOONGUVGRKCkpqZL64r9t2dnZ7qeyLFu2THTt2lX5ndyVkTs4Eln//Px8cdddd5V/L/tMniPPTSY1fnEjFzZyFUkIIYQcKN988434zW9+k7CFzbFN64htO8KVvladOnXEvn37lN/dd9994v7776/0tbdt2yYaNWqk/E6W9+7dK37++Wfx008/iXA4HPWYzZs3i2RS4xc3csdGsm51Q5FXZ/8qvMiJKMfccnpPpTz2g4VK+eYu3ZXy3z94XSnnwKo5JMyWvhyf+tfA0M7dlLIvEFDK//yvWp/MOHegvO3NFOZzb/id2hdOWH34/r3sP0o5BH0ZgLoFI+r3efCX0HXnqVuiY9+aK+IB+zIEVtYSKGfF2XdhGMsA9B/+XVcE9yuF4+vA7dXeEeLGDupfSeNXvmWs3w1dL1XKTy+OLRAMQ92Gwb3+veptpRyMqGM/4lx1rEa/rd4rz6/O28Gtz1TK/1qzRCkPP/NCpfzYklfV+kLfBWAs6kLn49zD9uJziXMHwbn757MuUspj33tFvT489vWgP4acob5HRr+ntrc2PBvaeHW6QCmPX64+ixHDOwLbgu8sPN4PfV/oqHOhri9TKf/slCrlG6CvRi9ZYJwrQ85U3ztPQ99gffC9E7I8pzjXRr+rjt3RGXXKf967LyKatvmy/N+ORCB3POTC5ov8pqJuXsV3h/YGI+LYtl+5C7G6deuW/z67CnZtDnZq/OKmbLtOLmzyfplEmfASyvBnKeWy4w70+8oubvD6Pnjw8X7xLm687bUtbrAuDrzUsC74Qsd/YPBfb1zcZPizjdc/2BY3mdo/qOrxeZbFTYbPPNeQePoP/7G03ivixPUcaGNruT5erw58b1vc5CV4cYODY2s/Pgv6XDefb1vc2PrTtLjBtsS7uAlAXeriO8yJr63x9o2+uBFxLW5s16+bob5zJdUhY5ALm8osbsqvU7eusripKho3biy2b9+u/E6W5b1q1aolAoGA+4l2jDw3mdBbihBCCEkCYSdS6U8i6dy5s1i8eLHyuzfffNP9vSQrK0u0bdtWOUbqXGW57JhkUeN3brymmbIdjDBurMCqPc+ndouvVi31e9hZKcYtUsv2NG7xohkKwb+qdsNf1PX96ve7oIHZnq+LjHcSwikqVsulpca641+/aPLLsWyPC4uzXq7P3De70OwFf2zV92cYd2KwPfrOlvkvXA1oT45PLUcsO2dIDrQf6yvAbIh/7XvNZAH8Y/7nIuM8DjrQ9zAX8HpoKvBlZRn7XuSou07Z0FchYdxI0v5ax107nDtFYGYrgu2MIkdtUG0c68xM4/WL4Xp74H4C+sP2HsH+8mVkGHeqlP637CLhPMHybijnwb1+iKijk4nTGvoK3wP43OJcsJnFtF03aK/2Tz5cv0mGanL6ujRY/nOwNLELBi8R4bifypwfD/v27ROffvqp4uotXbwbNGggmjRp4gqDv/32WzFt2jT3++uvv971grrjjjvEoEGDxNtvvy1mzZrlelCVId3ABwwYINq1ayc6dOggxowZ47qcDxw4UCSTtFncEEIIIenM6tWr3Zg13oWJRC5OZHC+77//Xnz99dfl3x977LHuQua2224TY8eOdQXW//73v12PqTJ69+4tdu7cKUaNGuUKkFu1auW6iaPIuLrh4oYQQghJAhH3f5U7Px7OPvts13U8FtGiD8tz1q5da7zu8OHD3U8qkTaLm1vO6fWrqAy28u9c/qZS7tPpcqV87/uq0r9fR/V7gVusCMZKgO39e1e+bhRO9u9wufF8AdvV2D7l/ngucPd6tS+2hesp5aHtLjPfG6+frW7FCzB7jVs9S71+xytj1z0aoZC5PvES71jiiyLemJhwvbvWq3OhT8fLjPUbCZ57A3GueI8H8+f1m/6rlAd3vEI9t1iNwXHnqsXmsYK2371WrdvQTlcp5aeWzVTKw/D+CM5rm4kQzb04NjjWpXD9WjlK8eEPVE++fp0s9YUYJjjX+3XqbZ7LUP/bV/0aFTbqe8HbH7Z3BKL1RWml+vrBZaon3cDOVxnb+uRKdS70w7mA9cGxxecSrr9wrepx2rNTz5jvpdKIHLdJojqQ5kA0CcZ7PokOBcWEEEIIqVGkzc4NIYQQkkpUt6A4neDihhBCCEkCcnGieRHGeT5J88XN2HfmlwduQlfvPm0vVsqTwDY+uK0amXXGmjlKOROse4UQrRNBVcfgNpcYj5+xdq4xciwG/0KXWO+3hZqrsmpLH9Ti90rZKVFt189/9rLx4TK5Ikdzf+3XQdVtTFs5x3g9dH9F13NrkD1wIUUXUwwToAc7w742a3SwvrZIq9c2V6NVT988G+rnGDU2M1bNi3l9rEvfY85SyrO+VM/dHVHn8TB4DqasmW3smz8cf456/KcvKeXBUPdJOPYwt3ZH1LlzJMgucC7ic1mEbvQAPhvIje1V/dO0/JeMYQ5w7g1rp0aTnpI/K665OeRUNcrucxvmxnQlD8cZsBD7KgRvKdv3tnk5fsVMY3DLm0HH+MKqucb7IXj/hoFfIw5LerY+XylPWq3Wx0swGBHNmhtvRw4C0mZxQwghhKQSNEslDi5uCCGEkCRAb6nEwcUNIYQQkgSksa1ycW6ISPfFjQyrXxZaP4iaGFssFUt6BJvGBrUO2tUwrnzAb9SRYNh71HFgLHLv/f2WxJIYMh9jg+A2KN4bbf2osdG2UaHvtbZgBHzN9g86C0vyRLy/lj4CXhd4/QhoZGz308qGsYkWj8TWvxh/pNhQP7yWL9OcmkIDxkqrO+DLyjSnrrDcX0uTAqBeCTUreD38hyAbjvdrIf7NY4PkwvHaPzzwbNn0W1oaGIgZhXPZ2x5M/ZCpzfuAUdNSAPqhLEiNgW9MbS5AWUtYizsO8I7FscO5i21Hjc2O8D5jOgisv/c5r4zAl6QOabO4IYQQQlIJuZCqzGKKC7HYcHFDCCGEJAG5O2nbobSdT9J8cSO3Tcu2TtFV2hpaHLZocUvUZvcM2ERgYIbCLVrcMtbMVFBGU5O3jHXVDHKQYRzrkq0b1cyZii0uo9h23JrH7XP8SwXbat0uB7A+mBUc3YMx+zFulxegazp2J26vo1kQ+jsSp6nIZCbTskxb7qXNazgeTReYgR1ND9pzB+ZYzModgnKOz/yk2foKwxJk+uI7Xv8e3aXjyxiPcwGzoGuu69DfOHe9ppV6lozjNldvNEPh3EGTGvYFvlPxObWaqQDsq0P8uUr5x0iBejxeH/pO+96JYxzJQUHaLG4IIYSQVIKC4sTBxQ0hhBCSBCLCJ8KV2CmS55PoMHEmIYQQQmoUabNzI7URZfoItN+KEFq7gVJz2HZbiH9biH6nVHUlx7U46jpsug/NhdWDTXPjhMPxaWqgbTb1PvYN2tptLqq2tur1M2ty8H4Y8t7Ul9FALUG8GiCcC4hNS6DPFf8Bh7BHPVUYNSlQN1tIAseSjkDTQVg0P3rEhPjGBscS21sEmh7tPQHtxzACONc013c4X0+RYJ77TqjU/CwZ5rHWFgta3aHvUaOjXV5zJcd5aZ7HSF1/LaW8N/JzXK7iAt5rqBHK9fQ9vl8TiZzTOK/jPZ+k+eKGEEIISSXClTRLVebcmg7NUoQQQgipUXDnhhBCCEkC3LlJHGmzuJFxHrKcGNtVEFYdw7ILCCOPoO0b7b2ok8D4FD4M666la8DYK2HL/bF+v55fZLGFa0ZcsFXb9EMYT0PXFfiN97NpdrAviuF7jFHht4wFxhKx1VdP/2BOx4Dg+bZ0CqgLKRbhuK7vTQ2C8wT1VThvbXFetLEEMI6OLUYPamJw7Aodc6oOrL+uC4kY+xIDoqGmSA/hj6kx4NnA7rOkb7DNfUyXYZqL+JzgOw2/11NfxE7tgPeKCow9PhcYIwmPxzg2P0UKRTxoYw9979XY4NypzkzbEcfnfipzPknzxQ0hhBCSSnDnJnFQc0MIIYSQGgV3bgghhJAkEBZ+91Px84lI98XN8HMuERn+rP0FsPfeuWyRUu7X5Uql/OTyWUq5f5er1ItD/AktVxVoC1DHcu+KherXoC3o0/Eyc1we0AJgPA3l/pY4Nn/Kf0cp746otu8+7XupJ6CuAq+PeqUiVSXz8Iq5Srlfx8vh+pYHv7jE3Bc2UFdi0ZloY2mJz6HNBUtes2Gr31XKvTtdZrzfk8vmqMd3uDz2/aDuf/zwfaXcp8Olxnl278o3lHL/jlfEvpcQ4o716nM1sLP63IxbOlMpD+4EzxVi62vbWNnGugSeq1o5SvHh92GudoL2Y9wdmJtjVr6knt+lt/F4fLZuXf6WUu7doVfsuYRtywiYtXXYt/gOsT3n8P1TK+CdiWMLc2vh2teUcs8OPcz3w7HF5wyOf3L5bKXc7/TeMd9LpRE5Dv8W1YFTSc2NPJ9Eh2YpQgghhNQo0mbnhhBCCEklKChOHGmzuHl6yQKRl7d/o2oX+Hze2u4SpTwu/0WlfGNr+H7ti8YJVhvmWwlsEaP79aCWFxpdw5/Jn3XAboySoCHsPbrbhuDcoW3BNAF1n7RmTlxbf3h9ZOgZfZTyM8tfiNNlVRj7Ft2Zsb61YXsbXWD3WCwhv0ypcgpwtx/D1kNKAxyPQS1+r5QnblRNN8jQ069Wys+seDFm/2HfDWl5kVKevH62cd4OAzPUmOWqmaUe9MWA356vlJ/erLZlWHvV5PbwinlQd/X+eX5MPyCMc8FmxLKl1tDa3059Np5arT6XOTC2+Jz2a6OakSblm8dWG69TeirliRteOuAUC7sj6ne54BZvoxjMHw0CZtdunCvjV6htbZKRp5R7tlbnyvhVM43PKaa6wLEKQV/c3B7GbpX6nDTwXD8YjIhjm4lqQUoQUIYQ3/lVWp0aBc1ShBBCCKlRpM3ODSGEEJJKRIRPRCqxx1CdAQcPNri4IYQQQpIANTeJI20WN9Im7P/FLOxHWzuU6/kDRnfmXItuBcOy2+zFPgxjD99jmPtgJGy8vt+gLUANCoaYd34uMtYFbdt4b9T72HQRojRs1A1gW7JBx1AIkR5Q5xAWpQesS4jWP/XQvRdA5QLqrfB2ODdyfeZHMA++18LeQxgCk0YJU1M4BT8b7426BXSVRo0NprbwZf0SeiHGXEG3/QZ+cMUGMP1CLmhcBJSzoP6YAgD1VYVQbuCHsQEtnFenES31CJaxvbb6YLoMDIuAc93LD+GIUWODY4GaGRz7bOjbAhCTaWlcwDUcNTZflwaNfROvxka7P7rCw/Xz4HDvOxXfYeTgJG0WN4QQQkgqUXlBMc1SseDihhBCCEma5qYSiTNplooJFzeEEEJIEohUMv0CBcWxSZvFzYhze/2afgG4f8WrxhQADy9T428M7HRl5UL2Q+jxx/IXGE/XwtxjaHTQAhjTL6A9Gcp3rH9braoTMMYm0dIdlEAIedBdYNsxtslgbKstbLwlDLwVW0h+SyyUSqdvgOvfvE4Nsd+n0+Xm9AvL1bhDg3Fueo+He43Y+Jb5XBjLh/PVNCEDcayAu9ZAuga4/uMfqHF1hrU1pBOIhm2ssa8RW8oBeK4eX25JFYL1hf57ctXs+NK4AH9a9Zb5/qa2YV9gWhO8t013oqV3UPtq4er40ilY0zXY0i9YnsMHl803pgLxvpeqM/0CSRxps7ghhBBCUglqbhIHFzeEEEJIksxSjHOTGNJmcTP2nfnl6RfQJXZgq4uV8qR1aljzwZbvs8FlEyccrq5DljD46Br+wnp1O7zQCRtdStHd2OSeii6V15/cXT0Bvp+8STUjIbZ0BxjyHk18M1aqZpYQutNq11NNE0XQN3g21gfdl4vgfuiGj2MZsPQ9uu1j+/H8a5pdoJSnb37JeP+BkBJgRv6cmK7h6Ebe77izlfLMz9V5FnRKjfP0uQ/nGsfqWkglMXXjLGPdx+XPNY7Vnoj6ujoywzw3MuEKmM4AwecK3eoHW/oaz8ewB5i+AdMv6GEM1Av0PUV9Nl/cMDfm3A/CvTE1hG1e254bpGGgjlLu2U4d+0lgdrKl9pi2Sp33SLzP6cAOqgnvmZVq33v/TZDpF05qbrw9OQhIm8UNIYQQkkqEHZ/7qcz5JDpc3BBCCCFJIFxJbynbbmQ6w8SZhBBCCKlRpM3OTR1fhsj7xS6LtnEH7Le4GnbADRG/t+lCUGOD9mEBodJFht+oI7FpbGyaH3NIfJgSWhh3s8YFU1doOgZL6gusO/Yd6iC0dAQWDRBqXmyu2xj23W/5Pgz1wfQWtuvH+z264JoEhjgPMD0Cgn3tg3vh2OLccCBdA46lre+LYcs9xwfuwJhqQtO2mZ9brC+2F+cOukejfg01NnmYxkWbK1hfSIGA94f3kGnuYxoQ7Dm8Nr5TUJeIbW0MGpsd4X1Gt3pb2hbN1duin0JZoU0Lp/UddG09T6qNUkhVkUgijt/9VPx87tyIdF/cEEIIIakEzVKJg2YpQgghhNQouHNDCCGEJIFIJT2emL88NmmzuNkTKRWRyP6Nqvoe+2q0uDKa1gB0KKiZQXuwFodGs+VHjKHQUQOUCffbA7FT8sB+bbKnByF9QR7qi34uUssQlh01NgjGdcGHLxO3USEdA4I6hkx4D2BfYl/nopbAZx4rxBbDCBMA+LX6mjdHUa+F+i7UQmhzB7QNqL/ytg/7JlxQqJahbaiTcOBemv4J62bRoiE4ViGIzbI7EjDrn6D+trFDHUmBtsNv1ofh9fHZwOcUU4dg/+HYlWD/+c3vnSIRO30D6ouw7X7LWKLGZhtobLRZbkmdsQsfbEilYZrH0eYq9mWOxSiBc22P8+t7KBjnvE1uED8aX0S6L24IIYSQmpV+gYubWLBnCCGEEFKjSJudG+mSW+aWazOtaNvxYCoIgktoPT9s96Mrtq1ysF2NZjDcksUVKbpBSrd39fzSmGahAGyto3swuv/a0hVkad+jicxvzCqOJjXcIC6E79Ekh/UpQndiy2igiyi622L7sb5a+gkYO3QPRlOKD7bnsT24m4/b+WhO8JqitJD6OdnmrX1oK9YN57mW9gOPtzh2YN+FNFMJmpnMY4nPDZqTtVQcWogHc9gAvD4en4s2SnhPYHuzsfvQsgPvHVO6BzzXZn7FedPQ4uqNJjk0c2nXh7HMBpOj7qqNpnkcC/M7OxPdueF7TE/RwPNchm3Z6KuQiPC5n8qcT9J8cUMIIYSkEjRLJQ72DCGEEEJqFNy5IYQQQg7KIH7cnxDpvriRrpC5sdxyMwJG3QjqTjDFAIIutzZQy4BulOjGWQhagxz43uvWaEML8Q73Rr1RNjg/o4YGNSp6ugKzbR5t+dJRMh7ND/Z9Dugc/MLm2m1O/4BFHBtUWNnar80VmAt4fS3kPvQH9o9XB6OlZgCtF2poUN+ErsioocnFkPoAPlfYVpwZUD1R36/Oa4wPgrqMXJiruyOlxhQAfk23ARWA94CWRsUPcxXHFu6nh3CwnA9aPHxWvD2op1Mwu63bNDb4nONc0kZec1uPL40I3g/7AkNCoMZGS9cA18+D873tMaUwqWoijs/9VOZ8Eh0u+wghhBBSo0ibnRtCCCEklZBB+CpjWmIQv9hwcUMIIYQkgcpnBefiRqT74kbGeQjESg8P9li/5XsEbbSoHcC4M5puAjQ/aK/WbO8WNC2AhyK4N+osNP0PlL0xc/bfC+OsmG3xqAnB2B96fAtLX0ARNUHY12iL3wftQVATg2Orx3oRxuOzbak+MK4QfB/QND5QH+h/b/1wrDDthxVNM2KuC8ZMwucANSQYVyfTkn4hD+LIaDoLAOur6a1gLuVY9FC2507Ts0FMJ4wLhHMJ+wvnhjDMLS0GD1y7sUVjg8dHLFo5LQ4NjC3qmwogZo/tnae9M/H+MPba8RY9mHestHEjByVps7ghhBBCUomw8LmfypxPosPFDSGEEJIEaJZKHOwZQgghJAmEPbs3FftUjHHjxoljjjlG5OTkiI4dO4qVK1fGPDYUCokHH3xQHH/88e7xLVu2FG+88YZyTDAYFLfeeqto2rSpqFWrlujSpYtYtWqVSCZps3MjY3KUxeVA274IWeLCgA1Wswdj/h8tXkipMaeMKA0b42Wg/RjzJQVgihegqd9Tn2I4FyQvwikuVsshsyZFy29jyatVFDG3HTU5eH3UwGCOmBxfyDhWEdBxYH0xt5SuA/EZc+rg9TItc6UQjsf+x7HHvGY4NxGvdiIE81C7l5aXC/72KVXPD0bCxjg2DjxXuyLwnIUjcY0FxiDS8ohBX6EGBo9HghH1+BzMTwR9j5qZXTg2iCV/EupcfoD+cqD/TefjvEeNzTbQ2GjxlGCuoFZMz2uFuaIiRo1NIc4tS34+mw4mDG8aTdsHaO8ZT/2093MNY+bMmWLEiBFiwoQJ7sJmzJgxolu3bmLLli2iYcOG2vH33HOPmDFjhpg4caJo1qyZWLRokbj00kvF0qVLRevWrd1j/vjHP4oNGzaI6dOniyOPPNI9vmvXrmLjxo3iqKOOSr+dm3A4LO69915x7LHHuqs9uTJ86KGHhOOZXPLnUaNGiSOOOMI9RnbY1q1bk1ltQgghpMrMUpX5xMvo0aPFkCFDxMCBA0WLFi3cRU5ubq6YPHly1OPlgmXkyJGiR48e4rjjjhPDhg1zf37yySfd73/++WcxZ84c8fjjj4szzzxTnHDCCeL+++93/zt+/HiRLJK6uPnb3/7mNv6f//yn2LRpk1uWHfSPf/yj/BhZfuqpp9wBWLFihahdu7a7yiwqKkpm1QkhhJAqSZxZmY9k7969yqcYdmXLKCkpEfn5+e4mQRl+v98tL1u2LOo58lrSHOVFbjS8//777s+lpaXuRoXpmLQzS8ltrUsuuUT07NnTLUsb4AsvvFBu/5O7NnLLTG6LyeMk06ZNE40aNRLz588XV1999QHfS5oXykwM2rajFtIft1jVLc8gbNliGPqQ5r4rjG6Rmm3I4japOpTq2+OIdws4F7basW6+WuoEFQGzyS7ekPfaxj24waPZBcOs49hg+HE0g2H7cHsbTXwNoO+3w+CiqQLNVmjaQFMKujdrf13Y0kvgUIPLLZo2cG4q965VC+6FpgBwfQbXbjQtBNCMA6YJDRhr7LsiuH8DLf0CVM/Sd3h9fBbywByMrudoAkQzFKYY0NJNwPEhixnOBo6X1+R8YqbZDKWZfSyu1miGQrMXmsKxrWgOr+83m6dt5l40o+0BE6mW7kEz6TmxU2EchErUo48+Winfd9997u4J8sMPP7gLEflvqBdZ3rx5c9Rry80Eudsjd2WkdWXx4sVi7ty57nUkeXl5onPnzq7VpXnz5u615L/jcrEkd2+SRVKHUYqOZEd98sknbnn9+vXuSq979+5u+YsvvhDbtm1TVpn16tVz7YSmVSauYgkhhJBUwxE+EanER54v+eabb8SePXvKP3fddVeV1XHs2LHixBNPdPU2WVlZYvjw4a5JS+74eE1XcjNC6muys7Nda0ufPn2UY9Jq5+bOO+90Fx+y0wKBgLsSfPjhh0Xfvn3d7+XCRhJtlVn2HfLoo4+KBx54oBpqTwghhFQcr2mpoudL6tat635sHHbYYe6/tdu3b1d+L8uNGzeOes7hhx/uWkqkFOTHH390BcPy326pvylD7ui8++67oqCgwP03XWpke/furRyTVjs3s2bNEs8995x4/vnnxZo1a8Szzz4rnnjiCfe/FUWuWL0rWLmiJYQQQtKdrKws0bZtW9diUkYkEnHL0rRkQmpq5M6M1NhIAXGZVMSL1MTKhc1PP/3kelVFOyYtdm5uv/12dwVYpp059dRTxVdffeXuvgwYMKB8JSlXlbLDypDlVq1aRb2m3BKTn2j26cxf7KwWJYDuKg5lLcw62Hfrgz24CEOho6YH3aOhhhg2vtiSoqA2nJ/r2RrcDbZwtJ1rrt/h+FwsUWOj6YsQaHs9S4h8bCv2bQ6ErEd9FLYXNTZouz8cUhSEQTuAY98Amqv3F7jiW0L86y66MHtLQkbXc69GB/vOiZjnWZYPFEwlJUrxcJCkZMLrxJeTbX6uQC+Empc8mMe7wurxR2ZEjM8V9gXW1w/6MNTQHInZFmCu4NzB51Kb+ZB+AccWwxTg3PDB+OF4NfHnlv+8NQSu3qBxwXtrGhd0w0dZoFoUeTjNoW8Og+cI74fvWHQ9R/B8fG9o14fUFajh8RarM/2C1AyibjDe8+NlxIgR7r+v7dq1Ex06dHB1rXLHRZqaJP3793cXMfLfYYl05Pn222/df3Plf6WWRy6I7rjjjvJryoWMNEv99re/FZ9++qn7b7u0yJRdM+0WN4WFhZpNTm6ZyY6TSBdxucCRq8qyxYzc8pKdLd3RCCGEkIOVcCWzglfk3N69e4udO3e6IVakvEP+2yqD8pXJP77++mvl32VpjpJOPZ9//rmoU6eO6wYuNTb169cvP6ZM5/O///1PNGjQQFx++eWuxCQTFvRps7i56KKL3A5o0qSJOPnkk8XatWtdVfagQYPc730+nxv18K9//asraJKLHRkXR9r8evXqlcyqE0IIIQclw4cPdz/RWLJkiVI+66yz3GB8Jq666ir3k0okdXEj49nIxcoNN9wgduzY4S5arrvuOndFWYbc+pJbZkOHDhW7d+8WZ5xxhrvKRJ96Qggh5GAiGWapdCGpixvpHy/tffITC7l7I/NayE9l8Ma5saZXwOMcsy0826JDQa2DppvwW86HrUe0zeP3xaBV8NqXY/ZB+cHxZSvBe2OsEy1OiyUmjy21BcZ5seun/Mb66vEzLJoYlI1YtoX1+mOI/4BZ46TdH+6HcYZAc1TsifyjXQvi0GBbCi2ZazDkvhaDx6bXAn2XKSaPJNevXs8P9cX7Z4OmBmO5YH/U1mIimdMvaP1pw5LmBevrHTuJA/15iEdjI/kpUvjrtbR3hLmuusYlYtZ+wfe25wDRNS/mdxreT6+tY24PXB/fC965XJ1eNhHhdz+VOZ+keW4pQgghJJWQDgropBDv+SQ6XPYRQgghpEaRNjs3w7r8XmT4s6Juh//fhgVK+ZqT90dILmPoajUacr/WFyllB9xxBbg9+sC9F92fH8x/XSnXhszWvVvi/VSXXB+Excfta1MYcjRr3LZuuVLO8anHX3NaT/V0cLHEzMU+0EY5kBPsT6sWKeWrT+tuvD6Cfe8D92INze1emPvO5hYK/aeNNV4f+wfa98hHrynlPq0vNNZ/0PIPlPJVp3SLafLEuv15oyocvOq036vnQt+O+kgdq4GtLhYm7vjwHaXcv40a8+LO5er1rj9VnVsaFpMqts9xLOkg4Dl1ioqNz9XY9XOU8tWnwLOQnWW83qh16nPer43af05xiXFuvLbxbaXco8VZMduvtR2wPbf4jkTXbjTRYQiDP+X/Ryn3Pa2HcSxuW/OWUu7duqcxRIX2nEP9sC/vWKPOtf74TvW0v9SR504X1QE1N4kjbRY3hBBCSCrhVDCzt/d8Eh32DCGEEEJqFNy5IYQQQpJAWPjcT2XOJ2m+uBm39A2Rl+cvT8Xg5cZ2lyrlyRvmK+XBoBWYtObluLbD0P0X3RZtOpYZ6xcYQ4tnW67vBUOLl0B5WOtLjLb4qRteNbbNFoIe3YH7d7pSKU9ePwuub3HNtoDuvHh/dGeO2FxWAS0VB1wP5xq6mmP/9T1F1Rw9t+EV4/37tYe5+9GcmP2Hfde32flKefrmhUq5AHQVw9qqgTOnwbzUrn+yquF58WO1LX06XqaU//WROvZIMKI+F40C4bieMxxrdMPHVB04tv3bX66Up0Jf49zCuTC44xVKedoa9XzkUH9tpdzz1HOV8nSYG97+xzQiyGF+NXLsPmg7znt008+ypEvAeTn9w7nGEBFDO6rvgWlrzX0T71ji9Z9Z91JMV/lgMCJOai6qBSmhq5zmpkqrU6OgWYoQQgghNYq02bkhhBBCUolIJQXFlTm3psPFDSGEEJIEIsLnfipzPolOWi5u8jBmA8Rc8Mdp2LRpXlCHYgXjcVQSbyjzIoG6AvXhcIrV2BwI6go0XQOUS6Dr8ixh0VFjg7Z1fJZR54Eam5AW5l1YdBLmsPMIHo9zBzU2qA3QND2gcTLpp/YfoN6/jiH9AtYV4yVh+H9sDMYA0tMvQKwRSDdQ5ISNbY33b1Dsy0K4fmacfY+6Em3uWFKToEYJdSlajCmLxubHSIFR/2ZL12BKTVHomPs+G+e9lvYEUtZY/pHFuaKnAsHUGj7j8WFoK86t3DjTmnjfA1qakATCCMWJg3tahBBCCKlRpOXODSGEEJJsqLlJHGmzuJFb1GXb1Lh9LCBsugZ8nxunC2muZfvcl5lpDGVu2/LF79ENNNeTIRi33nFr3pedbQ7LDuDWuJZlG0yAmokOQuAjmOUat4x3hlXTSp5frQ/0rAZur2P2ZKxv2HI8GhTRNILb52jKEVmZxuzImmkHwgagaUIz6xnSC6CpotAxzw2b8VSb10iOej0kYskKXhSnGyw+d7o5WcUfZ31rw1xHV3A832aGQjC9g54p2xfTDIXz1OY2j+8QNF/jc6CZ8CA9gmbOxr6xvIPxfjYTo5bRHeYijn3Q017t34dEa24q4wpOzU1MuOwjhBBCSI0ibXZuCCGEkFTCqaS3lDyfRIeLG0IIISQJMCt44kibxc11Z14oMvy/2HVLVXvyY/nzlPJASMfw4IoFxrDxAlxeUTMj0PUcbLqPr1Tvj/TpYLkfahtMLqvQduTJNWpI9y9LD1HK/dtfZm4banRQp1Ci1v3J5bPM1wfbvUYRuK7bdB5oT0e3T+w71Abg2OLx+L3t+tB/D+S/ap5rUJ/7P1DnZn9IkaBcH+pyx4eLlPLADpcbx+rxNfOM6QSQUevUtgyEVBvjl72glIfh2CMG/VDUvreNPfQ9hkHw5eQo5THLZpr7C+8PrvYL16npLXp26mmey6CnuneF2p/92l4Se+7jOwKfU6wrHo99heEw/DCvYW49uQqea5wrcL8xq9S+7QfpErT3CvSN9pxB349bjde/KubxpRH582T1e3LQkTaLG0IIISSVoLdU4uDihhBCCEkCNEslDi77CCGEEFKjSJudm3+9+4rIy9u/lguC+fjm1hcr5fFr5yrl61tdpJQnrlftyRg7BmNCaPE6IEbD1ad0V8o+0JlMWjPbeH44jnQPuJrF+BP926h2fAd0F1M/mhNXvIwiS+qJoZ17K+UpK9W+LQKdBYa01+NfYPwK9f4Y/wNjBGH/4P2xNTjWeDyC98f6XtPsAqU8edNLcD6MVxdVO/DM6hdjtg/PvaZ5N6U8deMcY1uGgWZm3PKXjGlN+h13tlKe8pl6/OB2qsZmDGjPwjA2ub6Ise8RjL2CzynGpUEw3skw0OKNXz3bODcbB+oo5Z6tuirlSfmqDsTGoFN6KOWpG2Jr9XCeFmDbLX/w63Fj1O/rQTwpb5yYaH01Kf8lY5yZfm3h+NXmea/FEAJKcO5CfcatnhWzPcFgRBzbTFQLzC2VONJmcUMIIYSkEjRLJQ4ubgghhJAkwMVN4kibxY3coi7bptYmBLgr45YuuoQitmDduAWLIfQxrDq6afrjDCOPW7Le7Xvcqi+yZDxH0FSBZhY0Q+VB+gSsO7p0Yl+i6QDTCWDWcT9sX6OpxJSO4EDCxIdg7uShS6ylv8KW+vpqmeeaDTQfCE/qjWyLxA77PoRb3lqWbXMGd1+tWsZ5aktnkOmpe7T64VhZM0/D9RA0YWpmL0hXEYCv0Qy1LbzPeD6aWtAMhnPfZ3lPmd4BmNZbTwuiXq0wgsc7RjMU9gW2FdHeA/AORLMYFm1iUa1voD44tt50EzgPyMFJ2ixuCCGEkFSCOzeJg4sbQgghJAlwcZM46ApOCCGEkBpFWu7c1MMlHYTqRjdHDPuOrtho2g+B/Rrdo1H34mDocyjnwP12R9RQ5Nno3qyVfTE1NnhsZF+B+otwxOjuim1FTUmhMKd7EBDyHnUZ6NaO34fg+tjXqMOI13VdmwsWsn1mrYIfJgveP1JQCNfzm7UKxSVGjZHJZTZSWGic10WOOs+cn3826jb0G0TMIQogFQg+l6h8+DGi1i9Xe86Ese+wr21kWlJnHBXIU8rfhoPq4Xg7OB/npk3D5MBYm0JCFEDfNPCb+wJDEgh/xHgv23OJ70z8fpclvQPez/acYv3zLHMT6xP2vEdQR5hIZKsqlziTxCItFzeEEEJIsqFZKnHQLEUIIYSQGgV3bgghhJAkwJ2bxJE2i5tbzuklMvy/xDooVbUE4/LnK+V+bdWw8COWvqV+3+kK9eKomcGw7lgGe/NoSPeQB/buPh2vMt8PYsWgbV+5P7QdefDjN5RyiaPavgd3uNwYk0erG8bwAd3AYyug7zuofS8y4PoYlwf0UiIzUxixxLnRvkdtgGUstf6wXR+0AU9sUudCv46XG88fuew1pdy//WWx6wd1u3urOtZ92vdSz4XUG6PXvqLeC+cC8NBHC5Ty4M7qPH7sAzXdw8C2cH/EpvGxpFPQiJg1QDj3Fq5dpJR7tu1mHnuYm2NWQXtPV1OPiKJi4/XGrlfP79P+8tjtx7Zh32Ff4TsD3xN4Ps5juN7jK+eYn2u4/sMr58b3jsV3HoLXX2F5rjzXL43IcZskqgMubhIHzVKEEEIIqVGkzc4NIYQQkkpw5yZxcHFDCCGEJAHH8bmfypxP0nxx88Tb80Ve3n4rXJGjWuNubH2JUp62XtWB9ActwKTVs4z5g3It2gCMczPklJ7qAXD+9A2z4X6qPT0T4iQUQn28sU/w3CJ4OG5qoeoInJBqu35662xj3JsCMMXnQJwXjP0xrKNqW5+0crbRbopxajDHDebjwfYitr7D+2s5dCzXw7mB52N8jn4ndVXKMz6ZbYxbM7iNOnefWTP7gOvW/9izlfKkL2ab58Zp6jyd+lHse0muPVU9fvJH6nMzGDQnz+S/aMwNtS2svq4OD4AOA8Dz9bFUv98Neq7jM9RcUT1bn6+Up+XPNY4N5nca1ulKpTxlxUylHLHE2bkG3hNTP5oT89n4DiQ0tX1h4zuq0JJDDVOoBbQ4OT6jNu+FVfOMsbqGdVHnwqRl6lxBTPnzorXnRrz+8tjv8GAwIlq1ENWCjHFTmTg3lTm3pkPNDSGEEEJqFGmzc0MIIYSkEtTcJI60WdzIbdiyrVhvmHKJA6YL3J52wEUTTQ24/YXfI7iFqgF7wLjdjaHJMQUChg8PetxCMTx/GM711cqBsoiL2tq9zekI0ARn71tzOgc0Q6EZDM1CeD/sn114ASj+YumMuR2OJtBMLWA6GCO0880mSAHjFdLMgr6Y5lB/ndrCBJomfFmqm30Q7oVtw1Qe+NyJAjWdwy4wOyGNA6opI2wxQyFY3xzo++Mz1HQKn5XuM7qKe5+raOBccoqK4jKBau8pcC3Hu3tTGtT3q+cGIzAPfRGL+RfMydC3WqoIHFtwxd4FZijtHfhzkdHsZDMH2965eH00n9f3jlU12jOouUkcNEsRQgghpEaRNjs3hBBCSCpBs1Ti4OKGEEIISQI0SyWOtFncSLfPMtdPtLX7IMw56kZ8EOrb5uqN7soRW2L6gN9yv4BRd5LrU48vBjWCt76oz0FXbgfDsIfV4/P8AaPOAetWDwyfmdAWDNteD66P9c2B89HWj/UphL5A91o/lIvhfqipQbJhrP0wt1DbgJoZ7A9fVpbRVVwDXPVR55HpsTzbdBF5MI8y/TAXUJ+kubWr5/tzss1tgdQc9fylRk3JbtCNNILnxgaOTcOAqrH5NhyMrcOIko4B+9qGLzvbONcRnMs+6E98L2R7dDIYIgFTumhjAWMZhrGOWOa9huWdqamVQM+FIR2yhdrWYnBt90MD8L2BY4chKrQOIAc9abO4IYQQQlIJufNSGdMSd25iw8UNIYQQkgTk/pHN0ct2PokOvaUIIYQQUqNIm52bn8KOCP0SsyQPY4lDXBu/Le6MiDfujHrFQkusFtS5hMBCrcd0KDXez6tTwXtrcVNK1JD2DsTyQFu+HjcGNCXQVxiDR8D1UZ+EfR2B+qPtH/sKdSZ6uoWwMU5Mo4CqCyl0So1jjSH98U8r1EdhfQVonmzaB+w/PD7k0Ryh3igC8ZtsoB4L9U+2GESoi8A/WTH2Cfblj6WqLiMAeiocS3yOGwbUdAo7wvvimruoD4s3xhKOFeq7bNo6fC/g3PY+O4UQXylPi2vjiyuNCaqDsK+x7thXOJaFGCPIomPcB89dkWXu6O9wjO+lfl3kebJsKVuqEpk+Qf6vMueTNF/cEEIIIakEvaUSBxc3hBBCSBKQYmIf49wkhLRZ3NTx/+rWi9vz6CaomRZgSxNdZpGIzVUcXTzBFR1BN8gwuDGiGQq3u72mE1vWaoF1ge1j3K7G7e2AZhYSZhdNbTvZZ9zu1ly90cwG17ONFW7t54AJMhgJGecGmmbQzIQb3Oimr5lqoP+tZiw43uYqH8+8w/QAeDzWBechmjS1kAiWTM5otqrtU8cCc4KjifIQf67RDIX1rW0ZO0Sf+xhDwmzWwrmK/am9hwKx3fzRZJoH6RfQ9RvrWt+vzrMgmIFsz6Et9QWmkNGAtmLbBIZUsLw39LGA94Ih5IRmqicHJWmzuCGEEEJSCbnmq5S3FN2lYsLFDSGEEJIEqLlJHHQFJ4QQQkiNIm12bqT2oFx/gFt5YAvXXAFh78/m8qoBi2vUUWhAfVCnYUNzjza4NqILJaZ+QNdkTSMCoC0cXZNR54A6AqxrxLIat90vrKVfQNdx1HkI4/dFEDagNlQI719i2TfWXOMBdD3X5g7MFZMGCbVbWt/bVCaZqis2omlqwHXZNndwbDHMAOo2/MKssfkpUgj1iw+TXimatg3r76+kDgWfYx9q62BuR4xpUcz6KE3vA+fb2qrNHQxRAH2p/VUNx1vnogVbiAV8TryaJE3rlEC4c5M40mZxQwghhKQS9JZKHDRLEUIIIaRGwcUNIYQQkkRvqcp8KsK4cePEMcccI3JyckTHjh3FypUrYx4bCoXEgw8+KI4//nj3+JYtW4o33nhDOSYcDot7771XHHvssaJWrVrusQ899JBwkujOlZZmKW1FB/ZYW8wGBO3XeD7afzUNDeg4MD4G2u5RB4IxIfB+Xp3GPkv8Cqe01BirxJZaAm372Bda/ArQZdhi9iDYN34tdgqOrTkdA94N44PYdBhor69ti9+BYFh6/BrvD8cbNUg4rbHvoW65GKcF5gZibRsCL74sSwj9MDTArrExp0nBsbSNLfa1rhEy6790/ZqIK50Fpr/Aue/VbxVAXTX9Esaj0rRx5jgy2jy0oMWOwbkF2O6na+ss2j4L3utp45ZA9i9QKqO5if+cmTNnihEjRogJEya4C5sxY8aIbt26iS1btoiGDRtqx99zzz1ixowZYuLEiaJZs2Zi0aJF4tJLLxVLly4VrVu3do/529/+JsaPHy+effZZcfLJJ4vVq1eLgQMHinr16ombb75ZJAPu3BBCCCFpwujRo8WQIUPcxUeLFi3cRU5ubq6YPHly1OOnT58uRo4cKXr06CGOO+44MWzYMPfnJ598svwYudC55JJLRM+ePd0doSuuuEJccMEFxh2hRMPFDSGEEJIEyrylKvOR7N27V/kUF0dPiltSUiLy8/NF165dy3/n9/vd8rJly6KeI68lzVFepOnp/fffLy936dJFLF68WHzyySduef369e733bt3F8kiLc1S28MB497etnCG8XsMEx8MQ8oAP2aaxpQC6pawA6YXVM/vQtMDbMH+4KiB6HdHYrvslqWgKKMAtr59ubXUconaF3vAapLtM7upF0F5Gx4O298/gKnEBra1vr/YbKbCDPCwI1wbyl9CJmqkvr9EKRdBNmakyAkYz8e5hv0dxP7OUrOWb4O56L3bHsge76ulvrC+gVTJwUiO0RX881CWse/RjPK/UuhcmNdflsL9gE7Z6lzcHCowmhzRjFUAfY/pHOrDZNDeA8DOCKRvgLGx/eUYBJPCdu1RMqfHwPdCYeTX4+v51e+CUNfd0De14Z20G9qeCd9nYYgE6Fs0we2KYNoSsz1lO8xFHFt8bm3PnfYOh/p42Vd9ScHdVlXGCFZ27tFHH638/r777hP333+/dvwPP/zg6mMaNWqk/F6WN2/eHPUe0mQld3vOPPNMV0sjFzFz5851r1PGnXfe6S6qpNkqEAi43z388MOib9++Ilmk5eKGEEIISTZVFefmm2++EXXr1i3/fXZ2tqgqxo4d65qx5MLF5/O5Cxxp0vKasWbNmiWee+458fzzz7uam3Xr1olbb71VHHnkkWLAgAEiLc1S3377rejXr5849NBD3a2uU0891RUjlSHV1qNGjRJHHHGE+73cPtu6dWtS60wIIYSkCnJh4/1kx1jcHHbYYe7Oyvbt25Xfy3Ljxo2jnnP44YeL+fPni4KCAvHVV1+5Ozx16tRx9Tdl3H777e7uzdVXX+3+G37NNdeI2267TTz66KMiWSR1cfPTTz+J008/XWRmZorXX39dbNy40RUpHXLIIeXHPP744+Kpp55yRU8rVqwQtWvXdrfJiorQ4EEIIYQcRDhV8ImDrKws0bZtW9e0VEYkEnHLnTt3Np4rdTdHHXWUKC0tFXPmzHEFxGUUFha62h0vchElr52WZinpPiZthVOmTCn/nfST9+7aSDc16YpW1pHTpk1z7YNyJSlXiQfKT+EMEQr7o2pi0BW7gV+1xQtISYAh8+v5LS6yYF/Whht0Jg6G+If77Qb7OWp4sP61PZNuJ2gy8sA2H9m9R61LCWhCAGwL6hqy4IjGAegrEL5lQ1+FhNlWn+krsoSF9xmvXwxbwj+C7f7oQInRDR9t94dCf2J9IqLEmJ4BdSo4dzSC+5RiDswF71RCvVV4926lXB+eizzfz2rdClRX66YZ6tgVQVt8mepz0wDHHjQ8LTLVeVvXr+q/lher5x+XgXMFylCfwwPq9YPw4t0JOhNtrsL1cKwLYC4VobkB9F+oI8H3iPaeQHdtON/bvzvDqEULGd9hOI/zoC743OHxtncgvqP2RMxpRPB4fE5Rx5gHeid0fReBgFGz470earUSSiXNUvL8eBkxYoRrKmrXrp3o0KGD+2+s3JWRpiZJ//793UVM2a6L3FSQFpZWrVq5/5VaHrloueOOO8qvedFFF7kamyZNmrhmqbVr17o6nUGDBom0XNwsWLDA3YW58sorxbvvvut26A033ODa9yRffPGF2LZtm6Lsln7z0jdfKrujLW6ksturFJciJ0IIIYQI0bt3b7Fz505X7iH/fZWLFhmUr0xk/PXXXyu7MNJKIjcYPv/8c9ccJd3ApXt4/fr1y4/5xz/+4Qbxk/9+79ixw9XaXHfdde490nJxIztLBv6RK0npR79q1So34I/cOpMrS9nxkmjK7rLvELnafOCBB6ql/oQQQkhFqUyU4bLzK8Lw4cPdTzSWLFmilM866yxXMmIiLy/P3QGSn1QhqZobubXVpk0b8cgjj7iRDocOHeru2kh9TUW56667xJ49e8o/UkVOCCGE1NQ4NyTFdm6kB5SMkOilefPmrlhJUqbelkpueWwZsiy30qIhVeLRlOIyTgPamWPFmcEw8PGCOg+0jWsrShRdgf1ZDxMf35rUqz0IgSYG7f4I6n9Qs4Kg5kO/PsY6MV8Pv8YQ96izQFt7MQoX4hxavB/WB233qKHx6p1c4HtNV4FxePBry9zF/o54GmxNL2C5F4J9bwNCl2igxmZvRNX8yCfJVD/b9TGsvu0psvWX3zZX4zy/KskBDQq++7S0KFrKF3P6BKuO0LKlYNO14DsY0y/oqS+gbLk+vpMjcYwbOThI6s6N9JSS+Sy8yAiHTZs2LRcXywWOV9ktNTRS4GRTdhNCCCEpjdx5qeyHpN7OjfSDl2GbpVnqqquucvNQPPPMM+5HIgMGyUBAf/3rX8WJJ57oLnakaEmKlXr16pXMqhNCCCEHpeYmHUjq4qZ9+/Zi3rx5rk5GplSXixcpSPKGbJbuZtJNTepxdu/eLc444wxX2Y25LgghhBBCJD5HBpOpwUgzlnQf79p4qMjw/5ILB2KJ3LviDaX80O8uVspjPpillG/9XW/1JsUlxpgKqKFBjc39H7yilDPBXn736Zeq54dCxnghmobHSynEowDb9p3L31LKuyO5SnnCmWeq52dAW0NwfdQ/QdycB5cuUMqjuqh9LyBWikZRsbkvENt0twWdsowl9qd2PMw9/P72/6pz8f/O7gHnq/d7+IN5SvnuzpfErg/U7YZ331HK/zrzbOM8e3DV60p51Bm9jH078r8LlfIjZ1+klBcuV7/v2QHaiuC8x761aeVw7PF4fI5rqxqgx96brZTvPP0y87MAc3P8qrlKedjv+hiPx/had/5X7f/HTu8W+1nB5xD7KgBlPB7nqQ3oy8dXvqyU7zj9CuNYjoO+ubFL77h0iXrgGrU9T63Yr+Ms4+Yzesfs+9JIiXhr5yTXIcWb0iAR/y41nXiv8OdW/A/1SGGR+GrIQwmt68EKc0sRQgghB3FuKaLDxQ0hhBCSLGq07SR5pM3i5om354s8jD//Czd2ulIpT1qhmqEGd7hcKU9ZOTMul9lcX8DoYtqv7SXGLddpq9Tt8CJw/8Xrh9A92LNljCHpsS5DWl5k3N6duPEl470LnbDFhVRtW78uat9PWTHT6IqN7rz4fSY4AIZgdPxQn2Loq3jdgXOgPVi/IotrONb36tO6K+Wp69X+yIH+7tNRNY08s1Kdu6ax+sNJ5ynlGZ/MMaYnuLGjalqYAfMS3XWvaa6aTV7bAmaoTj2V8vilLxrde3dBeoTfQPoFRHcfNrsX43OF7sSDO1+llCctV/s6G+YCzq3BndTzpyxX24toY91GfTanrZkbc+7hvEMa+FXz7T6n1BjSQEtnAOBzPhD6atpy9b1RAHNrGJihpiyLPY8l+NRmYogIqP9geMc/A33vHetgMCKaNTfenlQxMmjv4MGDxZkoeziYs4ITQggh6QiD+O1HaoZkmiXpFS29p2UOq2pb3HhzNMmfTR9CCCGEpFZW8FRFJsKWC5phw4aJmTNnimOOOUZ0795dzJ49W4TQkaCqFzeHHHKImxBLIhNmyTJ+yn5PCCGEEHKgHH744W6eyfXr17uBek844QRxzTXXuHHtZEy8rVu3ioRobt5++23RoEED9+d33lFdSA8GRrQ7V2T4ylzBVYvtfZtfVcqDTlFdUoeufl8pD/jt+XHd2weu4Y4na7nkwS2vKWU/hDa/ptkF6vmgg/GBu7RjcmcGW7QDrtm3frJUKWcKVUPzx5PON7cN65aTbbzfyI8XGvvWl5VlrH+8rtwOuLj6wHUc64ftQ5dXvJ61fnC+DzQ4oz5SXfGvhbnowF8xN3z4rlIe0vz3Me/nQBiA+zb+N655NmLjr5HCJX2bX2Dsi9c/VZ+bHr89QynfvV4NgXCd5bnS5haODQLuztjXSARcsf11aivlh9bNV8qDWkBfw/Wdn9X0EfdteSWuscW5ecfaxcbx8oagcNCtHPvCMu81cJ6DvsiXpV7vrvXqO+0abCvc7y8bVDf3a6FvtefWEgbAKVH78p5N6ntmyCk9Y9an1JE/q1q3xCHrXRnTUs0wS3n5/vvvxZtvvul+AoGAm4X8o48+clM1Pf744+5Cp0oXNzIzaLSfTcj05zI432GHHXagtyGEEELSg8qalmqIWSoUCokFCxaIKVOmiP/85z/itNNOc7MT/OEPfyiP3yMD/g4aNKjqFzcVYcaMGeLPf/4zFzeEEEIIiYpMjB2JRESfPn3cNEzREmOfc845rvTlQEno4qaGBz8mhBBCKg53blz+/ve/iyuvvNKYVkkubL744gtxoKRNnJsJ+e+Ux7lBVcbgdmp6g+kfq7b1/m3UODQzPlFDiyO2WCtI/9aQcgDsyc9tftkYxybXl2GMWeGNvxGMhI1xV645TbVFC7Bdv7RVtfsjxaDRsfVNn05qDKGZEGsF48xg7BGMq2OLu4OqC4y7Y4vTY4u7g+DxGGsF24Nxbl78+HVzjKQOapybFzfPizn3sO97n3iOcWxxHuFzMnWjeq+GgTpKufsJnZXyjE8WKeX+EDfn6S3m2CbF4PbaCDQ3tphG+NxgHJndEbW9OTB2A6G+0zfNiSsGU3+Il/Xix2r/IdpYt7xQPX+zqiPxEoSxw3mGMXkQ7CtheW7weK2vNpj7Co+ftUl9ByMYo8gWj6pfe5i7UB9ve2Scm2Obieqhspm9a4gr+DvvvOMmw8bFjcwredNNN4nJkyfHfU3GuSGEEEJI0nj22WfFzyDAl8jfTZs2rULXTJudG0IIISSVkBtYlVFvHOzKj71797ryFfkJBoPKzk04HBavvfaaaNiwYYWunTaLm72RX72Ec/0wI7SQ+eZMzxjaG7e/QmCawdDgeH3NzTHiGLdgC+H+ERHbDIVb0hhGHcOgY7oFrNsexxxQqQi2STOh7nmYvRfuXwRmIVuY9WyLWckGmun0+5nPx+Ot6SgwebFj7n9bf6CLrrH9vojxXDQpYgh+URo2mqF2hPeptwOzEZqJ8LnCuYkmwe1hNaxAg4DZfRmfGzRDYd+G4H7x5mrGsSm0hCWwmUzRrIVg/b3HByPq1XJh7LN95ucAxyJeczCCZqg92DXQVpyL+M4Mw9RE87pmLsZ3OKbe8LQf044klDTX3NSvX1/4fD73c9JJJ2nfy98/8MADqbe46devH9OwE0IIIdFIc83NO++84+7anHvuuWLOnDnlsfQkWVlZomnTpm4Qv2pd3Pz3v/8VTz/9tPjss8/cEMlHHXWUmD59ujj22GPFGWfsD9Y1fvz4il6eEEIIITWYs36JmSe9oJo0aeLu1FQVFVrcyBWWDIvct29fsXbtWlH8S8RdmfxKJr2SdjJCCCGExEYGo4eA9HGff7Dy4YcfilNOOUX4/X537SCjEMdCBvWrlsXNX//6VzFhwgTRv39/8eKLv6aOP/30093vUpE7u/YSGf5fQvkXq7b6h/PV9AtDWl6klP+06m2jS6wW8t8S5l1kqN0+eu1spRwAQ2r/Nr3U8zHsPN4fUyx4wu77srONuovRG1S38yJHvdfQdpeZ62JbeUOI+YdXqi6fA9ta2mpLd4B9j2VLXwkMS48KftBDYdh5e3oIxxgW/671b8XVH0+tUl1aB7eCsAIZgZjn/vWTBcaQBxjC/rWN6nPQ89RzY99LCHHbuneM7rgPLlPHfsipqqsz4qudq/4CE+rBc4Xfa9o2W2oNaP/o9XOMYRN8tWoZ58Ljy+Yq5cHgGo5pWbB+965WXekHwngpYNoSTK+AfYXPBZS1voPzMbXHI2vgucZ5Cc/NvUtfMc5FDaw/vheg/neueEMpD8V3qud6pRHZV8+IaiGNNTetWrUS27ZtcwXD8me5axMtNp78vRQXV8viZsuWLeLMM8/Ufl+vXj2xe/fuilySEEIIIWnCF1984SbLLPu5qqnQ4qZx48bi008/ddOSe3n//ffFcccdV1V1I4QQQmouaSwobtq0aXleKekRde+997qa3aqiQkH8hgwZIm655RY3LbncMvruu+/Ec8895+aRGjZsWJVVjhBCCKmxOFXwOcjJzMx0dbwpsXNz5513ukmuzjvvPFFYWOiaqLKzs93FjQyVnIo8vni+qPNL+gXUtNxwmmrrH7te1eDccloP9fsP1bDpGDcHY0IUWCbgTSf/Xv1FpjosE9ap98MoDBgmHmPBeNkFASLqwfL22ubdjHWduEnVDYSgbWFhjnOD8SgwJP2k/NnGvsOxy9ViCGFMIPV+maDAqw1dtTui/qIBjC1e3xYRA+Pa4NzAWDLXNbtAKf9z83xj+28ETc74terxWZ7+wRD1fzyhq1Ke8ZmqtzrUX1sp92ix37OhjAkfvhzzXpKBJ5yn1m3rbGPd//XhfONfXt+FVU3LcRlFxvhPCM4VZBeMPc6VmyFNyr/WvRzX3B/WWtWRjAOtXR48GxiD6voW6ntiIqQo8M6tnWFVr5MJcW5yMOYRYHuucKxxbqGm5am1L5v7Budx/jzjOw7H2vZXOvb942tUjU+ezxPnJhgRp7WwXJBUKTL1wvz58w8443fCFjdyt+buu+8Wt99+u2ue2rdvn2jRooWoU0cN6kUIIYSQGKSxoNjLiSeeKB588EHxwQcfiLZt24ratdU/rG6++WZRrUH8ZJAduaghhBBCSJxwceMyadIkN1pxfn6++8HNlIQubi67DFyADcydq5ouUoE6Prn1uP/nTAgV7svOMppq8PsGEJs8G7oRsxPj9jaGBvflgHs2bMHW92cYw65jVnC8v3e7Os8fO2T7gbiZa2HW4fRiLZswbtX7je7DdaAtfkgtEYB0CxjSH81AOVAfzGaMYP/gXMmxbMdr2YphrHGsIjA3fOCK3gBMFXh9dPlt4M+MORfQJCYgFQaaoX6MFKh1A/ddNDFmC3iuwLyKZhd0u7elusjzlxjTKQTA1KLNNQt5fnWuaUD7G8BzqadT8BnPR9MP9p9WfTi/ni/2WNeDtuima3O6BJwr+A7T5hIC8xLNv9qLA+YCvvOwLwMeM1LU7/H68A4/1I/pKDz9gSliSMJJqreUdPMmhBBCSBWRxt5SieaAFzdTpkxJbE0IIYSQNCKdIxQj//vf/8SCBQvE119/LUog6OTo0aNFtWpuduzY4Qb0k/z2t7+tcGpyQgghJO2g5sZl8eLF4uKLL3bj5G3evNlNy/Dll1+6EYvbtGkjKkKFFjd79+4VN954o5t6oSwsciAQEL179xbjxo1LSRPWsE4XiAzffrtrpKBQ+e7eT9Sw5v2PPVspX73hQ6Xc7zj1e2tocHRRBfv3oxsXGi/X+/izjdoHLTQ6aBsczyoY0y9giPnHt6h9cXhAvfYfTjrfeC9b+gUM0z7yY7XtVx5/llG3YQuh79jSK1jSH2B7IkVqSHxEC+EPGh8H74fnQ/tGfvyeUv7Dieca+3fkhtfN/eeZK9j3r3+2XCl3P76Tei+o+1+3vGZ+DqAv7tv4rnr8Sarr+fAPlyjlQUfvT7gbi0D9+krZ+bnIOJYibE4h4EetGzy3kX2q5uhueE9c1fR09Xq5kB4CuGP9f4xhF7zPqcQHupU/rf+vcay97dfmMaQR0dOwYAoZn/E5CEAqDKz7iE1vGsMC+Gqrbv2DV3yglHufeI75OQNwbJ2QOtev36T23bXwjvfXyin/udSRbXnOeD9Stdx1111uKBkZzC8vL8+NeyM3S2T+yt//HkKlJDqInwzg9+qrr7rpFuRH/rx69Wpx3XXXVagihBBCCEk/Nm3a5OaqlGRkZIiff/7ZDS0j3cP/9re/Vd/OjVzILFq0SJxxxq9/aXXr1k1MnDixwqssQgghJJ2Q+2OV0tyImkHt2rXLdTZHHHGE+Oyzz8TJJ5/sln/44YfqW9wceuihUU1P8neHHHJIhSpCCCGEkPSjU6dObm7K5s2bix49eog//elP4qOPPnLDysjvqm1xc88994gRI0aI6dOnu0k0JTJ1uYxYLJNfpSJPLV8k8srTL6jr3cGQAmDqF2qei8HtLlXKMz5Xw54jGF8DY6Hg/fu0ucioq5j52YK44twUOhjjIhAzFkc2xH3p11JNReEUq7b2GZ/8x9hWvD6mgsB4FP26XKmUZ342O67rYRwZjH2CfYVxbmxxaZCQlv7BrAUIgQYnYIltctUpqg5jxtbXjP3dp5M6d6d8Okspe49uGKhj1NjM3PqOUg7CPBraUR2rGZ/PMdYNdRPPb12slPt1VOs++ZtZxuckCLKQIwLm1xfGe8KxxrmozTX4fmDHK5TyC1+Z43nh/TDVyNRN6lxHcK72a62+J2Z+9mrM90wwgvGs1GvnWWJjheJMb4DzGtv67Kezjc/R0E5XKeXnt86J6zm1PddampcvXoo51jL9wknNRfVAV/BybyiZ6UAidTfy55kzZ7qRiyviKVXhxc348ePdtAtNmjRxPxLpviXzS+3cuVM8/fTT5ceuWbOmQhUjhBBCajT0lnKRXlJeE9WECRNEZcmoaJIrQgghhJBUpEKLm/vuu08cbOT4/O4nKuBGiGYkURo2btmiqQS3eIswBQBsd6OLrg9cUrX6AMXCbHrxmmawB3ArXgPcznErH80+iK3tCPadbTsc24rtwb4Lwfc4JzB5hM2kiNvfODe09AwwlCFIL4Hg9nsYxlpY5qI3pcKO8P5t3wOdZ1oIe3hOsK0C0h/g9bW5hhncISs3glm30fyKphGcq1jfXBh7bC+aTrD9mGrE2n8WkyfWH+cWujvjs2IzqcZjrvXjvLaYY21txfO14yGEA5pz0dyMz4HVvIzvePg6x+P6rqWkSSRpvHNzyCGHuHmjDoRdu3ZVbxA/ibSNRWBi1q1bt7KXJYQQQmo06RyheMyYMQm9fkZFk1wNHz5cLFmyRBQV/RpIS0YTlCuxssB+hBBCCCHIgAEDRMotbvr16+cuZCZPniwaNWp0wFtLhBBCCPmFNDZL7d27t9zKI382URFrUIUWN+vXrxf5+fluPqmDBWlvL7O5oy4B0bQ5ENYddSBo20f7r82W78P7OebzCy3XN7m0FuG10VQOYdRtOgGb5iUEp2di12PYd8Bm/0bdg67RQR2GmRJob20IY6/rOMz3x+NtLquoDcDj8X6oVfBqbCQ/Rn5NIYA9jak30JU7iBoZ0J4heL5t7uh6IdQXqX1XAm6vOHdtmhocG10bh/WBE2Au4HukCAVVaDOIxBcWYB9oilCwhccXevRb2Dc2rZs2DwHU2NiOx77Cd5SmI4S+wPAWOFbYdzj2GOIC65OTKn+Qp7nm5vvvv3fTLNSvXz/qJkllrEEVWty0b99efPPNNwfV4oYQQghJJdJZc/P222+LBg0auD+/844aY6sqqNDi5t///re4/vrrxbfffutm78zMVD1qTjvttKqqHyGEEEJqGGeddVbUn5O6uJGB+mTuh4EDB5b/Tm4dUVBMCCGEHCCMUFyOdE768MMPxY4dOzQP7IsvvlhUy+Jm0KBBonXr1uKFF144aATFwy+4TGT4s/cXQqot+/blakqB/m3VIIX3rnjdGIZdw9YfoOF5MH+eUg45EGK/g5r+QWRAyH+09cPEUHQc2VlGHcVDH0Gqh4g6Rfp1uMxcFxvQ948tm2sMk671Jeo4sAy29bjB9hQVW47PMPc9li3nD1v7rrm/oX0L89X0DD3bdot9PPTlyE3qub07wjwD/dVTa182piURAbXvhq17zxhi/+Fl6ry/odVFZi1aXh1j/bSxNz0H0Y7PhLH8+VdPUMlIeA/ge0J7toD7l6tpW/rjewTiXWH9Bq9aqpR7d+gV+1mA+FT43FnfUZY4Mdq8h7o/uXK2McUN9vWTy9TUG73xeMQ21lD/kR/AOxyv75m7pRH5zFc+Qu4BkcaaGy9vvPGGmxU8WpLMatXcfPXVV2LBggXihBNOqMjphBBCCCEuN910k7jyyivFqFGj3A2TqqBCf+aee+65rscUIYQQQionKK7Mpyawfft2Nxl3VS1sKrxzc9FFF4nbbrvNTUl+6qmnaoLiitjHCCGEkLSCZimXK664wg0KfPzxx4uqwudIFXCc+A26hlQTFMvgQPXq1RObNzUSeXn+qDEWhnZQbd+TVs4xagumrFa1AgjGYMA8J5gnpU+bi4zahRmr5hljTNhir0RMebCgboNbXWyMezN90yJjbBNbbieMl9Gvy5VKedIHM9XrW/MFReLqe1t8DC12CVwf4/bkwbOA98PYKRhfA+fC1ad1V8rTP1xojGPTs0MPpTwFtAume/U+6VylPOOTt5RyEHQMN3Y0PycYW+QPJ52nlGd+8rZS7tNR1RONM9Q9Wtybw/0B89yA2CgYEwnHGscO1VKDof3PrHhJKcfMXRdDTzZlxey4cmP1a3mhUp6x/tWYzwLG0sJ528CfYcw1ZYuHhXFrsOWoS5wGcwWfq6EdrzQej8STR8utD/Q9zl1v/YPBiDip+XaxZ8+ehKUSKvt36bhRjwh/Tk6FrxMpKhKfPzgyoXWtDgoLC12z1OGHHx51w+Tmm2+unp0bVDITQgghJE4qa1qqITs3L7zwgvjPf/4jcnJy3B0cr5OS/LnaFjeEEEIIqSQ0S7ncfffd4oEHHhB33nmn0TJULYubgoIC8e6774qvv/5alIDpoiKrrEQju6usy2xGM3vo7oBx+xu3TDGEPm4B29wubekV8iBUedBgCimw7Lo5aFK0bP/i1jmCdUfTALqx29IXYN9jX+RASHrhi1jSIQijmQpNDTlwvG4KMZuhNLMZvp2gP0zpFPYfHzngdA04T3FssS1oBsJ56beMtQ+2lrV5b0lrgjMVIx5o1wNsIfwRfez8lhQBAfPcRiwmSVv9hB/mEo6Pp74hfEdY/sHQ5g28JbEv8DnR0qRgqgoY3SJsKxyPqSWKoT42E56WHgKuj2Nnm0skscg1RO/evatsYVPhxc3atWtFjx49XDuZXOTIEMrSPz03N9fNE5GKixtCCCEkpeDOTXmG8JkzZ4qRI0eKpC5upKeU9JiaMGGCK4pavny5KwCS2cJvueWWKqscIYQQUlNJ59xSXqQT0uOPPy4WLVrkpm9CQfHo0aNFvFRoD2jdunXiT3/6k7uFFAgERHFxsTj66KPdylXlyosQQgghVcu4cePEMccc4wp4O3bsKFauXBnz2FAoJB588EHXTVse37JlSzeisBd5LSn8xc+NN954QPWRYWVk1gO5ptiwYYNrHSr7yPVGte3cyFVVmW1MmqGk7qZ58+buLo7MFp6KDOt0gcjw7Q+P7oRCyndPbJpndGHtt3aVUr765G7xhSa36FYeWa+6++b41OtdfXL3yt3P4JrvgGZj5AY1/H+Jo9qmrzlFdT32gds6uo77crLhe7XvR61T0z1ci9eHtmmaICxDfTRsx8P32v0AbL+GzWUV2vfaRrX/e7Q4y6i7GLZSTXHQt/kF6vGG+o38WL1X35N/r5TxORm5QXUVv7bF740h9Uetg+PBlfmO1Wr6h+tO7Gpsq9bXFp1HvGOPcxev/8SmOcb3hL92rno9SN/wAKQ2Qbd/Ac8Gzo1H1qnviaubnx+7PRbtnC8bnktM/WB5Dmzz/ub1b5nrCgxbu0QpX3VKN3P9be8FaM9dH75+wPUpdeQ8eE7UVGbOnOkGzJOWF7mwGTNmjOjWrZvYsmWL++85cs8994gZM2aIiRMnimbNmrm7K5deeqlYunSpuyCRrFq1SgkBIxco559/vuvefSAkIit4hXZuZINkY8qyecqQyc8995y49dZb3SzhhBBCCDlAzU1lPnEyevRoMWTIEDfxdYsWLdxFjtTLTp48Oerx06dPdy0yUmd73HHHiWHDhrk/P/nkk+XHyPg0jRs3Lv+8+uqr7k5PIrJ9J3Tn5pFHHhHBYND9+eGHH3YTXskGn3TSSeLf//53VdeREEIIqXFUleZGBgX0kp2d7X6ieSXl5+eLu+66q/x30grTtWtXsWzZsqj3kLITaY7yUqtWLfH+++9HPV7eQ+70yN0hU1Ltyy67TEydOtUNPih/NjF3rppgOWGLm5NPPlmUBTaW21hy5Tdv3jx3FdiqVauKXJIQQgghFUBqXr3cd9994v7779eOk17N0nyEOZxkefPmzVGvLU1WcrfnzDPPdHdjFi9e7C42YmUimD9/vti9e7e49tprjXWWMpayxY/8uaqp0OLmkksucVda119/vduITp06uToc2XGyE+QuTqrx1PJF5ekXEEy/MOMTdZXYv20vpTz94/nGe2FMBwRjm/Rre4lRO/Ai3A9jMmA8j31Oacy4PZiuALn21J5QWfVekzcuNMaL2B0pNcZ5QQae3lspv/jxbGNbMR4Hxhap51dV9sFIyBhbBMfCFqIf43tgTCSMr4Fh5rG/DvHnGjU2z2143RjbBFMYTN80O2Z968A8ufLEs5XyzK2LjGM5DNKQTN0435xKopmqoXlx8+vGuo/fqqZfwKcoZEm/gHFibDGYEC1mEowtpk+Y8cmcuGKt9G+vtve5D81pXBBMvzAH+tP7rAQjGBdGGGNj4XOGMX8ytbYJ43PSv5OqtZi1aa7xHTUYjn9uwxxjX9rSpmCssYFw/ckb1dQZAtIvNGsuqo8q8HiSWldv+oXsKLs2FWXs2LGuGUvqbeRiRC5wpEkrlhlr0qRJonv37uLII480XnfKlCnlP//rX/9yMx/Urr0/rteXX37pLpKkllcurqpNc7NmzRrxu9/9zv159uzZ7qrvq6++EtOmTRNPPfVUhSpCCCGEpBVVpLmRCxvvJzvG4uawww5zPZxlFm4vsiy1MtGQehq50JAx7eS/83KHp06dOq7+BpHfv/XWW+KPf/xj3BsmUtsjKdswkZqeXr16ifHjx4tqW9zI4H15eXnuzzIfhNzFkXY7WSHZOEIIIYSkFllZWaJt27auaakMuWMiy507dzaeK3U3Rx11lCgtLRVz5sxxFyTRdmOkVKVnT7AAJGHDpEJmqRNOOMFdyUl3MOkWJoP6SXbs2JGymUllVtyyzLi5aCpBN0gEtjhtWb5tphTc/halaLvELWJ1E7hQ25I1m1JM52ph2aEv0MUSV8NaWwDMLpwHpgRsO7YVt7/RrIZtLYTtbjzfZobC+qIpJxPUfzjW2nY9bOejGeqnSKGx//Xt+IjxeN0U48QMYe+EzOdm4TwKWzKwQ10xzICWXgC+x+cS+3JneH8ohzIO98Pc0Z4LYQzpj3OlyMG+iy9dhc0UhO3FsbS9R9BdW597Tsy+y9FSa5htIWg+RbDuWpZuKOt9bT4+YEunANhS3mDfI96jqy4BQGoG8RsxYoQbEbhdu3aiQ4cOriu43JWRpiaJdBCSi5hHH33ULa9YsUJ8++23rp5W/ldqeeSC6I477lCuK38nFzfy2hkYniQJGyYVGkfp+v3nP//ZDdwj/eTLVnyyUmV+74QQQghJLVfw3r17iyeeeML9d1wuWGSQPBmUr0xkLOPWff/99+XHFxUVubFupMOQ3NCQCx/pKVW/fn3lutIcJc8dNGhQ3HUq2zCR2iG5YXLBBRdUesOkQoubK664wm3E6tWrlUiF5513nvj73/8uKspjjz3mCpZkvBxvx8ooh4ceeqhr57v88ss1eyEhhBBCDozhw4e7OyLSzVvuzMhNijKWLFniumiXIWPVbNy40f23WDoNSVNRNLGwXJBIL2oZEiYVNkwqnBW8LFiPF7nFVVFkUMCnn37azSvhRZq8Fi5cKF566SXXXUwOityy+uCDDyp8L0IIISTZMLfUrxsmZ5xxhrtjJNM7eDdM5G5RtS5uqpJ9+/aJvn37uuGd//rXv5b/fs+ePa5b2fPPPy/OPfdc93fSpifdw2SyTmmPqxLA1o/uu/i9TUOj60DU78OauVm9nw/txRbQ/o327NoeXU2Ro147F23fms7CrClBNFu/5kpt1jHYwL7fAzoH1FlgX4dBd4KamBDoLlCngroO7GvUjTQM1FHKO8L71OvFqSXQtAo2LYTn+n5LV6MuQtNlQDoEm8YFx7YAdQ8Qwh81PHh+jq/U2Hcllr4JC/P5IXg2MrH9mibIMc79CFbH0l7U0BRaUg7gWHuvh/MYpVioNcM3DuqHUCuHfYfPGWpcdO0c1g/mFpyBzwHOTZsbPoLnF3jqs686FwwVNC0p59cQGlfxhkl1aqdiIs1OUl0toyR6kZEUZdIu7++lr32TJk2M0RRltEbvhxBCCEk5kqC5SReSvnPz4osvum5gZbmqvGzbts11XUPhkhQ+ye+iIRXeDzzwQMLqSwghhJDUJqk7N1IZfcstt7hJNzF3RUWROTOkOavsk6pZygkhhKQ3ZZqbynxICu7cSLOTdPVq06ZN+e9kvor33ntP/POf/3RdwmQSLhmx0Lt7Y4qmGCthmN+zkrPpRjT7MYC2blwhov0XdR04IzWNDWgbMJ0DxrVBML6Gtz4N/Bh7xNJY0AmgrRrjUYQt8TS0OCxga8fvw1rcG9Rh+OLsCzPZWhwbs7YgXo2NrkmCGllivWjtxThFgHd8UK/kg3mGGpBCTTRijoWCmhFhqzvoMlCTo8XZsYDX1zQ8CDQvB54r29zCuYrH22K5oGYJR9J2fxxP73sJn0PUsNjSKdjiSyFa/CoLMPWs2jstXhUcrmvtbFo2ON8zGTKq09ZDzU3NXNxIJfRHH32k/E4GEpK6mr/85S9uMjCZs0pGT5Qu4JItW7a4bui2aIqEEEIISU+SuriREQlPOeUU5XcycZaMaVP2+8GDB7sRFRs0aOAG87npppvchU2VeUoRQgghyYA7NzVXUGxDBgWUYZjlzo30hJIZQmUG0XiR7tBel2gT2nY4hgZH13DYUMbteQyrLnD73h+fWySagvD6Ebg+un0agT5C91Pczsatcb+2gWwxDWRA3S3ZiG2gG75uIvQbXb3zDFv90cxcNjMUuvOiGcuWudqWddxmljKl4hDa2Fn62hLiQKuJzUyEZhq4f3HEbDbCuRXvc4lzN0dYTLYQFiGuvo5yvu1thNfDVCiIt7719cGAa/uN7xRMAYN9ixZLbV5a+qJ2fI+19hxko4VTc0031wf/LfAeH4rTHFoZGOcmjRY3MjqiFyk0HjdunPshhBBCCDnoFjeEEEJIWkCzVMLg4oYQQghJAjRLJY60WdzsiTgi/IuhOE8zL0eM9l1NA4MunBb34QjYrwvQQ9RiS0f7cRClB37z+d7W7IFz0XbthEJx6Y1Qz4Mh8LGqqDkRpeb0BuhKbvFOjnI+6pXM9UXdRwOwzR/iz1XK20Bjg9dDd17UR6FuBecCagmCmMKgtNSopfCOD/YF3gt1FyjbcEpCcWlMfBBGQEtrAn2LOowwPFfbwmqIhzxfiSXtiIhr7uJzlavFeDCrZHaBf3Em/ssD/YGanlzL3MBn0aRPQ61XHtTdln7BNrZ4vE3jgsfjewj71qaXQvBytne46fw4FIokhUmbxQ0hhBCSUtAslTC4uCGEEEKSARc3CYOLG0IIISQJSGNZZRzPq89p/eCDi5soaDEbUOcAoFYB4+Ro9uxKLrcxLA5eH7UF3vglmT6MwRPf44G6CWw7alYCcbYV21JiCbNuw3Y+xq0JwfGosfkpUmjp+zjj7sTZ/7b2a/E+PGVbzCDUN+mpHnxxhbi3hdTH50rrK1tmEIyjY4l1kufPVMp7HNCX2dKwWN4DqLHRFDoWjVO86KlMfv2xKAJaL0uqBy2mj/bcQPwn1PtUNjYM9C3G9sKeR30VPhdaugi8vkHbh88BOTjh4oYQQghJBjRLJQwubgghhJAkQFfwxHFg+QgIIYQQQg4S0mbnpo7v1/g2aK/F/EYFaFu32JODjhprxGYbz/MHjPFAbPE06qPoBsD6RwzxLlBD46+takyckLltaGuvb9Gw2Ppej1WCuZ6cuGzv2NeoScHrHZ+h5or6rFSNY4NgHJyiiKqr2AWBeTJ9IaOuBecC1i8H43fkZBvHXsuT5sEP52JclWAE8ozVqgXHm/veFkcH2RbG79XyUYES49xCTRFqcraHS4x93wAEU0EMqgRjjf2Fz1a8sV/welp/afG2IjHHoxHMoz0wL7DteC9tbCFWF6K11fKc1rO8w2zaPoyXhRog7T0D6G9YX5VpoeKCZqmEkTaLG0IIISTl4AIlIdAsRQghhJAaRdrs3Mgt6rJt6iz8UksxICq8pXkgYdS1sOoWNDdM2LLFkP4Bn/p9bc/5tu1eLRWEtj0d33Yy9oXm1IlmLX+GMew6hlUPw3Y5mm1sW/1HBfKU8rfhIFzP7B6MZi493QIe7zOHiQdzApr90EyF6SvQjGfCiZjHKuCHsYLUHHgnPN+XpT1pKlDXLEvge0xbgmlU7O7Mwtj3QTApaqlCtLE1m6G01sDY6q7sZld7NFnie6Ge5/RdmhlKGMF5ZnOHtpkAsa+s8xKOx+vjOw7fCzgWRdj7aN6G9lWrKcoDBcWJI20WN4QQQkhKQc1NwqBZihBCCCE1Cu7cEEIIIUmAZqnEkTaLG6lVKNMraNtVGRlmXQl8j/ZftE+jzqMehH0vRNdxiz1ac9NEnYfleFOYfM22HlZt1Q7oLCI22zumY0BXc60C5rDrmi3fguZ271PHrq5fdWfeFt4Xl44C9VjZAvRVotRo29d0LTjXQPOkp2sQRrC+3vtr+ifoe5vGRdecmMca546mLwKyLW/qYgfmGrgTZ8Lswr4NaCH9zWOraXgAHBt8lrRnS0uBYO4/29zX3bd/nTu1tTQgfuO8xecOwblTjOkNLG7vqBUrsRyPbUeNja1vdK1fnO2pLmiWShhps7ghhBBCUgnu3CQOam4IIYQQUqPgzg0hhBCSDGiWShhps7iR9u8yG7gtyozN1o62dLTXarZ3LRR5fPZq/XpQX4hrY0pJoJ1rCfHuw5DyUBfULeD3mq7A1rdQ91zQzKA2AEPw4/eHBNR0CnsjPxvrmw2bmQWaDsJ8P7TcY38XwxHa1inEMtH61xJW3qQcQE2HAM0Kfh8CjQtqw2wqBZ+lLTjXUFODEfqxjM+RHnsFY6OYYzzhWGnxriwaI9SBFFrSNyC2OD3aeMEIeOeyrn2D5xLeGTg2RTAWmcL8jkH9FaK/N8zYYgYFLMfb4vRg/3g1QJoeKJFwcZMwaJYihBBCSI0ibXZuCCGEkFSCguLEkTaLG7llXbZtjRlvhS3zsrZFap5ReL4eoj++DTPcQsUtYM2tE2a81wW3ENMV4M1w798SFl13KUX3WvV43KnH+6HLKrrN4/fYFw3BDLUDXL31883pGvD6uD1umwto2sAw92h2Q9C9WYA5IZ7UIBjCQBtb6ItcHxhwIaR/vO63WlvwfL/Z/Ipmq1zI+K6Z1WC0cKyxPmFw47c9pzi3tTAEcaTC2F8f83jox/tjHr87Umqeh8L8nOVo/2qas3LbwJAM+B5CsO0282zAlqYEQNfyLM/53p8TDs1SCYNmKUIIIYTUKNJm54YQQghJJXyO434qcz6JDhc3hBBCSDKgWSphpM3iRrouZv6yytVC2JeoYeILQFvgFBcr5d0gHKmvudRiCHyzfdmB+/sywT4N9mHdVVG1l9cxuE+jfkdTUaAoRnPnVdnjhIyu2egyWg90Egi2VXddV78/KpBnTKegucVbxgLrb0t3YLPt4/Vy4Hp7IiFj+oUgao7QdR/mKo6PV2+FOgN080c09164F6ZTwLFD12ctxD+kZ8C+QnZHspXyYYFQXLoLrK8txAKGAcD6omu51ZUczg9G1P7KszwbTqjU2N9+k1s9XCsH9FSolUO9EbbVpl+yzWPsK+wbDK+B9cfnOgu+11zBS9X7B+Fr7zscdXHk4CRtFjeEEEJIKkFvqcTBxQ0hhBCSDGiWShhc3BBCCCFJgDs3iSNtFje1/X73E01TI7IytWO9+HLUaDCN/Gq37dNisZjjX2DMBtTYYPyRen61fkHQaWD8kl3wvbc91tDiGOcG9EDYtjowhfaB/geP11IAgMZHs+VDua6/llL+Nhw0xlrJjtN8jukRbNjs86jzwPbj96hxauBX1QSom9Fj1cSea6hJcUAXgfNSiwdluPaBxLnRUkfkZBs1PqibqO8vjkujg/VBjYqtvpoGJivLeL4tFQe29/BAljHWDL43fPCeMtW/yIdxa3yW+ElqMQjvyFyLnimMWjaYx9pY4PHZ5r7FuYBaOC3dBPZ+ptp3DeAd750bWnocclCSNosbQgghJKWgWSphcHFDCCGEJAGapRJH2ixu5DZqTLdddFm1mG6KYUtVczuEYrYtNDi65EIZTRHotplpybhrag9mBfeBmcSB7WU0LRSDS2ncIa8tbvSHBmqZs3pbsoJjegNt7LQM6mp90ISJ7r2QMUBPP4H7/QCaqTCTNo69LbM24m0fzgu8l55ZGff+A5ZM0+a6oVkMCWpJy83HWzNLWzLWaya+OLOoo7syzp0iS7oKrb81M6DxdK3+3v7Vs9eb3xm2bPPoeq09B1hZS8Z563NhGV00q2kZ0hncLu1Jm8UNIYQQklLQLJUwuLghhBBCkgRNS4mBiTMJIYQQUqNIy50bLaw8hP7WgNDdaF9G92XUeaCLpwba5rWUARjq3Gy/xvZ53SrD4KqtOrnr7sEO9I1NN4GWcrOzrU7jQB1jOgXUNaDtH13Hse+x/uhGvztidqHV2mdxsdU0MgAe78BcQ62CpkSwaAu89cvBe0E4f5y3EZgrGFIf/zLCeeiUlKinY13h/tmWP2GL4fo2N3sEn1N8jtFVXLtaadh4f9Tg6O+ZUqP+y5Y+AucGzl2vpgjd5PM0XSHqhdTvc6D1tpAHmuam1NyXmk4xjOkW4DmHMuqNsP6apAfesVqqkGQhx7gy+iBqi2KSlosbQgghJNnQWypx0CxFCCGEkBoFd24IIYSQZEBvqYSRNoub4d0uFxn+7Ki273tXvKqUB3e8QinftOxtpdyv4+XmmwX8xhQDyP0rX1bKeX5Vq9C705XxpUxAvPZstJ2DLfqhdQuUcmFEDYvev8tV6vl4PbCdiwyYYqDhWbhqoVLu2alnlAZ46+vE13ZL32tjhTZs0A5oZATMx1tSGOD5o9apc2Fg56uM7X1s6Wyl3B/mrtY+DyM3qX3fu8vlxrY8vHK+Wje8F+g6Rm54TT3+9N5K+cGl85TysNaXwPWgr7KzzX2LbcW5aIsvZdG+PbZMrW+/9pea6wcamSeXv2R+lrC+MFf+tGqRUu7TyfAewr7DeYnz1vacoC4R0hlgXz0MYzsY32Fw/4c/UOdxv05XmNtje+/AWI6Dvh/aKfZ7rDQi03xMENWBL7L/U5nzSZovbgghhJCUgjs3CYOaG0IIIYTUKNJm52b0G7NFXp4/qovmwHbq9vL4VeoW5rC2vZTypDUvGV1C0f3XFgp8YKuLjdvr0+B+mLXWlt3Y5AKJ7rHXnNbTmBX8uc0vGdtqS12Brt4923dXylOWzxTxkGlxx9WyCWsZ2lUwa7rmzltJsL7oknvtKT2U8uQNs4xzDU0jU1a+dMD3/sOJ5yrlmVtnG0Pa92+jmo1mrJlrdNftfeI5Svn5rWrd+nW4TClPWqfeH9kWVl9XJ6DFE+prc3dG9kTMru7D2kN9V88xXg/n3tAOqqll0sqZcb1H8Nmcun5WTFdyzOqNbakNJjk9DYl5nqLbOp6vv1Oxrmp9hrZT+3Za/ktG13BbffD4fm3U+oxbPSumq3wwGBHHNxPVAr2lEkfaLG4IIYSQlIJxbhIGzVKEEEIIqVFwcUMIIYQkgTKzVGU+FWHcuHHimGOOETk5OaJjx45i5cqVMY8NhULiwQcfFMcff7x7fMuWLcUbb7yhHfftt9+Kfv36iUMPPVTUqlVLnHrqqWL16tUiWaSNWSrL53M/kiBOCHBXDmHsbnB7xBVhEGz1qNNAezBqZjS3zACEVYetxzDW32fWDnjrUxiBg/1qXXzQFw64iKKmBcOyY980tKRTwL61pXdAsK0YZt5vefhR54AqnELLtm8uhswHnQTqUGxzxZcFLraAFjY+E1N9oHbCWxfHONZ4bdQf4VhhW1DH4cvKMqdHgO+L4H4hR+2bPL/qWr0PI/hbXEeKLH2P98vFyZOt1hdB7VsQ067A2OLcs86NnJwDnmtaagz0nLbMa3yukExNVygsz7XxckLkZBvfkagNtGlssC/x+ti3Xo0S6pVqmrfUzJkzxYgRI8SECRPchc2YMWNEt27dxJYtW0TDhg214++55x4xY8YMMXHiRNGsWTOxaNEicemll4qlS5eK1q1bu8f89NNP4vTTTxfnnHOOeP3118Xhhx8utm7dKg455BCRLLhzQwghhKQJo0ePFkOGDBEDBw4ULVq0cBc5ubm5YvLkyVGPnz59uhg5cqTo0aOHOO6448SwYcPcn5988snyY/72t7+Jo48+WkyZMkV06NBBHHvsseKCCy5wd3uSBRc3hBBCyEFsltq7d6/yKS6WgQh1SkpKRH5+vujatWv57/x+v1tetmxZ1HPktaQ5yos0O73//vvl5QULFoh27dqJK6+80t39kTs6cqcnmXBxQwghhCTTW6oyHyHcXZN69eqVfx599NGot/vhhx9EOBwWjRo1Un4vy9u2bYt6jjRZyd0eaWaKRCLizTffFHPnzhXff/99+TGff/65GD9+vDjxxBNds5Xc3bn55pvFs88+K5JF2mhupH27zMZdgroFCC2O2gRRrKZDsFlk0RaOkc3RNu/A/X2oPYDrobYB42F4dRaoZciF5SxqQjSgLlh31DkcGqitlHegxgaBEPUYJ8esiNHB87F+2F5b3J8ClJ3YdB2g28C5hO1BnYlTFP0vrgMdLxx77/G2GESIpj2L83tsC85jAX9dhuF6JdBbeUIdK1SF4Nhhe4vweCj/EgarnAIYS3wPoCYpLEqN9RHYH1qsFvNcd4qwBVBfj1akvj/DqP/Ba6N2DvumxPIe2IPv1BK1r0LaO9BnjKeF8xw1Nfh9kfYcm8cO3wuKVu8g/JP/m2++EXXr1i0vZ2MqkEowduxY14wl9TY+n881NUmTlteMJRc9cufmkUceccty52bDhg2uyWvAgAEiGRyEw0gIIYQc/FSVWUoubLyf7BiLm8MOO0wEAgGxfft25fey3Lhx46jnSHHw/PnzRUFBgfjqq6/E5s2bRZ06dVz9TRlHHHGEq9/x0rx5c/H111+LZMHFDSGEEJIMnCr4xEFWVpZo27atWLx4sbLrIsudO3c2nit1N0cddZQoLS0Vc+bMEZdc8mvEcukpJb2tvHzyySeiadOmIlmkjVmKEEIISSWSkX5hxIgRrqlImpGkZ5N0BZe7MtLUJOnfv7+7iCnT7axYscKNYdOqVSv3v/fff7+7ILrjjjvKr3nbbbeJLl26uGapq666yo2b88wzz7ifZJGWixst5gLE+8BYKbb4FH4RXw4btBf7ICYExrnJ82EcHswtpX5f5JRUPD9SnLqMQ/y5SvmnSKExHoWWBQvyaKHtH8mFK4SFaquvA31RDMoMtN2jXgmprVXHZxzr2pqawdIe0C5gbBhsj62+eD2vriMHc5DBWOO8Rh0DHp8Db9ZseJ34IAaPlgMNvkc9U8BnjrViy6mWjfmPYC7kQN+i/kobe3hO8bmyPff4nsmNc65iXCLtveCLxHxH4DvH1ndFmn7InNtJe8fAPMZ3qhZnB955tvph32Dfa88J9B3qobz1scUAOtjp3bu32Llzpxg1apQrIpaLFhmUr0xkLE1J0oOqjKKiIjfWjRQNS3OUdAOX7uH169cvP6Z9+/Zi3rx54q677nID/klXcLlo6tu3r0gWabm4IYQQQpKO9DZBj5N4z68Aw4cPdz/RWLJkiVI+66yzxMaNG63XvPDCC91PqsDFDSGEEJIMkhChOF1Im8WN3KYs26rMRFOBxR1Z/97skIxbong9zfRSat5+xy1m3cVVPR/bFzG4dJalpPj1YGg7hCKv66+llPdGfjZuf2O6Bi3dgWULGLeIi8FUobt2w1hZXMHRkKC5K1vdjSNxuZ7j/dAU4oTDRlOFhmXueLfrcR45ljDz6FYuoG42sC1a6gjbvEdXbCBHSwViNk1gioAwmNW0dBMItAd7z5Y+AZ8l29ji3HLwPWQIjIDPjR6CIGw0kZnMNvu/D5jHFsJbeN3Uo753LHMr01IfHGs0W+E7HNM7eM1g2rwnByVps7ghhBBCUgm5jqqUoLgqK1PDSKoruFRjSyFSXl6eG7K5V69emjuZFDPdeOONbqZRKWa6/PLLNR99QgghJF0jFJMUW9y8++677sJl+fLlbkhnmVpdJtuSbmleF7NXXnlFvPTSS+7x3333nbjsssuSWW1CCCGEpDBJNUtJ9zMvU6dOdXdwZGKvM888U+zZs0dMmjRJPP/88+Lcc891j5FZR2XkQ7kg6tSp0wHfa2jnbiLDv9890flZDWP+l49/DWgkGXjSr0nFJJetUZXiA+B7H7gxCrQn4+oavn/oI7UfssAW3w/vlwPRJ8Nm7YTjCYXuq5VjDJH/4MeLlHL7bNX9tcdvz1Avjm7ziM9s+77rw4XmtqKbPNrmwcVT+x7TG4DtX7s+1NeJkYCu/HC4P+oitPrAXMHz/7Tu12R0kmuaXWCs393rX1PKfZudHzuMAYS4n7JFHeu+zX9v7LtHNryilP940vnG5+DPG5Yr5SEtuivlYWvfU79veqZ6PT+EEfC4nkoiP6t6Lx/MRZumCMfeByEfInvV1CH3bHpdKQ884Tz1fHi2kJvz31HK15zcPa65ctfaJea5YTgXn3NsK+qjcCwj8M7018411v229Wpbr2/xe2NfDVq6VClf3ayrsT0acH8npD6Hf4S5qM1dT31KI/J9+WyNjXOTLqRUhGK5mJE0aNDA/a9c5MjdHG8GU5nfokmTJsYMppghlRBCCEn3CMXpRMosbmTEw1tvvdUN43zKKae4v5MBhmS4aG+wIFsGU6nj8WZHldlSCSGEEJI+pMziRmpvZBbRF198sVLXkRES5Q5Q2UdmSyWEEEJSDZ/jVPpDUtgVXEZKfPXVV8V7770nfvOb35T/XmYpLSkpEbt371Z2b0wZTGU21GgZUaUN2ecPRLXf5vhCRl1DgwzV9u7D66OtHMLKY+wYDEsfgXgeYbi/pg1Ae7ow49V1+DDODFwbNTarikPG9AACdBGaxgZw4Phcf4nx+lpbIV2DFpfH1vda2He/+X4evVJUQOeBGhpNE2QJO5+FKQfgfKxfjh80Pjh3vOMN83ZnOGDWT8G8zoG6aW2Fvg9hsg34vr5fTdXhRy0ZAjoRH+ibtPpY9U/mv+3wOdXGBucO1A85JuMnY3013Qt8X+RkmJ81z9zAumPbtefYolXTrqc9hxhzKGyuK5RxLmjPDbw3NJ1jxNw3jQN71K8Nz5XPkvqhSpHdFqnk+ST1dm4cx3EXNjInxdtvv+3mo/Ais5dmZmYqGUylq7jMfWHLYEoIIYSkMty5qaE7N9IUJT2hXn75ZTfWTZmORmplatWq5f538ODBbhZTKTKuW7euuOmmm9yFTTyeUoQQQghJH5K6uBk/frz737PPPlv5vXT3vvbaa92f//73v7sZSmXwPukJ1a1bN/Gvf/0r7nuN/e+rIi8v+kbV0FaXqPXa/LJSvqHVRUp54kevGNMdYCZsDPWNoc2vOaWHcct14oaXjSH9bZm0TWHQm2TkKeUezVV3XAfCqE/ZskDEA6YjwLb373C5Up760WylHESrE1wPw7jjCOP5mMka+xLri2NbBH8paRnmAdvcwDDyA36ruqg+vflVY3sHd7xCKU/c+FLMumCm5T8cf45SnvHZ68a6DWzbSylP+HieUq4NZq2+TX+nlCd9qT43Q9teqpSnfDLfOBZFYL49vMzMXP592DhWmA4Bd/Qx/UIIxu7mtup74t9boL4w17A/+rdU3yPj175srB/W/3pwHZ+68Y2Y7bH1ne05wHcKzgWcx/heGQZzZeJGta8QnAuTP5pvSR9h3rHQnpM26tj942O17/M8hweDEXFSc1E9MLdUzVzcSLOUjZycHDFu3Dj3QwghhNQYKhtlmGap1PeWIoQQQgipMd5ShBBCSLrBCMWJI20WN9KmXGZXttlrbYTgdLRvg5OlZovH4zV3aiijbiMTdCsh0PSglsB7P9TYfF0aNLvTgssn6hLQto1tK4xg26B2oEsIaZqX+Ij3fJsmKAhaghBoF7y2+mhbobug/Tk+9Xq56LptSWeh6asyAsa55tVxFMM8QdflEIxtECcSaMFQb4S6C3Q3Rl0Hbqmja3om9FUmvMkLQWODPYcaFn1u+IwaGdTKIdjX2B+oU7GB9cNny2aCwGfTFDEBhwLPtemPatvqCn1pmpfRsL1ncGTi1eSkDDRLJQyapQghhBBSo0ibnRtCCCEklZCbk7BBGff5JDpc3BBCCCHJgGaphJE2ixtpwy2z42aiuRc1LhgpXEvXYI4J4dc0MmC/tk1IMJDnQHySoFNq1ImgluAQf275z9+Gg0adAaYbcCCEvWZbt+iRMLRQNoY2h77I86lTslCE4+prRDvfEncGNTb1IJaKTd+EeqjDA2r7/JiSwIKmG8G5U1xywFoGjHPjFBcbv88MRIzH41iFUd1oeU4wxP7hAfNYf1OqHt8I3l6F8FwgDfxZxrg4eyJqOQ/1T1BffHZQY6P9UQ36KBwrfM5DeAW4P8417/W+C6O2yxxrqwjupemRLHFvsC6oubHF8EE9l61vUU9hO17rO9AMhQzaJ3JwkjaLG0IIISSlYBC/hMHFDSGEEJIEKpsfirmlYpOWixvNJdViWkEzEW6p4vY5utzG7aIG7tfo8oqgqaJxoLZS/ilSeMBtx8zN6JqMddfca+Hy2FfZvvjaiueji2gDv+rOvA9MEyGLuy6ambB9EWifTb+H9beF5A9ZtudtKQTweBwPr6kJzTDoqq2FKAAwTAAeb5v3NtdomzuynL0msw2aRrA+2P6IZe6iiRIzX6OrOI61zYRbqKU0iE8daupvbAu6ctvIBZMjPlfWlC9aX1meIy3kgtkMhdhN/er1iyGkQwOPNCEUX1dVDmpuEgZdwQkhhBBSo0jLnRtCCCEk6ciNl8q4c3PjJiZc3BBCCCFJgJqbxJE2i5s8f6DctVOzVYOWQHcBDRjdg5FcdIsEUKugpzwIGF10UWtwqF/V2GwL74tpH6+sHRJ1DXlQN3THxfQCNrCt2eBejJohvF8d0Apk+tAV3NwDIdA92HQiWF/UdaD2AV3X66BrPPRXfb9Z56K73Ppj6kpQR+GADgH7BnUWWDd8jrDvUa9lcxe2Ud8fgvpmGp+LbEuaEuwP7FstZITlubTKWuD8BraxFeaQFNjf3vb7hSVkgTCPDT5XthAMqF+yuc1rwPHYt3i/HHgvYN9p9cG+R/EdqXGkzeKGEEIIST1X8MoIiquyMjULLm4IIYSQZEBvqYRBbylCCCGE1CjScudGC/1dEjLGt3BCIaPWAONxoH0Z42FoYfDh/j41/IhVY/NjpMBof/bqRvDe2Ba06+PfBXi8ZtsGghDSXjN1azGEwuY4OmB718ZSlBq/x1gi1nQMjrG6Qvghrg2GdcfjoX0YFl9Augtbqg1MHYJzzdu+QugbHGvUWWh9q81rjEWinu+ESs3xmuC5CjpqfQJazJ6IURNk+0vNNld03UnYPDYwtzGujabJgfba4lchmBqlGFKLeGO94DsJ49yEoe0IxuyJYJoUW7wm6KsCeKdKDaR5LpjnPd5Pf+cJY312w4NcH56jakN2S2VuzcSZMUnLxQ0hhBCSbOgtlTi4uCGEEEKSATU3CYOaG0IIIYTUKNJm50bGuCjTP2ixVyCODX7vy8w02tIzNR0H5GOC66FOxQf5nBCbxgbvF09+IbRVo/4H9UYY7wLvrdvKzZoWBGOPoN4oB/o+EgkZv8+0xMnRNTKgDcDqYmon1Flg/iNLviAt7g7oYPIssVhEafiAj8e241hj3xVhnJsw3EvLO4bPTYZZLwTPVX3QL2F9CyAfUJ4hpo8kG8YiYIl5hBoYe33V9uGzpWlqLO8Ra5wbyAWG7fN75loJ3Bs1JZnCfO9C0PNgPCs9ZlAgrjg3tr7JizMGET53YXjusT7YH14NjzVPVVXCnZuEkTaLG0IIISSl4OImYdAsRQghhJAaRdrs3Nxw5oUiw58VdbX7VP48pTyw1cVK+daV7yjlPm0uMt8MTS+W1fWkNfOVcuNAHaXcs1VX8/3AlIHmAxH2bCGjyyO4RD6y/jX10rAd3L9tL/O9weUSt4Px+ydXvaSUe7e5JL62WdyVKwua5RAtdYZj8x0HstTt+NEfzlXKfSz9ce/SV9XjW18IFfTFnJePbnnFOK8dGKuxa9V52r/lxUbz7kMbFqrHt79MKT+8TH3uhpzSM3bdo5lv8TnDMrgfa2MR8Bvbi8dP/GiWUr76NLW/fDk56vkwdx5fDWPbQe0PUVxirN+Ta15Wyr1bQ/+bngPsC5y3lufKge99lhQzj+Wrbe2PdYWxGrlcnSt92l5sfq7ifC/cv/IVc308lEbkOEwW1QJdwRNG2ixuCCGEkFSCruCJg2YpQgghhNQouHNDCCGEJAMKihNG2ixupD3d+cUOjfZiNMU74OboRxdN24TC71EL4NXARNHYbAvvM14Pw9pjugZNO6DcG8rQ+JBjcakE12ME7+2ztD0YybJoViJx9oWqYdGw6TLixaKxwbmkaRXg/kXQ/9r1QVuAYQj0+4dj64MQvBf0bRhdybFtEQh5AK7b2Faca9pYgG7EqvuwhNDH+orSiHFuIsGIZaMb6odz03q8pX4FjmVuK2Nv0RtFzG3Hvsa+1d4xoA8y102dl+7pPstzju8VvD6OHdQX5y7iba8DaTUSiuwXfMfGez6JCs1ShBBCCKlRpM3ODSGEEJJS0CyVMLi4IYQQQpJCJRc3lqjW6UzaLG7GL31D5OXtt8IVwmS6EeJvTFyvxmgY2vZSpTxtrRpvoghs5Rg2HlMWYDqFnqeea7Rf4/0wzD2CodEjBjskpg/A+A9OUbFSnr7pFWMIey2MO9jWM6HuAztfpZQnrVFjiSDYlxgqHb/HscGQ+kWWMPJBsL+HoP6YngFTX4QxPAeGjYf79T3590p56oaXjSkS+nS5Qik/s+7FmP2N5/Y+SZ13z25R7xWEut/c+UqlPHH9LGPf9jvubKX8/Ofq9ftBnJcJH6sxj1ABg3MXQ/pjOoJCSB+BY4P1DcNcwuOHdlD7euL62ca5rY1Ve/U9Mmn1HGEC53L/lmpcnSnrXo7ZX3huAWhs8vzmdArYdsT2HA1tp47tpHVqTCNkcIfLlfKUfHPfCMt7DN8Lg9upff/Mmrkx2xMMRsTxzUT1wJ2bhEHNDSGEEEJqFGmzc0MIIYSkFK63E72lEkHaLG7kNmvZVqu2XQXb27i9jKHK0SyEx0fizOptc6PE+6GpBzPoqoYkdYsat6cxvYLmvopb9VD2gxtjscUMhFv/CG6n20xw+GJAM1k2mAb07euQcXses5qD47pmehCY7Rj6B81QaMJEMrXtf0NqjSjX85oXMi0hDbSM7ThW4I6rZc0GfNnZxrrZUmXgt4WO+hv1qZLzHt3k8bkWxiziRdBeHHusL7bf9pzi+TgX8Hht7mNmb7i/d+6GLG3B5yRkieOP7zg0Q2nvTMjybTOTYToFnIth21wFtJkF73BT32PbEoq8V2XuV511PcigWYoQQgghNYq02bkhhBBCUgoKihMGFzeEEEJIMqDmJmGkzeJG2vvLbP7ojquHwDdrDVCXgfbfhqCx0dIpIHg/sM2jVsGmdUC8tvsstL1rugIo244H0BXcr7lCm++XC/qhPZFQXPdH7YDmpg8pATTXb3Afxr4vQc2RReeBmiZ97oBmR9MEmecagv3j1UJomheLvqm2JSw86jqwLzGEv6ZBwXQMmpYN3fxRXxUw65Ew84cWNiBOqzzUF6+nzX3L+ThX9TAH5pQIOJ7eubQTQhjkQN/tg3lu6wlUdqDGRpuXlr7KijMNCo4VavusIwnX3wP9k2mT9pGDjrRZ3BBCCCEpBc1SCYOLG0IIISQZuFapyixuqrIyNQt6SxFCCCGkRpE2OzfSHl5mE2/gh2glNnuwBVscG1xB2kKba7FlwOKth1I362K88Tx0zQhWzhznxqYzwHQD+H0e6hwgTguGzMfzsWhLx4C6hGy4v6YDAVBHku0zXx91HxHL9bT4IqDvssX7wPFB3Yx37G33wtgnhaAnQt2CPq/jjLkBGhItDg9QGFH7LoyCLgDbgzGZUNOi3Q/7GtqPOhDUcfgt7bWl/tDeE/Cs4LPh1aFoeiWLRkaP3SXimufWlDBaTCFzTCW8nm2sENTuIRj3x2+K2ZNIaJZKGGmzuCGEEEJSCnfBXIlAfBYhdjpDsxQhhBCSDMp2birzqQDjxo0TxxxzjMjJyREdO3YUK1eujHlsKBQSDz74oDj++OPd41u2bCneeOMN5Zj7779f+Hw+5dOsWXVlH03znRuvKzi6F2Pob1vo7oaBOkp5h8XV2+YebAO317MsLrpBWM17t2Bxna9tfUNfOMXFcbUtAnfAvkQXTsRvcXvHzM/bI6pppT6Y6PB6uL2ur+4tIfQBm2s6msFwO19zoYX+17OuhyucEd5WV0xfUBgxpx/AkQSndg2tr7NV87AWogHI82NIhvjMB7YM9dgeLf0CpBRArO7EcD6mTbHNNV+W7f6+mCYrTBOimXsBNLHlwdjjeyOCz7UhJEG080VmhjE1Bj4nONc0MxaOJmaQh+cy6GmvFgqkhjFz5kwxYsQIMWHCBHdhM2bMGNGtWzexZcsW0bBhQ+34e+65R8yYMUNMnDjRXbAsWrRIXHrppWLp0qWidevW5cedfPLJ4q233iovZ8C/m9UNd24IIYSQNNm5GT16tBgyZIgYOHCgaNGihbvIyc3NFZMnT456/PTp08XIkSNFjx49xHHHHSeGDRvm/vzkk08qx8nFTOPGjcs/hx12mEgmXNwQQgghyUBGGK7sRwixd+9e5VMcY8e9pKRE5Ofni65du5b/zu/3u+Vly5ZFPUdeS5qjvNSqVUu8//77yu+2bt0qjjzySHcB1LdvX/H111+LZMLFDSGEEHIQc/TRR4t69eqVfx599NGox/3www8iHA6LRo0aKb+X5W3btkU9R5qs5G6PXLxEIhHx5ptvirlz54rvv/++/Bhp3po6daqrxRk/frz44osvxO9+9zsRDAZFskgbzc3w3/UUGWUu4JCP46aV7yjlgR2vUMoLV6viqZ7tfm90qdVA2yMcP2K5ev8I2I/7tL1YKTshVTPkQy1AKdjuPToUDOGODF6Vr5R3lar6ooFtLjG3rSRk1FUIqPtNyxcr5X5tLjZfH3CKipSyLztbPcDm1m8bO0tqDO172/0sx/ddqfZ/n/a91ONBT3Xv8leV8sC2vWK7D2eoSoXeH65Xyv1hbJ3iEqX8pzVvK+XB7S41tu269epfggM7XK6UxyyfqZSHdlCfO+tY2fraFuIf3gMOXN+Xo86lEUsXKeV+7S813g/n5kNrXlbKfTrA+dDfmJpkyNLl5mfFe3+cZ6Dl0voG2q71BWrxQubvH86fZxx7fE88uWaWUu7f/jLj8TiXtecS3nP3rnhFKffrqNbH+fnn8p9LI3IcnhXVgeNE3E9lzpd88803om7duuW/z8b3YCUYO3asa8aSehspFJbCYmnS8pqxunfvXv7zaaed5i52mjZtKmbNmiUGDx4skgF3bgghhJBk4FTSJPXLIlYubLyf7BiLG6mDCQQCYvv27crvZVnqZKJx+OGHi/nz54uCggLx1Vdfic2bN4s6deq45qdY1K9fX5x00kni008/FcmCixtCCCEkDcjKyhJt27YVixf/umMuTU2y3LlzZ+O5Undz1FFHidLSUjFnzhxxySWwi+9h37594rPPPhNHHHGESBZpY5YihBBCUgp356V6IxSPGDFCDBgwQLRr10506NDBdQWXuzLS1CTp37+/u4gp0+2sWLFCfPvtt6JVq1buf2VMG7kguuOOO8qv+ec//1lcdNFFrinqu+++E/fdd5+7Q9SnTx+RLNJmcfPEe6+KvDx/1O2qYa3VFejCj8wamykrZitltJhiigOMl4ExHoa0vEgp+yAGw5R184xh4TEGBca58cbfCFmehWHNLlB/Afea8omqG8DYKXjvsBbWXb3esE5XKuVJ+WrfIng/TEVRG/oCQ9zb4m1g+gi8HsbTwLg9OPYYuwXj9iD9TvrVi0Hy/CfzjPdD3cu0NfNjth9j/Fx77NnquV+o5+6BiX1L6wuV8sT1c41tu+bkX+3wkskb5qh173yVUp60cpaxL3dFVG1Z44A5VQfWB1NX4HNbAGOPMZP6g55pBuhKbOkXhoGOZMpq81zH+g06pYdSnv7xyzHbh7FatJg9lnuVWFLSYF/j3BoMz/WMVXOMfXXjGVfD8S/FFR/LBs61F1ao9Ql60r4EgxFxcnNRPcj3l68SbatAv/Tu3Vvs3LlTjBo1yhURy0WLFAKXiYyll5P0oCqjqKjIjXXz+eefu+Yo6QYu3cOl6amM//3vf+5C5scff3TNWGeccYZYvny5+3OySJvFDSGEEEKEGD58uPuJxpIlS5TyWWedJTZu3Gi83osvvihSDS5uCCGEkDQxS6ULabO4+fOZF/7qCg4s/Eh1R+556rlK+aaVb5vdGtG9GreA0U0RTClj16rb27AbLgaiyy26emNYdpN7M7i/Ivd9/B+lXOSo1x6MrsYWN3ctZD18j67M2vXxfHTnRRdR7It4XcE1F1mz67wI+Cv3MoL+e2LTPLO7MXD7sv8Y3bkVwF333k9eN84zdAV/ZJ1qrh3a1uwKPWqdev3BEGLh3g8WKOVBLS80mme1B8OSukKbK4YQCdHCJOD9x61VzXD9WsNczYL3S5EaSO2x/AXGkBOaKzjMrf/7cIF5rE1zHeed5bm0zXt0X8a+un/1ArPbOtTnzhULzfPe9l6xZHC/c9lrxvAa3vbudwWfIqoDJxIRTiXMUpVxI6/ppM3ihhBCCEkpuHOTMOgKTgghhJAaBXduCCGEkGQgZQI+7twkgrRZ3Iz2uII3ychTvuvZ8jylPH7tfKOr+KR1qhthPb9q/90TCRndKtFKeiNcH7UAU9aYXcFtbp5et010Bfe6iUuGNP+9UYfw7Cfz43KlDoGLaB7qiUB3MAVcwdGlFUFXa1v70BU8Xjd+/f7gWg7n27ZGsf/++FvVFf/fW8zuwpiyYNoaVRdiqhu6gr/w5ctmd12Yp89AiAJ0Bx54AjxXW1X33htB4/OPdercQgojqqamUSBsHEsMG4DtR3fmIgePV8s3gh5sCqRTQNd5lAjd3FrVeYxf+5Ix7ACGVbgBXOunbpwf872A884WjiLXp/ZtCLQcOfB9oWN2e0dd4lOr5xilf7dCKoopeDxcH8cOyfOp/7T1aaOG2xi/em7M90i1uoK7Y1YZV3AubmJBsxQhhBBCahQHxeJm3Lhx4phjjnHDP8uEXCtXrkx2lQghhJBK4UScSn/IQbq4mTlzphsuWoZzXrNmjWjZsqWbgn3Hjh3JrhohhBBScaT5r7IfcnBqbkaPHu2mWy/LezFhwgSxcOFCN936nXfeecDXOTqjjqibsd9u/HVp0HisNl3QeA7scuMixNYeaCH44Xs9ZoR5WOr5IZ4HEASthHJvSxh1X60c9QTQ3KDGJBPXx9BWDJuuaWgyM4x9j2HfbekXci3aApsuA1f7QcsfRvWhvTZ9FYKaIB/E77BphLD/UFfibR+Otb92LpxrTp0hstU4LoUR9ft6/jhjAEFcGtS4hBz1/AaQbgEiHOnA2AWh8xpA/TA1SCH2NsQk0nQr0FwcO/HL+yeWxiZk03vBWCN+w7n43OE7CcG2FUXUvq/vz4iZviAa2Le1cW5AX+A8z4Y4OhFN6+eY6wNzzZQWJWTpG3JwkNKLm5KSEpGfny/uuuuu8t/JnBddu3YVy5Yti3pOcXGx+ylj79691VJXQgghJB5c01IlvKUcCooPTrPUDz/8IMLhcHlCrzJkWSb8iobMZFqvXr3yz9FHH11NtSWEEELigGap9Ny5qQhyl0dqdMrYs2ePaNKkidi779dJECxVJ8T+cNuqK2A839sy5OL3uF2N1/eBqQXvh6YMBF1I48nui3VxwMSFdcEs2Ygta3ZppNh4fcRmlgpZzFI4Nng93N7eZ/nDKOA31ydes1SpY55reD1b/3nbhxnSbffCtuPc2IdzAf5Usl3fdj3NrT8Q34scx9rzCvjleuaxx5ALtvcAYnvO8Xw0SyG2872mp1CcZqkwHF+IJkqomt+PcyW+d2YE54rl+BKor80shc+9te+9ruC/TJTq2BUplcZVp5Lnk6j4nBTe15JmqdzcXDF79mzRq9evMSYGDBggdu/eLV5+WY0zEQ2Zip27N4QQQuLhm2++Eb/5zW8Scu2ioiJx7LHHxrRAxEPjxo3FF1984XoTk4Nk5yYrK0u0bdtWLF68uHxxE4lE3HKsdO3IkUce6U5SuYaTOzjy57p16ya45jULqVuSC0T2XcVg/1Uc9l3FYd9VDPlvRTAYdP/tSBRyISIXJPIP+Kr4d5ILm4NscSORJia5U9OuXTvRoUMHMWbMGFFQUFDuPWVDCpDl6rtMWCwfcj7oFYN9VznYfxWHfVdx2HfxI/WaiUYuSLgoSePFTe/evcXOnTvFqFGj3C28Vq1aiTfeeEMTGRNCCCGEHBSLG4k0QR2oGYoQQggh6U1Ku4JXJdnZ2W6UY/lfEh/su8rB/qs47LuKw74j6UxKe0sRQgghhMRL2uzcEEIIISQ94OKGEEIIITUKLm4IIYQQUqPg4oYQQgghNYq0WdyMGzdOHHPMMW7QpI4dO4qVK1cmu0oph0w62r59e5GXlycaNmzoRoXesmWLFjb8xhtvFIceeqioU6eOuPzyy8X27duTVudU5bHHHhM+n0/ceuut5b9j38Xm22+/Ff369XP7platWuLUU08Vq1evLv9e+j3IWFdHHHGE+33Xrl3F1q1bk1rnVEEmF7733nvdcP6yb44//njx0EMPKbmR2H8k7XDSgBdffNHJyspyJk+e7Hz88cfOkCFDnPr16zvbt29PdtVSim7dujlTpkxxNmzY4Kxbt87p0aOH06RJE2ffvn3lx1x//fXO0Ucf7SxevNhZvXq106lTJ6dLly5JrXeqsXLlSueYY45xTjvtNOeWW24p/z37Ljq7du1ymjZt6lx77bXOihUrnM8//9xZtGiR8+mnn5Yf89hjjzn16tVz5s+f76xfv965+OKLnWOPPdb5+eefnXTn4Ycfdg499FDn1Vdfdb744gvnpZdecurUqeOMHTu2/Bj2H0k30mJx06FDB+fGG28sL4fDYefII490Hn300aTWK9XZsWOH/NPPeffdd93y7t27nczMTPflWcamTZvcY5YtW5bEmqYOwWDQOfHEE50333zTOeuss8oXN+y72PzlL39xzjjjjJjfRyIRp3Hjxs7//d//lf9O9md2drbzwgsvOOlOz549nUGDBim/u+yyy5y+ffu6P7P/SDpS481SMjFZfn6+uw3rzTcly8uWLUtq3VKdPXv2uP9t0KCB+1/Zj6FQSOnLZs2auQlJ2Zf7kWannj17Kn0kYd/FZsGCBW7uuCuvvNI1h7Zu3VpMnDix/HuZYFCmXvH2ncz9I83L6d53ki5durjJhD/55BO3vH79evH++++L7t27u2X2H0lHDor0C5Xhhx9+cG3SmItKljdv3py0eqU6Mvu61Iucfvrp4pRTTnF/J1+QMgNt/fr1tb6U36U7L774olizZo1YtWqV9h37Ljaff/65GD9+vJskd+TIkW7/3XzzzW5/yaS5Zf0T7RlO976T3HnnnW5iYLlYDgQC7vvu4YcfFn379nW/Z/+RdKTGL25IxXcgNmzY4P4FSOx888034pZbbhFvvvkmM/1WYCEtd24eeeQRtyx3buTcmzBhgru4IWZmzZolnnvuOfH888+Lk08+Waxbt879w+TII49k/5G0pcabpQ477DD3rxn0SpHlxo0bJ61eqYxMUvrqq6+Kd955R/zmN78p/73sL2nm2717t3I8+3K/2WnHjh2iTZs2IiMjw/28++674qmnnnJ/ln8ls++iIz14WrRoofyuefPm4uuvv3Z/LusfPsPRuf32293dm6uvvtr1MrvmmmvEbbfd5no/Sth/JB2p8YsbubXdtm1b1ybt/UtRljt37pzUuqUaUmAuFzbz5s0Tb7/9tuta6kX2Y2ZmptKX0lVc/iOU7n153nnniY8++sj9q7nsI3cjpGmg7Gf2XXSk6RNDDkj9SNOmTd2f5TyU/wh7+06aYVasWJH2fScpLCx0dYRe5B908j0nYf+RtMRJE1dw6RkwdepUZ+PGjc7QoUNdV/Bt27Ylu2opxbBhw1x30SVLljjff/99+aewsFBxZ5bu4W+//bbrzty5c2f3Q3S83lIS9l1s1/mMjAzXpXnr1q3Oc8895+Tm5jozZsxQXJnlM/vyyy87H374oXPJJZfQlfkXBgwY4Bx11FHlruBz5851DjvsMOeOO+4oP4b9R9KNtFjcSP7xj3+4/7DIeDfSNXz58uXJrlLKIde60T4y9k0Z8mV4ww03OIcccoj7D9Cll17qLoCIfXHDvovNK6+84pxyyinuHyHNmjVznnnmGeV76c587733Oo0aNXKPOe+885wtW7Ykrb6pxN69e915Jt9vOTk5znHHHefcfffdTnFxcfkx7D+Sbvjk/yV794gQQgghpKqo8ZobQgghhKQXXNwQQgghpEbBxQ0hhBBCahRc3BBCCCGkRsHFDSGEEEJqFFzcEEIIIaRGwcUNIYQQQmoUXNwQQgghpEbBxQ0hJCrXXnut6NWrV5Vc68svvxQ+n8/Ns0UIIYkmI+F3IISkPUcffbT4/vvvxWGHHZbsqhBC0gAubgghCUdmqZaZqQkhpDqgWYqQFGD27Nni1FNPFbVq1RKHHnqo6Nq1qygoKBCrVq0S559/vrvjUa9ePXHWWWeJNWvWKOdKc8/TTz8tLrzwQpGbmyuaN28uli1bJj799FNx9tlni9q1a4suXbqIzz77rPyc+++/X7Rq1co9T+6qyPOuuuoqsWfPnph1jEQi4tFHHxXHHnusW8+WLVu69T4QaJYihFQnXNwQkmSkuaZPnz5i0KBBYtOmTWLJkiXisssuEzKnbTAYFAMGDBDvv/++WL58uTjxxBNFjx493N97eeihh0T//v3dxUOzZs3EH/7wB3HdddeJu+66S6xevdq91vDhw5Vz5OJn1qxZ4pVXXhFvvPGGWLt2rbjhhhti1lMubKZNmyYmTJggPv74Y3HbbbeJfv36iXfffTdhfUMIIRUi2WnJCUl38vPzHfkofvnll9Zjw+Gwk5eX57zyyivlv5Pn3nPPPeXlZcuWub+bNGlS+e9eeOEFJycnp7x83333OYFAwPnf//5X/rvXX3/d8fv9zvfff++WBwwY4FxyySXuz0VFRU5ubq6zdOlSpT6DBw92+vTpY633F1984dZp7dq11mMJIaSycOeGkCQjzTvnnXeea5a68sorxcSJE8VPP/3kfrd9+3YxZMgQd8dGmqXq1q0r9u3bJ77++mvlGqeddlr5z40aNXL/K6/n/V1RUZHYu3dv+e+aNGkijjrqqPJy586dXdPTli1btDrKXZ7CwkLXRFanTp3yj9zJ8Zq7CCEkFaCgmJAUENu++eabYunSpeI///mP+Mc//iHuvvtusWLFCjFs2DDx448/irFjx4qmTZuK7OxsdxFSUlKiXCMzM7P8Z6ltifU7uXipCHJBJVm4cKGyIJLIOhFCSCrBxQ0hKYBcfJx++unuZ9SoUe5CZt68eeKDDz4Q//rXv1ydjeSbb74RP/zwQ5XcU+7+fPfdd+LII490y1LT4/f7xW9/+1vt2BYtWriLGHmOFDUTQkgqw8UNIUlG7tAsXrxYXHDBBaJhw4ZueefOna7XkzRHTZ8+XbRr1841Kd1+++2up1JVkJOT44qVn3jiCffaN998s+sxFc1lOy8vT/z5z392RcRy9+eMM85wPavk4kuayuR1CCEkVeDihpAkIxcH7733nhgzZoy7yJC7Nk8++aTo3r27u9AYOnSoaNOmjeuy/cgjj7iLjKrghBNOcL2y5K7Qrl27XFdyuUsUC+mRdfjhh7teU59//rmoX7++W6+RI0dWSX0IIaSq8ElVcZVdjRByUCDj3MyfP7/a4s5IkbJ0Ud+6dau7qCKEkERCbylCSEKRu0Iy2J/coZK7T4QQkmholiKEVJrrr79ezJgxI+p37du3d93Fx48fT88qQki1QLMUIaTS7NixQ4mh40Xu2EihNCGEVBdc3BBCCCGkRkHNDSGEEEJqFFzcEEIIIaRGwcUNIYQQQmoUXNwQQgghpEbBxQ0hhBBCahRc3BBCCCGkRsHFDSGEEEJETeL/Acy72/1h1g8xAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ds_result.similarity.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Each pixel indexed by (i,j) in this image corresponds to the similarity between measurement i and j. The bright pixels indicate high similarity and the darker pixels reduced similarity. A check on this calculation is that the diagonal should have a perfect similarity = 1.0 because each data is perfectly self similar to itself, i.e. `S(i,i) = S(j,j) = 1.0`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 3: Cluster Measurement Data based on Similarity" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we can use the similarity matrix to cluster the data into groups. " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "2 ) measurement ---> derivative\n", "3 ) derivative ---> similarity\n", "4 ) similarity ---> labels\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "2) measurement\n", "\n", "Output Variables\n", "----------------\n", "0) normalized_composition\n", "1) normalized_composition_grid\n", "2) labels\n" ] } ], "source": [ "with my_first_pipeline:\n", " SpectralClustering(\n", " input_variable='similarity',\n", " output_variable='labels',\n", " dim='sample',\n", " params={'n_phases': 2}\n", " )\n", "\n", "\n", "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "The SpectralClustering pipeline operation takes:\n", "\n", " - `input_variable`: The similarity matrix to use for clustering ('similarity')\n", " - `output_variable`: The variable to store the cluster labels ('labels') \n", " - `dim`: The dimension containing different samples ('sample')\n", " - `params`: Dictionary of parameters for clustering\n", " - `n_phases`: The number of clusters/phases to find (2)\n", "\n", "Let's run the pipeline with this new operation" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "367c56818d734cee84398ef695190ab9", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/5 [00:00\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 488kB\n",
       "Dimensions:                      (sample: 100, component: 2, x: 150,\n",
       "                                  grid: 2500, log_x: 250, sample_i: 100,\n",
       "                                  sample_j: 100)\n",
       "Coordinates:\n",
       "  * component                    (component) <U1 8B 'A' 'B'\n",
       "  * x                            (x) float64 1kB 0.001 0.001047 ... 0.9547 1.0\n",
       "  * log_x                        (log_x) float64 2kB -3.0 -2.988 ... 0.0\n",
       "Dimensions without coordinates: sample, grid, sample_i, sample_j\n",
       "Data variables:\n",
       "    composition                  (sample, component) float64 2kB 5.7 ... 5.104\n",
       "    ground_truth_labels          (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    measurement                  (sample, x) float64 120kB 1.915e+06 ... 1.885\n",
       "    composition_grid             (grid, component) float64 40kB 0.0 0.0 ... 25.0\n",
       "    normalized_composition       (sample, component) float64 2kB 0.57 ... 0.2042\n",
       "    normalized_composition_grid  (grid, component) float64 40kB 0.0 0.0 ... 1.0\n",
       "    derivative                   (sample, log_x) float64 200kB -3.82 ... -0.4063\n",
       "    similarity                   (sample_i, sample_j) float64 80kB 1.0 ... 1.0\n",
       "    labels                       (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1
" ], "text/plain": [ " Size: 488kB\n", "Dimensions: (sample: 100, component: 2, x: 150,\n", " grid: 2500, log_x: 250, sample_i: 100,\n", " sample_j: 100)\n", "Coordinates:\n", " * component (component) " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "fig,axes = plt.subplots(1,2,figsize=(8,3.25))\n", "\n", "plot_scatter_mpl(ds_result,'composition',component_dim='component',labels='ground_truth_labels',ax=axes[0])\n", "plot_scatter_mpl(ds_result,'composition',component_dim='component',labels='labels',ax=axes[1])\n", "\n", "axes[0].set(title=\"Ground Truth Labels\")\n", "axes[1].set(title=\"Spectral Clustering Labels\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 4: Extrapolate Cluster Labels" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can extrapolate the labels from the `SpectralClustering` over the `composition_grid` that we supplied in the input dataset." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "2 ) measurement ---> derivative\n", "3 ) derivative ---> similarity\n", "4 ) similarity ---> labels\n", "5 ) ['normalized_composition', 'labels', 'normalized_composition_grid'] ---> ['extrap_mean', 'extrap_entropy']\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "2) measurement\n", "\n", "Output Variables\n", "----------------\n", "0) extrap_mean\n", "1) extrap_entropy\n" ] } ], "source": [ "with my_first_pipeline:\n", " GaussianProcessClassifier(\n", " feature_input_variable='normalized_composition',\n", " predictor_input_variable='labels',\n", " output_prefix='extrap',\n", " sample_dim='sample',\n", " grid_variable='normalized_composition_grid',\n", " grid_dim='grid',\n", " )\n", "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The GaussianProcessClassifier pipeline operation takes:\n", "\n", "- `feature_input_variable`: The composition data to use for training ('compositions')\n", "- `predictor_input_variable`: The labels to predict ('labels')\n", "- `output_prefix`: Prefix for output variables ('extrap')\n", "- `sample_dim`: The dimension containing different samples ('sample')\n", "- `grid_variable`: The grid points to extrapolate to ('composition_grid')\n", "- `grid_dim`: The dimension containing grid points ('grid')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1ef66176cd6e4558b64fb54bc8317da1", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/6 [00:00\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 548kB\n",
       "Dimensions:                      (sample: 100, component: 2, x: 150,\n",
       "                                  grid: 2500, log_x: 250, sample_i: 100,\n",
       "                                  sample_j: 100)\n",
       "Coordinates:\n",
       "  * component                    (component) <U1 8B 'A' 'B'\n",
       "  * x                            (x) float64 1kB 0.001 0.001047 ... 0.9547 1.0\n",
       "  * log_x                        (log_x) float64 2kB -3.0 -2.988 ... 0.0\n",
       "Dimensions without coordinates: sample, grid, sample_i, sample_j\n",
       "Data variables:\n",
       "    composition                  (sample, component) float64 2kB 5.7 ... 5.104\n",
       "    ground_truth_labels          (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    measurement                  (sample, x) float64 120kB 1.915e+06 ... 1.885\n",
       "    composition_grid             (grid, component) float64 40kB 0.0 0.0 ... 25.0\n",
       "    normalized_composition       (sample, component) float64 2kB 0.57 ... 0.2042\n",
       "    normalized_composition_grid  (grid, component) float64 40kB 0.0 0.0 ... 1.0\n",
       "    derivative                   (sample, log_x) float64 200kB -3.82 ... -0.4063\n",
       "    similarity                   (sample_i, sample_j) float64 80kB 1.0 ... 1.0\n",
       "    labels                       (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    extrap_mean                  (grid) int64 20kB 1 1 1 1 1 1 1 ... 1 1 1 1 1 1\n",
       "    extrap_entropy               (grid) float64 20kB 0.5813 0.5687 ... 0.4603\n",
       "    extrap_y_prob                (grid) float64 20kB 0.5813 0.5687 ... 0.4603
" ], "text/plain": [ " Size: 548kB\n", "Dimensions: (sample: 100, component: 2, x: 150,\n", " grid: 2500, log_x: 250, sample_i: 100,\n", " sample_j: 100)\n", "Coordinates:\n", " * component (component) " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig,axes = plt.subplots(1,2,figsize=(8,3.25))\n", "\n", "plot_surface_mpl(ds_result,'composition_grid',component_dim='component',labels='extrap_mean',ax=axes[0])\n", "plot_surface_mpl(ds_result,'composition_grid',component_dim='component',labels='extrap_entropy',ax=axes[1])\n", "\n", "axes[0].set(title=\"Most Likely Phase Label\")\n", "axes[1].set(title=\"Entropy of Phase Label\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The right subplot is related to our confidence in the label prediction and is a powerful tool for finding label boundaries because, by construction, it is maximized at label boundaries. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Step 5: Calculate Next Sample" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have a model that can predict phase labels and their uncertainty, we can use this information to select the next sample point. The `MaxValueAF` pipeline operation will select the composition with maximum entropy as the next point to measure, since high entropy indicates regions where the model is most uncertain about the phase label.\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "2 ) measurement ---> derivative\n", "3 ) derivative ---> similarity\n", "4 ) similarity ---> labels\n", "5 ) ['normalized_composition', 'labels', 'normalized_composition_grid'] ---> ['extrap_mean', 'extrap_entropy']\n", "6 ) ['extrap_entropy', 'composition_grid'] ---> next_sample\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "2) measurement\n", "\n", "Output Variables\n", "----------------\n", "0) extrap_mean\n", "1) next_sample\n" ] } ], "source": [ "with my_first_pipeline:\n", " MaxValueAF(\n", " input_variables=['extrap_entropy'],\n", " output_variable='next_sample',\n", " grid_variable='composition_grid',\n", " )\n", "\n", "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's run the pipeline" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "085eea8cbbbb4104a87fe6de9926459e", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/7 [00:00\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 568kB\n",
       "Dimensions:                      (sample: 100, component: 2, x: 150,\n",
       "                                  grid: 2500, log_x: 250, sample_i: 100,\n",
       "                                  sample_j: 100, AF_sample: 1)\n",
       "Coordinates:\n",
       "  * component                    (component) <U1 8B 'A' 'B'\n",
       "  * x                            (x) float64 1kB 0.001 0.001047 ... 0.9547 1.0\n",
       "  * log_x                        (log_x) float64 2kB -3.0 -2.988 ... 0.0\n",
       "Dimensions without coordinates: sample, grid, sample_i, sample_j, AF_sample\n",
       "Data variables: (12/14)\n",
       "    composition                  (sample, component) float64 2kB 5.7 ... 5.104\n",
       "    ground_truth_labels          (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    measurement                  (sample, x) float64 120kB 1.915e+06 ... 1.885\n",
       "    composition_grid             (grid, component) float64 40kB 0.0 0.0 ... 25.0\n",
       "    normalized_composition       (sample, component) float64 2kB 0.57 ... 0.2042\n",
       "    normalized_composition_grid  (grid, component) float64 40kB 0.0 0.0 ... 1.0\n",
       "    ...                           ...\n",
       "    labels                       (sample) int64 800B 1 1 0 1 0 1 ... 1 1 1 0 1 1\n",
       "    extrap_mean                  (grid) int64 20kB 1 1 1 1 1 1 1 ... 1 1 1 1 1 1\n",
       "    extrap_entropy               (grid) float64 20kB 0.5813 0.5687 ... 0.4603\n",
       "    extrap_y_prob                (grid) float64 20kB 0.5813 0.5687 ... 0.4603\n",
       "    decision_surface             (grid) float64 20kB 0.7655 0.7391 ... 0.512\n",
       "    next_sample                  (AF_sample, component) float64 16B 4.082 24.49
" ], "text/plain": [ " Size: 568kB\n", "Dimensions: (sample: 100, component: 2, x: 150,\n", " grid: 2500, log_x: 250, sample_i: 100,\n", " sample_j: 100, AF_sample: 1)\n", "Coordinates:\n", " * component (component) " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig,axes = plt.subplots(1,2,figsize=(8,3.25))\n", "\n", "plot_surface_mpl(ds_result,'composition_grid',component_dim='component',labels='extrap_mean',ax=axes[0])\n", "plot_surface_mpl(ds_result,'composition_grid',component_dim='component',labels='extrap_entropy',ax=axes[1])\n", "\n", "plot_scatter_mpl(ds_result,'next_sample',component_dim='component',labels=[-1],marker='x',color='red',s=100,ax=axes[0])\n", "plot_scatter_mpl(ds_result,'next_sample',component_dim='component',labels=[-1],marker='x',color='red',s=100,ax=axes[1])\n", "\n", "axes[0].set(title=\"Most Likely Phase Label\")\n", "axes[1].set(title=\"Entropy of Phase Label\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See that the red X is placed near the boundary of the two phases. Running the pipeline several times, you should see the X move about the bright region of entropy. This is because the `MaxValueAF` acquisition function doesn't choose the absolute maximum, but rather randomly chooses from the top `acquisition_rtol` percent of the entropy." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Full Pipeline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With that, we have a full `Pipeline` which defines the behavior of a decision agent! Let's view the whole pipeline defined in a single context:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PipelineOp input_variable ---> output_variable\n", "---------- -----------------------------------\n", "0 ) composition ---> normalized_composition\n", "1 ) composition_grid ---> normalized_composition_grid\n", "2 ) measurement ---> derivative\n", "3 ) derivative ---> similarity\n", "4 ) similarity ---> labels\n", "5 ) ['normalized_composition', 'labels', 'normalized_composition_grid'] ---> ['extrap_mean', 'extrap_entropy']\n", "6 ) ['extrap_entropy', 'composition_grid'] ---> next_sample\n", "\n", "Input Variables\n", "---------------\n", "0) composition\n", "1) composition_grid\n", "2) measurement\n", "\n", "Output Variables\n", "----------------\n", "0) extrap_mean\n", "1) next_sample\n" ] } ], "source": [ "with Pipeline() as my_first_pipeline:\n", "\n", " Standardize(\n", " input_variable='composition',\n", " output_variable='normalized_composition',\n", " dim='sample',\n", " component_dim='component',\n", " min_val={'A':0.0,'B':0.0},\n", " max_val={'A':10.0,'B':25.0},\n", " )\n", "\n", " Standardize(\n", " input_variable='composition_grid',\n", " output_variable='normalized_composition_grid',\n", " dim='grid',\n", " component_dim='component',\n", " min_val={'A':0.0,'B':0.0},\n", " max_val={'A':10.0,'B':25.0},\n", " )\n", "\n", " SavgolFilter(\n", " input_variable='measurement', \n", " output_variable='derivative', \n", " dim='x', \n", " derivative=1\n", " )\n", "\n", " Similarity(\n", " input_variable='derivative', \n", " output_variable='similarity', \n", " sample_dim='sample',\n", " params={'metric': 'laplacian','gamma':1e-4}\n", " )\n", "\n", " SpectralClustering(\n", " input_variable='similarity',\n", " output_variable='labels',\n", " dim='sample',\n", " params={'n_phases': 2}\n", " )\n", "\n", " \n", " GaussianProcessClassifier(\n", " feature_input_variable='normalized_composition',\n", " predictor_input_variable='labels',\n", " output_prefix='extrap',\n", " sample_dim='sample',\n", " grid_variable='normalized_composition_grid',\n", " grid_dim='grid',\n", " )\n", "\n", " MaxValueAF(\n", " input_variables=['extrap_entropy'],\n", " output_variable='next_sample',\n", " grid_variable='composition_grid',\n", " )\n", "\n", "my_first_pipeline.print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also visualize the full pipeline using the `.draw` and `.draw_plotly` methods" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "my_first_pipeline.draw();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While this doesn't always produce the more visually appealling graphs, it is a powerful way to check the consistency and flow of complex pipelines. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this tutorial, we learned how to build pipelines in using `AFL.double_agent` by:\n", "\n", "- Creating a new pipeline using `Pipeline()`\n", "- Adding data processing steps like normalization and derivative calculation\n", "- Implementing spectral clustering for phase identification\n", "- Using Gaussian Process classification to extrapolate phase boundaries\n", "- Adding active learning with acquisition functions to guide further sampling\n", "- Visualizing the pipeline structure and results at each step\n", "\n", "The pipeline we built demonstrates a complete workflow - from raw data processing through machine learning and active learning. This modular approach allows us to easily modify individual components while maintaining a clear data flow between steps.\n", "\n", "For more examples of AFL pipelines and components, check out the other tutorials and examples in the documentation.\n", "\n" ] } ], "metadata": { "kernelspec": { "display_name": "venv", "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.11.10" } }, "nbformat": 4, "nbformat_minor": 4 }