diff --git a/docs/tutorials/2015-11-03-constitutive-modelling-using-juliafem.ipynb b/docs/tutorials/2015-11-03-constitutive-modelling-using-juliafem.ipynb
index 9ce5a4c..b1c7284 100644
--- a/docs/tutorials/2015-11-03-constitutive-modelling-using-juliafem.ipynb
+++ b/docs/tutorials/2015-11-03-constitutive-modelling-using-juliafem.ipynb
@@ -8,7 +8,7 @@
     "\n",
     "Author(s): Jukka Aho\n",
     "\n",
-    "**Abstract**: This is reproduction of the results from notebook [*Ideal plastic Von Mises material*](https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/notebooks/2015-09-24-Ideal%20plastic%20Von%20Mises%20material.ipynb) made by Olli Väinölä. Small strain theory is used, see https://en.wikipedia.org/wiki/Flow_plasticity_theory. The purpose of this notebook is to show how one can easily design and simulate material models using JuliaFEM."
+    "**Abstract**: This is reproduction of the results from notebook [*Ideal plastic Von Mises material*](https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/notebooks/2015-09-24-Ideal%20plastic%20Von%20Mises%20material.ipynb) made by Olli Väinölä. Small strain theory is used, see https://en.wikipedia.org/wiki/Flow_plasticity_theory. The purpose of this notebook is to show how one can easily design and simulate material models using JuliaFEM. This is 2d version. For 3d version see Olli's notebook."
    ]
   },
   {
@@ -28,7 +28,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The atomic structure here is `IntegrationPoint`. It has identical `Field`-structure like elements and can store multidimensional variables which can be time-dependent also. That way one can easily store, for example, measured strain and easily run material simulation for measured data."
+    "The atomic structure here is `IntegrationPoint`. It has identical `Field`-structure like elements and can store multidimensional variables which can be time-dependent also. That way one can easily store, for example, measured strain and run material simulation for real measured data and fit material parameters."
    ]
   },
   {
@@ -96,12 +96,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Our material model is"
+    "Next to material model: ideal plastic material model."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 118,
+   "execution_count": 4,
    "metadata": {
     "collapsed": false
    },
@@ -112,7 +112,7 @@
        "calculate_stress! (generic function with 1 method)"
       ]
      },
-     "execution_count": 118,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -135,30 +135,25 @@
     "    function f(stress)\n",
     "        # https://en.wikipedia.org/wiki/Yield_surface\n",
     "        # https://en.wikipedia.org/wiki/Von_Mises_yield_criterion\n",
-    "        #s = stress - 1/dim*trace(stress)*I  # deviatoric stress tensor\n",
-    "        #J2 = 1/2*trace(s*s')\n",
-    "        #stress_v = sqrt(3/2*trace(s*s')) # equivalent tensile stress\n",
     "        stress_y = last(ip.fields[\"yield stress\"])[1]\n",
-    "        #k = stress_y/sqrt(2)\n",
-    "        #return J2 - k^2\n",
     "        s1 = stress[1,1]\n",
     "        s2 = stress[2,2]\n",
     "        s12 = stress[1,2]\n",
     "        stress_v = sqrt(s1^2 - s1*s2 + s2^2 + 3*s12^2)\n",
-    "        #s1, s2 = eigvals(stress)\n",
-    "        #stress_v = sqrt(s1^2 + s2^2 - s1*s2)\n",
     "        return stress_v - stress_y\n",
     "    end\n",
     "\n",
-    "    stress_trial = lambda*trace(strain)*I + 2*mu*strain\n",
+    "    strain_plastic_prev = last(ip.fields[\"plastic strain\"])[1]\n",
+    "    strain_elastic = strain - strain_plastic_prev\n",
+    "    stress_trial = lambda*trace(strain_elastic)*I + 2*mu*(strain_elastic)\n",
     "\n",
     "    if f(stress_trial) <= 0.0\n",
-    "        info(\"time=$time: no yield\")\n",
+    "        #info(\"time=$time: no yield\")\n",
     "        push!(ip.fields[\"stress\"], TimeStep(time, Increment(Matrix[stress_trial])))\n",
     "        push!(ip.fields[\"total strain\"], TimeStep(time, Increment(Matrix[strain])))\n",
     "        return true\n",
     "    else\n",
-    "        info(\"time=$time: yield, f(stress_trial) = $(f(stress_trial))\")\n",
+    "        #info(\"time=$time: yield, f(stress_trial) = $(f(stress_trial))\")\n",
     "        dt = time - ip.fields[\"total strain\"][end].time\n",
     "\n",
     "        # associated flow rule, plastic potential ψ(σ) = f\n",
@@ -181,13 +176,9 @@
     "        function residual(params::Vector)\n",
     "            dstress = reshape(params[1:prod(size(strain))], size(strain))\n",
     "            gamma = params[end]\n",
-    "\n",
     "            strain_prev = last(ip.fields[\"total strain\"])[1]\n",
     "            stress_prev = last(ip.fields[\"stress\"])[1]\n",
-    "\n",
     "            dstrain_total = 1/dt*(strain - strain_prev)\n",
-    "            #dstress = 1/dt*(stress - stress_prev)\n",
-    "            #dstress = 1/dt*(stress_trial - stress)\n",
     "            stress_tot = stress_prev + dstress\n",
     "            # derivative of plastic potential ψ(σ) w.r.t 2nd order tensor σ(ϵ)\n",
     "            # https://en.wikipedia.org/wiki/Tensor_derivative_%28continuum_mechanics%29\n",
@@ -196,181 +187,108 @@
     "            dstrain_plastic = gamma*dpsi_dstress\n",
     "            dstrain_elastic = dstrain_total - dstrain_plastic\n",
     "            dstress_elastic = lambda*trace(dstrain_elastic)*I + 2*mu*dstrain_elastic\n",
-    "\n",
     "            stress_delta = dstress - dstress_elastic\n",
     "            return [vec(stress_delta); psi(stress_tot)]\n",
     "        end\n",
     "\n",
-    "        \n",
     "        # solve equations using Newton iterations. Jacobian is calcualated\n",
     "        # using automatic differentiation as usual.\n",
     "        stress_prev = last(ip.fields[\"stress\"])[1]\n",
-    "        #initial_stress = last(ip.fields[\"stress\"])[1]\n",
-    "        #initial_gamma = last(ip.fields[\"plastic rate parameter\"])[1]\n",
-    "        initial_gamma = 0.0\n",
+    "        initial_gamma = last(ip.fields[\"plastic rate parameter\"])[1]\n",
     "        params = [vec(stress_prev); initial_gamma]\n",
-    "        #info(\"initial params = $params\")\n",
     "        dparams = zeros(5)\n",
-    "        l = [1, 4, 3, 5]\n",
-    "        #l = [1, 2, 3, 4, 5]\n",
-    "        for i=1:20\n",
+    "        l = [1, 4, 3, 5] # <-- reorder to voigt\n",
+    "        for iterations=1:10\n",
     "            A = ForwardDiff.jacobian(residual, params)[l,l]\n",
     "            b = -residual(params)[l]\n",
     "            dparams = A \\ b\n",
     "            params[l] += dparams\n",
-    "            solution_norm = norm(dparams)\n",
-    "            if solution_norm < 1.0e-7\n",
-    "                info(\"norm = $solution_norm\")\n",
-    "                break\n",
-    "            end\n",
+    "            norm(dparams) < 1.0e-7 && break\n",
     "        end\n",
     "        params[2] = params[3]\n",
-    "        #info(\"params = $params\")\n",
+    "\n",
+    "        # save all kind of stuff to integration point\n",
+    "\n",
     "        dstress = reshape(params[1:prod(size(strain))], size(strain))\n",
     "        stress = stress_prev + dstress\n",
-    "        #info(\"f(stress) = $(f(stress)), dstress = $(vec(dstress))\")\n",
+    "        dpsi_dstress = derivative(psi, stress)\n",
+    "        gamma = params[end]\n",
+    "        dstrain_plastic = gamma*dpsi_dstress\n",
+    "        strain_plastic_prev = last(ip.fields[\"plastic strain\"])[1]\n",
+    "        strain_plastic  = strain_plastic_prev + dstrain_plastic\n",
+    "\n",
     "        push!(ip.fields[\"stress\"], TimeStep(time, Increment(Matrix[stress])))\n",
     "        push!(ip.fields[\"total strain\"], TimeStep(time, Increment(Matrix[strain])))\n",
-    "        #push!(ip.fields[\"plastic rate parameter\"], TimeStep(time, Increment(params[end])))\n",
+    "        push!(ip.fields[\"elastic strain\"], TimeStep(time, Increment(Matrix[strain_elastic])))\n",
+    "        push!(ip.fields[\"plastic strain\"], TimeStep(time, Increment(Matrix[strain_plastic])))\n",
+    "        push!(ip.fields[\"plastic rate parameter\"], TimeStep(time, Increment(params[end])))\n",
+    "        push!(ip.fields[\"plastic potential\"], TimeStep(time, Increment(psi(stress))))\n",
+    "        push!(ip.fields[\"derivative of plastic potential\"], TimeStep(time, Increment(Matrix[dpsi_dstress])))\n",
     "    end\n",
     "\n",
-    "end    ### END OF CONSTITUTIVE MODEL"
+    "end"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Small \"simulator\" to study the behavior of material model in `IntegrationPoint`"
+    "Small \"simulator\" to study the behavior of material model in `IntegrationPoint`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 119,
+   "execution_count": 6,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "INFO: time=1.0: no yield\n",
-      "INFO: time=2.0: no yield\n",
-      "INFO: time=3.0: no yield\n",
-      "INFO: time=4.0: no yield\n",
-      "INFO: time=5.0: no yield\n",
-      "INFO: time=6.0: no yield\n",
-      "INFO: time=7.0: no yield\n",
-      "INFO: time=8.0: no yield\n",
-      "INFO: time=9.0: no yield\n",
-      "INFO: time=10.0: no yield\n",
-      "INFO: time=11.0: no yield\n",
-      "INFO: time=12.0: no yield\n",
-      "INFO: time=13.0: no yield\n",
-      "INFO: time=14.0: no yield\n",
-      "INFO: time=15.0: no yield\n",
-      "INFO: time=16.0: no yield\n",
-      "INFO: time=17.0: no yield\n",
-      "INFO: time=18.0: no yield\n",
-      "INFO: time=19.0: no yield\n",
-      "INFO: time=20.0: no yield\n",
-      "INFO: time=21.0: no yield\n",
-      "INFO: time=22.0: no yield\n",
-      "INFO: time=23.0: no yield\n",
-      "INFO: time=24.0: yield, f(stress_trial) = 5.438631395957261e6\n",
-      "INFO: norm = 6.327290296460759e-10\n",
-      "INFO: time=25.0: yield, f(stress_trial) = 1.4370745804477155e7\n",
-      "INFO: norm = 2.5368436951508793e-10\n",
-      "INFO: time=26.0: yield, f(stress_trial) = 2.330286021299705e7\n",
-      "INFO: norm = 2.1402519744192276e-10\n",
-      "INFO: time=27.0: yield, f(stress_trial) = 3.2234974621516943e7\n",
-      "INFO: norm = 9.421226040685514e-10\n",
-      "INFO: time=28.0: yield, f(stress_trial) = 4.116708903003678e7\n",
-      "INFO: norm = 2.5732227717057695e-8\n",
-      "INFO: time=29.0: yield, f(stress_trial) = 5.009920343855673e7\n",
-      "INFO: norm = 2.5811234708594938e-8\n",
-      "INFO: time=30.0: yield, f(stress_trial) = 5.9031317847076595e7\n",
-      "INFO: norm = 2.572690677593919e-8\n",
-      "INFO: time=31.0: yield, f(stress_trial) = 6.796343225559643e7\n",
-      "INFO: norm = 1.6939240257439999e-9\n",
-      "INFO: time=32.0: yield, f(stress_trial) = 7.689554666411638e7\n",
-      "INFO: norm = 2.6531859781938224e-8\n",
-      "INFO: time=33.0: yield, f(stress_trial) = 8.582766107263625e7\n",
-      "INFO: norm = 2.6549753353863674e-8\n",
-      "INFO: time=34.0: yield, f(stress_trial) = 9.475977548115605e7\n",
-      "INFO: norm = 2.6269774232540882e-8\n",
-      "INFO: time=35.0: yield, f(stress_trial) = 1.0369188988967597e8\n",
-      "INFO: norm = 3.943829269565131e-10\n",
-      "INFO: time=36.0: yield, f(stress_trial) = 1.126240042981959e8\n",
-      "INFO: norm = 2.672625454866766e-8\n",
-      "INFO: time=37.0: yield, f(stress_trial) = 1.215561187067157e8\n",
-      "INFO: norm = 2.6724023527734252e-8\n",
-      "INFO: time=38.0: yield, f(stress_trial) = 1.3048823311523557e8\n",
-      "INFO: norm = 4.0424078932575624e-10\n",
-      "INFO: time=39.0: yield, f(stress_trial) = 1.394203475237555e8\n",
-      "INFO: norm = 2.7378636631817178e-8\n",
-      "INFO: time=40.0: yield, f(stress_trial) = 1.483524619322754e8\n",
-      "INFO: norm = 1.634965889399672e-10\n",
-      "INFO: time=41.0: yield, f(stress_trial) = 1.5728457634079528e8\n",
-      "INFO: norm = 2.757582543090421e-8\n",
-      "INFO: time=42.0: yield, f(stress_trial) = 1.6621669074931514e8\n",
-      "INFO: norm = 2.7149985332652483e-8\n",
-      "INFO: time=43.0: yield, f(stress_trial) = 1.75148805157835e8\n",
-      "INFO: norm = 2.7222211807288396e-8\n",
-      "INFO: time=44.0: yield, f(stress_trial) = 1.8408091956635493e8\n",
-      "INFO: norm = 2.7731830203746644e-8\n",
-      "INFO: time=45.0: yield, f(stress_trial) = 1.9301303397487473e8\n",
-      "INFO: norm = 2.7741353645150486e-8\n",
-      "INFO: time=46.0: yield, f(stress_trial) = 2.0194514838339472e8\n",
-      "INFO: norm = 2.7680252846576977e-8\n",
-      "INFO: time=47.0: yield, f(stress_trial) = 2.1087726279191452e8\n",
-      "INFO: norm = 2.7789819953233903e-8\n",
-      "INFO: time=48.0: yield, f(stress_trial) = 2.1980937720043445e8\n",
-      "INFO: norm = 2.7842679685856577e-8\n",
-      "INFO: time=49.0: yield, f(stress_trial) = 2.287414916089543e8\n",
-      "INFO: norm = 2.7835836044051844e-8\n",
-      "INFO: time=50.0: yield, f(stress_trial) = 2.3767360601747423e8\n",
-      "INFO: norm = 2.8328177662423844e-8\n"
+      "elapsed time: 0.031678742 seconds\n"
      ]
     }
    ],
    "source": [
-    "function run(steps=50)\n",
+    "function run(steps=11)\n",
     "\n",
     "    # initialization\n",
     "    ip = IntegrationPoint([0.0, 0.0], 1.0)\n",
     "    ip.fields[\"total strain\"] = Field()\n",
-    "    ip.fields[\"plastic strain\"] = Field()\n",
+    "    ip.fields[\"plastic strain\"] = Field(Matrix[zeros(2,2)])\n",
     "    ip.fields[\"plastic potential\"] = Field()\n",
+    "    ip.fields[\"derivative of plastic potential\"] = Field()\n",
     "    ip.fields[\"elastic strain\"] = Field()\n",
     "    ip.fields[\"effective plastic strain\"] = Field()\n",
     "    ip.fields[\"stress\"] = Field()\n",
     "    ip.fields[\"young\"] = Field(200.0e9)\n",
     "    ip.fields[\"poisson\"] = Field(0.3)\n",
     "    ip.fields[\"yield stress\"] = Field(200.0e6)\n",
-    "    ip.fields[\"plastic rate parameter\"] = Field() # material parameter\n",
+    "    ip.fields[\"plastic rate parameter\"] = Field(0.0) # material parameter\n",
     "\n",
-    "    # run\n",
-    "    for (time, strain_11) in enumerate(linspace(0, 200e-5, steps))\n",
-    "        # set up strain etc.\n",
-    "        time = Float64(time)\n",
-    "        poisson = last(ip.fields[\"poisson\"])[1]\n",
-    "        strain = zeros(2, 2)\n",
-    "        strain[1, 1] = strain_11\n",
-    "        strain[2, 2] = -poisson*strain_11\n",
-    "        #strain[2, 2] = strain_11\n",
-    "        strain[1, 2] = 1/3*strain_11\n",
-    "        strain[2, 1] = 1/3*strain_11\n",
+    "    strain = zeros(2, 2)\n",
+    "    strain[1,1] = 2.0e-3\n",
+    "    strain[2,2] = -0.3*2.0e-3\n",
+    "    #strain[1,2] = 1.0e-3\n",
+    "    #strain[2,1] = 1.0e-3\n",
     "\n",
-    "        # calculate stress\n",
-    "        calculate_stress!(ip, strain, time)\n",
+    "    # calculate stress in integration point\n",
+    "    #for (time, omega) in enumerate(linspace(0, 4*pi, steps))\n",
+    "    #    calculate_stress!(ip, sin(omega)*strain, Float64(time))\n",
+    "    #end\n",
+    "\n",
+    "    for (time, k) in enumerate(linspace(0, 1, steps))\n",
+    "        calculate_stress!(ip, k*strain, Float64(time))\n",
     "    end\n",
     "\n",
     "    return ip\n",
     "end\n",
     "\n",
-    "ip = run();"
+    "tic()\n",
+    "ip = run()\n",
+    "toc();"
    ]
   },
   {
@@ -382,16 +300,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 120,
+   "execution_count": 7,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7ff7c4450b10>)"
+       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7fa8b80dd450>)"
       ]
      },
      "metadata": {},
@@ -400,10 +318,10 @@
     {
      "data": {
       "text/plain": [
-       "(0,250)"
+       "PyObject <matplotlib.legend.Legend object at 0x7fa8a16155d0>"
       ]
      },
-     "execution_count": 120,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -412,37 +330,45 @@
     "steps = length(ip.fields[\"total strain\"])\n",
     "eps11 = Float64[]\n",
     "sig11 = Float64[]\n",
+    "sig22 = Float64[]\n",
+    "sig12 = Float64[]\n",
     "principals = Vector{Float64}[]\n",
     "for i=1:steps\n",
-    "    # extract from integration points -- too complicated\n",
+    "    # extract from integration points\n",
     "    # field -> timestep -> increment -> (vector of tensors, take first) -> (first component)\n",
     "    strain = ip.fields[\"total strain\"][i][end][1]*1.0e6\n",
     "    stress = ip.fields[\"stress\"][i][end][1]*1.0e-6\n",
     "    push!(eps11, strain[1,1])\n",
     "    push!(sig11, stress[1,1])\n",
-    "    push!(principals, sort(eigvals(stress)))\n",
+    "    push!(sig22, stress[2,2])\n",
+    "    push!(sig12, stress[1,2])\n",
+    "    push!(principals, eigvals(stress))\n",
     "end\n",
     "\n",
-    "#PyPlot.figure(figsize=(7, 5))\n",
-    "PyPlot.plot(eps11, sig11, \"-k.\")\n",
+    "PyPlot.figure(figsize=(7, 5))\n",
+    "PyPlot.plot(eps11, sig11, \"-bo\", label=\"s11\")\n",
+    "PyPlot.plot(eps11, sig22, \"-ro\", label=\"s22\")\n",
+    "PyPlot.plot(eps11, sig12, \"-go\", label=\"s12\")\n",
     "PyPlot.title(\"Stress-Strain curve\")\n",
     "PyPlot.xlabel(\"Strain [ustr]\")\n",
     "PyPlot.ylabel(\"Stress [MPa]\")\n",
-    "PyPlot.ylim([0, 250])"
+    "#PyPlot.ylim([-250, 250])\n",
+    "#PyPlot.xlim([-2100, 2100])\n",
+    "PyPlot.legend(loc=\"best\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 121,
+   "execution_count": 8,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj0AAAI6CAYAAADMlPm5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3XlcTekfB/DPvXVblKiESHYlyyRZasZSRJYsg2RsZZuxMwYzZcY2YwnDGDOGkW1sGUIYQpYak3ZrsiRLiiI7abnn9wfdn1S0n+69n/frdV+v6TzPPedzLtP9ep7nnCMRBEEAERERkYqTih2AiIiIqCyw6CEiIiK1wKKHiIiI1AKLHiIiIlILLHqIiIhILbDoISIiIrXAooeIiIjUAoseIiIiUgsseoiIiEgtsOghojxJpVI4ODiU6TE7duwIqbTsfy3dvHkTUqkUHh4eZX5sIio7LHqIKF8SiaTMj1fWx3z/+CWtTp06qFu3bonvl4gKT1PsAERUPsXGxqJChQpleszNmzfj1atXZXrMsiBmIUdE/8eih4jy1KhRozI/Zq1atcr8mESkPji9RaTk3l2PEhsbiz59+sDIyAj6+vpo164djh49mus9GzduhFQqxaZNm3D48GF07NgRlSpVyrGeJq81PXPmzIFUKsWpU6ewa9cutG7dGnp6ejA2NsagQYOQmJiYZ8bU1FR4eXmhadOm0NPTQ+XKlWFtbY3vvvsOL1++VPTLa03PyZMnIZVKMXfuXISEhKBz586oXLkyDAwM4OzsjMjIyFzHS0xMxLx58/Dpp5+ievXq0NbWRs2aNTF48GBcvny5UJ9vfjZt2gR7e3uYmJhAV1cX5ubmcHZ2xs6dO3Pkvn37tuLPKPv17tqh7M/5/v37GDVqFGrWrAlNTU1s2rRJ0Sc0NBT9+/dXnIu5uTm++uorJCUl5cp148YNjBkzBg0aNECFChVgbGyM5s2bY+zYsUhNTVX0S09Px8qVK2FjYwMjIyPo6emhbt266NOnDwIDA0vkMyIqbzjSQ6Qi4uPjYW9vr/iCS0xMhK+vL7p164Zt27bB1dU113t27dqFw4cPo3v37hg3bhxu3bqVoz2/aZnff/8d/v7+6N27NxwcHHDmzBn4+vri3LlzOHv2LLS0tHLkcnBwwO3bt2Fra4tx48ZBLpfjypUrWLFiBcaOHQtzc/OPHjM0NBQLFy6Ek5MTJkyYgGvXrsHPzw9BQUE4cuQIPvvsM0XfoKAgLF68GI6OjrCxsYG+vj6uXr2KXbt2wd/fH6dPn0bz5s0L9fm+y9PTE4sWLUK9evXg5uaGSpUqITExEeHh4di1axdcXV1Rt25dzJ49GytWrAAATJ06VfF+a2vrHPtLTU1F27ZtUbFiRfTv3x9SqRTVq1cHAKxfvx5jxoyBrq4uevXqhVq1auHq1atYt24d9u/fjzNnzihGyJKSktCqVSs8e/YMPXr0wIABA5CWloYbN25gy5YtmDhxIoyMjAAA7u7u2LFjB5o1a4bhw4dDV1cXd+/exenTpxEQEIBOnToV+fMhKrcEIlJq8fHxgkQiESQSiTBjxowcbREREYJMJhMMDQ2Fp0+fKrZv2LBBkEgkgoaGhhAQEJDnfiUSieDg4JBj2+zZswWJRCJUqlRJuHjxYo62L774QpBIJMLOnTtzbLezsxMkEomwaNGiXMd4+PChkJaWpvi5Q4cOglQqzdHnxIkTivP77bffcrTt27dPkEgkQsOGDQW5XK7YnpycLDx//jzX8c6dOyfo6+sL3bp1y7E9+zP08PDI66PIxcjISKhVq5bw6tWrXG0PHjzI8XPt2rWFunXr5ruv7HMbPny4kJWVlaPtypUrgkwmExo2bCgkJibmaAsMDBQ0NDSEvn37KratXLlSkEgkwsqVK3Md5+XLl4q8jx8/FiQSidCqVascn1u2hw8f5puXSJlxeotIRVSuXBk//PBDjm0tW7bE4MGD8fjxY+zZsyfXe3r37o0uXboU+liTJk1CkyZNcmwbPXo0ACA8PFyxLTIyEmfOnEGLFi0wc+bMXPsxMjKCtrZ2gY7ZsGFDjBs3Lse2Xr16oUOHDrh+/TqCg4MV201MTKCnp5drH82bN4eDgwNOnDiBrKysAh03LxKJBDKZLM/L642NjQu9P21tbSxdujTX/lavXo3MzEz88ssvMDU1zdHm6OgIFxcX7N+/Hy9evMjRpqOjk+sYurq6iu3Zo2na2tp5jqxljwYRqRoWPUQqwsbGJs8v+g4dOgAAzp49m6utdevWRTqWra1trm1mZmYAgEePHim2nTlzBgDQtWvXIh3nXe3atctze37nd/DgQbi4uMDU1BRaWlqK9TQHDhxAeno6Hjx4UOQsgwcPRnx8PKysrODp6YmAgAA8efKkyPurU6cOqlSpkmt7SEgIgDfrg+bMmZPrlZycjKysLFy5cgXAmyJWX18f48ePR//+/bF27VrExMTk2q+BgQFcXFxw+vRpWFtbY/78+Th58mSO9VVEqohreohURLVq1fLcnr02JK8v5ey2wqpcuXKubZqab36dvDuC8vjxYwBAzZo1i3ScdxXm/H755RdMnToVRkZGcHJygrm5OSpUqACJRII9e/bg3LlzeP36dZGzLF++HPXq1cOGDRuwaNEiLFq0CJqamujevTuWLVuG+vXrF2p/+f05PHz4EACwZMmSfN8rkUgUIz3m5uYICwvDnDlzcPjwYfj5+QF4c1XcN998g4kTJyre5+vri8WLF2Pbtm2YPXs2gDcjRP3798fSpUtRtWrVQp0DkTJg0UOkIu7fv5/n9nv37gEAKlWqlKuttO8fk10cJSQkFHtfBT2/zMxMzJkzB6ampoiKispVLJ0+fbrYWaRSKSZPnozJkycjJSUF//77L3bs2IG///4bly5dwqVLl3Is5v6Y/P4cKlWqBIlEgidPnkBfX79A+7K0tMSOHTuQlZWFc+fO4dixY/j1118xefJk6OnpYcSIEQDeFDizZ8/G7NmzkZCQgKCgIGzcuBFbtmzBzZs3ERQUVOD8RMqC01tEKiIqKgrPnz/Ptf3kyZMAgBYtWpRxIsDOzg4AEBAQAEEQirWv4ODgPPfx/vk9ePAAT548gb29fa6C5/nz54iKiirRYs/ExAR9+/aFr68vHBwcEBcXh0uXLinaNTQ0irx+yM7ODoIgFKkA0dDQgI2NDWbMmIHt27cDAPbt25dnXzMzM3zxxRcICAhA/fr18e+//+aYpiRSFSx6iFTE48ePMW/evBzbIiIisHXrVlSuXBl9+/Yt80w2Njawt7fH2bNnsXjx4lztDx8+LPA007Vr1/D777/n2LZv3z4EBQWhYcOGijU/VatWRYUKFRAREZFjgW9GRgYmT56smDIqqvT09DxHizIyMpCamgqJRJLjTtbGxsZITk5GWlpaoY81YcIEyGQyTJ06FdeuXcszy7sLuKOiovKcxsweDcvO9eDBA1y4cCFXv+fPn+P58+eQyWSFGqkiUhac3iJSEe3bt8e6desQGhoKe3t7JCUlwdfXFwCwZs2aAk+PlLQtW7agY8eO8PT0xO7du9GhQwcIgoBr167h6NGjuHLlSo779OQ3IuTs7Ixp06bh0KFDaN68Oa5fvw4/Pz/o6upi/fr1in5SqRSTJk3CokWL0KxZM/Tq1Qvp6ek4ceIEHj9+rLh6q6hevnyJdu3aoUGDBrCxsUHt2rWRlpaGo0ePIjY2Fr1794aFhYWif+fOnREREQFnZ2e0a9cO2trasLa2Rs+ePT96LAsLC6xfvx4jRoxAkyZN4OzsjIYNGyIjIwO3b99GcHAwqlWrplisvHnzZqxduxafffYZ6tWrB0NDQ8TFxWH//v3Q0dHBlClTALyZbrSxsUGzZs3QrFkz1KpVC0+fPsWBAwdw//59xVQYkcoR9YJ5Iiq2d+8xExsbK/Tu3VswNDQU9PT0hM8++0w4cuRIrvds3LhRkEqlwqZNm/Ldb1736ZkzZ44glUqFU6dOfTDH+x4+fCjMnDlTsLCwEHR0dARDQ0OhRYsWwqxZs4SXL18q+nXs2DHf+/TMnTtXCAkJETp37iwYGBgIBgYGQteuXYWIiIhcx8vMzBR+/vlnwcrKStDV1RVMTU2FYcOGCbdv3xbc3d0FqVQq3Lp1q0DZ35eRkSF4e3sL3bp1E8zNzQUdHR2hatWqgp2dnbBmzRohIyMjR/8XL14IY8eOFczMzARNTU1BKpXmOE5en/P7Lly4ILi7uwu1a9cWtLW1BWNjY6FZs2bCV199JZw4cULRLzQ0VBg7dqzwySefCEZGRoKurq7QsGFDYcSIEcKlS5cU/R4/fizMmzdPcHR0FGrWrCloa2sLNWrUEBwcHIQdO3Z89DMgUlYSQSjmRDsRiermzZuoV68e3N3dc4x4qIqTJ0/C0dERc+bMyXUfIiKiwuCaHiIiIlILLHqIiIhILbDoISIiIrXANT1ERESkFjjSQ0RERGpB6e/Tc+nSJcyZMwdRUVG4d+8edHR0YGFhgfHjx2Pw4ME5+l6+fBlTp07F6dOnoaWlhR49euDnn3/O80F/Pj4+WLp0KW7evIlatWph0qRJmDBhQr45Hjx4gICAANSpUwe6urolfp5ERESq6tWrV7h58ya6du2a53dyiRH3ivni++effwRnZ2dh3rx5wrp164SVK1cK7du3FyQSifDjjz8q+t25c0eoUqWK0LBhQ+HXX38VFixYIBgZGQnW1tZCenp6jn3+8ccfgkQiEQYMGCCsW7dOGDZsmCCRSITFixfnm2PLli0CAL744osvvvjiq4ivLVu2lFq9IAgqep8euVyOli1bIjU1Fbdu3QIAjBs3Dps3b0ZsbCzMzMwAAIGBgXBycsKaNWswevRoAG+qzVq1asHe3h7+/v6KfQ4dOhR79+7FnTt38nzC9OnTp/HZZ59hy5YtaNy4cRmcpeqYOnUqli9fLnYMpcLPrGj4uRUeP7Oi4edWOJcvX8aQIUPw77//4tNPPy214yj99FZepFIpzMzM8OzZM8W23bt3o2fPnoqCBwA6deqERo0aYefOnYqi58SJE0hNTcW4ceNy7HP8+PHYunUrDh48mGvaDIBiSqtx48awsbEpjdNSWZUqVeJnVkj8zIqGn1vh8TMrGn5uRVPay0NUZiHzy5cv8eDBA8TFxWH58uUICAjAjBkzAAB3795FSkoKbG1tc72vVatWiI6OVvyc/d/v97WxsYFUKsXZs2dL8SyIiIiotKjMSM/XX3+NtWvXAgA0NTWxcuVKjBkzBgCQlJQEADA1Nc31PlNTU6SmpiIjIwMymQxJSUnQ0NDItZBKS0sLxsbGSExMLOUzISIiotKgMkXP1KlT4erqisTERGzduhUTJkyArq4uhg8fjlevXgEAtLW1c71PR0cHwJu1PDKZDK9evYKWllaex9DW1lbsi4iIiJSLyhQ9FhYWsLCwAAAMGTIEXbt2xZQpUzBw4EDFHOHr169zvS8tLQ3A/+cRdXV1kZ6enucx0tLSeDl6KRg0aJDYEZQOP7Oi4edWePzMioafW/mkMkXP+/r164ejR48iNjZWMa2VPc31rqSkJBgbG0MmkwF4M92VlZWFBw8e5JjiSk9PR2pqKmrUqPHB406dOhWVKlXKsW3QoEH8H+AD+NkUHj+zouHnVnj8zIqGn1v+tm/fju3bt+fY9uTJkzI5tsoWPdnTUFKpFDVr1oSJiQnCw8Nz9QsLC4O1tbXi5xYtWgAAwsPD0a1bN8X2iIgIyOXyHH3zsnz5cq7YJyIiykdeAwFRUVFo2bJlqR9b6a/eSklJybUtIyMDmzdvhrGxMZo0aQLgzcjPgQMHkJCQoOgXGBiIa9euYcCAAYptjo6OMDIywurVq3Psc/Xq1dDT00OPHj1K6UyIiIioNCn9SM+YMWPw7NkztG/fHjVq1MC9e/ewdetWXL16FRs2bICGhgYAwNPTE3///TccHBwwefJkPHv2DEuWLEHz5s3h4eGh2J+Ojg7mz5+P8ePHw9XVFV26dEFwcDC2bt2KBQsW5HljQiIiIir/lL7ocXNzg4+PD1avXo2HDx/CwMAAbdq0wapVq9CpUydFPzMzM5w6dQpff/01vv32W2hra6Nnz55YtmyZYj1PtrFjx0Imk2HZsmXw9/eHubk5VqxYgUmTJpX16REREVEJUcnHUIghez4yMjKSa3qIiIgKoay+Q5V+TQ8RERFRQbDoISIiIrXAooeIiIjUAoseIiIiUgsseoiIiEgtsOghIiIitcCih4iIiNQCix4iIiJSCyx6iIiISC2w6CEiIiK1wKKHiIiI1AKLHiIiIlILLHqIiIhILbDoISIiIrXAooeIiIjUAoseIiIiUgsseoiIiEgtsOghIiIitcCih4iIiNQCix4iIiJSCyx6iIiISC2w6CEiIiK1wKKHiNRbcjLwxx+AIIidhIhKGYseIlJvZ88CY8cCZ86InYSIShmLHiJSb507A3XqAH/+KXYSIiplLHqISL1JpcDIkYCvL/D0qdhpiKgUseghIvLwANLSgG3bxE5CRKWIRQ8RUc2aQPfunOIiUnEseoiIAGD0aCAq6s2LiFQSix4iIuDNSE+NGsC6dWInIaJSwqKHiAgANDXfrO3ZuhV48ULsNERUClj0EBFlGznyzRVcf/8tdhIiKgUseoiIstWtCzg5cUEzkYpi0UNE9K7Ro4H//gMuXRI7CRGVMBY9RETv6t0bqFKFC5qJVBCLHiKid2lpAcOHA5s3v7lhIRGpDBY9RETvGzUKSE0F9u4VOwkRlSAWPURE77O0BNq144JmIhXDooeIKC+jRwPHjwNxcWInIaISwqKHiCgv/fsDlStzQTORCmHRQ0SUF11dYMgQYMMGICND7DREVAJY9BAR5Wf0aOD+feDAAbGTEFEJYNFDRJSf5s2B1q25oJlIRbDoISL6kFGjgMOHgTt3xE5CRMXEooeI6EPc3IAKFYD168VOQkTFxKKHiOhDKlYEBg0CfHyArCyx0xBRMWiKHYCIqNwbPfrNpetHjgDduomdRnSCICAtLQ2vXr1SvORyuaINACQSCXR0dKCjowNdXV3o6upCU5NfOSQu/g0kIvqYVq3eLGr+80+VLXqePn2Kmzdv4u7du0hKSlK87t+/j9TUVMXr0aNHePbsWZGOoaOjAyMjIxgbG8PIyAhGRkYwNTVFrVq1UKtWLZiZmcHc3Bzm5ubQ0NAo4TMkYtFDRPRxEsmb0Z6pU4F794Dq1cVOVCRPnjxBbGys4nX9+nXEx8cjPj4eqampOfpWqVIFNWrUQLVq1WBiYgILCwsYGhrC0NAQBgYG0NXVRYUKFaCrqwsdHZ0cozgSiQRyuRyvX7/OMRr07NkzRfH08OFDPHz4EMHBwbhz5w4eP36seL+2tjYaNmwIS0tLWFhYoEmTJmjZsiUaNGgAqZSrMqjoWPQQERXE4MHA9OnAxo3At9+KneaDMjMzceXKFZw7dw7nzp3D2bNnceHCBSQlJSn6mJubo0GDBrC2tkbfvn1Rt25d1KlTB2ZmZqhevTq0tLTKNPPz58+RkJCAW7du4cqVK4iNjcWVK1ewYcMGJCYmAgAMDAxgY2MDW1tb2NnZoUOHDjA2Ni7TnKTcJEL2BCwVS1RUFFq2bInIyEjY2NiIHYeISsPQoUBICHD1KlBORhwEQUB8fDzCwsIQGhqKsLAwREVFIS0tDcCb4sba2hrNmjWDlZUVLC0t0ahRI+jr64ucvOAePnyIyMhIxSs8PBy3b98GAHzyySdwcHCAo6MjHB0doaenJ3JaKoqy+g7lSA8RUUGNHg1s2QKcOgU4OIgSITMzE+fOnUNwcDCCg4Px77//Ijk5GQBQr149tG7dGv3790eLFi3QvHlzGBkZiZKzJBkbG6NLly7o0qWLYtudO3dw4sQJHD9+HH5+flixYgV0dHTQuXNn9O7dGy4uLqhWrZqIqak84khPCeFID5EaEASgcWPAxgbYtq1MDimXy3Hx4kUcO3YMgYGBCAoKwvPnz6GtrY02bdqgXbt2sLe3R6tWrWBiYlImmcobQRBw/fp1+Pv7Y9++fTh9+jQEQYC9vT2GDh0KV1dXGBoaih2TPqCsvkNZ9JQQFj1EamLpUsDLC0hMBEppPUlycjIOHz6Mw4cPIzAwEMnJydDR0cFnn30GR0dHtG/fHra2ttDW1i6V4yu7lJQUHDhwADt37sSRI0cgk8nQq1cvDBs2DF27doVMJhM7Ir2H01tEROXR8OGApyfw11/AlCklsku5XI7IyEj8888/+OeffxAeHg5BEGBra4uRI0eic+fOsLe3h46OTokcT9WZmJjAw8MDHh4eSEpKwrZt27Bp0ya4uLjA1NQUY8eOxVdffaW2I2PqrHysxCMiUhYmJkCfPm/u2VOMgfKMjAwcO3YM48ePh7m5OVq3bo3ly5ejdu3a2LBhA+7du4fw8HAsWLAAjo6OLHiKyNTUFNOmTcP58+cRHR0NFxcXLFy4EObm5vjyyy8RGxsrdkQqQyx6iIgKa/RoICbmzZVchZCeno6DBw9i+PDhqFq1KpycnHDw4EH0798fx48fx4MHD7Bz504MHz6ci3BLgbW1NdasWYPbt29j1qxZ8Pf3R+PGjTFgwADExMSIHY/KAIseIqLC6tQJqFPnzWjPR2RmZiIgIAAjRoxAtWrV0LNnT4SFhWHixImIiopCfHw8VqxYAQcHBz6moYxUqVIFXl5euHnzJtatW4fw8HA0bdoUQ4cOxfXr18WOR6WIRQ8RUWFJpXjh5obXf21BG8susLDohSZNesDDYzpSUlIgCAIiIyMxZcoU1KxZE87OzggODsb48eNx/vx5xMTEYN68eWjRogUkEonYZ6O2tLW1MXLkSFy9ehW//fYbjh8/DktLS4waNSrHjRxJdfCfFUREBZCSkoIZM7wRFhaDtLRMZN2OQ1yWHC2u9MUajAUgR0xMKPz9u8DY+AWuXbuGatWqYfDgwRg8eDBsbGxY4JRTWlpaGDt2LNzd3fHHH3/gp59+gq+vL+bNm4eJEydyBE6FcKSHiOgjkpOTYWc3EBs39kNMzAHcuNEctzL/wkH0wGise9tLCsAOqamrkJVliEOHDiEhIQE///wzWrZsyYJHCejq6mLq1Km4du0ahg8fjmnTpsHW1hahoaFiR6MSwqKHiCgfKSkp8PCYjkaNuiAu7kcAbQFIAMQAaIs/MRotEYUWiHrnXXbQ0akCZ2dnjhAoKUNDQ6xatQqhoaGQSqWws7PDhAkT8PLlS7GjUTHx/0giIuScvsrM1ADwEklJKXj2bA3eFDl27/TWACDBIXTDPHyPB6jyTpv07ftJ2bVq1QphYWFYtWoVPD09cfToUWzZsgWtWrUSOxoVEUd6iEjtvT99dfWqP65etcazZ3/gzejOmyLn/7IACMiCJmZjHu7A/J02OTQ1s8oyPpUiTU1NTJkyBVFRUTAwMICdnR3mzZuHzMxMsaNRESh90RMeHo4JEyagSZMm0NfXR+3atTFw4EBcu3YtV9/Lly/D2dkZFStWhLGxMYYNG4YHDx7kuV8fHx80btwYurq6aNSoEVatWlXap0JEIpk5cwni4hbg/9NXAHD57c9AdpHzf1YA8lvnEYrWra1KJSeJx9LSEv/99x88PT0xd+5cdOrUiVd4KSGlL3oWL16MPXv2wMnJCStXrsSYMWMQFBQEGxsbXLp0SdEvISEB7du3x40bN7Bw4UJ88803OHjwIJycnJCRkZFjn2vWrMHo0aPRrFkzrFq1CnZ2dpg0aRK8vb3L+vSIqJRkr9dp0qQHtm07DKDNez3eHd15v8iZAcATQAgA+dttcgAhqF/fC97eM0oxOYlFJpNh3rx5OHnyJK5fv45WrVohKirq42+k8kNQcv/995+QkZGRY9u1a9cEHR0dYciQIYptY8eOFfT09IQ7d+4oth07dkyQSCTC2rVrFdtevnwpGBsbCy4uLjn2OWTIEEFfX1949OhRnjkiIyMFAEJkZGRJnBYRlaL79+8L9es7CECIAMgFwEV480yJd1/d37YJApAsAA4C8J8AZL3ddk8AhgkymZVQv353wcqqu+Du/o2QnJws9ulRGbh7965ga2sr6OrqCrt37xY7jtIrq+9QpR/psbOzy3WFRIMGDWBlZZXjmSq7d+9Gz549YWZmptjWqVMnNGrUCDt37lRsO3HiBFJTUzFu3Lgc+xw/fjxevHiBgwcPltKZEFFZyT2d9f70FZBzdMcEgC8APwAuAJxQqVIPuLtXxd27J3H9+kFcunQQGzYs4UMs1USNGjVw6tQpuLi4oF+/fliwYAGEYjyLjcqGSl69JQgC7t+/j2bNmgEA7t69i5SUFNja2ubq26pVKxw6dEjxc3R0NADk6mtjYwOpVIqzZ89i8ODBpZieiErS+1dlaWpm4e7d+wDena7OLnDavrNtBoCBALIvVTcBsBhAKOrX90JIyCEWOGquQoUK2LFjB6ysrODl5YXLly/Dx8cHWlpaYkejfKhk0bN161YkJibixx9/BADFYjNTU9NcfU1NTZGamoqMjAzIZDIkJSVBQ0MDVapUydFPS0sLxsbGSExMLP0TIKISkZycDHt7t7ejOt54M6ojB9AVOa/Gyi5wfsKbtT1SAMYAvoG+/peoUaMGAG1oamahdWsreHv7suAhAIBEIsHs2bNhaWmJYcOG4dmzZ9i5cycLn3JK5Yqe2NhYjB8/Hvb29hg+fDgA4NWrVwDePGflfTo6Ooo+MpkMr169yvcvq7a2tmJfRFT+5ZzGyiYFoIU301nZhU/29JU3gPnQ0rqHBg1M3xY4x1ng0EcNHDgQFStWRN++feHq6srCp5xS+jU977p37x569OgBQ0ND7Nq1S3Hbd11dXQDA69evc70nLS0tRx9dXV2kp6fnuf+0tDRFPyIq/8LCYpD7qizgzXTWmfe2mQBYAuB7fPFFJ67RoULr3r079uzZg0OHDsHV1TXf7xISj8qM9Dx58gTdunXD06dPERwcjOrVqyvasqe18rqnQlJSEoyNjSGTyRR9s7Ky8ODBgxxTXOnp6UhNTX07zJ2/qVOnolKlSjm2DRo0CIMGDSryuRFR4SUmJuLu3QfIOY2VLXs6az7e3GlscLuvAAAgAElEQVRZijfTXqFvLzn3LbugpFKyCx+O+ORv+/bt2L59e45tT548KZNjq0TRk5aWBhcXF1y/fh3Hjh2DpaVljvaaNWvCxMQE4eHhud4bFhYGa2trxc8tWrQA8Oamh926dVNsj4iIgFwuz9E3L8uXL4eNjU1xToeIiuHhw4dYvHgxfv31V6Sn10TOaaxsJgC2o1KlrqhZs6ZigTPX61BJeLfw+eKLL7Bz505IpSo1sVIseQ0EREVFoWXLlqV+bKX/U8jKysLAgQMRGhqKv//+G23a5DWUDfTr1w8HDhxAQkKCYltgYCCuXbuGAQMGKLY5OjrCyMgIq1evzvH+1atXQ09PDz169CidEyGiYnn+/DnmzZuHunXrYvXq1Zg+fTrc3Hog/zsn30Dfvk64dOkgrlzx53QWlaju3bvj77//hp+fH7y8vMSOQ28p/UjPtGnTsH//fri4uODBgwfYsmVLjvYhQ4YAADw9PfH333/DwcEBkydPxrNnz7BkyRI0b94cHh4eiv46OjqYP38+xo8fD1dXV3Tp0gXBwcHYunUrFixYgMqVK5fp+RHRh2VkZMDHxwdz5szB48ePMX78eHz77bcwMTFBSkoKQkMHIi7u3auyOI1FZaNXr15YunQppk2bBktLS8XFNSSiUr31YRno2LGjIJVKBYlEkusllUpz9L106ZLQtWtXQU9PTzAyMhKGDh2a791T//zzT8HS0lLQ1tYWGjZsKPzyyy8fzME7MhOVLblcLvj5+QmNGjUSJBKJMGzYMOHWrVu5+iUnJwvu7t8IMll3wcjIhXdOpjIll8uFkSNHCjKZTAgODhY7TrlVVt+hEkHgLSRLQvZ8ZGRkJNf0EJWyiIgITJ06Ff/++y+6dOmCxYsXf3S9Xb16gJsbsGBBGYUkeis9PR1OTk6IiYlBeHg46tSpI3akcqesvkOVfk0PEamPu3fvYvjw4WjVqhUeP36MgIAABAQEfLTgIRKTlpYWdu/eDQMDA/Tu3Zv3exMRix4iKvdevnyJefPmoVGjRvjnn3+wevVqREdHo0uXLmJHIyqQKlWqYM+ePbh69SqmTZsmdhy1xaKHiMotQRDg5+eHxo0b48cff8S4ceNw/fp1fPXVV7keNExU3jVv3hzLli3D6tWr8c8//4gdRy2x6CGicik2NhZdu3ZFv3790LRpU1y6dAlLlizJdfNPImUyduxYODs7Y8SIEUhJSRE7jtph0UNE5crz588xffp0NGvWDDdu3MD+/ftx8OBBNGzYUOxoRMUmkUiwfv16ZGZmYsyYMeC1RGWLRQ8RlQuCIGDPnj1o3LgxfvvtN8yZMwcXL15Ez549xY5GVKJMTU2xZs0a7N27F7t37xY7jlph0UNEoouPj4eLiws+//xzWFtb49KlS/Dy8oKOjo7Y0YhKRb9+/dCrVy9MnjwZT58+FTuO2mDRQ0SiycjIwKJFi9CkSROcO3cOe/bsgb+/P+rWrSt2NKJSt3LlSjx+/Bg//PCD2FHUBoseIhJFWFgYbG1tMWvWLIwbNw6XL19Gnz59IJHk9VR0ItVTu3ZtzJ07F7/++iuio6PFjqMWWPQQUZl6/vw5pk6dCjs7O2hqaiI8PBxLly6Fvr6+2NGIytzkyZNhaWmJKVOmcFFzGWDRQ0Rl5ujRo2jatCnWrFmDxYsXIzQ0FC1atBA7FpFoZDIZlixZgqCgIAQEBIgdR+Wx6CGiUvfkyROMGjUKXbp0QYMGDXDx4kV88803vMEgEYBu3brB3t4e33//PUd7ShmLHiIqVYcOHULTpk2xc+dOrFmzBkePHkW9evXEjkVUbkgkEvz444+IiIiAv7+/2HFUGoseIioVjx8/hoeHB7p3744mTZrg4sWLGDNmDBcqE+XBwcEBjo6O+P777yGXy8WOo7JY9BBRiTt27BiaNWsGPz8/+Pj44NChQzA3Nxc7FlG5Nn/+fFy4cAF+fn5iR1FZLHqIqMS8fPkSEydOhJOTEywsLHDhwgWMGDGCoztEBWBvb4+OHTti2bJlYkdRWSx6iKhEhIWFoUWLFvDx8cHKlStx5MgRju4QFdLXX3+NM2fOICQkROwoKolFDxEVS2ZmJubNmwd7e3tUrlwZ0dHRmDhxIqRS/nohKqwePXqgYcOG+Pnnn8WOopL4W4mIiuzGjRvo0KED5s6dCy8vL/z777+wsLAQOxaR0pJKpZgyZQr8/Pxw+/ZtseOoHBY9RFQkW7ZsgbW1NZKSkhAcHIy5c+dCJpOJHYtI6Q0bNgx6enrw8fERO4rKYdFDRIXy7NkzDB06FEOHDkWfPn1w9uxZ2Nvbix2LSGXo6+tjwIAB+Ouvv3j5eglj0UNEBRYVFQUbGxvs3bsXW7ZswebNm2FgYCB2rA9KSUmBh8d0JCT0wJo1vdCkSQ94eExHSkqK2NGI8jV8+HDEx8fj9OnTYkdRKSx6iOijBEHAL7/8grZt28LAwADR0dEYPHiw2LE+Kjk5GXZ2A7FxYz9kZBxAaqo/YmL2Y+PGfrCzG8jCh8qtzz77DHXq1MHmzZvFjqJSWPQQ0Qelpqaid+/emDJlCiZMmID//vsPDRo0EDtWgcycuQRxcQsAtAWQfa8gKYC2iIv7CTNmeIsXjugDpFIphg4dip07d+LVq1dix1EZLHqIKF9hYWGwsbHB6dOn4e/vj59//hna2tpixyqwsLAYAG3yaW3ztp2ofBo8eDCePn2Ko0ePih1FZbDoIaJcBEHAqlWr8Nlnn6F69eqIjo6Gi4uL2LEKLTNTA/8f4Xmf9G07UflkYWEBCwsL7Nu3T+woKoNFDxHl8OzZM7i5uWHixIkYP348goKClPbOypqaWQCEfFrlb9uJyq/evXtj//79yMri39WSwKKHiBQuXboEW1tbHD58GLt27cLy5cuhpaUldqwia93aCkBoPq2hb9uJyq/evXsjJSUFZ86cETuKSmDRQ0QAAF9fX7Rp0wba2tqIiIhAv379xI5UbN7eM1C/vieAEADZ9zuRAwhB/fpe8PaeIV44ogJo06YNqlatyimuEsKih0jNZWZm4ptvvoGbmxt69eqFkJAQNGzYUOxYJcLExAQhIb5wd/eDTOYCI6NesLJygbu7H0JCfGFiYiJ2RKIP0tDQgJOTEwIDA8WOohI0xQ5AROJJSUnBwIEDERQUhBUrVmDSpEmQSPJb+KucTExMsGHDEpw6Bbi5AQsWiJ2IqHAcHR2xbds2PHr0CIaGhmLHUWoc6SFSU9HR0bC1tcWlS5cQGBiIyZMnq1zBQ6QKHBwcIAgCgoKCxI6i9Fj0EKmhHTt24NNPP0XVqlURGRmJDh06iB2JiPJRt25d1KlTBydOnBA7itJj0UOkRuRyOTw9PTFo0CD069cPQUFBMDMzEzsWEX1Ehw4dEBwcLHYMpceih0hNPH36FH369MHixYuxdOlSbN68Gbq6umLHIqICaN26NS5cuIC0tDSxoyg1LmQmUgM3b96Ei4sLbt++jQMHDqBbt25iRyKiQmjZsiUyMjJw4cIFtGrVSuw4SosjPUQq7vTp02jdujVevnyJM2fOsOAhUkLNmzeHpqYmIiMjxY6i1Fj0EKmwLVu2wNHREY0bN0ZoaCgaN24sdiQiKgJdXV00adIEERERYkdRaix6iFSQIAj44YcfMHToUAwePBhHjx5FlSpVxI5FRMVgbW2N8+fPix1DqbHoIVIxr1+/xpAhQzB//nwsXLgQPj4+Sv38LCJ6o3Hjxrhy5QoEIb+H6NLHcCEzkQpJTU1F3759ERoaCl9fX7i6uoodiYhKiIWFBZ4+fYp79+7B1NRU7DhKiUUPkYqIj49H9+7dkZKSgsDAQHz66adiRyKiEmRpaQkAiI2NZdFTRJzeIlIB4eHhaNu2LTIyMhASEsKCh0gF1a9fH5qamoiNjRU7itJi0UOk5A4dOoSOHTuiXr16KvWEdCLKSSaTwczMDLdu3RI7itJi0UOkxDZv3oxevXrB0dERgYGBMDExETsSEZWiWrVq4c6dO2LHUFoseoiUkCAI8Pb2xvDhwzFs2DDs2bMHFSpUEDsWEZUyFj3Fw6KHSMnI5XJ8/fXXmDlzJmbNmoV169ZBU5PXJBCpg1q1aiEhIUHsGEqLvymJlEhGRgY8PDywbds2/Pbbbxg3bpzYkYioDJmZmSEhIQGCIEAikYgdR+mw6CFSEq9evYKrqysCAgKwY8cO3oOHSA1VqVIFGRkZeP78OSpWrCh2HKXDoodICTx9+hS9evVCWFgY/P394ezsLHYkIhKBsbExgDc3ImXRU3hc00NUzqWkpMDBwQFnz57F0aNHWfAQqTEjIyMAwMOHD0VOopw40kNUjt29exedO3fGo0ePcOrUKXzyySdiRyIiEWUXPampqSInUU4c6SEqp27duoX27dvjxYsXCA4OZsFTRCkpKfDwmI6EhB5Ys6YXmjTpAQ+P6UhJSRE7GlGhVa5cGQDw+PFjkZMoJ470EJVD169fh6OjI2QyGYKDg1G7dm2xIyml5ORk2Nu7IS5uAQBvpKZKkJoqR0xMGIKDByIkxJc3dCSloqurC+DNhQ1UeBzpISpnYmJi0L59e+jp6SEoKIgFTzHMnLnkbcHTFkD25b1SAG0RF/cTZszwFi8cURFoa2tDIpGw6CkiFj1E5cj58+fRsWNHVKlSBSdPnkTNmjXFjqTUwsJiALTJp7XN23Yi5SGRSKCjo8Oip4hY9BCVE9HR0XBwcIC5uTlOnDiBatWqiR1J6WVmauD/Izzvk75tJ1IuLHqKjmt6iMqB6OhodOrUCfXr18fRo0cVixWpeDQ1swAIyLvwkb9tJ1IumpqakMvlYsdQShzpIRIZC57S07q1FYDQfFpD37YTkbpg0UMkIhY8pcvbewbq1/cEEAIg+1/GcgAhqF/fC97eM8QLR1REgiCIHUFpseghEgkLntJnYmKCkBBfuLv7QSZzgZFRL1hZucDd3Y+Xq5NS48NGi4ZreohEcOHCBTg5ObHgKQMmJibYsGEJTp0C3NyABQvETkRUPBzpKTqO9BCVsdjYWHTu3Bm1atXCkSNHWPAQUaGkpaVBR0dH7BhKSSWKnhcvXmD27NlwdnaGkZERpFIpNm3alGffy5cvw9nZGRUrVoSxsTGGDRuGBw8e5NnXx8cHjRs3hq6uLho1aoRVq1aV5mmQGoiLi0OnTp1gYmKCo0ePwtDQUOxIRKREBEHAq1evFHdmpsJRiaInJSUF8+fPx5UrV2BtbQ0g7/nOhIQEtG/fHjdu3MDChQvxzTff4ODBg3ByckJGRkaOvmvWrMHo0aPRrFkzrFq1CnZ2dpg0aRK8vXkHVyqa27dvw9HREfr6+jh27BiqVKkidiQiUjLp6emQy+UseopIJdb01KhRA/fu3UPVqlURGRmJVq1a5dlvwYIFePXqFaKjo2FmZgYAaN26NZycnLBx40aMHj0awJtnmnh5eaFnz57YuXMnAGDkyJGQy+WYP38+xowZwykJKpSkpCR06tQJGhoaCAwMRPXq1cWORERKKPumhCx6ikYlRnq0tLRQtWpVAB9e4LV792707NlTUfAAQKdOndCoUSNFcQMAJ06cQGpqKsaNG5fj/ePHj8eLFy9w8ODBEj4DUmWpqalwcnJCWloaAgMDc/z9IyIqjBcvXgAA9PT0RE6inFSi6CmIu3fvIiUlBba2trnaWrVqhejoaMXP2f/9fl8bGxtIpVKcPXu2dMOSynj+/Dm6d++O+/fv4+jRo6hbt67YkYhIiT169AgAYGRkJHIS5aQS01sFkZSUBAAwNTXN1WZqaorU1FRkZGRAJpMhKSkJGhoaudZcaGlpwdjYGImJiWWSmZRbWloa+vTpg5iYGJw4cQKWlpZiRyIiJZeamgoAvAiiiNRmpCd7HlRbWztXW/alf9l9Xr16BS0trTz3o62tzQe90UdlZmZi0KBBOH36NPbv34+WLVuKHYmIVABHeopHbUZ6shd9vX79OldbWlpajj66urpIT0/Pcz9paWlcQEYfJAgCRo8ejf3792Pv3r3o0KGD2JGISEVkFz0c6SkatSl6sqe1sqe53pWUlARjY2PIZDJF36ysLDx48CDHFFd6ejpSU1NRo0aNfI8zdepUVKpUKce2QYMGYdCgQSVxGqQEPD09sXHjRvz111/o2bOn2HGISIUkJyejUqVKiu8rZbR9+3Zs3749x7YnT56UybHVpuipWbMmTExMEB4enqstLCxMcX8fAGjRogUAIDw8HN26dVNsj4iIgFwuz9H3fcuXL4eNjU0JJidlsnLlSixatAhLly7FkCFDxI5DRComKSkpz7WpyiSvgYCoqKgyWQagNmt6AKBfv344cOAAEhISFNsCAwNx7do1DBgwQLHN0dERRkZGWL16dY73r169Gnp6eujRo0eZZSblsXPnTkyZMgXTpk3DtGnTxI5DRCooMTHxg7MN9GEqM9KzatUqPH78WHFllb+/P27fvg0AmDRpEgwMDODp6Ym///4bDg4OmDx5Mp49e4YlS5agefPm8PDwUOxLR0cH8+fPx/jx4+Hq6oouXbogODgYW7duxYIFC3hjQsrl+PHjGDp0KL744gvetZuISk1SUhLMzc3FjqG0VKboWbZsGW7dugXgzSMo9uzZAz8/P0gkEgwbNgwGBgYwMzPDqVOn8PXXX+Pbb7+FtrY2evbsiWXLluWaHx07dixkMhmWLVsGf39/mJubY8WKFZg0aZIYp0fl2Pnz59GnTx907NgR69evh1SqVgOoRFSGEhMT0aZNG7FjKC2VKXri4+ML1M/KygqHDx8uUN9Ro0Zh1KhRxYlFKu7u3bvo3r07GjRogF27duV7qwMiouLKysrC7du3Ubt2bbGjKC3+k5SoiJ4+fYoePXpAKpXi4MGDqFixotiRiEiFJSYmIiMjg3d2LwaVGekhKksZGRlwdXVFfHw8Tp8+rfRXUxBR+Zc9o8Gip+hY9BAVkiAIGD9+PAIDA3H48GE0bdpU7EhEpAayi546deqIG0SJseghKqQlS5bgzz//xIYNG9CpUyex4xCRmrhx4waqV6+OChUqiB1FaXFND1Eh7NmzBzNnzoSXlxfc3d3FjkNEaiQ2NpYPLi4mFj1EBRQdHY0hQ4agf//+mDdvnthxiEjNXL58mUVPMbHoISqApKQkuLi4wMrKCps2beK9eJRISkoKPDymIyGhB9as6YUmTXrAw2M6UlJSxI5GVGBZWVm4evUqGjduLHYUpcY1PUQf8erVK/Tu3RsAsG/fPs6nK5Hk5GTY27shLm4BAG+kpkqQmipHTEwYgoMHIiTEFyYmJmLHJPqomzdv4vXr1xzpKSb+c5XoAwRBwKhRo3Dx4kXs27ePz7xRMjNnLnlb8LQFIHm7VQqgLeLifsKMGXxkCCmHixcvAnhzg10qOhY9RB/g7e2Nbdu2YePGjWXyBGAqWWFhMQDyu2V/m7ftROXfuXPnYGxsjJo1a4odRamx6CHKxz///IPvvvsOs2bNgqurq9hxqAgyMzXw/xGe90nfthOVf2fPnsUnn3wCiSS/v89UECx6iPJw5coVDBo0CC4uLpg7d67YcaiINDWzAAj5tMrfthOVf2fPnoW1tbXYMZQeix6i9zx9+hR9+vRBzZo18ddff/FKLSXWurUVgNB8WkPfthOVb0+fPkV8fDw++eQTsaMoPf42J3qHXC7H8OHDkZiYiL1798LAwEDsSFQM3t4zUL++J4AQAPK3W+UAQlC/vhe8vWeIF46ogCIiIgAAtra2IidRfix6iN6xaNEi7N27F1u2bEGjRo3EjkPFZGJigpAQX7i7+0Emc4GRUS9YWbnA3d2Pl6uT0ggLC0PFihVhYWEhdhSlx/v0EL0VEBCAWbNm4YcffoCLi4vYcaiEmJiYYMOGJTh1CnBzAxYsEDsRUeGEhoaiVatW0NDgwvvi4kgPEd7c+GvQoEFwdnbG7NmzxY5DRKQQFhaG1q1bix1DJbDoIbX3+vVrDBgwAJUrV8bWrVu5cJmIyo07d+4gMTERbdrkd78pKgxOb5Ha+/rrr3HhwgX8999/MDQ0FDsOEZFCcHAwAODTTz8VOYlqYNFDam3Hjh34/fff8ccff8DGxkbsOEREOQQHB8PS0pKL7ksIx/FJbcXGxmLUqFEYPHgwxowZI3YcIqJcgoKC0K5dO7FjqAwWPaSWXr58if79+8Pc3Bx//PEHb+1OROXOw4cPERMTw6KnBHF6i9TSpEmTEB8fj/DwcOjr64sdh4gol1OnTgEA2rdvL3IS1cGih9TO9u3b4ePjg/Xr18PKio8hIKLyKTAwEA0aNEDt2rXFjqIyOL1FaiUuLg5ffvklvvjiC7i7u4sdh4goX8eOHUPnzp3FjqFSWPSQ2khPT4ebmxuqVq2K1atXcx0PEZVbd+7cwdWrV1n0lDBOb5Ha8PT0xLlz5xASEsIHiRJRuXbs2DFIJBI4ODiIHUWlsOghtXDkyBEsW7YMy5YtQ8uWLcWOQ0T0QYcPH4atrS2MjIzEjqJSOL1FKi8lJQXDhw9Hly5dMGXKFLHjEBF9UGZmJgICAtCjRw+xo6gcFj2k0gRBwOjRo5GRkYGNGzfyuVpEVO6FhITgyZMn6N69u9hRVA6nt0ilrVu3Dvv27cPevXthamoqdhwioo86ePAgTExMOBVfCvjPXlJZ169fx5QpUzB69Gj07t1b7DhERAVy8OBBODs7c2S6FPATJZWUlZWFYcOGwdTUFD///LPYcYiICuT69eu4ePEi/6FWSji9RSppyZIlCA0NRVBQEB8zQURKY9++fdDR0YGzs7PYUVQSR3pI5Zw7dw4//PADpk+fjk8//VTsOEREBbZnzx44OTlBT09P7CgqiUUPqZTXr19j6NChsLS0xNy5c8WOQ0RUYPfv38d///2Hvn37ih1FZXF6i1TKjz/+iMuXLyM8PBza2tpixyEiKrC9e/dCKpWiZ8+eYkdRWRzpIZURFRWFhQsXYtasWbC2thY7DpUTKSkp8PCYjoSEHlizpheaNOkBD4/pSElJETsaUQ6+vr5wdHSEiYmJ2FFUFkd6SCWkp6fDw8MDTZs2xXfffSd2HConkpOTYW/vhri4BQC8kZoqQWqqHDExYQgOHoiQEF9+wVC5cO/ePZw6dQpr1qwRO4pK40gPqYSFCxciJiYGGzZsgJaWlthxqJyYOXPJ24KnLQDJ261SAG0RF/cTZszwFi8c0Tt2794NqVSKzz//XOwoKq3QRU9cXBwOHjyI0NBQyOXyPPtcuHAB8+bNK3Y4ooI4f/48fvzxR3z33Xdo0aKF2HGoHAkLiwHQJp/WNm/bicTn6+sLJycnPmC0lBW46JHL5XB3d0fDhg3h4uICOzs7NGrUCIcPH87V99y5c7xyhspEVlYWRo0aBQsLC3h5eYkdh8qZzEwN/H+E533St+1E4rp16xaCg4Ph5uYmdhSVV+CiZ+3atdi8eTM8PDywb98+rFmzBtra2ujevTsWLFiQq78gCCUalCgvv/76KyIiIrBu3TperUW5aGpmAcjvd5H8bTuRuLZu3YoKFSpwaqsMFHgh89q1a9G3b1/4+Pgotg0fPhwTJkzArFmzcPfuXfz222+lEpIoLzdv3oSXlxcmTJiAtm3bih2HyqHWra0QExOKN2t63heK1q2tyjoSUQ6CIOCvv/5C3759eff4MlDgkZ7r16/nui22lpYW1q5di8WLF+OPP/6Aq6srMjIySjwk0fsEQcDYsWNhbGyMn376Sew4VE55e89A/fqeAEIAZK9BlAMIQf36XvD2niFeOCIA0dHRiI2NxZAhQ8SOohYKXPTo6+vj6dOnebZNnz4dPj4+8PPzQ7du3fDs2bMSC0iUF19fXxw+fBi///47KlasKHYcKqdMTEwQEuILd3c/yGQuMDLqBSsrF7i7+/FydSoXNm/ejGrVqqFz585iR1ELBZ7eatq0KY4cOYJp06bl2e7u7g5DQ0O4ubkhJCQEEkl+iweJiufJkyeYOnUq+vXrxzuX0keZmJhgw4YlOHUKcHMD8liCSCSK169fY8uWLXB3d4emJm+bVxYKPNLTu3dvHDt2DJcvX/5gn4CAAMhkMi5kplIza9YsPH/+HCtWrBA7ChFRkfn7++Phw4cYOXKk2FHURoFLyxEjRqBDhw6oWrXqB/u1b98e586dQ3x8fLHDEb0vIiICv/32G5YtWwYzMzOx4xARFZmPjw/s7OzQuHFjsaOojQIXPbq6umjatGmB+tauXRu1a9cuciiivGRlZeGrr75C8+bNMXHiRLHjEBEV2e3bt3HkyBGsXbtW7ChqhZOIpDTWrl2LyMhI/Pfff5z/JiKltmHDBlSoUAEDBw4UO4pa4bO3SCk8fPgQs2bNwogRI2BnZyd2HCKiIsvMzMSff/6JwYMH8+rTMsaih5SCl5cXsrKysHDhQrGjEBEVy4EDB3D37l2MHTtW7Chqh3MEVO5FRUVh7dq1WL58+UcX0hMRlXerV69G27ZtYW1tLXYUtcOih8o1QRAwYcIEWFlZYdy4cWLHISIqlri4OBw5cgQbN24UO4paYtFD5dr27dsREhKCwMBAyGQyseMQERXLqlWrYGxsDFdXV7GjqKUiFz1JSUnw8fFBdHQ0njx5ArlcrmgTBAESiQTHjx8vkZCknl6+fIlvv/0Wffr0gaOjo9hxiIiK5dmzZ1i/fj3GjRsHXV1dseOopSIVPefPn0eHDh2QlpaGRo0a4cKFC2jSpAkePXqExMRE1KtXD7Vq1SrprKRmli1bhnv37mHJkiViRyEiKrZNmzbhxYsXnKoXUZGu3vr222+hr6+P2NhYBAYGAgBWrFiBhIQE+Pr64vHjx1i8eHGJBiX1kpiYiEWLFmHSpElo0KCB2HGIiIpFLpfj119/xeeff85BAREVqeg5ffo0vvzyS9SuXVvxYNHsZ20NGDAAX3zxBb755puSS0lqx8vLCxUqVMD3338vdhQiolBOE7AAACAASURBVGILCAjA1atXMXnyZLGjqLUiFT1yuRzVq1cHAFSuXBkaGhpITU1VtDdr1gyRkZElk5DUzvnz57Fp0ybMnj0blSpVEjsOEVGxLV26FLa2trC3txc7ilorUtFTp04dxQNFNTQ0UKdOHRw9elTRHhISgsqVK5dMQlI73377LRo0aIAvv/xS7ChERMUWFRWF48ePY/r06YrZERJHkRYyd+3aFTt37sRPP/0EABg3bhymTZuG+Ph4yOVynDx5EtOmTSvRoKQejh8/jkOHDmHXrl28RJ2IVMKyZctQt25dfP7552JHUXtFKnq8vLzg5uaG9PR0aGlpYcqUKXjx4gV27doFTU1N/PDDD/D09CzprKTi5HI5ZsyYgbZt2/KXAxGphFu3bsHX1xfLly/ng5LLgSJNbxkaGsLW1hZaWloAAIlEglmzZuHs2bOIiIjAnDlzFG3K6vXr15g5cyZq1KiBChUqoG3btjh27JjYsVTarl27EBkZCW9vbw4BE5FKWL58OQwMDDBixAixoxD4wNF8ubu7Y/ny5Rg6dChWrlwJDQ0NdO/eHadPnxY7mkrKzMzE999/j+7du6Ndu3ZixyEiKraUlBSsXbsWkyZNgp6enthxCMW4I/PNmzexadMmxMfH49GjR4pL1t/l7+9frHBiCQsLg6+vL5YuXYqvv/4aADB06FA0bdoUM2bMYOFTCjZv3oyrV69ix44dYkchIioRv/zyC6RSKSZOnCh2FHqrSEXP9u3bMWzYMGRlZaFy5cowMDDI1UeZpyey1yaNGTNGsU1bWxsjR46Ep6cn7t69i5o1a4qYULW8fv0ac+bMwYABA9CiRQux4xARFduTJ0+w6n/s3XdYFFfbBvB7VkAQEBGVYglqRKxgxWCv2FEDohGxJ7HwqvFT0cQUS1T0jcYWscSCCGpMxCixi4piQ+xgJSqKLWBD+p7vj7xu3IAISxl29/5dF5fu2bOz95xs3IczM2eWLcPnn38OKysruePQ/2hU9EybNg2Ojo7Yvn07HBwcCjuT7KKjo+Hg4AAzMzO19mbNmgEAzp8/z6KnEAUEBOD+/fuYNWuW3FFIBz158gRTpvgjPv4qAgJKITQ0C82b14W//xRUrFhR7niko1asWIGUlBTV0QIqGTQqep4+fYopU6boZMED/H0zVVtb22ztb9oePHhQ3JF0VkpKCubOnQsfHx/Url1b7jikYx4/fgxX1wG4det7AP5ITJSQmKjE1aunceyYFyIjt7DwoUL36tUr/Pe//8Xw4cNhZ2cndxx6i0YnMjdv3hx3794t7CwlRkpKCkqXLp2t3djYWPU8FY6AgAA8efIEX331ldxRSAdNnbrgfwVPCwBvDrkrALTArVtzMGWKv3zhSGctX74cL168wLRp0+SOQv+iUdGzePFibNy4Edu2bSvsPCWCiYkJ0tLSsrWnpqaqnqeCS0lJwfz58+Hj44OaNWvKHYd00OnTVwG4vONZl/89T1R4Xr16hQULFmDEiBGoVq2a3HHoXzQ6vNWwYUPMnDkTXl5eGDlyJKpUqYJSpUqpnhdCQJIkXLx4sdCCFidbW9scD2ElJCQAQK7TlRMnTsx2v6iBAwdi4MCBhRtSB7yZ5fnyyy/ljkI6KjOzFP6Z4fk3xf+eJyo8nOV5v+DgYAQHB6u1PX/+vFjeW6OiZ/ny5fD19YWJiQlq1KiR400htfnqrUaNGiE8PBwvX76Eubm5qv3UqVMAAGdn53e+dtGiRWjcuHGRZ9R2nOWh4mBgkAVAIOfCR/m/54kKx8uXL7Fw4ULO8rxHThMB586dQ5MmTYr8vTUqeubOnQtXV1fs3r1bJ++C7eHhgYULF2LVqlWqe4ilpaVh3bp1aNGiBa/cKgQ///wzHj9+zNuVUJFq3rwurl49hb/P6fm3U2jevG5xRyId9uOPP+LFixf8d60E06joef78Oby9vXWy4AH+PlHb09MT06ZNw+PHj1GzZk1s2LABd+/exbp16+SOp/UyMjLg7+8PLy8vfPjhh3LHIR3m7z8Fx4554datOfj73B4FACWAU6hZ80v4+2+RNyDpjMTERCxYsABjxoxB1apV5Y5D76BR0dOmTRtcunSpsLOUKBs3bsSMGTMQGBiIpKQkODk5YdeuXWjVqpXc0bTe5s2bcffuXezatUvuKKTjKlasiMjILZgyxR+nT89GZmYpGBi8WaeHl6tT4fH390dWVhbP5SnhJJHT/SPe486dO+jevTt8fHwwcuRIrjaJf45HRkVF8ZyeXGRlZaFevXqoXbs2QkND5Y5DRFRgCQkJqFmzJiZNmsRFVjVUXN+hGs301K9fX1XRTps2DSYmJlAo/r76XZIk1dVbL168KNSwpP127tyJa9euYf369XJHISIqFLNnz4axsbHqHFAquTQqej7++OP39tHmq7eo6CxYsABt2rRBixY5nVhKRKRdrl+/joCAAMybNw/lypWTOw69h0ZFD39LJ02cOHECkZGR2Llzp9xRiIgKxfTp01G5cmWMGzdO7iiUBxoVPUSaWLBgARwdHdGjRw+5oxARFVhkZCS2b9+OjRs3qm5TRCWbRkXPhg0bcj18JUkSjI2NUaVKFTRu3DjH+1iRfrl+/TpCQ0OxatUq1flfRETaSgiByZMnw8nJCYMGDZI7DuWRRkXPsGHD8tzXwsICfn5+mDp1qiZvRTpiyZIlqFixIry9veWOQkRUYL/++iuOHz+OvXv38hc5LaJR0RMdHY0hQ4agQoUKGDt2rOo2Ajdv3sTy5cuRlJSEpUuX4smTJ1i6dCmmTZsGc3NzjBkzplDDk3Z49uwZ1q9fj0mTJnEKmIi0XlpaGqZMmYLu3bujS5cucsehfNCo6Fm0aBGsra2xZ88etcNcDRs2RJ8+fdCtWzesXr0a69evR69evdCmTRv89NNPLHr01Lp165Ceno7PP/9c7ihERAX2448/4s6dO1xgVQtpNCcXGhqKPn365Hhej0KhQO/evVULz5UqVQr9+vXDjRs3CpaUtFJWVhaWLVuG/v37w9bWVu44REQF8ujRI8yePRtjxoxBnTp15I5D+aTRTE9WVhZiY2Pf+fy1a9egVCpVj0uXLs3DGnoqLCwMt2/fRnBwsNxRiIgKbMaMGTAwMMA333wjdxTSgEYzPe7u7lixYgWWLl2K1NRUVXtKSgqWLFmCn376Cb169VK1nzx5kjeW1FPLly9H8+bN0bx5c7mjEBEVyNmzZ7FmzRp8++23vP2SltJopmfx4sW4desWxo8fj8mTJ8PW1hZCCCQkJCAjIwPNmzfHjz/+CABITU3l8tx66vbt29i7dy/vTE9EWk+pVMLX1xf16tXj+alaTKOix8rKChEREdixYwf27NmDO3fuAAC6dOmCrl27ok+fPqpL+IyNjbFmzZrCS0xaIyAgAOXKlYOXl5fcUYiICiQwMBAnT55EeHg4DAy4rq+20vi/nEKhQL9+/dCvX7/CzEM6Ii0tDT///DOGDh0KExMTueMQEWns+fPnmDp1KgYMGIC2bdvKHYcKgCsqUZH49ddf8fTpU3z22WdyRyEiKpBvvvkGL1++xIIFC+SOQgWUp5me6tWrQ5IkXLt2DYaGhqrHQohsfd+0S5KE27dvF3pg0g5r1qxB69at4ejoKHcUIiKNRUdHY+nSpZg3bx6qVKkidxwqoDwVPW3btoUkSap1efIyvZfbvblIt8XFxeHQoUNYv3693FGIiDSWlZWFzz//HHXr1sWECRPkjkOFIE9Fz7+/vPhlRrlZt24dzM3N4eHhIXcUIiKNrV69GqdPn8axY8dgaGgodxwqBDynhwpVVlYW1q1bh4EDB8LU1FTuOEREGnn8+DGmTZuG4cOHo1WrVnLHoUKiUdETHR2dbYXdPXv2oHXr1nBxccHixYsLJRxpn8OHDyM+Ph7Dhw+XOwoRkcYmTpyIUqVKYf78+XJHoUKkUdEzdepUbNmyRfU4Li4O/fr1w59//gkhBL744gsEBAQUWkjSHoGBgahVqxZXYCYirfXHH39g8+bN+OGHH1ChQgW541Ah0qjouXDhAlq2bKl6vHHjRigUCpw7dw6nT5+Gp6cnix49lJycjF9//RWDBw/miexEpJWSk5MxevRodO7cGYMHD5Y7DhUyjRYnfP78uVr1GxYWhs6dO6NixYoAgE6dOiEsLKxwEpLWCA0NxatXrzBo0CC5oxARaWTGjBl4/PgxDh06xF/edJBGMz02Nja4evUqACAhIQFRUVHo0qWL6vlXr16pbkNB+iMwMBAtW7ZEjRo15I5CRJRvp0+fxo8//oiZM2fy3zEdpdFMT58+fbB06VKkpaXh5MmTMDIyQt++fVXPX7x4kR8YPfP06VPs378fS5YskTsKEVG+paWlYdiwYWjUqBHX5NFhGhU9s2bNwpMnT7Bx40ZYWlpiw4YNsLGxAfD3oa9t27Zh7NixhRqUSrZff/0VQgiuzUNEWmnmzJm4ceMGoqKieENRHabRf1lzc3MEBQW987n4+Hiu0aJntmzZgvbt26NSpUpyRyEiypeoqCjMnz8f33zzDRo0aCB3HCpChX7ijUKhQLly5bh6pR559OgRwsPD4eXlJXcUIqJ8SU9Px7Bhw9CgQQP4+fnJHYeKGOfwqMB+/fVXSJKEfv36yR2FiChfZs+ejZiYGJw9e5a/rOsBXmJFBfbbb7+hffv2sLKykjsKEVGenT59Gt9//z2++uorODk5yR2HigGLHiqQpKQkHD58GH369JE7ChFRnqWkpMDHxweNGjXC9OnT5Y5DxYSHt6hAwsLCkJmZCXd3d7mjEBHl2bRp03Dnzh2cO3eOh7X0CIseKpDffvsNzZo1Q5UqVeSOQkSUJ4cOHcKPP/6IxYsXo06dOnLHoWLEw1uksbS0NOzZs4ezPESkNZKSkjB06FC0b98evr6+csehYsaihzR27NgxJCcno2fPnnJHISJ6LyEERo8ejZcvX2LDhg28XZIe4uEt0lhYWBgqV66Mhg0byh2FiOi9Nm3ahC1btiAkJARVq1aVOw7JgGUuaSwsLAzdu3fnnYiJqMS7ffs2xo4di8GDB3MhVT3Gooc0cvv2bVy7dg3du3eXOwoRUa4yMjIwaNAgVKxYEcuWLZM7DsmIh7dII3v37oWBgQE6duwodxQiolx9++23OHPmDCIiIlC2bFm545CMWPSQRg4ePAgXFxeYm5vLHYWI6J0OHDiAuXPn4vvvv0eLFi3kjkMy4+EtyresrCwcOnQInTp1kjsKEdE7PXr0CN7e3ujUqROmTJkidxwqAVj0UL5FR0cjKSmJRQ8RlVhKpRI+Pj4AgMDAQF6eTgB4eIs0cPDgQZiamqJ58+ZyRyEiytGCBQuwb98+7Nu3D9bW1nLHoRKCpS/l25EjR9CyZUsYGRnJHYWIKJujR4/iyy+/xPTp09G5c2e541AJwqKH8iUrKwvHjx9H69at5Y5CRJTNo0ePMGDAALRu3Rrfffed3HGohGHRQ/ly6dIlvHjxAm3atJE7ChGRmqysLHzyyScQQiA4OBgGBjyDg9TxE0H5cuzYMRgZGfF8HiIqcb799luEh4fj4MGDsLGxkTsOlUAseihfIiIi0LRpUxgbG8sdhYhIJSwsDHPmzMGcOXPQrl07ueNQCcXDW5Qvp06dwkcffSR3DCIildu3b8Pb2xs9e/bE1KlT5Y5DJRiLHsqzR48e4c6dOzy0RUQlxuvXr9G3b1+UL18eGzdu5Ho8lCse3qI8O336NADAxcVF5iRERIAQAqNGjcLNmzdx6tQplCtXTu5IVMKx6KE8O336NCpVqoRq1arJHYWICEuWLMHmzZsREhKC+vXryx2HtADnASnPzp49i6ZNm0KSJLmjEJGeO3ToECZNmoRJkybBy8tL7jikJVj0UJ5duHABzs7OcscgIj0XFxeH/v37o0OHDpg3b57ccUiLsOihPHn8+DESEhLg5OQkdxQi0mOvXr1C3759YWFhgZCQEC5ASPnCTwvlyYULFwAAjRo1kjkJEekrpVKJIUOG4NatW4iMjET58uXljkRahkUP5cn58+dhamqKmjVryh2FiPTUd999h99++w07duzgicukERY9lCdXr15F3bp1uQYGEckiJCQEM2fOxJw5c9C7d2+545CW4jcY5UlsbCzq1Kkjdwwi0kOnTp3C0KFD4e3tjWnTpskdh7QYix56LyEEYmJi4OjoKHcUItIz9+7dg7u7O5o0aYLVq1dzyQwqEBY99F6PHj3C8+fPOdNDRMXq5cuX6NmzJ4yNjfHbb7/xRsdUYDynh94rNjYWAFC7dm2ZkxCRvsjMzMSAAQMQFxeHEydOoFKlSnJHIh3Aoofe6/bt2wCA6tWry5yEiPSBEAK+vr7Yu3cvdu/ezSu1qNBo/eGthw8fws/PD+3bt4e5uTkUCgWOHDnyzv4nTpxAq1atYGpqCltbW4wfPx7JycnZ+gkh4O/vj+rVq8PExAROTk4ICQkpyl0pseLi4mBnZ8epZSIqFgsXLsTKlSsREBAANzc3ueOQDtH6oic2Nhb+/v5ISEhAw4YNAeCdJ7qdP38eHTt2RGpqKhYtWoSRI0di1apV8PT0zNZ3+vTp8PPzg5ubG5YtW4Zq1arhk08+wZYtW4p0f0qiuLg4zvIQUbHYtm0bpkyZgi+//BIjRoyQOw7pGK0/vNW0aVMkJiaiXLly+OWXXxAZGfnOvtOnT4eVlRXCw8NhZmYGALC3t8eoUaOwf/9+dO7cGQBw//59/Pe//8W4ceOwZMkSAMCIESPQtm1bTJ48GZ6ennq1Xk1cXBxq1Kghdwwi0nHHjx/H4MGD8cknn2DWrFlyxyEdpPXf3GZmZihXrtx7+7148QIHDhyAt7e3quABAB8fH5iZmWHr1q2qttDQUGRmZmLMmDFq2xg9ejTi4+NzLax00d27d/HBBx/IHYOIdNiVK1fQq1cvtGjRAj///DMvTaciofVFT15dunQJmZmZaNq0qVq7oaEhnJ2dER0drWqLjo6GmZlZtnVpmjVrBuDvw2T6QqlU4uHDh6hcubLcUYhIR8XHx6Nr166oUqUKduzYgdKlS8sdiXSU3hQ9CQkJAABbW9tsz9nY2ODBgwdqfa2trbP1e/Pat/vquqdPnyIzMzPHcSMiKqikpCR07doVCoUCe/bsydPMPZGmStQ5PUIIpKWl5alvfq8kSklJAYAcf4MwNjZWPf+m77v6vb0tffCmwLOzs5M5CRHpmpSUFPTu3RsJCQk4fvw4/52hIleiip4jR46gQ4cOeeobGxsLBweHPG/bxMQEAHIsqlJTU1GmTBm1vqmpqTn2e3tb+iC3GTIiIk1lZmZi4MCBiIqKwqFDh3ibGyoWJaroqVOnDtavX5+nvjY2Nvna9psv7Tdf4m9LSEhQ+w3D1tYW4eHhOfYDcp/1mDhxIiwsLNTaBg4ciIEDB+Yrb0nx5MkTAEDFihVlTkJEukKpVGLUqFHYtWsXQkND0aJFC7kjUTEKDg5GcHCwWtvz58+L5b1LVNFjbW0NHx+fItl2/fr1YWBggDNnzsDDw0PVnp6ejvPnz2PAgAGqtkaNGmHt2rWIiYlRu9/UqVOnAADOzs7vfJ9FixahcePGRbAH8khKSoKJiQkXJiSiQiGEwKRJk7BhwwYEBgaiR48eckeiYpbTRMC5c+fQpEmTIn9vvTmR2cLCAp06dcKmTZvw6tUrVXtgYCCSk5PVFih0d3eHoaEhVqxYoWoTQmDlypWoUqUKXF1dizW7nBITE2FpaSl3DCLSEbNnz8bixYuxbNkyDBo0SO44pGdK1EyPpmbPng3g73UeAGDjxo04evQoAOCrr75S9ZszZw5cXV3Rtm1bjBo1CvHx8fjhhx/g5uaGLl26qPpVrlwZEyZMwIIFC5CRkYGmTZtix44diIiIwObNm/Vq/YikpCSUL19e7hhEpAOWLVuGr7/+GrNnz862DhpRsRA6QJIkoVAo1P588/d/i4iIEC1bthQmJibC2tpa+Pr6ilevXmXrp1Qqxdy5c4W9vb0oXbq0aNCggdi8efM7M0RFRQkAIioqqlD3TW6DBg0SrVq1kjsGEWm5DRs2CABi0qRJQqlUyh2HSpji+g7ViZkepVKZ574tW7ZERETEe/tJkgQ/Pz/4+fkVJJrWS05OVlvBmogov7Zs2YJhw4Zh5MiRWLBggV7NllPJojfn9JBmUlJS9OoSfSIqXKGhoRg0aBA++eQTrFy5kgUPyYpFD+UqJSVFbQ0jIqK82rNnD/r3749+/fph3bp1KFWqlNyRSM+x6KFccaaHiDRx+PBh9O3bF25ubggKCoKBgU6cTUFajkUP5SotLY03/yOifDl69Ch69uyJNm3aYOvWrTA0NJQ7EhEAFj30HkIIKBT8mBBR3hw9ehTdunVDixYt8Ntvv3FhUypR+G1GuRJCyB2BiLTE2wXP77//zvMBqcRh0UPvxastiOh9WPCQNmDRQ0REBXLkyBEWPKQVWPRQrkqVKoXMzEy5YxBRCXXw4EF0794dH330EQseKvFY9FCujI2NkZqaKncMIiqBwsLC0KNHD7Rp04YFD2kFFj2UKxMTE6SkpMgdg4hKmN9++w19+vRB165dsWPHDq7nRVqBRQ/likUPEf1bcHAwPD090a9fP2zbto1reZHWYNFDuWLRQ0Rv+/nnnzFo0CB4e3sjKCiICw+SVmHRQ7kqV64cnj17JncMIioBFi1ahBEjRuCzzz7Dzz//zHtpkdZh0UO5Kl++PBITE+WOQUQyEkJgxowZ+OKLLzBt2jSsWLGCK7WTVuId4ChXVlZWLHqI9JhSqcR//vMfLF++HPPnz8eUKVPkjkSkMRY9lKvy5csjKSkJSqWSv9kR6ZmMjAwMHToUwcHBWLVqFUaNGiV3JKICYdFDubKysoJSqURSUhKsrKzkjkNExSQ5ORmenp44cOAAQkJC0L9/f7kjERUYix7KVZUqVQAA8fHxLHqI9MSTJ0/Qo0cPxMTEYPfu3ejcubPckYgKBY9XUK7eFD337t2TOQkRFYe4uDi0bNkSd+7cQXh4OAse0ikseihXNjY2MDAwYNFDpAfOnz8PV1dXKJVKnDhxAk2aNJE7ElGhYtFDuSpVqhTs7OxY9BDpuIMHD6Jt27aws7PD8ePHUbNmTbkjERU6Fj30Xvb29rh9+7bcMYioiGzYsAFdu3bFRx99hPDwcFhbW8sdiahIsOih96pduzauXbsmdwwiKmRCCHz77bcYOnQohg0bht9//x3m5uZyxyIqMix66L0cHR1x7do1KJVKuaMQUSFJT0/HkCFD8N133+H7779HQEAA76NFOo+XrNN7OTo6IiUlBfHx8ahWrZrccYiogJKSkvDxxx/j+PHj2Lx5MwYOHCh3JKJiwaKH3svR0REAEBMTw6KHSMvduHEDPXv2xNOnT7F//360adNG7khExYaHt+i97O3tYWZmhvPnz8sdhYgK4PDhw3BxcYEkSTh58iQLHtI7LHrovRQKBRo3boyoqCi5oxCRhlavXo0uXbqgSZMmiIyMRK1ateSORFTsWPRQnjRp0gRnz56VOwYR5VNmZiYmTpyITz/9FJ9++inCwsJgaWkpdywiWbDooTxp2rQp4uLikJiYKHcUIsqjpKQkdO/eHUuXLsWyZcuwfPlyXqFFeo1FD+VJ06ZNAQBnzpyROQkR5cXVq1fRvHlzREVFYd++fRg7dqzckYhkx6KH8qRWrVqwtrbGkSNH5I5CRO8RGhoKFxcXGBsb48yZM+jQoYPckYhKBBY9lCeSJKFdu3Y4dOiQ3FGI6B2USiW+/fZb9OnTB25uboiMjESNGjXkjkVUYrDooTxr3749zp49ixcvXsgdhYj+JSkpCb169cLMmTMxe/ZsbN26FWZmZnLHIipRWPRQnrVv3x5ZWVk4duyY3FGI6C2XLl1Cs2bNEBkZiT/++ANffvklFAr+8070b/y/gvKsVq1aqFq1Kvbu3St3FCL6n6CgILi4uMDMzAxnz56Fm5ub3JGISiwWPZRnkiShd+/eCA0NhRBC7jhEei01NRWjR4+Gt7c3PD09ceLECZ6/Q/QeLHooX9zd3XH37l1cuHBB7ihEeuv27dto2bIl1q1bh1WrVmH9+vUoU6aM3LGISjwWPZQvbdu2RdmyZREaGip3FCK9tGPHDjRu3BjPnz9HZGQkRo0aBUmS5I5FpBVY9FC+GBkZoXv37tixY4fcUYj0Snp6OiZNmoS+ffuiQ4cOiIqKQqNGjeSORaRVWPRQvnl6euL8+fOIiYmROwqRXrh16xZatmyJpUuXYtGiRdi+fTssLCzkjkWkdVj0UL716NEDlpaW2Lhxo9xRiHReSEgIGjVqhKSkJJw4cQITJkzg4SwiDbHooXwrXbo0BgwYgE2bNiErK0vuOEQ6KTk5GSNHjsTAgQPRq1cvnDt3TnUPPCLSDIse0oiPjw/i4+Nx+PBhuaMQ6Zxz586hSZMmCA4Oxs8//4xNmzahbNmycsci0nosekgjLi4ucHBwwLp16+SOQqQzlEol/P390aJFC5iamuLcuXMYNmwYD2cRFRIWPaQRSZLw6aefYtu2bXj48KHccYi03r1799CxY0f4+flhwoQJiIyMRO3ateWORaRTWPSQxoYPHw4jIyOsWLFC7ihEWksIgaCgIDRs2BA3b97EwYMH4e/vDyMjI7mjEekcFj2kMUtLSwwfPhwrVqxASkqK3HGItM7Tp0/Rv39/eHt7o3v37rh48SLat28vdywincWihwpk/PjxSExMRGBgoNxRiLTKrl27UL9+fRw6dAhbt25FUFAQLC0t5Y5FpNNY9FCB1KxZE/369cP8+fORkZEhdxyiEu/Zs2cYPnw4evXqhSZNmuDy5cvw9PSUOxaRXmDRQwX29ddf4/bt29iwYYPcUYhKtN27d6NevXrYvn071qxZg127dsHW1lbuWER6g0UPFVjDhg3h5eWFmTNnOC42PgAAIABJREFUIi0tTe44RCVOYmIifHx80LNnTzg5OeHy5csYMWIEL0UnKmYseqhQfPvtt7h//z5Wr14tdxSiEuW3335DvXr1sHPnTqxbtw67d+9G1apV5Y5FpJdY9FChcHR0hLe3N+bMmYPk5GS54xDJ7sGDB/j444/Rr18/NGvWDFeuXMHQoUM5u0MkIxY9VGi++eYbJCYmwt/fX+4oRLJRKpUICAhA3bp1cfz4cWzZsgWhoaGoXLmy3NGI9B6LHio0NWrUwKRJkzB//nzcuHFD7jhExe7KlSto164dPv/8c3h4eCAmJgb9+/fn7A5RCcGihwrVV199BVtbW4wdOxZCCLnjEBWL5ORk+Pn5wdnZGY8ePcKhQ4ewZs0arrtDVMKw6KFCVaZMGSxbtgz79+/Hli1b5I5DVOR27tyJevXqYfHixfj666+5qjJRCcaihwpdjx490K9fP0yYMAFPnz6VOw5Rkbh9+zbc3d3h7u6OOnXq4MqVK5gxYwZKly4tdzQiegcWPVQkli5divT0dHz++ec8zEU65fXr1/j6669Rt25dnDt3Dlu3bkVYWBhq1qwpdzQieg8WPVQk7OzsEBAQgO3bt/O+XKQThBDYvn076tSpg/nz52PSpEmIjY2Fp6cnT1Qm0hIseqjIeHp6YvDgwRg3bhz+/PNPueMQaezChQvo2LEjPDw80KBBA1y5cgVz5syBqamp3NGIKB9Y9FCRWrp0KcqXL4+BAwciPT1d7jhE+fLo0SN8+umnaNSoER48eIBdu3Zh165d+PDDD+WORkQa0Pqi5+DBgxg+fDgcHBxgamqKmjVrYtSoUXj48GGO/U+cOIFWrVrB1NQUtra2GD9+fI4rCAsh4O/vj+rVq8PExAROTk4ICQkp6t3RORYWFtiyZQuioqLwn//8h+f3kFZISUnBvHnzUKtWLfzyyy/48ccfcenSJfTo0UPuaERUAAZyByioqVOn4tmzZ/D09EStWrVw69YtLFu2DLt27cL58+dhbW2t6nv+/Hl07NgR9erVw6JFi3Dv3j0sXLgQN27cQFhYmNp2p0+fjvnz5+PTTz9Fs2bNsGPHDnzyySeQJAleXl7FvZtazcXFBT/99BNGjhyJevXqwdfXV+5IRDnKysrCpk2bMGPGDCQkJGDMmDH45ptvUL58ebmjEVFhEFru2LFj2dqOHj0qJEkSX331lVp7t27dROXKlcXLly9VbWvWrBGSJIl9+/ap2uLj44WhoaHw9fVVe32bNm1E1apVRVZWVrb3jIqKEgBEVFRUQXdJZ33xxRdCoVCIP/74Q+4oRGqUSqXYs2ePaNiwoQAgPDw8xPXr1+WORaQ3ius7VOsPb7Vq1SpbW+vWrVG+fHnExsaq2l68eIEDBw7A29sbZmZmqnYfHx+YmZlh69atqrbQ0FBkZmZizJgxatsdPXo04uPjERkZWQR7ovv8/f3RrVs3eHl5ISYmRu44RACA06dPo3PnzujatSssLCwQGRmJbdu2oVatWnJHI6JCpvVFT05evXqFly9fokKFCqq2S5cuITMzE02bNlXra2hoCGdnZ0RHR6vaoqOjYWZmBkdHR7W+zZo1A/D3YTLKv1KlSmHz5s2oVq0aevbsiUePHskdifTYpUuX0KdPH7i4uODRo0cIDQ3FkSNH0KJFC7mjEVER0cmiZ/HixcjIyFA79yYhIQEAYGtrm62/jY0NHjx4oNb37XOB3njz2rf7Uv6ULVsWv//+O16/fo0OHTrg8ePHckciPXPjxg14e3vDyckJly5dwqZNm3D+/Hn07t2b6+0Q6bgSVfQIIZCampqnn3c5evQovvvuO3h5eaFdu3aq9pSUFADIcYl4Y2Nj1fNv+r6r39vbIs3Y29sjPDwciYmJaN++PQsfKhY3btzAkCFD4OjoiMOHD+Onn35CbGwsBg0ahFKlSskdj4iKQYkqeo4cOYIyZcrk6ef69evZXh8bG4u+ffuiYcOGWLNmjdpzJiYmAIC0tLRsr0tNTUWZMmXU+uZUWL1pe7Mt0lzt2rVZ+FCxeLvY2b9/PxYvXoxbt27hs88+g6GhodzxiKgYlahL1uvUqYP169fnqa+NjY3a43v37qFLly6wtLREWFhYtpVS3xyaenOY620JCQmws7NT6xseHp5jPwBqff9t4sSJsLCwUGsbOHAgBg4cmPsO6aE3hU+7du3Qvn17HD58GJUqVZI7FumIy5cvY+7cuQgJCYG1tTUWL16MUaNGqWZsiUgewcHBCA4OVmt7/vx58bx5kV4bVkyePn0qHB0dhY2Njbh582aOfZ49eyYMDQ3FlClT1NrT0tKEmZmZGDlypKpt+fLlQpIkcfXqVbW+QUFBQpIkERERkW37vGRdc7GxscLGxkY4OjqK27dvyx2HtNzJkyeFu7u7ACCqVasmli5dKlJSUuSORUS54CXreZScnIzu3bsjISEh1zsdW1hYoFOnTti0aRNevXqlag8MDERycjI8PT1Vbe7u7jA0NMSKFStUbUIIrFy5ElWqVIGrq2vR7ZAeql27No4cOYKMjAw0b94cERERckciLSOEwJ49e9CxY0e0aNECsbGxWLduHW7evIlx48ZxdoeIAJSww1uaGDRoEM6cOYPhw4fjypUruHLliuo5c3NzuLu7qx7PmTMHrq6uaNu2LUaNGoX4+Hj88MMPcHNzQ5cuXVT9KleujAkTJmDBggXIyMhA06ZNsWPHDkRERGDz5s28wqMIODg44NSpU/Dw8ECHDh2watUqDB06VO5YVMKlp6cjODgYCxcuxOXLl9G0aVNs27YNffv25cnJRJRdkc4jFQN7e3uhUCiEJEnZfqpXr56tf0REhGjZsqUwMTER1tbWwtfXV7x69SpbP6VSKebOnSvs7e1F6dKlRYMGDcTmzZvfmYOHtwpHWlqaGDlypAAgJk+eLDIzM+WORCXQkydPxNy5c4WdnZ0AIHr27CnCw8OFUqmUOxoRaaC4vkO1fqYnLi4uX/1btmyZp8MnkiTBz88Pfn5+mkYjDRgZGWHVqlWoW7cu/u///g+XLl1CYGCg2kKTpL8uXryIJUuWICgoCEIIeHt744svvkDdunXljkZEWkDrz+kh3SNJEiZOnIiwsDCcOXMGDRs2xL59++SORTLJyMjA9u3b0aFDBzg5OWHPnj2YMWMG4uPjsWbNGhY8RJRnLHqoxHJzc8OFCxdQv359uLm5wdfXF69fv5Y7FhWTe/fu4euvv8YHH3wADw8PpKenIyQkBHFxcZg+fTpn/4go31j0UIlWuXJl7NmzB0uWLMGaNWvQpEkTHD9+XO5YVEQyMjKwc+dO9O7dG/b29li0aBH69OmDCxcuICIiAl5eXlxQkIg0xqKHSjyFQgFfX19ERUXB3NwcrVq1wqhRo5CYmCh3NCok165dw9SpU1GtWjW4u7vj/v37WLFiBR48eIAVK1agYcOGckckIh3Aooe0Rt26dREZGYlly5Zh69atqF27NjZs2AClUil3NNLAX3/9hZUrV6Jly5ZwdHTE6tWr4enpiejoaERFReGzzz6Dubm53DGJSIew6CGtUqpUKYwdOxaxsbHo1KkThg4dihYtWuDAgQMQQsgdj94jNTUV27dvR9++fWFra4tx48ahXLlyCA4OxoMHD7BkyRI4OzvLHZOIdBSLHtJKtra2CA4ORnh4OCRJQufOndG+fXscO3ZM7mj0L2lpadi1axcGDx6MSpUqwcPDA/Hx8ViwYAHu37+P3bt3Y8CAAVw1mYiKHIse0mpt27bFyZMn8fvvv+PZs2do06YN3NzcEBkZKXc0vZaSkoLff/8dw4YNg7W1NXr16oWoqChMmjQJMTExOHPmDMaPHw9ra2u5oxKRHmHRQ1pPkiT07NkT586dw7Zt23Dv3j24urrio48+wi+//ILMzEy5I+qFxMREBAYG4uOPP0aFChXQu3dvREZGwtfXF5cuXcLVq1fxzTffwNHRUe6oRKSnWPSQzlAoFPDw8MDly5exc+dOGBsbw9PTE7Vq1cLChQvx5MkTuSPqFCEELly4gLlz56J169aoWLEifHx8cP/+fcyYMQMxMTGIjY3FrFmzUL9+fbnjEhGx6CHdo1Ao0KtXLxw+fBhRUVFo1aoVvvzyS9jZ2cHd3R3bt29HWlqa3DG10sOHDxEUFIThw4ejatWqcHZ2xvfff48KFSpg5cqViI+Px8mTJ+Hn58cZHSIqcbT+3ltEuWncuDECAwOxaNEihISEYOPGjfDw8IClpSX69++Pfv36oV27djAyMpI7aon05MkTHDt2DEePHsXBgwdx+fJlAECDBg3Qv39/9OjRA61atULp0qVlTkpE9H4sekgvVKhQAePGjcO4ceMQExODjRs3Ijg4GAEBAShbtiy6desGd3d3dOvWDeXKlZM7riyUSiWuX7+OU6dO4fjx4zh27BhiY2MBAB988AE6duyI6dOno0OHDjwBmYi0Eose0jt16tTB3Llz8f333+PixYsIDQ3Fjh078Mknn0ChUKBRo0bo0KED2rdvj1atWunkAnlKpRJ//vknLly4gKioKJw6dQpnzpzB8+fPAQD16tVDu3btMGPGDLRu3RpVq1aVOTERUcGx6CG9JUkSnJyc4OTkhK+//hp3797F/v37cfjwYWzatAkLFiyAQqFAw4YN0aRJEzRt2hRNmjRBw4YNteZwjhACDx8+RGxsLGJjY3HlyhVcuHABFy5cwMuXLwEAlSpVgouLCyZPnozmzZujWbNmejvbRUS6jUUP0f9Uq1YNI0aMwIgRIyCEwPXr13Hs2DGcPHkSZ8+exfr165GVlQUDAwPUqFEDjo6Oqp9atWqhatWqsLOzK9YbYgoh8PLlSyQkJODu3buIi4tT+7l27Zpq9sbAwAAffvghnJyc0KNHDzg5OcHZ2Rk2NjaQJKnYMhMRyYVFD1EOJElC7dq1Ubt2bYwcORLA3wvuXbx4EdHR0aqZky1btuDOnTtqr7OxsUHVqlVhbW0NKysrlC9fXvVTpkwZmJiYqH7enED95hYaQghkZGQgJSUFr1+/Vv357NkzJCUlISkpCYmJifjrr7+QkJCABw8e4PXr16r3VygUqFKlCqpXr466deuib9++qsKsZs2avEM5Eek1Fj1EeWRiYgIXFxe4uLiotb9+/RpxcXGIj4/HvXv3VD9PnjzB9evX8ddffyExMRGJiYnIysrK9/uWKlUKlpaWKF++vOrPatWqwcXFBba2trCzs4OtrS2qVKmCatWqsbAhInoHFj1EBVSmTBnUq1cP9erVy7Xf27M4KSkpSE1NRVpamurQ0ps/DQ0N1WaDWMQQERUOFj1ExUSSJBgZGcHIyAgWFhZyxyEi0jtckZmIiIj0AoseIiIi0gsseoiIiEgvsOghIiIivcCih4iIiPQCix4iIiLSCyx6iIiISC+w6CEiIiK9wKKHiIiI9AKLHiIiItILLHqIiIhIL7DoISIiIr3AooeIiIj0AoseIiIi0gsseoiIiEgvsOghIiIivcCih4iIiPQCix4iIiLSCyx6iIiISC+w6CEiIiK9wKKHiIiI9AKLHiIiItILLHqIiIhIL7DoISIiIr3AooeIiIj0AoseIiIi0gsseoiIiEgvsOghIiIivcCih4iIiPQCix4iIiLSCyx6iIiISC+w6CEiIiK9wKKHiIiI9AKLHiIiItILLHqIiIhIL7DoISIiIr3AooeIiIj0AoseIiIi0gsseoiIiEgvsOghIiIivcCih4iIiPQCix4iIiLSCyx6iIiISC9ofdFz9OhR9O7dG9WqVYOJiQmsra3RsWNH/PHHHzn2P3HiBFq1agVTU1PY2tpi/PjxSE5OztZPCAF/f39Ur14dJiYmcHJyQkhISFHvDhERERURrS96bty4AQMDA4wePRorVqzAlClTkJiYiB49eiAoKEit7/nz59GxY0ekpqZi0aJFGDlyJFatWgVPT89s250+fTr8/Pzg5uaGZcuWoVq1avjkk0+wZcuW4to1IiIiKkSSEELIHaKwpaSkoEaNGnBwcMCRI0dU7d27d8fFixcRGxsLMzMzAMDatWsxatQo7N27F507dwYA3L9/H9WrV8fnn3+OJUuWqF7ftm1bxMXF4c8//4RCoV4vnjt3Dk2aNEFUVBQaN25cDHtJRESkG4rrO1TrZ3pyYmJiggoVKsDQ0FDV9uLFCxw4cADe3t6qggcAfHx8YGZmhq1bt6raQkNDkZmZiTFjxqhtd/To0YiPj0dkZGTR7wQREREVKp0pel68eIGnT58iNjYW06dPx/Xr1zFp0iTV85cuXUJmZiaaNm2q9jpDQ0M4OzsjOjpa1RYdHQ0zMzM4Ojqq9W3WrBmAvw+TERERkXYxkDtAYenfvz/27dsHADA1NcXWrVvRrVs31fMJCQkAAFtb22yvtbGxQUREhFpfa2vrbP3evPbBgweFmp2IiIiKXoma6RFCIDU1NU8//zZ//nzs378fa9euRd26dTFgwADs379f9XxKSgoAoHTp0tlea2xsrHr+Td939Xt7W0RERKQ9StRMz5EjR9ChQ4c89Y2NjYWDg4PqsZOTk+rv3t7eaNy4McaOHYvr168D+Ps8HwBIS0vLtq3U1FSUKVNG9djExCTHwupN25ttERERkfYoUUVPnTp1sH79+jz1tbGxeedzhoaG6NWrF+bNm4dnz56hXLlyqkNTbw5zvS0hIQF2dnaqx7a2tggPD8+xHwC1vv82ceJEWFhYqLUNHDgQAwcOzHV/iIiI9EFwcDCCg4PV2p4/f14s712iih5ra2v4+PgUyrbeHIJ6c2l5/fr1YWBggDNnzsDDw0PVLz09HefPn8eAAQNUbY0aNcLatWsRExODOnXqqNpPnToFAHB2dn7n+y5atIiXrBMREb1DThMBby5ZL2ol6pweTTx+/Dhb27Nnz7B9+3Y0aNAAZcuWBQBYWFigU6dO2LRpE169eqXqGxgYiOTkZLUFCt3d3WFoaIgVK1ao2oQQWLlyJapUqQJXV9ci3CP98++Kn96PY6YZjlv+ccw0w3ErmUrUTI8munXrhqpVq6J58+aoVKkS7t69i3Xr1uHJkyfZDpXNmTMHrq6uaNu2LUaNGoX4+Hj88MMPcHNzQ5cuXVT9KleujAkTJmDBggXIyMhA06ZNsWPHDkRERGDz5s2QJKmY91K3BQcH8/BfPnHMNMNxyz+OmWY4biWT1hc9I0aMQEhICBYvXoxnz57BysoKrVq1wrRp07IdZmrUqBEOHDiAqVOn4osvvkDZsmUxcuRIzJ07N9t2582bB0tLSwQEBGD9+vVwcHBAUFCQ2mEwIiIi0h5aX/SMGTMm28rJuWnZsqXamjzvIkkS/Pz84OfnV5B4REREVEJo/Tk9RERERHmh9TM9JcWbq8ViYmJkTqJ9nj9/jnPnzskdQ6twzDTDccs/jplmOG758+a7s6gX/9XJu6zLISgoCN7e3nLHICIi0lqbNm3CoEGDimz7LHoKydOnT7F3717Y29tzxWYiIqJ8SElJwZ9//gk3NzdUqFChyN6HRQ8RERHpBZ7ITERERHqBRQ8RERHpBRY9REREpBdY9BAREZFeYNGTD0ePHkXv3r1RrVo1mJiYwNraGh07dsQff/yRY/8TJ06gVatWMDU1ha2tLcaPH4/k5ORs/YQQ8Pf3R/Xq1WFiYgInJyeEhIQU9e4Ui4MHD2L48OFwcHCAqakpatasiVGjRuHhw4c59ueY/e3hw4fw8/ND+/btYW5uDoVCgSNHjryzP8ft3dLS0jB16lTY2dmhTJkyaNGiBQ4cOCB3rGKXnJyMb775Bl27dkX58uWhUCiwYcOGHPvGxMSga9euMDc3h5WVFXx8fPD06dMc+65duxZ16tSBiYkJHBwcsGzZsqLcjWJ15swZjBs3DvXq1YOZmRk++OADeHl54caNG9n6csz+ceXKFXh6eqJmzZowNTWFlZUVXF1dERQUlK1vsY+boDxbs2aN6Nu3r/j+++/Fzz//LBYuXCicnZ2FJEli06ZNan2jo6OFsbGxaNKkiQgICBBfffWVMDY2Ft26dcu2XT8/PyFJkvjss8/EmjVrRM+ePYUkSSIkJKS4dq3INGnSRNSsWVP4+fmJtWvXiunTp4uyZcsKGxsb8fDhQ7W+HLN/HD58WEiSJGrXri1cXV2FJEniyJEjOfbluOVuwIABwtDQUEyZMkWsXr1auLq6CkNDQxERESF3tGIVFxcnJEkS9vb2on379kKSJLFhw4Zs/e7duycqVKggatWqJZYuXSq+//57Ub58eeHs7CzS09PV+q5cuVJIkiQ8PT3FmjVrhI+Pj5AkScyfP7+4dqtIffzxx8LOzk6MHz9erF27VsyePVvY2NgIMzMzcfnyZVU/jpm6sLAw0bVrVzFz5kyxZs0asWTJEtGmTRshSZKYPXu2qp8c48aip4Bev34tbGxsRJs2bdTau3XrJipXrixevnypaluzZo2QJEns27dP1RYfHy8MDQ2Fr6+v2uvbtGkjqlatKrKysop2B4rYsWPHsrUdPXpUSJIkvvrqK7V2jtk/Xr58KZKSkoQQQmzbti3Xoofj9m6nTp0SkiSJ//73v6q21NRU8eGHHwpXV1cZkxW/tLQ08ejRIyGEEGfPnn1n0TN69Ghhamoq7t27p2o7cOCAkCRJrFq1StX2+vVrYWVlJXr16qX2em9vb2FmZqb6/GqzEydOiIyMDLW2GzduCGNjY+Ht7a1q45i9X1ZWlnB2dhbVqlVTtckxbix6CkH9+vVFx44dVY+fP38uDA0NxdSpU9X6paenC3NzczFy5EhV2/Lly4UkSSImJkatb3BwsJAkSWd/G7WyshIeHh6qxxyzd8ut6OG45W7y5MnC0NBQrSAUQoi5c+cKSZJEfHy8TMnkdebMmXcWPZUqVRJeXl7Z2mvXri06deqkerx7924hSZL4448/1PpFRkbmOPutSxo3biyaNm2qeswxy5uePXuKmjVrqh7LMW48p0cDL168wNOnTxEbG4vp06fj+vXrmDRpkur5S5cuITMzE02bNlV7naGhIZydnREdHa1qi46OhpmZGRwdHdX6NmvWDABw/vz5ItwTebx69QovX75UW3WTY6YZjlvuoqOj4eDgADMzM7V2Xd7ngrh//z6ePHmS7fME/D1m//48AcjWt3HjxlAoFDo7tkIIPHr0SPXvF8fs3V6/fo2nT5/i1q1bWLRoEfbu3YspU6YAkG/ceMNRDfTv3x/79u0DAJiammLr1q3o1q2b6vmEhAQAgK2tbbbX2tjYICIiQq2vtbV1tn5vXvvgwYNCzV4SLF68GBkZGfDy8lK1ccw0w3HLXUJCQo5jo8v7XBC5fZ5sbW2RmJiIjIwMGBoaIiEhAaVKlcp2ywAjIyNYWVnp7NgGBQXhwYMHmD17NgCOWW6++OILrFq1CgBgYGCAJUuW4NNPPwUg37jpbdEjhEBaWlqe+hobG6s9nj9/PiZPnoy7d+9i5cqVGDBgAHbu3InOnTsD+OcusaVLl85xW2/fRTYlJeWd/d7eVklQkDF74+jRo/juu+/g5eWFdu3aqdp1dcyAwhm3d9HlcSsM+rjPBfG+z9ObPoaGhkhJSYGRkVGO2yldurROjm1sbCzGjh0LV1dXDBkyBADHLDcTJ05E//798eDBAwQFBWHcuHEwMTHBkCFDZBs3vS16jhw5gg4dOuSpb2xsLBwcHFSPnZycVH/39vZG48aNMXbsWFy/fh0AVDcczemLLjU1FWXKlFE9NjExQWpqao793t5WSVCQMXvT1rdvXzRs2BBr1qxRe05Xxwwo+LjlRpfHrTCYmJi8c2zePE//eN/n6e0+JiYmSE9Pz3E7qampOje2Dx8+RI8ePWBpaYlffvkFkiQB4Jjlpnbt2qhduzaAv78r3dzcMGHCBHh5eck2bnpb9NSpUwfr16/PU18bG5t3PmdoaIhevXph3rx5ePbsGcqVK6earnszffe2hIQE2NnZqR7b2toiPDw8x34A1PrKrSBjdu/ePXTp0gWWlpYICwuDqamp2vO6OmZA4X3WcqLL41YYbG1tc5z61uV9Loj3fZ6srKxgaGio6puVlYWnT5+qHXZIT09HYmKiTo3t8+fP0a1bN7x48QLHjh1T+/+UY5Z3H3/8Mfbv34/Y2FjZxk1vix5ra2v4+PgUyrbeTK0pFH+fF16/fn0YGBjgzJkz8PDwUPVLT0/H+fPnMWDAAFVbo0aNsHbtWsTExKBOnTqq9lOnTgEAnJ2dCyVjYdB0zP766y906dIFGRkZOHz4cI7nlejqmAGF+1n7N10et8LQqFEjhIeH4+XLlzA3N1e16/I+F0TlypVRsWJFnDlzJttzp0+fVhuvRo0aAfh7Ab+3z2k8e/YslEqlzoxtamoqevXqhZs3b+LAgQPZLgTgmOXd29+Vso1bPq8402tv1rh4W1JSkqhatapo2LChWnu3bt2EnZ1djmun7N27V9UWHx8vjIyMxLhx41RtSqVStG7dWlStWlUolcoi2JPi8+rVK9G8eXNhYWEhzp07l2tfjlnO8rJOD8ctZ2/W6Vm4cKGq7c06PR999JGMyeSV2yXro0ePFmXKlMlx7ZSAgABVW0pKis6vOZOZmSl69+4tjIyMsl0u/TaOmbrHjx9na0tPTxeNGzcWFSpUEJmZmUIIecaNRU8+NG7cWLi7u4s5c+aI1atXixkzZogqVaqI0qVLi4MHD6r1PXfunDA2NhaNGzcWP/30k/jyyy+FiYmJ6Nq1a7btTpkyRbVK7urVq0WPHj2EJEkiODi4uHatyLi7uwtJksSIESNEYGCg2s+OHTvU+nLM1M2aNUvMmjVLDBgwQDWGb9rexnHLXf/+/VUrMgcEBAhXV1dhZGSU48KZum7p0qVi1qxZYvTo0UKSJPHxxx+rPlPPnz8XQvyzSu6HH36oWiXX0tJSODk5ZVsld8WKFapVclevXq1aJXfrgq4UAAAHPklEQVTu3Lly7F6hGz9+vJAkSfTu3Tvbv1+BgYGqfhwzdX369BEdO3YU3333nVi9erWYNWuWcHR0FAqFQq3QlmPcWPTkw/Lly0Xr1q1FxYoVhaGhobCxsREeHh4iKioqx/4RERGiZcuWwsTERFhbWwtfX1/x6tWrbP2USqWYO3eusLe3F6VLlxYNGjQQmzdvLurdKRb29vZCoVAISZKy/VSvXj1bf47ZPyRJUo3d22OoUCiy9eW4vVtqaqqYPHmysLW1FcbGxsLFxUVtpWp9Ym9vr/Y5evvzdefOHVW/K1euCDc3N2FqairKly8vBg8enONv70IIsXr1auHo6ChKly4tatWqJX788cfi2p0i165du3f++/Xv/w85Zv8ICQkRnTt3FjY2NsLQ0FBYWVmJ7t27iwMHDmTrW9zjJgkhhIaH54iIiIi0BldkJiIiIr3AooeIiIj0AoseIiIi0gsseoiIiEgvsOghIiIivcCih4iIiPQCix4iIiLSCyx6iIiISC+w6CEiIiK9wKKHiEqcoUOHonr16nLHICIdw6KHiEocSZIgSZLcMTSyb98+jBgxAvXr10epUqVYvBGVILz3FhGVOJmZmRBCwNDQUO4o+TZs2DBs2bIFTZo0wZ07d2BgYIDbt2/LHYuIwKKHiKhQJSQkoFKlSihVqhR69uyJq1evsughKiF4eIuIitXLly8xYcIE2Nvbw9jYGNbW1ujSpQuio6NVfXI6p+evv/7C4MGDUbZsWVhaWmLo0KG4cOECFAoFNmzYoPZac3Nz3LlzBz169IC5uTmqVKmC5cuXAwAuXryIDh06wMzMDPb29ggODlZ7n6SkJPzf//0fGjRoAHNzc1hYWKB79+64ePFinvbP1tYWpUqV0nR4iKgIGcgdgIj0y+eff47t27fD19cXdevWxdOnT3H8+HHExsaiUaNGqn5vn9OjVCrRq1cvnDlzBmPGjIGjoyN27NiBIUOGZOsLAFlZWejevTvatWuHXr16YdOmTfD19UXp0qXx9ddfw8fHBx4eHvjpp5/g4+ODjz76CPb29gCAW7duITQ0FP3790f16tXx8OFDBAQEoG3btrh69SpsbW2LfpCIqGgIIqJiZGFhIXx9fXPtM2TIEGFvb696vH37diFJkliyZImqTalUio4dOwpJksSGDRvUXitJkpg3b56q7dmzZ6JMmTJCkiSxdetWVfu1a9eEJEni22+/VbWlpaVly/Pnn38KY2NjMWvWrHzta48ePUT16tXz9RoiKjo8vEVExcrS0hInT55EQkJCnl+zZ88eGBkZYdSoUao2SZIwduzYd75m5MiRqr9bWFjAwcEB5ubm8PT0VLU7ODigXLlyiIuLU7UZGRmp/p6VlYW//voLpqamcHBwUDsER0Tah0UPERUrf39/XL58GVWrVoWLiwu+++47taIjJ3fu3IGtrS2MjY3V2mvWrJljfxMTE1hZWam1WVhYoEqVKtn6li1bFklJSarHQggsWrQItWrVgrGxMSpWrIhKlSrh0qVLeP78eV53k4hKIBY9RFSsPD09cfv2bSxduhR2dnZYsGAB6tWrhz179uT6OpGPC00Vipz/aXvXCcZvb3vOnDmYNGkS2rVrh6CgIOzbtw/79+9HvXr1oFQq85yBiEoenshMRMXOxsYGo0ePxujRo/HkyRM0btwYc+bMQdeuXXPs/8EHHyA8PBwpKSkwMTFRtd+8ebPQs/3yyy/o0KEDVq9erdaelJSEihUrFvr7EVHx4UwPERUbpVKZ7RBRxYoVYWtri/T0dLX2t6/I6tq1KzIyMtQKEaVSqboM/d8KspqzgYFBthmdbdu24cGDBxpvk4hKBs70EFGxefHiBapUqQJPT080bNgQZmZmOHDgAM6ePYsffvhBre/bh5z69OmD5s2bY9KkSbh58yZq166NnTt3qs7F+XeR865DYXk5RNazZ0/MnDkTw4cPx0cffYRLly5h8+bNqFGjRp5ef/HiRezcuRPA3zNRz549w+zZswEAzs7O6Nmz53u3QURFg0UPERUbU1NTjB07Fvv27cOvv/4KpVKJWrVq4aeffsJnn32m6vfve28pFArs3r0b48ePx4YNG6BQKODu7o7/b+8OcRQGogAMP1RPwh1AYDkAF0BD8CSIsSiuQR1BcYMGBxfgAFyAZCqarNssYje4bjPfJyuaJ/9MJ30ppZjNZm8XnH/b2/XX8592u128Xq84Ho/f6yQul0tst9uPTpDu93uklN7enVKK0WgUy+VS9ECPrKEABut8PsdisYimaWI6nfY9DvDPiR5gEHLObyc6XdfFfD6P2+0Wz+czqqrqcTpgCHzeAgZhs9lEzjkmk0m0bRun0ymu12vs93vBA3zESQ8wCHVdx+FwiMfjETnnGI/HsVqtYr1e9z0aMBCiBwAogv/0AABFED0AQBFEDwBQBNEDABRB9AAARRA9AEARRA8AUATRAwAUQfQAAEX4AjsN/qGBNUX4AAAAAElFTkSuQmCC",
       "text/plain": [
-       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7ff7c5124450>)"
+       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7fa8a1931150>)"
       ]
      },
      "metadata": {},
@@ -451,17 +377,18 @@
     {
      "data": {
       "text/plain": [
-       "PyObject <matplotlib.text.Text object at 0x7ff7c44a5b90>"
+       "1-element Array{Any,1}:\n",
+       " PyObject <matplotlib.lines.Line2D object at 0x7fa8a1513050>"
       ]
      },
-     "execution_count": 121,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "function plot_principal()\n",
-    "    PyPlot.figure(figsize=(4, 4))\n",
+    "    PyPlot.figure(figsize=(6, 6))\n",
     "    n = 100\n",
     "    s = linspace(-300, 300, n)\n",
     "    s1 = repmat(s', n, 1)\n",
@@ -470,23 +397,17 @@
     "    contour(s1, s2, sigma, [200], colors=\"k\")\n",
     "    p1 = [p[1] for p in principals]\n",
     "    p2 = [p[2] for p in principals]\n",
-    "    PyPlot.plot(p1, p2, \"-b.\")\n",
+    "    PyPlot.plot(p1, p2, \"-bo\")\n",
     "    axis(\"equal\")\n",
     "    xlabel(\"sigma 1\")\n",
     "    ylabel(\"sigma 2\")\n",
-    "    title(\"principal stress plane\")\n",
+    "    title(\"principal stress\")\n",
+    "    dir = last(ip.fields[\"derivative of plastic potential\"])[1]\n",
+    "    PyPlot.plot([p1[end], p1[end]+dir[2,2]*50],\n",
+    "                [p2[end], p2[end]+dir[1,1]*50], \"-r\")\n",
     "end\n",
     "plot_principal()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {