{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 基于KNO求解一维Burgers\n",
    "\n",
    "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindflow/zh_cn/data_driven/mindspore_burgers_KNO1D.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindflow/zh_cn/data_driven/mindspore_burgers_KNO1D.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/master/docs/mindflow/docs/source_zh_cn/data_driven/burgers_KNO1D.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 概述\n",
    "\n",
    "计算流体力学是21世纪流体力学领域的重要技术之一，其通过使用数值方法在计算机中对流体力学的控制方程进行求解，从而实现流动的分析、预测和控制。传统的有限元法（finite element method，FEM）和有限差分法（finite difference method，FDM）常用于复杂的仿真流程（物理建模、网格划分、数值离散、迭代求解等）和较高的计算成本，往往效率低下。因此，借助AI提升流体仿真效率是十分必要的。\n",
    "\n",
    "近年来，随着神经网络的迅猛发展，为科学计算提供了新的范式。经典的神经网络是在有限维度的空间进行映射，只能学习与特定离散化相关的解。与经典神经网络不同，傅里叶神经算子（Fourier Neural Operator，FNO）是一种能够学习无限维函数空间映射的新型深度学习架构。该架构可直接学习从任意函数参数到解的映射，用于解决一类偏微分方程的求解问题，具有更强的泛化能力。更多信息可参考[Fourier Neural Operator for Parametric Partial Differential Equations](https://arxiv.org/abs/2010.08895)。\n",
    "\n",
    "但是这类神经算子在学习非线性PDE的长期行为时，变得不够准确和缺乏可解释性。库普曼神经算子（Koopman neural operator，KNO）通过构建方程解的非线性动力学系统，克服了这一问题。通过近似Koopman算子，一个控制动力学系统所有可能观测的无限维线性算子，作用于动力学系统的流映射，我们可以通过求解简单的线性预测问题等价地学习整个非线性PDE族的解。更多信息可参考：\n",
    "\n",
    "- \"[Koopman neural operator as a mesh-free solver of non-linear partial differential equations](https://arxiv.org/abs/2301.10022).\" arXiv preprint arXiv:2301.10022 (2023).\n",
    "- \"[KoopmanLab: machine learning for solving complex physics equations](https://arxiv.org/abs/2301.01104).\" arXiv preprint arXiv:2301.01104 (2023).\n",
    "\n",
    "本案例教程介绍利用库普曼神经算子的1-d Burgers方程求解方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 伯格斯方程（Burgers' equation）\n",
    "\n",
    "一维伯格斯方程（1-d Burgers' equation）是一个非线性偏微分方程，具有广泛应用，包括一维粘性流体流动建模。它的形式如下：\n",
    "\n",
    "$$\n",
    "\\partial_t u(x, t)+\\partial_x (u^2(x, t)/2)=\\nu \\partial_{xx} u(x, t), \\quad x \\in(0,1), t \\in(0, 1]\n",
    "$$\n",
    "\n",
    "$$\n",
    "u(x, 0)=u_0(x), \\quad x \\in(0,1)\n",
    "$$\n",
    "\n",
    "其中$u$表示速度场，$u_0$表示初始条件，$\\nu$表示粘度系数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 问题描述\n",
    "\n",
    "本案例利用Koopman Neural Operator学习初始状态到下一时刻状态的映射，实现一维Burgers'方程的求解：\n",
    "\n",
    "$$\n",
    "u_0 \\mapsto u(\\cdot, 1)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 技术路径\n",
    "\n",
    "MindSpore Flow求解该问题的具体流程如下：\n",
    "\n",
    "1. 创建数据集。\n",
    "2. 构建模型。\n",
    "3. 优化器与损失函数。\n",
    "4. 模型训练。\n",
    "5. 模型推理和可视化。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Koopman Neural Operator\n",
    "\n",
    "Koopman Neural Operator模型构架如下图所示，包含上下两个主要分支和对应输出。图中Input表示初始涡度，上路分支通过Encoding Layer实现输入向量的高维映射，然后将映射结果作为Koopman Layer的输入，进行频域信息的非线性变换，最后由Decoding Layer将变换结果映射至最终的预测结果Prediction。同时，下路分支通过Encoding Layer实现输入向量的高维映射，然后通过Decoding Layer对输入进行重建。上下两个分支的Encoding Layer之间共享权重，Decoding Layer之间也共享权重。Prediction用于和Label计算预测误差，Reconstruction用于和Input计算重建误差。两个误差共同指导模型的梯度计算。\n",
    "\n",
    "Encoding Layer、Koopman Layer、Decoding Layer以及两分支共同组成了Koopman Neural Operator。\n",
    "\n",
    "Koopman Layer结构如虚线框所示，可重复堆叠。向量经过傅里叶变换后，再经过线性变换，过滤高频信息，然后进行傅里叶逆变换；输出结果与输入相加，最后通过激活函数，得到输出向量。\n",
    "\n",
    "![Fourier Layer网络结构](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/docs/mindflow/docs/source_zh_cn/data_driven/images/kno.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import datetime\n",
    "import numpy as np\n",
    "\n",
    "import mindspore\n",
    "from mindspore import nn, context, ops, Tensor, set_seed\n",
    "from mindspore.nn.loss import MSELoss\n",
    "\n",
    "from mindflow.cell import KNO1D\n",
    "from mindflow.common import get_warmup_cosine_annealing_lr\n",
    "from mindflow.utils import load_yaml_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "下述`src`包可以在[applications/data_driven/burgers/kno1d/src](https://gitee.com/mindspore/mindscience/tree/master/MindFlow/applications/data_driven/burgers/kno1d/src)下载。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pid: 9647\n",
      "2023-03-04 08:03:20.885806\n"
     ]
    }
   ],
   "source": [
    "from src.dataset import create_training_dataset\n",
    "from src.trainer import BurgersWithLoss\n",
    "from src.utils import visual\n",
    "\n",
    "set_seed(0)\n",
    "np.random.seed(0)\n",
    "\n",
    "print(\"pid:\", os.getpid())\n",
    "print(datetime.datetime.now())\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=1)\n",
    "use_ascend = context.get_context(attr_key='device_target') == \"Ascend\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "从[config](https://gitee.com/mindspore/mindscience/blob/master/MindFlow/applications/data_driven/burgers/kno1d/configs/kno1d.yaml)中获得模型、数据、优化器的超参。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "config = load_yaml_config('kno1d.yaml')\n",
    "data_params = config[\"data\"]\n",
    "model_params = config[\"model\"]\n",
    "optimizer_params = config[\"optimizer\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 创建数据集\n",
    "\n",
    "下载训练与测试数据集: [data_driven/burgers/dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/data_driven/burgers/dataset/)。\n",
    "\n",
    "本案例根据Zongyi Li在 [Fourier Neural Operator for Parametric Partial Differential Equations](https://arxiv.org/pdf/2010.08895.pdf) 一文中对数据集的设置生成训练数据集与测试数据集。具体设置如下：\n",
    "基于周期性边界，生成满足如下分布的初始条件$u_0(x)$：\n",
    "\n",
    "$$\n",
    "u_0 \\sim \\mu, \\mu=\\mathcal{N}\\left(0,625(-\\Delta+25 I)^{-2}\\right)\n",
    "$$\n",
    "\n",
    "本案例选取粘度系数$\\nu=0.1$，并使用分步法求解方程，其中热方程部分在傅里叶空间中精确求解，然后使用前向欧拉方法求解非线性部分。训练集样本量为1000个，测试集样本量为200个。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data preparation finished\n",
      "input_path:  (1000, 1024, 1)\n",
      "label_path:  (1000, 1024)\n",
      "Data preparation finished\n",
      "input_path:  (200, 1024, 1)\n",
      "label_path:  (200, 1024)\n"
     ]
    }
   ],
   "source": [
    "# create training dataset\n",
    "train_dataset = create_training_dataset(data_params, shuffle=True)\n",
    "\n",
    "# create test dataset\n",
    "eval_dataset = create_training_dataset(\n",
    "    data_params, shuffle=False, is_train=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 构建模型\n",
    "\n",
    "网络由1层共享的Encoding Layer、多层Koopman Layer以及1层共享的Decoding Layer叠加组成：\n",
    "\n",
    "- Encoding Layer对应样例代码中`KNO1D.enc`，将输出数据映射至高维；\n",
    "- Koopman Layer对应样例代码中`KNO1D.koopman_layer`，本案例采用离散傅里叶变换实现时域与频域的转换；\n",
    "- Decoding Layer对应代码中`KNO1D.dec`，获得最终的预测值。\n",
    "\n",
    "基于上述网络结构，进行模型初始化，其中模型超参可在配置文件中修改。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name:KNO1D_channels:32_modes:64_depths:4_resolution:1024\n"
     ]
    }
   ],
   "source": [
    "model = KNO1D(in_channels=data_params['in_channels'],\n",
    "              channels=model_params['channels'],\n",
    "              modes=model_params['modes'],\n",
    "              depths=model_params['depths'],\n",
    "              resolution=model_params['resolution']\n",
    "              )\n",
    "\n",
    "model_params_list = []\n",
    "for k, v in model_params.items():\n",
    "    model_params_list.append(f\"{k}:{v}\")\n",
    "model_name = \"_\".join(model_params_list)\n",
    "print(model_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 优化器与损失函数\n",
    "\n",
    "使用均方误差作为训练的损失函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train_size = train_dataset.get_dataset_size()\n",
    "eval_size = eval_dataset.get_dataset_size()\n",
    "\n",
    "lr = get_warmup_cosine_annealing_lr(lr_init=optimizer_params[\"lr\"],\n",
    "                                    last_epoch=optimizer_params[\"epochs\"],\n",
    "                                    steps_per_epoch=train_size,\n",
    "                                    warmup_epochs=1)\n",
    "optimizer = nn.AdamWeightDecay(model.trainable_params(),\n",
    "                               learning_rate=Tensor(lr),\n",
    "                               weight_decay=optimizer_params[\"weight_decay\"])\n",
    "model.set_train()\n",
    "loss_fn = MSELoss()\n",
    "if use_ascend:\n",
    "    from mindspore.amp import DynamicLossScaler, auto_mixed_precision, all_finite\n",
    "    loss_scaler = DynamicLossScaler(1024, 2, 100)\n",
    "    auto_mixed_precision(model, 'O3')\n",
    "else:\n",
    "    loss_scaler = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 模型训练\n",
    "\n",
    "使用**MindSpore>= 2.0.0**的版本，可以使用函数式编程范式训练神经网络。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./summary_dir/name:KNO1D_channels:32_modes:64_depths:4_resolution:1024\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1, time cost: 18.375901, recons loss: 0.295517, pred loss: 0.085093\n",
      "epoch: 2, time cost: 2.577698, recons loss: 0.161718, pred loss: 0.002227\n",
      "epoch: 3, time cost: 2.564470, recons loss: 0.027144, pred loss: 0.000992\n",
      "epoch: 4, time cost: 2.547690, recons loss: 0.000782, pred loss: 0.000511\n",
      "epoch: 5, time cost: 2.532924, recons loss: 0.000057, pred loss: 0.000279\n",
      "epoch: 6, time cost: 2.536904, recons loss: 0.000048, pred loss: 0.000241\n",
      "epoch: 7, time cost: 2.527330, recons loss: 0.000048, pred loss: 0.000213\n",
      "epoch: 8, time cost: 2.536032, recons loss: 0.000048, pred loss: 0.000227\n",
      "epoch: 9, time cost: 2.462490, recons loss: 0.000048, pred loss: 0.000230\n",
      "epoch: 10, time cost: 2.564090, recons loss: 0.000049, pred loss: 0.000229\n",
      "---------------------------start evaluation-------------------------\n",
      "Eval epoch: 10, recons loss: 4.7733558130858e-05, relative pred loss: 0.01156728882342577\n",
      "---------------------------end evaluation---------------------------\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 91, time cost: 2.662080, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 92, time cost: 2.604443, recons loss: 0.000042, pred loss: 0.000007\n",
      "epoch: 93, time cost: 2.576527, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 94, time cost: 2.621569, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 95, time cost: 2.578712, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 96, time cost: 2.607216, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 97, time cost: 2.588060, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 98, time cost: 2.911451, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 99, time cost: 2.542502, recons loss: 0.000042, pred loss: 0.000006\n",
      "epoch: 100, time cost: 2.514851, recons loss: 0.000042, pred loss: 0.000006\n",
      "---------------------------start evaluation-------------------------\n",
      "Eval epoch: 100, recons loss: 4.17057997037773e-05, relative pred loss: 0.004054672718048095\n",
      "---------------------------end evaluation---------------------------\n"
     ]
    }
   ],
   "source": [
    "problem = BurgersWithLoss(model, data_params[\"out_channels\"], loss_fn)\n",
    "\n",
    "def forward_fn(inputs, labels):\n",
    "    loss, l_recons, l_pred = problem.get_loss(inputs, labels)\n",
    "    if use_ascend:\n",
    "        loss = loss_scaler.scale(loss)\n",
    "    return loss, l_recons, l_pred\n",
    "\n",
    "grad_fn = ops.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)\n",
    "\n",
    "def train_step(inputs, labels):\n",
    "    (loss, l_recons, l_pred), grads = grad_fn(inputs, labels)\n",
    "    if use_ascend:\n",
    "        loss = loss_scaler.unscale(loss)\n",
    "        if all_finite(grads):\n",
    "            grads = loss_scaler.unscale(grads)\n",
    "    loss = ops.depend(loss, optimizer(grads))\n",
    "    return loss, l_recons, l_pred\n",
    "\n",
    "def eval_step(inputs, labels):\n",
    "    return problem.get_rel_loss(inputs, labels)\n",
    "\n",
    "train_sink = mindspore.data_sink(train_step, train_dataset, sink_size=1)\n",
    "eval_sink = mindspore.data_sink(eval_step, eval_dataset, sink_size=1)\n",
    "\n",
    "summary_dir = os.path.join(config[\"summary_dir\"], model_name)\n",
    "os.makedirs(summary_dir, exist_ok=True)\n",
    "print(summary_dir)\n",
    "\n",
    "for epoch in range(1, optimizer_params[\"epochs\"] + 1):\n",
    "    time_beg = time.time()\n",
    "    l_recons_train = 0.0\n",
    "    l_pred_train = 0.0\n",
    "    for _ in range(train_size):\n",
    "        _, l_recons, l_pred = train_sink()\n",
    "        l_recons_train += l_recons.asnumpy()\n",
    "        l_pred_train += l_pred.asnumpy()\n",
    "    l_recons_train = l_recons_train / train_size\n",
    "    l_pred_train = l_pred_train / train_size\n",
    "    print(f\"epoch: {epoch}, time cost: {(time.time() - time_beg):>8f},\"\n",
    "          f\" recons loss: {l_recons_train:>8f}, pred loss: {l_pred_train:>8f}\")\n",
    "\n",
    "    if epoch % config['eval_interval'] == 0:\n",
    "        l_recons_eval = 0.0\n",
    "        l_pred_eval = 0.0\n",
    "        print(\"---------------------------start evaluation-------------------------\")\n",
    "        for _ in range(eval_size):\n",
    "            l_recons, l_pred = eval_sink()\n",
    "            l_recons_eval += l_recons.asnumpy()\n",
    "            l_pred_eval += l_pred.asnumpy()\n",
    "        l_recons_eval = l_recons_eval / eval_size\n",
    "        l_pred_eval = l_pred_eval / eval_size\n",
    "        print(f'Eval epoch: {epoch}, recons loss: {l_recons_eval},'\n",
    "              f' relative pred loss: {l_pred_eval}')\n",
    "        print(\"---------------------------end evaluation---------------------------\")\n",
    "        mindspore.save_checkpoint(model, ckpt_file_name=summary_dir + '/save_model.ckpt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 模型推理和可视化\n",
    "\n",
    "取6个样本做连续10步预测，并可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAHWCAYAAADO2QWWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACO6ElEQVR4nO29f5gcxX3n/57pnu7ZlXZXCP1YFq2Q7BjJxoCIhDZy4Jzn0FkQP77A+XxYp9hC4ez8sPAPGZ+l+MsPnR9HOHFiYUPMJRdD7LMjcC72JcSnPCDwT4SEZWEjbGTAYK2QVoBkaVda7cx2T3//6K6e6prqnp7Z2Zmd1fv1PP101ac+VV1d0z9qqj+fqozneR4IIYQQQsiUJ9vqChBCCCGEkHSw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0iaw40YIIYQQ0ia0vON27733YtGiRcjn8xgYGMDevXtbXSVCCCGEkClJppVrlT744IN4//vfj/vuuw8DAwPYvn07vvGNb+DgwYOYN29e1fylUglHjhxBV1cXMplME2pMCCGETE08z8PIyAj6+vqQzTZnXGZsbAzFYrFh5VmWhXw+37DypiMt7bgNDAzgyiuvxD333APA74j19/fjlltuwebNm6vmP3z4MPr7+ye7moQQQkjbMDg4iAULFkz6ccbGxjC3owOnG1hmb28vXnrpJXbeEjBbdeBisYh9+/Zhy5YtoSybzWL16tXYvXu3Nk+hUEChUAjjos/5+OCFyHXbcGFiHBYcGHBhwkUWRVhwpbgLAw4MlGCiCAsA4CIb5inBCGS+nsCV5LViwK0Im0GtACAb7A04MMNwCYakY6EQ5vfTnDBdlplwkUMxCPtl5FCQzs6Pm64Lw3FhOB7sApBxATgACgDcYO8AKAZ7kSbSHSld6OryJaWNBXJX0S3FpAd7zwUcFzg7BjgO4JT8th0NVMYD9fGgzVWZK6WJvSNtqhwxaWp6I1BvSBHPKXFTSTOlLRdsRrDvCMIdAPJClgW6ZgI5C4ANoBNAd6DQCWAGgPMCWXcQnwNgNoAeP22sFzg1oxun0INXMQ8ncB5OYRaOYzaG0IvjOB+n0IMTmI0hXIATZ2bjzPEe4NUc8AqAYwCOAzgBP35K2o7Bvx4wDmAEwKsAzgI4HcTPwm/1s/AvFPHrpv1F5JbUtaAId2haMx+kicbKS7rByL8diGYEyTaAmUEx+WCbIenlFV01rxnkt6XDzQBge0C+ADNfhG0XYeWLyBkFdGIMWTiwUYSFIjpwFgZc2CgihyI6g3gOBdgYRwdGYaEIAyVYKKADZwPdAky46MAYrOA50oGzoa6NAvIYhYkSLBSRhYNOjMGAC8stwHBcWGMecvLzQL7/Syjf5wVUPgdEmvoMkZ8TDiqeEZFnFCRdaPYyrhRWH/WmEhbxrBI3pN/MCPaWpKOm56V0kWZL+p2VaZ4BFGzANTMo2Fb4Pjs5DKzq/zW6uro0J9d4isUiTgP4RFC1iVIA8BdDQygWi+y4JdCyjtvrr78O13Uxf/78iHz+/Pl47rnntHm2bduGrVu3VshndmeR6/a7L0WlS5ODKXXkjLBD5sKEEbwOZZncQYt23MxQXivRjpv/tJA7buV9Vuq4uTCQhRGYIdoohTpGUAsTGRjh5sKAFzwjjDBswIOFbBD3YCADCxmYbgaGkyl33MRDzgr2OUQfog7KDw/5oWjAf3CJeEbai6YyApkX6HpBuhvExVduV9p7Un45XxbwSoCTAXIZYDxTfv6Kw6gdN1Ump+l0gPKNIXfW5ONAk94Icko8ruOW04TlvRzuQLlbIbohHRmgOwPksvDbVrxg5AJEp050NESHbgaAmYDVDZRmZOAiizMwMIYcisghDws28rDQgRw6YWIGspiJjNEFFLuBMzm/LNEHsqQKi+sptHwQLTsaJHrwL5AMKrvQ4goAqv8icovqWlBuPTUut2inEg8qngk2uX3lNhbFiRe2aGu5YybaR8Q7lfhMAHm/45bJF5EJ9lnDQhZm8AQrwkABZvDcMGEiBzPoirqwkIUFAzZKwXPCDarg7y14QcfNhY0SDGTRiXFYwZ9AGwY6YASnkA3S/WeSHTxjLMtDTjxHLJSfKWbwUxrSXv4Zxc8sP28yUljkUfNnUX62iK+Foixo9jLy18W0HTdDE1c7bnJHTHTW5LDakZP1Z1SmeabcccvARQZFZOAEJ9Vs0yFx2ZLm0HLnhFrYsmULTp06FW6Dg4OtrhIhhBByTpNr4Eaq07IRtzlz5sAwDBw7diwiP3bsGHp7e7V5bNuGbVcOyF5YOIzuQgauacAx4kfOyp9Mo589y+nRUTV1dM1R4m4NzWeEIwFlTLiKTuUnVTlfdDQumq77BCvGF003iDtiX4LhAGZwuIz8D1Yg/+MT6TMQfL6S9NVvjLJM/Vwh59WlJ+WVZBknuMnV47ua8pPi6nFRqecF8qDpMC7ijhKX2k4e66l1JC6n7E0DyAWXmWn6YdMAMuK3UT+riM9vefj/0HtQ/gffE+yDEbPwE+jMYD/b34/PAEZ68jiJWRhBF86iEyPoCuOjFfGOiO4oOnESszCKTpw904HR050onZzhf+UcCzYAmBXUbQ6ARVKaI+2dHOCcH2yI/m5QwjpMZS/C6jdndUtKk7d8PXoeYDrI5oswTBeG6cA0XRimC8sWZg6yGYT/yTO8nwO5hbKuHFbT/HhBKdONzeuPpBUqdMtNbsAf13fhwkABdiT/SHCjm4YLw3Bh2cJUQ5h9FCPPJWvMv0sMB/7InPhdk54PKe7dcC/rQpMOTboOdTheh/yKUK85OV29xkSaLBe6ch2D+yIDIG8CMEqYYY7BC/Llz1Q5BzItaNmIm2VZWL58OXbt2hXKSqUSdu3ahVWrVrWqWoQQQgipgTT/XdJupDotbadNmzZh/fr1WLFiBVauXInt27fjzJkz2LBhQyurRQghhJCUCJPNiVJtAJ34tLTjduONN+K1117D7bffjqGhISxbtgw7d+6scFgghBBCCCFTYGRy48aN2LhxY6urQQghhJA6aNRnzpZ3SNqEadFOnWc8dBoegBIcwzd0daUzc82sFC5bjzpGsrNB3NQf9UwJUg1DYxmryiKOCq7kyODI4ZIUFrrlMjKqUa7OmFeWA5VXiYuy04KNeENhsU86Rhq9uLS0Mt15JZ2vlCac6nOBLKfqqnl06O4y1YhZZ5QsTx8gOyOo0wrYUpoaF3OBGSjPA2b7DghnZ+ZQMPyZvgqwMIIuFGGjAAtF2EHcQgE2zqIDo+gM0/y9FVTTRSfOwoSLLoygCBuzcNKfQ3GGgcIMG8X5fjnC1L0AG65rwHUMFMYsuI4J1zFQcgzAMQAnaBAnE/9b6n6DpCeazlg83AfzkJvRmyYb7IUTAYDQkSCUG9F5GCucgyQjf1UvTjc5f6VcnWYo6XjR+SKTZPH1rXTUEq4KTvh8FPoF6TqR5TD8so0ZbmUapKmTJOcq8XxTn20VzzW/UlGZet3o7nlUkaVJT/NWVXXUeLWpSJR6ZIJrP9e4BQxqolEeofxUmo62mg6EEEIIIeRcZlqMuBFCCCGkNfBTaXNhOxFCCCGkbhrlVdqoFWimO/xUSgghhBDSJky7ETdhrCob5DuSwT4gh8v9e7fOlpAdH5IwInVIo6+XmxrD+Iyqm2SEq6bHzRyeNDu9WBtQZ2CrzgyuKyfJgFgO1zLTuS49aVb0am0mU21GdaDSmBiINyhOM3u66pSgrnOpWwNRjkfWM8yiYPtOBb5jgAUXZuh4IGRJ6X7V/EXKRdiEC7HGr3BwECuTyGF1jeAwbhiAAbh2WeY3t7zaiRnKyj9HZWOrxvLRnyH+B9StVuKHJUcgjU7l3ono6tLj0/Q6urJ1eXXHrpY3OU98XhX1txBOCrr8xRraS9YRzh+m4QJ29d8sjeOWH4+eS6pnq6CVVvRT8K3NT6XNhSNuhBBCCCFtAju4hBBCCKmbRk0HwkXm08GOGyGEEELqhh235sJPpYQQQgghbcI5MeKmMzqtR0dLoTang1hjV5Vqekn1TTsLeDWD/aR6CJtknZMCUF5ZQV0hIKnsiThZpJHryqiVak4Ialx1RBBhU5OuOijIctVRIUgbt/2ga5adEIQDAIDASUBxCpAcClSHAdXYXBh8WyiGc+NbKGjL08UBROR+PJoGAHHOCElOCUkOCfWgc2KoXL1kYs4Msq5qmK/T15VbzTEijU6cg0QaXYEDA2ZwTRjKXkX8VuUy/bjOYaGsZ1Vpf0dbL9OQdKSw6tigHhOIOjZE9JxKeTWHszgHsyTqfg8FeI1f1CcVdE5oLmwnQgghhNRNo+ZxY4ckHfxUSgghhBDSJtTccTt06BA8z6uQe56HQ4cO1VTWnXfeiUwmE9mWLl1aa5UIIYQQ0iLMBm6kOjW30+LFi3H06FHMmzcvIj9x4gQWL14MN8ZGII5LLrkEjz76aLlCZu0/nWP4WxwTtRsAarBNU6klX9p6ViszLr1Wuzgd6sS6STYV8k/poPJqs5Xj2kp6Lb9bIybETLr06plgV5brdOPs2wKZF8gcozxBtGtm4ZqBXZhRaUvmhLZqZVuxOLszVVZ5ymI61fJEu3KZsn2azjYtjU2bSJfTksJqXhm3AY991eZJplYbODVeYU8Vay+X3nYuTj+dbn35khB2bnJY/C4GnES7xGjech6BsKcr10kOl+tXRGVb6+ov7OhknaJSvTBfhdypfF4h3kYO0NvJRdNLNU0Er7OhS3oPkulDzU86z/OQyWQq5KdPn0Y+n6+9AqaJ3t7emvMRQgghpPVwOpDmkrrjtmnTJgBAJpPBbbfdhs7OzjDNdV3s2bMHy5Ytq7kCzz//PPr6+pDP57Fq1Sps27YNCxcu1OoWCgUUCoUwPjw8XPPxCCGEENI46FXaXFK30/79+wH4I27PPPMMLKs8xGxZFi6//HLceuutNR18YGAADzzwAJYsWYKjR49i69atuPrqq3HgwAF0dXVV6G/btg1bt26t6RiEEEIIIdOF1B23xx9/HACwYcMG3H333eju7p7wwa+77rowfNlll2FgYAAXXXQRHnroIdx8880V+lu2bAlH/gB/xK2/v3/C9SCEEEJIfXA6kOZSczvdf//9k1EPAMCsWbNw8cUX44UXXtCm27YN2660CPUnH/XDtRhsNsJpQUsrHBLS6BgJx1OdDlS5epy4K0d1SJCPrUP+OSfr96hWB5m4yYST4nGTDKsOB5LMk/TE9Skm0RW4pgHHSJ6YVjgjCB19etSpQMh1qAbrLswgl29mLueNq1MaB4QkhwPVyUDVjXOm0JU1EXTOCDJxBvs6uc7pQS2/uqNDOueGavF6y4lzlEgizuGgnt/IvxbLdRATAIvjyPWtjJevKVFG1NHBraiT6gyhK79CblQ+QMTxxL0clq84MginozBfFWcG16ycBLgW54ZGwk+lzWVKzeN2+vRpvPjii7jgggtaXRVCCCGEkClHSztut956K7773e/i5ZdfxhNPPIEbbrgBhmFg7dq1rawWIYQQQlKSa+BGqtPSkcnDhw9j7dq1OH78OObOnYurrroKTz75JObOndvKahFCCCEkJfxU2lxa2k47duxo5eEJIYQQQtqKadHBdc0MXDNTdeZp1XFB57QQ57DgKeUmrqQQZ6CvrVSwr2brG+c8EHfcON04m2Bx/DRXRJq6pC1rMql2/Li2SOOgEOeQAL3jARBd/aAsK6+CAESNqHWG/LIzgqwf5xigW5VAxQiMsOW9CJuB0bZwVPD1RVnFREeEuHPQxVXD8GoOCmnTJptqKwokpadxWIgro5ozgq78+lZ+qL2MiVCrk0GjHFFUxwdxbPXcxPHUdtDpVktzjcpj1oLhuJFnCQC4pgegcknKyYZepc1lSjknEEIIIYSQeNjBJYQQQkjdcMmr5sKOGyGEEELqhs4JzYWfSgkhhBBC2oRp1cFVDTWB6MzScY4LstNC2lUWVGcFIMZhIW7lgYpK6I9bYdNa7ReTy57sX7d1NuGVVDvXpHTdeWj01d9cvVbk60vngFDOF+9coIbLTgbpjf9VxwQdqtNBshF9paOCKF/kMyKNWNTWR1d/9Tzi4mnT4o45GaRdPQCYqBND3AoN6Zwb4sqod4WH2sqr3kbyCggC1aBfdVLwZeWVGOSy5DqrqyOosqjcVOSO9lpLu8qCrB9XTtw9asCpWGkhcjzXrXiuAMI5oX6Hh3oxDSCXaUA5HiZ/BZ1pwLTquBFCCCGkuZgmYLLj1jT4qZQQQgghpE3giBshhBBC6ibXoE+lueZPQdeWsONGCCGEkLpp6KdSUpVp0XFzTQOuctUYTmBwqnFY8NMb77Sgc1gQZGpxGpB109pY17LygY5aVnuYTOqpf5o2iik37jdLcjwoy9RZy6s7IZTjyc4Ier1Kp4Rq+VVkQ+kkZ4Ok/OKYwgBcLkNXjgXVILwYa8gdV/8kR4uonhEes9XUsqJAtRn0qzlCxDswpHdsSDpW7eVP3KEiLbpVD3QrHOgcFWS5Wmd1lYakcnTOCjp9OU+cw4J67Gi6Xw+d44Lp0jjsXGFadNwIIYQQ0hpyBpBrgMV8rlRdh9A5gRBCCCGkbeCIGyGEEELqx0BjhoEaYCd3LtDWHTfP8y0ZR4YrLRoNJ9nK0Uhhx5VGR52YN45MLeYH9diYNdK84VyycYvJm87GzUuMO0Y5XoKiK8XlsIOSold+kpWkNFkuh+WfLqpTRj5CnH5SHaunVeJWnJf+m4h6/gK1/eKIK7cV1GLjlp00Gzd9eyTZuNUykW7tx63Ujzu3bAPqYcbWo1IeV2e/LunL8Y8bf70adab59YhPN10vfBeKd2PTMNGYjtvUuX2nNG3dcRsZGQEAvGURjTJJK1AfjurLUI4XJrkuhBDiMzIygp6enlZXg0wSbd1x6+vrw+DgILq6upDJcIyVEELIuYvneRgZGUFfX19zD9ziEbd7770Xf/EXf4GhoSFcfvnl+OIXv4iVK1dqdf/2b/8WX/nKV3DgwAEAwPLly/Fnf/ZnsfpTkbbuuGWzWSxYsKDV1SCEEEKmBC0ZaWthx+3BBx/Epk2bcN9992FgYADbt2/HmjVrcPDgQcybN69C/zvf+Q7Wrl2Lt73tbcjn8/jsZz+Ld7zjHXj22Wdx4YUXNuAkJp+M1/SP4YQQQghpd4aHh9HT04NTi4DuBnTchktAz8vAqVOn0N3dnSrPwMAArrzyStxzzz0AgFKphP7+ftxyyy3YvHlz1fyu6+K8887DPffcg/e///0TqX7T4HQghBBCCKmfLHwnsYluQY9keHg4shUKehvhYrGIffv2YfXq1eWqZLNYvXo1du/enarqo6OjGB8fx+zZs2s86dbBjhshhBBC6sds4Aagv78fPT094bZt2zbtYV9//XW4rov58+dH5PPnz8fQ0FCqqn/yk59EX19fpPM31WlrGzdCCCGETC8GBwcjn0pt256U49x1113YsWMHvvOd7yCfz0/KMSYDdtwIIYQQUj8m0q+rnUQwOUR3d3cqG7c5c+bAMAwcO3YsIj927Bh6e3sT837uc5/DXXfdhUcffRSXXXZZ3VVuBfxUSgghhJC2w7IsLF++HLt27QplpVIJu3btwqpVq2Lz/fmf/zk+/elPY+fOnVixYkUzqtpQOOJGCCGEkPoRzgUtYNOmTVi/fj1WrFiBlStXYvv27Thz5gw2bNgAAHj/+9+PCy+8MLST++xnP4vbb78dX//617Fo0aLQFm7mzJmYOXNma06iRthxI4QQQkj9NPhTaS3ceOONeO2113D77bdjaGgIy5Ytw86dO0OHhUOHDiGbLX9c/NKXvoRisYj//J//c6ScO+64A3feeedEat80OI8bIYQQQmomnMftCqC7AR23YRfo2V/bPG7nIhxxI4QQQkj9GGBvoomwqQkhhBBSP42yceP3v1TQq5QQQgghpE3giBshhBBC6kda9YBMPhxxI4QQQghpE9hHJoQQQkj9cMStqbCpCSGEEFI/7Lg1FX4qJYQQQghpE9hHJoQQQkj9ZNGY6UBKDSjjHKDlI2733nsvFi1ahHw+j4GBAezdu7fVVSKEEEJIWswGbqQqLW2mBx98EJs2bcJ9992HgYEBbN++HWvWrMHBgwcxb968qvlLpRKOHDmCrq4uZDJ1LHJGCCGETBM8z8PIyAj6+voi63OS6UVL1yodGBjAlVdeiXvuuQeA3xHr7+/HLbfcgs2bN1fNf/jwYfT39092NQkhhJC2YXBwEAsWLJj044Rrlb4L6M41oLxxoOdfuFZpNVo24lYsFrFv3z5s2bIllGWzWaxevRq7d+/W5ikUCigUCmE87HM+MAh0dVcOuRqIDr+aAAwPMB3AdJExXRimC8NwYJolP2y6fl0MFwYcmCjBgAsDLrJwYMJP92WlQMdFNtAxgnQbRb+cUF4uCwByQbrIb4THcSLlyMcxpGMYcIN84thOcIpyWeU668pJPo/oufvn4gTHjZYPAKbrwnBcGI4Hw29eAEDGBeAAkPdBGhxpK0lhOV3ND40+FD1owkKvhGg5cfpyWD6mWp58fLkeUOSqvqiLKtOFXUnmxujGyL1A7kjp41K6owk7Qb3GpSLlsKvIHCWupqfR0enqmqKanhrX6cfFa8XUhHOIPnI6pHhHkG4E4a5gnwfQZQHd3QC6AfQEib0AZgOYG2xvBLAAOHNBBkP2BXgOS3EU8/EK+vEcLsYrWIDDWIDjh3qB/TngCIBfwd//EsAxAMcBuF4g/DWAEQCnAQwDGIPfYmNB64wjvpXTtoYcN1HZUrI8J+UxFJ1cFVlSmSKu+SpjKOqmJFffHeo7Racr66nl6mRymbrj6MpIqlNxGPhv/ejq6qo818mkUUte0cYtFS3ruL3++utwXRfz58+PyOfPn4/nnntOm2fbtm3YunVrZUJnNzBD03FTbzATgBntuPmbI4XLHbcsHGSDzozoHEU7PNGOltzJMYODynqmlG4FV7ks1+mV5Uasnr9lg+OW4/6WgRmG3eAez8AIHmIGMoHcC58B/ibiHoxgATm/DA8mvCBfuRzTzcBwMpUdN7kzpuuY1ZoOjT408biOm4vyA8aQdAxJJyvJsxpZBuV3QEbRU98NSV/wRXnymHdcWCfLVpd7wYPQkeoxLoV1cl0nKakTVi2eRidJV5aZVfRkORB9l6hdDzVfrcgDDGp3RKR1SPEOKb0DwMxg3wGgOwN0CwNv8SK2ANjwe3YdAGYA6AKM7gxO21l0wkQHLNiwkUMnDMxAFl3+n9jOnJ/PRrl/k0VwPXrwO2zj8N+U4t9MRjoTB9GbolprxbWGrnXiwjklT5xOXGsnpcV03OT7WL6vs9Imxw1lE0UnvnOqyOrRr1IOTYemN231EXzLli04depUuA0ODra6SoQQQsi5TdKgSa0bqUrLmmnOnDkwDAPHjh2LyI8dO4be3l5tHtu2Ydt2hfziNU/D6J6pfAKUPx2WR6+i++inz/RpE88v168sq6y7Lq3WeqnlAgjG8NxgDE7ITO2xU52XARiGA9hleVIZAGC6QdwR+xKMoIqRETsg/vMloB9Z06WhSlotOrXK1ZHBRpRV7Rzc8gBCTkoPx0Z0n2KrfapNmx73+Vf3e6Q4lic+46b45BuRy+WhtlG2yBhScJvkgiemafph0wAy8iervLS34Y+S5YN9T7DNgP9JdH6wP9/fxvqB4zNm43Wcj+OYg5exCK/jfLyK+Xgd52MQ/TiOOTiO83HyzCycPjwXeB3ASfj708o2FmwmgEXwP7068IdZnQX+BiGr0himJlzrPq2skfu4cBr9iejGpgVD42b5s0RWMtExzODZGMalNKP6+wHDJ/FLkOlOy0bcLMvC8uXLsWvXrlBWKpWwa9curFq1qlXVIoQQQkgt6Oz86tkaYSd3DtDSgclNmzZh/fr1WLFiBVauXInt27fjzJkz2LBhQyurRQghhJC0NMo5gR23VLS043bjjTfitddew+23346hoSEsW7YMO3furHBYIIQQQgghU8AUcOPGjdi4cWOrq0EIIYSQemiUYwGnA0lFyztujeA38Dxy6AyNNYFKg/iorGyJqxrQp9WrV181LI0vU+8kkFRmnL6KE0wtEnVMKDsr+Hszpr5Ww9pUGNuawujWrlKu4szgh0tSWOiVzzVTzUhellczoq9Vr5FlpMlfy7HidGupTyOPpcqVuPgdZYeBXFzbqFQzvAcqn4QiHjcfl+qQYKLsjCCm8LBRdkZQnBPGZviOCCPowig6MYIuHMf5GEFXuIm4nz4TLkzYKGAWTsKaUcTMJSM4u6gThTELY6c7AccAxnJlpwRH2us2XdsktVXc20LnaBAXTiubaH7ZCSBMKzsDCOKcAqJpUecAYOLP8cl6x4xjtDXOCey4NZW2mg6EEEIIIeRcZlqMuBFCCCGkRXDEramw40YIIYSQ+hGrSjSiHFIVNhMhhBBCSJswLUbczscJdOB0GNcZhwp0xqTJ4Upj0Nbq15ZXRl4ZQTgo+PLKVRR0ecUxnUBPdnAwIo4OSXW0Up+Teh7CiQGGlGZX6ukcGoB4pwY/Lh2nXueGWvTSlNsIvYmWHaeTpJcmXs2xQGckH+dvk8b5IA75CWgoMlORxa2QIDsozJDigbPC+AygmM9i1O5EERZG4e+F44GQibB/PzrowCgMuLBQQCdG0YXTKMJCARaKsP29baNoWyj02HBhoAALLkwUYcFfRdmE6xpwHX8DAMcx4Dr+SQpZyVHufTUe236VP0pWkRkVceWZrHEI0MV1zgFA8rOvludl4nMkwWFg4nn176i4c0k6Vkl6DzaVRn0qjfepIxIccSOEEEIIaROmxYgbIYQQQloER9yaCjtuhBBCCKkfLnnVVPiplBBCCCGkTZgWI249OAUb+TCe1kAViBqpNjJvkgFp7cetrawkkhwUxLGSnBQmUlac00L0HOKdF4oxeSucGOS47MhgSPp2TD1cpa0dNZ7OqQFQHBuA2oz7VVmtxvwTdQaY6PF0ZcTpJckb/elEvrR1M+7rnBGEXLdygh0Nj9uAawKumUXBLjsRuDBwFp1wYJQdC2AHzgZ25J6xUAivWRdn0YlRFGCjCyOBA0KlI4ILo+yMIKUBgGsY/mYboWOR0BOIsIPKe9+t4zWh3lcyuueVzqGqkc/QauU17z3QmDrE5S1gDC2Bn0qbyrTouBFCCCGkRYg/MxNlIh7i5xD8VEoIIYQQ0ibU3HE7dOgQPM+rkHueh0OHDtVU1p133olMJhPZli5dWmuVCCGEENIqzAZupCo1N9PixYtx9OhRzJs3LyI/ceIEFi9eDNet7SP1JZdcgkcffbRcIbP2X64DZ2Eri5xVsxfQydLYjlWzO2hUOZNVropsmwaUJ+OV43I5lfH67rTK45Qn+BX1AqKT/AqMinj0HIuobKt4OzgrolM0lDyKyY9hJ9vEAbXZxZXLqZRVtZEDqtuipc1XS95GTo472Z9G1Muz2oS78t5QZEHcM/35aYUtm2sacIyyfZmwNysGtmg6uzQXRjhJbrk6DgwYsFEM7UFdGLBRQAdGw/KELVsxuHbl8kVctncTMtmOLbR/k9Jl5HqlucfdyHnU9g6o1R4u7hiNembqZPWUXc87J005SeVmUahII9OPmt+6nuchk8lUyE+fPo18Pq/JUaUCpone3t6a8xFCCCFkCsDpQJpK6o7bpk2bAACZTAa33XYbOjs7wzTXdbFnzx4sW7as5go8//zz6OvrQz6fx6pVq7Bt2zYsXLiw5nIIIYQQ0gIa9ZmTn0pTkbqZ9u/fD8AfcXvmmWdgWeVPTJZl4fLLL8ett95a08EHBgbwwAMPYMmSJTh69Ci2bt2Kq6++GgcOHEBXV1eFfqFQQKFQHgoeHh6u6XiEEEIIIe1M6o7b448/DgDYsGED7r77bnR3d0/44Nddd10YvuyyyzAwMICLLroIDz30EG6++eYK/W3btmHr1q0TPi4hhBBCGgRH3JpKzc10//33T0Y9AACzZs3CxRdfjBdeeEGbvmXLlvCTLeCPuPX39wdTWUbt7tIYkwL1G6tOTnmNPUZadA4KaplxTgpRmSnJHO1knjKqg4JOpjotiPoC5XbQ1yUqUw2sXU276tqwsq2tiJ5wZojkDWXBMWylTM0kv0VUojo1+DKNIlI6Nwhqnew2yYGgmnNBKybUVC+7OAcFzWS8XrB3gjThgOCHy04IQNng35EM/1UHhaR4tMouHBiwUIA6Oa7I5zst6MuJc0aQJ9wVcnmvpstpaeOTRbVnWlx6vFx/sU7UASKu7Ga8C9TjeK1yTsiiMfZpnKAsFVOqmU6fPo0XX3wRF1xwgTbdtm10d3dHNkIIIYSQc4WWdtxuvfVWfPe738XLL7+MJ554AjfccAMMw8DatWtbWS1CCCGEpIXzuDWVljbT4cOHsXbtWhw/fhxz587FVVddhSeffBJz585tZbUIIYQQkhbauDWVljbTjh07Wnl4QgghhJC2Ylr0bw24sGKMMifL8LRxZU/8mLWWrUN1UADinQfUstM4KohjyOhXRaiU1ULcedRb5zgjchX9tWBpfwPXUGSR1Rqk3z1watCtzhDqB6s0qM4NhlOqcIoop8UWp3VyUIl1etAxGSsjJDy1PE2aI7Wva8rhrBQOjPWN6sb8siOCSEtyEqjmOFA+LTdYO8FvNCtwRvDvCTcsx4o5plrfOMeEuPOSqXTmqd9BoZqTkiDueZpEmmdckk49qzYkldlqh4mS1s2pCXAC3qYypZwTCCGEEEJIPNNixI0QQgghLYI2bk2FzUQIIYSQ+jHQmN4EP5Wmgp9KCSGEEELahGkx4majGJjslkk2SK3NUBSozVh0qh+/FnQOCkKuO47eEaDS6B9I56wgymrEbO06xwVR57jzEMcvy/XnEqef9hxFPl1a0Uj4PY2Y60ZyTEhybgiLiXFyqNSLd3poFrJTQWVaZfsJh4NQJ2aVAJ2hvs4RQaeb5Kig5kv6/XUycX0KNwX1uMJZoVq9ks+zdmeEavdkWqeEeqnVmaHelRjSpzfW0SEpLe5YjXru1ww/lTYVNhMhhBBC6odepU2Fn0oJIYQQQtoEjrgRQgghpH74qbSpsJkIIYQQUj/suDWVadFMRmDyq8ri9RtvRFr9mM2vT60kGe/HHa+ak4KaFmfcL44vI+qiW71AJxdpqqG1fLx6DKZrd9CIHj/OiUHNm7QiQ60ODTKJzg3lgrT1raDVjgkJj6y0BvQ65wO1bJ0xv5y3mrNCko4O2QnBjbkPk/TUehnhsYra+iedry4ed98k/R5xZU029TwXE695iTQOEa1ycgB8Rz0y/ZkWHTdCCCGEtIgsGuNYQKv7VLCZCCGEEELaBI64EUIIIaR+aOPWVNq6mTzPAwCMDVd+189Oik1ZKbE+9dq4ZSdl4sb4uiadf/12erXXpZqtR9y5J/+29aWZVX/bpPZMzpudQF4TXpV6JafXqgcA2Rp0m00poW6uJk0nc6Q2d5GRytbL5bCjyMQVVVLSozpelb3QL0X2op6lUK+k7CvtI90wT7KNnpq/mo1bnJ2aW+Ue9nWa+2Gn2j2lz5POxs1pio1b0nMqOe948C4U78amwY5bU2nrZhoZGQEA3Nn/9RbXhBDSHAqtrgAhU56RkRH09PS0uhpkkmjrjltfXx8GBwfR1dWFTCZTPQMhhBAyTfE8DyMjI+jr62vugblyQlNp645bNpvFggULWl0NQgghZErQkpE2fiptKvQqJYQQQghpE9i/JYQQQkj9GGhMb4KfSlPBjhshhBBC6oefSpsKP5USQgghhLQJ7LgRQgghpH6MBm51cO+992LRokXI5/MYGBjA3r17E/W/8Y1vYOnSpcjn87j00kvx7W9/u74Dtwh23AghhBDSljz44IPYtGkT7rjjDvz4xz/G5ZdfjjVr1uDVV1/V6j/xxBNYu3Ytbr75Zuzfvx/XX389rr/+ehw4cKDJNa+fjNf0KZYJIYQQ0u4MDw+jp6cHp54Cumc2oLzTQM+VwKlTp9Dd3Z0qz8DAAK688krcc889AIBSqYT+/n7ccsst2Lx5c4X+jTfeiDNnzuDhhx8OZb/1W7+FZcuW4b777pv4STQBjrgRQgghpH6EV+lEt+BT6fDwcGQrFPQrphSLRezbtw+rV68OZdlsFqtXr8bu3bu1eXbv3h3RB4A1a9bE6k9F2HEjhBBCyJShv78fPT094bZt2zat3uuvvw7XdTF//vyIfP78+RgaGtLmGRoaqkl/KkLnW0IIIYTUT4OXvBocHIx8KrVtuwGFTx/YcSOEEEJI/TR4Hrfu7u5UNm5z5syBYRg4duxYRH7s2DH09vZq8/T29takPxXhp1JCCCGEtB2WZWH58uXYtWtXKCuVSti1axdWrVqlzbNq1aqIPgA88sgjsfpTEY64EUIIIaR+WrhywqZNm7B+/XqsWLECK1euxPbt23HmzBls2LABAPD+978fF154YWgn95GPfARvf/vb8Zd/+Zd45zvfiR07duBHP/oR/uZv/qYBJ9Ac2HEjhBBCSFty44034rXXXsPtt9+OoaEhLFu2DDt37gwdEA4dOoRstvxx8W1vexu+/vWv4//7//4//Omf/ine9KY34Vvf+hbe+ta3tuoUaobzuBFCCCGkZsJ53F4EursaUN4I0PPG2uZxOxfhiBshhBBC6sbLAl4DvEo9Wt2ngs1ECCGEENImcMSNEEIIIXXjmv7WiHJIdVo+4nbvvfdi0aJFyOfzGBgYwN69e1tdJUIIIYSkRHTcGrGR6rS0mR588EFs2rQJ9913HwYGBrB9+3asWbMGBw8exLx586rmL5VKOHLkCLq6upDJZJpQY0IIIWRq4nkeRkZG0NfXF/GkJNOLlnqVDgwM4Morr8Q999wDwO+I9ff345ZbbsHmzZur5j98+DD6+/snu5qEEEJI2zA4OIgFCxZM+nGEV+mRVzPo7p744MnwsIe+eR69SqvQshG3YrGIffv2YcuWLaEsm81i9erV2L17tzZPoVBAoVAI46LPObgf6DjfH2YdnWGjBBNFWCggh3HYKCAHFybGYaEAGy6yKMJCMQi7MIKwARdGqF8K4k6wj25mmNcNFlgryw24wVdoJ5CVJB2xdwIdkacUHAsAirBCvRKMsN6iPuNBfR1kMe7aKI5ZcJwsXNeEc7oDcEygkAHGABQQ3Z9JiJ+O2Qs9WRcAMA7gbCAcBzACwAnisnw8CDtB2JG28aAsEU+DqQnnUJ4J0pTiAJAP4jn4C+LlJJ18EJZ18lJ6rnwoO0gypCy2FDaCfZKOCJtSeWaVstXyTQCGB+QLyJguDNOFbRdhmC5ydhEGHJgowUIRWTiwUYSBEmwUwqvWQhEmXOTg69sYD65cNxK3UAivegvFijvBRjHMY8KFFZbjhHeDmk8cOyuVIdJyKIR3Xw4FmK4La8yB4QCmC2QKANzgUnHhX4vi0ikGe1lHpJeUeD15x4K0GtI9F3BcYNwBHLGVgNFATdwN4wlxIN1d40i6UGRp7ywV9SUh320ibkphVS7ri7tPxE1F1iGlibs01M0CZlCY2OdMwAwyZ0Qh4oBqXJbJHpBxJ6jKsxp53LEMRSY3RFaKi3vdlsImAEtKnyGlWSg/FwyUnxmB/vA40P/vgK6uBszNUQOuacI1J95xc00P0auX6GhZx+3111+H67rhJHmC+fPn47nnntPm2bZtG7Zu3Voh7+4COrr9jps5IwMXGRSRgYUsisgiF7wSijBgBuEcTJjha8WAgVwYzsKSOmCi4xYfF50xVQ4AWUkm4mKfCcNmoFe+20vwF9XNhPUTd6oBL3jVeTD8clwbGctCxjGQcUwgE3TccpnoA8KA/9AoAcgEm19xwAs2K0jPwX9rmEG6yCvnA+DfZOKRPB4UImfIotxxywRpotBxSReIvo6qIXWmKjpu6h7wXwm5GJ2OICzrdEjp0rHE+WelzZA2U7PlUH4QW6jsjOU14bi4vDfLHbeM6SIThLO231nLBn9R/CtWdIzEHeCGd0AOJgw4QQeufJVbMIIrLYNyhyujXPlOcGX6d47fcYO4MoMrOwsLJZjIBFd9JrjDys1mIxtc2R4sZGHCC/QyMN0MLAvljpvoHIkeS04Ki46UKckMlDtqTvCbibSMEpYvxSz8yzkb5M0Ee3EfIIiLvSflF/mygFcCnAwwnpH2UrXGU+yhkYsrW+3EAdF+ia4zVws5Ja7ruCWF1Y5b3N0KRDtuclk5AGbGf6QhCAPBIy4IZ0THKm4P6Dtu6jQWOh05nqbjZioyU9Gt1nGzpfQORU/+Q6fGgx+ZpkPTm7b6CL5lyxacOnUq3AYHB1tdJUIIIeScxjWMhm2kOi0bcZszZw4Mw8CxY8ci8mPHjqG3t1ebx7Zt2LZdmXAUyI0DOQPI58cAG/BMoGADxXwOBcMOPoH6n0eLsODAwFl0BmMRdvBp1d9bwWfIUXSgGIx8uTBRCMYJfF2rIv8oOoPj2DiLjrA8cawCbBQLFlzHwOjpTpTGLGAs5/8lPo3yl8SxIC7C8uZUCct7JyYet0ETror4Hz0BewT104S8Twrr4nGyWtJ1+vkUaaJcXVw+ZiTuj5oBQNZ0YeULME1/GMcwXVjBZ09fXXxyrBYP8gefSP2wCzv45CniVvC9Wx1Bi8Z1smrxSpmMGO8D/FFqU0o34KAISyqnA4bhwpyhlO26MBwXhlMqj8SJa1cejQPKo3DQpMvhpDSk0AX8e03RzThAzgVycXXQle9CX2eg8pi6MgB4jv+JFih/phVhQEpDdJ/0uVUnU+W69DjkqgO+oYVK+JISn6AB5AqadMSPw+vioTzoK+RM6D/ByqNjckG2FFd1xD2uG10zUf6dRBiKHFK6fIxCsInyVHOKer+Hk7aiZSNulmVh+fLl2LVrVygrlUrYtWsXVq1a1apqEUIIIaQGSsrftnq3EjjiloaWjbgBwKZNm7B+/XqsWLECK1euxPbt23HmzBls2LChldUihBBCSEocGHAwcbs6B1w6PQ0t7bjdeOONeO2113D77bdjaGgIy5Ytw86dOyscFgghhBBCSIs7bgCwceNGbNy4sdXVIIQQQkgdyFNgTaycUgNqM/1pecetoQTu0eM2UMxnUbCtwCnAd0oQDgUFyZlAOCCIuNAdRWfEwUA4HER1OsJyRZ5iwUJhzEJxzC47H8Q5F+gcDGp1KNA5E6iGqsJQFopevW0cF9eFVVnauBpOK6vFmSEpLe44kTQPMAPLePjOBYbpwjADZ4EwHjgEGGWjfQARY3v/EG6irJwnXRmqflRelqUrR6evKzdaPxkxR6EBN8xVdlywgjSRGl8PAy5MwwUMwLCVektOCwCijgt+JSZu+F+trGrlpHAsSJ03QZZxAgN81TECev0KufycSJtPlsF3kADKjhCCcUnHcVDBuEamllEvpsaMKmeW62Ka/vHHnUDu+rc5EDgqCMeIAiqn/EAgO6PIZEcGncNCXpGr033I04E4UlilRc4Jjeu4cRqTNLTVdCCEEEIIIecy02vEjRBCCCFNhSNuzYUdN0IIIYTUDTtuzYWfSgkhhBBC2oTpMeI229/GbeDsTH+lBHl1A50zgkgbRWfofCA7KhRgYwRdYTmh8wEsiNUR5LJcmDh7pgOOY0QdE3TGovIM+o4S1jkc6BwQdIbDajgOeUbuOJKcENR4GqeEZu1TpQVzBQmLY9NFVlqtwN87kRUMxN4wykbyfrFRw3yRpjoPJOWJy1dOTzpWtfS4ukTzNbouKi7MME2s25uUbgQ6qqMCpFUVRD1F2ETgsGC4MGzpPNwg7Ii9v9oCEOO4IMLyXnUcSNKPKyPJKaGWY8blSeNwUEu6Kq9Vxy0v6ZpT0sMVDmKcGiouIzUe56jQSON89ZmnW5he3cc5K+hWVpDT0zgn5CWZnD5TSm/R+uz+XcoRt2bBETdCCCGEkDZheoy4EUIIIaQluDAbZOPGedzSwI4bIYQQQurGRVZrAlF7OSQN/FRKCCGEENImTIsRt7HzAJwfdUrQrZQg4g4MyalAmDcbwXBv+V+Dn2LARhGAMJp2UIQdGkT7JfvOCfaMgl/2TBvFMQuOY8B1TLiO4TsrOCbgZNI7IcQZE1cz3E2TlvTL69JqdU6IC6dxWoiVeWWHAiCyYgEQdSwAoHUuEIhVDMqHKxu8A5WG9nGG/yItKq9VT+8IUGsZ8efRiHpUP1fVMUGuh8CBATNwORBrJAhd//4zK8op6/ppogw/Xzl/ERpnBVhlhxKxt4NzSXBa8NMlxwW/8pPvAJA2XaTFyZPKTFOftPmq6dWSrouncUqIe8ZN1FGh2nOwmrOC6qigxnWrKOicFNSVE2QnBRPADClerPksG4JYv2Ti5ZA0TIuOGyGEEEJagxP8ZZp4OSQN/FRKCCGEENIm1NxxO3ToEDzPq5B7nodDhw7VVNadd96JTCYT2ZYuXVprlQghhBDSIkqBmcNEtxI/Aqai5lZavHgxjh49innz5kXkJ06cwOLFi+G6tX2lvuSSS/Doo4+WK2TW/sOdmtGNccOM2La5MMOJdMWkuW5wuqotm29z48JGIUgvp9koogArKLkYlH0WLgx0YDQ8jpiU14UB1zDgzCjbzJXt6Ey4rgHX8TfHCSYZFXZwQRzhPmgLJ5iUcCKT7sq6aZu4Vls3oDy5LaC1RwPKNmmAYncm6av2aRVhZSJcvyp6+ytZT9WJ6lcvK02ZteuksyNLoxNXVhqdeuqU1HZxxNm5ifLchAs0zt5NLkvUSdi8yfWUJ/EtGoHcCPTsst0bELV98/fB+Umnl1Htt5Jsu5Ls1erJH1dWlUlxazr2RHTTTq6rXi7Vnm1Jz7tGG0mpX/+q2fAmTcAr5IaSLturqTZvYnJ2Q9GTZTMAz/RfG2eKGQCVAytkelFzL8nzPGQylbMbnz59Gvl8vvYKmCZ6e3trzkcIIYSQ1kPnhOaSuuO2adMmAEAmk8Ftt92Gzs7OMM11XezZswfLli2ruQLPP/88+vr6kM/nsWrVKmzbtg0LFy6suRxCCCGENB923JpL6o7b/v37Afgjbs888wwsywrTLMvC5ZdfjltvvbWmgw8MDOCBBx7AkiVLcPToUWzduhVXX301Dhw4gK6urgr9QqGAQqEQxoeHh2s6HiGEEEJIO5O64/b4448DADZs2IC7774b3d3dEz74ddddF4Yvu+wyDAwM4KKLLsJDDz2Em2++uUJ/27Zt2Lp164SPSwghhJDG0LiVE2ifl4aabdzuv//+yagHAGDWrFm4+OKL8cILL2jTt2zZEn6yBfwRt/7+fowiD8BCEVY4uW50Yt3KOWaE6wBQQBF26JggGzhbKAbT6xZCJ4SOMKcRHk/rhKAcO3SIMOA7L9iys0R5mFnUM0xzhQNDuf5yGEDo5CDjOjX/tNH2MeMtgE2zckDbqCITzgRhPMGYXWckn5QnyYg/nW688X+cbpIjQ7U8jSo7bb1rLzdd2+km2E1yTEieXLfSUSEtOkcFUT/ZmcHXjTorlOusOCz4StWdFmwhC8pKclzwK1AmjWODTq9aOWnKitNP40SQNGFuLY4GukdMUv408mrlyVS71NJOwBs3gXiSo4IuHuecoMYDBwXhkFDMZ+GaBgqGjdPDWQDN/xLVuHnc2HFLw5Sax+306dN48cUXccEFF2jTbdtGd3d3ZCOEEEIIOVdo6aQpt956K971rnfhoosuwpEjR3DHHXfAMAysXbu2ldUihBBCSErEPGwTL4ekoaUdt8OHD2Pt2rU4fvw45s6di6uuugpPPvkk5s6d28pqEUIIISQlpQZ5lZb4qTQVLe247dixo5WHJ4QQQghpK6bF+hJj6ASQq3ASEE4KKups6gicDwCEjgTCsFk4JqjOCAC0cQCVDgmKTMTVND9cTg8qGTo1hMafNiqGpZP+7Uz0n5DOCD1NumqInuSEoI+nz1+vQ0PaPI06Vj2OEBOr38QcOmqpT1L7pkFe9UB1KpDrlXytxztAqOUKPSET91f0PIL7UnKuMYQngsZpoRiGfccFw0HowFDhuBDIa3YqqNfxIK2OmpaUr9a8On2dTjV5Ulm1Enc5VVslJsk5QV0tQeyrOSwImS3pBWHZGQEAXNOAY0Sd8UaRQSucExo3jxtH3NIwpZwTCCGEEEJIPNNixI0QQgghrcFBtkHTgZQaUJvpDztuhBBCCKmbxnmV8lNpGviplBBCCCGkTZgWI24OsqEjQCF0EFCM/BV8U85yWtkY2wBQDMqyYaFseCk7KrgwYKMQcSpQV0BQnRNiV0dQDDvVdPk8ZD3ducUNVzfi35CMagCuEjeDvs5oPY2skY4O9Tg5JJVRq6NDo48Zd7y4PGnql7aO1a6DOMQqB4DeeaAyXF4dQdRVXSGhHE53rat5ZGcFIY9bjSEsQ+e0gOjqImKlhSICpwWg7LgQhIEqzgsinHZlglodBiaSN62zQSsdEJKoxzkhaQUFOaxzRlCdEoRM0hWOCK4JuGbUGUF91xRghdf8ODIxJzO5NM45gZ9K0zAtOm6EEEIIaQ3suDUXfiolhBBCCGkTOOJGCCGEkLqR5yKdWDkccUsDO26EEEIIqRt6lTaXadFxK8KGETglAHpHAYEwdnYkw2dhcCycDcTKCUJelpUdF1SnBD9c6Zygk4t8Ik3ey2EnIqt0VIiLV/vn02xHBUEtDgtxct2xqjkq6GS1OD80yvFBjTfa+aHefI121qiHJAcFcWxx3aZxUphoHfy477CgOiuI41bWTwob5XusmtNCeDxHGm1I47wgpUUcGPyKRanVwSCtc4FOlnQpJD0q6vNzmRhxj0Kd3IhJj1s5QZemyL1gLxwRAN8ZwTWDd4DkjADIK/DoneIKMadDphfTouNGCCGEkNbgItsg54TJdiGeHrDjRgghhBAyCbz00kv4/ve/j1/96lcYHR3F3LlzccUVV2DVqlXI5/N1lcmOGyGEEELqpnHTgUy8jKnC1772Ndx999340Y9+hPnz56Ovrw8dHR04ceIEXnzxReTzeaxbtw6f/OQncdFFF9VUdlt33DzPN2Q8M+yiFNquAS4ycOFFNsA3vfA1S3BQQgle6MXiy93AfsCXlYKL0QksWHS2bL48q5GrNm7ZoH5RG7dSoo1bVpLF27iVUKuNW2NvDi/18LZer1SDvKQxhPEUTyR9PsWeqIqNm6xvKOUn2XpVlptkP6aWWy7HSW2rFk1LsnHLprZxK0nhpPLS2snJ5TlanWrHiquTfNxsyvLMinYvacN+mfo0UzGiNqS4oaRlpbjpSnqOUoZyaavxiI1bNZu0WtMbaeOW5BjYzjZu2Zj0JBs31dZNtXEL4lEbNw+u6QVyL3hPiXeYBwcluMFEu6UgLOJnhoNyveYa+bPjFuWKK66AZVm46aab8H/+z/9Bf39/JL1QKGD37t3YsWMHVqxYgb/+67/Ge97zntTlt3XHbWRkBADwrv5ftLgmhBBCSCPwUO7FOqjH5WBkZAQ9PT2NrBSpgbvuugtr1qyJTbdtG7/zO7+D3/md38FnPvMZvPzyyzWV39Ydt76+PgwODqKrqwuZTGuW+iCEEEKmAp7nYWRkBH19fU09buPmcZseI25JnTaV888/H+eff35N5bd1xy2bzWLBggWtrgYhhBAyJWjFSFvj5nGbfhPwPvDAA7jpppsq5I7j4LbbbsO2bdtqLpNLXhFCCCGETAIf/vCH8Z73vAe//vWvQ9nBgwcxMDCAf/iHf6irTHbcCCGEEFI3wjmhEdt0Y//+/Th8+DAuvfRSPPLII7j33nvxm7/5m1i6dCl+8pOf1FVmW38qJYQQQkhradwEvNNvLOmNb3wjfvjDH+KjH/0orr32WhiGgb//+7/H2rVr6y5z+rUSIYQQQsgU4V//9V+xY8cOrFq1CrNmzcLf/d3f4ciRI3WXx44bIYQQQurGCbxKG7FNN/7wD/8Q73nPe/DJT34S3//+9/HTn/4UlmXh0ksvxUMPPVRXmfxUSgghhBAyCfzwhz/Enj17cPnllwMAent78e1vfxv33nsv/uAP/gD/5b/8l5rLZMeNEEIIIXXTuOlApt8i8/v27YNt2xXyD33oQ1i9enVdZbLjRgghhJC6KTXII1RdvnE6oOu0CZYsWVJXmbRxI4QQQghpMv/+3/97fPrTn8bo6GhN+dhxI4QQQkjdcB63+li4cCF27dqFpUuX1pSPHTdCCCGE1I2Yx23i2+R1SU6cOIF169ahu7sbs2bNws0334zTp08n6t9yyy1YsmQJOjo6sHDhQnz4wx/GqVOnGlanBx54AN/5zndw4MCBmvKx40YIIYSQac26devw7LPP4pFHHsHDDz+M733ve/jgBz8Yq3/kyBEcOXIEn/vc53DgwAE88MAD2LlzJ26++eaajvuVr3wFhUKhQl4sFvGVr3wFANDd3V1TmRnP87yachBCCCHknGd4eBg9PT3YeOpTsLvzEy6vMDyGe3o+g1OnTtXcmUni5z//Od7ylrfgqaeewooVKwAAO3fuxO/+7u/i8OHD6OvrS1XON77xDfz+7/8+zpw5A9NM59tpGAaOHj2KefPmReTHjx/HvHnz4Lq1e9JyxI0QQgghU4bh4eHIphuxqoXdu3dj1qxZYacNAFavXo1sNos9e/akLkd0KNN22gDA8zxkMpkK+eHDh9HT05O6HBlOB0IIIYSQumncPG5+Gf39/RH5HXfcgTvvvLPucoeGhipGvEzTxOzZszE0NJSqjNdffx2f/vSnEz+vylxxxRXIZDLIZDK45pprIp0913Xx0ksv4dprr01/EnLd68pFCCGEEILGz+M2ODgY+VQaNxfa5s2b8dnPfjaxzJ///OcTrtfw8DDe+c534i1veUvqDuT1118PAHj66aexZs0azJw5M0yzLAuLFi3Cu9/97rrqw44bIYQQQqYM3d3dqWzcPv7xj+Omm25K1HnDG96A3t5evPrqqxG54zg4ceIEent7E/OPjIzg2muvRVdXF775zW8il8tVrRfgjxICwKJFi3DjjTcin5+4DaCAHTdCCCGE1E2j5mCrtYy5c+di7ty5VfVWrVqFkydPYt++fVi+fDkA4LHHHkOpVMLAwEBsvuHhYaxZswa2beOf//mfU3e+ZLu29evXp8pTCy13Trj33nuxaNEi5PN5DAwMYO/eva2uEiGEEEJS4sBo2DYZvPnNb8a1116LD3zgA9i7dy9++MMfYuPGjXjve98bepS+8sorWLp0adgHGR4exjve8Q6cOXMGf/d3f4fh4WEMDQ1haGioqifoJZdcgh07dqBYLCbqPf/88/jjP/5j3HXXXTWdT0tH3B588EFs2rQJ9913HwYGBrB9+3asWbMGBw8erDAk1FEqlXDkyBF0dXVpvTYIIYSQcwXP8zAyMoK+vj5ksy0fl5lSfO1rX8PGjRtxzTXXIJvN4t3vfje+8IUvhOnj4+M4ePBguPzUj3/849Dj9Dd+4zciZb300ktYtGhR7LG++MUv4pOf/CT+5E/+BP/hP/wHrFixAn19fcjn8/j1r3+Nn/3sZ/jBD36AZ599Fhs3bsQf//Ef13QuLZ3HbWBgAFdeeSXuueceAH5HrL+/H7fccgs2b95cNf/hw4crvE8IIYSQc5nBwUEsWLBg0o8j5nF736m/gNXdMeHyisNn8dWeTzR8HrdW8YMf/AAPPvggvv/97+NXv/oVzp49izlz5uCKK67AmjVrsG7dOpx33nk1l9uyEbdisYh9+/Zhy5YtoSybzWL16tXYvXt3qjK6uroAAP918E50dOeCgVb/azuAIFwK5WVZWceUwtlQxwnT/HgpzCsjx7NBHoGJ5KFUeUi4FPwM4vu+vPSHX3Mz4rVTgCXpic0Mlx0pwgrifjmijHFYcGGgEOxLQbgIKwjbKCIHBwbGYcOFgbNuB4pjFhwni2LBhjdmAYUcMAagAOA0ACcIjwE4g3KaGj8tyavFw+YbB3A2OMhwkOgE+7NBugtgNJA7kr7YRDkiHP2t9JhKOCfJ8lJcbJ0AjEDeEeiYwb5TCncACEaH7UA8I0iyAcwM9nJcThdheS/n6QFge8jMHIVlFzCz5wxsFJHHKDoxhg6MwkIRHTiLTpxFHmdhowAL45iJkTDNRjGIjwd5KtNnYAQ2xpFDAV2nCsgVg99vFP5vKeJngk3EC1J8TMozJslGA7kjyYL8XgE4WwAcBxgr+qouyleDfIWMo/zLy1cHpPi4FJf3SZjSPieFTUSvFnGliF9eDucBdGSBfB7osIFMZ/A7it+yM9hEvEtK7wx++xlBvFvR7QZg+enjFjDSY2McNgrIYRw2RpFHETaKwf1/Fh1wYaKIXCh3kUUBdvicKD9b9M8bAJFnjh/35SXpeafaMalxR2PBEzfVRJJNVEmTFvcpLq6cWm2uhL76rlCJe5eI90ZWSi+/u8R7qRR5n8nvrdLwGTzYf3v4bmwWrbJxm+pcddVVuOqqqxpebss6bq+//jpc18X8+fMj8vnz5+O5557T5ikUCpGJ+EZGRgAAVnceVtBxkzti5W6NIXXChKzcOZP1/X02TNPJBXLcQPRTrVnFfFB+gMgPPbEXYdHpkmUZ2BG9Sh0rEs8G6YCFLAyUYAcyAy5slIKHsQEbBix4gdyDgYzbiYxlIeMYyIzZ8HIWkMuV31Ae/DedAd9isgS/XyKawwl0PPgvkhL8t6wb5JfzZpW8APzXai7Ye5pMaodsXAmLNAPRTlw1ZM8htePWIcXFvlOKdwSbGew7pbDUcRPnKs7dCDb57Z+D324Wyi9l+c0vXu5CPhNA3kNmpolMvoBsdxZZFIKrwICJDEzkkENGKjoLCwZsjMNCBnmUYAPogAULQCdysOBhBkxYcNEJAzaymIksbGRgIYMuD8gVggLFpV9A+RrxUP7JMvB//0wgR/DTlIK4uDbEu8tF5BrxMkAuAzgZv3nEL2vA/2VFXFwd4iqQrwZIcXEn1nN1qB039aoQV0qHJtwBoCNT3jLyNWAgeg2IH0vu2InrQO7IiTTRmZ8BjNtApjuDIjKwkEURWWRhoAgDBRjIBVeFCxMmcjCCzX92+M+GTPBMycKKfd74P1X5mePHo882AGFaXDyjeXlnY15Val4ZfSdAr5+JKV9XlySEfu0dN3WwIKnjVvmOE+mlIEzToanD//gf/yMx/fbbb6+5zLbyKt22bRu2bt3a6moQQgghJIAjbvF885vfjMTHx8fx0ksvwTRNvPGNb2yvjtucOXNgGAaOHTsWkR87dix2XpUtW7Zg06ZNYXx4eJg2boQQQgiZkuzfv79CNjw8jJtuugk33HBDXWW2rONmWRaWL1+OXbt2hTMMl0ol7Nq1Cxs3btTmsW1bO4OyEQzmA+onyPhh67ih7GpD3HHo/im4mrqIOso2G3GfRuU09fOEGpdlRelzRiRcsOA6BgpjNlzHQMkxgDEbGMuUDX7GUDYSqjfuxMTVNNkETUyPM1ORO8F3IgeAc365ceMMkRzEX9Wq2VrcXg2rsrySntfomjHp+QSZCCfGPSBfQNZ0YeULsPNFGKYLyyjAhAsLRdgowIALK7BaVMMivQOjkStK2C6NoiO8nky4GEEXDDjoxKxQ17eCksrviZZvoRjqhccvFGE4JRhO8FlV2LDJNpKuEncCmZSWKQCdQb5uuQw5r6ORq2E5joQ4pLi8V+VxqNejfC0ZUljI5c/l8nfcYfi2gSLN1oQ1+5wJzLbHgPyYX15eo6fIxm3ANYFiPgfHMFAMbF4LwRUmro9i8GvLz6LKuB15ThUUUw81Lj8f5Xx+M0TT5L1qVyenqWFdXCXt1BTV7JmB9O8b/buqfIGpx1I/qRZTfehvPI1eOWG6093dja1bt+Jd73oX3ve+99Wcv6WfSjdt2oT169djxYoVWLlyJbZv344zZ85gw4YNrawWIYQQQlLiwKjZHjCunHOFU6dO4dSpU3XlbWnH7cYbb8Rrr72G22+/HUNDQ1i2bBl27txZ4bBACCGEENJuyHPFAf5ce0ePHsVXv/pVXHfddXWV2XLnhI0bN8Z+GiWEEELI1Mb3JJ54d2I6Oid8/vOfj8Sz2Szmzp2L9evXR6ZDq4WWd9wIIYQQ0r7IU8BMtJzpxksvvdTwMqdFx60Yzo5UG/GTMVY2S5yRq+p0IPKrOqrhrGxwG2eQq5YXcUpwDbiOvzmOAdcx4Tq+fmnMApzgHJxM2cgbKDsJiHAtGzR5Ad+wWcTzSlq1vRrWxdMQZwAeF07jlKBLT+O8UNfmAaYDmC6ypgvDdGGYTuh8YBj+r6+6owjj/8q0yvRyuFJfGD2La1LMlujCDZ0UXJhhvrNV6mHp6mW7MGw5Xe9iY7ourLFxGMF1YLpARnZcUJ0I5Ambk5wQdOmISdfJ5T00aWpY1auG+jiKu4aTHBpUuVyHsUBeQNkRQejb0by5wKkhb44DxjhgjoXOEl4ecAzfecE1s3BNA45R/iXFZL1JzlRJzlW6uH8K8c4LQLzjgu7ZK+/VsPpeUN8HSZ2LZnc81HMopr7YSDszLTpuhBBCCGkNHHFrLuy4EUIIIaRu6FXaXJLXZSKEEEIIIVMGjrgRQgghpG5KMLW24fWUQ6ozLVrpLDrhSM4JSTNk6xZ3V/XiHA7UtKSZu2tNC8uXnA4AwAn2EecDx/Ctg2UHBNl4WucIkDYdiBotq7p5SS+No0GcLE1atauzXocEnayas4IuLcmxwQxWTw8cDgBEnA7MQGYImeHH7cAtQHUi0MlkRwQ/vdJ5Qeew4FezUqYSNQovOynoyi/CTl0PALCC89TVwzRcGDMqTdTVNgAA03VhOG64IoMvAzJpVkPQXf9xzghxcp2zAjRpSdd5GnvyuC9ISfeAoZGr+zhHB0C/ooQJZNxg3XsDgFmCZ5YAjFc4LACIOC0AsiNW1BHBP0yyTOTXOW5Fy9Y7gInydPnUNFmu05H14nTVsJpfLUOnn6YMuZwiShVpZPoxLTpuhBBCCGkNboNs3OickA523AghhBBSNy6yDeq40ew+DWwlQgghhJA2gSNuhBBCCKkb3+6O04E0i2nRcSvCggcLQG0Gpjrj0loNVlVj1ar5XeFsEN3LTgiyvBTsEe4lhwT/AMl7gWqY70iyWlYxiDOyrme1gyR0V2Y1WVxYjqdxVBDhSDxY2QCIOBsAvoOBv486HYi9cDxQHQN8md5hQOjLRvll/co8clmVhvz68uIcE6rZmZSdFHynhfiyK50VyukdMedcva6RsgwXhuEAdjmvmi/S9oEzg0B2avDTJccG/2RFo0TjujQ1PU5fJo1jQty9lebprfsp09wzSY4NhhKXszkAUILhlOCaWRiOC9d04Rjl56CheUaWn5uVzgZCLmRapy7FeUGXXu2ZnlanlnRVx0L0/hL3j9A34GjfNYKkdxcAjAfvwWbjwkSmAd2JRnimngvwUykhhBBCSJtQc8ft0KFD8DyvQu55Hg4dOlRTWXfeeScymUxkW7p0aa1VIoQQQkiLKEXG2evfSvxUmoqaxyUXL16Mo0ePYt68eRH5iRMnsHjxYrhubYvcXnLJJXj00UfLFTI5VEoIIYS0C26DbNw4HUg6au4leZ6HTCZTIT99+jTy+bwmR5UKmCZ6e3trzifjBK7Iae0N1HQRjrNL0JVVzYYuYoOg2LXJYdW2TU4rOZqL2HR8OzfT8+3c1Mly09it1SJLk1YvSVdfGhu3tBPwAtEJcUNZ+U+Gzl4tVNPYrQGosF3zD1u2q/LTorZZQhbd6+3V0uhULzvZHk7OqyKuYRNu5D4QZQhbN7+8eHs3wNLbmyXZomnT6ssv72HAt4kTMjtBVy5P+kOq2siVw+W2M5UmzSTZvgkmYu9WjaR7rZodHABPiquPJdcU+6wkkyYxNyrtsvzDlq8rQ3PyRni1+deZAyNiA+bbyhVjbdpke7I4ezl5H2czp+YXZbia44s0I6Ibrbt83io6vST9ONtsMr1J3XHbtGkTACCTyeC2225DZ2dnmOa6Lvbs2YNly5bVXIHnn38efX19yOfzWLVqFbZt24aFCxfWXA4hhBBCmg9H3JpL6o7b/v37Afgjbs888wwsq+y9YlkWLr/8ctx66601HXxgYAAPPPAAlixZgqNHj2Lr1q24+uqrceDAAXR1dVXoFwoFFAqFMD48PFzT8QghhBBC2pnUHbfHH38cALBhwwbcfffd6O7unvDBr7vuujB82WWXYWBgABdddBEeeugh3HzzzRX627Ztw9atWyd8XEIIIYQ0BgdZeA0ZceNEF2mouZXuv//+hnTadMyaNQsXX3wxXnjhBW36li1bcOrUqXAbHByclHoQQgghJB2+zV9jNlKdKdVKp0+fxosvvoj3ve992nTbtmHbdk1lxjkmlGWV/xLSOiYklRMxojVcuK4Bw3RDxwMRNlUrZrkMSV9YO5ccI2r5rFoKO5qf1Kl0JommJyc3lESHhMppZny5poJKu2WluKGk6RwNVL1IOMbpIEyPMZaX9erTSWdgn8YhIY2eDtkYWnZCkM89yVBapLuJdfCdFYoNOOf6ddP9tqGuIaUbUj4bFfra/AqmxvtednqIykta+WQiOxpE5ZpJYQ31maqfHFYOOzHyuGdvGsTvKAz75fKTrnm1DNUJQqBe+0nOBrr81dA5YagOCiKdnNu0tON266234l3vehcuuugiHDlyBHfccQcMw8DatWtbWS1CCCGEpITOCc2lpR23w4cPY+3atTh+/Djmzp2Lq666Ck8++STmzp3bymoRQgghJCWlBnXcOAFvOlracduxY0crD08IIYQQ0lZMKRs3QgghhLQXDgxkOeLWNKZFx82Eb7yrGoSqxtWykbA6Y3c1w9Bq6AxUZUNSwwjKDAzfhbMC4K+UIBvHu4qRsqM4ILg6BwSIFReK2jTtKgxNIpvggAFUOhOU5Rqj7grHgypxQzUaTzZKV+Np9LUz7Vc1eK/utKDTS3aSqN1ZIm7VBIF/H1TeN9VQnRxEOeJ+qKyXL493WLC056E7l/jfRu8wUD1f9DpMc93E5ZVXcKgoT2naUDfBHyut0X09VPutdek6w/lKhzAzNl3nwFDN2SHNijc63TSkWb1A1dU5EMSlqatHxK0SUXksvfPCZF4PZOowLTpuhBBCCGkNLgx4DehOcMQtHey4EUIIIaRu/I4bP5U2C05TTAghhBDSJnDEjRBCCCF1wxG35jJtOm6yQaegmrFmksGpzkBUNQBVjU1lg1Hd8V0pHJlt3FAMdgNjZNf1dSypXnEOCG4Nzgeqs0MjSFoBQibOESEpTXUwAGJmo69qKJ7O4LxSN9moPVm/vry1zexfu6F+GpIcC9IabEfLke+deGeFsrF2vMNCNE9Zr/Kc45w6LCVeGY47XrxusmNCnCNI3O9S7ffS3QPNIGlFgKRVNWT0Tgy1rbgg54nTT1r1ptrKOGo5tThZVEPnSBd3T8WtnqBzUBhPXYPG4pYMeKUGdNwaUMa5AD+VEkIIIYS0CdNmxI0QQgghzcd1jIZMOeW1cNqqdoIdN0IIIYTUjeuYyMTML1oLXgPKOBfgp1JCCCGEkDZhWnRvjcB0tL68+lUSVGNQABHnB9kJwYgYsSqrHkTSys1thTKRXlTiiMykHpajGUl2YSbOrh7RdY2Is8NE0DkNJOpXMaaeqPH2RB0WdGWknSU/rVF7mhUa5Dxpjlnv6g61IK+g4AT3hDrje7SeTowBerLDkM4BQs4XPaZs3B3XBtUdF3T5yrp6JwZ9vPr1p8tXTR5XdhzVVsOoh1pWHIhzXtAZ71dzWqjmANCMVRd0+km6DoxEB440JDkgxDkoAJO7kkYSrpNFpiGfSjmWlAa2EiGEEEJImzAtRtwIIYQQ0hpcx2jQiBudE9LAjhshhBBC6sZxDGTG2XFrFm3dcfM8DwAwPnwWgGyHkA3ilRMplrS2DfE2DaUYG4qo7URWq1N57MrmVmeKjps5upTwVVtXbhye27gbo1SjjVumip1OCaWYfPrjVMory6/UUePqMaNlyPk9Ja+XMk0+ZknRE/GSclwvqFecvl9qpY2bnG5I5xZn2+VG5LpJe0vafE4VWzrV1kZne5dNYW8Wfw7R8rOpbQr156PXrRYvJaardSnXtR4bt/T3mhlzH02EWqwiXWRi5JUk332VZbnwYuO6cPQuLFWEHUlWCvOUNPplO2c5rYQ4Gzf5PjVi9sJ+M1tFT7Wnyyp1KT//x4d9a07xbiTTk7buuI2MjAAAHu7f1OKaEEIIIVODkZER9PT0NO14nmvCcxvQnWhEGecAbd1KfX19GBwcRFdXFzIZ/b88Qggh5FzA8zyMjIygr6+vuQd2DH9rRDmkKm3dcctms1iwYEGrq0EIIYRMCZo50kZaQ1t33AghhBDSYjji1lTYcSOEEEJI/bgZwGmAuZJLk6c0cAJeQgghhJA2gSNuhBBCCKkfB7XNGZNUDqkKR9wIIYQQQtoEjrgRQgghpH444tZU2HEjhBBCSP2w49ZU+KmUEEIIIaRN4IgbIYQQQurHATDeoHJIVdhxI4QQQkj9uMHWiHJIVfiplBBCCCGkTeCIGyGEEELqh84JTYUjboQQQgghbQJH3AghhBBSPxxxayrsuBFCCCGkfthxayr8VEoIIYSQac2JEyewbt06dHd3Y9asWbj55ptx+vTpVHk9z8N1112HTCaDb33rW5Nb0RSw40YIIYSQ+nFRHnWbyDaJ04GsW7cOzz77LB555BE8/PDD+N73vocPfvCDqfJu374dmUxm8ipXIy3vuN17771YtGgR8vk8BgYGsHfv3lZXiRBCCCFpaUSnrVGfWzX8/Oc/x86dO/G//tf/wsDAAK666ip88YtfxI4dO3DkyJHEvE8//TT+8i//El/+8pcnp3J10FIbtwcffBCbNm3Cfffdh4GBAWzfvh1r1qzBwYMHMW/evKr5S6USjhw5gq6urinVGyaEEEKajed5GBkZQV9fH7LZlo/LTBl2796NWbNmYcWKFaFs9erVyGaz2LNnD2644QZtvtHRUfzX//pfce+996K3t7dZ1a1KSztuf/VXf4UPfOAD2LBhAwDgvvvuw7/+67/iy1/+MjZv3lw1/5EjR9Df3z/Z1SSEEELahsHBQSxYsKB5B2ywc8Lw8HBEbNs2bNuuu9ihoaGKwSDTNDF79mwMDQ3F5vvYxz6Gt73tbfi93/u9uo89GbSs41YsFrFv3z5s2bIllGWzWaxevRq7d+9OVUZXVxcA4NBPgZ5O+D/6KPzv5GNKvBDECwCKQfiMklYM8gmZLHeCtKKmHDmPC3gF4GwBcBxgrOgv4TYGf+9I4bNBtnEpTWy6OFC+N5LuEVPa54K9CaAj2HcByAfxPIDzAHRnga6ZQO48AN0AOoP9XACzg0yzAVwQZJjt71+/YAZOoQcnMBsn0YNXcCFOYhZOYDZOYRaOojcI92CocAGGj/cAx/PAcQBHAJyCH5b3J4Pf5lSwPx00VNhqogVHpNYRLSlaRrdwXk5poRwAQ2olOS5aS+yDEV0jaDQTgB3sZwT7fJA+U0rPK3uhL5cxUypX1c8DsD3AdJDJF2HZBdj5cRimi5xRgI1x5FCACRcGXFgowkIRRhC3UURWCgu5f/aFoDXc4NRKYZrAkK40V3pcuDCCfRYODLgwg9z+5iCLImyUYKAQ1srfCrAwDhuj6MB4wUJhLIfCmU7gTN7/aQvwr4EC/N/+DMrXgbguxoKwrHsmkIv08FRGA4G4doaDRBEfRflOO4v67zwZUxPOIXp3qnJVFnd9QiPLacqRr3fli4ShqYqhZDcVXVlfl79amqHIdHmqlaPK85o6Jp2PLAvuK5guMqYLw3RhGE54f2WN6D1joRCES7BRQDa43wxpb8AJ7skiDDgw4cLCuJRXf4+W7+FSeJeIY3VgNHJcUbaNcRhwkUMhDBd+PYa3LHLDd2PTEC+xRpQDVAzI3HHHHbjzzjsr1Ddv3ozPfvaziUX+/Oc/r6sq//zP/4zHHnsM+/fvryv/ZNKyjtvrr78O13Uxf/78iHz+/Pl47rnntHkKhQIKhUIYHxkZAQB0dwHdouOWhf9MNoN4JogbQdyQwiVJR+y9QN8LtmywF+WUgoO7kp54IAW6XgbIZQAn4z86x4PqiG6FEYSzKL8axhHtsJlKXBwiqVsikB/X8uNddEE6g7DYugB0ZYDuDJDLovxwywGwUO5AdASZZ8DvbHQBhe4MXGRRgIFxmOiAhTFYsJGHhTxy6ISJGTAwE5lCF1DsBgrBC7oD/gvXDo4jv3eMoIEykN454yi/oMaDxpdbqZ6Om9pKcmvJrRZUIiNt2WAzpE19b4o2FO0oOnh5KdyhyCu2csctky/4e9NF1rCQRREGclKXqQBTipsww3AORqTjZgUmruWOWzlNUL3jZiAbHEmEszCQgQEPdvhqKsGCCwsGbBiw4MJGFp3IFCxkLAvIdgKZfLntxoP2LAWbbPxsBbIiove6+D0i14z4veWLq6RkACo7afXceTI5KazruOnCqizu+tTlidMXx1c6bnIbqdezvAHR61vE1U6WroOlS0vSSVOOKs8npFfb8tGOm7850v3lP9mycIM/P/J9ZgZXfQ4GHOTC+8xBDkVYMKSOmwEbGanjlpHiTvD481D+8+UFf3n8O6sTZnBHucHdY0h3lwcL2aC8DCzX/1Hb3XRocHAQ3d3dYTxutO3jH/84brrppsSy3vCGN6C3txevvvpqRO44Dk6cOBH7CfSxxx7Diy++iFmzZkXk7373u3H11VfjO9/5TtXzmCxa1nGrh23btmHr1q2trgYhhBBCBA1eZL67uzvScYtj7ty5mDt3blW9VatW4eTJk9i3bx+WL18OwO+YlUolDAwMaPNs3rwZ/+2//beI7NJLL8XnP/95vOtd76p6zMmkZdaLc+bMgWEYOHbsWER+7Nix2B7wli1bcOrUqXAbHBxsRlUJIYQQ0qa8+c1vxrXXXosPfOAD2Lt3L374wx9i48aNeO9734u+vj4AwCuvvIKlS5eGM1v09vbirW99a2QDgIULF2Lx4sUtOxeghSNulmVh+fLl2LVrF66//noAvpforl27sHHjRm2eOAPFH89+M3q6EQw7l20Nyh9wypY3dqEIwynB8EfIkZHnjxF2Meq8MiIsvtLKcVUnKLMziHeLfyFjwV7RjZTnKDpQZFBkcXFTE1btS9TPenbMfgaiNlfCPssBMAzMxWnMyZ9G34wjKNgW3oyf4Sw6UYCFs+jECLowik6MogOn7S6MXtiJwoXRtCIsjIbxDhRhowgLI+hCIbCFKro2Rk93oDhmozQ2GxjL+W0qNkcTTnI3V41pazGs1bVv3OegamFZJuLyuZgAzAyAHEpmDmPmjPBSiuSJlOdJsjothp2gMEf65KK2XVJ8TEmL+z1UeVw8TX7xuXmWWrfOYFPqWYEnZQKin0XlTLUa8+Q0MjMmXchTfOqKu5Z0abVen0nXaD1lJMV1nzurHTN1mhfeA9l8EQB8WzbTgSns2kwXhuGGnzbl90VyvCyTESllLLihmYKDIiycVd9L0nur4p0VpPklFbTpfloRY0YBwE/QdOR31kTLmSS+9rWvYePGjbjmmmuQzWbx7ne/G1/4whfC9PHxcRw8eBCjo6OTV4kG0dJPpZs2bcL69euxYsUKrFy5Etu3b8eZM2dCL1NCCCGETHES/xDVWM4kMXv2bHz961+PTV+0aBE8z4tNB1A1vVm0tON244034rXXXsPtt9+OoaEhLFu2DDt37qxwWCCEEEIIIVPAOWHjxo2xn0YJIYQQMsVpgxG36UTLO26EEEIIaWPYcWsq06LjdggL0RXMeSMbdwK+wSaAstz2t4hMMvQU+WR5qOu6MBwXhuNP5hZxcAD0DgdA1CEBihwp5EnhWkgyqq/mvCB08uU0zwQKNuCaWbimX4CNYjB3kYVOnEUXRlAIZhzyJ2KNhguw4MIMJ2Ytp9uBzN+7hoFCj41ijwUHRujAIMJyHhGWf1WhE7qsuAZcx98cx4DrmHAdAyXHAByj0jhf9/upe91vo/utqv1+aR+CsToZKS1XvV7Vwkn7emS1hpPSgei17KDsPKOrc1I4bDfhLKA4FaT5TZKeqLo03T2pxuN0khwTat3XmjZZ4Qk7PpTnZgOAbOiA4DsjAKhwSPCLib4HdDLVCUHgBI4HqkOC/+6wEp0dxHFkZwUAsANPuLi8flqls8RZjKMlzgmkqUyLjhshhBBCWkQbeJVOJ9hxI4QQQkj98FNpU2nZBLyEEEIIIaQ2OOJGCCGEkPoRaws3ohxSlWnRcTuO2RiFFXFKkPeyYanOuLNSHpNuuIABGHbUeFXNI8dNTX1kPdMtf9Q3HDlcksLlczVjbAAyNQwxe5pf3ZFuOtcU+2ywNyQ937gfiM4Q7oQtaIYy4QwQ1h0ugAJcmMGCyUV0Sg4DwtlAXu9COC9E3Ueq66r5KsoxDLiGCddWXVPK+f1zqDy2cGwAUOHcAEDv4FDN8F5OMzW6cfGkfRqdRuvWmz9NWDgfmEpYlydJliSvh4k4JCTFk/TinAnSyprl2JBGp15HCADyyggwXWQjDgjBMzZwRgjlRvzzX3VMEIhnntCPOiL4i+jIaa7WycFAEdAeR30vnEVHxOlATotzUgCAcZwFmf5Mi44bIYQQQlpEgxeZJ8mw40YIIYSQ+qFzQlOhcwIhhBBCSJvAETdCCCGE1A/ncWsq06LjdgLnY0ZwKqrBaXSflFZpAFpfelRPpxsJG5KuUdaFHdVX85dljR1bdjWXhGyIK4eF44GcR3ZMEDo6ZwbZcUF2aACi52SjCDc47wJsGDCAYM0F1TmhQ4mrDge6eF06hhE6aQjnBvk8i4XAsUG3KgNQdlxQV2XQrQ4gx01UfpKQ5aYmTd1PlgNCUlgg16/ak0d20NDpprnsJ3JrpH0yxulNxClhMsL1OjZU29eTR3YyUONV91FnBACxDglCFqYZyc/wNIhnVuVKCeV02UnB1zM1Tg/+igo6ZwWEsvj6qs53In0scKpqOg4a41XKT6Wp4KdSQgghhJA2oeaO26FDh+B5XoXc8zwcOnSoIZUihBBCSJsw3sCNVKXmjtvixYvx2muvVchPnDiBxYsX11TWnXfeiUwmE9mWLl1aa5UIIYQQ0ircBm6kKjXbuHmeh0wmUyE/ffo08vl8zRW45JJL8Oijj5YrZNZudncaM1FCDkB6G7U0OqZ0Fak6acusDFfq6vV09mz127ipx5JxUhgnqLZvqn1HWjs4nQ2cml7NDk61KZNJag8xCaYLN2KzJsvkY6WxdwNQMVmvbQf2d3Z5sl4xOa/W5m3MDhorU93OTReXw2YVmWoPp9ujxjQoYRHXhXXxOFmSPA1x9nG1kNYWr1ZZvfZucnwiOpNhB1erfpxuJB583Umwa/P38bZtAKrat+mereWnRdRWrZqdm9AzI3n19m7lY0dt3tLUVZdeCN6DZHqT+rG2adMmAEAmk8Ftt92Gzs7OMM11XezZswfLli2rvQKmid7e3przEUIIIWQKQK/SppK647Z//34A/ojbM888A8sqe69YloXLL78ct956a80VeP7559HX14d8Po9Vq1Zh27ZtWLhwoVa3UCigUCiE8eHh4ZqPRwghhBDSrqTuuD3++OMAgA0bNuDuu+9Gd3f3hA8+MDCABx54AEuWLMHRo0exdetWXH311Thw4AC6uroq9Ldt24atW7dO+LiEEEIIaRAOGjNHBacDSUXNFiD3339/ww5+3XXXheHLLrsMAwMDuOiii/DQQw/h5ptvrtDfsmVL+MkW8Efc+vv7G1YfQgghhNTIOIBK0/f6yiFVmVIT8M6aNQsXX3wxXnjhBW26bduwbbtCfhYdcJFPNDidiCOBzkkhTjetflJ+XTlxZaRNaxR6Y9yoTHZ20E3OK4drdWTQOTHEOTDIzg1qHhm53WT9pPY0JQcHf5JgYbDsBAbIgcODYcA1TMAGXNeA4RhwHRdO4JjgOiZc0/UdFcTEvEC8o0It4SSZmhaXHpeWNhwna5QzQhr9ep9ySfkma+LdWuNpwnFpE3VcmGi6Nk3vjABUOiT4Yb1TghxuxMS7cQ4KopwkJwUxKa/OUSGpXkb4LIt7J1mKvosip2Y9J5hSv/Lp06fx4osv4oILLmh1VQghhBCSBk4H0lRa2nG79dZb8d3vfhcvv/wynnjiCdxwww0wDANr165tZbUIIYQQkhangRupSks/lR4+fBhr167F8ePHMXfuXFx11VV48sknMXfu3FZWixBCCCFkStLSjtuOHTtaeXhCCCGETBTO49ZUppRzQr2cRQcAKzLrNFDdYSCts0B6Z4N0qyJUyxtXRlzetGkTRWeAm5QW56Sg6qtOBrJ+mpUW1H3SagzqqgdJqzEkOTLIzghJ+EbIwaoMhm8o7ZrCScGAabrKagrB76dzVPBPoLHOCLU6J6QNp4lXk9eqUwtpn3yNWjlBJ2+W00JSWrPCsenSutcJDglA5SoJQLJTAhDvmCCje2aqDgUyOgeFtOjKTeus4If9Y+pWWACAEns+5wTTouNGCCGEkBbRqGk8OB1IKthxI4QQQkj9uGiMqyMHDFMxpaYDIYQQQggh8XDEjRBCCCH146AxKydwOpBUTIuOWwE2PHRonAOs0ICzGMjTOCBU6qVf8SCN8avOGDbOyD3OQSGunEboJjkhpNXVGe4mGf4nOSjI6UlODdVWVVDLqbbyQtKKDGmQZ1QXv6MLMzSYrtA3ndBJAabrOyo4hn+XxjkqqPuktKR9NVnacJp4nKyW9MkizROxWSsqpNGZDIeFpLQJOz1onBGAqg4JfjjZKUGOy/dYNQcinQOCLr3skFReQQGIOhyU05McuaIrKqh1iHNWAKIOC+XjlY81jlLiuU4a7Lg1FX4qJYQQQghpE6bFiBshhBBCWkSjRso44pYKdtwIIYQQUj8uGvOplF6lqeCnUkIIIYSQNmFajLiNwwrMOWXD9TQOBMnOC8l59fq1ySbXIaEefZU0hvhJOqqTQpoVFHTxpFUV5HCalRXS6MmrKOgcI9T8KgacwAi5bHCcxkEBKDspGKYbrKbgOytoHRX8ytS3ryZLG64nXk1eq04jaMRqCrWmNVI2FRwZKnQ9Ja1+hwSg7JRQqVe5WgKQ7ICmQ+d04MuTnQfE86AWJ4Vajyfry89D+bxK4ZusyfBTaVPhiBshhBBCSJswLUbcCCGEENIiOOLWVNhxI4QQQkj9OAC8qlrVoXNCKtq64+Z5/pUyPny2wpYrycatFEmLTlhYzcbNrUhPa89WOTFinI2bM41s3Crt1tTfKZugq7d/09u4+eWotmelWBu3rLasEmQbN33eUiRN5M9q9Mp1KIWybCj3XF/mOQY8R4SzQZoZpiFIK++D29atYuPmxsh1tmquRpY2rObXpU/Exq1ZD/O080430sZNd8xG2bipZU/Exs1ISEuKG+ls3Ly4sBG9QDyzVDVPSbJxy0gXWEl5BmfgasPyRRmVy2G5LL2+FxNOTpPt1eLCSptIdSkNn/VlXiN6UWSq0tYdt5GREQDAw/2bWlwTQggh9SJ3M5L+HxSaUJfpwMjICHp6epp3wEb9ueKIWyrauuPW19eHwcFBdHV1IZNpxCQyhBBCSHvieR5GRkbQ19fX3APzU2lTaeuOWzabxYIFC1pdDUIIIWRK0NSRNtIS2rrjRgghhJAWwxG3psKOGyGEEELqxwE0/ne104gyzgE4AS8hhBBCSJvAETdCCCGE1I+Lxnwq5YhbKjjiRgghhBDSJnDEjRBCCCH146Axw0AccUsFO26EEEIIqR923JoKP5USQgghhLQJHHEjhBBCSP2MgyNuTYQdN0IIIYTUTwmN8SptRBnnAPxUSgghhBDSJnDEjRBCCCH14wDINKAcjrilgiNuhBBCCCFtAkfcCCGEEFI/HHFrKuy4EUIIIaR+xsGOWxPhp1JCCCGEkDaBI26EEEIIqR8XHHFrIi0fcbv33nuxaNEi5PN5DAwMYO/eva2uEiGEEEJqwWvARlLR0hG3Bx98EJs2bcJ9992HgYEBbN++HWvWrMHBgwcxb968qvlLpRKOHDmCrq4uZDKN6O4TQggh7YnneRgZGUFfXx+y2ZaPy5BJIuN5Xsv6uQMDA7jyyitxzz33APA7Yv39/bjllluwefPmqvkPHz6M/v7+ya4mIYQQ0jYMDg5iwYIFk36c4eFh9PT0ADgFoLsRJQLowalTp9Dd3YjypictG3ErFovYt28ftmzZEsqy2SxWr16N3bt3pyqjq6sLADD4TqA7B98luQD/ezukuAiXgr3Y3GBzAp0g7AX5HRcYdwAnSHccwAnWUhsPNpFNyBwprKZBky7rqHI5LHBSyurRqZWJXjyNyO+kKEd37qYkj8tfS5vF6cbJdb9tLeXo9NQy671W4jCVcC7Ym1I8H4S7AHQEsplBvMsCumYAmU74z/huADOC/VwAswPF2QB6AZwHYB4wdh7wyow+nEQPTmA2XsGFOI7zcQKzcRyz8QoW4ISInzoPhV/OBo4DeBX+/hCAkwBOBPtX4b9nTomzOQH/hTEG4NcAzgZhsRd3thPI5Jas1qK6VhNhU5HlNfEcKls3B8AA0KmU04GIoZERiPNBOC+p2spepMl6tqJfTS7y5pVjR/Q9IF9AxnRhmC5suwjDdJGzizDgwMY4DLjIwoGNIiwUYcJFFi4sFGGjiCxcGHBD/Rz8vCZcWBiHAQcWijCCPEagH81fPpafVgjzlmXRsmyprBwKMFGChaJf10IRhuPBcADTBTLiPeQAKAb7MZTfQQWU30FyPC5d7OXy1DQXGD4L9H+j/G4k05OWddxef/11uK6L+fPnR+Tz58/Hc889p81TKBRQKBTC+MjICAC/09adg//MKiFqJOkqYfV7uoeypV8Q9oLOmZMBxjP+HgjCgarccZNlasesWlyWqfK0Hbe4TkC1fBNlohdPrrpK1eNPlY5brR2xWo+ZplNmpNBJc63EIf9ecsdN3ncE4Rmo7Lh1Z4CuDJDJovxiFxktlDsBHUEBQUarGzg1IwsHBgow0QELediwkYeFDpjohIEZyGImMl43MLPbf0l2BOVZwSaOl4ViSD0O/+Y34b8Vs5JSBuWrRegB+js5bavpWhBS68lxXesKWacSVzpuGWnLKpuB6G+g9iNNRNvMRmUnT4Rripc7bhnTRSYIZ22/A5SVOlYGijBQCDtLJnIwYYZxAw5yKMKCIXXcjKBTlg06XxmYYUfMPwU/bzYIZ4NwCRa8oEkyMJCBhRIMeLBhwACCMj0Y8GAhCxMerEDXLmSiHbcxVHbKTEkmLimxGYh2wrJKutxxywT6rpQvi8ggBE2HKjlx4gRuueUW/Mu//Auy2Sze/e534+6778bMmTMT8+3evRuf+tSnsGfPHhiGgWXLluHf/u3f0NHR0aSaV9JWH8G3bduGnp6ecONnUkIIIYRUY926dXj22WfxyCOP4OGHH8b3vvc9fPCDH0zMs3v3blx77bV4xzvegb179+Kpp57Cxo0bW24/2LIRtzlz5sAwDBw7diwiP3bsGHp7e7V5tmzZgk2bNoXx4eFhdt4IIYQQEsvPf/5z7Ny5E0899RRWrFgBAPjiF7+I3/3d38XnPvc59PX1afN97GMfw4c//OGIzf2SJUuaUuckWtZxsywLy5cvx65du3D99dcD8J0Tdu3ahY0bN2rz2LYN27YrE96M8tcFeWhZjit2bFqdIJwJ5DnH3yL5kJxXqwtFH4Dn+DZ0AtmWTsSBso74IKN+cpVl9cjVtDidWvTSpFUrt5Z89eR3YsJJ1POZMe4GS3vjJX1OVsvIacKmFE/6UCc+ynXYgGn6+4ywTxKfMGco4Z4gPgPA+cF+hhTvhv+5sxsYnp/DqNGJY+jCCLpwHOdjJAhXi4+iEyfdWRg52YXx0x3A6zngNPxtDL7dmgiPKWGxic9TMwEsQvS54JzvVzjNRaE2upmwNzVxNU2W51OkJ5VR7wb4nzDN4DsfgFy+CMN0YAa2aIbpwjDc8JOk/LkyOT55OgBgS59S5TiA0HbNby7fxs2X13N8J/hcWz5WWLbrwhDGz+p1ITAkmbB3AyrfR+K6S0rXvcuE7AxahGw8NNFyGs/u3bsxa9assNMGAKtXr0Y2m8WePXtwww03VOR59dVXsWfPHqxbtw5ve9vb8OKLL2Lp0qX4zGc+g6uuumpS6pmWlnXcAGDTpk1Yv349VqxYgZUrV2L79u04c+YMNmzY0MpqEUIIISQ1cu9xouX4X9NkYgdtUjI0NFQxxZhpmpg9ezaGhoa0eX75y18CAO6880587nOfw7Jly/CVr3wF11xzDQ4cOIA3velNdddnorT0Q+2NN96Iz33uc7j99tuxbNkyPP3009i5c2eFwwIhhBBCzg36+/sj9uzbtm3T6m3evBmZTCZxi3N2rEap5I+i/uEf/iE2bNiAK664Ap///OexZMkSfPnLX6773BpBS0fcAGDjxo2xn0YJIYQQMtVp7KfSwcHByDxucaNtH//4x3HTTTcllviGN7wBvb29ePXVVyNyx3Fw4sSJWJv6Cy64AADwlre8JSJ/85vfjEOHDiUec7JpeceNEEIIIe1MYz+Vdnd3p5qAd+7cuZg7d25VvVWrVuHkyZPYt28fli9fDgB47LHHUCqVMDAwoM2zaNEi9PX14eDBgxH5L37xC1x33XVVjzmZTI+O2zz41tVpHAUUJ4FYWb36umOiMk/GCQzFJUeI2LLkeJU0T3FqAMqODkDZASIik3WhD9fi3NBI54c43ST9NHnryRd3s6Sdj06nZ2rS42S6cIekZxpARx7ImX44o060Kk+gKuLyfoYSniHJVGeEID42AxidkccIunAWnRhFJ0bRgdOBU8EoOnEWHaGTgRwvwMZZdKAAGyPoQhEWRtEZ7guwUHRtFMcsFMZsjI9ZgGOWz2MmfCPuOVCcDaQNmrBMWicEVaY6I4hwNWeFJFlFeuAwAACmi2zgJAAgdBzww2XnASBqfO/Hy8b25XiSrq/vV8VNlMnl69PSl19L3Seqn7YuwiFB226uC0N6eIo53CKokysKhCOKmMPNRvS9IeJCJ8kxTo53xhzvHOfNb34zrr32WnzgAx/Afffdh/HxcWzcuBHvfe97Q4/SV155Bddccw2+8pWvYOXKlchkMvjEJz6BO+64A5dffjmWLVuGv//7v8dzzz2Hf/zHf2zp+UyPjhshhBBCWoSDxnwqbcSonZ6vfe1r2LhxI6655ppwAt4vfOELYfr4+DgOHjyI0dHRUPbRj34UY2Nj+NjHPoYTJ07g8ssvxyOPPII3vvGNk1bPNLDjRgghhJAJMLWnAwGA2bNn4+tf/3ps+qJFi6Bbun3z5s2p1k5vJm21cgIhhBBCyLkMR9wIIYQQMgEa65xAkpkeHbcu+EaZsnEnkN6RoBHyevMl6dSRJpYWzkl6uaQydOUoOp4Urub0oE1TDHbjHCA0h06tE6eXpN9odDeTusS4KjeVuHAyyAUJpqk4G5iILg5uV9nPkOJJzgg654SZ5bTxGcDZmTkUDBuj6EAR/v4sOiNOBnJaEbbvYAA7dDoQcScw9QZ8Q+9OjMKAAwtFFGGhCyMowIZrGHBnGCjM8KcDcGGgACsIm3BdA67jlyP2Thg3I/J6MBRrc8OMXkmmlG5IzgKhTHIYABAxdI/uK9OT0tLopEvTG+2X9RqbV5c2kfOprEt9xxXlinBiXjeQOeUVE4xqD5ikN61YcF7c27IMiDovAOU+ki3FRRrXlj8nmB4dN0IIIYS0iKnvnDCdYMeNEEIIIROAn0qbCZ0TCCGEEELaBI64EUIIIWQCTP3pQKYT06PjNgNRQ02xlw061TSgPocBWafetCRngCqOAonHamS6FM5I4chqD6p+UrlKmqfkUx0YgKiDA5DsAKGiK6+i/OoqIUmrI5iK7XtOuqtMMyoTuhl5lnzhbKDGdc4IBnwHAiGTw/LqCEJPOB5Uc1TQyMZmAK6ZRcG2Ig4HvoNAZdxFuSFMuHDhwkYxlNkooAMGirBRhCXNS+87HLhQ5+n30wGgGDgkyDIXBmAArhE4I9hGqCPjTvAxZ1Rc5GXjdT9dcWCISVON5uX0JD29Tn1ODyKtEWXVnj7VynEi8arlSE4J/j7qmCB8UjLq5WIg+ixMezmKfLLzglhpQS5DfqbPSFl2w+Gn0mbCT6WEEEIIIW3C9BhxI4QQQkiLoFdpM6l5xO3QoUPaZSE8z8OhQ4dqKuvOO+9EJpOJbEuXLq21SoQQQghpGU4DN1KNmkfcFi9ejKNHj2LevHkR+YkTJ7B48WK4bgrjIolLLrkEjz76aLlCZh2DgMJuByhPYKhOWChkqu2bOpEhkN6+rJreRNNr1a02wW5ceWnKrFZu2vKCeGSeSFdjQ+boZVqqXXL1PgviLkXdfK6mJmwocdWOTYRlfZ1dm87OrdoEvHK6nJbXyIWdXGDb5plAwQaK+Rwcwwjt2CpP2QVQCG3ICrBgBHZtBVjowFm4MCrs2WSbOFGubCMn27j5cTOSJsuFTEaO6+o9EVR7tjh5Zbx8EcbZx+ns3NLoq7ZYcXnS2NFVK68We7uJHTt9HdLXU2/TVrWeim2bH9bbtyUiT6pbPkilHVuaMnRlmQAKKepB2p6ae0me5yGTqZye+fTp08jn87VXwDTR29tbcz5CCCGETAXoVdpMUnfcNm3aBADIZDK47bbb0NnZGaa5ros9e/Zg2bJlNVfg+eefR19fH/L5PFatWoVt27Zh4cKFWt1CoYBCofyXYnh4uObjEUIIIYS0K6k7bvv37wfgj7g988wzsCwrTLMsC5dffjluvfXWmg4+MDCABx54AEuWLMHRo0exdetWXH311Thw4AC6uroq9Ldt24atW7fWdAxCCCGETCacDqSZpO64Pf744wCADRs24O6770Z3d/eED37dddeF4csuuwwDAwO46KKL8NBDD+Hmm2+u0N+yZUs48gf4I279/f0TrgchhBBC6oVepc2kZhu3+++/fzLqAQCYNWsWLr74YrzwwgvadNu2Ydu2JgG+YbVqtClPWAiUjUAh6ci2y7pJDW1Ey4NGR3VwEOFaHAomqlOPo0CNDgWp8uniOsNd3f2pkyUZ/TbrHld/d9XePckxQch0Dgtxk+5CiSc5J6h6tiK3NWnyBL2KY4NnAo5yfgZcuDBgwIWFAoqwYaMAA07oOGDAgYVi6FhgBRPqAoA8wa6Iq5PsxjkfyHIAUB0T5LQkJwUZdYLeWjATLkid40IaWZxTgao72Q4PteRrjG79ThW11EWW1VR+glOCH0YFFZPvxiG/p1QHBTk9zRtazqd5PZLpx5SagPf06dN48cUXccEFF7S6KoQQQghJBacDaSYt7bjdeuut+O53v4uXX34ZTzzxBG644QYYhoG1a9e2slqEEEIISc14AzdSjZaunHD48GGsXbsWx48fx9y5c3HVVVfhySefxNy5c1tZLUIIIYSQKUlLO247duxo5eEJIYQQMmE4j1szmR5rlRqoNAZXjTzVsGwQCkQNQas5NMjHBaIrMah6OicHVV/o6RwcgHTOCUl61eKT4WyQ1vkgrrwk/Vp1qpF0F+jS4hxa1BUSZN24VRPEXueUoMZVRwSgfJ3IDgdyvnyVMhLs9EOjbAPwJ/+xwrUP/BURbLiSgbfsJNAhOR24MNCpcTqQHQ7UVRDk9DgdNaw6HbgxP2yjV1MA4ldU8NP0F2mSI4I+Hi2nNkeGyXFsSM5Tf/409YvTr+aMkHgsaeUf2SnBj0dXS/D1y+FM0rM5LXHvI927CZr06fFGJ1Xgz0wIIYSQCcB53JoJO26EEEIImQCcx62ZTKnpQAghhBBCSDwccSOEEELIBOCn0mYyPTpuutnq0+ZTnRXk8pIcFtLoyToiDTHxNM4LIk3EdSs06MpWnR10eep1Lki7KkKSPGl1hDT56yXp6tddS6q+zglBlqt7nVOCKo9zUpAdC9R43GoLQKXzQtJqDEI1/D3Ks8QLBwWxgoK8d2GGht71rIagpqtpQNTxQLdqQlJYppZVE+KcG+KcDeKodbWFOHk1ZwXdsZrl8JBUTqMdJdQ8cc4ItZSRxinBD5flsY4JKnJx1ZzldCTlmTKMozHdCXqVpoGfSgkhhBBC2oTpMeJGCCGEkBbBT6XNhB03QgghhEwAepU2E34qJYQQQghpE6bPiJvqBKBb+SBNGXEdftVAFKg0ElWPleS0kKQrywS2Jp7kYJBmFQbE6KhlVcsbR7U/T7X8uUrrwBBHGkPeuOskySlBLlu3ioIuvZqzQtzqCklODLJc1VPjuvMM2jcDwDMrHRQMx4VrunCMsjOCEa5uUAwcEvQOCDrHA9XpQOdwoO5l/bg8cXE1r444Z4R6SePEUI/jQlxaPc4KOlm1snV1rtdxIc3x1fxpnRGq1sNVnRDSOSX4eRFPvYNGcQ5yIp70/lHzNR1+Km0mHHEjhBBCCGkTps+IGyGEEEJawDgaMz8JpwNJAztuhBBCCJkA/FTaTNq64+Z5HgBg+IySIP/21SaaTUqvdZLaUkJ6LcdNq5OmjGp1TJtPd7w4vST9tHlrLasaaf4M6tpGd2w1rk7MrIaFQUI1Gzc5rrNxk8vR2bgZmry6fLK+Jr8X5HcMwDUB1/TvM9f04BgeSgji8OAGYQcluMgAAEpS2EUm/JnLsnJTq2miXN2+MgwpHP3x1LioYxIlqexGkJ1UG7fKc9HZuKWzX1N1dGXH25UBQLaGiW9NpXz1eGo8m5BuKr+ZkRDPKmmmq+g6alwf9vNG4xk5PpF3TJJu0vsnaBLxLhTvxuZRmGLlTG/auuN2/PhxAED/f2pxRQiZ1oiXgPhXzYcrIVOZkZER9PT0TPpxLMtCb28vhoY+37Aye3t7YVlWw8qbjmS85nfNG8bJkydx3nnn4dChQ025SM9FhoeH0d/fj8HBQXR3d7e6OtMOtu/kwvadfNjGk0st7et5HkZGRtDX14dstjm+h2NjYygWiw0rz7Is5PP5hpU3HWnrETdxYfb09PCBMcl0d3ezjScRtu/kwvadfNjGk0va9m32IEY+n2dHq8lwOhBCCCGEkDaBHTdCCCGEkDahrTtutm3jjjvugG2r0/6TRsE2nlzYvpML23fyYRtPLmxfotLWzgmEEEIIIecSbT3iRgghhBByLsGOGyGEEEJIm8COGyGEEEJIm8COGyGEEEJIm9DWHbd7770XixYtQj6fx8DAAPbu3dvqKrUF27Ztw5VXXomuri7MmzcP119/PQ4ePBjRGRsbw4c+9CGcf/75mDlzJt797nfj2LFjEZ1Dhw7hne98Jzo7OzFv3jx84hOfgONwkWCVu+66C5lMBh/96EdDGdt3Yrzyyiv4/d//fZx//vno6OjApZdeih/96Edhuud5uP3223HBBRego6MDq1evxvPPPx8p48SJE1i3bh26u7sxa9Ys3HzzzTh9+nSzT2VK4roubrvtNixevBgdHR144xvfiE9/+tORNTDZxun53ve+h3e9613o6+tDJpPBt771rUh6o9rypz/9Ka6++mrk83n09/fjz//8zyf71Egr8NqUHTt2eJZleV/+8pe9Z5991vvABz7gzZo1yzt27FirqzblWbNmjXf//fd7Bw4c8J5++mnvd3/3d72FCxd6p0+fDnX+6I/+yOvv7/d27drl/ehHP/J+67d+y3vb294WpjuO4731rW/1Vq9e7e3fv9/79re/7c2ZM8fbsmVLK05pyrJ3715v0aJF3mWXXeZ95CMfCeVs3/o5ceKEd9FFF3k33XSTt2fPHu+Xv/yl92//9m/eCy+8EOrcddddXk9Pj/etb33L+8lPfuL9x//4H73Fixd7Z8+eDXWuvfZa7/LLL/eefPJJ7/vf/773G7/xG97atWtbcUpTjs985jPe+eef7z388MPeSy+95H3jG9/wZs6c6d19992hDts4Pd/+9re9T33qU94//dM/eQC8b37zm5H0RrTlqVOnvPnz53vr1q3zDhw44P3DP/yD19HR4f3P//k/m3WapEm0bcdt5cqV3oc+9KEw7rqu19fX523btq2FtWpPXn31VQ+A993vftfzPM87efKkl8vlvG984xuhzs9//nMPgLd7927P8/wHUTab9YaGhkKdL33pS153d7dXKBSaewJTlJGREe9Nb3qT98gjj3hvf/vbw44b23difPKTn/Suuuqq2PRSqeT19vZ6f/EXfxHKTp486dm27f3DP/yD53me97Of/cwD4D311FOhzv/7f//Py2Qy3iuvvDJ5lW8T3vnOd3p/8Ad/EJH9p//0n7x169Z5nsc2nghqx61RbfnXf/3X3nnnnRd5Pnzyk5/0lixZMslnRJpNW34qLRaL2LdvH1avXh3KstksVq9ejd27d7ewZu3JqVOnAACzZ88GAOzbtw/j4+OR9l26dCkWLlwYtu/u3btx6aWXYv78+aHOmjVrMDw8jGeffbaJtZ+6fOhDH8I73/nOSDsCbN+J8s///M9YsWIF3vOe92DevHm44oor8Ld/+7dh+ksvvYShoaFI+/b09GBgYCDSvrNmzcKKFStCndWrVyObzWLPnj3NO5kpytve9jbs2rULv/jFLwAAP/nJT/CDH/wA1113HQC2cSNpVFvu3r0b/+7f/TtYlhXqrFmzBgcPHsSvf/3rJp0NaQZtucj866+/Dtd1Iy81AJg/fz6ee+65FtWqPSmVSvjoRz+K3/7t38Zb3/pWAMDQ0BAsy8KsWbMiuvPnz8fQ0FCoo2t/kXaus2PHDvz4xz/GU089VZHG9p0Yv/zlL/GlL30JmzZtwp/+6Z/iqaeewoc//GFYloX169eH7aNrP7l9582bF0k3TROzZ88+59sXADZv3ozh4WEsXboUhmHAdV185jOfwbp16wCAbdxAGtWWQ0NDWLx4cUUZIu28886blPqT5tOWHTfSOD70oQ/hwIED+MEPftDqqkwbBgcH8ZGPfASPPPII8vl8q6sz7SiVSlixYgX+7M/+DABwxRVX4MCBA7jvvvuwfv36FtduevDQQw/ha1/7Gr7+9a/jkksuwdNPP42PfvSj6OvrYxsT0mLa8lPpnDlzYBhGhRfesWPH0Nvb26JatR8bN27Eww8/jMcffxwLFiwI5b29vSgWizh58mREX27f3t5ebfuLtHOZffv24dVXX8Vv/uZvwjRNmKaJ7373u/jCF74A0zQxf/58tu8EuOCCC/CWt7wlInvzm9+MQ4cOASi3T9Lzobe3F6+++mok3XEcnDhx4pxvXwD4xCc+gc2bN+O9730vLr30Urzvfe/Dxz72MWzbtg0A27iRNKot+cw4d2jLjptlWVi+fDl27doVykqlEnbt2oVVq1a1sGbtged52LhxI775zW/iscceqxheX758OXK5XKR9Dx48iEOHDoXtu2rVKjzzzDORh8kjjzyC7u7uipfqucY111yDZ555Bk8//XS4rVixAuvWrQvDbN/6+e3f/u2K6Wt+8Ytf4KKLLgIALF68GL29vZH2HR4exp49eyLte/LkSezbty/Ueeyxx1AqlTAwMNCEs5jajI6OIpuNvh4Mw0CpVALANm4kjWrLVatW4Xvf+x7Gx8dDnUceeQRLlizhZ9LpRqu9I+plx44dnm3b3gMPPOD97Gc/8z74wQ96s2bNinjhET1//Md/7PX09Hjf+c53vKNHj4bb6OhoqPNHf/RH3sKFC73HHnvM+9GPfuStWrXKW7VqVZgupqt4xzve4T399NPezp07vblz53K6ihhkr1LPY/tOhL1793qmaXqf+cxnvOeff9772te+5nV2dnr/+3//71Dnrrvu8mbNmuX93//7f72f/vSn3u/93u9pp1e44oorvD179ng/+MEPvDe96U3n5FQVOtavX+9deOGF4XQg//RP/+TNmTPH++///b+HOmzj9IyMjHj79+/39u/f7wHw/uqv/srbv3+/96tf/crzvMa05cmTJ7358+d773vf+7wDBw54O3bs8Do7OzkdyDSkbTtunud5X/ziF72FCxd6lmV5K1eu9J588slWV6ktAKDd7r///lDn7Nmz3p/8yZ945513ntfZ2endcMMN3tGjRyPlvPzyy951113ndXR0eHPmzPE+/vGPe+Pj400+m/ZA7bixfSfGv/zLv3hvfetbPdu2vaVLl3p/8zd/E0kvlUrebbfd5s2fP9+zbdu75pprvIMHD0Z0jh8/7q1du9abOXOm193d7W3YsMEbGRlp5mlMWYaHh72PfOQj3sKFC718Pu+94Q1v8D71qU9FpppgG6fn8ccf1z5z169f73le49ryJz/5iXfVVVd5tm17F154oXfXXXc16xRJE8l4njQVNiGEEEIImbK0pY0bIYQQQsi5CDtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhBBCCCFtAjtuhJC6eO2119Db24s/+7M/C2VPPPEELMvCrl27WlgzQgiZvnCtUkJI3Xz729/G9ddfjyeeeAJLlizBsmXL8Hu/93v4q7/6q1ZXjRBCpiXsuBFCJsSHPvQhPProo1ixYgWeeeYZPPXUU7Btu9XVIoSQaQk7boSQCXH27Fm89a1vxeDgIPbt24dLL7201VUihJBpC23cCCET4sUXX8SRI0dQKpXw8ssvt7o6hBAyreGIGyGkborFIlauXIlly5ZhyZIl2L59O5555hnMmzev1VUjhJBpCTtuhJC6+cQnPoF//Md/xE9+8hPMnDkTb3/729HT04OHH3641VUjhJBpCT+VEkLq4jvf+Q62b9+Or371q+ju7kY2m8VXv/pVfP/738eXvvSlVlePEEKmJRxxI4QQQghpEzjiRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJrDjRgghhBDSJvz//fE6mZOuW4gAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Infer and plot some data.\n",
    "inputs = np.load(os.path.join(data_params[\"path\"], \"test/inputs.npy\"))  # (200,1024,1)\n",
    "problem = BurgersWithLoss(model, 10, loss_fn)\n",
    "visual(problem, inputs)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('ms_torch': conda)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "18d517ad782f4af88457d7728181a1bbe8dd4413f6d6fb70c713f7a70ee9d7f9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}