├── .gitignore ├── ANN └── ANN_tutorial.py ├── GBM └── gbm.py ├── ImportanceSampling ├── ImportanceSampling.ipynb └── ImportanceSampling.py ├── KL-Divergence └── kl-divergence.ipynb ├── KMeans └── kMeans.py ├── Multi-regression └── multivariable_reg.py └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/* 2 | .idea 3 | */.ipynb_checkpoints 4 | .ipynb_checkpoints 5 | */__pycache__ 6 | .DS_Store -------------------------------------------------------------------------------- /ANN/ANN_tutorial.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from sklearn.datasets import load_iris 3 | from sklearn.preprocessing import OneHotEncoder 4 | from sklearn.model_selection import train_test_split 5 | 6 | 7 | class fcnn(): 8 | 9 | def __init__(self, train_X, train_y, hid, lr=0.01): 10 | self.input = train_X.shape[1] 11 | self.hid = hid 12 | self.output = train_y.shape[1] 13 | self.train_X = train_X 14 | self.train_y = train_y 15 | self.lr = lr 16 | # initialise weights 17 | self.W1 = np.random.randn(self.input, self.hid) / np.sqrt(self.input) 18 | self.B1 = np.zeros((1, self.hid)) 19 | self.W2 = np.random.randn(self.hid, self.output) / np.sqrt(self.hid) 20 | self.B2 = np.zeros((1, self.output)) 21 | 22 | # active function for the first layer 23 | def tanh(self, X_fc1): 24 | X_tanh = np.tanh(X_fc1) 25 | 26 | return X_tanh 27 | 28 | # softmax for the output layer 29 | # input X_fc2 is the result after assign W2 30 | def softmax(self, X_fc2): 31 | X_output = np.exp(X_fc2) / float(np.sum(np.exp(X_fc2))) 32 | 33 | return X_output 34 | 35 | # define loss function 36 | # y is actual value 37 | # p-1 38 | def cross_loss(self, X_output, y): 39 | index = np.where(y == 1) 40 | loss = -np.log(X_output[:, index]) 41 | # the loss with derivative 42 | loss_dev = X_output-y 43 | 44 | return loss, loss_dev 45 | 46 | # forward propagation 47 | def fit(self, epoch=1): 48 | # iterate whole data set 49 | for step in range(epoch): 50 | print 'step', step 51 | for i in range(self.train_X.shape[0]): 52 | # forward propagation 53 | X_input = self.train_X[i, :].reshape(1, self.train_X.shape[1]) 54 | X_fc1 = np.dot(X_input, self.W1) + self.B1 55 | X_tanh = self.tanh(X_fc1) 56 | X_fc2 = np.dot(X_tanh, self.W2) + self.B2 57 | X_output = self.softmax(X_fc2) 58 | 59 | # calculate loss 60 | loss, loss_dev = self.cross_loss(X_output, self.train_y[i, :]) 61 | print 'loss', float(loss) 62 | 63 | # according loss to do the back propagation 64 | delta_output = loss_dev 65 | delta_input = np.dot(delta_output, self.W2.T) * (1 - np.power(X_tanh, 2)) 66 | 67 | # update weights 68 | self.W2 += -self.lr * np.dot(X_tanh.T, delta_output) 69 | self.B2 += -self.lr * delta_output 70 | self.W1 += -self.lr * np.dot(X_input.T, delta_input) 71 | self.B1 += -self.lr * delta_input 72 | 73 | def predict(self, test_X, test_y): 74 | result = np.zeros((test_X.shape[0], test_y.shape[1])) 75 | correct = 0 76 | for i in range(test_X.shape[0]): 77 | X_input = test_X[i, :] 78 | X_fc1 = np.dot(X_input, self.W1) + self.B1 79 | X_sig = self.tanh(X_fc1) 80 | X_fc2 = np.dot(X_sig, self.W2) + self.B2 81 | X_output = self.softmax(X_fc2) 82 | result[i, :] = X_output 83 | # calculate precision 84 | if np.argmax(X_output) == np.argmax(test_y[i, :]): 85 | correct += 1 86 | 87 | accuracy = float(correct)/test_X.shape[0] 88 | print 'accuracy', accuracy 89 | 90 | return result 91 | 92 | 93 | iris = load_iris() 94 | train_X = iris.data 95 | enc = OneHotEncoder() 96 | train_y = enc.fit_transform(iris.target.reshape((150, 1)), iris.target).toarray() 97 | 98 | train_X2, test_X2, train_y2, test_y2 = train_test_split(train_X, train_y) 99 | 100 | # training ... 101 | 102 | fc = fcnn(train_X2, train_y2, hid=10) 103 | 104 | fc.fit(epoch=3) 105 | 106 | # calculate accuracy 107 | 108 | output = fc.predict(test_X2, test_y2) 109 | 110 | -------------------------------------------------------------------------------- /GBM/gbm.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from sklearn.tree import DecisionTreeRegressor 5 | 6 | x = np.linspace(0, 50, 51) 7 | y = np.random.randn(51) 8 | 9 | plt.scatter(x, y) 10 | 11 | # GBM regressor 12 | 13 | 14 | def gbm(x, y, M): 15 | x = x.reshape(-1, 1) 16 | # var to store predictions 17 | all_preds = np.zeros((M, len(y))) 18 | # initialization 19 | pred = np.mean(y) 20 | # iterate 21 | # for each iteration fit the residual 22 | for i in range(M): 23 | print 'iteration', i+1 24 | all_preds[i, :] = pred 25 | residual = y - pred 26 | clf = DecisionTreeRegressor(max_depth=1) 27 | clf = clf.fit(x, residual) 28 | h = clf.predict(x) 29 | pred += h 30 | 31 | return all_preds 32 | 33 | 34 | preds = gbm(x, y, 12) 35 | 36 | plt.scatter(x, y) 37 | plt.plot(x, preds[0]) 38 | 39 | plt.scatter(x, y) 40 | plt.plot(x, preds[9]) 41 | 42 | # plot to see difference each iteration 43 | fig = plt.figure(figsize=[8, 8]) 44 | for i in range(12): 45 | ax = fig.add_subplot(3, 4, i+1) 46 | ax.set_title('iteration {}'.format(i+1)) 47 | ax.scatter(x, y, s=2.5) 48 | ax.plot(x, preds[i], c='r') 49 | -------------------------------------------------------------------------------- /ImportanceSampling/ImportanceSampling.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Importance Sampling\n", 8 | "---\n", 9 | "Using sampling to approximate a distribution\n", 10 | "\n", 11 | "$$E[f(x)] = \\int f(x)p(x) dx \\approx \\frac{1}{n}\\sum_{i} f(x_i)$$\n", 12 | "where $ x \\sim p(x)$\n", 13 | "\n", 14 | "$$E[f(x)] = \\int f(x)p(x) dx = \\int f(x)\\frac{p(x)}{q(x)}q(x) dx \\approx \\frac{1}{n} \\sum_{i} f(x_i)\\frac{p(x_i)}{q(x_i)}$$\n", 15 | "\n", 16 | "where $ x \\sim q(x)$\n", 17 | "\n", 18 | "Idea of importance sampling: draw the sample from a proposal distribution and re-weight the integral using importance weights so that the correct distribution is targeted\n", 19 | "\n", 20 | "$$Var(X) = E[X^2] - E[X]^2$$\n", 21 | "\n", 22 | "**Reference**\n", 23 | "\n", 24 | "- [1](https://www.youtube.com/watch?v=3Mw6ivkDVZc)\n", 25 | "- [2](https://astrostatistics.psu.edu/su14/lectures/cisewski_is.pdf)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 69, 31 | "metadata": {}, 32 | "outputs": [ 33 | { 34 | "name": "stderr", 35 | "output_type": "stream", 36 | "text": [ 37 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", 38 | " return f(*args, **kwds)\n", 39 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", 40 | " return f(*args, **kwds)\n" 41 | ] 42 | } 43 | ], 44 | "source": [ 45 | "import numpy as np\n", 46 | "import scipy.stats as stats\n", 47 | "import matplotlib.pyplot as plt\n", 48 | "import seaborn as sns" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 161, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "def f_x(x):\n", 58 | " return 1/(1 + np.exp(-x))\n", 59 | "\n", 60 | "def distribution(mu=0, sigma=1):\n", 61 | " # return probability given a value\n", 62 | " distribution = stats.norm(mu, sigma)\n", 63 | " return distribution" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 121, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/plain": [ 74 | "" 75 | ] 76 | }, 77 | "execution_count": 121, 78 | "metadata": {}, 79 | "output_type": "execute_result" 80 | }, 81 | { 82 | "data": { 83 | "image/png": "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\n", 84 | "text/plain": [ 85 | "
" 86 | ] 87 | }, 88 | "metadata": {}, 89 | "output_type": "display_data" 90 | } 91 | ], 92 | "source": [ 93 | "plt.figure(figsize=[6, 4])\n", 94 | "x = np.linspace(0, 4, 50) # x ranges from 0 to 4\n", 95 | "y = [f_x(i) for i in x]\n", 96 | "\n", 97 | "plt.plot(x, y, label=\"$f(x)$\")\n", 98 | "\n", 99 | "plt.xlabel(\"x\", size=18)\n", 100 | "plt.ylabel(\"y\", size=18)\n", 101 | "plt.legend(prop={\"size\": 14})" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "## Sampling" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 169, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [ 117 | "# pre-setting\n", 118 | "n = 1000\n", 119 | "\n", 120 | "mu_target = 3.5\n", 121 | "sigma_target = 1\n", 122 | "mu_appro = 3\n", 123 | "sigma_appro = 1\n", 124 | "\n", 125 | "p_x = distribution(mu_target, sigma_target)\n", 126 | "q_x = distribution(mu_appro, sigma_appro)" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 170, 132 | "metadata": {}, 133 | "outputs": [ 134 | { 135 | "name": "stderr", 136 | "output_type": "stream", 137 | "text": [ 138 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n", 139 | " warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n", 140 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n", 141 | " warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n" 142 | ] 143 | }, 144 | { 145 | "data": { 146 | "text/plain": [ 147 | "" 148 | ] 149 | }, 150 | "execution_count": 170, 151 | "metadata": {}, 152 | "output_type": "execute_result" 153 | }, 154 | { 155 | "data": { 156 | "image/png": "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\n", 157 | "text/plain": [ 158 | "
" 159 | ] 160 | }, 161 | "metadata": {}, 162 | "output_type": "display_data" 163 | } 164 | ], 165 | "source": [ 166 | "plt.figure(figsize=[10, 4])\n", 167 | "\n", 168 | "sns.distplot([np.random.normal(mu_target, sigma_target) for _ in range(3000)], label=\"distribution $p(x)$\")\n", 169 | "sns.distplot([np.random.normal(mu_appro, sigma_appro) for _ in range(3000)], label=\"distribution $q(x)$\")\n", 170 | "\n", 171 | "plt.title(\"Distributions\", size=16)\n", 172 | "plt.legend()" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 178, 178 | "metadata": {}, 179 | "outputs": [ 180 | { 181 | "name": "stdout", 182 | "output_type": "stream", 183 | "text": [ 184 | "simulate value 0.9542816022260111\n" 185 | ] 186 | } 187 | ], 188 | "source": [ 189 | "# value\n", 190 | "s = 0\n", 191 | "for i in range(n):\n", 192 | " # draw a sample\n", 193 | " x_i = np.random.normal(mu_target, sigma_target)\n", 194 | " s += f_x(x_i)\n", 195 | "print(\"simulate value\", s/n)" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 172, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "name": "stdout", 205 | "output_type": "stream", 206 | "text": [ 207 | "average 0.9495227171370471 variance 0.3043862985463373\n" 208 | ] 209 | } 210 | ], 211 | "source": [ 212 | "# calculate value sampling from a different distribution\n", 213 | "\n", 214 | "value_list = []\n", 215 | "for i in range(n):\n", 216 | " # sample from different distribution\n", 217 | " x_i = np.random.normal(mu_appro, sigma_appro)\n", 218 | " value = f_x(x_i)*(p_x.pdf(x_i) / q_x.pdf(x_i))\n", 219 | " \n", 220 | " value_list.append(value)\n", 221 | "\n", 222 | "print(\"average {} variance {}\".format(np.mean(value_list), np.var(value_list)))" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "## Different $q(x)$" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 179, 235 | "metadata": {}, 236 | "outputs": [], 237 | "source": [ 238 | "# pre-setting\n", 239 | "n = 5000\n", 240 | "\n", 241 | "mu_target = 3.5\n", 242 | "sigma_target = 1\n", 243 | "mu_appro = 1\n", 244 | "sigma_appro = 1\n", 245 | "\n", 246 | "p_x = distribution(mu_target, sigma_target)\n", 247 | "q_x = distribution(mu_appro, sigma_appro)" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 182, 253 | "metadata": {}, 254 | "outputs": [ 255 | { 256 | "name": "stderr", 257 | "output_type": "stream", 258 | "text": [ 259 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n", 260 | " warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n", 261 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n", 262 | " warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n" 263 | ] 264 | }, 265 | { 266 | "data": { 267 | "text/plain": [ 268 | "" 269 | ] 270 | }, 271 | "execution_count": 182, 272 | "metadata": {}, 273 | "output_type": "execute_result" 274 | }, 275 | { 276 | "data": { 277 | "image/png": "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\n", 278 | "text/plain": [ 279 | "
" 280 | ] 281 | }, 282 | "metadata": {}, 283 | "output_type": "display_data" 284 | } 285 | ], 286 | "source": [ 287 | "plt.figure(figsize=[10, 4])\n", 288 | "\n", 289 | "sns.distplot([np.random.normal(mu_target, sigma_target) for _ in range(3000)], label=\"distribution $p(x)$\")\n", 290 | "sns.distplot([np.random.normal(mu_appro, sigma_appro) for _ in range(3000)], label=\"distribution $q(x)$\")\n", 291 | "\n", 292 | "plt.title(\"Distributions\", size=16)\n", 293 | "plt.legend()" 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": 181, 299 | "metadata": {}, 300 | "outputs": [ 301 | { 302 | "name": "stdout", 303 | "output_type": "stream", 304 | "text": [ 305 | "average 0.9959984807502844 variance 83.36158359644132\n" 306 | ] 307 | } 308 | ], 309 | "source": [ 310 | "# calculate value sampling from a different distribution\n", 311 | "\n", 312 | "value_list = []\n", 313 | "# need larger steps\n", 314 | "for i in range(n):\n", 315 | " # sample from different distribution\n", 316 | " x_i = np.random.normal(mu_appro, sigma_appro)\n", 317 | " value = f_x(x_i)*(p_x.pdf(x_i) / q_x.pdf(x_i))\n", 318 | " \n", 319 | " value_list.append(value)\n", 320 | "\n", 321 | "print(\"average {} variance {}\".format(np.mean(value_list), np.var(value_list)))" 322 | ] 323 | } 324 | ], 325 | "metadata": { 326 | "kernelspec": { 327 | "display_name": "Python 3", 328 | "language": "python", 329 | "name": "python3" 330 | }, 331 | "language_info": { 332 | "codemirror_mode": { 333 | "name": "ipython", 334 | "version": 3 335 | }, 336 | "file_extension": ".py", 337 | "mimetype": "text/x-python", 338 | "name": "python", 339 | "nbconvert_exporter": "python", 340 | "pygments_lexer": "ipython3", 341 | "version": "3.6.5" 342 | } 343 | }, 344 | "nbformat": 4, 345 | "nbformat_minor": 2 346 | } 347 | -------------------------------------------------------------------------------- /ImportanceSampling/ImportanceSampling.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import scipy.stats as stats 3 | import matplotlib.pyplot as plt 4 | import seaborn as sns 5 | 6 | 7 | def f_x(x): 8 | return 1/(1 + np.exp(-x)) 9 | 10 | 11 | def distribution(mu=0, sigma=1): 12 | # return probability given a value 13 | distribution = stats.norm(mu, sigma) 14 | return distribution 15 | 16 | 17 | if __name__ == "__main__": 18 | # pre-setting 19 | n = 1000 20 | 21 | mu_target = 3.5 22 | sigma_target = 1 23 | mu_appro = 3 24 | sigma_appro = 1 25 | 26 | p_x = distribution(mu_target, sigma_target) 27 | q_x = distribution(mu_appro, sigma_appro) 28 | 29 | plt.figure(figsize=[10, 4]) 30 | 31 | sns.distplot([np.random.normal(mu_target, sigma_target) for _ in range(3000)], label="distribution $p(x)$") 32 | sns.distplot([np.random.normal(mu_appro, sigma_appro) for _ in range(3000)], label="distribution $q(x)$") 33 | 34 | plt.title("Distributions", size=16) 35 | plt.legend() 36 | 37 | # value 38 | s = 0 39 | for i in range(n): 40 | # draw a sample 41 | x_i = np.random.normal(mu_target, sigma_target) 42 | s += f_x(x_i) 43 | print("simulate value", s / n) 44 | 45 | # calculate value sampling from a different distribution 46 | 47 | value_list = [] 48 | for i in range(n): 49 | # sample from different distribution 50 | x_i = np.random.normal(mu_appro, sigma_appro) 51 | value = f_x(x_i) * (p_x.pdf(x_i) / q_x.pdf(x_i)) 52 | 53 | value_list.append(value) 54 | 55 | print("average {} variance {}".format(np.mean(value_list), np.var(value_list))) 56 | 57 | # pre-setting different q(x) 58 | n = 5000 59 | 60 | mu_target = 3.5 61 | sigma_target = 1 62 | mu_appro = 1 63 | sigma_appro = 1 64 | 65 | p_x = distribution(mu_target, sigma_target) 66 | q_x = distribution(mu_appro, sigma_appro) 67 | 68 | plt.figure(figsize=[10, 4]) 69 | 70 | sns.distplot([np.random.normal(mu_target, sigma_target) for _ in range(3000)], label="distribution $p(x)$") 71 | sns.distplot([np.random.normal(mu_appro, sigma_appro) for _ in range(3000)], label="distribution $q(x)$") 72 | 73 | plt.title("Distributions", size=16) 74 | plt.legend() 75 | 76 | # calculate value sampling from a different distribution 77 | 78 | value_list = [] 79 | # need larger steps 80 | for i in range(n): 81 | # sample from different distribution 82 | x_i = np.random.normal(mu_appro, sigma_appro) 83 | value = f_x(x_i) * (p_x.pdf(x_i) / q_x.pdf(x_i)) 84 | 85 | value_list.append(value) 86 | 87 | print("average {} variance {}".format(np.mean(value_list), np.var(value_list))) -------------------------------------------------------------------------------- /KL-Divergence/kl-divergence.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "For discrete variable:\n", 8 | "$$ D_{KL}(p || q) = \\sum_{i}p(x_i)(logp(x_i) - logq(x_i)) = \\sum_{i}p(x_i)(log\\frac{p(x_i)}{q(x_i)})$$\n", 9 | "\n", 10 | "For continuous variable:\n", 11 | "$$ D_{KL}(p || q) = \\int p(x)(logp(x) - logq(x)) dx = \\int p(x)(log\\frac{p(x)}{q(x)}) dx $$\n", 12 | "\n", 13 | "**Reference**:\n", 14 | "- [1](https://www.countbayesie.com/blog/2017/5/9/kullback-leibler-divergence-explained)\n", 15 | "- [2](https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence)" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 39, 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "%matplotlib inline\n", 25 | "\n", 26 | "import numpy as np\n", 27 | "import matplotlib.pyplot as plt\n", 28 | "import scipy.stats as stats\n", 29 | "import seaborn as sns" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "### Generate random distribution" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 21, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "def sample_gen(n=1000):\n", 46 | " samples = []\n", 47 | " for _ in range(n):\n", 48 | " if np.random.uniform() <= 0.5:\n", 49 | " x = np.random.uniform(-2, 2)\n", 50 | " else:\n", 51 | " x = np.random.normal(1, 1)\n", 52 | " samples.append(x)\n", 53 | " return samples" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 25, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "name": "stderr", 63 | "output_type": "stream", 64 | "text": [ 65 | "/Users/jeremy.zhang/anaconda3/lib/python3.6/site-packages/matplotlib/axes/_axes.py:6462: UserWarning: The 'normed' kwarg is deprecated, and has been replaced by the 'density' kwarg.\n", 66 | " warnings.warn(\"The 'normed' kwarg is deprecated, and has been \"\n" 67 | ] 68 | }, 69 | { 70 | "data": { 71 | "text/plain": [ 72 | "" 73 | ] 74 | }, 75 | "execution_count": 25, 76 | "metadata": {}, 77 | "output_type": "execute_result" 78 | }, 79 | { 80 | "data": { 81 | "image/png": "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\n", 82 | "text/plain": [ 83 | "
" 84 | ] 85 | }, 86 | "metadata": {}, 87 | "output_type": "display_data" 88 | } 89 | ], 90 | "source": [ 91 | "samples = sample_gen(n=2000)\n", 92 | "plt.figure(figsize=[10, 6])\n", 93 | "sns.distplot(samples)" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 49, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "data": { 103 | "text/plain": [ 104 | "" 105 | ] 106 | }, 107 | "execution_count": 49, 108 | "metadata": {}, 109 | "output_type": "execute_result" 110 | }, 111 | { 112 | "data": { 113 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAFpCAYAAACmgZ0NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xlc1VX+x/HXueybLIKCgAIKLnAVFMQd3DV30xaXNCunHCtrSpupzKymqbF+bVaTlmajZmou41YpuG+AO+4oIuKKiuzC5fv74yqBK8KFi/p5Ph484H6X831ftNvH8z3fc5SmaQghhBBCiMqlM3cAIYQQQoiHgRRdQgghhBBVQIouIYQQQogqIEWXEEIIIUQVkKJLCCGEEKIKSNElhBBCCFEFpOgSQgghhKgCUnQJIYQQQlQBKbqEEEIIIaqAFF1CCCGEEFXA0twBbuTu7q75+fmZO4YQQgghxF0lJCRc0DTNoyzHVruiy8/Pj/j4eHPHEEIIIYS4K6XUibIeK7cXhRBCCCGqgBRdQgghhBBVQIouIYQQQogqUKYxXUqpHsDngAUwXdO0f93muEHAfCBC07T4a9v+DjwDGICXNE37zRTBhRBCiNspKCggNTWVvLw8c0cRDwhbW1t8fHywsrIqdxt3LbqUUhbAVKArkArEKaWWapq2/4bjnICXgG0ltjUBngCCgTrAaqVUkKZphnInFkIIIe4iNTUVJycn/Pz8UEqZO464z2maRnp6Oqmpqfj7+5e7nbLcXmwJHNU07ZimaVeBn4F+tzjuPeBjoOQ/K/oBP2ualq9p2nHg6LX2hBBCiEqTl5dHzZo1peASJqGUombNmhXuOS1L0eUNnCzxOvXatpJhwgBfTdOW3eu5QgghRGWQgkuYkin+PpWl6LrVVbQSIXTA/wF/u9dzS7QxWikVr5SKP3/+fBkiCSGEEOK66Ojocs9xmZycTEhICADx8fG89NJLdzx2zpw5t92flpbGoEGDAJg5cyZjx469pywzZ84kLS2t+PWzzz7L/v3773DG/aUsRVcq4FvitQ+QVuK1ExACrFVKJQOtgKVKqfAynAuApmnfaZoWrmlauIdHmSZ1FUIIIYSJhYeH88UXX9x2/52KrsLCQurUqcOCBQvKff0bi67p06fTpEmTcrdX3ZSl6IoDApVS/kopa4wD45de36lpWoamae6apvlpmuYHbAX6Xnt6cSnwhFLKRinlDwQC203+LoQQQohqJDs7m169etGsWTNCQkKYN28eAJMnTyYiIoKQkBBGjx6Nphlv/kRHR/PKK6/QoUMHGjduTFxcHAMHDiQwMJC33noLMBY8jRo1YsSIETRt2pRBgwaRk5Nz07V///13WrduTfPmzRk8eDBZWVk3HZOQkECzZs1o3bo1U6dOLd6+du1aevfuDcC6desIDQ0lNDSUsLAwMjMzeeONN9iwYQOhoaH83//9HzNnzmTw4MH06dOHbt26leo1Azh58iQ9evSgYcOGvPvuu8Xvo+QxU6ZMYdKkSSxYsID4+HiGDh1KaGgoubm5pXrw5s6di16vJyQkhAkTJhSf7+joyJtvvkmzZs1o1aoVZ8+eLd8fWhW469OLmqYVKqXGAr9hnDLiB03TEpVSk4F4TdOW3uHcRKXUL8B+oBD4qzy5KIQQoiq9+79E9qddMWmbTerU4J0+wbfdv2rVKurUqcPy5csByMjIAGDs2LFMnDgRgOHDh7Ns2TL69OkDgLW1NevXr+fzzz+nX79+JCQk4ObmRv369XnllVcAOHToEN9//z1t27Zl1KhRfP3117z22mvF171w4QLvv/8+q1evxsHBgY8++ohPP/20+JrXPf3003z55ZdERUXx+uuv3/I9TJkyhalTp9K2bVuysrKwtbXlX//6F1OmTGHZMuMQ7pkzZ7Jlyxb27NmDm5sbycnJpdrYvn07+/btw97enoiICHr16oW7u/strzdo0CC++uorpkyZQnh4eKl9aWlpTJgwgYSEBFxdXenWrRuLFy+mf//+ZGdn06pVKz744APGjx/PtGnTigvV6qZMk6NqmrZC07QgTdPqa5r2wbVtE29VcGmaFn19jq5rrz+4dl5DTdNWmi66EEIIUT3p9XpWr17NhAkT2LBhA87OzgDExsYSGRmJXq8nJiaGxMTE4nP69u1bfG5wcDBeXl7Y2NgQEBDAyZPGZ9J8fX1p27YtAMOGDWPjxo2lrrt161b2799P27ZtCQ0N5ccff+TEidJLA2ZkZHD58mWioqIAY/F3K23btuXVV1/liy++4PLly1ha3rqfpmvXrri5ud12X82aNbGzs2PgwIE35S2ruLg4oqOj8fDwwNLSkqFDh7J+/XrAWKxe751r0aLFTYVfdVLtFrwWQoiSsq5msejoIlKupBRv0ykdYbXC6Fi3IzYWNmZMJ+4Hd+qRqixBQUEkJCSwYsUK/v73v9OtWzfGjx/PmDFjiI+Px9fXl0mTJpWagsDGxvh3WafTFf98/XVhYSFw8xN0N77WNI2uXbsyd+7c22bTNK1MT+K98cYb9OrVixUrVtCqVStWr159y+McHBxu28at8lpaWlJUVFS8rSzTMFy/DXsrVlZWxdexsLAo/l1VR7IMkBCiWrqQe4HPEj6j24JufBz3MSuTV7IqeRWrklexJGkJr69/nU6/dOLDbR9y8OJBc8cVopS0tDTs7e0ZNmwYr732Gjt27CguLtzd3cnKyirXgPOUlBS2bNkCGMc4tWvXrtT+Vq1asWnTJo4ePQpATk4Ohw8fLnWMi4sLzs7Oxb1Os2fPvuW1kpKS0Ov1TJgwgfDwcA4ePIiTkxOZmZllzvvHH39w8eJFcnNzWbx4MW3btqV27dqcO3eO9PR08vPzi29VArdtPzIyknXr1nHhwgUMBgNz584t7qm7n0hPlxCi2vlh3w9M3TmVgqICutTrwqiQUYS4/znwtkgrYuvprSw+spgFhxcw5+AcegX04o2IN3CxdTFjciGM9u7dy+uvv45Op8PKyopvvvkGFxcXnnvuOfR6PX5+fkRERNxzu40bN+bHH3/kL3/5C4GBgbzwwgul9nt4eDBz5kyefPJJ8vPzAXj//fcJCgoqddyMGTMYNWoU9vb2dO/e/ZbX+uyzz4iNjcXCwoImTZrQs2dPdDodlpaWNGvWjJEjR+Lq6nrHvO3atWP48OEcPXqUIUOGFI/VmjhxIpGRkfj7+9OoUaPi40eOHMnzzz+PnZ1dcXEJ4OXlxYcffkjHjh3RNI1HHnmEfv1uNU979abu1GVnDuHh4Vp55xoRQtzfNE3jy51fMm3vNLrU7cK4FuOoV6PeHc/JyM9g1v5Z/LD3B2rY1ODNyDfp5tetihKL6urAgQM0btzY3DFMKjk5md69e7Nv3z5zR3lo3ervlVIqQdO08NucUorcXhRCVAuapvFJ/CdM2zuNRwMf5ZPoT+5acAE42zjzYtiL/Nz7Z2rb1+Zv6/7Gq2tfJfNq2W+BCCFEVZCiSwhhdkVaEf/c9k9+3P8jQxoN4Z3W76BT9/bx1NCtIXN6zeHl5i8TmxLLkOVDSM5IrpzAQpiBn5+f9HLd56ToEkKY3fS90/n50M+MDB7JGy3fKPcaZ5Y6S57VP8t33b4jIz+DIcuHsCF1g4nTCiFE+UjRJYQwqwPpB/hm1zf09OvJqy1eNcmishGeEfzc+2fqONbhr2v+yo+JP97xkXMhhKgKUnQJIczmquEq/9j4D1xtXXmz1ZsmKbiuq+NYh1k9Z9G1XlemxE/h47iPKdKK7n6iEEJUEpkyQghhNl/t+oqjl48ytfNUnG2cTd6+vZU9/476N7XiavHfA//lYt5F3m/7PlYWVia/lhBC3I30dAkhzGLXuV3M3DeTRwMfpYNPh0q7jk7pGB8xnpebv8yK4ysYGzOWnIKbFwkWwtzi4+N56aWXAMjPz6dLly6EhoYWL5b9oCv5/itq5syZpKWlFb9+9tln2b9/v0nargjp6RJCVLncwlze3PgmdRzr8HrErRfbNSWlFM/qn6WmbU0mbZnEM789w9QuU3GzvfV6cUKYQ3h4ePHkoTt37qSgoIBdu3aV+XyDwYCFhUVlxbsnhYWFt12r8XZKvv+KmjlzJiEhIdSpUweA6dOnm6TdipKeLiFElZt9YDYpmSlMbjMZB6vbr9tmagMCB/BZ9GccuXyEEStHcCrrVJVdWzxckpOTCQn5cxWFKVOmMGnSJACio6OZMGECLVu2JCgoiA0bjE/Yrl27lt69e3Pu3DmGDRvGrl27CA0NJSkpiTVr1hAWFoZer2fUqFHFs837+fkxefJk2rVrx/z584mOjuaVV16hQ4cONG7cmLi4OAYOHEhgYCBvvfXWLbO+8MILhIeHExwczDvvvFO83c/Przhny5Yti5cWuj5rfPv27QkKCipexmfmzJkMHjyYPn360K1bNzRN4/XXXyckJAS9Xl/cY7do0SK6dOmCpmmcPn2aoKAgzpw5U/z+ASZNmsSIESPo1q0bfn5+/Prrr4wfPx69Xk+PHj0oKCgAYPLkyURERBASEsLo0aPRNI0FCxYQHx/P0KFDCQ0NJTc3l+joaK5PvD537lz0ej0hISFMmDCh+P06Ojry5ptv0qxZM1q1asXZs2cr9pfgFqSnSwhRpa5cvcIP+34gyieKll4tq/z6Het25Luu3zE2ZizDVwzn267fEuQadPcTxf1r5RtwZq9p2/TUQ89/lfv0wsJCtm/fzooVK3j33XdLLSZdq1Ytpk+fzpQpU1i2bBl5eXlER0ezZs0agoKCeOqpp/jmm28YN24cALa2tsXrKH777bdYW1uzfv16Pv/8c/r160dCQgJubm7Ur1+fV155hZo1a5bK8sEHH+Dm5obBYKBz587s2bOHpk2bAlCjRg22b9/OrFmzGDduXHGBlZyczLp160hKSqJjx47FBdmWLVvYs2cPbm5uLFy4kF27drF7924uXLhAREQEHTp0YMCAASxcuJCpU6eyatUq3n33XTw9PTl4sPQaqklJScTGxrJ//35at27NwoUL+fjjjxkwYADLly+nf//+jB07lokTJwIwfPhwli1bxqBBg/jqq6+YMmXKTT1naWlpTJgwgYSEBFxdXenWrRuLFy+mf//+ZGdn06pVKz744APGjx/PtGnTbluolpf0dAkhqtTMfTPJvJrJi2Evmi1D89rN+bHHjygUI1eOZOe5nWbLIh5OAwcOBKBFixYkJyff8dhDhw7h7+9fvH7iiBEjWL9+ffH+xx9/vNTxffv2BUCv1xMcHIyXlxc2NjYEBARw8uTJm9r/5ZdfaN68OWFhYSQmJpYa+/Tkk08Wfy+5FuJjjz2GTqcjMDCQgICA4oKpa9euuLkZb9tv3LiRJ598EgsLC2rXrk1UVBRxcXEAfPnll3z44YfY2NgUX+NGPXv2xMrKCr1ej8FgoEePHsXv6/rvLDY2lsjISPR6PTExMSQmJt7xdxkXF0d0dDQeHh5YWloydOjQ4t+ltbV1cU9bWf5cykN6uoQQVeZC7gX+e+C/9PTrSUO3hmbNEugayE+P/MToP0bzlz/+wtedvybc0zTjSUQ1U4EeqfKytLSkqOjPKUry8vJK7bexsQHAwsKCwsLCO7Z1tznmHBxK36K/3rZOpyv++frrG691/PhxpkyZQlxcHK6urowcObJU1pLTuNzu55KvS2a5U+5Tp06h0+k4e/YsRUVF6HQ39wGVfB9WVlbF17j+PvLy8hgzZgzx8fH4+voyadKkm37PN7pTppLXKMufS3lIT5cQospM3zudq4arjAkdY+4ogHEurxndZ+Dp4MmYNWOIOxNn7kjiAVG7dm3OnTtHeno6+fn5xbflyqNRo0YkJycX38L76aefiIqKMknOK1eu4ODggLOzM2fPnmXlypWl9l8fhzVv3jxat25dvH3+/PkUFRWRlJTEsWPHaNjw5n9EdejQgXnz5mEwGDh//jzr16+nZcuWFBYW8vTTTzNnzhwaN27Mp59+Wq7s1wssd3d3srKyWLBgQfE+JycnMjNvXn81MjKSdevWceHCBQwGA3PnzjXZ77IspKdLCFEl0rLS+OXQL/Rv0B8/Zz9zxynmYe/BD91/4NnfnmXM6jF82flLWnm1MncscZ+zsrJi4sSJREZG4u/vT6NGjcrdlq2tLTNmzGDw4MEUFhYSERHB888/b5KczZo1IywsjODgYAICAmjbtm2p/fn5+URGRlJUVMTcuXOLtzds2JCoqCjOnj3Lt99+i62t7U1tDxgwgC1bttCsWTOUUnz88cd4enoyefJk2rdvT/v27QkNDSUiIoJevXrdc3YXFxeee+459Ho9fn5+REREFO+7Ptjfzs6u1G1RLy8vPvzwQzp27IimaTzyyCP069fvnq9dXqq6LY0RHh6uXX/CQAjx4Ji4aSLLjy1n+cDleDp4mjvOTdJz03n292c5mXmSb7p8Q4RnxN1PEtXWgQMHaNy4sblj3Nf8/PyIj4/H3d291PaRI0fSu3dvBg0aZKZk5nOrv1dKqQRN08o0NkFuLwohKl1aVhpLk5byWMPHqmXBBVDTribfd/8eb0dvXop5iUMXD5k7khDiASNFlxCi0s09aLwtMSJ4hJmT3JmbrRvfdvkWe0t7xqweQ1pW2t1PEuIBlZycfFMvFxjn43oYe7lMQYouIUSlyinIYeHhhXSt17Xa9nKV5OXoxTddvyG3MJfnVz/P5bzL5o4khHhASNElhKhUS5KWkFmQybAmw8wdpcyCXIP4vNPnnMo8xdiYseQb8s0dSQjxAJCiSwhRaYq0ImYfmE1T96Y082hm7jj3JMIzgg/bf8ju87v5d9y/zR1HCPEAkKJLCFFpNp7ayIkrJ+6rXq6Suvl1Y0STEcw7NI9Vx1eZO44Q4j4nRZcQotL8tP8natnXoku9LuaOUm4vt3iZZh7NeGfzOyRnJJs7jhBlVnKR5+ooLS3NZAPyFy9eXGr5ookTJ5Zaz7K6kKJLCFEpjlw6wtbTW3my0ZNY6azMHafcrHRWTImagrWFNX9b9zfyCu+8zIgQplAZS9BUJoPBcM/n1KlTp9Qs8hVxY9E1efJkunSpfv/Yk6JLCFEpZh+Yja2FLYMC7/9Hyz0dPPlnu39y+NJh/rW96tfxE/ef5ORkGjduzHPPPUdwcDDdunUjNzcXgF27dtGqVSuaNm3KgAEDuHTpEmDsmfrHP/5BVFQUn3/+OSNHjuSFF16gY8eOBAQEsG7dOkaNGkXjxo0ZOXJk8bVeeOEFwsPDCQ4O5p133rlrtsmTJxMREUFISAijR48uXo8wOjqacePG0aZNG0JCQti+fTsAkyZNYvjw4XTq1InAwECmTZsGwNq1a+nYsSNDhgxBr9cD8OmnnxISEkJISAifffYZYFxkumnTpuTl5ZGdnU1wcDD79u0jOTmZkJAQwDgNRf/+/enTpw/+/v589dVXfPrpp4SFhdGqVSsuXrwIwLRp04iIiKBZs2Y8+uij5OTksHnzZpYuXcrrr79OaGgoSUlJjBw5srigW7NmDWFhYej1ekaNGkV+vvHBGD8/P9555x2aN2+OXq8vXrS7MskyQEIIk8u6msWK4yvoFdALF1sXc8cxifY+7Xk6+GlmJM6gp39PIr0izR1JlNFH2z/i4EXT/g+1kVsjJrSccMdjjhw5wty5c5k2bRqPPfYYCxcuZNiwYTz11FN8+eWXREVFMXHiRN59993iAuXy5cusW7cOMM78funSJWJiYli6dCl9+vRh06ZNTJ8+nYiICHbt2kVoaCgffPABbm5uGAwGOnfuzJ49e2jatOltc40dO5aJEycCMHz4cJYtW0afPn0AyM7OZvPmzaxfv55Ro0axb98+APbs2cPWrVvJzs4mLCyseNme7du3s2/fPvz9/UlISGDGjBls27YNTdOIjIwkKiqKiIgI+vbty1tvvUVubi7Dhg0jJCSE5OTkUrn27dvHzp07ycvLo0GDBnz00Ufs3LmTV155hVmzZjFu3DgGDhzIc889B8Bbb73F999/z4svvkjfvn1vOUt+Xl4eI0eOZM2aNQQFBfHUU0/xzTffMG7cOMC4buOOHTv4+uuvmTJlCtOnT7/rn31FSE+XEMLkViavJLcwl0cDHzV3FJMaEzoGH0cf3t/6PlcNV80dR1Rz/v7+hIaGAtCiRQuSk5PJyMjg8uXLxYssjxgxgvXr1xef8/jjj5dqo0+fPiil0Ov11K5dG71ej06nIzg4uLho+eWXX2jevDlhYWEkJiaWus12K7GxsURGRqLX64mJiSExMbF435NPPgkYF6u+cuUKly8b56nr168fdnZ2uLu707Fjx+JesJYtW+Lv7w/Axo0bGTBgAA4ODjg6OjJw4EA2bNgAGMdY/fHHH8THxzN+/Phb5urYsSNOTk54eHjg7OxcXAjq9fri97pv3z7at2+PXq9n9uzZpbLfyqFDh/D39ycoKOiWv++BAwcCf/75VDbp6RJCmNyiI4to4NKAEPcQc0cxKVtLW95u9TZ/Wf0Xvt/7PS+EvmDuSKIM7tYjVVlsbGyKf7awsCi+vXgnDg4Ot2xDp9OVak+n01FYWMjx48eZMmUKcXFxuLq6MnLkSPLybj/uMC8vjzFjxhAfH4+vry+TJk0qdbxSqtTx11/fbnvJvHday/nixYtkZWVRUFBAXl7eTe+z5Hu98f1ef69g7P1bvHgxzZo1Y+bMmaxdu/a217xbppLXtLCwqJJxdGXq6VJK9VBKHVJKHVVKvXGL/c8rpfYqpXYppTYqpZpc2+6nlMq9tn2XUupbU78BIUT1cuTSEfZe2MvAwIE3fVA/CNp4t6GnX0+m7Z0mTzOKe+bs7Iyrq2txD9BPP/1U3OtVHleuXMHBwQFnZ2fOnj3LypUr73j89QLL3d2drKysmwayz5s3DzD2Wjk7O+Ps7AzAkiVLyMvLIz09nbVr1xIRcfOC8B06dGDx4sXk5OSQnZ3NokWLaN++PQCjR4/mvffeY+jQoUyYUP4iODMzEy8vLwoKCpg9e3bxdicnJzIzM286vlGjRiQnJ3P06FGg4r/virprT5dSygKYCnQFUoE4pdRSTdNK9l/O0TTt22vH9wU+BXpc25ekaVqoaWMLIaqrX4/8iqXOkt4Bvc0dpdKMbzmejac28v7W95nWbdoDWVyKyvPjjz/y/PPPk5OTQ0BAADNmzCh3W82aNSMsLIzg4GACAgJo27btHY93cXHhueeeQ6/X4+fnd1Px5OrqSps2bbhy5Qo//PBD8faWLVvSq1cvUlJSePvtt6lTpw6HDx8udW7z5s0ZOXIkLVu2BODZZ58lLCyMWbNmYWlpyZAhQzAYDLRp04aYmBgCAgLu+f2+9957REZGUq9ePfR6fXGh9cQTT/Dcc8/xxRdflCokbW1tmTFjBoMHD6awsJCIiAief/75e76uqai7db0ppVoDkzRN637t9d8BNE378DbHPwk8pWlaT6WUH7BM07Qy32MIDw/XqvO8IkKI27tquEqn+Z2I9Izkk+hPzB2nUs07OI/3t73PP9v9kz71+5g7jrjBgQMHaNy4sblj3Feio6OZMmUK4eHhpbZPmjQJR0dHXnvtNTMlqz5u9fdKKZWgaVr4bU4ppSy3F72BkyVep17bduNF/6qUSgI+Bl4qsctfKbVTKbVOKdW+LKGEEPenmJMxZORnMDBwoLmjVLrBDQcTUjOEz3d8LmszCiHKpCxF1636zW/qHtM0baqmafWBCcBb1zafBupqmhYGvArMUUrVuOkCSo1WSsUrpeLPnz9f9vRCiGpl0ZFFeDp40sqrlbmjVDqd0jGuxTjO5pxl/qH55o4jRIWtXbv2pl4uMPZ0SS+XaZSl6EoFfEu89gHS7nD8z0B/AE3T8jVNS7/2cwKQBATdeIKmad9pmhauaVq4h4dHWbMLIaqRtKw0tqRtoX+D/ljoLMwdp0pEekXS0rMl0/ZOI6cgx9xxhBDVXFmKrjggUCnlr5SyBp4AlpY8QCkVWOJlL+DIte0e1wbio5QKAAKBY6YILoSoXpYkLQGgf4P+Zk5StV4Me5GLeReZc3COuaOIG9xtzLIQ98IUf5/uWnRpmlYIjAV+Aw4Av2ialqiUmnztSUWAsUqpRKXULoy3EUdc294B2KOU2g0sAJ7XNO1ihVMLIaoVTdNYlrSMlp4t8Xa8acjnAy20VijtvdszY98MMq/e/Mi6MA9bW1vS09Ol8BImoWka6enp2NraVqidMk2OqmnaCmDFDdsmlvj55ductxBYWJGAQojqb9+FfaRkpvCs/llzRzGLsWFjeXzZ4/y0/yfGhI4xdxwB+Pj4kJqaiowTFqZia2uLj49PhdqQGemFEBW24vgKrHRWdK7X2dxRzKJJzSZ0rdeVWftnMaTRkAdmvcn7mZWVVfHyNEJUF7L2ohCiQgqLCll5fCVRPlHUsL7p4eSHxphmY8gpyGHW/lnmjiKEqKak6BJCVMj209tJz0unV0Avc0cxqwauDehctzO/HP5FnmQUQtySFF1CiApZfnw5TlZOtPeRuY+fCn6KjPwM/pf0P3NHEUJUQ1J0CSHKLa8wjzUpa+hSrws2FjbmjmN2oR6h6N31/HTgJ4q0InPHEUJUM1J0CSHKbV3qOrILsnkk4BFzR6kWlFI81eQpTlw5wfrU9eaOI4SoZqToEkKU2/Jjy/Gw8yCidoS5o1QbXep1wcvBSwbUCyFuIkWXEKJcMvIz2HBqAz38ezw0y/6UhaXOkqGNhxJ3Jo796fvNHUcIUY1I0SWEKJfVJ1ZTWFRIL/+H+6nFWxkYOBB7S3t+2v+TuaMIIaoRKbqEEOXyW/Jv+Dr50qRmE3NHqXacrJ0YGDiQVcdXcSb7jLnjCCGqCSm6hBD37FLeJbaf2U63et1QSpk7TrU0tPFQDJqBX4/8au4oQohqQoouIcQ9i0mJwaAZ6ObXzdxRqi0fJx/a1GnDr0d+pbCo0NxxhBDVgBRdQoh79vuJ3/Fx9KGxW2NzR6nWBgcN5mzOWTad2mTuKEKIakCKLiHEPbmcd5ltp7fR1a+r3Fq8iw6+HXC3c2f+4fnmjiKEqAak6BJC3JPYk7EYNAPd63U3d5Rqz0pnxYAGA9hwaoMMqBdCSNElhLg3v534DW/yUNeXAAAgAElEQVRHb3lqsYwGBg5E0zQWHVlk7ihCCDOToksIUWYZ+RlsS9smTy3eg+sD6hceWYihyGDuOEIIM5KiSwhRZjEpMRRqhfLU4j0aFDSIszln2Xhqo7mjCCHMSIouIUSZ/X7id7wdvQmuGWzuKPeVKN8o3O3cWXB4gbmjCCHMSIouIUSZZORnsPX0VrrWk6cW79X1AfXrT63nbPZZc8cRQpiJFF1CiDJZn7qewqJCutTrYu4o96X+DfpTpBWx7Ngyc0cRQpiJFF1CiDKJPRmLh50Hene9uaPcl+rWqEtYrTCWJi1F0zRzxxFCmIEUXUKIu8o35LPx1EaifaPRKfnYKK++9ftyLOMYiemJ5o4ihDAD+fQUQtzVttPbyC3MpVPdTuaOcl/r7tcdGwsblhxdYu4oQggzkKJLCHFXMSkxOFg50NKzpbmj3NecrJ3o5NuJlckruWq4au44QogqJkWXEOKOirQi1p5cSzvvdlhbWJs7zn2vb4O+ZORnsD51vbmjCCGqmBRdQog72nN+D+l56XTylVuLptDaqzUedh4sSZJbjEI8bKToEkLcUczJGCyVJe182pk7ygPBQmdB74DebEzdyMW8i+aOI4SoQlJ0CSHuKDYllgjPCGpY1zB3lAdG3/p9KdQKWXFshbmjCCGqkBRdQojbOpZxjOQryXSs29HcUR4oDVwb0KRmE5YmLTV3FCFEFSpT0aWU6qGUOqSUOqqUeuMW+59XSu1VSu1SSm1USjUpse/v1847pJTqbsrwQojKFZMSA0BHXym6TK1PQB8OXDzAscvHzB1FCFFF7lp0KaUsgKlAT6AJ8GTJouqaOZqm6TVNCwU+Bj69dm4T4AkgGOgBfH2tPSHEfSD2ZCxNajbB08HT3FEeOD38e6BTOpYfX27uKEKIKmJZhmNaAkc1TTsGoJT6GegH7L9+gKZpV0oc7wBcX+OiH/Czpmn5wHGl1NFr7W0xQXYhRCU6n3OePef3MDZ0bKW0X2Ao4viFbJLOZZFbYOBqYRFXDUUYijTcHKzxcLTBw8mGWjVscbazqpQM5uRu506kZyQrjq1gbOhYWURciIdAWYoub+BkidepQOSNByml/gq8ClgD158t9wa23nCud7mSCiGq1NrUtQAmm4W+wFDEhiPnWbXvDIlpVzhyNourhqIynVu7hg2NvWoUf4XXc6WOi51JcplTr4BevLXpLfZc2EMzj2bmjiOEqGRlKbpu9c+vm1Zr1TRtKjBVKTUEeAsYUdZzlVKjgdEAdevWLUMkIURli0mJwcfRhwYuDSrUTmJaBgsTTrF09ykuZF3F2c6Kpj7OPN3Wj0ZeTgTWcsLJ1hIrCx3Wljp0SnEx+yrnM/M5n5VP2uVcDp3J5MDpK2w6eoECg/EjxMfVjpZ+brT0d6NdoDs+rvameNtVqnPdzry39T2WH1suRZcQD4GyFF2pgG+J1z5A2h2O/xn45l7O1TTtO+A7gPDw8JuKMiFE1couyGbb6W082ejJct/2SknP4Z8rDrAq8QxWForOjWozsLk30Q1rYW155+Gkbg7WNKjleNP2q4VFHD6bSVzyRbYfv8j6I+f5decpAAI8HOgQ6EFUQw9aB9TE1qr6Dx91tHYkyieK35J/Y3zEeCx1ZflIFkLcr8ryX3gcEKiU8gdOYRwYP6TkAUqpQE3Tjlx72Qu4/vNSYI5S6lOgDhAIbDdFcCFE5dl4aiMFRQXlemoxO7+Qr9ceZdqG41jqFH/rGsSwVvVwdaj4EkLWljpCvJ0J8Xbm6bb+aJrG0XNZrD9ygfWHzzN3ewozNydjb21BVJAH3YJr06lhbZztq++YsEcCHuH3E7+z9fRW2nnLBLRCPMjuWnRpmlaolBoL/AZYAD9ompaolJoMxGuathQYq5TqAhQAlzDeWuTacb9gHHRfCPxV0zRDJb0XIYSJxKTE4GrjSmit0Hs6b3PSBV6Zt4uzV/IZGObN+B6N8HS2raSUoJQisLYTgbWdeKadP3kFBrYcS2f1/rP8sf8sK/edwVKniAryoH+YN10a18bOunr1gLX3bo+TtRMrjq2QokuIB5zStOp1Ny88PFyLj483dwwhHloFRQVE/RxF53qdea/te2U6R9M0ftiUzD9XHMCvpj3/HtyM5nVdKznpnRUVaew5lcHKvadZsiuNM1fycLC2oKfei6da16Opj4tZ85U0afMkVh5fydrH12Jnef8/ICDEw0QplaBpWnhZjpUBBEKIUuLPxJNZkFnmW4t5BQb+sWgvv+44RbcmtfnksWY42Zr/dp5Opwj1dSHU14UJPRqx7fhFFu88xfK9p1mQkEp4PVdGtfOnW5PaWFqYd3GOXgG9WHhkIetOrqOHfw+zZhFCVB5ZBkgIUUrsyVhsLWxpXaf1XY+9kJXPY//Zwq87TvFKlyC+HdaiWhRcN9LpFK3r1+SjQU3Z8vdOTOzdhHOZ+YyZvYOof6/l1x2pFBWZr9e/Re0W1LKvxfJjMlGqEA8yKbqEEMU0TSP2ZCyt67S+622uyzlXGTZ9G4fPZvLd8Ba83CUQna76T/DpZGvFqHb+xL4WzXfDW1DT0ZpXf9nNgK83EZ980SyZdEpHd7/ubErbxJWrV+5+ghDiviRFlxCi2IGLBziTfeauE6JeyStg+PfbOXYhm+lPRdAt+P5bJshCp+gW7MniMW359LFmnL2Sz6Bvt/DXOTtIz8qv8jw9/HpQUFRAbEpslV9bCFE1pOgSQhSLSYlBp3RE+UTd9pjs/EKenhHHwTNX+HZYc9oFuldhQtPT6RQDm/sQ81oU47oE8sf+szzyxQa2H6/aXi+9ux5vR29WJa+q0usKIaqOFF1CiGKxJ2MJqxWGq+2tnzzMKzDwzI9x7Dp5mS+eCKNTo9pVnLDy2FtbMq5LEIvGtMHOyoInp23l67VHq2ysl1KKbn7d2Jq2lct5l6vkmkKIqiVFlxACgJOZJzl86TCdfG99a1HTNN5avI+txy7yyeBm9NR7VXHCqhFcx5n/vdiOHiGefLzqEM/8GEdWfmGVXLu7X3cKtUJiTsZUyfWEEFVLii4hBEDxWKKOdW89VcTsbSksSEjlpU4N6B/2YK9b72RrxVdPhvFev2DWH7nAiB+2V0nh1cStCb5Ovqw6LrcYhXgQSdElhACMtxYDXQPxdfK9aV/CiUu8+79Eoht68HKXIDOkq3pKKYa39uOrJ8PYdfJylRReSil6+PVg+5ntXMwzz5OUQojKI0WXEIJLeZfYcW7HLSdEPZeZx5jZCXg52/HZ46FY3AfTQphST71XceE1sgoKr+5+3TFoBlafWF2p1xFCVD0puoQQrE9dT5FWdNNUEQWGIsbO2UlGbgHfDmuBi33FF62+H/XUe/Hlk2HsvFZ45V6tvCVkg1yD8Hf257fk3yrtGkII85CiSwhBTEoMte1r08StSantX8cmsf34Rf41sClN6tQwU7rq4RG9F188EUZCyiXeXrKPylq3VilFd7/uxJ+N50LuhUq5hhDCPKToEuIhl1uYy+a0zXT07YhSf9463Hcqgy9jjtAvtM4DP3C+rHo19eLFToEsSEjll/iTlXadHn49KNKK+D3590q7hhCi6knRJcRDbmvaVvIMeaVuLeYXGvjbL7txc7Dm3b7BZkxX/bzcOZB2Ddx5e0kiiWkZlXKN+i71qe9cn9UpMq5LiAeJFF1CPORiT8biZOVEuGd48bbPVh/h0NlMPnq06UM7jut2LHSKz58Ixc3emhf+u4OM3IJKuU6Xel1IOJsgTzEK8QCRokuIh5ihyMDak2tp79MeK50VADtSLvGfdUk8Fu5Dx0a1zJyweqrpaMPUoWGkXc7ltfm7K2V8V5d6XSjSilh7cq3J2xZCmIcUXUI8xHad38Wl/EvFE6LmFRh47ZfdeDnb8XbvJnc5++HWop4bb/RsxB/7z/LrjlMmb7+ha0N8HH3448QfJm9bCGEeUnQJ8RCLTYnFSmdFuzrtAJgae5RjF7L56NGmONlamTld9TeqrT9hdV34cOUBk99mVErRpV4Xtp7eSubVTJO2LYQwDym6hHhIaZrGmpQ1RHpF4mjtSNL5LP6z7hgDwrxpF+hu7nj3BZ1O8V6/EC5mX+WT3w+ZvP0u9bpQWFTIutR1Jm9bCFH1pOgS4iF1+NJhUrNS6VK3C5qm8c6SRGysdPz9kUbmjnZfCfF2Znirevx36wn2nTLt04x6dz217Gqx5sQak7YrhDAPKbqEeEitTlmNTumI9o1m2Z7TbDx6gde7N6SWk625o913Xu3WEDcHG95avI+iItMNqtcpHZ3qdmLjqY3kFOSYrF0hhHlI0SXEQ2pNyhrCaoVhrWrw3rL9hHjXYGhkPXPHui8521nxj0casevkZeaZeNLUrvW6kmfIY3PaZpO2K4SoelJ0CfEQSrmSwpFLR+hctzP/98cRzmfl835//UO3mLUpDQjzpqW/Gx+tOsjlnKsma7d57ea42LjIRKlCPACk6BLiIbQmxThGqJ5tJDM3H2dIy7qE+rqYOdX9TSnFpD7BXM4p4IeNx03WrqXOkk51O7Hu5DquGkxXzAkhqp4UXUI8hFanrKaxW2O+WX2RGnZWvN69obkjPRCa1KlBj2BPZmxKNukUEp3rdiarIIttp7eZrE0hRNWzNHcAIUTVOpdzjj3n99CjzkjmH0tncr9gWerHhF7s3IBViWeYsek447oE3XsDBXlwbj9cOg5X0iDzDJEFOdhhwbpN/6R9rQ7g4A6u/uAZAo61QcltYSHuB1J0CfGQiUmJAWDzHi+CajsypGVdMyd6sATXcaZrk9r8sPE4o9r5U+Nuk8xmnYPj6yF5A6TGw7kDoBn+3G9ph42VLW1d7FlrSOHNdf+iVInl4AH12kBANNTvDK7yMIQQ1ZUUXUI8ZNakrMHF0puT52vw0zNNsLS4D0cZaBpoRcbvOotq19PzcudAeu8/y4+bknmxc2DpnUVFkLYDDq+Cw7/BmT3G7dZO4NsSgnqAV1Oo2QBqeIOtMyhF1NHFrN70Ngf/uonGtu6QfhTO7IPTu4xF2/4lxnZ8IkA/GIIHgqNH1b5xIcQdSdElxEMkIz+D7WfiMFzsQJfGtWkfWE3+p5x7CdKPwcUkuHgMLp+E3IvG7TnXvuddBkMBcMM8WEoHNk5g42z8blsDbF2gRh1w9vnzq4a38cui8j/2Qryd6dyoFtM3Hufpdv44FlyC4+vg6Bo48jvkXDDm9o2EzhPBPxq8mt0xW3vv9igUa9M20LjZC+DkCX7G5ZvQNGMRdnA57F0AK8fDqr8be7/0g6FJX7B2qPT3LYS4M6VpppvIzxTCw8O1+Ph4c8cQ4oG05OgS3tr0FvknxvLbmGH4u5vhf8RXTkNq3LWveDh/0FhgFVPGgsK+Jti5Gr/s3YyFlIW1sVdL6YzHKQWGq5B3BfKv/Pk99xJcOWX8XpLOElzqQc364BZw7as+uPmDS12wMNF6k/lZHEv4g9Ur5jPQ+Qju2YeN221dILArBHaHBp2N7+seDFsxjIKiAub1nnfnA88dgD2/GAuwjBSwqQFNH4MWI8FTX773JIS4JaVUgqZp4WU5Vnq6hHiILDi4nKICF55q3q7qCq6sc8benaNrjIVWxrXJQy2sjb07TfoaC5+a9Y3fXf3AykSz4l/NhoxTxmtmpMKl5D97005shqtZfx6rLIyFV6mCLACcfcHOxVi4WJbIdTUT8jIgOx0uJ8OlE8YC8vQeuHCYAM3A05ZW7MhuSI2oN7EO7HzX3qy7ifaN5vMdn3Mu5xy17Gvd/sBajaHLO9DpbUjZAjt+hB0/Qdx08A6H8KcheID0fglRxcrU06WU6gF8DlgA0zVN+9cN+18FngUKgfPAKE3TTlzbZwD2Xjs0RdO0vne6lvR0CVE5Luddpv3PUegyO7DhuU/vPsC7vDQNTu82jlc6vMo4fgnAyQvqtjaOOfKJMI5bsrSpnAxlzZl9HtKvFWHFX0lw8bixx+xeOXkZCyvPplCvDQlaQx6dvpP3+4cwrFXFB7gfvXSUAUsHMLH1RAYHDb63k3Muwu6fIWEGXDh8rffrcWMBVju4wtmEeFiZtKdLKWUBTAW6AqlAnFJqqaZp+0scthMI1zQtRyn1AvAx8Pi1fbmapoXe0zsQQpjcZ1sWgSriKX3/yim40pNgzzzYPRcupwAKfMKh01vG22me+uo14F0pcKxl/KrXuvQ+TYOcdGMRlnHSeNsyL6P0mDJrR+Mgd3s3Yw+ZS13jmLISmmsaTbyS+GnLCYZG1kVV8P3Xd6mPt6M3606uu/eiy94NWo+BVi8Ye7/iZ8COWRA3zVgEt7je+2VfoYxCiNsrSz93S+CopmnHAJRSPwP9gOKiS9O02BLHbwWGmTKkEKJi8goMLD6yAgtLd15u39F0DedehsRFxh6Uk1sBZRy8HTXBWGjdr0/PKWWcC8vB3fhEYbmbUTzVuh5v/LqX7ccvEhlQs4KxFB19OzL/8HxyC3Oxs7QrTyPGKSbqtYGeHxmL5PgZsGSMcfB9s8eNBVjtJhXKKoS4WVmeFfcGSq7gmnpt2+08A6ws8dpWKRWvlNqqlOpfjoxCiAr6MnYXhdaH6Vqvm2mmiDh/CP43Dj5pBMvGGQesd5kEryTCU4shbNj9W3CZWL9Qb2rYWjJr6wmTtBflG0W+IZ+taVsr3pi9G7T+K4yNg5ErIKgbJMyEb1rDjEcgeWPFryGEKFaWnq5b9YffciCYUmoYEA5EldhcV9O0NKVUABCjlNqraVrSDeeNBkYD1K0rEzUKYUpnMvKYsft/WNQq4pmwAeVvqKgIkmJg69eQtAYsbK71ioyEOs2r163DasTO2oLB4b78uDmZc1fyqFWjYg8JtKjVAkcrR9alrqNjXRP1WioFfm2NXz0+gt1zYMtUmNnL2HPZ7X156lEIEyjLP3lTAd8Sr32AtBsPUkp1Ad4E+mqaln99u6Zpade+HwPWAmE3nqtp2neapoVrmhbu4SH/OhbClD5edRDluBtvh7o0dC3HGouGQtg1B76OhNmPwtlE4zitV/dD3y/Bu4UUXHcxrFU9Cos05mxPqXBbVhZWtPNux9qTaynSikyQ7gYONaHNi/DSTuj2AZzZC99FQ+yHUCgLbgtREWUpuuKAQKWUv1LKGngCWFryAKVUGPAfjAXXuRLbXZVSNtd+dgfaUmIsmBCicu1IucSiPQexsE+iV/0e9zaQ21BoHKs1tSUsfsH4pOGA72DcXujwunG8kygTf3cHOgR5MGdbCgWGihdKHXw6kJ6XzoH0AyZIdxtWdtBmLIyNN85uv+5fMK2T8clOIUS53LXo0jStEBgL/AYcAH7RNC1RKTVZKXV9+od/A47AfKXULqXU9aKsMRCvlNoNxAL/uuGpRyFEJTEUaby9eB+utQ6iodHDr0fZTiwywO55xp6tRX8BK3t4fDb8ZYPxdqKlLI5dHiNa1+NcZj6/J56tcFttvduiUGxK22SCZHdh7waPToMn5sCVVPi+K6TtrPzrCvEAKtMsfZqmrQBW3LBtYomfu9zmvM2ADAQQwgxmbztBYtoVmkYcRmdRn0DXwDufUGSAfb/Cuo8g/QjUDoHH/wsNe4HuPlyfsZqJblgLH1c7Zm1JpldTrwq15WbrRpOaTdh4aiOjm442TcC7adQLagbCfx+FGb3g8VnQ4JYf/UKI25BPUiEeQOcz8/n3b4eIbGBJctY+uvt1v/3BRQbjcjFft4ZfnzUuhfPYLGPPVuM+UnCZiIVOMaxVPbYdv8jRc5kVbq+td1t2n99NRn6GCdKVkUcQPPO7cab+uUOMyzgJIcpMPk2FeAB9uPIAeQUGWupPGG8t+t/i1mKRAfYthG/awMJnjOsZDp4Jz2+CJv2k2KoEA5t7Y6FT/LrjVIXbaufdjiKtiG2nt5kg2T2o4QVPLTGuj/nzEOMyS0KIMpFPVSEeMNuPX+TXHad4tn0Am8/+RlP3pvg7+/95gKEAds6GqZGwYJRx26AZ8MJm44zkUmxVmlpOtrQPdGfxzlMUFd19CbY70bvrcbJ2qppxXTdyqAlD5sHVHPj5SeMal0KIu5JPVyEeIIWGIiYu2UcdZ1u6hxk4fOkwfer3Me4syIXt0+CLMOPs41a2fxZbIQOl2KoiA5v7kJaRx9bj6RVqx1JnSWuv1mw8tZGyrKFrcrUaw6DvjQt8rxxf9dcX4j4kn7JCPEC+XZfEwTOZTOzThD9SVmCps6RHzVBY+xF81hRWvAY16sCQ+cYxWyEDQWdh7tgPlW5NauNoY2myW4zncs5x9PJREyQrh6Du0G4c7PyvzF4vRBlI0SXEAyIxLYPP1xyhd1MvujRwYPnhX4nCHpev28DafxpnFB+5HEb9ZlzuRSY0NQtbKwse0Xuycu9pcq8aKtRWmzptANh0ygy3GK/rMB5c6sGyV6Aw/+7HC/EQk6JLiKpgKIQracZbMcfWGr+SN0FqgnGyyfxMqMAtovyCQv5v7nJG2cTyKZ+yZaqe9MIs+lw8b5zg8sUdMPxX8GsnxVY1MLC5D9lXDfy+/0yF2qntUJtA10A2ppmxl8naHnp9ChcOw6YvzJdDiPtAmebpEkKUw5l9sH8xpGyFUwlQkHPn4y1sjLO829e89t29xGsPsHYwFmZaEeRlQPZ5yDwN5w+hnd7PdEOWsZ3TdfhfnQa4FGXT4YXtYG1X+e9V3JOWfm54u9ixcMcp+oV6V6itdnXa8d8D/yWnIAd7K3sTJbxHgV2MD2Gs/zfoHzVOKSGEuIkUXUKYkqbBgaWw7T9wYhMoC/AMgbDh4NHQWDzZuwEKigqNg9tz0iHnAmRfMP6cfcH4Ov0oZKdDwe2eDFNgX5PMGgEsudoKW59QBg0aQqajBzHzOzEwcCBWUnBVSzqdYkCYN1+vPVrhRbDberdlRuIMtp/ZTrRvtOlC3qvuH8KhlbDhE+g31Xw5hKjGpOgSwlQun4SlY423Dl3qQrf3IXTotSKrAgpyjYVYQY5xLi2lA5saYO9GbiH0+3IDefYGVo3oALZW/H54IfmGfPrW73v3toXZDGjuzVexR1myK43nOpS/ZyisVhh2lnZsPLXRvEVXDS9oPgLiv4eoN8DF13xZhKimZEyXEKaw+2fjJKMn44zjW17aBW1erHjBBcaFh118jT1l7oFQsz44eqApHa8t2M3xC9n8e3AzathaAbA0aSn+zv4E1wyu+LVFpanv4UgzXxcW7kitUDvWFtZEekaadzD9dW1fAhRs+tzcSYSolqToEqKiNn9pXBjaUw9jNkPEM1UyDcPU2KMs33OaCT0a0baBOwAnrpxgx7kd9K3fFyUD5qu9gWHeHDyTyaEzFVsWqFWdVqRmpZKaWbECrsKcfaDZE7BjFmRWfGFvIR40UnQJUREbPoHf34Im/Y1Lo7j6Vcllf088w5TfDzMgzJu/lLg1tfDwQiyVJf3q96uSHKJiHtF7oRQs33u6Qu208moFUPVLAt1Ku1egqAC2fGXuJEJUO1J0CVFem7+ENZNBPxge/d64UHQVOHjmCq/M20UzXxc+HKgv7tG6arjK4qOLifaNxsPeo0qyiIrxcLKhpZ8bKypYdAU4B+Bh51E9iq6a9SHkUYj73jgVihCimBRdQpTHic3wx0Ro3BcG/AcsquaZlLNX8nhuVjwONpZ8N7wFtlZ/3saMSYnhUv4lBgUNqpIswjR6NfXi6Lksjpwtf4GilCLSK5JtZ7aZZ0mgG7X8i/Gp28RF5k4iRLUiRZcQ9yrrvHGhaFd/46PxVbSMTvKFbB79ZjMXs67y3VPh1L5hmoH5h+fj7ehN6zqtqySPMI0ewZ4mucUY6RXJxbyLHLl8xETJKsAnHNwbGpcHEkIUk6JLiHtRVASLRkPORRg8E2xrVMllD5y+wqBvt5CdX8jc0a0I9XUptT85I5ntZ7bzaOCj6JT8Z30/qVXDloh6Fb/FWK3GdSkFYcPg5DY4f8jcaYSoNuTTWYh7kTADkmKgx4fg1bRqLnniIo//ZwuWOsX851vT1MflpmMWHjEOoB8QOKBKMgnTekTvyeGzWRw9V/5bjJ4OntSrUa96FF1gfIpRZym9XUKUIEWXEGWVewli3od67SB8VKVfrqhIY9aWZIZO34abgzULXmhNg1pONx131XCVJUeXEO0bjbude6XnEqbXU+8FwIq9FVuLMdIzkrgzcRQUFZgiVsU41oKgHsY57AzVII8Q1YAUXUKU1bqPjYVXjw8rfdHo4xeyeeK7rUxckkiEnxvzn2+Dj+ut19Vbk7KGS/mXGBw0uFIzicpTu4Yt4fVcK3yLMdIrkpzCHBIvJJooWQWFDYPsc3Dkd3MnEaJakKJLiLI4fwi2fwctRlTqbcW8AgP/WZdEj8/Wc/DMFT4e1JRZo1ri4WRz23OuD6BvVadVpeUSle8RvRcHz2SSdD6r3G209GyJQrH19FYTJquABl3BsTbsmmPuJEJUC1J0CVEWv70JVg7Q6e1Kaf5MRh7//u0grT9cw4crD9IhyIM/Xo3isXDfO84sf/jSYeLOxDE4aLAMoL/P9dR7ArCyAr1dLrYuNHJrVH3GdVlYQpN+cHQNXM0xdxohzE4WvBbiblIT4Ogf0HUyOJhuzFRGTgEbjp5n1b4zrNp3BoOm0bVxbZ5u60+rALcyLeMz9+BcbCxseDTwUZPlEubh5WxH87ouLN97hrGdAsvdTqRXJLMPzCa3MBc7SzsTJiynRr2NvcRJa6BxH3OnEcKspOgS4m42fw62zhUePK9pGgdOZxJ76BzrDp0nIeUShiINF3srRrTxY0RrP+rWvPW4rVvJyM9gWdIyegX0wsX25icaxf3nEb0X7y8/QPKFbPzcHcrVRiuvVsxMnMnOsztp493GxAnLoV5bsHOFA/+Toks89KToEuJO0pNg/1Jo/yrY3Pzk4N3kFRhYe+g8aw+dI/bQOc5eyQcgxLsGY6LrE92wFqG+Lljo7n1g/qIji8gz5A3CAqUAACAASURBVDGk0ZB7PldUT92DPXl/+QH+2H+W50qsqXkvwmqFYamzZOuZrdWj6LKwhKCecGi58SnGKlouS4jqSIouIe5ky1dgYW1c1qSMCgxFbDxygaW70/g98QzZVw042f4/e/cdHmWVNn78e2bSQxISSC+0JBBqgEBAUEBAwQXbiqCo2BXXteyrru9PX9fuqruLa1m7IipidwULgrD0EnoLgRBCSEJI733m/P6Y4CJSkimZmeT+XFeuCTPPc557Lghz55z7uY8HFySEMr5vKOP6hhIW4HPugc7CZDaxKGMRw8OH0zekr01jCdcRG+JHv4gAftpXYHXS5efpx5DQIWzM3wjD7RygtZKmwc6FkL0G+lzo7GiEcBpJuoQ4k+pC2P4xJF8DAeHnPryhmQ/WZ/Pe2sOU1DQS6OPBtMFRTB8SRWrvEDyN9it0X5W7irzqPP40/E92G1O4hosGRPDqioOUVDfQrcuZ71o9m9TIVF7f8ToVDRUEeQfZOUIr9LkQPP0gfYkkXaJTk9udhDiTzW+BqRFG//Gsh1XVN/HaykzGPr+CF5dmMCgmiHduSCHt0Uk8f9VgxiZ0t2vCBbBw/0LC/cK5ME4+wDqai/qHY9bw8/5Cq8cYFTkKjWZzwWY7RmYDT1+Inwj7v7NspSVEJyVJlxCnY2qGbR9C4sXQPf6Mhy3emc8FL6zkxaUZDIsL5ps/jGH+TSOZ1D8cbw/HbISdWZbJpmObmNVvFh4GmazuaAZEBRIV5MOyfcetHmNg94H4efi5TusIgKRLoboA8rY4OxIhnEb+xxbidA79bPmAGHrdaV+uqG3isW/38O8d+QyJ7cr8mwYwJLZ97iBcuH8hXgYvaRPRQSmlmNw/nE+3HKWu0YSvV9uTd0+DJ8PDh7tW0pVwESiDpTt97EhnRyOEU7RqpkspNUUplaGUylRKPXya1/+klNqnlNqllPpZKdXjpNfmKKUOtnzNsWfwQjjM9o/ArxskXPybl9ZnFjPln6tZsusYf5qcyJd3jm63hKusvozFhxYzrc80gn2C2+Waov1N7h9BfZOZNQeLrB4jNTKV7MpsCmps28/Rbny7QvRwOLTS2ZEI4TTnTLqUUkbgNWAq0B+4RinV/5TDtgMpWuvBwBfACy3nhgB/AVKBkcBflFLySSFcW00JZPwAg2eCh9evXvpgfTaz392Er6eRr+aexz0TE/Cwc73W2Xx+4HPqTfVcn3R9u11TtL/U3iEE+HjYtMQ4KtKyLZRLzXb1ngD52yx7mArRCbXm02IkkKm1ztJaNwKLgMtOPkBrvVJrfWKPh41ATMv3FwPLtNalWusyYBkwxT6hC+Eguz8Hc9Ovlha11ry4dD9/+XYvk5LC+e6e89ttduuERlMjn+z/hDHRY4gPPnOdmXB/nkYDE/qGsWJ/ISaztmqMhOAEgr2DXWcfRoA+E0Cb4fAaZ0cihFO0JumKBo6e9OfclufO5BbgByvPFcL5tn8EkckQPgCAZpOZh77YxWsrD3HNyDhenz3MqjobW/1w+AeK64q5of8N7X5t0f4uGhBOSU0j23KsmxUyKAOpkalsOrYJra1L3OwuZgR4dYFDK5wdiRBO0Zqk63Stsk/7E6yUug5IAV5sy7lKqduVUluUUluKiqyvYRDCZsd2wvHdv8xy1TeZuOPDrXy+NZd7Jybw7BUD23U58QStNQv2LSC+azyjI0e3+/VF+xuXGIqnUfHTXutrslIjUymqK+JwxWE7RmYDoyf0PB+ypK5LdE6t+fTIBWJP+nMMkH/qQUqpScAjwKVa64a2nKu1fktrnaK1TgkNDW1t7ELY356vwOABA39Ps8nMvYu28/P+Qp66fCD3T05s1SbUjrCpYBMHyg5wQ/8bnBaDaF8BPp6M7tOdZfuOWz1TlRqZCuB6S4xl2VDqIomgEO2oNUlXGpCglOqllPICZgHfnnyAUmoo8CaWhOvkjn5LgYuUUsEtBfQXtTwnhOvRGtK/hZ7no32D+X9f72bp3uP8ZXp/rh/V49znO9CCvQvo5tON3/X+nVPjEO1rcv9wsktqySystur82IBYortEu1Yx/YmO9DLbJTqhcyZdWutm4G4syVI68JnWeq9S6kml1KUth70IdAE+V0rtUEp923JuKfAUlsQtDXiy5TkhXE/hPijNgv6X8tcf9vPZllzumZjATWN6OTWsrPIs1uStYVa/WXgZvc59gugwJiWFAbA83fru9KmRqaQdT8NkNtkrLNt0i4fAGGkdITqlVhWnaK2/11onaq37aK2faXnuMa31ieRqktY6XGud3PJ16Unnvqe1jm/5et8xb0MIO9j3LaCYXzKAN1dnccPoHtw/KcHZUfFh+od4G725uu/Vzg5FtLPIIF8GRgfyc7r1rSNSI1KpaqwivTTdjpHZQCnoMx4OrwJXSQSFaCeyDZAQJ6QvpqTbMB5fWcylQ6J4fPoAp9dPldaXsvjQYqb3mU6IT4hTYxHOMbFfONtyyiipbjj3wacxMtLS/d2l6rp6jYf6CijY7exIhGhXknQJAVByCAr38mbRAFJ6BPO3GUMwGJxfsP5pxqc0mBqkGWonNinJsgH2ygzr7uzu7tudhOAE10q6erTcgZuzwblxCNHOJOkSAqjZ8RUAm7zH8K/rhuHl4fwfjQZTA4v2L+L86PPp3bW3s8MRTjIwOpDwQG+blxh3FO6gwWTdbJndBcVA1zg4st7ZkQjRrpz/ySKEkzWZzBzb+Bm7dB+emjOFsAAfZ4cEwPdZ31NaX8oNA6QZamemlGJiUjirDxTR0GxdDdSoyFE0mBrYUbjDztHZIO48y0yXqzRuFaIdSNIlOr2Xv15NfNMBDP2nMzimfbf2OZMTzVATgxNJjUh1djjCySYlhVHTaGJTlnU3fw8PH45RGV2rdUSP0VBTZFnaF6KTkKRLdGqfbTlKwfbvABg4boaTo/mvDfkbyCzPlGaoAoDz+nTHx9PAciuXGLt4dWFQ90GuVdcVd57l8cg658YhRDuSpEt0Wttzynj06z38PjAdHRD5y16LrmDBvgV09+3O1F5TnR2KcAE+nkbGxofyc3qhTd3p95bspbKx0s7RWal7Avh1l2J60alI0iU6pcLKeu78aCtRgR6MNO9CxU+09A9yAQfLDrIufx3X9LtGmqGKX0zuH0ZeeR37C6qsOj81MhWzNrOlYIudI7OSUhA3SorpRaciSZfodBqaTdzx0VYq65qZf5ERQ0MFxE9ydli/+Cj9I3yMPsxIdJ3lTuF8E/pZutNbexfjkNAh+Bh9XKyuawyUH4HK32zJK0SHJEmX6FS01jz2zV6255Tz96uH0LNsPSgj9J7g7NAAKK4rZsmhJVza51KCfYKdHY5wIWEBPgyJ7coyK7cE8jJ6MTx8uIslXS39umS2S3QSknSJTuXDjUf4dMtR7p4QzyWDIiFzOcSMAF/XuGvxs4zPaDQ3cl3/65wdinBBk/qFsfNoOYVV9VadnxqZyqGKQxTWWr+Xo12FDwKvLlLXJToNSbpEp7Exq4QnF+9jYr8w/jQ5EaqLIH+7yywt1jfX82nGp4yLGUevIOdusi1c06T+4QCs3G9d0pQaaWk/4jKzXUYPyy89OS50V6UQDiRJl+gUcstquevjbcR182PerGTLFj9ZKy0vJrhG0vVd1neWZqj9pRmqOL1+EQFEd/VluZVLjP1C+hHkHeQ6SRdA7Ego3AcN1c6ORAiHk6RLdHh1jSbu+HArTc1m3r4hhUAfT8sLmcstt6xHDHFugPy3GWq/kH6MiBjh7HCEi7J0pw9jzcEi6pva3p3eoAyMjBjJpoJNVreesLvoFNBmy6yzEB2cJF2iQ9Na8+cvd7HvWCUvXzOUPqFdTrwAWf+B3uPB4Pwfg3X568iqyJJmqOKcJiaFU99kZv2hYqvOHxU5ioKaAnKqcuwcmZViUiyPeS7SykIIB3L+p40QDvTyz5l8uzOfBy7q+8st9wAUH4Tq49DrfOcFd5IFexcQ5hvGlJ5TnB2KcHGjeofg72W0eolxVOQoANbnu8gdg34hENIHciXpEh2fJF2iw/pmex7zlh/gymHR3DW+z69fzF5teezp/KQrozSDDcc2cE3SNXgaPZ0djnBx3h5GLkgM5ef041YtEcYFxhEbEMv6PBdJusAy25WbJptfiw5Pki7RIW0+XMpDX+witVcIf71y8G+X7A6vgcBoCOntnABPsmDfAnw9fKUZqmi1iUnhHK9sYE+edVv6jIkaw6aCTTSaGu0cmZViRlhmnitynR2JEA4lSZfocA4X13D7h1uICfblzeuH4+Vxyj9zrSF7rWWWy8n1UwU1BXyf9T1XJlxJkHeQU2MR7mNC31CUwuoNsMdEj6GuuY7thS5SvH6iris3zblxCOFgknSJDqW4uoGb56dhUIr3bxpBV7/T7F1YmA61xS5Rz7Vw/0LMmLkuSZqhitbr1sWb4XHB/LzfuqRrZMRIPAwerMtbZ+fIrBQ+EDx8pK5LdHiSdIkOo7y2keve2cSxijreun44Pbr5n/7A7DWWRyfXc1U3VvN5xudM7jGZmIAYp8Yi3M/EpHD25FVyrKKuzef6efoxPGw46/JdJOkyekJkstzBKDo8SbpEh1BV38Sc9zaTVVTD2zekkNIz5MwHH14NXeMguEf7BXgaXx38iuqmam4ccKNT4xDuaVLSiQ2wrbuL8bzo8zhQdsB1tgSKSYH8HdDsInVmQjiAJF3C7dU2NnPz/DT25lfyr9nDOD8h9MwHm81wZB30vKD9AjyNJnMTH6V/REp4CgO7D3RqLMI9xYd1IS7Ej5+treuKGgPgOkuMMSlgaoDju50diRAOI0mXcGt1jSZuX7CVrUfKeGlW8i97053R8T1QV+b0eq5l2cs4VnNMZrmE1ZRSTEoKZ92hEmobm9t8fmJwIqG+oa6zxBjTshND7lbnxiGEA0nSJdxWWU0js9/ZyLpDxbxw1RCmDY4690nZay2PTqzn0lozf+98egX14vwY5xfzC/c1KSmMxmYzaw+2vTu9Uorzos5jQ/4GTOa2bylkd4HR4B8m2wGJDk2SLuGW8svrmPHmBvbkVfKva4dx1fBWFqLnbICuPSAo2rEBnkVaQRrppenM6T8Hg5IfQWG9Eb1CCPDxsLp1xNjosVQ2VrKnZI+dI7OCUhCVLEmX6NDkf3zhdg4cr+L3r6/neEU9H9w8kqmDIlt3otaQsxHiRjs2wHOYv3c+IT4hTOszzalxCPfnaTQwLjGUFfuLMJvb3s19VOQoDMrgOnVdUUOhOAMaa5wdiRAOIUmXcCurDhQx440NNJs1n94xmtF9urX+5NIsqCmEuFGOC/AcMssyWZO3hmv7XYu30dtpcYiOY3L/cIqrG9iZW97mc7v6dGVg94Guk3RFJoM2Q4ELzLwJ4QCSdAm3YDZrXvn5IDe+v5nIIB++mnse/aMC2zZIzgbLoxNnuhbsW4CP0YeZfWc6LQbRsYxPDMNoUFa3jhgTNYbdxbspqy+zc2RWiEq2PMoSo+igJOkSLq+ironbFmzh78sOcNmQKL6+awyxIX5tHyhnA/gGQ/dE+wfZCkW1RSzJWsLl8ZfT1aerU2IQHU+QnycpPYKtrusaFzMOjWZ17mo7R2aFgEjoEg7Hdjg7EiEcQpIu4dK2Hinl0lfXsupAEU9eNoB5M5Px9TJaN1jORogdBQbn/LP/ZP8nNJubuaH/DU65vui4JiWFs7+gityy2jaf279bf8L9wlmRs8IBkbWRUpYlRpnpEh1Uqz59lFJTlFIZSqlMpdTDp3n9AqXUNqVUs1LqqlNeMymldrR8fWuvwEXH1tBs4q8/7LfUb5k0n94xihtG90RZu0F1dRGUZEIP5ywt1jbV8mnGp0zqMYnYwFinxCA6rhP96axZYlRKcWHchazPX09dc9u3FLK7qKFQfAAaqp0diRB2d86kSyllBF4DpgL9gWuUUv1POSwHuBFYeJoh6rTWyS1fl9oYr+gE9uRVcOkr63hj1SFmjohl6f0XMLzHWbb1aQ0n13N9nfk1lY2VzBkwxynXFx1br+7+9A71t3qJ8cK4C6k31bMhf4OdI7NC1IlieulMLzqe1sx0jQQytdZZWutGYBFw2ckHaK2ztda7ALMDYhSdRJPJzD+XH+Ty19ZRVtvI+zeN4LkrB9PF28P2wXM2gocPRA6xfaw2ajI1MX/vfIaGDWVIaPtfX3QOk5LC2ZhVQlV9U5vPHR4+nACvAH7O+dkBkbVRZEsxvdR1iQ6oNUlXNHD0pD/ntjzXWj5KqS1KqY1KqcvbFJ3oNA4cr+LKf61n3vIDTBscyU/3X8CEvmH2u0DOBogeDh7t36ZhSdYSCmoKuG3Qbe1+bdF5TOwXRpNJs8aK7vSeBk/GxYxjVe4qms1t31LIrgIjoUuEZfNrITqY1iRdpyuiaUsXvjitdQpwLfCSUqrPby6g1O0tidmWoqKiNgwt3J3JrHlz1SGmvbyWvPI6Xp89jJdmDaWrn5f9LtJYA8d2OqU/l8ls4t0975IUksTY6LHtfn3ReQzvEUxXP0+blhgrGirYXugCRezSmV50UK1JunKBkyt/Y4D81l5Aa53f8pgF/AcYeppj3tJap2itU0JDQ1s7tHBz2cU1XP3mBp77YT8T+oXy0/0XtL67fFvkbQNtgthU+499DsuOLONI5RFuG3yb9TcBCNEKHkYDE/qGsXJ/ISYrutOPiRqDt9HbNe5ilGJ60UG1JulKAxKUUr2UUl7ALKBVdyEqpYKVUt4t33cHxgD7rA1WdAxms2bBhmym/nMNB49X8dLMZN64bjjduzho6S93s+UxZoRjxj8DrTVv736bXkG9mBg3sV2vLTqnSUnhlNU2kZZd2uZz/Tz9GB05mhU5K9C67UmbXUUmAxoKdjk3DiHs7JxJl9a6GbgbWAqkA59prfcqpZ5USl0KoJQaoZTKBWYAbyql9racngRsUUrtBFYCf9VaS9LViRVVNXDDe5t57N97GdkrhJ/uH8flQ6MdOwuUuwW6xYOfjXdAttGq3FUcKDvArYNulY2tRbsY3zcUbw8DP+4psOr8C+MuJL8mn4yyDDtH1ka/dKaXui7RsbTqtjCt9ffA96c899hJ36dhWXY89bz1wCAbYxQdxLacMuZ+tJWKuiaevWIQ14yMdfySm9aQmwbxkxx7nd9cVvP2rreJ7hLN1F5T2/XaovPy9/ZgXGIoP+4p4LFp/TEY2vbzNS52HAZlYEXOCvqF9HNQlK0QEGHpTi93MIoORn79Fg6ntebDjUeY+eYGvD2MfDV3DNemxrVPjVNZNtQUtfvS4qaCTewq3sXNA2/G0+DZrtcWndvUQREUVNazw4oNsEN8QkgOTWZ5znIHRNZG0pledECSdAmHamw28+AXu/i/b/YwNr47i+8e2/aNqm2Ru8Xy2I5Jl9aa13e8TphvGJfFX3buE4Swowv7heNpVFYvMV7U8yIOlh3kYNlBO0fWRlFDofggNFQ5Nw4h7EiSLuEw9U0m7vxoK19szeWeiQm8O2cEQX7tPOuTuxk8/SHs1E0UHGfDsQ1sK9zGbYNvw9vY/n3BROcW5OvJ2PjufL/7mFUF8VN6TsGojCzJWuKA6NogqqWY/pgU04uOQ5Iu4RA1Dc3cPD+NlRmFPHPFQP40ObHN9SV2kZsG0cPAaIeu9q2gtea1Ha8R4R/BlQlXtss1hTjV1IGR5JbVsTe/ss3ndvPtxpjoMXyX9R1m7cRNRqQzveiAJOkSdldR18QN721mY1YJ/7h6CLNTezgnkKY6y/5t7bi0uDZvLbuKdnH74NvxMtqxwasQbTC5fzhGg+KHPcesOn9a72kcrz3OloItdo6sDQLCISBK6rpEhyJJl7CrqvomrntnE7tyy3nt2mFcMfQ3N7W2n/wdYG5ut6TrxCxXlH8Ul/eRHa+E8wT7ezGqdwg/7C6waolxfOx4/D39WZy12AHRtUFUsrSNEB2KJF3CbppNZu5euJ19xyp58/rhjuku3xbt3BR1Ve4q9pbs5Y4hd+BplDsWhXNNHRhJVnENB463vau7r4cvk+ImsezIMuqb6x0QXStFDYWSTKhv+zKpEK5Iki5hN08t2ceqA0U8ddlALuwX7uxwLPVcwT2hi+O3ljoxyxXTJYbpfaY7/HpCnMtFA8JRCquXGKf3mU5NUw3/Ofof+wbWFtKZXnQwknQJu5i/7jAfbDjCbef34trUOGeHY2mKejSt3Wa5lh1Zxv7S/ZZZLunLJVxAWIAPI3qEWN06IiU8hTC/MOcuMUpnetHBSNIlbLZyfyFPLtnHpKRwHp6a5OxwLCpyoboAYkY6/FJN5iZe2f4KfYL6MK33NIdfT4jWmjoogv0FVWQWtn2J0Wgw8rvev2Nd3jpK69u+l6NddAmDwGgpphcdhiRdwiY5JbX88ZPtJEUG8s9ZyRid0RbidHLTLI8xKQ6/1NcHvya7Mpt7ht2Dh6F9WlMI0Rq/GxSJUvDtznyrzp/eezombeKHwz/YObI2iEyWthGiw5CkS1jNZNb8z+c7UMBbN6Tg7+1CCUduGnj4QIRjt/6sbarljZ1vkByazITYCQ69lhBtFRbow3l9uvHvHXlW3cWYEJxAv5B+fH3wa6vOt4uoZCmmFx2GJF3Cam+vySItu4wnLhtAdFdfZ4fza7lpljufHHwX4cfpH1NUV8T9w+9vn70khWijy5KjOVJSy87cCqvOn5E4g4yyDHYUOWm26USTVCmmFx2AJF3CKunHKvnHTweYOjCCK4ZGOzucX2tugGM7HV5EX15fznt73mN8zHiGhQ9z6LWEsNaUgRF4eRj4ZnueVedP6z2NAM8APkn/xM6RtZIU04sORJIu0WYNzSbu/3QHgb6ePHPFINeb4Tm2C0yNDk+63t79NrXNtdwz7B6HXkcIWwT6eDKxXxhLdh2j2dT2bX38PP24POFylh1ZRmFtoQMiPIcTxfRS1yU6AEm6RJv9Y9kB9hdU8cJVgwjxd8GtbtqhKWpuVS6f7P+E6b2nkxCc4LDrCGEPlyVHUVzdwPpDJVadP6vvLEzaxBcHvrBzZK0UmSx3MIoOQZIu0SZ78ip4a3UW14yMdY0GqKeTmwZBsRDouI7487bOw6iM3D30boddQwh7Gd83jAAfD/69w7q7GOMC4xgbPZbPD3xOk6nJztG1ghTTiw5Cki7Ralprnlyyj2A/L9fpx3U6uVscOsu17fg2fjryEzcNvIkI/wiHXUcIe/HxNDJ1YARL9xZQ32Syaoxr+l1DcV0xy3OW2zm6VpBietFBSNIlWu2HPQVsPlzKnyYnEuTrol3XK49BxVGHJV1mbeb5tOcJ8w3jxgE3OuQaQjjCZcnRVDc083O6dXVZY6LHEBsQy8L0hXaOrBWkmF50EJJ0iVapbzLx7Pfp9IsIYNaIWGeHc2YnmqLGOqYT/ZKsJewr2ce9w+/Fz9PPIdcQwhFG9e5GWIA3/95h3V2MBmVgVt9Z7Cjawb6SfXaO7hy6hEFAlBTTC7cnSZdolXfXHia3rI7HpvXHw+jC/2xyN4PRyyFNUWubavnn1n8yoNsA2e5HuB2jQTF9SBT/ySiivLbRqjEuT7gcXw9fFuxbYOfoWiEqWWa6hNtz4U9P4SqOV9bz2spMLuofznnx3Z0dztkdTbPUf3h4233o+XvnU1hXyEMjHsKg5EdHuJ/fD4uh0WTmayt7dgV6BTKz70x+OPwDRyqP2Dm6c4hsKaZvqGrf6wphR/LJIc7phR8zaDZpHvmdCxfPAzQ3Wm4rd8DSYkFNAe/veZ+LelwkjVCF2+ofFcjgmCAWbT5q9bY+cwbMwdPgybu737VzdOcQNRTQlj58QrgpSbrEWWUUVPHltlxuGtuTHt38nR3O2RXsBlODQza5fnnby5i0ifuH32/3sYVoT7NGxJFxvIodR8utOr+7b3d+n/B7Fh9aTF61dTNmVjlRTC91XcKNSdIlzurlFQfp4u3B3HF9nB3Kuf3SFNW+M127i3azOGsx1/e/npiAGLuOLUR7mz4kEl9PI4s2H7V6jJsG3oRSivd2v2fHyM7hRDG91HUJNyZJlzijg8er+H73Meac14Oufi7Yef5UuWmW7UKC7LcXpNaaF7e8SIhPCLcNus1u4wrhLAE+nkwfEsniXflUNzRbNUaEfwSXx1/O15lfc7zmuJ0jPIuoZJnpEm5Nki5xRq+uzMTX08gtY3s7O5TWOZpm9/5cS48sZXvhdv449I908epi17GFcJaZI+KobTSxeKd1HeoBbh54M2ZtZv7e+fYL7Fwik6H4oBTTC7clSZc4rUNF1Szemc/1o3u45v6Kp6oqgIocuxbRN5gaeGnrSyQGJ3JF/BV2G1cIZxsW15XE8C4sSrN+iTEmIIZpvafx+YHPKa4rtmN0ZxGVjBTTC3cmSZc4rddWZOLtYeS2891llsv+m1x/uO9D8qrzeHDEgxgNRruNK4SzKaWYOSKOnUfLST9m/X6Gtw2+jWZzM2/tesuO0Z1FpBTTC/cmSZf4jcPFNXyzI4/rRsXRvYv9+105xImmqJFD7DJccV0xb+96m/Ex4xkVOcouYwrhSq4cGo2X0cCizTlWj9EjsAdXJlzJ5xmfk1Np/TitFhAOAZFSTC/cliRd4jdeW5mJp9HAbRe4ySwXtDRFHWK3pqivbn+VRlMj/5PyP3YZTwhXE+zvxcUDI/h6ex51jdZtgg0wd8hcPI2evLz9ZTtGdxaRUkwv3Ferki6l1BSlVIZSKlMp9fBpXr9AKbVNKdWslLrqlNfmKKUOtnzNsVfgwjHyyuv4ense16bGERbg4+xwWqe50fKfsJ1aRWSUZvDVwa+Y1W8WPYN62mVMIVzR7NQ4Kuubre5QDxDqF8qcAXNYmr2UPcV77BjdGUQNlWJ64bbOmXQppYzAa8BUoD9wjVKq/ymH5QA3AgtPOTcE+AuQCowE/qKUCrY9bOEoH6zPBuBWd6nlAji+DfsqXgAAIABJREFUG5rrIdb2ei6tNS+mvUigdyB3DrnTDsEJ4bpSe4UwMDqQd9dmYTZb16Ee4MYBNxLiE8Lft/zd6k73rXaimL5gt2OvI4QDtGamaySQqbXO0lo3AouAy04+QGudrbXeBZhPOfdiYJnWulRrXQYsA6bYIW7hADUNzXyyOYcpAyOI7urr7HBa72ia5dEORfT/OfofNhVsYu6QuQR5B9k8nhCuTCnFrWN7c6iohlUHiqwex9/TnzuH3MmW41tYk7fGjhGexolieqnrEm6oNUlXNHDyfcW5Lc+1hi3ninb2xdZcquqbuWVsL2eH0ja5my2dqoNs6xbfZGri71v/Tq+gXlzd92o7BSeEa7tkUCQRgT68szbLpnGuSryKuIA45m2dh8lsfY3YOZ0oppe6LuGGWpN0qdM819r541adq5S6XSm1RSm1pajI+t+2hPXMZs376w4zNK4rw+LcbAX4aJpdlhY/2f8JRyqP8EDKA3gaPO0QmBCuz8vDwJzzerIus4R9+da3j/A0eHLvsHvJLM/ky4Nf2jHC04hMlpku4ZZak3TlArEn/TkGaG0b41adq7V+S2udorVOCQ0NbeXQwp5+3l9Idkmt+81ynWiKamMRfXl9OW/seoPRkaM5P/p8OwUnhHu4dmQcfl5G3l172KZxJveYzIiIEby8/WUqGirsFN1pRCVD8QFoqHbcNYRwgNYkXWlAglKql1LKC5gFfNvK8ZcCFymlglsK6C9qeU64mPfWHiYqyIcpAyKcHUrb5LbUc9nYif5fO/9FTVMND454EKVON0ErRMcV5OfJ1SmxfLszj8LKeqvHUUrx8MiHqWqs4pXtr9gxwlNEDcXSmX6n464hhAOcM+nSWjcDd2NJltKBz7TWe5VSTyqlLgVQSo1QSuUCM4A3lVJ7W84tBZ7CkrilAU+2PCdcyN78CjZklTDnvJ54GN2sddtR25uiZpVn8VnGZ1yVcBUJwQl2DE4I93HTmJ40mzULNhyxaZzE4ERm9p3J5wc+J6M0w07RnSJqmOUxb6tjxhfCQVr1Cau1/l5rnai17qO1fqbluce01t+2fJ+mtY7RWvtrrbtprQecdO57Wuv4lq/3HfM2hC3eW5uNn5eRWSPjnB1K2+WmQcRgm5qi/m3L3/D18OUPQ/9gx8CEcC89uvlzUf9wPtp0hNrGZpvG+kPyHwj0CuS5zc85poVEl1DoGgd5W+w/thAO5GbTGsLeiqsbWLwznxnDYwjydbPi8eZGyN9u09Liurx1rMlbw+2DbyfEJ8SOwQnhfu4Y14fy2iY+WG/bbFeQdxD3DLuHrce3sjTbQRUl0SmQt80xYwvhIJJ0dXJfbM2l0WTm+tE9nR1K251oimplf65mczMvpr1ITJcYZifNtnNwQrifYXHBTOgbypurD1FV32TTWFfGX0lSSBIvbnmRmqYaO0V4kpgUqDgKVcftP7YQDiJJVydmNmsWbsohtVcI8WFdnB1O2x21rYj+ywNfcqjiEP+T8j94Gb3sGJgQ7utPk/tSXtvEe2uzbRrHaDDyyKhHKKot4tXtr9onuJNFD7c8yhKjcCOSdHViazOLySmtZfaoHs4OxTo2NEWtbKzktR2vkRKewsS4iQ4ITgj3NCgmiIv6h/PO2iwqam2b7RoSOoQZiTNYuH8h+0r22SnCFpFDwOAhxfTCrUjS1Yl9vOkI3fy9uHhAuLNDsc7RNMsSgxXe3vU25Q3l0iJCiNO4f3IiVfXNvL3Gti71APcOv5dg72Ce3PCkfTvVe/pC+ADIlZku4T4k6eqkjlfWszy9kBkpsXh7GJ0dTttV5FqaosaNbvOpOZU5fJT+EZf2uZT+3U7du10IkRQZyLTBkby37jAl1Q02jRXoFcifR/6ZvSV7WZSxyE4RtogebrmZxnzqtr9CuCZJujqpT9OOYjJrrhkZe+6DXVHORstjj7YnXf/Y+g88DZ7cM+weOwclRMdx36RE6ptMvLna9tmuKT2nMCZqDK9sf4XjNXYsfI9OgYZKKDlovzGFcCBJujohk1mzaHMO5yd0p0c3f2eHY50j68GrC4QPatNpaQVp/JzzMzcPvJkwvzAHBSeE+4sP68LlydEs2JBNfnmdTWMppXhk1CM0m5t5dtOz9uvddaK8QJYYhZuQpKsT+k9GIfkV9cxOddMCeoCcDZa7Fo0erT7FZDbxYtqLRPhHMGfAHAcGJ0THcP/kRLSGZ75Pt3ms2IBY7kq+ixVHV9ivd1e3BPAOlDsYhduQpKsT+nhTDmEB3kxMctOZntpSKNwHcee16bRvD31Lemk69w27D18PXwcFJ0THERvix13j4/lu1zHWZxbbPN4N/W9gYLeBPLvpWUrqSmwP0GCw7MMoM13CTUjS1cnkltWyMqOQWSNi8XS3fRZPOLrJ8tiGeq7aplpe3v4yg7sP5pJelzgoMCE6njvG9SY2xJe/fLuXJpNtBeseBg+eGvMU1U3VPLvpWfsEGDMCju+Fhmr7jCeEA7npp66w1qLNR1HATHfcZ/GEI+vB4Pnf5oit8O6edymuK5YWEUK0kY+nkb9MG8DBwmo+WJ9t83jxwfHMHTKXn478xE/ZP9keYNxo0CZZYhRuQZKuTqTJZObTLUeZ0DeM6K5uvLyWswGih1n69LTCsepjfLD3A6b2nEpyWLKDgxOi45mYFMaEvqG8tPwghZX1No9308Cb6N+tP89seoay+jLbBosdASjI2WRzXEI4miRdncjyfccpqmpg9ig3nuVqrLX05WlDf6552+YBcN/w+xwVlRAdmlKKv0wfQGOzmed+2G/zeCeWGSsbK3lq41O23c3oE2Rpkpqzwea4hHA0Sbo6kY835RDd1ZdxiW5aQA+WJQRzM/QY06rDdxbt5IfDP3BD/xuI6hLl4OCE6Lh6dvfn9gt68/X2PFYdKLJ5vMTgRP449I8sO7KMbzK/sW2w2FRLMb09O94L4QCSdHUS2cU1rM0sZtaIWIwGN65pOrIBUK3a5Nqszbyw+QW6+3bn1kG3Oj42ITq4uy+MJyGsCw9+vpPy2kabx7txwI2MjBjJc5uf40jlEesHihsNjVWWgnohXJgkXZ3EJ5tzMBoUM0e4aQf6E7LXQMRA8O16zkO/PfQtu4p3ce+we/Hz9GuH4ITo2Hw8jcybmUxpTSOPfrPH5vEMysAzY5/B0+DJw6sfpsls5QbbcamWxxM7VQjhoiTp6gQamk18tuUoF/UPJyzQx9nhWK+pDo5uhl7jznloVWMVL219icGhg7m0z6XtEJwQncPA6CDum5TAkl3H+PeOPJvHi/CP4PHzHmdPyR5e3/G6dYMExUJAFByVpEu4Nkm6OoEf9xRQVtvk3h3owdKfy9QAvcef89A3dr5BaX0p/2/k/8Og5J+5EPZ057g+DI3ryv99s4eCCtvvZpzcYzJXxF/BO7vfYfOxzW0fQCmIGyUzXcLlyadRJ/Dxphx6dPPjvD7dnB2KbQ6vBoOH5T/Xs8gqz2Jh+kKuTLiSAd0HtFNwQnQeHkYD/7g6mSaT5sEvdmI2276X4sMjH6ZnUE8eXP0ghbWFbR8gbhRU5kH5UZtjEcJRJOnq4A4er2Lz4VKuHRmHwZ0L6AGyVlkaonoHnPEQrTXPbX4OX09f7hl2TzsGJ0Tn0qu7P4/8Lok1B4t5dWWmzeP5efoxb/w86prreGDVA22v7zrxy5jMdgkXJklXB/fxphy8jAauGh7j7FBsU18B+dvOWc/1c87PbDy2kT8k/4EQn5B2Ck6Izml2ahxXDI1m3vIDrNxvxezUKfp07cPjox9ne+F25m2d17aTwwaAVwDkrLc5DiEcRZKuDqyu0cRX23KZMjCCbl28nR2ObY5sAG2GXhec8ZCaphr+uvmvJAQnMLPvzHYMTojOSSnFs1cMIikikHsXbSe7uMbmMS/pfQnX9ruWD/d9yNLspa0/0ehh2Y/18BqbYxDCUSTp6sCW7Mqnsr6Z2alu3IH+hMOrwMPHsrntGby6/VUKawt5bNRjeBg82jE4ITovXy8jb14/HINBcedHW6ltbLZ5zAdSHmBw6GAeW/cYB8sOtv7EXhdAyUGozLc5BiEcQZKuDuzjTTnEh3VhZK8OsMx2eLWl67Tn6Vte7C3Zy8L9C7m679Wyv6IQ7Sw2xI+XZw3lwPEqHvpil23b+gCeRk/+Pu7v+Hn68ccVf6S0vrR1J54oPzi82qbrC+EoknR1UHvzK9hxtJxrR8ahlJsX0FcXwfE90Pv09VzN5maeWP8EIT4hUjwvhJNckBjKAxf3ZcmuY/xj2QGbx4vwj+CVC1+huK6Y+1beR6OpFR3wwweCb7AkXcJlSdLVQS3clIO3h4HfD3PzAnqwLC3CGYvoF+1fRHppOn8e+WcCvQLbMTAhxMnmjuvDrBGxvLIik4832bCtT4uB3Qfy9Nin2V64nSc2PHHuGTSDAXqeb7nT2cbZNiEcQZKuDqi6oZlvtucxfUgUQX6ezg7Hdgd/Ar9uEDX0Ny8V1BTwyvZXGBs9lot7XOyE4IQQJyilePrygUzoG8r/fbOH5fuO2zzmlJ5TuGvIXXx76Fve3fPuuU/oPQ4qc6E0y+ZrC2FvknR1QP/ekUdNo4lrO0IBvdkEmcshfhIYjL96SWvN4+sfR6N5JPUR919GFaID8DAaePXaYQyMDuLuT7axPafM5jHvHHInU3tO5Z/b/sl3Wd+d/eBf6rpW2XxdIexNkq4ORmvNwk05JEUGMjT23JtCu7z87VBbAgkX/ealLw9+ybr8ddw37D5iAjrAMqoQHYS/twfv3TiCsAAfbp6fxsHjVTaNp5TiqbFPkRKewqPrHmVD/oYzH9wt3rIPo9R1CRfUqqRLKTVFKZWhlMpUSj18mte9lVKftry+SSnVs+X5nkqpOqXUjpavN+wbvjjV1iNl7M2vZHZqByigB8vSojJAnwt/9XRedR4vpr1IakQqs/rNclJwQogz6d7FmwU3j8TDaODadzZx2MYeXt5Gb/554T/pGdiT+1beR3pJ+ukPVMrSOuLwGjCbbbqmEPZ2zqRLKWUEXgOmAv2Ba5RS/U857BagTGsdD8wDnj/ptUNa6+SWrzvtFLc4g/fXZRPo48GVw6KdHYp9HPzJ0pvL779tL8zazGPrHkMpxZNjnpQNrYVwUT27+7Pw1lRMZs21b2/kaGmtTeMFegXyxqQ3CPQOZO7yueRW5Z7+wN7joLYYCvfZdD0h7K01n1YjgUytdZbWuhFYBFx2yjGXAR+0fP8FMFF1iGkW95JfXsePewu4ZmQcfl4doDlodaFleTFh8q+eXrR/EZsLNvNgyoNEdYlyUnBCiNZICA/go1tSqW00ce07G8kvr7NpvHD/cN6c9CZN5iZuX3b76TfH7j3e8pi5zKZrCWFvrUm6ooGTt23PbXnutMdorZuBCqBby2u9lFLblVKrlFLn2xivOIsFG46gteb60T2cHYp9ZC63PJ5Uz5Vdkc28rfMYGz2WKxOudFJgQoi26B8VyIKbR1Je08TsdzZxrMK2xKt31968Pul1SupKuPWnWympK/n1AYFREDkEMn606TpC2Ftrkq7TzVid2gDlTMccA+K01kOBPwELlVK/aaSklLpdKbVFKbWlqKioFSGJU9U1mvhkcw4XD4ggJtjP2eHYx8GfoEsERAwGoMHUwAOrHsDHw4fHRz/eMWrWhOgkhsR2Zf7NIyiqamDGGxvIKbFtqXFw6GBem/gax6qPcfuy26loqPj1AYlTIHcz1JScfgAhnKA1SVcuEHvSn2OAUze2+uUYpZQHEASUaq0btNYlAFrrrcAhIPHUC2it39Jap2itU0JDQ9v+LgRfbc+loq6Jm8b0cnYo9tHcCJkrLK0iWpKrF9NeJKMsg2fGPkO4f7iTAxRCtNXwHiF8fGsqVfXNXP3mBjILq20aLyUihZcvfJnsimzuWHYHVY0n3SWZeDFo839nzIVwAa1JutKABKVUL6WUFzAL+PaUY74F5rR8fxWwQmutlVKhLYX4KKV6AwmAdKyzM60189dlMyAqkBE9g50djn0cXgUNFZA0HYBlR5bxacan3DjgRi6IucDJwQkhrDUktiuLbh9Fs9nMrLc2kH6s0qbxRkeN5h/j/0FGaQZ/+PkP1Da1zKBFDoUu4XDgBztELYR9nDPpaqnRuhtYCqQDn2mt9yqlnlRKXdpy2LtAN6VUJpZlxBNtJS4AdimldmIpsL9Ta93KnUtFa63NLOZgYTU3jenVcZbc9n4D3oHQZwK5Vbn8Zd1fGNx9MPcMlb0VhXB3SZGBLLp9NB4GA7Pe2siu3HKbxhsXO47nL3ienUU7uWfFPdQ311u2BEq4CDJ/BlOTnSIXwjatutdea/291jpRa91Ha/1My3OPaa2/bfm+Xms9Q2sdr7UeqbXOann+S631AK31EK31MK31Yse9lc7r/XXZdO/ixfQhkc4OxT5MTbB/CfS9hEaleGj1QwC8MO4FPI0dYFsjIQTxYV34/M7RBPh4cO3bm0jLtu338Yt6XsTTY55mc8Fm7v/P/ZYNshOnQEMl5JylmaoQ7UgaHLm5A8erWLG/kNmpPfD2MJ77BHeQtQrqy9FJl/L0xqfZXbybJ8c8SXSXDtJ7TAgBQGyIH5/fOZqwAG9ueHczaw8W2zTe9D7TeWz0Y6zNW8tDqx+iqedYMHrDgaV2ilgI20jS5eZeW5mJn5eRG8/r6exQ7GffN+AVwEJTMV9nfs0dg+9gUo9Jzo5KCOEAkUG+fHrHaOJC/Lj5gzRW7Ldtk+yrEq/i4ZEP83POzzy48XFL4pXxPehTb7oXov1J0uXGDhfXsHhnPteP6kGwv5ezw7GPlqXFjX3O48Vt85gQO4G7ku9ydlRCCAcKDfBm0e2j6BcRwO0LtvLl1jN0mm+l2Umzf0m87vVrpqEsCwp22ylaIawnSZcb+9fKTDyNBm49v7ezQ7Gfw6s52lTJA81H6BXUi+fOf062+RGiEwj29+LjW1NJ7R3C/3y+k9dWZqJtmJ2anTTbstRYnc0fwsOp3fmJHaMVwjryaeamjpbW8vX2PK4ZGUdogLezw7Gbit2fck9EONrgwcsTXsbf09/ZIQkh2kmAjyfv3ziSy5OjeHFpBo/9ey8ms/WJ14zEGTw99mnSfL2Zm7uY6nrb2lMIYStJutzUG6sOYVCKO8Z1nFmuhtpi7i1aTbanJ/PGzyM2MPbcJwkhOhQvDwP/uDqZO8b15sONR5j70Vbqm0xWj3dpn0t5vtdV7PKAO76f/dvO9UK0I0m63FBBRT2fb8nlqpQYIoN8nR2OXZi1mf9degdbvT15dsBtjIwc6eyQhBBOYjAo/ndqEo9P78+y9OPMfmcTZTWNVo83ZdQD/L2kivSqI9z6062U1ZfZMVohWk+SLjf05upDmLRm7rg+zg7FLrTWvJD2AssqD/BAgydTh9/t7JCEEC7gxjG9+Ne1w9idV8Hv31jP0VIr92v08ufCXhfzSkk1hysOc/PSmymus609hRDWkKTLzeSX17FwUw5XDI0mNqRjbGz93p73+Dj9Y66vqGTOoFt+2WtRCCGmDork41tTKalu5MrX17Mnz8rlwUEzGFNZwr8S5pBXnceNP95IbpVtd0kK0VaSdLmZ53/cD8B9kxKcHIl9fLTvI17a9hJTvaN4oLwGBs9ydkhCCBczomcIX84djZfRwMw3N/DT3oK2D9J7PPh1Y2T2Zt6a/BZl9WVc/8P1pJek2ztcIc5Iki43svVIGf/ekc/tF/QmJtj9Z7k+3f8pz6c9z6TYCTxzJANDv9+BfzdnhyWEcEHxYQF8ddd5xId14fYPt/LqioNtaylh9ISh18H+70j27s6HUz/Ew+DBTUtvYuOxjY4LXIiTSNLlJsxmzZNL9hEW4M2dHaCW66uDX/H0pqcZHzOeF4JH4VlXBsOud3ZYQggXFh7ow6d3jOay5Cj+9tMB/vjJduoa23Bn44hbAQ1p79K7a28+mvoRkf6RzF0+l++yvnNY3EKcIEmXm/hmRx47j5bz0JR++Ht7ODscm3x98GseX/84Y6LG8Pdxf8NzwysQ2g96X+js0IQQLs7H08hLM5P585R+fLf7GFe9sZ6cklYW2HeNg76XwNb50FRHuH84H0z9gOTQZB5e8zD/2vEvmxqyCnEuknS5gdrGZp7/cT+DY4K4cqh7b/r84b4PeWz9Y4yOGs1LE17C69BKKNwHY+8Hg/xzFEKcm1KKueP78O6cFI6W1vK7V9bw455W1nml3gF1pbDnSwACvQJ5c/KbXNbnMl7f+Tp/Xv1n6pvrHRi96MzkU84NvLEqi+OVDTw2rT8Gg3ve2ae15rUdr/FC2gtM7jGZVy58BR+jN6z9BwTFwcDfOztEIYSbubBfON/dcz69u/tz50dbeWLxXhqbzWc/qef5ENYfNr35yybYXkYvnhrzFPcPv58fs3/klqW3UFRb1A7vQHQ2knS5uMzCKt5cdYhpgyNJ6Rni7HCsYtZmnk97njd2vsHl8ZfzwgUv4GX0giPr4egmOO+PliJXIYRoo9gQPz67czQ3nteT99dlM+PNDWQVVZ/5BKUss10Fu+DIupOeVtw88GbmTZjHwfKDzFwyk23Ht7XDOxCdiSRdLqyx2cw9n+zA39uDx6b3d3Y4VqlrruOBVQ/wcfrHXJd0HU+c9wQehpaatLXzwK+75Y4iIYSwkreHkccvHcDrs4eRXVzD1H+u4d21hzGfad/GQVdDl3BY8fQvs10nTIybyEeXfISvhy83L72ZBXsXSJ2XsBtJulzY35dlsO9YJc//fjBhAT7ODqfNimqLuOnHm1h+ZDkPpDzAQyMewqBa/sllr4XMZTBqLni5f/sLIYTzTR0UyU/3X8CY+O48tWQfs97eePoiey8/GPdnyNkAB3/6zcuJwYksmraIcTHjeHHLizy4+kGqG88yeyZEK0nS5aI2HCrhrdVZXDMyjsn9w50dTpull6RzzXfXkFWRxcsXvsycAXNQJzrNm5rhhz9DUCyMusu5gQohOpTwQB/enZPCC1cNJj2/kotfWs2rKw7+dtPsYTdASG9Y/gSYf9t2IsArgJcmvMR9w+5j2ZFlXLX4KnYU7mindyE6Kkm6XFBFbRN/+mwHvbr583/TkpwdTpv9O/PfzPnRkmR9OPVDxseO//UBW9+H43vg4mdklksIYXdKKa5OiWXp/RcwLjGUv/10gItfWs3P6cf/e5DREy58FAr3wu7PzzjOLYNuYf6U+QDM+XEOr+14jWZzczu8C9ERSdLlYrTWPPLNboqqGnhpVjJ+Xu7Tk6u2qZZH1j7Co+seZVD3QXzyu0/oG9L3lINKLXUUvS6ApEudE6gQolOI6urLG9cP56NbUvE0Grjlgy3MeW8zu3Nb9m/sfwVEDoEVz0BjzRnHGRo2lC+mf8G03tN4Y+cbzPlhDpllme30LkRHIkmXi/nHsgMs2XWMP12UyOCYrs4Op9UOlB1g1nezWHxoMXOHzOWtyW/R3bf7bw9c/hdoqIIpz8vG1kKIdjE2oTs/3Hs+j/4uiR1Hy5n+6lpu/WALe45VwcXPQUUOLH/8rGN08erCM2Of4cVxL5JTlcOMJTN4ZfsrNJga2udNiA5BudpdGSkpKXrLli3ODsMp3l93mCcW7+OakbE8e8Wg/9ZAubBGUyPv7H6Ht3e/TVfvrvz1/L+SGpl6+oP3fAVf3ARj7oPJT7RvoEIIAVTVNzF/XTZvr8misr6ZSUlhPOn9MVH734frv4E+E845Rml9KX9L+xuLsxbTI7AHj456lFGRo9oheuGKlFJbtdYprTpWki7X8M32PO77dAdTBkTw2uxhGN2gCeq249t4YsMTZFVkcUmvS/jzyD8T4nOGXmIlh+DNcRCWBDd9L325hBBOVVnfxPtrs/lgQzY1NdX85Pco3T2bMM9dT0DX08zSn8aG/A08ueFJcqtzuSDmAu4fdj/xwfGODVy4HEm63Mx/Mgq59YMtpPQMZv5NI/HxNDo7pLPKr87n9Z2v803mN0T5R/HoqEc5P+b8M5/Q3ADvToayI3DnWuga237BCiHEWdQ3mfhu1zHWr1nG82V/YpkeyXd9n2HakBjG9w095//H9c31fJz+Me/ufpea5hou63MZdyXfRYR/RDu9A+FsknS5ka+25fK/X+0mPqwLi24fRYCP684AFdcV887ud/gs4zMUimuTrmXukLn4eZ7lDkRTE3xxM6R/C9csgr5T2y9gIYRog/zv/kpU2nN8rH7HI3XXEuDtycSkMMb3DeP8hO506+J9xnPL68t5a/dbfLL/E9BwSe9LmDNgDonBie34DoQzSNLlBppNZp79fj/vrTvMqN4h/Gv2cEL8vZwd1mlllWfxacanfJ35NY2mRi6Pv5w7h9x57t/kTM3w1W2w9ytLsepo6cklhHBhWsOPD8OmNzic/BCvN09j2b7jlNU2ATAoOogx8d0Z3iOYYXFdT5uE5VXn8eG+D/nq4FfUNdcxJmoMM/vOZGz0WDylrKJDkqTLxZXWNHL3wm2sP1TCTWN68v8uScLT6Fo3ktY317MqdxWfZXzG5oLNeBo8ubjnxdwx+A56BvU89wDNjfDvP8Duz2DykzDmXofHLIQQNjOb4ctbLL8sXvQ0ptQ/sCe/ktUHilh9sIjtOeU0t2wv1KObH8mxXekbEUC/iAD6RgQSFeSDUoqKhgo+y/iMhfsXUlxXTJB3EFN6TmFa72kMDh383905hNuTpMtFaa35dmc+f/1hPyU1jTxz+UBmpLhOfVNFQwWrc1ez8uhK1uatpa65jij/KGb0ncEV8VfQzbdb6wYqz4HPb4S8rTDxMTj/fxwatxBC2FVzA3x5q6UsYsi1MG0eeFq2YqtrNLEnv4JtR8rYnlPOrtxy8ivqfznV38tIbIgfMcF+xAT7EhXsRZ1hH/uq/sOW4jU0mhoI9g4mNTKV0VGjSY1MJco/yi3uVhenJ0mXC9p6pJSnlqSz42jb5Gu1AAAJ90lEQVQ5A6ICee7KQU7tw2XWZvKr89ldvJttx7exo2gHB8oOYNZmQn1DmRA7gYlxE0mNTMVoaGVhv9aQvhi+/SNoM1z2KvS/zLFvRAghHMFshtUvwH+eg6hhlv/Pwgec9tCKuiYOHK9if0EVhwqryS2r5WhpHUfLaqltPGmLIUM9AcEH8AnMpNk7g2ZladLqYwgk0rc3vQITSQxOIDGkB0mhPYkKCJcZMTcgSZeLMJk1azOLWbjpCEv3Hic80JsHL+7HlUOjMbRDS4hmczMldSUcqzlGXnUe+dX5ZFdmc6j8EFkVWdQ11wHg5+HH4NDBDA0bypjoMQzqPqjtP+i5W2HZ/8GRdRAxCGZ8AN36OOBdCSFEOzrxi2R9JYy4FcY/DH5naI1zCq01ZbVNHC2tJbfMkoTll9dRXN1AUVUDBXXZlJn30+RxFKP3MQzeBSjDSUmaNmIwB+KlAvAxBtDFI5BA7yCCfboS6htCWJdgIruEEBMUQph/CIHegQR6BeJldM364I7K7kmXUmoK8E/ACLyjtf7rKa97AwuA4UAJMFNrnd3y2v8CtwAm4B6t9dKzXcvdky6tNQcLq/lmex5fbcujoLKern6ezBndkzvG9bZ5Wx+T2URZQxkldSWWr3rLY3FdMSX1/30sqSuhrL4Mza//fkN9Q+nTtQ/xXeOJ7xpPUrckEoMT8TBYEVdTHaQvge0fwuFV4B8K4//XspGsFIwKITqK2lJY+QxseQ88fGHwDEi52bKFkB3UNZoorm7gWGUNGSXZHC4/Sl51HoW1x6hoLKHWVEWDuYpmXY021IKxDqXO/NltwAtP5Y+fMZBAzxBCfLoR5hdGVEAYsUHh9AyKINw/jFC/UHw9fO3yHjozuyZdSikjcACYDOQCacA1Wut9Jx1zFzBYa32nUmoWcIXWeqZSqj/wCTASiAKWA4la699u6d7C3ZKuitomDhVXsz2nnM2HS9iSXUZJTSMGBeP7hnHV8BgmJoXh7XHmJbraplpK60spqy+jtL70V1//v727i23rLuM4/n38Fjt2ljpJX1PGMlro0FQJLgZovEwUiQ0quACJgkCVkCgXQ1oRCG2akAY3XCAhLhhCEyAhqEBDA1EhQdcJLkCiQKGDrZSyDhXSLc1Lkzi2Yzt2/HBxTqr0Lbjrid3Yv4905OOT/zl5lH+s8/h/zvk/c9W5KxKrudocTW9ec4x0PM1wZjhY0sHrSGaEkfQIO3I7GM2Nsj23/dY+YPUKTJ+F/54Ikqzzv4faAmy6E956EN72WegbeO3HFxG5nU2ehhPfhheegUYFhu6GN+yDux8IErDBnete3qxaX2a6VGF8fpbxwgwTC7NMlueYWZxnrlqgUCtQqhepLJeoNYtYYgFLFIPFrj13xL2fdGyIXGKYfGozI5nNbM5sYVt2K6MD27lzcBujAyMM9ifXPI/1sqiTrncAT7j7+8P3jwG4+9dWtTkWtvmDmSWAi8Bm4NHVbVe3u9Hva1fStdx0Gs0mjWUPlmaTRtOpLwfbKvUGpVqD8lKdUrXO/GKNmXKN2XKNS+UKF+bK/Gd2gUKtAraMWZ2tg3H2bO9n99Y0e3akiSdqlOolSkslyvUyxXqR8lLwOl+dv5xYVZer140xk8gwlB5iKD10TTI1nA5fw+3ZZDaaGzFPHYFqISj+ulSE0hQUJ4KJTefOw8rIWX4sKFp970fgrndBTPcdiEiPqMzDCz+Fl54NvnzWF4PtfYMwsgsGtgdLJg+pLPTl4I0PweBoW8NsNp1Cpc6lco2pYpXxwgzjhUkmSpNMLs4wV52mUJ9hsTnLks/h8QKWKF0ziubNBN7IQTNLnCwpsvTFB8jEB+gPl3Syn0w8TSbZR38iQzaVpj+VIZfMkEulySQT9KdSpJNxEvEEqVicZCJOKhYjFU+SiMdIxI1ELEYiZsTjRjIWwyzIYw0LX7l8rgvW6fhDCDeTdLVyTWkUGF/1/gJwdXG9y23cvWFmBWA43H7iqn3b+193HXufOMZCtXHFtvSOH5O440WCpMLXHLoFIBssuVWbSsDJJTg5zpV/MaAv3kcumSOXypFL5tiU3sTY4FiQVGWGyPflGc4MM5QeIp/Ok+/Lrz3p6Ho5/mVYvBSsx1OQ2woD24JvcXs/Blv2BDeV5l/f/thERG4HmU1w32eCpVGDV0/B5IswdSYoeXbpZTj/u+A+sJUvqiNvanvSFYsZ+WyKfDbFri0DBGMh99ywfbW+zFRxkfHCJBeKE7xSushkeYqZyhTztVlKjQUqjSLV5kXK/hILlIMHqBoEyy1yj4EbS7PvZGn65ifSXsm9VhIzA3ZtyfHrw+++9eAi0krSdb0U8uqM5EZtWtkXMzsEHArflszsbAtxSetGgJnXtusMcDrKWGT93EI/ywaift6IvnLTJ/4e7ue/AU9GcqSXAft8JIdaS8ujEK0kXReA1ZNJ7QRevUGbC+HlxUFgtsV9cfengKdaDVpujpmdbHXoUzYu9XNvUD/3BvVzd2rlRpw/A7vNbMzMUsAB4OhVbY4CB8P1jwK/8eBmsaPAATPrM7MxYDfwp2hCFxEREdk4/u9IV3iP1ueAYwRTRnzf3U+b2VeBk+5+FPge8EMzO0cwwnUg3Pe0mT0N/IPgiu/Daz25KCIiItKtbrvJUSV6ZnYovIQrXUz93BvUz71B/dydlHSJiIiItIEmVxIRERFpAyVdPcDMvm5m/zSzv5vZz82sc5W2JXJm9qCZnTWzc2b2aKfjkeiZ2evM7LdmdsbMTpvZI52OSdaPmcXN7JSZ/bLTsUi0lHT1huPAve6+l6Ck02MdjkciEpbpehJ4CHgz8PGw/JZ0lwbwBXe/B3g78LD6uas9ApzpdBASPSVdPcDdn3X3lfmCTxDMlybd4T7gnLv/292XgJ8AH+5wTBIxd59w97+G60WCE3LHq3tI9MxsJ/BB4LudjkWip6Sr93wa+FWng5DIXK9Ml07GXczM7gLeAvyxs5HIOvkm8CXg2urUsuG1MiO9bABm9hyw7To/etzdfxG2eZzgMsWRdsYm66qlUlvSHcwsBzwDHHb3hU7HI9Eys/3AlLv/xcwe6HQ8Ej0lXV3C3d+31s/N7CCwH9jnmiekm7RUaks2PjNLEiRcR9z9Z52OR9bF/cCHzOwDQBq4w8x+5O6f7HBcEhHN09UDzOxB4BvAe9x9utPxSHTCWqf/AvYBrxCU7fqEu6tKeRcxMwN+AMy6++FOxyPrLxzp+qK77+90LBId3dPVG74FDADHzex5M/tOpwOSaIQPSKyU6ToDPK2EqyvdD3wKeG/4GX4+HA0RkQ1EI10iIiIibaCRLhEREZE2UNIlIiIi0gZKukRERETaQEmXiIiISBso6RIRERFpAyVdIiIiIm2gpEtERESkDZR0iYiIiLTB/wBBD4kt1rvQzwAAAABJRU5ErkJggg==\n", 114 | "text/plain": [ 115 | "
" 116 | ] 117 | }, 118 | "metadata": {}, 119 | "output_type": "display_data" 120 | } 121 | ], 122 | "source": [ 123 | "n = 2000\n", 124 | "uni_samples = np.random.uniform(-1, 3, n)\n", 125 | "norm_samples = np.random.normal(1, 1, n)\n", 126 | "\n", 127 | "plt.figure(figsize=[10, 6])\n", 128 | "\n", 129 | "sns.distplot(samples, hist=False, label=\"sample distribution\")\n", 130 | "sns.distplot(uni_samples, hist=False, label=\"uniform approximation\")\n", 131 | "sns.distplot(norm_samples, hist=False, label=\"normal approximation\")\n", 132 | "\n", 133 | "plt.legend" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": {}, 139 | "source": [ 140 | "### Limit range to `[-1, 3]` " 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 103, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "data": { 150 | "text/plain": [ 151 | "array([-2.11403038, -1.76619909, -1.41836779, -1.0705365 , -0.72270521,\n", 152 | " -0.37487392, -0.02704263, 0.32078866, 0.66861996, 1.01645125,\n", 153 | " 1.36428254, 1.71211383, 2.05994512, 2.40777641, 2.75560771,\n", 154 | " 3.103439 , 3.45127029, 3.79910158, 4.14693287, 4.49476416])" 155 | ] 156 | }, 157 | "execution_count": 103, 158 | "metadata": {}, 159 | "output_type": "execute_result" 160 | } 161 | ], 162 | "source": [ 163 | "lower, upper = min(samples), max(samples)\n", 164 | "\n", 165 | "space = np.linspace(lower, upper, 20)\n", 166 | "space" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 67, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [ 175 | "dist_uni = stats.norm(1, 1)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": 68, 181 | "metadata": {}, 182 | "outputs": [ 183 | { 184 | "data": { 185 | "text/plain": [ 186 | "-8.379093586553296" 187 | ] 188 | }, 189 | "execution_count": 68, 190 | "metadata": {}, 191 | "output_type": "execute_result" 192 | } 193 | ], 194 | "source": [ 195 | "np.sum([1/2000*(np.log2((1/2000)/dist_uni.pdf(s))) for s in samples])" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 69, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "data": { 205 | "text/plain": [ 206 | "-8.380821783940933" 207 | ] 208 | }, 209 | "execution_count": 69, 210 | "metadata": {}, 211 | "output_type": "execute_result" 212 | } 213 | ], 214 | "source": [ 215 | "np.sum([1/2000*(np.log2((1/2000)/(1/6))) for s in samples])" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 104, 221 | "metadata": {}, 222 | "outputs": [ 223 | { 224 | "data": { 225 | "text/plain": [ 226 | "" 227 | ] 228 | }, 229 | "execution_count": 104, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | }, 233 | { 234 | "data": { 235 | "image/png": "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\n", 236 | "text/plain": [ 237 | "
" 238 | ] 239 | }, 240 | "metadata": {}, 241 | "output_type": "display_data" 242 | } 243 | ], 244 | "source": [ 245 | "s1 = np.random.normal(2, 1, 2000)\n", 246 | "s2 = np.random.normal(2.2, 1, 2000)\n", 247 | "\n", 248 | "plt.figure(figsize=[10, 6])\n", 249 | "\n", 250 | "sns.distplot(s1, hist=False, label=\"s1\")\n", 251 | "sns.distplot(s2, hist=False, label=\"s2\")" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": 119, 257 | "metadata": {}, 258 | "outputs": [ 259 | { 260 | "data": { 261 | "text/plain": [ 262 | "-0.24610114352357795" 263 | ] 264 | }, 265 | "execution_count": 119, 266 | "metadata": {}, 267 | "output_type": "execute_result" 268 | } 269 | ], 270 | "source": [ 271 | "dist_s1 = stats.norm(2, 1)\n", 272 | "dist_s2 = stats.norm(2.2, 1)\n", 273 | "\n", 274 | "KL = 0\n", 275 | "for i in range(1000):\n", 276 | " xi = np.random.normal(2, 1)\n", 277 | " pxi = dist_s1.pdf(xi)\n", 278 | " qxi = dist_s2.pdf(xi)\n", 279 | " \n", 280 | " kli = xi*np.log2(pxi/qxi)\n", 281 | " KL += kli\n", 282 | "KL/1000" 283 | ] 284 | } 285 | ], 286 | "metadata": { 287 | "kernelspec": { 288 | "display_name": "Python 3", 289 | "language": "python", 290 | "name": "python3" 291 | }, 292 | "language_info": { 293 | "codemirror_mode": { 294 | "name": "ipython", 295 | "version": 3 296 | }, 297 | "file_extension": ".py", 298 | "mimetype": "text/x-python", 299 | "name": "python", 300 | "nbconvert_exporter": "python", 301 | "pygments_lexer": "ipython3", 302 | "version": "3.6.5" 303 | } 304 | }, 305 | "nbformat": 4, 306 | "nbformat_minor": 2 307 | } 308 | -------------------------------------------------------------------------------- /KMeans/kMeans.py: -------------------------------------------------------------------------------- 1 | # use numpy to implement k-means algorithm 2 | 3 | import numpy as np 4 | import random 5 | import matplotlib.pyplot as plt 6 | 7 | x1 = np.random.normal(loc=1, scale=.4, size=50) 8 | y1 = np.random.normal(loc=1, scale=.3, size=50) 9 | x2 = np.random.normal(loc=3, scale=.2, size=40) 10 | y2 = np.random.normal(loc=2, scale=.3, size=40) 11 | 12 | plt.scatter(x1, y1, c='r') 13 | plt.scatter(x2, y2, c='b') 14 | 15 | x = np.concatenate((x1, x2)) 16 | y = np.concatenate((y1, y2)) 17 | 18 | data = np.stack((x, y), axis=1) # (90, 2) 19 | 20 | 21 | class kMeans(): 22 | 23 | def __init__(self, k, max_iter=100): 24 | self.k = k 25 | self.max_iter = max_iter 26 | self.centroids = None 27 | 28 | def distane(self, pt, centroids): 29 | # compute distance using euclidean 30 | # return the cluster corresponds to the min distance 31 | min_dist = 10000 32 | min_index = -1 33 | for i in range(len(centroids)): 34 | curr_dist = np.sum((pt-centroids[i])**2) 35 | if curr_dist < min_dist: 36 | min_dist = curr_dist 37 | min_index = i 38 | 39 | return min_index 40 | 41 | def updata_centroids(self, data, classes): 42 | for i in range(self.k): 43 | class_i_data = data[np.where(np.array(classes) == i)] 44 | self.centroids[i] = np.mean(class_i_data, axis=0) 45 | 46 | def fit(self, data): 47 | self.centroids = random.sample(data, self.k) 48 | # iteration 49 | iter = 0 50 | while iter < self.max_iter: 51 | iter += 1 52 | # a list to store class index 53 | classes = [] 54 | # iterate all points 55 | for point in data: 56 | curr_class = self.distane(point, self.centroids) 57 | classes.append(curr_class) 58 | # update centroids 59 | self.updata_centroids(data, classes) 60 | 61 | return np.array(classes) 62 | 63 | 64 | km = kMeans(k=2, max_iter=10) 65 | res = km.fit(data) 66 | 67 | color = ['r', 'c', 'g', 'k', 'b', 'm', 'y', 'w'] 68 | 69 | for i in range(data.shape[0]): 70 | plt.scatter(data[i, 0], data[i, 1], c=color[res[i]], s=40) 71 | 72 | -------------------------------------------------------------------------------- /Multi-regression/multivariable_reg.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import pandas as pd 3 | from sklearn.model_selection import train_test_split 4 | import matplotlib.pyplot as plt 5 | 6 | 7 | class muti_reg: 8 | 9 | def __init__(self): 10 | self.b = None 11 | 12 | def fit(self, train_X, train_y): 13 | train_X = train_X.reshape(len(train_y), -1) 14 | train_y = train_y.reshape(len(train_y), 1) 15 | X = np.insert(train_X, 0, 1, axis=1) 16 | self.b = np.linalg.inv(np.dot(X.T, X)).dot(X.T).dot(train_y) # (x.T*x)-1x.T*y 17 | 18 | def predict(self, test_X): 19 | test_X = test_X.reshape(test_X.shape[0], -1) 20 | X = np.insert(test_X, 0, 1, axis=1) 21 | output = np.dot(X, self.b) 22 | 23 | return output.flatten() 24 | 25 | 26 | def error(y_true, y_pred): 27 | n = len(y_true) 28 | sse = np.sum((y_true-y_pred)**2) 29 | mse = sse/float(n) 30 | rmse = np.sqrt(mse) 31 | sst = np.sum((y_true-np.mean(y_true))**2) 32 | r_square = 1-sse/sst 33 | # ad_r_square = 1-(1-r_square**2)*(n-1)/(n-k) 34 | # print ad_r_square 35 | print 'SSE:', sse, '\nMSE:', mse, '\nRMSE', rmse, '\nR_Square:', r_square 36 | 37 | 38 | # uni-variable regression 39 | 40 | x = np.linspace(1, 10, 20) 41 | y = 2*x+3+np.random.randn(20) 42 | 43 | plt.plot(x, y, 'bo') 44 | 45 | mr = muti_reg() 46 | mr.fit(x, y) 47 | y_pred = mr.predict(x) 48 | 49 | error(y, y_pred) 50 | 51 | # plt.grid() 52 | plt.scatter(x, y) 53 | plt.plot(x, 2*x+3, '-r', linewidth=2, label='actual') 54 | plt.plot(x, y_pred, '--b', label='predict') 55 | plt.legend(loc='upper left') 56 | 57 | # multi-linear-regression 58 | 59 | state = pd.read_csv('state.csv') 60 | data = state.drop([state.columns[0], 'Murder'], axis=1) 61 | data_y = state.Murder 62 | 63 | train_X, test_X, train_y, test_y = train_test_split(np.array(data), np.array(data_y)) 64 | 65 | mr2 = muti_reg() 66 | mr2.fit(train_X, train_y) 67 | test_pred = mr2.predict(test_X) 68 | 69 | error(test_y, test_pred) 70 | 71 | # SSE: 34.9067045869 72 | # MSE: 2.68513112207 73 | # RMSE 1.6386369708 74 | # R_Square: 0.658421407881 75 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Algorithm Implemention 2 | Implement algorithms with built-in functions 3 | 4 | ## Importance Sampling 5 | - [Importance Sampling](https://medium.com/@zhangyue9306/importance-sampling-introduction-e76b2c32e744) 6 | --------------------------------------------------------------------------------