JuliaFEM.jl/docs/tutorials/2015-11-03-constitutive-modelling-using-juliafem.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constitutive modelling using JuliaFEM\n",
    "\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "using JuliaFEM: IntegrationPoint, Field, FieldSet, TimeStep, Increment\n",
    "using ForwardDiff\n",
    "using PyPlot"
   ]
  },
  {
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "JuliaFEM.DefaultDiscreteField([JuliaFEM.TimeStep(0.0,JuliaFEM.Increment[[0.0]])])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ip = IntegrationPoint([0.0, 0.0], 1.0)\n",
    "\n",
    "ip.fields[\"total strain\"] = Field()\n",
    "ip.fields[\"plastic strain\"] = Field()\n",
    "ip.fields[\"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(0.0) # material parameter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing parameters is done just like with `FieldSet`s in general:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: [2.0e11]\n",
      "INFO: [2.0e8]\n"
     ]
    }
   ],
   "source": [
    "info(last(ip.fields[\"young\"]))\n",
    "info(last(ip.fields[\"yield stress\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our material model is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "calculate_stress! (generic function with 1 method)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\" Ideal plastic material model. \"\"\"\n",
    "function calculate_stress!(ip::IntegrationPoint, strain::Matrix, time::Number)\n",
    "\n",
    "    dim = size(strain, 1)\n",
    "    \n",
    "    poisson = last(ip.fields[\"poisson\"])[1]\n",
    "    young = last(ip.fields[\"young\"])[1]\n",
    "    mu = young/(2*(1+poisson))\n",
    "    lambda = young*poisson/((1+poisson)*(1-2*poisson))\n",
    "    if dim == 2\n",
    "        lambda = 2*lambda*mu/(lambda + 2*mu)  # <- correction for 2d\n",
    "    end\n",
    "\n",
    "    # yield function\n",
    "    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",
    "\n",
    "    if f(stress_trial) <= 0.0\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",
    "        dt = time - ip.fields[\"total strain\"][end].time\n",
    "\n",
    "        # associated flow rule, plastic potential ψ(σ) = f\n",
    "        psi = f\n",
    "\n",
    "        \"\"\" Calculate equations\n",
    "\n",
    "            dσ - C (dϵₜ - dγ*dΨ/dσ) = 0\n",
    "                         σₑ(σ) - σy = 0\n",
    "\n",
    "            dϵₜ = total strain\n",
    "            dϵₑ = elastic strain\n",
    "            dϵₚ = plastic strain\n",
    "        \n",
    "            dϵₜ = dϵₑ + dϵₚ\n",
    "            => dϵₑ = dϵₜ - dϵₚ = dϵₜ - dγ*dψ/dσ\n",
    "            dσ = λ⋅tr(dϵₑ)I + 2μ⋅dϵₑ\n",
    "            => dσ - λ⋅tr(dϵₑ)I - 2μ⋅dϵₑ = 0\n",
    "        \"\"\"\n",
    "        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",
    "            # \"Derivatives of scalar valued functions of second-order tensors\"\n",
    "            dpsi_dstress = derivative(psi, stress_tot)\n",
    "            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",
    "        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",
    "            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",
    "        end\n",
    "        params[2] = params[3]\n",
    "        #info(\"params = $params\")\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",
    "        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",
    "    end\n",
    "\n",
    "end    ### END OF CONSTITUTIVE MODEL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Small \"simulator\" to study the behavior of material model in `IntegrationPoint`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "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"
     ]
    }
   ],
   "source": [
    "function run(steps=50)\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 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",
    "\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",
    "\n",
    "        # calculate stress\n",
    "        calculate_stress!(ip, strain, time)\n",
    "    end\n",
    "\n",
    "    return ip\n",
    "end\n",
    "\n",
    "ip = run();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7ff7c4450b10>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0,250)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steps = length(ip.fields[\"total strain\"])\n",
    "eps11 = Float64[]\n",
    "sig11 = Float64[]\n",
    "principals = Vector{Float64}[]\n",
    "for i=1:steps\n",
    "    # extract from integration points -- too complicated\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",
    "end\n",
    "\n",
    "#PyPlot.figure(figsize=(7, 5))\n",
    "PyPlot.plot(eps11, sig11, \"-k.\")\n",
    "PyPlot.title(\"Stress-Strain curve\")\n",
    "PyPlot.xlabel(\"Strain [ustr]\")\n",
    "PyPlot.ylabel(\"Stress [MPa]\")\n",
    "PyPlot.ylim([0, 250])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAGaCAYAAABNIkevAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3XlcjdkfB/DPc9tVUhElS1GSLYlBSNmyhmxZ02AmW2IWy8xYxzKY7NuQapB1hqwpg9JESmUmMkJIoU2K9s7vj373jjvdSOo+d/m+X69e7j3Puc/zfW653/ucc55zOMYYAyGEEMITAd8BEEIIUW6UiAghhPCKEhEhhBBeUSIihBDCK0pEhBBCeEWJiBBCCK8oERFCCOEVJSJCCCG8okRECCGEV5SIiNQIBAI4OjpK9Zi9e/eGQCD9P/Pk5GQIBAJMnTpV6sdWNs2bN4eZmRnfYZBPQImISBXHcVI/nrSP+d/j1zT64K2Iz98x+XSqfAdAlEdiYiLq1Kkj1WMGBAQgPz9fqseUBvrgJYqEEhGRGktLS6kfs0mTJlI/JiHk41DTHKng3f6NxMREDB8+HAYGBtDR0UHPnj0REhJS4TV+fn4QCATw9/fHhQsX0Lt3b+jp6Yn1z0jqI1q2bBkEAgGuXr2K48ePo0uXLtDW1oahoSHc3NyQmpoqMcasrCwsWbIEbdu2hba2NurVqwcbGxssWrQIb9++FdWT1Ed05coVCAQCLF++HJGRkejbty/q1auHunXrwtnZGTExMRWOl5qaihUrVsDe3h6NGjWChoYGGjdujAkTJuDu3bsf9f5Wxt/fH927d0eDBg2gpaWFpk2bwtnZGUePHhWL+8mTJ6LfkfDn3b4o4fv84sULTJs2DY0bN4aqqir8/f1FdW7cuIFRo0aJzqVp06b48ssvkZaWViGuhw8fYsaMGWjZsiXq1KkDQ0NDtG/fHp6ensjKyhLVKyoqwpYtW2BrawsDAwNoa2vDzMwMw4cPx6VLl6r0Hri7u0MgEODRo0f4+eefYWVlBS0tLTRp0gTz589Hbm5ulfbz+vVrrF+/Hk5OTjA1NYWGhgaMjIzg4uKC69evS3yN8H3LzMzEjBkzYGxsDE1NTbRt2xZ+fn6VHis4OBiDBg1C/fr1oampiZYtW+Kbb75BTk5OlWIldEVE3uPRo0fo3r276EMnNTUVR44cwcCBA3Ho0CGMGTOmwmuOHz+OCxcuYNCgQZg5cyYeP34str2yJqUdO3YgKCgILi4ucHR0xPXr13HkyBHEx8cjLi4O6urqYnE5OjriyZMnsLOzw8yZM1FWVoZ79+5h06ZN8PT0RNOmTT94zBs3bmDNmjXo168fZs+ejfv37+O3335DWFgYLl68iB49eojqhoWFYd26dXBycoKtrS10dHTwzz//4Pjx4wgKCkJERATat2//Ue/vuxYvXoy1a9fC3Nwc48aNg56eHlJTU3Hz5k0cP34cY8aMgZmZGZYuXYpNmzYBALy9vUWvt7GxEdtfVlYWunbtCl1dXYwaNQoCgQCNGjUCAPj6+mLGjBnQ0tLCsGHD0KRJE/zzzz/Yu3cvTp8+jevXr4uuJNPS0tC5c2fk5uZi8ODBGD16NAoKCvDw4UMcOHAAc+bMgYGBAYDyJHL48GG0a9cOU6ZMgZaWFp49e4aIiAgEBwejT58+VX4/5s2bh/DwcIwdOxb16tXDhQsXsGnTJoSHh+PatWvQ0NB47+vv3LmD7777Dg4ODhg6dCj09fXx+PFjBAUF4fz58zh9+jQGDBhQ4XWvXr2Cvb09NDQ0MGbMGBQWFuLo0aPw8PCAQCDA5MmTxeovX74cy5cvh6GhIYYOHQojIyPEx8djw4YNOHfuHCIjI6Grq1vl81ZajJD/ePToEeM4jnEcx7755huxbdHR0UxNTY3p6+uz169fi8r379/POI5jKioqLDg4WOJ+OY5jjo6OYmVLly5lHMcxPT099vfff4ttGz9+POM4jh09elSsvFu3bozjOLZ27doKx8jMzGQFBQWi5w4ODkwgEIjVuXz5suj8tm/fLrbt1KlTjOM4ZmFhwcrKykTlL1++ZHl5eRWOFx8fz3R0dNjAgQPFyoXv4dSpUyW9FRUYGBiwJk2asPz8/ArbMjIyxJ43a9aMmZmZVbov4blNmTKFlZaWim27d+8eU1NTYxYWFiw1NVVs26VLl5iKigobMWKEqGzLli2M4zi2ZcuWCsd5+/atKN5Xr14xjuNY586dxd43oczMzErjfdeUKVMYx3GsQYMG7MmTJ6LysrIy5urqyjiOYytXrhR7jaT3IycnR+IxU1JSmImJCWvdunWFbcL3bfr06WLncOfOHaaqqsqsra3F6v/xxx+M4zhmb2/PcnJyxLb5+fkxjuOYt7d3lc5b2VEiIhUIP0T19fUlfvi6u7szjuOYv7+/qEyYiEaOHFnpft+XiL7//vsK9YUJ4+uvvxaVRUdHM47jmK2tbZXO5X2JyNLSUuJrevfuzTiOY1evXq3SMYYOHco0NTVZSUmJqOxjE5GhoSEzNzdnhYWFH6xblUSkqanJ0tPTK2ybN28e4ziOnTt3TuJrhw8fzlRVVUW/d2Ei2rNnz3tjysnJYRzHsR49enww/vcRJqJVq1ZV2Pbw4UOmoqJS4dw/9H7815w5cxjHcezp06di5RzHMR0dHZabm1vhNb169WICgYC9efNGVDZ8+HDGcRy7c+eOxOPY2NgwIyOjKselzKhpjlTK1tYW2traFcodHBzg7++PuLi4Ck0VXbp0qdax7OzsKpSZmpoCALKzs0VlwvZ9Sc0qH6tnz54Syx0cHHD16lXExcWhV69eovKzZ89i165diI6ORmZmJkpKSkTbOI5DRkYGGjZsWK1YJkyYgK1bt8La2hpjxoyBg4MDunbtCj09vWrtr3nz5qhfv36F8sjISADl/U03btyosP3ly5coLS3FvXv3YGtrCxcXFyxZsgSzZs1CcHAw+vfvjx49esDa2lrsdXXr1sXQoUNx+vRp2NjYwNXVFT179kSXLl2qNVLSwcGhQpmZmRlMTU3x+PFjvH79GnXr1n3vPiIiIrB582ZERkYiPT0dRUVFYtufPXsm+hsTsrCwgI6OToV9NWnSBIwxZGdni84nMjISampqOHr0KJiEha6LioqQnp6O7Oxs6Ovrf/CclRklIlKpyj5UhX0Nkjpjhds+Vr169SqUqaqW/3mWlpaKyl69egUAaNy4cbWO866POb/NmzfD29sbBgYG6NevH5o2bYo6deqA4zj8/vvviI+PR2FhYbVj8fHxgbm5Ofbv34+1a9di7dq1UFVVxaBBg7Bx40a0aNHio/ZX2e8hMzMTALB+/fpKX8txHN68eQMAaNq0KaKiorBs2TJcuHABv/32G4DyD+avvvoKc+bMEb3uyJEjWLduHQ4dOoSlS5cCADQ1NTFq1Chs2LABRkZGVY7/fb+bp0+fIicn572J6Pfff8eoUaNQp04d9OvXDy1atIC2tjYEAgEuX76Mq1evSvx9Sfo7BCT/LWZmZqK0tBTLly+vNA6O45CXl0eJ6AMoEZFKvXjxQmL58+fPAUDit/Xavr9F+EGRkpLyyfuq6vmVlJRg2bJlMDY2xq1btyp8SEZERHxyLAKBAF5eXvDy8kJ6ejquXbuGw4cP49ixY0hISEBCQoLYgI0Pqez3oKenB47jkJOTI/GbvyRWVlY4fPgwSktLER8fj9DQUGzduhVeXl7Q1taGh4cHgPKks3TpUixduhQpKSkICwuDn58fDhw4gOTkZISFhVU5/hcvXsDCwqJC+fv+9t71/fffQ1NTE9HR0WjVqpXYtmfPnuHq1atVjqUywhgyMjI+eV/KjoZvk0rdunULeXl5FcqvXLkCAOjYsaOUIwK6desGoHzIrKTmkI8RHh4ucR//Pb+MjAzk5OSge/fuFZJQXl4ebt26VaMJuEGDBhgxYgSOHDkCR0dHPHjwAAkJCaLtKioqYt/MP0a3bt3AGPuopPDucW1tbfHNN98gMDAQAHDq1CmJdU1NTTF+/HgEBwejRYsWuHbtmlgT64cIfwfvevjwIZ4+fYrmzZt/sFkuKSkJ1tbWFZJQWVkZrl27VuU43qdbt27IysrCnTt3amR/yowSEanUq1evsGLFCrGy6OhoHDx4EPXq1cOIESOkHpOtrS26d++OuLg4rFu3rsL2zMzMKjeR3b9/Hzt27BArO3XqFMLCwmBhYSHqQzIyMkKdOnUQHR0tarICgOLiYnh5eYmau6qrqKhI4lVVcXExsrKywHGcWD+LoaEhXr58iYKCgo8+1uzZs6GmpgZvb2/cv39fYizh4eGi57du3ZLYBCu8MhHGlZGRgb/++qtCvby8POTl5UFNTe2jrug2b96MJ0+eiJ6XlZXh66+/BmOsSvP3mZmZ4Z9//hG7L4oxhmXLluHu3bs18sVBOHx++vTpEu+/evPmjcR+OFIRNc2RSvXq1Qt79+7FjRs30L17d6SlpeHIkSMAgN27d1e5aaemHThwAL1798bixYtx4sQJODg4gDGG+/fvIyQkBPfu3RO7j6iyKydnZ2csWLAA58+fR/v27ZGUlITffvsNWlpa8PX1FdUTCASYO3cu1q5di3bt2mHYsGEoKirC5cuX8erVKzg6OuLy5cvVPp+3b9+iZ8+eaNmyJWxtbdGsWTMUFBQgJCQEiYmJcHFxEftm37dvX0RHR8PZ2Rk9e/aEhoYGbGxsMGTIkA8eq1WrVvD19YWHhwfatGkDZ2dnWFhYoLi4GE+ePEF4eDgaNmwo+pYfEBCAPXv2oEePHjA3N4e+vj4ePHiA06dPQ1NTE/PmzQNQ3lRqa2uLdu3aoV27dmjSpAlev36NM2fO4MWLF6JmvKrq0aMHbGxsMHbsWNStWxfBwcG4ffs27Ozs8M0333zw9d7e3vjyyy/RsWNHjBw5EmpqaoiIiMDdu3dFgyo+lZOTE9auXYtFixbBwsICgwYNQvPmzZGXl4fHjx8jLCwMPXv2xLlz5z75WAqPt/F6RGa9O/Q4MTGRubi4MH19faatrc169OjBLl68WOE1fn5+TCAQiA3p/i9Jw7eXLVvGBAKBxKHS7xsCnZmZyb799lvWqlUrpqmpyfT19VnHjh3Zd999x96+fSuq17t370qHby9fvpxFRkayvn37srp167K6deuyAQMGsOjo6ArHKykpYT///DOztrZmWlpazNjYmE2ePJk9efKEubu7M4FAwB4/flyl2P+ruLiY/fTTT2zgwIGsadOmTFNTkxkZGbFu3bqx3bt3s+LiYrH6b968YZ6enszU1JSpqqoygUAgdhxJ7/N//fXXX8zd3Z01a9aMaWhoMENDQ9auXTv25ZdfssuXL4vq3bhxg3l6erIOHTowAwMDpqWlxSwsLJiHhwdLSEgQ1Xv16hVbsWIFc3JyYo0bN2YaGhrMxMSEOTo6ssOHD3/wPRASDt9+9OgR27hxI7OysmKamprM1NSUeXt7Sxxa3bx5c4nDt/38/JiNjQ3T1tZmDRo0YCNHjmR///13pX9z73vfJP2Oha5du8bGjBnDTExMmLq6OjMyMmIdO3ZkCxYsYDExMVU+d2XGMfaJDe1E4SQnJ8Pc3Bzu7u5iVwaK4sqVK3BycsKyZcvwww8/8B0OeYe7uzsCAgKQnJwsdlVLFBv1ERFCCOEVJSJCCCG8okRECJEZfC9kSPgh94koISEBo0ePFt05bWhoiO7du+PgwYMV6t69exfOzs7Q1dWFoaEhJk+eXOnNaPv27UPr1q2hpaUFS0tLbNu2rbZPRWY0b94cZWVlCtk/BJQvDVFWVkb9QzJo//79KC0tpf4hJSP3w7efPHmCvLw8uLu7w8TEBG/fvsXx48cxadIkJCcnY8mSJQDKh5f26tUL+vr6WLNmDXJzc7Fhwwb89ddfiIqKgpqammifu3fvhqenJ0aNGoWvvvoKYWFhmDt3Lt6+fVuloaOEEEKqTiFHzZWVlaFTp07IysoSrYczc+ZMBAQEIDExUTTR4aVLl9CvXz/s3r0b06dPBwDk5+ejSZMm6N69O4KCgkT7nDRpEk6ePImnT59KnI8qIyMDwcHBaN68ObS0tKRwloQQUrvy8/ORnJyMAQMGSJxEt8bwO3q89gwZMoS1aNFC9NzIyIiNHTu2Qr1WrVqxvn37ip6fPXuWcRzHzp8/L1YvMjKScRzHDhw4IPF4Bw4cYADoh37oh34U7qeyz72aIvdNc0Jv377F27dvkZOTg6CgIAQHB4v6dZ49e4b09HSJSw107twZ58+fFz2PjY0FUHFZAltbWwgEAsTFxWHChAkV9tO8eXMA5Xf9t27duqZOi1fe3t7w8fHhO4wao0jno0jnAtD5yKq7d+9i4sSJos+32qIwiWj+/PnYs2cPgPIp27ds2YIZM2YAgGgeKGNj4wqvMzY2RlZWFoqLi6Gmpoa0tDSoqKhUuAxVV1eHoaEhUlNTJR5f2BzXunVr2Nra1th58UlPT09hzgVQrPNRpHMB6HxkXW13NyhMIvL29saYMWOQmpqKgwcPYvbs2dDS0sKUKVOQn58PABLXudfU1ARQ3haqpqaG/Pz8Sidn1NDQEO2LEEJIzVCYRNSqVSvRxJATJ07EgAEDMG/ePIwdO1aUzSXNyiycwVhYR0tLq8JKju/WpYEIhBBSsxQmEf2Xq6uraPZiYZOcpKna09LSYGhoKBq+bWxsjNLSUmRkZIg1zxUVFSErKwsmJibvPa63t3eFRbvc3Nzg5ub2qadECCG1JjAwULTOlJCkJUBqg8ImImETmkAgQOPGjdGgQQPcvHmzQr2oqCjY2NiIngsXQ7t58yYGDhwoKo+OjkZZWZlYXUl8fHwUpm1Y0ZKnIp2PIp0LQOcjCyR9Yb516xY6depU+wev1TF5UvDy5csKZUVFRczW1pbVr1+flZSUMMYY8/T0ZHXq1GFPnz4V1QsNDWUcx7Hdu3eLyvLz85mhoSEbOnSo2D4nTpzIdHR0WHZ2tsQ4YmJiGACa9p0QojCk9bkm91dEM2bMQG5uLnr16gUTExM8f/4cBw8exD///IP9+/dDRUUFALB48WIcO3YMjo6O8PLyQm5uLtavX4/27duLrfioqamJlStXYtasWRgzZgz69++P8PBwHDx4EKtXr5Z4MyshhJDqk/tENG7cOOzbtw87d+5EZmYm6tati88++wzbtm1Dnz59RPVMTU1x9epVzJ8/HwsXLoSGhgaGDBmCjRs3ik3vAwCenp5QU1PDxo0bERQUhKZNm2LTpk2YO3eutE+PEEIUnkJO8cMHYVtqTEyMwvQREUKUm7Q+1+R+9m1CCCHyjRIRIYQQXlEiIoQQwitKRIQQQnhFiYgQQgivKBERQgjhFSUiQgghvKJERAghhFeUiAghhPCKEhEhhBBeUSIihBDCK0pEhBBCeEWJiBBCCK8oERFCCOEVJSJCCCG8okRECCGEV5SICCGE8IoSESGEEF5RIiKEEMIrSkSEEEJ4RYmIEEIIrygREUII4RUlIkIIIbyiREQIIYRXlIgIIYTwihIRIYQQXlEiIoQQwitKRIQQQnilyncAhBDlVVBQgLS0NKSnpyM7OxvZ2dnIyclBQUEB8vPzUVhYCMYYAIDjOGhqakJLSwt16tSBvr4+DAwMYGhoCBMTExgaGoLjOJ7PiFQHJSJCSK1hjOHp06dITExEYmIiHjx4gEePHiE5ORkpKSnIzs6W+Lo6depAS0sLGhoaouRSVlaGgoICUZL6L01NTZiamqJly5awsrKClZUV2rVrBxsbG9SpU6dWz5N8GkpEhJAaUVxcjL///hs3b95EXFwc4uPjcfv2beTl5QEANDQ0YGZmBjMzM/To0QNNmjSBiYkJjI2NYWRkJLrC0dHR+eCVTVlZGXJycpCZmYmMjAykpqbi6dOnePLkCe7fv49z585h69atKC0thUAggLW1Nbp27QpHR0c4OjrC2NhYGm8JqSJKRISQasnOzkZERATCw8MRERGBW7duIT8/HyoqKmjVqhVsbGzg4uKCNm3awMrKCs2bN4eKikqNHFsgEEBfXx/6+vpo2bKlxDpFRUVISEhAdHQ0oqOjERERgb179wIA2rRpg2HDhsHFxQWdO3eGQEDd5XyiREQIqZK3b98iPDwcoaGhuHTpEuLi4sAYg4mJCXr06AFXV1d06dIFHTt2lImmMHV1dXTs2BEdO3bE9OnTAQAvXrzAlStXcOHCBezZswdr1qyBiYkJJkyYgMmTJ6Nt27Y8R62cKBERQir16NEjnDlzBufOncPly5dRWFgIY2Nj9O3bF3PnzkWvXr1gZmYmN4MEGjZsiLFjx2Ls2LEoKSnBn3/+iaNHj8LX1xfr16+Hra0tZs6ciQkTJkBTU5PvcJUGXY8SQkQYY4iPj8eyZcvQoUMHmJubY8GCBSgqKsLq1auRkJCAZ8+eISAgAO7u7jA3N5ebJPRfqqqq6NWrF7Zt24bU1FScPHkSJiYmmD59Opo2bYrly5cjKyuL7zCVAiUiQggSEhLwww8/wMrKCjY2Nti0aRPatWuHY8eOITMzE5cuXcL8+fNhbW0tt4nnfdTV1eHi4oLTp0/j3r17GD16NNatWwczMzOsWLECr1+/5jtEhUaJiBAllZaWho0bN8LGxgZt27bFli1b0L17d5w/fx4vX77EgQMHMGrUKOjq6vIdqlRZWFhg+/btePToETw8PLB69WqYmZlhy5YtKCkp4Ts8hUSJiBAlYGEBCASAujqDk1MyhgwZAlNTUyxevBgtW7bEyZMn8eLFC+zfvx/Ozs5QV1fnO2TeNWzYED4+PkhKSoKrqyvmzZsHOzs73Lhxg+/QFI7cJ6KbN29i9uzZaNOmDXR0dNCsWTOMHTsW9+/fr1D37t27cHZ2hq6uLgwNDTF58mRkZGRI3O++ffvQunVraGlpwdLSEtu2bavtUyGkxllYABwHJCUxMAYUF3O4fNkUN27MwI4dO/D8+XMcP34cLi4u0NDQ4DtcmWRqaoo9e/YgKioKKioq6NatG+bNmyfxplpSTUzOubq6MhMTE+bl5cX27dvHVq1axRo1asR0dHTY33//Lar39OlTVr9+fWZhYcG2bt3KVq9ezQwMDJiNjQ0rKioS2+euXbsYx3Fs9OjRbO/evWzy5MmM4zi2bt26SuOIiYlhAFhMTEytnSshVdWyJWNA2f9/WIUfS0u+I5RPJSUl7Oeff2YaGhrM2tqa3bp1i++QapW0PtfkPhH9+eefrLi4WKzs/v37TFNTk02cOFFU5unpybS1tdnTp09FZaGhoYzjOLZnzx5R2du3b5mhoSEbOnSo2D4nTpzIdHR0WHZ2tsQ4KBERvk2dypia2vsTEMCYQFBel1RfQkICs7GxYerq6mznzp18h1NrpPW5JvdNc926dYOqqvjtUC1btoS1tTUSExNFZSdOnBC1iwv16dMHlpaWOHr0qKjs8uXLyMrKwsyZM8X2OWvWLLx58wZnz56tpTMhpPrq1gX272coLgYA7v8/kk2ZAvj6SisyxWRtbY0bN25g+vTp8PT0xOzZs2kgwyeQ+0QkCWMML168QP369QEAz549Q3p6Ouzs7CrU7dy5M2JjY0XPhY//W9fW1hYCgQBxcXG1GDkhVefhAejpARzHkJvL8L7kAwAtW5ZfE1ESqhnq6urYtm0bdu3ahd27d2PQoEF49eoV32HJJYVMRAcPHkRqairGjh0LoHyYKgCJEx0aGxsjKysLxeVfJZGWlgYVFRVREhNSV1eHoaEhUlNTazl6Qt7PwwNQVy+/Aiq/veX9V0DCBCRh/A6pAV988QWCg4MRHR2Nnj174uXLl3yHJHcULhElJiZi1qxZ6N69O6ZMmQIAotEtkkYFCafxENbJz8+vdOiqhoYGjZQhvHk3Af3bBCeZmhowdSolIGlxcnJCREQEMjIy0KdPH0pGH0mh5pp7/vw5Bg8eDH19fRw/flx0B7iWlhYAoLCwsMJrCgoKxOpoaWmhqKhI4v4LCgpE9Srj7e0NPT09sTI3Nze4ubl93MkQ8n8eHsCBA0BxsbD5rfIEpKsL0CQA/GjdujUuX74MR0dH9OnTB5cuXYKRkRHfYVVZYGAgAgMDxcpycnKkcmyFSUQ5OTkYOHAgXr9+jfDwcDRq1Ei0TdgkJ2yie1daWhoMDQ2hpqYmqltaWoqMjAyx5rmioiJkZWXBxMTkvXH4+PjA1ta2Jk6JEFhYlN8D9L4ExHHlCcjVlfp/+GZlZSVKRv369UN4eDjq1q3Ld1hVIukL861bt9CpU6daP7ZCNM0VFBRg6NChSEpKwpkzZ2BlZSW2vXHjxmjQoAFu3rxZ4bVRUVGwsbERPe/YsSMAVKgbHR2NsrIysbqE1CY3t3wkJZWhsgQkbH4rKwNycigJyQorKyuEhoYiOTkZ48ePR2lpKd8hyTy5T0SlpaUYO3Ysbty4gWPHjuGzzz6TWM/V1RVnzpxBSkqKqOzSpUu4f/8+Ro8eLSpzcnKCgYEBdu7cKfb6nTt3QltbG4MHD66dEyHk/968eYMVK1bgyJEUSPovKkxARUWUfGRVmzZtcOTIEZw/fx7ffvst3+HIPLlvmluwYAFOnz6NoUOHIiMjAwcOHBDbPnHiRADA4sWLcezYMTg6OsLLywu5ublYv3492rdvj6lTp4rqa2pqYuXKlZg1axbGjBmD/v37Izw8HAcPHsTq1atRr149qZ4fUR5lZWU4ePAgFi1ahPT0dNSt64mcnH+HZXMc4O5OyUdeODs7w8fHB15eXmjbti3c3d35Dkl21ertslLQu3dvJhAIGMdxFX4EAoFY3YSEBDZgwACmra3NDAwM2KRJk9jLly8l7veXX35hVlZWTENDg1lYWLDNmze/Nw6aWYF8isjISNa5c2cGgLm6urIHDx4wc3OalkfelZWVMQ8PD6alpcXu3r3Ldzgfjab4kTOUiEh1PH/+nLm7uzMArGPHjuzq1auibZMn/5uEGjSgaXnk1Zs3b1irVq2YnZ1dhXktZR1N8UOIAispKcGWLVtgaWmJoKAg7Nq1Czdv3kSvXr1Edfz9y/8VCMpnUKAmOflUp04dHDhwAHFxcVi5ciXf4cgkSkSESFlUVBS6dOmCefPmYfzqBQ71AAAgAElEQVT48fjnn3/wxRdfQEVFRayeh0d5v5BwVJyHB08Bk09mZ2eHJUuWYO3atbhz5w7f4cgcSkSESMnr168xa9YsdO3aFQBw/fp17Ny5E4aGhhLrR0SUN8wBQHp6+XMivxYuXIjmzZvD09MTTPiLJQAoEREiFUFBQbC2toa/vz98fHxEV0XvY28PCCeWb9Cg/DmRX5qamti5cyfCwsJw8OBBvsORKZSICKlF6enpGDt2LFxcXNChQwfcuXMHXl5eFZYukcTXtzwB6egAQ4ZQH5Ei6NOnD0aMGIHvv/++0qnElBElIkJqAWMMR44cgbW1NS5duoRDhw7hzJkzaNq06UftR129vI+IKI6VK1fi8ePH8KVvFiKUiAipYenp6Rg1ahTGjRsHR0dH3LlzB25ubqJJeKvKwwN48QJ4+xY4c4YGKyiKNm3awM3NDatWrRJNuqzsKBERUoNOnTqFNm3a4OrVqzh69CiOHj1a7RmYIyIA4ecUDVZQLEuXLkVqaioCAgL4DkUmUCIipAa8fv0aU6dOxfDhw9G1a1ckJCSIzWFYHfb2QJ065Y9psIJisbS0xPDhw+Hj44MyanulRETIp4qMjISNjQ2OHz+Offv24dSpU2jYsOEn79fX999ERDe0Kp758+cjMTERFy5c4DsU3lEiIqSaSkpKsHz5cvTs2RONGjVCfHw8PDw8ProvqDIeHv82zb16RX1Eisbe3h62trbYvXs336HwjhIRIdWQkpKCPn36YMWKFfjuu+8QFhYGc3PzGj1GRASQl1f+OCOD+ogUDcdxmDp1Ks6dO4f09HS+w+EVJSJCPtLp06fRoUMHPHz4EFeuXMGyZcuqdF/Qx7K3L2+SAwADA+ojUkTjxo0Dx3E4fPgw36HwihIRIVVUXFyMr776CsOGDUOPHj0QFxeHnj171trxfH0B4e579qQ+IkVUv359DBo0qMI6asqGEhEhVZCSkgJHR0ds3rwZP//8M06ePFnpHHE1acOG8n9jYqiPSFG5uroiKioKqampfIfCG0pEhHxAaGgoOnbsiMePHyMsLAze3t41NiDhQ5YtK/83JYVualVUgwcPhoqKCk6fPs13KLyhRERIJRhjWLt2LQYMGABbW1vExsaiW7duUo0hOvrfx3RTq2IyMDBAz549KRERQsTl5uZi1KhRWLRoERYuXIhz586hfv36Uo/j3S4ouqlVcfXv3x9Xr15FcXEx36HwghIRIf+RlJSErl27IiQkBL///jt+/PHHCovWSYuvb/kKrbRKq2JzcnJCXl4eYmJi+A6FF5SICHnHxYsX0blzZ5SUlCAqKgrDhw/nNR5hnxCt0qrYOnXqBF1dXVy+fJnvUHhBiYgQlPcHbd68GQMHDkS3bt1w48YNWFlZ8R0WIiL+XQaC+ogUl6qqKrp06YKbN2/yHQovKBERpVdcXIwvv/wS8+bNw/z583H69GnUq1eP77AAlPcJqamVP6Y+IsXWqVMnRL87OkWJUCIiSi07OxvOzs7Yv38/9u3bh/Xr1/PWHySJry/QqFH55Ke0Sqtis7Ozw9OnT/Hy5Uu+Q5G6mp+XhBA58fDhQwwaNAjp6ekICQmBg4MD3yFJpKFBq7Qqg/bt2wMAEhISqr2GlbyiKyKilKKiotC1a1eUlpbi+vXrMpuEPDyAZ8/KZ+GmG1oVm7m5OVRVVZGYmMh3KFJHiYgonZMnT6J3796wtLREZGQkLCws+A6pUhERQH5++WMarKDY1NTU0KJFC0pEhCi6Xbt2wdXVFYMHD0ZoaCgvN6l+DHt7QFu7/DENVlB8LVu2xMOHD/kOQ+ooERGlwBjD0qVL4enpidmzZ+PIkSPQ1NTkO6wPolValUuTJk2QkpLCdxhSR4mIKLzS0lJ8+eWXWLFiBdauXYtNmzZBIJCPP30PD6CwsPxxdjb1ESm6Jk2a4OnTp3yHIXU0ao4otMLCQkyYMAEnT56En58fpkyZwndIHyUiAnj9uvxxZib1ESk6Y2NjZGZmoqioCOrq6nyHIzXy8bWQkGp48+YNhg0bhjNnzuC3336TuyQElPcJCe+t1denPiJFJ1zjKjs7m+dIpIsSEVFI2dnZ6NevH/7880+cP38ew4YN4zukavH1BRwdyx9360Z9RIpOmIgyMzN5jkS6KBERhZOeng4nJyfcu3cPf/zxBxyFn+Ryatu28n/j4qiPSNEJp5Z69eoVz5FIFyUiolCeP3+O3r17IzU1FVeuXEHnzp35DumTLVxY/m9qKt3Uqui0tLQAAPnCm8eUBA1WIArj2bNnonVdrl69KhOzZ9eE69f/fUw3tSo2ZU1EdEVEFEJKSgp69+6NgoIChIWFKUwSAoAePQCOK39MN7UqNg0NDQDloz2VCSUiIvdSUlLg6OiIoqIiXLlyBS1atOA7pBrl6wuoqNAqrcqAE37jUDIKkYjevHmDpUuXwtnZGQYGBhAIBPD395dY9+7du3B2doauri4MDQ0xefJkZGRkSKy7b98+tG7dGlpaWrC0tMQ2Ya8xkRn/TUJmZmZ8h1TjPDwAxmiVVqK4FCIRpaenY+XKlbh37x5sbGwASP5mkZKSgl69euHhw4dYs2YNvvrqK5w9exb9+vVDcXGxWN3du3dj+vTpaNeuHbZt24Zu3bph7ty5+Omnn6RyTuTD0tLS4OTkpNBJCCjvEyotLX9MfUSKrez/630o25WRQgxWMDExwfPnz2FkZISYmJhKR0qtXr0a+fn5iI2NhampKQCgS5cu6NevH/z8/DB9+nQA5R2FS5YswZAhQ3D06FEAwOeff46ysjKsXLkSM2bMkJkVPJVVeno6+vbti7dv3yIsLExhkxBQ3ieUnAwUFVEfkaIrKCgAALmYB7EmKcQVkbq6umghKcZYpfVOnDiBIUOGiJIQAPTp0weWlpaihAMAly9fRlZWFmbOnCn2+lmzZuHNmzc4e/ZsDZ8B+RhZWVno378/MjMzcenSJZibm/MdUq3y9QWaNAE0NWmVVkUnHC0nHD2nLBQiEVXFs2fPkJ6eDjs7uwrbOnfujNjYWNFz4eP/1rW1tYVAIEBcXFztBksqlZeXh0GDBuHp06cIDQ1Fq1at+A5JKtTUaJVWZUCJSMGlpaUBKJ9U8L+MjY2RlZUl6idKS0uDiopKhbVq1NXVYWhoiNTU1NoPmFRQWFiI4cOH486dOwgODkbbtm35DkkqPDyAJ0/Km+bohlbFJpxRQdma/pUmEQm/aQjH6b9L2B4rrJOfn1/pzLcaGhpKd7OZLCgpKYGbmxsiIiJw+vRpdOrUie+QpCYiAnj7tvwxDVZQbFlZWQAAfX19niORLqVJRMJLXUk3igk7CIV1tLS0UFRUJHE/BQUFSnfZzDfGGL744gucPn0ax44dg4ODA98hSZW9PaCjU/6YBisoNuGs28qWiBRi1FxVCJvkhE1070pLS4OhoSHU1NREdUtLS5GRkSHWPFdUVISsrCyYmJhUehxvb2/o6emJlbm5ucHNza0mTkMpfffdd/D19cWvv/6KIUOG8B2O1Pn6AufOAXl5QN26NFhBkb148QL16tXjZS2iwMBABAYGipXl5ORI5dhKk4gaN26MBg0a4ObNmxW2RUVFie4/AoCOHTsCAG7evImBAweKyqOjo1FWViZW9798fHxga2tbg5Ert23btmH16tXYsGEDJk6cyHc4vPDwAP5/0S5apZWSkWJKTU2V2I8tDZK+MN+6dUsqzeBK0zQHAK6urjhz5ozYmvCXLl3C/fv3MXr0aFGZk5MTDAwMsHPnTrHX79y5E9ra2hg8eLDUYlZmx48fx9y5czF//nwsWLCA73B4ExFRPqMCAGRlUR+RIktLS+MtEfFJYa6Itm3bhlevXolGtAUFBeHJkycAgLlz56Ju3bpYvHgxjh07BkdHR3h5eSE3Nxfr169H+/btMXXqVNG+NDU1sXLlSsyaNQtjxoxB//79ER4ejoMHD2L16tVKN6KFDxEREZg4cSLGjRuH9evX8x0Or+ztywcpZGeXr9ZKfUSK68mTJwo1YW+VMQXRvHlzxnEc4ziOCQQCJhAIRI8fP34sqpeQkMAGDBjAtLW1mYGBAZs0aRJ7+fKlxH3+8ssvzMrKimloaDALCwu2efPmSo8fExPDALCYmJgaPzdl888//zBDQ0Pm4ODACgoK+A5HJowZwxjAWP/+fEdCapORkRFbtmwZ32GISOtzTWGuiB49elSletbW1rhw4UKV6k6bNg3Tpk37lLDIR8rIyMCgQYPQoEED/P777xKH2yujX34Bjh4Fbt+mPiJF9fbtW7x8+VKhp6uqjFL1ERHZVlhYiJEjRyInJwdnz55VuiGs7+PlVf7v8+d0U6uiSkpKAgCFW8akKhTmiojIN/b/e4WioqLwxx9/KPz8cR/rzz//fUw3tSqmu3fvAoBS9hHRFRGRCevXr4e/vz/27duH7t278x2OzLG3L18YD6CbWhVVYmIiGjRoAENDQ75DkTpKRIR3Z86cwcKFC7FkyRJMmDCB73Bkkq8voKpKq7QqsoSEBFhbW/MdBi8oERFe3b17F+PHj4eLiwtWrFjBdzgyy8OjfPZtWqVVccXFxb33ZnlFRomI8CY7OxsuLi5o2rQpAgICIBDQn2NlIiKAkpLyx9RHpHjy8vKQlJSEDh068B0KL2iwAuFFWVkZJkyYgIyMDNy8eRO6urp8hyTT7O2Bx4+BwkLqI1JE8fHxYIzRFREh0rR8+XJcuHABhw4dUsrhqh/L1xcwMwPU1WmVVkUUFRUFTU1NpVlj67/oiohI3ZkzZ7BixQqsWrUKzs7OfIcjN2iVVsUVFRWFTp06iVYAUDZ0RUSk6uHDh5g0aRJcXFywaNEivsORGx4ewMOH5f1EdEOr4rl+/Tq6dOnCdxi8oUREpKagoACjR4+GgYEB/Pz8aHDCR4iIAN68KX9MgxUUS0pKCpKTk9GjRw++Q+ENNc0RqfH29kZCQgIiIyNpBvOPZG8PpKUBublA/fo0WEGRhIeHA4BSJyL6Skqk4vDhw9i1axe2bNkiWniQVJ2vL/DZZ+WPhYvkEcVw9epVtGrVCkZGRnyHwhtKRKTWPXjwADNmzICbmxumT5/OdzhyS7h6dF4e9RMpkkuXLsHJyYnvMHj10YnowYMHOHv2LG7cuIGySobw/PXXX3SXPAEAFBUVYdy4cTAyMsKuXbvAcRzfIcmthIR/H1M/kWJ4/PgxkpKS0LdvX75D4VWVE1FZWRnc3d1hYWGBoUOHolu3brC0tJS4tk98fDyWL19eo4ES+bRkyRLEx8fj8OHDqFu3Lt/hyLV3B1XRTa2KITQ0FBzHoXfv3nyHwqsqJ6I9e/YgICAAU6dOxalTp7B7925oaGhg0KBBWL16dYX6jLEaDZTIn0uXLmHDhg1YvXo17Ozs+A5H7u3ZU/6vsTHd1Koozp8/j88++wwGBgZ8h8KrKo+a27NnD0aMGIF9+/aJyqZMmYLZs2fju+++w7Nnz7B9+/ZaCZLIn8zMTEyePBl9+vTB/Pnz+Q5HIQhnQaKbWhVDcXExQkJC8NVXX/EdCu+qfEWUlJRU4S54dXV17NmzB+vWrcOuXbswZswYFBcX13iQRL4IF7krKCiAv78/3S9UQ6ZPBzgOePGCBisogmvXruH169cYOHAg36HwrspXRDo6Onj9+rXEbV9//TUaNGiAadOmYeDAgXB1da2xAIn8OXjwIE6cOIFjx46hcePGfIejMCIiAGGLNw1WkH9BQUEwNjaGra0t36HwrspfVdu2bYuLFy9Wut3d3R0nTpxAREQEvvrqKxodpaSePn2K2bNnY8KECRg1ahTf4SgUe3tARaX8MQ1WkG+MMZw8eRLDhw+nFgN8RCJycXFBaGioaF31yuoEBwdDTU2NBisoIcYYPv/8c+jo6GDr1q18h6NwhKu0chyt0irv4uPjkZycjOHDh/MdikyociLy8PBAfHz8B+/+7dWrF+Lj4/HHH398cnBEvuzduxchISHYt28f9PX1+Q5H4QhXaWWMVmmVd8ePH4e+vr7SD9sWqnIfkZaWVpXXymjWrBmaNWtW7aCI/Hny5AkWLFiAzz//HAMGDOA7HIUUEQEIxwJRH5H8YozhyJEjGDFiBNSF02UoOWqcJJ+MMYYZM2ZAT08PGzdu5DschWVvD2hqlj+mPiL5FRsbi6SkJIwdO5bvUGQGJSLyyX799VcEBwdj9+7d0NPT4zscheXrC7RsWb5AHt3QKr8OHTqE+vXrw9HRke9QZAYlIvJJXr58CW9vb4wfPx6DBg3iOxyFp64OlJbyHQWprtLSUhw6dAjjxo1T2tVYJaFERD6Jt7c3AMDHx4fnSBSfhwfwzz/lAxbohlb59McffyAtLQ2TJk3iOxSZQgvjkWoLCQnBoUOH4Ofnp9RrqUhLRET5EhAADVaQV35+fmjVqhU6d+7Mdygyha6ISLUUFBRg5syZcHBwwOTJk/kORynY2wPCCcwNDWmwgrzJzs7GiRMn4OHhQTf8/0e1r4jS0tKwb98+xMbGIicnR2xtIsYYOI6je4kU2Lp16/D48WMEBQXRfyop8fUFnj8Hzp8HCgv5joZ8rMOHD6OkpIS+uElQrUR0+/ZtODg4oKCgAJaWlvjrr7/Qpk0bZGdnIzU1Febm5mjSpElNx0pkxMOHD7FmzRp89dVXaN26Nd/hKBVJq7TS6DnZxxjDL7/8gsGDB6NRo0Z8hyNzqtU0t3DhQujo6CAxMRGXLl0CAGzatAkpKSk4cuQIXr16hXXr1tVooER2eHt7w8jICEuWLOE7FKUTH//vY+onkh9RUVGIjY3Fl19+yXcoMqlaiSgiIgJffPEFmjVrJmqWEc4tN3r0aIwfP57W2FBQ58+fR1BQEDZu3AhtbW2+w1E63bv/+5huapUfO3fuRPPmzdG/f3++Q5FJ1UpEZWVlosvLevXqQUVFBVlZWaLt7dq1Q0xMTM1ESGRGcXEx5s2bB0dHR5pZmyf+/uX/NmxIN7XKi8zMTBw5cgRffPEFVITTpxMx1UpEzZs3x6NHjwAAKioqaN68OUJCQkTbIyMjUa9evZqJkMiMHTt2ICkpCZs2baIBCjxRVS3/oZta5ccvv/wCxhimTZvGdygyq1qJaMCAATh69Kjo+cyZM7Fv3z707dsXTk5O8PPzw/jx42ssSMK/zMxMLFu2DNOnT0f79u35DkdpCWfgzsigm1rlQUlJCbZv344JEyagfv36fIcjs6o1am7JkiUYN24cioqKoK6ujnnz5uHNmzc4fvw4VFVV8cMPP2Dx4sU1HSvh0YoVK1BaWooVK1bwHYpSi4goT0QADVaQB7/99htSUlIwZ84cvkORadW6ItLX14ednZ1oCnOO4/Ddd98hLi4O0dHRWLZsmdxPb15YWIhvv/0WJiYmqFOnDrp27YrQ0FC+w+JFUlISduzYgUWLFtEMCjyzty9vmgNosIKsY4xhw4YNcHJygo2NDd/hyDSaWaES7u7u8PHxwaRJk7BlyxaoqKhg0KBBiFDCr6BLlixBo0aNMG/ePL5DUXq+vuX3EtEqrbIvPDwcN2/epBHEVVDtmRWSk5Ph7++PR48eITs7W+LS4EFBQZ8UHF+ioqJw5MgRbNiwAfPnzwcATJo0CW3btsU333yjVMno5s2bOHr0KHx9faGlpcV3OErPw6N8oMK7q7RSMpJN69evR9u2beHs7Mx3KDKvWokoMDAQkydPRmlpKerVq4e6wgmw3iHPo6qEfV0zZswQlWloaODzzz/H4sWL8ezZMzRu3JjHCKVnyZIlsLa2pmlJZERExL/T+1Afkey6ffs2zpw5A39/f7n+LJSWaiWiRYsWwcrKCidOnIClpWVNx8S72NhYWFpaQkdHR6xcOGNuXFycUiSiK1euICQkBCdOnKD7H2SEvT3w9CmQn099RLJszZo1aNasGdzc3PgORS5Uq48oIyMDnp6eCpmEgPIJXY2NjSuUC8tSU1OlHZLUMcawZMkS2NnZYcSIEXyHQ/7P1xewsgJUVOiGVll1//59HD16FN9++y0tfldF1boi6tKlC548eVLTsciM/Px8aGhoVCjX1NQUbVd0ISEh+PPPP3H+/HlqWpAxtEqrbPvxxx/RsGFDTJ06le9Q5Ea1rog2bdqEgIAAHDt2rKbjkQlaWloolDDPfkFBgWi7ImOMYdmyZejatSsGDBjAdzjkHR4ewJ075Y9Pn6YbWmVNUlISDhw4gEWLFom+uJIPq9YVUfv27bFixQqMHTsW06ZNg6mpqVgfgnA9otu3b9dYoNJkbGwssfktLS0NAGBiYlLpa729vaGnpydW5ubmJldtxSEhIYiMjMSFCxfoakjGREQAubnljzMyaLCCrFm5ciWMjIwwffp0vkP5aIGBgQgMDBQry8nJkcqxq5WItm/fjjlz5kBLSwvm5uYVPngB+R4117FjR1y5cgW5ubnQ1dUVld+4cQMA3ntzmo+PD2xtbWs9xtq0atUqdOnShWYKlkH29kB2dvmIORqsIFvu3r2LAwcOYNOmTXJ5NSTpC/OtW7fQqVOn2j84q4bGjRsze3t79urVq+q8XObduHGDcRzHNmzYICorKChgLVu2ZN26dZP4mpiYGAaAxcTESCvMWhEWFsYAsFOnTvEdCqnE1KmMWVqW/0tkx+jRo1nTpk1ZQUEB36HUGGl9rlXriignJwcTJ06UeCWkCLp06YLRo0dj0aJFePnyJVq0aAF/f388efIE+/fv5zu8WrVmzRq0bdsWQ4YM4TsUUgkaKSd7bt26hWPHjsHX11fiQCfyftVKRL169cJff/1V07HIlICAAHz//ff49ddfkZ2djQ4dOuDMmTPo0aMH36HVmtu3b+P8+fM4cOAABAKa/YmQqlq4cCGsrKwwadIkvkORS9X6tNmxYweuXLmCdevWITMzs6ZjkgkaGhr46aefkJqaivz8fFy/fh39+vXjO6xatWHDBjRt2hRjxozhOxRC5MbFixcREhKCNWvWQFW12rOmKbVqJaK2bdvi0aNHWLRoERo0aABtbW3o6upCV1cXdevWFf1L5EdKSgoCAwMxb948ugmPkCoqKyvDt99+C3t7e7i4uPAdjtyqVvp2dXX9YB15HjWnjLZt24Y6derQKpKEfISAgADExcUhIiKCPvM+QbUSkZ+fXw2HQfj09u1b/PLLL5g2bZrYcHVCSOXy8vKwePFijBkzBt27d+c7HLlGPdIEhw4dQnZ2NmbNmsV3KITIjXXr1iErKws//fQT36HIvWpdEX1oanOO46CpqQlTU1PY2trScEYZxhjD1q1bMXToUJibm/MdDiFyITk5GRs2bMCCBQvQrFkzvsORe9VKRB8zmZ+enh4WLlyIb7/9tjqHIrUsMjISt2/fpm91hHyE+fPnw9DQEIsWLeI7FIVQrUQUGxuLKVOmoH79+pg1axZatGgBoHzCv+3btyM7Oxtbt25Feno6tm7dikWLFkFXVxczZ86s0eDJp9u1axdatGih8EPTCakpFy9exO+//47AwMAKa5aR6uEYk7DG9we4u7sjLS1N4qSYZWVlGDhwIIyNjeHn54fS0lL06tULr1+/VuibYIVzMsXExMjNXHNZWVkwMTHBihUr8M033/AdDiEyr7CwEB06dEDDhg1x5coVhR8pJ63PtWoNVjh16hSGDx8u8ZcgEAgwbNgwnDp1CgCgoqKCkSNH4v79+58WKalxBw8eRGlpKdzd3fkOhRC5sH79ejx48ADbt29X+CQkTdVKRKWlpUhMTKx0+71791BWViZ6rqGhIZez0So6X19fDB06FEZGRnyHQojMe/DgAX788UfMnz8fbdu25TschVKtROTi4oIdO3Zg69atosXigPKVS7ds2YKdO3di6NChovLr16+jZcuWnx4tqTGxsbGIi4uDB62sRsgHMcYwa9YsGBkZ4YcffuA7HIVTrcEKmzZtwoMHD+Dl5YWvv/4axsbGYIwhLS0NxcXF6NKlCzZv3gygfFVTTU1NLFiwoEYDJ58mICAARkZGcHZ25jsUQmTeoUOHEBwcjNOnT0NbW5vvcBROtRKRoaEhrl27hpMnT+LChQt4/PgxAKB///5wdnbG8OHDRbM3a2pqYu/evTUXMflkJSUlCAwMhJubG03SSMgHZGRkYN68eRgzZgwtj1JLqv0pJBAIMHLkSIwcObIm4yFSEBoaihcvXtCU9YRUwfz581FaWipq5SE1j74OK6EjR47A0tJSboaZE8KXM2fO4Ndff4Wfnx8aNWrEdzgKq0qJyMzMDBzH4d69e1BTUxM9l3QLkrCc4zg8fPiwxgMmn6awsBC///475s6dS8NPCXmPV69e4YsvvsDAgQMxefJkvsNRaFVKRA4ODuA4TvTB5eDg8MHX0IecbAoJCUFOTg7Gjh3LdyiEyDRvb2/k5eVhz5499HlWy6qUiP677AMtAyG/fvvtN1hZWaFNmzZ8h0KIzAoKCoKfnx/27t0LU1NTvsNReLQMhBIpKSlBUFAQRowYwXcohMis9PR0TJ8+HUOGDKH77KSkWokoNjYWgYGBYmUXLlxAz5498dlnn2HTpk01EhypWREREcjMzMTw4cP5DoUQmcQYg6enJ0pLS/HLL79Qk5yUVCsRffvttzhy5Ijo+aNHjzBy5EgkJyeDMYb58+dj9+7dNRYkqRmnT59Go0aNYGdnx3cohMgkf39/nDhxArt27aJRclJUrUQUHx8Pe3t70fOAgAAIBALcunULUVFRGD16NCUiGXTu3DkMHDhQdLMxIeRfDx48wJw5czB16lSMGjWK73CUSrU+kXJyclC/fn3R83PnzqFfv35o0KABAKBv374027aMefToEe7evYvBgwfzHQohMqe4uBjjx49Hw4YN6cZVHlTrhtZGjRrhzp07AIC0tDTExMSILSWQl5dH37plzMWLF6GiooK+ffvyHQohMueHH35ATEwMIiIioKury3c4SqdaiWj48Kwn5n8AACAASURBVOHYunUrCgsLcf36dairq4uNxLp9+zbMzc1rLEjy6UJDQ/HZZ59BT0+P71AIkSkhISFYu3Yt1q5di88++4zvcJRStS5bVq5cCVdXVwQEBCA9PR3+/v6ijr2cnBwcO3YM/fv3r9FASfWVlZXhjz/+QJ8+ffgOhRCZIpxzsV+/fvj666/5DkdpVeuKSFdXFwcPHqx0W0pKCk2VLkNu376NrKwsSkSEvKO0tBTjx48HAPz666/UncCjGp/0VCAQoF69ejW9W/IJwsLCoK6uTs0OhLxj+fLluHLlCkJDQ9GwYUO+w1FqNPu2EggPD0eXLl1ouXZC/i84OBirVq3CypUr4ejoyHc4So+uRRUcYwwRERHo0aMH36EQIhMeP36MCRMmwNnZGYsWLeI7HAJKRAovJSUFaWlp6NatG9+hEMK7/Px8uLq6QkdHh/qFZAg1zSm4GzduAAA6d+7McySE8IsxhpkzZyIhIQEREREwNDTkOyTyf5SIFFxUVBRMTU1hbGzMdyiE8Grnzp3w8/ODn58frU4sY+i6VMHFxcWhU6dOfIdBCK/CwsLg5eWFOXPmYMqUKXyHQ/6DEpECY4whLi4OHTp04DsUQnjz+PFjuLq6omfPnti4cSPf4RAJKBEpsOfPnyM9PZ0SEVFaubm5GDZsGHR1dXHs2DGoqanxHRKRgPqIFJhwYtq2bdvyHAkh0ldaWoqJEyfi0aNH+PPPP2lwggyjRKTAEhMToaamRhPQEqW0aNEinDlzBqdPn6YvYzJO7pvmnj9/joULF8LR0RG6uroQCAS4evVqpfX//PNP9OjRA9ra2jA2NoaXlxfevHlToR5jDD/99BPMzMygpaWFDh064PDhw7V5KjUuMTERFhYWUFWl7xtEuezduxfr16/Hxo0bMWjQIL7DIR8g94koMTERP/30E9LS0tC+fXsAqHSd+bi4OPTp0wcFBQXw8fHBtGnTsGfPHowePbpC3cWLF2PhwoUYMGAAtm3bhqZNm2L8+PFiS6TLuqSkJLRs2ZLvMAiRqosXL+LLL7+Ep6cnvLy8+A6HVAWTc7m5uSw7O5sxxtixY8cYx3Hs6tWrEusOHDiQNW7cmOXm5orK9u7dyziOYxcvXhSVpaSkMDU1NTZnzhyx1/fq1Ys1adKElZaWVth3TEwMA8BiYmJq4rRqRKtWrZiXlxffYRAiNXFxcUxXV5cNHjyYFRcX8x2O3JPW55rcXxHp6OhUabbv169fIzQ0FBMnToSOjo6ofPLkydDR0cHRo0dFZadOnUJJSQlmzpwptg9PT0+kpKQgMjKy5k6glpSVlSE5ORlmZmZ8h0KIVDx9+hSDBw+GhYUFDh8+TE3SckTuE1FV/fXXXygpKYGdnZ1YuZqaGmxsbBAbGysqi42NhY6ODqysrMTqCqfJiYuLq/2AP1FGRgYKCwvRtGlTvkMhpNZlZWVhwIABUFVVxZkzZ8S+bBLZpzSJKC0tDQAkTnXTqFEjpKamitWVtD6J8LXv1pVV7ztfQhRJfn4+hg0bhpcvXyI4OJj+5uWQTF27MsZQWFhYpbofu7ZOfn4+AEBDQ0PivoTbhXUrq/fuvmSZMBGZmJjwHAkhtaekpARubm6IjY3FH3/8gVatWvEdEqkGmUpEV69ehZOTU5XqJiYmwtLSssr71tLSAgCJia6goAB16tQRq1tQUCCx3rv7ksTb2xt6enpiZW5ubnBzc6tyrDXhxYsXAAAjIyOpHpcQaSkrK8P06dNx9uxZnDp1ilYg/kSBgYEIDAwUK8vJyZHKsWUqEbVu3Rp+fn5VqtuoUaOP2rfwcl14pfCutLQ0sSsHY2NjXLlyRWI94P1XGT4+PjIxs292dja0tLRoVVaikBhjWLBgAfz9/XHgwAG6V6gGSPrCfOvWLalMmixTiahhw4aYPHlyrey7bdu2UFVVxc2bNzFq1ChReVFREeLi4jBu3DhRWceOHbFv3z7cvXsXrVu3FpUL1/axsbGplRhrUnZ2NgwMDPgOg5BasWrVKmzatAk7duzA+PHj+Q6HfCKlGaygp6eHvn374sCBA8jLyxOV//rrr3jz5o3YTa0uLi5QU1PDjh07RGWMMezatQumpqbo3r27VGOvjlevXlVoIiREEfj4+OCHH37AqlWr4OnpyXc4pAbI1BVRda1atQoAkJCQAAAICAhAWFgYAOC7774T1fvxxx/RvXt3ODg4YPr06UhJScHPP/+MAQMGoH///qJ6jRs3xrx587B+/XoUFxfDzs4OJ0+exLVr13Do0KFKZ26QJfn/a+/Oo6K4sz2Af6uhhWYREZVuFYWgLC6IuAVUXDDKImKMiMkQjKLPEOW5jUic6IxRRs3mEjcEHY0ixkSjzqgRNQqiJjECcQONiZowgDsISLP1fX/kUM+2wRgFiu6+n3P6aP/qVvW9FPTtqq6lrEzrey/GDMH69esxe/ZsxMbGYv78+VKnw+pLg54u20gEQSCZTKb1b83/n5Senk79+/cnhUJB9vb2FB0dTSUlJTpxGo2Gli5dSo6OjmRmZkbdu3enHTt21JlDU7uyQnh4OA0cOFDqNBirN5s3byYANGPGDNJoNFKnYxQa633NILaINBrNM8f2798f6enpfxgnCAJiY2MRGxv7IqlJpry8nA9UYAZj27ZtiIyMxNSpU7FixQq92CvBnp3RfEdkbDQaDWQyXr1M/23fvh0TJkzAxIkTsW7dOm5CBojfqRhjTdb27dsRERGBiRMnIiEhgT9cGSheqwaMiKROgbHntnXrVm5CRoLXrIEyMzN75sslMdbUbNiwAW+99RYmT57MTcgI8No1UAqFQi+uicfYk1auXImoqChER0cjPj6em5AR4DVsoBQKBR49eiR1Gow9MyJCXFwcZs2ahZiYGKxatYoPTDASBnH4NtPVokWLRrtgIWMviogwd+5cfPzxx1i0aBEWLFjATciIcCMyUHZ2drh3757UaTD2h6qrqzF16lRs2rQJq1evRnR0tNQpsUbGjchAtWzZEo8ePYJareYTW1mTpVarER4ejr179+Kzzz7Dm2++KXVKTAL8HZGB0qe7yTLjVFhYiBEjRuDAgQP46quvuAkZMW5EBsrBwQEAkJubK3EmjOn673//C19fX1y4cAHHjh1DcHCw1CkxCfGuOQPVvn17AMCvv/4qcSaMabt06RICAwNBRDh16pTWPb+YceItIgNlZWWFNm3a4Oeff5Y6FcZE33zzDfr3748WLVrg9OnT3IQYAG5EBs3V1RU5OTlSp8EYgN/vE+bv749+/frh5MmT4lY7Y9yIDJibmxs3IiY5jUaDBQsWYMKECYiIiMB//vMfNG/eXOq0WBPCjciAde3aFdnZ2aisrJQ6FWakHj16hLCwMMTFxWHZsmVISEiAXC6XOi3WxPDBCgasd+/eKC8vx6VLl+Dp6Sl1OszI5ObmYvTo0cjOzsaePXswevRoqVNiTRRvERkwT09PyGQynDt3TupUmJH59ttv0adPH9y+fRvp6enchNhTcSMyYJaWlujWrRtOnz4tdSrMiPzrX//CoEGD4OzsjLNnz6Jnz55Sp8SaOG5EBm7w4ME4fvy41GkwI1BRUYFp06Zh0qRJmDBhAr755hvY29tLnRbTA9yIDNyQIUNw/fp13LhxQ+pUmAHLy8vDkCFDkJCQgPXr1yM+Ph7NmjWTOi2mJ7gRGbhBgwbBxMQEKSkpUqfCDFRaWhp69eqFGzduIC0tDW+//TbfwoH9KdyIDJytrS0GDBiAffv2SZ0KMzAajQbLli3DkCFD4ObmhoyMDLz88stSp8X0EDciIxASEoJjx46hpKRE6lSYgbh//z5CQkLw7rvvIjY2FkeOHOHvg9hz40ZkBEJCQlBeXo4DBw5InQozAKdOnYKnpydOnz6NAwcOIC4uDqamfEoie37ciIzASy+9BG9vb3z22WdSp8L0WHV1NeLi4jBo0CB07NgRWVlZCAwMlDotZgC4ERmJiIgIHD58GAUFBVKnwvRQbm4uXnnlFSxYsADz58/H8ePHxXteMfaiuBEZibCwMJiYmGDbtm1Sp8L0zJdffgkPDw9cvXoVx44dw/vvv8+74li94kZkJGxtbREWFoa1a9eiqqpK6nSYHigqKsLEiRMRGhoKPz8/nD9/HkOGDJE6LWaAuBEZkZkzZ+LmzZv46quvpE6FNXHHjx+Hh4cHdu/ejc2bN2PXrl1o2bKl1GkxA8WNyIh4eXlh8ODB+PDDD0FEUqfDmqDS0lLMnDkTQ4cOhZOTE86fP4+JEyfyCaqsQXEjMjJ/+9vfcPbsWT6Um+lITU1Fjx49EB8fj08++QTffPMNHB0dpU6LGQFuREbGz88Pvr6+WLBgATQajdTpsCaguLgY0dHRGDx4MFQqFc6fP49Zs2ZBJuO3B9Y4+DfNyAiCgMWLFyMrKwtffvml1OkwiR04cABdu3bF5s2bsWrVKqSmpqJz585Sp8WMDDciI+Tr64ugoCDExMSgtLRU6nSYBAoKCjB+/HiMHDkS7u7uuHjxIv73f/+Xt4KYJPi3zkitXLkSBQUFWLx4sdSpsEZUXV2NtWvXwtXVFceOHcO2bdvw9ddfw8nJSerUmBHjRmSkOnXqhPfeew8ff/wxLly4IHU6rBF8//33ePnllzF9+nSEhYXhypUrCA8P5yPimOT0vhEdO3YMkyZNgouLCywtLeHs7IwpU6bUeSmb06dPY8CAAbC0tIRKpcKMGTNq3T1FRPjggw/g5OQEhUKBHj16YOfOnQ1dTqOaO3cuXF1d8eabb6K8vFzqdFgDuX37NiIjI9GvXz9UVlbi9OnT2LhxI58XxJoMvW9E8+bNQ1paGl577TV8+umnGD9+PHbt2oWePXvi1q1bWrFZWVnw8/ODWq3GihUrMHnyZGzcuBGhoaE6y50/fz5iY2MxYsQIrFmzBh06dMAbb7yBzz//vLFKa3BmZmZISkrC5cuXsXDhQqnTYfWsoqICK1euhIuLC7766iusXbsW586dg7e3t9SpMaaN9NzJkyd1xtLS0kgQBHrvvfe0xgMCAqhdu3ZUXFwsjiUmJpIgCJSSkiKO5ebmklwup+joaK35fX19ycHBgaqrq3Ve89y5cwSAzp0796IlNbrly5eTIAj09ddfS50KqwcajYb2799PnTt3JplMRlOnTqU7d+5InRbTQ431vqb3W0QDBgzQGRs4cCBatmyJnJwccezhw4c4evQowsPDYWVlJY5HRETAysoKu3btEsf27duHqqoqvPPOO1rLjYqKQm5uLs6cOdMAlUjnr3/9K/z9/TF+/HhcuXJF6nTYCzh37hyGDRuGUaNGoUOHDsjKysKGDRvQqlUrqVNjrE5634hqU1JSguLiYq0/vgsXLqCqqgq9e/fWipXL5fD09ERmZqY4lpmZCSsrK7i5uWnF9unTB8Dvu/gMiUwmQ3JyMlQqFYKDg3H//n2pU2J/0vXr1/HGG2+gd+/eKCgowL///W8cOXIE3bt3lzo1xv6QQTailStXorKyEmFhYeJYfn4+AEClUunEK5VK5OXlacXWdtvjmnkfjzUUNjY2+Pe//4379+8jNDQUFRUVUqfEnkFeXh6mTZsGV1dXpKamIjExET/++CNGjhzJR8MxvdGkGhERQa1WP9OjLmlpaVi0aBHCwsIwePBgcbysrAzA71/QP8nc3FycXhNbV9zjyzI0zs7O2LNnD06dOsXNqIm7ffs25s6dC2dnZyQnJ2PJkiX46aefEBkZyfcKYnqnSTWi1NRUWFhYPNPj6tWrOvPn5OTg1VdfhYeHBxITE7WmKRQKAKj1MGW1Wg0LCwut2NqaXc1YzbIMka+vL/bu3YvDhw9zM2qCbt++jZiYGDg5OSE+Ph5z587F9evXERMTo/U7zJg+aVIfndzd3bFly5ZnilUqlVrPf/vtNwwfPhy2trY4ePAgLC0ttabX7Far2UX3uPz8fLRt21Yr9sSJE7XGAdCKfdKsWbNgY2OjNfb666/j9ddff3pBTYi/vz/27t2L0aNHIzQ0FLt27ap1C5E1ntzcXHz00UfYuHEjTE1NMXv2bMyaNYvPBWL1Jjk5GcnJyVpjRUVFjfPiDXpMXiO5e/cuubm5kVKppGvXrtUaU1hYSHK5nGJiYrTGy8vLycrKiiZPniyOrV27lgRBoMuXL2vFJiUlkSAIlJ6errN8fT58uy6HDh0iMzMzGjBgAN2+fVvqdIxSdnY2RUZGklwuJ1tbW/r73/9O9+7dkzotZiT48O1nVFpaisDAQOTn5+PgwYNwdnauNc7GxgbDhg3D9u3bUVJSIo5v27YNpaWlWie1hoSEQC6XY926deIYEWHDhg1o3749fHx8Gq6gJsTf3x/Hjx/H1atX0bdvX1y8eFHqlIwCESEtLQ2jRo2Cu7s7Dhw4gLi4ONy8eRP/+Mc/eCuIGZwmtWvuefzlL3/B2bNnMWnSJFy6dAmXLl0Sp1lbWyMkJER8HhcXBx8fHwwaNAhTpkxBbm4uPvnkE4wYMQLDhw8X49q1a4eZM2fiww8/RGVlJXr37o29e/ciPT0dO3bsMKqjkby9vfH9998jODgYPj4++OyzzzB69Gip0zJI5eXl2LlzJ1avXo2MjAx06dIFmzdvxhtvvMG7Rplha9DtrUbg6OhIMpmMBEHQeTg5OenEp6enU//+/UmhUJC9vT1FR0dTSUmJTpxGo6GlS5eSo6MjmZmZUffu3WnHjh115mGIu+Ye9/DhQxozZgwBoLfffrvWnxl7PtevX6d3332XWrduTQAoICCADh06RBqNRurUmJFrrPc1vW9ETYWhNyKi35vz+vXrSaFQUOfOnenUqVNSp6S3KioqaN++fRQYGEiCIFDz5s0pOjqacnJypE6NMRF/R8SaHEEQ8PbbbyMrKwstW7ZE//79MXXqVL4Sw5+QnZ2NefPmwcHBASEhIbh16xYSEhKQl5eH1atXw9XVVeoUGWt03IjYn+bi4oJTp05hzZo12LlzJ1xdXbF27Vo+56gOBQUFWLlyJXr16oUuXbogMTERYWFhyMrKwg8//IDIyEid0w0YMybciNhzMTExwbRp05CTk4OgoCBER0fDxcUFmzdvRlVVldTpSe7OnTuIj4/H0KFD0a5dO8TExKBjx47YvXs38vLysGrVKvTo0UPqNBlrErgRsReiUqmwZcsWXLx4EX369EFkZCRcXFywevVqFBcXS51eo/rll1+wYsUKDBo0CEqlEtOmTYOpqSk2btyIgoIC7NmzB2PGjOEj4Bh7AjciVi+6dOmCL774ApmZmfD29sbs2bPh4OCAmTNnGtzVymuo1WocO3YMc+bMgbu7O5ydnREbGwtra2vEx8cjPz8fKSkpiIyM5HN/GHsKvT+PiDUtnp6eSEpKwrJly7BmzRps2bIFq1atgoeHB8LDwzFmzJg6Tzpu6ioqKpCRkYHU1FQcO3YMJ0+ehFqthkqlQmBgIJYsWYLhw4fD2tpa6lQZ0ysCEZHUSRiCjIwM9OrVC+fOnYOXl5fU6TQZlZWVSElJwdatW7F//36Ul5eja9euGDVqFF555RV4e3uLVzVvagoKCvD999/ju+++w5kzZ/Dtt9+irKwMFhYWGDRoEIYNGwY/Pz94eHgY1UnOzHg01vsabxGxBiWXyxEUFISgoCCUlJQgJSUF+/btQ0JCApYuXQozMzP07dsXPj4+6N27N3r16gVHR8dGfWMvLS3FlStXkJOTg4sXLyIrKws//vijeN8ppVKJfv36YfHixRg4cCB69uwJuVzeaPkxZui4EbFGY2VlhTFjxmDMmDHQaDS4ePEivvnmG5w8eRLbt2/H8uXLxTgXFxe4ubnhpZdegoODA9q3bw+VSgU7Ozu0bNkSlpaWf9isqqqqUFhYiPv37+P+/fsoKChAfn4+8vPzcePGDdy4cQPXr19Hbm6uOE+7du3g6emJt956Cz179kS/fv3Qvn173uJhrAFxI2KSkMlk8PDwgIeHB2bOnAng911hGRkZuHz5Mq5cuYLs7GykpqYiPz8fGo1GZ36FQgFzc3Oto9A0Gg3Kysrw6NEjVFZW6ryuiYkJ7O3t0bFjRzg5OcHX1xedOnWCu7s7XF1d0aJFi4YtnDGmgxsRazKUSiUCAwMRGBioNV5VVYX8/HzcunUL9+/fx71791BUVAS1Wo2ysjKUl5dDEATxoVAoxIetra34UCqVaNWqFUxMTCSqkDFWG25ErMkzNTWFg4MDHBwcpE6FMdYA+DwixhhjkuJGxBhjTFLciBhjjEmKGxFjjDFJcSNijDEmKW5EjDHGJMWNiDHGmKS4ETHGGJMUNyLGGGOS4kbEGGNMUtyIGGOMSYobEWOMMUlxI2KMMSYpbkSMMcYkxY2IMcaYpLgRMcYYkxQ3IsYYY5LiRsQYY0xS3IgYY4xJihsRY4wxSXEjYowxJiluRIwxxiTFjYgxxpikuBExxhiTFDcixhhjkuJGxBhjTFJ634jS0tIwatQodOjQAQqFAvb29vDz88OhQ4dqjT99+jQGDBgAS0tLqFQqzJgxA6WlpTpxRIQPPvgATk5OUCgU6NGjB3bu3NnQ5TDGmNHR+0b0008/wdTUFFFRUVi3bh1iYmJw//59BAUFISkpSSs2KysLfn5+UKvVWLFiBSZPnoyNGzciNDRUZ7nz589HbGwsRowYgTVr1qBDhw5444038PnnnzdWaYwxZhzIAD169IiUSiX5+vpqjQcEBFC7du2ouLhYHEtMTCRBECglJUUcy83NJblcTtHR0Vrz+/r6koODA1VXV+u85rlz5wgAnTt3rp6rYYwxaTTW+5rebxHVRqFQoFWrVpDL5eLYw4cPcfToUYSHh8PKykocj4iIgJWVFXbt2iWO7du3D1VVVXjnnXe0lhsVFYXc3FycOXOm4YtgjDEjYTCN6OHDh7h79y5ycnIwf/58XL16FXPmzBGnX7hwAVVVVejdu7fWfHK5HJ6ensjMzBTHMjMzYWVlBTc3N63YPn36APh9Fx9jjLH6YSp1AvVl3LhxSElJAQBYWlpi165dCAgIEKfn5+cDAFQqlc68SqUS6enpWrH29vY6cTXz5uXl1WvujDFmzJrUFhERQa1WP9PjScuXL8eRI0ewadMmdOnSBePHj8eRI0fE6WVlZQAAMzMznXnNzc3F6TWxdcU9vizGGGMvrkk1otTUVFhYWDzT4+rVq1rz9ujRA35+fpg4cSLS09PRqVMnTJs2TZyuUCgAAOXl5Tqvq1arYWFhoRVbW7OrGatZlqFLTk6WOoV6ZUj1GFItANdj7JrUrjl3d3ds2bLlmWKVSmWd0+RyOYKDg7Fs2TIUFhaiRYsW4m61ml10j8vPz0fbtm3F5yqVCidOnKg1DoBW7JNmzZoFGxsbrbHXX38dr7/++lPraYqSk5P1Mu+6GFI9hlQLwPU0BcnJyToNtKioqFFeu0k1Int7e0RERNTLsmp2n8lkv2/0devWDaampjh79izGjh0rxlVUVCArKwvjx48Xx3r27IlNmzYhOzsb7u7u4vh3330HAPD09KzzdVesWAEvL696qYExxhpLbR+YMzIy0KtXrwZ/7Sa1a+553L59W2essLAQu3fvRvfu3dG8eXMAgI2NDYYNG4bt27ejpKREjN22bRtKS0u1TmoNCQmBXC7HunXrxDEiwoYNG9C+fXv4+Pg0YEWMMWZcmtQW0fMICAiAg4MD+vbtizZt2uDXX3/Fv/71L9y5c0dnN19cXBx8fHwwaNAgTJkyBbm5ufjkk08wYsQIDB8+XIxr164dZs6ciQ8//BCVlZXo3bs39u7di/T0dOzYsQOCIDRylYwxZrj0vhFFRkZi586dWLlyJQoLC2FnZ4cBAwbg3Xff1dlF1rNnTxw9ehTz5s3D7Nmz0bx5c0yePBlLly7VWe6yZctga2uL+Ph4bNmyBS4uLkhKStLahfe4ml2B2dnZ9V+kRIqKipCRkSF1GvXGkOoxpFoArqepqnk/a+gjhQUiogZ9BSORlJSE8PBwqdNgjLF6t337dvzlL39psOVzI6ond+/exeHDh+Ho6Gg0h3czxgxbWVkZbty4gREjRqBVq1YN9jrciBhjjElK74+aY4wxpt+4ETHGGJMUNyLGGGOS4kbEGGNMUtyI/oS0tDSMGjUKHTp0gEKhgL29Pfz8/HDo0KFa40+fPo0BAwbA0tISKpUKM2bMQGlpqU4cEeGDDz6Ak5MTFAoFevTogZ07dzZ0OTh27BgmTZoEFxcXWFpawtnZGVOmTEFBQUGt8U25noKCAsTGxmLIkCGwtraGTCZDampqnfFNuZa6lJeXY968eWjbti0sLCzw8ssv4+jRo5LkUpfS0lL8/e9/h7+/P1q2bAmZTIatW7fWGpudnQ1/f39YW1vDzs4OERERuHv3bq2xmzZtgru7OxQKBVxcXLBmzZqGLAMAcPbsWUyfPh1du3aFlZUVOnbsiLCwMPz00086sU29FgC4dOkSQkND4ezsDEtLS9jZ2cHHxwdJSUk6sY1eT4Pe/9XAJCYm0quvvkr//Oc/afPmzfTRRx+Rp6cnCYJA27dv14rNzMwkc3Nz6tWrF8XHx9N7771H5ubmFBAQoLPc2NhYEgSBpk6dSomJiTRy5EgSBIF27tzZoPX06tWLnJ2dKTY2ljZt2kTz58+n5s2bk1KppIKCAr2q5/jx4yQIArm6upKPjw8JgkCpqam1xjb1Wuoyfvx4ksvlFBMTQwkJCeTj40NyuZzS09MbPZe6XL9+nQRBIEdHRxoyZAgJgkBbt27Vifvtt9+oVatW1LlzZ/r000/pn//8J7Vs2ZI8PT2poqJCK3bDhg0kCAKFhoZSYmIiRUREkCAItHz58gat5bXXXqO2bdvSjBkzaNOmTbRkyRJSKpVkZWVFFy9e1KtaiIgOHjxI/v7+9P7771NiYiKtXr2afH19SRAEWrJkiaT1cCN6QY8ePSKlUkm+vr5a4wEBBKkiBgAADgpJREFUAdSuXTsqLi4WxxITE0kQBEpJSRHHcnNzSS6XU3R0tNb8vr6+5ODgQNXV1Q2W+8mTJ3XG0tLSSBAEeu+997TGm3o9xcXF9ODBAyIi+uKLL57aiJp6LbX57rvvSBAE+vjjj8UxtVpNnTp1Ih8fn0bL44+Ul5fTrVu3iIjohx9+qLMRRUVFkaWlJf3222/i2NGjR0kQBNq4caM49ujRI7Kzs6Pg4GCt+cPDw8nKykpc5w3h9OnTVFlZqTX2008/kbm5OYWHh4tj+lBLXaqrq8nT05M6dOggjklRDzeietCtWzfy8/MTnxcVFZFcLqd58+ZpxVVUVJC1tTVNnjxZHFu7di0JgkDZ2dlascnJySQIgiSfdu3s7Gjs2LHic32r52mNSN9qqTF37lySy+VazZOIaOnSpSQIAuXm5jZaLs/q7NmzdTaiNm3aUFhYmM64q6srDRs2THx+4MABEgSBDh06pBV35syZWvdENAYvLy/q3bu3+FyfayEiGjlyJDk7O4vPpaiHvyN6Dg8fPsTdu3eRk5OD+fPn4+rVq5gzZ444/cKFC6iqqkLv3r215pPL5fD09ERmZqY4lpmZCSsrK7i5uWnF9unTBwCQlZXVgJXoKikpQXFxsdZZ1Ppcz5P0tZbMzEy4uLjAyspK8lxe1H//+1/cuXNHZx0Av9fz5DoAoBPr5eUFmUzW6HUTEW7duiX+fehjLY8ePcLdu3fx888/Y8WKFTh8+DBiYmIASFeP3l/0VArjxo1DSkoKAMDS0hK7du1CQECAOL3mBno1N+N7nFKpRHp6ulasvb29TlzNvHl5efWa+x9ZuXIlKisrERYWJo7pcz1P0tda8vPza825qfxc/4ynrQOVSoX79++jsrIScrkc+fn5MDEx0bm8TLNmzWBnZ9fodSclJSEvLw9LliwBoJ+1zJ49Gxs3bgQAmJqaYvXq1fif//kfANLVY7SNiIhqvW14bczNzbWeL1++HHPnzsWvv/6KDRs2YPz48di/fz9eeeUVAP9/pVozM7Nal/X4lWzLysrqjHt8WQ1ZT420tDQsWrQIYWFhGDx4sFaOQOPVUx+11EWKdVMfmlIuL+qP1kFNjFwuR1lZGZo1a1brcszMzBq17pycHEybNg0+Pj6YMGGCmGdNLk9qqrXMmjUL48aNQ15eHpKSkjB9+nQoFApMmDBBsnqMthGlpqZi6NChzxSbk5MDFxcX8XmPHj3E/4eHh8PLywvTpk3D1atXAUC86Gltb6ZqtRoWFhbic4VCAbVaXWvc48v6Iy9ST83Yq6++Cg8PDyQmJmpNa+x6XrSWp5Fi3dQHhUJRZ86NncuL+qN18HiMQqFARUVFrctRq9WNVndBQQGCgoJga2uLL7/8UrwnmT7W4urqCldXVwC/v3+NGDECM2fORFhYmGT1GG0jcnd317lxXl2USmWd0+RyOYKDg7Fs2TIUFhaiRYsW4mZtzWbu4/Lz89G2bVvxuUqlwokTJ2qNA6AV+zQvUs9vv/2G4cOHw9bWFgcPHoSlpaXW9Maup77WTW2kWDf1QaVS1bqrQ4pcXtQfrQM7OzvI5XIxtrq6Gnfv3tXaBVRRUYH79+83St1FRUUICAjAw4cPcfLkSa3fOX2rpTavvfYajhw5gpycHMnqMdpGZG9vj4iIiHpZVs0mqEz2+7Ef3bp1g6mpKc6ePYuxY8eKcRUVFcjKytK6uV7Pnj2xadMmZGdnw93dXRz/7rvvAACenp7PlMPz1nPv3j0MHz4clZWVOH78eK3fiTR2PfW5bp4kxbqpDz179sSJEydQXFwMa2trSXN5Ue3atUPr1q1x9uxZnWnff/+9Vi09e/YE8PvJpY9/D/vDDz9Ao9E0eN1qtRrBwcG4du0ajh49qnPgij7VUpfH378kq+dPHuln1GrOj3jcgwcPyMHBgTw8PLTGAwICqG3btrWeq3L48GFxLDc3l5o1a0bTp08XxzQaDQ0cOJAcHBxIo9E0QCW/Kykpob59+5KNjQ1lZGQ8NVYf6qnxLOcR6UstNWrOI/roo4/EsZrziLy9vRstjz/jaYdvR0VFkYWFRa3nqsTHx4tjZWVlkp17U1VVRaNGjaJmzZrpHKL8OH2ohYjo9u3bOmMVFRXk5eVFrVq1oqqqKiKSph5uRH+Cl5cXhYSEUFxcHCUkJNCCBQuoffv2ZGZmRseOHdOKzcjIIHNzc/Ly8qL169fT3/72N1IoFOTv76+z3JiYGPHs/YSEBAoKCiJBECg5OblB6wkJCSFBECgyMpK2bdum9di7d6/e1bN48WJavHgxjR8/XqyrZkzfaqnNuHHjxCsrxMfHk4+PDzVr1qzWE5Ol9Omnn9LixYspKiqKBEGg1157TVwPRUVFRPT/Z+936tRJPHvf1taWevTooXP2/rp168Sz9xMSEsSz95cuXdqgdcyYMYMEQaBRo0bp/H1s27ZNjNOHWoiIRo8eTX5+frRo0SJKSEigxYsXk5ubG8lkMq0PC1LUw43oT1i7di0NHDiQWrduTXK5nJRKJY0dO5bOnTtXa3x6ejr179+fFAoF2dvbU3R0NJWUlOjEaTQaWrp0KTk6OpKZmRl1796dduzY0dDlkKOjI8lkMhIEQefh5OSkd/UIgiDW83hdMplM72qpjVqtprlz55JKpSJzc3Pq16+f1pUgmgpHR0etn/3j6+TmzZti3KVLl2jEiBFkaWlJLVu2pDfffLPWT+1ERAkJCeTm5kZmZmbUuXNnWrVqVYPXMXjw4Dr/Pp78nWrqtRAR7dy5k1555RVSKpUkl8vJzs6OAgMD6ejRozqxjV0P36GVMcaYpPjKCowxxiTFjYgxxpikuBExxhiTFDcixhhjkuJGxBhjTFLciBhjjEmKGxFjjDFJcSNijDEmKW5EjDHGJMWNiLEG9NZbb8HJyUnqNBhr0rgRMdaABEEQb6Kmb1JSUhAZGYlu3brBxMSEGyprMHytOcYaUFVVFYhIvJmYPpk4cSI+//xz9OrVCzdv3oSpqSl++eUXqdNiBogbEWOsVvn5+WjTpg1MTEwwcuRIXL58mRsRaxC8a46x51RcXIyZM2fC0dER5ubmsLe3x/Dhw5GZmSnG1PYd0b179/Dmm2+iefPmsLW1xVtvvYUff/wRMpkMW7du1ZrX2toaN2/eRFBQEKytrdG+fXusXbsWAHD+/HkMHToUVlZWcHR0RHJystbrPHjwAH/961/RvXt3WFtbw8bGBoGBgTh//vwz1adSqWBiYvK8Px7GnpnR3iqcsRf19ttvY/fu3YiOjkaXLl1w9+5dnDp1Cjk5OeJtlAFofUek0WgQHByMs2fP4p133oGbmxv27t2LCRMm6MQCQHV1NQIDAzF48GAEBwdj+/btiI6OhpmZGRYuXIiIiAiMHTsW69evR0REBLy9veHo6AgA+Pnnn7Fv3z6MGzcOTk5OKCgoQHx8PAYNGoTLly9DpVI1/A+JsWfxp+9gxBgjIiIbGxuKjo5+asyECRPI0dFRfL57924SBIFWr14tjmk0GvLz89O5rfaECRNIEARatmyZOFZYWEgWFhYkCALt2rVLHL9y5QoJgkD/+Mc/xLHy8nKdfG7cuEHm5uY6d639I0FBQbXeLJGx+sC75hh7Tra2tvj222+Rn5//zPN8/fXXaNasGaZMmSKOCYKAadOm1TnP5MmTxf/b2NjAxcUF1tbWCA0NFcddXFzQokULXL9+XRxr1qyZ+P/q6mrcu3cPlpaWcHFx0dp9yJjUuBEx9pw++OADXLx4EQ4ODujXrx8WLVqk1Qhqc/PmTahUKpibm2uNOzs71xqvUChgZ2enNWZjY4P27dvrxDZv3hwPHjwQnxMRVqxYgc6dO8Pc3BytW7dGmzZtcOHCBRQVFT1rmYw1OG5EjD2n0NBQ/PLLL/j000/Rtm1bfPjhh+jatSu+/vrrp85Hf+JAVZms9j/Rug4ieHzZcXFxmDNnDgYPHoykpCSkpKTgyJEj6Nq1KzQazTPnwFhD44MVGHsBSqUSUVFRiIqKwp07d+Dl5YW4uDj4+/vXGt+xY0ecOHECZWVlUCgU4vi1a9fqPbcvv/wSQ4cORUJCgtb4gwcP0Lp163p/PcaeF28RMfYcNBqNzu6t1q1bQ6VSoaKiQmv88SPh/P39UVlZqdUcNBqNeEj2k17kqgympqY6Wz5ffPEF8vLynnuZjDUE3iJi7Dk8fPgQ7du3R2hoKDw8PGBlZYWjR4/ihx9+wCeffKIV+/justGjR6Nv376YM2cOrl27BldXV+zfv1/8bufJxlPXbrxn2b03cuRIvP/++5g0aRK8vb1x4cIF7NixAy+99NIzzX/+/Hns378fwO9bbIWFhViyZAkAwNPTEyNHjvzDZTD2LLgRMfYcLC0tMW3aNKSkpGDPnj3QaDTo3Lkz1q9fj6lTp4pxT15rTiaT4cCBA5gxYwa2bt0KmUyGkJAQLFy4EAMHDtQ6iKGu69Q9bfxx8+fPR2lpKXbs2CFequfgwYOYN2/eM21pZWZmYuHChVrLXrhwIQRBwIQJE7gRsXrDl/hhrAnYu3cvxowZg1OnTsHb21vqdBhrVNyIGGtkarVaa8unuroaw4cPR0ZGBgoKCmBmZiZhdow1Pt41x1gjmz59OtRqNV5++WWUl5djz549OHPmDJYuXcpNiBkl3iJirJElJyfj448/xrVr16BWq9G5c2dERUXhnXfekTo1xiTBjYgxxpik+DwixhhjkuJGxBhjTFLciBhjjEmKGxFjjDFJcSNijDEmKW5EjDHGJMWNiDHGmKS4ETHGGJMUNyLGGGOS+j/mB7d4xElnEwAAAABJRU5ErkJggg==",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x7ff7c5124450>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.text.Text object at 0x7ff7c44a5b90>"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function plot_principal()\n",
    "    PyPlot.figure(figsize=(4, 4))\n",
    "    n = 100\n",
    "    s = linspace(-300, 300, n)\n",
    "    s1 = repmat(s', n, 1)\n",
    "    s2 = repmat(s, 1, n)\n",
    "    sigma = sqrt(s1.^2 + s2.^2 - s1.*s2)\n",
    "    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",
    "    axis(\"equal\")\n",
    "    xlabel(\"sigma 1\")\n",
    "    ylabel(\"sigma 2\")\n",
    "    title(\"principal stress plane\")\n",
    "end\n",
    "plot_principal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.0",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}