MixedKernelTest.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ruhanaazam/gp_transfer/blob/main/MixedKernelTest.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VP0bM4HbO1f8",
        "outputId": "c2cd0041-72dd-47de-b4e2-1181241b32b6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "k_eXSNtIO_Zt"
      },
      "outputs": [],
      "source": [
        "!cd drive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "egHIkDIoPldz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bc03f50e-75df-495e-ad6b-b5096d42fe87"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: gpytorch in /usr/local/lib/python3.10/dist-packages (1.11)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from gpytorch) (1.2.2)\n",
            "Requirement already satisfied: linear-operator>=0.5.0 in /usr/local/lib/python3.10/dist-packages (from gpytorch) (0.5.1)\n",
            "Requirement already satisfied: torch>=1.11 in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (2.1.0+cu121)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (1.11.4)\n",
            "Requirement already satisfied: jaxtyping>=0.2.9 in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (0.2.25)\n",
            "Requirement already satisfied: typeguard~=2.13.3 in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (2.13.3)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch) (1.25.2)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch) (3.3.0)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.1 in /usr/local/lib/python3.10/dist-packages (from jaxtyping>=0.2.9->linear-operator>=0.5.0->gpytorch) (4.9.0)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (3.13.1)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (3.2.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (3.1.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (2023.6.0)\n",
            "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (2.1.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.11->linear-operator>=0.5.0->gpytorch) (2.1.5)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.11->linear-operator>=0.5.0->gpytorch) (1.3.0)\n",
            "Requirement already satisfied: botorch in /usr/local/lib/python3.10/dist-packages (0.9.5)\n",
            "Requirement already satisfied: multipledispatch in /usr/local/lib/python3.10/dist-packages (from botorch) (1.0.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from botorch) (1.11.4)\n",
            "Requirement already satisfied: torch>=1.13.1 in /usr/local/lib/python3.10/dist-packages (from botorch) (2.1.0+cu121)\n",
            "Requirement already satisfied: pyro-ppl>=1.8.4 in /usr/local/lib/python3.10/dist-packages (from botorch) (1.9.0)\n",
            "Requirement already satisfied: gpytorch==1.11 in /usr/local/lib/python3.10/dist-packages (from botorch) (1.11)\n",
            "Requirement already satisfied: linear-operator==0.5.1 in /usr/local/lib/python3.10/dist-packages (from botorch) (0.5.1)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from gpytorch==1.11->botorch) (1.2.2)\n",
            "Requirement already satisfied: jaxtyping>=0.2.9 in /usr/local/lib/python3.10/dist-packages (from linear-operator==0.5.1->botorch) (0.2.25)\n",
            "Requirement already satisfied: typeguard~=2.13.3 in /usr/local/lib/python3.10/dist-packages (from linear-operator==0.5.1->botorch) (2.13.3)\n",
            "Requirement already satisfied: numpy>=1.7 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (1.25.2)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (3.3.0)\n",
            "Requirement already satisfied: pyro-api>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (0.1.2)\n",
            "Requirement already satisfied: tqdm>=4.36 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (4.66.2)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (3.13.1)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (4.9.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (3.2.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (3.1.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (2023.6.0)\n",
            "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (2.1.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.13.1->botorch) (2.1.5)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch==1.11->botorch) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch==1.11->botorch) (3.3.0)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.13.1->botorch) (1.3.0)\n"
          ]
        }
      ],
      "source": [
        "!pip install gpytorch\n",
        "!pip install botorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "ra70LWXBPFRL"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "import numpy as np\n",
        "import gpytorch\n",
        "from botorch.utils.transforms import normalize, standardize\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from botorch import fit_gpytorch_model\n",
        "from botorch.models import SingleTaskGP, MixedSingleTaskGP\n",
        "from gpytorch.mlls import ExactMarginalLogLikelihood\n",
        "from botorch.models.transforms import Standardize, Normalize\n",
        "from botorch.utils.transforms import normalize, standardize\n",
        "from botorch.fit import fit_gpytorch_mll\n",
        "from tqdm import tqdm\n",
        "\n",
        "# Check if GPU is available\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "O9hWtnSKM5Ux"
      },
      "outputs": [],
      "source": [
        "base_path = \"/content/drive/My Drive/Colab Notebooks/Transfer_Coh2\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "PXDaiVe5PHr5"
      },
      "outputs": [],
      "source": [
        "def surfacePlot(model, title = \"Your Function\" ,n=900):\n",
        "    '''\n",
        "    Plots your (true or estimated) coheritability function.\n",
        "    model: function that takes in two wavelength and outputs coh2 (estimate)\n",
        "    n: n**2 is the number of points to plot the surface\n",
        "    '''\n",
        "    # Generate data for the plot\n",
        "    x1 = torch.linspace(0, 1, n)\n",
        "    x2 = torch.linspace(0, 1, n)\n",
        "    X1, X2 = torch.meshgrid(x1, x2)\n",
        "    X = torch.stack([X1.reshape((-1)),X2.reshape((-1))]).T\n",
        "\n",
        "    Z = model(X.to(device)).cpu().detach().numpy()\n",
        "\n",
        "    # Create a contour plot\n",
        "    plt.contourf(X1, X2, Z.reshape(n, n), cmap='viridis')\n",
        "    plt.colorbar(label='Function Value')\n",
        "\n",
        "    #plot top 1%\n",
        "    #threshold = np.percentile(Z, 99)\n",
        "    #threshold = torch.kthvalue(Z.flatten(), int(0.99 * n * n)).values\n",
        "    #plt.contour(X1, X2, Z.reshape(n, n), levels=[threshold], colors='red', linewidths=2)\n",
        "\n",
        "    # Add labels and title\n",
        "    plt.xlabel('Wavelength 1')\n",
        "    plt.ylabel('Wavelength 2')\n",
        "    plt.title(title)\n",
        "\n",
        "    # Show the plot\n",
        "    plt.show()\n",
        "    return"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "fXXuL2OGPLZS"
      },
      "outputs": [],
      "source": [
        "def getTaskID(trait, crop=\"Sorghum\"):\n",
        "    assert crop == \"Sorghum\", \"Does not handles ids for from that are not Sorghum yet.\"\n",
        "    ids = {\"narea\": 1, \"sla\": 2, \"pn\": 3, \"ps\": 4}\n",
        "    return ids[trait]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "PQ6jsov2PQsD"
      },
      "outputs": [],
      "source": [
        "def loadTasks(tasks):\n",
        "    taskData = []\n",
        "    for trait in tasks:\n",
        "        #read raw task file\n",
        "        data = pd.read_csv(f\"{base_path}/data/{trait}_coh2.csv\")\n",
        "        data = torch.tensor(data.values)\n",
        "\n",
        "        #format data for supervised training, each row : (taskid, wave1, wave2, coh2)\n",
        "        n = torch.ones(data.shape[0], dtype=torch.float32)\n",
        "        col_index =  torch.arange(data.shape[0], dtype=torch.float32)\n",
        "        col_index = torch.outer(n, col_index)\n",
        "        row_index = col_index.T\n",
        "\n",
        "        #stack wave1, wave2 and coh2 tensors together\n",
        "        task_ids = torch.ones(data.shape) * getTaskID(trait)\n",
        "        flat_data = torch.stack([task_ids.flatten(), col_index.flatten(), row_index.flatten(), data.flatten()])\n",
        "        flat_data = flat_data.T\n",
        "\n",
        "        #remove all rows with nans\n",
        "        nan_mask = torch.isnan(flat_data)\n",
        "        nan_in_rows = torch.any(nan_mask, dim=1)\n",
        "        clean = flat_data[~nan_in_rows]\n",
        "\n",
        "        taskData.append(clean)\n",
        "\n",
        "    #combine all tasks data into a tensor\n",
        "    all_tasks = torch.cat(taskData)\n",
        "    return all_tasks[:, :3], all_tasks[:, -1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "cbJXXCW0DJIP"
      },
      "outputs": [],
      "source": [
        "def normalize_standarize_data(x, y):\n",
        "  '''\n",
        "  x: unnormalized input to GP, inputs are normalized to be between 0, 2150\n",
        "  y: not standardized outputs\n",
        "  '''\n",
        "  d_xtrain = x[:,0].reshape(-1,1) #discrete part\n",
        "  c_xtrain = normalize(x[:, 1:], torch.tensor([[0,0],[2150,2150]])) #continous part\n",
        "  x_train_normalized = torch.cat([c_xtrain, d_xtrain], dim=1)\n",
        "  y_train_standardized = standardize(y).reshape(-1,1)\n",
        "  return x_train_normalized, y_train_standardized"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def shuffle_data(x, y):\n",
        "  indices = np.arange(x.shape[0])\n",
        "  np.random.seed(0)\n",
        "  np.random.shuffle(indices)\n",
        "\n",
        "  # Shuffle both X and Y using the same indices\n",
        "  x_shuffled = x[indices]\n",
        "  y_shuffled = y[indices]\n",
        "  return x_shuffled, y_shuffled\n"
      ],
      "metadata": {
        "id": "LpiqA_ETXwhp"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "fPpyyNciGv8F"
      },
      "outputs": [],
      "source": [
        "def mergeData(data_list, N):\n",
        "  '''\n",
        "  Merge a list of data (from different tasks).\n",
        "  Data_list = contains a list of x and y points\n",
        "\n",
        "  '''\n",
        "  X,Y = [],[]\n",
        "  for data in data_list:\n",
        "    task_X, task_Y = data\n",
        "    X.append(task_X[:N])\n",
        "    Y.append(task_Y[:N])\n",
        "  X = torch.cat(X)\n",
        "  Y = torch.cat(Y)\n",
        "  X, Y = shuffle_data(X, Y)\n",
        "\n",
        "  #alternatively you can interleave the data (i think random is expensive)\n",
        "  #stacked_X, stacked_Y = torch.stack(X, dim=0), torch.stack(Y, dim=0)\n",
        "  #interleaved_X = torch.flatten(stacked_X, start_dim=1, end_dim=-1) #stacked.view(-1)\n",
        "  #interleaved_Y = torch.flatten(stacked_Y, start_dim=1, end_dim=-1)\n",
        "\n",
        "  #return interleaved_X, interleaved_Y\n",
        "  return X, Y"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tasks = [\"narea\", \"sla\", \"pn\", \"ps\"]\n",
        "seed = 1234\n",
        "split = 0.85\n",
        "option_n = [100, 200, 500, 800]\n",
        "M = 1000"
      ],
      "metadata": {
        "id": "Sg1VbLOBWAvt"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "7sstobwJAyyX"
      },
      "outputs": [],
      "source": [
        "# #combined training set, seperated validation sets\n",
        "val_data = {}\n",
        "train_data = {}\n",
        "for task in tasks:\n",
        "  #load task data and split\n",
        "  X, Y = loadTasks([task])\n",
        "\n",
        "  #split into training and test sets\n",
        "  x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=split, random_state=seed+getTaskID(task))\n",
        "  x_train, y_train = x_train[:option_n[-1]], y_train[:option_n[-1]]\n",
        "  x_test, y_test = x_test[:M], y_test[:M]\n",
        "\n",
        "  #store saved data\n",
        "    #don't normalize it here maybe? ****\n",
        "  train_data[task] = x_train, y_train#normalize_standarize_data(x_train, y_train)\n",
        "  val_data[task] = x_test, y_test#normalize_standarize_data(x_test, y_test)\n",
        "\n",
        "  #remove excess to free up space\n",
        "  del X, Y, x_train, x_test, y_train, y_test"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# #If you want to load kernel\n",
        "# load_kernel = 1\n",
        "# if load_kernel:\n",
        "#   covar_module = torch.load('/content/drive/My Drive/Colab Notebooks/Transfer_Coh2/kernel/mixedKernel.csv')\n",
        "\n",
        "#   #remove gradients from kernel (this will fix the kernel hyperparameters)\n",
        "#   for param in covar_module.parameters():\n",
        "#     param.requires_grad = False"
      ],
      "metadata": {
        "id": "jt3v8lZ5raXR"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "qTLG2_TYaH7k"
      },
      "outputs": [],
      "source": [
        "# #train MultiTaskGP\n",
        "# results = {\"val_loss\":[], \"train_loss\": []}\n",
        "# for task in tasks: results[task] = {\"val_loss\": [], \"train_loss\": []}\n",
        "\n",
        "# for N in tqdm(option_n):\n",
        "#   #combine training data for all tasks\n",
        "#   x_train, y_train = mergeData(train_data.values(), N=N)\n",
        "\n",
        "#   # Train the model ...\n",
        "#   model = MixedSingleTaskGP(x_train, y_train, cat_dims=[-1])\n",
        "#   #if load_kernel: model.covar_module = covar_module\n",
        "\n",
        "#   # Use Exact Marginal Log Likelihood as the loss\n",
        "#   mll = ExactMarginalLogLikelihood(model.likelihood, model)\n",
        "\n",
        "#   # Fit the model\n",
        "#   fit_gpytorch_mll(mll, )\n",
        "\n",
        "#   # #save the losses, evaluations are task specific\n",
        "#   # for task in tasks:\n",
        "#   #   x_test, y_test = val_data[task]\n",
        "#   #   y_hat = model.posterior(x_test).mean\n",
        "#   #   val_loss = torch.mean((y_test - y_hat)**2).item()\n",
        "#   #   results[task][\"val_loss\"].append(val_loss)\n",
        "\n",
        "#   x_test, y_test = mergeData(val_data.values(), N=M//4) #combine for all tasks\n",
        "#   y_hat = model.posterior(x_test).mean\n",
        "#   val_loss = torch.mean((y_test - y_hat)**2).item()\n",
        "#   results[\"val_loss\"].append(val_loss)\n",
        "\n",
        "#   y_hat = model.posterior(x_train).mean\n",
        "#   train_loss = torch.mean((y_train - y_hat)**2).item()\n",
        "#   results[\"train_loss\"].append(train_loss)\n",
        "\n",
        "# # if not smoke_test: #prevents overwritting actual runs\n",
        "# #   #save results\n",
        "# #   with open(f'{base_path}/results/vanillaGP_mixed.pkl', 'wb') as pickle_file:\n",
        "# #     pickle.dump(results, pickle_file)\n",
        "\n",
        "# #   #save model\n",
        "# #   torch.save(model.state_dict(), f'{base_path}/models/vanilla_gp_mixed_{N}.pth')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#train MultiTaskGP\n",
        "results = {\"val_loss\":[],\n",
        "           \"train_loss\": []}\n",
        "\n",
        "x_test, y_test = mergeData(val_data.values(), N=M//4)\n",
        "x_test_normalized, y_test_standardized = normalize_standarize_data(x_test, y_test)\n",
        "\n",
        "for N in tqdm(option_n):\n",
        "  x_train, y_train = mergeData(train_data.values(), N=N//4)\n",
        "  x_train_normalized, y_train_standardized = normalize_standarize_data(x_train, y_train)\n",
        "\n",
        "  #model = SingleTaskGP(c_xtrain, y_train_standardized)\n",
        "  model = MixedSingleTaskGP(x_train_normalized[:N], y_train_standardized[:N], cat_dims=[-1])\n",
        "\n",
        "  # Use Exact Marginal Log Likelihood as the loss\n",
        "  mll = ExactMarginalLogLikelihood(model.likelihood, model)\n",
        "\n",
        "  # Fit the model\n",
        "  fit_gpytorch_mll(mll, )\n",
        "\n",
        "  #get gaussian likelihood then it has object noise\n",
        "  #refer: https://docs.gpytorch.ai/en/stable/likelihoods.html\n",
        "  #print(f\"noise: {model.likelihood.noise.item()}\")\n",
        "\n",
        "  #Get the lengthscale\n",
        "  #kernel = model.covar_module.base_kernel\n",
        "  #print(f\"lengthscale: {kernel.lengthscale.detach()}\")\n",
        "  #print(model.covar_module)\n",
        "\n",
        "  #save the losses\n",
        "  y_hat = model.posterior(x_test_normalized[:M]).mean\n",
        "  val_loss = torch.mean((y_test_standardized - y_hat)**2).item()\n",
        "  results[\"val_loss\"].append(val_loss)\n",
        "\n",
        "  y_hat = model.posterior(x_train_normalized[:N]).mean\n",
        "  train_loss = torch.mean((y_train_standardized - y_hat)**2).item()\n",
        "  results[\"train_loss\"].append(train_loss)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "shnpJJCrmdpJ",
        "outputId": "e0a97bb7-10f3-4924-e85a-eae4192fd4d4"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/4 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:174: InputDataWarning: Input data is not contained to the unit cube. Please consider min-max scaling the input data.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            " 25%|██▌       | 1/4 [00:02<00:06,  2.15s/it]/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:174: InputDataWarning: Input data is not contained to the unit cube. Please consider min-max scaling the input data.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            " 50%|█████     | 2/4 [00:04<00:05,  2.56s/it]/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:174: InputDataWarning: Input data is not contained to the unit cube. Please consider min-max scaling the input data.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            " 75%|███████▌  | 3/4 [00:24<00:10, 10.34s/it]/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:174: InputDataWarning: Input data is not contained to the unit cube. Please consider min-max scaling the input data.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            "100%|██████████| 4/4 [01:34<00:00, 23.54s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#plot training and validation loss\n",
        "# Create a line plot\n",
        "plt.plot(option_n, results[\"val_loss\"], label = \"Validation\")\n",
        "plt.plot(option_n, results[\"train_loss\"], label = \"Training\")\n",
        "\n",
        "# Add labels and title\n",
        "plt.xlabel('N points')\n",
        "plt.ylabel('MSE Loss')\n",
        "plt.title('Multi-Task Samples vs Loss')\n",
        "plt.legend()\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "t6QgeYXtpWyI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "outputId": "4eb641bd-fad3-42cc-ded0-eef60530ed86"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for task in tasks:\n",
        "  def modelWrapper(X):\n",
        "    id = getTaskID(task)\n",
        "    id_vector = id * torch.ones((X.shape[0],1))\n",
        "    inp = torch.cat([X, id_vector], dim=1)\n",
        "    return model.posterior(inp).mean\n",
        "\n",
        "  surfacePlot(modelWrapper, title=f\"GP for task {task}, {option_n[-1]} points\", n=100)"
      ],
      "metadata": {
        "id": "1Ug8B2l3ywqf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "9ab804de-7f0d-420e-9be8-29cecc93b1ed"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3526.)\n",
            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACL/klEQVR4nO2deVhV1frHvweQSQYnZBIFNcV5TEJNwCisrmWZqZmzll41DRu0TBxKy8y8lYnZNa2rZZlaOVCKopmkOVA5FoqhKKipIKCCsH9/+Duncw5n2PP4fp7nPA/ss/ba715n7bW++13vWsvEMAwDgiAIgiAIA+ChtAEEQRAEQRByQcKHIAiCIAjDQMKHIAiCIAjDQMKHIAiCIAjDQMKHIAiCIAjDQMKHIAiCIAjDQMKHIAiCIAjDQMKHIAiCIAjDQMKHIAiCIAjDQMKH0BVFRUV44oknUL9+fZhMJixevFhpkwSTmJiItm3bSpZ/dHQ0RowYIVn+RuHMmTMwmUxYuXKl0qYQBOECEj6E5OTl5WHixIlo0aIF/P394e/vj9atW2PChAn47bffbNLOmjULJpPJ8jGnnTFjBkpKStxe6/nnn8f333+P6dOn47PPPkOfPn2kui2Ul5dj1qxZyMrKkuwaeuLgwYP417/+hbCwMAQEBKB9+/Z47733UFVVVSPtt99+i86dO8PX1xeNGzdGWloabt++XSPdtWvX8MwzzyAkJAS1a9dGUlISDh06JMftiArVJYKQDy+lDSD0zaZNmzBw4EB4eXlhyJAh6NChAzw8PHDixAmsX78eS5cuRV5eHpo0aWJz3tKlSxEQEIDS0lL88MMPeOONN7Bjxw789NNPMJlMTq+3Y8cOPProo3jhhRekvjWUl5dj9uzZAO54ZQjnHDx4EN27d8ddd92Fl19+Gf7+/ti6dSsmT56MU6dO4T//+Y8l7datW9GvXz8kJibi/fffx++//47XX38dFy9exNKlSy3pqqur8fDDD+PXX3/Fiy++iAYNGuDDDz9EYmIiDh48iLvuukvWe2zSpAlu3LiBWrVqcT6X6hJByAhDEBKRm5vL1K5dm2nVqhVz/vz5Gt9XVlYy//nPf5j8/HzLsbS0NAYAc+nSJZu0jz/+OAOA2bt3r8trmkwmZsKECeLcAMMwN27cYKqqqhx+d+nSJQYAk5aWJtr1HJGQkMC0adNGsvybNGnCDB8+XLL8GYZhxo4dy3h7ezN///23zfFevXoxQUFBNsdat27NdOjQgamsrLQce/XVVxmTycQcP37ccmzt2rUMAOarr76yHLt48SJTp04dZvDgwRLdiTTIVZcIgmAYGuoiJGPBggUoKyvDJ598gvDw8Brfe3l54bnnnkNUVJTbvHr37g3gzrCZI1auXAmTyQSGYbBkyRLLUJmZ06dPY8CAAahXrx78/f1xzz33YPPmzTZ5ZGVlwWQy4YsvvsCMGTMQGRkJf39/h0NsZ86cQUhICABg9uzZluvNmjULAPDbb79hxIgRaNq0KXx9fREWFoZRo0bh77//tsnn+vXrmDJlCqKjo+Hj44OGDRvi/vvvdztc88MPP8Df3x+DBw92OARk5s8//0T//v0RFhYGX19fNGrUCIMGDUJxcbHTc65cuYIXXngB7dq1Q0BAAIKCgvDggw/i119/dWmTK0pKSuDr64s6derYHA8PD4efn5/l/2PHjuHYsWN45pln4OX1j0P63//+NxiGwbp16yzH1q1bh9DQUDz++OOWYyEhIXjyySfxzTff4NatWy5tio6Oxr/+9S/88MMP6NixI3x9fdG6dWusX7++Rlo29cdRjM+IESMQEBCAgoIC9OvXDwEBAQgJCcELL7xgGeJzV5cKCwsxcuRINGrUCD4+PggPD8ejjz6KM2fOuLw/giAcQ0NdhGRs2rQJzZs3R1xcnOC8Tp06BQCoX7++w+979eqFzz77DEOHDsX999+PYcOGWb4rKipC9+7dUV5ejueeew7169fHqlWr8Mgjj2DdunV47LHHbPKaO3cuvL298cILL+DWrVvw9vaucb2QkBAsXboU48ePx2OPPWbpfNu3bw8A2LZtG06fPo2RI0ciLCwMR48exUcffYSjR4/i559/toiycePGYd26dZg4cSJat26Nv//+G3v27MHx48fRuXNnh/e6adMmPPHEExg4cCBWrFgBT09Ph+kqKiqQkpKCW7duYdKkSQgLC0NBQQE2bdqEa9euITg42OF5p0+fxsaNGzFgwADExMSgqKgIy5YtQ0JCAo4dO4aIiAiH57kiMTERa9euxbPPPovU1FTLUNf69evx9ttvW9IdPnwYANC1a1eb8yMiItCoUSPL9+a0nTt3hoeH7ftbt27d8NFHH+GPP/5Au3btXNr1559/YuDAgRg3bhyGDx+OTz75BAMGDEBGRgbuv/9+ANzrjz1VVVVISUlBXFwcFi5ciO3bt+Odd95Bs2bNMH78eLd1qX///jh69CgmTZqE6OhoXLx4Edu2bUN+fj6io6NdXpsgCAco7XIi9ElxcTEDgOnXr1+N765evcpcunTJ8ikvL7d8Zx7qOnnyJHPp0iUmLy+PWbZsGePj48OEhoYyZWVlLq8LoMZQ15QpUxgAzI8//mg5dv36dSYmJoaJjo62DGXt3LmTAcA0bdrUxiZnuBqecHT+559/zgBgdu/ebTkWHBzsdmjOeqjr66+/ZmrVqsWMHTvW6RCcmcOHD9cYCnKE/VDXzZs3a+Sdl5fH+Pj4MHPmzHGZlzNu377NTJw4kalVqxYDgAHAeHp6MkuXLrVJ9/bbbzMAbIY/zdx9993MPffcY/m/du3azKhRo2qk27x5MwOAycjIcGlTkyZNGADM119/bTlWXFzMhIeHM506dbIcY1t/8vLyGADMJ598Ykk3fPhwBkCNcuvUqRPTpUsXy//O6tLVq1cZAMzbb7/t8l4IgmAPDXURkmAeHgoICKjxXWJiIkJCQiyfJUuW1EjTsmVLhISEICYmBs8++yyaN2+OzZs3w9/fn7MtW7ZsQbdu3dCzZ0/LsYCAADzzzDM4c+YMjh07ZpN++PDhNsMvfLA+/+bNm7h8+TLuueceALAZxqpTpw727duH8+fPu83z888/x8CBA/Hss89i2bJlNTwd9pg9Ot9//z3Ky8tZ2+7j42PJu6qqCn///TcCAgLQsmVL3jOmPD090axZM6SkpGDVqlVYu3Yt+vbti0mTJmHjxo2WdDdu3LDYYI+vr6/le3NaZ+ms83JFRESEjccmKCgIw4YNw+HDh1FYWAiAe/1xxLhx42z+v/fee3H69Gm35/n5+cHb2xtZWVm4evWq2/QEQbiHhA8hCYGBgQCA0tLSGt8tW7YM27Ztw//+9z+n53/99dfYtm0bsrKykJubiyNHjqBLly68bPnrr7/QsmXLGsdbtWpl+d6amJgYXtex5sqVK5g8eTJCQ0Ph5+dnEXEAbOJrFixYgCNHjiAqKgrdunXDrFmzHHaIeXl5ePrpp9G/f3+8//77Lme2Wd9HamoqPv74YzRo0AApKSlYsmSJy/ge4M5sqXfffRd33XUXfHx80KBBA4SEhOC3335ze64z3nzzTbz11lv4/PPPMWzYMDz55JPYsGEDevbsiQkTJljilMyC0VF8zs2bN20EpZ+fn9N01nm5onnz5jXKskWLFgBgiaHhWn/s8fX1tcTwmKlbty4rIePj44O33noLW7duRWhoKHr16oUFCxZYRBlBENwh4UNIQnBwMMLDw3HkyJEa38XFxSE5ORk9evRwen6vXr2QnJyMhIQENGvWTEpTayDU2wMATz75JJYvX45x48Zh/fr1+OGHH5CRkQHgjrCwTnf69Gm8//77iIiIwNtvv402bdpg69atNvmFh4eje/fu2LJlCw4cOMDajnfeeQe//fYbXnnlFdy4cQPPPfcc2rRpg3Pnzjk9Z968eUhNTUWvXr3wv//9D99//z22bduGNm3a2NjOhQ8//BC9e/eu4QF85JFHcP78eYvIMAfBX7hwoUYeFy5csIkvCg8Pd5oOAK9YJClwFoPFlilTpuCPP/7A/Pnz4evri9deew2tWrWyiXciCII9JHwIyXj44YeRm5uL/fv3K2pHkyZNcPLkyRrHT5w4YfmeD868LlevXkVmZiamTZuG2bNn47HHHsP999+Ppk2bOkwfHh6Of//739i4cSPy8vJQv359vPHGGzZpfH19sWnTJtx1113o06cPjh49ytrOdu3aYcaMGdi9ezd+/PFHFBQUID093Wn6devWISkpCf/9738xaNAgPPDAA0hOTsa1a9dYX9OeoqIihwsVVlZWAoDF49OxY0cAqCHuzp8/j3Pnzlm+N6c9dOhQDTG2b98++Pv7Wzw3rsjNzQXDMDbH/vjjDwCwBA5LVX+scefBa9asGaZOnYoffvgBR44cQUVFBd555x3B1yUII0LCh5CMl156Cf7+/hg1ahSKiopqfG/f4UjFQw89hP379yM7O9tyrKysDB999BGio6PRunVrXvma443sBYH5Dd/+/uy3z6iqqqoxdNSwYUNEREQ4HMIJDg7G999/b5nybp7p5oySkpIaU93btWsHDw8Pl1O9PT09a9j+1VdfoaCgwOX1XNGiRQts27bNZjp/VVUVvvzySwQGBlq8em3atEFsbCw++ugjG6G0dOlSmEwmPPHEE5ZjTzzxBIqKimymn1++fBlfffUV+vbt6zD+x57z589jw4YNlv9LSkrw6aefomPHjggLCwMgXf2xxlldKi8vtwzdmWnWrBkCAwPdTtcnCMIxNJ2dkIy77roLa9asweDBg9GyZUvLys0MwyAvLw9r1qyBh4cHGjVqJKkd06ZNw+eff44HH3wQzz33HOrVq4dVq1YhLy8PX3/9tdsgYWf4+fmhdevWWLt2LVq0aIF69eqhbdu2aNu2rSUWo7KyEpGRkfjhhx9qrEF0/fp1NGrUCE888QQ6dOiAgIAAbN++Hb/88ovTt/kGDRpg27Zt6NmzJ5KTk7Fnzx5ERkY6TLtjxw5MnDgRAwYMQIsWLXD79m189tln8PT0RP/+/Z3e17/+9S/MmTMHI0eORPfu3fH7779j9erVDj1WiYmJ2LVrl1sRO23aNDz99NOIi4vDM888Az8/P3z++ec4ePAgXn/9dZvVjt9++2088sgjeOCBBzBo0CAcOXIEH3zwAcaMGWOJqwHuCJ977rkHI0eOxLFjxywrN1dVVVlWQXZHixYtMHr0aPzyyy8IDQ3FihUrUFRUhE8++cTGdinqjzXO6tLt27dx33334cknn0Tr1q3h5eWFDRs2oKioCIMGDRJ8XYIwJEpOKSOMQW5uLjN+/HimefPmjK+vL+Pn58fExsYy48aNY3JycmzSOlu5mS1wMJ2dYRjm1KlTzBNPPMHUqVOH8fX1Zbp168Zs2rTJJo15Oru76d/W7N27l+nSpQvj7e1tMx353LlzzGOPPcbUqVOHCQ4OZgYMGMCcP3/eJs2tW7eYF198kenQoQMTGBjI1K5dm+nQoQPz4Ycf2lzD0crNubm5THh4ONOqVSunZXX69Glm1KhRTLNmzRhfX1+mXr16TFJSErN9+3abdI6ms0+dOpUJDw9n/Pz8mB49ejDZ2dlMQkICk5CQYHNuly5dmLCwMFZllZGRwSQkJDANGjRgvL29mXbt2jHp6ekO027YsIHp2LEj4+PjwzRq1IiZMWMGU1FRUSPdlStXmNGjRzP169dn/P39mYSEBOaXX35hZU+TJk2Yhx9+mPn++++Z9u3bMz4+PkxsbKzD359N/XE2nb127do18jPXc2sc1aXLly8zEyZMYGJjY5natWszwcHBTFxcHPPll1+yukeCIGpiYhiZxhsIgtAV169fR7169bB48WJMmDBBaXM4Ex0djbZt22LTpk1Km0IQhIxQjA9BELzYvXs3IiMjMXbsWKVNIQiCYA0JH4IgePHwww/jzJkzDrf0IAiCUCskfAiCIAiCMAyKCp/du3ejb9++iIiIgMlkslm63hlZWVno3LkzfHx80Lx5c5udkAmCINhy5swZiu8hDM38+fNx9913IzAwEA0bNkS/fv0crlllzcqVK2EymWw+5m1itIKiwqesrAwdOnRwuFeTI/Ly8vDwww8jKSkJOTk5mDJlCsaMGYPvv/9eYksJgiAIQl/s2rULEyZMwM8//4xt27ahsrISDzzwAMrKylyeFxQUhAsXLlg+7rZtURuqmdVlMpmwYcMG9OvXz2mal19+GZs3b7bZBmHQoEG4du2aZTsAgiAIgiC4c+nSJTRs2BC7du1Cr169HKZZuXIlpkyZImgld6XR1AKG2dnZSE5OtjmWkpKCKVOmOD3n1q1bNiucVldX48qVK6hfvz6rjR4JgiAI48IwDK5fv46IiAhRFqt0xs2bN1FRUSE4H4ZhavRtPj4+rFYyN68kX69ePZfpSktL0aRJE1RXV6Nz586YN28e2rRpw99omdGU8CksLERoaKjNsdDQUJSUlODGjRsON5ecP38+61VcCYIgCMIRZ8+elWyV+Zs3b6Jxk9q4dJHfJsDWBAQEoLS01OZYWloaZs2a5fK86upqTJkyBT169EDbtm2dpmvZsiVWrFiB9u3bo7i4GAsXLkT37t1x9OhRyVfhFwtNCR8+TJ8+HampqZb/i4uL0bhxY0TNngEPGQKyPMPKJb8GQYhBVaG/4Dz0UN+5loNfATsvQO0Lwjs1oZSFq2cirxrKgw1VlTeRs/F1BAYGSnaNiooKXLpYjd37GyIggP9IRGkpg17dLuLs2bMICgqyHGfj7ZkwYQKOHDmCPXv2uEwXHx+P+Ph4y//du3dHq1atsGzZMsydO5e37XKiKeETFhZWY7PLoqIiBAUFOfT2AM5dfB6+vvIIH3/5Hu5WYTU3ArXneGGo2zRqwnxPWrNbLJz9plKUh2fTatw+L0z8yFnfpYJrOXj6sBMTXrWUL5vgy0BppDrEjxrKgwtyhEYEBJgQECjk97lTpkFBQTbCxx0TJ07Epk2bsHv3bs5em1q1aqFTp07Izc3ldJ6SaEr4xMfHY8uWLTbHtm3bZqM+1YRXhDxvv2wEj31atQoJZ/eidrvFxt1vqsbykKu+y4FXRDlr8VPeqBr+59x3VqWRHggo0FZnLyVUHsrDMAwmTZqEDRs2ICsrCzExMZzzqKqqwu+//46HHnpIAgulQVHhU1paaqMS8/LykJOTg3r16qFx48aYPn06CgoK8OmnnwIAxo0bhw8++AAvvfQSRo0ahR07duDLL7/E5s2bOV/br8ADnj4eKG+k3QePi+Bxdq6aOk5Cebh0+PbnEe6hzt4Ws/dJ6jIJzLtR49j1GMejBEZiwoQJWLNmDb755hsEBgaisLAQABAcHGwZRRk2bBgiIyMxf/58AMCcOXNwzz33oHnz5rh27Rrefvtt/PXXXxgzZoxi98EVRYXPgQMHkJSUZPnfHIszfPhwrFy5EhcuXEB+fr7l+5iYGGzevBnPP/88/vOf/6BRo0b4+OOPkZKSwtsG6zc1rYggIYLHUV5aET9asVMoYv6+BH/4ikB3KCl+1DLMZY+UAsiR6HF1HDCOKFq6dCkAIDEx0eb4J598ghEjRgAA8vPzbWazXb16FWPHjkVhYSHq1q2LLl26YO/evWjdurVcZgtGNev4yEVJSQmCg4MR+9w8ePrUjPERS/yI/QYsdWeoJlEhZ1yLGuHyW0tVJlw6fKm9PdblIXcdYFsObIa67JFb/KhV9DhDjPJxJW7cYRY/tytv4uBXM1BcXMwpboYL5n7p0LFQQTE+pder0bl1kaS26gFNxfjIgbkBU4P3R843fzUNfR0vDDWs18Oo922Pu1gvQJ66ytbrwzbOxxqtDntZt418BB9brIUan3ISInqsz7/aiNZ70xskfJzgf065+B8lOz+1CCDz9dVijxyoSfSYvTiuOn2pPD1sy0FLw7TOkCvGha+3x10b6Op7MUWRXOXkiMAzwgQUoT5I+LhACfGjls5PyeEFa7TesbGF7+8udefvzOOhtOiRE6lifayR0vvDR/SI0e7Z5yGGENKql4xQFyR83CCX+FFjg2/GSF4XJVDzbw/IM2NLrcJPTqTo1JUSPWzy5SuE2JbT9Rg/wcNdhD7RVrSbQkg5jq0l1N5Ba41WYUWilKnWfxet229GDXGB1qhJ9Di7lvnDFbb3ZpTZWQQ3qEdniZTiRysNv17erJVGLMEjdZ5yoBXhJ4fXS2xvD9f8lBRufAQQiR+CLzTURUiCo87IlXDi2nlpVYRJ3UlraVhSi0JNKpSOW1GLt8psB9sXTRr2IvhAwocDSs70khI2gsRdR8qmExN74UVAGx08IH8nr+byIcFjC4memnARQFzEjxkSQcaGhA9H2Iqf2+f9NbGMv7uO0dn3aum81DL7zBlKl5OaBJCUZSHHfYo9u0tpwaMFpNoHzSyCSAAZExI+PFDS89O7wQkAwI7LsYpcX+mO3BVq6eTVWEZilQ1XoamUp8sepeuEPSR62CPlJrAkgIwJCR+NYBY8jv5XSgSpFTm8QGoUN2zgI4DYrKKsdtQiigF5RU9AQbXmtqpwhJTiB6AYIKNBwocncnp97EWPo+/lED9a6ujMCO3wtHjPbGAjDvV470Lrg7vhLncdNNtOOTDvBs1GsoPEDyEWJHwIVmi9E9S6/VJixLIRsvChHCs5i4UevD184LvFBYkfY2DMp8IJAQXVlo/WcOcVcoQa3P4EoRRCBB+fiQt8gm+FwEb0qHFGlyukWuuHMBbk8fl/7Bsl8/9yPDhG3o2cIJRET1teWKNEh+9KDCrpIePq/TF7fczi83alCfhFMvMIBSA5DNcPhBq8P1LE74gR3EoQeoDvqtdqW66iNNLD8mGDUG+PV0S5zYdtWqHwtZuLGKT4Kn1DHh836NVVyuZNlwQPYSTEmvnlKAjX1QuUdUwJnw5X7jZKqHgxny/EC8Q20NkevrE/hL7QZ68uEnI2KEq4210JGxI9hFExe4DYPANKe334tlF8vCZieWzEyk+Ix0qvL7QEO8jj4wStPRh8h8Os33JJ7BCELfbPhKMXFCGzvOxnELGdxi6kfeIreqRCSPnx9fwA5P0xMtrq3TWGWAF9fGZscYVED0FIh5Z3EpfDqyXE+yM0VklrL7mEcAzr8al9oRpetUjpEwShHHILHa4iQe6hPL7eHyGeH4C8P0bDsMLHHWIt9S50s1I5vD0E4Qi2cWdG8Rbqcdq7K5SKXxIifgB2O7o7w77NJyGkT8jHJwAhDxhBqJXjhaGcOnlzej0LAzHuTcwhFT4dMhdvj9JB20oFPdtTGumBsnBq5/UG/aIuEEvta2V5e8LYiCFe9CiA3N2Po+fbWeerhXgSpUWPGbWIH0J/qP8pVBh34kcsr4+Q4QLanZ0QghRiRS/iRy/3oVVI/BBSQDE+LBAr3kcKSPQQfODSodt7NNTiEdAqfHcPFwJbEaC331aMuB9Cf1BtYImrhkqph4pED8EHtqLn9nl/h8M4zo7zvY5a0br9ekHJbS4IfWJ4j4/9AmKuppeqyfNDoofgChfBwzad3jwERkbIb8lmqF6IkBSyyKEZ8v4QZgwrfALP3ICXF1Pz+P8LIbUsJEYCh5ATrp2LO/FDK4LrF66/K5v9AV0hhvgBhK/5Q2gf+vWdYO8JMiPV2Dy51Qm9QnVbfLh4nsUe5uG7m73QcwHxYpDKG1VbPoTxIOHjAmfixxH0BkFoHb5v07Rcg3EQy3unBvFjxsgCaP78+bj77rsRGBiIhg0bol+/fjh58qTb87766ivExsbC19cX7dq1w5YtW2SwVjyot3YDF/EjFHozJpRCavFCdZuwR03iBzBmAPSuXbswYcIE/Pzzz9i2bRsqKyvxwAMPoKyszOk5e/fuxeDBgzF69GgcPnwY/fr1Q79+/XDkyBEZLReGiWGYmoEuOqakpATBwcFIvPtVeHn5uk3vKNbHmZvZ3YPD9mGlmAhCbFwJD0eix96DyaZTcFe/tVavhQaDu/ICCx0yZzvUJeZqzVL9fkJEsVSC3fq3q7p1EyfeewXFxcUICgqS5HrmfunQsVAEBArYcuN6NTq3LuJt66VLl9CwYUPs2rULvXr1cphm4MCBKCsrw6ZNmyzH7rnnHnTs2BHp6em8bZcT8vjwQOo1OOjtmJAL+47D/5yHww5bjKFcrdVrth29M8GgJw+ClKJVbZ4fQPvDXyUlJTafW7dusTqvuLgYAFCvXj2nabKzs5GcnGxzLCUlBdnZ2fwNlhnDzupig7OZXc7etvzPebh8WLhM/zV3Elp7SybUhzPBYS162Agbcxq+HQLVZXGQwtvjCjl+NyEzvsSa7eWI8kbV8DklSdYO+aEsFr4m/t3yzbLbAIoQFRVlczwtLQ2zZs1yeW51dTWmTJmCHj16oG3btk7TFRYWIjTU9rcKDQ1FYWEhX7Nlh4SPE6Sazs517ROaDkwIgY/okWK9Kr3XYWedr7Op01Kv3iyHt6J3gxMuv+e6FIdaxc+NSO15fs6ePWsz1OXj4+P2nAkTJuDIkSPYs2ePlKapAhI+DpB6DR8+4gfgvkiY3jsbwjVcRI99J2z9v70IcufZtEfL9VDo2jOu4CN+2AhSPqLHWXvk6LdzJ3js03ERQFKWt5EICgriFOMzceJEbNq0Cbt370ajRo1cpg0LC0NRkW29KCoqQlhYGC9blcCwMT7Xo/1wPcbxxxVivQmzXfbfGnebSdp/p8edsglhsBE99jMZAwqqa6RhG/OjZdHDFT6xPmpZCZ4tbEWPkHP41hlaRZw7DMNg4sSJ2LBhA3bs2IGYmBi358THxyMzM9Pm2LZt2xAfHy+VmaJDHh+F4bPsPxcxY6SOh/gHR3XEleixFzuOVjDnOgSml7rHxQvBdcgLUGbTUoIA7gxvrVmzBt988w0CAwMtcTrBwcHw87vz7A8bNgyRkZGYP38+AGDy5MlISEjAO++8g4cffhhffPEFDhw4gI8++kix++CKtl43FEaKtzOp3lKErpBKaBuuv73Yw7t6q3tc7ofPM82mbZHKO8RlmMsRDwUcw0MBx1ymkcvrQ3Bj6dKlKC4uRmJiIsLDwy2ftWvXWtLk5+fjwoULlv+7d++ONWvW4KOPPkKHDh2wbt06bNy40WVAtNogj4+IqGH6IzUYBBesvQ3XY/x4L9hp3XlSHXTs+XG3R5QSnh+9DQ9JGeSsR9gs45eVlVXj2IABAzBgwAAJLJIHEj4sUftYPHU2+sXZ2zLXWTPWnYKzTtha/IjlBbK2X8ub7pqfMSHDXmraIJOr6HFUD609PQ8FHMOW0taC7TJDgc6EVKjjCTQgXhHlunvbIuTF3fABWzFsL+rZBPkD3Bc1FFv0mIP3rT9yYB5Gtv84gsszLre3x51nxL48Hf1+1kJHTNEjBGpXCXeQ8GGB2FNI6cEkuOBKMPRucMKlALLvkK3rnnWdZevRdNY5u+pEd1yOlUT0ODuulJfAmQhi87yLKXq4CFJ3s0vZih93oofv70+ebEIKSPjIDIkeQgq4BI9KJX7MSC08tDD8wUf8KAlX8cNWyIghevmIH7WXN6EsJHzcoPbYHsIYCOk8pHxrtvYuWHeeUokTtvmqQRyxLXcphrj4xBG58v44Kk9XokYKLx9BiAUFN4sA22EuegshhGDfkbANGlZKBIi93YoaxIwjXAWfuwvQlTKuh+sK22acrS3m7PckgUNoDRI+LiBvD6Fm+HY4XKf7BubdqBHs7GwxQ/tOU8gWKmoVOtbwWcnYjBzBzHKJHzVCU9sJZ5DwcYLYOyBL7e3RUoNEyIdY4sGR+DHDtnOVU8gIeRbYijV3oqd3gxNOxam16LFeO0nqfQK5oAfxQxCOIJeGDNAQF6EVHAl+R9PbrdPZix4++9CpBSn2u7MWCfaxN862ChETIesGuYr50YJHjiAcQcJHAGpYqdkaaogIa9zt1+UMd95OLQwB83kWuJ7jbqjR/L0Yz6XQMpdq0UQ52hy+19Cq+CakR/0tmAKI2bCTt4fQIqWRHjWeA0fH1Cb+reHSYbpL6+x7V7OarM9z1gnbe9KkHOqSUvxI5QEi0UNIAcX4SIgSoofG3wmAW4fhbudwV+e5wlmMiJyYy8HZMyFGZ+1M/HDN25noEfNFjE+wM5ffUUgwu6u8uECih3AHCR87xA5qJgi5cdZhiNkhaK3+iyFwuLxUWF/PXbmrKaBZTOzLnE/ZEYQUkPCRCKXfdAljwrfTUNPmmWqGqwfJmehhuxO7FuKp2CK1oCFPD8EWEj4SoLTooeEugg9mL447AcTF26OG4S4pEDNgWe7NSaUe7lICEj0EF/TzOiEjrhoNNTcOhL4R643aUf0ub1Rt+RDsYNsZO/Pq6MnbIyUkegiukMdHZqw9MVK5fsnbQwhFTIGjdm+BFIjRGbP1BMklkNT4O5LoIfhAwscKoQ2Is0bBmRCxPy7mQmmEsaCAUPUjVQyVs+1DnKEXrx2JHoIv5EuVGC5iRIhwIdFjXEj0qAs+HbLQly654oTUIDa0vDI4oQ5I+KgMrgKmVVgRiR4Dw0X0KDlMYZSOSsn71Lv4IcFDiAUJHyvknl0hBBI8BHl69INYbQ+bfMQYcpNTgJDgIcSGhI8dahA/rgQNCR4C4C961BacSoiPXsQPCR5CKhQXPkuWLEF0dDR8fX0RFxeH/fv3u0y/ePFitGzZEn5+foiKisLzzz+PmzdvymTtHbg0Gnw7KLPAsf8QxkXKPZEI4fDtpJV62VLjgpVmsUOCh5ASRWd1rV27FqmpqUhPT0dcXBwWL16MlJQUnDx5Eg0bNqyRfs2aNZg2bRpWrFiB7t27448//sCIESNgMpmwaNEi0eziOkvCjLPpnlpZUNBVh6oF+/WC1MLGK6JckY5FjdOh5cKZyJBK9LBtw/gsZmgNn99UbaLGnQCsuqU+gUgIQ1Hhs2jRIowdOxYjR44EAKSnp2Pz5s1YsWIFpk2bViP93r170aNHDzz11FMAgOjoaAwePBj79u0T3Ta+4scZ7pa6t05jj1SiQ8zdq63Ri0gS4q2T61p8UUr8GBUltgSRU/xoATV6uAhlUEz4VFRU4ODBg5g+fbrlmIeHB5KTk5Gdne3wnO7du+N///sf9u/fj27duuH06dPYsmULhg4d6vQ6t27dwq1btyz/l5SUsLbRVcPhrLFw9wbEp4MT22MkdSdr9KEYrdw/W/FjXZ+FdnJG9vrYo4Z4QjNCxY8aIaFDOEMx4XP58mVUVVUhNNS2kwgNDcWJEyccnvPUU0/h8uXL6NmzJxiGwe3btzFu3Di88sorTq8zf/58zJ49m7edYnt++CKW+NFKp0zIA1cR4ig9VzFE4sc5gXk3nH7HZxd3tbRfckFih2CDpmpJVlYW5s2bhw8//BCHDh3C+vXrsXnzZsydO9fpOdOnT0dxcbHlc/bsWdHscfaQSeX6FSJaKCiWkAqviHJecR5aGSJhi7kcnJWHK49KYN4Nl6LHnIYPbD1LWhUN/uc8LB+CYINiHp8GDRrA09MTRUW2XoyioiKEhYU5POe1117D0KFDMWbMGABAu3btUFZWhmeeeQavvvoqPDxqVnwfHx/4+PgIslVNb03W4sWdB4iEDqF2zOJHjx4g8z1pSeBpaciLhA7BF8WEj7e3N7p06YLMzEz069cPAFBdXY3MzExMnDjR4Tnl5eU1xI2npycAgGEYXnbYv0U5cydzFT9yuPNJ2BBqQkjAtPV5ehNB1uWiRJAzoK6XNzEg0UMIQdHak5qaiuXLl2PVqlU4fvw4xo8fj7KyMsssr2HDhtkEP/ft2xdLly7FF198gby8PGzbtg2vvfYa+vbtaxFAbAk849i1zMblbA09gATxD2KIFrWu5WJtF1fbHJWLtRBhG7/Dd7iLC2pu02hIS3x2796Nvn37IiIiAiaTCRs3bnSZPisrCyaTqcansLBQHoNFQNHp7AMHDsSlS5cwc+ZMFBYWomPHjsjIyLAEPOfn59t4eGbMmAGTyYQZM2agoKAAISEh6Nu3L9544w1Z7NXbWxNBiI3YYsU+PyW8Qc7uSexhOrP4ETvA2QyX9kttQ14kdqSjrKwMHTp0wKhRo/D444+zPu/kyZMICgqy/O9o7T21oqjwAYCJEyc6HdrKysqy+d/LywtpaWlIS0uTwTL28J3aThAEN+QaEuMi4NgIIGf5lUZ61Ag+diSAhAgea7iKH8B1ULbUkOCRngcffBAPPvgg5/MaNmyIOnXqiG+QDCgufPQOiR/CKMg9NCWFCBJyD2Lfv1hiRyhKCSASPfyxX69OjEk+9nTs2BG3bt1C27ZtMWvWLPTo0UPU/KWEhI9IuHINk/gh9I7S8ThChsSUtl1u+A7ZWwsRKUWQkQXPrr9boNZNb97nV5ZVANiFqKgom+NpaWmYNWuWMOP+n/DwcKSnp6Nr1664desWPv74YyQmJmLfvn3o3LmzKNeQGhI+HBGyjxegvxkrhLFRq2hQq11qQWi8olReICOLHjE5e/asTfyNmN6eli1bomXLlpb/u3fvjlOnTuHdd9/FZ599Jtp1pISEjxMC825wdjWzCQjU87RdwjiQsOCOmJ06n/bJHjEma4jpBSLRIx5BQUE2wkdqunXrhj179sh2PaGQ8FEQNcxYIQgSMdIjRaduDn6Wa6aXO/iKIBI82icnJwfh4eFKm8EaEj4iI2QaKAkhQk5I8EiD3B25GN4fsbEvA0dtopTlZD9TjpYhcU5paSlyc3Mt/+fl5SEnJwf16tVD48aNMX36dBQUFODTTz8FACxevBgxMTFo06YNbt68iY8//hg7duzADz/8oNQtcIaEjwv4NihirYHhrGMiQUQIhUSPdHBZnZnPDu3OFl41w7XNkmN9MrnEoLPyNB8nAVSTAwcOICkpyfJ/amoqAGD48OFYuXIlLly4gPz8fMv3FRUVmDp1KgoKCuDv74/27dtj+/btNnmoHRI+EiHlAmAkiAi+kODRP3xe2LS+OCtbAan1+5SCxMREl1s+rVy50ub/l156CS+99JLEVkkL1QAJkdvlLWRJfUL/UJ0wDly33gH4eZ/UAFe7tXqfhHiQ8JEYJfeWIRFEmKE6YEy4CiASBYQRoKEuF4gZMKj08u80jZ4g1IWcIkOMGWBqhIQawQfDenyuR/u5bASkaiDMHiAlp3DS2z9BKItSHbYcu7urHYrxIQxfAxwJHHeiR6xGS0kRRENgxoF+Z30h9KXMnfjRsxeFRA8B0FAXAHW4f9mseyEFtI+Y/vGKKCfxIyOuXmTEEhWOdnDnghrX/pESEjyENSR8eCL1tEg5hRCJH4IQBzlEjzXW4oWGsWwhsUM4g4SPAORcE8JRgyqmGCLxo2/I6yMtcgseR5AIugMJHsIdJHwEYt2oyf3AiblBIEDihyC44i4+T6l4GaOKIBI9BBtI+IiIksuiizVdnsSPflGD18eZUFBqmQchqMHLwwYjxfLQ1hQEG0j4SICSG+SJ4QUi8UOIjTvPiJRbvEgBV9HjyOuiR0Fi/RtKPVvVlbikrSkIV5DwkQFHD6gcD6UQLxCJH32ihNeHbQeoFfHDRfS4GmYSsrGolHBtm5z9ZubjSq1ZRuKHcAYJH4WQUwzxFUAkfgi5UXqFc3eIJXrUipaEQmmkh9shRRI/hCMMK3zKwj0QfFlpK2yRWgzx6VRI/BCEtKjB2yOknXE2vC6Hp8ed+CHRQzjCsMIHsH0o1BSMaI0UYoirACLxoy/UEOSsR+w74esxfqrz+vBtO9gGDSsxrOVM/JDoIZxhaOFjjRZEkBmxgqe1ElNBEFrFnfgR09sjRUdv39ZIsXyHGF4iEjkEF0j4OMD8EKldAJkR0hiR+CGkprxRNacOTc310d29OHqBknIoS8kOn2/8jKvf19l3SniSzLZU31RvfST4QcLHBWyC59QGHxFE4sd4qHW4Swv1kK2Qk8KLrDbPBlfxw/f3lSt2SAv1jxAOCR83aM37Y42Sq0oThDVspjbrudNx9Py5a1PU8MyKOXNKrN/XPh+hQkjP9Y5wDAkflmjR+2ONu+BEV14fCmzWJ0p4fZx5S7TW+XCx11nHrAZhwwahL39S/7bu8iePNmEPCR8O8BU/XGZ2SD21leuS7iR6CCkxQofENcZJrYi1sKHcqMUOQj2Q8JEIvtNY5Vrano0AItGjf5Ty+hgNNYkfMbxVYuRNEEpBwocjbLw+Yq/dIeXS9tbj8+QSJgjpUEr8CHmmqT0g9AgJHx64Ej9SL1jGxSPEdv0QR8GJ5O0xDmqd4aVH5BI/WhUsQtodqsMEWwwrfG5EVsPDV9lN9MSCj9hy50Wi1ZqNhdzix/6Z02pHrRakKD9Xz79YdUXMNsY6LxJBhCsMK3yscdVoaF0UseGOCPJDaaSH4Ya7WoUVuU1zvDBUtLz45i0HcokfR8+U2uqdlMJMLK+P2OXFRYSo/aXIbB8JIMIRJHzc4Gz9EUfDXWrbl8cRXqcKahy73SwSwD9DXuZOSI9eHz7ihM85XPNWiwCSWvy46vDVJn6khI/4kdurowdIABGOIOFDALgj2q7H+PFehl7tSClexEBtAkgq1DS7yRVyCDAlRR4bwSOmN1RM7O1iYwPFsRHWqL8FUgGOGmqtLmZo9u64w3zPemgs1C56rGkVVqS4vVJ7AcobVdfo9B0dI6TB3e/LpQ7KWV+dXYutDXr3bhHsIY+PG7TwdsoVLuLHPORlRmuNh9Iigi9Ke4DkeEMmoSMfbJ9bR89L7wYnHKbdcTm2xnlS1Vc2z3GrsCK316ehLwIgj49LuIgeLcT3uILt+kC3z/trotFQg+dEDMz3ocS9aE3kEjXxiiiXRPQ4+06KusolP7ZpqW7/w+7du9G3b19ERETAZDJh48aNbs/JyspC586d4ePjg+bNm2PlypWS2ykm5PFxgivRI3SYy1WAsdpwFnBqFj9qbED0IHgcweaNVmzUFBvBpa6pxWYlkOuZtPb4aBE11W0lKSsrQ4cOHTBq1Cg8/vjjbtPn5eXh4Ycfxrhx47B69WpkZmZizJgxCA8PR0pKigwWC4eEj0w4Ejtsv5daFEm9P5ic6FX0mFFiCEzuDkKMjttoa7oILTNnz82Oy7EuvT6u8lNimJbrNUn8AA8++CAefPBB1unT09MRExODd955BwDQqlUr7NmzB++++y4JH73iyNvjbpjLnehxh/X5YoogMQSPHqe8awG5OxapYiPkqDt6FUFKPHdcvDxy11G+19Kj+CkpKbH538fHBz4+PqLknZ2djeTkZJtjKSkpmDJliij5ywEJH41hFkFCBZAz0cNnKrtaxI/evT32KDX0BbAXEGqoF9boRQTJWa5ChrTE8FAeLwyV/NlWi/g5WRQCT39f3udXld8EAERFRdkcT0tLw6xZs4SYZqGwsBChoba/Z2hoKEpKSnDjxg34+al/BIGEjwhcj/Fz6fW53SxSsNfHHq9TBaqNC1ICo4keM0oNKdgLCLUJHDboRQRpAaH11HwunzV8jMjZs2cRFBRk+V8sb49eIOHjBGcLrbHZnd0RahI/eorpAYwreswoJX7MaFH02KMlESR2ecu5Do8ZvvVVynquFq+PGAQFBdkIHzEJCwtDUZFtnSkqKkJQUJAmvD0ACR/RcOf1AdQlfhzhaJhL7WutGF30mFFa/MiJq99cjDJQ81ovehCZALfnVs+B/FokPj4eW7ZssTm2bds2xMfHK2QRd2gdHx0gtpjSCiR6bDFCebi7RzHXkVGbyFCbPXrFaOVcWlqKnJwc5OTkALgzXT0nJwf5+fkAgOnTp2PYsGGW9OPGjcPp06fx0ksv4cSJE/jwww/x5Zdf4vnnn1fCfF4YVvh4hrmv3M68Hc4CgNkMIWktLoftIo5yvyUZoZPng57LRYqF7Nyhlk5QKjv0XF8Idhw4cACdOnVCp06dAACpqano1KkTZs6cCQC4cOGCRQQBQExMDDZv3oxt27ahQ4cOeOedd/Dxxx9rZio7YPChLnJrahNqrI0Hn99crOE/pdsJtYgvI6H0by4niYmJYBjG6feOVmVOTEzE4cOHJbRKWgzr8THjrlFRe4yLGTGGu4SuSC1HQ0Gixz16KyMh96Nlzw+X7SYI8aGy1y+GFz58ETLcpTRa3VdMbx26lFBZiY9ciy2S4LFFybpMv4M+IeEDfVRuKWOH1LBDPXXkxkWM9V/EQqy2wlrgkNghCHkxdIwPoX5I8BAAv9V7pZoGzTf+g4SNNmEzEYbQFsq/ymsArcT5iIGzOB8lZneR6BGG3spPTesUcRUxJHoIQj2Qx0dmjLrmDlf01mkT4uBs6wJHaQj9IMaeXwRhhoTP/8PHfc11+wqpRI+Y8T18NikVGxI9hDuU7gCNMtVZbZAAMh4//vgjli1bhlOnTmHdunWIjIzEZ599hpiYGPTs2ZNXnsr3cjrD2Ywp8vSwg0SPuFB5Ko+ah7m0KiDEXKGbUC9ff/01UlJS4Ofnh8OHD+PWrVsAgOLiYsybN493viR8rHDVQAmJ85HS06O1laAJQuuQt0c9kPjRN6+//jrS09OxfPly1KpVy3K8R48eOHToEO98OQufc+fOobS0tMbxyspK7N69m7chekGOdXzEEDxc1/KRK8Bbq2+gakUv5Xn7vL8qBAcfG9RgtzP0IBzI+6NfTp48iV69etU4HhwcjGvXrvHOl7XwuXDhArp164YmTZqgTp06GDZsmI0AunLlCpKSkngboha4en3kjIlRysMj96w2vXTWhDhYCwelBJDQ66pZ/OgFEj/6IywsDLm5uTWO79mzB02bNuWdL+tee9q0afDw8MC+ffuQkZGBY8eOISkpCVevXrWkcbXfh5ZQ25i8EYe0SPwQgHPBIJeQEFNoqcVrRRBaYezYsZg8eTL27dsHk8mE8+fPY/Xq1XjhhRcwfvx43vmyntW1fft2bNiwAV27dgUA/PTTTxgwYAB69+6NzMxMAIDJZOJtiNpwNsurvFE155WMbzeL5B3nYzTBYw2bqcuEvlFqs0gpr3n7vL/qXq70glgb0xLqYNq0aaiursZ9992H8vJy9OrVCz4+PnjhhRcwadIk3vmy7sGLi4tRt25dy/8+Pj5Yv349oqOjkZSUhIsXL/I2Qq04W0befujHfrjLUZwPHwHDV/SwFVmBeTdqxPo4mp6v9JYV1JDxQy/lJuf2DnJ5ZdTg/aEXCkLtmEwmvPrqq7hy5QqOHDmCn3/+GZcuXcLcuXMF5cu6R2vatCl+++03m2NeXl746quv0LRpU/zrX//iZcCSJUsQHR0NX19fxMXFYf/+/S7TX7t2DRMmTEB4eDh8fHzQokULbNmyhde12SJWI8tlyEqo6PE6VcBJAKkdvXTickHlxR6zCNFi7BBBGAFvb2+0bt0a3bp1Q0BAgOD8WA91Pfjgg/joo4/Qv39/2wz+X/z0798f586d43TxtWvXIjU1Fenp6YiLi8PixYuRkpKCkydPomHDhjXSV1RU4P7770fDhg0tCxn99ddfqFOnDqfr8oGry/16jJ9TQWEtahyJEzGHt8z5u8szMO+GxVMVUFBdw4vlf85D8a07+OzXZDRI8LCDxAZBqJ+kpCSXITQ7duzglS9r4fPGG2+gvNyx58PLywtff/01Cgq4xbEsWrQIY8eOxciRIwEA6enp2Lx5M1asWIFp06bVSL9ixQpcuXIFe/futczpj46O5nRNtSFXDA8bAUTiR9sIET3uhIBeYlLUKngo7ocgatKxY0eb/ysrK5GTk4MjR45g+PDhvPNlLXy8vLwQFBTk8vsmTZqwvnBFRQUOHjyI6dOnW455eHggOTkZ2dnZDs/59ttvER8fjwkTJuCbb75BSEgInnrqKbz88svw9PR0eM6tW7csqz0CQElJCWsbrVFrg8kVth4g3vlT4y07Ugoe63Ra/m218PzKWcb08kBogXfffdfh8VmzZjlcT5AtikWtXr58GVVVVQgNtW20Q0NDUVhY6PCc06dPY926daiqqsKWLVvw2muv4Z133sHrr7/u9Drz589HcHCw5RMVFSXqfWgVZ/E/1sNzXPYhkxMazrnD8cJQ3mXBJ7ZEi/EoWrNZS7YShFI8/fTTWLFiBe/zNbVlRXV1NRo2bIiPPvoIXbp0wcCBA/Hqq68iPT3d6TnTp09HcXGx5XP27FkZLZYfI09/NwpyCx5HeWgBrdhpj1btJgi5yM7Ohq+vL+/zFdudvUGDBvD09ERRka3LtaioCGFhYQ7PCQ8PR61atWyGtVq1aoXCwkJUVFTA29u7xjk+Pj7w8fERZKt9Q2Q/vVutnhFnOBNH9tPw7WN8lI7vscaosT5yDGuxzUvNQ18kHoyJFN7gqkKqS0rx+OOP2/zPMAwuXLiAAwcO4LXXXuOdr2IeH29vb3Tp0sWy+CFwx6OTmZmJ+Ph4h+f06NEDubm5qK7+pwP+448/EB4e7lD0CMXR27HSa9qwwZXXh6/oYYOaO0KtI8TLA0gjBNQqLtRqFxekvAcjvjAQ2sQ6TCU4OBj16tVDYmIitmzZgrS0NN758vL4XLt2Dfv378fFixdtRAgADBs2jHU+qampGD58OLp27Ypu3bph8eLFKCsrs8zyGjZsGCIjIzF//nwAwPjx4/HBBx9g8uTJmDRpEv7880/MmzcPzz33HJ/bqIG7xsaR6NGSt0eI6FGTt8eMUbw+Qt9iaRViguDHnWfnptJmGJZPPvlEknw5C5/vvvsOQ4YMQWlpKYKCgmzm2JtMJk7CZ+DAgbh06RJmzpyJwsJCdOzYERkZGZaA5/z8fHh4/NMJR0VF4fvvv8fzzz+P9u3bIzIyEpMnT8bLL7/M9TZQVegPhsMYoRY8PdaYRY67WVxaFT1GQc2ix/oaJH4IgtAKnIXP1KlTMWrUKMybNw/+/sIb1YkTJ2LixIkOv8vKyqpxLD4+Hj///LPg63LBmehx5e1Ry2rIroa9SPSoFzFiFfQw5EMQSkHPjzLUrVuX9b6fV65c4XUNzsKnoKAAzz33nCiiRwtoWfS4wtF+YkKgN37x0IKXR80otbEpoR+o/ijH4sWLJb8GZ+GTkpKCAwcOoGnTplLYoyqMJHq06O3RW3yPlr08ahvu0rr4kaos9fbMEPpDyIrMbGElfL799lvL3w8//DBefPFFHDt2DO3atbNsHWHmkUceEddChVC76LEXL2yvzVb0EPKhhOBxVr/VLna5oHXxQygD1Rl1cvPmTVRUVNgcc7WbhCtYCZ9+/frVODZnzpwax0wmE6qqqngZomXkEjyuhqfM37myRezhLTNKvenrYVaXnKKHTYC+OQ1XAaQmb481ahQ/5rKyt0vqMtT6s+IOWtFdf5SVleHll1/Gl19+ib///rvG93z1BivhYz9lnfgHOUQPF8HiaFd4V+eTt0d+xGyg2XTqfGYkqmFDWrGQSvxYl6ursnImaNQqFo2M2kSy0XnppZewc+dOLF26FEOHDsWSJUtQUFCAZcuW4c033+SdL+cW8dNPP7XZ9NNMRUUFPv30U96GqAm2w1xqEz3W51h/nOFK9LDt9JRuvLX0lid0EUJr2G49IWQZBrbnKl0H2CCmjf7nPGqUjdqXu9C7t4cQxpIlSxAdHQ1fX1/ExcVh//79TtOuXLkSJpPJ5iNk+whXfPfdd/jwww/Rv39/eHl54d5778WMGTMwb948rF69mne+nJ/WkSNHori4uMbx69evWxYe1CqOGjRnSC163IkWoYjh6VFLhyemoBAbs21ye3kA151xQEG15cM3D8IWtZaV2kVP7wYnanyUwKjenrVr1yI1NRVpaWk4dOgQOnTogJSUFFy8eNHpOUFBQbhw4YLl89dff0li25UrVywTqYKCgizT13v27Indu3fzzpfzrC6GYRzOsT937hyCg4N5G6IUbBsr6w5CKtEjpdDhAhtvj1pEjzViiQsxOgqlhRiX4PyAgmreQliN9cAZYg15lTeqdli+ahwa1ILocXZ8x+VY1vnQEhD8WbRoEcaOHWtxXKSnp2Pz5s1YsWIFpk2b5vAck8nkdE9NMWnatCny8vLQuHFjxMbG4ssvv0S3bt3w3XffoU6dOrzzZS18OnXqZHFr3XffffDy+ufUqqoq5OXloU+fPrwNkRu/Ag94+nAXPWKjhNgROsSlpc6OD44aUbYdiNSCh+/wlrs6bP6eYr70g5pFDxuvDlfxQ/xDSUmJzf/ONuuuqKjAwYMHMX36dMsxDw8PJCcnIzs722n+paWlaNKkCaqrq9G5c2fMmzcPbdq0Ee8G/p+RI0fi119/RUJCAqZNm4a+ffvigw8+QGVlJRYtWsQ7X9bCxzyzKycnBykpKQgICLB85+3tjejoaPTv35+3IWqFTVyPu20h7BEidtx1TK46OHfnqvGNVS0o7cEB+L+VuqvD1vVRiPdHC4jp9QH4z4KTGjWLHrHRk7eH61ZK9lTfvFMfo6KibI6npaVh1qxZNdJfvnwZVVVVlm2izISGhuLECcfitGXLllixYgXat2+P4uJiLFy4EN27d8fRo0fRqFEj3rZb88ILL2DMmDF4/vnnLceSk5Nx4sQJHDx4EM2bN0f79u15589a+Jh3Qo2OjsbAgQMlC2ZSE2w9PWwFD8Bf9LDtjPh2WloJZia4UxrpYVOX1TKkqhTOppPzQW2CB9CG6NlxOdat14e8Pfw5e/aszRo3jrw9fImPj0d8fLzl/+7du6NVq1ZYtmwZ5s6dK8o1vvnmG7z77ruIi4vDmDFjMHDgQNSuXRtNmjRBkyZNBOfPuZccPnw4iR6e8OlwSiM9nIqZ8kbVTj9cUGPjTdgitJMWIpxdxcGxnV2mRrwiyi0fKZGzfLQgeszsuBxrI27M/9sfd4WevD1iEhQUZPNxJnwaNGgAT09PFBXZ1puioiLWMTy1atVCp06dkJubK9huM3/++Sd27tyJFi1aYPLkyQgLC8OoUaOwd+9eUfLnLHzq1q2LevXq1fjUr18fkZGRSEhIkGwreblQk+ixh624cSWI+Iok8vZoGymHsLQsgABILoDkKB8tiR5ruAgda9Qw/Kx1vL290aVLF2RmZlqOVVdXIzMz08ar44qqqir8/vvvCA8PF9W2Xr16YeXKlSgsLMR//vMf/Pnnn+jZsydatWqFhQsX1hBrXOA8q2vmzJl444038OCDD6Jbt24AgP379yMjIwMTJkxAXl4exo8fj9u3b2Ps2LG8DVMKsUWPWIIHcOyZcdZYO2tkybujPbh2mM5mHQH/1C37ei6WKDLbqlWRbG23FEJF6+WjFrS8r53aSE1NxfDhw9G1a1d069YNixcvRllZmWWW17BhwxAZGYn58+cDuLNrwz333IPmzZvj2rVrePvtt/HXX39hzJgxkthXu3ZtjBo1CqNGjUJubi4++eQTzJ8/H6+++qrDNQXZwFn47NmzB6+//jrGjRtnc3zZsmX44Ycf8PXXX6N9+/Z47733NCd82IgeRysjO0vHFa6zrVw1nmLGMRDawz741h6pA5j10MFr6RnSqreHK+TlEZ+BAwfi0qVLmDlzJgoLC9GxY0dkZGRYAp7z8/Ph4fFPe3H16lWMHTsWhYWFqFu3Lrp06YK9e/eidevWktpZVlaGH3/8Ebt27cLVq1fRsmVL3nmZGIZhuJwQEBCAnJwcNG/e3OZ4bm4uOnbsiNLSUpw6dQrt27dHWVkZb8OkoqSkBMHBwYh9bh48ff6JVeLr6eGyPYQruIge+87EUaNn30AIbby13IFpGbE7Xb6L7AnxFOql7oj5W4hdJkYQPkosAgoA1Tdv4q+XZ6C4uJj3ppjuMPdLTd56HR6CZnVJb6vc7NmzBytWrMC6devAMAwGDBiA0aNHo0ePHrzz5OzxqVevHr777jubaWbAnaWl69WrB+COMgsMDORtlJYQOkOG6xRzNqLHfNy6odDS2yshHfb1iY0QEjo8evu8vy7EDz1D8kMeHmNy4cIFrFq1CitXrsQff/yBe+65B4sWLcKgQYNsltLhC2fh89prr2H8+PHYuXOnJcbnl19+wZYtW5Ceng4A2LZtGxISEgQbJwdSLk7oDj2vl0JoA1fxQGKih6EvM2oTQFry9pCQIdgQFRWF+vXrY+jQoRg9ejRatWolav6chc/YsWPRunVrfPDBB1i/fj2AOwsa7dq1C927dwcATJ06VVQj9QZbwePoTdv+7fl4YSiroS7zuXzRy1u7lpCrY5VzCwY91SO+Akgv988WEjsEV7788ks88sgjNjtEiAmvXHv06CFofE0tKOHtkcLLw6ZhUcvbKaFOrEWO/zkPSWf/6Un8AOKtBq0nSOwQQnj88cclzZ+X8KmurkZubi4uXryI6mrbBrJXr16iGCY1tS9UA7XkvSYX0eOq49Fbx0HURMmOVI4lD/RWh9lOg9fTPTtDC6KHxKqx4Sx8fv75Zzz11FP466+/YD8hzGQyoaqqSjTj9IIUXh62HYeYD7feOiu1YpQGWa/1yVGnqsf7dIQWRA9BcBY+48aNQ9euXbF582aEh4fDZDJJYZdukHq1XK4LGBLqxmi/m57Fj9HQmughr49x4Sx8/vzzT6xbt67GOj6ELUIED5ehBrkfXL12VGqAGmGCkBcSP8aEs/CJi4tDbm4uCR8HGGV6Ookf8TFy40v1SftozdtjDYkf9VJWVoY333wTmZmZDmOKT58+zStfzsJn0qRJmDp1KgoLC9GuXTvUqmUbIdy+fXtehmgRowgdQlqo0SWMhLP6rqT4JfGjTsaMGYNdu3Zh6NChoobWcBY+/fv3BwCMGjXKcsxkMoFhGN0HN5PQ+Qd6SxcHamzvQPVJ37Cp59ZplKgLaluYkgC2bt2KzZs3i758Dmfhk5eXJ6oBWkDNgofPbtJiLVZHnZUwqIG1heoTP5wtYirn9V3Bp54rWRfI+6Me6tata9kKS0w4C58mTZqIboSaUbPoscfdA+tqawKpF60jbKGGlTACzuo5m/ZGafFjtoFQjrlz52LmzJlYtWoV/P1F3CSYz0mfffYZ0tPTkZeXh+zsbDRp0gSLFy9GTEwMHn30UdGMI1zjqFFw9sCy2Y/JnIbrrDJ6SyfEQoqOhuqntNhviMwWLbxseUWUo6r8ptJmGJZ33nkHp06dQmhoKKKjo2vEFB86dIhXvpyFz9KlSzFz5kxMmTIFb7zxhiWmp06dOli8eDEJHxXCdRNKLTRIWobeIuXFCOJc6eEugpCCfv36SZIvZ+Hz/vvvY/ny5ejXrx/efPNNy/GuXbvihRdeENU4KQk8cwM37vJ1mUbNw1xSN+R8vD+Ee0j0KINWxI9RVnymdoVgQ1pamiT58gpu7tSpU43jPj4+KCsrE8UouQjMuwEAuB7jV+M7JUWP0PFv68aTq7dHbFuIfyDRoxxUP5WBb6Aw/V6ENQcPHsTx48cBAG3atHGoQbjAWfjExMQgJyenRpBzRkYGWrVqJcgYJVCb6DHDxuPiKnDQDJsd6N3dL4kf4ZDokRet1kVrocD1HsQa7urd4ESNYzsux7o8x1WcD1fxo9XfjhCfixcvYtCgQcjKykKdOnUAANeuXUNSUhK++OILhISE8MqXs/BJTU3FhAkTcPPmTTAMg/379+Pzzz/H/Pnz8fHHH/MyQim4ih6u7lmh3hZHeTiywT6NvdgJzLvh8F7t07u6dxI//CHRIz16qndK3osj0WM+7k78uILNsht6+g0JcZg0aRKuX7+Oo0ePWhwrx44dw/Dhw/Hcc8/h888/55UvZ+EzZswY+Pn5YcaMGSgvL8dTTz2FiIgI/Oc//8GgQYN4GaEE16P9aty8fccvdBza+nwxRJC7fMwCxjyEZ439MUdCKKCgWhTxY4+RGzQSPewQElDPt345845oefsFLWDk9oDgRkZGBrZv324zmtS6dWssWbIEDzzwAO98eU1nHzJkCIYMGYLy8nKUlpaiYcOGvA1QGrHFjjPKG1WLJn7ssfbwmAWO16mCGuluN4u0ScdX/ADibqRKDSHBFz51x91wEN/p2Xpgx+VYp14fdxi53AhpqK6urjGFHQBq1apVY98uLvASPmb8/f1FXVRITsrCPeDp808H76gjd9SoCnmDF1v8OBrScoXXqQLW4gcQPvTFFr4xDWqHvD3s4VOXuNYXLvEvWu3ExYjzETKkJQfu7k+LvxvhmN69e2Py5Mn4/PPPERERAQAoKCjA888/j/vuu493vqyET6dOnVhvDsZ3QSElsG9s2TSkfLaIsL+mGOLHlehx5O2x/o6N+DFfQy7xA+hLAJHokRYpRY/1OdSJqge2v6F1Ovr9tM0HH3yARx55BNHR0YiKigIAnD17Fm3btsX//vc/3vmyEj5SLSKkJDciq2HdpfPpbJVa1pzNTC0uCBU/gLhDhBQkTbhCDtFjfS51nsrD9zek30/bREVF4dChQ9i+fTtOnLgzBNuqVSskJycLypeV8JFqESE14KgR5Rr0KOemdmxEj9mj48zzY+/1AYSJH0Aa749WxQ95e6RD7jpBnSY3pBAaQofuSPxoG5PJhPvvvx/333+/aHnyivG5du0a1q1bh1OnTuHFF19EvXr1cOjQIYSGhiIyMtJ9BirAM6wcnv62HbWWgx6vx/jViPFxJoDsRQ8b2IofQDzvj5bFD1/YLErp6BwjiC0pApldodZn3R162r5CrPtQc9tN2PLee+/hmWeega+vL9577z2XaZ977jle1+AsfH777TckJycjODgYZ86cwdixY1GvXj2sX78e+fn5+PTTT3kZojRcxo8dPUBq6HwciR/AVui4iv9xt94PW8QOfNaS+JFqlVp3aey/V7ouio2a6gDFkMiD2OLNnB/9Zurm3XffxZAhQ+Dr64t3333XaTqTySSf8ElNTcWIESOwYMECBAYGWo4/9NBDeOqpp3gZoTRiPWBqED/u4OPtMcPG62NGTO+P1sQPIS5K/PZa7xyV9Pqo3buidvuMTl5ensO/xYTz9KJffvkFzz77bI3jkZGRKCwsFMUowjFs4nuEeGzYnMs1sFqs6ftqF5RCkOLevCLKLR+26dh+5ETo9fh0cO7OOV4YavkQjhEjLkdKWoUV6WY4UM/MmTMH5eU124AbN25gzpw5vPPl3Cv5+PigpKSkxvE//viD974ZSiFF5WfTUEu9M7EYw1WuIPHjGLXaJ7aIkUMEKSGySMyIixaEhRZsNDKzZ89GaWlpjePl5eWYPXs273w590iPPPII5syZg8rKSgB3xtny8/Px8ssvo3///rwNkZuWoZeUNkFSrsf4cRJAXMWSUuJHr3ARTbfP+9t8lERMgSKVoGIjaIQIHuo8ncP15VIJTwz9fsCSJUsQHR0NX19fxMXFYf/+/S7Tf/XVV4iNjYWvry/atWuHLVu2SGIXwzAO1xD89ddfUa9ePd75cu6N3nnnHcs2FTdu3EBCQgKaN2+OwMBAvPHGG7wNIaTBnaDhKpCsUUL8KN3RO0MMu5wJGXdCRw1lIkS0yOXdsRdAYg1ZkZfIPWZB40hkuPpOLpS+vpKsXbsWqampSEtLw6FDh9ChQwekpKTg4sWLDtPv3bsXgwcPxujRo3H48GH069cP/fr1w5EjR0SzqW7duqhXrx5MJhNatGiBevXqWT7BwcG4//778eSTT/LO38QwDMPnxD179uC3335DaWkpOnfuLHhBIbkoKSlBcHAwHswYi1q1vXnlwaahY9MZ8RECYi9eKAZsA57NiDHUp7ZgZ7WID4IAyIshBPv2var8Jk4Pn4fi4mIEBQVJck1zv9Tkrdfh4evLO5/qmzfx18szONkaFxeHu+++Gx988MGdPKqrERUVhUmTJmHatGk10g8cOBBlZWXYtGmT5dg999yDjh07Ij09nbft1qxatQoMw2DUqFFYvHgxgoODLd95e3sjOjoa8fHxvPPnPKvr7NmziIqKQs+ePdGzZ0/eFyaMixjT3bU808ud4JU6BowgCOfoYdaXfRyuj48PfHx8aqSrqKjAwYMHMX36dMsxDw8PJCcnIzs722He2dnZSE1NtTmWkpKCjRs3Cjf8/xk+fDgAICYmBj169ICXl6BtRWvA2eUQHR2NhIQELF++HFevXhXVGKOhlw5OKS+UGrwsAHs7/M95sPLysU1njVZFIEEQ/+BX4GF5/vl8/ArutBtRUVEIDg62fObPn+/wepcvX0ZVVRVCQ22FXmhoqNNZ2oWFhZzSC6GsrAyZmZk1jn///ffYunUr73w5C58DBw6gW7dumDNnDsLDw9GvXz+sW7cOt27d4m2E2ujd4ITSJmgOI8/0EiI6AgqqLR972JYRiR72WMeTGDmug9A3Z8+eRXFxseVj7dHREtOmTUNVVVWN4wzDOByGYwvn3qdTp054++23kZ+fj61btyIkJATPPPMMQkNDMWrUKN6GqIHeDU5YRI9axQ/XeBo5MbL4IdSNK5FDAoiwR+v1ISgoyObjaJgLABo0aABPT08UFdneb1FREcLCwhyeExYWxim9EP7880+0bt26xvHY2Fjk5ubyzpd3z2MymZCUlITly5dj+/btiImJwapVq3gboiTWgocNWn8o9IgexA+fIUPy9riHy3Y0ekHrMSqEPHh7e6NLly42w0nV1dXIzMx0GjwcHx9fY/hp27ZtgoKNnREcHIzTp0/XOJ6bm4vatWvzzpe38Dl37hwWLFiAjh07olu3bggICMCSJUt4G0KwR6jXpzTSo8ZHLJScdaak+OG7cKWr38FdDBiJHtfw8eToSfwQBBtSU1OxfPlyrFq1CsePH8f48eNRVlaGkSNHAgCGDRtmM1Q2efJkZGRk4J133sGJEycwa9YsHDhwABMnThTdtkcffRRTpkzBqVOnLMdyc3MxdepUPPLII7zz5RwqvWzZMqxZswY//fQTYmNjMWTIEHzzzTdo0qQJbyMI7pRGenAWGa4EDp/8nMF1Ty8xg7yVnO3FZq8263t1NNTHpixI8LiGxMsd9LRLOyEdAwcOxKVLlzBz5kwUFhaiY8eOyMjIsAQw5+fnw8Pjn7aqe/fuWLNmDWbMmIFXXnkFd911FzZu3Ii2bduKbtuCBQvQp08fxMbGolGjRgDuOF3uvfdeLFy4kHe+nNfxiYqKwuDBgzFkyBB06NCB94WVwtk6Po6GunZcjnWZlyt3MpeZPkJwJ1a4enMc5We/4zubBQ+5XFeK2W1KigOp9t4iXCNmJ6+XoSISPvwx1wE51/GJfW4ePH34r+NTdesmTrz3iqS2yg3DMNi2bRt+/fVX+Pn5oX379ujVq5egPDl7fPLz8x0uIU0ogzNPjVjDV/aix3zMnfjh4vWRAqU9P2Yb2KQjhCFF566HtVwA8voQ2sdkMuGBBx7AAw88IFqenIWPWfSUl5cjPz8fFRUVNt+3b99eHMtkZsflWFFncrEZ9hALJQQGG/HDFrGHu9QCCRvpoM6ckBq9iF+tk5mZiczMTFy8eBHV1bb9xIoVK3jlyVn4XLp0CSNGjEBGRobD7x3NudcK7oa2jMj1GD+HXh+pd4AnCHtI7BBy0yqsCEdOB7tPSEjC7NmzMWfOHHTt2hXh4eGijTZxFj5TpkxBcXEx9u3bh8TERGzYsAFFRUV4/fXX8c4774hiFKEPlAxy1gquOnN627wDCR5h0HAXoVXS09OxcuVKDB06VNR8OY+R7NixA4sWLULXrl3h4eGBJk2a4Omnn8aCBQucLoutV9w1JnynOKsNe++OVN4esRY01Aru6o/ROyulFxY0evkTd2gZeklpEwxLRUUFunfvLnq+nHuasrIyNGzYEMCdreMvXbpTKdq1a4dDhw6Jax2hGq7H+Fk+BCE1JDoItXCyKERpEwzLmDFjsGbNGtHz5Sx8WrZsiZMnTwIAOnTogGXLlqGgoADp6ekIDw/nZcSSJUsQHR0NX19fxMXFYf/+/azO++KLL2AymdCvXz9e1yXUh5G8Pu6Gsow61EWih1ALRn0G1cLNmzexaNEiJCQkYNKkSUhNTbX58IVzjM/kyZNx4cIFAEBaWhr69OmD1atXw9vbGytXruRswNq1a5Gamor09HTExcVh8eLFSElJwcmTJy2eJUecOXMGL7zwAu69917O1yTkQ6lp7VqZUWUff2H0hpZEjzRQnI9zjP7MqZnffvsNHTt2BAAcOXLE5jshgc6shU9eXh5iYmLw9NNPW4516dIFf/31F06cOIHGjRujQYMGnA1YtGgRxo4da1keOz09HZs3b8aKFSuc7r5aVVWFIUOGYPbs2fjxxx9x7do1zteVC7ar+RrJ0+EOowU6U8N7B+qYCbmgZ04b7Ny5U5J8Wfe2zZo1Q0xMDEaNGoX//e9/OHfuHADA398fnTt35iV6KioqcPDgQSQnJ/9jkIcHkpOTkZ2d7fS8OXPmoGHDhhg9erTba9y6dQslJSU2H4IgCIIgjAlrj8+OHTuQlZWFrKwsfP7556ioqEDTpk3Ru3dvJCUlISkpybK3B1suX76MqqqqGueFhobixAnHiwnu2bMH//3vf5GTk8PqGvPnz8fs2bM52UVoG60McxEEQRDOSUpKcjmktWPHDl75shY+iYmJSExMBHAn4Gjv3r0WIbRq1SpUVlYiNjYWR48e5WUIG65fv46hQ4di+fLlrD1M06dPtwmCKikpQVRUlFQmEiJhtOEugiAIwhZzfI+ZyspK5OTk4MiRIxg+fDjvfDkHNwOAr68vevfujZ49eyIpKQlbt27FsmXLnHppnNGgQQN4enqiqMh2bL+oqAhhYWE10p86dQpnzpxB3759LcfMS1h7eXnh5MmTaNasmc05Pj4+8PHx4WSXURFrd3aC4ArF9xAEYc+7777r8PisWbNQWlrKO19OEbUVFRXYvXs3Zs+ejaSkJNSpUwfjxo3D1atX8cEHHyAvL4/Txb29vdGlSxdkZmZajlVXVyMzMxPx8fE10sfGxuL3339HTk6O5fPII48gKSkJOTk5mvbkqMG7IdXsKzkFFQ1zEQThDhLa2ubpp5/mvU8XwMHj07t3b+zbtw8xMTFISEjAs88+izVr1vBeu8dMamoqhg8fjq5du6Jbt25YvHgxysrKLLO8hg0bhsjISMyfPx++vr5o27atzfl16tQBgBrHCYIgCMIZtAmpdsnOzoavry/v81kLnx9//BHh4eHo3bs3EhMTkZCQgPr16/O+sJmBAwfi0qVLmDlzJgoLC9GxY0dkZGRYAp7z8/Ph4WGMqd40rZ0gCEI+SPyom8cff9zmf4ZhcOHCBRw4cACvvfYa73xZC59r167hxx9/RFZWFt566y0MHjwYLVq0QEJCgkUIhYTwW9p74sSJmDhxosPvsrKyXJ7LZ9FEQhtQgLMxUPOwA3WMBKEcwcHBNv97eHigZcuWmDNnDh544AHe+bIWPrVr10afPn3Qp08fAHdmWO3Zswc7d+7EggULMGTIENx11101VlckuEFeH4IgCMLInD59GjExMfjkk08kyZ93D1u7dm3Uq1cP9erVQ926deHl5YXjx4+LaZvqkepNUEkvhx4CnAlCTNTskSIIPXLXXXdZNkAH7oTE2M/+FgLrXq66uhr79+/HggUL8OCDD6JOnTro3r07PvzwQ4SFhWHJkiU4ffq0aIYZHRriIQiCIIwIwzA2/2/ZsgVlZWWi5c96qKtOnTooKytDWFgYkpKS8O677yIxMbHGujlGgcb9CYLQCuS1Ioh/YC183n77bSQlJaFFixZS2qMJuIgedxuUukJv8T5y7NR++7w/reWjIahDJgjCHpPJVGOrCiG7sdvDWvg8++yzol1Uq5CXR35oZhehBrQ8u4vEJaE1GIbBiBEjLLsu3Lx5E+PGjUPt2rVt0q1fv55X/ry2rDAiSjV6evP6yIHavD5a7jQJgiDkxn4frqefflrU/En4uEFIhyVkmEuvyDHcBahL/JDoIQiCYI9U09jNkCvBBWrpsPQ21MN1ajt5vAiCIAixoB7FAccLQwWLHq16e/S03o5WfwOCEAuK73EPlZHxIOFjhRiCRyqM7vXhC4kfgiAIwhrDxvicLAqBpz//3V1dQZ0tO7jE+wiZ3aWmeB9Cu1CQOkHoA/L4aAi9eX0IgiAIQm5I+IgMeXu4QUNeBEEQ2uDKlSsYMmQIgoKCUKdOHYwePRqlpaUuz0lMTLQsSGj+jBs3TiaLHUPCR2Po0evDVvwInd1F4ocgCII/Q4YMwdGjR7Ft2zZs2rQJu3fvxjPPPOP2vLFjx+LChQuWz4IFC2Sw1jmGjfGRAupY1Q/F+xAEQXDn+PHjyMjIwC+//IKuXbsCAN5//3089NBDWLhwISIiIpye6+/vj7CwMLlMdQt5fAhVIOc0ehKoBEEQ3MjOzkadOnUsogcAkpOT4eHhgX379rk8d/Xq1WjQoAHatm2L6dOno7xc2ZdP8vgQmkKsvbvM4oe8PwRB6G3GXklJic3/Pj4+ln2v+FJYWIiGDRvaHPPy8kK9evVQWFjo9LynnnoKTZo0QUREBH777Te8/PLLOHnyJO99tsSAhA9haEgAEXrmeGEoLdCnIWpfqIZXLf4vdrcr75wbFRVlczwtLQ2zZs1yeM60adPw1ltvucz3+PHjvG2yjgFq164dwsPDcd999+HUqVNo1qwZ73yFQMKHIMB++IsEEkEQaufs2bMICgqy/O/K2zN16lSMGDHCZX5NmzZFWFgYLl68aHP89u3buHLlCqf4nbi4OABAbm4uCR+CYItYw118oOBoQmuQ18d4BAUF2QgfV4SEhCAkJMRtuvj4eFy7dg0HDx5Ely5dAAA7duxAdXW1RcywIScnBwAQHh7O+hyxoeBmwoKe9ukiCCkgAaFf6Ld1TatWrdCnTx+MHTsW+/fvx08//YSJEydi0KBBlhldBQUFiI2Nxf79+wEAp06dwty5c3Hw4EGcOXMG3377LYYNG4ZevXqhffv2it0LCR8Nose1fAiCIJSGxI9rVq9ejdjYWNx333146KGH0LNnT3z00UeW7ysrK3Hy5EnLrC1vb29s374dDzzwAGJjYzF16lT0798f3333nVK3AICGuggVIdfeXUKh4S5x0Gono7cZQIQt9Ps6p169elizZo3T76Ojo8EwjOX/qKgo7Nq1Sw7TOEEeH4IgCIKwQquinGAHCR+CIAgdQ504P6jc9AsJH4LgAa3+TGgB6rwJoiYkfAjOBObdsPkohdBNS4VC4ocg9A0JR31CwodgjTOho6T4URoSP4RaoU5bHFqGXlLaBEJkSPiIhB46QFczqtyJGzHED9sZXWpDD7+93FCnTBCEUmizpzE4Sg/xOIM8PwRBEITaoXV8CFZcj/GTVNho1dtjjZjr+7gSUrSGEEEQBH+039uoBL10RkIFiJG9PmJw+7y/W+8RmzQEQYjDySL3+1gR2oKEj8aQY5hLbu+LHrw9ZoQIEq7nkvghXEGrDxOEY/TT46gAvXh9AMdi5HqMnwKWGAMjiRgKbJYPEj8EURMSPhpC7qBmvuKHy3CXnrw9fJHTS0QQBHtIOOoT6nU0glIzufiIH7aeIaGiR4271HP1+pFwIaSGOm+CsIVmdYmMV0S5qjszV2LBmbgqjfRAQIHtec5meck1HCam6HEnKtleS09DnQRBEHqFhI8GEMvb464DN3/v6HrOxA9wZ2iLq+AR4u0RInr4lKX/OQ+X1+QreNQskAnnkAeFILQNDXUZBC5iwVlaZ2JFzaLH/5yHzUdsSPQYCxI9xoIC8fUJeXxUjtpWaXbk+eF6Pl+4iB5X5ebKfmf2ufP6sIUED0EQhLKQ8DEIYnXcAD/xo4ZAZjY2m9OwtdcsZFx5fkjs6AOtenvIa0EQthha+Ng3CFpt2NgitvgB2IkJNUxZt7fTPjCbzXCdq/IjcaNf9N4uEITRMKzwaRl6CYC3zTFrIUSNHTvkEDVCxZq16HG2xpB9gHZAQbUqBJseOV4YqhkvBLUDBKE/qGV3QquwIstHT7CJGVJbXJFYiLGPmBrLhrxN0kCihyD0ifpacRWiR/HjaJaTVDOf5Mb6HtjGItF2HPKidlGhdvsIeaB6oE+038vJhN7Ejxkpp3qLBRfbnIkeV94erqJHjWWlRa+PWjsVtdpFyAvVA/2ivhZc42ixA9ILcnp6SPyIg9o6F7XZIwZ6vCeCEIJhg5u1gBo7V6VwNaOKTzm5EzwU2Cwf1h2zUp5VEgeENVQf9A0JHw60City+UBo8Y1bS7AVOI68PVw8O1oWPbfP+2t6zzBXz5dUoog6OYIwFiR8VAp5e5SBi+gRc10kMdG6+HGGI4EiRAwZSfBoaQkBpTFSvTAqJHxEgrw92kfLnh6jwnWYjDo1giBI+KgQ8vYIg8uq0tbp9YRevT6uIFHjGvL6uIfqkDEg4aMyjCx6rIeNxCgHVwJIDLGjxmEugiAIwjXG7WVViNpET3mjarcfMfN1lEYMSiM9anyMAA2/EvaQR4MQwhtvvIHu3bvD398fderUYXUOwzCYOXMmwsPD4efnh+TkZPz555/SGuoGY/QAImGURoOL6OAqULiKGTEFkJio0SaCYINR2jGuULm4p6KiAgMGDMD48eNZn7NgwQK89957SE9Px759+1C7dm2kpKTg5s2bElrqGsMKn5NFIZwqutQPhVq8PUK8OFLlLfRcI0NeH8IR1MkTfJg9ezaef/55tGvXjlV6hmGwePFizJgxA48++ijat2+PTz/9FOfPn8fGjRulNdYFho/xsW8AaId2aRBDuJQ3qlaFQNSaCDNioDPhHgp2vgO189KRl5eHwsJCJCcnW44FBwcjLi4O2dnZGDRokCJ2GV742GPkh0Boh+5MmIgpFJQWP1oTPQThCqOLH7229yUlJTb/+/j4wMfHR3Y7CgsLAQChobblHBoaavlOCUj4EADE69DlEAZKiR8tix7y+hDOMKL4UavgCTxzA15eDO/zb9++EzcTFRVlczwtLQ2zZs1yeM60adPw1ltvucz3+PHjiI2N5W2X2iDhIwJixFEo7cnggldEueKxI3KXl5ZFjxkSP+JA5aht1Cp6xOTs2bMICgqy/O/K2zN16lSMGDHCZX5NmzblZUdYWBgAoKioCOHh4ZbjRUVF6NixI688xYCED8EK+4be+n+lRJBc4kcPoofgh7O6bX9c60LICF4fIwgeM0FBQTbCxxUhISEICQmRxI6YmBiEhYUhMzPTInRKSkqwb98+TjPDxEYbLgYVo7TnQwzcdezuGnUlG30pRYlap9ILQQ/1VQ5un/fnVFZ6KFc9CwM935uc5OfnIycnB/n5+aiqqkJOTg5ycnJQWlpqSRMbG4sNGzYAAEwmE6ZMmYLXX38d3377LX7//XcMGzYMERER6Nevn0J3oRLhs2TJEkRHR8PX1xdxcXHYv3+/07TLly/Hvffei7p166Ju3bpITk52mV4raGWYyxl6ET9CF2fUAnropKWEb/lwFUuEPJDoEY+ZM2eiU6dOSEtLQ2lpKTp16oROnTrhwIEDljQnT55EcXGx5f+XXnoJkyZNwjPPPIO7774bpaWlyMjIgK+vrxK3AEAFwmft2rVITU1FWloaDh06hA4dOiAlJQUXL150mD4rKwuDBw/Gzp07kZ2djaioKDzwwAMoKCiQ2XJxOhD/cx6aFz1mvCLKFRNAQtcI0rvYsYc66JqIJVyobNUDiR5xWblyJRiGqfFJTEy0pGEYxiZmyGQyYc6cOSgsLMTNmzexfft2tGjRQn7jrVC8x120aBHGjh2LkSNHonXr1khPT4e/vz9WrFjhMP3q1avx73//Gx07dkRsbCw+/vhjVFdXIzMzU1a7hTZuahE8UnT2SoofritOG0ns2EMd9D+IXRZaLVs9CQU93QshLor2vBUVFTh48KDN4kYeHh5ITk5GdnY2qzzKy8tRWVmJevXqOfz+1q1bKCkpsfkIRQzRo3fUNvQlxh5jekSrHbQWoKEvglAnis7qunz5MqqqqhwubnTixAlWebz88suIiIiwEU/WzJ8/H7NnzxZsq1hoUfTwnb5rPkeJxp/EDXvMv4/aZiZxqTd8bZejbqq1fPUMeXsIV2h6Ovubb76JL774AllZWU4DpaZPn47U1FTL/yUlJTUWd+KCUd/ghKxd4uw8o5alWlF6fRoh9YHr9HIl6h4JIHkg0UO4Q1Hh06BBA3h6eqKoyHb9iKKiIsvCR85YuHAh3nzzTWzfvh3t27d3mk7MpbqNPsQldsOthrWACFvkFD9S/uZSPKtieRGtbSMRJC4kegg2KNoTe3t7o0uXLjaByeZA5fj4eKfnLViwAHPnzkVGRga6du0qh6mGFz3WSBG7QB2AepAyNsWct9qErnmygatJB2zScEWt5UEQekbxoa7U1FQMHz4cXbt2Rbdu3bB48WKUlZVh5MiRAIBhw4YhMjIS8+fPBwC89dZbmDlzJtasWYPo6GjLRmcBAQEICAiQxEY9N0r+5zxUEw+jhq0wiH8Qw8On1t9TDOFizkNMTxC9APCHvD0EWxQXPgMHDsSlS5cwc+ZMFBYWomPHjsjIyLAEPOfn58PD459GaunSpaioqMATTzxhk4+rTdiEoNaGW2mkaqBJ/KgPtvEzav7dpPS4iimAKA6IIKRHceEDABMnTsTEiRMdfpeVlWXz/5kzZ6Q36P9Rc0NOEEqh1ueCr7gJKKgpWEojuecltgBSSvxocd8u8vYQXNBP4InIqLVxlwI9xR8RxkFIzE1AQbXl4+p7vnaJgZJtkNaEhNaEGqEsqvD4qA2xGxy9CQsp30SFlL19OasldokQB7GeIy6CxpyWqwdITbFzfNGi54cg2KCvHlkEjOTpsUYN4oxv2Tt74xd7Bg4hP2L+hkK8OHzO00O905rnhyDYoP0nUySkmlKqpcZPKVv5lj2XDpFEkLYQ87cSInjs8+GK0HtQw4uYVsQPeacIttBQF6RrXPg0eu7c41J33Gxc9GwDL9VUrs7O1/pwhJ4Qu26LIXYc5ckn8FnraGXYq1VYkWaEGqEchhc+avHycNlVXMh12MBW/AA1433UKna45qtmQeSuLNRsuyO0IHjs8+cifvQQ76MF0WOGxA/hDsMKn6pCfzBO9vcSAtdGXEiDWN6oWlHxA7ATOlocXuIjiNjeJ9/fnMuwnpDryIEUdUJqwUNoB2uhxlUEmc8l8aRfDCt81ICaOyZA+JuqFgWPO8Rc8RdgVwf4XlNtAkiq+qCE4DHqkJcW4eutMp9XWVaB02IaRCgOCR+RYeuFUUtn5A6+8TB6FD1SIEc5KSGA5LgvpT08JH4IQpuQ8JEAcwejxfgRV7ARQSR41IscsSZGEDx84Fv2tHUFQYgPCR8J0arAYQMJHG0ilfdHi4InMO+G5e/rMX688jCC10dLgc0EwQYSPhrGWWfjrIPQewNN6BcxRY+14LE+xlf8SAV5ewhCGkj4aBR70cOmYzDC2ynBDq1MsZZa8Nh/rxbxoxbRQ94eQo+Q8NEYfASPs/QkgtzDtXypTMVDLNHjTvDYp+UqfsR+oSDRQxDSQsJHA3Ad0mIL3w0Y9YhYnayrfNRWzmr2+ojxe3ARPPbnSeH5UXN5E4SRIOGjcpQIGlVbBy0ENc0A0pIo0jJ8BY99HmoZ9lICvt6e3g1OWP7ecTlWLHMIQlRI+GiY0kgPyfYjMuevBdQkbviidfEp5irifH9PMQQPX8Qc7mK7F55UcBU91mLH2XESQYSaIOGjcaQSP4D6BJAeBA5bjBqLxec3lkrwKOn1UUr8iCV6HKUj8UOoBRI+KsfdYojAPx2j3gSQkYSOK6QsfzXFnahJ9BgRCmYmjAIJH43AZijBVceoFRGhFTuVQG0eODHh8rvLKXaM6PUhCL2jvxZUxwh5My+N9LB8+CKlKAkoqCbRoxBib7zKBba/e2DeDctHbozgVeLr7aHhK0KLkPDRGGIMS6jFY2Du9EjwcEOK8hIifoSIHncoJXYIgqjJG2+8ge7du8Pf3x916tRhdc6IESNgMplsPn369JHWUDfQUJcGYRP34w4+cUFiCCYSOepFrngftoJHj6gppkoszF4ftoHOhHapqKjAgAEDEB8fj//+97+sz+vTpw8++eQTy/8+Pj5SmMcaEj4SwmY3cyGIMYWY7awwtQ6RaQFHnbhe1ogxyma1SsX6aCnOh4a99M/s2bMBACtXruR0no+PD8LCwiSwiB/GaLVkxv+cR40OQaoOorxRtWBR5Sz+R0hcEA1j3cGZ50KoR0OqcmVbTx3VcYIgCEdkZWWhYcOGaNmyJcaPH4+///5bUXuo5ZIRKTsKsTxKag+C1hJsNsXUImJ4GbWIVn8vwniUlJTYfG7duqWYLX369MGnn36KzMxMvPXWW9i1axcefPBBVFVVKWYTDXXJiNRj+2KunssXEj3yIKV4MNch+/oqZ926HuNHQoMwHF55F+Dl4c0/g+oKAEBUVJTN4bS0NMyaNcvhKdOmTcNbb73lMtvjx48jNpbfUOagQYMsf7dr1w7t27dHs2bNkJWVhfvuu49XnkIh4SMB1h2G3MGMYgQ+E4TUsAmuN8fUkACSnuOFobSAoQOOF4aiqvym0mZw5uzZswgKCrL87yqYeOrUqRgxYoTL/Jo2bSqWaWjatCkaNGiA3NxcEj56RW8zOAj2uPNa6CXAWQhsguvVJICcBTlL6YHTUoCzWBwvDK1xjK8wc5SX3gkKCrIRPq4ICQlBSEiIxBb9w7lz5/D3338jPDxctmvaQ8JHRXBp3G6f93f5vVLDXmw6MmedhB6HyZyJHyGiR+oYGWdiXSpvItuZhWoSQHpEDV4fVyLF/jt3thpR8EhNfn4+rly5gvz8fFRVVSEnJwcA0Lx5cwQEBAAAYmNjMX/+fDz22GMoLS3F7Nmz0b9/f4SFheHUqVN46aWX0Lx5c6SkpCh2HyR8FIbvm5z5PFcCSEnxI/Q8PYkgsTw7agkKVno4VcvxP2r3ACspfrgKFev0rcKKSOjIwMyZM7Fq1SrL/506dQIA7Ny5E4mJiQCAkydPori4GADg6emJ3377DatWrcK1a9cQERGBBx54AHPnzlV0LR8SPgrBVvBYN0KOHmx3AkjpToovUm+8qjXkEj1cOmb7WDYhsPX6mDGa90fO4S5zO6O094cLJHrkYeXKlW7X8GEYxvK3n58fvv/+e4mt4g4JHxnhI3acHbd/0L0iykXz/qhJLHHtEPWIWjw9rhBrNXGuv7VaBFBAQbUmficu2HtU5LoWQUgNCR+ZECp6HKXjI34Ax52Tozd9JaczW2NU74/cHakYwzBKDa/KNfylZEC6kkHOUoogEj2E3JDwkRg1zsbg28EpvU6QEQSQHrwGQuqJEA+ftSiRQgTRLLw78BEqjsSSu2BlEkSEVJDwkQg+gkcLY+pKix+AnTjQkjjSg9ixR+l64kikCBFDYokeoet6aXVquysRw2Zo310eBMEFEj4io8VGiStKd2psUPOUeTUKHTVtoitVXBdfMUSeHnVAM7cIsSDhIyJGED1mtCB+HKFG0UHURK6gdhI1BGE8SPiIhBiih8saGvTmQ+gdLc3o4yKo5R7uUrunxFXgtJrtJrQLCR8RkNPTo6aGQKteH4IwGmoXP2a0YCOhfajXEojYoofLku32uNvGArjztmn+iIHaV6IllEOMOkZDkwRBiA15fAQgladHirceR52Q+ZhQ8aKW9X4I/ggdfpESIyxjwBUuw13kRSEIW6iH4omWApndCRGxhUp5o+oaH0L9iFkPpBC/pZEe5AGygo2HlyCImpDHhwdqFD3OGkG2HZBY3h9nuMqXTyfpzk6tep3YlL+U9yakHshV5vbiR2lPkJJizPzcK9km8RFgamxDrbG+p+qb2mxLCOeQ8NEJ7rarYIsSQx5SrSHDBiUEkphDi1LZb52vM3vVIi4dCQ+5xBBf0SP2c8ZHANm3F1zFiJD2xtG5Sosh8qAZBxI+HFH64eQKzbxyjaPOR0uB33JsKKvF+iOHV0iNw25SixEpxYGrvKVod0noGBcSPjrCmdeHxA83tBiTRL+xa8QWQmKIHjUHlJtRizhQix2EPiDhwwG5vT2uFjN0NlPDlfgBtPn2TrCDxA97XAkXd6JITE+PFsQPQegNEj4ahe+CZGruHB0JS3rT4wYJXOHIPYQl9cQCKeBav7R0b4T+IeHDEjXG9qhZ/IhVXu7y0bMwEhJfQQJIe9j/VmoQC2LVHzbB8gQhFyR8dAibGV5SiR+5BaKcwZdS467s+NwrCSDtIqUQUrI+aNHDRegLEj4aR8gePGKLHzV4xbQmhISUGZclDNQ4xCm041Pb/UiNFtZY4gJ5gQilIOHDAjV06GpHrWWkViEk5lCgVsSP2J2bXhexdIce74tEECEnJHxUjLUnx9EML2eeHrablbr6jkvjo1bR4wghC7zJfX0ueapF0DlCqY5MyjWa9I6jmW1yBX2TCCKkhoSPRhBzo0G5G39r0ebuPlxN4WdzvpiI5S1SkzBU2uujNHKses0GV1PmlVoY0d00fiVsJhFESAEJH50h1pu/WOuL2AsZd8KGbX5K7DjNZrq9UiJHrV4fNXdWSgR+s1k4MaCgWlbxI8aq1tZ5kAgi1A4JHx0hdIiL4I5avDlqFD1aQS4vmNKbqdrjzp7AvBs1jl2P8WOdr5TiTejMMC6/d2kDXpcgVAz1gjrBXcfnf86Dc+MuRmcglWdGqOfIyNDbck2MViZ8RI/5uLPvHF1DarHHp03jeo5fAXWTeoM8PhqG7Vu+EAFDS+oTgDpjUsRGSs8PFwEgdXnyFT2O0rD1ACnp/SEvN2EPCR+NwXVIQw0P/fHCUEk8NELWMNITUg5zsY1JAfQhgJQM/paj/PiIHq9TBQCA280iHaZX2/AXQbiDhA8Lbp/3VySWQ2iHJuZy80K8PlIOS5H44Q6besFniMJR52bUVXq5lp8aRA9wx4NjL34cCR6C0DIkfFSGmLOy3CHHTAyKxZEWKbw9QuMynAkgrYgfvl4ftuWmhGeMy2/qSPyIaYcePIOEtlFFDVyyZAmio6Ph6+uLuLg47N+/32X6r776CrGxsfD19UW7du2wZcsWyW2UetbM7fP+olyDTfCeo6BD8zFnDaSa3chGFVd86gubuiEW9nnxCSzVCmzKrTTSQ/WiRw7UZg/BjjNnzmD06NGIiYmBn58fmjVrhrS0NFRUVLg87+bNm5gwYQLq16+PgIAA9O/fH0VFyrbZirdCa9euRWpqKtLS0nDo0CF06NABKSkpuHjxosP0e/fuxeDBgzF69GgcPnwY/fr1Q79+/XDkyBGZLRcHsQQPwK5T4xKzoSWMKn7EhE38h6uPszyNJIAcoaTg4fssX4/xcxu7wyaNM7TYxhidEydOoLq6GsuWLcPRo0fx7rvvIj09Ha+88orL855//nl89913+Oqrr7Br1y6cP38ejz/+uExWO8bEMAyjpAFxcXG4++678cEHHwAAqqurERUVhUmTJmHatGk10g8cOBBlZWXYtGmT5dg999yDjh07Ij093e31SkpKEBwcjCZvvQ4PX19eNosV7yOmF0nsuA1HDbWzoQpX5SG3IDFSvI/Yge6u6gefoQ/7TpFLnVIavsJMjuFjrnaIgf3vz1fw2KOFYa+qWzdx4r1XUFxcjKCgIEmuYe6XkhuMgpeHN+98bldXYPvlFZLaas3bb7+NpUuX4vTp0w6/Ly4uRkhICNasWYMnnngCwB0B1apVK2RnZ+Oee+6R3EZHKFrrKioqcPDgQSQnJ1uOeXh4IDk5GdnZ2Q7Pyc7OtkkPACkpKU7TS4EYgoUWnJMGo3h+5Kw/fOM97D1BjjpjvXl/zN4dPYke4B/vjhAvD6E/iouLUa9ePaffHzx4EJWVlTZ9dmxsLBo3bixrn22PosHNly9fRlVVFUJDbd/SQ0NDceLECYfnFBYWOkxfWFjoMP2tW7dw69Yty//FxcUAgOqbN4WYjorTdxo2zzD23p+qQuvOStj1zZgX16pyk672hWrc5pCv7xmgLNy28fY5BdyIrNmoVpU7v5fKMtfjv1LQPPAsThaFyH5dOam+yX0RNld1xFX9uH1bWF31+/Mmrkff6Swd1SvAed1Siqpb2hRjXJ9zpdFCOVfdulP/5Rgcuc1UAAIeg9vMnfa2pKTE5riPjw98fHyEmFaD3NxcvP/++1i4cKHTNIWFhfD29kadOnVsjrvqs+VA97O65s+fj9mzZ9c4fjbtdQWsMR6OHaCE4fhFaQMIQhh///03goODJcnb29sbYWFhyCr8n+C8AgICEBUVZXMsLS0Ns2bNcph+2rRpeOutt1zmefz4ccTGxlr+LygoQJ8+fTBgwACMHTtWsM1yo6jwadCgATw9PWtEeBcVFSEsLMzhOWFhYZzST58+HampqZb/r127hiZNmiA/P1+ySqxnSkpKEBUVhbNnz8oyhqwnqOz4Q2UnDCo//hQXF6Nx48Yuh3SE4uvri7y8PLczpNjAMAxMJpPNMVfenqlTp2LEiBEu82zatKnl7/PnzyMpKQndu3fHRx995PK8sLAwVFRU4Nq1azZeH1d9thwoKny8vb3RpUsXZGZmol+/fgDuBDdnZmZi4sSJDs+Jj49HZmYmpkyZYjm2bds2xMfHO0zvzMUXHBxMDYAAgoKCqPx4QmXHHyo7YVD58cfDQ9phOV9fX/jynHAjhJCQEISEsAsNKCgoQFJSErp06YJPPvnEbZl06dIFtWrVQmZmJvr37w8AOHnyJPLz85322XKg+ABramoqli9fjlWrVuH48eMYP348ysrKMHLkSADAsGHDMH36dEv6yZMnIyMjA++88w5OnDiBWbNm4cCBA06FEkEQBEEQwigoKEBiYiIaN26MhQsX4tKlSygsLLSJ1SkoKEBsbKxlLb7g4GCMHj0aqamp2LlzJw4ePIiRI0ciPj5esRldgApifAYOHIhLly5h5syZKCwsRMeOHZGRkWEJYM7Pz7dRld27d8eaNWswY8YMvPLKK7jrrruwceNGtG3bVqlbIAiCIAhds23bNuTm5iI3NxeNGjWy+c4c+F1ZWYmTJ0+ivPyfST/vvvsuPDw80L9/f9y6dQspKSn48MMPZbXdHsXX8ZGbW7duYf78+Zg+fbroUe5GgMqPP1R2/KGyEwaVH3+o7PSH4YQPQRAEQRDGRfEYH4IgCIIgCLkg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGHQpfBZsmQJoqOj4evri7i4OMuaAs746quvEBsbC19fX7Rr1w5btmyRyVJ1wqX8li9fjnvvvRd169ZF3bp1kZyc7La89QzXumfmiy++gMlksizkaUS4lt21a9cwYcIEhIeHw8fHBy1atDD0s8u1/BYvXoyWLVvCz88PUVFReP7553FT4B6GWmT37t3o27cvIiIiYDKZsHHjRrfnZGVloXPnzvDx8UHz5s2xcuVKye0kRITRGV988QXj7e3NrFixgjl69CgzduxYpk6dOkxRUZHD9D/99BPj6enJLFiwgDl27BgzY8YMplatWszvv/8us+XqgGv5PfXUU8ySJUuYw4cPM8ePH2dGjBjBBAcHM+fOnZPZcuXhWnZm8vLymMjISObee+9lHn30UXmMVRlcy+7WrVtM165dmYceeojZs2cPk5eXx2RlZTE5OTkyW64OuJbf6tWrGR8fH2b16tVMXl4e8/333zPh4eHM888/L7PlyrNlyxbm1VdfZdavX88AYDZs2OAy/enTpxl/f38mNTWVOXbsGPP+++8znp6eTEZGhjwGE4LRnfDp1q0bM2HCBMv/VVVVTEREBDN//nyH6Z988knm4YcftjkWFxfHPPvss5LaqVa4lp89t2/fZgIDA5lVq1ZJZaJq4VN2t2/fZrp37858/PHHzPDhww0rfLiW3dKlS5mmTZsyFRUVcpmoariW34QJE5jevXvbHEtNTWV69OghqZ1qh43weemll5g2bdrYHBs4cCCTkpIioWWEmOhqqKuiogIHDx5EcnKy5ZiHhweSk5ORnZ3t8Jzs7Gyb9ACQkpLiNL2e4VN+9pSXl6OyslLSDf3UCN+ymzNnDho2bIjRo0fLYaYq4VN23377LeLj4zFhwgSEhoaibdu2mDdvHqqqquQyWzXwKb/u3bvj4MGDluGw06dPY8uWLXjooYdksVnLUJ+hfRTfskJMLl++jKqqKst2F2ZCQ0Nx4sQJh+cUFhY6TG+9/4hR4FN+9rz88suIiIio0TDoHT5lt2fPHvz3v/9FTk6ODBaqFz5ld/r0aezYsQNDhgzBli1bkJubi3//+9+orKxEWlqaHGarBj7l99RTT+Hy5cvo2bMnGIbB7du3MW7cOLzyyitymKxpnPUZJSUluHHjBvz8/BSyjGCLrjw+hLK8+eab+OKLL7BhwwZFdhnWEtevX8fQoUOxfPlyNGjQQGlzNEd1dTUaNmyIjz76CF26dMHAgQPx6quvIj09XWnTNEFWVhbmzZuHDz/8EIcOHcL69euxefNmzJ07V2nTCEJydOXxadCgATw9PVFUVGRzvKioCGFhYQ7PCQsL45Rez/ApPzMLFy7Em2++ie3bt6N9+/ZSmqlKuJbdqVOncObMGfTt29dyrLq6GgDg5eWFkydPolmzZtIarRL41Lvw8HDUqlULnp6elmOtWrVCYWEhKioq4O3tLanNaoJP+b322msYOnQoxowZAwBo164dysrK8Mwzz+DVV1+12RiasMVZnxEUFETeHo2gq9rt7e2NLl26IDMz03KsuroamZmZiI+Pd3hOfHy8TXrgzi60ztLrGT7lBwALFizA3LlzkZGRga5du8phqurgWnaxsbH4/fffkZOTY/k88sgjSEpKQk5ODqKiouQ0X1H41LsePXogNzfXIhYB4I8//kB4eLihRA/Ar/zKy8triBuziGRo+0aXUJ+hA5SOrhabL774gvHx8WFWrlzJHDt2jHnmmWeYOnXqMIWFhQzDMMzQoUOZadOmWdL/9NNPjJeXF7Nw4ULm+PHjTFpamuGns3MpvzfffJPx9vZm1q1bx1y4cMHyuX79ulK3oBhcy84eI8/q4lp2+fn5TGBgIDNx4kTm5MmTzKZNm5iGDRsyr7/+ulK3oChcyy8tLY0JDAxkPv/8c+b06dPMDz/8wDRr1ox58sknlboFxbh+/Tpz+PBh5vDhwwwAZtGiRczhw4eZv/76i2EYhpk2bRozdOhQS3rzdPYXX3yROX78OLNkyRKazq4xdCd8GIZh3n//faZx48aMt7c3061bN+bnn3+2fJeQkMAMHz7cJv2XX37JtGjRgvH29mbatGnDbN68WWaL1QWX8mvSpAkDoMYnLS1NfsNVANe6Z42RhQ/DcC+7vXv3MnFxcYyPjw/TtGlT5o033mBu374ts9XqgUv5VVZWMrNmzWKaNWvG+Pr6MlFRUcy///1v5urVq/IbrjA7d+502IaZy2v48OFMQkJCjXM6duzIeHt7M02bNmU++eQT2e0m+GNiGPJrEgRBEARhDHQV40MQBEEQBOEKEj4EQRAEQRgGEj4EQRAEQRgGEj4EQRAEQRgGEj4EQRAEQRgGEj4EQRAEQRgGEj4EQRAEQRgGEj4EYRBmzZqFjh07Km2GBZPJhI0bNyptBkEQBoOED0GISHp6OgIDA3H79m3LsdLSUtSqVQuJiYk2abOysmAymXDq1CmZrZQXMQXX+vXr8cADD6B+/fowmUzIyckRJV+CIIwDCR+CEJGkpCSUlpbiwIEDlmM//vgjwsLCsG/fPty8edNyfOfOnWjcuLFhdmEXg7KyMvTs2RNvvfWW0qYQBKFRSPgQhIi0bNkS4eHhyMrKshzLysrCo48+ipiYGPz88882x5OSkgAAn332Gbp27YrAwECEhYXhqaeewsWLFwHc2Wm7UaNGWLp0qc21Dh8+DA8PD/z1118AgGvXrmHMmDEICQlBUFAQevfujV9//dWlvR9//DFatWoFX19fxMbG4sMPP7R8d+bMGZhMJqxfvx5JSUnw9/dHhw4dkJ2dbZPH8uXLERUVBX9/fzz22GNYtGgR6tSpAwBYuXIlZs+ejV9//RUmkwkmkwkrV660nHv58mU89thj8Pf3x1133YVvv/3Wpb1Dhw7FzJkzkZyc7DIdQRCEM0j4EITIJCUlYefOnZb/d+7cicTERCQkJFiO37hxA/v27bMIn8rKSsydOxe//vorNm7ciDNnzmDEiBEAAA8PDwwePBhr1qyxuc7q1avRo0cPNGnSBAAwYMAAXLx4EVu3bsXBgwfRuXNn3Hfffbhy5YpDO1evXo2ZM2fijTfewPHjxzFv3jy89tprWLVqlU26V199FS+88AJycnLQokULDB482DKU99NPP2HcuHGYPHkycnJycP/99+ONN96wnDtw4EBMnToVbdq0wYULF3DhwgUMHDjQ8v3s2bPx5JNP4rfffsNDDz2EIUOGOLWXIAhCFJTeJZUg9Mby5cuZ2rVrM5WVlUxJSQnj5eXFXLx4kVmzZg3Tq1cvhmEYJjMzkwHA/PXXXw7z+OWXXxgAzPXr1xmGYZjDhw8zJpPJkr6qqoqJjIxkli5dyjAMw/z4449MUFAQc/PmTZt8mjVrxixbtoxhGIZJS0tjOnToYPPdmjVrbNLPnTuXiY+PZxiGYfLy8hgAzMcff2z5/ujRowwA5vjx4wzDMMzAgQOZhx9+2CaPIUOGMMHBwZb/7a9rBgAzY8YMy/+lpaUMAGbr1q0Oy8Qas22HDx92m5YgCMIa8vgQhMgkJiairKwMv/zyC3788Ue0aNECISEhSEhIsMT5ZGVloWnTpmjcuDEA4ODBg+jbty8aN26MwMBAJCQkAADy8/MBAB07dkSrVq0sXp9du3bh4sWLGDBgAADg119/RWlpKerXr4+AgADLJy8vz2HwdFlZGU6dOoXRo0fbpH/99ddrpG/fvr3l7/DwcACwDMOdPHkS3bp1s0lv/78rrPOuXbs2goKCLHkTBEFIgZfSBhCE3mjevDkaNWqEnTt34urVqxYRExERgaioKOzduxc7d+5E7969AdwRISkpKUhJScHq1asREhKC/Px8pKSkoKKiwpLvkCFDsGbNGkybNg1r1qxBnz59UL9+fQB3Zo7ZxxaZMcfbWFNaWgrgTnxOXFyczXeenp42/9eqVcvyt8lkAnAn7kgMrPM25y9W3gRBEI4g4UMQEpCUlISsrCxcvXoVL774ouV4r169sHXrVuzfvx/jx48HAJw4cQJ///033nzzTURFRQGAzawwM0899RRmzJiBgwcPYt26dUhPT7d817lzZxQWFsLLywvR0dFu7QsNDUVERAROnz6NIUOG8L7Pli1b4pdffrE5Zv+/t7c3qqqqeF+DIAhCTEj4EIQEJCUlYcKECaisrLR4fAAgISEBEydOREVFhSWwuXHjxvD29sb777+PcePG4ciRI5g7d26NPKOjo9G9e3eMHj0aVVVVeOSRRyzfJScnIz4+Hv369cOCBQvQokULnD9/Hps3b8Zjjz2Grl271shv9uzZeO655xAcHIw+ffrg1q1bOHDgAK5evYrU1FRW9zlp0iT06tULixYtQt++fbFjxw5s3brV4hky252Xl4ecnBw0atQIgYGB8PHxYV2W1ly5cgX5+fk4f/48gDtDbQAQFhaGsLAwXnkSBGEsKMaHICQgKSkJN27cQPPmzREaGmo5npCQgOvXr1umvQNASEgIVq5cia+++gqtW7fGm2++iYULFzrMd8iQIfj111/x2GOPwc/Pz3LcZDJhy5Yt6NWrF0aOHIkWLVpg0KBB+Ouvv2yub82YMWPw8ccf45NPPkG7du2QkJCAlStXIiYmhvV99ujRA+np6Vi0aBE6dOiAjIwMPP/88/D19bWk6d+/P/r06YOkpCSEhITg888/Z52/Pd9++y06deqEhx9+GAAwaNAgdOrUycb7RRAE4QoTwzCM0kYQBKEfxo4dixMnTuDHH39U2hSCIIga0FAXQRCCWLhwIe6//37Url0bW7duxapVq2wWQiQIglAT5PEhCEIQTz75JLKysnD9+nU0bdoUkyZNwrhx45Q2iyAIwiEkfAiCIAiCMAwU3EwQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGEg4UMQBEEQhGH4Pyy9X2dlhO24AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHN0lEQVR4nO3deVwU9f8H8NcCcomAB3KJApqC5ZV+MdREjEQzzTQzNa/U0q+Wih1YJh6ZZaaWmph9PSrNyswOzVKU0iJvKg0pFEVRUFNBQA5hfn/4220X9piZnXvez8fDRzE7O/vZ2dn5vPbz+cxnDAzDMCCEEEII0QEXuQtACCGEECIVCj6EEEII0Q0KPoQQQgjRDQo+hBBCCNENCj6EEEII0Q0KPoQQQgjRDQo+hBBCCNENCj6EEEII0Q0KPoQQQgjRDQo+RJMKCwvx2GOPoXHjxjAYDFi+fLncRXJar169cM8998hdDFLLhg0bYDAYcPbsWbmLQghhgYIPkUxubi6mTp2K1q1bw9vbG97e3mjbti2mTJmC33//3WLduXPnwmAwmP4Z1509ezaKi4sdvtaMGTPw/fffY9asWfjoo4/Qt29fsd4WysrKMHfuXKSnp4v2Gmr22Wef4b777oO/vz8aN26MuLg47Nixo856NTU1WLx4MSIiIuDp6Yn27dvjk08+sbrNrKws9O3bFz4+PmjUqBFGjRqFK1euiP1WBPfnn39i7ty5FJoIkRJDiAS++eYbxtvbm/H19WUmT57MpKamMu+//z6TlJTEhIeHMwaDgTl79qxp/ZSUFAYAs3r1auajjz5iVq9ezTz66KMMACY2Npapqamx+3qBgYHMyJEjxX5bDMMwzJUrVxgATEpKiqivExcXx9x9992ivobQ3n33XQYA079/f2b16tXMsmXLmA4dOjAAmC+++MJi3eTkZAYAM3HiROb9999n+vfvzwBgPvnkE4v1zp8/zzRp0oRp2bIl88477zALFy5kGjZsyHTo0IGpqKiQ8u0xDMMwt2/fZm7duuXwmLTm888/ZwAw+/btE75ghBCrKPgQ0eXk5DD169dnoqOjmYsXL9Z5vKqqinnnnXeYvLw80zJj8Lly5YrFuoMHD2YAML/88ovd1zQYDMyUKVOEeQMMw9y6dYuprq62+hgFH9vuuusu5j//+Y9FKCgqKmJ8fHyYgQMHmpZduHCBqVevnsVnVlNTw9x///1Ms2bNmNu3b5uWT548mfHy8mLOnTtnWrZ7924GALNmzRqR35GwKPgQIj3q6iKiW7x4MUpLS7F+/XoEBwfXedzNzQ3PPfccwsLCHG6rd+/eAO50m1ljHG/BMAxWrVpl6iozOnPmDIYOHYpGjRrB29sb9913X51ul/T0dBgMBmzZsgWzZ89GaGgovL29rXaxnT17FgEBAQCAefPmmV5v7ty5AIDff/8dY8eORWRkJDw9PREUFISnnnoK//zzj8V2bt68ienTpyM8PBweHh5o2rQpHnzwQRw7dszu/vjhhx/g7e2N4cOH4/bt2zbXM44POnr0KLp16wYvLy9EREQgNTW1zrorVqzA3XffDW9vbzRs2BBdunTB5s2b7ZbDluLiYjRt2tTiM/D19YWPjw+8vLxMy7766itUVVXhv//9r2mZwWDA5MmTceHCBWRkZJiWf/HFF3j44YfRvHlz07KEhAS0bt0an332md3ynD17FgaDAUuWLMGyZcvQokULeHl5IS4uDidOnKiz/t69e3H//fejfv368Pf3xyOPPIKsrCyLdayN8QkPD8fDDz+MAwcOICYmBp6enoiMjMSHH35o8byhQ4cCAOLj403HjrHL9MiRI0hMTESTJk1Mn9dTTz1l9/0RQhxzk7sARPu+/fZbtGrVCl27dnV6W6dPnwYANG7c2OrjPXv2xEcffYRRo0bhwQcfxOjRo02PFRYWolu3bigrK8Nzzz2Hxo0bY+PGjRg4cCC2bt2KRx991GJbCxYsgLu7O55//nlUVFTA3d29zusFBARg9erVmDx5Mh599FEMHjwYANC+fXsAwO7du3HmzBmMGzcOQUFBOHnyJN5//32cPHkSv/76qykQTJo0CVu3bsXUqVPRtm1b/PPPPzhw4ACysrJw7733Wn2v3377LR577DEMGzYM69atg6urq919d/36dTz00EN4/PHHMXz4cHz22WeYPHky3N3dTRXq2rVr8dxzz+Gxxx7DtGnTUF5ejt9//x0HDx7EiBEj7G7fml69emHr1q1YsWIFBgwYgPLycqxYsQJFRUWYNm2aab3jx4+jfv36iI6Otnh+TEyM6fEePXogPz8fly9fRpcuXeq8VkxMDHbu3MmqXB9++CFu3ryJKVOmoLy8HO+88w569+6NP/74A4GBgQCAPXv2oF+/foiMjMTcuXNx69YtrFixAt27d8exY8cQHh5u9zVycnLw2GOPYfz48RgzZgzWrVuHsWPHonPnzrj77rvRs2dPPPfcc3j33Xfx8ssvm957dHQ0Ll++jD59+iAgIADJycnw9/fH2bNnsW3bNlbvjxBih9xNTkTbioqKGADMoEGD6jx2/fp15sqVK6Z/ZWVlpseMXV3Z2dnMlStXmNzcXGbNmjWMh4cHExgYyJSWltp9XQB1urqmT5/OAGD2799vWnbz5k0mIiKCCQ8PN3Vl7du3jwHAREZGWpTJFntdXdae/8knnzAAmJ9++sm0zM/Pz2HXnHlX1xdffMHUq1ePmThxos0uuNrPBcC8/fbbpmUVFRVMx44dmaZNmzKVlZUMwzDMI488Imh3WmFhIfPAAw8wAEz/mjRpUqersn///kxkZGSd55eWljIAmOTkZIZhGObw4cMMAObDDz+ss+4LL7zAAGDKy8ttlic3N5cBwHh5eTEXLlwwLT948CADgJkxY4ZpmXHf/PPPP6Zlv/32G+Pi4sKMHj3atGz9+vUMACY3N9e0rEWLFnU+48uXLzMeHh7MzJkzTctsdXV9+eWXDADm8OHDNt8LIYQf6uoiojJ2D/n4+NR5rFevXggICDD9W7VqVZ112rRpg4CAAEREROCZZ55Bq1atsGPHDnh7e3Muy86dOxETE4MePXqYlvn4+ODpp5/G2bNn8eeff1qsP2bMGIvuGD7Mn19eXo6rV6/ivvvuAwCLbix/f38cPHgQFy9edLjNTz75BMOGDcMzzzyDNWvWwMWF3dfYzc0NzzzzjOlvd3d3PPPMM7h8+TKOHj1qKseFCxdw+PBhVtt0xNvbG23atMGYMWPw+eefY926dQgODsbgwYORk5NjWu/WrVvw8PCo83xPT0/T4+b/ZbOuPYMGDUJoaKjp75iYGHTt2tXUYnTp0iVkZmZi7NixaNSokWm99u3b48EHH2TVstS2bVvcf//9pr8DAgLQpk0bnDlzxuFz/f39Adxp1auqqnK4PiGEPQo+RFQNGjQAAJSUlNR5bM2aNdi9ezc+/vhjm8//4osvsHv3bqSnpyMnJwcnTpxA586deZXl3LlzaNOmTZ3lxi6Gc+fOWSyPiIjg9Trmrl27hmnTpiEwMBBeXl6mEAcARUVFpvUWL16MEydOICwsDDExMZg7d67VCjI3NxdPPvkkhgwZghUrVliMnXEkJCQE9evXt1jWunVrADCNT3nppZfg4+ODmJgY3HXXXZgyZQp+/vlnrm/bZOjQocjLy8OGDRvw2GOPYdy4cUhPT0dlZSVeeeUV03peXl6oqKio8/zy8nLT4+b/ZbOuPXfddVedZa1btzbtB+OxYOt4uXr1KkpLS+2+hvkYJKOGDRvi+vXrDssXFxeHIUOGYN68eWjSpAkeeeQRrF+/3ur7JoRwQ8GHiMrPzw/BwcFWB4527doVCQkJ6N69u83n9+zZEwkJCYiLi0PLli3FLGodzrb2AMDjjz+OtWvXYtKkSdi2bRt++OEH7Nq1C8CdeWvM1ztz5gxWrFiBkJAQvPXWW7j77rvx3XffWWwvODgY3bp1w86dO3HkyBGny1dbdHQ0srOzsWXLFvTo0QNffPEFevTogZSUFM7bOnPmDHbt2oWBAwdaLG/UqBF69OhhEaiCg4NRUFAAhmEs1r106RKAO6HNuJ758trrNmrUyGprkBxsjbmq/R6tMRgM2Lp1KzIyMjB16lTk5+fjqaeeQufOna3+iCCEsEfBh4iuf//+yMnJwaFDh2QtR4sWLZCdnV1n+alTp0yP82Gr1eX69etIS0tDcnIy5s2bh0cffRQPPvggIiMjra4fHByM//73v9i+fTtyc3PRuHFjLFy40GIdT09PfPvtt7jrrrvQt29fnDx5knU5L168WKeV4q+//gIAi4G69evXx7Bhw7B+/Xrk5eWhf//+WLhwoalFha3CwkIAQHV1dZ3HqqqqLK5C69ixI8rKyupcMXXw4EHT4wAQGhqKgIAAq6Hv0KFDpvUc+fvvv+ss++uvv0z7wXgs2DpemjRpUqf1jA9HLXb33XcfFi5ciCNHjmDTpk04efIktmzZ4vTrEqJnFHyI6F588UV4e3vjqaeeMlWG5tj8AhbCQw89hEOHDllcGl1aWor3338f4eHhaNu2La/tGscb3bhxw2K58Rd/7fdX+/YZ1dXVFt1eANC0aVOEhIRY7drw8/PD999/b7rk3XilmyO3b9/GmjVrTH9XVlZizZo1CAgIMHUf1r7M3t3dHW3btgXDMJzHmrRq1QouLi749NNPLfbBhQsXsH//fnTq1Mm07JFHHkG9evXw3nvvmZYxDIPU1FSEhoaiW7dupuVDhgzBt99+i/Pnz5uWpaWl4a+//jJdHu7I9u3bkZ+fb/r70KFDOHjwIPr16wfgTgjt2LEjNm7caPG5njhxAj/88AMeeugh9jvCDmN4qn3sXL9+vc5xYwx11N1FiHPocnYiurvuugubN2/G8OHD0aZNG4wcORIdOnQAwzDIzc3F5s2b4eLigmbNmolajuTkZHzyySfo168fnnvuOTRq1AgbN25Ebm4uvvjiC9aDhGvz8vJC27Zt8emnn6J169Zo1KgR7rnnHtxzzz3o2bMnFi9ejKqqKoSGhuKHH36oMwfRzZs30axZMzz22GPo0KEDfHx8sGfPHhw+fBhvv/221dds0qQJdu/ejR49eiAhIQEHDhywGKxrTUhICN58802cPXsWrVu3xqefforMzEy8//77qFevHgCgT58+CAoKQvfu3REYGIisrCysXLkS/fv3N43XAu60VMTFxdm9TUdAQACeeuopfPDBB3jggQcwePBg3Lx5E++99x5u3bqFWbNmmdZt1qwZpk+fjrfeegtVVVX4z3/+g+3bt2P//v3YtGmTRbfRyy+/jM8//xzx8fGYNm0aSkpK8NZbb6Fdu3YYN26c3X1g1KpVK/To0QOTJ09GRUUFli9fjsaNG+PFF180rfPWW2+hX79+iI2Nxfjx402Xs/v5+ZnmaXJWx44d4erqijfffBNFRUXw8PBA7969sXnzZrz33nt49NFH0bJlS9y8eRNr166Fr6+vYKGLEN2S7Xoyojs5OTnM5MmTmVatWjGenp6Ml5cXExUVxUyaNInJzMy0WNfWzM1swcrl7AzDMKdPn2Yee+wxxt/fn/H09GRiYmKYb7/91mId4+Xsn3/+OevX++WXX5jOnTsz7u7uFpe2X7hwgXn00UcZf39/xs/Pjxk6dChz8eJFi3UqKiqYF154genQoQPToEEDpn79+kyHDh2Y9957z+I1rM3cnJOTwwQHBzPR0dF295XxuUeOHGFiY2MZT09PpkWLFszKlSst1luzZg3Ts2dPpnHjxoyHhwfTsmVL5oUXXmCKiopM69y8eZMBwDzxxBMO90tVVRWzYsUKpmPHjoyPjw/j4+PDxMfHM3v37q2zbnV1NfP6668zLVq0YNzd3Zm7776b+fjjj61u98SJE0yfPn0Yb29vxt/fnxk5ciRTUFDgsDzGy9nfeust5u2332bCwsIYDw8P5v7772d+++23Ouvv2bOH6d69O+Pl5cX4+voyAwYMYP7880+LdWxdzt6/f/8624uLi2Pi4uIslq1du5aJjIxkXF1dTZe2Hzt2jBk+fDjTvHlzxsPDg2natCnz8MMPM0eOHHH4Hgkh9hkYRqJ+BkKIbHr16oWrV69aHWTO1c6dO/Hwww/jt99+Q7t27QQonXTOnj2LiIgIvPXWW3j++eflLg4hRAY0xocQwsm+ffvwxBNPqC70EEIIQGN8CCEcvfXWW3IXgRBCeKMWH0IIIYTohqzB56effsKAAQMQEhICg8GA7du3O3xOeno67r33Xnh4eKBVq1bYsGGD6OUkRO3S09MFGd+jduHh4WAYhsb3EPL/uNbD6enpMBgMdf4VFBRIU2AByBp8SktL0aFDB6v3aLImNzcX/fv3R3x8PDIzMzF9+nRMmDAB33//vcglJYQQQrSHaz1slJ2djUuXLpn+NW3aVKQSCk/WMT79+vUzTRjGRmpqKiIiIkxzm0RHR+PAgQNYtmwZEhMTxSomIYQQoklc62Gjpk2bmm6mqzaqGtyckZGBhIQEi2WJiYmYPn26zedUVFRYzHRaU1ODa9euoXHjxpxu8EgIIUR/GIbBzZs3ERISwnuSUzbKy8tRWVnp9HYYhqlTt3l4eAh+D7uOHTuioqIC99xzD+bOnWv3notKo6rgU1BQgMDAQItlgYGBKC4uxq1bt6zeVHLRokWYN2+eVEUkhBCiQefPnxdtdvny8nI0b1EfVy7XOF7ZAR8fnzo3sk1JSRFstvHg4GCkpqaiS5cuqKiowAcffIBevXrh4MGDuPfeewV5DbGpKvjwMWvWLCQlJZn+LioqQvPmzRE2bzZcPD1lLJl6uAaVyV0EwkN1gbfcRWBNaceYM/vOK1+7F8veCrVdMcv5vutfcj4w2FJdVY7M7a9Z3LJFaJWVlbhyuQY/HWoKHx/+PRElJQx6xlzG+fPn4evra1ouZGtPmzZt0KZNG9Pf3bp1w+nTp7Fs2TJ89NFHgr2OmFQVfIKCgurc5LKwsBC+vr5WW3sA2018Lp6emg4+biHWK5LbF7md0O9sR7v7SctcI2s4f95yUOIx5sy+c/XQVvApa/ZvqLD3zipa3vmv9wXp379bPfGCj5EUQyN8fAzwaeDM/ruzH3x9fS2Cj9hiYmJw4MAByV7PWar6hsbGxiItLc1i2e7duxEbGytTiZTHLaTMZugxPk70Q+mft5LLx7ds5kFB7fi8l7JmNZLvg5JQVVVlmpOZmYng4GC5i8GarC0+JSUlyMnJMf2dm5uLzMxMNGrUCM2bN8esWbOQn5+PDz/8EAAwadIkrFy5Ei+++CKeeuop7N27F5999hl27Ngh11sghPCk5NBj5BZSxqvlp6xZjSwtH0JyNryYP1/t+0LLuNbDy5cvR0REBO6++26Ul5fjgw8+wN69e/HDDz/I9RY4kzX4HDlyBPHx8aa/jWNxxowZgw0bNuDSpUvIy8szPR4REYEdO3ZgxowZeOedd9CsWTN88MEHdCk7B1xO4mqomIhjfCtvManp2NJj+BG6xca4PbXuDy3jWg9XVlZi5syZyM/Ph7e3N9q3b489e/ZYbEPpdHd39uLiYvj5+aHFm69pcoyPowqFgo9+ORN+zCssZytFtR5XfPef2ip7KbqpxNgnPvnilPt2VTmOfj4bRUVFoo2bMdZLx/4MdGqMT8nNGtzbtlDUsmqBur6RxClK+9VPpCVU4HCm0lJr6AH0MeZHqrKKMQ6IyzifBrm3BH1toi6quqqLOHb7orfFCZrCDjHnTLeNEK+tV0rv9pIrnMkxDsgYeszDz80I61cFE21S7jeR8Hb7orfpHyFKoJXQ48z7kONqJzaUUibj/nGmPHyv7qIWIH2hFh9iU+3WI6INUg92pmPIkrWKXa7WIKWEntrEGgxNAYcAOg4+XvkuNicaU+rJgBChSBV+tBh6xNh3cnSFqeE8x6crrCTUxeZAZ2OXFgUgfdNt8LGn9hdMSScIY0Ui1S92avXRLjHDj9aPGaH3HYUex7iEQ3vhB6AxPXpHwYcF45dNrpOFtUqk9jIxg5Bx21qvzPRIjCBNx4ljSh7orGRcusAchR+iX/Tt48D7govkJyy2lYgUlQ0NltYuZ48f461S9BR61Ppe1djaUxvb90C3siDWUIsPD94XXCQ5eSjxxEpdX9plr/WHPnP5GFstqBK3xLbry7jfqPWHGFHw4Umq8MOFEm9NQNSHQo64uLQaU2UtHApAxIiCjxPEDD9U+RCifFx/bPANPWpt7RHyFjrW8LkajgIQoeCjMVK0+lB3FyH/Yvud03ro4XNOkHOWeQpA+kXBx0lK7PIiRO+igwodrpNVEChBSfgTI/AIfa5Swg8gpd8OhCgPBR+FolYVQupiE2j4bMvZEOSo1Ydvd4xSKe3c5Ez4ocve9YeCDyFE0YQMO2xfQ+mtQXwo/UazznbTU/ghbFHwUTA+rT50VRfRCikCD5fXdhSGlHxVpdJDj/lrUPghYlN2e6oK6HF8j9KaubUkOqhQ1gpfKZS4D8T6bHzya0StcJ09R0k9MaWzryXH3d2JulCLDyEycFSBOnpci10xRkoMPeaM5RPiMzAPPD75NYJWvGpp5bH1unK2/BhRC5A2UfBxgtJae5TazE7uEGtgrjl7lbEarnRSeugxFx1UWGd/camwrVWqzoQfrV2xJWf4MSoJdUF1BbUCaQ0FH8KJ3CdDNZKyMrfVGqH0QKH08onB2pgSPqFHjB9gSvmeKyH8EO2hI8IJYn+hlHLyIfzIOV6Hz1VKcrX2qDX0CLG/jEGnJNSFd0uP0OchpZ13hBjzo7TWeSIvavFxkp4mMFTaCVGplFqRy92NVZtS95PUlDSgVsvfcWr9IUZ0FAhAjC+T0k5ASiuPEintiiwllcWc0vaTFMT+cSTEOUjJ33GhyqaXH6nEPgo+AqFfEvqlx4pc75TWeqYHFH6IUKirC8JfRuosPl9wMa/oUvIvQTkpPewIUTnbOq74HhNK32ds8N2vYne1ONPtrpbvuFCTRBr3E/1g1SfdBp/6l2rgVs9yDo3auIYhLY73UcsJUWpKr8CdDT2OKhfj41yOD6XvMzaopUd+Qs6QTeN+9Em3wYcNYxhSUmuQNTR/j7SUXoGLHXpqr6uXcMxmvzrad0qsaIX8/PjML8WH0OEHoNYfPaHgwwKXrjCpW32oi0taSg89zuB7LOkh/AhVcWuxcmXznRBytmsjoe+NRgFIPyj4sCTlOCC2FQmFHmlpOfQQ9ZPyBxff74K12a6VhgKQ9tEny4GU9225fdHbarAxLqfQIy21hB6+lQp1lxK2nP0uCHkVpJjnKpr4ULso+ABokHurzj+lMA86VDkRIj2lt1BISYk/AMT+oXYrVNvh56effsKAAQMQEhICg8GA7du3O3xOeno67r33Xnh4eKBVq1bYsGGD6OUUku6DD9eQo/W79VJrj/5QoLaPS2Wv5e+P0KFHiSFKj0pLS9GhQwesWrWK1fq5ubno378/4uPjkZmZienTp2PChAn4/vvvRS6pcHQ/xudmhJfgLTxqvaxdyydtYp290GMc4yDEsUyVnLjEPt+I9fkJNeZH6IHOetKvXz/069eP9fqpqamIiIjA22+/DQCIjo7GgQMHsGzZMiQmJopVTEHpvsVHLDQwjkiNawViraLwvuBi+me+jDhPqfvRUWAQO7RSKBZecXGxxb+KigrBtp2RkYGEhASLZYmJicjIyBDsNcSm+xYf4E6rD1tcruxSU8sPtfYQexWzM8eyFio2IVomxJrDRy3nGLFpodXnh9IoeBr4V8vlpbcBFCIsLMxieUpKCubOnetc4f5fQUEBAgMtvwuBgYEoLi7GrVu34OXFvj6VCwUfkakp/BDbsgoCNVGBA3V/4bOtjPkcy1rZZ1yorQK296PH3ufXu8kpu9vdezWKdRnUcJm7mpw/fx6+vr6mvz08PGQsjfIos+1VofjO46PUJm4jau1hRwsnZnuhxye/ps4/NmwdP1oLPUK8Hy38COrd5JTD0GNcjwutHS9y8vX1tfgnZPAJCgpCYaHlZ1VYWAhfX19VtPYAFHwkY23sBFEfNYcfW6HHXsipvZzt8av3Sszejwkhw4+z2+La2sM1zEgdfuhHnPhiY2ORlpZmsWz37t2IjY2VqUTcUS3MkpCzNpuHIApC6pNVEKi6AGQv9JizNo8V1ykctBx6hLq0Xe6WH7eQMgoJBABQUlKCzMxMZGZmArhzuXpmZiby8vIAALNmzcLo0aNN60+aNAlnzpzBiy++iFOnTuG9997DZ599hhkzZshRfF6o1mVB6FtVGGcEpZlB1U1p4cdepWyrkqt9bHMZ6M+2DMauEa6//pWKy8zDSgw/UgcerXzuWnXkyBF06tQJnTp1AgAkJSWhU6dOmDNnDgDg0qVLphAEABEREdixYwd2796NDh064O2338YHH3ygmkvZARrc7JCQoUeJIYd+9TnHGH6U0sohxCBRR+GH7SBnaxWe+TIug1/tqf1+pfos2N54UymDncX6rj/k8ycAYGdJW0G2RwOdpdWrVy8wDGPzcWuzMvfq1QvHjx8XsVTiohYfO4QKPdSyo31q6/4yPx6FOs7NA4cYg19rs7XPpf4sjC1AfAKXVOcFIUIPtdwQraDgY4OQoUepqLVHeEoIP7Yq4Nqftxjhx0io1hxb2OxnOcKorRAk93eNT4tT7X1n6zPdWdJWsNYeI6W0oBJtouAjIiWHHiIeJbT+CB1+2Axw5vqe+YYjufctW2zCj7MXN3B5Pp8bHbMNP7bsvRrF+3PmG37kDplE+Sj4WOHsr181dG3RyUF8cgcgtuHHnJAtP/YqPLFbhMzJ+TkoseXCGIDYhiBr4YfN5yfEZ6zE/UfUjwY31yJ0kz8hcg6AZjNQtPatFEpCXRy28JgPcL590dtmmNp7Nco0NkSIitCZACPG7Nv2xr0Y36+SB+uahx97gdjavpMyvBIiJKrlzQgRepTe0gNQa49cjC0PUlaCQr4W3+4uZ7o7tEyoObyE2o6jliClhjdCuKLg8/8o9BApmYcgsSoUuSoqJVeQQpbN0VVO9h63d6sQJaDwQ7SMurqgn9BDlItNhSJUNw2bsR1surtqb9M8VCv5pq5sK2+2N+g0zmNT286Stujd5JTd1i5r+9gnv4bzOUmMmyHb6sJU2txV1ihl7iSiTLpv8dHTmB5q7VE3Li1EXH+ZW6s0S0JdLL4f9r4rtipINbcQiFV2W7cLUSJ74UHtny/RL123+Ohhrh4jCj3aYqtFxZmKqPYgZyNr3xPzY97RsSVUC4Eclayt/Ww+aNveHDZSjm0So9WHDfPPRehWIL6fObX2EHv009xRS2mwfkIP0abav7jZVBKOKgRHx7MzUzWotYXAVpkdhRrj48bn1973tn54OfODTO6bHgs5do1CDxGLrlt89IJae7RN6DBhreXHVtjhc2xxbSFQclgyb/kxXyYnuVp+rLH22dn7zJ39rCn0EDYo+DhBKScXeyj0ECMulQKbY1uIY0vJoYYte0HH0fsztu7wGdCsVmJ95hR6CFv6+KYpiFtIWZ1/Yr4WIcR5fCprW8+xNZBcSEJ2eakhUKihjEQ5KPjwxKW1x1HIETsAESI0PR6vXMJP7XVrV8xStBbLPd5HKhR6CFfU1SUirpWDcX0hvsh6rJiIbVQ5CMPe/ER8phBQSzixd1sSOdFxTfig4CMSZ04SzgQgJZ6ciLbo/RhT07gkJQ10FhqFHsKXOn5uKIyjE4lQFQOX7VB3GbFHjmOS3GGvglZTKFFK0OByZ3lCrKHgIzChKwZH26PAQ6RAx5l6aWmgs9yvT7SBurpUgCocIgQ+9y+iY4/UJsd4Hwo8REgUfAjREfMKy1ZlQmGHOCJV+KHAQ8RAwYcQnaKAIz5HFbdUV3WpbZAzBR4iJtnH+KxatQrh4eHw9PRE165dcejQIbvrL1++HG3atIGXlxfCwsIwY8YMlJeXS1RaQghRJ6FDlpDhxDhgmQYuEynI2uLz6aefIikpCampqejatSuWL1+OxMREZGdno2nTpnXW37x5M5KTk7Fu3Tp069YNf/31F8aOHQuDwYClS5dKVm61/XoihCgPlyDik//v+UaNt7agMEOURNZv0NKlSzFx4kSMGzcObdu2RWpqKry9vbFu3Tqr6//yyy/o3r07RowYgfDwcPTp0wfDhw932EpkTf1LNfDJ//efUOgLTggxcqY70db5yZnzlRitPrZaaqgFhyiVbMGnsrISR48eRUJCwr+FcXFBQkICMjIyrD6nW7duOHr0qCnonDlzBjt37sRDDz1k83UqKipQXFxs8c8aIUMQfdEJIfbYCyBszkNKCj/mKOwQNZCtq+vq1auorq5GYKDlLKiBgYE4deqU1eeMGDECV69eRY8ePcAwDG7fvo1Jkybh5Zdftvk6ixYtwrx58ziVTU93SiaEiIvtNAJCtjw7orfu+tphT0/vndSlqto9PT0dr7/+Ot577z0cO3YM27Ztw44dO7BgwQKbz5k1axaKiopM/86fP8/qtRydhBz9aqJfPIQQI0ddXnxCj7NBSS33CePD+4KLxT9Hj2t5X5C6ZGvxadKkCVxdXVFYaHnDv8LCQgQFBVl9zquvvopRo0ZhwoQJAIB27dqhtLQUTz/9NF555RW4uNQ9eD08PODh4cGrjNTyQwis3pRTTferUgrzlh+hblBK5yhLzuxT43OpNUj7ZPvGuLu7o3PnzkhLSzMtq6mpQVpaGmJjY60+p6ysrE64cXV1BQAwDCNKOaVsfiZEaWzdiTw6qNDmY3on9b5R6ngfKQnZakMtQNon66eblJSEtWvXYuPGjcjKysLkyZNRWlqKcePGAQBGjx6NWbNmmdYfMGAAVq9ejS1btiA3Nxe7d+/Gq6++igEDBpgCkBhsnVjoy0G0jIINd+b7zFoAEmvSSL3+QBMzpOjp/M5lPr0NGzbAYDBY/PP09JSwtM6TdR6fYcOG4cqVK5gzZw4KCgrQsWNH7Nq1yzTgOS8vz6KFZ/bs2TAYDJg9ezby8/MREBCAAQMGYOHChXK9Bc2wNiaJZvbVt6yCQAo/HNXeZ/a6BM27u4zdVc4EGL7dXmod6CxFMPG+4IKSJqK/jKy4zqcHAL6+vsjOzjb9bTAYpCquIAyMWH1EClVcXAw/Pz90Hvoa3OqxT6m2TiiOThhKDw9sBmEr/T0QcdEYH2GZf+esVd7Ott7wHfOjpvAjZWtMdUU5Tr37MoqKiuDr6yvKaxjrpTcOx8HTh397RHnJbST/50dOZe3atSv+85//YOXKlQDuDDkJCwvDs88+i+Tk5Drrb9iwAdOnT8eNGzd4l1Nu+mnLk4mSr+5iWzYlvwcivqyCwDr/iDCshY2SUBenBizzDU5q6dpRSznlVHvuuoqKCqvr8ZlPDwBKSkrQokULhIWF4ZFHHsHJkycFfw9iopuUOolNM7FUdzJmi0+QUdp7IERMbL8jYn4nSkJdeIcYrXZ7aT30/PhPa9Qrd+f9/KrSSgA/IiwszGJ5SkoK5s6dW2d9PvPptWnTBuvWrUP79u1RVFSEJUuWoFu3bjh58iSaNWvGu+xSouAjESUEB2dabuQuOyFS4PodMV+fzXeE6/blCj+A8rq+tB56hHT+/HmLri6+U7pYExsba3Hldbdu3RAdHY01a9bYnVNPSSj4SKj2SU/sMEFdVIQ4JtT3xLgdW99ra68jdmVuDE1qD0AUerjx9fVlNcaHz3x6tdWrVw+dOnVCTk4Or7LKgYKPjCiYaAvXX/+EPTV9V5RYVmcmOjQPHUoIQUQ45vPpDRo0CMC/8+lNnTqV1Taqq6vxxx9/2L1nptJQ8CEOUSVun7WKjqYH4E+JwUEMUrdiCDHLsxytQNTaI66kpCSMGTMGXbp0QUxMDJYvX15nPr3Q0FAsWrQIADB//nzcd999aNWqFW7cuIG33noL586dM91RQQ0o+BAiESWM81IivQQdJRDqFhdKHwRN2OM6n97169cxceJEFBQUoGHDhujcuTN++eUXtG3bVq63wBnN48OSvZOFlk8AVFHbx6fSpn1KYQdg35IhxqzMQt7fS8zznxJae6Scx6ffromoV9+5q7q+67tW1LJqgfxHFSE6o+dK//ZFb12/f6UQMkwpIZwQwgV1dRHCk1orcDkGYat1X4lFCWFByDu7K+kKMEIcoeDDgpDNwmpCXTLaYm8QtpiftdZCD5fL1a1RQugxEjL8CE0p++lWKIU5rVHGkaVyYt4hmCiT2iaDdFReMbqgqFtLHajbi+gNHaUOcPk1RF96okRcwocQQYUCj210jmBHKfuJuu60ibq67HBmtlOAvjSkLjlae9xCyjiHHz7l1EvYsTYDu6P3zrciF+OKLluvo9QuL7nQ+Vu7KPhYIfSAPyP6IumbnGOmxAw/egk8togVetRIqHNcWbMaWfcbnau1TbfBpzTYBa4e0n6xrH2R6QtGpCJ0+NF74HHE2YpbqtYeoWjhXKaF90Ac023wUQp7J0f6EioX1xChlCvkjOVgW3bz8ENBhz1q5VEXLbwHwh4FHwVzdPKkL6u8uIQfKS4b54JLmKHAw5697yzbFpySUBfVtPaIeQ6SqruLzqP6Q8FHxcQeQ0T3lhKe0vapeVko4DjHViXNNcTUXp/tmENnwhKfcY1SBAYxww8FHv2i4KMhYlxRprSKWmm4dnkBymv9MaIQxJ+1ytnZVhuuYcTa+mzKoNTQY/5aQocfCj36RsFHo4ScQp7Cj320b/SNTehpkHsLAHAzwsvh9oS8rFwrl6gLGX4o9BAKPhpH99AhRH5sAo+ayHFekfsSd6IddBTphLO31aCuD0Kss1b5821pUVsLjdS363E2aNEPQAJQ8NEduq8YIdIQYoyOElkbNyTleaWsWQ2vAEOhhxhRV5dOeV9w4XQioHEshNhm/l0yDwDGMGMtLKgl6AB1y2/rFhdczyvOsLXPba1DiBEFHx1je5Ki0KM/fK5WI3dYq5DVFHLYUkL4MaKAQ7ig4CMTe5eZSnmSdHSSotBDCH+1v1ta62ZWUvghhC3dBp9boTVw8XTcVCoEZycwM9Lir0aiXNTqIzxjGFBbALLXZUd3didqo9vgU5u1XyfOnJzEmHJerHECtn6dUWsPIeKQMwA5aomxVyY25xuhW3roXnFEaBR87GAzeM4aKe+zw+e12Jy8KPQQgFp9xCZmAOIbQPj+CBQi8Ng77zg6J9FxStii4MMS28mz1HBzQWMZzQOQeasPhR5ijsIPN3xaKPj+yLL2fDGIuX2hzje1t0PHLLGFgg8HjsKPGkKPOWsBiBBrKPywI0QlrodBwVL8uKJ7zxFbKPgQ0+BEY6sP3ZuLEH608t1h+x7YBgq59wmNEyLmKPhwpPb7xRhvlmhOa/cRIuKgVh/t4htM5A40XFEAIgAFH17UGH6sBR7Lx7yo1Yc4ROGHHbXsIzbf8eigQgBAVkGg2MVxWAZ7uJSPApC+UfDRAXuhx1zt+Tgo/BBrKPzYp4Z9wyXw2PobkCYMsQk9xvW4loeOZX1SV7OFQlhr7VHywGZHXVm1H1dbaxaRHgVidXILKXP42UUHFXIKG2zX5YPrtvmUhY5l/aEWH50whhu2rT9G1OpDbKHuAvVg+x22Fhx6NzlVZ9neq1FWnydnd5gR35YfgI5lvaCf9hypvTXkZoRXnX9Gtef1Mbp90ZtOCMQmCsbKxaaFx4ht6LG3XMjWH2e2xfe5ej2WV61ahfDwcHh6eqJr1644dOiQ3fU///xzREVFwdPTE+3atcPOnTslKqkw1F2LE8HUnsvH2lwiFH6ILcYKVuyKQ6rXUSvz/SPXPhKz64stJbQ8qcWnn36KpKQkpKSk4NixY+jQoQMSExNx+fJlq+v/8ssvGD58OMaPH4/jx49j0KBBGDRoEE6cOCFxyfmj4MOBrdYeJY/vYYMmMCRCql35sq2EbT3P1jaUUMkrgZj7oHaXlqPlQuIbXpwNPXo7lpYuXYqJEydi3LhxaNu2LVJTU+Ht7Y1169ZZXf+dd95B37598cILLyA6OhoLFizAvffei5UrV0pccv5ojI/OUeghUpGiNQjQR8uklJWzFCFHadR+tVdxcbHF3x4eHvDw8KizXmVlJY4ePYpZs2aZlrm4uCAhIQEZGRlWt52RkYGkpCSLZYmJidi+fbvzBZeIboOPa1AZXL1rWB/cah/bY42t0KOHKfOJdmk9AKmhRYLPAGNrsgoCOXWdCdnFJUf4yS4MgKu3J+/nV5eVAwDCwsIslqekpGDu3Ll11r969Sqqq6sRGGi53wIDA3HqlPVxXAUFBVbXLygo4F1uqek2+BixPbjtTVpYEuqiuu4uPi09ajjhEmKk9QCkdEKFH7ZoXM+/zp8/D19fX9Pf1lp79Ez3wQdQf7MmV/ZCD7X2EK2hAMQO19YVqdQONFJeOu8WUobKM+pr7ff19bUIPrY0adIErq6uKCy0/NwLCwsRFBRk9TlBQUGc1lci9X2iInG2NUMtY2X4hh5q7SFikWq6BBoM7ZjQYUKMIJVVEEitOwJxd3dH586dkZaWZlpWU1ODtLQ0xMbGWn1ObGysxfoAsHv3bpvrK5E6amuJODoZOmoNUUv4IUQpzAOPMQBJ1TJDAYiw4Rqk7WMkKSkJa9euxcaNG5GVlYXJkyejtLQU48aNAwCMHj3aYvDztGnTsGvXLrz99ts4deoU5s6diyNHjmDq1KlyvQXOqKurFkfdXmq8QSkhasIljAjR7aG3rm5CzA0bNgxXrlzBnDlzUFBQgI4dO2LXrl2mAcx5eXlwcfm3zuvWrRs2b96M2bNn4+WXX8Zdd92F7du345577pHrLXBGwUdgahzoTIgc+IYNa90nzgYgCj//UupYHyKeqVOn2myxSU9Pr7Ns6NChGDp0qMilEg81XVjhbJeXUlFXHFE7qpAJIc6imlAEFDAIIWpGg4eJllENbQMNerRE3QBEKvaONeMVPdYqZj1U1mo7L+nhMyHqQ2N8eKJBzoSI5/ZFb4eVPFWqykWfDVEyCj6ENTaVkdaYjymR62TOZlwLVTREaDTImWgVNVnYobdKntRlDBRKDj3G9bRWSUk5rw915QqHQjhROgo+TlDr1V186TUIKj30OPscNTAPQVzDkLXn8t2W3KQuK4UYIrf9+/fjySefRGxsLPLz8wEAH330EQ4cOMB7mxR8HOBT2atxHh+9hTilcybAaDX81MYm0Kgp1CgVhR8ily+++AKJiYnw8vLC8ePHUVFRAQAoKirC66+/znu7FHxY0GtLhznaB9LRS3Ah/MgR5uj+WEQOr732GlJTU7F27VrUq1fPtLx79+44duwY7+1yDj4XLlxASUlJneVVVVX46aefeBdErfTQUkKhRzoUeoiSOQo/FI6IkLKzs9GzZ886y/38/HDjxg3e22UdfC5duoSYmBi0aNEC/v7+GD16tEUAunbtGuLj43kXROm4VP5KncCQTxcchR7p6C300LHFn5xdeHqeR4lIKygoCDk5OXWWHzhwAJGRkby3y7qGTk5OhouLCw4ePIhdu3bhzz//RHx8PK5fv25ah2EY3gVRA1snaq6tPg1ybwlRHNFRxSQNLV6RJTTvCy4W/4j8zCeTFDP00PdDvyZOnIhp06bh4MGDMBgMuHjxIjZt2oTnn38ekydP5r1d1vP47NmzB19++SW6dOkCAPj5558xdOhQ9O7dG2lpaQAAg8HAuyBqwfZmhvZuVnozwkvoYrHmk1+j2BYpPdL7Cd0YrmkQMnd6nFeL6EtycjJqamrwwAMPoKysDD179oSHhweef/55PPvss7y3yzr4FBUVoWHDhqa/PTw8sG3bNgwdOhTx8fH4+OOPeRdCLo4qHa023VoLP94XXOq0XNGJVVxihR41HreOflDoYSwdH/QdJVpmMBjwyiuv4IUXXkBOTg5KSkrQtm1b+Pj4OLVd1j/9IyMj8fvvv1ssc3Nzw+eff47IyEg8/PDDvAqwatUqhIeHw9PTE127dsWhQ4fsrn/jxg1MmTIFwcHB8PDwQOvWrbFz507Or9sm8IrDdWw1sVo70Vg7MSu5ZcUnv6ZOi5S1LgS6JFgcFHrqogqcH/p+Eq1zd3dH27ZtERMT43ToATi0+PTr1w/vv/8+hgwZYrmB/w8/Q4YMwYULFzi9+KeffoqkpCSkpqaia9euWL58ORITE5GdnY2mTZvWWb+yshIPPvggmjZtiq1btyI0NBTnzp2Dv78/p9flKjqosE6FwrbLS+lqt/5Ya/kB6JelkCj02KaV7xUhxHnx8fF2h9Ds3buX13ZZB5+FCxeirMx6xefm5oYvvvjCNKsiW0uXLsXEiRMxbtw4AEBqaip27NiBdevWITk5uc7669atw7Vr1/DLL7+YrukPDw/n9JpCYXtytjfWRyko/KiXWGHH1vEtxedP4Yc7LX83tRDoCT8dO3a0+LuqqgqZmZk4ceIExowZw3u7rIOPm5sbfH197T7eokUL1i9cWVmJo0ePYtasWaZlLi4uSEhIQEZGhtXnfP3114iNjcWUKVPw1VdfISAgACNGjMBLL70EV1dXq8+pqKgwzfYIAMXFxazLqCdsww9xjhCtPVKHHVvriFnRUvjhTsvhh+jTsmXLrC6fO3eu1fkE2ZJtEMrVq1dRXV2NwEDLk3hgYCAKCgqsPufMmTPYunUrqqursXPnTrz66qt4++238dprr9l8nUWLFsHPz8/0LywsTND3QYjYxL5smO84LrGDCVXihBBrnnzySaxbt47381m3+ChBTU0NmjZtivfffx+urq7o3Lkz8vPz8dZbbyElJcXqc2bNmoWkpCTT38XFxZzDDzW1/ot+VUpDimNOiOBi3IbSjwk2c/9ooYWTvp/Cqy6glkelycjIgKenJ+/nyxZ8mjRpAldXVxQWWjb9FxYWIigoyOpzgoODUa9ePYturejoaBQUFKCyshLu7u51nuPh4QEPD486y7MLA+Dq7cnrknZrFYbaJ1WrfQWarUqATqriU0voqb09pR4bbL+bxvXUHICU+hkQwsfgwYMt/mYYBpcuXcKRI0fw6quv8t6ubMHH3d0dnTt3RlpaGgYNGgTgTotOWloapk6davU53bt3x+bNm1FTUwMXlzsnqb/++gvBwcFWQw8bXCsZLY47oNCjDFK1LKrlGBainHx+kND4NmJ05xgsl7sYuuXn52fxt4uLC9q0aYP58+ejT58+vLfLK/jcuHEDhw4dwuXLl1FTY3mCGD16NOvtJCUlYcyYMejSpQtiYmKwfPlylJaWmq7yGj16NEJDQ7Fo0SIAwOTJk7Fy5UpMmzYNzz77LP7++2+8/vrreO655/i8Dc5snYjV2tpjbZ4hCj3iyioItNrKqIXQo+RWH64o/BC1/EDQsvXr14uyXc7B55tvvsHIkSNRUlICX19fi2vsDQYDp+AzbNgwXLlyBXPmzEFBQQE6duyIXbt2mQY85+XlmVp2ACAsLAzff/89ZsyYgfbt2yM0NBTTpk3DSy+9xPVtcKa10GMNhR5pyDVmTIoTuVDhRwmVDoUfQrSJc/CZOXMmnnrqKbz++uvw9nb+5DR16lSbXVvp6el1lsXGxuLXX391+nW5cCb0KHUOHyXPKk2EpYQQIZeyZjVO/Tih8CO92i2icvxQ0PN3Rm4NGzZkfd/Pa9eu8XoNzsEnPz8fzz33nCChRw30EnqotUeb6ASur/Cj5u5GWxeaGJdroTuYOLZ8+XLRX4Nz8ElMTMSRI0cQGRkpRnkUw97Br4TQUzu8KDVkEfmo9QQuRrmFCD/WtkmEIdZtXIj6ODMjM1usgs/XX39t+v/+/fvjhRdewJ9//ol27dqZbh1hNHDgQGFLKANnT7xShx7jMjavy6W1h6iTnIFHiNYGsWZtNh7nQo3LM9+OUr5Damnt4RN0rN0zUWhq/bGgB+Xl5aisrLRYZu9uEvawCj7Gy83NzZ8/v84yg8GA6upqXgVRAjYHva2TplQtLvbG5tgLPzSmRx/UHnqkwDakcAlIcneHKXnfC9maI2b4odCjPKWlpXjppZfw2Wef4Z9//qnzON+8wSr41L5kXQuqC7zBODHzo5GUXUx8wwuFHu3jctIWuttGjEpXCffq4to9Jlf4kTv0UDcVEcuLL76Iffv2YfXq1Rg1ahRWrVqF/Px8rFmzBm+88Qbv7XKuET/88EOLm34aVVZW4sMPP+RdEDWofRJUYugxX68k1MXh8xydqOWufIhjbD8j7wsuNitye4/ZI/aNSuXGNchIPb2F3PtIjtAjxmvSeY6da9euYeTIkfD19YW/vz/Gjx/v8GahvXr1gsFgsPg3adIkVq/3zTff4L333sOQIUPg5uaG+++/H7Nnz8brr7+OTZs28X4fnL+l48aNQ1FRUZ3lN2/eNE08qAdKDD3m61Mrjz5wCT1s12O7rhSVrtwVO6Cc8Tu1KWHf0H0M9WXkyJE4efIkdu/ejW+//RY//fQTnn76aYfPmzhxIi5dumT6t3jxYlavd+3aNdOFVL6+vqbL13v06IGffvqJ9/vgfFUXwzBWr7G/cOFCnemltcS8MlBy6OGCzQldCSdXYp3QoYcLKY8L42vJ+avc2avChKak76W18CNmS5DQYYtae9jJysrCrl27cPjwYXTp0gUAsGLFCjz00ENYsmQJQkJCbD7X29vb5j047YmMjERubi6aN2+OqKgofPbZZ4iJicE333wDf39/vm+FffDp1KmTqZnqgQcegJvbv0+trq5Gbm4u+vbty7sgSibXCY9abYizrB271oJ77WPN3ngVuSpd89eVo7JiE36kaB1SUuhRO62GnuLiYou/bd2sm4uMjAz4+/ubQg8AJCQkwMXFBQcPHsSjjz5q87mbNm3Cxx9/jKCgIAwYMACvvvoqq7kAx40bh99++w1xcXFITk7GgAEDsHLlSlRVVWHp0qW83wvr4GO8siszMxOJiYnw8fExPebu7o7w8HAMGTKEd0GUiG2l0SD3FgDgZoSXIK8rReBRavM9YYfvFYi2Wit98mtUFbTlagWyF34o9PzL1j3plESJocfZi25qyu8cm2FhYRbLU1JSMHfuXGeKhoKCAjRt2tRimZubGxo1aoSCggKbzxsxYgRatGiBkJAQ/P7773jppZeQnZ2Nbdu22XzO888/jwkTJmDGjBmmZQkJCTh16hSOHj2KVq1aoX379rzfC+vgk5KSAgAIDw/HsGHD4CnAFVFKxrWVx9nQw7XScXSSFeLKHbWcZIl11ippW1MecDn+lDQ7sBwByPx7ZNy/9EOiLjHCD40pYuf8+fMWc9zYa+1JTk7Gm2++aXd7WVlZvMtiPgaoXbt2CA4OxgMPPIDTp0+jZcuWVp/z1VdfYdmyZejatSsmTJiAYcOGoX79+mjRogVatGjBuyxGnMf4SDGropzsBR5bv5adCT1CBx6u69milIqNCK92+OHT0qOk8APId/m7lIFHSfubLfOg4mwIEjL0KLG1R0i+vr6sJ/ebOXMmxo4da3edyMhIBAUF4fLlyxbLb9++jWvXrnEav9O1a1cAQE5Ojs3g8/fff+Onn37CunXrMG3aNEybNg1Dhw7FhAkT0K1bN9avZQvn4GPrBmIGgwGenp5o1aoVxo4dq6orvOQYwyNE4HF0IpTryy3FDKuEHVtdM0J0a1H4kY6S9jNfxnMC1wBEg5nFFRAQgICAAIfrxcbG4saNGzh69Cg6d+4MANi7dy9qampMYYaNzMxMAEBwcLDd9Xr27ImePXti1apV+PTTT7F+/Xr06NEDbdq0wfjx4zFq1CgEBvI7Njif/ebMmQMXFxf0798f8+bNw7x589C/f3+4uLhgypQpaN26NSZPnoy1a9fyKpBUvPJdeM9d4gw+l5rzCT3GdficMJ05ySq9X1+PyprVcG6ZYLv+7Yvepn9KoIWAoHVZBYGswgzb9Yg0oqOj0bdvX0ycOBGHDh3Czz//jKlTp+KJJ54wXdGVn5+PqKgoHDp0CABw+vRpLFiwAEePHsXZs2fx9ddfY/To0ejZsyfrMTr169fHU089hf379+Ovv/7C4MGDsWjRIjRv3pz3e+Hc4nPgwAG89tprdSYgWrNmDX744Qd88cUXaN++Pd59911MnDiRd8GUiO39sOw9nys2occ8bFg7UUg5DoJOVMplbWyKvXW4Mj++5Awgto53rmVSSpjTKjnOFfSZOmfTpk2YOnUqHnjgAbi4uGDIkCF49913TY9XVVUhOzsbZWV3vmvu7u7Ys2cPli9fjtLSUoSFhWHIkCGYPXs259cuLS3F/v378eOPP+L69eto06YN7/dhYBiG4fIEHx8fZGZmolWrVhbLc3Jy0LFjR5SUlOD06dNo3749SktLeRdMLMXFxfDz80PUc6/D1YP7AG2+wUeK0FObrROLvS8//WJWD7WcxNV+TMm9n9W+/5SEz2dZU16Ocy/NRlFREe+bYjpirJdavPkaXJy6qkv8skrtwIEDWLduHbZu3QqGYTB06FCMHz8e3bt3571NzrVxo0aN8M0339RZ/s0336BRo0YA7iSzBg0a8C6Ukkk1i7Kzocf4uLV1jF1gtbdHJ1h1UcvnpbTuMK74dhkTZVHr8adHly5dwhtvvIGoqCj07NkTp06dwtKlS3Hp0iWsW7fOqdAD8OjqevXVVzF58mTs27cPMTExAIDDhw9j586dSE1NBQDs3r0bcXFxThVMydh0eTkzeJQujSVsyT2pH1fGMqoxSGh58DQhShIWFobGjRtj1KhRGD9+PKKjowXdPufgM3HiRLRt2xYrV640TUDUpk0b/Pjjj6bLzGbOnCloIZXIGGycvSyYi9pX0TiaJ8NRH3rtk7jSrtIh3Cj1Kj9r1HqsST1vkBr3ESHO+uyzzzBw4ECLO0QIiddWu3fv7nRTk1YIHXa4tvbYCj9cQw/RPqW1WFDrj/QcXQihVWr8rPRs8ODBom6fV/CpqalBTk4OLl++jJoay4q6Z8+eghRMj9iEHmu/lPV0AiPOUWKFTa0/4rLVKqzXEEQI5+Dz66+/YsSIETh37hxqXxBmMBhQXV0tWOGI8BydpNVaCRFC6mI7r5bUk446Og/ROYiIiXPwmTRpErp06YIdO3YgODjY6izORFx8ugiU/quUiI+OAXEosRWNDzHDD9f94+wcTITYwzn4/P3339i6dWudeXyIc/hcycWmdYbPCZlafbRHyRWzFo41scKPM99FPrOoixF+hNgvah4PRpSHc/Dp2rUrcnJyKPgohPmJUcgTL4UfbVBy4NEaavmxJFYQNOJyflLLeCxiqbS0FG+88QbS0tKsjik+c+YMr+1yDj7PPvssZs6ciYKCArRr1w716tWzeJzt/TfIv5yZt8f8y6+2OV2IuOgYkJ4Y4UeOHyHOhh8pjj0++0Ur4VQvJkyYgB9//BGjRo0SdGgN5+AzZMgQAMBTTz1lWmYwGMAwDA1ulpi9L70QX3Bq9SFS0NpxppXwIybjveKcnayVwo+2fffdd9ixY4fg0+dwDj65ubmCFkAu9S/VwK3enS+d2BMPikFLJ0FCtEYJlaujCU4d4dvqY+991745rvnfUs5YT11f6tCwYUPTrbCExDn4tGjRQvBCyM04+7JaAhCFHsKGEipftrTWogEIv//l6vIC2M/zY+v91g48ttaR+nY9NDxA2RYsWIA5c+Zg48aN8PYW7vPhVdN/9NFH6N69O0JCQnDu3DkAwPLly/HVV18JVjA58L3zujOUfl8uOhmom5rChPnNTLVy3Am9/7nuF6Gu0GLbciT18Sbk69m6eTORz9tvv43vv/8egYGBaNeuHe69916Lf3xxbvFZvXo15syZg+nTp2PhwoWmMT3+/v5Yvnw5HnnkEd6FUQKf/BrVtPw4ItQvTi3+GtcTNbX8mLNWZjbHodbngJHr+yj1JIdyMt+/lWe0UR+o0aBBg0TZLufgs2LFCqxduxaDBg3CG2+8YVrepUsXPP/884IWTi5ShR8+rT1CnPD4DCyk8OM8OStkrYxpsLcPbb03uY9duYOns2N9zPENP2XNalh1d3Eh1WfqGkTnPbmkpKSIsl1eg5s7depUZ7mHhwdKS0sFKZQUGpy9hVt3eVp9TKmhB+B2Ejc/2Vo76XANQHJXIGplr0IG5AlA5q+vZubHJB2btgkZfvhyFH7Ynofoc9afo0ePIisrCwBw9913W80gXHAOPhEREcjMzKwzyHnXrl2Ijo52qjBK4Cj0KGFMjq1JvGpXZGx/YQl1aSmxxDZYyBUotRCC1FIJyt3qAwgXfhy1+th7r8ZzDN9zjlo+byKMy5cv44knnkB6ejr8/f0BADdu3EB8fDy2bNmCgIAAXtvlHHySkpIwZcoUlJeXg2EYHDp0CJ988gkWLVqEDz74gFch1ECpocBe2LE1WNtWuGNzVQW1+rDD595EcnfHmJdFDYTYX7WDgNbHsCih5QeQr5ufqMuzzz6Lmzdv4uTJk6aGlT///BNjxozBc889h08++YTXdjkHnwkTJsDLywuzZ89GWVkZRowYgZCQELzzzjt44okneBVCDjfDveq8+dqBQKlhx1ztVp3aYadB7i0AwM0IrzrrWAtAFH6cxzc4KGW/qmE8kLP7yVblz/XybS6U0OoDSBN+hH6vSvheEOnt2rULe/bssehNatu2LVatWoU+ffrw3i7n4AMAI0eOxMiRI1FWVoaSkhI0bdqUdwHkpqaw46jryhhojGHHXIPcWxbhx7g+hR9iixpbgRxhW+Er+QomIb53agk/dI7Rt5qamjq3xQKAevXq1blvFxe8go+Rt7e3oJMKSak02AWuHvZnDa39pRPz5O/sFQ9s5iCyFn6cQeGnLmeOESXvSyW1AvHZT0q5U7mzhDxG+IYfLvvEmfCj5O8DkUbv3r0xbdo0fPLJJwgJCQEA5OfnY8aMGXjggQd4b5dV8OnUqRPrm4MdO3aMd2Gkxibs2HtMqEpAitBj77l8W30ACj96o5TuGi6UMKZFCGr9nnE9ZtT6PonwVq5ciYEDByI8PBxhYWEAgPPnz+Oee+7Bxx9/zHu7rIKPWJMIyelWaI3FtNV8vmxKqAS4hh4urT5cwo8RnbS4U9s+k7P1h+u+cjb0KLHVR0hcW3347gs250q1fQ+I+MLCwnDs2DHs2bMHp06dAgBER0cjISHBqe2yCj5iTSKkFLa+cOYnBFtfeGfDj7OtPSWhLnXCjzHY1B7rYyvwCDlhoxxz0ygFn+NAzftJ6uAvx75SSugR870b36OjAOTsvrA3ZkzN3wMiLoPBgAcffBAPPvigYNvkNcbnxo0b2Lp1K06fPo0XXngBjRo1wrFjxxAYGIjQ0FDBCic2a182e1d7CB1+hJrJ1Fr4AWwHHSlQK5BjWtgvUoUfqcb1mFNK6JGKvQAk9L7QwrFPxPHuu+/i6aefhqenJ95991276z733HO8XoNz8Pn999+RkJAAPz8/nD17FhMnTkSjRo2wbds25OXl4cMPP+RVEKndmYbccuZmRydKMcKPUGyFH2cJccdkPYQgrp+9lvaD2F1fWtpXfEj9/vUW+IiyLFu2DCNHjoSnpyeWLVtmcz2DwSBd8ElKSsLYsWOxePFiNGjQwLT8oYcewogRI3gVQgm0MACST/iR+oaseghBeiVG+JfrGBGr8qeBvoTYl5uba/X/hcS51jt8+DCeeeaZOstDQ0NRUFAgSKEIfyWhLqzDjNx3ob990dv0T2+0+p6FqqjdQsqc3hbf8EItHoQow/z581FWVvc8cOvWLcyfP5/3djnXfB4eHiguLq6z/K+//uJ93wy5sW3tcXRCVNKvM2MAMg9C1pYphZoDkDMzNWuRs98DOb9HUoQetu9PSecTQuQwb948lJSU1FleVlaGefPm8d4u59pv4MCBmD9/PqqqqgDc6WfLy8vDSy+9hCFDhvAuiFzk7OKScpZovkFH6pms1RyAyL+4ttgY1xe6smcbZLIKAiVt6XH0Xin0ECVauHAhunXrBm9vb9NNQx1hGAZz5sxBcHAwvLy8kJCQgL///pv1c63NIfjbb7+hUaNGXIpugXNt+Pbbb5tuU3Hr1i3ExcWhVatWaNCgARYuXMi7IHJQwrgeJd8iQ86y6SX8aD3o2Qo05svFruSNocZasJE68NRm7b1T6CFKVVlZiaFDh2Ly5Mmsn7N48WK8++67SE1NxcGDB1G/fn0kJiaivLzc5nMaNmyIRo0awWAwoHXr1mjUqJHpn5+fHx588EE8/vjjvN8H58HNfn5+2L17Nw4cOIDff/8dJSUluPfee52eUEhqbQKvAHCXuxgA7gQMoS5tF4oSApme5gSyFX609N6V8F6ME/YpaRyPEvYLIWwYu5c2bNjAan2GYbB8+XLMnj0bjzzyCADgww8/RGBgILZv327zxubLly8HwzB46qmnMG/ePPj5+Zkec3d3R3h4OGJjY3m/D87B5/z58wgLC0OPHj3Qo0cP3i+sVXyvbFFS+FFC6DGn5Nti8G2tsfZZW9vvdBWc8JQUeggRQ+1xuB4eHvDw8JC8HLm5uSgoKLBoGPHz80PXrl2RkZFhM/iMGTMGABAREYHu3bvDzc2p24rWwXlr4eHh6NGjB5588kk89thjaNiwoaAFItJRWsCxRyutP/bCrflj9kKQ2vcBIcQ6r3zLm2dzVV1x57nG+1oZpaSkYO7cuc4UjRfjld6BgZY/NgIDA1ldBV5aWoq0tDQkJiZaLP/+++9RU1ODfv368SoX5z185MgRxMTEYP78+QgODsagQYOwdetWVFRU8CoA+ZfYQaSsWY3FPzVS85gYW6HH2txL9gKSWt8/IUQa58+fR1FRkenfrFmzbK6bnJwMg8Fg95/xPllSS05ORnV1dZ3lDMMgOTmZ93Y5t/h06tQJnTp1wuLFi5Geno7Nmzfj6aefRk1NDQYPHox169bxLgwRnloDjiPU+kEIIdb5+vrC19eX1bozZ87E2LFj7a4TGRnJqxxBQUEAgMLCQgQHB5uWFxYWomPHjg6f//fff6Nt27Z1lkdFRSEnJ4dXmQAeLT5GBoMB8fHxWLt2Lfbs2YOIiAhs3LiRd0HUQIqrwIQIKmK06nhfcDH9UxI1twCZE+N2I4QQ4khAQACioqLs/nN353chUEREBIKCgpCWlmZaVlxcjIMHD7IanOzn54czZ87UWZ6Tk4P69evzKhPgRPC5cOECFi9ejI4dOyImJgY+Pj5YtWoV74IQ54nVhVU77Cg1AMmBS4uTrc/H2oSS9j5HauUihMghLy8PmZmZyMvLQ3V1NTIzM5GZmWkxyWBUVBS+/PJLAHcaSKZPn47XXnsNX3/9Nf744w+MHj0aISEhGDRokMPXe+SRRzB9+nScPn3atCwnJwczZ87EwIEDeb8Pzl1da9aswebNm/Hzzz8jKioKI0eOxFdffYUWLVrwLgSxxPUKL75hx7wC5Xt3eSV1pcnV/cX1Jp219xnb/UiBhxAipzlz5lj07HTq1AkAsG/fPvTq1QsAkJ2djaKiItM6L774IkpLS/H000/jxo0b6NGjB3bt2gVPT8ubhFuzePFi9O3bF1FRUWjWrBmAO40u999/P5YsWcL7fRgYhmG4PCEsLAzDhw/HyJEj0aFDB94vLJfi4mL4+fmh366JqFefe/Mdm0thhWx9sBeA+IQOe5WntXKzCWBKCj9GcoYEIT9/CjuEyKu6rBxnxryOoqIi1uNmuDLWS1HPvQ5XD8eBwJbqinKcevdlUcsqNYZhsHv3bvz222/w8vJC+/bt0bNnT6e2ybnFJy8vz+oU0noh9eRnxtYfIcKFo0qU7xxESmv5AeSd+4dNCxAFGkIIccxgMKBPnz7o06ePYNvkHHyMoaesrAx5eXmorKy0eLx9+/bClEzF+AYIW6QIPc6i8FMXhRtCCHFOWloa0tLScPnyZdTUWNYxfK8i5xx8rly5grFjx2LXrl1WH7d2zT0hhBBij7WrZmmWbX2bN28e5s+fjy5duiA4OFiw3ibOwWf69OkoKirCwYMH0atXL3z55ZcoLCzEa6+9hrfffluQQikZfRHVQw0tLvamSKBjjeiBve+A0u6rRqSVmpqKDRs2YNSoUYJul3Pw2bt3L7766it06dIFLi4uaNGiBR588EH4+vpi0aJF6N+/v6AFVCuhu7uc4UwAUNI9xLTG0bxQdNInWsdmbjT6HuhXZWUlunXrJvh2OddopaWlaNq0KYA7t46/cuUKAKBdu3Y4duyYsKUjgpAigCltfI8aWnsIIY5R6NGvCRMmYPPmzYJvl3PwadOmDbKzswEAHTp0wJo1a5Cfn4/U1FSLKam5WLVqFcLDw+Hp6YmuXbvi0KFDrJ63ZcsWGAwGVhMhEcdsBSSlhRqtcHRCpxO+ddFBhZLMok7ER98BYk95eTmWLl2KuLg4PPvss0hKSrL4xxfnrq5p06bh0qVLAO7c8bVv377YtGkT3N3dsWHDBs4F+PTTT5GUlITU1FR07doVy5cvR2JiIrKzs00tS9acPXsWzz//PO6//37OrykVJXV3OXuFk3n4qd31pbRgpKbWnqyCQFMlTid562yFnNrLaf+pk/l3oPZyom+///676Z5eJ06csHjMmYHOrINPbm4uIiIi8OSTT5qWde7cGefOncOpU6fQvHlzNGnShHMBli5diokTJ2LcuHEA7gxm2rFjB9atW2fz7qvV1dUYOXIk5s2bh/379+PGjRucX5dY4hLQlBZ01I5O8MKgACkPIfY7fWbEmn379omyXdbBp2XLlmjRogXi4+PRu3dv9OrVC82aNYO3tzfuvfdeXi9eWVmJo0ePYtasWaZlLi4uSEhIQEZGhs3nzZ8/H02bNsX48eOxf/9+u69RUVGBiooK09/FxcW8yqoFtVt9nGmNUmqrj5pae4hw7FWcFIiEZ62FhlrgiFqwDj579+5Feno60tPT8cknn6CyshKRkZHo3bs34uPjER8fj8BAbgf61atXUV1dXed5gYGBOHXqlNXnHDhwAP/73/+QmZnJ6jUWLVqEefPmcSqXPXJcYSDk5IBidb0pcQJDog3m3zculWvtdenqIGGwHV9F+5s4Kz4+3m6X1t69e3ltl3Xw6dWrl+kmZOXl5fjll19MQWjjxo2oqqpCVFQUTp48yasgbNy8eROjRo3C2rVrWXerzZo1y2IQVHFxMcLCwsQqoqDMW1WUFCxsXd5uXC5XOam1R/vYVqT2xgVRZcwf10HltL+JM4zje4yqqqqQmZmJEydOYMyYMby3y3lwMwB4enqid+/e6NGjB+Lj4/Hdd99hzZo1NltpbGnSpAlcXV1RWGj5ZSosLERQUFCd9U+fPo2zZ89iwIABpmXGKazd3NyQnZ2Nli1bWjzHw8MDHh4enMqlBNbChZLCjz1qKSfRJjbzIwHUFSMVCj+Er2XLllldPnfuXJSUlPDeLqfL2SsrK/HTTz9h3rx5iI+Ph7+/PyZNmoTr169j5cqVyM3N5fTi7u7u6Ny5M9LS0kzLampqkJaWhtjY2DrrR0VF4Y8//kBmZqbp38CBAxEfH4/MzEzVtOSwofbg4H3BhSY+JJKjy9yVh0IPEdqTTz7J+z5dAIcWn969e+PgwYOIiIhAXFwcnnnmGWzevJn33D1GSUlJGDNmDLp06YKYmBgsX74cpaWlpqu8Ro8ejdDQUCxatAienp645557LJ7v7+8PAHWWi0mqXzC1Z01WYxii1h8iFbV2w9Qed0ddtoTYl5GRAU9PT97PZx189u/fj+DgYNMVXXFxcWjcuDHvFzYaNmwYrly5gjlz5qCgoAAdO3bErl27TAOe8/Ly4OKi35YDY/hRSnjg04ojRfmpsiBqZO1iA2fn3FISJQRLol6DBw+2+JthGFy6dAlHjhzBq6++ynu7rIPPjRs3sH//fqSnp+PNN9/E8OHD0bp1a8TFxZmCUEBAAK9CTJ06FVOnTrX6WHp6ut3n8pk0UW2UEnqcIffAZ6JtauvicnR1pZbCDyF8+fn5Wfzt4uKCNm3aYP78+ejTpw/v7bIOPvXr10ffvn3Rt29fAHeusDpw4AD27duHxYsXY+TIkbjrrrvqzK6oRfQrhj+xWn+ootAvtYUevaDzJOHrzJkziIiIwPr160XZPu8+pPr166NRo0Zo1KgRGjZsCDc3N2RlZQlZNkXS85dZqMHKNOiZCEWNoUcpt7Hhg835L6sgUNfnSeK8u+66y3QDdODOkJjaV387g3UNVFNTg0OHDmHx4sXo168f/P390a1bN7z33nsICgrCqlWrcObMGcEKpkT0ZRYOhR9CtIUCDxEKwzAWf+/cuROlpaWCbZ91V5e/vz9KS0sRFBSE+Ph4LFu2DL169aozb45W0RdaeEoatE2IVIxdsvZafpTcbUvnQqJ2rIPPW2+9hfj4eLRu3VrM8kgmuzAArt53LocT687Aam7Srk2sFhqhb8eh5AqDCM/Wnb3ZPldOte+bR8cuIXcYDIY6t6pw5m7stbEOPs8884xgL6o0cp8AlU5N3VJUgeiP8fvLJQAp7TtPxywh/2IYBmPHjjXddaG8vByTJk1C/fr1Ldbbtm0br+3zumUF0Q8pQg91eREhsG39UVroIYRYqn0frieffFLQ7VPwEYmWurmkIMYd6OlXtP5YCzV0by5C1EWsy9iNKPiIQCuhR+ouLqFbfqjbiwAUeAghltQzeINISq5xPUK/rlZCKCGEEGFQ8BGYFipauQczU/ghhBAiFgo+AtJCBSt36BHL7Yvemvh8CCGEOEebtRzhRUmhR6yyUPghhBB9U05Np3Jqr1CVFHqMKPwQQohyLFy4EN26dYO3tzf8/f1ZPWfs2LGmCQmN/4w3O5cLXdUlALVXpEoMPWKjS94JIYSbyspKDB06FLGxsfjf//7H+nl9+/a1uETdODGhXCj4EEUTe3JDCkCEEMLOvHnzAAAbNmzg9DwPDw8EBQWJUCJ+KPjonB5be6xh22pHAYkQQrhJT09H06ZN0bBhQ/Tu3RuvvfYaGjduLFt5KPg4Se3dXGqgpFtamH/eFIIIIUpUXFxs8beHh4ds3Ut9+/bF4MGDERERgdOnT+Pll19Gv379kJGRAVdXV1nKRMFHx6i1xzk0MzQhREj1L9XArR7/H3m3q+48NywszGJ5SkoK5s6da/U5ycnJePPNN+1uNysrC1FRUbzK9MQTT5j+v127dmjfvj1atmyJ9PR0PPDAA7y26SwKPk6g1h7pKKnVhxBClOz8+fPw9fU1/W2vtWfmzJkYO3as3e1FRkYKVTRERkaiSZMmyMnJoeBDiCMUfgghxDFfX1+L4GNPQEAAAgICRC7Rvy5cuIB//vkHwcHBkr1mbdTXQYgKGWeiphmpCSFSycvLQ2ZmJvLy8lBdXY3MzExkZmaipKTEtE5UVBS+/PJLAEBJSQleeOEF/Prrrzh79izS0tLwyCOPoFWrVkhMTJTrbVCLD1EXavWhLlZCiDzmzJmDjRs3mv7u1KkTAGDfvn3o1asXACA7OxtFRUUAAFdXV/z+++/YuHEjbty4gZCQEPTp0wcLFiyQdS4fCj48UeVD5GDruKOB1oQQsW3YsMHhHD4Mw5j+38vLC99//73IpeKOgg9xmk9+3RaYklDqRSWEEKI8FHx0rKxZDe9L2q2FHVuPCx2C9NrdRa2MhBDiPAo+hBNHgUdvxO5i4hJ26PYbhBDiGPVH6BzblhOf/BoKPTaI0RLjzNVa1DJECCG2UfDhQW8VixIDj9JmnRbqmKDL0wkhRFzKqj2ILPQ4XkaJhAw8FJ4IIcQ6Cj5ElZQY1pwJGxRU9IM+a0LkRcGHBxo8SmzhU6mJVRFSBas89JkQIj8KPgSA/RYUZy5Hp/l8CCGEKAnVSsSkrFmNzQCkpACjxG4uvqgFQF/cQsqoxZgQmSmnNiOKoaVgoWRShB4KVoQQYomCD09a/9VmLfwoodWHQhkhhBBnyF+TEcVyNvwIGZTsdcMpCdtALGVLDLX6EELIv+iWFcQuY9gwnzDQGGjsTWwoVOiRKuzYmxCRbRmU2gqo1HIRQogcKPg4wS2kTNW/pq1ViLbej7UbmpaEuoh6M1KxQo/Qsz5zCRZqPl4I4SI6qNDu41kFgRKVhBBLFHxUjs+dyu1V1MbHrFXQtsKP0IQOPM4GHXv7mEIPIZYcBR7z9Sj8EDlQ8FGh2hW58W8puoWshR8hty0kW+WUoouuNgo9RA/Yhh5C5ESDm1XGXujwvuDCKpQ4WwkLHVCkHLjs6Iarth63tV8d7Uu66SghhCgLtfg4ScpxPmxbWvh0f3Flvn2uLUBCl43tZ2At1DTIvYWbEV511uPS8lP7tZU29stYFhrkTMRErT1ELSj4aJSj8HP7ordgFaFcl5mbl99R2DAPPQ1yb1k8Zvy7dgDiS0mhx5yQnzkhQqBxPkQO1NWlEmKMq7FWQaupa8a8nHxDjxGb0CPW2CYpqeWzJerCt7WHQg+RA7X46JzaK0Jb5ecSUoRq6VELavkhSkChh8iFgo+TlBwcpBjro0TmocfeYGZbgUcJt+YQG437IVwJOYaHQg+REwUfFdBCF4tUHIUeR607egg95qj1hzgiROChoEOUhIIP0QxHM0s7orfQQ4hQKNgQNaHgQ3RP74GHWn0IIXpCwUfhqJuLHT77iWvg0fJ4KQo/hC9q7SFqQ8GH2MSnIpRrsLetW2mo7S7xhKgJhR6iRhR8NIxvZe3ML39bz5UiEIl1HzG9hB5q9SHWULghWkPBR8Hk6OYSq+JztF2hgpHQ4UcvoYdIz9oxT8GTEPHRABJiIudJ1y2kzPTPWUKEFSlvnKokSp6XSkts7Wc1zZxO9OXs2bMYP348IiIi4OXlhZYtWyIlJQWVlZV2n1deXo4pU6agcePG8PHxwZAhQ1BYKO993Sj4EMURIgDxDS56DTxEOmyCDYUfojSnTp1CTU0N1qxZg5MnT2LZsmVITU3Fyy+/bPd5M2bMwDfffIPPP/8cP/74Iy5evIjBgwdLVGrrqKuLAFBmE7sQdzmvHWLMu8Eo4FhHY33EQ4GGqFXfvn3Rt29f09+RkZHIzs7G6tWrsWTJEqvPKSoqwv/+9z9s3rwZvXv3BgCsX78e0dHR+PXXX3HfffdJUvbaqMWHKJpQ3V9GxhYdCj32UQUtPNqnRGuKiorQqFEjm48fPXoUVVVVSEhIMC2LiopC8+bNkZGRIUURraIWHyfQiUw6QrT+ECIXOnaJlIqLiy3+9vDwgIeHh6CvkZOTgxUrVths7QGAgoICuLu7w9/f32J5YGAgCgoKBC0PFxR8FEysy7NrY9OiYut+PVJe6krhR1rU5WVb7ePQ0X4yf5zNMUz7XZ8anL0FNzeG9/Nv3y4HAISFhVksT0lJwdy5c60+Jzk5GW+++abd7WZlZSEqKsr0d35+Pvr27YuhQ4di4sSJvMsrFwo+POmlAnZ0g0Lzx6UIQcYKQS/7X24Ufu5wdLyZP84lBLHZNiFcnT9/Hr6+vqa/7bX2zJw5E2PHjrW7vcjISNP/X7x4EfHx8ejWrRvef/99u88LCgpCZWUlbty4YdHqU1hYiKCgIPtvQkQUfBROqlYfa7jelTk6qFCyFiBq/SFS4HOMcQ2LFCyJ0Hx9fS2Cjz0BAQEICAhgtW5+fj7i4+PRuXNnrF+/Hi4u9uumzp07o169ekhLS8OQIUMAANnZ2cjLy0NsbCyr1xQDDW7mQQ0VLtvBu0KfdLmGJWdQhSENNRzvQqP5dAixlJ+fj169eqF58+ZYsmQJrly5goKCAouxOvn5+YiKisKhQ4cAAH5+fhg/fjySkpKwb98+HD16FOPGjUNsbKxsV3QBCgk+q1atQnh4ODw9PdG1a1fTTrNm7dq1uP/++9GwYUM0bNgQCQkJdtcXmtQnQzXepDQ6qND0T2wUfqRBIYAb2l9Ea3bv3o2cnBykpaWhWbNmCA4ONv0zqqqqQnZ2NsrK/j0vL1u2DA8//DCGDBmCnj17IigoCNu2bZPjLZjIXqt++umnSEpKQkpKCo4dO4YOHTogMTERly9ftrp+eno6hg8fjn379iEjIwNhYWHo06cP8vPzRS+rlCcz7wsuvEOPki7VNg9BYgUhoS95J9aJdfwbW1fs/ZOSUK/HdzvU2kSUaOzYsWAYxuo/o/DwcDAMg169epmWeXp6YtWqVbh27RpKS0uxbds2Wcf3AAoY47N06VJMnDgR48aNAwCkpqZix44dWLduHZKTk+usv2nTJou/P/jgA3zxxRdIS0vD6NGjRSunFCciIVp3lBR6rBFzMLSzA5+FCk9UadnHd9yMObGCrtCfnXF7fMrrzHMJIbbJGnwqKytx9OhRzJo1y7TMxcUFCQkJrCc3KisrQ1VVlc1JlCoqKlBRUWH6u/b8BmyIWZGpsStLKGKFIFsBSKoKRMtXnjl7lZfQrSlCfqZifl5s95u1MtCVdYQIS9bgc/XqVVRXVyMw0LLSCwwMxKlTp1ht46WXXkJISIjFzJDmFi1ahHnz5vEuo1gnQzECj9Jbe+wR44owuSsLrV55xjV0iB0ouJTF3jbE5szrUPghRDiyd3U544033sCWLVuQnp4OT09Pq+vMmjULSUlJpr+Li4vrTO5ki5pCjxiyCgIlvUpLysvhpaLV8AMoq0WLyzw61p6jBtT1RYgwZA0+TZo0gaura51b1LOZ3GjJkiV44403sGfPHrRv397menyn6tZ76DGi8OM8LYcfJbIXgrTwOVDrDyHOkbUWdnd3R+fOnZGWlmZaVlNTg7S0NLuTGy1evBgLFizArl270KVLF0HLJOYVFWoLPUZaCyJyoIpKHnJeHSYmrb0fKSntKkIiPdm7upKSkjBmzBh06dIFMTExWL58OUpLS01XeY0ePRqhoaFYtGgRAODNN9/EnDlzsHnzZoSHh5smT/Lx8YGPj49TZaEDXhm02OpDlIvPDxKljKej1h/HnL2KsKZcnT9YiW2yB59hw4bhypUrmDNnDgoKCtCxY0fs2rXLNOA5Ly/PYlrs1atXo7KyEo899pjFduzdhI0NvYYeqU+cvZv8O2h979UoO2sSIg4hWl7NtyF3COIzvkkP9HpOJ47JHnwAYOrUqZg6darVx9LT0y3+Pnv2rOCvT18Qx5wd62MeeMyX2Qo/Wmz1obE+8hC7i9m4fbkDEGD9XKbHMETfM2KPIoKPXOjLcYcUrT7GgMO2xUdroQeg400sQgQbn/w7oaUklP+2lBSAzOktDNH3jDii2+BTXeANF+tXwKuW9wUXxZ10a2PTvaXF0EP4E7PFxhh4av/tbABS+veQxgYRPdNt8JGao5M33xOlUJUCnQjFRb9CHZPyqsfagcfW43wDEIUfedD3jLBBwUcC9k7ozp4cjc83voYzJ1wlnAiptUfb5J7SwVHgsba+lsOP1tA4OsIGBR+RSH2CL2tWYxF+jMu4shd+hJrMUE/hRq8nYbkDjjVcQ4/587Qafmg2aKJHFHwExuWEL/YJkW8AchR+ALAKQHIFHCUM5tRj4FFi2DHiG3qI+lCrD3GEgo+A5A495q0+5vj86nTU7WUtALENOkJ2qbE9wdlaTy1392ZDrHFkzr6unIQKPM60+qiBErq5heRs+DHfF9Vl5UIUiSgIBR+BKPnkD/Br/WFzMmQTdqydgJwJIkIGDLnDihDYHntCT7qn5GNeSS08Su/uMtJi+AEcf8e19J4JOxR8BGKrtcUWoU+GXCs/tq/tzKywzk4VT+xzJng4e/wpMfSIHXa03uqjVdZafyjs6BsFHw3gUwnx7f4CpG+VIZaECh1qaYmwR+qWHa2HH621+hhp8T0R/ij4CEjuVh+unBn8TKQnRisLn2NQ7tYeJXVjsSX3d50Q8i8KPion1A0X6aSsXFLca0rpn7+Swo7WW30I0ToKPjLj2+piqzLkO+OsUu8zpFdyt6rYw7Vl01lKCj1aR11CRA8o+AiMb6XAJng4CjvWllEAUj4lhxw5KTnwaLHVR6jQY5ziQk8TlRJ1oeCjMFwqQTYVAwUg4fG5BQmFG26UHHr4UnKXojOhx9ZkphSAiFJR8BGYUis4vr9QKQDdwWeuHMKPWkKPVlp9xAg91tahAESUQv3fWsKaMxWKnit0Pbx3pbxHtYQeLXALKRM99DizPiFioRYfwpqSm+rFoJQwoDRi7Rc1hh61tfrQ4GW6MSuh4CMoqStK4wmXS4XBZl17J3Itd33pPejIGWzVGHr40MqPB7W13jhz25zqApq3TGso+GiArQBkL8DYq2jY/IpV0wlc74GGC3ufqxj7US+BRwmEbOHIKghUTfjhOuFq3fXpJqVaQ8FHQ4Rscldj+KGAIwwp9qNUgadB7i27j9+M8JKkHEQeNMs8sYZqCp1iE5LYVE5SzCrM9h9RB66hp0HuLd7/2G7bGWpotRJjPAtdpaUvZ8+exfjx4xEREQEvLy+0bNkSKSkpqKystPu8Xr16wWAwWPybNGmSRKW2jlp8BKLGirck1MXuSZttC5L5exeiBUiN+5KwwyUkOBtIuGiQe4taf3hQcpcXtfYI69SpU6ipqcGaNWvQqlUrnDhxAhMnTkRpaSmWLFli97kTJ07E/PnzTX97e8v72VDw0Tk+44PscRRa+MxMrSV8J5TUGylDT+3XFDsAKa2L2FnGlh9HAUjKFiIKPcLr27cv+vbta/o7MjIS2dnZWL16tcPg4+3tjaCgILGLyBoFHwFoocKWqiLWwr7iSshbihDxabH15/ZFb9Ev36auL/0pKipCo0aNHK63adMmfPzxxwgKCsKAAQPw6quvytrqQ8GHEBE56tpR2zwweiFV6w8RHrX2AMXFxRZ/e3h4wMPDQ9DXyMnJwYoVKxy29owYMQItWrRASEgIfv/9d7z00kvIzs7Gtm3bBC0PFxR8FEjqu18TIhVH48qMjIFDji4vc1ps/dEytYcet9xLcHNx57+BmjsDjcPCwiwWp6SkYO7cuVafkpycjDfffNPuZrOyshAVFWX6Oz8/H3379sXQoUMxceJEu899+umnTf/frl07BAcH44EHHsDp06fRsmVLu88VCwUfhajd529tDIBWw5CWg55QA8i1hG34ASxbXOQKQY7Cj1o+Qym6u+Sk9tAjpPPnz8PX19f0t73WnpkzZ2Ls2LF2txcZGWn6/4sXLyI+Ph7dunXD+++/z7lsXbt2BXCnxYiCj05xGeRYe10thAXje9Jy0LNV0aulwhQDn1nHuba8yN1aZI9cA5zVEn4oxDjH19fXIvjYExAQgICAAFbr5ufnIz4+Hp07d8b69evh4sL9HJaZmQkACA4O5vxcoej3zKsAzp74yprVqPbqEDZlV/P7q60k1KXOPyJu+LsZ4WX65ywlhyiulB4qlF4+vcrPz0evXr3QvHlzLFmyBFeuXEFBQQEKCgos1omKisKhQ4cAAKdPn8aCBQtw9OhRnD17Fl9//TVGjx6Nnj17on379nK9FWrxEYKxcmbTQiFGRc7l9eXE972r5f0Rfvi0/nB1M8JLU+HFWUpt+aHQo1y7d+9GTk4OcnJy0KxZM4vHGIYBAFRVVSE7OxtlZXeOLXd3d+zZswfLly9HaWkpwsLCMGTIEMyePVvy8puj4CMgWxU03wrf2onJ3olBqWNlhAp7FIC0jcvYHz6UMmBaKZQafogyjR071uFYoPDwcFMIAu4Msv7xxx9FLhl3FHxE4ExF7+hEZP64tRAkVPhh8x7svY6YXVTm26YQJC5Hn6PQ+1/s8ANQ6485Cj9Ejyj4EAvODLaWg5R3EtcbNp+vGK1wUoUfgH3rj5YvaVdS+KldDur6ImKg4KMgSjn5aIEWr4CTCp9AK3QAkiL8AOwulxcr9Cjp1hXmAUNJ5yFHLdyE8EHBh5go5SQsBqm7bNRKiCsN1bovtdaq4yjA2AoSxuVKCkDAv+WhAEScRcGHANB26GGD7iovHKHCj1StPlojVGBRUheYOQpAxFkUfAgRiFjhUapApcTwq/Tw4+w8REJ3dwkdVJQafij0EGdQ8FEQLicZW198vpWkksYbEEtqG8Ctxiu9iHXOno+c2aYQr0WINRR8FMZR+BHzS0/hR12EvKxf6Z+7EsMPzb59B9dzEt+B1BR4iFAo+CgQ3y+4EL+0jdtQekVILCllbiMxX1tJ4UeJoUfoLik223M2jNR+Pl3OTqRAwYdYRa0/6sUnBAnxeUsRuGoHDjmCkJChR8jvmBBd5Vy2J0YooaBDpEDBh9hE4Uf9uIQgZz5vuVqZhAohjgKUElt4rJEqrFBAIWpGwUcj7FU8xpM6n5M3hR/tYBOCuHR1KnVwNR9qCTZsCBlKagcpCjxECyj4aASbuVOcCUBKJ8V4BC1xdLxoKdQQYdD3h2gFBR8dUNpcI0ZSzw9i6/XohE6IbfT9IFpDwUdDlHi7ACVOflabtTLSyZ5Iga6iJER6FHw0Rozww+ekrIbAYw/f+xw5s02hX4+oh5oDENvzjdrem/F9VVco68ckcR4FHxVQU4uE2gMPW3J30yn18xeCnm8oa+u9KS008PkMrD1HSe9Ly8cVsUTBR+FsVbBuIWU2Kz+5urz0EnqUQCs3auRT8entijOg7vuRIzCIsU/lbunS2nFC2KHgo2COgoSSwg+FHnnYOwaUTOyKztr2tVTJmb8XtvtSye9fymCn5P1ApEHBR6HYBgm1Vny1RQcVclo/qyBQpJKoj5qOATm7Nmq/tlYqQK28D3NCd/lpcR8R/ij4KBSX6efl5qicXEMNG8ZtUgC6Q+nhR0ljOYyUcn8zwh59TkQIFHwUzFiR8Zl/RiknCDFCj7XtazEA1d53jt4j1/AjVXeoEkNPbcYyKuV7QwgRDwUfFZD7lzzfCQzFDj22XkvtIcjWfosOKlTde1ND6DEnx4UB5vcJU8qs6rbuXaaU8hHiDDqKNUgJv1qlDD3WXlvO13eGo3I7elwt3aNKVtasRpLA5pNfUydgWFsmJUevb3xczjIS4ixq8dEYJYQe4E6ri9zhg203mK1yytG64mi/OSqT3K2DWiJ2609JqIvVACFHqwqfIKPElipC2KDgoyFKCT1KwzeAyTV+qPbrqbGLSyxcW7ScDYJShB+la5B7CwBwM8LL5jo++TWqeC+EANTVpRlKDD1aqazl7jrTyn50Fp9uPLeQMtM/Yp2t1p4GubdMocfa32y3Q4jSUIuPyvEJPHya18W6QztRB0eVmti/9oUILnwv+VfizX/l1CD3ls3WH2r5IWpAwUelhAo8tR+jk5Z6ca3U2RxDbH/F2zp+hArMQsxrReOfuDGGG/NWHnvdXUYUfojSUfBRCWd+cXJpgqaTFjFyZsCr+TEk1P2Y1DSpp5rYGmRtxCbsEKImiqjhVq1ahfDwcHh6eqJr1644dOiQ3fU///xzREVFwdPTE+3atcPOnTslKql0vC+4WPzjy9mrNWqXieiDs+M1rF3yLMTxw6fV5vZFb0EGOWuZ0D92aLyPNg0cOBDNmzeHp6cngoODMWrUKFy8eNHuc8rLyzFlyhQ0btwYPj4+GDJkCAoL5b3iV/aa7NNPP0VSUhJSUlJw7NgxdOjQAYmJibh8+bLV9X/55RcMHz4c48ePx/HjxzFo0CAMGjQIJ06ckLjk4nA26Jhjc/KxNWCRTlzqImQ3l5Cffe0AJMTxzeW9UvcWe9TSSxyJj4/HZ599huzsbHzxxRc4ffo0HnvsMbvPmTFjBr755ht8/vnn+PHHH3Hx4kUMHjxYohJbZ2AYhpGzAF27dsV//vMfrFy5EgBQU1ODsLAwPPvss0hOTq6z/rBhw1BaWopvv/3WtOy+++5Dx44dkZqa6vD1iouL4efnhxZvvgYXT0/h3ohAhGxVcVSBOeq7t3YitPXL11YXhNxz+QhJyVdXcanghQg99q7uAdgdT0K0ovC5nQtfemrxdDb8ailEVVeU49S7L6OoqAi+vr6ivIaxXkpo8hTcXNx5b+d2TSX2XF0nalnNff311xg0aBAqKipQr169Oo8XFRUhICAAmzdvNgWkU6dOITo6GhkZGbjvvvtEL6M1sh6dlZWVOHr0KBISEkzLXFxckJCQgIyMDKvPycjIsFgfABITE22uryZyhR6iblK2aji6pLn2eubrWuv6EqL1x9o/4pySUBdNhRcivGvXrmHTpk3o1q2b1dADAEePHkVVVZVFnR0VFYXmzZvLWmfLOrj56tWrqK6uRmCg5S/pwMBAnDp1yupzCgoKrK5fUFBgdf2KigpUVFSY/i4qKgIA1JSXO1N0UVRXCHeiuV1lO/g0OHsLt2st8/q7HDfDLX+le54FSoMty1RTbn271WXW92dVaaXDsqqFrfcot5py9seNV74Lqu08zvW4YfWaZseWtWPK4zRwK1T5XatCfj/VoqjJnf/Wv8Tt89HSvqquuPO9l6Jz5DZTCTjxVbjN3DnfFhcXWyz38PCAh4eHM0Uzeemll7By5UqUlZXhvvvus+h9qa2goADu7u7w9/e3WG6vzpaC5q/qWrRoEebNm1dn+fmU12QojcIdFn6TZ4TfJFEjEY4tQqT0zz//wM/PT5Rtu7u7IygoCOkFHzu9LR8fH4SFhVksS0lJwdy5c62un5ycjDfffNPuNrOyshAVFQUAeOGFFzB+/HicO3cO8+bNw+jRo/Htt9/CYDA4XXapyBp8mjRpAldX1zojvAsLCxEUFGT1OUFBQZzWnzVrFpKSkkx/37hxAy1atEBeXp5oB7GWFRcXIywsDOfPn5ekD1lLaN/xR/vOObT/+CsqKkLz5s3RqFEj0V7D09MTubm5qKx0voWcYZg6IcRea8/MmTMxduxYu9uMjIw0/X+TJk3QpEkTtG7dGtHR0QgLC8Ovv/6K2NjYOs8LCgpCZWUlbty4YdHqY6/OloKswcfd3R2dO3dGWloaBg0aBODO4Oa0tDRMnTrV6nNiY2ORlpaG6dOnm5bt3r3b6k4HbDfx+fn50QnACb6+vrT/eKJ9xx/tO+fQ/uPPxUXc7jtPT094ynDBTUBAAAICAng9t6bmTr+c+XASc507d0a9evWQlpaGIUOGAACys7ORl5dns86WguxdXUlJSRgzZgy6dOmCmJgYLF++HKWlpRg3bhwAYPTo0QgNDcWiRYsAANOmTUNcXBzefvtt9O/fH1u2bMGRI0fw/vvvy/k2CCGEEM06ePAgDh8+jB49eqBhw4Y4ffo0Xn31VbRs2dIUYvLz8/HAAw/gww8/RExMDPz8/DB+/HgkJSWhUaNG8PX1xbPPPovY2FjZrugCFBB8hg0bhitXrmDOnDkoKChAx44dsWvXLtMA5ry8PIuk3a1bN2zevBmzZ8/Gyy+/jLvuugvbt2/HPffcI9dbIIQQQjTN29sb27ZtQ0pKCkpLSxEcHIy+ffti9uzZpl6VqqoqZGdno6zs32kmli1bBhcXFwwZMgQVFRVITEzEe++9J9fbAKCAeXykVlFRgUWLFmHWrFmCjXLXE9p//NG+44/2nXNo//FH+057dBd8CCGEEKJf2plsgRBCCCHEAQo+hBBCCNENCj6EEEII0Q0KPoQQQgjRDU0Gn1WrViE8PByenp7o2rUrDh06ZHf9zz//HFFRUfD09ES7du2wc+dOiUqqTFz239q1a3H//fejYcOGaNiwIRISEhzuby3jeuwZbdmyBQaDwTSRpx5x3Xc3btzAlClTEBwcDA8PD7Ru3VrX312u+2/58uVo06YNvLy8EBYWhhkzZqBcgfcwFNtPP/2EAQMGICQkBAaDAdu3b3f4nPT0dNx7773w8PBAq1atsGHDBtHLSQTEaMyWLVsYd3d3Zt26dczJkyeZiRMnMv7+/kxhYaHV9X/++WfG1dWVWbx4MfPnn38ys2fPZurVq8f88ccfEpdcGbjuvxEjRjCrVq1ijh8/zmRlZTFjx45l/Pz8mAsXLkhccvlx3XdGubm5TGhoKHP//fczjzzyiDSFVRiu+66iooLp0qUL89BDDzEHDhxgcnNzmfT0dCYzM1PikisD1/23adMmxsPDg9m0aROTm5vLfP/990xwcDAzY8YMiUsuv507dzKvvPIKs23bNgYA8+WXX9pd/8yZM4y3tzeTlJTE/Pnnn8yKFSsYV1dXZteuXdIUmDhNc8EnJiaGmTJliunv6upqJiQkhFm0aJHV9R9//HGmf//+Fsu6du3KPPPMM6KWU6m47r/abt++zTRo0IDZuHGjWEVULD777vbt20y3bt2YDz74gBkzZoxugw/Xfbd69WomMjKSqayslKqIisZ1/02ZMoXp3bu3xbKkpCSme/fuopZT6dgEnxdffJG5++67LZYNGzaMSUxMFLFkREia6uqqrKzE0aNHkZCQYFrm4uKChIQEZGRkWH1ORkaGxfoAkJiYaHN9LeOz/2orKytDVVWVqDf0UyK++27+/Plo2rQpxo8fL0UxFYnPvvv6668RGxuLKVOmIDAwEPfccw9ef/11VFdXS1VsxeCz/7p164ajR4+ausPOnDmDnTt34qGHHpKkzGpGdYb6yX7LCiFdvXoV1dXVpttdGAUGBuLUqVNWn1NQUGB1/YKCAtHKqVR89l9tL730EkJCQuqcGLSOz747cOAA/ve//yEzM1OCEioXn3135swZ7N27FyNHjsTOnTuRk5OD//73v6iqqkJKSooUxVYMPvtvxIgRuHr1Knr06AGGYXD79m1MmjQJL7/8shRFVjVbdUZxcTFu3boFLy8vmUpG2NJUiw+R1xtvvIEtW7bgyy+/lOUuw2py8+ZNjBo1CmvXrkWTJk3kLo7q1NTUoGnTpnj//ffRuXNnDBs2DK+88gpSU1PlLpoqpKen4/XXX8d7772HY8eOYdu2bdixYwcWLFggd9EIEZ2mWnyaNGkCV1dXFBYWWiwvLCxEUFCQ1ecEBQVxWl/L+Ow/oyVLluCNN97Anj170L59ezGLqUhc993p06dx9uxZDBgwwLSspqYGAODm5obs7Gy0bNlS3EIrBJ/jLjg4GPXq1YOrq6tpWXR0NAoKClBZWQl3d3dRy6wkfPbfq6++ilGjRmHChAkAgHbt2qG0tBRPP/00XnnlFYsbQxNLtuoMX19fau1RCU0d3e7u7ujcuTPS0tJMy2pqapCWlobY2Firz4mNjbVYHwB2795tc30t47P/AGDx4sVYsGABdu3ahS5dukhRVMXhuu+ioqLwxx9/IDMz0/Rv4MCBiI+PR2ZmJsLCwqQsvqz4HHfdu3dHTk6OKSwCwF9//YXg4GBdhR6A3/4rKyurE26MIZKh2zfaRXWGBsg9ulpoW7ZsYTw8PJgNGzYwf/75J/P0008z/v7+TEFBAcMwDDNq1CgmOTnZtP7PP//MuLm5MUuWLGGysrKYlJQU3V/OzmX/vfHGG4y7uzuzdetW5tKlS6Z/N2/elOstyIbrvqtNz1d1cd13eXl5TIMGDZipU6cy2dnZzLfffss0bdqUee211+R6C7Liuv9SUlKYBg0aMJ988glz5swZ5ocffmBatmzJPP7443K9BdncvHmTOX78OHP8+HEGALN06VLm+PHjzLlz5xiGYZjk5GRm1KhRpvWNl7O/8MILTFZWFrNq1Sq6nF1lNBd8GIZhVqxYwTRv3pxxd3dnYmJimF9//dX0WFxcHDNmzBiL9T/77DOmdevWjLu7O3P33XczO3bskLjEysJl/7Vo0YIBUOdfSkqK9AVXAK7Hnjk9Bx+G4b7vfvnlF6Zr166Mh4cHExkZySxcuJC5ffu2xKVWDi77r6qqipk7dy7TsmVLxtPTkwkLC2P++9//MtevX5e+4DLbt2+f1XOYcX+NGTOGiYuLq/Ocjh07Mu7u7kxkZCSzfv16yctN+DMwDLVrEkIIIUQfNDXGhxBCCCHEHgo+hBBCCNENCj6EEEII0Q0KPoQQQgjRDQo+hBBCCNENCj6EEEII0Q0KPoQQQgjRDQo+hOjE3Llz0bFjR7mLYWIwGLB9+3a5i0EI0RkKPoQIKDU1FQ0aNMDt27dNy0pKSlCvXj306tXLYt309HQYDAacPn1a4lJKS8jAtW3bNvTp0weNGzeGwWBAZmamINslhOgHBR9CBBQfH4+SkhIcOXLEtGz//v0ICgrCwYMHUV5eblq+b98+NG/eXDd3YRdCaWkpevTogTfffFPuohBCVIqCDyECatOmDYKDg5Genm5alp6ejkceeQQRERH49ddfLZbHx8cDAD766CN06dIFDRo0QFBQEEaMGIHLly8DuHOn7WbNmmH16tUWr3X8+HG4uLjg3LlzAIAbN25gwoQJCAgIgK+vL3r37o3ffvvNbnk/+OADREdHw9PTE1FRUXjvvfdMj509exYGgwHbtm1DfHw8vL290aFDB2RkZFhsY+3atQgLC4O3tzceffRRLF26FP7+/gCADRs2YN68efjtt99gMBhgMBiwYcMG03OvXr2KRx99FN7e3rjrrrvw9ddf2y3vqFGjMGfOHCQkJNhdjxBCbKHgQ4jA4uPjsW/fPtPf+/btQ69evRAXF2dafuvWLRw8eNAUfKqqqrBgwQL89ttv2L59O86ePYuxY8cCAFxcXDB8+HBs3rzZ4nU2bdqE7t27o0WLFgCAoUOH4vLly/juu+9w9OhR3HvvvXjggQdw7do1q+XctGkT5syZg4ULFyIrKwuvv/46Xn31VWzcuNFivVdeeQXPP/88MjMz0bp1awwfPtzUlffzzz9j0qRJmDZtGjIzM/Hggw9i4cKFpucOGzYMM2fOxN13341Lly7h0qVLGDZsmOnxefPm4fHHH8fvv/+Ohx56CCNHjrRZXkIIEYTcd0klRGvWrl3L1K9fn6mqqmKKi4sZNzc35vLly8zmzZuZnj17MgzDMGlpaQwA5ty5c1a3cfjwYQYAc/PmTYZhGOb48eOMwWAwrV9dXc2EhoYyq1evZhiGYfbv38/4+voy5eXlFttp2bIls2bNGoZhGCYlJYXp0KGDxWObN2+2WH/BggVMbGwswzAMk5ubywBgPvjgA9PjJ0+eZAAwWVlZDMMwzLBhw5j+/ftbbGPkyJGMn5+f6e/ar2sEgJk9e7bp75KSEgYA891331ndJ+aMZTt+/LjDdQkhxBy1+BAisF69eqG0tBSHDx/G/v370bp1awQEBCAuLs40zic9PR2RkZFo3rw5AODo0aMYMGAAmjdvjgYNGiAuLg4AkJeXBwDo2LEjoqOjTa0+P/74Iy5fvoyhQ4cCAH777TeUlJSgcePG8PHxMf3Lzc21Oni6tLQUp0+fxvjx4y3Wf+211+qs3759e9P/BwcHA4CpGy47OxsxMTEW69f+2x7zbdevXx++vr6mbRNCiBjc5C4AIVrTqlUrNGvWDPv27cP169dNISYkJARhYWH45ZdfsG/fPvTu3RvAnRCSmJiIxMREbNq0CQEBAcjLy0NiYiIqKytN2x05ciQ2b96M5ORkbN68GX379kXjxo0B3LlyrPbYIiPjeBtzJSUlAO6Mz+natavFY66urhZ/16tXz/T/BoMBwJ1xR0Iw37Zx+0JtmxBCrKHgQ4gI4uPjkZ6ejuvXr+OFF14wLe/Zsye+++47HDp0CJMnTwYAnDp1Cv/88w/eeOMNhIWFAYDFVWFGI0aMwOzZs3H06FFs3boVqamppsfuvfdeFBQUwM3NDeHh4Q7LFxgYiJCQEJw5cwYjR47k/T7btGmDw4cPWyyr/be7uzuqq6t5vwYhhAiJgg8hIoiPj8eUKVNQVVVlavEBgLi4OEydOhWVlZWmgc3NmzeHu7s7VqxYgUmTJuHEiRNYsGBBnW2Gh4ejW7duGD9+PKqrqzFw4EDTYwkJCYiNjcWgQYOwePFitG7dGhcvXsSOHTvw6KOPokuXLnW2N2/ePDz33HPw8/ND3759UVFRgSNHjuD69etISkpi9T6fffZZ9OzZE0uXLsWAAQOwd+9efPfdd6aWIWO5c3NzkZmZiWbNmqFBgwbw8PBgvS/NXbt2DXl5ebh48SKAO11tABAUFISgoCBe2ySE6AuN8SFEBPHx8bh16xZatWqFwMBA0/K4uDjcvHnTdNk7AAQEBGDDhg34/PPP0bZtW7zxxhtYsmSJ1e2OHDkSv/32Gx599FF4eXmZlhsMBuzcuRM9e/bEuHHj0Lp1azzxxBM4d+6cxeubmzBhAj744AOsX78e7dq1Q1xcHDZs2ICIiAjW77N79+5ITU3F0qVL0aFDB+zatQszZsyAp6enaZ0hQ4agb9++iI+PR0BAAD755BPW26/t66+/RqdOndC/f38AwBNPPIFOnTpZtH4RQog9BoZhGLkLQQjRjokTJ+LUqVPYv3+/3EUhhJA6qKuLEOKUJUuW4MEHH0T9+vXx3XffYePGjRYTIRJCiJJQiw8hxCmPP/440tPTcfPmTURGRuLZZ5/FpEmT5C4WIYRYRcGHEEIIIbpBg5sJIYQQohsUfAghhBCiGxR8CCGEEKIbFHwIIYQQohsUfAghhBCiGxR8CCGEEKIbFHwIIYQQohsUfAghhBCiGxR8CCGEEKIb/wetiDsx5iQu3QAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "N5Wttj_vVs_1"
      },
      "outputs": [],
      "source": [
        "# #Save kernel\n",
        "# #This kernels is for inputs with nxdim, where each row is [[0-2150], [0,2150], taskid]\n",
        "# if not smoke_test:\n",
        "#   #save mixed kernel\n",
        "#   torch.save(model.covar_module, f'{base_path}/kernel/mixedKernel.csv')\n",
        "\n",
        "#   #check that it loads\n",
        "#   temp = torch.load(f'{base_path}/kernel/mixedKernel.csv')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "rhUYmp1tgXSp"
      },
      "outputs": [],
      "source": [
        "# #load model and results, requires inputting data\n",
        "# model_N = option_n[-1] # num training data in desired model\n",
        "\n",
        "# #re-load model here\n",
        "# state_dict = torch.load(f'{base_path}/models/vanilla_gp_mixed_{model_N}.pth')\n",
        "# x_train_normalized, y_train_standardized = mergeData(train_data.values(), N=10)\n",
        "# model = MixedSingleTaskGP(x_train_normalized[:model_N], y_train_standardized[:model_N], cat_dims=[-1])  # Create a new GP model\n",
        "# model.load_state_dict(state_dict)\n",
        "\n",
        "# #re-load your results\n",
        "# with open(f'{base_path}/results/vanillaGP_mixed.pkl', 'rb') as pickle_file:\n",
        "#     results = pickle.load(pickle_file)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "gMN6UzWtalnP"
      },
      "outputs": [],
      "source": [
        "# #plot training and validation loss\n",
        "# for task in tasks:\n",
        "#   task_dic = results[task]\n",
        "\n",
        "#   # Create a line plot\n",
        "#   plt.plot(option_n, task_dic[\"val_loss\"], label = f\"{task} val_loss\", linestyle=\"--\")\n",
        "#   plt.plot(option_n, task_dic[\"train_loss\"], label = f\"{task} train_loss\", linestyle=\"solid\")\n",
        "\n",
        "# # Add labels and title\n",
        "# plt.xlabel('N points')\n",
        "# plt.ylabel('MSE Loss')\n",
        "# plt.title('Samples vs Loss')\n",
        "# plt.legend()\n",
        "\n",
        "# # Show the plot\n",
        "# plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "ByUybHE_oj85"
      },
      "outputs": [],
      "source": [
        "# #load model and results, requires inputting data\n",
        "# model_N = option_n[-1] # num training data in desired model\n",
        "\n",
        "# # #re-load model here\n",
        "# # state_dict = torch.load(f'{base_path}/models/vanilla_gp_mixed_{model_N}.pth')\n",
        "# # x_train_normalized, y_train_standardized = mergeData(train_data.values(), N=10)\n",
        "# # model = MixedSingleTaskGP(x_train_normalized[:model_N], y_train_standardized[:model_N], cat_dims=[-1])  # Create a new GP model\n",
        "# # model.load_state_dict(state_dict)\n",
        "\n",
        "# for task in tasks:\n",
        "#   def modelWrapper(X):\n",
        "#     id = getTaskID(task)\n",
        "#     id_vector = id * torch.ones((X.shape[0],1))\n",
        "#     inp = torch.cat([X, id_vector], dim=1)\n",
        "#     return model.posterior(inp).mean\n",
        "\n",
        "#   surfacePlot(modelWrapper, title=f\"GP for task {task}, {model_N} points\", n=100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "YDp3_O91M_PY"
      },
      "outputs": [],
      "source": [
        "#Make a barplot here...\n",
        "\n",
        "#single task test,\n",
        "#single task train\n",
        "#single task test\n",
        "#single task test\n",
        "\n",
        "#should technically have varience plot(s)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNXAmmDAJsTNVbVzDdzNxeG",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}