{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from netgen.occ import *\n", "from ngsolve import *\n", "from netgen.meshing import IdentificationType\n", "#from MS_helper_functions import *\n", "from netgen.webgui import Draw as DrawGeo\n", "from ngsolve.webgui import Draw\n", "#Draw = lambda *args, **kwargs : None\n", "\n", "import matplotlib.pyplot as plt\n", "%matplotlib widget\n", "plt.ioff()\n", "\n", "from myPackage import evalOnLine, L2Draw, colorprint, TextColor\n", "L2Draw.drawFunc = Draw\n", "from meshGen import mesh2DLaminates\n", "\n", "import numpy as np\n", "\n", "modelHalfAir = False\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "mu0 = 4e-7*np.pi\n", "\n", "muAir = 1 * mu0\n", "muFe = 10 * mu0\n", "\n", "\n", "order0 = 2" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "D = 0.06\n", "d = 0.02\n", "\n", "ff = 0.7\n", "\n", "\n", "numSheets = 5\n", "\n", "maxh_edges = d/numSheets*1/2 * 0.1\n", "\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. All together with Eddy currents\n", "### 4.1. Reference Solution " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "maxh_edges [0.0002, 0.0002]\n", "Boundaries {'left', 'bottom', 'iright', 'ibottom', 'ileft', 'top', 'itop', 'right'}\n", "Materials {'inner', 'insulation', 'outer'}\n", "0.0028\n" ] } ], "source": [ "import importlib\n", "\n", "import meshGen as mg\n", "mg = importlib.reload(mg)\n", "mesh2DLaminates = mg.mesh2DLaminates\n", "cMeshRef = mesh2DLaminates(D, d, ff, numSheets, multiscale=False, maxh_edges=[maxh_edges, maxh_edges], fullProblemX=True, onlySmooth = False, onlyRough = False, rotated=True, modelHalfAir=modelHalfAir, quad_dominated=False)\n", "meshRef = cMeshRef.mesh\n", "print(\"Boundaries\", set(meshRef.GetBoundaries()))\n", "print(\"Materials\", set(meshRef.GetMaterials()))\n", "\n", "print(cMeshRef.dFe)\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "48538248b8bf4511a8ef5f8630ac3af5", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {}, 'ngsolve_version': '6.2.2…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "BaseWebGuiScene" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Draw(meshRef)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'bottom', 'ibottom', 'ileft', 'iright', 'itop', 'left', 'right', 'top'}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "set(meshRef.GetBoundaries())" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[2KCG iteration 1, residual = 0.0036074343870852476 \n", "\u001b[2KCG iteration 2, residual = 1.5922217709282622e-17 \n" ] } ], "source": [ "mu = meshRef.MaterialCF({\"inner\":muFe, \"outer\":muAir, \"insulation\":muAir, \"gap\":muAir, \"multiscale\":muFe})\n", "def calcRef():\n", " fesPhi = H1(meshRef, order=order0+1, dirichlet=\"left|right\")\n", " fes = FESpace([fesPhi])\n", "\n", " trials, tests = fes.TnT()\n", " sol = GridFunction(fes)\n", "\n", " a = BilinearForm(fes, symmetric=True)\n", " f = LinearForm(fes)\n", "\n", " a += mu * (-grad(trials[0])) * (-grad(tests[0])) * dx\n", " a += 1e-3* trials[0] * tests[0] * dx(\"inner\")\n", "\n", "\n", " prec = Preconditioner(a, \"direct\")\n", "\n", " Phi = sol.components[0]\n", "\n", " Phi.Set((1 * x/Norm(x)), BND)\n", " solvers.BVP(bf = a, lf= f, pre=prec, gf=sol, maxsteps=30, tol = 1e-10, print=True)\n", "\n", " \n", " \n", " energy = Integrate( InnerProduct(mu * ( - grad(Phi)), ( - grad(Phi))), meshRef, definedon=meshRef.Materials(\"inner|insulation\")).real\n", " \n", " return sol, energy\n", "\n", "sol_ref, energy_ref = calcRef()\n", "\n", "\n", "Phi = sol_ref.components[0]\n", "H_ref = -grad(Phi)\n", "B_ref = mu * H_ref\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "energy:\t3.0876040950623074e-07\n" ] } ], "source": [ "#energy:\t3.10067858198899e-07\n", "#eddy current losses:\t5.042166093099941e-07\n", "\n", "\n", "# stab \n", "# energy:\t3.100512177819719e-07\n", "# eddy current losses:\t5.041911557192412e-07\n", "\n", "print(f\"energy:\\t{energy_ref}\")\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "03aa9d3b523b494ea6d97293958e2288", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "048bc8ab4ec54b81ad93eb6f941f2aee", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L2Draw( H_ref[0].real, meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = -50, max = 0)\n", "L2Draw( H_ref[1].real, meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = -10, max = 10)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "63b1c494b6b5483caae4d83faf07c38d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "961a8876d47b45f29f9c4efc6651172f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L2Draw(B_ref.real[0], meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False})\n", "L2Draw(B_ref.real[1], meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = - 5e-5, max=5e-5)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7c55654529da4249a6369a1635f879d3", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L2Draw(B_ref.Norm(), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = 0, max = 1e-4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4.1.1 Multiscale with REf Mesh" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.2 Multiscale " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "maxh_edges (0.002, 0.0006000000000000001)\n", "('outer', 'outer', 'multiscale', 'gap', 'gap')\n", "{'left', 'bottom', 'iright', 'ibottom', 'ileft', 'top', 'itop', 'right'}\n" ] } ], "source": [ "mg = importlib.reload(mg)\n", "mesh2DLaminates = mg.mesh2DLaminates\n", "cMeshMS = mesh2DLaminates(D, d, ff, numSheets, multiscale=True, modelHalfAir=modelHalfAir, onlySmooth=False, \n", " onlyRough=False, domainNameHalfAir=\"multiscale\", maxh_edges= (maxh_edges*10, maxh_edges*3), rotated=True, modelGap=True, maxh = d/2)\n", "# cMeshMS = mesh2DLaminates(D, d, ff, numSheets, multiscale=True, modelHalfAir=modelHalfAir, domainNameHalfAir=\"smoothFrame\", onlySmooth=onlySmooth)\n", "meshMS = cMeshMS.mesh\n", "print(meshMS.GetMaterials())\n", "print(set(meshMS.GetBoundaries()))\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a51f3927e5cb40c99be6aaff46a5595f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {}, 'ngsolve_version': '6.2.2…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ngsolve.webgui import Draw\n", "L2Draw.drawFunc=Draw\n", "L2Draw(CF([1, 2, 3, 4, 5, 6]), meshMS)\n", "from myPackage import drawBndAll\n", "\n", "# drawBndAll(meshMS, drawFunc=Draw, block=False)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "import importlib\n", "import MS_helper_functions as ms\n", "ms = importlib.reload(ms)\n", "cl_Phi = ms.cl_Phi\n", "\n", "getIntegrand4BFI = ms.getIntegrand4BFI\n", "cl_gradgradMS = ms.cl_gradgradMS\n", "cl_curlcurlMS = ms.cl_curlcurlMS\n", "pyLobatto = ms.pyLobatto\n", "pydxLobatto = ms.pydxLobatto\n", "getPhiPhiValue = ms.getPhiPhiValue\n", "pyPhiFunction = ms.pyPhiFunction\n", "pyPhiZero = ms.pyPhiZero\n", "pyPhiConst = ms.pyPhiConst\n", "\n", "\n", "cl_Phi.numSheets = numSheets\n", "cl_Phi.dFe = cMeshMS.dFe\n", "cl_Phi.d0 = cMeshMS.d0\n", "cl_Phi.mesh = meshMS\n", "\n", "cl_Phi.modelHalfAir = modelHalfAir\n", "cl_Phi.orientation = 1\n", "\n", "if False:\n", " import cempy as cp\n", " importlib.reload(cp)\n", " \n", " \n", " cl_Phi.phiFunction = cp.phiFunctions.Lobatto\n", " cl_Phi.dzPhiFunction = cp.phiFunctions.dxLobatto\n", "else:\n", " cl_Phi.phiFunction = pyLobatto\n", " cl_Phi.dzPhiFunction = pydxLobatto\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "force_full_Phi = True\n", "\n", "def calcMultiscale(orderPhi, mesh, drawPhis=True, couple_fluxes=False):\n", "\n", "\n", " if drawPhis:\n", " # cl_Phi.plotEvaluated(orderPhi, nFig=1)\n", " cl_Phi.plotEvaluated(orderT, nFig=1)\n", " cl_Phi.plotDirectEvaluated(orderT, nFig=1)\n", "\n", " VSpace = []\n", " # # u0 \n", " VSpace.append(H1(mesh, order=order0+1, dirichlet=\"left|right\")) \n", " \n", " # ui * phi i\n", " for phi_i in orderPhi: \n", " VSpace.append(H1(mesh, order=phi_i.fes_oder+1, definedon=phi_i.material, dirichlet=phi_i.dirichlet))\n", "\n", " \n", " \n", " VSpace = FESpace(VSpace)\n", " sol = GridFunction(VSpace, \"sol\")\n", " \n", " # multiscale container\n", " gradgradMS = cl_gradgradMS(orderPhi, sol, addPhi0Outer=True, secondOrder=False)\n", "\n", "\n", "\n", " a = BilinearForm(VSpace, symmetric=True)\n", " f = LinearForm(VSpace)\n", "\n", " a += muAir * grad(gradgradMS.trials[0]) * grad(gradgradMS.tests[0]) * dx(\"outer\")\n", " # a += gradgradMS.trials[0] * gradgradMS.tests[0] * dx(\"multiscale\")\n", " a += gradgradMS.getIntegrand4BFI(gradgradMS.gradu_pack, gradgradMS.gradv_pack, muAir, muAir, force_full_Phi=force_full_Phi, checkDimensions=False) * dx(\"gap\")\n", " a += gradgradMS.getIntegrand4BFI(gradgradMS.gradu_pack, gradgradMS.gradv_pack, muFe, muAir, force_full_Phi=force_full_Phi, checkDimensions=False) * dx(\"multiscale\")\n", "\n", " \n", "\n", " # couple fluxes\n", " if couple_fluxes:\n", " # [dn u] [ dn v]\n", "\n", " alpha = 2000\n", " h = specialcf.mesh_size\n", " \n", "\n", " a += alpha*order0**2/h * gradgradMS.getIntegrand4BFI(gradgradMS.gradu_trace_n_pack, gradgradMS.gradv_trace_n_pack, muFe, muAir, force_full_Phi=force_full_Phi) *ds(smoothbnd)\n", " a += -alpha*order0**2/h * gradgradMS.getIntegrand4BFI(gradgradMS.gradu_trace_n_pack, gradgradMS.gradv_trace_n_pack[:1], muFe, muAir, force_full_Phi=force_full_Phi) *ds(smoothbnd)\n", " a += alpha*order0**2/h * gradgradMS.getIntegrand4BFI(gradgradMS.gradu_trace_n_pack[:1], gradgradMS.gradv_trace_n_pack[:1], muFe, muAir, force_full_Phi=force_full_Phi) *ds(smoothbnd)\n", " a += -alpha*order0**2/h * gradgradMS.getIntegrand4BFI(gradgradMS.gradu_trace_n_pack[:1], gradgradMS.gradv_trace_n_pack, muFe, muAir, force_full_Phi=force_full_Phi) *ds(smoothbnd)\n", "\n", " prec = Preconditioner(a,type=\"direct\") \n", "\n", "\n", " # dirichlet boundary values\n", " sol.components[0].Set((x/Norm(x)), BND)\n", " \n", " solvers.BVP(bf = a, lf= f, pre=prec, gf=sol, maxsteps=30, tol = 1e-20, print=True)\n", " \n", " H_MS = sum(gradgradMS.gradsol_comp)\n", "\n", "\n", " energy = Integrate(gradgradMS.getIntegrand4BFI(gradgradMS.gradsol_pack, gradgradMS.gradsol_pack, muFe, muAir, force_full_Phi=force_full_Phi, checkDimensions=False), mesh, \n", " definedon=mesh.Materials(\"multiscale\")).real\n", "\n", " \n", " # print(\"a norm\", a.mat.AsVector().Norm())\n", "\n", " # print(\"ansatz\", gradgradMS.ansatz)\n", " return sol, energy, gradgradMS, H_MS\n", "\n", " \n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[2KCG iteration 1, residual = 0.006036466925596448 \n", "\u001b[2KCG iteration 2, residual = 3.722026732876261e-17 \n", "\u001b[2KCG iteration 3, residual = 4.357341935245324e-31 \n", "-grad(u0_outer) - grad(u1 * pyLobatto(1)) - grad(u2 * pyLobatto(2)_Fe) - grad(u3 * pyLobatto(2)_ins)\n", "diff energy 3.1066860884309816e-07 3.0876040950623074e-07 1.908199336867412e-09 0.6180194345249775 %\n", "[pyLobatto(1), pyLobatto(2)_Fe, pyLobatto(2)_ins]\n" ] } ], "source": [ "\n", "\n", "\n", "if \"curlcurlMS\" in locals():\n", " del curlcurlMS\n", "if \"gradgradMS\" in locals():\n", " del gradgradMS\n", "\n", "\n", "orderPhi = [\n", " \n", " cl_Phi(1, fes_order=1, material=\"multiscale|gap\", dirichlet=\"itop|ibottom|left|right\", modelHalfAir=modelHalfAir), \n", " cl_Phi(2, fes_order=1, material=\"multiscale|gap\", dirichlet=\"itop|ibottom|left|right\", inAir=False, modelHalfAir=modelHalfAir), \n", " cl_Phi(2, fes_order=1, material=\"multiscale|gap\", dirichlet=\"itop|ibottom|left|right\", inIron=False, modelHalfAir=modelHalfAir), \n", "\n", " ]\n", "\n", "sol_MS, energy_MS, gradgradMS, H_MS = calcMultiscale(orderPhi, meshMS, drawPhis=False, couple_fluxes=False)\n", "\n", "\n", "print(gradgradMS.ansatz)\n", "print(\"diff energy\", energy_MS, energy_ref, energy_MS - energy_ref, (energy_MS - energy_ref)/energy_ref * 100, \"%\")\n", "u_MS = sum(gradgradMS.sol_comp[:len(gradgradMS.orderPhi)])\n", "print(orderPhi)\n", "\n", "# J_MS = - (curlcurlMS.curlsol_comp[0] - curlcurlMS.curlsol_comp[1])\n", "# L2Draw((J_ref.imag, J_MS.imag), meshRef, settings = {\"Objects\":{\"Wireframe\":False}}, min = -20, max=20, diff=False)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0 1 2 3 4 5 6\n", "-- ------------------ ------------- -------------- ------------ ----------------- --------------- ------------------ ----------------\n", " pyPhiConstant pydxLobatto(1) pyLobatto(1) pydxLobatto(2)_Fe pyLobatto(2)_Fe pydxLobatto(2)_ins pyLobatto(2)_ins\n", "0 pyPhiConstant x x x x\n", "1 pydxLobatto(1) x x x x\n", "2 pyLobatto(1) x x x\n", "3 pydxLobatto(2)_Fe x x\n", "4 pyLobatto(2)_Fe x x x\n", "5 pydxLobatto(2)_ins x x\n", "6 pyLobatto(2)_ins x x x\n" ] } ], "source": [ "#gradgradMS.generateCouplingMatrix(muFe, muAir, force_full_Phi=force_full_Phi)\n", "gradgradMS.printCouplingMatrix(sparsity=True);\n", "#assert gradgradMS.checkCouplingMatrxiSymmetric(1e-3) == True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3 Comparison " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "\n", "start = -D/2*1.01\n", "end = -D/2*0.9\n", "\n", "start = -d/2\n", "end = d/2\n", "\n", "\n", "plt.figure(2)\n", "start = -d/2\n", "end = d/2\n", "\n", "pnt1 = [-d/2*0.99, start, 0] \n", "pnt2 = [-d/2*0.99, end, 0] \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "436fa33a95e148c591769676170c7dd1", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "start = -d/2\n", "end = d/2\n", "\n", "plt.figure(3)\n", "evalOnLine(H_MS[0] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=True, label=\"MS\", show=False, N=1000);\n", "evalOnLine(H_ref[0] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"\", show=False, clear=False, label=\"ref\", N = 1000, title=r\"$H_x$\");\n", "\n", "\n", "\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3ad0d1120c0640fc810ed890f34fe038", "version_major": 2, "version_minor": 0 }, "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAACH1UlEQVR4nO3deXxU9b0//tfnzCSTBLIHCCGBLBAWAZFFQlxAMYC11lZv1Xq/rUu1tUqp0P56a3tvpfa2etsKlt5aW66l9lrtorbX1laNLFYJUfZdEhIgCSRA9kDWmfP5/XHmnDkzmewzme31fDwCkzMnyeecWc573p/35/MRUkoJIiIiIooYSqAbQERERESjiwEgERERUYRhAEhEREQUYRgAEhEREUUYBoBEREREEYYBIBEREVGEYQBIREREFGEYABIRERFFGAaARERERBGGASARERFRhGEASERERBRhGAASERERRRgGgEREREQRhgEgERERUYRhAEhEREQUYRgAEhEREUUYBoBEREREEYYBIBEREVGEYQBIREREFGEYABIRERFFGAaARERERBGGASARERFRhGEASERERBRhGAASERERRRgGgEREREQRhgEgERERUYRhAEhEREQUYRgAEhEREUUYBoBEREREEYYBIBEREVGEYQBIREREFGEYABIRERFFGAaARERERBGGASARERFRhGEASERERBRhGAASUcT6+9//DiEEfvvb33q9/84770RcXBwcDscot4yIyL8YABJRxNq3bx8AYP78+X3eP3fuXFgsltFsFhGR3zEAJKKItW/fPsTGxmLmzJm97mtpaUFlZSUWLFgQgJYREfkXA0Aiilh79+7tM8O3f/9+SCn7zA4SEYUya6AbQEQUCA0NDaiqqsLy5cvR3Nzc6/5du3YB6Lt7mIgolAkppQx0I4iIRltxcTFWrFjR7z7R0dG4dOkSoqKiRqlVRESjgxlAIopIe/fuBQC8+OKLmDx5cq/7P/e5z2HSpEkM/ogoLDEAJKKItG/fPsTExOCee+6B1er+VtjW1obz58/j1ltvBQA0NzcjNTUVzc3NiI+PBwC8+uqrePbZZ/HBBx+MetuJiEaKg0CIKCLpU7x4Bn+AawCIPgI4KSkJubm5OHjwIADA4XDgu9/9Ln7wgx+MapuJiHyFASARRZyBpnjRu4fNA0AWLFiAAwcOAAB++9vfIisrC0uXLvV7W4mI/IFdwEQUcfbt2+eW4fO0d+9eWK1WzJ0719imB4BdXV343ve+h1dffXW0mktE5HPMABJRxBloBZC9e/di1qxZsNlsxjY9AHz++eexYMECLFy4cFTaSkTkD5wGhohoEJqbm5GRkYHExERs3boVs2bNCnSTiIiGjV3ARESDkJSUhEmTJmHJkiUM/ogo5DEDSEQ0CJcuXcK0adNQUlKCnJycQDeHiGhEGAASEQ3C2rVrAQAbN24McEuIiEaOg0CIiPpx4MABJCYm4ujRo/jP//zPQDeHiMgnmAEkIiIiijDMABIRERFFGAaARERERBGGASARERFRhOE8gCOgqirOnTuH+Ph4CCEC3RwiIiIaBCkl2trakJGRAUWJzFwYA8AROHfuHLKysgLdDCIiIhqG6upqZGZmBroZAcEAcATi4+MBaE+ghISEALeGiIiIBqO1tRVZWVnGdTwSMQAcAb3bNyEhgQEgERFRiInk8q3I7PgmIiIiimAMAImIiIgiDANAIiIiogjDGkA/k1LCbrfD4XAEuilBwWKxwGq1RnTdBRERUaAxAPSj7u5u1NbWor29PdBNCSpxcXGYOHEioqOjA90UIiKiiMQA0E9UVcWpU6dgsViQkZGB6OjoiM96SSnR3d2Nixcv4tSpU5g2bVrETsBJREQUSAwA/aS7uxuqqiIrKwtxcXGBbk7QiI2NRVRUFM6cOYPu7m7ExMQEuklEREQRh+kXP2OGqzeeEyIiosDilZiIiIgowjAAJCIiIoowDACpl/vuuw9CCDz88MO97nvkkUcghMB9990HALhw4QK+/OUvY/LkybDZbEhPT8fKlSuxa9euUW41ERERDRYDwCC1sbgMm7aWe71v09ZybCwu8+vfz8rKwu9//3t0dHQY2zo7O/HKK69g8uTJxrY77rgDBw8exIsvvoiysjK88cYbWLZsGRobG/3aPiIiIho+jgIOUhZFYIMzyFuzfJqxfdPWcmwoLsO6ony//v358+ejsrISr7/+Ov71X/8VAPD6668jKysLubm5AIDm5mZ88MEH2LFjB5YuXQoAmDJlCq6++mq/to2IiEJM3RHg8B+B674OxCQGujUEBoCjSkqJjp7BrQjy4HU56HGo2FBchh6Hiq8sy8MvdlTgZ9tO4qs3TsWD1+Wgvds+qN8VG2UZ1hyE999/P7Zs2WIEgL/+9a/xwAMPYMeOHQCAsWPHYuzYsfjLX/6CgoIC2Gy2If8NIiKKAM9fo/3fVgfc/qvAtoUAMAAcVR09Dsz67ttD/rmfbTuJn2072ef3Azn25ErERQ/9of785z+Pxx9/HKdPn4YQAjt37sTvf/97IwC0Wq34zW9+g4ceegjPP/885s+fj6VLl+Luu+/G3Llzh/z3iIgozJ3+INAtICfWAFKf0tLScMstt+DFF1/Eli1bcMsttyAtLc1tnzvuuAPnzp3DG2+8gZUrV2LHjh2YP38+fvOb3wSm0UREFLw6mgPdAnJiBnAUxUZZcOzJlUP6Gb3bN8oi0OOQ+OqNU/GVZXlD/rvD9cADD2D16tUAgJ///Ode94mJiUFRURGKiorw3e9+Fw8++CCeeOIJY6QwERERAKDncqBbQE4MAEeREGJIXbGbtpbjZ9tOYl1RPtYsn2YMAImyKG4DQ/xp1apV6O7uBgCsXDm44HXWrFn4y1/+4sdWERER0UgwAAxS5tG+erCn/+9tdLC/WCwWHD9+3Lht1tDQgM9+9rN44IEHMHfuXMTHx2PPnj340Y9+hNtuu83vbSMiIqLhYQAYpByqdAv+dPr3DlWOWlsSEhK8bh87diwWL16MjRs3oqKiAj09PcjKysJDDz2Eb3/726PWPiIiCnLWGMDeGehWkImQUo5eJBFmWltbkZiYiJaWll5BUmdnJ06dOoWcnBzExMQEqIXBieeGiCjC/GQ6cKlOu72+JbBtQf/X70jBUcBERETkX7FJgW4BeWAASERERP4Vk+S63dPR5240ehgAEhERkX/Zxrpucy7AoMAAkIiIiPzMtBxpZ3PAWkEuDACJiIjIz0zjTTuaAtcMMjAAJCIiIv8yTzjCLuCgwACQiIiI/IwZwGDDAJCIiIhGD2sAgwIDQCIiIvIvyQxgsAnbADA7OxtCiF5fjz76KADgvvvu63VfQUFBgFsduqSU+NKXvoSUlBQIIXDgwIFAN4mIiIIGawCDTdiuBbx79244HA7j+yNHjqCoqAif/exnjW2rVq3Cli1bjO+jo6NHtY3h5K233sJvfvMb7NixA7m5uUhLSwt0k4iIKFiYM4DsAg4KYRsAjhs3zu37p59+Gnl5eVi6dKmxzWazIT09fbSbFnK6u7sHDI4rKiowceJEFBYWjlKriIgodLALONiEbRewWXd3N1566SU88MADEMI1GeWOHTswfvx45Ofn46GHHsKFCxf6/T1dXV1obW11+wpHy5Ytw+rVq7Fu3TqkpaWhqKgIx44dwyc+8QmMHTsWEyZMwOc//3nU19cD0LrTv/rVr6KqqgpCCGRnZwf2AIiIKHi1NwS6BYQICQD/8pe/oLm5Gffdd5+x7eabb8bvfvc7bNu2Dc888wx2796NG2+8EV1dXX3+nqeeegqJiYnGV1ZW1tAaIiXQfXn0v8yp90F68cUXYbVasXPnTjz99NNYunQp5s2bhz179uCtt97C+fPnceeddwIAfvrTn+LJJ59EZmYmamtrsXv37iH/PSIiCmPm69BlBoDBIGy7gM1eeOEF3HzzzcjIyDC23XXXXcbt2bNnY+HChZgyZQrefPNN3H777V5/z+OPP45169YZ37e2tg4tCOxpB36YMfB+vvbtc0D0mCH9yNSpU/GjH/0IAPDd734X8+fPxw9/+EPj/l//+tfIyspCWVkZ8vPzER8fD4vFwi51IiLq3+WLWkBo6pGj0Rf2AeCZM2fw7rvv4vXXX+93v4kTJ2LKlCkoLy/vcx+bzQabzebrJgalhQsXGrf37t2L7du3Y+zYsb32q6ioQH5+/mg2jYiIQo05A2jv0HqnbL2vKTR6wj4A3LJlC8aPH49bbrml3/0aGhpQXV2NiRMn+q8xUXFaNm60RcUN+UfGjHFlDFVVxa233or/+q//6rWfX88XERGFp8sXGQAGWFgHgKqqYsuWLbj33nthtboO9dKlS1i/fj3uuOMOTJw4EadPn8a3v/1tpKWl4TOf+Yz/GiTEkLtig8H8+fPx2muvITs72+08EhERDY5HLXp7A5CSE5imEIAwHwTy7rvvoqqqCg888IDbdovFgsOHD+O2225Dfn4+7r33XuTn52PXrl2Ij48PUGuD16OPPorGxkZ87nOfw0cffYTKykq88847eOCBB9zmWiQiIvLKczDi5YuBaQcZwjqds2LFCkgvI2BjY2Px9ttvB6BFoSkjIwM7d+7Ev/3bv2HlypXo6urClClTsGrVKihKWH+GICIin2AAGGzCOgCk4dmxY0evbdOmTet3IM1jjz2Gxx57zH+NIiKi0GdLBLpaGAAGAaZviIiIyL/03rgxzmVCL9cHri0EgAEgERER+Z0eADqXaWUGMOAYABIREZF/6RnAsQwAgwUDQCIiIvIzPQM4XvufXcABxwCQiIiIRge7gIMGA0A/8zYNTaTjOSEiCn8bi8uwaatzeVWPLmDH5XpsfOfjALWMAE4D4zdRUVEAgPb2dsTGxga4NcGlvb0dgOscERFR+LEoAhuKywAAazwGgVikA2PUtkA1jcAA0G8sFguSkpJw4cIFAEBcXByEEAFuVWBJKdHe3o4LFy4gKSkJFosl0E0iIiI/WbN8Gkoq6rGhuAx3pnUgHcAbRxpwnRyLZHEJcd312FhchrVF+YFuakRiAOhH6enpAGAEgaRJSkoyzg0REYWvwrw0lFY2oq61E+kK8JcDZ7EkeSJwuRzvlO7HwuVTA93EiMUA0I+EEJg4cSLGjx+Pnp6eQDcnKERFRTHzR0QUIRyqRGFeKkS19r0QApejx2Hc5XJcO74bl1XWhAcKA8BRYLFYGPQQEVHEsSgCJRUNENFaoOeQQMlFG7KtwOWLVbAokV0aFUgcBUxERER+JfRBIBCok6kAgKIsBwBttDCNPgaARERE5HObtpZjQ3EZCvNS3bbXIgUAYG+qwYbiMmYBA4QBIBEREfmcQ5VYV5QPVUroIZ6EwAWZDACwdZxHYV4qHKwDDAgGgERERORz+vQupZWNRhewBHDO2QU8UTSipKLByABu2lrO7uBRxACQiIiI/MIYBez8XkKgTmpdwEniMpZmawsl3P2rXewOHmUcBUxERER+oY8CtsRo30sItCEOLTIOiaIdYzvOYkNxBwBgXVE+1iyfFsDWRhZmAImIiMgv9DpAT9VyPACg6+IpAEBBbgqDv1HGAJCIiIj8Qq8DVFUVAIzJYKqltiZwltBWyirMS2MN4ChjAEhERER+41AlrM5oQx8PrNcBjhMtAIA/7almDeAoYwBIREREfmNRBFRVHwWsBXj1MhEAkIpWjIm2oLqpA1nJsewGHkUMAImIiMhvHKpElMU9s9eABABAqmjB5W4HEmKsqG7qwKat5YFoYkRiAEhERER+s9bLIJAGqQWAaaIVANDaaeek0KOMASARERH5lZDuXcCuAFCrAUyIsWJRdgosiuBAkFHCAJCIiIj8ylgJRApEW4SxGkg6GhGNHrR22vH6Pq4NPJoYABIREZFf6R27iXFWdDsk6pCCZjkGVqFimjgLm1VBdVMHCvNSORBklDAAJCIiIr+yOrN6ze12JMRYAQh8LCcDAKaLKnTZVWQlx2JRdkoAWxlZGAASERGRX+ldwJNTx6C10w4BoELNAADkKHUQAG6fn8kawFHEAJCIiIj8TAsATze0Iys5FhJApZwIAMgV5yAB1gCOMgaARERE5Fd6BjA7bYwx6bMrAKzDWJuVNYCjjAEgERERjYpT9e0ozEtFdVMHkrNmAgCyRR0ud3UjKzkWJRUNnAx6lFgD3QAiIiIKc855AG+YMR49GSlQpURuThJ66iyIFd2YKJpw+/zpsCgCJRX1cKjS6wTS5DvMABIREZFf6VV9N8yYgLVF+SjMS8NPtlaiSo4HAGSLWqP2r7SykXWAo4AZQCIiIvIzLQMohHtgd0qmIw+1uCa5GT92jv5dV5TPOsBRwAwgERERjQpFCGzaWo4NxWVYV5QPNWUqACCm5VSAWxZ5GAASERGRX+mjgCEEHKpEQa424XPejCu1/8U5RFsUrCvKR0lFPecCHAUMAImIiMjPXF3Aeg3ghuIy/E9ZDABgpnIG3Q4VpZUNrAEcJWEbAK5fvx5CCLev9PR0434pJdavX4+MjAzExsZi2bJlOHr0aABbTEREFJ6EkQDUwo41y6ehMC8V/1ebAlUKTBDNuCkLKKlo4FyAoyRsA0AAuOKKK1BbW2t8HT582LjvRz/6ETZs2ID//u//xu7du5Geno6ioiK0tbUFsMVEREThRzozgIpzEMimreUoqWhAanIyTkktOdN19hAK81JRUtGAezaXshvYz8I6ALRarUhPTze+xo0bB0DL/j377LP4zne+g9tvvx2zZ8/Giy++iPb2drz88ssBbjUREVF4ER43HKo0JoQ+JqcAAOYoZ/DyQwVGEMhuYP8K6wCwvLwcGRkZyMnJwd13343KykoAwKlTp1BXV4cVK1YY+9psNixduhQlJSV9/r6uri60tra6fREREVH/hJEB1MKOtUX5RrB3TM0GAMwQp3HP5lKUVDRwKphRELYB4OLFi/Hb3/4Wb7/9NjZv3oy6ujoUFhaioaEBdXV1AIAJEya4/cyECROM+7x56qmnkJiYaHxlZWX59RiIiIjCQ+95APVu4Lo4LdCbJc6wBnAUhW0AePPNN+OOO+7AnDlzcNNNN+HNN98EALz44ovGPp4TUkope20ze/zxx9HS0mJ8VVdX+6fxREREYUS/sgpTDeCG4jIU5qVi8ZJlAIBcUYt40cUawFEStgGgpzFjxmDOnDkoLy83RgN7ZvsuXLjQKytoZrPZkJCQ4PZFREREA3EfBKLXAJZUNODFw+2okWlQhMSVogxZybGsARwFERMAdnV14fjx45g4cSJycnKQnp6O4uJi4/7u7m689957KCwsDGAriYhoVDVWAmf3BboVkcMZ1JlrAI/XtuFDdQYA4PaU06hu6mA38CgI2wDwG9/4Bt577z2cOnUKH374If7lX/4Fra2tuPfeeyGEwGOPPYYf/vCH+POf/4wjR47gvvvuQ1xcHO65555AN52IiEbLpquAzTcATacD3ZKwJjwygABw9692oaSiAQW5KfhQnQkAmNS638gM3v2rXQFpa6SwBroB/lJTU4PPfe5zqK+vx7hx41BQUIDS0lJMmaINN//mN7+Jjo4OPPLII2hqasLixYvxzjvvID4+PsAtJyKiUVdVCiRnB7oVYUtICYjetfcAUJiXhtdOaQHgVeIkrpsSi5KK0W5h5AnbAPD3v/99v/cLIbB+/XqsX79+dBpERETBq/VsoFsQEcwB4O+/tMQYDAJMwGl1ArKV8ziw489YV/Sv7AL2s7DtAiYiIhq01nOBbkFE0OcB1JVU1DtvCWxV5wMAblL2AtBGCnMksP8wACQiImIA6Fd6DSA85gEsrWw0Nr/rDABviT2MZ4s/xobiMo4E9iMGgEREFFE2Fpdh09Zy943OLmBmnfzDNQjEtc2hSqwrykdhXiqkBHar09Eq4xDX04R54iQKclPYDexHDACJiCiiWBSBDZ5BYOs5ox6NWSf/MdcAri3KR0lFPUoqGnBlViLssOI9dS4A4N7U4yjMS2Mw7kcMAImIKKKsWT4NBbkpzsEHTpcvYkNxGdYV5QMAAw+fcy4Fp7jCDnMX8NJp4wAA7zq0buDprSUMxv2MASAREUWcwry0Xtu+eaO2vjsDD9/zXAoOcHUBF+SmYNO2kwCAHeo82KWCGUo1bp3cDYDBuL8wACQiooijL0VmFt913lif1qHKALUs/EgpvU4EvbYoH2uWT3Pb1oKx2Cu1LOzCrg8ZjPsRA0AiIoo4FkWYpiDRvL1rr7EKBYMO39HmgNYDavfzumlrOUoqGtyC8XfVBQCAGU3buSScHzEAJCKiiFNSUQ8F7lm+iaLBCEaYAfQd85lUFPeww6FKFOSmuG37m70AqhRYrHyMtJ5z7AL2EwaAREQUUfTBB8IjAEyHNiCBGUDfUqU08n6Kx1Jwa4vyoQhhjAQGgFqk4gN1NgAg99xf+Vj4CQNAIiKKKPrgg6wkm9v2RNEOAMhMjgXAwQe+okoJ1yhg713AmcmxOFjdYmx/1XE9AOAe205Aqnws/IABIBERRZS1zqlezjV3uG0fi3ZkJceipqkDG4rL8OGphkA0L+xoNYAa4ZEB1IPxySlxbtvfUReiVcZivOM8Sra9wSygHzAAJCKiiONQJbKSYty2JYh2VDe5gkJvU8XQ0GkZQI1A7y5gQOt2z3JmXgGgR8Rgz5hlAIB7Y3eyJtMPGAASEVHEsSgCZ5vb3baNhTn400alsutx5MyjgD0HgQCuKXnMwbdDSjzTdB02RT2Af798JzOAfsAAkIiIIo5DlSjITnbbluCsAcxKjoUqJeeg8xHVNA+gZxcwoGUBC3JTe20/KrOxoe0m3Fu0CACDcV9jAEhERBHHogjsPu1e4xcPLQCsbupAaWUjp4PxEbWfGkAAxhrMnhNz60orGxiM+wEDQCKiYNR0BuhqC3QrwpZDlXh0Wa7btnjh6oJMiLFyOhgfkaYaQM9pYADXQBBzraC2r/Y/52b0DwaARETBpvEU8NO5wKb5gW5J2FpblA+PeANJaIOACgBo7bSzDtBHVFMNoOc0MIBrIEhpZWOvn9OVVDRg9+lGPhY+xACQiCjYVO3S/r98Ab2iFPKZvacvun0fLRxIgSvrWtXYzq5HH+hrLWAzb2szm2UmxzIj62MMAImIgk1Chuv25Yt970cjclVWknG7QcYDANJFI/QYpaapg12PPjBQDSCgr83cgILcFMTHWHvdz8fC9xgAEhEFGyXKdbvpTODaEeYevDbHuF0rtezTD6J+DSFVYzuzTiMnTSuBAH1nANcV5aOmqQNtnfZe9+s1mZyc23cYABIRBRtTAIJmBoD+Ik3nuVqOAwDMUyqwUtltbC/ITQHAOsDh2Fhchk1by91q+fT06qat5W7nVK8DrGlyX51F1+oMCjk5t+8wACQiCjYMAEeFeXTqxaSrjNv6fICAVrPGOsDhsSjauXvhg0qjBhAQxrQvnud0oDrAgtwUrFk+zY8tjiwMAImIgo1bAFgVuHaEOak6AACqFCiOW2Vst8LBKUh8YM3yaVhXlI/N758yOn5/vfMUNhSXYV1Rfq9gTq8D7CsI7GsACQ0PA0AioqBjCjZYA+g3+rxzEsD7ZzrxmuM6AMAYdPSagoQZwKHRu3/XLJ+GL16bY2QAf/nPU30G1HoG0FsQmOUcBbxpa/motD8SMAAkIgoS+kXTWwbQs2aKfMAZhKhQsCQ3BZdkDABgrHCvQ2Md4NDp3b+btpbjXxZkGtsVIfoMqNcW5WNRdooRBAJAtEULU6o5CtjnGAAS0eBV79YmJz7xVqBbEpb0i+b/7a9xbWypxqZ3T7AOzQ9UZ6AtAeyqbERSkhboxcM9AGQd4NDogfK6onxsKC7D117Zb2QA7VKb06+vWj69G1j/+bIf3Ix1zgEizMT6FgNAIhq8P34eaKwAXrkr0C0JS3oX2F/MAaCjG7979yNmP/zB6AJWsPamaWgXsQCAMegEwKXIhkv/IFNaqZ23sguX3CZ/qWnqwN2/2uX1Z0sq6gHArUZQryU0308jxwCQiAbP0RPoFoQ1PfuRlxbntv0TmV3MfviB6hwEIqFNUHzMuRKZ3gXMOsDhWbN8mtGNq2fzFKGdzIXZWpa1tLLRaz3f4pxUrwNE9CBwcU7fo4RpaHpPt01E1JeYBKCdn8D9Zc3yaSipqMfp05eAaNf25nMnsa5oKQCte02fM41GRhoZQAGHKhEdlwj0AGPRey66zORYZgCHYFF2Cg7XtKCty31S592nm1GYlwtVSq/ns7/nNqeA8S1mAIlo8GzxgW5B2CvMS4MC1X1b6mUAYB2aj+kTQasQsCgCH1/WMq+ZSu/VJmqaOrD7dCMHggxAH8hkUUSv4A/Qsq1al3oaP8gEGANAIho8W0KgWxD2SirqTZPmamTTGWwoLmMdmo9J1T0DuPzaawEAWTgPK7TgRQ+39aXIGID3z1z/5yJNt3j+ggUDQCIaPAaAfrVpazlKKxuheASAqaIVgJY5YRbKdyT0UcACa4vycSl6PC5LG6KEA1PEeed9WvDX2mlHFruBB7Rm+TQU5KYYtX8A3D7QxMdYUZCbwvMYBBgAEtHgmbuAnQX05Dv6KGDPDGCi0LqAM52T4TIL5RtSdQWAAOCQQI0yCQCQJ84Z+7V22pEQY0V1UwfP/QA2FpfhrMd6vuYz1tppx9mmDnb/BgEGgEQ0eDGmDGBHc8CaEa70UcCZSTFu2xOhBYA1nAzXp6R0DwAtisBxezoAIFfUuu3b2mk3VqdgBrZvFkWguqkDCTHex5hGWy2oburgih5BgAEgEQ2esLhuX74QuHaEKYcqsa4oH4rQApMmORaAKwPIOjTfMtcAAtr570maCsA9Awho516VkgNxBqBP19La6RoAYs5od9olP8QECQaARDR45iXKLjEA9DW9W6y2qR0A0CzHAAASnBlAZqF8y1sGcEdDEgAgT3EPAFs77SitbGTw0g9jKUMP5gDwkWV5/BATJBgAEtGAvK5Re/kiAK5R62sOVWKSswu4GVrNZYzogQ3dzEL5mCsDqHGoEmMzZwLQu4B7B3oMXvqmjwDeUFyG7FTXZObuZ0tgXVE+g+ggELYB4FNPPYVFixYhPj4e48ePx6c//WmcOHHCbZ/77rsPQgi3r4KCggC1mCh46W/sh2qaXBsvXcCmreUMRnzMogjUNWsZwDYZC1Vq5/Y/rb9mFsrHpDPAk0K7FK4tysek3NlQIZAkLiMVrb1+piBXW8mCH3p600cAA0D9pS6v+3x4uhFrlk/jIJAgELYB4HvvvYdHH30UpaWlKC4uht1ux4oVK3D58mW3/VatWoXa2lrj6+9//3uAWkwUvPTRqYerXQHg/sOHODedHzhUiYxEm3YbirGE1met/0QMtIsqs1C+IU1LwRmiYnFWTQPQuw4QABQh+KGnDxuLy1CYl4as5Fhc6nLNErAkN9m4vft0MweABImwXQrurbfecvt+y5YtGD9+PPbu3Yvrr7/e2G6z2ZCenj7azSMKKR+eakBpZSPuGWuBc35cxNZ8gBty7sb2igaokgGgr6wtysdL5dFAB6BCwY967sQ3o/4IAEhAOzph47JkPqIvBaeaciEOVcKROg1ouog85Rw+cmhdwkIAUuqrWPBDjzd6T4GZVRFYnJMCOGPpq3M4B2CwCNsMoKeWlhYAQEpKitv2HTt2YPz48cjPz8dDDz2ECxf6Lmzv6upCa2ur2xdRJCjM0zIilzq7jW0zlGr8v5r1bveTbwjhqk37X8unje0JwjUdDCeE9gFV7bVpbVE+mmKnAADyRY2x3fwZhxNy96afC70LWGdXpVvGb/7kZHb/BomICACllFi3bh2uvfZazJ4929h+880343e/+x22bduGZ555Brt378aNN96Iri7vtQtPPfUUEhMTja+srKzROgSigNJrezxXqFhu2Y91zjdzXgx9R5+gWAgFbd3AGXU8AC0DCHA6GF/RM9eey5PVjZkBALhSqfD6c5yQuzc9+6eI/s/JozdOG6UW0UAiIgBcvXo1Dh06hFdeecVt+1133YVbbrkFs2fPxq233op//OMfKCsrw5tvvun19zz++ONoaWkxvqqrq0ej+URBQRHCqEczK61sYE2Uj82ZpE24bZcCNquCNmgjKhNEO5cl8yHXUnDul8ILiXMBAHOUM0iN6X2OOSF3b2uWT0NhXipKKhqQN26M231LcpJN3/F9IliEfQD41a9+FW+88Qa2b9+OzMzMfvedOHEipkyZgvJy7wWqNpsNCQkJbl9EkWDT1nKUVDTA6gwAt9hXAgB6oGWiGIz4mD7djlDQZVfRKp0BINq5LJkPSYceALprjJ6EDmsiotCDrK7eWUBmYHvbWFwGVWqDxSouug+25FkKTmEbAEopsXr1arz++uvYtm0bcnJyBvyZhoYGVFdXY+LEiaPQQqLQ4VAlspJjjYlz2xALAIiCHSkxYDDiY/p5tkst2HBlADkhtG/pXcDul8K1K6ajLmEOAKDAVtnrp5iB7c2iCJRWNvbaVpiXig9PNbg2DtBFTKMnbAPARx99FC+99BJefvllxMfHo66uDnV1dejo0BapvnTpEr7xjW9g165dOH36NHbs2IFbb70VaWlp+MxnPhPg1tOQVZUCxU8A9u6B96Uh09f31GsAL8tY4z575yUGI77mrAG0Wixo7bSjxbkiSDLaAHBZMl/Ray09awAB4NxYrV58pqMM8R7r2tqsCj/0mOive70LWOdQJUoqGoyJzTU8Z8EibAPAX/ziF2hpacGyZcswceJE4+sPf/gDAMBiseDw4cO47bbbkJ+fj3vvvRf5+fnYtWsX4uPjA9x6GrJfrwR2Pgu893SgWxKWSirqAQBxUdqbdxei0CW1i+IYdKGqsZ3BiA/pGcBuh0RmcixOS22qKn15Mk4I7SP9TF90wZkBXGA5iTbTurYA0GVXkZWsfQjihx7XAJCqxnav9+vnCgAzgEEkbOcBlAPMSxYbG4u33357lFpDo6b8HWD5dwPdirCzOCcVhXlpEDu1wESFQDtiYMMlxIlOVLAo3rec719WiwU1TR04oWj1y/nirNtuJRUNKMhNHfXmhQvVGWironcu5NyYWVAhkIkLSEML6pFo3KfXYG4oLjNGwUeyNcunobSyASUVDZg1MQHHal1TpBXmpeKjimrASAIyAAwWYZsBpAjV4H3aBhoZfd6u7h5tdn8VCi4739HHoBMAV6fwJT0DaLVaUZiXijKpBYB54hwUuOau47JkI9RPouDRm+ejKTYbADBPOel2X6szI8gJuTXmASDm4E+3KDvZy09RoDEApPDS470LgkbOoUrEWrUAT0KgXWrLlY0RWgDIYMSHjMBEoKSiAZNzZqBd2mATPZgizhu7cVmykTEygH1cCvWBIFcp3meGqGEdIIA+BoAIYdQEWsyniF3AQYMBIIUHm2lKHoe97/1o2CyKQI9dO7cqBFqhDUxIcQ5MYDDiQ1Jfo1ZgXVE+HBA4KTMAaKtT6NdQLks2Qvp0O310S+oDQeYJ7z0L/NCj0WcJcBsAIqUxRdRHp8zBId8fggUDQAoP8aape5rPBK4dYcyhSiTGWABoGRPPgQkMRnzIOTo1PjYaAFBa2YhyqdcBVvdaloxB9zCpriX3vNEnhJ5vrXTretfxQ49GnyXAm+qmDiw2TwTNDGDQYABIYcL0Fn7xROCaEcbWFuVDOM+zCoGTqpaRyhPnjH0YjPiG1OenEwocqlZbVaY6A0Clxm1fZqGGz3yevbkYk41uSxxiZYfbusD6M5wferTnXWllQ6/tFlOgt3AKawCDEQNACg+qw3W7nhdCv5GuedNOykkAgKmmkakMRnzEtBKIRdHqAC3pMwEA0zxGAjMLNXxSdXW1e/PYipmoi9fqABcrx10/Z9on0j/06M/PwrxUTE5xTfficKapC/NSoarm7GnknqtgwwCQwoNkADga9ImgU8bEGDVpuaIWwtk9xmDER1TXIBCHKrGuKB/VlskAgFxxDlbYobAOcMQGmi4MAKoSFwIArlGOeL0/0j/06BnqkooGVDX27gZWpcRXlk11bWAXcNBgAEjhwfwJs+Fk3/vRiOiBngqBajkeXdKKWNGNLKFNFM1gxEf0DzRCMabg+VuVFZdkDKKFA1PEeaisAxwxPQD0XArOrCb5agDANdaPYYGj1/2R/KFnY3EZdp9udBv84am0shG/+qd5EE3knadgxQCQwoM5A8gA0G/GRGtvGRcu9cABC05JbfBNrqlbksHIyLlq07Tz6FAlJiWPMeYDnC1Oue3P+eiGSfa9FJyuLm46uixjMUZexhXitLGddYCu7t9M80ofcA/xencBU7BgAEgha2NxGTZtdc7PZa4BbG/A82/vi9guGX8SzgtmWrw2CbTeDTzVNBAk0rvEfMJUAwhoF9qapg7sU6cBABYq7ueW89ENj5EB7Kdb8rEVM1GTtAAAcI1y1PWzpn0i9UOP3v1b4zECWEJbLaUgN4XzAAYxBoAUsvT1JzdtLXfPAAJ4dcfuiHxD9jvnBfN8Ww8K81JRYQSArgxgJHeJ+YzH/HR6HeCpOG1Agh4A6mc4k+vSDotUB84AAkBVglYHWMg6QIO5+zchpveqsq2ddihCm8fSLQPIADBoMACkkLVm+TQU5KZgQ3EZOrp63O57eJE27UAkvSGPBr0GcHZmElQpUaE6RwIr5zgowZf0wQnODKBeB/hOazYAYLqoRjzaIQFkJceixrkuLYPuoXINtunPWWcd4GJLGWzo7nV/JH7o0bt/s5JjjaXxzBJirEZt4JeX5o1282gQGABSSCvMSwMAdPVoAWCz1FaniOlpibg35NGgdwFLoS39dNKUAVRNIyojtUvMZ/TMlGl+OocqYUueiDPqeChCGsuT6RPwsg5w6KTp+dyfizE5uBQ9HtHoxhLlmLE9kldk0bt/q5s6EGVxP382q4LWTrvrnAxitDWNPgaAFNL0NyF9lv4GJAIA/nnoRMS9IY8GYyJoqSAzORYVMgOqFEgSl5EG1yLwDEZGRuqrTpgCE70OcI/UsoELWAc4cnJwGcC1K6bjVMq1AICblL29fxyR9aHHs/u3x+H+Wu+yq8bScNo5Gdx5ptHFAJBCmjFJrvOCWS+1NYHnpaoR9YY8apwZE0VRUNPUgS5Eo1aMAwBMVVx1gAxGRsiILNwzgIV5qdirTgcALBTuAWAk1qGNlBzEKGDdyeTrAQDLLfvhbfG4SDr/H55q6Lf712ZVUN3U0TsDyPq/oMIAkMKCHgA2OAPA1sYLWFeUjzXLpwWyWWHHvBTcuqJ8ZCbH4oTDtSQcByX4hpDeM4AlFQ2wT9Lq0eYpJ2GF6+IbiXVoIzbIQSAAcC5lEdqlDRNFo9t0MLpIPP/VTR2ItvQOI7rsKgrzUrEoO8WoX9VEzrkJBQwAKWRt2lqODcVlKMhNMbqAa6SWjcp1TkuyaWs5gxAf0gOTBdmpALRMX7lzSbi5opKDEnzFYxoYAKYVQbLQIuMwRnRhpqgy7o/EOrSRkkPITHUjGrVpSwAANyn7jO2RNvhpY3EZFNP56nb0nuPPvfsX8JYxpcBjAEghS78gKkIYGcC9znnSVlj24sBHOxiE+Jg+ClgoFjhUiczkWPxTnQsAWG7ZBwUqByX4gPQYBQy4RgLvOtVsmg/whNvPsexhaAazEohubVE+TqVcB0B7rusibUUWc/evN726fwF2AQcpBoAUsvQLYklFPSxCe4M5pLqmG5h/+X1kMQjxKeF8I1cUxRiU8KE6E50yCmmiFdmiztiXdYAj4CUDCLjqAPc46wA9B4JEUh2ab+hdwINTkXQNVAjMVU5hAhp73R/uH3rM2T9vo3+Bvrp/OQgkGDEApJDmUCWmJNmM7zsQjeftnwQAZFjbUM0gxKeMDKBQjGDEDiuOyBwAWjewjsHI8HmrAQRcdYCdE7WJibUJoV0BRyTWoY2EHOQoYF1XTBoOOD9k3j72cK/7w/lDz8biMry2r8bo6gbQa/QvoC391mcmlBnAoMIAkEKaRRE419xufK9CMdanTXQ0GW9UDEJ8Q88AwpkB1C8Gh9RcAMCVimvRdwYjI9BPBnBdUT7KrfnoklakiybkilquSztcxlJwg7sUOlSJztyVAIBFXR8a28N98NNdv9yFLTtPGUu+6RM8e+P2HLR3awNthhho0+hgAEghzaFKPHZjrut7KLgotbkAJ1lboUrJIMSH9AygIixGMKJKaWRFrlQqGIz4gHHGPAITvUvtn6fbsdvZDXydcpjr0g6TNJYoG9z5WluUj0pnHeA1ylHEolP7PQjPwU8bi8sw54m3cKC62et0L2bm5eBUKbH2KgX4r2zgja8CPe19/yAFDANACmlri/Lx6NIc43stAEwCACSpjSitbGQQ4kN6BlAoihGMlFY24pDUgvArxBm3qUkYjAyP6CMDCLjqAN93Dr65Tjnkdj+73odCzwAO/jl6MSYX58QE2EQPrlNc3cDhNvhJz/q1dTnQZVdhs/YfLugrfxh2/BDouQwceAn4uTZ1EbuAgwsDQAp5z+8oN26rUFAjteXh0kUTxqCDQYgPuUYBa28dejByWqajRcbBJnqQL6qN/RmMDJMzAPT2rNW73lsztEzUEuUYojgf4PBIh/PG4M+VxaLg7Z55AIDlyv5e94d6HeA1T29F/nf+juO1rW5Zvy577+ledHrgp2f974/bCRz9c+8d7Z0+by8NHwNACnmqw/Um5YCCJiSgTiYDAKaL6rD5RB4M9ImghbAAgKkOMA0Hnd3A5pGpDEaGyVij1tLrLr3r/bQ1GxdlAsaILswX5ex6Hw59lpIhZKYcqsS5CTcAAG607DM+FOlC8UPPXb/chTnr38ac9W+j/lI3uh0SrZ12t27d/ujPuSjY8YXmn2Plye+76lgpaDEApJAXJVwXulhbFADguDoZADBLOYOapg7sPt0YUm/IwUrvmjRnAPU6wFJ1JgCgQDnOYGTE9EC791u0eT7AD9Q5AIDrLQdZBzgMQ1kKTmdRBH5zNgPtIg7jRCvmiQq3+0PhQ8/G4jIj06dn+9o67WjrtLtl+gaq+zOrrzyA4vjvYdXlN7QNyx4HvnkKWPwV4NafatvGX+HLw6ARYgBIIU9VHcbtS13am9dxOQUAMFNUISHGyguijxgZQEXLTJnrAEvVWQCAAuUYYMqK8NwPwwAT5+pd7/90aHWAy5SDbveHYhYqIOTQBoEA2rn/atEsHLAtAgDcZNnr9huC9UOPOcu3ZecpnG3uRLdDGtm+odJrAm3oxmrLn/HX6O8gu6cCiE0B7n4FWPYtIC4FuPlpYMF9wLrjwP1/9/FR0UgwAKSQ96XrtGDPLhVEO9+U9AzgbGsVWjvtnBDaRzxrAAFXMHJI5uKytCFFXEK+qDHuZzAydMYgEMX7W7Te9d4+eRkcUuAK5QwyUG/cHwpZqGAghzgNDOD60POHVi2bpdcBBmsGVg/8DlQ3G1m+4QR8nrrtdnw6qhRbbd/AN6L+BJuwozL5WuCRUmDGJ3r/QEIGEJs04r9LvjO4Dn6iIOaw22GFVv/X7ey+OObMAE6VVUiMUTghtI8o0FcCcdWm6cFIZnI89lyajqWWQ1iiHMMJhxaE68GIHgjSIPQxEbRO73ovqajHXpmPq8UJ3GTZi/91rIRE8GahAm1jcRle3VuNsWjHp6/KwkJTBnDT1nL8cU81IIE7FmSaVrHozaFKtE+5AfZzz2OGUo1McQE1crxxv/lDT3+/x5+ueXorLrZ1ISbKgjYfBHyAlvVz2Ltxq7ILD1v/iumK9kHvPNKwJ38tbvncoxzpG0KYAaSQ53BoXcAqFMTbtMDktExHl4zCGNGF5K6znBDaR/rKAK4rysfklDijG7hQOWpcB/RJYwvz0ka3sSGt7xpAwL3rvdixAABQpOwN2ixUoOn1blt2nkJLcyNe6ngEK3bejbKzWtb04qVubCguQ01TB2qaB/6waFEEik/1oMw2GwBwk7LP7f5AZWD12r7hDuboz3g04Yvyz/hnzDpsjP4Fpis1aJOx+B/r3Zjw7cO45Z7VDP5CDDOAFPIczlHADiho63I4b1twQmZirjiFBbazOCuvwIbiMqwL0KfxcGHMA2gKTNYW5WPT1nKUVDRAjbkSwO9RoByDRdphd77FsAt+aPqbB1DnUCUyk2NR3LwA38HLKFCOIwGX0YoxAMJnPrrh0DN9eldnt1111rvZsUQ5hXGiFeNEK7ov/h+guA8CWVeUjzXLp/X7+/UPPXsOLsas7kO4SdmL3zhWQQABycDe9ctdOFbbCgH3gRs2q4IuuzrsLl8burFMOYjPWnbgBuWAseZ6PRLxJ+unoC54AI/ePN8HR0CBwACQQp4eAKpQMCkpBmebtbmmjqtTMFc5hcn2U3iNE0L7hLESiMV9ehKHKpGVHIuPmrLQHBOPJNGGK0UF9srpSIixsgt+sNobge7LMCrK+gkALYpwLs01EadEFnJQjWXKAbyhXgMg9OejGypz0NdlV41yELMEXMb/Z/2D8f1MpQoAcBkxAAYX/AGuDz2/vjgDX7ABi5WPEY92tCHO2KekogEFuan9/JaR0wO/brvqdZ6+/ubu60sMurBMOYhPWD7Ecst+jIFr7r49cjr+pN6As5M+gZceXjqitlPgMQCkkKd3ATugGMEfAByXWg3aFeI0gNF5Qw53FmMpOPfAxKIIVDd1IDN5DP55aTY+ZdmF6y2HsNc+3W2FgEDWRAUz7ULegr9bv4ksXEC6RVvPGkLBPZtLceRsC2ZOTMAfvrzE+Bk9C/XHPdX4e9tVeNRajRWWvUYAaF6XNlzP+V2/3IX9VU0AgJgoS5+ZLhu6ca/lbTxifQNJ4rLbfQ0yHv9jvwXRFmVQwZ/OoUpk5M7GyeoMTFXOYalyEH9TXY+Pv+oAzYGuAHxS35eOBlxvOYRlykEsUw4iTnQZ99UiFW/hGvwZNyA2Y6bbc5BCGwNACnkOe4/2PxQU5qUaNWf6xMTzlXIIqFicq9WghfMF0W+6LwOW6F7TwOj0YKS0sgHvt87RAkDlMDbiswCAqsZ2lFQ0sAse2vPv1x9UastrRWnnsduuIttxGlk4AwDIsFcCAP5x5DxKHNrz2TObp2ehapo6UCwW4lHrG1iqHEQ0ejAhOQHVznVpw+mc6wMb9PMmAHQ7tOdkt6N3IJSAS7jT8h4etP4d6UILFE+omdho/xe8pS7CBDShGWPRhWjAoWLT1vJBB4H64Kfjaddg6qU/Yblln1sAqNcB+vL83/XLXdhf3eyW3UyIsQ65izcaPViglGGpchBLlYOYqVS73X8W4/CWuhj/UBfDkrkQf3i4EPf75AgomDAApJBnHgSi196UVDTgiMxBu3NakqniHBQxLuwuiP6kdy9NQAPeEF9HXMZMJEDLnvykuAwlf7wAAEZmSq8DnIC5QBQwV1QgCZfQjLGoaeqIyDpAc4bKHLTotardDjtS0YJHrW/iC9HFvX6+Wo4DoNVQvvxQQa/79TrAg025OC+TMEE0Y4lyDO81XQkg9OsAPQM+cy1fXwRULFY+xp2WHfiE8iFihPYBsUamYWPPv+DP6rVQneMfz8N9ZPoG5yCxwQSBRh3gscW49dKftBo5OKAKC6T0XR2gZ8bPs2t7MMGfgIrpogbXKEewRDmKJcoxjDFl+VQpcBBTsUvMw97oqzF74VKsXTEdXxxRyynYMQCkkKeaagD1qTEAoAdW7Fen4hrLUVytfIzfVWSyDtALz4L5rh4tOImJssDeeQkPWP+IOGs7cFab8NYhBfbUOtDqXH9Wz0zp5/08UnBCzcR0pQaFyhH8XdUCl3CvA+wr2OsrQ5UpLuA+y9u4x7LN6HI7qObiZ/bP4ApxGodkLnao85CVHIv3/+1Gr3/TVQeo4F3HAvyrdSuKlD14T9UCQPMqOMGe9dY/cJgNJuADgFh04lrlCG5U9mO5ZT/Gi2bjvo/VLPzasQp/cVyLbkQN2I7BBoF6BvZ/z6bja7axSBGXsFCU4UM509hnJGUn+uvy4qXuYWT8JCaLC7hGOYJCZ8CXJtzP7UWZiBIxDzsxD0di5qNo4aygf46QbzEApNB26I8Yc0zLnOif6ksrG427P1JnuAJAx00RXwfoGewB8FowH4Mu3Il38WXbXzHOdOG4LG3YZL8d9UgEoC0Cr2emFuekQhFat9h76pWYrtRguWW/EQAGw9xovuA22MAZLNuiLAN2RwLaeb1R2Y9PW3ZiubLPGFV5UM3Fs/Y7sF2dB0DgXSwwfqav4A9wTcJdUtGAYnUB/hVbcZNlH/7Dfj8kFGQmxwblc76vYG+wgxYScBkLlDJcrXyMRcoJzBGVsAnXOW+TsfirYwn+4FiGgzIPfa30oY+SNX5vjBUJMVGD/pDoUCUK8sZhe9VVuMPyPm6y7MWHdlcAONTnvPm8eI7o1fUV/I1DEwqVoyhUjuEayxFkinq3+9ulDR+pM1CizsJHYi6OYwrmZaWwpi+CMQCkkKO/SS6NPoH/7v4PxDu3d4gY/HFPNSyKMN7AP5IzAABXKx8DkMaFMNSDkMHwdpHta3SkLg0tuNOyHfdb38Y40QIAOKOOx0/tt+N19TqYL6Tm4A8wTwgdi3eb5+NL1je1IAcOOGAJyQmhvQV73gYb9JehykA9Ci1Hcb1yCMuVfW5db/90zMGvHTdjh3ol+gpS7tlc6rX7F3Cd84LcFBw+dyUuyRikiybMEadwSOahpqkj4FnvvmoeBxfsSUxCPWYoVZgpqoz/c0QdFOF+TNXqOLyrzsdWdT4+UmcMKtvXZVdhs2rTm48faxtwAmhP+vm/OmMp0Pg+blL24gf4V+iP5WDqAM2v06EEwdHowWLlOG5QDuBa5TDylbNu93dLC/bLadilzsJOx2wckFMRGxMDWLSyjRMM/CJexAeAzz33HH784x+jtrYWV1xxBZ599llcd911gW4WmfTKWtk78RBex8Pyr8Y1s03G4sc9/4Kazg63n92vTkWPtGCiaESmuAhFpIVlHeBILrLR6MG1ymF8xvIBViq7ES20QKdaHYdNjs/gz45rjfn8zDyDEvNAkNKm6WiQ8UgVbVisfIwS9YqgnxDafCEebrCnQMVUcRZXKhW4SpRjiXIMOcp5t32q1XH4m1qA1xzX4aTMHLBdJRUNfQaB5nPe0CmwI+pKfNLyIVZY9uCQPc9YB3u0MoDenoeeNY99iUUn8kUNZipVmCGqMNMZ7CWIdq/7V6rp2K3OwG45HR+pM1Alx2Owa/rarIqxlq3n6Oqh0M//vvIYdEkrcpTzyBW1OI0MqH3UARpdu23aB4GhrNSRjgbcYDmAG5UDKFSO9KrjOyqnoES9AgesV2JH11R0OKe3ibYqmDCMAJfCW0QHgH/4wx/w2GOP4bnnnsM111yDX/7yl7j55ptx7NgxTJ48OdDNi2huF2MjayWxQtmDf7e+hMnKRQDANsc8fLvni7iIJDjgGpmamRyLmqYOdMKGwzIH88VJXC0+xusV4wOeERmpkVxkdZnignPKhwMoVI65TfuwT52Kl+w34Q210Gvgp/MMSswTQifERONd+wLcZd2BImUPSlRt3dRgmQ7GMzva1eOAEKJXwNzfuUzAZUwVZ5Gv1CBf1OAK5TRmi1NuF2VAW6P6kMxFiXoFih0L+u2S7EtfQaD7ObeiuHsBPmn5EEXKXvwEd/l1Ch79HHp2gw/8PJTIFPVakCfOGFm9bHG+V1YP0DJZFXISjsnJ+FidjI/lZBxTp6DBWYYwWObVMEYS9Jnp53/H6U7si8rHEssxFCpHUenIMPYpqWjAntON+MWOkwB6f6gY6PWaKS7gU8ou3GIpxRXKGbf76mQytjvm4T31SpSqM9Gs94fYteONApAQE8XAj7yK6ABww4YN+OIXv4gHH3wQAPDss8/i7bffxi9+8Qs89dRTAW5d5PGc08v1qVhiiXIMX7X8GYWWYwC0N771PffiLXURPC+m5qlgAOAjdSbmKydxtfIxXlevD8qaqL54ZgsGf5F1iYIds8RpXKWcxHylHFeJk8hyBtC6OpmMfziuxquOpTgqs/v8XebudW9Bibkm7R1lAe7CDqyw7MH37F9AVnIcVClHNQPrteaxj2AP8P6hIB7tmCZqME05i3xRY9yeKBq97n9JxuCIzMFBNRcfqTPwkTrTbYLg4Yi2Kn1+aDGf8+2YB7tUMF2pwWRxHs22ST45530GewMEMtHowTRncHyFOG1k9xJER699AW1gwnF1Mo7LyTiuTsHHcjIqZAZ6hnGpSoixosuuDrt7d7D0SdB3tc7CEssxFCjH8JKjyG0fvTZUuz3wazYaPfiUpQT3WLZivnLS2K5KgQMyD9scV2G7ehWOyikAhNvAED276asgl8JXxAaA3d3d2Lt3L771rW+5bV+xYgVKSkq8/kxXVxe6ulyf7ltbW73uR4PXa4oDUxH9WKsDS9XdeMD6DyxQygEAXdKKzY5b8Jz9NrQ7uzfMoi0KFmWnoKqx3Tk6EvhInY6H8VcsUk4ACN6pMfoK9oaSLRiLdkwX1Ub32UzlDK4QZ2BzToWhs0sFe2U+djjm4T11Lo45LyQDcajS7WLjGQSaa9JONy5Ce4cNk0QDrhBncLQpG9V+rknznDak75rH3n8/Hu2YKs5imlKDacIZ7Ck1yOgj0AOAczIF5WomymQmTsgsHFDzUCkzjAFJw6HXpMU4uygHyuCYay9rmoAP1Zm4xnIURcoevNA5AaVDXAVnuMGeBQ7MEmdwlVKOK8QZzFZOYZqoMUoKzLqlBSdlJo7LLCPQ+1idbAwuGg7P8zZaAZA+CfrJhKuA7ldRoByH9vzSXk96Btb8obQvqWjBv1q24vPWYqMG1yEFdqmz8IZaiHcdC9CIhF4/Z17vl4EfDVbEBoD19fVwOByYMGGC2/YJEyagrq7O68889dRT+N73vjcazQt7ejdmt0N6jMKzILurDJ+xfIBPW3Yi2XoJANAlo/B7xzL8yv5JnMW4Pn9vt0PF7tONRvA3KSkGe5rzoUqBPKUW49CMmqbek+oGgmdX7lCCPQUqskUdZhiF8dWYIap6ZfZ0jXIs9qvTsE+dhv1yKg6qebiM2GG123NxeXNgYa5Jq2hW8X7UHKy07EGRZQ+O2rN9VpPmrRscGNy0ITHowixxBvnOQG+gjB6gZUjL1EyUSy3YK1cnoVxmjiizZ85QDTbY88acAQSAd9SFuMZyFCsse/GC4xYA3qcj8dYNDvSuSevrXEbBjvmiHIWWI1gkTmCeUuFWSqBrlmNwVM3GUZmNY+oUHJeTUTnMrJ5ZoAI+T8Z8gBXx6DgbjTTRinxRgzKZBQDGh1HPngmzZLTi69Y/4bOWfxof1mplCn5rX4FXHdfhIpL7/PvM+NFwRWwAqBPCPRCQUvbapnv88cexbt064/vW1lZkZWX5tX3hxrxoud6NqUDFInECqywfYYXcg0k215vkOZmCVx3X43/tK3ARSYP6G3rhtSsLOBYnZBZmiiosUj7GocQbAIx+HZq3gG8wXbmpaMF0pRozRRWmi2rMUKowTZxFrOj2uv85meLMqmThhDoZh2QOTst0DLXuTGcumNcDlr4uNuaaNAAoVhdoAaCyF8/iX4ZVkzaSmkcbujFTVGGOUok54hTmKJXIFzXG9CueamUKytVJOCknoVxOMoK+VowZsJ398Rbs+bIObaNz7rqSiga865iP70W9iIXiBJLRiiYkeJ2OxKIIr4MP+jufY9GOVZbdKFL2olA5iniPrtwWGYd96jQcljk4qubgqMxGjUzDcJ97ZtFWxTh3QPBkuvTn/D8r23AgZjqW4DCWKMdQ5shCVnIsqp2ToC/KTnELAC1w4EpRgTnKKTxmfQ3JQvuwe0DNxa/tn8Df1av7rcFlxo9GKmIDwLS0NFgsll7ZvgsXLvTKCupsNhtsNttoNC/s6PV9eu1VOhqw0nIY1ypHcK1yGKmizdj3srRhu3oVXnVcj3+qc4fVneb5SbtUnYmZShVWxR7H35sKRqUOzTPDMlDQokBFrjiHuaLSqJWaoVQbXUGeOmQ0TsgsHHcWxmsF8llowdhht9kc7OmGeoHRJ4QuzEvF1oqr4LAKXKGcwSRcxFmMG3BZOM8JlYdS82hDNxYqJ3CtcwLcWeIMorx0QV6QSTiuTtayeXISTvogo6fTL8zmgM/fF2m9G1jLMgFH1Sm4QjmD5Zb9eNWx1Ot0JC8/VIB7NpcOomtS4nrlED5reQ9Fyl5jZQ0AqJcJ+ECdjY/Umdij5qNcToIcQfe3zjPYC/aBDHod4PutM7EkSgsAX3SsRHVTBxJirKh2Tsiti0YPXo7+ARYqZca24+pkrO+5Fx/KGQCE15BZPy/Bfj4oNERsABgdHY0FCxaguLgYn/nMZ4ztxcXFuO222wLYsvCiB0Fj0IHr5CFcK47getth5Ilzbvs1ybF41zEfb6uL8L46R1ubc5iirQpsFgUQrrqlHeo83I+3sci+F8B9yEyO80sd2lDm9EpHAxYqZZirVOJKpQJXiNMYKzp77adKgTNyPD6Wk3FCZhmBXpWcMKJaM8+LLOCbbMLinFQU5qWhpKIeTUjAHjkdi8XHKLLsw28cKwecm86iiAEnVDYbgw4sV/bhVuf6w571jvUyAYfUXByWuTis5uCQmosL/XSpDYVnsOfPwQb90bsh9eC7WF2AK5QzKFL24lXH0j6XJesvCFSg4jZlJ75ifcNtjrkKdSL+z3ENtqnzcFRmjzjgG2rNYzDS6wBLxSwAwGLlOARUSCho7bQjyzkhNwBYYcca6+tuwd9edRru7P6u20wGEu4jl0PxvFBwi9gAEADWrVuHz3/+81i4cCGWLFmCX/3qV6iqqsLDDz8c6KaFvOufehsZl4/heusxrFMPYb4oR1S0KxPjkAKHZB7eV2fjA8cc7JPT+u3u6I85a6W/SVoUYSzpBGgZwA4ZjYmiEdNFNU40TfZZHWDfo5fdJaENS5WDKFSOYbFyHNke88MBWvbziMwxaqU+ViejXE4y5vMartG8yOpdYvqKLMWOBVisfIyblD34jWMlgP6XyBpcZkriKnESX7C+g5uVj9yyUrUyBTvV2fjAMRsfqTNwDqkYaRekt27wQAV73nie83ccC/GY9XVcrxxCDLrQCZtxPj273jfcOQ8FT201vhdQsULZi7XWVzFDqQagzbP5quN6vOa4DkdkDkZSThDqwZ43euA9JmcRLp+1IVlcwkxRhWPOEfXVzprkByz/wGPW14y5DX9q/wz+6dAGYenBn7lcgN275E8RHQDeddddaGhowJNPPona2lrMnj0bf//73zFlypRANy30qCr+v+dewbj6UhTgMP4hj2OM1ZnNciYIzqjj8YE6B/9U52CXOgutw+yqNH8qBry/SW4sLnMruu5CNHaps3Cj5QBuUA4geco8Y7/hXHzMo009Ry8LAUhnomUiGvBJyy7cZNmHheKEW+2ZQwocldk4oE7FIZmLg2oeKkY4ghQIjous5xJl/47fYbHyMRJwGa0YM+ASWS8/VIDPPl+C3aebet03T5zEN62/N6YEArRJgf+mFuBNRwFOyCyMJODz7AbvsqtIGxuNnd9aPuzfORrM5/yYnIIamYZMUY9rlSN4V13Q57JwX3lpLyagEbdaduESYvEFSzFmOeeba5Fx+KX9Vvyvo2hI3ePeusHDJdjzxpz13q3OwDLLQRQox3Hcke023vw+y1tIEO24ZE3G2IL7YJF34vy+OqhtWp9HMH2ooPAX0QEgADzyyCN45JFHAt2M0NR0GqjcgXff/COuchzGj82LjQutW7dEnYUSdTbeV+egSnqvrRyMoX4qdq+J0oLA7eo83Gg5gGWWgzg0iCWazDznk/McbWoO+qQECpRjeMTyf7hWOeI2ue1xdTLeU+eiVJ2JPep0XBphzZnn4IJguch61qSVqZOQr5zFMuUA3lCvGdQSWXfMz8T+0xdhhxU3Kx9ivGjGdcoh3GTZD0CbEugNRyH+11GEQzIXwwn6QjXY88Y8Bc+xc60oti/A/da3UaTsxbvqAq9d7/dsLsXR6ovYZlvvtnZsq4zFi46V2Gz/xIAf1AJR8xhszBnY+RYtAFyonMCvHTe77WcVWknIpdtfxthZhVgNYHXRrAC0mIgBIA2FvRuoKgHK3kHjwb8hpUPLEtwEAEJbbHyfmIn3erSg75icPOL6oOGOdPOsiQLgXG8VWChO4HBFNQrzsgZdB2hRBM42u9fnmReS14O/AuUYHrO+5pwLTPOhOgNvOhZjq2N+v1PYDCRYgz1vvNWk5StnscKyF2+o1/RZk2b2/rY3cdT2H9rxmrp4HVLgVcdS/NR+O85h8MvKeWZGgfDqYjNPwdPaaUexsgD3420st+yDYlcxNibaLQOod7PniHq34A8AvtPzRfxVLez1Nxjs9U3PwO6unA4Azho/13yABbkpUM5q7xeKlZdeCjw+C6l/Hc3AiX8AJ94EKnYA3dpo3RQAPdKCAzIPO9XZ+AhzsNueN+y5vczBlP59tFXB/dfkDCvA8ayJAoBqOQEV6kTkKbW4RjmCtyriBj0f3Zrl0wDAra7Q3F7PwK9LWvF7xw3Y7LgFNXL8kNsPuAcswRzsedO7DnAhHrW+gaXKQUSjB92I6rcO8J7Npchr+xi2qJ5e9/3Efhd+4fhUv38/3IM9bzyXhfuocwZaZBzSRCvmizLs6ZyBLNMk6A5VIj7GijhVC1Ca5Ri8ohahIO4cLk0sQkKta04/1qQNTM/A5iZdga4OK8aLZkwWF4yeD0UIWKC9Z1gslv5+FdGoYABIvXW2akHf0T/DXv4urNI07QMSsd1+JbapV+EDdc6Ip83QV5XosqtGd5yvgh3PCXIBbTRwnlKLG5X9aM5eBWDwdYB6EPjL4oP4uvVPGCeacUTNwSctuzBHOQ3AFfj9wv4p1GFokx2HcsDnjUOVxprMB2UuzsskTBDNKFCO4Z/qlX2uyKJnpqZaXPf91l6EFozBXFGJ3zludNs/GGoeg4U+HUl1UweiLFHYpl6Fz1h24gbLARzGLGM6ko3FZUYgV35kN/AqAKHgK99/EQCwJYDHEKrMGdgj1TlYIMqxSJxANSZASm3gk7Bpz2mLhZdeCjw+C0kjJVC1C9j7G3Qfeh3R0II+K7T6rX+oi/GuYz6O+GDaB8AV+OmrSvij9spbHeA2dR6+iH/gBst+/B/UIc8HuGb5NMRufwIPWN8CANxqKQXgWqlkKIGfeRqWcAxaLIowVmRJT4jD1vb5uMe6DUXKXvxTvRI1TR1eR2I7VIloi4DVWTv5plqI5huewprl03DP5lJ0nWlCNMInUPYlfToS/fX1gZyDz1h24hrlKH7crXpdiUVVtayU6oPJmiOZOQNbFDMTC1COBcoJvGa/3thHzwD+ae9ZPJR9ZaCaSgSAASB1twP7XwJ2/w9Qr62VGw3gpJqBN9UC/M1RgHKZ6bM/p3f1jsbald7qAD9UZ6JVxmGcaEXHqY9QmLdkSPMBbtpajpmi91KBBV0/Q5PHGp0C7ivORtqcXvr5/+OeatQ0deAdZQHuwTbcZNmH/7Dfj8xkLXvsmYHVnwslv9sDlAMTk2JxizP7qq85TN6Zs942q4Kd9isAAHNEJdKsHajvjHXrBgYAKZ11rD74YBfp9PO/89Q03B8NLDLN9ZeZFAtLh7MGkBlACgJ8Fkaqzlbgo18Bpb8A2rUA6bK04Q1HIV5x3IjTtny0dvdeQWE49GwEAKOrdzTqibzVAdphxXZ1Hm6zlGCFZS+ersgfdB3gpq3l2FBchs1R2sXzf+03oUA5jv+232YEf26jgRHZc3rp51/PAu5Sr8BlacNE0YibEs/h3aZJ/WdgnSdSCgYmg6UvC1fd2I7qpg7UIdWoe71KPYoPYwpQ7ZF5VR3a61z2sQQmDZ7e61A05WrgPDBNOYsktKEZ8ahp7jC6gFU+pykI8FkYaVQVOPAy8LMFwLbvA+31OItx+I+e+7C46+dYjy/jkMxDa+fIgz99eg0926d/zctKQtl/3jwqwZD+idys2LEAAFCk7HGbj64/evAHAIozr3dI5uIWx0/wf+q1xn5SugawJMRYMXNiAk78582jdrzBRq8DBLS5GN9zjsSee3knAPRZBwi4MlPgxXJIzN3AAFCialnAQuVor7WYAQDMAPqMnvW+bE1ChToRADBXqTTuNwaBKBwEQoHHV3wkObsXeKEI+MtXgMsX0BQ7GV/rfgTXd27A/0V9ApcQhy67Ch8tkGFk+6KdU0UcWr8Sh9avHNVAyFwHqNuhXoluaUGeUotMezU2FJcNuCqIQ5WYlBSD+BirEQDeuTALZT/4BNYV5SMzObZXgDvaxxqMzHWAgDn43gsAfdYBAoDQU6msTRsS/UOPnnXfqc4GoAWACTFWqFK6Pef1DCBrAEdOL2UoqWgwSmdyTCUjegB4/3V5o984Ig/sAo4Eqgq8/wyw/QcAJBA9Flj6TSQv/gry3jsDR3EZWjvtiLdZ0dZlx3CWyDV38+rfA4Hv9vRWB3gJcdglr8BScQhpZ7eiMO/+AesA1xblG2/uB5/+MdAJIzO1Zvk0Y4QwufMcib1NvQp2qWCmUo1McQGZOTMAeB+JLZ2DE9gFPDT6hx59BHapOhOqFJiu1MDWWY/SSrvbHIxS72pnPsAn9Pea7sQc4NJu5JrWPRfOAHDzB1X40icnB6R9RDq+4sPJ8b8CH/7SVYQGAO2NwCt3Adv/E4AE5nwW+Ope3HXkasz5z+0orWwwarDauryvYTsYejevzaogPsaK+6/JCYoMmB5UmOsAAVMmyrIXJRUNQ1oXWDgzgII1UwPyzMC2YCx2q1rQt0LZa6wI4vX8689jnuch0YNuPfPajHgck9rylkuUowDg9pxXVWcNIDOAPqEtC5eK95uSALgygIpwZQAVzgNIQYABYDj5w/8D/vFN4I9fAF68FXhjDfCrpUD5O4A1BrjtOdxV/0XMeeYgjte2oq3TjpKKBpRWNgz7Gmtz1rqZ690Or18ZVKNb+6sDvEqcxErn0s8D1QG66AEgXz4D0TOwqulDybvqfABaN3B/K4IYNYAMTIZkbVE+FmWnuD3ndzrrAK9xBoDm2ldjFDCfzz6xtkgbWFbprAHMVWoBAKqUxlrge860DOH9hsg/+IoPR8ffAE79E9j3ItBcBSRn46Ur/gfXvJ1uBH7maVhKKhrckoaezMGheTCHXu8WiNq+ofBWB3geKTio5kIREgu7PhxUHaBOMDM1aN4ysO+oWvC9SPkYibjUZwZWSOdAJAYmQ+b5nC9VtfVm5yvlAOCWeZXMAPqcQ5XoSswFAGSKetjQbfQcAEDp6eYh9ToQ+QPfWSPBQ9vxt4tpONvc6Rb4tXbaYekniNH3M49sNQ/mCOagz8xbFgoA3nUGIrkN/xxwXVo3HJ06JJ4Z2Go5AWXqJFiFikLlaJ8jsY1Hg+d5yDyf84dULRjJE+cwFu1umVej1pKXA5+xKAJHmq1oxVgAWjew3v0LABOT4oY0/yiRP/AVH04sNu3/1KlA+lzt9pw7gbgUt930AR8A4PCS+tNrAs3Tt4zm1C2+1lcd4NuOhQCAa5UjOFBxdvAZQC+3qG/eMrD6yNQlyrG+6wDZBTxsns/5BiSiRqZBERJzlFMAXHWArsE2PM++on3oSUOFmg4AyBG1bgFgdXMXM4AUcAwAw4ozmPv8X4CH3wdW7wVu/Sk2FpdB8Xhz72/Ahz4wJDM51sj4hWLgZ2aej05XJjNxRh0Pm+jBpxM+HsIncmcNoMKXz2B4y8DucnZJFipH+64DNDKtvFAOh2fm9aAzCzhXaPPS6ZnXnScvAGAG0JeMOkDprAMUtVBMAeAjN04HMJS6YyLf4ys+nHjWpqVNBaLj8OGphl4ZGG/MNYGllQ344N9uDPnAT2eej25iYoxzq0Cxsxt4QUfJEGoAtTdyjgIeHG8ZWH1qkqnKOYxHk/c6QOP5zLep4fDMvB5Stbnn5ioVAFx1gIqx4gqfz76iTxxvT3Z2vSvnjPlDAeDD001Dqjsm8ge+s4aV3hPnmrN/JRUNSIqN6vVT+vu+58CQezaX+rW1o0nPQmUmx6K2pdPY/q6zG3i55SCEdAzyEzkHgQyVZzaqFWNx1Dk1SYFyzHsdIDOAI9KrDlBqwcg858oUenAopT4IhJcDX9HPfY1Fm+tvmqhx6wIuqWweWt0xkR/wFR+OTBdMz+xfc0dPr92lhNvAEL3uL5zenPQslHlVCgDYI6ehDWOQhDZs3/qPQX0i1/fgNDCD560O0LxEmdc6QA62GRHPzOthNQeqFJgk6jHFOTddSUWDcRHgKGDf0c/93+qSAABTxTlY4Vpe0wFlyPOPEvka31nDiZcBHYV5aQBgrMTQF3PgFy51f5681QHaYcUOxxwAwKfHHB5U0CvAwQlDNZw6QMku4BEzP+cvIQ7/VLXBYbcpJQC0tZiNaWB4nn3KoUpjpZtY0Y0U0Wrcp0IMeh1yIn/hKz6suHcB628s6/qYlFnP+um3wzXw03muS6vb6tAmJl7UvXtwn8glB4EMlbc6wN3qDNilgsnKRWSKi70yIoKjgEfM/JwfH2/D+6r2YSdfqQagZcSF4FJw/mBRBN6vbEGn0GqOE9AOAFClACD6XwWHaBTwFR9OPAaBWBTtDQYA4m29lx5q7bQbXXKzMgK7Zu9o8LYiCAC8p86FQwrMVKowtrNuwE/kgjWAw+J5/i8jFgelNjBhibf5ANkFPGLm2tcLbV2ocI5KnepcnzYzOdYItDkIxLf0c2+P0uYCTBKXtO3Oy25JhTbbAtcRp0DhO2tY0t7I9QvuhuIytHU53PYwD/YozEvF4pz+RwiHA291aADQhATsl9qbcEXJ6wN+IhdcCm5YvJ3/j5zrAs8X5b0yIhLsAh4pz9rXCpkBQJuYeEpSNGqaOnCgSsvKsgvYt/RzX9cZDQBIghYAqrzsUpDgMzGsuOqnNhaXYffpRpRUNCDa0jugae20I8tZG6RKGVRr9/pLXyuCCADbHFcBAO4Ye2QQdYDMAA6Ht/O/T9UC7/lKea86QMEaQJ8w1wGelePQJaNgEz1wtNQAMPcO8Pnsaw5VQtoSAAC3To8DoNX/AeAoYAo4vrOGIyGMbEtWciy6Ha43GfNbfHVTR8Rk/4C+VwSRALaqWgA4q3M/omVXv79HD0yYARwab+d/vzMAnCbOIt65RJmRgeV8iz5hrgNUoeCU1Fan0LuB27u0mQFYA+h7FkWgtlObeivO0QbAvQuY9X8USHzFhwu3rJYwun+rPQY9SGjdv3q9VaRk/3R91QGekFk4L5MQI3owsfXQAHWAvedbpMHxHIldj0RUqeOgCIkrlQpkJse6siJGbRrfpkbC8zmv1wHmOQPA9HgtQGm3Mxvlaw5VInNcEgBgcdVmAMDYGJsxMK+koj5QTSNiABiWTBlA80hfXWunHYoQWFeUHzHZP11fdYCAwAfO9WlrD7zV7ydzwaXghs2cjcpwrsiyz1l/eZUoR01Th+ncswvYFzyf85XOOsBcUQvA9XzmPIC+t7YoHzH2FveNQmDN8mlYV5SP0spGbNpaHpjGUcTjO2u48KhrW7N8GgrzUtHa2XvN36zkWGNewEjK/gH91AEKYKdDCwBXxfa/LrCrC5gXzKEyj0o951yRZb+pDlDPDm4sLjN1AQemreHC8zlfoWoBYJ6iZQDr27THgV3A/rF70r3uGxSt5lIPAlkHSIHCV3zYcO8C3lhcBlXKXhnArORYVDd1uHe1RZA+6wAlsNOZAczuLjfqdbzhNDDD521FFn0gyAJLBc42XTZGAhvzAIreUxjR4Hk+5ys9uoD1NWo5DYx/3HbXg8D133RtMD2f1yyfFnEfwil4MAAMF+aMlrMLuLSy0S0DqAgYNYHuXW2Rpa86wPNIwUk1AxYhMallbz91gBwEMhKedYDH5WR0yigk4BJyRa3pwwm7gH3F/JzXA8BxogUJuAzFubKNhMJVKfwldarrNp/PFCT4TAxDz+2oQGml+9JvAoA54RfJUxD0XQcI7HSuT9t4+J0+A2TXPICRGUCPlOeKLHZYcUxOAQBMF9WoaerA7tONaLmsjcbmeR4583P+EuJQJ5MBaHWAinMlkLYuR8R+KPS7lFzXbYUZbQoODADDhiuYsyiKMQWMznwNzUqOxaLslIjteuirDlARrm7gG2NO9BkguwaB8I18OLxlYM0DEzKdNaqCGUCf8XzOV6rObmDlnHGerVZrxH4o9Lv4Ca7bfD5TkOAzMVyYgpkvL801poBJitWmeNDf1/XtkfxJv686QFUCu9XpAIBMexXiHK29fhZwrVErOGpyWPRsVEFuilGjqgckuUotapzzU3LCbd/xfM7rK4LkiXNGDWCnXUb0+4JfjRnvut3Vd30x0WhiABg2XAHgczsqoUoty9Lc0dNrz4LclIj/pN9XHWATElDhDEb6mg/QuETyYjksejZKEcKoUdXnpssV55AQY9UygFwJxKfMz/kKU8ZVrwGMtmoZbdYB+kFUjOt2Z3PAmkFkxnfWMKQoCkorG2F3qMa2KItAYV4qSioaoAgRsd2/uv7qAPc4s4DVh7b3kRFhYDISa41JcF3zVJq7gFs7e1CYl2oEJhxs4xvm53y1HAcAyBD1RgZQheK2FjMRhTe+s4YLj3q2wrxUfHS6yfi+xyFRUtFg1FdF+uSj/dUB7nVOTHxj3CmvmVI9MFEYmAybno3SM4Bn5AQ4pECC6EBOzGWoUuKSc4kyBtq+YX7OX4ZWHxyHLqMGsMMuI3pwGFGk4Ttr2HC9af/39pOoamw3vjeXUE1OiePko+i/DnCvqt2X0/UxouDo+5cwUTJsejZKnw6mG1GocWalxndVo7SyETaLdoI5Ctg3zM/5y1LrkowTncYHGhWC69P6U9SYQLeAyA0DwHBhymRdnZOKmqYOjI+3ud2ldwEDkbcCiDee89HpKmQGmuRYxIgepLR93Ot+vTZN4QTFw6ZnAM3Twejz0+U6V6iwO5zBNzOAPqOf93Zo7w1x6HJNBA1hrBHOOkA/sMUHugVEbvjOGjZcAaBDasHehbauXntxAIiLeT46PVjWCOx1rk6Reelgr5/jSiAjt7YoH4uyU9xqMD3XqLU54+uPz18a9faFKz3zOmtyOgAg1hQAqlCgCME6QH9hAEhBJuwCwNOnT+OLX/wicnJyEBsbi7y8PDzxxBPo7u52208I0evr+eefD1Crfeuj002QpowgB4B4Z16X1hwsCwB7nQNB0luP9MqGuOYB5EVyJDy7gY0MoDMA1M9z/aVu77+Ahkx/zrcLrQvYJuyIhlZrqXcBsw7QT2ISAt0CIjdhFwB+/PHHUFUVv/zlL3H06FFs3LgRzz//PL797W/32nfLli2ora01vu69914vvzFEmAK+gpxU7DLVtukDQPQgMNIHgOi8rUsLaLnU2jEzAABRFw55yYbo5zrsXj6jSg9GJqfEAei9Rq3eBZwW37ubnoZHf86/f9pVIzxGdALQAkAArAP0F2YAKchYA90AX1u1ahVWrVplfJ+bm4sTJ07gF7/4BX7yk5+47ZuUlIT09PTRbqKfmLuAvX96V6XkABAPeh2gOQgUAHa0TgRigBzlPCzd7hO36l1mCi+SI7K2KB+btpYb08FUdGpdwJniIqJgd3VNsqvdpxyqxPikeNg7FFiFirHQnvvS+YHGtRYz+RQDQAoyEZHCaGlpQUpKSq/tq1evRlpaGhYtWoTnn38eqqp6+WmXrq4utLa2un0FDVPQ9+HpZqyY5Vp6yOK8gOojXtkF7OK5Li2ghdLNiEeNTAMANFTs8egG5jyAvuJQJbKSY9HaaYc6ZjwuyRhYhYrJ4rwxz7aIjLepUWNRBGqaO2EV2vvd/da3AQCq1E54TYSvFOQ3S/9N+3/+FwLbDiKnsH9nraiowM9+9jM8/PDDbtu///3v409/+hPeffdd3H333fj617+OH/7wh/3+rqeeegqJiYnGV1ZWlj+bPiJHz7UA0LJZDueqIMz+9dbXiiAAcETNAQCI2oNuF0S9No3zAI6cRRGobupAZnIs6i/3GN3AU8U5Y8k9CMFRqT6kd7332m7KAK5ZPm20mxX+0ucAj9cAt24KdEuIAIRQALh+/XqvAzfMX3v27HH7mXPnzmHVqlX47Gc/iwcffNDtvn//93/HkiVLMG/ePHz961/Hk08+iR//+Mf9tuHxxx9HS0uL8VVdXe3z4xw+V2C3ODcVZ5s7ja2c/qVv3tal1R1RswEAyxJq3QJnYxQwsyQj1lcdYK6oNc7zgbNtzEj5kP4e0CTHum2XEMhylkOwTthPbPGcPYCCRsjUAK5evRp33313v/tkZ2cbt8+dO4cbbrgBS5Yswa9+9asBf39BQQFaW1tx/vx5TJgwwes+NpsNNpvN630BZ+oC1rp6owAAVkXg5YcKcM/mUmxwZlH46d5FD0BKKxuMVSl0R2Q2AGDC5Y+9ZgC5RNnImesAAaBSzQAs2prA+nmOs1mZufYxhyrxgwkb8b3zqzFGaCPgpdCysRwFTBQZQiYATEtLQ1pa2qD2PXv2LG644QYsWLAAW7ZsgaIMfKHev38/YmJikJSUNMKWBorrDXtSUixONWvBjF2VuGdzKad36IPnQARzEHjU2QU8VamF1dGBjcVlWFuUbwxO4Cd53yipqDduuyaDrkWL1FZOuNTlQDIzgD5lUQRerRqDJeM+izvaXgIAOKRi9BYU5HoviyCi8BF2KYxz585h2bJlyMrKwk9+8hNcvHgRdXV1qKurM/b561//is2bN+PIkSOoqKjA//zP/+A73/kOvvSlLwVvhm8Iqp3dv1ZFYEluihH8vfxQAbuAvfBcl1Z3EUm4gGQoUPHu9q2uLKBkDaAvLc5JNeow9QAwR9Qagfb4RG0aGNYB+o7+nN/T6Hq/uzIrmR8UiSJI2F3B3nnnHZw8eRLbtm1DZmYmJk6caHzpoqKi8Nxzz2HJkiWYO3cufvrTn+LJJ5/EM888E8CWj8xz208at2dMTASgZf92VTYiKzmW8//1w3NCYrMjjikAgFvHXzQuiq6JoMPu5RMQ+vkvzEtFndRG66eIS7BCD8gVrk7hY/o5v+bKmca2KyenYF1RPucBJIoQYXcFu++++yCl9PqlW7VqFfbv34+2tjZcvnwZhw8fxte+9jVYrSHTI96L1fRI3rtkinHbwrqeAXlbl1ZX4VyezNFQid2nG7GxuMzITAl2AfuEXoepSok2xBnb44X2eJxt7uLz18f0c/7JwqtcG4WCNcuncbYAoggRdgFgpPrSdbnG7Z9t07KB5ilg2P3bN2/r0uqq5HgAQH50gykzwgDQl/TnZWllI3pgRYeMBgAkQVsDWF+ijFkp31lblK8NBhszzrRVO79rlk/jewVRBGAAGIaqvUwBw+7f/pmng4k3TQdT7QwAx9nrjCyUHoYIxRKAloYn83yMrc4sYJLQAkAJgYJcrWuYdYA+Nna863b3pcC1g4hGHQPAMPH8e64aQD1EsTingCnMS8WG4jIGgf3Qu8QUIdBmGgyiZwAnKxdQUlEPiyKgQJugmBlA3zHXAbY6R/8mCm29WgkBRQjWAfpDlKnutaut7/2IKOwwAAwTFi/XRQengBk0vctLnw5Gd1amQZUCY9CJOUk97hlAjgL2GXMdYKupDhBwdQHzOexnDACJIgqvYGHioetyjNvCGaIsmJLEKWCGwLwubbxNCwK7EI06JAMALC1VrAH0E3MdYJv0DAC1tynWAfpZVxCtbU5EfscAMExsfr/SuK3nSPaeaWYN4BDo69ImxFjR1uXqBtbrAOeNbQYA10TQDEZ8Sq8DPCanuG3Xn88FuSlcxcafOhkAEkUSBoBhYGNxGfac1pbScnVQAtEWBQW5qSjITWHX2SD0NSF0laoFgGPaa7ChuMyYB1ARHATiS3odYNQ1j7pt15/ThXmDWwmIholdwEQRhQFgGLAoAvvONAFwXSwFgG6Hig3FZSjMS2P37yDo08F4TghtDAQRF5CZHMt5AP1ErwPsiE7FeZlkbJdC7wKu7+MnySfYBUwUURgAhoE1y6fh4eu1eQD1Ca9nZSQEskkhy6KIXhNCmwNA7T49AOTLx5f0DykbistQb5tsbFelNp1RaWUjSxn8YeantP+v/lJg20FEoyp0l74IQxud01x4q3PatLUcDlX2k8mTzn+1rNTRc61YZ7qgAmD91CDo3cAlFQ3GNr0GMEu5gMU5KRDnuBScv+jnv6JqDK5w9rDfdlUW1uzlKGC/uX0zcPZhIGtxoFtCRKOIV7Ag8uGpBq/z9W3aWo4NxWX48FSD15/bWFyGPWcaAbjPAagHfKwBHDzzfHS6KjkBAJCBBljRwy5gP9LPf1ZWtrHtU/MyuUatP0XFANnXABbmA4giCV/xQcicsdODv/5YFIH9Z5qAGNeISfMcgOv0ZZ9oQHodmrnerB4JaJc2xIkunD1dBhGtZwAZjPiafv6vip4GnNO3uj7M8IMMEZFvMAAMIoV5aSit1DJ5eibQbrrg9TUKcs3yaSgrOw6cd227MivRyGQx+Bu8tUX52LS13HgcNAJVcjxmiGpMFheMcdYKl4LzOaPEYf8E10bhWqOWiIh8g13AQWTN8mnGmqcA3II/vZ7P21qom7aW9xoFfLC6hXMADpN5XVpdtWkgiCK0x2XLztOj3bTIEWf6sMPBNkREPsd31hCgByN91QHuPFmPBVOSnd9pAWC0RTHWAd55ktNnDIX3OkDnQBBxwdimcBCI/8Qkum6z1pKIyOd4BQsyipeLXUlFg1EH6K0b+JqpadhnDALRdDtUowbwmqmcQHcozOvS6qrlOABaBtDYTzIw8Ru3AJBvU0REvsZ31iCyaWu52/QjnvSMlGc38Jrl07BgSpLx/dXZKUb3L2sAh868Lq2uSY4FACThsrHtQE2L1y558gFzAAgG2kREvsYAMIgMtNJBVWM7NjjnCjTbtLUc+6pcNYB7zjQawR9rAIfHsw7wMrTVQcYI1yTRu083cVoSfzEHgPbOwLWDiChMMQAMQgW5KcjyWI4MAGqaOnpNhruxuAwlFfV48NocAFoAqEquAzxSeh1gQW4KEmKsuIwYAMBYuALAhdmcmNhvose4bnOJMiIin2MAGEQW56RiXVE+FCFQ7bEcGQAkxFhRUtGA3acbja5HiyK0rkqprwSibeM6wCOj1wEqQqC1047LUgsA400ZwI+YAfQfcy1sV1vg2kFEFKYYAAYRPVDrqw6wtdOOrORYtxUR1iyfhnVF+fj1zlMAtAzgqivSR6fBYcz8WPSXAQS8T81DPjRhTqBbQEQUdhgABhm9DvAby3OQl9R7ouHqpg6vK3sIuLoi3zxci3VF+VhXlO91aTkaHL0O0JwBjBXdxv0SwmtNJvnImgPA5/8MZC4IdEuIiMIOVwIJMotzUvFIzNuYt+srqO26AxW4ye3+TGdt4MbiMiNL5VAlHrgmB9ijBSVRFuEWILJObXj0OsDM5Fi0NPWuyfzwdBMK8zJ4fv0lJUf7IiIin2MGMMisLcqHkBIJags+a9nhdp+ANhDEM+ukBYKuGsAehzSyfmuWT2MN4DDpGcCapg60w9brfgnh1h1PREQUKhgABqGj4z4BOyyYp1Riuqgytut5Jn25OL32bNPWcvzGWQMICDx0XQ67fn1gbVE+FmWnIDM5Fg707o6XENp9zAASEVGIYQAYhLptKSh2zAcAfNbyXq/7z5qygJu2lmNDcRnuL5xi3P/gdbms//MRiyJQ4xyRXYMJbvdJaPcxA0hERKGGAWAQcqgSh8ffCgC4w7oTFjgAaMFIVnIsqps6kOXMPOnTlXxhSTYALUsohGt0MLNTI6Of38zkWNze+V23+1RnBhDgSGAiIgotDACD0NqifERPL0KrkohktKJAOQZAC0b04K/amXla6xwRLKUKQMtKWYRrihjW/42Mfv5qmjpwAUlu92UmxXqtySQiIgp2DACD1GMrZqFq/I0AgFuUD93u8zYVjKrqg0AEFMFgxJdcy8IJtEvXYJCqZm2JsoLcFK63TEREIYUBYJDatLUcT1XNAAB8wrrb6Ab23EfvelSdGUAADAB9TJ8OpjAvFQ0ywdguoZ3nwry0QDWNiIhoWBgABimHKlFw421oVRKRhDajG1jvafzjnmq3rkdV1buAAcFH1af0DGBJRQOiEsab7hG91mYmIiIKBQwVgtTaonxIYcVb3fMAADcoBwAAqgSykrXasyzTFCTOpYDdagDJN/QM4LqifHREJ7vdx3kAiYgoFDEADGIOVeJw3NUAgBstBwFok0FXN3UgIcZqDAQBAFWyBtBf9JHAAHDgoivbt85YL7g+IO0iIiIaLgaAQcyiCPyldTocUJArzmGyOK918QJo7bSjMC/VGHwgVVcNIOM/39JHAm8oLkNe5kRjuz7VTmllI+dbJCKikMIAMIg5VIkrcjNRmzgPALDM2Q0soXUDq1KaBoG4loJjBtD39Czg3NxJbts53yIREYUiBoBBbG1RPgrz0vC/9dMBuOoAFaF1A5dWNhpdwNIIQARr0vxAn28Rtvhe93G+RSIiCjUMAEPAdnUeAGCJcgwx6IK3ZJNqmgia8Z8f2RIG3oeIiCjIMQAMcg5Voj1xGupkMmJED65SThr3aVOT1GNjcZlbF7BgF7D/RI8NdAuIiIhGLCwDwOzsbAgh3L6+9a1vue1TVVWFW2+9FWPGjEFaWhrWrFmD7u7uALW4bxZFoKa5Ex+qMwEAi5XjsAiBdUX5KKlocHUDS9agjQovXcBEREShxhroBvjLk08+iYceesj4fuxYV+bG4XDglltuwbhx4/DBBx+goaEB9957L6SU+NnPfhaI5vZJH3xQf3gB0FyCq8XHcEiJ0soGAK5lyC6WfwTAtToF+UnGvEC3gIiIaMTCNgCMj49Henq61/veeecdHDt2DNXV1cjIyAAAPPPMM7jvvvvwgx/8AAkJwVPntbYoH5u2luPl85PxRRswXymHFXZjabKXHyoAAEjpGgRCfpQ0GXhoGxCbPPC+REREQSosu4AB4L/+67+QmpqKefPm4Qc/+IFb9+6uXbswe/ZsI/gDgJUrV6Krqwt79+7t83d2dXWhtbXV7cvfNm0tx4biMqTnzIYjagxiRA9yRS0sQlud4p7NpVoNoGkpOPKzSQuAlNxAt4KIiGjYwjIA/NrXvobf//732L59O1avXo1nn30WjzzyiHF/XV0dJkyY4PYzycnJiI6ORl1dXZ+/96mnnkJiYqLxlZWV5bdj0Onr0O6sbEI5pgAAZoozcEiJrORY11JkKjOARERENDghEwCuX7++18AOz689e/YAANauXYulS5di7ty5ePDBB/H888/jhRdeQENDg/H7vI2UlVL2O4L28ccfR0tLi/FVXV3t+wP1sLYoHy8/VIDCvFR82KFNQjxLOYM5mYmobuowVgPhPMREREQ0WCFTA7h69Wrcfffd/e6TnZ3tdXtBgVYnd/LkSaSmpiI9PR0ffvih2z5NTU3o6enplRk0s9lssNlsQ2u4D2zaWo6SigbMi58K9BRjpqjCUzUtzmlgtG7g68ecxcMAJKeAISIiogGETACYlpaGtLS0Yf3s/v37AQATJ2rruC5ZsgQ/+MEPUFtba2x75513YLPZsGDBAt802If0buAPKjPwTZuWAbQIgZcfKsA9m0tRUtGAG65kFzARERENTsgEgIO1a9culJaW4oYbbkBiYiJ2796NtWvX4lOf+hQmT54MAFixYgVmzZqFz3/+8/jxj3+MxsZGfOMb38BDDz0UVCOAdfoyY/f/shPqOYE00Yok2WwEf+uK8rFy3DngRIAbSkRERCEhZGoAB8tms+EPf/gDli1bhlmzZuG73/0uHnroIbzyyivGPhaLBW+++SZiYmJwzTXX4M4778SnP/1p/OQnPwlgy/t39692Yfupy6hVtC7qfKXGmAoGAN48VAuA8wASERHRwMIuAzh//nyUlpYOuN/kyZPxt7/9bRRaNHKbtpajtLIRANA0dhomtdVhuqjGR2I2SioaUFLRgG/N4SgQIiIiGpywCwDDkb4aCABs256K2VYgX1TD4Zz8uSA3BUUzY4FyZgCJiIhoYGHXBRyO1hblY83yaQCAMlWbe3C6UmPcX5iXBilV53cMAImIiKh/DABDhL4iSGzmbABAvqiBVQHWFeVjQ3EZfvlepbYj4z8iIiIaAAPAEKFPBfPnqlh0SwviRQcmqBcBAIV5qai8eMm5JyNAIiIi6h8DwBCxtigfBbmpsMOKSqmtYfypjGZsKC5DSUUDbpo5HgBrAImIiGhgDABDhN4FvK4oH81jcgAAjguuif+k5ChgIiIiGhwGgCHCoUoU5KYAAJKmzAUA5OEcoi0K1hXl4/TFNm1HLgVHREREA2AAGCLWFuWjMC8NG4rL8JeaMQCAaUoNuh0qSisbcLqhPcAtJCIiolDBADCErFk+DYV5qdjWoGUCp4pzWJKTjJKKBmSnxQFgDSARERENjAFgCNm0tRwlFQ0Ynz0TDimQINpRcaoShXmpqGq47NyLASARERH1jwFgCNHrAK+emoHTMh0AMN1yDi8/VIDrpmprAttVDgYhIiKi/jEADCHmOsAK51QwOajBpq3lxj6qBDYWlwWqiURERBQCGACGqJNyEgBgaXIjNhSX4YOT9QAAhwQ+PNUQyKYRERFRkGMAGEL0uQAL81JxTmpdvj0tdQAAAa3rV0KgMC8tYG0kIiKi4McAMIToNYAFuanAmHEAgDTRAsAVACrOeQDZDUxERER9YQAYQsw1gLX2eABAKlrcdxLAhuIyWBSOBiYiIiLvGACGGH0uwMoObd6/NNEKwDX5i0MFCvNS4eBoYCIiIuoDA8AQo88F2BWtTQYdLzpgQ7dbDWBJRQMzgERERNQnBoAhxqFKbRBIVzS6pBUAkIpWUwCoZQAB1gESERGRd9ZAN4CGrqqxHYBAAxKQgUZjIIj5/pKKBhTkpgSmgURERBTUmAEMMRZFoKapAwDQIBMAAKmi1agBlHDdz+lgiIiIyBsGgCGsXiYC0KaCMXcBA+wGJiIior4xAAwxDlViXVE+CnJT0ABnAIhWwDQIJCs5FqqUnA6GiIiIvGINYIhZW5Rv3G6s0uYCTBZtrtQfgOqmDlQ3dWBdUT7WLJ822k0kIiKiIMcMYIgqqahHm4wFAIxFu1sNIABkJscy+CMiIiKvGACGoE1by1Fa2Yi0NG05uATR0asGsKapA5u2lgeohURERBTMGACGmE1by7GhuAzrivJxWWirgcxJE5iVHu/cw1XzV1JRH4AWEhERUbBjABhi9EEga5ZPQ2Z6OgAg2n4JH9dpS8JNSIjFOlOdIBEREZEnDgIJMeZBIJ9aPAP4GLjU0ojb5mUAx4CJiTFG7d+G4jJs2lrOWkAiIiJywwAwlNm0iaAnxnRj2tyJwDEAQusC1oM+hyr7+mkiIiKKUAwAQ1mMFgCOVS8BUg/0XDWAzPwRERGRN6wBDGXxGYBQAHsH0FarbROc+JmIiIj6xwAwlEXFAMk52u2LJwLbFiIiIgoZDABD3bjp2v/1+pq/zAASERFR/xgAhrqkKdr/zVXa/+wCJiIiogEwAAx1iZna/y3Vzg0MAImIiKh/DABDXVKW9r9qD2w7iIiIKGQwAAx1CZPcv2cXMBEREQ0g7ALAHTt2QAjh9Wv37t3Gft7uf/755wPY8mEak+axgQEgERER9S/sJoIuLCxEbW2t27b/+I//wLvvvouFCxe6bd+yZQtWrVplfJ+YmDgqbfSpMePcv2cGkIiIiAYQdgFgdHQ00tPTje97enrwxhtvYPXq1RAewVFSUpLbviEpegxgjdUmgyYiIiIahLDrAvb0xhtvoL6+Hvfdd1+v+1avXo20tDQsWrQIzz//PFRV7fd3dXV1obW11e0rKPTqBiYiIiLqW9hlAD298MILWLlyJbKysty2f//738fy5csRGxuLrVu34utf/zrq6+vx7//+733+rqeeegrf+973/N3koYtLdU0Dwy5gIiIiGoCQUspAN2Iw1q9fP2DwtXv3brc6v5qaGkyZMgV//OMfcccdd/T7s8888wyefPJJtLS09LlPV1cXurq6jO9bW1uRlZWFlpYWJCQkDPJI/OClfwFOFmu3c5YC974RuLYQEREFudbWViQmJgb++h1AIZMBXL16Ne6+++5+98nOznb7fsuWLUhNTcWnPvWpAX9/QUEBWltbcf78eUyYMMHrPjabDTabbdBtHjXmLmBmAImIiGgAIRMApqWlIS1t8LVuUkps2bIFX/jCFxAVFTXg/vv370dMTAySkpJG0MoAiUsNdAuIiIgohIRMADhU27Ztw6lTp/DFL36x131//etfUVdXhyVLliA2Nhbbt2/Hd77zHXzpS18KzgzfQNwGgTADSERERP0L2wDwhRdeQGFhIWbOnNnrvqioKDz33HNYt24dVFVFbm4unnzySTz66KMBaKkPxLELmIiIiAYvbAPAl19+uc/7Vq1a5TYBdMhjBpCIiIiGIOznAYwItsgcwURERETDwwAwHMSYAkB2ARMREdEAGACGgxjzGsYMAImIiKh/DADDgbkL2NEduHYQERFRSGAAGA5s8a7bXW2BawcRERGFBAaA4UCxuG53tQauHURERBQSGACGG2YAiYiIaAAMAMMNA0AiIiIaAAPAcNPTHugWEBERUZBjAEhEREQUYRgAEhEREUUYBoDhQlgG3oeIiIgIDADDh3kuQCIiIqJ+MAAMF+b1gImIiIj6wQAwXMy9W/s/bXpg20FERERBzxroBpCPLP0mMH4mkH1doFtCREREQY4BYLiwRAGzbw90K4iIiCgEsAuYiIiIKMIwACQiIiKKMAwAiYiIiCIMA0AiIiKiCMMAkIiIiCjCMAAkIiIiijAMAImIiIgiDANAIiIiogjDAJCIiIgowjAAJCIiIoowDACJiIiIIgwDQCIiIqIIwwCQiIiIKMJYA92AUCalBAC0trYGuCVEREQ0WPp1W7+ORyIGgCPQ1tYGAMjKygpwS4iIiGio2trakJiYGOhmBISQkRz+jpCqqjh37hzi4+MhhPDp725tbUVWVhaqq6uRkJDg098dDHh8oS/cj5HHF/rC/Rh5fMMnpURbWxsyMjKgKJFZDccM4AgoioLMzEy//o2EhISwfGHreHyhL9yPkccX+sL9GHl8wxOpmT9dZIa9RERERBGMASARERFRhGEAGKRsNhueeOIJ2Gy2QDfFL3h8oS/cj5HHF/rC/Rh5fDQSHARCREREFGGYASQiIiKKMAwAiYiIiCIMA0AiIiKiCMMAkIiIiCjCMAD0geeeew45OTmIiYnBggUL8P777/e7/3vvvYcFCxYgJiYGubm5eP7553vt89prr2HWrFmw2WyYNWsW/vznPw/570opsX79emRkZCA2NhbLli3D0aNHQ+L4nnrqKSxatAjx8fEYP348Pv3pT+PEiRNu+9x3330QQrh9FRQUDPn4AnWM69ev79X+9PR0t31C+THMzs7udXxCCDz66KPGPr56DH19fEePHsUdd9xhHMOzzz47rL/rq8cvUMc4mq/DQBzfaL4GA3WMofw63Lx5M6677jokJycjOTkZN910Ez766KMh/11fPoZhRdKI/P73v5dRUVFy8+bN8tixY/JrX/uaHDNmjDxz5ozX/SsrK2VcXJz82te+Jo8dOyY3b94so6Ki5KuvvmrsU1JSIi0Wi/zhD38ojx8/Ln/4wx9Kq9UqS0tLh/R3n376aRkfHy9fe+01efjwYXnXXXfJiRMnytbW1qA/vpUrV8otW7bII0eOyAMHDshbbrlFTp48WV66dMnY595775WrVq2StbW1xldDQ8Ogjy3Qx/jEE0/IK664wq39Fy5ccPtbofwYXrhwwe3YiouLJQC5fft2Yx9fPIb+OL6PPvpIfuMb35CvvPKKTE9Plxs3bhzW3/XF4xfIYxyt12Ggjm+0XoOBPMZQfh3ec8898uc//7ncv3+/PH78uLz//vtlYmKirKmpGdLf9dVjGG4YAI7Q1VdfLR9++GG3bTNmzJDf+ta3vO7/zW9+U86YMcNt25e//GVZUFBgfH/nnXfKVatWue2zcuVKeffddw/676qqKtPT0+XTTz9t3N/Z2SkTExPl888/H/TH5+nChQsSgHzvvfeMbffee6+87bbbBnsofQrUMT7xxBPyyiuv7LNd4fYYfu1rX5N5eXlSVVVjmy8eQ38cn9mUKVO8XlhH6zU4mL/lyVfH6Mlfr8NAHd9ovQalDJ7HMFRfh1JKabfbZXx8vHzxxRcH/Xd9+RiGG3YBj0B3dzf27t2LFStWuG1fsWIFSkpKvP7Mrl27eu2/cuVK7NmzBz09Pf3uo//OwfzdU6dOoa6uzm0fm82GpUuX9tm2YDk+b1paWgAAKSkpbtt37NiB8ePHIz8/Hw899BAuXLgwqGPTBfoYy8vLkZGRgZycHNx9992orKw07gunx7C7uxsvvfQSHnjgAQgh3O4byWPor+Pzxd/1xeM32L/lyRfH6I0/XoeBPj5/vwaBwB+juR2h/Dpsb29HT0+P8fwbzddhOGIAOAL19fVwOByYMGGC2/YJEyagrq7O68/U1dV53d9ut6O+vr7fffTfOZi/q/8/lLYFy/F5klJi3bp1uPbaazF79mxj+80334zf/e532LZtG5555hns3r0bN954I7q6ugZ1fIE+xsWLF+O3v/0t3n77bWzevBl1dXUoLCxEQ0OD8Tv0nxts24Lp+Mz+8pe/oLm5Gffdd5/b9pE+hv46Pl/8XV88foP9W558cYye/PU6DOTxjcZrEAiexzDUX4ff+ta3MGnSJNx0002D/ru+egzDkTXQDQgHnp+kpJS9tg20v+f2wfxOX+0zkEAdn2716tU4dOgQPvjgA7ftd911l3F79uzZWLhwIaZMmYI333wTt99+ez9HNLg2+/sYb775ZuP2nDlzsGTJEuTl5eHFF1/EunXrht22wbZ3NB/DF154ATfffDMyMjLctvvqMfTH8fnq7/ri8RvO7/HVMer8/ToMxPGN5mtwOL/H149hKL8Of/SjH+GVV17Bjh07EBMTM+S/66vHMJwwAzgCaWlpsFgsvT5FXLhwodenDV16errX/a1WK1JTU/vdR/+dg/m7+ki2obQtWI7P7Ktf/SreeOMNbN++HZmZmf22d+LEiZgyZQrKy8sHPDZdMByjbsyYMZgzZ47R/nB5DM+cOYN3330XDz744IDtHepj6K/j88Xf9cXjN9i/5ckXx2jmz9dhMByfzh+vQSA4jjGUX4c/+clP8MMf/hDvvPMO5s6dO6S/66vHMBwxAByB6OhoLFiwAMXFxW7bi4uLUVhY6PVnlixZ0mv/d955BwsXLkRUVFS/++i/czB/NycnB+np6W77dHd347333uuzbcFyfID26Wz16tV4/fXXsW3bNuTk5AzY3oaGBlRXV2PixImDOj4gsMfoqaurC8ePHzfaH+qPoW7Lli0YP348brnllgHbO9TH0F/H54u/64vHb7B/y5MvjhEYnddhII/Pkz9eg0BwHGOovg5//OMf4/vf/z7eeustLFy4cMh/11ePYVjy9yiTcKcPQX/hhRfksWPH5GOPPSbHjBkjT58+LaWU8lvf+pb8/Oc/b+yvD31fu3atPHbsmHzhhRd6DX3fuXOntFgs8umnn5bHjx+XTz/9dJ/TwPT1d6XUhr4nJibK119/XR4+fFh+7nOfG/YUIqN9fF/5yldkYmKi3LFjh9vUBO3t7VJKKdva2uTXv/51WVJSIk+dOiW3b98ulyxZIidNmjTs6RlG+xi//vWvyx07dsjKykpZWloqP/nJT8r4+PiweQyllNLhcMjJkyfLf/u3f+vVLl89hv44vq6uLrl//365f/9+OXHiRPmNb3xD7t+/X5aXlw/670rpm8cvkMc4Wq/DQB3faL0GA3mMUobu6/C//uu/ZHR0tHz11Vfdnn9tbW2D/rtS+u4xDDcMAH3g5z//uZwyZYqMjo6W8+fP7zVFwtKlS93237Fjh7zqqqtkdHS0zM7Olr/4xS96/c4//elPcvr06TIqKkrOmDFDvvbaa0P6u1Jqw9+feOIJmZ6eLm02m7z++uvl4cOHQ+L4AHj92rJli5RSyvb2drlixQo5btw4GRUVJSdPnizvvfdeWVVVNeTjC9Qx6nNRRUVFyYyMDHn77bfLo0ePuu0Tyo+hlFK+/fbbEoA8ceJEr/t8+Rj6+vhOnTrl9fnn+XtG6zUYqGMczddhII5vNF+DgTpGKUP3dThlyhSvx/fEE08M+u9K6dvHMJwIKZ1Vl0REREQUEVgDSERERBRhGAASERERRRgGgEREREQRhgEgERERUYRhAEhEREQUYRgAEhEREUUYBoBEREREEYYBIBEREVGEYQBIREREFGEYABIRERFFGAaARERERBGGASARERFRhGEASERERBRhGAASERERRRgGgEREREQRhgEgERERUYRhAEhEREQUYRgAEhEREUUYBoBEREREEYYBIBEREVGEYQBIREREFGEYABIRERFFGAaARERERBGGASARERFRhGEASERERBRhGAASERERRRgGgEREREQRhgEgERERUYRhAEhEREQUYRgAEhEREUUYBoBEREREEeb/B3yfzKbfjoltAAAAAElFTkSuQmCC", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "start = -d/2\n", "end = d/2\n", "\n", "\n", "plt.figure(4)\n", "\n", "evalOnLine(H_MS[1] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=True, label=\"MS\", show=False, N=1000);\n", "# [evalOnLine((H_comp[i])[1] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=False, label=\"MS_\" + gradgradMS.gradsol_pack[i][1].name, show=False, N=1000) for i in range(len(H_comp))];\n", "\n", "evalOnLine(H_ref[1] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"\", show=False, clear=False, label=\"ref\", N = 1000, title=r\"$H_y$\");\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9d6fdeaa7a3444f395c54700b576922c", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "'pyPhiConstant'" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "start = -d/2\n", "end = d/2\n", "\n", "H_comp = gradgradMS.gradsol_comp\n", "plt.figure(5)\n", "evalOnLine(mu * H_MS[0] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=True, label=\"MS\", show=False, N=1000);\n", "i = 0\n", "# evalOnLine(mu * (H_comp[i])[0] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=False, label=\"MS\", show=False, N=1000);\n", "evalOnLine(mu * H_ref[0] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"\", show=False, clear=False, label=\"ref\", N = 1000, title=r\"$B_x$\");\n", "\n", "plt.legend()\n", "plt.show()\n", "gradgradMS.gradsol_pack[0][1].name" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pyPhiConstant\n", "pydxLobatto(1)\n", "pyLobatto(1)\n", "pydxLobatto(2)_Fe\n", "pyLobatto(2)_Fe\n", "pydxLobatto(2)_ins\n", "pyLobatto(2)_ins\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "02621b1751d4427181528974e0f33f8a", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "start = -d/2\n", "end = d/2\n", "\n", "[print(o[1].name) for o in gradgradMS.gradsol_pack]\n", "\n", "plt.figure(6)\n", "H_MS = sum(gradgradMS.gradsol_comp) \n", "evalOnLine(mu * H_MS[1] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=True, label=\"MS\", show=False, N=1000);\n", "\n", "# [evalOnLine(mu * (gradgradMS.gradsol_comp[i])[1] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"x\", clear=False, label=\"MS_\" + gradgradMS.gradsol_pack[i][1].name, show=False, N=1000) for i in range(len(gradgradMS.gradsol_comp))];\n", "\n", "evalOnLine(mu * H_ref[1] , meshRef, pnt1, pnt2, plot=True, ls='-', marker=\"\", show=False, clear=False, label=\"ref\", N = 1000, title=r\"$B_y$\");\n", "\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Drawings" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "False\n", "pyPhiConstant\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5936c8429c2a41dfba10b219f03eaa46", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "db9b09efaf3341ae8575b45e219b252b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(H_ref[1].dim)\n", "print(gradgradMS.gradsol_comp[1].is_complex)\n", "\n", "H_MS = sum(gradgradMS.gradsol_comp)\n", "# H_MS = gradgradMS.gradsol_pack[1][1]\n", "\n", "print(gradgradMS.gradsol_pack[0][1].name)\n", "\n", "L2Draw((H_ref[0], H_MS[0]), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, diff=False)\n", "L2Draw((H_ref[1], H_MS[1]), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, diff=False, min = -10, max=10)\n", "\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4c18303893554927add43d3a97ba26ae", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ed5362cf0deb4c0ab1a91a3a53690dee", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L2Draw((H_ref[1], H_MS[1]), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = -50, max=50)\n", "L2Draw((H_ref[0], H_MS[0]), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = -50, max=50)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "194c65c8f02746d2a13ec4b46025f97b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "92ae135217974b169ad4014e0a907cf6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L2Draw((mu *H_ref[0], mu*H_MS[0]), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False})\n", "L2Draw((mu *H_ref[1], mu*H_MS[1]), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False})\n", "# lamMS = IfPos(cl_Phi(0, 0, inIron=False, material=\"multiscale\").phi, lambda1, lambda2)\n", "\n", "# Draw(lamMS * IfPos(y, -grad(sol_ref), H_MS)[0], meshMS, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False},min = -200, max=200)\n", "# Draw(lamMS * IfPos(y, -grad(sol_ref), H_MS)[1], meshMS, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False},min = -20, max=20)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "7b3c19aedeaa46d898b7eecdbe96c65d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "WebGuiWidget(layout=Layout(height='500px', width='100%'), value={'gui_settings': {'Objects': {'Wireframe': Fal…" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L2Draw((B_ref.Norm(), mu * H_MS.Norm()), meshRef, settings={\"Objects\":{\"Wireframe\":False}, \"deformation\": False}, min = 0, max = 1e-4)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "diff energy 3.0668649924192125e-07 3.0876040950623074e-07 -2.073910264309498e-09 -0.6716891804963248 %\n" ] } ], "source": [ "# print(\"Norm soll diff\", Integrate((sum(sol_comp_MS) - sol_ref)* (sum(sol_comp_MS) - sol_ref)/( (sol_ref)**2) , meshRef)*100, \"%\")\n", "print(\"diff energy\", energy_MS, energy_ref, energy_MS - energy_ref, (energy_MS - energy_ref)/energy_ref * 100, \"%\")\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "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.10.12" } }, "nbformat": 4, "nbformat_minor": 2 }