diff --git a/.github/workflows/basic_test.yml b/.github/workflows/basic_test.yml
index fce0977..9180687 100644
--- a/.github/workflows/basic_test.yml
+++ b/.github/workflows/basic_test.yml
@@ -56,5 +56,5 @@ jobs:
           python -m pip install parameterized
           python -m pip install torch torchvision
           python --version
-          python -m pytest ./tests/test_synthetic.py -s
+          python -m pytest ./tests/test_synthetic*.py -s
         shell: bash
diff --git a/.latent-data/NATS-Bench b/.latent-data/NATS-Bench
index f955e2b..47de7e1 160000
--- a/.latent-data/NATS-Bench
+++ b/.latent-data/NATS-Bench
@@ -1 +1 @@
-Subproject commit f955e2ba13ae92ce5af6d28bb47d58eb6d5be249
+Subproject commit 47de7e1508536512ece82e0add082e0547cc7996
diff --git a/lib/datasets/__init__.py b/lib/datasets/__init__.py
index 07106cd..3b5800b 100644
--- a/lib/datasets/__init__.py
+++ b/lib/datasets/__init__.py
@@ -4,5 +4,7 @@
 from .get_dataset_with_transform import get_datasets, get_nas_search_loaders
 from .SearchDatasetWrap import SearchDataset
 
-from .synthetic_adaptive_environment import QuadraticFunc, CubicFunc, QuarticFunc
-from .synthetic_adaptive_environment import SynAdaptiveEnv
+from .math_base_funcs import QuadraticFunc, CubicFunc, QuarticFunc
+from .math_base_funcs import DynamicQuadraticFunc
+from .synthetic_utils import SinGenerator, ConstantGenerator
+from .synthetic_env import SyntheticDEnv
diff --git a/lib/datasets/synthetic_adaptive_environment.py b/lib/datasets/math_base_funcs.py
similarity index 63%
rename from lib/datasets/synthetic_adaptive_environment.py
rename to lib/datasets/math_base_funcs.py
index 01dbfe0..ef78302 100644
--- a/lib/datasets/synthetic_adaptive_environment.py
+++ b/lib/datasets/math_base_funcs.py
@@ -176,93 +176,31 @@ class QuarticFunc(FitFunc):
         )
 
 
-class SynAdaptiveEnv(data.Dataset):
-    """The synethtic dataset for adaptive environment.
+class DynamicQuadraticFunc(FitFunc):
+    """The dynamic quadratic function that outputs f(x) = a * x^2 + b * x + c."""
 
-    - x in [0, 1]
-    - y = amplitude-scale-of(x) * sin( period-phase-shift-of(x) )
-    - where
-    - the amplitude scale is a quadratic function of x
-    - the period-phase-shift is another quadratic function of x
+    def __init__(self, list_of_points=None):
+        super(DynamicQuadraticFunc, self).__init__(3, list_of_points)
+        self._timestamp = None
 
-    """
-
-    def __init__(
-        self,
-        num: int = 100,
-        num_sin_phase: int = 7,
-        min_amplitude: float = 1,
-        max_amplitude: float = 4,
-        phase_shift: float = 0,
-        mode: Optional[str] = None,
-    ):
-        self._amplitude_scale = QuadraticFunc(
-            [(0, min_amplitude), (0.5, max_amplitude), (1, min_amplitude)]
+    def __getitem__(self, x):
+        self.check_valid()
+        return (
+            self._params[0][self._timestamp] * x * x
+            + self._params[1][self._timestamp] * x
+            + self._params[2][self._timestamp]
         )
 
-        self._num_sin_phase = num_sin_phase
-        self._interval = 1.0 / (float(num) - 1)
-        self._total_num = num
+    def _getitem(self, x, weights):
+        raise NotImplementedError
 
-        fitting_data = []
-        temp_max_scalar = 2 ** (num_sin_phase - 1)
-        for i in range(num_sin_phase):
-            value = (2 ** i) / temp_max_scalar
-            next_value = (2 ** (i + 1)) / temp_max_scalar
-            for _phase in (0, 0.25, 0.5, 0.75):
-                inter_value = value + (next_value - value) * _phase
-                fitting_data.append((inter_value, math.pi * (2 * i + _phase)))
-        self._period_phase_shift = QuarticFunc(fitting_data)
-
-        # Training Set 60%
-        num_of_train = int(self._total_num * 0.6)
-        # Validation Set 20%
-        num_of_valid = int(self._total_num * 0.2)
-        # Test Set 20%
-        num_of_set = self._total_num - num_of_train - num_of_valid
-        all_indexes = list(range(self._total_num))
-        if mode is None:
-            self._indexes = all_indexes
-        elif mode.lower() in ("train", "training"):
-            self._indexes = all_indexes[:num_of_train]
-        elif mode.lower() in ("valid", "validation"):
-            self._indexes = all_indexes[num_of_train : num_of_train + num_of_valid]
-        elif mode.lower() in ("test", "testing"):
-            self._indexes = all_indexes[num_of_train + num_of_valid :]
-        else:
-            raise ValueError("Unkonwn mode of {:}".format(mode))
-
-    def __iter__(self):
-        self._iter_num = 0
-        return self
-
-    def __next__(self):
-        if self._iter_num >= len(self):
-            raise StopIteration
-        self._iter_num += 1
-        return self.__getitem__(self._iter_num - 1)
-
-    def __getitem__(self, index):
-        assert 0 <= index < len(self), "{:} is not in [0, {:})".format(index, len(self))
-        index = self._indexes[index]
-        position = self._interval * index
-        value = self._amplitude_scale[position] * math.sin(
-            self._period_phase_shift[position]
-        )
-        return index, position, value
-
-    def __len__(self):
-        return len(self._indexes)
+    def set_timestamp(self, timestamp):
+        self._timestamp = timestamp
 
     def __repr__(self):
-        return (
-            "{name}({cur_num:}/{total} elements,\n"
-            "amplitude={amplitude},\n"
-            "period_phase_shift={period_phase_shift})".format(
-                name=self.__class__.__name__,
-                cur_num=self._total_num,
-                total=len(self),
-                amplitude=self._amplitude_scale,
-                period_phase_shift=self._period_phase_shift,
-            )
+        return "{name}(y = {a} * x^2 + {b} * x + {c})".format(
+            name=self.__class__.__name__,
+            a=self._params[0],
+            b=self._params[1],
+            c=self._params[2],
         )
diff --git a/lib/datasets/synthetic_env.py b/lib/datasets/synthetic_env.py
new file mode 100644
index 0000000..db396e4
--- /dev/null
+++ b/lib/datasets/synthetic_env.py
@@ -0,0 +1,81 @@
+#####################################################
+# Copyright (c) Xuanyi Dong [GitHub D-X-Y], 2021.04 #
+#####################################################
+import math
+import abc
+import numpy as np
+from typing import List, Optional
+import torch
+import torch.utils.data as data
+
+from .synthetic_utils import UnifiedSplit
+
+
+class SyntheticDEnv(UnifiedSplit, data.Dataset):
+    """The synethtic dynamic environment."""
+
+    def __init__(
+        self,
+        mean_generators: List[data.Dataset],
+        cov_generators: List[List[data.Dataset]],
+        num_per_task: int = 5000,
+        mode: Optional[str] = None,
+    ):
+        self._ndim = len(mean_generators)
+        assert self._ndim == len(
+            cov_generators
+        ), "length does not match {:} vs. {:}".format(self._ndim, len(cov_generators))
+        for cov_generator in cov_generators:
+            assert self._ndim == len(
+                cov_generator
+            ), "length does not match {:} vs. {:}".format(
+                self._ndim, len(cov_generator)
+            )
+        self._num_per_task = num_per_task
+        self._total_num = len(mean_generators[0])
+        for mean_generator in mean_generators:
+            assert self._total_num == len(mean_generator)
+        for cov_generator in cov_generators:
+            for cov_g in cov_generator:
+                assert self._total_num == len(cov_g)
+
+        self._mean_generators = mean_generators
+        self._cov_generators = cov_generators
+
+        UnifiedSplit.__init__(self, self._total_num, mode)
+
+    def __iter__(self):
+        self._iter_num = 0
+        return self
+
+    def __next__(self):
+        if self._iter_num >= len(self):
+            raise StopIteration
+        self._iter_num += 1
+        return self.__getitem__(self._iter_num - 1)
+
+    def __getitem__(self, index):
+        assert 0 <= index < len(self), "{:} is not in [0, {:})".format(index, len(self))
+        index = self._indexes[index]
+        mean_list = [generator[index][-1] for generator in self._mean_generators]
+        cov_matrix = [
+            [cov_gen[index][-1] for cov_gen in cov_generator]
+            for cov_generator in self._cov_generators
+        ]
+
+        dataset = np.random.multivariate_normal(
+            mean_list, cov_matrix, size=self._num_per_task
+        )
+        return index, torch.Tensor(dataset)
+
+    def __len__(self):
+        return len(self._indexes)
+
+    def __repr__(self):
+        return "{name}({cur_num:}/{total} elements, ndim={ndim}, num_per_task={num_per_task})".format(
+            name=self.__class__.__name__,
+            cur_num=len(self),
+            total=self._total_num,
+            ndim=self._ndim,
+            num_per_task=self._num_per_task,
+        )
diff --git a/lib/datasets/synthetic_utils.py b/lib/datasets/synthetic_utils.py
new file mode 100644
index 0000000..f1fdab8
--- /dev/null
+++ b/lib/datasets/synthetic_utils.py
@@ -0,0 +1,157 @@
+#####################################################
+# Copyright (c) Xuanyi Dong [GitHub D-X-Y], 2021.03 #
+#####################################################
+import math
+import abc
+import numpy as np
+from typing import Optional
+import torch
+import torch.utils.data as data
+
+from .math_base_funcs import QuadraticFunc, QuarticFunc
+
+
+class UnifiedSplit:
+    """A class to unify the split strategy."""
+
+    def __init__(self, total_num, mode):
+        # Training Set 60%
+        num_of_train = int(total_num * 0.6)
+        # Validation Set 20%
+        num_of_valid = int(total_num * 0.2)
+        # Test Set 20%
+        num_of_set = total_num - num_of_train - num_of_valid
+        all_indexes = list(range(total_num))
+        if mode is None:
+            self._indexes = all_indexes
+        elif mode.lower() in ("train", "training"):
+            self._indexes = all_indexes[:num_of_train]
+        elif mode.lower() in ("valid", "validation"):
+            self._indexes = all_indexes[num_of_train : num_of_train + num_of_valid]
+        elif mode.lower() in ("test", "testing"):
+            self._indexes = all_indexes[num_of_train + num_of_valid :]
+        else:
+            raise ValueError("Unkonwn mode of {:}".format(mode))
+        self._mode = mode
+
+    @property
+    def mode(self):
+        return self._mode
+
+
+class SinGenerator(UnifiedSplit, data.Dataset):
+    """The synethtic generator for the dynamically changing environment.
+
+    - x in [0, 1]
+    - y = amplitude-scale-of(x) * sin( period-phase-shift-of(x) )
+    - where
+    - the amplitude scale is a quadratic function of x
+    - the period-phase-shift is another quadratic function of x
+
+    """
+
+    def __init__(
+        self,
+        num: int = 100,
+        num_sin_phase: int = 7,
+        min_amplitude: float = 1,
+        max_amplitude: float = 4,
+        phase_shift: float = 0,
+        mode: Optional[str] = None,
+    ):
+        self._amplitude_scale = QuadraticFunc(
+            [(0, min_amplitude), (0.5, max_amplitude), (1, min_amplitude)]
+        )
+
+        self._num_sin_phase = num_sin_phase
+        self._interval = 1.0 / (float(num) - 1)
+        self._total_num = num
+
+        fitting_data = []
+        temp_max_scalar = 2 ** (num_sin_phase - 1)
+        for i in range(num_sin_phase):
+            value = (2 ** i) / temp_max_scalar
+            next_value = (2 ** (i + 1)) / temp_max_scalar
+            for _phase in (0, 0.25, 0.5, 0.75):
+                inter_value = value + (next_value - value) * _phase
+                fitting_data.append((inter_value, math.pi * (2 * i + _phase)))
+        self._period_phase_shift = QuarticFunc(fitting_data)
+        UnifiedSplit.__init__(self, self._total_num, mode)
+        self._transform = lambda x: x
+
+    def __iter__(self):
+        self._iter_num = 0
+        return self
+
+    def __next__(self):
+        if self._iter_num >= len(self):
+            raise StopIteration
+        self._iter_num += 1
+        return self.__getitem__(self._iter_num - 1)
+
+    def set_transform(self, transform):
+        self._transform = transform
+
+    def __getitem__(self, index):
+        assert 0 <= index < len(self), "{:} is not in [0, {:})".format(index, len(self))
+        index = self._indexes[index]
+        position = self._interval * index
+        value = self._amplitude_scale[position] * math.sin(
+            self._period_phase_shift[position]
+        )
+        return index, position, self._transform(value)
+
+    def __len__(self):
+        return len(self._indexes)
+
+    def __repr__(self):
+        return (
+            "{name}({cur_num:}/{total} elements,\n"
+            "amplitude={amplitude},\n"
+            "period_phase_shift={period_phase_shift})".format(
+                name=self.__class__.__name__,
+                cur_num=len(self),
+                total=self._total_num,
+                amplitude=self._amplitude_scale,
+                period_phase_shift=self._period_phase_shift,
+            )
+        )
+
+
+class ConstantGenerator(UnifiedSplit, data.Dataset):
+    """The constant generator."""
+
+    def __init__(
+        self,
+        num: int = 100,
+        constant: float = 0.1,
+        mode: Optional[str] = None,
+    ):
+        self._total_num = num
+        self._constant = constant
+        UnifiedSplit.__init__(self, self._total_num, mode)
+
+    def __iter__(self):
+        self._iter_num = 0
+        return self
+
+    def __next__(self):
+        if self._iter_num >= len(self):
+            raise StopIteration
+        self._iter_num += 1
+        return self.__getitem__(self._iter_num - 1)
+
+    def __getitem__(self, index):
+        assert 0 <= index < len(self), "{:} is not in [0, {:})".format(index, len(self))
+        index = self._indexes[index]
+        return index, index, self._constant
+
+    def __len__(self):
+        return len(self._indexes)
+
+    def __repr__(self):
+        return "{name}({cur_num:}/{total} elements)".format(
+            name=self.__class__.__name__,
+            cur_num=len(self),
+            total=self._total_num,
+        )
diff --git a/notebooks/TOT/synthetic-adaptive-env.ipynb b/notebooks/TOT/synthetic-adaptive-env.ipynb
deleted file mode 100644
index b1b140d..0000000
--- a/notebooks/TOT/synthetic-adaptive-env.ipynb
+++ /dev/null
@@ -1,121 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "filled-multiple",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The root path: /Users/xuanyidong/Desktop/AutoDL-Projects\n",
-      "The library path: /Users/xuanyidong/Desktop/AutoDL-Projects/lib\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os, sys\n",
-    "import torch\n",
-    "from pathlib import Path\n",
-    "import numpy as np\n",
-    "import matplotlib\n",
-    "from matplotlib import cm\n",
-    "# matplotlib.use(\"agg\")\n",
-    "import matplotlib.pyplot as plt\n",
-    "import matplotlib.ticker as ticker\n",
-    "\n",
-    "\n",
-    "__file__ = os.path.dirname(os.path.realpath(\"__file__\"))\n",
-    "root_dir = (Path(__file__).parent / \"..\").resolve()\n",
-    "lib_dir = (root_dir / \"lib\").resolve()\n",
-    "print(\"The root path: {:}\".format(root_dir))\n",
-    "print(\"The library path: {:}\".format(lib_dir))\n",
-    "assert lib_dir.exists(), \"{:} does not exist\".format(lib_dir)\n",
-    "if str(lib_dir) not in sys.path:\n",
-    "    sys.path.insert(0, str(lib_dir))\n",
-    "\n",
-    "from datasets import SynAdaptiveEnv\n",
-    "from xlayers.super_core import SuperSequential, SuperMLPv1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "consistent-transition",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "SynAdaptiveEnv(100/100 elements,\n",
-      "amplitude=QuadraticFunc(y = -12.000007629394531 * x^2 + 11.999908447265625 * x + 0.9999204277992249),\n",
-      "period_phase_shift=QuarticFunc(y = 6.985218524932861 * x^4 + -13.632467269897461 * x^3 + -17.948883056640625 * x^2 + 53.29509735107422 * x + 53.29509735107422))\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "def visualize_q_func():\n",
-    "    # save_dir = (save_path / '..').resolve()\n",
-    "    # save_dir.mkdir(parents=True, exist_ok=True)\n",
-    "    \n",
-    "    dpi, width, height = 10, 200, 80\n",
-    "    figsize = width / float(dpi), height / float(dpi)\n",
-    "    LabelSize, LegendFontsize, font_gap = 40, 40, 5\n",
-    "    \n",
-    "    fig = plt.figure(figsize=figsize)\n",
-    "    \n",
-    "    dataset = SynAdaptiveEnv()\n",
-    "    print(dataset)\n",
-    "    xaxis, yaxis = [], []\n",
-    "    for idx, position, value in dataset:\n",
-    "        xaxis.append(position)\n",
-    "        # yaxis.append(dataset._amplitude_scale[position])\n",
-    "        yaxis.append(value)\n",
-    "\n",
-    "    cur_ax = fig.add_subplot(1, 1, 1)\n",
-    "    cur_ax.plot(xaxis, yaxis, color=\"k\", linestyle=\"-\", alpha=0.6, label=None)\n",
-    "\n",
-    "    # fig.savefig(save_path, dpi=dpi, bbox_inches=\"tight\", format=\"pdf\")\n",
-    "    # plt.close(\"all\")\n",
-    "    # plt.show()\n",
-    "visualize_q_func()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/notebooks/TOT/synthetic-data.ipynb b/notebooks/TOT/synthetic-data.ipynb
new file mode 100644
index 0000000..3677a48
--- /dev/null
+++ b/notebooks/TOT/synthetic-data.ipynb
@@ -0,0 +1,112 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "filled-multiple",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The root path: /Users/xuanyidong/Desktop/AutoDL-Projects\n",
+      "The library path: /Users/xuanyidong/Desktop/AutoDL-Projects/lib\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os, sys\n",
+    "import torch\n",
+    "from pathlib import Path\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "__file__ = os.path.dirname(os.path.realpath(\"__file__\"))\n",
+    "root_dir = (Path(__file__).parent / \"..\").resolve()\n",
+    "lib_dir = (root_dir / \"lib\").resolve()\n",
+    "print(\"The root path: {:}\".format(root_dir))\n",
+    "print(\"The library path: {:}\".format(lib_dir))\n",
+    "assert lib_dir.exists(), \"{:} does not exist\".format(lib_dir)\n",
+    "if str(lib_dir) not in sys.path:\n",
+    "    sys.path.insert(0, str(lib_dir))\n",
+    "\n",
+    "from datasets import SinGenerator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "consistent-transition",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SinGenerator(100/100 elements,\n",
+      "amplitude=QuadraticFunc(y = -12.000019073486328 * x^2 + 11.999970436096191 * x + 0.9999865293502808),\n",
+      "period_phase_shift=QuarticFunc(y = 7.079958915710449 * x^4 + -13.879528999328613 * x^3 + -17.825382232666016 * x^2 + 53.32909393310547 * x + 53.32909393310547))\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def visualize_q_func():\n",
+    "\n",
+    "    dpi, width, height = 10, 200, 80\n",
+    "    figsize = width / float(dpi), height / float(dpi)\n",
+    "    LabelSize, LegendFontsize, font_gap = 40, 40, 5\n",
+    "    \n",
+    "    fig = plt.figure(figsize=figsize)\n",
+    "    \n",
+    "    dataset = SinGenerator()\n",
+    "    print(dataset)\n",
+    "    xaxis, yaxis = [], []\n",
+    "    for idx, position, value in dataset:\n",
+    "        xaxis.append(position)\n",
+    "        # yaxis.append(dataset._amplitude_scale[position])\n",
+    "        yaxis.append(value)\n",
+    "\n",
+    "    cur_ax = fig.add_subplot(1, 1, 1)\n",
+    "    cur_ax.plot(xaxis, yaxis, color=\"k\", linestyle=\"-\", alpha=0.6, label=None)\n",
+    "\n",
+    "visualize_q_func()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/TOT/synthetic-env.ipynb b/notebooks/TOT/synthetic-env.ipynb
index 30bf348..88fe63a 100644
--- a/notebooks/TOT/synthetic-env.ipynb
+++ b/notebooks/TOT/synthetic-env.ipynb
@@ -36,8 +36,8 @@
     "if str(lib_dir) not in sys.path:\n",
     "    sys.path.insert(0, str(lib_dir))\n",
     "\n",
-    "from datasets import SynAdaptiveEnv\n",
-    "from xlayers.super_core import SuperSequential, SuperMLPv1"
+    "from datasets import ConstantGenerator, SinGenerator, SyntheticDEnv\n",
+    "from datasets import QuadraticFunc"
    ]
   },
   {
@@ -50,16 +50,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SynAdaptiveEnv(100/100 elements\n",
-      "amplitude=QuadraticFunction(y = 4.8680419921875 * x^2 + 3.565875291824341 * x + 0.9999021291732788),\n",
-      ")period_phase_shift=QuadraticFunction(y = 0.00021915265824645758 * x^2 + 0.9999573826789856 * x + -1.2333193808444776e-05)\n"
+      "SyntheticDEnv(20/20 elements, ndim=1, num_per_task=100)\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAACNMAAAidCAYAAACneeLnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdyXPW9d7/+fcXwjwcOGAUjgg3OHNARXFEBgHBkIQkgJ67qje9+e26q3vXu98/0JteddVd3dWrrvunDCEhQJhlFD0qTojKwQMHBZkkzEOGby9+OafP4BAgyecaHo8qFobL1GuRXCy+z3pfWZ7nAQAAAAAAAAAARAxIPQAAAAAAAAAAAAqFmAYAAAAAAAAAALqJaQAAAAAAAAAAoJuYBgAAAAAAAAAAuolpAAAAAAAAAACgW0VffNPx48fnU6ZM6YtvDQAAAAAAAAAA9+yjjz46n+f5ff/89T6JaaZMmRIffvhhX3xrAAAAAAAAAAC4Z1mWnfipr/uYJwAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6CamAQAAAAAAAACAbmIaAAAAAAAAAADoJqYBAAAAAAAAAIBuYhoAAAAAAAAAAOgmpgEAAAAAAAAAgG5iGgAAAAAAAAAA6NajmCbLsv81y7LDWZZ9kWXZf2ZZNrSvhwEAAAAAAAAAQH/71Zgmy7LfRcT/HBHP5Xn++4gYGBF/6OthAAAAAAAAAADQ33r6MU8VETEsy7KKiBgeEaf6bhIAAAAAAAAAAKTxqzFNnuffR8T/HhF/iYjTEXEpz/Ot//y6LMv+S5ZlH2ZZ9uG5c+d6fykAAAAAAAAAAPSxnnzM09iIWB4R/xYREyNiRJZl/8M/vy7P8//I8/y5PM+fu++++3p/KQAAAAAAAAAA9LGefMzTooj4c57n5/I8b4+IdRHxct/OAgAAAAAAAACA/teTmOYvEfFilmXDsyzLImJhRBzp21kAAAAAAAAAAND/fjWmyfP8/YhYExEfR8Tn3f/Pf/TxLgAAAAAAAAAA6HcVPXlRnuf/NSL+ax9vAQAAAAAAAACApHryMU8AAAAAAAAAAFAWxDQAAAAAAAAAANBNTAMAAAAAAAAAAN3ENAAAAAAAAAAA0E1MAwAAAAAAAAAA3cQ0AAAAAAAAAADQTUwDAAAAAAAAAADdxDQAAAAAAAAAANBNTAMAAAAAAAAA0Ec+/fTTePfdd6Orqyv1FHpITAMAAAAAAAAA0Ae6urpi7dq1sWfPnsiyLPUcekhMAwAAAAAAAADQB/74xz/GmTNnorq6WkxTRMQ0AAAAAAAAAAC9rKurKzZu3BgPPvhgPPPMM6nncAfENAAAAAAAAAAAveyDDz5wlaZIiWkAAAAAAAAAAHrR31+lefrpp1PP4Q6JaQAAAAAAAAAAetEHH3wQZ8+edZWmSIlpAAAAAAAAAAB6yV+v0kyaNMlVmiIlpgEAAAAAAAAA6CUHDx6Ms2fPRk1Njas0RUpMAwAAAAAAAADQC7q6umLTpk0xadKkmDlzZuo53CUxDQAAAAAAAABALzh48GCcO3fOVZoiJ6YBAAAAAAAAALhHnZ2dsXHjxnjooYdcpSlyYhoAAAAAAAAAgHt08ODBOH/+vKs0JUBMAwAAAAAAAABwDzo7O2PTpk0xefLkmDFjRuo53CMxDQAAAAAAAADAPXCVprSIaQAAAAAAAAAA7lJHR0ds3LgxpkyZEr///e9Tz6EXiGkAAAAAAAAAAO7Se++9FxcuXHCVpoSIaQAAAAAAAAAA7kJHR0ds3rw5pkyZEtOnT089h14ipgEAAAAAAAAAuAuu0pQmMQ0AAAAAAAAAwB3q6OiITZs2xb/927+5SlNixDQAAAAAAAAAAHfowIED8eOPP7pKU4LENAAAAAAAAAAAd+CvV2mmTp0aTz75ZOo59DIxDQAAAAAAAADAHdi/f39cvHjRVZoSJaYBAAAAAAAAAOihjo6O2Lx5c0ydOjWeeOKJ1HPoA2IaAAAAAAAAAIAe2rdvX1y8eDFqa2tdpSlRYhoAAAAAAAAAgB7461WaadOmxeOPP556Dn1ETAMAAAAAAAAA0AP79u2Ltra2qKmpcZWmhIlpAAAAAAAAAAB+RXt7e2zevDkefvhhV2lKnJgGAAAAAAAAAOBXuEpTPsQ0AAAAAAAAAAC/oL29PVpbW+ORRx6Jxx57LPUc+piYBgAAAAAAAADgF+zdu9dVmjIipgEAAAAAAAAA+Bl/vUrz6KOPukpTJsQ0AAAAAAAAAAA/Y8+ePXHp0qWoqalJPYV+IqYBAAAAAAAAAPgJf3+V5tFHH009h34ipgEAAAAAAAAA+Al79uyJy5cvu0pTZsQ0AAAAAAAAAAD/5Pbt29Ha2hqPPfaYqzRlRkwDAAAAAAAAAPBPXKUpX2IaAAAAAAAAAIC/89erNI8//ng88sgjqefQz8Q0AAAAAAAAAAB/Z/fu3XHlyhVXacqUmAYAAAAAAAAAoNutW7diy5Yt8cQTT8TDDz+ceg4JiGkAAAAAAAAAALq5SoOYBgAAAAAAAAAg/vtVmq1bt8YTTzwR06ZNSz2HRMQ0AAAAAAAAAAAR8e6777pKg5gGAAAAAAAAAODmzZuxZcuWmD59uqs0ZU5MAwAAAAAAAACUvV27dsW1a9eitrY29RQSE9MAAAAAAAAAAGXtxo0bsXXr1pg5c2ZMmTIl9RwSE9MAAAAAAAAAAGVt586dcf369aiurk49hQIgpgEAAAAAAAAAytb169dj27Zt8dRTT8XkyZNTz6EAiGkAAAAAAAAAgLK1Y8eOuHHjRtTU1KSeQoEQ0wAAAAAAAAAAZenatWuxffv2mDVrVkyaNCn1HAqEmAYAAAAAAAAAKEvbtm2LW7duuUrDPxDTAAAAAAAAAABl5+rVq7Fz58549tlnY+LEiannUEDENAAAAAAAAABA2dm6dWvcvn07qqurU0+hwIhpAAAAAAAAAICycuXKldi1a1fMnj07JkyYkHoOBUZMAwAAAAAAAACUlS1btkR7e7urNPwkMQ0AAAAAAAAAUDYuXboU7777brzwwgtx//33p55DARLTAAAAAAAAAABlY8uWLdHZ2RnLli1LPYUCJaYBAAAAAAAAAMpCW1tb7N69O1566aWorKxMPYcCJaYBAAAAAAAAAMpCa2trdHV1RVVVVeopFDAxDQAAAAAAAABQ8i5evBh79+6NV155JcaPH596DgVMTAMAAAAAAAAAlLxNmzZFnufxxhtvpJ5CgRPTAAAAAAAAAAAl7cKFC7F///6YM2dOjBs3LvUcCpyYBgAAAAAAAAAoaZs2bYosy1yloUfENAAAAAAAAABAyTp//nwcOHAgXn311Rg7dmzqORQBMQ0AAAAAAAAAULI2btwYAwcOjKVLl6aeQpEQ0wAAAAAAAAAAJens2bNx8ODBmDt3bowZMyb1HIqEmAYAAAAAAAAAKEmu0nA3xDQAAAAAAAAAQMn54Ycf4v33348FCxbE6NGjU8+hiIhpAAAAAAAAAICS09LSEoMHD47XX3899RSKjJgGAAAAAAAAACgpp06dig8//DAWLFgQo0aNSj2HIiOmAQAAAAAAAABKysaNG12l4a6JaQAAAAAAAACAkvH999/Hhx9+GAsXLowRI0aknkMREtMAAAAAAAAAACVjw4YNMXTo0Fi0aFHqKRQpMQ0AAAAAAAAAUBJOnjwZhw4dikWLFrlKw10T0wAAAAAAAAAAJWHDhg0xfPjwWLhwYeopFDExDQAAAAAAAABQ9E6cOBGffvppLF68OIYPH556DkVMTAMAAAAAAAAAFL0NGzbEiBEj4rXXXks9hSInpgEAAAAAAAAAitqf//zn+Pzzz2Px4sUxdOjQ1HMocmIaAAAAAAAAAKCobdiwIUaOHBkLFixIPYUSIKYBAAAAAAAAAIrWsWPH4vDhw7FkyRJXaegVYhoAAAAAAAAAoGg1NzfHqFGjYt68eamnUCLENAAAAAAAAABAUTp69Gh89dVXsXTp0hgyZEjqOZQIMQ0AAAAAAAAAUHTyPI/m5uYYPXq0qzT0KjENAAAAAAAAAFB0vv766/jmm2+iqqoqBg0alHoOJURMAwAAAAAAAAAUlTzPo6mpKcaOHRtz5sxJPYcSI6YBAAAAAAAAAIrK4cOH49tvv3WVhj4hpgEAAAAAAAAAikae59Hc3Bzjxo2Ll19+OfUcSpCYBgAAAAAAAAAoGp9++mmcOHEiqquro6KiIvUcSpCYBgAAAAAAAAAoCn+9SlNZWRkvvvhi6jmUKDENAAAAAAAAAFAUPvroo/j++++juro6BgyQPNA3/GQBAAAAAAAAAAWvq6srWlpaYsKECTF79uzUcyhhYhoAAAAAAAAAoOD98Y9/jNOnT0dNTY2rNPQpP10AAAAAAAAAQEH761WaBx98MGbNmpV6DiVOTAMAAAAAAAAAFLT33nsvzp49G7W1tZFlWeo5lDgxDQAAAAAAAABQsDo6OmLjxo0xZcqUmDlzZuo5lAExDQAAAAAAAABQsA4cOBAXLlxwlYZ+I6YBAAAAAAAAAApSe3t7bNy4MaZNmxZPPvlk6jmUCTENAAAAAAAAAFCQ9u7dG21tba7S0K/ENAAAAAAAAABAwbl9+3Zs3rw5Hn300Xj88cdTz6GMiGkAAAAAAAAAgILz7rvvxuXLl2P58uWpp1BmxDQAAAAAAAAAQEG5efNmtLa2xpNPPhkPP/xw6jmUGTENAAAAAAAAAFBQdu7cGdeuXXOVhiTENAAAAAAAAABAwbh+/Xps27YtZs6cGVOmTEk9hzIkpgEAAAAAAAAACsaOHTvi+vXrUVtbm3oKZUpMAwAAAAAAAAAUhGvXrsX27dtj1qxZMWnSpNRzKFNiGgAAAAAAAACgIGzdujVu3boVNTU1qadQxsQ0AAAAAAAAAEByV65ciZ07d8Zzzz0XEydOTD2HMiamAQAAAAAAAACSa21tjfb2dldpSE5MAwAAAAAAAAAk1dbWFrt3744XX3wx7r///tRzKHNiGgAAAAAAAAAgqc2bN0dnZ2dUV1enngJiGgAAAAAAAAAgnR9//DH27dsXr7zySowfPz71HBDTAAAAAAAAAADpbNq0KSIiqqqqEi+B/05MAwAAAAAAAAAkcf78+di/f3/MmTMnfvvb36aeAxEhpgEAAAAAAAAAEmlpaYmBAwfGG2+8kXoK/I2YBgAAAAAAAADod2fOnImDBw/GvHnzYsyYMannwN+IaQAAAAAAAACAfrdhw4YYNGhQLF26NPUU+AdiGgAAAAAAAACgX506dSo+/PDDeO2112LUqFGp58A/ENMAAAAAAAAAAP1qw4YNMWTIkHj99ddTT4F/IaYBAAAAAAAAAPrNyZMn4+OPP45FixbFiBEjUs+BfyGmAQAAAAAAAAD6TXNzcwwfPjwWLlyYegr8JDENAAAAAAAAANAvjh8/Hp999lksXrw4hg8fnnoO/CQxDQAAAAAAAADQL5qammLEiBHx2muvpZ4CP0tMAwAAAAAAAAD0uT/96U/x5ZdfxtKlS2Po0KGp58DPEtMAAAAAAAAAAH0qz/NYv359jB49OubPn596DvwiMQ0AAAAAAAAA0Ke++uqrOHr0aFRVVcXgwYNTz4FfJKYBAAAAAAAAAPrMX6/SjB07Nl599dXUc+BXiWkAAAAAAAAAgD7z+eefx/Hjx6O6ujoqKipSz4FfJaYBAAAAAAAAAPpEnufR1NQUlZWV8dJLL6WeAz0ipgEAAAAAAAAA+sRHH30U3333XVRXV8fAgQNTz4EeEdMAAAAAAAAAAL2uq6srmpubY+LEiTF79uzUc6DHxDQAAAAAAAAAQK97//3348yZM1FbWxsDBsgTKB5+WgEAAAAAAACAXtXR0REtLS3x0EMPxdNPP516DtwRMQ0AAAAAAAAA0KsOHDgQ58+fj+XLl0eWZannwB0R0wAAAAAAAAAAvaa9vT02btwY06ZNi+nTp6eeA3dMTAMAAAAAAAAA9Jo9e/ZEW1ubqzQULTENAAAAAAAAANArbt26FZs3b47HH388HnvssdRz4K6IaQAAAAAAAACAXrFz5864cuVKLF++PPUUuGtiGgAAAAAAAADgnl2/fj22bt0aM2fOjKlTp6aeA3dNTAMAAAAAAAAA3LMdO3bE9evXo7a2NvUUuCdiGgAAAAAAAADgnly9ejW2bdsWs2bNikmTJqWeA/dETAMAAAAAAAAA3JMtW7bE7du3XaWhJIhpAAAAAAAAAIC7dunSpdi1a1e88MILMWHChNRz4J6JaQAAAAAAAACAu7Z58+bo7OyM6urq1FOgV4hpAAAAAAAAAIC7cuHChdizZ0+88sorcd9996WeA71CTAMAAAAAAAAA3JWNGzdGlmWxbNmy1FOg14hpAAAAAAAAAIA7dvbs2Xjvvfdi3rx5MXbs2NRzoNeIaQAAAAAAAACAO9bS0hIVFRWxdOnS1FOgV4lpAAAAAAAAAIA7curUqfjggw9iwYIFMXr06NRzoFeJaQAAAAAAAACAO9Lc3BxDhgyJJUuWpJ4CvU5MAwAAAAAAAAD02IkTJ+LQoUOxePHiGDFiROo50OvENAAAAAAAAABAjzU3N8eIESNi0aJFqadAnxDTAAAAAAAAAAA9cuzYsfjiiy9iyZIlMXTo0NRzoE+IaQAAAAAAAACAHmlqaorRo0fH/PnzU0+BPiOmAQAAAAAAAAB+1VdffRVff/11VFVVxZAhQ1LPgT4jpgEAAAAAAAAAflGe59HU1BRjx46NV199NfUc6FNiGgAAAAAAAADgF33xxRfx7bffxrJly6KioiL1HOhTYhoAAAAAAAAA4Gf99SrNfffdFy+//HLqOdDnxDQAAAAAAAAAwM86dOhQnDx5MmpqamLgwIGp50CfE9MAAAAAAAAAAD+pq6srmpubY8KECTF79uzUc6BfiGkAAAAAAAAAgJ/0wQcfxOnTp6O2tjYGDJAYUB78pAMAAAAAAAAA/6KzszM2bNgQkyZNimeeeSb1HOg3YhoAAAAAAAAA4F8cOHAgzp8/H3V1dZFlWeo50G/ENAAAAAAAAADAP2hvb4+WlpaYOnVqTJ8+PfUc6FdiGgAAAAAAAADgH+zevTva2tqivr7eVRrKjpgGAAAAAAAAAPibmzdvRmtrazzxxBPx6KOPpp4D/U5MAwAAAAAAAAD8zc6dO+PKlStRV1eXegokIaYBAAAAAAAAACIi4tq1a7Fly5Z4+umnY8qUKannQBJiGgAAAAAAAAAgIiK2bt0at27diuXLl6eeAsmIaQAAAAAAAACAuHz5cuzYsSOef/75mDhxYuo5kIyYBgAAAAAAAACITZs2RWdnZ1RXV6eeAkmJaQAAAAAAAACgzF24cCH27NkTc+bMicrKytRzICkxDQAAAAAAAACUuZaWlsiyLKqqqlJPgeTENAAAAAAAAABQxn744Yd47733Yv78+TF27NjUcyA5MQ0AAAAAAAAAlLHm5uYYPHhwLF26NPUUKAhiGgAAAAAAAAAoUydPnoyPPvooFi1aFKNGjUo9BwqCmAYAAAAAAAAAytT69etj+PDhsXjx4tRToGCIaQAAAAAAAACgDP3pT3+KL774IpYuXRrDhg1LPQcKhpgGAAAAAAAAAMpMnuexfv36GD16dCxYsCD1HCgoYhoAAAAAAAAAKDNHjhyJo0ePxrJly2Lw4MGp50BBEdMAAAAAAAAAQBn561WacePGxZw5c1LPgYIjpgEAAAAAAACAMvLJJ5/EiRMnorq6OioqKlLPgYIjpgEAAAAAAACAMtHV1RVNTU3xwAMPxIsvvph6DhQkMQ0AAAAAAAAAlIkPPvggTp8+HcuXL48BAyQD8FP8ZgAAAAAAAABAGejo6IgNGzbEpEmT4plnnkk9BwqWmAYAAAAAAAAAysCBAwfi/PnzUVdXF1mWpZ4DBUtMAwAAAAAAAAAlrr29PVpaWuLhhx+O6dOnp54DBU1MAwAAAAAAAAAlbteuXXHp0iVXaaAHxDQAAAAAAAAAUMJu3rwZra2tMX369HjkkUdSz4GCJ6YBAAAAAAAAgBK2ffv2uHbtWixfvjz1FCgKYhoAAAAAAAAAKFFXr16Nbdu2xaxZs2Ly5Mmp50BRENMAAAAAAAAAQInasmVL3Lp1K2pra1NPgaIhpgEAAAAAAACAEtTW1ha7du2KF154ISZMmJB6DhQNMQ0AAAAAAAAAlKBNmzZFV1dX1NTUpJ4CRUVMAwAAAAAAAAAl5vz587F3796YM2dOjB8/PvUcKCpiGgAAAAAAAAAoMRs2bIiBAwdGVVVV6ilQdMQ0AAAAAAAAAFBCTp06Fe+//34sWLAgxowZk3oOFB0xDQAAAAAAAACUkObm5hgyZEgsXbo09RQoSmIaAAAAAAAAACgRJ06ciEOHDsXixYtjxIgRqedAURLTAAAAAAAAAECJaGpqihEjRsSiRYtST4GiJaYBAAAAAAAAgBLwzTffxOHDh2Pp0qUxdOjQ1HOgaIlpAAAAAAAAAKDI5Xke69evjzFjxsSCBQtSz4GiJqYBAAAAAAAAgCJ3+PDhOHbsWFRVVcWgQYNSz4GiJqYBAAAAAAAAgCKW53k0NjbG+PHj45VXXkk9B4qemAYAAAAAAAAAitiHH34Y3333XdTW1kZFRUXqOVD0xDQAAAAAAAAAUKQ6Ozujqakpfve738Xzzz+feg6UBDENAAAAAAAAABSp/fv3x7lz56Kuri6yLEs9B0qCmAYAAAAAAAAAilB7e3ts3Lgxpk6dGjNmzEg9B0qGmAYAAAAAAAAAitCuXbuira0tGhoaXKWBXiSmAQAAAAAAAIAic+PGjWhtbY3p06fHI488knoOlBQxDQAAAAAAAAAUma1bt8a1a9eivr4+9RQoOWIaAAAAAAAAACgily9fjh07dsRzzz0XkyZNSj0HSo6YBgAAAAAAAACKyObNm6O9vT1qa2tTT4GSJKYBAAAAAAAAgCJx4cKF2LNnT7z88stx//33p54DJUlMAwAAAAAAAABFoqWlJSIiqqurEy+B0iWmAQAAAAAAAIAicPr06Xjvvfdi/vz5MXbs2NRzoGSJaQAAAAAAAACgCDQ1NcWQIUPijTfeSD0FSpqYBgAAAAAAAAAK3PHjx+PQoUOxePHiGDlyZOo5UNLENAAAAAAAAABQ4NavXx8jR46MRYsWpZ4CJU9MAwAAAAAAAAAF7KuvvoojR47EG2+8EUOHDk09B0qemAYAAAAAAAAAClSe59HY2Bhjx46NefPmpZ4DZUFMAwAAAAAAAAAF6pNPPonjx49HTU1NDBo0KPUcKAtiGgAAAAAAAAAoQF1dXdHU1BT3339/vPTSS6nnQNkQ0wAAAAAAAABAAXr//ffj9OnTUVdXFwMGeLwP/cVvGwAAAAAAAAAUmI6OjtiwYUNMnjw5nnnmmdRzoKyIaQAAAAAAAACgwOzduzcuXLgQdXV1kWVZ6jlQVsQ0AAAAAAAAAFBAbt26FRs3boxHH300nnjiidRzoOyIaQAAAAAAAACggOzYsSOuXLkS9fX1rtJAAmIaAAAAAAAAACgQ165di61bt8ZTTz0VU6dOTT0HypKYBgAAAAAAAAAKxJYtW+LmzZtRV1eXegqULTENAAAAAAAAABSAtra22LlzZzz//PMxceLE1HOgbIlpAAAAAAAAAKAAbNy4MTo7O6O2tjb1FChrYhoAAAAAAAAASOzcuXOxb9++mDt3bowfPz71HChrvxrTZFn2WJZln/zdn8tZlv0v/bANAAAAAAAAAMpCc3NzDBw4MKqqqlJPgbJX8WsvyPP864h4OiIiy7KBEfF9RDT27SwAAAAAAAAAKA/fffdd/PGPf4wlS5bEb37zm9RzoOzd6cc8LYyIY3men+iLMQAAAAAAAABQbpqammLYsGGxZMmS1FOAuPOY5g8R8Z8/9RdZlv2XLMs+zLLsw3Pnzt37MgAAAAAAAAAocceOHYvPPvssXn/99Rg+fHjqOUDcQUyTZdngiKiNiNU/9fd5nv9HnufP5Xn+3H333ddb+wAAAAAAAACgJOV5Ho2NjTF69Oh47bXXUs8But3JZZo3IuLjPM/P9NUYAAAAAAAAACgXX375ZRw9ejSWLVsWQ4YMST0H6HYnMc2/x898xBMAAAAAAAAA0HN/vUozfvz4mDNnTuo5wN/pUUyTZdnwiFgcEev6dg4AAAAAAAAAlL6PPvooTp48GbW1tVFRUZF6DvB3evQbmef59YgY18dbAAAAAAAAAKDkdXZ2RlNTU0ycODFmz56deg7wT+7kY54AAAAAAAAAgHu0f//+OHv2bNTX18eAAR7bQ6HxWwkAAAAAAAAA/eT27dvR0tIS06ZNixkzZqSeA/wEMQ0AAAAAAAAA9JOdO3fGpUuXoqGhIbIsSz0H+AliGgAAAAAAAADoB9evX48tW7bEzJkz4+GHH049B/gZYhoAAAAAAAAA6Aetra1x48aNqKurSz0F+AViGgAAAAAAAADoY21tbbFz58544YUX4ne/+13qOcAvENMAAAAAAAAAQB9raWmJrq6uqKmpST0F+BViGgAAAAAAAADoQ2fOnIn9+/fHvHnzYvz48annAL9CTAMAAAAAAAAAfWj9+vUxaNCgqKqqSj0F6AExDQAAAAAAAAD0kePHj8fHH38cixcvjlGjRqWeA/SAmAYAAAAAAAAA+khjY2OMHDkyFi9enHoK0ENiGgAAAAAAAADoA0eOHImvvvoqqqqqYujQoannAD0kpgEAAAAAAACAXpbneTQ2Nsa4ceNi3rx5qecAd0BMAwAAAAAAAAC97OOPP44TJ05EbW1tVFRUpJ4D3AExDQAAAAAAAAD0os7Ozli/fn1MnDgxnn/++dRzgDskpgEAAAAAAACAXnTgwIE4e/Zs1NfXx4ABHstDsfFbCwAAAAAAAAC95Pbt27Fhw4aYNm1azJgxI/Uc4C6IaQAAAAAAAACgl+zatSsuXboUDQ0NkWVZ6jnAXRDTAAAAAAAAAEAvuH79erS2tsaMGTPi4YcfTj0HuEtiGgAAAAAAAADoBa2trXHjxo2oq6tLPQW4B2IaAAAAAAAAALhHbW1tsXPnznj++efjwQcfTD0HuAdiGgAAAAAAAAC4Ry0tLdHV1RW1tbWppwD3SEwDAAAAAAAAAPfgzJkzsX///pg7d26MHz8+9RzgHolpAAAAAAAAAOAeNDU1xaBBg2LZsmWppwC9QEwDAAAAAAAAAHfpxIkT8dFHH8XixYtj1KhRqecAvUBMAwAAAAAAAAB3qbGxMUaOHBmLFy9OPQXoJWIaAAAAAAAAALgLR44ciSNHjkRVVVUMHTo09Rygl4hpAAAAAAAAAOAO5XkejY2NMW7cuJg3b17qOUAvEtMAAAAAAAAAwB36+OOP48SJE1FbWxsVFRWp5wC9SEwDAAAAAAAAAHegs7Mz1q9fHxMnToznn38+9Rygl4lpAAAAAAAAAOAOHDhwIM6ePRv19fUxYIDH7lBq/FYDAAAAAAAAQA/dvn07WlpaYtq0aTFjxozUc4A+IKYBAAAAAAAAgB7atWtXtLW1RUNDQ2RZlnoO0AfENAAAAAAAAADQA9evX4/W1taYMWNGPPzww6nnAH1ETAMAAAAAAAAAPdDa2ho3btyIurq61FOAPiSmAQAAAAAAAIBf0dbWFjt37oznn38+HnzwwdRzgD4kpgEAAAAAAACAX9HS0hJdXV1RW1ubegrQx8Q0AAAAAAAAAPALzpw5E/v374+5c+fG+PHjU88B+piYBgAAAAAAAAB+wfr162PQoEGxbNmy1FOAfiCmAQAAAAAAAICf8ec//zk+/vjjeP3112PUqFGp5wD9QEwDAAAAAAAAAD8hz/NYt25djBo1KhYtWpR6DtBPxDQAAAAAAAAA8BMOHz4c33zzTVRXV8fQoUNTzwH6iZgGAAAAAAAAAP5JV1dXrFu3Lu67776YM2dO6jlAPxLTAAAAAAAAAMA/+eCDD+L777+Purq6qKioSD0H6EdiGgAAAAAAAAD4O+3t7dHU1BSTJ0+OZ599NvUcoJ+JaQAAAAAAAADg7+zevTt+/PHHaGhoiCzLUs8B+pmYBgAAAAAAAAC63bhxIzZt2hRPPvlkPP7446nnAAmIaQAAAAAAAACg25YtW+LatWvR0NCQegqQiJgGAAAAAAAAACKira0ttm/fHs8//3xMmjQp9RwgETENAAAAAAAAAERES0tLdHV1xfLly1NPARIS0wAAAAAAAABQ9n744YfYv39/zJs3L8aPH596DpCQmAYAAAAAAACAsrd+/foYPHhwVFVVpZ4CJCamAQAAAAAAAKCsffvtt3Ho0KF4/fXXY9SoUannAImJaQAAAAAAAAAoW3mex7p162L06NGxaNGi1HOAAiCmAQAAAAAAAKBsffHFF3H06NGorq6OIUOGpJ4DFAAxDQAAAAAAAABlqaurK9atWxeVlZUxZ86c1HOAAiGmAQAAAAAAAKAsvf/++3Hq1KlYvnx5DBw4MPUcoECIaQAAAAAAAAAoO+3t7dHc3ByTJ0+OZ599NvUcoICIaQAAAAAAAAAoO7t3744ff/wxGhoaIsuy1HOAAiKmAQAAAAAAAKCsXL9+PTZt2hTTp0+Pxx9/PPUcoMCIaQAAAAAAAAAoK1u3bo1r165FfX196ilAARLTAAAAAAAAAFA22traYvv27fHCCy/EpEmTUs8BCpCYBgAAAAAAAICy0dLSEl1dXVFbW5t6ClCgxDQAAAAAAAAAlIUffvgh9u3bF/Pnz4/x48enngMUKDENAAAAAAAAAGVh/fr1MWTIkHjjjTdSTwEKmJgGAAAAAAAAgJL37bffxqFDh2LJkiUxatSo1HOAAiamAQAAAAAAAKCk5Xke69ati9GjR8fChQtTzwEKnJgGAAAAAAAAgJL2+eefx9GjR6OmpiaGDBmSeg5Q4MQ0AAAAAAAAAJSsrq6uaGxsjMrKynjllVdSzwGKgJgGAAAAAAAAgJJ18ODBOHXqVNTX18fAgQNTzwGKgJgGAAAAAAAAgJLU3t4ezc3NMWXKlHjmmWdSzwGKhJgGAAAAAAAAgJK0a9euuHjxYjQ0NESWZannAEVCTAMAAAAAAABAybl+/Xps3rw5pk+fHo899ljqOUAREdMAAAAAAAAAUHJaW1vjxo0b0dDQkHoKUGTENAAAAAAAAACUlIsXL8bOnTvj+eefjwcffDD1HKDIiGkAAAAAAAAAKCkbNmyIPM9j+fLlqacARUhMAwAAAAAAAEDJOHXqVBw4cCDmzZsX48aNSz0HKEJiGgAAAAAAAABKRmNjYwwdOjSWLVuWegpQpMQ0AAAAAAAAAJSEb775Jj777LN44403YsSIEannAEVKTAMAAAAAAABA0cvzPNauXRtjx46N1157LfUcoIiJaQAAAAAAAAAoeh999FEcP348amtrY9CgQannAEVMTAMAAAAAAABAUevo6Ij169fHxIkT48UXX0w9ByhyYhoAAAAAAAAAitrevXvj3LlzsWLFihgwwGNw4N54FwEAAAAAAACgaN28eTNaWlrisccei+nTp6eeA5QAMQ0AAAAAAAAARWvLli1x9erVWLFiRWRZlnoOUALENAAAAAAAAAAUpba2tti2bVvMnj07Jk+enHoOUCLENAAAAAAAAAAUpZaWlujq6oq6urrUU4ASIqYBAAAAAAAAoOicPn069u3bF/Pnz4/x48enngOUEDENAAAAAAAAAEWnsbExhgwZElVVVamnACVGTAMAAAAAAABAUTl69Gh8+umnsXTp0hg5cmTqOUCJEdMAAAAAAAAAUDTyPI9169bFmDFjYuHChannACVITAMAAAAAAABA0Th06FB8++23UVtbG4MHD049ByhBYhoAAAAAAAAAikJnZ2c0NjbGxIkT46WXXko9ByhRYhoAAAAAAAAAisLevXvj7NmzUV9fHwMGeNwN9A3vLgAAAAAAAAAUvJs3b0ZLS0s8+uijMWPGjNRzgBImpgEAAAAAAACg4G3bti2uXLkSK1asiCzLUs8BSpiYBgAAAAAAAICCdunSpdi6dWs899xzMWXKlNRzgBInpgEAAAAAAACgoLW0tERHR0csX7489RSgDIhpAAAAAAAAAChYP/zwQ+zbty/mzZsXlZWVqecAZUBMAwAAAAAAAEDBamxsjMGDB8eyZctSTwHKhJgGAAAAAAAAgIJ07Nix+OSTT2LJkiUxatSo1HOAMiGmAQAAAAAAAKDg5Hkea9asid/85jexcOHC1HOAMiKmAQAAAAAAAKDgfPLJJ/Htt99GTU1NDBkyJPUcoIyIaQAAAAAAAAAoKJ2dndHY2BgTJkyIV155JfUcoMyIaQAAAAAAAAAoKPv3748zZ85EfX19DBjgsTbQv7zrAAAAAAAAAFAwbt26FRs2bIhHHnkkZs6cmXoOUIbENAAAAAAAAAAUjG3btsXly5ejoaEhsixLPQcoQ2IaAAAAAAAAAArC5cuXY+vWrTFr1qyYOnVq6jlAmRLTAAAAAAAAAFAQWlpaor29Perr61NPAcqYmAYAAAAAAACA5M6cORN79+6NuXPnRmVlZeo5QBkT0wAAAAAAAACQXGNjYwwaNCiqq6tTTwHKnJgGAAAAAAAAgKS+/fbbOHToUCxZsiRGjRqVeg5Q5sQ0AAAAAAAAACST53msWbMmRo8eHYsWLUo9B0BMAwAAAAAAAEA6n376aRw7dixqampiyJAhqecAiGkAAAAAAAAASKOzszPWrVsXEyZMiDlz5qSeAxARYhoAAAAAAAAAEtm7d2+cOXMmGhoaYsAAj6+BwuDdCAAAAAAAAIB+d/PmzWhpaYlHH300ZsyYkXoOwN+IaQAAAAAAAADod1u2bIkrV67EypUrI8uy1HMA/kZMAwAAAAAAAEC/unjxYmzbti1mz54dkydPTj0H4B+IaQAAAAAAAADoV83NzZHnedTX16eeAvAvxDQAAAAAAAAA9Jvvvvsu3nvvvViwYEGMGzcu9RyAfyGmAQAAAAAAAKDfrF27NoYNGxZVVVWppwD8JDENAAAAAAAAAP3iyy+/jC+//DKWLVsWw4cPTz0H4CeJaQAAAAAAAADoc11dXbF27doYP358zJ8/P/UcgJ8lpgEAAAAAAACgzx08eDC+++67qKuri4qKitRzAH6WmAYAAAAAAACAPnX79u1oamqKKVOmxHPPPZd6DsAvEtMAAAAAAAAA0Kd27NgRbW1tsXLlysiyLPUcgF8kpgEAAAAAAACgz1y5ciVaW1vjqaeeikceeST1HIBfJaYBAAAAAAAAoM+0tLTE7du3o6GhIfUUgB4R0wAAAAAAAADQJ86cORN79uyJV199NR544IHUcwB6REwDAAAAAAAAQJ9obGyMQYMGRXV1deopAD0mpgEAAAAAAACg1/3pT3+KQ4cOxdKlS2P06NGp5wD0mJgGAAAAAAAAgF6V53msXbs2xowZE4sWLUo9B+COiGkAAAAAAAAA6FUff/xxfPvtt1FbWxuDBw9OPQfgjohpAAAAAAAAAOg1HR0d0djYGL/73e/ipZdeSj0H4I6JaQAAAAAAAADoNbt3745z587FihUrYsAAj6SB4uOdCwAAAAAAAIBecf369di4cWM88cQT8eSTT6aeA3BXxDQAAAAAAAAA9IrW1ta4fv16rFixIrIsSz0H4K6IaQAAAAAAAAC4ZxcuXIgdO3bECy+8EJMmTUo9B+CuiWkAAAAAAAAAuGdNTU2RZVnU1dWlngJwT8Q0AAAAAAAAANyTv/zlL/H+++/HwoULY+zYsannANwTMQ0AAAAAAAAAdy3P81i7dm2MHDkyli5dmnoOwD0T0wAAAAAAAABw1w4fPhxfffVVVFdXx7Bhw1LPAbhnYhoAAAAAAAAA7kpXV1esXbs2Kisr49VXX009B6BXiGkAAAAAAAAAuCsHDhyIU6dORX19fVRUVKSeA9ArxDQAAAAAAAAA3LFbt25Fc3NzTJs2LZ555pnUcwB6jZgGAAAAAAAAgDu2bdu2uHTpUqxYsSKyLEs9B6DXiGkAAAAAAAAAuCOXL1+OrVu3xqxZs2LatGmp5wD0KjENAAAAAAAAAHekubk52tvbo76+PvUUgF4npgEAAAAAAACgx06fPh379u2LefPmRWVlZeo5AL1OTAMAAAAAAABAj61bty6GDBkS1dXVqacA9AkxDQAAAAAAAAA98tVXX8Vnn30WVVVVMXLkyNRzAPqEmAYAAAAAAACAX5XneaxZsybGjRsXr732Wuo5AH1GTAMAAAAAAADArzp48GCcPHky6uvrY9CgQannAPQZMQ0AAAAAAAAAv+j27duxfv36mDJlSjz33HOp5wD0KTENAAAAAAAAAL9o+/bt0dbWFqtWrYosy1LPAehTYhoAAAAAAAAAftbly5ejtbU1nnnmmXj44YdTzwHoc2IaAAAAAAAAAH5Wc3NztLe3R0NDQ+opAP1CTAMAAAAAAADATzp16lTs27cvFixYEJWVlannAPQLMQ0AAAAAAAAAP2nNmjUxbNiwWLZsWeopAP1GTAMAAAAAAADAv/jyyy/j8OHDUVVVFSNGjEg9B6DfiGkAAAAAAAAA+AddXV2xZs2aGD9+fCxYsCD1HIB+JaYBAAAAAAAA4B+899578f3330d9fX1UVFSkngPQr8Q0AAAAAAAAAPzNrVu3oqmpKaZOnRrPPvts6jkA/U5MAwAAAAAAAMDfbN26NS5duhSrVq2KLMtSzwHod2IaAAAAAAAAACIioq2tLbZu3RrPPvtsTJ06NfUcgCTENAAAAAAAAABERERzc3N0dXVFQ0ND6ikAyYhpAAAAAAAAAIjvvvsuDhw4EAsWLIjx48enngOQjJgGAAAAAAAAoMzleR5r1qyJ4cOHR1VVVeo5AEmJaQAAAAAAAADK3OHDh+PIkSOxbNmyGD58eOo5AEmJaQAAAAAAAADKWFdXV6xZsyYqKytj3rx5qecAJCemAQAAAAAAAChj+/fvj9OnT0dDQ0NUVFSkngOQnJgGAAAAAAAAoEzdvHkzmpqa4pFHHomnn3469RyAgiCmAQAAAAAAAChTW7ZsiStXrsTKlSsjy7LUcwAKgpgGAAAAAAAAoAxdvHgxtm3bFrNnz44pU6akngNQMMQ0AAAAAAAAAGVo/fr1ked51NfXp54CUFDENAAAAAAAAABl5i9/+Uu8//77sXDhwhg3blzqOQAFRUwDAAAAAAAAUEbyPI81a9bEiBEj4o033kg9B6DgiGkAAAAAAAAAysjnn38eX3/9ddTU1MSwYcNSzwEoOGIaAAAAAAAAgDLR2dkZa9asifvvvz9effXV1HMACpKYBgAAAAAAAKBM7N27N86cORMrVqyIgQMHpp4DUJDENAAAAAAAAABl4MaNG7Fhw4Z49NFHY+bMmannABQsMQ0AAAAAAABAGWhtbY2rV6/GypUrI8uy1HMACpaYBgAAAAAAAKDEXbhwIbZv3x4vvvhiTJ48OfUcgIImpgEAAAAAAAAocU1NTZFlWdTV1aWeAlDwxDQAAAAAAAAAJez48ePx/vvvx6JFi2Ls2LGp5wAUPDENAAAAAAAAQInK8zzWrFkTo0aNiqVLl6aeA1AUxDQAAAAAAAAAJeqTTz6Jo0ePRm1tbQwdOjT1HICiIKYBAAAAAAAAKEEdHR2xdu3amDhxYsyZMyf1HICiIaYBAAAAAAAAKEHvvvtunDt3LlauXBkDBng0DNBT3jEBAAAAAAAASszVq1ejpaUlpk+fHtOnT089B6CoiGkAAAAAAAAASkxLS0vcunUrVq1alXoKQNER0wAAAAAAAACUkB9++CF2794dr776akyYMCH1HICiI6YBAAAAAAAAKCFr166NwYMHR01NTeopAEVJTAMAAAAAAABQIo4cORKfffZZVFVVxahRo1LPAShKYhoAAAAAAACAEtDV1RVr1qyJ8ePHx2uvvZZ6DkDREtMAAAAAAAAAlIADBw7Ed999Fw0NDTFo0KDUcwCKlpgGAAAAAAAAoMjdvHkzmpqaYtq0aTFr1qzUcwCKmpgGAAAAAAAAoMht2bIlLl++HG+++WZkWZZ6DkBRE9MAAAAAAAAAFLEff/wxtm3bFi+88EJMmTIl9RyAoiemAQAAAAAAAChijY2NERFRV1eXdghAiRDTAAAAAAAAABSpP//5z/HBBx/E4sWL47e//W3qOQAlQUwDAAAAAAAAUITyPI/Vq1fH6NGjY+nSpannAJQMMQ0AAAAAAABAEfroo4/i2LFjUVdXF0OGDEk9B6BkiGkAAAAAAAAAikx7e3usW7cuHnzwwXjppZdSzwEoKWIaAAAAAAAAgCKzc+fOuHDhQqxatSoGDPDYF6A3eVcFAAAAAAAAKCJXrlyJTZs2xcyZM+Pxxx9PPQeg5IhpAAAAAAAAAIpIc3Nz3L59O1auXJl6CkBJEtMAAAAAAAAAFIlTp07F3r17Y/78+XH//fenngNQksQ0AAAAAAAAAEVizZo1MWzYsKiurk49BaBkiWkAAAAAAAAAisDhw4fj8OHDsWzZshgxYkTqOQAlS0wDAAAAAAAAUOC6urpi9erVUVlZGfPnz089B6CkiWkAAAAAAAAACtzevXvj9OnTsWLFiqioqEg9B6CkiWkAAAAAAAAACtiNGzeiubk5Hn300XjqqadSzwEoeWIaAAAAAAAAgAK2efPmuHbtWqxatSqyLEs9B6DkiWkAAAAAAAAACtT58+djx44d8dJLL8VDDz2Ueg5AWRDTAAAAAAAAABSodevWxYABA2L58uWppwCUDTENAAAAAAAAQAE6duxYfPTRR7FkyZIYM2ZM6jkAZUNMAwAAAAAAAFBg8jyPd955J8aMGROLFy9OPQegrIhpAAAAAAAAAArMBx98EMePH4/6+voYMmRI6jkAZUVMAwAAAAAAAFBAbt++HY2NjfHQQw/FCy+8kHoOQNkR0wAAAAAAAAAUkO3bt8fFixfjzTffjCzLUs8BKDtiGgAAAAAAAIACcfny5WhtbY1nnnkmHnnkkdRzAMqSmAYAAAAAAACgQKxfvz46OjqioaEh9RSAsiWmAQAAAAAAACgAJ0+ejAMHDsSCBQuisrIy9RyAsiWmAQAAAAAAAEgsz/N45513YsSIEbFs2bLUcwDKmpgGAAAAAAAAILFPPvkkvvnmm1i+fHkMHz489RyAsiamAQAAAAAAAEioo6Mj1qxZExMnTow5c+akngNQ9sQ0AAAAAAAAAAnt2LEjzp8/H2+++WYMGOARLkBq3okBAAAAAAAAErl8+XJs2rQpZs6cGU888UTqOQCEmAYAAAAAAAAgmebm5mhvb49Vq1alngJANzENAAAAAAAAQAInT56Mffv2xYIFC6KysjL1HAC6iWkAAAAAAAAA+lme5/HOO+/E8OHDY9myZannAPB3xDQAAAAAAAAA/eyTTz6Jb775JpYvXx7Dhw9PPQeAvyOmAQAAAAAAAOhHHR0dsWbNmpg4cWK8+uqrqecA8E/ENAAAAAAAAAD9aOfOnXH+/Pl48803Y8AAj2wBCo13ZgAAAAAAAIB+cvny5di4cWPMnDkznnjiidRzAPgJYhoAAAAAAACAftLc3By3b9+OlStXpp4CwM8Q0wAAAAAAAAD0g++++y727dsXCxYsiPvvvz/1HAB+hpgGAAAAAAAAoI/leR7vvPNODB8+PKqrq1PPAeAX9CimybJsTJZla7Is+yrLsiNZlr3U18MAAAAAAAAASsVnn30WX3/9ddTW1sbw4cNTzwHgF1T08HX/R0S05nm+MsuywRHh3R0AAAAAAACgBzo6OmL16tUxYcKEmDt3buo5APyKX71Mk2XZ6IiYGxH/d0REnue38zxv6+NdAAAAAAAAACVh165dce7cuVi1alUMGNCjDw8BIKGevFNPjYhzEfH/ZFl2KMuy/yvLshH//KIsy/5LlmUfZln24blz53p9KAAAAAAAAECxuXLlSrS0tMTvf//7mD59euo5APRAT2KaioiYFRH/Z57nz0TEtYj43/75RXme/0ee58/lef7cfffd18szAQAAAAAAAIpPc3Nz3L59O1atWpV6CgA91JOY5ruI+C7P8/e7/3tN/Pe4BgAAAAAAAICf8f3338fevXtj/vz58cADD6SeA0AP/WpMk+f5DxFxMsuyx7q/tDAivuzTVQAAAAAAAABFLM/zeOedd2LYsGFRXV2deg4Ad6Cih6/7nyLi/82ybHBEfBsR/2PfTQIAAAAAAAAobp9//nl89dVX8Yc//CFGjBiReg4Ad6BHMU2e559ExHN9OwUAAAAAAACg+HV0dMTq1avjgQceiLlz56aeA8Ad+tWPeQIAAAAAAACg59599904e/ZsrFq1KgYOHJh6DgB3SEwDAAAAAAAA0EuuXr0aLS0tMX369Pj973+feg4Ad0FMAwAAAAAAANBLNmzYELdu3YpVq1alngLAXRLTAAAAAAAAAPSCU6dOxe7du2PevHkxYcKE1HMAuEtiGgAAAAAAAIB7lOd5vPPOOzFs2LCoqalJPQeAeyCmAQAAAAAAALhHn3/+eRw5ciRqampixIgRqecAcA/ENAAAAAAAAAD3oKOjI9asWRP3339/zJs3L/UcAO6RmAYAAAAAAADgHuzevTvOnDkTb775ZgwcODD1HADukZgGAAAAAAAA4C5dvXo1WlpaYvr06TF9+vTUcwDoBWIaAAAAAAAAgLu0YcOGuHnzZqxcuTKyLEs9B4BeIKYBAAAAAAAAuAunTp2KPXv2xNy5c2PixImp5wDQS8Q0AAAAAAAAAHcoz/N45513YujQoVFbW5t6DgC9SEwDAAAAAAAAcIc+++yzOHLkSNTW1saIESNSzwGgF4lpAAAAAAAAAO5AR0dHrF69OiZMmBBz585NPQeAXiamAQAAAAAAALgDO3bsiHPnzsWqVati4MCBqecA0MvENAAAAAAAAAA9dPny5di4cWPMnDkzpk+fnnoOAH1ATAMAAAAAAADQQ+vXr4+Ojo5YtWpV6ikA9BExDQAAAAAAAEAPnDhxIg4cOBALFy6MysrK1HMA6CNiGgAAAAAAAIBfked5vP322zFy5MhYtmxZ6jkA9CExDQAAAAAAAMCv+PDDD+PYsWNRX18fQ4cOTT0HgD4kpgEAAAAAAAD4Bbdu3Yq1a9fGQw89FC+99FLqOQD0MTENAAAAAAAAwC/YunVrXLx4Md56660YMMAjVoBS550eAAAAAAAA4Gf8+OOPsWXLlpg9e3Y8/PDDqecA0A/ENAAAAAAAAAA/Y+3atRER0dDQkHgJAP1FTAMAAAAAAADwE44ePRoffvhhLFmyJH7729+mngNAPxHTAAAAAAAAAPyTrq6uePvtt2Ps2LGxZMmS1HMA6EdiGgAAAAAAAIB/8t5778XJkydjxYoVMXjw4NRzAOhHYhoAAAAAAACAv3Pjxo1obGyMadOmxXPPPZd6DgD9TEwDAAAAAAAA8Hc2bdoUV69ejbfeeiuyLEs9B4B+JqYBAAAAAAAA6HbmzJnYsWNHvPzyyzF58uTUcwBIQEwDAAAAAAAA0G3NmjUxaNCgqKurSz0FgETENAAAAAAAAAARcfjw4fjss89i2bJlMXr06NRzAEhETAMAAAAAAACUvc7Ozli9enVUVlbGa6+9lnoOAAmJaQAAAAAAAICyt3v37jh9+nSsXLkyKioqUs8BICExDQAAAAAAAFDWrl69Ghs2bIgnnngiZs6cmXoOAImJaQAAAAAAAICy1tzcHDdv3ow333wzsixLPQeAxMQ0AAAAAAAAQNn6/vvvY8+ePTFv3ryYOHFi6jkAFAAxDQAAAAAAAFCW8jyPt99+O4YPHx41NTWp5wBQIMQ0AAAAAAAAQFn65JNP4uuvv47a2toYMWJE6jkAFAgxDQAAAAAAAFB22tvbY82aNTFx4sSYO3du6jkAFBAxDQAAAAAAAFB2tm/fHufPn4+33norBgzw2BSA/59/FQAAAAAAAICy0tbWFps3b46nn346Hn/88dRzACgwYhoAAAAAAACgrKxfvz46Oztj5cqVqacAUIDENAAAAAAAAEDZOH78eLz33nuxcOHCuO+++1LPAaAAiWkAAAAAAACAspDnefy3//bfYvTo0VFVVZV6DgAFSkwDAAAAAAAAlIUPPvgg/vznP0d9fX0MHTo09RwACpSYBgAAAAAAACh5N2/ejLVr18bkyZPjpZdeSj0HgAImpgEAAAAAAABK3ubNm+PSpUvxhz/8IbIsSz0HgAImpgEAAAAAAABK2tmzZ2P79u3x4osvxtSpU1PPAaDAiWkAAAAAAACAkrZ69eoYOHBgNDQ0pJ4CQBEQ0wAAAAAAAAAl6/Dhw/HZZ59FdXV1/OY3v0k9B4AiIKYBAAAAAAAASlJHR0e8/fbbUVlZGa+99lrqOQAUCTENAAAAAAAAUJJ27doVZ86cibfeeisqKipSzwGgSIhpAAAAAAAAgJJz+fLlaGlpiRkzZsTvf//71HMAKCJiGgAAAAAAAKDkNDY2Rnt7e7z55puppwBQZMQ0AAAAAAAAQEk5fvx4HDhwIBYtWhSVlZWp5wBQZMQ0AAAAAAAAQMnI8zz+8z//M0aPHh1VVVWp5wBQhMQ0AAAAAAAAQMk4ePBgHD9+PFasWBFDhw5NPQeAIiSmAQAAAAAAAErCzZs3Y926dTF16tR44YUXUs8BoEiJaQAAAAAAAICSsHHjxrhy5Uq89dZbkWVZ6jkAFCkxDQAAAAAAAFD0zpw5Ezt27IiXX345pkyZknoOAEVMTAMAAAAAAAAUtTzP4+23345BgwZFXV1d6jkAFDkxDQAAAAAAAFDUPv/88zh8+HDU1NTE6NGjU88BoMiJaQAAAAAAAICi1dHREatXr44HHnggFixYkHoOACVATAMAAAAAAAAUrR07dsTZs2fjrbfeioEDB6aeA0AJENMAAAAAAAAARamtrS02btwYTz31VDz55JOp5wBQIsQ0AAAAAAAAQFFqbGyMzs7OWLVqVeopAJQQMQ0AAAAAAABQdI4dOxYHDx6MxYsXx3333Zd6DgAlREwDAAAAAAAAFJU8z+Ptt9+OMWPGxBtvvJF6DgAlRkwDAAAAAAAAFJUDBw7EiRMnYsWKFTFkyJDUcwAoMWIaAAAAAAAAoGhcv349GhsbY9q0aTF79uzUcwAoQWIaAAAAAAAAoGi0tLTE1atX49///d8jy7LUcwAoQWIaAAAAAAAAoCicPn06du3aFa+++mpMmjQp9RwASpSYBgAAAAAAACh4eZ7H22+/HUOHDo3ly5enngNACRPTAAAAAAAAAAXv008/jSNHjkRtbW2MHDky9RwASpiYBgAAAAAAACho7e3tsXr16pg4cWLMmzcv9RwASpyYBgAAAAAAACho27Zti/Pnz8dbb70VAwZ4xAlA3/IvDQAAAAAAAFCwLl68GJs3b45Zs2bF448/nnoOAGVATAMAAAAAAAAUrLVr10ae57Fy5crUUwAoE2IaAAAAAAAAoCAdPXo0/vjHP8aSJUti3LhxqecAUCbENAAAAAAAAEDB6erqirfffjv+P/b+7M3K8t77dn+jKKCkV1oNCIGIQY0GmyigotgEkUaLEqHowS7P2ljP1jqO979496IiKG0VWAKioIhdFIwNYmDKBCVBUCNKIyCNQBV1r53MHMmMDU1VXaM5zx3YGBufvXGP+/oedV144YXx+9//PnUOACXEmAYAAAAAAADIO2+//XZ88cUXUVVVFW3atEmdA0AJMaYBAAAAAAAA8sqxY8fi+eefj8svvzyuu+661DkAlBhjGgAAAAAAACCvrFy5Mr7//vuYOHFi5HK51DkAlBhjGgAAAAAAACBvfP755/H222/H7bffHpdccknqHABKkDENAAAAAAAAkBeyLIuampro0KFDjBkzJnUOACXKmAYAAAAAAADIC++++27s3LkzKisr44ILLkidA0CJMqYBAAAAAAAAkvv+++9j+fLl0b9//xgyZEjqHABKmDENAAAAAAAAkNyLL74YR44ciYkTJ0Yul0udA0AJM6YBAAAAAAAAkvrqq6/i9ddfj5tvvjn69u2bOgeAEmdMAwAAAAAAACSTZVksXbo0Kioq4r777kudAwDGNAAAAAAAAEA6H330UWzfvj3GjRsXHTp0SJ0DAMY0AAAAAAAAQBonT56MZcuWRe/evePWW29NnQMAEWFMAwAAAAAAACTy8ssvx8GDB2PSpElRVuboEoD84BsJAAAAAAAAaHH79u2LV155JW688cb41a9+lToHAP7JmAYAAAAAAABoccuWLYtWrVpFZWVl6hQA+DfGNAAAAAAAAECL+vjjj2PLli0xevTo6NKlS+ocAPg3xjQAAAAAAABAi2loaIilS5dGz549Y8SIEalzAOA/GNMAAAAAAAAALWbdunWxd+/emDhxYpSXl6fOAYD/YEwDAAAAAAAAtIiDBw/GmjVrYvDgwXHFFVekzgGAH2RMAwAAAAAAALSIurq6yLIsHnjggdQpAPCjjGkAAAAAAACAZvfJJ5/Exo0bY+TIkdG1a9fUOQDwo4xpAAAAAAAAgGZ1+vTpqK2tja5du8bvf//71DkA8JOMaQAAAAAAAIBm9eabb8ZXX30VEyZMiNatW6fOAYCfZEwDAAAAAAAANJvvvvsuVq1aFVdccUVcc801qXMA4GcZ0wAAAAAAAADNZsWKFVFfXx8TJ06MXC6XOgcAfpYxDQAAAAAAANAsPvvss3jnnXfizjvvjJ49e6bOAYAzYkwDAAAAAAAANLksy6KmpiY6d+4co0aNSp0DAGfMmAYAAAAAAABochs2bIjdu3dHVVVVVFRUpM4BgDNmTAMAAAAAAAA0qWPHjsXy5cvjsssuixtuuCF1DgCcFWMaAAAAAAAAoEmtWrUqjh8/HhMnToxcLpc6BwDOijENAAAAAAAA0GS+/PLL+NOf/hTDhw+P3r17p84BgLNmTAMAAAAAAAA0iSzLora2Ntq3bx9jx45NnQMA58SYBgAAAAAAAGgSH3zwQezYsSPuu+++aN++feocADgnxjQAAAAAAADAeTtx4kTU1dVF3759Y9iwYalzAOCcGdMAAAAAAAAA52316tVx+PDhmDRpUpSVOYYEoHD5FgMAAAAAAADOy549e+LVV1+NoUOHxi9/+cvUOQBwXoxpAAAAAAAAgHOWZVnU1tZGRUVFVFZWps4BgPNmTAMAAAAAAACcsw8//DC2b98e48aNi44dO6bOAYDzZkwDAAAAAAAAnJOTJ0/Gs88+G3369Ilbb701dQ4ANAljGgAAAAAAAOCcrF69Og4dOhTV1dVRVuboEYDi4BsNAAAAAAAAOGt79uyJdevWxdChQ6N///6pcwCgyRjTAAAAAAAAAGcly7Kora2NioqKqKysTJ0DAE3KmAYAAAAAAAA4Kx9++GFs3749xo0bFx07dkydAwBNypgGAAAAAAAAOGMnT56MZ599Nvr06RO33npr6hwAaHLGNAAAAAAAAMAZW716dRw6dCiqq6ujrMxxIwDFx7cbAAAAAAAAcEb27NkT69ati6FDh0b//v1T5wBAszCmAQAAAAAAAH5WlmVRW1sbFRUVUVlZmToHAJqNMQ0AAAAAAADwszZt2hTbt2+PcePGRceOHVPnAECzMaYBAAAAAAAAftLJkydj2bJl0adPn7j11ltT5wBAszKmAQAAAAAAAH7S6tWr49ChQzFp0qQoK3PECEBx800HAAAAAAAA/Kg9e/bEunXrYujQoTFgwIDUOQDQ7IxpAAAAAAAAgB+UZVnU1tZGRUVFVFZWps4BgBZhTAMAAAAAAAD8oE2bNsX27dtj3Lhx0bFjx9Q5ANAijGkAAAAAAACA/3Dy5MlYtmxZ9OnTJ2699dbUOQDQYoxpAAAAAAAAgP+wevXqOHToUEyaNCnKyhwrAlA6fOsBAAAAAAAA/+brr7+OdevWxdChQ2PAgAGpcwCgRRnTAAAAAAAAAP+UZVnU1tZG27Zto7KyMnUOALQ4YxoAAAAAAADgnzZt2hTbtm2LcePGRceOHVPnAECLM6YBAAAAAAAAIiLi5MmT8eyzz0afPn1i+PDhqXMAIAljGgAAAAAAACAiIlavXh0HDx6MSZMmRVmZo0QASpNvQAAAAAAAACC+/vrrePXVV2Po0KExYMCA1DkAkIwxDQAAAAAAAJS4LMuitrY22rRpE5WVlalzACApYxoAAAAAAAAocR999FFs27Ytxo0bFx07dkydAwBJGdMAAAAAAABACTt58mQsW7Ys+vTpE8OHD0+dAwDJGdMAAAAAAABACVuzZk0cPHgwJk2aFGVljg8BwLchAAAAAAAAlKhvvvkm1q1bF0OHDo0BAwakzgGAvGBMAwAAAAAAACUoy7KoqamJNm3aRGVlZeocAMgbxjQAAAAAAABQgj766KPYtm1bjBs3Ljp27Jg6BwDyhjENAAAAAAAAlJiTJ0/GsmXLonfv3jF8+PDUOQCQV4xpAAAAAAAAoMSsXr06Dh48GNXV1VFW5sgQAP6Vb0YAAAAAAAAoIV999VWsW7cuhg0bFgMGDEidAwB5x5gGAAAAAAAASkSWZVFTUxMVFRVx//33p84BgLxkTAMAAAAAAAAl4v33349PP/00Kisro2PHjqlzACAvGdMAAAAAAABACTh+/HjU1dVFv3794uabb06dAwB5y5gGAAAAAAAASsCqVaviyJEjUV1dHblcLnUOAOQtYxoAAAAAAAAocp9//nm8+eabMXz48Ojbt2/qHADIa8Y0AAAAAAAAUMSyLIslS5ZEhw4dYty4calzACDvGdMAAAAAAABAEVu/fn189tlnUVVVFe3atUudAwB5z5gGAAAAAAAAitTRo0djxYoVcdlll8WNN96YOgcACoIxDQAAAAAAABSp5cuXx/fffx/V1dWRy+VS5wBAQTCmAQAAAAAAgCL0t7/9LTZs2BB33nlnXHLJJalzAKBgGNMAAAAAAABAkWlsbIwlS5bEhRdeGKNHj06dAwAFxZgGAAAAAAAAiswbb7wRX375ZUyYMCHatm2bOgcACooxDQAAAAAAABSRw4cPx6pVq+LKK6+MwYMHp84BgIJjTAMAAAAAAABF5Nlnn42GhoaYOHFi5HK51DkAUHCMaQAAAAAAAKBIbN++PT744IMYOXJk9OjRI3UOABQkYxoAAAAAAAAoAg0NDVFTUxPdunWLkSNHps4BgIJlTAMAAAAAAABF4NVXX42vv/46Jk2aFK1bt06dAwAFy5gGAAAAAAAACtyBAwfixRdfjMGDB8dVV12VOgcACpoxDQAAAAAAABS4pUuXRi6XiwkTJqROAYCCZ0wDAAAAAAAABWzLli2xefPmGD16dFx00UWpcwCg4BnTAAAAAAAAQIGqr6+PpUuXxsUXXxx33HFH6hwAKArGNAAAAAAAAFCgXnrppdi/f39UV1dHeXl56hwAKArGNAAAAAAAAFCA9u7dG2vXro0bb7wxBg4cmDoHAIqGMQ0AAAAAAAAUmCzLoqamJsrLy6Oqqip1DgAUFWMaAAAAAAAAKDCbNm2K//7v/4777rsvOnXqlDoHAIqKMQ0AAAAAAAAUkBMnTsSyZcuiT58+MXz48NQ5AFB0jGkAAAAAAACggLz44otx6NChqK6ujrIyx30A0NR8uwIAAAAAAECB+Oqrr+K1116Lm2++Ofr37586BwCKkjENAAAAAAAAFIAsy2LJkiVxwQUXRGVlZeocAChaxjQAAAAAAABQAN57773YsWNHVFZWRvv27VPnAEDRMqYBAAAAAACAPHf8+PGoq6uL/v37x7Bhw1LnAEBRM6YBAAAAAACAPLdy5co4evRoVFdXRy6XS50DAEXNmAYAAAAAAADy2K5du+Ktt96K22+/Pfr06ZM6BwCKnjENAAAAAAAA5KnGxsZYtGhRdO7cOcaNG5c6BwBKgjENAAAAAAAA5Kk33ngjvvjii5gwYUJUVFSkzgGAkmBMAwAAAAAAAHno0KFDsWrVqrjyyivj2muvTZ0DACXDmAYAAAAAAADy0LJly+L06dMxadKkyOVyqXMAoGQY0wAAAAAAAECe2bp1a3z44YcxatSo6N69e+ocACgpxjQAAAAAAACQR+rr62PJkiXRs2fPuPvuu1PnAEDJMaYBAAAAAACAPLJmzZrYv39/VFdXR3l5eeocACg5xjQAAAAAAACQJ77++utYu3Zt3HjjjfHrX/86dQ4AlCRjGgAAAAAAAMgDWZbFkiVLom3btlFVVZU6BwBKljENAAAAAAAA5IH3338/Pvnkk7j//vujU6dOqXMAoGQZ0wAAAAAAAEBix48fj2effTZ++ctfxi233JI6BwBKmjENAAAAAAAAJLZixYo4evRoTJ48OXK5XOocAChpxjQAAAAAAACQ0GeffRZvv/12jBgxIvr06ZM6BwBKnjENAAAAAAAAJNLY2BiLFy+Ozp07x9ixY1PnAABhTAMAAAAAAADJvPHGG/HFF1/Egw8+GBUVFalzAIAwpgEAAAAAAIAkDh06FM8//3xcddVVMXjw4NQ5AMA/GNMAAAAAAABAAkuXLo3GxsaYNGlS5HK51DkAwD8Y0wAAAAAAAEAL+/jjj2PTpk1x7733Rrdu3VLnAAD/wpgGAAAAAAAAWlB9fX3U1NREr1694q677kqdAwD8L8Y0AAAAAAAA0ILWrFkT+/fvj8mTJ0d5eXnqHADgfzGmAQAAAAAAgBayZ8+eWLt2bdx0000xcODA1DkAwA8wpgEAAAAAAIAWkGVZLFmyJNq2bRtVVVWpcwCAH2FMAwAAAAAAAC3gvffei08//TQqKyujY8eOqXMAgB9hTAMAAAAAAADN7Pjx41FXVxf9+/ePm2++OXUOAPATjGkAAAAAAACgma1YsSKOHTsWkydPjlwulzoHAPgJxjQAAAAAAADQjHbu3BlvvfVWjBgxInr37p06BwD4GcY0AAAAAAAA0EwaGxtj8eLF0aVLlxgzZkzqHADgDBjTAAAAAAAAQDN5/fXX48svv4yJEydGRUVF6hwA4AwY0wAAAAAAAEAzOHjwYKxatSp+85vfxG9/+9vUOQDAGTKmAQAAAAAAgGawbNmyaGxsjIkTJ0Yul0udAwCcIWMaAAAAAAAAaGIff/xxbNq0Ke69997o1q1b6hwA4CwY0wAAAAAAAEATOnXqVNTU1MTFF18cd911V+ocAOAsGdMAAAAAAABAE1q9enXs378/qquro7y8PHUOAHCWjGkAAAAAAACgifz973+PV155JYYNGxYDBw5MnQMAnANjGgAAAAAAAGgCWZbFokWLol27djF+/PjUOQDAOTKmAQAAAAAAgCawfv362LlzZzzwwAPRvn371DkAwDkypgEAAAAAAIDz9N1338Xy5cvj8ssvjxtvvDF1DgBwHoxpAAAAAAAA4DwtW7YsTp06FZMnT45cLpc6BwA4D8Y0AAAAAAAAcB62bt0aH3zwQdxzzz3Rs2fP1DkAwHkypgEAAAAAAIBzdOrUqViyZEn07NkzRo4cmToHAGgCxjQAAAAAAABwjtasWRP79++PKVOmRHl5eeocAKAJGNMAAAAAAADAOfjqq69i7dq1MXTo0Bg4cGDqHACgiRjTAAAAAAAAwFnKsiwWLVoUF1xwQYwfPz51DgDQhIxpAAAAAAAA4CytX78+/va3v0VVVVV06NAhdQ4A0ISMaQAAAAAAAOAsfPfdd7F8+fIYOHBgDBkyJHUOANDEjGkAAAAAAADgLDz77LNx6tSpmDx5cuRyudQ5AEATM6YBAAAAAACAM7Rt27Z4//33Y+TIkdGrV6/UOQBAMzCmAQAAAAAAgDNQX18fixcvjh49esTIkSNT5wAAzcSYBgAAAAAAAM7AmjVrYt++fTF58uRo3bp16hwAoJkY0wAAAAAAAMDP+Oqrr2Lt2rVx0003xa9//evUOQBAMzKmAQAAAAAAgJ+QZVksXrw4KioqoqqqKnUOANDMjGkAAAAAAADgJ7zzzjvx17/+NcaPHx8dO3ZMnQMANDNjGgAAAAAAAPgRR44cibq6urjsssti6NChqXMAgBZgTAMAAAAAAAA/4tlnn42TJ0/G5MmTI5fLpc4BAFqAMQ0AAAAAAAD8gG3btsV7770XI0eOjIsvvjh1DgDQQsrP5EO5XG5XRByJiNMR0ZBl2fXNGQUAAAAAAAAp1dfXx5IlS6JHjx5xzz33pM4BAFrQGY1p/uH2LMv2N1sJAAAAAAAA5Ik1a9bE3r174//+3/8brVu3Tp0DALQg1zwBAAAAAADAv9izZ0+sXbs2brzxxhg0aFDqHACghZ3pmCaLiFdyudyHuVzukR/6QC6XeySXy23M5XIb9+3b13SFAAAAAAAA0EKyLIvFixdH27Zt44EHHkidAwAkcKZjmmFZll0bEfdExP8nl8vd+r8/kGXZk1mWXZ9l2fXdu3dv0kgAAAAAAABoCe+8807s2LEjqqqqomPHjqlzAIAEzmhMk2XZV//4d29ErIiI3zVnFAAAAAAAALS0I0eORF1dXfzqV7+KoUOHps4BABL52TFNLpdrn8vlOv7P/yPi7oj4uLnDAAAAAAAAoCXV1dXFyZMnY8qUKZHL5VLnAACJlJ/BZ3pGxIp/PDCUR8SSLMtebtYqAAAAAAAAaEHbt2+Pd999N0aNGhUXX3xx6hwAIKGfHdNkWbYzIq5pgRYAAAAAAABocfX19bF48eLo3r17jBo1KnUOAJDYz17zBAAAAAAAAMXspZdeir1798bkyZOjdevWqXMAgMSMaQAAAAAAAChZe/bsiZdffjl+97vfxaBBg1LnAAB5wJgGAAAAAACAkpRlWSxcuDAqKipiwoQJqXMAgDxhTAMAAAAAAEBJevvtt+Nvf/tbVFVVRceOHVPnAAB5wpgGAAAAAACAknPo0KF47rnn4vLLL48hQ4akzgEA8ogxDQAAAAAAACVn6dKl0dDQEFOmTIlcLpc6BwDII8Y0AAAAAAAAlJTNmzfHpk2bYvTo0dGjR4/UOQBAnjGmAQAAAAAAoGScOHEiampq4pJLLom77rordQ4AkIeMaQAAAAAAACgZzz//fBw6dCimTp0a5eXlqXMAgDxkTAMAAAAAAEBJ2LVrV7zxxhsxfPjw6N+/f+ocACBPGdMAAAAAAABQ9E6fPh0LFy6Mzp07x/333586BwDIY8Y0AAAAAAAAFL1XX301vvzyy6iuro6KiorUOQBAHjOmAQAAAAAAoKjt27cvXnjhhRg8eHBcc801qXMAgDxnTAMAAAAAAEDRyrIsFi9eHK1atYqJEyemzgEACoAxDQAAAAAAAEXrvffei23btkVlZWV06dIldQ4AUACMaQAAAAAAAChKR44ciWXLlsWAAQPi1ltvTZ0DABQIYxoAAAAAAACKUl1dXZw4cSKmTJkSuVwudQ4AUCCMaQAAAAAAACg627Zti3fffTd+//vfxyWXXJI6BwAoIMY0AAAAAAAAFJVTp07FokWLokePHjFq1KjUOQBAgTGmAQAAAAAAoKi8+OKLsX///pg6dWq0bt06dQ4AUGCMaQAAAAAAACgaX375Zaxbty6GDRsWAwcOTJ0DABQgYxoAAAAAAACKQmNjYyxcuDDat28f48ePT50DABQoYxoAAAAAAACKwptvvhm7du2KBx98MNq3b586BwAoUMY0AAAAAAAAFLxvv/02Vq5cGVdeeWVcf/31qXMAgAJmTAMAAAAAAEBBy7IsampqIsuyqK6ujlwulzoJAChgxjQAAAAAAAAUtI8++ii2bNkSY8eOjW7duqXOAQAKnDENAAAAAAAABev48eNRU1MTffr0iTvuuCN1DgBQBIxpAAAAAAAAKFgrVqyII0eOxNSpU6OszNEXAHD+PFEAAAAAAABQkP7617/GW2+9FXfccUf07ds3dQ4AUCSMaQAAAAAAACg4DQ0NsWjRoujatWuMHTs2dQ4AUESMaQAAAAAAACg4L7/8cuzZsyeqq6ujbdu2qXMAgCJiTAMAAAAAAEBB+frrr+Oll16KG264Ia666qrUOQBAkTGmAQAAAAAAoGBkWRaLFi2KNm3axIQJE1LnAABFyJgGAAAAAACAgrF+/frYsWNHVFVVRadOnVLnAABFyJgGAAAAAACAgnDo0KGoq6uLyy+/PIYOHZo6BwAoUsY0AAAAAAAAFITa2to4ffp0TJkyJXK5XOocAKBIGdMAAAAAAACQ9zZt2hQfffRRjBkzJnr06JE6BwAoYsY0AAAAAAAA5LXjx49HTU1N9OnTJ+66667UOQBAkTOmAQAAAAAAIK8999xzcfTo0Zg2bVqUlTneAgCal6cNAAAAAAAA8tYnn3wS69evj7vuuisuvfTS1DkAQAkwpgEAAAAAACAv1dfXx8KFC6N79+4xZsyY1DkAQIkwpgEAAAAAACAvvfDCC7Fv376YOnVqtG7dOnUOAFAijGkAAAAAAADIO59//nmsW7cuhg0bFpdffnnqHACghBjTAAAAAAAAkFcaGxtjwYIF0aFDh6iqqkqdAwCUGGMaAAAAAAAA8sqrr74aX3zxRUyaNCnatWuXOgcAKDHGNAAAAAAAAOSNvXv3xqpVq+K3v/1tDB48OHUOAFCCjGkAAAAAAADIC1mWxaJFi6JVq1YxadKkyOVyqZMAgBJkTAMAAAAAAEBeeOedd+KTTz6Jqqqq6NKlS+ocAKBEGdMAAAAAAACQ3OHDh6Ouri4uu+yyuPnmm1PnAAAlzJgGAAAAAACA5Gpra+PUqVMxdepU1zsBAEkZ0wAAAAAAAJDUX/7yl9i0aVOMHj06evbsmToHAChxxjQAAAAAAAAk8/3330dNTU307t077r777tQ5AADGNAAAAAAAAKSzfPnyOHz4cEybNi1atWqVOgcAwJgGAAAAAACANHbs2BFvvfVW3HnnndG3b9/UOQAAEWFMAwAAAAAAQAL19fWxcOHC6NatW4wZMyZ1DgDAPxnTAAAAAAAA0OJWr14d33zzTUyZMiXatm2bOgcA4J+MaQAAAAAAAGhRX375ZaxduzaGDh0agwYNSp0DAPBvjGkAAAAAAABoMY2NjbFgwYJo3759VFVVpc4BAPgPxjQAAAAAAAC0mNdffz12794dEydOjPbt26fOAQD4D8Y0AAAAAAAAtIj9+/fHypUr4+qrr47rrrsudQ4AwA8ypgEAAAAAAKDZZVkWixYtilatWkV1dXXkcrnUSQAAP8iYBgAAAAAAgGb37rvvxrZt26KysjIuvPDC1DkAAD/KmAYAAAAAAIBm9d1338WyZctiwIABceutt6bOAQD4ScY0AAAAAAAANKulS5fGqVOnYtq0aa53AgDynjENAAAAAAAAzWbLli2xcePGuPfee6NXr16pcwAAfpYxDQAAAAAAAM3i+++/j8WLF8cll1wSd999d+ocAIAzYkwDAAAAAABAs3juuefi8OHDMX369CgvL0+dAwBwRoxpAAAAAAAAaHKffPJJvP3223HXXXdFv379UucAAJwxYxoAAAAAAACa1MmTJ2PBggXRo0ePGDNmTOocAICzYkwDAAAAAABAk1q1alXs378/pk6dGm3atEmdAwBwVoxpAAAAAAAAaDKfffZZvPbaa3HrrbfGwIEDU+cAAJw1YxoAAAAAAACaRENDQ8yfPz+6dOkS48ePT50DAHBOjGkAAAAAAABoEmvWrIk9e/bElClToqKiInUOAMA5MaYBAAAAAADgvH355Zfx0ksvxU033RRXXXVV6hwAgHNmTAMAAAAAAMB5aWxsjAULFkT79u1jwoQJqXMAAM6LMQ0AAAAAAADnZd26dbF79+6YNGlStG/fPnUOAMB5MaYBAAAAAADgnH3zzTfxwgsvxODBg+Paa69NnQMAcN6MaQAAAAAAADgnWZbFwoULo3Xr1jFp0qTI5XKpkwAAzpsxDQAAAAAAAOfkT3/6U+zYsSMeeOCB6Ny5c+ocAIAmYUwDAAAAAADAWTtw4EAsX748rrjiihgyZEjqHACAJmNMAwAAAAAAwFnJsiwWL14cERFTpkxxvRMAUFSMaQAAAAAAADgr7733XmzdujXuv//+6Nq1a+ocAIAmZUwDAAAAAADAGfvuu+9i6dKlMWDAgLjttttS5wAANDljGgAAAAAAAM5YTU1NnDp1KqZPn+56JwCgKBnTAAAAAAAAcEY++uij2LRpU4wePTp69uyZOgcAoFkY0wAAAAAAAPCzjh07FkuWLIk+ffrE3XffnToHAKDZGNMAAAAAAADws+rq6uLo0aMxffr0aNWqVeocAIBmY0wDAAAAAADAT9q6dWu88847MXLkyOjTp0/qHACAZmVMAwAAAAAAwI86ceJELFq0KHr16hWjRo1KnQMA0OyMaQAAAAAAAPhRK1asiIMHD8b06dOjdevWqXMAAJqdMQ0AAAAAAAA/aMeOHfHmm2/GiBEjon///qlzAABahDENAAAAAAAA/6G+vj4WLlwYXbt2jXHjxqXOAQBoMcY0AAAAAAAA/IcXXnghvvnmm5g6dWq0bds2dQ4AQIsxpgEAAAAAAODf7N69O9atWxfDhg2LQYMGpc4BAGhRxjQAAAAAAAD80+nTp2PBggXRsWPHqKqqSp0DANDijGkAAAAAAAD4p7Vr18aXX34ZkydPjnbt2qXOAQBoccY0AAAAAAAARETEV199FatXr47rr78+rrnmmtQ5AABJGNMAAAAAAAAQjY2NMX/+/KioqIiJEyemzgEASMaYBgAAAAAAgFi3bl3s2rUrJk2aFB07dkydAwCQjDENAAAAAABAifv6669j1apVMXjw4LjuuutS5wAAJGVMAwAAAAAAUML+53qntm3bRnV1deRyudRJAABJGdMAAAAAAACUsNdffz127twZDz74YHTq1Cl1DgBAcsY0AAAAAAAAJWrv3r2xcuXKuPrqq+N3v/td6hwAgLxgTAMAAAAAAFCCsiyLBQsWROvWrWPy5MmudwIA+AdjGgAAAAAAgBL05ptvxo4dO+KBBx6ILl26pM4BAMgbxjQAAAAAAAAlZt++fbF8+fK46qqrYsiQIalzAADyijENAAAAAABACfmf653KyspiypQprncCAPhfjGkAAAAAAABKyFtvvRWffvppPPDAA3HhhRemzgEAyDvGNAAAAAAAACXiwIED8dxzz8WgQYNi2LBhqXMAAPKSMQ0AAAAAAEAJyLIsFi5cGBERU6dOdb0TAMCPMKYBAAAAAAAoAevXr49t27ZFVVVVdO3aNXUOAEDeMqYBAAAAAAAocgcPHoy6urq4/PLL45ZbbkmdAwCQ14xpAAAAAAAAitj/XO/U2NgY06ZNc70TAMDPMKYBAAAAAAAoYn/+859j69atUVlZGd26dUudAwCQ94xpAAAAAAAAitShQ4di2bJlcdlll8Vtt92WOgcAoCAY0wAAAAAAABShLMti8eLF0dDQ4HonAICzYEwDAAAAAABQhN5///3YsmVL3HfffdGjR4/UOQAABcOYBgAAAAAAoMh89913UVtbG/37948RI0akzgEAKCjGNAAAAAAAAEXkf653OnXqVEyfPj3KyhwHAQCcDU9PAAAAAAAARWTjxo3xl7/8JcaNGxe9evVKnQMAUHCMaQAAAAAAAIrEkSNHoqamJvr16xd33nln6hwAgIJkTAMAAAAAAFAkampq4uTJkzFjxgzXOwEAnCNPUQAAAAAAAEVg06ZN8eGHH8bo0aPj4osvTp0DAFCwjGkAAAAAAAAK3NGjR2PJkiVx6aWXxt133506BwCgoBnTAAAAAAAAFLja2to4fvx4TJ8+PVq1apU6BwCgoBnTAAAAAAAAFLDNmzfHBx98EKNGjYrevXunzgEAKHjGNAAAAAAAAAXq2LFjsWjRoujdu3fcc889qXMAAIqCMQ0AAAAAAECBWrZsWRw9ejRmzJjheicAgCZiTAMAAAAAAFCANm/eHO+++26MGjUq+vTpkzoHAKBoGNMAAAAAAAAUGNc7AQA0H2MaAAAAAACAAlNTU/PP653Ky8tT5wAAFBVjGgAAAAAAgALy0UcfxQcffBD33nuv650AAJqBMQ0AAAAAAECBOHLkSCxevDj69OnjeicAgGZiTAMAAAAAAFAgamtr4/jx4zFz5sxo1apV6hwAgKJkTAMAAAAAAFAAPvzww9i4cWOMHj06fvGLX6TOAQAoWsY0AAAAAAAAee7IkSOxZMmS6Nu3b4wcOTJ1DgBAUTOmAQAAAAAAyGNZlsWSJUvixIkTMWPGjCgrc7wDANCcPG0BAAAAAADksY0bN8amTZti7Nixcckll6TOAQAoesY0AAAAAAAAeeq7776Lmpqa+OUvfxl33XVX6hwAgJJgTAMAAAAAAJCHsiyLRYsWxcmTJ13vBADQgjx1AQAAAAAA5KH3338/Nm/eHOPGjYtevXqlzgEAKBnGNAAAAAAAAHnm8OHDUVtbG/37948777wzdQ4AQEkxpgEAAAAAAMgj/3O9U319veudAAAS8PQFAAAAAACQR957773YsmVL3HfffdGzZ8/UOQAAJceYBgAAAAAAIE8cOnQoamtr41e/+lWMGDEidQ4AQEkypgEAAAAAAMgDWZbFwoULo6GhIaZPn+56JwCARDyFAQAAAAAA5IE///nP8fHHH8f48eOjR48eqXMAAEqWMQ0AAAAAAEBiBw8ejKVLl8bAgQPjtttuS50DAFDSjGkAAAAAAAASyrIsFixYEFmWxfTp0yOXy6VOAgAoacY0AAAAAAAACa1fvz7++7//OyorK6Nbt26pcwAASp4xDQAAAAAAQCIHDhyIurq6+PWvfx3Dhw9PnQMAQBjTAAAAAAAAJPGv1ztNmzbN9U4AAHnCmAYAAAAAACCBt99+O7Zv3x5VVVXRtWvX1DkAAPyDMQ0AAAAAAEAL279/f9TV1cWgQYPilltuSZ0DAMC/MKYBAAAAAABoQf9zvVMul3O9EwBAHjKmAQAAAAAAaEF/+tOf4pNPPokHHnggLrrootQ5AAD8L8Y0AAAAAAAALWTfvn3x3HPPxZVXXhnDhg1LnQMAwA8wpgEAAAAAAGgBWZbF/Pnzo1WrVjF16lTXOwEA5CljGgAAAAAAgBbw+uuvx44dO2LChAlx4YUXps4BAOBHGNMAAAAAAAA0s6+//jpWrFgRV199dQwZMiR1DgAAP8GYBgAAAAAAoBk1NjbG008/HW3atHG9EwBAATCmAQAAAAAAaEYvv/xy7Nq1KyZPnhydOnVKnQMAwM8wpgEAAAAAAGgmX3zxRbz44otxww03xHXXXZc6BwCAM2BMAwAAAAAA0AwaGhri6aefjvbt28ekSZNS5wAAcIaMaQAAAAAAAJrBiy++GH//+99j2rRp0b59+9Q5AACcIWMaAAAAAACAJrZz5854+eWXY9iwYfGb3/wmdQ4AAGfBmAYAAAAAAKAJnTp1Kp5++um46KKLYsKECalzAAA4S8Y0AAAAAAAATWj58uWxd+/emD59elRUVKTOAQDgLBnTAAAAAAAANJHt27fHG2+8ESNGjIjLL788dQ4AAOfAmAYAAAAAAKAJnDhxIubPnx89e/aM+++/P3UOAADnyJgGAAAAAACgCSxbtiwOHjwYM2bMiDZt2qTOAQDgHBnTAAAAAAAAnKctW7bEhg0bYuTIkdG/f//UOQAAnAdjGgAAAAAAgPNw7NixWLhwYfTu3TtGjx6dOgcAgPNkTAMAAAAAAHAelixZEseOHYuZM2dGeXl56hwAAM6TMQ0AAAAAAMA52rhxY2zcuDFGjx4dvXv3Tp0DAEATMKYBAAAAAAA4B4cPH44lS5ZEv379YuTIkalzAABoIsY0AAAAAAAAZynLsli0aFGcOnUqZs6cGWVljlwAAIqFJzsAAAAAAICz9Oc//zm2bNkS999/f/Tq1St1DgAATciYBgAAAAAA4CwcOHAgli5dGgMHDowRI0akzgEAoIkZ0wAAAAAAAJyhLMtiwYIFkWVZTJ8+PXK5XOokAACamDENAAAAAADAGXrzzTdj+/bt8cADD0S3bt1S5wAA0AyMaQAAAAAAAM7AN998E88991xcddVVcfPNN6fOAQCgmRjTAAAAAAAA/IzGxsZ45plnonXr1jF16lTXOwEAFDFjGgAAAAAAgJ+xbt262LlzZ0yaNCm6dOmSOgcAgGZkTAMAAAAAAPAT/v73v8eqVavi2muvjRtuuCF1DgAAzcyYBgAAAAAA4Ec0NDTE008/HRdccEFUV1e73gkAoAQY0wAAAAAAAPyI1atXxxdffBFTp06Njh07ps4BAKAFGNMAAAAAAAD8gF27dsXLL78cQ4YMiWuuuSZ1DgAALcSYBgAAAAAA4H85depUzJs3Lzp37hwTJkxInQMAQAsypgEAAAAAAPhfli9fHt98803MmDEj2rVrlzoHAIAWZEwDAAAAAADwL7Zt2xZvvPFG3HHHHfHrX/86dQ4AAC3MmAYAAAAAAOAfjh8/Hs8880xcfPHFcf/996fOAQAgAWMaAAAAAACAf1iyZEl89913MXPmzGjdunXqHAAAEjCmAQAAAAAAiIiNGzfGBx98EKNHj46+ffumzgEAIBFjGgAAAAAAoOQdOnQoFi9eHL/85S/jnnvuSZ0DAEBCxjQAAAAAAEBJy7IsFixYEPX19TFz5swoK3N8AgBQyjwNAgAAAAAAJe1Pf/pTbN26NaqqqqJnz56pcwAASMyYBgAAAAAAKFnffPNN1NXVxZVXXhnDhw9PnQMAQB4wpgEAAAAAAEpSY2NjzJs3L1q3bh3Tpk2LXC6XOgkAgDxgTAMAAAAAAJSkNWvWxK5du2Ly5MnRpUuX1DkAAOQJYxoAAAAAAKDk7N69O1avXh2/+93v4vrrr0+dAwBAHjGmAQAAAAAASkp9fX3MmzcvOnXqFJMmTUqdAwBAnjGmAQAAAAAASsry5cvj66+/jhkzZkS7du1S5wAAkGeMaQAAAAAAgJKxbdu2eP311+P222+PQYMGpc4BACAPGdMAAAAAAAAl4fjx4zF//vzo2bNnVFZWps4BACBPGdMAAAAAAAAloba2Ng4fPhyzZs2KNm3apM4BACBPGdMAAAAAAABF78MPP4z33nsv7r333ujXr1/qHAAA8pgxDQAAAAAAUNQOHToUixcvjn79+sU999yTOgcAgDxnTAMAAAAAABStLMtiwYIFcerUqZg1a1a0atUqdRIAAHnOmAYAAAAAAChab731VmzdujWqqqqiZ8+eqXMAACgAxjQAAAAAAEBR2rt3b9TV1cUVV1wRw4cPT50DAECBMKYBAAAAAACKTmNjY8ybNy/Ky8tj+vTpkcvlUicBAFAgjGkAAAAAAICi8/LLL8dnn30W1dXV0aVLl9Q5AAAUEGMaAAAAAACgqOzevTteeOGFuOGGG+KGG25InQMAQIExpgEAAAAAAIpGfX19PP3009GpU6eYNGlS6hwAAAqQMQ0AAAAAAFA0VqxYEXv27Inp06dH+/btU+cAAFCAjGkAAAAAAICisH379njttdfitttuiyuuuCJ1DgAABcqYBgAAAAAAKHjHjx+PZ555Jnr27Bnjx49PnQMAQAEzpgEAAAAAAApeTU1NHD58OGbNmhVt2rRJnQMAQAEzpgEAAAAAAAra+++/H++//36MHj06+vXrlzoHAIACZ0wDAAAAAAAUrG+//TaWLFkS/fv3j3vuuSd1DgAARcCYBgAAAAAAKEiNjY3x9NNPR2NjY8yaNSvKyhx7AABw/jxVAgAAAAAABenVV1+NTz/9NCZOnBjdu3dPnQMAQJEwpgEAAAAAAArOF198EStXrozBgwfHkCFDUucAAFBEjGkAAAAAAICCUl9fH3Pnzo0OHTrElClTIpfLpU4CAKCIGNMAAAAAAAAFZfny5bFnz56YPn16dOjQIXUOAABFxpgGAAAAAAAoGFu3bo3XX389RowYEVdeeWXqHAAAipAxDQAAAAAAUBCOHTsW8+fPj4svvjgqKytT5wAAUKSMaQAAAAAAgLyXZVksXLgwjh49GrNnz47WrVunTgIAoEgZ0wAAAAAAAHnvz3/+c3z00Udx3333RZ8+fVLnAABQxIxpAAAAAACAvLZ///6ora2NgQMHxp133pk6BwCAImdMAwAAAAAA5K3GxsaYN29elJWVxcyZM6OszNEGAADNyxMnAAAAAACQt15++eX429/+FpMnT46LLroodQ4AACXAmAYAAAAAAMhLu3btihdeeCF+97vfxQ033JA6BwCAEmFMAwAAAAAA5J2TJ0/G3Llzo3PnzjFp0qTUOQAAlBBjGgAAAAAAIO/U1dXFvn37YtasWdGuXbvUOQAAlBBjGgAAAAAAIK9s2bIl3nrrrbj77rtj4MCBqXMAACgxxjQAAAAAAEDe+O6772LBggXRp0+fGDt2bOocAABKkDENAAAAAACQF7IsiwULFsT3338fs2bNivLy8tRJAACUIGMaAAAAAAAgL7z99tvxX//1XzF+/Pi45JJLUucAAFCiznhMk8vlWuVyuY9yudyLzRkEAAAAAACUnm+++SaWLVsWV1xxRdx+++2pcwAAKGFn85dp/r8Rsa25QgAAAAAAgNJ0+vTpmDt3brRp0yamT58euVwudRIAACXsjMY0uVyud0TcGxFPNW8OAAAAAABQal588cXYvXt3TJ06Nbp06ZI6BwCAEnemf5nm/42I/19ENP7YB3K53CO5XG5jLpfbuG/fvqZoAwAAAAAAitzf/va3eOmll2Lo0KExePDg1DkAAPDzY5pcLjc6IvZmWfbhT30uy7Insyy7Psuy67t3795kgQAAAAAAQHE6ceJEzJs3L7p27RoPPvhg6hwAAIiIM/vLNMMiYmwul9sVEbURMSKXyy1q1ioAAAAAAKDoLV26NA4cOBCzZs2KioqK1DkAABARZzCmybLs/8myrHeWZf0iYmJEvJ5l2ZRmLwMAAAAAAIrWpk2b4p133olRo0bFgAEDUucAAMA/nclfpgEAAAAAAGgyBw8ejIULF0a/fv3i3nvvTZ0DAAD/pvxsPpxl2ZsR8WazlAAAAAAAAEWvsbEx5s2bF6dPn47Zs2dHq1atUicBAMC/8ZdpAAAAAACAFvPKK6/Ep59+GhMnTowePXqkzgEAgP9gTAMAAAAAALSIXbt2xfPPPx/XXXddDBkyJHUOAAD8IGMaAAAAAACg2Z08eTLmzp0bnTt3jilTpkQul0udBAAAP8iYBgAAAAAAaHZLly6Nffv2xaxZs6Jdu3apcwAA4EcZ0wAAAAAAAM1q06ZNsWHDhhg5cmQMHDgwdQ4AAPwkYxoAAAAAAKDZHDx4MBYuXBj9+vWLMWPGpM4BAICfZUwDAAAAAAA0i8bGxpg3b16cPn06Zs+eHa1atUqdBAAAP8uYBgAAAAAAaBavvPJKfPrppzFx4sTo0aNH6hwAADgjxjQAAAAAAECT27VrVzz//PNx3XXXxZAhQ1LnAADAGTOmAQAAAAAAmtTJkydj7ty50blz55gyZUrkcrnUSQAAcMaMaQAAAAAAgCa1dOnS2LdvX8yaNSvatWuXOgcAAM6KMQ0AAAAAANBkNm3aFBs2bIiRI0fGwIEDU+cAAMBZM6YBAAAAAACaxMGDB2PhwoXRr1+/GDNmTOocAAA4J8Y0AAAAAADAeWtsbIx58+bF6dOnY/bs2dGqVavUSQAAcE6MaQAAAAAAgPP2yiuvxKeffhoTJ06MHj16pM4BAIBzZkwDAAAAAACcl127dsXzzz8f1113XQwZMiR1DgAAnBdjGgAAAAAA4JydPHky5s6dG507d44pU6ZELpdLnQQAAOfFmAYAAAAAADhnS5cujX379sWsWbOiXbt2qXMAAOC8GdMAAAAAAADnZNOmTbFhw4YYOXJkDBw4MHUOAAA0CWMaAAAAAADgrB08eDAWLlwY/fr1izFjxqTOAQCAJmNMAwAAAAAAnJXGxsaYN29enD59OmbPnh2tWrVKnQQAAE3GmAYAAAAAADgrr7zySnz66acxceLE6NGjR+ocAABoUsY0AAAAAADAGdu9e3c8//zzcd1118WQIUNS5wAAQJMzpgEAAAAAAM7IyZMn46mnnorOnTvHlClTIpfLpU4CAIAmZ0wDAAAAAACckaVLl8a+ffti1qxZ0a5du9Q5AADQLIxpAAAAAACAn7Vp06bYsGFDjBw5MgYOHJg6BwAAmo0xDQAAAAAA8JMOHjwYCxcujH79+sWYMWNS5wAAQLMypgEAAAAAAH5UY2NjzJ07N06fPh2zZ8+OVq1apU4CAIBmZUwDAAAAAAD8qDVr1sSOHTti8uTJ0aNHj9Q5AADQ7IxpAAAAAACAH/TXv/41XnzxxbjpppvixhtvTJ0DAAAtwpgGAAAAAAD4D8ePH4+nnnoqunfvHpMmTUqdAwAALcaYBgAAAAAA+DdZlsXChQvj8OHD8dBDD0VFRUXqJAAAaDHGNAAAAAAAwL9Zv359bNq0Ke6///7o27dv6hwAAGhRxjQAAAAAAMA/7dmzJ5YuXRqDBg2Ku+66K3UOAAC0OGMaAAAAAAAgIiLq6+tjzpw5UVFREbNmzYpcLpc6CQAAWpwxDQAAAAAAEBERzz33XPz973+PGTNmRKdOnVLnAABAEsY0AAAAAABAbN68Od544424884746qrrkqdAwAAyRjTAAAAAABAiTt06FDMnz8/Lr300rj//vtT5wAAQFLGNAAAAAAAUMIaGxtj3rx50dDQEA899FCUl5enTgIAgKSMaQAAAAAAoIStXbs2Pvnkk5g4cWL07NkzdQ4AACRnTAMAAAAAACVq586dsWrVqrjhhhtiyJAhqXMAACAvGNMAAAAAAEAJOn78eDz11FNx0UUXxeTJkyOXy6VOAgCAvGBMAwAAAAAAJSbLsli8eHEcPHgwHnroobjgggtSJwEAQN4wpgEAAAAAgBLzzjvvxMaNG2PcuHHxy1/+MnUOAADkFWMaAAAAAAAoId98803U1tbGr3/96/j973+fOgcAAPKOMQ0AAAAAAJSIhoaGmDNnTrRu3TpmzpwZuVwudRIAAOQdYxoAAAAAACgRy5cvjy+++CJmzJgRXbp0SZ0DAAB5yZgGAAAAAABKwH/913/Fa6+9FiNGjIirr746dQ4AAOQtYxoAAAAAAChyhw8fjmeeeSZ69+4dlZWVqXMAACCvGdMAAAAAAEARy7Is5s2bF6dOnYqHH344WrdunToJAADymjENAAAAAAAUsVdeeSW2b98eEydOjF69eqXOAQCAvGdMAwAAAAAARWrXrl2xcuXKuP7662Po0KGpcwAAoCAY0wAAAAAAQBE6ceJEzJkzJy688MKYPHly5HK51EkAAFAQjGkAAAAAAKDIZFkWixcvjm+//TZmz54d7dq1S50EAAAFw5gGAAAAAACKzHvvvRfvv/9+jBkzJgYMGJA6BwAACooxDQAAAAAAFJFvvvkmlixZEgMHDoyRI0emzgEAgIJjTAMAAAAAAEWivr4+nnzyyWjdunXMnj07ysocAwAAwNnyFA0AAAAAAEWirq4uvvzyy5g5c2Z06dIldQ4AABQkYxoAAAAAACgCmzZtijfffDPuvvvuuOqqq1LnAABAwTKmAQAAAACAAnfgwIFYsGBB9OvXL8aNG5c6BwAACpoxDQAAAAAAFLDTp0/HU089FRERDz/8cJSXlycuAgCAwmZMAwAAAAAABez555+PnTt3xrRp06Jbt26pcwAAoOAZ0wAAAAAAQIHaunVrrF27Nm699da49tprU+cAAEBRMKYBAAAAAIACdOjQoXj66aejd+/eMWHChNQ5AABQNIxpAAAAAACgwDQ2Nsa8efPi5MmT8fDDD0fr1q1TJwEAQNEwpgEAAAAAgALz0ksvxSeffBKTJk2KXr16pc4BAICiYkwDAAAAAAAFZMeOHfHCCy/EjTfeGEOGDEmdAwAARceYBgAAAAAACsTRo0fjqaeeiu7du0d1dXXkcrnUSQAAUHSMaQAAAAAAoABkWRbz58+Po0ePxiOPPBIVFRWpkwAAoCgZ0wAAAAAAQAF47bXXYsuWLVFVVRV9+vRJnQMAAEXLmAYAAAAAAPLc7t27Y/ny5fHb3/42brvtttQ5AABQ1IxpAAAAAAAgj33//ffx5JNPRufOnWPatGmRy+VSJwEAQFEzpgEAAAAAgDyVZVksWrQovv3223jooYeiffv2qZMAAKDoGdMAAAAAAECeWr9+fWzcuDHGjh0bAwYMSJ0DAAAlwZgGAAAAAADy0FdffRVLly6NQYMGxciRI1PnAABAyTCmAQAAAACAPHPq1Kl48skn44ILLohZs2ZFLpdLnQQAACXDmAYAAAAAAPJMbW1tfP311zFr1qzo1KlT6hwAACgpxjQAAAAAAJBHPvjgg9iwYUOMHDkyBg0alDoHAABKjjENAAAAAADkib1798bChQtjwIABMXbs2NQ5AABQkoxpAAAAAAAgDzQ0NMScOXOiVatW8dBDD0VZmVf4AACQgidxAAAAAADIA8uXL4/PP/88ZsyYERdddFHqHAAAKFnGNAAAAAAAkNjmzZvjtddeixEjRsQ111yTOgcAAEqaMQ0AAAAAACT07bffxvz58+PSSy+N8ePHp84BAICSZ0wDAAAAAACJnD59OubMmROnT5+Ohx9+OMrLy1MnAQBAyTOmAQAAAACARFauXBk7d+6MqVOnRo8ePVLnAAAAYUwDAAAAAABJbNmyJV555ZW47bbb4vrrr0+dAwAA/IMxDQAAAAAAtLADBw7E008/HX369ImqqqrUOQAAwL8wpgEAAAAAgBbU0NAQc+bMicbGxnj00UejdevWqZMAAIB/YUwDAAAAAAAtaOXKlfHZZ5/FtGnTonv37qlzAACA/8WYBgAAAAAAWsjmzZtj3bp1cdttt8V1112XOgcAAPgBxjQAAAAAANACDhw4EM8880xceuml8cADD6TOAQAAfoQxDQAAAAAANLOGhoaYM2dONDY2xiOPPBLl5eWpkwAAgB9hTAMAAAAAAM1sxYoV8dlnn8X06dOje/fuqXMAAICfYEwDAAAAAADNaPPmzfHqq6/G7bffHtdee23qHAAA4GcY0wAAAAAAQDM5cOBAPPPMM3HppZdGVVVV6hwAAOAMGNMAAAAAAEAzaGhoiCeffDIaGxvjkUceifLy8tRJAADAGTCmAQAAAACAZrBixYrYtWtXTJ8+Pbp37546BwAAOEPGNAAAAAAA0MQ2b94cr776atx+++1x7bXXps4BAADOgjENAAAAAAA0oQMHDsQzzzwTffv2jaqqqtQ5AADAWTKmAQAAAACAJtLQ0BBPPvlkZFkWjzzySJSXl6dOAgAAzpIxDQAAAAAANJHly5fHrl27Yvr06dGtW7fUOQAAwDkwpgEAAAAAgCbwl7/8JV577bUYMWJEDB48OHUOAABwjoxpAAAAAADgPO3fvz/mz58fffv2jfHjx6fOAQAAzoMxDQAAAAAAnIeGhoaYM2dOZFkWjzzySJSXl6dOAgAAzoMxDQAAAAAAnIfly5fHrl27Yvr06dGtW7fUOQAAwHkypgEAAAAAgHP00UcfxWuvvRZ33HFHDB48OHUOAADQBIxpAAAAAADgHOzfvz/mz58f/fr1i8rKytQ5AABAEzGmAQAAAACAs9TQ0BBPPvlkREQ8/PDDUV5enrgIAABoKsY0AAAAAABwlp577rnYvXt3TJ8+Pbp165Y6BwAAaELGNAAAAAAAcBY++uijeP311+OOO+6IwYMHp84BAACamDENAAAAAACcob1798YzzzwT/fr1i8rKytQ5AABAMzCmAQAAAACAM1BfXx9PPPFEtGrVKh555JEoLy9PnQQAADQDYxoAAAAAADgDNTU18eWXX8asWbOia9euqXMAAIBmYkwDAAAAAAA/45133okNGzbEqFGj4qqrrkqdAwAANCNjGgAAAAAA+Al///vfY8mSJXH55ZfHmDFjUucAAADNzJgGAAAAAAB+xIkTJ+Lxxx+Pdu3axUMPPRRlZV6rAwBAsfPUDwAAAAAAPyDLsliwYEHs378/Hn744ejUqVPqJAAAoAUY0wAAAAAAwA9444034sMPP4z77rsvLrvsstQ5AABACzGmAQAAAACA/2Xnzp1RV1cX11xzTdx9992pcwAAgBZkTAMAAAAAAP/i2LFj8eSTT0aXLl1ixowZkcvlUicBAAAtyJgGAAAAAAD+IcuymDt3bhw5ciQeffTRaNeuXeokAACghRnTAAAAAADAP7z00kuxdevWePDBB6Nv376pcwAAgASMaQAAAAAAICK2b98eq1atihtvvDFuueWW1DkAAEAixjQAAAAAAJS8Q4cOxVNPPRW9evWKyZMnRy6XS50EAAAkYkwDAAAAAEBJO336dMyZMydOnToVjz76aLRt2zZ1EgAAkJAxDQAAAAAAJW3lypXx17/+NaZMmRIXX3xx6hwAACAxYxoAAAAAAErW5s2b45VXXonhw4fH7373u9Q5AABAHjCmAQAAAACgJO3fvz+efvrp6Nu3b0yYMCF1DgAAkCeMaQAAAAAAKDn19fXx+OOPRy6Xi0cffTTKy8tTJwEAAHnCmAYAAAAAgJKzbNmy+OKLL2LmzJnRtWvX1DkAAEAeMaYBAAAAAKCkvPvuu/HWW2/FyJEj4+qrr06dAwAA5BljGgAAAAAASsZXX30VixcvjoEDB8a4ceNS5wAAAHnImAYAAAAAgJJw4sSJePzxx6OioiIeeuihKCvzihwAAPhPfikAAAAAAFD0siyLRYsWxd69e+Phhx+Ozp07p04CAADylDENAAAAAABF709/+lN88MEHMW7cuBg4cGDqHAAAII8Z0wAAAAAAUNR27doVy5Yti9/85jcxcuTI1DkAAECeM6YBAAAAAKBoHTt2LJ588sno0qVLzJw5M3K5XOokAAAgzxnTAAAAAABQlBobG2Pu3Llx+PDheOSRR6J9+/apkwAAgAJgTAMAAAAAQFFavXp1bN26NR588MHo169f6hwAAKBAGNMAAAAAAFB0Pv7441i9enUMGTIkbrnlltQ5AABAATGmAQAAAACgqOzfvz/mzp0bv/jFL6K6ujpyuVzqJAAAoIAY0wAAAAAAUDTq6+vjiSeeiCzL4rHHHos2bdqkTgIAAAqMMQ0AAAAAAEWjpqYmPv/885g1a1Z07949dQ4AAFCAjGkAAAAAACgK69evjw0bNsSoUaPi6quvTp0DAAAUKGMaAAAAAAAK3u7du6OmpiauuOKKGDNmTOocAACggBnTAAAAAABQ0I4dOxZPPPFEdOrUKWbPnh1lZV59AwAA584vCgAAAAAAClZjY2PMnTs3Dh8+HI8++mh06NAhdRIAAFDgjGkAAAAAAChYq1evjq1bt8aDDz4Y/fr1S50DAAAUAWMaAAAAAAAK0scffxyrV6+OIUOGxC233JI6BwAAKBLGNAAAAAAAFJz9+/fH3Llz4xe/+EVUV1dHLpdLnQQAABQJYxoAAAAAAApKfX19PPHEE5FlWTz22GPRpk2b1EkAAEARMaYBAAAAAKCg1NTUxOeffx6zZs2K7t27p84BAACKjDENAAAAAAAFY8OGDbFhw4YYNWpUXH311alzAACAImRMAwAAAABAQdi9e3csWbIkBg0aFGPGjEmdAwAAFCljGgAAAAAA8t6xY8fiiSeeiI4dO8ZDDz0UZWVebwMAAM3Drw0AAAAAAPJalmUxb968OHz4cDz22GPRoUOH1EkAAEARM6YBAAAAACCvrV69Oj7++ON48MEHo1+/fqlzAACAImdMAwAAAABA3tq6dWu8+OKLcdNNN8Utt9ySOgcAACgBxjQAAAAAAOSlAwcOxFNPPRW/+MUvYvLkyZHL5VInAQAAJcCYBgAAAACAvFNfXx9PPPFEZFkWjz32WLRp0yZ1EgAAUCKMaQAAAAAAyDu1tbWxe/fumDVrVnTv3j11DgAAUEKMaQAAAAAAyCsbNmyI9evXxz333BNXX3116hwAAKDEGNMAAAAAAJA3Pv/881iyZEkMGjQoxo4dmzoHAAAoQcY0AAAAAADkhaNHj8bjjz8eHTt2jNmzZ0dZmVfYAABAy/NLBAAAAACA5BobG+Opp56Kw4cPxx/+8Ifo2LFj6iQAAKBEGdMAAAAAAJDcypUrY9u2bVFdXR19+/ZNnQMAAJQwYxoAAAAAAJLatGlTrF27Nm699dYYNmxY6hwAAKDEGdMAAAAAAJDMV199Fc8880z0798/HnzwwdQ5AAAAxjQAAAAAAKTx/fffxx//+Mdo27ZtPProo1FeXp46CQAAwJgGAAAAAICWl2VZzJs3L/bv3x+PPPJIdOnSJXUSAABARBjTAAAAAACQwJo1a2LLli0xYcKEuOyyy1LnAAAA/JMxDQAAAAAALerjjz+OF154IW666aa47bbbUucAAAD8G2MaAAAAAABazN69e+Opp56K3r17x5QpUyKXy6VOAgAA+DfGNAAAAAAAtIiTJ0/GH//4xygrK4s//OEP0bp169RJAAAA/8GYBgAAAACAZpdlWSxYsCD27NkTDz/8cHTt2jV1EgAAwA8ypgEAAAAAoNm9+uqrsXHjxrj//vtj0KBBqXMAAAB+lDENAAAAAADNavv27fHcc8/FtddeG3fffXfqHAAAgJ9kTAMAAAAAQLP59ttvY86cOdGrV6+YPn165HK51EkAAAA/yZgGAAAAAIBmUV9fH48//ng0NDTEH/7wh6ioqEidBAAA8LOMaQAAAAAAaHJZlkVNTU3s3r07Zs2aFT179kydBAAAcEaMaQAAAAAAaHJvv/12bNiwIe6999645pprUucAAACcMWMaAAAAAACa1M6dO6O2tjauuuqqGD16dOocAACAs2JMAwAAAABAk/nuu+/iiSeeiIsuuihmz54dZWVeQwMAAIXFrxgAAAAAAJpEQ0NDPPHEE3H8+PF47LHHol27dqmTAAAAzpoxDQAAAAAATaKuri7++te/xrRp06J3796pcwAAAM6JMQ0AAAAAAOft3XffjTfeeCPuvPPOuOGGG1LnAAAAnDNjGgAAAAAAzssXX3wRixYtioEDB8b48eNT5wAAAJwXYxoAAAAAAM7ZsWPH4o9//GN06NAhHnnkkSgr89oZAAAobH7VAAAAAABwThobG2POnDlx+PDheOyxx6Jjx46pkwAAAM6bMQ0AAAAAAOdkxYoVsW3btqiuro5+/fqlzgEAAGgSxjQAAAAAAJy1999/P1555ZW47bbbYtiwYalzAAAAmowxDQAAAAAAZ+Xzzz+PBQsWxGWXXRYTJkxInQMAANCkjGkAAAAAADhjR44ciT/+8Y/RoUOHePTRR6NVq1apkwAAAJqUMQ0AAAAAAGfk9OnT8eSTT8aRI0fiD3/4Q3Ts2DF1EgAAQJMzpgEAAAAA4Iw8++yz8emnn8bUqVOjb9++qXMAAACahTENAAAAAAA/65133ok33ngj7rrrrrjxxhtT5wAAADQbYxoAAAAAAH7SZ599FosXL45BgwZFZWVl6hwAAIBmZUwDAAAAAMCPOnz4cDz++OPRpUuXePjhh6OszGtlAACguPnVAwAAAADAD2poaIjHH388jh8/Hv/n//yfaN++feokAACAZmdMAwAAAADAf8iyLGpqamLnzp0xc+bM+MUvfpE6CQAAoEUY0wAAAAAA8B/eeuutWL9+fdxzzz1x7bXXps4BAABoMcY0AAAAAAD8mx07dkRtbW385je/ibFjx6bOAQAAaFHGNAAAAAAA/NPBgwfjiSeeiO7du8esWbOirMxrZAAAoLT4FQQAAAAAQERE1NfXxx//+Meor6+PP/zhD9GuXbvUSQAAAC3OmAYAAAAAgMiyLBYuXBi7d++O2bNnx8UXX5w6CQAAIAljGgAAAAAA4rXXXov33nsvxo4dG1dffXXqHAAAgGSMaQAAAAAASty2bduirq4uBg8eHKNGjUqdAwAAkJQxDQAAAABACdu/f3/MmTMnLr744pgxY0bkcrnUSQAAAEkZ0wAAAAAAlKiTJ0/G/5+9Pwu2sjzQPu5rbdiAIKggIAKiEG0VE6PRqNhO0eDUGGeJGkGCzDMxb9d38tV33lGRGQRUBEEco8R5CEqMijgSCAZUoog4MCgIAnt9B2/ernTaRNS9efbw+1VRBexVu67T567/eu5JkyalXC5n8ODBadasWdGTAAAACiemAQAAAABogMrlcm677basXbs2/fv3T7t27YqeBAAAUCuIaQAAAAAAGqBHHnkkL7/8ci6++OJ079696DkAAAC1hpgGAAAAAKCBefPNN/PAAw/k+OOPz09/+tOi5wAAANQqYhoAAAAAgAbkww8/zC233JJOnTrlmmuuSalUKnoSAABArSKmAQAAAABoILZt25bJkyenUaNGGTx4cJo0aVL0JAAAgFpHTAMAAAAA0ABUVVVlxowZ+fDDDzNgwIC0adOm6EkAAAC1kpgGAAAAAKAB+O1vf5vXX389l19+ef7t3/6t6DkAAAC1lpgGAAAAAKCee+mll/Lwww/nlFNOyemnn170HAAAgFpNTAMAAAAAUI+98847ue2223LooYemd+/eKZVKRU8CAACo1cQ0AAAAAAD11KZNmzJ58uS0atUqAwcOTOPGjYueBAAAUOuJaQAAAAAA6qEdO3Zk8uTJ+eKLLzJkyJC0bNmy6EkAAAB1gpgGAAAAAKCeKZfLueOOO/L222/n2muvTadOnYqeBAAAUGeIaQAAAAAA6pknnngif/zjH9OrV68cc8wxRc8BAACoU8Q0AAAAAAD1yJtvvpl77rknxx57bM4///yi5wAAANQ5YhoAAAAAgHpi3bp1mT59ejp27Ji+ffumVCoVPQkAAKDOEdMAAAAAANQDW7duzcSJE1NZWZkhQ4akadOmRU8CAACok8Q0AAAAAAB1XFVVVaZNm5ZPPvkkgwYNSps2bYqeBAAAUGeJaQAAAAAA6rh77rkny5cvz1VXXZXvfe97Rc8BAACo08Q0AAAAAAB12OLFi/PEE0/kJz/5SU4++eSi5wAAANR5YhoAAAAAgDpq1apVmTNnTo444ohcdtllRc8BAACoF8Q0AAAAAAB10KeffprJkyenTZs2ue6661JR4bgXAACgOni6AgAAAACoY7788stMmjQpO3bsyJAhQ9KiRYuiJwEAANQbYhoAAAAAgDqkXC7ntttuy3vvvZf+/funQ4cORU8CAACoV8Q0AAAAAAB1yMMPP5wlS5bkoosuyve///2i5wAAANQ7YhoAAAAAgDrilVdeyQMPPJATTjghPXv2LHoOAABAvSSmAQAAAACoA95///3MmjUrBx98cH7xi1+kVCoVPQkAAKBeEtMAAAAAANRyn3/+eSZOnJhmzZpl8ODBqaysLHoSAABAvSWmAQAAAACoxXbt2pWpU6dm06ZNGTJkSPbdd9+iJwEAANRrYhoAAAAAgFps3rx5WblyZa655pocfPDBRc8BAACo98Q0AAAAAAC11O9///ssWrQoZ599dk444YSi5wAAADQIYhoAAAAAgFpoxYoVmTdvXr7//e/nwgsvLHoOAABAg/G1MU2pVGpWKpVeLJVKr5VKpWWlUun/tyeGAQAAAAA0VB9++GGmTp2a9u3bp3///qmo8L1IAACAPaXxbnxme5KflMvlz0ulUmWS50ql0sPlcvmPNbwNAAAAAKDB2bp1ayZOnJiKiooMGzYszZo1K3oSAABAg/K1X2co/1+f/+2flX/7U67RVQAAAAAADdCuXbsyderUfPzxxxk8eHD233//oicBAAA0OLv1btBSqdSoVCq9mmR9ksfL5fILX/GZAaVSaUmpVFry0UcfVfNMAAAAAID6rVwuZ968eVmxYkWuvvrqfO973yt6EgAAQIO0WzFNuVzeVS6Xf5ikU5Ifl0qlo77iM9PK5fJx5XL5uLZt21bzTAAAAACA+u2ZZ57JokWLcvbZZ6dHjx5FzwEAAGiwdium+X/K5fLGJM8kOacmxgAAAAAANETLli3L/Pnzc/TRR+fCCy8seg4AAECD9rUxTalUalsqlfb929/3SnJWkhU1vAsAAAAAoEH44IMPMm3atHTs2DG//OUvU1Hxjb4DCQAAQDVrvBuf6ZDktlKp1Cj/N765q1wuP1SzswAAAAAA6r8tW7ZkwoQJqayszNChQ9O0adOiJwEAADR4XxvTlMvl15Mcswe2AAAAAAA0GDt37syUKVOycePGjB07Nq1bty56EgAAANmNa54AAAAAAKhe5XI5c+fOzcqVK3PNNdeka9euRU8CAADgb8Q0AAAAAAB72JNPPpnFixfnvPPOywknnFD0HAAAAP6OmAYAAAAAYA96/fXXc/fdd+fYY4/NBRdcUPQcAAAA/oGYBgAAAABgD1m7dm1uueWWdO7cOX379k2pVCp6EgAAAP9ATAMAAAAAsAd89tlnmTBhQpo1a5YhQ4akadOmRU8CAADgK4hpAAAAAABq2M6dOzN58uRs3rw5Q4YMyX777Vf0JAAAAP4JMQ0AAAAAQA0ql8uZPXt2Vq1alb59++bggw8uehIAAAD/gpgGAAAAAKAGPfroo/njH/+YXr165bjjjit6DgAAAF9DTAMAAAAAUENeeeWV3HfffTn++ONz/vnnFz0HAACA3SCmAQAAAACoAX/9618zc+bMHHzwwenTp09KpVLRkwAAANgNYhoAAAAAgGq2efPmTJw4MS1atMiQIUNSWVlZ9CQAAAB2k5gGAAAAAKAa7dixIxMnTsyWLVsydOjQ7LPPPkVPAgAA4BsQ0wAAAAAAVJNyuZzbbrst77zzTvr165fOnTsXPQkAAIBvSEwDAAAAAFBNfve73+Wll17KhRdemGOOOaboOQAAAHwLYhoAAAAAgGrw8ssv57e//W1OPPHEnHPOOUXPAQAA4FsS0wAAAAAAfEerV6/OrFmz0q1bt1x99dUplUpFTwIAAOBbEtMAAAAAAHwHn3zySSZNmpR99tkngwcPTmVlZdGTAAAA+A7ENAAAAAAA39IXX3yRCRMmZOfOnRk+fHhatmxZ9CQAAAC+IzENAAAAAMC3sGvXrkybNi3r1q3LoEGDcsABBxQ9CQAAgGogpgEAAAAA+IbK5XLmzZuXP/3pT7n66qtz+OGHFz0JAACAaiKmAQAAAAD4hp588sksWrQoZ599dk4++eSi5wAAAFCNxDQAAAAAAN/Aa6+9lrvvvjvHHHNMLrrooqLnAAAAUM3ENAAAAAAAu2nNmjW55ZZb0qVLl/Tr1y+lUqnoSQAAAFQzMQ0AAAAAwG7YsGFDJk6cmL333jtDhw5NkyZNip4EAABADRDTAAAAAAB8je3bt2fixInZtm1bhg0bllatWhU9CQAAgBoipgEAAAAA+Beqqqpyyy235L333st1112Xjh07Fj0JAACAGiSmAQAAAAD4F+6+++68/vrr6d27d4466qii5wAAAFDDxDQAAAAAAP/EM888kyeffDJnnnlmTj/99KLnAAAAsAeIaQAAAAAAvsKyZcsyb968/OAHP8ill15a9BwAAAD2EDENAAAAAMA/eP/99zNt2rR06tQp/fv3T0WFo1QAAICGwhMgAAAAAMDf2bx5cyZMmJBmzZpl6NChadq0adGTAAAA2IPENAAAAAAAf/Pll19m4sSJ+fzzzzN06NDst99+RU8CAABgDxPTAAAAAAAkKZfLmTVrVt599930798/Bx10UNGTAAAAKICYBgAAAAAgyX333ZelS5fm0ksvzdFHH130HAAAAAoipgEAAAAAGrzFixfn0Ucfzamnnpozzzyz6DkAAAAUSEwDAAAAADRoK1asyB133JEjjzwyvXv3TqlUKnoSAAAABRLTAAAAAAAN1rp16zJ16tQccMABGTBgQBo1alT0JAAAAAompgEAAAAAGqTPPvss48ePT6NGjTJs2LDstddeRU8CAACgFhDTAAAAAAANzo4dOzJ58uRs2rQpQ4YMSZs2bYqeBAAAQC0hpgEAAAAAGpRyuZxbb701q1atyrXXXpuuXbsWPQkAAIBaREwDAAAAADQo9913X5YsWZJLLrkkP/rRj4qeAwAAQC0jpgEAAAAAGoxFixbl0UcfzWmnnZaf/vSnRc8BAACgFhLTAAAAAAANwptvvpm5c+fm+9//fnr37p1SqVT0JAAAAGohMQ0AAAAAUO+tWbMm06ZNS+fOnXPdddelosLRKAAAAF/NEyMAAAAAUK99+umnGT9+fFq0aJFhw4aladOmRU8CAACgFhPTAAAAAAD11hdffJHx48fnyy+/zPDhw7PPPvsUPQkAAIBaTkwDAAAAANRLO3fuzJQpU7Ju3boMHjw4Bx54YNGTAAAAqAPENAAAAABAvVMul3PHHXdkxYoVueaaa3L44YcXPQkAAIA6QkwDAAAAANQ7CxcuzPPPP59evXrlpJNOKnoOAAAAdYiYBgAAAACoV/74xz/mwQcfzEknnZTzzz+/6DkAAADUMWIaAAAAAKDeWLFiRW677bYcfvjhufrqq1MqlYqeBAAAQB0jpgEAAAAA6oW1a9dmypQpOeCAAzJw4MA0bty46EkAAADUQWIaAAAAAKDO27RpU8aPH5/KysoMHz48zZs3L3oSAAAAdZSYBgAAAACo07Zv354JEyZky5YtGT58eFq3bl30JAAAAOowMQ0AAAAAUGdVVVVl+vTp+etf/5oBAwbkoIMOKnoSAAAAdZyYBgAAAACok8rlcubPn5833ngjV155ZY466qiiJwEAAFAPiGkAAAAAgDrp8ccfzzPPPJOzzz47p556atFzAAAAqCfENAAAAABAnfPyyy/nnnvuyXHHHZeLLrqo6DkAAADUI2IaAAAAAKBOWbVqVWbOnJlu3bqlb9++KZVKRU8CAACgHhHTAAAAAAB1xvr16zNx4sS0bt06Q4cOTWVlZdGTAAAAqGfENAAAAABAnfD5559n/PjxKZVKGT58eFq0aFH0JAAAAOohMQ0AAAAAUOvt2LEjEydOzIYNGzJ06NC0a9eu6EkAAADUU2IaAAAAAKBWq6qqysyZM/P222+nX79+6dq1a9GTAAAAqMfENAAAAABArVUul7NgwYIsXbo0l112WY499tiiJwEAAFDPiWkAAAAAgFrr8ccfz1NPPZWzzjorZ555ZtFzAAAAaADENAAAAABArfTSSy/lnnvuyXHHHZdLL7206DkAAAA0EGIaAAAAAKDWWbFiRWbNmpXDDjss1157bUqlUtGTAAAAaCDENAAAAABArfLee+9l8uTJad++fQYPHpzGjRsXPQkAAIAGREwDAAAAANQaGzZsyPjx49OsWbOMGDEizZs3L3oSAAAADYyYBgAAAACoFbZu3Zqbb74527Zty4gRI7LffvsVPQkAAIAGSEwDAAAAABRu586dmTx5ctavX58hQ4akY8eORU8CAACggRLTAAAAAACFKpfLmTVrVlauXJm+ffvm3/7t34qeBAAAQAMmpgEAAAAACnX33XdnyZIlueSSS3L88ccXPQcAAIAGTkwDAAAAABTmiSeeyBNPPJGf/OQn+elPf1r0HAAAABDTAAAAAADFWLJkSRYsWJBjjz02l112WUqlUtGTAAAAQEwDAAAAAOx5K1euzKxZs/K9730v/fr1S0WFo0oAAABqB0+oAAAAAMAetXbt2kyePDlt27bNkCFDUllZWfQkAAAA+G9iGgAAAABgj9mwYUNuvvnmVFZWZvjw4WnRokXRkwAAAOB/ENMAAAAAAHvEF198kfHjx+eLL77IiBEj0qZNm6InAQAAwP8ipgEAAAAAatzOnTszefLkfPDBBxk0aFA6depU9CQAAAD4SmIaAAAAAKBGlcvl3Hrrrfnzn/+cvn375ogjjih6EgAAAPxTYhoAAAAAoEbde++9eemll3LRRRflhBNOKHoOAAAA/EtiGgAAAACgxjz99NN57LHHcvrpp+fss88ueg4AAAB8LTENAAAAAFAjli5dmvnz5+eHP/xhrrjiipRKpaInAQAAwNcS0wAAAAAA1e6tt97KjBkz0rVr1/Tv3z8VFY4iAQAAqBs8wQIAAAAA1Wrt2rWZNGlS2rRpk6FDh6aysrLoSQAAALDbxDQAAAAAQLXZsGFDbr755lRWVmbEiBFp0aJF0ZMAAADgGxHTAAAAAADVYsuWLRk3bly++OKLjBgxIvvvv3/RkwAAAOAbE9MAAAAAAN/Zl19+mQkTJuSjjz7K0KFD06lTp6InAQAAwLcipgEAAAAAvpNdu3Zl2rRpefvtt9O/f/8cdthhRU8CAACAb01MAwAAAAB8a+VyOXfccUfeeOONXHnllTnmmGOKngQAAADfiZgGAAAAAPjW7r///vzhD39Ir169cuqppxY9BwAAAL4zMQ0AAAAA8K08+eSTeeSRR3Lqqafm/PPPL3oOAAAAVAsxDQAAAADwjb300ku56667cswxx+TnP/95SqVS0ZMAAACgWohpAAAAAIBvZPny5Zk1a1YOPfTQ/PKXv0xFhWNGAAAA6g9PuQAAAADAbnv33XczefLkdOjQIUOGDEllZWXRkwAAAKBaiWkAAAAAgN2yfv36jB8/PnvvvXeGDx+e5s2bFz0JAAAAqp2YBgAAAAD4Wps3b864ceNSLpczcuTI7LvvvkVPAgAAgBohpgEAAAAA/qUvvvgi48aNy2effZbhw4enffv2RU8CAACAGiOmAQAAAAD+qR07dmTSpElZu3ZtBg4cmIMPPrjoSQAAAFCjxDQAAAAAwFeqqqrKzJkzs3LlyvTt2zfdu3cvehIAAADUODENAAAAAPC/lMvlzJ8/P0uXLs1ll12WE044oehJAAAAsEeIaQAAAACA/+Xhhx/OM888k549e+ass84qeg4AAADsMWIaAAAAAOB/ePbZZ/PAAw/kxBNPzMUXX1z0HAAAANijxDQAAAAAwH979dVXM2fOnBx11FG55pprUiqVip4EAAAAe5SYBgAAAABIkrz11luZPn16unTpkgEDBqRRo0ZFTwIAAIA9TkwDAAAAAOT999/PpEmT0qZNmwwfPjxNmzYtehIAAAAUQkwDAAAAAA3cJ598kptvvjlNmjTJyJEjs/feexc9CQAAAAojpgEAAACABuyzzz7LTTfdlO3bt2fEiBFp06ZN0ZMAAACgUGIaAAAAAGigtm3blnHjxmXDhg0ZPnx4OnbsWPQkAAAAKJyYBgAAAAAaoB07dmTixIl5//33M2jQoHTr1q3oSQAAAFAriGkAAAAAoIGpqqrK9OnT89Zbb6Vfv3456qijip4EAAAAtYaYBgAAAAAakHK5nNtvvz2vvfZaevfuneOPP77oSQAAAFCriGkAAAAAoIEol8u5++678/zzz6dXr145/fTTi54EAAAAtY6YBgAAAAAaiEceeSRPPPFEzjjjjJx//vlFzwEAAIBaSUwDAAAAAA3AokWLcv/99+eEE07IFVdckVKpVPQkAAAAqJXENAAAAABQzy1ZsiRz587N97///fTp00dIAwAAAP+CmAYAAAAA6rFly5Zl5syZ6datWwYMGJBGjRoVPQkAAABqNTENAAAAANRTq1evzpQpU9KhQ4cMHTo0TZo0KXoSAAAA1HpiGgAAAACoh9auXZvx48dn3333zciRI9O8efOiJwEAAECdIKYBAAAAgHrm448/zk033ZQmTZpk5MiRadWqVdGTAAAAoM4Q0wAAAABAPbJ58+bcdNNN2bFjR0aOHJn999+/6EkAAABQp4hpAAAAAKCe2Lp1a8aNG5dNmzZl+PDhOfDAA4ueBAAAAHWOmAYAAAAA6oEvv/wyEydOzAcffJDBgwena9euRU8CAACAOklMAwAAAAB13K5duzJt2rSsWrUq/fr1y5FHHln0JAAAAKizxDQAAAAAUIeVy+XcdttteeONN3LllVfmuOOOK3oSAAAA1GliGgAAAACoo8rlcubPn58XXnghF154YU499dSiJwEAAECdJ6YBAAAAgDpq4cKFefrpp3PWWWflnHPOKXoOAAAA1AtiGgAAAACog55++uk8+OCDOemkk3LppZemVCoVPQkAAADqBTENAAAAANQxL774YubNm5ejjz4611xzjZAGAAAAqpGYBgAAAADqkNdffz2zZs3KYYcdluuuuy4VFY74AAAAoDp50gYAAACAOuLPf/5zpk6dms6dO2fo0KGprKwsehIAAADUO2IaAAAAAKgDVq9enYkTJ6Zdu3YZOXJkmjVrVvQkAAAAqJfENAAAAABQy7333nsZP358WrVqlVGjRqVFixZFTwIAAIB6S0wDAAAAALXYhx9+mHHjxqVJkyYZPXp09tlnn6InAQAAQL0mpgEAAACAWurTTz/NjTfemHK5nNGjR6dNmzZFTwIAAIB6T0wDAAAAALXQ5s2bc+ONN2bbtm0ZOXJkDjjggKInAQAAQIMgpgEAAACAWmbLli256aabsnHjxgwfPjydO3cuehIAAAA0GGIaAAAAAKhFtm3blvHjx+fDDz/MkCFD0q1bt6InAQAAQIMipgEAAACAWmLHjh2ZNGlS3n333Vx33XU54ogjip4EAAAADY6YBgAAAABqgV27dmXatGn585//nL59++aHP/xh0ZMAAACgQRLTAAAAAEDBqqqqMmvWrLz++uu58sorc8IJJxQ9CQAAABosMQ0AAAAAFKhcLmfu3Ll56aWXcvHFF+e0004rehIAAAA0aGIaAAAAAChIuVzO3XffnWeffTbnnntuzj777KInAQAAQIMnpgEAAACAgixcuDBPPPFEzjjjjPzsZz8reg4AAAAQMQ0AAAAAFOLJJ5/Mgw8+mJNOOilXXHFFSqVS0ZMAAACAiGkAAAAAYI9bvHhx7rrrrhx77LG55pprhDQAAABQi4hpAAAAAGAPWrJkSWbPnp3u3bvnl7/8ZSoqHNEBAABAbeJJHQAAAAD2kDfffDMzZszI9773vQwaNCiNGzcuehIAAADwD8Q0AAAAALAHrFy5MlOmTEmnTp0ydOjQNGnSpOhJAAAAwFcQ0wAAAABADXvnnXcyYcKE7L///hk5cmT22muvoicBAAAA/4SYBgAAAABq0Nq1a3PzzTenZcuWGTVqVPbee++iJwEAAAD/gpgGAAAAAGrIhx9+mBtuuCGVlZUZPXp09t1336InAQAAAF9DTAMAAAAANeDjjz/ODTfckCQZPXp09t9//4IXAQAAALtDTAMAAAAA1ezTTz/NDTfckB07dmT06NE54IADip4EAAAA7CYxDQAAAABUo40bN+bGG2/M1q1bM3LkyHTs2LHoSQAAAMA3IKYBAAAAgGry2Wef5aabbsqmTZsyYsSIdOnSpehJAAAAwDckpgEAAACAarBly5bcdNNN+fjjjzNs2LB07dq16EkAAADAtyCmAQAAAIDv6IsvvsjNN9+cdevWZciQITnssMOKngQAAAB8S2IaAAAAAPgOtm/fnvHjx2fNmjUZOHBgjjzyyKInAQAAAN+BmAYAAAAAvqUdO3Zk4sSJWb16dfr3758f/OAHRU8CAAAAviMxDQAAAAB8Czt37szkyZOzcuXKXHvttfnRj35U9CQAAACgGohpAAAAAOAb2rVrV6ZPn55ly5bl6quvzgknnFD0JAAAAKCaiGkAAAAA4BuoqqrKrFmz8uqrr6Z3797593//96InAQAAANVITAMAAAAAu6lcLuf222/PSy+9lEsuuSRnnHFG0ZMAAACAaiamAQAAAIDdUC6XM3fu3Dz//PPp1atXevbsWfQkAAAAoAaIaQAAAADga5TL5SxYsCCLFi3K2WefnfPPP7/oSQAAAEANEdMAAAAAwL9QLpfzwAMP5Mknn8xPfvKTXHTRRSmVSkXPAgAAAGqImAYAAAAA/oWHH344Dz/8cE455ZRcfvnlQhoAAACo58Q0AAAAAPBPPP7443nggQdy4okn5qqrrhLSAAAAQAMgpgEAAACAr/DMM8/k7rvvznHHHZc+ffoIaQAAAKCBENMAAAAAwD9YvHhx7rzzzhx99NHp169fKiocowEAAEBD4RQAAAAAAP7Oiy++mNmzZ6d79+4ZMGBAGjVqVPQkAAAAYA8S0wAAAADA3yxZsiQzZ87MoYcemkGDBqVx48ZFTwIAAAD2MDENAAAAACRZunRpZsyYke9973sZNmxYmjRpUvQkAAAAoABiGgAAAAAavFdffTXTp0/PIYcckmHDhqVp06ZFTwIAAAAKIqYBAAAAoEF7/fXXM23atHTp0iUjRoxIs2bNip4EAAAAFEhMAwAAAECD9eabb2bq1Knp3LlzRo4cKaQBAAAAxDQAAAAANEzLli3L5MmTc+CBB2bkyJHZa6+9ip4EAAAA1AJiGgAAAAAanOXLl2fSpEnp0KFDRo0alebNmxc9CQAAAKglxDQAAAAANCgrVqzIxIkTc8ABB2T06NFp0aJF0ZMAAACAWkRMAwAAAECDsXLlykycODFt27bNqFGjhDQAAADA/yKmAQAAAKBBeOuttzJhwoS0adMmo0ePTsuWLYueBAAAANRCYhoAAAAA6r1Vq1Zl/Pjx2XfffTNmzJi0atWq6EkAAABALSWmAQAAAKBee/vtt3PzzTdnn332EdIAAAAAX0tMAwAAAEC99c477+Smm25Ky5YtM3bs2Oy7775FTwIAAABqOTENAAAAAPXSmjVrMm7cuOy9995CGgAAAGC3iWkAAAAAqHf++te/5sYbb8xee+2VMWPGZL/99it6EgAAAFBHiGkAAAAAqFfee++93HjjjWnatGnGjBmTNm3aFD0JAAAAqEPENAAAAADUG2vXrs2NN96YysrKjB07Nvvvv3/RkwAAAIA6RkwDAAAAQL3wwQcf5IYbbkijRo0yduzYtG3btuhJAAAAQB0kpgEAAACgzlu3bl1uuOGGlEqljB07Nu3atSt6EgAAAFBHiWkAAAAAqNPWr1+fG264IeVyOWPGjEn79u2LngQAAADUYWIaAAAAAOqsjz76KL/5zW+ya9eujBkzJh06dCh6EgAAAFDHiWkAAAAAqJPWr1+f//qv/8qOHTsyevToHHjggUVPAgAAAOoBMQ0AAAAAdc769evzm9/8Jjt37syYMWPSqVOnoicBAAAA9UTjogcAAAAAwDfx4Ycf/o+rnTp27Fj0JAAAAKAeEdMAAAAAUGf8v5CmqqoqY8eOdbUTAAAAUO3ENAAAAADUCevWrctvfvOblMvljBkzRkgDAAAA1AgxDQAAAAC13gcffJAbbrghSTJ27Nh06NCh4EUAAABAfVVR9AAAAAAA+Fc++OCD/OY3v0mSjBkzRkgDAAAA1ChvpgEAAACg1lq7dm1uuOGGlEqljB07NgcccEDRkwAAAIB6TkwDAAAAQK30/0KaioqKjB07Nu3bty96EgAAANAAiGkAAAAAqHXef//93HDDDWncuHHGjBkjpAEAAAD2GDENAAAAALXKe++9lxtuuCGVlZUZO3Zs2rVrV/QkAAAAoAER0wAAAABQa/z1r3/NjTfemCZNmmTMmDFCGgAAAGCPE9MAAAAAUCv8fUgzduzYtG3btuhJAAAAQAMkpgEAAACgcGvWrMmNN96YZs2aZezYsdl///2LngQAAAA0UGIaAAAAAAr17rvv5qabbspee+2VMWPGCGkAAACAQolpAAAAACjM34c0Y8eOTZs2bYqeBAAAADRwFUUPAAAAAKBheuedd3LjjTcKaQAAAIBaxZtpAAAAANjj3n777dx0003Ze++9M3bs2LRu3broSQAAAABJxDQAAAAA7GGrV6/OuHHjsvfee+dXv/pV9ttvv6InAQAAAPw3MQ0AAAAAe8z/C2latmyZsWPHCmkAAACAWkdMAwAAAMAe8dZbb2XChAlp1apVxowZI6QBAAAAaiUxDQAAAAA1bsWKFZk4cWL222+/jBkzJvvuu2/RkwAAAAC+kpgGAAAAgBq1bNmyTJ48OW3bts3o0aPTqlWroicBAAAA/FNiGgAAAABqzOuvv56pU6emQ4cOGTVqVPbee++iJwEAAAD8S2IaAAAAAGrE0qVLM3369Bx00EEZOXJkmjdvXvQkAAAAgK8lpgEAAACg2r344ouZNWtWDjnkkAwfPjx77bVX0ZMAAAAAdouYBgAAAIBq9Yc//CG33357Dj300AwbNixNmzYtehIAAADAbhPTAAAAAFBtnn322dxxxx054ogjMmTIkDRp0qToSQAAAADfiJgGAAAAgGrx9NNPZ968eTnqqKMyaNCgVFZWFj0JAAAA4BsT0wAAAADwnT322GO55557cswxx6R///5p3NixEwAAAFA3OdUAAAAA4Dv53e9+lwceeCDHHXdc+vXrl0aNGhU9CQAAAOBbE9MAAAAA8K2Uy+X89re/ze9+97uceOKJ6dOnTyoqKoqeBQAAAPCdiGkAAAAA+MbK5XLuvffePPbYY/n3f//3XHXVVUIaAAAAoF4Q0wAAAADwjZTL5cyfPz9PP/10Tj/99PTu3TulUqnoWQAAAADVQkwDAAAAwG4rl8uZM2dOnn322Zx11lm59NJLhTQAAABAvSKmAQAAAGC3VFVV5fbbb8/zzz+fc889Nz/72c+ENAAAAEC9I6YBAAAA4GtVVVVl5syZeemll9KrV6+cf/75QhoAAACgXhLTAAAAAPAv7dy5MzNmzMjSpUtz8cUX5+yzzy56EgAAAECNEdMAAAAA8E/t3LkzU6dOzeuvv57LL788Z555ZtGTAAAAAGqUmAYAAACAr7Rjx45Mnjw5y5Yty5VXXpnTTjut6EkAAAAANU5MAwAAAMD/sm3btkycODFvvfVWrrnmmpx88slFTwIAAADYI8Q0AAAAAPwPW7Zsyc0335w1a9akX79++fGPf1z0JAAAAIA9RkwDAAAAwH/bvHlzxo0bl3Xr1mXQoEE5+uiji54EAAAAsEeJaQAAAABIkmzYsCE33nhjNmzYkGHDhuWII44oehIAAADAHiemAQAAACDr16/PTTfdlC1btmTUqFHp1q1b0ZMAAAAACiGmAQAAAGjg1q5dmxtvvDG7du3K2LFjc9BBBxU9CQAAAKAwFV/3gVKp1LlUKj1dKpWWl0qlZaVSaeSeGAYAAABAzXv33XfzX//1XymVSvnVr34lpAEAAAAavN15M83OJGPL5fLSUqnUMsnLpVLp8XK5/Kca3gYAAABADfrLX/6S8ePHp0WLFhk9enTatm1b9CQAAACAwn1tTFMulz9I8sHf/v5ZqVRanqRjEjENAAAAQB21fPnyTJw4Ma1bt87o0aOz3377FT0JAAAAoFbYnTfT/LdSqXRwkmOSvPAVPxuQZEASrwMGAAAAqMVeffXVTJ8+PQcccEBGjRqVli1bFj0JAAAAoNao2N0PlkqlvZPck2RUuVze/I8/L5fL08rl8nHlcvk4rwQGAAAAqJ1eeOGFTJ06NZ07d87YsWOFNAAAAAD/YLfeTFMqlSrzf0OaOeVy+d6anQQAAABATXj22WczZ86cHHrooRk6dGiaNWtW9CQAAACAWudrY5pSqVRKMiPJ8nK5fEPNTwIAAACguj3++OO5++67c9RRR2XQoEGprKwsehIAAABArbQ7b6Y5OckvkrxRKpVe/dv//X/K5fLvamwVAAAAANWiXC7noYceykMPPZQf/ehH6devXxo33q2XFQMAAAA0SF97clIul59LUtoDWwAAAACoRuVyOXfffXeeeOKJ9OjRI7/4xS9SUVFR9CwAAACAWs3XkAAAAADqoaqqqsydOzfPPvtszjjjjFxxxRX5v7d5AwAAAPCviGkAAAAA6pldu3bl1ltvzYsvvphzzz03P/vZz4Q0AAAAALtJTAMAAABQj+zYsSPTp0/Pa6+9lgsvvDDnnntu0ZMAAAAA6hQxDQAAAEA9sX379kyePDnLly9P7969c8YZZxQ9CQAAAKDOEdMAAAAA1ANbt27NhAkTsnr16vTp0yc9evQoehIAAABAnSSmAQAAAKjjNm/enHHjxuWDDz7IgAEDcuyxxxY9CQAAAKDOEtMAAAAA1GEff/xxbrrppmzatCnDhg3LkUceWfQkAAAAgDpNTAMAAABQR61duzbjxo3Ll19+mdGjR6dr165FTwIAAACo88Q0AAAAAHXQ6tWrM378+FRWVub666/PgQceWPQkAAAAgHpBTAMAAABQxyxfvjyTJ09Oq1atMmrUqOy///5FTwIAAACoN8Q0AAAAAHXI0qVLc8stt6RDhw4ZOXJkWrVqVfQkAAAAgHpFTAMAAABQRzz33HO544470rVr1wwbNizNmzcvehIAAABAvSOmAQAAAKgDHn300dx7773p3r17Bg4cmKZNmxY9CQAAAKBeEtMAAAAA1GLlcjn33XdfHn300Rx//PHp27dvGjd2pAMAAABQU5y8AAAAANRSVVVVmTNnTp577rmcdtpp6d27dyoqKoqeBQAAAFCviWkAAAAAaqGdO3dmxowZWbp0ac4777xccMEFKZVKRc8CAAAAqPfENAAAAAC1zPbt2zN58uQsX748l112Wc4666yiJwEAAAA0GGIaAAAAgFpky5YtGT9+fN5999306dMnPXr0KHoSAAAAQIMipgEAAACoJTZu3Jhx48Zl/fr1GTRoUI4++uiiJwEAAAA0OGIaAAAAgFpg/fr1uemmm/L5559nxIgR+bd/+7eiJwEAAAA0SGIaAAAAgIK99957GTduXHbt2pWxY8emS5cuRU8CAAAAaLDENAAAAAAFWrVqVcaPH59mzZplzJgx6dChQ9GTAAAAABo0MQ0AAABAQd58881MmTIlrVu3zqhRo9K6deuiJwEAAAA0eGIaAAAAgAK89NJLmTlzZjp16pQRI0akZcuWRU8CAAAAIGIaAAAAgD3uySefzF133ZXDDjssQ4cOTbNmzYqeBAAAAMDfiGkAAAAA9pByuZz77rsvjz76aI499tj069cvlZWVRc8CAAAA4O+IaQAAAAD2gF27dmX27Nl5/vnnc9ppp6V3796pqKgoehYAAAAA/0BMAwAAAFDDtm/fnmnTpuXNN9/MBRdckPPOOy+lUqnoWQAAAAB8BTENAAAAQA3asmVLJkyYkLfffjtXX311TjnllKInAQAAAPAviGkAAAAAasinn36acePG5eOPP87AgQNzzDHHFD0JAAAAgK8hpgEAAACoAWvXrs24ceOyffv2jBo1KoceemjRkwAAAADYDWIaAAAAgGq2atWqTJgwIZWVlbn++uvTsWPHoicBAAAAsJvENAAAAADV6LXXXsv06dPTunXrjBw5Mm3atCl6EgAAAADfgJgGAAAAoJosXrw4s2fPTpcuXTJs2LC0bNmy6EkAAAAAfENiGgAAAIDvqFwu55FHHsn999+f7t27Z+DAgWnatGnRswAAAAD4FsQ0AAAAAN9BuVzO/Pnz8/TTT+eEE05Inz590qhRo6JnAQAAAPAtiWkAAAAAvqWdO3dm1qxZWbJkSX7605/mkksuSalUKnoWAAAAAN+BmAYAAADgW9i2bVsmT56cFStW5JJLLknPnj2LngQAAABANRDTAAAAAHxDmzdvzs0335z3338/1157bU488cSiJwEAAABQTcQ0AAAAAN/ARx99lHHjxmXTpk0ZOnRojjrqqKInAQAAAFCNxDQAAAAAu2nNmjW5+eabU1VVlTFjxuSQQw4pehIAAAAA1UxMAwAAALAbVqxYkUmTJqVFixYZNWpU2rdvX/QkAAAAAGqAmAYAAADga7z44ou59dZb0759+4wcOTL77rtv0ZMAAAAAqCFiGgAAAIB/olwu57HHHsu9996bww47LIMHD07z5s2LngUAAABADRLTAAAAAHyFqqqqzJ8/P88880yOP/749O3bN40bO0oBAAAAqO+cAAEAAAD8gy+//DK33HJLXnvttfTs2TMXX3xxSqVS0bMAAAAA2APENAAAAAB/5/PPP8/EiRPz9ttvp3fv3jnjjDOKngQAAADAHiSmAQAAAPibjz76KDfffHM2bNiQgQMH5phjjil6EgAAAAB7mJgGAAAAIMk777yTCRMmpKqqKqNHj063bt2KngQAAABAAcQ0AAAAQIP3xhtvZNq0aWnVqlVGjBiR9u3bFz0JAAAAgIKIaQAAAIAG7dlnn82cOXNy0EEHZdiwYWnVqlXRkwAAAAAokJgGAAAAaJDK5XIefPDBLFy4MEcddVQGDBiQpk2bFj0LAAAAgIKJaQAAAIAGZ9euXZk9e3aef/75nHzyybn66qtTUVFR9CwAAAAAagExDQAAANCgbNu2LVOmTMny5cvTq1evnH/++SmVSkXPAgAAAKCWENMAAAAADcamTZsyfvz4vP/+++nTp0969OhR9CQAAAAAahkxDQAAANAgfPDBB7n55puzZcuWDBs2LN27dy96EgAAAAC1kJgGAAAAqPfeeuutTJo0KY0bN86vfvWrHHTQQUVPAgAAAKCWEtMAAAAA9drLL7+cmTNnpk2bNhk5cmTatGlT9CQAAAAAajExDQAAAFBvPfHEE7n77rvTtWvXDB06NC1atCh6EgAAAAC1nJgGAAAAqHfK5XIWLFiQJ598Mscee2z69euXysrKomcBAAAAUAeIaQAAAIB6ZceOHZk5c2aWLl2aM888M5dddllKpVLRswAAAACoI8Q0AAAAQL2xefPmTJo0Ke+8804uv/zynHnmmUVPAgAAAKCOEdMAAAAA9cIHH3yQ8ePHZ/PmzRk0aFB++MMfFj0JAAAAgDpITAMAAADUeX/+858zZcqUNG7cONdff326dOlS9CQAAAAA6igxDQAAAFCnPf/887n99ttzwAEHZNiwYWnTpk3RkwAAAACow8Q0AAAAQJ1ULpfz4IMPZuHChTniiCMycODA7LXXXkXPAgAAAKCOE9MAAAAAdc7OnTtz22235cUXX8zJJ5+cq666Ko0aNSp6FgAAAAD1gJgGAAAAqFO2bNmSyZMn56233sqFF16Yc845J6VSqehZAAAAANQTYhoAAACgzli/fn3Gjx+fTz/9NP3798/xxx9f9CQAAAAA6hkxDQAAAFAnrFq1KhMnTkySjBkzJt26dSt4EQAAAAD1kZgGAAAAqPWWLFmSWbNmpXXr1hk+fHjatWtX9CQAAAAA6ikxDQAAAFBrlcvlPPLII7n//vtz6KGHZvDgwWnRokXRswAAAACox8Q0AAAAQK20a9euzJkzJ4sXL86Pf/zj9OnTJ40bO8oAAAAAoGY5gQIAAABqnS+++CJTp07N8uXLc/7556dXr14plUpFzwIAAACgARDTAAAAALXKJ598kgkTJmTdunXp06dPevToUfQkAAAAABoQMQ0AAABQa7z77ruZMGFCduzYkZEjR+bwww8vehIAAAAADYyYBgAAAKgVXnvttUyfPj2tWrXKmDFj0qFDh6InAQAAANAAiWkAAACAQpXL5Tz11FNZsGBBunTpkqFDh6ZVq1ZFzwIAAACggRLTAAAAAIXZtWtX5s2bl0WLFuWYY45Jv3790qRJk6JnAQAAANCAiWkAAACAQmzdujVTp07NihUrcs455+TCCy9MqVQqehYAAAAADZyYBgAAANjj1q9fnwkTJuTjjz9O3759c9JJJxU9CQAAAACSiGkAAACAPWzlypWZPHlySqVSRo8enUMPPbToSQAAAADw38Q0AAAAwB7z3HPPZc6cOWnfvn2GDRuW/fffv+hJAAAAAPA/iGkAAACAGldVVZV77703jz/+eI488sgMGDAge+21V9GzAAAAAOB/EdMAAAAANWrbtm2ZMWNGXn/99Zxxxhm5/PLLU1FRUfQsAAAAAPhKYhoAAACgxnz66aeZOHFi1q5dm5///Oc5/fTTi54EAAAAAP+SmAYAAACoEatXr87kyZPz5ZdfZvjw4TnyyCOLngQAAAAAX0tMAwAAAFS7l156Kbfeemv23XffjBkzJh06dCh6EgAAAADsFjENAAAAUG3K5XIeeuihPPTQQzn00EMzaNCg7L333kXPAgAAAIDdJqYBAAAAqsWOHTty6623ZsmSJenRo0euuuqqNG7s6AEAAACAusWJFgAAAPCdbd68ORMnTsy7776biy++OD179kypVCp6FgAAAAB8Y2IaAAAA4Dt57733MmHChGzZsiWDBg3KD3/4w6InAQAAAMC3JqYBAAAAvrXXXnstM2bMSPPmzfPrX/86nTt3LnoSAAAAAHwnYhoAAADgGyuXy3n88cdz7733pkuXLhkyZEj22WefomcBAAAAwHcmpgEAAAC+kZ07d2bu3LlZvHhxfvSjH6Vv375p0qRJ0bMAAAAAoFqIaQAAAIDd9tlnn2XKlCn5y1/+kvPPPz+9evVKqVQqehYAAAAAVBsxDQAAALBb/vrXv2bSpEn57LPP0r9//xx//PFFTwIAAACAaiemAQAAAL7W0qVLM2vWrDRv3jzXX399unTpUvQkAAAAAKgRYhoAAADgnyqXy3nooYfy0EMPpWvXrhk8eHBatWpV9CwAAAAAqDFiGgAAAOArbd++PbNmzcorr7ySHj165Kqrrkrjxo4SAAAAAKjfnIABAAAA/8snn3ySSZMm5f33389ll12WM888M6VSqehZAAAAAFDjxDQAAADA//DWW29lypQp2bVrV4YPH57u3bsXPQkAAAAA9hgxDQAAAPDfFi1alDvvvDNt27bN0KFD0759+6InAQAAAMAeJaYBAAAAsmvXrtx111155plnctRRR6V///7Za6+9ip4FAAAAAHucmAYAAAAauM8//zxTp07NypUr07Nnz1x00UWpqKgoehYAAAAAFEJMAwAAAA3Y+++/n0mTJmXjxo259tprc+KJJxY9CQAAAAAKJaYBAACABurVV1/NzJkz06xZs/zqV7/KIYccUvQkAAAAACicmAYAAAAamHK5nIcffjgPPPBADj744AwePDj77rtv0bMAAAAAoFYQ0wAAAEAD8uWXX+a2227LkiVLcsIJJ+QXv/hFKisri54FAAAAALWGmAYAAAAaiE8//TSTJk3Ke++9l4svvjg9e/ZMqVQqehYAAAAA1CpiGgAAAGgAVq1alcmTJ2fHjh0ZOnRovv/97xc9CQAAAABqJTENAAAA1HOLFy/OnDlz0qZNm4wdOzYdOnQoehIAAAAA1FpiGgAAAKindu7cmQULFuSZZ57JEUcckeuuuy4tWrQoehYAAAAA1GpiGgAAAKiHNm/enKlTp+Yvf/lLevbsmYsuuigVFRVFzwIAAACAWk9MAwAAAPXM22+/nSlTpmTLli3p379/jj/++KInAQAAAECdIaYBAACAemTx4sWZO3du9tlnn/znf/5nOnXqVPQkAAAAAKhTxDQAAABQD+zcuTN33XVXfv/73+eII47IddddlxYtWhQ9CwAAAADqHDENAAAA1HGbN2/OlClTsmrVqvTs2TMXXXRRKioqip4FAAAAAHWSmAYAAADqsNWrV2fq1KnZunVrrrvuuhx33HFFTwIAAACAOk1MAwAAAHXUc889lzvvvDP77rtv/s//+T/p1KlT0ZMAAAAAoM4T0wAAAEAds3PnzsyfPz+LFi3KkUcemf79+6dFixZFzwIAAACAekFMAwAAAHXIpk2bMnXq1KxatSpnn312LrzwwlRUVBQ9CwAAAADqDTENAAAA1BGrV6/OlClT8sUXX+S6667LcccdV/QkAAAAAKh3xDQAAABQBzz77LO58847s99++2XkyJHp2LFj0ZMAAAAAoF4S0wAAAEAttnPnzsybNy/PPvtsunfvnl/+8pdp0aJF0bMAAAAAoN4S0wAAAEAttXHjxkydOjWrV6/OueeemwsuuCAVFRVFzwIAAACAek1MAwAAALXQqlWrMmXKlGzfvj0DBw7MscceW/QkAAAAAGgQxDQAAABQyzz77LO5884707p164wePToHHnhg0ZMAAAAAoMEQ0wAAAEAtsWPHjtx5551ZvHhxunfvnv79+6d58+ZFzwIAAACABkVMAwAAALXAxx9/nKlTp2bNmjU577zz0qtXr1RUVBQ9CwAAAAAaHDENAAAAFOzNN9/MjBkzUi6XM3To0PzgBz8oehIAAAAANFhiGgAAAChIuVzOQw89lIULF6Zjx44ZNGhQ2rZtW/QsAAAAAGjQxDQAAABQgC1btmTGjBlZtmxZTjrppFx55ZVp0qRJ0bMAAAAAoMET0wAAAMAetmbNmkyZMiWbNm3KVVddlVNOOSWlUqnoWQAAAABAxDQAAACwRy1evDhz585Ny5Ytc/311+fggw8uehIAAAAA8HfENAAAALAH7NixI3feeWcWL16cI444Iv3798/ee+9d9CwAAAAA4B+IaQAAAKCGffLJJ5kyZUrWrFmTc889NxdccEEqKiqKngUAAAAAfAUxDQAAANSgZcuWZcaMGamqqsqQIUNy9NFHFz0JAAAAAPgXxDQAAABQA8rlchYuXJiHHnooHTt2zMCBA9OuXbuiZwEAAAAAX0NMAwAAANVsy5YtmTlzZt58882ceOKJueqqq9KkSZOiZwEAAAAAu0FMAwAAANVozZo1mTJlSjZu3Jgrr7wyp556akqlUtGzAAAAAIDdJKYBAACAarJ48eLMnTs3LVu2zPXXX59DDjmk6EkAAAAAwDckpgEAAIDvaMeOHZk3b16ee+65HH744enfv39atmxZ9CwAAAAA4FsQ0wAAAMB38Mknn2Tq1Kl59913c+655+aCCy5IRUVF0bMAAAAAgG9JTAMAAADf0htvvJFZs2Zl165dGTJkSI4++uiiJwEAAAAA35GYBgAAAL6hqqqq3H///Xn00UfTuXPnDBgwIO3atSt6FgAAAABQDcQ0AAAA8A1s3Lgxt9xyS956662ccsopueKKK1JZWVn0LAAAAACgmohpAAAAYDctX748M2bMyJdffpl+/frlhBNOKHoSAAAAAFDNxDQAAADwNaqqqrJw4cIsXLgwHTp0yIABA9KhQ4eiZwEAAAAANUBMAwAAAP/C5s2bM2PGjKxYsSInnnhirrzyyjRt2rToWQAAAABADRHTAAAAwD/x1ltvZfr06dm6dWuuueaa9OjRI6VSqehZAAAAAEANEtMAAADAPyiXy3n00Udz//33p23bthkxYkQ6depU9CwAAAAAYA8Q0wAAAMDf2bJlS2bOnJk333wzxx13XH7xi1+kWbNmRc8CAAAAAPYQMQ0AAAD8zerVqzNt2rR89tln+fnPf57TTjvNtU4AAAAA0MCIaQAAAGjwyuVynnzyydxzzz1p3bp1fv3rX6dLly5FzwIAAAAACiCmAQAAoEHbunVrbr/99rzyyiv54Q9/mD59+qR58+ZFzwIAAAAACiKmAQAAoMF69913M23atHz66ae57LLLcuaZZ7rWCQAAAAAaODENAAAADU65XM6iRYty1113pWXLlvnVr36Vbt26FT0LAAAAAKgFxDQAAAA0KNu2bcsdd9yRl156Kd27d0+/fv2y9957Fz0LAAAAAKglxDQAAAA0GO+9916mTZuW9evX58ILL8w555zjWicAAAAA4H8Q0wAAAFDv/f21Ts2bN8+YMWNy2GGHFT0LAAAAAKiFxDQAAADUa1u3bs3s2bOzdOnSdO/ePddee21atmxZ9CwAAAAAoJYS0wAAAFBvrV69Orfccks2bNiQSy65JD/96U9d6wQAAAAA/EtiGgAAAOqdcrmcxx57LPfff3/222+/XH/99enatWvRswAAAACAOkBMAwAAQL3y2WefZdasWVm2bFmOPfbY/OIXv0jz5s2LngUAAAAA1BFiGgAAAOqNFStWZMaMGfniiy9y1VVX5ZRTTnGtEwAAAADwjYhpAAAAqPOqqqry4IMP5uGHH0779u0zatSodOzYsehZAAAAAEAdJKYBAACgTtuwYUNuueWW/OUvf0mPHj3Su3fvNG3atOhZAAAAAEAdJaYBAACgznrttddy6623ZteuXenXr19OOOGEoicBAAAAAHWcmAYAAIA6Z+fOnbnnnnvy1FNP5aCDDsp1112Xdu3aFT0LAAAAAKgHxDQAAADUKevXr8/06dOzZs2anHnmmbn44ovTuLHHWwAAAACgejhtBAAAoM544YUXMmfOnDRu3DhDhgzJ0UcfXfQkAAAAAKCeEdMAAABQ623fvj3z5s3LH/7wh3zve99L//79s99++xU9CwAAAACoh8Q0AAAA1Grvvfdepk+fng8//DDnnXdeevXqlYqKiqJnAQAAAAD1lJgGAACAWqlcLufZZ5/N/Pnz07x584waNSqHH3540bMAAAAAgHpOTAMAAECt8/nnn+f222/Pa6+9lu7du+faa69Ny5Yti54FAAAAADQAYhoAAABqlRUrVmTWrFn5/PPPc9lll+XMM89MqVQqehYAAAAA0ECIaQAAAKgVdu7cmQceeCCPP/542rdvn2HDhqVz585FzwIAAAAAGhgxDQAAAIX78MMPM2PGjLz77rs59dRTc9lll6VJkyZFzwIAAAAAGiAxDQAAAIUpl8v5wx/+kHnz5qWysjKDBw/OD3/4w6JnAQAAAAANmJgGAACAQmzdujWzZ8/O0qVLc/jhh+faa6/NvvvuW/QsAAAAAKCBE9MAAACwx61cuTIzZ87Mpk2bcvHFF6dnz54plUpFzwIAAAAAENMAAACw5+zatSsPPvhgHnnkkbRt2zb/+Z//mS5duhQ9CwAAAADgv4lpAAAA2CPWr1+fGTNm5J133snJJ5+cK664Ik2bNi16FgAAAADA/yCmAQAAoEaVy+X88Y9/zJ133plGjRpl4MCBOfbYY4ueBQAAAADwlcQ0AAAA1JitW7dmzpw5WbJkSQ499ND88pe/zH777Vf0LAAAAACAf0pMAwAAQI34y1/+khkzZmTjxo258MILc/bZZ6eioqLoWQAAAAAA/5KYBgAAgGpVVVWVhQsXZuHChWnTpk1+/etf55BDDil6FgAAAADAbhHTAAAAUG0+/vjjzJgxI6tXr86JJ56Yn//852nWrFnRswAAAAAAdpuYBgAAgO+sXC7nxRdfzNy5c5Mk/fv3z/HHH1/wKgAAAACAb05MAwAAwHeyZcuWzJkzJy+//HK6deuWX/7yl2nTpk3RswAAAAAAvhUxDQAAAN/asmXLctttt+Xzzz/PRRddlJ49e6aioqLoWQAAAAAA35qYBgAAgG/syy+/zL333punn346HTp0yPDhw9O5c+eiZwEAAAAAfGdiGgAAAL6Rd999NzNnzsy6dety5pln5qKLLkplZWXRswAAAAAAqoWYBgAAgN1SVVWVRx55JA8++GBatWqVUaNG5Ygjjih6FgAAAABAtRLTAAAA8LU++uijzJw5M6tXr87xxx+fK6+8Ms2bNy96FgAAAABAtRPTAAAA8E+Vy+U899xzWbBgQSoqKtK/f/8cf/zxRc8CAAAAAKgxYhoAAAC+0ubNmzN79uy8/vrrOfzww9O3b9/st99+Rc8CAAAAAKhRYhoAAAD+l9deey2zZ8/OF198kcsvvzw/+clPUiqVip4FAAAAAFDjxDQAAAD8t23btuWuu+7K4sWL07lz54wZMyYHHnhg0bMAAAAAAPYYMQ0AAABJklWrVmXmzJn55JNPcs4556RXr15p3NhjIwAAAADQsDgVBQAAaOB27tyZhQsX5uGHH07r1q0zduzYHHrooUXPAgAAAAAohJgGAACgAfvggw8yc+bMrFmzJj169MgVV1yRZs2aFT0LAAAAAKAwYhoAAIAGqFwu55lnnsk999yTpk2bZtCgQTnmmGOKngUAAAAAUDgxDQAAQAPzySef5Lbbbsuf//znHHXUUenTp09atWpV9CwAAAAAgFpBTAMAANBAlMvlPPfcc1mwYEFKpVKuueaa9OjRI6VSqehpAAAAAAC1hpgGAACgAdi4cWNuv/32LFu2LIcffniuueaatGnTpuhZAAAAAAC1jpgGAACgHiuXy3nhhRcyf/787Ny5Mz//+c9z2mmneRsNAAAAAMA/IaYBAACopzZv3pw77rgjr732Wrp165a+ffumXbt2Rc8CAAAAAKjVxDQAAAD10Msvv5w5c+Zk+/btufTSS3PmmWemoqKi6FkAAAAAALWemAYAAKAe2bJlS+bOnZslS5bk4IMPTt++fdOhQ4eiZwEAAAAA1BliGgAAgHritddeyx133JEtW7bkZz/7Wc455xxvowEAAAAA+IbENAAAAHXc1q1bM3/+/Pzxj39Mp06dMnLkyHTq1KnoWQAAAAAAdZKYBgAAoA5btmxZbr/99mzevDnnnXdezj///DRu7FEPAAAAAODbcsIKAABQB23bti133313nn322XTo0CGDBw/OwQcfXPQsAAAAAIA6T0wDAABQx6xcuTK33nprPv300/Ts2TMXXHBBKisri54FAAAAAFAviGkAAADqiC+//DL33XdfnnrqqbRr1y7XX399unXrVvQsAAAAAIB6RUwDAABQB6xatSq33npr1q9fnzPOOCMXXXRRmjZtWvQsAAAAAIB6R0wDAABQi23fvj0PPPBAnnrqqbRu3TqjR4/O4YcfXvQsAAAAAIB6S0wDAABQS/35z3/O7bffno8//jinn356Lr74Ym+jAQAAAACoYWIaAACAWmbbtm255557smjRorRr1y6/+tWvcuihhxY9CwAAAACgQRDTAAAA1CLLli3L7Nmzs3Hjxpx11ln52c9+liZNmhQ9CwAAAACgwRDTAAAA1AJbt27NggUL8oc//CEdOnTIr3/963Tt2rXoWQAAAAAADY6YBgAAoGCvvfZa5syZk88++yznnntuzj///FRWVhY9CwAAAACgQRLTAAAAFOTzzz/PvHnz8tJLL6VTp04ZNmxYDjrooKJnAQAAAAA0aGIaAACAPaxcLufll1/OvHnzsnXr1vTq1SvnnHNOGjf2iAYAAAAAUDQntQAAAHvQ5s2bM3fu3Lzyyivp0qVLRo8enY4dOxY9CwAAAACAvxHTAAAA7AHlcjkvvPBC5s+fny+//DIXX3xxfvrTn6aioqLoaQAAAAAA/B0xDQAAQA3bsGFD5syZkzfeeCPdunVLnz590r59+6JnAQAAAADwFcQ0AAAANaRcLmfx4sVZsGBBdu3alcsvvzxnnHGGt9EAAAAAANRiYhoAAIAa8Mknn2T27NlZvnx5DjvssFxzzTVp27Zt0bMAAAAAAPgaYhoAAIBqVFVVlaeffjoPPPBAkuSqq67KKaecklKpVPAyAAAAAAB2h5gGAACgmrz33nuZPXt23nnnnRx11FG56qqr0rp166JnAQAAAADwDYhpAAAAvqMdO3bkoYceymOPPZYWLVqkf//+Oe6447yNBgAAAACgDhLTAAAAfAcrVqzInDlzsn79+vTo0SOXXnppWrRoUfQsAAAAAAC+JTENAADAt7Bly5bcc889Wbx4cdq2bZvRo0fn8MMPL3oWAAAAAADfkZgGAADgGyiXy3n55Zczb968bNmyJWeffXZ69eqVysrKoqcBAAAAAFANxDQAAAC76dNPP83cuXPzxhtvpEuXLhk5cmQ6d+5c9CwAAAAAAKqRmAYAAOBrVFVV5fe//33uu+++lMvlXHbZZfnJT36SioqKoqcBAAAAAFDNxDQAAAD/wtq1a3P77bfn7bffTvfu3XPllVdm//33L3oWAAAAAAA15GtjmlKpNDPJfyRZXy6Xj6r5SQAAAMXbsWNHfve73+WRRx5J8+bN069fv/z4xz9OqVQqehoAAAAAADVod95Mc2uSCUlur9kpAAAAtcNbb72V2bNn58MPP8yJJ56Yyy67LHvvvXfRswAAAAAA2AO+NqYpl8uLSqXSwXtgCwAAQKG2bt2ae++9N88++2z233//jBw5MkceeWTRswAAAAAA2IN25800u6VUKg1IMiBJDjrooOr6tQAAADWuXC7nlVdeyZ133pnPPvssPXv2zH/8x3+kadOmRU8DAAAAAGAPq7aYplwuT0syLUmOO+64cnX9XgAAgJr0ySefZN68eXn99dfTuXPnDBs2LF26dCl6FgAAAAAABam2mAYAAKAu2bVrV5544ok89NBDSZJLLrkkZ511VioqKgpeBgAAAABAkcQ0AABAg7Nq1arccccdWbt2bY4++uj07t07rVu3LnoWAAAAAAC1wNfGNKVS6c4kpyfZv1QqvZfk/1sul2fU9DAAAIDqtmXLltx777157rnnst9++2XIkCE5+uiji54FAAAAAEAt8rUxTblc/vmeGAIAAFBTyuVyXnjhhSxYsCBbt25Nz5498x//8R9p2rRp0dMAAAAAAKhlXPMEAADUa+vWrcucOXOycuXKdO3aNVdddVU6depU9CwAAAAAAGopMQ0AAFAv7dixI7/73e/y6KOPpmnTprn66qvz7//+7ymVSkVPAwAAAACgFhPTAAAA9c6f/vSnzJ07Nx999FFOOOGEXHrppWnVqlXRswAAAAAAqAPENAAAQL2xadOm3HXXXVmyZEnat2+f0aNH5/DDDy96FgAAAAAAdYiYBgAAqPOqqqqyaNGi3Hfffdm5c2d69eqVc845J40be+QBAAAAAOCbcbIMAADUaWvWrMmcOXPyzjvv5IgjjsiVV16Zdu3aFT0LAAAAAIA6SkwDAADUSdu2bctvf/vbPPXUU2nZsmX69++f4447LqVSqehpAAAAAADUYWIaAACgTimXy3nllVcyf/78bNq0Kaeddlp+9rOfpXnz5kVPAwAAAACgHhDTAAAAdcaHH36YefPm5U9/+lM6d+6cQYMG5ZBDDil6FgAAAAAA9YiYBgAAqPW2b9+ehx9+OI899liaNGmS3r1757TTTktFRUXR0wAAAAAAqGfENAAAQK31/650uuuuu7Jhw4acdNJJufjii9OqVauipwEAAAAAUE+JaQAAgFpp3bp1mTdvXpYvX57OnTvnuuuuS7du3YqeBQAAAABAPSemAQAAapXt27dn4cKFeeKJJ1zpBAAAAADAHiemAQAAaoVyuZylS5dmwYIF2bBhQ3r06JGLL744LVu2LHoaAAAAAAANiJgGAAAonCudAAAAAACoLcQ0AABAYf7xSqef//znOfXUU13pBAAAAABAYcQ0AADAHudKJwAAAAAAaisxDQAAsEetW7cud955Z1asWJHOnTtnwIAB6dq1a9GzAAAAAAAgiZgGAADYQ/7+SqemTZu60gkAAAAAgFpJTAMAANSocrmcl19+OQsWLMjGjRtz8skn56KLLnKlEwAAAAAAtZKYBgAAqDHvvfde5s+fn5UrV6Zz584ZOHCgK50AAAAAAKjVxDQAAEC127JlSx544IEsWrQozZs3z5VXXplTTjnFlU4AAAAAANR6YhoAAKDaVFVV5fe//31++9vfZtu2bTn99NPTq1evtGjRouhpAAAAAACwW8Q0AABAtVi+fHnuuuuurF27NkcccUQuv/zyHHjggUXPAgAAAACAb0RMAwAAfCcff/xxFixYkFdffTX7779/hgwZkh/84AcplUpFTwMAAAAAgG9MTAMAAHwr27dvz8MPP5zHH388jRo1yoUXXpizzjorlZWVRU8DAAAAAIBvTUwDAAB8I+VyOS+++GLuvffebNy4MSeeeGIuuuii7LvvvkVPAwAAAACA70xMAwAA7LZ33nkn8+fPz+rVq3PwwQdn4MCB6dq1a9GzAAAAAACg2ohpAACAr7V58+bcd999+cMf/pBWrVqlT58+Oemkk1IqlYqeBgAAAAAA1UpMAwAA/FM7d+7MU089lYULF2bHjh05++yzc95556VZs2ZFTwMAAAAAgBohpgEAAP6XcrmcN954IwsWLMj69evzgx/8IJdddlnatWtX9DQAAAAAAKhRYhoAAOB/WLduXe66664sW7YsBxxwQEaMGJHu3bsXPQsAAAAAAPYIMQ0AAJAk+fzzz/PQQw/l97//fZo2bZrLL788p59+eho1alT0NAAAAAAA2GPENAAA0MDt3LkzTz/9dBYuXJht27bl1FNPTa9evdKyZcuipwEAAAAAwB4npgEAgAaqXC7nlVdeyT333JOPP/44Rx11VC655JIceOCBRU8DAAAAAIDCiGkAAKABeuedd7JgwYL85S9/yYEHHpgRI0ake/fuRc8CAAAAAIDCiWkAAKAB2bBhQ+6777688ML/v717C9KyTvA8/3sSUiARSIqzkMkpOSUpIoiIBwQPpVa1h2rLbqvasqqiuqo7amejL2evdi/mZvZiI3Y3dmYnOiY6JuZmO2K6a9QqT2UpNFIcRBGRg4pykOQgJiAghzST99mLeiunrNIWFfLNw+cT8UaamU8Yv7zxn/B+fZ7NGTVqVB577LHccsstqaurq/U0AAAAAADoE8Q0AAAwCFy4cCHPP/98XnjhhZRlmfvuuy/33ntvhg8fXutpAAAAAADQp4hpAABgAKtUKtmwYUOefPLJnD59OjfeeGMeeuihjBs3rtbTAAAAAACgTxLTAADAALV79+78t//233Lo0KHMnj07P//5zzNz5sxazwIAAAAAgD5NTAMAAAPMkSNH8k//9E/ZsWNHxo0bl5/97GdZsmRJiqKo9TQAAAAAAOjzxDQAADBAnDlzJr/61a+ybt26XHXVVXn44YezevXq1NfX13oaAAAAAAD0G2IaAADo57q7u/PSSy/l6aefzieffJKVK1fmz/7szzJq1KhaTwMAAAAAgH5HTAMAAP1UWZZ59dVX88QTT6SjoyNtbW357ne/mylTptR6GgAAAAAA9FtiGgAA6Ifeeuut/OIXv8iBAwcyderU/N3f/V1aW1trPQsAAAAAAPo9MQ0AAPQj7e3t+e///b9nx44dGTt2bH70ox9l+fLlqaurq/U0AAAAAAAYEMQ0AADQD5w4cSJPPfVUNm3alBEjRuThhx/O6tWrU19fX+tpAAAAAAAwoIhpAACgDzt37lyeffbZvPTSS0mSu+66K/fdd19GjhxZ42UAAAAAADAwiWkAAKAP6urqytq1a/PMM8/k/PnzWb58eR544IGMGzeu1tMAAAAAAGBAE9MAAEAfUpZlNm/enCeffDInTpzIwoUL8+d//ueZNm1aracBAAAAAMCgIKYBAIA+YteuXfnnf/7ntLe3p7m5OT/84Q8zf/78Ws8CAAAAAIBBRUwDAAA19v777+cXv/hFdu/enXHjxuUnP/lJli1blqIoaj0NAAAAAAAGHTENAADUSEdHR5588sm88sorGTlyZP7iL/4it99+e4YO9Ws6AAAAAADUir+lBwCAXnb27Nk888wzWbt2bYqiyH333Zd77rknI0aMqPU0AAAAAAAY9MQ0AADQSzo7O7NmzZo899xzuXDhQm6++eY88MADaWxsrPU0AAAAAACgSkwDAABXWHd3d9avX5+nn346p0+fzqJFi/Kd73wn11xzTa2nAQAAAAAAf0RMAwAAV0ilUskrr7ySp556KsePH8+cOXPyN3/zN2lpaan1NAAAAAAA4HOIaQAA4DIryzLbtm3Lk08+mSNHjqSpqSl/9Vd/ldbW1hRFUet5AAAAAADAv0JMAwAAl9Hu3bvzxBNPZP/+/Zk0aVJ+9rOfZcmSJSIaAAAAAADoJ8Q0AABwGezbty9PPPFE3nrrrYwdOzaPP/54VqxYkbq6ulpPAwAAAAAAvgQxDQAAfA2HDx/OE088kTfeeCOjRo3KX/zFX2TlypWpr6+v9TQAAAAAAOArENMAAMBX0NHRkaeeeiqvvPJKhg0blgcffDB33nlnhg0bVutpAAAAAADA1yCmAQCAL+HUqVN5+umn8/LLL2fIkCH55je/mXvuuScjR46s9TQAAAAAAOAyENMAAMAlOHv2bJ5//vm89NJLuXjxYm677bZ861vfSmNjY62nAQAAAAAAl5GYBgAA/hWdnZ158cUX8+tf/zoXLlzIjTfemPvvvz8TJkyo9TQAAAAAAOAKENMAAMBn6Orqyrp16/Lss8/mzJkzue666/Lggw9m6tSptZ4GAAAAAABcQWIaAAD4A11dXVm/fn2effbZnDp1KvPnz8+DDz6YWbNm1XoaAAAAAADQC8Q0AACQpLu7Oxs2bMgzzzyTkydPZs6cOfnrv/7rzJ07t9bTAAAAAACAXiSmAQBgULt48WI2btyYp59+OidOnMjs2bPzox/9KPPmzUtRFLWeBwAAAAAA9DIxDQAAg1KlUsmmTZvy9NNPp6OjIzNmzMhjjz2W1tZWEQ0AAAAAAAxiYhoAAAaVSqWSLVu25Fe/+lWOHTuW6dOn59FHH01bW5uIBgAAAAAAENMAADA4VCqVvPbaa/nlL3+ZDz74INOmTcvPf/7zLFq0SEQDAAAAAAD0ENMAADCglWWZ119/Pb/85S9z+PDhXHPNNfnbv/3bLF68WEQDAAAAAAD8CTENAAADUlmW2bZtW371q1+lvb09U6ZMyU9/+tMsXbpURAMAAAAAAHwuMQ0AAANKWZZ5880389RTT+XgwYOZOHFifvKTn+SGG25IXV1drecBAAAAAAB9nJgGAIABoSzL7Ny5M7/85S+zf//+jB8/Pj/60Y+yfPlyEQ0AAAAAAHDJxDQAAPRrZVlm+/btefrpp3PgwIGMGzcujz/+eG666aYMGTKk1vMAAAAAAIB+RkwDAEC/VJZlXn/99Tz99NNpb2/P+PHj84Mf/CA33XRThg71ay4AAAAAAPDVeJcBAIB+pVKp5LXXXsszzzyTw4cPZ+LEifnxj3+cG2+80eOcAAAAAACAr01MAwBAv1CpVPLKK6/kmWeeyQcffJApU6bkr//6r7N06VIRDQAAAAAAcNmIaQAA6NMuXryYTZs25dlnn82HH36YadOm5Wc/+1mWLFmSoihqPQ8AAAAAABhgxDQAAPRJ3d3d2bBhQ5577rkcP348zc3N+fnPf55FixaJaAAAAAAAgCtGTAMAQJ/S1dWV9evX5/nnn8/Jkyczc+bMfP/738/ChQtFNAAAAAAAwBUnpgEAoE/45JNPsm7dujz//PM5ffp0Wlpa8sMf/jDz588X0QAAAAAAAL1GTAMAQE11dnZm7dq1eeGFF3LmzJnMmzcvP/3pTzNnzhwRDQAAAAAA0OvENAAA1MT58+ezZs2a/OY3v8nZs2fT2tqab3/722lpaan1NAAAAAAAYBAT0wAA0KtOnz6dF198MWvXrs2FCxeyaNGifOtb38rMmTNrPQ0AAAAAAEBMAwBA7zh+/Hh+/etf57e//W26u7uzdOnS3HvvvWlqaqr1NAAAAAAAgB5iGgAArqjDhw/nueeey5YtW1IURVasWJF77rknEydOrPU0AAAAAACAPyGmAQDgiti7d2+ee+65vPHGGxk2bFjuuOOO3H333WlsbKz1NAAAAAAAgM8lpgEA4LIpyzK7d+/Os88+m3feeScjR47M/fffn9WrV2fkyJG1ngcAAAAAAPCFxDQAAHxtlUol27Zty3PPPZcDBw6ksbExjzzySG677bYMGzas1vMAAAAAAAAumZgGAICvrLu7O5s3b87zzz+fDz74IBMnTswPfvCD3HTTTRk61K+aAAAAAABA/+MdDgAAvrTOzs6sX78+L7zwQk6ePJmmpqb89Kc/zZIlS1JXV1freQAAAAAAAF+ZmAYAgEt27ty5rFmzJi+++GLOnj2bOXPm5Ac/+EFaW1tTFEWt5wEAAAAAAHxtYhoAAL7QyZMn8+KLL2bdunXp7OzMokWLcu+992b27Nm1ngYAAAAAAHBZiWkAAPhc7e3teeGFF/LKK68kSW644Ybce++9mTp1ao2XAQAAAAAAXBliGgAAPqUsy7z11lv59a9/nV27dmXYsGFZvXp17rzzzowbN67W8wAAAAAAAK4oMQ0AAEmSixcv5tVXX80LL7yQgwcPZvTo0XnooYdy++23p6GhodbzAAAAAAAAeoWYBgBgkLtw4ULWr1+fF198MSdOnMiUKVPy+OOPZ/ny5Rk61K+LAAAAAADA4OLdEQCAQeqjjz7KSy+9lHXr1uX8+fOZO3duvve97+Xaa69NURS1ngcAAAAAAFATYhoAgEHm8OHDeeGFF7J58+ZUKpUsWbIk3/zmNzNjxoxaTwMAAAAAAKg5MQ0AwCBQlmX27NmT559/Pjt27Eh9fX1WrlyZu+66K+PHj6/1PAAAAAAAgD5DTAMAMIBVKpVs3bo1v/71r3PgwIGMGjUqDzzwQFatWpWRI0fWeh4AAAAAAECfI6YBABiAOjs7s2HDhvzmN79JR0dHJk2alMceeyw33XRT6uvraz0PAAAAAACgzxLTAAAMICdOnMiaNWvy8ssv5/z585k9e3YeeeSRXHfddSmKotbzAAAAAAAA+jwxDQBAP1eWZfbu3ZsXX3wxr7/+epJkyZIlufPOOzNr1qwarwMAAAAAAOhfxDQAAP3UxYsXs3Xr1vzmN7/J/v3709DQkLvvvjurVq3KN77xjVrPAwAAAAAA6JfENAAA/czZs2fz8ssvZ82aNfnoo48yadKkfO9738uKFSsybNiwWs8DAAAAAADo18Q0AAD9xJEjR/LSSy9l48aN6erqyoIFC/LYY4+lra0tRVHUeh4AAAAAAMCAIKYBAOjDyrLMrl278uKLL2bnzp0ZOnRoli9fnjvvvDNTp06t9TwAAAAAAIABR0wDANAHdXV1ZdOmTXnxxRdz5MiRjB49Og8++GBuu+22jBo1qtbzAAAAAAAABiwxDQBAH/LRRx9l7dq1WbduXc6ePZumpqb8+Mc/zg033JChQ/3qBgAAAAAAcKV5RwYAoA/Yv39/XnrppWzZsiVlWWbx4sW5884709LSkqIoaj0PAAAAAABg0BDTAADUSHd3d1577bWsWbMm+/bty/Dhw7N69erccccdGT9+fK3nAQAAAAAADEpiGgCAXnby5MmsW7cuL7/8cs6cOZNJkybl0UcfzYoVKzJ8+PBazwMAAAAAABjUxDQAAL2gLMvs2bMna9asybZt21KWZRYtWpTVq1dn/vz5HuUEAAAAAADQR4hpAACuoM7OzmzevDlr1qzJ4cOH09DQkLvuuiu33367RzkBAAAAAAD0QWIaAIAr4NixY1m7dm02bNiQ8+fPp6mpKY8//niWLVuWq666qtbzAAAAAAAA+BxiGgCAy6Qsy+zcuTNr1qzJjh07UldXl6VLl2b16tWZNWuWRzkBAAAAAAD0A2IaAICv6dy5c9mwYUPWrl2bDz/8MKNHj87999+f2267LWPGjKn1PAAAAAAAAL4EMQ0AwFfU3t6etWvXZvPmzfnkk08ye/bsPPTQQ1m8eHGGDvVrFgAAAAAAQH/kXR4AgC+hu7s727Zty9q1a7Nnz57U19fnxhtvzOrVq9PU1FTreQAAAAAAAHxNYhoAgEvQ0dGRl19+Ob/97W9z5syZjB8/Pg8//HBuueWWjBw5stbzAAAAAAAAuEzENAAAn6NSqeTNN9/Mv/zLv2TXrl1Jkuuuuy4rV65Ma2triqKo8UIAAAAAAAAuNzENAMAf+eijj7J+/fq8/PLL+eijj9LY2Jhvf/vbufXWWzN27NhazwMAAAAAAOAKEtMAACQpyzK7du3KunXrsn379lQqlSxcuDDf+973smjRotTV1dV6IgAAAAAAAL1ATAMADGpnzpzJhg0bsm7dunR0dGTUqFG5++67s3LlyowfP77W8wAAAAAAAOhlYhoAYNApyzJ79uzJunXrsnXr1ly8eDFz587NQw89lOuvvz5Dh/oVCQAAAAAAYLDyThEAMGicO3cuGzduzLp163L06NE0NDRk1apVue222zJlypRazwMAAAAAAKAPENMAAANaWZbZt29fXn755WzZsiVdXV2ZOXNmfvjDH+aGG27IVVddVeuJAAAAAAAA9CFiGgBgQPr444+zefPmrF+/PocPH86wYcOyYsWKrFy5Mk1NTbWeBwAAAAAAQB8lpgEABoyyLPPWW29l/fr12bZtW7q7uzNjxow89thjWbZsWYYPH17riQAAAAAAAPRxYhoAoN87efJkNm7cmPXr1+f48eNpaGjIypUrc8stt2TatGm1ngcAAAAAAEA/IqYBAPqlixcvZvv27fntb3+bHTt2pCzLzJ8/P9/5zneyePHi1NfX13oiAAAAAAAA/ZCYBgDoV44dO5b169dn48aNOX36dBobG3Pffffllltuyfjx42s9DwAAAAAAgH5OTAMA9HmffPJJtm7dmvXr12fPnj2pq6vLtddem1tvvTVtbW2pq6ur9UQAAAAAAAAGCDENANBnHTx4MOvXr8/mzZtz/vz5TJgwId/5zneyYsWKjBkzptbzAAAAAAAAGIDENABAn3Lu3Lls2bIl69evz/vvv5+hQ4dm6dKlufXWWzNnzpwURVHriQAAAAAAAAxgYhoAoOYqlUp2796dDRs2ZNu2benu7s60adPy6KOPZvny5WloaKj1RAAAAAAAAAYJMQ0AUDNHjhzJxo0bs3nz5nz00UcZOXJkbrvttqxYsSLNzc3uQgMAAAAAAECvE9MAAL3q949x2rhxY/bt25e6urq0tbXl0UcfzbXXXpuhQ/16AgAAAAAAQO14twoAuOIqlUp27dqVjRs39jzG6ZprrskjjzySG2+8MaNHj671RAAAAAAAAEgipgEArqDfP8Zp06ZNOXXqVM9jnG6++eY0NTV5jBMAAAAAAAB9jpgGALisfv8Ypw0bNmT//v2pq6vLtddemxUrVniMEwAAAAAAAH2ed7MAgK/t949x2rBhQ9544410d3dn6tSpHuMEAAAAAABAvyOmAQC+svb29mzevDmbNm3K6dOnM3LkyKxcuTI333xzpk2b5jFOAAAAAAAA9DtiGgDgSzl58mReeeWVbN68OYcOHep5jNPNN9+ctrY2j3ECAAAAAACgX/NuFwDwhc6dO5fXX389mzdvzjvvvJOyLDN79ux8//vfz9KlS3P11VfXeiIAAAAAAABcFmIaAOAzdXd3Z+fOndm0aVO2b9+e7u7uTJo0Kffff39uvPHGTJgwodYTAQAAAAAA4LIT0wAAPcqyzN69e7Np06a89tprOXv2bEaNGpWVK1dm+fLlmT59eoqiqPVMAAAAAAAAuGLENABAjh49ms2bN+eVV15JR0dH6uvrc/3112f58uVZsGBBhgwZUuuJAAAAAAAA0CvENAAwSJ0+fTpbtmzJ5s2bc+DAgRRFkQULFuT+++/P4sWLM3z48FpPBAAAAAAAgF4npgGAQaSzszPbtm3L5s2bs3v37lQqlTQ3N+eRRx7JsmXLMmbMmFpPBAAAAAAAgJoS0wDAANfV1ZUdO3Zky5Yt2b59e7q6ujJu3Ljcc889Wb58eaZMmVLriQAAAAAAANBniGkAYAC6ePFidu/enS1btmTbtm25cOFCRo0alVtuuSU33HBDWlpaUhRFrWcCAAAAAABAnyOmAYABolKpZM+ePdmyZUu2bt2as2fPpqGhIUuXLs2yZcsyb9681NXV1XomAAAAAAAA9GliGgDox8qyzL59+7Jly5a8+uqrOX36dIYNG5brrrsuy5YtS2tra4YOddwDAAAAAADApfLuGgD0M2VZpr29vSegOX78eIYOHZprr702y5Yty7XXXpurrrqq1jMBAAAAAACgXxLTAEA/cfTo0WzZsiVbtmzJBx98kLq6urS2tuaBBx7I4sWLM3z48FpPBAAAAAAAgH5PTAMAfVhHR0deffXVbNmyJe3t7SmKInPnzs3dd9+d66+/PldffXWtJwIAAAAAAMCAIqYBgD7m2LFj2bp1a7Zu3ZoDBw4kSWbNmpW//Mu/zJIlS9LY2FjbgQAAAAAAADCAiWkAoA/44IMP8tprr2Xr1q05ePBgkmTmzJl5+OGHs3Tp0owbN67GCwEAAAAAAGBwENMAQI0cOXKkJ6A5dOhQkmT27Nl55JFHsmTJknzjG9+o8UIAAAAAAAAYfMQ0ANBLyrLsCWhee+21HDlyJEVRpKWlJX/5l3+Z66+/PmPHjq31TAAAAAAAABjUxDQAcAWVZZlDhw71BDQffPBBiqLInDlzsmrVqixevDiNjY21ngkAAAAAAABUiWkA4DIryzIHDx7seYTTsWPHUhRF5s2bl7vuuiuLFy/O6NGjaz0TAAAAAAAA+AxiGgC4DMqyzL59+/L6669n69at6ejoSF1dXebPn59vfvObWbx4cUaNGlXrmQAAAAAAAMAXENMAwFfU3d2dd955J6+//nreeOONnDp1KnV1dWltbc23vvWtLF68OCNHjqz1TAAAAAAAAOBLENMAwJfQ2dmZHTt2ZNu2bXnzzTdz/vz5DBs2LAsXLsz111+ftra2NDQ01HomAAAAAAAA8BWJaQDgC5w5cybbt2/Ptm3bsmvXrnR3d+fqq6/OkiVLsnjx4ixYsCD19fW1ngkAAAAAAABcBmIaAPgMHR0d2bZtW7Zt25Z33303ZVlm3Lhxuf3223P99ddn9uzZqaurq/VMAAAAAAAA4DIT0wBAkrIsc+jQoWzbti2vv/562tvbkyTTpk3Lt7/97SxevDjTpk1LURQ1XgoAAAAAAABcSWIaAAatSqWS9957r+cONB0dHSmKIrNnz84jjzyS6667LhMmTKj1TAAAAAAAAKAXiWkAGFQuXLiQXbt2Zfv27XnzzTfz8ccfZ+jQoZk/f37uu+++LFq0KKNHj671TAAAAAAAAKBGxDQADHjHjx/P9u3bs3379rzzzjvp7u5OQ0ND2tract1116WtrS3Dhw+v9UwAAAAAAACgDxDTADDgVCqV7N+/P9u3b88bb7yRw4cPJ0kmTZqU1atXZ9GiRWlpaUldXV2Nm0ixAAAAF/pJREFUlwIAAAAAAAB9jZgGgAGhs7PzU49vOnPmTOrq6tLS0pLvfve7WbRoUSZNmlTrmQAAAAAAAEAfJ6YBoN86ceJEz+Ob3n777XR3d2fEiBFpa2vLokWL0tbWloaGhlrPBAAAAAAAAPoRMQ0A/UZZlj2Pb9q+fXva29uTJBMnTsyqVat6Ht80ZMiQGi8FAAAAAAAA+isxDQB92rlz57Jr167s3LkzO3bsyOnTp1MURVpaWvLwww/3PL6pKIpaTwUAAAAAAAAGADENAH1KWZZpb2/Pjh07smPHjuzduzeVSiUNDQ1pbW3teXzTyJEjaz0VAAAAAAAAGIDENADU3Pnz57N79+7s2LEjO3fuzEcffZQkaWpqyr333pu2trbMnDkzdXV1tR0KAAAAAAAADHhiGgB6XVmWOXToUHbu3Jk333wz7733XiqVSkaMGJHW1ta0tbVl4cKFGTNmTK2nAgAAAAAAAIOMmAaAXnHhwoWeu8/s2LGj5+4z06ZNyz333JOFCxdm9uzZ7j4DAAAAAAAA1JSYBoAroizLHDlypCee2bNnTyqVSoYPH/6pu880NjbWeioAAAAAAABADzENAJfNxx9/nLfeeiu7du3Krl27cvLkySTJ1KlTc/fdd6etrS2zZ8/OkCFDarwUAAAAAAAA4LOJaQD4yrq7u7N3796eeOb9999PWZZpaGjI/Pnz8+1vfzttbW0ZO3ZsracCAAAAAAAAXBIxDQCXrCzLHDt2rCeeefvtt9PZ2Zm6urrMmjUr999/fxYsWJAZM2akrq6u1nMBAAAAAAAAvjQxDQD/qrNnz37q0U0nTpxIkkycODErVqxIa2tr5s6dmxEjRtR4KQAAAAAAAMDXJ6YB4FO6u7uzb9++nnjmwIEDKcsyI0aMyPz583PfffeltbU148ePr/VUAAAAAAAAgMtOTAMwyJVlmaNHj/bcfeYPH900c+bM/Nmf/VlaW1s9ugkAAAAAAAAYFMQ0AIPQiRMn8tZbb/W8Tp06lSSZMGFCbrrpprS2tmbevHke3QQAAAAAAAAMOmIagEHgzJkzefvtt3vimQ8//DBJMmrUqMyfPz/z5s3LggULPLoJAAAAAAAAGPTENAAD0IULF/LOO+/0xDOHDh1KkgwfPjzz5s3L6tWrs2DBgkyZMiVFUdR4LQAAAAAAAEDfIaYBGAC6urry3nvv5a233srbb7+d/fv3p1KppL6+PrNnz85DDz2UBQsWpLm5OXV1dbWeCwAAAAAAANBniWkA+qFKpZL9+/f3PLrp3XffTXd3d+rq6jJjxozce++9mT9/fmbNmpX6+vpazwUAAAAAAADoN8Q0AP3AxYsXc+DAgbzzzjt555138t577+XChQtJkmnTpmXVqlWZP39+5syZk+HDh9d4LQAAAAAAAED/JaYB6IO6u7t74pm33347e/fuTWdnZ5JkypQpWb58eebOnZt58+Zl1KhRNV4LAAAAAAAAMHCIaQD6gO7u7uzbt+9Td57p6upKkkydOjU333xz5s6dmzlz5ohnAAAAAAAAAK4gMQ1ADXR1dWXv3r098czevXvT3d2doigyderUrFy5MnPmzMmcOXNy9dVX13ouAAAAAAAAwKAhpgHoBZ988kn27t2bt99+O3v27Mm+fft64pmmpqasWrWq584zDQ0NtZ4LAAAAAAAAMGiJaQCugI8//jjvvfde3n333bz77rs5cOBALl68mLq6ujQ3N+eOO+7I3Llz09LSkhEjRtR6LgAAAAAAAABVYhqAr6ksy3R0dPSEM++++26OHj2aJBk6dGhmzJiRu+66qyeeGT58eI0XAwAAAAAAAPB5xDQAX1KlUsnBgwc/Fc+cPn06SdLQ0JCWlpbcfPPNaWlpSXNzc+rr62u8GAAAAAAAAIBLJaYB+AKdnZ3Zt29fTzizd+/edHZ2JknGjRuXBQsWpKWlJS0tLZkyZUqKoqjxYgAAAAAAAAC+KjENwB85ffp03nvvvbz77rvZs2dPDh48mEqlkqIoMm3atJ67zsyePTtjx46t9VwAAAAAAAAALiMxDTCoXbx4Me3t7dm7d2/ee++97N27N8ePH0+S1NfXZ+bMmbn33nvT0tKSWbNmZcSIETVeDAAAAAAAAMCVJKYBBpXTp09n7969Pa/9+/enq6srSdLY2JhZs2bljjvuyKxZs9Lc3JyhQ/1nEgAAAAAAAGAw8S4xMGD9a3edGTJkSJqbm7Ny5crMmjXLI5sAAAAAAAAASCKmAQaQS73rzMyZM9Pc3Jz6+voaLwYAAAAAAACgrxHTAP1SV1dXDh48mH379vW8Ojo6krjrDAAAAAAAAABfnZgG6PMqlUqOHj2affv2Zf/+/dm/f3/a29tTqVSS/I+7zqxatSqzZs1y1xkAAAAAAAAAvjIxDdCnlGWZEydO9EQz+/fvz4EDB9LZ2ZkkGTFiRGbMmJF77rknM2fOzPTp09PY2Fjb0QAAAAAAAAAMGGIaoKbOnj37qXBm3759OXPmTJJk6NChaWpqys0335wZM2Zk5syZmThxYoqiqPFqAAAAAAAAAAYqMQ3Qazo7O9Pe3t4TzRw4cCDHjh1LkhRFkcmTJ6etra0nnJk6dWqGDvWfKQAAAAAAAAB6j3epgSuis7Mz77//ft5///0cOHAg77//fo4ePZqyLJMkY8eOzYwZM3LrrbdmxowZmT59eoYPH17j1QAAAAAAAAAMdmIa4Gu7cOFCDh482BPNHDhwIB988EFPODNmzJhMnz49S5cuzfTp09Pc3JzGxsbajgYAAAAAAACAzyCmAb6UCxcu9AQzv49njh071hPONDY2Zvr06Vm2bFmam5szffr0jBkzpsarAQAAAAAAAODSiGmAz3Xu3Lk/uePMsWPHer4/duzYNDc3Z/ny5T13nBk9enQNFwMAAAAAAADA1yOmAVKWZY4fP56DBw+mvb295+Px48d7rvnGN76R6dOnZ8WKFT13nBk1alQNVwMAAAAAAADA5SemgUGmu7s7R44cycGDB3te7e3tOX/+fJKkKIpMnjw5s2bNyu23355p06alublZOAMAAAAAAADAoCCmgQHs7NmzPXea+X00c/jw4VQqlSTJVVddlWnTpuXGG29MU1NTmpqacs011+Sqq66q8XIAAAAAAAAAqA0xDQwAlUolHR0dOXTo0KfimRMnTvRcM2bMmDQ1NeXaa6/NtGnT0tTUlAkTJqSurq6GywEAAAAAAACgbxHTQD9z5syZHDp06E9eXV1dSf7HY5pmz56dVatWpampKdOmTcvo0aNrvBwAAAAAAAAA+j4xDfRRXV1dOXz48J9EM6dPn+65ZtSoUZk6dWpWrlyZqVOnZurUqR7TBAAAAAAAAABfg5gGaqwsy3z44Yd/Es0cO3YsZVkmSerr63PNNdekra2tJ5qZOnWqu80AAAAAAAAAwGUmpoFeUpZlTpw4kSNHjuTw4cOf+tjZ2Znkd49omjBhQqZOnZply5b1RDMTJkxIXV1djX8CAAAAAAAAABj4xDRwmV1KNJMko0ePzjXXXJNbb721J5qZMmVKhg0bVsP1AAAAAAAAADC4iWngKyrLMsePH/+TaObo0aOfimbGjBmTKVOm5JZbbsmUKVNyzTXXZMqUKRk5cmQN1wMAAAAAAAAAn0VMA1+gUqmko6MjR48e/VQ4c+TIkXzyySc91zU2NmbKlCm59dZbe6KZyZMni2YAAAAAAAAAoB8R00DV+fPn88EHH+To0aOfeh07diwXL17sue730cxtt932qTvNNDQ01HA9AAAAAAAAAHA5iGkYVMqyzIkTJ3L06NE/CWdOnTrVc11dXV0mTpyYyZMn57rrrsukSZMyefLkTJ48WTQDAAAAAAAAAAOYmIYBqbOzM8eOHfvMO810dXX1XNfQ0JDJkydn4cKFPbHM5MmTM378+AwZMqSGPwEAAAAAAAAAUAtiGvqt7u7ufPjhhz3RzB9+/Oijj3quK4oi48aNy+TJkzNv3rxPRTNXX311iqKo3Q8BAAAAAAAAAPQpYhr6tIsXL+b48eOfGcycOHEiZVn2XDtq1KhMnDgxra2tmThxYs9jmiZOnJj6+voa/hQAAAAAAAAAQH8hpqHmKpVKTp48+ZnBTEdHRyqVSs+1I0aMyKRJkzJ79uzcfPPNPdHMxIkT09DQUMOfAgAAAAAAAAAYCMQ09IpPPvkkHR0d+fDDD//k9cfBzFVXXZWJEyemqakpS5cuzcSJEzNp0qRMnDjRY5kAAAAAAAAAgCtKTMNlUZZlPv74488MZT788MOcOnXqU9ePGDEiEyZMSFNTU5YsWZIJEyb03GFmzJgxghkAAAAAAAAAoCbENFyy7u7unDhxIh0dHT2vPwxnLly48KnrGxsbM2HChCxcuDATJkz41GvkyJE1+ikAAAAAAAAAAD7fJcU0RVHcm+T/SjIkyX8uy/LfX9FV1ESlUsmJEydy/PjxdHR09Hz8/T+fOnUqZVn2XD906NCMGzcuEyZMSEtLy6dimfHjx6e+vr6GPw0AAAAAAAAAwJf3hTFNURRDkvyHJHcnaU+ypSiKp8qy3HWlx3F5VSqVnDp16lOhzB9+PHnyZCqVSs/1RVFk7NixGT9+fBYsWJDx48dn3LhxPR8bGxtTV1dXw58IAAAAAAAAAODyupQ709yY5N2yLPcmSVEU/5jkwSRimn7iH//xH7Nz584cP348Fy9e/NT3GhsbM27cuLS0tHwqlBk/fnzGjh2bIUOG1Gg1AAAAAAAAAEDvu5SYZmqSg3/weXuS5X98UVEUP0vysyRpbm6+LOO4PEaMGJHm5uZcf/31n4plvvGNb3gUEwAAAAAAAADAH7iUmKb4jK+Vf/KFsvz7JH+fJDfccMOffJ/aefDBB2s9AQAAAAAAAACgX6i7hGvakzT9wefTkhy+MnMAAAAAAAAAAKB2LiWm2ZJkTlEUM4uiuCrJo0meurKzAAAAAAAAAACg933hY57KsuwuiuLfJHk+yZAk/1CW5c4rvgwAAAAAAAAAAHrZF8Y0SVKW5TNJnrnCWwAAAAAAAAAAoKYu5TFPAAAAAAAAAAAwKIhpAAAAAAAAAACgSkwDAAAAAAAAAABVYhoAAAAAAAAAAKgS0wAAAAAAAAAAQJWYBgAAAAAAAAAAqsQ0AAAAAAAAAABQJaYBAAAAAAAAAIAqMQ0AAAAAAAAAAFSJaQAAAAAAAAAAoEpMAwAAAAAAAAAAVWIaAAAAAAAAAACoEtMAAAAAAAAAAECVmAYAAAAAAAAAAKrENAAAAAAAAAAAUCWmAQAAAAAAAACAKjENAAAAAAAAAABUiWkAAAAAAAAAAKBKTAMAAAAAAAAAAFViGgAAAAAAAAAAqBLTAAAAAAAAAABAlZgGAAAAAAAAAACqxDQAAAAAAAAAAFAlpgEAAAAAAAAAgCoxDQAAAAAAAAAAVIlpAAAAAAAAAACgSkwDAAAAAAAAAABVYhoAAAAAAAAAAKgS0wAAAAAAAAAAQJWYBgAAAAAAAAAAqsQ0AAAAAAAAAABQJaYBAAAAAAAAAIAqMQ0AAAAAAAAAAFSJaQAAAAAAAAAAoEpMAwAAAAAAAAAAVWIaAAAAAAAAAACoEtMAAAAAAAAAAECVmAYAAAAAAAAAAKrENAAAAAAAAAAAUCWmAQAAAAAAAACAKjENAAAAAAAAAABUiWkAAAAAAAAAAKBKTAMAAAAAAAAAAFViGgAAAAAAAAAAqBLTAAAAAAAAAABAlZgGAAAAAAAAAACqxDQAAAAAAAAAAFAlpgEAAAAAAAAAgCoxDQAAAAAAAAAAVIlpAAAAAAAAAACgSkwDAAAAAAAAAABVYhoAAAAAAAAAAKgS0wAAAAAAAAAAQJWYBgAAAAAAAAAAqsQ0AAAAAAAAAABQJaYBAAAAAAAAAIAqMQ0AAAAAAAAAAFSJaQAAAAAAAAAAoEpMAwAAAAAAAAAAVWIaAAAAAAAAAACoEtMAAAAAAAAAAECVmAYAAAAAAAAAAKrENAAAAAAAAAAAUCWmAQAAAAAAAACAKjENAAAAAAAAAABUiWkAAAAAAAAAAKBKTAMAAAAAAAAAAFViGgAAAAAAAAAAqBLTAAAAAAAAAABAlZgGAAAAAAAAAACqxDQAAAAAAAAAAFAlpgEAAAAAAAAAgCoxDQAAAAAAAAAAVIlpAAAAAAAAAACgSkwDAAAAAAAAAABVYhoAAAAAAAAAAKgS0wAAAAAAAAAAQJWYBgAAAAAAAAAAqsQ0AAAAAAAAAABQJaYBAAAAAAAAAIAqMQ0AAAAAAAAAAFSJaQAAAAAAAAAAoEpMAwAAAAAAAAAAVWIaAAAAAAAAAACoEtMAAAAAAAAAAECVmAYAAAAAAAAAAKrENAAAAAAAAAAAUCWmAQAAAAAAAACAKjENAAAAAAAAAABUiWkAAAAAAAAAAKBKTAMAAAAAAAAAAFViGgAAAAAAAAAAqBLTAAAAAAAAAABAVVGW5eX/lxbFh0kOXPZ/MV/H+CQdtR4BwIDhXAHgcnKuAHC5OFMAuJycKwBcTs6Vvml6WZYT/viLVySmoe8piuLVsixvqPUOAAYG5woAl5NzBYDLxZkCwOXkXAHgcnKu9C8e8wQAAAAAAAAAAFViGgAAAAAAAAAAqBLTDB5/X+sBAAwozhUALifnCgCXizMFgMvJuQLA5eRc6UeKsixrvQEAAAAAAAAAAPoEd6YBAAAAAAAAAIAqMQ0AAAAAAAAAAFSJaQaYoijuLYri7aIo3i2K4n/5jO8XRVH839Xvby+KYkktdgLQ913CmfJX1bNke1EUG4qiuK4WOwHoH77oXPmD65YVRXGxKIrv9uY+APqXSzlXiqJYVRTFtqIodhZF8S+9vRGA/uMS/h5sTFEUvyyK4o3qufLjWuwEoO8riuIfiqI4VhTFjs/5vvfr+wkxzQBSFMWQJP8hyX1JWpN8ryiK1j+67L4kc6qvnyX5f3t1JAD9wiWeKfuS3F6W5aIk/y7J3/fuSgD6i0s8V35/3f+e5PneXQhAf3Ip50pRFI1J/mOSB8qyXJjkkd7eCUD/cIl/Xvmfkuwqy/K6JKuS/B9FUVzVq0MB6C/+S5J7/5Xve7++nxDTDCw3Jnm3LMu9ZVl+kuQfkzz4R9c8mOS/lr+zKUljURRTensoAH3eF54pZVluKMvyZPXTTUmm9fJGAPqPS/mzSpL8z0n+Ocmx3hwHQL9zKefK95P8oizL95OkLEtnCwCf51LOlTLJqKIoiiRXJzmRpLt3ZwLQH5RluS6/Oyc+j/fr+wkxzcAyNcnBP/i8vfq1L3sNAHzZ8+InSZ69oosA6M++8FwpimJqku8k+U+9uAuA/ulS/rwyN8nYoijWFkXxWlEUj/faOgD6m0s5V/6fJAuSHE7yZpK/K8uy0jvzABhgvF/fTwyt9QAuq+IzvlZ+hWsA4JLPi6IoVud3Mc2tV3QRAP3ZpZwr/2eSf1uW5cXf/c+eAPC5LuVcGZpkaZI7k4xIsrEoik1lWb5zpccB0O9cyrlyT5JtSe5IMjvJC0VRvFyW5ekrvA2Agcf79f2EmGZgaU/S9AefT8vvKukvew0AXNJ5URTFoiT/Ocl9ZVke76VtAPQ/l3Ku3JDkH6shzfgk3yqKorssyyd6ZSEA/cml/h1YR1mWZ5OcLYpiXZLrkohpAPhjl3Ku/DjJvy/LskzyblEU+5LMT/JK70wEYADxfn0/4TFPA8uWJHOKophZFMVVSR5N8tQfXfNUkseL37kpyamyLI/09lAA+rwvPFOKomhO8oskP/B/dwLwBb7wXCnLcmZZljPKspyR5J+S/FxIA8DnuJS/A3syyW1FUQwtiqIhyfIku3t5JwD9w6WcK+/nd3c7S1EUk5LMS7K3V1cCMFB4v76fcGeaAaQsy+6iKP5NkueTDEnyD2VZ7iyK4m+r3/9PSZ5J8q0k7yY5l9/V1ADwKZd4pvyvScYl+Y/Vuwh0l2V5Q602A9B3XeK5AgCX5FLOlbIsdxdF8VyS7UkqSf5zWZY7arcagL7qEv+88u+S/JeiKN7M7x7P8W/Lsuyo2WgA+qyiKP6/JKuSjC+Koj3J/5akPvF+fX9T/O6OdAAAAAAAAAAAgMc8AQAAAAAAAABAlZgGAAAAAAAAAACqxDQAAAAAAAAAAFAlpgEAAAAAAAAAgCoxDQAAAAAAAAAAVIlpAAAAAAAAAACgSkwDAAAAAAAAAABV/z/NuK2W+UUf8gAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 2880x2880 with 1 Axes>"
+       "<Figure size 5760x2880 with 1 Axes>"
       ]
      },
      "metadata": {
@@ -69,167 +67,166 @@
     }
    ],
    "source": [
-    "def visualize_q_func():\n",
-    "    # save_dir = (save_path / '..').resolve()\n",
-    "    # save_dir.mkdir(parents=True, exist_ok=True)\n",
+    "def visualize_env():\n",
     "    \n",
-    "    dpi, width, height = 10, 400, 400\n",
+    "    dpi, width, height = 10, 800, 400\n",
     "    figsize = width / float(dpi), height / float(dpi)\n",
     "    LabelSize, LegendFontsize, font_gap = 40, 40, 5\n",
     "    \n",
     "    fig = plt.figure(figsize=figsize)\n",
     "    \n",
-    "    dataset = SynAdaptiveEnv()\n",
-    "    print(dataset)\n",
+    "    timestamps = 20\n",
+    "    mean_generator = SinGenerator(num=timestamps)\n",
+    "    std_generator = SinGenerator(num=timestamps, min_amplitude=0.5, max_amplitude=0.5)\n",
+    "    std_generator.set_transform(lambda x: x + 1)\n",
+    "    dynamic_env = SyntheticDEnv([mean_generator], [[std_generator]], num_per_task=100)\n",
+    "    print(dynamic_env)\n",
+    "    \n",
     "    xaxis, yaxis = [], []\n",
-    "    for idx, position, value in dataset:\n",
-    "        xaxis.append(position)\n",
-    "        yaxis.append(value)\n",
-    "    \n",
-    "    def draw_ax(cur_ax, xaxis, yaxis, xlabel, ylabel,\n",
-    "                alpha=0.1, color='k', linestyle='-', legend=None, plot_only=False):\n",
-    "        if legend is not None:\n",
-    "            cur_ax.plot(xaxis[:1], yaxis[:1], color=color, label=legend)\n",
-    "        \n",
-    "        if not plot_only:\n",
-    "            cur_ax.set_xlabel(xlabel, fontsize=LabelSize)\n",
-    "            cur_ax.set_ylabel(ylabel, rotation=0, fontsize=LabelSize)\n",
-    "            for tick in cur_ax.xaxis.get_major_ticks():\n",
-    "                tick.label.set_fontsize(LabelSize - font_gap)\n",
-    "                tick.label.set_rotation(10)\n",
-    "            for tick in cur_ax.yaxis.get_major_ticks():\n",
-    "                tick.label.set_fontsize(LabelSize - font_gap)\n",
-    "    \n",
-    "    cur_ax = fig.add_subplot(1, 1, 1)\n",
-    "    cur_ax.plot(xaxis, yaxis, color=\"k\", linestyle=\"-\", alpha=0.6, label=None)\n",
+    "    for timestamp, dataset in dynamic_env:\n",
+    "        num = dataset.shape[0]\n",
+    "        xaxis.append(torch.zeros(num) + timestamp)\n",
+    "        yaxis.append(dataset[:,0])\n",
+    "    xaxis = torch.cat(xaxis).numpy()\n",
+    "    yaxis = torch.cat(yaxis).numpy()\n",
     "\n",
-    "    # fig.savefig(save_path, dpi=dpi, bbox_inches=\"tight\", format=\"pdf\")\n",
-    "    # plt.close(\"all\")\n",
-    "    # plt.show()\n",
-    "visualize_q_func()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "supreme-basis",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def optimize_fn(xs, ys, test_sets):\n",
-    "    xs = torch.FloatTensor(xs).view(-1, 1)\n",
-    "    ys = torch.FloatTensor(ys).view(-1, 1)\n",
-    "    \n",
-    "    model = SuperSequential(\n",
-    "        SuperMLPv1(1, 10, 20, torch.nn.ReLU),\n",
-    "        SuperMLPv1(20, 10, 1, torch.nn.ReLU)\n",
-    "    )\n",
-    "    optimizer = torch.optim.Adam(\n",
-    "        model.parameters(),\n",
-    "        lr=0.01, weight_decay=1e-4, amsgrad=True\n",
-    "    )\n",
-    "    for _iter in range(100):\n",
-    "        preds = model(ys)\n",
-    "\n",
-    "        optimizer.zero_grad()\n",
-    "        loss = torch.nn.functional.mse_loss(preds, ys)\n",
-    "        loss.backward()\n",
-    "        optimizer.step()\n",
-    "        \n",
-    "    with torch.no_grad():\n",
-    "        answers = []\n",
-    "        for test_set in test_sets:\n",
-    "            test_set = torch.FloatTensor(test_set).view(-1, 1)\n",
-    "            preds = model(test_set).view(-1).numpy()\n",
-    "            answers.append(preds.tolist())\n",
-    "    return answers\n",
-    "\n",
-    "def f(x):\n",
-    "    return np.cos( 0.5 * x + x * x)\n",
-    "\n",
-    "def get_data(mode):\n",
-    "    dataset = SynAdaptiveEnv(mode=mode)\n",
-    "    times, xs, ys = [], [], []\n",
-    "    for i, (_, t, x) in enumerate(dataset):\n",
-    "        times.append(t)\n",
-    "        xs.append(x)\n",
-    "    dataset.set_transform(f)\n",
-    "    for i, (_, _, y) in enumerate(dataset):\n",
-    "        ys.append(y)\n",
-    "    return times, xs, ys\n",
-    "\n",
-    "def visualize_syn(save_path):\n",
-    "    save_dir = (save_path / '..').resolve()\n",
-    "    save_dir.mkdir(parents=True, exist_ok=True)\n",
-    "    \n",
-    "    dpi, width, height = 40, 2000, 900\n",
-    "    figsize = width / float(dpi), height / float(dpi)\n",
-    "    LabelSize, LegendFontsize, font_gap = 40, 40, 5\n",
-    "    \n",
-    "    fig = plt.figure(figsize=figsize)\n",
-    "    \n",
-    "    times, xs, ys = get_data(None)\n",
-    "    \n",
-    "    def draw_ax(cur_ax, xaxis, yaxis, xlabel, ylabel,\n",
-    "                alpha=0.1, color='k', linestyle='-', legend=None, plot_only=False):\n",
-    "        if legend is not None:\n",
-    "            cur_ax.plot(xaxis[:1], yaxis[:1], color=color, label=legend)\n",
-    "        cur_ax.plot(xaxis, yaxis, color=color, linestyle=linestyle, alpha=alpha, label=None)\n",
-    "        if not plot_only:\n",
-    "            cur_ax.set_xlabel(xlabel, fontsize=LabelSize)\n",
-    "            cur_ax.set_ylabel(ylabel, rotation=0, fontsize=LabelSize)\n",
-    "            for tick in cur_ax.xaxis.get_major_ticks():\n",
-    "                tick.label.set_fontsize(LabelSize - font_gap)\n",
-    "                tick.label.set_rotation(10)\n",
-    "            for tick in cur_ax.yaxis.get_major_ticks():\n",
-    "                tick.label.set_fontsize(LabelSize - font_gap)\n",
-    "    \n",
     "    cur_ax = fig.add_subplot(2, 1, 1)\n",
-    "    draw_ax(cur_ax, times, xs, \"time\", \"x\", alpha=1.0, legend=None)\n",
-    "\n",
+    "    cur_ax.scatter(xaxis, yaxis, color=\"k\", linestyle=\"-\", alpha=0.6, label=None)\n",
+    "    cur_ax.set_xlabel(\"Time\", fontsize=LabelSize)\n",
+    "    cur_ax.set_ylabel(\"X\", rotation=0, fontsize=LabelSize)\n",
+    "    for tick in cur_ax.xaxis.get_major_ticks():\n",
+    "        tick.label.set_fontsize(LabelSize - font_gap)\n",
+    "        tick.label.set_rotation(10)\n",
+    "    for tick in cur_ax.yaxis.get_major_ticks():\n",
+    "        tick.label.set_fontsize(LabelSize - font_gap)\n",
+    "    \n",
     "    cur_ax = fig.add_subplot(2, 1, 2)\n",
-    "    draw_ax(cur_ax, times, ys, \"time\", \"y\", alpha=0.1, legend=\"ground truth\")\n",
-    "    \n",
-    "    train_times, train_xs, train_ys = get_data(\"train\")\n",
-    "    draw_ax(cur_ax, train_times, train_ys, None, None, alpha=1.0, color='r', legend=None, plot_only=True)\n",
-    "    \n",
-    "    valid_times, valid_xs, valid_ys = get_data(\"valid\")\n",
-    "    draw_ax(cur_ax, valid_times, valid_ys, None, None, alpha=1.0, color='g', legend=None, plot_only=True)\n",
-    "    \n",
-    "    test_times, test_xs, test_ys = get_data(\"test\")\n",
-    "    draw_ax(cur_ax, test_times, test_ys, None, None, alpha=1.0, color='b', legend=None, plot_only=True)\n",
-    "    \n",
-    "    # optimize MLP models\n",
-    "#     [train_preds, valid_preds, test_preds] = optimize_fn(train_xs, train_ys, [train_xs, valid_xs, test_xs])\n",
-    "#     draw_ax(cur_ax, train_times, train_preds, None, None,\n",
-    "#             alpha=1.0, linestyle='--', color='r', legend=\"MLP\", plot_only=True)\n",
-    "#     import pdb; pdb.set_trace()\n",
-    "#     draw_ax(cur_ax, valid_times, valid_preds, None, None,\n",
-    "#             alpha=1.0, linestyle='--', color='g', legend=None, plot_only=True)\n",
-    "#     draw_ax(cur_ax, test_times, test_preds, None, None,\n",
-    "#             alpha=1.0, linestyle='--', color='b', legend=None, plot_only=True)\n",
+    "    cur_ax.scatter(xaxis, yaxis, color=\"k\", linestyle=\"-\", alpha=0.6, label=None)\n",
+    "    cur_ax.set_xlabel(\"Time\", fontsize=LabelSize)\n",
+    "    cur_ax.set_ylabel(\"X\", rotation=0, fontsize=LabelSize)\n",
+    "    for tick in cur_ax.xaxis.get_major_ticks():\n",
+    "        tick.label.set_fontsize(LabelSize - font_gap)\n",
+    "        tick.label.set_rotation(10)\n",
+    "    for tick in cur_ax.yaxis.get_major_ticks():\n",
+    "        tick.label.set_fontsize(LabelSize - font_gap)\n",
+    "    plt.show()\n",
     "\n",
-    "    plt.legend(loc=1, fontsize=LegendFontsize)\n",
-    "\n",
-    "    fig.savefig(save_path, dpi=dpi, bbox_inches=\"tight\", format=\"pdf\")\n",
-    "    plt.close(\"all\")\n",
-    "    # plt.show()"
+    "visualize_env()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
+   "id": "supreme-basis",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def optimize_fn(xs, ys, test_sets):\n",
+    "#     xs = torch.FloatTensor(xs).view(-1, 1)\n",
+    "#     ys = torch.FloatTensor(ys).view(-1, 1)\n",
+    "    \n",
+    "#     model = SuperSequential(\n",
+    "#         SuperMLPv1(1, 10, 20, torch.nn.ReLU),\n",
+    "#         SuperMLPv1(20, 10, 1, torch.nn.ReLU)\n",
+    "#     )\n",
+    "#     optimizer = torch.optim.Adam(\n",
+    "#         model.parameters(),\n",
+    "#         lr=0.01, weight_decay=1e-4, amsgrad=True\n",
+    "#     )\n",
+    "#     for _iter in range(100):\n",
+    "#         preds = model(ys)\n",
+    "\n",
+    "#         optimizer.zero_grad()\n",
+    "#         loss = torch.nn.functional.mse_loss(preds, ys)\n",
+    "#         loss.backward()\n",
+    "#         optimizer.step()\n",
+    "        \n",
+    "#     with torch.no_grad():\n",
+    "#         answers = []\n",
+    "#         for test_set in test_sets:\n",
+    "#             test_set = torch.FloatTensor(test_set).view(-1, 1)\n",
+    "#             preds = model(test_set).view(-1).numpy()\n",
+    "#             answers.append(preds.tolist())\n",
+    "#     return answers\n",
+    "\n",
+    "# def f(x):\n",
+    "#     return np.cos( 0.5 * x + x * x)\n",
+    "\n",
+    "# def get_data(mode):\n",
+    "#     dataset = SynAdaptiveEnv(mode=mode)\n",
+    "#     times, xs, ys = [], [], []\n",
+    "#     for i, (_, t, x) in enumerate(dataset):\n",
+    "#         times.append(t)\n",
+    "#         xs.append(x)\n",
+    "#     dataset.set_transform(f)\n",
+    "#     for i, (_, _, y) in enumerate(dataset):\n",
+    "#         ys.append(y)\n",
+    "#     return times, xs, ys\n",
+    "\n",
+    "# def visualize_syn(save_path):\n",
+    "#     save_dir = (save_path / '..').resolve()\n",
+    "#     save_dir.mkdir(parents=True, exist_ok=True)\n",
+    "    \n",
+    "#     dpi, width, height = 40, 2000, 900\n",
+    "#     figsize = width / float(dpi), height / float(dpi)\n",
+    "#     LabelSize, LegendFontsize, font_gap = 40, 40, 5\n",
+    "    \n",
+    "#     fig = plt.figure(figsize=figsize)\n",
+    "    \n",
+    "#     times, xs, ys = get_data(None)\n",
+    "    \n",
+    "#     def draw_ax(cur_ax, xaxis, yaxis, xlabel, ylabel,\n",
+    "#                 alpha=0.1, color='k', linestyle='-', legend=None, plot_only=False):\n",
+    "#         if legend is not None:\n",
+    "#             cur_ax.plot(xaxis[:1], yaxis[:1], color=color, label=legend)\n",
+    "#         cur_ax.plot(xaxis, yaxis, color=color, linestyle=linestyle, alpha=alpha, label=None)\n",
+    "#         if not plot_only:\n",
+    "#             cur_ax.set_xlabel(xlabel, fontsize=LabelSize)\n",
+    "#             cur_ax.set_ylabel(ylabel, rotation=0, fontsize=LabelSize)\n",
+    "#             for tick in cur_ax.xaxis.get_major_ticks():\n",
+    "#                 tick.label.set_fontsize(LabelSize - font_gap)\n",
+    "#                 tick.label.set_rotation(10)\n",
+    "#             for tick in cur_ax.yaxis.get_major_ticks():\n",
+    "#                 tick.label.set_fontsize(LabelSize - font_gap)\n",
+    "    \n",
+    "#     cur_ax = fig.add_subplot(2, 1, 1)\n",
+    "#     draw_ax(cur_ax, times, xs, \"time\", \"x\", alpha=1.0, legend=None)\n",
+    "\n",
+    "#     cur_ax = fig.add_subplot(2, 1, 2)\n",
+    "#     draw_ax(cur_ax, times, ys, \"time\", \"y\", alpha=0.1, legend=\"ground truth\")\n",
+    "    \n",
+    "#     train_times, train_xs, train_ys = get_data(\"train\")\n",
+    "#     draw_ax(cur_ax, train_times, train_ys, None, None, alpha=1.0, color='r', legend=None, plot_only=True)\n",
+    "    \n",
+    "#     valid_times, valid_xs, valid_ys = get_data(\"valid\")\n",
+    "#     draw_ax(cur_ax, valid_times, valid_ys, None, None, alpha=1.0, color='g', legend=None, plot_only=True)\n",
+    "    \n",
+    "#     test_times, test_xs, test_ys = get_data(\"test\")\n",
+    "#     draw_ax(cur_ax, test_times, test_ys, None, None, alpha=1.0, color='b', legend=None, plot_only=True)\n",
+    "    \n",
+    "#     # optimize MLP models\n",
+    "# #     [train_preds, valid_preds, test_preds] = optimize_fn(train_xs, train_ys, [train_xs, valid_xs, test_xs])\n",
+    "# #     draw_ax(cur_ax, train_times, train_preds, None, None,\n",
+    "# #             alpha=1.0, linestyle='--', color='r', legend=\"MLP\", plot_only=True)\n",
+    "# #     import pdb; pdb.set_trace()\n",
+    "# #     draw_ax(cur_ax, valid_times, valid_preds, None, None,\n",
+    "# #             alpha=1.0, linestyle='--', color='g', legend=None, plot_only=True)\n",
+    "# #     draw_ax(cur_ax, test_times, test_preds, None, None,\n",
+    "# #             alpha=1.0, linestyle='--', color='b', legend=None, plot_only=True)\n",
+    "\n",
+    "#     plt.legend(loc=1, fontsize=LegendFontsize)\n",
+    "\n",
+    "#     fig.savefig(save_path, dpi=dpi, bbox_inches=\"tight\", format=\"pdf\")\n",
+    "#     plt.close(\"all\")\n",
+    "#     # plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
    "id": "shared-envelope",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The Desktop is at: /Users/xuanyidong/Desktop\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualization\n",
     "# home_dir = Path.home()\n",
diff --git a/tests/test_synthetic_env.py b/tests/test_synthetic_env.py
new file mode 100644
index 0000000..3db40b0
--- /dev/null
+++ b/tests/test_synthetic_env.py
@@ -0,0 +1,30 @@
+#####################################################
+# Copyright (c) Xuanyi Dong [GitHub D-X-Y], 2021.04 #
+#####################################################
+# pytest tests/test_synthetic_env.py -s             #
+#####################################################
+import sys, random
+import unittest
+import pytest
+from pathlib import Path
+
+lib_dir = (Path(__file__).parent / ".." / "lib").resolve()
+print("library path: {:}".format(lib_dir))
+if str(lib_dir) not in sys.path:
+    sys.path.insert(0, str(lib_dir))
+
+from datasets import ConstantGenerator, SinGenerator
+from datasets import SyntheticDEnv
+
+
+class TestSynethicEnv(unittest.TestCase):
+    """Test the synethtic environment."""
+
+    def test_simple(self):
+        mean_generator = SinGenerator()
+        std_generator = ConstantGenerator(constant=0.5)
+
+        dataset = SyntheticDEnv([mean_generator], [[std_generator]])
+        print(dataset)
+        for timestamp, tau in dataset:
+            assert tau.shape == (5000, 1)
diff --git a/tests/test_synthetic.py b/tests/test_synthetic_utils.py
similarity index 74%
rename from tests/test_synthetic.py
rename to tests/test_synthetic_utils.py
index f9dff6a..e28dcb9 100644
--- a/tests/test_synthetic.py
+++ b/tests/test_synthetic_utils.py
@@ -1,7 +1,7 @@
 #####################################################
 # Copyright (c) Xuanyi Dong [GitHub D-X-Y], 2021.03 #
 #####################################################
-# pytest tests/test_synthetic.py -s                 #
+# pytest tests/test_synthetic_utils.py -s           #
 #####################################################
 import sys, random
 import unittest
@@ -14,7 +14,7 @@ if str(lib_dir) not in sys.path:
     sys.path.insert(0, str(lib_dir))
 
 from datasets import QuadraticFunc
-from datasets import SynAdaptiveEnv
+from datasets import ConstantGenerator, SinGenerator
 
 
 class TestQuadraticFunc(unittest.TestCase):
@@ -40,11 +40,21 @@ class TestQuadraticFunc(unittest.TestCase):
         self.assertTrue(abs(function[1] - 1) < thresh)
 
 
-class TestSynAdaptiveEnv(unittest.TestCase):
-    """Test the synethtic adaptive environment."""
+class TestConstantGenerator(unittest.TestCase):
+    """Test the constant data generator."""
 
     def test_simple(self):
-        dataset = SynAdaptiveEnv()
+        dataset = ConstantGenerator()
+        for i, (idx, t, x) in enumerate(dataset):
+            assert i == idx, "First loop: {:} vs {:}".format(i, idx)
+            assert x == 0.1
+
+
+class TestSinGenerator(unittest.TestCase):
+    """Test the synethtic data generator."""
+
+    def test_simple(self):
+        dataset = SinGenerator()
         for i, (idx, t, x) in enumerate(dataset):
             assert i == idx, "First loop: {:} vs {:}".format(i, idx)
         for i, (idx, t, x) in enumerate(dataset):