From 32fea94b0243fd054b229f79b9d95a3d5aad918a Mon Sep 17 00:00:00 2001 From: Enzo Busseti Date: Sun, 30 Jun 2024 19:53:11 +0400 Subject: [PATCH] added experiments notebook, in last commit forgot to git add --force --- experiments/CG convergence.ipynb | 2644 ++++++++++++++++++++++++++++++ 1 file changed, 2644 insertions(+) create mode 100644 experiments/CG convergence.ipynb diff --git a/experiments/CG convergence.ipynb b/experiments/CG convergence.ipynb new file mode 100644 index 0000000..9bf52c0 --- /dev/null +++ b/experiments/CG convergence.ipynb @@ -0,0 +1,2644 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3a422525", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/usr/lib/python311.zip',\n", + " '/usr/lib/python3.11',\n", + " '/usr/lib/python3.11/lib-dynload',\n", + " '',\n", + " '/usr/local/lib/python3.11/dist-packages',\n", + " '/usr/lib/python3/dist-packages',\n", + " '../env/lib/python3.11/site-packages',\n", + " '..']" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import sys\n", + "sys.path.append('../env/lib/python3.11/site-packages')\n", + "sys.path.append('..')\n", + "sys.path" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5cfe40e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOADING LIBRARY /home/enzo/repos/project_euromir/experiments/../project_euromir/libproject_euromir.so\n" + ] + } + ], + "source": [ + "import cvxpy as cp\n", + "import numpy as np\n", + "import scipy as sp\n", + "import matplotlib.pyplot as plt\n", + "from project_euromir import equilibrate\n", + "from project_euromir.loss_no_hsde import (create_workspace, loss_gradient, hessian, _densify)\n", + "\n", + "# %matplotlib tk" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "4cf3532d", + "metadata": {}, + "outputs": [], + "source": [ + "MASTER_SEED = 1200\n", + "np.random.seed(MASTER_SEED)\n", + "\n", + "m, n = 181, 170\n", + "x = cp.Variable(n)\n", + "A = np.random.randn(m, n)\n", + "b = np.random.randn(m)\n", + "objective = cp.norm1(A @ x - b)\n", + "d = np.random.randn(n, 5)\n", + "constraints = [cp.abs(x) <= .25, x @ d == 2.,]\n", + "program = cp.Problem(cp.Minimize(objective), constraints)\n", + "\n", + "data = program.get_problem_data('SCS')[0]\n", + "matrix=data['A']\n", + "b=data['b']\n", + "c=data['c']\n", + "zero=data['dims'].zero\n", + "nonneg=data['dims'].nonneg\n", + "m = len(b)\n", + "n = len(c)\n", + "\n", + "QR = False\n", + "if not QR:\n", + " d, e, sigma, rho, matrix_transf, b_transf, c_transf = \\\n", + " equilibrate.hsde_ruiz_equilibration(\n", + " matrix, b, c, dimensions={\n", + " 'zero': zero, 'nonneg': nonneg, 'second_order': ()},\n", + " max_iters=1000)\n", + "else:\n", + " q, r = np.linalg.qr(np.vstack([matrix.todense(), c.reshape((1, n))]))\n", + " matrix_transf = q[:-1].A\n", + " c_transf = q[-1].A1\n", + " sigma = np.linalg.norm(b) / np.mean(np.linalg.norm(matrix_transf, axis=1))\n", + " b_transf = b/sigma\n", + "\n", + "workspace = create_workspace(m, n, zero)\n", + "\n", + "# these functions should be unpacked inside newton-cg\n", + "def separated_loss(xy):\n", + " return loss_gradient(\n", + " xy, m=m, n=n, zero=zero, matrix=matrix_transf, b=b_transf, c=c_transf, workspace=workspace)[0]\n", + "\n", + "def separated_grad(xy):\n", + " return np.copy(loss_gradient(\n", + " xy, m=m, n=n, zero=zero, matrix=matrix_transf, b=b_transf, c=c_transf, workspace=workspace)[1])\n", + "\n", + " \n", + "def hessian(xy, m, n, zero, matrix, b, c, workspace, regularizer = 0.):\n", + " \"\"\"Hessian to use inside LBFGS loop.\"\"\"\n", + "\n", + " x = xy[:n]\n", + " y = xy[n:]\n", + "\n", + " # zero cone dual variable is unconstrained\n", + " y_error = np.minimum(y[zero:], 0.)\n", + "\n", + " # this must be all zeros\n", + " dual_residual = matrix.T @ y + c\n", + "\n", + " # slacks\n", + " s = -matrix @ x + b\n", + "\n", + " # slacks for zero cone must be zero\n", + " s_error = np.empty_like(s)\n", + " s_error[:zero] = s[:zero]\n", + " s_error[zero:] = np.minimum(s[zero:], 0.)\n", + "\n", + " def _matvec(dxdy):\n", + " result = np.empty_like(dxdy)\n", + " dx = dxdy[:n]\n", + " dy = dxdy[n:]\n", + "\n", + " # dual residual sqnorm\n", + " result[n:] = 2 * (matrix @ (matrix.T @ dy))\n", + "\n", + " # s_error sqnorm\n", + " s_mask = np.ones(m, dtype=float)\n", + " s_mask[zero:] = s_error[zero:] < 0.\n", + " result[:n] = 2 * (matrix.T @ (s_mask * (matrix @ dx)))\n", + "\n", + " # y_error sqnorm\n", + " y_mask = np.ones(m-zero, dtype=float)\n", + " y_mask[:] = y_error < 0.\n", + " result[n+zero:] += 2 * y_mask * dy[zero:]\n", + "\n", + " # gap\n", + " constants = np.concatenate([c, b])\n", + " result[:] += constants * (2 * (constants @ dxdy))\n", + "\n", + " return result + regularizer * dxdy\n", + "\n", + " return sp.sparse.linalg.LinearOperator(\n", + " shape=(len(xy), len(xy)),\n", + " matvec=_matvec\n", + " ) \n", + " \n", + " \n", + " \n", + "def separated_hessian(xy):\n", + " return hessian(\n", + " xy, m=m, n=n, zero=zero, matrix=matrix_transf, b=b_transf, c=c_transf,\n", + " workspace=workspace, regularizer=0.)\n", + "\n", + "def dense_hessian(xy):\n", + " return _densify(hessian(\n", + " xy, m=m, n=n, zero=zero, matrix=matrix_transf, b=b_transf, c=c_transf,\n", + " workspace=workspace, regularizer=0.))#1e-10))" + ] + }, + { + "cell_type": "code", + "execution_count": 718, + "id": "4df79fd5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===============================================================================\n", + " CVXPY \n", + " v1.5.1 \n", + "===============================================================================\n", + "(CVXPY) Jun 30 06:14:38 PM: Your problem has 170 variables, 175 constraints, and 0 parameters.\n", + "(CVXPY) Jun 30 06:14:38 PM: It is compliant with the following grammars: DCP, DQCP\n", + "(CVXPY) Jun 30 06:14:38 PM: (If you need to solve this problem multiple times, but with different data, consider using parameters.)\n", + "(CVXPY) Jun 30 06:14:38 PM: CVXPY will first compile your problem; then, it will invoke a numerical solver to obtain a solution.\n", + "(CVXPY) Jun 30 06:14:38 PM: Your problem is compiled with the CPP canonicalization backend.\n", + "-------------------------------------------------------------------------------\n", + " Compilation \n", + "-------------------------------------------------------------------------------\n", + "(CVXPY) Jun 30 06:14:38 PM: Compiling problem (target solver=GLPK).\n", + "(CVXPY) Jun 30 06:14:38 PM: Reduction chain: Dcp2Cone -> CvxAttr2Constr -> ConeMatrixStuffing -> GLPK\n", + "(CVXPY) Jun 30 06:14:38 PM: Applying reduction Dcp2Cone\n", + "(CVXPY) Jun 30 06:14:38 PM: Applying reduction CvxAttr2Constr\n", + "(CVXPY) Jun 30 06:14:38 PM: Applying reduction ConeMatrixStuffing\n", + "(CVXPY) Jun 30 06:14:38 PM: Applying reduction GLPK\n", + "(CVXPY) Jun 30 06:14:38 PM: Finished problem compilation (took 1.856e-02 seconds).\n", + "-------------------------------------------------------------------------------\n", + " Numerical solver \n", + "-------------------------------------------------------------------------------\n", + "(CVXPY) Jun 30 06:14:38 PM: Invoking solver GLPK to obtain a solution.\n", + "\n", + "ECOS 2.0.10 - (C) embotech GmbH, Zurich Switzerland, 2012-15. Web: www.embotech.com/ECOS\n", + "\n", + "It pcost dcost gap pres dres k/t mu step sigma IR | BT\n", + " 0 +2.796e-15 -4.250e+01 +2e+03 7e-01 4e-01 1e+00 2e+00 --- --- 1 1 - | - - \n", + " 1 +2.431e+01 +1.393e+01 +9e+02 3e-01 1e-01 1e+00 1e+00 0.6757 2e-01 1 1 1 | 0 0\n", + " 2 +2.818e+01 +2.371e+01 +5e+02 1e-01 4e-02 5e-01 5e-01 0.9551 5e-01 1 1 1 | 0 0\n", + " 3 +3.392e+01 +3.169e+01 +3e+02 5e-02 2e-02 2e-01 3e-01 0.6023 2e-01 1 1 1 | 0 0\n", + " 4 +3.568e+01 +3.389e+01 +2e+02 4e-02 2e-02 2e-01 2e-01 0.3509 4e-01 1 1 1 | 0 0\n", + " 5 +3.873e+01 +3.762e+01 +1e+02 2e-02 9e-03 1e-01 1e-01 0.4375 1e-01 1 1 1 | 0 0\n", + " 6 +3.993e+01 +3.917e+01 +8e+01 2e-02 5e-03 4e-02 1e-01 0.7327 5e-01 1 1 1 | 0 0\n", + " 7 +4.201e+01 +4.162e+01 +4e+01 8e-03 3e-03 2e-02 5e-02 0.5206 9e-02 1 1 1 | 0 0\n", + " 8 +4.295e+01 +4.273e+01 +2e+01 4e-03 1e-------------------------------------------------------------------------------\n", + " Summary \n", + "-------------------------------------------------------------------------------\n", + "(CVXPY) Jun 30 06:14:38 PM: Problem status: optimal\n", + "-03 1e-02 3e-02 0.5909 2e-01 1 1 1 | 0 0\n", + " 9 +4.380e+01 +4.374e+01 +7e+00 1e-03 4e-04 2e-03 8e-03 0.9362 3e-01 1 1 1 | 0 0\n", + "10 +4.416e+01 +4.414e+01 +2e+00 3e-04 1e-04 4e-04 2e-03 0.8013 7e-02 1 1 1 | 0 0\n", + "11 +4.427e+01 +4.427e+01 +3e-01 4e-05 1e-05 6e-05 3e-04 0.8955 4e-02 1 1 1 | 0 0\n", + "12 +4.428e+01 +4.428e+01 +7e-02 1e-05 3e-06 1e-05 8e-05 0.8943 2e-01 1 1 1 | 0 0\n", + "13 +4.428e+01 +4.428e+01 +2e-02 3e-06 1e-06 4e-06 2e-05 0.9890 3e-01 1 1 1 | 0 0\n", + "14 +4.429e+01 +4.429e+01 +4e-04 7e-08 2e-08 9e-08 5e-07 0.9801 2e-03 1 1 1 | 0 0\n", + "15 +4.429e+01 +4.429e+01 +1e-05 2e-09 7e-10 3e-09 2e-08 0.9690 5e-04 1 1 1 | 0 0\n", + "16 -nan +nan -nan -nan -nan -nan -nan 0.9890 1e-04 0 0 0 | 0 0\n", + "Reached NAN dead end, recovering best iterate (15) and stopping.\n", + "\n", + "Close to OPTIMAL (within feastol=2.1e-09, reltol=3.1e-07, abstol=1.4e-05).\n", + "Runtime: 0.079745 seconds.\n", + "\n", + "\n", + "ECOS 2.0.10 - (C) embotech GmbH, Zurich Switzerland, 2012-15. Web: www.embotech.com/ECOS\n", + "\n", + "It pcost dcost gap pres dres k/t mu step sigma IR | BT\n", + " 0 +2.796e-15 -4.250e+01 +2e+03 7e-01 4e-01 1e+00 2e+00 --- --- 1 1 - | - - \n", + " 1 +2.431e+01 +1.393e+01 +9e+02 3e-01 1e-01 1e+00 1e+00 0.6757 2e-01 1 1 1 | 0 0\n", + " 2 +2.818e+01 +2.371e+01 +5e+02 1e-01 4e-02 5e-01 5e-01 0.9551 5e-01 1 1 1 | 0 0\n", + " 3 +3.392e+01 +3.169e+01 +3e+02 5e-02 2e-02 2e-01 3e-01 0.6023 2e-01 1 1 1 | 0 0\n", + " 4 +3.568e+01 +3.389e+01 +2e+02 4e-02 2e-02 2e-01 2e-01 0.3509 4e-01 1 1 1 | 0 0\n", + " 5 +3.873e+01 +3.762e+01 +1e+02 2e-02 9e-03 1e-01 1e-01 0.4375 1e-01 1 1 1 | 0 0\n", + " 6 +3.993e+01 +3.917e+01 +8e+01 2e-02 5e-03 4e-02 1e-01 0.7327 5e-01 1 1 1 | 0 0\n", + " 7 +4.201e+01 +4.162e+01 +4e+01 8e-03 3e-03 2e-02 5e-02 0.5206 9e-02 1 1 1 | 0 0\n", + " 8 +4.295e+01 +4.273e+01 +2e+01 4e-03 1e-03 1e-02 3e-02 0.5909 2(CVXPY) Jun 30 06:14:38 PM: Optimal value: 4.429e+01\n", + "e-01 1 1 1 | 0 0\n", + " 9 +4.380e+01 +4.374e+01 +7e+00 1e-03 4e-04 2e-03 8e-03 0.9362 3e-01 1 1 1 | 0 0\n", + "10 +4.416e+01 +4.414e+01 +2e+00 3e-04 1e-04 4e-04 2e-03 0.8013 7e-02 1 1 1 | 0 0\n", + "11 +4.427e+01 +4.427e+01 +3e-01 4e-05 1e-05 6e-05 3e-04 0.8955 4e-02 1 1 1 | 0 0\n", + "12 +4.428e+01 +4.428e+01 +7e-02 1e-05 3e-06 1e-05 8e-05 0.8943 2e-01 1 1 1 | 0 0\n", + "13 +4.428e+01 +4.428e+01 +2e-02 3e-06 1e-06 4e-06 2e-05 0.9890 3e-01 1 1 1 | 0 0\n", + "14 +4.429e+01 +4.429e+01 +4e-04 7e-08 2e-08 9e-08 5e-07 0.9801 2e-03 1 1 1 | 0 0\n", + "15 +4.429e+01 +4.429e+01 +1e-05 2e-09 7e-10 3e-09 2e-08 0.9690 5e-04 1 1 1 | 0 0\n", + "16 -nan +nan -nan -nan -nan -nan -nan 0.9890 1e-04 0 0 0 | 0 0\n", + "Reached NAN dead end, recovering best iterate (15) and stopping.\n", + "\n", + "Close to OPTIMAL (within feastol=2.1e-09, reltol=3.1e-07, abstol=1.4e-05).\n", + "Runtime: 0.087315 seconds.\n", + "\n", + "GLPK Simplex Optimizer 5.0\n", + "877 rows, 521 columns, 63602 non-zeros\n", + " 0: obj = 0.000000000e+00 inf = 1.501e+02 (186)\n", + " 684: obj = 1.095693126e+02 inf = 5.235e-14 (0) 5\n", + "* 1148: obj = 4.428640698e+01 inf = 0.000e+00 (0) 4\n", + "OPTIMAL LP SOLUTION FOUND\n", + "(CVXPY) Jun 30 06:14:38 PM: Compilation took 1.856e-02 seconds\n", + "(CVXPY) Jun 30 06:14:38 PM: Solver (including time spent in interface) took 1.336e-01 seconds\n" + ] + }, + { + "data": { + "text/plain": [ + "2.7755575615628914e-16" + ] + }, + "execution_count": 718, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "program.solve(# verbose=True,\n", + " # ECOS/CVXOPT\n", + " # solver='ECOS', abstol=1e-16, reltol=1e-16, feastol=1e-16,\n", + " # CLARABEL\n", + " solver='CLARABEL', tol_feas = 1.0e-16, tol_gap_abs = 1.0e-16, tol_gap_rel=1e-16,\n", + " # solver='GLPK', verbose=True, # CVXPY intf does not work?\n", + " # SCS\n", + " # solver = 'SCS', eps=1e-16, max_iters=1000000\n", + " )#, eps=1e-16, max_iters=1000000)\n", + "\n", + "np.max(constraints[0].violation())" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "a83ea724", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1795.977318834588" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xy = np.random.randn(m+n)\n", + "separated_loss(xy)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "443067c3", + "metadata": {}, + "outputs": [], + "source": [ + "grad = separated_grad(xy)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "9aadf4cc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "H = dense_hessian(xy)\n", + "plt.imshow(H)\n", + "plt.figure()\n", + "plt.plot(np.linalg.eigh(H)[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "098870ad", + "metadata": {}, + "outputs": [], + "source": [ + "optimal_point = xy" + ] + }, + { + "cell_type": "markdown", + "id": "dc632887", + "metadata": {}, + "source": [ + "### USING LSQR INSTEAD " + ] + }, + { + "cell_type": "code", + "execution_count": 565, + "id": "1bdfca03", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.525929617483746e-10\n", + "6.522278456272828e-10\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def residual(xy):\n", + " x, y = xy[:n], xy[n:]\n", + " \n", + " y_error = np.minimum(y[zero:], 0.)\n", + "\n", + " dual_residual = matrix_transf.T @ y + c_transf\n", + "\n", + " s = -matrix_transf @ x + b_transf\n", + " \n", + " s[zero:] = np.minimum(s[zero:], 0.)\n", + "\n", + " gap = c_transf.T @ x + b_transf.T @ y\n", + "\n", + " return np.concatenate([y_error, dual_residual, s, [gap]])\n", + "\n", + "def Dresidual(xy):\n", + " \n", + " x, y = xy[:n], xy[n:]\n", + " \n", + " y_active = np.zeros(m, dtype=float)\n", + " y_active[zero:] = y[zero:]<=0\n", + " \n", + " s = -matrix_transf @ x + b_transf\n", + " \n", + " s_active = np.ones(m, dtype=float)\n", + " s_active[zero:] = s[zero:]<=0\n", + " \n", + " return sp.sparse.bmat([\n", + " [None, sp.sparse.diags(y_active).tocsc()[zero:]],\n", + " [None, matrix_transf.T],\n", + " [- sp.sparse.diags(s_active) @ matrix_transf, None],\n", + " [c_transf.reshape(1,n), b_transf.reshape(1,m)]\n", + " ])\n", + "# dual_residual = matrix_transf.T @ y + c_transf\n", + "\n", + "# s = -matrix_transf @ x + b_transf\n", + " \n", + "# s[zero:] = np.minimum(s[zero:], 0.)\n", + "\n", + "# gap = c_transf.T @ x + b_transf.T @ y\n", + "\n", + "\n", + "print(np.linalg.norm(residual(xy))**2,)\n", + "\n", + "#plt.imshow(Dresidual(xy).todense()[:])\n", + "def get_best_loss_direction(xy, direction):\n", + " return np.min([separated_loss(xy + step * direction) for step in steps])\n", + "\n", + "def get_next_point(xy, direction):\n", + " which = np.argmin([separated_loss(xy + step * direction) for step in steps])\n", + " return xy + (steps[which]) * direction\n", + "steps = np.logspace(-10,0,100)\n", + "\n", + "H = separated_hessian(xy)\n", + "grad = separated_grad(xy)\n", + "steps = np.logspace(-10,0,100)\n", + "\n", + "EXPONENT = 0.25\n", + "\n", + "TOL=1e-6\n", + "DAMP=0#1e-4\n", + "iters = np.arange(1,1000,20)\n", + "losses = []\n", + "residualnorms=[]\n", + "for iterlim in iters:\n", + " direction = sp.sparse.linalg.lsmr(Dresidual(xy), -residual(xy), atol=TOL, btol=TOL, damp=DAMP,\n", + " maxiter=iterlim)[0]\n", + " #direction = sp.sparse.linalg.lsqr(Dresidual(xy), -residual(xy), atol=0., btol=0., iter_lim=iterlim)[0]\n", + " losses.append(get_best_loss_direction(xy, direction))\n", + " residualnorms.append(np.linalg.norm(H @ direction + grad))\n", + " # if np.linalg.norm(H @ direction + grad) < (np.linalg.norm(grad)**(1+EXPONENT)):\n", + " # break\n", + " \n", + " \n", + "plt.plot(iters[:len(losses)], \n", + " np.array(residualnorms)/(np.linalg.norm(grad)**(1+EXPONENT)), label=f'||r||*||g||^-({1+EXPONENT})')\n", + "plt.yscale('log')\n", + "plt.figure()\n", + "plt.plot(iters[:len(losses)],np.array(losses)/(np.linalg.norm(residual(xy))**2))\n", + "\n", + "xy = get_next_point(xy, direction)\n", + "print(separated_loss(xy))" + ] + }, + { + "cell_type": "markdown", + "id": "20f9b808", + "metadata": {}, + "source": [ + "## MINI SOLVER " + ] + }, + { + "cell_type": "code", + "execution_count": 579, + "id": "a8b01f6d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7.819071330021671e-16" + ] + }, + "execution_count": 579, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.linalg.norm(separated_grad(xy))" + ] + }, + { + "cell_type": "code", + "execution_count": 715, + "id": "73badb8a", + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "xy = np.random.randn(n+m)\n", + "TOTITERS = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 716, + "id": "8438cc40", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iters 574 loss 27.83195265972278\n", + "iters 1312 loss 2.884542891256059\n", + "iters 1836 loss 0.6416850697554278\n", + "iters 3026 loss 0.3530810469418572\n", + "iters 3983 loss 0.2538035491703633\n", + "iters 4573 loss 0.14165754389851112\n", + "iters 5358 loss 0.08916730032290011\n", + "iters 6217 loss 0.08335596285313752\n", + "iters 7047 loss 0.0738648207906936\n", + "iters 7797 loss 0.03213948703751669\n", + "iters 8770 loss 0.028159432043503064\n", + "iters 9352 loss 0.010275255112950014\n", + "iters 10237 loss 0.00927747135369286\n", + "iters 11144 loss 0.006781680801958021\n", + "iters 11900 loss 0.004062769980356029\n", + "iters 12971 loss 0.003739825394414027\n", + "iters 13768 loss 0.0023586480261149766\n", + "iters 15169 loss 0.0023579293494375188\n", + "iters 16288 loss 0.0019166356548574444\n", + "iters 17294 loss 0.0017803944719270172\n", + "iters 18210 loss 0.0010421196530086732\n", + "iters 19616 loss 0.0010312547814803035\n", + "iters 21231 loss 0.0010309371610243117\n", + "iters 22861 loss 0.001030583195545363\n", + "iters 24431 loss 0.0010062432587785832\n", + "iters 25648 loss 0.0008681469097759874\n", + "iters 26644 loss 0.0007549318656194022\n", + "iters 27665 loss 0.0006460182098109562\n", + "iters 28946 loss 0.000623474945721827\n", + "iters 30018 loss 0.000480286753402478\n", + "iters 31216 loss 0.0004756780128140519\n", + "iters 32623 loss 0.00047019328130473194\n", + "iters 33759 loss 0.0003961818411778967\n", + "iters 34998 loss 0.00037098599279038115\n", + "iters 36223 loss 0.00035276695496022127\n", + "iters 37661 loss 0.0003439159883418181\n", + "iters 38924 loss 0.00031152190820110654\n", + "iters 40209 loss 0.00030211526187534307\n", + "iters 41448 loss 0.0002763485281438899\n", + "iters 42614 loss 0.00023099385891931794\n", + "iters 44068 loss 0.00021980253078724072\n", + "iters 45387 loss 0.00021487374690829755\n", + "iters 46752 loss 0.00020943124378992154\n", + "iters 47974 loss 0.00016553363533558773\n", + "iters 49349 loss 0.00016491340647126906\n", + "iters 50828 loss 0.0001639761874969347\n", + "iters 52269 loss 0.00015262294258455513\n", + "iters 53768 loss 0.00014860073275797957\n", + "iters 55053 loss 0.00012723072717317984\n", + "iters 56352 loss 0.00012702941176135753\n", + "iters 57843 loss 0.00012649625011643348\n", + "iters 59335 loss 0.00012626564432794855\n", + "iters 60700 loss 0.00011874249504995292\n", + "iters 62168 loss 0.00011616183871411972\n", + "iters 63483 loss 0.00010867932417266075\n", + "iters 64833 loss 9.934946860689878e-05\n", + "iters 66145 loss 9.732733104929122e-05\n", + "iters 67494 loss 9.142604022570204e-05\n", + "iters 68961 loss 9.076267369663076e-05\n", + "iters 70530 loss 9.066179087090549e-05\n", + "iters 72098 loss 9.064717580394984e-05\n", + "iters 73579 loss 8.715825324441766e-05\n", + "iters 75005 loss 8.634062288342079e-05\n", + "iters 76304 loss 7.448076493874197e-05\n", + "iters 77514 loss 7.378932120906498e-05\n", + "iters 78783 loss 7.143254137099781e-05\n", + "iters 80132 loss 6.699434953878056e-05\n", + "iters 81557 loss 6.438553921665864e-05\n", + "iters 83081 loss 6.243488458221998e-05\n", + "iters 84630 loss 6.137358512475096e-05\n", + "iters 86237 loss 6.110672596368715e-05\n", + "iters 87870 loss 6.097145784488719e-05\n", + "iters 89377 loss 4.976970466914789e-05\n", + "iters 90882 loss 4.958748564104349e-05\n", + "iters 92395 loss 4.950228981277284e-05\n", + "iters 93980 loss 4.9479443639699675e-05\n", + "iters 95491 loss 4.726459055962389e-05\n", + "iters 96958 loss 4.6541255169847844e-05\n", + "iters 98546 loss 4.640576456274344e-05\n", + "iters 100080 loss 4.611618356451744e-05\n", + "iters 101558 loss 4.3348498400970484e-05\n", + "iters 103055 loss 4.165198789605964e-05\n", + "iters 104588 loss 4.0616685481051755e-05\n", + "iters 106159 loss 4.048694165108817e-05\n", + "iters 107746 loss 4.023690468898971e-05\n", + "iters 109294 loss 3.980685622116898e-05\n", + "iters 110822 loss 3.9074661640362885e-05\n", + "iters 112428 loss 3.7420756014224874e-05\n", + "iters 113982 loss 3.6280529541493986e-05\n", + "iters 115488 loss 3.4637298116876936e-05\n", + "iters 117067 loss 3.256211190639637e-05\n", + "iters 118706 loss 3.252617102603743e-05\n", + "iters 120258 loss 3.2453490659720254e-05\n", + "iters 121754 loss 2.9532991393664534e-05\n", + "iters 123398 loss 2.9412144043696122e-05\n", + "iters 124978 loss 2.8700476344581536e-05\n", + "iters 126469 loss 2.6865476372964754e-05\n", + "iters 127979 loss 2.4870239651360155e-05\n", + "iters 129530 loss 2.3980109004745484e-05\n", + "iters 131002 loss 2.3205857059332256e-05\n" + ] + } + ], + "source": [ + "TOL=1e-2\n", + "DAMP=1e-4\n", + "\n", + "\n", + "for i in range(1,101):\n", + " \n", + "# global iter_used\n", + "# iter_used = 0\n", + " \n", + "# D = Dresidual(xy)\n", + "# def matvec(var):\n", + "# global iter_used\n", + "# iter_used += 1\n", + "# return D @ var\n", + "# def rmatvec(var):\n", + "# global iter_used\n", + "# iter_used += 1\n", + "# return D.T @ var\n", + "# wrapped = sp.sparse.linalg.LinearOperator(shape=D.shape,\n", + "# matvec=matvec,\n", + "# rmatvec=rmatvec,)\n", + " \n", + " TOL = 1e-12 #max(separated_loss(xy)**0.5, 1e-8)\n", + " result = sp.sparse.linalg.lsmr(\n", + " #wrapped, \n", + " Dresidual(xy),\n", + " -residual(xy), \n", + " atol=0.,\n", + " btol=TOL,#np.linalg.norm(separated_grad(xy))**.5, \n", + " damp=DAMP,#1e-3,\n", + " maxiter=10000)\n", + " # print('iters', result[2])\n", + " #print('iters', iter_used)\n", + " direction = result[0]\n", + " xy = get_next_point(xy, direction)\n", + " # xy += direction\n", + " TOTITERS += result[2] #iter_used\n", + " print('iters', TOTITERS, 'loss', separated_loss(xy))\n", + " if separated_loss(xy) < 1e-25:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "id": "ce3d2686", + "metadata": {}, + "source": [ + "# DEPENDENCE ON NUMBER OF CG ITERS " + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "597f8f66", + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "xy = np.random.randn(n+m)" + ] + }, + { + "cell_type": "code", + "execution_count": 460, + "id": "80b39e69", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5202885446733455e-08\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtgAAAL1CAYAAAD94ZPtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVhU1RvA8e8w7LuIsiiLuyIKivu+r7lUamWZmlkalWaZmVnaZmmalWjZpln5szQ1c0tz33HBDTcUBBVFUED2Zeb3x4UZRkBBgQF5P88zD/eee+69Z4jw5cx736PSarVahBBCCCGEECXCxNgDEEIIIYQQ4lEiAbYQQgghhBAlSAJsIYQQQgghSpAE2EIIIYQQQpQgCbCFEEIIIYQoQRJgCyGEEEIIUYIkwBZCCCGEEKIESYAthBBCCCFECZIAWwghhBBCiBIkAbYQotw4ceIEo0ePplatWlhaWmJra0vz5s2ZPXs2t27dMuir0Wj49ddf6d27N9WrV8fMzAxHR0fatGnDF198QWxs7H3vN2rUKFQqle5lbm5OnTp1eOutt0hMTMzXP2/fu1+jRo0y6Lt582Z69eqFu7s7FhYWuLu706VLFz777DODft7e3jz22GOF3ketVlOlShX8/Px4+eWXOXDgQL5x7dixA5VKxcqVKwt8n6+++ioqlarAY5mZmbi6ut7z/BkzZqBSqYr0Pb3b3d8nGxsbGjVqxMyZM0lOTiYzM5NmzZrh7e3NnTt38p0fFhaGjY0NzzzzTKH3iIiI0F3/f//730OP3xg/h7a2tgAsWbLknj9nuS9vb2+D91bYKyIiQnefu4/Z29vTrl07li9fXuC4Dh48yOOPP46npycWFha4uLjQtm1b3nzzzSJ9H4WozEyNPQAhhAD4/vvveeWVV2jQoAGTJ0/Gx8eHzMxMDh8+zLfffsv+/ftZvXo1AKmpqQwaNIitW7fy1FNP8fXXX+Pu7k5iYiL79u1jzpw5rF27lt27d9/3vlZWVmzbtg2A+Ph4Vq5cydy5czlx4gT//vtvvv5DhgwpMMCoVq2abvvbb79l/PjxPPnkkyxYsAAnJyeioqLYt28fK1eu5J133rnvuHLvo9VqSUxM5NSpU/zyyy8sXryY119/na+++uq+1yiKf/75hxs3bgDw448/MmTIkBK5bl55v2dJSUns3LmTDz/8kBMnTrBq1SqWLVtGixYtePPNN1m8eLHuPI1Gw+jRo3FwcCAoKKhI95o2bRpPPvkkZmZmDzRWY/0c5urfvz/79+83aGvbtm2+nzsLCwuDPps2bcLBwSHf9dzc3Az28/5chYeH8+mnnzJ8+HC0Wi3Dhw/X9Vu/fj0DBw6kS5cuzJ49Gzc3N6Kjozl8+DD/+9//mDt3bpHfkxCVklYIIYxs3759WrVare3Tp482LS0t3/H09HTt2rVrdfsvvfSSFtD+/vvvBV4vOTlZu3jx4vved+TIkVobG5t87V27dtUC2kuXLhm0A9rAwMD7XtfT01PbqVOnAo9lZ2cb7Ht5eWn79+9fpPtkZWVpX3jhBS2gXbhwoa59+/btWkD7559/FnjPwMBAbWG/7vv37681NzfX9uzZU2tiYqKNiorK1+eDDz7QAtqbN28WeI17Key9jBgxQmtiYqJNTU3VarVa7eeff64FtJs2bdL1mTt3rhbQrl+//p73CA8P1wLavn37agHt119//UDjL28/h7nu9XNXnP82BV0nIiJCC+T7ee3UqZO2Tp062szMzHzXuftnWAiRn6SICCGM7tNPP0WlUrF48eJ8M3MA5ubmDBw4EIDo6Gh++ukn+vfvX2jagLW1NWPHjn3g8bRo0QJAN7NbXHFxcflmDnOZmDz4r121Ws2CBQtwdnZmzpw5D3ydXNeuXWPTpk0MGDCAyZMno9FoWLJkyUNftygcHBx0KTAAb731Fu3bt+fFF18kISGB8+fP89577zF27Fj69etXpGt269aN3r1789FHHxWYbnI/5e3nsCx4eXlRrVq1fD/rcXFxODs7Y2qa/4Puh/kZFqKykP9LhBBGlZ2dzbZt2wgICMDDw+O+/bdv305WVpYu0CkN4eHhmJqaUrt27XzHtFotWVlZ+V5arVbXp23btqxatYoZM2Zw/PhxsrOzS2xsVlZW9OjRg/DwcK5cufJQ11qyZAnZ2dm88MIL9OjRAy8vL3766SeD91IS8n7P4uPjWbt2LUuXLuXpp5/WpXKYmJiwdOlSbt++zWuvvcbo0aNxdXVl3rx5xbrX559/TmxsbLH/ACmPP4fFkZ2dne9nsig/dwkJCdy6dYv69esbtLdt25aDBw/y+uuvc/DgQTIzM0tr6EI8kiTAFkIYVWxsLCkpKdSqVatI/aOiogBl5u1udwcYRZXbPy4ujm+//Za//vqLt99+m+rVq+fru3DhQszMzPK9fvvtN12fb7/9loYNGzJz5kz8/f2xs7OjR48eBAUFlUigkvver1279sDX0Gq1/Pzzz9SoUYPevXvrHtQMDw9n+/btDz3GvPJ+z6pUqcLgwYPp0KED3333nUG/OnXqMGfOHJYtW8aBAwdYsmSJ7uG/ovLz82P48OHMmzeP69evF/m88vBz+DBcXV3z/Uw2aNAgX7/cP3YyMzO5cOECzz//PNbW1nzwwQcG/T777DM6dOjAN998Q5s2bbCxsaF9+/Z89tlnJCUllcl7EqIikwBbCPFICAkJyRdgFKWCQ3Jysq6/s7Mz48eP56mnnuKTTz4psP+wYcMIDg7O98qbxlCnTh2OHz/Ozp07mTlzJj169CA4OJhXX32Vtm3bkpaW9lDvtSRmmHfu3ElYWBgjR47UpWmMHj0alUrFTz/99NDXzyvv92zXrl18/fXXHD58mD59+pCenm7Qd/z48bi5udG9e3c6der0QPf7+OOPyczMZObMmSUx/GJ50J/Dh7V169Z8P5Nr1qzJ1y/3jx1zc3Pq16/Pxo0bWb58OQEBAQb9qlatyu7duwkODuazzz5j0KBBnD9/nqlTp9KkSZMyeU9CVGRSRUQIYVTOzs5YW1sTHh5epP6enp4AXL582aC9QYMGBAcHA7B48WK+//77Il3PysqKXbt2AXD9+nXmzp3L8uXLadq0aYHVPqpVq6bL0b4XExMTOnXqpAsSk5OTGTNmDCtWrOCnn37ilVdeKdL4CpL73t3d3QF0ebKFpQRkZWXly6X98ccfAXj88ceJj48HlLzoDh06sGrVKhYsWICjo+MDjzGvu79nHTt2pFq1ajzzzDMsWbKEl19+2aC/ubk55ubmD3w/b29vXnnlFRYsWMCkSZOKdI6xfw4flp+fH87OzvftN2zYMCZPnkxmZiYnT55k6tSpPP300xw9epR69erl69+iRQvdf7vMzEymTJnCl19+yezZs5k9e3aJvw8hHhUygy2EMCq1Wk337t05cuRIkXKKu3TpgqmpKX///bdBu5WVlS4YyA08i8LExER33mOPPcamTZto3LgxM2fO1KUBlAQbGxumTp0KwKlTpx74OqmpqWzdupU6depQs2ZNAFxcXAC4evVqgedcvXpV1weUvNtVq1YB0LJlS6pUqaJ77d69m7S0NH7//fcHHmNRNG3aFIDjx4+XyvXfe+89rK2teffdd4vU39g/h2Ul94+dtm3b8tJLL7FmzRqSk5N544037nuumZmZLpXkYX6GhagMJMAWQhjd1KlT0Wq1jB07loyMjHzHMzMzWbduHaDU9X3hhRdYv359gYuKPCwLCwuCgoJIS0vj448/fqBrREdHF9h+5swZgAcOvLKzs3n11VeJi4tjypQpuvZ69erh5eXFn3/+mS995ObNm2zfvp0ePXro2n7//XdSU1P56KOP2L59e76Xs7NziaeJ3C0kJASgwDz3klC1alWmTJnCypUrOXToUJHOKU8/h2WlY8eOPP/886xfv96g/nZp/QwLUVlIiogQwujatm3LokWLeOWVVwgICGD8+PE0btyYzMxMjh07xuLFi/H19WXAgAEAzJ8/n/DwcJ599ln+/vtvBg0ahLu7OykpKZw9e5b//e9/WFpaPvBiI507d6Zfv378/PPPvPPOOwYPvt24caPA1RTt7e3x8fEBoHHjxnTv3p2+fftSp04d0tLSOHjwIHPnzsXFxYUxY8bcdwy599Fqtdy5c0e30Mzx48d544038pV/++KLLxg2bBjdu3dn7NixuLq6cuHCBT777DPMzc2ZPn26ru+PP/5IlSpVeOutt7C0tMx37+eff5558+Zx/Phx/Pz8dO3r1q3Dzs4uX//7LU6T93uWlpZGSEgIH3/8MY6OjowePfq+34sHNXHiRIKCgti4cWOR+pe3n8PiOHLkSIELzfj4+GBvb3/Pcz/66CNWrFjB9OnT2bp1KwC9e/emZs2aDBgwgIYNG6LRaAgJCWHu3LnY2toyYcKEUnkfQjwyjFR/Wwgh8gkJCdGOHDlS6+npqTU3N9fa2NhomzVrpn3//fe1MTExBn2zs7O1v/zyi7Znz55aZ2dnrampqdbBwUHbqlUr7fTp07VXrly57/3utcDHyZMntSYmJtrRo0fr2oBCX+3bt9f1++6777RPPPGEtnbt2lpra2utubm5tk6dOtpx48blW8ilsIVmcl8mJiZae3t7bZMmTbQvvfSSdv/+/YW+n61bt2p79eqldXR01Jqammrd3Ny0zz33nPbChQu6PsePH9cC2okTJxZ6nbNnz2oB7WuvvabVavWLmRT2upe7+5qZmWlr166tHT16tDYsLKzAcwr6ntxL7kIzc+bMyXds8eLFunsXdaGc8vRzqNUWbaGZwl5btmwp0nUmT56sBbQ7d+7UarVa7YoVK7TDhw/X1qtXT2tra6s1MzPTenp6akeMGKENDQ2973sSorJTabUlXPBUCCGEEEKISkxysIUQQgghhChBEmALIYQQQghRgiTAFkIIIYQQogRJgC2EEEIIIUQJkgBbCCGEEEKIEiQBthBCCCGEECVIFpopJzQaDdeuXcPOzg6VSmXs4QghhBBCiLtocxb/cnd3x8Sk8HlqCbDLiWvXruHh4WHsYQghhBBCiPuIioqiZs2ahR6XALucyF1+OCoq6r7L2gohhBBCiLKXmJiIh4eHLm4rjATY5URuWoi9vb0E2EIIIYQQ5dj90nnlIUchhBBCCCFKkATYQgghhBBClCAJsI0sKCgIHx8fWrZsaeyhCCGEEEKIEqDSarVaYw9CKEnzDg4OJCQkSA62EEIIkYdGoyEjI8PYwxCVgJmZGWq1utDjRY3X5CFHIYQQQpRbGRkZhIeHo9FojD0UUUk4Ojri6ur6UOuSSIAthBBCiHJJq9USHR2NWq3Gw8Pjngt7CPGwtFotKSkpxMTEAODm5vbA15IAWwghhBDlUlZWFikpKbi7u2NtbW3s4YhKwMrKCoCYmBiqV69+z3SRe5E/BYUQQghRLmVnZwNgbm5u5JGIyiT3j7nMzMwHvoYE2EIIIYQo1x4mF1aI4iqJnzcJsIUQQgghhChBEmALURFptXB2PRz6HhKvGXs0Qggh7rJjxw68vb11+6NGjWLGjBnFPq+o5y5ZsoQuXboYtHXp0oUlS5YUabwPe39hSAJsI5OFZsR9JcfB9VOGbZf3wf+Gw4a3YOPbxhmXEEIIo1qyZAlt2rQx9jBEASTANrLAwEBCQ0MJDg429lCEsSXFQHqSfv/0GvjKD+bUhm87KEF1rqtH9NvXT+a/VsJViL1QakMVQghRsh7kgbq///6bQYMGlcJoxMOSAFuI8iDuohJMz/OBkOWg0cCW9+F2RE4HLawZD6dXK7sxZ/TnxkdCVrp+P2Q5fN0MFrWHmLNKGsnZDcqx1Hj45w0lYI+SP+qEEMJYZsyYgb+/Pz/99BO1a9fGwsKC4iyunZaWxr///svAgQOLfE5WVhavv/46jo6OVK1alSlTpjBy5EgGDx78AO9A3IvUwRaiPDj1F2SmKNtrX4Ho4xB/Wdlv9RIcWqwE23+OAkdPiDmtP1erUY5VawCRB2FtIGiV0lYsbK3v134i3A6H0LXK/t+vwri9oJZfA0KIikGr1ZKamW2Ue1uZqUu8mklYWBh//PEHq1atKna95f/++w9XV1caN25c5HM+//xzfvvtN37++WcaNWrEV199xZo1a+jatWtxhy7uQ/5lFaIkabWw7xvITIXOb0NRfxmf25DnGho4uEjZbvsq9JgBp1ZBSpzS9n03fV9zO8i4A0d/gct74doxpd2mGiTfNLzH3vmG+zfPwokV4NkGbp5TxmpTDWoEGI47OwviwqB6w6K9FyGEKCWpmdn4vL/ZKPcO/bA31uYlGzZlZGSwbNkyqlWrVuxz165dW+z0kG+++YapU6fy+OOPA7BgwQI2bNhwn7PEg5AUESFK0oGFsGU67PhUmYUuioSrcO0ooILXQwyPtQ0EtRkM+wV8n8x/br0eytf9C/TBtVNteO0otHgBPNvCY/OhwyT9Oe1eh27Tle1tH8H3XeF/z8Dyp+GH7vD7MMjOVKqUpMYrM90LW8OZdUX/PgghhLgvLy+vBwqutVot69atK1Z6SEJCAjdu3KBVq1a6NrVaTUBAQLHvL+5PZrCFKCmabNjxmX7//CZw9y+4761LcOM0NHwMTq1U2jzbglMtGPgN/P2aEgjbuyvHvDuAV3uo3khJA4k5Aw37g1UVw+s61VaCcUt7eOzLPGPTKGOxc4OaLSHhihJc34nW96laD+IuwIV/4St/SLwCzvUh9rxyPPRvaDTgIb5BQgjxcKzM1IR+2Nto9y5pNjY2D3TeoUOHyMjIoEOHDsU+9+40l+LkfYuikwBbiJJwOwIOfgfpifq2s+uhyzuG/eKjlBSSQ98p+/2+gBN/KNtNhylfmz8PtTqDg4fhuSoVdJps2HbrEuyaraSVNH4chi4peHwmJuCT56NERw+o3xfObwSXJvDsn2DvBiG/Kw9TJl5R+uUG1wDhu5QUGFlRTQhhJCqVqsTTNCqitWvX0r9//2LlbTs4OODi4sKhQ4fo2LEjoCxFf+zYMfz9/UtppJWXpIiUkDt37tCyZUv8/f1p0qQJ33//vbGHJMpK0k34uZ+SHgLg2hRUarh+An4bBhF7lPbUeCV4zQ2uQaljfeMUqM0NA+AqXkpQfD9OtSEwOCdXe2bxxv3k9/DyLuVl76a0+T0Dlg6G/UytQG0BSdcNA24hhBBG8aDl+V577TVmzZrF2rVrOXfuHBMmTOD27duyFH0pkD8DS4i1tTU7d+7E2tqalJQUfH19eeKJJ6hataqxhyZK043TShCdeFXfVq8XeLSG4O/hwmYI2wJ1eyipF7lcmiiz3bmVQlq/DNZODzYG57rQ+5Pin2dhB25+hm0qFfT5TPlDIFe3aRD2H1zarpT86/khaDLzB+JCCCFK3cWLFwkLC6N37+KnykyZMoXr16/z/PPPo1areemll+jdu3exK5iI+5MAu4So1Wqsra0BpTZldna25DU9imIvwB/PQ+2u0OdT2DpTSaewdoaUWKVPvV7gXA8iD8CNk0r6Rt7guunT8MR3kHILlj0OafHQ8U2jvJ0C+T0DttWVmXhzG+Xl5qcE2MHfKy87dwg8IEG2EEI8oBkzZjzQ8uNr166lW7du2NraFvtcU1NTvvnmG7755hsANBoNjRo1YtiwYcW+lrg3SRHJsWvXLgYMGIC7uzsqlYo1a9bk67Nw4UJq1aqFpaUlAQEB7N692+B4fHw8fn5+1KxZk7fffhtnZ+cyGr0oE7FhSkAcEwoHgpSVFi/+pxwbuQ7eOA0jVoNna2U2evweeP822NfQX6Pre9BvtrJt7QRjtyuVQ+5+WNGYVCplxt22uhJcA9TqBP7P6fvcuQZhW40zPiGEqMRq1qzJ1KlTH+jcy5cv8/3333P+/HlOnjzJ+PHjCQ8PZ/jw4SU8SiEBdo7k5GT8/PxYsGBBgcdXrFjBxIkTmTZtGseOHaNjx4707duXyMhIXR9HR0eOHz9OeHg4v//+Ozdu3Cir4YuSEndRKVF3t4vb4IdukBClb/tzJGiywM0fXHzAoSbU6WZ4nokJPP0bVPFWHmjsPNlw1tfEpOI8NDhoATz/Nzh4Kvtn/tEfizkDSx4zXM69qG6eU1aflE98hBDivoYNG6Z7SLG4TExMWLJkCS1btqR9+/acPHmSrVu30qhRoxIepZAUkRx9+/alb9++hR6fN28eY8aM4cUXXwRg/vz5bN68mUWLFjFr1iyDvi4uLjRt2pRdu3YxdOjQUh23KCHJsUqJveDvwbUJPPWb8qAhwJGlyvLi2mwlt3rgAljcBTKTleOtXrr3td2bwYQi1sQuz1QqqN1ZeTjyp95w+i8lFabru7B0gLKwzcox8OaZ+18rr6CcmqxqM2gypOTHLYQQRuDt7c3EiRN1+4MHD8bR0bHY5xX1XH9/f0aNGmXQNmrUKIMKIR4eHuzdu7dU7i8MqbSSKJyPSqVi9erVDB48GFBWWrK2tubPP//UrX4EMGHCBEJCQti5cyc3btzAysoKe3t7EhMTadu2LcuXL6dp06YF3iM9PZ309HTdfmJiIh4eHiQkJGBvb1+q70/c5fI+WDpQeXAvl60rvLARLBxgXiPITge/4TBgPpha6MvZ+QyCoUsrzix0SdBkK7P3hS0880F80b8fmanwiauy3XwkDPy66OPQapVXUaqtCCEqpLS0NMLDw3XpmUKUhXv93CUmJuLg4HDfeE1msIsgNjaW7OxsXFxcDNpdXFy4fv06AFeuXGHMmDFotVq0Wi2vvvpqocE1wKxZs5g5s5hl1cSDO7UKNr6jLMKSeFVZ9bDbdOXBxFVj9cF1y7FKWb2bZ5QHGFNvK8G1mz8MXqgPHP2HK0uMO3pVruAawEQNT/0Ky4fDufX5j98OV1JG4sKg0UBl8ZzCXD+l385dCr4oji6DLe+DnSu8tBNMzYt+rhBCCFHKJMAuhoJWP8ptCwgIICQkpMjXmjp1KpMm6Zevzp3BFqVk5QvK15/76NsyU+HCFqUKiFMdeHmnUrouYi8s6Qeha/R9W43NH0g71S71YZdrXd9VHnQ0tVS+P0d/geQY+LqZvs/OOTBud+FBdu7y7qDUDS/InRvKtZs/D3Yuyn+zv19VjqXeUpak92hZMu9JCCGEKAESYBeBs7MzarVaN1udKyYmJt+sdlFZWFhgYWFBUFAQQUFBZGdnl8RQRUGyMgpuP/yj8tXRC0b+rQTXoCxZbm4HGXeU/TavQBMpYZSPqy9MPAlWjkrajCYL9s5XjplaQVaq8j0M/iF/nW6NBnbMUlahzBUfqf80waEmJFwFj1YQ8htcPwnhO5WHLNffVdIwcv/9A2ytFnZ+Dhb20PaVh33nQgghxD1JgF0E5ubmBAQEsGXLFoMc7C1btjzQSkp5BQYGEhgYqMvpEaXg9F+G+xYO4NUWzm9S9vt8pgR0uUxMYNA3cGAR9JuTfzEWoWeX5w/MTm8ps/oZyeD7pDKz/PtQ2B8EUYegTldl1htgy3TYn1OxR20O2Tl/BJ38w/D6ef/bReyGda8ri/OYWUP7CUqQHnkA2r+ef2x5l3WPPq70BWg8GOzdH/qtCyGEEIWRADtHUlISYWFhuv3w8HBCQkJwcnLC09OTSZMmMWLECFq0aEHbtm1ZvHgxkZGRjBs37qHuKzPYpWzHZ/rAKlffz5TFXg4sBLTQoIDqMY0fV16i6CzsIGCkft+mh1JB5doxuHJIeYVtVcoUXtym9OnzOTQfAXeuw7mNSl3x3GO5bF2VfPfQNXBsmdJWvzfU6Z4TYO+DrHRlJtu1qVJffPuncPA7eH4tuPsri+Tk2joDen8KNlKnXgghROmQKiI5duzYQdeuXfO1jxw5kiVLlgDKQjOzZ88mOjoaX19fvvzySzp16lQi9y/qU6niPqKClRQDR09YPU6Z9QRllnTIT8rDio6S615mMpJh79ew87P8x7q+p9QFv1tyHPzvGXBvrsyEO9dTUjtWjtbnxT/1K9TvA/ObwJ1oJQ88K02ZQW/3OvwzUelXxRsa5tTnvnbU8D4txii549Wl/qsQ5ZVUERHGUBJVRKS+VY4uXbroKoDkfeUG1wCvvPIKERERpKenc+TIkRILrkUJSbkFSx+Dn/vCl42V4Fqlhm7vwfSb0GiABNdlzdwGuk6FSWfAuT7UbAltX4WR/xQcXAPYVIUx/yqfNHi0VHK8TUxgyM8wYg0MW6YEzWozaJ3zCVJWmvL11iV9cA1wO0JJRbk7uAYlB3/rjBJ7q9y5DhkpJXc9IUSFtmPHDry9vXX7o0aNKtLS6HefV5xzc6lUKiIiInT7S5YsoUuXLkU+P5e3tzc7duy459hyaTQahg4dikqlYsKECcW6T0ZGBnXr1r1vje6HlZ6ejqenJ0eOHCnV+4AE2EYXFBSEj48PLVtKFYSHdm6DPtACJaB7NRg6FRLIibJj7678t3hxq/LAY60HWIXMxETJ4/YZqM+tbvECeLRRZri9OoBdTm61a5P853eYBK8dVWa/c53fpKSSnF1f+MOwudLvwI7P4Yee8G1H+KGH8iAmwI1QmN8UPnWDbzvAyZXFf39FlRyrPB8gwbwQld6oUaMMAmljGj9+PHv27OG7777jp59+4qOPPiryuYsXL8bLy4v27dvr2j755BPatWuHtbV1kRe5GTVqFCqVyuDVpk0b3XELCwveeustpkyZUuSxPSjJwTYyecixhJz5B9YGKtu1OitpAt4dwEw+UnykWdrDmM36/ZRbcOFfJa/+s5wl3Wt1gl4f6x9WrVoH3rupHM9KhY1vK+127tCgj/LQ6+0IMDFV8sVXvajcJ/qEUuM7r/8NB692Ofn8Oa6fVHLDS2tVyj9HKZ/OxIVB/7mlcw8hRJnLzMzEzMzsvv1u3brF8uXLeeUVfUWkixcvsn//fp577rnSHGKhpk6dyqZNm9i1axf16tWjadOm9OvXD2dnZ8aPH3/f87/55pt8M/QZGRkMHTqUtm3b8uOPPxZ5LH369OHnn3/W7ZubG66T8OyzzzJ58mTOnDlTqkvEywy2qNg0GmW2cMWz+rZ+X0C9HhJcV0bWTuD3tBIYP/G9kqc95Of8lWBMzfVlGXPduQaHf4L/PlRmqBd3gd1zlQckQ9cqwbWdOzz2JfTKKTsYHWIYXOeKC4PsLGU78Rpc2lm893HlCJzblL89/Y7+uYLgH5RKKUJUJlqt8myHMV4l/P/bjBkz8Pf356effqJ27dpYWFhQlMfiLC0tuXr1Kn369OHKlSt8++23jB49mnr16hXr/n///Tf16tXDysqKrl27snTpUlQqFfHx8cW6zpdffsnKlSvZvXu3bgxt2rRh27ZtzJw5k//973/3PP/o0aOEhYXRv39/g/aZM2fyxhtv0KRJAZ9I3oOFhQWurq66l5OTk8HxqlWr0q5dO5YvX16s6xaXzGAbmVQReQhZGfDbkxC+S9m3qQ6DFkC1+sYdlygfmg5TXoXxfwb2fgUuTZSc779fg1Mr9eUDs9P1wbO5nZIz7v+svvqIW1NY/xYkXYcqtaBeT2gbCF/6QkaS8kBm1EGlcsqtS/D079Cwf/5xaLVw8k+lekqHScqiPL8+AWnxSjpLowFKv7iLsPiuB7FvnoPqDR/muyRExZKZAp8aqczmu9eU50pKUFhYGH/88QerVq1CrVYX6Rxra2s+/fRTNmzYwMCBA8nKyuK///4r0ux3roiICIYMGcKECRN48cUXOXbsGG+99dYDvYc33niDN954I1+7v79/vvVDCrJr1y7q169fYgUeduzYQfXq1XF0dKRz58588sknVK9e3aBPq1at2L17d4ncrzASYBuZpIg8IK0W1k3QB9euTeDp5fIQoyi6TpOVEoB+T4O5NfSdDWf+1tfkzuvVYLB3M2yr1QkCDyrbeVf5dG2qlA5cNcaw/575SoCtyQZUSk45KPnUm6cq22Fboe/nSnANsG6isvCRjTMcXQrpCYbXvLBZAmwhKrCMjAyWLVtGtWrVinxOWloan376KQcPHqRLly60aNGCHj16MGfOHFq1alWka3z77bc0aNCAOXPmANCgQQNOnTrFJ598cp8zS15ERATu7iXzR1Pfvn0ZOnQoXl5ehIeHM336dLp168aRI0ewsLDQ9atRo0ap565LgC0qpmPL4PjvSpWQZ/+Auj2MPSJR0VjYGa7qaFMVHv8Orh6BZs8pD81u+xi8O+YPrnPlDaxzueUE2He7cgg+cVfKSNq5grWz8iBu5H59n+SbsPIF/X5KrFIVZdgyuJzTr/0E5dOaf6dBxF5lP9fF7WDnBtUawI3TYFVFWSHTo7U+oBeiIjOzVmaSjXXvEubl5VWs4BogJSUFFxcXNm3axOjRoxk3bhxjx45l//79RQ6wz507l6+4QlHPfVCRkZH4+Pjo9t99913effddUlNTS6wE41NPPaXb9vX1pUWLFnh5ebF+/XqeeOIJ3TErKytSUkr3QXEJsEXFodEoK/2d26ivh9z1XQmuRcnxfUJ5gVIf22+4EqQWh/9wCPtPKS94JdjwWGay8jU+Unnllg80t1VKEP7YE8jJwfR/Dk78D86sg5mO+msEjIb0RGX7wmblOo6ecP5fZeVMSwflj4Kz/+jP6TETOkxUtrVaZSEeC7uCV8AUojxTqUo8TcOYbGyK/16cnJwIDAw0aKtTpw516tQp8jW0Wi2quyYISntZFHd3d0JCQnT7ubnRzs7OnDx5slTu6ebmhpeXFxcuXDBov3XrVrH/sCkuCbCNTHKw7yM7U6makJYAKhMIv+thsRYvFHiaECWisJnre3Hzg9cOK9t/vawEycP/UBbMiY+Cze/CjVPKcUdPJUD2H67U/O7wBuyZpyyM1HESVPGC7Xk+slWplcVztBolkE5LUBbb8WoPl3Pqx6YlGAbXAFs/UEojqtTKsV3Kx8I0flzSqoSowPKu1VEcDRs2ZMOGDQZthw8fLoERFc7U1JS6devma2/WrBmLFi0qMOh/WHFxcURFReHmZvi7/NSpUzRr1qxE73U3+czQyAIDAwkNDSU4OPj+nSujA4uUgCBid/7guuFjStUIIcqrx76EVw4qS7s71YbanZWqJqZWUCNAqcv94jZl6XaAHh/AG6eVnO+qdZSAu8tUZcl5lRrajFdm8EzU0PRp/X1yg+tcVbxh7DZ46wJYV1Xavu8Gizvrg2tQPg3KKz1JSTuR6iRCPNJefvllzp49y5QpUzh//jx//PGHLlgv6SD3frp27UpycjKnT582aI+MjCQkJITIyEiys7MJCQkhJCSEpKQkXZ+GDRuyevVqAJKSknjrrbfYv38/ERER7NixgwEDBuDs7Mzjjz9ucO3du3fTq1evUn1fEmCL8is7E3Z9oWzbuiof1w//A96Jgj6fQ7859z5fCGMzt87/EGK1+jAhBJ7/W1mNsmaA8jWXQ00lQAalvcs78NIOmHpFqeedq99seD1ECdZBeWhz2nV4OxxePaIE8LbVlQC9MHfPdG+ZDkv66SupCCEeSbVq1WLlypX89ddfNG3alEWLFjFt2jQAg4cBy0LVqlV54okn+O233wza33//fZo1a8YHH3xAUlISzZo1o1mzZgYz7efOnSMhQXn4W61Wc/LkSQYNGkT9+vUZOXIk9evXZ//+/djZ6cuy7t+/n4SEBIYMKaW1CnJIiogov64eVaomWDkpS23nfUirzTjjjUuIh2XnWvxzzAt4wMqpFjy/BhKvQuMnlNltMyvDPq3GQssXYdtHyux0VpqSw33rkvKp0KUdULuLMmt9+CflnH/fgwtblFQUC3uwrgIDvlZmzoUQJWLGjBnFWv68pA0cOJCBAwfq9j/55BNq1qxZYg8cFse7775Ljx49ePfdd3XB8JIlS+6bApM3b9zKyorNmzffo7di3rx5TJ48GSsrq/v2fRgSYIvyKzclpFZHqYAgRGE829y/j0oF3d83bNvwNhz6Dja/B6PWKatg5nV3SpZzfcOKJUKICm3hwoW0bNmSqlWrsnfvXubMmcOrr75qlLE0adKE2bNnExERUeyFZYojPT0dPz+/Aut2lzQJsI1MHnIsRHqSUpMYlKXPhRAlq+tUOPwj3DgJn3srZQNz+T2j1JhPvKpv2zkbWo5V6oRHHlD+8E29rZQPbDzYMM1FCFHuXbhwgY8//phbt27h6enJm2++ydSp90gpK2UjR44s9XtYWFjw3nvvlfp9QAJso5OFZgqxZjxcPwlqC6hXug8iCFEpWVUBjzZweY+ynxKrfO08RSl/qcmGJY8p7cmxkHoL9gfBvq+VFJPW4yHmtBKI7/wMuk1XAm0hBADe3t5MnDhRtz948GAcHR2LfV5xzs31wQcfGPT39/dn1KhRBn2+/PJLvvzyy3teZ+LEiXh7e99zbKJgKm1pFz4URZIbYCckJJTYcqHlXmo8rBwNXu2UB7Rypd+Bz2spC3KMWAN1uhZ2BSHEw9j7tfJgY16vHlZKCua1daZSPjAvUyvISjVse2knuPsbtqXehpDlytL0xa0pLiq9tLQ0wsPDqVWrllFyg0XldK+fu6LGa5LYKown+Hu4uE1ZLS8xZ2WuM+tgVk0luHaqLcG1EKWp1VhoneeBYTPr/ME1QJMCnra/O7gGiNij344Ng5/7K+knm6fC5mkPPVwhhKgoJMAWxqHVKrNauQ7/BFHB8Mfz+jZZoVGI0mVmBX0/h9ePQYP+MGp9wf1cGkO1RgUfG/gN9JihbEcdUFJLEq/BnyP16ScAIb/BiT+lxrYQolKQAFsYx/WTcOuifv/AIljxrFIWDAAVNH3KKEMTotJxqg3P/A41mhfep8mTylcHD2iXs8R6zVbg/6ySyw3KJ1Bf1Id5jfSrVeb114v6h5eFEOIRJg85GlmlrSJyJWflylqdIfkmxIRCRpKy/PPrIcpS0Ra2Rh2iECKPFmOUT5l8n4AG/cC1CTTsr9TGdm8GppZKje3chyWr1oWu05S+10/CjzmfSIVtBZ9BxnsfQghRBuQhx3Ki0jzkqNXCPxPhyBJlv/MUpY7vr0PA1EL5uLmgfE8hRPl2erWy8qqlIwz7BWyqGh4/txGWP60s+T5itRKUa7PlwUdxT/KQozCGknjIUWawRdnJTIOdn+uDa4CaLaFON5gapZTkU8uPpBAVUuPHlVdhPNsqX7XZ8EvO6nHWVZVl4B09c45plUVxhBCigpMcbFF2lj+dv9RXjQDlq7mNBNdCPMqsHJVZ67xS4mDNK8p25AH4zEu/XHtecRch9kKpD1EIIUqKRDSibFw/BZe2K9utXgKnOkq+tbWTccclhCg7jy+G77sqz1vkitit1MpeNwHSE+CfN6DFC8qxy/sg6pDyh3laAky+CDbOBV9bCCHKEZnBFqVLo4Gb5+DfnBq4jR+HfnOgzThl4QkhROVRrT70+jh/e/QJZTY7169P5tTR7gtbP1CCa4CzhZQR3DkH5vkoeeDnNipt8niRMLL09HRef/11qlevjqWlJR06dCA4WHnAf8eOHahUKv777z9atGiBtbU17dq149y5cwbXWLduHQEBAVhaWlK7dm1mzpxJVlaWMd6OKCaZwRala99XsHWGsq1SQ9vXjDocIYSRVffJ35abk50rbCsEtczfb93rSqWSmFDwfRJqdVIC6e05Qfufo5SvI9fB2lfBrSk89WuJDl+UDykZZRtkWpsXP1x6++23WbVqFUuXLsXLy4vZs2fTu3dvwsLCdH2mTZvG3LlzqVatGuPGjeOFF15g7969AGzevJnnnnuOr7/+mo4dO3Lx4kVeeuklQFkKXZRvUkWknHgkq4hotfB1M7gdruwPXQqNBxt1SEIII0tLgM9yHmr0ag+X9z74tWYkKPnZ39xVv9vWBZJuKNvTrisL6ogKqbBqDt7vFPJpRimJ+Kx/sfonJydTpUoVlixZwvDhwwHIzMzE29ubiRMn0rJlS7p27crWrVvp3r07ABs2bKB///6kpqZiaWlJp06d6Nu3L1OnTtVd99dff+Xtt9/m2rVrJffmRD6yVPojICgoCB8fH1q2LGC2pqKLDlGCa1MrmHpVgmshhPLsRYP+ykx2m/FFP6+g1BKNBsJ35m/PDa4BYs8Xf4xCPKSLFy+SmZlJ+/btdW1mZma0atWKM2fO6NqaNm2q23ZzcwMgJiYGgCNHjvDhhx9ia2ure40dO5bo6GhSUlLK6J2IByUpIkYWGBhIYGCg7i+iR0JmKuxfAAe/U/br95JFY4QQes/8rnzNylCeyzi9uuB+1X3gyR+V3yk1A5SHHs9t0B/f/w1sef/e9zq9Rlmp0sJOygA+QkI/7G3sIdxTbnKA6q6fN61Wa9BmZmam285t12g0uq8zZ87kiSeeyHd9qQle/kmALUrG7QgloDa3gZtnlSWTASwclNXchBDibqbmMHQJDF4Eu+YoNfFvnlXK+YXvUqqJWOaZeHDwMDw/b3Dd7nXlU7PwXYZ99syD48shO1PJ3x66FOr1KHg8147B0kHQeTK0k+dFyrMHyYkuS3Xr1sXc3Jw9e/YYpIgcPnyYiRMnFukazZs359y5c9StW7cURypKS/n+CRXlX2aq8mT/P29AeqLhsbo9oPM7UK2BccYmhKgYzKyge06w7N1B+ZpbIz+vVmPh6FIlUM7rzfNg56LMUP85CpJjoU5X2PaRcvxOtL7v0SWFB9jr31JKBf77HrR9VWa7xQOzsbFh/PjxTJ48GScnJzw9PZk9ezYpKSmMGTOG48eP3/ca77//Po899hgeHh4MHToUExMTTpw4wcmTJ/n44wJSpkS5IjnYIr/0JLh9WV+DtjBXj8KClrBqjBJcm+Z8ZGVTHYYtg+dWgccjmFsuhDAO53rwxmnoNFnf5tVBCa5BCYiHLYXR66F2l4KvcWkXZGcpv9v+GAkbJiu53BqN4WI2C9vee3Gb7Ew4/LNShlSIAnz22Wc8+eSTjBgxgubNmxMWFsbmzZupUqVKkc7v3bs3//zzD1u2bKFly5a0adOGefPm4eXlVcojFyVBqoiUE+WqisjP/fI82a+CMf+CRyvDPlqtElzHXQCrKtCgH/T9XDmmtlA++hVCiNIQH6WU7Eu4Cn1mQd3uBfc7sw5WPJe/fcjPShm/zGRlf+Q65Vprxhn2azYCfJ+A8N3Q9V1Q6/Nl2faxktYCYOcOT3ynlA0UJepe1RyEKC0lUUVEUkSEXtxF2Pf1XWWztMosz+AgJT8yV/hOJbg2t4PXjylBthBClAVHDxhRyIOReTUaANUawc2cqg2+Q+DUSlgz3jDNZO2rEB+pbNu56VNKLmyBY8uUbXt3JUUFlBSU/Qv159+5Bsd+lQBbCKEjKSKVUfRx+KEnLMvzZPK1EPihOxxZouzX6gwTTkCVWso/Hr8N1a+QBhD8g/LV72kJroUQ5Vf/LwAVdHob/JWHzchKA5UJ9M2ZgY6/DGihyTAlBWXSWTAxhaTr+uuEbdVvX/hXmf2u1ghavqi0RZ8ofAzRJyDlVkm+KyFEOScBdmVkYgpXDsHVI8r+9VPKSmqpt/V92r0GVbxg3B5lxTRNFix/Gla9CCf+0C9Z3HJM2Y9fCCGKyrsDTImALu9A7a5KyT6AlmOV4LjJMGXf1gX6zQYTNdi75X/I8tJOyMipPXztmPK1bnd9PnjsOaXc4Ia3ledYNBrYPA3+eB6+66j8/pSMTCEqDUkRKSFRUVGMGDGCmJgYTE1NmT59OkOHDjX2sAqWW+oqLR7S78Cmd5TV1TzaKHmEidfAq53Sx8IWHl+szMDEXYCTfyovAO+OUL2RUd6CEEIUmZWjfvuJ75VP4zq8ASYm8OT30GEiWDkZfhrXNlCfNnInGrJS4cJm5dO+Q4uVdvdmYOeqPNidHKNfqv3Qd2BdFVLi9NeLOggzHeGJH6DpUNj3jTJZMfwPJaAXQjxSZAa7hJiamjJ//nxCQ0PZunUrb7zxBsnJycYeVsEs7cHSUdk++SdE7AYTMxjyI1Tx1gfXudSm0OsjwzZzW+j2XlmMVgghSk7NFtB9uuHiVy6N8we5PoPgzbPKq/1EpW3rTNg7X9/HvZny1c0v/33yBtd57f0KMtOUUoDXTyiLcon7knoMoiyVxM+bzGCXEDc3N90yp9WrV8fJyYlbt25hY2Nj5JEVwtEDrsdD8I/KfpMh4FCz8P4N+sLEU2BbHa4cBtcmSqAuhBCPuqbDlMD6drhhe5VayteWY+D6SchMUSYf7lwr/Fo3TsInLvr96/fI3Y6PVJ53qdMdand+4OFXZGq1GoCMjAysrKyMPBpRWeQuRZ93pc3ikgA7x65du5gzZw5HjhwhOjqa1atXM3jwYIM+CxcuZM6cOURHR9O4cWPmz59Px44d813r8OHDaDQaPDw88h0rNxw8lX8QbpxS9msWoV61Y8778W5feuMSQojyxqUxVG8MMaf1bf3nKSkmoExANOirz7GOuwgL8uRwe7SBMZvhMy8lNS+v8F1KIO3omf++Wz6A038ps97ProR6PUv0bVUEpqamWFtbc/PmTczMzDAxkQ/eRenRarWkpKQQExODo6Oj7g+8ByEBdo7k5GT8/PwYPXo0Tz75ZL7jK1asYOLEiSxcuJD27dvz3Xff0bdvX0JDQ/H01P9ijIuL4/nnn+eHH34oy+EXn+Ndwb9rU+OMQwghKoImQ+C/nAD7ub8Krr2du/Kjc10Y8pMScHu1B/OcTzI9Wit53KCUPY3YC9np8F1neGW/ks+dS5MNl7br909WzgBbpVLh5uZGeHg4ly9fNvZwRCXh6OiIq6vr/Tvegyw0UwCVSpVvBrt169Y0b96cRYsW6doaNWrE4MGDmTVrFgDp6en07NmTsWPHMmLEiHveIz09nfT0dN1+YmIiHh4eZbfQzL4F8O+0nB0VvHtV/4+AEEIIQ/GR8JWfUoXprQuGD04W1Y1Q+G8mdJ4CNZorD0yueA4SopTjbQKh1YvKg+ZL+uc/v00gdHpLKTH4IPevwDQaDRkZGcYehqgEzMzM7jlzLQvNlKCMjAyOHDnCO++8Y9Deq1cv9u3bBygfK4waNYpu3brdN7gGmDVrFjNnziyV8RZJ3hnsqnUkuBZCiHtx9IRn/wSV+sGDWxcfGL5Cv+/uD08shp/7KvsHgpRXXnV7QtgWw+N2bvDakUr1e9vExERWchQViiQzFUFsbCzZ2dm4uLgYtLu4uHD9urIQwd69e1mxYgVr1qzB398ff39/Tp48Weg1p06dSkJCgu4VFRVVqu8hn1qdoGbO8ueNBpTtvYUQoiKq2wPqdC3Za3q1g/5zCz/eaTI0uavk651o5QH13DKCQohyR2awi0GVm1+XQ6vV6to6dOiARqMp8rUsLCywsLAgKCiIoKAgsrOzS3Ss92VVBV7cApmpYCZPZgshhNG0fFFZBOfbjsoKkble3qWUAKzRXHmIcuUL+mNbpivLuL8aXPbjFULcl8xgF4GzszNqtVo3W50rJiYm36x2cQUGBhIaGkpwsJF+SUpwLYQQxle1Dkw4Ds4N9G3VchbyUpuBz2AlNSSv2POwejxseR8SrpTZUIUQ9ycBdhGYm5sTEBDAli1bDNq3bNlCu3btCjlLCCGEKAbbaobVSUzN9dsmahi9AQZ8bXjO8d+VMn5bjfhMjxAiH0kRyZGUlERYWJhuPzw8nJCQEJycnPD09GTSpEmMGDGCFi1a0LZtWxYvXkxkZCTjxo17qPsaLUVECCFE+dPtPchKg8ZP5D/mVBscvSH6OBz+0fBY7PkyGZ4QomikTF+OHTt20LVr/odXRo4cyZIlSwBloZnZs2cTHR2Nr68vX375JZ06dSqR+xe17IsQQgjBpqlwYKF+36oKTIkw2nCEqCyKGq9JgG1keWewz58/LwG2EEKI+9vxGeyYZdj2ThRYyr8fQpSmogbYkoNtZEZ/yFEIIUTF02ig8tXFF6yclO34Iq50mJmmX9ZdCFEqJMAWQgghKhoXHwg8BCPXQRUvpe2/j+C/D2Gej7K0+tn1+c+7sBU+cYHDP5XteIWoZCRFpJyQHGwhhBAP5Pen4fzGgo+N3a7U0U65paz8+JU/3LmmHPsgHhKvQvgucKoDnq3LasRCVFiyVHoFIVVEhBBCPJSqdQo/tuMzaDoM1r4KLo0h74JpMx3zdFQpM+LV6ivpI+c3g2sTcKhRWqMW4pEmM9jlhMxgCyGEeCC3wmH9m3Dxv4e7Tu9Z0PYVJb1k1Rhl0ZtXD5XMGIV4RMhDjkIIIURl4FQLRvyl31eZQP2+xb/Olvfh0g44+J2yH3uuRIYnRGUkKSJGJikiQgghSsSL/0Hwj9DrY7CpCsd+hYSrkJ0Ojl6w7nV9Xzs38H0S0hKgyRD4ZRBoMpWvQoiHJiki5YSkiAghhChVH1YFTZayPSNB367Jhq/8ICEq/zkv/As1WyhLtQshJEVECCGEEHm0n6B8rdnSsN1EDWO3wYQT0GWq4bGfein53UKIYpEUESGEEKIy6DoNqtaF2l3yH7OtrnztPAXcm8Hvw/THjvwMHq2gyTBQS9ggRFHIDLYQQghRGZiowX842LsX3kelgvq9oUaAYfua8XD899IdnxCPEAmwjSwoKAgfHx9atmx5/85CCCFEWbCpnr/t6C9wcDFoNGU/HiEqGAmwjSwwMJDQ0FCCg4ONPRQhhBBCYW6j3+49S/l6JRg2TobQ1cYZkxAViATYQgghhDCUfke/ffdDkTdCy3YsQlRAEmALIYQQwpCZlX777qXYNZllOxYhKiB5HFgIIYQQhrq/DzdOQ7vXwNrJ8FjCFeOMSYgKRAJsIYQQQhiqWgdeO1zwsfgCFqQRQhiQFBEjkyoiQgghyr2hS8As58HHK4dg1VjITIPdc5Ul2X9/Gs5tNOoQhShPZKn0ckKWShdCCFGuJd2EL+rq9707QsRuwz7950GToWAp/46JR5MslS6EEEKIkmPjbLh/d3ANsH4S/P0aJMeWzZiEKKckwBZCCCHE/alUULvr/fuFroE5dSDyYKkPSYjySgJsIYQQQhTNM8vhrQsw5GdoE3jvvru/UL5mpcOyJ+Cvl0GyUkUlIVVEhBBCCFE0ZlbKy/cJ5ZWeoDzkWBBzG0i9Dcd+g4v/KW0tx0BcGHi1hypeZTduIcqYBNhCCCGEeDCmloUfu3UJvu+mfM31Yy9AC9bO8PbFUh+eEMYiKSJCCCGEeDBtA8HUCpo9B6M2gN8z+mPRxw2DawByUkRSYiVdRDzSZAZbCCGEEA/GqTa8fUlJG1GpwN0f6veBP0fq+/g/C35Pw9IBhufGR4JVFSUQ9+6gnC/EI0JmsI1MFpoRQghRoZlb64NjcxtoPFhJAQFw9IIBX0GtTmDnZnhe9HH4aywsfQxCfivTIQtR2iTANrLAwEBCQ0MJDg429lCEEEKIkuHaRPnaeQqozZTtqnUN+/wxAs5vUrb3fv3g9zr2G1za8eDnC1EKJEVECCGEECVr4Ddw4zTU761vc/QCClicBkCrUcr5mVoU7z43QmHtK8r29Fh9MC+EkckMthBCCCFKlqMHNOhjmFedN3juOs2wf9wF+LwWxEcV7z4JV/Tb108Uf5xClBIJsIUQQghR+mrmedao0+T8xzOT4cy64l3zTrR++/K+BxuXEKVAAmwhhBBClL6mT0HPD2HMVmVmu8u7+fts/xQubiv6NROv6bcv73/4MQpRQiTAFkIIIUTpMzGB9hPAI2cmu9NkeO0oBAZD85yyfhl3YNnjEHMW/n0Pzv9772smXtVvR4eUyrCFeBASYAshhBCi7JmYQNU6UK0+PPalvrQfwA/dYd838PvQe18jb4CdeA0y00pnrEIUkwTYJejxxx+nSpUqDBkyxNhDEUIIISoOEzU8twpavaTsZyTpj+2cDbfCDfvv+gL+HH1XuxbiL5f6UIUoCgmwS9Drr7/OL7/8YuxhCCGEEBWPuz/0+RzMbAzbt38Cywbr9zNTYdtHcPovuJ0TYJtaKl/vDsSFMBIJsEtQ165dsbOzM/YwhBBCiIrJxARcffO3345Qvt4IhVUv5j/u1T6nXzikxsOBbyH9TmmNUoj7kgA7x65duxgwYADu7u6oVCrWrFmTr8/ChQupVasWlpaWBAQEsHt3IQXzhRBCCPFgcleBvNuaQPhtKJz9x7Ddu6M+KL91CVaOhk1TYHMBVUqEKCMSYOdITk7Gz8+PBQsWFHh8xYoVTJw4kWnTpnHs2DE6duxI3759iYyMLOORCiGEEI+wqvUKbg/5FRKvGLaZmELfz8GptrJ/aLG+zN9RSdkUxiNLpefo27cvffv2LfT4vHnzGDNmDC++qHw0NX/+fDZv3syiRYuYNWtWse+Xnp5Oenq6bj8xMbH4gxZCCCEeNS6Ni9Zv+J/gUBNcfMDMCiwcID3BsE9UMMSeU4L2jDtQt0fJj1eIAkiAXQQZGRkcOXKEd955x6C9V69e7Nv3YCtHzZo1i5kzZ5bE8IQQQohHh3cH6PkRONcDc1u4Egz/5fn30r4mvLQDbKvp25xqw+QwWPoYRB3Ut/94V0BdvbFSh7vNK0q97Q5vQKuxyjGtVvmad3l3IR6QpIgUQWxsLNnZ2bi4uBi0u7i4cP36dd1+7969GTp0KBs2bKBmzZoEBwcXes2pU6eSkJCge0VFRZXa+IUQQogKQ6WC9q9Dg75QqyO0nwhj86zuaOVoGFznMjWH5/5Samo3GlDwtWNOw5El8MsgpYb2hrf0x9ZPglkecFtK/YmHJzPYxaC6669arVZr0LZ58+YiX8vCwgILC4sSG5sQQgjxSDIxgRoBefbvEbpY2EKLF6DJUKjiDaF/F1wb+060fluTrZT+O/yTsn/0F+g+HbKzlPrcMqMtHoDMYBeBs7MzarXaYLYaICYmJt+sdnEFBQXh4+NDy5YtH+o6QgghxCOt1yegUkP/uffva2EHvT6GiSegQb97970dAZd26PeTrkPqbfimGSwtZCZciPuQALsIzM3NCQgIYMuWLQbtW7ZsoV27dg917cDAQEJDQ++ZTiKEEEJUem0D4YNbULNF8c57Zjl0fa/w46tfhmO/6veP/Qqfe0N8JETshuS4BxquqNwkRSRHUlISYWFhuv3w8HBCQkJwcnLC09OTSZMmMWLECFq0aEHbtm1ZvHgxkZGRjBs37qHuGxQURFBQENnZ2Q/7FoQQQohH18Okajh66re92sPlvfr9K/eZ4ArbCif+BwGjwWfgg49BVCoqrTb3sdnKbceOHXTt2jVf+8iRI1myZAmgLDQze/ZsoqOj8fX15csvv6RTp04lcv/ExEQcHBxISEjA3t6+RK4phBBCCCDyAPzUW9l+cRtkpUL4Ltj5ub6PTXXISILMlMKvMyOh8GOiUihqvCYBdjkhAbYQQghRShKuwJc59bXfDgdrJ8jKgEvb4cK/EPwDDPtFyd2+fkqZqd71BRxbZnidty6AbfWyH78oN4oar0mKiJFJiogQQghRyuxrQKuXQG2uBNeglPWr3xvq9YIu74JNVaW9Tjfla/0++QPsiN3g+2TZjVtUWDKDXU7IDLYQQghRjqTehm87QUKkvi1gNAyYb7QhCeMrarwmVUSEEEIIIe5mVQVePwYv7YRBQUrbuY2wZz5kJBt1aKL8kxQRI5MUESGEEKKcUpuCu7+yeiQoNbK3fgC3w5X62ioT8Gqn1Oc2szTmSEU5Iyki5YSkiAghhBDllFYLn7hCVlrBxx094dUjSl63eKRJiogQQgghRElQqQoPrkFZlCb2fNmNR5R7EmALIYQQQtxPq5cN962rGu7HnCm7sYhyTwJsIwsKCsLHx4eWLVsaeyiiAklIzeTpxfvpMmc7q49dMfZwhBDi0dfjAxi8CPrPBdem8MJmGP4nmOQ8zhZzGjJS4L+P4OpR445VGJ3kYJcTkoMt7paSkcW+sDiOX4knJjGdDwb6YG2u/CJfc+wqE1eEAODv4ciawPZGHKkQQlRih76HDW8p29Uawc0zYGYDj82Duj3Axlk5duM0JMdC7c75r5FwRVnspt3r+jrdolyShWaEqEA0Gi0Ld4RhZ2nGUy09sDRT88Ha0/x5RD877eNuz8h23gCcu3FH137pZhJarRaVSgVAWmY2QdvDSE7P5t1+DVGbqHTHABJSMjlzPZFW3k6YmOjbhRBCPIDqjfTbN3PSRDKTYfXLYG4LY7aAiw8saqccG7cXXH0Nr/HrEOXc2Avw9G9lM25RqiTAFqIc2HrmBl/8qzwg88+Ja3z9TDPWhlwz6PPB36dZd/way8a05tx1fYCdmJbF7ZRMnGzMyczW8PxPhzgUfguAqrbm/Hk4CjcHK+YO8+PcjTuM//UIaZkaXutWlzd7NSi7NymEEI8i16ZgYQ/pifmPZSTB0gHKapG5IvcbBtharT4wP/tP6Y5VlBlJESknJEXk0ZGWqdQ0tzRTF/mcyX8eN5itzuVX04EFw5vTcfZ2XdsAP3fWHTcMvv8c1xZHKzNWHr3CdzsvFXgPM7UKE5WK9CwNAOamJvw3qTMeTtZFHqcQQogC3LkBmkw4sAj2L7h337tXg7x5HoJyn8NSwXsxUu6vHJMyfRWEPOT4aIlJTKP3/F10mr2dpPSsIp2TrdGy7WwMAC93qm1w7IUOtfBwsqZjPWddW97gurG78j/3+F+P0vPLXbrg+sNBjbE00//vrTZRkZmtJT1LQw1HKwK8qpCRpWHZgcvM/fcczyw+wLM/HOC15cc4eSXBYAzHo+KZ+tcJ4lMyivGdEEKISsTOBRxqQu9PoGpdfbu1c/6+x36Fn/rCv+8p+xG78hzUwuW9pTpUUTYkRcTIAgMDCQwM1P1FJCq2N/4I4XJcCgC7z9+kbxO3+55z8FIccckZOFiZ8VbvBuy7GMfJqwlYmal5rKk7AEtGtyI6IZX+X+8hITUTgBqOVjTzdOT0tURik9J11xvRxovn23rT3LMKUbdSaFfHmfC4ZMb/eoTq9pbMGOBDzJ10Xl52hMW78s92bztzg8XPt+CbbRd4vq03n6w/w9X4VFzsLZnYo35JfJuEEOLRZZXnIcWhS2DpY4bHNZkQuU95dZ4CZzcYHv/fs/DqISVgz0urhegQqO4DphalMXJRgiTAFqKEJKRksjcsTre/5cyNQgPsBdsusPtCLF8/04w1IVcB6NfEFTO1Cd8804xPNpzh5U61Uec8hKg2UVGzijUbJnREo9GyJyyW+i52XIxJAiJ11/3qaX/65dzTt4YDvjWUP9r8rR3ZP7W7rl9GlgZHazPiU5RgvV2dqvRr4sbvByMJjU7k2R8OAnDg0i3dOfsuxjGxx8N+l4QQ4hE34Cv43zPQbTrU6ghjt8P3XfXHTUxBk/MJ5+55cPE/ZfuZFfDnKOUBydC/oe0rhtc9vxmWPwUN+sMzv5fJWxEPTgJsIUrAdzsvMmvjWYO2bWdjSMnI0pXWA1gRHMmUVSd1+6/+fpSz0coDi4P9awDg7WzD98+3KPA+NRytAHimlScATWs6cOBSHH8du8p7/RsxKOca92NuasK7/Rqx8sgVhjSvydAWNVGpVHSuX43Oc7ajKeDJjGORt0nNyMbKvOi55UIIUem4+MCE4/r9vFVGen4IrcfBuglwfDnsmZdzji806AMd3oAdn0J0zvlaLez7RpnNDl2jtJ1bDym3pJxfOScBthAPQavVsvxQlEFw/XizGhy+fIuoW6n4vL+Zvr6ufDCgMUv3R7Box0WD84MjbgNQp5oNLb2L/8vSTG3C3GF+TO7TAFd7y2KdO6yFB8NaeBi0eThZ06Z2VfZd1M/E+7jZczslg+iENPaExdLTx6XY4xRCiErLzAosHSEtHmp1UtI7andRAmwAWxfo8o6y7dZU+Xr9hPI1JhS2TFe21XnSQk6uhNYvlcHgxYOSAFuIYtBqtey7GIdXVWtqVrHmp70RfPRPqEGf5p6O9PRx4ZXflJW8Np66zsZT1w36/Dy6JdfiU5m2+hQAU/s2euCa1CqVCjcHqwc6tyCfPN6EF5cG06l+NVIzsnmxYy3+dyiKH/aE89E/oZyJTsTF3oKnWnqW2D2FEOKR9sp+uH0Z3Jsp+w0fg/p9wasdtH9d38/NT/l686yyKuSNPP++ZOuftSFsiwTY5ZwE2EYWFBREUFAQ2dnZxh6KKILvdl3is41nqeFoxdZJnfllfwSgPFhobmrCrvM36dfEDScbc+YMacrJqwn8sv+ywTXmP+VP1wbVAbAyU5OYmkn3RtXL+q0UqpazDf+92cWgLbBrXf44HEXkrRTmbVHqdTfzrEJ9FzsjjFAIISoYe3fllcvCFob/L38/OzewqQbJN2G+L6TE5e8DEHkANNlgkidlL+kmqFT6lSOFUUkd7HJC6mCXbxqNlrlbzhG0XZ/i0al+NXadv4m1uZrD7/UwyLXOa8bfp1myLwJ/D0f+HNcWM3XFrI65/2IcM9ed5mzOIjeTezcgsKtSjkqr1XL2+h3qVretsO9PCCHKhf0LYfPU+/dzqgMj14FDDchMhS8aAFp4+xKozUp9mJWV1MEWopiiE1J5f+0pdl+4adCenJ7Fy78e0QXX9arbArDrvNKvl49LocE1wDt9GzJjgA/fPNOsQgefbetUZdPETnw8WFmB7Kc94brygMsOXKbvV7sJ2h5W7Osu2nGR/l/vJi5PqUEhhKi02r4CL+0s/HjtnIokty7Cxrfh8M9w8xykJyirSd48W/i5osxU3H/thSghGVkavtp6gV5f7uKX/Zd5/qdDfLdTCaa1Wi0vLAlmS+gNzNUmzBvmx79vdKJ1Lf0DiferDW1ppmZU+1qPzIqJPX1cMFebEJecwdBv93Mo/Bbvrz0NwPytF4p1La1Wy+ebznL6WiI/7AkvjeEKIUTF4+6v1NDOVb2xfrvFaP322X/gn4nw21B924Ut8GMvZSY8V1QwbHxHyesWZUJysEWlkJiWyY5zN+nr64oKyMjW6Gad5/57ju/yLLii1cKsjWdxsbfEw8mKg+G3sDA1YflLbWjuWQWAL4b6MXPdaYa39sTb2cYYb8loXOwt+XFUC8YsPUx4bDLDvttvcDwtM7vIy8TfSNTPWhdnBjsjS8P6k9dwtDbX5bMLIcQjpV5vZVVIc1sYvBC+6wwBo8BnEIzeCD/31fdNjtFv/zdT+Rp1ECztlfrZZ/7OOaiFvp+X1Tuo1CTAFpXCe6tP8ffxa4ztWIuTVxM4dTWRP15uy8HwOF1wPdDPncm9G/Drgct8t+sSE1eE6M4f6OeuC65BKWf3w8jKu7x9x3rVeKtXfT7dkP+jyB/3hLP7wk0l+G7hwRs96hdaIeXElXjddnhscpHunZaZzVPf7ef4lQRMTVTsn9qdanayqpkQ4hFjbg2vHFAWplGpYEoEmOdM6Lg2Kdo11gYa7ofvKrifKHESYItK4e/j1wD4frc+DaHf17t12+M61+Gdvg0BGNOxlsGMtokKRrevVUYjrThGtPHm/I0k/Go68EwrT1757Sj/ht5gzuZzuj7fbAujsbsDfXxd851/OzmDGX+f1u0HR9wmM1tDUloWpmoVd9KyqGprzvoT0Xz0TygzB/ky0M+dT9af4fiVBACyNFqOXL5FH9/7L0mfnJ6FiUolC+UIISqOvA8rWtjm2X7ACk6pt5XqI388r1x7yM9K8C5KnATY4pF38869Uw+eaFaDKX0a6Par21nSo5ELW8/coGuDaswY2BivqpUrDaQorMzVfDHUT7c/tIUHe8JiycjS8ETzGkQnpLH7QixL90XQ2N0eWwtTqtiYA8ps9YgfD3ItIc3gmvWmbSz0fq8vP0bTGg6sOBwFgFdVay7HpRAccfu+AXZSehY95u7EztKUTRM76ZagF0KICqv/XAj+Ebq+CyueU9pUJqDVKNsTT8GxX2HnZ/pz7kTD0aVK7jZA12ngXK/o94w5A3auYFXl/n0rOSnTZ2R562CfP39eyvSVsOsJaQxcsIeYPEF2m9pOvNGjPi8sCcbM1IRNEzrh6mC4CmJsUjoHL92iV2OXCl35o6xptVoys7WYm5pwNT6Vjp9v0y277uFkxT+vdSQ1I5tnvj9AeGwyVW3MeaypG0np2fx17ApF/W1Uu5oNr3erx8QVIfjVdGDtqx0MjsfcSWP3+VgG+btjqjZh06nrjPv1CAB/vNyWVrVkiWEhxCNCo4GFrSEtAYavgF8GQ62O8NSvyvEZDoWf2/tTCPsPfAYq+d0ACVchYjf4PqmfQc9IhmvHYEl/qBEAY7eV5jsq14papk8C7HJC6mCXvFNXE5i4IoSwmCQAajvbUN/Fjvcea0TNKtYkpGaSkaWR/N1StOzAZT76J5SMLE2+YzUcrVgT2F73/c/M1rAnLJatoTf47WAkAN5Vrenf1I2+vm4M/XY/qZnKgkyvdq3L8NaetPtsGyYqWDamNT/tCadvEzf6+Loy8Js9XIpNZtYTTRjsX4NPNoTy64FI3b1nPdGEp1p4PPDqmUIIUa6kJSoz11aOSk1sU0t96seK5+DMOmj8OJz5BzSZBV9jhpJ6x1d+cDsCen0C7V5VgutvApTZ71zv3waTyjn5JAF2BSMB9sPTarW8vfIEcckZeFe14ed94Wi1YGFqwqj23oztWBtnWwmmy1pMYhp/HrlikJvd2N2e+U/5U6+AlSC1Wi0bTl7Hq6o1vjX0My87z9/kk/Wh3EnL4o+X2+LhZM3zPx3S1SN/EO/1b8SLHWs/8PlCCFHupSdB1AGo3Q3Cd8DlfZByCw7/aNhv6lUlzzt3xrtGCxj7H1zeDz/3Mez70g64FgIN+4NtCVRyio+En/srJQg7Tnr465UiCbArGAmwH96pqwk89s0eg7ZePi5M7deIWpWslF55o9FoWR4cSXU7S5p5OlLVxhxVCTxYsy8sluE/HCxSX1sLU1rVcmLbWX05q4audmya2KnI90vPyuZM9B0ysjSYqVU0y6ksk5Wt4ZttYfi42+Nib0m96rbYWMgjLkKIciopBr4oIPd60EJY+4qy7VwfWrwAoX9D5D7Dfs4NIPYcmNnA07/Cnevg9wyE/AZZ6dByTP5rJ1yBcxvB0Uu5XptAsK2mHFv/FgR/r2znzqTfugThu8H/WVCXn9+nEmBXMBJgPxytVsv0tad0aQC1q9kwoo0Xo9p5l0ggJ8qv9SeiOXfjDp3rV+O/Mzf4/VAkE7rXY+a6UF2fVrWc+HiwL/Vd7EjJyOKjf86w/JDys1LNzoI61Wx4ppUnnetXw9Ha3OD652/coaqNOQcu3WLmutMG+fxfPe1PH19X/jx8hffWnNK1D2tRk9lD/CgNm05F8/H6M3z1dDMCvORBIyHEA9o6A/Z8WXLX6/kRbJmubL8Vpg+ecwW1NlxlUm0BE0/ApZ2wdz7E5PzOnnYDzCzhE3fITIYBX+nzwzNTldKD3h2U4N8IJMCuYCTAfnAajZZRS4J1qQJfP9OMgX7uRh6VMBatVotKpeLZHw6wNyyOr572Z5B/jXz9Wn2y1SBYBrA0M+Gf1zrw64FIbC1MaV/XmWe+P2DQx9bClKT0rHuOwUyt4sIn/R7+zRTA+531yteq1uyY3LVU7iGEqASys+Dgt7BnHqTEPfz11OaQnaFsj90ONZobHr/Xw5Z5NRmmpIrkLqTTZCg8+YOyfXo1/DkKbKrD5OKtHFxSihqvVc4MdfHIOBxxi17zd+mC69rVbOjeUFb2q8xyP7H48il/fnuxdYHBNYCTjX6memxHpc55WqaGfl/tYcm+CBZsD2PyyuO6PqYmKsZ1rsPR6T258EnffJVITFTQo5Hys5eZrdU9RLsiOJIXlwYTn5JR6Ji1Wq3B8ffXnuLZHw6QmJZp0GflkSu6/Yi4FNJyHvoUQohiU5sqDzH2mFn0c2reY4G17Dy/4xKv6rc12Uqlk6I6+YfhKpVmVvrtyzkrByfHQPqdol/TCMpPUosQxXTqagIjfjykqywxrV8jXuxYS1JCBKDUM69uZ1no8bd6NeClZYf5aLAvz7b2okO9aoz86RAZ2fp/CK7cTgVgzpCmPNbU3WCRmt9ebM2fh6+QnJ5FXRdbPJ2sqVPNlo6ztxF1K5UXlwZz+PJtXenB+VsvMGNg43zjuHI7hVd+O8qJKwlM6F6P59t68cv+ywB8/E+oLtVk3Ylo3vrzuMG5ey7E0sPH5cG+QUIIAeA/XKk4Ym6jzA4XZtweZQXJr5sp+dF2boaVRfJKuAo3TisPL/7xPPg9bXi8Xm9w91f65NbkLkxiNBxYBJkpygOauW6Fg1vTorxDo5AAW1RINxLTGLM0mNTMbLyrWvNqt3o80ayGBNeiyHr4uHD+476Y5tQ571jXmYaudpy9fodmno6cuJJAtkaLnYUpg/xrYG5q+IGfmdqE4a098123sZsDUbdSCY64bdC+ZF8ETWo4kJyRRb3qdpibmuDuaMnnm85xImdlyq/+u8D5G/pZmT8OX6GPryvdGrqw7cwNXXtzT0eORsaz96IE2EKIh2SihmbPFTzL3HqckkYC4JRTcWnEatg8DdoGGs4053ViBWx6B8iZYTj6i+FxhxrKAjkAvz8N5/MsMmZmrQTTucK2KK+73bokAXZl8c8///Dmm2+i0WiYMmUKL774orGH9Ei6kZjGl1vOcyMxnXrVbVk5vh0OVmb3P1GIu5jmWUTIxETFn+PacictC3dHK67cTuHzTefoWNc5X3B9L829HNl0+nqBx968awba0sxE929aS+8qBEfcZuMp5Vw7S1PupGUxZdVJFj5rxs6cNKhfx7QmITWTo78f5cClW7pr3UnLZML/QqjvYseQgJp8t/MiZqYm3E7OYEqfhnjnqaRzJy0TtYkKa3P5J0AIkcPERKl9/e80aD0estOV9JGAUUqNbfOc3yFVvOHp35TtZ1fBocVKDveNU+DmB1EH4drRwu9TsyV0fke/b5dnkqDfF+AzGHbNVq57L7cuPsCbLDvykGMJycrKwsfHh+3bt2Nvb0/z5s05ePAgTk5FWzFOHnIsXFhMEpnZGqzM1Ly6/Cinribqjv3+Ymva1XU24uiEMJSakc2qo1dwc7BkzNLDAJibmtCxrjNX41M5ez1/3mADFzvWBLan85ztugcvv3zKjwXbwrh4M9mg7+mZvUnNzKbFx1sBeLa1JxN71GfKqhO6EoQWpiak51ncp6+vK4ueCwCU4LrnvF1YW6j5d2Ingz8yhBCVnFarVOowty7eeZpsZUGai/8VnGZiZqNUBGk9Dvp+bnhs8zTYv0DZzi3Rl50FN8/At4ar9CpUgFaZdR8UVLxxloCixmsyfVFCDh06ROPGjalRQ3mgql+/fmzevJlnnnnGyCOr2MJjk+n/9W6DYCGvNrWrlvGIhLg3K3M1z7XxAmDhs81ZfiiSucP8dPngy/ZHMH3taUB5bmDjqWgm9KiPlbmaJaNb8c22C5ioVPT1daO2sy3Dvtuv+/n3q+mAjYUpNham1Hex5fyNJH47GKlb+TJXepYG76rWWJmbciY6kY2nrvPcDwextzJlw0n97Prhy7fl/yEhhJ5KVfzgGpQ0E0t7sK9Z8PGBX8PWmcpqkndr8YISYNftoW9Tmyr53gWp000J5GPOFH+cZUimLnLs2rWLAQMG4O7ujkqlYs2aNfn6LFy4kFq1amFpaUlAQAC7d+/WHbt27ZouuAaoWbMmV69ezXcNUTwfrjttEFzXq27L5N4NMFOreK9/I1nqWpRr/Zq4sWxMa4OHLYe28GBoQE0+HNSYsZ1q89cr7elcX6kX6+Nuz6LnAgh6tjmWZmr8PBzZ/XZXtk7qxPNtvZjW30d3nY8G+RpUQrEyUzOpZ32eaeXJe/0b8d+bXdg4oSOtvJVP0faExRoE1wBbQm8Y7B+4FMfLyw5z5XYKQghRbFW8QGUCJqYw8h9lQZo+n0GTIfDGSfBsk/+cqnXgzXPw9O/5j/kOUWa/h+XJ4e40Wfl69ajyAGQ5JTPYOZKTk/Hz82P06NE8+eST+Y6vWLGCiRMnsnDhQtq3b893331H3759CQ0NxdPTk4Iybcr7A3cpGfeu5WtscUkZbD+n5J0uGd0SO0tT6la3xUxtwnNtPDFTm5T79yBEQWYOUqqJFOXn19bSFFtLU97p29DgnCY1Hdg5uQujfg4m6lYKv45pTU0nfTmr9Cylus6Hgxrzw+5LrDya/w/+f05c45UudXTVUQJ/O0pccgbhN5OZ/3QzUjKysLc0Q22iws2x8IosQggBgLkTPL5MmQWv0RZeyqn6cb/fdRbOoCmgX/8g6JmszI77vQCmFuDaAtzbwdUjcHId1u1fKpW38rAkB7sAKpWK1atXM3jwYF1b69atad68OYsWLdK1NWrUiMGDBzNr1iz27dvHnDlzWL16NQATJkygdevWDB8+vMB7pKenk56uX+QiMTERDw+PMs3Bzl2wQgghhBCiIop4zRVqBJTZ/WShmRKUkZHBkSNH6NWrl0F7r1692LdP+eusVatWnDp1iqtXr3Lnzh02bNhA7969C73mrFmzcHBw0L08PDxK9T0IIYQQQjxyNk6BcjhXLCkiRRAbG0t2djYuLob1Zl1cXLh+XclpNDU1Ze7cuXTt2hWNRsPbb79N1aqFPzw0depUJk2apNvPncEuS6EfFv4HgLHtvRDLhP8dIyVTw6Jnm9G5gazOKERJ0mi0dPliB7FJhitM9vSpzsud6pCYlskLSw4bHNvwekd2X7jJ9nMxBHaty+XYFP4XHMmHg3xp6GZXlsMXQlR26cnw73To9avycGY5IwF2MdydU63Vag3aBg4cyMCBA4t0LQsLCywsLAgKCiIoKIjs7LJf8rg81MA9ez2RarYWVLW10LVptVo+Wn+GlEwNrWs50b2Ra7HqEAshiqZ9XWfWhlwzaOvr60aLnAcjFwxvRkJqJptOXWf3hVje+vM4odFKmUwz9SV2X4gF4IlF+2jhVYWlL7TCxsL4v1eEEJWAuQM8+bWxR1EoiVqKwNnZGbVarZutzhUTE5NvVru4AgMDCQ0NJTg4+KGuUxEdj4qn31e7efaHg2g0ysc72Rotm0/fIPJWCuZqE34a1VKCayFKyXNtvPJN/PT1ddNtP9bUnWdbezHIX6mQlBtcA7rgOtfhy7fztZ2+lsA/J67R/rNtbD8XU8KjF0KI8ksilyIwNzcnICCALVsMl+rcsmUL7dq1e6hrBwUF4ePjQ8uWLR/qOhXR97svodHC2et32HsxlqxsDS8sCWbcr0cAaFmrisyGCVGKWno7seOtLrzdpwEAo9t76yqK5NW7sUuhf+j29XWlTjVlhbcjl/UrS/528DL9v97Dq78f42p8Km+sCCmw2pIQQjyKJHrJkZSURFhYmG4/PDyckJAQnJyc8PT0ZNKkSYwYMYIWLVrQtm1bFi9eTGRkJOPGjXuo+wYGBhIYGKh7KrWySEzLNKjB++OecI5cvq1bDhqgS33JuxaitHlVtWFcpzo086hCgFeVAvvYWZrRrUF1Np2+jplaRS1nG87fSAJgQo96hF5LZNIfxzl8+TabTl0nOOIWP+4JN7hGfEomvefv4tcXDeuCCyHEo0gC7ByHDx+ma9euuv3cBxBHjhzJkiVLeOqpp4iLi+PDDz8kOjoaX19fNmzYgJeXl7GGXKEduXxbt4CM2kTFjnM32ZFT8/qJZjWwNFfzdCuprCJEWTAxUdG2zr1XdBwSUJNNp6/TulZVRrT1YupfJ5n+WCMautpjbab8U3IsMl73CRSAnYUpTzSvwdnrdzgYfovzN5JYeeQKr3SpW6rvRwghjE3qYBtZ3occz58/X6Z1sI3lWnwqn286y9qQazzRvAYWpmqWH1KWem7l7cSKl9uU+0V6hKiM9lyIpb6LLdXtDWegtVotfb/azdnrdwDo18SVtnWcGeTvjr2lGWmZ2bzy21G2nY2hc/1qLH2hlTGGL4QQD62odbAlwC4nivofrKK7eSednl/uJD4lE4CPBvsyoKkbczafw9bSlJc61jaoKCKEqBhSMrL450Q0DlZm9G7smu/4qasJPPbNHgC6NaxO14bV0Wq1jGjjJX9QCyEqjKLGa5IiIsrMrvM3mfrXSV1wDdDMwxFHa3M+ebyJEUcmhHhY1uamDGtReFpXIzf9P0Tbzsaw7WyM7rwhATVJy8xm3fFrdGlQnWp28ke2EKJikyoiRlZZqoikZWYzcUUIV+NTdW0eTlY0dJXFKYSoDNQmKka3987X/sn6UDQaLd9su8DklScMcrhzzd96nlkbz0gVEiFEhSEz2EZWWaqIbDgZza3kDExNVGya2Ilqthao1SpM1fI3nhCVxQcDGmNnacbX/13Qtd1OySQiLpn/HYoClAegL95MorazDdPWnOKP4Ciycurk9/N1w8/DMd91r8Wncjwqnj6+rpJuIoQoFyTAFqXqclwyX/13gX9ORAPwRs/61K1ua+RRCSGMxaeAJdVXBEcRn6pPHes+dyczBvjw+8FIg34/7w3n8yFNSc/SYG2m1v2B/sz3B7gcl4KjtRm+7g78MLIFu87fxMXessCAXAghSps85FhOPKoPOY7/9QgbTykrYPq42bPi5TbYWZoZeVRCCGO5eDOJ7nN3AuBgZUZCnsC6KKzN1WRkaRjR1osPBjQmLTObhtM3GfQZ06GWrg53+Kx+MqsthCgxRY3X5PN5I3uUc7CT07N0DzIN8ndn+VgJroWo7LycrHXbg/3di31+SkY2WRotP++NACAkKj5fn7yL3Ny8k17sewghxMOSANvIAgMDCQ0NJTg42NhDKXF/H79GepYGr6rWzH/KHwdrCa6FqOxM1Sb8OLIFnz/ZhBFtvbnf5HKTGg60quXEmQ/7UDtnSfZcN++k8+G60Huen7vipBBClCXJwRYlJiUjCxOVijPRiby49DBxyRkADA2oKR/RCiF0ujdy0W3/8XJbwm8m885fJ6hRxYobCem4O1py5XYqHw/25elWnrq+AZ5VuHQzWbc/9pfDhEYn3vNez/14kB+eb0FyRhapGdkM9HfH2rzgf/qyNVr+OnqFTvWr4WIvy7kLIR6cBNjioWm1Wr7ccp7vd4eTmpltcKxbw+qM61zHSCMTQpR3Lb2daOntRJcG1ahiY46Z2gStVktyRja2Fob/RDV0M8x3zE0PGeTvzuTeDbgWn8ZTi/ej1YK/h6Pu+Iu/HNadE52Qxhs96xc4lu93X+KzjWfxq+nA2lc7lNybFEJUOhJgiwem1Wr5+/g1ft4bkS8PsrazDXOH+dGkhoOU4hNC3Ffe5ddVKlW+4Brg2daeXLhxhy2hN3SfkFWxNmPuUD9M1SbUrGLNshdak5yRRXJ6VoH52dvOxugC7OsJaZiqVTjnrB77814ld/v4lQSibqXgkSdfXAghikMCbCMLCgoiKCiI7Ozs+3cuI1tDb/Bv6HWuxafhZGPOF0P9MDfNHyR/8e85grZf1O1P69eIq/GpONmY80KHWgX+AymEEA/K0kzNZ082pU3tq0xcEQJAvyZuBn/Ed6jnDEBcUjo1HK0MFrcCOHUtgbikdGZvOseKw1E4Wpux/c0umJioiEvK0PXrOHs7nz/ZhKEBHmi02nwTBWeiE3lt+TF83Ozp18SNLg2qYWmmLqV3LoSoaKRMXzlRXsr0pWVm0/KTrdxJy9K1je9Sh7d7NzDIo05IyaTVp1tJz9LwYodaDG5WA98aj+5COUKI8kOj0bLzwk2i49Po39QNB6vCH6DuMmc7EXEpANR3seX8jST6NXFlw8nruj7v9W/Ef2di2H8pzuDcdnWq4u5oxaZT1/nntQ54OysPWWq1WoZ/f9Cg/+TeDQjsWrck36YQohySMn2iUCkZykenB/L846DVapm35TwNp2/SBde5M9CLdlzk5WVHSM/Sz7L/eSSK9CwNjdzsmda/kQTXQogyY2KiomuD6gxv7XnP4BqguWcV3XZfXzcAXXBtlTPj/PH6M+y/FIeNuZq5Q/10i9PsuxjHyiNXSErP0qWPAByLis8XjB8Mv/XQ70sI8eiQALsSOnklgcFBe3l75QlACa4//CfUYPniV7vW5eSMXkzp0xBzUxP+Db3BO6tOkpyehUaj5dcDlwF4vq2XVAgRQpRb7w/wYUhATf56pR1Pt/JAbaL8vqrhaMW/b3TCIk/62xdD/XgyoCarx7ejqo25wXXyBtCHcrb7+rqyNrA9AKevJpCt0ZKcrv/073ZyBjfvpDP5z+P8c+Jaqb1HIUT5I0mylVCNKlYARCekotFo+XlfhG7RBjtLUzydrHmujRI4j+9Sh6Y1HRjx40FWH7vK6mNXddexszBl0AMsFCGEEGXF0Vp5jiTXIH931oZc46PBjfFwsmbZmNbM33qeBq529PF1BZQZ8k71qxn8vjt7/Q6X45KpamuhC7D9PBxp4GqH2kRFXHIGQ7/dR2h0Il893QxnW3PG/nKEWzkPY/555ApaLXRuUA17SzNik9K5GJNE69pVy/C7IYQoK5KDXU6UZQ52VraGBtM3ka3Rsu3Nzgz5dj+3kjOY/pgPYzrUKvCcN/84zqqjVwzaRrf35oMBjUt1rEIIUZIyszXcTsmgut2961zfvJPOX0evoFIplUcOXLrF2I61WHX0qi5o/v3F1rSr60yf+bs4e/1Oke7/TCtPZj3RhIEL9nDiSgLLxrSiY71qD/2+hBBlo6jxmsxgG5kxqoiYqk1wtbfkanwqC3dc5FZyBt5VrRnZ1qvQc6b0bUBaZjaZ2RquxqfS0tuJt3s3LLMxCyFESTBTm9w3uAaoZmfByzk1/KtYm3Pg0i1+3htBlkY/J9U459mTZp6ORQ6w/zlxjd6NXThxJQGA5YciJcAW4hEkM9jlRFlXERn27X4ORdzC2lxNSkY2r3Wry5u9GpT6fYUQoqK5k5ZJwMdbycjS6Noau9uz/vWOANxKzmBFcBSpmdn4uNkzb8u5fEu0T+hej6/yPOeSq7azDdve6lLgfVcducLUv07SqX415j/tL6VPhSgHpIqIuKfcPOyUDGXm3MfNeKUBhRCiPLOzNKNHo+q6/WdaefDDyBa6fScbc8Z3qcOknvXp4+vK3692wKuqNW4Olgz0c+fDQY15o2d9qttZ5Lv2pdhkgraHUdBc168HL5ORrWHrmRssyVPFRAhR/smfw5VUDUcrg/1GEmALIUShBvnX0JX3G9nOGzcHq0L7Wpqp2TShEyoVBovPjGrvzexN5+hUvxrjOtVm5ZEr/HXsKnM2n8PaXE3/pm5Ut7MkM1vDmmNXORYZrzt35/mbjOlQGytzWcxGiIpAAuxKKncGG8DGXI2nLAkshBCF6tKgGg1d7TBVq6hX3e6+/QsKhF/sUBu/mo60ruWEqdqE1rWrYqpW8cfhK8xcF8q8f8/Tr4kbt1My+Df0BgAmKtBoITjiNo3e38SbPevjbGfBM608S/w9CiFKjgTYlVS96ra6bR93e0xMpJa1EEIUxsJUzYbXOz7U70pzUxPa13XW7atNVEzr58P2cze5eSedO+lZrDgcZXDO2E61+ed4tG7J97lbzgPQoa4zHjIxIkS5JTnYlVSAVxUWDG/GM608eadvI2MPRwghyr3SmIhwsDbj34mdeLNn/XzHnmnlwYTu9Zj+WP7f0d3n7uSnPZKXLUR5JVVEyomyriIihBCi/EjPymbG36dZfkg/g31gandcHZSSgtcT0mgz67985535sA9mahWmapkvE6IsSBURIYQQooKwMFUz64mmNPN01LW52Ourjrg6WPJcm/x5143e30STGf+y+tiVfMeEEMYjAbaRBQUF4ePjQ8uWLY09FCGEEEb2Zk9lPYLB/u6oVIYpKR8PbsKR93pgbmr4T3dqZjZ/Hb2KEKL8kBSRckJSRIQQQgCExdzB3dEKa/OC6xCcuprAW38eN1g90ruqNTsmdy2rIQpRaUmKiBBCCFEB1a1uV2hwDeBbw4FejV0N2q7Gp5KtkfkyIcoLCbCFEEKICsbZ1ly3baKCzGwtMXfSjDgiIUReEmALIYQQFcyQgJp0a1idDwb4ULOKUg876lYq0QmpbDwZXeDS6wDJ6Vks3BEmwbgQpUxysMsJycEWQgjxIJ794QB7w+IM2izNTGjmUYUfR7UwSDeZ+tcJlh+Kom51W7ZO6lzWQxWiwitqvCYrOQohhBAVmKOVeb62tEwN+y/FsSX0Bv2buLF49yUauzuwJWcJ9rCYJH7ZH0FGloa/jl6lTnVb5g71y1ehRAjxYGQGu5yQGWwhhBAP4reDl5m2+lShx1UqKMq/9D+NakG3hi7Ep2QQ+PtRBvnVYFhLjxIcqRAVn1QRMYLHH3+cKlWqMGTIEGMPRQghRCXxVAsPVo1vV+jxok6j7ctJM5m9+Rx7w+J4e9WJkhieEJWSBNgl6PXXX+eXX34x9jCEEEJUIqZqEwK8qjCijRcAHw/2Zd2rHahZxUrX5641aww81tQNgB/2hPPi0mA2nIwu1fEKURlIDnYJ6tq1Kzt27DD2MIQQQlRC0/o34ulWHjR2dwBg/esdyczWkK3RYmmmxm/mv7q+7/ZryGD/GtxKyaCqjQX/nFCC6q1nYgyuqdFoMTG5R3QuhChQpZnB3rVrFwMGDMDdXVl+ds2aNfn6LFy4kFq1amFpaUlAQAC7d+8u+4EKIYQQD8DSTK0LrgEcrMxwtrXAxd4SByszPJz0M9ovdapDdXtLGrraU83OgnGd61DfxTbfNV/85TCh1xLLZPxCPEoqTYCdnJyMn58fCxYsKPD4ihUrmDhxItOmTePYsWN07NiRvn37EhkZqesTEBCAr69vvte1a9fK6m0IIYQQD2TRswHYW5ry/mM++Y6907ch/77Rma2TOuFd1VrXvu1sDP2+lskmIYqrUlYRUalUrF69msGDB+vaWrduTfPmzVm0aJGurVGjRgwePJhZs2YV+do7duxgwYIFrFy58p790tPTSU9P1+0nJibi4eEhVUSEEEIYXY95OwmLSdLtO1iZse7VDnjmCb6FqIykikgxZGRkcOTIEXr16mXQ3qtXL/bt21cq95w1axYODg66l4eHlEISQghRPuRdih0gITWTlUeijDQaISoeCbCB2NhYsrOzcXFxMWh3cXHh+vXrRb5O7969GTp0KBs2bKBmzZoEBwcX2nfq1KkkJCToXlFR8otLCCFE+VDV1iJf29fbwug8ZzsxibLMuhD3IwF2Hqq76hhptdp8bfeyefNmbt68SUpKCleuXKFly5aF9rWwsMDe3p5ly5bRpk0bunfv/sDjFkIIIUpS3uzRRc82121fjkvhf8EyISTE/UiADTg7O6NWq/PNVsfExOSb1S5pgYGBhIaG3nO2WwghhChLd9KydNv1Xe0Mjmkq36NbQhSbBNiAubk5AQEBbNmyxaB9y5YttGtX+OpYQgghxKOofV1nABytzfCoYvhgY2xSekGnCCHyqDQLzSQlJREWFqbbDw8PJyQkBCcnJzw9PZk0aRIjRoygRYsWtG3blsWLFxMZGcm4ceNKdVxBQUEEBQWRnZ1dqvcRQgghimp0e29sLUzpXL8a5qaGc3FXb6caaVRCVByVpkzfjh076Nq1a772kSNHsmTJEkBZaGb27NlER0fj6+vLl19+SadOncpkfEUt+yKEEEKUtYEL9nDiSgIAVW3MWRPYHg8na7I1WtQmKiLjUnBztMRMLR+Mi0dbUeO1ShNgl3cSYAshhCivYu6kserIVT7fdBYAa3M1y8a0YtyvR9FotMQlZzAkoCZfDPUz8kiFKF1SB7uCCAoKwsfH554VR4QQQghjqm5nyah23rr9lIxsnly0n5t30olLzgBg5ZErdJu7g/0X44w0SiHKD5nBLidkBlsIIUR55/3O+iL1e61bXQK71sXSTF3KIxKibMkMthBCCCFK1Ownm/JEsxpUt8u/EE1e32wLY9GOi7r90GuJhMcml/bwhCg3Kk0VkfJKqogIIYSoKIa19GBYSw/Ss7KJTcrgk/WhbDhZ8IrHodGJAETdSmFw0F6sLdTsndINGwsJPcSjT2awjUwWmhFCCFHRWJiqqeFohZ2FWaF9tFolL7vj7O1kZGuIT8nkh93h9PtqN78fjCzD0QpR9iTAFkIIIcQDaeimX+WxsbthPurRyNu8vfK4QduXW88TGp3Iu6tPlsn4hDAW+ZxGCCGEEA/k2dZeRN1KpUuDanSqX43/ztxg/G9HycjScCunugiAm4Ml0QlpBuemZWbLQ5DikSUz2EYmZfqEEEJUVOamJrw/wIdO9asB0L2RC6Eze2NqotL12TihI3umdMu3IuTZ63fYGxbL2F8Oy/Lr4pEjAbaRSQ62EEKIR4mp2gQPJ2sA+jdxo5GbPWoTFd5VrQ367Tp/k2d/OMiW0Bt88PdpYwxViFIjAbYQQgghStQTzWrgVdWaN3vV17XVcrYx6DNvy3nd9vnrdx7oPmmZ2fT7ajcT/3fswQYqRCmRAFsIIYQQJeq17vXYObkrtavZ6tqcbAqvnX0hJollBy5T3LXvjkbeJjQ6kTUh1wxyvoUwNgmwjUxysIUQQlQGFnlysA+/1yPf8elrTrH7QmyxrhmfkqnbDo649eCDE6KESYBtZJKDLYQQojJ4oX0tzE1NGOTvjrNtwbPZu87fLNY181YmORQuAbYoP6RMnxBCCCFKnWdVa4681wMbcyX0WBPYnq+2nsfc1ITNp28A8MOecCLikvn2uQCyNFosTE1QqVSFXvN6Qqpu+7DMYItyRAJsIYQQQpQJO0v9yo/+Ho78PLoVANfiU2n32TYAtp6JYen+y8z79xy9G7sy7yn/Qq93Lc8M9sWbyWi12nsG5EKUFUkREUIIIYRRuTta0aexq27/o39CSc7I5q9jVwt88DEuKZ3IuBSu5wmwk9Kz5EFHUW5IgC2EEEIIo/t2RAAHpnbP115v2kaWH4o0aBvx4yF6fLmTI5dvG7RfvpVSqmMUoqgkwDYyqSIihBBCKFwdLKnhaGXQlqXRMvWvk7r9a/GphEYnkpGl0bXlLmJzOS65bAYqxH1IgG1kUkVECCGE0PNxty+wPStbw6IdF3W52rmszdUEeDkBcDkuhR3nYug0e7tUFRFGJQG2EEIIIcqNRm4FB9h1p23k801n87WP7Vib2tWUVSJ/PXCZUT8HE3krRVZ3FEYlAbYQQgghyg0X+8JXfMzLTK2iS4NqjO9Shzo5K0bGJukfcryWkFbslSGFKClSpk8IIYQQ5Uafxq58uv4MTrbm2FmYERqdmK/PkICafDzYF0szNQBdG1bjlS51WLjjokG/V38/xqXYZFzsLTA1UfFat3o4Wpvh6WTNplPXaeHtRDW7ogX0QhSHSit/3pULiYmJODg4kJCQgL19wR+PCSGEEJVBfEoGVuZqLEzVnL9xh5eXHSE8VnmAsaGrHZsmdirwvLUhV5my6gRpmZoCj+ea2rchszaexc/DkbWB7QE4d/0OIVG3GdbCQ2ppi0IVNV6TFBEhhBBClCuO1uZYmCqz0/Vd7Nj2ZmfdsWxN4fOCg/xrEDqzD0HDm6M2KTxInrVRyeU+HhWva+s9fxdTVp1k06nrDzl6ISTAFkIIIUQ5p1KpMM0JmFt4O92zr4mJiv5N3djxVhe+fS7gvtdOSs/i0s0k3X5whFJbe9OpaA5einuIUYvKTAJsIYQQQpR7GyZ05KVOtXmvf6Mi9fdwsqaPrys/jmxxz37nb9xh29kY3f7xK/GsPxHNuF+P8tTiA2Rl3zvdRIiCSA62kQUFBREUFER2djbnz5+XHGwhhBCihP28N5yZ60If6Nytkzqh1ULNKtZYmatLeGSiopEc7ApCFpoRQgghSlfNKta67RkDfAqttV2QhTsu0vPLXXzw96nSGJp4REmALYQQQohHWs0q+uXXO9avxsYJHVkT2N5gWfY+jV3pUNcZM7WKBi52uva/jl4F4I/DV+75gKUQeUkdbCGEEEI80jyc9DPYucG2v4cje9/pRkhUPEv3RTClT0OcbMxJycjC0dqcZfsjmL72tMF1zkQn4lvDoUzHLiomCbCFEEII8UiztTDln9c6YKpW6cr/5fL3cMT/KX/dvrmpOUCBgfS+i7ESYIsikRQRIYQQQjzyfGs40NC16LnX/h6OvNuvIa28nahTzQbQl/AT4n6kikg5ISs5CiGEEOXTofBbDPtuPwDV7Sz4dkQAzT2rGHlUwhiKGq9JiogQQgghxD34uOsDqZg76TyxcB8d6jqjUkGvxq7YW5oyyL+GEUcoyhsJsEtIVFQUI0aMICYmBlNTU6ZPn87QoUONPSwhhBBCPCRbC1PM1SZk5Fl0Zk9YLAC7LyhfO9R1pqqthVHGJ8ofycEuIaampsyfP5/Q0FC2bt3KG2+8QXJysrGHJYQQQogSYGNx70Vmzl2/U0YjERWBBNglxM3NDX9/fwCqV6+Ok5MTt27dMu6ghBBCCFEi5j3lj72l/oP/wK518K2hTx05d0MJsDVSK1tQiQLsXbt2MWDAANzd3VGpVKxZsyZfn4ULF1KrVi0sLS0JCAhg9+7dD3Svw4cPo9Fo8PDweMhRCyGEEKI86NqgOidm9Gb/1G7MHerHpJ4NWDW+HS+0rwXA+Rt3OHElniYzNjNvy3kjj1YYW6UJsJOTk/Hz82PBggUFHl+xYgUTJ05k2rRpHDt2jI4dO9K3b18iIyN1fQICAvD19c33unbtmq5PXFwczz//PIsXLy719ySEEEKIsuXmYMWTATVRmyg1tf09HQFYfiiKgQv2kpyRzdf/XeCxb3bz895wcou1fbH5HC8vO0xGlibfNdccu0qD9zay6/zNsnwrohRVyjJ9KpWK1atXM3jwYF1b69atad68OYsWLdK1NWrUiMGDBzNr1qwiXTc9PZ2ePXsyduxYRowYcd++6enpuv3ExEQ8PDykTJ8QQghRgZy7fofe83cVevzjwb480bwGPu9vBmDRs83p28TNoI/3O+sBqGJtxrH3e5XeYMVDK2qZvkozg30vGRkZHDlyhF69DH+oe/Xqxb59+4p0Da1Wy6hRo+jWrdt9g2uAWbNm4eDgoHtJOokQQghR8dR3sWV4a0+cbc0LPP7emlO64Brg4s0kg+OpGdm67dspmaUzSFHmJMAGYmNjyc7OxsXFxaDdxcWF69evF+kae/fuZcWKFaxZswZ/f3/8/f05efJkof2nTp1KQkKC7hUVFfVQ70EIIYQQZU+lUvHp4004/F5P9kzpSg1Hq3v2P34lgVNXE7gWnwrAkcuGq0PGJaUXdJqoYKQOdh4qlcpgX6vV5msrTIcOHdBo8udVFcbCwgILC6mXKYQQQjwqalaxxiTP1OUTzWrw17GrBn22hN5gS+gNajvb8N+bndl9wTDvet6W83zyeJOyGK4oRTKDDTg7O6NWq/PNVsfExOSb1S5pQUFB+Pj40LJly1K9jxBCCCFKX7+c/Ora1Wz4+HFfXu9Wt8B+l2KTuRyXwsZTSuxRr7otAL8djGTHuZh8/eNTMpi0IoTDEVICuCKQABswNzcnICCALVu2GLRv2bKFdu3aleq9AwMDCQ0NJTg4uFTvI4QQQojSN6lnfWYM8GH52DZYm5sytIX+Gasejaozqp23br/LFzuIvJWCpZkJf73Sjla1nAA4FK4PorM1WrRaLYt2XuSvY1cZ8u1+KmF9igqn0qSIJCUlERYWptsPDw8nJCQEJycnPD09mTRpEiNGjKBFixa0bduWxYsXExkZybhx40p1XEFBQQQFBZGdnX3/zkIIIYQo1yxM1YzKqY0NULOKPie7a8PqPNvaC3tLU77epo9JejRywc7SjAF+7hwKv8Xpa4kAJKVn0fvLXbg5WFLNTp9WeuJKAn4ejqX/ZsQDqzQB9uHDh+natatuf9KkSQCMHDmSJUuW8NRTTxEXF8eHH35IdHQ0vr6+bNiwAS8vr1IdV2BgIIGBgbqyL0IIIYR4dKhUKiZ0r8f2czEM9HMHoHOD6ny9LQwLUxMm9qjPUy2VWW5fd6Xs26mrCWi1Wo5HxXM1PpWrOQ9E5loTclUC7HKuUtbBLo+KWldRCCGEEBXf3rBYalezwc1BP8OdlplN4w82k63RMneoHxdikvh258V85zZys2fjhI5lOVyRo6jxWqWZwS6vJEVECCGEqHza13XO12ZppqZJDQdCouJ588/jhZ57JjqRCzfuUM/FTte2dF8EZmoThrf2LJXxiuKRGexyQmawhRBCCHHpZhLv/HXS4EHHvFzsLbiRqNTK/uH5FvTwcSEmMY1Wn/4HwNHpPXGyKXjRG/HwZCVHIYQQQogKpnY1W/54uS0Te9TTtZmb6sO17o305YNf/OUwPeft5L+z+rJ+p64mcDwqnsQ0/aqQWq2W9Cz5pLwsSYBtZFIHWwghhBB36+mjD6SHt9KnfUzoXo8GeVJDLsQkMfUv/crRP+8NZ1DQXp7+7gBZ2RqiE1L54t9z+H6wmVNXE8pm8EJSRMoLSRERQgghRF5L9oZjY2HKY03d+XTDGfr6utKurjMXbybRfe7OYl+vpXcV/hxXuut7POrkIUchhBBCiAosbz3tjwb76rZrVbV5oOvdSs4A4PyNO6jA4CFJUbIkRUQIIYQQogIxMVFRw1Ep7+dXs+A1NAb5u+druxqfSnRCKr2+3MXjC/eRkpFVquOszCTANjLJwRZCCCFEcf0+tjWfP9mE70e20LX1b+Km257/lD9nPuxjcE5apoZXfz8GKKtEnriSwPkbd0hIzeR+0rOyeXf1Sf49fb2E3sGjTXKwywnJwRZCCCHEg/h+1yVupWQwsUc9vtp6AX8PR3o1dgXA+531hZ7XuX41dp6/SdcG1fh5dCsAVh+7wo97wln0bAAeTtYA/Hk4ilVHr3DgklI6MOKz/qX8jsovKdMnhBBCCFEJjO1Umyl9GmJhqubtPg11wTXAomebU6eaDWsC2+dLJ9l5/iYA28/dJHe+9Y0Vxzl1NZFP1p8B4HJcMpNXntAF1wDJ6SWbWqLRaNl8+jrXE9JK9LrGJA85CiGEEEI8ovo2caNvTurIyvHtSErL4lJsEk8u2m/Q77tdl3gmTznA6EQl2A2PTc53zWUHLrPyyBWeb+vFiDZeqFQqALI1WkxU6PYLotVqydJoMVPr53g3nIrm1d+PUd3OgkPTejz4my1HJMAWQgghhKgEzNQmVLExp6mlo8GKkACfbTzLkcu3dfvHo+Lp8Pk2rtxOzXedzzaeBeD9tadZG3KNtMxsfhrVkheXHiYtM5sNEzoaBNCgpJ58/V8YDlZmXLhxh7d6N2B0TpWUbTkL5cTcSUer1aJSqVi2P4JlBy7z06iW1KxirbvOldsp2FuZYW9pVnLfmFIgKSJGJg85CiGEEKIsmalN+P75FtiYqw3at4TeMNgvKLi+25HLtzl9LZHXlh/j5NUELsQkFXjeGyuOEx6bTEhUPMkZ2cxcF8rvByMZ8M0e/jp6VdcvNkkpJTh97WnO30ji250Xdccu3Uyi29ydBP52tFjv1xgkwDaywMBAQkNDCQ4ONvZQhBBCCFFJNK3pyL6p3Xmyec0Sud6hcH2OdnTC/QNzgHdXn+TkXatLtvxkK6N+PqTbz8jS6La3n7tJRpaG4IhbaDTlu0aHBNhCCCGEEJWQg5UZL3euja2FKS72Fvfs28vHhZ9Gtbhnn1zR8Ur+dnpWNkv3RRBxVx53veq22FsWnqW849xN3XZ6lob0rGwlsM4J4tMyNdy4U74fiJQcbCGEEEKISqq+ix2nZvbm5p10Wn6y1eBYDUcrrsYrs9HTH/PBw8mayb0bMGfzOUa29WLp/ssFXvPizSSm/nWCCzeSOHz5Ns62hsG7V1VrfhzZkuiEVGasC+VMdGKh4zt5JYG+83eTkpFNYpq+XndEbApuDlYP+rZLnQTYQgghhBCVXDW7/DPYc4Y05deDl9Fq0a0c+UqXOjT3rELTmg5cvpViMNuc6+e9EaRmZuv2Y5PSDY738XXDs6o1nlWtaehqZxBgv9uvIZ9uOKvbv1RAFRNQyge2rVO1eG+yDEmALYQQQggh2PJGJ37aG87LneqQma2hnosd7eo6G/RRqVS6wParp5tx8koCCamZHAyPo4ajFbM2njUIrvMK8KrCqHbePNZUv+Jk3lSRS5/2w8RERWN3Bz5ef+aeM9sRcSkP81ZLneRgG5lUERFCCCFEeVDPxY5ZTzTF29mGei529+3vYGVGh3rO9G/qxoeDfKnvWvA5zTwdAejWsDoD/NwN6mTXrmar2zYxUdrb13Vm/WsdCrxWVRtzgHx53eWNBNhGJlVEhBBCCPEocM+TE+3jpiwj7mJvwffPt2D6Yz4839Yr3zlPt/JgsL8784b5GbTnBtuAwQqUw1p6AHAk8na5riQiKSJCCCGEEOKheTtb413VGnsrM/4c15ZVR67Stk5VnG0tGNOhVoHnWJiqmf90swKPfTcigD0XYnm1W11af/ofAOM61eHXA5e5eSedI5G3aentVGrv52GotLmLzwujSkxMxMHBgYSEBOzt7Y09HCGEEEKIYtNotGRrtflWcnxYx6PiUZuo8K3hwKQ/Qvjr6FUea+rGN880u+fS7CWtqPGapIgIIYQQQogSYWKiKvHgGsDPwxHfGkqqyFMt/t/encdFVb1/AP/Mxio7sgsibiCKippgLoihVlTuZi5lVpSlaLllpWmmtv4qNbOvuVZquaRGIS655g6K+4YCAiKorLLNnN8fyMTIsAwMDOLn/Wpeybnnnnnume2ZM+ee2wQSCbD9dDJmbT2L+jhWzASbiIiIiB4ZTzSzw8JB7SCRADZmRnU6gl1VnINNRERERI+UoZ2awMfZUj2qXd9wBJuIiIiIHjn1NbkGmGAbHNfBJiIiImpYuIpIPcFVRIiIiIjqN64iQkRERERkAEywiYiIiIj0iAk2EREREZEeMcEmIiIiItIjJthERERERHrEBJuIiIiISI+YYBMRERER6RETbCIiIiIiPZIbOgAqVnK9n8zMTANHQkRERETalORplV2nkQl2PZGVlQUAaNKkiYEjISIiIqKKZGVlwcrKqtztvFR6PaFSqZCUlAQLCwtIJJJav7/MzEw0adIECQkJvDR7HWB/1x32dd1if9ct9nfdYn/XrUehv4UQyMrKgouLC6TS8mdacwS7npBKpXBzc6vz+7W0tKy3T+KGiP1dd9jXdYv9XbfY33WL/V236nt/VzRyXYInORIRERER6RETbCIiIiIiPWKC/ZgyNjbGrFmzYGxsbOhQHgvs77rDvq5b7O+6xf6uW+zvutWQ+psnORIRERER6RFHsImIiIiI9IgJNhERERGRHjHBJiIiIiLSIybYRERERER6xAT7MbRkyRJ4enrCxMQE/v7+2L9/v6FDeiTt27cPoaGhcHFxgUQiwZYtWzS2CyEwe/ZsuLi4wNTUFL169cLZs2c16uTn5+Odd96Bvb09zM3N8dxzzyExMbEOj+LRMH/+fHTu3BkWFhZwcHDACy+8gIsXL2rUYX/rz/fff4927dqpL/YQEBCAv/76S72dfV175s+fD4lEgvDwcHUZ+1u/Zs+eDYlEonFzcnJSb2d/69fNmzcxcuRI2NnZwczMDO3bt8eJEyfU2xtsfwt6rKxbt04oFArx448/inPnzomJEycKc3NzcePGDUOH9siJiIgQM2fOFBs3bhQAxObNmzW2L1iwQFhYWIiNGzeK2NhYMWzYMOHs7CwyMzPVdcLCwoSrq6uIiooSJ0+eFEFBQcLPz08UFRXV8dHUb3379hUrVqwQZ86cETExMeKZZ54R7u7uIjs7W12H/a0/W7duFX/++ae4ePGiuHjxonj//feFQqEQZ86cEUKwr2vL0aNHRdOmTUW7du3ExIkT1eXsb/2aNWuWaNOmjUhOTlbfUlNT1dvZ3/pz584d4eHhIV5++WVx5MgRERcXJ3bu3CmuXLmirtNQ+5sJ9mOmS5cuIiwsTKOsdevWYvr06QaKqGF4OMFWqVTCyclJLFiwQF2Wl5cnrKysxNKlS4UQQty7d08oFAqxbt06dZ2bN28KqVQq/v777zqL/VGUmpoqAIi9e/cKIdjfdcHGxkb873//Y1/XkqysLNGiRQsRFRUlevbsqU6w2d/6N2vWLOHn56d1G/tbv6ZNmyaefPLJcrc35P7mFJHHSEFBAU6cOIGQkBCN8pCQEBw6dMhAUTVMcXFxSElJ0ehrY2Nj9OzZU93XJ06cQGFhoUYdFxcX+Pr68vGoREZGBgDA1tYWAPu7NimVSqxbtw45OTkICAhgX9eS8ePH45lnnkGfPn00ytnftePy5ctwcXGBp6cnhg8fjmvXrgFgf+vb1q1b0alTJwwZMgQODg7o0KEDfvzxR/X2htzfTLAfI2lpaVAqlXB0dNQod3R0REpKioGiaphK+rOivk5JSYGRkRFsbGzKrUNlCSEwefJkPPnkk/D19QXA/q4NsbGxaNSoEYyNjREWFobNmzfDx8eHfV0L1q1bh5MnT2L+/PlltrG/9e+JJ57A6tWrERkZiR9//BEpKSkIDAxEeno6+1vPrl27hu+//x4tWrRAZGQkwsLCMGHCBKxevRpAw35+yw0dANU9iUSi8bcQokwZ6Ud1+pqPR8XefvttnD59GgcOHCizjf2tP61atUJMTAzu3buHjRs3YsyYMdi7d696O/taPxISEjBx4kTs2LEDJiYm5dZjf+tP//791f9u27YtAgIC4OXlhVWrVqFr164A2N/6olKp0KlTJ3z66acAgA4dOuDs2bP4/vvvMXr0aHW9htjfHMF+jNjb20Mmk5X5xpeamlrm2yPVTMkZ6RX1tZOTEwoKCnD37t1y65Cmd955B1u3bsWePXvg5uamLmd/65+RkRGaN2+OTp06Yf78+fDz88M333zDvtazEydOIDU1Ff7+/pDL5ZDL5di7dy++/fZbyOVydX+xv2uPubk52rZti8uXL/P5rWfOzs7w8fHRKPP29kZ8fDyAhv3ezQT7MWJkZAR/f39ERUVplEdFRSEwMNBAUTVMnp6ecHJy0ujrgoIC7N27V93X/v7+UCgUGnWSk5Nx5swZPh4PEULg7bffxqZNm7B79254enpqbGd/1z4hBPLz89nXehYcHIzY2FjExMSob506dcJLL72EmJgYNGvWjP1dy/Lz83H+/Hk4Ozvz+a1n3bp1K7Ok6qVLl+Dh4QGggb931/15lWRIJcv0LV++XJw7d06Eh4cLc3Nzcf36dUOH9sjJysoS0dHRIjo6WgAQX331lYiOjlYvebhgwQJhZWUlNm3aJGJjY8WLL76odekhNzc3sXPnTnHy5EnRu3fver/0kCG8+eabwsrKSvzzzz8aS2vl5uaq67C/9WfGjBli3759Ii4uTpw+fVq8//77QiqVih07dggh2Ne1rfQqIkKwv/Xt3XffFf/884+4du2aOHz4sHj22WeFhYWF+nOQ/a0/R48eFXK5XMybN09cvnxZ/Pzzz8LMzEysXbtWXaeh9jcT7MfQ4sWLhYeHhzAyMhIdO3ZUL3VGutmzZ48AUOY2ZswYIUTx8kOzZs0STk5OwtjYWPTo0UPExsZqtHH//n3x9ttvC1tbW2FqaiqeffZZER8fb4Cjqd+09TMAsWLFCnUd9rf+jB07Vv0e0bhxYxEcHKxOroVgX9e2hxNs9rd+layzrFAohIuLixg4cKA4e/asejv7W7+2bdsmfH19hbGxsWjdurVYtmyZxvaG2t8SIYQwzNg5EREREVHDwznYRERERER6xASbiIiIiEiPmGATEREREekRE2wiIiIiIj1igk1EREREpEdMsImIiIiI9IgJNhERERGRHjHBJiIiIiLSIybYRERERER6xASbiIiIiEiPmGATEREREekRE2wiIiIiIj1igk1EREREpEdMsImIiIiI9IgJNhERERGRHjHBJiIiIiLSIybYRERERER6xASbiIiIiEiPmGATEREREekRE2wiIiIiIj1igk1EREREpEdMsBuAlStXQiKRaNwaN26MXr16Yfv27WXqP1y39O3ll1/WqBsZGYmQkBC4uLjA2NgYLi4u6NWrFxYsWAAAmD17doXtldx69epVafwmJia4ceNGme29evWCr6+vRlnTpk2rdF9jx46FsbExYmNjy7S7YMECSCQSbNu2rcL2St9WrlxZ7nFoi1ObhIQEvP322/Dy8oKJiQlsbGzQq1cv/PzzzxBCaK3/1ltvoWXLljA1NYWtrS3atm2L1157DQkJCRp1K3u8qmrgwIGQSCR4++23y61z/vx5jBo1Cs2aNYOJiQns7e3RsWNHvP3228jMzFTXE0Jg3bp16N69OxwcHGBiYgI3Nzf07dsX//vf/9T1rl+/DolEgi+++ELr/X3xxReQSCS4fv26uqxXr16QSCRo1qyZ1r7bt2+f1seu5Dl3/PhxdVnJc9nBwQFZWVll2mratCmeffbZMuWZmZlYsGABnnjiCVhbW0OhUMDR0RH9+vXDL7/8gvz8/HL7sLT8/HwsXrwYPXv2hJ2dHRQKBezs7NCrVy/88MMPWmNKT0/HjBkz4OPjAzMzM1haWqJr165YvHgxCgsLtd6PrvuUfv7LZDLY2NjAz88Pb7zxBg4fPlylYwPK77/SXn75ZTRq1EijrOQx7tevX5n62p4z//zzT7VfwyWq+jqq6vtQad9++y0kEkmF7xUPt2VpaYnAwED8+uuvWutfu3YNb7/9tvo9wszMDG3atMEHH3yAmzdvqutp69/SGjVqVOYzQJvSxy2VSmFlZQVvb2+MHj0aO3bsKPeYSt5PvvnmG0gkEvz999/l3sePP/4IiUSCTZs2Aaj8c0CXOKry+ffwZ5uZmZn6feu7777T+nrUpiqfz4cPH4ZcLse7776rtY1PP/200v4qsX//fgwdOhSurq4wMjKClZUVAgMD8f333yMnJ0ejH8p7f//9998hkUjwzz//qMtefvlljWMwMjKCl5cX3nvvPY33+9LtV/U5rK2PSt9Kx1HymIeFhZVpp+S1//vvv2uNoSrt65O8Vlolg1ixYgVat24NIQRSUlKwaNEihIaGYuvWrQgNDdWoO3jwYK0v5saNG6v/vXTpUrz55psYNGgQFi1aBFtbWyQkJODQoUP4/fffMX36dIwbN07jgy85ORkDBw7EO++8gxEjRqjLLS0tK40/Pz8fH3zwAdasWVOl4+3WrZvWZKz0ff3f//0fdu3ahTFjxuDIkSNQKBQAgNjYWMyaNQsvv/wyQkND4ebmppEI/e9//8Py5cvx999/w8rKSl3u5eVVpdjKc/DgQTz77LNo1KgRpkyZgnbt2iEjIwMbNmzAyJEjsW3bNvzyyy+QSou/+yYmJqJjx46wtrbGu+++i1atWiEjIwPnzp3Dhg0bcO3aNTRp0gRA1R6vqkhNTVW/8f/888/44osvYGJiolEnOjoa3bp1g7e3Nz766CM0bdoUaWlpOHXqFNatW4f33ntP/TjMmDEDCxcuxGuvvYYpU6bAwsICN27cwO7du/HHH39g3LhxNepTCwsLxMXFYffu3QgODtbY9tNPP8HS0lLrB0B5bt++jc8++wxz586ttO7ly5fRr18/pKam4vXXX8fMmTNhY2OD5ORkREZGYuzYsTh//nylbd2+fRv9+vXDmTNnMGbMGEyYMAEODg5IT0/H7t27MXXqVBw4cEDjtXHhwgWEhIQgOzsb7777LgIDA3H//n1s374dEydOxG+//YaIiAiYmZnVaB/gv/cLIQQyMzNx5swZrF69GsuWLcOECRPwzTffVLl/qysyMhK7d+9G7969q1T/008/RVBQUJnyyl7Dur6OqvI+VNpPP/0EADh79iyOHDmCJ554Qmu90n0eFxeHTz/9FCNGjIAQQuO9dfv27Rg+fDjs7e3x9ttvo0OHDpBIJIiNjcVPP/2EP//8E9HR0RUec3WUPu7s7GxcvHgR69atQ9++fTFo0CD8+uuv6vfbh40cORLTpk3DTz/9pPWLE1D8eda4ceMyn136iKMqn38lSj4DCgoKkJSUhF27dmHq1Kn4/PPPsW3bNvj5+VUYX+njqejzedq0aViwYAEGDBiAJ598Ur3fmTNn8PHHH+ONN94ot69KzJo1C3PmzEFgYCDmzp0LLy8v5Obm4tChQ5g9ezYuXbqEr7/+ukrxamNqaordu3cDAO7du4fff/8dX375JU6fPq31C01Vn8MP99HDfHx8ypQtX74ckyZNQqtWrcqN999//9X4e+7cudizZ4/6GCpqXy8EPfJWrFghAIhjx45plOfm5gpjY2Px4osvapQDEOPHj6+0XXd3d9GjRw+t25RKpdbyuLg4AUB8/vnnVYz+v/j79esnpFKpiImJ0djes2dP0aZNG40yDw8P8cwzz1Sp/aioKCGRSMRHH30khBCioKBA+Pn5iSZNmoh79+5p3WfWrFkCgLh9+3aVj0NbnKXdvXtXODg4CA8PD5GSklJm+4IFCwQAMX/+fHXZRx99JACIa9euaW2z9ONQncdLm88//1wAEM8884wAIH7++ecydUaPHi3Mzc1FZmam1jZUKpUQ4r/n4OjRoyuNq7LnTklccXFx6rKSPu/atasYMWKERv3MzExhZmYmXnvtNQFArFixQr1N22um5DHv16+fMDc3F8nJyRrtPfycKywsFD4+PsLa2lqcO3dOa8zXr18Xmzdv1rqttJCQEKFQKMTevXu1bk9LSxNr1qxR/11UVCR8fHyElZWVuHjxYpn669atEwDEG2+8UaN9hCj//aKoqEiMHTtWABBLliyp9Bir8podM2aMMDc31yjr2bOnaNmypWjWrJnw9/dXP7eE0P6c2bNnjwAgfvvtt0pj0kaX15Eu70NCCHHs2DGN19Zrr72mtZ62Pr9+/boAoBHbtWvXhLm5uejQoYPW9zKVSiU2btyo/ltb/5Zmbm4uxowZU+lxVHTcJa+jqVOnVnhMQ4cOFUZGRiItLa1MG+fPnxcAxLvvvqsu0/VzoKpxlKeiz4CYmBhhZWUl3N3dRV5eXoXtVPXzOT8/X/j5+QkvLy+Rk5MjhCh+j/H39xfNmjUTWVlZFd7Phg0bBADx6quvarxGSmRmZorIyEj13xX1w2+//SYAiD179qjLynvuBAUFaf2MqupzWIjy+0gbDw8PERAQIKysrMTAgQM1tlX22q/s+a9vnCLSgJmYmMDIyKjcUYTKpKenw9nZWeu2khFWfZo6dSrs7Owwbdo0vbbbp08fhIWF4dNPP8WJEycwe/ZsnDp1CsuXL9cYna5t//vf/5CamooFCxbA0dGxzPapU6eidevW+Pzzz9U/1aenp0MqlcLBwUFrm6UfB309Xj/99BMcHR2xatUqmJqaqkfcSktPT4elpWW5PzdLJBIAQE5ODvLz82v9eTR27Fhs2rQJ9+7dU5etW7cOADB8+HCd2vrkk09QVFSE2bNnV1hv8+bNOHfuHGbOnAlvb2+tdTw8PPDCCy9U2M6xY8ewY8cOvP766+jRo4fWOnZ2dhg5cmSZ+54+fTpatmxZpv6wYcMQEhKC5cuXIyUlpdr7VEQmk2HRokWwt7fH559/Xmn9mlAoFJg3bx5OnDiB9evX1+p91eb73vLlywEUT08LDAzEunXrkJubW6V9PTw80LhxY9y6dUtd9tVXXyEnJwdLlizR+l4mkUgwcODAGsWsq9mzZ6NNmzZYtGgR8vLyyq336quvoqCgAL/88kuZbStWrABQ/Lqu7Tiqw8/PDzNnzkR8fHy1n48Pfz4bGRlh9erVSEhIUH8Gzp8/H9HR0Vi5cmWFU3sAYM6cObCxsVFPQXqYhYUFQkJCqhVrRTp16gQAGs/L8mh7DleHra0tpk+fjk2bNuk0Ta2uMcFuQJRKJYqKilBYWIjExESEh4cjJydH608xQggUFRWVuYlS81gDAgKwceNGdUKqVCprNX4LCwt88MEH6p+CK1OVYyjx+eefw93dHYMHD8bChQsRFhaGp556qjYOo1xRUVGQyWTl/uQpkUjw3HPP4c6dOzhx4gSA4sdApVJh4MCBiIyMrHCqgz4er0OHDuH8+fMYPXo07OzsMGjQIOzevRtxcXFl7is5ORkvvfQS9u7di/v372ttz97eHs2bN8eSJUvw1Vdf4cKFC1ofn5oaPnw4ZDKZxvy+5cuXY/DgwVWanlSah4cH3nrrLSxfvhyXLl0qt15UVBQA4Lnnnqte0DVop2SfipL3F154AUVFRer5hdXZpzKmpqbo06cP4uLikJiYWKV9qmvYsGHw9/fHBx98UO788tJUKpXW94fK6Po6qur70P379/Hrr7+ic+fO8PX1xdixY5GVlYXffvut0pgAICMjA3fu3NH4crRjxw44Ojqia9euVWqjhLZ4q9I3VRUaGorc3FyNcxwe1qdPH3h4eJT5Aq9UKrFmzRp07dq1xj/dlxeHLp8d5Sl5ve7bt69K9avy+dyuXTt8/PHHWLx4Mb755hvMnTsXkydPRvfu3StsOzk5GWfOnEFISEiZ6V21LS4uDnK5HM2aNau0rrbncGklfVT6Vt7rb+LEiXB1dcXUqVNrFH9tYoLdgHTt2hUKhQJGRkZo0qQJfvjhByxatAh9+/YtU3fJkiVQKBRlbj///LO6ztKlS9G6dWt8/PHHaN++PSwsLNCnT58KT6CqqbCwMDRr1gzTpk2r9M0uIiJC6zHMmzevTF1zc3N88sknuH79Oho3blzrI27axMfHo3HjxjA3Ny+3jqenp7ouAIwYMQJvvPEGdu7ciX79+sHa2ho+Pj6YPHmyxsl+gH4er5IRtpKRo1dffRVCCPWIUon33nsPL7zwAn799Vf06tULFhYW6NixIz744APcvn1bo+4vv/wCGxsbvPvuu/D29oaVlRVCQ0OxZs0avSXbFhYWGDx4sPrD+ty5czhy5Ei1R8BmzpwJc3NzvP/+++XWKTnB1MPDQ6P84Q/vyhK06rRT8vwoeb5o8/BzqTr7VEVJ3ElJSVXepzokEgkWLlyIq1ev4ocffqi0/rBhw7S+P1T2RUDX11FV34d+//13ZGRk4NVXX1XH16hRI/Vr7mElj39hYSEuX76M0aNHw8zMDLNmzVLXiY+Pr/Dx1CYnJ0drvAqFQuMkuJqoynNCKpXi5ZdfRkxMjMYc8b/++gvJycnqfqqNOKry+VfdtstT1c/nKVOmoGvXrggPD0fLli3xySefVNp2VV7b+lLyfpSeno6lS5di06ZNmDp1qtZfWavyHC6tpI9K34yNjbXWNTU1xezZs7F//36tiznUBzzJsQFZvXq1+qfqtLQ0bN68GePHj4dSqSxztvDQoUMxZcqUMm2U/hbq5eWFU6dO4cCBA/jnn39w/Phx7N27F7t27cKKFStw4MCBMie/1ZSRkRE++eQTjBgxAhs2bMCwYcPKrfvkk09qPWHD1dW1TJlKpcJ3330HqVSK1NRUnDp1Ct26ddNr7PpQknCW/MQnkUiwdOlSzJgxAxERETh+/Dj27duHr7/+Gj/88AMiIiLQs2dPADV/vLKzs7FhwwYEBgaqTzTp2bMnvLy8sHLlSsyePVv9E7mxsTE2b96M8+fPIzIyUn1f8+bNw9KlS3Hw4EH1ySedO3fGlStXsHv3buzbtw/Hjx/Hrl27sH37dmzYsAFbt27V+pOmrsaOHYuePXsiNjYWK1euhJeXF3r06KH+NUAXJVOV3n///QpPRNPmm2++waRJk9R/t2nTBmfOnNE5hj/++AMDBgxQ/21ubo7s7Owq7//wc6m296kLwcHBCAkJwZw5czBmzJgK6y5cuFDrCZHapmeVpuvrqKrvQ8uXL4epqal6ylKjRo0wZMgQrFixApcvX0aLFi006i9ZsgRLlixR/61QKLB582b4+/tXGH9lTE1Nyx11LW+Kkq6q+px45ZVXMHfuXPz000/47rvvABRPDzE3N6/wvb+mcVTl86+6bZenqp/PMpkMs2bNQr9+/fD++++Xm2AaQsmXs9JefPFFrYNagO7P4dJ9VKKi96JXXnkFX3/9NaZPn46nn366qodRZ5hgNyDe3t7q+VAA0K9fP9y4cQNTp07FyJEjYW1trd7WuHFjjbrlkUql6NGjh/qNNycnB6+++irWr1+Pn376CW+99Zbej2P48OH44osvMHPmzArnD1pZWVXpGIDiJd7+/fdfrFu3DrNmzcLYsWMRExMDU1NTfYVdKXd3d1y+fBk5OTnljmKXjEqXrAxSwsPDA2+++ab67w0bNuDFF1/ElClTcPToUXV5TR6v9evXIzs7G0OHDtWYyzx06FDMnz8fUVFRZUZbvL291W+IQgj83//9HyZPnowPP/wQGzZsUNdTKBTo27evev/09HQMHjwY27dvx19//YWnn34acnnx21F5I74lP2GXd05Bjx490KJFC/zwww/YsGEDwsPDa5S4h4eHY9GiRZg6dSr27t1bZru7uzsA4MaNGxo/eY4YMUK9CsAbb7xR6TJ9pdspfUZ8r169cOzYMQDAxx9/jD179pTZJy4uTutZ90DZ51J19qmKkqU1XVxcqrxPTSxcuBAdO3bEF198gVdeeaXces2aNavy+8PDdHkdVeV96MqVK9i3bx8GDRoEIYT69TV48GCsWLECP/30E+bPn6+xT0kSWFhYiNjYWMyYMQPDhw/HyZMn1cm4u7t7melbVTm28uLV1zkRVX1OeHh4IDg4GL/88gu++OILZGVlYfv27RgxYgQsLCxqLY6qfv5Vp+3y6PL5XJJUGxkZVant0q/tqpLJZDq/15b+cpaSkoIvv/wSv/76K9q1a6d1laqqPIdLe7iPqnIMn376KV544QWsWrWqTkbwdcEpIg1cu3btcP/+/QrnkurC3NwcM2bMAIBqjcpVRemfgpctW1bj9s6dO4ePPvoIo0ePxrBhw7By5UpcuXIFM2fO1EO0VffUU09BqVRi27ZtWrcLIbB161bY2tpWOko1dOhQtGvXrtLHQJfHq+Sn6vDwcNjY2KhvJR/85f2UXUIikWDSpEmwtrau9L7s7OwQHh6uEZe9vT1kMpnGur2l3bx5EzKZDHZ2duW2+8orr+D777/HnTt3Kh3hrEzJT5D79u3Dn3/+WWZ7yRz+rVu3apQ7ODigU6dO6NSpU5WShPLasba2Vrfz8DGX7LNly5Zy292yZQvkcrl6Pebq7FOZ+/fvY+fOnfDy8oKbm1uV9qmp9u3b48UXX8RXX31V45Olqqqm73s//fQThBD4/fffNV5bzzzzDABg1apVZZKdkiQwICAAr7/+OrZs2YKcnByNX0f69u2LW7du1asTvYQQ2LZtG8zNzauULL366qu4c+cO/vjjD6xduxYFBQV6mR6iaxy6Knm9VvW1oo2+Pp+dnZ3Rtm1b7Nixo8onzTo6Olb4XltSp7SSL2edOnXCs88+i7///htt2rTBxx9/XOaaDEDVnsM19fzzz6Nbt26YNWuW3k9mrSkm2A1cTEwMAO3re1YmOTlZa/n58+cB1O6IVZ8+ffDUU09hzpw5Ov0s/rCioiKMGTMG9vb26rV6u3btismTJ+Obb77BwYMH9RVypcaNGwcHBwfMmDEDqampZbZ/9tlnuHDhAqZOnaoeOSjvMcjOzkZCQoLGY1CTx+v8+fP4999/MWjQIOzZs6fMLTg4GH/88QfS09MrvK+kpCRkZmaq76uwsFC9T2VxmZiYoFu3bti6dWuZN8q8vDxs3boVTz75ZIXTXMaMGYPQ0FBMmTJF61QhXY0dOxbe3t6YPn06VCqVxrYBAwbAx8cHn376KS5cuFDt++jUqRNCQkLw448/Yv/+/VXap+S+FyxYoPXDef369dixYwfGjRsHJyenau9TkZKfttPT0/W+8k9lPvnkExQUFODjjz/We9v6ft9TKpVYtWoVvLy8tL623n33XSQnJ+Ovv/6qsJ3u3btj9OjR+PPPP9Xr+06aNAnm5uZ46623kJGRUWYfIQQ2b96sU7w19fHHH+PcuXOYOHFilaYQvvDCC7Czs8NPP/2EFStWoGXLlhrrQNdVHLo4deoUPv30UzRt2hRDhw6tdjs1+Xx+2Icffoi7d+9iwoQJWqevZGdna6xV3adPH+zZs6fMOTNCCPz2229o2rQpmjdvXuF9GhsbY/HixcjLy6vSXHFtz2F9WLhwIRISEvDtt9/qrU194BSRBuTMmTPqn3bS09OxadMmREVFYcCAAWV+Oilv1MPS0lJ95nabNm0QHByM/v37w8vLC3l5eThy5Ai+/PJLODo66mWUoSILFy6Ev78/UlNT0aZNmzLb7927p/UYjI2N0aFDBwDFyxwdP34cf/31l8ZPcHPnzsW2bdv0PlUkMzNTfRWp0ho3boyePXti06ZNePbZZ+Hv748pU6bAz88PmZmZWL9+PX7++WcMGzZMY27gvHnzcPDgQQwbNgzt27eHqakp4uLisGjRIqSnp2ucrFmTx6tkdHrq1Kno0qVLme1ZWVnYtWsX1q5di4kTJ+L111/HvXv3MGjQIPj6+kImk+HChQv4+uuvIZVK1QlXRkYGmjZtiiFDhqBPnz5o0qQJsrOz8c8//+Cbb76Bt7e3xjSgBQsWICgoCAEBAQgPD4e7uzvi4+Pxf//3f7h165Z66b3yuLi4VDhCq6uSnyBL5kK3a9dOY9uWLVvQt29fdOnSBa+99hp69eoFGxsb3Lt3D0eOHMGpU6fKXcKvtLVr16Jv377o06cPXn75ZfTt2xcODg7IzMzE6dOnsXPnTo3VUGQyGTZu3IinnnoKAQEBePfddxEQEID8/Hxs27YNy5YtQ8+ePfHll1/WaJ8SJe8XQghkZWWpLzRz6tQpTJo0Ca+99lqV+jMlJUXr66Np06Y6jTJ6enrizTffrPACN5cvX9b6/uDm5lbhaLuur6PK3of++usvJCUlYeHChVpHO319fbFo0SIsX7680itdzp07F+vXr8eHH36InTt3wtPTE+vWrVO/P5RcaAYo/uWuZOS89Fx+fSl93Dk5OeoLvJRcSbCqX36MjY3x0ksv4bvvvoMQQuerzlYnjqp8/pU4ceIErKysUFhYqL7QzJo1a+Dg4IBt27ZVeRqHLp/P1TFkyBB8+OGHmDt3Li5cuIBXX31VfaGZI0eO4IcfflAvxQkAH330EbZt24YnnngC06dPR4sWLZCSkoIff/wRx44d05jiV5GePXvi6aefxooVKzB9+vRKj+Xh53BppfuoNC8vrwq/hHTr1g3PP/88/vjjjyrFXGdqeZ1tqgMli7SXvllZWYn27duLr776qsxC+A/XLX3r1q2but4PP/wgBg4cKJo1aybMzMyEkZGR8PLyEmFhYSIhIUFrLDW50Iy2ReZHjBghAGi9wEB5x+Dq6iqEKL4YgEKhKPdiDv/++6+QSqVi0qRJZbZV90Iz5cXUs2dPdb34+Hgxfvx40axZM2FkZCSsrKxEjx49xNq1a8tcIODw4cNi/Pjxws/PT9ja2gqZTCYaN24s+vXrJyIiIjTqVufxEqL4wjsODg6iffv25dYpKioSbm5uom3btkIIISIjI8XYsWPVFy6Ry+XC2dlZDBw4UPz777/q/fLz88UXX3wh+vfvL9zd3YWxsbEwMTER3t7eYurUqSI9Pb3MfR0/flwMGDBA2NvbC5lMJuzt7cWAAQPEiRMntPZ5RRf3EeK/i3tU9UIz2h7zwMBA9QVCHpaRkSE+/fRT0blzZ2FpaSnkcrlwcHAQTz31lFi8eLH6ohGVycvLE99995148sknhbW1tZDL5cLW1lZ0795dLFy4UGtfpaWlienTp4vWrVsLExMT0ahRI9GlSxexaNEiUVBQoPV+dN2n9PNYKpUKS0tL0bZtW/H6669rPNaVqeg1W3Jxk/IuNKPtMb59+7awtLQs90Iz5d1mzpxZYZy6vI6q8j70wgsvCCMjI5GamlrufQ4fPlzI5XL1BahQwUVApkyZIgBoXJTo6tWr4q233hLNmzcXxsbGwtTUVPj4+IjJkydrXJhJnxeaKTlOiUQiGjVqJFq1aiVGjRqlcTGT0io6plOnTgkAQiaTiaSkJK11yrvQTHXiqMrnX8n7QcnN2NhYODs7i5CQEPHNN9+Ue5Gth+n6+SxEzS6WtHfvXjF48GDh7OwsFAqFsLS0FAEBAeLzzz8vE/Ply5fFyJEjhbOzs5DL5cLa2lqEhISIXbt2lWm3oudObGyskEql4pVXXlGX6fIc1tZHpW8//vijet/yLi507tw5IZPJ6tWFZiRC1OEp4EREREREDRznYBMRERER6RETbCIiIiIiPWKCTURERESkR0ywiYiIiIj0iAk2EREREZEeMcEmIiIiItIjXmimnlCpVEhKSoKFhQUkEomhwyEiIiKih4gHF9xycXGBVFr+ODUT7HoiKSkJTZo0MXQYRERERFSJhISECq8KywS7nrCwsABQ/ICVviQyEREREdUPmZmZaNKkiTpvKw8T7HqiZFqIpaUlE2wiIiKieqyy6bw8yZGIiIiISI+YYBMRERER6RETbCIiIiIiPeIcbCIiogZOpVKhoKDA0GEQ1XsKhQIymazG7TDBJiIiasAKCgoQFxcHlUpl6FCIHgnW1tZwcnKq0XVJmGATERE1UEIIJCcnQyaToUmTJhVeGIPocSeEQG5uLlJTUwEAzs7O1W6LCTYREVEDVVRUhNzcXLi4uMDMzMzQ4RDVe6ampgCA1NRUODg4VHu6CL/KEhERNVBKpRIAYGRkZOBIiB4dJV9GCwsLq90GE2wiIqIGriZzSYkeN/p4vTDBJiIiIiLSI87Bfgzdyy1A5NkUFCgFRnX1MHQ4RERERA0KR7AfQ9EJ9zBtYyy+2XkZSpUwdDhEREQaXn75ZUgkEvXNzs4O/fr1w+nTpzXqla5T+rZu3Tp1nR9++AF+fn4wNzeHtbU1OnTogIULFwIAmjZtWm4bEokEvXr10hrf7NmzIZFIEBYWplEeExMDiUSC69evAwCuX79ebtuHDx8GAEydOhVNmzZFVlaWRluhoaHo0aMHPvroowpjLH1/pZXcd0xMTLn9fOjQITz99NOwsbGBiYkJ2rZtiy+//FI9d7/Enj17EBQUBFtbW5iZmaFFixYYM2YMioqKqtTPFdm4cSN69+4NGxsbmJmZoVWrVhg7diyio6PL1L1//z5sbGxga2uL+/fvl9netGlT/N///Z/G36X7ukR4eHi5j62+MMF+DHXzsoeliRxp2fk4fv2OocMhIiIqo1+/fkhOTkZycjJ27doFuVyOZ599tky9FStWqOuV3F544QUAwPLlyzF58mRMmDABp06dwsGDBzF16lRkZ2cDAI4dO6beZ+PGjQCAixcvqss2bdpUbnwmJiZYvnw5Ll26VOmx7Ny5s0yM/v7+AIC5c+eiUaNGmDx5srr+Tz/9hD179mDFihWYOnWqxn5ubm6YM2eORlmTJk2q3K8lNm/ejJ49e8LNzQ179uzBhQsXMHHiRMybNw/Dhw+HEMUDcGfPnkX//v3RuXNn7Nu3D7Gxsfjuu++gUCjUa6tX1s/lmTZtGoYNG4b27dtj69atOHv2LJYtWwYvLy+8//77Zepv3LgRvr6+8PHxqfCxKc3ExATTpk3TsXdqjlNEHkNGcime8nHCxpOJiIhNxhPN7AwdEhERkQZjY2M4OTkBAJycnDBt2jT06NEDt2/fRuPGjdX1Si4Kos22bdswdOhQvPrqq+qyNm3aqP9duh1bW1sAgIODA6ytrSuNr1WrVnBwcMAHH3yADRs2VFjXzs6u3BiNjY2xatUqBAQEYNCgQfDx8cGkSZPw2WefwcvLCwDQqFEjdX2ZTAYLC4ty26uKnJwcvPbaa3juueewbNkydfm4cePg6OiI5557Dhs2bMCwYcMQFRUFZ2dnfPbZZ+p6Xl5e6Nevn/rvyvpZm8OHD+Ozzz7DN998gwkTJqjLPT090bNnT3WCX9ry5csxcuRICCGwfPlyvPTSS5Ue6xtvvIHvv/8eERERePrppyutry8cwX5MPetXvHj6bycScfNe2Z9ZiIio4RFCILegyCA3bQlTVWVnZ+Pnn39G8+bNYWdX9UEhJycnHD58GDdu3Kj2fVdkwYIF2LhxI44dO1ajdvz9/TFjxgyMGzcOo0aNQufOnfHmm2/qKcqyduzYgfT0dLz33ntltoWGhqJly5b49ddfART3YXJyMvbt21due9Xp519//RWNGjXCW2+9pXX7wyt5XL16Ff/++y+GDh2KoUOH4tChQ7h27Vql99O0aVOEhYVhxowZdXo1U45gP6Z6tmiMzk1tcOz6XXz653ksfqmjoUMiIqJadr9QCZ+PIg1y3+fm9IWZUdXTju3bt6tHbnNycuDs7Izt27eXuRrliy++WOZiIKdPn0azZs0wa9YsDBw4EE2bNkXLli0REBCAp59+GoMHD9bLVS07duyIoUOHYvr06di1a1e59QIDA8vcX0ZGhkbcH3zwAVasWIEjR47g0qVLtbq0Ysm0Fm9vb63bW7dura4zZMgQREZGomfPnnByckLXrl0RHByM0aNHw9LSEgCq1c+XLl1Cs2bNIJf/95z46quv8NFHH6n/vnnzJqysrAAUT5vp378/bGxsABRPIfrpp5/wySefVHq8JX37888/Y9SoUZXW1weOYD+mpFIJ5r7gC4kE+DM2GRdSMg0dEhERkVpQUBBiYmIQExODI0eOICQkBP379y8zSvr111+r65XcSuYkOzs7499//0VsbCwmTJiAwsJCjBkzBv369dPbaOYnn3yC/fv3Y8eOHeXWWb9+fZkYH/5SEBUVheTkZAghajwiXlXl/aoghFAn+DKZDCtWrEBiYiI+++wzuLi4YN68eWjTpg2Sk5MBVL+fH/4SMXbsWMTExOCHH35ATk6OOj6lUolVq1Zh5MiR6rojR47EqlWrypyQqU3jxo3x3nvv4aOPPkJBQUGl9fWBI9iPsdZOlnja1xl/xibju91XsHgER7GJiBoyU4UM5+b0Ndh968Lc3BzNmzdX/+3v7w8rKyv8+OOPGqOWTk5OGvW08fX1ha+vL8aPH48DBw6ge/fu2Lt3L4KCgnQ7CC28vLzw2muvYfr06Vi+fLnWOk2aNKkwxrt37+K1117D+++/D4VCgbfeegs9e/aEvb19jePTpmXLlgCA8+fPIzAwsMz2CxcuwMfHR6PM1dUVo0aNwqhRo/DJJ5+gZcuWWLp0KT7++GN1HV36uUWLFjhw4AAKCwuhUCgAFM+nt7a2RmJiokbdyMhI3Lx5E8OGDdMoVyqV2LFjB/r371/pMU+ePBlLlizBkiVLKq2rDxzBfsy9E1z8go+ITcblW1mV1CYiokeZRCKBmZHcILeaTnmQSCSQSqVal2fTRUnimJOTU6N2Svvoo49w6dIljeUBdfHOO++oT5icPn06mjRpgrfffltv8T0sJCQEtra2+PLLL8ts27p1Ky5fvowXX3yx3P1tbGzg7OxcYR9W1s8vvvgisrOzq5TwLl++HMOHDy/zK8BLL71U7peahzVq1Agffvgh5s2bh8zM2v/VniPYj7nWTpbo18YJf59NwY/7r+GzwX6GDomIiAj5+flISUkBUDzCu2jRImRnZyM0NFSj3r1799T1SlhYWMDc3BxvvvkmXFxc0Lt3b7i5uSE5ORmffPIJGjdujICAAL3F6ujoiMmTJ+Pzzz/Xuj09Pb1MjNbW1jAxMcHmzZvx22+/4dixY+qR3JUrV8Lf3x8bN27EoEGDahTbxYsXy5T5+Pjghx9+wPDhw/H666/j7bffhqWlJXbt2oUpU6Zg8ODBGDp0KIDi9a1jYmIwYMAAeHl5IS8vD6tXr8bZs2fx3XffAUC1+jkgIADvvvsu3n33Xdy4cQMDBw5EkyZNkJycjOXLl6u/UN2+fRvbtm3D1q1b4evrq9HGmDFj8Mwzz5RZWaY8r7/+Or7++mv8+uuveOKJJ3TtSt0IqhcyMjIEAJGRkVHn933kWrrwmLZdeH/4l8jOK6zz+yciotpx//59ce7cOXH//n1Dh6KTMWPGCADqm4WFhejcubP4/fffNeqVrlP6Nn/+fCGEEL///rt4+umnhbOzszAyMhIuLi5i0KBB4vTp02Xuc8+ePQKAuHv3bqXxzZo1S/j5+WmUZWZmCnt7ewFAxMXFCSGEiIuLKzfGX3/9Vdy+fVs4ODiIefPmlbmPefPmCQcHB3H79m2Ncg8PD/H1119XGmNF910S3759+0S/fv2ElZWVMDIyEj4+PuKLL74QRUVF6nZOnjwpRo4cKTw9PYWxsbGws7MTPXr0EFu3blXX0aWfH7Z+/XrRq1cvYWVlJRQKhXBzcxMjRowQhw8fFkII8cUXXwhra2tRUFBQZt/CwkJha2srvvzyS619o62vfvnlFwFA9OzZs9yYKnrdVDVfkwhRg3VzSG8yMzNhZWWFjIwM9Vm5dUUIgd5f7kVcWg4+G9wOQzvpvmA9ERHVP3l5eYiLi4OnpydMTEwMHQ7RI6Gi101V8zXOwSZIJBIM7OAKAPgrNtnA0RARERE92phgEwCgn2/xFaEOXklHVl6hgaMhIiIienQxwSYAQHOHRmhmb44CpQp7L902dDhEREREjywm2ASgeJpIj5bFZ+Aev37XwNEQERERPbqYYJNaB3drAEB0wj2DxkFERET0KGOCTWodmtgAAM4nZSK/qPJLjxIR0aOBC4YRVV1Fl3evKl5ohtSa2JrC1twId3IKcC4pEx3cbQwdEhER1YBCoYBEIlFfiKOmV1MkasiEECgoKMDt27chlUphZGRU7baYYJOaRCJBhybW2HUhFSfj7zHBJiJ6xMlkMri5uSExMRHXr183dDhEjwQzMzO4u7tDKq3+RA8m2KTBv6kNdl1IxfHrd/Dqk56GDoeIiGqoUaNGaNGiBQoLuQQrUWVkMhnkcnmNf+1hgl0LBgwYgH/++QfBwcH4/fffDR2OTjo3tQUAHLt+F0II/pxIRNQAyGQyyGQyQ4dB9NjgSY61YMKECVi9erWhw6iWtq5WMJJJkZadj/g7uYYOh4iIiOiRwwS7FgQFBcHCwsLQYVSLiUKGtm5WAIpHsYmIiIhINzon2FlZWQgPD4eHhwdMTU0RGBiIY8eO1Xif6rSrq3379iE0NBQuLi6QSCTYsmWL1npLliyBp6cnTExM4O/vj/379+s1jvquk0fxyY3Hr98xcCREREREjx6dE+xx48YhKioKa9asQWxsLEJCQtCnTx/cvHmzRvvo2u7Bgwe1nrBx4cIFpKSkaN0nJycHfn5+WLRoUbmxrl+/HuHh4Zg5cyaio6PRvXt39O/fH/Hx8eo6/v7+8PX1LXNLSkoqt91HSacH87CP3+AINhEREZHOhA5yc3OFTCYT27dv1yj38/MTM2fOrPY+urarVCqFn5+fGDx4sCgqKlKXX7x4UTg5OYmFCxdWeiwAxObNm8uUd+nSRYSFhWmUtW7dWkyfPr3SNkvbs2ePGDRoUJXrZ2RkCAAiIyNDp/upDenZ+cJj2nbhMW27SM/ON3Q4RERERPVCVfM1nUawi4qKoFQqYWJiolFuamqKAwcOVHsfXduVSqWIiIhAdHQ0Ro8eDZVKhatXr6J379547rnnMHXqVF0OS62goAAnTpxASEiIRnlISAgOHTpUrTYrs3jxYvj4+KBz58610n512JoboZm9OQDgFC+bTkRERKQTnRJsCwsLBAQEYO7cuUhKSoJSqcTatWtx5MgRJCcnV3uf6rTr4uKC3bt34+DBgxgxYgR69+6N4OBgLF26VMcu+E9aWhqUSiUcHR01yh0dHcuddqJN3759MWTIEERERMDNza3CueTjx4/HuXPn9D7fvKbaN7EGAEQzwSYiIiLSic5zsNesWQMhBFxdXWFsbIxvv/0WI0aMqHB9zarsU5123d3dsXr1aqxfvx5yuRzLly/Xy7rND7chdFwPOjIyErdv30Zubi4SExPr1eh0VbV3twYAxDDBJiIiItKJzgm2l5cX9u7di+zsbCQkJODo0aMoLCyEp2f5V/2ryj7VaffWrVt4/fXXERoaitzcXEyaNEnXw9Fgb28PmUxWZrQ6NTW1zKh2Q1cygn0q4R6EEIYNhoiIiOgRUu11sM3NzeHs7Iy7d+8iMjISzz//vF72qWq7aWlpCA4Ohre3NzZt2oTdu3djw4YNeO+996p7SDAyMoK/vz+ioqI0yqOiohAYGFjtdh9FrZ0sYSSXIuN+Ia6n84IzRERERFWl86XSIyMjIYRAq1atcOXKFUyZMgWtWrXCK6+8AgBYtGgRNm/ejF27dlV5n6rWKaFSqdCvXz94eHiop4d4e3tj586dCAoKgqurq9bR7OzsbFy5ckX9d1xcHGJiYmBrawt3d3cAwOTJkzFq1Ch06tQJAQEBWLZsGeLj4xEWFqZrVz3SjORStHGxRHT8PcQk3IXng5MeiYiIiKhiOifYGRkZmDFjBhITE2Fra4tBgwZh3rx5UCgUAIpHlq9evarTPlWtU0IqlWL+/Pno3r07jIyM1OVt27bFzp07YWdnpzX248ePIygoSP335MmTAQBjxozBypUrAQDDhg1Deno65syZg+TkZPj6+iIiIgIeHh66dtUjr30T6+IEO/4eBnRwM3Q4RERERI8EieAE23ohMzMTVlZWyMjIgKWlpaHDAQD8EXMTE9fFwK+JNf4Y383Q4RAREREZVFXztWrPwaaGr+REx/NJmcgvUho2GCIiIqJHBBNsKpe7rRlszY1QoFThXFKmocMhIiIieiQwwaZySSQS+LlZAeAVHYmIiIiqigk2Vah9ExsAvOAMERERUVUxwaYK+TUpHsHmJdOJiIiIqoYJNlWog7sNpBLgRnouku7dN3Q4RERERPUeE2yqkJWpAu3crAEAB6+kGTYYIiIiokcAE2yq1JPN7QEAB5hgExEREVWKCTZV6skWxQn2wStp4HWJiIiIiCrGBJsq1cHdGqYKGdKyC3DxVpahwyEiIiKq15hgU6WM5TJ08bQFABy4zGkiRERERBVhgk1VUjIPmyc6EhEREVWMCTZVSck87CNxd1BQpDJwNERERET1FxNsqpJWjhawb2SE3AIlouPvGjocIiIionqLCTZViVQqQaAXl+sjIiIiqgwTbKqykmki/1y8beBIiIiIiOovJthUZcGtHSCVALE3M3jZdCIiIqJyMMGmKrNrZIxOHsXL9UWdu2XgaIiIiIjqJybYpJOQNo4AgB3nUgwcCREREVH9xASbdPKUT3GCffjaHWTkFho4GiIiIqL6hwk26cTDzhytnSygVAnsusBpIkREREQPY4JNOisZxd55ngk2ERER0cOYYJPOgr2LE+x9l9J4VUciIiKihzDBJp21c7WCfSNjZOcX4WjcHUOHQ0RERFSvMMEmnUmlEgS1agwA2H+FF50hIiIiKo0JNlVLYHM7AMWriRARERHRf5hgU7U84VmcYJ+5mYGsPC7XR0RERFSCCTZVi4u1KdxtzaBUCRy7zlFsIiIiohJMsKnaerS0BwD8FcurOhIRERGVYIJN1RbazgUA8PfZFOQXKQ0cDREREVH9wASbqq1zU1s4WhojK68I+y6lGTocIiIionqBCTZVm1QqwTNti0ext59OMnA0RERERPUDE2yqkVA/ZwBA1LlbuF/AaSJERERETLCpRto3sYartSlyC5Q4cIXTRIiIiIiYYNeCAQMGwMbGBoMHDzZ0KLVOIpEg2NsBAPDPxVQDR0NERERkeEywa8GECROwevVqQ4dRZ4JalSTYtyGEMHA0RERERIbFBLsWBAUFwcLCwtBh1JmuzexgJJfi5r37uJKabehwiIiIiAxK5wQ7KysL4eHh8PDwgKmpKQIDA3Hs2LEa71NUVIQPPvgAnp6eMDU1RbNmzTBnzhyoVCpdQyzXvn37EBoaChcXF0gkEmzZskVrvSVLlsDT0xMmJibw9/fH/v379RZDQ2RqJENAs+JLp+/hNBEiIiJ6zOmcYI8bNw5RUVFYs2YNYmNjERISgj59+uDmzZs12mfhwoVYunQpFi1ahPPnz+Ozzz7D559/ju+++05rmwcPHkRhYWGZ8gsXLiAlRfuVBXNycuDn54dFixaVG+v69esRHh6OmTNnIjo6Gt27d0f//v0RHx+vruPv7w9fX98yt6Skx3epuqBWjQEAey7cNnAkRERERAYmdJCbmytkMpnYvn27Rrmfn5+YOXNmjfZ55plnxNixYzXqDBw4UIwcObJMm0qlUvj5+YnBgweLoqIidfnFixeFk5OTWLhwYaXHAkBs3ry5THmXLl1EWFiYRlnr1q3F9OnTK22ztD179ohBgwZVuX5GRoYAIDIyMnS6n/oi7na28Ji2XXjN+FPk5hdVvgMRERHRI6aq+ZpOI9hFRUVQKpUwMTHRKDc1NcWBAwdqtM+TTz6JXbt24dKlSwCAU6dO4cCBA3j66afLtCmVShEREYHo6GiMHj0aKpUKV69eRe/evfHcc89h6tSpuhyWWkFBAU6cOIGQkBCN8pCQEBw6dKhabVZm8eLF8PHxQefOnWul/brS1N4cDhbGKFIJnEvONHQ4RERERAajU4JtYWGBgIAAzJ07F0lJSVAqlVi7di2OHDmC5OTkGu0zbdo0vPjii2jdujUUCgU6dOiA8PBwvPjii1rbdXFxwe7du3Hw4EGMGDECvXv3RnBwMJYuXarLIWlIS0uDUqmEo6OjRrmjo2O500606du3L4YMGYKIiAi4ublVOEd9/PjxOHfuXKXz2B8FbV2tAACxifcMGwgRERGRAek8B3vNmjUQQsDV1RXGxsb49ttvMWLECMhkshrts379eqxduxa//PILTp48iVWrVuGLL77AqlWrym3X3d0dq1evxvr16yGXy7F8+XJIJBJdD6mMh9sQQujUbmRkJG7fvo3c3FwkJiY+8qPTVdXWrTjBPn0zw8CREBERERmOzgm2l5cX9u7di+zsbCQkJODo0aMoLCyEp6dnjfaZMmUKpk+fjuHDh6Nt27YYNWoUJk2ahPnz55fb7q1bt/D6668jNDQUubm5mDRpkq6Ho8He3h4ymazMaHVqamqZUW0qq11Jgp3IBJuIiIgeX9VeB9vc3BzOzs64e/cuIiMj8fzzz9don9zcXEilmuHIZLJyl+lLS0tDcHAwvL29sWnTJuzevRsbNmzAe++9V91DgpGREfz9/REVFaVRHhUVhcDAwGq3+7jwc7MGAFxJzUZqVp5hgyEiIiIyELmuO0RGRkIIgVatWuHKlSuYMmUKWrVqhVdeeQUAsGjRImzevBm7du2q8j4AEBoainnz5sHd3R1t2rRBdHQ0vvrqK4wdO7ZMDCqVCv369YOHh4d6eoi3tzd27tyJoKAguLq6ah3Nzs7OxpUrV9R/x8XFISYmBra2tnB3dwcATJ48GaNGjUKnTp0QEBCAZcuWIT4+HmFhYbp21WPHrpEx2rlZ4XRiBvZevI0hnZoYOiQiIiKiOqdzgp2RkYEZM2YgMTERtra2GDRoEObNmweFQgGgeGT56tWrOu0DAN999x0+/PBDvPXWW0hNTYWLiwveeOMNfPTRR2VikEqlmD9/Prp37w4jIyN1edu2bbFz507Y2dlpjf348eMICgpS/z158mQAwJgxY7By5UoAwLBhw5Ceno45c+YgOTkZvr6+iIiIgIeHh65d9Vjq1coBpxMz8A8TbCIiInpMSYQQwtBBEJCZmQkrKytkZGTA0tLS0OFUW3T8XQxYcggWxnKc/OgpKGTVnoVEREREVK9UNV9j9kN61c7NGrbmRsjKL8KJG3cNHQ4RERFRnWOCTXolk0rQq+WDy6ZfTDVwNERERER1jwk26V2v1g4AgH2X0gwcCREREVHdY4JNete1mS0A4EJKJjLuFxo4GiIiIqK6xQSb9M7BwgRN7cwgBHAynvOwiYiI6PHCBJtqRaemxaPYx+LuGDgSIiIiorrFBJtqRZcHCfbx6xzBJiIioscLE2yqFZ2a2gAAYhLvIb9IaeBoiIiIiOoOE2yqFZ725rBvZISCIhViEzMMHQ4RERFRnWGCTbVCIpGgk8eDedicJkJERESPESbYVGv8PYqniZxOvGfYQIiIiIjqEBNsqjXNHRsBAK7dzjFwJERERER1hwk21Rov++IEOy49B0qVMHA0RERERHWDCTbVGlcbUxjJpSgoUiHp3n1Dh0NERERUJ5hgU62RSSVoamcGALh6O9vA0RARERHVDSbYVKua2XMeNhERET1emGBTrfJyMAcAXE7lCDYRERE9HphgU61q7WQJADifnGngSIiIiIjqBhNsqlU+LsUJ9oWUTK4kQkRERI8FJthUq5ramcNEIUVeoQrX0zkPm4iIiBo+JthUq2RSCVpxmggRERE9RphgU63zcS5OsM8lMcEmIiKiho8JNtU6H2cLABzBJiIioscDE2yqdSUnOp5jgk1ERESPASbYVOtK5mDfyszHnZwCA0dDREREVLuYYFOta2QsV18yndNEiIiIqKFjgk11oo2LFQDgVOI9wwZCREREVMuYYFOd6OBuDQA4cf2uYQMhIiIiqmVMsKlOdGpqCwA4EX8XKl7RkYiIiBowJthUJ9q4WMJEIcW93EJcvZ1t6HCIiIiIag0TbKoTCpkUHd1tAAD7L6cZOBoiIiKi2sMEm+pMsLcjACDybIqBIyEiIiKqPUywqc6E+BQn2Meu3+F62ERERNRgMcGmOtPE1gwtHRtBJYATN7iaCBERETVMTLBrwYABA2BjY4PBgwcbOpR6p2Q97IspvOAMERERNUxMsGvBhAkTsHr1akOHUS+1crIAAJxPyTJwJERERES1gwl2LQgKCoKFhYWhw6iXWj9IsC8ywSYiIqIGSucEOysrC+Hh4fDw8ICpqSkCAwNx7NixGu/TtGlTSCSSMrfx48frGmK59u3bh9DQULi4uEAikWDLli1a6y1ZsgSenp4wMTGBv78/9u/fr7cYHnfezpYAgGu3s5FXqDRwNERERET6p3OCPW7cOERFRWHNmjWIjY1FSEgI+vTpg5s3b9Zon2PHjiE5OVl9i4qKAgAMGTJEa5sHDx5EYWFhmfILFy4gJUX7MnA5OTnw8/PDokWLyo11/fr1CA8Px8yZMxEdHY3u3bujf//+iI+PV9fx9/eHr69vmVtSUlK57VIxBwtj2JgpoBLABY5iExERUUMkdJCbmytkMpnYvn27Rrmfn5+YOXOm3vYRQoiJEycKLy8voVKpymxTKpXCz89PDB48WBQVFanLL168KJycnMTChQsrPRYAYvPmzWXKu3TpIsLCwjTKWrduLaZPn15pm6Xt2bNHDBo0qMr1MzIyBACRkZGh0/08ikYvPyI8pm0Xqw7FGToUIiIioiqrar6m0wh2UVERlEolTExMNMpNTU1x4MABve1TUFCAtWvXYuzYsZBIJGW2S6VSREREIDo6GqNHj4ZKpcLVq1fRu3dvPPfcc5g6daouh6VxvydOnEBISIhGeUhICA4dOlStNiuzePFi+Pj4oHPnzrXSfn3Uvok1ACAm/p5B4yAiIiKqDTol2BYWFggICMDcuXORlJQEpVKJtWvX4siRI0hOTtbbPlu2bMG9e/fw8ssvlxuLi4sLdu/ejYMHD2LEiBHo3bs3goODsXTpUl0OSUNaWhqUSiUcHR01yh0dHcuddqJN3759MWTIEERERMDNza3COerjx4/HuXPnKp3H3pCoE+zEewaNg4iIiKg26DwHe82aNRBCwNXVFcbGxvj2228xYsQIyGQyve2zfPly9O/fHy4uLhXG4u7ujtWrV2P9+vWQy+VYvny51hFvXT3chhBCp3YjIyNx+/Zt5ObmIjEx8bEana4KvwcJ9rXbObjLKzoSERFRA6Nzgu3l5YW9e/ciOzsbCQkJOHr0KAoLC+Hp6amXfW7cuIGdO3di3LhxlcZy69YtvP766wgNDUVubi4mTZqk6+FosLe3h0wmKzNanZqaWmZUm6rP1twILR0bAQD+vZZu4GiIiIiI9Kva62Cbm5vD2dkZd+/eRWRkJJ5//nm97LNixQo4ODjgmWeeqbCttLQ0BAcHw9vbG5s2bcLu3buxYcMGvPfee9U9JBgZGcHf31+9gkmJqKgoBAYGVrtdKqtbc3sAwIEraQaOhIiIiEi/5LruEBkZCSEEWrVqhStXrmDKlClo1aoVXnnlFQDAokWLsHnzZuzatavK+5RQqVRYsWIFxowZA7m8/NBUKhX69esHDw8P9fQQb29v7Ny5E0FBQXB1ddU6mp2dnY0rV66o/46Li0NMTAxsbW3h7u4OAJg8eTJGjRqFTp06ISAgAMuWLUN8fDzCwsJ07SqqwJPN7bHi4HXsv3xb5yk4RERERPWZzgl2RkYGZsyYgcTERNja2mLQoEGYN28eFAoFgOKR5atXr+q0T4mdO3ciPj4eY8eOrTAGqVSK+fPno3v37jAyMlKXt23bFjt37oSdnZ3W/Y4fP46goCD135MnTwYAjBkzBitXrgQADBs2DOnp6ZgzZw6Sk5Ph6+uLiIgIeHh4VK2DqEqeaGYHcyMZEu7cx7e7rmDsk01hYaKofEciIiKiek4ihBCGDoKAzMxMWFlZISMjA5aWloYOp058HXUJ3+y6DACQSIDw4JaY2KeFgaMiIiIi0q6q+Vq152AT1dRrPZrhCU9bGMulEAL4fu8V3MvlqiJERET0aGOCTQbTyFiO9W8E4MLcfmjp2Ah5hSqsP5Zg6LCIiIiIaoQJNhmcRCLBK92Kl2zceDLRwNEQERER1QwTbKoXnvZ1hkImwaVb2bh0K8vQ4RARERFVGxNsqheszBTo0aIxAGD76WQDR0NERERUfUywqd7o5+sEAPjnYqqBIyEiIiKqPibYVG/0bFk8gh17MwN3criaCBERET2amGBTveFgaYLWThYQAth/+bahwyEiIiKqFibYVK8EtXYAAPx9JsXAkRARERFVDxNsqldC27kAAHZdSEVmXqGBoyEiIiLSHRNsqle8nS3QwqERCopUiOQoNhERET2CmGBTvSKRSNBfvZoI52ETERHRo4cJNtU7PVsVz8Pef/k2ipQqA0dDREREpBsm2FTvtG9iDWszBTLzihCTcM/Q4RARERHphAk21TsyqQRdmtoCKF4Tm4iIiOhRwgSb6qXmDo0AAFdvZxs4EiIiIiLdMMGmesmr8YMEOzXHwJEQERER6YYJNtVLXhzBJiIiokcUE2yql5o1NgcApGbla1xwJunefdwvUBoqLCIiIqJKMcGmesnSRAFHS2MAwNXU4lHsa7ez0fPzPQj+8h9cSMk0ZHhERERE5WKCTfVWS0cLAMDFlCwAwJ+nk1GoFEjKyEPYmhMo5BrZREREVA8xwaZ6y8fZEgBwLrl4tDrq/C31tuvpuVh3LMEgcRERERFVhAk21Vs+Lg8S7KRMXLudjdOJGZBIgLd6eQEAtkTfNGR4RERERFoxwaZ6q2QE+/iNu3j3t1MAgKBWDhjs7wYAOHMzAwVFnCZCRERE9QsTbKq3PO3NYSwvfopGx9+DRAJM7dcKnvbmsDJVIL9IxZMdiYiIqN5hgk31llwmxdtBzeFpb46uzWyxdKQ/WjtZQiKRoH0TawBATMI9g8ZIRERE9DC5oQMgqsg7wS3wTnCLMuXtm1hj76XbiE3MMEBUREREROXjCDY9kkqu9HgjPdfAkRARERFpYoJNjyR3WzMAQPwdJthERERUvzDBpkdSSYKdkpmHvEJeOp2IiIjqDybY9EiyMVPAwrj4FILEuxzFJiIiovqDCTY9kiQSCZpwmggRERHVQ0yw6ZGlnofNEx2JiIioHmGCTY+sJramAICEu/cNHAkRERHRf5hg0yPL0dIEAHA7K9/AkRARERH9hwl2LRgwYABsbGwwePBgQ4fSoDW2MAYApGblGTgSIiIiov8wwa4FEyZMwOrVqw0dRoNXkmBzBJuIiIjqEybYtSAoKAgWFhaGDqPBc7AoniKSygSbiIiI6hGdE+ysrCyEh4fDw8MDpqamCAwMxLFjx/Syz82bNzFy5EjY2dnBzMwM7du3x4kTJ3QNsVz79u1DaGgoXFxcIJFIsGXLFq31lixZAk9PT5iYmMDf3x/79+/XWwykPyUj2Fl5RbzYDBEREdUbOifY48aNQ1RUFNasWYPY2FiEhISgT58+uHnzZo32uXv3Lrp16waFQoG//voL586dw5dffglra2utbR48eBCFhYVlyi9cuICUlBSt++Tk5MDPzw+LFi0qN9b169cjPDwcM2fORHR0NLp3747+/fsjPj5eXcff3x++vr5lbklJSeW2S/pnaSKHsbz4KcxpIkRERFRvCB3k5uYKmUwmtm/frlHu5+cnZs6cWaN9pk2bJp588skqxaFUKoWfn58YPHiwKCoqUpdfvHhRODk5iYULF1baBgCxefPmMuVdunQRYWFhGmWtW7cW06dPr1JsJfbs2SMGDRpU5foZGRkCgMjIyNDpfh533RbsEh7Ttovj1+8YOhQiIiJq4Kqar+k0gl1UVASlUgkTExONclNTUxw4cKBG+2zduhWdOnXCkCFD4ODggA4dOuDHH3/U2qZUKkVERASio6MxevRoqFQqXL16Fb1798Zzzz2HqVOn6nJYagUFBThx4gRCQkI0ykNCQnDo0KFqtVmZxYsXw8fHB507d66V9hs6B/WJjlxJhIiIiOoHnRJsCwsLBAQEYO7cuUhKSoJSqcTatWtx5MgRJCcn12ifa9eu4fvvv0eLFi0QGRmJsLCwClfjcHFxwe7du3Hw4EGMGDECvXv3RnBwMJYuXarLIWlIS0uDUqmEo6OjRrmjo2O500606du3L4YMGYKIiAi4ublVOEd9/PjxOHfuXKXz2Em7/5bq4xQRIiIiqh/kuu6wZs0ajB07Fq6urpDJZOjYsSNGjBiBkydP1mgflUqFTp064dNPPwUAdOjQAWfPnsX333+P0aNHa23X3d0dq1evRs+ePdGsWTMsX74cEolE10Mq4+E2hBA6tRsZGVnjGKhqnB5cbCY5gyPYREREVD/ofJKjl5cX9u7di+zsbCQkJODo0aMoLCyEp6dnjfZxdnaGj4+Pxn7e3t4aJxc+7NatW3j99dcRGhqK3NxcTJo0SdfD0WBvbw+ZTFZmtDo1NbXMqDbVD242ZgCARF4unYiIiOqJaq+DbW5uDmdnZ9y9exeRkZF4/vnna7RPt27dcPHiRY36ly5dgoeHh9a20tLSEBwcDG9vb2zatAm7d+/Ghg0b8N5771X3kGBkZAR/f39ERUVplEdFRSEwMLDa7VLtcbUxBQDcvJtr4EiIiIiIiuk8RSQyMhJCCLRq1QpXrlzBlClT0KpVK7zyyisAgEWLFmHz5s3YtWtXlfcBgEmTJiEwMBCffvophg4diqNHj2LZsmVYtmxZmRhUKhX69esHDw8PrF+/HnK5HN7e3ti5cyeCgoLg6uqqdTQ7OzsbV65cUf8dFxeHmJgY2Nrawt3dHQAwefJkjBo1Cp06dUJAQACWLVuG+Ph4hIWF6dpVVAfcHiTYHMEmIiKi+kLnBDsjIwMzZsxAYmIibG1tMWjQIMybNw8KhQJA8cjy1atXddoHADp37ozNmzdjxowZmDNnDjw9PfF///d/eOmll8rEIJVKMX/+fHTv3h1GRkbq8rZt22Lnzp2ws7PTGvvx48cRFBSk/nvy5MkAgDFjxmDlypUAgGHDhiE9PR1z5sxBcnIyfH19ERERUe5IOhmWq3Vxgp2alY/8IiWM5TIDR0RERESPO4kQQhg6CAIyMzNhZWWFjIwMWFpaGjqcR4YQAj4fReJ+oRJ73usFT3tzQ4dEREREDVRV87Vqz8Emqg8kEkmpedicJkJERESGxwSbHnlNHiTYcWnZBo6EiIiIiAk2NQBtXa0AANHx9wwbCBERERGYYFMD0NHDBgBwIv6ugSMhIiIiYoJNDUAH9+IE+0Z6LtKyecl0IiIiMiwm2PTIszJVoKVjIwDA7gupBo6GiIiIHndMsKlBGNjRDQCwbN81qFRceZKIiIgMhwk2NQgvPeEOCxM5rqRmIzrhnqHDISIioscYE2xqECxMFOjS1BYAcOZmhoGjISIioscZE2xqMHxciq+odC4p08CREBER0eOMCTY1GG0eJNhnkzmCTURERIbDBJsaDB/n4gvOXErJRqFSZeBoiIiI6HHFBJsajCa2pmhkLEeBUoUb6TmGDoeIiIgeU0ywqcGQSCRwszEFACTevW/gaIiIiOhxxQSbGhQm2ERERGRoTLCpQXG1Lk6wb95jgk1ERESGwQSbGhTXByPYNzmCTURERAbCBJsaFFdrMwAcwSYiIiLDYYJNDYqreg52roEjISIioscVE2xqUErmYKdm5SO/SGngaIiIiOhxxASbGhT7RkawMJFDCOBqKtfCJiIiorrHBJsaFIlEAm/n4kumn0/ONHA0RERE9Dhigk0Njs+DBPscE2wiIiIyACbY1OD4cASbiIiIDIgJNjU4JVNEztzMwP0CnuhIREREdYsJNjU4rZ0t4Gptisy8Inyw5Yw6yY6ITUbQF//g+PU7Bo6QiIiIGjIm2NTgKGRSfPCMNwBg48lEvPnzCaRk5GHa76cRl5aDL3ZcNHCERERE1JAxwaYGqZ+vEz55wRcA8M/F2xjywyFk5RcBAA5fu4OLKVmGDI+IiIgaMCbY1CBJJBKM7OqBvm0cAQAJd+5DIZPAz80KALDm8HUDRkdEREQNGRNsatBe694MUgkgl0rwwTM+mNa/NQBg08mbyMwrNHB0RERE1BDJDR0AUW3q1NQWJz98CsZyGUyNZBBCoIVDI1xOzcZXOy5h9nNtDB0iERERNTAcwaYGz9rMCKZGMgDFU0dmPjgBcuWh69h1/pYhQyMiIqIGiAk2PXZ6tXLAmAAPAED4uhjcyy0wcERERETUkDDBpsfSzGd80NTODFn5RTgSx3WxiYiISH+YYNeCAQMGwMbGBoMHDzZ0KFQOI7kUXZvZAQBiEu4ZNhgiIiJqUJhg14IJEyZg9erVhg6DKtHB3RoAEB1/17CBEBERUYPCBLsWBAUFwcLCwtBhUCXaN7EBAJxOzECRUmXgaIiIiKih0DnBzsrKQnh4ODw8PGBqaorAwEAcO3asxvvMnj0bEolE4+bk5KRreBXat28fQkND4eLiAolEgi1btmitt2TJEnh6esLExAT+/v7Yv3+/XuOg+qG5QyOYG8mQW6DEtbQcQ4dDREREDYTOCfa4ceMQFRWFNWvWIDY2FiEhIejTpw9u3rxZ433atGmD5ORk9S02NrbcNg8ePIjCwrIXCrlw4QJSUlK07pOTkwM/Pz8sWrSo3HbXr1+P8PBwzJw5E9HR0ejevTv69++P+Ph4dR1/f3/4+vqWuSUlJZXbLtU/MqkEbVyKr+x45maGgaMhIiKiBkPoIDc3V8hkMrF9+3aNcj8/PzFz5swa7TNr1izh5+dXpTiUSqXw8/MTgwcPFkVFReryixcvCicnJ7Fw4cJK2wAgNm/eXKa8S5cuIiwsTKOsdevWYvr06VWKrcSePXvEoEGDqlw/IyNDABAZGRk63Q/VzOytZ4THtO3i461nDR0KERER1XNVzdd0GsEuKiqCUqmEiYmJRrmpqSkOHDhQ430uX74MFxcXeHp6Yvjw4bh27ZrWNqVSKSIiIhAdHY3Ro0dDpVLh6tWr6N27N5577jlMnTpVl8NSKygowIkTJxASEqJRHhISgkOHDlWrzcosXrwYPj4+6Ny5c620TxXzLRnBTuIINhEREemHTgm2hYUFAgICMHfuXCQlJUGpVGLt2rU4cuQIkpOTa7TPE088gdWrVyMyMhI//vgjUlJSEBgYiPT0dK3turi4YPfu3Th48CBGjBiB3r17Izg4GEuXLtXlkDSkpaVBqVTC0dFRo9zR0bHcaSfa9O3bF0OGDEFERATc3NwqnKM+fvx4nDt3rtJ57FQ7fF2LE+xzSZlQqYSBoyEiIqKGQOc52GvWrIEQAq6urjA2Nsa3336LESNGQCaT1Wif/v37Y9CgQWjbti369OmDP//8EwCwatWqctt1d3fH6tWrsX79esjlcixfvhwSiUTXQyrj4TaEEDq1GxkZidu3byM3NxeJiYkcna7HvBqbw1guRXZ+EW7cyTV0OERERNQA6Jxge3l5Ye/evcjOzkZCQgKOHj2KwsJCeHp66nUfc3NztG3bFpcvXy63zq1bt/D6668jNDQUubm5mDRpkq6Ho8He3h4ymazMaHVqamqZUW1qGOQyKbydLQHwREciIiLSj2qvg21ubg5nZ2fcvXsXkZGReP755/W6T35+Ps6fPw9nZ2et29PS0hAcHAxvb29s2rQJu3fvxoYNG/Dee+9V95BgZGQEf39/REVFaZRHRUUhMDCw2u1S/ebr+iDB5jxsIiIi0gO5rjtERkZCCIFWrVrhypUrmDJlClq1aoVXXnkFALBo0SJs3rwZu3btqvI+APDee+8hNDQU7u7uSE1NxSeffILMzEyMGTOmTAwqlQr9+vWDh4eHenqIt7c3du7ciaCgILi6umodzc7OzsaVK1fUf8fFxSEmJga2trZwd3cHAEyePBmjRo1Cp06dEBAQgGXLliE+Ph5hYWG6dhU9Iny5VB8RERHpkc4JdkZGBmbMmIHExETY2tpi0KBBmDdvHhQKBYDikeWrV6/qtA8AJCYm4sUXX0RaWhoaN26Mrl274vDhw/Dw8CgTg1Qqxfz589G9e3cYGRmpy9u2bYudO3fCzs5Oa+zHjx9HUFCQ+u/JkycDAMaMGYOVK1cCAIYNG4b09HTMmTMHycnJ8PX1RUREhNY4qGEoOdExNjEDKpWAVFrzefxERET0+JIIIbh0Qj2QmZkJKysrZGRkwNLS0tDhPFYKlSq0m70D9wuViAzvgVZOvMw9ERERlVXVfK3ac7CJGgqFTIqOHtYAgKPX7xg2GCIiInrkMcEmAtC5qS0A4DgTbCIiIqohJthEALo8SLD/vZoOzpoiIiKimmCCTQSgo4cNTBUypGbl43xylqHDISIiokcYE2wiACYKGQK9ilef2XMx1cDREBER0aOMCTbRA71aNQYAHLySZuBIiIiI6FHGBJvogbZu1gCAq7ezDRsIERERPdKYYBM94GlnDgC4lZmP3IIiA0dDREREjyom2EQPWJkpYGNWfHXR62m5Bo6GiIiIHlVMsIlK8Xgwin09PcfAkRAREdGjigk2USme9sUJdlwaE2wiIiKqHibYRKU0LRnBZoJNRERE1cQEm6gUL4fiBPtSKlcSISIiouphgk1Uio+zJQDgQnImipQqA0dDREREjyIm2ESlNLUzh7mRDPlFKlzjNBEiIiKqBibYRKVIpRJ4PxjFPpuUAQAQQmDq76fw9Df7cTenwJDhERER0SOACTbRQ9q4FCfYZ25mAgA2nryJDccTcS45E6v+vW7AyIiIiOhRwASb6CEdPWwAAIeupgMAlu69qt625t8buF+gNEhcRERE9Ghggk30kG7N7QEA55MzcSElE1cerChiYSJHek4B/rf/miHDIyIionqOCTbRQ+wbGcPXtXiayJc7LgEAWjo2wrwBbQEA3++9itSsPAghDBYjERER1V9MsIm06OPtCACIOncLANC5qS1C2znDr4k1cguU6DJvF976+aQhQyQiIqJ6igk2kRZjn/SEg4Wx+u/erR0gkUjwwTPe6rK/zqTg0q0sQ4RHRERE9RgTbCItLE0UWDSiI/q2ccT/DWuP4Acj2p2b2mLNq11gZiQDAKw/lmDIMImIiKgeYoJNVI4unrb4YVQnvNDBVaO8e4vG+GZ4BwDA32dSDBEaERER1WNMsImqIdDLDnKpBDfv3UfCnVxDh0NERET1CBNsomowN5bDr4k1AODfa+mGDYaIiIjqFSbYRNXUtZktAODwVSbYRERE9B8m2ETVFNCs+II0/15L55rYREREpMYEm6ia/D1soJBJkJyRhxvpnIdNRERExZhgE1WTqZEMHZrYAAAOcx42ERERPcAEm6gGSuZhH+Q8bCIiInqACTZRDXRv2RgAcODybShVnIdNRERETLCJaqRDE2tYmMhxN7cQsTczDB0OERER1QNMsIlqQC6T4snmxauJ7L1428DREBERUX3ABLsWDBgwADY2Nhg8eLChQ6E60PPBNJG9l1LxVdQlBM7fxas7EhERPcaYYNeCCRMmYPXq1YYOg+pIz1bFCfbJ+Hv4dtdlJGXkYfW/1w0bFBERERkME+xaEBQUBAsLC0OHQXXE2coUrRw1H++rt3MMFA0REREZms4JdlZWFsLDw+Hh4QFTU1MEBgbi2LFjet1n/vz5kEgkCA8P1zW8Cu3btw+hoaFwcXGBRCLBli1btNZbsmQJPD09YWJiAn9/f+zfv1+vcVDD82w7Z42/j1+/AxVXFSEiInos6Zxgjxs3DlFRUVizZg1iY2MREhKCPn364ObNm3rZ59ixY1i2bBnatWtXYRwHDx5EYWFhmfILFy4gJSVF6z45OTnw8/PDokWLym13/fr1CA8Px8yZMxEdHY3u3bujf//+iI+PV9fx9/eHr69vmVtSUlKFMVPD9Xbv5tjwRgD+b1h7mCpkyMwrwsVbWYYOi4iIiAxB6CA3N1fIZDKxfft2jXI/Pz8xc+bMGu+TlZUlWrRoIaKiokTPnj3FxIkTtbapVCqFn5+fGDx4sCgqKlKXX7x4UTg5OYmFCxdWeiwAxObNm8uUd+nSRYSFhWmUtW7dWkyfPr3SNkvbs2ePGDRoUJXrZ2RkCAAiIyNDp/uh+mf4D/8Kj2nbxfqj8YYOhYiIiPSoqvmaTiPYRUVFUCqVMDEx0Sg3NTXFgQMHarzP+PHj8cwzz6BPnz4VxiGVShEREYHo6GiMHj0aKpUKV69eRe/evfHcc89h6tSpuhyWWkFBAU6cOIGQkBCN8pCQEBw6dKhabVZm8eLF8PHxQefOnWulfap7bd2sAABnkrguNhER0eNIpwTbwsICAQEBmDt3LpKSkqBUKrF27VocOXIEycnJNdpn3bp1OHnyJObPn1+lWFxcXLB7924cPHgQI0aMQO/evREcHIylS5fqckga0tLSoFQq4ejoqFHu6OhY7rQTbfr27YshQ4YgIiICbm5uFc43Hz9+PM6dO1fpPHZ6dLRxsQQAnOGFZ4iIiB5LOs/BXrNmDYQQcHV1hbGxMb799luMGDECMpms2vskJCRg4sSJWLt2bZmR7oq4u7tj9erVWL9+PeRyOZYvXw6JRKLrIZXxcBtCCJ3ajYyMxO3bt5Gbm4vExESOTj9mfF2LR7DPJWfy8ulERESPIZ0TbC8vL+zduxfZ2dlISEjA0aNHUVhYCE9Pz2rvc+LECaSmpsLf3x9yuRxyuRx79+7Ft99+C7lcDqVSqbXdW7du4fXXX0doaChyc3MxadIkXQ9Hg729PWQyWZnR6tTU1DKj2kTl8bQzh7mRDHmFKsSlZWtsO5eUibxC7c9nIiIiahiqvQ62ubk5nJ2dcffuXURGRuL555+v9j7BwcGIjY1FTEyM+tapUye89NJLiImJ0To6npaWhuDgYHh7e2PTpk3YvXs3NmzYgPfee6+6hwQjIyP4+/sjKipKozwqKgqBgYHVbpceL1KpBM0frIt96dZ/CfbyA3F4+tv9eH9TrEb9S7ey8Prq45i0PgZFSlWdxlqfqVQCu87fwtZTScjILbtiEBERUX0l13WHyMhICCHQqlUrXLlyBVOmTEGrVq3wyiuvAAAWLVqEzZs3Y9euXVXex8LCAr6+vhr3Y25uDjs7uzLlAKBSqdCvXz94eHiop4d4e3tj586dCAoKgqurq9bR7OzsbFy5ckX9d1xcHGJiYmBrawt3d3cAwOTJkzFq1Ch06tQJAQEBWLZsGeLj4xEWFqZrV9FjrKVDI5xKuIdLt7LwdFtnJNzJxdzt5wAAm6JvYtJTLdHE1gxCCLy66hgS7twHALz0hDs6NbXVSwwJd3Jx8Eoamjs00lubdSUrrxBvrj2JA1fSAAAyqQR9vB3wTu8W6ik4RERE9ZXOCXZGRgZmzJiBxMRE2NraYtCgQZg3bx4UCgWA4pHlq1ev6rSPrqRSKebPn4/u3bvDyMhIXd62bVvs3LkTdnZ2Wvc7fvw4goKC1H9PnjwZADBmzBisXLkSADBs2DCkp6djzpw5SE5Ohq+vLyIiIuDh4VGtWOnx1PLBCPblByPYf5/RnHa0/EAcZj/XBhdvZamTawA4fC1dL8mwSiUw5qejuJaWA4kE+POd7vB5cPJlfXcjPQfjfzmJMzczIZNK4GBhjOSMPESevYXIs7fQx9sR7/VtidZOj8bxEBHR40cihOBZWPVAZmYmrKyskJGRAUtLJg6Puj0XU/HKimNo4dAIUZN74rXVxxF17ha6t7DH/stpMFXIcGh6b/x+IhHzIs6r9+vW3A4/j+uqt/sv8dIT7pg3oG2l+/1zMRV/xCTB094cYT29YCSv9iwynZ1LysSyfVex7XQylCoBGzMF1rz6BHxdrXDpVhaW7LmCraeSoBKARAI87+eCSU+1hIedeZ3FSEREj7eq5mt19+lJ9BgpGcGOS8tBfpESx6/fAQCE92kJb2dL3C9UYvW/N7Drwi0AwItdmgAAjl+/i/yimp0EqVIJLN5dPBXKx7n4xf9HTBJy8osq3O9ebgHeWHMCm6Nv4quoS3h11TFkV7JPTQkhcOhKGkb/dBRPf7sfW2KSoFQJdG9hj+0Tuqung7R0tMD/De+AHZN64pm2zhAC2BKThOAv9+LLHRdr3GdERET6xASbqBa4WJnAvpERilQCa/69gbu5hTBRSNHW1QphPZsBAL7eeQmHr92BVAK81as57BsZIb9IhVMJVVs/+5cj8dgSfbNM+Xe7r+D4jbswM5Jh2Wh/eNqbIzu/CNtOJVXY3ubom8gvKj7J0lguxf7LaRj2w79IzczT8eirJi4tBy+vOIYR/zuCfZduQyoBQv1csP2dJ7Hm1Sfgam1aZp/mDo2w+KWO2P7Ok+jZsjGKVALf7b6Cvl/vw6pD15GVx5MhiYjI8JhgE9UCiUSCp3ycAACf/Fk8BSTQyx5GcimebecCr8b/TWt4ob0rmtia4YlmxecO/Hs1HUDx6O71tByta2mfuZmB9zfHInx9DNYdjVfX/2rHRXy98xIA4INnfOBmY6YeHf/lQT1thBD49cH2Oc+3wYY3AmBnboSzSZl4+tsD+CPmJlR6WNM7M68QG44nYNTyI+jz1V7svXQbRjIpRgd4YO+UIHz3YocqncTo62qFVWO74PuXOsK+kTGup+di1tazeOLTXZjy2yn8czEVhVyRhYiIDETnkxyJqGr6+zqpk1YAGB1QfKKsTCrBohEd8WnEeWTmFWHSUy0BAAHN7PDn6WQcvpaOiWiBv8+k4M2fT+KtXl6Y2q+1Rtu/n0hU/3v6plgcvX4Ht7Pysf9y8aobU/q2wognilfGGezfBF/suITTiRk4ceMO/D3KnkR5Mv4uLt3KholCiufbu8LKVIFNbwVi3KrjuJyajYnrYrA5+ia+e7EDLEx0Pzk54U4uvo66hO2xySgo+i/x7dmyMWaF+qBZ40Y6twkA/ds648kW9th08ibWHL6BK6nZ+O1EIn47kQhPe3PM6N8aT/k46uUCVPR4E0Igv0iFnPwiZD+45RUqcb9AhfuFSuQVKpFfpEKRUoVClUCRUoUipUChqvj/RUoVikp9SX346+rDZ0OJh2oopFKYGslgqpDB1EgGMyMZTBTF/y/5t5FMiiKVgFIl1P8v/rcKKhWgEuK/m/rv0uVlj/vhV87DLyXJQzXKbi9vm0RruWZ9STnl5fwb2huSqOtWob0qxKVVJRUe7qcy2yvdv5LtVXiPq/l9VHoPtXz/5ddwsDCGi5ZfPQ2JJznWEzzJseEpVKowfNlhnLhxF+3crLDlrW6QSst/g7h6OxvBX+6FkVyKUx+F4Nnv9uPq7RwAwJV5/SGXFf/gpFQJdPokCndzC+HV2FxdBwDkUgk+fNYHYwKbarQ9feNprDuWgL5tHPHDqE5l7vvdDaew8WQiBvu74YshfuryvEIllu27hiX/XEFeoQpdPG2xemwXmCjKv3Lrw33w7a7L+GHvNRQ8GFFu4dAIz7d3wbPtXNDUXn8nKAohcDTuDradTsKfp5Nx98Ha2c5WJujZsjH8PWzQwd0GzezNK3wcqH5QqQTu5BYgJSMPyRl5SM64j+SMPNzJLoBEUvxhK5UA0gf/L/67+N8yqQQSiQQSSXHiKiDw4D+IB4mkUiWQmVeIuzkFuJNTgMy8IihVQp3YClFyE7hfqER2fhEKlfy4JKqPtA1E1Zaq5mscwSaqJQqZFBvfDMTtrHxYmMgrTeqa2ZvD1doUN+/dx+G4dMhK1T94NR09WzYGAJxPzsTd3EJYGMsRGd4DB6+mY8fZFFibKTCwoxu8tIwGj+vuiXXHErDj3C3EpeXAs1Rim3G/EH/GFs/PfrGLu8Z+JgoZJgS3QM+WjTHyf0dwNO4OwtfFYPFLHTXi0ybhTi4mrItGdPw9AMCTze3xXt9W8HOzqpURZYlEgiea2eGJZnaY1q81lu69iuUH4pCckYd1xxKw7lgCAMC+kREGdXTD8C7uGv1AdadIqULC3ftIzcxDWnYBUrPy1Il0SkYekjPv41ZGvvpLWX1jbiSDmbEcZg9GlE0UMpgopDCSy2Akk0AulUIuk0Ahk0IulUAuk0IhkxQn/uWMkAIVj+AVKotHyu8XqnC/oAj3C5XILVDifoGyuLxAiUKlCvIH9ymVSCB/cJ8ySfH/pRIJpNLiLyWlv6DIHnwZkUjKjrQ+PJIOlB1tL66nhSj9z1Kj90JrFZQe79MsL+d+qlRflC2rwv2Xczfat2s/eh32r2R7JQ1U6WufgWOo7T60Mq3ess+1iQk2US1rbGFcpXoSiQQ9WjbGr0fjseNsCq6VGpn+KzZZnWCXrEjS0cMGcpkUPVs2Vm8rT3MHC/Ru7YDdF1Kx/MA1fPLCf0v2/RFzE3mFKrRytEBHd2ut+/s1scYPo/3x8k/H8PfZFMyPOI8PnvUp9/62n07CjI2xyMovgoWJHPMHtsWz7Vyq1A/6YGGiwJS+rfFO7xY4fC0dh66mIyb+Hk7fvIe07AL8sO8afth3DYFedhjZ1QNP+ThCIeMpKbUlOeM+jl+/ixM37iI6/i4upGSpT6itiEQCNG5kDGcrEzhbmcLpwcnDEokEKtWDkWghHoxK/zfdQTwYoVYJAQkeJI8P2pNK/xvptjBRwNbMCDbmRrAyVaD4KSBRJ74liaepQgZzYzkamchhbiSv9MslERETbKJ6pOeDBPvXowka5bsvpEIIAYlEgmM37gIAOje10ant17o3w+4Lqfj9RCImP9UKtuZGyC8qngICAMO7NKlwZDnQyx5fDvXDO79G438H4pBTUIQ3ezaHu52Zuk7G/ULMjzivHi3297DBN8Pbw83GrLxma5WJQoZerRzQq5UDgOJRwH8u3sYvR27gn0u3cehqcfLtYGGMF7u44ykfR7R2slBPx6HKFRSpkJadj3u5hbh3vwCZ9wuRll2AG+k5iEvLxbmkDCRllF2JxkQhhbOVKewbGcG+kTGcrUzhbGUCJyuT4oTa2hQOFsb84kNEjyQm2ET1SK9WjdHE1lR9dcfuLexx4sZdpGbl42xSJlo7WeBoXPEItq5XfOzazBZtXa0QezMDqw5dx6SnWmLlwetIvHsfDhbGGNa5SaVthPq54Oa9+1jw1wX8ejQBvx5NQAd3a/i6WCE7vwg7z99CVl4RJBJgfK/mCO/Tol4lqwqZFE/5OOIpH0ck3s3FuqMJWHcsHqlZ+fhm12V8s+syTBUytHOzQkcPG7R2soC5kRz37hfi0q0snEvKxN3cAuQXqdRfeID/RkdLfl6XSAC5TKKePmAsL55CIJdKIH3wk70A1D/tSwD1CWzmxnI0tjCGq7UpXG1M4WJtCkcLY639WHLinbFcqrdpN1l5hUi4cx/xd3IQfycXSffykJlXiOy8IuQUFCE7X4mc/CL1yX5ZeZWvlS6TSuDtbIFOHrbo6GGDdq5WcLc141x4ImqweJJjPcGTHKnEwStpeGXFMbjZmuJ/ozth/l8XEHXuFt7o0Qwd3G0QtvYEbMwU+HdGcJVPNiyx9VQSJvwaDYVMglA/F/zx4MIuCwa2xfCH5l9X5NCVNCzddw37L98uMzeupWMjzH6uDQK97HWKzVAKilT4+2wKNp5IxMn4u1VKGOuaTCqBk6UJGhnLkVtYhPsFD+bfFiohBKCQSWBtZgRbMyNYmylgbixH4YNVLIpUKhQ++H+RUsDCRA4bMyPYmhdPjZBKgIQ793HjTi4S7uTiTk6BzvHJpcX3b2Uqh5WpArbmRnC3NUdTezM0d2gEPzdrmBtzPIeIHn1VzdeYYNcTTLCptPTsfFiZKiCXSRF17hZeW30cAGBtpsC93MJqnzGtUgm89fNJ/H02RV02sIMrvhzqV60R0KR793HwShri7+TCSCaFf1MbPOFp98jOUVWpBK7ezsbJ+Ls4eeMerqfnIK9IBVOFFK0cLeDtbAknKxMYy2VlVqgA/jvRRwigUKVCXoESeUVK5BWqcL9ACZX4bwk1iQQwe7DkmhBQn7SWk1+EW5n5uHmvePQ4OeN+na9eYWtuhCa2ZvCwNYObjSmsTIuT9kbGcpgby2FuLFP/29aseP4yR6OJ6HHABPsRwwSbyqNSCfT5eq/6pEcLEzmiJvWEk5VJtdrLLSjCsn3XcOZmBnq0bIwRXdzr1TQO0qRSCdzOzkfi3fu4X6CEmfGDtY8VcpgayWCskCI7rwh3cgpwL7cQd3ILkFeghFz2YPWKB6tYyGXFU1Oy8opwN7egeHm63AIUKQWa2JrC3dYMTWzN4G5rVq21zomIHgdMsB8xTLCpImduZuCDLWeQnHEfi0d01Hn+NREREdUc18EmakB8Xa2wZXw3Q4dBREREVcDfhYmIiIiI9IgJNhERERGRHjHBJiIiIiLSIybYRERERER6xASbiIiIiEiPmGATEREREekRE2wiIiIiIj1igk1EREREpEdMsImIiIiI9IgJNhERERGRHjHBJiIiIiLSI7mhA6BiQggAQGZmpoEjISIiIiJtSvK0krytPEyw64msrCwAQJMmTQwcCRERERFVJCsrC1ZWVuVul4jKUnCqEyqVCklJSbCwsIBEIqn1+8vMzESTJk2QkJAAS0vLWr+/xx37u26xv+sW+7tusb/rFvu7btX3/hZCICsrCy4uLpBKy59pzRHsekIqlcLNza3O79fS0rJePoEbKvZ33WJ/1y32d91if9ct9nfdqs/9XdHIdQme5EhEREREpEdMsImIiIiI9IgJ9mPK2NgYs2bNgrGxsaFDeSywv+sW+7tusb/rFvu7brG/61ZD6W+e5EhEREREpEccwSYiIiIi0iMm2EREREREesQEm4iIiIhIj5hgExERERHpERPsx9CSJUvg6ekJExMT+Pv7Y//+/YYO6ZG0b98+hIaGwsXFBRKJBFu2bNHYLoTA7Nmz4eLiAlNTU/Tq1Qtnz57VqJOfn4933nkH9vb2MDc3x3PPPYfExMQ6PIpHw/z589G5c2dYWFjAwcEBL7zwAi5evKhRh/2tP99//z3atWunvtBDQEAA/vrrL/V29nXtmj9/PiQSCcLDw9Vl7HP9mT17NiQSicbNyclJvZ19rX83b97EyJEjYWdnBzMzM7Rv3x4nTpxQb2+QfS7osbJu3TqhUCjEjz/+KM6dOycmTpwozM3NxY0bNwwd2iMnIiJCzJw5U2zcuFEAEJs3b9bYvmDBAmFhYSE2btwoYmNjxbBhw4Szs7PIzMxU1wkLCxOurq4iKipKnDx5UgQFBQk/Pz9RVFRUx0dTv/Xt21esWLFCnDlzRsTExIhnnnlGuLu7i+zsbHUd9rf+bN26Vfz555/i4sWL4uLFi+L9998XCoVCnDlzRgjBvq5NR48eFU2bNhXt2rUTEydOVJezKuNjLAAABeVJREFUz/Vn1qxZok2bNiI5OVl9S01NVW9nX+vXnTt3hIeHh3j55ZfFkSNHRFxcnNi5c6e4cuWKuk5D7HMm2I+ZLl26iLCwMI2y1q1bi+nTpxsooobh4QRbpVIJJycnsWDBAnVZXl6esLKyEkuXLhVCCHHv3j2hUCjEunXr1HVu3rwppFKp+Pvvv+ss9kdRamqqACD27t0rhGB/1wUbGxvxv//9j31di7KyskSLFi1EVFSU6NmzpzrBZp/r16xZs4Sfn5/Wbexr/Zs2bZp48skny93eUPucU0QeIwUFBThx4gRCQkI0ykNCQnDo0CEDRdUwxcXFISUlRaOvjY2N0bNnT3VfnzhxAoWFhRp1XFxc4Ovry8ejEhkZGQAAW1tbAOzv2qRUKrFu3Trk5OQgICCAfV2Lxo8fj2eeeQZ9+vTRKGef69/ly5fh4uICT09PDB8+HNeuXQPAvq4NW7duRadOnTBkyBA4ODigQ4cO+PHHH9XbG2qfM8F+jKSlpUGpVMLR0VGj3NHRESkpKQaKqmEq6c+K+jolJQVGRkawsbEptw6VJYTA5MmT8eSTT8LX1xcA+7s2xMbGolGjRjA2NkZYWBg2b94MHx8f9nUtWbduHU6ePIn58+eX2cY+168nnngCq1evRmRkJH788UekpKQgMDAQ6enp7OtacO3aNXz//fdo0aIFIiMjERYWhgkTJmD16tUAGu7zW27oAKjuSSQSjb+FEGXKSD+q09d8PCr29ttv4/Tp0zhw4ECZbexv/WnVqhViYmJw7949bNy4EWPGjMHevXvV29nX+pOQkICJEydix44dMDExKbce+1w/+vfvr/5327ZtERAQAC8vL6xatQpdu3YFwL7WJ5VKhU6dOuHTTz8FAHTo0AFnz57F999/j9GjR6vrNbQ+5wj2Y8Te3h4ymazMt73U1NQy3xypZkrOSK+or52cnFBQUIC7d++WW4c0vfPOO9i6dSv27NkDNzc3dTn7W/+MjIzQvHlzdOrUCfPnz4efnx+++eYb9nUtOHHiBFJTU+Hv7w+5XA65XI69e/fi22+/hVwuV/cZ+7x2mJubo23btrh8+TKf37XA2dkZPj4+GmXe3t6Ij48H0HDfv5lgP0aMjIzg7++PqKgojfKoqCgEBgYaKKqGydPTE05OThp9XVBQgL1796r72t/fHwqFQqNOcnIyzpw5w8fjIUIIvP3229i0aRN2794NT09Pje3s79onhEB+fj77uhYEBwcjNjYWMTEx6lunTp3w0ksvISYmBs2aNWOf16L8/HycP38ezs7OfH7Xgm7dupVZVvXSpUvw8PAA0IDfv+v+vEoypJJl+pYvXy7OnTsnwsPDhbm5ubh+/bqhQ3vkZGVliejoaBEdHS0AiK+++kpER0erlzxcsGCBsLKyEps2bRKxsbHixRdf1LrskJubm9i5c6c4efKk6N27d71edshQ3nzzTWFlZSX++ecfjaW1cnNz1XXY3/ozY8YMsW/fPhEXFydOnz4t3n//fSGVSsWOHTuEEOzrulB6FREh2Of69O6774p//vlHXLt2TRw+fFg8++yzwsLCQv05yL7Wr6NHjwq5XC7mzZsnLl++LH7++WdhZmYm1q5dq67TEPucCfZjaPHixcLDw0MYGRmJjh07qpc6I93s2bNHAChzGzNmjBCieOmhWbNmCScnJ2FsbCx69OghYmNjNdq4f/++ePvtt4Wtra0wNTUVzz77rIiPjzfA0dRv2voZgFixYoW6Dvtbf8aOHat+j2jcuLEIDg5WJ9dCsK/rwsMJNvtcf0rWWFYoFMLFxUUMHDhQnD17Vr2dfa1/27ZtE76+vsLY2Fi0bt1aLFu2TGN7Q+xziRBCGGbsnIiIiIio4eEcbCIiIiIiPWKCTURERESkR0ywiYiIiIj0iAk2EREREZEeMcEmIiIiItIjJthERERERHrEBJuIiIiISI+YYBMRERER6RETbCIiIiIiPWKCTURERESkR0ywiYiIiIj0iAk2EREREZEe/T8pR3NBdsuW7wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "H = separated_hessian(xy)\n", + "grad = separated_grad(xy)\n", + "steps = np.logspace(-10,0,100)\n", + "\n", + "residualnorms = []\n", + "# len_direction = []\n", + "best_losses = []\n", + "# unit_step_losses = []\n", + "def get_best_loss_direction(xy, direction):\n", + " return np.min([separated_loss(xy + step * direction) for step in steps])\n", + "\n", + "def get_next_point(xy, direction):\n", + " which = np.argmin([separated_loss(xy + step * direction) for step in steps])\n", + " return xy + (steps[which]) * direction\n", + "\n", + "EXPONENT = .5\n", + "\n", + "for i in range(1, 1000):\n", + " cg_solution = sp.sparse.linalg.cg(H, -grad, atol=0., rtol=0., maxiter=i)[0]\n", + " residualnorms.append(np.linalg.norm(H @ cg_solution + grad))\n", + " # len_direction.append(np.linalg.norm(cg_solution))\n", + " best_losses.append(get_best_loss_direction(xy, cg_solution))\n", + " if np.linalg.norm(H @ cg_solution + grad) < (np.linalg.norm(grad)**(1+EXPONENT)):\n", + " break\n", + " # unit_step_losses.append(separated_loss(xy + cg_solution))\n", + "\n", + "fig, axes = plt.subplots(2, figsize=(8,9))\n", + "\n", + "plt.sca(axes[0])\n", + "plt.plot(np.array(residualnorms)/np.linalg.norm(grad), label='||r||/||g||')\n", + "plt.plot(np.array(residualnorms)/(np.linalg.norm(grad)**(1+EXPONENT)), label=f'||r||*||g||^-({1+EXPONENT})')\n", + "# plt.plot(np.array(residualnorms)/(np.linalg.norm(grad)**1.3), label='||r||*||g||^-1.3')\n", + "# plt.plot(np.array(residualnorms)/(np.linalg.norm(grad)**1.5), label='||r||*||g||^-1.5')\n", + "plt.hlines(1, xmin=0, xmax=len(residualnorms), label='one')\n", + "plt.yscale('log')\n", + "plt.legend()\n", + "plt.title('CG RESIDUAL BY N CG ITERS')\n", + "\n", + "# plt.figure()\n", + "# plt.plot(np.array(len_direction) / np.linalg.norm(grad))\n", + "# plt.title('LENGHT OF THE DIRECTION DIV BY GRAD LEN')\n", + "\n", + "plt.sca(axes[1])\n", + "plt.plot((best_losses) / separated_loss(xy), label='BEST NEXT LOSS GAIN')\n", + "plt.yscale('log')\n", + "plt.legend()\n", + "plt.title(\"BEST NEXT LOSS ASSUMING GOOD LINE SEARCH DIVIDED BY CURRENT\")\n", + "\n", + "# plt.figure()\n", + "# plt.plot(unit_step_losses)\n", + "# plt.title(\"UNIT STEP NEXT LOSS\")\n", + "\n", + "xy = get_next_point(xy, cg_solution)\n", + "print(separated_loss(xy))" + ] + }, + { + "cell_type": "markdown", + "id": "9e8bb8f4", + "metadata": {}, + "source": [ + "# Line search research " + ] + }, + { + "cell_type": "code", + "execution_count": 343, + "id": "d84bed00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0004052682826740908 -4.066879161035486e-07 2.0408981730941382e-07\n", + "0.0005017514736412268\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "current_point = xy\n", + "current_loss = separated_loss(xy)\n", + "current_direction = cg_solution\n", + "current_gradient = separated_grad(xy)\n", + "assert current_direction @ current_gradient < 0\n", + "\n", + "losses_on_line = [separated_loss(current_point + cg_solution * step) for step in steps]\n", + "plt.plot(steps, losses_on_line)\n", + "\n", + "test_step_len = 1\n", + "loss_test_step = separated_loss(current_point + current_direction*test_step_len)\n", + "\n", + "current_loss, loss_step_1\n", + "\n", + "c = current_loss\n", + "b = current_direction @ current_gradient\n", + "# a * (1**2) + b * 1 + c = loss_step_1\n", + "def get_a(loss_at_step, step_len):\n", + " return (loss_at_step - c - b * step_len)/(step_len**2)\n", + "\n", + "a = get_a(loss_test_step, test_step_len)\n", + "\n", + "vertex = -b / (2 * a)\n", + "\n", + "print(a, b, c)\n", + "quad_approx = lambda x: a * x**2 + b * x + c\n", + "plt.plot(steps, [quad_approx(x) for x in steps])\n", + "plt.yscale('log')\n", + "\n", + "print(vertex)" + ] + }, + { + "cell_type": "code", + "execution_count": 349, + "id": "c775b1f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 -7.527354584959345e-05\n", + "2.0408981730941382e-07 2.0167405033450724e-07\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def fit_cubspline(x_left, loss_left, grad_left, x_right, loss_right, grad_right):\n", + " # a * x^3 + b * x^2 + c * x + d\n", + " assert grad_left < 0\n", + " assert grad_right > 0\n", + " assert x_left < x_right\n", + " matrix = [\n", + " [x_left**3, x_left**2, x_left, 1.],\n", + " [x_right**3, x_right**2, x_right, 1.],\n", + " [3 * x_left**2, 2 * x_left, 1., 0.],\n", + " [3 * x_right**2, 2 * x_right, 1., 0.],\n", + " ]\n", + " rhs = [loss_left, loss_right, grad_left, grad_right]\n", + " return np.linalg.solve(matrix, rhs)\n", + "\n", + "current_point = xy\n", + "current_loss = separated_loss(xy)\n", + "current_direction = cg_solution\n", + "current_gradient = separated_grad(xy)\n", + "\n", + "\n", + "LEFT_STEP = 0\n", + "left_point = xy + current_direction * LEFT_STEP\n", + "left_loss = separated_loss(left_point)\n", + "left_grad = separated_grad(left_point)\n", + "\n", + "RIGHT_STEP = 0.01187731700475939\n", + "right_point = xy + current_direction * RIGHT_STEP\n", + "right_loss = separated_loss(right_point)\n", + "right_grad = separated_grad(right_point)\n", + "\n", + "\n", + "\n", + "a,b,c,d = fit_cubspline(x_left=LEFT_STEP, loss_left=left_loss, grad_left=current_direction@left_grad,\n", + " x_right=RIGHT_STEP, loss_right=right_loss, grad_right=current_direction@right_grad)\n", + "\n", + "my_spline = lambda x: a * x**3 + b * x**2 + c * x + d\n", + "\n", + "xs = np.linspace(0,1)\n", + "plt.plot(steps, losses_on_line)\n", + "plt.plot(xs, [my_spline(x) for x in xs])\n", + "# plt.yscale('log')\n", + "\n", + "print((current_direction@left_grad) / (current_direction@current_gradient),\n", + " (current_direction@right_grad) / (current_direction@current_gradient))\n", + "print(left_loss, right_loss)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 347, + "id": "a66067ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.01187731700475939, -52.433477785125454)" + ] + }, + "execution_count": 347, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def get_roots_spline(a,b,c,d):\n", + " # 3 * a * x^2 + 2 * b * x + c == 0 \n", + " tmp = np.sqrt((2*b)**2 - 4 * (3 * a * c))\n", + " # x = (-b ± √ (b2 - 4ac) )/2a\n", + " return (- 2 * b + tmp)/(6*a), (- 2 * b - tmp)/(6*a)\n", + "\n", + "get_roots_spline(a,b,c,d) " + ] + }, + { + "cell_type": "code", + "execution_count": 372, + "id": "6e11c200", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0003117785215677139\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x, y = xy[:n], xy[n:]\n", + "s = b_transf - matrix_transf @ x\n", + "\n", + "plt.plot(x, label='x')\n", + "plt.figure()\n", + "plt.plot(y, label='y', alpha=.5)\n", + "plt.plot(s, label='s', alpha=.5)\n", + "print(y.T @ s)" + ] + }, + { + "cell_type": "markdown", + "id": "46f66f47", + "metadata": {}, + "source": [ + "# MINI NEWTON_CG " + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "14f9942c", + "metadata": {}, + "outputs": [], + "source": [ + "def line_search(xy, direction): # can be made much smarter, I understand enough dcsrch now\n", + " current_loss = separated_loss(xy)\n", + " for i in range(100):\n", + " proposed = xy + direction * 0.5**i\n", + " if separated_loss(proposed) < current_loss:\n", + " break\n", + " return proposed" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "50aba4e8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FINAL LOSS: 5.013207684135979e-08\n", + "FINAL LOSS: 2.2336614022752972e-08\n", + "FINAL LOSS: 7.103871419007735e-09\n", + "FINAL LOSS: 2.2960431230258557e-09\n", + "FINAL LOSS: 4.934056476386888e-10\n", + "FINAL LOSS: 5.522459784737324e-10\n", + "FINAL LOSS: 1.2209644570790878e-09\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for CG_ITERS in [2,5,10,20,50,100,200]:\n", + " \n", + " np.random.seed(0)\n", + " xy = np.random.randn(n+m)\n", + "\n", + " losses = []\n", + "\n", + " for i in range(100000//CG_ITERS):\n", + " current_loss = separated_loss(xy)\n", + " losses.append(current_loss)\n", + " current_grad = separated_grad(xy)\n", + " direction = sp.sparse.linalg.cg(\n", + " separated_hessian(xy), -current_grad, atol=0., rtol=0., maxiter=CG_ITERS)[0]\n", + " xy = line_search(xy, direction)\n", + "\n", + " plt.plot(np.arange(len(losses)) * CG_ITERS, losses, label=f'CG_ITERS = {CG_ITERS}')\n", + " print('FINAL LOSS:', losses[-1])\n", + "plt.legend()\n", + "plt.yscale('log')\n", + "plt.show()\n", + " # print('FINAL LOSS:', losses[-1])\n" + ] + }, + { + "cell_type": "markdown", + "id": "2b76b68d", + "metadata": {}, + "source": [ + "# USING SOME TERMINATION RULE " + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "dfe4c076", + "metadata": {}, + "outputs": [], + "source": [ + "def run_with_term_rule(xy, MAXHESSIAN, cg_termination_rule):\n", + " \n", + " losses = [separated_loss(xy)]\n", + " cg_used_iters = [0]\n", + " USED_ITERS = 0\n", + " \n", + " for i in range(1000):\n", + " if USED_ITERS > MAXHESSIAN:\n", + " break\n", + " def iter_counter(_):\n", + " nonlocal USED_ITERS\n", + " USED_ITERS += 1\n", + " direction = sp.sparse.linalg.cg(\n", + " separated_hessian(xy), -separated_grad(xy), **cg_termination_rule(xy),\n", + " callback=iter_counter)[0]\n", + "\n", + " xy = line_search(xy, direction)\n", + " \n", + " losses.append(separated_loss(xy))\n", + " cg_used_iters.append(int(USED_ITERS))\n", + " if losses[-1] < 1e-25:\n", + " break\n", + " \n", + " \n", + " plt.plot(cg_used_iters, losses)\n", + " print('FINAL LOSS:', losses[-1])\n", + " plt.yscale('log')\n", + " return xy\n" + ] + }, + { + "cell_type": "markdown", + "id": "6ef93ef0", + "metadata": {}, + "source": [ + "# FIX SEED " + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "2eed485c", + "metadata": {}, + "outputs": [], + "source": [ + "SEED = 0\n", + "MAXITERS = 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "52691a96", + "metadata": {}, + "outputs": [], + "source": [ + "# np.random.seed(SEED)\n", + "# xy = np.random.randn(n+m)\n", + "\n", + "# solution = run_with_term_rule(\n", + "# xy, MAXHESSIAN=MAXITERS,\n", + "# cg_termination_rule= lambda x: {'maxiter':200})" + ] + }, + { + "cell_type": "markdown", + "id": "260df638", + "metadata": {}, + "source": [ + "### Nocedal " + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "ac59d535", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FINAL LOSS: 7.246752968237809e-26\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(SEED) # this was run with 1000 Ruiz iters\n", + "xy = np.random.randn(n+m)\n", + "\n", + "solution = run_with_term_rule(\n", + " xy, MAXHESSIAN=MAXITERS,\n", + " cg_termination_rule=lambda xy: {'rtol':min(0.5, np.linalg.norm(separated_grad(xy)) ** 0.5)})" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "39643cce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FINAL LOSS: 5.624313078551257e-30\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(SEED) # this was run with 100 Ruiz iters\n", + "xy = np.random.randn(n+m)\n", + "\n", + "solution = run_with_term_rule(\n", + " xy, MAXHESSIAN=MAXITERS,\n", + " cg_termination_rule=lambda xy: {'rtol':min(0.5, np.linalg.norm(separated_grad(xy)) ** 0.5)})" + ] + }, + { + "cell_type": "markdown", + "id": "df36dd23", + "metadata": {}, + "source": [ + "### With different powers" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "4fa96702", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FINAL LOSS: 9.964404118963978e-26\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(SEED)\n", + "xy = np.random.randn(n+m)\n", + "\n", + "solution = run_with_term_rule(\n", + " xy, MAXHESSIAN=MAXITERS,\n", + " cg_termination_rule=lambda xy: {'rtol':min(0.5, np.linalg.norm(separated_grad(xy)) ** 0.25)})" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "b66c3c07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FINAL LOSS: 1.2870836166383337e-29\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(SEED)\n", + "xy = np.random.randn(n+m)\n", + "\n", + "solution = run_with_term_rule(\n", + " xy, MAXHESSIAN=MAXITERS,\n", + " cg_termination_rule=lambda xy: {'rtol':min(0.5, np.linalg.norm(separated_grad(xy)) ** 0.75)})" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "72401742", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FINAL LOSS: 7.334390622227785e-26\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGdCAYAAADqsoKGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7Y0lEQVR4nO3df3xU5Z3//feZmczkB0lICARCAsQf9VcgSKAWFCTqQlOlBau1XZfSrWyXulQpve9+Rb73bcveu3G1X2t3KbTqKrVdK7YKX7tfWoytEBSqEogGQRQNhB8JIYFkkkBmkpnr/iPJQEyA/BhyJpPX8/GYRzLnXDnnM6fWeXud61yXZYwxAgAAGOQcdhcAAAAQDoQaAAAQFQg1AAAgKhBqAABAVCDUAACAqECoAQAAUYFQAwAAogKhBgAARAWX3QUMlGAwqGPHjikxMVGWZdldDgAA6AFjjBoaGpSRkSGH48J9MUMm1Bw7dkxZWVl2lwEAAPrg8OHDyszMvGCbIRNqEhMTJbVdlKSkJJurAQAAPeH1epWVlRX6Hr+QIRNqOm45JSUlEWoAABhkejJ0hIHCAAAgKhBqAABAVCDUAACAqECoAQAAUYFQAwAAogKhBgAARAVCDQAAiAqEGgAAEBUINQAAICoQagAAQFQg1AAAgKhAqAEAAFFhyCxoeamcbPLr3//8sdwuhx7+0jV2lwMAwJBFT00/NTa3at32g/rNXw/ZXQoAAEMaoSZMjLG7AgAAhjZCTT9Zlt0VAAAAiVADAACiBKEmTIy4/wQAgJ0INQAAICoQasKEgcIAANiLUNNPDBQGACAyEGrChI4aAADsRajpJ4uuGgAAIgKhJlzoqgEAwFaEmn6inwYAgMhAqAEAAFGBUNNPHUNqmHwPAAB7EWoAAEBUINSECZPvAQBgL0JNP1kMFQYAICIQasKEjhoAAOxFqOkn5t4DACAyEGoAAEBUINT0U0dHjWGkMAAAthp0oWbBggVKSUnRXXfdZXcpAAAgggy6UPPAAw/o+eeft7uMs0KT7wEAADsNulCTn5+vxMREu8sAAAARZkBDTXFxsebNm6eMjAxZlqWNGzd2abNmzRplZ2crNjZWeXl52rZt20CW2Gsd89QwpAYAAHsNaKhpampSbm6uVq9e3e3+9evXa9myZVq5cqV2796tmTNnqqCgQBUVFQNZJgAAGIRcA3mygoICFRQUnHf/E088ofvuu0+LFy+WJD355JPavHmz1q5dq8LCwl6dy+fzyefzhd57vd6+FQ0AAAaFiBlT4/f7VVJSojlz5nTaPmfOHG3fvr3XxyssLFRycnLolZWVFa5SO2HyPQAAIkPEhJqamhoFAgGlp6d32p6enq6qqqrQ+7lz5+ruu+/Wpk2blJmZqXfffbfb461YsUL19fWh1+HDhy9p/QAAwF4DevupJ6zPdH0YYzpt27x5c4+O4/F45PF4wlpbd86t9rO1AgCAgRMxPTVpaWlyOp2demUkqbq6ukvvDQAAwGdFTKhxu93Ky8tTUVFRp+1FRUWaMWOGTVVd3Lk9MzzWDQCAfQb09lNjY6MOHDgQel9eXq7S0lKlpqZq3LhxWr58uRYuXKipU6dq+vTpeuqpp1RRUaElS5YMZJkAAGAQGtBQs3PnTuXn54feL1++XJK0aNEirVu3Tvfcc49qa2u1atUqVVZWKicnR5s2bdL48eMHssxe6TSmxrYqAADAgIaa2bNnX3Q16/vvv1/333//AFUEAACiRcSMqQEAAOgPQk0/nfsE98V6oQAAwKVDqAEAAFGBUNNP1jlDhemnAQDAPoQaAAAQFQg1/dVpTI19ZQAAMNQRagAAQFQg1PQT61cCABAZCDVhZBgqDACAbQg1/URHDQAAkYFQE0YMFAYAwD6EGgAAEBUINf1kMVIYAICIQKgBAABRgVDTT/TTAAAQGQg1YcRAYQAA7EOo6SeG1AAAEBkINWHE5HsAANiHUNNPFqNqAACICISaMGJMDQAA9iHUAACAqECo6ScGCgMAEBkINWHE3ScAAOxDqAEAAFGBUBNGhpHCAADYhlDTT4ypAQAgMhBqwoh+GgAA7EOo6Scm3wMAIDIQasKIITUAANiHUNNPMU5LTkdbb80Zf8DmagAAGLoINf1kWWdDTYCuGgAAbEOoCYP2TKNgkFADAIBdCDVh4Gx/rpuOGgAA7DNoQk1DQ4OmTZumyZMna+LEiXr66aftLinEYXH7CQAAu7nsLqCn4uPjtXXrVsXHx+v06dPKycnRnXfeqREjRthdWmgCviChBgAA2wyanhqn06n4+HhJUnNzswKBQMQsS9AxUDhS6gEAYCgKW6gpLi7WvHnzlJGRIcuytHHjxi5t1qxZo+zsbMXGxiovL0/btm3r1Tnq6uqUm5urzMxM/fCHP1RaWlqYqu+f0O2noM2FAAAwhIUt1DQ1NSk3N1erV6/udv/69eu1bNkyrVy5Urt379bMmTNVUFCgioqKUJu8vDzl5OR0eR07dkySNHz4cL333nsqLy/XCy+8oOPHj4er/H5xtPfUcPsJAAD7hG1MTUFBgQoKCs67/4knntB9992nxYsXS5KefPJJbd68WWvXrlVhYaEkqaSkpEfnSk9P16RJk1RcXKy777672zY+n08+ny/03uv19vSj9JqDMTUAANhuQMbU+P1+lZSUaM6cOZ22z5kzR9u3b+/RMY4fPx4KJl6vV8XFxbrqqqvO276wsFDJycmhV1ZWVt8/wEV03H4KcvsJAADbDEioqampUSAQUHp6eqft6enpqqqq6tExjhw5olmzZik3N1c33XSTli5dqkmTJp23/YoVK1RfXx96HT58uF+f4UJCoYaeGgAAbDOgj3RbVucVrY0xXbadT15enkpLS3t8Lo/HI4/H05vy+szRHg2ZpwYAAPsMSE9NWlqanE5nl16Z6urqLr03g5HD4pFuAADsNiChxu12Ky8vT0VFRZ22FxUVacaMGQNRwiXlDN1+srkQAACGsLDdfmpsbNSBAwdC78vLy1VaWqrU1FSNGzdOy5cv18KFCzV16lRNnz5dTz31lCoqKrRkyZJwlWCbjjtoAVINAAC2CVuo2blzp/Lz80Pvly9fLklatGiR1q1bp3vuuUe1tbVatWqVKisrlZOTo02bNmn8+PHhKsE2rvZBNazSDQCAfcIWambPnn3RMSX333+/7r///nCdMmJ0LJPQSqgBAMA2g2btp0jmcnYsk0CoAQDALoSaMKCnBgAA+xFqwsDl6OipYUphAADsQqgJA3pqAACwH6EmDDqefmJMDQAA9iHUhEFHT01Dc6vNlQAAMHQRasIgpv3pp8r6MzZXAgDA0EWoCYPczOGSpIO1p+0tBACAIYxQEwaTxw2XJJVW1NlaBwAAQxmhJgyuHp0kSTpad0atAR7rBgDADoSaMHC7zl7GwEWWigAAAJcGoSYMOp5+kiTm3wMAwB6EmjBwWmdDzYkGn42VAAAwdBFqwiA2xqGM5FhJ0g9+V6ogk/ABADDgCDVhYFmWfvaN6+WwpHcPntJv362wuyQAAIYcQk2YTJuQqu/OvlyS9ONX9+rDKq/NFQEAMLQQasLoB39zlcYOj5M/ENRv/nrI7nIAABhSCDVh5HBYuiN3jCTJ38pjUAAADCRCTZglx8VIkhgrDADAwCLUhJmj/fFu5uADAGBgEWrCrGPGGkOqAQBgQBFqwizUU2NzHQAADDWEmjDrmFw4SE8NAAADilBziZBpAAAYWISaMOP2EwAA9iDUhBm3nwAAsAehJsw6emroqgEAYGARasKMnhoAAOxBqAkzi8n3AACwBaEmzDom36OnBgCAgUWoCbOOMTVvl59US4BFLQEAGCiEmjCLcbaFmvozLbrhX/+sVX/Yq2pvs81VAQAQ/Qg1YXbrNen6cm6G0oa5dbLJr2ffKtfXfrlD/lZ6bQAAuJQsM0RWXvR6vUpOTlZ9fb2SkpIu+flaA0EVf3xCy14slbe5VYkel3KzhqvwzonKSo2/5OcHACAa9Ob7e9CEmv379+uee+7p9P63v/2t5s+f36O/H+hQ0+GlnYf1P15+P/Q0lNvp0KTMZKUkuJV/1Sh9PjtFl48cFnpqCgAAnBWVoeZcjY2NmjBhgg4dOqSEhIQe/Y1doUZqG1/z8fEGPfrHD7Xz0Kku+y9LS9DSW67QnVMyB7QuAAAiXW++v10DVFNYvfrqq7r11lt7HGjslhwXo6kTUvX7787Qx8cbtP94gz490aQ3D9SotKJOn9Y06f/63XsanRSr6ZePoNcGAIA+CNtA4eLiYs2bN08ZGRmyLEsbN27s0mbNmjXKzs5WbGys8vLytG3btj6d66WXXup0K2owuTI9UXdMytADt16pl/5xukr+n9v0xetGK2ikv33mbU355yKt+sNeHaptUiuPhAMA0GNhCzVNTU3Kzc3V6tWru92/fv16LVu2TCtXrtTu3bs1c+ZMFRQUqKKiItQmLy9POTk5XV7Hjh0LtfF6vXrrrbf0pS99KVyl2yoxNkb/siBHt12TLo/LoVOnW/TsW+W6+fEtmv2TLdr60QkFgoPuDiEAAAPukoypsSxLGzZs6DSI94YbbtCUKVO0du3a0LZrrrlG8+fPV2FhYY+P/etf/1qbN2/Wb37zmwu28/l88vl8ofder1dZWVm2jKnpKX9rUG8eOKH/9dpH+ri6MfQYeFyMU8lxMUrwODXM41JCx8vtlNPh0I1XjNCXczPkcvKEPgAgukTcmBq/36+SkhI99NBDnbbPmTNH27dv79WxXnrpJX3nO9+5aLvCwkL9+Mc/7tWx7eZ2OXTL1em65ep0Nfpa9W9//FAbdx9Vg69VZ1oC5/27l3cd0YpXyjTM41Kc26m4GKeGx8coPSlWbqdDTocll9Nq++lof+9of+90aJjHqREJHo0Y5laCx6UYp0Nup0NulyW30ym3y6EYp9X+0yGPy8G4HwBAxBmQUFNTU6NAIKD09PRO29PT01VVVdXj49TX1+udd97Ryy+/fNG2K1as0PLly0PvO3pqBothHpf+eX6OHpl3rY6cOqNGX6safa1qav/Z6GvVGX9Ap0779dt3Dutkk1++Vr/UdOlrs6y23qOOcOOwLM3LHaPv/83nlOhxEXgAALYY0KefPvtlZ4zp1RdgcnKyjh8/3qO2Ho9HHo+nV/VFIpfToQlpF37K64Fbr1RVfbPOtAR0xt/2qm3y60SDT63BoFqDRoGAUcAYBYJGrUGj1kBQgaDUGgyqoblVNY0+1TT61dwSkL81KH8gKH9rUC3tP1vPGddjjHTaH9Bp/9neo+feOqjn3jqoeLdTa+6dotlXjbpk1wQAgO4MSKhJS0uT0+ns0itTXV3dpfcGvedxOTV+xKV9vD0YNG1BJxBUc0tAzf6gfK1toWZXxSn9/I1PVHHytE77A1q3/SChBgAw4AYk1LjdbuXl5amoqEgLFiwIbS8qKtJXvvKVgSgB/eRwWIp1OBUb41RSbEynfVemJ+qeaeO0u+KUFqzZrrcO1GjFK2WKi3EqNsahuBin4txOpcS7NWV8ipLjYuR0WEpwOxncDAAIm7CFmsbGRh04cCD0vry8XKWlpUpNTdW4ceO0fPlyLVy4UFOnTtX06dP11FNPqaKiQkuWLAlXCbDZ9eNSdPXoRH1Y1aDfvlNx0fbDPC7des0o/fjL12l4vHsAKgQARLOwPdK9ZcsW5efnd9m+aNEirVu3TlLb5HuPPfaYKisrlZOTo5/+9KeaNWtWOE5/UXYukzCUHKxpUtHe423je9rH+Pha234ePnVG7x+pU0ug8z9yU8en6OufH6dxqfGaNiGFgcYAgJCoX/upLwg1kSMYNGoJBrXrUJ2+8+udamhuDe17qOBqLbn5churAwBEEkJNNwg1kem9w3V6qvhT1TT69Hb5STksacH1mcpKjVNcjFPxbmdofpwYp0Mp8W6NSvLIUtuj5ZIly5IclhXaZrVva3t13u6w2sYHjUhw0yMEAIMAoaYbhJrIZozR/9y4R//19sXH4oTDbdek6+lv5hFsACDCEWq6QaiJfMYY7Tx0Sq/vO67G5rbJBU/7A2oJBNUSNPK3BlTt9anuTIuMMTJqmzOn43cZKXjudpn2/ef8LoXW0vrK5AyNSPDI6WjrvUmJd+sb08YpOT7m/EUCAAYUoaYbhBp0+I8/f6z/VfRRt/tSE9yanDVc41LjFRvjlNMhOR0OuRyWslLjNClzePsSEm23wzoeTwcAXBoRt/YTEEm+O/tyJcXFqKbRp9agUTDYNtPyG/ur9cmJJv3lw+oeH8vpsJQ2zK3kuBjFu10aOzxOibEu3XvDeE3MTL6EnwIA8Fn01ADt/K1B7Tx0UuU1TTpy6oxa2peHCASNWgJB7TlWr0M1p9USDKolYEK3sbozzOPSC/9wgyZlDh+4DwAAUYjbT90g1CDcWgNB1Tb5ddzbrIbmVjU0t+hYXbP+uKdS7x48JbfTobunZir/qlFKS/Qoof1JrmEel0YMG/zrkgHAQCDUdINQg4HS6GvVd39Tom0f15y3TUHOaH1tapauzUjSiAQ3y0UAwHkQarpBqMFAMsZo+ye1erX0mN47UqeG5lad9rfK3xpU0zmrm3dIiY9RbIxTMU6HEmNdyslIVrzHGZpzJ2dskr6cO5ZByQCGHEJNNwg1iBT7qxq0bvtB7fikRhUnT+sCQ3M6uXxkgmZfNUpjh8cpPSlW8W6nPC6HPDEOeVxtv6ckuJXGrS0AUYRQ0w1CDSJRIGh06rRfJ5v88rUE5Q8EdaLBp72VXrUGgjKSzvgDennXkU7LSVzIhBHxumLUMA3zuORyOjQ6KVb/MOsyJccx/w6AwYdQ0w1CDQaz+tMt+sv+4yo74tVxb7OqG5rV3BKUrzUgX2tQvvbf2yYm7Pr3U8en6D8XTWNiQQCDDqGmG4QaDAX1Z1r03uE6HT51un2F9KB+ufUTeZtbZVlSRnKcRiV5NCLBLY/LqYmZyRqTHCunw5LTsuRwWHI7HcqbkKKkWAIQAPsRarpBqMFQVXLolH74+/f0yYmmHv9NUqxLt16Trhin1RZ42kOPZbUtBvrN6RPo9QEwIAg13SDUYKirbmjW4ZNndKKhWadOt6ihuUUlh06poblVgaBR0LRNKFjd4NORU2cueKxJmcn69bdvINgAuOQINd0g1AA9EwgaFe09roO1TQq0z6gcehmj9e8e1skmv1wOS5ePHBa6nRXjdKhj0fPE2Bh9+6ZsjR0eZ++HATDoEWq6QagBwmPP0Xp977e7VV5z4dtZl49M0L8umCiXs+22ldOy5LAsORxta2bFx7iUlRony2LuHQDnR6jpBqEGCB9jjI6cOqPymiadaPCptqltcdCOf5v8eschVXmbL3qc/3n7NVo887JLXC2AwYxVugFcUpZlKSs1Xlmp8d3un3XlSK367w9U2+hXoH2sjjEKjd3xB4KqO92i5946qG/fmC0HMyUDCANCDYCwm5iZrN8tmXHe/c0tAU37l9d1tO6M3jxQo1mfGzmA1QGIVoQaAAMuNsapBdeP1fM7Dmnxr3bqspEJSk+KVdowjxJjXUqKdWlYrEvxbpfiYpzyxDjaxuNY0nUZyeftIQIwtBFqANjiH2++XG9/elL7jzfow6q2V0+kJri17Yf5SvDwry8AnfFvBQC2GDs8Tn9aNlOHak/r0MnTOl7frJomnxqbW9Xoaw2tbH6mJajm9pXN9x9v0MkmvzbsPqq/+8J4mz8BgEhDqAFgG8uyNCEtQRPSEnrU/tk3y7Xqv/fq2bfKNTLRo9gYp+JinG2PjavtUfG0YR4lx8XI6Wh7hLztp3h0HBgCeKQbwKDhbW7R9H/9s5rae256KjstQffdlK3brklXepKHgAMMIsxT0w1CDRAd/nfpUb2087DO+ANtt6ZaAmoJBCW1PTJ+oqFtzpzzcVhtA5VjY5zyuBxyOc8fcNKGeTQ+NV6O9l4fS2r72d7zY1ltxwvtc1iac+1oTb98RJg/NTB0EWq6QagBhoZA0MjXGmibEyco+QIB/eG9Sr2y64j2VXp1gbwTFulJHr398G2X9iTAEMLkewCGLKfDUrz73H+1xei+m7J1303ZOuMPqKG5Rc0tQflaA2puCao1GOz2OEEjHas7o8r6MzJGMpKCpm0SQWOMgkYypn2bpGDQ6OdbDui416eaRp/ShnkG4uMCOAehBsCQEed2Ks7t7HH7vPEpvTr+H94/pkO1p/VRVYPSriDUAAPNYXcBABAtPpeeKKnt0XMAA49QAwBhcvXotlDzEaEGsAWhBgDCJNRT08PZkQGEF2NqACBMrgr11DTq8MnTio1xyumwlBIfw9w4wACIyJ6aBQsWKCUlRXfddVev9gGAnbLTEuR2OdToa9XMx97QtH95XVP+uUiLf7XT7tKAISEiQ80DDzyg559/vtf7AMBOMU6H/r/5OcoZmySXo21yPkn684fV2l1xyt7igCEgIkNNfn6+EhMTe70PAOz2talZ+u/vzdSBf/2Sygtv11enZEqSnt72qbzNLWoNdD8vDoD+6/WYmuLiYj3++OMqKSlRZWWlNmzYoPnz53dqs2bNGj3++OOqrKzUddddpyeffFIzZ84MV80AMGjcd1O2Xt51RJvKqrSprKrTPpfDUnpSrIZ5XMpKjdM/zLxMN1zGEgtAX/U61DQ1NSk3N1d///d/r69+9atd9q9fv17Lli3TmjVrdOONN+qXv/ylCgoKtHfvXo0bN06SlJeXJ5/P1+VvX3vtNWVkZPThYwBAZLo2I0n3TM3S73cdUeAzazS0Bo2O1p2R1Da3zev7qjX9shGacfmITutLTRiRoMlZw5WeFCungwHHwPn0OtQUFBSooKDgvPufeOIJ3XfffVq8eLEk6cknn9TmzZu1du1aFRYWSpJKSkr6WG7P+Xy+TsHJ6/Ve8nMCQHf+7a5JevSrE+UPBHXaF1Cgfck9X2tQVfVndNof0J/2VOmlnYe149Na7fi0ttvjWFbbuB2nZcnlsORwnP3psCSnZcmyLDkdbS+rfVvb75acjrbFN7NS4/X4XZM+s5wEMPiF9Z9ov9+vkpISPfTQQ522z5kzR9u3bw/nqS6qsLBQP/7xjwf0nABwPpZlyeNyyuPqvEzD2OFxkqSZV47U/flX6IW3D+lkk799jSmpJRjU3mNefVzdqEDQyN/a/zE57x+p1/VZw7V45mX9PhYQScIaampqahQIBJSent5pe3p6uqqqqs7zV13NnTtXu3btUlNTkzIzM7VhwwZNmzbtovvOtWLFCi1fvjz03uv1Kisrq4+fDAAuvbHD4/R/z726232BoFFtk0+tAaNA0Kg12PEzqGCwbWHNoGnbFmxfcDP0e1AKtO9/p/yk1m75RM+9dVDfmjFBLmdEPi8C9Mkl6Xv87CRTxpheTTy1efPmPu07l8fjkcfDgnIAooPTYWlUYmy/jzP9shF66d3DOlp3Rn/cU6V5uYxjRPQIa0RPS0uT0+ns0itTXV3dpfcGADDwYmOc+rsvjJckPbPtUxljLvIXwOAR1lDjdruVl5enoqKiTtuLioo0Y8aMcJ4KANBHC6ePl9vl0HtH6vXuQSYFRPTodahpbGxUaWmpSktLJUnl5eUqLS1VRUWFJGn58uV65pln9Oyzz2rfvn36/ve/r4qKCi1ZsiSshQMA+iZtmEdfnTJWkvQvm/Zp7zEvPTaICpbp5T/JW7ZsUX5+fpftixYt0rp16yS1Tb732GOPqbKyUjk5OfrpT3+qWbNmhaXgvvJ6vUpOTlZ9fb2SkpJsrQUA7PbJiUZ96Wfb5Gt/miptmEeXpSVoWOzZoZYdIyFHJXn0rRnZoQU7gYHUm+/vXoeawYpQAwCdfVjl1b//+WO9vq+6R4+Kz70uXbddky5H+6SAliVZOrvGlWVZsiQleJy68Yq0Lo+vA31BqOkGoQYAutfcEtDeSq+OnDqj5pZA20bT8cNo60cn9Mc9VerNt0V6kkezPzdKI4a5lZrgltvlkMOy5GifBNDq6AeyzvYIdTwla0nnBKW2nw7L0tQJqaF5fTB0EGq6QagBgL77+HiDnn2rXEfrmjuNvzGmLfh0TBZoZFRe06Tj3q5L4fTX5SMT9OcfzA77cRHZevP9zRzZAICLujI9UYV3TupRW19rQK99cFwHa5pU2+RXbZNfgfZJAgPGKNi+BpaRQgGp7Xd12a727W8eqNEnJ5p0ssmv1AR3GD8ZogmhBgAQVh6XM+yT+s1+/A0drD2tD47Va+aVI8N6bEQP5scGAES86zKSJUkfHGNxYpwfoQYAEPGuzWgbS0GowYUQagAAEe+6UKipt7kSRDJCDQAg4nXcfiqvaVKTr9XmahCpCDUAgIg3MtGjUYkeGSO9suuI3eUgQhFqAACDwjc+P06S9P+++oH+7U8fqrqh2eaKEGmYfA8AMCgYY/TIqx/o+R2HQtsmjIhXVmq8EtwuOZ2WXA5LLodD2WnxyhmbrFGJsUpLdCvB7epmWYez79tmMQ7Nc9xjDkdv/wK9xeR7AICoY1mWfvzl63TjFWlau+UTlR6u08Ha0zpYe9qmeqTv3ny5fvjFq205P7qipwYAMCidavJrb6VXlfXNam4JKBA0agkE5WsNam+lVweON6q2yaeTTX4FL9E3XYzT0pv/4xalJ8VemhOAnhoAQPRLSXDrxivSLtouEDTytwbPrlGltltZoaUZzlm/qje+8+udevfgKT331kE9VEBvTSQg1AAAoprTYSnO7Qz7cb8z63K9e3Cnfln8iV7ZdUQuh9U2Lsc6z3idc1YkP9eIYR79/G+naGSiJ+w1DjWEGgAA+uDWq0dp2oQUvXvwlKob+r4q+ScnmrSprFKLZkwIX3FDFKEGAIA+cDgsvfSP03Wi0adqr09Bc/b2VsfvOueWV7CbgT0v7zqil3YeYabkMCHUAADQR5ZlaVRirEYl9m2g8KnT/vZQw5pW4cDkewAA2KRj+YePjjfI3xq0uZrBj1ADAIBNMlPilBTrUkvA6OPqBrvLGfQINQAA2MSyrFBvzQdHuQXVX4QaAABsdF1G24RyDBbuP0INAAA2yhnb3lPDYOF+I9QAAGCjjp6avZVeBS7Veg5DBKEGAAAbXTZymGJjHDrtD+hgbZPd5QxqhBoAAGzkdFi6ZkzHuBpuQfUHoQYAAJuFBgsfZbBwfxBqAACwWeixbnpq+oVQAwCAzXJCoaZexjBYuK8INQAA2Oxzo4fJ5bB06nSLKuub7S5n0CLUAABgM4/LqStGDZMk7WFcTZ8RagAAiACMq+k/Qg0AABEgZyyPdfdXRIaaBQsWKCUlRXfddVeXfS6XS5MnT9bkyZO1ePFiG6oDACD8rjtnsDD6xmV3Ad154IEH9O1vf1u/+tWvuuwbPny4SktLB74oAAAuoWvGJEqSKuubdbLJr9QEt80VDT4R2VOTn5+vxMREu8sAAGDAJMbGKDstQRK9NX3V61BTXFysefPmKSMjQ5ZlaePGjV3arFmzRtnZ2YqNjVVeXp62bdsWjlolSV6vV3l5ebrpppu0devWsB0XAAC7dcws/OaBGpsrGZx6HWqampqUm5ur1atXd7t//fr1WrZsmVauXKndu3dr5syZKigoUEVFRahNXl6ecnJyuryOHTt20fMfPHhQJSUl+sUvfqFvfvOb8noZUAUAiA5fzs2QJL3w1wp5m1tsrmbw6fWYmoKCAhUUFJx3/xNPPKH77rsvNIj3ySef1ObNm7V27VoVFhZKkkpKSvpYrpSR0fY/eE5Ojq699lp99NFHmjp1apd2Pp9PPp8v9J7wAwCIdLddk64rRw3Tx9WN+vWOQ/qn/CvsLmlQCeuYGr/fr5KSEs2ZM6fT9jlz5mj79u39Pv6pU6dCQeXIkSPau3evLrvssm7bFhYWKjk5OfTKysrq9/kBALiUHA5L3519uSTpZ69/rC37q22uaHAJa6ipqalRIBBQenp6p+3p6emqqqrq8XHmzp2ru+++W5s2bVJmZqbeffddSdK+ffs0depU5ebm6o477tDPfvYzpaamdnuMFStWqL6+PvQ6fPhw3z8YAAAD5CuTx+qL142WPxDUd35doq0fnbC7pEHjkjzSbVlWp/fGmC7bLmTz5s3dbp8xY4bKysp6dAyPxyOPx9PjcwIAEAmcDkv/8bfX65/+a5de23tc33l+p265epSGeVzq+Cq1ZMmy1P6+/XdJDstSjNOhGJel6ZeN0OyrRtn4SQZeWENNWlqanE5nl16Z6urqLr03AACgezFOh1b/7RTd/1+79Pq+4/rjnp7f7ejw7Jvl2v7QrRqZOHT+Az+socbtdisvL09FRUVasGBBaHtRUZG+8pWvhPNUAABENbfLoV8uzNO2j0/oYE2TTrcEZMzZ/cYYGSMZqf2nUdBILYGg/lhWqYO1p7Vx91H9w6zux55Go16HmsbGRh04cCD0vry8XKWlpUpNTdW4ceO0fPlyLVy4UFOnTtX06dP11FNPqaKiQkuWLAlr4QAARDunw2q7hXRV7/4uMyVOKzfs0Us7D2vxzOxeDQEZzHodanbu3Kn8/PzQ++XLl0uSFi1apHXr1umee+5RbW2tVq1apcrKSuXk5GjTpk0aP358+KoGAADnNS83Q6v+sFcfVzfqvSP1mpw13O6SBoRlzLmdWdHL6/UqOTlZ9fX1SkpKsrscAAAuqQdf3K3/XXpM994wTv+yYKLd5fRZb76/I3LtJwAA0D9fmdw2We2OT2ptrmTgEGoAAIhCyXFtq3y3BIM2VzJwCDUAAEShITI2uBNCDQAAUWxojJxtQ6gBACAKdXTUEGoAAMCgNlTmpjkXoQYAgCg09CINoQYAAEQJQg0AAFGo4+7TEJljVxKhBgCAqGS134AaOpGGUAMAQFQaguOECTUAAESj2Ji2r/gmX6vNlQwcQg0AAFFoZGKsJMnb3KrmloDN1QwMQg0AAFEoKdYlj6vta77a67O5moFBqAEAIApZlqWRiR5J0olGQg0AABjEkuNiJEneMy02VzIwCDUAAESpjlBTT6gBAACDGaEGAABEBUINAACICkmMqQEAANFgeHxbqKnyNttcycAg1AAAEKWuz0qRJP3109ohsbAloQYAgCg1OWu4JKmm0S/vmehfLoFQAwBAlIpzOzUmuW25hO2f1NhczaVHqAEAIIp9dUqmJOnnWw5E/S0oQg0AAFHsWzdOkNvl0J6jXn1yosnuci4pQg0AAFEsbZhHV6UnSpI+PdFoczWXFqEGAIAoN2KYW5JUF+Xz1RBqAACIckmxQ2MSPkINAABRLinOJYlQAwAABrkxyXGSpD+8X6mDNdE7WJhQAwBAlLt94hg5HZbKa5r04z98YHc5lwyhBgCAKDchLUE/+/pkSdJbn9TqjD9gb0GXCKEGAIAh4PaJYzR2eJz8rUHt+DQ6ZxeOyFCzYMECpaSk6K677uqy7yc/+Ymuu+465eTk6De/+Y0N1QEAMPhYlqX8q0dKkh7f/JGaW6KvtyYiQ80DDzyg559/vsv2srIyvfDCCyopKdHOnTu1du1a1dXVDXyBAAAMQt/4/Dg5HZb2VXr16nvH7C4n7CIy1OTn5ysxMbHL9n379mnGjBmKjY1VbGysJk+erD/96U82VAgAwOBzXUay7p99uSRpU1ll1K0F1etQU1xcrHnz5ikjI0OWZWnjxo1d2qxZs0bZ2dmKjY1VXl6etm3bFo5alZOTozfeeEN1dXWqq6vTX/7yFx09ejQsxwYAYCi4fdIYSdKW/Sf07XXvRtWg4V6HmqamJuXm5mr16tXd7l+/fr2WLVumlStXavfu3Zo5c6YKCgpUUVERapOXl6ecnJwur2PHLtwVdu211+qBBx7QLbfcogULFmjatGlyuVy9/QgAAAxZV49O0iPzrpXb5dAb+0/ohXcqLv5Hg4Rl+tH3ZFmWNmzYoPnz54e23XDDDZoyZYrWrl0b2nbNNddo/vz5Kiws7PGxt2zZotWrV+v3v//9edssXrxYCxYs0O23395ln8/nk8/nC733er3KyspSfX29kpKSelwHAADR6Nk3y7Xqv/dq6vgU/f67M+wu57y8Xq+Sk5N79P0d1jE1fr9fJSUlmjNnTqftc+bM0fbt28NyjurqaknS/v379c4772ju3LndtissLFRycnLolZWVFZbzAwAQDb40se021M5Dp/TwhrKouA0V1lBTU1OjQCCg9PT0TtvT09NVVVXV4+PMnTtXd999tzZt2qTMzEy9++67oX3z58/Xtddeq7/7u7/Tc889d97bTytWrFB9fX3odfjw4b59KAAAotDo5Fj94G8+J0l64e0KzVv9pmobfRf5q8h2SQakWJbV6b0xpsu2C9m8efN59/W0x8fj8cjj8fT4nAAADDXfu/VKXT8uRctfKtWB6kb9x18O6Edfvs7usvosrD01aWlpcjqdXXplqquru/TeAAAA+910ZZqe+NpkSdIL71Soova0vQX1Q1hDjdvtVl5enoqKijptLyoq0owZkTsICQCAoezGK0boxitGyN8a1D/+pkQfHW+wu6Q+6XWoaWxsVGlpqUpLSyVJ5eXlKi0tDT2yvXz5cj3zzDN69tlntW/fPn3/+99XRUWFlixZEtbCAQBAeFiWpVVfyVFcjFP7Kr362i936PclR/TnfccH1QDiXj/SvWXLFuXn53fZvmjRIq1bt05S2+R7jz32mCorK5WTk6Of/vSnmjVrVlgK7qvePBIGAMBQ9MmJRj344m7tOeoNbfva1Ew9dleubTX15vu7X/PUDCaEGgAALq6m0afH/7Rf5TVNeufgSXlcDr3z8G1Kjo+xpR7b5qkBAACDW9owj/7trkla/49f0NWjE+VrDerFdwfHrMOEGgAA0IVlWVo4fbwk6fHN+/WTzftVdqQ+ohfB5PYTAADoVjBotGx9qV597+zajJkpcZqXm6G/v3GCRiXGXvIaGFPTDUINAAC91xoI6g/vH9NrHxzX1o9O6HT701BXpSdq04Mz5XT0fHLdvujN9zdLXAMAgPNyOR1acH2mFlyfqTP+gP7yYbUe3lCm/ccb9PKuI/ra1MhZW5ExNQAAoEfi3E7dPmmMluZfIUn6xZZPbK6oM0INAADola9/PkuWJX1a06QTDZGzCCahBgAA9EpibIw+NypRkrSr4pTN1ZxFqAEAAL02ZfxwSYQaAAAwyF0/LkWStOsQoQYAAAxiU9pDzftH6nXa32pzNW0INQAAoNcuH5mg8SPi5WsNalNZld3lSCLUAACAPrAsS3fnZUqSfrfzsM3VtCHUAACAPvlqXqYclvR2+Ukd9zbbXQ6hBgAA9M2Y5DilDfNIkmoa7Z+vhlADAAD6LDbGKUlqbgnaXAmhBgAA9ENsTFuU8LUEbK6EUAMAAPoh1FPTSqgBAACDWKyL208AACAKeNpvPzVz+wkAAAxmDBQGAABR4WyooacGAAAMYrGu9ttPDBQGAACDGbefAABAVPC4mKcGAABEAcbUAACAqBAbeqSb208AAGAQY0ZhAAAQFTzcfgIAANEg9Eg3t58AAMBgxkBhAAAQFc6OqaGnBgAADGIdTz8xT003Dh8+rNmzZ+vaa6/VpEmT9Lvf/S60r6GhQdOmTdPkyZM1ceJEPf300zZWCgAAIun2k8vuAj7L5XLpySef1OTJk1VdXa0pU6boS1/6khISEhQfH6+tW7cqPj5ep0+fVk5Oju68806NGDHC7rIBABiSYl2Rs0xCxIWaMWPGaMyYMZKkUaNGKTU1VSdPnlRCQoKcTqfi4+MlSc3NzQoEAjLG2FkuAABDWmjyvcE4T01xcbHmzZunjIwMWZaljRs3dmmzZs0aZWdnKzY2Vnl5edq2bVufitu5c6eCwaCysrJC2+rq6pSbm6vMzEz98Ic/VFpaWp+ODQAA+i+Sbj/1OtQ0NTUpNzdXq1ev7nb/+vXrtWzZMq1cuVK7d+/WzJkzVVBQoIqKilCbvLw85eTkdHkdO3Ys1Ka2tlbf/OY39dRTT3U6/vDhw/Xee++pvLxcL7zwgo4fP97bjwAAAMLEc84yCXbfPen17aeCggIVFBScd/8TTzyh++67T4sXL5YkPfnkk9q8ebPWrl2rwsJCSVJJSckFz+Hz+bRgwQKtWLFCM2bM6LZNenq6Jk2apOLiYt19993dHsPn84Xee73ei342AADQOx09NZLkaw12ej/Qwvr0k9/vV0lJiebMmdNp+5w5c7R9+/YeHcMYo29961u65ZZbtHDhwk77jh8/HgonXq9XxcXFuuqqq7o9TmFhoZKTk0Ovc29hAQCA8OgYKCxJPpsHC4c11NTU1CgQCCg9Pb3T9vT0dFVVVfXoGG+99ZbWr1+vjRs3avLkyZo8ebLKysokSUeOHNGsWbOUm5urm266SUuXLtWkSZO6Pc6KFStUX18feh0+fLh/Hw4AAHQR47TksNp+t3uw8CV5+smyrE7vjTFdtp3PTTfdpGCw+6SXl5en0tLSHh3H4/HI4/H0qC0AAOgby7IUG+PUaX/A9sHCYe2pSUtLk9Pp7NIrU11d3aX3BgAARIezT0BF0e0nt9utvLw8FRUVddpeVFR03gG/AABgcDu7Uvcgu/3U2NioAwcOhN6Xl5ertLRUqampGjdunJYvX66FCxdq6tSpmj59up566ilVVFRoyZIlYS0cAABEhkiZq6bXoWbnzp3Kz88PvV++fLkkadGiRVq3bp3uuece1dbWatWqVaqsrFROTo42bdqk8ePHh69qAAAQMTwRslJ3r0PN7NmzLzq5zv3336/777+/z0UBAIDBw+OKjJW6I26VbgAAMLg425/pDto8ozChBgAA9IuzfdqWgM0LdRNqAABAvzja0wQ9NQAAYFBzWNx+AgAAUaBjTE0gSKgBAACD2NmeGpvrsPf0AABgsOtY0DJITw0AABjMeKQbAABEhY7bTwFCDQAAGMxCY2q4/QQAAAazs7ef7K2DUAMAAPrFwSPdAAAgGjg7nn5iTA0AABjMmFEYAABEhbO3n2yuw97TAwCAwS6m/f6TrzVgax2EGgAA0C/ZaQmSpA8rG2ytg1ADAAD6JTdzuCTpvSN1ttbhsvXsAABg0MsZm6x7pmZp8rjhCgZNaIzNQCPUAACAfknwuPRvd02yuwxuPwEAgOhAqAEAAFGBUAMAAKICoQYAAEQFQg0AAIgKhBoAABAVCDUAACAqEGoAAEBUINQAAICoQKgBAABRgVADAACiAqEGAABEBUINAACICkNmlW5jjCTJ6/XaXAkAAOipju/tju/xCxkyoaahoUGSlJWVZXMlAACgtxoaGpScnHzBNpbpSfSJAsFgUMeOHVNiYqIsywrrsb1er7KysnT48GElJSWF9dhDEdczvLie4cX1DB+uZXhF6/U0xqihoUEZGRlyOC48ambI9NQ4HA5lZmZe0nMkJSVF1T9IduN6hhfXM7y4nuHDtQyvaLyeF+uh6cBAYQAAEBUINQAAICoQasLA4/HokUcekcfjsbuUqMD1DC+uZ3hxPcOHaxleXM8hNFAYAABEN3pqAABAVCDUAACAqECoAQAAUYFQAwAAogKhpp/WrFmj7OxsxcbGKi8vT9u2bbO7pEuuuLhY8+bNU0ZGhizL0saNGzvtN8boRz/6kTIyMhQXF6fZs2frgw8+6NTG5/Ppe9/7ntLS0pSQkKAvf/nLOnLkSKc2p06d0sKFC5WcnKzk5GQtXLhQdXV1ndpUVFRo3rx5SkhIUFpamh544AH5/f5ObcrKynTzzTcrLi5OY8eO1apVq3q0hshAKCws1LRp05SYmKhRo0Zp/vz52r9/f6c2XM+eW7t2rSZNmhSafGz69On64x//GNrPteyfwsJCWZalZcuWhbZxTXvuRz/6kSzL6vQaPXp0aD/XMgwM+uzFF180MTEx5umnnzZ79+41Dz74oElISDCHDh2yu7RLatOmTWblypXm5ZdfNpLMhg0bOu1/9NFHTWJionn55ZdNWVmZueeee8yYMWOM1+sNtVmyZIkZO3asKSoqMrt27TL5+fkmNzfXtLa2htp88YtfNDk5OWb79u1m+/btJicnx9xxxx2h/a2trSYnJ8fk5+ebXbt2maKiIpORkWGWLl0aalNfX2/S09PN17/+dVNWVmZefvllk5iYaH7yk59cugvUC3PnzjXPPfec2bNnjyktLTW33367GTdunGlsbAy14Xr23Kuvvmr+z//5P2b//v1m//795uGHHzYxMTFmz549xhiuZX+88847ZsKECWbSpEnmwQcfDG3nmvbcI488Yq677jpTWVkZelVXV4f2cy37j1DTD5///OfNkiVLOm27+uqrzUMPPWRTRQPvs6EmGAya0aNHm0cffTS0rbm52SQnJ5tf/OIXxhhj6urqTExMjHnxxRdDbY4ePWocDof505/+ZIwxZu/evUaS+etf/xpqs2PHDiPJfPjhh8aYtnDlcDjM0aNHQ21++9vfGo/HY+rr640xxqxZs8YkJyeb5ubmUJvCwkKTkZFhgsFgGK9EeFRXVxtJZuvWrcYYrmc4pKSkmGeeeYZr2Q8NDQ3myiuvNEVFRebmm28OhRquae888sgjJjc3t9t9XMvw4PZTH/n9fpWUlGjOnDmdts+ZM0fbt2+3qSr7lZeXq6qqqtN18Xg8uvnmm0PXpaSkRC0tLZ3aZGRkKCcnJ9Rmx44dSk5O1g033BBq84UvfEHJycmd2uTk5CgjIyPUZu7cufL5fCopKQm1ufnmmztNRjV37lwdO3ZMBw8eDP8F6Kf6+npJUmpqqiSuZ38EAgG9+OKLampq0vTp07mW/fBP//RPuv3223Xbbbd12s417b2PP/5YGRkZys7O1te//nV9+umnkriW4UKo6aOamhoFAgGlp6d32p6enq6qqiqbqrJfx2e/0HWpqqqS2+1WSkrKBduMGjWqy/FHjRrVqc1nz5OSkiK3233BNh3vI+1/J2OMli9frptuukk5OTmSuJ59UVZWpmHDhsnj8WjJkiXasGGDrr32Wq5lH7344ovatWuXCgsLu+zjmvbODTfcoOeff16bN2/W008/raqqKs2YMUO1tbVcyzAZMqt0XyqWZXV6b4zpsm0o6st1+Wyb7tqHo41pH+gWaf87LV26VO+//77efPPNLvu4nj131VVXqbS0VHV1dXr55Ze1aNEibd26NbSfa9lzhw8f1oMPPqjXXntNsbGx523HNe2ZgoKC0O8TJ07U9OnTdfnll+tXv/qVvvCFL0jiWvYXPTV9lJaWJqfT2SWxVldXd0m3Q0nHSP4LXZfRo0fL7/fr1KlTF2xz/PjxLsc/ceJEpzafPc+pU6fU0tJywTbV1dWSuv4XkZ2+973v6dVXX9Ubb7yhzMzM0HauZ++53W5dccUVmjp1qgoLC5Wbm6uf/exnXMs+KCkpUXV1tfLy8uRyueRyubR161b9+7//u1wu13n/y51r2jMJCQmaOHGiPv74Y/75DBNCTR+53W7l5eWpqKio0/aioiLNmDHDpqrsl52drdGjR3e6Ln6/X1u3bg1dl7y8PMXExHRqU1lZqT179oTaTJ8+XfX19XrnnXdCbd5++23V19d3arNnzx5VVlaG2rz22mvyeDzKy8sLtSkuLu70qOJrr72mjIwMTZgwIfwXoJeMMVq6dKleeeUV/eUvf1F2dnan/VzP/jPGyOfzcS374NZbb1VZWZlKS0tDr6lTp+ree+9VaWmpLrvsMq5pP/h8Pu3bt09jxozhn89wGZDhyFGq45Hu//zP/zR79+41y5YtMwkJCebgwYN2l3ZJNTQ0mN27d5vdu3cbSeaJJ54wu3fvDj3K/uijj5rk5GTzyiuvmLKyMvONb3yj28cSMzMzzeuvv2527dplbrnllm4fS5w0aZLZsWOH2bFjh5k4cWK3jyXeeuutZteuXeb11183mZmZnR5LrKurM+np6eYb3/iGKSsrM6+88opJSkqKmMcSv/vd75rk5GSzZcuWTo95nj59OtSG69lzK1asMMXFxaa8vNy8//775uGHHzYOh8O89tprxhiuZTic+/STMVzT3vjBD35gtmzZYj799FPz17/+1dxxxx0mMTEx9J3Btew/Qk0//fznPzfjx483brfbTJkyJfQobjR74403jKQur0WLFhlj2h5NfOSRR8zo0aONx+Mxs2bNMmVlZZ2OcebMGbN06VKTmppq4uLizB133GEqKio6tamtrTX33nuvSUxMNImJiebee+81p06d6tTm0KFD5vbbbzdxcXEmNTXVLF26tNMjiMYY8/7775uZM2caj8djRo8ebX70ox9FzCOJ3V1HSea5554LteF69ty3v/3t0P8fR44caW699dZQoDGGaxkOnw01XNOe65h3JiYmxmRkZJg777zTfPDBB6H9XMv+s4yJ9OkBAQAALo4xNQAAICoQagAAQFQg1AAAgKhAqAEAAFGBUAMAAKICoQYAAEQFQg0AAIgKhBoAABAVCDUAACAqEGoAAEBUINQAAICoQKgBAABR4f8HvQlekL8g8d4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(SEED)\n", + "xy = np.random.randn(n+m)\n", + "\n", + "solution = run_with_term_rule(\n", + " xy, MAXHESSIAN=MAXITERS,\n", + " cg_termination_rule=lambda xy: {'rtol':min(0.5, np.linalg.norm(separated_grad(xy)) ** 1)})" + ] + }, + { + "cell_type": "markdown", + "id": "72ac2cb0", + "metadata": {}, + "source": [ + "# FOR COMPARISON: LBFGS " + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "880df8c0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(SEED)\n", + "xy = np.random.randn(n+m)\n", + "def fun(xy):\n", + " return separated_loss(xy), separated_grad(xy)\n", + "\n", + "all_losses = []\n", + "def callback(xy):\n", + " all_losses.append(separated_loss(xy))\n", + "\n", + "sp.optimize.fmin_l_bfgs_b(\n", + " fun,\n", + " x0=xy,\n", + " factr=0.,\n", + " pgtol=0.,\n", + " m=10,\n", + " maxiter=MAXITERS*2,\n", + " maxfun=np.inf,\n", + " callback=callback,\n", + ")\n", + "\n", + "plt.plot(np.arange(len(all_losses))/2., all_losses)\n", + "plt.yscale('log')" + ] + }, + { + "cell_type": "markdown", + "id": "26210e17", + "metadata": {}, + "source": [ + "# FOR COMPARISON: DENSE SOLVE " + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "c05cf8a4", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3a049f18e9ae4943b600145730f6767c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(0)\n", + "xy = np.random.randn(n+m)\n", + "\n", + "losses = []\n", + "\n", + "for i in range(1000):\n", + " print(i)\n", + " current_loss = separated_loss(xy)\n", + " losses.append(current_loss)\n", + " current_grad = separated_grad(xy)\n", + " direction = np.linalg.lstsq(dense_hessian(xy), -current_grad, rcond=None)[0]\n", + " xy = line_search(xy, direction)\n", + "\n", + "plt.plot(np.arange(len(losses)), losses, label=f'DENSE SOLVE')\n", + "print('FINAL LOSS:', losses[-1])\n", + "plt.legend()\n", + "plt.yscale('log')\n", + "plt.show()\n", + " # print('FINAL LOSS:', losses[-1])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 717, + "id": "7a03d2e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "559200.0" + ] + }, + "execution_count": 717, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "800 * len(xy)/2" + ] + }, + { + "cell_type": "markdown", + "id": "fe7cd6b1", + "metadata": {}, + "source": [ + "# END " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "63ee4417", + "metadata": {}, + "outputs": [ + { + "ename": "Exception", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m\n", + "\u001b[0;31mException\u001b[0m: " + ] + } + ], + "source": [ + "raise Exception" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7571cb2", + "metadata": {}, + "outputs": [], + "source": [ + "fixed_rule = lambda x: {'maxiter':200}\n", + "np.random.seed(0)\n", + "xy = np.random.randn(n+m)\n", + "\n", + "solution = run_with_term_rule(xy, MAXHESSIAN=40000, cg_termination_rule=fixed_rule)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59c63663", + "metadata": {}, + "outputs": [], + "source": [ + "xs = np.linspace(0,1)\n", + "losses = []\n", + "for step in xs:\n", + " losses.append(separated_loss(xy + step * cg_solution))\n", + " \n", + "plt.plot(xs, losses)\n", + "print(np.min(losses))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b4aaf75", + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(matrix_transf)\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36a431e2", + "metadata": {}, + "outputs": [], + "source": [ + "# system = sp.sparse.bmat([[None, matrix_transf.T], [matrix_transf, None]]).todense()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78196dee", + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(matrix_transf.T @ matrix_transf)\n", + "plt.colorbar()\n", + "plt.figure()\n", + "plt.plot(np.linalg.eigh(matrix_transf.T @ matrix_transf)[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "893985dc", + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(matrix_transf @ matrix_transf.T)\n", + "plt.colorbar()\n", + "plt.figure()\n", + "plt.plot(np.linalg.eigh(matrix_transf @ matrix_transf.T)[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dcaf4e89", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}