diff --git a/notebooks/2015-11-23-2d-tie-contact.ipynb b/notebooks/2015-11-23-2d-tie-contact.ipynb index 77c932a..7ff8b1a 100644 --- a/notebooks/2015-11-23-2d-tie-contact.ipynb +++ b/notebooks/2015-11-23-2d-tie-contact.ipynb @@ -484,7 +484,7 @@ "\n", "\n", "\n", - "Put some load to the top, dx=dy=0 on left boundary." + "Put some load on the top, dx=dy=0 on left boundary." ] }, { @@ -503,33 +503,108 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Found 5 element sets: LOWER_TO_UPPER, RIGHT, UPPER_TO_LOWER, LEFT, LOAD\n" - ] - }, { "data": { "text/plain": [ - "Dict{ASCIIString,Any} with 2 entries:\n", - " \"nodes\" => Dict(68=>[71.42857142857142,9.999999999999998],2=>[95.0,-4.…\n", - " \"connectivity\" => Dict(11=>(:SE2,:OTHER,[11,12]),134=>(:TR3,:OTHER,[75,96,76]…" + "create_problems (generic function with 1 method)" ] }, - "execution_count": 2, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "mesh = parse_aster_med_file(Pkg.dir(\"JuliaFEM\")*\"/geometry/2d_beam/BEAM.med\")" + "using JuliaFEM.Core: Element, MortarProblem, calculate_normal_tangential_coordinates!\n", + "\n", + "phi = pi/4\n", + "rmat = [cos(phi) -sin(phi); sin(phi) cos(phi)]\n", + "\n", + "function create_problems()\n", + "\n", + " mesh = parse_aster_med_file(Pkg.dir(\"JuliaFEM\")*\"/geometry/2d_beam/BEAM.med\")\n", + " \n", + " for (k, v) in mesh[\"nodes\"]\n", + " mesh[\"nodes\"][k] = rmat*v\n", + " end\n", + " \n", + " field_problem = PlaneStressLinearElasticityProblem()\n", + "\n", + " # field problems\n", + " joo = Dict(:QU4 => Quad4, :TR3 => Tri3)\n", + " for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype in keys(joo) || continue\n", + " element = joo[eltype](elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"youngs modulus\"] = 900.0\n", + " element[\"poissons ratio\"] = 0.25\n", + " push!(field_problem, element)\n", + " end\n", + "\n", + " # neumann boundary condition -1 on y direction\n", + " for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == :LOAD || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " # FIXME\n", + " # element[\"displacement traction force\"] = rmat*[0.0, -0.01]\n", + " f = rmat*[0.0, -0.01]\n", + " element[\"displacement traction force\"] = Vector{Float64}[f, f]\n", + " push!(field_problem, element)\n", + " end\n", + "\n", + " # boundary conditions\n", + " boundary_problem = DirichletProblem(\"displacement\", 2)\n", + "\n", + " for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == :LEFT || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"displacement\"] = 0.0\n", + " push!(boundary_problem, element)\n", + " end\n", + "\n", + " info(\"created $(length(get_elements(field_problem))) field elements.\")\n", + " info(\"created $(length(get_elements(boundary_problem))) boundary elements.\")\n", + "\n", + " # Contact definition: contact pair is `LOWER_TO_UPPER <--> UPPER_TO_LOWER`:\n", + "\n", + " mortar_surface = :UPPER_TO_LOWER\n", + " slave_surface = :LOWER_TO_UPPER\n", + "\n", + " master_elements = JuliaFEM.Core.Element[]\n", + " for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == mortar_surface || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " push!(master_elements, element)\n", + " end\n", + "\n", + " contact_problem = MortarProblem(\"displacement\", 2)\n", + " for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", + " eltype == :SE2 || continue\n", + " elset == slave_surface || continue\n", + " element = Seg2(elcon)\n", + " update!(element, \"geometry\", mesh[\"nodes\"])\n", + " element[\"master elements\"] = master_elements\n", + " calculate_normal_tangential_coordinates!(element, 0.0)\n", + " push!(contact_problem, element)\n", + " end\n", + "\n", + " info(\"# of master elements: $(length(master_elements))\")\n", + " info(\"# of slave elements: $(length(contact_problem.elements))\")\n", + "\n", + " return field_problem, boundary_problem, contact_problem\n", + "\n", + "end" ] }, { @@ -543,115 +618,11 @@ "name": "stderr", "output_type": "stream", "text": [ + "INFO: Found 5 element sets: LOWER_TO_UPPER, RIGHT, UPPER_TO_LOWER, LEFT, LOAD\n", "INFO: created 104 field elements.\n", - "INFO: created 4 boundary elements.\n" - ] - } - ], - "source": [ - "field_problem = PlaneStressLinearElasticityProblem()\n", - "\n", - "# field problems\n", - "joo = Dict(:QU4 => Quad4, :TR3 => Tri3)\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype in keys(joo) || continue\n", - " element = joo[eltype](elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"youngs modulus\"] = 900.0\n", - " element[\"poissons ratio\"] = 0.25\n", - " push!(field_problem, element)\n", - "end\n", - "\n", - "# neumann boundary condition -1 on y direction\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == :LOAD || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"displacement traction force 2\"] = -1.0\n", - " push!(field_problem, element)\n", - "end\n", - "\n", - "# boundary conditions\n", - "boundary_problem = DirichletProblem(\"displacement\", 2)\n", - "\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == :LEFT || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"displacement\"] = 0.0\n", - " push!(boundary_problem, element)\n", - "end\n", - "\n", - "info(\"created $(length(get_elements(field_problem))) field elements.\")\n", - "info(\"created $(length(get_elements(boundary_problem))) boundary elements.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Contact definition: contact pair is `LOWER_TO_UPPER <--> UPPER_TO_LOWER`:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO: created 4 boundary elements.\n", "INFO: # of master elements: 14\n", - "INFO: # of slave elements: 20\n" - ] - } - ], - "source": [ - "using JuliaFEM.Core: Element, MortarProblem, calculate_normal_tangential_coordinates!\n", - "\n", - "mortar_surface = :UPPER_TO_LOWER\n", - "slave_surface = :LOWER_TO_UPPER\n", - "\n", - "master_elements = JuliaFEM.Core.Element[]\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == mortar_surface || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " push!(master_elements, element)\n", - "end\n", - "\n", - "contact_problem = MortarProblem(\"displacement\", 2)\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == slave_surface || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"master elements\"] = master_elements\n", - " calculate_normal_tangential_coordinates!(element, 0.0)\n", - " push!(contact_problem, element)\n", - "end\n", - "\n", - "info(\"# of master elements: $(length(master_elements))\")\n", - "info(\"# of slave elements: $(length(contact_problem.elements))\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO: # of slave elements: 20\n", "INFO: Starting solver divided_beam\n", "INFO: # of field problems: 1\n", "INFO: # of boundary problems: 2\n", @@ -673,16 +644,42 @@ "INFO: Assembling boundary 1: dirichlet boundary\n", "INFO: Assembling boundary 2: mortar problem\n", "INFO: Solving system\n", - "INFO: UMFPACK: solved in 0.0015990734100341797 seconds. norm = 104.93886213441557\n" + "INFO: UMFPACK: solved in 0.32906603813171387 seconds. norm = 1.0493886213441448\n", + "INFO: timing info for iteration:\n", + "INFO: boundary assembly : 2.0574679374694824\n", + "INFO: field assembly : 0.0727851390838623\n", + "INFO: dump matrices to disk : 9.5367431640625e-7\n", + "INFO: solve problem : 0.45780277252197266\n", + "INFO: update element data : 0.019611835479736328\n", + "INFO: non-linear iteration : 2.607689142227173\n", + "INFO: Starting iteration 2\n", + "INFO: Assembling field problems...\n", + "INFO: Assembling body 1: plane stress linear elasticity\n", + "INFO: Assembly: 10.0 % done. \n", + "INFO: Assembly: 20.0 % done. \n", + "INFO: Assembly: 30.0 % done. \n", + "INFO: Assembly: 40.0 % done. \n", + "INFO: Assembly: 50.0 % done. \n", + "INFO: Assembly: 60.0 % done. \n", + "INFO: Assembly: 70.0 % done. \n", + "INFO: Assembly: 80.0 % done. \n", + "INFO: Assembly: 90.0 % done. \n", + "INFO: Assembly: 100.0 % done. \n", + "INFO: dim = 210\n", + "INFO: Assembling boundary problems...\n", + "INFO: Assembling boundary 1: dirichlet boundary\n", + "INFO: Assembling boundary 2: mortar problem\n", + "INFO: Solving system\n", + "INFO: UMFPACK: solved in 0.0017130374908447266 seconds. norm = 1.249111411770011e-13\n" ] }, { "data": { "text/plain": [ - "(1,true)" + "(2,true)" ] }, - "execution_count": 10, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -691,23 +688,25 @@ "output_type": "stream", "text": [ "INFO: timing info for iteration:\n", - "INFO: boundary assembly : 0.09911894798278809\n", - "INFO: field assembly : 0.05243706703186035\n", + "INFO: boundary assembly : 0.09813404083251953\n", + "INFO: field assembly : 0.05019092559814453\n", "INFO: dump matrices to disk : 9.5367431640625e-7\n", - "INFO: solve problem : 0.07156205177307129\n", - "INFO: update element data : 0.0012559890747070312\n", - "INFO: non-linear iteration : 0.2243940830230713\n", - "INFO: solver finished in 0.22567105293273926 seconds.\n" + "INFO: solve problem : 0.07112407684326172\n", + "INFO: update element data : 0.0012018680572509766\n", + "INFO: non-linear iteration : 0.22066807746887207\n", + "INFO: solver finished in 2.829770088195801 seconds.\n" ] } ], "source": [ "using JuliaFEM.Core: DirectSolver\n", + "\n", + "field_problem, boundary_problem, contact_problem = create_problems()\n", + "\n", "solver = DirectSolver()\n", "solver.name = \"divided_beam\"\n", "solver.method = :UMFPACK\n", - "solver.nonlinear_problem = false\n", - "solver.max_iterations = 1\n", + "solver.max_iterations = 3\n", "solver.dump_matrices = false\n", "push!(solver, field_problem)\n", "push!(solver, boundary_problem)\n", @@ -715,6 +714,100 @@ "call(solver, 0.0)" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import PyPlot" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: displacement at tip: [0.12002620186301985,-0.15542771506722675]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "PyPlot.Figure(PyObject )" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "2-element Array{Float64,1}:\n", + " 0.120026\n", + " -0.155428" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function plot(field_problem, scaling_factor=30, time=0.0)\n", + "\n", + " fig = PyPlot.figure(figsize=(15, 4))\n", + "\n", + " g_tip = rmat*[100.0, 0.0]\n", + " u_tip = nothing\n", + " \n", + " for element in field_problem.elements\n", + " conn = get_connectivity(element)\n", + " X = element(\"geometry\", time)\n", + " u = element(\"displacement\", time)\n", + " x = X + scaling_factor*u\n", + " if isapprox(element(\"geometry\", [1.0, -1.0], time), g_tip)\n", + " u_tip = element(\"displacement\", [1.0, -1.0], time)\n", + " info(\"displacement at tip: $u_tip\")\n", + " end\n", + "\n", + " # undeformed\n", + " for i=1:length(X)\n", + " px1 = X[i][1]\n", + " py1 = X[i][2]\n", + " px2 = X[mod(i,length(X))+1][1]\n", + " py2 = X[mod(i,length(X))+1][2]\n", + " PyPlot.plot([px1, px2], [py1, py2], \"k-\", alpha=0.5)\n", + " end\n", + "\n", + " # deformed\n", + " for i=1:length(x)\n", + " px1 = x[i][1]\n", + " py1 = x[i][2]\n", + " px2 = x[mod(i,length(x))+1][1]\n", + " py2 = x[mod(i,length(x))+1][2]\n", + " PyPlot.plot([px1, px2], [py1, py2], \"r--\", alpha=0.5)\n", + " end\n", + " end\n", + "\n", + " PyPlot.axis(\"equal\")\n", + " PyPlot.axis(\"off\")\n", + "\n", + " return u_tip\n", + "end\n", + "\n", + "u_tip = plot(field_problem)" + ] + }, { "cell_type": "code", "execution_count": 11, @@ -723,47 +816,71 @@ }, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: XDFM: ndim = 210\n" - ] + "data": { + "text/plain": [ + "0.19637735038614154" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "xdoc, xmodel = JuliaFEM.Postprocess.xdmf_new_model()\n", - "coll = JuliaFEM.Postprocess.xdmf_new_temporal_collection(xmodel)\n", - "grid = JuliaFEM.Postprocess.xdmf_new_grid(coll; time=0.0)\n", + "norm(u_tip)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "true" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "isapprox(u_tip, [-0.025032650050963334,-0.19477533256579582]) || warn(\"different result\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "true" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "isapprox(norm(u_tip), 0.19637735038616433)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model 3: splitted beam, frictionless contact, small sliding\n", "\n", - "Xg = Dict{Int64, Vector{Float64}}()\n", - "ug = Dict{Int64, Vector{Float64}}()\n", - "for element in field_problem.elements\n", - " conn = get_connectivity(element)\n", - " X = element(\"geometry\", 0.0)\n", - " u = element(\"displacement\", 0.0)\n", - " for (i, c) in enumerate(conn)\n", - " Xg[c] = X[i]\n", - " ug[c] = u[i]\n", - " end\n", - "end\n", - "perm = sort(collect(keys(Xg)))\n", - "nodes = Vector{Float64}[Xg[i] for i in perm]\n", - "disp = Vector{Float64}[ug[i] for i in perm]\n", - "elements = []\n", - "\n", - "for el in field_problem.elements\n", - " isa(el, Element{Quad4}) || continue\n", - " push!(elements, (:Quad4, get_connectivity(el)))\n", - "end\n", - "for el in field_problem.elements\n", - " isa(el, Element{Tri3}) || continue\n", - " push!(elements, (:Tri3, get_connectivity(el)))\n", - "end\n", - "\n", - "#elements\n", - "JuliaFEM.Postprocess.xdmf_new_mesh!(grid, nodes, elements)\n", - "JuliaFEM.Postprocess.xdmf_new_nodal_field!(grid, \"displacement\", disp)\n", - "JuliaFEM.Postprocess.xdmf_save_model(xdoc, \"/tmp/beam_2d.xmf\");" + "Modification to the above: allow beams to slide in tangential direction without a friction. Global assembly operator can be modified by writing own functions `preprocess_assembly!` and `postprocess_assembly!`. Here we simply remove all kinematic constraints in tangential direction to achieve frictionless sliding between bodies." ] }, { @@ -777,264 +894,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING: using PyPlot.mesh in module Main conflicts with an existing identifier.\n", - "WARNING: using PyPlot.grid in module Main conflicts with an existing identifier.\n" - ] - } - ], - "source": [ - "using PyPlot" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABMQAAAF0CAYAAADMwuUoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3XdYU+cXB/BvQgh7iIKAKCqiaBVHBay4F0VxIbaOn1StrdRWqyLaZdWqtYA46t5a3NuquDfVFrTuLeAeoCICCmSc3x+3pKCASUgIlPN5Hh7a3Hvfe26W5OS85xUREYExxhhjjDHGGGOMsXJCbOgAGGOMMcYYY4wxxhgrSZwQY4wxxhhjjDHGGGPlCifEGGOMMcYYY4wxxli5wgkxxhhjjDHGGGOMMVaucEKMMcYYY4wxxhhjjJUrnBBjjDHGGGOMMcYYY+UKJ8QYY4wxxhhjjDHGWLnCCTHGGGOMMcYYY4wxVq5wQowxxhhjjDHGGGOMlSucEGOMMcYYY4wxxhhj5QonxBhjjDHGGGOMMcZYucIJMcYYY4wxxhhjjDFWrnBCjDHGGGOMMcYYY4yVK5wQY4wxxhhjjDHGGGPlCifEGGOMMcYYY4wxxli5wgkxxhhjjDHGGGOMMVaucEKMMcYYY4wxxhhjjJUrnBBjjDHGGGOMMcYYY+UKJ8QYY4wxxhhjjDHGWLnCCTHGGGOMMcYYY4wxVq5wQowxxhhjjDHGGGOMlSucEGOMMcYYY4wxxhhj5QonxBhjjDHGGGOMMcZYucIJMcYYY4wxxhhjjDFWrnBCjDHGGGOMMcYYY4yVK5wQY4wxxhhjjDHGGGPlCifEGGOMMcYYY4wxxli5wgkxxhhjjDHGGGOMMVaucEKMMcYYY4wxxhhjjJUrnBBjjDHGGGOMMcYYY+UKJ8QYY4wxxhhjjDHGWLnCCTHGGGOMMcYYY4wxVq5wQowxxhhjjDHGGGOMlSucEGOMMcYYY4wxxhhj5QonxBhjjDHGGGOMMcZYucIJMcYYY4wxxhhjjDFWrnBCjDHGGGOMMcYYY4yVK5wQY4wxxhhjjDHGGGPlCifEGGOMMcYYY4wxxli5wgkxxhhjjDHGGGOMMVaucEKMMcYYY4wxxhhjjJUrnBBjjDHGGGOMMcYYY+UKJ8QYY4wxxhhjjDHGWLnCCTHGGGOMMcYYY4wxVq5wQowxxhhjjDHGGGOMlSucEGOMMcYYY4wxxhhj5QonxBhjjDHGGGOMMcZYucIJMcYYY4wxxhhjjDFWrnBCjDHGGGOMMcYYY4yVK5wQY4wxxhhjjDHGGGPlCifEGGOMMcYYY4wxxli5wgkxxhhjjDHGGGOMMVauSAwdAGOs7Lp+/TouDRyI9549g9LYGHKJBMmOjnjk4gKFWAyFkRGyTUzw3N5edYw4JwcVU1Mhk0ggNzZGjlSKHCMjwNjYgFcCzJ07F0+ePMHgwYNRo0YNg8ZSXFOnTkVOTg5Gjx4NGxsbQ4ejtezsbEyZMgVSqRSffvopnJ2dDR2S1h4+fIgFCxbAyckJ/fr1g62traFD0trOnTsRFxeHwMBANG7c2NDhFMu8efPw+PFjDB8+HA4ODoYOp1gmT54MmUyGkJCQMv1akclk+Omnn2BpaYmhQ4eW6dfK1atXsXbtWlSqVAm9e/cu04/LkSNHcPToUQQHB8PNzc3Q4RTL7Nmz8fTpUwwZMgSurq6GDqdY5s6di/T0dAQHB6NKlSqGDkdrSqUSEyZM+E+87gHhfSwlJQVff/016tSpY+hwGGNFEBERGToIxljZNGrIELy3bBlqQ8iuGwO4DuDsP/9tDOAhgOV5jnkPwNw3xnEBIAIg/+dnC4BHAGQAcgDEA7iWZ/9WABoCyAKQDYAAWAF4BSATwHMAF/Mcn/ubMcYYY4yxkvDFF19g/vz5hg6DMVYETogxxrR2MDoascHByAoOhqW7e8E7KZWA+N/Z2ZKcHNgnJ0Mil0Mik0Eik8Hu2TOY5ORAkpMDY7kct2vWhNzYGEYKBcQKBZ44OSG1YkXVGE3++gu1bt5UbTfOyYFlRoZqe7aJCa6/916+ME75+kJmYqL6/87bt+Plw4e48+gRsgFUNjWFKCsL2QCMpVK41K8PmYkJXpmb45WFBVIrVkSKoyNk/1TCQSTSyX2oa8uXL0dSUhIAwMXFBUOHDjVwRJpTKpWYM2cOnj59ChcXF9y/fx8A0LhxYwQGBho4Ou1MnToV2dnZICJYWVlh7Nixhg5JKytWrEBiYiLMzMzw+vVr9O7dG56enoYOS2OJiYlYsWIFjIyMoFAo4O7ujuDgYEOHpbHXr1/j119/RUZGBqpUqYIHDx4AAOrXr4+PP/7YwNFpJzw8HBn/vJ83b94c/v7+Bo5Ic5mZmZgxYwZycnJQtWpV3Lt3DzY2NhgzZoyhQ9PayZMnsWfPHgBAixYt4OfnZ+CINKdUKjFt2jRkZWWpbgsODoZ7YX+/lAGnTp1CTEwMAMDCwgLDhw+HhYWFgaPS3KZNm3DhwgU4ODggOTkZAODv74/mzZsbODLt5FaF79q1C126dDF0OIyxohBjjGnp/N69NAGg83v3GjaQ16+JkpOJbt4kOn2a6M8/ie7dI0pMJLp+nejSJSK5XLV7eno6Rbi60niAIqVSuvvRR5Tk7U2HAbplbk6PAXoNENnbE1WrRuTqStSsGdGECcLPxIlEq1blj0GhIAoPJ1q4kGjtWqKYGKJdu4j++ovo/v1859eXe/fukUgkIk9PT6pbty6JxWJKS0vT+3l1SaFQUIMGDQgADRkyhFavXk0AyNnZmQBQnz59DB2ixg4ePEgAaOjQoTRixAgCQH379jV0WBpbtWoVAaDmzZtTZmYmmZiYkLm5OWVnZxs6NI1cunSJJBIJSaVSunHjBlWqVIlsbW0NHZbGbty4QVZWVgSAJk6cqHqtVK9enQDQoEGDDB2ixvbv308AqF+/fmRhYUHW1taGDkljaWlpZGdnRwBoyZIlqscFAM2aNcvQ4Wkt9zpsbW1JJBJRfHy8oUPSWOfOnVX/jgAgIyMjMjc3p/T0dEOHprXcxyUwMJAAkIWFBV26dMnQYWnM0dGRrKysiIgoNjaWbGxsCAA1bdq0zP0dQ0R05swZAkBnzpwxdCiMsXfghBhjTGulJiGmge3bt5OZmRkBID8/P9WH+S2zZ9NQgM4HBtKq2rUpDqDNNWsS7dhBdOsW0cWLRLdvE125IiTdLl7MP3BaGlFgIJGfH1Hr1sJPjRpCMs3Vlah6daLPPyeaM4do2TKideuIEhLyj3HvHlFcHNGNG0TPnglJNg106NCBAFB8fDzFxMQQABo4cKC2d1WJUygU1LhxYwJAAwYMIKJ//9iPjo6mRo0aEQDq0aOHgSPVjJeXF4lEInr27BkRkSrhFx0dbeDI1JeSkkJSqZTMzMxUHx4XLVpEACgoKMjA0anv0aNHZG5uTmKxmE6cOEFERAMGDCAAdO3aNQNHp77Y2FiSSqUkEolo+fLlRJT/tVKvXj0CQF999ZWBI9WMh4cHicViSk1NpW+//ZYA0Pz58w0dltoyMzPJ0dGRANDMmTOJ6N/HxdzcnIyMjCgxMdHAUWon9zoiIyNJLBZThQoVSCaTGTosteXG7+XlpfrvkJAQAkDe3t6GDk9rudeyevVqio6OJrFYTBKJhPbv32/o0NSWlpZGAKhTp06q27Kzs8nf358AkKmpKW3dutWAEWqOE2KMlR2cEGOMaa0sJcRkMpnqG1SpVEqrV68WNjx7RvTzz3S+Z0/6DKAtc+YQbd1KZ6ysqC1A2xo2FBJgmsjOJnr0iOjYMaKNG4Uk2E8/EW3eTLR3L9HWrUSrVwsVbXktXfpvMq11ayIfHyIPD6LGjYlatCDq2lVI0B04QPTHH0Rnz6qSZrnVYQ3ee081nKOjI5mYmJBCw8SaISgUCvL29iYA9PHHH6tuz/vHft59PvzwQwNGq760tDQSiUTUpEmTfLdZWFiQRCIpMx+Oc5N4O3fuzHd7buKlLFSLZGZmkr29PQGgtWvXqm6/ePFimaqoWr9+vepD78GDB1W3532tyGQyqlmzJgGgsWPHGjBa9eV+gMx9bctkMjIxMSEHBwcDR6ae7OxsqlatGgGgSZMmqW7PfVwmTpxIIpGIXFxcysR78pvyPr8iIiIIAHXu3NnQYanlyZMnZGxsrEro572W3KTL9OnTDR2mVvJeCxHRiRMnVMnyRYsWGTg69fz8888EgDZt2vTWtvXr15OJiQkBoO7du5eZJCwnxBgrO3iVScbYf97p06fh5+eH58+fw9PTE0eOHIFdhQrA5s3AihWAXI5nnp5YCqB1hQrAq1do3LgxniYnY/H58zAbMQJ+q1YBtWqpd0KpFHB0FH400bs30KwZkJoKPH8O3L8PXL8OvHgBvHwJKBTAkyfAq1fCj0wGNGwIABg8eDCICIerVwe6dAEsLHCoenVcfPwYVzw9Ub95c8DaGnB2FuKqVQuoWxewstIsRj1p06YN4uLi0KNHD6xfv77AfcRiMU6dOoW2bdti7969aNeuHQ4ePAhxnh51pc33338PIsLkyZNVt1lbW2Pv3r1o1aoVmjdvjgcPHpTqa5gyZQouXryIoKAgBAQE5NsWExODmjVrokePHqpeb6WRUqlEo0aNkJKSgvDwcPTt21e1rX79+rC2tsbu3bsNGKF6IiMjMXbsWJibm+Ovv/5C/fr1C9xPIpHg8uXLqF27NiIiImBlZYUffvihhKPVTEhICABg0aJFAIRrGDRoEBYuXIiNGzfio48+MmR4RZLL5ahfvz7u3r2LsLAw/Pjjj2/tU6tWLYwcORIzZ87EkCFDsHz58gJGKhvCwsKwadMmxMTEYM2aNejfv7+hQypS69atIZPJsGPHDlhaWubb9vvvv8PBwQFjx45Ft27dynQ/MUDo73blyhU0adIEQ4cORUJCAsLDww0dVpE2bNgAIyOjAnuEfvzxx/Dz80O7du2wY8cOODg4YN++ffDy8jJApIyx/yRDZ+QYY2VXWagQGzVqFIlEIhKLxTRlyhThxpQUopUriXr3Jho9mujBg/zfssbGEv3wA8lkMqperRr1BeiIn59Q9VWa/NOX7MGDB0J1WIMGQhXar78STZ5MijFjaJdYTH8ZGRE1aCD0RDMxEX7nTuUcNkzoe7ZundD3zADfZrZr167QaoM3v/3O1bFjR1U/q9JcbWFjY1Nof6oJEyaU+iqLa9eukVgspooVKxZ6Pw8fPpwA0Pjx40s4OvW1bNlSNUWqID169CAA9ODBgxKOTH3Dhg0jAFSpUiV6VMB7UUGvlbxT+KKiokoyXI3cvn2bAFCzZs3y3f769WuSSCRUrVo1A0X2bgqFgho2bFjo8+vNx8Xd3Z0AlKkpbURvX0d6ejqZmZmRsbExPXnyxMDRFW7s2LH5puETvX0t8fHxJBKJyMnJqVT/e1KQwv6NTE1NpapVqxIA6tWrl4GiezeFQkESiYTq1q37zn3Dw8NJLBaTSCSiESNGlEB02uMKMcbKjtL7lTRjjBXD3bt34ebmhpkzZ8LZ2RnXrl3D9+PGAUeOAAsWCFVXkycDUVFC1VReSiVgZSVUWVy9imOVKmHdvn34c/hwICXFMBdUECMjAMCgQYNARFi2bBnQqxcwfDjwww8QR0bi0Ndfw0ehwLbBg4VqMldXoGNHIDwc+OILwM9PuH65HEhMBK5ezX+O+fOBHj2AQYOAsDAgIgKYNAlYsgQ4fFioYivGYsX+/v44fPgwOnTooFGFzv79+xEQEICTJ0/C29sbSqVS6xj0ZdeuXUhLS8OAAQMK3D5x4kQ0a9YMMTExmDt3bglH925KpRLt2rUDEWH//v2FVrHNmjULFStWxM8//6xaHaw06d+/P06cOAF/f38sWLCgwH1yV/8rjZUUSqUSAQEBmD9/PmrVqoU7d+7AUc3qU3Nzc1y9ehUVK1ZEaGioqvqqtPn8888B4K34TE1NERQUhLt37+LQoUOGCO2dWrRogfPnz6Nfv36FPr/yOn78OIyNjdGzZ0+8evWqBCLUD0tLS2zZsgUymQytW7c2dDgFOn36NCIjI+Hk5ISVK1cWul/Tpk0RFhaGR48eYeDAgSUWnz7Z2toiMTER77//PrZs2YKmTZtCLpcbOqy3HDhwAHK5HL169XrnvmPHjsWNGzfg4uKCX3/9FTVq1MCdO3dKIErG2H+aoTNyjLGy6/zBgzQMoPN5+tiUBnPmzCEjIyMCQJ999pnwje/Tp0SzZwu9vA4dIsrJyXdMvm9ZDx4k+qchMpHQUNzZyoomAXRu8GCirKySvqRC5asOK8Dr169JIhbTaktLou7diaKiiNq3FxYBUMeJE0QREURhYUSDBhH16EFUs+a/FWYNGhBNmSL0SfvtN6Lt24VVNfMHUeDQ3bt3JwDUqlWrQk9f2LffuYKCgggANWjQoNT1FmncuDGJRKIiV8h6/fo12djYkFgspotvLtRgYJ9++ikBoDFjxrxz3yNHjqhWBCtNvvvuOwJAnp6e76z8MDc3p6pVq5ZQZOqRyWSqxSR8fX2LvIaiXispKSmqVdtK22IOz549I5FIVGiFSGpqKonFYvLw8CjhyN4tt1K1e/fuhe5T0OOycuVKVYVrWVHY8yt3UYrS1qtOJpNRhQoVSCwW040bN/JtK+xaPDw8CADFxMSUZKjF8q5/I4lI1T+1atWqlJqaWoLRvVvu3wGaVBkqFArVgghGRkaqBSxKE64QY6zs4AoxxpjW5BUqYP4/v0uDjIwMNGvWDMOHD4eFhQWOHTuGxYsXC5UtNjZAtWpASAjQrh1gbFz4QDKZ0AfsH5UqVcLJixex3NQUG1aswJWffhKqyEqBfNVhBTA1NcW0999HlYwMXGnXTuhTplAAe/aod4IWLf6tDFu+HNi2DbhxA9i/X6ge++474f50dwdMTIDkZCArK/8YPXsCnTsD/fsL1WthYfi9dm1U37EDYe7uOLJqldb356ZNm9C/f39cvHgRDRo0KDXfgD9//hznzp2Dl5cXrK2tC93P1NQUR48eBQC0atUKOTk5JRRh0Y4fP45ly5bBzc0NkZGR79y/TZs26NSpE06fPo2NGzeWQITvtnjxYvz888+oUqUK4uPj39mnzdfXF/fu3cOLFy9KKMKivXjxAjVq1MC5c+fQp08fxMbGat1rrlKlSrhy5QosLCwQHByMLVu26Dha7X355ZcgIsyZM6fA7ba2tujUqROuXbuG06dPl3B0hQsMDMSBAwfQrl07bN++XaNjP/nkE3Ts2BEnT57E7Nmz9RRhyVi5ciWcnJwQGRlZqh6f7t27IzU1Fb/88ovafcGOHTsGY2NjBAUFISMjQ88RlpwtW7YgLCwM9+7dg6urKxISEgwdksrx48dRsWJFODg4qH2MWCzGggULEBsbC0tLS4waNQre3t54+fKlHiNljP1XcUKMMfafkNsY96+//oKfnx9SkpPRytwcyP2jViIRpv7Z2797sFq1AB+ffDe5urpiV3w8thoZYeMvvyBx7txiTRXUhYcPH+LAgQOoX79+4Q1mnzzBcEtLxAEI/u03oGpVwM0NKM70IyMjoHZtIcnVpw/wwQfC1MuPPgI++0wYP5dSKUy39PcXblcocH7NGtS5eRNjjY0Rnp0N8bhxwvTVGTOAZcuANz5cWgKQpqUVmjRbvXo1hgwZgmvXrsHDw6NUJJW++eYbEBGmTZv2zn0bNWqEyMhIpKamokOHDiUQXdFycnIQEBAAiUSiStapY8uWLTAxMcHgwYMN/hjs2bMHISEhsLa2xqVLlyDNk+AuzMiRIwEAUVFR+g7vne7cuYPq1avj/v37+Oabb7Bu3bpij+ns7IzLly/D1NQUvXv3xh51k+J6lJWVhc2bN6Nq1apo3759ofstWbIEwL+N9w3tk08+wbZt2+Dt7Y0DBw5oNcauXbtgY2OD0NBQJCUl6TjCkiMWi3Hs2DGIRCJ06tSpVHwpsWbNGsTExMDLywthYWFqH+fg4IDly5fj1atXRT4fy6KIiAgsXLgQ6enpqFevHmJjYw0dEh4+fIjU1FS0adNGq+N9fX2RnJwMf39/xMfHo3Llyti2bZtug2SM/edxQowxVqbl9p7o3r07FAoFVq9ejb0rV0IaHQ3s2gXcvKn5oLVqAe+//9bN9evXx7KjR7GLCGtHj8b9zZt1cAXay11ZcunSpYXvtHkzTKyscKhJE5w5cwZ3794F2rYVen+lpuo/SLFYSJQNHw789BMGZ2Wh0aNH6N2gARzv3IEoOlqoQAsIABo1Auzs3kp8dQXQas4coFMnIChISLr973/AsGHAlClAdDSWDB2Kr0NCkJCQAHd3d4P35lm3bh3s7OzQrl07tfYfPXo0OnbsiBMnTmDq1Kl6jq5oXbt2RXp6OmbOnAkXFxe1j7O0tMTMmTORmZmJ4OBgPUZYtHPnzqFbt26QSqU4d+4cbG1t1Tquc+fOkEql2LBhg54jLFp8fDzq1KmDly9fYv78+WolVdXl6uqKs2fPQiqVIiAgQKOEpz6MHTsWcrn8nb3bXFxc4OvrizNnzuCmNu/pOvTll1/it99+Q4MGDXDq1Cmtq/akUin27dsHpVKJVq1alco+iOpyd3dHREQEUlNT0b17d4PGkpycjMGDB8PMzAyHDx/W+Pj//e9/8Pf3R1xcXKlIjuvS0KFDsWfPHiiVSrRu3Rpr1qwxaDyzZs0CAHz11VdajyGVShETE4P169eDiBAYGIgePXqUisQsY6yMMOiETcZYmWboHgnx8fFkZ2en6hH07OFDor17iSZOJJo3j+jOHbXHUqcPR66dO3dSe4CmGhvT0+PHi3MJWnv06BGJRCJ67733Ct/p2jWiCROIzp1TPVYBAQFEmZlEkyYR/fFHicVLRKqeH3Xr1lV7Ja/Vq1eTM0CHR48mWrJE6Fc2ciRRy5ZEdesSOTsTGRsTmZoSubrSfXt7mgVQXzs7yjx6lCghgejFCyKlUs9X969NmzYRAAoLC9PoOJlMRvb29iQSiejPP//UU3RFy30dvLnanyZy+/AY4n3h3r17ZGZmRmKxmE6ePKnx8c2bNyeRSESvC+l7p29bt24lIyMjMjIyop07d2p0rCbvYWfPniVjY2OSSCQGe64pFAoyNTWlihUrqrX/lStXCAC1bt1av4EV4ZtvviEAVKtWLbV7Fr7rcRk1ahQBoEGDBukyVJ1T5/nl7e2t9nNQX9TpA/auaymq/1hpo8nrPtelS5fIwsKCANCkSZP0GF3RateuTVKpVGfjpaamUuPGjQkAVahQgeLi4nQ2tqYM/fcxY0x9XCHGGCuTQkND4e3tjRcvXmDKTz/h/NSpsBs7FoiLAzp0AIYOFXqG6UFAQACCV67E3zIZFvn5If3NlRlLwLt6hwEAqlQRVpT09ESTJk1Qq1Yt7NmzB68AwMMDuHixpMLFqFGjsHDhQri7u+PChQsaVVU8BPCwSRNgyBDg+++BmTOFFS6nTwcGDBCmwdrYADVqoIq/Pzx9fVHx+XPM6dIFWYsXC/s/ffrvgHfvAuvWAadOCT3PdFyZMWnSJIjFYkycOFGj4yQSCf744w+IxWJ06NChxHvYPH/+XFVZoe00MECYCiYSiUq8UiQjIwMNGzbE69evsWHDBnzwwQcaj/HFF1+AiDBv3jw9RFi0OXPmoFevXjA2NkZcXBwCAgL0dq5GjRrhxIkTICK0bNkSFy5c0Nu5CvPzzz8jKysL3333nVr7161bFw0bNsTx48fx+PFjPUf3tqlTp+KXX35B1apVcfnyZUgkEp2MO2PGDLi7u2PFihXFet2VBocOHYK5uTkGDRpkkBVnx40bh2vXrmHAgAHw9/fXehyJRIL9+/eDiNC6desyXb1XkPfeew+JiYmoXLkyJkyYYJCVNZVKJW7duoUGDRrobExbW1v8/fffCA8PR1paGnx8fPD111/rbHzG2H8TJ8QYY2XK3bt34ebmhhkzZsDZ2Rk3/vgD3z9+LCRHrK2FpImvr9DnSlsnTgCXLhW5S/Ann6Dl9Om49Po1Qlq2RM6TJ9qfT0OPHz/Gvn37UK9ePfi80essH0tL4b4QiQAIPUQUCgXGjBkjNMLv06dE4h03bhxmzZqFGjVq4NKlS8X/IPniBbBiBXDmDNC+vTDFNfdx//JLtI2NheOUKfguMxMNFi/Gi86dhamYuc6dAxYtAr79VpjO2bkz8OGHQPfuwFdfCb3M7t9/e3EANTx+/BiXLl1C8+bNYW5urvHx7u7uWLRoETIyMtCqVSuNjy+Otm3bIicnB+vXr4elpaXW47i5ueGLL77A/fv3MWnSJB1GWDilUglPT088f/4cUVFRCAoK0mqcfv36wcjICKtWrdJxhEULDQ3FiBEjYGtri+vXr6NJkyZ6P6ePjw8OHjwIhUIBb29vXL9+Xe/nzCsqKgoWFhaq3m3qWLRoEYgIQ4cO1WNkb5s9ezZ++OEHODg44MqVK2r1pNPE8ePHYWxsjJ49exp8undxWFpaYvPmzZDJZGjdunWJnvv06dOIjIyEk5MTVq5cWezxmjZtirCwMDx69MggCSN9c3BwwO3bt/Hee+9h1apVJZ74W7duHZRKJfr27avzsceOHYsbN27AxcUFv/76K2rUqIE7d+7o/DyMsf8GTogxxsqMuXPnombNmkhMTMTnn36Ku2vXwu3QISA7GxgzBpgzB3ByKv6JLl4E7t17525fh4bC7ZtvYPfsGX5p0ADKzMzin1sNavUOK0DPnj1RsWJFrFy5Eko7O6GqSs/Gjx+PiIgIVK1aVTcfJG/dEpJZGRnA4MFAxYpCwi8wUFgRc+9e4PZtfP/994iYPh23UlNRw88Pyc+e/TtGt25ATAwwd67wvOnWDahcGXj2TFhsYMECYOlS4JdfgMhIYXXNP//MH0ch/UnGjRsHQEg+auvTTz9Fr169cPbsWY0aQhfHtGnTcOHCBQQGBqJbt27FHm/OnDmws7PD5MmTS6RSxNfXF0lJSRgxYgRGjx6t9ThisRienp64fPlyifWgCQoKwowZM+Dq6oq7d++imp4qWwvSpk0b7Ny5Ezk5OWjcuHGJfWhcunQpXrx4gWHDhmlULerj4wN3d3fs2rWrxFaUW7FiBUYX7d0cAAAgAElEQVSOHIkKFSrg+vXrxUoWF8bR0RFLlixBZmYmOnbsqPPxS5K/vz+Cg4Nx7do11fuhvsnlcnTq1AkikQjHjh3Tuq/bm8LDw+Hh4YHo6OhSsQiFrpmamuLChQvw8/PD8ePHUadOnRJLyC5fvhwA9JbcdnNzw+3btxESEoLbt2/Dzc1N1bOMMcbyMeR8TcZY2VZSPRLS09PJx8eHAJC1tTX9uXGj0CNs4kShZ1hWVrHPka8Px8yZRAcPqn3s6E8+oTCAJlavTors7GLHUpTc3mH16tXT6vjw8HACQNOnT9dxZG+bPHkyASBnZ2fKzMzUagzV4/Lbb0SHDwuP+erVQh80IqLdu4latyZKSSFSKIhWriQKDxf6hhHRnDlzVM+be/fuqXfS58+JHjwgunCB6MgRoi1biN7sR9WvH1H37kSffUY0fjzRggVES5eSr4kJuajZE6koCoWCXFxcCADt37+/2OMV5caNGyQWi8nOzk7tvkjqOHjwIAEgb29vnY1ZkKCgIAJA3bt318l4uc+ZJUuW6GS8wshkMlXPJS8vr2Lf99r0Esq1adMmEolEZGlpSQ8ePChWHOpwcnIiqVSq1TXHxMQQABowYIAeIstvw4YNJBKJyMrKip48eaLVGJo8Lh07diQANGvWLK3OpU+aXIdCoSAnJycSiUQUHx+v99i6dOlCACgiIkKt/TW5lidPnpBUKiVzc3NKT08vbqg6V5zXfV7Dhg0jAGRnZ6f+v5XFYGlpSVWqVNH7eYiIYmNjycbGRvVem5aWpvdzcg8xxsoOrhBjjGlNkpqKYf/81pfff/8dDg4O+Ouvv+Dn54eU48fhc/kyYGwMfP454OcHmJjo9qQ5OYAGlUxRK1ci7cMPIbt9G1N9fAAi3caTh7bVYbnGjBkDU1PTd67qVlwREREYP348KleujOvXr2s1fTCXOQCb+/eFqr127YB+/YDc8WxshD5pdnbCipa9ewuP3fr1gEyGr776CkuWLMHLly/h4eGhXgVMhQqAszPQoAHQpo1QffZmP6rAQGGKpoWFsJLpunXIGDcOq7OzcV4uF1bBXLtWqFiLjwcSEwGZTO1rFovFOHXqFIyNjdGtWzc8f/5c7WM1oVQq0bZtWxAR9u3bp7O+SADQvn17dOjQAXFxcdiyZYvOxs0rLCwMmzdvxvvvv4/t27frZMzPP/8cIpEIixcv1sl4BcnIyIC7uzvi4uLQs2dPxMXF6fS+11RQUBBWrlyJjIwM1KtXD0/z9tzTsV27duHRo0fo16+fVtfs7++PKlWqYN26dcjSYlqzumJiYtCnTx+YmZnh0qVLcHBw0Nu5cu3atQs2NjYIDQ1FUlKS3s+nL2KxGMeOHYNIJEKnTp30Wm25Zs0a7N69G15eXnqpqHVwcMDy5cvx6tUrtG/fXufjlxbz5s1DVFQUnj9/Dnd3d5w+fVpv57p69SoyMjLQqVMnvZ0jL19fXyQnJ8Pf3x/x8fGoXLkytm3bViLnZoyVfpwQY4xpTy6H/T+/dT+0HL169UL37t2hUCiwdu1a7N27F9J69YReT59+qpvpkQV5/hxQKDQ6ZNGePXjQtCkU585hqp6mvCQnJ2Pv3r2oW7duwQ3DHz8GEhKKHEMsFuOTTz5BSkoKduzYoZc4Z8+ejXHjxqFSpUq4ceNGsaYYmT99iqEAnC5dEvp9tWyp6okGQOgnlpsMA4REWZ8+QhP9c+cAAEOGDEF0dDRevXqFunXr4ubNm8W4un/06gWEhQkN+9etAw4fxkdWVvgGgPWIEUKyDBCSZXv2AL/9BuSdUnvpEhARIRz7xx/CY/dG/xYXFxesXbsWWVlZWjWIV0dISAgePHiAkSNHomnTpjoff9u2bZBKpRg4cKDOPxTPnTsX06dPR9WqVfHnm1Nai0EqlaJOnTo4e/asXnrq3L9/H66urrh9+zZGjhyJrVu36vwc2ggODsbChQuRlpYGDw8PvU1JHD16NMRiMWbPnq31GOHh4ZDL5Rg7dqwOI/vX0aNH0bVrV0ilUpw7d67EprFKpVLs27cPSqUSrVq1KtPN3N3d3REREYHU1FSdTMMuSHJysmohkMOHD+vlHADQv39/+Pv7Iy4uDlFRUXo7j6GNHj0aW7duhUwmQ7NmzfT6NwIAjfoHFpdUKkVMTAzWr18PIkJgYCB69uxZYlPjGWOlmIEr1BhjZdj5vXtpAkDn9+7V6bjx8fFkZ2dHAKh1vXqUvnTpv1Pk9EQ17WDVKmEKnhbTDxQKBX3i5kYTAArv21fnMXbu3JkAUGxs7Nsb5XKihQuJ5s8Xpg4WIT09ncRiMbm7uxNlZxOdPy8crwPz589XTbt49uyZ9gMplUQnT9K5Xr1oEEDrC5u+Fh1NtHbt27cnJwtj5JE7/cnU1JQuXbqkfWwFuHfvHgGgdu3avb1RLid69ix/PHv3EvXoQdSmjfB8a92aqEkTIm9vom7diIYOJYqKIjp2jIb0708AaMiQITqN+cSJEwSAatasqdNx35Q7BbGvDl8TO3bsIJFIRLa2tnqZ/pI73XfTpk06Hffs2bNkZmaml2lxupo6NX36dAJAjo6OWk91Lsyff/5JACggIKDYY1WsWJFMTU1J8Y73O03FxcWRRCIhY2NjOn/+fLHH0+ZxGTVqFAGgQYMGFfv8uqLt8yt3WnB0dLTOY/Lw8CAAFBMTo9Fx2lyLTCajChUqkFgsphs3bmgaqt7o6nWfV3x8PJmamhIAioqK0tm4uapWrUrm5uY6H1ddqamp1LhxYwJAFSpUoLi4OJ2fg6dMMlZ2cIUYY6xUCQ0Nhbe3NzJSUxE9aBCO9ukDy1evgPT0Ejm/JCdH+A8tpviJxWIsvXoVDytXhnzdOiwaPlxncSUnJ2PPnj3w8PCAb271UV6LFwNHjgBdu/5bLVUIS0tLfPjhh7h58yYuxcYCW7cKlUzFtGzZMgwbNky1Up5d3pUdNZGVBWzcCOzbh6e1amEVALmZWcH72tkBBVVv2NsLv//8U1U199FHH2H79u3IyclBkyZNcO6fCjJdyJ2qExkZ+fZGIyMhzryVbX5+wLZtQvXYvHlCc//OnYVrefQIiI4GJk0CBgzAkpMnsdLGBs+XLsXRKVOAGzeEyrhiTM3NyclBly5dYGRkhCNHjmg9jjq++uor1K5dG+vWrcOFCxeKPd7p06cRGBgIExMTnDt3DtbW1jqIMr/cyoV58+bpbMyYmBg0bdoU2dnZ2Lp1K77++mudja1LoaGhmDRpEh4/fgwPDw/k5L4n6sCwYcMgEomwaNGiYo81fvx4ZGVl4aefftJBZIJLly6hRYsWICIcO3YMnp6eOhtbEzNmzIC7uztWrFiBAwcOGCQGXTl06BDMzc0xePBgnS6wMW7cOFy7dk1VvaVvEokE+/fvBxGV+IqMJa1p06a4efMm7OzsEBoaii+//FJnY2dlZeH+/ft6qUhWl62tLf7++2+Eh4cjLS0NPj4+pfb9mDGmf5wQY4yVCnfv3oWbmxtmzJiBlvb2uP/dd/hfjRrCFLkvvhBWASwBkuxs4T8KS8C863hjY8y6eRPpVlZImjsXy3XUq6vI3mE3bwJbtgg9r1xc1BpvwYIFAICh48cDjo5AMfuFrF69GkOGDIGVlRWuXr2KSpUqaTfQ48dCci8xEejTB48bNECRHzs6d/53emJBEhKAzZuFabAAunXrhpiYGMjlcnh7eyM+Pl67OPNQKpXYvn07nJyc0KRJE80ONjUF3nsPCAgAJk8GNm0S+pV98IHQK+3LL4H+/RE4eTLsJRIcnDABLxcuBGbNElbFzHX1KhAbK0wVVUP37t3x8uVLzJw5s0Smg8XExEAkEqFr167FGufu3bto2bIlAODEiRNwdXXVRXhvsbS0RPXq1XU2FXPRokUICAiARCLByZMn0bNnT52Mqy8//vgjwsLCcO/ePdSrV08n04oSEhLw999/w9fXF87OzsUeb/jw4bC0tMSMGTN0kpxISEiAl5cX5HI59u3bp7dpyuo6fvw4jI2N0bNnzxJb+U8fLC0tsXnzZshkMrRu3VonY54+fRqRkZFwcnLCb7/9ppMx1dG0aVOEhYXh0aNHGDhwYImd1xBcXFxw584d1KxZE/Pnz8eHH36ok9fZ0qVLQUSl4v4bO3Ysbty4ARcXF/z666+oWbMm7t69a+iwGGMljBNijDGDmzt3LmrWrIlXiYnYX78+jvr4wN7dHRg2TGhqXoLNpsVyOWBrK/xoydzKCuNu3IDczAwXvvkGW1atKlZMycnJiImJKbg6TKkEwsMBa2tAg284q1WrhiZNmuDUqVNIk8uBlSuFqiMtbNy4EcHBwbCwsMCVK1fg6Oio1Tg4dQr47juhKf7QoYCHh3bj5BKJhF5f5uZCk/1/Kl38/Pxw6NAhKJVKNG/eHLGxscU6zdKlS5GVlaWbb9H37QPOnxcSYe3aAWlpwLffwmr4cPSKicFUpRIfbNwIZd++QtVZru3bgR9+AIKChORaSAgwciQwbZpQhZaWptp13bp12Lt3L7y9vTFch1WMRXFzc8Pnn3+Ou3fvYsqUKVqN8fLlSzRs2BDZ2dnYsmWL3isMevfujaysLBw6dKhY43z33XcICQmBtbU1rl69Ch8fHx1FqF8REREYNmwYEhIS0LBhw2J/GP78888BAAsXLtRFeBCLxRg1ahTS09OLXcl3//591XNr27ZtpaJ5uqOjI5YsWYLMzEx01FNfypLi7++P4OBgXLt2DePGjSvWWHK5HJ06dYJIJMKxY8cgfkdFtK6Fh4fDw8MD0dHR2LNnT4meu6RZWlri5s2baNmyJfbt2wdPT89iV4yuXr0aIpEIAwYM0FGUxePm5obbt28jJCQESUlJqFmzZrH6GzLGyiDDzthkjJVlxe0hlp6eTs2aNSMRQN3Mzem5lxdR585Emza9sw+WruX24dg8dy7RhAlE9+8Xe8yHV6/St8bG9BlABzTscZJXQEAAAaATJ068vTE6Wug/deSIxuPGxsYSAPqsc2ehl1VBvbjeYevWrSQSicjc3Jxu376t8fFERJSTQ7R9u3C/L1wo9DX7h076oyQnE02dSrR+fb4+XidPniSJREJGRkZ08OBBrYd3c3MjiURCMplM+xiJiNLThb5iQ4cKz//bt4natSOaM0e1y+jRowkABQUF5T82O5voyhXhfoyKIho+nMjHh6h6dSJXV6E/2ezZlL5kCXUyNqbGUiml3blTvHg1pFAoqEKFCiSRSCglJUWjY2UyGVWrVo0A0Jw894c+PXnyhABQ586dtR6jX79+BICqVKlCqampOozubfroJURENHDgQAJATZo00bpf15MnT0gkElGDBg10GptCoSBTU1OqVKmS1mOkpKSQtbW1Xu47ouI/Lh07dtRLzzlNFfc6FAoFOTs7k0gkovj4eK3j6NKlCwGgiIgIrcco7rU8efKEpFIpmZubU3p6utZx6IK+XvdvCg4OVvUW1PT9Oy8TExNyc3PTYWS6ExsbSzY2NgSAvLy8itWfknuIMVZ2cIUYY8wgfv/9dzg4OODOn39iZr162DpqFCp8/LHQOyko6J19sPRFnLu6pLFxscdy8vDA4EOHUNnICMu7dEH8X39pPEZycjJ2794NDw8PtGjRIv/Ghw+B1auB5s2FSjoN+fr6wtXVFSv274eiRg1Aw1W6YmJi0KtXL5iYmODChQvaTV97/hxYtkxYdbFHD6EyTCrVfJyi2NsDgYHCtMITJ1Q3f/DBBzh16hSMjIzQqVMnxMTEaDx0UlISEhIS0L59e0iKW8m4d6+wYmtYmPD8d3UF2rYFdu4E/um9ExUVhYYNG2Lz5s1YsWLFv8dKpUDdusIKrKNHA7/+KvRPO3MGmD8fGDUKqFMH4ZMno4FMhrU9e8L66tV/j5fLgQULgAMHgLt331rxUhfEYjHWrVsHuVyu8apzzZo1w927dzFmzBh89dVXOo+tIA4ODnBycsLx48c1PlapVKJly5ZYu3YtPD09kZiYCNtiVJ0a0ooVKxAUFIS///5b6ylvw4YNAxFh7ty5Oo1NLBZjyJAhePr0KdatW6fx8S9fvlStqLlo0SL0799fp/Hpwq5du2BjY4PQ0FAkJSUZOhyticViHD9+HCKRCJ06ddJqGu6aNWuwe/dueHl5qfo2GoKDgwOWL1+OV69elYpqwpKwatUqVW/B6tWr4/LlyxqPcerUKWRnZxd76ry++Pr6Ijk5Gf7+/oiPj0flypWxbds2Q4fFGNMzTogxxrSmNDfH0X9+q0sul6NXr174qHt3dJDJsK9XL3z91VcwGjoUCA3NPw3MAMS5f6TrKClTq2VL9F6/HnUATGrRAtevX9fo+E8//RREhCVLluTfQARs2CD0oBozRuv4pkyZArlcjrVPngC3bgH376t13IEDB9C1a1dIpVKcO3cObm5ump/86lVg0SJAJgOGDAEaNdLs+NOnhf5g6vDwAFq1AubMEaYQ/qNp06Y4c+YMjI2N0bVrV43/+A0NDQUATJ8+XaPj3pKcDFy5IjyWee/LkBDhd55pZrGxsbCwsMBnn32Gm+9aDMHOTuiz9r//4ZezZzHl7l0k9OgBj+XL8/dee/BAaPI/dSoQHCwc068f0KcPMH680KMuNbV41whhumrbtm1x6tQpte/r7t2748yZMwgKCip40QI96tatGzIyMnBagx57r169goeHB2JjY9G5c2ecPXsWUl0neUvYpk2b0LlzZ8TGxqJTp04aHfvq1Sts374d1atXR6tWrXQeW2RkJCQSCcaOHatxXHXq1MGzZ88QFRWlmtJZ2kilUuzbtw9KpRKtWrUq083c3dzcEBkZidTUVI2T4snJyRg8eDDMzMxwWMMvb/Qht5l/XFwcoqKiDB1Oifjxxx8RHR2N169fo1GjRhov+PDrr78C+HfRktJIKpUiJiYG69evBxEhMDAQPXv21EkfRcZYKWXgCjXGWBmmaUl4fHw82dnZEQAaUrMmZX7/PdHJkyU+PbIgudMOfg8PF6buZWbqdPxTs2fTRICamJjQgwcP1DomJSWFRCIR1alT5+2Nly8LcV64UOzYbG1tycnMjBTt2glTFt/hyJEjZGRkRFKplC5evKj5CeVyor17hfg3bCDKyip01yKng2zfTrR4sfrnVSiEqYR+fkT37uXbdO3aNTIzMyORSETr169XczgFSaVSqlq1qvoxFESpJFq2TJgaWdC0y3nziNq2Jbp1S3XTyZMnSSQSkb29vVpTNW/dukVisZgqVKhQ+P650zRjYoRYPv9cmGqZO+1yxAii6dOFabr79hGdPavVazctLY2kUilZWVm9M/bhw4cTAPLx8dH4PLqQmJhIAKh3795q7f/o0SOyt7cnABQSEqLn6PIrialTbdq0IQDUo0cPtY8JCQkhALRp0ya9xZU7NXWvmtP3s7OzydXVlQDQxIkT9RYXke4el1GjRhEAGjRokI4i04wun18+Pj4EgKKjo9U+xsPDgwDQ7t27i31+XV2LTCajChUqkFgsphs3bhQ7Lm2U1JTJvE6cOEFSqZREIhEtWrRI7eMcHBzIxsZGj5HpVmpqKjVu3JgAUIUKFSguLk7tY3nKJGNlB1eIMcZKRGhoKJp5eeHFixeYMmUKlly5AvOwMGE1PQNNjyxIeuXKwIgRQuWVDjUbMQIf/PwzmmRno5uHB16o0cA+tzps8eLFb290cQE6dhRWliymr7/+Go9ev8YZU1OhUqgIf/zxBzp06ACxWIy//voL9evX1+xkL18CSUlC4/gPPwR69wZMTLQL/MULzRY/EIuBKVOEyqht24CsLNWmOnXq4OLFizAzM0Pfvn2xSo2FEObNm4ecnBzdfNvt4wN07VrwAhIDBwLOzvmmtH7wwQeYOHEiUlJS0KVLlyKHViqVaNu2LYgI+/btK3xqZ+40TX9/4KuvhOq9M2eEyrXffgM+/VSo4jMyEqr79u4VFi7ItWaNsPrl778D168L0zALYG1tjYiICKSnp2Pw4MGFxj1jxgzMmTMHNWrUKPbCB9qqUaMGKlasiIMHD75z38uXL8PNzQ0pKSmYNm2aaiXX/5JDhw7B29sb27dvV2t6oVwux4oVK2Bvb4+goCC9xTVv3jyIxWK1FomQy+Vo0KAB7ty5g9GjR2PChAl6i0uXZsyYAXd3d6xYsULjypzS5uDBgzA3N8fgwYOR/M908KJ8++23uHbtGvr374/OnTuXQITqkUgk2L9/P4gIrVu3LtPVe5po0aIFrly5AisrKwwdOlSthRKeP3+O5OTktxcGKsVsbW3x999/Izw8HGlpafDx8cGoUaMMHRZjTNcMnJBjjJVh6nwDdufOHapVowa1AOhHGxu6qU1FUQkokW9ZFQraN3gwfQeQp709vX79utBdU1JSSCwWU+3atfUXzz9kMhlJpVJqYW8vVG09eVLgfnFxcSSRSEgikWj0TalKQgJRRATRqlVFVoXlVeTjMn060YEDmsfx7BnRtGlEq1e/VeF0584dsrS0JAC08B3Vcq6urmRsbKx1o3GNnD0rPDZvVLb5+voSAJo5c2ahh+ZW6IwYMUK3Mb1Z3TV5srAoRuvWwk/79kStWgkLBYwZQ/Tbb0SJiard3d3dSSQSFVhluHnzZgJAdnZ2Bm9anVt9VFQFyMGDB0kikZBYLKa1WixOoQslVSmiUCioQYMGwoIcn31W5L7jx48vsYUQcputF/XepFAoqGHDhmrFriu6fFwePXpExsbGZGFhQZk6rmJ+F10/v2JiYghAwRXQeZw5c4ZEIhE5OTnp7L1W19cyduxYAkADBgzQyXiaMESFWK7U1FSqWrUqAaBevXoVue+kSZMIAO3YsaOEotOtW7duqa61Ro0adOcdi9JwhRhjZUfpKctgjP3nzJ07F21q1ECnpCSMef99TNiwAbVq1zZ0WIYjFqPTwoVo1rUrOqSkoFnduoX2pRgyZAiUSiUWLVqk97AkEgn69OmDkykpuP7oEfDkyVv7nDt3Dr6+viAiHD16FF5eXuqfgAg4flxYMMHREejVS/uqsFxyObB7d4GxvpOdnbBww61bwJEj+TZVq1YN169fh42NDUJCQgpdfv3q1au4c+cO/P39IS6JCkdPT6By5bfiPXz4MGxtbREaGopz5869ddgff/yBhQsXonr16rpfSv7NSrMffhAek40bgYkThf5jTk7A48dC9djw4UCzZkD9+kBQEA7+8APcifDxGxUfp06dwkcffQQzMzOcP38elpaWuo1bQ7nVD+Hh4QVuX7VqFTp27AiRSIQjR46gb9++JRleiROLxfj7779Ru3ZtLFmyBKNHjy5039mzZ8PKygrDhg3Te1yLFy+GSCTC0KFDC92nZcuWOH/+PPr27Vtw5W0p5+joiCVLliAzMxMdO3Y0dDjF4u/vj+DgYFy/fr3QBvlyuRwdOnSASCTCsWPHSua9Vgvh4eHw8PBAdHQ09uTpUflfZ2tri8TERLz//vvYsmULmjZtWujfNJs3b4ZEIkFAQEAJR6kbbm5uuH37NkJCQpCUlISaNWvq/t9UxphBlM5/WRhjZVpGRgb83n8fp4YPx2cSCUaOG4fuu3dD7Oen+xUEyxpjY3RduxbNW7RA89u34fv++29Ns3j69Cl27twJd3d3tNFi9UhtzJ49GyQSoXds7FvTMC9dugQfHx8oFAocPHhQsykPr14Ba9cKiZzWrYH+/QELi+IHfO+esBKio6N2x9eqBXToIKw6+cZqWc7Ozrh16xbs7OwwcuRIREREvHX4mH8WMih2M311icXCSpk9euS7WSqV4tixYwCANm3aICvPNNCcnBx06dIFRkZGOHr0aMnECQAODsKqp0OGCI+9vz/QpQtQpw7g7i5MkzY3R7XHjxHZuDF637uHQ507AzExSEpKQtu2bSESiXAyNhYuLi4lF3chPD09YWVlhV27dr217aeffsLAgQNhYWGBixcv6qVpfGkkkUhw8eJFuLq6YubMmRg/fvxb+8yfPx8vX77E8OHDSySR4ezsjJYtW+Ls2bMFLl7SqVMnnDx5EgEBAVi7dq3e49GXTz75BB07dsTJkyfL/AfyFStWwNnZGVFRUYiPj39re48ePZCamopffvkF7u7uBohQfceOHYNUKkVQUBAyMjIMHU6JkUgkOH36NAIDA3HmzBnUrFnzrZYQSqUSV69ehYeHR6lNaqpDLBZjwYIFiI2NhaWlJUaOHAkfHx+8fPnS0KExxoqh7L4rMcZKpd+3b8eXdnb4+u+/McTREWOOHYP7tGlCdUsZUPnKFeDNFR11zdISvbZuRcuGDVH7wgV0emPZ9s8++wxKpbJEKxhsbW3Rrl07XLxyBVevXlXdfv36ddW3vnv37tUsQXf/vtCH6sEDIRHWpo3u+sXduyf8rlZN+zGaNxeqlQ4dAhSKfJsqVaqEhIQE2NvbY9y4cZg0aZJqm1wux4EDB1CjRg3tP6TJ5cCFC0L1nLoqVwasrN662dPTE7NmzUJaWhratWunur1nz55IS0vD9OnT4erqql2cxSGXCytU5iZDR44EjI2FSrLffgPCwhBw6BD2WFnhl3378ODVKzRq1Ag5OTmIWbsWjcaPF1bZjIwU+pIlJb31OJWUtm3b4smTJ3j48KHqtsGDB2PChAlwdHREUlIS6tSpY5DYDEUqleLatWtwdnbGlClT8Msvv+TbPmnSJJiYmOR77ejb0qVLAQjvoXn16tULBw4cQJs2bbBz584Si0dfdu3aBRsbG4SGhiIpKcnQ4WhNLBbj+PHjEIlE8PPzy1ddtGbNGuzevRteXl6FVpCVJg4ODli+fDlevXqF9m/8m14ebNmyBWFhYbh37x5cXV2RkJCg2hYTEwO5XK7XPoIlydfXF8nJyapVRitXrowdO3YYOizGmJY4IcYY0wm5XI5BXbrgVM+eGCyToXrXrmh7/jyMmzXL33i7lDPKySmZD9329ui7bRs6unPy4IEAACAASURBVLnB/OhRBAUGAhAaz/7+++9vV4c9egTcuaPXkHKbgH/55ZcAgISEBDRu3Bg5OTnYsWOH+lN0iIQExowZQgJn6FChIkuX7t8XnldVq2o/hkgEdO8ODBokNIp/g62tLW7dugVHR0dMnDgR3333HQChubVMJiveh7Q//gC2bweeP9d+jDyGDx+ODz/8EKdOncLEiROxceNGxMTEoGnTpoZZ4j4nB/j2W+DkSWDYMOB//xMWDZBKIVu3DsnJyUhITMSFO3fQ+8cfcVCphEvv3nj58iV+/PFHNGnYEMr27YUE2vHjwnMpOBioW1dIrH76KXDsGPDsmWZJRS2FhoYCACIjI6FUKtGhQwesWLECHh4eSEpKQqVKlfQeQ2lkamqK69evw97eHt9++y3mzJkDANi2bRuSk5MRHBxc+CIOeuDu7o4mTZogNjYW9+/fBwAMHDgQW7duhZeXFw4dOlRiseiTVCrFvn37oFQq0apVqzLdzN3NzQ2RkZFITU1Ft27dAAhV0oMHD4aZmRkO51lMpLTLbfofFxeHqKgoQ4dT4iIiIrBw4UKkp6ejXr16qsVQFi5cCABqLXpRVkilUsTExGD9+vUgIvTo0QM9e/YsdMooY6z0Krm/Uhhj/z0yGewB3Dh3DlPatEH99HSYOTuj0bJlsPnwQ0NHpxWxXC58CC8JNWrgfxs2QOrvj0XbtuGLL77A48ePoVQqVX9AAhAqbbZvF5I2n32mtwSju7s76tevj6NHj6p6hmVlZWHLli3q9/3IyRGSYRcuCEmwQpJNxWZkJCRHirsaqLGx8PP0KXDqlDC1L08Vm7W1NRISElCnTh1MmzYNWVlZ2LhxI0xMTIrsVVSk58+FqZrNmwMVKxYv/jx27tyJKlWqYNKkSZBIJDA1NcXu3buRnJyM9PR0pKenIyMjA+np6cjMzMz38/r1a7x+/RqvXr3C69evkZWVpfqdnZ2t+snJyYFMJlP9lslkkMvlkMlkUCgUkMvlMJLJMFkmQ30izAaw8/hx0Mcfg4gwAUCT/fvR69tvUdjHhkmTJuWrKhKJRHASieAlEqGjSITaiYmoEhuLIxs3QmFsDJJK8cLcHJlWVkhwdobU1haWlpawtraGjY0NbGxs/s/eeYdFcXZt/N5dWBakGkWwoSKKqFgAUWMgFkCxR4gdRdHYOxiTGMxrF7GLNVbsRCUWBDs2EFBsiII1KioiTTq75/vjkSZt2QLiN7/r4kJnnjnPmZ2yzJlz7gM9PT3UrFkTenp6qFWrFmrXrg1dXV2py3dsbGygrq4OPz8/BAUFISoqCt26dcPZs2erdQmQItDU1ER0dDSaNm2KadOmQUNDA0uWLIFAIMCaNWsq3Z/NmzejQ4cO+OWXX9CkSRPs3r0bLVu2REhIyDd1rKytrTFjxgysXr0abm5u2LFjR1W7JDOzZs3C4cOHERAQAF9fXyxZsgTZ2dk4depUlWsIVhR/f3/o6+vDw8MD/fr1++pLPRXNL7/8gkaNGqFPnz6wtbXFnj17cO3aNejr66NmzZpV7Z7CGTx4MBwcHNCtWzccP34c+vr6CAwMhEAZf/dwcHAoBS4gxsHBITOCxETMBxA1dixa8nhoNm4cRvj4FBfbrkbwc3MrVeeMb2GBn/ftQ/yQIdiyeTMegAWmCpe+YdMmFqzx9lZ6tt2aNWvQo0cPtG/fHgBw4MABDBw4ULqN4+OBQ4eAlBRg8GCgZUvlOaqiAlhaKs7ep0/A7dvs2Ds4FFmloaGBmJgYtGjRAqtXrwYAmJmZYf78+cjJyUFWVlZ+cOjLQFF2djZyc3Pzg0a52dmY+uwZ0nk8bDx0CFkSSX4gSSwWQywWQ/J5WeF/SyQSSCQSEBEkEgl4YjEMiPCSCPT5B0B+pkjenHUUUKrM4/HA4/HA5/PB5/MhEAjyf6uoqEBFRQVqampQVVWFuooKfvv4ESY5OdhXty4+1K6NH9XUoKamBpFIhIyMDDS7fRtrLCzw3MwM6urqSE9PL5JNMXr0aGhoaOQH8fKCdi/S07G+UJBOkJWF77KzUSstDfofPqC2RIJ/797ND7RNB5AD4DqABwAeAigpj4bH40EgEOTvj6qqKoRCYb7PIpEI6urqEAgERbKOdu7cKfdn+61Qs2ZNREVFoVmzZnBzcwPASnY1NDQq3RcrKys0b94cp0+fBsAykCIjI7+pYFgeq1atwsmTJ7Fz504MHTq0Wgvtnzt3DnXq1MHIkSMBFGRbVTdUVFQQFBSEDh06wNbWFq9evfomz72ycHBwQGRkJKytrTFixAgAwJAhQ6rYK+Whq6uLW7duYcWKFZg3bx6sra3RuXPnqnaLg4NDSqrvUysHB0eV4+HhAXcAAgCdAwPRthr/MZ6Hdlwc64pXifB79MAvPj54N2QIUgDUr18f+/btAwBovX4Nq927EWdujoeVWDrSkgjj+vbF4MGDpdvg7l3gxAlATw8YPx5QdglZUhLrFqkoGjVigbCAACbU36ZNkdUikQjXrl1DvXr1AABRUVGIiooq1yzvcwAzL6g0gAh1JRIsU1HBw+TkIoGmwj95wRk+nw8VFZX8gE3ecquMDFhkZMDP0BA5IlF+YOr58+f52i2GhoZwdHSEuro61NXVoaGhkf+jrq4OTU1N1KhRA5qamtDU1ISWlha0tLSgra0NDQ2Nij/ESSSsk+j9+0Dv3uhYmt7cqFEwrVMH+NysIC/4+s8//8DZ2Rl+fn6Ii4uTKTNk3effnz59Qs7//geKiADi45Gbm4ssiQQ5ublIFgrxUlMT4Xp6eCASITU9HWlpaUhPT0dmZmZ+wC0tLQ2JiYn5wcW8Uhgej1epuljVBQMDA9y4cQOtWrUCALRq1Sr/PlbZ1K5dO19Y/8KFC5VatlnZBAcHo2HDhhg4cCDev39fJUFIRaCpqQl3d/f8a2vPnj1V7JHsWFpawt3dHStWrMDo0aOr9b7ISsuWLREVFZWvX/n8+fMqux9UFnkZ2gsWLMC1a9cAAHFxcVXsFQcHR3l8u38hcHBwKJ3Ro0fj/uzZyAaw1dER9lu2YMCYMVXtllzUiI9n5XOVCY8H+/Xr0QjAEADbL17EiIsXAQB/A7gKwCUqCpkHD1aaS5oAPpw4gWvnz+P7sgSCc3OBM2eA8HAWROrdu3Iy7BITgSZNFGuzQwem1XbiBFC7NlC3bv6qt2/fomWhjLcOHTpg165dEIlE+ZlEGhoaEAqFpQeSkpKYlpaJCWw/Z5rJTGYmsHYtJrdsCXwuZ7116xYsLS2hr6+PBg0aICIiAv369cvX5VE6fD5gZsY0vsoS8Z80iZ0zyck4Hx6O27dvo0ePHvjpp5+wdetWuLm5wdraGg++6P5ZETQ1NfMDbkhJAe7dY91Ez54FnjxBu/h49K9Th2UZ1qkDGBqyH2NjFtQtgUaNGuHly5cAAFNTU4SEhMDc3FxmH7810tPTi2QoLVy4sAq9KaB79+6IiYmpajeUhoGBAbZs2YIxY8bAzs4u/0G8upGbm4t169bl/3/u3Lnw8vKqQo/kY/ny5fj333+xd+9eDB06FL169apqlyqVt2/fwrJQFndISAhCQkKq0KOq4dSpU+jdu3dVu8HBwVEGXECMg4NDZoyNjfEIQP1Jk/Bu61aEjh2Li9u3w+vSJQgrsexQkQhycgA1tUqds3///rh87Ro0u3VD0wcPMOLdO9T780/YxMWhyZUriPz5Z2xv1qxSfPH09MSTJ0/QY/p06Kxdi6X29ph//Tqsra2LD05OBp4+BSIjmWB6+/aV10DB2bnEjotyweOx4FJ8PHDwINNr09LCmzdv0KJFC6SkpMDHxwerV69GREQEjI2NK3aer1kD5OQAnwXa5UIkYgG8LVsAY2NkGxujR48e4PF4uHTpEurUqQNDQ0MMGzYMHz58gEherTVpsbIqf0y7dizYqK2NUaNGQSAQ4MCBAwCAsWPHIjg4GHv27MHo0aOxa9cu+X3S1ga+/579jB/Pln38yIKfnz6x369esZLZnj3Z5woADx8CN28CZmZIb9wYL168gI2NDaZNm4aff/4ZFhYWOHPmzP/LjnJfkp2djRYtWiAuLg7u7u7YunUrPn36hL///rvSs7PyfGjWrBk0NTVx69Yt2NvbIygoqFL9qExcXV1x4MABnD17FmvXrsX06dOr2qUKM2DAACQmJmLp0qVYv349vL298fPPP8NKmnvKV8rly5fRoEEDODk54d27d9VOD01W7t69i06dOiE9PR2//fYbvL29oa6ujg0bNlS1a0pBLBZj9erViIyMhKqqKiZOnAhdXV3873//44JhHBzVAeLg4OCQkTtnzpAnQHfOnKHk9+/p1yZN6DRA3kIhXQ8Kqmr3KoSvry8BoOdWVkRLllTavK6urgSAOnXqREREL+/cIXeAVtWtS9S9O9H8+ZXmy+vXrwkAWVpaEhHR2/796W8ej1RUVCgsLKzo4EePiJYtI7p4kSghQWk+5R0XX19fpc1RjORkInd3Ijc3ehETQ5qamgSAtm/fTkRE27ZtIwD0119/SW/zyRMiBweizzYUQkYG0YABRFOnkr29PQGglStX5q/O89PBwUFxcyoQHx8fAkDjxo0rts7U1JQA0I4dOyrPoexsoqysgv/v30/UrRuRrS09b9KEDgAUbW9P9Ntv9GDxYqotEBCPx6vcc7MMquRaIaKcnBxq2rQpAaA5c+YQUcG55+HhUam+EBHZ2NgQAIqOjiYiou7duxMAGjBgQKX7QlR5xyUrK4t0dHRIIBDQ06dPFW5fmfuRZzvvuyc2Npb4fD7p6upSTk6O0uarjGslb64OHToo1f7Xch86deoUqaioEJ/Pp4MHDxJRwTWYmppaxd4pnpCQENLV1SUAZGFhQYmJiUREFBERQQAoIiKiij3k4OAoj/9fKo8cHBxKQ7t2bSyNiQG5uKB1djZe2dtjobNztWsH/0lfn5VNVQJz587Fzp070aJFi/z25A3MzfG6Y0eYv3mD3NBQVmZ34ABw8iRw+TJw6xYQE8N0znJyFOrPlClTACD/LW6doUPxU9u2qCsW4/vvv8fdu3eZTtT588D+/UDDhoC1tWK1vL4GtLWBQYOQ8eABNpmZIS0tDbt378bYsWMBAGPGjIFIJCraCbQsJBIgKIhln40apTg/RSJgxAjEBQYiNSgInTt3xuxC2Wdubm6wsrJCYGAg/P39FTevApBIJHB3d4e6ujp8fHyKrQ8NDYWmpibc3Nxw//79ynFKVbVoue/QocCpU8CqVdiUnY0YHg8mAgFw8CDMfHzwWkcH9wAIR4zAJUdHdk1Ws/udvEgkErRr1w6xsbGYOHFifombm5sbdHR0sHHjxkr9Dnjz5g2uXLmCtm3bonnz5gCAoKAgWFtb4/jx43Bxcak0XyoboVCIwMBASCQS2NjYVJvv3vfv32PMmDFQV1fHxc9SAcbGxvDy8kJSUlLllXwribzmADdv3izSPORbxMfHB3369IFAIMDVq1fzNUjzvju3bt1ale4pnMmTJ6Njx45ITU2Ft7c3wsPDoaurW9VucXBwVBAuIMbBwaE4+Hw47t4NswsXIKhRA0I/Pww0NMST2Niq9kxqsmvUAD4LpysTLy8vrFixAg0aNCjaAS0tDev69UMWgDdZWUyLSSJhJV03bzJ9q337gM2b2bKPH4HVq4Ht21mZ36lTQHAwK/+KjGQC56mpwOcuhKWRmZmJf//9F40bNy4oj+zVC7o1ayJw2jTk5uaiq5UV3ixbBly7BtjZAUOGAOrqyv2gqoiYmjUxLCIC6jk5OLN4cZEHaT6fj/79+yMuLg63bt0q31hoKPDuHfDTTwrvwPqifXtciInBZBUVnA0MLLY+KCgIQqEQw4YNQ2ZmpuImTkyUS2tv5syZSEtLw6JFi0osqdPW1sbly5cBAF26dEF6errMc8mFSIRcc3N4vXmDo23agH/qFCtT7dEDqurqMDExgbFAAI2AAJwZMABYuhTYuZNplUVFfdMBMolEgg4dOuD+/fsYNWpUscDmrFmzkJaWVkQXStmMHz8eRFQkWM3n83H9+nW0bt0ae/fuxeTJkyvNn8rG2toaM2bMwKtXr/K7fX7t2NraIjs7G35+fkVKCmfNmgVra2sEBATA19e3Cj2UH39/f+jp6cHDw+Ob1bObNWsWJk+eDG1tbTx8+BCdOnXKXzd48GDw+Xzs37+/Cj1UHM+ePYORkRF8fHxgZGSEmJgYzJo1q6rd4uDgkBEuIMbBwaFw6nXtip8SE6Hdrx/av38Pz2bNsGrRoqp2Syr4YrHSReH//vtveHh4oFatWoiKiirQoUpOBnbuxHeqqvCzsEBsTg5epqcDw4cDEyYA7u7AH38As2Yxfau6dVlWS5s2TAQ+Nxd4+RIICQH8/YF164ApU4BFi9jPmjXA338Dhw4Bp0+zABsAJCZi4dSpUBWLsXTJkgJHtbUBc3OYvnuHc3//jTE5OVjv6YlnP/zA9JgqSy/sS5Tc+ODBgwcwNzeHf04Ous+bB/u8z7UQKz4Ltru7u5dvUEsLsLEpItKvCCQSCX6wtcVmIvRp1Qoaly4VG6OrqwsfHx+kp6ejf//+ipk4JgbYto1lLcpAnhZbnTp1ynyIaN++PdavX4/k5OQqbWG/d+9eSCQSTHB2Bnx9gatXWXOEvn0hdHBAs6QkjGjQAL+EhuKP8+eBGjWYiP+//xZcI7m5LJB29SrTLfsG6Nq1KyIiIjBo0KAStd7++OMPiEQiLKqke39KSgoCAgJgYmJSTPOQz+fj1q1baNq0KXx8fDB37txK8akqWLVqFUxMTLBz506cPXu2qt0pk7lz5yI6Ojo/i+pLzp07Bw0NDYwZMwbv37+vAg8Vg4qKCoKCgkBEsLW1rTbZe9IyYMAArF69GkZGRnj58iUaN25cZD2fz0fTpk1x7969KvJQcXh7e8PExAQvX77ElClT8Pz582L7y8HBUb3gAmIcHBzKQVUVE/39MfDIERiLRHg9fz5szc2RlJRU1Z6VCh8ATyJhQSYlcezYMYwbNw5aWlp4+PBhwRvxDx9YsCo3FxgzBp7//IO7AB6uXl00y0QgYIGqevWY+L+WFtCtG9C/P3tInzgR8PAA5s8HFi8GvLyAkSMBBwegdWvgu++A7Gzg+XMmGg5AcuUKNHbtwgKRCINjY4G1a4EdO4AjR1iHvuBgdL16FcOmTsWG3Fy07N0bz549U9pnVC4XL7KAnhK4e/cuLCwskJ2djePHj+P7hQvZZ334MPssPtOwYUM0a9YMly9fRnZ2dtlGW7UCunZVuK9jxozBf//9B6uZM6EzbBgQGwuIxcXGjR07Fh06dEBQUBCOHTsm36T37wMzZrBmCoMGyWRi2LBhyM3NxY4dO8odO2nSJDg7O+POnTuYMGGCTPPJy7Zt29ANgNuVK8Ddu+x66tEDqFUL+PgRmpqaiHr6FLUtLLD44kX8sH49JDNmANOnFwTE/vsP+OcfFtDu25eVY86fD6xcyTI6yzuHvjJ69uyJ4OBg9OrVC35+fiWO4fP5cHNzQ0JCQn7TBGUyadIkSCQSrF27tsT1KioqePDgARo0aIAVK1ZUWqCuKggODoaqqioGDhxYddmV5XDr1i14eXnB0NAQe/bsKXGMpqYm/Pz8kJOTAxsbm0r2ULFYWlrC3d0dcXFxGD16dFW7oxCys7PRrl07+Pv7w9raGrGxsdDW1i5x7IABA5CdnY1LJby4qQ4kJSXB0tISc+bMgZaWFkJCQrB+/fqqdouDg0MBcAExDg4OpWLu5IT5r19Ds3NnXLl3DwYGBjh8+HBVu1UiAgDpNWsqvnvhZ4KDg+Hk5AQ1NTXcu3cPtWrVYitevWIBKJEIGDsWqFkTRkZGeG5uDrXERMTIUmYgEACGhqzrX6tWrHNe9+7AgAHsgX7SpHw9q62PHmFzbi50xo1jpZAtWwJ6ekBGBgucpaQAL1+i3cqV2OXnh8zMTLRu3Rovv8iaqjSSkgAl6HTcunULVlZWyMnJwcmTJ5l2jUAA/PwzwOezzLrc3Pzxv/76K8RiMZYuXapwX8rj5MmT2L17N5o3b45Vq1axY5mcDISHlzg+MDAQQqEQI0aMkL108tYtlqWoowP8738yXScxMTE4deoUWrVqxTJCMjJYpmIJgbw8Dh48iKZNm2LLli3Yt2+fbL7LSnY2uoWGYolIBEGjRsCcOQUag7VqsXMRLNgSHh4OR0dHXL16FWZmZsgsnEHZuDEL4m7YALi5AU2asEw7Hx/AxYVdc2vWAOfOAdHRrMz5K2XQoEEIDAyEra0tTpcTmPby8oKKigp+/fVXpfqUmZmJQ4cOoX79+ujVq1ep44RCIaKjo1GnTh3Mnz+/1OBZdcfAwABbtmxBWloa7OzsqtqdYuTm5uZ3xb18+XKBZEAJ9OrVCy4uLnj06JF0GblfMcuXL4epqSn27t2LgICAqnZHLj5+/IgmTZogMjISgwcPRkhISJkdZfM6n1bHTpN+fn4wNDREREQE+vTpg/j4+JI7b3NwcFRLuIAYBweH7KioIP7z7zKH6enhr2vX8M/Ro+DxeBg8eDD69uxZfmZNJZMD4EnXrkoR1Y+MjET37t0hEAgQFhYGIyMjtuLqVZbVJRIBrq5Fggwzjx/HBwDX58xRuD+FWeDtjXg1NYxfs4aJ5PfoAQwcCAwbBujrsyBZ587A+fMYNGgQ9u3bh/T0dLRq1Qpv3rxRqm8lkpjIAnYKJDQ0FB07doRYLEZQUFDRh2pNTaaX9u4d8OhR/uJRo0ZBXV1denF9BZGUlARnZ2cIhcL8ZgzQ1wfatWPlpCWgq6uLzZs3Iz09XTaR6tBQYN48Ns+GDey3DDg7OwNgQS4ALNj6779AWFip2/D5fISFhUFDQwOjRo3Co0LHQKkkJODB1KnoIpEgrmtXYONGoE6dgvUdO7LPvFAw79SpU3Bzc8OjR4/QpEkTfPz4sWC8igoLTg8fzrI3Dx5kn+uKFex609cH7txhy729mTZg4aDzV1Bm5eLigqNHj8LKygoXLlwod7xIJMKgQYPw8uVLqcbLiru7O3Jzc/NLmctCQ0MD0dHRqFmzJmbMmIG///5baX5VJa6urrCzs8P169e/usDfgAEDkJiYiGXLlsHExKTc8Tt37kTdunXh7e2NsDLuFdWBy5cvQygUwsnJCZ+qafl0TEwMGjVqhNevX+O3334ruJ+XQd26daGnp1etMsRyc3PRp0+f/O+tI0eO4MSJE2UG/jg4OKohVd3mkoODo/oiS1vp5ORk6tmmDc0BqIOmJl29elWJHkqPMluXP336lEQiEfH5fLpy5UrBiocPiebOJZoyhaiUduQrmzalQIDuX7umcL+IWIt0AOTq6lp85e7dRLa2RGFhRCEhRJ6eRPfuERHRrl27CADp6OjQu3fvlOIbUQnHJSWFaNQoIgWeN1euXCEVFRVSUVGhy5cvlz7wczv1wgwdOpQA0M2bN4uuePOGSCJRmI+Fad26NQGgI0eOFF0hFpe7rbW1NQGgo0ePSj/h5ctEdnZErq5EyckV9LaAoKAgAkAODg5FV7i6Ek2YUO72169fJx6PR3p6epSRkSGzH1IRGUm0eDH5mJpSQ4ASEhKKj4mNZddECeeFp6cnASBtbW16/vy59PNKJERJSUQPHhAFBhb9vF1diYYNI5o/n+jgQaKoqCLHXJn3MCKiCRMmEABq3bo1iaU41/JISEggHo9HZmZmSvFLLBaTSCSiWrVqVWi7d+/ekZaWFvF4PDp06JBSfCNS/nEpi6ysLNLR0SGBQEBPnz6Vy5ai9iPPjqWlZYW2i42NJT6fT3p6epSTk6MQH6rimBSev0OHDgqzVVn7cvHiRVJVVSUej0fbt2+v0Lb9+/cnAEr9m0FRhISEkK6uLgEgCwsLSizhPl8Wsvx9zMHBUTVwGWIcHByVira2NgJCQtB11Cj0TkvD0i5dMHn8+G9OZDaP9+/fw9zcHFlZWTh27Bi6dOnCVty+zUrwLCxYJkih7lqFGXToEEIAeI8ZoxT/Zs+eDT6fjzVr1hRd8fEjy1Tp1AmwtGQll61bs2ye9+8xatQobNmyBcnJyTA1NS2aCaNMnj1jZZwK0nm7dOkSfvzxRwCspLVMnRpdXZalExTE/ECBuL6Hh0fBuHfvmOj83bsK8bEwv//+O+7duwdnZ2c4OTkVXVlG2VEeZ86cgZqaGkaMGCGdtlBMDMuMatKEZYaVog8jDaNGjYJAICjeaczOjpUJlqNL16lTJ6xcuRKJiYnK1RM6fRo4dgxo0QK/v3yJ3Lp1UbNmzeLj8j6LQtpyeSxYsABbtmxBamoqTE1NpetGCjDNMR0dwMwMsLcv+nk7OLCus9HRwKZNLLPU2hr48UdgwgQY3r4NjYrvrVTMnj0bmzdvhomJCW7dulVmiduX1KxZEz169EBUVBTuKuGaWLBgATIzM/Hnn39WaDt9fX3cv38f6urqGDJkSLnln9URoVCIwMBASCQS2NjYVPn37Pv37zFmzBioq6vj4sWLFdrW2NgYXl5eSExMlC3L9Ssir4nAzZs34e3tXdXuSM3u3bvRrVs3AKzhwdixYyu0/cSJEwHgq9femjx5Mjp27IjU1FR4e3sjPDwcukqQaeDg4PhKqOqIHAcHR/VFrjdgEgm9OXmSVurq0hSAfqxTh2JjYxXvpJT4+vqSBkDHV64kys5WiM3k5GT67rvvCADt2rWrYMW1ayyz5N9/pcrqmdimDTUC6N7n7CxFcf/+fQJA9vb2xVcuXkxkb08UF1ewLCuLaONGonXriDIziYho/fr1BIC+++67Cr9BlYZib79PnmRZa4X9kpGgoCDi8/mkqqpKYWFh0m0kFrPMueXL8zODmjdvTgKBgGUtSSRE27YRbdhAlJsrt4+FuXnzJvF4PDIwMKhQhs6X7NixgwBQjx49yh4oFhOtX0+0Zw+RnBlZeefJxIkTi69MSyNycCBaWvlz9wAAIABJREFUsUIqW3lZBtOmTZPLp1K5f58oMpLCwsIIAE0oLXstM5Ndx/fvl2rK39+fBAIBCQQCOnPmjOJ8TEwkuniRZZja2xOZmtLTjh3JE6CwESOIjhwhun6dSAGZGHnZbkZGRpSVlSWTjadPnxIA6tSpk9z+FEYsFpOmpiZpaWnJfE08fvyY1NTUiM/n08WLFxXqH1HVZyMREc2cObP0TGApUcR+mJqaEgA6deqUzDY6dOhAAGjv3r0y2/gajklOTg7p6ekRn8+nx48fy2ynsvZl/vz5BIA0NTUpKipKZjuqqqrUokULBXqmOJ4+fUoNGzbMv9/Jk1XJZYhxcFQfuIAYBweHzCjkC//dO7rQpg2dBcgFoOVLlyrOwQrg6+tLTQG6M3CgXGVheWRlZVH9+vUJAHl7e7OFEgnRuXPsIfrcOalL6mJjY2UqMSkPGxsbAlA8EPn2LSvLKqms7sMHoiVLWMnWZ/+9vb0JAOnr61NqKaWfslLsj/0tW4h69JAqkFgWp06dIj6fT0KhkG7fvl2xjdPSiNasIdq0iSg7m3bv3k0AaH5eKdukSUQVKZOTgrzSJ3kfnvLo2LEjASA/P7+yB6akyB3Yy8nJoRo1apCGhkbppU4LFhD17s2CruUgFovJyMhIOv+loZTrcMiQIQSg7IciKYLnISEhJBQKicfjFQ2MK5LcXDq0cSO1BOi8hwfR9u1ECxcSnT1bMObmTaJDh4geP5b6+lm+fDkBIENDQ0pLS5PLRUtLSwJAL168kMtOYdasWUMAyNPTUy47d+7cIVVVVVJRUSle/iwnX0PwhYjIxMSEAFBQUJBM28u7Hx4eHgSAhg8fLtP2eaSmppKGhgapqqrKXHr3tRyTsLAw4vF4ZGhoKHNAtzL2ZdiwYfn3gfj4eLlstW3blgQCgVwvdZTBypUrSSAQEACaMmWK3Pa4gBgHR/WBK5nk4OCoWvT10fX6dbQYOxbjBAKozJuHjubmlVeCVwhh/j+EZQ0rF4lEgjZt2uDVq1eYN28eZs2axVZERABXrrBSqO7dWXmUFBgbG+OHH35AeHg4Hjx4IJdveXz48AFXrlyBubk5jAs3ESACzpwBatcGSipL+e47JgD+7Bnw/j0AYNasWViyZAnev3+PZs2aSVeKJyvv3jFB/QqUbH3JsWPH0KdPH6iqqiIiIgJt27atmAENDSayn5AA+PvDZeRIqKurw8/HB9i5k5W85TVNUBC9evVCcnIyVq1aJZUINV68AAIDS10dGBgINTU1jBw5suzjpaXFOm3KwcyZM5GWloYlS5aULkY8aBDw6RMrRy0HPp+P8PBwiEQiDBkyBM/KKbUsk7Q0YP9+4PHjYquCgoJQs2ZNNG7cuPTtpSjdtba2RlRUFGrUqIHRo0crpyupQIAcHR08ABBnbs661c6bB/zwQ8GYK1dYV8tx44DevVnJ5fLlwK5dRcX7P7NhwwbMnTsXtWvXRnR0NDQ05CvI3LJlCwBgwoQJctkpzMKFCyESiSpcLvkl5ubmuHLlCogI33//Pe7fv68gD78egoODoaqqioEDByr3Hl0C4eHh8PLygqGhIfbs2SOXLU1NTfj5+SEnJwe2trYK8rBqsLS0hLu7O+Li4jB69OiqdqcYEokEnTt3xv79+2Fubo7nz58XdMeWkZ9//hlisRhHjx5VkJfykZSUBEtLS8yZMwdaWloICQn56ks6OTg4FAsXEOPg4Kh6NDRQb/t2dPTzg1mjRuh07x6sDQ1x+PDhSnUjPwwmpz5V586dER0dDTc3NyxZsgTIzWXBozZtgKFDWcfGCrJz504AUNgfzdOmTQMRFe8+RgSYmACOjqUHQkxNARcXYN++fN2nefPmwdPTE3FxcWjevDkyMzMV4mcxmjRhvsnI4cOHMWjQIIhEIty5cwetWrWSzVCdOsCAAcD9+8C1a/jpp58wKiEBiSkpQF4AVEH4+PjgwoULsLGxyW9dXy5pacCNG8DTpyWu1tbWxtatW5GRkaFUPZ6kpCRs2rQJBgYGZfveqhULIp48KZXdWrVqISAgAGKxGNbW1rJ1rH3yhGlxvXlT7Fx/8eIFPn78iO7du1fcbgkYGxvj2bNn0NfXx2+//YbJkycrxG6ZCASAmlrB/2fNAo4eBebPB3r2ZAH5EyeABQuYTmCDBixQ/9dfOPH775g2dSp0dXURHR0NbTm04/Jo3749mjdvjsDAQCQlJcltz9fXFwkJCRg3blyFNM1Kw9raGoGBgRCLxbCyssKTJ0/ktvk1YWBggC1btiAtLQ12dnaVNm9ubi7s7e3B4/Fw+fJlhRyrXr16wcXFBdHR0Zg7d64CvKw6li9fDlNTU+zduxcBAQFV7U4+nz59grGxMW7cuIE+ffrg9u3bEMr5shBA/r1v+/btctuSFz8/PxgaGiIiIgJ9+vRBfHw8rK2tq9otDg6OSoYLiHFwcHw1qAwYgJ6RkRg5eTJGSiTYMHgwevfqJdvDrgyoAiA+X66MmF69eiE0NBQDBw7Etm3bgOxs4MABIO+tePPmMtk1NjZGly5dFJIllp2dDT8/P9SvXz9fUD4fPp8F7ApnjZWEgQFQqxbg55cvKr5gwQLMmzcPr169gqmpqXKOW3IyoK8v06b79u3DkCFDoK6ujnv37qG5jMcin5Ytmaj5ypXY0KQJrAGsS0xkn4uCePbsGaZNmwZtbW0ElpHxVYwWLYD69YFTp1gjgBJwcXFB586dcf78efj5+SnI46IMGzYMYrEYu3btKn+wkxO79hITpbL9448/YvHixYiPj88XepaK7Gx23u7dywKbEycWO9/zmiW4u7tLb7ccatWqhWfPnsHY2Bg+Pj4YOHCgwmxLTc2aLOg1fTrLFlu/HmjfnmXFvnkD3LuHTxs3QmvJEvwpFOLZwoWoee8eC6xmZck9/dq1ayGRSDBt2jS5bf36669QUVHJP1aKoHv37jh27BiysrLys3y/JVxdXWFnZ4fr168XfxmiJAYMGIDExEQsW7ZMuuxWKdm5cyfq1q0LLy8vhIeHK8xuVXD58mUIhUI4OTnh06dPVe0OXr58iYYNG+L58+eYNm0aTpw4oZBAJsBexhgYGODGjRsKsScLubm56NOnD5ydnQEAR44cwYkTJ0rPYObg4Pim4QJiHBwcXxc6Omi/bh1mHzuGEXXrQnLmDPT19XHt2jWlT90GQM3nz2XefsSIEThz5gxsbGxYOUBGBguE/fcfKwmTM/MsL6jg6uoqlx1PT0/k5ORgwYIFshvh81kAQ0UFOHyYZcEBWLJkCWbNmoUXL17AzMwMuZ+XKwQiFiyRodvTzp07MXLkSGhoaCAqKqpomag82NkB2trQ9fGBnqoqHkdHI/PSJZYRKGdHN4lEgi5dukAikeDMmTMQiUTSb8zjAd9/Dxw/zjomlkJAQADUhEJsGz4cmWfPyuXvlzx8+BABAQFo3bo1HBwcyt+gZ0+gY0d23UjJvHnz4ODggGvXrkmXKfL0KeDmBmzfDnTrBowYUWKHV39/f9SoUQNWVlZl24uJAfz9pfZXQ0MDjx8/RocOHXD8+HF07Nixajr/paQAq1axrDE+n92frK3xqGtXDIqPx+9CISb6+kJXT49lGu7Zw8qB8/j0iZXlVtB3BwcH1KtXDwcPHpQrYB4QEIDXr19j8ODBFbsupKBfv37Yt28f0tLS0LJlS3z48EGh9quakydPQkdHB7Nnz5av3FgK9u3bh1OnTsHKykqhwWWAlU4HBweDx+PB3t5esd81lYy+vj527NiB9PR0hWWlykpoaCiaNWuGpKQkrFu3TimBUzs7O6SkpFRJFmZoaChq166NU6dOwcLCAnFxccU7NnNwcPy/gguIcXBwyIxKYiImff6tUPh81OjTB+OvXUP/xYvx6dMndOnSBRMnTlTqw6MmwIIuMjB9+nTs27cP5ubmrJ18Sgp7gPz4ERg9GihLh0hKjI2N0dfKCi/DwuTKEtu4cSO0tbUr3DK9GBoawM8/A3FxRfSqvL29MWnSJDx58gStWrVS3INKTg7LDqtdu0Kbbd26FWPGjIGmpiaio6NhpEh9r5gYdowlEjTQ14cbgDcuLuxz6d0bGDWKaTlt2pSvuSYtI0eOxJs3bzBnzhx06tSp4r61aMFKEX19gVJKWLU1NXF94EA4ZmfDQ8GlR4MHDwYAHDp0SLoNVFWBkSOBunUrNM/p06dRr149rFixAifLKrk8doxlg336BCxaBNjYlKjjl5SUhNevX6OzNKXNKSlAZCQgFkvtL5/PR2hoKPr164fQ0FDllhh/SVYWcP48sG4dK6sdPZppqAmFiNPUxKwjR2CtooI9N26gjrMzMHw4MHcuMHly0VLlCxfYud2/PzBzJrB1KxAWJlUwc/HixcjJycGvv/4q825Mnz4dfD4fPj4+Mtsoi6FDh2LLli1ISUmBqakpUj5nwX4LCIVCBAYGQiKRwMbGRmnfqe/fv8eYMWOgrq6OCxcuKGUOY2NjrFixAomJiUot/a4Mhg8fDkdHR9y8eRPe3t5V4oOfnx86d+6M3NxcHD9+HFOnTlXKPHkZomvWrFGK/dKYPHkyOnbsiNTUVHh7eyM8PBy6Mrxg4+Dg+LbgAmIcHByyk5uL2p9/K4VGjTDht9/w9OlTNG7cGPs2b4axkZHS3iqqA5DIkDK/aNEirFu3Do0bN0ZERAT4iYnAjh3s4XPMmAo/4JfFtr590Q3AmDFjZNp++/btSE1NLa5hJGMgEPXqsQflsDDgzp38xRs3boSbmxsePXqEdu3aKeahSyhkguAVKLvZsGEDfvnlF+jo6CA6Ohr169eX3w+ABedOnQIOHWLNB3r2RM1Bg+AkEmH0p08s88bRkZWWvn7NghBv35ZtMy0tP+Pm2LFj2L9/P8zMzOQrCZs0iZWZ7t5dfJ1EAvzvf2j/9i0+NW2K9bdvK0y3LyAgAPfu3UOvXr3QokULhdgsDT6fj5s3b0JNTQ2DBg0qXuaWnc0y5c6cAczNmYi8pWWp9latWgUA0pX1aWuza0eGMid/f39MnDgRsbGxMDIyqpxMJF9fICSElUV7eLCgllCIDzdvYuO5cwhWUcHEGTNgXLjJAI/HgtANGxYss7FhgbIffmDn1+HD7Jxv1Qro0gWYMAF49AgoQbx91KhR0NPTw+bNm2W6L9y4cQMxMTFwdHRUiLZZaYwfPx7e3t5ISEhA8+bNK12IXplYW1tjxowZePXqFdzc3JQyh62tLbKzs/HPP/9As4QsTEUxe/ZsdOjQAQEBAfD19VXaPJWBv78/9PT04OHhgZiYmEqd28vLC87OzlBTU0N4eLhSA4yWlpYQiURlv8BQIM+ePYORkRF8fHxgZGSEmJiYgmZHHBwcHFXd5pKDg6P6cufMGfIE6M6ZM8qfTCKh/d260QSAavN4tHz5coWa9/X1pb8AetK5c4W28/HxIQBUp04dSktLI7pzh2jyZKL164mSkhTqIxERBQTQDV1dagBQVFRUhTevV68eqaqqUk5OTsHCZ8+I/v6bKC1NNp8kEqLjx4kWLiR686bIKhcXFwJAbdu2lanNujwt5b29vQkA6enp0bt37yq8fam8fUu0YQPb37Awtv9eXkSOjuQyYgQBoKtXrxbdRiIhKm//Z84ksrenTCcn8ubzaZZAQCl79hBFRhKlpsru759/Ejk4ECUkFCzLySH69VeiH38k8vWl5ORkUlNTI3V1dXYey4mBgQEJBAJKTEyU25a0BAUFEQAyMDAoOL/fvCFat45o8WKi27fLPwZE1KxZM1JVVZXufH37lsjTk+jlS5n9XrRoEQEgLS0tio2NldmOVNfKf/8RJScXWXQnMJAuATSQz6ewsDCi+/fZPkVHSz95VhbRlSvsnHJ0JPrhB2bD05PdC48fJ4qIIMrOJiKipUuXEgCZ7uNt2rQhHo9HcXFxFd5WFhYsWEAAyMjIiLKysiq8vTz3MGVjYmJCACgoKKjcsRXZDw8PDwJAI0eOVISb5ZKamkoaGhqkqqoq1b3+az4mYWFhxOPxyNDQUKp7kCL25ZdffiEAVKtWLXr9+rXMdipC586dicfjyXRNVYSVK1eSQCAgADRlyhSlzlWYiIgIAkARERGVNicHB4dscBliHBwc1QMeD0N9ffHr7NmYqqaG/XPnol3btvj48aPCprgL4H0FslkOHz6MSZMmQUdHB1FRUdCIjwdWrwaSkljpl46OwnzLp0sXtG7VCk6ouJbYpUuX8Pr1azg5ORWIx0okQEAA+62uLptPPF5BV8rly4uUTe3evRtDhgxBZGRkpeolLVu2DLNnz8Z3332Hx48fQ19GIf4iEAGhocC2bUx3afx4lmnE4wHt2gFpafD65RcAKF4OxuOxbcqy7ewMDBiAXZcuQVcigXvbttD6+28mgN6nD/Dnn7L5PXEim//ff9n/s7NZdk9oKDBlCjB8OLS1tbF9+3ZkZGSgd+/ess3zmbVr1+Lt27eYOHFipZaj2NnZYf78+Xj79i3TLHv3jmmFCYXAL78AbduWfQzAGk7ExMSgffv20olIa2gA9+4BcpQw//7779ixYwc+ffqEli1bIiwsTGZbRXj1Kr/hRT7167Osts88ePAAk3r3RjyAXw8fhqWlJWBmBjRtyu4L0up8CYUsM2zpUpY5efkyMGMG0yZr0oRlRwYE5JeoesyZgykqKri0cGGFsusePnyIO3fuwMbGBgYGBlJvJw+enp6YM2cOXrx4gdatW1drraovCQ4OhqqqKgYOHKiwDLjw8HB4eXnB0NBQumYaCkBTUxN+fn7IycmBra1tpcypLCwtLeHu7o64uDiFdZUuDYlEAjs7O2zZsgXNmjXDixcvUFeBGe1l4eLiAiJS2jmSlJQES0tLzJkzB1paWggJCcH69euVMhcHB0c1p6ojchwcHNWXSs0QyyMri3L/+YcONG9O0wD6TlWVDh06JLdZX19fGgzQ1YkTpRp/7tw54vP5pK6uTv/99x/Ro0csY2jHDqKUFLn9KRNPT7qip0cqFcwSMzc3Jx6PR/Hx8QULDx4kmj6d6NUr+f16/Zpo6VKifftYRlQhBg4cSACoS5cuFTIpy9vvv/76iwBQ7dq1FZuh9OABy3g5fZplWBUmOTk/28rMzIz4fD5lZGRUeAp3d3cCQMOGDWMLEhKIbt5kx+nChbI3fvGCZa4dOsQy1wrv+7lzRP/7H9H79+x4d+tGdOJEMRNdunQhAHTw4MEK+05ElJOTQxoaGlSjRo2iWYiVSNeuXQkAef75J9GtW8WPVRmsX7+eANC2bduk20AsJurRg2jLFhm9LeD06dMkEAhIIBDQiRKOTXnkXSuHN28mOnyYnavnz5c6PjY2lkQiEdnxePRo/Pii12xCAruf3b4tw56UwufsMCIiev2aHhoZ0UWA3rRoQTR8ONFff7HP8d69Uk3knZ+PHz9WnF9SkpdF06ZNmwplu37N2UhERDt27CAA1Lmc7Ghp9iMnJ4f09PSIz+dXyTHKy0j28PAoc9zXfkyIiExNTQkAnT59usxxsu5LRkZG/hxdu3aVKYNbHrKysojH49H333+vcNtHjhwhkUhEAKhPnz5V8l3EZYhxcFQfuAwxDg6O6oVQCMFPP2HInj34rW1bbBeLsXzwYDg6OsrVtQwAhJBOQyw8PBw9e/aEiooKIiIiUP/jR+DgQZZVMXIkoKUllx/l4uSE9k2boiekzxJ78uQJ7t69CxsbG9SqVYst/PiR6SlpaDAtMHmpW5dlhMTEAFeuFFl19OhR9O7dG1evXpW9i1ZQEMtqKoP58+fD09MTBgYGiI2NVUyGUmwscOsWE6kfOxbo1Yt11yyMtjbLQEpNxZ9//gmJRIK//vqrQtPcuHEDK1euRL169bB37162sGZNwMoKGDwY6Nq1bAMfPgDnzgE+PsCcOcCAASyzbMwYtvzOHbY8PZ1liPXpU8xEQEAARCIRRo8ejU8y6GJNnToV6enpWLZsmfwt7CWSinfqzM5GUFAQDAwM8Nf//oezHz4UP1ZlsHPnTvD5fOkzM/h8lgkaH18xP0ugV69eCAkJgYqKCvr164ft27dXaHthSgpmAmh29izw8iU7/j/+WOLYV69eoU2bNsjKysLSGTPQrFu3og0GatYsyCysYDOIUincZbduXTSJjsY0gQDL4uLY/ScykmWY9unDtMg2bWJ6Z2/eAGIxXr16hatXr8LCwgImFdARVBSbN2/G0KFDcefOHfzwww+VPr+ycHV1hZ2dHa5fvy53R8H+/fsjMTERy5Ytq5JjtHPnTtStWxdeXl4IDw+v9PkVyeXLlyEUCuHk5CTTvbgs3r59i4YNGyI6Ohpjx47FhQsXpMuIVSBCoRBGRka4deuWwmzm5uaib9++cHZ2BgAcOXIEJ06ckP+7iIOD45uGC4hxcHBUTzp0QB0/Pzg6O2OzlhY0AgKgX7s2rl27JrNJVQASgaDMMTExMejSpQuICMHBwWiRkgIcPQq0acM6C1bGH16tWkHDzAxj9fURGhqKR48elbvJxIkTATCx+3zWr2cBB2nEw6XFxASwtQUuXmSBpEKcPHkSdnZ2uHDhAnr27Flx29HRrBy1FDw8PLBo0SLUq1cPMTEx8gtu5+ay7pm+vkwgHAAaNCh9vL09kJWFwYMHo0aNGhUKaGRmZsLBwQF8Ph9XrlyR7eGkfXvWSfHff1np7tSpQPfugJ4e8OwZcP8+EBHBxt68CWzeDPzzD3DkCNvm4UNoCoXYvn07MjMz0aeEgFlZfPz4Edu2bYOhoSGmTJlScf8Lk5EBrF3Ljrk0iMWsccHGjVDJyUFoaChUVVXRt29fvC2vmcFnJBIJ7t69C1NT04o9QOnpAQkJ0o8vA0tLSzx8+BBaWloYN26cdEHVzExg0yZ8v2kT7AEkNmjArulSSkTfv3+Pli1bIi0tDfv27YOFtzdrDPElOjossH3qlOxNN8pAKBLBfMgQrEtKQmC3buw+evYs68rasSO7l549yzpYLluGw46OqAcWmKoq9u/fj379+uH69euwt7evMj8UzcmTJ6Gjo4PZs2fj2bNnMtnYt28fTp8+DSsrK7i7uyvYQ+ng8/m4dOkSeDwe7O3tq3V5q76+Pnbs2IH09HTZXyKVwN27d2FsbIz4+HgsWbKkwoF3ReLo6IiMjAyFBC9DQ0NRu3ZtnDx5EhYWFoiLi4OTk5MCvOTg4PjW4QJiHBwc1RdjYwj37IHVwoWYY2eHfqmpcOjSBRMmTJBJqyoUQFIZAY83b96gXbt2yM7OxokTJ2CdlcV0cTp3Zg+UlfmG1dER9kZGMAbKzWZJSUnB+fPnYWpqipYtW7KF9+8Dly6xjC5Fa/HY2rJsuX/+KRbACgoKgq2tLQIDA9G/f3/pbUokrJudnl6Jq6dPnw4vLy80aNAAjx8/lr+r2YcPTH/q5k3AwQEYMqRoBk1JGBkBiYlASgqcnZ3x4cMHXL16VarpHBwckJqamt+tVC60tZmm2aBBwMyZwOLFgJ0dMHw42xdLS6BHD5aVk5wMnDwJrFrFMoJcXTE8KQl/mpqCf/kyznh5sc9CCoYOHQqxWIzdJXW0rCjq6kBqKjsG5ZGYCOzcCVy7xrLp1NTQsGFDHD16FFlZWbC0tJTqfnD06FHk5uZixIgRFfPV2BhQU6vYNmXQuHFjPHv2DAYGBliwYAHGjx9f8kAidn4OHQocOYIPTZtiJIDXlpZFs7EKkZSUBFNTU6SkpGDbtm0YOnQoO69L0g9UUQF69wZevCjSQVaRbNiwAXw+H9OnT2cLmjRhem/bt7OOsvPmAWPHIsXCAmH378OoaVOmcwYAv//Ofg4cYAHrStIn9Pf3R9euXXH27Fn89NNPlTKnshEKhQgMDIREIoGNjU2Fvz/fv38PV1dXqKur48KFC0ryUjpMTEywYsUKJCYmVuw75itk+PDhcHR0xM2bN+Ht7S23vdOnT8PCwgKZmZk4ePAg5s2bpwAvZSev0+O6devksjN58mR07NgRqampWLlyJcLDwytVv5KDg6OaU9U1mxwcHNWX28HBZAvQ7eDgqnaFKDaWPs6bR0v09KgJQA0aNKhQx7bydDgSExNJT0+Pjdm7l2kHPXjAOqt9oZdVKaSlEbm60tzPXcKiy+gI5+rqWlSLRCwmGjuWyMmJdYdTBunpRGvWEG3eXEzDSSwWU6dOnQgAOTk5lWkm77gc2rKFdUt89KjYmIkTJxIAaty4sUy6XUWQSFg3vEWLWHe8L7pmlklmJtGHD0QSCb17904qXR4iojVr1hAA6tatmxyOl0JCAuuAuXQp04m7dIlpQxXuNCgWE717x87lgACiU6coY8sWmquiQgsFAkrft69gbEoKUVAQ05b67z+2z0R0//79fH0lhXHwIJGtLdHTp6WP+fdfpo22ejXz5wvyNNl69epV7nQ//vgjAaDUinb0PH+eaNWqim0jBRkZGdSsWTMCQI6OjkVXPn3K9LbyOjlGR5d7D0tNTSV9fX0CQGvWrJHekX/+IVq+XPYutOXQq1cvAsA6XJbCkCFDCACdO3euYOGSJURDhjDtPltbol69iIYOZd1a/fyKdlVVMGKxmKysrAgAubi4lDm2OuhV5TFz5kwCQK6ursXWlbUf0updVSYdOnQo1d/qdEzK02WTdl82btxIPB6P1NTU6Pr168pyt8JoaWmRgYGBTNs+ffqUGjZsmN8F9mlZ3xWVDKchxsFRfeACYhwcHDLz1X3hp6YS7dlDJzp1Ik2A+Hw+LV++XKpNy/qjMiMjgwwNDQkArV+zhj1snTypaO8rzpkzFLdwIQGgTp06lThELBaTmpoa1alTp2DhnTtEI0YwoXVl8uYNC76U8KArFovJwsKiqIB8CeQdlzN//smE4L94IHBzcyMAZGJiIn/79oQEonnziP74gwVa5LTXqlUr4vP5lFZGIOHx48fE5/NJR0dH8e3n371jAYP+/QuaJqSkEPXty4K9kwmoAAAgAElEQVR95bB//35SA8ihcFDv1SsWfMoLxHh6Ei1dSof09OgPgOKWLyeKjSX69El+/9PSiBwcWDDmS1JTiX77jQVCliwhKiMQ2rlzZwJAS5cuLXM6dXV1MjIyqrifYWFMEF4JotRisZi+//57AkAWFhZMHDoykn3u27YRPX+eP7a8e1i9evUIAC1ZsqRiTqSmsoCqv7+ce1My//33HwEgS0vLEtdnZGSQiooKNWzYsGQDiYksKLl6NVHv3kRNmxLp6RHp6xN16EA0ZgzRtWssSK9AxGIxtWrVigDQlClTSh1XnYIvREQmn1+yBAUFFVle2n54eHgQABo5cmRlulkuqamppKGhQaqqqvTu3bsi66rbMQkLCyMej0eGhobFxO+l2Ze8QKeOjs5XFTQiIrK3tycAlFz4JY0UrFy5kgQCQbnXX1Xx1f19zMHBUSpcySQHB8e3g6YmMGIE+vzzDy7cvAkdHR3MnTsX7dq1w8ePH2UymZubi9atWyMuLg5//fEHptSqBURFAY0aKdZ3WejaFQa//w5ra2vcuHEDMTExxYYsWrQIWVlZ+P3339mCnBymteToyPSllImhISt7evaMidIXgs/n4+bNmzA3N8f+/fvLbQ6gkZDAdKIKif+7uLhg+/btMDU1RVRUFIRCoey+Pn/OdLciI4Fu3YC+fQF57AHw9PSERCLBggULSlyfV55ERDh79qx8/n/JmzfAlCms7HDx4oLPTUsLMDdn2mjlNKEYOnQorG1sEHj9Og4cOMAW1qsHzJgB/PYbK2376Sfc/PQJbxITYW9gAIPAQGDPHsDLC1ixgpUynjzJhPwrioYGK0e+fLmor0+eAK6urFzwl19YgwCRqFQzFy9eRK1atfDbb78hODi4xDHBwcHIyMiQrQROW5uV66WlVXzbcuDz+bh69SoGDRqEiIgINGvWDOkNGzK9wrFjWZluOWRnZ6NFixZ4/fo1/vjjj4qXSWlqsnvFrVtMrF/B1K9fHx07dkR4eHiJ+lUzZ85Ebm4uvLy8Sjagq8uu2Rkz2Lm2aRNQqxbTVhMKWSOOf/9lgv0+PkwT7d49QE6hcj6fj9u3b8PY2BgbNmyo8vIzRREcHAxVVVUMHDgQ6eVct+Hh4fDy8oKhoSF27dpVOQ5KiaamJvz8/JCTkwNbW9uqdkcuLC0t4e7ujri4OOkbfnxmwIABWL16NYyMjPDy5Uv5S/IVzNixYwEAPj4+Uo1PSkqCpaUl5syZAy0tLYSEhGD9+vXKdJGDg+Nbp6ojchwcHNWXr/0NWE5ODg3s35+MAVJTU6ODBw+WOtZ3714aCNCxQqVEYrGY2rVrRwBo2vjxRH//zUrpKlCKWRlERUWVWp6np6dHNWrUKHir/OwZy/ZQYjlRMU6cYGVteVlKhRCLxWRmZkYAaMKECcXW5739Dhs+nGV/fGbw4MEEgFq3bi1fS/XcXJZdsmAB0c6dRO/fy26rBDQ1Nem7774rcZ2zszMBoHnz5il0TkpIYOWw/foVy6gjIlbqa2tLdPhwuaZSU1NJJBKRSCQqtZRQX1+fVFRU2Bv+rCyWmfbgASvPPHKEaNOmotl2Bw8Sbd1KdOwY0dWrrAz2zRt2LL7k/n3mq78/K2cNDWXn0tSpRGWUCX/J06dPSUVFhUQiEcXHxxdbP2DAAAJAr1+/ltpmPgkJLGM0JaXi25ZHVhbRy5dERDR16lQCQLVq1SqW8UJUcqaIWCym5s2bEwCaMWNG0Q0yM4levCj5c/8SsZgds9WrlVJmfefOHQJAdnZ2RZbn5OSQmpoa1a5dWzpDL16w0smxY4m6dmVZdBIJ0cePLLPO359lR3p6sqyxPK5cYeeTDFl+GRkZVL9+fQJAixYtKra+umUjERHt2LGj2HfKl/tRXinf14KLiwsBIA8Pj/xl1fGYEJVcmlravmRlZVHbtm0JAFlbW8v3PalExGIxCQQCatu2bbljjxw5QiKRiABQnz59vtp9Ivr6/z7m4OAogMsQ4+Dg+GZRUVHB0cWLceLnn9FXIsHIIUPg6OiI7BIyY3hiMcwBqGZk5C+zt7fH7du3MWrQIKxt1w6IjwdGjWIi2l8RLVq0QIcOHXD9+vUiWWIHDhxAYmIixo0bV9C1sFEjYNYsoGbNynOwZ08m3H/4cLFMIT6fjzt37sDExASbN28uENf+AlFyMvDddwCAn376CYcOHUK7du0QGRkpe0v1PDH2q1eBrl0BFxegdm3ZbJWCs7MzEhIScOnSpSLLDx8+jCNHjqB169ZYsmSJ4iZMTGQZWsbGwJo1rOvnl5iZAS1aAMePlytErqmpiV27diEzMxOOjo7F1nt7e+P9+/eYNGkS6+opFAL6+mwOW1vAyQmYMKFotp2xMfuc4+NZ9tf+/SybzcEBGDYM8PYGgoNZJqa+PsuC8vcHDh4ETp9mTQFWrQKaN5f6Y2ncuDEOHDiAzMxMWFlZFRMNv3jxIvT19VG3bl2pbeZTsyYTn9fSqvi2pSGRsI6g69YBhw4BYjHWrVuH5cuX48OHD2jSpEm53WUlEgnat2+PR48eYdy4cVi9enXRAS9fAjt2ACkp5fvD57PGDOfPs86PCsbc3BxmZmY4d+5ckWzeP//8E1lZWdJ120xPZ5mLamrAsmXsvHn4kDUN0NNjnYD79WPnmrs768KZx+rVLNuwb19g+nTW2TI0tNwsSgAQiUR4+PAh9PX18ccff3wT2Squrq6ws7PD9evXsXbt2hLH9O/fH4mJiVixYgVMSrrPfCXs3LkThoaG8PLyUkg3w6rk8uXLEAqFcHJywqcyMhw/fvyIJk2aIDIyEoMHD0ZISIjs35NKhs/nw8TEBA8ePCh1TG5uLvr27QtnZ2cAwJEjR3DixImvdp84ODiqF1xAjIOD49vGzAwt5s3D3rlzsdjI6P/YO+/4qKr8/T8zk957gYTee+8SYClLB0FWBFkrLpZdu/uz7Lq6X11Xl93VRUVRREUQQUBDEZAOBkLoJQQChPRKQiZ9Zs7vjyeTSSBlMvUGz/v1uq9JZu7ce+bec8/Mee7n83xwfNs2hIWF4dChQ3VWU1eXZzdoNACAefPm4eeff8aCESPwxZAhTId68EEgKsrhH8EcjOkqtdMpXn75ZWg0Grz99tt1V7Zlap45uLgwxauqipUnbxEjXFxccPbsWXTo0AHvv/8+Xnzxxds2YXB1Bbp3x7Rp07Bx40YMHjwYx44dMwl9zeX0aeDjj3leH3oIGD3adlVCr19nWh+Af/7znwB4Lozk5OTg/vvvh4eHR4MpfBaRn0+BT61mdb7GUmPuuYdplSdONLnZ3/3udxgzZgwOHDiA1atX1zyv0+nw2muvwdvb+3axpTEGDQJmzTJVEXzmGaa73XsvxbKKCuCXXyigLlvGSqU//QSsXk3xqXdv9qlmMnfuXDz11FO4du0a5syZU/P8hQsXUFRUhN/+9rfN3qbNMRiAHTuYbvrjjzyHDz8MVI9LL774Ir766iuUlpaiT58+t41jps0YMGLECJw6dQrz58/HJ598cvtKqamAtzdTDs2hXTuKmydPsjqpjfnggw8ghMATTzwBgJ/h/fffh5+fH5YsWdL4mw0G4M03gaws4K9/Zcpkly411+FteHszJdfIypXAX/7C1MuSEva9P/wB6NmTYvmHHzKtuqqq3s35+Pjg4sWLCAwMxB//+EesXLnSgiOgLGJjY+Hv74/nnnvutlTW1atXY+vWrRgyZAiee+45J7XQPNRqNfbt2weVSoWJEydCV/1d3xIJCwvD559/jtLSUvymAcuDS5cuoV27dkhPT8fLL7+MtWvXOriVzefuu+9GVVUVfvrpp9teO3LkCEJDQxEbG4uBAwciMzMTc+fOdUIrJRLJHYuzQ9QkEknLpUWFhOfmCvHRRyJ+7FjxsEolAIjHHnusJpVw3fLl4q+A2LR0aU3Vwgm9ewv9rFlC/P73NG5WOMaqWklJSSIuLk4AELNnz3Z2s0wkJzM18eef6325oqKipmLUq6++KoQwpYMcW7BAvFhtwj9y5MjbjIXNxmDg8tlnrJ5XXSXRpnz3nRArVtT827t37zrm+sYUth9//NG2+42NFeJ//zMvdU+vF+K994T45huzNl1SUiI8PT3rpE4++uijAoD4+OOPrWl1/RgMNOY/d06IP/2J5ugTJjB9MiZGiDlzWPxg/fp6q0s2xqBBgwQA8e9//1sIIcQDDzwgAIizZ8/a/nM0hxMnhHjkEX6+554TopH0zR07dggXFxehVqvF999/L4Somzo1btw4AUDMnDmz4f09/rgQr7zSvDaWl7PfrFnTvPeZSXR0tHBxcRFlZWXiX//6lwAg3nzzzabfuH49j9u335qe27yZz1mSBltWJsTWraxYOX68EE88wTTLN97gtb1jR73VTzMzM4Wvr69QqVTi2+q2tNT0PCGEiIuLEyqVSkRFRYmvvvpKABAffvihcHV1FV5eXs2vyOpE3nvvvZqKrS35nAghxJQpUwQA8d5779X5LHv27BGurq5CpVKJFbW+g5SOsSrzrFmz6jz/+OOPCwBCo9GI9957z0mts4wW9ftYIvmVIwUxiURiMS3uC7+qSoh33xVlQ4eKL3x9RRAgoqOjxeXLl8WG//xHLAXE4vHjBQBxV7t2Qv/220L83/8JkZnp7Jabxflz52oEo0GDBgmVSmWZJ5I9OXCAE8sG/J9KSkpqquH97W9/E19//bVQA+KDkBDRHxBjx461fN+pqUJ8+CHFUTv4INVg9LmqrBRCCPH9998LAOLZZ58Vf/zjHwUAsWjRItvvV6djZUZzSUigQJmXZ9bq3377rQAgRo0aJXJzc4VarRatW7e2sLFmUFEhxOLFFG527GBbz56l0PH660L87ncmgeyRR4SIizNrs2VlZSIwMFCoVCoRFxcnwsPDhZ+fn3VtraqyvLJmYSE/T0wMvd+2bjXLy+rEiRPCw8NDqFQqsWzZspqJsdE3aPz48Y23d+JEs6qN3sa5c41ew9bwzTff1FSNCwoKEp6enk2L39nZPH6ff173+dRUHlNbCM8GgxBZWby2v/uOomC1ECmEEGLPHv6fmipSUlKEp6enUKlUYsuWLS1efDFWKIyJiREAaiou1/axaikYbxoZb3q11HNS27/t3XffFQDE4sWLhUqlEq6uruLnBm46KZng4GARFBQkhKDno/HmWNu2bRVXGdMcWtzvY4nkV4wUxCQSicUkxMWJUEAkmDkRVQzbtgkxebI41rmzaAcItVotXp4wQewBRE9ADAsNFZXGCVZZmbNbax6HDwvx2Wdi8ODBAkCNka4QgqblNjaLtxiDQYgvv6TpdT3m5kLQyD0iIkIAEPPmzROBgPgrIO4fOdKyfer1QuzfL8Tf/kZj8IICKz6AGSQn09D+wIGap3x9fYWvr69AtQhrcYSbLamqokDYDEPssWPHCgCiZ8+eAoD9Jl56vRCvvUZj9AMHKPb9+9805K9NdjYFshUrhDh+3OzNJyYmCo1GU2PQPGPGDOvau2HD7YJMU5SVCbFzpxBvvinESy8JsWoVz0kzSElJEf7+/jXRYMZrv74CG3UwFivYv795bRaC1/BXXwmxdKldhOXg4GDh6upafyGAhtpz4kT9xQEeeUQIe4geBkON4C2EoEBoFGdnzxZ5jzwiHtRoxFBAvPLnP7do8UUIITp37lzTtwCI+++/39lNsoji4mLh5eUlNBpNiz8n8fHxQqVSiYCAgJrz4uPjI86fP+/splnE3XffLQCI1157reb8PPnkk85ulsVIQUwiaTmohBDC6rxLiUTyq2TXV18ha9EiRI0cCc/OnXGzdWsIjQYGtbrmUefhAW14OADAKy8PACCqXxdqNYRaDRgMMLi4QO/qCmGFSWpeXh4OHjyIu+66C8HVBuwN4ZGfjzbHjqE0LQ3v/PILSsrL8TcA76jVeGPaNFRGRSFlyBCbtGfUqFEICQmxeDvm4JuWhm47duBQnz546D//AQC89tpr6NGuHbru2IFUX198VVho1rGxNy4lJWgdG4sLaWkoX7gQQdX9ozZlZWV4+umnUVJSAncAoyIi8Mhbb0HfTP8z19JSRB87Bu+8POR06YKcHj3Y52rRnH5jFgYDxr77LjL69sXFal+q5cuX48CBAwDoK9aYebu5/cazoACV3t7Qu7tb3lYhaDreRFuMx6ayshKLFy+GTqdDVFQU/vGPf1i+70bosGcPOhw6hEtjxyJl5EgAQGBKCoL278fnLi7oOWFCs64pj6IihJ87B4NGg9xOnVAeHIxDhw7ho48+AgC88MIL6Nu3b7PaWPvY9MzMhH9aWs35bgqVToduP/0EtU6HvM6dkdu5M33yLKCkpAQvvfQSCgsLAQD+/v743//+B1Uj57XtoUPotHcv9j33HHQeHs3ep5tWiy67diGvY0dk9e5d7zqWXlfbtm2r8apbvnw5vL29m90+I62PH4fe1RVnIyPtPhZ7FBYi6MoVBF6/Dv/0dLimpkKXloZSAPsBFM6YgS4TJqDM3x95BQW2HXOswJzxprCwEE899RSEEPDw8MCnn37aaP+yd3us4dSpU3j33XcBAI888gjGjBnTZFuUcJ5qt8d4bNasWYMtW7YAADw9PbF06VL42rK4hxltsdWxSUhIqPGi9PT0xEsvvYROnTo1uz2O+L1lDklJSXjjjTcQGxuLqVOnOrs5EomkEaQgJpFILOb1+fMRs3YtSgHkAjgDwKV6MU7t0gB8Vv338wDqm9oMB+AOIAlACgDdLctBAKcBRAKYCUBfveiqH90AtAVQBaAMQGX1trJqbeNK9WNtVABGARgLwL/6cSeAOACbATRef09ZqAFsAHAWwGu1np8LoBOA9wGU1vM+ZxEG4BEAFwBstNM+ugGYAfaL78G+5Sg+AK+DJqzALaYtgPsAnAKw1U77cBbjAbwM4CcA79R6XgXgcQCFAFbX877GaA/2txHV/+cBSARwArzeM6xoLwAMBjAJwN+b8Z5eAK4BaLhWnP34O4B2ABZasY27AIwB+3qh9U264wgEMBXsc6UAboBjQiWAVPDcH3RW4yQSiUNYsmQJPvzwQ2c3QyKRNIIUxCQSicXsXrkS+x96CB7PP4/o2iXsAUAIqISAqjr6CwBcS0qgNhig0uuhMhigMhigNhjgm5kJdVUVdJ6e0Lm7m9bR66E2GHAzMhIloaFwKy5GSHJyzXuN73crLkbIpUtwP3cOZUVFKI2Ohnu3bqjw8alpzoWpU+tEQvhmZCD62DHo3dzgUl6OyMOH4ZmTg8K2bVHWti2qPD1R0KED9O7u0FUv5X5+KG3Gncd9+/bh008/bfIutK3oun07Wp88iZ2PPoqUoiL0Mhgw/NtvkTR+PL4qK8OKFSvw6KOPIiYmxu5taYp9+/bhl08/xf/17w/XWbNQ0LFjveulpqYiISGhWXd91VVV6LVpE3xyc5E+YADSBgxoNLJs7969Nj82nXfuRFRCAvY8/3xNRcSSkhLk5OSgVatWcG8kqqupfuOTlYV2cXEoCQnBtWHDrIpibIr6jk1FRQWuX7+ONm3aNPo5LME3IwODvvwSNyMjkbBgwW3VJJM2boRqwwaU3Xsv+kyb1uztuxUVISQ5GUHXrsE/PR3uN26goqIC+ogIXBs7Flm9epm9rdrHZnrHjuiwfz/OzpwJXT0RTZ4FBSgLCLBdJdN6+OGHH7Bu3TrMnz+/yYiE4R9/jJKQEJy2olqbSq+HT3Y2hFrNKOBbIoasua7Ky8uRmZnZ5LViLo4ei2uTlZWFuLg4jB4xAlEaDbzz8pBy4AAO7d0Lt+pjE3jlCiLPnkVBu3Yo6NABlbW+u+yNuccmLy8Pe/fuxdixY+0aLWVsjz2/q3JycnDgwAHExMQ0+r1ij+8Ga6jvXKWnp+PIkSOIiYlxaBSbPY5NWVkZsrKyLLrunXmN18fFixfx5ptvyggxiaQFYL9f0RKJ5I4nLCwMADB58mT0HTfOya0BLkyejP3bt8Pn7bex4L77AIMB0OkAnQ59vLzqTtjy84ERI4DycqCiAoiJAXJz4VdWBpSUAKWlwIABfCwt5XNt2gCzZ5u2sWEDcOUK4OHBxdUVuHgR8PUFfHzQVqNBBoC5rVph0qxZwK1tsDVjxwILF2KRry/w5JPAo48CPXsi4r33kPrdd1ixYgViYmKwYMEC+7WhGXz66afwHT8eY1UqYPRoIDra+o1mZQHr1wOBgcDcuWi/YIFZx9zmx6ZTJ+Cll7Cgd2/2o2by6aefYsyYMbe3Z9s2YOdO9sN58zDCjmKYEYf1G60W+PRTYPJktPrLX9CtHlFgtRA4vmEDHiouRs/77rP+esrJAeLigJQUdOzeHRg/vllvNx6b6d27A9u2oefgwUD//qYV8vOBXbv4+JvfAD16WNfeJli3bh2mTp3a+LkqLwcuXQJmzEBvC/pmHTIzgeXLgXHj6n7uapQ05jR4TTmB1atXY9XevfjaeGw2bwaOHgWOHOESEQF068ZxbOJEoHt3u7bH3GPzpz/9ya7tqN0ee/ebZ555xqz1lNSHAWX1Y3lsGub48eN48803ERkZ6eymSCSSJpCCmEQiuWPQhobiApi+BJUK0Gi41HenMTgYqPYmMgshKK7VpmdPIDTUJKrdvAlkZFBAKyxE/2PH8DqA1uvXsz1qNXD//UD79rdv/9w5oLKS62g03G5ICP82l1atgN69gZ9+AgICgORk4C9/AZrpu+VIMnv35udetw547DGgvsiInBzAz4+iY0MIQWFj1y4eu3ff5fFzFv37A/7+FEytFR2MbN4M/Pe/QN++wD333BY9ZRWFhcDZs7wm7CnaNkZGdeLiK6/U3w8AQKXCUQAP6/Xs383wmKmXsDBgxoym16usBGJjKbIPHXq7eGv0hMvM5LnPzaVgnpNDgXz2bLuLGmaTns7Htm2t31ZkJNCnD0Xarl0p+tsTrRbYs4cikY2jE53KzJnA9OlASgqFsdOngZMnubz7Lse3nj1502P2bB5rZ12nEolEIpHcQUhBTCKR3DFUeXsjHdWCmK1RqRgBVptu3bjUxnhnMikJJdOn46+FhfjDAw9g+rRpjDJrSKRJSKB4kprKib5xn15enFB36UKxKyiIkSYNMXMmRbB//5vCiQIi9xpDqNXAvHmMMtm+HagvhWvVKmDIEEbx1YdWC2zaBFy+DAwfzuPjgMipRnFz48RVr7fN9tavB5YtAwYNAt5+2/afLy+PYmJ0tG2EEkvo0gXo0KHJz3YQwM2oKGD3bqBjR8cIAzdvAhcuUPj53/+A4GD01ekwB9XFQsLCKF6npgIffkjxUq0GXnwRGDXq9rHDmUREAHPmcCyxBRMnAklJPDYzZ9pmm/VRWQn8/e8U+8eMubMEMYD9pX17Lr/7HW/ArF0LfPYZsH8/x7lLlyhcDxwItGvHa7VdO55LKZBJJBKJRNJspCAmkUjuGFR6/W3G+U5Dp0OZvz+SAdxs1arp6JBFiyie5OQAaWkUKPLzgRs3uPj6AmVljDypj4IC4IsvKKAlJzNqbcAA4OOPgdBQhCQloS0AVVWVjT+oDfD1Be67jxFCe/dysmukspJCYkBA/e+9dg347jtOBhcutD5iyJa0aUOhs4lKjk0SH89zO3w48MYb9hH7OnZkZN0vvzhPEAPM/mxZPXqwvyQmOibyKiSEkWuLFzMS8cQJ+GzbhicBdP/4Y2DfPqbrLl0KtG7NPrxkCY+p0vD2prhuK3x8mGoaG8vouDZtbLft2vzjH4yeevttjhl3MtevAz/8wLH/rrvYt4KCGC3m48P/r10Dzpzh+BIRAfzhD3yvVsvvATv61UkkEolEcqcgBTGJRHLHoDIYlCOIubmhKCoKmfHx5r9Ho2EKkiWeE66unIxqtUzLzMjgcuECUFGBIZcv4wcAYf/8Jyf0zz7LiByl0KoV04X27mW0jdFrqbC6fl1gYN31dTqmqXp7U8CZOpV/K4nevTlRtUYQO3oU2LoVePhhRt/Ya5KrUgG9ejElc/BgCmQKpiQsjGnPe/YwfcxRk//QUKa2TZ+OQx074o9xcVg/ZQrCPT0pJgLAl18yrfLXxMCBTO+LjWXqc3NSvc1h3TpGBD74YPOPrRDwycmB4+zGraC8nJGax44BUVE8lv/5D6/N4mLg4EFGHfbpw/UrKiielZWZtvHWW8CpUxzf+/RhdG337lIgk0gkEomkHqQgJpFI7hjUOp1yBLHycj44an++vvSXAThhNyIEUFyM/GnTcD09HcVjxiBi5MiGI64AoKgIeP99RqmFhQHh4RTpWrdmSp290nOGDWN03ObN3G9ICNNIMzLqRoTk5jKF0MeH4t+8ebZviy0IDbUqQij48mWmSA0fzrQ0e6dEDR7Mfrt6NdNulc64ccCKFUwhMwoEDqYAQMaAAfQA7N6dQtDXX/NY/poECJUKmDaNqc+HDzOqyVYcPw588gmLoNx/v0WbiD5yBIqXKJOTmfpdUQFMmcL0aLWahVr69OEx3rcPePppky+kuzvQuXPd7UyfzhsI58+zL65aRf9FlQro14+vDx8uUywlEolEIoEUxCQSiRXofXywG8DMxszOHYhaSRFi5eWASoVKZ7dDpQL8/CDUalwA0GrkSIw0pwJTeDjFqZMnmbZTu6CAmxswaxbw+OO2b+uMGRQ5vv2WVTLPneNE0d+f4l5CgqlowMSJtt2/wqjw8WHa65gxjpm8enkx9W37dkbmNSaaWktRESOqxo+3PAU0KorRYXv30nDc1lFJZuJ//To/y6JFjAh85x1GiT3wgFPa4zQiIijOLF1qu2qaOTlME46IoEhricioUsGzqAizm17TOdy8Cfz8M/0oW7WiGObvz9cyMpg6368f08F372al2ca82oYP5wKwwMvRo8ChQ7yu163jmB4Tw8jatm3heeMGpDQmkUgkkl8rUhCTSCQWo/f1xQEAQiGCWHaPHrjg7EYYKS+HXuz/Y7gAACAASURBVEFG2oVt22IPALOKkfv70yvJiF7PaLHUVE7QMjOb9uras4ceOJ6ejPYypoJGR5sq8tWHuzsNpT/5hJFiWVmMdigv5/YSExl9M3GisozK7YA2IsIU9eco7rsP2LIFWLOGHlj2oLgYWLmSf991l3WeaGPHMiopJYWG/E6g644djGZcsIBi8dGjjMwZMUJZackAr2V7CofTpzOFb8cO67dlMABvvglUVTEN0IrvmeKICEQDyLu1UrCTCbpyhcUyXF0ZETZ/ft0Vjh7l45AhHD/bt+f1aW7xAi8vCupjxtADT6sFrl6l5+S1a8Du3eh0/DheAqCurL59U1rKa1LB1YklEolEIrEVUhCTSCR3DIXR0Uh3diOMlJdDr6AJhUt5OYosfbNGw4ix8HDz3xMczAlVWhpw+jSN8YXga0JgXG4u/g9AdHw8xa3aqYUhIYxAW7eOEWIA8NFHjFK7997bK3tKbEdEBCff27cDjzxi++3rdMDLL1NcXb7cet+3iAgKd5cv08zdwdVFu4CRqVi82CQgvPACi0Hs3EkBQ0nC7YoVjOKyV/VZX19Gea5bBz9rz+3+/YCfH/Daa1Yb9d9o0wbuAPwzMqxrk41wv3kTDwJofeIEIwknTODNg1txcQF++1uTr+SiRRQb8/M5xjYXHx9TQYWYGECnQ/KyZdi9cSN6GfvvmjWM0O3Qgd5lAwdyUdD3mUQikUgktkIKYhKJ5I7BLyMDdkzyah5t2iC/fXtnt4LodNBUVaHEkfvs06eur1NpKZCeTiHk9Gn4vPUW3AC4lpaahLLa9OjBdLj//pdpUuHhTNFUuNl7vWi1jMwxpkHVhxAUoexVoa85LFrECL2LF22/7XffpefXyy83T2BtDI2GRuRqNX3oHITKYMAEANnduqHj+PGmF7y8gD/9icdw506mwCmBigpGXA4ebN/9dO8OdO6MVtu2wSopcMAAiuO9elndpII2bRAOIDAlxeptWYVOBxw8iM4//wxvAFdGj0afGTMaXj87u2766V13MUq3osI27XFxQWlICI7Wfm7UKAq6Z84AP/5Iv0ZXV6Ztd+1K8W7KFIeLzxKJRCKR2AP5bSaRSO4MhEDbuDgoRi7p0gV5SkmXKqEUpnVmG7y8GJnSuTPg7o7S4GB8kpuLyJgYDA8Lq/89Q4cyffLUKYooTzzBKIXgYIopUVFc7rqLhv9K5YsvgHbtaDpeHwYDJ54nT9pOJLKG7t1ZsfSXX+qPWrGU1avp/7ZwISfVtiI4GOjbFzhwgCKKgyJZAq9eRTCATKPheW3CwoBJkyhyjhhhXz82czlxgkUaGrrebIVKBUyZApdNmxBjzXb8/GwihgGAwcMDGQD6paXZZHsWcekSU4U9PJDbuTM+AjCsqaIbDz1EccqIiwtTc+1J165cAAp4p08DR47Q8P+nn1gB8/Rpjr1t23Jsi4pSViSkRCKRSCRmIgUxiURyZ2AwAEIox1Rfp6s/8skZaCmFOVUQq41Gg6JWrZCamNj4eh06AB9/zGiI1FR631y7xjTMjAwKIDdvUvB7+OGGtyOEcyuqtWlDX6X60OmYnnT5MjB7NqPqLijACW/4cGDtWrjZSjw5eBD47DNg9GhO8m1NTIxp4m7LCoeNUOnjg70AujQkdg0axD6sBDEMoJCRm9u4h5+tCAxEdrduGA7Ao8jiZG2bkgTgrpwcx++4ooIRjPHxjBRdvBjZP/8MvTnvVanoq+gsXFwoMg8YwNTkykqOVTdvciw+epSVLzUa4MEHKYxVVnLx8XFeuyUSiUQiMRMpiEkkkjuDarNkxQhin3+O1klJzm4FMRhQ7ueHYme3w0hVFUrCwlBu7vru7jTxr8/IX6ul6XZjrFnDtJ/QUJOxf7t2FCscEVkWGAisXUv/s6Ag0/OVlcBLLwFJScDbb9dNMXU2nToBzzyDys2brd9Wbi7wz39ym6++almlwKYICKDP0aFDTAl0QKEPbXg49gNY3NAKKpVlPk/24uJFeprZ4/jXQ16XLigA0OrkSeeL0gDOAXCprKSY4+fnmJ0mJgJbt7IoyOTJ7JsOOv52wc3NlMI5bBjPa04Oi1oYo93i4oDXX+c42707r8uhQx13zCUSiUQiaQZSEJNIJHcGShPEysuhV4rHSnQ0Lk2YgNJVq5zdElJUhEpbpeKZE4XQsyejytLTOUE9eLCmv8DFBUP0eiwA0OrUKaYKDRxo28l7VBQj2o4c4aQY4AT5hReA8+eB559XlhgG8PPbIsKjrIxi4MiRdY3n7cHo0UwLPHzYfqbxLRWDAUhOBmp7ndkZoVbjRwCT27enCNWYh54D2AMgv0MHtM7Jsb84U1wMbNvG67tzZ6ZLO/nz2wWV6vaCK506Ab//PSM2Dx5k2rBKxWiz6GgKaVOnKjvNXSKRSCS/GhQyW5NIJC0RVVUVwgGTuOBMqtvQRKyQ4ygvh156qtRPYSGqvLwct7++fbkY0emYgpmcDKSkwHX5cjwBwCU7m2mYgwbVfX9JCaNrQkK4NLftbdtyMnzqFAWxigrg6aeZevTyy8BvfmP1R1QsKhWj8saNY6ScPfHxYYXMuDhGpFhb5dDWlJczojEkxPH7vnqVhS2MFQYdxHUAmspKpj4/9VTD105iIiM97di+GwASJ09GH3sX5jh3jp6AGg0wdy4FeSdHxzmUVq0oiAEmIfbIEWDzZqZYbtwIvPIKoxWnTwfuuYdjpC39CiUSiUQiMRMpiEkkEotxzcvDHwBotApwpyothZtWC42z2wEwjaS8HHqllKk/cgQRZ886uxUmioocK4jdiosLJ2PVVUDLv/0WxwEETJyIwfPn375+djYnuEZPuHPnKL60akV/sA4dKKIFBNQ/8VWrGTVx4QLTJNes4UTxL39hVNOdjIcHRQFHMXIk02NXrGClR1uTlcVzaEk10B9+4Psfe8zxvlAnTvBxwADH7hdAYVQUkJfHipszZ96+woULrMg5YgRN9O0oHlV5edlv+3l5wM8/U9Tr3h2YONH+Ik9eHsV2pd58UatNxVQWLgSuXGFBDX9/CuXZ2YwgNUaatWsHv/R0/IrkQ4lEIpE4GSmISSSSO4P8fASmpsLX2e0AOGE2GKB3gI+RWaSkwLOw0NmtIELYNmXSBujd3HAOwEigfn+fDh0Y0VBQwAno3r00lE5JYcSDTkdhy8ODPjoxMZwA1qZ3b1aY++wzoLCQXlqWiCpOwA2Ax40bzm6GeXh5MQrvzBnbe0UJAWzZwkimxx5r/vvHj2ek1LZtwKxZtmuXObi6MkrPCZ5meg8PfvYffwT69WM0kJHCQuC11yhST5/eMiOp9Hp61+3fz/42ZozJZ8tSDhwAMjOBefMaXqe4GFi2jCJjv37W7c9RHDtGIWzkSFYQHjCAfeDaNS6JiYg6fhyi9voZGUyztHd1VIlEIpH8KpGCmEQiuTMoKwMAVDi5GQCYFlVaCoNSUra0WlQ5s1JZbVQq4LnnULBmjbNbQgwG6Dw8kIBqQawhXFw4IQsLqzvZ1es5YSstpXl8bm790T/5+Uxb27qV1diKiphCpxTRtBEmAWgXFwc8/njLMASfPJmFCvbvp3eTrTh/nqm2ixZZJtwEBdE76csveRxnzLBd25oiO9u5PnUDBjBKbcsWiokaDaMkX3uN4+WyZS3iWriNtDRG/uXlMcItJsY20VqXLzedmu3ry7Hmk0+ADz+0fp+O4NQp+oh16gSsW8d+ERBAQa9a1Lv4+eesvAuwOuf27fw7IoKRd/36Af37t5gbChKJRCJRNlIQk0gkdwahocju1g2ZiYnObgnv7B89ChelGHtrtdApabLp7g6DUlJ8iouhMhhQYOn7NRpO8AAa8jfEiBFMCUpP5wTv/fcpioSE8P1t2zKqbPBgCgUK4igA19JSprb17Nn4ygqoJgh3d0ag/PwzH23hXVZeDnzxBb3oOnSwfDt9+rDPLFvGqMHqtF2707Ejizs4C5WK4uQnnwC//AKMGsVr4OxZ4M9/ZvtaEhUVwO7djBCNjGTBiIgI22y7vJxphEYfrsbo2ZPjydmzTDdVOomJvAZatwZWrwZOnrwtuk1f+4bCn/8M3Hcfj/OJEzTq370buH6d1/VddwGPPsqqwbYoAiKRSCSSXx1SEJNIJHcGOh2gUinDVL86PdGpPlm1UZIglp8PpKdDpRTRp4BSmMWCmLkMH84FYCrf+fOMYrpyhVFHFy5wYjtkCAYdPIjnAUTFxzOCont3e7euUbIBlPv5MbLpnXcaXlGrBb76CpgypW5anDMYMoTCy969wOzZ1m9v1SogIQF45BHrtqNSsZDCgw8Cr7/OFFpHVKNVQuGGiAgWO9i3jxFrmzYBc+YAkyY5u2XN4/hx+gAGBNAnbOhQ20ZOnjhBwc2ctMtJk4Dly+mbp3RBLCOD43+/fjxuy5cD33/fdLpnmzZcjF6E167xfUeO8Lt2/Xo+HxJCYaxtW6BLF8f79EkkEomkRSIFMYlEcmdQXWVSAfUuWd2uVy+U+yrA0ayyEqishE4pk4PkZOCnnyAcFRnTFAUFEGo1HOqw5udHT5xhw0zPGQw1HmUhq1YhHIC7Vgvk5NQVxGJjmSoVHk6Bwd/fIRFZxWFhnIAeOUIB4FZKS4F//YtRGvauJmkOrq70ddu2jVFi1vgP5eWxMt7o0Y1HAZpLQADw//4fo1/++1/guees32ZLYcwY4OuvgQ8+YJSYtQKjpZSVNd/wXqulaH3mDMf4J57gubQ1CQkUc8wRuNzcgLFjgR072D4lR0klJfF4DR1KETgmhsezuV5/7doBzz5r+r+4mH6ORl/HY8eAZ57hMUxJAeLjOdY6M0JSIpFIJIpFCmISieTOQEmCmEoFhIRAr4QIsfR04PBhuBijk5xNUREnP85OqzOSn48qT084PV7NmD6ZnQ2dhwe+BxA5diyGxcSY1tHrGWFx7lyNZx6qqhhh1rYt084GDqQ/j42LFmT17s1otrVrbxfEjF5Qp04xDc6WRvbWMHAgcPgwsGcPDbwt5cMPmQr6+OO2a9uQIYxc27OHj9akYbYUdDqaz+fnU7ypqAD++U8Ku23asA+3aWN/UefcOUYVvfSSeb5lQjC1b8cOjltz59q3Gua5c+wP5kYOzp1LoXzzZmDBAvu0yRZotSyuYEwtnTuXhRZ++IEVKC3F15fnwygglpRQsASAuDjgo4+A//2PBSW6dWPac//+txc+kUgkEsmvEimISSSSO4MqJksqQhArLwfc3CCUYECekwNUVqJSCeIcQEHM39/ZrTAxahRSLl9m1IoSKC6GNiQE9TrhaTT0FRKCURHZ2fTk0elown3oECfuAQEUpYxRZGPG8L3WoFazCuAXXzDqonZK5PvvM6rl2Wetr65nSzQafvb4eI4PlvjWpaXRnH/OHNtXuVuyhBP3TZv4t4Iqr9qctDQKNgUFFG20Wj526cL+lJTE6EOAxQd+8xsKu1ot/7el+OTryyiiuDj2j8bIz6fYdPWqKdXPnmOpTkfhefp089/Tti2jSLdtU7YgFh5et8ppmzb0lbN1BeTaxWx+9ztG0MXFMRX1wgWOkxkZFEP79mWEZrt29on2k0gkEonikYKYRCKxmMqQEHwAYIYSUgN1Ogi12lSu3ZmUlSmnYlpVFRAejnKliFBFRZzglpY6uyXEy0s5xwYAystRFBWFG42to1JR8PLzY5SDcfJcUQHcuMEUv6wsCmYXLwK1izucPk1xwiiWhYYy7coc5sxhhNjXXwOvvMLnNm40eUE5smqiufTtSwFjxw5WeGwuBw5QnHnwQdu3zcWFx+3jjxklM2+eciInbYQLgMjTpynYGs3nQ0NpqJ6RAdx7L33yAKbOpabSMN3XF7h0iZFc3t4mH6m2bdlvrbnZEBVF4enUqcYFsYQEiky+vsD99zvG+P/0aV7HAwc2730zZwKff87jZyzyoTQGD779uenTgW++YV9o1co++w0L49hkHJ/y8oDvvmP0qFbL8QugINa2LcWxzp2VnX4qkUgkEpshBTGJRGI5rq40I7c2+sQWDBiAC1OnAhs2OLsljBBTiiDm7g707IlKpfy4LypiOpASBDEhgNRUqKsUUYqB5OaiwtKUQ3d3igUREQ37D5WVMQIlPt5UEfLaNYpr7dvzfQMG0AfsVnHGx4eTyqQkTtpPn2a1xCFD6KekRFQqisLx8azq2KaN+e+9epWC4ty59rue/f15TLOy7FOh89Ilel7NnOnwcdo7NxdLAARfuQI8/TSLShiFrPbt2Y9q4+fHqonGSqYVFUylu36dUWQ//0why82N0X4eHhQ5o6LMF3UBtqF9e57b+khPZypr//5MDx4zxrLoQksoLmY/7d+/ee+bMIGplufPK1cQq49OnXjeExLsJ4jdSkgIIzKXLOH/paXsY0YPstOnWdmyc2eoKysxH4B3djZTw5UQ9S2RSCQSmyIFMYlEcmeg0UDfnEmRPVGSIKbVMsJCCZEnlZWs/Netm7NbQrRa4PPP4V07xcbZ5OWhwp4Rl0OHcqmqAnJzGUX2008UyXbs4Pnp3p0CQ3g4Wl+4gH4APAsKKEYsXAj85z+sFLhhAyffb7yh7Ilijx4UCX/+GXjgAfOvhbg4ii1GgcZedO9uv0qiycmMGnKkGFZRASQmotXp0ygGkPSb36DvyJF11+naFdi6tXGRwd2dgkmnTvxfpwMyMyle7NrFFLj8fL4/MtIUQRYdXTdtrj66dqWhe+39V1YCu3czdTMigtu097m/lawsRoc19/tDrQYWLVJGQYvmoFYDkyc3fb7siZcXv5OM30tlZTUCqH9aGh4F0OPTTznmde0K9OnDmwZduyrjZqBEIpFIrEIKYhKJ5M7gzBm0OnXK2a0g48dTcNi2zdktocGwUqLDMjMpwihFLMzPBwDlRM8ZDEB+vmOqk7q6MiKjVStTNIoQ9PPJz6dQlp2NyBMn8D4A/927mY55zz1c5x//YOW2J59UzvlsCJWKaaPffEPhz9zUt7lzef0oQUy2lISEun5v9ubSJXpulZUhdeBAfLFyJcbX15979QK+/57rm1u508WFYld0NCuHCsHx5Pp1LufPU9AFKFhMn87ouOhorlub3r2Z7mvcv7HdpaWMtho2zDki729/yxsqlhASYtu2OAp7icGWUsvL70aHDpgP4PsZMxAeEEAPsvh4jn8GA/vW0KH0Qhs4UApkEolE0gKRgphEIrkzyMyET3a2s1tBlOCpZkSrVY4glpNDIaZ1a4pjzqagAFCpUKmUCLGbNwGDwfKUSWtRqRhhEhhYE5VTtmYNsgHkjhuHPsOGsS+1b0+BoaoK+OQTeu8YxTWjD4+SrgGAnkBRUYwS69DBPJHL1bVlG22XlzPiyZoKfuZSWspIw1OnKDhOn47yLVsaXt/oG3b2rPmC2K2oVPSHCgsDBg3ic0VFFMc8PSngbtwICIFuly5hLoDgy5c59vTrx/fHxbENZ86w3dOmOTfKyt9fWUVHJLgJIKtPH1PBgps36Tu2Zg0jFffuBb78kiLt3XfTg6x9+/rTziUSiUSiOKQgJpFI7gyqTfUVwdmzdatpOROtlibWWq2zW8IUqJEjOVk4dszZraEg5u8PoZS7+gEBwCuvQPvNN85uSQ3eeXlIBRAWFGQyxX7ySQpiN27QDNu47N9PYSEri1EfEydSJIuMZAqao3yY6kOlojn+qlX0jlJK2u6t6PVM5evShSKeNZw6xe317WubtjXE+fPAli3c16xZ3F9TQkBAANd1d7dtW/z9Gf1l5MUXgdRUFK5cCV8AkWfOAMuXMz0yKQlYupRCx+zZTIWTAobtuXGD4nlo6J1xfF1cmFLerRv7kIsLPce6duV3ytmzHB/9/CiOTZmi/ChaiUQi+RUjBTGJRHJnoNPBoBRhY8eO5psi24sRI+iRcuiQs1vC6A0vr+YZYNuTggJWvFQSGo1y/LiEgDYsDD8BuP/W11QqHrugIJOBvxBAYiJw8iTNwbOzKZDp9fxMISFMKxo6lOlGer1jRbL27bns2kWxqb7xwh7G9s1BraaAsGkTTb+tie48dYqT9YYKLFhLVhajYxITKYBOmdK8yMAZM+wfverpCXTpgqxevbASwPgZM9A3Jgb49ltTOvmiRRRsJfbh6FGKpk8/3fh6QvA7QslkZFBkdXfndRUVxT6m17NiKsDITKNJf2amSfRduZLXSr9+/F52ZCqzRCKRSBpECmISieTOQKdTTqRPWVkdHxKn0qMHH5UiiCkpHejwYR4fpaRMGlO9lIJWC01VFa6Zu75KdbtBvE7HVNnMTE4mjQJYRgbw+eeMGjGmW7ZqBYSHU8SxFyNHAs88w2ig0aNvfz02ltEcEybYrw2NoVIxcurjj+mxtXCh5QJpYiI9jmwtQAvBSnwbN1K8W7yY11FzhcQOHWzbLjMQGg0FikOHKOD17EnfsdmzHd6WXw2//MJ01Kb6x7FjwI4dUDuq2mRzOX0aeO01/v3CC8DatUz/HziQN8GM9gQeHozw7NKl7vvVaiAtjQLh8uVMqezWjWLsuHF1IxslEolE4jCkICaRSCxGU1yMsQBUZWXObgojxJQQWaPXMz1ECSkSBgOjIJQi+ChJEDMYGLWgJEPn7dspCCmFak8+q5z5XFxMYtfAgabnAwKAqVNN6ZanTpn6a1oaI7mmTWMERkSE7USdTp1YGODUKWDUqLpiU1YWcPw4jc2diY8PP/sLLzDaZPFiy7Zz5QrN4W1JURHw44/A5csUFSdOVI5HoRmodTrg5Zc5Tr/7Ls/5jz8yHTgqytnNsw1CsKBLRITJq81ZFBayOqM56b/dugHbtiEgNdX+7WomESdPMt06LAx45x0KYa+/zjFtzhwK6T/+CMyf3/BGfv97LgUF9K47fhw4d47C2r//zevp4YdNHmTO8pKUSCSSXxlSEJNIJBaj0WoxBoC6pMTZTQHOn4d3Xp6zW2GqEKYEQezGDeCDD4AHHnB2S0hREX/oK4GcHPoIRUfzODkbIYC8PEasKMHvDQCys2FwdUWhPbbt48PJpFEk0+kowJ09Cxw4QJFs924+r1Ix3TIyEsGXLiEKgEqns3zfEycyAuvkSZNgYDDQFD4oyGTQ7ky6daOY9e23wJAhTLNqDoWF9DEcOtQ27RGCFSt37ODYdt99t0fAtAB6/PADj83f/05RIzKSkUlbtwKPPuq8dNmkJAqYkyZZ3waVisbvR4+y3zjzRlF8PPvOkCFNr+vrC3TtiuCtW+3fLnMRAkMBtDtyhMfyrbc4dqWk8HtjwAAKWF278oZGY4KYkaAgRidOmcL/r1+nB59Ox3HvxAnTeu3aAXfd5dxCDxKJRHKHIwUxiURiMdnZ2RgAwOWpp3Cqd28ItRpCo4FBra75uywgAOn9+6Pd4cN8XqOBQaPh69X/+2ZkoCQ0FJU+PqZ1am/D3x8GjQbupaV1njeuKwAM2rULaTk5AIAtjVU3szPuxcXocvo0rgQEIPbIEae2xzsvDx1On0bS9u2I3bcPABAbG+uUtgBAZEoKSrRa3CwoqGmHs9rjlZeHTgEBSLpyBVsOH3ZqWwDAtbQU3Y4dwzU3N8QmJABwbj8GgOj4eCReuwbAwcemOu1SZTDA/eZNeN64Ac+rV+F54gRa//gj/gHA9V//wsXVq5Hety/KgoJQFhiICh8fs8WENgUF8Fq6FBcnToTQaBBx5gy67tiBk3PnomjtWrO2Ye8+rG7VCsPKyqB+7DHELV4MXRMiu7G/bNmyBX7p6Wh74wYuJCdDl5FhVTvctFpEHT8O79xcFLRvj8xevWCIj6fYYUZ7nHldGdmyZQvmAXA9cACH7r4b165coQAFwKu8HB337UNabi5utGvnkPbc2neiEhLgeeMGLuXn22T7YRcuoM+GDTgBIL+J6Cx7nqfusbEIKyrCvrg4CnRNEJScjOjt2zEIzh//VAYDMlaswG8BfKvRoO3gwcDmzQCAkIsX0bmqCgmpqahcvRqRvr5oe/48TixbhgpLKtPWigbTuLvDOy8PPqmp8D5+HNeys1Hl5YWwCxfguWkTZgM49N13tvmQVqCk6xtQXnuSkpIAAJlKqKgtkUgaRSWEEM5uhEQiaZm8ev/9iPr6a+wCkAIq7JrqR+PfxQASAEyr53XjMhLAZQDaW143sh2AHsDUBtrhB2AugCoAn1fvswxAefVi/DsBgE/1+mW3vFYBwBaDYQ8ALwJ4HTDfe8lO9ABwD4B/gJ9PYqIvgFkA/g+AFbFGNqMjgIUA/gvYJyLLArqD1+NZZzekGjcA2wBsBPALgIngmGEsi1ABIKPWchW8vusjGMAT4NhyDMA34LjxqJ3abimdASwDcBgcU8xlAIAhAD62Yt8qAO0AjAfgCeAHOH9Ms5RWAF4FkAvgr/W8fjeADgA+gHPGys8BxAH4xIbb/A5AMoA/23CbzeUL8Ji/0Iz3fA8gEcDL9mhQMwgB8DCAHQBO3PLaDLBPGa8vNYBnAOwDxxN7MB3AAgDGpPocABfAcW4fWu61eaezZMkSfPjhh85uhkQiaQQpiEkkEovZvXIl9j/0EDyefx7RzU3paQohoDIYoNLrIdRqqISAS3k51NXPqQyGmr9dysow4KuvcL20FM+np+O3Y8ZgRP/+0FRVQVNZyceqKlwfOhTBly8j8Pr12/enUsG9uBiaigrkd+wIvasr9G5udR51np640bYtfHJyoNdoap43uLlBVKelhJ89i96bNuHwH/6AdXFxWLt2Le69915MmzbNtsfHDIIvX0bkmTM4O2sWtmzdijVr1mD+/PmYOrUhadFxbNmyxantCT93DoEpKUicMgWxsbFOPU8Az1XEuXM4N306YrdudXp7jCjh2BgJvHIF7T74APfn5qJLrfZoKivhWVjISLIbN+BZWAi3khJcHTECrc6cQYWPD8qCglAaGIiywEDoq/3Ioo4dg29WFiq8vdH+8GEkLFiAwmZECDmqD0cd6nARKgAAIABJREFUPYqQ5GRcGT0aN1u3bnC9286VFRUz3YuKEHX8ODwLC3FtxAiUBgfD0MxiB8bjo4S+c/Lrr5G7fTuq5s3DlBkzbnvdpbQUXXfuZARcnz52b0/tvjNnxAiMWrYMFyZPRnptnz0r6bxrF6Lj43HwiSdQ2Ygflb3Ok0t5OWKWLsWVUaNwtb4CFg1QsXQpoo8fx9q778a4u++2WXss4adNm/DV+vW3HRs3rRYu5eUoDQmpeU5dVQWDnavmxsbGYvfatXhh5EhMCg2FX0YGAlNSoNbpUBwejsTJk1ESGgptSAj0drZtUNL1rcT2JCUl4Y033kBsbKwifnNJJJKGkSmTEonEYsLCwgAAkydPRt9x45zbmFOnkKnR4MC6dXjskUcwZsGC21YZBHCSWF5uWsrKTI/XrgEFBegUGXn7a+XlgJcXvXPeeIPbqY2bGysExscDxcWYnZ0N/+hopAK4v3dvTBk2jN4jPj7cjiO8anbvBvz80HfhQkClwpo1azB16lQsqOfY2J3kZGDnTpoKV1dSdGp71q8HunTBwOp9r127FtOmTXNOWwB6GoWGot/99wNqtfPbUwvFtOWXX3Dh8GGc3b4dzzbVnpIS9FGrWeEuPZ3LzZtcgoPpHzVkCPvkqVPAzJmY+sorzW6SQ/rwffcB332Hnleu0Gy/kcIUVp8rvR44eJDphP36ATNnom90tIUN5/FptD0VFcCKFayyZ+cCFwu3b8fXM2Y03Jbhw1mAJDCQRR/sjLHvzPHxAcLDEf788yw+YSsmTADmz8c9Gg3QRH9o8jxZwtGjQKtWiPjjHzGiZ0+z37ahsBCa48fxSFAQhjt7zAHw1fr1yhj/qlm7di0ilyxBb2N7kpKA2Fj4FBUhMiQEyM8HUlNZAKBdO/qcRUTYpS126TdWoKT2HD9+HG+88QYiIyOd3RSJRNIEUhCTSCR3Bh06oLjCjGQXlYqCTLUoU4em7s4bRbCnnzaJZLcKZ4cP15gY++bkYBQYiYLKStN2+vQBZs4EPvvMJJLVXry9afIdGWmdOX9KCo16lUB+PpCbq4xiAwArfdlpkmARyck0jlcKFy/S3NlgcHZLTOTloTgiApVNr2mqrGoU6oXgOTeKY+npwN69FMiqqgB3d4qkUVFcIiMBjcZOH6SZqFTA9OksBLB/P/+2BxkZ9EjKzQVGjgRiYlgl1J64u7NipVrt/IqvPXsCn3zCGxbVNxEcwsmTvPZtKYYBFET69WMhhEcecby5vlYLjB/f7PNaHhCAeADT09OtinJsNpcuUUCyc5SXzenSBXj2WdP/N2/yu//qVV5bnTrxuy4lhZUyBwxgwQ4lfd9IJBKJE5GCmEQiuTMICkJ5WUOOQTbC+MPc37/hKI1z54DSUuCtt5C0ejXeWbUKfWbNQp8ZMzhB0Go5WdfpOOnWalldLzmZf+v1FM8OHwb69uUPWaNQ5utr+rtPH7anpMQUdXbrhOfYMedWGKtNURGNg51Vxe1WIiOBNm2c3QpiFGuMFQ+VwPXrQFYWEBrq7JaYyMxEmaWROyoVI8OCg3ntAKy+qtWaBLLUVCAxkdemiwv7iErFCWX//rz+nIWnJ7BoUaPRYRZTXk6hLS6OIsqjj/KzO5L4eGDJEsfu81ZUKoqAa9cy6qZrV8fsNzHRfvuaPRt49VXgyBFGwDma7t0t+g76BMBkDw8gLY2VgO2JEOz/e/aw8qM5FTGVjJ8f0Ls3F8B0Iy8tjeLr7t38PzKSInDXrsCIEYyalUgkkl8hUhCTSCR3BlVVMCghosPN7TahRWg0TMG5dTJ/a6SHEIwyKywEJk6kcFZVxUl7cbFJPNNqgY4dKaLt2sX3qtVc3yiYabWc4LZuDcTHw/3mTTj1vndRkX0m85ZirygbSygtpeDi7LTj2mRnA+HhyokQ0+uBnBzLBbH6cHExXZfGlC69nkJgWhqXH36gsFydfozWrWsWdVWV7dpiDsHBtt/m9evAmjVMF58/n5Fhjh5Hu3VjdJ5RiHQmXbtybN2+nY92bo+bVsv+NmuWfXYwYgQwaRIFX0djxXh2BUCltzevPXsKYuXlwLffMppq3Dhg8GD77ctZGG9CjRzJ5fp1/jY4cQJISKAAXFICBAXxt8uUKeyPSroZIpFIJHZECmISiaTlYzAAej0M1WbZTiU8HBg0yLL3qlSM9PLyMi99xt+fKR7GyLPaS0oKRY2bN4HPPkOXnBy8DKBHbCx//AYE8P2jRnG/N2/yOXulNBYV8Qe35HZyc/lY7cmnCLKzKdIppWR8Xh6g06EsMNC++9FoTKLX0KHAnDnsuxkZpkiyAweAigr0TkjAswA67NlD4WTIEF6PTo6CDLpyhRGHjV1vlZXAzz/T56l1a3pMRUU5rpG16dOHotzZs0zxs5aSEp5HS8YylQr47W+Bjz6i/9xdd1nfnkbwysuj4DNsmH12oFZT4Cgpsc/27UhB+/bAjRv2S5vMyQFeeomPb73FiOxfA23acJk3j/+fOQNs3Ai88w4j3OPjOS4MGsTxrH17rq8UuwOJRCKxMVIQk0gkVqGIMrXVkRqKiBArK6vfn8weGMWz+pg3j3eBFywAZs/Gla++wsaNGzHS6CdSWEjR46676J2ycSPf5+FhEssCAngH3dWV4khgID+bJZOTrCzlpCgmJfHu+D33KCOlNDeX7VCKYFhayojE8HDlCGKursDQoSjPznb8vo0p0kYvJCGAvDxUPvkkFgHwuHqVAsq2bUCvXiYfsqgoCtv2Euqzsymi1roevQC0PnGC562h/nTlCiPfSkoYPTRkiHOvg759uf/Tp60XxCorga++4jj2wAOWbSM0lGLogQNsWyMVGq3Fo7iYn9meY2MLFXpyO3cG7r/fPhu/cAF45RUWdXj9dfOPUVoaRbpevRr+HqyqAr75htFmPXrYrMl2o3dvfgf99BOvw4gI4OGHOYacO0dhWKXiWPbww1xHKZHDEolEYgOkICaRSCymMjISbwCY6YCKXI2iNEFMCcJGfj4fIyOBoCCUhITgNICcbt2AGTPqrtu1K02XCwu5FBXx8coVepnl5DDVAuDk3iiWGSPUevViBI+7O9M1b50oVFYytbNtW3t/avNIT+fERgliGMDJSHCwckzck5J4PpVkuhwUBEyeDMPq1c5uCft3aCg0Oh2SAFQ+9BC6TplCD7K8PD7u389+r1ZT8JgxgwJUSQkFF2sjXrKzabI/c2YdEak9QMGuvmiv8nIarB8/zqiPRYuUMVYZI2IvXLB+W2+/zeiWZcus205MDAW6XbuAu++2vl0NcDMykql6SvFWVBL2Gp8PHmRV34AA4N//bt730vHj/P4w+nPVh6srI643bGgZghjA1MmAAODJJxkpdukSxUghKABeu8bfBMZz8swzGJ6QgBcBRJw5w89rR+FYIpFI7IkUxCQSScvHxwf4619RrITJcmmpMsxp9XpGfxkNxBvDw8MU0XIrS5bwh3B5eV2xrLDQJCr16gV89x0n6Ua/NKNo5ufHu8yFhRTMDAbnC1FNpZM5mrw8Zfm1HDtGo297eFbdQbgXFyMJQDuA0ZO10zkNBgqdaWmmiNHz54EtW3gdGK+36GiOF82NKg0PpxC2dSu3UX2upgAISE29fXKam8t9Z2bSP2/AAGWJMJ06cZywhjVraIz+0EMU6q3Bw4Oi2P/+x23ZqeBFaUhI4+KKxLYkJPCa6dYN+Nvfmu9ruWmTecUJQkMpiC1cSPFZ6Zw7xxtjkyfzJtiXX9J/rmNHflfe+n05ejTKL1/GSAC9Nm+mCB0dTXF7+HBg2jRlfcdKJBJJI0hBTCKR3BmoVMqY4DkyZbIxiot5PKytjFc7la8xX7M5c3gnubZolpUFnDrFiUFWFvDPf/KHc6dOiD5/HmMABFy/TtEgONhxx62gQFl+XQMGUCRRCleuUHBxtsG5ESGAzZuVZXit16PCzw8/AniqvtfVah7D8HDTc337MuouLY1RZPHxwL59FNGvX2c0yfTpFMpCQpoezyZPplfgv/7FtC8AXVAtshjfW1LCVM5z53iNRkcrq7iFkdGjOX5YOn4eOwasWMGbAIsW2aZNgwZROImPp/jobCG/pVBRwRsjShk/AArUu3ZR7Bk1ij5xzT2f169zbDSnAMK0acDKlcD33wPPPWdZmx2FVsvPNnYs/3/pJeDxx5lW/ac/1X+c5szBifJyLNy6FZsefhgzw8J4De7cyfFm0yZg6lSKye3acdxRgserRCKR1IOCvq0kEonEQkpLgbQ0qHU6Z7cEuPde60UoW6DV8tHHxzH7CwtrWGRq2xZ4/33gz39mFI1WC9fjxzEAQHR8PCdQHTpwInv6NKtnBgeblqAg2/6YLijgRFcp9Orl7BbUxc3N8sIQ9iA/Hzh50rxoR0eRkwOVwYBm1e5zc2O0iDFiRAj2xbNnaXCfm8tJqBB1ozajonh93DoxdXMDxowBnnkGWLoUiIxENKrT8ISgCLZ1K/+ePZuVNJVw06A++vfnmGXJGJ6VBbz5Jo/TK6/Yrk1qNdPGPvuM/c9OUWJ3HEeP0r/y+edt099u3OD1MWVKw56ZTaFS8UbN5Mn0h7OEo0f5aE4BBB8fRkrt3UtRSUni4K0cPUrBcMgQ/u/jw5TSlSuBQ4eaLCyhjYykV+miRYxMj4/ntVxYyBTTAwd4LbVuTd9OmVopkUgUhoJHaIlEIjGT7Gzgm2/gYk5lRntjzxLxzaG4GPD2VoYv1Y0bjJSZM6fmqSvFxVj6yScYNGMG+kyaxEk7wAlxfj59rMrKTNvw9uZzHTsymsQolAUGNm+yodXS78Te1QpbKgYDj6e9qt5ZgtHYPzLSue2oTXo6hFqNLGu2oVKxH8fEcAEoDhs97tLSOFk9cgR48UVeG1u3mkSy0FCKhHPnAt9+i/adOqESwM2ICGDtWuDiRYpgkyc7Thi3lMDA270NzaGyEnj5ZU7E337b9pXwoqMZ2bdrFyP4WnqlvdJSirD2rCh65gzHe1uJr25u9Jdr3dq8dMX6UKl4nVjTphMnaDhvbnTxrFkUxHbu5DWoVEpK2Me7djU916YNfUPPnGHqpLm/IzSaut8d1QVIcO0ao9C8vfn8Bx9QLOvdmzdfBg2yXOyUSCQSK5GCmEQiaflUVgJQgKm+wUCDfzc350diaLXKmQSHhjJNpR4Mrq51hY4BA0yRGMbJW34+RZHMTEaD7N1bc86hUtGrLDiYFfNCQ5nWEhjI1LBbo2oSE3nX+557bP85LeH0aVbxevRRZaRkFRRQeKmd6udsMjN5jpWQimwkIwMVfn6weUyquzujwTp04P9C8FpWqShyZ2RwYm6MImvdmhNZX19037YNVwGok5J4Pfzud6bKmHcqW7Yw8ue11xpP6baG8eMpyOzdy1S7lsyuXYzAbSgVzlp0OqbLzZxpu216e7MfJyRQbLH0u9Xa7+TExOZFqfbrR+ExNlbZglheHr+fb+0PY8bw5pM1v6uqC5AgNLRuynvHjvye3rWLUbEaDSPJg4Mpjk2dqpzfLxKJ5I5HCmISiaTlo5Qqk9nZwPLlwOLF9pucmUvHjsoRNaqqaJrdXLy8uERF8Q62cTJqFAny802CWX4+q3uVldEQGOCP7MBAU+olwGibigrrTbdtRVYW26MEMQxgHwaU03cAHiMlRYcBQHY2Sh1RXbe2D2BgIPCHP7C/ZGTQh8wYRVZQAJ+cHHQGUJCaSkHCz4/XirPFeXuh11M0//Of7esv5+tLYWD3bmDgQJsUwHAvLkZ/ACq93vr2NYeePZkC2qsXMGGC7bd/8iRvVtg65bpfP+Af/+D4bU70amIiH22UGu9h/I7p3795b5w0CfjiC1ZqVpJvZW0WLmTRnFuxZ5rnlClcDAYWGzlyhH6jsbEs0LN8OVMwjR5kUVHKTjuVSCQtGjm6SCSSlo9SBDFjip8SIllqpz84m8JC2wqERpHA1/d2YUsI4OmnTSKZUTRLTDR525SW0utt0iSgUycEX76M9gBcyssdLyDk5tJAXSlkZ/POvDG1xdkYDJwoTZrk7JbU5eGHkblqlXP27e5e14vMYADuuQc3JkzAlatXEa7RAJ9/zolmcDDT/tq04RIZqYw0alug0QD33eeY63XYMKZ4bdtGXzEr9+mXno5JAISjxcr27Xl9//CDfQSxhATemGiucNQUHTrwe2TDhsYFMSEYcbtzJ2+i2EgQ88vOZpRqc1PJZ89mJNSFC8oVxFxduTgDY5Vqo4+mXk/Psdxc/n3kCCMzXVw4jk2cqLybIxKJpMUjBTGJRGIxLgUFmAdAXVLi3IZUVfEHk7OjbJQkiCkFg4GeXY6IpgFMKZQBAYySq01lJatnXbvGlIyQECA9HZFnz2IRgO5btjB9ZOJETujS0/me0FAKRPaYvObmMmpDKVRVMQ1PKaSmcpKttFQ1tRoGpVRNU6uBwEAId3f8C8CsJ59E+ylT2JdTU7ns2cNzu2SJKfovL4/iSEv2xXKUoOTiwj64fz+jaawc4yPOnUM54PjvLLWa4vLKlfR0atPGtts/c4aim62vDbWaAt66dey39d1EqKwEPvyQnpWjRwPjxtls965lZfxeaK6o5ePDipM2iCr8VaDRMFXTiMHA6LqrV/m9bexX27YBGzeaPMgGDnRGayUSyR2CFMQkEonFqCsq0B2AqjpCy2lcvEjDdWPEhLMoK+MPd3d357ZDCGDVKpridu7s3LZotbzT6yhBrDHc3DhpGjwYeOqpmqfPenvjg/XrMXDYMPQZNsw0eYmL4wQPYOpmaCgnRF5evKPetat1E53KSkY9KGmyVLvAgRIwHn8liYYVFbaf8FvLpUvQubvjBIBZANMrAwNN179ez9TT2n3t++/pzxYWZooii4ig2ODsmwtKxHgsv/4aePBBy1O4dDqEXL6MStu1rHnMmsXP8P33jKa1FTodcPmy/fyy5syhILZhA/DYY3VfKyhg6mxyMvD//h/wm9/YdNdFrVtTZLOEO0WsOXKEN3CmTXPcPtVqjkkREXULKnh783fWli3sD66uGKLX41UArRMSgLvvljcmJRKJ2UhBTCKRtHxyc2ms7GzKyhht4WzPnrIy3k01llF3Jjod012CgpzdEgo9wcG3p/Oo1SgAcPPWSc/s2az+l5PDPpaTA6SkUKS5cIGRNoMGmYSy2o/mVMxKSeE2/f1t+jGtxtn9tzbFxRS6ne3JV5vYWFZmU1LqYVkZcrp1Q/KpU/W/rtHcHvk3dy6jhK5fZ188dozpqXo9xZ/RozmGhIc7TiBLTubYZWNBwyaoVBzHMjOBw4ctF0jOnIGmqgoJAEbYtIFm4ucHDB1KT7Qnn7TddhMTGT1nLwEoJIQFV3btqluEJDmZYphWC/ztbw0WcLEGbUSEKa3v14qrK8eIzp2db8kwejQXnY6FaeLjYVi/HvcA6LhqFX3IWrWiiPbYY0CXLsoaryUSiaKQgphEImn5KCViIzmZ6RrORqvlo9GM25kEBdEcVwmUllJ8Mndio1ZzEnZrek5lJc91QQHT0HJzmdJx7BhTPPz8gGefpWiyb19dsaz2XetTp+jzpASxEKConJ3NVFOlTB4MBlb5UxLp6ZwUFhQ4uyUm0tNR2tx+FBTEpV8//l9aChw8yCqWiYlMszxxgmOrMYKsRw/7RjRmZQGbNwMjRtwe4XHjBqPenElICH2kDhzgcfPza/42EhJg0GhwwvatM585c/gZduyw3Ta1WkYl27PAwYIFwNq1FHDbt2c/ffZZ3oB4/33nR0TfyfTvz+O9bBnw6qvObg1xcampTH3Mxwe/37ULF3r2ROfERI4lP/zAtFUvL45fRpP+Vq1kFKxEIqlBCmISiaTl07u3MqJsLl5k9TdnU1zMR1m2vC5GAcNYcdJS3NyA7t1vf16vp4l/aSn/12ppqGwUygCek7AwCk/Hj/M9ShGfLl0Ctm4FXn7Z2S0xkZnJCY9SKCtjP2rdWjmCmBBAWlrzBbFb8fKiT9LEify/qorj2fXr9CH75RcKUkZBLDWVKb9t2thu/PXyYsTH6dOMYjJy6RKFkDlzKMo5k5gYtm/nTranuZw5g5KQEOelTAIU8/r04XG1VVGP3FxWE7anZUDfvhRtExL4Pbd5M6MY//hH5dxYaCkcP86bO+YWClCpeHPi66+B/8/eece3Vd5t/5K87XjESTzixCs7hOxA9iAhgeyQAIFACw3haaEt7dMBvE+flr4db/t0PG1pKRRKoZTVEsJISAJkkpDl2HH2trx3POMhy9L7x8XpsRwPSZZ0bie/7+ejj2zZOrp1dJ8j3Zeu3/X76U99K3x6SCqAPpWVLJvt14/nrmXLOFcsFmYAfvopg/m1stucHAr+0sVSEG5Y5OgXBKH309KiRjB0fb0aIpRKDrFTp3itQgZUZSWvfbVwCghwDl2Oj2dJks3Gx9bKLsvKgCNHmFFmt/MD+9y5XOgnJCCyuBiRgP+zvEpLuThWZWFQV8e5rFJXMU3wHjhQzzczmitXgMbGngti7QkKAlJSeAE4HzVhF+AXAPv28eeoKF0YS0zsWDB2hZtu4vzLztYFsZIS4Lvf5fExfLjnz8dbhISwpPP99ykKuBNMb7cDFy4wk8poHnoI2LYNAZ643Dpi2TIKLL7EZKJA/uKLFHRuuYWPq8qXCr2JzEwer+50zoyLY2OaX/8ayW3PBYrwbQAtYWEUu8xmdtvdtQt45BGW0ra28hze1MQ72O3A44/z9qFDKRJPmcJrVd4HBUHwOXK0C4LQ+2lpMa5teFvS0z0rofE2RUX8gKfCB7qjRylWqiKIRUf7f64EBlIc07r7AcDatcwoGziQWShhYRQ29u9H6uHD+E8Ao7ds4d+Skymm2e0UrHy1+CstdR6j0RQX81o1QSwkpOcuQ29SVQUEB6PB1+WEJpPz3FuwgBk9+fm6i+yDD/hzcDAm2Wx4HED/c+forHMl5Forzzx7lr9brXR72O1shKHCOQ2gwyojg47KRx91vfyqsBAIC0Ol0Q1gADqrR49G68aN3tumr6MLbDa6bq9cYX7jihVqZR52R3Ex57DRjVTq64F33rm2OYErLF0K7NuHIR99BC/3KO0RsZcuIRHApTlzkKxleK5bR/H0xRf5XMPDeX5py49+BBw+zC843nkHePNNvWv5hAnA/ffzWJESS0G4blHkk4UgCEIP0ASx1lZjxxEcfG1wtREcOUL3hgpUVwMjRxo9ChIYqLtdjKapiftm9Wrg3nv12x0OnH3xRby1aRNmpKfrmUmffcYyLc2FlpBA8SoyknOup108HQ4KYio4cDSuXqXArEI5tMb773MBrtIifOhQ4KmnYH/zTf8/dkQEj2/tGF+7ls6TTZsw6JVXcC+A4f/6Fxeby5bReTF5ctfbHD6cHe0A4Oc/p8D285+r1VjBZGI3xRdeYA7XHXe4dr/SUmDcOFSqcB4KClLjiyRXqatjl8niYmDePGe3oo8IrquD16Qrh4MdEePigHvu8dZWPePwYb4HeerkfOoptH7yCf4L8Mvr0C02GwZcvIi/AJijZSICfO+4916KYTk5wG9/6yyqm810ompuVKuVX+Lt2QNs20aBrK6OX0qlpDC3LjWV770qvQcIgtAjRBATBMFj7KGhOAlgpdEfqlta6D5obDR2HK66IHxNdXXPBRJv4HAwqF2FsQDM/lGFigqWgLXveGkyoSUiAucAlI0erZe9LllCIaGkRL+cOMFQ/qIiigi33cYP6lqb+pgY1z+0V1ezOYVKDrEJE+jEUWnhceECg8NVQxX3QkQEMGsWcPo06pKSML+qCu8++CCWjhnD+aWVKnXFTTcB27cDzz0H7N7Ncqe2eWKqMGgQHSc7dvDc4sq5PzISmDIFdlXy53oLZ84wyH3ECJa4tbQAr7zCcP3UVJ897IALF3C3tzZmMvG8/OKLPFd7K7vNE44eZbyDp1+AxMTg9JIlqM/MRMqlS94dmyccPIighgZsAjCn/blw8GDgiSeAX/wC+OMfgW99q/PtBAfT9Tptmt65tLycorzFwvwxm43nuf/8T35BVVHBGAZVzsGCILiNCGKCIHiMrW9fbATwfyIijB1ISgoXGka6ohwOdQSxyEg13BT19XTtqeTwUYWqKpbNDBni2v+HhPBb6rZ5RV/kEeHECQb5t7SwjOvqVf0+kycDt9+ud8OMi+u47OzgQWD/fuCrX+35c/MmKolhRUUUeFVxPAI8vpqauEBTidOncbVfP7QAqElJAZYv7/r/q6qAv/+dIkFJCZ1Uf/4zsHIl8MADfhmyR3z961xk795Nx1h3jBjBy+uv+3xo1w27d1PMiImh0ycpie+3Nhvw2mvAf/+3zx464cQJ1Hhzg7Nnc16/+y5LbY3i1CnOwx6IOBUjRuBjAPNPnWIuZtv8TH/S2gocOYLKIUNQ0dn/LFrE98isLLpPXRXY+/ThJS2NorfNBhQUUATTysefeorvDcOG0QF7663GN/4QBMEtRBATBKH3M28er40UxFpa+MFMBUEsNlaND2SVlVy4qOAQa2wELl5keZkKr1F5OYXLnjSDMJv1BbaGw0EhUnORaSWXRUXA3/7G+/Tvr7vIBgygYHnxIoUyoxY17bFaWRqVlKROblRtLUO83Qmh9jUFBXxdH3vM6JHoOBzAwIHIDwxk6ZErmEycx0eOMAT7yhVup6yMAsKkSXQMGu1Gbk9kJEWOHTs4RlWOn+uF118H/vpXzo1f/EL/csVk4rlh40Y6xnzRKKWoCH3z81HnzW3GxbFT5qef0vlohKuovp6Op9tu6/GmdgCo79+f7k+jCAgAvvpVlL79dtf/t2oVvzjYto3zyJMvNgID6Uhs60p8+GGKbCdPAm+8QZE2LAxpDQ14BkDImTM8d6n05Y4gCE4o8ilTEAShl2O1UnwwusukJoio0GHy6FG2Of/ud40eCcWhjRvp6FBBEPPVN+omE1/7yEh+Y62RlMQFmOa+KSnWoGyvAAAgAElEQVRhcPmVK3SV5eVRnPvd74Dp01m2ZuQcKiigY+gb31AnwL6oiAKi0YHYbSkoYJmPkeVX7amqAhobUeeOSzUmhjlcd9zBUqSjR5lFdvo03TTvvEOHxuDBeufLtDQ1ypSmTuVYt24FvvSlG2/hm5XFTKoNG7z6eiRmZ1NkmD2b5ZLthfHVqzkv3n2X5zZv80WO3UEAXk38Wr4ceOYZbn/aNG9u2TUOH6a72AtlyDYAlpkzMaN9UL2/CQuD3RWx/PbbGQ+wcSO7rHoj83XGDL2MvqGB76cHDiDwzTfxAIC+r7zC9w5NSEtN5fn6RjtPCILCiCAmCELv54MPjC9j6tOHORVG09xMt5rRwhxAh09oqBriXGUlF2u+7sTnKuXlzoKVrwkMZObRoEH6bQ4HP6gfPcoFZ3AwnQs5ORShIiORcvky5gCILC6m6OvrLnIaxcV8LF84PzylqIgLKJUWMgUFLI9WQRjSyM8HADR4+tpFRFAEmT2bv1utdP9evcrMqIwMiglPPul8P6O6DQcEUMh7/XWKzJ4GlRtIOoChO3cygNxdR+alSzwmvDQHTTYb7gHQ/9IlvsazZnW8bc1t9fHHwFe+4v1jICsLTVFRKPPuVjmvY2P5ucUIQayyku89/nz/UQWTiU6xV19lN8lHH/VuZ/Dw8H+fuy7cfjvmTJqEAxs2ILZ/f76vbt1KMTIiAli/nvOgoYGfk1Q6hwvCDYYIYoIg9H5OnJBSFY36el6rIEI1NqrRdROgEyomRs/9MBKHg9lh6enGjkMrO4qOpgC2YQO7BNbWUpAqKoL54kXcAiD188/5jXr//iyvLCykEDNwoG/yq4qLWdKpivjkcPA5qxbuXljI3BqVyM8HBgxAq7fE0+Bg4Oab+fPUqXwtamudF5B2O/Cb3/AY1zrCxcf7zzk3bBgDyrdvZ1m2aqWd3VALILKoiHldCxa4fkeHg0KgJl56gZjCQgwBYJk6FWO7a4SydCnwf/8vkJ19bYOSnnLmDGp9kcVpNrNc8f33jWmAU1vLTK3eLsA0NzMn012CgoD77qNTzsdfHNYDsA4dCkycyBusVp4fc3P11/23v2WG54gRFHinTePng97++ghCL0IEMUEQejcOh3HOgLaUl/MbwMmTjf0gU/dF4okKDrGEBOcQeCOprFSn9M5kAhYvNnoUOpcv8/gZOZJzNyaGl1GjkFNSgl89/zwm33EHxmr7r6yMH+C1rq7R0UBiIn8eMIAf6nsqRBQXU1hQhepqtQRegGOqqXF2/alAfj5LG+u8mr6kYzJd26jDbuciPy+Pgu2hQ8C+fXSEjhiB5NpapAB8v/AVixaxM2ZWFrPm2tLUxHNQYqKSC90KAMGNjcBbb7kniOXlsUTWiw7tquRkPAfgJlfEqLlz+Vrn5npXECspAcrLcWX8eO9tsy133cVzaHa2/7sfL13q2+1fver7Jh8NDcCf/gQsXMj3G3eJiNCzZwGeF/zx5UtwMMWuts10br+dt586xc6pL7+sxx6MGgWsWKHelx6CcJ0hgpggCL0bm43XRgtieXm0w0+ZYuw4UlKYwaOCIFZTo05Zhr9LFHsTLS3AzJm6C6ejf4mI0BcM06fzW+zqapYRFhVRwNqyhflk/ftze4mJuossMZHlJK7Q1MQuXrNmeeHJeYmwMHY8VEl82ruXnUG//nWjR+LMl77E8/Lmzf57zMBACiKaKFJdDYwfT8Hh7Fnc/NlneB9A7P/+L29bsICuJm/mCfbrB3z5y3Sj1tQ4i3aXLgH/+hfwne+o4d7tgKLx4zH02DGWp7Zt1NEVBw/yvOBN56TJ5HpnR7OZ55q9e1m22pMmJW05cQIICkKFr94zBg6kMFVe7pvtd0V8vO+2XVoKvPQSS299+YXGrl08x7japbkrdu/m+WLFCmMcybfeqh8/tbUUeI8eBT78kKJ+RgbPHf6KKxCEGxD1vqYSBKH34HDA9MW1YbS08NpoQayhgYsro0u8zGZmYhjtQnA4jCkH6QibjXktlZVGj4ScP88FlyqUlHAx784xZDLRfXPTTfyG+0tfYibLX/8KfPOb7HLa1MQP9K+9BvzP/+gdB202utI0h1l7jh6l0KNC8wON0FAKLCqN6dQpCt8qhfwDdF+0d3D5m5gYZgU98wzw1luoSUzEaQAVQ4dy0b59O+ent0lIYA7fJ5843374MI8vRcUwACgcN46i9TvvuH6n7Gw+555k/ZWWen5fgMdla6t3z6nNzcDy5Wjy5fvXqlVsDHA9ERdHV/j77/MzkS/Iy6NINHeud77469cPOHaMoqrRREXx/fSpp/ge+NxzUj4pCH5AHGKCIHhMcEkJfgggoMbl73O9T3Mzy2WMFsQaG9VYLNfUUKzwZlCsJ1y9SuHD6IUxwA/QNhu/lVeBzEwKuV04svxKaSkXtT3FbL62HMThoGOmqEgvoywpYQdJgKKa5iLr35/uhTNn+Le0tJ6P6XrmwgXvOCSud6qrEdLQgPcB2Jcvx4R16yiGdZU/VFREt8aQIe69twQHc0G7aRPL51NTefvHHys/n+3BwXRl7t1LMcMVR+fZsxSkPHpAO4XJw4eBxx7zXNiNjGQmlDfL8+PiKPLl5Hhvm+3xJP9KdUwmOq1++EPgxz8GfvlL727fbqfIHRZ2bVmyp9x8M7+827GDQronJZi+oq6O43G30YUgCG4hR5ggCB7T1NSEaAAVH3+MMyUlcAQFwREYyOsvfrYHB8PuwzyJkJwcJG/ZgsK0NJy3WAAA58+fR2Zmps8esyOiT55EYFUVKts87vnz5/0+nphPP4W5oQFXli93ut3fYwkqLUX/4mKU5+XB1sE3xf4cT0RmJhIbG5Hb0ICWDh7L3/tmQGYmmpOTUdvJY/l1PA4H4jMzUT9hAq76et8UF/PicCBg1iwEV1QgqLwcgadOIWjPHgSXlCA0JwcB5eWA2Yyyn/wEDaNHo2nIkH8vCIw4pmC3I3brVtRPmABrG1HVkLFotLYiISgI9cOGof6LxzZ0PF8Qs2MHbH37on7iRCXGAwBh587BZjIhA8AIF8cS88kniN2yBSarFdZBg9CUno6GUaNwdcSI7svyHA70a22F6YUXULF6Ncx1dUi/cAEVY8eiWqHXSqPtWE6OH4+Ud95B+bPPovr227u8X2BpKdJyc1E6a1an57LOMF+9iphduxBcVITaGTPQkJ//7+6kHu+bU6fcGkOXBAYCgYFKvU7aOLRro8fT1ViiBw1C3JtvouzXv0bNbbd57TGjd+5EXHY2ijdsQH12tsvj6ZbwcERHRyPs+edxZfFiWL2QFXnmiy92GjtzQrtCUBBjMARB8Ckmh8PIWidBEHozb/7tb3j/K1/BcHRef10A4K/dbGclgCAALQCsba61n3MBdJa0MR7A/wJ4AsBxt0bvXe4FEADgDQPHAABfBlAH4F2DxxECYBD42tkMHsstABYC+BkAo9/wAgD8F4DNAIxfXgEx4LHzDwCXDByHCUAKgMkAfgDADqASPH9cAlD6xc+FX1z8Wfw6AMBjAF4B57MKJAJ4FDy3Fhg8Fg0TgCcB7PviogrzwHn1KzfuYwYwEcAUAGMApAMIBc9lFvD5bUbn83AggA0AtgCIBfA0gIegzvzpiufB4++xbv5vHICvAHgGQJUb2x8I4H/Ac/EzMPa8I/iOXwG4CcAjAIq8sL1w8PNVDoBve2F77TEDWAdgDjj2c17a7j/+8Q+sW7fOS1sTBMEXiCAmCILHVFRUYPv27UhNTUVYSAhMLS0w2WxO1wgIQEtcXJfbid69GwENDbxfB9uonT4dDWPGdHjfYIsFSX/4A5pSUlAVHIzsc+cwetIkRMXFwR4SAntwMGx9+6Jx1Chf7IJ/M+iXv4Stb1+UPProv28rLi7Gli1bsGTJEiRqXfh8zIC33kJTcjLqpk93ut2IsXSFP8cTtW8fgouKUHHPPYaPJbCiAgM2bkTFihVo6aRM0a+vlcMBc0MDy6U6KA3z97wxNTZiyBNPoHLlSlQtWIDg8nIEVlcjqLQUweXlaMzPx4ULFxDyxBOIHT0a5vp6BFVWoiUuDnYflSyHnT2L6L17UfrQQ3C0CTY28pgKP3kSUQcOoOThh//tnjP6GA+srMSAd95B5fLlsCYmGj4ejdgPPsCVhga8VF/v+VhsNoRevIjwM2cQfvEiYDKhfM0aNGslkR0QvXs3Qi0WoKUFEadP4/JvfvPvLCBV9k1HYwk/dQrRn32G8nvuga2LbLDovXsRVFLS6Xm1I0LPnsXA558HzGYUPfYYmjoIXld53xhNT8YTYrEAAQFoHjzYL2Mx19Qg9Uc/QsuAAch/+uke52DF/f3viDpwAHk/+EGHDi5vvFbmujok/+xnMLW0IP/pp2HrQbfkxsZGWCwWLFq0CP172nVZEASfIoKYIAhqo52iugqrz8sDCgqYC9PUxDyvttcDBrDrUVe88AKDecPCWBLT/jo9veuMk7VrGST+wx+6/xy9yc9/zrDZdoKY3/FXG3NXeO01ij1r1xo9EnZl27SJ+Sre6oh2PZGRAXzve8D//m/H2USNjcx3SkvjAiszkw0TAOaRJSWxE2RUFP/HGyLZli2AxQI8/njPt+Ut3n2XTSI2bDB6JDoZGcBHHwFPP218pqNGayvwi18A8+Z595zocPDS2SK/shI4eZLZYQcPAhMnAr9yx6NmIK2twM6d7JjcVah8UxNz1rr5wuvffPQRj+vERDbZ8EZuYXtqaphfqUpepEq89BJfzzVr/PeYO3YAP/kJu6suW+b5dq5c4ZwZOhR45BHvja8j8vLYGGbKFL4XSXdHQbjukQwxQRDUxhVRJTm554G6I0fyg7QmpFVWOgtrS5d2LYjZbMClS8DGjQz57dPn2uuQEN+KRFYrLyp0MnvrLXaba5dlZghXrlCsVIH9+xlErYoYppJwCTA0ec4cdq/siLAw5yD5CRMoVhcUAIWFvD57lp0qa2ooit11F0WypCR2FHP3+RYWqrfALigAhg0zehTO5OdT7FBFDAPYwKGlxbuB6wDnUFfz6Nw54PnngePHGcweGgq89x5w663cRyoTEMDGAN0RGuraeczhoCj43nvAmDHAz37mWmC/J2zZwvdxlYRiV9i2jeLqwoW+2X59PbB1q//3y/z5QFkZj4Pp03n+9YTt29lw5ctf9u74OiI5GfjjH9n45d13gXvukS6PgnCdI4KYIAgCwEV4Z7hipP3DHyh21NbSwVJXR3GqLd/7HkWizqir4yIrPNyzD2BFRRQDWlvdv6+3uXKFjh2jsdnYQcrTD+LeJjdXrQXxH/8ITJpkvKNQo6jIPVHFZKLrISaGi22A8//ECSA7myH+OTnAkSP8W2gohbFbbgFGjOh++01NwOefA6plwNx/P4ULldi0SZ15pGE2s4ucv4+56dMpwu7fDxw7xo6gv/sd/zZgADBqFDB2LDB1Kv/veqW1lUJMRgaFhdtu8624MHEiv4wpKfHMgdbQQEeQv7v62e3A5s3AzJm+EQsPHeKXfEZ0Ol29mg78TZuA9evd/0Li4kUKzHff7T+xfdAgOunefJMuzzvu8M/jCoJgCCKICYIgdIcrH+AGDuQHtrZYrRS56ut53d0H3U8+4TepJhOFs/YOs6SkrhfxBQVcCPgoS8llHA6KUF2V2/gLk4lihqtlPb6mqUkdZ09TExdJffoYPRKd4uKeCwQBASy3bFty2dREp5d20URjmw34858pmGjllgkJ+sLr5EmWS6owl9uiWiZNSQlLje66y+iROJOYyAW5EWjO5fvu4+9FRcDhwyxHfPllOl4iIylSvPSSegKnN2hqonN6+XKKVb5m+HCez/bs6T4moSN27eI8/trXvD+2rhgxgiWBmzdTOPQ2R49yvxjx3hMczPNCQ4NnbuSEBGDBAv+7vIcPBxYvpuswJobitSAI1yUiiAmCIPiK4GA6k1x1J82ezVIxTUTThLTSUn5LWlfXtSBWWgpUVVEYM5v5IS462v8ZGA0NLFOKjvbv43ZEQABzR1TAZqPoMn++0SMhpaW8jo83dhwaLS1AeTmzW7xNaChLLduWW2qPOXy4Xmpps/HYCQjg30pLWTLdWQmnQI4e5fXkycaOQ2UGDgRWruQcO36cQuyFCzzPX49iGMAvdh5/3H+OK7OZ0QQvvwwsWeK+2P/553Tu+ZshQ3ge2rrVN4LYqVP87GBU6V8HIfgu06cPnXNGMGUKP1Pt3g2MG2f8l42CIPgEEcQEQRBUoX//njk/5s6lo+Wzz5xvj4jQy8pGjmQJkS+prua1aq4ao6mooHuuqyw6f1JSwoW4Km6j0lKWDvkzryssDFi0iD+3tjLvpqAAOHAA2LePpUY2G11Go0cDK1YAgwdzgWdU2PKmTXzNZs0y5vE7wmqlGKZS+V99PR2HaWn+L4HriuxsOlZHjeKlO6qrGcg/ciQzyIYO7V2ZRv7e90uXMstz82b3GqmUlbHE1R9Oto64807g978HzpxxbV64Sl0d8/1U+SKmt3H77RTG/CWG2e18L4yP713HuSD0YhT6hCAIgiD0iH79gB/9iB+o6uq4kKquZri49nN9fdfbaG7mgk0T0GJi3F/4X7jAD+BRUZ4/F2+xfTtDllUo5Sov57UqglhpKceiijslKQn4+teNy54LCGCJXWIiF0Df/CYdPZGRzFmrqOCCubmZpT/x8RTHpk71X0adw8E8HVUy8TSuXFGvpOjCBXYgffJJtQSxiAhdhHWFqiqeTw8cAP76VzpmRoygk2nKFAplvlo422x0Tg4bRucVAFy+zPeIZcuu3a/nz/OYMNJJk5bGfbJtm3uC2MGDvL71Vt+MqzvuvBN48UUGuf/Xf3lvu4cP8zOBUc+rt2My6e9JtbXcl778sq+4mPNg/XoeS4Ig+ByFPiEIgiAIXsFsZrlidDSQkuLefaurKSK1DeYPD9fFsehoOlO6ykM7c4YuGxXKC4qL1cnIKi+nSKhKh8lt29QpJwW48FDFrQZw8VNTwwwoLY/I4eDrmJ/POZ6TQ7EMoEtq0ya6pAYP9k3HxYoK5jKp5MSy2ZiPpTU1UIW8PIqWqhxvAMvJm5rcKwtOS2PHu9paNoc4epQlcK++CvztbzynvPyyb46dq1fptrrzTjaiACh6WSzOYpjDQUfljh3MezKqxE1j8WLgt7/lfnK13Dkri0KzUcdWaCgwYwZF96Ym783bggJ+2aBKdiVAkbehofNSyvx84PRpNmFQqWvtxo0c9/r1vjuvWCz8ElK1zsaCcB0jgpggCIKgEx8P/OAHdJJprrK2l/PnmXXWFefPc7FUVUURzUgHUmWl+6Kgr6ioUMcdZrPxdWobPC84k5/PRcmECfptJhPL3eLidCFM4+pVLmT37KE4FhDAQGizmQvtiRMZst4TCgs5hp5k8nib4mIK6Kq5GfLyrs2MM5q8PF57ck6KimLZm1b6Vl9PgezCBd+5KrUcyGefpQBnNlMUaJtlabUCr73G42XOHIo6RnPHHRzn8eOuC2JnztBZZiSrV7O5zq5dFCG9QUsLsGqVWuV327axZP9rX7tWWLLbmaXmcKjjXtZYtowuzbffBh54wDfjs1j4PqHacxeE6xgRxARBEARnTCaWiUVGerbIHTiQQtSzz/JDeN++enOBfv3oZEhM1EtwfIXW5TM21reP4ypr1lAwUYELFyiKGb0A1GhpAZ57jkHYqrjWqqroenJ1PH37Al/+sp4BU1BAkWDLFnbaA7jITU/ncTVoEI8DdxY+BQUUVX197LhDfj5dHKo0ZwAoTlZWMldRJXJzdfduT+nTB5g3j5eusNuBn/yEr8+UKQwHd6eEdOpUCjSZmTwWLl7U9+uVK8D3v8/n9bOf6S4yowkOpmCRmcnzXHfPt6yMAs2aNf4ZX2eMHMlQ/bIy721z6lR1XNIad97JphLvvXdtWeuxY3Scrl+vlogH8LPL2rV0bH7wAUvqPemc2RmtrTyWuvvSURAEryKCmCAIguBdvvMdClGVlc6Xc+foMrPbgQcf9L1748oVXquSt2Q2d11q6k+amthcwdcNFlxF65CqQpmtRmEhxV13F2Vms3MW2V13cbF9/DgXT/n5wKef6gv1efN0V43V2nVm35Yt6nW8TE/nvFbJ0ZCdzXONiq41fztWGxspsOzbB7z1FsXU9HQe+5Mn0yXa1ZybP5/ixbvv0gHmcFBkuXSJ+WwNDcAzz6gjhmlMnMjyw9Onu+8cmZHBaxVythYtovvP4fCO2KJaKTNA5/jMmcCPf0yxbulS3l5VBfzhD8DCheoduxopKRTCNm5kHuDChd7bdnEx3wNSU723TUEQukUEMUEQBMG7tM0wS093/ltrKz/0dhe4n5EBnDjh7Czr148uHFfdDWfOUHwwKqS9LTYbr1UJ966sZDaRCvsG4ELAbFbLZVRY2P1C2lUSEnjRaG2lSJafT+FM44UXKBhrOWSDB+vdxurrGXBudD5Te9o/NxXYtYulR6p1ul2yxP/CYUQE8Kc/caGdlaWfW997D/jnPym83Hcfu6imprIct+0YAwMpin3wAZ2AkZEs//7xjymEPvuseqWpAN8vRo9mEwxXWLxYDRFGxX3pC2bMoLj/3HMUZhMSOJeKitRzdrbn5pvp1v3Vr/h5RsuY7Clafljb9wRBEHyOIp/MBUEQhBuCgADXwp8jIymalZQwGFlb1JhMXOQOHcrFZVecPEmhJSKi5+PuKWfOMHD9ySfVKHcrKVFLxCguZi6XKoJhXR1DzH2V1RUQwG233b7DwRBpLbD/9GkKZ7W1vAQF6UKm0DXnzqkVIq5hZFB2cDAdUJoLqqWF5Wk//SnD+VeuBHbupPvrjjuc77t6Nc9fn35KwWbzZp6Dn3lGnZL0jrjnHtf+z2xmKangP8xmdtN8+GHOwf/4D2D3buDuu3tHoPyiRXRdvvACv8DwRnae5IcJgiEo8slTEARBENowYoQe3Oxw6JlA2sWV0rqsLDoYmpuNF6HKy1kaYvQ4NEpL1QrULypSaxFks9EF4M/wepOJjgmtJLKlhULh4cPAZ59RrCgvB556ivvqrruYOTR4MEVib2bZuMrly8y8mTvXmMfvCKuV5ZJa+LzQMUFBLOmNiKAQ++STFMo7OkdlZ/P8dfQonVd33cWA8etl4d5eABT8Q1wc8PWvA7/4BfDNb3JurV9v9Khcw2wGfvQjOiV37waGD+9Z0xyHg26ztk1cBEHwCyKICYIgCGpjMnEx1qeP6/k7Vis/sIaEAP/v/1EwGDBA7xAYF0enmr9aupeVqdNh8upVOqBUcYg1NQEffwx85StGj0Snb1+6YowkKIhugeRkhn0//jhL1VavpmuyrIwuMoCOyuRk5jj5M6PqzBkgJ6f7YHd/UlTE/CjVRI5PPqGQqVIGXHU1Rddly3i+7EiUdjhYrhsXx/LdpiY6xCwWCmqTJ6sj9Au9j/R05n0WFAAPPQQcOKCX7qriGO6M4GDghz8EXn4ZeP114JFHPG9gYDJRHLTbvTtGQRC6RfEzjSAIgiB4QHAwg6ArKigclJfz+tQpBi0D/AD6H//hH2GovFytEq65c1nmoQInT3JBpIpApyJ2OwWI225zLgNraOBCMi+Pl4YG/W+ffsoFZXIyX+uugtM9JT9fjdyltuTlAaGhFHBUobWVTj+VhEOA58SpUxmW3xkmE8vY1qyhs3T/fjpitm1jDllgIMt4x4wBpk+nGHm9OMd6M4WFdEirkhPZnpwc4C9/AQ4e5Dj79aPL6sABZgAGBFCsHTWKouukSb45h/WUkBDg/vuBl14C3niDop6n4zSZ5NgRBAMQQUwQBEG4PgkK0rv9taW5mQJVeXn3HSgtFooMcXHMyvGkDbzNRsFHlQV6RIRaocWnT3O/qtINzeGg8yk1VZ2uoFeu0GHYvpNfeDgXkcOHX3uf6mp2Aty9m/s3IYGvfZ8+dPb0tES1uZkCiWrdBfPyKNKpUsIJ0LXW0uL/DpPdYbHQKetKiLfJxDm0ejUvra0M5z98mNdbtzKwf+FCdhFWiSNHWNq7Zo3RI3GP2loe+550Hdy6VQ2na3tqaoDnnwe2b+f564EHeLz+/Od0daak8Lxy7hzwr3/RjbhxIzPr5szhvkhN5flLFfEoOhpYt45OsXff5ZcWnnxWEATBEEQQEwRBEG4sQkLomHHFIZWVxfwcgE6I/v0pbGnll4mJ3XfMPHuW4dWqLUxUISCAgcShoUaPhFRUsPvel750bZdUoygq4iJw0iTX77NmDcW9igrdQfbpp3RJAsC0aRSztLLM/v3dE5EKCrh9lRxidjtda6p14szLo0CvmgsyN5fzyhPxMCCAOYRaFqHNxjnRlUhhsxnjggkOphN1/nx1HVMdsWcPcP488K1vubfPamuBvXvVKkNvaODzychgyf499/AcGx4OHDqk/4/ZrH+RNXcu58zx4/wCq7KSQfY7dvA1/drX1Hk9ExLopDx1iudFQRB6DSKICYIgCEJnrFpFx0NZmfPl/Hlm6UycCCxf3vU2zp1jWK4qJYq7d+vfsqtAfT1LYlShsJDXKoX8FxTQzeiuY81kong7YADFtFWrKK4dOUKHT3k5F5sOBxtVTJnCskxX2LeP89qVrrH+or5ez1NTidxcCoeqOFoAOvyKi70X4h0Y2P055eRJis0VFWxaMWUKz6G+LoUbPZqOqcxM52YLDodaTsL2jBoFPPcc99XCha7f7/BhirD+bArSHXY7nbdz5rDTadvcOa1JTmPjtfcLDOQcabud4mI+v5gY/fZjxzi/UlNZwpuY6H+X1rBhakUjCILgEiKICYIgCEJXRETwA3Zamn6bw8FvubsLwK2rY8mH3c5v7cPCjA2gbm1lx8KICDUEMZuNAmPbBY/RFBZS5FHFsQZ4N6tr4EBgxQr99+ZmPuf2C8wdOyjkaA6ywYOdu7seOECBRyVBISqKwdQqYbcDW7Z0L5z7m5ISjlUnYJUAACAASURBVM2fZZzJyXQmbtuml8IFBdGJOWYMhZJJk7wvHGoNKl57DZg1Sxfgtm+nqHvffd59PG+Rnk4H1ObN7gliGRkUhocM8d3Y3KVPH+CJJzp+bWNieH5xRRg1myn0tRf7tPP13r10woaE8P138GA6YceN819Iv8PB99m4OHYCFgRBaUQQEwRBEAR3MZm6L5UE2NFx5EgKCS+/zNtiY1leoV0SE7lY8IewUF5OUUyV0q2yMo7HlQwjf1FYqJazwmplpo475ZLuEBLChXf78tCEBOYXZWfTDQZQSK2tpePm1CmWCAldc/o055RKcxygEPb97zuLnL4mNpYdLZct00vhjhzh9ebNDFNPTGQZ5siR3s2Kuvlmhrh//DGwdClvy87uOH9PFcxmYNEi4NVX6ex01bV6+jT3nxE5Vs3NjBq45ZZrH7+z1zEmhuJdT+biyJG8tLZyX+XkAG+/zfn19ts8py9ZorujExJ8u39KSymKPfSQWu8ngiBcgwhigiAIguArEhKAJ5/kh/SKCroytMvnn7PsEmCXKn8szEpKeK1KwH9RERcl8fFGj4Q0NTHzTZWAf4BzZ9YsZ4eiP7jpJl4cDgb05+XReXLkCMvPCgq40MzNBWbPpvNnwADjHGMOh14yqRJHj3KOq1QWrGFk0witFE5zh9psFKg2bNCz73bsAL7zHf01dTh48UTIuPlmusS2bKEgVlHBeezv48pdVqwA/vEPuum+8Y3u/7+2lsemO44yb3D1Kl2jmZkUxVzN6QTo4APYeKKnBATQFTZ4MM9LVisFuoICjnHXLj5OaChw772+ef1NJmDlSuDvf2fnyUce6TzrzG7nOV7bB4Ig+B0RxARBEATB1wQEUPSJj2fpBsCFXU0NRaruFg7l5VxkxMX1LG+ntJQuDSPLNtuSkMBMH1UWAydOcEH3wANGj0QnLAyYN8+4xzeZuJjr25dzd/165hq98AIX3Zcv03WTlcWxJifTfZSe7l8nYk0N8Lvf8bUbOtR/j9sdDQ3MylKlY6mqBAbSkRgVBXz723QMlZU5C5wlJcArr3COtXX6uOogW7QIeOklirgnT/K2W2/18hPxMjExFFN37QIef7x7MfDQIYos/npeTU0U7N57j07nBx6gEOWKg1rDm4JYe4KDuS+0/WGz8YsYrcOqRmEhyy3T0jiv4uN7Ju4HBQFr1wJ//Svw+us8b3bkgMvPp3D2ta+plccoCDcQIogJgiAIghGYTFzstM1t6oxDh+jOMZkYrt625DIhgQsRV8jK4v1VwR0XgT84fpyLa5UcYipisdBx86Mf8XerlQvK3Fxedu2i+LpqFf9eUUH3VlKS78TPvDxeq9QMweFgUHjbIHcVyM2lO+qBB1w/d/iD48f17Cuz+VpBNSKCHUQtFjYHaWmhsBUfz/moZUV1JpCtWEHxYfNmZofFxvo3Q81Tli8Hnn6aXRq7E8cvXuTz8nV+mNUKvPUWnWu1tXSIbtjgmeMqIAD47//2T9OJwEA9F7EtNhu/dPr0U/4cFsbjd8AAimmjR7vvTIyIANatA158EfjFL/gats+mtFh4ToyN7dHTEgTBc0QQEwRBEATVueMOZki1Lbm8cIEf4AFg7Fjgrru63obdzm/AFy3y/Xh7K0VFXCD7uuudqzgcdKwNHQpERxs9Gp3qas45jeBg58YTra363ATYAW7fPi54Bw7kPh44kBdXBGFXyMvj4lUlJ1Z1NcUC1UQXi4Vji4gweiTOREfTVdOZ8BAVxfLhWbM4xwoKgA8/pLNz40bg3XeBuXN191j7rKg+fYCHH6Z4e+oUMGKEf55XT9EEmfPnuxfEAgNZgu+rfCy7naWtf/87j+vJk4FHH+1Zd0WTyfgOrCkpzPuy2TivLBZg0ybgk0/YjKFfP5ZYavPK1fLwfv3opP3e94Af/pDCWNvXxmLhYxuR9yYIAgARxARBEARBfQIDGTbdNpjb4aDLoaSk+46Ira10h9XXq9MWvrKS7o5bb1Wno2NMDLBmjdGj0Kmu5oL//vvVEcTq6ihkLVnS+f8EBDgLU/Pn08GTm0vhKjsbeP99vv6JiSwpXLiQC0NPHUve7MTpLTTXmmrj0hbhKnUItVopSC9e7Nr/BwTwOWhdRZubmf9XU8Pnt3MnxY32JbSzZgF/+ANLfVeu9PrT8AlmM/Dgg8DBgzyXdyYeORwsVfZViLvVysYEFRU8Zh95hDmD1xOBgbroNXcuS54zMjhf6uvZmbS1lWLywoV6BEJXTJzIefrssxTZVq/m7TYbz1uqOUgF4QZDBDFBEARB6I2YTCyzcKXUorSUncocDgpjLS1cNA0cyFwyf7Wjb4tW9jR9uv8fuyMaGynSzZlj9Eh0Cgp4rVJZaX4+r9uXHHWFyaRn6N1yC+dhfj4bSxw/TuHoX//i/2plbKmpri02AYp0hYUs21KJ3FweXyq51jRnlZG5dB2Rn0/3kaduupAQfb7Mnk2xoX13T6sVePNNOptKSykeORxqCYOdMXkyj52unFQmk2/FleBgYMIE7jfVuqb6ivBwzqfZs/l7SwvnqsXi/N7b1MQvL1JT6ZTt1895Xq1axW0dOMBy1vHjOT9tNvUbOwjCdY4IYoIgCIJwvRMXBzz1FN1khYV0YmRncwGqBf4PHMi29f4KJC8qYtmJKoH6RUW89pW7whPy87mwUklQycujk64n3RxNJj3HZ+1a3lZXx21rOWQlJbrAUVdH909KSselSgcPsiRz/XrPx+QLhg1Tr1yysJCLetXGZbHQdeOtYPHAwGufY2srhSWbjee7LVuAP/+Zc3nsWM+zovyBv8+TnQmFM2b45vFqa7nfVcq064igIAqC6enOt9fX0524dSvfV/v04XyOiKBQP2QIHWVWK/DBByz/zctjVpkqXZYF4QZFBDFBEARBuN4JDKTQk5TELDKAi+LSUgpBRUX8cB4R4T9BrLhYrQD0wkKWbqoUblxQoJY7DKBI5447zFUiI1l+pZVgtbbqfysu1heabTtZhoSwFPPYMS5AVRN5Ro0yegTXsnkzxXB/dgB1hZoaumt86dYKC2MZ3Ny5elbURx+xJO6NN5gVFR7ObLH58+nIcjUr6nrB4WB54K5dFHB8cax3xFtv8f1g6VL/PJ636d+fJaRWK99LLRaWVx49Crz8MkveH3hAF/Xfeks/Z91I80sQFEQEMUEQBEG4EQkKurbLo8PR9X0qK4EjR/RA9PZlIa7S2koxztWSOH9QW0vBUJXFSUMDF1Pr1hk9Eh2HA+jb1z+iadvSsOHD6XBs28ly61bgs884j/PzKfB8/jkdQKpk0qnIiRPcV0aHmLfnrrsoePoLLSvqscf4e0MDz20ZGcy227WLHQfDw3me0lxBKnXp9Tb79/M5Oxx8X/DnHAkK4pc0vZ3gYJ4fhw4FFizg+8rhw8Dp08yEPH2aollGBrPYnn3W6BELwg2PCGKCIAiCIJDuxKDaWnY6O3iQv4eEMEtGE8gGDqRg0t12Ll7USyZVYelS/y7IuyMrCzh3zntdGL2ByWRc04H2nSytVjqdPv8c+O1vubj8wQ8oYNx9N50XKSkMtDeia+jZs3zc9qVVRmKz0f2zbJnRI+kYI0sVw8OZH6hlCFqtwI9/TIEoLY0C7KhRnFsAUFbG8Xr6pYBKHDkCvPgiz+0pKcD/+T8Uof35vK4XQaw9UVEUxtqKY3v28PlGRUl+mCAogAhigiAIgiC4Rloa8M1vMoC+uFgvtzx9msJERATw3e92v52MDAoGqmWnqJQddPw4BZXRo40eiZoEB7PTnRZK/atfUaA9d47CZkYGsHcvX9OkJOChh/zreNmzh9l9KgliJSUUOlRqHAGoGWwfHMxz3NSpwIYNFMiamvS/79kDnDrFUl+tK2FKCkuujTiP1NayBM+dxz59GvjTn/g8EhJ47l682JjxWyzsFHrPPf5/bF/S1MTSyZISXgID2XXyppv4nFUrXRaEGxARxARBEARBcI+wsGuDha9eZUlIdwvb3FyKPXFxFNBUoKWFCxWVFuVlZRQvjOgA2hkVFXQAqlRul5Wld78LDGQ4OkCRpaKC862qSh+z1cqOq4MHU8RITvZ+04LmZi5+J0/27nZ7Sl4eRWjVss1ee41O09tvN3okOs3NLNHVBJrgYGen4fLlnHM5ORQ2Tp7kPMvJYQbZzJm8uOKYdZfjxznvv/QlfdtvvcVz6sqV3d+/rIwloVlZQHk58I1vACtWGHuuqa0Frlwx7vG9icPB43/bNuCf/+QXSDNnsiz4ppso3L/yCoV8ld5zBOEGRaFPWYIgCIIg9Fq0jlpd0drKxe+pU3QhvP22nmOWmGhMaRsA7N4NXLoEfPWrxjx+exwO7suZM40eiY7DAbz0EjB9OjB7ttGj0QkJARYtunYxbzKxJLd9WW5zMwOwz57VS3/j4hjqPno0Ow321LWRn8/9pVrIf24uhUCVRFabjULd8OFGj8SZoiK6w+64o+O/h4ToWVEA59WxY8DOnTy/bd4MZGYyTF1zkKWmUiDrKaGhLHMcNw4YP55zVxPIusPhADZtonNp7Vo2pVBB4A4JoVjdm2lo0MXK0lI+p3nzKDaOGOH8v/Pnq+VIFoQbGIXeEQVBEARBuK4xm+lGWL2a7ouCApYeWa38W1wcxbGkJGDMGOas+IOCArW6S9bUAPX1FC9Uobyci2iVxuRwcFzTprl+n8hIYNUq/lxdTZHo4kUKGdu38/ZlyyjQaDlk0dHujUvr2KpSALvDwXHdeqvRI3GmoICiWGqq0SNxxmKhc9DVTrghIdy32v5tauL+1hxkx49zPnz96/x7fT2ftycZgUOGcL/9858UxA4dAs6c4fmzO0wm4N57eRyoIIRp9HZB7NAh4OOP+bPWpXTo0M5FL5XOo4JwgyOCmCAIgiAI/sFkorgQHa2XbdntFDUKCnjJy+M37GPG+GdMdjvdIHPn+ufxXCE/n9dJScaOoy15eXoelyqUlVF4SE727P4xMbyMG0eRtqiIrh6TiULZ0aP8v759gQcfdF003b2bjkeVyqHKyli6pZprzWJhCbZqeYK5udxXnr6GoaEUVTXnW2MjywI1MjMpwsbEsHROc5C5Ir4GBNB5tHkzt3n0KO/XPqC9pobHbGSk8+0qNerQCA7uXYJYRQWF9KlT+XtSEkt+x471fgm2IAg+RQQxQRAEQRCMw2zmYjg+Hpg0ibdZrd27w86f58IjIaFnJWDl5cwQU0no0RxrqmSsARTpEhKMK2vtiLw8igODBnlne1qnVI2rV/kYubnsCKfx6qsMME9JoYjRttNgUxMbTKgWDt6vHxsLqDTPAeDCBQqaKomHNhuPwQULvLfNsDBeNKZMoaPLYqGLLCuL56GzZ4GRI+k0mzvXed61ZfVq4L33eDl1iq4kzY1UWwvs38/GEpMmMShfdW6+mSWHKtPczH2dlcXzYVgYv7jp00cv/RcEodchgpggCIIgCGrhiuiybRtDmAMCKNRopZaDBrkXZJ2fz/91tTTKHwQEqJepdPy4LliqQm4unVi+Kq2NiKCTsW0IvcPBuWKxcHFst/P/mpo4/zSni2qB+oGB6pUlNjUxR/CBB4weiTPV1RQ7fLm/wsIofI0cyd8bGtj18aOPeH35Ml1ksbEch+Yi09xegwYx827zZor6d95J19JLL1GQnTqV3URVK5HtjJgYlk2qht3O/XnkCF8jm40lq2vW8LVTKY9PEASPkKNYEARBEITex+OPM7hYK7W8eJE5LgCdYx0FGXfE++9TFFPJ+bRwodEjcKakhF3ptA6OqnDnnXRx+ROTSe+G2NzMuWexMM9p9246yq5eBV5+maVsc+Z0nSV0I5OZSYFBtXnVvz/wn//p38cMD6eIqgmpdXU8L2kOssxMXg8dytywQYPY3OJnP+OcPHGCzkWATSY2bOjcXaYiQUF0yKlCTQ2bJPzpTyw3jo8HHnuM+97dTEFBEJRGBDFBEARBEHofAQF6idstt/C2xkY9rN/VQPNLl67N3hGcOXKE11OmGDuO9rjS2dSXhITQLTJkCEO0GxqAdeso1Grup1On6GDUyitTU7m49qdAduUKm1csWHBtnpSRHD3KfaiaIAYYX8IZGUkH2OjR/L26GliyhPurb182gAgMpFhdV8fMsiVLKNr072/s2D0hNpZOTLvdOPHYZmPJalYWHXqBgWzYMWUKu+uKqC0I1yUiiAmCIAiCcH0QFkYHxdCh3f/v558D2dnszjZuHBeVKogF2uLWXx02XeHMGZY0SUZO1wQHUxS77z52U21qAoqL6RqzWIAdO7joXrNGbxrR0MDX25eL7ZwcOohUy5IKCwOWLlWr7MxuZ1msSh0YAc6foCDgy18GZsyga6mkhNlbW7dSaLXb6VTUhNfkZOZb9QbS03kxiro6usG0Jh3LlgE33aRmGacgCF5FoXcgQRAEQRAEPxEby8uqVUBlJfCb31D0GTxYv/jbyQMwQ6ipiQtfVYiNBe691+hROLNvH1+b6dONHonOhQtAayswcSJ/Dw2l+zAtjaWTNhs7WQ4YoN9nyxaW+yYnU8RISWEumjcFGYuF21Rpcd/aSiedSt1dAZYpvv468NWvut5V1B+cOEFBTMvxi4vjZexYYP16Bunn5lL8vHgROHwYOHmS91m5kqJ/SopzsP+NTEMDcxGTk+kyjozkMTpsmO8cdi0twKZNLHVNSPDNYwiC4DYiiAmCIAiCcOPRNtC6tpZllvn5vJw+zQV7cDAzY/zlrHE4+PgTJvjn8VyhpYUup0WLjB6JM9nZXMyqRE0NF7udlZYGBl475hkzuDi2WFjWaLXqmXZjxvDvN9/suUDmcFAo0RxpqlBUxLmlWtC/xUKhNSbG6JE4ExhI52FoaMd/j4riPLn5Zv5eU0NHYkYG59OZMywDjY/XA/pTUjrf3vWI3U6xMCuLXYoBnte0hirTpvn28bX3FtVEYEG4wRFBTBAEQRCEG5uoKOe8Hk0Eys/3r6Oipgaor1erNLGoiOKgSuJTQwM7682aZfRInMnNpbPQnQYNWg7erFncz8XFwCef0OHz/vtcvKenc7uaiJGU5LpAVl1NwTclxaOn5DMsFu6nxESjR+KMxcJ9pVJelN3OueWOYBMdDdx1Fy8A54EW0H/6NHDgAMsCJ02iUyo0lM9bJRehtzh3jseS3U73bXw8G2OMHctmBv7CYuHjtXWICoJgOCKICYIgCIIgtCUoiAKQKyJQTQ3L3gYPppCVlOR5x8qCAl6rJIjl5XGRHBdn9Eh08vJ4rZJIpzmxtC6BnhAQwNf+4Yd5sdk4JwoLuZjet4+un9mzgdtu432am3m/znK4du6kO0ilOQXwNUxOVkt40vb3vHlGj8QZrUlDT9x0MTF0u44fz7laXa27ww4d4hwzmSjOts0g85dA1tBAN9u4cd7p4tjczIYWGzcC+/fzi41776UjLCHBmKYJFgv3q9ENGwRBcEIEMUEQBEEQBE9pbqazZ98+/mw204HQNossOtq1RdDZs/xfIzsntqeqimKKSsJFXh5dfd5YOHuLigou6r3pxAoM1MWJGTPocCkpcXYtHjoE7N3r7CAbNEgXyDIyKJipNKcA4J57uL9U4vLlngtPvsBi4euZlOSd7ZlM7FSp8cgjPM41B9nx4xSRcnM55xYuBKZOdd/96A5NTRRvtfOlJ2iidFYWXXA2G0W9W26hEGZkeajVStFRtdJzQRBEEBMEQRAEQfCYuDjgwQe5cKyo0HPILl1i2VtQEPDUU66VuH3wgXolZMuXc2GpEps2sYxQJadFfT1D2AcP9t1jmM163pHG6NGcYxYLy+B27WI5aXMz/7Zvn5qZRUFBagmaALB9OwXE+HijR+KM1crOub7qxmky6U1GJk6ksFRZCezezTl17hwbRpjNFOW0DLLBg73XDVfbTkuL59vYtIliXmwsXZTjxlE4V4H8fH5xkpZm9EgEQWiHCGKCIAiCIAg9xWzWO79pneCuXuXCsjsxTHOZFRQA8+f7fqzu4quFuCdcvcoF+tSpRo/EmbQ04Jvf9P/j9u/Py7RpFGXLyoDPPqMQ9sEHFDJqauhOmTgRWLKEQoZKr6kqnDhBodWbHT69wZw5/n08k4lzas0aXhwOiv2agywjg91w6+tZghkdTVfi1KmeC2RBQXwcq9W1/7fZ6KitqNAF3ylTeO5NTlZLLAe47yIifNfBUhAEj5F3Q0EQBEEQBF8QEdF9qZrDAfzud3T1lJdzYVhezoWT0Ys6h8P4MbTn6FEKP5roKOiYzcxHuvtuXv75T+CXvwQeeIAL8sOHKSAEBlLASE0FhgzxrautI7ZsAfr1U0vUtFop9qxZY/RI1MNkYhD8gAEUnRwO4PnngZde4u+bNwN1dSxN1OZVaqpz6W53mM3ssjp6dOcdUR0ONp3IyqJ4qZW32u28v7/nsTtIfpggKIsIYoIgCIIgCEbhcNC1k5/P/Kdz54Dz55kTpQX7JyezlNLfrp4PP6QTQ+tUpwJVVSwf0zqCqoDNxoWuas6iEycoeH372/zd4aCDTHP6HDrELqL338+/t7ZyHrojZLiL3c6ythkzfLN9TyktpciqNStQBauVIrlKQorJxPkzahSwfj0bQFgs+tw6eJDlloGBFKmmTgWGD+dr39kxEhREUaup6dq/lZUB773HxwwJASIjKcSNH09htTcwfjwbGwiCoBwiiAmCIAiCIBiF2UxHhOaKsFpZOpmXx8uePbwtMJDllNOm+W9subkUVFSipoaihUoh/ydPAlu3At/5ju9Cxz2hqgqYMEH/3WRiPlZ8PHDrrRTIGhv1vxcWAq+8ogsZWqfBxETvBZKXlrJE2JvNB7yBxcLSP9Xm+8aNFItUcq5p4fXjx/N3s5mlpunpFL/sdr7OFgsvNhtw5QpdZdq8SktjHp4mkJlMfJ7NzfzdbgcuXqRo+8orvG3qVGDdOr5GKh3/riCOVkFQFhHEBEEQBEEQVCE4WF9cAnTtlJZSHGsfqO5LtPyzefP895jdYbdTLJw92+iROJObS/eHSmJYXR3Lbpct6/x/TCYgPFz/fdAg4Ktf1YWMAweA99+noystjaLt8uU9yyDzdsdEb2GxUPxTSWix2zm3pk83eiTOXLlCd9iqVR3/3WymiJqYqAv4V6/yXGKxsIPlzp0UwJKTGYIfF8d5UVEBfPIJkJ3NjLKEBODRR/llgORvCYLgA0QQEwRBEARBUJWAAAphrohhFy9yIamVWcbFeV5qlZ/Pa5VyeUpK6JZTzV2Um8syTpXIy+N1aqrr99EyyBISdKfP5cvsXHn8ON2KVVXODjLNRebqPLNYfFuS6Qlaqai/w+u7o7RUz8lSCYuFr7c7HRMjIijsTZ/OeVVcrAuv777LY6isDPjXv/haTJ8O3HefesKpIAjXHQq9GwmCIAiCIAgeY7NRsDh1iovO0FAKF5pAlpTkuhBhsQBRUSwjU4XcXI4/MdHokejU1dExo5pIZ7EwX6lPH8+3YTZT6NPEvvalcAcOAJmZwLe+pd+nuJjh6x3NM7sdePttYOVKz8fkC8rL1RRaLRa6qPzpDHUFi4VjCgnx7P5mM89FSUnMkrvnHnaMrKlhd9SWFuDSJbpBU1J04TU+Xr2cPkEQej0iiAmCIAiCIFwPjBzJS0sL86C0HLJ9+5jNk5oKPPSQa9t6+206eVQiPZ0in0ruojNnKESqJqbk5np/TO1L4ex2CoKaO6yxEfjLX651kCUmUtg5eRKorlbPTZeQAHz/+97LSfMWJ09SeFJpvjscFMTGjvXeNoOCgJtv5s8zZ9KxV1SkN3/YtYvnr8xMYO1aZohpAplKJa6CIPRKFDrDCoIgCIIgCD0mKEgXIwAKF2VlFMq6wuHgdXMzhbSZM305SvfRAuFVYutWdgbtiRPL2zgcFA18HRBvNjs7CENCmPeUk6NnRX38MXD4MOdiXR1zobQGEirRNktNBWw2BuovWWL0SJxpamKXR3fKJd0lIICC6uDBwKxZFMhycuhybW0Fduzg/gkNpeiblqYLZCp14xQEoVcggpggCIIgCML1jJYN1R2VlcCrr3LRW1XFxabdLi6Mrjh7Fhg+3OhROGMyAYsW+f9x2zrItKwoi4XCxvHjwMGDLE28+26KdYsWAZMnO3cbFMjJkzwOVetOGBZG0dOfBAQ4l+7abHTAag6yTz8Fzp9nqa7JxMD/2bP5/yKQCYLQDSaHQ/s6UBAEQRAEQbhhqa4GMjIo8hw/ThEtPFzPIEtJMU68yM3l+MaN8/9jd8aVK8BddwGPPcYcJKFz7HZg8WJg9Ghg2DDgxAlmnAUEsDtncjJdPuPH+9dtV1gIfPQRcO+9zMxThb/8BfjnP4HNm9Ur5VQNm43dVGNjua8sFpaOp6Q4Z5D1pMmIJzQ3M2dv4kS15pYgCE6IQ0wQBEEQBEEAYmKABQt40XLIcnNZPrl3L909QUHMFps+ncKGv8jKYqC7SoJYeTm7Mc6ebfRInMnPZ/lYcLDRI9E5fZqOp5Ur9f2ldRvUSiz37gVuukm/T14eBbPERN+5FHNy+DpGRPhm+54SEcF9pZIY5nDwHOBpmL6vKCtjft2aNcCqVUBDA89dBQWcVx9/zFLL8HBgwwagb1/9XOZLgSwvD9i9W89HEwRBSUQQEwRBEARBEJxpn0PW2gqUlFAgy82lmOFPcnPVK03MzaXw5Eo5qr9obARefhlYsYJuK1XIy+O+mjxZv61tt0EtTL2t+3D3buDyZQowmtOnf382V/BW0HxuLt1pKpVs2u0UNadPN3okzlRWAn/6E/Dww9xnqnDiBOfDtGn8PTycYr0m2Le0UBzLzdUz77ZvpxNWO8dpc8ubApnFwry12FjvbVMQBK8jgpggCIIgCILQNQEBunjhykK9uJglhSkpPS+Bq6tjpplKi3DAN50ce0peHp08qo2rvp6ZYV2F17cXpdatu7bb4KFDdPcMGwbMmQPMKxxD0gAAGx1JREFUmOF5t0G7na/hrFnu39eXlJbSTaeJ0apgsVAwUq2xRUsLsHx558J0UBCD99s2Ahg/nnPRYmFjDLud56nGRh47M2ZQeO2JQGax8DWUHDNBUBoRxARBEARBEATvcvYssGcPf+7Xj4tMLYcsJsa9RWJeHq9VEsSamyn6TZxo9Eic0VwwMTFGj0TH4aA40NYd5goddRs8coSX48eBzz5j+HxoqO7yGTXKufNlVxQVUVxTUXgKCmJen0pYLByTaiWTOTnud1TV5hXAOZCfz+28+SaF1507WerY1kEWG+v6eUvV84MgCNcggpggCIIgCILgXebNowCSl6eXWWZm8m9RUfybq9lbu3bRMRMZ6bvxuktpqZpOLIuFY1LJlVJezlynngpPAQHMbJs6lb931G0wJkYXxK5coXuoszD1Dz8Ejh1jRplKlJRQrPFWWag30ERNlcpwAbpHKyuB227zfBvBwRTUhgxhfmJtLc9bJSWcV6dO0UEWFcUmGqmp/N1k6vw4y8vj/6gmtgqCcA0KnWkFQRAEQRCE64bISIaka0HpjY26QOZOiPnnn6snPCUnA08+qZZbpraWzQcefNDokThjsehuL28SGKh3EpwzhwJZWw4d4iU8XHf5DBzIi9nM7KmEBLWEJ4Bh+lar0aNwpqAAqKhQT+CxWHjtzfNDVBQwZgwvAN1eeXl8rL59eVtGBrBvH/dHWhqv2zpfc3IkP0wQegmKvQMIgiAIgiAI1yVhYcCIEbx0R3U1y+JiYugCWrrU9+NzF5U6AAIUf86cAQYMMHokziQmAvPnswzQl7QXthYsAEaO1B1k27ez22VtLTB0KLtarlhBJ4+vulh6gsmkltAK0KV5+DDwgx8YPRJnWlvp7OppTmFXhIQ4h/QD7LQ7Zgzn1okTdNBFR3MeJSSwGcSIEWo5NQVB6BARxARBEARBEAS1KC8H9u9n2ZLNRofGzp10YgwaxDInwZmsLAoD7uYp+Zq2eU3+pG2Y+rx5dF0dPgwcOMB8u4oK4KOPgOxsYOxYvRyuXz8RMtqTnc3X0JfCkyeMH29MGafmNARYzp2bS3Fs0yZg40bevmiR/8clCILbiCAmCIIgCIIgqMWwYSxJLC3VA68zMujqMZvZ7VIrl0tO9q+jJi+PbqP77lNLILBY6IhSye2kEsHBwMyZvERFAVevco4dPw6UlVEcs9tZ6qYF9I8e7d8xvvsuXZE9ycTyNnY7cP68et04VSE0VHe+LlpE0fWNN9QrLxUEoUNEEBMEQRAEQRDUw2xmuV1iInDLLSxLKi/X3RjHjjHHZ+ZMlsf5C4uFQd7h4f57zO6wWlmqpZorpaiIDj+VOoQCFMGGDQPuuIMXwDkrymJh2ZsmiNlsvE9amvtdUl3FbgfOnQNmzPD+tnvClSt00Gn7SRUaGymEqyYAV1dzvmt5Y4IgKI0IYoIgCIIgCIL6mEzsGBgXB0yZQoGssrL7bCqHw7sCRm4uF7wqLcTz8ymopKcbPRJn9u9nZtf69UaPRMdu52XaNOfb22dFORz630pL2ZVSy4rSSnfj4rwX6F5SQlFONWeRxcJ9M3Kk0SNx5pNP+Lps2GD0SJxpbmbZspTdCkKvQAQxQRAEQRAEofdhMgH9+3f/f8eOsVNlaqpeZhkZ6dljtrZSfJozx7P7+wqtc6cr+8NfOBwUUyZONHokzpSUAPHxDPrviraCRlISyys1d2JODrBjB3DyJJ1Ao0YBd99NQTI62rNxWSwUd7VsKlWwWDgm1XL7LBY2R1CNZcucxVRBEJRGBDFBEARBEATh+qVfPzq6Ll8GjhzRb0tJoUiWmspMKVcoLmZ5ordcQd4iN5djUsmVUlnJnC4VHU9BQRS53KFtVhQAVFUxoD8jg/v//fd5e2wsn3N6OjsRusrlywyub98t00g0UXPCBKNH4kxtLUs5VZtbGiodh4IgdIlCZ1xBEARBEARB8DLJyXqGVV0dxQvtkpnJErl161zb1pYtvE9Cgu/G6y4OB0vaVOsuabGwrNSIDpNdYbFwPgQE9Gw7ffsCixfzAgANDXr+mMXCoP62gtj583RaddSIwWYDXn8dWL26Z2PyNrW16pZxAuoJ04Ig9DpEEBMEQRAEQRBuDCIjKVJoQsXVq0BTU9f30cqfTCaWyCUkqOXiMZmA++83ehTXsmsXy+xUKrWz2ymEzpzp/W2HhzOEv20Qv0ZjI/Dmm5xL/fsznD81FRgwgDlkx4/zf266yfvj6gnR0cBTTxk9ims5doxOvIgIo0ciCEIvR6F3c0EQBEEQBEHwIxER3S+qi4ooZgwezPK4JUu8H9R/vWG3A3v2ALNnGz0SZ+x2YOFC/ziL2oqmYWHAd76ju8dycoC9e4FDh5hndvUquxOq5qYDeu6k8wXvvQeMG2f0KARBuA4QQUwQBEEQBEEQOiM8HBg/Hrh0iYvw0lLg17/WM8hSUujyMUoga2pivpVKXLgA1NcDkyYZPRJnAgONG1OfPs7uxIoKiobHjlFwbW4GHngASEwEFi0Cbr2V8ysszJjxqkpeHvPDVGvWIAhCr8TkcEgbDEEQBEEQBEHoFqsVKCjQnT6Fhew8GR5OYWzkSP86V2w24Je/BO68Uy2B4MMPgeefp9DjasOCGxWbja7DmTPZrTIzk/PJZqPIGh9PYWzaNM87WHpCeTlfv/vuY2mnKmzcCDz7LPDOO2p1VRUEoVciDjFBEARBEARBcIXgYHYPTE/n7y0tzgJZXp5/BbGiIo5BpZB/gMLhypVqiWF2O3D0KEWnjoLtjeL4cbrDFiyg6LVmDW+vrtbn1Zkz/JtGTg5f9+Rk37kDLRagpsa/IpwrBAQAy5erJ4ZVV3NfSSm1IPQqRBATBEEQBEEQBE8ICmJAeloaf++u8MJqBSor6foxm3v++BYLO0yqJIg5HBzX2LFGj8SZkhJ2CU1IUEsQKymhu7B9KWdMDEt1x4+/9j5Hj7LBg8nEzpWpqRQfR43yngiZkwMkJanVFAFgU4RRo4wehTONjcDvfw+sWqXevBcEoUtEEBMEQRAEQRAEb9CdOyQ3F3j9dbp62maQJSR4JpDl5tIl5A1xzVtcuQLU1fG5qYTFQgFz4ECjR+JMdTUwf757wtPq1cBtt1G0sljoMtu1C2hoYDD/7NnAnDmcG54IWpqoOXmy+/f1JTU1QFWVenMrN5f7LDnZ6JEIguAmIogJgiAIgiAIgj9ISwMeflgvhduxg1lRoaFcTKelAVOnulZ2ZbWylG7xYl+P2j0sFo5fNXEgJ4djUqlrot1OMWXGDPfuZzIBsbG8TJpEMWb5cuDAASA7Gzh7FsjPp1CalEQBadw418sMi4vZ+VI14cli4bU/uoS6g8VCR19MjNEjEQTBTUQQEwRBEARBEAR/EBjIxXxKCh08NhtzwDrLiuqK7Gzg889ZpqUSYWEM+A8JMXokOnY7891mzjR6JM6UlDA/TCu59RSTCRg2jBeAAllFBedUTg5LLJOTdUGsooIuvsGDOSfbs307cPAg8PTTPRuXt7lyhW7K8HCjR+KMxaKeeCgIgkuIICYIgiAIgiAIRhAYSKEiOZllbq40fy8uBuLigIwMlsP5M8TfFUaP5kUlTp6ka+ruu40eiTM5Ob4p4zSZ2BlywABgyhTOq7ZzKzsb+Owzzr9BgyjmxMdTmAsNZQnmwIG+C+z3lHnzeJyoREMDhU1XhWxBEJRCBDFBEARBEARBUIHuSiVra4EXXqAQtns33VhlZUBiolqlgKrx+ed04qlWxjlsGBAZ6fvXzmRynlu33QaMGaNnkB06BGRl0TmWksLSy/nzWZarWqi+avM8N5fXqpVxCoLgEiaHw5WvogRBEARBEARBMBS7XS+xvHyZzqfwcIoWycl0+qSm0t1jRNB+TQ3HEhbm/8fuiscfB1pbgeefN3okamK3A6dOUQjbuZNia3w8nYjDhgFr19I9NnCgcYKUw+Fatp6/2boVOH8eeOIJo0ciCIIHiENMEARBEARBEHoDZjNL3AYNYh5WaytLKLUMsr17gU8/pSiVkgLce2/HGVG+YscOuowefdR/j9kddjuddarlh6mE2QzcfDMvQUFAaSnw059ScM3NBfbvp1CmCa+jRjHM3598+CFfy5Ur/fu43VFcLPlhgtCLEUFMEARBEARBEHojAQEdC2Q5OUBlpX/FMIeDotyYMf57TFcoKQGGDFGvG+elS0BLCzBypNEjcebYMbrBZszQu1/a7brwmpPDnzUcDgbwJyezdNdXzsTLl9XbVwDw0EMsLRUEoVcigpggCIIgCIIgXA+0FchcISuLpXEJCT0XMqqr6cRSLUvJYvFNcH1POXiQQpNKIo9WljhrlvPtZjOQlMSLJpJpVFXRPdbSws6iKSmcf5GRdJx5Q5StruZFRSeW2axe8wFBEFxGBDFBEARBEARBuNGwWpl/ZLXqQoaWQeaJQGaxUExRURBLTlYrjN1uZymiah0Ty8qAmBhg7lzX7xMbCzz1FFBYqJfubtpEsTU0lBlka9YAw4dzXnmSA5aTo+bcEgSh1yOCmCAIgiAIgiDcaAQHA08+6Sxk7NpFp09oKEWkxYspkLjCoUNAVJRabhlNeFItP6yoiEKkao4ni0V3GbpDQADnS3IyRb577gEyM4EjR4Bz55htt2sXmy2kpLAk85ZbXBfHLlygmKZaswZBEHo9IogJgiAIgiAIwo1IeyHDZtO7WFosrgsQdjuwbRswZYovR+s+ViswbhwwdKjRI3HGYqEgmZho9EicsVgohgUF9Ww7oaHA9Om8AJxXBQX6vDp+HLj1Vv3/T58G+vcHBgy4ViSz24E33ri2VFMQBMELiCAmCIIgCIIgCALzntoKZN1x8SIQEQE0NjLjaeJE34/RHUJD1QvTB1iqGhOjVhmn1hThllu8v+3AQL0cV3ssjdZW4L33KF5GROgOsqgollvm5nJuqdasQRCE6wIRxARBEARBEARBcJ+tW9nNMi+P12YzuzrGx3uWFXUjYLWylHDlSqNH4ozDASxfTpeWr2k7NwICgO99D8jP1x1k770H7N9PgczhAEpL6SCz233XxVIQhBsSk8PRVqIXBEEQBEEQBEFwAZtNzyA7f57Chc3GUkvNEZSaCsTF+V8gs9spsiQleafTobc4coQC0K9+pV6JqSo0NLAL59GjwKuvspPlsGFAnz7AbbcBc+ZwXsXGGie8ijgnCNcFIogJgiAIgiAIgtBz2mZF5eTw59ZWIDycjqjhw/03lsJC4MUXgfXrgcGD/fe43fHOO8DbbwOvv84cMaFz7HZg1SpgwgRg1iwKZADQ1MS/RUZSGJs1i6Krv7h6Ffj974G1a4H0dP89riAIXkehr0sEQRAEQRAEQei1tM2KmjuXHSs1gaxfP/+OxWJhOPzAgf593O5obAT+f3t382PVXcYB/JmxdGh5h+lQcBjupIAKVozUmtqmqUFF66KbdiG6senCxOjCf8OdS5eu7E6jURNSXwpa+oZtpekL0nsAGVpQXgoDxcIcF09upmNt5w4z957DnM8nOZnC3Dnn6e3NJP3meZ7fI4/UKwwry4j9+yPuvjtizZqqq5nWbkdcuBBx330Ru3fnFRFx9WqO6XZGLP/3Z86dyz1kq1f3poOsKHL0dXh44e8N9JVADAAAWHhLlmQwMT4++2tffz3i0qUM09atm3+QURR5OECdFtdfv55BzkMPVV3JTO+8E/GHP+T7VadAbGIiPzsfPJEyImJoKEcot2798M+89VbEgQMZ8q1alZ+nFSvytZs3L0xdnYB35cqFuR9QGYEYAABQrXY792t9cBSuc811V9TUVAZPDzzQo2Jv0MREds11Tlusi3Y7u/tGR6uuZKYzZ7I7bPXq7n9m9+6I++/P0yk7HWQ//3l2ja1Zk/f7+tczaFu16sbqKor6/TcEbohADAAAqNY3v5kL00+cyICmKCIOH85On5Urc5H6rl3d3eu11/I+dQt4iiJHJTdsqLqSmYoi96zV6fCBssy6PvvZuf/s0qURn/pUXhERjz2WS/oPHYq4eDHiV7/K+69Zk8HWF77Q/Z65S5cyqHvwwbnXBdROjX7rAQAAjTU0FLFlS14RuSuq0+kzl/G0p5+OOHIkT5isk/XrcwF8nU4nnJrK9/i++6quZKZz5yLefbe7cdvZrF0b8fDDeUXkHrfO56rdzsX4nUDs7Nnce9dq/f/PXGdnmQ4xWBQEYgAAQP0MDeXJlN2cTnnqVO7CarUi/v73iLvuqtfi+oju/1366dVXI155JU8BrZN2O4PDsbGFv/dtt0V8+tN5/b/n/vrX+c9r12YgNzyc+8c2bsxAbHg4x3qBm55ADAAAuLm99VbEvn3Z8fTiixE7d0a8/HIGGpaff7S//jXi9On6dTxt2RLx6KMZivbTrl0ZlH1wB9mTT2bX2PBwfr4ef7y/NQE9M1CWZVl1EQAAAPNy+XIGGSdPRrzxRu56ishOn1Yrw7HOqYP9dupUdqytW9f/Z3+cH/wgF/3/7GdVV1Jfp09HPPNM7iF76aWIn/zkxnabAbWjQwwAALj53X57xGc+k9dXvxoxOTlzV9ShQ/m6rVsjvvOd/ta2b18urd+7t7/P/ThTU7lPq277w+pmZCTikUdyDHdoqH7ddMANE4gBAACLz7JlEdu35xWRJwQeO5ZBUD9dv56nXn7lK/197mzefjt3dO3ZU3UlMx09mkv177mn6kpm6uwPW7686kqABSIQAwAAFr/lyyN27Jj9dZcvR/zpT9kJ1Gpl59l8nDyZY4l16ywqioglS+p3Guff/hZx/nz9ArEdO/JESmDREIgBAAB0XLgQ8Y9/RDz3XP55/frpcKzVylMK56IoctTuzjsXts75arezQ+wTn6i6kmllme/X5z9fdSUfNj5edQXAAhOIAQAAdGzYEPGjH2Uw1jlp8M03I559NmJgIL//xBMRg4Pd3e/Pf85Ru25f3w9TUxHHj0c88EDVlcz073/naGvduumARUkgBgAA8L9WrYrYuTOviBzjK4oMyroNt957L+LppyMefbRnZd6Qa9dymf62bVVXMlNR5Hs7NlZ1JUADCMQAAABms3p1d6N8ZZkh2MaNERMTuT/sS1/qfX1zceutEQ89VHUVH/ab32T32q23Vl0J0AACMQAAgIVy5UrECy9EXLwY8frrOQL49tu5l2xsTNjzUaamIp5/vp5BHbAoCcQAAAAWyu23R/z4x7kPq93OMcDDhyMOHsxxwE9+MndkjY9HbNqUJz3209RU7kQbH89l/3XxxhsRk5MRu3ZVXQnQEAIxAACAhTQwkIv0h4cjvvjFHKP817+ml/QfOhSxf3+e8Pjd7/b3BMOJiYhf/CIPBhgd7d9zZ3PsWMTISMS991ZdCdAQAjEAAIBeGhiIuOOOvDoB2ZkzGY7deWd/aymKHNvcsKG/z53NxYsRe/ZELF9edSUz7dsXsX17dvYBi4pADAAAoJ8GBrIbamRk9tcePBhx9WqOWY6OZlfZfBRF7jKb730WUllmXXUbl7xwIeIvf8n3XSAGi45ADAAAoK7Ono145ZWIP/4x941t2pQjlq1WnmQ5l2Dr+vWI48cjHnywZ+XekDNncn9Yq1V1JTMVRX7dvLnSMoDeEIgBAADU1cMPR3zjG3lSZWcH2YEDEU89laOP3/pWxM6d3d3r1Vdz0f/evb2seO6KIoO9TZuqrmSmoohYvz4PSgAWHYEYAABAnQ0OZjfYxo0RX/5ynhR56tR0YNOtAweyQ6xOy/Qjcp/Z7t39P3FzNkURsW1b1VUAPSIQAwAAuJkMDuZOq272Wh05kiOJ4+MRL70UcdddEbfU7H8DN22qX3fY+fMR587Vb4wTWDA1+00IAADAgpmYiNi/P+I//4k4fDhix45c1N9qZXfZwEDVFdZTUeR7IxCDRWugLMuy6iIAAADokWvXIk6ejDhxIuLo0fx67VrEbbflwvjOkv6Rkf4HZCdP5gho3TrEfvnL3Nv2/e9XXQnQIwIxAACAJrl2LeKf/5xe0n/iRJ5AOTYW8fjj/a3lyScjLl+O+N73+vvc2bzwQn69555q6wB6xsgkAABAk9xyS3aEdcYB338/A7L33+9vHWWZgdy99/b3ud0QhMGiJxADAABosiVLcmxyNpOTEb/73XSYtm7d/EYsT5+OuHKlu2cDLDCBGAAAALObnMzTF3/729z7tWLFdDjWakWsXTu3gKzdzm610dEeFQzw0QRiAAAAzG5kJOKJJyKuXs29Y+12jjwePpzjj2vWRPzwhxGDg93d76mnIpYuzVAMoM/85gEAAKB7Q0MRW7bkFZEB2fHjEefOdR+GTU1FHDgQsWdP7+oE+BgCMQAAAG7c0FDE1q2zv64sI37/+4gNG3L88soVy+uBygjEAAAA6L333os4dizi2Wdz1HJyMuLUqYiXX87F+itXVl0h0CADZVmWVRcBAABAQ1y+nMFYUeT1zjv592vXzlzS3++ArCwjXnwxu91Wrervs4G+E4gBAABQncnJmQHZ6dP59489FrFjR//qOHs24qc/jdi7N2Lbtv49F6iEkUkAAACqs2xZxPbteUVkQFYUEZs397eOoogYGIgYG+vvc4FKCMQAAACoj2XLuusMe+aZ7OrqjFguWza/5xZFLvxfunR+9wFuCgIxAAAAbj5TUxHtdsTzz+ef77gjl/O3WtldNpeArCzzXnff3ZNSgfoRiAEAAHDzuf/+vC5enN4/dvRoxHPP5fe/9rX8fjfOns37jI/3qlqgZgRiAAAA3LxWrMjOrk5317vvZjg2MtL9PewPg8YRiAEAALB4rFwZ8bnPzf66I0eyo6zVinjzzYiNGyOGhnpeHlAPAjEAAACa59KliNdeizh4MOLMmYhvf7vqioA+GijLsqy6CAAAAKjE+fMZjo2OVl0J0EcCMQAAAAAaZbDqAgAAAACgnwRiAAAAADSKQAwAAACARhGIAQAAANAoAjEAAAAAGkUgBgAAAECjCMQAAAAAaBSBGAAAAACNIhADAAAAoFEEYgAAAAA0ikAMAAAAgEYRiAEAAADQKAIxAAAAABpFIAYAAABAowjEAAAAAGgUgRgAAAAAjSIQAwAAAKBRBGIAAAAANIpADAAAAIBGEYgBAAAA0CgCMQAAAAAaRSAGAAAAQKMIxAAAAABoFIEYAAAAAI0iEAMAAACgUQRiAAAAADSKQAwAAACARhGIAQAAANAoAjEAAAAAGkUgBgAAAECjCMQAAAAAaBSBGAAAAACNIhADAAAAoFEEYgAAAAA0ikAMAAAAgEb5L9PIT/PFjf/XAAAAAElFTkSuQmCC", - "text/plain": [ - "PyPlot.Figure(PyObject )" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(-20.0,120.0,-20.0,25.0)" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fig = figure(figsize=(15, 4))\n", - "for element in field_problem.elements\n", - " conn = get_connectivity(element)\n", - " X = element(\"geometry\", 0.0)\n", - " #info(X)\n", - " for i=1:length(X)\n", - " px1 = X[i][1]\n", - " py1 = X[i][2]\n", - " px2 = X[mod(i,length(X))+1][1]\n", - " py2 = X[mod(i,length(X))+1][2]\n", - " plot([px1, px2], [py1, py2], \"k-\")\n", - " end\n", - "end\n", - "for element in field_problem.elements\n", - " conn = get_connectivity(element)\n", - " X = element(\"geometry\", 0.0)\n", - " u = element(\"displacement\", 0.0)\n", - " x = X + u\n", - " #info(X)\n", - " for i=1:length(x)\n", - " px1 = x[i][1]\n", - " py1 = x[i][2]\n", - " px2 = x[mod(i,length(x))+1][1]\n", - " py2 = x[mod(i,length(x))+1][2]\n", - " plot([px1, px2], [py1, py2], \"r--\", alpha=0.5)\n", - " end\n", - "end\n", - "\n", - "axis(\"equal\")\n", - "axis(\"off\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Model 3: splitted beam, frictionless contact, small sliding\n", - "\n", - "Same model as above, now with sliding contact. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "using JuliaFEM.Preprocess: parse_aster_med_file\n", - "using JuliaFEM.Core: PlaneStressLinearElasticityProblem, DirichletProblem,\n", - " get_connectivity, Quad4, Tri3, Seg2, LinearSolver,\n", - " update!, get_elements, BiorthogonalBasis, StandardBasis" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Found 5 element sets: LOWER_TO_UPPER, RIGHT, UPPER_TO_LOWER, LEFT, LOAD\n" - ] - }, - { - "data": { - "text/plain": [ - "Dict{ASCIIString,Any} with 2 entries:\n", - " \"nodes\" => Dict(68=>[71.42857142857142,9.999999999999998],2=>[95.0,-4.…\n", - " \"connectivity\" => Dict(11=>(:SE2,:OTHER,[11,12]),134=>(:TR3,:OTHER,[75,96,76]…" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mesh = parse_aster_med_file(Pkg.dir(\"JuliaFEM\")*\"/geometry/2d_beam/BEAM.med\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO: Found 5 element sets: LOWER_TO_UPPER, RIGHT, UPPER_TO_LOWER, LEFT, LOAD\n", "INFO: created 104 field elements.\n", - "INFO: created 4 boundary elements.\n" - ] - } - ], - "source": [ - "field_problem = PlaneStressLinearElasticityProblem()\n", - "basis = StandardBasis\n", - "\n", - "# field problems\n", - "joo = Dict(:QU4 => Quad4, :TR3 => Tri3)\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype in keys(joo) || continue\n", - " element = joo[eltype](elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"youngs modulus\"] = 900.0\n", - " element[\"poissons ratio\"] = 0.25\n", - " push!(field_problem, element)\n", - "end\n", - "\n", - "# neumann boundary condition -1 on y direction\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == :LOAD || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"displacement traction force 2\"] = -1.0\n", - " push!(field_problem, element)\n", - "end\n", - "\n", - "# boundary conditions\n", - "boundary_problem = DirichletProblem(\"displacement\", 2; basis=basis)\n", - "\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == :LEFT || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"displacement\"] = 0.0\n", - " push!(boundary_problem, element)\n", - "end\n", - "\n", - "info(\"created $(length(get_elements(field_problem))) field elements.\")\n", - "info(\"created $(length(get_elements(boundary_problem))) boundary elements.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO: created 4 boundary elements.\n", "INFO: # of master elements: 14\n", - "INFO: # of slave elements: 20\n" - ] - } - ], - "source": [ - "using JuliaFEM.Core: ContactProblem, SmallSlidingContact, Element, BoundaryProblem,\n", - " calculate_normal_tangential_coordinates!, BoundaryAssembly\n", - "\n", - "mortar_surface = :UPPER_TO_LOWER\n", - "slave_surface = :LOWER_TO_UPPER\n", - "\n", - "master_elements = JuliaFEM.Core.Element[]\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == mortar_surface || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " push!(master_elements, element)\n", - "end\n", - "\n", - "contact_problem = ContactProblem(\"slider between two half-beams\", \"displacement\", 2;\n", - " contact_type=SmallSlidingContact)\n", - "\n", - "import JuliaFEM.Core: postprocess_assembly!\n", - "\n", - "function JuliaFEM.Core.postprocess_assembly!{T}(assembly::BoundaryAssembly, problem::BoundaryProblem{ContactProblem{T}}, time::Real)\n", - " info(\"postprocess contact assembly: remove stiffness in x direction on boundary.\")\n", - " C1 = sparse(assembly.C1)\n", - " C2 = sparse(assembly.C2)\n", - " dim = size(C1)\n", - " info(\"dim = $dim\")\n", - " for i=1:2:dim[1]\n", - " C1[i,:] = 0\n", - " C2[i,:] = 0\n", - " end\n", - " assembly.C1 = C1\n", - " assembly.C2 = C2\n", - " info(\"postprocess contact assembly: done.\")\n", - "end\n", - "\n", - "for (elid, (eltype, elset, elcon)) in mesh[\"connectivity\"]\n", - " eltype == :SE2 || continue\n", - " elset == slave_surface || continue\n", - " element = Seg2(elcon)\n", - " update!(element, \"geometry\", mesh[\"nodes\"])\n", - " element[\"master elements\"] = master_elements\n", - " calculate_normal_tangential_coordinates!(element, 0.0)\n", - " push!(contact_problem, element)\n", - "end\n", - "\n", - "info(\"# of master elements: $(length(master_elements))\")\n", - "info(\"# of slave elements: $(length(contact_problem.elements))\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO: # of slave elements: 20\n", "INFO: Starting solver divided_beam_small_sliding_contact\n", "INFO: # of field problems: 1\n", "INFO: # of boundary problems: 2\n", @@ -1054,66 +918,64 @@ "INFO: dim = 210\n", "INFO: Assembling boundary problems...\n", "INFO: Assembling boundary 1: dirichlet boundary\n", - "INFO: Assembling boundary 2: slider between two half-beams\n", - "INFO: assemble: doing postprocess for problem JuliaFEM.Core.BoundaryProblem{JuliaFEM.Core.ContactProblem{JuliaFEM.Core.SmallSlidingContact}} assembly\n", - "INFO: postprocess contact assembly: remove stiffness in x direction on boundary.\n", - "INFO: dim = (104,156)\n", - "INFO: postprocess contact assembly: done.\n", + "INFO: Assembling boundary 2: mortar problem\n", + "INFO: assemble: doing postprocess for problem JuliaFEM.Core.BoundaryProblem{JuliaFEM.Core.MortarProblem} assembly\n", + "INFO: postprocess mortar assembly: remove contraints in tangent direction on boundary.\n", + "INFO: dim of C1 = (104,156)\n", + "INFO: dim of C2 = (104,156)\n", + "INFO: dim of P = (104,104)\n", + "INFO: postprocess mortar assembly: done.\n", "INFO: Solving system\n", - "INFO: UMFPACK: solved in 0.3429999351501465 seconds. norm = 313.6918010692049\n" - ] - }, - { - "data": { - "text/plain": [ - "(1,true)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO: UMFPACK: solved in 0.00822305679321289 seconds. norm = 3.141256420230667\n", "INFO: timing info for iteration:\n", - "INFO: boundary assembly : 1.373000144958496\n", - "INFO: field assembly : 1.434999942779541\n", - "INFO: dump matrices to disk : 0.0\n", - "INFO: solve problem : 0.4829998016357422\n", - "INFO: update element data : 0.016000032424926758\n", - "INFO: non-linear iteration : 3.306999921798706\n", - "INFO: solver finished in 3.4630000591278076 seconds.\n" + "INFO: boundary assembly : 0.6682760715484619\n", + "INFO: field assembly : 0.06378602981567383\n", + "INFO: dump matrices to disk : 9.5367431640625e-7\n", + "INFO: solve problem : 0.08866310119628906\n", + "INFO: update element data : 0.0013039112091064453\n", + "INFO: non-linear iteration : 0.8220479488372803\n", + "INFO: Starting iteration 2\n", + "INFO: Assembling field problems...\n", + "INFO: Assembling body 1: plane stress linear elasticity\n", + "INFO: Assembly: 10.0 % done. \n", + "INFO: Assembly: 20.0 % done. \n", + "INFO: Assembly: 30.0 % done. \n", + "INFO: Assembly: 40.0 % done. \n", + "INFO: Assembly: 50.0 % done. \n", + "INFO: Assembly: 60.0 % done. \n", + "INFO: Assembly: 70.0 % done. \n", + "INFO: Assembly: 80.0 % done. \n", + "INFO: Assembly: 90.0 % done. \n", + "INFO: Assembly: 100.0 % done. \n", + "INFO: dim = 210\n", + "INFO: Assembling boundary problems...\n", + "INFO: Assembling boundary 1: dirichlet boundary\n", + "INFO: Assembling boundary 2: mortar problem\n", + "INFO: assemble: doing postprocess for problem JuliaFEM.Core.BoundaryProblem{JuliaFEM.Core.MortarProblem} assembly\n", + "INFO: postprocess mortar assembly: remove contraints in tangent direction on boundary.\n", + "INFO: dim of C1 = (104,156)\n", + "INFO: dim of C2 = (104,156)\n", + "INFO: dim of P = (104,104)\n", + "INFO: postprocess mortar assembly: done.\n", + "INFO: Solving system\n", + "INFO: UMFPACK: solved in 0.0014190673828125 seconds. norm = 3.927608258855347e-12\n", + "INFO: timing info for iteration:\n", + "INFO: boundary assembly : 0.11057901382446289\n", + "INFO: field assembly : 0.05525398254394531\n", + "INFO: dump matrices to disk : 2.1457672119140625e-6\n", + "INFO: solve problem : 0.07990384101867676\n", + "INFO: update element data : 0.0012819766998291016\n", + "INFO: non-linear iteration : 0.24703502655029297\n", + "INFO: solver finished in 1.0706429481506348 seconds.\n", + "INFO: displacement at tip: [0.39054101395962204,-0.44586724992142107]\n", + "WARNING: result changed" ] - } - ], - "source": [ - "using JuliaFEM.Core: DirectSolver\n", - "solver = DirectSolver()\n", - "solver.name = \"divided_beam_small_sliding_contact\"\n", - "solver.method = :UMFPACK\n", - "solver.nonlinear_problem = false\n", - "solver.max_iterations = 1\n", - "solver.dump_matrices = false\n", - "push!(solver, field_problem)\n", - "push!(solver, boundary_problem)\n", - "push!(solver, contact_problem)\n", - "call(solver, 0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, - "outputs": [ + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "PyPlot.Figure(PyObject )" + "PyPlot.Figure(PyObject )" ] }, "metadata": {}, @@ -1123,48 +985,109 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING: using PyPlot.mesh in module Main conflicts with an existing identifier.\n" + "\n" ] } ], "source": [ - "using PyPlot\n", + "using JuliaFEM.Core: SparseMatrixCOO, Element, get_integration_points, get_jacobian, get_connectivity, add!\n", + "using JuliaFEM.Core: BoundaryAssembly, BoundaryProblem, get_elements\n", "\n", - "fig = figure(figsize=(15, 4))\n", - "for element in field_problem.elements\n", - " conn = get_connectivity(element)\n", - " X = element(\"geometry\", 0.0)\n", - " #info(X)\n", - " for i=1:length(X)\n", - " px1 = X[i][1]\n", - " py1 = X[i][2]\n", - " px2 = X[mod(i,length(X))+1][1]\n", - " py2 = X[mod(i,length(X))+1][2]\n", - " plot([px1, px2], [py1, py2], \"k-\")\n", + "function calculate_normal_tangential_coordinates(elements::Vector{Element}, time::Real)\n", + " P = SparseMatrixCOO()\n", + " field_dim = 2\n", + " for element in elements\n", + " for ip in get_integration_points(element, Val{2})\n", + " J = get_jacobian(element, ip, time)\n", + " w = ip.weight*norm(J)\n", + " nt = transpose(element(\"normal-tangential coordinates\", ip, time))\n", + " normal = nt[1,:]\n", + " tangent = nt[2,:]\n", + " for nid in get_connectivity(element)\n", + " ndofs = [2*(nid-1)+1, 2*(nid-1)+2]\n", + " add!(P, [2*(nid-1)+1], ndofs, normal)\n", + " add!(P, [2*(nid-1)+2], ndofs, tangent)\n", + " end\n", + " end\n", " end\n", - "end\n", - "for element in field_problem.elements\n", - " conn = get_connectivity(element)\n", - " X = element(\"geometry\", 0.0)\n", - " u = element(\"displacement\", 0.0)\n", - " x = X + u\n", - " #info(X)\n", - " for i=1:length(x)\n", - " px1 = x[i][1]\n", - " py1 = x[i][2]\n", - " px2 = x[mod(i,length(x))+1][1]\n", - " py2 = x[mod(i,length(x))+1][2]\n", - " plot([px1, px2], [py1, py2], \"r--\", alpha=0.5)\n", + " P = sparse(P)\n", + " for i=1:size(P,1)\n", + " if sum(abs(P[i,:])) > 0.0\n", + " P[i,:] = P[i,:] / norm(P[i,:])\n", + " end\n", " end\n", + " return P\n", "end\n", "\n", - "#axis(\"equal\")\n", - "#axis(\"off\")" + "import JuliaFEM.Core: postprocess_assembly!\n", + "\n", + "function JuliaFEM.Core.postprocess_assembly!(\n", + " assembly::BoundaryAssembly, problem::BoundaryProblem{MortarProblem},\n", + " time::Real)\n", + " info(\"postprocess mortar assembly: remove contraints in tangent direction on boundary.\")\n", + "\n", + " C1 = sparse(assembly.C1)\n", + " C2 = sparse(assembly.C2)\n", + " info(\"dim of C1 = \", size(C1))\n", + " info(\"dim of C2 = \", size(C2))\n", + " dim = size(C1, 1)\n", + "\n", + " P = calculate_normal_tangential_coordinates(get_elements(problem), time)\n", + " #P = full(P)\n", + " #P[abs(P) .< 1.0e-9] = 0\n", + " #P = sparse(-P)\n", + " info(\"dim of P = \", size(P))\n", + " C1 = P*C1\n", + " C2 = P*C2\n", + "\n", + " for i=2:2:dim\n", + " C1[i,:] = 0\n", + " C2[i,:] = 0\n", + " end\n", + "\n", + " #for i=1:2:dim\n", + " # info(\"normal direction in node: i=$i, \", P[i,i:i+1])\n", + " # info(\"# nonzeros in row: \", length(nonzeros(P[i,:])))\n", + " #end\n", + "\n", + " assembly.C1 = C1\n", + " assembly.C2 = C2\n", + " info(\"postprocess mortar assembly: done.\")\n", + "end\n", + "\n", + "\n", + "field_problem, boundary_problem, contact_problem = create_problems()\n", + "using JuliaFEM.Core: DirectSolver\n", + "solver = DirectSolver()\n", + "solver.name = \"divided_beam_small_sliding_contact\"\n", + "solver.method = :UMFPACK\n", + "solver.max_iterations = 3\n", + "solver.dump_matrices = false\n", + "push!(solver, field_problem)\n", + "push!(solver, boundary_problem)\n", + "push!(solver, contact_problem)\n", + "call(solver, 0.0)\n", + "\n", + "\n", + "u_tip = plot(field_problem, 30)\n", + "isapprox(u_tip, [-0.03903778814766088,-0.5899441561142401]) || warn(\"result changed\")\n", + "# [-0.039030212458572940,-0.5885059481026573]\n", + "# [-0.039036748287580560,-0.5897457086352924]\n", + "# [-0.039037269987308750,-0.5898452701000865]\n", + "# [-0.039037788147688480,-0.5899441561146597]\n", + "# [-0.039099099865037394,-0.5906742308544110]\n", + "# [-0.039099231221552275,-0.5907858076472083]\n", + "# [-0.039099285443584080,-0.5908044797337564]\n", + "# [-0.039149880055252856,-0.5916839898102431]\n", + "# [-0.039149700806172030,-0.5917487545114570]\n", + "# [-0.039149456207397196,-0.5918347268056199]\n", + "# [-0.039148982216695556,-0.5920462890915309]\n", + "# [-0.039148229226873680,-0.5923403595745590]" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, "metadata": { "collapsed": false }, @@ -1172,91 +1095,16 @@ { "data": { "text/plain": [ - "JuliaFEM.Core.BoundaryAssembly(JuliaFEM.Core.SparseMatrixCOO([65,61,65,61,65,61,65,61,66,62 … 69,65,70,66,70,66,70,66,70,66],[65,65,61,61,149,149,151,151,66,66 … 149,149,70,70,66,66,148,148,150,150],[1.04962,-0.485085,0.051661,-0.0238754,-0.844859,0.390455,-0.256418,0.118505,1.04962,-0.485085 … 0.0174914,-0.430652,-0.00571773,0.140775,-0.0121938,0.30022,0.000420114,-0.0103436,0.0174914,-0.430652]),JuliaFEM.Core.SparseMatrixCOO([65,65,65,65,66,66,66,66,65,65 … 70,70,69,69,69,69,70,70,70,70],[65,61,149,151,66,62,150,152,65,61 … 148,150,69,65,147,149,70,66,148,150],[0.485085,0.0238754,-0.390455,-0.118505,0.485085,0.0238754,-0.390455,-0.118505,0.283224,0.0849655 … 0.0639392,0.49021,-0.140775,-0.30022,0.0103436,0.430652,-0.140775,-0.30022,0.0103436,0.430652]),JuliaFEM.Core.SparseMatrixCOO([61,61,62,62,61,61,62,62,61,61 … 66,66,65,65,66,66,65,65,66,66],[65,61,66,62,65,61,66,62,65,61 … 70,66,69,65,70,66,69,65,70,66],[-1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0 … -1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0,-1.0,0.0]),JuliaFEM.Core.SparseMatrixCOO(Int64[],Int64[],Float64[]))" + "(0.5936326182349801,0.5927224376865623)" ] }, - "execution_count": 7, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "con = assemble(contact_problem, 0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0x0 sparse matrix with 0 Float64 entries:" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "C1 = sparse(con.C1)\n", - "C2 = sparse(con.C2)\n", - "D = sparse(con.D)\n", - "g = sparse(con.g)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "40x40 Array{Float64,2}:\n", - " 0.0 0.0 -5.0 0.0 … 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 -5.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 3.55271e-15 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 3.55271e-15 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 … 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 … 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " ⋮ ⋱ ⋮ \n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 … 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 … 3.55271e-15 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 -5.0 0.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 -5.0 0.0 0.0 0.0\n", - " 0.0 0.0 0.0 0.0 0.0 0.0 -5.0 0.0 0.0" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nz1 = sort(unique(rowvals(D)))\n", - "nz2 = sort(unique(rowvals(D')))\n", - "full(D[nz1,nz2])" + "norm([-0.039148229226873680,-0.5923403595745590]), norm([0.39054101395962204,-0.44586724992142107])" ] }, { @@ -1941,7 +1789,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 0.4.1", + "display_name": "Julia 0.4.2", "language": "julia", "name": "julia-0.4" }, @@ -1949,7 +1797,7 @@ "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "0.4.1" + "version": "0.4.2" } }, "nbformat": 4, diff --git a/notebooks/2015-12-18-normal-tangential-coordinates.ipynb b/notebooks/2015-12-18-normal-tangential-coordinates.ipynb index c307adc..953a828 100644 --- a/notebooks/2015-12-18-normal-tangential-coordinates.ipynb +++ b/notebooks/2015-12-18-normal-tangential-coordinates.ipynb @@ -3027,7 +3027,7 @@ }, { "cell_type": "code", - "execution_count": 108, + "execution_count": 1, "metadata": { "collapsed": false }, @@ -3055,7 +3055,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 2, "metadata": { "collapsed": false }, @@ -3064,7 +3064,7 @@ "data": { "image/png": "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", "text/plain": [ - "PyPlot.Figure(PyObject )" + "PyPlot.Figure(PyObject )" ] }, "metadata": {}, @@ -3076,7 +3076,7 @@ "(-0.5,4.5)" ] }, - "execution_count": 109, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -3106,7 +3106,68 @@ }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10x10 Array{Float64,2}:\n", + " -0.196116 0.980581 0.0 0.0 … 0.0 0.0 0.0 \n", + " 0.980581 0.196116 0.0 0.0 0.0 0.0 0.0 \n", + " 0.0 0.0 0.0914276 0.995812 0.0 0.0 0.0 \n", + " 0.0 0.0 0.995812 -0.0914276 0.0 0.0 0.0 \n", + " 0.0 0.0 0.0 0.0 0.0 0.0 0.0 \n", + " 0.0 0.0 0.0 0.0 … 0.0 0.0 0.0 \n", + " 0.0 0.0 0.0 0.0 0.987285 0.0 0.0 \n", + " 0.0 0.0 0.0 0.0 0.158957 0.0 0.0 \n", + " 0.0 0.0 0.0 0.0 0.0 0.287348 0.957826\n", + " 0.0 0.0 0.0 0.0 0.0 0.957826 -0.287348" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using JuliaFEM.Core: SparseMatrixCOO, Element, get_integration_points, get_jacobian, get_connectivity, add!\n", + "\n", + "function calculate_normal_tangential_coordinates(elements::Vector{Element}, time::Real)\n", + " P = SparseMatrixCOO()\n", + " field_dim = 2\n", + " time = 0.0\n", + " for element in elements\n", + " for ip in get_integration_points(element, Val{2})\n", + " J = get_jacobian(element, ip, time)\n", + " w = ip.weight*norm(J)\n", + " nt = transpose(element(\"normal-tangential coordinates\", ip, time))\n", + " normal = nt[1,:]\n", + " tangent = nt[2,:]\n", + " for nid in get_connectivity(element)\n", + " ndofs = [2*(nid-1)+1, 2*(nid-1)+2]\n", + " add!(P, [2*(nid-1)+1], ndofs, normal)\n", + " add!(P, [2*(nid-1)+2], ndofs, tangent)\n", + " end\n", + " end\n", + " end\n", + " P = sparse(P)\n", + " for i=1:size(P,1)\n", + " if sum(abs(P[i,:])) > 0.0\n", + " P[i,:] = P[i,:] / norm(P[i,:])\n", + " end\n", + " end\n", + " return P\n", + "end\n", + "P = calculate_normal_tangential_coordinates(Element[s1, s2, s3, s4], 0.0)\n", + "P = full(P)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": { "collapsed": false }, @@ -3122,7 +3183,7 @@ "data": { "image/png": "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", "text/plain": [ - "PyPlot.Figure(PyObject )" + "PyPlot.Figure(PyObject )" ] }, "metadata": {}, @@ -3134,7 +3195,7 @@ "(-1.0,5.0,-0.2,1.2000000000000002)" ] }, - "execution_count": 111, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -3157,11 +3218,9 @@ " plot([X1[1],X2[1]], [X1[2],X2[2]], \"-ko\")\n", "end\n", "for i=1:5\n", - " s = 4*(i-1)+1\n", + " s = 2*(i-1)+1\n", " e = s + 1\n", " normal = vec(P[2*(i-1)+1, s:e])\n", - " s = 4*(i-1)+3\n", - " e = s + 1\n", " tangent = vec(P[2*(i-1)+2, s:e])\n", " println(\"i = $i, normal = $normal, tangent = $tangent, dot = \", dot(normal, tangent))\n", " plot([nodes[i][1], nodes[i][1]+normal[1]*0.5], [nodes[i][2], nodes[i][2]+normal[2]*0.5], \"-r\")\n",