diff --git a/README.md b/README.md
index 39e2cea..fd719a7 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,5 @@
-Python-ELM v0.3
-===============
-
-__---> ARCHIVED March 2021 <---__
+Python-ELM
+==========
 
 ###### This is an implementation of the [Extreme Learning Machine](http://www.extreme-learning-machines.org) [1][2] in Python, based on [scikit-learn](http://scikit-learn.org).
 
@@ -9,12 +7,11 @@ __---> ARCHIVED March 2021 <---__
 
 > It is clear that the learning speed of feedforward neural networks is in general far slower than required and it has been a major bottleneck in their applications for past decades. Two key reasons behind may be: 1) the slow gradient- based learning algorithms are extensively used to train neural networks, and 2) all the parameters of the networks are tuned iteratively by using such learning algorithms. Unlike these traditional implementations, this paper proposes a new learning algorithm called extreme learning machine (ELM) for single- hidden layer feedforward neural networks (SLFNs) which ran- domly chooses the input weights and analytically determines the output weights of SLFNs. In theory, this algorithm tends to provide the best generalization performance at extremely fast learning speed. The experimental results based on real- world benchmarking function approximation and classification problems including large complex applications show that the new algorithm can produce best generalization performance in some cases and can learn much faster than traditional popular learning algorithms for feedforward neural networks.
 
-It's a work in progress, so things can/might/will change.
 
-__David C. Lambert__  
-__dcl [at] panix [dot] com__  
+The implementation is an update of the original repo [Python-ELM](https://github.com/dclambert/Python-ELM) by David C. Lambert.
+
+It's a work in progress, so things can/might/will change.
 
-__Copyright © 2013__  
 __License: Simple BSD__
 
 Files
diff --git a/elm.py b/elm.py
index 2c33336..47aa040 100644
--- a/elm.py
+++ b/elm.py
@@ -17,26 +17,26 @@
 ----------
 .. [1] http://www.extreme-learning-machines.org
 .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine:
-          Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
-          2006.
+    Theory and Applications", Neurocomputing, vol. 70, pp. 489-501, 2006.
 """
 
 from abc import ABCMeta, abstractmethod
 
 import numpy as np
-from scipy.linalg import pinv2
+from scipy.linalg import pinv
 
 from sklearn.utils import as_float_array
 from sklearn.utils.extmath import safe_sparse_dot
 from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
 from sklearn.preprocessing import LabelBinarizer
+from random_layer import MLPRandomLayer, RandomLayer
 
-from random_layer import RandomLayer, MLPRandomLayer
-
-__all__ = ["ELMRegressor",
-           "ELMClassifier",
-           "GenELMRegressor",
-           "GenELMClassifier"]
+__all__ = [
+    "ELMRegressor",
+    "ELMClassifier",
+    "GenELMRegressor",
+    "GenELMClassifier"
+]
 
 
 # BaseELM class, regressor and hidden_layer attributes
@@ -130,13 +130,14 @@ class GenELMRegressor(BaseELM, RegressorMixin):
     ----------
     .. [1] http://www.extreme-learning-machines.org
     .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine:
-          Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
-              2006.
+        Theory and Applications", Neurocomputing, vol. 70, pp. 489-501, 2006.
     """
 
-    def __init__(self,
-                 hidden_layer=MLPRandomLayer(random_state=0),
-                 regressor=None):
+    def __init__(
+        self,
+        hidden_layer=MLPRandomLayer(random_state=0),
+        regressor=None
+    ):
 
         super(GenELMRegressor, self).__init__(hidden_layer, regressor)
 
@@ -150,8 +151,10 @@ def _fit_regression(self, y):
         or supplied regressor
         """
         if (self.regressor is None):
-            self.coefs_ = safe_sparse_dot(pinv2(self.hidden_activations_), y)
+            self.coefs_ = safe_sparse_dot(pinv(self.hidden_activations_), y)
         else:
+            if len(y.shape) > 1 and y.shape[1] == 1:
+                y = y.ravel()
             self.regressor.fit(self.hidden_activations_, y)
 
         self.fitted_ = True
@@ -233,7 +236,7 @@ class GenELMClassifier(BaseELM, ClassifierMixin):
         (default=MLPRandomLayer(random_state=0))
 
     `binarizer` : LabelBinarizer, optional
-        (default=LabelBinarizer(-1, 1))
+        (default=LabelBinarizer(neg_label=-1, pos_label=1))
 
     `regressor`    : regressor instance, optional (default=None)
         If provided, this object is used to perform the regression from hidden
@@ -256,13 +259,14 @@ class GenELMClassifier(BaseELM, ClassifierMixin):
     ----------
     .. [1] http://www.extreme-learning-machines.org
     .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine:
-              Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
-              2006.
+        Theory and Applications", Neurocomputing, vol. 70, pp. 489-501, 2006.
     """
-    def __init__(self,
-                 hidden_layer=MLPRandomLayer(random_state=0),
-                 binarizer=LabelBinarizer(-1, 1),
-                 regressor=None):
+    def __init__(
+        self,
+        hidden_layer=MLPRandomLayer(random_state=0),
+        binarizer=LabelBinarizer(neg_label=-1, pos_label=1),
+        regressor=None,
+    ):
 
         super(GenELMClassifier, self).__init__(hidden_layer, regressor)
 
@@ -401,13 +405,15 @@ class ELMRegressor(BaseEstimator, RegressorMixin):
     ----------
     .. [1] http://www.extreme-learning-machines.org
     .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine:
-          Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
-              2006.
+        Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
+        2006.
     """
 
-    def __init__(self, n_hidden=20, alpha=0.5, rbf_width=1.0,
-                 activation_func='tanh', activation_args=None,
-                 user_components=None, regressor=None, random_state=None):
+    def __init__(
+        self, n_hidden=20, alpha=0.5, rbf_width=1.0,
+        activation_func='tanh', activation_args=None,
+        user_components=None, regressor=None, random_state=None
+    ):
 
         self.n_hidden = n_hidden
         self.alpha = alpha
@@ -423,12 +429,14 @@ def __init__(self, n_hidden=20, alpha=0.5, rbf_width=1.0,
     def _create_random_layer(self):
         """Pass init params to RandomLayer"""
 
-        return RandomLayer(n_hidden=self.n_hidden,
-                           alpha=self.alpha, random_state=self.random_state,
-                           activation_func=self.activation_func,
-                           activation_args=self.activation_args,
-                           user_components=self.user_components,
-                           rbf_width=self.rbf_width)
+        return RandomLayer(
+            n_hidden=self.n_hidden,
+            alpha=self.alpha, random_state=self.random_state,
+            activation_func=self.activation_func,
+            activation_args=self.activation_args,
+            user_components=self.user_components,
+            rbf_width=self.rbf_width
+        )
 
     def fit(self, X, y):
         """
@@ -451,8 +459,10 @@ def fit(self, X, y):
             Returns an instance of self.
         """
         rhl = self._create_random_layer()
-        self._genelm_regressor = GenELMRegressor(hidden_layer=rhl,
-                                                 regressor=self.regressor)
+        self._genelm_regressor = GenELMRegressor(
+            hidden_layer=rhl,
+            regressor=self.regressor
+        )
         self._genelm_regressor.fit(X, y)
         return self
 
@@ -525,24 +535,27 @@ class ELMClassifier(ELMRegressor):
     ----------
     .. [1] http://www.extreme-learning-machines.org
     .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine:
-          Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
-              2006.
+        Theory and Applications", Neurocomputing, vol. 70, pp. 489-501, 2006.
     """
 
-    def __init__(self, n_hidden=20, alpha=0.5, rbf_width=1.0,
-                 activation_func='tanh', activation_args=None,
-                 user_components=None, regressor=None,
-                 binarizer=LabelBinarizer(-1, 1),
-                 random_state=None):
-
-        super(ELMClassifier, self).__init__(n_hidden=n_hidden,
-                                            alpha=alpha,
-                                            random_state=random_state,
-                                            activation_func=activation_func,
-                                            activation_args=activation_args,
-                                            user_components=user_components,
-                                            rbf_width=rbf_width,
-                                            regressor=regressor)
+    def __init__(
+        self, n_hidden=20, alpha=0.5, rbf_width=1.0,
+        activation_func='tanh', activation_args=None,
+        user_components=None, regressor=None,
+        binarizer=LabelBinarizer(neg_label=-1, pos_label=1),
+        random_state=None
+    ):
+
+        super(ELMClassifier, self).__init__(
+            n_hidden=n_hidden,
+            alpha=alpha,
+            random_state=random_state,
+            activation_func=activation_func,
+            activation_args=activation_args,
+            user_components=user_components,
+            rbf_width=rbf_width,
+            regressor=regressor
+        )
 
         self.classes_ = None
         self.binarizer = binarizer
diff --git a/elm_notebook.ipynb b/elm_notebook.ipynb
new file mode 100644
index 0000000..e9f1171
--- /dev/null
+++ b/elm_notebook.ipynb
@@ -0,0 +1,1128 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import time\n",
+    "import numpy as np\n",
+    "from sklearn.cluster import k_means\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from elm import ELMClassifier, ELMRegressor, GenELMClassifier, GenELMRegressor\n",
+    "from random_layer import RandomLayer, MLPRandomLayer, RBFRandomLayer, GRBFRandomLayer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_toy():\n",
+    "    x = np.arange(0.25, 20, 0.1)\n",
+    "    y = x * np.cos(x) + 0.5 * np.sqrt(x) * np.random.randn(x.shape[0])\n",
+    "    x = x.reshape(-1,1)\n",
+    "    y = y.reshape(-1,1)\n",
+    "    return x, y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def res_dist(x, y, e, n_runs=100, random_state=None):\n",
+    "    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=random_state)\n",
+    "\n",
+    "    test_res = []\n",
+    "    train_res = []\n",
+    "    start_time = time()\n",
+    "\n",
+    "    for i in range(n_runs):\n",
+    "        e.fit(x_train, y_train)\n",
+    "        train_res.append(e.score(x_train, y_train))\n",
+    "        test_res.append(e.score(x_test, y_test))\n",
+    "        if (i % (n_runs / 10) == 0):\n",
+    "            print(f\"{i:d}\")\n",
+    "\n",
+    "    print(f\"\\nTime: {time() - start_time:.3f} secs\")\n",
+    "\n",
+    "    print(f\"Test Min: {min(test_res):.3f} Mean: {np.mean(test_res):.3f} Max: {max(test_res):.3f} SD: {np.std(test_res):.3f}\")\n",
+    "    print(f\"Test Min: {min(train_res):.3f} Mean: {np.mean(train_res):.3f} Max: {max(train_res):.3f} SD: {np.std(train_res):.3f}\")\n",
+    "    print()\n",
+    "    return (train_res, test_res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df17607700>]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.datasets import load_iris, load_digits, load_diabetes, make_regression\n",
+    "\n",
+    "stdsc = StandardScaler()\n",
+    "\n",
+    "iris = load_iris()\n",
+    "irx, iry = stdsc.fit_transform(iris.data), iris.target\n",
+    "irx_train, irx_test, iry_train, iry_test = train_test_split(irx, iry, test_size=0.2)\n",
+    "\n",
+    "digits = load_digits()\n",
+    "dgx, dgy = stdsc.fit_transform(digits.data / 16.0), digits.target\n",
+    "dgx_train, dgx_test, dgy_train, dgy_test = train_test_split(dgx, dgy, test_size=0.2)\n",
+    "\n",
+    "diabetes = load_diabetes()\n",
+    "dbx, dby = stdsc.fit_transform(diabetes.data), diabetes.target\n",
+    "dbx_train, dbx_test, dby_train, dby_test = train_test_split(dbx, dby, test_size=0.2)\n",
+    "\n",
+    "mrx, mry = make_regression(n_samples=2000, n_targets=4)\n",
+    "mrx_train, mrx_test, mry_train, mry_test = train_test_split(mrx, mry, test_size=0.2)\n",
+    "\n",
+    "xtoy, ytoy = make_toy()\n",
+    "xtoy, ytoy = stdsc.fit_transform(xtoy), stdsc.fit_transform(ytoy)\n",
+    "xtoy_train, xtoy_test, ytoy_train, ytoy_test = train_test_split(xtoy, ytoy, test_size=0.2)\n",
+    "plt.plot(xtoy, ytoy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sine\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.342 secs\n",
+      "Test Min: 0.850 Mean: 0.933 Max: 0.967 SD: 0.020\n",
+      "Test Min: 0.978 Mean: 0.995 Max: 1.000 SD: 0.006\n",
+      "\n",
+      "tanh\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.294 secs\n",
+      "Test Min: 0.850 Mean: 0.931 Max: 0.967 SD: 0.020\n",
+      "Test Min: 0.978 Mean: 0.994 Max: 1.000 SD: 0.007\n",
+      "\n",
+      "tribas\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.319 secs\n",
+      "Test Min: 0.717 Mean: 0.885 Max: 0.983 SD: 0.049\n",
+      "Test Min: 0.878 Mean: 0.965 Max: 1.000 SD: 0.026\n",
+      "\n",
+      "inv_tribas\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.287 secs\n",
+      "Test Min: 0.750 Mean: 0.889 Max: 0.967 SD: 0.045\n",
+      "Test Min: 0.867 Mean: 0.970 Max: 1.000 SD: 0.025\n",
+      "\n",
+      "sigmoid\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.267 secs\n",
+      "Test Min: 0.867 Mean: 0.934 Max: 0.967 SD: 0.017\n",
+      "Test Min: 0.978 Mean: 0.995 Max: 1.000 SD: 0.006\n",
+      "\n",
+      "softlim\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.273 secs\n",
+      "Test Min: 0.783 Mean: 0.904 Max: 0.983 SD: 0.038\n",
+      "Test Min: 0.889 Mean: 0.978 Max: 1.000 SD: 0.019\n",
+      "\n",
+      "hardlim\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.260 secs\n",
+      "Test Min: 0.483 Mean: 0.772 Max: 0.950 SD: 0.088\n",
+      "Test Min: 0.611 Mean: 0.865 Max: 0.989 SD: 0.073\n",
+      "\n",
+      "gaussian\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.275 secs\n",
+      "Test Min: 0.750 Mean: 0.924 Max: 0.983 SD: 0.026\n",
+      "Test Min: 0.944 Mean: 0.989 Max: 1.000 SD: 0.009\n",
+      "\n",
+      "multiquadric\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.254 secs\n",
+      "Test Min: 0.867 Mean: 0.933 Max: 0.983 SD: 0.021\n",
+      "Test Min: 0.978 Mean: 0.994 Max: 1.000 SD: 0.007\n",
+      "\n",
+      "inv_multiquadric\n",
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 0.262 secs\n",
+      "Test Min: 0.817 Mean: 0.926 Max: 0.967 SD: 0.023\n",
+      "Test Min: 0.967 Mean: 0.991 Max: 1.000 SD: 0.008\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for af in RandomLayer.activation_func_names():\n",
+    "    print(af)\n",
+    "    elmc = ELMClassifier(activation_func=af)\n",
+    "    tr, ts = res_dist(irx, iry, elmc, n_runs=200, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0, 1, 2])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "elmc.classes_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sine\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 1.061 secs\n",
+      "Test Min: 0.191 Mean: 0.191 Max: 0.191 SD: 0.000\n",
+      "Test Min: 0.234 Mean: 0.234 Max: 0.234 SD: 0.000\n",
+      "\n",
+      "tanh\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.967 secs\n",
+      "Test Min: 0.627 Mean: 0.627 Max: 0.627 SD: 0.000\n",
+      "Test Min: 0.680 Mean: 0.680 Max: 0.680 SD: 0.000\n",
+      "\n",
+      "tribas\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.833 secs\n",
+      "Test Min: 0.292 Mean: 0.292 Max: 0.292 SD: 0.000\n",
+      "Test Min: 0.356 Mean: 0.356 Max: 0.356 SD: 0.000\n",
+      "\n",
+      "inv_tribas\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.720 secs\n",
+      "Test Min: 0.275 Mean: 0.275 Max: 0.275 SD: 0.000\n",
+      "Test Min: 0.355 Mean: 0.355 Max: 0.355 SD: 0.000\n",
+      "\n",
+      "sigmoid\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.738 secs\n",
+      "Test Min: 0.683 Mean: 0.683 Max: 0.683 SD: 0.000\n",
+      "Test Min: 0.738 Mean: 0.738 Max: 0.738 SD: 0.000\n",
+      "\n",
+      "softlim\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.719 secs\n",
+      "Test Min: 0.620 Mean: 0.620 Max: 0.620 SD: 0.000\n",
+      "Test Min: 0.660 Mean: 0.660 Max: 0.660 SD: 0.000\n",
+      "\n",
+      "hardlim\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.684 secs\n",
+      "Test Min: 0.517 Mean: 0.517 Max: 0.517 SD: 0.000\n",
+      "Test Min: 0.599 Mean: 0.599 Max: 0.599 SD: 0.000\n",
+      "\n",
+      "gaussian\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.702 secs\n",
+      "Test Min: 0.420 Mean: 0.420 Max: 0.420 SD: 0.000\n",
+      "Test Min: 0.454 Mean: 0.454 Max: 0.454 SD: 0.000\n",
+      "\n",
+      "multiquadric\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.665 secs\n",
+      "Test Min: 0.697 Mean: 0.697 Max: 0.697 SD: 0.000\n",
+      "Test Min: 0.737 Mean: 0.737 Max: 0.737 SD: 0.000\n",
+      "\n",
+      "inv_multiquadric\n",
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.800 secs\n",
+      "Test Min: 0.634 Mean: 0.634 Max: 0.634 SD: 0.000\n",
+      "Test Min: 0.657 Mean: 0.657 Max: 0.657 SD: 0.000\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for af in RandomLayer.activation_func_names():\n",
+    "    print(af)\n",
+    "    elmc = ELMClassifier(activation_func=af, random_state=0)\n",
+    "    tr, ts = res_dist(dgx, dgy, elmc, n_runs=100, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 44.213 secs\n",
+      "Test Min: 0.848 Mean: 0.879 Max: 0.903 SD: 0.010\n",
+      "Test Min: 0.996 Mean: 0.999 Max: 1.000 SD: 0.001\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x1df17687e20>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "elmc = ELMClassifier(n_hidden=500, activation_func='multiquadric')\n",
+    "tr, ts = res_dist(dgx, dgy, elmc, n_runs=100, random_state=0)\n",
+    "plt.scatter(tr, ts, alpha=0.1, marker='D', c='r')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9757494137676193 0.9574473162536483\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df17712820>,\n",
+       " <matplotlib.lines.Line2D at 0x1df17712880>]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACAeUlEQVR4nO3dd3xkZfX48c+9U1MmvZfNbrK9N3bZpS1tKSJFpYuAiorwUwQL6FexIaKIouIX0a+sAgIqTTrLssA2dmF73002ddN7n3bv7487M0m2JtkkdzI579crLzI3k5mTIZucnOc851F0XdcRQgghhDCBanYAQgghhBi7JBERQgghhGkkERFCCCGEaSQREUIIIYRpJBERQgghhGkkERFCCCGEaSQREUIIIYRpJBERQgghhGmsZgdwIpqmUVlZicvlQlEUs8MRQgghRD/ouk5bWxtZWVmo6olrHmGdiFRWVpKbm2t2GEIIIYQYhPLycnJyck54n7BORFwuF2B8IXFxcSZHI4QQQoj+aG1tJTc3N/R7/ETCOhEJLsfExcVJIiKEEEKMMv1pq5BmVSGEEEKYRhIRIYQQQphGEhEhhBBCmEYSESGEEEKYRhIRIYQQQphGEhEhhBBCmEYSESGEEEKYRhIRIYQQQphGEhEhhBBCmEYSESGEEEKYRhIRIYQQQphGEhEhhBBCmEYSESGEECJMbDzUwJPritF13exQRkxYn74rhBBCjBXPbCzlhy/vQtNhdk48C/KSzA5pREhFRAghhDDZ71cd5AcvGUkIQGVzt7kBjSBJRIQQQggTVbd088jKAwAkRNsAqG93mxnSiJJERAghhDBRcX0HAOOTo7l8ThYADe0eM0MaUZKICCGEECY63NwFQHZiFCmxDgAaOqQiIoQQQogRUBlMRBKiSI61A1AvFREhhBBCjITDTcFEJJrkGKMi0rtH5M2dVRyqazcltpEgiYgQQghhouDSTFaCk1SXUREJ9ohsK2/m9me28O1/bzctvuEmiYgQQghhospePSLBikhDoCJSWGtUQqpaInc7rww0E0IIIUyi63qoIpKTEE1ijLF9t8Pjp8vjDy3btHX7TItxuElFRAghhDBJfbsHt09DUSAj3kmsw4rdqgY+5g5VS9rdPvxaZI59l0RECCGEMEkw0UhzObBbVRRFITW0hdcTqpaAkYxEIklEhBBCCJMc7rV1Nyi4hbehV0UEoLXLO7LBjRBJRIQQQgiTBHtAsnonIjFGIlLX5u5TEYnUPhFJRIQQQgiT9J6qGpQcWJo5UNOO26eFrrd1S0VECCGEEEOoZ8dMTyISHPO+o6K5z32lIiKEEEKIIRWaqprYOxExlmZ2Vbb0uW+b++QVEV3X6fSMroRFEhEhhBDCJD1TVY9uVu32an3u29p18gTjO//ZwfyfraS8sXMIoxxekogIIYQQJmh3+2gJ7ITps2smMF31SP3pEdlc2kS3V2NPVevQBDkCJBERQgghTBDcmhvntOJy2kLXgz0iQVE2C9C/HpFgsjKa+kkkERFCCCFMcKytu9DTIxI0OT0WgNZ+JSLGfUbTzBFJRIQQQggTVLYcPcwMIDGmbyIyNSMOgNaTLM14fFpou69URIQQQghxQsH+kCMTD5tFJSG6Z6lmaqYLOHly0buH5GRJSzgZ1kTkwQcf5LTTTsPlcpGWlsaVV17J/v37h/MphRBCiFEhuAsmrld/SFCwT8TlsIaWbk7WrNo7UZGlmYAPPviAO+64g48++oiVK1fi9XpZvnw5HR0dw/m0QgghRNgLVi3ioqxHfSw45j0rIQqX0/j4ySsivmO+H+6O/uqH0FtvvdXn9ooVK0hLS2Pz5s2cffbZw/nUQgghRFgLVi1cJ6iIZCdGhSomJ6+IjM6lmWFNRI7U0mJMiUtKShrJpxVCCCHCTrBqEReoeNBaBZ/8Der2cV1rHBY1gaS4q0KJyMkGmrVKReTENE3jrrvu4owzzmDmzJnHvI/b7cbtdodut7aOnoEsQgghxEAEqxbxDh1e/SZsfQY049pZwFl26C59E0/LnwHo8vrx+jVslmN3VYzWisiI7Zq544472LVrF88999xx7/Pggw8SHx8fesvNzR2p8IQQQogR1drlRUFj/ub7YPMKIwkZtwQu/Cks/BLEpuNsKcL19MXcZHkHgPYTVDpGa4/IiCQid955J6+99hqrV68mJyfnuPe77777aGlpCb2Vl5ePRHhCCCHEiGvt8vIj61OklLwGqhWufw6++Bac8U247BH4+kcw7XIUzcfPbCv4tLr+hAnGkbtmdF0fiS/jlA1rIqLrOnfeeScvvfQS7733HhMmTDjh/R0OB3FxcX3ehBBCiEh0nuc9brW+bdy48nGYcknfO0QnwTX/gNPvAOBh2+P4StYd9/Hae53O69P0ow7NC1fDmojccccdPP300/zzn//E5XJRXV1NdXU1XV1dw/m0QgghRFhzd7Zyt/JPALrPvBdmX33sOyoKLP85a6xLcCg+ct/+stHUegxHVktGS5/IsCYi//u//0tLSwvLli0jMzMz9Pb8888P59MKIYQQYcHn13jknf18dKih7/W1fyBdaaZMS8V29rdO/CCqyh8Tv8NObTw2TzO89i04xrLLkYlIf07rDQfDvjRzrLdbbrllOJ9WCCGECAvrixr4/XuFPPD63p6LbdVEbfojAL9XbsRid570cRxRLu7x3o6mWOHAm7DrhaPuc2QFpOUk233DhZw1I4QQQgyTw81GK0JdW89oCj74Faqvky3aRDY4+zfc0+W0ckDPZVv+V4wLb3wH2uv63EcqIkIIIYToo6a1G4CmTo9xobsVthtjLH7tuxZX1NFTVY8lONRsXfoXIH0WdDXC6p/3uU8w8bCoCtB3wFk4k0RECCGEGCY1rUYlxO3T6PL4Ydd/wNtBuyufDdr0Yx54dyzB6astHh0u/bVxccs/oLZnySdYEcmIcwZuS0VECCGEGNNqAxURCFRFNq8A4EDOZwHlmAfeHUufg+/ylsDUy0DXYOX9ofsEE5GsBCMROdlI+HAhiYgQQggxTKp7JSJdpZ9A1Xaw2NmZdDFAvysiwYPx2oKzQi74iTEE7eDbcOgDvH6NLq8fgOyEKOO+UhERQgghxrbg0gxAzM6njXemXU6tFgv0VDpOJni/UJUjZSIs/KLx/qqf0N7Vk3RkBRIRmSMihBBCjGFev0ZDh5GIOPCQUvJf4wMLbuk5eXeAzap9qhxnfxesUXB4M76D7wLgtKkkxdgD95WlGSGEEGLMqm93h+aOLVV3Y/V1gisL8s6gNVDB6P/STK8ekaDYVDjtSwDEfPQbQMfltIUes7VLKiJCCCHEmNV7WeZC9RPjnamXgqqGttb2v1k1kFwcWeVY+g2wOomu2cwZ6i5cTmvoMaUiIoQQQoxh1S1Go6qCxoWWLcbFKZcCnEJF5IgqhysdFtwKwDesL+Fy2nolLVIREUIIIcas2jYjEZmnFJKqtNClxsD4s4CeaoWr33NEjPu5fRpun7/vB8/4Jn7VxmJ1HwuU/b36SaQiIoQQQoxZwamql9qMasiOqEVgNRpJg9WK/i7NxPbaXXPUfJC4TIoyLwPg8o4Xeu2wkYqIEEIIMWYFe0QuDiQiayyLQh8b6NKMRVXIijcGlR2oaTvq4x9n3gDA7I51JHSVAdDh8ePza4OMfuRIIiKEEEIMkX99Us49/9pOt9dPTWs3+UolOf4KPLqF1f65APj8Gh0eY3mlv9t3ARbnJwOwoajhqI+Vqbms9M9HRce19fHQ9XZ3+C/PSCIihBBCDJGH397PC1sqeGtXNbWtbs5SdwKwSZvK4a6jd7P0d6AZwJJgInLISEQ8Po0n1xVT1tBJa7ePJ3zG8oxl+7Nk29qB0THmXRIRIYQQYgh0e/3UthnLMe/uraG6tZul6m4A1mszaeny4tf0UCISZbNgs/T/1/CSAiMR2V7eTKfHx1/WHOInr+7hvpd20Nbt5WN9CrVxs8Dv5ibbe8Do2DkjiYgQQggxBKpaes6VeX9/HW1dbharxum467UZ6LrRGzLQRtWgnMQoshOi8Gk6m4ob+edGoxdk46FGKpu7AIWigpsA+Jz+DjZ8kogIIYQQY8Xhpq7Q++1uH9OUUhKUDnS7ixL7JMA4gXegjapBiqJwemB55uF39nO42Xg+n6azpawZgNYJF0NsOil6I5eom0bFFl5JRIQQQoghcLi5s8/tJeoeAJS8pcRGGztemjp7V0QGlohAz/LMrsOtAETbLX0+HhsdAwuNse+3WN+iscPDinXFbC5tGvBzjRRJRIQQQoghUBGoiGTEGUlHMBFhwlkkRhvzQ5o7PaEG0rgBNKoGBRORoP/51PQ+t11OKyy8FR9W5quFvPrGq/z41T1874UdA36ukSKJiBBCCDEEgkszVy/MIcqqs0jdZ3xgwtkkRBvVj94Vkf5OVe0tOyGKcUnRACwtSObqhTl9EhqX0waxaexIPB+Az/rfAKCsoRNN0wf3hQ0zSUSEEEKIIVAR6NmYmBbL9TkNuJQuuiwuSJ/VtyIywAPvjnTVvGwsqsLtywqwWVTOmZIW+lhwO/C+nGsAuEzdSKLSjsevUd/uPubjmU0SESGEEGIIBCsiOYnRfDmnAgDfuDNAVUkMVUQG36wadNcFk9j54+WcNSkVgPOnHp2InHPepVRHTcKheLk5egPQkyiFG0lEhBBCiFPk82tUB86WyUmMIqtlOwCuyecAkBCqiJxasyoYu2ei7T3VlGVTUkmJtTMpLRaH1WhezU6MJuO82wG4mpWA3mdXTzgZXF1ICCHECem6TmuXj/jowf2yEaNLdWs3fk3HblFJjbFDxcfGB3KN82WCFZHmTi8tp1gROVJCtJ237zobm/WI2sLsa2Dlj8j2VHC6upfK5mlD8nxDTSoiQggxDH74yi7m/3wluw63mB2KGAHBHTNZCU7U5mLoagSLAzJmA5AYY1RE9la3sr6oHoBFExKH7PmTYx1HJzYOF8y6GoAbLe+G5o6EG0lEhBBiGLy3txa/pof1/AYxdILLHtmJUT3VkMw5YDUSkODSzKG6DjQdFk9IYmKaa/gDW3grAMvVT2iurxn+5xsESUSEEGKINbS7qQyM+65o6jzJvUUkCFYbchKij1qWgZ6lmaAbT88bmcAy59CeMBWH4mNK/Tsj85wDJImIEEIMsd2VraH3w7UcLoZWMOHMToyC8k3GxZyFoY8nRNlD7yfH2LloRvqIxdY14zoAlnVJIiKEEGPCrsqevpCKMN2pIIZWMOEcF6tDjXHiLjk9FZGEmJ6KyDWn5YZ2t4yEmNNuwKNbmMEh2su2j9jz9pckIkIIMcR2H+6piEgiMjYEe0Qm+wtB94MrC+KzQx93OaykuRzYLSrXnzZuRGOLTkhnjbIAAM8nT43oc/eHJCJCCDHEeldEGjs8dHrC/wRUMXiaplPZbPQEZXfsMi7mntbnPoqi8OxXTuelO5YyLjl6pENkbexFAMTufxH83hF//hORREQIIQapsrmLR989SLu7J9Fo7fZS2mD0CzgCcx3CdZCUGBp17W48fg2LquCq32ZczDntqPsVpMYyIyt+ZIMLqE49kzo9Dru7AQ69b0oMxyOJiBBCDNIjKw/w23cP8OTa4tC1PYFG1eyEKPJTY4Gjl2c8Po1ur3/kAhXDqqS+AwjMEDm82bh4jETETBlJLl73n27c2PWCucEcQRIRIYQYpGDS0XspJjjAbGZ2HDmJUUDfMz50XedLf/+YhT9/l4YwPYRMDExJg5GIzE10Q3s1KCpkzDI5qr6yE6J41b/EuLH3NfB2mxtQL5KICCHEIPj8GoV17QDsr24LXQ9u3Z2RFU92QiAR6TVLZFt5M2sO1tPu9rG/pg0x+h0KVEROdxoH3ZEyGewxJkZ0tOyEKLbok6hTU8HTBgfDZyuvJCJCCDEIpY2deHxa6P2OQJ/IsSoivXtEnv6oLPR+S2d4NQ2KwSmuMxKR6UpgiS5zjonRHFt2YhQ6Km+x1LgQRsszkogIIcQgHOhVBdF1OFDTRlu3l6JAlWRmVnzP0kwgEWnu9PDajsrQ5zV3SSISCYJLMzndB40LYZiIZAWqc893B2abHHgb3OFRkZNERAghBuHIZZX91W1sKm5E0yEvOZq0OCc5icY2zWAi8p/NFbgDVRQwTmIVo5tf0ykJ7JJKbNljXAzDRCQ5xk603cIubTztMXng64L9b5kdFiCJiBBCDMqBQCISZTMmZO6rbmNtoXGq6hkTUwBCFZH6djddHj/PbDSWZZIDJ7E2d3lGNGYx9Cqbu/D4NNIsHVjbAj0iYdaoCsYck1uWjgcUnmmfb1zc/7qZIYVIIiKEEIMQbFBdHjgzZG9VK+sCiciZE1PA7yO+o4QF9nJmKof4y+q9FNd34HJYuXphLiA9IpEguCyzLL7KuJCUD05zZoWczN0XTub0/CTe8MwDQD+4EnzmJ8NWswMQQojRptvrD5Xjr5ibxSvbKtle0Uy3VyNO6WRZw/Pw+7+itJTzggo4oHl9DPHWpVgWfgU9wQnI0kwkKA7smFnkLIdOwnJZJshqUfnD9fO57NE2ar0JpHmaoXQtFJxnalxSERFCiAE6VNeBX9OJj7KxtCAFi6rQ7dWYrRTxvvM7RL9/P7SUgy2aJksyTXosCUoHN1tXcuO2zzOr9r9Az9KMpuk8t6mMwtrwaB4U/XcouGOG8N0x01uqy8Hnl0zgXb9RFWH/m+YGhCQiQggxYMH+kCnpLpw2CxNSYrhI/Zjn7T8jSW+CpAK4/I/w3WJ+O/u/LHA/zk2ee6lLOwPF72bu1h/ykPUJWjuMoVLrixq498WdfO+FnWZ+WWIQRsOOmSPNzk3gXc04BI/9bxrbvkwkiYgQQgxQcMfM5AxjhPvVsdv5X9vviFI8NGadA1/9AObfBDYnk9JdaKi485aR8rVX4fwfoSsq11rf57a2P4GuU9ZoLPPsOtyCXzP3l4IYmOL6DmLpJK6z1LiQEf6JyJyceNZpM+nS7UblrmaXqfFIIiKEEAMUnCEyJd0FDUXcUvNLVEXnP9oyor7wb3C4Qve9ekEOv/7cbJ64aQGKaoGz7qHhkifQdIWrtHdg/R+obTMqI26fRmngL2wR/jw+jfLGTqYqgSF1cdkQk2xuUP2QEG0nIzmBNVpgd4/JyzOSiAghxAAdCPRyTEmywPOfx+Hv4GNtMqsK7iPK6ehzX6fNwtULc0mItoeu2Wdfyc99nzdurPwhSYdXhz62r1r6REaL8qZONB1m2wLbdtNnmhvQAMzJSWBlaHnmDVNjkURECCEGQNN0qpqNCsaMPQ9D7R6ISSP+C//koWsX9OsxXA4rf9cv4R++CwH4dNlDxGFUQiQRGT2Co90XOANbd9OnmxjNwMzOiWe1fx5vx18DF/3C1FgkERFCiAGob3fj03RmqiVEb/+7cfGzf2HyxEnEOW39egxFUYiPsvOA70Y88fkk+hu41/pPAPZVtQ5X6GKIlQZ6e6aqgaWZ0VQRyU2gnnh+2Hkt5C01NRZJRIQQYgCqWroBnZ87nkJBh5mfhfxlA36chCgbbuwULnkQgBusq1mi7pYTeUeRujY3oJPjCWzdTZ9hajwDMSMrDouqUNvmprql29RYJBERQogBqGrp5nJ1PXP1vWCLhgt/NqjHiY82qiflrrk8418OwM+sT1LR2B46yVeEt/p2NzlKPQ6tE1QbJE80O6R+i7ZbmZRm7PraXtFsaiySiAghxADUNrXyPdtzxo2z7oH47EE9TkKUkYiUNXTyS+81NOmxTFQruUJZG5pTIsJbfbu7Z8dM6lSw9G9pLlzMzU0AYHt5s6lxSCIihBADkHzoZbKVBtpsKbDkzkE/TnAXzYGaNtqIZoVyJQB3WV/gYGXjUIQqhlldW69EZBQtywTNzkkAYEdFi6lxSCIihBD9pfk5rcJoUN2dZwwsG6z4QEXkYG07AKtcV9BmS2acWkf07mdPPVYx7Orb3UxVy40bo2jHTNBp4xO5Ym4Wn5qdaWockogIIUR/7f0vad4KmvUYGqfeeEoPlRDoESkMJCJxcXEUTvkqAEsP/w187lOLVQwrTdNpaPeM6orIpHQXj143j+sXjTM1DklEhBCiP3Qd1jwCwN/9F5GWcmoTNIM9Iu2BxtQ0lwP7olup1JNI0hp48s8Pc/fz22jtlhN6w1FLlxeL5maCEpwhMnq27oYbSUSEEKI/StZC9Q46dQcrfMvJiB/8sgzQZ9IqQFqck4LMZJ7VLwLgtJp/8eLWCt7aWX1KzyOGR327m4nKYSyKDlFJEJtudkijliQiQgjRH5ufBOBl/xk0K3GkuU4tEQlu3w1KjXXgtFk457pv41WdzFRLWKTso6K565SeRwyPujY309ReyzKKYm5Ao5gkIkIIcTId9bD3VQD+6T+PlFgHduup/fgMLs0EpcUZZ9QsnD4R27zrALjV+hZVkoiEpbp2N5OUwBkzadPMDWaUG9ZE5MMPP+TTn/40WVlZKIrCyy+/PJxPJ4QQw2P7s+D30Jo4k116PpmnuCwDRy/NpMb2Oixv8dcAWK5+greh5JSfSwy9+nYPE5VK40bqFHODGeWGNRHp6Ohgzpw5PPbYY8P5NEIIMWR0XUfX9d4XYPMKAPZkfQaAjLghSESOUxExbkyjOeMMLIrO/MbXTvm5xNCr710RSZ1qbjCjnHU4H/ySSy7hkksuGc6nEEKIIaNpOp99fD02VeW5r5yOqipQug4aCsEey0fRy4DqIamIxEUd2SPS9zE9s2+E6nVc4H4PXfOjqJZTfk4xdFpaWshR6o0bKVIRORVh1SPidrtpbW3t8yaEECOlvt3N1rJmNpU0Ut0aOAhsW2C42MzPUNZuJAMZ8VGn/FwWVSHOafwtaLeqxEX1/bswbu4VtOrRZCn1dOx//5SfTwwtW3MRqqLjtiVATIrZ4YxqYZWIPPjgg8THx4fecnNzzQ5JCDGGNHZ6Qu+X1HeAz41vzysAfOA4L3DyLkNSEYGePpE0lwPliF0XzuhY3lHPAMC35ZkheT4xdGLbigDoii+QHTOnKKwSkfvuu4+WlpbQW3l5udkhCSHGkMb2nkTkUH0HHFyJ1dNGlZ7E7WsdocPoTnWGSFBwumqqy3HMj693GTNFXIfeALcchBdOUjpLAPAny7LMqQqrRMThcBAXF9fnTQghRspRFZFd/wHgVf8SOr06DR3Gx4eqIhI8bybtOIlIa9JcirRMLP4uCFRmhPl0XSfLZ8wQsaRLo+qpCqtERAghzNTU0ZOIVNbWw/63APivf0mf+6UPwa4Z6FmaOV5FJCsxihf8Zxs3djw/JM8pTl1Ll5cCjB0z0dmj77C7cDOsiUh7ezvbtm1j27ZtABQXF7Nt2zbKysqG82mFEGJQGjt6znXJrn0PfF0c0jLYpU/g68sKAEgJTEAdCuOSjKbX/JTYY348Mz6KV7XTjRsl69Da6vBr+jHvK0ZOfUsbeUoNAPYMGWZ2qoZ1++4nn3zCueeeG7p99913A3DzzTezYsWK4XxqIYQYsMaOnhNvl3R+ACq8qi0lOyGab104GauqMD1r6JaMv3ZOAbOy41k2Je2YH89KcFKup3PIOpF8XyG/fPQ3bEu9gue/cvpRza1i5LRXHsSm+OnESXRcttnhjHrDmogsW7as72AgIYQIY42dRkUkhi7OUHYC8Jr/dCanx2KzqNy9fGgbE11OGxfPzDzuxzMD24RXKqfzVQo5w72OJ4rPYlNxI4vzT+30XzF43pp9AFTaxjFREsJTJj0iQggREOwROVvdgUPxUqFkclDPZnK6y5R4gk2xL3TOB2Cpupt42nnuY9lRaCa1fj8A9c4JJkcSGSQREUKIgOCumEttmwF43TsfUJhkUiKSEe9EUeCAP4N9+jhsip8LLZt5fWcVzb12+IiRFdVSCECbK9/kSCKDJCJCCBHQ1OHBio/z1G0AvONfCMDk9GM3kw43m0UNHYb3mm8xANdEbcbj03hp62FTYhKQ0HEIAHfiJJMjiQySiAgBbC9v5jN/Wsem4kazQxEm0XWdxk4Pi9R9xOjt1OtxbNWNXzQT08xJRAAyE4w+kTe1RQAs8G8nmm6e21QuPXhm0PykuAM7P+WMmSEhiYgQwAtbKthS1szzsvY+ZnV6/Hh8GsvVTwB41z8fDZXcpCii7cPa139CWYE+kSI9i86YcVh0L+fadrO/po09VXIe14hrLsWue3DrNqwp482OJiJIIiIEUFzfAUBJQ4fJkQizNHZ4AJ3lFqM/5B0tsCyTZk5/SFBw54zdasE27WIAPuvaDcCeSklERlzdAQAO6Zm4ooZmsN1YJ4mIEPQkICX1Rycim4obuf3pzVS1dI10WGIENXZ4mKaUkaU0oFuj2GadA2Bao2rQhJRoAM6cmIJtqpGInOb9BNA5WNtuYmRjVJ2xdfegnk2c02ZyMJHBvHqjEGHC49M43GQkGQ0dHlq7vX1+wDy5rpg3d1VTkBrLty+SNeFI1djpYZm6HQBlwtlkNybReLiFqRnmJiJXL8yl0+Pn03OyIFYFWwwubz0zlBIO1Bx7EJoYRvVGRaRQy2a2U36FDgWpiIgxr6yxk95Ts4+sitS1GdM2N5VII2ska+rwsMyyzbgx6UK+e/EUblg8jotmZJgal9Nm4avnFJCVEAVWB+QvA+A8dSsHa6QiMtL02p6KiEsSkSEhiYgY80qP6AspPiIRCc6W2FbejNvnH7G4xMhqa2lggWL8tcvECzhrUiq/uGoWUfahOVdmyExeDsB5lm0cbu6i3e2jtq2bCx75gN+vOmhycBFO1yEwzKxQz8YlSzNDQhIRMeYdmXiU1Hf2uV3fblREPD6NHRUtIxaXGFnxleuwKhr1jnGQFMYTMycZicgctYhkWjhY08ar26sorG3n1e2VJgcX4VorUTzt+HSVamsWdqv8Ch0K8iqKMS/YqOq0Gf8ciut7yt1un5+2bl/otswZiVzZ9WsBKE8+w+RITiIuC9JnoaJzhrqbgzXtrDlYBxhbkMUwClRDSvV0nM4ok4OJHJKIiDEvWAE5oyAFgOKGnopIQ3vfMdobJRGJTLrOxNaNADRknWNyMP1QsAyAM9Rd7Kps4aNDDQB0eHwn+CQxGD6/xl8+PMSuwy1QZyQiB/Uc6Q8ZQpKIiDEvuDSzbKqxA6F3s2owEQkesLmltAmfXxvZAMXwq9lNor+eTt2BN3uJ2dGcXKBh9UzLTl7aWkG31/ie7HRLRWSofXSokQfe2MtPXt3dKxGRrbtDSRIRMaZ1e/1UBuaDLJucCkBLlzd0Cmt9h9EfMiXdhctppd3tY29VmznBiuFT9B4AH2nTiI8zb5x7v41bgqbayVYaSHZXhC57/BoenyTKQ6kh8DOgqqU7lIgUallSERlC8kqKMa2iqRNdh1iHlZzEKDLinFS3dlNeXkxi2xrydn7EX2xF5HT5aIpJZaM3geJtHmZlX9lTJhGj36HVAKzRZnFtjN3kYPrBHoOWcxpq2TrOVHdR4s8MfajT48NuHQVfwygR7Ltp6vCAEtwxk8N4qYgMGUlExJhWHOgPyUuORlEULnUdZHn3CmY9tw/QyQfyLYDbeFtqAz55geY9E4g562vYFn0ZLPLPaFTzdqOXbkAB1mqzuH00JCKAdeK5ULaOM9RdPKNdiAJoOnR4/CREmx1d5OhwG303dk8TdBq9OIf0DGZHyb/7oSKvpBhzdF3np6/twW5RQ+XVhXHN8PRn+VHDuz0LljmnsUabyRulKoun5HJhtpeNGz7kdO8mEjqL4e3voW97GuXyRyF7gWlfjzhFFZtQfF3U6gkc1LNJjB4diQj558J7P2epupu5WbEUN7lp7vTS6ZaG1aHUFaiITFCqAWixp9PV7ZQZIkNIEhEx5hTVdfDkuhIAVAU+ra7n++VPgr8DTbHylPdcDk76Mj+/+WJeen4bL/oPk5c3lZhzCjhr2bd5+aN9HFj5F+7QnyehZif89QK45Few6DZzvzAxOIfeB2CtNhOX04bNMkpa5zLn4rbEEu9v58a8Zn7b4aK500uHbOEdUsHXs0A1ZrTU2nMBcDnk1+dQGSX/4oQYOsGj0xU0fmj5O3+w/xGHvwPGLWHdxW9wv+9WtrXGAFAfaFpNDpTrbRaVq8+YTvzZX+d898O8bzsLdA3e+Da88z+gSaPgqFNk9Ies888kaZQsywBgsWItMLYaXxV/kBiHMQG2QyoiQ6ozsCU6X6kCoNKSAyDNqkNIEhEx5uypbMWKj+eS/49brW+j6QotC78JN79G5oQZABTVdqBpOg2BqaopLkefx7jp9PF025O4pe1rFM36lnFx/R/g9W8ZY6DF6NDVBJVbAaMiMqoSEcCSf7bx3/INRNuNX4ySiAytziOWZsoUozE4LkqWZoaKJCJizNlf2cCfbb9lccdqdNWK58oniL/sp2CxMj45GrtFpcvr53BzV2i8e0pM30QkPtrGjafnAQr31i2Hq/4MigqbV8AHD438FyUGp3gNoFPnHE8NSRSkjoKtu72ND0yBLfsIVyCHkumqQ6unImIszRTpWQDSIzKEJBERY4umcV3FA5xv2YpmcaJc/xzOedeEPmy1qOSnGssyB2raQgPNkmOP/kv5S2dOwG5R+bikic0JF8GlvzY+8P6DsPnvw/+1iFPXqz8EYNmUVBODGYS06eCMB087UykBoF0qIkOqw+1HRSNPqQFgvy8dkKWZoSSJiBg7dJ3OV7/LRfo6vLoFz9VPw6QLj7rbpHQXAJ+UNuHTjGWWY5Xs0+OcfHqO8dfRc5vK4LQvw1nfNj74+j2hkr8IYyXG+TJvtU/CoiqcNXGUJSKqBcYZk2BneHcBPX/Bi6HR6fGRo9ThUHx4FTtF3QkAMll1CEkiIsaOTU8QvfUvAPwq6hs4px6dhABMSjPK8xuKjJkBLqcVp+3YR8Fft8jooH99Z5Xxl+h5/wNTLwPNC//5IrhlCmvYaq8LHWK2SZvCgnGJxEePwl8ueUsBmNy9EzD+ghdDp9PjDzWq1tqyaXEbDelSERk6koiIsaF0Pbz9fQB+4b2eynGXH/euk9ONRGTn4RYAUmIdx73vwrxE8lNj6PT4eW17pTFt9Yo/osfnQOMh1vz2Jh577yBFde3HfQxhktJ1AFTYxtNEHOeMtmWZoDyjT2RCx3YUNKmIDLHeiUipkoU7MEJfKiJDRxIREflaq+BfN4PmY7PrPJ7wX8b0zLjj3j24NOMPLMskn2AnhaIoXLvQqIo8/0m5cTEqkZcLfoZPVzmrezU7332a83/zAe/srh6iL0gMidL1AHzgngLAuVPSzIxm8DLngC2GKH8rk5TDtEtFZEh1uH2hRtV9np7vkVipiAwZSUREZNP8+P51K3TUoqVN58d8DVCYnnX8RCQvydg5E3SsRtXePjM/B6uqsLWsmfVF9azeV8s9Gxz8yW9UXR5w/AMXnby5SxKRsBKoiKzzTSE9zsG0TJfJAQ2SxQa5iwBYrO6VisgQ6/L4Q1t3d7uNRtVYhxWLKmdNDRVJRERE61j9G6wVG2jXndylf5vd9cYP6RNVRHrvnIETL80ApLocnDfV+Evphr9s5NYVH6PpUDXrDvSkApL1Rr5jfZ71RfXoMmMkPHQ2Qs1uADZp01g2OQ1lNB9iGFieWazulR6RIaTrOh0eH/mqsTRzSDdmiEh/yNCSRERErI7ijTjW/BKAH/tu5r/lTjTdWGpJc504uQguzwAknyQRAfjG+ZOYmR1HtN1oap0/LoH7P7MA5bLfAvB5y7tkte2iuL5jsF+OGEplGwCdSts46olndm682RGdmjxj58xC9QCdbq/JwUQOt0/DqXeTqTQCkogMF3k1RUTS3J20PvNFMvHzjrKEC677Fhte38vh5i5mZMef9K/fyWk9g61STrI0AzAzO57X/t9Z6LpOS5eXWIcVq0WF/HNgzg2o2//JD21PsaHoSvJH29CsUUzXdUoaOjlU186SguTQ9FFKjGWZ7aoxSTfd5TQrxKGRNR9NsZJBE1FdVWZHEzE6ey3LNOouWjD+7Uqj6tCSREREpD3PfZ+Zvgpq9URyPv9npk/MZMH4JJ5cV8xls7NO+vl9KiIxJ6+IBCmKQsKRp7decD/enS8yn0K2bn8RTr+7348nBu/V7ZU89NY+Kpq6APh/503knuVGYyqlxvyQ9T7jdnrcKE9E7NF0Jk0jtmEnE7p3A58xO6KI0LtRtSJwxgxIRWSoydKMiDh1+zcw7dAKAHbMvZ/pE/MAo5fjuxdPPWGjatCk9IFVRE7IlUHNzK8AcFHV4+g+96k9nuiXv645FEpCALaVNxvvdLdAtTFzY1XXJADS4vqfbIar7oyFAEzx7DE5ksjRZ4ZI4NRdkPHuQ00SERFRdJ+H7v98HYuis8ZxDudeccugHicvKRqH1fjnkXqSfpL+SL3429TqCeRQQ/17fzrlxxMnFxx1/q0LJgNwqC7Qn1O2EXQNX8J4KrVEFOXEW7RHC1/WaQBM8+83OZLI0enxMSHQqNocNS50PS5KKiJDSRIREVHWPPVTcr2HaNJdZF//+0FvsbNaVH5+5Uz+33kTmZASc/JPOAlHdDz/TbwFgNhPHgWPNK0Ot67A4W9zAo2oh5u7jK2tgWWZtrTFgLH0ZrWM/h+FyjhjC+8UvQRdvr+GRO+KSFvshNB1qYgMrdH/r0+IgL+/uZaFJU8AsGfWd8gfP/6UHu/qhbncs3zKkG3r9My+nhItnShPE90bnhiSxxTH1+k1EpHshCgSA6Pbi+s7Qo2qVYkLAEiPgGUZgKiUPKr0JGyKH2/5FrPDiQgd3d5QIuJNyA9dlx6RoSWJiIgIb+2qJnX9T4hW3FTFz+WMz37D7JCO8um54/ir8lkAut//LY1NTSZHFNk6AxWRKLsltFOptKo2dBhhUfQcgJNu5R4tou1WtmgTAfCVfmRyNJFBa60mVulGQ0VJkorIcJFERESEqs2vcallE34sZN7wJ+PMlzCTmxTNdV/+NuVkkKC38PJffoqmyYCz4eDXdDyBM0GibBYKAgPqug9tAN0P8eMo9iUDkDbat+4GWC0q2zF2ASnlm0yOJjJYmw8BUG/NIN7V08AeJxWRISWJiBj9/D4uqngUgIPjb4D0GSYHdHwzc5Oxn/ddAC7v+A/VDY0mRxSZurw900Wj7dZQRSSmaqNxcfwZ1LZ1A5GxYyZon20aALaqT0Cm+J4yZ0sRAHWOcX0ammWOyNCSRESMfltWkOUto0F3UTPvm2ZHc1LpZ9xMlZJGitJKx6anzA4nIgXPW1EUcNpU8gMNxzmtgd6JvKXUthrbqCNlaQag3DERt27D2t0IjYfMDmfUi24rBqApKo/EXomI9IgMLUlExOjW3QKrfwHAb32fIzllFJygarHyQfI1AKTv+itocjbIUOv29CzLKIpCQVosTtxM9ga2tuadQW1bIBEZ7cPMenE4otitG3Nzgr0wYvDiOksBaI0+oiISJRWRoSSJiBgV3L7j/LJe8xvobKBQy+JZ/3mjpsxenf85mvRY4rrKYe+r+Pwab+ysoq1bzgkZCp1eoyISZTPO/hmXFM1CSxE2xY8/JgOS8qltDSzNRFBFJNpuYbtWYNw4vNncYCJAYiAR6XDlS0VkGEkiIsLeH1YdZNaP32F7cDJmUFMJfPS/ADzguxFdsQxoHLuZxmWk8g//hcaNdY+yYl0xX39mC79dedDcwCJE7x0zADaLyoXRhQA0pp6GDtS1R15FJMZhZZskIkPD5yHBY2zd7Y7Px+WwMjc3gUlpsaT24yBM0X+SiIiwt6awHo9PY1PxEY2d7/4Y/B7ass5ktTaXVJdj0APMRtrEtFj+4VtON3ao3ELtrtUAbC6TLb1DITjMLHgaMsBiy14ACqPn0NTpxes3mjkj6ZdKjN3KDj2QiFRtB79U2AatqQQLftp1J8SmoygKL96+lDe/eVZEDMALJ/JqirDXEPjLNbjLATDGdO9+CVDYPfO7gDKqDi7LT42lgXhe9J0JwMLafwFwoLoNv2zpPWVdoYpIoITuc1Pg3gfAZqaHvpeSYuzYrZHzYzDaYaFET8dtdYGvG2rl3JlBazCqk8V6BtEOoydEVRVJQoaBvKIi7NW3ewBCzYXoOrz9feP9+TdxyGIMGhpN8yBiHVYy452s8F8EwPn6JrKop8vrp6yx0+ToRr/gVNUoW+BH3OHN2HQ3dXo8G1uTqYnAHTNgVER0VKpiphsXZHlm8OqNROSQnkWMw3KSO4tTIYmICGsen0ZLl1Fergk0F7L3v3D4E7DFwLn/E7o+WhpVgwpSYzmg57LdNgeLonOTdSUAe6taTY5s9OsKbN+NDlZEAmPdN2pT2VXZyuHAqbxDcaBhOIlxGF9vebQxT0QSkVPQYPQUHdIyeyprYlhIIiLCWmOHJ/R+bZvb2Or63s+NC0vuAFd6qMyePooqIkBo2ucfO84H4DrLapy42SeJyCnrOqJZNXjQ3V77TJo6vfxjQwkwuqpo/RET+HqL7caEVQ7LmTODFkhEivXM0OsqhockIiKs1Qf6QwDqWt2w/TmoPwBRibD0ToBQmX20HV42Mc2Y9rlKm0+5lkqi0s4VlvXsrW4zObLRr2dpxmI0bAZGnmfONnYq7Qu8xqOtinYy0YGKyAHrZONC3T5wt5sY0SgWWJop0jN7KmtiWEgiIsJa70TE7e5Ce/9BABrm3kFlt7GvP7g0M5qaVcFYmgHQUHlKM35Bft6ykn3VUhE5VX12zVRuA28nRCVy4bJz+uysSo+wpZnYQC9DlT8e4nJA14zdM2Jgupqgsx4wKiLRUhEZVpKIiLAWbFQFuN7yHmpLOVpsBheum8LVj2/Ar+mhJtbRtt4frIgAbE/+FLrFziy1hPim3TLY7BT1mSMSWJYh7wzS46O5aEZ66H6RNEMEenpiOjw+yJ5nXJQ+kYFrMM6YqdYT6cRJtDSrDitJRERYC1ZEoujmTutLABTPuINGj4XDzV3sqGgO3We0VURSXQ5cgVL65AnjUaZfAcANlvc4UCPLM6cieOhdtM0aalQl7wwAPr84L3S/iNs1E/iF2enxQ+Zc42L1DvMCGq2CO2a0TMDYjSSGjyQiIqwFZ4jcanmbVKWVjphcNiZcGvr4azuq0HWwqEqfsyBGA0VRmJYVB8Di/CRYcAsAl1vWc7C82sTIRr/Q0oxVg7KPjIvjjURkSUEyi8YnkRRjZ3KGy6wQh0WoIuL29SQisjQzcA3BrbtGIhI8KkAMD0nzRFirb/cQRztftb4KwMfjv8ahhp7lmle3VwLGX7bqKJmq2tsDV87ko+JGLp2ZCUomDc48krtLce57Ec6cbnZ4o1bw9N0sdxF42sARD+kzASMBfPrLiwEiapgZGPNpADrcfp6vSORaQK8/iOJuB0fsiT9Z9Oi1YybKZhmVP1tGk8j6VygiTn27m69aXyNe6WSvlsuGmHMpaegIfTx0guooLbFPSndx0+l5xg86RaFq4rUAzKp+2dzARrlgj0huS2D76rjTQe35q9ZuVSMuCYGekfYNHW5+sLKGKj0JBR1qdpsc2ShTbyQiRXqmDDMbAZH3L1FEFH9rDbda3gbgN75rqGvzcqi+46j7RUrTYfRpn8etWynwHaS7VJoMB6s70COS3hR4DQPLMpEuONDM69fxaTq7tPHGB2R5pv80DRqNZtVDepZs3R0BkoiIsHZF2z+JVtxUxMzkXW0+h5u7KGswRqBPz4wL3W+0zRA5ngnjxvGBZQkAdR/82eRoRq9Ojx8FjaSGQCKSd6a5AY2QYCIStFsfb7wjiUj/tVaArxtNtVGhp8rW3REgiYgIW1pDMVf53wHg0Oy7AYUdFS34NB2nTeUz87ND9x1tU1WPR1EUDhdcB0BqyX/BLbtnBqPL42eqUo7N0wL2WMicY3ZIIyLaZkEJtDNkxjvZpRnnMEkiMgCBHTOdMePQUCURGQGSiIiw5X3vQeyKnzX+mSTPugDo2ZY5PjmGJQXJoftG0oTMyYsuokjLxKl1oe18wexwRqUur5/F6l7jRu5isIyN8rqqKtyxbCKfmZ/Nl8/KZ3dwaaZuL3i7T/i5IiDQqNoaMx44usokht6IJCKPPfYY48ePx+l0snjxYjZt2jQSTytGs9p92Pf8G4DHrTeSkxDd58P5qTFMy4gjPso4njtSekQAFuUn86JqTFrt2vBXk6MZnTo9vRKRMdIfEvTti6bwyDVzSYm1U0USrWo8aD6o3WN2aKNDIBFpjDLmzcjW3eE37InI888/z913383999/Pli1bmDNnDhdddBG1tbXD/dSnbG9VKxVNciS7KVb/HEXXeMt/GjWuGcRFWfvscpiQEoOqKnz/0qlcNjuTpb2qI6OdzaLSNPEzuHUrMQ07aT30MesL69E03ezQRo0uj49F6j7jxhjpDzlSnNMGKBRa8o0LsjzTP4GlmQZHLiAVkZEw7InII488wm233catt97K9OnTefzxx4mOjuZvf/vbcD/1oLl9fn78391c8ugaLnl0zXGTkYqmTr644mMW/GwlZ/zyPS7/41oKa3vW9A/WtIUaK8UAHN4Me19FR+Fh39Ukx9hRFKXPFt38FGMmwrWnjeOPN8zHYY2sv1qWzJrCO9pCAF79+6+54a8befzDIpOjGh18fo08rZxkpQ3dGgVZ88wOyRRxgWrhHl0SkQEJVESq7UYiIj0iw29YExGPx8PmzZu54IILep5QVbngggvYsGHDUfd3u920trb2eRtp9e1urnpsPSvWlwDQ1u3j7n9tx3/EX6Mvba3gkt+t4b19tTR0eALjxlv43gs70TSdLWVNXPLoGj7zv+vx+rUTPp9UXY6w6mcAFGZ+ikI9h5RAAtJ7hPuE1BhTQhspy6ak8oJ+LgCfYi0OPPxtbXFoW6o4vt79IVrOaWAdXRN3h0p8lPGX/DZfYKS9JCLHpWk6P3hpJys+2AMt5QBUWnIASURGwrAmIvX19fj9ftLT0/tcT09Pp7r66BHWDz74IPHx8aG33Nzc4QzvmP60uog9Va0kx9j5xVWziLZb2FTcyF/WHArdZ31hPd96fjttbh/zxyXwwu1LePa204m2W9hc2sSK9SV86/lt+DSd+nY3eyqPnVDpus51T3zExb9bExplPtZ0efx9E7HiD+HQalBtvJf+JQBSY41EpG9FJLITEZfTxrKLP0eDNY0EpYNrYndQ3+7hv4FJsuL4unr1h6hjrD+kt2BF5BN34OdozW7wy2GKx7K/po1nNpbx73c+MC5EJVLUYfy8cTltJkY2NoTV4td9993H3XffHbrd2to6oslIZ0cbWzav53y1kntnO5nU+C5nZhdTWnGYxPc68Hziw+5tZZ7byy6Hhm51EutNQHknGeJzeHZ8PCsKY3j29QrK9CyCed7HJY3MyU046vmK6zsorG0HYG9VG2dOipydH/315X98zEeHGll9zzLGJUXByvuNDyy4hUNdKUB56AyZYCKSGG0jITry/8q95cyJ4L0VPniIr7jW81T7Qv5vTTFXL8hBUWTk9PF0un0sDvSHKOPHZn8IBHtEoERPQ3fEobhboW4/ZMw0ObLw09hhHBsxXjcSfX/SRFbtNfoYz5yUYlpcY8WwJiIpKSlYLBZqamr6XK+pqSEjI+Oo+zscDhyOEfhl3FoJxWvQm4qpKNqDo72cVG8l0e3VvAxgB7Yadx0HjAtW5gLtH1EACuDvhqZmaCqBw5uZA/w28PuxQXdRFLuQZ5qmsa0oDs7KPyqMT0qaQu8X17ePuW94XdfZVtaMX9P5pLSRcdWfQOUWsMXAOd+l/j+lAKGlmeDOmAkRXg3pY+4N8MFD5DRtZKK9kf01sOZgPWdPTjU7srDlry8kTWnGjQ1H9kKzwzGN02bBYVVx+zTcqTNxVqw3lmckETlKc6dRKSpQjESkXM2my+tnQkoM847xR6QYWsOaiNjtdhYsWMCqVau48sorAdA0jVWrVnHnnXcO51OfWOU2eOkrKMCR9ZZWPQq3K4/UcVMgcTy4MmkmlnvfqKDaG401Jp66Dj/LZ2TwgwsnGAOnOuqgpQIai+go3YJSs4tkpY3kjtUssq+ms+T/0F+8EuX02/s0zn1c0hh6/1hjyyNdc6eXjsCZIIVVzXDI6A1h6f+D2DTqO4zu9ZTA0szCvERUBc6aNIZ+CSeOhwlnoxR/yA+yt3Fr8Xk8s7FUEpETsJavB2CvOom5tsjZ1j0YcVE26trctCfO6ElE5t1odlhhp6nTqIjkq0Yi8m5dPACfmZct1ccRMOxLM3fffTc333wzCxcuZNGiRfzud7+jo6ODW2+9dbif+ri64/Mpcc5lW3sCZXo6ZXoaZXoapXo6XVYXG2+/AHodKZ8AnO4v5sev7gFjJYWrLzwb0o8+QjwGjHXYik/wH1hJxdqnyVNqYMfzxlvembDsezDhbDaX9lRESsZgIlLR1BV6P+PQv6GhED06hUc6LqT79T2UNxq9I8mxxv+LxfnJ7PjxRaETRseMeV+A4g9Z0voWCssoHoPfKwMRVfkRALtts5hrbiimiw8kIk1x00gBaVg9jpYuoyKSr1QBsKk1CYAr52Uf93PE0Bn2n+jXXnstdXV1/OhHP6K6upq5c+fy1ltvHdXAOpL+cdDGL5q/i92i8si1c0hudfPaa8awn8/OziYx5uj+g5uWjOelbZVsL2/mgmlpTD5GEhJisUHeEix5S7j30IW4Sz7iNxM+YUL1W1C6Fv6+Fs/4c7E3XISx+MOY/OUSbFKNoptLG/8OwJ5JX+UPa/su5QWbVYGxl4QATLsMHPE4Oyo4Xd3L3ra5ZkcUvnSduJqNAOx3jo2x7icS5zT+vVTHTGUSQPVO0Px9TiIW0NThAXQKVCMRKdKzWDwhidyk6BN/ohgSI/JT/c477zR3KeYIXzxjAvuq2rj2tFwW5xuDsDRN54UtFXz93IJjfo5FVXjshnn8bW0JXzprQr+f67T8ZH5fPJlH45bxu+t+DWt/C588ib1kNa/ZP+Cf6qd5sOsKypsUPD4tIo8mP57DzUZF5FbLW6ToTWgJebyoLgcOMzXDRazDSn5qDDmJUeYGajZbFMz6HHzyf1xrWc1dnTNw+/wRNztlSDSV4OyqxqtbKIueYXY0pgtOHq62ZYMtGrwd0FAEqZNNjiy8NHd5SaOZGLrx6SplejpfmS/VkJEydn7r9WK1qDxy7dxQEgJw29n5vHXX2RSkxh7383ISo/nRp6eTndD/X4yLxhslvo9LmiAuCy79Ndy5ib2J52JVNL6gv8I7jnuZq++jfIzNE6lo6iKBNr5mfRWA8rl383G5sfZ1+7IC/nP7Un71uTmyRgsw7/MAXKJ+TBztNLR7TA4oTBUb2y+36hOxOMZQU/NxBLfwtnRrkDHLuCjLM0dp7vRQEOgP6YjOZvmsXC6fI4nISBmTichImjcuAYuqcLi5iwde38MbO6tojc7lXut3+KLn23RGZZKr1PIv+09R3v8F+H1mhzxiKpo6ucP6CnFKF7u1PD60n83uwMyVBXmJJkcXZrLmQdoMHIqXyy0bqGsbm3NnTqr4QwDWazOIkkFUoYpIa5e35wTiqm3mBRSmmju9oR0z8TnTeezG+fL9M4IkERlmMQ4rCwO/VP+yppivP7OFhT97l50Vzbynzafp5g/Y6LoQi6KTv/sxeOpK6Kg3N+gRotUXcbPlbQAe8l3Hf7ZU4td0MuKcA6o6jQmKEqqKXG35QBKRY9H1nkTEP0MmYtIzS6SlTyIiFZEjNXV6Qo2qpEwyN5gxSBKREfCnG+fzwFUzuX7ROApSY/D4NTQdshOiyEpPY+2sB/iG507cahSUrIE/nwOVW80Oe1jpus4XWv+MXfFzMG4JH2pz2F7RAsCC8YmyHHMss6/Fh5U56iE8h3eYHU34qdsHHXV4VQfb9IlE28dgY/MRQhWRbl+vRGSHkbSJkJYuryQiJpJ/qSMgOdbBjYuN8x50XWdfdRvv769jcX4SiqIwISWGP2hLsSfP5mHtV8ahS09eClf/HSYvP+rxdF3n8Q8OMTXTxblT0kb6yxm0DreP/32/iM8uyCG1+kOWKVvw6hZazvkJ/LunCrRgnCzLHFNMMnvjz2RWy/tkFr8AXGh2ROHlkNEfUhYzB0+nDacc305c4LyZli4vpEwH1QbuFjrqSqhWUk/YEzdW6LpOc6eXfGvg+IRkSURGmlRERpiiKEzLjOP2ZQXMD/zCHR+YFLquNQVuew/yzwVvJzx7HWz5B6UNHbyxswo98FfMhqIGHnprH998dusJD9Qzg8+v8cg7+/sMawt6cl0xf1xdyE9f2YZt5Q8AeE79FBOn9T0ddeF4SUSO52DWlQBMrnkDfLI800dgWeZAzHxADiuDI3pErHZInQLAL5/8N8t/+yG7K1vMDC8stLl9WDQ3OUrgjyGpiIw4SUTCQPAAt6qWbjrVGLjx3zDnetD98N//x2u//yZff2Yz7x+oA2BT4Jd8a7evz1C0cPDBgTp+/14hX31qMx3uvo236wobAJhc8iyOliLq9DjeTLqJhGh76ByZKJuFaZlxIx73aNE57hyq9CRi/C2w/02zwwkfmh9K1gKwxzEXkEQEjugRAUg3xrsntO7Hr+n8d5scotjS6SVPqUFVdHDEQ4xMLR5pkoiEgYRoO4nRgQOq6jvBYsN/+Z/YVXAbAHco/+ZB619Zs89Yw+ydfKzeVzvyAZ9AcBpqY4eHpz8qDV3v9vrZXNZECi3cof4HgF/7riUp2ThfJzggbk5uPDaLfFseT4ormhf8Zxk3tj5tbjDhpGo7uFvAEc9B1TjXSZZmerbvtnYbichOv3GoxVS1DIC3d1eHKq1jVd9G1YlGY7gYUfITP0wED3L75Vv7+NVb+1j2m/e5bPe5/MD7RfyoXG9dzVk7f4DP42ZLr0RkVZglIlWt3aH3n/jwEJ0eoyqyrbwZj0/j29bniVO62KFN4N/+c8hJNCYXzg/sLBpT58gMQqrLwb/95xg3ilZBy2FzAwoXgfkhjD+DjkAhTioiPUszLV1eWru9PLrTmBq9JLoKu1WlpKGT/TVtZoZout5bd6U/xBySiISJOYETHj88UMef3i+ivLGLhGgb2RfeQdcVf8OjWzjXt4aGf9yEx+Mmxm7BoioU1rZT1hA+g9CqW3oSkYYOD898ZPzltaGogVnKIa6xGr8wfuy9GR01NDX168sKeOKmBXzl7KNPKRY90lwOSvUMNurTQNdg+z/NDik8BPpDmHAOnYGDFCUR6amIdHs1Nh5qZKsnB4BEdwUXFBh//Ly1q9q0+MJBU6cndNgdKRPNDWaMkkQkTNx3yTSeuGkB91w4mc8tyOGBq2ay4d7z+fqyicTOu4qH4v8Ht24lveJtHrM9ypLxsZwWaOp8b1/NUY+n6zq/X3WQP39QNKJfR1UgEQmeDvvnD4to7fayqaiGX9r+gorOq/qZbNGNEdPZgUTEabOwfEaGLMucRPAk4ue9garI1qdBC6+G5RHn80DpBuP9CWfTFUhEomT7Li6HNbTS8OGBOhqIp8WShILOZ3OMSshYT0RaurwUhJZmZPS9GeSnfpiwW1WWz8jg/50/iYevnsONi/P6TPZzTL+Ur3jvwa3bWG7ZzP+0P8iFk4yjqo+1PLPrcCuPrDzAg2/uo909ctNaq1qM82O+vqyA/JQY6ts9/PDlXcw7/E9mqKX4HYmsHn9X6P65Y/0cmQGKsltwOay8qS1Cs8VCUwmUrTc7LNNUNHXy3zdeAV8XRKdA2jS6vIFERHpEUFUFV+CgyA8Cze7tCcbOmdNjqrCoCvuq2yhtGHuHbgY1tffqEZGlGVNIIjJKnDkxhQ+0OXzJ+226dRvjG9dyXfH3ceBh46FGCmv7rvO+sKUi9H5D+8hs89Q0nZoW47lyk6J56HOzURTYvn0z31D/DYB68QOcNmNK6HOyE+R0y4FKdTnowknd+MuMC2O4afWht/ZzaNMbxo0JZ4OihPqSZGnGEFyeKQs0kluzZgMQ07SXxROMs7BW7umpqv7rk3L+sOrgCEdpHm9bDXFKJzoKJMnSsBkkERkl5ucl4rSprNVmcZv/u+i2aGLKVvOc63eo/i4u/+M6XtlmNC56/Rqvbu/Zllc/QgekNXZ68Pg1FMXoZThtfBJfXDKOh2x/wal42R+zAGXuDZw/LY34KBuzsuPlPIdBSA1sdT6QdYVxYffLrN9ziAsf+YA3dlaZGNnI23W4hSXqHuNGvrFc1bM0I99b0NOwCmC3qCTlG3NWqNnNaYFDOYvqjIqIpun8z8u7+M3KA336vSKZo+UQAG3OLLA5TY5mbJJEZJRw2iyhHxrtWWeg3PgfsMUwz7uNF+J+h+7p4JvPbeOvaw6x5mAdDR09yUd9oCLS6fHxr4/Lh61CEvzBlRrrCPV63Bu/ksXqPtp1J8Wn/wIUhTSXk3fvPod/3rZ4WOKIdMFE5KB1KqROBV8Xbz33Jw7WtvOXNYdMjm7kdHv91DQ0ME8x/nrXx58NIEszRwjOEgGYlhWHLStwCm/NbtID30t1bca/3cZODx6f0XPU7vaObKAmcbUZ/2Y6XBNMjmTskkRkFPn0nCwALpqRAePPgJteBHssMzzbeSf1UWLp5IE39vKLN/b1+bzgkfHPbSrnuy/s4DcrDwxLfMFG1cz4wF8VVduxffALAPbM+T4XntGTeKS6HLh6/YAU/RdMRGrbPTRMuhqAq1gNwPbyZpo7R6YCZraDNe0sUA5gV/xU6CkU+VLx+jW8fmMuhizNGHpXROblJhgNmRY7uFvJtRjTRGsDhyjW9Np+3+2NvCboorr2o5axE7uMeUeeBFmWMYskIqPI1QtyeO+ec7jtrMA/mHGnwxdeAUc8uW3beSPpEVx6B4W17QBMD0woDVZASgINaR8XHz1+fSgEG1Uz4p3gbocXbgPNC1MvY9FV38CiyqCgoRBKRNq6+da+KXh1C/PUQs5LbEDTYW3h2Di9eV91K2eouwHY4J/O5rIm2rp7GrNlacbQOxGZm5sAFlto1HuO29hVV9tq/Iyo7XWqc3egshQpfH6Nz/xpPVc9tr7P15bmKQdAT5JGVbNIIjKKKIpCfmps31/oOQvh5lcgKpFxnXt4xfUQCbQxMS2Wc6YYW2iDyzTBv3YK69pDkxaDNh5q4Ia/fERx/eC750MVkTgn/Pf/Qf1+iM2ATz8q0wqHUGpgC+/K3TV8WKnyAcaa/21xxu6ZD/bXmRbbSDpQ08ZZqnEK8TptJh+XNPHmLqNHZkJKDHbZCg70HHwHgUQEQqPeUzqM6mh9uxtN06lr7Z2IRFZFpMPtp6XLS5vbx+HmrtD1bL/R2G9Nk627ZpF/qZEgax7c/BpEpzDBW8jKpF/z6GXZoZkTwR6RmsAPGV2HHeU9h13pus5PXt3D+qIGnttU1q+nfGtXNdvKm/tcC/aIXNj2Eux+EVQrXL0CYlJO8QsUvQUrIm2BbdmtU68DYEHz21jx8eHBujExtrvqcAkz1FI0FD7UZrO5tImnNhhl9s+fnociyS/QUxFJiLaRlxzYpRZIRGKa9gPg03SaOj3UtvVemomsikhXr6+nMpCIaF43Wbox/sCZNdWUuIQkIpEjYybc8jrEppPaWciMt64hVzH+Mg72iPRe/91W3jMmfufhFvZUtQJwMLCscyI7K1r42tObueXJTX1O/61q6WKpuoslRb8zLix/APKWnOpXJo4QTEQA4pxWzr/8RohNx+5u5GLbNmpa3WNibHdqzToA2pNm0kgcxfUd7KtuI8pm4XMLckyOLnwE/yCZl5vQk5xlGImIWruLpBhj7Httm7vv0owvshKR3onV4SYjEWmvPohV0WjXncSl5JoV2pgniUgkSZsKt74J8bnQWMSyNTcwTSmlocMou/b+IdO7mvHspvLQ+wdrT/4L7K3dRvm7udPbp98ktnEPf7b9FlX3waxrYPFXh+CLEkfqnYh85ex84mOijNOaga/ErAGMKZqRrLnTwzzPZgCcU5czOT029LEr52X36YsY6y6dnck3zpvI9y+d1nMxUBGhsZhxscYfE7Vt7ohuVj1WRaSrymjsLyELu+yyMo0kIpEmuQC+tBLSZmDvruNf9p8yrW0DDR0e/FpPuX5beTO6rtPh9vHfbT0Hp1U0dYUGQh1P7+FHK/ca7+uNxfyi66e4lC66s5fCFX+UvpBhkhLjYEZWHBPTYrn1jMCWwwU3AzCr+xPGKTWhKZqRQNd19le34etVfdtX2cxZ6k4A7FOXsyAvKfSxLyzJG/EYw1mc08bdy6cwKXDCNWAsl8ZmADpzHcYfFrWt3RHdrNo7ETncbCRc/hpjaarSIhU0M0kiEoniMuHWN/DkLsWldPFb/y/xrnkU0ImPsmGzKNS3e6ho6uLV7ZV0ePxMSIkhKcaOrsOhuuM3rJY2dHCgpmf5ZtXeWvS6A2hPXkqa0sxeLRfl+n+C1XHcxxCnRlUVXvt/Z/LmN88iJjC+m6R8mHgBCjo3Wt5lW1lzxPSJPL2xjIt+9yF/WVMcutZ48CMSlXY61RjIXshZk4w+pCX5yUwL7BYTJxFYnplhMfrC6trdod0zEHmJSPcxKiJKgzGDptohyauZJBGJVFEJqDe9xLP+c1EVnaxND/C/tt8xNcEf+kH94cE6/rrW+OF+7Wm5TEozytsnWp4JVkPm5iZgt6jENu3B/38XY2mrpFDL4lu2H+KITRzmL04oinL0AYGn3QbANZYP8Hm6aO0auTOGhtOeSqN/6f39PWcq2UuMuSllCYvBYuWSmRn89QsLeezG+abEOCqlzwCgwF8CGFt463pVRNy+yFqa6dMjEkhEnM3GrqHGaBlmZiZJRCKY1e7k17avc7/3ZvyKlUssH/On1m9wVYIxO+CHL++isLadpBg7Vy/IYVJgnb13xeNI7wQSkSvmZvGtjG38x/4TrN0NtCZM5xrPj7AlZA//FyaObdKFED+ORKWdT1s2UNnSdfLPGQWCUz93VLSElmdyG42tyl155wJGYnbB9PRQ46Xoh3Rjwmp2YJZIYW07nl7LX5FWEeny9G2s1/x+YgNTVVtdBWaFJZBEJOIlxzr4u/8ifpD0CCVaOsn+Wm4t/Aa/sf2JJL2FlFg7z952OsmxDialGWvIB4+TiDR2ePikpJE42rm68lfc3vBLohU3O+xzeXPBX2gkzhhmJsyhWuC0LwJwk2VlqPw82gX7Frq8fvZVt+FpqWGSx1jbj5txsZmhjW6BpZmkjoMoaOyqbOnz4eCZPZGid2Ll9es0VhVj83fh0S1Ep000MTIhiUiES441/kJ8rT6DyzwPsD3zanQUPmtZyxrnXayc8Q5Too3EI1gROXIEctDqXWXcoK5kTdS3id39T3QUHvVdxZWt3+bn7xoNr5mSiJhr3k14sTFHPYS79GOzoxkSvfsWtpQ1UbLhJVRFZw/5TMiXaZiDljwRLHZsvg5ylDqaO/sOOYy07btdR1R4msuMZucSPYOZ42TWkZkkEYlwyYEZAu1uH+1Es3fej1C+vApP+lyicJO4/Qn47Qz4x5XMqnqRGUoxNY3Nxl8Pug6tlbD/LXj921z89jn83PYk8XorpE5F+cIrbBj3VTTU0HCt2TkJJn61gpgU9iSdD0Bu4T9NDubUaZoeGsgHsKW0Cf/e1wE4nLYMVY4NGDyLzTg0EZimHD3IMNK27x651NRRYRwPcFDPZk5uvBkhiQDrye8iRrOUI9bM0+OdkLMA+9feh8JVsOZhKNsAh1bjOrSa1wObXfRfWAEN9J4fRjHAYT0Z5Yy7yDr/62Cx8tSXNA7VdeD2+XHaLKGGV2Ge4gnXMafxLaY2vAOdjRCddPJPClONnR58vbad7yqtZXzXRgBccy43K6zIkTELqncwTSnjHU7r86FI6xE58utpKzcSkcPWPC6Nk0qumSQRiXDBikhQuivwD05RYNIFxltDEex5BQpX0Vq2gzi9FUUP7LhQLJAymcqYaXz3wBRKXQv48MILQjNCbBaVKRkuRPiwjlvEzo/HM0stga1PwRnfNDukQQsuy8TYLXR4/OS0fEyU3U2VnsSchWeZHF0ECOycmWktg8Dv6YRoG82d3oiriBy5NBPdWggKaMmT5TgAk8nSTIQL9ogEpccdY75HcgGcdTfc+jq/nPU687of5/H5r8E9++H7h+GOj/hd7F2s1WZx/ows+Ucb5rISo3nKf6Fx4+P/A230/kIJnn2SmxTNpLRYLlS3ALA37kyiHPJ31CkLTFidrvZMVx6XZJxH446wHpFgYuVyWgGdAozD7mJzZ5gYlQBJRCJeckxP4mGzKCRGn3h746R0F03EsaU5ClwZYIvCr+ms2mvMcLhwevqwxitOXXZCFP/1L6VZj4HmUjj4NmBMKH1mYyn7q0fPOTTBHTOpLgfzc+M432IkIpZpl5oZVuQIJCLZejUxGLuscgOJSKQtzQQrIgWpsaTSTLzSiV9XyJk4y+TIhCQiES6lV0UkzeU8aXPfxECPR1FdzxberWVNNHR4iHNaWTRh9PYbjBWpsQ78FifP+c8zLqz/I2DMgPnBS7v43gs7TIxuYIIDttJcTs6PryRDaaJddzJ9yadMjixCxCSDKxOAKYpRFRkXSkRGbyXtWLo9PYnIRLUSgDI9jRnj5I8rs0kiEuF694gcc1nmCAWpRiJS2tAZOlk3OE313KlpR0/zFGFHVRUy4p2s8C1HU6xQuhYOb+GjQw0A7Klq7XNuSzirDRzClhbn4Az3WgD2uZaQmihj3IdMoCoyTTV2zoyL0IpIcDtyfmoMkxRjWabCOq7PIZLCHPJbJcL17hFJ70dneEack2i7BZ+mU97YCcCGwC+w86amDU+QYshlxUdRTTKHcwJLGBv+yJbSJgA8Po2Shk4To+u/4NJMWqydmMJXAZh3ya1mhhR5AoPNpimlQK9EJMJ6RIID2lJdDmbYjIP+2uNkkFk4kEQkwrkcVuyBKkZ/EhFVVZiQEgNAUV0HPr8W6imYIzNCRo3shCgANqTfAIC++2UaKw+FPr6vutWUuAYquDQz2XcAWsrBFoNl8nKTo4owvSoiLoeVhGgbEHlLM8EekSibhalWIxGxpU81MyQRIIlIhFMUJVQV6U8iAj3LM0V17ZQ0dOL2aUTbLaG/lET4y0ww/l/v9OXChHNQdD+3qq+HPj5aGlaDFZGCuneMC1MuAVuUiRFFoEAiMkUpJyvejtNmASJwaSaQWDltFiYGdsxMnLHAzJBEgCQiY0BKoE8krZ9roaFEpLadvVXGX85TMlwyxXIUyQpURCqbu+DMuwC43vIeaarx/3PfKEhEdF2ntq0bBY2U0jeNizOuMjeoSJQ8Ed3iIFbp5hfnxhEVSETcEVYRCSZWLq2VGJ+xTDl+yjwzQxIBkoiMAdctymVOTjxnT07t1/0L0oylmUP1HaFEZFqmNAeOJqFEpKUb8s/lkH0KUYqHH6d9AIyOikib20e3V2OuUoS1vRLssTDxArPDijwWK0qasUSxwHE4VBHx+DX8vabajnbBpZmEzsASZfw4cMgk6HAgicgYcOPiPF6588x+d4fnpwQPv2uXRGSUyu5VEdF0+J3HGIe+vONV4uigrLGTjsD5QOEqOFX1c/YNxoUpl4BNRnEPi/TALI2a3ThtPb8WIml5JlQRaS0yLqRONjEa0ZskIuIoE1JiUBRo6fLySYlRwpwmY9xHleApyC1dXrZVNPNq9xwO6LlYve18PXoVAPtr2vBrOjWBLbLhpratGxs+LlPXGRdmX2tuQJEssHOGml04rZbQ5UhKRIK7ZmJaC40LqdKoGi4kERFHibJbQn9RB0/VnSoVkVHF5bQR5zRGoH/575+go/J24o0A3KS/Rhwd7K9u4xvPbmXxL1axqbjRzHCPqa7NzXnqVuL1NmPoVsF5ZocUuQINq1TvRFWV0E67bl/k9ImEmlWbgxWRKSZGI3qTREQcU35qz9rpuKRoYuVcj1HnirnZADR2eADQZ1wFqVOJ0dv5kvUN/rLmEK/vNLYxvhH4bzipbXXzOYvR08Lsa0G1nPgTxOAFDr+juRS6W3EElmcipSLi13Q8gSF+tqYDxsUUSUTChSQi4pgKUmNC70/LlGWZ0ehnV85k8/9cwF++sJCfXTGDL58zEc79PgBfsrxJc11P8rGhqMGsMI+ro7GSc9Vtxo25N5gaS8SLToI4I3E1+kQiawtv8OuIpRNLmzHeXXpEwockIuKYCnpVRKRRdfRKjnVw4fR0bloynmi7FaZdTlfKTGKVbr5mfZXcJGMJbn9NG/Xt7hGL65mNpfzyzX0nHDWfV/k6VkWjJm6mlNFHQnqvPpFQRSQylmZCB94pgSQkNgOiEk2MSPQmiYg4pvxeFZGpGZKIRAxFwXL+DwH4guUdHr0klamBRuTgWTTDzefX+PF/d/P4B0U89Na+Y99J1zmt8TUAqsZ/ZkTiGvMyevpEgg2r7giriEyzSjUkHEkiIo5pYq+KyHSpiEQU+9SLaE1fhFPxMv/A71lakALA+hFanqlu7cbrN+ZT/GVNMa/vOLo/RT/0ATm+Mjp0B/4Znx2RuMa8PhWRwNJMhJw3E0xEplqCiYjsmAknkoiIY0p1Ofjs/ByunJsVKt+LCKEoxF3xK0CBnf/i4gRj3PVHI5SIVDR19bn9nf9sp+yIQ/i61j4GwIvaOczIzx2RuMa8jOAskT1EW41EMWKWZjzG1zFJPWxckKW+sCKJiDgmRVH4zTVz+N1181AUGe0ecbLmwZzrAZi/71eois6h+g6qWrpO8omn7nAgETk9P4m5uQl0evy8s6e65w6NxUQVrwTg47TPhf46F8MsKR+sUeDrYpxSA0RQs2qgsjNeDyQismMmrEgiIsRYdf6PwBaN9fDH3Jm8BRiZ3TPBikheUgwL84yGwT5D1T7+Kwo6H/hnkzt5zrDHIwJUC6RPB6DAXwJEUkXEjxM3mbqRYElFJLxIIiLEWBWXCWfdA8BXu/9GPO0j0rBa0WQsw+QkRpERmABbExjnTncrbHkKgCf9F7FoQvKwxyN6CfSJTPAb57FESkWky+tnknIYFR2iUyA2zeyQRC+SiAgxli39BqRMIcbXxL3WZ9l1uHXYn/Jws1ERyU6MIi3OSESqgxWRTX8GdwtFWiZrmcuCPNliOaICfSK5nkAiEkHNqlPVMuNGoOojwockIkKMZVY7fPpRAK63riah7mO8J5jtMRSCSzM5idFkxAUrIt3Q3QLr/wjAo77PMCM7USb6jrRARSTbbYxB7/ZETiIyRSk3bqTNMDcYcRRJRIQY6/KWoM+/GYBfqI9zqLJm2J7Kr+lU9qqIBBOR6pZu9I8eh+5mahx5vKYtYfGEpGGLQxxHYNR7vLeWeNoj5qyZLk+vREQqImFHEhEhBMqFP6VeTWW8WoP93f8ZtuepbevGp+lYVYV0l4O0OAcADl8bbDC27D7B59BQJRExgzMOEvIAmK6WRkyPSLdPY6oarIhIIhJuJBERQkBUAv/N/xGarjCh9D+w741heZrgskxmghOrRcVps5AQbeMO68so7hZ8SZN5smUeigIL8yQRMUWgT2SaUhYxiQgd9aQqLcb7Msws7EgiIoQAIGryMv7iv9S48cod0FQ65M8RnCGSndAzJG9xTA1ftLwFQOHc76KhkpsYTXy0bcifX/RDoE9kmlIaMdt341qNE3ebHNngiD3JvcVIk0RECAEYhxv+xncNuymArkZ4/kbwdJ78EwegZ+tutHFB1/mW58/YFD+H089js2MR0Pf0ZzHCAmfOTFMjpyKS2HYQgIaYApMjEcciiYgQAoAp6S58io0vd9+FFpUM1Tvh1W9SWNPGnf/cQnnjqSclPTtmAhWRHc8z1b2TLt3OynHforC2HYCJafJXq2kCFZFJSgVer8fkYIZGcmchAE2xk0yORBzLsCUiDzzwAEuXLiU6OpqEhIThehohxBCJslsYnxJDFcnsWPooKBbY+S8Kn7+X13ZU8X9riwHQdZ0b//oRF//uQ9wDnDMRmiGSEAWNh+CN7wDwB9+VHPQkUlTXAUBBqiQipknIw2uNwaH4SOoa+uU5M6R1GXNR2uPl1N1wNGyJiMfj4eqrr+b2228frqcQQgyxaYGTljf4p8OnfgPAxY1P82XL66FqRV27m3WFDeyrbmNfVduAHj9YEcmNs8C/bgZ3K7WJ83jCfxk1rd0USUXEfKpKR4IxAj27u9DkYIaAppHhNpLojgRpVA1Hw5aI/OQnP+Fb3/oWs2bNGq6nEEIMsemBRGRvVSssvJWmJfcB8D+2Z5hf9RwAB2vaQ/ffV93/SayapgeaVXVmbv85VO+A6GQOnPkoPqwU13eEKiZSETFXZ6KxxTUnMGF1VGsuwal349Zt+BLGmx2NOIawGlvodrtxu92h262twz9uWgjRY1qmCwgkIsDKpBtp8O3iduur3O3/G543YzjgujV0/70DqIjUt7vx+P38wPpPYne/Dihw1RMkRI8HKkLLMkkxdhJj7EP1JYlB8KRMg4Mw3h8BiUjNHgAK9SycDofJwYhjCatm1QcffJD4+PjQW25urtkhCTGmzMpOQFXgYG07hbVtbCxu5CHfdfzKey0A9o1/4LRNd5GAkYAMpCJS3tjJvdZnuc36unHhskdg0gWkB6arBk2Uaojp/GlGw2rwFN7atm50XTcxolNQswuAvXoeDpvF5GDEsQwoEbn33ntRFOWEb/v27Rt0MPfddx8tLS2ht/Ly8kE/lhBi4FJdDs6bmg7A0x+VsbG4AVD4m3oVd3u+hqZYmdn6IW87vscydRv7q9v69wuqvZacN7/A16yvGbc/9RtY+EUAkmPs2CxK6K4FabJ113Rp09B0hWSa+WTXPhY9sIpfvLHX7KgGp3onAHu0PKIkEQlLA1qaueeee7jllltOeJ/8/PxBB+NwOHBI6UwIU31hSR7v7q3huY/L6PZqWFSFS2dm8uLWs5k943TO2fV9JiiVrLD/ig3e6TTtVkmafh6off+uaeny0tDYQH7FK/DBr0jvrMet23gl+1tcc9qXQ/dTVYU0l1P6Q8KIPcpFsZ5BgVJF8e6PgFR2Hm4xO6x+eX1HFftr2rjr/EmoqhJKRPbq47hCEpGwNKBEJDU1ldTU1OGKRQgRBs6cmMKElBiK642ejZlZcczOiefFrYd5qSaNX3Y/wHds/+YmyzssseyB/3wWYtNh4oWQNAGiEqCjgT0bPmRm92ZQjASj0lHALa1f4dMF5x/1nGlxjp5ERHbMmC7KbmG7Po4CqqB6F3AuzZ1es8Pql/95eSdNnV7mj0tg2Tg7NBtbkPdoeTglEQlLw9asWlZWRmNjI2VlZfj9frZt2wbAxIkTiY2VHzRChCtVVfj86Xn87DWjyW/RhCQmphlNrNvLmwEHzyR8lUMpNzP14F+4zrEOW3sNbHu6z+MsAVCgNWY8cefcyXe3TOZASzvjkqOPes6MXn0i0iNiPqfNwh5tPJdZNhLXvIfRkog0d3poCsS5am8tyxxGFadST6GFWFmaCVPDloj86Ec/4u9//3vo9rx58wBYvXo1y5YtG66nFUIMgc8tyOHht/fT5fWzeELyUXM9Jqe5yMzO5od7v8j2Gd/j4UUdUPwhdNRCVzPb6zRerU5kp5bP7IUX84NFMzm0ahUAuUlHJyLBhlWHVe1zDo0wh9OqsksfD8DEwM6Z5q7wn7Ja1mv676q9Nfw04wAKsFszThR22sNqf4YIGLZEZMWKFaxYsWK4Hl4IMYzio2z8+urZbC9vZtmUVCyqQqzDSrvbB8Ck9FimZhgzR3bVdEPBucYb4PNrfPmX71HnN7biR9d14vb5qWrtBiDvGIlIRryRiOSnxhrr+sJUVovKPiYAMEGpJppuOr1Our3+sF7eKG3oSUQqW7ppPrSFRGCPHkhEwjj2sUzSQyHEMV02O4sffGo6VouKoih9ejcmpbuYkmEs1xTVteP195zSuqawnrq2nnlAhXXtHG7qQtchxm4h6RgzQubkJACwJD95mL4aMVCdtiSq9URURWeaYvRZhPvyTNkR5yF5K3cAsEcbByBLM2FKEhEhRL/0PhF3cnosOYlRxDqseP06b++uZm9VKyX1HTy/ydh2/+k5WYAx1v1AYBprblI0inJ0xWNJQTKbvn8+//OpaSPwlYj+cNpUdmvjAZihlgDhvzxT2mA0WOckRmHFR2K7MaJ+j56HVVWwWeRXXjgKq8mqQojwFewTsagKE1JiUBSFqRkuPilt4s5/bj3q/redNYE1B+to7vTywYFaAMYdY1kmKO2IwWbCXA6rhV3d4zmfrcwYJRWR4NLMF5bk8cKb72DDh8/moqI7lVi7VEPClaSHQoh+mZJuLMUUpMbgsBo/1L9ydj5TM1zkJkWREusg1mHFoipcMC2NWdnxoR0w7+07eSIiwovTprInUBGZZSkBjF0p4Sy4NLNwfBIXJdcZ12wT0FFlqmoYk4qIEKJfzpmcyh3nFnDGxJTQteUzMlg+I+O4nzMxLZZPSpuoaTV6Ro61dVeEJ6fNwu7AzpnJSgU2fGFdEen2+qnu1RB9cXIttMOHrcb3Z5TsmAlbkogIIfrFalH5zkUDO0b9yG2/x9q6K8KTkYik0EoscbQzWamguWum2WEdV0WgITrWYSUpxk4SxQChZEoaVcOXpIhCiGFz5JRUWZoZPZw2FVCojJoEwHS1hKYwXpopazQaVcclRaPoOkrVdgAOWiYCsnU3nEkiIoQYNr2npCoKMqxsFHEG+oDaE6cDMFMppiWMl2aCjap5ydHQeAg8bWB1cs0lFwBSjQtnsjQjhBg22QlRRNksdHn9ZMQ55a/SUWTZlFQ2lzWRPmUxVD7DLLWYDaMgERmXFA1V24yLGbO4YUkBM3KSGZ8ipzqHK0lEhBDDRlUV8lNj2F3ZKssyo8xNS8bz+dPzUBqKYDVMV0pp6egyO6zjCu6YGZccDZWB7eSZcwGYk5tgTlCiX2RpRggxrIINq5KIjD6KokBSPj5bLE7FS0JHkdkhHVdwmFleUgxUbjMuZs0zLyDRb5KICCGG1YXT07FbVZZNSTM7FDEYqkp3ymwAsjv3mxzMsWmaTnmTUa3JS3JCoFGVrLnmBSX6TZZmhBDD6rLZWVw8IwOrjNcetbTMuVC1ngJveCYiNW3deHwaVlUh03c40KgaBSlTzA5N9IP8ZBBCDDtJQkY3W+58AKZziG6v3+RojlbVYgwyS49zYq0xDrojYxZY5G/t0UB+OgghhDghZ95CAKYppTS3tpsczdGC24oTY2w9jaqyLDNqSCIihBDihJTE8TQTi13x03V4p9nhHCU4aC0x2t6zdVcaVUcNSUSEEEKcmKKEJpRqh48+adlsTcGKSJSlZ8dMYOuuCH+SiAghhDipMqfR+Gmv3W5yJEcLngo8Ra0AbwfYXZAqjaqjhSQiQgghTqo6ZhoAsQ3htzQTPBV4smefcSF7PqgyxXe0kERECCHESTXGzwAgvvUgeDpNjqavYI9IXtce40LOaSZGIwZKEhEhhBAnF5dNjZ6Air9nYNgQ8fk1vvX8Nv65sWxQnx+siGS0Bao1koiMKpKICCGEOKnEGDtbtEnGjYqPh/Sxt1e08NLWwzy2urBf9y9t6OCFzRVomg4YFZE4OohrP2TcIWfhkMYnhpckIkIIIU4qPtrOVs3YOTPUiUiw2bS/w9J++Mpu7vn3dtYU1gc+38scNXAOTuIEiEkZ0vjE8JJERAghxEklRtvYGqqIfDKkj93abSytuH1av+5/uMnoUSmpNw66a+70ME8JVFNkWWbUkURECCHESSVE2dmpT8CPCm2V0HJ4yB47OBm1vxWRYE9IdatxxkyHx8889aDxQUlERh1JRIQQQpxUQrSNbhwcVMYbF4ZweaalyweAT9Px+U9cFdF1neYuIxGpaekOLOvozFODFRHpDxltJBERQghxUgnRNgA2+4a+TyS4NAPgOUki0trtwx9oUq1u7aa5y0u+UkWC0gFWJ6TPHLK4xMiQREQIIcRJZcZHEee08om/wLgwhH0iLV09iYjbe+JEJNjYCkYi0tTh4TR1v3Ehaz5Y7UMWlxgZkogIIYQ4KYuqcOakFLbqgYpI1TbweU74Of3V2isR6faduE8keK4MQG2rm6ZOL4vUvcaF8WcMSTxiZEkiIoQQol/OnpRKiZ5Bm+ICXzfUDM2494FURJp6VUTa3T4qmjpZrAZGu+ctHZJ4xMiSREQIIUS/nDkpBVDY5A9s4y37aEget08icpItvL2XZgBqygrJUerxY4GcRUMSjxhZkogIIYTol5zEaPJTY9joD5xsW7p+SB63rdsXet99sqWZDm+f246qjQBUx0wBR+yQxCNGliQiQggh+u3sSal8rE01bpSuB61/Q8hO5FQqIjmtWwGoTZx/ynEIc0giIoQQot/OnpzCLn0CXTigqxHq95/S4/n8Gu3unorIyYaaNXf1rYgsxGhUbU6TQWajlSQiQggh+u30/GSw2NjsD+yeKV13So/Xe1kG+tOsaiQi0XYLybQwUa0EwJMl/SGjlSQiQggh+i3abmVOTgKbtGnGhdINp/R4LUdUOPq7NDM53cXCwPyQvVousQlppxSHMI8kIkIIIQZkaqaLj/VeDau6PujH6j1VFfrRrBpIRKZluliq7gZgkzY1NPlVjD6SiAghhBiQyekutmoT8WE1DsBrKhn0Yx1ZEek+2dJMYNfM1Iw4zlKNOSZrtVkkRMtE1dFKEhEhhBADMjndRTcO9qrBPpHBb+M9emnmJM2qgYrI7NgW8tVqfLrKBm06iVIRGbUkERFCCDEgk9NdAKzxTDYulKwZ9GO1dh3RrHqCHhGPT6PDYyQqk9qNQ/e26hPxWGOJslkGHYMwlyQiQgghBiQpxk6qy8FaLXDSbdHqQfeJHFUROcHSTLAaoioQU2EkP2v9s0iMtqEoyqCeX5hPEhEhhBADNjk9ls3aZHyqE9qroXbvoB7nyGbVEx16F9y6m+hUUQ69D8AabRYJUdIfMppJIiKEEGLAJqe7cGOnJHaucaHovUE9zkAqIsEdM4ucFdDdTKcaw3a9QHbMjHKSiAghhBiwKYE+kY3qHOPCKSYiwWTiRM2qwaWZM9UdAJS4FuDHQqLsmBnVJBERQggxYJMzjETk1Xbj3BmtZB11TS0DfpzWQCKSGusATtysGlyaWegzzpdpyTwTgJzEqAE/rwgfkogIIYQYsElpxkm3H7Wn0eFIRfV38/sVTw/4cYKJSFpcfxIRD0m0MsltDDKbd8G1PHrdXO48b+KAn1eED0lEhBBCDJjLaSM7IQpQeLPTGPee3bCBxg7PiT/xCMGlmTSXEzjxoXfNnV7Ot2xBRYOM2ThTxnPF3GwZZjbKSSIihBBiUCanG1WRD/2zADhH3c7HJY0DeozWwKF3aa6TV0SaOz0sVzcbN6ZeNtBwRZiSREQIIcSgzMyOB6AqZSl+LExTyziwb1e/P1/X9VBFJDWYiJygItLR3spZgUZVpn5qkFGLcGM1OwAhhBCj05fOnEB8lI3L52bR+PeFpNZvJKroTeCCfn1+p8ePXzMGoaX2oyIyvvkjnIqXzuhsotNnnHL8IjxIRUQIIcSgJETb+fJZ+aS5nNhnXQ7A3PYPaTtiSNnxBKshNosS2oJ7oh6ROR3rAGgetxxkkmrEkERECCHEKYufexUA85WD7Nx/sF+fE0xE4qNsOANnxXiOVxHxe1nkNc6X8Uy85BSjFeFEEhEhhBCnLj6bUuc0VEWnffvL/fqU4NbdOKcNh9X4dXS8pRn94EoSaKdej8NRsHRIQhbhQRIRIYQQQ6Jl/MUApFWs7N/9g4lIlA2HLZiIHHtpxrf1WQBe8Z9BYmz0qYYqwogkIkIIIYZE0oLPADDDvZ3u1vo+H/NrOm/vrmZTcc/23uDW3bgoGw6rsTTTfayzZjobsRx8C4C3reeGlnFEZJBERAghxJDInjiL/YzHpvhp+OiZ0PU3dlax/Lcf8NWnNnPLk5tCfSB9e0ROUBHZ/RKq5mGvlktr/NTh/0LEiJJERAghxJBQFIX1ccbyTMyuZ0DXWV9Yz9ef2UJRXQdgbNmtaukCoCkwhTWhV0XE69dDW3pDthvLMi/4zyYjQc6ViTSSiAghhBgyleMux63bSGjdD1XbWFtoLNEsm5JKXrLR21HW2NnnvzmJUaFmVThi50x9IVR8jIbKK/6lZMY7R+grESNFEhEhhBBDJjszi7e004wbW55iX3UbAOdPTaMg1RgJX95oVERKG4wqSV5ydJ9EpM/yzKY/A3DAtYg6EsmIk4pIpBm2RKSkpIQvfelLTJgwgaioKAoKCrj//vvxeAZ2IJIQQojRY2Kai+f9y4wbO/9NcWUdAFMz48hNNJKI8iajElIaqIjkJcdgtahYVGNIWahhtaMBtjwFwCtRxpwSqYhEnmEb8b5v3z40TePPf/4zEydOZNeuXdx22210dHTw8MMPD9fTCiGEMNGk9Fg2aNMp01MZ567jNO97FHMuUzJcbC/vWZpp6fTS3Gk0q45LMq47rSodHn9PReTjv4KvCzJm817nNKCdDElEIs6wVUQuvvhinnzySZYvX05+fj6XX3453/72t3nxxReH6ymFEEKYLM3lINZh5ynfhQDcYXmFvAQbcU4buYGEo6Kxk9JGY1kmJdZBjMP4m9gR2Jbr9mng7YJNTxgPesY3qW5zA0giEoFGtEekpaWFpKSk437c7XbT2tra500IIcTooSgKBWmxPO2/gGY1gTy1lltiNwKQm2gkIuVNXZQ2GMsy45N7hpOFpqt6Ndj2DHTWQ/w4OiddFtrqK4lI5BmxRKSwsJA//OEPfPWrXz3ufR588EHi4+NDb7m5uSMVnhBCiCEyKS2WLpz8wf0pAD7T9gz4POQmGT0ijR0e9lQZf2iOO0Yi4u1ogNW/MC4uvZPqNmPwWYzdgsshh8ZHmgEnIvfeey+Kopzwbd++fX0+5/Dhw1x88cVcffXV3Hbbbcd97Pvuu4+WlpbQW3l5+cC/IiGEEKaamGbsjnnGfwF1ejzx7irY9jQup43EaBsAaw8a23rzkmJCnxecmJr58a+gswFSp8KCW6lu6QaMaogip+5GnAGnlvfccw+33HLLCe+Tn58fer+yspJzzz2XpUuX8sQTT5zw8xwOBw6HY6AhCSGECCPBRKQbB3/yXc79tqdg5Y+h4HzGJUXT1NnCrsoWAMan9K2IzFUKySh8zrjwqd+A1U5VIBHJjJetu5FowIlIamoqqamp/brv4cOHOffcc1mwYAFPPvkkqipjS4QQItIFExGAf6sX8aPsvSiHP4EXvsy4xAfYXgF6YHhqcMcMQKLaxX22J1DQYc71MP5MAKpbeyoiIvIMW2Zw+PBhli1bxrhx43j44Yepq6ujurqa6urq4XpKIYQQYSAnsWdAWUFGEsrn/g8c8VCxic+3rwB6RrjnJQeWZjwdfL/5R0xRK+h2JMOFPw3dJzgSXmaIRKZhS0RWrlxJYWEhq1atIicnh8zMzNCbEEKIyGVRFfIDU1SnZbggcTxc/igAi6ue4Y+2P+CiE5fTavSMNBbDs9cz2bOHFj2a1af9mWp/HP/YUEK319+nR0REnmFrP77llltO2ksihBAiMs0fl8DeqlYWjg+MbJhxFbRWob3zQy6zfMRp6j6KbVNQnv8H7H8TdD9uxcmt7u9yedREHl11kGc3lVHa0NmrR0QSkUgk+6CEEEIMue9ePJXzp6WxbHJaz8UlX6cmbib+f91KjlJPuncjBDdZFpzPY9q1bNkby0U+LXQOzXObylADo9/lnJnIJImIEEKIIRcfZeO8qelHXU+ZeiZzPb/iNGUfN0zWWT7eBpOXQ9Y86l7cCZTh9mnUBiapdnh6DsCTikhkkkRECCHEiLFZVBLiE3m/eS6XzJgFp40LfcxpM9oWu71+agI7ZYIcVpWEwAwSEVlkP60QQogRdcbEZGwWpad/JMBhNQaaNXd5aes2pqkmx9gBoxoiw8wikyQiQgghRtRDn53Nlh9eSEFqbJ/rwS2/5Y3GOTROm8pXzzEGZIa2+YqII0szQgghRpSiKLicRy+zOAJLMxVNxtyQ9DgnXzxjAlF2K0vyk0c0RjFyJBERQggRFoJLMxVNRkUkzeXAalG56fQ8M8MSw0yWZoQQQoSFYLOq129MXk2Lk10yY4EkIkIIIcJCsCISlO6SRGQskERECCFEWAg2qwalxclp7GOBJCJCCCHCwpGJSLokImOCJCJCCCHCgtPWd2kmTZZmxgRJRIQQQoQFqYiMTZKICCGECAuOIyoiqVIRGRMkERFCCBEWeldEnDaVOKeMuhoLJBERQggRFnr3iKS55GyZsUISESGEEGGhd0VE+kPGDklEhBBChIXeiYjsmBk7JBERQggRFno3q8ows7FDEhEhhBBhwdlnaUYqImOFJCJCCCHCgtWiYlGNBtU0l1RExgpJRIQQQoSNYJ+IVETGDklEhBBChI3EaDsAuYnRJkciRopMixFCCBE2fn/9XA43dzMuWRKRsUISESGEEGFjQV4SC/LMjkKMJFmaEUIIIYRpJBERQgghhGkkERFCCCGEaSQREUIIIYRpJBERQgghhGkkERFCCCGEaSQREUIIIYRpJBERQgghhGkkERFCCCGEaSQREUIIIYRpJBERQgghhGkkERFCCCGEaSQREUIIIYRpwvr0XV3XAWhtbTU5EiGEEEL0V/D3dvD3+ImEdSLS1tYGQG5ursmRCCGEEGKg2traiI+PP+F9FL0/6YpJNE2jsrISl8uFoihmh3PKWltbyc3Npby8nLi4OLPDMYW8BgZ5HeQ1CJLXQV4DiLzXQNd12trayMrKQlVP3AUS1hURVVXJyckxO4whFxcXFxHfaKdCXgODvA7yGgTJ6yCvAUTWa3CySkiQNKsKIYQQwjSSiAghhBDCNJKIjCCHw8H999+Pw+EwOxTTyGtgkNdBXoMgeR3kNYCx/RqEdbOqEEIIISKbVESEEEIIYRpJRIQQQghhGklEhBBCCGEaSUSEEEIIYRpJRIbZAw88wNKlS4mOjiYhIaFfn3PLLbegKEqft4svvnh4Ax1Gg3kNdF3nRz/6EZmZmURFRXHBBRdw8ODB4Q10mDU2NnLjjTcSFxdHQkICX/rSl2hvbz/h5yxbtuyo74Wvfe1rIxTxqXvssccYP348TqeTxYsXs2nTphPe/9///jdTp07F6XQya9Ys3njjjRGKdHgN5HVYsWLFUf/PnU7nCEY79D788EM+/elPk5WVhaIovPzyyyf9nPfff5/58+fjcDiYOHEiK1asGPY4h9NAX4P333//qO8DRVGorq4emYBHkCQiw8zj8XD11Vdz++23D+jzLr74YqqqqkJvzz777DBFOPwG8xr86le/4ve//z2PP/44GzduJCYmhosuuoju7u5hjHR43XjjjezevZuVK1fy2muv8eGHH/KVr3zlpJ9322239fle+NWvfjUC0Z66559/nrvvvpv777+fLVu2MGfOHC666CJqa2uPef/169dz/fXX86UvfYmtW7dy5ZVXcuWVV7Jr164RjnxoDfR1AGO6Zu//56WlpSMY8dDr6Ohgzpw5PPbYY/26f3FxMZ/61Kc499xz2bZtG3fddRdf/vKXefvtt4c50uEz0NcgaP/+/X2+F9LS0oYpQhPpYkQ8+eSTenx8fL/ue/PNN+tXXHHFsMZjhv6+Bpqm6RkZGfqvf/3r0LXm5mbd4XDozz777DBGOHz27NmjA/rHH38cuvbmm2/qiqLohw8fPu7nnXPOOfo3v/nNEYhw6C1atEi/4447Qrf9fr+elZWlP/jgg8e8/zXXXKN/6lOf6nNt8eLF+le/+tVhjXO4DfR1GMjPitEI0F966aUT3ue73/2uPmPGjD7Xrr32Wv2iiy4axshGTn9eg9WrV+uA3tTUNCIxmUkqImHq/fffJy0tjSlTpnD77bfT0NBgdkgjpri4mOrqai644ILQtfj4eBYvXsyGDRtMjGzwNmzYQEJCAgsXLgxdu+CCC1BVlY0bN57wc5955hlSUlKYOXMm9913H52dncMd7inzeDxs3ry5z/9DVVW54IILjvv/cMOGDX3uD3DRRReN2v/nMLjXAaC9vZ28vDxyc3O54oor2L1790iEGzYi8XthsObOnUtmZiYXXngh69atMzucYRHWh96NVRdffDGf+cxnmDBhAkVFRXz/+9/nkksuYcOGDVgsFrPDG3bBNdD09PQ+19PT00ft+mh1dfVRJVWr1UpSUtIJv6YbbriBvLw8srKy2LFjB9/73vfYv38/L7744nCHfErq6+vx+/3H/H+4b9++Y35OdXV1RP0/h8G9DlOmTOFvf/sbs2fPpqWlhYcffpilS5eye/fuiDwE9FiO973Q2tpKV1cXUVFRJkU2cjIzM3n88cdZuHAhbrebv/71ryxbtoyNGzcyf/58s8MbUpKIDMK9997LQw89dML77N27l6lTpw7q8a+77rrQ+7NmzWL27NkUFBTw/vvvc/755w/qMYfacL8Go0V/X4fB6t1DMmvWLDIzMzn//PMpKiqioKBg0I8rwteSJUtYsmRJ6PbSpUuZNm0af/7zn/nZz35mYmRiJE2ZMoUpU6aEbi9dupSioiJ++9vf8tRTT5kY2dCTRGQQ7rnnHm655ZYT3ic/P3/Ini8/P5+UlBQKCwvDJhEZztcgIyMDgJqaGjIzM0PXa2pqmDt37qAec7j093XIyMg4qjnR5/PR2NgY+nr7Y/HixQAUFhaGdSKSkpKCxWKhpqamz/Wamprjfr0ZGRkDuv9oMJjX4Ug2m4158+ZRWFg4HCGGpeN9L8TFxY2JasjxLFq0iLVr15odxpCTRGQQUlNTSU1NHbHnq6iooKGhoc8vZbMN52swYcIEMjIyWLVqVSjxaG1tZePGjQPefTTc+vs6LFmyhObmZjZv3syCBQsAeO+999A0LZRc9Me2bdsAwup74VjsdjsLFixg1apVXHnllQBomsaqVau48847j/k5S5YsYdWqVdx1112haytXruxTHRhtBvM6HMnv97Nz504uvfTSYYw0vCxZsuSorduj/XthKGzbti3s/+0PitndspGutLRU37p1q/6Tn/xEj42N1bdu3apv3bpVb2trC91nypQp+osvvqjruq63tbXp3/72t/UNGzboxcXF+rvvvqvPnz9fnzRpkt7d3W3Wl3FKBvoa6Lqu//KXv9QTEhL0V155Rd+xY4d+xRVX6BMmTNC7urrM+BKGxMUXX6zPmzdP37hxo7527Vp90qRJ+vXXXx/6eEVFhT5lyhR948aNuq7remFhof7Tn/5U/+STT/Ti4mL9lVde0fPz8/Wzzz7brC9hQJ577jnd4XDoK1as0Pfs2aN/5Stf0RMSEvTq6mpd13X9pptu0u+9997Q/detW6dbrVb94Ycf1vfu3avff//9us1m03fu3GnWlzAkBvo6/OQnP9HffvttvaioSN+8ebN+3XXX6U6nU9+9e7dZX8Ipa2trC/27B/RHHnlE37p1q15aWqrruq7fe++9+k033RS6/6FDh/To6Gj9O9/5jr537179scce0y0Wi/7WW2+Z9SWcsoG+Br/97W/1l19+WT948KC+c+dO/Zvf/Kauqqr+7rvvmvUlDBtJRIbZzTffrANHva1evTp0H0B/8skndV3X9c7OTn358uV6amqqbrPZ9Ly8PP22224L/dAajQb6Gui6sYX3hz/8oZ6enq47HA79/PPP1/fv3z/ywQ+hhoYG/frrr9djY2P1uLg4/dZbb+2TjBUXF/d5XcrKyvSzzz5bT0pK0h0Ohz5x4kT9O9/5jt7S0mLSVzBwf/jDH/Rx48bpdrtdX7Rokf7RRx+FPnbOOefoN998c5/7/+tf/9InT56s2+12fcaMGfrrr78+whEPj4G8DnfddVfovunp6fqll16qb9myxYSoh05wK+qRb8Gv++abb9bPOeecoz5n7ty5ut1u1/Pz8/v8fBiNBvoaPPTQQ3pBQYHudDr1pKQkfdmyZfp7771nTvDDTNF1XR+x8osQQgghRC8yR0QIIYQQppFERAghhBCmkURECCGEEKaRREQIIYQQppFERAghhBCmkURECCGEEKaRREQIIYQQppFERAghhBCmkURECCGEEKaRREQIIYQQppFERAghhBCmkURECCGEEKb5/zCzGKfPhzrvAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "elmr = ELMRegressor(random_state=0, activation_func='gaussian', alpha=0.0)\n",
+    "elmr.fit(xtoy_train, ytoy_train)\n",
+    "print(elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test))\n",
+    "plt.plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.8539052299524694 0.8438980713759163\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df1981e9a0>,\n",
+       " <matplotlib.lines.Line2D at 0x1df1981ea00>]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "elmr = Pipeline(\n",
+    "    [\n",
+    "        ('rhl', RandomLayer(random_state=0, activation_func='multiquadric')),\n",
+    "        ('lr', LinearRegression(fit_intercept=False))\n",
+    "    ]\n",
+    ")\n",
+    "elmr.fit(xtoy_train, ytoy_train)\n",
+    "print(elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test))\n",
+    "plt.plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "20\n",
+      "40\n",
+      "60\n",
+      "80\n",
+      "100\n",
+      "120\n",
+      "140\n",
+      "160\n",
+      "180\n",
+      "\n",
+      "Time: 22.659 secs\n",
+      "Test Min: 0.606 Mean: 0.672 Max: 0.737 SD: 0.027\n",
+      "Test Min: 0.734 Mean: 0.784 Max: 0.823 SD: 0.016\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x1df19b14f70>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABmiklEQVR4nO2dfXRU533nv5JG7y8jhNAbyGCTkEAw0GDgEHISn125dOtu193dFO/aJuXkZUtkB0PWNdTHsJt6oanrlK6hoeaQhHPqLN5w7JRTs+BUSZ14i0MC9TrUGIwxr0IjCYFGjEavc/ePXx/NndG9M/fO3DtzZ+b7OWeO0J378twX9Hzv77VI0zQNhBBCCCEepjjbAyCEEEIISQYFCyGEEEI8DwULIYQQQjwPBQshhBBCPA8FCyGEEEI8DwULIYQQQjwPBQshhBBCPA8FCyGEEEI8jy/bA3CKSCSC7u5u1NbWoqioKNvDIYQQQogFNE3D0NAQ2traUFxsbkfJG8HS3d2N9vb2bA+DEEIIISlw9epVzJkzx/T7vBEstbW1AOSE6+rqsjwaQgghhFghGAyivb19ah43I28Ei3ID1dXVUbAQQgghOUaycA4G3RJCCCHE81CwEEIIIcTzpCRY9u7di3nz5qGiogKrVq3CyZMnTde9//77UVRUNO3z4IMPGq7/h3/4hygqKsLu3btTGRohhBBC8hDbguWVV17Bli1bsGPHDpw+fRpLly7F2rVr0dvba7j+q6++ihs3bkx9zpw5g5KSEnzhC1+Ytu5rr72Gt99+G21tbfbPhBBCCCF5i23B8u1vfxtf+cpXsGHDBixatAj79u1DVVUVvvvd7xqu39DQgJaWlqnPj3/8Y1RVVU0TLNevX8cTTzyBl19+GaWlpamdDSGEEELyEluCZWxsDKdOnUJHR0d0B8XF6OjowIkTJyzt48CBA3j44YdRXV09tSwSieCxxx7DU089hU996lOW9jM6OopgMBjzIYQQQkh+Ykuw9Pf3Y3JyEs3NzTHLm5ub0dPTk3T7kydP4syZM/jyl78cs/xb3/oWfD4fvv71r1sey65du+D3+6c+LBpHCCEkbTQt2yMgJmQ0S+jAgQO49957sXLlyqllp06dwl/+5V/i+9//vq2S+tu2bcPg4ODU5+rVq24MmRBCSKEwPAxcuyY/ieewJVgaGxtRUlKCQCAQszwQCKClpSXhtqFQCIcOHcKXvvSlmOU///nP0dvbi7vuugs+nw8+nw+XL1/GN77xDcybN890f+Xl5VNF4lgsjhBCSFoMDwM3bgC3bslPihbPYUuwlJWVYfny5ejq6ppaFolE0NXVhdWrVyfc9oc//CFGR0fx6KOPxix/7LHH8O677+Kdd96Z+rS1teGpp57C8ePH7QyPEEIIsY8SK+PjQGOj/KRo8Ry2S/Nv2bIFX/ziF3Hfffdh5cqV2L17N0KhEDZs2AAAWL9+PWbPno1du3bFbHfgwAE89NBDmDlzZszymTNnTltWWlqKlpYWfOITn7A7PEIIIcQ6erGiLPV1dUAwKMtbW4GqquyOkQBIQbCsW7cOfX192L59O3p6erBs2TIcO3ZsKhD3ypUr09pDnzt3Dm+99RbeeOMNZ0ZNCCGEpIuRWFFQtHiOIk3Lj5DoYDAIv9+PwcFBxrMQQghJTCKxoicYBEpLKVpcxOr8zV5ChBBCCgtNA27eBEKhxGIFkO9DIVk/P97vcxYKFkIIIYVFUREwcyZQXS0WlEQEg7LezJmyHckaFCyEEEIKj6oqcfOUlpqLFrqDPAUFCyGEkMIkkWihWPEcFCyEEEIKFyPRQrHiSShYCCGEFDZ60dLfT7HiUWzXYSGEEELyDiVabt6UAFuKFc9BwUIIIYQAIlIqK5kN5FHoEiKEEEIUFCuehYKFEEIIIZ6HgoUQQoi3YYXZ1Mmja0fBQgghxLsMDwPXrslPYo88u3YULIQQQryJalB465b8zJOJNyPk4bWjYCGEEOI99N2UGxvlZ55MvK6Tp9eOgoUQQoi30E+4qptyXV3eTLyuksfXjoKFEEKIdzCacBV5MvG6Rp5fOwoWQggh3iDRhKvIg4nXFQrg2lGwEEIIyT6aJmXxQyHzCVdRVyfr3byZV2m7KVMg146ChRBCSPYpKpIePtXV0a7JZgSDst7MmaxMCxTMtaNgIYQQ4g30XZPNJt5gkN2UjSiAa0fBQgghxDskmnhzfMJ1nTy/dhQshBBCvIXRxJsHE25GyONrR8FCCCHEe+gn3v7+vJhwM0aeXjtftgdACCGEGKIm3ps3JUg0xyfcjJKH146ChRBCiHepqgIqK3MuoyWjaJrx9cmza0eXECGEEG+TJxOuKyTryJxH146ChRBCCMlFMt2ROcuF5ihYCCGEkFwj0x2Zk1lyMgAFCyGEEG+QY6Xis0amOzJn2pJjAgULIYSQ7OOBN/icINMdmTNtyUkABQshhJDs4pE3eM+T6Y7MmbbkJIGChRBCSPbw0Bu8p8l0R+ZMW3IsQMFCCCEkO3jsDd7TZLIjc6YtORahYCGEEJJ5Mv0Gn8zSkAsBv5noyJxpS44NKFgIIYRklmzEYiQK6M2lgF+3OzJn0pJjEwoWQgghmSNbsRhmAb25GPDrdkfmTFhyUoCChRBCSObIViyGUUBvLgf8ut2R2W1LTgpQsBBCCMksmXiDTxbQ29+f+wG/6jrOmOGOeHDbkmMTChZCCCGZx803+GQBvUNDwLvvynE8krKbMlVVwJw57okHty05NqBgIYQQkh3ceINPFtAbDss6IyPy73B4+jq5JlrcDnh125JjkZQEy969ezFv3jxUVFRg1apVOHnypOm6999/P4qKiqZ9HnzwQQDA+Pg4nn76adx7772orq5GW1sb1q9fj+7u7tTOiBBCSO7g5Bt8soBeTQMGBkSEtLTIz4EB44DeDKfseh63LTkWsC1YXnnlFWzZsgU7duzA6dOnsXTpUqxduxa9vb2G67/66qu4cePG1OfMmTMoKSnBF77wBQDA8PAwTp8+jWeffRanT5/Gq6++inPnzuF3f/d30zszQggh3sNo8nfyDT5RQG9REdDQIPvv6ZGfDQ3GFooMp+zmBFm+DkWaZk86rlq1CitWrMCePXsAAJFIBO3t7XjiiSewdevWpNvv3r0b27dvx40bN1BdXW24zi9/+UusXLkSly9fxl133WVpXMFgEH6/H4ODg6hLlipHCCEk8wwPi8Vi5kxjUaJpqU+K+n0Did1Cvb1iWZkxA2hunv59FgNLCxGr87ctC8vY2BhOnTqFjo6O6A6Ki9HR0YETJ05Y2seBAwfw8MMPm4oVABgcHERRURHq6+vtDI8QQohXsVLvJB2xot83kDigt7YWWLJExIxHUnZJcmwJlv7+fkxOTqI5TpE2Nzejp6cn6fYnT57EmTNn8OUvf9l0nZGRETz99NP4T//pPyVUWqOjowgGgzEfQgghHiSVeidWjf9m+wYSB/Q2NnoqZZckJ6NZQgcOHMC9996LlStXGn4/Pj6O3//934emafjOd76TcF+7du2C3++f+rS3t7sxZEIIIemQSoNDq6Xyk+0bSBzQm42UXQbwpowtwdLY2IiSkhIEAoGY5YFAAC0tLQm3DYVCOHToEL70pS8Zfq/EyuXLl/HjH/84aRzKtm3bMDg4OPW5evWqnVMhhBDiNqk0OLRaKt/qvoHEAb2ZTNnNpZ5FHsSWYCkrK8Py5cvR1dU1tSwSiaCrqwurV69OuO0Pf/hDjI6O4tFHH532nRIrH3zwAf7+7/8eM1XQVALKy8tRV1cX8yGEEOIRUmlwaNV1ZHffQOKU3Eyk7OZizyKPYdsltGXLFuzfvx8HDx7E2bNnsXHjRoRCIWzYsAEAsH79emzbtm3adgcOHMBDDz00TYyMj4/jP/7H/4hf/epXePnllzE5OYmenh709PRgbGwsxdMihBCSNVJpcHjtGtDdndx1lGrzxGS4mbKbyz2LPITP7gbr1q1DX18ftm/fjp6eHixbtgzHjh2bCsS9cuUKiotjddC5c+fw1ltv4Y033pi2v+vXr+PIkSMAgGXLlsV899Of/hT333+/3SESQgjJJqrB4diYcfl7PcEgUFws6/p8xu6dYFAmeOWysbPvbNdSMYuziT8nkhTbdVi8CuuwEEKIx0jmugkGgYkJ+beRWIlfVx8Ua2Xf2c74yYUxegBX6rAQQgghlknW4NDnA8rKgEjEnntH09xtnugEqcTwkIRQsBBCCHGPRA0O29ok2NWslL4eI/eOG80TnSDVOJv8cHi4BgULIYQQd0lU7ySRpUSRSIRko5ZKMlQMT6pCjBhCwUIIIcR9EtU7Sde9k8laKlaxK8QqKzM7vhyEgoUQQkhmSFTvJF33TiZqqdjFqhADWFDOAhQshBBCMkcit0e67h0vulTMhJjPFxUrLChnCQoWQggh3sGL7p10iRdiExOSGcWCcragYCGEEDswk8N9vOjeSRclWioq5Pdbt4B33wWGhqw3hSxwKFgIIcQqbF6XObzo3nGC4mIRJZOTwMiIPEvhcPR7ihZTKFgIIcQKbF5H0kE9P0NDIlDGx4GWFnEPBQIULRagYCGEkGQw1iB9CtmVpp6fsTERKMPDQG2tfFdTYy5aWFAuBgoWQghJhFnzOq+LFi9NcoXsStM/P34/0NAg8SxDQ9F1jEQLC8pNg4KFEELMSNQPxsuixUsCoZBdaUYl+isrgeZmyRiKFy3Dw8DAADA46I2KvR6DgoUQQozI1eZ1XhIIhe5KMyvRbyRa7twRcVJaKg0hKVamQcFCCCHx5GrzOi8JhFx1pTmNWbVbvWjp6ZFCclVVEttCsWIIBQshhMSTi83rvCQQctWV5haJREtlpdRm8fkoVpJAwUIIIUak20U4k3hJIOSqK81tzEr019UBS5bId9l+jjwOBQshhJiRbhfhTJCOQHDahZWrrrRMYdYrqbEx/yr7ugAFCyGEJCLdLsJuko5AcCOTKBddaZnGrFdSIV2DFKFgIYSQZKTbRdgtUhUI4bB7mURuudLyyQqTj72SMgAFCyGEWMGrXYTtCgTA/Uwip11pXqor4xS0qNiGgoUQQqzi1TdjqwIBSC2TKBXrhhVXmpX9eqmuDMkqFCyEEGIHr74ZJxMIQGqZROlYNxK50qzsV9+DJ9t1ZUjWoWAhhJB8wUwgAKllEjlh3TBypVnZr1onGJQqsOGwu+nQ+RQjk6dQsBBCSD4RLxAqK1PLJAqFnIt10bvSrFTj1YuVcFh666jGgG6IlnyMkclDKFgIISTf0AuEVDKJKiulXLyTVXOLiqxV440XK+Pj0uF4fNwd0cIYmZyBgoUQQvIRfayNnUwiv18sGk5XzbVSjbe7Wywd/f1RsVJbK+vU1k4XLekWnnOz9xJdTI5DwUIIIYWAlUyiRGJFkYposVqNd2JCjn/zJnD7dlSsKPSiJRBIr/Ccm72X6GJyBQoWQggpFBJlErW0iOXC6bL6dqrxlpaKECkqEvF05870dWprRczcuiXrpJJinmrvJaZhZxUKFkIIKSTMMomUtcLpsvpWY2g0DbhyRdZfsEAElM83XbTcuQPU1wM1NSKw7LpeUu29ZCcN282ifAUMBQshhOQCTsZEmFXtdausfrL9ahowNATMmgXMnSsTfWUl0NwcK1ru3JHfq6pEBNl1B6Xae0llTFlJw3bDxUQAULAQQoj3cSMmwqxqr1sdqs32Gw4D589L/Mo998hHraMXLQMDUbFSW5vaGNLNmEqWhu10oDKJgYKFEEK8jJsxEWbWCac7VCvrUPx+w2Hgww/FgmF2bCVaVLxKqmIl0bnFkygI2SwN2+lAZTINChZCCPEq2YyJcKpDdbx1SO13YgJ4/31ZtnChWE/UuRmJlpqa9MWK0bnpRYum2UvvVmnYTgcqE0MoWAghxItkOibCaBJNt0N1MutQVRUwf74Ikvhz04uKvj6grMzZLtlG1h7lmrKa3j0xIX2OioudDVQmhlCwEEKI18h0TESiGJlUO1SbWYf6++WnzyfZQJWV0W2MRIvfD4yMpJ7CnAi9tefsWTmmpkm8jFWrSSQiYsrnczZQmUyDgoUQQrxEpmMirMTI2LUImFmHhoaAd9+VCbyuzni/+nPr7xdLR0WF/HTTFVZdDXzykyIs7FpN5swB2tqcD1QmMVCwEEJIIlKJN0g1RiHVtFsvlaY3E1yaJsuGhsT9Eg6b76OuTs7r7FkRD7NmueMKU2PVW3vq6uR3QCwvVq0mTgcqk2lQsBBCiBmppBOnk4KcStptOqXpu7udjZFRAmBsbLrgKiqSJoazZkmlWtUTyIjeXqm5UlMjriAnxmY2VnX++muYTLSYCRGnApWJIRQshBBiRCrpxE6kILtVvC1+nBcvAlevyn70pCoMlHWov1/EhpEYUSnK9fUSSDswMN061Nsry2fMkHWdGFs8Vt1uRqIl2bVPN1CZmELBQggh8aTiKnHSveJW8TZA3EgXL4p1ZXLS2NKRijAoKhJBEgrJvs0sKJWV0XoqPl+sZSORWElnbHrsut30QbVWrSapBiqThKQkWPbu3Yt58+ahoqICq1atwsmTJ03Xvf/++1FUVDTt8+CDD06to2katm/fjtbWVlRWVqKjowMffPBBKkMjhBDBibgOq64SN1KQ3YiJCIWAX/0KOHcOKC8XF43qfmwkWuzEyAwPS2BsMrdPMChiZckSOYY6t8FBiW+prjYXK6mOTU8qbjcVVGvHasLUZcexLVheeeUVbNmyBTt27MDp06exdOlSrF27Fr29vYbrv/rqq7hx48bU58yZMygpKcEXvvCFqXX+7M/+DP/zf/5P7Nu3D7/4xS9QXV2NtWvXYmRkJPUzI4QULqnGkaSSTuxmCrKTMRHDw8BHH8kkPzQEjI7K8tpaY9FiJ0ZGfw2amqJun3jRohdcjY2x51ZWJgXkGhvdj99Jxe1Gq0nWKdI0e/J01apVWLFiBfbs2QMAiEQiaG9vxxNPPIGtW7cm3X737t3Yvn07bty4gerqamiahra2NnzjG9/Af/2v/xUAMDg4iObmZnz/+9/Hww8/bGlcwWAQfr8fg4ODqEtm5iOE5C9q8gyFZFKzOsFbiWsAYicywP42qYqNmzdlgk4nZqW7Wywro6MiJurrRSAAImJKS0VsjI9bH6/ZdQuHRayo46gMnPh9xp9bsvvgZOaN2bGY3ZNRrM7ftiwsY2NjOHXqFDo6OqI7KC5GR0cHTpw4YWkfBw4cwMMPP4zq6moAwEcffYSenp6Yffr9fqxatSrhPkdHRxEMBmM+hJACJ9U4klTSifv75ZOJFOR03u7jxUptrVwbZQHp75f1lKXlww8lyDQdsQJMD7C9dcu4+Fv8ubkZvxMPU5FzCluCpb+/H5OTk2iO8y82Nzejp6cn6fYnT57EmTNn8OUvf3lqmdrO7j537doFv98/9Wlvb7dzKoSQfCOdOJJU4hoaG+WTaBslTpwoy55O6nJfnxRCq62NjslItBQVyfUqK4utQGuEFZGnREtbm6Qoh8PGgi3+3DIpJJiKnDNkNEvowIEDuPfee7Fy5cq097Vt2zYMDg5Ofa5everACAkhOYkTcSSpxjWYbRMOi1jo7c3OJKiuycQEcNddcuz+fnHTqPhAvWjp7pblc+eKxSOZQLIq8lTjwpkz7Qm2TAoJpiLnBLYES2NjI0pKShAIBGKWBwIBtLS0JNw2FArh0KFD+NKXvhSzXG1nd5/l5eWoq6uL+RBCChAnS9mn4o4w2kbFb3R3S5pusj44Tnfvjbd+qPiR27eBnh6xuOhFS3W1rNvaCtxzj/UJ26rIS7VxYSaFBINqPY8twVJWVobly5ejq6tralkkEkFXVxdWr16dcNsf/vCHGB0dxaOPPhqz/O6770ZLS0vMPoPBIH7xi18k3SchpMBxo5R9Ku4I/Ta9vdFg01mzZLJN1Acnncq4ZsRbP8Jh+VlfL8uDwahouXNHxr1okXROTlVUuBVzkkkhwVRkT2PbJbRlyxbs378fBw8exNmzZ7Fx40aEQiFs2LABALB+/Xps27Zt2nYHDhzAQw89hJkzZ8YsLyoqwpNPPonnnnsOR44cwa9//WusX78ebW1teOihh1I7K0JIYeBWKftU3BGqs/DAgIiB+nqJ31BZN0bWHScq4yY7h4mJaCCtirtR9U8uXxZh1daWmliJP5ZbMScUEgSAz+4G69atQ19fH7Zv346enh4sW7YMx44dmwqavXLlCoqLY3XQuXPn8NZbb+GNN94w3Ocf/dEfIRQK4atf/Spu376Nz372szh27BgqKipSOCVCSEGhJssbN6JdgONJZfJU+7WaTqwKp82YIcGtDQ3RwFUlEG7ciI4hPqMp/nunUValyko5Xigk4/X7gZaW9I+pvw/9/fZSylNB0zIvZLJxTDKF7TosXoV1WAgpcNyqqWFlkoo/ttk2aix+v4gFN+t/6MdUWipuqvFxEVNDQ1KWv7RUAmKN6qOkc9x0asa4eYx0BEcmzqtAcaUOCyGEeBa33BLJJjijOBqzberqZN2zZ407GjvV3M8o6La5Wa7FwID8nDtXAmybm9OrEROP2zEnqbrR0okVctN1RyxDwUIIyR+yUVPDThxNb68EudbUiJXFCCdEi9GYlGjx++VnZaWs50SNGKPju0GqhQHTERxONrUkaUHBQgjJL7JRU8NKem+mmvslGlNlpQTYqtiaXKrqmmphwHQEhxtNLUnKULAQQvKPbNTUSJbem8nmfonGpPaX62JFkUhApCM43GxqSVKCgoUQkp9kI5tDCQSfzziORt+h2Go1XafGZBbbk6wEf7ZJtTBgOoLDyWKExDEoWAghxGkiEal7YhRHk8nmfgqz2B7A+aJ1TpJqYcBQKHXB4UYxQuIIFCyEEOIU6s1clb2vqDAWH9noEhwf2wN4P/MllcKADQ2SCZWq4HCrGCFJGwoWQghxgvjgTp9POiSbkY2MJhXbA+RO5ovdppRKQKQjOFJphElch4KFEELSxSy4c2IisRBwK6MpkXsiHM69zBe7bjQnBEc2XHckIRQshBCSDulmkzid0ZSoQFouZ77YdaM5ITiy4bojplCwEEJIqqSSTWJk/XAq/iFRgbR8yHyx60ZzQnBkw3VHDKFgIYSQVEglm+TaNeDqVXfEQKICafmU+WLXjeaE4MhGMUIyDdvdmgkhhCCaTTI2Zt4lWhEMSgDu2JjEkIyPOzvxmcXQ6DtA2xmr1zNfqqqirQWsrm+n87YTxySOQwsLIYSkitXgzokJ+ff4eFQ0OOV2sRqXAuRX5otd4eBErBDFSlahYCGEkHRIFtypFyvhsPQUCoedES1241KAws58oeDIaShYCCEkXcyCO+PFyvi4FDZTv6cjWlKNS6msZOYLyUkoWAghxAnigzuNxEptrSyrrU1ftKRTkZWZLyQHoWAhhGQfL2ajpIISAvX10p35zp3pYkWhFy39/all5aRTII2ZLyTHoGAhhGSXRIXOcpGqKqC9XfoIXboE9PRMFyuK2lrg9m1x16SagZJOgTSni9YR4iIULISQ7JGo0FkuMzwMXL4MTE5GuzYbceeOWGNqasTSkqqlKZ0CaQxEJTkCBQshqZIvboxskajQmRW8ev2Hh6NWlbvvFtFw+7aIFv2Y79yRBolVVRJbkm7dE8alpIZXnyMyDQoWQlIh39wYmcas0JlV0eLV668/r6YmoLlZPqWlQCAAnD0LjIzEipXa2tSFRfxky7gUe3j1OSKGULAQYpd8dWNYwYm30XQb8Hn1+hudV2WlCBa/X1w03d3AP/+zuInSFStmk62bcSn5ZI3w6nNETKFgIcQO6boxchkn3kbTbcAXCnnz+ls5r4YGcfuMjEhGkM+XnlhJNNm6EZeST9aIQv5/nMNQsBBilXTdGG7i9puvE2+j6Tbg6+8HTp+O7YXjheuf6LzCYXEF+XzA3LkyOZaVSXn+VO9ZNibbfLJGOP3/OJ+sTh6HgoUQK6TrxnB7bG6++To1QaZT6Ky/H3j3XWBgQERAOBxdN9vX3+y8lFiZmJAsoIoKcRE1NQFLl0pci90xZ0M055M1wun/x/lkdcoBKFgISUa6boxMjM2tN1+nJ0izmiH6t9T4dFwlVkZGpL7J+LgIAS+JlvjzihcrADA0JP++915xD9kdczZEs5etinZx+v9xPlmdcgQKFkISka4bw03cfvN1a4I0mty7u6Nl6vViJRSSzJqhIaClRbZXFWKNREsmr7/Zefl8wJUrcl30YqW0VAJw9TErVsecDdHsZauiXZz+f5xPVqccgoKFkESk48ZwE7fffN2eINXkPjEBfPihdDD+8EP5XYkVfT2TWbMkFVhhJFoyef0TnVdbm4w3EpEx68VKZWXs+lbGnA3R7GWrYio4+f84n6xOOQYFCyHJSKdfixu4/ebrBauSUT0Tn89ctAQC3imUVlUF3HOPCJehIWB01FysWK1Em0nR7IX77wZO/D/OJ6tTDkLBQogV0unX4iSZePPNxASpzsPnA+bPlzol8+fL793dEsionzBVPRMj0dLXJ8taWrIvVhRKtHz84yJcxsdjv7f7zDgpmpMJC6P7b7aNF6xadkjn/3G+WZ1yEAoWQqySTr8WJ8jkm6+bVqX4P/yVlTKpV1bK7xMTkvZbXBx7bCPRolxGCxfKxOklqqpEsNxzjzPPjBOi2WpWi/5Yvb3RGKNUjuk1Uvl/nK9WpxyDgoUQO2SzX0umXQNuWJXM3lL1Y6yrE1ECiHgxEy1Xr0qq8JIlEvjoRYqKnH1m0hHN8VktoVDyY/n9kkre3T09Xkh/zFybmO3eE6/GshUYFCyE2CWb/VoyHU9jZYK0OlnZfUuNRKTIms83XbRUVUlqsF6seG3S1I9H/8zoXVfpWr/MJtv4/cZntQSDUoTPrIu02mZwUMY8a5Y0cAwExOKiP2au1iJJ9P/Y6L54LZatAKFgISQV3OzXYuXYmYynSTRB2pmsUnlLnTNH3EXxgqm2Fvj0p6NixWuTptF4lMgaGJDl6Yw50WQbv994q5YqvDcwIPVtjESLfhvVwLG+XuKFBgbE8qLufy7XIjH6f5zovngllq1AKdI0r72WpEYwGITf78fg4CDqkr29EZIPxE9Ebv/BHB4WC8nMmbGTVSgk4sLqcZMFLxqdR6Jj6b9TacXZnDDMxqpfXvwv74qRiL1rF08kEt2X0bH9frGS6MVKICC/19ZKDFC8W83s/iiR4/PJ8vh958OEbfWZzvT/vTzH6vxNCwshuUqm42n0b6PpFM5K5S3VzKKgH0d1tcS1XLyYvTd9s+vS3x87zu5u+VRXp55VMjwMXL9ubElpbJSU6nffjfZeihcrgLinRkailpZEYlIFRzc3T983kPsZMnae6WzGshUwFCyE5DKZjqcpKnKmcFYqwaPx5nv9OEpLZTKenBQhkA3RYnZdgkGZ3FUBuUAAKC8Xy4aqH5NKDxu9K0YviOrqJAZjfFyOqSwj8WJF0dIi6733ngi+RDFGRUWyv+Fh2WZiIjbeI5dEi37cqTzT2YxlK1DoEiIkH9C0zGQkpOLOsbK/dNxKSgSoyVgVa2trk5TiTEwkidwogYAErFZUyLKSkqhouHNHXCzNzdFzsZrto47V2yuCZMYM2U/8sXt6RFjU1xtnU6kxVFVFs7OU20ePpok1Rp1Pfb1xQTzA+y4SvXsTSO+ZztT/vTyGLiFCCgkviBUgdUuLnbfURGIFkJ/l5ZmztCQTK+PjEu+hxENpaXSdmhoRE1YtLUYBtMPDIiTiu1irztBFRRIsGw7Lenr0gqmpyTwzS/V76u6WfSUSK4C3a5HorVMXL8onnWeaYiVjpCRY9u7di3nz5qGiogKrVq3CyZMnE65/+/ZtdHZ2orW1FeXl5ViwYAGOHj069f3k5CSeffZZ3H333aisrMT8+fPxJ3/yJ8gT4w8huY+bhbPsZFzpx2EkVhRKtFy6JBkfbv0tMbsumhbNBqqpkeDU4mL53L4dO56aGllvYEDGbXbthodFMOjdPuoYLS3GDSFV8bpZs+Q66I+tFyuVleaZWUp4DQ7KJF9aKuubiRXAu7VI9IJv5kwRX5cuxYpII7wswAoI24LllVdewZYtW7Bjxw6cPn0aS5cuxdq1a9Hb22u4/tjYGB544AFcunQJhw8fxrlz57B//37Mnj17ap1vfetb+M53voM9e/bg7Nmz+Na3voU/+7M/w4svvpj6mZHchX8QvIfbhbPsrDdzpkz8H35oLFYAsST09orFYGxsepVWpzC7LkVFksJcVSXCwO+XsUQiYp3Qn++dO9GU56Eh42s3PCyWgKtXo5Nr/DHMulg3NADt7TLpjo7KdkZiRe/2iG9OOTEh31dUiPjJxVok8dapoiLgrrvEovThh4mfEa8KsALDdgzLqlWrsGLFCuzZswcAEIlE0N7ejieeeAJbt26dtv6+ffvw/PPP4/3330epiYr9nd/5HTQ3N+PAgQNTy/7Df/gPqKysxN/8zd9YGhdjWPKE+NRZ4i2cjmFJhFlsgKYBH3wgn9pasVDoGRkBLl+WMc6ZI9+3tsq/3Zps3IxhUed7/rzso6oq1h2jjjExIeeq6qS0tcn5qntSWgpcuCCiaNYsc7GiP6eLF8WqU1wcPe74uBwLmB7rkimxYjduJNFzGw6LYAGkn1WqTSpJyrgSwzI2NoZTp06ho6MjuoPiYnR0dODEiROG2xw5cgSrV69GZ2cnmpubsXjxYuzcuROTk5NT63zmM59BV1cXzp8/DwD4f//v/+Gtt97Cv/k3/8Z0LKOjowgGgzEfkuPkehGqQiBThbMSFe8qKhLxMXeuiBN9M0QlVgDgYx+Lfl9Z6e6bsdl1Ua6TigqxdMydK+sMDVkPuA2HxUpUViafeCuKvl1BT0/UWqMXK62tYk1YsiRqlUkmVuKbUyqBY9Y6IVMTu92Ce8lEdmWlnCMw3dJCseIpbAmW/v5+TE5OolkfiQ6gubkZPT09httcvHgRhw8fxuTkJI4ePYpnn30WL7zwAp577rmpdbZu3YqHH34Yn/zkJ1FaWorf+I3fwJNPPolHHnnEdCy7du2C3++f+rS3t9s5FeI10qnrQTKL200grQhX1Q25rS0qSvRiZe5ceYbq6yWgd3DQ/WfJ7LrU1YlQUC6b5mZxzYyMJBcr8cLB5xMhYiRaqqpEGCmRZHRPGhulQnBtrXn9kETNKRXxoiVTtUjsvtRYjb1SomV8HLhyRbajWPEcrmcJRSIRNDU14aWXXsLy5cuxbt06PPPMM9i3b9/UOv/7f/9vvPzyy/jBD36A06dP4+DBg/jzP/9zHDx40HS/27Ztw+Dg4NTn6tWrbp8KcQsn6nqQzOJW4Sy7xbuUaLl9W9wmQFSslJZGy8qn8iw52eensTG6PBSSMbe1RYOHE4kVvXBQlpR40aLaFSxZIusmuicqfdysh47RBG9kndL3e6qvz5xYsfNSYyf2anxcnp1Zs+QaUKx4Dp+dlRsbG1FSUoJAIBCzPBAIoKWlxXCb1tZWlJaWoqSkZGrZwoUL0dPTg7GxMZSVleGpp56asrIAwL333ovLly9j165d+OIXv2i43/LycpSXl9sZPvEiicy1qujWjRv8w+FF1OTsVMxRosJrZs9AVZVkyFy5Ir/fdVesWFFWAbvPUjqxVGbXJX45ELuOPi7D7P+FEi0qZmV8XNwYbW1y7ipgNtnYlUsoXoioCX5sLGodMosXGRyMtkJw2+WWyrOhUNf9xo3Yyrx6lDXlrrvkd8bReRJbFpaysjIsX74cXV1dU8sikQi6urqwevVqw23WrFmDCxcuIBKJTC07f/48WltbUVZWBgAYHh5GcXHsUEpKSmK2IXmIG3U9SGZxqglkMuFq9gxomlgYZs6UcVy+LNVujWqEWE1NdSKWyuy66JfHtzpQcRnJ3Bh6S8v4uHzKyqLna/WemAkMNcH7fCKMurunZ9AEAjLeUCjxvpwg1WdDj53YK6eeaeI4tl1CW7Zswf79+3Hw4EGcPXsWGzduRCgUwoYNGwAA69evx7Zt26bW37hxIwYGBrBp0yacP38er7/+Onbu3InOzs6pdf7tv/23+B//43/g9ddfx6VLl/Daa6/h29/+Nn7v937PgVMknsTNuh4ks6Q7WZlNSFZKvutN/mryNMNKaqqTsVRmx9Av17c6UAJJCbBEbgwlWkpKxI3hRgZUKCTj6e6OjZcJBGT50JCIFjeL8zn5UmMn9oqpy57ElksIANatW4e+vj5s374dPT09WLZsGY4dOzYViHvlypUYa0l7ezuOHz+OzZs3Y8mSJZg9ezY2bdqEp59+emqdF198Ec8++yy+9rWvobe3F21tbfgv/+W/YPv27Q6cIvEkRqZnM1gDIX/RC1d92XjV/6ahIdat098v6xu5ICoqJJsFkElVb2WxEkCZjtshVeIFkv5YydwY4+NSXyW+O3W6pQFUOvO1a2Ktqq2VGCHF7dvijlL/H7u7ZbnTbRDMng0jkj0bCr17qL8/vU7ZJOOwlxDJLpms60G8iVG5+UBAlutrjhg9C0Zl+lVDPhXHYqVHTzaeQ7Nj6o8FJF/HKMPHbm8m/faq9kpFhVxHVYKir0+sKn6/lPHX15IZGXGnd5MVCwuQWg8rxql4BvYSIrlBpup6EO+ifwZ6e6Oio6Eh2ment1e+b2kxFitmWTSqSms6YgVwPpbKalwGYO7G0F+L+H2m4s6KFys1NSJKSkpEkIyMSDr2+Hg0pRmQ9Soq3OndlOjvgyKVvxOMU8lJKFhI9nG7rgfxPlVV8uY+MCAuB1W9tqZGfh8YkOdB9c5JlkWjAlKTkY1YKrsCCZieKq2ulRIH6ZYGMBIrCiUkb96UVOiKChmHPhDXjmixe+3ceqmheznnoGAh3sCtuh4kNxgeljTZGTOkpsfQkCwfGpLfKyulrLzqGKwyVBJl0fj9UgwsEjEXGW73SIonVYFUWRmtneL3RxsRqliMdLJoVFPFvj4pwa8XK5omgjEUkn+PjkYtLoOD05s4FhcD16/LmIyut90qtQq+1BBQsBAvof4oGRW0IvmL3jqgCr0pa0ppabQWyMiIxFMMDUmwdnFx4iyatjbZZzKR4ZbbwYh0BJIquT84GHX7DA0B776bOHA9WVr4zZuyXNVx0bc6KCoSwThrllzTgQFx0ZWXi3CKb+IYiQCzZ8vY4q93uunifKkpeChYiLegb7mwMLI46C0kKktnYkJiNoaH5d+qEKW+l43an2JoyPqklslYqlQF0vCw9ApSlhRNk38PDYl7JlG3YTN3ll5AKcHo88WKloqK6P/J0VEZlxIwimSBt06li/OlpqChYCHeg77lwsHM4lBZKZOSEis1NTIxKyuD3z+9AV84HC1ylmogZqbcDnYFklGMSlGRXItZs8Rto6+VEk8id5Z+LGaiZXxcjvXJT8o+VLdmwJ5YcaL1Bl9qChYKFkJIdlHl9fWTdzgsgZ56sWJUbl+JlqEhyQgaHLSWGZRoLFbcDk5Ug7AqkBIF6SprVH29uWixIroSiZahIbGs3HMP8LnPyc/R0WjHabtiRZGOaOFLTUFCwUIIyS7DwxIb4ffLhDk4GM2AMRMrCuXquH3buohItl4yt0OqgaOJjmUmkKwE6epFS1+fXDt1jnYsREaiZWRErr8SJI2N0YaTQ0Ox39kRKwq23iA2sF3plhBCHENf6GxsLJoBU1oqE2BPj0zEzc0SSxFPICDbzpolNUNUdVw1CRoVVrNSMEzfHNCoKaEarxOuokRNJK1WhK6slO1qa6N1aNJxi6lzbGuTPkV6F0xVlQiUf+kFZ+iecaNKLSl4WOmWEJId4t/A1QSrRMvNm+JymDFDvo8v1R8ISMZJQ4NUXgVixUX8hJ1KFVi9wAGMx+tUfItZV2SjaxVP/LVLtdKt/njqvM1EhJo6Uh1z/NgZRFuwWJ2/KVgIIZknWVl6v19iMSorxcrS3S1pzKpUfzAoYmXGDPndjPiJfHxcrBBWMoj0Akf1R/P5rJXIdwMrpfyVMHOi7HwiAZXumBUUKwQszU8I8SpWAjEHB8Vyop/EysrkuwsXxIVQUiLBtcnSeW/eBM6eFbdKaamIHxWnYRY7oR9jdXW0YF1paex6NTWZi8GwGqTrVBaNE64Ztt4gDkLBQgjJHHYCMT/6SMq8+3xSsVaV2y8qkniWUEhERKJ03t5ecSvV1IjgCQREDAUC5qLFqKFiRYUUS9Mfa2AA+Kd/EtGUDdGSKIvJS3EgrFJLHIKChRAvkB+e2cTYKUtfWgpcvixZL7W1scXk2tpENExMyHdm6by9vSIqVAxMIBCtJzI+bixa9GJFBfGqbKXa2uh2168D770ngum992QsqfQZSuW+52LxNFapJQ5AwUJItnEyTdbrWClLHw5LLZXSUikXr6wF+mJyFRUiXgD5d7xoGRyUOJXq6lixUlsr3+vFR2mpiI1r10SAKOuPKsymL1dfWysT7okTcox58yT195e/lNokdvoMpXPfc7F4Wi4KLeIpKFgIySbp9lfJFdTkDCQuS69pwJUrEm8yf35s3ZX4YnI1NdK7RgXVKtHS2yvun4ULRbB8+GGsWFEo0fLhh7Fpy/r19N2f79yRY3R3R0WTpkXH0ddn/f45cd+95PaxSi4KLeIZKFgIyRZO9VfxOvGTM2AuWoaGpKbKvHlyPRThsIgRJVaUFaaoSFxELS2xhdP8/un1TIxQy5U1pbgYOH8+1r2kRMudO8A774hoaWwUi8qtWxL8u3ChrPvuu2KBsXI91H0fG8vP+26GuuaF4AYljkLBQkg2cLq/ilcxE2WAeSDmPffIR32nabGxJOGwxLcMDopAUenPzc0iXqqrZd3+frF8qIBdfW8cQH5XAb2RSLRC7PCwiCG9aAmHo12Ny8uj4x0cFItMRYWIppGRxKIl/r6HwzKOYDC/7nsyCskNShyDgoWQTONWfxWvkUyUAeaBmPogzaGhaCxJf7+IFVUVd3hYgl4HBkS01NSIMFIfsy7ESqw0N8v3xcXRtOdPflLWUaIlEgEuXRLBMneuWFRCIYnF8PtlfCMjsk1Li6z34YeyXaLroaxGg4PRho35cN+TUShuUOI4FCyEZJJC6a9iVZQB5oGY8b1t6uokO+fWLfnO5wNmzxbXzHvviZApKzMWPXrRMjAQK1ZU52FVFK6yUqwugAgPFUyr+hrNmiWVdRsa5DMxIZaekREpcjdzpmxfrPvzaiZW9FlLhSBaCsUNSlyBgoWQTGEnrVc19bObJusF7IoywDwQU4mOiQmxctTUyLajo2I9AUQ83LolBeVUD6L47fWixe83FysKvWg5e1a+/8QnZPnEhIgW1dvI5xOh8k//JL8vWRLbPyf+vuvFSnzWUjgc7auTa/c9GYXiBiWuQcFCSKZQjeySpfUC8n11tb00WS9gR5TV1kZFmRVKSuR6NDfLvvXunZYWETOqCq6eeNHS1pZYrCiUaCkpEQtKTQ2wYoXEsPT1yTojI2Kx6e+XcdTWGhdxU/c9EJguVvTX4/ZtuSZWmgDmkqApFDcocRUKFkKs4NTkkKhUuSKXq4BaFWXhsGTjFBcnFmVKAA0Py8Tm84n1YtYs+fetW/Jz1iyJLxkaEotIKBS7H/11v3lTtikrkziTRMKqokKOFwqJwJkxA1i0SETLtWsiVnp75RwWLpR4lGvXpj8vVVVi2bl1S0RJvFgBRPDU14uLaHAw8eSdS0GrheIGJa5DwUJIMowmh3QETL73V0kmylRKspWJSaUbj46KFaOmRpZXVIhIqauLumdUfElZWTTjx2hcM2aIlWXOnOTCqqhIzmPmTBE5ajx33y0i5soVESILFkQL2KkgWiA6Bk2TZTU1IkrMMpaam8XFlcgdmEtBq4XiBiUZgYKFkEQYTQ5OvN3me38VM9GixAog2Tg+X/JJt7parBe1tRIroqiokAleiZXSUnGlNDaaW230hcusWrtqayUupa5Ofg+HxRowb558FiwQ68vt2yJGbt2SHkj9/dHnRFmeVAdls4ylysrE7sBcC1otBDcoyRhFmpYfUtZqe2pCLBNvyg4Go3EPkYj8cU1XXKhjhELO7M9rxDcSVGJFX8XWqlDr75caJyMjErOi0IuVujr719DMZRE/ruFhESLd3SKSVIXbgQERKTNmiIhQFXGV+2rmzNh93LghY1bit6oqVqyYXQur4zRD07InBJK5hfJJrBPbWJ2/aWEhxAijP7ClpTJZdXdH63uk+3ab7/1V9Fk+Z8/KsviS+1bjFxobxdJRURG1tKQrVvRjTGbtqqwUd9PYWNRlMTAQDaJV7ipVp+XKFXFl6SvZqmPV1ETjWtIRK1avX7ZjXvLdDUoyAgULIfEYTQ4qFbWiQgIujTr9pkqh9Feprp4uVhSpiJarV8WKkY5YUVjpJlxUJPdp3jwRIjduyHMwOSnj6OsTy0p/v5yL3y8/y8qmn1skItvU1KQnVqxcP6/EvOS7G5S4DgULIXoSiRXVxya+068ToiVfffYq6DISkVgPI7GisBp0qUSLqnzr1IRnxdpVVSVtA2bMECvP5KQ8DzNmyP0/f17G5PdL1pLPF/ucXLwoH1UZd3Iy8TmkG7TqtZgXK8KQEBMoWAhRGE0O8WJFUVsrf/QHBqICxsvBj9lCH3Q5NJR4XaOgSzPhUlUlcSyqeJtTWLF2KdfQ5KQ8F+GwZAaNjMjPsbFof6Gamuhz4vPFuhR9PtlfRYX5pJ1O0KpXC7XluxuUuAYFCyGK+MkhvumenqEh+UPb0CDbOZGS6Wb8ezZi69UxU609YxZ3oSbi0lJg8WJrmUZ2SGbtCoclTmXGDBl3ICDuqUBALCvKajIyIgG4VVUicnp7RZwUF0eFrs8XW8LfCHX9fD7r18/rhdoKxQ1KHIWChRA9Zk339HUzVKCnCpYE0k/JdDMoMhsBl/HHtBt0aRZ3ET8RK7GYqQlYf/yZM+X5qKiQ30MhiWEpKRHBcu6cWGD0GWaaNl3oTkxYG3skIusmu365UqgtX92gxDUoWAiJx6xp3p075mIlHV+8m0GRTuzbrnXG7JhWgy7N4i76+7NrNVAuw/7+qJVlwQIpVldVJYJ1dFSExfi4BOGGQuImUmIl/tmxMnZ1PVTci160xF8/FmojeQwFCyFGGImWkRGZkNwQK24ERTqxb7vWmWTHTBZ0aRZ3MTQkNViCwexZDYqK5L4rS4qKU2lsjC1a19cnx581K7qumVjRj91IPMRfTxX3MjFhfP1YqI3kMRQshJihn1xDISnnrhrnAc6KFaeDIp3Yt13rTKJjdndPFy3xQZdmrgxNk2VDQ2LZUGXvjTCb+NO1IGiajG9wUNw5qrz+yIiMq74+6qIqK4uW829oEAEzOGguVgBj8WB2PZMF6+Z7vypSsFCwEJII/eR6zz3ycSIl082gSCf2bdc6k+iYpaUSlHrxYqxo0QddJtpe9e+ZNUusFYGAuWgxm/jTieEZHpbxX7smYqipScTHxARw+bL8bGiQT0kJ8LGPSa+hyUkZw4wZIjLMsqSSucWM7mGyYF0WaiN5CAULIckw6j+TTkqmm0GRTuzbrnUm0TFVWvjkpFhZ9KJFn7qcLO6islJEQn29WCyMmhvqJ2JlyUg3hkdtf/u2pCsXF8txKiqi7kJ1HpOTkmpdXy9j+PjH5d+LF4uAGhoSS4vZmK2IFYWVYF0WaiN5BgULIVbQ+/jTScl0MyjS6r41zVrMhBXrTCRifkx9DRuVTXP5slgq9Me0GndRWSnXXKUD6++JfiIG5Bj6IN1UYnjUtRgbmx4/MjQU7fg8OiqCqKRExlhTI+KqoSHqQmxslAaOZWWJxYPTzwcLtZE8goKFkFRINUjRzaBIK/sOh8XS0dtrLWYiHr1o6e8Hrl+XSTr+mEYF91Tg6djYdJdOqp2T1XK9WLlxQ87x3XdFWKQSw6OuRTAosSrhcGz8yMSE7GvuXBEn8WJFWXhUVllrq4gWK+X/nX4+WKiN5AkULIRkGjeDIhPtW4mI7m5xqfj9qb/Z9/dLM8OBAXFz+P3RYxqJFTVxz59vXujNatyF2cQPREXG5KQExA4Px4ojq40C1X5UFVsVN2MmWtQ1S5ZBZrX8v9PPBwu1kTwgJcGyd+9ezJs3DxUVFVi1ahVOnjyZcP3bt2+js7MTra2tKC8vx4IFC3D06NGYda5fv45HH30UM2fORGVlJe6991786le/SmV4hHgfN4MijfatRMTt2xK8OmOGTMT6eBKrb/aBgAib2lrZ1/h4VLRMTAAffmgsVtRkbiQaElXFtTLxA7EiY3xc4kkmJqYH6VqJx9Hvp6Eh2jvKSLSEQsDs2dYzyKyIBzeeD6YukxzHtmB55ZVXsGXLFuzYsQOnT5/G0qVLsXbtWvT29hquPzY2hgceeACXLl3C4cOHce7cOezfvx+zZ8+eWufWrVtYs2YNSktL8X/+z//Be++9hxdeeAEzZsxI/cwI8TpuBkXq993bGxUr9fUiHJqbE9dIMRMtgYDEazQ0SLYMEBUAt2+LZWNsLCpAjArtqW1U/EUoZFwV1+dLHHehJn4gGmsyMSH7qa2V5TU15qIlPv4jvjDc+Hh0P/qGl+Gw/B6JSExKfb39DDIr4oFBs4TEUKRp9goUrFq1CitWrMCePXsAAJFIBO3t7XjiiSewdevWaevv27cPzz//PN5//32UlpYa7nPr1q34v//3/+LnP/95CqcgBINB+P1+DA4Ooi6ZSZsQL6He6kMhsXA4ORn190djOWbNmi4c7GSpGIkVPar8fDgs6xUXyz6N6o+o4/r9Yp2JP3eVigwktkbEj1VZkvRiA5A4FJ8vOhaziV9dr5ERsdDEMzQkomx0FGhvF5FSWRkbB3TzplirnLqHbj4fhHgAq/O3LQvL2NgYTp06hY6OjugOiovR0dGBEydOGG5z5MgRrF69Gp2dnWhubsbixYuxc+dOTE5Oxqxz33334Qtf+AKamprwG7/xG9i/f3/CsYyOjiIYDMZ8CMlJ3AqKVIXOZswQd4WRcDByjxi92ScTK2pfPp8cY8YMCUS1IlbMSvCPjCSuNWIUd6PSn1UvKIW+a/LgoLFYMSoMF09pKfDRRyKmlMXGqQwyMxg0SwgAm4Klv78fk5OTaG5ujlne3NyMnp4ew20uXryIw4cPY3JyEkePHsWzzz6LF154Ac8991zMOt/5znfw8Y9/HMePH8fGjRvx9a9/HQcPHjQdy65du+D3+6c+7e3tdk6FEGOy1VPF6YlOP5k3N4tgMauyauQe0YuWvj6ZvGtqzMWKfl+RiIiROXOiMR0KI7Giz+IJBqMWocbGxLVGjOJuNM1YtKiuyaWl4saJn/j110sVhlP9oxQjI5KWXVUl1/POndgKvvpxOQ2DZgmx5xLq7u7G7Nmz8Y//+I9YvXr11PI/+qM/wptvvolf/OIX07ZZsGABRkZG8NFHH6GkpAQA8O1vfxvPP/88bty4AQAoKyvDfffdh3/8x3+c2u7rX/86fvnLX5pabkZHRzE6Ojr1ezAYRHt7O11CJHXcMOdnEytpykDiuAh1TSorRWCMjYnYsLIvIPb4icQKEBsYrGJtErlv4s9TuaQaGmS7+P2pGi7J9hPvXpqYEPFy+bKsN3NmNH15fJwxJYSkiSsuocbGRpSUlCAQCMQsDwQCaDHy9wJobW3FggULpsQKACxcuBA9PT0YGxubWmfRokUx2y1cuBBXrlwxHUt5eTnq6upiPoSkjJsdk7OFE+mx6s2+sVGERn+/TOJW9mVUtCyRWOnpiTaa1AfKJktFrqqS/d66JRYPtV1lpXwqKkRwJBIrRtdLWWomJoAPPpB19GLFLOOJEOIKtgRLWVkZli9fjq6urqllkUgEXV1dMRYXPWvWrMGFCxcQiUSmlp0/fx6tra0oKyubWufcuXMx250/fx5z5861MzxCUsPNjsnZxon02KKiaHxHebkIg3jRYrYvffxFS4sIifhaL+GwWC+uX5eA1kBA4l9UzImqzJsoFVnFnuj7DQUCst2SJTIGK1YQs+tVVTVdrCgoWgjJCLbTmrds2YL9+/fj4MGDOHv2LDZu3IhQKIQNGzYAANavX49t27ZNrb9x40YMDAxg06ZNOH/+PF5//XXs3LkTnZ2dU+ts3rwZb7/9Nnbu3IkLFy7gBz/4AV566aWYdQhxBTc7JnsF/SSsetnYSY/VX6M5c0QY6EWLVSuNqsoaH3PS3S3NBcNh4Px5CWg9fVrcTw0N0ZgQo1gb/dhU7InqN3TrllheGhvtxX/o06qvXJGYnKYmY7GisNtGgRBiG5/dDdatW4e+vj5s374dPT09WLZsGY4dOzYViHvlyhUU6yL729vbcfz4cWzevBlLlizB7NmzsWnTJjz99NNT66xYsQKvvfYatm3bhm9+85u4++67sXv3bjzyyCMOnCIhJiTrmxMMyvf5EJ+g3CZnz0og6syZ9sWKukYq8HZgINpnx4qVRo2jtTUac6IaCGqaTPgjIzK+4mKZ/JVrB5heit5obPqAWyXQlHvK7vVqa4sG2kYiInrMApfttlEghNjGdh0Wr8I6LMQWTgSkegVNSz5JqvPt7xeRsXChCA0r25hdo95eERdW9mW074sXxboCiBvn2jWxigBSOdbnk+MuWiT/1t+HZGNT1yTd+6fqwYyNRccTTy48I4R4GFeCbgnJC9zsmOwUVo+lJtREriv95N7eLuJCX5bf6JhWBF1Tk/m+rDIyItdW1WUqLpZYF59P4liCQeBXvxJhpASBlfuXyI1kh6oq4OMfj1axdbqNAiHEMhQspPBws2OyE1gRIWq9ZJlNRsLD758eo6M/ph1B5/fbFwRqTKrf0MiIxMOUl4s1RU38qsx/KCQxKan0PXLi/hUVebtMfjaM5PlhmCc5BgULKUzc7JicDlbTq61kNiWL0YmvLKuOGQ67JwiUGLpzR44/PCzbV1RIjEh9vQTalpTI9+Pjcv3HxiT+JhSS/WTj/hmlaWdbrFgVt7l+TEJAwUIKGTc7JqeC1fRqK5lNVlw6+sqywWDsMQF3BIGyjtTUiNtnfFxEyLx5IloA+dnQEHUPqQq75eXRNGcgO/fPS2Xys1E7KB/rFZGcgYLFLjSF5hdeMfVbTa+2YjXp7pY34GQunXBYPv390Tdm/T4AdwSBuuZ1dSJIqqvF5aNnclK+mzFDBIuqgxJvycnG/fNCmfxs1A7K53pFJCegYLEDTaH5SbZN/cPDIhCsum6SWU0mJsSFUlxsbh1RZedVD7DiYsn6CYfl/K9elSwewB1BoK55U5MEApeXy/EBEVolJZJCrMRKoiq12bh/2UxdzkbtoEKoV0Q8DwWLVWgKzS3sWsKyZepX6b1Xr8pEa0RdXTSGo7/fWmZTJCJN/ny+6aJFL1YmJiRupLVVJp/Ll+UzOSkiKl60OCkIjETLpUv2xEr8vrzgqnETq3FJTv59ysYxCTGAgsUKNIXmFqlawoxM/W66ADVNxnnpUrQkfThsvK7fLxP62Fi0Wq0ZKhB2zhwpfqa3jmiaxIFcuxYVK6qGis8nIqanR66BEhDXromAsCoI7FwzvWhpbpbfR0ftiRX9vrLtqnETq3FJTv59ysYxCTGBgiUZNIXmFulawvSmfrddgOGwCJCyMvmMj5uLlmBQ4jcWLpR1rQbCxsd4FBXJcUZHZZkSKyqWpaJChEpfn6xTViZjDIetCYJUrpka4z33AJ//fLQsvh2xosjXKrPZqB2UC/WKSEFBwZIImkJzCyctYW67ANX+fT5g/nz5qcREvGjRixBVBt9OIKxetFy9KnVPPvYxsWjcuRMVK5OTYpmpqZF93b4tFhqfL3oNEgmCdK6ZEkN33QV8+tPWmxUWCtmoHeT1ekWk4KBgMYOm0OyRyhuak5Ywt12A8WNV/W+MRIuRCEklM6aqSrJuABEkc+fKMScmpMGfEitA9I26ulrGUFub/Bo4cc3URKfcWRQrsWS79oyX6hWRgoSCxQiaQrNHKi4FJy1hbrsAzcZqJFo+/FAEhdFEkEpmTHU1sHixvAUHg+L+KS0Vl49Cn6EzY0a0W3Ki59yNa1bIb+mJ/o5ks/aMV+oVkYKFgsUImkKzQyouBSctYW67AJMJYb1oUVVey8rMOwSnkhlTXR2dfIaGxOXT3i5uolu3YjN0mpvNOyUr6DZ1FiuCPVu1Z7xQr4gUNBQsZtAUmllScSk4aQnLhAvQihBWoqWkRNw2c+YkFsKpZMbon+3xcTlOS0tisWL0nGfbbZpvFk07gj0btWeyXa+IFDwULImgKTQzpOpScMoSlkkXoBUhrLoq33OPtWcrFcuekWhR525FrGTbbZpvRRxTEezZqD1TKPVuiCehYElGvplCvfZWmq5LwQlLWKZdgFaEcFub+8+WfhyhEDB7thx3fDx2LEbXLZtu03wr4phODFA2as/ke70b4lkoWKyQL6ZQr72VOuVScMISlmkXoFeEsP6N+Z575GP1Oc+G2zTfijg6EQOUjdg5xuuRLEDBYpVcN4V67a3UaZeCEwIg0y5Arwhh/Ruz3efczWuWiWykbJLtGCBCcgwKFjvkqinUi2+lbrgUnBAAmbZ8eEUIx3dAtvOcu3HN4q2B+ZaNlO0YIEJyEAoWu+SaKdTLb6VuuBScEACZtnx4UQjbfc6dvGbx1kCrXaq98ExbhaUTCLENBUs+kwtvpW64FJwQAJm2fOTDROTENYu3BtrtUu20JcJNiwZLJxBiCwqWfCWX/ONuuBScEABetHx4nXSumXpmx8aiz6zfL60BQiFpV5AIN7KRrASppyNqWDqBEMtQsOQjuegf90oAajyZtny4cQ8yfV9TuWZKrASD0YaMiqYmaRFw65a5aHErGylZkLoTmXdeyRgjxONQsOQjueof90oAarZwI+3ca6nsRujFSjgMDA5O71idSLRkK3Xaycw7rwp2QjwEBUu+kqv+8UJ1w7iRdu61VHYjlDWwv18Eyvi4CBN9x2pFU5O0DbhzR0QN4K5YSRSk7kbmXaELdkKSQMGSz+Sqfzzblp5M48bk58VUdiOKiqQNQCgE3L4t8SqA/IwXLcGgWAIXLpSmkE5bIqwGqRtlLTkVD1aogp0QC1Cw5Dv0j3sTFVfiRtq5l1PZ4xkeFmtJQwNQXy/WE4VetAQC0We2sdF5S4TVIPVgEHj3Xel07VbmXaEJdkIsQsFSCNA/7i1UXEmi+iKpTn65kMqu0I+1qUmaLvp800XL7dvi1vL7o8+sk5YIq0Hq4bCMeWhIxmwUzOy1a0xIHkHBUijQP+4N1CR944a8qQeDzqWd51Iqu5FIqKyMipahIVl2545YXmpqRDDoRYJTlggrQeqaBnR3A++/LyKqocH8+Klk3rGCLSFJoWApJOgfzy76OiNFRTIph8OxgaXxWJ38MpHK7uSkaiYSKitlfAMDcq18PnleZ850N5MtWZD6yIiMKRKJtQAZYTfzLhcyuQjxABQshQb949lBb/3w++UNfdYscXfEZ8PosTr5uZ3K7sakaiQSwuFojJUSdrW1mbEKmomWcBj48EMRU6tXAxUV8rvRPbMbH5YLmVyEeAQKFkLcxshVo9wf9fXmosXJbtOp7lM/fjcmVf2Ye3vlOkxMAG1tkgkUDsfGrrhN/DVUYgUA5s8XoTl/vvweL1pSFStez+QixCNQsBDiJoniShKJlnT6KKWbyq53/WRiUq2qElEyMCDXoaZG3GUzZshncDCzk7i6hhMT0scIEJFSWSn/rqycLlrSEStez+QixCNQsBDiFlbiSvSipa9PJu3BwfQyuSorU09l17t+MjWpqtTmGTPkOgwMyFibm+WTzUm8ujpWrCj0ouXsWRE36YgVBUULIaZQsBDiFlbjSiorZaKrrZWgzrKy9LodX7sm/7abyq53/Vy8KB+3J1X95K0Eit8vP5VIyPQkroRmJAIsWDBdrCiUaCktlXtmtp6eXMrkIsRjULAQ4iZW40pqa4ElSyR2Ix2xoo81Aaynsusn0upqSeHt7pZxG+HEpGqW2tzWNn3yz2STTr3QVOnVZoyPi2iZMyd5AHMuNiUlxENQsBDiNlbjShobU087N4s1AZLvU79tba24ZIqLJRsmUQZTupOqmQXKaOLPdJNOOwHMbW3W7lmuNiUlxCNQsBCSCay2SEhlckoWa5Kozkv8tkVFkglTVSUiZGJCRIuRFcWJSdXLTTrd6MXl5fMlxONQsBCSKdxokZBOAKfZtioQuLRURMudO8Cvfy2WF4WTk6qXm3S60YvLy+dLiIehYCEkkzjZIiGdAM5k8RRKtExOirjq7QU++ED24cak6uUmnW4ITS+fLyEeJSXBsnfvXsybNw8VFRVYtWoVTp48mXD927dvo7OzE62trSgvL8eCBQtw9OhRw3X/9E//FEVFRXjyySdTGRoh3seJFgnpBnDaiacYHpbYlupqyRyyk8JrBy836XSjF5eXz5cQD+Kzu8Err7yCLVu2YN++fVi1ahV2796NtWvX4ty5c2hqapq2/tjYGB544AE0NTXh8OHDmD17Ni5fvoz6+vpp6/7yl7/EX//1X2PJkiUpnQwhOUO6gZRKcIyNJW6gCJjHmqgJ88aN6fsIhyV2ZWQEuOceWRaJyMdN1Jhu3pTxemnyrqoSy5OTQbBePl9CPIZtC8u3v/1tfOUrX8GGDRuwaNEi7Nu3D1VVVfjud79ruP53v/tdDAwM4Ec/+hHWrFmDefPm4fOf/zyWLl0as96dO3fwyCOPYP/+/ZgxY0ZqZ0NIIeFEAKfah88X288nEJCqs/X1wNy58vH7JYXX5zOPi3EiBdfLTTrdyNjx8vkS4iFsCZaxsTGcOnUKHR0d0R0UF6OjowMnTpww3ObIkSNYvXo1Ojs70dzcjMWLF2Pnzp2YnJyMWa+zsxMPPvhgzL4TMTo6imAwGPMhpOBwKoAzEhFXj+rno8SKKuCmr49iFhfjZIPEQkvlLbTzJSQFbAmW/v5+TE5Oorm5OWZ5c3Mzenp6DLe5ePEiDh8+jMnJSRw9ehTPPvssXnjhBTz33HNT6xw6dAinT5/Grl27LI9l165d8Pv9U5/29nY7p0JI/pBOAKcK3B0ZEetIXx9w/XqsWFHoJ9X4uBh2HSaEuIzrWUKRSARNTU146aWXsHz5cqxbtw7PPPMM9u3bBwC4evUqNm3ahJdffhkVFRWW97tt2zYMDg5Ofa5everWKRDifVIJ4IwvNldaKkKlvj5qVTFDHxcTDrPrMCHEdWwF3TY2NqKkpASBQCBmeSAQQEtLi+E2ra2tKC0tRUlJydSyhQsXoqenZ8rF1Nvbi09/+tNT309OTuJnP/sZ9uzZg9HR0ZhtFeXl5SgvL7czfELyGzsBnGbF5gCpcFtUZB7Mq7feAMb7CQZlObNeCCEOYcvCUlZWhuXLl6Orq2tqWSQSQVdXF1avXm24zZo1a3DhwgVEdNkF58+fR2trK8rKyvCv//W/xq9//Wu88847U5/77rsPjzzyCN555x1DsUIIMcFKAGeyYnOqf9DEROK4GIBdhwkhGcO2S2jLli3Yv38/Dh48iLNnz2Ljxo0IhULYsGEDAGD9+vXYtm3b1PobN27EwMAANm3ahPPnz+P111/Hzp070dnZCQCora3F4sWLYz7V1dWYOXMmFi9e7NBpElJAJArgtFpszvcvxle9aLEqVvT7oWghhDiE7Tos69atQ19fH7Zv346enh4sW7YMx44dmwrEvXLlCoqLozqovb0dx48fx+bNm7FkyRLMnj0bmzZtwtNPP+3cWeQamsasAJJ59MXmGhsTr1tXJ7EwFRXSCLG/X2JWWlsltuXaNXv7uXnT+RomhJCCokjT8qN3eTAYhN/vx+DgIOqSVf7MJsPDLBJFsocVCwsw3ZoS/8ymsh8+74QQA6zO3+wllEmY+kmyTSrF5oziYth1mBCSYShYMkV8Cil9+yRbpFJszsiVw67DhJAMQsGSCcxSSClaSLZwqlswuw4TQjIEBYvbJEshpWgh2cKpbsHsOkwIyQAULG5iNYWUooVkCyU2ZsxIT2TY2U9+xPkTQjKM7bRmYpFUUkiZ+kmyQVWVM8+dlf0wS44QkiK0sLhFUZH8Ua6uNs+iUOj7slCs5C9etiw49dxZKVrHLDlCSApQsLgJUz+JYnhYiq0V6iTNLDlCSJpQsLgNUz9JLloWnLQGMUuOEOIAFCyZgKmfhUsuWhactAYxS44Q4hAULJmCqZ+FRy5aFpy0BuV7lpyXY5IIyUMoWDKJUymkxPvkomXBSWuQPksuWW+vujpZ7+bN3BEBhR6TREgWoGDJNEZ9WUhmyNRkmIuWBaetQfmcJZeLMUmE5AEULNkgF/4o5xuZeiPORcuCW9agfMySy8WYJELyBAoWkv9k8o041ywLbluD8ilLLhdjkgjJIyhYSH6TjTdiL1kWElluMmUNyuUsOXWuuRiTREieQcFC8pdsvhF7wbKQzA2WSWtQLmbJqevX3597MUmE5CEULCQ/8cIbcTYtC1bdYJm0BuVSlpy6fgMDwNmzYlnKlZgkQvIUChaSf3gpSycblgW7brBMWoNyIUtOf/1mzQJqaoA7d4De3sTbeSEmiZA8hoKF5BdezNJRgqC+PrNixY4bLJPWIC9P5kbXr7lZrEIDA+aiJVdicgjJYShYSH6Ra1k6TpKuGywX40ysYkWQJrp+iUQLxQohGYGCheQf6cZlOG1tURPh7dvuuaCccoPlUpyJVazU4LFy/YxEC8UKIRmDgoXkJ6nGZThdYC4TadVOu8FyIc7EKlaCj+1cv+ZmscoNDYlooVghJGNQsJD8xW5chtMF5jKVVu2GGyzfXGSJxKLd69fYCMydC4yOAn4/xQohGYKCheQ3VuMynLaEZDqt2kvF6ryAXbFo5/r5/bKfigpgcJB1VwjJEBQsJP9JFpfhtCUkW2nVXihW5wVSFYtWrp/fLyJFpTyzWBwhGYOChRQGZnEZTltCsp1Wnctl8J0gXbGY6PrpxQp7CRGScShYSOEQH5fhhiXEC2nV+ZyenAinxKLR9TMSK/p9UbQQ4joULKQwcdMS4oV4knxMT06Gk2JRf/0SiRUFRQshrkPBQgoTty0hXognyaf0ZKs4KRarqoDZs4Fw2FuVkwkpUChYSOHitiXEC/Ek+ZCebBcnxWJxcfZdfIQQABQspNBx2xJSqPEk2cZJsegFFx8hhIKFENctIYUYT+IFnBSLXnDxEVLgULAQArhvCSnEeBIv4KRY9IKLj5ACxpftARDiGdSEdPOmxCHYmYA0LXncAuMaskNVFVBZ6cz1V8/IjRsibKurKVYIyRAULIToSWVyGx5OTeSQzOFGnRvec0IyCgWLFay8PZP8wa5YuXFD0lnHxvi2XSg4abUhhFiCMSzJGB4Grl1jMSgyHacbJpLcgmKFkIxCwZIINSHdusWJiMTidMNEQgghCaFgMYNvz8QMpxsmEkIISUpKgmXv3r2YN28eKioqsGrVKpw8eTLh+rdv30ZnZydaW1tRXl6OBQsW4OjRo1Pf79q1CytWrEBtbS2amprw0EMP4dy5c6kMzRn49kzMcKNhIiGEkKTYFiyvvPIKtmzZgh07duD06dNYunQp1q5di97eXsP1x8bG8MADD+DSpUs4fPgwzp07h/3792P27NlT67z55pvo7OzE22+/jR//+McYHx/Hb/7mbyIUCqV+ZqnCt2dihpsNEwkhhCSkSNPs/TVdtWoVVqxYgT179gAAIpEI2tvb8cQTT2Dr1q3T1t+3bx+ef/55vP/++ygtLbV0jL6+PjQ1NeHNN9/E5z73OUvbBINB+P1+DA4Ooi7ZZGKGlbdnORiLRRUqfEYIIcRRrM7ftiwsY2NjOHXqFDo6OqI7KC5GR0cHTpw4YbjNkSNHsHr1anR2dqK5uRmLFy/Gzp07MTk5aXqcwcFBAEBDQ4PpOqOjowgGgzGftODbM7EC+8oQQkhWsCVY+vv7MTk5iebm5pjlzc3N6OnpMdzm4sWLOHz4MCYnJ3H06FE8++yzeOGFF/Dcc88Zrh+JRPDkk09izZo1WLx4selYdu3aBb/fP/Vpb2+3cyrTKSpiV1ZiDfaVIYSQjON6llAkEkFTUxNeeuklLF++HOvWrcMzzzyDffv2Ga7f2dmJM2fO4NChQwn3u23bNgwODk59rl69mv5g+fZMrMK+MoQQklFsVbptbGxESUkJAoFAzPJAIICWlhbDbVpbW1FaWoqSkpKpZQsXLkRPTw/GxsZQVlY2tfzxxx/H3/3d3+FnP/sZ5syZk3As5eXlKC8vtzN8a+h7hQSDse4hTkhED/vKEEJIxrBlYSkrK8Py5cvR1dU1tSwSiaCrqwurV6823GbNmjW4cOECIpHI1LLz58+jtbV1SqxomobHH38cr732Gn7yk5/g7rvvTuVcnINvz/mD2zFGTnYDJoQQYoptl9CWLVuwf/9+HDx4EGfPnsXGjRsRCoWwYcMGAMD69euxbdu2qfU3btyIgYEBbNq0CefPn8frr7+OnTt3orOzc2qdzs5O/M3f/A1+8IMfoLa2Fj09Pejp6UE4HHbgFFNEL1r6+ylWcpFMtVWoqgLmzOGzQQghLmK7+eG6devQ19eH7du3o6enB8uWLcOxY8emAnGvXLmC4uKoDmpvb8fx48exefNmLFmyBLNnz8amTZvw9NNPT63zne98BwBw//33xxzre9/7Hv7gD/4ghdNyCHZlzV0y3ZSQwdeEEOIqtuuweBVH6rCYwW7NuUV8rRS68wghxLO4UoelYKFYyR3YVoEQQvISCpZ8Ij+MZanDtgqEEJK3ULDkC5kKMPUqbEpICCF5DQVLPqAm61u3CnMyZlsFQgjJeyhYch29ZaGxsTAtCGyrQAgheQ8FSy7DANMobKtACCF5DQVLrsIA0+mwKSEhhOQtFCy5CANMzWFbBUIIyUsoWHINBpgmh20VCCEk76BgyTUYYGoNNiUkhJC8goIlF2GAqTW81pSwkKxchBDiMBQsuQoDTK3hFctSoRf2I4SQNKFgyWUYYJobFHphP0IIcQAKllyHAabehoX9CCHEEShY8gEGmHoTFvYjhBDHoGDJF7wWYFrosLBf+jBImRCig4Iln/BKgGmhw8J+6cMgZUJIHBQshDgJC/ulD4OUCSEGULAQ4iTpFPajaGGQMiHEFAoWQpwmlcJ+dIEwSJkQkhAKFkLcwE5hP7pAGKRMCEkKBQshbmGlsB9dIAxSJoRYgoKFeI98iuVIVNiPLhAGKRNCLEPBQrxFPsZyGBX2owtEYPdxQohFKFiId8jnWA59YT+6QGJh93FCiAUoWIg3KIRYDpW6TBfIdNh9nBCSBAoWkn0KKZaDLhBz2H2cEJIAChaSXQoxloMuEHPYfZwQYgIFC8kehRzLQReIOew+TggxgIKFZAfGctAFkgh2HyeExEHBQrIDYzkEukDMybd7TQhJCwoWkj0YyyHQBUIIIUmhYCHZhbEcAl0ghBCSEAoWkn0YyyHQBUIIIaZQsBBvwFgOQgghCfBlewCETKFEy82bEmBLsUIIIeRfoGAh3qKqCqispHuEEEJIDHQJEe9BsUIIISQOChZCCCGEeB4KFkIIIYR4npQEy969ezFv3jxUVFRg1apVOHnyZML1b9++jc7OTrS2tqK8vBwLFizA0aNH09onIYQQQgoH24LllVdewZYtW7Bjxw6cPn0aS5cuxdq1a9Hb22u4/tjYGB544AFcunQJhw8fxrlz57B//37Mnj075X0SQgghpLAo0jR73eRWrVqFFStWYM+ePQCASCSC9vZ2PPHEE9i6deu09fft24fnn38e77//PkpLSx3ZpxHBYBB+vx+Dg4OoS9ZMjxBCCCGewOr8bcvCMjY2hlOnTqGjoyO6g+JidHR04MSJE4bbHDlyBKtXr0ZnZyeam5uxePFi7Ny5E5OTkynvkxBCCCGFha06LP39/ZicnERzc3PM8ubmZrz//vuG21y8eBE/+clP8Mgjj+Do0aO4cOECvva1r2F8fBw7duxIaZ8AMDo6itHR0anfg8k6/hJCCCEkZ3G9cFwkEkFTUxNeeukllJSUYPny5bh+/Tqef/557NixI+X97tq1C//9v//3acspXAghhJDcQc3bySJUbAmWxsZGlJSUIBAIxCwPBAJoaWkx3Ka1tRWlpaUoKSmZWrZw4UL09PRgbGwspX0CwLZt27Bly5ap369fv45Fixahvb3dzikRQgghxAMMDQ3B7/ebfm9LsJSVlWH58uXo6urCQw89BEAsKF1dXXj88ccNt1mzZg1+8IMfIBKJoLhYQmbOnz+P1tZWlJWVAYDtfQJAeXk5ysvLp36vqanB1atXUVtbi6IcrpQaDAbR3t6Oq1evMnjYY/DeeBPeF2/C++JNvHhfNE3D0NAQ2traEq5n2yW0ZcsWfPGLX8R9992HlStXYvfu3QiFQtiwYQMAYP369Zg9ezZ27doFANi4cSP27NmDTZs24YknnsAHH3yAnTt34utf/7rlfVqhuLgYc+bMsXs6nqWurs4zDxOJhffGm/C+eBPeF2/itfuSyLKisC1Y1q1bh76+Pmzfvh09PT1YtmwZjh07NhU0e+XKlSlLCgC0t7fj+PHj2Lx5M5YsWYLZs2dj06ZNePrppy3vkxBCCCGFje06LMRdWE/Gu/DeeBPeF2/C++JNcvm+sJeQxygvL8eOHTti4nOIN+C98Sa8L96E98Wb5PJ9oYWFEEIIIZ6HFhZCCCGEeB4KFkIIIYR4HgoWQgghhHgeChZCCCGEeB4Klgywd+9ezJs3DxUVFVi1ahVOnjxpuu7999+PoqKiaZ8HH3zQcP0//MM/RFFREXbv3u3S6PMXN+7L2bNn8bu/+7vw+/2orq7GihUrcOXKFbdPJa9w+r7cuXMHjz/+OObMmYPKykosWrQI+/bty8Sp5B127g0A7N69G5/4xCdQWVmJ9vZ2bN68GSMjI2ntk0zH6fuya9curFixArW1tWhqasJDDz2Ec+fOuX0aydGIqxw6dEgrKyvTvvvd72r//M//rH3lK1/R6uvrtUAgYLj+zZs3tRs3bkx9zpw5o5WUlGjf+973pq376quvakuXLtXa2tq0v/iLv3D3RPIMN+7LhQsXtIaGBu2pp57STp8+rV24cEH727/9W9N9kum4cV++8pWvaPPnz9d++tOfah999JH213/911pJSYn2t3/7txk6q/zA7r15+eWXtfLycu3ll1/WPvroI+348eNaa2urtnnz5pT3Sabjxn1Zu3at9r3vfU87c+aM9s4772i//du/rd11113anTt3MnVahlCwuMzKlSu1zs7Oqd8nJye1trY2bdeuXZa2/4u/+AuttrZ22oNy7do1bfbs2dqZM2e0uXPnUrDYxI37sm7dOu3RRx91fKyFhBv35VOf+pT2zW9+M2a9T3/609ozzzzjzKALBLv3prOzU/tX/+pfxSzbsmWLtmbNmpT3Sabjxn2Jp7e3VwOgvfnmm84MOkXoEnKRsbExnDp1Ch0dHVPLiouL0dHRgRMnTljax4EDB/Dwww+jurp6alkkEsFjjz2Gp556Cp/61KccH3e+48Z9iUQieP3117FgwQKsXbsWTU1NWLVqFX70ox+5cQp5iVv/Xz7zmc/gyJEjuH79OjRNw09/+lOcP38ev/mbv+n4OeQrqdybz3zmMzh16tSUe+LixYs4evQofvu3fzvlfZJY3LgvRgwODgIAGhoaHBy9fShYXKS/vx+Tk5PTeiI1Nzejp6cn6fYnT57EmTNn8OUvfzlm+be+9S34fL6YBpLEOm7cl97eXty5cwd/+qd/it/6rd/CG2+8gd/7vd/Dv//3/x5vvvmm4+eQj7j1/+XFF1/EokWLMGfOHJSVleG3fuu3sHfvXnzuc59zdPz5TCr35j//5/+Mb37zm/jsZz+L0tJSzJ8/H/fffz/++I//OOV9kljcuC/xRCIRPPnkk1izZg0WL17s+DnYgYLFwxw4cAD33nsvVq5cObXs1KlT+Mu//Et8//vfR1FRURZHV7gY3ZdIJAIA+Hf/7t9h8+bNWLZsGbZu3Yrf+Z3fYYBnhjC6L4AIlrfffhtHjhzBqVOn8MILL6CzsxN///d/n6WRFgb/8A//gJ07d+Kv/uqvcPr0abz66qt4/fXX8Sd/8ifZHlpBY/e+dHZ24syZMzh06FCGRzod292aiXUaGxtRUlKCQCAQszwQCKClpSXhtqFQCIcOHcI3v/nNmOU///nP0dvbi7vuumtq2eTkJL7xjW9g9+7duHTpkmPjz1fcuC+NjY3w+XxYtGhRzPKFCxfirbfecmbgeY4b9yUcDuOP//iP8dprr01lDi1ZsgTvvPMO/vzP/zzGlE7MSeXePPvss3jsscemLF733nsvQqEQvvrVr+KZZ55J634TwY37UlwctWM8/vjj+Lu/+zv87Gc/w5w5c9w7EYvQwuIiZWVlWL58Obq6uqaWRSIRdHV1YfXq1Qm3/eEPf4jR0VE8+uijMcsfe+wxvPvuu3jnnXemPm1tbXjqqadw/PhxV84j33DjvpSVlWHFihXTUv/Onz+PuXPnOjf4PMaN+zI+Po7x8fGYP8IAUFJSMmUVI8lJ5d4MDw8bXncA0DQtrftNBDfui/r5+OOP47XXXsNPfvIT3H333S6dgU2yGvJbABw6dEgrLy/Xvv/972vvvfee9tWvflWrr6/Xenp6NE3TtMcee0zbunXrtO0++9nPauvWrbN0DGYJ2ceN+/Lqq69qpaWl2ksvvaR98MEH2osvvqiVlJRoP//5z109l3zCjfvy+c9/XvvUpz6l/fSnP9UuXryofe9739MqKiq0v/qrv3L1XPINu/dmx44dWm1trfa//tf/0i5evKi98cYb2vz587Xf//3ft7xPkhw37svGjRs1v9+v/cM//ENM2YDh4eGMn58eCpYM8OKLL2p33XWXVlZWpq1cuVJ7++23p777/Oc/r33xi1+MWf/999/XAGhvvPGGpf1TsKSGG/flwIED2sc+9jGtoqJCW7p0qfajH/3IreHnLU7flxs3bmh/8Ad/oLW1tWkVFRXaJz7xCe2FF17QIpGIm6eRl9i5N+Pj49p/+2//TZs/f75WUVGhtbe3a1/72te0W7duWd4nsYbT9wWA4ceoHlgmKfqXwRFCCCGEeBbGsBBCCCHE81CwEEIIIcTzULAQQgghxPNQsBBCCCHE81CwEEIIIcTzULAQQgghxPNQsBBCCCHE81CwEEIIIcTzULAQQgghxPNQsBBCCCHE81CwEEIIIcTzULAQQgghxPP8f4TEIpAkuzWEAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rhl = RandomLayer(n_hidden=200, alpha=1.0)\n",
+    "elmr = GenELMRegressor(hidden_layer=rhl)\n",
+    "tr, ts = res_dist(mrx, mry, elmr, n_runs=200, random_state=0)\n",
+    "plt.scatter(tr, ts, alpha=0.1, marker='D', c='r')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9749866396617243 0.9573187133337618\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df198582e0>,\n",
+       " <matplotlib.lines.Line2D at 0x1df19858340>]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rhl = RBFRandomLayer(n_hidden=15, rbf_width=0.8)\n",
+    "elmr = GenELMRegressor(hidden_layer=rhl)\n",
+    "elmr.fit(xtoy_train, ytoy_train)\n",
+    "print(elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test))\n",
+    "plt.plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\B294MQ\\Environments\\py39\\_cdk2.pyVenv_\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9702709156488231 0.9452682709298682\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df1993b190>,\n",
+       " <matplotlib.lines.Line2D at 0x1df1993b1f0>]"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "nh = 15\n",
+    "(ctrs, _, _) = k_means(xtoy_train, nh)\n",
+    "unit_rs = np.ones(nh)\n",
+    "\n",
+    "# rhl = RBFRandomLayer(n_hidden=nh, activation_func='inv_multiquadric')\n",
+    "# rhl = RBFRandomLayer(n_hidden=nh, centers=ctrs, radii=unit_rs)\n",
+    "rhl = GRBFRandomLayer(n_hidden=nh, grbf_lambda=.0001, centers=ctrs)\n",
+    "elmr = GenELMRegressor(hidden_layer=rhl)\n",
+    "elmr.fit(xtoy_train, ytoy_train)\n",
+    "print(elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test))\n",
+    "plt.plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9617258176757133 0.9166666666666666\n",
+      "0.9464161447459986 0.9083333333333333\n"
+     ]
+    }
+   ],
+   "source": [
+    "rbf_rhl = RBFRandomLayer(n_hidden=100, random_state=0, rbf_width=0.01)\n",
+    "elmc_rbf = GenELMClassifier(hidden_layer=rbf_rhl)\n",
+    "elmc_rbf.fit(dgx_train, dgy_train)\n",
+    "print(elmc_rbf.score(dgx_train, dgy_train), elmc_rbf.score(dgx_test, dgy_test))\n",
+    "\n",
+    "def powtanh_xfer(activations, power=1.0):\n",
+    "    return pow(np.tanh(activations), power)\n",
+    "\n",
+    "tanh_rhl = MLPRandomLayer(n_hidden=100, activation_func=powtanh_xfer, activation_args={'power':3.0})\n",
+    "elmc_tanh = GenELMClassifier(hidden_layer=tanh_rhl)\n",
+    "elmc_tanh.fit(dgx_train, dgy_train)\n",
+    "print(elmc_tanh.score(dgx_train, dgy_train), elmc_tanh.score(dgx_test, dgy_test))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 6.933 secs\n",
+      "Test Min: 0.914 Mean: 0.927 Max: 0.939 SD: 0.006\n",
+      "Test Min: 0.959 Mean: 0.967 Max: 0.974 SD: 0.003\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "rbf_rhl = RBFRandomLayer(n_hidden=100, rbf_width=0.01)\n",
+    "tr, ts = res_dist(dgx, dgy, GenELMClassifier(hidden_layer=rbf_rhl), n_runs=100, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(ts)\n",
+    "plt.hist(tr)\n",
+    "print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 5.109 secs\n",
+      "Test Min: 0.234 Mean: 0.305 Max: 0.375 SD: 0.029\n",
+      "Test Min: 0.897 Mean: 0.909 Max: 0.924 SD: 0.006\n",
+      "\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# from sklearn.svm import SVR\n",
+    "from sklearn.ensemble import RandomForestRegressor\n",
+    "tr, ts = res_dist(dbx, dby, RandomForestRegressor(n_estimators=15), n_runs=100, random_state=0)\n",
+    "plt.hist(tr)\n",
+    "plt.hist(ts)\n",
+    "print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "10\n",
+      "20\n",
+      "30\n",
+      "40\n",
+      "50\n",
+      "60\n",
+      "70\n",
+      "80\n",
+      "90\n",
+      "\n",
+      "Time: 0.108 secs\n",
+      "Test Min: 0.361 Mean: 0.389 Max: 0.411 SD: 0.011\n",
+      "Test Min: 0.571 Mean: 0.584 Max: 0.596 SD: 0.005\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function print>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAaqUlEQVR4nO3dfWxV9f3A8U8BuahryxD7pFXA501R5wPDp+FgAhqVaZbpjEFjNHPVRIlxsvmEOstPzUa2IG5OYS5TtyWKmzqcVsEYQSOm0+lkltWI03YTQws4i9Lz+2M/789K0d5y77cWX6/kJN5zzj332y8n7dtzb3vKsizLAgAgkSEDPQAA4PNFfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLDBnoAH9fd3R1vvvlmlJeXR1lZ2UAPBwDogyzLYv369VFXVxdDhnzytY3PXHy8+eabUV9fP9DDAAD6Yc2aNbH77rt/4j6fufgoLy+PiP8OvqKiYoBHAwD0RWdnZ9TX1+d/jn+Sz1x8fPhWS0VFhfgAgEGmLx+Z8IFTACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBSwwZ6AADweTbmioe2WPfa3JMGYCTpuPIBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFIFxUdjY2McccQRUV5eHlVVVTFjxoxYtWpVj30mTZoUZWVlPZbvfve7RR00ADB4FRQfy5Yti4aGhlixYkU8+uij8f7778cJJ5wQGzdu7LHf+eefH2+99VZ+uemmm4o6aABg8BpWyM5Llizp8XjRokVRVVUVK1eujOOOOy6/fqeddoqamprijBAA2K5s02c+Ojo6IiJi1KhRPdb/5je/idGjR8eBBx4Ys2fPjnfffXerx+jq6orOzs4eCwCw/SroysdHdXd3xyWXXBJHH310HHjggfn13/nOd2LPPfeMurq6eOGFF+L73/9+rFq1Ku67775ej9PY2Bhz5szp7zAAgEGmLMuyrD9PvPDCC+NPf/pTPPXUU7H77rtvdb/HH388Jk+eHC0tLbHXXnttsb2rqyu6urryjzs7O6O+vj46OjqioqKiP0MDgEFjzBUPbbHutbknDcBItk1nZ2dUVlb26ed3v658XHTRRfHggw/Gk08++YnhERExYcKEiIitxkcul4tcLtefYQAAg1BB8ZFlWVx88cVx//33x9KlS2Ps2LGf+pzm5uaIiKitre3XAAGA7UtB8dHQ0BB33313PPDAA1FeXh5tbW0REVFZWRk77rhjrF69Ou6+++448cQTY5dddokXXnghLr300jjuuONi/PjxJfkCAIDBpaD4WLBgQUT89w+JfdTChQvjnHPOieHDh8djjz0W8+bNi40bN0Z9fX2cfvrpceWVVxZtwADA4Fbw2y6fpL6+PpYtW7ZNAwIAtm/u7QIAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQ1LCBHgAFurayD/t0lH4cANBPrnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AIKmC4qOxsTGOOOKIKC8vj6qqqpgxY0asWrWqxz7vvfdeNDQ0xC677BJf+MIX4vTTT4/29vaiDhoAGLwKio9ly5ZFQ0NDrFixIh599NF4//3344QTToiNGzfm97n00kvjj3/8Y/z+97+PZcuWxZtvvhmnnXZa0QcOAAxOwwrZecmSJT0eL1q0KKqqqmLlypVx3HHHRUdHR9xxxx1x9913x9e//vWIiFi4cGEccMABsWLFivjqV79avJEDAIPSNn3mo6OjIyIiRo0aFRERK1eujPfffz+mTJmS32f//fePPfbYI5YvX74tLwUAbCcKuvLxUd3d3XHJJZfE0UcfHQceeGBERLS1tcXw4cNj5MiRPfatrq6Otra2Xo/T1dUVXV1d+cednZ39HRIAMAj0Oz4aGhrir3/9azz11FPbNIDGxsaYM2fONh0DALYnY654aIt1r809aQBGUhr9etvloosuigcffDCeeOKJ2H333fPra2pqYtOmTbFu3boe+7e3t0dNTU2vx5o9e3Z0dHTklzVr1vRnSADAIFFQfGRZFhdddFHcf//98fjjj8fYsWN7bD/ssMNihx12iKampvy6VatWxeuvvx4TJ07s9Zi5XC4qKip6LADA9qugt10aGhri7rvvjgceeCDKy8vzn+OorKyMHXfcMSorK+O8886LWbNmxahRo6KioiIuvvjimDhxot90AQAiosD4WLBgQURETJo0qcf6hQsXxjnnnBMRET/5yU9iyJAhcfrpp0dXV1dMnTo1br311qIMFgAY/AqKjyzLPnWfESNGxPz582P+/Pn9HhQAsP1ybxcAICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEiq3zeWAwAK09sN4z6PXPkAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQ1bKAHwP+5tnKgRwAASbjyAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACCpguPjySefjJNPPjnq6uqirKwsFi9e3GP7OeecE2VlZT2WadOmFWu8AMAgV3B8bNy4MQ4++OCYP3/+VveZNm1avPXWW/nlnnvu2aZBAgDbj4L/vPr06dNj+vTpn7hPLpeLmpqafg8KANh+leQzH0uXLo2qqqrYb7/94sILL4y1a9dudd+urq7o7OzssQAA26+ix8e0adPirrvuiqampvif//mfWLZsWUyfPj02b97c6/6NjY1RWVmZX+rr64s9JADgM6Tod7U944wz8v990EEHxfjx42OvvfaKpUuXxuTJk7fYf/bs2TFr1qz8487OTgECANuxkv+q7bhx42L06NHR0tLS6/ZcLhcVFRU9FgBg+1Xy+HjjjTdi7dq1UVtbW+qXAgAGgYLfdtmwYUOPqxitra3R3Nwco0aNilGjRsWcOXPi9NNPj5qamli9enVcfvnlsffee8fUqVOLOnAAYHAqOD6ee+65OP744/OPP/y8xsyZM2PBggXxwgsvxK9+9atYt25d1NXVxQknnBDXX3995HK54o0aABi0Co6PSZMmRZZlW93+yCOPbNOAAIDtm3u7AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhq2EAPgBK4trKP+3WUdhwA0AtXPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUm4s93nWlxvQufkcAEXmygcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACQlPgCApAqOjyeffDJOPvnkqKuri7Kysli8eHGP7VmWxdVXXx21tbWx4447xpQpU+LVV18t1ngBgEGu4PjYuHFjHHzwwTF//vxet990003x05/+NG677bZ45plnYuedd46pU6fGe++9t82DBQAGv4L/vPr06dNj+vTpvW7LsizmzZsXV155ZZx66qkREXHXXXdFdXV1LF68OM4444xtGy0AMOgV9TMfra2t0dbWFlOmTMmvq6ysjAkTJsTy5ct7fU5XV1d0dnb2WACA7VdRbyzX1tYWERHV1dU91ldXV+e3fVxjY2PMmTOnmMNIpy83ZotwczYAkhhzxUNbrHtt7kkDMJJPNuC/7TJ79uzo6OjIL2vWrBnoIQEAJVTU+KipqYmIiPb29h7r29vb89s+LpfLRUVFRY8FANh+FTU+xo4dGzU1NdHU1JRf19nZGc8880xMnDixmC8FAAxSBX/mY8OGDdHS0pJ/3NraGs3NzTFq1KjYY4894pJLLokbbrgh9tlnnxg7dmxcddVVUVdXFzNmzCjmuAGAQarg+Hjuuefi+OOPzz+eNWtWRETMnDkzFi1aFJdffnls3LgxLrjggli3bl0cc8wxsWTJkhgxYkTxRg0ADFoFx8ekSZMiy7Ktbi8rK4vrrrsurrvuum0aGACwfRrw33YBAD5fxAcAkJT4AACSEh8AQFLiAwBISnwAAEkV9cZybIfcPA+AInPlAwBISnwAAEmJDwAgKfEBACQlPgCApMQHAJCU+AAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAk5cZyFIcb0AHQR658AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICk3FgOAEpgzBUPDfQQPrNc+QAAkhIfAEBS4gMASEp8AABJiQ8AICnxAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASbmxXArXVg70CAAY5LanG9W58gEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgqaLHx7XXXhtlZWU9lv3337/YLwMADFIl+QunX/7yl+Oxxx77/xcZ5g+pAgD/VZIqGDZsWNTU1JTi0ADAIFeSz3y8+uqrUVdXF+PGjYuzzjorXn/99a3u29XVFZ2dnT0WAGD7VfT4mDBhQixatCiWLFkSCxYsiNbW1jj22GNj/fr1ve7f2NgYlZWV+aW+vr7YQwIAPkOKHh/Tp0+Pb33rWzF+/PiYOnVqPPzww7Fu3br43e9+1+v+s2fPjo6OjvyyZs2aYg8JAPgMKfknQUeOHBn77rtvtLS09Lo9l8tFLpcr9TAAgM+Ikv+djw0bNsTq1aujtra21C8FAAwCRY+Pyy67LJYtWxavvfZaPP300/HNb34zhg4dGmeeeWaxXwoAGISK/rbLG2+8EWeeeWasXbs2dt111zjmmGNixYoVseuuuxb7pQCAQajo8XHvvfcW+5AAwHbEvV0AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASZX8z6sDAANnzBUPbbHutbknDcBI/p8rHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKTeW6821lQM9AgDYbrnyAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACS+vzdWM5N4wBgQLnyAQAkJT4AgKTEBwCQlPgAAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACS+vzdWA4AttGYKx7q8fi1uScN0EgGJ1c+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEmJDwAgKfEBACRVsviYP39+jBkzJkaMGBETJkyIZ599tlQvBQAMIiWJj9/+9rcxa9asuOaaa+L555+Pgw8+OKZOnRr/+te/SvFyAMAgUpL4+PGPfxznn39+nHvuufGlL30pbrvttthpp53izjvvLMXLAQCDSNHv7bJp06ZYuXJlzJ49O79uyJAhMWXKlFi+fPkW+3d1dUVXV1f+cUdHR0REdHZ2Fnto//eCWWmOS9+U6t8VIKHurnd7PO7tZ9bH9/ksKcXP2A+PmWWf/nO26PHx9ttvx+bNm6O6urrH+urq6njllVe22L+xsTHmzJmzxfr6+vpiD43PgrmVAz0CgKKrnDfQIyhMKce7fv36qKz85O/1A35X29mzZ8esWbPyj7u7u+Odd96JXXbZJdavXx/19fWxZs2aqKioGMBRfv50dnaa+wFk/geOuR9Y5n9gbcv8Z1kW69evj7q6uk/dt+jxMXr06Bg6dGi0t7f3WN/e3h41NTVb7J/L5SKXy/VYN3LkyIiIKCsri4iIiooKJ+EAMfcDy/wPHHM/sMz/wOrv/H/aFY8PFf0Dp8OHD4/DDjssmpqa8uu6u7ujqakpJk6cWOyXAwAGmZK87TJr1qyYOXNmHH744XHkkUfGvHnzYuPGjXHuueeW4uUAgEGkJPHx7W9/O/7973/H1VdfHW1tbXHIIYfEkiVLtvgQ6qfJ5XJxzTXXbPG2DKVn7geW+R845n5gmf+BlWr+y7K+/E4MAECRuLcLAJCU+AAAkhIfAEBS4gMASCppfMyfPz/GjBkTI0aMiAkTJsSzzz671X3vu+++OPzww2PkyJGx8847xyGHHBK//vWve+xzzjnnRFlZWY9l2rRppf4yBq1C5v+j7r333igrK4sZM2b0WJ9lWVx99dVRW1sbO+64Y0yZMiVeffXVEox88Cv23Dv3C1PI/C9atGiLuR0xYkSPfZz7hSn2/Dv/+67Q7z3r1q2LhoaGqK2tjVwuF/vuu288/PDD23TMXmWJ3Hvvvdnw4cOzO++8M3vppZey888/Pxs5cmTW3t7e6/5PPPFEdt9992Uvv/xy1tLSks2bNy8bOnRotmTJkvw+M2fOzKZNm5a99dZb+eWdd95J9SUNKoXO/4daW1uz3XbbLTv22GOzU089tce2uXPnZpWVldnixYuzv/zlL9kpp5ySjR07NvvPf/5Twq9k8CnF3Dv3+67Q+V+4cGFWUVHRY27b2tp67OPc77tSzL/zv28Knfuurq7s8MMPz0488cTsqaeeylpbW7OlS5dmzc3N/T7m1iSLjyOPPDJraGjIP968eXNWV1eXNTY29vkYhx56aHbllVfmH8+cOXOLb8r0rj/z/8EHH2RHHXVU9stf/nKLue7u7s5qamqym2++Ob9u3bp1WS6Xy+65556SfA2DVbHnPsuc+4UodP4XLlyYVVZWbvV4zv3CFHv+s8z531eFzv2CBQuycePGZZs2bSraMbcmydsumzZtipUrV8aUKVPy64YMGRJTpkyJ5cuXf+rzsyyLpqamWLVqVRx33HE9ti1dujSqqqpiv/32iwsvvDDWrl1b9PEPdv2d/+uuuy6qqqrivPPO22Jba2trtLW19ThmZWVlTJgwoU//pp8XpZj7Dzn3P11/53/Dhg2x5557Rn19fZx66qnx0ksv5bc59/uuFPP/Ief/J+vP3P/hD3+IiRMnRkNDQ1RXV8eBBx4YN954Y2zevLnfx9yaJHe1ffvtt2Pz5s1b/IXT6urqeOWVV7b6vI6Ojthtt92iq6srhg4dGrfeemt84xvfyG+fNm1anHbaaTF27NhYvXp1/OAHP4jp06fH8uXLY+jQoSX7egab/sz/U089FXfccUc0Nzf3ur2trS1/jI8f88NtlGbuI5z7fdWf+d9vv/3izjvvjPHjx0dHR0fccsstcdRRR8VLL70Uu+++u3O/AKWY/wjnf1/0Z+7/8Y9/xOOPPx5nnXVWPPzww9HS0hLf+9734v33349rrrmm3z/Le5MkPvqrvLw8mpubY8OGDdHU1BSzZs2KcePGxaRJkyIi4owzzsjve9BBB8X48eNjr732iqVLl8bkyZMHaNSD3/r16+Pss8+O22+/PUaPHj3Qw/lc6evcO/dLZ+LEiT1ugnnUUUfFAQccED//+c/j+uuvH8CRfT70Zf6d/6XR3d0dVVVV8Ytf/CKGDh0ahx12WPzzn/+Mm2++Oa655pqivlaS+Bg9enQMHTo02tvbe6xvb2+PmpqarT5vyJAhsffee0dExCGHHBJ/+9vforGxMR8fHzdu3LgYPXp0tLS0OAE/otD5X716dbz22mtx8skn59d1d3dHRMSwYcNi1apV+ee1t7dHbW1tj2MecsghJfgqBqdSzP1ee+21xfOc+73r7/eej9phhx3i0EMPjZaWlogI534BSjH/vXH+b6k/c19bWxs77LBDj6tHBxxwQLS1tcWmTZuK8u/5oSSf+Rg+fHgcdthh0dTUlF/X3d0dTU1NPQr303R3d0dXV9dWt7/xxhuxdu3aHt8QKHz+999//3jxxRejubk5v5xyyilx/PHHR3Nzc9TX18fYsWOjpqamxzE7OzvjmWeeKejfdHtXirnvjXO/d8X43rN58+Z48cUX83Pr3O+7Usx/b5z/W+rP3B999NHR0tKS/x+eiIi///3vUVtbG8OHDy/az/KISPurtrlcLlu0aFH28ssvZxdccEE2cuTI/K9QnX322dkVV1yR3//GG2/M/vznP2erV6/OXn755eyWW27Jhg0blt1+++1ZlmXZ+vXrs8suuyxbvnx51tramj322GPZV77ylWyfffbJ3nvvvVRf1qBR6Px/XG+fLp87d242cuTI7IEHHsheeOGF7NRTT/Xrhr0o9tw79wtT6PzPmTMne+SRR7LVq1dnK1euzM4444xsxIgR2UsvvZTfx7nfd8Wef+d/3xU696+//npWXl6eXXTRRdmqVauyBx98MKuqqspuuOGGPh+zr5LFR5Zl2c9+9rNsjz32yIYPH54deeSR2YoVK/Lbvva1r2UzZ87MP/7hD3+Y7b333tmIESOyL37xi9nEiROze++9N7/93XffzU444YRs1113zXbYYYdszz33zM4///yCJ+DzpJD5/7je4qO7uzu76qqrsurq6iyXy2WTJ0/OVq1aVaLRD27FnHvnfuEKmf9LLrkkv291dXV24oknZs8//3yP4zn3C1PM+Xf+F6bQ7z1PP/10NmHChCyXy2Xjxo3LfvSjH2UffPBBn4/ZV2VZlmWFXSsBAOg/93YBAJISHwBAUuIDAEhKfAAASYkPACAp8QEAJCU+AICkxAcAkJT4AACSEh8AQFLiAwBISnwAAEn9L7SA4vTQmSZsAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rhl = RBFRandomLayer(n_hidden=15, rbf_width=0.1)\n",
+    "tr,ts = res_dist(dbx, dby, GenELMRegressor(rhl), n_runs=100, random_state=0)\n",
+    "plt.hist(tr)\n",
+    "plt.hist(ts)\n",
+    "print"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.10716771050800278 0.08333333333333333\n"
+     ]
+    }
+   ],
+   "source": [
+    "elmc = ELMClassifier(n_hidden=1000, activation_func='gaussian', alpha=0.0, random_state=0)\n",
+    "elmc.fit(dgx_train, dgy_train)\n",
+    "print(elmc.score(dgx_train, dgy_train), elmc.score(dgx_test, dgy_test))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9993041057759221 0.9277777777777778\n"
+     ]
+    }
+   ],
+   "source": [
+    "elmc = ELMClassifier(n_hidden=500, activation_func='hardlim', alpha=1.0, random_state=0)\n",
+    "elmc.fit(dgx_train, dgy_train)\n",
+    "print(elmc.score(dgx_train, dgy_train), elmc.score(dgx_test, dgy_test))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.8585594314871885 0.814394001947798\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df199e7940>,\n",
+       " <matplotlib.lines.Line2D at 0x1df199e77f0>]"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "elmr = ELMRegressor(random_state=0)\n",
+    "elmr.fit(xtoy_train, ytoy_train)\n",
+    "print(elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test))\n",
+    "plt.plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9274175754289422 0.9062543431581013\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x1df199c6550>,\n",
+       " <matplotlib.lines.Line2D at 0x1df199c6520>]"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "elmr = ELMRegressor(activation_func='inv_tribas', random_state=0)\n",
+    "elmr.fit(xtoy_train, ytoy_train)\n",
+    "print(elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test))\n",
+    "plt.plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "_cdk2.pyVenv_",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/elm_notebook.py b/elm_notebook.py
deleted file mode 100644
index ff05acf..0000000
--- a/elm_notebook.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# -*- coding: utf-8 -*-
-# <nbformat>2</nbformat>
-
-# <codecell>
-
-# Demo python notebook for sklearn elm and random_hidden_layer modules
-#
-# Author: David C. Lambert [dcl -at- panix -dot- com]
-# Copyright(c) 2013
-# License: Simple BSD
-
-# <codecell>
-
-from time import time
-from sklearn.cluster import k_means
-
-from elm import ELMClassifier, ELMRegressor, GenELMClassifier, GenELMRegressor
-from random_layer import RandomLayer, MLPRandomLayer, RBFRandomLayer, GRBFRandomLayer
-
-# <codecell>
-
-def make_toy():
-    x = np.arange(0.25,20,0.1)
-    y = x*np.cos(x)+0.5*sqrt(x)*np.random.randn(x.shape[0])
-    x = x.reshape(-1,1)
-    y = y.reshape(-1,1)
-    return x, y
-
-# <codecell>
-
-def res_dist(x, y, e, n_runs=100, random_state=None):
-    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=random_state)
-
-    test_res = []
-    train_res = []
-    start_time = time()
-
-    for i in xrange(n_runs):
-        e.fit(x_train, y_train)
-        train_res.append(e.score(x_train, y_train))
-        test_res.append(e.score(x_test, y_test))
-        if (i%(n_runs/10) == 0): print "%d"%i,
-
-    print "\nTime: %.3f secs" % (time() - start_time)
-
-    print "Test Min: %.3f Mean: %.3f Max: %.3f SD: %.3f" % (min(test_res), mean(test_res), max(test_res), std(test_res))
-    print "Train Min: %.3f Mean: %.3f Max: %.3f SD: %.3f" % (min(train_res), mean(train_res), max(train_res), std(train_res))
-    print
-    return (train_res, test_res)
-
-# <codecell>
-
-from sklearn.cross_validation import train_test_split
-from sklearn.preprocessing import StandardScaler
-from sklearn.datasets import load_iris, load_digits, load_diabetes, make_regression
-
-stdsc = StandardScaler()
-
-iris = load_iris()
-irx, iry = stdsc.fit_transform(iris.data), iris.target
-irx_train, irx_test, iry_train, iry_test = train_test_split(irx, iry, test_size=0.2)
-
-digits = load_digits()
-dgx, dgy = stdsc.fit_transform(digits.data/16.0), digits.target
-dgx_train, dgx_test, dgy_train, dgy_test = train_test_split(dgx, dgy, test_size=0.2)
-
-diabetes = load_diabetes()
-dbx, dby = stdsc.fit_transform(diabetes.data), diabetes.target
-dbx_train, dbx_test, dby_train, dby_test = train_test_split(dbx, dby, test_size=0.2)
-
-mrx, mry = make_regression(n_samples=2000, n_targets=4)
-mrx_train, mrx_test, mry_train, mry_test = train_test_split(mrx, mry, test_size=0.2)
-
-xtoy, ytoy = make_toy()
-xtoy, ytoy = stdsc.fit_transform(xtoy), stdsc.fit_transform(ytoy)
-xtoy_train, xtoy_test, ytoy_train, ytoy_test = train_test_split(xtoy, ytoy, test_size=0.2)
-plot(xtoy, ytoy)
-
-# <codecell>
-
-# RBFRandomLayer tests
-for af in RandomLayer.activation_func_names():
-    print af,
-    elmc = ELMClassifier(activation_func=af)
-    tr,ts = res_dist(irx, iry, elmc, n_runs=200, random_state=0)
-
-# <codecell>
-
-elmc.classes_
-
-# <codecell>
-
-for af in RandomLayer.activation_func_names():
-    print af
-    elmc = ELMClassifier(activation_func=af, random_state=0)
-    tr,ts = res_dist(dgx, dgy, elmc, n_runs=100, random_state=0)
-
-# <codecell>
-
-elmc = ELMClassifier(n_hidden=500, activation_func='multiquadric')
-tr,ts = res_dist(dgx, dgy, elmc, n_runs=100, random_state=0)
-scatter(tr, ts, alpha=0.1, marker='D', c='r')
-
-# <codecell>
-
-elmr = ELMRegressor(random_state=0, activation_func='gaussian', alpha=0.0)
-elmr.fit(xtoy_train, ytoy_train)
-print elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test)
-plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
-
-# <codecell>
-
-from sklearn import pipeline
-from sklearn.linear_model import LinearRegression
-elmr = pipeline.Pipeline([('rhl', RandomLayer(random_state=0, activation_func='multiquadric')),
-                          ('lr', LinearRegression(fit_intercept=False))])
-elmr.fit(xtoy_train, ytoy_train)
-print elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test)
-plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
-
-# <codecell>
-
-rhl = RandomLayer(n_hidden=200, alpha=1.0)
-elmr = GenELMRegressor(hidden_layer=rhl)
-tr, ts = res_dist(mrx, mry, elmr, n_runs=200, random_state=0)
-scatter(tr, ts, alpha=0.1, marker='D', c='r')
-
-# <codecell>
-
-rhl = RBFRandomLayer(n_hidden=15, rbf_width=0.8)
-elmr = GenELMRegressor(hidden_layer=rhl)
-elmr.fit(xtoy_train, ytoy_train)
-print elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test)
-plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
-
-# <codecell>
-
-nh = 15
-(ctrs, _, _) = k_means(xtoy_train, nh)
-unit_rs = np.ones(nh)
-
-#rhl = RBFRandomLayer(n_hidden=nh, activation_func='inv_multiquadric')
-#rhl = RBFRandomLayer(n_hidden=nh, centers=ctrs, radii=unit_rs)
-rhl = GRBFRandomLayer(n_hidden=nh, grbf_lambda=.0001, centers=ctrs)
-elmr = GenELMRegressor(hidden_layer=rhl)
-elmr.fit(xtoy_train, ytoy_train)
-print elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test)
-plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
-
-# <codecell>
-
-rbf_rhl = RBFRandomLayer(n_hidden=100, random_state=0, rbf_width=0.01)
-elmc_rbf = GenELMClassifier(hidden_layer=rbf_rhl)
-elmc_rbf.fit(dgx_train, dgy_train)
-print elmc_rbf.score(dgx_train, dgy_train), elmc_rbf.score(dgx_test, dgy_test)
-
-def powtanh_xfer(activations, power=1.0):
-    return pow(np.tanh(activations), power)
-
-tanh_rhl = MLPRandomLayer(n_hidden=100, activation_func=powtanh_xfer, activation_args={'power':3.0})
-elmc_tanh = GenELMClassifier(hidden_layer=tanh_rhl)
-elmc_tanh.fit(dgx_train, dgy_train)
-print elmc_tanh.score(dgx_train, dgy_train), elmc_tanh.score(dgx_test, dgy_test)
-
-# <codecell>
-
-rbf_rhl = RBFRandomLayer(n_hidden=100, rbf_width=0.01)
-tr, ts = res_dist(dgx, dgy, GenELMClassifier(hidden_layer=rbf_rhl), n_runs=100, random_state=0)
-
-# <codecell>
-
-hist(ts), hist(tr)
-print
-
-# <codecell>
-
-from sklearn.svm import SVR
-from sklearn.ensemble import RandomForestRegressor
-tr, ts = res_dist(dbx, dby, RandomForestRegressor(n_estimators=15), n_runs=100, random_state=0)
-hist(tr), hist(ts)
-print
-
-rhl = RBFRandomLayer(n_hidden=15, rbf_width=0.1)
-tr,ts = res_dist(dbx, dby, GenELMRegressor(rhl), n_runs=100, random_state=0)
-hist(tr), hist(ts)
-print
-
-# <codecell>
-
-elmc = ELMClassifier(n_hidden=1000, activation_func='gaussian', alpha=0.0, random_state=0)
-elmc.fit(dgx_train, dgy_train)
-print elmc.score(dgx_train, dgy_train), elmc.score(dgx_test, dgy_test)
-
-# <codecell>
-
-elmc = ELMClassifier(n_hidden=500, activation_func='hardlim', alpha=1.0, random_state=0)
-elmc.fit(dgx_train, dgy_train)
-print elmc.score(dgx_train, dgy_train), elmc.score(dgx_test, dgy_test)
-
-# <codecell>
-
-elmr = ELMRegressor(random_state=0)
-elmr.fit(xtoy_train, ytoy_train)
-print elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test)
-plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
-
-# <codecell>
-
-elmr = ELMRegressor(activation_func='inv_tribas', random_state=0)
-elmr.fit(xtoy_train, ytoy_train)
-print elmr.score(xtoy_train, ytoy_train), elmr.score(xtoy_test, ytoy_test)
-plot(xtoy, ytoy, xtoy, elmr.predict(xtoy))
-
diff --git a/plot_elm_comparison.py b/plot_elm_comparison.py
index e8762d5..8f66777 100644
--- a/plot_elm_comparison.py
+++ b/plot_elm_comparison.py
@@ -30,32 +30,31 @@
 __________
 .. [1] http://www.extreme-learning-machines.org
 .. [2] G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, "Extreme Learning Machine:
-          Theory and Applications", Neurocomputing, vol. 70, pp. 489-501,
-          2006.
+    Theory and Applications", Neurocomputing, vol. 70, pp. 489-501, 2006.
 
 ===============================================================================
 Basis Functions:
-  gaussian rbf  : exp(-gamma * (||x-c||/r)^2)
-  tanh          : np.tanh(a)
-  sinsq         : np.power(np.sin(a), 2.0)
-  tribas        : np.clip(1.0 - np.fabs(a), 0.0, 1.0)
-  hardlim       : np.array(a > 0.0, dtype=float)
+    gaussian rbf  : exp(-gamma * (||x-c|| / r)^2)
+    tanh          : np.tanh(a)
+    sinsq         : np.power(np.sin(a), 2.0)
+    tribas        : np.clip(1.0 - np.fabs(a), 0.0, 1.0)
+    hardlim       : np.array(a > 0.0, dtype=float)
 
-     where x   : input pattern
-           a   : dot_product(x, c) + b
-           c,r : randomly generated components
+    where
+        x   : input pattern
+        a   : dot_product(x, c) + b
+        c, r : randomly generated components
 
 Label Legend:
-  ELM(10,tanh)      :10 tanh units
-  ELM(10,tanh,LR)   :10 tanh units, LogisticRegression
-  ELM(10,sinsq)     :10 sin*sin units
-  ELM(10,tribas)    :10 tribas units
-  ELM(10,hardlim)   :10 hardlim units
-  ELM(20,rbf(0.1))  :20 rbf units gamma=0.1
+    ELM(10, tanh)      :10 tanh units
+    ELM(10, tanh, LR)  :10 tanh units, LogisticRegression
+    ELM(10, sinsq)     :10 sin*sin units
+    ELM(10, tribas)    :10 tribas units
+    ELM(10, hardlim)   :10 hardlim units
+    ELM(20, rbf(0.1))  :20 rbf units gamma=0.1
 
 """
-print __doc__
-
+# print(__doc__)
 
 # Code source: Gael Varoqueux
 #              Andreas Mueller
@@ -69,9 +68,11 @@
 from matplotlib.colors import ListedColormap
 from sklearn.datasets import make_moons, make_circles, make_classification
 from sklearn.preprocessing import StandardScaler
-from sklearn.cross_validation import train_test_split
+from sklearn.model_selection import train_test_split
 from sklearn.linear_model import LogisticRegression
 
+from sklearn.calibration import CalibratedClassifierCV
+
 from elm import GenELMClassifier
 from random_layer import RBFRandomLayer, MLPRandomLayer
 
@@ -82,8 +83,10 @@ def get_data_bounds(X):
     x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
     y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
 
-    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
-                         np.arange(y_min, y_max, h))
+    xx, yy = np.meshgrid(
+        np.arange(x_min, x_max, h),
+        np.arange(y_min, y_max, h)
+    )
 
     return (x_min, x_max, y_min, y_max, xx, yy)
 
@@ -117,20 +120,26 @@ def plot_contour(ax, X_train, y_train, X_test, y_test, xx, yy, Z):
     ax.set_yticks(())
 
     ax.set_title(name)
-    ax.text(xx.max() - 0.3, yy.min() + 0.3, ('%.2f' % score).lstrip('0'),
-            size=13, horizontalalignment='right')
+    ax.text(
+        xx.max() - 0.3, yy.min() + 0.3, ('%.2f' % score).lstrip('0'),
+        size=13, horizontalalignment='right'
+    )
 
 
 def make_datasets():
-    return [make_moons(n_samples=200, noise=0.3, random_state=0),
-            make_circles(n_samples=200, noise=0.2, factor=0.5, random_state=1),
-            make_linearly_separable()]
+    return [
+        make_moons(n_samples=200, noise=0.3, random_state=0),
+        make_circles(n_samples=200, noise=0.2, factor=0.5, random_state=1),
+        make_linearly_separable()
+    ]
 
 
-def make_classifiers():
+def make_classifiers(calibrated: bool):
 
-    names = ["ELM(10,tanh)", "ELM(10,tanh,LR)", "ELM(10,sinsq)",
-             "ELM(10,tribas)", "ELM(hardlim)", "ELM(20,rbf(0.1))"]
+    names = [
+        "ELM(10, tanh)", "ELM(10, tanh, LR)", "ELM(10, sinsq)",
+        "ELM(10, tribas)", "ELM(hardlim)", "ELM(20, rbf(0.1))"
+    ]
 
     nh = 10
 
@@ -150,28 +159,38 @@ def make_classifiers():
 
     log_reg = LogisticRegression()
 
-    classifiers = [GenELMClassifier(hidden_layer=srhl_tanh),
-                   GenELMClassifier(hidden_layer=srhl_tanh, regressor=log_reg),
-                   GenELMClassifier(hidden_layer=srhl_sinsq),
-                   GenELMClassifier(hidden_layer=srhl_tribas),
-                   GenELMClassifier(hidden_layer=srhl_hardlim),
-                   GenELMClassifier(hidden_layer=srhl_rbf)]
+    classifiers = [
+        GenELMClassifier(hidden_layer=srhl_tanh),
+        GenELMClassifier(hidden_layer=srhl_tanh, regressor=log_reg),
+        GenELMClassifier(hidden_layer=srhl_sinsq),
+        GenELMClassifier(hidden_layer=srhl_tribas),
+        GenELMClassifier(hidden_layer=srhl_hardlim),
+        GenELMClassifier(hidden_layer=srhl_rbf)
+    ]
+    if calibrated:
+        classifiers = list(
+            map(lambda clf: CalibratedClassifierCV(clf), classifiers)
+        )
 
     return names, classifiers
 
 
 def make_linearly_separable():
-    X, y = make_classification(n_samples=200, n_features=2, n_redundant=0,
-                               n_informative=2, random_state=1,
-                               n_clusters_per_class=1)
+    X, y = make_classification(
+        n_samples=200, n_features=2, n_redundant=0,
+        n_informative=2, random_state=1,
+        n_clusters_per_class=1
+    )
     rng = np.random.RandomState(2)
     X += 2 * rng.uniform(size=X.shape)
     return (X, y)
 
+
 ###############################################################################
 
+calibrated = True
 datasets = make_datasets()
-names, classifiers = make_classifiers()
+names, classifiers = make_classifiers(calibrated)
 
 i = 1
 figure = pl.figure(figsize=(18, 9))
@@ -181,8 +200,9 @@ def make_linearly_separable():
     # preprocess dataset, split into training and test part
     X, y = ds
     X = StandardScaler().fit_transform(X)
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4,
-                                                        random_state=0)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=.4, random_state=0
+    )
 
     x_min, x_max, y_min, y_max, xx, yy = get_data_bounds(X)
 
@@ -200,7 +220,10 @@ def make_linearly_separable():
 
         # Plot the decision boundary. For that, we will asign a color to each
         # point in the mesh [x_min, m_max]x[y_min, y_max].
-        Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
+        if calibrated:
+            Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, [1]]
+        else:
+            Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
 
         # Put the result into a color plot
         Z = Z.reshape(xx.shape)
diff --git a/random_layer.py b/random_layer.py
index 713a795..5c4b106 100644
--- a/random_layer.py
+++ b/random_layer.py
@@ -1,4 +1,4 @@
-#-*- coding: utf8
+# -*- coding: utf8
 # Author: David C. Lambert [dcl -at- panix -dot- com]
 # Copyright(c) 2013
 # License: Simple BSD
@@ -24,15 +24,16 @@
 from scipy.spatial.distance import cdist, pdist, squareform
 
 from sklearn.metrics import pairwise_distances
-from sklearn.utils import check_random_state, atleast2d_or_csr
+from sklearn.utils import check_random_state, check_array
 from sklearn.utils.extmath import safe_sparse_dot
 from sklearn.base import BaseEstimator, TransformerMixin
 
-__all__ = ['RandomLayer',
-           'MLPRandomLayer',
-           'RBFRandomLayer',
-           'GRBFRandomLayer',
-           ]
+__all__ = [
+    'RandomLayer',
+    'MLPRandomLayer',
+    'RBFRandomLayer',
+    'GRBFRandomLayer',
+]
 
 
 class BaseRandomLayer(BaseEstimator, TransformerMixin):
@@ -48,8 +49,10 @@ def activation_func_names(cls):
 
     # take n_hidden and random_state, init components_ and
     # input_activations_
-    def __init__(self, n_hidden=20, random_state=0, activation_func=None,
-                 activation_args=None):
+    def __init__(
+        self, n_hidden=20, random_state=0, activation_func=None,
+        activation_args=None
+    ):
 
         self.n_hidden = n_hidden
         self.random_state = random_state
@@ -108,7 +111,7 @@ def fit(self, X, y=None):
         -------
         self
         """
-        X = atleast2d_or_csr(X)
+        X = check_array(X)
 
         self._generate_components(X)
 
@@ -130,7 +133,7 @@ def transform(self, X, y=None):
         -------
         X_new : numpy array of shape [n_samples, n_components]
         """
-        X = atleast2d_or_csr(X)
+        X = check_array(X)
 
         if (self.components_ is None):
             raise ValueError('No components initialized')
@@ -147,18 +150,18 @@ class RandomLayer(BaseRandomLayer):
     that are a weighted combination of dot product (multilayer perceptron)
     and distance (rbf) activations:
 
-      input_activation = alpha * mlp_activation + (1-alpha) * rbf_activation
+    input_activation = alpha * mlp_activation + (1-alpha) * rbf_activation
 
-      mlp_activation(x) = dot(x, weights) + bias
-      rbf_activation(x) = rbf_width * ||x - center||/radius
+    mlp_activation(x) = dot(x, weights) + bias
+    rbf_activation(x) = rbf_width * ||x - center||/radius
 
-      alpha and rbf_width are specified by the user
+    alpha and rbf_width are specified by the user
 
-      weights and biases are taken from normal distribution of
-      mean 0 and sd of 1
+    weights and biases are taken from normal distribution of
+    mean 0 and sd of 1
 
-      centers are taken uniformly from the bounding hyperrectangle
-      of the inputs, and radii are max(||x-c||)/sqrt(n_centers*2)
+    centers are taken uniformly from the bounding hyperrectangle
+    of the inputs, and radii are max(||x-c||)/sqrt(n_centers*2)
 
     The input activation is transformed by a transfer function that defaults
     to numpy.tanh if not specified, but can be any callable that returns an
@@ -182,10 +185,10 @@ class RandomLayer(BaseRandomLayer):
     `user_components`: dictionary, optional (default=None)
         dictionary containing values for components that woud otherwise be
         randomly generated.  Valid key/value pairs are as follows:
-           'radii'  : array-like of shape [n_hidden]
-           'centers': array-like of shape [n_hidden, n_features]
-           'biases' : array-like of shape [n_hidden]
-           'weights': array-like of shape [n_features, n_hidden]
+            'radii'  : array-like of shape [n_hidden]
+            'centers': array-like of shape [n_hidden, n_features]
+            'biases' : array-like of shape [n_hidden]
+            'weights': array-like of shape [n_features, n_hidden]
 
     `activation_func` : {callable, string} optional (default='tanh')
         Function used to transform input activation
@@ -234,34 +237,43 @@ class RandomLayer(BaseRandomLayer):
     _gaussian = (lambda x: np.exp(-pow(x, 2.0)))
 
     # multiquadric RBF
-    _multiquadric = (lambda x:
-                     np.sqrt(1.0 + pow(x, 2.0)))
+    _multiquadric = (
+        lambda x:
+        np.sqrt(1.0 + pow(x, 2.0))
+    )
 
     # inverse multiquadric RBF
-    _inv_multiquadric = (lambda x:
-                         1.0/(np.sqrt(1.0 + pow(x, 2.0))))
+    _inv_multiquadric = (
+        lambda x:
+        1.0 / (np.sqrt(1.0 + pow(x, 2.0)))
+    )
 
     # internal activation function table
-    _internal_activation_funcs = {'sine': np.sin,
-                                  'tanh': np.tanh,
-                                  'tribas': _tribas,
-                                  'inv_tribas': _inv_tribas,
-                                  'sigmoid': _sigmoid,
-                                  'softlim': _softlim,
-                                  'hardlim': _hardlim,
-                                  'gaussian': _gaussian,
-                                  'multiquadric': _multiquadric,
-                                  'inv_multiquadric': _inv_multiquadric,
-                                  }
-
-    def __init__(self, n_hidden=20, alpha=0.5, random_state=None,
-                 activation_func='tanh', activation_args=None,
-                 user_components=None, rbf_width=1.0):
-
-        super(RandomLayer, self).__init__(n_hidden=n_hidden,
-                                          random_state=random_state,
-                                          activation_func=activation_func,
-                                          activation_args=activation_args)
+    _internal_activation_funcs = {
+        'sine': np.sin,
+        'tanh': np.tanh,
+        'tribas': _tribas,
+        'inv_tribas': _inv_tribas,
+        'sigmoid': _sigmoid,
+        'softlim': _softlim,
+        'hardlim': _hardlim,
+        'gaussian': _gaussian,
+        'multiquadric': _multiquadric,
+        'inv_multiquadric': _inv_multiquadric,
+    }
+
+    def __init__(
+        self, n_hidden=20, alpha=0.5, random_state=None,
+        activation_func='tanh', activation_args=None,
+        user_components=None, rbf_width=1.0
+    ):
+
+        super(RandomLayer, self).__init__(
+            n_hidden=n_hidden,
+            random_state=random_state,
+            activation_func=activation_func,
+            activation_args=activation_args
+        )
 
         if (isinstance(self.activation_func, str)):
             func_names = self._internal_activation_funcs.keys()
@@ -311,15 +323,15 @@ def _compute_centers(self, X, sparse, rs):
             n_features = X.shape[1]
 
             if (sparse):
-                fxr = xrange(n_features)
+                fxr = np.arange(n_features)
                 cols = [X.getcol(i) for i in fxr]
 
                 min_dtype = X.dtype.type(1.0e10)
-                sp_min = lambda col: np.minimum(min_dtype, np.min(col.data))
+                sp_min = (lambda col: np.minimum(min_dtype, np.min(col.data)))
                 min_Xs = np.array(map(sp_min, cols))
 
                 max_dtype = X.dtype.type(-1.0e10)
-                sp_max = lambda col: np.maximum(max_dtype, np.max(col.data))
+                sp_max = (lambda col: np.maximum(max_dtype, np.max(col.data)))
                 max_Xs = np.array(map(sp_max, cols))
             else:
                 min_Xs = X.min(axis=0)
@@ -391,35 +403,59 @@ class MLPRandomLayer(RandomLayer):
     """Wrapper for RandomLayer with alpha (mixing coefficient) set
        to 1.0 for MLP activations only"""
 
-    def __init__(self, n_hidden=20, random_state=None,
-                 activation_func='tanh', activation_args=None,
-                 weights=None, biases=None):
+    def __init__(
+        self, n_hidden=20, random_state=None,
+        activation_func='tanh', activation_args=None,
+        weights=None, biases=None
+    ):
 
         user_components = {'weights': weights, 'biases': biases}
-        super(MLPRandomLayer, self).__init__(n_hidden=n_hidden,
-                                             random_state=random_state,
-                                             activation_func=activation_func,
-                                             activation_args=activation_args,
-                                             user_components=user_components,
-                                             alpha=1.0)
+        super(MLPRandomLayer, self).__init__(
+            n_hidden=n_hidden,
+            random_state=random_state,
+            activation_func=activation_func,
+            activation_args=activation_args,
+            user_components=user_components,
+            alpha=1.0
+        )
+
+    @property
+    def weights(self):
+        return self.user_components["weights"]
+
+    @property
+    def biases(self):
+        return self.user_components["biases"]
 
 
 class RBFRandomLayer(RandomLayer):
     """Wrapper for RandomLayer with alpha (mixing coefficient) set
        to 0.0 for RBF activations only"""
 
-    def __init__(self, n_hidden=20, random_state=None,
-                 activation_func='gaussian', activation_args=None,
-                 centers=None, radii=None, rbf_width=1.0):
+    def __init__(
+        self, n_hidden=20, random_state=None,
+        activation_func='gaussian', activation_args=None,
+        centers=None, radii=None, rbf_width=1.0
+    ):
 
         user_components = {'centers': centers, 'radii': radii}
-        super(RBFRandomLayer, self).__init__(n_hidden=n_hidden,
-                                             random_state=random_state,
-                                             activation_func=activation_func,
-                                             activation_args=activation_args,
-                                             user_components=user_components,
-                                             rbf_width=rbf_width,
-                                             alpha=0.0)
+        super(RBFRandomLayer, self).__init__(
+            n_hidden=n_hidden,
+            random_state=random_state,
+            activation_func=activation_func,
+            activation_args=activation_args,
+            user_components=user_components,
+            rbf_width=rbf_width,
+            alpha=0.0
+        )
+
+    @property
+    def centers(self):
+        return self.user_components["centers"]
+
+    @property
+    def radii(self):
+        return self.user_components["radii"]
 
 
 class GRBFRandomLayer(RBFRandomLayer):
@@ -427,7 +463,7 @@ class GRBFRandomLayer(RBFRandomLayer):
 
     Creates a layer of radial basis function units where:
 
-       f(a), s.t. a = ||x-c||/r
+    f(a), s.t. a = ||x-c|| / r
 
     with c the unit center
     and f() is exp(-gamma * a^tau) where tau and r are computed
@@ -475,8 +511,8 @@ class GRBFRandomLayer(RBFRandomLayer):
     References
     ----------
     .. [1] Fernandez-Navarro, et al, "MELM-GRBF: a modified version of the
-              extreme learning machine for generalized radial basis function
-              neural networks", Neurocomputing 74 (2011), 2502-2510
+        extreme learning machine for generalized radial basis function
+        neural networks", Neurocomputing 74 (2011), 2502-2510
 
     """
     # def _grbf(acts, taus):
@@ -488,13 +524,17 @@ class GRBFRandomLayer(RBFRandomLayer):
 
     _internal_activation_funcs = {'grbf': _grbf}
 
-    def __init__(self, n_hidden=20, grbf_lambda=0.001,
-                 centers=None, radii=None, random_state=None):
+    def __init__(
+        self, n_hidden=20, grbf_lambda=0.001,
+        centers=None, radii=None, random_state=None
+    ):
 
-        super(GRBFRandomLayer, self).__init__(n_hidden=n_hidden,
-                                              activation_func='grbf',
-                                              centers=centers, radii=radii,
-                                              random_state=random_state)
+        super(GRBFRandomLayer, self).__init__(
+            n_hidden=n_hidden,
+            activation_func='grbf',
+            centers=centers, radii=radii,
+            random_state=random_state
+        )
 
         self.grbf_lambda = grbf_lambda
         self.dN_vals = None
@@ -512,7 +552,7 @@ def _compute_centers(self, X, sparse, rs):
         sorted_distances = np.sort(squareform(pdist(centers)))
         self.dF_vals = sorted_distances[:, -1]
         self.dN_vals = sorted_distances[:, 1]/100.0
-        #self.dN_vals = 0.0002 * np.ones(self.dF_vals.shape)
+        # self.dN_vals = 0.0002 * np.ones(self.dF_vals.shape)
 
         tauNum = np.log(np.log(self.grbf_lambda) /
                         np.log(1.0 - self.grbf_lambda))