{ "cells": [ { "cell_type": "markdown", "source": [ "# Linear rotating shallow water dynamics\n", "\n", "\n", "\n", "This example solves the linear 1D rotating shallow water equations\n", "for the ``u(x, t)``, ``v(x, t)`` and the surface surface elevation ``\\eta(x, t)``,\n", "for a fluid with constant rest-depth ``H``. That is, the total fluid's depth\n", "is ``H + \\eta(x, t)`` with ``|\\eta| \\ll H``.\n", "\n", "The linearized equations for the evolution of ``u``, ``v``, ``\\eta`` are:\n", "\n", "$$\n", "\\begin{aligned}\n", "\\frac{\\partial u}{\\partial t} - f v & = - g \\frac{\\partial \\eta}{\\partial x} - \\mathrm{D} u, \\\\\n", "\\frac{\\partial v}{\\partial t} + f u & = - \\mathrm{D} v, \\\\\n", "\\frac{\\partial \\eta}{\\partial t} + H \\frac{\\partial u}{\\partial x} & = - \\mathrm{D} \\eta.\n", "\\end{aligned}\n", "$$\n", "\n", "Above, ``g`` is the gravitational acceleration, ``f`` is the Coriolis parameter, and\n", "``\\mathrm{D}`` indicates a hyperviscous linear operator of the form ``(-1)^{n_ν} ν \\nabla^{2 n_ν}``,\n", "with ``ν`` the viscosity coefficient and ``n_ν`` the order of the operator.\n", "\n", "Rotation introduces the deformation length scale, ``L_d = \\sqrt{g H} / f``.\n", "Disturbances with length scales much smaller than ``L_d`` don't \"feel\"\n", "the rotation and propagate as inertia-gravity waves. Disturbances with\n", "length scales comparable or larger than ``L_d`` should be approximately\n", "in geostrophic balance, i.e., the Coriolis acceleration\n", "``f \\widehat{\\bm{z}} \\times \\bm{u}`` should be in approximate\n", "balance with the pressure gradient ``-g \\bm{\\nabla} \\eta``." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "using FourierFlows, Plots, Printf, Random\n", "using LinearAlgebra: mul!, ldiv!" ], "metadata": {}, "execution_count": 1 }, { "cell_type": "markdown", "source": [ "## Coding up the equations\n", "### A demonstration of FourierFlows.jl framework\n", "\n", "What follows is a step-by-step tutorial demonstrating how you can create your own\n", "solver for an equation of your liking." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "The basic building blocks for a `FourierFlows.Problem()` are:\n", "- `Grid` struct containining the physical and wavenumber grid for the problem,\n", "- `Params` struct containining all the parameters of the problem,\n", "- `Vars` struct containining arrays with the variables used in the problem,\n", "- `Equation` struct containining the coefficients of the linear operator ``L`` and the function that computes the nonlinear terms, usually named `calcN!()`.\n", "\n", "The `Grid` structure is provided by FourierFlows.jl. One simply has to call one of\n", "the `OneDGrid()`, `TwoDGrid()`, or `ThreeDGrid()` grid constructors, depending\n", "on the dimensionality of the problem. All other structs mentioned above are problem-specific\n", "and need to be constructed for every set of equations we want to solve." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "First lets construct the `Params` struct that contains all parameters of the problem" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "struct Params{T} <: AbstractParams\n", " ν :: T # Hyperviscosity coefficient\n", " nν :: Int # Order of the hyperviscous operator\n", " g :: T # Gravitational acceleration\n", " H :: T # Fluid depth\n", " f :: T # Coriolis parameter\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 2 }, { "cell_type": "markdown", "source": [ "Now the `Vars` struct that contains all variables used in this problem. For this\n", "problem `Vars` includes the representations of the flow fields in physical space\n", "`u`, `v` and `η` and their Fourier transforms `uh`, `vh`, and `ηh`." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "struct Vars{Aphys, Atrans} <: AbstractVars\n", " u :: Aphys\n", " v :: Aphys\n", " η :: Aphys\n", " uh :: Atrans\n", " vh :: Atrans\n", " ηh :: Atrans\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 3 }, { "cell_type": "markdown", "source": [ "A constructor populates empty arrays based on the dimension of the `grid`\n", "and then creates `Vars` struct." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " Vars(dev, grid)\n", "Constructs Vars for 1D shallow water based on the dimensions of arrays of the `grid`.\n", "\"\"\"\n", "function Vars(::Dev, grid) where Dev\n", " T = eltype(grid)\n", " @devzeros Dev T grid.nx u v η\n", " @devzeros Dev Complex{T} grid.nkr uh vh ηh\n", "\n", " return Vars(u, v, η, uh, vh, ηh)\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 4 }, { "cell_type": "markdown", "source": [ "In Fourier space, the 1D linear shallow water dynamics read:\n", "\n", "$$\n", "\\begin{aligned}\n", "\\frac{\\partial \\hat{u}}{\\partial t} & = \\underbrace{ f \\hat{v} - i k g \\hat{\\eta} }_{N_u} \\; \\underbrace{- \\nu k^2 }_{L_u} \\hat{u} , \\\\\n", "\\frac{\\partial \\hat{v}}{\\partial t} & = \\underbrace{ - f \\hat{u} }_{N_v} \\; \\underbrace{- \\nu k^2 }_{L_v} \\hat{v} , \\\\\n", "\\frac{\\partial \\hat{\\eta}}{\\partial t} & = \\underbrace{ - i k H \\hat{u} }_{N_{\\eta}} \\; \\underbrace{- \\nu k^2 }_{L_{\\eta}} \\hat{\\eta} .\n", "\\end{aligned}\n", "$$\n", "Although, e.g., terms involving the Coriolis accelaration are, in principle, linear we include\n", "them in the nonlinear term ``N`` because they render the linear operator ``L`` non-diagonal.\n", "\n", "With these in mind, we construct function `calcN!` that computes the nonlinear terms." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " calcN!(N, sol, t, clock, vars, params, grid)\n", "Compute the nonlinear terms for 1D linear shallow water dynamics.\n", "\"\"\"\n", "function calcN!(N, sol, t, clock, vars, params, grid)\n", " @. vars.uh = sol[:, 1]\n", " @. vars.vh = sol[:, 2]\n", " @. vars.ηh = sol[:, 3]\n", "\n", " @. N[:, 1] = params.f * vars.vh - im * grid.kr * params.g * vars.ηh # + f v - g ∂η/∂x\n", " @. N[:, 2] = - params.f * vars.uh # - f u\n", " @. N[:, 3] = - im * grid.kr * params.H * vars.uh # - H ∂u/∂x\n", "\n", " dealias!(N, grid)\n", "\n", " return nothing\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 5 }, { "cell_type": "markdown", "source": [ "Next we construct the `Equation` struct:" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " Equation(dev, params, grid)\n", "Construct the equation: the linear part, in this case the hyperviscous dissipation,\n", "and the nonlinear part, which is computed by `calcN!` function.\n", "\"\"\"\n", "function Equation(dev, params, grid)\n", " T = eltype(grid)\n", " L = zeros(dev, T, (grid.nkr, 3))\n", " D = @. - params.ν * grid.kr^(2*params.nν)\n", "\n", " L[:, 1] .= D # for u equation\n", " L[:, 2] .= D # for v equation\n", " L[:, 3] .= D # for η equation\n", "\n", " return FourierFlows.Equation(L, calcN!, grid)\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 6 }, { "cell_type": "markdown", "source": [ "We now have all necessary building blocks to construct a `FourierFlows.Problem`.\n", "It would be useful, however, to define some more \"helper functions\". For example,\n", "a function that updates all variables given the solution `sol` which comprises ``\\hat{u}``,\n", "``\\hat{v}`` and ``\\hat{\\eta}``:" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " updatevars!(prob)\n", "Update the variables in `prob.vars` using the solution in `prob.sol`.\n", "\"\"\"\n", "function updatevars!(prob)\n", " vars, grid, sol = prob.vars, prob.grid, prob.sol\n", "\n", " @. vars.uh = sol[:, 1]\n", " @. vars.vh = sol[:, 2]\n", " @. vars.ηh = sol[:, 3]\n", "\n", " ldiv!(vars.u, grid.rfftplan, deepcopy(sol[:, 1])) # use deepcopy() because irfft destroys its input\n", " ldiv!(vars.v, grid.rfftplan, deepcopy(sol[:, 2])) # use deepcopy() because irfft destroys its input\n", " ldiv!(vars.η, grid.rfftplan, deepcopy(sol[:, 3])) # use deepcopy() because irfft destroys its input\n", "\n", " return nothing\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 7 }, { "cell_type": "markdown", "source": [ "Another useful function is one that prescribes an initial condition to the state variable `sol`." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "\"\"\"\n", " set_uvη!(prob, u0, v0, η0)\n", "Sets the state variable `prob.sol` as the Fourier transforms of `u0`, `v0`, and `η0`\n", "and update all variables in `prob.vars`.\n", "\"\"\"\n", "function set_uvη!(prob, u0, v0, η0)\n", " vars, grid, sol = prob.vars, prob.grid, prob.sol\n", "\n", " A = typeof(vars.u) # determine the type of vars.u\n", "\n", " mul!(vars.uh, grid.rfftplan, A(u0)) # A(u0) converts u0 to the same type as vars expects (useful if u0 is a CPU array while working on the GPU)\n", " mul!(vars.vh, grid.rfftplan, A(v0)) # A(v0) converts u0 to the same type as vars expects (useful if v0 is a CPU array while working on the GPU)\n", " mul!(vars.ηh, grid.rfftplan, A(η0)) # A(η0) converts u0 to the same type as vars expects (useful if η0 is a CPU array while working on the GPU)\n", "\n", " @. sol[:, 1] = vars.uh\n", " @. sol[:, 2] = vars.vh\n", " @. sol[:, 3] = vars.ηh\n", "\n", " updatevars!(prob)\n", "\n", " return nothing\n", "end\n", "nothing #hide" ], "metadata": {}, "execution_count": 8 }, { "cell_type": "markdown", "source": [ "## Let's prescibe parameter values and solve the PDE\n", "\n", "We are now ready to write up a program that sets up parameter values, constructs\n", "the problem `prob`, # time steps the solutions `prob.sol` and plots it." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Choosing a device: CPU or GPU" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "dev = CPU() # Device (CPU/GPU)\n", "nothing # hide" ], "metadata": {}, "execution_count": 9 }, { "cell_type": "markdown", "source": [ "## Numerical parameters and time-stepping parameters" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ " nx = 512 # grid resolution\n", "stepper = \"FilteredRK4\" # timestepper\n", " dt = 20.0 # timestep (s)\n", " nsteps = 320 # total number of time-steps\n", "nothing # hide" ], "metadata": {}, "execution_count": 10 }, { "cell_type": "markdown", "source": [ "## Physical parameters" ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "Lx = 500e3 # Domain length (m)\n", "g = 9.8 # Gravitational acceleration (m s⁻²)\n", "H = 200.0 # Fluid depth (m)\n", "f = 1e-2 # Coriolis parameter (s⁻¹)\n", "ν = 100.0 # Viscosity (m² s⁻¹)\n", "nν = 1 # Viscosity order (nν = 1 means Laplacian ∇²)\n", "nothing # hide" ], "metadata": {}, "execution_count": 11 }, { "cell_type": "markdown", "source": [ "## Construct the `struct`s and you are ready to go!\n", "Create a `grid` and also `params`, `vars`, and the `equation` structs. Then\n", "give them all as input to the `FourierFlows.Problem()` constructor to get a\n", "problem struct, `prob`, that contains all of the above." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ " grid = OneDGrid(dev, nx, Lx)\n", " params = Params(ν, nν, g, H, f)\n", " vars = Vars(dev, grid)\n", "equation = Equation(dev, params, grid)\n", "\n", " prob = FourierFlows.Problem(equation, stepper, dt, grid, vars, params, dev)\n", "nothing #hide" ], "metadata": {}, "execution_count": 12 }, { "cell_type": "markdown", "source": [ "## Setting initial conditions" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "For initial condition we take the fluid at rest (``u = v = 0``). The free surface elevation\n", "is perturbed from its rest position (``\\eta=0``); the disturbance we impose a Gaussian\n", "bump with half-width greater than the deformation radius and on top of that we\n", "superimpose some random noise with scales smaller than the deformation radius.\n", "We mask the small-scale perturbations so that it only applies in the central part\n", "of the domain by applying\n", "\n", "The system develops geostrophically-balanced jets around the Gaussian bump,\n", "while the smaller-scale noise propagates away as inertia-gravity waves." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "First let's construct the Gaussian bump." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=1}", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAEECAIAAAB7oN2aAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3dd0AUV+IH8LeVpQlLb1JsKGBiQYOIiqJGTUwsZwyJZ+KlcClqFDV3msSLMYkl0XRr1CRqNJacEkUFKyCKCCgKdpp0WJC2BZb5/fF0b34LLAsM7ALfz1/sY/btY9jd77x5b97wGIYhAAAA3RXf0A0AAAAwJAQhaPvhhx/eeOONvLy8DnvFgwcPhoWFJScnd9grGok7d+688cYbu3btanbLs2fPhoWFRUVFteJVNm3aFBYWlpOT04rnNrRu3bo33nijvLycXSiTybZs2RIeHh4WFrZhwwZOXogQEhcX98Ybb/z111+6NyssLAwLC/v++++brTA2NjYsLOz48eMcNbCtKisrr127dunSpdzc3BY9sbS0ND4+PjU1VaVS6bN9eXl5WFjYunXrWtXMboAB/fz3v/+le2znzp2Gbkv7euGFFwghqampHfaK4eHhhJBDhw512CsaiXPnzhFC5s2bpym5cuXKli1b7ty5o7Ul/ZZfv359K15l+vTphJCkpKQ2tfWJUaNGEUIePnyoKSkoKOjZsychRCwWS6XSqVOncvJCDMPs2LGDEPLZZ5/p3uzWrVuEkClTpmhKkpKStmzZkp6errXltm3b9KmwA+Tm5r7yyisSiUTzVezp6RkTE9PsE4uKimbNmiUQCOizbG1tv/3222af9fDhQ0LIyJEjuWh7F4Qeob527typ9UNXNXDgwODgYAsLC0M3pOuztrYODg4eMGCApuTo0aNhYWGXL182YKtaaseOHTk5OeHh4XK5XCaTHT16lKuanZ2dg4ODPT09W/rEY8eOhYWFxcbGctUSbt2/f3/48OF79+7t16/fkiVLVq5cOWfOHIVC0Wy/UC6XP/vsswcOHAgKCvrhhx9WrVolFAoXLlyIrl4bCQ3dgM6hsLDw+PHjffr0sbKyiomJuXfvXp8+fQzdqPayevVqQzehu3j66afPnj1r6Fa01Z07dwghs2bN4vM5PrCeNGnSpEmTuK3T4Orq6mbPnp2bm/vZZ5+tWLGCx+PRcrVaXV1drfu5P/zwQ3Jy8rPPPnvs2DHaKZw9e/aQIUNWrlz5yiuvuLm5tXvruygEoV5+++232trauXPnWllZXb16ddeuXfqnxaNHjyIjI3Nzc52dnSdPniyVSm/cuKFUKocOHcre7P79+8nJybm5uXw+v3///sHBwSKRiL1BRkaGTCbr37+/ubk5u/zq1asmJiZ+fn6aErVaffHixfv375eUlNjZ2Xl5eY0YMUIsFms2kMvlFy5cyMzMlMvltra2Pj4+gwcP1nyL3b9/v7y83NfXl33epqSk5NKlS9nZ2Uql0sPDY9y4cdbW1lp/5r179+zt7d3d3XNyck6dOvXo0aO+fftOmjRJ6w/RgWGYuLi45ORkPp8/ZswY9h9FCMnLy8vPz/fy8rKxsWGXa+3Pqqqq27dv29raenp60pZUVlYOGTJk9OjRdAOFQhEZGZmRkeHo6Pj8889bWVlpqqqvr09OTpZIJL6+vjKZ7Pjx44WFhR4eHpMnT9ba7VoqKiru3r1L/3xNYXp6ek1NjZubm6Ojo6YwOTlZIBA89dRTmqba2dl5eHgQQlJTU/Pz8wkhmZmZV69epdsPGDDAzMyM/Vq3bt06d+6cQqEYOHDguHHjNN+k+uzeCxcupKSkiESi0aNHa+1eQoharb569ert27cLCwutrKyeeeYZ2s6mFBQU5ObmZmRkEEIyMjKEQiEhpF+/fpaWllpblpSUZGVlubq6Ojk5aQpTUlLUanXv3r0176Xa2trr169bWFh4e3sTQkpLSzMzM7WeRQjJzs4+efJkdXW1t7f3hAkTtF7r5s2bdIQ7KytLsxu9vb21TnLcvXv3zJkzNTU1vr6+48eP5zzFm3LgwIGrV6+GhIR89NFH7HKBQNCjRw/dz6WndletWqU5NdqvX7/XXnvtp59++u233/7973+3tDG3bt2qrq6m71u6883Nzfv3719aWhoZGVlcXNyvX7/JkyfTnaNWq6Ojo9PT0y0tLZ977jmtf0rnZuhzs53DwIEDeTwejRaxWOzq6lpXV6fPE0+ePGlra6vZ25aWlkeOHKG9yfr6erqNUqns37+/1v/Fw8Pj8uXL7KrmzJlDCLl48SK7sL6+nhDSp08fTcndu3d9fHy0anN1ddVscPr0aQcHB60Nnn/+ec0GDccIQ0NDNR88zR+ya9cudkuOHTtGCHnvvffWr19PvxApPz+//Px83XuJjhHu2rUrJCRE80Qej/fOO++w9/Mnn3xCCNm9e7fW0728vPh8vubh+fPnCSFz5879+uuv2S2ZMWOGSqVKSEhwdXXVFDo7O6elpWmeW1NTQwjx8fE5ePAg+3vT1dX10qVLOv4EOgYzZswYTUltbS39Xnv77bc1hVlZWYSQsWPH0odaY4Q0DrUkJiYyT8YI161bt3DhQvZvg4ODq6qqdO9eOkYYFRU1ZswY9u798MMP2ZudPXvWzs5O69UnT54sk8nYm7HHCL/44ouGDT579mzDNtB/Cns0NC8vj0b42rVrNYVnzpwhhLz55pv0YaNjhOvWrWMfWvn5+Z04cYKwxgj79evXsFWxsbEMa4xw6dKl7AOIkSNHPnr0SPdu1JNarda9wZQpUwgh+/fvb2nN9M1jZ2en+eqgIiIi2G+qRjU6RvjNN9/w+fyBAwfm5OQwDEMPwgICAg4cOMA+7HvmmWfKysoePHgwcOBATaGFhcXp06db+icYLQRh8y5dusT+jnvxxRcJISdOnGj2iXfu3DEzMxOJRGvXrr1///7t27c//vhjCwsL2gXRvJtramr8/Pw2bNhw7ty5O3fuXLx4cdGiRQKBwMHBoaysTFObnkFI+z2LFy9OTk7Ozs6+evXqzp07Z86cSX8rl8vt7OxMTEw2btyYlpaWnZ198eLFjRs3fvDBB5oaGgbhlClTli9ffvLkybS0tKSkpA0bNkilUoFAwM4GGoSenp49evT4+uuvExISTp06FRQURAh5+eWXde8oGoQuLi5+fn5RUVH0eJ8eHHz88ceazVoUhO7u7paWlhs3brxy5crRo0f79u1LCPnkk0/s7e3nzZsXHR0dHx//6quvEkKCgoI0z6VBKJVKzczMli9ffvv27Tt37ixfvpzH49nY2OhOdG9vb7FYrImluLg4Qgifz+/du7dmG61vdq0gjImJoU3617/+FfUE/YKmQejl5eXk5LRt27bExMQjR47QwcXly5fr3r00CL28vJ555pnDhw8nJSVt3ryZhjT7u+yPP/547rnn9uzZc/ny5du3b0dGRtLjklmzZrFrYwdhRkZGVFRUYGAgIWTLli20wVrBSSmVSnNzc3d3d03Jb7/9RvfPhAkTNIW0k7R3795GdxfDMHv27CGEODk57du3Lzs7Oz4+fty4cfTIRhOEcXFxr7/+Ov0UaHYj/SjRIPTy8nJwcNi8efOVK1ciIiLo9/vixYt170aGYaqrq7///vvx48cPHDhwwoQJ69evz87OZm+we/fuBQsW6K6EHhnfunVrx44d48eP9/PzGzt27FdffdXsAQ3Ne39/f63ytLQ0Qoizs7OO52oFYV1d3bvvvksICQkJKS8vp4U0CB0dHS0sLD7++OP4+Pjo6Gj6zw0LC/Pz85s8efLx48cTEhKWLFlCCHFzc1OpVLrb3FkgCJsXFhZGCPn555/pw8OHDxNCZs+e3ewTX3vtNULIp59+yi5csGABPaTSOqzTsmLFCkLITz/9pCnRJwhVKhU9xGuq2oSEBELI3Llzdby0PrNGaezNmTNHq4TH47FnvpWWllpYWJiYmOjuQNMglEgkubm5msKsrCyxWCyRSEpKSmhJi4KQEBIVFaUpjImJoYVvvfWWprCuro52wjQJR4OQEPLee++xX+K9994jhCxatEjHX/HOO++wj5BWrVpFDwIIIQ8ePKCFNOfi4+Ppw4azRj/++GNCyG+//aZVOQ1CiURy//59TWFaWhqfz+/Xr5+OVjFPgnDgwIHsr60ffviBEPLOO+/oeKJKpaLnzGmPgWo4a5QeGqakpOhuxrPPPksI0UyIff3118Vi8bRp0yQSiVwup4UBAQE8Hk/z79AKQrVaTf9f58+f11Qrl8tpIXvW6GeffUYI2bZtm1YbaBCKxWL2hNJ79+4JBAJ2SDfq5s2bdNoOPetOe6U8Hi8gIGDRokXLli0bNmwYIeT999/XUUlFRQUhRCgUzpw5kxBib2/v5+dHq/Lz8ysqKtLx3F9//ZUQMmnSJK3yoqIiWqeO57KDsKqqaurUqfR7gP2WoEFICPnxxx/ZT6TNCw4OZn9ljR07lhBy4cIFHS/aiWDWaDPkcvn+/ftNTU3pG5cQ8txzz9nZ2f35558lJSU6nsgwTEREhEAgmD9/Prt80aJF+rwuTSOaW/oTCoXm5ua5ubnZ2dmNbkAHY27cuFFVVdWimrVMnDhRIpE0bN6IESNoL5CysbHx9/dXKpX6XJUYGhrq4uKieeju7j5r1iyFQtG6q76eeuqp8ePHax4GBgbSzzN7/wsEAtpaOsrFRrNZ6yE9BmoK7T+dPn2aPjx9+rSrq+s///lPQgg940cIOXfunKWlpdbwsP5mzpzZq1cvzcMBAwa4ubllZWXR4yHdPvjgA/YZxYkTJ5LG/nA2kUg0ZcqU+vr6xMTE1jWYbdy4cYS1f86ePRsYGPjCCy8oFIr4+HhCSGVl5dWrV/38/JoafEpKSsrKyho2bJhmuJcQIpFI6GGK/qZOncoejOjdu3fv3r1zc3N1X5OXmppqZ2d39uzZ4uLijIyM0tLSvXv3Tp06NSUlZePGjevWrSssLPzuu++++eYbHZVUVlYSQurq6g4fPvzTTz8VFRWlpqbm5OSMHDnyxo0b77//vo7nyuVyQkjDcUR6hqmurk6hUDT3p5PS0tKJEydGREQsWLBg165dDcfvLSws3n77bc1DV1dXOpTzwQcfsE8m09Psut8/nQiCsBmHDh0qLy+fMWOGZkqFWCyePXu2SqXat2+fjieWlJTIZDIXFxepVMou9/T0bDjtIiMjg558kEqlPB6Px+M988wztJIWtZbH482bN08mk3l7e0+bNu27775LT09nb9CnT5/Ro0cnJSV5eHj8/e9/37Fjhz5X8lZUVKxcudLf39/Z2Zk2TyQSKRSK0tJSrS3pHAc2Ok+ksLCw2Vd5+umntUoGDRpECKFnflpKa6CIz+fb2trSE5Xscnt7e0IIPabW6NGjh5eXF7vEy8vLysoqKytLx7y+sWPH8vn86OhoQkhNTc2lS5cmTJgwYsQIc3Nz+u2flpaWm5vbcBpUq/8oQoijo6NSqSwrK2v2uVr/Gvp/KSgoYBeePHnyhRde6NOnj6mpKf1Hf/7556SF78MTJ078ykJ7veT/HyjcvXs3KysrJCSEXXju3Lna2lqal42i74Sm3if6a/Rdqlari4uLdTwrKCgoLi4uODiY5oGlpWVoaOiRI0fKysrS0tIyMjKysrLmz5+v+6DExMSE/jBjxgx6CoG++i+//CIUCg8ePKhjV9PnNjyEpeHK5/M1lTeloKBg+PDhCQkJW7Zs+fbbbxudZtWrVy/2yDp58hnReu/RQn0+150CZo02g141WFdXt3btWk0h/TbcuXOnjiM4evimNbWSkkql7O/TtLS0kSNHVlRUBAUFTZkyRSqV8vn84uLir7/+Wq1Wt7TBGzZs6NWr19atW48cOXLkyBFCiK+v7/fff09PZfB4vGPHjn322Wd79+7dvXv37t27eTzeuHHjfvzxx4bfDlRNTQ09XPX19Z09e7atrS2dgLpq1aq6ujqtjbXmNxJC6HwzfbosDafw0BL6OW+pRlsiFArZs2ebah79kDdszKNHjyorK5uaPmpjYzNo0KCUlJTi4uLk5GSlUhkSEiIWi0eNGkWH4mhGsicEcfJHEUIYPVYM1npuwydu2rTp3XfftbS0nDx58uzZs2nP4/z585GRkQ3/0Tp89tlnFy9e1Dx88cUXg4ODCSGDBw+2s7M7c+ZMfX29Zle4u7v37dv39OnTq1evpnGoY//QDGjqfaI/U1NTrRJ9dqOrq2tZWdm6deuOHj1aVFTk6Og4YcKE0NBQX19fOljLMMymTZtSU1M3bdrUVCU9evQQCARqtZr2yDV69+7dp0+fW7duXb9+valDATpZWiaTaZXTEmtr62bnD8tkssrKyh49etDj7EY19R7TKqevpc/nulNAEOqSmZlJj2f379+/f/9+rd8mJSWlpKQ0dTRK+3YNTwmq1Wqtw/DVq1eXl5dv3ryZDkZSMTExX3/9NXuzRt95DTsoAoFg4cKFCxcuzMrKOnPmzOHDh48dOzZlypSUlBQadRYWFmvXrl2zZk1aWtrp06d37959+vTpiRMn3rx5s9GL6Hfu3Hnjxo25c+f+8ssvmkKlUrlixYpW92wa1fDokpZo5uI39dlr9uqrltLqILIbo3uCe0hISFJS0rlz5+i5RHrwERIScuLEiRs3bjT7RW9AKpVq+fLllpaWV69epROLqKKiosjIyBZV9dVXX7G/rDXnOfl8/ujRow8fPpySknL69GlLS0t/f39CSEhIyLZt28rLy0+fPi0UCtmnPbXQd0JT75P2dv369YkTJxYWFnp5eVlbW6enpyckJHz++ec+Pj4BAQEikej8+fO3bt3SOqmuRSQS9e7d+86dO1onisiTnNPxZqZ9Mjrax0YXz2vqQJbNx8fnww8/nDVrVnBwcGRkZEBAQLNP6SZwalSXXbt21dfXz5kzJ6oBOvKnY5UZS0vLvn37lpaWpqamsstjY2O1jq+vXbtGCAkNDWUXaq5/0qBfKFqfeR2nDT08PObNmxcREfH+++8rFAo6mUWDx+P5+vouWLDg8uXLQUFB2dnZV65cabQe2jw66YNd2Ireqm4N1xpNSkoihGgmbTe6B0pKShrNrbaorKy8e/cuu+TevXsVFRVeXl4Nj5fZNCf6Tp8+7ePjQ2cz0sJTp05duHDBwcHB19dXRw302ILzfdusrKys8vJyf39/dgqSJ/+CFhkxYsRzLOwBUboroqKizp8/rzlFHBISolarDxw4cPPmTX9/f/ZlnVrormvqfcJG+/3c7sb09PQBAwYkJyc/ePAgJSWlpKTk+PHjf//73/Py8nbs2LFlyxahUPjLL7+sX79edz10dO3+/fvsQoZhaImOi+L79u3r5OT08OFDrTcnHYHWcQDBNnXq1D///FOpVE6YMKELLObAFQRhk5gnM7wXLVo0voGlS5fy+fw9e/Yolcqmapg7dy4h5KOPPtJ0YlQqFZ0WyEZPxNGLhKjKysqvvvpKazM6S4J9eM4wzJdffsneRqVSNRzwd3Z2JoTQdlZXV2ud/+HxeOwNGqLXlrFn3zAMs3LlykY3bov9+/ezF4bOyMg4dOiQmZnZ5MmTaUnDPUAIafRStrbT6o7Tf8ff/vY33c8KCgoSi8UREREpKSmant/TTz9tZ2f37bfflpeXN3v9O50uxNUC2fqj/+WHDx+yw+PMmTOaET5O0H3y448/lpSUaPYPHVtdtWoVwzC6u8uDBg3q1atXUlKSZvIRIaSmpuann37S2rI9dmNwcHB0dLTmDJBYLJ48efKvv/4qk8lyc3NlMllqaurcuXObPT9JJ5Nv3bqVPbdl3759hYWFrq6umhUMysvLv/vuOzq5l+Lz+XTWMfvLoays7Oeff9b8Sh+TJ0+OjIzk8XjPP/9865Zx73pwarRJ0dHRDx486N+//5AhQxr+tmfPnkFBQRcuXIiIiGjq+3Hx4sV//PHH0aNHAwICZs6cWVdXt3///vr6eldXV/YUlbFjx54/f/6VV15Zs2ZN3759b926tXLlyobj3i+88EJ4ePjOnTvt7OymTJlSXFy8fft2rePKhw8fBgQEzJ07d/To0b169WIYJjY2ds2aNSKRaNq0aYSQyMjIf//736+//vrQoUM9PT2rq6uPHDly6NAhZ2dnOi2+oeDg4C+//HLFihUmJiYBAQFFRUUbN25MSUnR3TdqBTrosnbtWh8fnxs3bixdurS2tnblypWak0ijR492dnY+c+bM22+/HRoaWl1d/ccff0RGRkql0kePHnHYEltb2z179piamr722ms8Hu+XX37ZunWrg4PDsmXLdD/R3Nw8ICDgwoULhBDNnFU+nz927NgDBw6wC5vi7+/P4/G++eYbhULh5ubG5/NnzJjR8Dp3zkmlUjrA+dprr82fP79Hjx5RUVErV67s1avXgwcPuHoVb29vNzc3mk+aXWFrazto0CDaq9MdhHw+f926dX/7299mz569fv36wMDAnJyclStXNsyeoUOH8ng8evVRz549+Xz+Cy+80MaVUNjLA7HxeDz2bOdmjRw58tVXX92zZ09QUNCyZcucnZ0vXLhAV6pav369ZuWKwsLChQsXCgQC9kSEZcuW7d27d+vWrWKx+OWXXy4tLf30008LCgrefPNN9tXuzRozZkxkZOSUKVOmTp26f/9+egFMt2aIazY6B3qukh6oNmrLli3k/1+91FBRUVFoaCg9USMQCKZNm5abm2tvb29ubq7ZRi6X08UmNIKCguh1b5MnT2bXtm/fPnb8+Pr60mUeNdcR5uXlNTy14uTk9N///pducPbsWa31yWg9ycnJmldpeB3hihUr2AtQeXh4JCYm2tnZWVlZabbRrCzT6G7UWiVHCx1W+fXXXzWdP0IIn88PDw/Xutry/Pnz7JV63NzcLl++3NTKMlqv4uLiIhaLtQoXL15MCDl8+DB9qFlZJiIigj0c6OXlpefdGz799FP6v2YvhrB582Zaj+aCQqrhdYQMw2zcuJE9W4e9skzDu0/QWQ/FxcU6mtTo3SfoFKSnn35aU5Kamspe2obP5y9ZsoSu5rxp0ybNZq2+jpCip0kcHR3Z/9mlS5cSQiQSSU1NDXvjRleW+f7779mL/w0ePJgOvmp9En/44Qd2dGmtLKPVKnq6kn25ZLuSy+Xz5s1j57e1tfX27dvZ29BbaggEAq3nXrt2jX3tB50orlAodL9ioyvL0E+xWCw+ePAgw1pZRuu5dK5TZmYmu5D2wtesWdOiP9xo8Rjcob4JOTk5tbW1Tk5OTXV9lEolXRq02dXx5XJ5YWGho6OjqalpeXm5VCr18fG5efMme5vk5OTU1NT6+npfX99hw4bV1tbm5OSYmZlpHcYWFRVFR0dXVlb26dMnODhYIBA8ePBAJBLR++BQ9+7dS0tLKywsNDU17dWrl7+/P3uqZH19fWpq6r1790pKSqRSaZ8+fQYPHsz+TObn51dVVXl4eLCflZGRkZiYWF5e7uXlNWbMGJFIlJWVxTCM5m+vqakpKCjo0aOHVvelqKioqqrK1dVVx9zu0tLSR48eOTo6mpubJyYmXr9+nV7hp3WpA/Xo0aOoqKjS0lJXV9fx48dLJJLs7Oy6ujrNBXYKhSIvL8/CwkJrMiG93k7rugj2S9P/lJmZGf3vVFRUREdHFxcXu7u7jxs3rtm56VRVVVVRUZFQKGQvOiqXy/Pz83k8ntary+Xyhw8fWllZNZz3WFFRQWfS011HH9ra2moNoeXm5tLVX7XWwGMrLCysrq7W+hfU19dnZmaKxWL2kZNSqYyNjc3IyDA3Nx81apSbm1t5eblMJrOzs9McFjx8+FAul/fq1UvzigUFBXRJVa0ZuY2iFUokEnYvqrKysri4WOttTHdCYWGhnZ2d1tSSgoKCM2fOVFdX9+vXb9SoUWq1utEPi6ZmQoiLi4tEIqEPbWxstKZz5+XlKRQKd3d3rSsH2lVWVlZsbGxlZaWbm9uYMWO0Fmitra3NzMzk8XgN1/dXq9UxMTF3796VSCQjR45kX1ralLq6uuzsbK3dTp68/+nbVa1WZ2VlmZiYsNcgJE3sHPqGbLgnOykEYUdbt27dhx9++P777+tzH1HoYOwgNHRbAKCDYIywfb355pt+fn6BgYFOTk7Z2dlHjx7dsGGDhYWFnuvLAABAe0MQtq/s7Oyff/6ZXeLp6blr1y59zmYAAEAHQBC2rxMnTly7di09Pb24uFgikWiuvTV0u6BxIpFozZo1HTBLEwCMB8YIAQCgW8MF9QAA0K0ZIAirqqr27t3b8a/bUrW1tYZuQldQX1/f8QuGdUl4Q3IFe5IrXWZPchmE1dXViYmJMTExutfALS0tXb58OYev2070ubkXNKuurq5F9y6ApiiVSgxkcAIfba50mT3J2WQZetG0j4+PiYlJcnLykiVLGi6qCQAAYGw4C0IzM7OioiK6dEVKSsqQIUPeeecdzL4DAAAjx9mpUfb9ke3s7HQs+AQAAGA8OL6O8LPPPsvMzExMTNy+fbuO7mBtba3W7T/oCv3cNqaN6uvru8z9lw2Irq2MPdlGCoVizZo1gYGBkyZNMnRbOj18tLnSKfYk+4YBTeE4CH18fKytrR88eHDo0KE5c+Y01S+sqanRupGeWCym6+gbD7lcjn5t26lUKoZhMHG0jY4fP56QkJCWlubv78/5DbC6G3y0udIp9qSZmVmzWchxEM6cOZMQ8s9//tPT0/PUqVPsu+qwWVlZsW+taZwYhrGwsDB0Kzo9GoR63roBGsUwTHR0tEAgqK2tjY+Px93j2ggfba50mT3ZLtcR8vl8Ho/X7J2aAUAfN27cyM/Ppzc5ovfeAwAOcdYjPH/+/F9//TVkyBC1Wr1v3z5ra+vRo0dzVTlAd5aVlUUICQgIiI+Pz8nJqa+v12fYAwD0xNnHydvb29ra+vjx41FRUePGjbt48SJGMgA4kZeXRwjx9PS0s7Orq6vTvWAFALQUZz1CJyenFStWcFUbAGjk5uYSQlxcXFxdXYuLi/Py8pydnQ3dKICuAydYAIwdDUJnZ2eaf/QhAHAFQQhg1Gpra4uLiwUCgYODg4uLC3lyphQAuIIgBDBq+fn59fX1jo6OQqHQ1dWVoAFPZcMAAB9gSURBVEcIwDUEIYBRo/0/GoEIQoD2gCAEMGrFxcWEEAcHB0KIvb09j8eTyWS4HxMAhxCEAEatvLycEGJtbU0IEQqFlpaWarW6oqLC0O0C6DoQhABGraysjBAilUrpQ/oDLQQATiAIAYwa7REiCAHaD4IQwKihRwjQ3hCEAEZNKwjpYCGCEIBDCEIA48UwzKNHj3g8Hs0/8iQR6flSAOAEghDAeFVUVNTV1VlYWAiFj5cFRo8QgHMIQgDjpXVelGCMEKAdIAgBjBeCEKADIAgBjBeCEKADIAgBjBddQcbKykpTYmlpKRQKq6ur6+rqDNcugC4FQQhgvGgQ9ujRQ1PC4/HMzc0ZhqmqqjJcuwC6FAQhgPGqrKwkhFhaWrILaS7SXwFA2yEIAYxXo0FoYWFBEIQA3EEQAhgvmnbsU6MEPUIAriEIAYwXTTvaBdRAjxCAWwhCAOOFHiFAB0AQAhgvjBECdAAEIYCRUqlUSqVSJBKZmJiwy9EjBOAWghDASDXaHSToEQJwDUEIYKQaHSAk6BECcA1BCGCk0CME6BgIQgAj1VQQokcIwC0EIYCRoguNNgxCWoIgBOAKghDASNFltbWupieEmJiYiMVipVKpUqkM0S6ArgZBCGCkqqurSWNBqCnEDSgAOIEgBDBSTfUICSHm5ubkSVICQBshCAGMlI4gRI8QgEMIQgAjRTt8tPOnBT1CAA4hCAGMFIIQoGMgCAGMFIIQoGMgCAGMFMYIAToGghDASNXU1BBCzMzMGv4KPUIADiEIAYyRUqmsra01MTERiUQNf4sgBOAQghDAGOkYICQIQgBOIQgBjJHuIMQYIQCHEIQAxkjHTBmCHiEApxCEAMYIQQjQYRCEAMYIY4QAHQZBCGCMmg1CHo9XXV3NMEzHtgugC0IQAhgj3UEoFApNTEzq6uqUSmXHtgugC0IQAhgj3UFIMHEUgDsIQgBjpGNZGYr+CsOEAG2HIAQwRrSrp6NHSIOQ5iUAtAWCEMAY0a6ejh4hJo4CcAVBCGCMaFcPPUKADoAgBDBGzU6WQY8QgCtCripSq9V79+6NiooqKirq27dveHi4p6cnV5UDdDeYLAPQYTjrEdbU1Pz8889jxoxZsmSJSqUaOXJkeXk5V5UDdDd69ghxahSg7TjrEVpaWp47d47+HBIS4uTklJCQMHHiRK7qB+g+1Gq1Uqnk8/kmJiZNbYMeIQBX2mWMsLS0tKyszN3dvT0qB+jyNDNleDxeU9ugRwjAFc56hBr19fVvvPHGq6++2r9//6a2KS8vHzx4MLvExMQkKiqK88a0Bdbs4IRKpWIYRqVSGbohnUlhYWFdXZ1IJKqsrNQUVldX19fXs6Oxrq5OJpOxtwF94KPNlU6xJ83MzAQCge5tOA5ChmHCwsIqKir27dunYzMLC4vt27ezS/h8vqWlJbeNaTsjbFKnQ4NQxyk+aKi4uFgoFFpbW7PfgTwej91HtLe3FwqFarUa79JWwE7jStfYk1wGIcMw8+fPT0tLO3nypKmpqa5XFQqHDh3K4UsDdCX0QFvHlFGCMUIA7nAZhP/617/i4+Ojo6ObupsoAOij2avpCcYIAbjD2WSZ3NzcdevW3blzp3fv3jY2NjY2Nnv37uWqcoBupdn11Qh6hADc4axH6OzsLJPJ2CW6j2cBoCn69AjNzMx4PF5NTQ3DMDomlwJAszgLQj6fL5VKuaoNoDvTp0coEAhMTEwUCoVCodA9JA8AumGtUQCjo0+PkODsKABHEIQARkefHiHBfBkAjiAIAYyOXC4negcheoQAbYQgBDA6za64TeGWhACcEM6dO1ef7fh8/q5du9q5MQBAiN6nRhGEAJwQRkREODk56d6otrb2wYMHCEKAjoHJMgAdSThr1qytW7fq3uju3bve3t4d0yAAwGQZgI7E13GPCA0zM7Nx48Z1QGsAgKBHCNCx+IsXL252I1dX1+jo6A5oDQDQu/LyeDyJRKJ7S/QIATiBWaMAxoWumkZXUNO9JXqEAJz4f0usKZXKu3fvFhQUsAvNzc1HjBjRsa0C6L7oRYT6LNWLHiEAJ/4XhBEREe+8805ubq7WFv37909PT+/YVgF0X3rOlCHoEQJw5HEQlpWVhYaGDho06Mcff3Rzc2Nv0exABQBwSP8gRI8QgBOPg/DGjRvV1dUHDhxwdnY2bIMAujk9p4wS9AgBOPJ4soyjoyMhRCQSGbQxAIAeIUBHexyE/fr1e/7557/66ivDtgYAWtojRBACtNH/Jsv8/vvvzz333PDhw0eMGMG+z6e9vX14eLgh2gbQHenfIxQKhWKxWKVSKZVKExOT9m8aQNf0vyD84osvLly4QAhJS0sTi8Wa8r59+yIIATqM/j1CuplKpaqurkYQArTa41OjGRkZa9eufeedd0pKSqqqqmQsly9fNmwTAboVGoT69AgJzo4CcOFxjzAzM7O+vn7t2rWWlpaGbRBAN6fnzQgp3JsXoO0e9wi9vb0FAkFJSYlhWwMAdGUZ9ji9DriCAqDtHgehi4vLhx9++P7778tkMsM2CKCbq6qqIoRYWFjoszHdDKdGAdri8anRysrKhISES5cuubu7DxgwwNraWrNFz549d+zYYaDmAXQ7LTo1SnuENDsBoHX+36LbAQEBhmoHAFCtGCNEjxCgLR4HoaWlZVRUlGGbAgAEk2UAOhzuRwhgROhdefl8vp6L3WOyDEDb8TMyMprdSKFQ4GpCgA6g/115KUyWAWg7/pdfftnsRjk5Obg3L0AHoNNe9DwvSjBZBoALwqysrCNHjujeKD8/v2NaA9DNtWiAkGCyDAAXhKdOnTp16lSz2+l5ogYA2qJFC40STJYB4IIwPT1dn+0QhAAdoKWnRhGEAG0n7N+/v6HbAACPoUcI0PFw+QSAEWnpGCGdXyqXy+vr69uzXQBdGYIQwIjof1deisfjmZmZMQyD+TIArYYgBDAiLT01SnBLQoA2QxACGJGWTpbRbIxLCQFaDUEIYERaOkZIcCkhQJshCAGMSCtOjWLiKEAb/e82TOXl5Rs2bDh79mx+fj7DMI1uvX//fn9//45qG0C3Q4NQ/8kyBEEI0GaPg7C+vv7FF1+Mi4sLCQkZN25cU5fPs2/YCwCcq6ysJIT06NFD/6fQdbcRhACt9jgI79y5c+HChYMHD86cOdOwDQLozuicF5pteqIbY7IMQKs9HiMsLCwkhEyZMsWgjQHo1ujlgPTSQP2fhSAEaKPHQfjUU0+Zmprque4oALSH6upqhmHMzc1btLQvghCgjR4HoVQq/fHHH8PCwtLS0gzbIIBuqxXnRQmuIwRos8djhOXl5atXr87Pz/f19ZVKpVKpVLNF79699blPEwC0USuupifoEQK02eMgFIlE48ePb3QLJyenDmwPQPfVuh4hghCgjR4Hobm5+ZYtWwzbFIBuri1BiMsnAFoNK8sAGAsaZugRAnQwBCGAsWhdj9DExEQkEimVytra2vZpF0AXhyAEMBatC0KCVdYA2gZBCGAsWh2EODsK0BbcB2F5eblCoeC8WoAuD0EIYBBcBuHChQvt7OykUuk333zDYbUA3QSCEMAguAzCmTNnXrp06cUXX+SwToDuoxV35aUQhABtIWx+E72NHj2aENKiZRIBQKN1K8sQBCFA23AZhPqrra2Njo5ml/D5/HHjxhmkMQBGoqKigrTwZoQUDUJ6L0MAaCnDBGFNTc0XX3zBLhGLxcOHDzdIY5pSXV2N3m3bqVQqhmFwiVuz1Gp1RUUFj8djGKbRvh29N0Wj70mxWFxXV1dSUoJOoT7w0eZKp9iTZmZmfH4zg4CGCUIrK6szZ84Y5KX1xzBMK6YtgBYahCYmJoZuiLF79OiRQCCwsrKytLRsapum7tDk4OAgFAoVCgXesfrAR5srXWZP4jpCAKNAz4vqSEEd6LNwahSgdbjsEcbExKSnp2dmZvJ4vK1bt44ZM8bb25vD+gG6MBpjCEKAjsdlEJaUlDx48ODZZ58lhDx48GDIkCEcVg7QtdEYa8VMGUKIlZUVedKnBICW4jIIp0+fPn36dA4rBOg+Wj1llDzpESIIAVoHY4QARqEtY4SmpqZ0sgxm5wK0AoIQwCi0ZYyQPOlKYpgQoBUQhABGoS2nRgnOjgK0AYIQwCi0sUeIiaMArYYgBDAKODUKYCgIQgCjQM9q0gshWoEGIU6NArQCghDAKLT61hMUxggBWg1BCGB4DMPQFbdbPVkGPUKAVkMQAhheRUWFWq22sLAQClu5xoW1tTUhpKysjNN2AXQLCEIAwysvLydPwqx16HNpPQDQIghCAMOjASaVSltdAw3CR48ecdYmgG4DQQhgeOgRAhgQghDA8GiAtfraCUJIjx49+Hw+HWvkrl0A3QKCEMDw2t4j5PP5lpaWdPYpd+0C6BYQhACGR8f22hKEBMOEAK2FIAQwvLb3CAmGCQFaC0EIYHicBCEdYkQQArQUghDA8OiF8G0MQnr1BYIQoKUQhACG18YVtyn6dIwRArQUghDAwCorK1UqlZmZmYmJSVvqsbGxIYSUlpZy1C6A7gJBCGBgNLrs7OzaWI+trS1BEAK0HIIQwMBKSkrIkxhrC1oDrQ0A9IcgBDAwGl1t7xHSGhCEAC2FIAQwMHoys+09QlNTUzMzM5VKVVlZyUW7ALoLBCGAgXEVhATDhACtgiAEMDAEIYBhIQgBDIyrMUKCYUKAVkEQAhgYhz1CGoToEQK0CIIQwJAUCkV1dbVYLLa0tGx7bbiCAqAVEIQAhlRUVEQIsbe35/F4ba/N3t6eEFJYWNj2qgC6DwQhgCHl5+cTQpycnDipzdnZmRBSUFDASW0A3QSCEMCQaBDSAGs7BwcHPp9fUlJSV1fHSYUA3QGCEMCQuO0RCoVCOzu7+vp6esYVAPSBIAQwJHoak6seoaYqmq8AoA8EIYAhcXtqlGCYEKDlEIQABlNfX19cXMzj8RwdHbmqk1aFHiGA/hCEAAZTVFRUV1dnY2MjFou5qtPFxYUgCAFaAkEIYDBZWVmEEHd3dw7r7NmzJyEkOzubwzoBujYEIYDB0CD09PTksE4XFxexWFxYWFhTU8NhtQBdGIIQwGAyMzMJIR4eHhzWKRAI3NzcGIZBpxBATwhCAIOhQejl5cVttbRCWjkANAtBCGAYtbW1eXl5tAPHbc20i4kgBNATghDAMLKzs9VqNR3S47Zm2iPMyMjgtlqArgpBCGAYaWlphJB+/fpxXnOfPn14PN69e/dqa2s5rxyg60EQAhjGzZs3CSG+vr6c12xhYeHh4aFSqe7evct55QBdD4IQwDDS09MJIT4+Pu1ROa2WZi0A6IYgBDCA3NxcmUxmbW1NF4LhnJ+fH0EQAugHQQhgAImJiYSQgQMHcnJj+ob8/Px4PF5qaqpCoWiP+gG6EgQhgAHExsYSQgIDA9upfqlU2r9/f5VKlZCQ0E4vAdBlIAgBOlpJScnt27dNTEz8/f3b71WCgoIIIXFxce33EgBdA4IQoKOdPHmSYZhhw4ZJJJL2e5WRI0fyeLwrV67IZLL2exWALgBBCNCh5HL5X3/9RQiZOnVqu76Qra3tyJEja2tr//zzz3Z9IYDOjssgLCgoWLhw4dSpU1evXo0heoBG/f7771VVVX5+fu104QTbrFmzeDxeZGRkbm5ue78WQOfFWRAyDDNp0iS5XL5gwYIzZ84sXLiQq5oBuoyEhIT//ve/AoFg3rx5HfByvXr1GjdunFKpXL9+Pe7KBNAUzoLw9OnTRUVFmzdvnjBhwo4dO3799dfS0lKuKgfo7Orq6o4cOfLll18yDPPKK6+0x8pqjXr77bednZ3v37//73//+969ex3zogCdi5CrihITEwMDA/l8PiHE09PTzs4uNTU1ODi40Y3r6upSUlK4eul2Ul1dbW5ubuhWdHq1tbUMw3C+rnSnUFVVpVQqZTJZVlZWcnJyRUUFIeRvf/vbrFmzOqwNZmZmq1ev/uSTTx48eLBo0aK+ffsOGDDAycnJyspKIpF0z/8LPtpcMf496ePjo8+bnLMgLCgosLGx0Ty0s7MrKChoamOZTDZ+/Hh2CZ/PHzp0KFeN4YRarRYIBIZuRafHMAzDMPQIqZvz8vJ6+eWXhwwZUl1d3YqnV1dXMwzTigvwzczMVq1a9eeff546dSo9PZ0u7dad4aPNFePfk5s2bXJ3d2/2+4ezIDQ3Ny8rK9M8rKmp0XGkYGpqOmnSJHYJj8fz9PTkqjGcUKlU3fN4mVtqtZoQYuSflnZiZmYmkUjoOmo+Pj49e/ZsY4Xm5uatW4nGwsIiLCxs3rx5N2/evH//fnFxcWVlpUKh6J63p8BHmyvGvyelUqk+R+GcBWHPnj1jYmLozyqVKi8vz93dvamNLS0td+/ezdVLt5PKykpLS0tDt6LTU6lUDMOYmJgYuiFAxGLx4MGDBw8ebOiGGBg+2lzpMnuSsxNW06ZNu3r1Kj3r8scff7i6uj711FNcVQ4AANBOOAtCJyen1atXjxo1avTo0YsXL/7hhx/aaTXhjhETE6N18hZaZ+3atStXrjR0K7qCmTNnRkZGGroVXYGzs3NVVZWhW9HpJScn02X8ugDOTo0SQhYtWvTKK6/k5OT079/fwsJCx5ZqtfrBgwccvjTn8vLyFAqFkTeyUygrK6upqcGebLuampqCggLsybZjGCYzM9PMzMzQDenccnNzVSqV8b8h3dzcmh3I5DEM0zGt0aiqqgoNDU1LS+vg120RtVqtUCiMfGZwp6BUKgkhGCNsu5qaGrFYLBRyefDaPVVUVFhaWnbqU1bGQK1Wy+Vy3X0eY/DXX38NGDBA9zYGCEIAAADjgau7AACgW0MQAgBAt4YgBACAbg1BCAAA3RqC8H+USuX169dTUlLkcjm7vL6+PiUl5dq1a1oTi0pLS+Pj44uKijq2mZ2DQqFgL7lHyeXyS5cuZWRkaJVnZmbGx8fjPkE6KJXKy5cv379/39AN6UzKy8u1PsvkyZtNq1ylUl2+fPnu3bsd2LpO4969ewkJCTKZTKs8IyPj0qVLWnuSvlE7331OGGAYhmH++usvGxubgQMHDh482MnJ6dy5c7S8vLx82LBhAwcO9PX1DQwMrKyspOX79u2zsbEZO3asra3tjh07DNdwo3Pt2jVfX1+BQCASibTKXVxcgoKCXFxc3nvvPU15eHi4k5PT6NGjnZ2dr1y50uHt7QTS0tLc3NxGjhzp5ub2j3/8w9DN6QSWLl1qa2tLCPnoo4/Y5YsXL9a82RITE2nh/fv3PT09R4wY4eHhERoaqlarDdFkY1RUVOTh4eHp6RkYGNijR4/169drfvX+++87OzuPGjXKxcUlOTmZFt6+fdvd3T0wMNDd3X3u3Ln19fUGaniLIQgfu3nzZmZmJv35iy++8PHxoT+vXr16woQJarW6rq4uODj4q6++YhhGoVA4ODicPHmSYZj4+PgePXpoAhIKCgpiYmIuXryoFYSTJk36z3/+wzBMUVGRvb395cuXGYa5fv26tbV1Xl4ewzDr168fM2aMIZps7KZPn/7hhx8yDCOTyVxcXDRHadCUuLi4u3fvvvrqq+wgTElJkUql9M22du3a4OBgWj5nzpz58+czDFNRUeHl5XXs2DGDtNkIPXr0KC4ujv6cmJjI5/OzsrIYhrly5YqtrW1hYSHDMKtXr544cSLd5qWXXlq8eDHDMOXl5T179jx16pSBGt5iCMJGREdH29nZ0Z+ffvrpPXv20J937tz5zDPPMAxz8uRJV1dXzfY+Pj4HDx7s+HYas2vXrrGDsLy8nM/nZ2dn04f/+Mc/lixZwjDMRx999PLLL9PCkpISHo9XUFDQ8a01ZjU1NUKh8Pbt2/The++9x+5Pgw5z5sxhB+GKFStCQ0Ppz0VFRTwer7CwUK1WSySSpKQkWr5s2bLXX3/dAG01eiqVSiKR0G700qVL586dS8tzc3N5PJ5MJlOpVCKR6MaNG7T8gw8+eOuttwzW3BbCGGEjNm3aNGPGDPpzTk6Ol5cX/dnT0zMnJ0erkJZnZ2d3fDs7kdzcXD6f7+bmRh82uidtbW0tLCxoOWjk5+fX1dVpblKm2XXQUjk5Ob169aI/29vbm5mZ5eTkFBcXKxSKhp9x0LJr1y53d/eBAweS//+xdXFxEYvFDx8+LCwsrK2t7aR7snst1zR79mymwUo6//jHP9jra3/55Zfp6elxcXH0oVwu16xTJ5FI6C1V6WJXmqdIJJJuNdHj9u3bH3/8ccPy9evXe3h4NPoUusc0i1pp9iR79xJCTE1Nu9We1EdNTQ0dcKUPNbsOWqrRNxt9vzX8jANbbGzs8uXLIyIi6I6Sy+XsRRPpTqMlnXRPdq8gpGfhtAr79eun+fnbb7/dsWPH+fPnra2taYmTk5NmulRpaamzs7NWIS13cnJq36YbE3t7+5dffrlhuWanNeTk5FRTU6NQKCQSCWHtSUdHx9LSUrpNfX19WVlZt9qT+nByclKr1eXl5VKplLB2HbQU+82mVqvpm42+32QyGV2DG7u3oYSEhJkzZ+7duzcgIICWsPekSqWqqKhwdnam70+ZTObg4EA6257sXkE4ffp0Hb/dvn37xo0bz5075+LioikcNmxYbGzshAkTCCExMTHDhw8nhAwdOjQ9Pb2srEwqlcrl8sTExO+//769G288bGxsNKeO9eTs7Ozm5hYTE0P3ZGxs7GuvvUYIGTZs2MaNG+k2ly5dkkqlmnOAQNna2vbq1Ss2Nnbq1KmEEM0P0FLDhg379ttv6c/x8fG2traenp4ikcjPzy82NpYe28XExGi+7oEQkpKS8uKLL27fvp1+cqlhw4Zt376d/hwXF0c/3QKBwNvbOzY2ln45xMbGjhs3zjCNbjnBf/7zH0O3wShERES8+uqrs2fPzs3NjYuLi4uLCwgI4PP5Li4uCxYscHFxSUpK+vzzz3/88UcXFxepVJqUlHTw4EEbG5tPPvnEwcFhyZIlhv4LjEVNTc2GDRtiY2MvX75sYmJy/fr1YcOG8fl8tVr95Zdfuru7//bbb2fOnNm6datYLPb29l63bl1eXp5KpQoPD3/ttdc60YenY/B4PIFAsGrVKk9Pz/3790dERGzbts3U1NTQ7TJqZ86c+eOPP86ePVtSUlJQUGBqauri4tKvX7+1a9fm5+crlcrw8PDXX3997NixhBBTU9OPPvrIy8vryJEjv//++/bt243/jgodo6Cg4JlnnvHz87OysqLfio6Ojra2tt7e3p9//nlJSYlCoQgPD3/77bdHjRpFCBGJRCtXrvT09Dx8+PDBgwe3b9/eWe51hSB8rLCw0MHBQSKRKJ4YO3asQCBwd3f39/c/ePBgZmbmunXrAgMD6fbPP/98ZmZmZGSkt7f3d999h9sMaSiVylOnTgmFwsDAQIVCQQihH5LAwEATE5NDhw7x+fxt27bRU1JCoXDGjBnnz5+PiYmhc69xc5yGhg0bZmlpefDgQbVavXXrVs2cI2hKWlra7du3e/fu7erqqlAo+vTp07NnT5FINH36dM2bbdGiRfTNNnjwYAcHhwMHDsjl8s2bN2sm1EBVVVVtbS3dh5Sfn5+Dg4NYLJ4+ffrZs2fj4uJeeeWVBQsW0D3p7+8vlUoPHjyoUqm2bt3a1IwBI4TbMAEAQLeGyycAAKBbQxACAEC3hiAEAIBuDUEIAADdGoIQAAC6NQQhAAB0awhCAADo1hCEAEYkODh4+PDhw4cPP3DgAC3ZtGkTXZGg7UpLS4c/cfnyZU7qBOgCEIQARiQxMdHNzW3RokWDBg2iJXl5ecnJyZxUbm5uvmjRomnTpl25cuXRo0ec1AnQBSAIAYyLr69vaGho3759Oa9ZIpGEhoY+++yznNcM0Kl1r7tPAHSw/Pz82NjYQYMGaYJNqVQePXq0Z8+erb7LwYkTJ2pqaqZOnVpfX3/06NGhQ4dKJJIDBw6UlZWNHz8+KCiIEJKamnrs2DETE5MXXnihd+/enP09AF0ReoQA7cje3v6bb74ZP3685gaWy5Yt+/vf/86+Q6z+1Gr1e++9N3PmTJFIJBKJKisrX3rppfXr1z/99NO//fbbzp07R40atX379m3bto0aNerPP//8/PPPhwwZcu3aNU7/JoCuBkEI0I6EQuG+ffuqq6vDwsIIIX/99df333+/YcOGIUOGtLSq6urq6dOn79+//9SpU+xbEu7evfvEiROJiYn3798PCQlZtmzZ5s2bb9++ffny5Vu3bpmZma1Zs4bLPwmgy0EQArSvnj17bt++/dChQytWrJg7d+6MGTPefffdllZSWlo6ceLEmzdvXrx4ceTIkexfvf7660OHDiWECIXCl19+uaysbOnSpY6OjoQQOzu7SZMmcTXXBqCrQhACtLtp06bNnz//iy++sLa21tzaW3+1tbXDhw+Xy+WXLl3q16+f1m8HDBig+dnOzk6rxN7evri4uLUNB+gWEIQAHYGmkUAg4PNb/KHj8/m9evXKzMzMyMho+FuRSKT5md4fVasE9xwF0A1BCNDuNm3atG/fvq+++qqoqKgV50UFAsGxY8fGjBkTEhJy9uzZ9mghQHeGIARoX6mpqeHh4fPnzw8PD9+2bduePXt27tzZ0krEYvEff/wxadKk559/Pioqqj3aCdBtIQgB2lF1dfVLL73Ut2/ftWvXEkJeeumlt9566913371+/XpLqxKJRPv27XvppZemTp165MiRdmgsQDf1f4jX8nppFVTaAAAAAElFTkSuQmCC", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 13 } ], "cell_type": "code", "source": [ "gaussian_width = 6e3\n", "gaussian_amplitude = 3.0\n", "gaussian_bump = @. gaussian_amplitude * exp( - grid.x^2 / (2*gaussian_width^2) )\n", "\n", "plot(grid.x/1e3, gaussian_bump, # divide with 1e3 to convert m -> km\n", " color = :black,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\",\n", " title = \"A gaussian bump with half-width ≈ \"*string(gaussian_width/1e3)*\" km\",\n", " size = (600, 260))" ], "metadata": {}, "execution_count": 13 }, { "cell_type": "markdown", "source": [ "Next the noisy perturbation. The `mask` is simply a product of hyperbolic tangent functions." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=2}", "image/png": "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", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 14 } ], "cell_type": "code", "source": [ "mask = @. 1/4 * (1 + tanh( -(grid.x - 100e3) / 10e3)) * (1 + tanh( (grid.x + 100e3) / 10e3))\n", "\n", "noise_amplitude = 0.1 # the amplitude of the noise for η(x,t=0) (m)\n", "η_noise = noise_amplitude * Random.randn(size(grid.x))\n", "@. η_noise *= mask # mask the noise\n", "\n", "plot_noise = plot(grid.x/1e3, η_noise, # divide with 1e3 to convert m -> km\n", " color = :black,\n", " legend = :false,\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\")\n", "\n", "plot_mask = plot(grid.x/1e3, mask, # divide with 1e3 to convert m -> km\n", " color = :gray,\n", " legend = :false,\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " xlabel = \"x [km]\",\n", " ylabel = \"mask\")\n", "\n", "title = plot(title = \"Small-scale noise\",\n", " grid = false,\n", " showaxis = false,\n", " xticks = [],\n", " yticks = [],\n", " bottom_margin = -20Plots.px)\n", "\n", "plot(title, plot_noise, plot_mask,\n", " layout = @layout([A{0.01h}; [B; C]]),\n", " size = (600, 400))" ], "metadata": {}, "execution_count": 14 }, { "cell_type": "markdown", "source": [ "Sum the Gaussian bump and the noise and then call `set_uvη!()` to set the initial condition to the problem `prob`." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=1}", "image/png": "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", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 15 } ], "cell_type": "code", "source": [ "η0 = @. gaussian_bump + η_noise\n", "u0 = zeros(grid.nx)\n", "v0 = zeros(grid.nx)\n", "\n", "set_uvη!(prob, u0, v0, η0)\n", "\n", "plot(grid.x/1e3, η0, # divide with 1e3 to convert m -> km\n", " color = :black,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\",\n", " title = \"initial surface elevation, η(x, t=0)\",\n", " size = (600, 260))" ], "metadata": {}, "execution_count": 15 }, { "cell_type": "markdown", "source": [ "## Visualizing the simulation" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We define a function that plots the surface elevation ``\\eta`` and the\n", "depth-integrated velocities ``u`` and ``v``." ], "metadata": {} }, { "outputs": [], "cell_type": "code", "source": [ "function plot_output(prob)\n", " plot_η = plot(grid.x/1e3, vars.η, # divide with 1e3 to convert m -> km\n", " color = :blue,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " xlabel = \"x [km]\",\n", " ylabel = \"η [m]\")\n", "\n", " plot_u = plot(grid.x/1e3, vars.u, # divide with 1e3 to convert m -> km\n", " color = :red,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"u [m s⁻¹]\")\n", "\n", " plot_v = plot(grid.x/1e3, vars.v, # divide with 1e3 to convert m -> km\n", " color = :green,\n", " legend = false,\n", " linewidth = 2,\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"v [m s⁻¹]\")\n", "\n", " Ld = @sprintf \"%.2f\" sqrt(g*H)/f /1e3 # divide with 1e3 to convert m -> km\n", " plottitle = \"Deformation radius √(gh) / f = \"*string(Ld)*\" km\"\n", "\n", " title = plot(title = plottitle,\n", " grid = false,\n", " showaxis = false,\n", " xticks = [],\n", " yticks = [],\n", " bottom_margin = -30Plots.px)\n", "\n", " return plot(title, plot_η, plot_u, plot_v,\n", " layout = @layout([A{0.01h}; [B; C; D]]),\n", " size = (600, 800))\n", "end\n", "nothing # hide" ], "metadata": {}, "execution_count": 16 }, { "cell_type": "markdown", "source": [ "## Time-stepping the `Problem` forward" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We time-step the `Problem` forward in time. We update variables by calling\n", "`updatevars!()` and we also update the plot. We enclose the `for` loop in\n", "an `@animate` macro to produce an animation of the solution." ], "metadata": {} }, { "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "┌ Info: Saved animation to \n", "│ fn = /home/runner/work/FourierFlows.jl/FourierFlows.jl/docs/src/generated/onedshallowwater.mp4\n", "└ @ Plots /home/runner/.julia/packages/Plots/OfMyZ/src/animation.jl:104\n" ] }, { "output_type": "execute_result", "data": { "text/plain": "Plots.AnimatedGif(\"/home/runner/work/FourierFlows.jl/FourierFlows.jl/docs/src/generated/onedshallowwater.mp4\")", "text/html": [ "" ] }, "metadata": {}, "execution_count": 17 } ], "cell_type": "code", "source": [ "p = plot_output(prob)\n", "\n", "anim = @animate for j = 0:nsteps\n", " updatevars!(prob)\n", "\n", " p[2][1][:y] = vars.η # updates the plot for η\n", " p[2][:title] = \"t = \" * @sprintf(\"%.1f\", prob.clock.t/60) * \" min\" # updates time in the title\n", " p[3][1][:y] = vars.u # updates the plot for u\n", " p[4][1][:y] = vars.v # updates the plot for v\n", "\n", " stepforward!(prob)\n", "end\n", "\n", "mp4(anim, \"onedshallowwater.mp4\", fps=18)" ], "metadata": {}, "execution_count": 17 }, { "cell_type": "markdown", "source": [ "## Geostrophic balance" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "It is instructive to compare the solution for ``v`` with its geostrophically balanced approximation, ``f \\widehat{\\bm{z}} \\times \\bm{u}_{\\rm geostrophic} = - g \\bm{\\nabla} \\eta``, i.e.,\n", "\n", "$$\n", "\\begin{aligned}\n", "v_{\\rm geostrophic} & = \\frac{g}{f} \\frac{\\partial \\eta}{\\partial x} \\ , \\\\\n", "u_{\\rm geostrophic} & = - \\frac{g}{f} \\frac{\\partial \\eta}{\\partial y} = 0 \\ .\n", "\\end{aligned}\n", "$$\n", "The geostrophic solution should capture well the the behavior of the flow in\n", "the center of the domain, after small-scale disturbances propagate away." ], "metadata": {} }, { "outputs": [ { "output_type": "execute_result", "data": { "text/plain": "Plot{Plots.GRBackend() n=4}", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1wT5x8H8E8Gew8BURQUJyoqoDgQq7hr1Tr6q7sqtdbdqnWLtlqr1aq17lW1arVu695bUJQhS0EBWYIMgQAhyf3+uGuIIexAQL7vV199HU+e3D05k/vePZPHMAwIIYSQ2oqv6QIQQgghmkSBkNQAKSkpAQEB9+7dCwwMzMvL03RxNOnt27eTJ0/esGFDiTlnzpw5ffr0Ch7u5cuXkydP3rt3bwX3wwoKCpo4ceLhw4fVsjdC1IUCIam+xGLxli1bWrduXadOnbZt23bt2tXZ2dnIyKhHjx4HDhyQSqUaKVV6evqOHTsuXLigkaO/f/9+x44d58+fLzHnwYMHDxw4UMHDJSQk7Nix48aNGxXcDysmJmbPnj0PHjxQy94IURehpgtAiGrJycmDBw++f/++trb2p59+6uLioqenl5GR4efnd/v27Rs3boSEhPz8889VX7CEhITJkyf369evX79+VX/00vPw8NDUvQIhNQsFQlIdSSSSYcOG3b9/v3PnzocPH27QoIHiq7GxsT4+Prm5uZoqXo1w6tQpTReBkJqBAiGpjg4cOHD79u2GDRteuHDB2NhY6VU7O7vdu3cnJiYWfuOzZ898fX0zMjLq16/fq1cvS0vLwnnS09OvXLkSGxurq6vr5ubm5uZWOM/Lly/9/f3j4uJ0dXVtbW07depkZWUFIC4u7vnz5wAyMjKePHnCZra2tq5fv75UKn327Jm+vn6LFi0yMjIuXLgQFxfXsWPHrl27stkiIyNv376dnJxsY2PTvXt3peienp4eGRlpZWVlZ2cXHh5+69YtkUjUpk2b7t278/mqmzDevXt34cKFxMTEhg0b9uvXz9DQUPHVgIAAAM7Ozkrvio2NvXXrVlJSkpmZmaOjY5cuXQQCgcr9K3n16tW1a9cyMzNbtmzp5eVV+F2JiYm+vr7R0dFSqbRRo0Y9evRQKpJKEonk0aNHkZGRiYmJlpaWnTp1atGihVKeoKCg/Pz89u3b5+XlXbx4MTIy0szMrFevXvXr1y+8Q7FYfO/evZCQkPz8/Hr16nXt2rVu3bpKeSIiIu7evZuSklK3bt0ePXrUq1evNGeAfLQYQqqfDh06ANi8eXPp3xITE9OtWzfF77aBgcEff/yhlG3Xrl1KkdXDwyM+Pl6eQSKRfP311zweTzEPj8e7cuUKwzALFiwo/CP6/vvvGYZJTU0F0L59++PHj8sPMWPGDIZhcnNzJ0yYoLhPgUAwa9YsiUQiPy77ADdjxozvvvtOMWeXLl1SUlLk2V68eAGgV69ef//9t2KYsbW1DQoKUvyk5ubmJiYmiilZWVlfffWVUli1srIq5qzevn0bwJgxY3788UfFN7Zv3/7NmzeKOfv166d00szNzU+cOKGY59y5cwCmT58uTzl9+rSZmZnS+Rw6dGhWVpbiG+vXry8UCoOCgho1aiTPpqur+9dffykV+MKFCw0bNlTcG5/P37JlizxDamrq4MGDFTNoaWktXbpUJpMVcx7Ix40CIal23r9/zz5tREVFlfItqampDg4OPB5vwoQJN2/eDAsLO3TokJ2dHYCjR4/Ksx09ehSAiYnJtm3bIiIiHj58OGjQIACtWrXKyclh8+zatQuAu7v7pUuXYmJiQkJCzp8/7+3tfePGDYZhXrx4sXv3bgBubm5X/hMREcH8FwitrKz09fVnzJhx7ty527dv37x5k2GYsWPHAnB2dr5w4UJkZOSpU6eaNGkCYNasWfKysYHQ1tbWzMxs3759MTExfn5+n376KYBPPvlEfplmA2G9evUMDAwWL158586dW7duDRs2DICLi4viOVEKhBKJxMvLC4Crq+vJkydfvHjh5+e3c+fOTp06FXNi2UBoa2traGi4devW6Ohof3////3vf2wszM/Pl+f08PBYvnz5lStXwsLC/Pz8Vq1aZWhoqKOjExISIs9TOBDu3LlzyJAhR44cefz4cVhY2NmzZ7t06QLA29tbsRj169fn8/kNGjT44osvLl265Ovru2TJEoFAoK+vn5iYKM92+fJlgUCgo6OzZMkSf3//sLCwixcvTps2bePGjWyG3NxcV1dXAEOGDLl69WpYWNjp06dbtmwJYN26dcWcB/Jxo0BIqp3g4GAAOjo6pX/L7NmzASxYsEAxMTw8XEdHp3HjxmwUkUgk7LPCyZMn5XkkEom7uzsA+bPjyJEjAfj7+xd1rJCQEAD9+vVTSmcDIYBFixYppj99+hSAqamp4oPd69evdXR0BALBq1ev2BR5k55i8cRiMXuZPn/+PJvCBkIAe/bsUfwUjRs3Vrp1UAqE+/fvZ6OXSCQq6qMVxgZCpcNJpdLOnTsDOHjwYDHvZY/IPhOzCgfCwkQiUZMmTbS1tdPT0+WJbBXomDFjFHOOHz9esWDyk/DPP/8UtfP169cDGD16tGJicnKyubm5qamp0mMoqT1o+ASpdjIyMgAUbl46e/ZsLwUDBw5k0xmGOXjwoFAoVKq3bNq0qZeXV2RkZEREBAB/f//o6OgWLVqwT4EsgUAwb948AMePH2dTTE1NAZS7i79AIJgzZ45iysmTJwF4e3tbWFjIExs2bDhy5EipVKrUpaVJkyaKxdPS0po5c6Z8J3JWVlbjxo1TPGiPHj0AvHr1qqiCHTp0CMCSJUv09PTK+qGsra1Hjx4t/5PP57N3HkqlUsJ+EF9f3zIdS09Pr1evXmKx+NmzZ0ovzZ07V/HPXr16QeEjsw2NLi4uQ4cOLWrn7HiSxYsXKyZaWlqOGDEiPT2dxnXUWtRZhlQ7BgYGAHJycpTSk5OT2f4pDMOkp6ez2QC8efMmOTnZ1NR05cqVSm+Jj48H8Pr162bNmrFPcu3atVNqynJxcQHAdoEBMG7cuO3bt0+dOnX37t19+/bt3r27p6entrZ2KQtva2vLhlI5+XGVcrq4uOzdu1d+XFbr1q2Vite2bVvF4rGaNGmi1NRnbW0NICkpqaiCsX1nChejNFq0aKGlpVV8qd69e7dmzZrLly/HxcUlJycrphe/89OnT2/bti08PDw+Pl5xtoSUlBTFbDwer2nTpoop7EeW95liPyBbMJWkUmlgYKBAINizZ4/SSQ4NDQXw+vXr4otKPlYUCEm1U69ePR6PJxKJkpKS2Isda8KECRMmTACQlpZmbm4uT09PTweQlZW1Y8eOwnszMzOTSCRsBgBs509FbEpmZib7Z4cOHe7evbt8+fLr16/7+/uvWrXK2Nh4zpw5CxYsEApL/r0U7qfKHlfxg6g8rmJiidn09fWVsrFxUSaTFVUwdg82NjYlfABVSizVu3fv3NzcXr161b59+9GjR5ubm7OBc8GCBezJL8rq1asXLFhgamo6YMAAe3t7IyMjABcvXrx586bSG9nGP8UU9iMz/82W/P79ewCFO4jKZWZmSqVSPp+/c+fOwq+amZkVc/bIx40CIal2LC0tmzVrFhYWdu3aNbbFrnjs1dPOzi4qKqrEbG/fvlVKZ5+iTExM5Cnu7u4XLlzIysq6e/fupUuX9u7du3TpUh6Pp1SlppLSo4b8uIWf1dgUpS6spcxWDiYmJllZWfHx8Q4ODmV9b4ml+uOPP169ejV79my2EY719u3b+fPnF7PbzMzM5cuXW1paPn36VHEgRERExM2bN8taSPZfkK0DUMnAwIDH4+no6CQlJSk94JJajtoISXXE9oNYv3598c8TrAYNGlhYWLx69SohIaGYbK1atQLw5MkT5sMVV/z8/OSvKjI0NOzbt+9vv/125coVAP/88w+bzl5DS1MwlpOTE3tcpXT2uK1bt1ZMDAgIUHou8ff3V1m8smIrRdm9lVVISIjSFK9KpWKrJdnepHKFP7KSsLCw3Nzcrl27Kg0HLF8hS/yAWlparVu3zsnJYbsvESJHgZBUR99++23jxo2fPHkyadKkEmfZ5vP57PiEhQsXMoWWFWNrJgG0bdvW0dExPDxcsYuHRCJZs2YNgOHDhyvll7O1tQUgLwb7Z2xsbCk/Czu2YdeuXYotZ1FRUUeOHBEKhUpj2qKiok6cOCH/UywWb9q0CUAxHUBKacyYMQBWrFiRnZ1d1vcmJyezXUBZUqmUffKTl4qtEI6JiVHMs2LFiuJ3W6dOHQCxsbGK/2onTpwo3E2mNNzc3Jo3b/7s2bNiJvX+6quvACxZsqTwfUzhf3dSi2iyyyohRQsKCmLn+2jQoMHixYuPHz9+5cqVI0eO/Pjjj82bNwdga2srz5yens4m9u7d+/Dhw0+fPr179+7+/fu//PLLJk2ayLOdPn2ax+MZGRlt2LAhODj42rVr7Hyh7dq1y8vLY/N4enp+9tln+/fvv3//flhY2Pnz59mhAkuXLpXvh33IGzt27MaNG7dv3/7gwQNGYUB94c/i7e0NwMnJ6dSpU8HBwUeOHLG3twfwww8/yPOw3UcbNGhgbGy8ZcuW0NDQmzdvsh0j+/TpI88mH1CvdIilS5fiw/EMSsMnZDIZOyqxdevWhw4dCg4OvnPnzubNm1UWWI4dPmFnZ6evr79u3bqQkJB79+6x3UE7duwonxCAjT22traHDh0KCwu7evVqr1692JGdDg4O8r0pDZ+QyWRsPa23t7efn19wcPCaNWsMDAzYUfNHjhyRv5EdUK9UtuvXrwOYNGmSYmm1tLS0tLTmzJlz586d4ODg06dPe3t7r1+/ns2Ql5fn4eHBFv7PP//08/N7+PDh4cOHJ02aZGRkVMx5IB83CoSk+kpISPj666+VukgAsLS0nDNnjuKwPIZhkpOTR4wYodSXUl9ff/z48YrZ/vrrL8VhDAD69u379u1beYaxY8cqTR4mFAqnTp0qFovleR4/fty2bVt5c6DSzDKFP4hYLJ4+fbribrW1tRctWiSVSuV52EA4c+bMRYsWKTY0enl5paWlybOVOxAyDJOTk/Ptt98qdfmxt7cv5p9APrPM2rVrFcvfuXPnpKQkeTaZTPbtt98qFpvtpsvn84sJhAzD+Pr6KvbfEQgEy5cvX7hwYfkCIZvo6Oio+AG1tbV37dolz5CVlTV58mSlNkJtbW3Fuw1S2/AYWqGeVG8ikej+/ftxcXE5OTnGxsYtWrRo3bp1UR044+Pj79+/n5KSYmRkZGdn5+rqWriDZXZ29p07d16/fq2np+fm5saOWFfErnERHx8vFovr1avXvn37wn0+AYjF4sTERIlEYmJiYmFhIZPJ2GHyRU1cGR8ff/v27fT0dAsLC09PT6WumKdPnx48ePDMmTM3bNjw+vXrO3fu5ObmtmnTpkOHDooBJj8/PzY2Vk9PT6l7ZFpaWlpampWVlXz8Jdt1SHFOMlZSUhI7zaaxsXGzZs0KjydRlJubGx8fb2hoaGVlFRcXd/Pmzezs7JYtW3bu3LnwDKgRERH+/v5ZWVmOjo4eHh4CgSAqKkooFMpnVRWJRHFxcaampmylqDzx3r17r1+/NjY29vT0tLGxSU1NTU9PV/wsMTExUqlUqZtPTk5OQkKCkZGR4t4ASKXSR48ehYeHS6VSW1vbzp07Kw1oAZCSknL//v34+HgDA4N69eq5uLgo9pYitQ0FQkKqBcVAqOmyEFK7UGcZQgghtRoFQkIIIbUaDagnpFpo2bLl6tWr2bURCCFVidoICSGE1GpUNUoIIaRWo0BICCGkVqNASAghpFajQEgIIaRWo0BICCGkVqNASAghpFajQEgIIaRWo0BICCGkVqNASAghpFar2YEwPj4+ISFB06UoklQq1XQRaio6deXDMIxMJtN0KWokmUxG02yVz0fwlavZgXDHjh07duzQdCmKJBKJNF2EmopOXflIpdK8vDxNl6JGEovFEolE06WokT6CX2vNDoSEEEJIBVEgJIQQUqvRMkyEEKI22dnZDx480HQpqlROTo6enl4VHEggEHTr1k0gEKh9zxQICSFEbU6ePDlv3jwnJydNF6TqMAzD4/Gq4EB+fn5Xrlxxc3NT+54pEBJCiNpIpdLevXvv27dP0wX5CLm7u1dSD1VqIySEEFKrUSAkhBBSq1EgJIQQUqtRICSEEFKrUSAkhBBSq1EgJIQQUqtRICSEEFKrUSAkhBBSq1EgJIQQUqtRICSEEFKrUSAkhBBSq2kmECYnJ2/evHnNmjUvXrwo/KpMJrt79+5vv/22YcOGwMDAqi8eIYR8BB48eDBu3Dj5n717946OjtZgeaotDUy6nZKS0r59+549e1pbW7u5uV2/fr19+/aKGf7444/t27d7eXnxeLxu3bqtXbvW29u76stJCCFqwDBISqqKA/H5sLJSTHj//n1YWJj8z4CAgNzc3KooSU2jgUC4c+dOZ2dndnZ2XV3d1atXHz16VDHDmDFjpk2bxq7r4ezsvHLlSgqEhJCaSizGkiVVcSATE/z6a1Uc6KOjgUB49erVYcOGsdsDBgzYtGmTUgZTU1P5tra2tpaWVtUVjhBC1EtHBzt3aroQpDgaCITx8fHW1tbsto2NTXp6enZ2toGBQeGcWVlZy5cvnz17dlG7YhjmypUrWVlZioljx45t2rSpestcPnl5edra2pouRY1Ep658JBJJfn4+n0+d4MosLy9PIBBUfLk7iUSilvKohaGhofzyKBKJUlNTNVueisvPz8/LyyvTW7S1tUtcN1gDgZDH4zEMw26zXzuVv9u8vLyhQ4e6u7tPnjy5mF3p6emZmZkpJuro6FSTCwGfz68mJalx6NSVD/8/mi5IzaOuU1c1a7WXkpOT05s3b/7555927dqtXr36I/hi8Hi8yvgUGgiEtra2CQkJ7HZCQoK5ubmenp5SHrFYPHz4cFNT0927dxf/xfLw8Fi4cGFllbVitLS0qF63fOjUlQ/7Y6FTVw5SqVQgEFT81AkEArWURy1MTU0PHz78yy+/SCSSH374AYCRkZGmC1UhQqGwMr7eGgiEffv2PXPmzLRp0wCcOXOmb9++bHp4eLi1tbWpqalUKh07dqxAIDh48KBQqIESEkLIx6F///79+/dntz/77DPNFqba0sCT8sSJE6OiooYOHTp16tQdO3bMnz+fTR8wYMC5c+cAbNy48dixYwzDjBo1asSIEV988UXVF5IQQkgtoYHnLTMzM39//1OnTolEogULFtSvX59N3717d5MmTQAMGTKkTZs2VV8wQgghtZBmKh6NjY3Hjh2rlOjp6cluODg4ODg4VHmhCCGE1EY1vhMRIYQQUhEUCAkhhKj2+vXrJ0+e5Ofna7oglYsCISGEkAKHDx/28fEBMH369IEDB/7yyy9Kk5agLPMG9O3bNyoqqqzvqmIFbYQXLlxYtWpVKd92+PBheScXQgghH40jR4588803APbt2xcWFlavXj2lDEuWLNm9ezeAvXv39unTp5hdRUdHv3z5slGjRgBatGiRkJDg6up69OhRc3PzSit+eRQ8ESYmJj5//tyoFO7evSsSiTRYaEIIIRWRlZU1bdo0Nze38ePH//XXX5s3b2bTRSLRw4cPPTw8RowYkZWVNXXq1Llz5yq9d+nSpfHx8Vu3bh07dmx+fn58fPzEiRPPnj3r4eHh6en577//ynOeOnVq8ODB7HZgYOC7d+8sLCxWrFiRlpY2cuRI+VIYUVFRkyZNks84VvU+6DXaqlWr8+fPl/ieajV1AiGEkLL6+uuvAZw4cSIkJGTs2LHyB7vLly97enoaGBj8/PPPx44dW7ZsWZ06dZTey87tMmjQoEmTJoWHh2tpaR08eJDP5+/du/fp06cjR46MiYkxMTEBcPr06eXLlyu+a9y4cYsXLzYzM4uLizt+/PioUaMAbN++vTQzglaegkDYtGnTTz/9tDTvmTBhAvshCSGEFE+SKzk6/GjJ+SpMz1xvyJ9DSpMzNzf377//Ztc/sLOzGzZsWGZmJvvS6dOnBw0axOPx2PpMe3t7pcmc09PThw0blpqa6uXlZWxszD7GSaXSDRs2GBgYODo6+vj4PH/+vHPnzunp6aGhoZ06dQJw9erVqVOnWlhYyKcSmzJlytatW0eNGiUWi/ft23fx4kU1noqyKgiEXbp06dKlS2nes5OWFCGEkNIR6gpHnh2pkUPfuHFj+PDhAJo0afLgwQN5elJSkra2tnwVIHt7+6CgIABSqfTixYu/Fruo4S+//OLk5LRx48b169fHxMQ0bNgwISHBzMxMvoKQkZERG1bPnTvXt29foVAolUonTJhw4sQJZ2fnzp07s8PEP//881mzZj1//vz58+cODg7t2rWrnHNQKjSTJyGEfJy6d+8eFxeHQiv82NjYsG17tra2ACIjI9n0e/futWzZ0sLCoph93r9/f/HixQBatmzZpUsXY2Nj+SIKSk6fPs3WfMbGxkokEldXVwBNmjTp2bMnAG1t7YkTJ+7evTsoKKiYJYaqRnHDJwIDA0ePHl1lRSGEEKJGPB5PR0dHR0dHacUGHR2d0aNHT506NTQ09MSJE6dOnWLT2XrR4vdpaWkpFotzcnIWLFhQuB+NXF5e3u3bt3v16gXA1NSUz+fn5+ffvXv38ePHI0aMYPN8/fXXe/fuffLkiTxFUz54Irxx44ZUKpX/+fLly+zs7CovEiGEkMq1detWHx+fyZMnt2nT5quvvmIv9efOnVNsq3NxcSncNXLFihVTpkzx8fGZMGHCgAEDAOjq6jo7Oytlu379eseOHdn6UlNT0/nz53fr1k0oFB47dky+FFTDhg1dXFyaN2+ucmH2qvRBIBw0aJBiB6G8vDw3N7fKOGpubu6tW7cYhunevbuurq7KPPHx8QkJCc7OzrQSEyGEqJeWltYvv/wCQCKRfPLJJxMnTnz9+rW9vb18nmcej/f48ePCb3Rycrp9+7ZiSsOGDa9evaqUzc/PT3HhoGnTprFL7ynKyMgICAjYuHFjxT9OBX0QY+rXr3/v3j15H6GnT5+uWLFC7Yd89+5dly5d6taty+fzZ82adffuXUtLS8UMMTEx7u7u6enpOTk5SUlJVlZWai8DIYTUZocPH/7jjz8aNWrk7+/v6Og4atQoLS2tS5cuqWv/S5cuLT7Dzp07N2/e3L9/fycnJ3UdtNw+CITjxo1LSUmRB0JbW9sxY8ao/ZCbN29u0qTJ2bNnAQwZMmTz5s3sdD5ylpaWV69etbS0lHdqIoQQokZjxozp1KlTYmJivXr11Lvaz++//84OvSieu7t7mzZtKqnSsaw+6Czzww8/sCsCsqytrT///HO1H/LUqVNffvklu/3ll1+ePHlSKYO+vn7Lli1p2D4hhFQeR0fHrl27qn3NOzc3t+L7nbJat27dsWNHpe6smqK6+S0hIcHU1FRPT68yDvnmzRs7Ozt2287Oju3dW26PHz/etm2bYkrfvn3l+9csqVSq2PmIlB6duvKR/kfTBal52JNW8euyTCZTR3GIajKZrKxfbz6fX+KcNaoD4dq1a0eOHMkO+1C7/Px8ef8XLS2tvLy8cu+KYZi4uDg/Pz/FRFdX12rSrCgWiyvy6WozOnXlI5FI8vPzq8ldds2Sl5cnEAgqHsaq7QILHwGGYcpxZdDV1S1nIKxUNjY2KSkp7Pbbt2/r1q1b7l3xeLxBgwYtW7ZMTUVTM6lUqq+vr+lS1Eh06sqHDYSVVJfzcePz+QKBQGm8XTloa2urpTykMB6Pp6urWxlXBg3cOXbt2vX69evs9vXr17t27cpuS6VSDc4+TgghpHbSwBPhzJkzu3TpYmNjw+Pxdu7ceefOHTbdxMTk5MmT7EwECxcuZAd4/vTTT+w86FVfTkIIIbWBBgJh69at79y5s3//fgC3b99u06YNm75q1aqmTZuy22ZmZiYmJqtXr6764hFCCKlVNDNpi7Oz87p165QSZ8yYId8uZgo7Qgiptpo2bfr9999XtxXYPw6ZmZlFzURWQaoD4bRp06pJx8uPh1SKtDR8OIcOIeQj06lTp8jIyBoziCI0FCdP4vVreHriyy9Rrv7G2dnZVTNZKI/HMzU1rYw9qw6EpZkXgJSBnx+2bcPbtzA3x/jx+OQTTReIEFJZasy65TExWLcOYjEAXLoEsRjffVeO3WhpaRkaGqq5bFVLdfy/ePGifBLV9+/fT5o0qXXr1hMmTEhPT6/Csn0sgoPx0094+xYAUlPx22+4dq1SDiQWIzAQly7h/n0kJlbKIQghHweZDGvXclGQdeMGAgI0VyBNUv1E6O3tvXjxYi8vLwCLFi3av39/v379/v333/T09BMnTlRtCWu43FysWwe2noTHA8OAYbBtG1q3hnorn+/cwfbtyMgoSLGzw8CB6NULtHwHIdVcZiZu3kRYGIyM0LMnFKa6rCy3buH1awDQ0YGTE/z9AWDfPvz2W6UfuvpRcYnMzMx88+ZNx44dAUgkkr/++mvu3LkrV668e/eup6dnWlqafFZuUrJ//wU7e4CJCVatwpo1iI5Gbi527MDixWo7yoUL2LJFOTE2Flu24NIl/PADKjBrASFE/WJjERaGrCzo6CAmBjduQCTiXrp4Ed98g759K/HoMhmOHOG2hw1Dr16YPBl5eXj5EkFBaN1aDYeIjcWxY8jIgJsb+vRBhWcqqFSqAyEAtk3S19c3LS1tyJAhANzc3GQyWXR0dG0JhA8e4MgRGBrCw6OcX0qxGP8t/Yxx49CgAaZPx9y5YBj4+uLVK6hlutvQUGzfzm1bWKBdO6SmIiQEubkAEBmJefPw44+wt1fDsSoiNxcJCcjIAJ8PY2PUqQNNr8ZJiAa8e4fff8eTJ0VmkEqxZQvq1VNPQFLp9m3ExwOAkRE++wz6+ujZE+fPA8C5c2o4bmAgli/n6l39/fH4MRYvrs5VUypKZmVlJRQKQ0JC7O3tjx07Zm5u3q5dOwAZGRmoPRMI/f03Dh7ktgMDoaNTjh4ugvv3wbaqWllxb2/WDF264O5dMAyOH8ecORUtp0yGrVvBzkLbpAlWrgQ7vVZuLs6dw+HDEIuRng4fH6xbh5xNAPIAACAASURBVFJMCa9+aWm4ehX37yMyEkozB1lZwckJbm5wc0Pl9IompHqJjsaSJUhLU/GSnR0GDMC1a3jxAgyD9euxdWul/C4YBkePcttsFATw6ae4cAEMg0ePkJJSof7tKSlYvfqD1scnT7B5M2bNqkChK5eKQCgUCgcNGuTt7T1gwIC//vpr3Lhx7IpIT58+FQqFDRo0qPJCVrkrVwqiIGv7drRrhzL23BXKO8V8+mnB3dDQobh7FwDu3YO3NyrYwezqVbx6BQC6uli4EPJJJnV1MWwYnJywfDmys/HuHX7+GatXV+lNWXo6jhzB5cvIz1ed4e1bvH2LGzegqwtPTwwciIYNq654hFSx2FgsWsQ15PP56NgR1tbIzYWpKZyd4eQEHg+dOmHGDGRkICUFhw/jq6/UX4zr1xEbCwD6+vj0Uy7Rzg7Oznj2DFIpLlxARVai3bULmZkAYG6OLl1w9iwAXLuGli3Ru3eZ9yaR4NkziMVo3hyVNjpT9WVxx44ds2fPvn///rBhw1atWsUmHj9+vFu3bjW9m2zJ/Pzwxx/cdtu2ePsW8fHIzsblyxgxogz7iY3lh4dDKIRQiB49CtIdHdGiBUJDIZHg+nUMGVL+ospkOH6c2x4+XMVNXIsWWLgQy5ZBIkF4OPbvx4QJ5T9c6TEM/v0XBw4UNHsAEAhgawszMzAM0tORmFgQIHNzcekSLl+Gmxv+97+q6ClAapbMTGRkIDsbOTkFiVpaMDSEiUlZ71A1IykJS5dyUdDAAIsWqa6BNDfHxIlYvx4AzpyBlxfUu6icSIQDB7jtwYOheD3/9FM8ewYAly7hiy9Qvsq/oCDcuwcAPB7mzYOTE0Qirp/81q2wtET79mXYW0QE1q8Hu1SftjZGjsTQoeUpVUlUB0Jzc/M///xTKXHHjh2VUYLq5elTrF7N1TQ2boyFC+Hnh7VrAeDKFQwfjpKW8yjw38TicHdXfuzr3Ruhodw+KxII79//oKJfpTZtMH48du0CgFOn0L492rYt/xFLIzMTa9fi6dOClBYtMGAAOnSA4qoIUimiouDvj1u3uPtTtunU1xcdOvA//xxOTpVbTlINMQwSE/HmDd68QXw8EhLw9i1SUoqsVGDp6MDWFg0aoEkTODmhceMy/E6rRnIyFi3i+s3p6+PHH4u72+veHZcvIzgYEgm2bMGqVer8OLt24d07ADA3V774uLnBygpv3yIjA5cvFzwslom8Lu2TT7if8JQpePUKUVGQSPDjj5gwAZ9+WqpPFBODZcuQlcX9KRZj3z5oa2PgwPIUrFjVt/VSA16+xKpVXNW2jQ2WLYOeHtzdYWSEzEwkJiI4uLTNyAyDW7e4bcXHQVbXrtixAzk5iI1FVBTKPX3Bv/9yGwMGFNeW8NlnCAiAnx8YBr/9hk2bKlofW4yEBCxbhoQE7k87O0ycCBcXFTkFAjRpgiZN8MUXCA3FqVN48IBrRPT11XnwAL17Y/RomovnI5edjagovHqF16/x+jViYlCOdSjz8vDqFV694n50RkZwc0PXrmjXrlp00EhKwqJFSEoCAG1tLF5cQp0Hj4cpUzBzJiQSBAfjzBkMGqSekty9iytXuO3Jk5UvGnw+hgzhet6dOFGerp7PniEkBAC0tDB6NJeoo4MlSzB3LlJSIJFgxw5ER2PatBJ2JZFg9WouChoaok4drg1o9244OZX/mlkEgY+Pj3r3WBpSqTQyMpLP5xezcNqbN28yMjKKn6Ph5s2bPB6ve/fuKl5jGFy6hEOHcOUKDAxQv34JZRKLsXBhQd+WVau4S7BAgORkvHgBAPr6qq/phT1/jjNnZDIZ38wMU6YoT1wkFCI2lhvEo6+Pdu1KtU8lsbHYu5fb2/ffo5gl6Hg8tG2LGzeQm4ucHMTEwNOzUm6ZY2OxYAGSk7mDDhuGH34o+cwDqFMHHh7o2hVZWYiJASCTyfjR0bhwAWIxmjWrFpezmkAmk8lksoovqldZGAZJSQgKwp07OHMGf/6JP//EtWvw90dUFFJTUdTi4/r6sLJC3bqws4ONDfefhQV0dSGTfdAvA4BYzAXFixfx/j1sbUvTP1kikbBLEqrjcypISCj4UWhrY+HCUlXJmJggPx/PnwNAUBDat1dDT7e3b+Hjwz1be3riiy9U5LG3x+XLyM2FSAQDA7RoUZodi8VirhPl5s1cvO/bF56eBTn09eHhgdBQ7mE0MhI6OmjZsridnj7N3dbo6WH1agwfjmfP8O4dGAZv3sDLqzQFKz0NXF+Cg4MHDhxoYGAQHx8/f/78efPmKWXIyckZNmxYYGAgj8dzcnI6ceJEmRcazcnBzz8X1M4FBGDQIEyaVNxb/v6bm43F0BDLl38w2r1TJ+7Z69EjfP11qQogfxzs2lX1RdzTEzduAMDt2xg/vjxh6eJFbsPdveQ2ZBMTzJoFHx8wDB4/xoEDGDu2zEcs3ps3WLSI6w6no4O5c9GxY9n2YGeHOXMwbBj278eDBwAgFuPoUVy9itGj4eVV7eq7SIlSUvDmDWJiuDu/6OgPGvlUMjNDgwaoXx/16qFuXVhbw8oKOjrFvSU7m6tcCQtDQABSU7n0jAwcP46TJ9G1K0aM0EBXLDYKsld/NgqW8k4awJdf4ulTvHiB/Hz8/DM2boSRUflLwjD4/Xeuzb5uXXz7reps2tr44gvuofDoUfTsCWPj0h4iMpKbmEYgUNGSZ2GB1auxaRN33TtyBF5eRVZN5eXh2DFue9QobpjZrFmYPp17Svbzg5tbaQtWChoIhLNmzfrqq6+WLl0aGRnZtm3boUOHNm7cWDHDzp07U1NTo6KiAHzyySfbtm2bPXt2GQ6QmopVqxAe/kHi6dOwti6ycjkrC2fOcNsTJig/xDg5wcAA2dl4+7ZUg/8kEty/z21366Y6T9u2MDHh+oaFhJS5PSw/n/s+AaUd49i+PYYP57pNHzsGc/NytgGoFB9fEAX19bFsWQm3e8Wwt8fSpXmPHgn//pt7EE9NxaZNOHcOEybA2VltZSZqlJ+PlBQkJyMpCYmJSEhAQgLi4koOe1paaNgQDg5wcIC9Pezty3O5NzBA8+Zo3hz9+4NhEBmJe/dw8ybXJieT4fZt3LkDDw+MGQMbm/J8wHJITcXixVwU1NXFkiX4b8m5UhEKMW8eZs9GVhaSk7FxIxYtKv+94L17XEcYPh/ff49iFnnv2xf//os3b5CVhYMHiwyZhZ0+zW107ap62iyhEDNm4PVrvHqF3FycOoVx41Tv6to1rt9p3boFl6n69dGvH9cH9e+/VQdChsG1azh5Eu/fw9ER//sfmjUrTdmrOhAmJSXduHHj0KFDABo3buzl5XXkyJFFixYp5jl8+PCkSZPY6p1JkyZt2bKlmECoLxLh6lXcuoXoaEilMDFBcjI3lpzHw/DhiInBw4cAsHcvnJ2hcvjHxYvcWxo1UvHQLRTC1ZV7yPP1LTkQPnuG9+8BMJaWRdYtCATo0oUbwXr7dpkD4aNH3BfF2roMv67Ro/H6NXx9AWDHDujqqqeGISEBixZxt+F6evDxKWWNSjFkLVti3TrcuIH9+7lLSVQUFi+GiwvGjlV7C0Gly85Gdjby8pCXB5EIMhny85Ubw/LywDCq23q1tQu68AmFBXl0dLhWHB6Pq/2TSMDjFVdPXiYMg+xsiMUQi5GVBZEIIhGysrg+nOnpeP8e794hNRWln4XYxIQLe+x/dnZQb20kjwdHRzg6YuxYPH6MM2e4AMAwuH0b9+9j4EB88UWlT+YgEsHHh5thWEcHy5ahVasy78TGBt99hx9/5Ib33boFlc1AJZJIsH8/t/3ZZyXEBqEQEyZgxQoAuHQJAweWqttqejo3KgzA4MHF7fx//wO70Prlyxg9WvW/Phvt2NIqZhg2jJscPDwcAQEqbov37sXJk9z248d48gSffVZCXSBbrhJzqFdMTIyhoaF8jSdHR8fo6GilPNHR0fJnRJUZFNnveH71WPx/f/GBTG0tI77AFDwe3N0R7wBeA6RnchfT0VvRv7/yXRXD4PhdZNsAQN32WHNPxWFeWSPSBgD+eIbX9Ur4kHfuIMoGgKRZM6HKvbGSrLh97gxB+u2yLYBy5QribQDAqK3qAheF74H3OVyLxcyj6PkO9Ur6OMXLzMTFixAJARsIhfDywpl3OHO35DcWKy8vT0dHB9BGk/EQP+d60AGIjMPRn+HggLZty1BpUwWkUrx/j8xMZGUhOxsiEXJykJPDBb+qwjAMwzB8+XdJKCz4XvF4Jfd9YBiuDUm+USq6QBGPWdra3PAG9j8zMy5IJwPJgO8b4E2pj1Iuhn3QwhUBAVzPZADhD/DHM7i4oFEjxUuBRCLh8XjqaSOUyXDtGuJzABvw+ejRA/+m49/y/ii0unOdzL8/gSFMeeYqe/EC9xnABtraiHfAL6UoSU57rke6974S5xIRi8XaYWEIswCAOnVwPBEoetJ/hkFCI66S9rvjsLVVzpCSglsSwAZaWggwxPMPS8t0RmQY997emYU+5gOlr2J7iXbRD78FigyEQUFBZ86ciY+Pl7AXoP9sl8/mVS6ZmZmKDX76+vqx8i/of7KysuR59PX1379/X9TeGIaJf2+alPVBYDM00tMyMpLZ2THxQsRHAeAJG/FT8yCTIUUky/FjPuyIyMvM5EczgD60tKQxQGxU4QPxpFJ+qiFkMrzLkelEMMX03WAYQUAypPoA8i30+TdV7E1O8N6UbeeXnQ1gSt2Tk5efzw/KAKMPHk+WpMMUewgVb9dpws8BsrMB4B9fWcuWTHn7VvDy8/nh4cgDoA+BQOboyIRmI7Rs5VFJKpUqXJKMeFauvPh4HttUDiAlCY8vM+bmjI0No6EpaXh5eRCJeCIRcnJ4ubkQi5XnzeEIgNL8EtWGAYquPivNInny73ZZvhU8HrS0GG1t6OhAW5vR0YGuLnR0uF+KGHgLvM0FEkraUeXg2/Ms6/DevOHJ++LH+jPGL5kGDZj/Wh9lMhmPx+Opox2aHx3NS0kH9MHjyeztmRd5eFGBH4XMXH6hYP7xlZV93mDB8zDk6gNg6teX3S/VnQdPYst/lwGGwbt3stznTLF1DFKJRDv0FcT6AGTG1iVekfh51ryUJADM1QhZg1zlV2NjeSn6ABhLS9ndGOWCiU347wzAMEjJkEmCmf/qeHliMT8khL3wMmZmTN26vPh4nljc2KOHrkzGL+kxQ/UFfdOmTbNmzdLW1ra2thaqtcOetbV1eno6wzDsFy41NdWmUJW9tbV12n9TEKnMIMfj8Zwck5q6uKBNGzg5QUsLIhGEQhWdR65p4fJlADDIxndzP6g7+vtvMG8BwMMDnxZ977MjEpGRANDXqLhuIIGByEwAACsr0ZQe+sXUxQO4lMcNN3Sqg7Gl7iF97RpykgCgSRNMKvtMDQAyO+CPP7gmvfoGpak6UCEvD1u3okECAGhp4auv8GFbb0WIRCIVpy4pCZcuISTkv5CThPwwOLaAh0dVVJaKRIiORkwMoqMRF4e8XAgAI6A0TVq6umyE4P4vEEAoVL6119ICj6fcAZKVnw/5/ahUWpBHLObSGYat22cAJi+Pr8ZVYfX0IBBAWxt6etyn0NODvj709WFkBENDGBnB2BiGhuVb07VKMQwCA/Hvv/8t0vIWsmi4f4Lu3SEQiMViPp+vhsvdhQt4HwJ2PmYvL/TqVdEdAvA3xd9/A4Due8weVFwLX2GBgXgfAwB6elgwuIRuR4oOpCA4GADaNsCwfsVkzHvyREf0BgCMjLDgs5LruqOjuUUCDEVYOOaDKjqZDCtXwiQLACYPUf27PvyOq+5uYoHx47nEPXuQy114MWMM9+PKybF0sC4xCkJlIJRKpQsWLBg1atSWLVuMKtJPSZVGjRrp6uo+ffq0ffv2AB4+fDit0ICStm3bPnz4sG/fvmyGdsWOLrg3sqvXsmUlH7jDKLxhV+nLQvSdgku/SISNvjDPBYCv+6JR0RPIpXXEjgAASH2GrsOLzHZtL8yzAOCLQZmd6pVwAhsNQMBZMAySn6DZZNSpU/IHYRjsvcsdYoIXupZ3xjv76Zg/HzIZ3j0F/w06dy7b2xkGP/2EvBcwB4RCLJ5Thu5wpZCZmanq1DXAUDdERODQoYI5ixN9ccwX9vZcj231znz07h2eP8fz5wgORmxswTOffqHHPIEA1taoWxc2NqhTBxYWsLCAiQlMTGBkVGVBQiKR5OfnF1S65OYWRFCZ7IOJflSStzUCaj6T1YRHQ0zshcOHcfo0N1Tj8QkkP8HUqbkODgKBoEIjTxgGe/Yg8BzY+/CePTFzgnq6Oneuj7DLiI0FspDkV7b5z05s4C4X//sUPcsyZ5PlUMx9CAAxd9F6YjGDj8UnN2rLD+FZioUEutjh4g6kpwNZsJV8cAMdFATtRJgDFhYYU8Qor4YjMe0+ZDIk+cFsKJyccPMmkp/AHODxsPpbNCvzHbmKQPju3TuRSDRz5ky1R0EAenp6EydOnDlz5tq1a69fv/7mzZvhw4cDePjw4eTJkwMCAgBMmzbt888/d3Fx4fP5GzZsOCqfH7YitLXx1VdcI+2//2LAAG5lonv3uG4yDg4lPFV06YKdO8EwCA5GWhpULsGRlsaN2eDxVIyjL8zWFq1bIzAQEglOnYK3d8lv8ffnWuCNjdGpU8n5i8LO9sI2Su/diw4dyjZWb/9+rtMNj4fp09UbBUvQtCl8fBARgaNH4evLBafXr7FtG3bvhosLunSBi0s5+5rLZIiJQVgYQkMRElLc+sZmZnB05Hp8NGyIunWr42BHpXrjatWqqim6uvjqK3Tvjs2bEREBANHR+OEHwSefYNy48s9mmZuLDRu42cUAdOyIadPUNuCHz8fIkfjlFwA4dw6DB5f2680OwACgo1PmXuLNm6NZM4SHIz8fV68WObdZVBQ/JISbS7KUPdh5PLRrx/V79/f/IBDK+9t36lTk2bOzKxh+tmkTpk/Htm3cS/37l7KbqBIVP11LS8v69evHxsa6urqWY48l+vnnn1evXv3DDz/Ur1//xo0bbA2Yqalp5/8eSjw9PXfu3LllyxYA27dv71GaiFIanTvDyQnPn0Miwb59WLAAAFdfCqBnzxLebm6OVq0QFMS1hA8bpiLPpUvcbWarVrCy4jp2Fm/oUAQGcu8dOLDkvt3y2WR69qzoEl8jR+LmTW7SnEuXMGBAad9440bBHKfDhpUq5Ktd06ZYvBhv3uD0ady8yd3N5Ofj4UM8fMh1HWzZEk2bokED2NoWOXFiaioSExEbi+hoREUhMpLbVWFCIRo3RosWaNECTZvSlDc1m4MD1q7lZsTNyQHDCK5exaNHGDcOffqU+Qk+Ohq//FLQH6dzZ8yZo+Yboy5d0KABYmIgEuHIkVLdNAP46y9uo1ev8swnNWAANw7t0iV8/rnqyCQf8NelSxlG/SsGwuH/VbAxDDeAGCihjmrcOPj6Ijsb8fHclRyArW1BTWkZ8RhVLfynTp1asGDBkSNHnKv3sC0fHx8ej7esNFWjrIgIzJnDPUP4+EBHhzuJQiH27Sv5i3L9Ord8s4UFdu1S/qLn52PiRK7hbe5cdOtWRP3ehxgGc+Zwd6atW2PFiuJ+P7GxmDoVDAM+H9u2qWG53ZMnsWcPAJiZcQMqSvTsGZYv5yrcOnTA4sWVMc69VKdOLjsbt27h+nXlwaOKTExgbFzQQCKRICsL6en4sC+YMl1dNG8OJyc4OaFp0zK0r2iIctUoKVFKCrZtw6NHBZ1l7OwwZgzc3Uv1xWYYnD+PPXsKGm4HDcLEiZUy+cPDh1i5EgCEQqxbV3K7+N273EOktjZ27CjP3DRiMcaP527of/xRxZw4MTGYNk2Sny/U0sJvv5Whl0B6OsaOBcNAKMRff3GtnmFhmDsXAExMsH9/Cbcjt25h3bqC1goDA/z0ExwdS/3ZPqD6mtu/f/+TJ0+2bdvWyspKabmJSLbDSA3VtCl69sTVqwCwaVNB9WaPHqW6XerWDX/+idRUvHuHs2eVp6w9d46LgpaWZWhyY+cVnDMHUimCgvDzz/juuyIHOR07xv3Dd+yonkXnBwzAmTNISUFaGo4dK7nt4dkz/PQTFzzs7fH999VithcDA/Tvj/79kZCAe/fg64uICOXJujIy/usiURJzczRvjpYt0bw5HB3VPMqNVDeWlli8GL6+zLZtPLbRITYWq1ahYUMMGgQPj+LuDsPCsGcPN7YBgK4uvv22HAuXlpa7O9q04VpSVq/GTz+pHrfOys7Gzp3c9oAB5ZyhTVsbn3zCTTZy4YKKQMi2FgFwcytbXzlTUzg64sULbpUl9oIprxd1dy/5odzTE7q62LwZ79/D3h7ffVeRmYNUB0Jvb+/9+/e7uro2a9bM4CNbRnz8eG40emoqNwZcKFQ97V5hQiGGDMHu3QBw8CBMTdGpE/c7efkShw5x2YYMKVutiKMjvvySm7Xd1xfTpmHaNBWtbq9e4eZNbvvzz8uw/2Joa2PsWG7Nl5Mn0aVLcbeZ16/j99+5KFinDpYtK1vvtSpQty6GDcOwYRCJ8Pw5IiIQFYXYWCQnF/nkZ2QEGxtu7QIHBzRuXHlrnpHqq0OH/ObNtc6fF5w8yXUpio7Gpk3YsQOurnB2hqMj6tSBQACxGPHxCAvD/ftc8xvLwQFz56p5yaTCpk7F7NkQiZCQgJkzMXQoPvtMRbU/O70+e30zNy/t9U2lvn1x9qzqBXuvXi2YraYc6xe6uHAn8PFjdO4MhiloYS3lg0THjmWex7EIKqpGMzMzTUxMVq1aNX/+fLUco/KUuWqUFRyMZcu4qgweDxMnlmFyd4kE8+Z98APQ1YWBAdLSwPZZt7fHb7+xgbBs9XsHDhQsG83j4dNPMWFCQUBVPG7Hjli8uLS7LRHD4IcfuLtaKyssWQJ7e+U8+fnYu7dguoc6dbBypXoeSYtQtlNXIoZBWhqysgrqrwQCGBjA1LSci65VV1Q1Wm65ubkCgUArJwcnTuD8+ZInh5MTCjF0KL74oqJt9qXk64uffy64sbOywrx5yj1E9u7FiRMAwONh0aKKRotFi7h+DAMHFky2HB6OhQvZH1Re3746U6eWebfh4ZgzBwDMzLB3L54/BzvFmJER9u+v4q5nKlafyMzMXLNmzZo1a+pW5pVOLYpbfaIYVlZo3RoSCXR1MWYM+hU3REYZn482bfD4ccEqWRIJ29gOAIaGWLRIXgshFot1St+q5OyMRo0QGMhNRBIRgadP0aYNjIwgk+H33/H4MQBoaWHhQnV2/+Px0KoVrl6FRILsbFy8iPv38fw54uO5ubUCAvDrr/Dz4/I7OOCnn2BtrbYCqFK2U1cidtYxExOYm3P/mZnBwODjq/as7qtPVGPc6hP6+mjbFv37w9S05KnjtLXRvTt++AFdulTdd6lePbRti5AQrukuOxs3bqBhw4IZkv/5B0eOcNtDhqhh9T5zc65jy+vX6NYNRkYIDsaKFVy3soYNc6dN0y5H5ZC5OS5fRk4OcnPRpAlu3uQW5OndGx06VLTMZaS6s0z79u29vb2nTJlSxaUpq3I+EVZcdjb++Qe+vkhM5B4yBAI4OeHbbxVnLCvPY83799i8uaDrlJYWXFwQH88uTgQAkyapbXEyRU+eYPXqIjtMynXujNmzS9WnpmLU/ERYa9ATYblxT4RK9xCxsfD3R2goYmKQns517rC0hL092rRBhw6VPmdpUaRSXLmC/fu5cCgUYuZMeHri778Leop26oT589UzhnXuXISFAYC9Pdq2xblz3COpiQnWrs0yMjIs36jT/fu5TqdNm+LVK25Wvw0b1Dg1RympDoT3798fN27c7Nmze/fubfFhK6uZyvFzGqKxQKiInVXSyKhwJVv5r+anT2PfPhXNWn36YOrUyuqfEh2NAwfw5Inq5jR9fYwbh379qqZ3DAXC8qFAWG6qA2E1l5SEZcsQF8f9aWnJLbgBwNkZS5eqreY/MhJz5ypPP2thgRUr0KBBVlZWOQNhfDy++eaDuQlbteJGe1ct1YHQxsYmiV1fsRCV+TWlWgTColXoah4Vhe3bueWeAejq4n//K3Iojxrl5iI6GtHRiIzE69fIyICFBZyd0adPJa5rXwgFwvKhQFhuNTIQAkhNxbJlXKWiXNu2WLRIzTU3V65g82bIZ+9r2RLz5rHNQOUPhAA2buS68QPg87FhQ8nL+1QC1Q2Sa9euzSl9WzGpDI0a4ZdfuIBkZIQWLapoyitdXTRrVr7ZGQghVc3cHKtXY8cO3LwJmQxaWhgyBF9+qf7OJr16oXlzXLwIhkGrVsXN/FImU6YgLg6hoTAyKliDt8qpfiKsKT7mJ8LajU5d+dATYbnV1CdCObZrj7V11TdbVuiJEIBUithY1K+vwUkKq9/siIQQQsqK7Q5dEwkEKoZsVa2CDkWPHz/eJp+6tFjz589PkTfJEkIIITVZQSAMCgo6JJ8bpVhr165NZecsIIQQQmq4D6pGIyIixo0bV+J7KtisKJPJ5s2bt2fPHoZhJkyYsHbtWqWFE1NTU318fJ48eZKYmOjr62tRvlnyCCGEkFIoCIRmZmYWFhaP2elLitWiRYuKzPpx6NChs2fPhoaG8vn8bt26OTs7jx07VjFDfn6+paXl1KlTR40aJVWaOpkQQghRq4JAOHjw4MGDB1fBIffu3fvtt99aW1sDmDZt2t69e5UCobW19dKlS9+9e1cFhSGEEFLLqWP2nTKKiIho3bo1u92qVasXihNYl11OTk7ah/KVpj8ghBBCilYpwycCAgJu376tlMjn86dOnQogLS1NPujEyMioIk9+DMNs3Lhx+/btiol//vnnJ5W3JFhZZMkn5iZlRKeufNhxhJLiVxsmqtT4cYSak52dXZ3Ho+vr6wtKmhK9UgJhRkZGVFSUUqK8KJaWlu/fv5fntCpmbcmS8Hi8+fPnV9sB9QBoVHi50akr30Fs5wAAIABJREFUBxpQX25aWloUCMuHx+NVaEB9NVApgbBbt27dunUr6tXmzZsHBAR4eXkBCAwMbEazeRFCCNEcDbQRTpo0afPmzS9fvoyKitq0adOkSZPY9C+//DIgIIDd9vf3Z7cDAgKePHlS9YUkhBBSS2hgirVhw4aFh4d7eXkxDOPt7T1ixAg2PTExMY9dkxaYMmWKVCp1cXFZsGABj8fzk68KSwghhKiV6kAYHR1d1AC+Ro0aVfyoixYtWrRokVLiDXYRZADAo0ePKn4UQgghpESqA2HHjh1rxHqEhBBCSAWpDoQ7d+7Mzc2V/5mSknLz5s2rV6+uWrWqqgpGCCGEVAXVgXDgwIFKKVOmTPnxxx+PHTs2efLkyi8VIYQQUkXK0Gt07Nix165de/XqVeWVhhBCCKliZQiE2dnZ8v8TQgghH4fS9hqNiopasmSJsbFx06ZNq6RghBBCSFUoQ69RKyurffv2aWtrV36pCCGEkCpSql6jPB7Pxsamffv2+vr6VVUwQgghpCqUttcoIYQQ8lHSwFyjhBBCSPVBgZAQQkitRoGQEEJIraaZQHjixAkPDw8XF5f169cXnrw0IiJi+vTpnTp16tSp0+LFi2nkIiGEkMqjgWWYnj59OmHChMOHD1tbW3/xxRfm5ubjx49XzPDkyZM6deqsX78ewOzZs+Pi4vbu3Vv15SSEEFIbaCAQbtu2bcyYMf369QOwaNGiLVu2KAXCL7/8Ur69bNky+cq9hBBCiNppoGo0KCjIzc2N3XZzcwsKCipmaacnT540b968qopGCCGk1qmUJ8K3b98GBwcXTvfw8NDS0kpOTjY1NWVTzMzMcnNz379/b2JiUji/v7//2rVrr1+/XtSBGIbZuHHjvn37FBO3bt3atWvXCn0ANcnOzubxeJouRY1Ep658JBJJfn5+Uatqk2Lk5uYKBAItLS1NF6TmqebdOPT19fn8Eh75KiUQhoaG/vLLL4XTXV1dtbS0jI2Ns7Ky2JSsrCyhUGhoaFg48/PnzwcMGLBnzx4XF5eiDsTj8caNGzdjxgzFRBsbm2oyAw7DMCo/GikRnbryYQOhnp6epgtS8wiFQgqE5VbTf62VEgg9PT09PT2LetXBweHFixfsdkRERIMGDQQCgVKe8PDwPn36rFu3bujQocUfy8zMrFGjRhUsMCGEkFpLA22Eo0eP3r9/f3p6ulQq3bx58+jRo9n0devWPXv2DMDLly979uz5/fff9+vXLy0tLS0treoLSQghpJbQQCAcNGhQ//79HRwcbG1t+Xz+3Llz2fQDBw6Eh4cDOHnypEgk+vHHHxs3bty4cWNHR8eqLyQhhJBagldMj81KlZ2dnZeXZ25uXpGd+Pj48Hi8ZcuWqatU6pWZmWlkZKTpUtRIdOrKh9oIy406y5RbVlYWtRGWk4GBgYGBgaaOTgghhLBorlFCCCG1GgVCQgghtRoFQkIIIbUaBUJCCCG1GgVCQgghtRoFQkIIIbUaBUJCCCG1GgVCQgghtRoFQkIIIbUaBUJCCCG1GgVCQgghtRoFQkIIIbUaBUJCCCG1GgVCQgghtRoFwsqSmpo6aNAgTZeiRvL3958xY4amS1EjHT9+/Ndff9V0KWqkDRs2HD16VNOlqJG+++67R48eaboUFaKxhXnVYtu2bZs2bapXr56mC6JCfn5+UFBQ+/btNV2QmiczMzM2NrZly5aaLkjNk5SUJBKJHBwcNF2Qmuf169e6uro2NjaaLkjNExoaamtra2JioumCqLZt27bGjRsXn6dmB0IAV69e1XQRCCGEVFMdO3Y0MjIqPk+ND4SEEEJIRVAbISGEkFqNAiEhhJBajQIhIYSQWo0CISGEkFqNAqHapKam+vj49OjRw93d/dtvv01ISJC/dP78+R49enTo0GHNmjXy3knZ2dmzZ892cXEZOHBgQECAhkpdLchksv3798+cOXPEiBEvX75UfGn37t2dO3f28PA4ePCgPDExMXHs2LEuLi6jRo2Ki4ur8vJWUydPnvT09HR3d9+0aZOmy1IdJSQkbNq06auvvpo8ebJielZW1qxZs1xcXD777LOgoCB5+q1bt3r37u3m5ubj4yORSKq8vNXI7du3x48f7+7u7uXltWvXLnl6bm7uvHnzXF1d+/fv7+fnJ09/9OhRv379XF1dFyxYkJeXp4kilxFD1MTX1/ebb765cuXK48ePhw8f3rZtWzY9NDTUyMjo+PHjjx8/bt68+ZYtW9j0b775pk+fPsHBwevXr7e2ts7OztZc2TVMLBYPHDjQx8dHV1f30aNH8vRz587Z2Njcvn372rVrlpaWN27cYNM9PT2//vrrkJCQGTNmuLm5aabQ1Yy/v7+Jicm5c+cePXrk4OBw4MABTZeo2rl27dqYMWO+/vprW1tbxXRvb+/+/fsHBwf/+uuvNjY2IpGIYZi4uDhjY+M///zz2bNnrq6uK1eu1FCpq4WlS5f+/vvvfn5+p0+ftrGx2blzJ5v+/fffe3p6BgUFbdmyxdzcPD09nWGY1NRUMzOzrVu3BgUFeXh4zJs3T6NlLxUKhJWCfRxMSkpiGOa7774bP348m37kyBEnJyeGYTIyMvT19Z8/f86mu7q6/vnnn5oqbfVhZGSkGAj79evHPkMzDLNs2bLhw4czDBMYGKivr8/eN4jFYlNTU8W31Fre3t7Tp09nt3ft2uXu7q7Z8lRb165dUwyE6enpenp64eHh7J/t2rVj7yF++umnQYMGsYmXL1+uV6+eTCar+tJWQ0uWLBk6dCjDMDk5Oaampr6+vmx6t27d2Lv8TZs2de/enU18+PChmZlZXl6epkpbSlQ1WimePn1qYWFhYWEBIDAwsEOHDmx6hw4dQkND8/PzIyMj+Xy+fPIUNze3Wl47qlJQUJCbmxu73aFDh8DAQDbRyclJX18fgJaWVtu2bdn0Wk7pa0bnpJRevHihra3dtGlT9k83Nzf21Cmdz7i4uHfv3mmslNXJ06dPmzVrBiAmJiYzM9PFxYVN79ChA3sRUzx1rq6uGRkZsbGxmiptKQk1XYAa5vHjx9nZ2UqJ9erVc3R0lP+ZnJw8ZcqUX3/9VSAQsH/KJx8yMzOTyWTJyclv3741NTWVv8XMzCwmJqbyi69Jt27dKpzYpEkTW1vbot6ieJbMzMySkpKUEhXTazmlr5lIJMrMzCxxQg1S+OuUmJiolG5sbCwQCJKSkiwtLTVTympj3759/v7++/fvB/D27VtjY2M+n3uaMjMzi4yMZNMbNWrEJgoEAmNj46SkpBInOdMsCoRls2XLlujoaKXEwYMHT58+nd1OS0vr3bv3qFGjxo8fz6YYGxuLRCJ2OysrC4CJiYmJiYk8kU1X/DV+lFasWFE4cebMmZ999llRb1E6dewpqoWnrjSUzpWWlpaBgYFmi1QjFPV1MjY2lt/y5uTkSKVS+pqdOnVq/vz5V65cMTMzA2BiYqL4VKDyF8owTHZ2dvU/dRQIy2bPnj3FvJqRkdGnT58ePXqsXLlSnmhvb//ixQt2+8WLF1ZWVgYGBg0bNszIyEhOTq5Tpw6b3rNnz0otucZdu3atrG9hT13nzp0BvHjxwt7enk18+fKlTCZjb0X/z959B0ZRpg0Af2Z7zZZsdjdl03uAFAiEEnoV7wQEUfBEQE+9E1E89EAQG3B6eIcNURD1rKDSQSAQQkICCYRUSC+bsj2b7X13vj+GL8YQqkAIeX9/7U5m3312sjvPzFvr6+vRHNNwxdcsNDS061IduYawsDC9Xt/R0UE0ZNTV1c2YMQMAIiIiuh9PJpMpkUj6MtC+dvjw4WefffbQoUODBw8mtshkMq/XK5fLw8LCAKCuro74U3h4eE1NDbFPc3MzjuMhISF9FfaN6utGyvuHxWLJzMxctmxZj0b1I0eOyGQyrVbr8/lmz569YsUKYvvkyZPXrl2L43hlZSWbzW5tbe2DoO8xPTrL/Pe//83IyHA6nTabLSUlheir5vF4QkNDf/jhBxzH9+/fL5FI7v2m+Lvg559/jo6ONhgMXq932rRp69at6+uI7lE9OsvgOD5hwoQ333wTx/Hy8nI2m93e3o7jeFFRkb+/P/GrXLJkyeLFi/sk2nvEsWPHxGLx2bNne2x/6KGHiBNabW0tl8utq6vDcbyqqsrPz494/OKLL86ZM+fuB3yzUCK8bY4cOSL4vfLychzHfT7fSy+9xOfzg4KCxo8fr9frif2rqqri4+PDw8MFAsFnn33Wp7H3vaFDh3Y/dC0tLTiO2+32OXPmBAQE+Pv7L1y40OVyETtnZ2cHBgZGRkZKJJIjR470aeD3Cq/X+8wzzwgEAolEMn36dLPZ3NcR3XOqqqq6f8fGjRtHbL906VJsbCzxS+waGIDj+BtvvMHn80NCQoYPH65QKPom6HvDvHnzuh+6adOmEdsbGhoGDx4cGhrK5/M3b97ctf+mTZv4fH5oaGhycnJTU1PfBH0z0OoTd4nFYrHb7URFaBccx5VKpb+/P51O76vA7n16vZ5EIvVoZvB4PBqNRiwWUyioev83JpPJ5XKhPh0362q/RJvNZjKZ0CKF16ZQKIRCIYPB6L7R4XDo9fprdIW7p6BEiCAIggxoqDkdQRAEGdBQIkQQBEEGNJQIEQRBkAENJUIEQRBkQEOJEEEQBBnQUCJEEARBBjQ0BgtB+pm8vDxiduOgoKCpU6cCgFar3bNnz8yZM4ODg/94+QcPHtTpdACQkJAwYsSIP14ggtzjUCJEkH5m69ate/fuTU1NTU9PJxJhc3PzM888k5WVdVsS4b59+6qqqs6dO/fUU0+hRIgMBCgRIkj/ExUVdfr06TtU+LZt2wCgH0yUjCC3CWojRJCBgpiXzuv1dm1xuVydnZ19GBKC3AtQIkSQPub1emfMmDFkyBCj0Uhs0ev1CQkJDz30kM/nu4UCOzs7J0+enJKS0tTUBAAzZsx47LHHtm7dKvl/u3btcrlcL7zwgp+fn1AoTEpKunjx4u38SAjSr6BEiCB9jEwmf/755wqF4qmnngIAHMeXLl2qVqs//PDDW1hTsLm5efTo0RqN5uDBg8RKjWazOTs7e8eOHd99911+fv6QIUMWLVq0dOnSjo6O48ePHz582Gq1Llmy5PZ/MATpJ1AbIYL0PZlM9tVXX/35z3/eunWr3W7ft2/fnj17iPVOb0pFRcUDDzwQFxf3yy+/8Hi8ru1Wq/XAgQPE0rIffvjh4MGDL168eP78eSLRrlq16tlnn1UoFP1lrQAEub1QIkSQe8KDDz64bNmyl156yefzvfzyyw899NDNlnD06NGtW7c+/PDD27Zto1Kp3f+UkpLStcB6bGwsAEyZMqXrdpPY0tLSghIhMjChqlEEuVc8//zzTqeTRCKtWrXqFl6+fft2AFizZk2PLAgAAoGg6zGNRgOA7us7EltcLtctvCmC3AdQIkSQe4Lb7V60aFFoaCiNRnvhhRduoYRt27YNGjQoMzOzsrLytoeHIPcxlAgR5J6wZs2a8+fP//DDD9u3b//uu+++/PLLmy2Bz+cfP348MTFx0qRJZWVldyJIBLkvoUSIIH3vyJEjmzZtevfdd0eOHDlv3rynn376b3/7W3l5+c2Ww2azDxw4kJKSMn78+LNnz96JUBHk/oMSIYL0MbVavXjx4unTp7/44ovElg8//DAuLm7BggU2m+1mS2OxWAcOHBg/fvyUKVNOnjx5u4NFkPsQ6jWKIH1MIpEolcruWxgMRmlp6Y2XkJ6ejuN411MajbZnz56up1dOxtZ9ZwAYPXp0jy0IMqCgO0IE6X8qKiqoVOqMGTPuROEjR46kUqnt7e13onAEuQdh6EoQQfoXpVJJTMbGZrNlMtltL18ul9vtdgAQCARdow8R5D6GEiGCIAgyoKGqUQRBEGRAQ4kQQRAEGdBQIkQQBEEGNJQIEQRBkAENJUIEQRBkQEOJEEEQBBnQUCJEEARBBjSUCBEEQZABDSVCBEEQZEBDiRBBEAQZ0FAiRBAEQQY0lAgRBEGQAQ0lQgRBEGRAQ4kQQRAEGdBQIkQQBEEGtP6dCBUKhVKp7Osorsrr9fZ1CP0VOnS3Bsdxn8/X11H0Sz6fDy3Oemvug69c/06En3/++eeff97XUVyVzWbr6xD6K3Tobo3X63U6nX0dRb/kcrk8Hk9fR9Ev3Qe/1v6dCBEEQRDkD0KJEEEQBBnQKH0dAIIgyP3P6/Xm5ubel43fdrudyWTehTcik8ljx44lk8m3vWSUCBEEQe64CxcuzJ49Oz09va8Duf1wHMcw7C680blz544fPz5s2LDbXjJKhAiCIHec1+tNSEjIysrq60D6sYyMjDt0S43aCBEEQZABDSVCBEEQZEBDiRBBEAQZ0FAiRBAEQQY0lAgRBEGQAQ0lQgRBEGRAQ4kQQRAEGdBQIkQQBEEGNJQIEQRBkAENJUIEQRBkQEOJEEEQBBnQ+iYRarXaTz75ZNOmTfX19Vf+1efz5efnb968+YMPPqioqLj74SEIgtzH3G73uHHjmpubiac6nW7UqFFWq7VPg+pLfTDptk6nS0tLmzhxokQiGTZsWHZ2dlpaWvcdPvnkk61bt06ePBkA1q1bt2nTpqeeeurux4kgCHJHaa1aL343FmaScCQY/LZABJVKDQsL++abb9auXQsAP/zwQ0BAAJvNvguR3Jv6IBFu27YtOTn566+/BgAGg/Huu+/u3Lmz+w6PP/74888/T6zrkZqaumHDBpQIEQS5/7yX/57BYbgLb/TRAx8xKIzuWxYtWvTss8+uWbMGw7Cvv/569erVdyGMe1YfJMLjx48//PDDxOOZM2d+9NFHPXYQCARdj+l0OoWC1opCEOQ+9O+p/+6rt544caLX6y0oKODz+c3NzTNnzuyrSO4FfZBjFAqFVColHgcGBhoMBqvV2utducViefPNN1988cWrFYXjeFZWlsVi6b7xiSeeiI2Nvb0x3xqn00mj0fo6in4JHbpb4/F43G43iYQ6wd00p9NJJpN9Pt8dKt/tdt+hkm8NhmGPP/74119/zePxFi5cSKfT+zqiG+J2u51O5029hEajXXfd4D5IhBiG4ThOPCa+dr3+bp1O59y5c4cPH/7MM89coygmk9n9DhIA6HT6PXIiIJFI90gk/Q46dLeG9P/6OpD+504furuzhvtNWbRo0bBhwxgMxqFDh/o6lhuFYdid+B/1QSIMCgpSqVTEY5VKJRQKmUxmj31cLte8efP8/Px27Nhx7S9QZmbmPVu7TaVSqVRqX0fRL6FDd2uIHws6dLfA6/WSyeQ7d+juwSaeqKiopUuX2my2Ht0V72UUCuVO/I/64Mpx+vTp+/fvJx7v379/+vTpxOPa2lqDwQAAXq/3iSeeIJPJ33333T347UEQBLk/bNq0acuWLX0dRd/rg0S4dOnShoaGuXPn/v3vf//ss8/++c9/EtsfeOCBgwcPAsAHH3zw008/4Ti+cOHCRx55ZP78+Xc/SARBEGSA6IP7LYFAUFxcvHfvXpvNVlZWFhISQmzfvn070cll9uzZQ4YMufuBIQiCIANQ31Q88ni8RYsW9dg4fvx44kFERERERMTdjglB+o/GzkYSRgrjh3UfJY0gyK1BLXAI0p9orJpN+Zsa6htwHBeFit6Z+I6YLe7roBCkf0PdrBGk33B6nG+ferulqEX2pSzsizDsK2zzmc044H0dF3Lfam1tLS4uvtmhe/0OSoQI0m/8UPmD7rxOsl9C8pGADKwmVlNe02n56b6OC7mv7NmzZ9WqVQDwyiuvTJ069d133yX683fn8XhusLRZs2ZVVVXd7Kvust+qRn/55ZdXXnnlBl924sSJ8PDwOxIRgiC9sXvsWeeyJAckmBdLfTjVIrDUbq8V5gtzJ+VmhmX2dXTI/WPnzp2PPPIIAHz55ZdnzpyJjo7uscOGDRs+/vhjn8+3bdu2P/3pT9coSq1WX7hwIT4+HgBSU1ObmpqSk5N/+uknsfjeqs//LRGaTCabzfbggw9e9zVffPGFy+W6k1EhCNJTVkMWvZCOeTFyKvnx1Y+3Gdre3fUuTU+rLqp2jXbRyGhGOuQm2Gy21atXnzlzJjY2dubMmQqFYsWKFQDgdrtzcnK2bdv26KOPdnZ2vvTSS5GRkR988EH3165cuXL16tVHjhxZuHBhe3u7xWJZsWLFwoULN27ciOP4Sy+9NGvWLGLP/fv3P/jgg8Q8D0VFRSQSacmSJWvXrv3ss8/efPPN+Ph4YnTcV199pdVqV65cedcPw2W/6ywTExOzbdu2675mx44ddyweBEF6d/zScW4FFzDIfCITwzCZQEZPp/tO+Oil9BJVyYjgEX0dINKfLFu2TK/X79q1q66ubtGiRaNGjSK2Z2dnDxs2jMvlbtiwYe/eva+99lpwcHCP1xJzu0yfPp3NZldUVEgkkh9++AHDsM8++6yqquovf/lLY2NjQEAAAOzbt2/ZsmXdX/Xkk0/+7W9/A4DHHntszJgx8fHxLpfr1VdfPXv27F377Ff6LRGmpKQ8+eSTN/KatWvX+vv736mIEAS5QqupVVeik7glrjDX1NFTiY2DHhhUnl3OqeOUtZehRNgf7X1yr63DdhfeaN7OeVTWbzOTeb3eb7/9tqamJiwsLCws7LHHHpPL5cSf9u3b99BDDwFAZGQkhmGhoaFBQUHdizKbzY8++mh7e/v48eO5XC4xcbTX6/3ggw/4fH5cXFxsbGx5efmkSZMsFktRURExLi4vL+/pp5/m8/l//vOfiXJiY2Pfe++9BQsWOByOLVu29O2Qud8SYWpqampq6o285o033rhT4SAI0ptTzadYjSwACBkRwqRcnpt3SNyQ88LztA5abWUtDO/T+JBbMuurWX3yvh0dHW63OzQ0lHgaFhZGJEIcxw8dOvT6669f47X//e9/g4ODDx06tGXLlo8++igiIsJut7PZbD6fT+zA5XLNZjMAHD16dOLEiXQ6HcfxJUuW7NixY9SoUePGjYuMjCT2/Mtf/vLGG29IJJKuhfn6Cuo1iiD9QL48n9XEAoDRU0Z3bYwPiHcGOQFAV6Vzeu7zDu7IbeTv70+n05uamoinjY2NxIPi4uLg4OCuZfJ6VVBQQHQlSUpKGjZsGFEF2quum0uNRqPT6TIzM8lkclxc3IwZM4gd3nzzzaioKKPR+O23396Wz3XLrpUIS0pKZs+efddCQRCkV63G1o6qDrKd7BP6MlIyurazqWxuDBcAqO3UOn1d3wWI9DNkMvnJJ5984YUXqqqqDhw4sGvXLmJ7V+q6BpFI5Ha7XS7XK6+8co3uLV6v9/jx48SaCn5+fnQ63el0njt3LicnZ+HChQCQk5Ozffv2b7/99ueff16xYkV1dfXt+3w37XedZXbs2NF9nEdra+tdjwdBkJ7OtJ3hVHEAQJwh7tE7NHxwePPuZrqCXq2rHiQe1EcBIv3P5s2b33rrrWeeeSYhIeGpp55SKBQAsG/fvq6kCACpqalXrnn0+uuvP/300+++++4jjzwyd+5cAKDRaFc2q+Xl5SUlJRGLxTKZzLfffnv8+PEkEmnnzp0CgcDhcGzatOnrr78ODAwMDAzcuHHjpk2btm3b1lerNv4uEa5YsSI9Pb3rqdlsDgwMvBPv6nA4cnNzcRwfN24cg8HodR+lUqlQKJKTk9FKTMgAV9RcxKnhAED6zPQef0pISmigNVBN1Ia2Bkjsi+CQ/olMJq9fvx4AfD7ftGnT5syZ09raSqFQiDF/hIKCgitfGBsbe+rUqe5bpFJpbm5uj92ys7PnzJnT9fTpp59++umnu54yGAxirSHC0qVLly5d+sc+0B/yuxwjk8m+++67rqGOJSUlb7311m1/y46OjjFjxkilUhKJtHz58tOnT4tEou47tLS0jBw5srOz0263q9Xqe23oJYLcTWanub20XeqQuiSukWkje/w1QhDhFrnJCnJrbStM7ZMAkX5p79697733XkxMTFlZWWBg4OLFixkMxoULF25X+Xcid9w5v0uEK1eutNvtXU9lMtlzzz1329/y448/jo6OPnDgAADMnj37448/7tENVSQSHTt2LCAgQCKR3PZ3R5D+pVhZzGxiAgAvhcelc3v8NZwf7ha7GQqGsclo99ipgNamR27I3LlzU1NTFQpFUFAQMVLidpX8/vvvd/VH7S9+11nmiSeeCAsL63oqEommTr39F5l79+597LHHiMePPvronj17euzAYrGSkpLIZPJtf2sE6XcuKC8wG5kAkDiml6pPKpnqF+YHADQdrdnQfJdjQ/q1qKiozMzMqKio29syN3To0Gt0Jb039d78Vl1dHRQU5Ofndyfesq2tTSaTEY9DQ0Pb29v/SGmVlZU7d+7svoWod/0jZd4uXq/X6/X2dRT9Ejp0BBzw0spSoUHoYXjSh6X3ekwCowPboZ2mpdXr6iO5kejQ3RrioJFId2pEmc/nu0MlDyg+n+9mv94kEum6mb73RPj5558vWLBg2LBhN/V+N8jtdnf1f6FSqX9kgQ8cxy9evNjjGxYWFkZ0VepzLpfrvl++5A5Bh47Q0NngrnMDDr4IXwgnpNdjIouStUM7TUdr0DY4g5xut/vOnc3vY06nk0wm37l05XK5iElYkFuG4/gtnBkYDMYtJsI7SiqV6nQ64rFWq/0jHVMxDJs/f/66detuU2i3mdfrZbFYfR1Fv4QOHaGqqYqtYGMYFpYaxmaze90nJjQm3y+fYqJolVrWSJbb7WYymXc5zvsAiUQik8lXjha4XW7kdIxcG4ZhDAbjTpwZ+uDKccyYMdnZ2cTjEydOjBkzhniMqg4QpIfz7eeZbUwAGJIx5Gr7hPBCnCInAGgbtHcvMgS5j/TBHeHy5ctHjx5NDJ/Ytm1b1wAUPz+/PXv2TJkyBQBWr15ttVoB4J133mGz2Rs3brz7cSJI39Lb9fWN9WGmMJyJj04ffbXdxGwf6RVUAAAgAElEQVSxT+KDRnC0OywuCx2j380gEeQ+0Ad3hIMHD87Ly9NoNEql8tSpU8nJycT29evXx8bGEo8FAkFQUNC//vWv4ODgrrlcEWRAKWgtYNeyAcAvwe/KgRNdMMB4oTwAoOvo7eY/1PUMQQamvpm0JTk5+f333++xcfny5V2P+3CFRgS5R+TKc7kXuQAwaOp15k4TR4lVoKLpaG2mtki/yLsSHXJzJBKJTqeLiorq60BuPxzH707zZ3t7+9VmIvuDek+Er732GofDuRPvhyDIjajtqG2sbJRpZTgLnzJzyrV3Do0OVZKV1E5qm74NQu5OgMjNiYiIyMvLs9nuxuqDd5nNZrs7XdtoNFpIyB35fveeCNG6uwjSt3659AuvhAcAgeMCBezrDAcK5Ad6uB6qgapqVcFVe9UgfeweGd9821kslv5+49R7G+GuXbu6ZkTVaDQzZswQiUTTpk37g4Pf+ymn2Yn70AAg5O4pU5UV1hRyqjk4hv950Z+vu7+UI3Xz3ACga9Pd+egQ5H7TSyLEcXzZsmV6vZ54unLlytOnT8+fP7+xsXHRokV3N7y+Z2g27H1y77FXjjlNaHw3cjfY3LZPzn3iV+pH8pAkwyQJsQnXfYmUI3Xz3QBgUpvufIAIcr/ppWrUZDJpNBpifSmn07l79+5Vq1atXr26pKQkLS1Nq9X2u3nk/ojibcVel7ejpuP0u6cnrZ/U1+EAAKit6mJFsc1t49F5w4KGCZj3xDQ6yG2B4/hHhR+p9Krw0nAyiTz3mbk38io+g48JMADw6rxmlxkNqL9v4DherasuU5c5PU4+gz9YMjhScDc6Q7m8rgvKC2qLOl4UHyeKuwvv2Ld6SYREcy5R51tQUGCxWP70pz8BQFJSEgC0trYOnESoq9apy9U0Lg18oC5XG5oN/PA7OJbDZXFd/Oli5KRIojf8lWxu246SHcfqj+FwuaqWQqLMTpi9YPACCqkPOgBrrdqajhqtVevFvXwGP1IQGSGIwABNn3Hrfqn6Jb8xX3pASraRE4clxqTF3OALeYE8HHCqkaq2qMU8tHLZ/aDV2PpR4UdVuqruGyMFkY8nP54e1HNlytuosbPxvdPvdQ3FGRM6ZsXIFVTyVefccdvcZ7afwT34kMeHcKT9srGwl7OnWCym0+nnz5+PiIjYuXOnVColUiAxL9qAmvhKXaEGgPCx4RgJqzlQU/drXfpz1/n++XDfJe0lnU0XwAqQMWRX7qCr1tUerBVECWJnxpJpv1tho2RHSUNWQ+PxxinvTvEL6TnjeYetY13OOrlB3n2jx+f56eJPdR11r419jUG5Ix2Lr+T2uk80nThaf7ReX9/jT3wGPzMsc0bMDJlfL58dubYaXc235d+KTorYjexAaeCc1+Zc/zX/Txgs7IAOqpGqtqoHw+A7FyRyd5xTnPv36X/bPfYe2xs7G9/KeWts2NgXRrxAp9z+yRNajC1rsteYneauLadbTgPAK6Nf6XWMhM/jy12ba1VYAUBRrJjxwQy2uPe5AG+Q2+au+L5CVaaK+1Nc1NS7NNqkl0RIJpMXLlz49NNPf/3110ePHn355ZeJOXyLiopoNFr3dZrue7oqHQAEJAYIIgQ1B2rkp+SpS1Ip9Kvee51XnP/03Kcaq4Z4GsIOeXXcq+H88K4dTK2mk2+cdFvdzaea3Tb3kIW/9fDrqOtoPN4IAE6Ts+x/ZZmrM7uXbHaZ12avbTW1Ek9TpClRwqhKTWWNrgYASlWl/zr9r7Vj15JJd3ztqtMtp7+48IXO1nunDIPDcKDmwMHagyNDRj6R/ESwX/Cdjue+4fF5Np/dzKhn8Mp4HDZn8QeL+WE3Uf0gDhV3QAfFSFFb1XcuyH5Kb9e7vC4JW0Kcyo1OY7W2WmVRmZwmH+4jk8hcGjeIFZQoTrxzc43elJNNJz8o/MDr8wIAhUSZGDFRypHKjfLCtkKHxwEAufJcjVXz5oQ3WdTbeWdidVnfynmLyIIsKitJnHSu/RwAnG45nRqYOjWql1X5WgtajS1GfgifI+WoSlVn/ntm8obJf6RWqPLHyup91QBQ9HER7sOjp0ffelk3rPdz+scffyyRSC5cuLBy5cq1a9cSGwsLCx977LH+1fzQXthe/n25w+CImRET+6dYGpt2Ey/GQVulBYCAxACWiCWKF+mqdW1n2sLHh/e6+77qfV+UfNF9gvlmY/Oq46vemvBWjH8MAOA4fuaDM26r2z/Ov6Omo/ZgbeKcRArz8r+gOacZx/GwzLCW0y3KEqXX7SVTL2c1r8/7r7x/EVmQQqK8MOKFCRETiAJ/uvTTN2XfAECxovir0q+Wpi296WN0wxwex0eFH+XKc7u20Mi0JHFSKC+UQqKoLepKTaXBYSACK2gtKGovejjx4flJ869RqYJ02Vu9t93YHpIXQiaRZ/5tZkDMzTVABImDKumVJCdJrUWJEAAAB/xE44mCloJqXbXZZQYAAVOQIk1pM7XV6+uvXAjC5/OxqKwp0VPmD5rPo/feNnF3HKk/sqVoC9H8IeVIXxv7WtfFtMlp+qrkq6zGLACo1lVvzNu4bvy6G2kWaTndoq3ShmSESAZfa7XzLee2EBdSLCpr4+SNkYLIT899erjuMADsKNkxLGiYkCns8ZKa/TUAkPhwomyU7PCyw5pKTf2x+uhpvWcvj8+js+koJIqIJep1B4fBUXe4DsOw2D/F1h6oPf/ZeVYAK2ho0HU/4O/g0Jzb7DQ5Y2bEkCg3NHsaucfq8AQqlTpp0qTHH3980qRJXZdIkydPnjVr1s0FdIfl5ORgGDZ+/Phe/2rrsGWvybZqrB67R12hrj1U29nYyQvjMXg3VIVokBuq91WzxezBjw0GANyHt59rd1ldkZN6aaw+1nBs6/mtxGMeg5cqTdXZdC6Py4N7ipXFEyMm0in01vzWmn01TCFz+n+na6u0pjYTU8j0j708ZPPCtgtOs3P488P1DXqb1iZOEnMDL8+q9V35d9lN2QCAAbZy9Mpx4eOI7RiGJYmTcByv1FQCQE1HTYx/TBD3+l8au97eeLzRbXNzpdwbvHbT2XRrsteUqcqIpwKm4PEhj7886uVp0dPSAtNSpCljQsfMTpg9SDzI7rETrQs+3HdRc7FIUTRIPIjHuLkzi8vlotP795yZWqtWYVbQKXQa+fqXX+3m9n/n/5tTzPG76BcRETF73WyMdHMX1UaH8cLRC2Qr2Z3onpRyT/Tq6kMWl+WNk28cqDmgMCtcXhex0eFxNBua9XZ9ry/BcdyDe2o7ao81HOPSuFHCqD5p7f7p4k9flHxBZMFwfviGSRsCub+tz0On0EeEjODSuBdUFwBAZVE5Pc60wLRrlYjDmQ/OlH9T3lHT0XSiicFn+Mf8Nky89lDt8VXHNZUaUYKo1FRKXFUDwD9G/2OIZAgAJEuT81vzzU6z2+s2OU0jZSO7l21uN5d+XUphUUa9PIrGprED2C35LdpL2pARIXTe736/Nrfti5Iv3i94f3fV7n3V+7IashweR5Qwikr63VVyzYEa5QVlSEbIyBdHel1eTaWmJa/FZXEJIgUUxg11g/B5fCffOFm1u0pZrFSXq8PHhZPI18+FvSfC/uLaifD81vMddR3BI4KH/224vcNuajMZW4yNxxrFSeKuWmy3153VmPV16dc7K3cWtBYYHcZQXihx5lIWK9vOtgWlBYWODgUAbhC37nCdqc0UlB7E8v9ddUS1rvpfp//lw30AMEg86N0p706OnJwelH6q6ZQHPDa3TWVRZYZm5r2b5zQ505akieJFJAqp9Uyrz+OLmBgBAGalueL7CjqXPvSvQ20dNu1FLZ1LJ66DKjWVHxd9TPwwFg5Z+EDMAz0+5mDx4IbOBiL3VKgrJkdNppOvlUK0VdoTr51ozW9tPtnscXgCU6+/DJbKolp1fFW76XLj+bToaWvHrR0sGdzjFI8BJuFIMsMyR4SMaDG2aG1aADA4DCeaTojZ4u5VxNd1jyRCo8OoMCvsHjubxu5qIDE6jA36Bq1VCwAsKuvKhhOlWfl27ttfXPjiaMPR3Zd2lyhLdDady+tiU9m9tuO6vK63T71tqjdJD0nZVPaCdQsE4TfdE9iLe3OO5VD1VGuodWbmzJv/rPcPo8P4Rs4b1brqri0cGodOoXdlRAqJkhiQODx4eHpwelpg2iDxoGBusNVltbgsGIa5vK6i9qIzrWeETGGI392bpwfH8S9Lv9xZeXmZ8Vj/2Lcnvt3rFWScKA7DsAp1BQDUdNREC6Ov1gaB+/Cij4sajzdSmJTwCeGGJoPygjIwNZAlYgGAqlRV8H6Bz+OzqCxmrfkL9xc2tw0ApkRNmZt4ubsymUQO5YUSF+LNxuYUaUoA+7e6ioZjDaoyVVBGUOS4SADghfKMLUZ9g15+Wk6hUwRRAuJ6TmPVrDy2skRZ4va5iRfa3LYKdcWp5lOx/rHdCyz7X5lNa0t+Ipkn40mTpT6vT3NRo6vWNec0EzVz1z2MxduK5blyOo9O59KNLUYahxaQcP3Klb5JhF6vt6GhgUQiXaOita2tzWg08njXupO4RiL0ODyFHxT6fL6Jb04URAoiJkZETo50mpydjZ26Gl309GiMhCnNyjXZa7IaslQWldll1lg1parS7KbsSEGklCNtym7S1ejCx4eLk8QAQKaS3Ta39pLWoXeEjQ3rOv05PI7XT75ucpoAIEoY9c7Ed9hUNgAImAIpU3pGcQYAWk2toiZRZ04nW8zOWJ6BkTCWiFW9r9qqtcb9KY5MI8tz5YrzipCMkNAxoSQyqfFEo8/ti5kR4/K61p1cR1TspAamPj/8+StPuxiGpQWlnWw6affY7R671qodHXrVlQp01bqT6066LC5RvMhhcOiqdP6x/tygq07oDAAaq2bViVXEeZ+omH100KPXru0UMAWTIyf7Mfwq1BVe3Ovxec60njE6jKmBqSTshmoq+jwRVmoqNxVs2nZh2691vx6sPfhr/a9qi1pulH9T9s1n5z873nj8eOPx/TX7D9UdUllUsf6xXRmurqNu1YnfLhoAQGfTVWgqcppzdlftzmrIajW2BnIDu05wXp93U8GmMkVZ0N4gqpU6+S+Th84begsB0yn0A1kH6Eq6UWKcNW3WAOy7q7FqytRleS15n5z7pM3UBgAYYPMHzV82fNni1MVzEuekSFPiRHHToqc9O+zZGTEzhgUNGyQelBiQOEg8aHjw8KnhU2P8Y+o76y0uCwAYHIY8ed5FzcX4gHg/es+ea3+cQW5Qlaq4Qdyu+5XtF7bvq95HPE6WJr854U027aq9TpICkrouf8vUZZMiJl15jeXz+PLfy28+1UyhU8avGx/3pziP3aO9pDU0GaKnRns93lNvnnKanbEzYw1yw8WKi42yRi/TK2QK14xd0/0aV8KRtBhbWo2tANBoaJwaNbXrLFSyo8TWYUuYlyAMv1xlGjw8WF+nNzQbFOcV7UXtYWPCrGB9NetVlUVF7CBkCkkYiciIVrf1lPxUKC9UxpMBgNPsLP68mEQmjfj7CBKVBBhIk6WykTJTu8kgN2gqNDEPxOAYfqbtzNGGozW6Gh6D1+NCoeV0S8mXJWQaeeLbE6Up0uacZpfZdSOtjH2QCCsrK0eOHLl79+7169djGDZ6dM+ztsPheOihhzZs2LBjx46srKw5c+ZcrQW7KxEWtBZsObdlZ+XO3OZcwCCcH95+tl2eKxcliBJmXR6PTGPTgocHtxa0mtpMrACWU+r85/F/Ki3Knu/uceTKc2OEMYZjBqvamjAroStP8MJ4jccaDc0Gj80jiLp8q76jZEexohgA2FT2xskbu/9jhFShyWNq7GwEANP3JqlXmvxEsiheBABkGlldobYoLfxwPj+cX/FjhVlhTpidIIgUMPiM6j3V9k573J/jfqj6oai9CAC4dO5bE966WsM4nUyX8WSnmk8BgNwojxJEBeABbWfbFOcVBrmBTCPT/egYhinOKU6tP+WxeyImRIxbO45CpyhLlJ0NncRlQa8lG53G1cdXqy1qAKBT6GvGrrlGlu0Ow7BY/9iMkIxydTlxlVCnrytVlaYFpt1I834fJkIcx3de3Ln5zGbijpbg9Djr9HVlqrKunlCXt3ud9fr6E40nwvhhUo40pznnvfz3rC4rAFDJVBlPZnaau8a6AIDNbWvobDjWcMzpccaL4l1e1/tn3j/TeoZ3ged30S8qKuqRjY/cSE3OlSgkyuH8w9RGqkPgGDtl7O3tQ9HnvC4vRsKuNrNzq6n1PwX/+bz48zx5XqWm0u62AwAJI72Q8cKs+FlEGsMAC2AHRAujQ/xCeq2s9ng8IbyQB+IeoJKp9R31Hp8HANRW9bGGYzQyLV4UfwvzSpvaTYrzCk2lxthi9Av2I9qrcBw/v/V84QeFrWda1WXqkIwQCp2y6+Kuny7+RLxqlGzU6szV1+4R2v3y1+FxtJvax4aP7b6Dz+s7/a/TbWfbaBza+DfHE1fzAQkBTSebTG0mGpemOK9oK2zjh/MzX8tUKVSlxaWAgS3C9vfhf4/1j+3xdnH+cUcajnh93k57J4fGiRfFA4BNZyvZUUJhUIY8NYTBvJyGSWRS+PhwYaRQX683thr1DfqdlJ21+loAoJFpL496eXnG8tkJsyUcySXtJZfX5cW9Z9rOxAhjgrhB7YXtLfktksGSqGm/dRZl8Bnh48PleXKzwowL8A9bPtxdtbtGV1OhqThSf8TldQ2RDCH+NZ1Nnbnrc30e37C/DgvJCOEGcf1kfmlL0m6klaEPEuGCBQtmzZq1c+fOuXPnLliwYP78+ULh7xpgt2zZcu7cudLS0uXLl3/++ed2uz0jI6PXonJycnAMr2BWfF36tcaqsbgsHfaOovaiSk0lL59nbbcmzE4Qxf3WKouRMCqT2na2zWq1fur5lDjT0ci0RSmLlqYtjRXF1nbU2j12H+4723Y2KC+I5CGlLE6hsi6nYSqTygvlyfPkumpd9Z5qdbnawDNsq9tGnOmWjViWJE7qHp7L5UoNST3WcIwkJ3HyOQweY9qqaV2nObfNrSxW+rw+2UjZ+U/P4148/W/pVCaVRCYpihU2rQ2LxLY2bSVqXJ9Lf65H4T0EcYM0Vk1TZxOzhSn/St65q7P9TLuqTKU4p6g7XFe1u6rucF39kXqfxxcxISLjxQyMhPnH+DfnNpvbzSwRSxgtBACH0VHyZUnpl6UusysgMcDldb1+8vVmQzNxlNaOW5samHpT/2s+gz8pcpLSrGwxtgBAh60jpzmHuOG+vAcOtg4blUkFDDx2D4lK6jp0VyZCQ7NBXa4mkUl0vzuSI7VWbVF70RclX2Q1ZBFbKCRKKC8UAIiuegQyiRzrHytmiZ0eJ1Hb5vQ6TzWf+qXql/yWfOJSl4/xF+sWRxVEpSpSU0NTRVYRo5Nh5Bi94IX/H2Ozt3rvnqo9coOcaqBKDkqCmEGPvvXo1YaQ3ojcilxfuc/L9iZPSw5g3dODfSt3Vua/l29oMphaTaoSlV+IH5XZ+8WuodPwzeZvdq/ZvefAni8VX+5v2F+pr/T4PD7cp7KoqnRV+2v2bzm3pcf6Uzw675XRr2SGZfZaZq88Hg+JRKJRaIPEg6ZFT/Pi3gZ9gw/3eXFviaqkobNhWNCwazT3uq3ujroOR6fDbXfbtLbOps7ibcXFnxe3nW1TFivbC9vrjtTR2DSP01OyvaTpZBOZRmbymcZWo1VtbQtr23JuC1HOKMuotII0CpUiiLxO9TidTA/jh52SnwKAdnO7gCEgOuURCj8qlOfJ6X70Se9M6uqIQKKQuIFcea5cU67RVGowEpb5z0yOhPNt47eOAgfFTAmZEbIkbcmVKZ9NY2OAlanLAOCS9tK48HEcGqfxeKOiWBEyIiRoZBCN9tuRwTDML8RPNlLWlNNUd6mulFLqFrgxwFaPXT1KNgoASBgpUhCZGZZ5QXmB6Lhb2FY4PHi45oRGX6+PeSCmR2UmRsJoLFpzQfOJshOXwi91bccBv6S91GRoGhE8wtJiyXkjx2V2RUyISH7i8tJ+/DD+Dba13+1R2Gq1+uTJk99//z0AREVFTZ48+ccff3zttde67/Pjjz8+9dRTxF3gU0899emnn7744otXK7CqpsoR4ejxOSrVld6j3gRuQkhGzyr+4BHBJCrpbO5ZbbQWWECn0N8c/yaRY8L4YSmSlFezXlVb1Z5OT3VrdWpkao/mwODhwZPemVS1p0pdrtZUanLycqhzqU6xMy0wjejJ2QOXxp2fNP/gTwcB4FLUJRfJxYTLtcGhY0IvbL9A/Eg8Do8gUsAUXP6TOEmsq9LtO7LPk+QBgMSAxEkR1+/+8ET0E41bGsmVZACQ8+Rjxo3hh/NtHTZtldaqttr1diqLOujRQQmzEohqMxKFlPJEyul3T1d8VxE+Ltxpcp5Yc8KitABA+XflFo0lJy2ntqMWAMgk8iujX0mRplw3hisxKcxXx7yaUJPwZcmXXrfXrrCv/3n9VPLUiNYIh8Fh19vdVjeVTaUyqTadjcahEedEXhwvemy02+Fm+DEMckPV7ipDi8FldgEAmUZOW5rWdRdr1Vg9Dg9PxruyLtDn8fm8vu7DXZpymw7+eLC5o9nKsjLTmeLBYiFTKGAK7G57sbK4qbOp+8uHBAxZ7L84UBbICmBd1FwsU5XZPfYQv5CRspE8Os/n8WFkrERV8lHhR8RgErf3cvtHeEP48Irhv3XKaAR/8PcH/1RmqtFobCW31mbW2sJsxP6cWo74V3EQI2jktJFB6TfZO+73hEFCNagpJorKrEoQXX9itjsLh8pdlZ2NnVFTowLTArvOrcRthDxPDgBNJy8f8Jb8lglvTugx/qz9XPuxDcdq2mucHicA0Fposm9lANAa2bp59uYr/90kjDRYMjiCHxHjH5MRknEjfZSuxo/u91TaU5MjJ39Y+GFdRx0AFLUXvXz05TXj1vRoNXRZXOpytfaStv5Yvcfu6VEOhUkJHhZM59E7Gzu1l7RFnxQR26ksauaqTG4Q99Dzh2pP1ebgOXgYDgCpytTQk6EdWIe+Vg8AvfbL6y4tMG1myMycEzlurnv7he3xovgIQQQA1OyvaTzeSGFQxq8b3yOhBo8Ijp4eXX+kHgBSF6cGJAZcUF44D+fD+GFUA3Uee97VbnxnJ8zOlec2G5odHsfmM5s3TN7Qkt8CALLRvY8YZolYITNDCjYV+JX5WSOtDyc+PDx4ePcdxGzx+knriVpTu8e+Pnf9zIqZABCQ2Ms1XODIwDpTncvmIjvIwIKZMTPlRjnRd6+wrXDNN2tSDqdgDkyaLB2+bPiVL7+uu50IW1paOByOWHx55ovo6Gi5XN5jn+bm5q5Vu6Kjo5ubm69RILeIawu2mSJN6aL0SUGTSjpK8g35LB3LbXVXMiunMKaw4Xe/LiqL2hTQZG42c+o4pmTTylEru99p+bP814xb8/LRl6laqs1lU3N76YkuGSKRDJF47J7v3vnO+qtVul+qekr17LBnrxbhJPGkguYCF8mlTFTuqdqzYPACYjtTwJQMkahKVYUfFwJA8PDfmrsDEgMsLouyVAlJgAH216F/vW61jFVrzVuVF6+Mr6ZVG4YbGlMaJ06ZmCK7nLo8Do/L4mIIGD2q3WSjZcRYjvx/5xtbjBaVRRgtjH8ovujjotO7T5fpyyAWAODZYc+OCBlx7QB6gYNZZbYoLe1F7VgpNts6u7yx3Gv3AsAluCSnycN4YWwam8qmuq1ut9VNopBcFpeuWgcAredaq3+s7lEeU8jkBnE1lZpzn54r+bKEH873eXz6ej0AkGlkYZRQNloWPi689UxrZ2OnTWvTVGp8Xl/ExAjxILHX6W0tbT2x9wRRb8kEJpRBQ2JD0Zgij98V5y8SZYptivR/0iJDEQBQ6BR+BH/UjFHiQeKGrIaLey9qq7VWtZUtZoeMCHk57OUsUVaBosDhcYhYolH2UYxCBhkjiweJhzw+pKO2Q12mpjAphiaDqd3EoXESIEF8UtwqatXwND66L/hscDA3OGVKSvrf/uhcIdIQqRrUVDO1R/3tbeQ0O8k0cvdri86mTovKQqaSG080+jy+5L8ke5wexXlFe2G7vkEPAK0FrQweg8ahZSzPaD/ffunnS7gPpzAoQ/861OPw2PV2xXmFodlw4JkDTAFzyMIh4kHiyp2VHqfnfNZ5eYccB9wWYTMMM3BqOAwFg2KgcBo54qNiY4rR7e/2UX1EGIPEg55Lf464fSf4PL66X+ssSkvk5EiHwUFhUHo9wwKAy+oiU8mqEhXuxoNSg2hsGnGNJTALVghXHHIcyjubR3KQjDzjWyfemsKfIhPIdDU6R6eD7ke3aW1et5coxz/GH/fhHqeHwqBQWVRhlDBxbmJX7YU8V0501RZECZLmJRH9PuIfjf/x3R85ORzDE4ZgCE4sTPRhvuARwe2F7RXfVYSPv06PR6fR6b/VP6I+wuazqWeqN7I2/mfafzxKT+lXpRiGZbyY0XUv2F3639ITZiXgPtxP5ufxebYXbwcMLHGW2MpYX4UPRvX+XhQSZXnG8pXHVnp8nkpN5S+nf3FVucg0cnB6cPf6ku5OCE54SV5WIysUC+0673UnZArXjlv7j6P/sHvsap26tKI0XhJP1E51h+P41tKtGpGGJWex5Kxnlzw7NmwsjuP/K/vfz5d+JjlIzh3OUmdp0viksevGdo06uylXTYTHjh3bt29fS0uLw/G7D5mVlXULb9PFbP7dRIgsFqu1tbXHPhaLpWsfFotlMl11HmEcx50upyPPIa+VW1otJ+EkACx9fWlRcZEP93VKO1ccXrFixIpBAZfXNfX6vNvLtpf7lYtxMa2ZNn/+/CR+ksVi6V6miCKaGzv3UM4hH+4rJhXLtXJ/Zi9fJovLcjjpsPCskKanTTRM5GLcHuUAgNVqxTCs9tfaQEZghajCSXf+XPHz+ODxfrTLbe+hkwO5mK4AACAASURBVEPbits8Rg+dRw+ZFNJVAjuS3WptpdlouAnPiMuQ0CRXFt6dx+7J/me2RWEJTQg1TjTWmeoAYHPB5uCJwb8FzwCbvZe10AYtHpS3Lk9eIAcA/1j/EatGUFlU2nRa2ydtAUcCbHzb1BFTx0jHXDuAy3DoqO1oOt5kbjUDgL3D7jD87suTyEls5DR24B0elqc9qb1SVDkmfszjGY9T7VSvw8vwZ7jMLovC4jQ6G7IbnBonmUZ2Gp0MAUOWKQsZHULn0zEMUxQqKr6tsKqsqkoVAFBZVCqbatPalBVKZYWyaGtR19thGIYDXnO4puZwjRf31unrLGDRjdM5hU6mkik8L2RfZLMvsp0Spz5N76P7WEZWSFRIqC+UW8z1qr0WsHCDuE6j02F1qCpVxNt1L9yoMBr3GAEgPDj80TWPetwec425dFepx+uJnR8bPzceAFhhLNkUGXFwbB02ppBZ+U2l95CX18nz6r0AQBaQE+cnxs+Nd4PbbXFf/yBfHZfL9ZF9JBupRdFiCb+B/9cNsKqs7YXttXtr6Tw6L4ynPKfEcZwXyjMrzTQWzT/Bv62grfvaLPJ8OQAQo/SYQmbouNCW3BZLhwU64PCKwwBAopCEw4RN6U0bzBuUFiWZTI4dFxtLi6VforuUrtPvnyZRSE6ns8XU0uns1KfrdaN1HBrnL4P/khGcwSQzq4urc97M4dRyJNUS4AL9IbqIJooPjw+jhzVva26jtyUtTHJZXFa1tfJ/lcRF0sU9F4nY4ufGh08KxzDM5/E1Zzfb1DYqh6o8p7Tr7SQKyePyYBhGoVF8Hh+O40wh0663AwATmOmOdLlR7sW9AJAP+cHcYAlbAgA2gw0jYaJEkShBJE4W+8f1PFF0/5/6p/n7p13ewQc+4ge1n7vfyDBSNVR+OX+Cc4LD7AgaHpS2PE2/Qm9sM9Zk1cjGXGuGpvOfnrfpbXFhcWX1ZeKD4jZa2zukd0YeHOm0OyOnRQqThVf72WI8DAPMYrEcrD/YpG8CAFecS9oobc5rjl8Qf7WOVmKSeAZrxn7Vfi/D++uOXzMcGTGjYxweh9VqvXLnC6oLeZq84PBgTj3nQfeDTrvTCZfXLVCVqOTZ8kELB7GlbCFZ+HTy0/8p/A+7la236rV8rc3R8zT1w8UfjtYdFcqEjGbGGPuYNP804nM9HP0wh8Q5uPkgZsWMIcZdibtyD+ROiZgyIniEmCU2Oo1yo3yIeAiLxSLmhLmGqy7Mu2HDBolEEh0dfXtH0EskEoPB0LWisV6vv3KNLolE0tnZSTzudYcuGIZJmdLB7MGHvz/cfbC8f57/OdI5Z4TT7rNvOLNhctTkkbKRVpd1f83+uo46ajiVhJFizDELUhf0eqf1SPIjpeZSF+ayS+w/1vz46phXr9xn+9ntNrBRMiiyYzLZJVmvy3HhOM7hcJQFSjFX7DfGT0PRuMF9sOngX4f+ldghelw0yU0q+1/Z0GeGCqW/XQddtF3USDSsJpawTbjk8SXXXeurYGuBQ+MQRYsmb5w8gTah/nC9xqqxe+0fl3y8cfLGa4+35SRxpr47teL7CnGSOGZGDIVJUVvVuwS72PFsTg0n+XDyzLSZ6jNqq9pK96PzI/iCSAGNTdNe0rafa3dZXADA4DNE8aLOhs76o/VWze9+En4SP24wVxAhCBsXRufSqUwq1Y+6u2r3DxU/EK1rpzpPlZ0sey79uVGRowAAeCAKEQFAUEYQl9t7X9bYSbGxk2KJJhmMhIniRWQa2WV1qUpVlT9WmhVmUZxINkpG49ICUwJdFldddl19Tf1Z3VlDiKFzWKeX512csnhixMTG6sbKXZUdJR0umysqP4pFZfkx/Mh1ly8nuWLu4McGR02LwjDMbXO35LeUfl0KPpCmSoOGBvnJ/IRRQnW5Wt+gb8hqMLebc1/O9bl9RAKInR47dNHQK79aHC4HAEb+fWTKYym6ap2mUqMuVw96dFDomFC4HSICIrL52TQdzaA1/PH14TwOT9EnRfJTcuJD2R12u9qOYRiZTDa3mAHAZXQpzyrJZHJQehCO4/xwvs/tazjWgON41NQofizfFG3q9HRGz4yOIEU0/dpU92sd7sPFS8TbHNvMBjMAkClkAKh11dYOreWkcYarhzOyGHazvVHaaBhssEfYXQJXjCBmdebqrkbl9PHpUSFRVburOuo6LCoLZAEAqEGthsuVN225bV6nl4iZH8L3k/l1NnRyg7jaS9r6vfX1e3tOCggAdCbd6/aKYkQ0Nk13SUehUHAcd5vcbCFbECmwaq0RoRHx3Phjucc6OZ2OIIfWq01LTHv2oWc9Rg+NQ2MKb/EM+dPFnwq1hdxxXMlBSXpxuofp4Yg4mSsy6Vx68iPJZz88Kz8iT5h+1SpuQ7NBWaCks+gzP5zJ/oad/0N+yL4Q02lTtaU6KTEp45mMrsk6rkZn0+2u3U2hUADgkWmPYJWYVW21t9l7HW9gVpizXsliG9hDTENUMSpOJaeN0jbv0XnEN63H983ldX1b9S2FQrFH2yNUEawWVtcO2ipt8eZir8trajBN3TSVLWZPiZvSZGkqOFNAwkgXGBfGWMZ0tcIQt337G/ZTKBRnpFN8QRysD+7+Xg+EPNCh7GigN7RNbSPTyVqH9vuq77+v+p5JYTo8DhaVte2hbdfNgtBrInS73e+///7y5cvff/99Mvk2T9kVGRnJYDCIhSwA4OzZs88//3yPfVJSUs6ePTt9+nRiB2IdjKvhSrkylkyeK4+Zcbmh2OvyYs1YfEB8R2yHBSw44FkNWV3dHwDALXAHBAaEkkJNrabufROcJidRj0HCSPH2+HIodwQ6TrecnqyYPDTodz3aC9sKTzSeAABzvDmqNsosN+uqdUR30B46mzqNLUa6H/2xOY+9ffptAPi17tcHYh7oammInBwZOblnS8D3Fd9bI62sJlaSOimQc51xfvVH6ptPNVMYlMx/ZtLYNBrQ/jHqH6tPrPb4PNW66q3ntz4/vOcR7kEYJRy39vIgfYfHsSF3g9lptk63crycaGt0wb8Luu+MkTAKk+K29n7vwhazwzLDZCNlGBmjMCl+wb30O5+bOHe0bPQXJV8UthUCgMFh2Ji3cUTwiCVpS25kNgAClU2Vpvx2hURj00JHhxIjPgktxpaPL35coiwxko2QeHkjCSMtG7FsSuQUAEhNSU1NSfW6vE0nmxqyGqhMKiuAZWo1MQXM0DGhstGyrlopKosaNSUqakrPaQ+lKVJpijR6anT269n6ej2FQZEMlogSRElzk649eIEpZMpGyWSjbvN0rMRiTDQdTd/a+5jxm1K8rbjuRJ3KqdLKtPYhdiqLyjFysBAM/IHTwZFKpTKyjKwl2wS2BmFDu6nd7XP7M/1TMlPCuGHnjOf2VO0h2psBgElhTk2ZOmHWhMr2yg8uXp45rAcLZsmWZmOPYiQnycvxAgCGYQ/GPLg4dXGP1j5htHD0K6N9Hl/FDxX6Oj2ZTibu/KKmRDWfajYrzBQ6hRfKo/PpGS9kMPiXezO2nmmt2l1l19s9Do/b6g4fHx6QGGBsNYaOCfWP9Xd0OjAWRiaTwQ1kOhlwMLWZuEHc7rMBZzydsSFvwyXtJQDIgRzlWeXqsatv+T7hSP2Rb8q/AQBzvHmoe6h/pT+dRx/18ihiHHrYuLDS/5XqG/TqcrVkiAQA1BVqn9sXkBjQNa68em81juPR06I5Us7cf8zVdGjqjtXRVXQFXZG6KPW6WRAAtpzbQsxlGsoLfTDuwYpRFVV7qlryWq5MhD6Pr2BTgdPoZAqYkZ5IR6kDx/G2hLYSX8kE6KVvxE8Xf1KalQCAxWGhFaHqMnXXVFklO0q8Li+Dx7B32qv3Vg/961AAWJyyuFnbbAe7JdiyPnf9P0b/Y0TwCLVV/em5T4k++QAwJGVI7JlYortD18VH4/FGDoUz488zFOMVB2oOEENfAID4XFa3dVflrhuZb6uXg2UwGJxO5xNPPHHbsyAAMJnMpUuXLl++fNOmTdnZ2W1tbfPmzQOAwsLCZ555prS0FAD+/ve/P/zww8OGDSORSJs3b961a9c1CsQjcdBBY1ZjVyJUV6i9Lm9oYujcOXM/KvqImCuvC41MWzhkoUQhkZ+Sq8vVXYmw8sfK8u/LwzLDMpZn2HQ2uoseIA2o59YDwCfnPvlwxocc2uXLEJVFtfnsZuLxuKhx6Q+mX/r5UuPxxl4TofyUHABCx4Smh6YnS5PLVGUen+ez85+9NeGtqzX7VWoqy9Xl5Diy6LRI3CbWXNQQXZ97panUFH9eDADDnx/ODb58C5UQkPBkypPbL2wHgKP1R4O4QXMSbmj6Zh/u25S/iRjvQWaQn/3oWfwM3na2jcFn8MP5Vq3V0GwwNBncVjeDz4icFEnMNG9qM3U2ddLYtJgHYqTJ0hsZwBbIDVwzdk1Re9Gn5z4lepoUtheeU5zLDMuclzgvjP+H5rO1e+zflX93sPZgjxMui8p6MePFHlNjkGnk6GnRV5sR6kbQuLTp/53usrrINPKttU/cLmK22CPwAIBNZfP4PLe2IInH4aneW60oVjSVNdWb6xsfbXQFXB6HDsRVjR4AA+hqPdcAdGuRPAEnrizT7rHvq97XNUgOAEQs0bPDnk0LTLO5bbny3F/rfyWGqeFU3Ev1AkAgN/D54c8Tk5v0ikQhJf8lucfGpPlJHpuHwqRcObGWbKRMNlLW9Rl7TFPCFDKJNqCuLuJXrjPDY/DWT1q/pWgLMcNZTUfNS0deWjl65SDxoKsFeTW7q3Z/VfoVcds6RDJk+fzlllaLX4hfV9hkGjl2Zmz5d+Wl/yudtH7S+c/ON2Y1AgBbwh6/bjxPxrPpbM2nmjESFv9QPAAABs9tfG59wvqL9RftYfZtrdviE+O7t5he6Wj9UeLciAG2bMQyCokSNi6sak9V86nm1CWpPQ5ga0FrR10HW8J+4MMHTG0m25e2c+5zhlTDl6Vf9ugCAwByg/znSz8Tjx8f8zh+Ae9s6tRUagJTA01tJl21jsqijls77ug/jjZmNyYvSqbQKZgLi3fGV9IqncFOn8f3zql3hEyhwWEg+swDwIiQEa+OfjU/J19RrNBe0hKVKDiOE/Mzx06LHT94/JyEOfkt+XkteVXaKpvbRiFR4kRx1/gKddfL8AkWi/X9998nJSUNGXJDRdysCRMmKBSKzz77zOFw7NixIygoCAAsFktbW9uDDz4IAOHh4dHR0Vu3bi0sLHz99ddnzrzqNBk5OTmYHxZkDTIrzdIUKTuADQC1B2s7ajuipkaFp4WPCx+XGphKJ9NZVFaIX8ikyEnLRywfGjTUY/O0FbaRKKSwsWEA0HSiqXhbMQAY5UaLyuK2u1UlqriRcVXSKqfXaXPbmjqbxoSOIZPIKotqbfZaokOgmC1+bexrQqmw9mCtWWmOezCuq/c/wWFzlGwt8dg9w54exgpgRQoij9YfxQFXWVQ8Bu/KwToAgOP4f878R2vT4lR8sGiwQCmQ58qrdlc1ZjW6LK6AhIDuvYE1FzWn3jnlcXjiZ8UnzP5dFUq8KF5tUTcZmgCgTF0m5oivu4yZ1+f9oPADYqZ5AHh++PPDZcNF8aLIyZGhY0LFg8QhI0Kip0UnPpwY9+e4pHlJgWmBwmihMFoYmBYYOSkyLDOMI+Xc1DDuYL/gKZFTzC5zo74RAHDA5Qb5kfojOpsuihfFZV1rmH93OOBEFxgSRipsL3wr560SZUnXZJJ0Cl3EFE2ImLBi1Ir/a+9O45q41gaAn6xAgJAEJOz7IgoIxuCKUkARtGBdr7XWWkW9LrXiW7X2Wmztrq2Vtl5atYu9tV57W/dKVbRiqwiIEjYNYd/DGshGtnk/jL+UhgjIlmCe/6fkZDJ5HBOemTPnPAef/zQcSFTSwOb/DWUMRFJaVhqZT1bZqKbMmWJN7e8B/AuGbn5w88GvD0rLS8vkZQ3RDTJ33dUP+s/R2pHjxFFpVN2XMkAI+bB83ot6z8fWh0QkmZPN/e385/nNC3UItTKzsqBYeDI9F4xdsDlsc/+7B7QIRALJjNTniHm99Sfx6RO9n/0TCcTJLpOtqFZ5jXkYhslUst8rfkcIBdgF9LdShFrxedbnvxT/gj/1s/VLjkg2I5uZM8x1wmZ4Mip+r+io7ii7WtZU2EQ2I1s5WonrxbWZte4z3Qv/W9jCb/GY6aFdn4FAIHADuTfkN0QakUqj4jXyoryidAqYaVW2V37wxwf4XMl4//gYnxiEkAXLovp2taRRwvRm2rj+bRrP3a/uSholoS+FjgkYQ7OlTYiYcEl+SaqSylVymUoWbBesnT6h0qje+v2tFlkLflg2cDfIWmXCAiHFnOLMdS4+XdxU1OT5jKdvnG/9vXpxvZjuTGd6Mht4DVW/V3kGe9YE1EiUEoSQTCXDp6UREGHxuMWbwzaTiWSJUNLIa7RgWeBVt1oethT/Ukyzo3E3cBEBkYlkL6ZXhEfEkvFL4v3j/xH4jxifmH7W/ddzzkggEI4ePbp27VomkxkdHd19gsiQoFKpycnJycnJ3RvHjh2bmpqqfbpo0aJFixb1a3ck5DvPt+BkQeGpwoi9ERq1pvp2NULIedKjf3+AXUDPoeR4r1pjfiM+CL7olyKE0LjF4/gX+JUZlbVZtQihgNiAzezN7918D8Ow3Prc7Ze3B9gF3Ki8gf/NpZKoO2fstDazRs7IPtBeWCAsvVLqH/+3FSzrc+plrTIbNxu7ADuEkAfDY2HAQvxc6WjuUXsr+56Lit2suon3vVBIlBc2vVBmVlb5R6VaocaXJqnLqQt/PZxmR1OIFYWnCh+ee6hRa9xnuk98WU+xwc1hm5ukTfmN+RiGpWSmEBFR7wQPnFgh/vjWxzl1OY+O/7hFs71n692SSB7KaXyWVMvNYZtjvGP+w/tPbn0uQkiDaS6XXr5RfuO5cc9FekY6Wjsq1cri5uLs2mxeI0+mlHmxvOJ84/ATveLm4t8Ev92puYMXx7IgW+A1onAhDiEvTnjRh+UzgKnQoxTThSlDMko7paGzoc9OdR0alebmxzdvX7ldr6kXRgulnlINRcO0YG7kbvRgeEiVUrFCjJ+ht8pay9rKajpqxAox05zpwfDwZHqak81LWkqya7Pb5e0Mc0asb2yERwSJSMJ/PpdLL5e1leELKSSMTeg5tyFgTEDAGENP+eifeP94D4bHR39+JJKL1Br1D7wf7tTc2Ry22ZvVx5pB1aLqA7ce9bgghILZwbvDdz+u9AHVkjo1aer1N6/LWmU0O9qsPbPoLvTrydeFBcIrO69Im6UEIgEvg6xlQbbYPXN3UlqSXCWv6aj59Panu2bs6vnl71R0vnfzPXyop5uN26qQVdqXvKK9co/mPjz3UHv1jBDqrOsU5gvJ5mT8sgEhZE42T+Qkvn/zfYTQr/xfuWO4HKtHN4+O5h7F/4FUEnXL5C0ERHCd6lpwsqDmTs3EtRPxCzj8ZpDPHJ/mB81l6WWekZ74n1wvjtfBuQe/z/v+Wvk1hVpBJBBDHUOXjV+m/WLg436FBY+6IKr+qEIIuc1w63n+re3A6yf9nSehoaGhoaHz5s0jkUh0+t9u87S2DsHth6E1Nn4s3plTd7dOKVFKm6U2rjYsP90xuN3R7Gh0V3pHdUfzw2aNUiOqEtFsacErgi3tLbMPZ6vkKoY7w3GioxPBaXng8hP5JxBC5W3l2nlmVBJ1d/hu7SVdwIIAYYHwwbkHPrE+f3WOYajkXAlCSNtnixB6Puj53PrcsrYylUa17/d90V7R0d7RY+3G4qeTQonwy5wv8S2f9XvWkeXouMNx0vpJiIDaK9ozD2W28Fsu/PMCewJbmC9USpUEIiFgYUDoS6F6r8MoJMob4W+8ce0NfF7wwdsHJUrJfL/5Pbe833D/UOYh7cpKsb6xqyas6rnZ8PG19X3rmbcErYIfeD/gyViikJwsOHmy4KQF2UKhUXTv5KwX1/9Z9acHw0OukmvrNiGEMAzTZkGGOSORkzjTfSYyMXaudtWomtJGGcBiTLdSb13+5bKYKK5/rl7mIkMI+dv6vx7+ui1Nz6jpSM/Ino0THScuC1ym00ggEDhOHJ277KNdMDv407mffnzrY7zevaBVkPRbUpRX1NLxS/8qFtGNQq04++DsyYKT2nqnUZ5Rm8I29V6qkB3EXvDtgpaHLbb+tvhSATN2zUjfnS6qEiGEgpYHae+GaLnSXTeHbT5w6wBC6Fb1rR8LftSZtyBXyff9vq+usw4hZE423xW+q/tJic8cn4L/FuDDuPB7kwihsvQyfGEcbb8xQmia67RJTpNy6nIwhB3KPpTCTmGYM34u+vki/yK+wUshL+GF05heTEu2paRRcifljrxdzvBg4PcgXae7ZqdmN+Y3dtR2VGZUIoTcw93pZvRNYZvWT1rfImthmDF0yuvY+tuSzcntFe2yVpk50xyfyOg+YwhWBtRfWWbx4sUXLlyIj4+Pi4vjcrmcbqKjowf/qUMFL7EWNSeKSCE23Gto5DU2FjQqJcoJL06w9dHz6+1OXC9ufthMJBFrMmskQsm4JePYQWxbX1u7sXYkCiloeRDe0RrEDrKiWuUL87W91S50lzcj3ux+Y4DuTK/8o1JcJ1bL1Q6hDvgpWOFPhWXXyqzGWE3eMlnbZUoikia7TM6sycRv6pa1lV0tu3qBf6GkpUTQKjiWe6xN3oYQsqXZ7pyxE/+RkM3JZDOyFdvKM9JT0iBpK2/rrO3UKDWOoY7Td0z3ivLqpTeSSqJOd5ueW5+Lr450t+5uZ1dniEOIthuno6sjNSf163tf4ymEQCD8I/AfL4fqKS0xAlgWrAiPCH9b/9LW0nZZOz7WS6VR9VwxByHULm/X3hhHCFmQLRBCGkxjSbWM843bOX2n3p7np165pLzmYg1ZQbaMsgx1foIyQPX36//7/n/FanHtslq5k9zX1nfNxDVrOWufslJtvehP12h3NAot0jPSnGxe1FSkxtQYwsrayi7yLz5seYj/mjCEyZSyivaKK2VXPs38NLMmE5+AQSVRN3A3vDDhhf6sHko2J9Od6do7mmRzsvdsb7IZ2W+en2+cr963eDA8xAoxXgqjQFhAJVHHjXk0Wqxd3v7272/jS97jS9no3OAkUoiYBmvMa2yvaPeJ8SEQCAhDdw7dUUqVnESOTsWDQPtA/NJN3CW+XXM7py4nTZCGvxTuHr46ZLX2zwiRSKy7W9de2Y4QCloehC9/QaKQRFUiUaWo4V6DtEVq62sbuOxRMEQC0Ypq1fMmN5FEbOG3dNR0MNwYSomSf4FvaW8Zsjpk8H+vCD3/yrS3tzOZzNTU1PXr1w9y78Nt7969BAIhOTkZ02Dpb6Tjl8wsb9bsj2brLP7eU0dtx6+bfsUwDNNgVCtq/NH4XlYrFHWJblffligkXkyvEMeQnhWNW/gtV3Zc0ag1FiwLEpWkVqhlrTKVShW5N9Jlsm51G1GX6ODtg9rRUDrIRPL70e8/7m5We0V7R00H3YXe82b+4+BL0jxseYg/daG7LBq3yN7SPr8x//zD83iPPELIxtxmy+Qtk52ffOL8UNNgmmv8a5kNmXmNeXgHjgvdZYLDBK4Tl2nBTBOkXS27ipdloVFo4e7hMd4xvra+Ko1KrpKbk80HNkjk6ZBemv6/9f8zbzW332X/+tLX+//GI9uOFN0oapnR0j6lfWPYxrk+c4cvSOMkl8tJJNIAFuat76w/cvdIdl1235si5MPyeXXKq4McDtYnlUb1TsY72r8wHCfOLPdZTdKmcw/PieQivHEdZ92z/s/qeW+X6uLGixKhhJPI8Y/3r7lTk/FOhpWD1bNfPdsz32TXZb+b8W6Xogufg4ELZge/OevNv13MYejq61eFhUL3me5Ttk7R/nHuqO1IezVNJVchhKZsndJz/HxPgjRB1hdZeIHWihsVQc8H6fQPD4yeRNjW1sZise7evYvPcDBm2kSIENKoNPyLfHm7PGh5UJ9ZEHf709vl6eUIoQkrJ4xf2lslz/6ozKjMPZaLT8JFCFGtqAEvBIyf99jdPmh+cK38WnZtdvfV3m3MbJKmJfWxwNiT61J1Hbpz6GblzcdtMMNtxvpJ6xnmT7Ak+rDq7OzE5xFKlBIqkarTgyRVSivaKyhEigfDA1b97a6osejgpoNWZVbEFcSPt3/cz3eJWkX7Yvep1eqKDRWLwxavCF4xrEEapwEnQlyBsOB/Rf/LrcvtXmO9O5YFa1ngshjvmP5cCA6eXCV/+8bb+FJNOogEYiInUe9dElxtVu2NfTfIZuSo96MyD2aKqkWcdRz/Z/31bpxdl/1hxoddmi6EEIFAiPGOSeQk9rwHrJKrOus7mZ66BVTx9SIClwVqR/30TtosPZd4TqPWEElETIMlHEvoz9pMfdKTCBFCERERcXFxO3bsGPwHDKvuiXAAujq7yq+VMz2Z7CD2kKxao1aqZS0yhI8osTGTyqWPmxXeXXVHdZGwqEXW4mjlyHXmPult3n7CMOyS4NLxvOP4YB8tZ2vnNRPXcJ0HW99raGkTIXgibdK2V195lZXL6ojoOPbJsX6+67vD390/el/sJSasInwR94VpnlsMMhHimqXNmTWZRU1FNR01nV2dJALJkmrpyfAMcwkLcw4b4b4KpVr5zf1vLvIvam/rIITsLe03h23us3p+ZkomPmEDIUR3psd9HtfLUu9N7U2F7YVKjXLcmHHO1v0apTkYvB94BScLEEI+MT5hmwdSWbQn/f8xr7322rp160Qi0Zw5c3RKBnA4T89NbzNrs0ezcIYIiULCp9Y9or8Cny5XuqsrfYjnVvdEIBDifOOmu06/Vn4tX5jf0dXhZO001WVqmHPYyJyighFgTbUm2ZEQQqgFtcnamBZ9L/CrVqt5Z3gIoc6gztUBq00zCw4VO5rdfL/5vVxsjSQKibKOsy7WJzajMqOmo8aCbBHiGNLPAPqoGgAAFnVJREFUcuST1k/CVFjF7xU2bjZTk6b2kgURQhZkiwiPiCGLuy+BywKlzVJrR+vxSwbbjael/4rQwcGhsVH/qDO92xvKIK8Ihxtc1gwYHLqBUalUrx1+DX2LpG7SrUe2akdJ9OLS+UuXky8rbZSdWzqPJhw12UQ4JFeETxlZq8yCadFnb5lYLB58ST/D0n9FeOrUKYVCofclAIAxs3O2a0bN1DZqvbi+P4kw83+ZCCFRqGiuz1yTzYJArwGXUR119CfCmTNNbgIWAE8HR1fHJlITSUyqbalFnn1sXF5WLioQYWRMEiTBy4sAYIIMXBQKADC0HOmOSmslASPUVdX1uXHaf9MIGEE8VhziFWJH01MsFwBT8FcizMjI2LdvX3/es3LlyoaGhr63AwCMOEcrRyVLiRBqrOqjuAyGMMFtAUJIPFYc7WVEhTIAGGF/JcLS0tJ+Lrp74sSJXhbLBQAYkJOVk5KpRAiJakSPm9OGyyvJ09RqNGQNxZvScw0BAEzH3+4R5ufn96eCmkaj6XObXmAYtmPHjmPHjmEYtmbNmo8++khn4cTW1ta33norJyenoaEhKyvL1raPYmkAAC1rM2vKGApCCLWgZknzGEs9i6zibly9gTAkc5NN95puyuV4APgrAzk7O0+aNInQD9HR0ZaWlr3stHcnTpw4e/ZscXExn8+/ePHiDz/8oLOBUqlksVgbN24sKytTq/Ws4QkA6IWtmy1CiNJGqe2sfdw2Gkwj+EOAEJJ6ScPdw0cuOACMz1+ngXPmzJkzZ84IfOQ333yzadMmNpuNENq8efM333yzcuXK7huw2ezk5OSWlpYRCAaAp4+Du0MFqqC2UWs6akIcQvRuk1+VTywhYgSMEkQZbz9kE5MBGI0MMGr04cOHQUGPyqQGBgby+fzB7E0mk7X9nVKpHIowARitXFxdMBJGFpNrmmset01GWgZRRZS5yiYHTO5ZRB4AkzIsNwZ4PF5GRoZOI5FI3LhxI0Kora1NW4bA2tp6MFd+GIYdOnToyy+/7N743XffPfPMY1egHUlisbjvjYA+cOgGRqVSKZVKFpXVZdNFbaGWPyzvDOrsuRmGYSXpJQSM0OHbMYE1obNTzzamBirLDJhEIjGqimM6aDRan6trDUsibG9vFwgEOo3aUOzs7LSDTkUikb29/YA/iEAg7Nq1y2hLrCGEoE7YgMGhGwA8EY61GKtkK81bzdsr2/UeRl4Zj1RGwsgYeQI5zAOKzSKEEIVCgUQ4MAQC4ekssTZIM2fO7KU2jb+/f15eHj48lcfj+fmZ4gKqAAwfB2sHzBFDxUhZo+zo6qCb0XU2+P3s70iDpN7SKX5TIAsCYIB7hGvXrv38889LS0vLy8tTUlLWrl2Ltz///PN5eXn449zcXPxxXl7e3bv6F7AFAOhFQASmFxMhRG2kVomqdF7FEFZ2qwwhJA4QT3ebboD4ADAy+q8IRSKRjY3NMH3kkiVL+Hx+ZGQkhmHr1q1btmwZ3l5fX9/V1YU//uc//6lWqzkczuuvv04gELKz+7X6MwAA5zLWpRJVmgnNKtsqA+0Du790v/w+qkAYCSMHkIPsh2B1bwBGO/2JMCgoaMKECS+++OKCBQuGo9P8jTfeeOONN3Qar1+/rn18586dIf9QAEyHm6NbqXUpuZNcUVqB/r60eHpaOkFNkLnLZvjNgH5RANDjukY3btxYVFS0dOlSV1fX7du35+fnj3BYAIDB8GR4drG7EEJVRX/rGpWr5KU3ShFCEm9JpGekYYIDwMjoT4S7du0qLS3NyclJSEg4cuRIcHDw+PHjP/zwQ6FQOMLxAQAGwJvljSfCFkGLSqPStl+7d82sxAwjYTZhNj4sH8MFCIAR6W2wDIfD+fLLLxsaGr7//nsnJ6fdu3e7urqOWGQAgAGjm9FpnjSEELmeXNleqW2/eeomASOI/cXRwbDcBACP9D1qlEajPfPMM1FRUc7OzrBsPQCjhcd4D4QQtZHKb35UvKmssUx6S4oQEk8UP+NhFEUnADAGvSVCmUx24sSJuXPnuru7v/nmmxMnTjxz5syIRQYAGAw/Nz8lXUlSkB4UP8Bbzv14jigjyp3lEydPtDEfrmHhAIw6+hPhrVu3EhMTHR0dV6xY0dDQcODAgdra2jNnziQkJIxwfACAgRlrN1buIkcI8TP5GIZJlJLytHKEUBunLc43ztDRAWBE9E+fWLhwoUKhWLZs2cqVK2fMmDHCMQEABs/fzp/gT0BFSPNAU9Ja8ueffxKFRJWlagxnjM7MQgBMnP5E+P3338+aNYtKpY5wNACAoUIkEAOnB5afKbeosbhw/0LpyVIqoorHiVcHrzZ0aAAYF/1do7Nnz4YsCMBoN8V/itxZTlATKndXUh9QNWYaq5lWsAwvADoMUGsUADAyJjlOoi2ndbG7iEqihqJpeq5pY8xGWH0QAB3DsvoEAMAYkIik/5v/f0mkpK7WLoIVYe3ktQF2AYYOCgCjA4kQgKeZk7XTF/O/qOus82J5WVIsDR0OAMbIMF2jv/zyS3h4OIfD+eSTT3oubczn81955ZWpU6dOnTp1z549EonEIEEC8HSwpdkGsYMgCwLwOAa4Irx3797LL7984sQJNpu9bNkyFov10ksvdd/g7t27dnZ2n3zyCUJo27ZttbW1X3/99cjHCQAAwBQYIBGmpqauXLkyLi4OIfSvf/3r8OHDOolw+fLl2sfJycnalXsBAACAIWeArtH8/Hwul4s/5nK5+fn5PXtHtXJzc/39/R/3KgAAADBIw3JFKBQKCwoKeraHh4dTKBShUMhgMPAWJpMpl8s7OjpsbPRUPszNzf3oo4+uXbv2uA/CMOzQoUPffvtt98Z///vfRlINRyKREAgwVH0g4NANjEqlUiqVarXa0IGMPnK5nEQiDcc65E89Ix/GQaPRiMQ+LvmGJREWFxd/8MEHPdsnTZpEoVBsbGy0B04sFpNIJCsrq54bFxUVzZ8//9ixYxwO53EfRCAQVq1a9corr3RvdHBwoNFog/sXDA0Mw/T+00Cf4NANDJ4ILSwsDB3I6EMmkyERDtho/7UOSyKcNWvWrFmzHveqh4cHn/9oXRg+n+/u7k4ikXS24fP5MTEx+/fvX7x4ce+fxWQyvby8BhkwAAAAk2WAe4QvvPDC8ePH29vb1Wr1F198sWLFCrz9k08+ycvLQwgJBILIyMikpKS4uLi2tra2traRDxIAAICJMEAiXLBgQWxsrKenp5OTE4FAeO211/D248ePP3jwACF0+vRpqVS6b98+b29vb29vHx+fkQ8SAACAiSD0MmJzWEkkkq6uLhaLNZid7N27l0AgJCcnD1VUQ6uzs9Pa2trQUYxKcOgGBu4RDhgMlhkwsVgM9wgHyNLS0tISSl0AAAAwMFh9AgAAgEmDRAgAAMCkQSIEAABg0iARAgAAMGmQCAEAAJg0SIQAAABMGiRCAAAAJg0SIQAAAJMGiRAAAIBJg0QIAADApEEiBAAAYNIgEQIAADBpkAgBAACYNEiEAAAATBokwuHS2tqakJBg6ChGpdzc3FdeecXQUYxKP//884EDBwwdxaj06aefnjp1ytBRjEpJSUl37twxdBSDYrCFeYdEampqSkqKs7OzoQPRQ6lU5ufnT5w40dCBjD6dnZ3V1dXjxo0zdCCjT2Njo1Qq9fT0NHQgo09FRYW5ubmDg4OhAxl9iouLnZycbGxsDB2Ifqmpqd7e3r1vM7oTIULo6tWrhg4BAACAkZo8ebK1tXXv24z6RAgAAAAMBtwjBAAAYNIgEQIAADBpkAgBAACYNEiEAAAATBokwiHT2tq6d+/eqKioqVOnbtq0qb6+XvvSpUuXoqKipkyZsn//fu3oJIlEkpSUxOVy4+PjeTyegaI2ChqN5vjx41u3bl26dKlAIOj+0tdffz1jxozw8PATJ05oGxsaGlatWjVp0qQXXnihtrZ2xOM1UmfOnImIiJg2bdpnn31m6FiMUX19fUpKyssvv7x+/fru7RKJZNu2bVwuNyEhIT8/X9uekZERExMzefLkt956S6VSjXi8RiQjI2P16tVTp06dPXv2sWPHtO1yuXznzp1cLnfevHk5OTna9qysrLi4uLCwsN27d3d1dRki5CeEgSGSlZW1YcOGy5cvZ2dnL168ODQ0FG8vLi62trb+6aefsrOzx44de/jwYbx9w4YNc+bM4fF4H3/8MZvNlkgkhovdwBQKxbPPPrt3715zc/M7d+5o2y9cuMBms2/cuHH16lVbW9vr16/j7bNmzUpMTCwsLNyyZQuXyzVM0EYmNzfXxsbm/Pnzt2/f9vT0/P777w0dkdFJT09fuXLlunXrnJycurcnJibGxsbm5+fv37/fwcFBKpViGFZbW0un07/99tt79+5xOJx3333XQFEbhT179nz22WdZWVlnzpxhs9lHjhzB27dv3z5z5kwej/fFF1+wWKz29nYMw1pbW5lM5uHDh3k83owZM3bs2GHQ2PsFEuGwwC8HGxoaMAxLSkp66aWX8PaTJ0+OHz8ewzCRSESj0QoLC/F2Dofz3XffGSpa42Ftbd09EcbGxn744Yf44+Tk5CVLlmAYxuPxaDQaft6gUCgYDEb3t5isxMTELVu24I+PHj06ZcoUw8ZjtNLT07snwvb2dgsLi4cPH+JPQ0JC8HOId955JyEhAW+8fPmys7OzRqMZ+WiN0J49exYtWoRhmEwmYzAYWVlZePvMmTPxs/yUlJSIiAi8MTMzk8lkdnV1GSrafoKu0WFx//59FotlZ2eHEOLxeFwuF28PCwsrLi5WKpWlpaVEIlFbPCUsLCwvL89g4Rqr/Pz8sLAw/HFYWBjegZyfnz9+/HgajYYQolAoISEhJt6xjNP5msEx6aeSkhIqlern54c/1R46neNZW1vb0tJisCiNyb179/DDVVVV1dnZyeFw8HbtHzEej6f92U6aNEkkElVXVxsq2n4iGzqAUSYnJ0cikeg0Ojs7+/j4aJ82NTVt2LDhwIEDJBIJf8pgMPCXmEymRqNpamoSCoXaRry9qqpq+MM3pBs3bvRs9PX1dXJyetxbuh8lJpPZ2Nio09i93cTpfM2kUmlnZ2efBTVAz69TQ0ODTjudTieRSI2NjfiprSn77rvvcnNzjx8/jhASCoV0Op1IfHQ1xWQyS0tL8XYvLy+8kUQi0en0xsbGPoucGRYkwidz+PDhyspKncYFCxZs2bIFf9zW1jZnzpwVK1asXr0ab6HT6VKpFH8sFosRQjY2NjY2NtpGvL37r/Gp9Pbbb/ds3Lp1a3x8/OPeonPo8ENkgoeuP3SOFZlMtrS0NGxIo8Ljvk7dj6dMJlOr1fA1O3v27M6dO69cucJkMhFCNjY23a8K9P5CMQyTSCTGf+ggET6Zr7/+updXRSLR3LlzIyMj3333XW2jh4dHSUkJ/rikpMTe3t7S0tLNzU0kEjU1NY0ZMwYhJBAIIiMjhzVyg0tPT3/St+CHbtq0aQihkpISDw8PhJC7u7tAINBoNPipqEAgwNtNnM7XzN3dXXuqDnrh7u7e2tra0tJia2uLEBIIBHPnzkUIeXp6dj+eFhYWbDbbkIEa2q+//rp+/fqLFy8GBQXhLa6urmq1uqqqys3NDSEkEAgCAwMRQh4eHnw+H9+moqICwzAXFxdDhd1fhr5J+fQQi8UzZ85MTEzUuamelpbm6ura1NSk0WgWLly4bds2vD0qKurNN9/EMKygoMDS0rK6utoAQRsZncEyBw8enDJlSldXl1QqDQ0NxceqqVQqV1fXkydPYhh27tw5e3t7478VPwJ++uknX19fkUikVqvnzp2Lf7VATzqDZTAMi4iIePvttzEM4/F4lpaWtbW1GIZlZWXZ2triv8o1a9Zox7uZpsuXL9vb22dmZuq0x8fHb9++HcMwPp9vbW3N5/MxDCsuLqbT6QKBAMOwbdu2PffccyMf8JOCRDhk0tLSmH/H4/EwDNNoNK+++iqDwXBycoqIiGhpacG3Ly4u9vf39/DwYDKZqampBo3d8DgcTvdDV1VVhWGYTCZbuHDhmDFjbG1tn3/+eYVCgW+cnp7u6Ojo5eXFZrMvXbpk0MCNhVqtXr9+PZPJZLPZc+fO7ejoMHRERqe4uLj7d2zWrFl4e2FhoZ+fH/5L/Oqrr7TbJycnMxgMFxcXLpdbV1dnmKCNw5IlS7ofupiYGLxdIBAEBQW5ubkxGIyDBw9qt9+/fz+DwXBzcwsODi4vLzdM0E8CVp8YIWKxWCaT4R2hWhiG1dfX29rampmZGSow49fa2kokEnVuM6hUKqFQaG9vTyZD9/5fOjo6FAoFjOl4Uo/7JUql0o6ODliksHd1dXUsFsvc3Lx7o1wub21t7WUonFGBRAgAAMCkwe10AAAAJg0SIQAAAJMGiRAAAIBJg0QIAADApEEiBAAAYNIgEQIAADBpMAcLgFHm5s2bZWVlCCEnJ6fZs2cjhJqamk6fPj1v3jxnZ+fB7//ixYvNzc0IobFjx06ePHnwOwTAyEEiBGCUSU1NPXPmTGhoKJfLxRNhRUXF+vXrr1y5MiSJ8MyZM8XFxdnZ2WvXroVECEwBJEIARh9vb+8//vhjmHZ+5MgRhNAoKJQMwBCBe4QAmAq1Wi0UCtVqtbZFoVC0tbUZMCQAjAEkQgAMTK1Wx8bGBgcHi0QivKW1tTUgICAhIUGj0Qxgh21tbdHR0SEhIeXl5Qih2NjY5cuXf/nll/b29mw2m81mnzp1SqFQbN26lU6ns1iswMDAoqKiofwnATCqQCIEwMBIJNJXX31VV1eXmJiIEMIwbM2aNY2NjSkpKQNYU7CiomL69OlCofDChQuenp4Ioc7OzmvXrh07duyHH374888/g4ODV61atWbNmqampqtXr/76669isVi7jjQAJgjuEQJgeK6urt9++218fHxqaqpMJjt79uzp06fd3d2fdD/5+flxcXH+/v4///yzjY2Ntl0ikZw/fx5fWjYlJSUoKKiwsDAnJwdPtK+//vqGDRvq6upGy1oBAAwtSIQAGIX58+dv2bJl27ZtGo0mKSkpISHhSffw22+/paamLlq06MiRIxQKpftLISEh2gXW/fz8EEKzZ8/WXm7iLVVVVZAIgWmCrlEAjMXmzZu7urqIROLu3bsH8HZ8tOe//vUvnSyIEGIymdrHVCoVIdR9fUe8RaFQDOBDAXgKQCIEwCgolcpVq1a5ublRqdStW7cOYA9Hjx4NDAwMDw8vKCgY8vAAeIpBIgTAKOzZsycnJ+fHH388cuTIf/7zn2+++eZJ98BgMK5cuRIQEBAVFZWXlzccQQLwVIJECIDhpaWl7d+//4MPPpg6derSpUsTExO3bNkygCkNVlZWFy5cmDBhQkRExJ07d4YjVACePpAIATCwxsbG1atXx8TEbNu2DW9JSUnx8fFZunSpVCp90r3RaLTz589HRERER0dfv359qIMF4CkEo0YBMDA2m11fX9+9xdzc/P79+/3fA5fLxTBM+9TMzOz06dPapz2LsXXfGCE0ffp0nRYATApcEQIw+hQUFFCp1Li4uOHY+bRp06hUam1t7XDsHAAjRIAzQQBGl7q6OrwYm5WVlaur65Dvv6KiQiaTIYRYLJZ29iEATzFIhAAAAEwadI0CAAAwaZAIAQAAmDRIhAAAAEwaJEIAAAAm7f8BJc549QbptuQAAAAASUVORK5CYII=", "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "execution_count": 18 } ], "cell_type": "code", "source": [ "u_geostrophic = zeros(grid.nx) # -g/f ∂η/∂y = 0\n", "v_geostrophic = params.g / params.f * irfft(im * grid.kr .* vars.ηh, grid.nx) #g/f ∂η/∂x\n", "\n", "plot_u = plot(grid.x/1e3, [vars.u u_geostrophic], # divide with 1e3 to convert m -> km\n", " color = [:red :purple],\n", " labels = [\"u\" \"- g/f ∂η/∂y\"],\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"u [m s⁻¹]\")\n", "\n", "plot_v = plot(grid.x/1e3, [vars.v v_geostrophic], # divide with 1e3 to convert m -> km\n", " color = [:green :purple],\n", " labels = [\"v\" \"g/f ∂η/∂x\"],\n", " linewidth = [3 2],\n", " alpha = 0.7,\n", " xlims = (-Lx/2e3, Lx/2e3), # divide with 1e3 to convert m -> km\n", " ylims = (-0.3, 0.3),\n", " xlabel = \"x [km]\",\n", " ylabel = \"v [m s⁻¹]\")\n", "\n", "title = plot(title = \"Geostrophic balance\",\n", " grid = false,\n", " showaxis = false,\n", " xticks = [],\n", " yticks = [],\n", " bottom_margin = -20Plots.px)\n", "\n", "plot(title, plot_u, plot_v,\n", " layout = @layout([A{0.01h}; [B; C]]),\n", " size = (600, 400))" ], "metadata": {}, "execution_count": 18 }, { "cell_type": "markdown", "source": [ "---\n", "\n", "*This notebook was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*" ], "metadata": {} } ], "nbformat_minor": 3, "metadata": { "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.5.4" }, "kernelspec": { "name": "julia-1.5", "display_name": "Julia 1.5.4", "language": "julia" } }, "nbformat": 4 }