Chapter07-NumericalStokes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0f82e058",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary packages\n",
    "using PyPlot\n",
    "using SparseArrays\n",
    "using LinearAlgebra\n",
    "using IterativeSolvers\n",
    "using AlgebraicMultigrid\n",
    "using Printf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e25e4c4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "unpack (generic function with 1 method)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Grid\n",
    "    x::Vector{Float64}\n",
    "    y::Vector{Float64}\n",
    "    xc::Vector{Float64}\n",
    "    yc::Vector{Float64}\n",
    "    nx::Int64\n",
    "    ny::Int64\n",
    "    W::Float64\n",
    "    H::Float64\n",
    "    dx::Float64\n",
    "    dy::Float64\n",
    "    function Grid(W::Float64,H::Float64,nx::Int64,ny::Int64)\n",
    "        dx = W/(nx-1)\n",
    "        dy = H/(ny-1)\n",
    "        new(LinRange(0,W,nx),LinRange(0,H,ny),\n",
    "            LinRange(0-dx/2,W+dx/2,nx+1),LinRange(0-dy/2,H+dy/2,ny+1),\n",
    "            nx,ny,W,H,W/(nx-1),H/(ny-1))\n",
    "    end\n",
    "end\n",
    "\n",
    "struct BoundaryConditions\n",
    "    # The intent here is that each boundary gets a flag\n",
    "    # 0 = Free-slip\n",
    "    # 1 = No-slip\n",
    "    # other possibilities?\n",
    "    top::Int64\n",
    "    bottom::Int64\n",
    "    left::Int64\n",
    "    right::Int64\n",
    "end\n",
    "\n",
    "function initial_conditions(grid::Grid)\n",
    "    # Setup the initial density structure\n",
    "    rho = zeros(grid.ny,grid.nx)\n",
    "    etaS = ones(grid.ny,grid.nx)\n",
    "    etaN = ones(grid.ny,grid.nx)\n",
    "    for i in 1:grid.ny\n",
    "        for j in 1:grid.nx\n",
    "            if grid.x[j] < grid.W/2.\n",
    "                rho[i,j] = 3200.\n",
    "                etaS[i,j] = 1.0e21\n",
    "            else\n",
    "                rho[i,j] = 3300.\n",
    "                etaS[i,j] = 1.0e23\n",
    "            end\n",
    "            if grid.xc[j] < grid.W/2.\n",
    "                etaN[i,j] = 1.0e21\n",
    "            else\n",
    "                etaN[i,j] = 1.0e23\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return rho, etaS, etaN\n",
    "end\n",
    "\n",
    "function initial_conditions_updown(grid::Grid)\n",
    "    # Setup the initial density structure\n",
    "    rho = zeros(grid.ny,grid.nx)\n",
    "    etaS = ones(grid.ny,grid.nx)\n",
    "    etaN = ones(grid.ny,grid.nx)\n",
    "    for i in 1:grid.ny\n",
    "        for j in 1:grid.nx\n",
    "            if grid.y[i] < grid.H/2.\n",
    "                rho[i,j] = 3200.\n",
    "                etaS[i,j] = 1.0e21\n",
    "            else\n",
    "                rho[i,j] = 3300.\n",
    "                etaS[i,j] = 1.0e21\n",
    "            end\n",
    "            if grid.yc[i] < grid.H/2.\n",
    "                etaN[i,j] = 1.0e21\n",
    "            else\n",
    "                etaN[i,j] = 1.0e21\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return rho, etaS, etaN\n",
    "end\n",
    "\n",
    "\n",
    "node_index(i::Int,j::Int,ny::Int) = ny*(j-1)+i\n",
    "vxdof(i::Int,j::Int,ny::Int) = 3*(node_index(i,j,ny)-1)+1\n",
    "vydof(i::Int,j::Int,ny::Int) = 3*(node_index(i,j,ny)-1)+2\n",
    "pdof( i::Int,j::Int,ny::Int) = 3*(node_index(i,j,ny)-1)+3\n",
    "\n",
    "\n",
    "function form_stokes(grid::Grid,eta_s::Matrix,eta_n::Matrix,bc::BoundaryConditions,gx::Float64,gy::Float64)\n",
    "    k::Int = 1 # index into dof arrays\n",
    "    nx = grid.nx\n",
    "    ny = grid.ny\n",
    "    nn = nx*ny\n",
    "    nnz = 2*11*nn + 5*nn # total number of nonzeros in matrix (not including BCs)\n",
    "    row_index = zeros(Int64,nnz) # up to 5 nonzeros per row\n",
    "    col_index = zeros(Int64,nnz) \n",
    "    value = zeros(Float64, nnz)\n",
    "    kcont = 2*eta_s[1,1]/(grid.dx+grid.dy)# scaling factor for continuity equation\n",
    "    kcont = 1e20/(grid.dx+grid.dy)*2\n",
    "    kbond = 1e20/(grid.dx+grid.dy)*2# scaling factor for dirichlet bc equations.\n",
    "\n",
    "    R=zeros(3*nn,1)\n",
    "    \n",
    "    # loop over j\n",
    "    for j in 1:nx\n",
    "        # loop over i\n",
    "        for i in 1:ny\n",
    "            dxp = j<nx ? grid.x[j+1] - grid.x[j]   : grid.x[j]   - grid.x[j-1]\n",
    "            dxm = j>1  ? grid.x[j]   - grid.x[j-1] : grid.x[j+1] - grid.x[j]\n",
    "            dxc = 0.5*(dxp+dxm)\n",
    "            dyp = i<ny ? grid.yc[i+1]- grid.yc[i]   : grid.yc[i]   -grid.yc[i-1]\n",
    "            dym = i>1  ? grid.yc[i]  - grid.yc[i-1] : grid.yc[i+1] -grid.yc[i]\n",
    "            dyc = 0.5*(dyp+dym)\n",
    "\n",
    "            # discretize the x-stokes - note that numbering in comments refers to Gerya Figure 7.18a\n",
    "            # and equation 7.22\n",
    "            this_row = vxdof(i,j,ny)\n",
    "            # Boundary cases first...            \n",
    "            if j==1 || j == nx # left boundary or right boundary\n",
    "                # vx = 0\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = kbond\n",
    "                k+=1\n",
    "                R[this_row] = 0.0 *kbond\n",
    "            elseif i==1\n",
    "                # dvx/dy = 0 (free slip)\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = -kbond\n",
    "                k+=1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i+1,j,ny)\n",
    "                value[k] = kbond\n",
    "                k+=1                \n",
    "                R[this_row] = 0.0*kbond\n",
    "            else\n",
    "                # vx1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i,j-1,ny)\n",
    "                value[k] = 2*eta_n[i,j]/dxm/dxc\n",
    "                k+=1\n",
    "                # vx2\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i-1,j,ny)\n",
    "                value[k] = eta_s[i-1,j]/dym/dyc\n",
    "                k+=1\n",
    "                # vx3\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = -2*eta_n[i,j+1]/dxp/dxc -2*eta_n[i,j]/dxm/dxc - eta_s[i,j]/dyp/dyc - eta_s[i-1,j]/dym/dyc\n",
    "                if i == ny #vx4\n",
    "                    # if i == nx, dvx/dy = 0 -> vx3 == vx4 (see Gerya fig 7.18a)\n",
    "                    value[k] += eta_s[i,j]/dyp/dyc\n",
    "                    k+=1\n",
    "                else\n",
    "                    k+=1\n",
    "                    # vx4\n",
    "\n",
    "                    # enforce dvx/dy = 0 (free slip)                \n",
    "                    row_index[k] = this_row\n",
    "                    col_index[k] = vxdof(i+1,j,ny)\n",
    "                    value[k] = eta_s[i,j]/dyp/dyc\n",
    "                    k+=1\n",
    "                end\n",
    "\n",
    "                # vx5\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i,j+1,ny)\n",
    "                value[k] = 2*eta_n[i,j+1]/dxp/dxc\n",
    "                k+=1\n",
    "                # vy1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i-1,j,ny)\n",
    "                value[k] = eta_s[i-1,j]/dxc/dyc\n",
    "                k+=1\n",
    "                # vy2\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i,j,ny)\n",
    "                value[k] = -eta_s[i,j]/dxc/dyc\n",
    "                k+=1\n",
    "                # vy3\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i-1,j+1,ny)\n",
    "                value[k] = -eta_s[i-1,j]/dxc/dyc\n",
    "                k+=1\n",
    "                # vy4\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i,j+1,ny)\n",
    "                value[k] = eta_s[i,j]/dxc/dyc\n",
    "                k+=1\n",
    "                # P1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = pdof(i,j,ny)\n",
    "                value[k] = kcont/dxc\n",
    "                k+=1\n",
    "                # P2\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = pdof(i,j+1,ny)\n",
    "                value[k] = -kcont/dxc\n",
    "                k+=1\n",
    "\n",
    "                R[this_row] = -gx*(rho[i-1,j]+rho[i,j])/2.\n",
    "            end\n",
    "            # END X-STOKES\n",
    "            \n",
    "            # BEGIN Y-STOKES\n",
    "            dxp = j < nx ? grid.xc[j+1] - grid.xc[j]   : grid.xc[j]  -grid.xc[j-1]\n",
    "            dxm = j > 1  ? grid.xc[j]   - grid.xc[j-1] : grid.xc[j+1]-grid.xc[j]\n",
    "            dxc = j > 1  ? grid.x[j]    - grid.x[j-1]  : grid.x[j+1] - grid.x[j]\n",
    "            dyp = i < ny ? grid.y[i+1]  - grid.y[i]    : grid.y[i]   - grid.y[i-1]\n",
    "            dym = i > 1  ? grid.y[i]    - grid.y[i-1]  : grid.y[i+1] - grid.y[i]\n",
    "            dyc = i < ny ? grid.yc[i+1] - grid.yc[i]   : grid.yc[i]  - grid.yc[i-1]            \n",
    "            \n",
    "            this_row = vydof(i,j,ny)\n",
    "            if i==1 || i == ny\n",
    "                # top row / bottom row\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = kbond\n",
    "                k+=1\n",
    "                R[this_row] = 0.0*kbond\n",
    "            elseif j==1\n",
    "                # left boundary - free slip\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = kbond\n",
    "                k+=1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i,j+1,ny)\n",
    "                value[k] = -kbond\n",
    "                k+=1\n",
    "                R[this_row] = 0.0*kbond\n",
    "            else            \n",
    "                #vy1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i,j-1,ny)\n",
    "                value[k] = eta_s[i,j-1]/dxm/dxc\n",
    "                k+=1\n",
    "                #vy2\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i-1,j,ny)\n",
    "                value[k] = 2*eta_n[i,j]/dym/dyc\n",
    "                k+=1\n",
    "                #vy3\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = -2*eta_n[i+1,j]/dyp/dyc -2*eta_n[i,j]/dym/dyc - eta_s[i,j]/dxp/dxc - eta_s[i,j-1]/dxm/dxc\n",
    "                if j == nx\n",
    "                   # free slip - vx5 = vx3.\n",
    "                   value[k] += eta_s[i,j]/dxp/dxc\n",
    "                end\n",
    "                k+=1\n",
    "                \n",
    "                #vy4\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i+1,j,ny)\n",
    "                value[k] = 2*eta_n[i+1,j]/dyp/dyc\n",
    "                k+=1\n",
    "                #vy5\n",
    "                if j<nx\n",
    "                    row_index[k] = this_row\n",
    "                    col_index[k] = vydof(i,j+1,ny)\n",
    "                    value[k] = eta_s[i,j]/dxp/dxc\n",
    "                    k+=1\n",
    "                end\n",
    "                #vx1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i,j-1,ny)\n",
    "                value[k] = eta_s[i,j-1]/dxc/dyc\n",
    "                k+=1\n",
    "                #vx2\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i+1,j-1,ny)\n",
    "                value[k] = -eta_s[i+1,j-1]/dxc/dyc\n",
    "                k+=1\n",
    "                #vx3\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i,j,ny)\n",
    "                value[k] = -eta_s[i,j]/dxc/dyc\n",
    "                k+=1\n",
    "                #vx4\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i+1,j,ny)\n",
    "                value[k] = eta_s[i+1,j]/dxc/dyc\n",
    "                k+=1\n",
    "                #P1\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = pdof(i,j,ny)\n",
    "                value[k] = kcont/dyc\n",
    "                k+=1\n",
    "                #P2\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = pdof(i+1,j,ny)\n",
    "                value[k] = -kcont/dyc\n",
    "                k+=1\n",
    "\n",
    "                R[this_row] = -gy*(rho[i,j-1]+rho[i,j])/2.\n",
    "            end\n",
    "            # END Y-STOKES\n",
    "            \n",
    "            # discretize the continuity equation\n",
    "            # dvx/dx + dvy/dy = 0\n",
    "            this_row = pdof(i,j,ny)\n",
    "            if i==1 || j == 1 || (i==2 && j == 2)\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] =  kbond\n",
    "                k+=1  \n",
    "                R[this_row] = 0.0\n",
    "            else\n",
    "                dxm = grid.x[j] - grid.x[j-1]\n",
    "                dym = grid.y[i] - grid.y[i-1]\n",
    "                \n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i,j,ny)\n",
    "                value[k] =  kcont/dxm\n",
    "                k+=1\n",
    "\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vxdof(i,j-1,ny)\n",
    "                value[k] = -kcont/dxm\n",
    "                k+=1\n",
    "\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i,j,ny)\n",
    "                value[k] =  kcont/dym\n",
    "                k+=1\n",
    "\n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = vydof(i-1,j,ny)\n",
    "                value[k] = -kcont/dym\n",
    "                k+=1\n",
    "                \n",
    "                row_index[k] = this_row\n",
    "                col_index[k] = this_row\n",
    "                value[k] = 0.0\n",
    "                k+=1\n",
    "\n",
    "                R[this_row] = 0.0\n",
    "            end\n",
    "            # END CONTINUITY\n",
    "            \n",
    "        end\n",
    "    end\n",
    "    @views row_index = row_index[1:(k-1)]\n",
    "    @views col_index = col_index[1:(k-1)]\n",
    "    @views value = value[1:(k-1)]\n",
    "\n",
    "    L = sparse(row_index,col_index,value)\n",
    "    return L,R    \n",
    "end\n",
    "\n",
    "function unpack(solution, grid::Grid)\n",
    "    P = zeros(Float64,(grid.ny,grid.nx))\n",
    "    vx = zeros(Float64,(grid.ny,grid.nx))\n",
    "    vy = zeros(Float64,(grid.ny,grid.nx))\n",
    "    ny = grid.ny\n",
    "     for j in 1:grid.nx\n",
    "        for i in 1:grid.ny                \n",
    "            vx[i,j] = solution[vxdof(i,j,grid.ny)]\n",
    "            vy[i,j] = solution[vydof(i,j,grid.ny)]\n",
    "            P[i,j]  = solution[pdof(i,j,grid.ny)]            \n",
    "        end\n",
    "    end\n",
    "    return vx,vy,P\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "97767382",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.008324 seconds (432.02 k allocations: 10.477 MiB)\n",
      "  0.050814 seconds (9.07 k allocations: 19.858 MiB, 29.26% gc time, 9.73% compilation time)\n",
      "  0.000057 seconds (10 allocations: 61.391 KiB)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([0.0 -5.502816557260031e-13 … -3.468084276924002e-13 0.0; 0.0 -5.502816557260031e-13 … -3.468084276924002e-13 0.0; … ; 0.0 5.473309491322802e-13 … 3.4476719268853305e-13 0.0; 0.0 5.502816557254942e-13 … 3.4680842769238986e-13 0.0], [0.0 0.0 … 0.0 0.0; 8.254224835889809e-13 8.254224835889809e-13 … -5.200168166147197e-13 -5.202126415386003e-13; … ; 8.254224835882412e-13 8.254224835882412e-13 … -5.200168166147037e-13 -5.202126415385847e-13; 0.0 0.0 … 0.0 0.0], [0.0 0.0 … 0.0 0.0; 0.0 0.0 … 1.1968501781025352e-9 1.1981473849856892e-9; … ; 0.0 -1.1524182590804905e-7 … -1.163666980806819e-7 -1.1636798053421853e-7; 0.0 -1.1764191443374569e-7 … -1.1883876461184828e-7 -1.1884006181873143e-7])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set up the grid\n",
    "nx = 51\n",
    "ny = 51\n",
    "W = 1e5\n",
    "H = 1.5e5\n",
    "gy = -10.0\n",
    "gx = 0.0\n",
    "grid = Grid(W,H,nx,ny)\n",
    "rho,eta_s,eta_n = initial_conditions(grid)\n",
    "bc = BoundaryConditions(0,0,0,0)\n",
    "@time L,R = form_stokes(grid,eta_s,eta_n,bc,gx,gy)\n",
    "@time solution = L\\R\n",
    "@time vx,vy,P = unpack(solution,grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed00c3d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "sys:1: UserWarning: Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 2 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "L1 = Matrix(L)\n",
    "cond(L1)\n",
    "L1\n",
    "\n",
    "figure()\n",
    "contourf( L1 )\n",
    "colorbar()\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4b2abfeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAEJCAYAAABBt/lpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB0C0lEQVR4nO2deXxU5b3/P+ecWTKZJENCyCYQUAGBIFaUzba4slyWWq2KeFNoLepVpF7g19ZalXpVbN16L9bWcq24ULHXnWopUBekrAapYDBQBBIkIZBlss52zvP7Y2bOPE/mnEwmZJJJ8n2/XnnxzHO+5znLfGd45pzP+XwlxhgDQRAEQRAEkTDknt4BgiAIgiCIvg5NuAiCIAiCIBIMTbgIgiAIgiASDE24CIIgCIIgEgxNuAiCIAiCIBIMTbgIgiAIgiASDE24CIIgCIIgEgxNuAiCIAiCIBIMTbgIgiAIgiASDE24CIIgCIIgEoylp3egO3j22Wfx+OOPo7KyEmPHjsVvfvMbfOtb3+rQupqm4eTJk0hPT4ckSQneU6KvwhhDY2MjCgoKIMsd/51DuUv0NJS7RG+ls7mbyB3q06xfv55ZrVa2Zs0aVlpayn784x8zp9PJjh8/3qH1KyoqGAD6o78u+auoqKDcpb9e+Ue5S3+99S+e3E0kEmN9u3j1pEmTcPHFF+N3v/ud3jd69Ghce+21WLVqVcz13W43BgwYgCG//AUsLFXvl72RGIVrWzxm/SzUFzndiodva5FYrxrZjodvB7jt+yOD+0Ntjy+6DwDj2z4f1x8Zm6mRNlhkX4yQFCXStkQukko2a6RttUVWCPdbI+uBW86skTGYjW9HfpFotsi6WmgcjV9ujfwKVrm2ZuPaFq4d2VV9XZXvs8Ak1rjNhHgW2v/I+6t5PKh48GHU19fD5XKhI3RV7o687QEotpQObZMg2qL6PDj0h4d6JHePlAxBeloSXJkgeiWNTRrOm1ARV+4mkj59S9Hn86GkpAQ/+9nPhP7p06dj+/bthut4vV54vZGZUmNjIwBATkmBzCL/aSncVW5uGgGFmbS14AuLxk2yVL7NTbi4yY9s4dqKn2tzX0JqqM1/L8mRHWQS3wbXDnBtfuUYEy6Jm3BJVuO2zE245FC/zKWbwk24FItx28JNsgzamsV4wiXxEy6TiRi3q5F4bpclC0xiuTYXz0/QYDDh0tfp4O2RrsxdxZYCxU4TLuLs6IncTU+TkZFOEy7i7EiW29J9OpPPnDkDVVWRm5sr9Ofm5qKqqspwnVWrVsHlcul/Q4YM6Y5dJQgByl2it0K5SxDG9OkrXGHazm4ZY6Yz3nvvvRfLli3TXzc0NHTphz+QIum3F4m+jeSTDK9yxTVGF+Su3wlo9g5sq7O72oH1TMc26uf6OrSeUbzZGJpJP2L3x9yPPgrzx44xIpm+d/syimR83UTu29dTOoRVUmMHdSN9esKVnZ0NRVGiflVVV1dH/foKY7fbYbd34H+nTkKTrf7D2Uy2kjF3CaIjUO4ShDF9egpss9kwYcIEbN68WejfvHkzpk6d2kN7RRCxodwleiuUuwRhTJ++wgUAy5YtQ3FxMS655BJMmTIFf/jDH1BeXo477rijp3eNINqFcpforVDuEkQ0fX7CddNNN6GmpgYPPfQQKisrUVRUhPfffx+FhYU9vWsE0S6Uu0RvhXKXIKLp8xMuALjzzjtx55139ug+hO0Y/I6zEM1zN4B5qwe9xQtSO9CWZMEjItLUou80C7G8SJPvl036w9s02yfBzgLGMV2MmVVGTLr56eKuyF0tBUC8rhAxUlQyEa2bjRFL/G42nqTF7ufbYQs50/G4thwwjuExEuGb0emHDsxIFrmnL3aIEV31vdvEOrkD/QQlji8wubu/wHqYJq19i6Pupk9ruJIREs0TBEEQRP+DJlwEQRAEQRAJhiZcBEEQBEEQCaZfaLi6E+GGocHtcsH4VDKOZYLWiY8x0z2FXvDlfgJ8LKfb4uog8mU0hV01EKMIGi6TWorC9mWDNreeqfZL0FZxbTn62JmxBK3NGHw/Okcvlz2oqRpYSpxaBjNdSCxj0Q5op/ixw/orQatlYk5qpNUCAJnzNtRHNtN+qSZts/gYGi7JrBRtJ5UDXa4D6wp8PbtTjVpymVcmG0oCv5+UXv7l1xyjLnB3Q1e4uhnScBEEQRBE/4MmXARBEARBEAmGJlwEQRAEQRAJhjRcCcRIPxRwSLB4wst5UyBjfRZTeB1TZIFkpHuSOY0Ur7PivEiYZqzbEny9jHQpkrEODNZICgl6LiNtF7fPrANtQy8vcHouxWR5vHouqZ2+s6Arild3BVqKBjji1XDxbYOTYaJ5MtJntcVIryXqqbgxzDRXvH7PoDi18Faa6MB4Hy6J+1wY+X11pIh2XAW6Teh6L6+zH5D5e1jDxZTYQf0YpQve465GSRITuabkknDRFa7uJjzZIvo+yTDZIgiCIJIDmnARBEEQBEEkGJpwEQRBEARBJBjScMVDLA1Q2zZHWCPldwAWb9iHi9clMa5t4j9loueCJahx4LVa4b5gsIlui/fnkmPMvQUPMG49XqtltRpvP9zP91m47fHHxfWL+rXotuDDJejeuLap11l0WwoAmtV8edR4PAbbkfwSmLXnbytKjgAkRyBmHIvlvRUcLfiPoOHi63By/ZwWi28LOkI1rMfjhuO1WoKkjxuPOxxmIGfUbIAcKsEnSCW5seUAtx8mtRmNPblYdF/bWDPtSDw1KuMlQVqentZw1avxFgLtX9gk8ikzo5lqKfZv9MkWkXRo1tgx8ZAMk63+itzF9Y6T0pCUIIheBU24CIIgCIIgEgxNuAiCIAiCIBIMTbgIgiAIgiASDInmu5oYYvpAigQlpOMShN6CANxYoC6I3HnRuRZqa8ZCeXH/TITySgxxIS9YVowNVgWzU0EgH2wzK1c4m2/zQnkLd7yCmJ4/DwbL5ejl7bW7w/g0WbA6/FBSjc0jOyKU52PCacU07j0TikpLhm2Y9YeKrDOVy0sz41perK4Zv9+G75uBMSrQ1viUb0eboAqmq4JQPraAnsdQC2byWe20bqyL9WY9LZpvZCSabw+F+wDKSWI4miw0J1nhc7rC1c0oJJonCIIgiH4HTbgIgiAIgiASDE24CIIgCIIgEgxpuLoCM5NMA/1QwMFpuHjJlaBHYsb9vNaJ15louqjJaJdEUYxgYMrvIDNuG62n8KarfJFqXpcVbXJqrtvi+rmxNS5GM9BzmWu1TPRckll/6F9E9wEw1XaZmqAmGc4UP5SU2L+tNAOtVrAd6VdDuaZxGiphPa5fVbn3mNNoaVx/WKPIArx7aez947VYCifTMHxPTAxJJTWywEzPFT4RwnrCeCZFr82UAybxMdfj6aTBaWc1YSzQs+aRjaqjR7ef7MimLrvtoyC5TEETQQtpuPo3pOEiCIIgiP4HTbgIgiAIgiASDE24CIIgCIIgEgxpuLqAjuh9wm01RYLsC/twmWiKLLzehfMn4nVMvI7KauyxpK9npuHivbe0GLc6ZRPtl6C/MvbqCmu3xMLUnD7LGp8PV1jPxeu6NC6TO+LDJXg3hdtnVZw8ui9Zilen2zyw2GPvhwZjXZbKeW6F26rZck6fFVCj1wMAlSsarYW1W7w2jv8daKaLMtHmGcFLXGRet+XnY8wKWUf389ov0/3rSIFrIy2WiazGMLYtCUo1uac1XBr5cLVHT3hvKZ3UjXU3rSwQO6gb6fIrXKtWrcKll16K9PR05OTk4Nprr0VZWZkQs2jRIkiSJPxNnjxZiPF6vbj77ruRnZ0Np9OJefPm4cSJE0JMXV0diouL4XK54HK5UFxcjPr6eiGmvLwcc+fOhdPpRHZ2NpYuXQqfr4sr28ZBeLJFJB+nd2/BkXVPo3T1vShb/QAq3vwjvDXVQkzlW6+ibOUylK1chsP3B/8qnvuNEMMCAZx5600ce/B+HPt/9+LUmj8iUO8WYnpj7vZnkv3/l2PHP8Kekt/i409W4pN/PILP97+M5pbTQkzpwdfxwUc/F/4+LfmdEKNpARw6/C4+2fYwPtr6ID7f/xK83gYhhnKXIDpHl1/h+vjjj3HXXXfh0ksvRSAQwH333Yfp06ejtLQUTqdTj5s5cyZeeOEF/bXNZhPGueeee7BhwwasX78eAwcOxPLlyzFnzhyUlJRACV09WbBgAU6cOIGNGzcCAG677TYUFxdjw4YNAABVVTF79mwMGjQI27ZtQ01NDRYuXAjGGFavXt3Vh070cporjiDrosvgyB0KTVFRvfWvKP/zczj39p9Attn1OOf5FyDvO/N1Y39JEa8wnnnnbbSUliJn4b9DdjpR+/a7qF77shBDuUt0JfX1RzG4YDLSMwaDMQ1ffbUJ+/75AiZPvAeKEvluzcoaidGjrtdfy7KYu4f/9RecOfMlxo6ZD6s1FYePvI8Dpa8KMZS7BNE5unzCFf4QhnnhhReQk5ODkpISfPvb39b77XY78vLyDMdwu914/vnn8fLLL+Pqq68GALzyyisYMmQItmzZghkzZuDgwYPYuHEjdu7ciUmTJgEA1qxZgylTpqCsrAyjRo3Cpk2bUFpaioqKChQUFAAAnnzySSxatAiPPPIIMjIyorbt9Xrh9Xr11w0NDVExRN9k2PW3623NChT823wcWv0APFUnkDr0PH2ZpFhgSc8QKimFL4ConlY07t6NnJtvhmPUSADAoOIFqHjwYT2Wcpfoai4a/wPhluLoC67Htu2PoqHxa2QOGK73y5ICuz3dcIxAwIOTlSUYM/oGZGWdDwAYO/pG/GPHr/QYyl2C6DwJF8273cFbKVlZWUL/Rx99hJycHIwcORKLFy9GdXXk1k1JSQn8fj+mT5+u9xUUFKCoqAjbt28HAOzYsQMul0v/0APA5MmT4XK5hJiioiL9Qw8AM2bMgNfrRUlJieH+rlq1Sr9U7nK5MGTIkLM8A0RvRfO2AgDklFShv+XYv/CvXz+AY79ZhVNvv4ZAU6O+zHviBKCqcIwcpfdZXC5Y83L115S7RKIJBIKTF6tF9LCqrz+KT/7xCHbsehIHy96Ez9ekL2to/BqMqcjKHKH32e0ZcKbm6K8pdwmi8yRUNM8Yw7Jly/DNb34TRUVFev+sWbNwww03oLCwEEePHsX999+PK6+8EiUlJbDb7aiqqoLNZkNmZqYwXm5uLqqqqgAAVVVVyMnJQVtycnKEmNzcXGF5ZmYmbDabHtOWe++9F8uWLdNfNzQ0RD78nPpVEOrGYXwaFM0H25rCCWu5d0LihfKcoFwzEd/GnDULQnlubEH8G0NbJhmL2XkBvSiKjzY5FQXxJqJ5XghvNRHQh9qMF8oLxrFcvyD2h0mMQR8Yqj54F47Bw2HPzddPt3PEBUgfOx5WVya8jbWo2fJXfP3C7zB46TJIFgvUpgZAUaCkpoJxb5KS5kRYo93duTsgxQNrirEIiRfHm7UD3IkJhEXznAjez13q86tKVCwA+ANcjMTFhD5TpvaEfJFs1fg9NnqoQTIRs5sJ6PnPgpE5aqzi1sHtGI8HEzG90f6ZFrLuiIYstC5jDP86/BcMSC9Ehm0Q4Aue3WzX+cjLHIMU+wC0eupwpOLv+Oyz/8WkC/8DsmxBoNkNSVJg12yAN/KO2CypaA61e+J7l4xP26ezxqf9AY+aXKL5hE64lixZgs8//xzbtm0T+m+66Sa9XVRUhEsuuQSFhYV47733cN1115mOxxgTnriTDJ5O6kwMj91uh91uN1zWFcikG+0VVG1+E97qkxj273cL/RlF39Db1nPykXLOEBx94r/Q/GUp0oouNB+wzf+jvTF3id5B2dG/oKnlFC4p+pHQn5c9Tm+npeYiI+0cbNv7JM7UlSFn4NgOj0+5SxCdI2G3FO+++268++67+PDDDzF48OB2Y/Pz81FYWIjDhw8DAPLy8uDz+VBXVyfEVVdX67+c8vLycOrUqaixTp8+LcS0/UVVV1cHv98f9QuMIMJU/v1NNB7+AoUL7oQ1Y0C7sZb0DFgHZMJ/JvhEmJKWAagq1JYWIU5tbtbblLtEovjyq7/gdO2XmDD2h0ixu9qNtdvSkWJ3ocVTAwCw2dLBmAp/oFWI8/kpdwmiK+jyCRdjDEuWLMGbb76JDz74AMOHD4+5Tk1NDSoqKpCfnw8AmDBhAqxWKzZv3qzHVFZW4sCBA5g6dSoAYMqUKXC73di9e7ces2vXLrjdbiHmwIEDqKys1GM2bdoEu92OCRMmdMnxEn0Hxhgqt7yBhsOfo/Dm/4BtwMCY66gtzQi462FJDwqB7YMHA4qC1kOH9JiAuwH+qsh/UpS7RFfDGAtNtkoxYewP4UjJjLmOz98Cr7cBNltQRJ/hLIAkKait/5ce4/U1ork1Yi9BuUsQnafLbynedddd+NOf/oR33nkH6enp+i8dl8sFh8OBpqYmrFy5Etdffz3y8/Nx7Ngx/PznP0d2dja++93v6rG33norli9fjoEDByIrKwsrVqzAuHHj9KcWR48ejZkzZ2Lx4sV47rnnAAQfT54zZw5GjQoKlqdPn44xY8aguLgYjz/+OGpra7FixQosXrzY8EmZzmJmfCpIM3QNV+S2oqkpJ69j4vUivHbKGj1XFnqEItW8wSnX7gINF6/VgokxqxYuNq3weq9oI9O2/cJ54OMtBusJ58+4zT9VaPQ+Vf79DbgP7sXQ7/4Qst0Of3PwSSnJmQLZaoPm8+L0B39D2pgLYUnLgK+hFjWb34eS6oSzKHi7RklxIH3iRNRseBdyRipkZypq394Aa14u/JXBz0J3567L2gKbzVjLoHEnTtBwcScowJ24sJ7Lx2m1fNxyoV+NfL3wRokyn4+wRu0Tn5b8+w7OMNXMNNiQjhSv5kVkQn9Yw8XvFD+e8WfIzEhVrAoeWm722TPrN5DsfHnsL6iq/RwXnX8zrJoCf3M9AMCipECRrQioXhw5+RFyM8fAbk1Dq7ceh7/+O6wWB/LSRkL2BWCDBecMvAiHjm2EDXZYLQ4cOrEZaSmD0OQJPtTUE9+7jSoZn7ZHbzEh7Qk8qj92UDfS5ROu3/0uaKR3+eWXC/0vvPACFi1aBEVRsH//frz00kuor69Hfn4+rrjiCrz22mtIT488rvz000/DYrHgxhtvRGtrK6666iqsXbtW9+ACgHXr1mHp0qX604zz5s3DM888oy9XFAXvvfce7rzzTlx22WVwOBxYsGABnnjiia4+7A5DGq7kpW5f8CmrY+ufFfrz5s3HgPETAUmC91QlGv75KVRPKyxpGXCcez7ybiqGbI/8pzBw3ncgyTKq174M5vcjZeT5yFn07/h6VSTvemPuEsnLidN7AACflq0V+scO+w7Oyf4GJElGU2s1Ttb8EwHVA7s1HVnpwzD+3O/BokS0U6OGzIQkyfj8q9ehan5kZZyLC8/9HraXRj4TlLsE0TkkxjpSM6L/0tDQAJfLhcJfPQyLFHlaRvZGfmHzJUKUiJWMMLlS/AZ9nOu82ObG8HNXBrgYmfu1H47hYyWVaweMr3B1xVOKPXqFS4hF1HKz9aLilfC2jccw7TfZJrOEnhbjyvpoHg+O//QXcLvdXXp1tT3CubvggwWwpdkMY7rrCpcvYBzj9QWvcAUCkf1QfZHlGteWPJEY2RtpK57IvlpC8iMLJ6Hj27amyHtia4hc1urtV7jaHSeesQ0IqF58sO+xHsnd6rJC/M7XzsMoBF3hagdPkx8PT97UrbnbHlS8miAIgiAIIsFQ8erOYqbbMiqKzPWrKZErWOIVEu6RauFXM9dv/CM7siHeGoz38pL5sbmrTMzkV3vYz0fQgXGbk4yvZBl5ZQGAFvbhMtGpmV7tMilOHblixvUJbTNPLn773PEY+HCJxZG5/jjaUkDSr3b1JFm2VthNNFyqifeWnztB/BUuf/gKl8JdveKuZHlkvh1JKoXrl7grwiy0TcZ9FWlc0WuJ86qDwXsWDOLGMyoiburDxfVzV4wlA38u8YqVmd+WcQxifM7Eq15dcFXrbG5aGPmE9bCXUZNKdhHtIUs9/x2TrHhVJXZQN0JXuLoZhTRc/YZkmGwRBEEQyQFNuAiCIAiCIBIMTbgIgiAIgiASDGm44iBeLY+RfiiQwj3VqBnrtkQ9V2QMXhbCz5TDwzCurqFQJ46vJ9iBJ6mMboSZ1yeM1mpFxYdrH5rps3jfLN5fiddtCevy/dHjmflwmemywvsqaRGtmPBem/wsMdIL8SSLhmuApRkplmi/KwBQ+acUueQV6iOy6LaXE9W1ypGxLUKbe8LWRGcSTke7JYAWX/BJSs0SWU/jnl6EzPtwmdQ1De+nE7CG6zKbPFVoptuSA8YfuvC6Yt1F7rj4fkG3xY+H6JiOaLhMdGA8MZ9S7KS2S1JNK112C/+VU4L/rJzao/vQG1EMv8n7F75Acl1TSq696QfIyeXD1qvRulgPqXXxz49kmGz1FsKTra5Cn2x1EcLEiuhWaLJF9BVowkUQBEEQBJFgaMJFEARBEASRYGjCRRAEQRAEkWBINN9JmInZoqnRZihGtQFyyEdQEH9rJsJ2E2U23y2HhOa8mJfxgmDFWBwvdUCIG9kIt22hcLBZAelogbyZ8F4sl2M8nmYghDcT0psWrzZ7b8Jts/cxhrFmcN3k1fgMsLTAYTH+qPNmpyr3JhsJ5QHAqwVF8R4tIo63SirXji2UF7YZetDCr0XGCHDGp7ISGU/lTHYFnXyshxd441Pe7LQDQnm9hJYgnjcpj9WRsllGbbPPpPD5jFNY35nlZmg9a3zaHCDj096GnCTlhnw9+7xHFHSFq5uRe/a7iyAIgiCIHoAmXARBEARBEAmGJlwEQRAEQRAJhjRcXUFHjE9DMhhV4TRcvCyDNx41k25wwhW+8C5C3l4Stz2hzRus8jIOYXC0j2AEalYcun0zU0FbZab3MtFZGem1zIpRm23HqJg43xZi4y1YbUCyGJ+65FakKsamZULxahMNF6/XSpGCycvrthTE1m3xBDgxXbjtkyPb49sBIad5s1NuQEGkFXYB5pabFK8W9VcGui0AkhpaQTXWcJn2m5mdagZasVgar7ZoJl8csdYzGyNmbM+aBzaRhqtdZDI4NcVPxqf9G9Jw9R+SYbJFEARBJAc04SIIgiAIgkgwNOEiCIIgCIJIMKThigczrZaJbksy0AmZ+nAJd584vZJQJ9pAqwKAhfoFrZZqXBhbkNgwE22XAWaFu819uKJjTD3KOqDbMtJfaSaFqTUT3ZaRlxcfY7YfAmbvu1FblQCl528rDlCa29FwmXlvRb4a7FJEw+NlQT2XLPhtcW1O06QJ+rBI26dExvaF3hQL57fFt30yL4DijkHi9Vzti+kks4LtKrffAWM9l6DRChVxNvPeMi1erZoJNLXo7XVIzBmHD1e83luagSash324WgLGhdeJIKThMscfSK5zQ1e4uhnScPUjkmCyRXQN4ckWQRBEZ6EJF0EQBEEQRIKhCRdBEARBEESCoQkXQRAEQRBEgiHRfCfhRdKSiWheEF4bGJ/yOliZeyd42SqnSYfGC+U5E0gpJC7nzVB5fbGZ8SNPrFqjZqagpqJ5g3NiZpIajzmp+Xix24i1HdNj5NpxGJ8mCy65FU45chC8UF7jnuxQuQPysIhQmRfQe0JFpnmhrmJS+ZwXzfOC/BQlIsL3qMGxrUokeWUut/m28GRHPD8VTU1QjUXpElfIOmxU2iGhvNBvZoJqIJA3E9V3yATVZN1Y6wljxIjRela/1uon0Xx7SB0wG+6vBAIx/mPrZugKVzdDonmCIAiC6H90+YRr5cqVkCRJ+MvLy9OXM8awcuVKFBQUwOFw4PLLL8cXX3whjOH1enH33XcjOzsbTqcT8+bNw4kTJ4SYuro6FBcXw+VyweVyobi4GPX19UJMeXk55s6dC6fTiezsbCxduhQ+n6+rD5noI5z5cCPKVi5D2cplOPRA8O/Irx/UlzPGULNlI46uWokjD/wEXz/3W/iqqoQxWCCAmjffxPH778ex/3cvTq35IwJt8pJyl+hqDjfuxsZTvxP+Pji9Vl/OGMPhpj348MxL2FS9Brvq3kFjoFYYQ2MqSpu24e81L2LzmedR0rARHrVJiKHcJYjOk5BbimPHjsWWLVv01wrnAfTrX/8aTz31FNauXYuRI0fi4YcfxjXXXIOysjKkp6cDAO655x5s2LAB69evx8CBA7F8+XLMmTMHJSUl+lgLFizAiRMnsHHjRgDAbbfdhuLiYmzYsAEAoKoqZs+ejUGDBmHbtm2oqanBwoULwRjD6tWrE3HYRB/ANigPQ75/B3ebMfKbpO6TD1D/j4+Re/3NsGYPQt1Hm3Hyf3+Pof/vZ5AcwXpvZ955Gy0HS5FTXAw5PRW1b7+LU3/4I/KW3KGPQ7lLJII0JROXZs7TX0ucBOFoyz4ca/0c49KvgNMyAEeaS/Bp/V/wraz5sCB4y+5g83ZU+45jfPpVsMkp+LJ5B0oaNmJixhx9HMpdgug8CZlwWSwW4apWGMYYfvOb3+C+++7DddddBwB48cUXkZubiz/96U+4/fbb4Xa78fzzz+Pll1/G1VdfDQB45ZVXMGTIEGzZsgUzZszAwYMHsXHjRuzcuROTJk0CAKxZswZTpkxBWVkZRo0ahU2bNqG0tBQVFRUoKCgAADz55JNYtGgRHnnkEWRkZBjuu9frhdfr1V83NDREFsZZ0NjIBFWzAXrdX14Wwg0h6Ll4rZgwHm9sGhpOYVF9wQXRsW3pvPGpcQyv0QrHm2qrOqCBM9zOWWi4DDVhEiApMhRXRtTxMsZQv30rsq64GmnjLgQA5My/GcceehCN+/YiY+oUaK2taNyzG4MW3AzHyJGAwjCoeAEqHnwYnsNHAABlZWXdnrupkh9OIXkiTV63xeusrIjodjyIaGhkuX1NhMoXwOYSOZXTbfm0SL8tpN2ycgJEhduGJGi4ELtt3hXs54cz0V8ZFqc+G90W7+FlpNcy02qZ6bOMDFE1BgkSbMzGxQFMC4AxhmMtn+PclIuQqwwFGDDO8W186FuHky1lGGIfDT/z4YTnS4xLnYaBcvC7e5zj2/i44TXUeIN3F3oidwHAQ8an7UIaLnP6hYbr8OHDKCgowPDhwzF//nx89dVXAICjR4+iqqoK06dP12PtdjumTZuG7du3AwBKSkrg9/uFmIKCAhQVFekxO3bsgMvl0j/0ADB58mS4XC4hpqioSP/QA8CMGTPg9XpRUlJiuu+rVq3SL5e7XC4MGTKkC85IBIn8E5MaX80ZHHl8JY4++TAqX3sJ/toaAECgrhZqUyNSR4zSYyWLBSnnngfP8WMAAO+JE4CqwjEqEmNxuWDLz4P3eDkAYPfu3b02d4nkpkVtwEe167C17lX8s/HvaFGDk5ZWrRE+1opsyzl6rCwpyLTkoT5QDQBoCJwBgybEpMhOpMmZcKunAVDuEsTZ0uUTrkmTJuGll17C3/72N6xZswZVVVWYOnUqampqUBXSu+Tm5grr5Obm6suqqqpgs9mQmZnZbkxOTk7UtnNycoSYttvJzMyEzWbTY4y499574Xa79b+Kioo4zwDRW3EMLkTedTdj8PdvQ+61N0JtakTFmv+B2tKMQGPwPy8lLV1YR0lLhxpapjY2AooCJTVViJHT04PLAJw6dYpyl+hyBlhzUJR2OSZkzMJY57fh1Vqxy/0ufJoHXtYKALDJDmEdu+SAV2sBAHhZCyTIsMp2MUZO0den3CWIs6PLbynOmjVLb48bNw5TpkzBeeedhxdffBGTJ08GIGoLgODtmrZ9bWkbYxTfmZi22O122O120+VE38U5crTetklAypBCHHv6UTTs3YOUIYWhJW1zhxn0tQ1hgncI5S7R1QyyDQXj6jC6rDn4pO41nPQdhssSnCRJbfI0VIE15tjC3VvKXYLoNAn34XI6nRg3bhwOHz6Ma6+9FkDwV1B+fr4eU11drf8qysvLg8/nQ11dnXCVq7q6GlOnTtVjTp06FbWt06dPC+Ps2rVLWF5XVwe/3x/1C6xTmBXP5b9TjAonK6JfltF6vO2NIL0x69fC//JiqOjlbfuFzcfw6zE7RmZyvIYFvU20WqYaLn4HTDRX7S1vr20Wz++TbLfDlpsPX80ZOMeOAwAEmhqguCI6FLWpCUroYQ8lPR1QVagtLcGrXKHi1VpTE5QhgwEEr9R2d+6myQGk8z5c3AnnLZh8XKJYGaep4v4j59uR8YwLYHtlrug1r9uSrVw76JNi4XRbCvfZ4gu283queFQrgm5L8MHi+lVjjZSu0eoq3ZaRLkszWc7tKz+ZMvXN4sazQEK6nImWQD1ylODtOW+gCXbFrsf6tBbYYQcCAdg1Oxg0+AMtsEqRiY9Xa0WGlAWgZ3IXADwBsovsK8jdrDdTk6wGasJ9uLxeLw4ePIj8/HwMHz4ceXl52Lx5s77c5/Ph448/1idTEyZMgNVqFWIqKytx4MABPWbKlClwu93YvXu3HrNr1y643W4h5sCBA6isrNRjNm3aBLvdjgkTJiT0mNvDcLJFJCVaIAD/6VOwpKfDkpkFJT0dLf86pC9ngQA8Xx1BSuEwAIB98GBAUdB6KBSjMATcDfBVVsFeOBQAMHHixF6bu0TvQWMqmrR62ORUOKQ02CQHagInheV1gSoMUIJXvzKUgZAgCzFerQVNWj1cSjYAyl2COFu6/KfDihUrMHfuXAwdOhTV1dV4+OGH0dDQgIULF0KSJNxzzz149NFHMWLECIwYMQKPPvooUlNTsWDBAgCAy+XCrbfeiuXLl2PgwIHIysrCihUrMG7cOP2pxdGjR2PmzJlYvHgxnnvuOQDBx5PnzJmDUSHB8vTp0zFmzBgUFxfj8ccfR21tLVasWIHFixebPilD9G9Ob3wXzlFjYB2QiUBLE2o/2gzN60H6xZdCkiQMmPpt1H24BdaB2bBmD0L9R1sgWW1Iv+gbAADZ4UD6xImoffddKKmpIVuIDbAV5CNlxHkAgFGjRlHuEl1OWcsuDLIOQYqUBp/agq98/0SA+XGO9XxIkoRC2xh85f0cqXIGUuUMfOX9JxTJgnzruQAAq2TDYOsIlHn3wCrZYZXsKPN+inR5ALKU4FOLlLsEcXZ0+YTrxIkTuPnmm3HmzBkMGjQIkydPxs6dO1FYGNTA/OQnP0FrayvuvPNO1NXVYdKkSdi0aZPuwQUATz/9NCwWC2688Ua0trbiqquuwtq1awU/r3Xr1mHp0qX604zz5s3DM888oy9XFAXvvfce7rzzTlx22WVwOBxYsGABnnjiia4+ZKKPEGioR+Xrr0BtaYaS6kTKkEIMvv3HsGYGb6kM+PaV0AJ+nHnnDWitrbAPGYr8xbdBTknR704NnPcdSIqM6pdeBvP7kTLyfOTe8kNI3C09yl2iq/Fozfi8+SP4mAc2KQUuZRAmO+fAIacBAIbbxgWNTT07EGA+uJRsTHBMh0WK3N4dZb8UEiT8s/VjqAhgoJKPIsfVkCTKXYLoCiTGOlJsq//S0NAAl8uFwl89DNkaecpH0FOpEU2MUM+Qb/PSF66tx3N9ZusJ7RgaLTPdluktdLN+A52rqSdXB/RcuidXB8boiM7LyOMrbq2Y0f51yDPMuLafqBULxmgeD47/9Bdwu93d9ks/nLtfHsxFerqxekDl3ng/dzh+7qR4OF1WM1djsVkLan0atRS9r1GLfEbq1cjTmnUBZ6Ttj/TX+iL9td5gf60nstzdEhnb0xLxmNKaIvuhNHH+YQ2R/baFrJzsdZEDc9REPlwp1a16W6ifGDDWYgk6r0Cov7O6rbbxoX7G92nGujJhPB4uhhnFdPKrPsB8+KD1tR7J3eqyQmSky/jGru93y3aJvoXa4sWhWx7r1txtD6ql2N0YTba6iq6eOnd1ceb+Np7cd3/LhCdbXUV4stVVhCdbXYXhZKur6OLfvIaTrV4MTbaIvgJNuAiCIAiCIBIMTbgIgiAIgiASDE24CIIgCIIgEgw5ynWWDhRzNtRUyZF+XmkhmY1nIo6PSyhvsBum+9cRjP1Vzc+J1E4fEFNgb7aumZjd9P3gMNp+xwT7xieWdbX+qwuxSzLskvGJ0Lh3UOHasvDOqlwreKAqN55fjojW/SzylWLlnv6wcyaoVs7k1BISMspmZqdxFKzuCMJDI8LnxUygHvrXqOg0IArb4xXKh+JNTU07UMiamW3HaDweAwNbU+KJTQCBgBI7iCAMUAPJdU0pufamP9B3ddQEQRAEQZhAEy6CIAiCIIgEQxMugiAIgiCIBEMarq7ArJC1mcZIa6cP5rots35dw8Wi+6La/C7FcXvTVKPUERNUo3U7EBtLzxVzG2hHixXPeJKJIC6WjkiTksKLyy4pSOE0VyqXSJpplXMYxlhDiWrj9Fl8oWurFNDbNq7N68Ms3LrhQtV88WrJRM8VFx0w+5WMtFqAWLw63DbVeEWbl0a1DQxOg83QRrUOxJpptYw0WiaaK9ZJPRdjPVsANuAnDRfRObQkyx26wtXd9C1PQqI9kmCyRRAEQSQHNOEiCIIgCIJIMDThIgiCIAiCSDCk4YqHDng9SZx4RNBzhW8lcj5cgm6LC+U1J1zdYFM9l5FGy1TPZUIsqUxHNFwxY8x0VnH6Kxn5esW1H2bbFLR4JvsUh8YMTIpPKJcgLFBg4X5b8booTUhCbiUu2fgC17aQ3sfP6bBsBposQPTh4tsKt82w35e5D5exJxfryPtthInPlWSmvwq3FZkrWG2ioeqAb5bhuibb7pBuy0B/xWIsbzfeaHkX13qMl2TT4SQfPf8dk6xo5MPVz6HPRv8hCSZbRBfR1QWrCYLod9CEiyAIgiAIIsHQhIsgCIIgCCLB0ISLIAiCIAgiwZBovpMIIne+XyhebWKYGVpZENubaG+FfrPpsYHxaU+rhwyFzB0xT401hkl8h4T3ZqL4mOt1YJ+SGEWSoXDGp7wEWTVJZN4cVeEWyKGmwi2XBRG8SVvi28ywP7KesWi+Qxi9P2ZDxCpYDcRlLNoRhELV4W1qJuPFIZQPdrOOLY9eYNzf0eUJhvl74YeuW+kD5ydBh8BINN/P6Y3/YxMEQRAEcVbQhIsgCIIgCCLB0ISLIAiCIAgiwZCGKx7MtEYmMca6LGOhleA5aabFMrsdGUPmkkg7qA7dIY3nLmoHdjbmNuPUinV43LMYuyeRIUE2+W2lCporXufF94PrjzYqVTgdltiO/V6Gx5G7wp23I3R2CDPzz1iGqYCxDsxsM2Z6LtP4OExQxQVxbacnkfx0XYDoHJIvuXInufaGIAiCIAiiD0ITLoIgCIIgiATT5ROuYcOGQZKkqL+77roLALBo0aKoZZMnTxbG8Hq9uPvuu5GdnQ2n04l58+bhxIkTQkxdXR2Ki4vhcrngcrlQXFyM+vp6Iaa8vBxz586F0+lEdnY2li5dCp/P19WHTPQRKv7rYRxdtjzq78wbbwAATr/6Ko7+53Lh7+Rv/lsYgwUCqHnjTRy/734c+3/34tSaPyLQJi8pd4mu5hP/u9gceC3q70utBADwhbYbW7Q/R/7Y69jNPhDG0JiKL9ln+Ji9iw/YW9jH/gEPaxFiKHcJovN0uYZrz549UNVI3bEDBw7gmmuuwQ033KD3zZw5Ey+88IL+2mazCWPcc8892LBhA9avX4+BAwdi+fLlmDNnDkpKSqAoQRehBQsW4MSJE9i4cSMA4LbbbkNxcTE2bNgAAFBVFbNnz8agQYOwbds21NTUYOHChWCMYfXq1Wd/oB3wfepszVfz9To3YI9ruLqaBG2zYPk9gobGX1mFqt89B+dF4/WfJo4LLkD2gpsiu6JYhP2pefNttHxRipzvF0N2pqL2nXdx6g9/RN6SO/SYHs9dDt6fS2Ox6wV29heago5rhuL23upNGPp6nf3xTrJMBwu9f0xjaEIDPmMfI0caoscMRC7G4FL9dVtdXxn+iTOoRBEmwQobDuNz7MM/MAHT9JieyF2JfLiITpJsudPlE65BgwYJrx977DGcd955mDYt8qG12+3Iy8szXN/tduP555/Hyy+/jKuvvhoA8Morr2DIkCHYsmULZsyYgYMHD2Ljxo3YuXMnJk2aBABYs2YNpkyZgrKyMowaNQqbNm1CaWkpKioqUFBQAAB48sknsWjRIjzyyCPIyMjo6kMnejlKWprw2r3lA1iyByLl/PP0PsmiwGKSO1prKxp37cagW26GY9RIQGIYVLwAFQ8+DM/hIwCAsrIyyl2iy7FJKQg7tjKJ4Zj2JRxIQyYi38cyFNilFMP1A8yPkziKsZiIgVIuAKCITcQneA91OA2AcpcgzpaEarh8Ph9eeeUV/PCHP4QkRWaaH330EXJycjBy5EgsXrwY1dXV+rKSkhL4/X5Mnz5d7ysoKEBRURG2b98OANixYwdcLpf+oQeAyZMnw+VyCTFFRUX6hx4AZsyYAa/Xi5KSEtN99nq9aGhoEP6I/gcLBNBUUoL0SROF3PX86wiO/+JBVDyyCqfX/xlqY6O+zFtxAlBVOC4YpfdZXC7Y8vPgPV4OANi9ezflLpFQNKaiCsdRIA0TcrcOp/Ex24DtbCNKWQl8zKMva0AdGBgGIlfvs0sOpMEFN2oBUO4SxNmS0AnX22+/jfr6eixatEjvmzVrFtatW4cPPvgATz75JPbs2YMrr7wSXq8XAFBVVQWbzYbMzExhrNzcXFRVVekxOTk5UdvLyckRYnJzc4XlmZmZsNlseowRq1at0vUJLpcLQ4YMMY0l+i7N+w9Aa/UgbWLkFoxj9AUYVHwL8u+6AwO/Mw++8gpU/vb3YIEAAAQnX4oCJTVVGEtOT9cnZqdOnaLcJRLKaZxEAH4UYLjeN1DKQxEmYgK+jRG4EA2oRQm26reRffBAggyrJMo7bLDDh+DEjHKXIM6OhE64nn/+ecyaNUv4tXPTTTdh9uzZKCoqwty5c/HXv/4Vhw4dwnvvvdfuWIwx4dca3z6bmLbce++9cLvd+l9FRUW7+0X0TZp27oJj9AWwuFx6X9rF30Dq2DGw5ecjtWgscm9fDP/p02j5orT9wRgDKHeJbuJr9hUGIg92yaH35UlDkS3lI01yYZBUgG/gm2hBI87AfBIUgXKXILqChBmfHj9+HFu2bMGbb77Zblx+fj4KCwtx+PBhAEBeXh58Ph/q6uqEq1zV1dWYOnWqHnPq1KmosU6fPq3/usrLy8OuXbuE5XV1dfD7/VG/wHjsdjvsdrvxwjjFvKbFpruZhArb+5C+Ofz2+mtr0XroMHJuXdjue24ZkA5LZib8Z04DEoOSkQaoKtTWZuEql9bUBGXIYADBK7U9krsmqHEaYHbWLlON47cd68v1RmXu2NRw1fmuO95W1oxaVGO8fBkkWRKNT7kHJOxwIIU50YLglVcbUsCgwc98wlUuH7xIR/B7uKdyVwr04XwgEoqkJlfuJGxK8MILLyAnJwezZ89uN66mpgYVFRXIz88HAEyYMAFWqxWbN2/WYyorK3HgwAF9wjVlyhS43W7s3r1bj9m1axfcbrcQc+DAAVRWVuoxmzZtgt1ux4QJE7rsOIm+R9OuPVDS05A6ZnS7cWpzM9T6eighIbB9yGBAUdBadkiPCbgb4Kusgr1wKABg4sSJlLtEwjipHYUNdmRL+e3G+ZgXXrTAhuBVsAxkQoKEWkQmVF7Wiia44UIWAMpdgjhbEnKFS9M0vPDCC1i4cCEslsgmmpqasHLlSlx//fXIz8/HsWPH8POf/xzZ2dn47ne/CwBwuVy49dZbsXz5cgwcOBBZWVlYsWIFxo0bpz+1OHr0aMycOROLFy/Gc889ByD4ePKcOXMwalRQsDx9+nSMGTMGxcXFePzxx1FbW4sVK1Zg8eLF9KQMYQrTNDTu2oO0Sy+BFLIgAQDN60XdXzfBOX4clIwMBGprUfeXv0J2OuG8sAgAIDscSJ88EbVvb4CS6gzaQry9AbaCfKSMCD7pOGrUKMpdIiEwxnCSHUWBNAwydzUrwPz4in2BHGkw7HCgFc04gs9hhR05CMo9LJIVBWw4DuFzWJkNlpAtRBpc+pOOlLsEcXYkZMK1ZcsWlJeX44c//KHQrygK9u/fj5deegn19fXIz8/HFVdcgddeew3p6el63NNPPw2LxYIbb7wRra2tuOqqq7B27VrdgwsA1q1bh6VLl+pPM86bNw/PPPOMsK333nsPd955Jy677DI4HA4sWLAATzzxRCIOmegjtB46DLWuHumTJ4oLJBn+ykqc2vMptFYPlIx0OEacj5xFxZBTIo/aZ313HiRZRvXal8H8fqSMPB+5t/wQkhz5D5Byl0gEtewUPGhBgXyu0C9BQhPcqGTHEYAfdqQgE4MwDpNhkax63EiMhwQJ+7ELKlRkIQdjcSkkTsNFuUsQnUdirAtc9/owDQ0NcLlcKPzVw8J/rPEWOjaMN9MHxVsgOWYx5x52Po1n8x2JjRVjsk8xT8NZnKZYY2seD47/9Bdwu93d9ks/nLs1h4YjI92keDWn4QogYnzq4UxQvVxMc+g4W7TIj58GLaK9qdci2rV6NdKuVSMeZ2f8kR9Xp33B/tPeSF9Na2S9utaI8LupKdIONEUmCkpjZF9sDcH33lavdyGlNvLmOM4EIv1VzXpbCnDqNK4tBULngS8qHYiMAZXr52M482e+n/H94XX59bivYyE2RpHqYDfr2PLoBcb9IQLMj4/wTo/kbnVZIaa8/eNu2SbR99A8Hhx98OfdmrvtkSSyboIgCIIgiL4LTbgIgiAIgiASDE24CIIgCIIgEkzCfLj6IqZyJTOtFi/sMSp23YFY0/EMtm9q59MDGi5DZaDZbsSruTIcmz9pxisK3bHGMNsPMxkMt2qy1V5WmaZbPgGAxh2Exjlr+TktDx+j8vGhA1W5JNW4322mbca3JcP+yHqR5XF7chmde9PPhWTc5ncp7JvFy5wkPiA+ZzKJW5eFE4V7oELQfpntk8a94N4zKbSvLMbytgjxhsg96rcn+3tu20Q3kaD8Yr7EjNtZ6ApXd5NcPmwEQRAEQXQDNOEiCIIgCIJIMDThIgiCIAiCSDCk4eosZjor2US3ZdDPTGJFaQkXI0yPTbZjtF4HbmNKMYRHploaZhwjGcaYjcEPwvfH0IeZaKs6pP0SNF9cw2BshljHldwEoCLAa7IYr+GKtP2Cnovr547TF0pCP4t4X/m4tsqdVz6Gb6uCzisYL+q6jDVczOQ9jkszJxt/0JhZ8eVw22oBwp5c/BiyyRcBr8tiJp/hcLygD+P2gxuD8V5dZnoufT1+wMh5N/PhEuMNljMJnEVbtyMHYsf0a3rJ91BPwHowb42gK1zdDWm4khf64iLMCCTZNzdBEL0OmnARBEEQBEEkGJpwEQRBEARBJBiacBEEQRAEQSQYEs13ElOhvGzcbxQvma3HiYkkM2E916/rbCW+z2B5G2IJ5YU96oDBqRBjInaOdJqtF7tf0p86MNsRbtu8HpgX9RsJ9U22JxQU1mIL6MPDJIsBqpep8JiYwQqieS7GJ4jmeSG8HFrOCeLBi+MjXyk+rs0bpQYMRPYBTvzNTAT0cRGrcDzaCOUFIXq0mN5QSA8AcuRYhALTfIzCxXDGpmETVGYicufzTtg+n4+SUeFr432SuG7xg8EviEZiWs+K5pPMvJLoPbAkM82lK1zdjZwk/wsTBEEQBNFt0ISLIAiCIAgiwdCEiyAIgiAIIsGQhqsrMCkwzRubSkbaLtlYq2Woz4JoUCgbaLtkUw2XieFhJ+UxZrotoQ2DGJP1NM1YcMNMDFHD6zLNRHPFIRyjMAbXHxpH0HVpJieHf395Q9QkvlPsZRpsJvunChoucO3IsXk4zZUnpMvyMGukT+PaXD9vdurlYvycXiugBWPMjU+5ne1AEfFYiFpKrq2ZabRC/ypmRqa8Vsvk9ytvWqpE66Uk4XPDiaV4mRVvpMqNJynRmi/BJFUxK+revm5LoIfdI6l4NdFZSMPV3yENF0EQBEH0O2jCRRAEQRAEkWBowkUQBEEQBJFgSMPVWUyKQzNuCivotpToaruyohnGiv2R9XiNlszpuZSwr5ew3Hg9Mz2XbCCK0UwKP5r5JAkSKE6nE44xWy4LMhTeQ8t4bKaF/YuM/bEEnyKTYxDsiwy2IaylGWh6AHPfpVA3k5JD2+VhDFbu4HhPLP7983EH5+cS2cP5aYU1WoKGi9kibU6rJeq2jAtZB0LbCXDbU008ucx83mLquSTjNuN0Ufzngim8Ni+cawACwaSRzLRaHcFIz8VrsvhYfp943ywz8SULfw90QJxp4stmhMTi0HslACpeTXQWlmS5Q1e4uptk+B+Y6Bbore5DBLTYMQRBEO1AEy6CIAiCIIgEQxMugiAIgiCIBEMTLoIgCIIgiAQTt2h+69atePzxx1FSUoLKykq89dZbuPbaa/XljDH88pe/xB/+8AfU1dVh0qRJ+O1vf4uxY8fqMV6vFytWrMCrr76K1tZWXHXVVXj22WcxePBgPaaurg5Lly7Fu+++CwCYN28eVq9ejQEDBugx5eXluOuuu/DBBx/A4XBgwYIFeOKJJ2CzRUS8+/fvx5IlS7B7925kZWXh9ttvx/33398xYWlbTMS3YvFqkzYvaFfC4ttIn6IYm5ry4niLSYwSilEkY6G8wo1hKpqPITjSTMTLfL8odo6YJaoh4bFgbskJhZkwBrcd2UScHxKrm5mnCgJ6rtlaehQN72+F79jXUOsbMWhpMVInjIWEsGEk4H5nC5o+3gWtpRW24UORect3YM/Pj4ztVVH3xl/QvOczML8fKaNGIGv+d2FxZUb2pbkFta+/jZYDpQCA1KIxyJozCzzdmbtNmgXQjH9b8QJ6XszuE8xOo41NWzR7pM/E+FQQ0HP9Ps0S1eaLV6tmD2WYmdHGQNDXy8a5IQrl+RwM7hf/WWXc79ROegeHBgqNKRitGhuc1nmrcLR5HxoCp+HVWvAN1wzk2ofrD24wxvCvlk9xwvMl/MwLlyUHY5xTkSZzeclUlLXuQqXvCDSmIstagDGplyFFduoxftWDg607cNpfDgAYZB2KEY5LhN3u7u9dMj7tQ3SzrrXXG582Nzdj/PjxeOaZZwyX//rXv8ZTTz2FZ555Bnv27EFeXh6uueYaNDY26jH33HMP3nrrLaxfvx7btm1DU1MT5syZA1WN/Ce9YMEC7Nu3Dxs3bsTGjRuxb98+FBcX68tVVcXs2bPR3NyMbdu2Yf369XjjjTewfPlyPaahoQHXXHMNCgoKsGfPHqxevRpPPPEEnnrqqXgPu8vgn0Akuhfm9cE6NB9ZxfMMlzf89WM0bPoEWf9+LXJ/cTcUVxpOP/W/0DwePab2/95By74DyP7RLchbfhc0rxfVv/uj4O595sV18H19Enl3/Ah5d/wIvq9P4sxrr+vLe2vuEj2HyvxItw7E6PRvGS4/2vpPHPPsx2jnVEx2XQu77MCnDX9FgPn0mC9bduCU7xjGO6/ExPQ5UJkfe5v+JjwB+XnLR2hUazEhbQYmpM1Ao1qL0pZtkf2g3CWIThP3Fa5Zs2Zh1qxZhssYY/jNb36D++67D9dddx0A4MUXX0Rubi7+9Kc/4fbbb4fb7cbzzz+Pl19+GVdffTUA4JVXXsGQIUOwZcsWzJgxAwcPHsTGjRuxc+dOTJo0CQCwZs0aTJkyBWVlZRg1ahQ2bdqE0tJSVFRUoKCgAADw5JNPYtGiRXjkkUeQkZGBdevWwePxYO3atbDb7SgqKsKhQ4fw1FNPYdmyZZ27ykX0WhzjR8ExfpThMsYYGjdvg2vOlUidUASmAQN/eBNOLPsvNO/ah/Rpk6G1tKLpH3uQ/YP5cIweCWhA9qKb8fV9j8Dz5WE4xoyCv+oUWg+WIX/Z3UgpLAQAZM+/AZVPr9a3RblLxMsgeyEG2YP5BLe4jDGG4637ca7jouBVLwDj0i7Hh3WvoNJ3BEPso+FnPpzwHcI45zQMtJ4TjHFejo/d61ETOIls62A0qXU4EziBSWlzMcCSAwAYm/pN7GraoG+LcpcgOk+XariOHj2KqqoqTJ8+Xe+z2+2YNm0atm/fDgAoKSmB3+8XYgoKClBUVKTH7NixAy6XS59sAcDkyZPhcrmEmKKiIv1DDwAzZsyA1+tFSUmJHjNt2jTY7XYh5uTJkzh27JjhMXi9XjQ0NAh/RN8ncLoWqrsRjrEj9D7JakHKqHPh/eo4AMBb/jWgqkgZPVKPsQxwwVqQB+/RY8GYo8chOVJgH1aox6QMK4SUkqK/ptwlupJWrRFe1oJsa0SSIUsKMi35qA9UAwAaAmfAoCHbEolJkZ1IUzJRHzgFAKgPVMMCmz7ZAoABlhxYELkdTLlLEJ2nS41Pq6qqAAC5ublCf25uLo4fP67H2Gw2ZGZmRsWE16+qqkJOTg7akpOTI8S03U5mZiZsNpsQM2zYsKjthJcNHz48ahurVq3CL3/5y9gHa+LBKMXQbQERPYhi4c1LjbVavLaLj7HK0f38coVz9uT1WRbZ+JZmPBouvh0wMankjSzD/bzGi9dq8QarfAyvyxL6Q7+Q+f3gfzVrXJtxjrKs7TFKDJKsgUGCGrrlLbvSgu9baAw5Iw3qmXowCVAbGgGLAiXNgaAYIRijpKcFlyEYo6SloS1KmhOB0K3J7s7dFmbVDTyBiKYOADTuNxev5xKLUHPGpyFdVjOn4WrRbIZtL6fValE5PZfKabjUoFaMN0YVtIBmBcpjFLI2y2ZBzyUUduadhyNNKVxBml/OVZWOW8/FOxyHb+WpvAuvmZlumyOSFcBiATQNXi2YV3ZrOiQlcm7tllS0qo2QrBb4VC8kyLDZncIwdjkVXnggKQp88MAmOyBZxP8WbLIDAS0ohumJ713ScMWA/P5M6fUaro7Q9pIxYyzmZeS2MUbxXRHDYrgx33vvvXC73fpfRUVFu/sdL7z4lkhC2qYFY/Ero41yq+1crxfmLtH7kGImb5taDIapKyYv5S5BdI4unXDl5eUBiFzpClNdXa3/wsnLy4PP50NdXV27MadOnYoa//Tp00JM2+3U1dXB7/e3G1NdHbzE3vZXWhi73Y6MjAzhj+j7KK50AIDmbhT6tcZmKBnBZUpGOhBQoTa3CDFqY5MQozaKYwCA2tystyl3ia7ELqcCAHyamJc+rRU22aHHMGjwa14xhnlgkyIxPq01anw/i6xDuUsQnadLJ1zDhw9HXl4eNm/erPf5fD58/PHHmDp1KgBgwoQJsFqtQkxlZSUOHDigx0yZMgVutxu7d+/WY3bt2gW32y3EHDhwAJWVlXrMpk2bYLfbMWHCBD1m69at8Pl8QkxBQUHUJW+if2MZlAnFlY7WL/6l97FAAJ6yr2A7L6jHshWeAygKPAcP6zEBdwP8J6tgHz4MAGAfXgjW6oH3eLke4zl2HIx70pFyl+hKHEoG7HIqzvhO6H0aU1HrO4kB1uCP4AxLNiTIOOOLXDnyqM1oDNTqMQMsuQgwH+r91XpMvf+U8KQj5S5BdJ64NVxNTU34178i/ykdPXoU+/btQ1ZWFoYOHYp77rkHjz76KEaMGIERI0bg0UcfRWpqKhYsWAAAcLlcuPXWW7F8+XIMHDgQWVlZWLFiBcaNG6c/tTh69GjMnDkTixcvxnPPPQcAuO222zBnzhyMGhV8ymz69OkYM2YMiouL8fjjj6O2thYrVqzA4sWL9V9HCxYswC9/+UssWrQIP//5z3H48GE8+uijeOCBBzr1pAyv/xA9uYyrHvN6Ll26wSQolqD9hZluy2qJ2GPwmiurEum3ypF2eBwbt9wSr4YrhhBAMyl4zGu4eN2WUYxqEitou7h9VTnPJJkrFB3WdgnricIbHcadh4DXB39VbWSdmlr4yr+GnOqEJXsA0mdcBvdfPoQ1byAsOdlw/+VDyHYrnJMvAiQG2ZmCtG9eirrX/wI5LRWKw4m6N/4C6zl5SBl9PiAxWPNz4Bg9Cmde/T8MvOl7kACcWf86HKNHofVgGYDuz1235hA0Ujy8nov34eJ1W7wnV9hPy1TDpUb6m7g2773lUXlPrpCGS41sg9fuaYKGi2vH465iWryauwXGS6ss3Itw8VtOCiChA3ou/j1SeZ8tvoK7ZLBxYz1XIOBFSyDyeGKr1oiGQA2scgoc1nQUpl2Erxo/hdOWhVTLAHzV+CkUyYoC5wWAbIEVFgxOHYOypp2wWZ2wyin4svEfSLcMRLZzGCDJSLPlILtlKL5o3oqxGdMAAAeatyLbNkSfqPXE967sJxlGe1DN1nZIstyJe8L16aef4oorrtBfL1u2DACwcOFCrF27Fj/5yU/Q2tqKO++8Uzc+3bRpE9LT0/V1nn76aVgsFtx444268enatWuhKJEv3XXr1mHp0qX604zz5s0TvL8URcF7772HO++8E5dddplgwBfG5XJh8+bNuOuuu3DJJZcgMzMTy5Yt0/e5J1C4yRTRvXiPfI3K//qj/rr2lfcBAM5vXoxBt38PGf82DcznR+1L70BtboX9vCHIWX4r5JTIxCHrxrmok2Wc+cM6MJ8fKRecj5zv/xASZ1iZ/f1bUPvG2zj17B8AAKlFY5E1dxYqVj4CoPfmLtFzuH3V2HP6Df31l+5PAAAFqaNxYdY1GJ4+ASoLoLT+I/g1L1y2XFyS/R1Y5Mhk+ALXNyFJEvbVboQKFQNtgzFu4GxI3ITvwgFX42DDJ9hTF7SCyLEPw8i0yfj4zMsAKHcJ4myQGGv7+AvB09DQAJfLhcJfPQw4I4/2w8I5T3NPG0pcv8Q7w1vCTyZyV6YUusLVtl81cRw3enpRiFWNt81MrpYwNTqG8W7s/IUGLlbSTK5ccPFSqJ//5al5PDj+01/A7XZ3mz4lnLv/988LkJre/Ve4GgKRz0sz1+/2OSIx/mB/g5eL9XLjtUbagdbIlTE0R/ZJaYkcg7UpeO6tnKuAvSHyRqTURd4oe03klpcc4N8s7jMcCFWF4EyZJZWP5d54rl/iv1bNnkIMr8ttz+wKlxhj8lk16o/3612L/n4IaD5sqf7fHsnd6rJCzPrV0m7ZZm+FrnCZo/o8+Gzdfd2au+1BtRQJgiAIgiASTJf6cPUrTHRbfD+v4Qr7cDEm6Ve2zK5qCVequLZdCRjG2EJXu/irV/wVLgt3NYy/kiULtRfbF8VoZlevuP4ApxMS+2XTvrZt4YoLp+sx0nbxVxr4YwnwV7sEzYjxMYQ9GyRZhRZeVzLR95jYJBnBpOT49VmvOnW/q7YIdQthfLWLr4kYvvIlXtUy9uFqVfk2V2PRwIeLf8/4tnDVUfDe4msftj0qwJ8RucrFeF82TrfFFN6PjLsiHPmYASGvLqZYIlew+M8Kf/WT6+dLPUGKnEtJ6A+ty+u6mEmy8ZhdEYu1ntkYPIpBnhhc9epOlCTzUko6kuA7JlnpFz5chDkK1VJMWjS1az8OyTDZ6q/wtxS7BJXeTIIgzg6acBEEQRAEQSQYmnARBEEQBEEkGJpwEQRBEARBJBgSzcdDhwxODcxOuX6NSbpAntdzCSJ4S0S1KwjlZWNhfUpIVcoL5fn1LBInmueOQUHnRPN8kWNeKO/nYnijy3CMmWjex4vtuX6+ADdv3BkICa35BwD8JgJ2vki2GWGxOP8ov6A7NjW85dtSdH+SyH7cmgM+1fijzj88oJqI5vm2NySg54X0vCCeF8o382L6QKQtiuaDbfPi1eDanBGuiYBeP+emZqdcW+GF99zDA9ypksPnRPD44Ibm+vl9lUzMTpmwryx6PD7xzGwhhIPnRO6xxPKddQDqYdE8GZ+2T4yv7n4NS7LcoStc3YyVjE8JgiAIot9BEy6CIAiCIIgEQxMugiAIgiCIBEMarq7ARC8icUak4fI7mibBZg3qq/jyPBaTsj0pnBYrRTA+5bVdwbadc2zk21bBEJUrCcSbPcYwjeK1PoK+R+b1V3x/ZPvekChGMEblag9atGgjzLYxsoHJqd/EzFOE0wPxGi1eaxcS30iM1w4ZaLLaaycx9YFUeAJWw2W80SxfvsmvGWu4wm0v956JpqbG7RZu+15ewxUIFa8OcMWreeNari3oogQNV9ujEhFkU7zkidNw8aavciDyuQgfpqCT4f3a+M+NaZFqbmUjvZag8epA2R4TzY6UKA2X2rMyCMWbXDocIjbJ4kFIGq5+TniyRRAEQRBE/4EmXARBEARBEAmGJlwEQRAEQRAJhjRcnYTXhUgmnlyyQTugKrCHbisKxas7oNtK4aq4Orh2WK/Fe2/ZpejlgOhtZRX8uTruw2Xm0cR7MwW4fqsaHNvPabJ4DRCvH+O9xHh/LqOi22IfJ87pwF1bwQ8ptFuCj5KJd5JpwWqDfiYnh0dOfcAJu6mGi9Mxmej0jLzWfFq0lxYgemzxbV635fFzeq5ASN/H6aLUAPc7kNfScW2JbxvJNIxrlovFqy3Gbyav5woXSGcKIIW9sATdlok/llBgmj8GbkNhTZWZ95a4U4YI3nGxxugIBusyuSNaycShJJkOp9dgVqC8HyH7k+ALmIOucHUzdtJw9RuSYbJFdA0S/edFEMRZQhMugiAIgiCIBEMTLoIgCIIgiARDEy6CIAiCIIgEQ6L5eBBML42dF80E9GHj04AqIyVsfKqYFKO2GBucOgTRvC+qP0XmhfKRdorEmaBybbGQNWfSGhIfqULBas6MkhMBe1hEAM1v08sJ6C1SsG0kpAcAr8S3eTG9iTFrDBmcphiLoXk9sMyLp8PFqzmDWIkvoGxStJxxb3Yye6DW+hyw+WyGy/iHIfj3VTMpUB4uQM4b1PIPNwj9BganUTH+YAwvlGecgSjflnj/TUF8HmkaCegF41Nej89pwWXueIXnKcJtkyLa/GecTzBe8yUZCeW5pqlhaQcE9EKN9XjE8nHEsh42PpV9JIZsF5IXmiIHkuvk0BWubiaFRPMEQRAE0e+gCRdBEARBEESCoQkXQRAEQRBEgiENV2fpQMFqXncUNj71qQoc1qDWyczs1CZ3XLcFAKlysD9V8UbG44xPeW0Xb3ZqNSlkbQSv4eJNMa2aatxvsB3eGFUWCmebtU3SM9xtcneW1x/xpqUKr5/hTGfDMXxBa17rw+txmCDS48VD0RqgZNF1uf2psJpquIyNT/l2gDsZgZC2TeU0bkKha774OB/Dabj4diCk3VL9kT7GF6wOmJid8ia1sSQ+JhousXg1r8Pk+sPvpbBtE1NcXhelRmu1ol+E12t/eXCbht0CpoWvDYM7HqoFelYGQRquGJyN0W0fRw70rP6wLXSFq5sJT7YIgiAIgug/xD3h2rp1K+bOnYuCggJIkoS3335bX+b3+/HTn/4U48aNg9PpREFBAb7//e/j5MmTwhiXX345JEkS/ubPny/E1NXVobi4GC6XCy6XC8XFxaivrxdiysvLMXfuXDidTmRnZ2Pp0qXw+XxCzP79+zFt2jQ4HA6cc845eOihh+L7JUj0GZoOlOPIL1/D/uL/xv55/wX3zi/1ZSyg4swrm3B82TP417//F47/x2Oofvb/EKhtEMaoWvUcji/6GY4v+hnKf/RTlP/opzjz3DohRm1pwZkX/4RjP/0Fjv30F6h++U/QWluFGMpdIh7q3Eexr/RlbN39K2z5xy9QXVOqL9M0FYeP/Q079q3GBzsfwtY9v8aBw6/D6xNz99MDz2PL9vuDfzuCf/sPvSbE+AOtOHD4dXy4+2F8uPthHDj8OvwBjxBDuUsQnSPuW4rNzc0YP348fvCDH+D6668XlrW0tGDv3r24//77MX78eNTV1eGee+7BvHnz8OmnnwqxixcvxkMPPaS/djgcwvIFCxbgxIkT2LhxIwDgtttuQ3FxMTZs2AAAUFUVs2fPxqBBg7Bt2zbU1NRg4cKFYIxh9erVAICGhgZcc801uOKKK7Bnzx4cOnQIixYtgtPpxPLly+M9dKKXo3p8cAzPxcCrx+Poo28IyzSvH56vTiLre5fDXpgHf4MXNS+9j6onXkbBQ0uE2LRpEzHgu9folgWSVfwYnVm7DmqdG3l3/Cj4+rXXcea11yP7QblLxImq+ZHmzENB7sX4/MtXhWWa5kdj00mcO/hypDnzEAh4UHb0few7uA6Txv+HEHtO7iU4d8iV+i1FRRZrbB44/H/weN34xujvAwAOHnkHX371TmQ/KHcJotPEPeGaNWsWZs2aZbjM5XJh8+bNQt/q1asxceJElJeXY+jQoXp/amoq8vLyDMc5ePAgNm7ciJ07d2LSpEkAgDVr1mDKlCkoKyvDqFGjsGnTJpSWlqKiogIFBQUAgCeffBKLFi3CI488goyMDKxbtw4ejwdr166F3W5HUVERDh06hKeeegrLli0TtBphvF4vvN6IFqqhoSEqpi2SxOs/jPvDPly8hsvC6b34to3TdvF6Lr4IdVi3BUS0W3yfUzbWc1kFTy5OwxVDJKKaFK/mx+Y9uXhtV3g7oq6L03PxWjfDSsTGaIIGh9cfqYYxAyeei4ETzwUAHEVQ2iNJDJLEYEmzY/CDi/RYJSBj4A9m4+R9v0egph6W7AHBBRIg2a1QMtPB/NybHTqt/spT8JSWIW/F3bANK4SsAtnzb0Dl06v10O7O3XpPCiyKPfb5hLGGi9drhduq2XJOfyUUpOZjOM8tLdRmvA+Xny8e3QHdloElnuC9ZerDZVyUXNiObNDHy0IEDzBuEIX7TjC27NM1X0LGm3wMs3IvQFbuBcEXX74KZpGh2YI7J9tScdHFtwoDjbTOw6d7n0WL1oiUlAGhDUqQLDZY0wYIY4c32dxcjZr6w5hw8X8gI2MIAOAC63Uo+ez3emxPfO/KvuTS4SQddOHQFDmQXPq/hGu43G43JEnCgAEDhP5169YhOzsbY8eOxYoVK9DY2Kgv27FjB1wulz7ZAoDJkyfD5XJh+/btekxRUZH+oQeAGTNmwOv1oqSkRI+ZNm0a7Ha7EHPy5EkcO3bMcH9XrVql38Z0uVwYMmTI2Z4CAdJw9R60Fg8gSZBTU4T+5h37UHHXQ6h84EnU/fkv0DyR/yi8Xx2H5EiBPTTZAoCUYYWQUiJj9NbcJXoPgYAHgASLRczdU9X78Mm2h7Fr929w+F/vIxCI5K67oRwWJQWujEjeuFxDoXCTdcpdgug8CZ1weTwe/OxnP8OCBQuQkZGh999yyy149dVX8dFHH+H+++/HG2+8geuuu05fXlVVhZycnKjxcnJyUFVVpcfk5uYKyzMzM2Gz2dqNCb8Ox7Tl3nvvhdvt1v8qKio6ceREb0fz+VH76iakXXahMOFyTvkGsv9jPnLvvQ0Zc65Cy94DOPPbl/TlakMjlLS0qPGUNKfeptwlEomq+nHkq78hN2e8MOHKzb0IY0fPxzcu+hGGFV6B02e+wP4vIvpDn68JVpszajyblXKXILqChNlC+P1+zJ8/H5qm4dlnnxWWLV68WG8XFRVhxIgRuOSSS7B3715cfPHFAGB42ZkxJvR3JiYs3DRaFwDsdrvwy4zof7CAiur/+TOgMWT/cK6wLP3yiXrbmpsPa042qh5eDW/5CdiHDg4uMMqtNpf9KXeJRKBpKr4oXQ8GhlEj5wnLzim4VG+npeXBkZqNT0t+i8bGr5Gefg4AQDIwM2l7x4pylyA6R0ImXH6/HzfeeCOOHj2KDz74QLi6ZcTFF18Mq9WKw4cP4+KLL0ZeXh5OnToVFXf69Gn9l1JeXh527dolLK+rq4Pf7xdi2v6iqq6uBoCoX2AdQtBnmfXzui2uHer3BSxItQa1Vh3SavF+W0q0bguIaLd43VaqiYaLb9s4MYocw4dLkyIXQ32chkvQbTETfZim6fsX9uKSTTRjsfzAgEj9P5uswqNaQ31m+qPIeKosji3LDIrMoIXeJ0UOwOcBKp/6MwLVdSh44IdQnHZoXD0u4T8fCbAOOwdQFASqz8A+dDCUjHSoodvjmgL9tqLa3Kyv1t252+hLgWLpgIaLO2/8A2XMQK+lacbnm68zyOu5+JqIGtcPvm5iSMcleG9xbT4WvC+WgYZFTQGU0MN1ZrotzcppB/ntmGi+wikr8dovwZOLi+XPCb9jGn9ioycfHZUwahYJqk28QaFpKkr/+So83jqMv3QxJFsqePVT27GdWYMhSQqa/bVw2obAmpoOr79J14aF8Qd6LncB4C+v/xHz5i2Me71+Q088/dlLnjiV1eQqpdfltxTDk63Dhw9jy5YtGDhwYMx1vvjiC/j9fuTn5wMApkyZArfbjd27d+sxu3btgtvtxtSpU/WYAwcOoLKyUo/ZtGkT7HY7JkyYoMds3bpVeGR506ZNKCgowLBhw7ricOMmPNnqj/DGp10yntq14/k8wMkn/wxfZS0K7v8BlPTUmOv4vz4FqCoUV/BHhf3cQrBWD7zHyvXJlufYcTBP5NH63pq7iYQXzXcFiid2TDx0xHi0JwlOttahtaUGF176I8Nbg21pbjoFxlTYbOkAgAxXIdSABw3uyO28hvpyqJzOqydylyZbRF8h7m+5pqYm7Nu3D/v27QMAHD16FPv27UN5eTkCgQC+973v4dNPP8W6deugqiqqqqpQVVWlf/iOHDmChx56CJ9++imOHTuG999/HzfccAO+8Y1v4LLLLgMAjB49GjNnzsTixYuxc+dO7Ny5E4sXL8acOXMwatQoAMD06dMxZswYFBcX47PPPsPf//53rFixAosXL9avqC1YsAB2ux2LFi3CgQMH8NZbb+HRRx81fVKG6NuorT40HzmF5iPBq6e+qnq0HKmC77QbTNVw8onX4DlyEvn3XA+maQjUNyJQ3wgWctr2n6pB/dtb4D16AoHTtWj9/Euc+f0rsA4tgP28YQAAa34uUsaMQs2r/wfPsePwHDuOM+tfh2P0KH0/KHeJeFEDXjQ1nERTQ9DT0NNai6aGk/C01oNpKkr3vYKmhq8xetxNAGPweRvh8zZC04K529pSg2NHtqDBfQKtrbWoOf0lSj9fh7T0ArgyhwEAnGk5yBo4EmVfvAF3fTnc9eUoK30TmQNH6vtBuUsQnSfuW4qffvoprrjiCv31smXLAAALFy7EypUr8e677wIALrroImG9Dz/8EJdffjlsNhv+/ve/47//+7/R1NSEIUOGYPbs2XjwwQehKJFbVevWrcPSpUsxffp0AMC8efPwzDPP6MsVRcF7772HO++8E5dddhkcDgcWLFiAJ554Qo8J21TcdddduOSSS5CZmYlly5bp+0z0L5oOVeHgTyIeRl//7xYAwIArxyNn/jQ07SkDABxf/jthvbz7boVjzLmQLAo8pUfQuGk7NK8XlqwBSBl3AVzzroYkR367ZC+8BXWvv42qZ/8AAEgtGousubNQsfIRAJS7RPw0uk/gn3v+oL8+UvYeACC34GIMO/9q1Jw+CAAo2fE/wnrjL12MAVnnQZIU1NUewYny7VADXthTBmDgoFEYdt7VkDi5wOgL5+Pwl+/i85LnAQADc0bj3PNnYOcnvwJAuUsQZ4PEyP63XRoaGuByuVD4q4eBDE4HY4/cY5BsnL+UndNi2biaiLagdoq/pZhui1yqT7NG2umWSDvDGrk3kqYYt7tFw4XYGi6/0B+p3deiBdv8LUV+vRY1cl69miVqPQBo5W4ftqqh8bg+j2oxbHsDXNukP1zbz6jGHxDxigq2uZp/vNaI845CqJ+T6EHzeHD8p7+A2+2OqWnsKsK5e+H/rYCSmtwaLv6WoqDh8hvruWQfVyOTu0sftqLjbylyckdYOMN/awtXt5OTeogeXyyqTyihKWiyjGMETOJjrsfTya/sOCzuBAIBD7Z9sLJHcre6rBD/fssPumWbvRbScJkSUL344J+/6tbcbQ8qXt0FSMI3sHF/2NDTE7DCGZpoCcan3Dc6L5q3cxMku2w8cQpPtPhJlpnxqWiCGtkmL1ZXDP4nULkD4ydWNs5k1MMi6cQXig6PLXPjyh34wPIFs0VRvGzQxxVb5kw2A9w5VhjXlngxfcgxnvulb/ZQhPi/pEkh66QpWx2k2WOFIhsXr2YGwu3gAuOY8NvGuHPMnVZhwsW3YdIfnkQJBqf8hIvr5ydFsqn5aPShdKh4tWB8Gi1s581OzY1MjfuFXTE632YFq00/IjHyq4v/L1TlLpf6xoXkSy7hc9LR2clPL5k0nQ1SXxfNE+3j5K5qEQRBEATRP6AJF0EQBEEQRIKhCRdBEARBEESCIQ1XZ+mIbos3Pg1piTwBK9LCGi5et6VE7jVbOIGKlWuncIWnUwz0XLxuyyn5opa3HYPXcFljKGp5WYuPW4/XYsmcyaig15INBPl8F29MyYlszIoph2P8XKyFb8sK1x/ZkF/j3w+uuHDY0FIoQm5ckNzU/NYA3vi0J/G3WqEitmdZR/Rc+gkQhOW8PouLNNFwiYWgpag+3uBU0E4Jxqf8dsz2VdxlAGKucd9+ktl+h8aTIiklaF8ETZYgpjfYD7P943aws8L2tvvVlag9bOVAGq4YCJrDvq/LigfScPVz0kjD1W9IhskWQRAEkRzQhIsgCIIgCCLB0ISLIAiCIAgiwZCGq4sR5CIGmqBmv003POW1WrzmiS/8LLaN/bnCei4zv61UQe/F6ba4bdpi6DRU7ljsnPeWjffvMvG80kPMpvdcqJ/TX/HeXyqn0Qr7gNm5YtkBjdNt8f5mmrH3lpFHmrn3VudIFg0Xa7WAxftRFzylDE6GiW6K1zSZ6ZhEbVeoTzVeLmq4+BjjtpFGit99Lk0gWYyLUJtpsSIpY6LbMpPPxCGrOSsNl1HSdoGmJ+xT12N4/bFj+jNaEnzJJCtactUupitc3Uw6abj6Dckw2SK6hrObCBEEQdCEiyAIgiAIIuHQhIsgCIIgCCLB0ISLIAiCIAgiwZBoPh46YIApmYg9ZE4077J5hD6gjdmpqWieE6tLvCFqUBhohYlJKqf8TeG2aeUOwsoVblYMxLcqp/z1mymmYWIyFx6a19FzBXF9XDFsXuzv59wmjc6DV4qkL3/+eKG8bCCOb9sOv2dGfcEXxv1MiDEqZJ0cRaxljww53t9WsUxQO1K02TQmWlgvCN8NhertxJjEG2xOKF4tGp/GEMKbFqM2WdBJzVfXa8XOPge1HjY+hZd0r+2imbns9iDJYsBKovn+TXiyRRAEQRBE/4EmXARBEARBEAmGJlwEQRAEQRAJhjRcCUQw1wyJOhp9drjsHqEPABQY64s6YoIaHscmLDc2OOV1WymCRioy9zbS+2i8wamgC+HNphjXq3JtOWr//JzeS+g3OV5FKLStRi33cXouWYqt4TJ6b4SC1eg7KC0yZC1eDVf7i011WyZjxDIFNRvPzNTU1PjUSM7Cy7M441NeZsJMTk8sDVeXFZ42IklkMGoPfxoYabjaR0tgoiSLFquTMEYarn5NeLJFEARBEET/gSZcBEEQBEEQCYYmXARBEARBEAmGNFxdjJE2iMftTYlouAR9kXGRZbN+hVvXZqBp4jVhCifB4LVafNsChYuPnoernJmRbLAcADTwGi1u/0LFrv2c7kxhkdTj9WiKZOWOIVq3Fdx+tG+WbKKBM2vHg5m3Wiw0C4Mc6Hk1mOwBlA4cQqc1SGcztlF/vAWhY8XzGi6+kLXJtx8/RsxD690Slw7R0yVBmYc0XO0Sj84qkXqvJIQ0XP0c0nD1H5JhskUQBEEkBzThIgiCIAiCSDA04SIIgiAIgkgwcWu4tm7discffxwlJSWorKzEW2+9hWuvvVZfvmjRIrz44ovCOpMmTcLOnTv1116vFytWrMCrr76K1tZWXHXVVXj22WcxePBgPaaurg5Lly7Fu+++CwCYN28eVq9ejQEDBugx5eXluOuuu/DBBx/A4XBgwYIFeOKJJ2Cz2fSY/fv3Y8mSJdi9ezeysrJw++234/7774fUifpgsleCZg/dA/coQErH1Q1hHVCDz44BoduKDf4UZFiD7Xp/KgZYW9rfPqdpkg0Mhxq1FAyQW4O7xxSkhuoL8r5ZfJv321Ji+HDxui0/4z3A+PEiGPmKpUs+tGhBjdYAuRUNWkpo27wWy9hDy4g0xYsm1Q4AcFq8aA6E2ooPzaotKr72n1/j2PoSNB6qhremGaN/+R1kXzZCL4N48n/eRs2W/cI6KSMGo/CxxQgEgkfHAgHU/ul9NO/4HMznR8qY85FVfC0s6Zn6OmpLC+r+/A5a9pcCAFKLxiBrzixh3O7MXWszoJiUuex3cEkaj6ysp2k+cQRn9nyI1lMnEGhuwNB5P0DGiHH68hMbX0X9F3uEdRz5Q3Hegnv011oggKqP34X7y8+gBfxIGzoCBVdfD2v6AD1G9bTg5AdvofHIFwCA9PPGIveb/yaM293fu+8e/gRzh06Me73+AjPTZbEkrLHYzWjMHzuoG4l7wtXc3Izx48fjBz/4Aa6//nrDmJkzZ+KFF17QX/MfRAC45557sGHDBqxfvx4DBw7E8uXLMWfOHJSUlEBRguLtBQsW4MSJE9i4cSMA4LbbbkNxcTE2bNgAAFBVFbNnz8agQYOwbds21NTUYOHChWCMYfXq1QCAhoYGXHPNNbjiiiuwZ88eHDp0CIsWLYLT6cTy5cvjPfTIZAuIa7LFM4DTcIUnWwBiTrY6NHZosgVAn2wlE+HJFgB9snU2hCdbAPTJFgDDyRYAqB4/0s/LxjmzxuCfD7wXvVyTkHbxeRj843nw+4N5KFkUfbIFALWv/AUte7/EoCXzIac4Ubv+PVT/Zi3y7/sxpFBB7jMv/AlqvRt5d/wo+Pq113Hmtdcj2+mB3CV6N5rfh5RBBRhQNBEV7641jEkbdgHOmTlffy3JirC86qO30XDkCwyZUwwlJRVVH7+L42/9L87792V67la89wr8TfUYdv1tAICvN/8ZJzf/nz5GT+QuTbaIvkLcE65Zs2Zh1qxZ7cbY7Xbk5eUZLnO73Xj++efx8ssv4+qrrwYAvPLKKxgyZAi2bNmCGTNm4ODBg9i4cSN27tyJSZMmAQDWrFmDKVOmoKysDKNGjcKmTZtQWlqKiooKFBQUAACefPJJLFq0CI888ggyMjKwbt06eDwerF27Fna7HUVFRTh06BCeeuopLFu2zPDXltfrhZdzNm5oaIj3FBFJyqBJwzBo0rB2Y2SrAmtmGpg/8tEIhK4OqS0eNH5UgkH/cQMcReeD+WVk3zYfXy9fBc/Bw3CMHQV/5Sl4SsuQt+JupAwpBABkz78BlU+v1sej3CXiJX34aKQPHw0AqDCJkRQLrM4Mw2WqtxV1+3dh8KwFSCscCQAY/G+3oOwPD6Gp/BDSh10AT80pNB37Eucu+DFS84O5e841N+KrV/9HH4dylyA6T0I0XB999BFycnIwcuRILF68GNXV1fqykpIS+P1+TJ8+Xe8rKChAUVERtm/fDgDYsWMHXC6XPtkCgMmTJ8PlcgkxRUVF+oceAGbMmAGv14uSkhI9Ztq0abDb7ULMyZMncezYMcN9X7VqFVwul/43ZMiQsz8hRK+h6cBxlBY/ia+W/A+qfvcOAu4mfZn3q5OAqiJl3Ai9z5KZAevgXHiPHA/GHCmH5EiBffhQPSZlWCGklMgVPcpdIhE0n/gXDj77AA79cRW+3vQaAi2N+rLWUyfANBVpw0bpfdY0F1Ky89Dy9bFgzMljkO0p+mQLAFILhkG2Ue4SRFfQ5T5cs2bNwg033IDCwkIcPXoU999/P6688kqUlJTAbrejqqoKNpsNmZmZwnq5ubmoqqoCAFRVVSEnJydq7JycHCEmNzdXWJ6ZmQmbzSbEDBs2LGo74WXDhw+P2sa9996LZcuW6a/dbjeGDh0KzeMBbLxBT+SWnaRydQO1yD1jVY14gAQCwV9v/kCkz2eJtL1Wv2HbY4mIb1o5IY6Nu2WohNoWOXLPXuPb3A/KAPfr0i7UJ+S1WO2rWPycNsDLtVu5dgvnDdMSMj9q1SLLmzWVW49rawHDtkeNtL2qP/Rv5PeCj7Ng8HPSBT+nXQoERE2D5vEj0OyFGlrBWVSI9EtGwDooA60nG1HzxlZU3P8CCh68FZLVgsCpWsCiQJIkaC0esNCtRtmZikBtPbRWDwI1tVCcTmitHkDltHPOVAQ8HjDGuj13VR9ZkfQ1tIAfqjfyvjoHn4e04aNhTR8Af0MdTu/agqOv/RbDbloCWbHAV18TvMUoycJ6SooT/sY6qF4PfA11sKQ4heUAoDhSofl6JncbmzQEkkyHk2wwMx8u0nAhgGDumJ6jbqbLJ1w33XST3i4qKsIll1yCwsJCvPfee7juuutM12OMCZeajS47d0VM+MSbiTftdrvwyyx8abviwYdN953onZSter9Dccdu+5Xwuvy2h6JivPgKzds/1V9XrLjfcKzGxuBVh+7M3UN/iN5fondz4v1XOhRX9rsHhNcHn/m5YRwvuDeL6YncPW9CBcxvohJEx2hsbITL5erp3Ui803x+fj4KCwtx+PBhAEBeXh58Ph/q6uqEq1zV1dWYOnWqHnPq1KmosU6fPq3/UsrLy8OuXbuE5XV1dfD7/UJM+FcXvx0AUb/SzCgoKEBpaSnGjBmDiooKZGQYayT6Mw0NDRgyZEivOj8ulwvr1q3DnDlz2o37xje+ge9///v4z//8T3z88ceYN28ejh07JuTuZZddhtmzZ+PnP/85Xn75Zdx3330oLy8HEDk3GRkZeOCBB1BQUEC5m0RQ7iZv7lZUVIAxhqFDh/aq96e76I25252Ez09paalwC7xHYWcBAPbWW2+1G3PmzBlmt9vZiy++yBhjrL6+nlmtVvbaa6/pMSdPnmSyLLONGzcyxhgrLS1lANiuXbv0mJ07dzIA7Msvv2SMMfb+++8zWZbZyZMn9Zj169czu93O3G43Y4yxZ599lg0YMIB5vV495rHHHmMFBQVM07QOH6fb7WYA9HEJkd54frord8PnhnI3OemN56e/5C6/D73p/eku6Ny0TzKen7gnXI2Njeyzzz5jn332GQPAnnrqKfbZZ5+x48ePs8bGRrZ8+XK2fft2dvToUfbhhx+yKVOmsHPOOYc1NDToY9xxxx1s8ODBbMuWLWzv3r3syiuvZOPHj2eBQECPmTlzJrvwwgvZjh072I4dO9i4cePYnDlz9OWBQIAVFRWxq666iu3du5dt2bKFDR48mC1ZskSPqa+vZ7m5uezmm29m+/fvZ2+++SbLyMhgTzzxRFzHnIxvXDLRW85PT+Tuli1bGAA2c+ZMfTnlbvLQW85Pf8xdxnrP+9MT0Llpn2Q8P3FPuD788EP9Vw//t3DhQtbS0sKmT5/OBg0axKxWKxs6dChbuHAhKy8vF8ZobW1lS5YsYVlZWczhcLA5c+ZExdTU1LBbbrmFpaens/T0dHbLLbewuro6Ieb48eNs9uzZzOFwsKysLLZkyRLm8XiEmM8//5x961vfYna7neXl5bGVK1fSr6wuprecn57KXQDs+PHjQgzlbnLQW85Pf8xdxnrP+9MT0Llpn2Q8P2d1S7G/4PF42IMPPhj1pUIEofNjTk+fm57efrJD58ecZDg3ybAPyQqdm/ZJxvMjMZYkz0sSBEEQBEH0Uah4NUEQBEEQRIKhCRdBEARBEESCoQkXQRAEQRBEgqEJF0EQBEEQRIKhCRdBEARBEESCoQlXB3j22WcxfPhwpKSkYMKECfjkk096epfOipUrV0KSJOEvLy9PX84Yw8qVK1FQUACHw4HLL78cX3zxhTCG1+vF3XffjezsbDidTsybNw8nTpwQYurq6lBcXAyXywWXy4Xi4mLU19cLMeXl5Zg7dy6cTieys7OxdOlS+Hw+dBdbt27F3LlzUVBQAEmS8PbbbwvLk+1c7N+/H9OmTYPD4cA555yDhx56qN3CrJS7lLvJci4odyl3w/T13DWlh+woeg3r169nVquVrVmzhpWWlrIf//jHzOl0RpkB9iYefPBBNnbsWFZZWan/VVdX68sfe+wxlp6ezt544w22f/9+dtNNN7H8/Pwo1+pzzjmHbd68me3du5ddccUVhq7VRUVFbPv27Wz79u2sqKjIsFrAFVdcwfbu3cs2b97MCgoKBNfqRPP++++z++67j73xxhuGJVOS6Vy43W6Wm5vL5s+fz/bv38/eeOMNlp6eburgTblLuZss54Jyl3KXpy/nbnvQhCsGEydOZHfccYfQd8EFF7Cf/exnPbRHZ8+DDz7Ixo8fb7hM0zSWl5fHHnvsMb3P4/Ewl8vFfv/73zPGInXZ1q9fr8d8/fXXhnXZdu7cqcfs2LHDsC7b119/rce8+uqrQl227qTtBz/ZzsWzzz7LXC6XYOS3atUq0xp1lLuUu8lyLih3KXfN6Gu52x50S7EdfD4fSkpKMH36dKF/+vTp2L59ew/tVddw+PBhFBQUYPjw4Zg/fz6++uorAMDRo0dRVVUlHLPdbse0adP0Yy4pKYHf7xdiCgoKUFRUpMfs2LEDLpcLkyZN0mMmT54Ml8slxBQVFQmV3GfMmAGv14uSkpLEHXwHSbZzsWPHDkybNg12u12IOXnyJI4dOybsO+VuEMrd5DgXlLtBKHdjk2znIp7cjQVNuNrhzJkzUFUVubm5Qn9ubi6qqqp6aK/OnkmTJuGll17C3/72N6xZswZVVVWYOnUqampq9ONq75irqqpgs9mQmZnZbkxOTk7UtnNycoSYttvJzMyEzWZLivObbOfCKCb8uu35otyNQLkbgXK356Dc7RjJdi7iyd1YWOKK7qdIkiS8ZoxF9fUmZs2apbfHjRuHKVOm4LzzzsOLL76IyZMnA+jcMbeNMYrvTExPk0znwmhfzNbt7L4nM5S78ZFM54Jyl3I3HpLpXMSbu2bQFa52yM7OhqIoUbPY6urqqBlvb8bpdGLcuHE4fPiw/tRMe8ecl5cHn8+Hurq6dmNOnToVta3Tp08LMW23U1dXB7/fnxTnN9nOhVFMdXU1gOhfg5S7ESh3I1DuJg+Uu8Yk27mIJ3djQROudrDZbJgwYQI2b94s9G/evBlTp07tob3qerxeLw4ePIj8/HwMHz4ceXl5wjH7fD58/PHH+jFPmDABVqtViKmsrMSBAwf0mClTpsDtdmP37t16zK5du+B2u4WYAwcOoLKyUo/ZtGkT7HY7JkyYkNBj7gjJdi6mTJmCrVu3Co8sb9q0CQUFBRg2bJiw75S7QSh3k+NcUO5GQ7lrTLKdi3hyNyZxSez7IeHHk59//nlWWlrK7rnnHuZ0OtmxY8d6etc6zfLly9lHH33EvvrqK7Zz5042Z84clp6erh/TY489xlwuF3vzzTfZ/v372c0332z4SO7gwYPZli1b2N69e9mVV15p+EjuhRdeyHbs2MF27NjBxo0bZ/hI7lVXXcX27t3LtmzZwgYPHtytjyc3Njayzz77jH322WcMAHvqqafYZ599pj9+nkznor6+nuXm5rKbb76Z7d+/n7355pssIyMj5qP1lLuUuz19Lih3KXd5+nLutgdNuDrAb3/7W1ZYWMhsNhu7+OKL2ccff9zTu3RWhD1NrFYrKygoYNdddx374osv9OWaprEHH3yQ5eXlMbvdzr797W+z/fv3C2O0trayJUuWsKysLOZwONicOXNYeXm5EFNTU8NuueUWlp6eztLT09ktt9zC6urqhJjjx4+z2bNnM4fDwbKystiSJUuEx28TzYcffsgARP0tXLiQMZZ85+Lzzz9n3/rWt5jdbmd5eXls5cqV7T6aTLlLuZss54Jyl3I3TF/PXTMkxjpjl0oQBEEQBEF0FNJwEQRBEARBJBiacBEEQRAEQSQYmnARBEEQBEEkGJpwEQRBEARBJBiacBEEQRAEQSQYmnARBEEQBEEkGJpwEQRBEARBJBiacBEEQRAEQSQYmnARBEEQBEEkGJpwEQRBEARBJBiacBEEQRAEQSSY/w+XoFFzlSQklQAAAABJRU5ErkJggg==",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 3 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure()\n",
    "subplot(1,3,1)\n",
    "pcolor(grid.x,grid.y,vx)\n",
    "gca().set_aspect(\"equal\")\n",
    "gca().invert_yaxis()\n",
    "\n",
    "subplot(1,3,2)\n",
    "pcolor(grid.x,grid.y,vy)\n",
    "gca().set_aspect(\"equal\")\n",
    "gca().invert_yaxis()\n",
    "\n",
    "subplot(1,3,3)\n",
    "pcolor(grid.x,grid.y,P)\n",
    "gca().set_aspect(\"equal\")\n",
    "gca().invert_yaxis()\n",
    "show()\n",
    "\n",
    "figure()\n",
    "plot(vy[8,: ])\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "540694af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Attempt a faster solution using GMRES preconditioned with algebraic multigrid\n",
    "# note - this won't work without introducing a better preconditioner for the pressure block of the stokes system.\n",
    "# function solve_gmres(L,R)\n",
    "#     ml = ruge_stuben(L);\n",
    "#     p = aspreconditioner(ml);\n",
    "#     return gmres(L, R; Pl=p, restart = 200)\n",
    "# end\n",
    "    \n",
    "# @time s = solve_gmres(L,R);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f13b71a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7803×7803 SparseMatrixCSC{Float64, Int64} with 66799 stored entries:\n",
       "⢵⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀⠀⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷⣄⠀\n",
       "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢿⣷"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6f96b905",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Base.EnvDict with 25 entries:\n",
       "  \"USER\"                          => \"maxrudolph\"\n",
       "  \"JUPYTERHUB_HOST\"               => \"\"\n",
       "  \"JUPYTERHUB_USER\"               => \"maxrudolph\"\n",
       "  \"HOME\"                          => \"/home/maxrudolph\"\n",
       "  \"JUPYTERHUB_OAUTH_CALLBACK_URL\" => \"/user/maxrudolph/oauth_callback\"\n",
       "  \"JUPYTERHUB_API_URL\"            => \"http://127.0.0.1:8081/hub/api\"\n",
       "  \"JUPYTERHUB_CLIENT_ID\"          => \"jupyterhub-user-maxrudolph\"\n",
       "  \"PATH\"                          => \"/opt/julia-1.7.1/bin:/opt/conda/bin:/usr/…\n",
       "  \"JUPYTERHUB_ACTIVITY_URL\"       => \"http://127.0.0.1:8081/hub/api/users/maxru…\n",
       "  \"LANG\"                          => \"C.UTF-8\"\n",
       "  \"SHELL\"                         => \"/bin/bash\"\n",
       "  \"JUPYTERHUB_SERVICE_PREFIX\"     => \"/user/maxrudolph/\"\n",
       "  \"LC_ALL\"                        => \"C.UTF-8\"\n",
       "  \"JUPYTERHUB_API_TOKEN\"          => \"4a386b767bb748d0b1684925930511df\"\n",
       "  \"PWD\"                           => \"/home/maxrudolph\"\n",
       "  \"JUPYTERHUB_SERVER_NAME\"        => \"\"\n",
       "  \"JUPYTERHUB_BASE_URL\"           => \"/\"\n",
       "  \"JPY_API_TOKEN\"                 => \"4a386b767bb748d0b1684925930511df\"\n",
       "  \"PYDEVD_USE_FRAME_EVAL\"         => \"NO\"\n",
       "  \"JPY_PARENT_PID\"                => \"119\"\n",
       "  \"OPENBLAS_MAIN_FREE\"            => \"1\"\n",
       "  \"OPENBLAS_NUM_THREADS\"          => \"8\"\n",
       "  \"JULIA_NUM_THREADS\"             => \"4\"\n",
       "  \"LINES\"                         => \"30\"\n",
       "  \"COLUMNS\"                       => \"80\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ENV"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.5",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}