From eb66175651e1ad396b15a6a07754732af78fe95a Mon Sep 17 00:00:00 2001
From: brian <guoboqiang@huawei.com>
Date: Mon, 15 Sep 2025 19:52:50 +0800
Subject: [PATCH 1/5] add burgers1d case

---
 .../{ => applications}/acoustic/README.md     |   0
 .../{ => applications}/acoustic/README_CN.md  |   0
 .../acoustic/acoustic.ipynb                   |   0
 .../acoustic/acoustic_CN.ipynb                |   0
 .../{ => applications}/acoustic/config.yaml   |   0
 .../acoustic/images/errors.png                | Bin
 .../acoustic/images/wave.gif                  | Bin
 .../acoustic/solve_acoustic.py                |   0
 .../acoustic/src/__init__.py                  |   0
 .../{ => applications}/acoustic/src/utils.py  |   0
 .../{ => applications}/acoustic/src/visual.py |   0
 MindFlow/applications/burgers1d/README.md     |  56 +++
 MindFlow/applications/burgers1d/README_CN.md  |  56 +++
 .../applications/burgers1d/burgers1D.ipynb    | 460 +++++++++++++++++
 .../applications/burgers1d/burgers1D_CN.ipynb | 470 ++++++++++++++++++
 .../burgers1d/configs/burgers.yaml            |  55 ++
 .../applications/burgers1d/images/result.jpg  | Bin 0 -> 28848 bytes
 .../applications/burgers1d/src/__init__.py    |  26 +
 .../applications/burgers1d/src/dataset.py     |  48 ++
 MindFlow/applications/burgers1d/src/model.py  |  76 +++
 MindFlow/applications/burgers1d/src/utils.py  | 105 ++++
 MindFlow/applications/burgers1d/train.py      | 149 ++++++
 mindscience/data/flow/data/__init__.py        |  30 ++
 mindscience/data/flow/data/boundary.py        | 206 ++++++++
 mindscience/data/flow/data/data_base.py       | 130 +++++
 mindscience/data/flow/data/dataset.py         | 393 +++++++++++++++
 mindscience/data/flow/data/equation.py        | 137 +++++
 mindscience/data/flow/data/existed_data.py    | 153 ++++++
 mindscience/data/flow/data/mind_dataset.py    | 242 +++++++++
 29 files changed, 2792 insertions(+)
 rename MindFlow/{ => applications}/acoustic/README.md (100%)
 rename MindFlow/{ => applications}/acoustic/README_CN.md (100%)
 rename MindFlow/{ => applications}/acoustic/acoustic.ipynb (100%)
 rename MindFlow/{ => applications}/acoustic/acoustic_CN.ipynb (100%)
 rename MindFlow/{ => applications}/acoustic/config.yaml (100%)
 rename MindFlow/{ => applications}/acoustic/images/errors.png (100%)
 rename MindFlow/{ => applications}/acoustic/images/wave.gif (100%)
 rename MindFlow/{ => applications}/acoustic/solve_acoustic.py (100%)
 rename MindFlow/{ => applications}/acoustic/src/__init__.py (100%)
 rename MindFlow/{ => applications}/acoustic/src/utils.py (100%)
 rename MindFlow/{ => applications}/acoustic/src/visual.py (100%)
 create mode 100644 MindFlow/applications/burgers1d/README.md
 create mode 100644 MindFlow/applications/burgers1d/README_CN.md
 create mode 100644 MindFlow/applications/burgers1d/burgers1D.ipynb
 create mode 100644 MindFlow/applications/burgers1d/burgers1D_CN.ipynb
 create mode 100644 MindFlow/applications/burgers1d/configs/burgers.yaml
 create mode 100644 MindFlow/applications/burgers1d/images/result.jpg
 create mode 100644 MindFlow/applications/burgers1d/src/__init__.py
 create mode 100644 MindFlow/applications/burgers1d/src/dataset.py
 create mode 100644 MindFlow/applications/burgers1d/src/model.py
 create mode 100644 MindFlow/applications/burgers1d/src/utils.py
 create mode 100644 MindFlow/applications/burgers1d/train.py
 create mode 100644 mindscience/data/flow/data/__init__.py
 create mode 100644 mindscience/data/flow/data/boundary.py
 create mode 100644 mindscience/data/flow/data/data_base.py
 create mode 100644 mindscience/data/flow/data/dataset.py
 create mode 100644 mindscience/data/flow/data/equation.py
 create mode 100644 mindscience/data/flow/data/existed_data.py
 create mode 100644 mindscience/data/flow/data/mind_dataset.py

diff --git a/MindFlow/acoustic/README.md b/MindFlow/applications/acoustic/README.md
similarity index 100%
rename from MindFlow/acoustic/README.md
rename to MindFlow/applications/acoustic/README.md
diff --git a/MindFlow/acoustic/README_CN.md b/MindFlow/applications/acoustic/README_CN.md
similarity index 100%
rename from MindFlow/acoustic/README_CN.md
rename to MindFlow/applications/acoustic/README_CN.md
diff --git a/MindFlow/acoustic/acoustic.ipynb b/MindFlow/applications/acoustic/acoustic.ipynb
similarity index 100%
rename from MindFlow/acoustic/acoustic.ipynb
rename to MindFlow/applications/acoustic/acoustic.ipynb
diff --git a/MindFlow/acoustic/acoustic_CN.ipynb b/MindFlow/applications/acoustic/acoustic_CN.ipynb
similarity index 100%
rename from MindFlow/acoustic/acoustic_CN.ipynb
rename to MindFlow/applications/acoustic/acoustic_CN.ipynb
diff --git a/MindFlow/acoustic/config.yaml b/MindFlow/applications/acoustic/config.yaml
similarity index 100%
rename from MindFlow/acoustic/config.yaml
rename to MindFlow/applications/acoustic/config.yaml
diff --git a/MindFlow/acoustic/images/errors.png b/MindFlow/applications/acoustic/images/errors.png
similarity index 100%
rename from MindFlow/acoustic/images/errors.png
rename to MindFlow/applications/acoustic/images/errors.png
diff --git a/MindFlow/acoustic/images/wave.gif b/MindFlow/applications/acoustic/images/wave.gif
similarity index 100%
rename from MindFlow/acoustic/images/wave.gif
rename to MindFlow/applications/acoustic/images/wave.gif
diff --git a/MindFlow/acoustic/solve_acoustic.py b/MindFlow/applications/acoustic/solve_acoustic.py
similarity index 100%
rename from MindFlow/acoustic/solve_acoustic.py
rename to MindFlow/applications/acoustic/solve_acoustic.py
diff --git a/MindFlow/acoustic/src/__init__.py b/MindFlow/applications/acoustic/src/__init__.py
similarity index 100%
rename from MindFlow/acoustic/src/__init__.py
rename to MindFlow/applications/acoustic/src/__init__.py
diff --git a/MindFlow/acoustic/src/utils.py b/MindFlow/applications/acoustic/src/utils.py
similarity index 100%
rename from MindFlow/acoustic/src/utils.py
rename to MindFlow/applications/acoustic/src/utils.py
diff --git a/MindFlow/acoustic/src/visual.py b/MindFlow/applications/acoustic/src/visual.py
similarity index 100%
rename from MindFlow/acoustic/src/visual.py
rename to MindFlow/applications/acoustic/src/visual.py
diff --git a/MindFlow/applications/burgers1d/README.md b/MindFlow/applications/burgers1d/README.md
new file mode 100644
index 000000000..b44ce7d55
--- /dev/null
+++ b/MindFlow/applications/burgers1d/README.md
@@ -0,0 +1,56 @@
+ENGLISH | [简体中文](README_CN.md)
+
+# 1D Burgers
+
+## Overview
+
+Burgers' equation is a nonlinear partial differential equation that simulates the propagation and reflection of shock waves. It is widely used in the fields of fluid mechanics, nonlinear acoustics, gas dynamics et al. It is named after Johannes Martins Hamburg (1895-1981). In this case, MindFlow fluid simulation suite is used to solve the Burgers' equation in one-dimensional viscous state based on the physical-driven PINNs (Physics Informed Neural Networks) method.
+
+## QuickStart
+
+You can download dataset from [physics_driven/burgers_pinns/dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/dataset/) for model evaluation. Save these dataset at `./dataset`.
+
+### Run Option 1: Call `train.py` from command line
+
+```shell
+python train.py --config_file_path ./configs/burgers.yaml --mode GRAPH --device_target Ascend --device_id 0
+```
+
+where:
+
+`--config_file_path` indicates the path of the parameter file. Default './configs/burgers.yaml'；
+
+`--mode` is the running mode. 'GRAPH' indicates static graph mode. 'PYNATIVE' indicates dynamic graph mode. Default 'GRAPH'.
+
+`--device_target` indicates the computing platform. You can choose 'Ascend' or 'GPU'. Default 'Ascend'.
+
+`--device_id` indicates the index of NPU or GPU. Default 0.
+
+### Run Option 2: Run Jupyter Notebook
+
+You can use [Chinese](./burgers1D_CN.ipynb) or [English](./burgers1D.ipynb)Jupyter Notebook to run the training and evaluation code line-by-line.
+
+## Results
+
+![Burgers PINNs](images/result.jpg)
+
+## Performance
+
+| Parameter               | Ascend               | GPU                |
+|:----------------------:|:--------------------------:|:---------------:|
+| Hardware                | Ascend 32G           | NVIDIA V100 32G    |
+| MindSpore version       | >=2.0.0                | >=2.0.0                   |
+| dataset                 | [Burgers Dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/)      | [Burgers Dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/)                   |
+| Parameters              | 6e4                  | 6e4                   |
+| Train Config            | batch_size=8192, steps_per_epoch=1, epochs=15000 | batch_size=8192, steps_per_epoch=1, epochs=15000 |
+| Evaluation Config       | batch_size=8192, steps=4      | batch_size=8192, steps=4               |
+| Optimizer               | Adam                 | Adam                   |
+| Train Loss(MSE)         | 0.001                | 0.0001             |
+| Evaluation Error(RMSE)  | 0.010                | 0.008              |
+| Speed(ms/step)          | 10                   | 40                |
+
+## Contributor
+
+gitee id：[liulei277](https://gitee.com/liulei277)
+
+email: liulei2770919@163.com
diff --git a/MindFlow/applications/burgers1d/README_CN.md b/MindFlow/applications/burgers1d/README_CN.md
new file mode 100644
index 000000000..663c8844d
--- /dev/null
+++ b/MindFlow/applications/burgers1d/README_CN.md
@@ -0,0 +1,56 @@
+[ENGLISH](README.md) | 简体中文
+
+# 一维Burgers问题
+
+## 概述
+
+伯格斯方程（Burgers' equation）是一个模拟冲击波的传播和反射的非线性偏微分方程，被广泛应用于流体力学，非线性声学，气体动力学等领域，它以约翰内斯·马丁斯汉堡（1895-1981）的名字命名。本案例采用MindFlow流体仿真套件，基于物理驱动的PINNs (Physics Informed Neural Networks)方法，求解一维有粘性情况下的Burgers方程。
+
+## 快速开始
+
+从[physics_driven/burgers_pinns/dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/dataset/) 中下载验证所需要的数据集，并保存在`./dataset`目录下。
+
+### 训练方式一：在命令行中调用`train.py`脚本
+
+```shell
+python train.py --config_file_path ./configs/burgers.yaml --mode GRAPH --device_target Ascend --device_id 0
+```
+
+其中，
+
+`--config_file_path`表示参数文件的路径，默认值'./configs/burgers.yaml'；
+
+`--mode`表示运行的模式，'GRAPH'表示静态图模式, 'PYNATIVE'表示动态图模式，默认值'GRAPH'；
+
+`--device_target`表示使用的计算平台类型，可以选择'Ascend'或'GPU'，默认值'Ascend'；
+
+`--device_id`表示使用的计算卡编号，可按照实际情况填写，默认值0；
+
+### 训练方式二：运行Jupyter Notebook
+
+您可以使用[中文版](./burgers1D_CN.ipynb)和[英文版](./burgers1D.ipynb)Jupyter Notebook逐行运行训练和验证代码。
+
+## 结果展示
+
+![Burgers PINNs](images/result.jpg)
+
+## 性能
+
+| 参数               | Ascend               | GPU                |
+|:----------------------:|:--------------------------:|:---------------:|
+| 硬件资源                | Ascend, 显存32G            | NVIDIA V100, 显存32G    |
+| MindSpore版本           | >=2.0.0                 | >=2.0.0                    |
+| 数据集                  | [Burgers数据集](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/)      | [Burgers数据集](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/)                   |
+| 参数量                  | 6e4                   | 6e4                   |
+| 训练参数                | batch_size=8192, steps_per_epoch=1, epochs=15000 | batch_size=8192, steps_per_epoch=1, epochs=15000 |
+| 测试参数                | batch_size=8192, steps=4      | batch_size=8192, steps=4           |
+| 优化器                  | Adam                 | Adam                   |
+| 训练损失(MSE)           | 0.001                | 0.0001             |
+| 验证损失(RMSE)          | 0.010                | 0.008              |
+| 速度(ms/step)           | 10                   | 40                |
+
+## Contributor
+
+gitee id：[liulei277](https://gitee.com/liulei277)
+
+email: liulei2770919@163.com
\ No newline at end of file
diff --git a/MindFlow/applications/burgers1d/burgers1D.ipynb b/MindFlow/applications/burgers1d/burgers1D.ipynb
new file mode 100644
index 000000000..3683fc6c3
--- /dev/null
+++ b/MindFlow/applications/burgers1d/burgers1D.ipynb
@@ -0,0 +1,460 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# 1D Burgers\n",
+                "\n",
+                "[![DownloadNotebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook_en.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/master/mindflow/en/physics_driven/mindspore_burgers1D.ipynb)&emsp;[![DownloadCode](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code_en.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/master/mindflow/en/physics_driven/mindspore_burgers1D.py)&emsp;[![ViewSource](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source_en.png)](https://gitee.com/mindspore/docs/blob/master/docs/mindflow/docs/source_en/physics_driven/burgers1D.ipynb)\n",
+                "\n",
+                "## Environment Setup\n",
+                "\n",
+                "This notebook requires **MindSpore version >= 2.0.0** to support new APIs including: *mindspore.jit, mindspore.jit_class, mindspore.data_sink*. Please check [MindSpore Installation](https://www.mindspore.cn/install/en) for details.\n",
+                "\n",
+                "In addition, **MindScience version >=0.1.0** is also required. If it has not been installed in your environment, please select the right version and hardware, then install it as follows."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "mindscience_version = \"0.1.0\"  # update if needed\n",
+                "!pip uninstall -y mindscience\n",
+                "!pip install mindscience==$mindscience_version"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Overview\n",
+                "\n",
+                "Computational fluid dynamics is one of the most important techniques in the field of fluid mechanics in the 21st century. The flow analysis, prediction and control can be realized by solving the governing equations of fluid mechanics by numerical method. Traditional finite element method (FEM) and finite difference method (FDM) are inefficient because of the complex simulation process (physical modeling, meshing, numerical discretization, iterative solution, etc.) and high computing costs. Therefore, it is necessary to improve the efficiency of fluid simulation with AI.\n",
+                "\n",
+                "In recent years, while the development of classical theories and numerical methods with computer performance tends to be smooth, machine learning methods combine a large amount of data with neural networks realize the flow field's fast simulation. These methods can obtain the accuracy close to the traditional methods, which provides a new idea for flow field solution.\n",
+                "\n",
+                "Burgers' equation is a nonlinear partial differential equation that simulates the propagation and reflection of shock waves. It is widely used in the fields of fluid mechanics, nonlinear acoustics, gas dynamics et al. It is named after Johannes Martins Hamburg (1895-1981). In this case, MindFlow fluid simulation suite is used to solve the Burgers' equation in one-dimensional viscous state based on the physical-driven PINNs (Physics Informed Neural Networks) method."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Problem Description\n",
+                "\n",
+                "The form of Burgers' equation is as follows:\n",
+                "\n",
+                "$$\n",
+                "u_t + uu_x = \\epsilon u_{xx}, \\quad x \\in[-1,1], t \\in[0, T],\n",
+                "$$\n",
+                "\n",
+                "where $\\epsilon=0.01/\\pi$, the left of the equal sign is the convection term, and the right is the dissipation term. In this case, the Dirichlet boundary condition and the initial condition of the sine function are used. The format is as follows:\n",
+                "\n",
+                "$$\n",
+                "u(t, -1) = u(t, 1) = 0,\n",
+                "$$\n",
+                "\n",
+                "$$\n",
+                "u(0, x) = -sin(\\pi x).\n",
+                "$$\n",
+                "\n",
+                "In this case, the PINNs method is used to learn the mapping $(x, t) \\mapsto u$ from position and time to corresponding physical quantities. So that the solution of Burgers' equation is realized."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Technology Path\n",
+                "\n",
+                "MindFlow solves the problem as follows:\n",
+                "\n",
+                "1. Training Dataset Construction.\n",
+                "2. Model Construction.\n",
+                "3. Optimizer.\n",
+                "4. Burgers1D.\n",
+                "5. Model Training.\n",
+                "6. Model Evaluation and Visualization."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import time\n",
+                "\n",
+                "import numpy as np\n",
+                "import sympy\n",
+                "\n",
+                "import mindspore\n",
+                "from mindspore import context, nn, ops, Tensor, jit, set_seed\n",
+                "from mindspore import dtype as mstype\n",
+                "from mindspore import load_checkpoint, load_param_into_net"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "The following `src` pacakage can be downloaded in [applications/physics_driven/burgers/src](https://gitee.com/mindspore/mindscience/tree/master/MindFlow/applications/physics_driven/burgers/src)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from mindscience.pde import Burgers, sympy_to_mindspore\n",
+                "from mindscience.models import MultiScaleFCSequential\n",
+                "from mindscience.utils import print_log\n",
+                "from mindscience.utils import load_yaml_config\n",
+                "\n",
+                "from src import create_training_dataset, create_test_dataset, visual, calculate_l2_error\n",
+                "\n",
+                "set_seed(123456)\n",
+                "np.random.seed(123456)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# set context for training: using graph mode for high performance training with GPU acceleration\n",
+                "context.set_context(mode=context.GRAPH_MODE, device_target=\"GPU\", device_id=0)\n",
+                "use_ascend = context.get_context(attr_key='device_target') == \"Ascend\""
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# load configurations\n",
+                "config = load_yaml_config(\"configs/burgers.yaml\")"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Training Dataset Construction\n",
+                "\n",
+                "In this case, random sampling is performed according to the solution domain, initial condition and boundary value condition to generate training data sets. The specific settings are as follows:\n",
+                "\n",
+                "Download the test dataset: [physics_driven/burgers_pinns/dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/dataset/)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# create training dataset\n",
+                "burgers_train_dataset = create_training_dataset(config)\n",
+                "train_dataset = burgers_train_dataset.create_dataset(batch_size=config[\"data\"][\"train\"][\"batch_size\"],\n",
+                "                                                     shuffle=True,\n",
+                "                                                     prebatched_data=True,\n",
+                "                                                     drop_remainder=True)\n",
+                "# create test dataset\n",
+                "inputs, label = create_test_dataset(config[\"data\"][\"root_dir\"])"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Model Construction\n",
+                "\n",
+                "This example uses a simple fully-connected network with a depth of 6 layers and the activation function is the `tanh` function."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# define models and optimizers\n",
+                "model = MultiScaleFCSequential(in_channels=config[\"model\"][\"in_channels\"],\n",
+                "                               out_channels=config[\"model\"][\"out_channels\"],\n",
+                "                               layers=config[\"model\"][\"layers\"],\n",
+                "                               neurons=config[\"model\"][\"neurons\"],\n",
+                "                               residual=config[\"model\"][\"residual\"],\n",
+                "                               act=config[\"model\"][\"activation\"],\n",
+                "                               num_scales=1)\n",
+                "if config[\"model\"][\"load_ckpt\"]:\n",
+                "    param_dict = load_checkpoint(config[\"summary\"][\"ckpt_dir\"])\n",
+                "    load_param_into_net(model, param_dict)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Optimizer"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 7,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# define optimizer\n",
+                "optimizer = nn.Adam(model.trainable_params(), config[\"optimizer\"][\"learning_rate\"])"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Burgers1D\n",
+                "\n",
+                "The following `Burgers1D` defines the burgers' problem. Specifically, it includes 3 parts: governing equation, initial condition and boundary conditions.\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 8,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "class Burgers1D(Burgers):\n",
+                "    def __init__(self, model, loss_fn=nn.MSELoss()):\n",
+                "        super(Burgers1D, self).__init__(model, loss_fn=loss_fn)\n",
+                "        self.ic_nodes = sympy_to_mindspore(self.ic(), self.in_vars, self.out_vars)\n",
+                "        self.bc_nodes = sympy_to_mindspore(self.bc(), self.in_vars, self.out_vars)\n",
+                "\n",
+                "    def ic(self):\n",
+                "        ic_eq = self.u + sympy.sin(np.pi * self.x)\n",
+                "        equations = {\"ic\": ic_eq}\n",
+                "        return equations\n",
+                "\n",
+                "    def bc(self):\n",
+                "        bc_eq = self.u\n",
+                "        equations = {\"bc\": bc_eq}\n",
+                "        return equations\n",
+                "\n",
+                "    def get_loss(self, pde_data, ic_data, bc_data):\n",
+                "        pde_res = self.parse_node(self.pde_nodes, inputs=pde_data)\n",
+                "        pde_loss = self.loss_fn(pde_res[0], Tensor(np.array([0.0]), mstype.float32))\n",
+                "\n",
+                "        ic_res = self.parse_node(self.ic_nodes, inputs=ic_data)\n",
+                "        ic_loss = self.loss_fn(ic_res[0], Tensor(np.array([0.0]), mstype.float32))\n",
+                "\n",
+                "        bc_res = self.parse_node(self.bc_nodes, inputs=bc_data)\n",
+                "        bc_loss = self.loss_fn(bc_res[0], Tensor(np.array([0.0]), mstype.float32))\n",
+                "\n",
+                "        return pde_loss + ic_loss + bc_loss"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Model Training\n",
+                "\n",
+                "With **MindSpore version >= 2.0.0**, we can use the functional programming for training neural networks."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 9,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def train():\n",
+                "    '''Train and evaluate the network'''\n",
+                "    problem = Burgers1D(model)\n",
+                "\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\n",
+                "\n",
+                "    # the loss function receives 3 data sources: pde, ic and bc\n",
+                "    def forward_fn(pde_data, ic_data, bc_data):\n",
+                "        loss = problem.get_loss(pde_data, ic_data, bc_data)\n",
+                "        if use_ascend:\n",
+                "            loss = loss_scaler.scale(loss)\n",
+                "\n",
+                "        return loss\n",
+                "\n",
+                "    grad_fn = ops.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=False)\n",
+                "\n",
+                "    # using jit function to accelerate training process\n",
+                "    @jit\n",
+                "    def train_step(pde_data, ic_data, bc_data):\n",
+                "        loss, grads = grad_fn(pde_data, ic_data, bc_data)\n",
+                "        if use_ascend:\n",
+                "            loss = loss_scaler.unscale(loss)\n",
+                "            is_finite = all_finite(grads)\n",
+                "            if is_finite:\n",
+                "                grads = loss_scaler.unscale(grads)\n",
+                "                loss = ops.depend(loss, optimizer(grads))\n",
+                "            loss_scaler.adjust(is_finite)\n",
+                "        else:\n",
+                "            loss = ops.depend(loss, optimizer(grads))\n",
+                "        return loss\n",
+                "\n",
+                "    epochs = config[\"data\"][\"train\"][\"epochs\"]\n",
+                "    steps_per_epochs = train_dataset.get_dataset_size()\n",
+                "    sink_process = mindspore.data_sink(train_step, train_dataset, sink_size=1)\n",
+                "    for epoch in range(1, 1 + epochs):\n",
+                "        # train\n",
+                "        time_beg = time.time()\n",
+                "        model.set_train(True)\n",
+                "        for _ in range(steps_per_epochs):\n",
+                "            step_train_loss = sink_process()\n",
+                "        print_log(f\"epoch: {epoch} train loss: {step_train_loss} epoch time: {(time.time() - time_beg)*1000 :.3f} ms\")\n",
+                "        model.set_train(False)\n",
+                "        if epoch % config[\"summary\"][\"eval_interval_epochs\"] == 0:\n",
+                "            calculate_l2_error(model, inputs, label, config[\"data\"][\"train\"][\"batch_size\"])"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "burgers: u(x, t)*Derivative(u(x, t), x) + Derivative(u(x, t), t) - 0.00318309897556901*Derivative(u(x, t), (x, 2))\n",
+                        "    Item numbers of current derivative formula nodes: 3\n",
+                        "ic: u(x, t) + sin(3.14159265358979*x)\n",
+                        "    Item numbers of current derivative formula nodes: 2\n",
+                        "bc: u(x, t)\n",
+                        "    Item numbers of current derivative formula nodes: 1\n"
+                    ]
+                },
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "epoch: 100 train loss: 0.42995507 epoch time: 63.536 ms\n",
+                        "    predict total time: 243.24369430541992 ms\n",
+                        "    l2_error:  0.8788317251751688\n",
+                        "=================================================================================================\n",
+                        "epoch: 200 train loss: 0.41935205 epoch time: 62.145 ms\n",
+                        "    predict total time: 7.87043571472168 ms\n",
+                        "    l2_error:  0.88964679457787\n",
+                        "=================================================================================================\n",
+                        "epoch: 300 train loss: 0.42547783 epoch time: 62.736 ms\n",
+                        "    predict total time: 7.727861404418945 ms\n",
+                        "    l2_error:  0.8895206005088669\n",
+                        "=================================================================================================\n",
+                        "epoch: 400 train loss: 0.4227412 epoch time: 62.124 ms\n",
+                        "    predict total time: 7.363557815551758 ms\n",
+                        "    l2_error:  0.8889956873924331\n",
+                        "=================================================================================================\n",
+                        "epoch: 500 train loss: 0.41943315 epoch time: 62.960 ms\n",
+                        "    predict total time: 4.832983016967773 ms\n",
+                        "    l2_error:  0.8881562175445344\n",
+                        "=================================================================================================\n",
+                        "...\n",
+                        "=================================================================================================\n",
+                        "epoch: 14600 train loss: 0.00013843024 epoch time: 62.264 ms\n",
+                        "predict total time: 5.646228790283203 ms\n",
+                        "l2_error:  0.004415987361258303\n",
+                        "=================================================================================================\n",
+                        "epoch: 14700 train loss: 7.498202e-05 epoch time: 62.589 ms\n",
+                        "    predict total time: 5.714178085327148 ms\n",
+                        "    l2_error:  0.004421070906100957\n",
+                        "=================================================================================================\n",
+                        "epoch: 14800 train loss: 0.00018732375 epoch time: 61.509 ms\n",
+                        "    predict total time: 6.393909454345703 ms\n",
+                        "    l2_error:  0.05152295200248691\n",
+                        "=================================================================================================\n",
+                        "epoch: 14900 train loss: 0.00013548511 epoch time: 62.688 ms\n",
+                        "    predict total time: 6.286382675170898 ms\n",
+                        "    l2_error:  0.004916392108302118\n",
+                        "=================================================================================================\n",
+                        "epoch: 15000 train loss: 0.00011926594 epoch time: 61.978 ms\n",
+                        "    predict total time: 5.469322204589844 ms\n",
+                        "    l2_error:  0.004314286890692662\n",
+                        "=================================================================================================\n",
+                        "End-to-End total time: 944.745542049408 s\n"
+                    ]
+                }
+            ],
+            "source": [
+                "start_time = time.time()\n",
+                "train()\n",
+                "print_log(\"End-to-End total time: {} s\".format(time.time() - start_time))"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Model Evaluation and Visualization\n",
+                "\n",
+                "After training, all data points in the flow field can be inferred. And related results can be visualized."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 11,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAHWCAYAAAD3vrTNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e9RtSVUeDj+z1t77Pe85ffrGpZtubBpoLgFbCZI4CDK8EPJpevgLGeanDNTwYRKDJATkkyj4abg4JDiGDSomDDAC3jUaMd7AoMj4ftooF0FEbRqaa9/vffqc9917r6r5/VFzVs2qtda+nfOePm+za4zu9zx7zppVa61aq+aaT81aBICxLduyLduyLduyLduyLYemuAe7A9uyLduyLduyLduyLduyXtk6cNuyLduyLduyLduyLYesbB24bdmWbdmWbdmWbdmWQ1a2Dty2bMu2bMu2bMu2bMshK1sHblu2ZVu2ZVu2ZVu25ZCVrQO3LduyLduyLduyLdtyyMrWgduWbdmWbdmWbdmWbTlkZevAbcu2bMu2bMu2bMu2HLKydeC2ZVu2ZVu2ZVu2ZVsOWdk6cNuyLduyLduyLduyLYesbB24bdmWbdmWbdmWbTmU5dnPfjb+9//+37jpppvAzPgX/+JfLK3z9V//9fjIRz6C/f193HDDDXjhC194Fnp65svWgduWbdmWbdmWbdmWQ1mOHTuGj3/84/gP/+E/rKR/5ZVX4vd///fx/ve/H0972tPw5je/GT/3cz+Hf/bP/tkB9/TMF8L2Y/bbsi3bsi3bsi3bcsgLM+N5z3sefud3fmdQ57/+1/+Ka665BldffXX67Vd/9Vdx4YUX4lu+5VvORjfPWBk92B04DOWyyy7DiRMnHuxubMu2bMu2bMu2rF2OHz+Om2+++ay0tbOzg8lkckZtTqdTzGazM2Lrmc98Jt73vvcVv733ve/Fm9/85jNi/2yWrQO3pFx22WW46aabHuxubMu2bMu2bMu2bFwuv/zyA3fidnZ2sP/ZzwKPetTGNk6cOIHjx48Xv73mNa/Ba1/72tPtHgDg0ksvxW233Vb8dtttt+GCCy7AkSNHsL+/f0baORtl68AtKRp5u/zyy7dRuG3Zlm3Zlm05VOX48eO46aabzsr8NZlMovP2mCuA++9f38D55+P457/QmW+n0+kZ7OVDp2wduBXLiRMnTvsGIOcwOb6L+cl9hNavjGcP7IF96OLGYXLeCvjEHjgEuFGD8bEjp42n958CmOHGI4yP7izGuxNMT+wBzGgmI4yOrIDvPwUAXbwzxmhnXOBmMsLsxF4vHh2ZwI2bxXjUYPaA4N0duMYN4vHRHYAI85P7q+FjRwBmzE9NBzEHRrsX8eS8XQQfFuPWo92PVMLk+C7CfDH2sxZ+Ou/FO+cfRTudl3h/Bj9ru5gIO8d3O3i+N0OYCz7/KOanpuvhNe+Fg7o3zvi9ssq9scm9ssa9seheOdP3xmh3B+TO7L1h8Ur3hsXnwL1xxu6Vw1j2TwLTUxvUawCcmfl2qNx666245JJLit8uueQS3HfffYcq+gYcMgfu2c9+Nl75ylfia77ma3DZZZctXawIxHTha6+9Fk996lPxxS9+ET/2Yz+Gd73rXWepx7Ecffj5eNYP/t94+r/9f+HIhcfgZ3Pc/elbcMEVj8DkvF200znu+cwtuOAxj8Tk2BG0+zPc/ZlbcOFjL8HkaMT33HgrLrzyEoyP7mC+P8O9N96KCx97Cca7O5jvTXHvZ2/DhY+9FOPdCWanprjvc7fhosdditGRCWYn93Hf527HRVc9CqOdMWYP7OO+L9yOix6veA/3feEOXHzVZWgmI0xPnML9X7wTFz/hMjTjEab3n8L9X8p4/76TOHHz3VF/3CT8sCdcBjdqsH/vA3jg1ntw8VUR793zAE7edg8ufsLlcI3D3t0ncPKO+6K8cTh11/04def9Gd95P07ddT8e9oTLQY5w8o77sH/PA7j4qsv68e33Yv++U3jYEy4DADxw2z2YndjDxVdFfOKWezA/tY+LHx/D+iduvgvzvVnC9990F/x0josed2k//tKd8HOPix4bb/r7vngH2AdceKXBgXHhYx4JALj3C7eDAFxwheDP3w4iwgVXPCLiz90Gahpc8BUPBwDc89nb0IwbnP/oiO++8VaMdsY4//KHRfyZWzDe3cHxyy7O+OgOjj9K8KdvxuS8XZx36UUAgLs+fTN2ju/ivEsE33ATjlxwDMceeSE4MO7+9M04ctF5OPaIC3rxXTfchKMPPx9HH3Y+gg+4+9M349gjLsDuxccjvuFmHHukYo+7b7gZ5116EY5ceB5C63HXDTfj+KMuxpELj2V82cU4csEx+HmLuz99M86//OHYOf8o/EzwVzwCO8d34Wdz3CX3xs55u/le0XtjOsfdn765uDfu/sytuOix+d645zO34qLH5XvjnhvjvTDenSR88ePl3jg1xb2fvRUXX3VZvBdO7uPez92Oi/VeObmP+z6f75V0b+i9Ut8b95/CiZvuxMVXXd57b+zd+wAeuOWe7r1i743b78PFT5B74e77ceqO7r2R8X3Yu3v43njgtnsxvd/cG7feg+mJvYRP3Ho35g9McfFVcm/ccjfmp6b53rj5bvj9KS56nN4rd8JPW3Ov3Ak/a3HRY/O9Elo/eG/c94U7AHB5bzjCBV+R7w3XNDh/4N6458Zb0Zh7454bb8XoyBjHLzP3SnFv3ILJeUfSvXH3p2/GpLg3bsaRC47i2CMvHL5XLj4Pxx5u7o2HnY+jD8/3xtGHX4CjDzvec6943H3DLTh2yYXYveg8BO9x16duxvFHVfdKcW/cgvMvf1i8N+Yt/vY3/wz/z4//Om7/m8/X08q5XUYU/9uk3gGX6667Dv/8n//z4rfnPve5uO666w687TNdDlUW6jd/8zfjWc96Fj7ykY/gt3/7t5c6cFdeeSX+5m/+Bm9961vxcz/3c3jOc56DN7/5zbjmmmvwR3/0Ryu1efz4cdx///04//zzN3ojOO/Si/BvrvtJnP/oh8ONmvQ7M4OItrgHM8chuSp+MPp7JsuDca6Bxef3XBkLW7y9N861e6PGB9mf0Hr4uccv/bP/L77w/3yy9xwtK6c7h23SFq68BHhgg7bOOw587ra1+nrs2DFcddVVAICPfexj+P7v/368//3vx913340vfvGL+PEf/3Fcfvnlaa839Qt+9md/Fj//8z+Pb/qmb8JP//RPr+UXnCvlUDlwtpytdOHTHfzf9qv/GU/5v58N12y33NuWbdmWbdmW9QoHxgO33oM3XfFCsA9r139QHLjHP2pzB+4zt6zV16//+q/Hn/7pn3Z+f+c734kXvehFeMc73oErr7wS3/iN31jUedOb3oSnPOUp+NKXvoTXv/71Z52ZOxPlUFGo65YHO1346MPP3zpv27It27It27JxIUc4ftnFeMK3PAOf+r2/fLC7s1qZNPG/TeqtWT7wgQ8sjAC/6EUv6q3z9Kc/fe22zrXykHbgNkkXnkwm2NnZSbhOZ16nPOIpV2ydt23Zlm3Zlm05rcIMXPHsp24duG0pyta7qMqrXvUq3H///em/09kD7tijH3kGe7Yt27It27ItX67l4ic++sHuwuqlIWDk1v+vOfgkhodSeUg7cJukC7/hDW/A+eefn/67/PLLN25//9QMgePb07Zsy7Zsy7ZsyyaFCAgHlChyIEUjcJv8ty0rl4c0hbpJuvBsNjtjn+zwcNjnMY66+Rmxty3bsi3bsi1fXoXTf4fIgWtc/G+TetuycjlUDpxNFwaAxz72sfjqr/7qwXTht771rfiP//E/4o1vfGNKF/72b/92XHPNNWenwzu7eIDHIGYcQbkhI1EZmdviNTB106fPJayPWV5Bd4u3+MsJb++NzXDLBKZD5NxMGmC+XQN30OVQOXDPeMYzinThN73pTQByuvCjHvUoXHHFFUn+uc99Dtdccw3e9KY34WUvexm+9KUv4d/+23971vZ62d9rccpPMCLGDA12yMMhgEFoA2FEDAKDQZgHwngBrvVLDPiEgQDAB4cRhZVxm9oDAhhtcKZ91Y/vgZthkj0aV8MhkCyHYATBI0LqT2BCY453Uxxb6GJmwMlssy4OHB1OnazWwQQgcPzBbVB/E+yl72cTx3NNCzBS2RxzOl5tn78cMeJamUVYp81VMCOvvdFNLVbF/gxgvU/6cGuObRle9dw8uJjknBOC9ezO9TLekA4dbx24dcqhcuAOW7qw94yT7RhEwBHXIsBJJCneiS1ziiwFxIlnEW4HMctbWi13g5h7sG2vxNHxGZb3Y314b4q9wTByBDlvlf6qWB+EVt6HwwAOjOQI9mIAJOdifRyvpWOAN6rfxSz/W4R9VZ8XyBfhdK4fRAyU9wbOgD1/wHhorJ0RTAajkstfvyZ+sP/SAuwPCbbndhGOY5Ly8+8wlIY2S0jYJjGsVQ6VA3fYCk+O4uR8DAIjjAinMJIbWXbbFseIARCROEriDYgk38hDWNFifWufCHAJ1/Ke/mAdfYNDPp6Ma/kyzPGNVLAWwur29H8lBjggnQ+iiAHjmJwVzHASGVy9fjzKRZjVE1kb57G5Wf2zj9N0J+NPz0eUk5HX+ookrvtgYrNe4MxhRtMnp4xJ742FODuGhw/LvVGPnZ5zcbYxmXuNK7nF8WWeEPSN7jCUSQO0Wwr1oMvWgTvAMt+b44HpGA0xZr7BzsjDUXyYtMFh7ELEAObeYdQwHIRC9YRxI3ImtMFh1IQk94EwcgxKcsLYhYQ9i1z0W28wR8pybOrPQ2yPEOlEHwgjwczxt7GLHgKD4D1hlHC2B9HX/gHR8Yj9CZka8ITGCaXJjMBuAEcKlfV4EaMXYQEODIQQ18OSODaBTXs9mJE/w+ejL5ApXQZY9CH6AMHRZlgdLaVcW3EkFXsPcbLXxbk9AqXJzAeCE0d1HWz756r+NiQTEOK5d6QjYX3sDV2+HBN8QIm5pEyZF8k3xWlKXYojhTmEAWaG05MNgl+A1U/dDBPm0Y9Do3KwLE9QfZblA8tw7jszpbEQnQ2l+zm3n45Vj+rMYI12r4fprGIHhzTWDdZnlYNeC0JgRjOgH3G8yzwO2Rq4bRLDWSlbB+4ASztj7M9GaBywM2oREB98+tDznCnVAIL3hlJlwPuK4vSWgiWEUOqHkOXcK0eWF1h0FrQXJ+qSkvWhpIRZ7AWpHyw2/QucHSeVYyGOx7G6vmD5myKDnd9LbClRi+OE29V32ATHc6+ObK9+VFuIibuUrbrTSps55GspP62FwyLMKMZGxrV8NbwuPT9MScaxcjr2zgQePl55KSnkNIz13J8GBsrlFX24Xq6wDHONjUNHAAKVcvVPk4M1gHXsJgdO/lrMZwiz+e1M4kiBUg/Oa3CzPi3Q12tJMib0KA5BGbsN18BtHbh1ytaBO8ASJrs4OR2BKL7F7s3j6U6hc/MIsLiUx5veWUyo6sdaVm5xXNC8QB9WLvYX6Rf2a7lGg1albThGcxbI3UJ5V1/7v6p+QzFapRRt+lC1xQzTnxX0B7HUX1m/W5+IYuR0EaXKS+QJa39W1S+vRR8upyfOY5cr+WnjauyyyHh4bJ5ZXN0LK/WfOvJFFHExVtfGcm+top/G2jK8zlg9jXuDK/lauKRMH2xcUqYABu6VIRyTrhwCHyLnZtIAfkuhHnTZOnAHWNr9gJN7I4wcY9YGjEeMxgll2hLGI07USo1bHzFRfNB6TxiJnLmSI8v1+eCDYqFYPWEyyhRrqo8YDfCBMG4ypeoDEg5BKNpG+5PlEP3AiJQpRXo0sMihlG7caJuIEXyJ5yH2WbH3ai9i9vGtdSSUqGcCc6ZIA8eHZOOiY+V9xCMHQPqf5AD0e9A6WcwFNxT1OQBLKVPKNCKH6AY3K1KobTwtyb4PJE56PpcZ5+e9E0dSI3YNaaS1xEqppqzaAAAOzsWxFCOVQrGyULgkNJ9c24yV1rGU7BJc6c+E8lR7MSuVUlRzFZyc7ALL+VInXO87lcfDy/oGj3TiX4gZgNBc5NJYju0JDqZ9kki36e8qmIOMRTn/MeIb7YcQIzeb4nmIx6FjPcszBjGUBiwxJz+T4NKzog8rLdiH4+hfBVO6N5QSDulejX/1flCKODtHGWeKV7GTey+yEsBiTHDyXF2OfWC4FXFetytjG5mCHcZ6Xg5bEsOWQj0bZevAHWDx+3Oc2h/BOWBn7MHsE60RAiVqUB+8cYORiMFZzoL93Ogzwbe6aF8eFgnH/4U2v88FBrhNJF6cKFpOmFkWVlt5wvLgFB6FwaBaHwbLQ9zqA0gRnCRPWCjKBXL74qqUYs4m1YejYgCg5JixhBpKeUmVEuLEnQrlyUN/JjaYM60ExEQLpY2UvlL9EseDI5ft1/qJRhJ9pd/q7NlBzBZHEM9vnjQJZXtU2SMu63N1PFz1N5jAASNfI/3jWc+vHBxzSVUzluLaXroQRMW1S/IFuF2AUeA4tmJ9Sr/04t7+dTEW4uhcBbGvY3lTrP0rqc8Kc3Z+u5jNNhyZ5qvxsr+0Ji7GIsqxKMMnHVtZn6p7OUp8oh9LnPVLjDVwWBmL82b6p91chD0TAg4bhbphBG67jchaZevAHWCh0VGcOtXEB9AuYTofFTRejChE56VpOGG7AD1OUChwjM4oDjmaorhTf5E8wLn8wAaCWVCd7efCQgsM1eeqfo/+uvaXyG10JvUnYUamWfpwPn/9tIyhWAfkjpw4mH3yPn0C8er6Zf/ytRvCaQ8wK+eMYxu5vabSL+XLMDrtrVuf1tKvxgLsvdCVr4e79w6RM2OtHnvr4pCiqMP6LkWIN7Hfdy8Bq94LfdjBY82xvbL+uphQLmdYdq8uv1f0cmw2dtfHDtGXW6d+ykItru05XrbbiJyVsnXgDrC4GWP/gQZNw5kibRhgoG2B0QhwkgnZehg5Yd4CY5EDUT9hipmHowZwzgmlKnJyMaLg48uMc5p1GuU6IXmfcRD5xMiDj/1L+lof2d6okfptfOCPxAn1IdJ641GZFRr1KUb7mDFqgBgNEIqzMZEwBpwDSN48sz5LHRZ5g7m83cbouwP7qDUyWbHMQCMvd4mWcbH9UNQXGgksci7sx/5F77ARudJeqb68KScKlWM7TjY2jjMcpWsbgsUm69XWr/XFPsnxgUuKlpBxXF9EmZbiEreJ1hF96EtE1rfYB10HGPHMs1Cesb5mUTqKERrV78NqP6/TVAp1NUyI+ykqZjlfq+LyeBs59yzzSHSOIuW5Ig7RXnRkSDKcWbI6G7QJy9hOFGw/Bmd7al8pzi5uEo5DkRIlOoRr+6GyH+n0nGe6DLfi+KVMS4nUK47tWYpVHKkFOFKiq+G5hIPtWEalvxBD62+GPUd2oouxRK5js8bxOh3KbUTCdg3cQZetA3eAxU1naE42eICAyU5AOBLgXJwgOMj6CMHguL4iySuslKpmsUbHI2OlZG2Wq2bkqX7GSE4TJX1gyuXbXxDKNlT1uzger1KRsh4ZLF8P07fllH3F8U0/63OaXIFsT/yV3P8kj1GvBqWDZLNPk2Oj9gmJ0q3tBy4jGcnhMu33ydUOVB6s3KzjkfOqD2BG7I8zlCaQMTPL3GrqQx1Lg0msiUPS0ZfQG7OL28+Q9s9GKONYQOpfnG4dsaFMqaSExXGpca5vJ5/YL88lDgbrtdXpiRnFep/FmDv1s91VsDgMcnwMdTpkDInWEMWlv2Ws96bVp6p+SfkuxpyiTqn+QsozYl4ZW8q23x6vie292sWy3CAfnWgsxnbsrIJZx2I91lFSrAeB0YvJaK+in89fpGHdIXTgNnAvtg7cWmXrwB1gGdEOdk41YAJmTJjNmhiAcRLNkQcLuRh5UxyzLrPcOQa5LKdKTsQdfTco58o+99jryoEhfY2Eoeh/oe9KrJSbrV/LgbI/xd+19Ov+LdenJXK9dkB5vRSX/+bi3FgWpPfYxCsaPPYee7XcLZT32KPs8A72Z1A+0P7K+j39WVcf0ZndtL3F53v538XXY9Hf+l4Y+BvWs7fu8fhB+3IvrHlc9fiusTf3Rj1WF98bG/5dcC+e3b/rju34N0gCgzp3h6I4smsb1qu3LSuXrQN3gKWZOxx5gOCdQ9MSQsPxPyJQANAA1DA8XNwDbgSgYQQCvGc0IxIKNMpHI8A18aHnPdAIpcrI8jghO3CIlGSk3aK8SZRqjP6NVE4x2tc0ORMxYRdD91bOqPTRL7eUaWChQClHF6Ock3wschj9+PCVTEDBYR5pmUazTJXSbADNulVKFogzBnOkeAHKWZ+JsiSA4zpEIFMVKUuUc5YoEOlwUJlFCihlK/ZSfYk+cNYPEgFJFKnIM6Ur40dDXDqJygIaZtXXpBVKmFUOQkN5o+VEwXJFyaasV4JzAcxIUZN0bY0cHXlNEZssWpeUk7y232lPPAYKkmUqlGLMau3BhqJbRT9G2SJNFZ0jglKojnIW5xBGAJikPlBQjkRKbw9hqQ+dpwitUp7ivah+wt7KNeM5rzvUjGiSa9Sx50uMguKt65cYUIoWcCzXOlCB9fqmb5WG7NQOYUj/mUnofpPxrGNZw6HiwDq5BxjrYwQdVpJopRSrjAWEnPF8cDiOmZgdpGMPS7HeG+1ho1DHG1Ko2ySGtcrWgTvAQvv72D3ZIDRAO2bMdxjBrJsKo4hHHJ2s4CMmZowRnbhW8skdE4IHvOzO2lB0wry+XrJDKzOn7o2eN/KNTqBiCGaVIzp9Vh/soBvuxgeRg1KhkXAVrG/qFS7kQR05CM7yOMnpYvGMXYFz/TwpZkdBP/6eqEpJ3df2g6y5svYAmElYaCR5xw0BgIsY0Pbt1gZKbZtJlzJOWbVK56TzHHGKeKg9eTvXB3ao5EW0wsqDlaszghyxoSZerR45LNZJmBuw1S/6BwSf7TmRs22fc39A4jzILOySs1Xqd3EcG86xZDrL74SEQ4FlLC/Qtzjee2pfJ3wCOdMfgyH1QZkGQ9BtIUx9mZujby0rwjpYj0+dwlxf/KI0YRf+kXHKlX4vKc/sIJX6SP23OGtXDs6gPTOWO5iT85bGCmd7KePZ2kPZf71GVm7vJeu25OUIgqHPgMXY0v2U7HO6NgdJqUasY0+SjFQuxzmE9WP2gV16bh2Kst1G5KyUrQN3gKWhCXZPxgG5d17AWNaEBeL4ckIGO6TXWAaDXSn3BnNVn4G4vsnaa9g+p+MEQ/rvkgbU1+9MYXCpX9QXmWOjX8prTMZGrlDaAyr7GJLXf/PM1E/fLLOfT1OaxLjHfn08frF+ffzD9nMHrLy4Firzuf+u91gr/QH58Lnq17cUcZ/+svYISFusrNIekCewVfTthL1Mn4b0B3EeL4W8F2cj9fF2jn+gft+90jmeMCSXsbbwfA30Z2Cs1vXrsctC7y28dxbWX4apwPXxLR4bq40dbFx/s/bq9ZzL6nuJkodi1JzjZRuBOytl68AdYBn7MXYeIARHaLyDb4DQcIxsMCM0kVYFCGQwwwHMYEcITQCTi3IHBMcIFDfRZMEEAgVGcAR2QtEi6rMTAijuToogr8fMDDRRn9kBIVK4TAzv4oaTrhHaB0qRKo5RqGaERHtFylJpLRQ4ZWkaypQZCQdGgbOcezFCXT/ikdlYWOXQMAgy5gprcoBmlWokRilajYzZ+gSlXOPGwUCmYFXuFCtla/QT5hwlcI1EhaR/SqkmylQylPU5bilQi7W4isJVOl7dDEfaspWX+kDehiTLJZLgcjwJqGijhMlglqaG9LW9aD9GwfQa9uNESyFTqkDGUcSZljL6Tul30772RylQ1VcKVPUTJar6FLNybVbokD6SvkZTtb+UoqvRieNEWSrWa6dOnkakIFHqtKdgyPcG5JAJnJwH+5k3jR4Cub6Tfmp9xeipP4zN2EwhJsWVfg9mmHuhxsJExMhylgPr4Hrsy4k1awLPJE5jO41FVGOzi1nOow+aJHRIyrgBeOvAHXTZOnAHWfb3sLNHCI3DaAbMdwLYCQ3CDn4sTpfgMIpOm9IlYQQE10DX+PgGYJcnmNZgF1x0Bp1QhWI/Lu9iUIgULasc0p687hHnHfhH8pT0o9g/YsAJBatPFsVxxw0hIkbZPhJlqw5IRdGCslzspr96/MFSrFTUd6BkJ1GzhnaBTm7QbF5K2a4hMKjA8XIFswYtf/vUbKgsOGffantSv6JQnVKsYs/i+FwXHGKih6vqJypSrkvwWU5UZrHa/qCnfxaHECdAlm0zYkSDO/q6Pky3KMlydT5iJzVrVZ0DzVpNGxsHxdGZ0Z3xrdyJXFe0NbJezMplJTcCl1idwdhpIzezaIpYctme1c/9o5j4IhOo6lN1/OmTXexiRFr0WSnWIf1I8CePIoh+xupUlZR43jw7r2dkjtfJYo1QkbzI6PUke8/o+kkjh8FMOtah/nIa++oMUTH20ulNY7LEci6Q27XydOyr4rSMIt8rOiS0X4v7k80QYJYjsHFokZYbrIPzs6KLlUJNz4ywBKd+HrIs1O0+cGelbB24AywNj3DkVHyDne0Coza+XbBSptOoF4jjptVKoVaU6pB8J8llbZyhYEEAZrl+SdGKs2LkbChXhjywbf2CsuWCslV9PxOZRAZtxN9SiiXO0YQkF9v9+vEBmylgTkaGaJjF7S+neHv1B9vrHl9f+0CMkqT6ftP28mkuzh+G+0fIToLKC5qn6nsfDbSI9sEK9YcpRpmQB+Vd/WX27Lno62/dP/tVEJXb/pihn+tX+p3zVekPUZi2jUJeY87/BhRzdt4GxkqtX4/9QX2DM2XaHeur1Ae6xxsq+TrYm/O3yfHY/qjTW8grTKbnQ1hQcd1UvvoWOXp88iWGjrVzuGwjcGelbB24AyyjMMGR+wnBAU3IjhALJ8KElJWqK3872AFBUqpY5Pomz0KZsjx82FGkWDUFiyJmscdESN9DZtGX30na0olKJ0WlZEEQucnAE6zOHJOZmJjisZI8UBkxWqiZiQxAcKttyjq/TAkCIJvFGQ1ZClSCJmBG3ooFgvVbqsae3VOrX85F+3b/t1o/b+Rr+msiemnjYLa4onDTqzlSYoSVs5FH/TxZOKEUbX/YzChO7VM+HxqlBGt/c3SxXy6QM6Wa7DuzlkzljMpet36fHAyQUMDJMSWV53pRkPUSJSpRs5AcmZxlm/QdcqafUqyQa2oo1kxpIkVYIHp2Mu+Tp8lf/gZzPI6QEl4iLh02S4Hm+l1HPf2bjPMnXhUX+rySvh4LIV/PiPsp27q/emzFvSR9WESRwlKsTvq7lsPVxfZcs71XBnC6N9JYspgTbe9g9ENVvxdH4FbWX4BBsjn6IXLgGtowieEQHeM5ULYO3AEWnguFOgL8PjA/El9KGPGN3Y9hKFUawDoHE/zIyEOFObaTMBzaEctDOmI/ik+i+AYvDpbLj+kwSr5hXIoxgmQaRrkXDOaYFSvr+ZTS9UrJsvS/4WTPodJnXeNKkU4y9V1gow+hcAk8yrl7xJEKZTMpsawXUkoyiAOmFKxzOQvVUXbQSjklqtjqk9FnpX7TGjeuaBC5/oqNU6MOXlpzY7AGLUMY1mfIA944T7V+ucEyJeeJK/0huVf7+i1bdbaEwg3ibDlrzynFG6nWxjjCLHJOlKusnzMbKxMBJPUZsu2CHJNSnMlZB8kaKKnvqepvxF6+qME1BRu6FGujzrDY07nHnm8dbLZ/4EyR13I9dyzbSKSokYw/b9YT6hYzVl87oOeXkPuo81zUzw4SczxOSusn4x1TOFC1PpAiVwx93sRnjt77+k6ZHG7rEDHS9z71WVBQpcbx0+odHMxYpBy5KtfoZXv9mGSsce6X3nsojzfhUOLgsz6BELzcS5V8OZZ7RTLWg44tOfer42jHH7Ys1G0E7qyUrQN3gMWxw2Q/3oCzXWCka5hIKE+hKFmzTC1uLK4oUpXPK5yyXKPzMlY5ZPJYRtHqlxOA+ASfZ3lwpj0IBUtZzg4py7amWAPQyaplx+lr8CzHiFbqKjYPXjgjl+ND2qYi4kCArhGqeStLSZZYzFu51B3S17mffL+8lyaq2qNQ2TdYu27teV/WH+5fXoDfX7+/v9a+dVpV34fq+Iw9jegU9lDKqeq/CSwWUSM9/wsp1p76GWenW08UMzqULBt7ydHotYcUFRnqj/puffKa8gOisx9QypMjUeuLM06VnHvt5whg1o+Ki8am7ilXyNFfX2XD+l37xEPt9+McdczeVqG/DNdjfc32YdonUKc+r4zji15973hejGsKtQ1xL80uIXsOl9GGDtxo68CtU7YO3AGWcTiC8R4QKH6WKUAoVHFm1BFhohgZE0cpYwgFirjo3sgzlqiX0qGqT1lfv/WX9OWJXbRPpj0gTUqcKNisnx7WqX9lff1cjFKq6jwyIVGwIOq3p30mceycZhJqfVEWu0yU90xSSlcdVcGZN4mPZD0+SAJIoOxwMGV1jWJoUcrRYqrlNlOQ+v8mmkmuTZKbzDpAaBRLsxmnK9srKV7bP6VUtYqlSFNULZvrPb5aXx2QHLWjRIV2KVMMysExUqIlUaxKdap+2mMvy5M9+V2jzErLkeJUPypqZIaMfqQ4RU7ZoUlRXfPXORRrBy3VqpN+SYFmZznbqShiYEF9Q8FW9vr1qaJcuTNerGNqlwfYl4dYN12mfmwdrEF9KvRtf5bar+sX7a5WyOh3j70f9/0FhijXRVgjsavqL8JCoab1L4egOMph3nXrbcvKZevAHWAJ81MY7xO4AcKc4SeE0CI5J0pZqpMRxpTXoHFNsQJ+TJJ1CoOVhilxpEBJMishlCUVFKZStPqUjFmvMhuw9C9RlkAYZwfHUqz6JAwjpEy+LM/2EwUr9rnJcgJkzVy2Z/WVck0UraFYwejImeJGyfpEJFaKtmoPlHaV9/LlCCeTtJdtPzQ6xkL56u4bQeT6oNcsVmYGXF4TpxSifow+b6Sb/zoHOKGRlMLUNWOhqh9CXv9HyBRbPAzdAibj4ONXIHT9lTc0DUEoQFM/MCdKEcj6Km/lqxu65UjrY9/0Cw9BaCylyVofnckoR8qC1SzNemNkpGxjgUprycXzQb9QIveRz04dy/VoHIF9xN5HTF43/gVcQ6Y+4ByljX5bliQZlevxi70UbdSxxgTXAMQSPU4UpWZka1YrF+dTOcvAZn0jZ2cx3ZeaNcxqb0ge/0tYxgKAgiK2znTRnvZXKWKU+jrWS/34e9xOSO4FIHlcRWRT7wXK6//USRmMiIVKHmy0PDvUfZiFAtWMYnV46yxPi+1YzxnrmfItlx+UWK+9Ot4A0FYUKnske6th3ciXDh+Fii2FetBl68AdYKFAkUIlRrsTHQN13hJlqc5cE2/eFHkiYDQXTATvLOYKSwKCoTBD04Pl3mCO+iNfyhMFC8r9ETkIifIM0l/Y+gRDwXIlj8eTNjLuyMWxSjg+tIqNj11lT7DGu7Q+m/aUco0XI9pLFGyT6zOi4zzSCRoAnOKu/RKLU5WihjojAd5EGyhhThNcMHIOJe0WLA1EMBRlduJsNKOkZLuZdDUlGsykB9S0VU99ZDmBwK2RV/1hXtxfZkvJynrC4nipQyEDVX/DkuOr5DkyKM6iWd9X/pVv8y6gLBPlaO36XJ80smnkafI1EVYr9wP9AUpKOEVEK3uddZe1vtqV81hTtv0ULuvlWF0fyyjZqGb1l1KcXF7bmnLEQkzFvUSAMBRZfxGlqS9s9VhaDcd7qRiLcu7WwT4gfZHh0JTGIUUP1q23LSuXrQN3gGWCoxjtRwcrJuixZHYC44ay40OS8QbdfBeAo0F9dhTXiKb6iJNgqk+Ai44SJ0yC5XNdxj4glCw40bjUKI5RuawvD12X5b4p6+umprk+hK6EZK2ScVQ59Tc5XvJffBYbyjfpG3viLGV9ZIoaecKyOIwspkqfO/qo7KXognG2MyahXhVznr1Erpm5yRlXR0z02WB1BgHk/bcKubTFGnnIpG48jtw+mXZtfWfbT9mdub6112lf/NXUvhHYDWrVEYl6mmgRnUH7mTMdi4prfSBGy4bkBFooRyW39vQihVC2l+qn8WTao1pOoDDcviPqsYcUuUrRozRb2+vBAJX6jEyxwthTD9J17KGw123PYir1sZp+MTap+AMufq4p0pJirc8N23Mh+q6a74f7ls/vqvrL+7MYg3T/QTb27VhbDQeGUKhV58/lMtowArfhGriXvOQleOUrX4lLL70UH//4x/HSl74UH/rQh3p1X/jCF+Kd73xn8dv+/j52d3c3avvBLFsH7gCLb/cwngJwQDM3FKi84ReUaWCEEcm6MwAcKVClTAEkeQSMMDHyAHChzwP1DcU6lsgdIn0X9c03QceUnSDVl/qOc3+atrQPLuW6c0LKapUHFAvlmaJclnJlxZk24tFi/SCjWeYuwbE/BeXrOTtyQ/pAypJVJ0UpUz2haUuYhGWCnat+tgfKUTo9Ibr+sAk5KkhEII+85QohLsoWpxVEMRLZiDNr7KXED6UoZcYKQqmqgxQ84JpMY80HKFlbv6mxec56n7dM0WiNawhpLSTLVz3k1MX2ozye+7jRsk6WoQWahtKs6EOkQFXB+6iv8kgZRjkx0LbxKyBagvZHKd9W24/H32p72j9tTxqIlGF2HrQ9dUyH5bn9ODHLSw2TtBfHdWChOOOpAAcU5zeEmHWqX7VgjtePYO2X+ulaW8pVSt6mIjtQdv1jkdVq9SUyy2y20OnTZ0MR1xSoOlM9mKCba6M6d+YZZjEZilTkGtntw7H/XEQIW6Vk+7DeO3pvwdD5i7BZ5tIGlrGU++NoDWwpVI/DU86iA/ft3/7tuPbaa/HiF78Yf/EXf4GXv/zleO9734snPelJuOOOO3rr3HfffXjSk56UsHWaD1PZOnAHWgJGMwIcox2hoFBDg2KBNhOh8RmHEQylyiXFyohRKUO5BlfrU0HJlvUpUYy99kGVPlf6lPuPTIlmWiU+ARuf5WzliB/vLihUZ+XIjonIQ40bi0t9jfzBtKeTSYxwydrAkHy/pJ9TOLCQMmUjZyA55ZayzfpllC/Zk3OvUTnbXo76ifNaRwHVK5ZjtfYA+Zg2aVdkvy2dF8QpUkoXWEzJ6sRNSb9LsbZtWX+Zvm81WhEFdqsVIiRKVZ+rrc/6VOkDZiJl/UqHkffYC621h669YOzZfonc+7J+LbeUJlG5hkzrRxzr+5qiNHLn0q2CRInmH+L6SJT1UesnyjX2J1T6zHqtS4fJUq8FDvKrOGu1vWCA8S17+mf+DUYOT2f5IEXJ4pTV9D0P4YGxOIRZ1tqaY1AHdSFOTmZsb90sVMXpXDLE+T9E9GIDFKnZ69Rbs7ziFa/A29/+9hRVe/GLX4xrrrkG3/M934M3vvGNvXWYGbfddtv6jZ1jZevAHWCZ8DE0c8TIQHIeorPVCCWqk68+NDUS0/iM40a7ZX2MKDlWmqWqODQUIzQJI373dEX9JBfHKTgCGblvACrslRSrUrC9cnCMdJn2QUIrGbnqR+c0y9U5tXJ2KOXmlTo5exLVTJsZW3mBpa6RcyVnK9ctWKxc9dk4d0luInEiR4G5yL5P9hLmvLREnGkYnCZAmQs1HKJULjNKDBR7AXJakJRDI5YCzYOV05hUuZ46ZzAQr6X0VByETCHG6Exuj8jU18NKUdtMz0vPU1Qw61PHfkmRdu1luXwCraCxJOrMuX/kSnlujyVy2d+eymv7tj+uUz9TugB65RTs8Qy3n7E6HZwirVFMhRzIkdd+mpFSdKo/skYVrttbrt/QIv26b8so1XUpTSpxNVaX1SesqS8Ue34wqDxuJRLMNTjny1mKwI3HY3zN13wN3vCGN6TfmBnve9/78MxnPnOw3nnnnYfPfe5zcM7hox/9KF796lfjb//2b9fv74NcDp0Dd5i47pb3xYEDnI+UYtC38TnAggHEDLYmLu5tWqSsT10DRwHgRr7qAICmQsmqw6UUqNRPFCshLubnTNkSo6Rw2zjoEyaRjyjRCVY+WmiPulm1LP1TeVvKmYXCtXIYCld8gTCi6NC0bLCePyNHRZm24uiNzKOUFccOMmd52iS0pnibcrLSrNRmbhxl87yOmEBzcURVHmD0CTTjuGbRqT6Kz5HRTHGUY671OUXLslwwAbptCtpynSFacdokk1DlCQcGGwqTPCKHp/UF65q/uHCfkkMYszh1MiaEluGa/L3P4AFSDKVk5fuhiDRWY/S9R64PFPoA4GvsMyVKyBSp3GqRpmriQOeQKVcCoQXAQTABcQuHSIOpG8peaDE5P0GON8rivWJpM2ZxIkFAC7TMBWWr8niuxF6Tt9HNclTy0r6eS6tPlClcLZmGJFDIjmktBwitj51UijX3J59LsH4lBSlCVmwUzNkee0ORyrPDRsTKSHDMeI5OfW6PCMW1TJgIrc/r9Kw91W+FokxZsCG2Q4V9quxnnOh6lftFOH+HeRV9ho61nGIcfBw3ISB9C/lQlEYmpk3qATh+/Hjx83Q6xWw266g//OEPx2g06kTTbrvtNjz5yU/ubeL666/H93zP9+Cv//qvccEFF+AHfuAH8Od//ud46lOfiptuumn9Pj+I5VA5cIeN62YOkTady/om1rUsQmkaDIqTiWImQ7lypiiTvrPyaE+/dBTrE5op0qQalKIUe0zx815ZTlku+tkep/4leU0Bu8reacgDxFlSR0n/s5RpRbmikEfHuLGUa5VZyBajomjl/CbKFZT6o2uQdJ1idPiopGCN/RhIsHL5r9CnIlECKneVPTL1XdleQbmip302xyOTpsrjR86NPcXqjOp/ZmxmzLJO0Y4VQ+EyEuWZw8xmzHOMgnnO0QYy9XQMRMqV8lhExkQklGbWbxNFCvnqgWKhTA2lyqAOpVtSrmQo3LKflgLt15f95mp7pn9IdtHT/36KNlHWbLJaAShlmilccYAqCldLkE+IDcnTPVjZq7NeE6Uql7mmVLOzmR1L1XdF/82xir65VSPVbR0+izneq1S0l+0p9owiy9augVtuP3bGXoswgIOMzSF5B4uzqE6j9j2EuAbuLE5dp11Cs2EErmnggI4j9ZrXvAavfe1rz0jfPvjBD+KDH/xgwn/+53+Ov/u7v8O///f/Hj/6oz96Rto4W+VQOXCHjeueYBcUZG5l5G09XKZIATtZy3+y5YdiEIl+H2UolKvRZ4e0kDbrZ5wo0yF7o6o/TjdXNXKlSBPWybCr70fIlOrKcsUxMqmTNSNGHhfKlYJVeymaorjPnpE7K6eOfqgwavk4RyFj/yyWviVMKSFB5ajkZX3uqU/D9Smez8H2iQt9VLRRsiejNZA6UCKnTGensUzDOA7nkpZaTOEi0VCkP2jUFDWlqnuEmfoAvPFEKSVDCO7oZ/tD9qxnW1OwRBikWOOxL6Z0eylSK6eSgiUJZSVc1S/lXfspMibyZqHcJmv0yalHv68/KHAgzo6enOt+rMkuQ3KS/q9qTzKgV9aP19YPjeUKExYtB+jRJ7McwcgPYxZqO2oA2syBmwC4/PLLceLEifTzdDrtVb/zzjvRti0uueSS4vdLLrkEt95662p9bVv81V/9Fa666qr1+/sgl0PjwJ0trnsymWBnZyfhOpS7TvGYpk1fNZOQgUhxBcEUI2k8B6AUXwB4hpxlKfXZZKkyI9FYTQB4zpki1OiO1keJWdpjpSCTPmU5uIdytHJTXyhYlo1+1fNTinjUGv0k5448jCm1BVYKlWLyBMesWlT6lnJV2s9mxYLiuUkUKyEvEG9i/5uWARJ9bR+QjY+RN3BtYn8az0X9tP+dbJTctBKV0o2F59kRTLSRRvUAoVgpUbSFXK89KGe1tuJEyfghQ4kmyljkIIDmMcIKoUhpykDj0lc0lCJNX+HwAJxLX/VAG3EgRiPhIhas9lnOFRIF6+LEqGNPKVmxH51KmSDnUT/otiOmvtqjkYPGV7iNGJA1loFBsvNupEBNFiuQs0opjqUQGG7koAR8CIxGcIzGZRzEGWkakVNlLwDzeZQr984tw7lMEXOIGMQIgSJlq7vLcryXNYu2nccBqPoahWmE8p3L59syRRv7l2i4Nh6FysXvSRTrXO6VVF/8dpW3LZv20q2a7HsZ685lR8PKNVKntKMmayQK2MghFKM6fjmyV2bwZnmpX8sBYN6qUy1yj0iR9mBCzMCOW7sY+QAm0m+jGsq10reYod9ZdunLDMEzHMWxUePAeu2UQiU5f/GvJrochuIbTZtfs8g+cCdOnCgcuKEyn8/xkY98BM95znPwO7/zOwDi+X/Oc56Dt7zlLSs16ZzD1VdfjT/4gz9Yv78Pcjk0DtzZ4rpf9apX4TWvec0Z6XNAG9d2qRNmQuVpMpPnIAHFxr7sDJZIisWhyc5apqMq/UEcEwWsfv03NAvsQfab4+H2YY6TUVOm4oBUFLDFRX2OiQuu6k+zcn0q9IusWUK8QOrYSXsaJY36qPQRI5Qms08d2wip2Gg44RD7Rnp9A1LkIlGq4jxaORMyhav6SuGqsyzPS40shCSPkSsnfY6DK16Uxl6zkD+9BYidkGmb4Mz+a4i/N3WkjnL7DB0T4iSJHIz8UXQzdgBrz9YXe0KhxnslOmIp6klle+Lz5vaq9sH6RRRDwSZ7UdHi1K72j8yn18Re67Pc1mOODkLeSiSOR89Wv6TVmG19ac9X7XHGJPcSmfNfZu3CyOO5LiheIGXhapSHByje9PWOUNnX/nSebWz6lfW0KOWZbiRx5Bz0XGR9PYeKa7mOHdW1crL3FhSz+uAgVH3swyH2tv4qRep9DwaUAs7XPrbXh2NnBylU+4Hgc7z404jArVuuvfZavOtd78KHP/xh/OVf/iVe/vKX49ixY3jHO94BAHjXu96Fm266Ca9+9asBAD/yIz+CD37wg/j0pz+NCy+8EK985SvxmMc8Bj/3cz+3fn8f5HJoHLhNyiZc9xve8AZce+21CR8/fnzjhY1j7KbJUyNh+ojRW1Hn0/SheUQhcb9+AGLkznwVgQgpUzEAQAOJ1pRyVvuupGR1EUiiVEcoKdxq/VVXX6I/i+y54fqD7bPRtxTuuMSQaMsQPl19ruQkG08phVvX90X9mMFbtOesPlX1uWqPQHV/3aL+99R3tLC/hT2ivHGy6FMl77TvKEdhCWV9EgeIsnOY9ocDJwo3Y0ozMoMTZZvlkKxWyGihwh6I0r0WIM5UuvdKdyEggMiZsauzfboTzZ0nfdfQjYzm7FCoviv0ncu9gzmX1l48LVGeF7j3yaM9Z89lQUlyD8XpCjn1yD0y7tZfz35Di+ToaZ8KudpvB9pvFtanFfpb6i+W9+O4rUceH7Z+iWP7YVBeYiIy6wGzPASlUDeIaD1IJWh68rrFrV/nN37jN/CIRzwCr3vd63DppZfiYx/7GL75m78Zt99+OwDgiiuuQDDfIbvooovw9re/HZdeeinuuecefOQjH8E/+Sf/BH/3d3+3fn8f5HJoHLizxXXPZrPebJdNSpClt6SeC5npwLw5EpCiPxqR4xbQD8DbN2BHkJBQlOv7Cs8ha7GizAkFm+6HXkq1h5JVGfoo1BpXlGqTJ0uwwUqB6rdUqZJbe1igbylbmPZFv6y/QF9oqiSfSxcMZmLwSGjANh+fdDX+TyhT3RgYQgumLWBS/+Ss6flVG66idBPNxwBJYgkBpJSw0Gg6mIKOD43MmvpKoTIhbyxc2Df15zLWdLAEpC94MMUs2pgla+SaoUsEzKMTluaXSk6BTZZrHrtxsBIw40Q/x0hktteAoFmxKeN6nu137SFej4bSlysQIOsMkycXk4DSQk9L2cJQwEgYjUsOJFidSI2SRAo3reNL8kjBMWcKFD4ubm9GOdNQNz4GIlWmlC0AiVbGLF4gJi8wVM7a/bTxcJB7VylS3XrC6bmWZAMnYaQggzk6WpxoOlfVV8qzTfXzRJuilKC0llLtc8pyleMN9vyholwjpcipv0j7F2pqwtxnxyu/FJDRVxzHQ/CL5Pney45aifO3VaNzGIJdN1nKu5jgE+Wq8pKCzfNAHEue89c6AKVN47g4TN9CbUcOm0XgNnNSf/ZnfxY/+7M/2yv7xm/8xgK/4hWvwCte8YqN2jnXyqFx4A4j1+0xU7+tfKk3mJBvYvOinbbmALLTxXnZTNaH0fdZP1GwalIdnQHMTWpO3/0LykGdyIi5xCT1FXOlH5/IcFbfWX029F+/fujIYShLzpSvldf9H9LvHJ9M9vLwjPq2fnYqtT2lMC0u9E19qLzWl0gQcXRenK6ZFLkLOkbi+jgXKDsN0l489UrZiryuL/KiPpv6LOciqIsgVGCqb66x2Auc26MeORu5rQ9A9jFbZE/l3fp1f9KA8fnaAeXYru+dWj865WZsgMxfzn6Qqc+mvhka6R+6FgxAomzVGdd3slRFKNakb6KGSst5zvXhzPooieSk5rR986LkiKosUZN8AE4vgVkO43DEKF69UXEKKGlEKckpvZSm4yXEtcF99Tm+dNrvAhcvvhrPNN9NpuLZoI6dntso90Ye37nyVUp5LbY9e29DsdxdbkhePaPkfLi6f8j9q4tSqvbZohRqOEQUausa8AZZqOS2H7NfpxwaBw44fFx3QzEZghlYdOslZ66+n63Dow89najMX420FLhHLzkp6jxY7CtMGYdRqa8UmXaxdBa5s3GtLt5XnOyl+j32KNvr6lf2q/qlfl9/zIQIwI+R1odFCtKcS9U3uKtPlf6i+l37fmTt9dUvcWgQHQzBqPWdxVTV52K/Os2CLfq3qD7x4o2IqW6/whL56xubaj+98chYK8a2fj5McKjHflU/eWvJHhdjG2THOuco4OC9Q8m+rk/jvvbsWE1jrdw0Goj66gSwOGNFqeZ5KuQSCTPen91KBUDxmSlpzjiHcWNdq1DW16xVlJEps56s3ui3cISG6ht5d2NfEkrX9H+ZfdMf1Un9E2esXx6NBWu/aq/Ul/YG7ZWYRJ8X6NfHV9TX52+iUA+PAxccJWd7nULu8BzjuVAOlQN36LhuedN1OtGhnBdWNsPoGFCnMDl2KiPErMQeR0xZlETBkvzmjX5ccVvUd7oguC/LtcZK3THLViXGnmRVOm/s6Ymw9i0mksgPp3V5SUWzOOX0sLVPKtcNWHN9mpf6I8HR8SOhVCXqRlEfQMKjtJFu1k/2zfnvx7JRr9Ev7BEJ5Zv7myKl8nLaJEpU7XHCdoDpd24zxRovVsq6VWfA2LOzh2alFvWJ0Bi5XqvB+lS3L1nT5iUifcvVxeuVBreLY1MpUj3eTLEynMizvSxP/UsUK4A22rf0fYwA58QQsFK+5fExIWbosrZHWd9u5SL3Dum1h95L8rm8Sh+c5ZEu5+y4in3d6iVRjnItg2SlFlu5cHb0chaouW9YmSpK+7dp4MPaJ2gWJAvFK/vdpfYZc9FX5ivItYzzsCzIR/5CQqZ0o1ydISvPmCsscq1PkaIEascOicZsmQE2WakGs157Jjg7Vsz5K+xBKdn+9vShbjdKzhSuaQ+ykTB15UqxZiznscWh+haqHzXgsH40bRuBW69U73fbUpfjx4/j/vvvx/nnn79SWrMtj2/+Lzzf/Q6cj05YHWE7U+8a6kQVL2jGS7QUbEefBvSp0tf6ZOrX9myUrMkORYp0JMwVRnTu7EPTrWOvwuL8JH3NGm2MfVqA1Xlr+vuTJ3CVx/WCRWRqgX50EBbY0/aLqGeWU5xzDOWa5Szy4KTPlX0GxxcKqx8W1ec0JjSySzoW1FGvx0aBs5ypqk+5/xoVTFSTOZd6vLV9lrFEVfsEc+3B6fh1fOvx6tiyzmzKqkwvPpKpaJ1jGQ9pbNj25QcbaUv9N+3BtNeJ4iHXre9tXW6QnG89n+k+NvcWuvaA0tkA69515fFYB8W5vJa2n1I19e2Lodp3Aw6P9M8tkMctUhbIwWk9mzn8zvEm/VAef6nPXf2iPc79hZGTaY5KnF6cezEbZ3hAX15+fXA49f7/g1M/9P/GuuV05rBN2/ri3/4XcOjfu21RIbeDr3jKa89KXx8K5VBF4A5badwkTuyQbRy0MHLULP+0sUOnz5aVKNiekhIFdAJUfWuPs7x0llBMQAn7jNPklDAVuNgCBNzV10jMoD1U9mhB+z32T7s+pSgWI34r1n4Zoc4yjpmcFi+Sc6ZYh/SNs8CIk3tjsPZ1SH9p/Vq/sEddytuVclTy3vp+qH7Z//TjouMx+sFSomI/eniCZew26d6gyj4XYzvdK9X9nJ1VKsZK595AXZ+K+mzvIXvs1kPwpb7+3LWHQh6zerv2WF8I9NwU9iTyI5iqvwClr1YA3JE7ylucAD0OESFtYaLywsEhymtHO3JAM5yH5F17i+TxOIfl5fq+TezX2KF8zvbp+yCf0jpMSQxNA94giWEbgVuvbB24gyxNg3YEjGTxd0C8WQmIb9GC1VkK8ld1dB5Z9e9QsRRsEXVD/HfabBhIC447jpk+WPQ/+6bdpy/HWEQeBrBTmslkCiYKlkx0ZIBCTZOtYJc28rXKivNMEUbGAajrE1AzAGkjXY4nNck56+vx5PqL9bv2S8xEkSYEF3JO/e1SxCORq76OEd3oN+m7vFgceh4IaLR/ztQmpAidGi22hiE9j4RGJ2YbBUr6ai9SlMP1uxRt0T50rEUPgASn5QoyFp3Wd+Z4JIqVnCWRp+ORsR7taeKCUJ6iX0dQY3sydtURIqEI0/GqfU6UKEl7tX76pjCZ/lknSI4lJc661HLqH+nl02sLwijka6sJF+l4zIMhRXv1xco4jGTkKORan1NUqdWsVhvNhlKilCjXRvtfyUuMdL7qT3858YT0+IuIouD0PVjmQXmf/YhjQ7rE0VFuO2HEr0QkPTNY+zAQv0IBtokYJda1ejELddFT/twqftQgbEChuq0Dt1bZOnAHWGa0j3YizlmIa7PA+Ua2jlXQByMNyJGf5X24duJqrP8uNlE1BsgaJPNWaCdEra+qFU2UJgvrxMG0xwO/9+rlzETHqLJcucgyTRN0dTLI2nNI22mwPHHJRM24qB/tp4il1i8w5cnNynWia1BEPON2GhaX9riwzxlL/0JDHX0u9KmT5epqfUu5NlFfHRzNkmUgUayOdJLPW5LoZc4UZcY6yTvRd3bMFPUprZdTJyJYORPQSPQG3KkP5LGn/UvJDJA1m7Z/OgkHQDci7lC2jGJxfvoKBosTR2V/rb6lWJN9Q7mm+prFS/bbsFycz6SvDow6z2ZoEpC211BBw1mfCcVYSPeK9IHS/R03j1WnLJ0Hc6+CYSjgKGAy7Yf8LIjnRaJmyO0Tm4CjOEvB9o+Rs2rFuep8a9Xc287IdWNhNsdP5l5KlK7N0nU0LIdkwVb2o/PEyVlTXyp991Q84QBZv0bZPlnMtTMn+qk/VRavjLFgNtU+DMWDEIrQ5mplk8SHL+eydeAOsJAbwctXuUayTxuA+BDzxsFiLKZUB+RYIF/YL61TPxD0YWkeOEnf0CCppAkJm1Gwdf1FOCDv51ZRsIspUbOezcpDj/7p2HdWTmtQvgOUrMG+yV+FWEW/S8n2YL8EP9gUrdkmYiOKNhh7ThuCOalD9uTfaUueHsrX4FRJJ3ShbBvS6R7FtdGxnROhKdW36w117Oe98cr2+u1zMRZSqccijD4q+2zl2Xb28Kiqj+TIsZwf9NmTRCTxg4y9sj/RqeyXA+IsJco2O0KZwqXiWVWvmSN5kaopW9bG9NmEUq7FOmNdORXOXVfOnWco8yL9iL1H3EaEq8rncPGNQ+D1o2lcpllvy5KydeAOsNBogvlEXj8lHEFBHJsxkhNFHmnPM93/raBUgUy5AimqsLKcze8L/qZ+y1uxLVbXbnVA+rC2BlRuH8K13FKwhoaBeUAuxc78PohJKFUuoioAenEg5OSFTezbc7aoPZkoWGcPEkrTVfYpU7IFzSX6aQIFVsKB8pcBUtRLj9dcg4xlQhbHiCkvaK/XUzGJ/ZD1CbU9QE3G+oZKpGwz1eN8TmOUJ1OZHUpXKrFk+KnzZR2ndLq1P8i0lx1fKqeKQu3YQ9kHMnKlRO25k1OfI4p2PJiV/dqXgsK0E3uvPnX0y/PDRX2rH887V/ZNe5ZSTVj3k+N8z6vcZIhbfaf97bE3SOGqnDhfu7q9or5QpDp2GIky1ehXuTdbpmyJIN+y7Zcrdar2VU6O03ms7ef2dU88LvauU3kf1shiCEDw5oKc4yW4DR3ODaJ2X85l68AdYJnTKbQ78SHkA2PUyhOV48OoCRFTEymERlLY9cHTKKXD8WFqcWiyo6WLkJ3WR3QEUraiOnFmMlTnbsiJwwAmICccaEWxrRMvh+ohK04pXI+cszytS9GJVB/CipGPF2QesFgFr7YxsSOA5yizSqXvHawvmOKgB2vf2X5yhUVeULBCaeoQMZQxcXbuIgbYUYVruaXlorNGYh8cH7DpW7JzFHvnkejbSTQ0eQ2XCzL+hJJVrDQaiX3NgqWA5LxmCtc4UxwpzRQ8kvGt17wJciwSxXGQvek0QmvGWnSqKK1368tyJZj+cA9FrPeX3AAuGEpTnJy0vs+cb6Z09Q1G3KjYRDTTNTcOVnB6v8lGzuZlgEJ1DxjnylLI6NOXsRbkvJCcgDqLldSZNusDU4epXJ4gQyre7xV9n5YJelO/cE6iM1wsd9B69b1h2wty/uVeKJaZZLNIW8z0yNP1txSuOrCJspXPXymFqhSpoVSd6V/Qezbo1YvOX9CvschzjXw+WHIkGCmBg8w+nAWFqs9zT+mrFoehtE2zUQTObfL1hi/jsnXgDrCEpsH8SPz3aAa0lkI1kw9kfVzxBmblA5hMfQooFskXlKo6UNVP6d+1/pKi89TKWa9plkrzQbXma0CuDqY4c0T9+hD9VXGKMhmaqsQwFOtA1qqDoVxFLriXUq0p29p+LfdV/br9Qdztb2hkHyyj76r2m1C211T2G78EW8pSzw+q4x3AwZX1occP6V8hN/u1aX2yOM74GtHOJ6FqfwlFW/Snas8eb/pR61dZr0EpWOvck9WX858GqlY0Y9deC6Dor+oPUraI93dT6cPoF/apn8JcSNn26Nv+lvKyfTt+07kZtCcrEBe2t0i+AoVLVGTdgk2/gF4KN0CxfAWjpnATjhE4uy9o6ciLt1pRuN5L9O0QJTG0TQO/gQPXbB24tcrWgTvIsrOD2RGOjoojIHD6mkIKpYvz5ST2TvqXMqbAKRsu6cmnoJy8sYq5iLnCAaCmKw/AMAWLAcy5DqP/b69zZ4tSqPZBWsvTNwpLvYLa0YmwT1/ktf76WDd85Y58iGJNGWw2kgEMZNHmmWIwy7bC6qgPUbra39Sftqyfjk1pJ6NvJ6sap6hNgXP9fvmZ1a/7Y+dhNvpsjt9SogEoIr069hUzZJNVlXNlP2WaImXR2rGZMrWT/WhE9WxiStnffnuo7a9IqapOSUFW138F/cX2abF9fdCYY0nnk+K5TGO1lpuIdcLQ5AjOTrU22DN2i+x7Fxt19t7gsj0k+6a+NKcJQOnF0jj1YBmrTNKvfopU/7Y8QOGyZJ8KhZsSNEJ0Kl1w9Xv4OVsCEULvw31xSZnC27JS2TpwB1jmfBLTYwznCX7MaOaUHDh20RlTB44poGmjsxapz0hNUXrFYzQtEMTpi7vQU6ZYLZaHvAvi18iDwnmDSaJ+Vh4yDtWbolcsDlKw+lhOySqODyQLyr8qJ5iHJBu59gH5Iav7UJWRCdGnHn1963W56eWY8tYM+kA3r9EFbhGdpXoCWITNt1kjruUZN21OnGDkCaXE1JVrhJPZUJrIWakFRuEkFBFTncjMbMIms6+r31efUlSZjLyLdaPeUj8YfYd8fJCQCTcUPxyv9pqsC7YUbaZ0U/BGKN00jHTCtu03gP22a2jS3B31R+lIkz29dwp71vm234q10XTbX1sfgF0PmDqMTAmn9qzjpOcrH2Extgt9oNzCBJwcr6QPM1bVNsF02IxNu/yCgLylijlea6+6V4g5JooYOSg/A/QiJ327TAEQCjZvv5LW4prnEDvkj9zLcom4LyQBXl48jH0bYYXnksK17RPAbXTi0lcVdDmGRrTbSOHqFzSCLJtx3sWlCjgcxW8YgcM2ArdW2TpwB1h47DA9Gh/gk30gNLJrlzhZ8WtxlCjUMC5xTamGsWCVj7JcP2Vl5ajrN/2YQ17XBMgDIxTVi79B5U35Oyo50C8HUHyZIi2GNzLATPj24YrslA1RsAAKCjNRsMv018GccaKRLAWrD2yNLtQU6aD+KpgMBZonw6I9GpJLf+vMxEE8kGW7LiUcNq1PvfbyFnElRZmULEVLJUaF9dpa3NT1TXugzHIxR+cnU6Dyt6J8s73SAUj9Mbg4Hvnb1P3Ve6fCfWM73zvG2WOVU297KmfA0HzyD3u/qj5V90aSk5GbCKMZC0NZp2xPirHXWHv12O7ol/YYi9rL56qQ+7K+W1B/IwrX2O9QuAFwnuAClZvBn+NlG4E7O2XrwB1g4ckRTI8yXAjgxgmFGiNoDnFRquLGYBfIyKMzlLA8pRxR9JRUzkjymIRXyU19lXOI/9ZInK6FK5IfJEKo5sA54mGfJ2lOXCY3WB+2KRmjTw6Y2dK8Zfd5hVZfqWprEMhRJdvACJmCtXbI6CuWY1sZL6BgB7FbIl+IN2hv4fFR+i7lEGWsDkH6FioBmjiRJvsk72LNDNT6EbORU578Olj0FQPxu6CcMz+bCqcMP4oTTaSzOFGgpIv5pZ9Fe6CUvFG0B87OlDpM0paORaUhE0ULFPsn6vEkrOd8wB4IaCQUFm8JLpwrtv1BvJYxcmluHi71e+snh0K9nEx51mMnOKQF+dloHkuwY9OMoSF9O5b75KEYq0bP3shs7OlYJpRRt57jqeuHuj+mfjo19ng69uVe4v7205Y45nfdFqXxANlMlXO8tOTgN9gShHF4jvFcKFsH7gDLnPcwPcpoAjCfeIxnLjlIAQEjTwnPCswIiFmrOXtUKFZxquaO0fiIvXhOKld+UylaLzNFfAhAqJuYBZvoGc5YJ7dGnTlxrhR7Q9GqMxXI0FPykNX1doBQsCK3zzZQtm/1LUWTIpHmoWqfr7YQkDfPTD9kuwWlKhM25GPyiSpSfVfaSfrFB8oB+Kq+YG7MMbgeCjZhLrFSsNpeqHCnfh9e0p7aU7nFvg8voHjbaK9YM9RQhWu5wchri9IvluZSTLa+xVziNsp1bFEAeKQUcaZMdclSvAcyjRezZjOl7OR8xlPPgAeooTyO29wfVmdNKE/4sr3oF+YsU5b2IGNFJ/Y4dnLmYXLEPEp7QNq4mClTsGlNmFJ8Mi82XqJQuh5Sny+GJrX1WRdiOaufs2rlpyR30p6ldJN9uVZxJb/aj8eVlivovUtmrLrs1Noth6g4dgDIWbRD+qxZqoo9imeC3iupvke6rxvpT2j0oRCd1SIC6s21l7FYUNCe01hO97o8Z4r6xj4x0HiKi+cOSWmdg8f6dOjWgVuvbB24AyxhFDA7Grc9GO8D3AQohUoeCIF7cVzzYHF0vrziEJ2tUOBMwSZs6hNTWhSLIAvb9XkQuKBcWZMpoBhllmpF0SoFy0ZfH+QwzZjmSoq1evu1L7abFPuSXBtJafrGeckdM321a57MBFPoc6W/CHNlv8BU4F4KNmEjr/WD6d5CTKU9VO0BC+Q9mKi/f8v6b+uvSqnqBMsWU4WzPJ3wWSX3JW4qnNvjYoJmLrfsKOg4mP6mHwRYCpRKHKr6hT0eoDhXpFQZ1Xkw/SmyUHvHrjh7fRSt0U9RJLW3UJ+K9ur+p7+k9vK17cp7xtpS/XUpW1TfnpVP2/XKxdygPH6pYdg+kpNuHdDGy1Y2xcA6t0twBD/4mj1caIM6X85l68AdYOEju9g/yqAQ4r5YDJCPzlTKBpU39IbF0RJ5ifvkMJRrScl2MckCa6FkvcpDolAtxepaFPqJcrX1x9Qjh8HoxeC8fi/hmqK1k4+U2qGzeJ1bvuOE9ZVFFCxQ0FoA4l1k9fUhzMjRCDtp2W+aqlzqJfsJZ9qnX17iwnGhHvs22tCHQRIdye3B0RKcJ58uzvZSO8588omQKMqM8+TMhiLNFGhNiQ5TpF2s35lctX5XXylZPc96b/TpB2sfSN/cLO2Z9lymkPvsB1sfiGu+NeqH2NZQNlE9dpmEUhV9BmKYSSPrWjHVN2vOesZ2n36oxj7qe6dwXs1YRTX2YfT1+SDnw+pjib6135UbirRHHqiKPBKnsauqiX6X9tK9gOicNHptVW6jplV9xfrCfai+xOAa+A1SLmiDqN2Xc9k6cAdYPE+xd15A4x3aCScKNa4PYozaTKnOKETKVOQRq76RSxpppFxd2hCSYep3cHw3VRyz9zJl6+XteSSUbLtT1Q+I/ZVwvg+qj5xVS5HSzQ/DTPHqfaxOq5eHoFKwvqkwl/pgQ9HG01NQtvrHPt5qXJchGQElBWsNAuUmmyR25nnyY6uvtJC+YVt9l38bomBLTAvkXNBkKfVS7QslmxwsNlgn17o/QluthIVC7W0vYRrGQnHqOUXgnMXZJ59XWO2h6g+q/gzqZwzEl6owQkGphlGZKcmjvOWEUq5RJJOz4DRmm6ifM6zj8QdwpEX1/GtkWyldNvbJZI4rxduaLFpAXhyozDIOZqzo2JX2XGDjZMf6BJQbCcv46FC0cm93xp7KQWLfjC+f5am/SR+Jsi2WExD16+vLoDOOWctZX5892jZL+0pxGrlS1wVlW9UnRrG8AMKJ1/qk9wYD7Dk62ZU8tWeubbrWxl7ciSB+7SWdu0NQAjZLYtikzpdz2TpwB1h84zHbZZxixmSfwC5SqInSHGXsAiGM2GAUcqrlHgjB1PeUKVSVF5hMlivLAyFTro4pY5bd661+IMxl8lEKtcAB4KasrzhStMa5Y31YZlxkwYbovIVKrhNK/XdZ1usyZ64u+hLeV6dDwVYdSv8comBV39Imql/XXxkP0FzWPitegdLEGphlgoXFpn2lIGuKssatxVRisnKucNV/7Q8PyblHP2M9IW5e9q/GvRQrIWWlFvZd1b7BTilZ2765hsso2rzQv7r25sVmKUXbN3ZqypelbTPW0n1GVT2jD5CpLzYHKdYV7Ff66Sd7L9T9qcYuq82O3CgaZ31RhnYvZVttwq0vcKlPaezLtRiQa2cbj8zaHJLSugbtRpuePPQicFdeeSWe/exn4zGPeQyOHj2KO+64A3/1V3+F6667DtPp9LRsbx24AyxhdxfT3ZA+LbS/i5SEkD6jJQ8QxxlrVqliYvkETpIbClaco8ZzwlTUj86f41KeKFmpnylTRjPPcoQYSVN5WpMBGsBxv7qIAYgzmmihWp+BppWJSPqcFkIPYVl4XGTF2k9Pyf+GKFn7rF33fU+du46XaEtNwZoGO7QToaCtkr6hYG1yBSPqJ1zLFZv+EgGsm/mmBeQy+REyJYpufZb+FbiWL8QbtKfRGD0AIwdyMsEwBbsmJVvrG8qTHTKl2osNZZrk/fVT/2mZfk99/cqHk6zZtkvJphYMxcqNfEVB+9uU7YdG11flm0dfwhgANXn85K9WGO/Kjm1pLztw+ok0LsZupmjr+qX92l6ffmjiM031Y3Qr9y9RnPbeMO2npR2I9uqxymasxqFrKdI8lupzn8fyMEWqX1hZhUKNS13WfVo9eGXTbUQeShG4F7zgBXjZy16GZzzjGbjttttw8803Y29vDxdffDEe//jHY39/H7/8y7+MN77xjfjCF76wURtbB+4Ai8c+9o4FNJ7QjhjjluJ3EcEILlKkTmjJ4AKa1iUaMTjR9wTigOAglCYBggs5McbzSKk6BjyZ+gjwZPTBSe58fACGROES2h0We5GynYPBLiQK2HPMkh0LxeoRs2oVx/wIqc8xeYopUrYI8vzmSMEiAGGsOM60XmgUdXI9GyxZZ4ChZLnELA6ffvdT/MbkyAV5mEentPSltCxz7oZkBGSazL7li1DlEHmiZSyFqc9vQ8EWUb9lFKxktlnKlUjaZ5VTpW9x9IrZyNVpVAozYdcj78XUiwGAZpIVa2g4HpXnr8C+rM+8DHN2elfSN1gX+xsKkoEOVsqUdEyPKDviIVKyNqqSKNuqfj/OlLBGmpNckpESpQzkjZwpOnqAOIGqYNpvfMbFeFXKN0XTpap6wi6fKwLyWNQXBTk/bm4oTe0vmbGl95+lUMWRo8pe6hvl9tR+MXbMViwI4gSJPntOdHWWIzn68d6i8t7qZMHKuSIgfXtVx7KRx/YAMvR8olCB/O1WPdcynhwZez461MqYHJYydw7tBhmlD5Us1I9+9KOYzWZ45zvfiW/7tm/Dl770pUI+mUzwzGc+E89//vPx4Q9/GC95yUvwm7/5m2u3s3XgDrS02D/m4QJhPCNgJg9XXZA8KinVUZsxQAit7ELPkeK0GKyUqsqBMC4pVTb6xBUOmTKFJD7wvJIPULpKiUZ7SsGi0jf1VW7ao0DJ0YGuy1M5l1gpV/3weF0/y40DxUhZt4FLrI9B/RukPap+R4WtfBXnrvM5Me2jdcbUoKGs0uRhKVhC+gRUQfvoX5ftK31TYGfa4myjX5+69bVfcpITbmu5cbRWwDk0VskHMa9lfyWKd1n9Osu1rz86KOT8lpRrl5It7C2gWJe1n67nfKA+qNg8lm09ezMoJYzFFC2jpGStQxXlbP4dT2KH0jRjG8jHkyjUon62XbfHElbrXV5APfoszp7a1HOX5KadnrHer7/YHtf1gYpCpXI5ASG9uKWx1Arrcoi+hRposyQG9xChUH/oh34If/RHfzQon81m+MAHPoAPfOAD+OEf/mFceeWVG7WzdeAOsIyOHUF7LGCPW/CpBrOd+Hv8liilGzpGzTJ2XnZ2l/8iJUr5hjYUbJ+88ZkyjfqZggXHSJ5SrmDNQs3tNXNCE6ycTEJBXF9n7Y/mZPaEk/3o9InKjNFMsmaZkzxRsowK1/L4CTKNlkU5yvrSP8WOKTl2UQ6R5/Onjh2ARLF5lXNXDmRH0H4fE1jdsUu6YkNPabFRsepJf20wodC3k3EjDq/UJ0KMHOiktoByhWBL4RIhLabvUrQkmI2cUqRnXQpWz8mQfB1KNk2UAxQsAymyk7GhVJOcKtzf39Xr99tLeEVKVhu3FCcrxan1G/nkWEGhZn1dwJ/MqbNk6kfHPOq7tCA/128W1EdT6rPBUZ9E32TREhJFm8c2d+x168dkDQRrjxLu07f2O3IdS0rJSmRPseonShZybYbkOvZSoheyQygXM46l+EvQ9n2pQbLsxG+ypOxBKl/uFOoi560ud999N+6+++6N2tk6cAdYGp6BjnrMPWE+aTGeEZyPT+u2iZShCw7EDO8YY+9ASiM2jMlcKFMwWhcwkaxTYsC7gLGhXBXrRsC+iVmvLiBSpCbrdc4RT2ZiD9LeLLZHISAQYvs+vi57l3H8HiEiRRqA+a7ozyylq3LCfDeACRjPSPpfytsQwEDauLjlCu9wxkEoVpYs1wB4cFxbJ5E8Lw9Q3cg4jGQdoETmvMzATvQBJDqTOFOyaRNlfVibmTuoHCjfM7kMcCwqGrios1oVp/YkwkCVHCSOqdlsFLbtHgrWcZwslSIFejBH+jn1p7c+VfUt5q59dSIJYEPBElBQrimqt6h/FQXbxVxSpta+OLpdLJmBHtH5LbJOOWceAkIx9tdfDfPi/gCJliNDkaZpnbN8mOKlBfY4U9LqSdaUsKkPrQ+Y9QomEsfIFK3VJzO2lYZMY1ftiyMugZdg6qeXNqlPeuxAiqpykLWLjvK1EVwkSkn/OQjLYPQJsraQkL55Wo7lHOVTijRtX+LNscrxKWWbWASlk/V4nBn7pn5q31CyTp7Pro3/PiylJYd2g2gaPUQoVFte+MIX4l3velfn96Zp8PrXvx6vfvWrN7a9deAOsDie4cjRFicBYOowdw5gn6k+L/+TGZd9yJ+VIoCb6NwBgkWu9YPqSwltMFtASZarYBcIYZ4xGKWcgTCKzh+z4LlgQLJSkZMpkjz3h8fZ23GBwPOIo/1I+ULajnvB6cHGKB/Ps5wYKaoTMRW4aUu585TT7MU5S2+yjLidQdpyJfYnTS5Acu5Se4ZS1UXE+tat/UvYFJXbrNm+Qj3/Tt+ANcZ0UrQ0VK9+DwVLOrQIeU2R1gvIkzuZdmx9MvVpnfrUtZcOiasohHTaXJuOPfT0z/xeU3yJMu2V1xQh+vvTWjllR6Kn/UXH169PZf+dOX5mpC06UgVEitTqs8VUYSvnAqcOLbS3qH52fBqB5bdikd9gADBxMXbT3/SyUWbBOiBl5UrMLL3A1PVZ/lE4qsaRSvrG0dX27L0OihEuVYVpH8hj2eq7gbGdHLl0r1Bxb9pDST+GXL8eixTifdyE+LJ/WMp2G5FcfvqnfxrXXHMNvvd7vxf33nsvAOCJT3wifuVXfgUPe9jDtg7cuVrGR3ewe8SDmbBHAB2Js34IQPA6wAWnL7pLtEiSDXQWV9qVwZFyNeshEqUKiPNh1kuw3vzI2BOaNmNXy0PeTy46S5Tf/qS+1R/1yNP3Flkp1gob/YjDoDx+IszUn1X2Kty0QqnKuevg+RJ5wnp+zJzUh31XXuyjlQ8lyROu5RXWqENnPZ3RKT5bpDbYGkDhIJWbuca+ajZ0KlZe6xu8rn5acL7MXqJwzTYkpr9L29NTYnBynuw8WDsfRSSTO5FNu76qH9MCOS+sD+lfx5na0F7dn3S8ImQgUZDqsJQYkQK1Y6OnfkNVfcryYPY466tv6Xut3yRMRX/66oeiPS73eOvoU94Cxh5/PfZCZX/BvYHa3ir3xgJ7oUfufIzAFV/DOcfLnBzmG0XTDo+Tumr5h//wH+KXfumX8IlPfAIvetGL8MQnPhE/8RM/gXe/+914yUteclq2tw7cAZYxtTh2tEUIhPEoYN46hBDdMucYviX4ENfQNE1A2zoESRVvGkaYO3AgBGZgxKA2vu6GAIQm4xaRJhwJJRkYMet15pJz5puYFepk7VxwjMk8bxQcKdseLBNncIiUawCAgNAYCrZH7g3OlKwrKNSkL3gnUaxsKNmMNSt2thvfjTOOvMlojqTPiFm3kP4wCOM2yuc7DLBsXOwBP4khLv1WrB+LI2cpWpZ1gMFQsAzZZBUxaqkP8lH8q+dSn+f68WrdyLigaCk7aQyDbX0zthRTPDwxKDJ1MLWiWdRe6xMjbzRs1tZpfbKN1vpk9AUTkPexUn3zPci0pckA7tqjSNupvYCCUiUg01JuRfsD7WnWY6I0QSXlKecuy9fFpT0gtteXdbuJvVoOICc32HWPtT3o+aAuJWsynAE5/3reKjnLgnymXF9fVoId85CoHeWxGLNQ47OOkK+tzVrVG0GfN0TZqeHU/1w/nUuY+npv2LGDfHxWP64/Y2NfjgHm/izuhZ72dfmBjk17ryGPvXivEKjN546AIgvV7nV5rhdPDn4DZ8w9BB24G2+8Ec961rPw5je/Ge95z3vgvccLX/hC/Nqv/dpp2946cAdYaL6PY7stfCDM5w7N3KzxIMCPSCJvgKOAkdnLzBHgR5zkAMOPHEJgeTZzrk/AyDGCyAFgRIx2lCfzEYB25ABZM+LAmI6R6TniSImGvLbFj0PMPpWHS8IOIHDGiJSkH4dIvcrDJ0yCfPVBHrqzkOy7kOUZ5wnCBSBI1m5AfCu3OMnFvgsMr1m+EMp4JhsSU5SHNssbTwhzzrgt5S4IZcvZfmNoNWLktWgsEVFL0QbkrFGZdCyVUryki/NnqT0gYp1g+ijZ+iVef1AziS7XbUo4/247kJrVXf7VeZL66qR26sPoO6MPFJGg+tgtTZQwm9+1fVJ71G9PnQ2tHwbsocd+3b6eH3HMSzl19RPmfnsLcbWeDago23XtU3mcDqV9+S3KuYxQcjk2iqzXHrm+UBRRQDOWGOJIFViSsszxNra+oTQd5PNeVt86etJ2w2V9vU+BiiINSGM9/ZTGaty0YnhjYbFX1bfLEdKPJH2p29d7xufLkPsbhR3K1RsckJLUDpMDx+QQvoy3EanLNddcg+c///m47rrr8MQnPhH/5t/8G3zgAx/ALbfcclp2D50D95KXvASvfOUrcemll+LjH/84XvrSl+JDH/rQoP6/+lf/Cq9//etx5ZVX4oYbbsAP/uAP4g//8A/PSl/HuyMc34nfWXpgf4zJJD5NmXVNDSUcJFLUJw8hRuqs3O4HEALBc5aHoOu7IvZB7Us2W4iOX0AAMyOY9nWLEoi+Jgs0nmI0hE1CgNhrvOxnp7iSK8Wa5G0tdzH6pXhe6muWa6pf4ck0UsJl/bylSaRYUeFanrcwaWYo8GiGuAGyYDfPkQSwLDA2D+waF+vp+uTyeR6jkvwr3fhZKVkakHfqVX/VAbT90D8FBWuiHFaukdjacIeCVXkw8h6Ks6NPi/WTPRM5i/WorF/J2XGFK/sde/mvXXA+jGmBnDv6qe2B9qw8OVMD9ZMzVsvDIvuUF/pX+snegLxjD8jJAAnDYNO/ngX4qb4Zv0zx27ARa2ZoVcm8POg3pnWsJGevd2zF/iSKlkpKtW8sFt9ylchicoo7+ibxo2cs990boU9e/U1O3CHaRqTFZvvAbRqBO5f9gre+9a144QtfiB/+4R/Gtddei0suuQQ///M/j0984hP4vu/7PvzP//k/N7Z9qBy4b//2b8e1116LF7/4xfiLv/gLvPzlL8d73/tePOlJT8Idd9zR0X/mM5+JX/3VX8WrXvUq/N7v/R5e8IIX4N3vfjee/vSn45Of/OSB93c8IhybzNEyYTxizD3B+/i23LiYFu6DgwOjcQGtdzmi1mQcADSOI/aRck1yT2BiOCMHib5QtkSMpgmYz504gpGinc9FDpRyivJ2LvYZcA0DM6F0KWbN0twBgTBHG7NcZw7wBE+AlyzXgrKdOdlNnEvMHsEBO7OYhctgoVRzVq3FSBRrdBz3xDnZmWYKlx0w2Y9yDUOO97NccZIDmEzzZEJssmblt/Es/xsMoawhiR2yfUqAvt4nrM/iRjYypkk8hoTFnpOoUvrOo0wUhIy1fW0mXkykLU7U7zfdiN3VSYHL+YHEmHlfWEi5Ih5q/KfKfSWHkds5h8QZ1UilTtRk9HlAn0SuFOEQ5Wr7SgC1VDhSdf20E7/ac9leolSR20fd/kJMmeLskSdnA8hRM42CNqtgEsy9cgBp/Fn7APIazQKTYO6Vqz29dvZS2TWfhT1ke4P1yWCych1gOWpY13dGPyCPt0R3SiOBELf4CGJPr72uXzUUKkFZBmMv9adL0aq+HovKCchReuv4JTmBJNHKHr/eC5o8RZAXVF23fAjK2UxiONf9gmc961n42q/9Wvz1X/81AOC2227DNddcg5e85CX4+Z//+dNy4PSRvXL5hm/4Bvzpn/5pr+x7v/d78ba3vW3jziwrH/zgB/GhD30IL33pSwHEG/KLX/wifuZnfgZvfOMbO/q/9mu/hmPHjuFbv/Vb02/XXXcdPvaxj+H7vu/7Vmrz+PHjuP/++3H++efjxIkTa/X3Md/6LDzj196EE9MJ5t5h2o4QZCYlAtogDps4cCG4JG8cwxvsiNH6Bp5jKsNIHT52IDCIGHMf9Unqt63oU6zvPSU5CNHBY4KjWF8dPidvmnOLAcznzkxu4gCKfQBo5wQOBHLxIdfOsv0xIzqAot8AoBnFaKBjNExopnENn3fx9VS3NQkubiRcYAbG4rAFis7QRLBvYhRwPKUkH3mDXdyIeDIl6Jt10xIm+9nZbFRfHJKmJYynSJRs40kic/Fh27RAMzfyEH9ThyZ+7gzpbnMe6SscDJMYog6QOnTowdyTNcsoomb1YzBh0RlaEJ0eBvWL8MBzNXVhQZREJ2gznyebhby2Z/X77PXor1S/0Odu/bq/4lQDxmms+0NV/RWxXrssr/rT46yuhE1UNTnlMM6kWYO1DrZryFa1xy63b699n7yOurGec9M+MCzvRO2qm4GRo172RaN/rHD32umxLxhb2X7+ikX/tY6/LRq7utVR0wL3fvr3ceNv/yusW05nDtu0rZ/E72OG9T3OCUb4/+Catfr6YPgF65TJZILZbNYre+ITn4hPfepTG9teOwL3nve8Bz/90z+NV7/61WjbeIEe9rCH4R3veAe+7uu+7sAcuPF4jK/5mq/BG97whvQbM+N973sfnvnMZ/bWeeYzn4lrr722+O29730vnve85x1IH+symTQ4NmpjFmo7wkS20WDW5xAlzBVGr9wbnJ8cgWGyWK1+vD4hQChWSjhTtKJvcAgQxzFiH3RtHiVdFjmzRBI9lfKAUh5qucEemJr6viUEL/1hyZoVSjViJIpVI2Fx8+AYbmjaSj4r649mhKYtKdICT4HGV7ilChv5Psr+zThRthGjomgr+TTubZco2paLzZ6VvpXgCJw4hhBcU7Rk6SqunDWdKIa2aFJ7ltZawGpoux2H0DiTiTK1Mp30aEBet08lXqo/UL+jb2kv7Y+Z0OttMFJ/a3ubOG+99Xu2xVBKU52TkPUX4T77GhXsr7/YfrKF07RXO0yhskdL9FHZp6q+Q4pE9lGwTRobXWfR7tQRv/qS206PSFu/Z2xl++UWKfZaFO2le4VzpM7oxz3gCNjpdwLOxeLRxOSvDeqtUw6DXzDkvAE4LecN2MCB+8Zv/Eb8wi/8Ap773OfiBS94AR772Mfif/yP/4Hrr78eT3va006rM4vKwx/+cIxGI9x2223F77fddhue/OQn99a59NJLe/UvvfTSwXYmkwl2dnYSPn78+MZ93pk4HHNT+BFh5BieI2UK4pR9rhG0hhieKUfgEq7lrpLHB15DjDaInEQeCJ4dnOB5IISgOGAeXKRwKUYA594hBBezYl3A3DeSJStyieip/qxtYoTORf3pPGJyMQI4E+wooGkY+zORU6R4p4IhFPB02oCZ4Jzo7zeRMnZC6e5FfU8MahjYa8CBsO8YcIxmrwF7wpRiFG1nrwF8fEgyMY7sNXH/OVkXdeRUIxSqXK/9SOmyhLKO7OUsXADY2cvfriXOFC0TZyzp/omCbWV+CbI9iiRKgIHxXJyxY/G3kSSRgKO9kWQoxrf3+E3dtIUMxyhiiryxfL6MIRRtpmT1KxQa4UtzqvTDMKZxQrOULKXgQfF31UJAl4I1baXNihfJIToOKQuWkCfblHChjlXo6gPZES0oW+scEHKWpejr1j1Qx02720Phkul/x3Fzxm4PTvVDrqty7Qubk2GzIrO8xHo8eszL9JfZB+WXg145ynMH6Ia03B9lAgpKtCO3uDHnDpBrq41lilad7QKrPb1XtP+QgaDHi5KStfqWIgUgWbS63RJ36P+0vIDK+klPxiYVYzM+e0ixoVDJA489/lnciMNRTpdCrefd6XTa6widLb/goMof//Ef4/3vfz9+8id/Ent7e2vXX9uBu+666/C0pz0Nb33rW/HRj34Uzjn8yI/8CH7iJ35i7cbPxfKqV70Kr3nNa86IrXDyJI41c3g4tM5hGkYIMotGB8zBy3dWRkqhQh24AM+ZQh2JfkDcE80pxSq4cYyWHTjhgHloIF9HxYgCWoOjw5cpV+cydghwxLE+OzQUImU6CsImiYPmQ/yWs9TfGUcHrBFKdjpuEAQ7YhwZ+4hdnKWmkyZhArAveNQEOAKmOx4hRAwQ9nZUHhdF7R2JDuZ5ozgL7O2OEBi4oAkx6rk3gg/AZOQxYofZqQAOwGgcMGLC9FSIlO/IY+wd/MnoEIaxR+MJM8Gzicdo7rB7Mq7pa0dBcPys2HwSMJoTjpyKTlTbBIxnDjunKOM5YbKXKd7RnDDZj5HC0MREivE+hIKNiR8jzaJ1McLXzNU7iIkcTZuzbBufI3dxrVeZtda0yOtxgLT9CyA+g1KynLP0YOUwkykWO3ExF68MS5CdjQWTOJbRi8xyEo8oZ8FyXuzOWd4kZynK83pD0ZfJMS4ZIJNlK/pc6UuXKRj9NKGb+pBEIokCRXk+KUWWrnXiIMdLUh8oHQw9yZwd11Q/2PqUs2o7f7nA6ZySrV/9dTWmQXmyl/rDPfUP2l5dn7IjpI68OR8pYmscZOtsBXXExF7o0U9ZtIjrbxt1iDmOjRQJVPuU7xOW+sVYCea4TcQQErUjI3cBuPtSj+d95qP4YxyO4jdMYmikzk033VT8/prXvAavfe1rz0jfzqXyhS98Ac95znPw7/7dv8NjHvOYtetvlMTwxCc+Ec94xjPwpS99CZdddhme9KQn4ejRozh16tQm5lYqd955J9q2xSWXXFL8fskll+DWW2/trXPrrbeupQ8Ab3jDG4rw6vHjxzuDadUyHjkcoym4AfbCBGNnnhpmGkyUqubW13Lkm3uoPnrlbVW/TfrWXuAl9tNvNFjfcylXfdUNwnMoZitnFJRsjExW+lbOkP30hHJlIASXsN0YmRlofcziTfqeYnKGlcvGyszAfE7Yb7N8PiN4wWBgZ0oYzyUEwcDOPmE8pwKP5iFGCBiY7MmedRw9jPF+3ExYKZqdPcT1doLHU0TnTdqLlC2SvKZ8mzlnyjjEtXjOUMDkGX6MAlsKVyN+FjsbHgoVZs7RD/Q5bKsXrWUpUfFxcvMNCme0kNOAPJT1l9rbVJ/imkwK2SELLp8fJkZwKD6DxEDaVgIUHXiS/SFh6ouvJms+zfnmrK+ZlRmjwrpNh97L8YaKcvlyABvfkVgwDePCHuJeZ736ap+H7TmNXg3Yc5U9V9nr1OeqPrrtodSPS9Syfarto+zfyDwXQ8PyucFoK42dNH7yvcEghIZlI0kk+zp2kr7B7Yhxz6VzXH3+3+Ir92/AYSkegN/gmaC3yeWXX16sgZtOp736Z8svOKjyohe9CMDmTN/aDtwP/uAP4rWvfS3e9ra34ZWvfCWuuuoq/OIv/iL++q//Gt/1Xd+FD37wgxt1ZFmZz+f4yEc+guc85zn4nd/5HQAAEeE5z3kO3vKWt/TWue666/Cc5zwHP/VTP5V+e+5zn4vrrrtusJ3ZbLaQs16n7E4czuMpPBxGTaRQA4QSBctWVhl7RErVEcMxxw8CC2WpOFKiAQ0zPEj22rH6Ud6HveBGMQgeQqGCMZcIX4OAEWU8omDkDg15jMCYcUyiGFFAQ4xpcGA4jMhjJDjqxwjgfhiBmTB2Ub4vSRljFzCigD0/ivYaj4YC9tsRPDvsCN5rxwggTASfmo0R4DBpWjQu4ORsAg/CkVGLhgJOTicITNiZeDTEOLE/hmeHI+MWjWPcvzcBM2F3p4Ujxv2nJvAG3/tArL+760HEuPf+CQI77O7Gd8uT90X9ybEWxMD03p24FvCYBzHg796BD8D+sYApA+6uCXwLnDoe97/buWuM+Zxw97GYRHHeXSNwCzxwXsTn39WgmQOz3Ui/Hr+ngWsZ8yPRSTvv3kgBT3djhuzR+x1cy2h3COM5cOSEi87bDqGZM3ZOOjgf5c2cMdmLkYf5DmE0Z4z348alUR4w3o/Tervj0MwDRtMYYpjvZswIaAU3syhvjwieR7mX+q4lsAvJ3kq4CWgnEZOPn4dT7LzIxw5N2y8PTYA3cj8WPPeg4ODHDD8mjGYRt5MSh1HEzczHBJsxw08Io6nR78XRgW/HFou9keiz6I+kPaaMpx4E18HzCSOMCONp5HrbnSgf70ePcr7DCE1MuAGA+RFGcDVGTNgBMDsS6cfxPgBEe8HFlwhw1GcX140OYoovIAzk7x5P4wvP7Gj8rvFY9Ge70bMZz6J+3IQbGM8cGIzZbqQQx1OHQIzpLstyhPicmx1RTAgU24vLE0z9IPac1BccHGMq+lEeMD0aI9njmUOggP1jSJhdwPQIofExwz44xvRolI9m0RnbPxbXtI7mDtyIfBYj7KFhTI/FF67RnKQ/calEM4tjc3o0JkM1c4Ifxfqjafy6DVzA/i7hyfgC3hp+Gtc90O/EnIvFw224Bi5G4E6cOLFSEsPZ8gtOp3z3d383fv3Xf73jV4zHYzz/+c/HL/7iL26cXLK2A/eyl70Mz3ve8/Ce97wHAPDJT34S//gf/2P8+I//OP70T/8UR44c2agjq5Rrr70W73rXu/DhD38Yf/mXf4mXv/zlOHbsGN7xjncAAN71rnfhpptuSt8W+6mf+il84AMfwCte8Qr8/u//Pp7//OfjGc94Br73e7/3wPpoSzi1h2N+hrZxaHmOKY0TRTrmAE+ui0koTgSEVTBninSOBoEiBTpGwJwyHiGg7cMAGjAaDpi7JjlwYw6YLcAjoz9CiPWbkWCPEQfMmhECgBECRsyYGvmYA6ajmJU7QYsGjP1RlE/QwjFjfzxGYMIRzNGAcWo8BkMwM07tiIOFGRowHtiZIIBwFDOMwDixu4PAwDHB9+0eAYNwHu/DgXHv0V0wgAuwBwfgnvN2wSBcyHsgZtx5wTGAgYfxSQDAbRedBwB4ZHgAHAi3PPw4iBmX+vvA7PClR1wAYsYV/h7MfYPPPupiNCHgce2dmLYNbrjs4WhCwJPa2zGdj/D3lz8CI+9x9exmPDCb4OO7l2Hi5/ia2ZcwnU/w8d1HY9zO8Y/3P4t2egSf3L0C43aGr5l+GrPZUfz97pWYtFM8bfop7DXHcMORx2PH7+Pq2d9if3Y+bhT8lNnf4FRzIT6/83js+D08af4JnGwuxhd3rsKRcApP8H+NB5qH40s7j8dOOIUn+I/jfvcI3Dy5Ckf4JB4fPob73KW4ZfJ47PIDeGz4GO6ZPAq3jh+Po7gfV4aP457JZbht/DgcxX14TPg47p58Be6YPBa7fC+u5I/jrsljcMfkShzFPbgCf407J1fijsmVOIa7cAV/AndMHos7J4/BebgTX8GfwO2Tx+OuyRU4jjvwFfgb3Da5CnfhK3Acd+DR+BvcOnkC7qZH43zchkfz3+KWyZNwDy7D+bgNl+PvcPPkSbiHLsOFuAWX4XrcMnky7sGluAg341H4FG6aPBn3kuIb8MWdf4D76JF4GG7Co/BpfH7nqbifHoGL8UVcxp/B53e+EifwMDwMX8SlfCM+t/OVOEEPwyPwBVzCn8dnd74SJ+giXIIv4BH8RXx256k4SRfikfg8HsFfwo07V+MknY9L8Tk8gm/CjUeuxkmcj0vxWTwct+DTR74KezgPj8LncDFuwad3vwp7OIbL6EZcjNtxg+BH02dwEe7ADbtXYx9H8RX0GZyPu3HD0auxjyP4CvoMLsDduP7o1ZjhCK6gz+B83IPrj16NKXZwJd2A8+gErj/2lZhhB1fiUzjmTuLvjz0Vc0zwOHwKR+kUrt99KlqM8Tj3KRxxe/j75iloMcJV7nqM3Qyfav5BxHQ9xjTH3x/7BwhweAKuR+M8/v7YPwCD8ERcD3KMvzv6JDAIT8b1AAHXH30SAOBJuB7BEf7+6BNBYDyZroenEa4/dhWc4DmN8XfjJ6CBx1NxPWbYwd+PHo8RPJ7irsd+cwSfGj8ODVp8pbseJ5ujuH78OExojqfS9XigOQ+fGl+JCeb4Sroe943Ow6fGj8EO5rga1+O+8fm4YfIY7GCKq3ED7h6fj09PrsAu9nE1bsBd7kJ8ZvwVOEr7+Er6NO6YXIjPTB6No9jH1fxp3D65CJ/euRznYQ9fxZ/GLZOH4cady3Ace7iaP4ObJg/D53YehfNxClfjRtw0eTg+N7kUx3EKX8U34guTR+DzO5fgApzE1fxZfH7nkfj8kUtwER7Av+Q/wzX0IUxuvRv2G7/nepmzw3wDB87BLV6f0VPOdb/gHe94B97znvd0tjQ5fvw43vGOd+AXf/EXN7a9tgN39dVX46677ip+a9sW//k//2f83u/93sYdWaX8xm/8Bh7xiEfgda97HS699FJ87GMfwzd/8zfj9ttvBwBcccUVCCFzHddddx1e8IIX4Md+7Mfw4z/+47jhhhvwvOc976zsAQfEdQ/HfPS6TzUTjIsBnSnK08IEgBmNrqTeyB7DraPPstDWYNeR6z7n0j8hEzpyAsAxoshmFbhL+vGcWTkx0CCIfZUHMLkkdxzATqKTCGiCYGnbYsfRAVWsDq3WH3Nb6I/ZF/IJzzEKPuMwx5gD4BzgGDs8wxhtxMTYmc0wgk94d38fE3hQQ4BjjPenaNiDHAEjBsIeAB8pdmJgfw+RKxW8t4+4112sHz9JEeK6MmJgWuG57HfiRL9tK+wzjpxzvE4WA0ibqOkCrT4s4zPueybyVjg7uzDLjt2+say7uwKSYbFAnxHPrS3L6lv9un6v/aH25B63n+FgynJdE1BkZxC6s5ZJjbSZFqkvtLkcVB0PdftTLOewuJJ3jqe214PVZvHvFfsPGZdUyWlADpRYP3WzaXsde7pYbo3zv7B+pT9rgdsfAE5O4/PhkJT4lF2/v5vUOdf9AiLZi7Iqj370o3Hfffednm2kJ8629JXT2UPnOd/2dLz4Xf8eJ8ZHMG/Gca0YOTiOi/QDQyJaQqkyEETekKztIkLDmsSQ649E7onQcMAYQtF26js0HCnRlgmBCCMOGEGwc3DBiz5Je0EoXdEPkYJs5aYcibxFjCBOgo8RP8QI4ZhjBC5jidhJxHEi8plEBHfbOUYcMKUGDOBIaCOWCN+uj3jfjcAAjs5nETejGFGbTTHigL1mjEDA8ekULgTsjScAgPP3TqEJAacmOwADF5yK+OROxBeePImGGQ/s7ADMuPj+B9AExondI6DAePi9J+AC48SxXcAzjt95L4gZD5x3FOwDjt92LwDg1PFdsA84dkvE+xccBdqA3ZvvAQBMLzwKahmTm+4FCGgvOgrMPMZfuAdwhHDRLmgWQF+6F+QccOGR6EzddH+cMC84AswDcMuJiM/fifj2B4CRA86bADMP3LkX8bFxlN+7Hx2YoyNg7oH7plF+ZBQHyQOziHeaqH9C8KSJE8y+OI87o9ifvTbiSRPrz3z0NyZNdM6moj+WdNaZB0aE9K24mZWHaMMh68/FOZVPv2Ee4r8Ve85yz0Abov1GFjwFI2cM6Lv4W6j0402ZcctxH5xCH8BYnLIQItb2Va64leMbuzhxq37C4gAp9pKJMW7iOZmHqDNp4sSu8kkTn96eK7yCPHC8lmTs74j9VvCRUcRzH8/pkbHoi/O+o/I2YyBeWwCYjCr9nvpAHE8qB6LDYuVz2cX5yCjLHZXtKWYAU5VLGqriI+N4HIv0Wew3FPuj+jr2g+g3FI+PWfSd2JOx6uTeSGPfxeupcq0fQsbjHn0fIiaARw6/94X78H/95vpOxoOxD9x/Dv8/7Pd9fmNJOYIGP+GefVb6etDlox/9KJgZX/3VX41PfvKTads1AGiaBo997GPxnve8B9/xHd+xcRuH6ksMh634k3s4b76P4Bza0GLmRggU17w57xHIgSlmjY6CBytFyowRe3iKDowDYxw8vIsOkOOAUQgRE8FJ/eA0KzVgHAJa18TvgHLAJHjBhCYEjAWzjw7byLdom1GWe49504gDFzDxbcJN8Bi3Hu0o6o+8x0TrgzAObaw/ig7XuG0xaT2m43FcH9O2mLQtppMJGMDOfI6dtsV0PEYgws58jnHbYjaJMcsj+xFPj0wihTqdYjJvsX9kAmZgdzrDeB7lAHD01BTjtsX+kZ0495zax2TeYrob9XdO7mM8b3He7g6YGeMTexjPW+wejXh0Yh/jWYvJ0Ul8qN93Cs3c46Kjkzgh3rcHzFpccPRkfOjetwfMPI7vnowPXcHH7lL5PjDz2L37VKx//z7QBkwUn9gHZgHNPXvxof7ALDoO9+1F+amZ1JtGe6fm8e8Ds/h3TzaGOym/T1tgD1FPJyEA2J/HSWguE8d+myNicx/rMXKdmc8RFi/1UhaJOEIcm0YA4PWzBZC3C7ORZ8sS6UN2LLzFgGz+Z+r7LG9D/E8jeQHRUSTEPe2C6pNk9Zn6mpGqkUMH2ZwQOUqo+hodKeqrfZmc1V7ry/qtz/1Lcpj+hKp/GqXV+kbe+hycc+JYaaRQz0cvptJRUvuKSfqvY0L7NzP6jZE7EtyW9qyc5FqoPar1BRNiZNJRT/02B72IMlb9hCnLtT4Qx7Iei8V6ffbnWZ9rfTZY7c1z3YB4j6k+c5Z39MUp37djO+Rrn+TzKKzvBQd5aRL9Uby+NG7yZ8sOQYnrq9fv7yZ1ztXy7ne/GwDwtKc9De9973vxwAMPJNlsNsPnPvc5/NZv/dZptbF14A6wNIFxdDYDk8PeaIxGaS4AKVVTaKWmwo4ZQGuwmXBUXuBQ0DTEwWw+FNDoVgwAEBgjpQQBIESHEG6W6ruQ7VGIFCSMvgsBPM9ya4/EAUzYB4xbnx92IWDkPVj2vXE+YNy2yb7zAU3I9Zu5x2jeAidE3rYY62TKDPIBo1YoSWY0c4/xvI1RLI7OCc19gTH3mRKctvlNXJ0XK99v85u7Yqs/rfT3WpmwKjmZ+jpZ9+GZzw98xVauUZJVceBM7ei44VoOwxqVYzHt41YH67n6dyVORSeyVdfw1JRVXZrK1jJ9dapW1q/k69a3VJc6BZ36C9rrtUelvcK+q/ACeV0OxN6Z7A/11F9wrtbVr8/9uvrLrl097tcdq4QY4WvocDlwfHpJDA+F8rrXvQ4A8LnPfQ6//uu/PphJezpl68AdYDlvRDi2vw8WGjRIZmjDEMqUJamAMWKlUIVStZgNxYq43mvEksWq8iEMYByivhc8CgFjxeQwCprVGperjHzGgQgT72N9it9l3Zm3GDGjpZgJNp77hJmAyTzWb13MNDsyi0kHXvBk2iYciLC7P0cTRJ8IO/szOGa0TVxZN9qbg5jhZR2TExwaWeN2MkaieCQO48lZdDyUQntgGvcOMxhBMBAjYgyRM3BimmmtIJEvlQcjHwmFZjEz8IC87Y/kbfuk4IaiY7bXGszAKRNNCAGYicekb/utOlTIlKJiZt3DJRYdJADi+qs+B4yyk7bI8Vr1AaxLEXV+IWNfsS2NnDf93eo7ZCpSJz/V14iF1ad19UXORq7UKyNeEydypugsOiOv7Tmq6lf6yd4Q7rFvT39jJnzVL/Ca8o79ZfaW2K99ij7nF6aOOiFDTsyQvl6rIX2Vn0n9wvnSsWT6Z+V9x2P1h8auXntQ7Ju+BFp9ArhxcU3sISmbJjE0DyEHTssv/MIvHJjtrQN3gMWfnOH4qT34psG4bTEfRYrQhYCxb+FdA1YKtG3hG1fgIJSlC0HwKNdv50neeLFncdvCj0bwSnHOW/iRyFuPyXwOPxohOMUt2vGokLfjUXQ+W4+dmZW3guMOSqN5i/FsjnYyjg5m6zGZtWgnkUJ1M4/JbA6fcIvRtEXYETydw01bTGTdDO3HCNZ4Z4REb8xajHTdiuBG17WcmgPTOWhnHPX35jECputYTs0yDgycFKz1T85ilOvIKFOTc5/XtZycRzxpojN0ymBtf+7zOpf9Nq97ChzXkIWQJ/qpRNjUkWhDptMYkT4LQPpch9JfGtlprQOHWLfAlTMQqgcpc//ktk5ZONkhT3CpTZgJjXNSgf5Wf19Ko1Sqr1RhUjH1lda0pWPf6gPpW2IJG3kjctvn2ilRe66nvjMd7bNvceojlTjVl4m9Y29DOTTyatqy5y5FB6kfV5epcFCG9Ov+dY51gX5tr/Yal0ZHjX7ftdSInT0ftpqVD9XvnI+6veo3ro5PlYpjLx04ahz4MCUx8NlLYjgXyyc/+Um87nWvw//6X/8L8/l8UO+qq67CK17xCnz+85/v/W7rsrJ14A6ytB7H9qZg57C3M8FUaasQ16glijQIZdnKw4cla7Jtk37jA+J3mQSHADZ4rOt/BI98AGbzjNuQHwghoGkDQPOy/nRm9D2wb/BcKNZU3wNTiXi1AaN5C6frTHwAtR60L5NUG+Ji570hLOutlMJVfErkc58XCyfso+MFRNm0zfXnbYxiNYKnbbavlOTUx8X6iVKVtWfqYFl9lSeKVddjUZa3cn0shblPGXudOI2cgsEh40RpUo6whQDM5eFmo001BVpE3BaU9V+Oc6knzY68nkR76nechmX2Fthft76lJBOu5KtSpIP2FtlfEmVYpr+ufNH5IZxdCnaj9muvcY3269JHmZ4OnX66+rSCvr6gLDquc6y07NBu8JDZ5OsN52J56Utfije+8Y34b//tv+H//J//gw9/+MO4+eabsb+/j4suughPecpT8HVf93V46lOfire85S347//9v2/UztaBO8ByfOxw7NQU7GJiwLG9/ZSk0DAAoTmbEOJLv1KqQTbg4PjZFudD1ieg8QEjAMxxaw0X4m7iLPJRGwrcVHjcRnsBcZdx1VfctEGCP5wiaPrZIQbiejL5NxNAszZ9xggUHZz0CCKJSNk3XF0sr0r78xLvWbmpr/hkrb+kvsVc2WOJkA3JNSnA4pmNeBkMOUnzCqcImDhbLZfytHafKwfMnLSVKM8zVBZRojpB6stIn7yhMmKxTL+OcFj9FAFZUl9LWgNlaCiNfAIl5Zn6ayjYjv1af6C+te8sRoUred3eMv2l8hXsL3J+114vuKa9Tv3T1e9xyLDARk3hNsvGlh2LWDwWsab+sntDMQHcOLhljv85VAJvlsSwyfdTz8XyJ3/yJ/hH/+gf4VnPeha+4zu+A9/5nd+JxzzmMdjd3cWdd96Jv/qrv8Iv/MIv4Jd/+Zdx7733btzO1oE7wDLbm+HIqSl84zCZxazKlDU6zxRpEwJGsxY8csmBG81bBKE8nQ8Yz1oEkTc+YDKdI4wNZTrLlKdrPUazFn7cJNxM5wiTKKfWo9mfw03iVgDUxgxEN24S5mkLp1sXzFpgvwVNGhBRylikSRNvt5mPFObEpP7P2pgqD8SI1v5cUv85Jw0kucXiQE2FogRi3anPqf77sT8Rc04ymNRYKNC91lCe0l5Nec5Dxpp0oFiTCHSN2zwYCrQH61YNSlXp1g7qGPmQKVKgpDi5wgDOCOXZV/psakSinivSBIMyyqEYrnLCxIlaRV8nYeskyZ56q9VHPtcpuucMNvqOMrb2NGqlE69+ukr1E2VaY5y+XNuz54NNfxqjnxzkIXl1fIky1ePR82eOr8BL5DUFu0yfTFVrRv+RooU1rvTTuwzlMdqHbZ3ClNEji7Wu6S/bvouMrH7n5qj0ByKKqV/2XqHSnm0fSPcGjRzCIVoD55k2Skh4KGWhAsCf/dmf4c/+7M8OzP7WgTvA4ueM8d4cxxxhtjOOmaNCmTY+gJ3Qnkpxtkhy50PepkApS6VYQ8Bo7qPjJdi1HuO5jw5WCMDcY6yZkEFsaSakDzkT02LV78NTk1nphVJUrJTn1OB5yHheydX2fiVXPFM5lVgo25QlqlsRJLkv5QUOGbc+RsE0cjbz+RgAoUQ5R9LmPicPKGWp+5FZSlRxnfUZ0JMVihxps46LjbTZciajbnZSGZQvoqGq+oNRmnpSH9Bft/66FOjaFOZpUpanK1/anzXtd+wt0K/HxrKxcKb1V6lfO2sHTfHWDtY6WaodOar+L9EnpCzUhe2eY2UeCPMNnLHRQ8yBA4Af+ZEfWSh//etfv7HtrQN3gGW3ITR7M4AAFxg78m/IdlYaWSEfs0bjbs3x230UFCMFIlQOH782kHBg+YBylmMR1s0719I3uF1ir6MfSv1ZJZ/5Ctfyyn7d/jJ5p78L5OqQ6fURlYy5wigdsT75ys7XGfLS+qJnlpapJ/hFFKjqb0yB9mFaYs9wuH0TcNNjz8qLCZp65NUk0Yn+LdBfRb6IYl1Gydb9OV1K9cG2p9dYceOq+lTiRWMTWO6sLtOvnb0zYd+O5XWWC/TKe+oTDl0W6pd7EoMt//Jf/ssCj8djPPaxj0XbtvjMZz6zdeDO1TLbnwOnpmgaBzf3QmFGh41mLTBqwC5izOZwjey+7hmYtaCRPOxk0T+NzG7ps3kHY2zwtI1ZkKC8SWuSS7RrLA+npC+7tWs0bKfJ9ffnmeKcKSUqu6fX8qnPlKhSktN5uXt6n9xSrjPpDxDXqCXMOcJm6/dRnkNYN4XVbUU0guYoR9p0d34gR9z04eslEpcwZ6z69iF9UKXPvo1QWDlVlGSacCj+3kv7VE4YpB6JPiNHx5IZxbW8oliVT+6z5yp9S5FSJU+UKOVrkHAth6FUK7k64Q7xugdz/OpPrmOvj7It+tcnN+eHa/sibyifP4Zs66EdN+fbUq4Qe2pbKVwdBxYnSlfxEnt2Gw7bvu0PkN9N0thTfeQT32ePzLklqz/Qfv3vPop3mX071uy90qevYzvJzbHVY7u+9zr2zFhI/afs5C+K1J1jJSYxbFDvIZLEYMvTn/70zm/Hjx/HO9/5Tvz2b//2adneOnAHWOZzHxfYOweajGIigqNMaWomY6JLDfahlNtMyFXwzMesRUfRdsqspExxWvk85M1iW3GYlKJVelHl8x5s6yt9OV+A21DiWQDms1Ku9mY97fkAtFafy/4vwrpGTbff0L3T9PkYVC5YJx9dm5Yo0JDl6sjZcoYCap1STFxD8r4HoZk0O1GlRfqEYn501WSybCF6TXmKb5R+66ME16FAzwSl2VRyi1N/N21vTX3bXn2t62u7TH4Q9mrbdf0zSXGuot9Zk2ZKh7Jc0/6iDNg++x2567a/UL++l+Izmgbv0XOz+A2TGB5qa+CGyokTJ/Bf/st/we/+7u/il37plza2s3XgDrDsEuWtLphjlAnIER3mzbA3ONF4BocK62d7kpwzRWnXZFkK0fOwfstL5FV9X9lfhi0lq3JrXyejofoL5VhMeQL5Abo2BXqGSooC9PQH6NJQtXxEpXyZfrNEv4OX6Rs5VXI7OWlESie1hGkJXqZ/JuWuxJ3+ux57PfXTte1zhhfI62vVp6+U9CrXatlYWkZxLq1/mmPPneZYPdv21z0/i+rXY9GMNSYsXyt5DpXg3QZfQgXCQzACN1QuuOACXHDBBadlY+vAHWDxszbu+t9Qpvg0Qjb16Tt3icIcCYVaU5rzCtdypSDHo1h/HjImg0fGnlC4RX39APVM60sYQtvXrNCpJCDYrFObNWopWyBTngUOmcK1mI2+finBbnSra+z0A+NWrmuJWs4UKCNH3PooTq6wymHwmS59drUvibaBiSzIw9zSVqSVKDMuNnvOVfpAnhyUEoRi06HUNmV5gZEpQxh72j+l/HRjXks5ompfz7lS0anvPfpY0v4Zk1uMioIjQynKfw3l403HY87vulmejhBpt0qu7Vlc6FcU6hDWS53qI//DjpUCV/aL+tof+b1RPrrSryn6YmyK/fpaJH0qHSwYnUFKlKvjqcd6jz7QIzfjn7SvZizZsdFpv+d40vkfqm/vN3P8I3eoPqU1Dw7D29cuqPcQdOBe+tKXFpiI8KhHPQrf/d3fjT/8wz88LdtbB+4Ay2zm41cAHMX1X+pEeKEP9fugSpcWlGmFa7lSio4yHamUoupaXFCkiuUhl/C8wpXcG9wy4Ct9H/r1te2ifp++hMa86OrHzQNnWhOI/+7ILTa/qZyRKU+gdNjsb4vwmSx9D2M7dxR0STVpFxNTn35tj8pjrZ22mrZZaaPaSr52/ar/QL4m6nirrHEVpvLarENRLjt3vXiZftWe+jAb21uAIfXtS8a69euxtIhiXMVebds1JV5Kca5i3zhAK1GcZOwvGOt99tehROtrn84tZXl9fu3YHaxv5I5AjQMdon3gGATmBedxqN6ic39Iy/d///cXOISAO+64A+9617vwhje84bRsbx24AyxHGHF3f1COLCktV2Q6cl4/pZSkxbXcc/68Up++xSGgWJ81iEPG3vSvT18dpIS5x7lCJVfM5QPK1q8py15KFOa/HjlQvrHX9mq54jNZlq6LGZpEpJzpj7UvW6O2yhq2teqfZntWrvNzgRecj2X6vXiZ/jpyWuwELNNfKl/BPhbo1/Y79St9Z35P8tMYi8v0z7T9+ljX1e+03+OQnc69vqy+2GClyg9JaQOh3cCBax+CDtzjHve4A7O9deAOsniOHzpvXEmhtiF/GspR3hdtNECZWqwU6X6bKdi5ROSUklyGU5aoZp2GCgslqvrqMGrkRJMWlMIssFCcFnuOx6yRES+/JSxOn67l8TCUJ+c1fwVGfqDZD5erPRt1UjpDHTf77VBbNn14UPVvuw2GldsIky31NhKjClvaqqBAFVcTSp2g0IloUVl/ZDBQ4Uq+zF5ak6UYFe6RkzlJG1GOqOxb7Cps5eqsVPKOfcbi9leQF5vDLmuvOn5Axi7KDYcTNvb1HlH7TTUWVT/Zd6Y+l2NH7dsqugbPjgdC/pJF53q4sr6O9fr4tX7TlP3XsWLXlKmcqMTptFGXQk36FiNX6tWv5T1j316L+tpqX6xeLa+XD9T90efWyB0qB84Hgt/AgfMPQQfuIMvWgTvAsj+X7ThO7Mf1YkdG8YGmlGiRRWooTpX7Rdivjtsay7/3xfHRrFeLbXuasemR7em6MkD+HYCZPHQ0YUKjhOqA6UNaI3IF7pHrQ1ujcynKiNyuFn3gaQkLsP61kbl1H472QQxU9XkxbQVUNCAvzlys5twObbSM4kwLpS1GiW39DiXYI6/t2b5afeqTnwZF2Ss/XcqTslPhzCRdYEbphBh7y/AiCrR2aIcc8lXbg7Rn7S+iKAmR8rT2COW2Kp01ij1jO0XsqBgqnbHSVx8wjinQoVzTmkp0x2Ktn8a11bd9JRQvakv1++Q99Yt7s6++lS+41/raEwr1MK2B88F1kvJXqreIbt+WTtk6cAdYdpjjNiKA7C9maU+jGDhTlqtgdbgKzGcGKwXbGmzfgHsp3kqeMGXHq7PFhrzRLqJJ+/T76utk1akzgPVNeNUHoj5zV6WxXKXvTL0kX9D2Q4kCPSPyNfQ71wrlpH268rqsZK/HadjYPvXUr+T27+na69Sv21lBv7a/qH/1vbLItuo/mBTq2agvFCo1TW+Vc7G03mG+gQPXbh24tcrWgTvA4jwDp+YSZeP8NqubxTZC7yjF2Qjd0FZ4HoTCFP2Z4JHc6ImylIfDrM0UJiHvgaZvx7OQKc0+rJSnPkzmfpjyBAwlKgdus0ABs+5NnDqb9UmUKVD1sOw6OfMzwP24LlT9g7J6wvWEaoulWYAurdJUtmu5jXARcjRt0J6hlQiZQk24WSwfN+Wi9pGJwCj9kvRrXNlrVA6jTwajwkvkgxEtxeiXBzGm8hQRquTqQOjLQodCpSxPWBvmDSlRtU/ZWdeTX4w9zhRl4cyb9ocozpoSTcfnTH/q/ldy5nxP2/NHMBE6Z/psj1cPQ8dqpd85vwP6dWS5LyJ2Ovp6byyyN7jeVceiuVecwfZ6JgrVlfJ07Tg7q9Z+R05dub6I1ucyjW/Kc8EhKRzK075yvUN0jOdC2TpwB1j2dSPfhoCRz9t8qANHmoXK+dukFutGun04fRsVPbiiZJUC1QdMK/reYEuRatYnKhzMw9ELJsR6HGL7QHffOsDMUeIoBOmPzgQc0PtmumpUrf6t70130cOhQ6v10ThqxzgJZNrqYO6X2wlW7dXryMhMFL0UqCvrjyv9pq6/oj2dMFIkBOisY6od1LXlK+g3lbwZkBfXhrIc5twUlKRidQCrc19P4oP1FaOHYiTjgBIiRWkcbOdyfx0ZLMdiMcFcO+2vKx3Y1D5V457yS6MdznqNAXTHgrGXzPScj/p4h/SHHD5bH0C5RU41Nm2p9fX89MmH+guU92Jxvof0KZ+34uWPyrHXeebU8pp+1nNnjt8WOR/UHK6P2bee0LJbrljXWxSd3JZO2TpwB1gaIK6BA4CjY5PJyetRpjW2tCGQI2ZL9eXmqCnYTmZo5XylLFKu5NZBk8m/zhQt5FTJK+9r1Ve2mpZZqo/F+rU9Z37rk9MyuU6YRr/jBCyQu4H+FPJFeJn+QcvPtf6s2d+69F57i9eQ9xW7Lup07dkxuKp+3V5tZ2H9Srau/ir9WXbuVr12q9RfqX+L7J1m/Z72uSHAuUO1xYZn2mwN3GEKM54DZevAHWDZCRwjcER5b0uNsFlK0yY0EMo94FSuFCyQ92FTuVKY+rBWylMjDZrVqXJNKoBg/Zi7Ukc+lG/UvpJrNMBSO0RIPE3tEKaywR2tfUz/riYoKx+69+t1NUr16lu6UtEJV4YbGsBYIq/aQ097VPWHNmhvZCM0MLSQ4tOQO1qNoj0deRF9RBkBkUXcxdAhc+xKYdabHGtUo47uJcebsn0yhpM9Pdc9EaQ6GmtvFhqyV/dP6liK0/bP2u873rr/tb49nzD6i5YHLNK3DuaZ1LdyPT9WsK5+3Z4dy73yBWO/tz23RD5cnwmghsDMIFAaovpoZSKQ68pBhEBAOET7wPlARYxg5XqHKMp4LpStA3eA5ZSuZXPzchsRjZBZB2zukR74SonqQ0X1yegrnQrEJ4DaA3KSgd3I1lIuNaWqiQY6GTGyw6eRslDJEUpsKdAN/bSi2EkIwNKszprWKmgcMg9eGKdhQJ7eymuMBbjqS8cJQYnr+pa262x9YTCZ+pai1czDPqxZqlq/IQBKmVIPRokJecsYPX8jOnN40Ua8OmnaoudKZ7h6HVPTd61N2/piY528or1qEtH2ycjtC47N+tT2dPJK0daqfetQOhjHDHlW1/VRru5/jz1Uv9njt2OFzFinFfRrer1XHz1j05xPoDxeq6+/1Wvy+vT77HW2NelpbyGF2nM96pdD01cmgJRytcNAsThhaWWIdl/kgeJ3TbU7gVDsMhMIIHKFHIjO22HaYqNtHeaWJVq13taBW6tsHbgDLA0QEwQge6ylbEnjUAF5TZyWmiJdRqHWWa199S0FmuRc1a9sWodMHTlbNqVA69L34OzIsVhe01DWqUr2XYVVrpOiq3BlD1Z/waTvlsg79dfUb2jJ1wVW6N9ChxTnuLxnkj0de3Xpc8ixor1lY7W2V+svuxewgv6ye8XeC6k/Q23JuajvnUX6C+1V9dfV7+3fkvpLj2/FcwfE9xqiYnhYXx5E4rRRR85i31Kh9ROzD3vnEBo6VNuIMNNmSQzbLIa1ytaBO8ByJHDcIJdG8oolUTP7WSlCjpbp2LVfNiDkPdP0UaBfR9BSU5yDFKhgu8WHtt9bzkQoDfmhWG8FomXZupEhClQPaBlluZDi5PUoUDrN9gh5g2Q9vYlSlWOsNxttBuRqz9JMxYQlk+OotudKvE6W6qpyuw9ZyhpFjJgUmMyifJTRSB6Q2/rWEeeqPiieG1u/iMCJ3Bl7url2wqKvLzgdilIdALGnX9FQuf04etE/IGUe2rGQ9NW+tVe9VKm+XmvVt9hGM7V9W38RRbmK/dPVr+/tuqxaf1Ce67O5V+IVy2OH5PKovT6KM+jxMYNBObqm9auhwSaaSdp+IUchD6a+45wjFojQHrYkhpaKmMPK9Q7RMZ4LZevAHWA5GThu6eEoOm2jJt7pnrtJBJbSrClW3ZfNUX7S6HdUAXlNMw6f4vQwMxE/lQ9lfZ6pYp9k9Vv8kFyL0klp64OaUqz1XYXNpDokTzQHVZO+yg1tJIuIy0ndUq5Ah4KtcbH1BWWaTx/i2r46aImmWuQUKF4gp+r86XUoMGWaUc9Fos0on+/Coawp2D656U+DfD6IslOpk1zC8huM3EY0E+VoLmhyiGBkLjtI9npr/1hOQG1vsD3tnLnWhb3q/NVZmPZ4UtepdAi1vh27p6Vv2zeljwK1stq+q/Qt1jaKjYN1LA/oF+27xXJrz5zGIcozRb9Enx2VTpWjwpylOJkAJlfIvVx+S4FaSraQG6z+vOprD5Uy1T7Vck8EYk79bZ2L/Woc/KJv0J5jZeM1cJ3Bui2LyqFx4C666CL8zM/8DL71W78VIQT81m/9Fl72spfh5MmTg3Xe//734xu+4RuK39761rfi+77v+w64t7E4hmwX0uaF4Pp00ExOouyw2UxN3ZrD6ttiadOCQuX8m94M+jDWdT/WRmV284MtH6RdOYblhC6t5CiPziF5Ub+mFBdRjCvILUWpDpilrRbWp5721pDXFOnZpjxHVB7f6VKcdanfsnvrrynHOvWxQv/WsKeOxCJ7df8XyXv7U7V1oPo9Tt+QPoDOGkVb6rHdkeu5HbBRnVs2PwMSxTIOUKQw+ylOfV8LRs6VnIk6cl/IUdi38j794KijjyX2UNkLzomdQ+TAtdskhrNRDo0D98u//Mt41KMehec+97kYj8d4xzvegbe97W34zu/8zoX13va2t+FHf/RHEz516tRBdzWVXUASFITSVAfNW8dJnTmDAcC8RXbWtwHi2AWpP9SDM+SdqcMSTNSueEtWjP4Hfz1BrRpR0kOwzhMv0F8lQkUAJq6rnw60D2N1OSFTpBvbM7jXXtWeq/QXUapnRF5hnWRTBEyjj5SjWzbaOnLlPoOdrFQXxzYPyHvrSxpnX/2CwgSKjZNTNDWYiFNPtNW2V9tzPfZ0yUOKIJWXEED/2C4oU1RjmbuOGGHYPjDsbA7p185e3Z8+ffu3LnpoQ/I0tGs7VPwBsgMGAEH+YbvGpr62p45SslH1p5CTRMTEjnXs6r91f4B+SlXtoKc9S6Gm/lDMQk1WiRAA+MYhHJ4PMaANDvMN9hFptxG4tcqhcOCe/OQn41u+5VvwjGc8Ax/5yEcAAC996UvxB3/wB/iBH/gB3HLLLYN1T506hdtuu+1sdbUoe4BQm7LvWtpNm4UyNWuROkkJwTx8GR0KVJ0pqh9Rp1GsKb2PklPG6HyD0TpFSjVpcUD6QHaKOAl2qqtyV2FCGRVYpA+ZNE3fC4oUub3Ud1dlOhr7tEL9jhwZE0kEjfITvnZi+tZpdSjYIXtGbrNMifJWFAmvIE+UqdEvKFOqMPqzWjWUUVCYVt/WB9A0pbyhUs6NcahMG3qt0qJ66VtjsINpX+R1f2sKmM3saK+PHrvd8Z90LMuf9EF4e77sWIa5F8y1tvq2pLHCyPS3qW+9llrfOpjp/Jib2Z4P/VM8QuzYM/+ZB0JcsaXq2XHRY2aiuBxXu22eEyz/SNZUnnDsr/4SpDXtYh2x8lZO4ti5SEMCBE8iFycpyPkakut/JMeptwwKnB+CQc5P7F+Wc5JT4dt65MckS30yL0QedjgQvJzftmkQDlEELoT8zrNWPVqusy25HAoH7pnPfCbuueee5LwBwPve9z6EEPC1X/u1ePe73z1Y9zu/8zvxXd/1Xbj11lvxu7/7u3j961+Pvb29Qf3JZIKdnZ2Ejx8/vnG/4zOV82rUeqsNxRqBs5QqQ5w/Li0WsMKnU06HAgXypA6UTkCSux79RfIF+mnS1L5R/oyYbX9Ivxcb/d4szzUo2dOtX5/rpZRqpX+6lCetoo/15FinftV+HRWqSz2W1qUsl9E2TU//F9mry+m237eGc5n+UKnHXrK3Wv/rxw1TLafe9q2PyD32koMGgJ0r3h+5Ix+mQANRR17YrxzAWl5TsNZ+b3967NXyxZTsMGULxHcuLxTqYUpi8K2D3yAC5w84C/UwLsVaVA6FA3fppZfi9ttvL37z3uPuu+/GpZdeOljvV37lV/D5z38eN998M77qq74Kb3zjG/GkJz0J3/Zt3zZY51WvehVe85rXnJF+HwWQomvpDq0ySDvlTHlkS0pjKFFSbPpp3+KVVrKUaS8NpRg9EaVFuNIfudK+Omd6aoYoUy0jXRhdyZfVV9yhWJfo10kD43Xra8cpywss/9Z5Nu3JNqRvcDE3U+UcUU90ECgoUEIZ/SOYiNMK9TsU6lB9014dQXI63VGuX2epcjD2euSJYq3toxx7ROXYG6JIbRLDkL119dPxLtCv7xWr31ekPlc/JewAuy8ZqNynzOqzsRcqeUhyKtqrHZu6P7WcXbc+Gx2tMESRLqJQl9Vfxb6lOBlI576PAo1yWihnGq6vODpxh2wNXPWxn5XrHbCPehiXYi0qD6oD94Y3vAE/9EM/tFDnyU9+8sb23/72t6d//83f/A1uueUW/Mmf/Ake97jH4cYbbxzs07XXXpvw8ePHcdNNN23Uforz2YdxirefBUfNzusEFF8KVqfN6unE7whxEYfLk6ClpRyE5jK0VYGRM/PUXqJfOeqPKMfLk0Mocmfsqa3G5a0cHCFvlsrGIRTcGIpV6w86UFw5YJQX8Rdyc/4S7rGnDlbHgRzSV6cKFSbjgOisInpK8em5T7SYqQ/q4pRVim772gFLQXbsVfJN6qMaKzo+9Phs35I9Kydzbq286ZdDsDOUrVKSC+1Reb6TPtC5F4Csr9fX2icgU77SxpB+5/yKfvq2Z3RyyHzrM94muT7L7aslZWKaW9pSnMERHKtDQXLbkJzy6FxkOYp9zhiRWhSXPC62h8jtLS7tBUKmWPUUmP6GKtqqFKr2NTtZJHLjBBKgW4PobxrNIjm2oO2JRimXR0pB0WZ5wpQpXU8EkoghS3+cOpFyvH3yjM3xUmkfUMeNEJw7VAv8/XzDCNwBcqiHdSnWovKgOnA/+ZM/iXe+850LdW688UbceuuteOQjH1n83jQNLr74Ytx6660rt/cXf/EXAICrrrpq0IGbzWaYzWYr21xUOi8gaVI5C2UZLVWXpRTmaVCg6tTUtKCVL7LvSKJOA/X72nPVsY+aSr5In3r0q/4eJAXbsee69jrXdgEFu1Rupyhkp6PAS+Tr1K/7X5dlFOOZpjSX2atLPVbXpTTrsbtMfxGFWdlLUaEefXUa+ihM+7emMIH8LAtAL0WpEbjoEGaHRdsLlT6Zf/e1pzh9YayyNyhXB9EeT6e+W9m+rd9vb5gCVWcxGIcNKClULQv1m/gd1MO0ke+8pfhxoXXrHSCFejaXYp2t8qA6cHfeeSfuvPPOpXrXXXcdLrroIjz96U/HRz/6UQDAN33TN8E5l5yyVcrTnvY0AFjoaZ/JcvQgjSvtlN7eBAM9DgJ1HZpaXnx+CBWu5A11F3VbeU3zuEpuKVKVr0qprqvPKGmsvvod++hxWBY4w0qZrqq/bA1a7dyNq/SzZc50n8NgZ6G0Bx31y5Xi1FBGvajdVfX7nNEhOdAzVk17Q/YG5Tq2jby2T3366Jd36ldjpb43VtF3rkOLsRlrZOUS0enTZ2Mv1DRbklNqz+qrPRIdlbOjhfJF9dPxngZluly+xL5cyySXa9GHo4PnBvWTvSWU5qoUKWDO3Rr27A5QSmfHdXCHh0INvGESgxxivfZ8Op2edmDlbC7FOlvlUKyB+/u//3v84R/+Id7+9rfjxS9+McbjMd7ylrfg137t15Izdtlll+GP//iP8a//9b/Ghz70ITzucY/DC17wAvzBH/wB7rrrLnzVV30V3vSmN+EDH/gAPvGJT5yVfk83rZjmIzsxmb9KmaVvNBIiB1FTnGZCKzDyuioGCooUQNp9Xp9qHaz2LcVJhi9RjK49QBymyp6lqZQCZVN/5FA8xS1FS1Su07L2tT91+w5l/2rKt6ZA07UhWZOH/MpsEyiSfu2gIV9Cddj0WumaNpslCj1+yhRscqgA84QvaTwr50XymuLskWv9PgrXng/XI6+dGtNEwoU9M7b77C2Sd+wD5Ua95loCZf0U2DXnU6+V/uwo20NFWToIZZnb61CcBBBTSUGKPC5iB1ySR30n38NUfSf6QeVMifJjIpPZqJSo6ENvU3VclBIt2ycq5ZTak/4OyeVc6hVIFCVn2/EnKuR67RbJ0/mAOFrVZWGY+pTrWwrSYkbeJkTlnuJJJr1WQBFR9nKtrH7MWoUkKORz2y8nEHLEryXAIWfpKtYD8wSQq/pLFLcROURr4EZzwqil5Yp1PTkP9bKl17zmNXjta1/bW+dcXIp1tsqhcOCAGMJ8y1vegj/+4z9O2SP/6T/9pyQfj8d48pOfjKNHY9xrNpvhn/7Tf4qXv/zlOHbsGL74xS/it37rt/BjP/ZjZ63Pac3Cuh/1VaeKrCNQ/e1QiHWUppZvQIEWTskiihMl5VjrE8qoUC+lWU3CdsuS09XvOGQoz1dtr9ZXB9c6dMXxUVUf6Hxr0joFffY7WaYocZ9DWOAl8nXr4wzK63LaFKkr+99nv9a3xV6L1N4C/QHKMZlpyj3D4FyHtrPNsqOOPBgcTH2lLEOlb+uHxhVyoKTxlHrrk8f+lO2pru2vlvRxFHMeakqzK3e9ch6ob9uODuoCypOQKNO+a8NGX53DWh+mXtzWxHWuHXpwopWNw1XL09cdjLy+VoqTPsptU7xzyXE/LMWF+N8m9QDg8ssvx4kTJ9Lv0+lwOORcXIp1tsqhceDuueeehZkin//859NbGAB86Utfwjd8wzechZ4Nl10bCamTFtaiQFFOKoTuGrJ1vgywzAGp64+W6K9rbxkFO27y+QGyM2kpXIuX6XfkVf2l+pW8jjCt2z+3RH+ZvXXrL+tvn9yWjoO1QJ7Gok6dKG0P6i9or+OALbhXFuinHiwamxLxGKxPyJGaXjkl+Sr6LPdKob+MsrRyjUxp+3ItN5e706rPtHn9TfRPp7/rHn+vfh0ZtNdW2zfyzr1gcHL+q3lBtxIZ3Az5HCzNnNC0G9STU3PixInCgVtUHupLsRaVQ+PAHcbi09ov/RID4v+WUaANShosUZyKK3lNSTpUmEo8dpIFKli/VRko/jBqhALlLB8tsDcy9iD6ztgbu1gnID6stL+q3ye3EapeOfr1CRlrlmqiZF3G0rWkT0Z/MOHClZjl2o0oXwtSOSPtcJo2cK7sKQXdG4GC1KcuhZmyFnlYDiNfRHEOUpZSTlcOMuEW055eW4cSD1CeDOTMRUKkrZijLFGa0X6M6Bist5euVUr3DqfF4ST2E6Upx8NOMgfhQMwIlTy4iHXiCUTwDmhk413VV3mmTOOp6tqT0yhZ0N7pLe1Sf6N+xDFax7l/Eq1TWi5SnDFPVOXxNIpcnEt1eRNWSpIo2Qc4Z2n2OC5s6pM+25jz9QJysq3Ic8QvU8hgNpStXm8q9Vk33ZX+CKWsbi9Ju8XaNO0vEZw4WYliVX3EezbqU8yCJcpjQ85V7G+miJ3c7kFkSqF2skrl3PZhpriRL5mIpbcvBMsi2+dQGbeE8QYO3PjMdyWVw7oUa1HZOnAHWKYgiTQhOkNeZzgMUJh9TgO6UYrOJIoclVFc791Vf0WhaZD2H+vTrynLjtyVfEttz37+yJHZu0xwTSEulKOHEkVZfyV7PKxfU5gF5UrZ4Uu4ktcbC9vL20cZ1v2v7S1qr6ZkrUPaKxeHru5f3b6V27KM0lwWsetE4JbQ+T2UJ7Hx6VwZ0eKe+oW8lCbKS2Vc61Meuoy8NUafPADgxkHnKp1o20rf7qjAzsEbfVTtsWlPcaEPvfXEaXJNoZ/l2v/FWZ5MrpMxb9tj15XDyK09dZpyf6iSZ4dE69uhyIjnEwvksL8Riv3Rsn5ec2jHrsp95YBqnztfhpC6WU6pbmGv6p91FosvIQKDOOlXkTa9BofpQ+8uENwGWagHnadxGJdiLSpbB+4Ay25DwKQBwEDLpYPjUDpclroh8xuQHYwheV1fF+Vvak+TDkwYf7G8ru+WyE/X/pL6tUOi/dFiz/2Z0K/ltERe168mjU4EcJn+MnldTtfesuOr5VKSD0NIERG9tqtsJptsSH/sJIke/Tw5I0+khPS5pI6eYsqRG+3PQWwMm/q+Yv14vKvrryrH/7+9846Pour6+G9md1NJgBBKaCGAgIAEUFRURKqI+mAFFBG7gi+KoFKkgyBqECu2R5ogKioiFhRFFAzyUA1KlU5CICSQkJ6d+/4xfbObLdnd2dmc7+dzIWduO3N37s7Ze27RpHGUHdtWG+/4WTiPd53faXq4K891vC/1y9eYQx5X8e6eNWeyt+kdZUEy6gTHH0ohjKWcg7Xch3z+V0WHGadiVQUZcAGEWXhxV3+BF8fYZZef1gUKiAZDJZcnVFl2Uco/ERWXp1SRHC//4uE5vcvTJpUvDwNoV10yADZOdWkyx3im5neszzG94oK0uHDRSvlllyjTxDtzmWrvX/kWZRqXqJzeov/WcxyR0q7ihEN5ztJb5Q7Mqe0JzSXtiBkHdZsP+SQLq0aW6wPTrDKV6tO6nGWZ4/Rz2jioP0uZJj/gJp6psm5nf07/rHGSfnK89n615TGmkxmD4vWHhVNljpP26OV0Lk+5PvHoJckQYZJhovMwS6siIZ1HyUFxWwHicUJ2DsrGsEwjc1JexUXJxHiBE/8WjTO5fCm/5mMEOM3KQkB264kuSzGF6lLklPyqfh7Eg1M3c5Vcsmr9kn5Sfk6qW25mppQPBxemdrNb6RRPKV5QxqPkrw938bJLVr0faPQTOHF+mLY9VLMSqgtUTi+5eLWb8QJQN+6Vni1O83kyQDqrVDWaONnl6aiPNl5jaMsuUvkaL5WnTS/rz7koT1u/3NfU+uX2Z1J66GS5+2n3pJPL57T1u5Mlg7GCV921ZoAXuGotYiA8gwy4AFLCQRyBYxDPFamQjvvh4GTeEq83CrTxyoiZRq40J40XP01Fdoi3OotnqgFls6iyY355Gw+4kJ2lt/EO+rmrT+NylfPr5tQ5uGR5Tp/fZtHn5x3KczTotC5l2YDUGVRS+dr6XMUrRg7U9Byn/px05bKsKt7RxeuoP1dVvBuXKs87KU8jSy9lXXpNtOPEbGWnf0XWjxRoz2EHpHlZklHFIL7ktbI8Z00xoCycYhsLnLpKU9ZB62KU61NckhwUF5vWiOEkI0M+iUB9ATtxsUpGC6fE612WWltYNAAd9NM0jiDpY9fUJ9+7ojvPK4+WHM9096N3QYLjVYOD43SrNmX9eW35nKNLVX+4vMBVdsnq4sE7xDusQuU4jQGISvpISZT0TjfyVQxMedBNNgAd3NlQDXOlrTQuYTle6zKV04v6yQaZ8/q1styW0HQ9ZcUop5eVNBwnGcn68plD+S5lThqB43kI0PerUMZSzsESgiNw4QYZcAEk0soDUdK0zDLOYR4X1G8xDnq3GQe9G0s2gFzJnFRWlfFwU14VLlVv63fqAuXUb0mnLlb1S86ti9SxPN7L9MrfbvSV4R3SO43XyMGO5xzi3bg0xbURGpl3kDlOL8tVQmOQaF44TFO+Y7w2v/y3wHuXHl6WX5V+7tJr41XjzHl+9WUr5neUnabXPqPO6tM+o070rZzeTXnSNWfzttzV5658Z+mVAZQq0muvu/tsPK1bLc/L9C4+W3+U77w+7/PbOU4x4syCrQKw+WDA2Zw9KIRLyIALIBYrD0RbAUGQRnCkIQYrLz6pdkmWR7QEqfvKqz6duSwB/YgXpLSuXJyO6Rkqu0QdZXkVqSsXaqX0kktTW79uRM7R5enMharJb7Oo6eX20r6R5I105fLkVbPysIa8ClXrMpbbX9aX41SXp80C3YiadhWnXJ5W1rowPYq3VJYZc5CleM5ZvFWVOQAWizgipEnPNG4oVZYu8OKKOXlFIHhOM6IjHdGjGWrRjUhxHOwW0QUlX5P3N5RX3tml9JyUXszPlBE0rdus0oiXE1lGWfnnmJ4DOM3Ih+KiZNJoBeRBQk4xKtSVhqqLElJZyqpNzSMpPQHKykM4jLTI+imrRqXXrhovPqDKRrTSNce9vJTRPU5ymUr5lMedl1yWyoiUGKN1yQKatnaRXjGwuMqrTsV7YYo+Wlm7J52zeOamPFlWVn3yckvAIV4uX9RTPntVkNz/2vqZVJ6jzKBxybpJr70/MI2LFwwuXaKc6nJVPj8AzlyuVbmAXeWX3c86l7AUb7ZtRHi7j4sYfMhTkyEDLoAUcwCirKKhUCEA5XbJaOBEt5SyqIGr7DLVGi2uZGVOHScaRdr8jnJV6eV92cAc0ktGg4VX50kBlWWed55ecIwXVINOl59TXaJy+Y5HZ2ldrK7SW7TxGlluX60+2vxy+cqb26F8x/S+xHMai5PnAM6h/bQGqay/bGBKoxRMG6+RmUN5ogtQfiGpBpJs8Nl57bYZgJ0T61e2QpBGKDkmucB4HhWSrJTPmGhTOqRXXHSyDEjzgJhud3po4rUvdSW9xsVpl1xwqqzOW1KMEim9INUvN52uPI5TXJRKPKcaNXBRv+NGrJVcsJqXsj6eU9ujivIFjte5cJnkEpXvh/GVXZayLLostem5Sull80TbHjqXM6B3GWoNEI5z4rLlKhlwev3U8mTjWdCVV3mUTZ7fpWxqK38datpfn95h7zymbmMCzeehlsfpZHnEtHJ6TulyjrJ86oXj513pfl3IctvLeZS2h2oYK5sMa2TlMHsTGXBWHxcxWM1ziyEBGXABxGaxiAYcA1BaoT/T0p0LtUqZ08uO5VXX5epJ+qpcvEp6OE/vWB4HZV6V8/QcdN+q2r9dpeflhE7SywaWIjvEy/eiK6+K9Nq0zu5HaQv5Sxm6lwbjHWTZwNEYYXJupskPqC9kVy5GxUDS6Ce/NFylD6bLkkEaJfKq/Kr1qeQyrqI85/Fu8sN5fsWIcVG+Gu+8fIaqy3eaXvuMuqoPqkHhvjzoyqv07IFzGe80PScZkFzleOflq0aMJ+kFrrI+zu7NmexNW/uS3ln+qp5NV7LAiVuXmGkEjrP7NprG0QicV5ABF0BskbILlakjQAKTXKi8xoUK/QiZlVcn5TOo6V3JNmnVp1yezaF8rYuVMSk9r0/vzIUKTk3PA+rGvA4uTsVFqo3npBE3TqxfWQTA1Dlwsqykl9uD07hYmX6jXY6Jo4XO0jtuxKutj4Mm3qKR4bAKFOqqVimeWdRJ9gCkES+NLOXnqkoPgBOklXHSaKu8BkPe90p5KTmMSNktvOKiBIAKKw9OYKLbiONgt1rACUx1u0htxzMmjkhpVvoxSeak0UjGcYosrU9U8submwoWaZI8UydUcwIDDwZBTg9Nep0xKslMfYSYdHccGCCNaEC6P60LUtx4VnqhM7U8WW/tykNldJBTDQDxI5RbUaxPPpKIY/Ijopo6HKSRHUkf3km8XWklTpe/Un2crD+vjA5yyr2q8VoXq1y/AmPKsyAVqb7ENSNuSg6mz+8YL696VdMz3bPGwcnopqYsaPRTXbhQZAZ1rp0c7yg7pnc8equq9FXl144gMk16rcwAcYGNZkGKPBIn9yU5j6OsW+WqjJ66Tu8yv0ZfBkDenFmZYSI/GxrdwXGwc7z6LJgAnxcxmOcWQwIy4AJIIQMQHSEaSnYmulBlF6Y8D07qsLqtHJRVmtDIvF52XBXquOpTWXWqqU9bvtUibnutTa/9eatL78Tl6Xh0VqU5dzwgnyyhuEAlC0nrogUqyxyn37pCXjWqS6+ZJ8Y5iVdkF/HaeV8WQL9qldfME2OKi5Rp9ePV43aY7NK0yEYRL30Ji7KdExcFyEaTnRfrk2VBcoFyTAADB4GHIkMykOy8lF8yiJhV3aZDkNpfJ0Od9yPOWVN3hxek501rcMn5lT3QGCBuACHF8w75eU6xn5nkUpV9Y7KLVrZMZNl5er1LSm4PXpoP6mzekRyvuJe08bJ+TGOEcPIqzMrlMenz0s6RkuOVsy618XDmElVdmFoZnOr+0hpFjOc1Ll11d3/IdUrGnZxfdkEzpXxxTqK8S4+aHjqDVnBILxsrOplT5yzCsTwprfZrQbfprCY906bX5JH/d8ynbHwr6+QmvXIvUn3KcVUaA9jj/A5ns2oNZ+9drj7k1+irfdbk+9EZ0JwoiatQzWPdWAQOFh9G0yy0jYhXkAEXQKxWCxArrUItKVeNLtlAUob/qytzzjd/lXGXX0nPqX/rXKKOsmP5zuI1Bp6jPs5cqv5Mz3G6e5Mn7itf8g5fwkwqXxnc0MQzqEaN40tCjeeUeMf08pewdqsNx3hUkd95fXBI711+AVXr6yy/rizH9nWI99qlClSKFyyaeM5dfNXlC3C+ClObv+p4wHErCFf36/z+XOunbQPFiHFTnmMeBv0IFKB5VhzuTxvvKr1j3f5K7yy/bNg407+q+3E00DytT2sk+Su/42fpSvb0WXCU7ZKRbaajtKzl8G0OHO8+DaFCBlwAiYqyigac7Da1C+rfERZRZpBcnlXIysa4TIp3I8suSgbxmtP02kUFnDpCpaR3WJQgx8v6WTTxjosMbLw6osUguVAlly1Y5X3MbLwqy/pzkDaHZWBWXv7RLX6R8o4yp5cruUA5cWRGKl92ccr1CQ77oNmlbxHZbamuuhQTyLJuM1JAWTlnt3BOZWXSvoV3kPXpBU194he4VL50S0q8E5lBPwLHwIn3y5ia3sGlqnUjyZPgnbmZ5JV0cjwAxWWrH4GSLWHZpastj1PeUBxjoktSk19wiJf1UeOhvAD1K/WgrFrVuijVY7CkUSxNvKgfXzm/DGPiqk5lRI9p7s1BlnCmny5eGSFT289teVKZjuVVcok6Sa9zoWriFaNCWx4qjxA5GjTaARJP0rvKr8jyswq9ESs/q0p+h5E6Z+md55f0U75e9PXJOjqT5UUL4tmsal5X6auSxbbSlsd5np8TXah2xyXMIYy1jIO1zId85rnFkIAMuABSxBgQGymuQI1gQJm0CpXnpA1+LaoBZLOom9u6imdQDSrFhcpE40h2oUJ6OVnlOXTa/NJXguKC5NVvC2erRmUXprJKU2MgOttIWLaQlPxQ6mcWHpxVLU9+Kcv3wyzqPCZtPJPSCxZOnUPGq/OwZJlJbjUBooHGLKrbS978VZU19UvxelmdFwZOjAfHgxcETX4HlybPS24/ycDTvKSdyaIbC2r9nOxyVU8iEBzTS28/eV6YGM9J+utlQHVriS5MHoLWZSq3L6fWx2SDUUrvOKeNk8q3a2R5dIfjoSlP3nZEE68xJAROvypULE816AVecvExjYtUY2jI5UPKr25tIcVLc/Y4Jb94XW5h+VmQ56TJc/Tkl7zsolVcnMqgieoG45m6dYcqQ7lfR5cl5xAvt4fcheTyoUkv/62b7yddU4xtQPdsOUsv61fJ5apND/0ok9YAU1yu0t+CJh4O6R1l5/nV6QVyWrtDXll2di5oVemd5Vc3CdEbSYDq4nQly4fJcx6mdybrjTN1NF6bXnAlc+InI3B8pbYIZXgfFzHQNiLeQQZcAOGsPBAbIQpFZQ4uVItuKN2ty9Rxo11v4oHKLlWLQ7xuTpuTeK/yc+peaoDiwpRhgM4FyhzKZ3J+Tv3FK7sPmCI7bO3Ac5p5JFDmHWnjtV+szvK7lDUvOWjK4DT16Vym8N5FqS3Pe5eqQ3q4S++oT9X3J7gtr3J+uzZeuidP9IE2j6Z8rYlQOR66Z9HRgJC3snCVX57XpI2XXbTOylPyaMpxOjdMcx0O6Z21hfZ+3bkUtXO6mOb+PEuvmS5QhT7aZ8l3lyWnc0F7n9/1s+dJfu2iFt/19y2/LDsadc6e9apkO8y3kS9f4dsiBp6OYvAKMuACSHRMhGjACUydxC//LY+IKS5Vq+QylWSbgxxhFUfyoI23iz1cHlHTrXLVjMBZeTFeLs8iyYIgfrs4ukSlo6iYPOJmtYCzSJP4pfycNp7nwMmT+hkAiyxDvCatGhWUETV5kYCYXp6DBkGzGSfPQR7xEzRHV3FMiuecx+tlAGCVvvjU1Vzi16rsolS+9B1WgbrefJRJ5bkqH4qxqUUdMVInYuvTcy7Sq8aOrI+g0UfUl4M8mOUsvWIgSvUro0SA6qbi4KY8zYIWTXlyJsVNKV9QPwolnkkuXd1KPe09a+6d8WLf4SRjQJ40r+jjxOWruHjl9hcE1W0lP0va9tCMkIHnwQQBvDzapI3XtqNjfrldHdI5S6+9T8f7rl76ysaoq/TafI7t7o3BKcuywVSd/N5sU1KV7JgfmnTMQ1l7XXHFepHfaXmc2vpVPSva/8VtRHgInHkMOIsdvi1ioBE4ryADLoAU2ZlqwEUIQFmFasBF8NLbVyMzS2UXqyxHalysHCcaXbKbU1nFCVXWulw5DszGiyOCksHFrDw4TfnMJm0mKjBx8ai0dQWTXLSCVVq5JTDVhSmVL7swOektLcerBg4Hu8UCi2xg8eLu/hZJX4EXXZa8ZCAKFh52XnIxyvFyeUw0yASOhwWibOdFF4OFia8AR1n+9Wph6qpKJrnpZFldqSjJPKdzuQocp5wAKY8qOLpkeRfl2yEaBcocOg7goK4clN00vKCXne5mr8RryxONJNEgVFdRygaaHaIRoneZQlm1aod8dqV4wc45pIe0SlLrEgWvvILUw+TF+u0cwPHqSkxlM1M5P8R4QRMvlw+usv4VHAfOYtGXp9FPLk+7u778rEDWV2NECxwnnlQgG9DyZ6dxO3I8Dztko0ItX/58ec39KEaekl4c4VLT8+DBNOnlERgpHpy4RseD9PJoqPJ5OMrKsyoqI8ZLbjxF9iC/1gDm9H0Bms9LduPKAyfyaJvaVwCtGSPLzEF2/HGkyJq/tbLeyFJdsq7yy7Jd1t2JrG6kwyl/6evnYAfT5HcmQ3NSrF4W+6b2btV45kqW2tcubT5tFnyeA2ceGzUkIAMukFh4sNhI8UWpXYUKqBP3tTKqkh3Glh1XJGnjOehcnAzQuyydxut/tTOLOi9G4ABmUcsXAN0B1KKsn9chWDTxHCBYLOq8FCm9o6wvz035HI8KWVcp3pms3B+gvJChKV+bXudm4nm97MSNJDjk5xzya2Wnu7dryq7SRQnAq1Wx8NzlK8cL0NdXVbzgRF93+R3vp0qXq2zAOsnvrDx54YP2xe7sRc9B/sxUI5Y5lOlYlyv3sfv0nFfpXaVzlV45qUBzvar8TBc4j13AjvkBtf2qSu+Jy1Vn8FaRnrmQ3T1rrvLbXchiWt5tea7ye1Z+5e+CqvLLK6jluXxmgQy44EAGXACJqhUJxEaI7hVHF6XNqpEdXJ4amckuS6tFdWHyHDgrr3dpuoiX88NqgSDLvOgyZdKigwqLuuqUSSNqskuVk0bE1H3SpM0/q5ArrBbNKlQGO+8kv87FqcocJJenJl73hSrrJ8XLxpMqM8UAqJxes4pS62aTy2fyFyx0xq1SnvRtrsy50uQH9AaSeEFvFKt/c0p8Vel1BlwV8brJzRq9K+WXrRwvypfvT5GltlCOrpKvadyxlVyOnGafMPm+mdqkleI1m9+6L4+T0qtT493W70X5AielF1glfb3Tz316zpV+Lv7XfKqVPueq8rnK77I8jYFZVXrn+dW+CE06RwPJk7J1aV30LU91c1W+4z27a0O3//vYV7SyAECAuTby5QUfFzHQPnBeQQZcALloF2CvFQWLwMAirOA0LlRmE3fPl1eRMpvkInLm0rTwEKxiPBPE9HartCqRMdgtHASbBbwAcIJoENmtHKzSNh6ChUeFlYdFkOaQSS5MXoCy1UCF1aJxi4i7/1uYVD7HocLKwyqo8VqZSfFy+XZezC+61eR9jGS3FpysCoXqQoX0K9TCS5s6MsWFadW6PJWVitIqTV35YrxFU5+dl12qUn2y2wic6gbSuInsHKd3uaq2TyW3kbhoQd22Q544Lf+YlF2YiosVajyD5GLlVFeOvMpTXsloBwBtek5d9Sin17pc7RoXn7Y8Ga0L0m08p3HBSvWL8bzk6pFdmGr72AFYpHuS78/CqduIyC5XOYMdnOgOl9JXcKKLU2ug8pqXml7mpPQWD9NL7aMxALQuQ2eyHdKcTkg/EKBdRcoggAev3J+jLLnpZGMd8ouZ16TX3C8ntq9jevmzFyTjTHX7iW2gdVmKLkzo9HUmy581gzoAz5j8bFYuD07yO5Yvv3/l8hz1VeJdyPI7n3OMlz4veXRKG6+VHeMrpLIdZbmWSvnFXykuy/NJ1o6eAzpviPhsqD/qKsvS/ybbRsRSBp9G4Cy0iMEryIALIBUch5KYSMQwBq64XJxXBqkT2yy6X2rMKj65iizvHQbJZWi1KF8M4t5fvC6/3WZRvjzkvcHsDvkrHOIdy+OqyF9h0eeXXZTKS1KaMwRNfl4n83qZc3iJ8Hq3gtgG2nhet9Re64ZwdLkyQJkbJcfL17X16V2kvNP0SnB0kXKcTh+lXZzoo31JaPM7k12ld9w93lOXp/a+Pa1PHilwlV8+u9RZvCzrng2O0+mrrVOWdc8Wx6GCqzq9vs3VeXPu0sv3Lzi0vzv95L4m1weHeLsbWffscZWfdXgoqy5XTleus3o8kT114XpSnrZtPXHJVvW/q77m7FlzJ1ft0nS+zYjj5+MPWfksnf1g0tRd6VmVnm9mokUMvJ2jbUSCABlwAcQaG4WimEjwAkOktFJOdOmJ+5QxQJEhbziqcVnKsnJUkyaeuYyHss8XkyZy26WNeJWVe7w+Xi87iecc41FFeo3bSetidHALuXIriekd8oNzKM91fuVlp0nvuE2EjO6l4fgSc5Gek+9Hk97xy9+xPKcv62rFSy9vB9etTnf5c4O+bR1lBunzc+LWcZUe0ipUT8pX7kXzVnOVnjmmd1Ge0/RwnV7r7q6cX362VJPX3f1U9ax5m59VI7/f9AH07aeRnT97rp/96sqSgn4t39e+4W9ZV78Xz5oAwA5e2UDcDFh9HIGz0gicV5ABF0CK7AIKY6JgsQsoi7AiorxCcXGW2aySy1F0EZZbLarMcyizWmBl6kq0cmkVpxxfIbsoZVlyEXJMnHNWYeE15fEot2jiOTG9VZ6bwXEoV2TJpcrxsEIyyHgOFbzkkpXS2zX1CZryIOvjsArUrqwa1bo0xVeBHeJZnzbZJSrFK+VJ+a0QtyFRXKSAEi+7WGWXr8BVjnd0G1k0cqV43QiV1mWqHuCunJwgJeS16Tmoq1qhxiurSBlz6RaS3Sby93UFRN1kt1YFOF16ZQTNSXlMjufUifV2Dsrh8rIMTpueA8cxxY0nu3VUly/Aa0YDBAC86PdR8vO8Wp5dlmWXrUbWxUNzv5xqJtirkAVFllcOyi5bQFkVC1QpVwCwSPcjb5DMaxahiOm5KmX5sxTzQ+MS5WBnUF3IzmRtfkknZzJTruj3iRPj1R83ArQuYiZ9ns5l+dnUG2p6F6pe1syHVOK9GYHipH/1I4hKek4v++rClEtx5iKV3ddKeo4LuCwjjm6r9VdAfVacy+KPxQpw0K53DXWs5T4uYiCLxCuouQJImcChOCoCPAMiS8sUN5wAoMLBpWnneVQwaOJ5nRtKO6dMUGSmk+3a/BbewWXK61yids7BxaqJZ07jHWSOd3CTAQLTpxd06VXZDoA56CNo6pO/9B3za+MFB5cqoL4MtPX5Fi/OY9O7fCvXp84rqmwAyvHO0guAsspXjtcaXAwA45y7TJ2n5xQDzFm8vImqY7zW7cXpromF6VzMqCxzjjKn5nd0UcrxrtM7Kc8DWdB8XnI8oHfhelKe9lmU3fW+6qPd+oNJDa/Vp5Ksqd8T2dnIq6u+I8v6OXMOMlfZhejOZQoXsvY5dZTVtuIr1VeV7I3B6KwvCZzz6QzuZMe+4YkMzTVHWVCueefulzfydWzrUIZOYggOZMAFEFutKBRFRioLB4qjIpSOXMllp0ySll4AsotUidfPedPl5xzL4xRZfmHoZOhlrUvQMR4aWV7FWSme4xS3jXLNhRvHMd5Zek4uv5Kby1V81fkdXbLelA9n5cujH3J+TvwKdxbvMj3nkF5zL1pZTK/u0uZZes6r9MyD9O7cQp64SDUXAF1+uW25SvGeys6eVW9ld8++r3Jll6/vLlPHZ9PbZzmQsrd9wWPZxbPrKHv77PtL9saFypT8nNP0rp5tAZwyMm8GfHahkkXiFaZprkmTJuHmm29G586dUVZWhrp163qUb8aMGXj00UdRp04dbN68GSNHjsShQ4cCrK1IcQXDxagoWAQBZVYLIirs4CUXX5nVAqvAlDMNyyWXJ8/EjWjLJJepEs/zsDKoLlcLD6vkImW86GK1CoLqIlVkcXSowsLDKghQXJLyqkxHFyigulAdXKA2QVBkbbzskrXp8ssuUSbtIs7pyqvgeNiYAEj62TlxJSKnyJBcopp4BnBSfQycfqNeSCsZAWXzS3nVqvwLVloXohjQyipYAIzjFTeU6sKU48XhHV6bH/JqMTE9g0M85+BClWQm6QfH9LwmvXRdTS8acLoRPU6/co9zkOX7k116HK91gXKSS1RtH46DulGulJ5zyM8p5Vd2acrpwYkuQt6FzHSyeB92JrpQociARW5cN7LWBakt3+JQn1cy1JWLTGpv1aUpy+JGxo4uWQHiyK47WXaTyaMyzmS5PgYoGwkLkrEst6czWaufXdJSKwN69z009Wnrlw0HOb9WH0f9KunrzJDyVea0K6ClZxWqvlqXpXruLZR4cPrRcY7jlWdXL3MQwKol2zVt7SgrGwNzsnZifNXli/rbwUMwkQuV83EEjqMROK8wjQEXERGBzz//HOnp6Xj44Yc9yvP888/jqaeewogRI3DkyBHMmjUL69atQ/v27VFaWhpgjYEyO0ORLQJ8NENkeTkYXyEaaFBXdfJQXZqcJNshuVS18TyPCsZcygLPw26xKC8BO8fDblFdrPJpBLp4MJ0sVJKhvlQ4TllZ6ZjejsouU3VXc9nFpXfBAkAZeL1+uvyq68Eul+EQ77iSznEVqfo/V+VKtsouT063bYiz9JxOVl14ztJrZSa3jZfpAfX+qkqvleWXmXgYfNUuUUA1SOV5SDyntq1kw+rycw5/c5r8gkZWXqqc+lkzh/SOst1DWXSh8mJ7+pDfqYzKbizHZ9vRZemtrC0PbmR1wr3r9pJlfX75mVf/Z7r/4fZ/8X7V6QPQXK9K9hX5WXImq8+194aM1i6Q28CZLM/Ok/cU9EUWqpTVPGrfFut3Jdul7y8T7SLi+xw4m/91CWdMY8BNnz4dADBixAiP84wZMwazZ8/GmjVrAAD3338/srOzcdttt+HTTz8NhJo6+JgoFNoixc7KcSiNEDf1VVxW8nC6U5mrMl4541Ia5ZBhisxViq86vWRYOEmvnCGppOfdxLvOr5Nl14eTX9/aeKduEbkuB1lML46feOqmcerSrLJ8z9O7zO+Ffk7vz8f6PdFHGfHwRJaNCxeycs4rx3mUXvtsOj6rzmR5CwyGys92oGWvnnVvZc1n5Y0cEBdmkGTdsy1NqDVCH6aRveoLjrKrvgDv+oIyz9NEFpzPLlQy4LzCNAact6SkpCApKQnr169XruXn5+PPP/9E9+7dg2LAldk5XLRGwsIElPEW2AQ7LExcOVfGW2BlgjSCxmlkcdxKkSW3SDmnrhK1y7I0ziVAlG1SfgEcyjgeNs0IWDnHIQIMosuURwU4WMEUl24FeNigujTleA6SCxMcrEzQy9KrR4C8Gav4u7FyvPgrVJbtigxA0lfezFUunzGNC5MTv7zkzVHFVZwceE5wIfOAlJ9pypNdqGJ6cSWgVuZ5VV+tbOfEnfgt0g9/1W3lPL24WJfTyxyn6GOXhosUl600HGfxVJZ+86suXrE+ThPPQXSrMaV+8f5dy1p9xBeZLFcw0UWm6i+5/DTpRRma9NpVtJJLUkpgD4DMQTKqAXVEUJo3Kh8nzGnut7qyRfwIlNE0HmIbKi5IJ7K8fxuDNI2fU0dBLeJHqMpS2zmTAefufK2suiA58d8gyco3muJyleMhybJ+Wll9lmRjnOPl8pkUH5qyII2neSLLzwoHQP4R7D6/2D4VEKeJmAVaxBAcwtaAa9SoEQAgOztbdz07O1uJc0ZERAQiIyMVOS4uzmcdivKLUWiJBA+GSHsFBKFC2Y2/Qlp1KhtsFZzsMpVekhwPO2NqPC/KssFWwXGKC1Q0UuTjhMQvQDvHKS5O8YuDQ6n6dSpu3QHo4gXwSrzAVXYbCRqXpyg7ukiZi3gn6SUZUL+kmFbm1K0LBHCVNgYGB8hbA7uWoeSX3XraeL2sra9y/czi4J7iqpA5td1kGdBu2yHPcHGdvkpZ+Vw4nax124BT3UbyD3fBrSy9pDjxKdDKdo0sukDVrSC07m+5PLu2fLjeTNVXWeuyczw8XX5O5Qxy+yvp3cjaZ0WyxSvJju5sR/d8VTIDX8ml563M3MjatoLySQVeFvu6xU16R/3UFJXjuZCXmYcyU4L6wDGH+3aU5dE3xnG4eOYCzIK1DLD6MEuJRuC8w1ADbu7cuZgwYUKVadq1a4f9+/cHSSNg4sSJiru2uuQdyUYhLxqDjCtFGWyajgrAoXNzcOjIXFXxrvO7TO+ivKr+17+I3OfXzYXxob6q9Oc8vF9tPriRtfeldWFAk8afsqoH5zK9O529kT1+Nrxs21D9P9zupzr/y6N3YnPo20O57AcZmmvBlv11D6H8rIpTW4CTfx6AWaCTGIKDoQZcWloaFi9eXGWaw4cP+1T26dOnAQANGzZU/pblXbt2ucw3d+5czJ8/X5Hj4uJw6tQpn3Q4dzATR3YcQ+suTVFuscDG7LBAcnFKLkvZ5VnuRLZyTDlfsxycIgsch3ImrqqU5Qqmj3cpQ/xi18p2iG46ZzKnSS+upJN+FTL1fEtxfgb0MqCsClU3wq2uDDDIK+s0LlFwAHNwMbqTwcEimZuKSxJqPAdUS4YH96OmF5dg6kYMHdJDk14esfRUll2MVcmO+cVtf/0viy+kqmXRJemrLI/0yhPFRVneCUxNr74gqyvLL9uq5Cr3YauGLI+5u5NVw8cXWTYxxPK4asqA+izLI1T+lLX6ygZSKMvaRQ0AU9qMadKXlVXgn1WbYRZ8PgvVhzw1GUMNuJycHOTk5ASk7CNHjiArKwt9+vTB7t27AYjG2FVXXYWFCxe6zFdWVoayMv89RT+M/RAj1s9GJC+ekCC7SAWIq0C1sgB5how6T4zjnMmyC1WNF2SXKYeqZcgyD0H5encuM8kUcHTJyivjqpThHxlQv+RUWeOC5VSXp84l606GOqfEM4MIihHgqcwcymcO5asyB3m1mny/jvllwziQsmN9nAtZ1s9zWS7dc9lehSwwSKt4XcnyVhPSs8x4zQRygDG929StDP3IsjOZcyMz6HEcaKhKdsxfWebcyly1ZOiuCNB/1sxLWSzDfzLnRGamkyHJXCWZAdgwdTlKLhTCLFjLALsvixgCbMCZcTuyqjDNHLhmzZohISEBzZs3h8ViQWpqKgDg0KFDKCwUH+y9e/di4sSJWL16NQBgwYIFmDx5Mg4ePKhsI5KZmanEB4Njv+3BxwOn49Z3n0RCqyTlumAXwMuz4g2TbV7KfqxfEMDzqswEAZxfZaZMhPZJZurEbEfZ7yvgvNbVv23l+FlUkv3y2Vv8JwtOnqVAykHum/7vCybuG46r3CVdHGXf7z0U+oZruTjvIn6dvgJb3lgDM8ELPi5i8Nd+NC4w43ZkVWEaA27mzJl44IEHFFl2g95www3YuHEjAHG+XO3atZU0L7/8MmJjY/H++++jTp062LRpEwYMGBD0Rj+8fhfeuOQxNL+uPeq0aIiic/k4/PNuNL2qLeokN0BRjig3694OtZvXR+GZ8ziyIQPNr70U8U0TcTH7PI7+moHm17VHfJN6uHg6D0c3ZiC5RwfENa6HgqxcHPttD1r0vAy1GtVFQeY5HPv9H7S44TLUalgH+SdzcHzzXqT0ugyxDergwomzOPnHPrTo3Qmx9WvjwvGzOLllH1J6pyImMR7nj2bj1NYDSOmTiph68cg7ko3M/x1Ay76dEVW3FvIOn0bWjn9FuU4s8v7NwuldR9Cybyoia8ci92AmsjOOomXfzoiMj8G5A6dw9u/jaNm3MyLiopGz7yRy9p0U5VpRyNl7AucOnELLvp1hi43C2b+PI/ffLLTskwpbTCTO7DmG80fPIKVPKmzREcjOOIYLx8+gZZ/OsEbZcHr3ERScOoeUPqmwRtqQtfMwLp7OQ0rvTrBG2pC5/RCKcvKR0qsTLBFWZG47hOLcArS44TLwNisy/3cApflFSO55GXirBae2HkDZxWK06HkZOAuPk1v2oaK4DMnXdwTHczi5ZR/sZRVo3qMDOI7DiT/2QrALaH5de3Ach+Ob/wEANL+2PRhjOL7pH/AWHs2uuVSUf/8blggrml7dDkxgOPbbHthiItHkqrYQKuw49tseRNSKRpMr20CosOPorxmIqhOLxldcAqG8Akd/zUB0QhwaX9Ea9rIKHPnlL8Q2qI2krq1QUVqOI7/8hbikBDTqnIKKknIc+WU34prUQ6NUUT788y7Ubt4ADS9LRnlxGY78vBt1UhqiQYfmKC8qxeGfdyOhVRLqd2iO8sIS/PvTLiS2bYLES5uh7GIJDv+0E/XbN0e9tk1QVlCMf3/aiQYdk1GvTROU5hfh8E+70DA1BQmtk1B6oRCH1+9Go84pqNsqCSXnC3F4/S40vrw16rZshOLcAlHu1gZ1UzzoG2cv4Mgvf6HZNe1Qu5mmr8h9Q+oryT3a6/pG8vUdEZeUoPaNnh1Rq1Fd5J86h+Ob/qm6b6TvQ0qfVETXi8OF42dx6s/9TvtGdEIc8g6fRub2Q677xqEsZO8+gpb91L5xZs8xtOrXBRFx0Ti3/xTO/nMcLft1UfpGzv5TaNVP0zcOZYp9JSYSZ/4+jrzDp0W5qr7RO1WUdx1BQVau0jeydvyLwjMXkNJb6hvbD6H4nKZvbDuIkvOFoqzpG8nXdxTlP/ejvKjUdd9I3wehwq7vGwxodu2lAOC0b/A2K5p1l/rG73/DGmUT+4pdwNGNGbq+cWxjBiLjY9C4m9RXNvyl7xsb/kJMYjwaX67pKw3rIKlLS7WvNE6oum+0aIAGHZP1faN9M1FevwsJlzRG/fbNxb6xfhcS2zVFYrumKCsoxuH1u1C/Q3O1b6zfhYaXtUDCJY2VvuLYN5K6tkLdlo1QkncRh9fvQkVpeVDfV/7AWgrYfVnEEOF/XbSYcTuyqtCO1hJOiIuLQ35+PuLj41FQUGC0OgRBEAThMcF8h8l1zU4ESn2oKjIOmJyDgOs6YsQILFiwwK0LNSUlBYcPH0bnzp2VqVgA8Ouvv2LXrl0YM2ZMwHT0BNOMwBlNdbYTIQiCIAgjMOLdFRPl24KEyCjxf0edS0tL/To33VN83Y4sWJAB5wb5QfJ1JSpBEARBGE1cXFzAR+DKysqQlZWFsSeT3Cd2QUFBQaX37fTp0zFjxgyn6UNxO7JgQQacGzIzM9GkSRO/PfjytiT+LLMmQO3mO9R2vkNt5zvUdr7j77aLi4tDZmamHzSrmtLSUqSkpCAiwr+T2aqatx6K25EFCzLgPCAQD35BQQF9qfkAtZvvUNv5DrWd71Db+Y6/2i6Y7V9aWhrUhYKhuB1ZsODdJyEIgiAIgjA3zZo1Q2pqqm47stTUVMTGxipp9u7di9tuu02R5e3Ibr31VnTs2BFLly4N+nZkrqAROIIgCIIgwh4zb0fmCkYheCEiIoJNmzaNRUREGK6LmQK1G7UdtZ25ArUdtR2FwAbaB44gCIIgCMJk0Bw4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJkkAFHEARBEARhMsiACwCjRo3CkSNHUFxcjC1btqBbt25Vpr/rrruwd+9eFBcX46+//sJNN90UJE1DC2/a7ZFHHsFvv/2G3Nxc5Obm4qeffnLbzuGMt8+czJAhQ8AYw1dffRVgDUMXb9uudu3aeOutt5CZmYmSkhLs37+f+qyHbff0009j3759KCoqwvHjxzF//nxERkYGSdvQoEePHlizZg1OnToFxhgGDRrkNk/Pnj2xfft2lJSU4ODBgxgxYkQQNCXMgOFLYcMpDB48mJWUlLAHHniAXXrppey9995jubm5rH79+k7Td+/enZWXl7Nnn32WtWvXjs2cOZOVlpayDh06GH4vodxuH3/8MRs5ciRLTU1lbdu2ZR999BHLy8tjjRs3NvxeQr3t5JCcnMxOnDjBNm7cyL766ivD78MMbWez2djWrVvZ2rVr2TXXXMOSk5PZ9ddfzzp16mT4vYR6291zzz2suLiY3XPPPSw5OZn169ePnTp1iqWlpRl+L8EMAwYMYLNmzWK33XYbY4yxQYMGVZm+RYsW7OLFi+zVV19l7dq1Y08++SQrLy9n/fv3N/xeKBgeDFcgrMKWLVvYm2++qcgcx7GTJ0+y8ePHO02/cuVK9s033+iupaens4ULFxp+L6Hcbo6B53l24cIFNnz4cMPvxQxtx/M827RpE3vooYfYokWLaqwB523bPf744+zQoUPMarUarrvRwdu2e/PNN9n69et111599VX2+++/G34vRgVPDLiXXnqJZWRk6K598skn7PvvvzdcfwrGBnKh+hGbzYbLL78c69evV64xxrB+/Xp0797daZ7u3bvr0gPAunXrXKYPR3xpN0diYmJgs9mQm5sbKDVDEl/bburUqThz5gw++uijYKgZkvjSdv/5z3+Qnp6Ot99+G6dPn0ZGRgYmTpwInq9ZX6W+tN0ff/yByy+/XHGzpqSkYODAgfjuu++CorNZoXcE4Qo6SsuPJCYmwmq1Ijs7W3c9Ozsb7dq1c5qnUaNGTtM3atQoYHqGGr60myPz5s1DZmZmpS+6cMeXtrv22mvx8MMPo3PnzkHQMHTxpe1atmyJ3r17Y/ny5Rg4cCBat26Nd955BzabDTNnzgyG2iGBL233ySefIDExEZs2bQLHcbDZbFi4cCHmzp0bDJVNi6t3RO3atREVFYWSkhKDNCOMpmb9bCTCkvHjx2Po0KG4/fbbQ+Z8ulClVq1aWLZsGR599FGcO3fOaHVMB8/zOHPmDB577DHs2LEDn332GV588UU88cQTRqsW8vTs2ROTJk3CqFGj0LVrV9x+++24+eabMXnyZKNVIwhTQiNwfiQnJwcVFRVo2LCh7nrDhg1x+vRpp3lOnz7tVfpwxJd2kxk3bhwmTJiAvn37IiMjI5BqhiTetl2rVq2QkpKCb775Rrkmu//Ky8vRtm1bHD58OLBKhwi+PHdZWVkoLy+HIAjKtb179yIpKQk2mw3l5eUB1TlU8KXtZs2ahWXLluG///0vAGDPnj3KIeEvvvgiGGMB19uMuHpHXLhwgUbfajg0AudHysvLsX37dvTp00e5xnEc+vTpg/T0dKd50tPTdekBoF+/fi7ThyO+tBsAPPfcc5gyZQoGDBiA7du3B0PVkMPbttu3bx86duyIzp07K2HNmjXYsGEDOnfujBMnTgRTfUPx5bnbvHkzWrduDY7jlGtt2rRBZmZmjTHeAN/aLiYmRmf4AoDdblfyEs6hdwRRFYavpAinMHjwYFZcXMzuv/9+1q5dO/buu++y3Nxc1qBBAwaALVmyhM2ZM0dJ3717d1ZWVsbGjh3L2rZty6ZNm1ZjtxHxpt2ef/55VlJSwu644w7WsGFDJcTGxhp+L6Hedo6hJq9C9bbtmjZtyi5cuMDeeOMNdskll7CBAwey06dPs0mTJhl+L6HedtOmTWMXLlxgQ4YMYS1atGB9+/ZlBw8eZCtXrjT8XoIZYmNjWWpqKktNTWWMMTZmzBiWmprKmjVrxgCwOXPmsCVLlijp5W1E5s2bx9q2bctGjhxJ24hQkIPhCoRdePLJJ9nRo0dZSUkJ27JlC7vyyiuVuA0bNrBFixbp0t91111s3759rKSkhGVkZLCbbrrJ8HsI9XY7cuQIc8a0adMMv49QbzvHUJMNOF/a7uqrr2bp6emsuLiYHTp0iE2cOJHxPG/4fYR621ksFjZ16lR28OBBVlRUxI4dO8beeustVrt2bcPvI5ihZ8+eTr+75LZatGgR27BhQ6U8O3bsYCUlJezQoUNsxIgRht8HBeMDJ/1BEARBEARBmASaA0cQBEEQBGEyyIAjCIIgCIIwGWTAEQRBEARBmAwy4AiCIAiCIEwGGXAEQRAEQRAmgww4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJkkAFHEIRhbNiwAa+99prRahAEQZgOMuAIgiAIgiBMBh2lRRCEISxatAgPPPCA7lqLFi1w7NgxYxQiCIIwEWTAEQRhCPHx8fj++++xZ88eTJ06FQBw9uxZCIJgsGYEQRChj9VoBQiCqJnk5+ejrKwMRUVFyM7ONlodgiAIU0Fz4AiCIAiCIEwGGXAEQRAEQRAmgww4giAMo6ysDBaLxWg1CIIgTAcZcARBGMbRo0dx1VVXITk5GfXq1QPHcUarRBAEYQrIgCMIwjBeffVV2O12/PPPP8jJyUHz5s2NVokgCMIU0DYiBEEQBEEQJoNG4AiCIAiCIEwGGXAEQRAEQRAmgww4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJkkAFHEARBEARhMsiAIwiCIAiCMBlkwBEEQRAEQZgMMuAIgiAIgiBMBhlwBEEQBEEQJoMMOIIgCIIgCJNBBhxBEARBEITJIAOOIAiCIAjCZJABRxAEQRAEYTLIgCMIgiAIgjAZZMARBEEQBEGYDDLgCIIgCIIgTAYZcARBEARBECaDDDiT0r17d0ybNg21a9f2W5m33nortm/fjuLiYhw7dgzTp0+HxWJxm69t27aYN28edu7cifz8fGRmZmLt2rW4/PLLK6WdNm0aGGOVQnFxsd/ugyC8JZT6U3JystM+whjDkCFD/KYfQXhDKPURV+8ROVxzzTVK2kWLFjlNs3fvXr/dh1FYjVaA8I1rrrkG06dPx+LFi3HhwoVqlzdgwACsXr0av/76K0aPHo3LLrsMkydPRoMGDTBq1Kgq8z7yyCN4+OGH8cUXX+Cdd95B7dq18fjjj2PLli0YMGAAfv7550p5nnjiCVy8eFGR7XZ7te+BIHwllPqTzIoVK/Ddd9/prqWnp1dbN4LwhVDqI19++SUOHTpU6fqcOXNQq1Yt/O9//9NdLykpwSOPPKK75o97CAUYBfOFcePGMcYYS05O9kt5e/bsYTt37mQWi0W5NmvWLGa321nbtm2rzNu1a1cWGxuru5aQkMCys7PZ77//rrs+bdo0xhhj9erVM7wNKVCQQyj1p+TkZMYYY+PGjTO8XShQkEMo9RFnoWnTpsxut7P33ntPd33RokWsoKDA8PYLUDBcAQpeBtkIcsTXjnXppZcyxhgbOXKk7npSUhJjjLEXXnjBp3JXrVrFcnJynOqemJjI4uLiDG9LChRCrT9pDbiYmBhms9kMbyMKNTuEWh9xFp577jnGGGPXX3+97rpswPE8H3bvHHKhmpAvv/wSbdq0wb333osxY8YgJycHAHD27FnEx8fDZrO5LaOkpASFhYUAgC5dugAAtm3bpkuTlZWFEydOKPHe0qhRI0U3Rw4fPoy4uDhcvHgRq1evxrhx43DmzBmf6iGI6hCq/WnatGl49dVXIQgCtm/fjhdeeAE//fSTN7dGEH4hVPuIlmHDhuH48eP47bffKsXFxMQgPz8fsbGxyM3NxSeffILx48cr+pgZw61ICt4HV8PZGzZscPpLyZFFixZVKqtp06aV6vnzzz/ZH3/84bV+1113HbPb7WzGjBm660899RR744032D333MPuuOMO9tprr7GysjK2f//+sPt1RME8IZT6U7NmzdgPP/zAHn/8cXbLLbewp556ih09epRVVFSwgQMHGt5WFGpmCKU+4hjat2/PGGPspZdeqhQ3Z84cNnfuXHb33XezIUOGsEWLFjHGGPv999917lszBhqBCzPGjRuHunXruk2XmZmp/B0dHQ0AKC0trZSupKQE8fHxXulQv359rFixAkeOHMHLL7+si3vjjTd08pdffomtW7dixYoVGDVqFObNm+dVXQQRSIzoTydOnMCAAQN015YtW4Z//vkHaWlplRY2EISRhMI7Z9iwYQCA5cuXV4qbNGmSTv70009x4MABzJkzB3fddRc+/fRTr+oKJciACzN27NjhdR55C4/IyMhKcVFRUV5t8RETE4O1a9ciLi4O1113nUdD1J988gnS0tLQt29fMuCIkMLo/iSTl5eHRYsWYeLEiWjSpAlOnTrldRkEEQhCoY/ce++9yMjIQEZGhkfpX3vtNcyaNQt9+/YlA44IHerWrYuIiAi36YqLi5Gfnw9AnHcAAElJSTh58qQuXVJSErZu3epR3TabDV9++SU6deqEG2+8EX///bfHep84cQIJCQkepyeIYGBkf3LkxIkTAICEhAQy4IiQweg+cu2116JFixaYMGGCx3lKSkpw7tw5079zaCNfk8IYc3r9yy+/xOnTp92G119/Xcmza9cuAMAVV1yhKyspKQnNmjVT4quC4zgsXboUffr0wb333ut0ImlVtGjRAmfPnvUqD0H4i1DrT85o2bIlAFA/IQwhVPvIsGHDIAgCVqxY4XGeWrVqITEx0fR9iUbgTIrsmqxTpw6OHTumXPdlPsI///yDvXv34rHHHsN7770HQRAAACNHjoQgCFi1apWSNj4+HklJScjKylJ+TQHAm2++iaFDh+Kxxx7DV1995bLexMTESitTR44ciQYNGuCHH35wqzdBBIJQ6k/O+kjjxo3x0EMPYffu3Th9+rTvN0oQPhJKfUTGarXi7rvvxqZNm5QRai2RkZGw2Wy6TeMBYMqUKeB5PizeOYavpKDgfbjiiisYY4ytXbuW3XfffWzIkCEsJibG5/JuvvlmZrfb2fr169kjjzzCFixYwCoqKiptijhixAjGGGMjRoxQrj399NOMMcY2b97Mhg0bVilo9SosLGQfffQRe+aZZ9jIkSPZ8uXLmd1uZzt27GDR0dGGtyuFmhlCqT999NFHbOPGjWzq1KnskUceYbNnz2Znz55lJSUlrGfPnoa3FYWaGUKpj2jLYIyxxx57zGkdycnJLDc3l7399tts9OjRbPTo0Wzt2rWMMca+++47xnGc4e1azWC4AhR8DC+88AI7ceIEq6iocLq829swaNAgtmPHDlZcXMyOHz/OZs6cyaxWqy6Ns84kL8t2hVav999/n+3Zs4dduHCBlZaWsgMHDrC5c+eyWrVqGd6eFGp2CJX+NHToUPbrr7+y7OxsVlZWxs6cOcO++OIL1qVLF8PbiELNDqHSR+SwYsUKVlpayurWreu0/Nq1a7OlS5eyAwcOsIsXL7Li4mKWkZHBJkyYUKkeMwZO+oMgCIIgCIIwCbSIgSAIgiAIwmSQAUcQBEEQBGEyyIAjCIIgCIIwGWTAEQRBEARBmAwy4AiCIAiCIEwGGXAEQRAEQRAmg05i8IDGjRujoKDAaDUIA4mLi9PtJE64h/oNQf3GN6jvEJ70HTLg3NC4cWM6OJoAADRp0oReRh5C/YaQoX7jHdR3CBl3fYcMODfIv4KaNGlCv4hqKHFxcTh16hR9/l5A/YagfuMb1HcIb/qO4cdBhHKIi4tjjDEWFxdnuC4U6BnwJfTo0YOtWbOGnTp1ijHG2KBBg9zm6dmzJ9u+fTsrKSlhBw8edHqMTTi3GYXqB3oGqN0oBPYZMNUihh49emDNmjU4deoUGGMYNGiQ2zw9e/bE9u3bUVJSgoMHD2LEiBFB0JQgQofY2Fjs3r0bTz75pEfpW7RogW+//RYbNmxA586dsWDBAnz44Yfo379/gDUlCIIgPMVULlT5RfTRRx/hq6++cptefhG9++67GDZsGPr06YMPP/wQWVlZ+PHHH4OgMUEYzw8//IAffvjB4/RPPPEEjhw5gmeffRYAsG/fPlx33XV45plnqN8QBEGECKYy4OhFRBCBp3v37li/fr3u2rp167BgwQJjFCIIgiAqYSoXqre4ehF1797dZZ6IiAjExcXpgpmJjo/DJVddgY69e6LRJa3AcZzRKhEhTqNGjZCdna27lp2djdq1ayMqKsppnnDrN77CWyxofll71GvW1GhVCMJUcDyPlK6piIh2/h1DVMZUI3De4u5FVFJSUinPxIkTMX369CBpGDiatGuD/qMexqU9roHFqn7MZ44cw7cL3sGeX34zUDsi3AiXfuMrEdFR6DFsCHrcNxhx9RJQnF+AWf1uQ2lRkdGqEUTIw/E87n91Njr164WNSz/BmlfeMFolUxDWI3C+MHfuXMTHxyuhSZMmRqvkFbzFggGjH8OYlR+hY6/rYbFacfbYCRzP+AelRUVokJKMB1+fh76PPWC0qkSIcvr0aTRs2FB3rWHDhrhw4YLTHz2A+ftNdWjXozue//oTDHz6CcTVSwAgjnw3btvaYM0IwhzcMWkcOvXrBQBo3/M6g7UxD2E9AufLi6isrAxlZWXBUM/vRERH4/602bi0xzUAgF0/rMe6dz7EmSPHAACRsTG48clH0XP4UNw0+nGcO5mJnd/RXEBCT3p6OgYOHKi71q9fP6Snp7vMY+Z+4yvWiAgMGj8G1wy+HQCQeyoL37/1HrrefCMuva47mlzaBkd2/mWwlgQR2vQf+TCuGXKHIsfWqW2gNuYirEfg0tPT0adPH901dy8isxIZE4NHF87HpT2uQVlxCZY9OxnLnpuiGG8AUFpYhDUvv46f3l8EALh72njUTWpklMpEkIiNjUVqaipSU1MBACkpKUhNTUWzZs0AAHPmzMGSJUuU9O+++y5atmyJefPmoW3bthg5ciQGDx6M1157zRD9Q5H4+on4v6Xv4prBt0MQBPy6ZAVevu0e7Fi7Dif27AUANG7bxmAtCSK06T74dtw46hEAwJpX3oAgCIipHY/YunWMVcwkmMqAoxeRcyw2Gx58fR5aXt4ZxfkFWPjI/2HXup9dpl/39oc4smM3ImNi0H/kw0HUlDCCK664Art27cKuXbsAAK+99hp27dqFmTNnAgCSkpLQvHlzJf3Ro0dx8803o1+/fti9ezfGjRuHRx55hFZuSzRIScbTKz5Esw6X4mJuHj54Ygy+efVNlJeUAgAy9x0AADRud4mRahJESNOpXy/c8YK4Q8SPC/+LjUs/QV7maQBAw5YtDNTMXBi+67CnoWfPnswZixYtYgDYokWL2IYNGyrl2bFjByspKWGHDh0Kux3lOY5j982bwdIy0tmLW9azZh0u9Shf88vas7SMdPbKrk2sQUqy4fcRyiHUn4FQDOHaZk3atWEzf/uepWWks/FrVrKEpo0rpUlo2pilZaSzeds3Mt5qMVxnegbMFWpCu7Xq1pXN276RpWWkszunPK9cf+SdNJaWkc6uvsv9aTHhHDx9Bkw1B27jxo1VboPx4IMPOs3TtWvXQKplKP2eeAhdBvZHRXk5Fo+ZiBN/7/Uo3/GMf/D3ht/RoVcPXHvPXfhqTlqANSUIc9O0fVs8/sEbiImPx/GMf/DhqLEoPH+hUrq8U1koLriI6LhaaNiyBbIO/GuAtgQRmjRp1wYPvfEyrBER2P3jL/jyxVeVuDNHjuHSHtegQUqygRqaB1O5UAk9HXv3VOYPrJo5Dwe3/M+r/Js++RwAcPnNN8IaGel3/QgiXEhq0xqPvy8ab0d2/oV3Hx3t1HgDAMYYLmSfAQDE1K4dTDUJIqRJaJKERxbOR1StWBzauh0rJs4AEwQlXp6zTQacZ5ABZ1ISmzfFPS9OAQBsXLYS/1v9rddlHNyyDbmnshAdH4dO/W7ws4YEER7Ub9Ecj7//OmJqx+Po7gx88MQzKC2sen83QXop8Tx9xRIEAETHx+PRha8hPrEeMvcfxKKnx6PCYeV67qksAEDtBvWNUNF00LeLCbHYbBj+ymxE1YrFv9t2Yu38t3wqhzGGravXAgA639jXnyoSRFgQ36A+HntvAeLqJeDkP/vxwcixHm3OK48qcDydfEIQFqsVDyyYiwYpyTh/OhsfjByLkouFldIJdjsAcWNfwj3USibkptGPo2n7triYm4ePx0+DUGH3uayMnzcCANpc3Q22KHKjEoRMVFwtPPbua0honIQzR47h/SfGoKTgokd5mcAAABxvCaSKBGEK7pzyPFp364qSi4X4YNQ45J/NcZpO/eFDpoknUCuZjJaXd0bPEfcAAD6bNgf5Z85Wq7zTB/9FbmYWbFGRaH3lFf5QkSBMj8VqxYj5c5B0SStcOHMW7z8+BoV55z3OzxiNwBEEAFw/fCiuuuNWCHY7lj03GacPul7UQ1MPvINayUTYoiIxZOYL4Hkef36xBn//uskv5e797Q8AQIcb6AgTggCAOyc/hzZXd0NJYSH+++SzyMs67VV+wS4ZcBx9xRI1l7bXXIVbx/0fAGDNq29i36YtVaZXR66p33gCtZKJuHHUo0hs3hTnT2fj61de91u5//y2GQBwyVU0AkcQ198/FFfd+R8Idjs+fm4qTkkb83qDPALH0wgcUUNJbN4U970yE7zFgq1frcXvH3/qNg+NXHsHGXAmoXHbS3D98CEAgFWzXnG7Cs4bju7KgCAISGzeFLXq1fVbuQRhNtpddzVuHauOGOz9/Q+fyqE5cERNJjI2Bg++8TJi4uNxdFcGVs162aN8NHLtHdRKJoDjONw15XlYrFbsWvcz9kojZv6ipOAisv89AgBokdrJr2UThFmo36I57psnjhj8+cUaj0YMXEGrUImaCsdxuHfuNDRqlYIL2Wex+JmJsJeXe5SX+o13kAFnAq68/RYkp3ZEycVCfD1vQUDqOLLzLwBAi86XBaR8gghlImNj8ODr8xAdH4cjO3bji9mvVKs8gVbTETWU/qMeQcde16O8tBSLxkxAQc45j/MqUw8sNHLtCfTtEuJEx8fj5jGjAAA/vP2By+XX1eWoZMCldKEROKJmwXEc7nlxKhq2bIHz2WeweOxE2CsqqlWmPJLAV3H0H0GEG5f16Yn+TzwEAFg182Wc2POPV/lVFyr1G08gAy7EGfB/jyK2bh1kHfwXmz9ZFbB6ju7KACCe98hb6dcPUXPo9dBwXNanJyrKyrB4zERcPJdX7TIZk+bA0UgCUUNo1Lol7pkzFYB4OtC2Nd95XYbSb2jk2iOolUKYRpe0wjWDbwcAfDV3vrJLdSA4d/IUSi4WwhoRgfrJzQNWD0GEEpdcdQVuGv0YAODLOWlejxi4gubyEDWJ6Ph4PPj6PETGxODAlv9hbZqPpwPRPnBeQa0Uwgx6/mnwFgt2//gL/v3fjoDXl3XgEACgcZvWAa+LIIwmvkF9DJs3Q1y08OU3+POLNX4rW5kDR6vpiDCH43ncN28GEps3xbmTmVj27GSfBxvoJAbvoFYKUTr06oE2V3dDeWkpvkl7Myh1ZkoGXBIZcESYw1ssGP7yTMTVS8CpfQfw5Zw0v5avjiTQCBwR3tw0+nG0u+5qlBWXYNHT41F0Id/nsgQaufYKMuBCEIvVquxFtXHpSuRlercLvK9kHRCPOGnclgw4IrwZ8H+PoeXlnVFysRBLxr6AitJSv5ZP+8ARNYHL+t6APo/cDwD4dOqLihfHV+R+w1O/8Qgy4EKQ7oNvQ/0WzVFwLhe/fLg0aPVm0QgcUQNoe81V6ktn2hycO3HS73UwQXQh0UgCEa40bNkCQ2dPBgD8umQFdv2wvtpl0kkM3kEGXIgRVSsW/R4Xl2Gve/tDlBb578QFd2QdEkfg6jRsgJja8UGrlyCCRVxiPWWl3B+ffom/fvwlIPUIdKYjEcZExsbggQUvISo2Fgf/3IZvX3vHL+UyOonBK6iVQoxeD96HWgl1cebIMfz5pf8mVXtCaWGRcmh3/Ra0EpUILziOw71zpiKuXgIy9x/E1y/77zxhR2g1HRHODJ01GQ1SknH+dDY+fn6q33ZIUPqNhfqNJ1ArhRBxifXQ4z7xvNNvFywM6LYhrjh34hQAoF6zJkGvmyACyQ0P3Is23a9EaVExlj03BRVlZQGri/azCh9GjRqFI0eOoLi4GFu2bEG3bt1cph0xYgQYY7pQXFwcRG0Dzw0j7kWnfr1QUVaGJWMn4WJu9fdNlBHkfkMjcB5BrRRC9Hv8QUTGROPo7gzs+WWjITrIBlxis6aG1E8QgaBp+3a4afQTAICv572GM0eOBbQ+Jv34oh3lzc3gwYMxf/58zJgxA127dsXu3buxbt061K9f32WeCxcuoFGjRkpITk4OosaBpeUVXTBwzEgAwOqXFuB4hn/2TZRR+g3NgfMIMuBChIQmSbj6zkEAgO8WLDRMjxxpQjeNwBHhQkR0NO6bNwMWmxW7f/wFf375TcDrpBG48GDs2LH44IMPsHjxYuzduxdPPPEEioqK8NBDD7nMwxhDdna2Es6cORNEjQNHXGI9DH9lFixWK7Z98z3SP//K73XI/YbOQvUM+nYJEfqPfBgWmxX7//gT/27baZgeOTQCR4QZg55/GvVbNMf509n4fMa8oNQp0Bw402Oz2XD55Zdj/Xp1dSVjDOvXr0f37t1d5qtVqxaOHj2K48ePY/Xq1Wjfvn0w1A0ovMWC4a/MQnxiPWQd/BerZgamH8lz4AAavfYE+nYJAeq3aI7LbxkAAPj+zfcN1eUcjcARYUTH3j1x9V2DIAgCVkyaieJ83zcZ9QZGq1BNT2JiIqxWK7Kzs3XXs7Oz0ahRI6d59u/fj4ceegiDBg3CfffdB57n8ccff6BJE9ffpxEREYiLi9OFUOOm0Y+h1RVdUHKxEIufmYjyEv/umygjaA046jtuoRYKAfqPfBi8xYI9G37z21mMviLPgYurl4DImBhDdSGI6hCXWA+Dp08AAPy6eHlQjqOTobNQayZbtmzBsmXLsHv3bvz222+44447cPbsWTz++OMu80ycOBH5+flKOHXqVBA1dk+HG65D74fVzXpzjp0IWF00AucdpjPgwm1FUMOWLdB5QF8A4r5vRlNysVBZVUSjcOFFuPUddwyZ9QJi69bBqb0H8EOQR7YZnYVqenJyclBRUYGGDRvqrjds2BCnT3t2Ok5FRQV27tyJ1q1db44+d+5cxMfHK6Gq0bpgk9C0MYa+OAUA8NuyT/HXTxsCWp88cg0AHM2Dc4upvl3CcUVQ/5EPg+d5/PXTBmTuP2i0OgA0W4k0bWywJoS/CMe+UxXXDLkDl17XHeUlpVg+YRrsFRVBrV9gtJ+V2SkvL8f27dvRp08f5RrHcejTpw/S09M9KoPneVx22WXIyspymaasrAwFBQW6EApYIyJwf9qLiImPx9FdGVg7/62A1ykI6tZZdI6we0z17RJuK4IatW6JTv17AwB+fPe/BmujcuHMWQBAfP1EgzUh/EW49Z2qqN+iOW4dNxoA8O2Cd5B9+GjQdaA5cOHB/Pnz8eijj+L+++9Hu3btsHDhQsTGxmLRokUAgCVLlmDOnDlK+ilTpqBfv35ISUlBly5d8PHHHyM5ORkffmi8d8Vb/vPcU2jWvh0K885j2bOTg/IjSDcCR6PXbjFNC4XjiqB+jz8Inuex+8dflIPkQ4GCc7kAgLj69QzWhPAH4dh3XMFbLbh3zjREREfhQPpWbFrxuSF6qC5UGkUwM5999hmeffZZzJw5E7t27ULnzp0xYMAA5cdM8+bNkZSUpKSvW7cuPvjgA+zduxffffcd4uPjcc0112Dv3r1G3YJPdBnYH9cOvROCIGD5xBk4nx2cH2+6OXA0eu0Wq9EKeEpVK4LatWvnNI+8Iuivv/5C7dq18eyzz+KPP/5Ahw4dXE4UjYiIQGRkpCIHakVQw5YtlNG3n977KCB1+Er+2RwAQHw9MuDCgWD0nWD1G3f0eWQEml/WHkX5+Vg5Zbayr1SwURcx0EvI7Lz99tt4++23ncb16tVLJ48dOxZjx44NhloBo0FKMu6eNh4A8PMHS7B/85ag1a1bhUojcG4J6xYK5RVBfaXRt7/W/xpSo28AUJBzDgCNwNVkvO07obCSrmn7tuj32IMAgC9fTMOF7LNB10GG9oEjzIgtKhL3p72IyJgYHNq6HeveCa7rVzsCR3Pg3GOab5dwWhFUv0VzZeXp+vcW+b386pJ/VjLgEsmACweC0XeMXklnjYjAPS9OVU5b2Pndj0Gt3xE6iYEwI3dMehZJl7RCfs45fPz8VJ1BFWzIheoe07RQOK0I6vPICPA8j783/I5T+w74vfzqUnBONODiyYALC4LRd4xeSTfg/x5Do9YtkZ9zDl/MejmodTuD2WkfOMJcXH7rTbjy9lsg2O1YPn6aMhc62AjKOcKmMU8MwzRz4ABxRdCSJUuwbds2bN26IDQS5wAANXZJREFUFWPGjKm0IujUqVOYNGkSAHFF0JYtW3Do0CHUqVMHzz33nOErghKaNkbXm/sDAH4KwdE3QDMCVy8BHM8b+iuM8A/h0HdckdKlE3qOuAcA8Pn0l1B4/oLBGtE+cIS5aJCSjDsnPwcA+PHdj3Bo63bDdBEEAbzFQqPXHmAqA+6zzz5D/fr1MXPmTDRq1Ai7du2qtCJIOwlSXhHUqFEj5OXlYfv27YavCOr90HBYrFbs27QFJ/4OzZVJF3PzlE4UW7c2Lp7LM1olopqEQ99xRkR0FIbOngKe57F19Vr8s3GT0SoBABjtA0eYBHXeWzQOpG/F+vcXG6oPo/mjHmMqAw4w94qg2g3ro9ttNwMA1r8fmqNvgDiEXZh3HnH1EhCfmEgGXJhg5r7jipvHjEJi86bIyzqNr+ctMFodBUHeB45G4IgQ5/aJ48R5b2dzsHzidMM9LuoeijT9wB307RJEeo64F1abDf9u24kjO/8yWp0qkbcSoYUMRKjSqltXXHfv3QCAz6bNQcnFQoM1UqGzUAkz0PWWG3HVHbdCsNvx8fhpIfFjXT6NgVyo7qEWChKxdevg6jsHAYDhQ9SeUJAjTmCNp61EiBAkIjoaQ2a+AAD447OvcCD9fwZrpEdxA9F5jkSIUr9Fc9w15XkAwE/vfoR//7fDYI1E5BE4cqG6h1ooSPQYNhiRMdE48fdeHEjfarQ6bsnPkTbzTaTjtIjQ45axT6Je08bIPZWFtWmBP6PRW+gkBiKUsUZEYPgrsxAZE4ODf27DTyE0qCDPH6UROPdQCwWByNgYXHvPnQCAnz9carA2nlGYJ67ki6kTb7AmBKGnVbeuuHao2J8+mzYHpUVFBmtUGYFOYiBCmP889xSatGuDgnO5WD7B+HlvWpQteOjHj1vo2yUIdL/rNsTEx+PMkWPY8/NGo9XxiOJ8cR+vmHgy4IjQISI6CoNnTAQguk4P/rnNYI2co0zEppcQEWJ06t9b+QG0YuIM5eSdUIF+/HgOtVCAsdhsuP7+oQCADR99bNjZjN5SlJ8PAIiON+ZMS4Jwxk1PPYHEZuKq07XzQ891KqNuI0Jz4IjQIaFpYwyeLv4A+vnDpSE5nUd+R9IWPO6hFgowl98yALUb1Mf57DPY/u06o9XxGHkEjgw4IlRI6dJJWXX6+fSXUFoYeq5TGVqFSoQaFqsVw1+Zhei4Wjiy8y/88Nb7RqvkFNWFSuaJO6iFAgjHcej14DAAwG9LV8JeXm6wRp6julDJgCOMxxoZicEzJokb9n61Fvv/+NNolapEoJcQEWIMHDMSzTu2R9GFfHz8/FTlyKpQQ13EQD9+3EHfLgGkQ68eaJCSjKL8fGxZ9bXR6nhF0QVyoRKhw42jHkaDlGRcOHMWX7/yutHquEU9zJ5eQoTxXNrjGtww4l4AwKdTX8T509kGa+QaQTmJgaYfuIMMuADS68H7AAB/rPwyJFfKVUURuVCJEKFZh0uVl88Xs15GScFFgzVyDx0HRIQKtRvWxz0vTgEA/Pbxp9jzy28Ga1Q1NP3Ac+jbJUCkdOmEFp0vQ3lpKTat+NxodbymWFrEEBUbC95Kv4QIY7BYrRgy6wXwFgt2fLsOf/8aGmeduoP2siJCAY7nce/c6YitWwcn/tmHtfOdH6UXSqhHaVHfcQe1UIC4QZr7tu2b71FwLtdgbbynWDPKQVuJEEbR59ERSLqkFQrO5WL1S68ZrY7HKHPg6CVEGEi/xx9E625dUVJYiI+fm2KKedg0eu051EIBoEFKMjr2uh6CIGDjkk+MVscnmCAoRhy5UQkjaHRJK/R99AEAwOq581F4/oKxCnkB7QNHGE2rK7qg3+MPAhCnHuQcP2mwRp6hzh8l88Qd1EIBQJ6v8/eG33H26HGDtfEd2kqEMAreYsGQGZNgsVmx55eN2LXuZ6NV8gp1Hzj6iiWCT2yd2hj20gzwFgu2rl6LHd/+aLRKHiOvjqUfP+6hbxc/E5dYD5ffOgAA8Oui5QZrUz3klai0lQgRbK4fPhTNL2uP4vwCfDH7VaPV8Rr1LFT6iiWCz5BZk1G7YX2cOXIMX81JM1odr1A38qW51+6w+pKpRYsW6NGjB5KTkxETE4OzZ89i586dSE9PR2lpqb91NBXX3Xs3rBEROLLzLxzdnWG0OtVCHYGjOXD+gvqOexKbN8WAJx8FAKx55Q3kn80xWCPvoeOA/Av1G8/pMWwwOtxwHcpLS7H02RdQVlxitEpeQatQPccrA+7ee+/F008/jSuuuALZ2dnIzMxEcXExEhIS0KpVK5SUlGD58uWYN28ejh83r+vQVyJjYnDNkNsBAL8uNvfoG6Aep0UjcNWH+o5ncByHwTMmwRYVif1//Imtq9carZJPqCvp6CVUHajfeEeTS9vglnH/BwD45tU3kXXgX4M18h7aBNtzPDbgduzYgbKyMixevBh33nknTp7UT4iMiIhA9+7dMXToUGzbtg2jRo3CqlWr/K5wKHPlHbcqh9b/veF3o9WpNjQHzj9Q3/Gcq++6Da2u6ILSoiJ8PuMlo9XxGVpJV32o33hHZEwMhr8yG1abDX+t/xWbV35htEo+oWzBQ/NH3eKxATdhwgT8+KPriZBlZWXYuHEjNm7ciBdeeAEtWrTwh36mgbdYcP3wIQCAjctWmubQ+qogA84/UN/xjDoNG+CWsU8CAL5/4z3kZZ42WCPfoX3gqg/1G++444VnUT+5GfKyTuOzaXONVsdn1BXc1Hfc4bEBV1VHciQ3Nxe5uebb+6w6pPbvjYTGSSg4l4tta743Wh2/IJ/GEFOb5sBVB+o7nnHn1OcRVSsWR3dlYNMn5h5JITdQ9aF+4zmX3zIAV/znJgh2O5ZPmK5sxG5GBEFchcrT9AO3+PTtMmLECKfXLRYL5syZUy2FzErPB8StQzav/AIVYTKplg609z/Ud5zT9eb+aH/9tagoK8Nn0+YoLkizouxlRW4gv0D9xjWJzZvijsnPAgDWLfwvjuzYbbBG1UOdP0qrUN3h07fLG2+8gc8++wx16tRRrrVp0wZ//vkn7rnnHn/pZhpadeuKZu3boay4BH+YdN6BM4oLRAMuMjbWYE3CB+o7lamVUBe3jX8GAPDTe4uQffiosQr5AVpJ51+o3zjHYrXivpdnIio2Fof+twM/f7DEaJWqDfUdz/HJgOvSpQuaNm2KjIwM9O3bF6NGjcKOHTuwb98+pKam+lvHkKeXdGzW1tVrTbVbvDtKCgsBAFFxtQzWJHygvlOZ28aPQWzdOsjcfxC/fLTMaHX8guxC5cmF6heo3zhn4JiRaNbhUhSev4AVE6ebfuQaoC14vMGnfeAOHz6Ma6+9FgsWLMAPP/wAu92OESNGYOXKlf7WL+Rp1LolLu1xDQS7Hb8tDa/7LykQDbjoWmTA+QvqO3ra97wOXQb2h2C349OpcyBU2I1WyS/QIgb/Qv2mMu16dFdO/fl0ymxcyD5rsEb+QVnBTScxuMXnb5ebb74ZQ4cORXp6Os6fP4+HH34YSUlJ/tTNFPQcIQ7fZ/y8EedOnjJYG/9SclE8CzWqFrlQ/Qn1HZGoWrG4c8pzAIBfl6zAyX/2GayR/1Dn8ZAB5y+o36jEJdbDPbOnAAB+X/4Z/v51k8Ea+Q91/ijNgXOHT98u7777Lj7//HPMmzcPPXr0QKdOnVBWVoaMjAzcfffd/tYxZImvn4iuN98IQHwBhRsl0mH25EL1H9R3VG4Z+3+o07ABzh47gXXv/NdodfwKzePxL9RvVDiOw71zp6FWQl2c2ncAa+e/bbRKfoXJZ6FS33GLTwbctddei6uuugrz588HAGRnZ+Pmm2/G1KlT8dFHH/lVQUdGjRqFI0eOoLi4GFu2bEG3bt2qTH/XXXdh7969KC4uxl9//YWbbrrJb7pcd+/dsNpsOLx9F47/9bffyg0ViqUROKvNBmtEhMHahAfUd0RaXdEF3e++DQDw2fS5YbNyW4bm8fgX6jcqvR4ajjZXd0NpUTE+fn4qKsrK/Fq+0QiM9oHzBuZtiIiIcBnXpk0br8vzNAwePJiVlJSwBx54gF166aXsvffeY7m5uax+/fpO03fv3p2Vl5ezZ599lrVr147NnDmTlZaWsg4dOnhcZ1xcHGOMsbi4OH0bREezWZvXsbSMdNahV4+A3bORgeM49sruzSwtI53VqlfXcH2MCq6eAV9CTek7VbWZLSqSTfz2c5aWkc7unPK84Z9vIEKb7leytIx0NvazJYbrYlSgfuPfdw4A1iL1Mvbyzt9ZWkY6u/K2Wwz/jAMRHn77VZaWkc663Xaz4boYFbzoO8Yr62nYsmULe/PNNxWZ4zh28uRJNn78eKfpV65cyb755hvdtfT0dLZw4cJqN2SPYYNZWkY6m/DNp4zjOMPbJlBh9h8/sbSMdJaY3MxwXYwK/nwRGRWC3XeqarNbnnmSpWWksyk/rWaRsTGGt00gwiVXd2NpGels3BfLDNfFqED9Rgz+eudEx8exF9Z9ydIy0tmwl6Yb3jaBCg+9+YpooN5+q+G6GBU87Tt+H6P8+eefMXnyZERHR/u1XJvNhssvvxzr169XrjHGsH79enTv3t1pnu7du+vSA8C6detcpvcU8disoQCAX5d+EhbHZrlCXsgQ7itROZ7HDQ8MQ62EuobpUBP6TtP27ZSFP6tmvYLSwqJqlReqKHPgasBKukaXtELXW240rP6a0G8A4O5pE5DQOAk5J05i1ayXq11eqMKEmjMH7uZnRqFF6mU+5/e7AXf8+HH06dMH+/b5d0VZYmIirFYrsrOzddezs7PRqFEjp3kaNWrkVXpAPCA5Li5OFxzp1PcGJDRJwsXcvLA5NssVJRdrxl5wHXtfj1vH/R/GfrYEvEGrn8zcdzzpN7zVgiGzXgBvsWDHt+uw97fNPt5R6FNT5sDxFguGzJyEYXOno88jIwzRwcz9BvDwndO/N1L790ZFeTmWPTslbH/4AIAgreDmw/wkhiv+MxC9HxqOJ/77JuIS6/lUhk/7wFXFgw8+CABOH0IzMHHiREyfPr3KNKcPH8WO737E6UOHw27ytSPKStTYGIM1CSy9HpA2Y/56LQS7MXuRmbnveNJvhAo7fvnvMvR97AGsnrcgKHoZhbKXVZgbcNcPH4rmHdujOL8A//v6W0N0MHO/ATzrO3t+2Yj1HyxBYd75sNpuxxk1YQV3g5Rk3PGCePzZT+8tQkHOOZ/K8enbZfjw4YhwsirRZrNh+PDhAIAC6Rgmf5GTk4OKigo0bNhQd71hw4Y4ffq00zynT5/2Kj0AzJ07F/Hx8Upo0qRJ5XIP/ovl46eFxbEl7qgJpzGkdOmE5NSOKC8txaYVnwe0rnDtO570GwDY+d2PePX2YSjMO+/9jZiImrAPXGJyMwx48lEAwNevvI78szkBqytc+w3gWd8RKuz4/o138duy8N+4mIX56LU1MhL3p72IyJhoHEjfil/+6/vpMz610KJFi1C7du1K1+Pi4rBo0SKflamK8vJybN++HX369FGucRyHPn36ID093Wme9PR0XXoA6Nevn8v0AFBWVoaCggJdqMkoI3BhPAfuBukotG3ffI+L5/ICWle49h1v+k04zxmVUU9iCM9RBI7jMHj6RNiiIrH/jz/xv9WBHX0L134D0DvHkXAfvR70/NNIuqQV8nPOYcXEGdU6/swnFyrHcU6/hJs2bYoLFwJ3Fuj8+fOxZMkSbNu2DVu3bsWYMWMQGxurdOAlS5bg1KlTmDRpEgDg9ddfx8aNGzF27Fh8++23GDp0KK644go89thjAdMx3Ci+KB+nFZ6nMTRISUbHXtdDEARsXPJJwOujvlMzkM9CDde9rK6++za0uqILSouK8PmMlwJeH/WbmoNyEkMYGnCd+vfGNYNvhyAIWDFxBgrO5VarPK8MuB07doAxBsYYfv75Z1RUVChxFosFKSkp+OGHH6qlUFV89tlnqF+/PmbOnIlGjRph165dGDBgAM6cOQMAaN68uTJ5GBB/Dd17772YPXs25syZg4MHD+K2227D33+H36a7gUI5TitMXajyWYL//Po7zh49HrB6qO/ULMJ5Hk+dhg1wy9gnAQDfvb4QeZmu3YPVhfpNzUP98RNefSehSRIGT58IAPjlv8twcMv/ql2mVwbc6tWrAQCdO3fGunXrcFF6uQPiMPDRo0fxxRdfVFupqnj77bfx9tvOjw7p1atXpWurVq3CqlWrAqpTOCMfaB8VG34jcHH1EnD5rQMAABsWBfYoNOo7NQvZhWrUiuZAcufU5xEVG4ujuzKweeWXAa2L+k3NQ+074TMCx1stuG/eTETH1cLRXRlY984HfinXKwNu5syZAICjR4/i008/RWmYr8AkwnsRw3X33g1rRASO7srA0V1/BbQu6js1C2URQ5iNInQZ2B/tr78WFWVl+HTqi9Wav+MJ1G9qHuG4AOim/3sMyakdUZSfj4+fnwqhwj87Hfg0B27p0qV+qZwIfdRFDOE1AhcRHY1rhtwBANiwaHnQ6qW+UzMIx33gYuvWwe0TngEgbn1w5sixoNVN/abmIG/jFC7zR9t0vxK9H74fAPDZ1DnIy/LflAOPW+jvv//GkCFDYLPZqkzXunVrvPPOOxg/fny1lSOMR5kDF2arUK+641bE1I7H2aPH8fevvwe0Luo7NY9wXEl324RnEFu3DjL3H8QvH/m+9YGnUL+pmaiLGMw/eh1XLwH3zp0GANi88gtk/LzRr+V7PAI3evRozJs3D++88w5++uknbNu2DZmZmSgpKUHdunXRvn17XHfddejQoQPeeustLFy40K+KEsagrEINIxcqb7Xg+vs1R6EF2A1EfafmEW57WXW44Tp0Hdgfgt2OT6fO8ZsLqCqo39RMwuXHD8dxuHfuNMTVS0DmgUNY8+qbfq/DYwPul19+Qbdu3XDttddiyJAhGDZsGJKTkxEdHY2cnBzs3LkTS5cuxfLly3H+/Hm/K0oYQ3G+uCdROM2BS+3fBwmNk1BwLjcoR6FR36l5CGG0CjUqrhbunPw8AODXJSuCdhIA9ZuaSbhMP+j10HC06X4lSouKsezZyQE5tcnrOXCbN2/G5s3he4YhoUc24GLizXlMjTPkY7M2rfg8qEehUd+pOaiLGMz9EgKA/4wbjdoN6+Ps0eNY985/g14/9ZuaRTiMXrdIvQwD/k88pWT13PkBmy/q0yKGKVOmVBk/a9Ysn5QhQo+iC/kAAGtEBGxRkSgvMfcqsDbdu6HJpW1QWlSMPz4N7BYIzqC+UzMIl60Q2nTvhqvu/A8A4NNpcww7+5n6Tc3B7KtQo+PjMezlGbBYrdjx7TpsXb02YHX5ZMDdfvvtOtlmsyElJQUVFRX4999/qTOFEWXFxbCXV8BisyKmdjwulJw1WqVq0evB+wAAW7/6RjFOgwn1nZqBMopg4hG4iOho3DV1AgBg0yercGTHbsN0oX5Tc1B+/Jh0+sHgGROR0DgJOcdPYtWslwNal08GXNeuXStdi4uLw+LFi/HVV19VWykitCjKz0dcvQREx8fjQrZ5Dbgm7dqgTfcrYa+owMalgT82yxnUd2oGzG7+OXADn34C9Zo2Ru6pLHz72juG6kL9puZg5mPorr3nLnTqewMqysux7LnJKC0sCmh9fmuhgoICTJs2jX4JhSHhMg+ul3Ro/e4ffwno8T/eQn0n/BBMfp5jStdU9Bg2GADw+Yy5KCsuNlijylC/CU/kETjOZNMPmrRrg/88OxoA8M2rb+LkP/sDXqdfW6h27dqoXbu2P4skQoCifNHVGG1iAy6hSRJSb+wDANjw0ccGa1MZ6jvhhZm3QrBFRWLIzBcAAH9+sQYH0qt/ZmOgoH4TfphxDlxkTAyGvzIL1ogI7NnwGzat+Dwo9frkQh09erRO5jgOSUlJGD58OL7/PvDbMhDBRRmBqx1vsCa+03PEveAtFuzbtAWZ+w8apgf1nZqBmc9CHfDkY6if3Azns89gzatvGK0OAOo3NQlBkE9iMM/0g7umPo/6LZojL+s0Vk5+MWj1+mTAPfPMMzpZEAScPXsWS5Yswdy5c/2iGBE6yAacWUfgYuvWwZW33QIA2LDI2NE36js1A3kOnNlo3qkDrh8+BACwasY8lEgbeRsN9ZuagzwCZ5YfP1fefiu63nwj7BUV+Pi5qSjOD97iOJ8MuJYtW/pbDyKEKVLmwJlzBO66e+9GRHQUju/5B4e2bjdUF+o7NQNBegkBoiso0Kd9+ANrRASGzHwBvMWCbWu+x97f/zBaJQXqNzUHdQV36I/ANWrdErdPHAsA+OGt93F0d0ZQ6zePk5kwDHm7DTOOwEVER+O6e+4CEJpz34jwRHahAuaZB9d/5MNo1CoF+TnnsHreAqPVIWooZjmJISI6CsNfmYWI6Cjs27TFkPdLaLcQERKYeQ7c1XcNUg6t9/dBwgThCu2IW6i/iACgWYdLlVXaq2bOC6obiCC0mGUB0G0TxqJR65a4cOYsPnlhJhhj7jP5mdBuISIkKDbpKlSL1YqeI+4BIM59M4MbiwgP9AZcaLuCLDYbhswSXac7vvsRf2/43WiViBqMGVahdr3lRlx1x60Q7HYsnzAdF3PzDNEjdFuICBmUOXBx5jLgut5yI+o0bIALZ85i2zc/GK0OUYPQzYEL8Q1J+z3xIJIuaYWCc7lYPXe+0eoQNRwmr0IN0R8+9Vs0x11TngcA/PTuR/j3fzsM0yW0v1mIkMCMc+A4jkPvh4YDAH5buhL28nKDNSJqEtoRuFA+D7Vp+7ZKP/li1ssoPH/BYI2Imo4yAheCP3yskZG4/9XZiIyJwcE/t+Gn9xcbqk/otRARcphxDlzHPj3RICUZRfn5SP98tdHqEDUM7SKGUHUFWWw2DJ09BRarFbt+WE9zRImQQFD2UAy9fjPouafQuO0lKDiXi+UTphs+LSf0WogIOYpMuA9cn0fuBwBsWrEKpUWBPY+OIBzR7gMXqtshaF2nX85JM1odggCgPUc4tMyTzjf2wTVD7oAgCFgxcToKcs4ZrRIZcIR7ZBeqxWpFVK1Yg7VxT5vuV6JZh0tRWlSMTcs/M1odogaiXZEWai8iwMF1OvsVFOadN1YhgpBQzkINoR8+9Zo1xd3TJwIAfvlwacgcLxd63yxEyFFRWorigosAgLjEegZr454+j44AIJ7jSHN6CKMQQnQ7BK3rdOf3PyFj/a9Gq0QQCqF2EoM1IgL3vzobUbVi8e/2nVj3zodGq6QQWt8sRMgiDxfHh7gB16JzJ7Tu1hUV5eX4dclyo9UhajAsRDckvXHUI4rr9CtynRIhhmAPrRG4W58djabt2+Jibh6Wj58GwW43WiWF0PpmIUKWfMmAC/URuL6PiaNv277+DheyzxqsDVGTUQ240HgRAeJZp+qGvbTqlAg9FBdqCPzw6dSvl3KSzycvzAy5d4rxLUSYgoKzOQCA+PqJBmvimqbt2+LSHtdAsNvxy3+XGa0OUcNRXEF8iLiCIiNxz+wp4C0WbF/7A/b8QqtOidAjVE5iqNe0CQbPmAQA+PnDpdi3aYuh+jjDNAZc3bp18fHHH+PChQvIy8vDhx9+iNjYqifUb9iwAYwxXVi4cGGQNA4v8k3gQu3z6AMAgJ3f/4RzJ08Zq0wIQX3HGIQQG4Eb+PQTaJCSjAtnzuKrua8ZrQ5BOCUUTmKwRkRgeNpsRMfVwpEdu/HDW+8bpktVWI1WwFOWL1+OpKQk9OvXDzabDYsWLcL777+PYcOGVZnv/fffx9SpUxW5iLaU8ImCEHehNrqkFTr1vQGCIODnD5YYrU5IQX3HGBQXaghsSNrqii7oOXwoAOCzaXPorFMiZAmFHz7/ee4pNGvfDoV557Hs+SkhNe9NiykMuHbt2uGmm27CFVdcge3btwMARo8eje+++w7PPvsssrKyXOYtKipCdnZ2sFQNW/LPSiNw9UPTgOsrrTzNWP8rsg8fNVaZEIL6jnGEyhy4yNgYDJ09BQCwZdXXIekKIggZo12onW/sg2uH3gkAWDFpRsjNe9Ni/E9DD+jevTvy8vKUFxAArF+/HoIg4Kqrrqoy77Bhw3D27FlkZGRgzpw5iI6OrjJ9REQE4uLidIEACs6F7ghcg5RkpN7YBwDw03uLDNYmtAhm3yH0yHvBGb0dwqDnnkZCkyScO5mJNa+8YaguBOEOIxcxJCY3w90zxP3e1n+wJOR/7JhiBK5Ro0Y4c+aM7prdbkdubi4aNWrkMt+KFStw7NgxZGZmolOnTpg3bx7atm2LO++802WeiRMnYvr06f5SPWxQR+BCbxFD38ceAM/z2PPLRmQdOGS0OiFFsPpOREQEIiMjFZl++GhdqMaNwLXveR2uuvM/EAQBKyfPolNJiJBH3UYkuAacNTISI+bPQVRsLA79bwfWvf1BUOv3BUMNuLlz52LChAlVpmnXrp3P5X/wgfoB7NmzB1lZWfjll1/QsmVLHD582KVO8+fPV+S4uDicOkUT4vOlVaixdWrDYrOFzOHw9Vs0R5eb+gEAfnz3I4O1CR6h1nfoh09lBIP3gYutWweDpdGE35auxOHtuwzRgyC8QR655oJ8Fuodk8ahcZvWKDiXi4+fnxqy8960GOpCTUtLQ7t27aoMhw8fxunTp9GgQQNdXovFgoSEBJw+fdrj+v78808AQOvWrV2mKSsrQ0FBgS4Q4nFaFZLRFlcvwWBtVPo+9gB4iwV/b/gdp/YeMFqdoBFqfWfu3LmIj49XQpMmTXy/uTDB6Dlwd00dj7h6Ccg6+C++f/M9Q3QwM7R62xiM6DfdBg3EVXfcCkEQsHz8tJA459QTDB2By8nJQU5Ojtt06enpqFu3Lrp27YodO3YAAHr37g2e55UXiyd07twZAKqcuE24piDnHOomNUJ8g0ScP2385Pb6LZqj68D+AIB1C0PneJNgEGp9p6ysDGVlZR6XVxMwch+4brfdjE59b0BFeTlWTJyBCvpsvIZWbxuD7ELlg+RCTWrTCne88BwAYN07H+Lgn9uCUq8/MMUihn379uH777/HBx98gG7duuGaa67BW2+9hZUrVyovlMaNG2Pv3r3o1q0bAKBly5aYPHkyunbtiuTkZNx6661YunQpNm7ciIyMDCNvx7TkZoptXa9JY4M1Eek/8mHwFgv2bPitRo2+eQP1HeNQJ2MHdwQuoWlj3DbhGQDAD2+9j8z9B4Nafzggr95+5JFHsHXrVmzevBmjR4/G0KFDkZSUVGVeefW2HMiL4x3BXMQQGRuDEWlzEBEdhX2btuDn9xcHvE5/YgoDDhBXxO3btw8///wzvvvuO2zatAmPPfaYEm+z2dCuXTvExMQAEEcE+vbtix9//BH79u1DWloavvjiC9x6661G3YLpOXdCnAtYr5nx7rGGrVLQeUBfAMC6t2vW6Ju3UN8xBiMmY/MWC+59cSqiYsWDt39dvCJodYcTtPOBcQRzI98hM19A/RbNkZd1GismTlfm35kFU6xCBYC8vLwqh66PHTumW+118uRJ3HDDDUHQrOaQc/wkACCxeVODNQEGPPkoeJ7H7h9/oREGN1DfMQYjRuB6PzwcKV1TUVxwEZ9MmqnMJyK8g3Y+MA5BEBcPBLrfXD98KFL790ZFeTmWjnvBlOcCm8aAI4xHGYFrauwIXNP27dCpXy8IgmCKpd5EzSTYc+CaX9Ye/Uc+DAD4cs6ryMv0fJFKTSHUVm/LOtHOByrBGIFL6dIJt4x9EgCw5pU3cDzjn4DVFUjIgCM8RjbgjB6BG/jU4wCAHWvX0akLRMgSzNV0kTExGDZvBixWK3Z+9yN2rF0X8DrNSFpaGhYvXlxlmkCt3nZlwNECID2BPokhrl4Chr86GxarFTu++xGbP1kVkHqCARlwhMfknBBdqPH1ExERHYWy4pKg69D6ysvR9tqrUVFeXuNWnhLmIpj7wN0+aRwSmzVF7qksrJr9SsDrMyuhtnqbqAwLYL/hLRbc98os1G5QH6cPHcbn01/yex3BxDSLGAjjKc4vQNEF8RDsBIPcqAOfHgkA2PL5auSezDREB4LwhGCdxNBlYH90GzQQgt2OFROno6TgYkDrqwnQ6m3jEALYbwY+PRKtu3VFSWEhloydhLLiYr/XEUzIgCO8Qh6FS2wWfDdqp/69kdypA0qLirDeZMu9iZpHMM5CrdesKe6a8jwA8RzgIzv/ClhdNQ1avW0Mgeo3nfr1Qq8HxcVcn055EWeOHPNr+UZALlTCK3KOn0Tzju3RICU5qPVarFYMfOoJAMCvi1eg4FxuUOsnCG8J9Bw4i82G4a/MRFQtccsQ+lHjX2j1tjEEYuS6QUoyhsx6AQCwYdFy/PXTBr+VbSQ0Akd4hbxlR+O2ro8jCwTdB9+O+snNkJ9zDhuXfBLUugnCFwK9D9zNz4xCsw6XovD8BawYP90UZzcShDuY3b9z4CJjYvDAgpfEQ+q3bsd3r4fP0WZkwBFekbn/EACgcdtLglZndHycsj3Curc/QCkdTUOYAGUfuAAcyt2xd0/0HD4UALBy8myczz7jJgdBmANB6je8n/rN0NmT0bBlC5zPPoNlz08Jqx86ZMARXiGPwNVPbgZbVGRQ6uz3+IOIrVMbpw8dxtav1galToKoLsp+Vn4egUto2hhDJXfQr0tW4J+Nm/xaPkEYiT/7Te+H70enfr1QUVaGJc9MxMVzedUuM5QgA47wioKccyg4lwveYkGj1q0CXl9i86a49p67AABrXn0zrH49EeGNvKM878c5cNaICIxIm4Po+Dgc3ZWBbxe847eyCSIUYH46iaHttVfjJmnP0K/mzjftZr1VQQYc4TXBnAf3n2efgtVmw95N6di/eUvA6yMIfxGIHeVvm/AMmrZvi4u5eVj27GQIFfSDhggv/HGCSb2mTXDfyzPA8zy2rPoaW1Z97S/1Qgoy4AivkefBNWnXJqD1tOl+JTr06gF7eQXWvPx6QOsiCH/j7w1Juw0aiO533wZBELB8wnSa90aEJUI1V29HREfjwTfmISY+Hkd3Z+DLOWn+VC+kIAOO8JrjGX8DAFqkXhawOixWK26fOBYAsGnlqrDYs4eoWcj7WfnDgGtyaRvcKe33tu6dD3EgfWu1yySIUKS6P3yGzp6MpEtaIf9sDpY8Mwn28nJ/qhdSkAFHeM3RXeKu4kltWiFS2sTS3/S4bwgapCSj4FwufnyHjswizIc8X5Ov5n5WsXVq44EFL8EWGYm/f92En2m/NyKMqc5ZqH0fewCp/Xujorwci5+ZiPyz7o9NMzNkwBFek382B+dOZoK3WJCc2sHv5ddp1FDZNuTb195GycVCv9dBEIHGHyNw8tmNCY2TkHP8JD55YaZSLkGEI772mw43XIebRouLFr6c/QqO7d7jd91CDTLgCJ84uks8sqdF505+L/v2SWMRGRONf7fvxLY13/u9fIIIBoorqBr7Wd0y7v/Q5upuKC0qwqKnx6M4v8Bf6hFESCKPXHtzEkPDVim4d+50AMDmlV/gzy+/CYRqIQcZcIRPyG7UlK6pfi039cY+6NjrelSUl+OLWa/QaANhWqq7n9WVt9+qbNb7yaSZOH3osN90I4hQxdvV29Hx8XjojZcRVSsWh/63A6vnvRZI9UIKMuAInzi0dTsAoGXXVERER/mlzFoJdZWFCz9/sATZ/x7xS7kEYQTV2Qeu5RVdcOeU5wCIp49k/LzRr7oRRKiinGDigQHHWy0YkfYiEps3xbmTmVg6dlKN2lqHDDjCJ84cOYZzJ0/BGhGB1lde4Zcy7542HnH1EpB54BB+/mCJX8okCKPwdQSuQUoyHnz9JVhtNuz6YT1+fPejQKhHECGJfIawJ4sYbp84DpdcfQVKCgvx0VPPo/D8hUCrF1KQAUf4zN7f0wEAl/boXu2yrr77NnTs3RMV5eVYMXEG7BUV1S6TIIzEl7NQ4xvUx6PvvibuYbUrA59Mnh0o9QgiJFFH4Koeue5x3xBcM/h2cV/E8dNx+uC/wVAvpCADjvCZvb//AQBo3/NaryacOpLUpjVuGz8GAPD96+8i68Ahf6hHEIbi7Vye2Lp18Pj7ryOhcRLOHDmGj0Y/h4rS0kCqSBAhhyf9pkOvHvjPc08BANamvVVjzwMmA47wmUNbd6C44CLqNGqIlld08amM6Ph4PPi6uMfVP79txsaln/hZS4IwBm9W08XWqY3H338djVql4PzpbLz/+Jga5w4iCEBdvW2xWp3GN+vYHvfNmwme5/HHp1/W6HcGGXCEz1SUlmLXD+sBAFfefovX+XmrBfenzUa9pk2Qc+IkVkykPa6I8EF+lt3N5YlLrIeRH72NJu3aID/nHBY+Mhp5WaeDoSJBhByFFy7AXi5OoYlvUF8Xl9AkCQ+/9QoioqOwd1M6vpo73wgVQwYy4IhqsfUrcb+dTn17ITo+3qu8d0+dgDZXd0NJYSEWj5mA4vz8QKhIEIYgSPM4q1qlndi8Kf5v6btIuqQVLpw5i3ceHIWcYyeCpSJBhBxChR3nTp4CADRMSVauR8fH4+G30xBXLwGn9h3AsnGTlVHumgoZcES1OJ7xD07tPYCI6Cj0fmiYx/luGft/uPL2WyDY7fj4uanIOlDzJqAS4U324aMAxDmezmjRuRNGL3sfic2aIufESbw14gmcPXo8iBoSRGhy5shRAOKKbACwRkTgwTdeUqYYfPjksygtKjJQw9CADDii2nz/1vsAgOvuHYw6DRtUmZbjONz67Gj0elA09j6f/pKyGIIgwomT/+wDADRt365S3NV3DcLIj95CrYS6OPH3Xrw1/HHknswMtooEEZKcOXIMgGjAcRyHe+ZMRavLu6C44CI+GDUO+WfOGqxhaGAaA27SpEnYvHkzCgsLkZeX53G+GTNmIDMzE0VFRfjpp5/QurXzX8OE7+z9bTOO7NiNiOgo3PfKLJeTTyOiozFs3gzcMOJeAMCXc9KwdfXaYKpaI6G+Ywwn/9kPAKjfojkiY2IAANHxcRg2bwbunjYBVpsNu3/8Be88OAoF53KNVJUgQgrFgGvZArc+Oxqdb+wjHlA/ZkKN3C7EFaYx4CIiIvD5559j4cKFHud5/vnn8dRTT+GJJ57AVVddhcLCQqxbtw6RkZEB1LRm8snk2SjOL0BKl0548M2XEVNbPx/u0uuvxbhVS9Hlpn6wl1dg5ZTZ2PzJKoO0rVlQ3zGGi7l5yMs6DZ7nkZzaAVffNQjj16xE14H9IdjtWPva21j27GSUFZcYrSpBhBTZkgHX5upu6Hn/PQCAlZNnKycAESrMTGHEiBEsLy/Po7SZmZls3LhxihwfH8+Ki4vZkCFDPK4vLi6OMcZYXFyc4fce6qHddVezuVs3sLSMdDbnz1/YQ2++woa/MotN+v4LlpaRztIy0tnkH79iLS/vbLiu3oRweQaC2XfCpc2q3eavzVWefTk8//UnrPll7Q3XLdCBngFqN19DdHycrs/0enCY4TqF4jNgmhE4b0lJSUFSUhLWr1+vXMvPz8eff/6J7t1dnxwQERGBuLg4XSA8Y9+mLXhrxOM4te8AImOi0eGG69B5QF/Ua9oYpUVF+OW/S/HqncNxePsuo1UlqsDXvkNU5ujOv5S/z2efwep5C5B253Acz/jHQK0IIrQpzi9A7qksAMDGZSuxYdFygzUKTZxPVgoDGjVqBADIzs7WXc/OzlbinDFx4kRMnz49kKqFNaf2HsD8u0cgObUjmrRrA4vVipwTp3Bo6zaUl9Cu8mbAl74TERGhc6/SDx+RzSu/QHHBReRlZuHw9l10RBxBeMiip8ejXtPGyPh5o9GqhCyGjsDNnTsXjLEqQ9u2bYOuU3x8vBKaNGkS1PrDhWO79+CPT7/E78s/w97fNpPx5mdCre9MnDgR+fn5Sjh16lTQ6g5lKsrKsPWrb3Dwz21kvBGEF2TuP0jGmxsMHYFLS0vD4sWLq0xz+PBhn8o+fVrcybxhw4bK37K8a9cul/nKyspQVlbmU50EESxCre/MnTsX8+eru6LHxcWREUcQBBFADDXgcnJykJOTE5Cyjxw5gqysLPTp0we7d+8GIL5UrrrqKq9W4xFEKBJqfYd++BAEQQQX0yxiaNasGVJTU9G8eXNYLBakpqYiNTUVsbGxSpq9e/fitttuU+QFCxZg8uTJuPXWW9GxY0csXboUmZmZWL16dfBvgCAMgvoOQRBEeGL4kllPwqJFi5gzevbsqaRhjLERI0bo8s2YMYNlZWWx4uJi9tNPP7FLLrkkIMt5KYRvMPszYETfMXubUah+oGeA2o1CYJ8BTvqDcEFcXBzy8/PRpEkTFBQUGK0OYQDyfK74+Hh6BjyE+g1B/cY3qO8QnvadsN1GxF/I2yHQhGwiLi6OvlA9hPoNIUP9xjuo7xAy7voOjcB5QOPGjSs1omwhh/uvpJpyn0DV9xoXF4fMTDps3Btqcr8Bas69Ur/xPzW579SU+wSq33doBM4DqmrEgoKCsH/IgJpzn4Dze60p9+5PqN+I1JR7pX7jP6jv1Jz7BHzvO6ZZhUoQBEEQBEGIkAFHEARBEARhMsiA85HS0lJMnz4dpaXhfURUTblPoGbdq1HUpDauKfdaU+7TaGpKO9eU+wSqf6+0iIEgCIIgCMJk0AgcQRAEQRCEySADjiAIgiAIwmSQAUcQBEEQBGEyyIDzA5MmTcLmzZtRWFiIvLw8o9XxK6NGjcKRI0dQXFyMLVu2oFu3bkar5Hd69OiBNWvW4NSpU2CMYdCgQUarVGMI175D/YYIJOHabwDqO95ABpwfiIiIwOeff46FCxcarYpfGTx4MObPn48ZM2aga9eu2L17N9atW4f69esbrZpfiY2Nxe7du/Hkk08arUqNIxz7DvUbItCEY78BqO/4QpWn3VPwPIwYMYLl5eUZroe/wpYtW9ibb76pyBzHsZMnT7Lx48cbrlugAmOMDRo0yHA9aloIp75D/YZCsEI49RuA+o63gUbgCKfYbDZcfvnlWL9+vXKNMYb169eje/fuBmpGEKEL9RuC8A3qO95DBhzhlMTERFitVmRnZ+uuZ2dno1GjRgZpRRChDfUbgvAN6jveQwacC+bOnQvGWJWhbdu2RqtJECEH9R2C8B7qN4S3WI1WIFRJS0vD4sWLq0xz+PDh4ChjADk5OaioqEDDhg111xs2bIjTp08bpBVhBmpy36F+Q/hKTe43APUdXyADzgU5OTnIyckxWg3DKC8vx/bt29GnTx98/fXXAACO49CnTx+89dZbBmtHhDI1ue9QvyF8pSb3G4D6ji+QAecHmjVrhoSEBDRv3hwWiwWpqakAgEOHDqGwsNBg7Xxn/vz5WLJkCbZt24atW7dizJgxiI2NxaJFi4xWza/ExsaidevWipySkoLU1FTk5ubixIkTBmoW/oRj36F+Q/0m0IRjvwGo7/jSdwxfRmv2sGjRIuaMnj17Gq5bdcOTTz7Jjh49ykpKStiWLVvYlVdeabhO/g49e/Z0+vktWrTIcN3CPYRr36F+Y7x+4RzCtd8A1He8KYeT/iAIgiAIgiBMAq1CJQiCIAiCMBlkwBEEQRAEQZgMMuAIgiAIgiBMBhlwBEEQBEEQJoMMOIIgCIIgCJNBBhxBEARBEITJIAOOIAiCIAjCZJABRxAEQRAEYTLIgCMIgiAIgjAZZMARBEEQBEGYDDLgCIIgCIIgTAYZcIRTEhMTkZWVhYkTJyrXunfvjtLSUvTu3dtAzQgidKF+QxC+QX3HNzw69Z5CzQs33XQTKy0tZZdffjmrVasWO3ToEEtLSzNcLwoUQjlQv6FAwbdAfce7wEl/EIRT3nrrLfTt2xfbtm3DZZddhm7duqGsrMxotQgipKF+QxC+QX3HOwy3IimEboiKimKHDh1ipaWlrGPHjobrQ4GCGQL1GwoUfAvUdzwPNAeOqJJWrVqhcePG4HkeLVq0MFodgjAF1G8Iwjeo73gOuVAJl9hsNmzduhW7du3C/v37MWbMGFx22WU4e/as0aoRRMhC/YYgfIP6jvcYPgxIITTDyy+/zA4fPszi4uIYx3Hst99+Y998843helGgEMqB+g0FCr4F6jteB8MVoBCCoWfPnqysrIxde+21yrXk5GR2/vx59sQTTxiuHwUKoRio31Cg4FugvuN9IBcqQRAEQRCEyaBFDARBEARBECaDDDiCIAiCIAiTQQYcQRAEQRCEySADjiAIgiAIwmSQAUcQBEEQBGEyyIAjCIIgCIIwGWTAEQRBEARBmAwy4AiCIAiCIEwGGXAEQRAEQRAmgww4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJk/D88vrGnBuu2ygAAAABJRU5ErkJggg==",
+                        "text/plain": [
+                            "<Figure size 640x480 with 5 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "# visualization\n",
+                "epochs = config[\"data\"][\"train\"][\"epochs\"]\n",
+                "visual(model, epochs=epochs, resolution=config[\"summary\"][\"visual_resolution\"])"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3.9.0 ('py39')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.9.0"
+        },
+        "orig_nbformat": 4,
+        "vscode": {
+            "interpreter": {
+                "hash": "57ace93c29d9374277a79956c3f1b916d7d9a05468d906842f9921d0d494a29f"
+            }
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 2
+}
diff --git a/MindFlow/applications/burgers1d/burgers1D_CN.ipynb b/MindFlow/applications/burgers1d/burgers1D_CN.ipynb
new file mode 100644
index 000000000..48dd04676
--- /dev/null
+++ b/MindFlow/applications/burgers1d/burgers1D_CN.ipynb
@@ -0,0 +1,470 @@
+{
+    "cells": [
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# 一维Burgers问题\n",
+                "\n",
+                "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/master/mindflow/zh_cn/physics_driven/mindspore_burgers1D.ipynb)&emsp;[![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/master/mindflow/zh_cn/physics_driven/mindspore_burgers1D.py)&emsp;[![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/master/docs/mindflow/docs/source_zh_cn/physics_driven/burgers1D.ipynb)\n",
+                "\n",
+                "## 环境安装\n",
+                "\n",
+                "本案例要求 **MindSpore >= 2.0.0** 版本以调用如下接口: *mindspore.jit, mindspore.jit_class, mindspore.data_sink*。具体请查看[MindSpore安装](https://www.mindspore.cn/install)。\n",
+                "\n",
+                "此外，你需要安装 **MindScience >=0.1.0** 版本。如果当前环境还没有安装，请按照下列方式选择后端和版本进行安装。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "mindscience_version = \"0.1.0\"  # update if needed\n",
+                "!pip uninstall -y mindscience\n",
+                "!pip install mindscience==$mindscience_version"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 概述\n",
+                "\n",
+                "计算流体力学是21世纪流体力学领域的重要技术之一，其通过使用数值方法在计算机中对流体力学的控制方程进行求解，从而实现流动的分析、预测和控制。传统的有限元法（finite element method，FEM）和有限差分法（finite difference method，FDM）常囿于复杂的仿真流程（物理建模，网格划分，数值离散，迭代求解等）和较高的计算成本，往往效率低下。因此，借助AI提升流体仿真效率是十分必要的。\n",
+                "\n",
+                "在经典理论与结合计算机性能的数值求解方法的发展趋于平缓的时候，近年来机器学习方法通过神经网络结合大量数据，实现流场的快速仿真，获得了接近传统方法的求解精度，为流场求解提供了新思路。\n",
+                "\n",
+                "伯格斯方程（Burgers' equation）是一个模拟冲击波的传播和反射的非线性偏微分方程，被广泛应用于流体力学，非线性声学，气体动力学等领域，它以约翰内斯·马丁斯汉堡（1895-1981）的名字命名。本案例采用MindFlow流体仿真套件，基于物理驱动的PINNs (Physics Informed Neural Networks)方法，求解一维有粘性情况下的Burgers方程。"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 问题描述\n",
+                "\n",
+                "Burgers'方程的形式如下：\n",
+                "\n",
+                "$$\n",
+                "u_t + uu_x = \\epsilon u_{xx}, \\quad x \\in[-1,1], t \\in[0, T],\n",
+                "$$\n",
+                "\n",
+                "其中$\\epsilon=0.01/\\pi$，等号左边为对流项，右边为耗散项，本案例使用迪利克雷边界条件和正弦函数的初始条件，形式如下：\n",
+                "\n",
+                "$$\n",
+                "u(t, -1) = u(t, 1) = 0,\n",
+                "$$\n",
+                "\n",
+                "$$\n",
+                "u(0, x) = -sin(\\pi x),\n",
+                "$$\n",
+                "\n",
+                "本案例利用PINNs方法学习位置和时间到相应物理量的映射$(x, t) \\mapsto u$，实现Burgers'方程的求解。"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 技术路径\n",
+                "\n",
+                "MindFlow求解该问题的具体流程如下：\n",
+                "\n",
+                "1. 创建数据集。\n",
+                "2. 构建模型。\n",
+                "3. 优化器。\n",
+                "4. Burgers1D。\n",
+                "5. 模型训练。\n",
+                "6. 模型推理及可视化。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import time\n",
+                "\n",
+                "import numpy as np\n",
+                "import sympy\n",
+                "\n",
+                "import mindspore\n",
+                "from mindspore import context, nn, ops, Tensor, jit, set_seed\n",
+                "from mindspore import dtype as mstype\n",
+                "from mindspore import load_checkpoint, load_param_into_net"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "下述`src`包可以在[applications/physics_driven/burgers/src](https://gitee.com/mindspore/mindscience/tree/master/MindFlow/applications/physics_driven/burgers/src)下载。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from mindscience.pde import Burgers, sympy_to_mindspore\n",
+                "from mindscience.models import MultiScaleFCSequential\n",
+                "from mindscience.utils import print_log\n",
+                "from mindscience.utils import load_yaml_config\n",
+                "\n",
+                "from src import create_training_dataset, create_test_dataset, visual, calculate_l2_error\n",
+                "\n",
+                "set_seed(123456)\n",
+                "np.random.seed(123456)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# set context for training: using graph mode for high performance training with GPU acceleration\n",
+                "context.set_context(mode=context.GRAPH_MODE, device_target=\"GPU\", device_id=0)\n",
+                "use_ascend = context.get_context(attr_key='device_target') == \"Ascend\""
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# load configurations\n",
+                "config = load_yaml_config(\"configs/burgers.yaml\")"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 创建数据集\n",
+                "\n",
+                "本案例根据求解域、初始条件及边值条件进行随机采样，生成训练数据集与测试数据集，具体设置如下：\n",
+                "\n",
+                "下载测试数据集： [physics_driven/burgers_pinns/dataset](https://download.mindspore.cn/mindscience/mindflow/dataset/applications/physics_driven/burgers_pinns/dataset/) 。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# create training dataset\n",
+                "burgers_train_dataset = create_training_dataset(config)\n",
+                "train_dataset = burgers_train_dataset.create_dataset(batch_size=config[\"data\"][\"train\"][\"batch_size\"],\n",
+                "                                                     shuffle=True,\n",
+                "                                                     prebatched_data=True,\n",
+                "                                                     drop_remainder=True)\n",
+                "# create test dataset\n",
+                "inputs, label = create_test_dataset(config[\"data\"][\"root_dir\"])"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 构建模型\n",
+                "\n",
+                "本例使用简单的全连接网络，深度为6层，激发函数为`tanh`函数。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# define models and optimizers\n",
+                "model = MultiScaleFCSequential(in_channels=config[\"model\"][\"in_channels\"],\n",
+                "                               out_channels=config[\"model\"][\"out_channels\"],\n",
+                "                               layers=config[\"model\"][\"layers\"],\n",
+                "                               neurons=config[\"model\"][\"neurons\"],\n",
+                "                               residual=config[\"model\"][\"residual\"],\n",
+                "                               act=config[\"model\"][\"activation\"],\n",
+                "                               num_scales=1)\n",
+                "if config[\"model\"][\"load_ckpt\"]:\n",
+                "    param_dict = load_checkpoint(config[\"summary\"][\"ckpt_dir\"])\n",
+                "    load_param_into_net(model, param_dict)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 优化器"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 7,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# define optimizer\n",
+                "optimizer = nn.Adam(model.trainable_params(), config[\"optimizer\"][\"learning_rate\"])"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Burgers1D\n",
+                "\n",
+                "下述`Burgers1D`将Burgers 1-D问题同数据集关联起来，包含3个部分：控制方程，边界条件和初始条件。\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 8,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "class Burgers1D(Burgers):\n",
+                "    def __init__(self, model, loss_fn=nn.MSELoss()):\n",
+                "        super(Burgers1D, self).__init__(model, loss_fn=loss_fn)\n",
+                "        self.ic_nodes = sympy_to_mindspore(self.ic(), self.in_vars, self.out_vars)\n",
+                "        self.bc_nodes = sympy_to_mindspore(self.bc(), self.in_vars, self.out_vars)\n",
+                "\n",
+                "    def ic(self):\n",
+                "        ic_eq = self.u + sympy.sin(np.pi * self.x)\n",
+                "        equations = {\"ic\": ic_eq}\n",
+                "        return equations\n",
+                "\n",
+                "    def bc(self):\n",
+                "        bc_eq = self.u\n",
+                "        equations = {\"bc\": bc_eq}\n",
+                "        return equations\n",
+                "\n",
+                "    def get_loss(self, pde_data, ic_data, bc_data):\n",
+                "        pde_res = self.parse_node(self.pde_nodes, inputs=pde_data)\n",
+                "        pde_loss = self.loss_fn(pde_res[0], Tensor(np.array([0.0]), mstype.float32))\n",
+                "\n",
+                "        ic_res = self.parse_node(self.ic_nodes, inputs=ic_data)\n",
+                "        ic_loss = self.loss_fn(ic_res[0], Tensor(np.array([0.0]), mstype.float32))\n",
+                "\n",
+                "        bc_res = self.parse_node(self.bc_nodes, inputs=bc_data)\n",
+                "        bc_loss = self.loss_fn(bc_res[0], Tensor(np.array([0.0]), mstype.float32))\n",
+                "\n",
+                "        return pde_loss + ic_loss + bc_loss"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 模型训练\n",
+                "\n",
+                "使用**MindSpore >= 2.0.0**的版本，可以使用函数式编程范式训练神经网络。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 9,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def train():\n",
+                "    '''Train and evaluate the network'''\n",
+                "    problem = Burgers1D(model)\n",
+                "\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\n",
+                "\n",
+                "    # the loss function receives 3 data sources: pde, ic and bc\n",
+                "    def forward_fn(pde_data, ic_data, bc_data):\n",
+                "        loss = problem.get_loss(pde_data, ic_data, bc_data)\n",
+                "        if use_ascend:\n",
+                "            loss = loss_scaler.scale(loss)\n",
+                "\n",
+                "        return loss\n",
+                "\n",
+                "    grad_fn = ops.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=False)\n",
+                "\n",
+                "    # using jit function to accelerate training process\n",
+                "    @jit\n",
+                "    def train_step(pde_data, ic_data, bc_data):\n",
+                "        loss, grads = grad_fn(pde_data, ic_data, bc_data)\n",
+                "        if use_ascend:\n",
+                "            loss = loss_scaler.unscale(loss)\n",
+                "            is_finite = all_finite(grads)\n",
+                "            if is_finite:\n",
+                "                grads = loss_scaler.unscale(grads)\n",
+                "                loss = ops.depend(loss, optimizer(grads))\n",
+                "            loss_scaler.adjust(is_finite)\n",
+                "        else:\n",
+                "            loss = ops.depend(loss, optimizer(grads))\n",
+                "        return loss\n",
+                "\n",
+                "    epochs = config[\"data\"][\"train\"][\"epochs\"]\n",
+                "    steps_per_epochs = train_dataset.get_dataset_size()\n",
+                "    sink_process = mindspore.data_sink(train_step, train_dataset, sink_size=1)\n",
+                "    for epoch in range(1, 1 + epochs):\n",
+                "        # train\n",
+                "        time_beg = time.time()\n",
+                "        model.set_train(True)\n",
+                "        for _ in range(steps_per_epochs):\n",
+                "            step_train_loss = sink_process()\n",
+                "        print_log(f\"epoch: {epoch} train loss: {step_train_loss} epoch time: {(time.time() - time_beg)*1000 :.3f} ms\")\n",
+                "        model.set_train(False)\n",
+                "        if epoch % config[\"summary\"][\"eval_interval_epochs\"] == 0:\n",
+                "            calculate_l2_error(model, inputs, label, config[\"data\"][\"train\"][\"batch_size\"])"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "burgers: u(x, t)*Derivative(u(x, t), x) + Derivative(u(x, t), t) - 0.00318309897556901*Derivative(u(x, t), (x, 2))\n",
+                        "    Item numbers of current derivative formula nodes: 3\n",
+                        "ic: u(x, t) + sin(3.14159265358979*x)\n",
+                        "    Item numbers of current derivative formula nodes: 2\n",
+                        "bc: u(x, t)\n",
+                        "    Item numbers of current derivative formula nodes: 1\n"
+                    ]
+                },
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "epoch: 100 train loss: 0.42995507 epoch time: 63.536 ms\n",
+                        "    predict total time: 243.24369430541992 ms\n",
+                        "    l2_error:  0.8788317251751688\n",
+                        "=================================================================================================\n",
+                        "epoch: 200 train loss: 0.41935205 epoch time: 62.145 ms\n",
+                        "    predict total time: 7.87043571472168 ms\n",
+                        "    l2_error:  0.88964679457787\n",
+                        "=================================================================================================\n",
+                        "epoch: 300 train loss: 0.42547783 epoch time: 62.736 ms\n",
+                        "    predict total time: 7.727861404418945 ms\n",
+                        "    l2_error:  0.8895206005088669\n",
+                        "=================================================================================================\n",
+                        "epoch: 400 train loss: 0.4227412 epoch time: 62.124 ms\n",
+                        "    predict total time: 7.363557815551758 ms\n",
+                        "    l2_error:  0.8889956873924331\n",
+                        "=================================================================================================\n",
+                        "epoch: 500 train loss: 0.41943315 epoch time: 62.960 ms\n",
+                        "    predict total time: 4.832983016967773 ms\n",
+                        "    l2_error:  0.8881562175445344\n",
+                        "=================================================================================================\n",
+                        "...\n",
+                        "=================================================================================================\n",
+                        "epoch: 14600 train loss: 0.00013843024 epoch time: 62.264 ms\n",
+                        "predict total time: 5.646228790283203 ms\n",
+                        "l2_error:  0.004415987361258303\n",
+                        "=================================================================================================\n",
+                        "epoch: 14700 train loss: 7.498202e-05 epoch time: 62.589 ms\n",
+                        "    predict total time: 5.714178085327148 ms\n",
+                        "    l2_error:  0.004421070906100957\n",
+                        "=================================================================================================\n",
+                        "epoch: 14800 train loss: 0.00018732375 epoch time: 61.509 ms\n",
+                        "    predict total time: 6.393909454345703 ms\n",
+                        "    l2_error:  0.05152295200248691\n",
+                        "=================================================================================================\n",
+                        "epoch: 14900 train loss: 0.00013548511 epoch time: 62.688 ms\n",
+                        "    predict total time: 6.286382675170898 ms\n",
+                        "    l2_error:  0.004916392108302118\n",
+                        "=================================================================================================\n",
+                        "epoch: 15000 train loss: 0.00011926594 epoch time: 61.978 ms\n",
+                        "    predict total time: 5.469322204589844 ms\n",
+                        "    l2_error:  0.004314286890692662\n",
+                        "=================================================================================================\n",
+                        "End-to-End total time: 944.745542049408 s\n"
+                    ]
+                }
+            ],
+            "source": [
+                "start_time = time.time()\n",
+                "train()\n",
+                "print_log(\"End-to-End total time: {} s\".format(time.time() - start_time))"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## 模型推理及可视化\n",
+                "\n",
+                "训练后可对流场内所有数据点进行推理，并可视化相关结果。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 11,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnAAAAHWCAYAAAD3vrTNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e9RtSVUeDj+z1t77Pe85ffrGpZtubBpoLgFbCZI4CDK8EPJpevgLGeanDNTwYRKDJATkkyj4abg4JDiGDSomDDAC3jUaMd7AoMj4ftooF0FEbRqaa9/vffqc9917r6r5/VFzVs2qtda+nfOePm+za4zu9zx7zppVa61aq+aaT81aBICxLduyLduyLduyLduyLYemuAe7A9uyLduyLduyLduyLduyXtk6cNuyLduyLduyLduyLYesbB24bdmWbdmWbdmWbdmWQ1a2Dty2bMu2bMu2bMu2bMshK1sHblu2ZVu2ZVu2ZVu25ZCVrQO3LduyLduyLduyLdtyyMrWgduWbdmWbdmWbdmWbTlkZevAbcu2bMu2bMu2bMu2HLKydeC2ZVu2ZVu2ZVu2ZVsOWdk6cNuyLduyLduyLduyLYesbB24bdmWbdmWbdmWbTmU5dnPfjb+9//+37jpppvAzPgX/+JfLK3z9V//9fjIRz6C/f193HDDDXjhC194Fnp65svWgduWbdmWbdmWbdmWQ1mOHTuGj3/84/gP/+E/rKR/5ZVX4vd///fx/ve/H0972tPw5je/GT/3cz+Hf/bP/tkB9/TMF8L2Y/bbsi3bsi3bsi3bcsgLM+N5z3sefud3fmdQ57/+1/+Ka665BldffXX67Vd/9Vdx4YUX4lu+5VvORjfPWBk92B04DOWyyy7DiRMnHuxubMu2bMu2bMu2rF2OHz+Om2+++ay0tbOzg8lkckZtTqdTzGazM2Lrmc98Jt73vvcVv733ve/Fm9/85jNi/2yWrQO3pFx22WW46aabHuxubMu2bMu2bMu2bFwuv/zyA3fidnZ2sP/ZzwKPetTGNk6cOIHjx48Xv73mNa/Ba1/72tPtHgDg0ksvxW233Vb8dtttt+GCCy7AkSNHsL+/f0baORtl68AtKRp5u/zyy7dRuG3Zlm3Zlm05VOX48eO46aabzsr8NZlMovP2mCuA++9f38D55+P457/QmW+n0+kZ7OVDp2wduBXLiRMnTvsGIOcwOb6L+cl9hNavjGcP7IF96OLGYXLeCvjEHjgEuFGD8bEjp42n958CmOHGI4yP7izGuxNMT+wBzGgmI4yOrIDvPwUAXbwzxmhnXOBmMsLsxF4vHh2ZwI2bxXjUYPaA4N0duMYN4vHRHYAI85P7q+FjRwBmzE9NBzEHRrsX8eS8XQQfFuPWo92PVMLk+C7CfDH2sxZ+Ou/FO+cfRTudl3h/Bj9ru5gIO8d3O3i+N0OYCz7/KOanpuvhNe+Fg7o3zvi9ssq9scm9ssa9seheOdP3xmh3B+TO7L1h8Ur3hsXnwL1xxu6Vw1j2TwLTUxvUawCcmfl2qNx666245JJLit8uueQS3HfffYcq+gYcMgfu2c9+Nl75ylfia77ma3DZZZctXawIxHTha6+9Fk996lPxxS9+ET/2Yz+Gd73rXWepx7Ecffj5eNYP/t94+r/9f+HIhcfgZ3Pc/elbcMEVj8DkvF200znu+cwtuOAxj8Tk2BG0+zPc/ZlbcOFjL8HkaMT33HgrLrzyEoyP7mC+P8O9N96KCx97Cca7O5jvTXHvZ2/DhY+9FOPdCWanprjvc7fhosdditGRCWYn93Hf527HRVc9CqOdMWYP7OO+L9yOix6veA/3feEOXHzVZWgmI0xPnML9X7wTFz/hMjTjEab3n8L9X8p4/76TOHHz3VF/3CT8sCdcBjdqsH/vA3jg1ntw8VUR793zAE7edg8ufsLlcI3D3t0ncPKO+6K8cTh11/04def9Gd95P07ddT8e9oTLQY5w8o77sH/PA7j4qsv68e33Yv++U3jYEy4DADxw2z2YndjDxVdFfOKWezA/tY+LHx/D+iduvgvzvVnC9990F/x0josed2k//tKd8HOPix4bb/r7vngH2AdceKXBgXHhYx4JALj3C7eDAFxwheDP3w4iwgVXPCLiz90Gahpc8BUPBwDc89nb0IwbnP/oiO++8VaMdsY4//KHRfyZWzDe3cHxyy7O+OgOjj9K8KdvxuS8XZx36UUAgLs+fTN2ju/ivEsE33ATjlxwDMceeSE4MO7+9M04ctF5OPaIC3rxXTfchKMPPx9HH3Y+gg+4+9M349gjLsDuxccjvuFmHHukYo+7b7gZ5116EY5ceB5C63HXDTfj+KMuxpELj2V82cU4csEx+HmLuz99M86//OHYOf8o/EzwVzwCO8d34Wdz3CX3xs55u/le0XtjOsfdn765uDfu/sytuOix+d645zO34qLH5XvjnhvjvTDenSR88ePl3jg1xb2fvRUXX3VZvBdO7uPez92Oi/VeObmP+z6f75V0b+i9Ut8b95/CiZvuxMVXXd57b+zd+wAeuOWe7r1i743b78PFT5B74e77ceqO7r2R8X3Yu3v43njgtnsxvd/cG7feg+mJvYRP3Ho35g9McfFVcm/ccjfmp6b53rj5bvj9KS56nN4rd8JPW3Ov3Ak/a3HRY/O9Elo/eG/c94U7AHB5bzjCBV+R7w3XNDh/4N6458Zb0Zh7454bb8XoyBjHLzP3SnFv3ILJeUfSvXH3p2/GpLg3bsaRC47i2CMvHL5XLj4Pxx5u7o2HnY+jD8/3xtGHX4CjDzvec6943H3DLTh2yYXYveg8BO9x16duxvFHVfdKcW/cgvMvf1i8N+Yt/vY3/wz/z4//Om7/m8/X08q5XUYU/9uk3gGX6667Dv/8n//z4rfnPve5uO666w687TNdDlUW6jd/8zfjWc96Fj7ykY/gt3/7t5c6cFdeeSX+5m/+Bm9961vxcz/3c3jOc56DN7/5zbjmmmvwR3/0Ryu1efz4cdx///04//zzN3ojOO/Si/BvrvtJnP/oh8ONmvQ7M4OItrgHM8chuSp+MPp7JsuDca6Bxef3XBkLW7y9N861e6PGB9mf0Hr4uccv/bP/L77w/3yy9xwtK6c7h23SFq68BHhgg7bOOw587ra1+nrs2DFcddVVAICPfexj+P7v/368//3vx913340vfvGL+PEf/3Fcfvnlaa839Qt+9md/Fj//8z+Pb/qmb8JP//RPr+UXnCvlUDlwtpytdOHTHfzf9qv/GU/5v58N12y33NuWbdmWbdmW9QoHxgO33oM3XfFCsA9r139QHLjHP2pzB+4zt6zV16//+q/Hn/7pn3Z+f+c734kXvehFeMc73oErr7wS3/iN31jUedOb3oSnPOUp+NKXvoTXv/71Z52ZOxPlUFGo65YHO1346MPP3zpv27It27It27JxIUc4ftnFeMK3PAOf+r2/fLC7s1qZNPG/TeqtWT7wgQ8sjAC/6EUv6q3z9Kc/fe22zrXykHbgNkkXnkwm2NnZSbhOZ16nPOIpV2ydt23Zlm3Zlm05rcIMXPHsp24duG0pyta7qMqrXvUq3H///em/09kD7tijH3kGe7Yt27It27ItX67l4ic++sHuwuqlIWDk1v+vOfgkhodSeUg7cJukC7/hDW/A+eefn/67/PLLN25//9QMgePb07Zsy7Zsy7ZsyyaFCAgHlChyIEUjcJv8ty0rl4c0hbpJuvBsNjtjn+zwcNjnMY66+Rmxty3bsi3bsi1fXoXTf4fIgWtc/G+TetuycjlUDpxNFwaAxz72sfjqr/7qwXTht771rfiP//E/4o1vfGNKF/72b/92XHPNNWenwzu7eIDHIGYcQbkhI1EZmdviNTB106fPJayPWV5Bd4u3+MsJb++NzXDLBKZD5NxMGmC+XQN30OVQOXDPeMYzinThN73pTQByuvCjHvUoXHHFFUn+uc99Dtdccw3e9KY34WUvexm+9KUv4d/+23971vZ62d9rccpPMCLGDA12yMMhgEFoA2FEDAKDQZgHwngBrvVLDPiEgQDAB4cRhZVxm9oDAhhtcKZ91Y/vgZthkj0aV8MhkCyHYATBI0LqT2BCY453Uxxb6GJmwMlssy4OHB1OnazWwQQgcPzBbVB/E+yl72cTx3NNCzBS2RxzOl5tn78cMeJamUVYp81VMCOvvdFNLVbF/gxgvU/6cGuObRle9dw8uJjknBOC9ezO9TLekA4dbx24dcqhcuAOW7qw94yT7RhEwBHXIsBJJCneiS1ziiwFxIlnEW4HMctbWi13g5h7sG2vxNHxGZb3Y314b4q9wTByBDlvlf6qWB+EVt6HwwAOjOQI9mIAJOdifRyvpWOAN6rfxSz/W4R9VZ8XyBfhdK4fRAyU9wbOgD1/wHhorJ0RTAajkstfvyZ+sP/SAuwPCbbndhGOY5Ly8+8wlIY2S0jYJjGsVQ6VA3fYCk+O4uR8DAIjjAinMJIbWXbbFseIARCROEriDYgk38hDWNFifWufCHAJ1/Ke/mAdfYNDPp6Ma/kyzPGNVLAWwur29H8lBjggnQ+iiAHjmJwVzHASGVy9fjzKRZjVE1kb57G5Wf2zj9N0J+NPz0eUk5HX+ookrvtgYrNe4MxhRtMnp4xJ742FODuGhw/LvVGPnZ5zcbYxmXuNK7nF8WWeEPSN7jCUSQO0Wwr1oMvWgTvAMt+b44HpGA0xZr7BzsjDUXyYtMFh7ELEAObeYdQwHIRC9YRxI3ImtMFh1IQk94EwcgxKcsLYhYQ9i1z0W28wR8pybOrPQ2yPEOlEHwgjwczxt7GLHgKD4D1hlHC2B9HX/gHR8Yj9CZka8ITGCaXJjMBuAEcKlfV4EaMXYQEODIQQ18OSODaBTXs9mJE/w+ejL5ApXQZY9CH6AMHRZlgdLaVcW3EkFXsPcbLXxbk9AqXJzAeCE0d1HWz756r+NiQTEOK5d6QjYX3sDV2+HBN8QIm5pEyZF8k3xWlKXYojhTmEAWaG05MNgl+A1U/dDBPm0Y9Do3KwLE9QfZblA8tw7jszpbEQnQ2l+zm3n45Vj+rMYI12r4fprGIHhzTWDdZnlYNeC0JgRjOgH3G8yzwO2Rq4bRLDWSlbB+4ASztj7M9GaBywM2oREB98+tDznCnVAIL3hlJlwPuK4vSWgiWEUOqHkOXcK0eWF1h0FrQXJ+qSkvWhpIRZ7AWpHyw2/QucHSeVYyGOx7G6vmD5myKDnd9LbClRi+OE29V32ATHc6+ObK9+VFuIibuUrbrTSps55GspP62FwyLMKMZGxrV8NbwuPT9MScaxcjr2zgQePl55KSnkNIz13J8GBsrlFX24Xq6wDHONjUNHAAKVcvVPk4M1gHXsJgdO/lrMZwiz+e1M4kiBUg/Oa3CzPi3Q12tJMib0KA5BGbsN18BtHbh1ytaBO8ASJrs4OR2BKL7F7s3j6U6hc/MIsLiUx5veWUyo6sdaVm5xXNC8QB9WLvYX6Rf2a7lGg1albThGcxbI3UJ5V1/7v6p+QzFapRRt+lC1xQzTnxX0B7HUX1m/W5+IYuR0EaXKS+QJa39W1S+vRR8upyfOY5cr+WnjauyyyHh4bJ5ZXN0LK/WfOvJFFHExVtfGcm+top/G2jK8zlg9jXuDK/lauKRMH2xcUqYABu6VIRyTrhwCHyLnZtIAfkuhHnTZOnAHWNr9gJN7I4wcY9YGjEeMxgll2hLGI07USo1bHzFRfNB6TxiJnLmSI8v1+eCDYqFYPWEyyhRrqo8YDfCBMG4ypeoDEg5BKNpG+5PlEP3AiJQpRXo0sMihlG7caJuIEXyJ5yH2WbH3ai9i9vGtdSSUqGcCc6ZIA8eHZOOiY+V9xCMHQPqf5AD0e9A6WcwFNxT1OQBLKVPKNCKH6AY3K1KobTwtyb4PJE56PpcZ5+e9E0dSI3YNaaS1xEqppqzaAAAOzsWxFCOVQrGyULgkNJ9c24yV1rGU7BJc6c+E8lR7MSuVUlRzFZyc7ALL+VInXO87lcfDy/oGj3TiX4gZgNBc5NJYju0JDqZ9kki36e8qmIOMRTn/MeIb7YcQIzeb4nmIx6FjPcszBjGUBiwxJz+T4NKzog8rLdiH4+hfBVO6N5QSDulejX/1flCKODtHGWeKV7GTey+yEsBiTHDyXF2OfWC4FXFetytjG5mCHcZ6Xg5bEsOWQj0bZevAHWDx+3Oc2h/BOWBn7MHsE60RAiVqUB+8cYORiMFZzoL93Ogzwbe6aF8eFgnH/4U2v88FBrhNJF6cKFpOmFkWVlt5wvLgFB6FwaBaHwbLQ9zqA0gRnCRPWCjKBXL74qqUYs4m1YejYgCg5JixhBpKeUmVEuLEnQrlyUN/JjaYM60ExEQLpY2UvlL9EseDI5ft1/qJRhJ9pd/q7NlBzBZHEM9vnjQJZXtU2SMu63N1PFz1N5jAASNfI/3jWc+vHBxzSVUzluLaXroQRMW1S/IFuF2AUeA4tmJ9Sr/04t7+dTEW4uhcBbGvY3lTrP0rqc8Kc3Z+u5jNNhyZ5qvxsr+0Ji7GIsqxKMMnHVtZn6p7OUp8oh9LnPVLjDVwWBmL82b6p91chD0TAg4bhbphBG67jchaZevAHWCh0VGcOtXEB9AuYTofFTRejChE56VpOGG7AD1OUChwjM4oDjmaorhTf5E8wLn8wAaCWVCd7efCQgsM1eeqfo/+uvaXyG10JvUnYUamWfpwPn/9tIyhWAfkjpw4mH3yPn0C8er6Zf/ytRvCaQ8wK+eMYxu5vabSL+XLMDrtrVuf1tKvxgLsvdCVr4e79w6RM2OtHnvr4pCiqMP6LkWIN7Hfdy8Bq94LfdjBY82xvbL+uphQLmdYdq8uv1f0cmw2dtfHDtGXW6d+ykItru05XrbbiJyVsnXgDrC4GWP/gQZNw5kibRhgoG2B0QhwkgnZehg5Yd4CY5EDUT9hipmHowZwzgmlKnJyMaLg48uMc5p1GuU6IXmfcRD5xMiDj/1L+lof2d6okfptfOCPxAn1IdJ641GZFRr1KUb7mDFqgBgNEIqzMZEwBpwDSN48sz5LHRZ5g7m83cbouwP7qDUyWbHMQCMvd4mWcbH9UNQXGgksci7sx/5F77ARudJeqb68KScKlWM7TjY2jjMcpWsbgsUm69XWr/XFPsnxgUuKlpBxXF9EmZbiEreJ1hF96EtE1rfYB10HGPHMs1Cesb5mUTqKERrV78NqP6/TVAp1NUyI+ykqZjlfq+LyeBs59yzzSHSOIuW5Ig7RXnRkSDKcWbI6G7QJy9hOFGw/Bmd7al8pzi5uEo5DkRIlOoRr+6GyH+n0nGe6DLfi+KVMS4nUK47tWYpVHKkFOFKiq+G5hIPtWEalvxBD62+GPUd2oouxRK5js8bxOh3KbUTCdg3cQZetA3eAxU1naE42eICAyU5AOBLgXJwgOMj6CMHguL4iySuslKpmsUbHI2OlZG2Wq2bkqX7GSE4TJX1gyuXbXxDKNlT1uzger1KRsh4ZLF8P07fllH3F8U0/63OaXIFsT/yV3P8kj1GvBqWDZLNPk2Oj9gmJ0q3tBy4jGcnhMu33ydUOVB6s3KzjkfOqD2BG7I8zlCaQMTPL3GrqQx1Lg0msiUPS0ZfQG7OL28+Q9s9GKONYQOpfnG4dsaFMqaSExXGpca5vJ5/YL88lDgbrtdXpiRnFep/FmDv1s91VsDgMcnwMdTpkDInWEMWlv2Ws96bVp6p+SfkuxpyiTqn+QsozYl4ZW8q23x6vie292sWy3CAfnWgsxnbsrIJZx2I91lFSrAeB0YvJaK+in89fpGHdIXTgNnAvtg7cWmXrwB1gGdEOdk41YAJmTJjNmhiAcRLNkQcLuRh5UxyzLrPcOQa5LKdKTsQdfTco58o+99jryoEhfY2Eoeh/oe9KrJSbrV/LgbI/xd+19Ov+LdenJXK9dkB5vRSX/+bi3FgWpPfYxCsaPPYee7XcLZT32KPs8A72Z1A+0P7K+j39WVcf0ZndtL3F53v538XXY9Hf+l4Y+BvWs7fu8fhB+3IvrHlc9fiusTf3Rj1WF98bG/5dcC+e3b/rju34N0gCgzp3h6I4smsb1qu3LSuXrQN3gKWZOxx5gOCdQ9MSQsPxPyJQANAA1DA8XNwDbgSgYQQCvGc0IxIKNMpHI8A18aHnPdAIpcrI8jghO3CIlGSk3aK8SZRqjP6NVE4x2tc0ORMxYRdD91bOqPTRL7eUaWChQClHF6Ock3wschj9+PCVTEDBYR5pmUazTJXSbADNulVKFogzBnOkeAHKWZ+JsiSA4zpEIFMVKUuUc5YoEOlwUJlFCihlK/ZSfYk+cNYPEgFJFKnIM6Ur40dDXDqJygIaZtXXpBVKmFUOQkN5o+VEwXJFyaasV4JzAcxIUZN0bY0cHXlNEZssWpeUk7y232lPPAYKkmUqlGLMau3BhqJbRT9G2SJNFZ0jglKojnIW5xBGAJikPlBQjkRKbw9hqQ+dpwitUp7ivah+wt7KNeM5rzvUjGiSa9Sx50uMguKt65cYUIoWcCzXOlCB9fqmb5WG7NQOYUj/mUnofpPxrGNZw6HiwDq5BxjrYwQdVpJopRSrjAWEnPF8cDiOmZgdpGMPS7HeG+1ho1DHG1Ko2ySGtcrWgTvAQvv72D3ZIDRAO2bMdxjBrJsKo4hHHJ2s4CMmZowRnbhW8skdE4IHvOzO2lB0wry+XrJDKzOn7o2eN/KNTqBiCGaVIzp9Vh/soBvuxgeRg1KhkXAVrG/qFS7kQR05CM7yOMnpYvGMXYFz/TwpZkdBP/6eqEpJ3df2g6y5svYAmElYaCR5xw0BgIsY0Pbt1gZKbZtJlzJOWbVK56TzHHGKeKg9eTvXB3ao5EW0wsqDlaszghyxoSZerR45LNZJmBuw1S/6BwSf7TmRs22fc39A4jzILOySs1Xqd3EcG86xZDrL74SEQ4FlLC/Qtzjee2pfJ3wCOdMfgyH1QZkGQ9BtIUx9mZujby0rwjpYj0+dwlxf/KI0YRf+kXHKlX4vKc/sIJX6SP23OGtXDs6gPTOWO5iT85bGCmd7KePZ2kPZf71GVm7vJeu25OUIgqHPgMXY0v2U7HO6NgdJqUasY0+SjFQuxzmE9WP2gV16bh2Kst1G5KyUrQN3gKWhCXZPxgG5d17AWNaEBeL4ckIGO6TXWAaDXSn3BnNVn4G4vsnaa9g+p+MEQ/rvkgbU1+9MYXCpX9QXmWOjX8prTMZGrlDaAyr7GJLXf/PM1E/fLLOfT1OaxLjHfn08frF+ffzD9nMHrLy4Firzuf+u91gr/QH58Lnq17cUcZ/+svYISFusrNIekCewVfTthL1Mn4b0B3EeL4W8F2cj9fF2jn+gft+90jmeMCSXsbbwfA30Z2Cs1vXrsctC7y28dxbWX4apwPXxLR4bq40dbFx/s/bq9ZzL6nuJkodi1JzjZRuBOytl68AdYBn7MXYeIARHaLyDb4DQcIxsMCM0kVYFCGQwwwHMYEcITQCTi3IHBMcIFDfRZMEEAgVGcAR2QtEi6rMTAijuToogr8fMDDRRn9kBIVK4TAzv4oaTrhHaB0qRKo5RqGaERHtFylJpLRQ4ZWkaypQZCQdGgbOcezFCXT/ikdlYWOXQMAgy5gprcoBmlWokRilajYzZ+gSlXOPGwUCmYFXuFCtla/QT5hwlcI1EhaR/SqkmylQylPU5bilQi7W4isJVOl7dDEfaspWX+kDehiTLJZLgcjwJqGijhMlglqaG9LW9aD9GwfQa9uNESyFTqkDGUcSZljL6Tul30772RylQ1VcKVPUTJar6FLNybVbokD6SvkZTtb+UoqvRieNEWSrWa6dOnkakIFHqtKdgyPcG5JAJnJwH+5k3jR4Cub6Tfmp9xeipP4zN2EwhJsWVfg9mmHuhxsJExMhylgPr4Hrsy4k1awLPJE5jO41FVGOzi1nOow+aJHRIyrgBeOvAHXTZOnAHWfb3sLNHCI3DaAbMdwLYCQ3CDn4sTpfgMIpOm9IlYQQE10DX+PgGYJcnmNZgF1x0Bp1QhWI/Lu9iUIgULasc0p687hHnHfhH8pT0o9g/YsAJBatPFsVxxw0hIkbZPhJlqw5IRdGCslzspr96/MFSrFTUd6BkJ1GzhnaBTm7QbF5K2a4hMKjA8XIFswYtf/vUbKgsOGffantSv6JQnVKsYs/i+FwXHGKih6vqJypSrkvwWU5UZrHa/qCnfxaHECdAlm0zYkSDO/q6Pky3KMlydT5iJzVrVZ0DzVpNGxsHxdGZ0Z3xrdyJXFe0NbJezMplJTcCl1idwdhpIzezaIpYctme1c/9o5j4IhOo6lN1/OmTXexiRFr0WSnWIf1I8CePIoh+xupUlZR43jw7r2dkjtfJYo1QkbzI6PUke8/o+kkjh8FMOtah/nIa++oMUTH20ulNY7LEci6Q27XydOyr4rSMIt8rOiS0X4v7k80QYJYjsHFokZYbrIPzs6KLlUJNz4ywBKd+HrIs1O0+cGelbB24AywNj3DkVHyDne0Coza+XbBSptOoF4jjptVKoVaU6pB8J8llbZyhYEEAZrl+SdGKs2LkbChXhjywbf2CsuWCslV9PxOZRAZtxN9SiiXO0YQkF9v9+vEBmylgTkaGaJjF7S+neHv1B9vrHl9f+0CMkqT6ftP28mkuzh+G+0fIToLKC5qn6nsfDbSI9sEK9YcpRpmQB+Vd/WX27Lno62/dP/tVEJXb/pihn+tX+p3zVekPUZi2jUJeY87/BhRzdt4GxkqtX4/9QX2DM2XaHeur1Ae6xxsq+TrYm/O3yfHY/qjTW8grTKbnQ1hQcd1UvvoWOXp88iWGjrVzuGwjcGelbB24AyyjMMGR+wnBAU3IjhALJ8KElJWqK3872AFBUqpY5Pomz0KZsjx82FGkWDUFiyJmscdESN9DZtGX30na0olKJ0WlZEEQucnAE6zOHJOZmJjisZI8UBkxWqiZiQxAcKttyjq/TAkCIJvFGQ1ZClSCJmBG3ooFgvVbqsae3VOrX85F+3b/t1o/b+Rr+msiemnjYLa4onDTqzlSYoSVs5FH/TxZOKEUbX/YzChO7VM+HxqlBGt/c3SxXy6QM6Wa7DuzlkzljMpet36fHAyQUMDJMSWV53pRkPUSJSpRs5AcmZxlm/QdcqafUqyQa2oo1kxpIkVYIHp2Mu+Tp8lf/gZzPI6QEl4iLh02S4Hm+l1HPf2bjPMnXhUX+rySvh4LIV/PiPsp27q/emzFvSR9WESRwlKsTvq7lsPVxfZcs71XBnC6N9JYspgTbe9g9ENVvxdH4FbWX4BBsjn6IXLgGtowieEQHeM5ULYO3AEWnguFOgL8PjA/El9KGPGN3Y9hKFUawDoHE/zIyEOFObaTMBzaEctDOmI/ik+i+AYvDpbLj+kwSr5hXIoxgmQaRrkXDOaYFSvr+ZTS9UrJsvS/4WTPodJnXeNKkU4y9V1gow+hcAk8yrl7xJEKZTMpsawXUkoyiAOmFKxzOQvVUXbQSjklqtjqk9FnpX7TGjeuaBC5/oqNU6MOXlpzY7AGLUMY1mfIA944T7V+ucEyJeeJK/0huVf7+i1bdbaEwg3ibDlrzynFG6nWxjjCLHJOlKusnzMbKxMBJPUZsu2CHJNSnMlZB8kaKKnvqepvxF6+qME1BRu6FGujzrDY07nHnm8dbLZ/4EyR13I9dyzbSKSokYw/b9YT6hYzVl87oOeXkPuo81zUzw4SczxOSusn4x1TOFC1PpAiVwx93sRnjt77+k6ZHG7rEDHS9z71WVBQpcbx0+odHMxYpBy5KtfoZXv9mGSsce6X3nsojzfhUOLgsz6BELzcS5V8OZZ7RTLWg44tOfer42jHH7Ys1G0E7qyUrQN3gMWxw2Q/3oCzXWCka5hIKE+hKFmzTC1uLK4oUpXPK5yyXKPzMlY5ZPJYRtHqlxOA+ASfZ3lwpj0IBUtZzg4py7amWAPQyaplx+lr8CzHiFbqKjYPXjgjl+ND2qYi4kCArhGqeStLSZZYzFu51B3S17mffL+8lyaq2qNQ2TdYu27teV/WH+5fXoDfX7+/v9a+dVpV34fq+Iw9jegU9lDKqeq/CSwWUSM9/wsp1p76GWenW08UMzqULBt7ydHotYcUFRnqj/puffKa8gOisx9QypMjUeuLM06VnHvt5whg1o+Ki8am7ilXyNFfX2XD+l37xEPt9+McdczeVqG/DNdjfc32YdonUKc+r4zji15973hejGsKtQ1xL80uIXsOl9GGDtxo68CtU7YO3AGWcTiC8R4QKH6WKUAoVHFm1BFhohgZE0cpYwgFirjo3sgzlqiX0qGqT1lfv/WX9OWJXbRPpj0gTUqcKNisnx7WqX9lff1cjFKq6jwyIVGwIOq3p30mceycZhJqfVEWu0yU90xSSlcdVcGZN4mPZD0+SAJIoOxwMGV1jWJoUcrRYqrlNlOQ+v8mmkmuTZKbzDpAaBRLsxmnK9srKV7bP6VUtYqlSFNULZvrPb5aXx2QHLWjRIV2KVMMysExUqIlUaxKdap+2mMvy5M9+V2jzErLkeJUPypqZIaMfqQ4RU7ZoUlRXfPXORRrBy3VqpN+SYFmZznbqShiYEF9Q8FW9vr1qaJcuTNerGNqlwfYl4dYN12mfmwdrEF9KvRtf5bar+sX7a5WyOh3j70f9/0FhijXRVgjsavqL8JCoab1L4egOMph3nXrbcvKZevAHWAJ81MY7xO4AcKc4SeE0CI5J0pZqpMRxpTXoHFNsQJ+TJJ1CoOVhilxpEBJMishlCUVFKZStPqUjFmvMhuw9C9RlkAYZwfHUqz6JAwjpEy+LM/2EwUr9rnJcgJkzVy2Z/WVck0UraFYwejImeJGyfpEJFaKtmoPlHaV9/LlCCeTtJdtPzQ6xkL56u4bQeT6oNcsVmYGXF4TpxSifow+b6Sb/zoHOKGRlMLUNWOhqh9CXv9HyBRbPAzdAibj4ONXIHT9lTc0DUEoQFM/MCdKEcj6Km/lqxu65UjrY9/0Cw9BaCylyVofnckoR8qC1SzNemNkpGxjgUprycXzQb9QIveRz04dy/VoHIF9xN5HTF43/gVcQ6Y+4ByljX5bliQZlevxi70UbdSxxgTXAMQSPU4UpWZka1YrF+dTOcvAZn0jZ2cx3ZeaNcxqb0ge/0tYxgKAgiK2znTRnvZXKWKU+jrWS/34e9xOSO4FIHlcRWRT7wXK6//USRmMiIVKHmy0PDvUfZiFAtWMYnV46yxPi+1YzxnrmfItlx+UWK+9Ot4A0FYUKnske6th3ciXDh+Fii2FetBl68AdYKFAkUIlRrsTHQN13hJlqc5cE2/eFHkiYDQXTATvLOYKSwKCoTBD04Pl3mCO+iNfyhMFC8r9ETkIifIM0l/Y+gRDwXIlj8eTNjLuyMWxSjg+tIqNj11lT7DGu7Q+m/aUco0XI9pLFGyT6zOi4zzSCRoAnOKu/RKLU5WihjojAd5EGyhhThNcMHIOJe0WLA1EMBRlduJsNKOkZLuZdDUlGsykB9S0VU99ZDmBwK2RV/1hXtxfZkvJynrC4nipQyEDVX/DkuOr5DkyKM6iWd9X/pVv8y6gLBPlaO36XJ80smnkafI1EVYr9wP9AUpKOEVEK3uddZe1vtqV81hTtv0ULuvlWF0fyyjZqGb1l1KcXF7bmnLEQkzFvUSAMBRZfxGlqS9s9VhaDcd7qRiLcu7WwT4gfZHh0JTGIUUP1q23LSuXrQN3gGWCoxjtRwcrJuixZHYC44ay40OS8QbdfBeAo0F9dhTXiKb6iJNgqk+Ai44SJ0yC5XNdxj4glCw40bjUKI5RuawvD12X5b4p6+umprk+hK6EZK2ScVQ59Tc5XvJffBYbyjfpG3viLGV9ZIoaecKyOIwspkqfO/qo7KXognG2MyahXhVznr1Erpm5yRlXR0z02WB1BgHk/bcKubTFGnnIpG48jtw+mXZtfWfbT9mdub6112lf/NXUvhHYDWrVEYl6mmgRnUH7mTMdi4prfSBGy4bkBFooRyW39vQihVC2l+qn8WTao1pOoDDcviPqsYcUuUrRozRb2+vBAJX6jEyxwthTD9J17KGw123PYir1sZp+MTap+AMufq4p0pJirc8N23Mh+q6a74f7ls/vqvrL+7MYg3T/QTb27VhbDQeGUKhV58/lMtowArfhGriXvOQleOUrX4lLL70UH//4x/HSl74UH/rQh3p1X/jCF+Kd73xn8dv+/j52d3c3avvBLFsH7gCLb/cwngJwQDM3FKi84ReUaWCEEcm6MwAcKVClTAEkeQSMMDHyAHChzwP1DcU6lsgdIn0X9c03QceUnSDVl/qOc3+atrQPLuW6c0LKapUHFAvlmaJclnJlxZk24tFi/SCjWeYuwbE/BeXrOTtyQ/pAypJVJ0UpUz2haUuYhGWCnat+tgfKUTo9Ibr+sAk5KkhEII+85QohLsoWpxVEMRLZiDNr7KXED6UoZcYKQqmqgxQ84JpMY80HKFlbv6mxec56n7dM0WiNawhpLSTLVz3k1MX2ozye+7jRsk6WoQWahtKs6EOkQFXB+6iv8kgZRjkx0LbxKyBagvZHKd9W24/H32p72j9tTxqIlGF2HrQ9dUyH5bn9ODHLSw2TtBfHdWChOOOpAAcU5zeEmHWqX7VgjtePYO2X+ulaW8pVSt6mIjtQdv1jkdVq9SUyy2y20OnTZ0MR1xSoOlM9mKCba6M6d+YZZjEZilTkGtntw7H/XEQIW6Vk+7DeO3pvwdD5i7BZ5tIGlrGU++NoDWwpVI/DU86iA/ft3/7tuPbaa/HiF78Yf/EXf4GXv/zleO9734snPelJuOOOO3rr3HfffXjSk56UsHWaD1PZOnAHWgJGMwIcox2hoFBDg2KBNhOh8RmHEQylyiXFyohRKUO5BlfrU0HJlvUpUYy99kGVPlf6lPuPTIlmWiU+ARuf5WzliB/vLihUZ+XIjonIQ40bi0t9jfzBtKeTSYxwydrAkHy/pJ9TOLCQMmUjZyA55ZayzfpllC/Zk3OvUTnbXo76ifNaRwHVK5ZjtfYA+Zg2aVdkvy2dF8QpUkoXWEzJ6sRNSb9LsbZtWX+Zvm81WhEFdqsVIiRKVZ+rrc/6VOkDZiJl/UqHkffYC621h669YOzZfonc+7J+LbeUJlG5hkzrRxzr+5qiNHLn0q2CRInmH+L6SJT1UesnyjX2J1T6zHqtS4fJUq8FDvKrOGu1vWCA8S17+mf+DUYOT2f5IEXJ4pTV9D0P4YGxOIRZ1tqaY1AHdSFOTmZsb90sVMXpXDLE+T9E9GIDFKnZ69Rbs7ziFa/A29/+9hRVe/GLX4xrrrkG3/M934M3vvGNvXWYGbfddtv6jZ1jZevAHWCZ8DE0c8TIQHIeorPVCCWqk68+NDUS0/iM40a7ZX2MKDlWmqWqODQUIzQJI373dEX9JBfHKTgCGblvACrslRSrUrC9cnCMdJn2QUIrGbnqR+c0y9U5tXJ2KOXmlTo5exLVTJsZW3mBpa6RcyVnK9ctWKxc9dk4d0luInEiR4G5yL5P9hLmvLREnGkYnCZAmQs1HKJULjNKDBR7AXJakJRDI5YCzYOV05hUuZ46ZzAQr6X0VByETCHG6Exuj8jU18NKUdtMz0vPU1Qw61PHfkmRdu1luXwCraCxJOrMuX/kSnlujyVy2d+eymv7tj+uUz9TugB65RTs8Qy3n7E6HZwirVFMhRzIkdd+mpFSdKo/skYVrttbrt/QIv26b8so1XUpTSpxNVaX1SesqS8Ue34wqDxuJRLMNTjny1mKwI3HY3zN13wN3vCGN6TfmBnve9/78MxnPnOw3nnnnYfPfe5zcM7hox/9KF796lfjb//2b9fv74NcDp0Dd5i47pb3xYEDnI+UYtC38TnAggHEDLYmLu5tWqSsT10DRwHgRr7qAICmQsmqw6UUqNRPFCshLubnTNkSo6Rw2zjoEyaRjyjRCVY+WmiPulm1LP1TeVvKmYXCtXIYCld8gTCi6NC0bLCePyNHRZm24uiNzKOUFccOMmd52iS0pnibcrLSrNRmbhxl87yOmEBzcURVHmD0CTTjuGbRqT6Kz5HRTHGUY671OUXLslwwAbptCtpynSFacdokk1DlCQcGGwqTPCKHp/UF65q/uHCfkkMYszh1MiaEluGa/L3P4AFSDKVk5fuhiDRWY/S9R64PFPoA4GvsMyVKyBSp3GqRpmriQOeQKVcCoQXAQTABcQuHSIOpG8peaDE5P0GON8rivWJpM2ZxIkFAC7TMBWWr8niuxF6Tt9HNclTy0r6eS6tPlClcLZmGJFDIjmktBwitj51UijX3J59LsH4lBSlCVmwUzNkee0ORyrPDRsTKSHDMeI5OfW6PCMW1TJgIrc/r9Kw91W+FokxZsCG2Q4V9quxnnOh6lftFOH+HeRV9ho61nGIcfBw3ISB9C/lQlEYmpk3qATh+/Hjx83Q6xWw266g//OEPx2g06kTTbrvtNjz5yU/ubeL666/H93zP9+Cv//qvccEFF+AHfuAH8Od//ud46lOfiptuumn9Pj+I5VA5cIeN62YOkTady/om1rUsQmkaDIqTiWImQ7lypiiTvrPyaE+/dBTrE5op0qQalKIUe0zx815ZTlku+tkep/4leU0Bu8reacgDxFlSR0n/s5RpRbmikEfHuLGUa5VZyBajomjl/CbKFZT6o2uQdJ1idPiopGCN/RhIsHL5r9CnIlECKneVPTL1XdleQbmip302xyOTpsrjR86NPcXqjOp/ZmxmzLJO0Y4VQ+EyEuWZw8xmzHOMgnnO0QYy9XQMRMqV8lhExkQklGbWbxNFCvnqgWKhTA2lyqAOpVtSrmQo3LKflgLt15f95mp7pn9IdtHT/36KNlHWbLJaAShlmilccYAqCldLkE+IDcnTPVjZq7NeE6Uql7mmVLOzmR1L1XdF/82xir65VSPVbR0+izneq1S0l+0p9owiy9augVtuP3bGXoswgIOMzSF5B4uzqE6j9j2EuAbuLE5dp11Cs2EErmnggI4j9ZrXvAavfe1rz0jfPvjBD+KDH/xgwn/+53+Ov/u7v8O///f/Hj/6oz96Rto4W+VQOXCHjeueYBcUZG5l5G09XKZIATtZy3+y5YdiEIl+H2UolKvRZ4e0kDbrZ5wo0yF7o6o/TjdXNXKlSBPWybCr70fIlOrKcsUxMqmTNSNGHhfKlYJVeymaorjPnpE7K6eOfqgwavk4RyFj/yyWviVMKSFB5ajkZX3uqU/D9Smez8H2iQt9VLRRsiejNZA6UCKnTGensUzDOA7nkpZaTOEi0VCkP2jUFDWlqnuEmfoAvPFEKSVDCO7oZ/tD9qxnW1OwRBikWOOxL6Z0eylSK6eSgiUJZSVc1S/lXfspMibyZqHcJmv0yalHv68/KHAgzo6enOt+rMkuQ3KS/q9qTzKgV9aP19YPjeUKExYtB+jRJ7McwcgPYxZqO2oA2syBmwC4/PLLceLEifTzdDrtVb/zzjvRti0uueSS4vdLLrkEt95662p9bVv81V/9Fa666qr1+/sgl0PjwJ0trnsymWBnZyfhOpS7TvGYpk1fNZOQgUhxBcEUI2k8B6AUXwB4hpxlKfXZZKkyI9FYTQB4zpki1OiO1keJWdpjpSCTPmU5uIdytHJTXyhYlo1+1fNTinjUGv0k5448jCm1BVYKlWLyBMesWlT6lnJV2s9mxYLiuUkUKyEvEG9i/5uWARJ9bR+QjY+RN3BtYn8az0X9tP+dbJTctBKV0o2F59kRTLSRRvUAoVgpUbSFXK89KGe1tuJEyfghQ4kmyljkIIDmMcIKoUhpykDj0lc0lCJNX+HwAJxLX/VAG3EgRiPhIhas9lnOFRIF6+LEqGNPKVmxH51KmSDnUT/otiOmvtqjkYPGV7iNGJA1loFBsvNupEBNFiuQs0opjqUQGG7koAR8CIxGcIzGZRzEGWkakVNlLwDzeZQr984tw7lMEXOIGMQIgSJlq7vLcryXNYu2nccBqPoahWmE8p3L59syRRv7l2i4Nh6FysXvSRTrXO6VVF/8dpW3LZv20q2a7HsZ685lR8PKNVKntKMmayQK2MghFKM6fjmyV2bwZnmpX8sBYN6qUy1yj0iR9mBCzMCOW7sY+QAm0m+jGsq10reYod9ZdunLDMEzHMWxUePAeu2UQiU5f/GvJrochuIbTZtfs8g+cCdOnCgcuKEyn8/xkY98BM95znPwO7/zOwDi+X/Oc56Dt7zlLSs16ZzD1VdfjT/4gz9Yv78Pcjk0DtzZ4rpf9apX4TWvec0Z6XNAG9d2qRNmQuVpMpPnIAHFxr7sDJZIisWhyc5apqMq/UEcEwWsfv03NAvsQfab4+H2YY6TUVOm4oBUFLDFRX2OiQuu6k+zcn0q9IusWUK8QOrYSXsaJY36qPQRI5Qms08d2wip2Gg44RD7Rnp9A1LkIlGq4jxaORMyhav6SuGqsyzPS40shCSPkSsnfY6DK16Uxl6zkD+9BYidkGmb4Mz+a4i/N3WkjnL7DB0T4iSJHIz8UXQzdgBrz9YXe0KhxnslOmIp6klle+Lz5vaq9sH6RRRDwSZ7UdHi1K72j8yn18Re67Pc1mOODkLeSiSOR89Wv6TVmG19ac9X7XHGJPcSmfNfZu3CyOO5LiheIGXhapSHByje9PWOUNnX/nSebWz6lfW0KOWZbiRx5Bz0XGR9PYeKa7mOHdW1crL3FhSz+uAgVH3swyH2tv4qRep9DwaUAs7XPrbXh2NnBylU+4Hgc7z404jArVuuvfZavOtd78KHP/xh/OVf/iVe/vKX49ixY3jHO94BAHjXu96Fm266Ca9+9asBAD/yIz+CD37wg/j0pz+NCy+8EK985SvxmMc8Bj/3cz+3fn8f5HJoHLhNyiZc9xve8AZce+21CR8/fnzjhY1j7KbJUyNh+ojRW1Hn0/SheUQhcb9+AGLkznwVgQgpUzEAQAOJ1pRyVvuupGR1EUiiVEcoKdxq/VVXX6I/i+y54fqD7bPRtxTuuMSQaMsQPl19ruQkG08phVvX90X9mMFbtOesPlX1uWqPQHV/3aL+99R3tLC/hT2ivHGy6FMl77TvKEdhCWV9EgeIsnOY9ocDJwo3Y0ozMoMTZZvlkKxWyGihwh6I0r0WIM5UuvdKdyEggMiZsauzfboTzZ0nfdfQjYzm7FCoviv0ncu9gzmX1l48LVGeF7j3yaM9Z89lQUlyD8XpCjn1yD0y7tZfz35Di+ToaZ8KudpvB9pvFtanFfpb6i+W9+O4rUceH7Z+iWP7YVBeYiIy6wGzPASlUDeIaD1IJWh68rrFrV/nN37jN/CIRzwCr3vd63DppZfiYx/7GL75m78Zt99+OwDgiiuuQDDfIbvooovw9re/HZdeeinuuecefOQjH8E/+Sf/BH/3d3+3fn8f5HJoHLizxXXPZrPebJdNSpClt6SeC5npwLw5EpCiPxqR4xbQD8DbN2BHkJBQlOv7Cs8ha7GizAkFm+6HXkq1h5JVGfoo1BpXlGqTJ0uwwUqB6rdUqZJbe1igbylbmPZFv6y/QF9oqiSfSxcMZmLwSGjANh+fdDX+TyhT3RgYQgumLWBS/+Ss6flVG66idBPNxwBJYgkBpJSw0Gg6mIKOD43MmvpKoTIhbyxc2Df15zLWdLAEpC94MMUs2pgla+SaoUsEzKMTluaXSk6BTZZrHrtxsBIw40Q/x0hktteAoFmxKeN6nu137SFej4bSlysQIOsMkycXk4DSQk9L2cJQwEgYjUsOJFidSI2SRAo3reNL8kjBMWcKFD4ubm9GOdNQNz4GIlWmlC0AiVbGLF4gJi8wVM7a/bTxcJB7VylS3XrC6bmWZAMnYaQggzk6WpxoOlfVV8qzTfXzRJuilKC0llLtc8pyleMN9vyholwjpcipv0j7F2pqwtxnxyu/FJDRVxzHQ/CL5Pney45aifO3VaNzGIJdN1nKu5jgE+Wq8pKCzfNAHEue89c6AKVN47g4TN9CbUcOm0XgNnNSf/ZnfxY/+7M/2yv7xm/8xgK/4hWvwCte8YqN2jnXyqFx4A4j1+0xU7+tfKk3mJBvYvOinbbmALLTxXnZTNaH0fdZP1GwalIdnQHMTWpO3/0LykGdyIi5xCT1FXOlH5/IcFbfWX029F+/fujIYShLzpSvldf9H9LvHJ9M9vLwjPq2fnYqtT2lMC0u9E19qLzWl0gQcXRenK6ZFLkLOkbi+jgXKDsN0l489UrZiryuL/KiPpv6LOciqIsgVGCqb66x2Auc26MeORu5rQ9A9jFbZE/l3fp1f9KA8fnaAeXYru+dWj865WZsgMxfzn6Qqc+mvhka6R+6FgxAomzVGdd3slRFKNakb6KGSst5zvXhzPooieSk5rR986LkiKosUZN8AE4vgVkO43DEKF69UXEKKGlEKckpvZSm4yXEtcF99Tm+dNrvAhcvvhrPNN9NpuLZoI6dntso90Ye37nyVUp5LbY9e29DsdxdbkhePaPkfLi6f8j9q4tSqvbZohRqOEQUausa8AZZqOS2H7NfpxwaBw44fFx3QzEZghlYdOslZ66+n63Dow89najMX420FLhHLzkp6jxY7CtMGYdRqa8UmXaxdBa5s3GtLt5XnOyl+j32KNvr6lf2q/qlfl9/zIQIwI+R1odFCtKcS9U3uKtPlf6i+l37fmTt9dUvcWgQHQzBqPWdxVTV52K/Os2CLfq3qD7x4o2IqW6/whL56xubaj+98chYK8a2fj5McKjHflU/eWvJHhdjG2THOuco4OC9Q8m+rk/jvvbsWE1jrdw0Goj66gSwOGNFqeZ5KuQSCTPen91KBUDxmSlpzjiHcWNdq1DW16xVlJEps56s3ui3cISG6ht5d2NfEkrX9H+ZfdMf1Un9E2esXx6NBWu/aq/Ul/YG7ZWYRJ8X6NfHV9TX52+iUA+PAxccJWd7nULu8BzjuVAOlQN36LhuedN1OtGhnBdWNsPoGFCnMDl2KiPErMQeR0xZlETBkvzmjX5ccVvUd7oguC/LtcZK3THLViXGnmRVOm/s6Ymw9i0mksgPp3V5SUWzOOX0sLVPKtcNWHN9mpf6I8HR8SOhVCXqRlEfQMKjtJFu1k/2zfnvx7JRr9Ev7BEJ5Zv7myKl8nLaJEpU7XHCdoDpd24zxRovVsq6VWfA2LOzh2alFvWJ0Bi5XqvB+lS3L1nT5iUifcvVxeuVBreLY1MpUj3eTLEynMizvSxP/UsUK4A22rf0fYwA58QQsFK+5fExIWbosrZHWd9u5SL3Dum1h95L8rm8Sh+c5ZEu5+y4in3d6iVRjnItg2SlFlu5cHb0chaouW9YmSpK+7dp4MPaJ2gWJAvFK/vdpfYZc9FX5ivItYzzsCzIR/5CQqZ0o1ydISvPmCsscq1PkaIEascOicZsmQE2WakGs157Jjg7Vsz5K+xBKdn+9vShbjdKzhSuaQ+ykTB15UqxZiznscWh+haqHzXgsH40bRuBW69U73fbUpfjx4/j/vvvx/nnn79SWrMtj2/+Lzzf/Q6cj05YHWE7U+8a6kQVL2jGS7QUbEefBvSp0tf6ZOrX9myUrMkORYp0JMwVRnTu7EPTrWOvwuL8JH3NGm2MfVqA1Xlr+vuTJ3CVx/WCRWRqgX50EBbY0/aLqGeWU5xzDOWa5Szy4KTPlX0GxxcKqx8W1ec0JjSySzoW1FGvx0aBs5ypqk+5/xoVTFSTOZd6vLV9lrFEVfsEc+3B6fh1fOvx6tiyzmzKqkwvPpKpaJ1jGQ9pbNj25QcbaUv9N+3BtNeJ4iHXre9tXW6QnG89n+k+NvcWuvaA0tkA69515fFYB8W5vJa2n1I19e2Lodp3Aw6P9M8tkMctUhbIwWk9mzn8zvEm/VAef6nPXf2iPc79hZGTaY5KnF6cezEbZ3hAX15+fXA49f7/g1M/9P/GuuV05rBN2/ri3/4XcOjfu21RIbeDr3jKa89KXx8K5VBF4A5badwkTuyQbRy0MHLULP+0sUOnz5aVKNiekhIFdAJUfWuPs7x0llBMQAn7jNPklDAVuNgCBNzV10jMoD1U9mhB+z32T7s+pSgWI34r1n4Zoc4yjpmcFi+Sc6ZYh/SNs8CIk3tjsPZ1SH9p/Vq/sEddytuVclTy3vp+qH7Z//TjouMx+sFSomI/eniCZew26d6gyj4XYzvdK9X9nJ1VKsZK595AXZ+K+mzvIXvs1kPwpb7+3LWHQh6zerv2WF8I9NwU9iTyI5iqvwClr1YA3JE7ylucAD0OESFtYaLywsEhymtHO3JAM5yH5F17i+TxOIfl5fq+TezX2KF8zvbp+yCf0jpMSQxNA94giWEbgVuvbB24gyxNg3YEjGTxd0C8WQmIb9GC1VkK8ld1dB5Z9e9QsRRsEXVD/HfabBhIC447jpk+WPQ/+6bdpy/HWEQeBrBTmslkCiYKlkx0ZIBCTZOtYJc28rXKivNMEUbGAajrE1AzAGkjXY4nNck56+vx5PqL9bv2S8xEkSYEF3JO/e1SxCORq76OEd3oN+m7vFgceh4IaLR/ztQmpAidGi22hiE9j4RGJ2YbBUr6ai9SlMP1uxRt0T50rEUPgASn5QoyFp3Wd+Z4JIqVnCWRp+ORsR7taeKCUJ6iX0dQY3sydtURIqEI0/GqfU6UKEl7tX76pjCZ/lknSI4lJc661HLqH+nl02sLwijka6sJF+l4zIMhRXv1xco4jGTkKORan1NUqdWsVhvNhlKilCjXRvtfyUuMdL7qT3858YT0+IuIouD0PVjmQXmf/YhjQ7rE0VFuO2HEr0QkPTNY+zAQv0IBtokYJda1ejELddFT/twqftQgbEChuq0Dt1bZOnAHWGa0j3YizlmIa7PA+Ua2jlXQByMNyJGf5X24duJqrP8uNlE1BsgaJPNWaCdEra+qFU2UJgvrxMG0xwO/9+rlzETHqLJcucgyTRN0dTLI2nNI22mwPHHJRM24qB/tp4il1i8w5cnNynWia1BEPON2GhaX9riwzxlL/0JDHX0u9KmT5epqfUu5NlFfHRzNkmUgUayOdJLPW5LoZc4UZcY6yTvRd3bMFPUprZdTJyJYORPQSPQG3KkP5LGn/UvJDJA1m7Z/OgkHQDci7lC2jGJxfvoKBosTR2V/rb6lWJN9Q7mm+prFS/bbsFycz6SvDow6z2ZoEpC211BBw1mfCcVYSPeK9IHS/R03j1WnLJ0Hc6+CYSjgKGAy7Yf8LIjnRaJmyO0Tm4CjOEvB9o+Rs2rFuep8a9Xc287IdWNhNsdP5l5KlK7N0nU0LIdkwVb2o/PEyVlTXyp991Q84QBZv0bZPlnMtTMn+qk/VRavjLFgNtU+DMWDEIrQ5mplk8SHL+eydeAOsJAbwctXuUayTxuA+BDzxsFiLKZUB+RYIF/YL61TPxD0YWkeOEnf0CCppAkJm1Gwdf1FOCDv51ZRsIspUbOezcpDj/7p2HdWTmtQvgOUrMG+yV+FWEW/S8n2YL8EP9gUrdkmYiOKNhh7ThuCOalD9uTfaUueHsrX4FRJJ3ShbBvS6R7FtdGxnROhKdW36w117Oe98cr2+u1zMRZSqccijD4q+2zl2Xb28Kiqj+TIsZwf9NmTRCTxg4y9sj/RqeyXA+IsJco2O0KZwqXiWVWvmSN5kaopW9bG9NmEUq7FOmNdORXOXVfOnWco8yL9iL1H3EaEq8rncPGNQ+D1o2lcpllvy5KydeAOsNBogvlEXj8lHEFBHJsxkhNFHmnPM93/raBUgUy5AimqsLKcze8L/qZ+y1uxLVbXbnVA+rC2BlRuH8K13FKwhoaBeUAuxc78PohJKFUuoioAenEg5OSFTezbc7aoPZkoWGcPEkrTVfYpU7IFzSX6aQIFVsKB8pcBUtRLj9dcg4xlQhbHiCkvaK/XUzGJ/ZD1CbU9QE3G+oZKpGwz1eN8TmOUJ1OZHUpXKrFk+KnzZR2ndLq1P8i0lx1fKqeKQu3YQ9kHMnKlRO25k1OfI4p2PJiV/dqXgsK0E3uvPnX0y/PDRX2rH887V/ZNe5ZSTVj3k+N8z6vcZIhbfaf97bE3SOGqnDhfu7q9or5QpDp2GIky1ehXuTdbpmyJIN+y7Zcrdar2VU6O03ms7ef2dU88LvauU3kf1shiCEDw5oKc4yW4DR3ODaJ2X85l68AdYJnTKbQ78SHkA2PUyhOV48OoCRFTEymERlLY9cHTKKXD8WFqcWiyo6WLkJ3WR3QEUraiOnFmMlTnbsiJwwAmICccaEWxrRMvh+ohK04pXI+cszytS9GJVB/CipGPF2QesFgFr7YxsSOA5yizSqXvHawvmOKgB2vf2X5yhUVeULBCaeoQMZQxcXbuIgbYUYVruaXlorNGYh8cH7DpW7JzFHvnkejbSTQ0eQ2XCzL+hJJVrDQaiX3NgqWA5LxmCtc4UxwpzRQ8kvGt17wJciwSxXGQvek0QmvGWnSqKK1368tyJZj+cA9FrPeX3AAuGEpTnJy0vs+cb6Z09Q1G3KjYRDTTNTcOVnB6v8lGzuZlgEJ1DxjnylLI6NOXsRbkvJCcgDqLldSZNusDU4epXJ4gQyre7xV9n5YJelO/cE6iM1wsd9B69b1h2wty/uVeKJaZZLNIW8z0yNP1txSuOrCJspXPXymFqhSpoVSd6V/Qezbo1YvOX9CvschzjXw+WHIkGCmBg8w+nAWFqs9zT+mrFoehtE2zUQTObfL1hi/jsnXgDrCEpsH8SPz3aAa0lkI1kw9kfVzxBmblA5hMfQooFskXlKo6UNVP6d+1/pKi89TKWa9plkrzQbXma0CuDqY4c0T9+hD9VXGKMhmaqsQwFOtA1qqDoVxFLriXUq0p29p+LfdV/br9Qdztb2hkHyyj76r2m1C211T2G78EW8pSzw+q4x3AwZX1occP6V8hN/u1aX2yOM74GtHOJ6FqfwlFW/Snas8eb/pR61dZr0EpWOvck9WX858GqlY0Y9deC6Dor+oPUraI93dT6cPoF/apn8JcSNn26Nv+lvKyfTt+07kZtCcrEBe2t0i+AoVLVGTdgk2/gF4KN0CxfAWjpnATjhE4uy9o6ciLt1pRuN5L9O0QJTG0TQO/gQPXbB24tcrWgTvIsrOD2RGOjoojIHD6mkIKpYvz5ST2TvqXMqbAKRsu6cmnoJy8sYq5iLnCAaCmKw/AMAWLAcy5DqP/b69zZ4tSqPZBWsvTNwpLvYLa0YmwT1/ktf76WDd85Y58iGJNGWw2kgEMZNHmmWIwy7bC6qgPUbra39Sftqyfjk1pJ6NvJ6sap6hNgXP9fvmZ1a/7Y+dhNvpsjt9SogEoIr069hUzZJNVlXNlP2WaImXR2rGZMrWT/WhE9WxiStnffnuo7a9IqapOSUFW138F/cX2abF9fdCYY0nnk+K5TGO1lpuIdcLQ5AjOTrU22DN2i+x7Fxt19t7gsj0k+6a+NKcJQOnF0jj1YBmrTNKvfopU/7Y8QOGyZJ8KhZsSNEJ0Kl1w9Xv4OVsCEULvw31xSZnC27JS2TpwB1jmfBLTYwznCX7MaOaUHDh20RlTB44poGmjsxapz0hNUXrFYzQtEMTpi7vQU6ZYLZaHvAvi18iDwnmDSaJ+Vh4yDtWbolcsDlKw+lhOySqODyQLyr8qJ5iHJBu59gH5Iav7UJWRCdGnHn1963W56eWY8tYM+kA3r9EFbhGdpXoCWITNt1kjruUZN21OnGDkCaXE1JVrhJPZUJrIWakFRuEkFBFTncjMbMIms6+r31efUlSZjLyLdaPeUj8YfYd8fJCQCTcUPxyv9pqsC7YUbaZ0U/BGKN00jHTCtu03gP22a2jS3B31R+lIkz29dwp71vm234q10XTbX1sfgF0PmDqMTAmn9qzjpOcrH2Extgt9oNzCBJwcr6QPM1bVNsF02IxNu/yCgLylijlea6+6V4g5JooYOSg/A/QiJ327TAEQCjZvv5LW4prnEDvkj9zLcom4LyQBXl48jH0bYYXnksK17RPAbXTi0lcVdDmGRrTbSOHqFzSCLJtx3sWlCjgcxW8YgcM2ArdW2TpwB1h47DA9Gh/gk30gNLJrlzhZ8WtxlCjUMC5xTamGsWCVj7JcP2Vl5ajrN/2YQ17XBMgDIxTVi79B5U35Oyo50C8HUHyZIi2GNzLATPj24YrslA1RsAAKCjNRsMv018GccaKRLAWrD2yNLtQU6aD+KpgMBZonw6I9GpJLf+vMxEE8kGW7LiUcNq1PvfbyFnElRZmULEVLJUaF9dpa3NT1TXugzHIxR+cnU6Dyt6J8s73SAUj9Mbg4Hvnb1P3Ve6fCfWM73zvG2WOVU297KmfA0HzyD3u/qj5V90aSk5GbCKMZC0NZp2xPirHXWHv12O7ol/YYi9rL56qQ+7K+W1B/IwrX2O9QuAFwnuAClZvBn+NlG4E7O2XrwB1g4ckRTI8yXAjgxgmFGiNoDnFRquLGYBfIyKMzlLA8pRxR9JRUzkjymIRXyU19lXOI/9ZInK6FK5IfJEKo5sA54mGfJ2lOXCY3WB+2KRmjTw6Y2dK8Zfd5hVZfqWprEMhRJdvACJmCtXbI6CuWY1sZL6BgB7FbIl+IN2hv4fFR+i7lEGWsDkH6FioBmjiRJvsk72LNDNT6EbORU578Olj0FQPxu6CcMz+bCqcMP4oTTaSzOFGgpIv5pZ9Fe6CUvFG0B87OlDpM0paORaUhE0ULFPsn6vEkrOd8wB4IaCQUFm8JLpwrtv1BvJYxcmluHi71e+snh0K9nEx51mMnOKQF+dloHkuwY9OMoSF9O5b75KEYq0bP3shs7OlYJpRRt57jqeuHuj+mfjo19ng69uVe4v7205Y45nfdFqXxANlMlXO8tOTgN9gShHF4jvFcKFsH7gDLnPcwPcpoAjCfeIxnLjlIAQEjTwnPCswIiFmrOXtUKFZxquaO0fiIvXhOKld+UylaLzNFfAhAqJuYBZvoGc5YJ7dGnTlxrhR7Q9GqMxXI0FPykNX1doBQsCK3zzZQtm/1LUWTIpHmoWqfr7YQkDfPTD9kuwWlKhM25GPyiSpSfVfaSfrFB8oB+Kq+YG7MMbgeCjZhLrFSsNpeqHCnfh9e0p7aU7nFvg8voHjbaK9YM9RQhWu5wchri9IvluZSTLa+xVziNsp1bFEAeKQUcaZMdclSvAcyjRezZjOl7OR8xlPPgAeooTyO29wfVmdNKE/4sr3oF+YsU5b2IGNFJ/Y4dnLmYXLEPEp7QNq4mClTsGlNmFJ8Mi82XqJQuh5Sny+GJrX1WRdiOaufs2rlpyR30p6ldJN9uVZxJb/aj8eVlivovUtmrLrs1Noth6g4dgDIWbRD+qxZqoo9imeC3iupvke6rxvpT2j0oRCd1SIC6s21l7FYUNCe01hO97o8Z4r6xj4x0HiKi+cOSWmdg8f6dOjWgVuvbB24AyxhFDA7Grc9GO8D3AQohUoeCIF7cVzzYHF0vrziEJ2tUOBMwSZs6hNTWhSLIAvb9XkQuKBcWZMpoBhllmpF0SoFy0ZfH+QwzZjmSoq1evu1L7abFPuSXBtJafrGeckdM321a57MBFPoc6W/CHNlv8BU4F4KNmEjr/WD6d5CTKU9VO0BC+Q9mKi/f8v6b+uvSqnqBMsWU4WzPJ3wWSX3JW4qnNvjYoJmLrfsKOg4mP6mHwRYCpRKHKr6hT0eoDhXpFQZ1Xkw/SmyUHvHrjh7fRSt0U9RJLW3UJ+K9ur+p7+k9vK17cp7xtpS/XUpW1TfnpVP2/XKxdygPH6pYdg+kpNuHdDGy1Y2xcA6t0twBD/4mj1caIM6X85l68AdYOEju9g/yqAQ4r5YDJCPzlTKBpU39IbF0RJ5ifvkMJRrScl2MckCa6FkvcpDolAtxepaFPqJcrX1x9Qjh8HoxeC8fi/hmqK1k4+U2qGzeJ1bvuOE9ZVFFCxQ0FoA4l1k9fUhzMjRCDtp2W+aqlzqJfsJZ9qnX17iwnGhHvs22tCHQRIdye3B0RKcJ58uzvZSO8588omQKMqM8+TMhiLNFGhNiQ5TpF2s35lctX5XXylZPc96b/TpB2sfSN/cLO2Z9lymkPvsB1sfiGu+NeqH2NZQNlE9dpmEUhV9BmKYSSPrWjHVN2vOesZ2n36oxj7qe6dwXs1YRTX2YfT1+SDnw+pjib6135UbirRHHqiKPBKnsauqiX6X9tK9gOicNHptVW6jplV9xfrCfai+xOAa+A1SLmiDqN2Xc9k6cAdYPE+xd15A4x3aCScKNa4PYozaTKnOKETKVOQRq76RSxpppFxd2hCSYep3cHw3VRyz9zJl6+XteSSUbLtT1Q+I/ZVwvg+qj5xVS5HSzQ/DTPHqfaxOq5eHoFKwvqkwl/pgQ9HG01NQtvrHPt5qXJchGQElBWsNAuUmmyR25nnyY6uvtJC+YVt9l38bomBLTAvkXNBkKfVS7QslmxwsNlgn17o/QluthIVC7W0vYRrGQnHqOUXgnMXZJ59XWO2h6g+q/gzqZwzEl6owQkGphlGZKcmjvOWEUq5RJJOz4DRmm6ifM6zj8QdwpEX1/GtkWyldNvbJZI4rxduaLFpAXhyozDIOZqzo2JX2XGDjZMf6BJQbCcv46FC0cm93xp7KQWLfjC+f5am/SR+Jsi2WExD16+vLoDOOWctZX5892jZL+0pxGrlS1wVlW9UnRrG8AMKJ1/qk9wYD7Dk62ZU8tWeubbrWxl7ciSB+7SWdu0NQAjZLYtikzpdz2TpwB1h84zHbZZxixmSfwC5SqInSHGXsAiGM2GAUcqrlHgjB1PeUKVSVF5hMlivLAyFTro4pY5bd661+IMxl8lEKtcAB4KasrzhStMa5Y31YZlxkwYbovIVKrhNK/XdZ1usyZ64u+hLeV6dDwVYdSv8comBV39Imql/XXxkP0FzWPitegdLEGphlgoXFpn2lIGuKssatxVRisnKucNV/7Q8PyblHP2M9IW5e9q/GvRQrIWWlFvZd1b7BTilZ2765hsso2rzQv7r25sVmKUXbN3ZqypelbTPW0n1GVT2jD5CpLzYHKdYV7Ff66Sd7L9T9qcYuq82O3CgaZ31RhnYvZVttwq0vcKlPaezLtRiQa2cbj8zaHJLSugbtRpuePPQicFdeeSWe/exn4zGPeQyOHj2KO+64A3/1V3+F6667DtPp9LRsbx24AyxhdxfT3ZA+LbS/i5SEkD6jJQ8QxxlrVqliYvkETpIbClaco8ZzwlTUj86f41KeKFmpnylTRjPPcoQYSVN5WpMBGsBxv7qIAYgzmmihWp+BppWJSPqcFkIPYVl4XGTF2k9Pyf+GKFn7rF33fU+du46XaEtNwZoGO7QToaCtkr6hYG1yBSPqJ1zLFZv+EgGsm/mmBeQy+REyJYpufZb+FbiWL8QbtKfRGD0AIwdyMsEwBbsmJVvrG8qTHTKl2osNZZrk/fVT/2mZfk99/cqHk6zZtkvJphYMxcqNfEVB+9uU7YdG11flm0dfwhgANXn85K9WGO/Kjm1pLztw+ok0LsZupmjr+qX92l6ffmjiM031Y3Qr9y9RnPbeMO2npR2I9uqxymasxqFrKdI8lupzn8fyMEWqX1hZhUKNS13WfVo9eGXTbUQeShG4F7zgBXjZy16GZzzjGbjttttw8803Y29vDxdffDEe//jHY39/H7/8y7+MN77xjfjCF76wURtbB+4Ai8c+9o4FNJ7QjhjjluJ3EcEILlKkTmjJ4AKa1iUaMTjR9wTigOAglCYBggs5McbzSKk6BjyZ+gjwZPTBSe58fACGROES2h0We5GynYPBLiQK2HPMkh0LxeoRs2oVx/wIqc8xeYopUrYI8vzmSMEiAGGsOM60XmgUdXI9GyxZZ4ChZLnELA6ffvdT/MbkyAV5mEentPSltCxz7oZkBGSazL7li1DlEHmiZSyFqc9vQ8EWUb9lFKxktlnKlUjaZ5VTpW9x9IrZyNVpVAozYdcj78XUiwGAZpIVa2g4HpXnr8C+rM+8DHN2elfSN1gX+xsKkoEOVsqUdEyPKDviIVKyNqqSKNuqfj/OlLBGmpNckpESpQzkjZwpOnqAOIGqYNpvfMbFeFXKN0XTpap6wi6fKwLyWNQXBTk/bm4oTe0vmbGl95+lUMWRo8pe6hvl9tR+MXbMViwI4gSJPntOdHWWIzn68d6i8t7qZMHKuSIgfXtVx7KRx/YAMvR8olCB/O1WPdcynhwZez461MqYHJYydw7tBhmlD5Us1I9+9KOYzWZ45zvfiW/7tm/Dl770pUI+mUzwzGc+E89//vPx4Q9/GC95yUvwm7/5m2u3s3XgDrS02D/m4QJhPCNgJg9XXZA8KinVUZsxQAit7ELPkeK0GKyUqsqBMC4pVTb6xBUOmTKFJD7wvJIPULpKiUZ7SsGi0jf1VW7ao0DJ0YGuy1M5l1gpV/3weF0/y40DxUhZt4FLrI9B/RukPap+R4WtfBXnrvM5Me2jdcbUoKGs0uRhKVhC+gRUQfvoX5ftK31TYGfa4myjX5+69bVfcpITbmu5cbRWwDk0VskHMa9lfyWKd1n9Osu1rz86KOT8lpRrl5It7C2gWJe1n67nfKA+qNg8lm09ezMoJYzFFC2jpGStQxXlbP4dT2KH0jRjG8jHkyjUon62XbfHElbrXV5APfoszp7a1HOX5KadnrHer7/YHtf1gYpCpXI5ASG9uKWx1Arrcoi+hRposyQG9xChUH/oh34If/RHfzQon81m+MAHPoAPfOAD+OEf/mFceeWVG7WzdeAOsIyOHUF7LGCPW/CpBrOd+Hv8liilGzpGzTJ2XnZ2l/8iJUr5hjYUbJ+88ZkyjfqZggXHSJ5SrmDNQs3tNXNCE6ycTEJBXF9n7Y/mZPaEk/3o9InKjNFMsmaZkzxRsowK1/L4CTKNlkU5yvrSP8WOKTl2UQ6R5/Onjh2ARLF5lXNXDmRH0H4fE1jdsUu6YkNPabFRsepJf20wodC3k3EjDq/UJ0KMHOiktoByhWBL4RIhLabvUrQkmI2cUqRnXQpWz8mQfB1KNk2UAxQsAymyk7GhVJOcKtzf39Xr99tLeEVKVhu3FCcrxan1G/nkWEGhZn1dwJ/MqbNk6kfHPOq7tCA/128W1EdT6rPBUZ9E32TREhJFm8c2d+x168dkDQRrjxLu07f2O3IdS0rJSmRPseonShZybYbkOvZSoheyQygXM46l+EvQ9n2pQbLsxG+ypOxBKl/uFOoi560ud999N+6+++6N2tk6cAdYGp6BjnrMPWE+aTGeEZyPT+u2iZShCw7EDO8YY+9ASiM2jMlcKFMwWhcwkaxTYsC7gLGhXBXrRsC+iVmvLiBSpCbrdc4RT2ZiD9LeLLZHISAQYvs+vi57l3H8HiEiRRqA+a7ozyylq3LCfDeACRjPSPpfytsQwEDauLjlCu9wxkEoVpYs1wB4cFxbJ5E8Lw9Q3cg4jGQdoETmvMzATvQBJDqTOFOyaRNlfVibmTuoHCjfM7kMcCwqGrios1oVp/YkwkCVHCSOqdlsFLbtHgrWcZwslSIFejBH+jn1p7c+VfUt5q59dSIJYEPBElBQrimqt6h/FQXbxVxSpta+OLpdLJmBHtH5LbJOOWceAkIx9tdfDfPi/gCJliNDkaZpnbN8mOKlBfY4U9LqSdaUsKkPrQ+Y9QomEsfIFK3VJzO2lYZMY1ftiyMugZdg6qeXNqlPeuxAiqpykLWLjvK1EVwkSkn/OQjLYPQJsraQkL55Wo7lHOVTijRtX+LNscrxKWWbWASlk/V4nBn7pn5q31CyTp7Pro3/PiylJYd2g2gaPUQoVFte+MIX4l3velfn96Zp8PrXvx6vfvWrN7a9deAOsDie4cjRFicBYOowdw5gn6k+L/+TGZd9yJ+VIoCb6NwBgkWu9YPqSwltMFtASZarYBcIYZ4xGKWcgTCKzh+z4LlgQLJSkZMpkjz3h8fZ23GBwPOIo/1I+ULajnvB6cHGKB/Ps5wYKaoTMRW4aUu585TT7MU5S2+yjLidQdpyJfYnTS5Acu5Se4ZS1UXE+tat/UvYFJXbrNm+Qj3/Tt+ANcZ0UrQ0VK9+DwVLOrQIeU2R1gvIkzuZdmx9MvVpnfrUtZcOiasohHTaXJuOPfT0z/xeU3yJMu2V1xQh+vvTWjllR6Kn/UXH169PZf+dOX5mpC06UgVEitTqs8VUYSvnAqcOLbS3qH52fBqB5bdikd9gADBxMXbT3/SyUWbBOiBl5UrMLL3A1PVZ/lE4qsaRSvrG0dX27L0OihEuVYVpH8hj2eq7gbGdHLl0r1Bxb9pDST+GXL8eixTifdyE+LJ/WMp2G5FcfvqnfxrXXHMNvvd7vxf33nsvAOCJT3wifuVXfgUPe9jDtg7cuVrGR3ewe8SDmbBHAB2Js34IQPA6wAWnL7pLtEiSDXQWV9qVwZFyNeshEqUKiPNh1kuw3vzI2BOaNmNXy0PeTy46S5Tf/qS+1R/1yNP3Flkp1gob/YjDoDx+IszUn1X2Kty0QqnKuevg+RJ5wnp+zJzUh31XXuyjlQ8lyROu5RXWqENnPZ3RKT5bpDbYGkDhIJWbuca+ajZ0KlZe6xu8rn5acL7MXqJwzTYkpr9L29NTYnBynuw8WDsfRSSTO5FNu76qH9MCOS+sD+lfx5na0F7dn3S8ImQgUZDqsJQYkQK1Y6OnfkNVfcryYPY466tv6Xut3yRMRX/66oeiPS73eOvoU94Cxh5/PfZCZX/BvYHa3ir3xgJ7oUfufIzAFV/DOcfLnBzmG0XTDo+Tumr5h//wH+KXfumX8IlPfAIvetGL8MQnPhE/8RM/gXe/+914yUteclq2tw7cAZYxtTh2tEUIhPEoYN46hBDdMucYviX4ENfQNE1A2zoESRVvGkaYO3AgBGZgxKA2vu6GAIQm4xaRJhwJJRkYMet15pJz5puYFepk7VxwjMk8bxQcKdseLBNncIiUawCAgNAYCrZH7g3OlKwrKNSkL3gnUaxsKNmMNSt2thvfjTOOvMlojqTPiFm3kP4wCOM2yuc7DLBsXOwBP4khLv1WrB+LI2cpWpZ1gMFQsAzZZBUxaqkP8lH8q+dSn+f68WrdyLigaCk7aQyDbX0zthRTPDwxKDJ1MLWiWdRe6xMjbzRs1tZpfbKN1vpk9AUTkPexUn3zPci0pckA7tqjSNupvYCCUiUg01JuRfsD7WnWY6I0QSXlKecuy9fFpT0gtteXdbuJvVoOICc32HWPtT3o+aAuJWsynAE5/3reKjnLgnymXF9fVoId85CoHeWxGLNQ47OOkK+tzVrVG0GfN0TZqeHU/1w/nUuY+npv2LGDfHxWP64/Y2NfjgHm/izuhZ72dfmBjk17ryGPvXivEKjN546AIgvV7nV5rhdPDn4DZ8w9BB24G2+8Ec961rPw5je/Ge95z3vgvccLX/hC/Nqv/dpp2946cAdYaL6PY7stfCDM5w7N3KzxIMCPSCJvgKOAkdnLzBHgR5zkAMOPHEJgeTZzrk/AyDGCyAFgRIx2lCfzEYB25ABZM+LAmI6R6TniSImGvLbFj0PMPpWHS8IOIHDGiJSkH4dIvcrDJ0yCfPVBHrqzkOy7kOUZ5wnCBSBI1m5AfCu3OMnFvgsMr1m+EMp4JhsSU5SHNssbTwhzzrgt5S4IZcvZfmNoNWLktWgsEVFL0QbkrFGZdCyVUryki/NnqT0gYp1g+ijZ+iVef1AziS7XbUo4/247kJrVXf7VeZL66qR26sPoO6MPFJGg+tgtTZQwm9+1fVJ71G9PnQ2tHwbsocd+3b6eH3HMSzl19RPmfnsLcbWeDago23XtU3mcDqV9+S3KuYxQcjk2iqzXHrm+UBRRQDOWGOJIFViSsszxNra+oTQd5PNeVt86etJ2w2V9vU+BiiINSGM9/ZTGaty0YnhjYbFX1bfLEdKPJH2p29d7xufLkPsbhR3K1RsckJLUDpMDx+QQvoy3EanLNddcg+c///m47rrr8MQnPhH/5t/8G3zgAx/ALbfcclp2D50D95KXvASvfOUrcemll+LjH/84XvrSl+JDH/rQoP6/+lf/Cq9//etx5ZVX4oYbbsAP/uAP4g//8A/PSl/HuyMc34nfWXpgf4zJJD5NmXVNDSUcJFLUJw8hRuqs3O4HEALBc5aHoOu7IvZB7Us2W4iOX0AAMyOY9nWLEoi+Jgs0nmI0hE1CgNhrvOxnp7iSK8Wa5G0tdzH6pXhe6muWa6pf4ck0UsJl/bylSaRYUeFanrcwaWYo8GiGuAGyYDfPkQSwLDA2D+waF+vp+uTyeR6jkvwr3fhZKVkakHfqVX/VAbT90D8FBWuiHFaukdjacIeCVXkw8h6Ks6NPi/WTPRM5i/WorF/J2XGFK/sde/mvXXA+jGmBnDv6qe2B9qw8OVMD9ZMzVsvDIvuUF/pX+snegLxjD8jJAAnDYNO/ngX4qb4Zv0zx27ARa2ZoVcm8POg3pnWsJGevd2zF/iSKlkpKtW8sFt9ylchicoo7+ibxo2cs990boU9e/U1O3CHaRqTFZvvAbRqBO5f9gre+9a144QtfiB/+4R/Gtddei0suuQQ///M/j0984hP4vu/7PvzP//k/N7Z9qBy4b//2b8e1116LF7/4xfiLv/gLvPzlL8d73/tePOlJT8Idd9zR0X/mM5+JX/3VX8WrXvUq/N7v/R5e8IIX4N3vfjee/vSn45Of/OSB93c8IhybzNEyYTxizD3B+/i23LiYFu6DgwOjcQGtdzmi1mQcADSOI/aRck1yT2BiOCMHib5QtkSMpgmYz504gpGinc9FDpRyivJ2LvYZcA0DM6F0KWbN0twBgTBHG7NcZw7wBE+AlyzXgrKdOdlNnEvMHsEBO7OYhctgoVRzVq3FSBRrdBz3xDnZmWYKlx0w2Y9yDUOO97NccZIDmEzzZEJssmblt/Es/xsMoawhiR2yfUqAvt4nrM/iRjYypkk8hoTFnpOoUvrOo0wUhIy1fW0mXkykLU7U7zfdiN3VSYHL+YHEmHlfWEi5Ih5q/KfKfSWHkds5h8QZ1UilTtRk9HlAn0SuFOEQ5Wr7SgC1VDhSdf20E7/ac9leolSR20fd/kJMmeLskSdnA8hRM42CNqtgEsy9cgBp/Fn7APIazQKTYO6Vqz29dvZS2TWfhT1ke4P1yWCych1gOWpY13dGPyCPt0R3SiOBELf4CGJPr72uXzUUKkFZBmMv9adL0aq+HovKCchReuv4JTmBJNHKHr/eC5o8RZAXVF23fAjK2UxiONf9gmc961n42q/9Wvz1X/81AOC2227DNddcg5e85CX4+Z//+dNy4PSRvXL5hm/4Bvzpn/5pr+x7v/d78ba3vW3jziwrH/zgB/GhD30IL33pSwHEG/KLX/wifuZnfgZvfOMbO/q/9mu/hmPHjuFbv/Vb02/XXXcdPvaxj+H7vu/7Vmrz+PHjuP/++3H++efjxIkTa/X3Md/6LDzj196EE9MJ5t5h2o4QZCYlAtogDps4cCG4JG8cwxvsiNH6Bp5jKsNIHT52IDCIGHMf9Unqt63oU6zvPSU5CNHBY4KjWF8dPidvmnOLAcznzkxu4gCKfQBo5wQOBHLxIdfOsv0xIzqAot8AoBnFaKBjNExopnENn3fx9VS3NQkubiRcYAbG4rAFis7QRLBvYhRwPKUkH3mDXdyIeDIl6Jt10xIm+9nZbFRfHJKmJYynSJRs40kic/Fh27RAMzfyEH9ThyZ+7gzpbnMe6SscDJMYog6QOnTowdyTNcsoomb1YzBh0RlaEJ0eBvWL8MBzNXVhQZREJ2gznyebhby2Z/X77PXor1S/0Odu/bq/4lQDxmms+0NV/RWxXrssr/rT46yuhE1UNTnlMM6kWYO1DrZryFa1xy63b699n7yOurGec9M+MCzvRO2qm4GRo172RaN/rHD32umxLxhb2X7+ikX/tY6/LRq7utVR0wL3fvr3ceNv/yusW05nDtu0rZ/E72OG9T3OCUb4/+Catfr6YPgF65TJZILZbNYre+ITn4hPfepTG9teOwL3nve8Bz/90z+NV7/61WjbeIEe9rCH4R3veAe+7uu+7sAcuPF4jK/5mq/BG97whvQbM+N973sfnvnMZ/bWeeYzn4lrr722+O29730vnve85x1IH+symTQ4NmpjFmo7wkS20WDW5xAlzBVGr9wbnJ8cgWGyWK1+vD4hQChWSjhTtKJvcAgQxzFiH3RtHiVdFjmzRBI9lfKAUh5qucEemJr6viUEL/1hyZoVSjViJIpVI2Fx8+AYbmjaSj4r649mhKYtKdICT4HGV7ilChv5Psr+zThRthGjomgr+TTubZco2paLzZ6VvpXgCJw4hhBcU7Rk6SqunDWdKIa2aFJ7ltZawGpoux2H0DiTiTK1Mp30aEBet08lXqo/UL+jb2kv7Y+Z0OttMFJ/a3ubOG+99Xu2xVBKU52TkPUX4T77GhXsr7/YfrKF07RXO0yhskdL9FHZp6q+Q4pE9lGwTRobXWfR7tQRv/qS206PSFu/Z2xl++UWKfZaFO2le4VzpM7oxz3gCNjpdwLOxeLRxOSvDeqtUw6DXzDkvAE4LecN2MCB+8Zv/Eb8wi/8Ap773OfiBS94AR772Mfif/yP/4Hrr78eT3va006rM4vKwx/+cIxGI9x2223F77fddhue/OQn99a59NJLe/UvvfTSwXYmkwl2dnYSPn78+MZ93pk4HHNT+BFh5BieI2UK4pR9rhG0hhieKUfgEq7lrpLHB15DjDaInEQeCJ4dnOB5IISgOGAeXKRwKUYA594hBBezYl3A3DeSJStyieip/qxtYoTORf3pPGJyMQI4E+wooGkY+zORU6R4p4IhFPB02oCZ4Jzo7zeRMnZC6e5FfU8MahjYa8CBsO8YcIxmrwF7wpRiFG1nrwF8fEgyMY7sNXH/OVkXdeRUIxSqXK/9SOmyhLKO7OUsXADY2cvfriXOFC0TZyzp/omCbWV+CbI9iiRKgIHxXJyxY/G3kSSRgKO9kWQoxrf3+E3dtIUMxyhiiryxfL6MIRRtpmT1KxQa4UtzqvTDMKZxQrOULKXgQfF31UJAl4I1baXNihfJIToOKQuWkCfblHChjlXo6gPZES0oW+scEHKWpejr1j1Qx02720Phkul/x3Fzxm4PTvVDrqty7Qubk2GzIrO8xHo8eszL9JfZB+WXg145ynMH6Ia03B9lAgpKtCO3uDHnDpBrq41lilad7QKrPb1XtP+QgaDHi5KStfqWIgUgWbS63RJ36P+0vIDK+klPxiYVYzM+e0ixoVDJA489/lnciMNRTpdCrefd6XTa6widLb/goMof//Ef4/3vfz9+8id/Ent7e2vXX9uBu+666/C0pz0Nb33rW/HRj34Uzjn8yI/8CH7iJ35i7cbPxfKqV70Kr3nNa86IrXDyJI41c3g4tM5hGkYIMotGB8zBy3dWRkqhQh24AM+ZQh2JfkDcE80pxSq4cYyWHTjhgHloIF9HxYgCWoOjw5cpV+cydghwxLE+OzQUImU6CsImiYPmQ/yWs9TfGUcHrBFKdjpuEAQ7YhwZ+4hdnKWmkyZhArAveNQEOAKmOx4hRAwQ9nZUHhdF7R2JDuZ5ozgL7O2OEBi4oAkx6rk3gg/AZOQxYofZqQAOwGgcMGLC9FSIlO/IY+wd/MnoEIaxR+MJM8Gzicdo7rB7Mq7pa0dBcPys2HwSMJoTjpyKTlTbBIxnDjunKOM5YbKXKd7RnDDZj5HC0MREivE+hIKNiR8jzaJ1McLXzNU7iIkcTZuzbBufI3dxrVeZtda0yOtxgLT9CyA+g1KynLP0YOUwkykWO3ExF68MS5CdjQWTOJbRi8xyEo8oZ8FyXuzOWd4kZynK83pD0ZfJMS4ZIJNlK/pc6UuXKRj9NKGb+pBEIokCRXk+KUWWrnXiIMdLUh8oHQw9yZwd11Q/2PqUs2o7f7nA6ZySrV/9dTWmQXmyl/rDPfUP2l5dn7IjpI68OR8pYmscZOtsBXXExF7o0U9ZtIjrbxt1iDmOjRQJVPuU7xOW+sVYCea4TcQQErUjI3cBuPtSj+d95qP4YxyO4jdMYmikzk033VT8/prXvAavfe1rz0jfzqXyhS98Ac95znPw7/7dv8NjHvOYtetvlMTwxCc+Ec94xjPwpS99CZdddhme9KQn4ejRozh16tQm5lYqd955J9q2xSWXXFL8fskll+DWW2/trXPrrbeupQ8Ab3jDG4rw6vHjxzuDadUyHjkcoym4AfbCBGNnnhpmGkyUqubW13Lkm3uoPnrlbVW/TfrWXuAl9tNvNFjfcylXfdUNwnMoZitnFJRsjExW+lbOkP30hHJlIASXsN0YmRlofcziTfqeYnKGlcvGyszAfE7Yb7N8PiN4wWBgZ0oYzyUEwcDOPmE8pwKP5iFGCBiY7MmedRw9jPF+3ExYKZqdPcT1doLHU0TnTdqLlC2SvKZ8mzlnyjjEtXjOUMDkGX6MAlsKVyN+FjsbHgoVZs7RD/Q5bKsXrWUpUfFxcvMNCme0kNOAPJT1l9rbVJ/imkwK2SELLp8fJkZwKD6DxEDaVgIUHXiS/SFh6ouvJms+zfnmrK+ZlRmjwrpNh97L8YaKcvlyABvfkVgwDePCHuJeZ736ap+H7TmNXg3Yc5U9V9nr1OeqPrrtodSPS9Syfarto+zfyDwXQ8PyucFoK42dNH7yvcEghIZlI0kk+zp2kr7B7Yhxz6VzXH3+3+Ir92/AYSkegN/gmaC3yeWXX16sgZtOp736Z8svOKjyohe9CMDmTN/aDtwP/uAP4rWvfS3e9ra34ZWvfCWuuuoq/OIv/iL++q//Gt/1Xd+FD37wgxt1ZFmZz+f4yEc+guc85zn4nd/5HQAAEeE5z3kO3vKWt/TWue666/Cc5zwHP/VTP5V+e+5zn4vrrrtusJ3ZbLaQs16n7E4czuMpPBxGTaRQA4QSBctWVhl7RErVEcMxxw8CC2WpOFKiAQ0zPEj22rH6Ud6HveBGMQgeQqGCMZcIX4OAEWU8omDkDg15jMCYcUyiGFFAQ4xpcGA4jMhjJDjqxwjgfhiBmTB2Ub4vSRljFzCigD0/ivYaj4YC9tsRPDvsCN5rxwggTASfmo0R4DBpWjQu4ORsAg/CkVGLhgJOTicITNiZeDTEOLE/hmeHI+MWjWPcvzcBM2F3p4Ujxv2nJvAG3/tArL+760HEuPf+CQI77O7Gd8uT90X9ybEWxMD03p24FvCYBzHg796BD8D+sYApA+6uCXwLnDoe97/buWuM+Zxw97GYRHHeXSNwCzxwXsTn39WgmQOz3Ui/Hr+ngWsZ8yPRSTvv3kgBT3djhuzR+x1cy2h3COM5cOSEi87bDqGZM3ZOOjgf5c2cMdmLkYf5DmE0Z4z348alUR4w3o/Tervj0MwDRtMYYpjvZswIaAU3syhvjwieR7mX+q4lsAvJ3kq4CWgnEZOPn4dT7LzIxw5N2y8PTYA3cj8WPPeg4ODHDD8mjGYRt5MSh1HEzczHBJsxw08Io6nR78XRgW/HFou9keiz6I+kPaaMpx4E18HzCSOMCONp5HrbnSgf70ePcr7DCE1MuAGA+RFGcDVGTNgBMDsS6cfxPgBEe8HFlwhw1GcX140OYoovIAzk7x5P4wvP7Gj8rvFY9Ge70bMZz6J+3IQbGM8cGIzZbqQQx1OHQIzpLstyhPicmx1RTAgU24vLE0z9IPac1BccHGMq+lEeMD0aI9njmUOggP1jSJhdwPQIofExwz44xvRolI9m0RnbPxbXtI7mDtyIfBYj7KFhTI/FF67RnKQ/calEM4tjc3o0JkM1c4Ifxfqjafy6DVzA/i7hyfgC3hp+Gtc90O/EnIvFw224Bi5G4E6cOLFSEsPZ8gtOp3z3d383fv3Xf73jV4zHYzz/+c/HL/7iL26cXLK2A/eyl70Mz3ve8/Ce97wHAPDJT34S//gf/2P8+I//OP70T/8UR44c2agjq5Rrr70W73rXu/DhD38Yf/mXf4mXv/zlOHbsGN7xjncAAN71rnfhpptuSt8W+6mf+il84AMfwCte8Qr8/u//Pp7//OfjGc94Br73e7/3wPpoSzi1h2N+hrZxaHmOKY0TRTrmAE+ui0koTgSEVTBninSOBoEiBTpGwJwyHiGg7cMAGjAaDpi7JjlwYw6YLcAjoz9CiPWbkWCPEQfMmhECgBECRsyYGvmYA6ajmJU7QYsGjP1RlE/QwjFjfzxGYMIRzNGAcWo8BkMwM07tiIOFGRowHtiZIIBwFDOMwDixu4PAwDHB9+0eAYNwHu/DgXHv0V0wgAuwBwfgnvN2wSBcyHsgZtx5wTGAgYfxSQDAbRedBwB4ZHgAHAi3PPw4iBmX+vvA7PClR1wAYsYV/h7MfYPPPupiNCHgce2dmLYNbrjs4WhCwJPa2zGdj/D3lz8CI+9x9exmPDCb4OO7l2Hi5/ia2ZcwnU/w8d1HY9zO8Y/3P4t2egSf3L0C43aGr5l+GrPZUfz97pWYtFM8bfop7DXHcMORx2PH7+Pq2d9if3Y+bhT8lNnf4FRzIT6/83js+D08af4JnGwuxhd3rsKRcApP8H+NB5qH40s7j8dOOIUn+I/jfvcI3Dy5Ckf4JB4fPob73KW4ZfJ47PIDeGz4GO6ZPAq3jh+Po7gfV4aP457JZbht/DgcxX14TPg47p58Be6YPBa7fC+u5I/jrsljcMfkShzFPbgCf407J1fijsmVOIa7cAV/AndMHos7J4/BebgTX8GfwO2Tx+OuyRU4jjvwFfgb3Da5CnfhK3Acd+DR+BvcOnkC7qZH43zchkfz3+KWyZNwDy7D+bgNl+PvcPPkSbiHLsOFuAWX4XrcMnky7sGluAg341H4FG6aPBn3kuIb8MWdf4D76JF4GG7Co/BpfH7nqbifHoGL8UVcxp/B53e+EifwMDwMX8SlfCM+t/OVOEEPwyPwBVzCn8dnd74SJ+giXIIv4BH8RXx256k4SRfikfg8HsFfwo07V+MknY9L8Tk8gm/CjUeuxkmcj0vxWTwct+DTR74KezgPj8LncDFuwad3vwp7OIbL6EZcjNtxg+BH02dwEe7ADbtXYx9H8RX0GZyPu3HD0auxjyP4CvoMLsDduP7o1ZjhCK6gz+B83IPrj16NKXZwJd2A8+gErj/2lZhhB1fiUzjmTuLvjz0Vc0zwOHwKR+kUrt99KlqM8Tj3KRxxe/j75iloMcJV7nqM3Qyfav5BxHQ9xjTH3x/7BwhweAKuR+M8/v7YPwCD8ERcD3KMvzv6JDAIT8b1AAHXH30SAOBJuB7BEf7+6BNBYDyZroenEa4/dhWc4DmN8XfjJ6CBx1NxPWbYwd+PHo8RPJ7irsd+cwSfGj8ODVp8pbseJ5ujuH78OExojqfS9XigOQ+fGl+JCeb4Sroe943Ow6fGj8EO5rga1+O+8fm4YfIY7GCKq3ED7h6fj09PrsAu9nE1bsBd7kJ8ZvwVOEr7+Er6NO6YXIjPTB6No9jH1fxp3D65CJ/euRznYQ9fxZ/GLZOH4cady3Ace7iaP4ObJg/D53YehfNxClfjRtw0eTg+N7kUx3EKX8U34guTR+DzO5fgApzE1fxZfH7nkfj8kUtwER7Av+Q/wzX0IUxuvRv2G7/nepmzw3wDB87BLV6f0VPOdb/gHe94B97znvd0tjQ5fvw43vGOd+AXf/EXN7a9tgN39dVX46677ip+a9sW//k//2f83u/93sYdWaX8xm/8Bh7xiEfgda97HS699FJ87GMfwzd/8zfj9ttvBwBcccUVCCFzHddddx1e8IIX4Md+7Mfw4z/+47jhhhvwvOc976zsAQfEdQ/HfPS6TzUTjIsBnSnK08IEgBmNrqTeyB7DraPPstDWYNeR6z7n0j8hEzpyAsAxoshmFbhL+vGcWTkx0CCIfZUHMLkkdxzATqKTCGiCYGnbYsfRAVWsDq3WH3Nb6I/ZF/IJzzEKPuMwx5gD4BzgGDs8wxhtxMTYmc0wgk94d38fE3hQQ4BjjPenaNiDHAEjBsIeAB8pdmJgfw+RKxW8t4+4112sHz9JEeK6MmJgWuG57HfiRL9tK+wzjpxzvE4WA0ibqOkCrT4s4zPueybyVjg7uzDLjt2+say7uwKSYbFAnxHPrS3L6lv9un6v/aH25B63n+FgynJdE1BkZxC6s5ZJjbSZFqkvtLkcVB0PdftTLOewuJJ3jqe214PVZvHvFfsPGZdUyWlADpRYP3WzaXsde7pYbo3zv7B+pT9rgdsfAE5O4/PhkJT4lF2/v5vUOdf9AiLZi7Iqj370o3Hfffednm2kJ8629JXT2UPnOd/2dLz4Xf8eJ8ZHMG/Gca0YOTiOi/QDQyJaQqkyEETekKztIkLDmsSQ649E7onQcMAYQtF26js0HCnRlgmBCCMOGEGwc3DBiz5Je0EoXdEPkYJs5aYcibxFjCBOgo8RP8QI4ZhjBC5jidhJxHEi8plEBHfbOUYcMKUGDOBIaCOWCN+uj3jfjcAAjs5nETejGFGbTTHigL1mjEDA8ekULgTsjScAgPP3TqEJAacmOwADF5yK+OROxBeePImGGQ/s7ADMuPj+B9AExondI6DAePi9J+AC48SxXcAzjt95L4gZD5x3FOwDjt92LwDg1PFdsA84dkvE+xccBdqA3ZvvAQBMLzwKahmTm+4FCGgvOgrMPMZfuAdwhHDRLmgWQF+6F+QccOGR6EzddH+cMC84AswDcMuJiM/fifj2B4CRA86bADMP3LkX8bFxlN+7Hx2YoyNg7oH7plF+ZBQHyQOziHeaqH9C8KSJE8y+OI87o9ifvTbiSRPrz3z0NyZNdM6moj+WdNaZB0aE9K24mZWHaMMh68/FOZVPv2Ee4r8Ve85yz0Abov1GFjwFI2cM6Lv4W6j0402ZcctxH5xCH8BYnLIQItb2Va64leMbuzhxq37C4gAp9pKJMW7iOZmHqDNp4sSu8kkTn96eK7yCPHC8lmTs74j9VvCRUcRzH8/pkbHoi/O+o/I2YyBeWwCYjCr9nvpAHE8qB6LDYuVz2cX5yCjLHZXtKWYAU5VLGqriI+N4HIv0Wew3FPuj+jr2g+g3FI+PWfSd2JOx6uTeSGPfxeupcq0fQsbjHn0fIiaARw6/94X78H/95vpOxoOxD9x/Dv8/7Pd9fmNJOYIGP+GefVb6etDlox/9KJgZX/3VX41PfvKTads1AGiaBo997GPxnve8B9/xHd+xcRuH6ksMh634k3s4b76P4Bza0GLmRggU17w57xHIgSlmjY6CBytFyowRe3iKDowDYxw8vIsOkOOAUQgRE8FJ/eA0KzVgHAJa18TvgHLAJHjBhCYEjAWzjw7byLdom1GWe49504gDFzDxbcJN8Bi3Hu0o6o+8x0TrgzAObaw/ig7XuG0xaT2m43FcH9O2mLQtppMJGMDOfI6dtsV0PEYgws58jnHbYjaJMcsj+xFPj0wihTqdYjJvsX9kAmZgdzrDeB7lAHD01BTjtsX+kZ0495zax2TeYrob9XdO7mM8b3He7g6YGeMTexjPW+wejXh0Yh/jWYvJ0Ul8qN93Cs3c46Kjkzgh3rcHzFpccPRkfOjetwfMPI7vnowPXcHH7lL5PjDz2L37VKx//z7QBkwUn9gHZgHNPXvxof7ALDoO9+1F+amZ1JtGe6fm8e8Ds/h3TzaGOym/T1tgD1FPJyEA2J/HSWguE8d+myNicx/rMXKdmc8RFi/1UhaJOEIcm0YA4PWzBZC3C7ORZ8sS6UN2LLzFgGz+Z+r7LG9D/E8jeQHRUSTEPe2C6pNk9Zn6mpGqkUMH2ZwQOUqo+hodKeqrfZmc1V7ry/qtz/1Lcpj+hKp/GqXV+kbe+hycc+JYaaRQz0cvptJRUvuKSfqvY0L7NzP6jZE7EtyW9qyc5FqoPar1BRNiZNJRT/02B72IMlb9hCnLtT4Qx7Iei8V6ffbnWZ9rfTZY7c1z3YB4j6k+c5Z39MUp37djO+Rrn+TzKKzvBQd5aRL9Uby+NG7yZ8sOQYnrq9fv7yZ1ztXy7ne/GwDwtKc9De9973vxwAMPJNlsNsPnPvc5/NZv/dZptbF14A6wNIFxdDYDk8PeaIxGaS4AKVVTaKWmwo4ZQGuwmXBUXuBQ0DTEwWw+FNDoVgwAEBgjpQQBIESHEG6W6ruQ7VGIFCSMvgsBPM9ya4/EAUzYB4xbnx92IWDkPVj2vXE+YNy2yb7zAU3I9Zu5x2jeAidE3rYY62TKDPIBo1YoSWY0c4/xvI1RLI7OCc19gTH3mRKctvlNXJ0XK99v85u7Yqs/rfT3WpmwKjmZ+jpZ9+GZzw98xVauUZJVceBM7ei44VoOwxqVYzHt41YH67n6dyVORSeyVdfw1JRVXZrK1jJ9dapW1q/k69a3VJc6BZ36C9rrtUelvcK+q/ACeV0OxN6Z7A/11F9wrtbVr8/9uvrLrl097tcdq4QY4WvocDlwfHpJDA+F8rrXvQ4A8LnPfQ6//uu/PphJezpl68AdYDlvRDi2vw8WGjRIZmjDEMqUJamAMWKlUIVStZgNxYq43mvEksWq8iEMYByivhc8CgFjxeQwCprVGperjHzGgQgT72N9it9l3Zm3GDGjpZgJNp77hJmAyTzWb13MNDsyi0kHXvBk2iYciLC7P0cTRJ8IO/szOGa0TVxZN9qbg5jhZR2TExwaWeN2MkaieCQO48lZdDyUQntgGvcOMxhBMBAjYgyRM3BimmmtIJEvlQcjHwmFZjEz8IC87Y/kbfuk4IaiY7bXGszAKRNNCAGYicekb/utOlTIlKJiZt3DJRYdJADi+qs+B4yyk7bI8Vr1AaxLEXV+IWNfsS2NnDf93eo7ZCpSJz/V14iF1ad19UXORq7UKyNeEydypugsOiOv7Tmq6lf6yd4Q7rFvT39jJnzVL/Ca8o79ZfaW2K99ij7nF6aOOiFDTsyQvl6rIX2Vn0n9wvnSsWT6Z+V9x2P1h8auXntQ7Ju+BFp9ArhxcU3sISmbJjE0DyEHTssv/MIvHJjtrQN3gMWfnOH4qT34psG4bTEfRYrQhYCxb+FdA1YKtG3hG1fgIJSlC0HwKNdv50neeLFncdvCj0bwSnHOW/iRyFuPyXwOPxohOMUt2vGokLfjUXQ+W4+dmZW3guMOSqN5i/FsjnYyjg5m6zGZtWgnkUJ1M4/JbA6fcIvRtEXYETydw01bTGTdDO3HCNZ4Z4REb8xajHTdiuBG17WcmgPTOWhnHPX35jECputYTs0yDgycFKz1T85ilOvIKFOTc5/XtZycRzxpojN0ymBtf+7zOpf9Nq97ChzXkIWQJ/qpRNjUkWhDptMYkT4LQPpch9JfGtlprQOHWLfAlTMQqgcpc//ktk5ZONkhT3CpTZgJjXNSgf5Wf19Ko1Sqr1RhUjH1lda0pWPf6gPpW2IJG3kjctvn2ilRe66nvjMd7bNvceojlTjVl4m9Y29DOTTyatqy5y5FB6kfV5epcFCG9Ov+dY51gX5tr/Yal0ZHjX7ftdSInT0ftpqVD9XvnI+6veo3ro5PlYpjLx04ahz4MCUx8NlLYjgXyyc/+Um87nWvw//6X/8L8/l8UO+qq67CK17xCnz+85/v/W7rsrJ14A6ytB7H9qZg57C3M8FUaasQ16glijQIZdnKw4cla7Jtk37jA+J3mQSHADZ4rOt/BI98AGbzjNuQHwghoGkDQPOy/nRm9D2wb/BcKNZU3wNTiXi1AaN5C6frTHwAtR60L5NUG+Ji570hLOutlMJVfErkc58XCyfso+MFRNm0zfXnbYxiNYKnbbavlOTUx8X6iVKVtWfqYFl9lSeKVddjUZa3cn0shblPGXudOI2cgsEh40RpUo6whQDM5eFmo001BVpE3BaU9V+Oc6knzY68nkR76nechmX2Fthft76lJBOu5KtSpIP2FtlfEmVYpr+ufNH5IZxdCnaj9muvcY3269JHmZ4OnX66+rSCvr6gLDquc6y07NBu8JDZ5OsN52J56Utfije+8Y34b//tv+H//J//gw9/+MO4+eabsb+/j4suughPecpT8HVf93V46lOfire85S347//9v2/UztaBO8ByfOxw7NQU7GJiwLG9/ZSk0DAAoTmbEOJLv1KqQTbg4PjZFudD1ieg8QEjAMxxaw0X4m7iLPJRGwrcVHjcRnsBcZdx1VfctEGCP5wiaPrZIQbiejL5NxNAszZ9xggUHZz0CCKJSNk3XF0sr0r78xLvWbmpr/hkrb+kvsVc2WOJkA3JNSnA4pmNeBkMOUnzCqcImDhbLZfytHafKwfMnLSVKM8zVBZRojpB6stIn7yhMmKxTL+OcFj9FAFZUl9LWgNlaCiNfAIl5Zn6ayjYjv1af6C+te8sRoUred3eMv2l8hXsL3J+114vuKa9Tv3T1e9xyLDARk3hNsvGlh2LWDwWsab+sntDMQHcOLhljv85VAJvlsSwyfdTz8XyJ3/yJ/hH/+gf4VnPeha+4zu+A9/5nd+JxzzmMdjd3cWdd96Jv/qrv8Iv/MIv4Jd/+Zdx7733btzO1oE7wDLbm+HIqSl84zCZxazKlDU6zxRpEwJGsxY8csmBG81bBKE8nQ8Yz1oEkTc+YDKdI4wNZTrLlKdrPUazFn7cJNxM5wiTKKfWo9mfw03iVgDUxgxEN24S5mkLp1sXzFpgvwVNGhBRylikSRNvt5mPFObEpP7P2pgqD8SI1v5cUv85Jw0kucXiQE2FogRi3anPqf77sT8Rc04ymNRYKNC91lCe0l5Nec5Dxpp0oFiTCHSN2zwYCrQH61YNSlXp1g7qGPmQKVKgpDi5wgDOCOXZV/psakSinivSBIMyyqEYrnLCxIlaRV8nYeskyZ56q9VHPtcpuucMNvqOMrb2NGqlE69+ukr1E2VaY5y+XNuz54NNfxqjnxzkIXl1fIky1ePR82eOr8BL5DUFu0yfTFVrRv+RooU1rvTTuwzlMdqHbZ3ClNEji7Wu6S/bvouMrH7n5qj0ByKKqV/2XqHSnm0fSPcGjRzCIVoD55k2Skh4KGWhAsCf/dmf4c/+7M8OzP7WgTvA4ueM8d4cxxxhtjOOmaNCmTY+gJ3Qnkpxtkhy50PepkApS6VYQ8Bo7qPjJdi1HuO5jw5WCMDcY6yZkEFsaSakDzkT02LV78NTk1nphVJUrJTn1OB5yHheydX2fiVXPFM5lVgo25QlqlsRJLkv5QUOGbc+RsE0cjbz+RgAoUQ5R9LmPicPKGWp+5FZSlRxnfUZ0JMVihxps46LjbTZciajbnZSGZQvoqGq+oNRmnpSH9Bft/66FOjaFOZpUpanK1/anzXtd+wt0K/HxrKxcKb1V6lfO2sHTfHWDtY6WaodOar+L9EnpCzUhe2eY2UeCPMNnLHRQ8yBA4Af+ZEfWSh//etfv7HtrQN3gGW3ITR7M4AAFxg78m/IdlYaWSEfs0bjbs3x230UFCMFIlQOH782kHBg+YBylmMR1s0719I3uF1ir6MfSv1ZJZ/5Ctfyyn7d/jJ5p78L5OqQ6fURlYy5wigdsT75ys7XGfLS+qJnlpapJ/hFFKjqb0yB9mFaYs9wuH0TcNNjz8qLCZp65NUk0Yn+LdBfRb6IYl1Gydb9OV1K9cG2p9dYceOq+lTiRWMTWO6sLtOvnb0zYd+O5XWWC/TKe+oTDl0W6pd7EoMt//Jf/ssCj8djPPaxj0XbtvjMZz6zdeDO1TLbnwOnpmgaBzf3QmFGh41mLTBqwC5izOZwjey+7hmYtaCRPOxk0T+NzG7ps3kHY2zwtI1ZkKC8SWuSS7RrLA+npC+7tWs0bKfJ9ffnmeKcKSUqu6fX8qnPlKhSktN5uXt6n9xSrjPpDxDXqCXMOcJm6/dRnkNYN4XVbUU0guYoR9p0d34gR9z04eslEpcwZ6z69iF9UKXPvo1QWDlVlGSacCj+3kv7VE4YpB6JPiNHx5IZxbW8oliVT+6z5yp9S5FSJU+UKOVrkHAth6FUK7k64Q7xugdz/OpPrmOvj7It+tcnN+eHa/sibyifP4Zs66EdN+fbUq4Qe2pbKVwdBxYnSlfxEnt2Gw7bvu0PkN9N0thTfeQT32ePzLklqz/Qfv3vPop3mX071uy90qevYzvJzbHVY7u+9zr2zFhI/afs5C+K1J1jJSYxbFDvIZLEYMvTn/70zm/Hjx/HO9/5Tvz2b//2adneOnAHWOZzHxfYOweajGIigqNMaWomY6JLDfahlNtMyFXwzMesRUfRdsqspExxWvk85M1iW3GYlKJVelHl8x5s6yt9OV+A21DiWQDms1Ku9mY97fkAtFafy/4vwrpGTbff0L3T9PkYVC5YJx9dm5Yo0JDl6sjZcoYCap1STFxD8r4HoZk0O1GlRfqEYn501WSybCF6TXmKb5R+66ME16FAzwSl2VRyi1N/N21vTX3bXn2t62u7TH4Q9mrbdf0zSXGuot9Zk2ZKh7Jc0/6iDNg++x2567a/UL++l+Izmgbv0XOz+A2TGB5qa+CGyokTJ/Bf/st/we/+7u/il37plza2s3XgDrDsEuWtLphjlAnIER3mzbA3ONF4BocK62d7kpwzRWnXZFkK0fOwfstL5FV9X9lfhi0lq3JrXyejofoL5VhMeQL5Abo2BXqGSooC9PQH6NJQtXxEpXyZfrNEv4OX6Rs5VXI7OWlESie1hGkJXqZ/JuWuxJ3+ux57PfXTte1zhhfI62vVp6+U9CrXatlYWkZxLq1/mmPPneZYPdv21z0/i+rXY9GMNSYsXyt5DpXg3QZfQgXCQzACN1QuuOACXHDBBadlY+vAHWDxszbu+t9Qpvg0Qjb16Tt3icIcCYVaU5rzCtdypSDHo1h/HjImg0fGnlC4RX39APVM60sYQtvXrNCpJCDYrFObNWopWyBTngUOmcK1mI2+finBbnSra+z0A+NWrmuJWs4UKCNH3PooTq6wymHwmS59drUvibaBiSzIw9zSVqSVKDMuNnvOVfpAnhyUEoRi06HUNmV5gZEpQxh72j+l/HRjXks5ompfz7lS0anvPfpY0v4Zk1uMioIjQynKfw3l403HY87vulmejhBpt0qu7Vlc6FcU6hDWS53qI//DjpUCV/aL+tof+b1RPrrSryn6YmyK/fpaJH0qHSwYnUFKlKvjqcd6jz7QIzfjn7SvZizZsdFpv+d40vkfqm/vN3P8I3eoPqU1Dw7D29cuqPcQdOBe+tKXFpiI8KhHPQrf/d3fjT/8wz88LdtbB+4Ay2zm41cAHMX1X+pEeKEP9fugSpcWlGmFa7lSio4yHamUoupaXFCkiuUhl/C8wpXcG9wy4Ct9H/r1te2ifp++hMa86OrHzQNnWhOI/+7ILTa/qZyRKU+gdNjsb4vwmSx9D2M7dxR0STVpFxNTn35tj8pjrZ22mrZZaaPaSr52/ar/QL4m6nirrHEVpvLarENRLjt3vXiZftWe+jAb21uAIfXtS8a69euxtIhiXMVebds1JV5Kca5i3zhAK1GcZOwvGOt99tehROtrn84tZXl9fu3YHaxv5I5AjQMdon3gGATmBedxqN6ic39Iy/d///cXOISAO+64A+9617vwhje84bRsbx24AyxHGHF3f1COLCktV2Q6cl4/pZSkxbXcc/68Up++xSGgWJ81iEPG3vSvT18dpIS5x7lCJVfM5QPK1q8py15KFOa/HjlQvrHX9mq54jNZlq6LGZpEpJzpj7UvW6O2yhq2teqfZntWrvNzgRecj2X6vXiZ/jpyWuwELNNfKl/BPhbo1/Y79St9Z35P8tMYi8v0z7T9+ljX1e+03+OQnc69vqy+2GClyg9JaQOh3cCBax+CDtzjHve4A7O9deAOsniOHzpvXEmhtiF/GspR3hdtNECZWqwU6X6bKdi5ROSUklyGU5aoZp2GCgslqvrqMGrkRJMWlMIssFCcFnuOx6yRES+/JSxOn67l8TCUJ+c1fwVGfqDZD5erPRt1UjpDHTf77VBbNn14UPVvuw2GldsIky31NhKjClvaqqBAFVcTSp2g0IloUVl/ZDBQ4Uq+zF5ak6UYFe6RkzlJG1GOqOxb7Cps5eqsVPKOfcbi9leQF5vDLmuvOn5Axi7KDYcTNvb1HlH7TTUWVT/Zd6Y+l2NH7dsqugbPjgdC/pJF53q4sr6O9fr4tX7TlP3XsWLXlKmcqMTptFGXQk36FiNX6tWv5T1j316L+tpqX6xeLa+XD9T90efWyB0qB84Hgt/AgfMPQQfuIMvWgTvAsj+X7ThO7Mf1YkdG8YGmlGiRRWooTpX7Rdivjtsay7/3xfHRrFeLbXuasemR7em6MkD+HYCZPHQ0YUKjhOqA6UNaI3IF7pHrQ1ujcynKiNyuFn3gaQkLsP61kbl1H472QQxU9XkxbQVUNCAvzlys5twObbSM4kwLpS1GiW39DiXYI6/t2b5afeqTnwZF2Ss/XcqTslPhzCRdYEbphBh7y/AiCrR2aIcc8lXbg7Rn7S+iKAmR8rT2COW2Kp01ij1jO0XsqBgqnbHSVx8wjinQoVzTmkp0x2Ktn8a11bd9JRQvakv1++Q99Yt7s6++lS+41/raEwr1MK2B88F1kvJXqreIbt+WTtk6cAdYdpjjNiKA7C9maU+jGDhTlqtgdbgKzGcGKwXbGmzfgHsp3kqeMGXHq7PFhrzRLqJJ+/T76utk1akzgPVNeNUHoj5zV6WxXKXvTL0kX9D2Q4kCPSPyNfQ71wrlpH268rqsZK/HadjYPvXUr+T27+na69Sv21lBv7a/qH/1vbLItuo/mBTq2agvFCo1TW+Vc7G03mG+gQPXbh24tcrWgTvA4jwDp+YSZeP8NqubxTZC7yjF2Qjd0FZ4HoTCFP2Z4JHc6ImylIfDrM0UJiHvgaZvx7OQKc0+rJSnPkzmfpjyBAwlKgdus0ABs+5NnDqb9UmUKVD1sOw6OfMzwP24LlT9g7J6wvWEaoulWYAurdJUtmu5jXARcjRt0J6hlQiZQk24WSwfN+Wi9pGJwCj9kvRrXNlrVA6jTwajwkvkgxEtxeiXBzGm8hQRquTqQOjLQodCpSxPWBvmDSlRtU/ZWdeTX4w9zhRl4cyb9ocozpoSTcfnTH/q/ldy5nxP2/NHMBE6Z/psj1cPQ8dqpd85vwP6dWS5LyJ2Ovp6byyyN7jeVceiuVecwfZ6JgrVlfJ07Tg7q9Z+R05dub6I1ucyjW/Kc8EhKRzK075yvUN0jOdC2TpwB1j2dSPfhoCRz9t8qANHmoXK+dukFutGun04fRsVPbiiZJUC1QdMK/reYEuRatYnKhzMw9ELJsR6HGL7QHffOsDMUeIoBOmPzgQc0PtmumpUrf6t70130cOhQ6v10ThqxzgJZNrqYO6X2wlW7dXryMhMFL0UqCvrjyv9pq6/oj2dMFIkBOisY6od1LXlK+g3lbwZkBfXhrIc5twUlKRidQCrc19P4oP1FaOHYiTjgBIiRWkcbOdyfx0ZLMdiMcFcO+2vKx3Y1D5V457yS6MdznqNAXTHgrGXzPScj/p4h/SHHD5bH0C5RU41Nm2p9fX89MmH+guU92Jxvof0KZ+34uWPyrHXeebU8pp+1nNnjt8WOR/UHK6P2bee0LJbrljXWxSd3JZO2TpwB1gaIK6BA4CjY5PJyetRpjW2tCGQI2ZL9eXmqCnYTmZo5XylLFKu5NZBk8m/zhQt5FTJK+9r1Ve2mpZZqo/F+rU9Z37rk9MyuU6YRr/jBCyQu4H+FPJFeJn+QcvPtf6s2d+69F57i9eQ9xW7Lup07dkxuKp+3V5tZ2H9Srau/ir9WXbuVr12q9RfqX+L7J1m/Z72uSHAuUO1xYZn2mwN3GEKM54DZevAHWDZCRwjcER5b0uNsFlK0yY0EMo94FSuFCyQ92FTuVKY+rBWylMjDZrVqXJNKoBg/Zi7Ukc+lG/UvpJrNMBSO0RIPE3tEKaywR2tfUz/riYoKx+69+t1NUr16lu6UtEJV4YbGsBYIq/aQ097VPWHNmhvZCM0MLSQ4tOQO1qNoj0deRF9RBkBkUXcxdAhc+xKYdabHGtUo47uJcebsn0yhpM9Pdc9EaQ6GmtvFhqyV/dP6liK0/bP2u873rr/tb49nzD6i5YHLNK3DuaZ1LdyPT9WsK5+3Z4dy73yBWO/tz23RD5cnwmghsDMIFAaovpoZSKQ68pBhEBAOET7wPlARYxg5XqHKMp4LpStA3eA5ZSuZXPzchsRjZBZB2zukR74SonqQ0X1yegrnQrEJ4DaA3KSgd3I1lIuNaWqiQY6GTGyw6eRslDJEUpsKdAN/bSi2EkIwNKszprWKmgcMg9eGKdhQJ7eymuMBbjqS8cJQYnr+pa262x9YTCZ+pai1czDPqxZqlq/IQBKmVIPRokJecsYPX8jOnN40Ua8OmnaoudKZ7h6HVPTd61N2/piY528or1qEtH2ycjtC47N+tT2dPJK0daqfetQOhjHDHlW1/VRru5/jz1Uv9njt2OFzFinFfRrer1XHz1j05xPoDxeq6+/1Wvy+vT77HW2NelpbyGF2nM96pdD01cmgJRytcNAsThhaWWIdl/kgeJ3TbU7gVDsMhMIIHKFHIjO22HaYqNtHeaWJVq13taBW6tsHbgDLA0QEwQge6ylbEnjUAF5TZyWmiJdRqHWWa199S0FmuRc1a9sWodMHTlbNqVA69L34OzIsVhe01DWqUr2XYVVrpOiq3BlD1Z/waTvlsg79dfUb2jJ1wVW6N9ChxTnuLxnkj0de3Xpc8ixor1lY7W2V+svuxewgv6ye8XeC6k/Q23JuajvnUX6C+1V9dfV7+3fkvpLj2/FcwfE9xqiYnhYXx5E4rRRR85i31Kh9ROzD3vnEBo6VNuIMNNmSQzbLIa1ytaBO8ByJHDcIJdG8oolUTP7WSlCjpbp2LVfNiDkPdP0UaBfR9BSU5yDFKhgu8WHtt9bzkQoDfmhWG8FomXZupEhClQPaBlluZDi5PUoUDrN9gh5g2Q9vYlSlWOsNxttBuRqz9JMxYQlk+OotudKvE6W6qpyuw9ZyhpFjJgUmMyifJTRSB6Q2/rWEeeqPiieG1u/iMCJ3Bl7url2wqKvLzgdilIdALGnX9FQuf04etE/IGUe2rGQ9NW+tVe9VKm+XmvVt9hGM7V9W38RRbmK/dPVr+/tuqxaf1Ce67O5V+IVy2OH5PKovT6KM+jxMYNBObqm9auhwSaaSdp+IUchD6a+45wjFojQHrYkhpaKmMPK9Q7RMZ4LZevAHWA5GThu6eEoOm2jJt7pnrtJBJbSrClW3ZfNUX7S6HdUAXlNMw6f4vQwMxE/lQ9lfZ6pYp9k9Vv8kFyL0klp64OaUqz1XYXNpDokTzQHVZO+yg1tJIuIy0ndUq5Ah4KtcbH1BWWaTx/i2r46aImmWuQUKF4gp+r86XUoMGWaUc9Fos0on+/Coawp2D656U+DfD6IslOpk1zC8huM3EY0E+VoLmhyiGBkLjtI9npr/1hOQG1vsD3tnLnWhb3q/NVZmPZ4UtepdAi1vh27p6Vv2zeljwK1stq+q/Qt1jaKjYN1LA/oF+27xXJrz5zGIcozRb9Enx2VTpWjwpylOJkAJlfIvVx+S4FaSraQG6z+vOprD5Uy1T7Vck8EYk79bZ2L/Woc/KJv0J5jZeM1cJ3Bui2LyqFx4C666CL8zM/8DL71W78VIQT81m/9Fl72spfh5MmTg3Xe//734xu+4RuK39761rfi+77v+w64t7E4hmwX0uaF4Pp00ExOouyw2UxN3ZrD6ttiadOCQuX8m94M+jDWdT/WRmV284MtH6RdOYblhC6t5CiPziF5Ub+mFBdRjCvILUWpDpilrRbWp5721pDXFOnZpjxHVB7f6VKcdanfsnvrrynHOvWxQv/WsKeOxCJ7df8XyXv7U7V1oPo9Tt+QPoDOGkVb6rHdkeu5HbBRnVs2PwMSxTIOUKQw+ylOfV8LRs6VnIk6cl/IUdi38j794KijjyX2UNkLzomdQ+TAtdskhrNRDo0D98u//Mt41KMehec+97kYj8d4xzvegbe97W34zu/8zoX13va2t+FHf/RHEz516tRBdzWVXUASFITSVAfNW8dJnTmDAcC8RXbWtwHi2AWpP9SDM+SdqcMSTNSueEtWjP4Hfz1BrRpR0kOwzhMv0F8lQkUAJq6rnw60D2N1OSFTpBvbM7jXXtWeq/QXUapnRF5hnWRTBEyjj5SjWzbaOnLlPoOdrFQXxzYPyHvrSxpnX/2CwgSKjZNTNDWYiFNPtNW2V9tzPfZ0yUOKIJWXEED/2C4oU1RjmbuOGGHYPjDsbA7p185e3Z8+ffu3LnpoQ/I0tGs7VPwBsgMGAEH+YbvGpr62p45SslH1p5CTRMTEjnXs6r91f4B+SlXtoKc9S6Gm/lDMQk1WiRAA+MYhHJ4PMaANDvMN9hFptxG4tcqhcOCe/OQn41u+5VvwjGc8Ax/5yEcAAC996UvxB3/wB/iBH/gB3HLLLYN1T506hdtuu+1sdbUoe4BQm7LvWtpNm4UyNWuROkkJwTx8GR0KVJ0pqh9Rp1GsKb2PklPG6HyD0TpFSjVpcUD6QHaKOAl2qqtyV2FCGRVYpA+ZNE3fC4oUub3Ud1dlOhr7tEL9jhwZE0kEjfITvnZi+tZpdSjYIXtGbrNMifJWFAmvIE+UqdEvKFOqMPqzWjWUUVCYVt/WB9A0pbyhUs6NcahMG3qt0qJ66VtjsINpX+R1f2sKmM3saK+PHrvd8Z90LMuf9EF4e77sWIa5F8y1tvq2pLHCyPS3qW+9llrfOpjp/Jib2Z4P/VM8QuzYM/+ZB0JcsaXq2XHRY2aiuBxXu22eEyz/SNZUnnDsr/4SpDXtYh2x8lZO4ti5SEMCBE8iFycpyPkakut/JMeptwwKnB+CQc5P7F+Wc5JT4dt65MckS30yL0QedjgQvJzftmkQDlEELoT8zrNWPVqusy25HAoH7pnPfCbuueee5LwBwPve9z6EEPC1X/u1ePe73z1Y9zu/8zvxXd/1Xbj11lvxu7/7u3j961+Pvb29Qf3JZIKdnZ2Ejx8/vnG/4zOV82rUeqsNxRqBs5QqQ5w/Li0WsMKnU06HAgXypA6UTkCSux79RfIF+mnS1L5R/oyYbX9Ivxcb/d4szzUo2dOtX5/rpZRqpX+6lCetoo/15FinftV+HRWqSz2W1qUsl9E2TU//F9mry+m237eGc5n+UKnHXrK3Wv/rxw1TLafe9q2PyD32koMGgJ0r3h+5Ix+mQANRR17YrxzAWl5TsNZ+b3967NXyxZTsMGULxHcuLxTqYUpi8K2D3yAC5w84C/UwLsVaVA6FA3fppZfi9ttvL37z3uPuu+/GpZdeOljvV37lV/D5z38eN998M77qq74Kb3zjG/GkJz0J3/Zt3zZY51WvehVe85rXnJF+HwWQomvpDq0ySDvlTHlkS0pjKFFSbPpp3+KVVrKUaS8NpRg9EaVFuNIfudK+Omd6aoYoUy0jXRhdyZfVV9yhWJfo10kD43Xra8cpywss/9Z5Nu3JNqRvcDE3U+UcUU90ECgoUEIZ/SOYiNMK9TsU6lB9014dQXI63VGuX2epcjD2euSJYq3toxx7ROXYG6JIbRLDkL119dPxLtCv7xWr31ekPlc/JewAuy8ZqNynzOqzsRcqeUhyKtqrHZu6P7WcXbc+Gx2tMESRLqJQl9Vfxb6lOBlI576PAo1yWihnGq6vODpxh2wNXPWxn5XrHbCPehiXYi0qD6oD94Y3vAE/9EM/tFDnyU9+8sb23/72t6d//83f/A1uueUW/Mmf/Ake97jH4cYbbxzs07XXXpvw8ePHcdNNN23Uforz2YdxirefBUfNzusEFF8KVqfN6unE7whxEYfLk6ClpRyE5jK0VYGRM/PUXqJfOeqPKMfLk0Mocmfsqa3G5a0cHCFvlsrGIRTcGIpV6w86UFw5YJQX8Rdyc/4S7rGnDlbHgRzSV6cKFSbjgOisInpK8em5T7SYqQ/q4pRVim772gFLQXbsVfJN6qMaKzo+9Phs35I9Kydzbq286ZdDsDOUrVKSC+1Reb6TPtC5F4Csr9fX2icgU77SxpB+5/yKfvq2Z3RyyHzrM94muT7L7aslZWKaW9pSnMERHKtDQXLbkJzy6FxkOYp9zhiRWhSXPC62h8jtLS7tBUKmWPUUmP6GKtqqFKr2NTtZJHLjBBKgW4PobxrNIjm2oO2JRimXR0pB0WZ5wpQpXU8EkoghS3+cOpFyvH3yjM3xUmkfUMeNEJw7VAv8/XzDCNwBcqiHdSnWovKgOnA/+ZM/iXe+850LdW688UbceuuteOQjH1n83jQNLr74Ytx6660rt/cXf/EXAICrrrpq0IGbzWaYzWYr21xUOi8gaVI5C2UZLVWXpRTmaVCg6tTUtKCVL7LvSKJOA/X72nPVsY+aSr5In3r0q/4eJAXbsee69jrXdgEFu1Rupyhkp6PAS+Tr1K/7X5dlFOOZpjSX2atLPVbXpTTrsbtMfxGFWdlLUaEefXUa+ihM+7emMIH8LAtAL0WpEbjoEGaHRdsLlT6Zf/e1pzh9YayyNyhXB9EeT6e+W9m+rd9vb5gCVWcxGIcNKClULQv1m/gd1MO0ke+8pfhxoXXrHSCFejaXYp2t8qA6cHfeeSfuvPPOpXrXXXcdLrroIjz96U/HRz/6UQDAN33TN8E5l5yyVcrTnvY0AFjoaZ/JcvQgjSvtlN7eBAM9DgJ1HZpaXnx+CBWu5A11F3VbeU3zuEpuKVKVr0qprqvPKGmsvvod++hxWBY4w0qZrqq/bA1a7dyNq/SzZc50n8NgZ6G0Bx31y5Xi1FBGvajdVfX7nNEhOdAzVk17Q/YG5Tq2jby2T3366Jd36ldjpb43VtF3rkOLsRlrZOUS0enTZ2Mv1DRbklNqz+qrPRIdlbOjhfJF9dPxngZluly+xL5cyySXa9GHo4PnBvWTvSWU5qoUKWDO3Rr27A5QSmfHdXCHh0INvGESgxxivfZ8Op2edmDlbC7FOlvlUKyB+/u//3v84R/+Id7+9rfjxS9+McbjMd7ylrfg137t15Izdtlll+GP//iP8a//9b/Ghz70ITzucY/DC17wAvzBH/wB7rrrLnzVV30V3vSmN+EDH/gAPvGJT5yVfk83rZjmIzsxmb9KmaVvNBIiB1FTnGZCKzDyuioGCooUQNp9Xp9qHaz2LcVJhi9RjK49QBymyp6lqZQCZVN/5FA8xS1FS1Su07L2tT91+w5l/2rKt6ZA07UhWZOH/MpsEyiSfu2gIV9Cddj0WumaNpslCj1+yhRscqgA84QvaTwr50XymuLskWv9PgrXng/XI6+dGtNEwoU9M7b77C2Sd+wD5Ua95loCZf0U2DXnU6+V/uwo20NFWToIZZnb61CcBBBTSUGKPC5iB1ySR30n38NUfSf6QeVMifJjIpPZqJSo6ENvU3VclBIt2ycq5ZTak/4OyeVc6hVIFCVn2/EnKuR67RbJ0/mAOFrVZWGY+pTrWwrSYkbeJkTlnuJJJr1WQBFR9nKtrH7MWoUkKORz2y8nEHLEryXAIWfpKtYD8wSQq/pLFLcROURr4EZzwqil5Yp1PTkP9bKl17zmNXjta1/bW+dcXIp1tsqhcOCAGMJ8y1vegj/+4z9O2SP/6T/9pyQfj8d48pOfjKNHY9xrNpvhn/7Tf4qXv/zlOHbsGL74xS/it37rt/BjP/ZjZ63Pac3Cuh/1VaeKrCNQ/e1QiHWUppZvQIEWTskiihMl5VjrE8qoUC+lWU3CdsuS09XvOGQoz1dtr9ZXB9c6dMXxUVUf6Hxr0joFffY7WaYocZ9DWOAl8nXr4wzK63LaFKkr+99nv9a3xV6L1N4C/QHKMZlpyj3D4FyHtrPNsqOOPBgcTH2lLEOlb+uHxhVyoKTxlHrrk8f+lO2pru2vlvRxFHMeakqzK3e9ch6ob9uODuoCypOQKNO+a8NGX53DWh+mXtzWxHWuHXpwopWNw1XL09cdjLy+VoqTPsptU7xzyXE/LMWF+N8m9QDg8ssvx4kTJ9Lv0+lwOORcXIp1tsqhceDuueeehZkin//859NbGAB86Utfwjd8wzechZ4Nl10bCamTFtaiQFFOKoTuGrJ1vgywzAGp64+W6K9rbxkFO27y+QGyM2kpXIuX6XfkVf2l+pW8jjCt2z+3RH+ZvXXrL+tvn9yWjoO1QJ7Gok6dKG0P6i9or+OALbhXFuinHiwamxLxGKxPyJGaXjkl+Sr6LPdKob+MsrRyjUxp+3ItN5e706rPtHn9TfRPp7/rHn+vfh0ZtNdW2zfyzr1gcHL+q3lBtxIZ3Az5HCzNnNC0G9STU3PixInCgVtUHupLsRaVQ+PAHcbi09ov/RID4v+WUaANShosUZyKK3lNSTpUmEo8dpIFKli/VRko/jBqhALlLB8tsDcy9iD6ztgbu1gnID6stL+q3ye3EapeOfr1CRlrlmqiZF3G0rWkT0Z/MOHClZjl2o0oXwtSOSPtcJo2cK7sKQXdG4GC1KcuhZmyFnlYDiNfRHEOUpZSTlcOMuEW055eW4cSD1CeDOTMRUKkrZijLFGa0X6M6Bist5euVUr3DqfF4ST2E6Upx8NOMgfhQMwIlTy4iHXiCUTwDmhk413VV3mmTOOp6tqT0yhZ0N7pLe1Sf6N+xDFax7l/Eq1TWi5SnDFPVOXxNIpcnEt1eRNWSpIo2Qc4Z2n2OC5s6pM+25jz9QJysq3Ic8QvU8hgNpStXm8q9Vk33ZX+CKWsbi9Ju8XaNO0vEZw4WYliVX3EezbqU8yCJcpjQ85V7G+miJ3c7kFkSqF2skrl3PZhpriRL5mIpbcvBMsi2+dQGbeE8QYO3PjMdyWVw7oUa1HZOnAHWKYgiTQhOkNeZzgMUJh9TgO6UYrOJIoclVFc791Vf0WhaZD2H+vTrynLjtyVfEttz37+yJHZu0xwTSEulKOHEkVZfyV7PKxfU5gF5UrZ4Uu4ktcbC9vL20cZ1v2v7S1qr6ZkrUPaKxeHru5f3b6V27KM0lwWsetE4JbQ+T2UJ7Hx6VwZ0eKe+oW8lCbKS2Vc61Meuoy8NUafPADgxkHnKp1o20rf7qjAzsEbfVTtsWlPcaEPvfXEaXJNoZ/l2v/FWZ5MrpMxb9tj15XDyK09dZpyf6iSZ4dE69uhyIjnEwvksL8Riv3Rsn5ec2jHrsp95YBqnztfhpC6WU6pbmGv6p91FosvIQKDOOlXkTa9BofpQ+8uENwGWagHnadxGJdiLSpbB+4Ay25DwKQBwEDLpYPjUDpclroh8xuQHYwheV1fF+Vvak+TDkwYf7G8ru+WyE/X/pL6tUOi/dFiz/2Z0K/ltERe168mjU4EcJn+MnldTtfesuOr5VKSD0NIERG9tqtsJptsSH/sJIke/Tw5I0+khPS5pI6eYsqRG+3PQWwMm/q+Yv14vKvrryrH/7+9846Pour6+G9md1NJgBBKaCGAgIAEUFRURKqI+mAFFBG7gi+KoFKkgyBqECu2R5ogKioiFhRFFAzyUA1KlU5CICSQkJ6d+/4xfbObLdnd2dmc7+dzIWduO3N37s7Ze27RpHGUHdtWG+/4WTiPd53faXq4K891vC/1y9eYQx5X8e6eNWeyt+kdZUEy6gTHH0ohjKWcg7Xch3z+V0WHGadiVQUZcAGEWXhxV3+BF8fYZZef1gUKiAZDJZcnVFl2Uco/ERWXp1SRHC//4uE5vcvTJpUvDwNoV10yADZOdWkyx3im5neszzG94oK0uHDRSvlllyjTxDtzmWrvX/kWZRqXqJzeov/WcxyR0q7ihEN5ztJb5Q7Mqe0JzSXtiBkHdZsP+SQLq0aW6wPTrDKV6tO6nGWZ4/Rz2jioP0uZJj/gJp6psm5nf07/rHGSfnK89n615TGmkxmD4vWHhVNljpP26OV0Lk+5PvHoJckQYZJhovMwS6siIZ1HyUFxWwHicUJ2DsrGsEwjc1JexUXJxHiBE/8WjTO5fCm/5mMEOM3KQkB264kuSzGF6lLklPyqfh7Eg1M3c5Vcsmr9kn5Sfk6qW25mppQPBxemdrNb6RRPKV5QxqPkrw938bJLVr0faPQTOHF+mLY9VLMSqgtUTi+5eLWb8QJQN+6Vni1O83kyQDqrVDWaONnl6aiPNl5jaMsuUvkaL5WnTS/rz7koT1u/3NfU+uX2Z1J66GS5+2n3pJPL57T1u5Mlg7GCV921ZoAXuGotYiA8gwy4AFLCQRyBYxDPFamQjvvh4GTeEq83CrTxyoiZRq40J40XP01Fdoi3OotnqgFls6iyY355Gw+4kJ2lt/EO+rmrT+NylfPr5tQ5uGR5Tp/fZtHn5x3KczTotC5l2YDUGVRS+dr6XMUrRg7U9Byn/px05bKsKt7RxeuoP1dVvBuXKs87KU8jSy9lXXpNtOPEbGWnf0XWjxRoz2EHpHlZklHFIL7ktbI8Z00xoCycYhsLnLpKU9ZB62KU61NckhwUF5vWiOEkI0M+iUB9ATtxsUpGC6fE612WWltYNAAd9NM0jiDpY9fUJ9+7ojvPK4+WHM9096N3QYLjVYOD43SrNmX9eW35nKNLVX+4vMBVdsnq4sE7xDusQuU4jQGISvpISZT0TjfyVQxMedBNNgAd3NlQDXOlrTQuYTle6zKV04v6yQaZ8/q1styW0HQ9ZcUop5eVNBwnGcn68plD+S5lThqB43kI0PerUMZSzsESgiNw4QYZcAEk0soDUdK0zDLOYR4X1G8xDnq3GQe9G0s2gFzJnFRWlfFwU14VLlVv63fqAuXUb0mnLlb1S86ti9SxPN7L9MrfbvSV4R3SO43XyMGO5xzi3bg0xbURGpl3kDlOL8tVQmOQaF44TFO+Y7w2v/y3wHuXHl6WX5V+7tJr41XjzHl+9WUr5neUnabXPqPO6tM+o070rZzeTXnSNWfzttzV5658Z+mVAZQq0muvu/tsPK1bLc/L9C4+W3+U77w+7/PbOU4x4syCrQKw+WDA2Zw9KIRLyIALIBYrD0RbAUGQRnCkIQYrLz6pdkmWR7QEqfvKqz6duSwB/YgXpLSuXJyO6Rkqu0QdZXkVqSsXaqX0kktTW79uRM7R5enMharJb7Oo6eX20r6R5I105fLkVbPysIa8ClXrMpbbX9aX41SXp80C3YiadhWnXJ5W1rowPYq3VJYZc5CleM5ZvFWVOQAWizgipEnPNG4oVZYu8OKKOXlFIHhOM6IjHdGjGWrRjUhxHOwW0QUlX5P3N5RX3tml9JyUXszPlBE0rdus0oiXE1lGWfnnmJ4DOM3Ih+KiZNJoBeRBQk4xKtSVhqqLElJZyqpNzSMpPQHKykM4jLTI+imrRqXXrhovPqDKRrTSNce9vJTRPU5ymUr5lMedl1yWyoiUGKN1yQKatnaRXjGwuMqrTsV7YYo+Wlm7J52zeOamPFlWVn3yckvAIV4uX9RTPntVkNz/2vqZVJ6jzKBxybpJr70/MI2LFwwuXaKc6nJVPj8AzlyuVbmAXeWX3c86l7AUb7ZtRHi7j4sYfMhTkyEDLoAUcwCirKKhUCEA5XbJaOBEt5SyqIGr7DLVGi2uZGVOHScaRdr8jnJV6eV92cAc0ktGg4VX50kBlWWed55ecIwXVINOl59TXaJy+Y5HZ2ldrK7SW7TxGlluX60+2vxy+cqb26F8x/S+xHMai5PnAM6h/bQGqay/bGBKoxRMG6+RmUN5ogtQfiGpBpJs8Nl57bYZgJ0T61e2QpBGKDkmucB4HhWSrJTPmGhTOqRXXHSyDEjzgJhud3po4rUvdSW9xsVpl1xwqqzOW1KMEim9INUvN52uPI5TXJRKPKcaNXBRv+NGrJVcsJqXsj6eU9ujivIFjte5cJnkEpXvh/GVXZayLLostem5Sull80TbHjqXM6B3GWoNEI5z4rLlKhlwev3U8mTjWdCVV3mUTZ7fpWxqK38datpfn95h7zymbmMCzeehlsfpZHnEtHJ6TulyjrJ86oXj513pfl3IctvLeZS2h2oYK5sMa2TlMHsTGXBWHxcxWM1ziyEBGXABxGaxiAYcA1BaoT/T0p0LtUqZ08uO5VXX5epJ+qpcvEp6OE/vWB4HZV6V8/QcdN+q2r9dpeflhE7SywaWIjvEy/eiK6+K9Nq0zu5HaQv5Sxm6lwbjHWTZwNEYYXJupskPqC9kVy5GxUDS6Ce/NFylD6bLkkEaJfKq/Kr1qeQyrqI85/Fu8sN5fsWIcVG+Gu+8fIaqy3eaXvuMuqoPqkHhvjzoyqv07IFzGe80PScZkFzleOflq0aMJ+kFrrI+zu7NmexNW/uS3ln+qp5NV7LAiVuXmGkEjrP7NprG0QicV5ABF0BskbILlakjQAKTXKi8xoUK/QiZlVcn5TOo6V3JNmnVp1yezaF8rYuVMSk9r0/vzIUKTk3PA+rGvA4uTsVFqo3npBE3TqxfWQTA1Dlwsqykl9uD07hYmX6jXY6Jo4XO0jtuxKutj4Mm3qKR4bAKFOqqVimeWdRJ9gCkES+NLOXnqkoPgBOklXHSaKu8BkPe90p5KTmMSNktvOKiBIAKKw9OYKLbiONgt1rACUx1u0htxzMmjkhpVvoxSeak0UjGcYosrU9U8submwoWaZI8UydUcwIDDwZBTg9Nep0xKslMfYSYdHccGCCNaEC6P60LUtx4VnqhM7U8WW/tykNldJBTDQDxI5RbUaxPPpKIY/Ijopo6HKSRHUkf3km8XWklTpe/Un2crD+vjA5yyr2q8VoXq1y/AmPKsyAVqb7ENSNuSg6mz+8YL696VdMz3bPGwcnopqYsaPRTXbhQZAZ1rp0c7yg7pnc8equq9FXl144gMk16rcwAcYGNZkGKPBIn9yU5j6OsW+WqjJ66Tu8yv0ZfBkDenFmZYSI/GxrdwXGwc7z6LJgAnxcxmOcWQwIy4AJIIQMQHSEaSnYmulBlF6Y8D07qsLqtHJRVmtDIvF52XBXquOpTWXWqqU9bvtUibnutTa/9eatL78Tl6Xh0VqU5dzwgnyyhuEAlC0nrogUqyxyn37pCXjWqS6+ZJ8Y5iVdkF/HaeV8WQL9qldfME2OKi5Rp9ePV43aY7NK0yEYRL30Ji7KdExcFyEaTnRfrk2VBcoFyTAADB4GHIkMykOy8lF8yiJhV3aZDkNpfJ0Od9yPOWVN3hxek501rcMn5lT3QGCBuACHF8w75eU6xn5nkUpV9Y7KLVrZMZNl5er1LSm4PXpoP6mzekRyvuJe08bJ+TGOEcPIqzMrlMenz0s6RkuOVsy618XDmElVdmFoZnOr+0hpFjOc1Ll11d3/IdUrGnZxfdkEzpXxxTqK8S4+aHjqDVnBILxsrOplT5yzCsTwprfZrQbfprCY906bX5JH/d8ynbHwr6+QmvXIvUn3KcVUaA9jj/A5ns2oNZ+9drj7k1+irfdbk+9EZ0JwoiatQzWPdWAQOFh9G0yy0jYhXkAEXQKxWCxArrUItKVeNLtlAUob/qytzzjd/lXGXX0nPqX/rXKKOsmP5zuI1Bp6jPs5cqv5Mz3G6e5Mn7itf8g5fwkwqXxnc0MQzqEaN40tCjeeUeMf08pewdqsNx3hUkd95fXBI711+AVXr6yy/rizH9nWI99qlClSKFyyaeM5dfNXlC3C+ClObv+p4wHErCFf36/z+XOunbQPFiHFTnmMeBv0IFKB5VhzuTxvvKr1j3f5K7yy/bNg407+q+3E00DytT2sk+Su/42fpSvb0WXCU7ZKRbaajtKzl8G0OHO8+DaFCBlwAiYqyigac7Da1C+rfERZRZpBcnlXIysa4TIp3I8suSgbxmtP02kUFnDpCpaR3WJQgx8v6WTTxjosMbLw6osUguVAlly1Y5X3MbLwqy/pzkDaHZWBWXv7RLX6R8o4yp5cruUA5cWRGKl92ccr1CQ77oNmlbxHZbamuuhQTyLJuM1JAWTlnt3BOZWXSvoV3kPXpBU194he4VL50S0q8E5lBPwLHwIn3y5ia3sGlqnUjyZPgnbmZ5JV0cjwAxWWrH4GSLWHZpastj1PeUBxjoktSk19wiJf1UeOhvAD1K/WgrFrVuijVY7CkUSxNvKgfXzm/DGPiqk5lRI9p7s1BlnCmny5eGSFT289teVKZjuVVcok6Sa9zoWriFaNCWx4qjxA5GjTaARJP0rvKr8jyswq9ESs/q0p+h5E6Z+md55f0U75e9PXJOjqT5UUL4tmsal5X6auSxbbSlsd5np8TXah2xyXMIYy1jIO1zId85rnFkIAMuABSxBgQGymuQI1gQJm0CpXnpA1+LaoBZLOom9u6imdQDSrFhcpE40h2oUJ6OVnlOXTa/NJXguKC5NVvC2erRmUXprJKU2MgOttIWLaQlPxQ6mcWHpxVLU9+Kcv3wyzqPCZtPJPSCxZOnUPGq/OwZJlJbjUBooHGLKrbS978VZU19UvxelmdFwZOjAfHgxcETX4HlybPS24/ycDTvKSdyaIbC2r9nOxyVU8iEBzTS28/eV6YGM9J+utlQHVriS5MHoLWZSq3L6fWx2SDUUrvOKeNk8q3a2R5dIfjoSlP3nZEE68xJAROvypULE816AVecvExjYtUY2jI5UPKr25tIcVLc/Y4Jb94XW5h+VmQ56TJc/Tkl7zsolVcnMqgieoG45m6dYcqQ7lfR5cl5xAvt4fcheTyoUkv/62b7yddU4xtQPdsOUsv61fJ5apND/0ok9YAU1yu0t+CJh4O6R1l5/nV6QVyWrtDXll2di5oVemd5Vc3CdEbSYDq4nQly4fJcx6mdybrjTN1NF6bXnAlc+InI3B8pbYIZXgfFzHQNiLeQQZcAOGsPBAbIQpFZQ4uVItuKN2ty9Rxo11v4oHKLlWLQ7xuTpuTeK/yc+peaoDiwpRhgM4FyhzKZ3J+Tv3FK7sPmCI7bO3Ac5p5JFDmHWnjtV+szvK7lDUvOWjK4DT16Vym8N5FqS3Pe5eqQ3q4S++oT9X3J7gtr3J+uzZeuidP9IE2j6Z8rYlQOR66Z9HRgJC3snCVX57XpI2XXbTOylPyaMpxOjdMcx0O6Z21hfZ+3bkUtXO6mOb+PEuvmS5QhT7aZ8l3lyWnc0F7n9/1s+dJfu2iFt/19y2/LDsadc6e9apkO8y3kS9f4dsiBp6OYvAKMuACSHRMhGjACUydxC//LY+IKS5Vq+QylWSbgxxhFUfyoI23iz1cHlHTrXLVjMBZeTFeLs8iyYIgfrs4ukSlo6iYPOJmtYCzSJP4pfycNp7nwMmT+hkAiyxDvCatGhWUETV5kYCYXp6DBkGzGSfPQR7xEzRHV3FMiuecx+tlAGCVvvjU1Vzi16rsolS+9B1WgbrefJRJ5bkqH4qxqUUdMVInYuvTcy7Sq8aOrI+g0UfUl4M8mOUsvWIgSvUro0SA6qbi4KY8zYIWTXlyJsVNKV9QPwolnkkuXd1KPe09a+6d8WLf4SRjQJ40r+jjxOWruHjl9hcE1W0lP0va9tCMkIHnwQQBvDzapI3XtqNjfrldHdI5S6+9T8f7rl76ysaoq/TafI7t7o3BKcuywVSd/N5sU1KV7JgfmnTMQ1l7XXHFepHfaXmc2vpVPSva/8VtRHgInHkMOIsdvi1ioBE4ryADLoAU2ZlqwEUIQFmFasBF8NLbVyMzS2UXqyxHalysHCcaXbKbU1nFCVXWulw5DszGiyOCksHFrDw4TfnMJm0mKjBx8ai0dQWTXLSCVVq5JTDVhSmVL7swOektLcerBg4Hu8UCi2xg8eLu/hZJX4EXXZa8ZCAKFh52XnIxyvFyeUw0yASOhwWibOdFF4OFia8AR1n+9Wph6qpKJrnpZFldqSjJPKdzuQocp5wAKY8qOLpkeRfl2yEaBcocOg7goK4clN00vKCXne5mr8RryxONJNEgVFdRygaaHaIRoneZQlm1aod8dqV4wc45pIe0SlLrEgWvvILUw+TF+u0cwPHqSkxlM1M5P8R4QRMvlw+usv4VHAfOYtGXp9FPLk+7u778rEDWV2NECxwnnlQgG9DyZ6dxO3I8Dztko0ItX/58ec39KEaekl4c4VLT8+DBNOnlERgpHpy4RseD9PJoqPJ5OMrKsyoqI8ZLbjxF9iC/1gDm9H0Bms9LduPKAyfyaJvaVwCtGSPLzEF2/HGkyJq/tbLeyFJdsq7yy7Jd1t2JrG6kwyl/6evnYAfT5HcmQ3NSrF4W+6b2btV45kqW2tcubT5tFnyeA2ceGzUkIAMukFh4sNhI8UWpXYUKqBP3tTKqkh3Glh1XJGnjOehcnAzQuyydxut/tTOLOi9G4ABmUcsXAN0B1KKsn9chWDTxHCBYLOq8FCm9o6wvz035HI8KWVcp3pms3B+gvJChKV+bXudm4nm97MSNJDjk5xzya2Wnu7dryq7SRQnAq1Wx8NzlK8cL0NdXVbzgRF93+R3vp0qXq2zAOsnvrDx54YP2xe7sRc9B/sxUI5Y5lOlYlyv3sfv0nFfpXaVzlV45qUBzvar8TBc4j13AjvkBtf2qSu+Jy1Vn8FaRnrmQ3T1rrvLbXchiWt5tea7ye1Z+5e+CqvLLK6jluXxmgQy44EAGXACJqhUJxEaI7hVHF6XNqpEdXJ4amckuS6tFdWHyHDgrr3dpuoiX88NqgSDLvOgyZdKigwqLuuqUSSNqskuVk0bE1H3SpM0/q5ArrBbNKlQGO+8kv87FqcocJJenJl73hSrrJ8XLxpMqM8UAqJxes4pS62aTy2fyFyx0xq1SnvRtrsy50uQH9AaSeEFvFKt/c0p8Vel1BlwV8brJzRq9K+WXrRwvypfvT5GltlCOrpKvadyxlVyOnGafMPm+mdqkleI1m9+6L4+T0qtT493W70X5AielF1glfb3Tz316zpV+Lv7XfKqVPueq8rnK77I8jYFZVXrn+dW+CE06RwPJk7J1aV30LU91c1W+4z27a0O3//vYV7SyAECAuTby5QUfFzHQPnBeQQZcALloF2CvFQWLwMAirOA0LlRmE3fPl1eRMpvkInLm0rTwEKxiPBPE9HartCqRMdgtHASbBbwAcIJoENmtHKzSNh6ChUeFlYdFkOaQSS5MXoCy1UCF1aJxi4i7/1uYVD7HocLKwyqo8VqZSfFy+XZezC+61eR9jGS3FpysCoXqQoX0K9TCS5s6MsWFadW6PJWVitIqTV35YrxFU5+dl12qUn2y2wic6gbSuInsHKd3uaq2TyW3kbhoQd22Q544Lf+YlF2YiosVajyD5GLlVFeOvMpTXsloBwBtek5d9Sin17pc7RoXn7Y8Ga0L0m08p3HBSvWL8bzk6pFdmGr72AFYpHuS78/CqduIyC5XOYMdnOgOl9JXcKKLU2ug8pqXml7mpPQWD9NL7aMxALQuQ2eyHdKcTkg/EKBdRcoggAev3J+jLLnpZGMd8ouZ16TX3C8ntq9jevmzFyTjTHX7iW2gdVmKLkzo9HUmy581gzoAz5j8bFYuD07yO5Yvv3/l8hz1VeJdyPI7n3OMlz4veXRKG6+VHeMrpLIdZbmWSvnFXykuy/NJ1o6eAzpviPhsqD/qKsvS/ybbRsRSBp9G4Cy0iMEryIALIBUch5KYSMQwBq64XJxXBqkT2yy6X2rMKj65iizvHQbJZWi1KF8M4t5fvC6/3WZRvjzkvcHsDvkrHOIdy+OqyF9h0eeXXZTKS1KaMwRNfl4n83qZc3iJ8Hq3gtgG2nhet9Re64ZwdLkyQJkbJcfL17X16V2kvNP0SnB0kXKcTh+lXZzoo31JaPM7k12ld9w93lOXp/a+Pa1PHilwlV8+u9RZvCzrng2O0+mrrVOWdc8Wx6GCqzq9vs3VeXPu0sv3Lzi0vzv95L4m1weHeLsbWffscZWfdXgoqy5XTleus3o8kT114XpSnrZtPXHJVvW/q77m7FlzJ1ft0nS+zYjj5+MPWfksnf1g0tRd6VmVnm9mokUMvJ2jbUSCABlwAcQaG4WimEjwAkOktFJOdOmJ+5QxQJEhbziqcVnKsnJUkyaeuYyHss8XkyZy26WNeJWVe7w+Xi87iecc41FFeo3bSetidHALuXIriekd8oNzKM91fuVlp0nvuE2EjO6l4fgSc5Gek+9Hk97xy9+xPKcv62rFSy9vB9etTnf5c4O+bR1lBunzc+LWcZUe0ipUT8pX7kXzVnOVnjmmd1Ge0/RwnV7r7q6cX362VJPX3f1U9ax5m59VI7/f9AH07aeRnT97rp/96sqSgn4t39e+4W9ZV78Xz5oAwA5e2UDcDFh9HIGz0gicV5ABF0CK7AIKY6JgsQsoi7AiorxCcXGW2aySy1F0EZZbLarMcyizWmBl6kq0cmkVpxxfIbsoZVlyEXJMnHNWYeE15fEot2jiOTG9VZ6bwXEoV2TJpcrxsEIyyHgOFbzkkpXS2zX1CZryIOvjsArUrqwa1bo0xVeBHeJZnzbZJSrFK+VJ+a0QtyFRXKSAEi+7WGWXr8BVjnd0G1k0cqV43QiV1mWqHuCunJwgJeS16Tmoq1qhxiurSBlz6RaS3Sby93UFRN1kt1YFOF16ZQTNSXlMjufUifV2Dsrh8rIMTpueA8cxxY0nu3VUly/Aa0YDBAC86PdR8vO8Wp5dlmWXrUbWxUNzv5xqJtirkAVFllcOyi5bQFkVC1QpVwCwSPcjb5DMaxahiOm5KmX5sxTzQ+MS5WBnUF3IzmRtfkknZzJTruj3iRPj1R83ArQuYiZ9ns5l+dnUG2p6F6pe1syHVOK9GYHipH/1I4hKek4v++rClEtx5iKV3ddKeo4LuCwjjm6r9VdAfVacy+KPxQpw0K53DXWs5T4uYiCLxCuouQJImcChOCoCPAMiS8sUN5wAoMLBpWnneVQwaOJ5nRtKO6dMUGSmk+3a/BbewWXK61yids7BxaqJZ07jHWSOd3CTAQLTpxd06VXZDoA56CNo6pO/9B3za+MFB5cqoL4MtPX5Fi/OY9O7fCvXp84rqmwAyvHO0guAsspXjtcaXAwA45y7TJ2n5xQDzFm8vImqY7zW7cXpromF6VzMqCxzjjKn5nd0UcrxrtM7Kc8DWdB8XnI8oHfhelKe9lmU3fW+6qPd+oNJDa/Vp5Ksqd8T2dnIq6u+I8v6OXMOMlfZhejOZQoXsvY5dZTVtuIr1VeV7I3B6KwvCZzz6QzuZMe+4YkMzTVHWVCueefulzfydWzrUIZOYggOZMAFEFutKBRFRioLB4qjIpSOXMllp0ySll4AsotUidfPedPl5xzL4xRZfmHoZOhlrUvQMR4aWV7FWSme4xS3jXLNhRvHMd5Zek4uv5Kby1V81fkdXbLelA9n5cujH3J+TvwKdxbvMj3nkF5zL1pZTK/u0uZZes6r9MyD9O7cQp64SDUXAF1+uW25SvGeys6eVW9ld8++r3Jll6/vLlPHZ9PbZzmQsrd9wWPZxbPrKHv77PtL9saFypT8nNP0rp5tAZwyMm8GfHahkkXiFaZprkmTJuHmm29G586dUVZWhrp163qUb8aMGXj00UdRp04dbN68GSNHjsShQ4cCrK1IcQXDxagoWAQBZVYLIirs4CUXX5nVAqvAlDMNyyWXJ8/EjWjLJJepEs/zsDKoLlcLD6vkImW86GK1CoLqIlVkcXSowsLDKghQXJLyqkxHFyigulAdXKA2QVBkbbzskrXp8ssuUSbtIs7pyqvgeNiYAEj62TlxJSKnyJBcopp4BnBSfQycfqNeSCsZAWXzS3nVqvwLVloXohjQyipYAIzjFTeU6sKU48XhHV6bH/JqMTE9g0M85+BClWQm6QfH9LwmvXRdTS8acLoRPU6/co9zkOX7k116HK91gXKSS1RtH46DulGulJ5zyM8p5Vd2acrpwYkuQt6FzHSyeB92JrpQociARW5cN7LWBakt3+JQn1cy1JWLTGpv1aUpy+JGxo4uWQHiyK47WXaTyaMyzmS5PgYoGwkLkrEst6czWaufXdJSKwN69z009Wnrlw0HOb9WH0f9KunrzJDyVea0K6ClZxWqvlqXpXruLZR4cPrRcY7jlWdXL3MQwKol2zVt7SgrGwNzsnZifNXli/rbwUMwkQuV83EEjqMROK8wjQEXERGBzz//HOnp6Xj44Yc9yvP888/jqaeewogRI3DkyBHMmjUL69atQ/v27VFaWhpgjYEyO0ORLQJ8NENkeTkYXyEaaFBXdfJQXZqcJNshuVS18TyPCsZcygLPw26xKC8BO8fDblFdrPJpBLp4MJ0sVJKhvlQ4TllZ6ZjejsouU3VXc9nFpXfBAkAZeL1+uvyq68Eul+EQ77iSznEVqfo/V+VKtsouT063bYiz9JxOVl14ztJrZSa3jZfpAfX+qkqvleWXmXgYfNUuUUA1SOV5SDyntq1kw+rycw5/c5r8gkZWXqqc+lkzh/SOst1DWXSh8mJ7+pDfqYzKbizHZ9vRZemtrC0PbmR1wr3r9pJlfX75mVf/Z7r/4fZ/8X7V6QPQXK9K9hX5WXImq8+194aM1i6Q28CZLM/Ok/cU9EUWqpTVPGrfFut3Jdul7y8T7SLi+xw4m/91CWdMY8BNnz4dADBixAiP84wZMwazZ8/GmjVrAAD3338/srOzcdttt+HTTz8NhJo6+JgoFNoixc7KcSiNEDf1VVxW8nC6U5mrMl4541Ia5ZBhisxViq86vWRYOEmvnCGppOfdxLvOr5Nl14eTX9/aeKduEbkuB1lML46feOqmcerSrLJ8z9O7zO+Ffk7vz8f6PdFHGfHwRJaNCxeycs4rx3mUXvtsOj6rzmR5CwyGys92oGWvnnVvZc1n5Y0cEBdmkGTdsy1NqDVCH6aRveoLjrKrvgDv+oIyz9NEFpzPLlQy4LzCNAact6SkpCApKQnr169XruXn5+PPP/9E9+7dg2LAldk5XLRGwsIElPEW2AQ7LExcOVfGW2BlgjSCxmlkcdxKkSW3SDmnrhK1y7I0ziVAlG1SfgEcyjgeNs0IWDnHIQIMosuURwU4WMEUl24FeNigujTleA6SCxMcrEzQy9KrR4C8Gav4u7FyvPgrVJbtigxA0lfezFUunzGNC5MTv7zkzVHFVZwceE5wIfOAlJ9pypNdqGJ6cSWgVuZ5VV+tbOfEnfgt0g9/1W3lPL24WJfTyxyn6GOXhosUl600HGfxVJZ+86suXrE+ThPPQXSrMaV+8f5dy1p9xBeZLFcw0UWm6i+5/DTpRRma9NpVtJJLUkpgD4DMQTKqAXVEUJo3Kh8nzGnut7qyRfwIlNE0HmIbKi5IJ7K8fxuDNI2fU0dBLeJHqMpS2zmTAefufK2suiA58d8gyco3muJyleMhybJ+Wll9lmRjnOPl8pkUH5qyII2neSLLzwoHQP4R7D6/2D4VEKeJmAVaxBAcwtaAa9SoEQAgOztbdz07O1uJc0ZERAQiIyMVOS4uzmcdivKLUWiJBA+GSHsFBKFC2Y2/Qlp1KhtsFZzsMpVekhwPO2NqPC/KssFWwXGKC1Q0UuTjhMQvQDvHKS5O8YuDQ6n6dSpu3QHo4gXwSrzAVXYbCRqXpyg7ukiZi3gn6SUZUL+kmFbm1K0LBHCVNgYGB8hbA7uWoeSX3XraeL2sra9y/czi4J7iqpA5td1kGdBu2yHPcHGdvkpZ+Vw4nax124BT3UbyD3fBrSy9pDjxKdDKdo0sukDVrSC07m+5PLu2fLjeTNVXWeuyczw8XX5O5Qxy+yvp3cjaZ0WyxSvJju5sR/d8VTIDX8ml563M3MjatoLySQVeFvu6xU16R/3UFJXjuZCXmYcyU4L6wDGH+3aU5dE3xnG4eOYCzIK1DLD6MEuJRuC8w1ADbu7cuZgwYUKVadq1a4f9+/cHSSNg4sSJiru2uuQdyUYhLxqDjCtFGWyajgrAoXNzcOjIXFXxrvO7TO+ivKr+17+I3OfXzYXxob6q9Oc8vF9tPriRtfeldWFAk8afsqoH5zK9O529kT1+Nrxs21D9P9zupzr/y6N3YnPo20O57AcZmmvBlv11D6H8rIpTW4CTfx6AWaCTGIKDoQZcWloaFi9eXGWaw4cP+1T26dOnAQANGzZU/pblXbt2ucw3d+5czJ8/X5Hj4uJw6tQpn3Q4dzATR3YcQ+suTVFuscDG7LBAcnFKLkvZ5VnuRLZyTDlfsxycIgsch3ImrqqU5Qqmj3cpQ/xi18p2iG46ZzKnSS+upJN+FTL1fEtxfgb0MqCsClU3wq2uDDDIK+s0LlFwAHNwMbqTwcEimZuKSxJqPAdUS4YH96OmF5dg6kYMHdJDk14esfRUll2MVcmO+cVtf/0viy+kqmXRJemrLI/0yhPFRVneCUxNr74gqyvLL9uq5Cr3YauGLI+5u5NVw8cXWTYxxPK4asqA+izLI1T+lLX6ygZSKMvaRQ0AU9qMadKXlVXgn1WbYRZ8PgvVhzw1GUMNuJycHOTk5ASk7CNHjiArKwt9+vTB7t27AYjG2FVXXYWFCxe6zFdWVoayMv89RT+M/RAj1s9GJC+ekCC7SAWIq0C1sgB5how6T4zjnMmyC1WNF2SXKYeqZcgyD0H5encuM8kUcHTJyivjqpThHxlQv+RUWeOC5VSXp84l606GOqfEM4MIihHgqcwcymcO5asyB3m1mny/jvllwziQsmN9nAtZ1s9zWS7dc9lehSwwSKt4XcnyVhPSs8x4zQRygDG929StDP3IsjOZcyMz6HEcaKhKdsxfWebcyly1ZOiuCNB/1sxLWSzDfzLnRGamkyHJXCWZAdgwdTlKLhTCLFjLALsvixgCbMCZcTuyqjDNHLhmzZohISEBzZs3h8ViQWpqKgDg0KFDKCwUH+y9e/di4sSJWL16NQBgwYIFmDx5Mg4ePKhsI5KZmanEB4Njv+3BxwOn49Z3n0RCqyTlumAXwMuz4g2TbV7KfqxfEMDzqswEAZxfZaZMhPZJZurEbEfZ7yvgvNbVv23l+FlUkv3y2Vv8JwtOnqVAykHum/7vCybuG46r3CVdHGXf7z0U+oZruTjvIn6dvgJb3lgDM8ELPi5i8Nd+NC4w43ZkVWEaA27mzJl44IEHFFl2g95www3YuHEjAHG+XO3atZU0L7/8MmJjY/H++++jTp062LRpEwYMGBD0Rj+8fhfeuOQxNL+uPeq0aIiic/k4/PNuNL2qLeokN0BRjig3694OtZvXR+GZ8ziyIQPNr70U8U0TcTH7PI7+moHm17VHfJN6uHg6D0c3ZiC5RwfENa6HgqxcHPttD1r0vAy1GtVFQeY5HPv9H7S44TLUalgH+SdzcHzzXqT0ugyxDergwomzOPnHPrTo3Qmx9WvjwvGzOLllH1J6pyImMR7nj2bj1NYDSOmTiph68cg7ko3M/x1Ay76dEVW3FvIOn0bWjn9FuU4s8v7NwuldR9Cybyoia8ci92AmsjOOomXfzoiMj8G5A6dw9u/jaNm3MyLiopGz7yRy9p0U5VpRyNl7AucOnELLvp1hi43C2b+PI/ffLLTskwpbTCTO7DmG80fPIKVPKmzREcjOOIYLx8+gZZ/OsEbZcHr3ERScOoeUPqmwRtqQtfMwLp7OQ0rvTrBG2pC5/RCKcvKR0qsTLBFWZG47hOLcArS44TLwNisy/3cApflFSO55GXirBae2HkDZxWK06HkZOAuPk1v2oaK4DMnXdwTHczi5ZR/sZRVo3qMDOI7DiT/2QrALaH5de3Ach+Ob/wEANL+2PRhjOL7pH/AWHs2uuVSUf/8blggrml7dDkxgOPbbHthiItHkqrYQKuw49tseRNSKRpMr20CosOPorxmIqhOLxldcAqG8Akd/zUB0QhwaX9Ea9rIKHPnlL8Q2qI2krq1QUVqOI7/8hbikBDTqnIKKknIc+WU34prUQ6NUUT788y7Ubt4ADS9LRnlxGY78vBt1UhqiQYfmKC8qxeGfdyOhVRLqd2iO8sIS/PvTLiS2bYLES5uh7GIJDv+0E/XbN0e9tk1QVlCMf3/aiQYdk1GvTROU5hfh8E+70DA1BQmtk1B6oRCH1+9Go84pqNsqCSXnC3F4/S40vrw16rZshOLcAlHu1gZ1UzzoG2cv4Mgvf6HZNe1Qu5mmr8h9Q+oryT3a6/pG8vUdEZeUoPaNnh1Rq1Fd5J86h+Ob/qm6b6TvQ0qfVETXi8OF42dx6s/9TvtGdEIc8g6fRub2Q677xqEsZO8+gpb91L5xZs8xtOrXBRFx0Ti3/xTO/nMcLft1UfpGzv5TaNVP0zcOZYp9JSYSZ/4+jrzDp0W5qr7RO1WUdx1BQVau0jeydvyLwjMXkNJb6hvbD6H4nKZvbDuIkvOFoqzpG8nXdxTlP/ejvKjUdd9I3wehwq7vGwxodu2lAOC0b/A2K5p1l/rG73/DGmUT+4pdwNGNGbq+cWxjBiLjY9C4m9RXNvyl7xsb/kJMYjwaX67pKw3rIKlLS7WvNE6oum+0aIAGHZP1faN9M1FevwsJlzRG/fbNxb6xfhcS2zVFYrumKCsoxuH1u1C/Q3O1b6zfhYaXtUDCJY2VvuLYN5K6tkLdlo1QkncRh9fvQkVpeVDfV/7AWgrYfVnEEOF/XbSYcTuyqtCO1hJOiIuLQ35+PuLj41FQUGC0OgRBEAThMcF8h8l1zU4ESn2oKjIOmJyDgOs6YsQILFiwwK0LNSUlBYcPH0bnzp2VqVgA8Ouvv2LXrl0YM2ZMwHT0BNOMwBlNdbYTIQiCIAgjMOLdFRPl24KEyCjxf0edS0tL/To33VN83Y4sWJAB5wb5QfJ1JSpBEARBGE1cXFzAR+DKysqQlZWFsSeT3Cd2QUFBQaX37fTp0zFjxgyn6UNxO7JgQQacGzIzM9GkSRO/PfjytiT+LLMmQO3mO9R2vkNt5zvUdr7j77aLi4tDZmamHzSrmtLSUqSkpCAiwr+T2aqatx6K25EFCzLgPCAQD35BQQF9qfkAtZvvUNv5DrWd71Db+Y6/2i6Y7V9aWhrUhYKhuB1ZsODdJyEIgiAIgjA3zZo1Q2pqqm47stTUVMTGxipp9u7di9tuu02R5e3Ibr31VnTs2BFLly4N+nZkrqAROIIgCIIgwh4zb0fmCkYheCEiIoJNmzaNRUREGK6LmQK1G7UdtZ25ArUdtR2FwAbaB44gCIIgCMJk0Bw4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJkkAFHEARBEARhMsiACwCjRo3CkSNHUFxcjC1btqBbt25Vpr/rrruwd+9eFBcX46+//sJNN90UJE1DC2/a7ZFHHsFvv/2G3Nxc5Obm4qeffnLbzuGMt8+czJAhQ8AYw1dffRVgDUMXb9uudu3aeOutt5CZmYmSkhLs37+f+qyHbff0009j3759KCoqwvHjxzF//nxERkYGSdvQoEePHlizZg1OnToFxhgGDRrkNk/Pnj2xfft2lJSU4ODBgxgxYkQQNCXMgOFLYcMpDB48mJWUlLAHHniAXXrppey9995jubm5rH79+k7Td+/enZWXl7Nnn32WtWvXjs2cOZOVlpayDh06GH4vodxuH3/8MRs5ciRLTU1lbdu2ZR999BHLy8tjjRs3NvxeQr3t5JCcnMxOnDjBNm7cyL766ivD78MMbWez2djWrVvZ2rVr2TXXXMOSk5PZ9ddfzzp16mT4vYR6291zzz2suLiY3XPPPSw5OZn169ePnTp1iqWlpRl+L8EMAwYMYLNmzWK33XYbY4yxQYMGVZm+RYsW7OLFi+zVV19l7dq1Y08++SQrLy9n/fv3N/xeKBgeDFcgrMKWLVvYm2++qcgcx7GTJ0+y8ePHO02/cuVK9s033+iupaens4ULFxp+L6Hcbo6B53l24cIFNnz4cMPvxQxtx/M827RpE3vooYfYokWLaqwB523bPf744+zQoUPMarUarrvRwdu2e/PNN9n69et111599VX2+++/G34vRgVPDLiXXnqJZWRk6K598skn7PvvvzdcfwrGBnKh+hGbzYbLL78c69evV64xxrB+/Xp0797daZ7u3bvr0gPAunXrXKYPR3xpN0diYmJgs9mQm5sbKDVDEl/bburUqThz5gw++uijYKgZkvjSdv/5z3+Qnp6Ot99+G6dPn0ZGRgYmTpwInq9ZX6W+tN0ff/yByy+/XHGzpqSkYODAgfjuu++CorNZoXcE4Qo6SsuPJCYmwmq1Ijs7W3c9Ozsb7dq1c5qnUaNGTtM3atQoYHqGGr60myPz5s1DZmZmpS+6cMeXtrv22mvx8MMPo3PnzkHQMHTxpe1atmyJ3r17Y/ny5Rg4cCBat26Nd955BzabDTNnzgyG2iGBL233ySefIDExEZs2bQLHcbDZbFi4cCHmzp0bDJVNi6t3RO3atREVFYWSkhKDNCOMpmb9bCTCkvHjx2Po0KG4/fbbQ+Z8ulClVq1aWLZsGR599FGcO3fOaHVMB8/zOHPmDB577DHs2LEDn332GV588UU88cQTRqsW8vTs2ROTJk3CqFGj0LVrV9x+++24+eabMXnyZKNVIwhTQiNwfiQnJwcVFRVo2LCh7nrDhg1x+vRpp3lOnz7tVfpwxJd2kxk3bhwmTJiAvn37IiMjI5BqhiTetl2rVq2QkpKCb775Rrkmu//Ky8vRtm1bHD58OLBKhwi+PHdZWVkoLy+HIAjKtb179yIpKQk2mw3l5eUB1TlU8KXtZs2ahWXLluG///0vAGDPnj3KIeEvvvgiGGMB19uMuHpHXLhwgUbfajg0AudHysvLsX37dvTp00e5xnEc+vTpg/T0dKd50tPTdekBoF+/fi7ThyO+tBsAPPfcc5gyZQoGDBiA7du3B0PVkMPbttu3bx86duyIzp07K2HNmjXYsGEDOnfujBMnTgRTfUPx5bnbvHkzWrduDY7jlGtt2rRBZmZmjTHeAN/aLiYmRmf4AoDdblfyEs6hdwRRFYavpAinMHjwYFZcXMzuv/9+1q5dO/buu++y3Nxc1qBBAwaALVmyhM2ZM0dJ3717d1ZWVsbGjh3L2rZty6ZNm1ZjtxHxpt2ef/55VlJSwu644w7WsGFDJcTGxhp+L6Hedo6hJq9C9bbtmjZtyi5cuMDeeOMNdskll7CBAwey06dPs0mTJhl+L6HedtOmTWMXLlxgQ4YMYS1atGB9+/ZlBw8eZCtXrjT8XoIZYmNjWWpqKktNTWWMMTZmzBiWmprKmjVrxgCwOXPmsCVLlijp5W1E5s2bx9q2bctGjhxJ24hQkIPhCoRdePLJJ9nRo0dZSUkJ27JlC7vyyiuVuA0bNrBFixbp0t91111s3759rKSkhGVkZLCbbrrJ8HsI9XY7cuQIc8a0adMMv49QbzvHUJMNOF/a7uqrr2bp6emsuLiYHTp0iE2cOJHxPG/4fYR621ksFjZ16lR28OBBVlRUxI4dO8beeustVrt2bcPvI5ihZ8+eTr+75LZatGgR27BhQ6U8O3bsYCUlJezQoUNsxIgRht8HBeMDJ/1BEARBEARBmASaA0cQBEEQBGEyyIAjCIIgCIIwGWTAEQRBEARBmAwy4AiCIAiCIEwGGXAEQRAEQRAmgww4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJkkAFHEIRhbNiwAa+99prRahAEQZgOMuAIgiAIgiBMBh2lRRCEISxatAgPPPCA7lqLFi1w7NgxYxQiCIIwEWTAEQRhCPHx8fj++++xZ88eTJ06FQBw9uxZCIJgsGYEQRChj9VoBQiCqJnk5+ejrKwMRUVFyM7ONlodgiAIU0Fz4AiCIAiCIEwGGXAEQRAEQRAmgww4giAMo6ysDBaLxWg1CIIgTAcZcARBGMbRo0dx1VVXITk5GfXq1QPHcUarRBAEYQrIgCMIwjBeffVV2O12/PPPP8jJyUHz5s2NVokgCMIU0DYiBEEQBEEQJoNG4AiCIAiCIEwGGXAEQRAEQRAmgww4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJkkAFHEARBEARhMsiAIwiCIAiCMBlkwBEEQRAEQZgMMuAIgiAIgiBMBhlwBEEQBEEQJoMMOIIgCIIgCJNBBhxBEARBEITJIAOOIAiCIAjCZJABRxAEQRAEYTLIgCMIgiAIgjAZZMARBEEQBEGYDDLgCIIgCIIgTAYZcARBEARBECaDDDiT0r17d0ybNg21a9f2W5m33nortm/fjuLiYhw7dgzTp0+HxWJxm69t27aYN28edu7cifz8fGRmZmLt2rW4/PLLK6WdNm0aGGOVQnFxsd/ugyC8JZT6U3JystM+whjDkCFD/KYfQXhDKPURV+8ROVxzzTVK2kWLFjlNs3fvXr/dh1FYjVaA8I1rrrkG06dPx+LFi3HhwoVqlzdgwACsXr0av/76K0aPHo3LLrsMkydPRoMGDTBq1Kgq8z7yyCN4+OGH8cUXX+Cdd95B7dq18fjjj2PLli0YMGAAfv7550p5nnjiCVy8eFGR7XZ7te+BIHwllPqTzIoVK/Ddd9/prqWnp1dbN4LwhVDqI19++SUOHTpU6fqcOXNQq1Yt/O9//9NdLykpwSOPPKK75o97CAUYBfOFcePGMcYYS05O9kt5e/bsYTt37mQWi0W5NmvWLGa321nbtm2rzNu1a1cWGxuru5aQkMCys7PZ77//rrs+bdo0xhhj9erVM7wNKVCQQyj1p+TkZMYYY+PGjTO8XShQkEMo9RFnoWnTpsxut7P33ntPd33RokWsoKDA8PYLUDBcAQpeBtkIcsTXjnXppZcyxhgbOXKk7npSUhJjjLEXXnjBp3JXrVrFcnJynOqemJjI4uLiDG9LChRCrT9pDbiYmBhms9kMbyMKNTuEWh9xFp577jnGGGPXX3+97rpswPE8H3bvHHKhmpAvv/wSbdq0wb333osxY8YgJycHAHD27FnEx8fDZrO5LaOkpASFhYUAgC5dugAAtm3bpkuTlZWFEydOKPHe0qhRI0U3Rw4fPoy4uDhcvHgRq1evxrhx43DmzBmf6iGI6hCq/WnatGl49dVXIQgCtm/fjhdeeAE//fSTN7dGEH4hVPuIlmHDhuH48eP47bffKsXFxMQgPz8fsbGxyM3NxSeffILx48cr+pgZw61ICt4HV8PZGzZscPpLyZFFixZVKqtp06aV6vnzzz/ZH3/84bV+1113HbPb7WzGjBm660899RR744032D333MPuuOMO9tprr7GysjK2f//+sPt1RME8IZT6U7NmzdgPP/zAHn/8cXbLLbewp556ih09epRVVFSwgQMHGt5WFGpmCKU+4hjat2/PGGPspZdeqhQ3Z84cNnfuXHb33XezIUOGsEWLFjHGGPv999917lszBhqBCzPGjRuHunXruk2XmZmp/B0dHQ0AKC0trZSupKQE8fHxXulQv359rFixAkeOHMHLL7+si3vjjTd08pdffomtW7dixYoVGDVqFObNm+dVXQQRSIzoTydOnMCAAQN015YtW4Z//vkHaWlplRY2EISRhMI7Z9iwYQCA5cuXV4qbNGmSTv70009x4MABzJkzB3fddRc+/fRTr+oKJciACzN27NjhdR55C4/IyMhKcVFRUV5t8RETE4O1a9ciLi4O1113nUdD1J988gnS0tLQt29fMuCIkMLo/iSTl5eHRYsWYeLEiWjSpAlOnTrldRkEEQhCoY/ce++9yMjIQEZGhkfpX3vtNcyaNQt9+/YlA44IHerWrYuIiAi36YqLi5Gfnw9AnHcAAElJSTh58qQuXVJSErZu3epR3TabDV9++SU6deqEG2+8EX///bfHep84cQIJCQkepyeIYGBkf3LkxIkTAICEhAQy4IiQweg+cu2116JFixaYMGGCx3lKSkpw7tw5079zaCNfk8IYc3r9yy+/xOnTp92G119/Xcmza9cuAMAVV1yhKyspKQnNmjVT4quC4zgsXboUffr0wb333ut0ImlVtGjRAmfPnvUqD0H4i1DrT85o2bIlAFA/IQwhVPvIsGHDIAgCVqxY4XGeWrVqITEx0fR9iUbgTIrsmqxTpw6OHTumXPdlPsI///yDvXv34rHHHsN7770HQRAAACNHjoQgCFi1apWSNj4+HklJScjKylJ+TQHAm2++iaFDh+Kxxx7DV1995bLexMTESitTR44ciQYNGuCHH35wqzdBBIJQ6k/O+kjjxo3x0EMPYffu3Th9+rTvN0oQPhJKfUTGarXi7rvvxqZNm5QRai2RkZGw2Wy6TeMBYMqUKeB5PizeOYavpKDgfbjiiisYY4ytXbuW3XfffWzIkCEsJibG5/JuvvlmZrfb2fr169kjjzzCFixYwCoqKiptijhixAjGGGMjRoxQrj399NOMMcY2b97Mhg0bVilo9SosLGQfffQRe+aZZ9jIkSPZ8uXLmd1uZzt27GDR0dGGtyuFmhlCqT999NFHbOPGjWzq1KnskUceYbNnz2Znz55lJSUlrGfPnoa3FYWaGUKpj2jLYIyxxx57zGkdycnJLDc3l7399tts9OjRbPTo0Wzt2rWMMca+++47xnGc4e1azWC4AhR8DC+88AI7ceIEq6iocLq829swaNAgtmPHDlZcXMyOHz/OZs6cyaxWqy6Ns84kL8t2hVav999/n+3Zs4dduHCBlZaWsgMHDrC5c+eyWrVqGd6eFGp2CJX+NHToUPbrr7+y7OxsVlZWxs6cOcO++OIL1qVLF8PbiELNDqHSR+SwYsUKVlpayurWreu0/Nq1a7OlS5eyAwcOsIsXL7Li4mKWkZHBJkyYUKkeMwZO+oMgCIIgCIIwCbSIgSAIgiAIwmSQAUcQBEEQBGEyyIAjCIIgCIIwGWTAEQRBEARBmAwy4AiCIAiCIEwGGXAEQRAEQRAmg05i8IDGjRujoKDAaDUIA4mLi9PtJE64h/oNQf3GN6jvEJ70HTLg3NC4cWM6OJoAADRp0oReRh5C/YaQoX7jHdR3CBl3fYcMODfIv4KaNGlCv4hqKHFxcTh16hR9/l5A/YagfuMb1HcIb/qO4cdBhHKIi4tjjDEWFxdnuC4U6BnwJfTo0YOtWbOGnTp1ijHG2KBBg9zm6dmzJ9u+fTsrKSlhBw8edHqMTTi3GYXqB3oGqN0oBPYZMNUihh49emDNmjU4deoUGGMYNGiQ2zw9e/bE9u3bUVJSgoMHD2LEiBFB0JQgQofY2Fjs3r0bTz75pEfpW7RogW+//RYbNmxA586dsWDBAnz44Yfo379/gDUlCIIgPMVULlT5RfTRRx/hq6++cptefhG9++67GDZsGPr06YMPP/wQWVlZ+PHHH4OgMUEYzw8//IAffvjB4/RPPPEEjhw5gmeffRYAsG/fPlx33XV45plnqN8QBEGECKYy4OhFRBCBp3v37li/fr3u2rp167BgwQJjFCIIgiAqYSoXqre4ehF1797dZZ6IiAjExcXpgpmJjo/DJVddgY69e6LRJa3AcZzRKhEhTqNGjZCdna27lp2djdq1ayMqKsppnnDrN77CWyxofll71GvW1GhVCMJUcDyPlK6piIh2/h1DVMZUI3De4u5FVFJSUinPxIkTMX369CBpGDiatGuD/qMexqU9roHFqn7MZ44cw7cL3sGeX34zUDsi3AiXfuMrEdFR6DFsCHrcNxhx9RJQnF+AWf1uQ2lRkdGqEUTIw/E87n91Njr164WNSz/BmlfeMFolUxDWI3C+MHfuXMTHxyuhSZMmRqvkFbzFggGjH8OYlR+hY6/rYbFacfbYCRzP+AelRUVokJKMB1+fh76PPWC0qkSIcvr0aTRs2FB3rWHDhrhw4YLTHz2A+ftNdWjXozue//oTDHz6CcTVSwAgjnw3btvaYM0IwhzcMWkcOvXrBQBo3/M6g7UxD2E9AufLi6isrAxlZWXBUM/vRERH4/602bi0xzUAgF0/rMe6dz7EmSPHAACRsTG48clH0XP4UNw0+nGcO5mJnd/RXEBCT3p6OgYOHKi71q9fP6Snp7vMY+Z+4yvWiAgMGj8G1wy+HQCQeyoL37/1HrrefCMuva47mlzaBkd2/mWwlgQR2vQf+TCuGXKHIsfWqW2gNuYirEfg0tPT0adPH901dy8isxIZE4NHF87HpT2uQVlxCZY9OxnLnpuiGG8AUFpYhDUvv46f3l8EALh72njUTWpklMpEkIiNjUVqaipSU1MBACkpKUhNTUWzZs0AAHPmzMGSJUuU9O+++y5atmyJefPmoW3bthg5ciQGDx6M1157zRD9Q5H4+on4v6Xv4prBt0MQBPy6ZAVevu0e7Fi7Dif27AUANG7bxmAtCSK06T74dtw46hEAwJpX3oAgCIipHY/YunWMVcwkmMqAoxeRcyw2Gx58fR5aXt4ZxfkFWPjI/2HXup9dpl/39oc4smM3ImNi0H/kw0HUlDCCK664Art27cKuXbsAAK+99hp27dqFmTNnAgCSkpLQvHlzJf3Ro0dx8803o1+/fti9ezfGjRuHRx55hFZuSzRIScbTKz5Esw6X4mJuHj54Ygy+efVNlJeUAgAy9x0AADRud4mRahJESNOpXy/c8YK4Q8SPC/+LjUs/QV7maQBAw5YtDNTMXBi+67CnoWfPnswZixYtYgDYokWL2IYNGyrl2bFjByspKWGHDh0Kux3lOY5j982bwdIy0tmLW9azZh0u9Shf88vas7SMdPbKrk2sQUqy4fcRyiHUn4FQDOHaZk3atWEzf/uepWWks/FrVrKEpo0rpUlo2pilZaSzeds3Mt5qMVxnegbMFWpCu7Xq1pXN276RpWWkszunPK9cf+SdNJaWkc6uvsv9aTHhHDx9Bkw1B27jxo1VboPx4IMPOs3TtWvXQKplKP2eeAhdBvZHRXk5Fo+ZiBN/7/Uo3/GMf/D3ht/RoVcPXHvPXfhqTlqANSUIc9O0fVs8/sEbiImPx/GMf/DhqLEoPH+hUrq8U1koLriI6LhaaNiyBbIO/GuAtgQRmjRp1wYPvfEyrBER2P3jL/jyxVeVuDNHjuHSHtegQUqygRqaB1O5UAk9HXv3VOYPrJo5Dwe3/M+r/Js++RwAcPnNN8IaGel3/QgiXEhq0xqPvy8ab0d2/oV3Hx3t1HgDAMYYLmSfAQDE1K4dTDUJIqRJaJKERxbOR1StWBzauh0rJs4AEwQlXp6zTQacZ5ABZ1ISmzfFPS9OAQBsXLYS/1v9rddlHNyyDbmnshAdH4dO/W7ws4YEER7Ub9Ecj7//OmJqx+Po7gx88MQzKC2sen83QXop8Tx9xRIEAETHx+PRha8hPrEeMvcfxKKnx6PCYeV67qksAEDtBvWNUNF00LeLCbHYbBj+ymxE1YrFv9t2Yu38t3wqhzGGravXAgA639jXnyoSRFgQ36A+HntvAeLqJeDkP/vxwcixHm3OK48qcDydfEIQFqsVDyyYiwYpyTh/OhsfjByLkouFldIJdjsAcWNfwj3USibkptGPo2n7triYm4ePx0+DUGH3uayMnzcCANpc3Q22KHKjEoRMVFwtPPbua0honIQzR47h/SfGoKTgokd5mcAAABxvCaSKBGEK7pzyPFp364qSi4X4YNQ45J/NcZpO/eFDpoknUCuZjJaXd0bPEfcAAD6bNgf5Z85Wq7zTB/9FbmYWbFGRaH3lFf5QkSBMj8VqxYj5c5B0SStcOHMW7z8+BoV55z3OzxiNwBEEAFw/fCiuuuNWCHY7lj03GacPul7UQ1MPvINayUTYoiIxZOYL4Hkef36xBn//uskv5e797Q8AQIcb6AgTggCAOyc/hzZXd0NJYSH+++SzyMs67VV+wS4ZcBx9xRI1l7bXXIVbx/0fAGDNq29i36YtVaZXR66p33gCtZKJuHHUo0hs3hTnT2fj61de91u5//y2GQBwyVU0AkcQ198/FFfd+R8Idjs+fm4qTkkb83qDPALH0wgcUUNJbN4U970yE7zFgq1frcXvH3/qNg+NXHsHGXAmoXHbS3D98CEAgFWzXnG7Cs4bju7KgCAISGzeFLXq1fVbuQRhNtpddzVuHauOGOz9/Q+fyqE5cERNJjI2Bg++8TJi4uNxdFcGVs162aN8NHLtHdRKJoDjONw15XlYrFbsWvcz9kojZv6ipOAisv89AgBokdrJr2UThFmo36I57psnjhj8+cUaj0YMXEGrUImaCsdxuHfuNDRqlYIL2Wex+JmJsJeXe5SX+o13kAFnAq68/RYkp3ZEycVCfD1vQUDqOLLzLwBAi86XBaR8gghlImNj8ODr8xAdH4cjO3bji9mvVKs8gVbTETWU/qMeQcde16O8tBSLxkxAQc45j/MqUw8sNHLtCfTtEuJEx8fj5jGjAAA/vP2By+XX1eWoZMCldKEROKJmwXEc7nlxKhq2bIHz2WeweOxE2CsqqlWmPJLAV3H0H0GEG5f16Yn+TzwEAFg182Wc2POPV/lVFyr1G08gAy7EGfB/jyK2bh1kHfwXmz9ZFbB6ju7KACCe98hb6dcPUXPo9dBwXNanJyrKyrB4zERcPJdX7TIZk+bA0UgCUUNo1Lol7pkzFYB4OtC2Nd95XYbSb2jk2iOolUKYRpe0wjWDbwcAfDV3vrJLdSA4d/IUSi4WwhoRgfrJzQNWD0GEEpdcdQVuGv0YAODLOWlejxi4gubyEDWJ6Ph4PPj6PETGxODAlv9hbZqPpwPRPnBeQa0Uwgx6/mnwFgt2//gL/v3fjoDXl3XgEACgcZvWAa+LIIwmvkF9DJs3Q1y08OU3+POLNX4rW5kDR6vpiDCH43ncN28GEps3xbmTmVj27GSfBxvoJAbvoFYKUTr06oE2V3dDeWkpvkl7Myh1ZkoGXBIZcESYw1ssGP7yTMTVS8CpfQfw5Zw0v5avjiTQCBwR3tw0+nG0u+5qlBWXYNHT41F0Id/nsgQaufYKMuBCEIvVquxFtXHpSuRlercLvK9kHRCPOGnclgw4IrwZ8H+PoeXlnVFysRBLxr6AitJSv5ZP+8ARNYHL+t6APo/cDwD4dOqLihfHV+R+w1O/8Qgy4EKQ7oNvQ/0WzVFwLhe/fLg0aPVm0QgcUQNoe81V6ktn2hycO3HS73UwQXQh0UgCEa40bNkCQ2dPBgD8umQFdv2wvtpl0kkM3kEGXIgRVSsW/R4Xl2Gve/tDlBb578QFd2QdEkfg6jRsgJja8UGrlyCCRVxiPWWl3B+ffom/fvwlIPUIdKYjEcZExsbggQUvISo2Fgf/3IZvX3vHL+UyOonBK6iVQoxeD96HWgl1cebIMfz5pf8mVXtCaWGRcmh3/Ra0EpUILziOw71zpiKuXgIy9x/E1y/77zxhR2g1HRHODJ01GQ1SknH+dDY+fn6q33ZIUPqNhfqNJ1ArhRBxifXQ4z7xvNNvFywM6LYhrjh34hQAoF6zJkGvmyACyQ0P3Is23a9EaVExlj03BRVlZQGri/azCh9GjRqFI0eOoLi4GFu2bEG3bt1cph0xYgQYY7pQXFwcRG0Dzw0j7kWnfr1QUVaGJWMn4WJu9fdNlBHkfkMjcB5BrRRC9Hv8QUTGROPo7gzs+WWjITrIBlxis6aG1E8QgaBp+3a4afQTAICv572GM0eOBbQ+Jv34oh3lzc3gwYMxf/58zJgxA127dsXu3buxbt061K9f32WeCxcuoFGjRkpITk4OosaBpeUVXTBwzEgAwOqXFuB4hn/2TZRR+g3NgfMIMuBChIQmSbj6zkEAgO8WLDRMjxxpQjeNwBHhQkR0NO6bNwMWmxW7f/wFf375TcDrpBG48GDs2LH44IMPsHjxYuzduxdPPPEEioqK8NBDD7nMwxhDdna2Es6cORNEjQNHXGI9DH9lFixWK7Z98z3SP//K73XI/YbOQvUM+nYJEfqPfBgWmxX7//gT/27baZgeOTQCR4QZg55/GvVbNMf509n4fMa8oNQp0Bw402Oz2XD55Zdj/Xp1dSVjDOvXr0f37t1d5qtVqxaOHj2K48ePY/Xq1Wjfvn0w1A0ovMWC4a/MQnxiPWQd/BerZgamH8lz4AAavfYE+nYJAeq3aI7LbxkAAPj+zfcN1eUcjcARYUTH3j1x9V2DIAgCVkyaieJ83zcZ9QZGq1BNT2JiIqxWK7Kzs3XXs7Oz0ahRI6d59u/fj4ceegiDBg3CfffdB57n8ccff6BJE9ffpxEREYiLi9OFUOOm0Y+h1RVdUHKxEIufmYjyEv/umygjaA046jtuoRYKAfqPfBi8xYI9G37z21mMviLPgYurl4DImBhDdSGI6hCXWA+Dp08AAPy6eHlQjqOTobNQayZbtmzBsmXLsHv3bvz222+44447cPbsWTz++OMu80ycOBH5+flKOHXqVBA1dk+HG65D74fVzXpzjp0IWF00AucdpjPgwm1FUMOWLdB5QF8A4r5vRlNysVBZVUSjcOFFuPUddwyZ9QJi69bBqb0H8EOQR7YZnYVqenJyclBRUYGGDRvqrjds2BCnT3t2Ok5FRQV27tyJ1q1db44+d+5cxMfHK6Gq0bpgk9C0MYa+OAUA8NuyT/HXTxsCWp88cg0AHM2Dc4upvl3CcUVQ/5EPg+d5/PXTBmTuP2i0OgA0W4k0bWywJoS/CMe+UxXXDLkDl17XHeUlpVg+YRrsFRVBrV9gtJ+V2SkvL8f27dvRp08f5RrHcejTpw/S09M9KoPneVx22WXIyspymaasrAwFBQW6EApYIyJwf9qLiImPx9FdGVg7/62A1ykI6tZZdI6we0z17RJuK4IatW6JTv17AwB+fPe/BmujcuHMWQBAfP1EgzUh/EW49Z2qqN+iOW4dNxoA8O2Cd5B9+GjQdaA5cOHB/Pnz8eijj+L+++9Hu3btsHDhQsTGxmLRokUAgCVLlmDOnDlK+ilTpqBfv35ISUlBly5d8PHHHyM5ORkffmi8d8Vb/vPcU2jWvh0K885j2bOTg/IjSDcCR6PXbjFNC4XjiqB+jz8Inuex+8dflIPkQ4GCc7kAgLj69QzWhPAH4dh3XMFbLbh3zjREREfhQPpWbFrxuSF6qC5UGkUwM5999hmeffZZzJw5E7t27ULnzp0xYMAA5cdM8+bNkZSUpKSvW7cuPvjgA+zduxffffcd4uPjcc0112Dv3r1G3YJPdBnYH9cOvROCIGD5xBk4nx2cH2+6OXA0eu0Wq9EKeEpVK4LatWvnNI+8Iuivv/5C7dq18eyzz+KPP/5Ahw4dXE4UjYiIQGRkpCIHakVQw5YtlNG3n977KCB1+Er+2RwAQHw9MuDCgWD0nWD1G3f0eWQEml/WHkX5+Vg5Zbayr1SwURcx0EvI7Lz99tt4++23ncb16tVLJ48dOxZjx44NhloBo0FKMu6eNh4A8PMHS7B/85ag1a1bhUojcG4J6xYK5RVBfaXRt7/W/xpSo28AUJBzDgCNwNVkvO07obCSrmn7tuj32IMAgC9fTMOF7LNB10GG9oEjzIgtKhL3p72IyJgYHNq6HeveCa7rVzsCR3Pg3GOab5dwWhFUv0VzZeXp+vcW+b386pJ/VjLgEsmACweC0XeMXklnjYjAPS9OVU5b2Pndj0Gt3xE6iYEwI3dMehZJl7RCfs45fPz8VJ1BFWzIheoe07RQOK0I6vPICPA8j783/I5T+w74vfzqUnBONODiyYALC4LRd4xeSTfg/x5Do9YtkZ9zDl/MejmodTuD2WkfOMJcXH7rTbjy9lsg2O1YPn6aMhc62AjKOcKmMU8MwzRz4ABxRdCSJUuwbds2bN26IDQS5wAANXZJREFUFWPGjKm0IujUqVOYNGkSAHFF0JYtW3Do0CHUqVMHzz33nOErghKaNkbXm/sDAH4KwdE3QDMCVy8BHM8b+iuM8A/h0HdckdKlE3qOuAcA8Pn0l1B4/oLBGtE+cIS5aJCSjDsnPwcA+PHdj3Bo63bDdBEEAbzFQqPXHmAqA+6zzz5D/fr1MXPmTDRq1Ai7du2qtCJIOwlSXhHUqFEj5OXlYfv27YavCOr90HBYrFbs27QFJ/4OzZVJF3PzlE4UW7c2Lp7LM1olopqEQ99xRkR0FIbOngKe57F19Vr8s3GT0SoBABjtA0eYBHXeWzQOpG/F+vcXG6oPo/mjHmMqAw4w94qg2g3ro9ttNwMA1r8fmqNvgDiEXZh3HnH1EhCfmEgGXJhg5r7jipvHjEJi86bIyzqNr+ctMFodBUHeB45G4IgQ5/aJ48R5b2dzsHzidMM9LuoeijT9wB307RJEeo64F1abDf9u24kjO/8yWp0qkbcSoYUMRKjSqltXXHfv3QCAz6bNQcnFQoM1UqGzUAkz0PWWG3HVHbdCsNvx8fhpIfFjXT6NgVyo7qEWChKxdevg6jsHAYDhQ9SeUJAjTmCNp61EiBAkIjoaQ2a+AAD447OvcCD9fwZrpEdxA9F5jkSIUr9Fc9w15XkAwE/vfoR//7fDYI1E5BE4cqG6h1ooSPQYNhiRMdE48fdeHEjfarQ6bsnPkTbzTaTjtIjQ45axT6Je08bIPZWFtWmBP6PRW+gkBiKUsUZEYPgrsxAZE4ODf27DTyE0qCDPH6UROPdQCwWByNgYXHvPnQCAnz9carA2nlGYJ67ki6kTb7AmBKGnVbeuuHao2J8+mzYHpUVFBmtUGYFOYiBCmP889xSatGuDgnO5WD7B+HlvWpQteOjHj1vo2yUIdL/rNsTEx+PMkWPY8/NGo9XxiOJ8cR+vmHgy4IjQISI6CoNnTAQguk4P/rnNYI2co0zEppcQEWJ06t9b+QG0YuIM5eSdUIF+/HgOtVCAsdhsuP7+oQCADR99bNjZjN5SlJ8PAIiON+ZMS4Jwxk1PPYHEZuKq07XzQ891KqNuI0Jz4IjQIaFpYwyeLv4A+vnDpSE5nUd+R9IWPO6hFgowl98yALUb1Mf57DPY/u06o9XxGHkEjgw4IlRI6dJJWXX6+fSXUFoYeq5TGVqFSoQaFqsVw1+Zhei4Wjiy8y/88Nb7RqvkFNWFSuaJO6iFAgjHcej14DAAwG9LV8JeXm6wRp6julDJgCOMxxoZicEzJokb9n61Fvv/+NNolapEoJcQEWIMHDMSzTu2R9GFfHz8/FTlyKpQQ13EQD9+3EHfLgGkQ68eaJCSjKL8fGxZ9bXR6nhF0QVyoRKhw42jHkaDlGRcOHMWX7/yutHquEU9zJ5eQoTxXNrjGtww4l4AwKdTX8T509kGa+QaQTmJgaYfuIMMuADS68H7AAB/rPwyJFfKVUURuVCJEKFZh0uVl88Xs15GScFFgzVyDx0HRIQKtRvWxz0vTgEA/Pbxp9jzy28Ga1Q1NP3Ac+jbJUCkdOmEFp0vQ3lpKTat+NxodbymWFrEEBUbC95Kv4QIY7BYrRgy6wXwFgt2fLsOf/8aGmeduoP2siJCAY7nce/c6YitWwcn/tmHtfOdH6UXSqhHaVHfcQe1UIC4QZr7tu2b71FwLtdgbbynWDPKQVuJEEbR59ERSLqkFQrO5WL1S68ZrY7HKHPg6CVEGEi/xx9E625dUVJYiI+fm2KKedg0eu051EIBoEFKMjr2uh6CIGDjkk+MVscnmCAoRhy5UQkjaHRJK/R99AEAwOq581F4/oKxCnkB7QNHGE2rK7qg3+MPAhCnHuQcP2mwRp6hzh8l88Qd1EIBQJ6v8/eG33H26HGDtfEd2kqEMAreYsGQGZNgsVmx55eN2LXuZ6NV8gp1Hzj6iiWCT2yd2hj20gzwFgu2rl6LHd/+aLRKHiOvjqUfP+6hbxc/E5dYD5ffOgAA8Oui5QZrUz3klai0lQgRbK4fPhTNL2uP4vwCfDH7VaPV8Rr1LFT6iiWCz5BZk1G7YX2cOXIMX81JM1odr1A38qW51+6w+pKpRYsW6NGjB5KTkxETE4OzZ89i586dSE9PR2lpqb91NBXX3Xs3rBEROLLzLxzdnWG0OtVCHYGjOXD+gvqOexKbN8WAJx8FAKx55Q3kn80xWCPvoeOA/Av1G8/pMWwwOtxwHcpLS7H02RdQVlxitEpeQatQPccrA+7ee+/F008/jSuuuALZ2dnIzMxEcXExEhIS0KpVK5SUlGD58uWYN28ejh83r+vQVyJjYnDNkNsBAL8uNvfoG6Aep0UjcNWH+o5ncByHwTMmwRYVif1//Imtq9carZJPqCvp6CVUHajfeEeTS9vglnH/BwD45tU3kXXgX4M18h7aBNtzPDbgduzYgbKyMixevBh33nknTp7UT4iMiIhA9+7dMXToUGzbtg2jRo3CqlWr/K5wKHPlHbcqh9b/veF3o9WpNjQHzj9Q3/Gcq++6Da2u6ILSoiJ8PuMlo9XxGVpJV32o33hHZEwMhr8yG1abDX+t/xWbV35htEo+oWzBQ/NH3eKxATdhwgT8+KPriZBlZWXYuHEjNm7ciBdeeAEtWrTwh36mgbdYcP3wIQCAjctWmubQ+qogA84/UN/xjDoNG+CWsU8CAL5/4z3kZZ42WCPfoX3gqg/1G++444VnUT+5GfKyTuOzaXONVsdn1BXc1Hfc4bEBV1VHciQ3Nxe5uebb+6w6pPbvjYTGSSg4l4tta743Wh2/IJ/GEFOb5sBVB+o7nnHn1OcRVSsWR3dlYNMn5h5JITdQ9aF+4zmX3zIAV/znJgh2O5ZPmK5sxG5GBEFchcrT9AO3+PTtMmLECKfXLRYL5syZUy2FzErPB8StQzav/AIVYTKplg609z/Ud5zT9eb+aH/9tagoK8Nn0+YoLkizouxlRW4gv0D9xjWJzZvijsnPAgDWLfwvjuzYbbBG1UOdP0qrUN3h07fLG2+8gc8++wx16tRRrrVp0wZ//vkn7rnnHn/pZhpadeuKZu3boay4BH+YdN6BM4oLRAMuMjbWYE3CB+o7lamVUBe3jX8GAPDTe4uQffiosQr5AVpJ51+o3zjHYrXivpdnIio2Fof+twM/f7DEaJWqDfUdz/HJgOvSpQuaNm2KjIwM9O3bF6NGjcKOHTuwb98+pKam+lvHkKeXdGzW1tVrTbVbvDtKCgsBAFFxtQzWJHygvlOZ28aPQWzdOsjcfxC/fLTMaHX8guxC5cmF6heo3zhn4JiRaNbhUhSev4AVE6ebfuQaoC14vMGnfeAOHz6Ma6+9FgsWLMAPP/wAu92OESNGYOXKlf7WL+Rp1LolLu1xDQS7Hb8tDa/7LykQDbjoWmTA+QvqO3ra97wOXQb2h2C349OpcyBU2I1WyS/QIgb/Qv2mMu16dFdO/fl0ymxcyD5rsEb+QVnBTScxuMXnb5ebb74ZQ4cORXp6Os6fP4+HH34YSUlJ/tTNFPQcIQ7fZ/y8EedOnjJYG/9SclE8CzWqFrlQ/Qn1HZGoWrG4c8pzAIBfl6zAyX/2GayR/1Dn8ZAB5y+o36jEJdbDPbOnAAB+X/4Z/v51k8Ea+Q91/ijNgXOHT98u7777Lj7//HPMmzcPPXr0QKdOnVBWVoaMjAzcfffd/tYxZImvn4iuN98IQHwBhRsl0mH25EL1H9R3VG4Z+3+o07ABzh47gXXv/NdodfwKzePxL9RvVDiOw71zp6FWQl2c2ncAa+e/bbRKfoXJZ6FS33GLTwbctddei6uuugrz588HAGRnZ+Pmm2/G1KlT8dFHH/lVQUdGjRqFI0eOoLi4GFu2bEG3bt2qTH/XXXdh7969KC4uxl9//YWbbrrJb7pcd+/dsNpsOLx9F47/9bffyg0ViqUROKvNBmtEhMHahAfUd0RaXdEF3e++DQDw2fS5YbNyW4bm8fgX6jcqvR4ajjZXd0NpUTE+fn4qKsrK/Fq+0QiM9oHzBuZtiIiIcBnXpk0br8vzNAwePJiVlJSwBx54gF166aXsvffeY7m5uax+/fpO03fv3p2Vl5ezZ599lrVr147NnDmTlZaWsg4dOnhcZ1xcHGOMsbi4OH0bREezWZvXsbSMdNahV4+A3bORgeM49sruzSwtI53VqlfXcH2MCq6eAV9CTek7VbWZLSqSTfz2c5aWkc7unPK84Z9vIEKb7leytIx0NvazJYbrYlSgfuPfdw4A1iL1Mvbyzt9ZWkY6u/K2Wwz/jAMRHn77VZaWkc663Xaz4boYFbzoO8Yr62nYsmULe/PNNxWZ4zh28uRJNn78eKfpV65cyb755hvdtfT0dLZw4cJqN2SPYYNZWkY6m/DNp4zjOMPbJlBh9h8/sbSMdJaY3MxwXYwK/nwRGRWC3XeqarNbnnmSpWWksyk/rWaRsTGGt00gwiVXd2NpGels3BfLDNfFqED9Rgz+eudEx8exF9Z9ydIy0tmwl6Yb3jaBCg+9+YpooN5+q+G6GBU87Tt+H6P8+eefMXnyZERHR/u1XJvNhssvvxzr169XrjHGsH79enTv3t1pnu7du+vSA8C6detcpvcU8disoQCAX5d+EhbHZrlCXsgQ7itROZ7HDQ8MQ62EuobpUBP6TtP27ZSFP6tmvYLSwqJqlReqKHPgasBKukaXtELXW240rP6a0G8A4O5pE5DQOAk5J05i1ayXq11eqMKEmjMH7uZnRqFF6mU+5/e7AXf8+HH06dMH+/b5d0VZYmIirFYrsrOzddezs7PRqFEjp3kaNWrkVXpAPCA5Li5OFxzp1PcGJDRJwsXcvLA5NssVJRdrxl5wHXtfj1vH/R/GfrYEvEGrn8zcdzzpN7zVgiGzXgBvsWDHt+uw97fNPt5R6FNT5sDxFguGzJyEYXOno88jIwzRwcz9BvDwndO/N1L790ZFeTmWPTslbH/4AIAgreDmw/wkhiv+MxC9HxqOJ/77JuIS6/lUhk/7wFXFgw8+CABOH0IzMHHiREyfPr3KNKcPH8WO737E6UOHw27ytSPKStTYGIM1CSy9HpA2Y/56LQS7MXuRmbnveNJvhAo7fvnvMvR97AGsnrcgKHoZhbKXVZgbcNcPH4rmHdujOL8A//v6W0N0MHO/ATzrO3t+2Yj1HyxBYd75sNpuxxk1YQV3g5Rk3PGCePzZT+8tQkHOOZ/K8enbZfjw4YhwsirRZrNh+PDhAIAC6Rgmf5GTk4OKigo0bNhQd71hw4Y4ffq00zynT5/2Kj0AzJ07F/Hx8Upo0qRJ5XIP/ovl46eFxbEl7qgJpzGkdOmE5NSOKC8txaYVnwe0rnDtO570GwDY+d2PePX2YSjMO+/9jZiImrAPXGJyMwx48lEAwNevvI78szkBqytc+w3gWd8RKuz4/o138duy8N+4mIX56LU1MhL3p72IyJhoHEjfil/+6/vpMz610KJFi1C7du1K1+Pi4rBo0SKflamK8vJybN++HX369FGucRyHPn36ID093Wme9PR0XXoA6Nevn8v0AFBWVoaCggJdqMkoI3BhPAfuBukotG3ffI+L5/ICWle49h1v+k04zxmVUU9iCM9RBI7jMHj6RNiiIrH/jz/xv9WBHX0L134D0DvHkXAfvR70/NNIuqQV8nPOYcXEGdU6/swnFyrHcU6/hJs2bYoLFwJ3Fuj8+fOxZMkSbNu2DVu3bsWYMWMQGxurdOAlS5bg1KlTmDRpEgDg9ddfx8aNGzF27Fh8++23GDp0KK644go89thjAdMx3Ci+KB+nFZ6nMTRISUbHXtdDEARsXPJJwOujvlMzkM9CDde9rK6++za0uqILSouK8PmMlwJeH/WbmoNyEkMYGnCd+vfGNYNvhyAIWDFxBgrO5VarPK8MuB07doAxBsYYfv75Z1RUVChxFosFKSkp+OGHH6qlUFV89tlnqF+/PmbOnIlGjRph165dGDBgAM6cOQMAaN68uTJ5GBB/Dd17772YPXs25syZg4MHD+K2227D33+H36a7gUI5TitMXajyWYL//Po7zh49HrB6qO/ULMJ5Hk+dhg1wy9gnAQDfvb4QeZmu3YPVhfpNzUP98RNefSehSRIGT58IAPjlv8twcMv/ql2mVwbc6tWrAQCdO3fGunXrcFF6uQPiMPDRo0fxxRdfVFupqnj77bfx9tvOjw7p1atXpWurVq3CqlWrAqpTOCMfaB8VG34jcHH1EnD5rQMAABsWBfYoNOo7NQvZhWrUiuZAcufU5xEVG4ujuzKweeWXAa2L+k3NQ+074TMCx1stuG/eTETH1cLRXRlY984HfinXKwNu5syZAICjR4/i008/RWmYr8AkwnsRw3X33g1rRASO7srA0V1/BbQu6js1C2URQ5iNInQZ2B/tr78WFWVl+HTqi9Wav+MJ1G9qHuG4AOim/3sMyakdUZSfj4+fnwqhwj87Hfg0B27p0qV+qZwIfdRFDOE1AhcRHY1rhtwBANiwaHnQ6qW+UzMIx33gYuvWwe0TngEgbn1w5sixoNVN/abmIG/jFC7zR9t0vxK9H74fAPDZ1DnIy/LflAOPW+jvv//GkCFDYLPZqkzXunVrvPPOOxg/fny1lSOMR5kDF2arUK+641bE1I7H2aPH8fevvwe0Luo7NY9wXEl324RnEFu3DjL3H8QvH/m+9YGnUL+pmaiLGMw/eh1XLwH3zp0GANi88gtk/LzRr+V7PAI3evRozJs3D++88w5++uknbNu2DZmZmSgpKUHdunXRvn17XHfddejQoQPeeustLFy40K+KEsagrEINIxcqb7Xg+vs1R6EF2A1EfafmEW57WXW44Tp0Hdgfgt2OT6fO8ZsLqCqo39RMwuXHD8dxuHfuNMTVS0DmgUNY8+qbfq/DYwPul19+Qbdu3XDttddiyJAhGDZsGJKTkxEdHY2cnBzs3LkTS5cuxfLly3H+/Hm/K0oYQ3G+uCdROM2BS+3fBwmNk1BwLjcoR6FR36l5CGG0CjUqrhbunPw8AODXJSuCdhIA9ZuaSbhMP+j10HC06X4lSouKsezZyQE5tcnrOXCbN2/G5s3he4YhoUc24GLizXlMjTPkY7M2rfg8qEehUd+pOaiLGMz9EgKA/4wbjdoN6+Ps0eNY985/g14/9ZuaRTiMXrdIvQwD/k88pWT13PkBmy/q0yKGKVOmVBk/a9Ysn5QhQo+iC/kAAGtEBGxRkSgvMfcqsDbdu6HJpW1QWlSMPz4N7BYIzqC+UzMIl60Q2nTvhqvu/A8A4NNpcww7+5n6Tc3B7KtQo+PjMezlGbBYrdjx7TpsXb02YHX5ZMDdfvvtOtlmsyElJQUVFRX4999/qTOFEWXFxbCXV8BisyKmdjwulJw1WqVq0evB+wAAW7/6RjFOgwn1nZqBMopg4hG4iOho3DV1AgBg0yercGTHbsN0oX5Tc1B+/Jh0+sHgGROR0DgJOcdPYtWslwNal08GXNeuXStdi4uLw+LFi/HVV19VWykitCjKz0dcvQREx8fjQrZ5Dbgm7dqgTfcrYa+owMalgT82yxnUd2oGzG7+OXADn34C9Zo2Ru6pLHz72juG6kL9puZg5mPorr3nLnTqewMqysux7LnJKC0sCmh9fmuhgoICTJs2jX4JhSHhMg+ul3Ro/e4ffwno8T/eQn0n/BBMfp5jStdU9Bg2GADw+Yy5KCsuNlijylC/CU/kETjOZNMPmrRrg/88OxoA8M2rb+LkP/sDXqdfW6h27dqoXbu2P4skQoCifNHVGG1iAy6hSRJSb+wDANjw0ccGa1MZ6jvhhZm3QrBFRWLIzBcAAH9+sQYH0qt/ZmOgoH4TfphxDlxkTAyGvzIL1ogI7NnwGzat+Dwo9frkQh09erRO5jgOSUlJGD58OL7/PvDbMhDBRRmBqx1vsCa+03PEveAtFuzbtAWZ+w8apgf1nZqBmc9CHfDkY6if3Azns89gzatvGK0OAOo3NQlBkE9iMM/0g7umPo/6LZojL+s0Vk5+MWj1+mTAPfPMMzpZEAScPXsWS5Yswdy5c/2iGBE6yAacWUfgYuvWwZW33QIA2LDI2NE36js1A3kOnNlo3qkDrh8+BACwasY8lEgbeRsN9ZuagzwCZ5YfP1fefiu63nwj7BUV+Pi5qSjOD97iOJ8MuJYtW/pbDyKEKVLmwJlzBO66e+9GRHQUju/5B4e2bjdUF+o7NQNBegkBoiso0Kd9+ANrRASGzHwBvMWCbWu+x97f/zBaJQXqNzUHdQV36I/ANWrdErdPHAsA+OGt93F0d0ZQ6zePk5kwDHm7DTOOwEVER+O6e+4CEJpz34jwRHahAuaZB9d/5MNo1CoF+TnnsHreAqPVIWooZjmJISI6CsNfmYWI6Cjs27TFkPdLaLcQERKYeQ7c1XcNUg6t9/dBwgThCu2IW6i/iACgWYdLlVXaq2bOC6obiCC0mGUB0G0TxqJR65a4cOYsPnlhJhhj7jP5mdBuISIkKDbpKlSL1YqeI+4BIM59M4MbiwgP9AZcaLuCLDYbhswSXac7vvsRf2/43WiViBqMGVahdr3lRlx1x60Q7HYsnzAdF3PzDNEjdFuICBmUOXBx5jLgut5yI+o0bIALZ85i2zc/GK0OUYPQzYEL8Q1J+z3xIJIuaYWCc7lYPXe+0eoQNRwmr0IN0R8+9Vs0x11TngcA/PTuR/j3fzsM0yW0v1mIkMCMc+A4jkPvh4YDAH5buhL28nKDNSJqEtoRuFA+D7Vp+7ZKP/li1ssoPH/BYI2Imo4yAheCP3yskZG4/9XZiIyJwcE/t+Gn9xcbqk/otRARcphxDlzHPj3RICUZRfn5SP98tdHqEDUM7SKGUHUFWWw2DJ09BRarFbt+WE9zRImQQFD2UAy9fjPouafQuO0lKDiXi+UTphs+LSf0WogIOYpMuA9cn0fuBwBsWrEKpUWBPY+OIBzR7gMXqtshaF2nX85JM1odggCgPUc4tMyTzjf2wTVD7oAgCFgxcToKcs4ZrRIZcIR7ZBeqxWpFVK1Yg7VxT5vuV6JZh0tRWlSMTcs/M1odogaiXZEWai8iwMF1OvsVFOadN1YhgpBQzkINoR8+9Zo1xd3TJwIAfvlwacgcLxd63yxEyFFRWorigosAgLjEegZr454+j44AIJ7jSHN6CKMQQnQ7BK3rdOf3PyFj/a9Gq0QQCqF2EoM1IgL3vzobUbVi8e/2nVj3zodGq6QQWt8sRMgiDxfHh7gB16JzJ7Tu1hUV5eX4dclyo9UhajAsRDckvXHUI4rr9CtynRIhhmAPrRG4W58djabt2+Jibh6Wj58GwW43WiWF0PpmIUKWfMmAC/URuL6PiaNv277+DheyzxqsDVGTUQ240HgRAeJZp+qGvbTqlAg9FBdqCPzw6dSvl3KSzycvzAy5d4rxLUSYgoKzOQCA+PqJBmvimqbt2+LSHtdAsNvxy3+XGa0OUcNRXEF8iLiCIiNxz+wp4C0WbF/7A/b8QqtOidAjVE5iqNe0CQbPmAQA+PnDpdi3aYuh+jjDNAZc3bp18fHHH+PChQvIy8vDhx9+iNjYqifUb9iwAYwxXVi4cGGQNA4v8k3gQu3z6AMAgJ3f/4RzJ08Zq0wIQX3HGIQQG4Eb+PQTaJCSjAtnzuKrua8ZrQ5BOCUUTmKwRkRgeNpsRMfVwpEdu/HDW+8bpktVWI1WwFOWL1+OpKQk9OvXDzabDYsWLcL777+PYcOGVZnv/fffx9SpUxW5iLaU8ImCEHehNrqkFTr1vQGCIODnD5YYrU5IQX3HGBQXaghsSNrqii7oOXwoAOCzaXPorFMiZAmFHz7/ee4pNGvfDoV557Hs+SkhNe9NiykMuHbt2uGmm27CFVdcge3btwMARo8eje+++w7PPvsssrKyXOYtKipCdnZ2sFQNW/LPSiNw9UPTgOsrrTzNWP8rsg8fNVaZEIL6jnGEyhy4yNgYDJ09BQCwZdXXIekKIggZo12onW/sg2uH3gkAWDFpRsjNe9Ni/E9DD+jevTvy8vKUFxAArF+/HoIg4Kqrrqoy77Bhw3D27FlkZGRgzpw5iI6OrjJ9REQE4uLidIEACs6F7ghcg5RkpN7YBwDw03uLDNYmtAhm3yH0yHvBGb0dwqDnnkZCkyScO5mJNa+8YaguBOEOIxcxJCY3w90zxP3e1n+wJOR/7JhiBK5Ro0Y4c+aM7prdbkdubi4aNWrkMt+KFStw7NgxZGZmolOnTpg3bx7atm2LO++802WeiRMnYvr06f5SPWxQR+BCbxFD38ceAM/z2PPLRmQdOGS0OiFFsPpOREQEIiMjFZl++GhdqMaNwLXveR2uuvM/EAQBKyfPolNJiJBH3UYkuAacNTISI+bPQVRsLA79bwfWvf1BUOv3BUMNuLlz52LChAlVpmnXrp3P5X/wgfoB7NmzB1lZWfjll1/QsmVLHD582KVO8+fPV+S4uDicOkUT4vOlVaixdWrDYrOFzOHw9Vs0R5eb+gEAfnz3I4O1CR6h1nfoh09lBIP3gYutWweDpdGE35auxOHtuwzRgyC8QR655oJ8Fuodk8ahcZvWKDiXi4+fnxqy8960GOpCTUtLQ7t27aoMhw8fxunTp9GgQQNdXovFgoSEBJw+fdrj+v78808AQOvWrV2mKSsrQ0FBgS4Q4nFaFZLRFlcvwWBtVPo+9gB4iwV/b/gdp/YeMFqdoBFqfWfu3LmIj49XQpMmTXy/uTDB6Dlwd00dj7h6Ccg6+C++f/M9Q3QwM7R62xiM6DfdBg3EVXfcCkEQsHz8tJA459QTDB2By8nJQU5Ojtt06enpqFu3Lrp27YodO3YAAHr37g2e55UXiyd07twZAKqcuE24piDnHOomNUJ8g0ScP2385Pb6LZqj68D+AIB1C0PneJNgEGp9p6ysDGVlZR6XVxMwch+4brfdjE59b0BFeTlWTJyBCvpsvIZWbxuD7ELlg+RCTWrTCne88BwAYN07H+Lgn9uCUq8/MMUihn379uH777/HBx98gG7duuGaa67BW2+9hZUrVyovlMaNG2Pv3r3o1q0bAKBly5aYPHkyunbtiuTkZNx6661YunQpNm7ciIyMDCNvx7TkZoptXa9JY4M1Eek/8mHwFgv2bPitRo2+eQP1HeNQJ2MHdwQuoWlj3DbhGQDAD2+9j8z9B4Nafzggr95+5JFHsHXrVmzevBmjR4/G0KFDkZSUVGVeefW2HMiL4x3BXMQQGRuDEWlzEBEdhX2btuDn9xcHvE5/YgoDDhBXxO3btw8///wzvvvuO2zatAmPPfaYEm+z2dCuXTvExMQAEEcE+vbtix9//BH79u1DWloavvjiC9x6661G3YLpOXdCnAtYr5nx7rGGrVLQeUBfAMC6t2vW6Ju3UN8xBiMmY/MWC+59cSqiYsWDt39dvCJodYcTtPOBcQRzI98hM19A/RbNkZd1GismTlfm35kFU6xCBYC8vLwqh66PHTumW+118uRJ3HDDDUHQrOaQc/wkACCxeVODNQEGPPkoeJ7H7h9/oREGN1DfMQYjRuB6PzwcKV1TUVxwEZ9MmqnMJyK8g3Y+MA5BEBcPBLrfXD98KFL790ZFeTmWjnvBlOcCm8aAI4xHGYFrauwIXNP27dCpXy8IgmCKpd5EzSTYc+CaX9Ye/Uc+DAD4cs6ryMv0fJFKTSHUVm/LOtHOByrBGIFL6dIJt4x9EgCw5pU3cDzjn4DVFUjIgCM8RjbgjB6BG/jU4wCAHWvX0akLRMgSzNV0kTExGDZvBixWK3Z+9yN2rF0X8DrNSFpaGhYvXlxlmkCt3nZlwNECID2BPokhrl4Chr86GxarFTu++xGbP1kVkHqCARlwhMfknBBdqPH1ExERHYWy4pKg69D6ysvR9tqrUVFeXuNWnhLmIpj7wN0+aRwSmzVF7qksrJr9SsDrMyuhtnqbqAwLYL/hLRbc98os1G5QH6cPHcbn01/yex3BxDSLGAjjKc4vQNEF8RDsBIPcqAOfHgkA2PL5auSezDREB4LwhGCdxNBlYH90GzQQgt2OFROno6TgYkDrqwnQ6m3jEALYbwY+PRKtu3VFSWEhloydhLLiYr/XEUzIgCO8Qh6FS2wWfDdqp/69kdypA0qLirDeZMu9iZpHMM5CrdesKe6a8jwA8RzgIzv/ClhdNQ1avW0Mgeo3nfr1Qq8HxcVcn055EWeOHPNr+UZALlTCK3KOn0Tzju3RICU5qPVarFYMfOoJAMCvi1eg4FxuUOsnCG8J9Bw4i82G4a/MRFQtccsQ+lHjX2j1tjEEYuS6QUoyhsx6AQCwYdFy/PXTBr+VbSQ0Akd4hbxlR+O2ro8jCwTdB9+O+snNkJ9zDhuXfBLUugnCFwK9D9zNz4xCsw6XovD8BawYP90UZzcShDuY3b9z4CJjYvDAgpfEQ+q3bsd3r4fP0WZkwBFekbn/EACgcdtLglZndHycsj3Curc/QCkdTUOYAGUfuAAcyt2xd0/0HD4UALBy8myczz7jJgdBmANB6je8n/rN0NmT0bBlC5zPPoNlz08Jqx86ZMARXiGPwNVPbgZbVGRQ6uz3+IOIrVMbpw8dxtav1galToKoLsp+Vn4egUto2hhDJXfQr0tW4J+Nm/xaPkEYiT/7Te+H70enfr1QUVaGJc9MxMVzedUuM5QgA47wioKccyg4lwveYkGj1q0CXl9i86a49p67AABrXn0zrH49EeGNvKM878c5cNaICIxIm4Po+Dgc3ZWBbxe847eyCSIUYH46iaHttVfjJmnP0K/mzjftZr1VQQYc4TXBnAf3n2efgtVmw95N6di/eUvA6yMIfxGIHeVvm/AMmrZvi4u5eVj27GQIFfSDhggv/HGCSb2mTXDfyzPA8zy2rPoaW1Z97S/1Qgoy4AivkefBNWnXJqD1tOl+JTr06gF7eQXWvPx6QOsiCH/j7w1Juw0aiO533wZBELB8wnSa90aEJUI1V29HREfjwTfmISY+Hkd3Z+DLOWn+VC+kIAOO8JrjGX8DAFqkXhawOixWK26fOBYAsGnlqrDYs4eoWcj7WfnDgGtyaRvcKe33tu6dD3EgfWu1yySIUKS6P3yGzp6MpEtaIf9sDpY8Mwn28nJ/qhdSkAFHeM3RXeKu4kltWiFS2sTS3/S4bwgapCSj4FwufnyHjswizIc8X5Ov5n5WsXVq44EFL8EWGYm/f92En2m/NyKMqc5ZqH0fewCp/Xujorwci5+ZiPyz7o9NMzNkwBFek382B+dOZoK3WJCc2sHv5ddp1FDZNuTb195GycVCv9dBEIHGHyNw8tmNCY2TkHP8JD55YaZSLkGEI772mw43XIebRouLFr6c/QqO7d7jd91CDTLgCJ84uks8sqdF505+L/v2SWMRGRONf7fvxLY13/u9fIIIBoorqBr7Wd0y7v/Q5upuKC0qwqKnx6M4v8Bf6hFESCKPXHtzEkPDVim4d+50AMDmlV/gzy+/CYRqIQcZcIRPyG7UlK6pfi039cY+6NjrelSUl+OLWa/QaANhWqq7n9WVt9+qbNb7yaSZOH3osN90I4hQxdvV29Hx8XjojZcRVSsWh/63A6vnvRZI9UIKMuAInzi0dTsAoGXXVERER/mlzFoJdZWFCz9/sATZ/x7xS7kEYQTV2Qeu5RVdcOeU5wCIp49k/LzRr7oRRKiinGDigQHHWy0YkfYiEps3xbmTmVg6dlKN2lqHDDjCJ84cOYZzJ0/BGhGB1lde4Zcy7542HnH1EpB54BB+/mCJX8okCKPwdQSuQUoyHnz9JVhtNuz6YT1+fPejQKhHECGJfIawJ4sYbp84DpdcfQVKCgvx0VPPo/D8hUCrF1KQAUf4zN7f0wEAl/boXu2yrr77NnTs3RMV5eVYMXEG7BUV1S6TIIzEl7NQ4xvUx6PvvibuYbUrA59Mnh0o9QgiJFFH4Koeue5x3xBcM/h2cV/E8dNx+uC/wVAvpCADjvCZvb//AQBo3/NaryacOpLUpjVuGz8GAPD96+8i68Ahf6hHEIbi7Vye2Lp18Pj7ryOhcRLOHDmGj0Y/h4rS0kCqSBAhhyf9pkOvHvjPc08BANamvVVjzwMmA47wmUNbd6C44CLqNGqIlld08amM6Ph4PPi6uMfVP79txsaln/hZS4IwBm9W08XWqY3H338djVql4PzpbLz/+Jga5w4iCEBdvW2xWp3GN+vYHvfNmwme5/HHp1/W6HcGGXCEz1SUlmLXD+sBAFfefovX+XmrBfenzUa9pk2Qc+IkVkykPa6I8EF+lt3N5YlLrIeRH72NJu3aID/nHBY+Mhp5WaeDoSJBhByFFy7AXi5OoYlvUF8Xl9AkCQ+/9QoioqOwd1M6vpo73wgVQwYy4IhqsfUrcb+dTn17ITo+3qu8d0+dgDZXd0NJYSEWj5mA4vz8QKhIEIYgSPM4q1qlndi8Kf5v6btIuqQVLpw5i3ceHIWcYyeCpSJBhBxChR3nTp4CADRMSVauR8fH4+G30xBXLwGn9h3AsnGTlVHumgoZcES1OJ7xD07tPYCI6Cj0fmiYx/luGft/uPL2WyDY7fj4uanIOlDzJqAS4U324aMAxDmezmjRuRNGL3sfic2aIufESbw14gmcPXo8iBoSRGhy5shRAOKKbACwRkTgwTdeUqYYfPjksygtKjJQw9CADDii2nz/1vsAgOvuHYw6DRtUmZbjONz67Gj0elA09j6f/pKyGIIgwomT/+wDADRt365S3NV3DcLIj95CrYS6OPH3Xrw1/HHknswMtooEEZKcOXIMgGjAcRyHe+ZMRavLu6C44CI+GDUO+WfOGqxhaGAaA27SpEnYvHkzCgsLkZeX53G+GTNmIDMzE0VFRfjpp5/QurXzX8OE7+z9bTOO7NiNiOgo3PfKLJeTTyOiozFs3gzcMOJeAMCXc9KwdfXaYKpaI6G+Ywwn/9kPAKjfojkiY2IAANHxcRg2bwbunjYBVpsNu3/8Be88OAoF53KNVJUgQgrFgGvZArc+Oxqdb+wjHlA/ZkKN3C7EFaYx4CIiIvD5559j4cKFHud5/vnn8dRTT+GJJ57AVVddhcLCQqxbtw6RkZEB1LRm8snk2SjOL0BKl0548M2XEVNbPx/u0uuvxbhVS9Hlpn6wl1dg5ZTZ2PzJKoO0rVlQ3zGGi7l5yMs6DZ7nkZzaAVffNQjj16xE14H9IdjtWPva21j27GSUFZcYrSpBhBTZkgHX5upu6Hn/PQCAlZNnKycAESrMTGHEiBEsLy/Po7SZmZls3LhxihwfH8+Ki4vZkCFDPK4vLi6OMcZYXFyc4fce6qHddVezuVs3sLSMdDbnz1/YQ2++woa/MotN+v4LlpaRztIy0tnkH79iLS/vbLiu3oRweQaC2XfCpc2q3eavzVWefTk8//UnrPll7Q3XLdCBngFqN19DdHycrs/0enCY4TqF4jNgmhE4b0lJSUFSUhLWr1+vXMvPz8eff/6J7t1dnxwQERGBuLg4XSA8Y9+mLXhrxOM4te8AImOi0eGG69B5QF/Ua9oYpUVF+OW/S/HqncNxePsuo1UlqsDXvkNU5ujOv5S/z2efwep5C5B253Acz/jHQK0IIrQpzi9A7qksAMDGZSuxYdFygzUKTZxPVgoDGjVqBADIzs7WXc/OzlbinDFx4kRMnz49kKqFNaf2HsD8u0cgObUjmrRrA4vVipwTp3Bo6zaUl9Cu8mbAl74TERGhc6/SDx+RzSu/QHHBReRlZuHw9l10RBxBeMiip8ejXtPGyPh5o9GqhCyGjsDNnTsXjLEqQ9u2bYOuU3x8vBKaNGkS1PrDhWO79+CPT7/E78s/w97fNpPx5mdCre9MnDgR+fn5Sjh16lTQ6g5lKsrKsPWrb3Dwz21kvBGEF2TuP0jGmxsMHYFLS0vD4sWLq0xz+PBhn8o+fVrcybxhw4bK37K8a9cul/nKyspQVlbmU50EESxCre/MnTsX8+eru6LHxcWREUcQBBFADDXgcnJykJOTE5Cyjxw5gqysLPTp0we7d+8GIL5UrrrqKq9W4xFEKBJqfYd++BAEQQQX0yxiaNasGVJTU9G8eXNYLBakpqYiNTUVsbGxSpq9e/fitttuU+QFCxZg8uTJuPXWW9GxY0csXboUmZmZWL16dfBvgCAMgvoOQRBEeGL4kllPwqJFi5gzevbsqaRhjLERI0bo8s2YMYNlZWWx4uJi9tNPP7FLLrkkIMt5KYRvMPszYETfMXubUah+oGeA2o1CYJ8BTvqDcEFcXBzy8/PRpEkTFBQUGK0OYQDyfK74+Hh6BjyE+g1B/cY3qO8QnvadsN1GxF/I2yHQhGwiLi6OvlA9hPoNIUP9xjuo7xAy7voOjcB5QOPGjSs1omwhh/uvpJpyn0DV9xoXF4fMTDps3Btqcr8Bas69Ur/xPzW579SU+wSq33doBM4DqmrEgoKCsH/IgJpzn4Dze60p9+5PqN+I1JR7pX7jP6jv1Jz7BHzvO6ZZhUoQBEEQBEGIkAFHEARBEARhMsiA85HS0lJMnz4dpaXhfURUTblPoGbdq1HUpDauKfdaU+7TaGpKO9eU+wSqf6+0iIEgCIIgCMJk0AgcQRAEQRCEySADjiAIgiAIwmSQAUcQBEEQBGEyyIDzA5MmTcLmzZtRWFiIvLw8o9XxK6NGjcKRI0dQXFyMLVu2oFu3bkar5Hd69OiBNWvW4NSpU2CMYdCgQUarVGMI175D/YYIJOHabwDqO95ABpwfiIiIwOeff46FCxcarYpfGTx4MObPn48ZM2aga9eu2L17N9atW4f69esbrZpfiY2Nxe7du/Hkk08arUqNIxz7DvUbItCEY78BqO/4QpWn3VPwPIwYMYLl5eUZroe/wpYtW9ibb76pyBzHsZMnT7Lx48cbrlugAmOMDRo0yHA9aloIp75D/YZCsEI49RuA+o63gUbgCKfYbDZcfvnlWL9+vXKNMYb169eje/fuBmpGEKEL9RuC8A3qO95DBhzhlMTERFitVmRnZ+uuZ2dno1GjRgZpRRChDfUbgvAN6jveQwacC+bOnQvGWJWhbdu2RqtJECEH9R2C8B7qN4S3WI1WIFRJS0vD4sWLq0xz+PDh4ChjADk5OaioqEDDhg111xs2bIjTp08bpBVhBmpy36F+Q/hKTe43APUdXyADzgU5OTnIyckxWg3DKC8vx/bt29GnTx98/fXXAACO49CnTx+89dZbBmtHhDI1ue9QvyF8pSb3G4D6ji+QAecHmjVrhoSEBDRv3hwWiwWpqakAgEOHDqGwsNBg7Xxn/vz5WLJkCbZt24atW7dizJgxiI2NxaJFi4xWza/ExsaidevWipySkoLU1FTk5ubixIkTBmoW/oRj36F+Q/0m0IRjvwGo7/jSdwxfRmv2sGjRIuaMnj17Gq5bdcOTTz7Jjh49ykpKStiWLVvYlVdeabhO/g49e/Z0+vktWrTIcN3CPYRr36F+Y7x+4RzCtd8A1He8KYeT/iAIgiAIgiBMAq1CJQiCIAiCMBlkwBEEQRAEQZgMMuAIgiAIgiBMBhlwBEEQBEEQJoMMOIIgCIIgCJNBBhxBEARBEITJIAOOIAiCIAjCZJABRxAEQRAEYTLIgCMIgiAIgjAZZMARBEEQBEGYDDLgCIIgCIIgTAYZcIRTEhMTkZWVhYkTJyrXunfvjtLSUvTu3dtAzQgidKF+QxC+QX3HNzw69Z5CzQs33XQTKy0tZZdffjmrVasWO3ToEEtLSzNcLwoUQjlQv6FAwbdAfce7wEl/EIRT3nrrLfTt2xfbtm3DZZddhm7duqGsrMxotQgipKF+QxC+QX3HOwy3IimEboiKimKHDh1ipaWlrGPHjobrQ4GCGQL1GwoUfAvUdzwPNAeOqJJWrVqhcePG4HkeLVq0MFodgjAF1G8Iwjeo73gOuVAJl9hsNmzduhW7du3C/v37MWbMGFx22WU4e/as0aoRRMhC/YYgfIP6jvcYPgxIITTDyy+/zA4fPszi4uIYx3Hst99+Y998843helGgEMqB+g0FCr4F6jteB8MVoBCCoWfPnqysrIxde+21yrXk5GR2/vx59sQTTxiuHwUKoRio31Cg4FugvuN9IBcqQRAEQRCEyaBFDARBEARBECaDDDiCIAiCIAiTQQYcQRAEQRCEySADjiAIgiAIwmSQAUcQBEEQBGEyyIAjCIIgCIIwGWTAEQRBEARBmAwy4AiCIAiCIEwGGXAEQRAEQRAmgww4giAIgiAIk0EGHEEQBEEQhMkgA44gCIIgCMJk/D88vrGnBuu2ygAAAABJRU5ErkJggg==",
+                        "text/plain": [
+                            "<Figure size 640x480 with 5 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "# visualization\n",
+                "epochs = config[\"data\"][\"train\"][\"epochs\"]\n",
+                "visual(model, epochs=epochs, resolution=config[\"summary\"][\"visual_resolution\"])"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3.9.0 ('py39')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.9.0"
+        },
+        "orig_nbformat": 4,
+        "vscode": {
+            "interpreter": {
+                "hash": "57ace93c29d9374277a79956c3f1b916d7d9a05468d906842f9921d0d494a29f"
+            }
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 2
+}
diff --git a/MindFlow/applications/burgers1d/configs/burgers.yaml b/MindFlow/applications/burgers1d/configs/burgers.yaml
new file mode 100644
index 000000000..6360f8a0c
--- /dev/null
+++ b/MindFlow/applications/burgers1d/configs/burgers.yaml
@@ -0,0 +1,55 @@
+data:
+  name: Burgers1D
+  root_dir: "./dataset"
+  train:
+    batch_size: 8192
+    epochs: 15000
+  domain:
+    size: 8192
+    random_sampling: true
+    sampler: "uniform"
+  BC:
+    size: 8192
+    random_sampling: true
+    sampler: "uniform"
+  IC:
+    size: 8192
+    random_sampling: true
+    sampler: "uniform"
+  time:
+    size: 8192
+    random_sampling: true
+    sampler: "uniform"
+geometry:
+  coord_dim: 1
+  time_dim: 1
+  coord_min: -1.0
+  coord_max: 1.0
+  time_min: 0.0
+  time_max: 1.0
+model:
+  name: MLP_with_Residual
+  in_channels: 2
+  out_channels: 1
+  activation: tanh
+  layers: 6
+  neurons: 128
+  residual: true
+  load_ckpt: false
+optimizer:
+  name: Adam
+  learning_rate: 0.0001
+  warmup_epochs: 1
+  weight_decay: 0.0
+  gamma: 0.5
+loss:
+  train:
+    name: MSE
+summary:
+  root_dir: "./summary"
+  ckpt_dir: "./summary/checkpoints"
+  save_ckpt: false
+  eval_interval_epochs: 100
+  save_checkpoint_steps: 50
+  keep_checkpoint_max: 10
+  visual_resolution: 100
\ No newline at end of file
diff --git a/MindFlow/applications/burgers1d/images/result.jpg b/MindFlow/applications/burgers1d/images/result.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8fdfb1b9af70d2cd15ba5161288b6fd554eb8a6e
GIT binary patch
literal 28848
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

literal 0
HcmV?d00001

diff --git a/MindFlow/applications/burgers1d/src/__init__.py b/MindFlow/applications/burgers1d/src/__init__.py
new file mode 100644
index 000000000..00649b536
--- /dev/null
+++ b/MindFlow/applications/burgers1d/src/__init__.py
@@ -0,0 +1,26 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""init"""
+from .dataset import create_training_dataset, create_test_dataset
+from .utils import visual, calculate_l2_error
+from .model import Burgers1D
+
+__all__ = [
+    "create_training_dataset",
+    "visual",
+    "calculate_l2_error",
+    "create_test_dataset",
+    "Burgers1D",
+]
diff --git a/MindFlow/applications/burgers1d/src/dataset.py b/MindFlow/applications/burgers1d/src/dataset.py
new file mode 100644
index 000000000..11e1af9b9
--- /dev/null
+++ b/MindFlow/applications/burgers1d/src/dataset.py
@@ -0,0 +1,48 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""create dataset"""
+import os
+import numpy as np
+
+from mindspore import Tensor
+from mindspore import dtype as mstype
+
+from mindscience.data.flow import Dataset, Interval, TimeDomain, GeometryWithTime, generate_sampling_config
+
+
+def create_training_dataset(config):
+    """create training dataset by online sampling"""
+    geom_config = config["geometry"]
+    data_config = config["data"]
+
+    time_interval = TimeDomain("time", geom_config["time_min"], geom_config["time_max"])
+    spatial_region = Interval("domain", geom_config["coord_min"], geom_config["coord_max"])
+    region = GeometryWithTime(spatial_region, time_interval)
+    region.set_sampling_config(generate_sampling_config(data_config))
+
+    geom_dict = {region: ["domain", "IC", "BC"]}
+    dataset = Dataset(geom_dict)
+
+    return dataset
+
+
+def create_test_dataset(test_dataset_path):
+    test_data = np.load(os.path.join(test_dataset_path, "Burgers.npz"))
+    x, t, u = test_data["x"], test_data["t"], test_data["usol"].T
+    xx, tt = np.meshgrid(x, t)
+
+    test_data = Tensor(np.vstack((np.ravel(xx), np.ravel(tt))).T, mstype.float32)
+    test_label = u.flatten()[:, None]
+    return test_data, test_label
diff --git a/MindFlow/applications/burgers1d/src/model.py b/MindFlow/applications/burgers1d/src/model.py
new file mode 100644
index 000000000..de2b93685
--- /dev/null
+++ b/MindFlow/applications/burgers1d/src/model.py
@@ -0,0 +1,76 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Burgers1D"""
+import numpy as np
+import sympy
+
+from mindspore import Tensor
+from mindspore import dtype as mstype
+
+from mindscience.pde import Burgers, sympy_to_mindspore
+
+
+class Burgers1D(Burgers):
+    r"""
+    Burgers 1-D problem based on PDEWithLoss
+
+    Args:
+        model (Cell): network for training.
+        loss_fn (str): Define the loss function. Default: mse.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    """
+    def __init__(self, model, loss_fn="mse"):
+        super(Burgers1D, self).__init__(model, loss_fn=loss_fn)
+        self.ic_nodes = sympy_to_mindspore(self.ic(), self.in_vars, self.out_vars)
+        self.bc_nodes = sympy_to_mindspore(self.bc(), self.in_vars, self.out_vars)
+
+    def ic(self):
+        """
+        define initial condition equations based on sympy, abstract method.
+        """
+        ic_eq = self.u + sympy.sin(np.pi * self.x)
+        equations = {"ic": ic_eq}
+        return equations
+
+    def bc(self):
+        """
+        define boundary condition equations based on sympy, abstract method.
+        """
+        bc_eq = self.u
+        equations = {"bc": bc_eq}
+        return equations
+
+    def get_loss(self, pde_data, ic_data, bc_data):
+        """
+        Compute loss of 3 parts: governing equation, initial condition and boundary conditions.
+
+        Args:
+            pde_data (Tensor): the input data of governing equations.
+            ic_data (Tensor): the input data of initial condition.
+            bc_data (Tensor): the input data of boundary condition.
+        """
+        pde_res = self.parse_node(self.pde_nodes, inputs=pde_data)
+        pde_loss = self.loss_fn(pde_res[0], Tensor(np.array([0.0]), mstype.float32))
+
+        ic_res = self.parse_node(self.ic_nodes, inputs=ic_data)
+        ic_loss = self.loss_fn(ic_res[0], Tensor(np.array([0.0]), mstype.float32))
+
+        bc_res = self.parse_node(self.bc_nodes, inputs=bc_data)
+        bc_loss = self.loss_fn(bc_res[0], Tensor(np.array([0.0]), mstype.float32))
+
+        return pde_loss + ic_loss + bc_loss
diff --git a/MindFlow/applications/burgers1d/src/utils.py b/MindFlow/applications/burgers1d/src/utils.py
new file mode 100644
index 000000000..a48ff6deb
--- /dev/null
+++ b/MindFlow/applications/burgers1d/src/utils.py
@@ -0,0 +1,105 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""
+visualization functions
+"""
+import time
+import numpy as np
+from matplotlib.gridspec import GridSpec
+import matplotlib.pyplot as plt
+
+from mindspore import Tensor
+from mindspore import dtype as mstype
+
+from mindscience.utils import print_log
+
+
+def visual(model, epochs=1, resolution=100):
+    """visulization of ex/ey/hz"""
+    t_flat = np.linspace(0, 1, resolution)
+    x_flat = np.linspace(-1, 1, resolution)
+    t_grid, x_grid = np.meshgrid(t_flat, x_flat)
+    x = x_grid.reshape((-1, 1))
+    t = t_grid.reshape((-1, 1))
+    xt = Tensor(np.concatenate((x, t), axis=1), dtype=mstype.float32)
+    u_predict = model(xt)
+    u_predict = u_predict.asnumpy()
+    gs = GridSpec(2, 3)
+    plt.subplot(gs[0, :])
+    plt.scatter(t, x, c=u_predict, cmap=plt.cm.rainbow)
+    plt.xlabel('t')
+    plt.ylabel('x')
+    cbar = plt.colorbar(pad=0.05, aspect=10)
+    cbar.set_label('u(t,x)')
+    cbar.mappable.set_clim(-1, 1)
+    t_cross_sections = [0.25, 0.5, 0.75]
+    for i, t_cs in enumerate(t_cross_sections):
+        plt.subplot(gs[1, i])
+        xt = Tensor(np.stack([x_flat, np.full(x_flat.shape, t_cs)], axis=-1), dtype=mstype.float32)
+        u = model(xt).asnumpy()
+        plt.plot(x_flat, u)
+        plt.title('t={}'.format(t_cs))
+        plt.xlabel('x')
+        plt.ylabel('u(t,x)')
+    plt.tight_layout()
+    plt.savefig(f'images/{epochs + 1}-result.jpg')
+
+
+def _calculate_error(label, prediction):
+    '''calculate l2-error to evaluate accuracy'''
+    error = label - prediction
+    l2_error = np.sqrt(np.sum(np.square(error[..., 0]))) / np.sqrt(np.sum(np.square(label[..., 0])))
+
+    return l2_error
+
+
+def _get_prediction(model, inputs, label_shape, batch_size):
+    '''calculate the prediction respect to the given inputs'''
+    prediction = np.zeros(label_shape)
+    prediction = prediction.reshape((-1, label_shape[1]))
+    inputs = inputs.reshape((-1, inputs.shape[1]))
+
+    time_beg = time.time()
+
+    index = 0
+    while index < inputs.shape[0]:
+        index_end = min(index + batch_size, inputs.shape[0])
+        test_batch = Tensor(inputs[index: index_end, :], mstype.float32)
+        prediction[index: index_end, :] = model(test_batch).asnumpy()
+        index = index_end
+
+    print_log("    predict total time: {} ms".format((time.time() - time_beg)*1000))
+    prediction = prediction.reshape(label_shape)
+    prediction = prediction.reshape((-1, label_shape[1]))
+    return prediction
+
+
+def calculate_l2_error(model, inputs, label, batch_size):
+    """
+    Evaluate the model respect to input data and label.
+
+    Args:
+         model (Cell): list of expressions node can by identified by mindspore.
+         inputs (Tensor): the input data of network.
+         label (Tensor): the true output value of given inputs.
+         batch_size (int): data size in one step, which is the same as that in training.
+
+    """
+    label_shape = label.shape
+    prediction = _get_prediction(model, inputs, label_shape, batch_size)
+    label = label.reshape((-1, label_shape[1]))
+    l2_error = _calculate_error(label, prediction)
+    print_log("    l2_error: ", l2_error)
+    print_log("==================================================================================================")
diff --git a/MindFlow/applications/burgers1d/train.py b/MindFlow/applications/burgers1d/train.py
new file mode 100644
index 000000000..0260e8f87
--- /dev/null
+++ b/MindFlow/applications/burgers1d/train.py
@@ -0,0 +1,149 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""train process"""
+
+import argparse
+import os
+import time
+
+import numpy as np
+
+import mindspore
+from mindspore import context, nn, ops, jit, set_seed
+from mindspore import load_checkpoint, load_param_into_net
+
+from mindscience.models import MultiScaleFCSequential
+from mindscience.utils import print_log, log_config, log_timer
+from mindscience.utils import load_yaml_config
+
+from src import create_training_dataset, create_test_dataset, visual, calculate_l2_error, Burgers1D
+
+
+set_seed(123456)
+np.random.seed(123456)
+
+
+def parse_args():
+    '''Parse input args'''
+    parser = argparse.ArgumentParser(description="burgers train")
+    parser.add_argument("--config_file_path", type=str, default="./configs/burgers.yaml")
+    parser.add_argument("--device_target", type=str, default="Ascend", choices=["GPU", "Ascend"],
+                        help="The target device to run, support 'Ascend', 'GPU'")
+    parser.add_argument("--device_id", type=int, default=0, help="ID of the target device")
+    parser.add_argument("--mode", type=str, default="GRAPH", choices=["GRAPH", "PYNATIVE"],
+                        help="Running in GRAPH_MODE OR PYNATIVE_MODE")
+    parser.add_argument("--save_graphs", type=bool, default=False, choices=[True, False],
+                        help="Whether to save intermediate compilation graphs")
+    parser.add_argument("--save_graphs_path", type=str, default="./graphs")
+
+    input_args = parser.parse_args()
+    return input_args
+
+
+@log_timer
+def train():
+    '''Train and evaluate the pinns network'''
+    # load configurations
+    config = load_yaml_config(args.config_file_path)
+
+    # create dataset
+    burgers_train_dataset = create_training_dataset(config)
+    train_dataset = burgers_train_dataset.create_dataset(batch_size=config["data"]["train"]["batch_size"],
+                                                         shuffle=True,
+                                                         prebatched_data=True,
+                                                         drop_remainder=True)
+    # create  test dataset
+    inputs, label = create_test_dataset(config["data"]["root_dir"])
+
+    # define models and optimizers
+    model = MultiScaleFCSequential(in_channels=config["model"]["in_channels"],
+                                   out_channels=config["model"]["out_channels"],
+                                   layers=config["model"]["layers"],
+                                   neurons=config["model"]["neurons"],
+                                   residual=config["model"]["residual"],
+                                   act=config["model"]["activation"],
+                                   num_scales=1)
+
+    if config["model"]["load_ckpt"]:
+        param_dict = load_checkpoint(config["summary"]["ckpt_dir"])
+        load_param_into_net(model, param_dict)
+
+    # define optimizer
+    optimizer = nn.Adam(model.trainable_params(), config["optimizer"]["learning_rate"])
+    problem = Burgers1D(model)
+
+    if use_ascend:
+        from mindspore.amp import DynamicLossScaler, auto_mixed_precision, all_finite
+        loss_scaler = DynamicLossScaler(1024, 2, 100)
+        auto_mixed_precision(model, 'O3')
+    else:
+        loss_scaler = None
+
+    def forward_fn(pde_data, ic_data, bc_data):
+        loss = problem.get_loss(pde_data, ic_data, bc_data)
+        if use_ascend:
+            loss = loss_scaler.scale(loss)
+
+        return loss
+
+    grad_fn = ops.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=False)
+
+    @jit
+    def train_step(pde_data, ic_data, bc_data):
+        loss, grads = grad_fn(pde_data, ic_data, bc_data)
+        if use_ascend:
+            loss = loss_scaler.unscale(loss)
+            is_finite = all_finite(grads)
+            if is_finite:
+                grads = loss_scaler.unscale(grads)
+                loss = ops.depend(loss, optimizer(grads))
+            loss_scaler.adjust(is_finite)
+        else:
+            loss = ops.depend(loss, optimizer(grads))
+        return loss
+
+    epochs = config["data"]["train"]["epochs"]
+    steps_per_epoch = train_dataset.get_dataset_size()
+    sink_process = mindspore.data_sink(train_step, train_dataset, sink_size=1)
+    for epoch in range(1, 1 + epochs):
+        # train
+        local_time_beg = time.time()
+        model.set_train(True)
+        for _ in range(steps_per_epoch):
+            step_train_loss = sink_process()
+        local_time_end = time.time()
+        epoch_seconds = (local_time_end - local_time_beg) * 1000
+        step_seconds = epoch_seconds/steps_per_epoch
+        print_log(f"epoch: {epoch} train loss: {step_train_loss} "
+                  f"epoch time: {epoch_seconds:5.3f}ms step time: {step_seconds:5.3f}ms")
+        model.set_train(False)
+        if epoch % config["summary"]["eval_interval_epochs"] == 0:
+            eval_time_start = time.time()
+            calculate_l2_error(model, inputs, label, config["data"]["train"]["batch_size"])
+            print_log(f'evaluation time: {time.time() - eval_time_start}s')
+
+    visual(model, epochs=epochs, resolution=config["summary"]["visual_resolution"])
+
+
+if __name__ == '__main__':
+    log_config('./logs', 'burgers')
+    print_log("pid:", os.getpid())
+    args = parse_args()
+    context.set_context(mode=context.GRAPH_MODE if args.mode.upper().startswith("GRAPH") else context.PYNATIVE_MODE,
+                        device_target=args.device_target,
+                        device_id=args.device_id)
+    print_log(f"Running in {args.mode.upper()} mode, using device id: {args.device_id}.")
+    use_ascend = context.get_context(attr_key='device_target') == "Ascend"
+    train()
diff --git a/mindscience/data/flow/data/__init__.py b/mindscience/data/flow/data/__init__.py
new file mode 100644
index 000000000..fc07ab59f
--- /dev/null
+++ b/mindscience/data/flow/data/__init__.py
@@ -0,0 +1,30 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""init"""
+from .dataset import Dataset
+from .mind_dataset import MindDataset
+from .boundary import BoundaryBC, BoundaryIC, Boundary
+from .equation import Equation
+from .existed_data import ExistedDataset
+from .data_base import ExistedDataConfig, CONSTRAINT_TYPES
+
+__all__ = ["Dataset",
+           "MindDataset",
+           "Equation",
+           "BoundaryBC",
+           "BoundaryIC",
+           "ExistedDataset",
+           "ExistedDataConfig",
+           "CONSTRAINT_TYPES"]
diff --git a/mindscience/data/flow/data/boundary.py b/mindscience/data/flow/data/boundary.py
new file mode 100644
index 000000000..cdfe9e8cf
--- /dev/null
+++ b/mindscience/data/flow/data/boundary.py
@@ -0,0 +1,206 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#pylint: disable=W0223
+#pylint: disable=W0221
+"""
+Sampling data of boundary condition and initial condition.
+"""
+from __future__ import absolute_import
+import numpy as np
+
+from mindspore import log as logger
+from .data_base import Data
+from ..geometry.geometry_base import Geometry, SamplingConfig
+from ....utils.check_func import check_param_type
+
+
+class Boundary(Data):
+    """
+    Base class of boundary condition and initial condition.
+
+    Args:
+        geometry (Geometry): specifies geometry information of boundary condition and initial condition.
+
+    Raises:
+        ValueError: if `sampling_config` of geometry is ``None``.
+        TypeError: if `geometry` is not an instance of Geometry.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.geometry import generate_sampling_config, Geometry
+        >>> from mindflow.data import Boundary
+        >>> geometry_config = dict({'BC' : dict({'random_sampling' : True, 'size' : 100, 'sampler' : 'uniform',})})
+        >>> sampling_config = generate_sampling_config(geometry_config)
+        >>> geom = Geometry("geom", 1, 0.0, 1.0, sampling_config=sampling_config)
+        >>> boundary = Boundary(geometry=geom)
+    """
+    def __init__(self, geometry):
+        check_param_type(geometry, "geometry", data_type=Geometry)
+        self.geometry = geometry
+        check_param_type(geometry.sampling_config, geometry.name, data_type=SamplingConfig)
+
+        self.data = None
+        self.data_size = None
+        self.batch_size = 1
+        self.shuffle = False
+        self.batched_data_size = None
+        self.columns_list = None
+        self._bound_index = None
+        self._bound_index_num = 0
+        super(Boundary, self).__init__()
+
+    def _get_sampling_data(self, geom_type="BC"):
+        """get sampling data"""
+        sample_data = self.geometry.sampling(geom_type=geom_type)
+        if not isinstance(sample_data, tuple):
+            sample_data = (sample_data,)
+        logger.info("Get {} sample_data size: {}".format(geom_type, len(sample_data[0])))
+        return sample_data, self.geometry.columns_dict[geom_type]
+
+    def _initialize(self, batch_size=1, shuffle=False, geom_type="BC"):
+        """initialization: sampling and set attrs."""
+        data, self.columns_list = self._get_sampling_data(geom_type=geom_type)
+        if not isinstance(data, tuple):
+            data = (data,)
+        self.data = data
+        self.data_size = len(self.data[0])
+        self.batch_size = batch_size
+        if batch_size > self.data_size:
+            raise ValueError("If prebatch data, batch_size: {} should not be larger than data size: {}.".format(
+                batch_size, self.data_size
+            ))
+        self.batched_data_size = self.data_size // batch_size
+        self.shuffle = shuffle
+        self._bound_index = np.arange(self.data_size)
+        logger.info("Get {} dataset: {}, columns: {}, size: {}, batched_size: {}, shuffle: {}".format(
+            geom_type, self.name, self.columns_list, self.data_size, self.batched_data_size, self.shuffle))
+        return data
+
+    def _get_index_when_sample_iter(self, index, geom_type="BC"):
+        if self._bound_index_num == self.batched_data_size:
+            self.data = self._initialize(self.batch_size, self.shuffle, geom_type=geom_type)
+            self._bound_index_num = 0
+        index = self._bound_index_num
+        self._bound_index_num += 1
+        return index
+
+    def _get_index_when_sample_all(self, index):
+        data_size = self.__len__()
+        if (self._random_merge or self.shuffle) and index % data_size == 0:
+            self._bound_index = np.random.permutation(self.data_size)
+        index = index % data_size if index >= data_size else index
+        return index
+
+    def __len__(self):
+        return self.batched_data_size
+
+    def _get_item(self, index):
+        col_data = None
+        for i in range(len(self.columns_list)):
+            temp_data = self.data[i][self._bound_index[index]] if self.batch_size == 1 else \
+                        self.data[i][self._bound_index[index * self.batch_size : (index + 1) * self.batch_size]]
+            col_data = (temp_data,) if col_data is None else col_data + (temp_data,)
+        return col_data
+
+
+class BoundaryBC(Boundary):
+    """
+    Sampling data of boundary condition.
+
+    Args:
+        geometry (Geometry): specifies geometry information of boundary condition. Derived from mindflow.geometry,
+            the geometry could be cube or disk, etc.
+
+    Raises:
+        ValueError: if sampling_config.bc of `geometry` is ``None``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.geometry import generate_sampling_config, Geometry
+        >>> from mindflow.data import BoundaryBC
+        >>> geometry_config = dict({'BC' : dict({'random_sampling' : True, 'size' : 100, 'sampler' : 'uniform',})})
+        >>> sampling_config = generate_sampling_config(geometry_config)
+        >>> geom = Geometry("geom", 1, 0.0, 1.0, sampling_config=sampling_config)
+        >>> boundary_bc = BoundaryBC(geometry=geom)
+    """
+    def __init__(self, geometry):
+        super(BoundaryBC, self).__init__(geometry)
+        self.sampling_config = self.geometry.sampling_config.bc
+        if not self.sampling_config:
+            raise ValueError("BC info for the current geometry: {} should not be None".format(geometry.name))
+        self.name = geometry.name + "_BC"
+        self.constraint_type = "BC"
+        self._random_merge = self.sampling_config.random_merge
+
+    def __getitem__(self, bc_index):
+        if not self.data:
+            self._initialization()
+        if self.sampling_config.random_sampling:
+            bc_index = self._get_index_when_sample_iter(bc_index, geom_type="BC")
+        else:
+            bc_index = self._get_index_when_sample_all(bc_index)
+        return self._get_item(bc_index)
+
+    def _initialization(self, batch_size=1, shuffle=False):
+        """initialization: sampling and set attrs."""
+        return self._initialize(batch_size=batch_size, shuffle=shuffle, geom_type="BC")
+
+
+class BoundaryIC(Boundary):
+    """
+    Sampling data of initial condition.
+
+    Args:
+        geometry (Geometry): specifies geometry information of initial condition.
+
+    Raises:
+        ValueError: if sampling_config.ic of geometry is ``None``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.geometry import generate_sampling_config, Geometry
+        >>> from mindflow.data import BoundaryIC
+        >>> geometry_config = dict({'IC' : dict({'random_sampling' : True, 'size' : 100, 'sampler' : 'uniform',})})
+        >>> sampling_config = generate_sampling_config(geometry_config)
+        >>> geom = Geometry("geom", 1, 0.0, 1.0, sampling_config=sampling_config)
+        >>> boundary_ic = BoundaryIC(geometry=geom)
+    """
+    def __init__(self, geometry):
+        super(BoundaryIC, self).__init__(geometry)
+        self.sampling_config = self.geometry.sampling_config.ic
+        if not self.sampling_config:
+            raise ValueError("IC info for the current geometry: {} should not be None".format(geometry.name))
+        self.name = geometry.name + "_IC"
+        self.constraint_type = "IC"
+        self._random_merge = self.sampling_config.random_merge
+
+    def _initialization(self, batch_size=1, shuffle=False):
+        """initialization: sampling and set attrs."""
+        return self._initialize(batch_size=batch_size, shuffle=shuffle, geom_type="IC")
+
+    def __getitem__(self, ic_index):
+        if not self.data:
+            self._initialization()
+        if self.sampling_config.random_sampling:
+            ic_index = self._get_index_when_sample_iter(ic_index, geom_type="IC")
+        else:
+            ic_index = self._get_index_when_sample_all(ic_index)
+        return self._get_item(ic_index)
diff --git a/mindscience/data/flow/data/data_base.py b/mindscience/data/flow/data/data_base.py
new file mode 100644
index 000000000..1591888da
--- /dev/null
+++ b/mindscience/data/flow/data/data_base.py
@@ -0,0 +1,130 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""
+This dataset module supports various type of datasets, including .... Some of the operations that are
+provided to users to preprocess data include shuffle, batch, repeat, map, and zip.
+"""
+from __future__ import absolute_import
+import os
+import abc
+
+from ....utils.check_func import check_param_type, check_param_value, check_param_type_value
+
+CONSTRAINT_TYPES = ["equation", "bc", "ic", "label", "function", "custom"]
+DATA_FORMATS = ["npy"]
+
+
+class Data:
+    """
+    This class is the base class of Dataset, Equation, Boundary and ExistedDataset. It represents
+    a node in the data flow graph.
+
+    Args:
+        name (str): distinguished name of specified dataset. Default: ``None``.
+        columns_list (Union[list, tuple]): list of column names. Default: ``None``.
+        constraint_type (str, optional): constraint type of the specified dataset to get it's corresponding loss
+            function. Default: ``None``. The `constraint_type` can be ``"equation"``, ``"bc"``, ``"ic"``,
+            ``"label"`` or ``"function"``.
+
+    Raises:
+        TypeError: if `constraint_type` is ``None`` or `constraint_type.lower()` is not in
+            [``"equation"``, ``"bc"``, ``"ic"``, ``"label"``, ``"function"``].
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    def __init__(self, name=None, columns_list=None, constraint_type=None):
+        none_type = type(None)
+        check_param_type(name, "name", data_type=[str, none_type])
+        check_param_type(columns_list, "columns_list", data_type=[list, tuple, none_type])
+        check_param_type(constraint_type, "constraint_type", data_type=[str, none_type])
+        check_param_type(constraint_type, "constraint_type", data_type=(str, none_type))
+        if constraint_type:
+            check_param_value(constraint_type.lower(), "constraint_type", CONSTRAINT_TYPES)
+        self.name = name
+        self.columns_list = columns_list
+        self.constraint_type = constraint_type
+        self.dataset_type = type(self).__name__
+
+    def set_constraint_type(self, constraint_type="Equation"):
+        check_param_type(constraint_type, "constraint_type", data_type=str)
+        check_param_value(constraint_type.lower(), "constraint_type", CONSTRAINT_TYPES)
+        self.constraint_type = constraint_type
+
+    @abc.abstractmethod
+    def create_dataset(self):
+        """Return a dataset of the size `batch_size`."""
+        raise NotImplementedError("{}.create_dataset not implemented".format(self.dataset_type))
+
+    @abc.abstractmethod
+    def _initialization(self):
+        """Initialize dataset to get data"""
+        raise NotImplementedError("{}._initialization not implemented".format(self.dataset_type))
+
+    @abc.abstractmethod
+    def __getitem__(self, index):
+        """Defines behavior for when an item is accessed. Return the corresponding element for given index."""
+        raise NotImplementedError("{}.__getitem__ not implemented".format(self.dataset_type))
+
+    @abc.abstractmethod
+    def __len__(self):
+        """Return length of dataset"""
+        raise NotImplementedError("{}.__len__ not implemented".format(self.dataset_type))
+
+
+class ExistedDataConfig:
+    """
+    Set arguments of ExistedDataset.
+
+    Args:
+        name (str): specifies the name of dataset.
+        data_dir (Union[str, list, tuple]): the path of existed data files.
+        columns_list (Union[str, list, tuple]): list of column names of the dataset.
+        data_format (str, optional): the format of existed data files. Default: ``'npy'``.
+            The format of ``'npy'`` is supported now.
+        constraint_type (str, optional): specifies the constraint type of the created dataset.
+            Default: ``"Label"``.
+        random_merge (bool, optional): specifies whether randomly merge the given datasets.
+            Default: ``True``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+    """
+    def __init__(self, name, data_dir, columns_list, data_format="npy", constraint_type="Label", random_merge=True):
+        check_param_type(name, "name", data_type=str)
+        self.name = name
+        if isinstance(data_dir, str):
+            data_dir = [data_dir]
+
+        check_param_type(data_dir, "data_dir", data_type=[str, list, tuple])
+        for path in data_dir:
+            if not os.path.exists(path):
+                raise ValueError('ExistedDataset file: {} does not exist'.format(path))
+        self.data_dir = data_dir
+
+        if isinstance(columns_list, str):
+            columns_list = [columns_list]
+        check_param_type(columns_list, "columns_list", data_type=[str, tuple, list])
+        self.columns_list = columns_list
+
+        check_param_type(constraint_type, "constraint_type", data_type=str)
+        check_param_value(constraint_type.lower(), "constraint_type", CONSTRAINT_TYPES)
+        self.constraint_type = constraint_type
+
+        check_param_type_value(data_format, "data_format", DATA_FORMATS, data_type=str)
+        self.data_format = data_format
+
+        check_param_type(random_merge, "random_merge", data_type=bool)
+        self.random_merge = random_merge
diff --git a/mindscience/data/flow/data/dataset.py b/mindscience/data/flow/data/dataset.py
new file mode 100644
index 000000000..1c6520005
--- /dev/null
+++ b/mindscience/data/flow/data/dataset.py
@@ -0,0 +1,393 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#pylint: disable=W0223
+#pylint: disable=W0221
+#pylint: disable=W0212
+"""
+Combine pde/ic/bc datasets together
+"""
+from __future__ import absolute_import
+import copy
+
+import mindspore.dataset as ds
+from mindspore import log as logger
+
+from .data_base import Data, ExistedDataConfig
+from .existed_data import ExistedDataset
+from .equation import Equation
+from .boundary import BoundaryIC, BoundaryBC
+from ..geometry import Geometry
+from ....utils.check_func import check_param_type, check_dict_type_value
+
+_geomdata_dict = {
+    "domain": Equation,
+    "IC": BoundaryIC,
+    "BC": BoundaryBC,
+}
+
+
+class Dataset(Data):
+    r"""
+    Combine datasets together.
+
+    Parameters:
+        geometry_dict (dict, optional): specifies geometry datasets to be merged. The key is geometry instance and
+            value is a list of type of geometry. For example, geometry_dict = {geom : ["domain", "BC", "IC"]}.
+            Default: ``None``.
+        existed_data_list (Union[list, tuple, ExistedDataConfig], optional): specifies existed datasets to be merged.
+            For example, existed_data_list = [ExistedDataConfig_Instance1, ExistedDataConfig_Instance2].
+            Default: ``None``.
+        dataset_list (Union[list, tuple, Data], optional): specifies instances of data to be merged. For example,
+            dataset_list=[BoundaryIC_Instance, Equation_Instance, BoundaryBC_Instance and ExistedData_Instance].
+            Default: ``None``.
+
+    Raises:
+        ValueError: If `geometry_dict`, existed_data_list and dataset_list are all ``None``.
+        TypeError: If the type of `geometry_dict` is not dict.
+        TypeError: If the type of key of geometry_dict is not instance of class Geometry.
+        TypeError: If the type of `existed_data_list` is not list, tuple or instance of ExistedDataConfig.
+        TypeError: If the element of `existed_data_list` is not instance of ExistedDataConfig.
+        TypeError: If the element of `dataset_list` is not instance of class Data.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.geometry import Rectangle, generate_sampling_config
+        >>> from mindflow.data import Dataset
+        >>> rectangle_mesh = dict({'domain': dict({'random_sampling': False, 'size': [50, 25]})})
+        >>> rect_space = Rectangle("rectangle", coord_min=[0, 0], coord_max=[5, 5],
+        ...                        sampling_config=generate_sampling_config(rectangle_mesh))
+        >>> geom_dict = {rect_space: ["domain"]}
+        >>> dataset = Dataset(geometry_dict=geom_dict)
+    """
+
+    def __init__(self, geometry_dict=None, existed_data_list=None, dataset_list=None):
+        super(Dataset, self).__init__()
+        if all((geometry_dict is None, existed_data_list is None, dataset_list is None)):
+            raise ValueError(
+                "Dataset should have at least one sub-dataset, but got None")
+
+        if geometry_dict is not None:
+            check_param_type(geometry_dict, "geometry_dict", data_type=dict)
+            check_dict_type_value(geometry_dict, "geometry_dict", key_type=Geometry, value_type=str,
+                                  value_value=list(_geomdata_dict.keys()))
+
+        if existed_data_list is not None:
+            if isinstance(existed_data_list, ExistedDataConfig):
+                existed_data_list = [existed_data_list]
+            check_param_type(existed_data_list,
+                             "existed_data_list", (list, tuple))
+
+            for data_config in existed_data_list:
+                check_param_type(
+                    data_config, "element in existed_data_list", ExistedDataConfig)
+
+        if dataset_list is not None:
+            if isinstance(dataset_list, Data):
+                dataset_list = [dataset_list]
+            check_param_type(dataset_list, "dataset_list", (list, tuple))
+            for dataset in dataset_list:
+                check_param_type(dataset, "element in dataset_list", Data)
+
+        self.existed_data_list = existed_data_list
+        self.geometry_dict = geometry_dict
+        self.dataset_list = dataset_list
+        self.all_datasets = dataset_list if dataset_list else []
+        self.columns_list = None
+        self._iterable_datasets = None
+
+        self.num_dataset = len(dataset_list) if dataset_list else 0
+        if existed_data_list:
+            self.num_dataset += len(existed_data_list)
+        if geometry_dict:
+            for geom in geometry_dict:
+                self.num_dataset += len(geometry_dict[geom])
+        logger.info("Total datasets number: {}".format(self.num_dataset))
+        self.dataset_columns_map = {}
+        self.column_index_map = {}
+        self.dataset_constraint_map = {}
+
+    def _create_dataset_from_geometry(self, geometry, geom_type="domain"):
+        """create dataset from geometry."""
+        dataset_instance = _geomdata_dict.get(geom_type)(geometry)
+        return dataset_instance
+
+    def _get_all_datasets(self):
+        """get all datasets"""
+        if self.geometry_dict:
+            for geom, types in self.geometry_dict.items():
+                for geom_type in types:
+                    dataset = self._create_dataset_from_geometry(
+                        geom, geom_type)
+                    self.all_datasets.append(dataset)
+
+        if self.existed_data_list:
+            for data_config in self.existed_data_list:
+                dataset = ExistedDataset(data_config=data_config)
+                self.all_datasets.append(dataset)
+
+    def create_dataset(self,
+                       batch_size=1,
+                       preprocess_fn=None,
+                       input_output_columns_map=None,
+                       shuffle=True,
+                       drop_remainder=True,
+                       prebatched_data=False,
+                       num_parallel_workers=1,
+                       num_shards=None,
+                       shard_id=None,
+                       python_multiprocessing=False,
+                       sampler=None):
+        """
+        create the final mindspore type dataset to merge all the sub-datasets.
+
+        Args:
+            batch_size (int, optional): An int number of rows each batch is created with. Default: ``1``.
+            preprocess_fn (Union[list[TensorOp], list[functions]], optional): List of operations to be
+                applied on the dataset. Operations are applied in the order they appear in this list.
+                Default: ``None``.
+            input_output_columns_map (dict, optional): specifies which columns to replace and to what.
+                The key is the column name to be replaced and the value is the name you want to replace with.
+                There's no need to set this argument if all columns are not changed after mapping.
+                Default: ``None``.
+            shuffle (bool, optional): Whether or not to perform shuffle on the dataset. Random accessible input is
+                required. Default: ``True``, expected order behavior shown in the table.
+            drop_remainder (bool, optional): Determines whether or not to drop the last block
+                whose data row number is less than batch size. If ``True``, and if there are less
+                than batch_size rows available to make the last batch, then those rows will
+                be dropped and not propagated to the child node. Default: ``True``.
+            prebatched_data (bool, optional): Generate pre-batched data before create mindspore dataset. If ``True``,
+                pre-batched data will be returned when get each sub-dataset data by index. Else, the batch operation
+                will be done by mindspore dataset interface: dataset.batch. When batch_size is very large, it's
+                recommended to set this option to be ``True`` in order to improve performance on host.
+                Default: ``False``.
+            num_parallel_workers (int, optional): Number of workers(threads) to process the dataset in parallel.
+                Default: ``1``.
+            num_shards (int, optional): Number of shards that the dataset will be divided into.
+                Random accessible input is required. When this argument is specified, `num_samples` reflects the
+                maximum sample number of per shard. Default: ``None``.
+            shard_id (int, optional): The shard ID within num_shards. This argument must be specified
+                only when num_shards is also specified. Random accessible input is required. Default: ``None``.
+            python_multiprocessing (bool, optional): Parallelize Python function per_batch_map with multi-processing.
+                This option could be beneficial if the function is computational heavy. Default: ``False``.
+            sampler (Sampler, optional): Dataset Sampler. Default: ``None``.
+
+        Returns:
+            BatchDataset, dataset batched.
+
+        Examples:
+            >>> data = dataset.create_dataset()
+        """
+        self._get_all_datasets()
+        check_param_type(prebatched_data, "prebatched_data", data_type=bool)
+        check_param_type(drop_remainder, "drop_remainder", data_type=bool)
+        check_param_type(shuffle, "shuffle", data_type=bool)
+        check_param_type(batch_size, "batch_size",
+                         data_type=int, exclude_type=bool)
+
+        if prebatched_data and not drop_remainder:
+            raise ValueError(
+                "prebatched_data is not supported when drop_remained is set to be False")
+        for dataset in self.all_datasets:
+            prebatch_size = batch_size if prebatched_data else 1
+            prebatch_shuffle = shuffle if prebatched_data else False
+            dataset._initialization(
+                batch_size=prebatch_size, shuffle=prebatch_shuffle)
+            self.columns_list = dataset.columns_list if not self.columns_list else self.columns_list + \
+                dataset.columns_list
+            logger.info("Check initial all dataset, dataset: {}, columns_list: {}, data_size: {}".format(
+                dataset.name, dataset.columns_list, len(dataset)))
+
+        dataset = self._merge_all_datasets(shuffle=False if prebatched_data else shuffle,
+                                           num_parallel_workers=num_parallel_workers,
+                                           num_shards=num_shards,
+                                           shard_id=shard_id,
+                                           python_multiprocessing=python_multiprocessing)
+        logger.info("Initial dataset size: {}".format(
+            dataset.get_dataset_size()))
+        logger.info("Get all dataset columns names: {}".format(
+            self.columns_list))
+
+        self.dataset_columns_map, self.dataset_constraint_map, self.column_index_map = self._create_trace_maps()
+        logger.info("Dataset columns map: {}".format(self.dataset_columns_map))
+        logger.info("Dataset column index map: {}".format(
+            self.column_index_map))
+        logger.info("Dataset constraints map: {}".format(
+            self.dataset_constraint_map))
+
+        if sampler:
+            logger.info("Dataset uses sampler")
+            dataset.use_sampler(sampler)
+
+        if preprocess_fn:
+            input_columns = copy.deepcopy(self.columns_list)
+            check_param_type(input_output_columns_map,
+                             "input_output_columns_map", (type(None), dict))
+            if input_output_columns_map:
+                new_columns_list, new_dataset_columns_map = self._update_columns_list(
+                    input_output_columns_map)
+                self.columns_list = new_columns_list
+                self.dataset_columns_map = new_dataset_columns_map
+                self.column_index_map = {}
+                for i in range(len(self.columns_list)):
+                    self.column_index_map[self.columns_list[i]] = i
+                logger.info("Dataset columns map after preprocess: {}".format(
+                    self.dataset_columns_map))
+                logger.info("Dataset column index after preprocess: {}".format(
+                    self.column_index_map))
+                logger.info("Dataset constraints after preprocess: {}".format(
+                    self.dataset_constraint_map))
+            output_columns = self.columns_list
+
+            dataset = dataset.map(operations=preprocess_fn,
+                                  input_columns=input_columns,
+                                  output_columns=output_columns,
+                                  num_parallel_workers=num_parallel_workers,
+                                  python_multiprocessing=python_multiprocessing)
+            dataset = dataset.project(output_columns)
+            logger.info("Get all dataset columns names after preprocess: {}".format(
+                self.columns_list))
+
+        if not prebatched_data:
+            dataset = dataset.batch(batch_size=batch_size,
+                                    drop_remainder=drop_remainder,
+                                    num_parallel_workers=num_parallel_workers)
+        logger.info("Final dataset size: {}".format(
+            dataset.get_dataset_size()))
+        return dataset
+
+    def _merge_all_datasets(self, shuffle=True, num_parallel_workers=1, num_shards=1, shard_id=0,
+                            python_multiprocessing=False):
+        """merge all datasets"""
+        self._iterable_datasets = _IterableDatasets(self.all_datasets)
+        dataset = ds.GeneratorDataset(source=self._iterable_datasets,
+                                      column_names=self.columns_list,
+                                      shuffle=shuffle,
+                                      num_parallel_workers=num_parallel_workers,
+                                      num_shards=num_shards,
+                                      shard_id=shard_id,
+                                      python_multiprocessing=python_multiprocessing
+                                      )
+        return dataset
+
+    def _update_columns_list(self, input_output_columns_map):
+        """update columns list"""
+        new_dataset_columns_map = {}
+        for dataset in self.all_datasets:
+            columns_list = dataset.columns_list
+            new_dataset_columns_map[dataset.name] = []
+            for column in columns_list:
+                if column in input_output_columns_map.keys():
+                    new_column = input_output_columns_map[column]
+                    if isinstance(new_column, list):
+                        new_dataset_columns_map[dataset.name] += new_column
+                    else:
+                        new_dataset_columns_map.get(
+                            dataset.name).append(new_column)
+                else:
+                    new_dataset_columns_map.get(dataset.name).append(column)
+
+        new_columns_list = []
+        for name in new_dataset_columns_map:
+            new_columns_list += new_dataset_columns_map[name]
+        return new_columns_list, new_dataset_columns_map
+
+    def get_columns_list(self):
+        """get columns list
+
+        Returns:
+            list[str]. column names list of the final unified dataset.
+
+        Examples:
+            >>> columns_list = dataset.get_columns_list()
+        """
+        if not self.columns_list:
+            raise ValueError("Please call create_dataset() first before get final columns list to avoid unexpected "
+                             "error")
+        return self.columns_list
+
+    def _create_trace_maps(self):
+        """create trace maps"""
+        dataset_columns_map = {}
+        dataset_constraint_map = {}
+        column_index_map = {}
+        for dataset in self.all_datasets:
+            name = dataset.name
+            dataset_columns_map[name] = dataset.columns_list
+            dataset_constraint_map[name] = dataset.constraint_type
+
+        for i in range(len(self.columns_list)):
+            column_index_map[self.columns_list[i]] = i
+        return dataset_columns_map, dataset_constraint_map, column_index_map
+
+    def __getitem__(self, index):
+        if not self._iterable_datasets:
+            raise ValueError(
+                "Call create_dataset() before getting item by index to avoid unexpected error")
+        return self._iterable_datasets[index]
+
+    def set_constraint_type(self, constraint_type="Equation"):
+        """set constraint type of dataset
+
+        Args:
+            constraint_type (Union[str, dict]): The constraint type of specified dataset. If is string, the constraint
+                type of all subdataset will be set to the same one. If is dict, the subdataset and it's constraint type
+                is specified by the pair (key, value). Default: ``"Equation"``. It also supports ``"bc"``, ``"ic"``,
+                ``"label"``, ``"function"``, and ``"custom"``.
+
+        Examples:
+            >>> dataset.set_constraint_type("Equation")
+        """
+        if isinstance(constraint_type, str):
+            logger.warning("Argument constraint_type: {} is str, the same type will be set for all of the sub-datasets"
+                           .format(constraint_type))
+            for datasets in self.all_datasets:
+                datasets.set_constraint_type(constraint_type)
+        elif isinstance(constraint_type, dict):
+            for dataset in constraint_type.keys():
+                if dataset not in self.all_datasets:
+                    raise ValueError("Unknown dataset: {}. All sub-dataset are: {}".format(
+                        dataset, [data.name for data in self.all_datasets]))
+                dataset.set_constraint_type(constraint_type[dataset])
+        else:
+            raise TypeError("the type of constraint_type should be dict or str but got {}"
+                            .format(type(constraint_type)))
+
+    def __len__(self):
+        if not self._iterable_datasets:
+            raise ValueError(
+                "Call create_dataset() before getting item by index to avoid unexpected error")
+        return len(self._iterable_datasets)
+
+
+class _IterableDatasets():
+    """get data iteratively"""
+
+    def __init__(self, dataset_list):
+        self.dataset_list = dataset_list
+        dataset_size = [len(dataset) for dataset in dataset_list]
+        logger.info("Get all dataset sizes: {}".format(dataset_size))
+        self.longest = max(dataset_size)
+
+    def __getitem__(self, index):
+        col_data = None
+        for dataset_instance in self.dataset_list:
+            item = dataset_instance[index]
+            col_data = col_data + item if col_data else item
+        return col_data
+
+    def __len__(self):
+        return self.longest
diff --git a/mindscience/data/flow/data/equation.py b/mindscience/data/flow/data/equation.py
new file mode 100644
index 000000000..a14aa95b8
--- /dev/null
+++ b/mindscience/data/flow/data/equation.py
@@ -0,0 +1,137 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#pylint: disable=W0223
+#pylint: disable=W0221
+"""
+Sampling data of equation domain.
+"""
+from __future__ import absolute_import
+import numpy as np
+
+from mindspore import log as logger
+
+from .data_base import Data
+from ..geometry import Geometry, SamplingConfig
+from ....utils.check_func import check_param_type
+
+_SPACE = ""
+
+
+class Equation(Data):
+    """
+    Sampling data of equation domain.
+
+    Args:
+        geometry (Geometry): specifies geometry information of equation domain.
+
+    Raises:
+        TypeError: if `geometry` is not instance of class Geometry.
+        ValueError: if sampling_config of `geometry` is ``None``.
+        KeyError: if sampling_config.domain of `geometry` is ``None``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.geometry import generate_sampling_config, Geometry
+        >>> from mindflow.data import Equation
+        >>> geometry_config = dict({'domain' : dict({'random_sampling' : True, 'size' : 100, 'sampler' : 'uniform',})})
+        >>> sampling_config = generate_sampling_config(geometry_config)
+        >>> geom = Geometry("geom", 1, 0.0, 1.0, sampling_config=sampling_config)
+        >>> boundary = Equation(geometry=geom)
+    """
+    def __init__(self, geometry):
+        check_param_type(geometry, "geometry", data_type=Geometry)
+        check_param_type(geometry.sampling_config, _SPACE.join(("sampling_config of geometry:", geometry.name)),
+                         data_type=SamplingConfig)
+        self.sampling_config = geometry.sampling_config.domain
+        if not self.sampling_config:
+            raise ValueError("domain info of geometry: {} should not be None".format(geometry.name))
+        self.geometry = geometry
+
+        self.data = None
+        self.data_size = None
+        self.batch_size = 1
+        self.shuffle = False
+        self.batched_data_size = None
+        self.columns_list = None
+
+        self._domain_index = None
+        self._domain_index_num = 0
+        self._random_merge = self.sampling_config.random_merge
+
+        name = geometry.name + "_domain"
+        columns_list = [geometry.name + "_domain_points"]
+        constraint_type = "Equation"
+        super(Equation, self).__init__(name, columns_list, constraint_type)
+
+    def _get_sampling_data(self):
+        sample_data = self.geometry.sampling(geom_type="domain")
+        return sample_data, self.geometry.columns_dict["domain"]
+
+    def _initialization(self, batch_size=1, shuffle=False):
+        """initialization: sampling and set attrs."""
+        data, self.columns_list = self._get_sampling_data()
+        if not isinstance(data, tuple):
+            data = (data,)
+        self.data = data
+        self.data_size = len(self.data[0])
+
+        self.batch_size = batch_size
+        if batch_size > self.data_size:
+            raise ValueError("If prebatch data, batch_size: {} should not be larger than data size: {}.".format(
+                batch_size, self.data_size
+            ))
+        self.batched_data_size = self.data_size // batch_size
+        self.shuffle = shuffle
+        self._domain_index = np.arange(self.data_size)
+        logger.info("Get domain dataset: {}, columns: {}, size: {}, batched_size: {}, shuffle: {}".format(
+            self.name, self.columns_list, self.data_size, self.batched_data_size, self.shuffle))
+        return data
+
+    def _get_index_when_sample_iter(self, index):
+        if self._domain_index_num == self.batched_data_size:
+            self.data = self._initialization(self.batch_size, self.shuffle)
+            self._domain_index_num = 0
+        index = self._domain_index_num
+        self._domain_index_num += 1
+        return index
+
+    def _get_index_when_sample_all(self, index):
+        data_size = self.__len__()
+        if (self._random_merge or self.shuffle) and index % data_size == 0:
+            self._domain_index = np.random.permutation(self.data_size)
+        index = index % data_size if index >= data_size else index
+        return index
+
+    def __getitem__(self, index):
+        if not self.data:
+            self._initialization()
+        if self.sampling_config.random_sampling:
+            index = self._get_index_when_sample_iter(index)
+        else:
+            index = self._get_index_when_sample_all(index)
+
+        col_data = None
+        for i in range(len(self.columns_list)):
+            temp_data = self.data[i][self._domain_index[index]] if self.batch_size == 1 else \
+                        self.data[i][self._domain_index[index * self.batch_size : (index + 1) * self.batch_size]]
+            col_data = (temp_data,) if col_data is None else col_data + (temp_data,)
+        return col_data
+
+    def __len__(self):
+        if not self.data:
+            self._initialization()
+        return self.batched_data_size
diff --git a/mindscience/data/flow/data/existed_data.py b/mindscience/data/flow/data/existed_data.py
new file mode 100644
index 000000000..08d659219
--- /dev/null
+++ b/mindscience/data/flow/data/existed_data.py
@@ -0,0 +1,153 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#pylint: disable=W0223
+#pylint: disable=W0221
+"""
+This dataset module supports npy type of datasets. Some of the operations that are
+provided to users to preprocess data include shuffle, batch, repeat, map, and zip.
+"""
+from __future__ import absolute_import
+
+import numpy as np
+from mindspore import log as logger
+
+from .data_base import Data, ExistedDataConfig
+from ....utils.check_func import check_param_type
+
+
+class ExistedDataset(Data):
+    r"""
+    Creates a dataset with given data path.
+
+    Note:
+        The ``'npy'`` data format is supported now.
+
+    Parameters:
+        name (str, optional): specifies the name of dataset. Default: ``None``. If `data_config` is ``None``,
+            the `name` should not be ``None``.
+        data_dir (Union[str, list, tuple], optional): the path of existed data files. Default: ``None``.
+            If `data_config` is ``None``, the `data_dir` should not be ``None``.
+        columns_list (Union[str, list, tuple], optional): list of column names of the dataset. Default: ``None``. If
+            `data_config` is ``None``, the `columns_list` should not be ``None``.
+        data_format (str, optional): the format of existed data files. Default: ``'npy'``.
+        constraint_type (str, optional): specifies the constraint type of the created dataset. Default: "Label".
+        random_merge (bool, optional): specifies whether randomly merge the given datasets. Default: ``True``.
+        data_config (ExistedDataConfig, optional): Instance of ExistedDataConfig which collect the info
+            described above. Default: ``None``. If it's not ``None``, the dataset class will be create by
+            using it for simplifying. If it's ``None``, the info of (name, data_dir, columns_list, data_format,
+            constraint_type, random_merge) will be used for replacement.
+
+    Raises:
+        ValueError: Argument `name`/`data_dir`/`columns_list` is ``None`` when `data_config` is ``None``.
+        TypeError: If data_config is not a instance of ExistedDataConfig.
+        ValueError: If data_format is not ``'npy'``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.data import ExistedDataConfig, ExistedDataset
+        >>> data_config = ExistedDataConfig(name='exist',
+        ...                                 data_dir=['./data.npy'],
+        ...                                 columns_list=['input_data'], data_format="npy", constraint_type="Equation")
+        >>> dataset = ExistedDataset(data_config=data_config)
+    """
+    def __init__(self,
+                 name=None,
+                 data_dir=None,
+                 columns_list=None,
+                 data_format='npy',
+                 constraint_type="Label",
+                 random_merge=True,
+                 data_config=None):
+        if not data_config:
+            if not name or not data_dir or not columns_list:
+                raise ValueError("If data_config is None, argument: name, data_dir and columns_list should not be"
+                                 " None, but got name: {}, data_dir: {}, columns_list: {}"
+                                 .format(name, data_dir, columns_list))
+            data_config = ExistedDataConfig(name, data_dir, columns_list, data_format, constraint_type, random_merge)
+        check_param_type(data_config, "data_config", data_type=ExistedDataConfig)
+
+        name = data_config.name
+        columns_list = [name + "_" + column_name for column_name in data_config.columns_list]
+        constraint_type = data_config.constraint_type
+
+        self.data_dir = data_config.data_dir
+        self._data_format = data_config.data_format
+        self._random_merge = data_config.random_merge
+
+        self.data = None
+        self.data_size = None
+        self.batch_size = 1
+        self.shuffle = False
+        self.batched_data_size = None
+        self._index = None
+        self.load_data = {"npy": self._load_npy_data}
+
+        super(ExistedDataset, self).__init__(name, columns_list, constraint_type)
+
+    def _initialization(self, batch_size=1, shuffle=False):
+        """load datasets from given paths"""
+        data = self.load_data.get(self._data_format.lower())()
+        if not isinstance(data, tuple):
+            data = (data,)
+        self.data = data
+        self.data_size = len(data[0])
+        self.batch_size = batch_size
+        if batch_size > self.data_size:
+            raise ValueError("If prebatch data, batch_size: {} should not be larger than data size: {}.".format(
+                batch_size, self.data_size
+            ))
+        self.batched_data_size = self.data_size // batch_size
+        self.shuffle = shuffle
+        self._index = np.arange(self.data_size)
+        logger.info("Get existed dataset: {}, columns: {}, size: {}, batched_size: {}, shuffle: {}".format(
+            self.name, self.columns_list, self.data_size, self.batched_data_size, self.shuffle))
+        return data
+
+    def __getitem__(self, index):
+        if not self.data:
+            self._initialization()
+        if self._random_merge:
+            index = np.random.randint(0, self.batched_data_size) if index >= self.batched_data_size else index
+        else:
+            index = index % self.batched_data_size if index >= self.batched_data_size else index
+
+        if self.shuffle and index % self.batched_data_size == 0:
+            self._index = np.random.permutation(self.data_size)
+
+        col_data = None
+        for i in range(len(self.columns_list)):
+            temp_data = self.data[i][self._index[index]] if self.batch_size == 1 else \
+                        self.data[i][self._index[index * self.batch_size : (index + 1) * self.batch_size]]
+            col_data = (temp_data,) if col_data is None else col_data + (temp_data,)
+        return col_data
+
+    def _load_npy_data(self):
+        """
+        Load npy-type data from exited file. For every column the data shape should be 2D, i.e. (batch_size, dim)
+        """
+        data = tuple()
+        for path in self.data_dir:
+            logger.info("Read data from file: {}".format(path))
+            data_tmp = np.load(path)
+            data += (data_tmp.astype(np.float32),)
+        logger.info("Load npy data size: {}".format(len(data[0])))
+        return data
+
+    def __len__(self):
+        if not self.data:
+            self._initialization()
+        return self.batched_data_size
diff --git a/mindscience/data/flow/data/mind_dataset.py b/mindscience/data/flow/data/mind_dataset.py
new file mode 100644
index 000000000..043b8f2ca
--- /dev/null
+++ b/mindscience/data/flow/data/mind_dataset.py
@@ -0,0 +1,242 @@
+# Copyright 2021 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+#pylint: disable=W0223
+#pylint: disable=W0221
+#pylint: disable=W0212
+"""
+Combine pde/ic/bc datasets together
+"""
+from __future__ import absolute_import
+
+import mindspore.dataset as ds
+from mindspore import log as logger
+
+from .data_base import Data, CONSTRAINT_TYPES
+from ....utils.check_func import check_param_type, check_param_value, check_dict_type, check_dict_type_value
+
+
+class MindDataset(Data):
+    """
+    Create dataset from MindRecord-type data.
+
+    Args:
+        dataset_files (Union[str, list[str]]): If `dataset_file` is a str, it represents for
+            a file name of one component of a mindrecord source, other files with identical source
+            in the same path will be found and loaded automatically. If `dataset_file` is a list,
+            it represents for a list of dataset files to be read directly.
+        dataset_name (str, optional): name of dataset. Default: ``"dataset_name"``.
+        constraint_type (str, optional): constraint type of the specified dataset to get it's corresponding loss
+            function. Default: ``"Label"``. Other supported types can be found in `mindflow.data.Dataset`.
+        shuffle (Union[bool, Shuffle level], optional): Perform reshuffling of the data every epoch
+            If `shuffle` is ``False``, no shuffling will be performed.
+            If `shuffle` is ``True``, performs global shuffle. Default: ``True``.
+            Otherwise, there are two levels of shuffling:
+
+            - ``Shuffle.GLOBAL``: Shuffle both the files and sample.
+            - ``Shuffle.FILES``: Shuffle files only.
+
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: ``None``.
+            When this argument is specified, 'num_samples' reflects the maximum sample number of per shard.
+        shard_id (int, optional): The shard ID within `num_shards`. Default: ``None``. This
+            argument can only be specified when `num_shards` is also specified.
+        sampler (Sampler, optional): Object used to choose samples from the
+            dataset. Default: ``None``, sampler is exclusive
+            with shuffle and block_reader. Support list: ``SubsetRandomSampler``,
+            ``PkSampler``, ``RandomSampler``, ``SequentialSampler``, ``DistributedSampler``.
+        num_samples (int, optional): The number of samples to be included in the dataset. Default: ``None``,
+            all samples.
+        num_parallel_workers (int, optional): The number of readers. Default: ``None``.
+
+    Raises:
+        ValueError: If `dataset_files` are not valid or do not exist.
+        TypeError: If `dataset_name` is not string.
+        ValueError: If `constraint_type.lower()` not in [``"equation"``, ``"bc"``, ``"ic"``, ``"label"``,
+            ``"function"``, ``"custom"``].
+        RuntimeError: If `num_shards` is specified but `shard_id` is ``None``.
+        RuntimeError: If `shard_id` is specified but `num_shards` is ``None``.
+        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> from mindflow.data import MindDataset
+        >>> dataset_files = ["./data_dir"] # contains 1 or multiple MindRecord files
+        >>> dataset = MindDataset(dataset_files=dataset_files)
+    """
+    def __init__(self, dataset_files, dataset_name="dataset", constraint_type="Label", shuffle=True,
+                 num_shards=None, shard_id=None, sampler=None, num_samples=None, num_parallel_workers=None):
+        super(MindDataset, self).__init__()
+        check_param_type(dataset_name, "dataset_name", data_type=str)
+        check_param_type(constraint_type, "constraint_type", data_type=str)
+        check_param_value(constraint_type.lower(), "constraint_type", CONSTRAINT_TYPES)
+        self.mind_dataset = ds.MindDataset(dataset_files,
+                                           num_parallel_workers=num_parallel_workers,
+                                           shuffle=shuffle,
+                                           num_shards=num_shards,
+                                           shard_id=shard_id,
+                                           sampler=sampler,
+                                           num_samples=num_samples)
+        self.columns_list = self.mind_dataset.get_col_names()
+        logger.info("Get MindRecord dataset with columns: {}".format(self.columns_list))
+        self.dataset_columns_map = {dataset_name: self.columns_list}
+        for i in range(len(self.columns_list)):
+            self.column_index_map[self.columns_list[i]] = i
+        self.dataset_constraint_map = {dataset_name: constraint_type}
+        self.dataset_name = [dataset_name]
+
+    def split_dataset(self, dataset_dict, constraint_dict=None):
+        """split the original dataset in order to set difference loss functions.
+
+        Args:
+            dataset_dict (dict): dictionary of each sub-dataset, the key is the labeled name while the value
+                refers to the specified columns contained in the sub-dataset.
+            constraint_dict (Union[None, str, dict]): The constraint type of specified dataset. If ``None``,
+                "Label" will be set for all. If is string, all will be set to the same one. If is dict,
+                the subdataset and it's constraint type is specified by the pair (key, value). Default: ``None``.
+
+        Examples:
+            >>> dataset.split_dataset({"Equation" : "inner_points", "BC" : "bc_points"})
+        """
+        check_dict_type_value(dataset_dict, "sub-dataset dict", key_type=str, value_type=str,
+                              value_value=self.columns_list)
+        if constraint_dict:
+            check_dict_type(constraint_dict, "sub-constraint dict", key_type=str, value_type=str)
+            for key, value in constraint_dict.items():
+                if value.lower() not in CONSTRAINT_TYPES:
+                    raise ValueError("constraint type for dataset {} should be in {}, but got {}".format(
+                        key, CONSTRAINT_TYPES, value))
+            if dataset_dict.keys() != constraint_dict.keys():
+                raise ValueError("The sub-dataset name should be consistent, but got dataset_dict: {},"
+                                 "while constraint_dict: {}".format(dataset_dict.keys(), constraint_dict.keys()))
+
+        self.dataset_columns_map = dataset_dict
+        if constraint_dict:
+            self.dataset_constraint_map = constraint_dict
+        else:
+            self.dataset_columns_map.clear()
+            for sub_data in self.dataset_columns_map.keys():
+                self.dataset_constraint_map[sub_data] = "Label"
+        self.dataset_name = list(dataset_dict.keys())
+
+    def set_constraint_type(self, constraint_type="Equation"):
+        """set constraint type of dataset
+
+        Args:
+            constraint_type (Union[str, dict]): The constraint type of specified dataset. If is string, the constraint
+                type of all subdataset will be set to the same one. If is dict, the subdataset and it's constraint type
+                is specified by the pair (key, value).
+
+        Examples:
+            >>> dataset.set_constraint_type("Equation")
+        """
+        check_param_type(constraint_type, "constraint_type", data_type=(str, dict))
+        if isinstance(constraint_type, str):
+            check_param_value(constraint_type.lower(), "constraint_type", CONSTRAINT_TYPES)
+            for dataset in self.dataset_name:
+                self.dataset_constraint_map[dataset] = constraint_type
+        else:
+            for dataset in self.dataset_name:
+                if dataset not in constraint_type:
+                    raise ValueError("constraint type of dataset {} was not defined in constraint_type {}".format(
+                        dataset, constraint_type))
+                self.dataset_columns_map[dataset] = constraint_type[dataset]
+
+    def create_dataset(self,
+                       batch_size=1,
+                       preprocess_fn=None,
+                       updated_columns_list=None,
+                       drop_remainder=True,
+                       prebatched_data=False,
+                       num_parallel_workers=1,
+                       python_multiprocessing=False):
+        """
+        create the final mindspore type dataset.
+
+        Args:
+            batch_size (int, optional): An int number of rows each batch is created with. Default: ``1``.
+            preprocess_fn (Union[list[TensorOp], list[functions]], optional): List of operations to be
+                applied on the dataset. Operations are applied in the order they appear in this list.
+                Default: ``None``.
+            updated_columns_list (list, optional): List of columns to be applied on the dataset.
+                Default: ``None``.
+            drop_remainder (bool, optional): Determines whether or not to drop the last block
+                whose data row number is less than batch size. If ``True``, and if there are less
+                than batch_size rows available to make the last batch, then those rows will
+                be dropped and not propagated to the child node. Default: ``True``.
+            prebatched_data (bool, optional): Generate pre-batched data before data preprocessing.
+                Default: ``False``.
+            num_parallel_workers (int, optional): Number of workers(threads) to process the dataset in parallel.
+                Default: 1.
+            python_multiprocessing (bool, optional): Parallelize Python function per_batch_map with multi-processing.
+                This option could be beneficial if the function is computational heavy.
+                Default: ``False``.
+
+        Returns:
+            BatchDataset, dataset batched.
+
+        Examples:
+            >>> data = dataset.create_dataset()
+        """
+        check_param_type(prebatched_data, "prebatched_data", data_type=bool)
+        check_param_type(drop_remainder, "drop_remainder", data_type=bool)
+        check_param_type(batch_size, "batch_size", data_type=int, exclude_type=bool)
+
+        dataset = self.mind_dataset
+        if prebatched_data:
+            dataset = dataset.batch(batch_size=batch_size,
+                                    drop_remainder=drop_remainder,
+                                    num_parallel_workers=num_parallel_workers)
+
+        if preprocess_fn:
+            dataset = dataset.map(operations=preprocess_fn,
+                                  input_columns=self.columns_list,
+                                  output_columns=updated_columns_list,
+                                  column_order=updated_columns_list,
+                                  num_parallel_workers=num_parallel_workers,
+                                  python_multiprocessing=python_multiprocessing)
+            if updated_columns_list:
+                self.columns_list = updated_columns_list
+                dataset_name = "data"
+                self.dataset_columns_map = {dataset_name: self.columns_list}
+                for i in range(len(self.columns_list)):
+                    self.column_index_map[self.columns_list[i]] = i
+
+        if not prebatched_data:
+            dataset = dataset.batch(batch_size=batch_size,
+                                    drop_remainder=drop_remainder,
+                                    num_parallel_workers=num_parallel_workers)
+        logger.info("Final dataset size: {}".format(dataset.get_dataset_size()))
+        logger.info("Dataset columns map after preprocess: {}".format(self.dataset_columns_map))
+        logger.info("Dataset column index after preprocess: {}".format(self.column_index_map))
+        logger.info("Dataset constraints after preprocess: {}".format(self.dataset_constraint_map))
+        return dataset
+
+    def get_columns_list(self):
+        """get columns list
+
+        Returns:
+            list[str]. column names list of the final unified dataset.
+
+        Examples:
+            >>> columns_list = dataset.get_columns_list()
+        """
+        return self.columns_list
+
+    def __getitem__(self, index):
+        return list(self.mind_dataset.create_tuple_iterator())[index]
+
+    def __len__(self):
+        return self.mind_dataset.get_dataset_size()
-- 
Gitee


From 9df1ba3d88763cf70051626c8c8484c2d9be0174 Mon Sep 17 00:00:00 2001
From: brian <guoboqiang@huawei.com>
Date: Mon, 15 Sep 2025 19:59:44 +0800
Subject: [PATCH 2/5] fix

---
 MindFlow/applications/burgers1d/README.md          | 2 +-
 MindFlow/applications/burgers1d/README_CN.md       | 2 +-
 MindFlow/applications/burgers1d/burgers1D.ipynb    | 2 +-
 MindFlow/applications/burgers1d/burgers1D_CN.ipynb | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/MindFlow/applications/burgers1d/README.md b/MindFlow/applications/burgers1d/README.md
index b44ce7d55..606018925 100644
--- a/MindFlow/applications/burgers1d/README.md
+++ b/MindFlow/applications/burgers1d/README.md
@@ -4,7 +4,7 @@ ENGLISH | [简体中文](README_CN.md)
 
 ## Overview
 
-Burgers' equation is a nonlinear partial differential equation that simulates the propagation and reflection of shock waves. It is widely used in the fields of fluid mechanics, nonlinear acoustics, gas dynamics et al. It is named after Johannes Martins Hamburg (1895-1981). In this case, MindFlow fluid simulation suite is used to solve the Burgers' equation in one-dimensional viscous state based on the physical-driven PINNs (Physics Informed Neural Networks) method.
+Burgers equation is a nonlinear partial differential equation that simulates the propagation and reflection of shock waves. It is widely used in the fields of fluid mechanics, nonlinear acoustics, gas dynamics et al. It is named after Johannes Martins Hamburg (1895-1981). In this case, MindFlow fluid simulation suite is used to solve the Burgers equation in one-dimensional viscous state based on the physical-driven PINNs (Physics Informed Neural Networks) method.
 
 ## QuickStart
 
diff --git a/MindFlow/applications/burgers1d/README_CN.md b/MindFlow/applications/burgers1d/README_CN.md
index 663c8844d..26b568bc8 100644
--- a/MindFlow/applications/burgers1d/README_CN.md
+++ b/MindFlow/applications/burgers1d/README_CN.md
@@ -4,7 +4,7 @@
 
 ## 概述
 
-伯格斯方程（Burgers' equation）是一个模拟冲击波的传播和反射的非线性偏微分方程，被广泛应用于流体力学，非线性声学，气体动力学等领域，它以约翰内斯·马丁斯汉堡（1895-1981）的名字命名。本案例采用MindFlow流体仿真套件，基于物理驱动的PINNs (Physics Informed Neural Networks)方法，求解一维有粘性情况下的Burgers方程。
+伯格斯方程（Burgers equation）是一个模拟冲击波的传播和反射的非线性偏微分方程，被广泛应用于流体力学，非线性声学，气体动力学等领域，它以约翰内斯·马丁斯汉堡（1895-1981）的名字命名。本案例采用MindFlow流体仿真套件，基于物理驱动的PINNs (Physics Informed Neural Networks)方法，求解一维有粘性情况下的Burgers方程。
 
 ## 快速开始
 
diff --git a/MindFlow/applications/burgers1d/burgers1D.ipynb b/MindFlow/applications/burgers1d/burgers1D.ipynb
index 3683fc6c3..2485235c8 100644
--- a/MindFlow/applications/burgers1d/burgers1D.ipynb
+++ b/MindFlow/applications/burgers1d/burgers1D.ipynb
@@ -36,7 +36,7 @@
                 "\n",
                 "In recent years, while the development of classical theories and numerical methods with computer performance tends to be smooth, machine learning methods combine a large amount of data with neural networks realize the flow field's fast simulation. These methods can obtain the accuracy close to the traditional methods, which provides a new idea for flow field solution.\n",
                 "\n",
-                "Burgers' equation is a nonlinear partial differential equation that simulates the propagation and reflection of shock waves. It is widely used in the fields of fluid mechanics, nonlinear acoustics, gas dynamics et al. It is named after Johannes Martins Hamburg (1895-1981). In this case, MindFlow fluid simulation suite is used to solve the Burgers' equation in one-dimensional viscous state based on the physical-driven PINNs (Physics Informed Neural Networks) method."
+                "Burgers equation is a nonlinear partial differential equation that simulates the propagation and reflection of shock waves. It is widely used in the fields of fluid mechanics, nonlinear acoustics, gas dynamics et al. It is named after Johannes Martins Hamburg (1895-1981). In this case, MindFlow fluid simulation suite is used to solve the Burgers' equation in one-dimensional viscous state based on the physical-driven PINNs (Physics Informed Neural Networks) method."
             ]
         },
         {
diff --git a/MindFlow/applications/burgers1d/burgers1D_CN.ipynb b/MindFlow/applications/burgers1d/burgers1D_CN.ipynb
index 48dd04676..51d18e4fe 100644
--- a/MindFlow/applications/burgers1d/burgers1D_CN.ipynb
+++ b/MindFlow/applications/burgers1d/burgers1D_CN.ipynb
@@ -38,7 +38,7 @@
                 "\n",
                 "在经典理论与结合计算机性能的数值求解方法的发展趋于平缓的时候，近年来机器学习方法通过神经网络结合大量数据，实现流场的快速仿真，获得了接近传统方法的求解精度，为流场求解提供了新思路。\n",
                 "\n",
-                "伯格斯方程（Burgers' equation）是一个模拟冲击波的传播和反射的非线性偏微分方程，被广泛应用于流体力学，非线性声学，气体动力学等领域，它以约翰内斯·马丁斯汉堡（1895-1981）的名字命名。本案例采用MindFlow流体仿真套件，基于物理驱动的PINNs (Physics Informed Neural Networks)方法，求解一维有粘性情况下的Burgers方程。"
+                "伯格斯方程（Burgers equation）是一个模拟冲击波的传播和反射的非线性偏微分方程，被广泛应用于流体力学，非线性声学，气体动力学等领域，它以约翰内斯·马丁斯汉堡（1895-1981）的名字命名。本案例采用MindFlow流体仿真套件，基于物理驱动的PINNs (Physics Informed Neural Networks)方法，求解一维有粘性情况下的Burgers方程。"
             ]
         },
         {
-- 
Gitee


From bb285a4bdabc7aa21aeffce492b7571f06cb1514 Mon Sep 17 00:00:00 2001
From: brian <guoboqiang@huawei.com>
Date: Mon, 15 Sep 2025 20:08:32 +0800
Subject: [PATCH 3/5] fuck codespell

---
 .jenkins/rules/codespell/codespell.allow | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.jenkins/rules/codespell/codespell.allow b/.jenkins/rules/codespell/codespell.allow
index 0aaa17dec..c302dcbdd 100644
--- a/.jenkins/rules/codespell/codespell.allow
+++ b/.jenkins/rules/codespell/codespell.allow
@@ -4,3 +4,4 @@ labled
 conect
 pertubated
 quater
+Burgers
-- 
Gitee


From 94d15c51f225e0fcf7a5ae511adbfe579efcdf6c Mon Sep 17 00:00:00 2001
From: brian <guoboqiang@huawei.com>
Date: Mon, 15 Sep 2025 20:18:12 +0800
Subject: [PATCH 4/5] ddd

---
 .jenkins/rules/codespell/codespell.allow | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.jenkins/rules/codespell/codespell.allow b/.jenkins/rules/codespell/codespell.allow
index c302dcbdd..0461d424d 100644
--- a/.jenkins/rules/codespell/codespell.allow
+++ b/.jenkins/rules/codespell/codespell.allow
@@ -4,4 +4,4 @@ labled
 conect
 pertubated
 quater
-Burgers
+Hamburg
-- 
Gitee


From edeb428f3c56d7cb5ff5e2a55f8b2724a4507c38 Mon Sep 17 00:00:00 2001
From: brian <guoboqiang@huawei.com>
Date: Mon, 15 Sep 2025 20:34:42 +0800
Subject: [PATCH 5/5] rename mindscience.data.pde

---
 MindFlow/applications/burgers1d/src/dataset.py             | 2 +-
 mindscience/data/{flow => pde}/__init__.py                 | 2 ++
 mindscience/data/{flow => pde}/data/__init__.py            | 0
 mindscience/data/{flow => pde}/data/boundary.py            | 0
 mindscience/data/{flow => pde}/data/data_base.py           | 0
 mindscience/data/{flow => pde}/data/dataset.py             | 0
 mindscience/data/{flow => pde}/data/equation.py            | 0
 mindscience/data/{flow => pde}/data/existed_data.py        | 0
 mindscience/data/{flow => pde}/data/mind_dataset.py        | 0
 mindscience/data/{flow => pde}/geometry/__init__.py        | 0
 mindscience/data/{flow => pde}/geometry/csg.py             | 0
 mindscience/data/{flow => pde}/geometry/geom_utils.py      | 0
 mindscience/data/{flow => pde}/geometry/geometry_1d.py     | 0
 mindscience/data/{flow => pde}/geometry/geometry_2d.py     | 0
 mindscience/data/{flow => pde}/geometry/geometry_3d.py     | 0
 mindscience/data/{flow => pde}/geometry/geometry_base.py   | 0
 mindscience/data/{flow => pde}/geometry/geometry_nd.py     | 0
 mindscience/data/{flow => pde}/geometry/geometry_td.py     | 0
 mindscience/data/{flow => pde}/geometry/shapes/__init__.py | 0
 mindscience/data/{flow => pde}/geometry/shapes/adapter.py  | 0
 mindscience/data/{flow => pde}/geometry/shapes/pentagon.py | 0
 mindscience/data/{flow => pde}/geometry/shapes/polygon.py  | 0
 mindscience/data/{flow => pde}/geometry/shapes/rotating.py | 0
 mindscience/data/{flow => pde}/geometry/shapes/shapes.py   | 0
 mindscience/data/{flow => pde}/geometry/shapes/simplex.py  | 0
 25 files changed, 3 insertions(+), 1 deletion(-)
 rename mindscience/data/{flow => pde}/__init__.py (93%)
 rename mindscience/data/{flow => pde}/data/__init__.py (100%)
 rename mindscience/data/{flow => pde}/data/boundary.py (100%)
 rename mindscience/data/{flow => pde}/data/data_base.py (100%)
 rename mindscience/data/{flow => pde}/data/dataset.py (100%)
 rename mindscience/data/{flow => pde}/data/equation.py (100%)
 rename mindscience/data/{flow => pde}/data/existed_data.py (100%)
 rename mindscience/data/{flow => pde}/data/mind_dataset.py (100%)
 rename mindscience/data/{flow => pde}/geometry/__init__.py (100%)
 rename mindscience/data/{flow => pde}/geometry/csg.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geom_utils.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geometry_1d.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geometry_2d.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geometry_3d.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geometry_base.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geometry_nd.py (100%)
 rename mindscience/data/{flow => pde}/geometry/geometry_td.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/__init__.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/adapter.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/pentagon.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/polygon.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/rotating.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/shapes.py (100%)
 rename mindscience/data/{flow => pde}/geometry/shapes/simplex.py (100%)

diff --git a/MindFlow/applications/burgers1d/src/dataset.py b/MindFlow/applications/burgers1d/src/dataset.py
index 11e1af9b9..498757874 100644
--- a/MindFlow/applications/burgers1d/src/dataset.py
+++ b/MindFlow/applications/burgers1d/src/dataset.py
@@ -19,7 +19,7 @@ import numpy as np
 from mindspore import Tensor
 from mindspore import dtype as mstype
 
-from mindscience.data.flow import Dataset, Interval, TimeDomain, GeometryWithTime, generate_sampling_config
+from mindscience.data.pde import Dataset, Interval, TimeDomain, GeometryWithTime, generate_sampling_config
 
 
 def create_training_dataset(config):
diff --git a/mindscience/data/flow/__init__.py b/mindscience/data/pde/__init__.py
similarity index 93%
rename from mindscience/data/flow/__init__.py
rename to mindscience/data/pde/__init__.py
index 63f887bac..9328357ee 100644
--- a/mindscience/data/flow/__init__.py
+++ b/mindscience/data/pde/__init__.py
@@ -16,6 +16,8 @@
 init
 """
 from .geometry import *
+from .data import *
 
 __all__ = []
+__all__.extend(data.__all__)
 __all__.extend(geometry.__all__)
\ No newline at end of file
diff --git a/mindscience/data/flow/data/__init__.py b/mindscience/data/pde/data/__init__.py
similarity index 100%
rename from mindscience/data/flow/data/__init__.py
rename to mindscience/data/pde/data/__init__.py
diff --git a/mindscience/data/flow/data/boundary.py b/mindscience/data/pde/data/boundary.py
similarity index 100%
rename from mindscience/data/flow/data/boundary.py
rename to mindscience/data/pde/data/boundary.py
diff --git a/mindscience/data/flow/data/data_base.py b/mindscience/data/pde/data/data_base.py
similarity index 100%
rename from mindscience/data/flow/data/data_base.py
rename to mindscience/data/pde/data/data_base.py
diff --git a/mindscience/data/flow/data/dataset.py b/mindscience/data/pde/data/dataset.py
similarity index 100%
rename from mindscience/data/flow/data/dataset.py
rename to mindscience/data/pde/data/dataset.py
diff --git a/mindscience/data/flow/data/equation.py b/mindscience/data/pde/data/equation.py
similarity index 100%
rename from mindscience/data/flow/data/equation.py
rename to mindscience/data/pde/data/equation.py
diff --git a/mindscience/data/flow/data/existed_data.py b/mindscience/data/pde/data/existed_data.py
similarity index 100%
rename from mindscience/data/flow/data/existed_data.py
rename to mindscience/data/pde/data/existed_data.py
diff --git a/mindscience/data/flow/data/mind_dataset.py b/mindscience/data/pde/data/mind_dataset.py
similarity index 100%
rename from mindscience/data/flow/data/mind_dataset.py
rename to mindscience/data/pde/data/mind_dataset.py
diff --git a/mindscience/data/flow/geometry/__init__.py b/mindscience/data/pde/geometry/__init__.py
similarity index 100%
rename from mindscience/data/flow/geometry/__init__.py
rename to mindscience/data/pde/geometry/__init__.py
diff --git a/mindscience/data/flow/geometry/csg.py b/mindscience/data/pde/geometry/csg.py
similarity index 100%
rename from mindscience/data/flow/geometry/csg.py
rename to mindscience/data/pde/geometry/csg.py
diff --git a/mindscience/data/flow/geometry/geom_utils.py b/mindscience/data/pde/geometry/geom_utils.py
similarity index 100%
rename from mindscience/data/flow/geometry/geom_utils.py
rename to mindscience/data/pde/geometry/geom_utils.py
diff --git a/mindscience/data/flow/geometry/geometry_1d.py b/mindscience/data/pde/geometry/geometry_1d.py
similarity index 100%
rename from mindscience/data/flow/geometry/geometry_1d.py
rename to mindscience/data/pde/geometry/geometry_1d.py
diff --git a/mindscience/data/flow/geometry/geometry_2d.py b/mindscience/data/pde/geometry/geometry_2d.py
similarity index 100%
rename from mindscience/data/flow/geometry/geometry_2d.py
rename to mindscience/data/pde/geometry/geometry_2d.py
diff --git a/mindscience/data/flow/geometry/geometry_3d.py b/mindscience/data/pde/geometry/geometry_3d.py
similarity index 100%
rename from mindscience/data/flow/geometry/geometry_3d.py
rename to mindscience/data/pde/geometry/geometry_3d.py
diff --git a/mindscience/data/flow/geometry/geometry_base.py b/mindscience/data/pde/geometry/geometry_base.py
similarity index 100%
rename from mindscience/data/flow/geometry/geometry_base.py
rename to mindscience/data/pde/geometry/geometry_base.py
diff --git a/mindscience/data/flow/geometry/geometry_nd.py b/mindscience/data/pde/geometry/geometry_nd.py
similarity index 100%
rename from mindscience/data/flow/geometry/geometry_nd.py
rename to mindscience/data/pde/geometry/geometry_nd.py
diff --git a/mindscience/data/flow/geometry/geometry_td.py b/mindscience/data/pde/geometry/geometry_td.py
similarity index 100%
rename from mindscience/data/flow/geometry/geometry_td.py
rename to mindscience/data/pde/geometry/geometry_td.py
diff --git a/mindscience/data/flow/geometry/shapes/__init__.py b/mindscience/data/pde/geometry/shapes/__init__.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/__init__.py
rename to mindscience/data/pde/geometry/shapes/__init__.py
diff --git a/mindscience/data/flow/geometry/shapes/adapter.py b/mindscience/data/pde/geometry/shapes/adapter.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/adapter.py
rename to mindscience/data/pde/geometry/shapes/adapter.py
diff --git a/mindscience/data/flow/geometry/shapes/pentagon.py b/mindscience/data/pde/geometry/shapes/pentagon.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/pentagon.py
rename to mindscience/data/pde/geometry/shapes/pentagon.py
diff --git a/mindscience/data/flow/geometry/shapes/polygon.py b/mindscience/data/pde/geometry/shapes/polygon.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/polygon.py
rename to mindscience/data/pde/geometry/shapes/polygon.py
diff --git a/mindscience/data/flow/geometry/shapes/rotating.py b/mindscience/data/pde/geometry/shapes/rotating.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/rotating.py
rename to mindscience/data/pde/geometry/shapes/rotating.py
diff --git a/mindscience/data/flow/geometry/shapes/shapes.py b/mindscience/data/pde/geometry/shapes/shapes.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/shapes.py
rename to mindscience/data/pde/geometry/shapes/shapes.py
diff --git a/mindscience/data/flow/geometry/shapes/simplex.py b/mindscience/data/pde/geometry/shapes/simplex.py
similarity index 100%
rename from mindscience/data/flow/geometry/shapes/simplex.py
rename to mindscience/data/pde/geometry/shapes/simplex.py
-- 
Gitee