hsugawa8651/matrix_computation_20190308.ipynb Secret

## matrix_computation_20190308.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prelude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Julia Version 1.1.0\n",
      "Commit 80516ca202 (2019-01-21 21:24 UTC)\n",
      "Platform Info:\n",
      "  OS: macOS (x86_64-apple-darwin14.5.0)\n",
      "  CPU: Intel(R) Core(TM) i5-7267U CPU @ 3.10GHz\n",
      "  WORD_SIZE: 64\n",
      "  LIBM: libopenlibm\n",
      "  LLVM: libLLVM-6.0.1 (ORCJIT, skylake)\n"
     ]
    }
   ],
   "source": [
    "versioninfo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×4 Array{Int64,2}:\n",
       " 1  4  7  10\n",
       " 2  5  8  11\n",
       " 3  6  9  12"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=reshape( collect(1:12), 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(ij, a[ij]) = (1, 1)\n",
      "(ij, a[ij]) = (2, 2)\n",
      "(ij, a[ij]) = (3, 3)\n",
      "(ij, a[ij]) = (4, 4)\n",
      "(ij, a[ij]) = (5, 5)\n",
      "(ij, a[ij]) = (6, 6)\n",
      "(ij, a[ij]) = (7, 7)\n",
      "(ij, a[ij]) = (8, 8)\n",
      "(ij, a[ij]) = (9, 9)\n",
      "(ij, a[ij]) = (10, 10)\n",
      "(ij, a[ij]) = (11, 11)\n",
      "(ij, a[ij]) = (12, 12)\n"
     ]
    }
   ],
   "source": [
    "for ij in eachindex(a)\n",
    "    @show ij, a[ij]\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(ij, a[ij]) = (CartesianIndex(1, 1), 1)\n",
      "(ij, a[ij]) = (CartesianIndex(2, 1), 2)\n",
      "(ij, a[ij]) = (CartesianIndex(3, 1), 3)\n",
      "(ij, a[ij]) = (CartesianIndex(1, 2), 4)\n",
      "(ij, a[ij]) = (CartesianIndex(2, 2), 5)\n",
      "(ij, a[ij]) = (CartesianIndex(3, 2), 6)\n",
      "(ij, a[ij]) = (CartesianIndex(1, 3), 7)\n",
      "(ij, a[ij]) = (CartesianIndex(2, 3), 8)\n",
      "(ij, a[ij]) = (CartesianIndex(3, 3), 9)\n",
      "(ij, a[ij]) = (CartesianIndex(1, 4), 10)\n",
      "(ij, a[ij]) = (CartesianIndex(2, 4), 11)\n",
      "(ij, a[ij]) = (CartesianIndex(3, 4), 12)\n"
     ]
    }
   ],
   "source": [
    "for ij in CartesianIndices(a)\n",
    "    @show ij, a[ij]\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(ij, a[ij]) = (1, 1)\n",
      "(ij, a[ij]) = (2, 2)\n",
      "(ij, a[ij]) = (3, 3)\n",
      "(ij, a[ij]) = (4, 4)\n",
      "(ij, a[ij]) = (5, 5)\n",
      "(ij, a[ij]) = (6, 6)\n",
      "(ij, a[ij]) = (7, 7)\n",
      "(ij, a[ij]) = (8, 8)\n",
      "(ij, a[ij]) = (9, 9)\n",
      "(ij, a[ij]) = (10, 10)\n",
      "(ij, a[ij]) = (11, 11)\n",
      "(ij, a[ij]) = (12, 12)\n"
     ]
    }
   ],
   "source": [
    "for ij in LinearIndices(CartesianIndices(a))\n",
    "    @show ij, a[ij]\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ex1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "make_uvw (generic function with 2 methods)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function make_uvw(nx,ny,rng = Random.MersenneTwister(1234))\n",
    "  u=rand(nx,ny)\n",
    "  v=rand(Float64, size(u))\n",
    "  w=similar(u);\n",
    "  return u,v,w\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_double_loop_ij (generic function with 4 methods)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_double_loop_ij(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds for i in 1:nx\n",
    "        @simd for j in 1:ny\n",
    "            w[i,j]=u[i,j]+v[i,j]*alpha\n",
    "        end\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_double_loop_ji (generic function with 4 methods)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_double_loop_ji(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds for j in 1:ny\n",
    "        @simd for i in 1:nx\n",
    "            w[i,j]=u[i,j]+v[i,j]*alpha\n",
    "        end\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "using BenchmarkTools\n",
    "using Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "rng=Random.MersenneTwister(12345);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx1=200; ny1=100;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     26.046 μs (0.00% GC)\n",
       "  median time:      93.483 μs (0.00% GC)\n",
       "  mean time:        89.271 μs (0.00% GC)\n",
       "  maximum time:     650.663 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_double_loop_ij(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     9.118 μs (0.00% GC)\n",
       "  median time:      25.649 μs (0.00% GC)\n",
       "  mean time:        24.581 μs (0.00% GC)\n",
       "  maximum time:     94.851 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_double_loop_ji(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_eachindex (generic function with 4 methods)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_eachindex(u,v,w, nx=size(u,1), ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds @simd for ij in eachindex(u)\n",
    "        w[ij]=u[ij]+v[ij]*alpha\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     8.783 μs (0.00% GC)\n",
       "  median time:      25.358 μs (0.00% GC)\n",
       "  mean time:        24.329 μs (0.00% GC)\n",
       "  maximum time:     152.343 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_eachindex(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_CartesianIndices (generic function with 4 methods)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_CartesianIndices(u,v,w,  nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds @simd for ij in CartesianIndices(u)\n",
    "        w[ij]=u[ij]+v[ij]*alpha\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     9.044 μs (0.00% GC)\n",
       "  median time:      25.775 μs (0.00% GC)\n",
       "  mean time:        24.683 μs (0.00% GC)\n",
       "  maximum time:     78.076 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_CartesianIndices(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_LinearIndices_CartesianIndices (generic function with 4 methods)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_LinearIndices_CartesianIndices(u,v,w,  nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds @simd for ij in LinearIndices(CartesianIndices(u))\n",
    "        w[ij]=u[ij]+v[ij]*alpha\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     8.878 μs (0.00% GC)\n",
       "  median time:      25.547 μs (0.00% GC)\n",
       "  mean time:        24.636 μs (0.00% GC)\n",
       "  maximum time:     78.647 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_LinearIndices_CartesianIndices(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_with_matrix (generic function with 4 methods)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_with_matrix(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    w=u+v*alpha\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  312.66 KiB\n",
       "  allocs estimate:  4\n",
       "  --------------\n",
       "  minimum time:     21.182 μs (0.00% GC)\n",
       "  median time:      158.228 μs (0.00% GC)\n",
       "  mean time:        172.537 μs (14.69% GC)\n",
       "  maximum time:     10.018 ms (98.74% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_with_matrix(u,v,w, $nx1,$ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex1_with_dot_matrix (generic function with 4 methods)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex1_with_dot_matrix(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @. w=u+v*alpha\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     9.461 μs (0.00% GC)\n",
       "  median time:      31.773 μs (0.00% GC)\n",
       "  mean time:        30.716 μs (0.00% GC)\n",
       "  maximum time:     158.427 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex1_with_dot_matrix(u,v,w, $nx1,$ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14-element BenchmarkTools.BenchmarkGroup:\n",
       "  tags: []\n",
       "  (\"ex1_CartesianIndices\", \"nx1=100\", \"ny1=200\") => Trial(9.514 μs)\n",
       "  (\"ex1_with_matrix\", \"nx1=100\", \"ny1=200\") => Trial(21.143 μs)\n",
       "  ⋮"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "suite = BenchmarkGroup()\n",
    "for (nx1,ny1) in [(200,100),(100,200)]\n",
    "    for f in [\n",
    "        :ex1_double_loop_ij,\n",
    "        :ex1_double_loop_ji,\n",
    "        :ex1_eachindex,\n",
    "        :ex1_CartesianIndices,\n",
    "        :ex1_LinearIndices_CartesianIndices,\n",
    "        :ex1_with_matrix,\n",
    "        :ex1_with_dot_matrix ]\n",
    "      suite[string(f), \"nx1=\"*string(nx1), \"ny1=\"*string(ny1)] = @benchmarkable $(f)(u,v,w,$nx1,$ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))\n",
    "    end\n",
    "end\n",
    "tune!(suite);\n",
    "results = run(suite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Any,1}:\n",
       " Pair{Any,Any}((\"ex1_double_loop_ji\", \"nx1=200\", \"ny1=100\"), Trial(9.368 μs))                \n",
       " Pair{Any,Any}((\"ex1_CartesianIndices\", \"nx1=200\", \"ny1=100\"), Trial(9.392 μs))              \n",
       " Pair{Any,Any}((\"ex1_double_loop_ij\", \"nx1=200\", \"ny1=100\"), Trial(26.295 μs))               \n",
       " Pair{Any,Any}((\"ex1_with_dot_matrix\", \"nx1=200\", \"ny1=100\"), Trial(9.353 μs))               \n",
       " Pair{Any,Any}((\"ex1_LinearIndices_CartesianIndices\", \"nx1=200\", \"ny1=100\"), Trial(8.894 μs))\n",
       " Pair{Any,Any}((\"ex1_with_matrix\", \"nx1=200\", \"ny1=100\"), Trial(21.212 μs))                  \n",
       " Pair{Any,Any}((\"ex1_eachindex\", \"nx1=200\", \"ny1=100\"), Trial(9.254 μs))                     "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r_slice=collect(results[@tagged \"nx1=200\" && \"ny1=100\" ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       " 6\n",
       " 3\n",
       " 4\n",
       " 1\n",
       " 2\n",
       " 7\n",
       " 5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcs=[ e[1][1] for e in r_slice ];\n",
    "times=[ e[2].times for e in r_slice ];\n",
    "faster=sortperm(r_slice, rev=true, by=e->median(e[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "7-element Array{PyCall.PyObject,1}:\n",
       " PyObject Text(0, 1, 'ex1_with_matrix')                   \n",
       " PyObject Text(0, 2, 'ex1_double_loop_ij')                \n",
       " PyObject Text(0, 3, 'ex1_with_dot_matrix')               \n",
       " PyObject Text(0, 4, 'ex1_double_loop_ji')                \n",
       " PyObject Text(0, 5, 'ex1_CartesianIndices')              \n",
       " PyObject Text(0, 6, 'ex1_eachindex')                     \n",
       " PyObject Text(0, 7, 'ex1_LinearIndices_CartesianIndices')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig, ax = plt[:subplots]()\n",
    "ax[:boxplot](times[faster][:], vert=false)\n",
    "ax[:set_xscale](\"log\")\n",
    "ax[:set_xlabel](\"time / ns\")\n",
    "\n",
    "ax[:set_yticklabels](funcs[faster])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzs3XlcVNX/P/DXMMAwwwCyg4YMSggouGuoiH3Mj6AS5JKhphZZSn5ySTO1wi2IFPVTkWIapGQfU1ATErdEMZCPjtAXBBFRFBXDLRaHxRnevz/8zf1wZVgdFuk8H4/7gHvOuWe743A899x7BUREYBiGYRiGYZ57Ou1dAYZhGIZhGEY72MCOYRiGYRimk2ADO4ZhGIZhmE6CDewYhmEYhmE6CTawYxiGYRiG6STYwI5hGIZhGKaTYAM7hmEYhmGYToIN7BiGYRiGYToJNrBjGIZhGIbpJNjAjmEY5m9k586deOONN9CrVy/o6OhAJpNpNf+4uDgEBATA0dERYrEYMpkM06dPR15ensb0x48fh4eHByQSCSwsLDB79mwUFxfXSff48WOsXr0aMpkMIpEIzs7O+Prrr7Va92d18eJFBAUFwcPDA4aGhhAIBEhKStJqGZs3b8bEiRPh4OAAgUCAUaNG1Zu2uLgYs2fPhoWFBSQSCTw8PHDixAmNaZt6HpiOjw3sGIZh/kZ27dqFixcvYsiQIejZs6fW8w8LC4NCocDKlSuRmJiIdevWIT09HQMGDMDFixd5aU+dOgUfHx9YW1vj4MGD+Pe//43jx49j9OjRqKqq4qUNCgpCaGgo3n//fRw5cgSvvfYaFixYgJCQEK23oaXOnz+PAwcOwMzMDKNHj26VMrZu3Yrr16/jH//4BywtLetNV1VVhdGjR+PEiRP497//jYMHD8La2hre3t44deoUL21zzgPzHCCGYRjmb0OlUnG/jx8/nuzt7bWa/59//lkn7NatW6Snp0eBgYG88MGDB5Orqys9fvyYC/v9998JAH377bdcWFZWFgkEAgoJCeEdP2fOHBKLxXT//n2ttqGlavft3r17CQCdPHmy1cro3bs3eXl5aUwXERFBACglJYULe/z4Mbm6utKQIUN4aZt6HpjnA5uxYxiG6aBWrVoFgUCAixcvIiAgACYmJrC2tsbbb7+NkpISLt1//vMfCAQCfPPNN7zjg4ODIRQKcezYMS5MR6d1v/atrKzqhHXt2hUvvPACCgsLubBbt27h3LlzePPNN6Grq8uFDxs2DE5OTti/fz8XduDAARAR3nrrLV6+b731FioqKpCYmNjsehYUFEAgEGDDhg3YuHEjHBwcIJVK4eHhgbNnz3Lpdu3aBYFAgNTU1Dp5rFmzBnp6erh9+zaA1u/b5pSxf/9+9OrVCx4eHlyYrq4uZsyYgf/+97+4desWgOadB+b5wAZ2DMMwHdykSZPg5OSE2NhYfPzxx9i9ezcWLVrExb/xxhuYO3cuPvzwQ5w/fx4A8Ntvv2HdunVYsWIFxowZ0+wyiQhKpbJJW2OuXr2K69evo3fv3lxYVlYWAMDd3b1Oend3dy5endbS0hI2NjZ10tXOqyUiIiJw7NgxbN68GT/++CMePXqEcePGcQPnqVOnwsbGBhEREbzjlEolIiMj8dprr6Fr167NLlelUjWpb2tqalrUrqysrHr7FgB3Wbw554F5PrCBHcMwTAcXGBiI1atX45VXXsGiRYsQGBiIn376CUTEpdm8eTN69+6N119/HTk5OZg2bRo8PT2xatWqFpV56tQp6OnpNWkrKCioNx+lUonAwEBIpVLeYPT+/fsAADMzszrHmJmZcfHqtJrSGRoaQl9fn5e2uYyMjBAfHw8/Pz/4+flhx44dePjwIQ4fPgwA0NfXx3vvvYe9e/fybiaIi4vD7du3MX/+/BaV27Nnzyb17Zo1a1qUf319pg5T91lzzgPzfNBtPAnDMAzTnl599VXevru7OyorK1FcXAxra2sAgEgkws8//4yBAwdiwIABMDY2xk8//QShUNiiMgcOHIhz5841KW19M1ZEhMDAQCQnJyM2NhZ2dnZ10ggEAo3HPh1eX7rG4hozfvx4Xh+pZ66uX7/Ohc2bNw+hoaH47rvvsHLlSgDAN998Azc3N4wcObJF5R46dKhJNya0ZDZQrTl91tTzwHR8bGDHMAzTwZmbm/P2RSIRAKCiooIX7ujoCE9PTyQkJGDevHmwtbVtcZlSqRT9+vVrUtraa7PUiAjvvPMOYmJi8MMPP8DPz48Xr26TphmhBw8e8GaQzM3NkZGRUSfdo0ePUF1drXG2qama0rfW1taYOnUqIiMj8fHHH+PixYtITk5GZGRki8t1dXXlzbjWp6Xr9szNzevtW+B/M3TNOQ/M84FdimUYhukktm/fjoSEBAwZMgTffPMN0tLSWpzXs1yKVQ/qoqKisH37dsyYMaNO/n369AEAZGZm1onLzMzk4gHAzc0Nd+/exZ07d+qkq51Xa1qwYAEKCwtx8OBBfPPNN+jSpQumT5/e4vxa+1Ksm5tbvX0L/K/PmnMemOcDm7FjGIbpBDIzM/HBBx9g5syZ+O677zBs2DBMnToV6enpMDU1bXZ+Lb0US0SYM2cOoqKiEBkZWedOVrVu3bphyJAhiImJwZIlS7jLoWfPnkVubi4WLlzIpfXz88Mnn3yCH374AcuWLePCo6OjIRaL4e3t3ez2NdfAgQMxbNgwhIWFISsrC++++y4MDQ1bnF9rX4p97bXXEBQUhLS0NAwdOhTAk/WOMTExGDp0KJdvc84D83xgAzuGYZjn3KNHj/D666/DwcEB3377LfT19fHzzz9jwIABeOutt3DgwAEubXZ2NrKzswEAd+7cgUKhwL59+wA8uTzo6uoK4MlNBYMGDWp2XT744APs2LEDb7/9Ntzc3HiPDhGJROjfvz+3HxYWhjFjxmDKlCkICgpCcXExPv74Y/Tp04c3IOzduzcCAwO5x7cMHjwYR48exbZt27Bu3Tre5cKkpCS8/PLLCA4ObvGNI/VZsGABpk6dCoFAgKCgoDrxCoUCv/76KwBw7T516hTu3bsHQ0ND+Pj4cGnd3NxaVIfz589zM6SlpaUgIu78DR48GPb29gCAt99+GxEREZgyZQq++OILWFlZ4dtvv0Vubi6OHz/Oy7Op54F5TrTbE/QYhmGYBgUHBxMAunv3Li88KiqKANC1a9eIiGjGjBkkkUjo4sWLvHTqh+Ru2rSpTp6atuDg4Geus729fb35a3oY8tGjR+mll14iAwMDMjMzo5kzZ2p8yHF1dTUFBwdT9+7dSV9fn5ycnOirr76qk+7QoUMEgLZu3dpgPa9du0YAaP369XXi6uuLqqoqEolE5O3t3WCeTW17S8yaNaveMqKionhp79y5QzNnziQzMzMyMDCgl156iY4dO6Yx36aeB6bjExA1YfUmwzAMwzwHPvroI/z000/Iy8uDgYGBVvM+dOgQXn31VSQkJGDcuHFazZthtIUN7BiGYZhOY/DgwZgzZw7effddreWZnZ2N69evY8GCBTA0NMSFCxfYY0CYDosN7BiGYRimAaNGjcLvv/+OAQMG4IcffoCzs3N7V4lh6sUGdgzDMAzDMJ0Ee44dwzAMwzBMJ8EGdgzDMAzDMJ0EG9gxDMMwDMN0EuwBxQzDNKqmpga3b9+GkZERuxuQYRimDRARysrK0LVr12a9M5gN7BiGadTt27dhZ2fX3tVgGIb52yksLMQLL7zQ5PRsYMcwTKOMjIwAPPmCMTY2bufaMAzDdH6lpaWws7Pjvn+big3sGIZplPryq7GxMRvYMQzDtKHmLn9hN08wDMMwDMN0EmxgxzAMwzAM00mwS7EMwzD1yMvLQ/nDuzAov4FKaXeQrgGMjIzw4osvtnfVGIZhNOpUA7vo6GgsXLgQf/31V3tXRWsKCgrg4OCA9PR09OvXD0lJSXj55Zfx8OFDdOnSpb2r99yRyWRYuHAhFi5c2N5VqePpugkEAuzfvx/+/v7tXDPtU6lU+P7777X2onY9PT3Y2tqirKwMDx8+5MIFAgH3mAA9PT2YmJjA19cXI0eOhJ2dHTw9PSEUCjXmmZeXBycnJ/S30cGF96QYEFmO9Ds1AIDLly/zBneenp44c+aMVtrSGF1dXYjFYkgkEtja2mLgwIEoLi7G7du3YW1tjWvXrkGhUEBXVxdSqRQKhQJSqRSOjo54+PAhJBIJbGxsYG5uDqFQiFGjRmHUqFFcP6hUKiQnJ6OwsBC///47srKyIBAI4Ofnhw8++AD6+vr11k197K1bt/Dnn3/i/v37AAAzMzPY2NigW7duDfZ5ffkVFRXB1ta23mNVKhWSkpKQlJQEAHXaxDB/K9TGIiMjycvLi4yMjAgAPXz4sFnHA6D9+/drjFMoFPTnn39qo5pa4eXlRQsWLHimPK5du0YAKD09nYiIqqqqqKioiGpqarRRxWf222+/kY+PD5mZmZFYLCYXFxdavHgx3bx585nzbuhct1RxcTE9evRIq3kGBwdT3759nzkfe3t72rRpE7dfVFRElZWVz5yvNpSUlBAAKikpeea8YmNjCUCH2GQyGcXGxmqsp1wuJwCUsD2EKNiYsk/8RDExMQSA5HI5l66926CNzcrKimJjYyk2NpZkMlm96QQCAS1durTe89rQsU3p88by03RsbGwsWVpa1tsmhnletfR7t83X2CkUCnh7e2PFihVaz1ssFsPKykrr+TZXdXV1q+Wtr68PGxubDvGQ2MjISLzyyiuwsbFBbGwssrOzsXXrVpSUlCA8PLzF+bZm/1laWkIikbRa/tpkY2MDkUjU3tXQqri4OEyaNKm9q8ERCoWYPHky4uLi6k3j4OAAAHBxdoaLiwsvriP8O3xW3bp1Q3FxMSZNmoTJkyfzZrkkEgnXZgMDAxAR1q9fj48++oiXR1xcHCZPngwLCwsuzN7eXuPvFhYWjfa5Oj83NzekpqairKwMqampcHNz4x2r/jzdvXsXI0aMwIkTJ3DixAmMGDECxcXFjZbDMJ1Sc0eQNTU1FBYWRg4ODmRgYEDu7u60d+9eIiJavXo12dra0r1797j0vr6+5OnpSSqVipfPyZMntT5jFxUVRSYmJty+eiZl586dZG9vT8bGxjR16lQqLS1tUnuIiJRKJb399tskk8nIwMCAnJycaPPmzbxyZ82aRX5+fhQSEkK2trZkb29PRHVn7Ozt7enzzz+nt956i6RSKdnZ2VFkZCQvr7S0NOrXrx+JRCIaOHAgxcXF8WbsNPXbmTNnaOTIkSQWi6lLly70z3/+kx48eNCk9j148ICmTZtGFhYWZGBgQI6OjvT99983eh4KCwtJX1+fFi5cqDFeXb979+7RG2+8Qd26dSOxWEx9+vSh3bt389J6eXnR+++/T4sWLSJzc3MaOXIk2dvb8/73re5TIqJffvmFBgwYQCKRiBwcHGjVqlX0+PFjLj44OJjs7OxIX1+fbG1t6V//+hfvHNSeFQsPD6c+ffqQRCKhF154gebNm0dlZWVcvPozlZiYSM7OzmRoaEhjx46l27dv88qrPWOn/jysX7+ebGxsyMzMjIKCgqi6uppL8+eff9KECRPIwMCAZDIZxcTE1Knb05/1wsJCmjp1KpmampJEIqGBAwfS2bNntdIvjdHGjJ1SqSRTU9N2n52qvQmFQho/fjw5ODiQUqnk1Vc9Y5d94ieiYGOiW+lcmFwupxEjRrR7/Vu6iUQiMjAwIKFQSEKhkHx8fEggEJCBgQHp6OgQALK2tqbHjx+TSqUiX19fsre352bGdHV1qaqqijuvMpmMJkyYQPb29iQWi2n8+PFc2IQJE0gmk9H48eNJIpFw4Zr6vHZ+vr6+df5uqOvi4OBAVVVVXHkTJkzgpVWpVDRhwgSSSCT1lsMwHV1Lv3ebPbBbsWIFOTs7U2JiIuXn51NUVBSJRCJKSkoipVJJHh4e5O/vT0REW7ZsIRMTEyooKKiTT1sN7KRSKU2cOJEyMzPp9OnTZGNjQytWrGhSe4iIqqur6bPPPqP//ve/dPXqVYqJiSGJREJ79uzh8pg1axZJpVJ68803KSsrizIzM4lI88DOzMyMIiIiKC8vj0JDQ0lHR4dycnKIiKi8vJwsLS1p6tSplJWVRYcOHaIePXo0OLBLT08nkUhE8+bNo4yMDMrKyqKvv/6a7t6926T2vf/++9SvXz86d+4cXbt2jY4dO0a//PJLo+dh48aNBIA3wNHk5s2btH79ekpPT6f8/Hz66quvSCgU8gYkXl5eJJVKaenSpXTp0iXKycmh4uJiAkBRUVFUVFRExcXFRESUmJhIxsbGFB0dTfn5+XT06FGSyWS0atUqIiLau3cvGRsb06+//krXr1+ntLQ02rZtG+8c1B48bdq0iX777Te6evUqnThxgnr16kXz5s3j4qOiokhPT49eeeUVOnfuHMnlcnJxcaFp06ZxaTQN7IyNjWnu3LmUk5NDhw4dIolEwquHj48P9enTh1JSUuj8+fM0bNgwEovF9Q7sysrKqEePHuTp6UnJycmUl5dHe/bsoZSUFK30y9MqKyuppKSE2woLC595YKf+7Ha07Y033iAAFBkZSXK5nNvUl13Tf43mBnZnzpwhAFxcZ9kmTZpUJ+y7777jzl1KSgoBoMWLF3Px6s+q+rxGRERwcerfU1NTuWO/+eYbLl79+8mTJ+v9nKSmpmr8HKnz27RpE5efprTqdPWVwzAdXZsM7MrLy8nAwID7Y6IWGBhIAQEBRESUn59PRkZGtGzZMpJIJBQTE6Mxr7Ya2EkkEt4M3dKlS2no0KFNbo8mQUFBNGnSJG5/1qxZZG1tzf0PVk3TwG7GjBncfk1NDVlZWdGWLVuI6Mn6QzMzM94asC1btjQ4sAsICKDhw4drrGdT2ufr60tvvfVWvW2tz7x588jY2LjZxxERjRs3jj788ENu38vLi/r161cnnaZz7enpSSEhIbywXbt2ka2tLRE9mYFzcnLizY7V9vTA7mk///wzmZubc/tRUVEEgK5cucKFRUREkLW1NbevaWBnb2/PmyWYMmUKTZ06lYiIcnNzCQBvcJuTk8P7Y/l0+yMjI8nIyIju37+vsd7P2i9PCw4O1jgAeJaB3e7du9t9ANOSTb3Gjm6ld7oBnXr7xz/+USesqKiIO3elpaV1Bmfz58/nndfvv/+ei1P/XlZWxh27Y8cOLl79+9Oz97Xzqz1zXps6v/nz53P5aUqrTldfOQzT0bXJGrvs7GxUVlZizJgxkEql3LZz507k5+cDAHr06IENGzYgLCwMvr6+mD59enOK0DqZTMZ7HYetrS2Ki4sBNK09ALB161YMGjQIlpaWkEql+O6773Djxg1eOW5ubg3eLabm7u7O/S4QCGBjY8PVJycnB3379uWtAfPw8Ggwv4yMDIwePVpjXFPaN2/ePPznP/9Bv3798NFHHyElJaXRNgAAETVpfZFKpcLnn38Od3d3mJubQyqV4ujRo3X6b9CgQU0qVy6XY82aNbz2zJkzB0VFRVAoFJgyZQoqKirQo0cPzJkzB/v374dSqaw3v5MnT2LMmDHo1q0bjIyMMHPmTNy/fx+PHj3i0kgkEvTs2ZPbr/0Zqk/v3r15a5VqH5OTkwNdXV1em52dnRu8yzkjIwP9+/eHmZlZm/TL8uXLUVJSwm2FhYUNtrcpbG1tnzmP1vDGG28AeLJmVC6Xc1tMTAwAoGvXrlxamUwGAFxcZ2FqalonLD4+nvs9KysLAHD16lUuTP1vQn1eKyoquDj171lZWdyxmuI1fSbUYerjnqYOr/1vUlPa2mEd9bPHMK2hWY87qal5cqt/QkICunXrxourvcj79OnTEAqFKCgogFKphK5u+z1VRU9Pj7cvEAi4djSlPT///DMWLVqE8PBweHh4wMjICOvXr0daWhovvaGh4TPXh4ia2Kr/EYvF9cY1pX0+Pj64fv06EhIScPz4cYwePRrvv/8+NmzY0GC5Tk5OKCkp4R5DUJ/w8HBs2rQJmzdvhpubGwwNDbFw4cI6N0g0tf9qamqwevVqTJw4sU6cgYEB7OzskJubi2PHjuH48eMICgrC+vXrcerUqTp9f/36dYwbNw5z587F2rVrYWZmhjNnziAwMBCPHz/m0mk6Z42dq6ac5+YsvG/oPAPa7RfgyedD2zdueHp6wtTUlPc4kvYmFApRVlYGBwcHBAYGanw8Ru1+UJ8HFxcXjBgxos0ecaJtIpEIAoGA+5wrFAoIBAKIRCJUV1ejpqYGn3zyCWbPng0dHR2EhobC3t4eu3btAvDkkStBQUEAnpxXmUyGw4cPw97eHsXFxfj1118hk8nw+eefAwAXL5FIYGVlhcTERDg4OMDT07NO3dT5hYSE4MCBA9zjaoAnn/PQ0FA4ODggKCgImzdvRnFxMT7//HMcPHiQS1tTU4OQkBBIJBJYW1trLIdhOqtmzdi5urpCJBLhxo0bcHR05G12dnYAgD179iAuLg5JSUkoLCzE2rVrW6Xi2tCU9iQnJ2PYsGEICgpC//794ejoyJvN03Z9/vjjD97/bM+ePdvgMe7u7jhx4kS9+TXWPuDJnaKzZ89GTEwMNm/ejG3btjVa18mTJ0NfXx9ffvmlxnj1swSTk5Ph5+eHGTNmoG/fvujRowfy8vIazR94MjhSqVS8sAEDBiA3N7dOexwdHbkvdbFYjFdffRVfffUVkpKSkJqaiszMzDr5nz9/HkqlEuHh4XjppZfg5OSE27dvN6luz8LFxQVKpRLnz5/nwnJzcxt8/qK7uzsyMjLw4MEDjfHa7JfWIhQKsX379jYrrylkMhl+/fVXbNiwodnPPEtOTm6lWrW+qqoqVFZWQqVSwcbGBocPHwYRoaqqirsL+M8//4SJiQn69OmDQ4cO4c8//8Tdu3cBAIsWLeKuUAiFQoSHhyMhIQGWlpaoqKhAQkICiAjx8fGIj48HESEhIQEKhQIWFhZISEiot8/V+cXHx8Pf3593V6y/vz/i4+OxYcMG6OvrY+PGjaioqEB8fDy8vLxw/PhxHD9+HCNHjkR8fDwqKipadG4Z5nnWrKk0IyMjLFmyBIsWLUJNTQ1GjBiB0tJSpKSkQCqVYvTo0Zg3bx7CwsIwYsQIREdHY/z48fDx8cFLL70EALhz5w7u3LmDK1euAAAyMzNhZGSE7t2713uZ6WnXrl1DRkYGL8zR0bE5TWlSe2bNmgVHR0fs3LkTR44cgYODA3bt2oVz585xX37aNG3aNKxcuRKBgYH45JNPUFBQ0OjM2fLly+Hm5oagoCDMnTsX+vr6OHnyJKZMmQILC4tG2/fZZ59h4MCB6N27N6qqqhAfH1/nkQ6a2NnZYdOmTZg/fz5KS0sxc+ZMyGQy3Lx5Ezt37oRUKkV4eDgcHR0RGxuLlJQUmJqaYuPGjbhz506TypDJZDhx4gSGDx8OkUgEU1NTfPbZZ5gwYQLs7OwwZcoU6Ojo4P/+7/+QmZmJdevWITo6GiqVCkOHDoVEIsGuXbsgFot5j1tQ69mzJ5RKJb7++mv4+vri999/x9atWxut17Pq1asXvL29MWfOHGzbtg26urpYuHBhg7NyAQEBCAkJgb+/P0JDQ2Fra4v09HR07doVHh4eWu2X1jRx4kTExsZ2mEee1NTUYN++fRpnOhUKBQDg0qVLcAGQc+kScor4/9Fo6pKEjuzWrVuwsrLCli1bAAAffvghF6dQKJCTkwMAqKyshEAgwJIlS+r8h27ixInYt28f79jr169r/P3+/fv19rmm/IYNG8aFOzg48I5Vf57mzp2LM2fOYMyYMVxadZsaKodhOqNmXyNdu3YtrKysEBoaiqtXr6JLly4YMGAAli9fjtmzZ2PIkCGYP38+AGDMmDGYP38+ZsyYgYyMDEilUmzduhWrV6/m8hs5ciQAICoqCrNnz25SHRYvXlwn7OTJk81tSoPtUT9nb+7cucjIyMDUqVMhEAgQEBCAoKAgHD58uEXlNUQqleLQoUOYO3cu+vfvD1dXV4SFhTX4R9DJyQlHjx7FihUrMGTIEIjFYgwdOhQBAQFNap++vj6WL1+OgoICiMVieHp64j//+U+T6hsUFAQnJyds2LABr732GioqKiCTyTBhwgTuHH366ae4du0axo4dC4lEgnfffRf+/v4oKSlpNP/w8HAsXrwY3333Hbp164aCggKMHTsW8fHxWLNmDb788kvo6enB2dkZ77zzDgCgS5cu+OKLL7B48WKoVCq4ubnh0KFDMDc3r5N/v379sHHjRoSFhWH58uUYOXIkQkNDMXPmzCa1/1lERUXhnXfegZeXF6ytrbFu3Tp8+umn9abX19fH0aNH8eGHH2LcuHFQKpVwdXVFREQEAGi1X1rbxIkToVQqO/ybJy5dugTgyb+h196TYvr06dybJ2qv2yWiTvXmCT8/vxa9eWLixIncsdp480Tt/Bp684Q6HXvzBMM8IaCWLOxiGOZvpbS0FCYmJigpKYGxsXF7V6dN3Lt3DwcOHIDrizKYqu6xd8UyDNOmWvq9ywZ2DMM06u84sGMYhmlPLf3ebfNXijUkJCSE97iG2puPj097V+9vhZ0LhmEYhnn+dKgZuwcPHtR7159YLK7zyA6m9bBzwdTGZuwYhmHaVku/d9vvAXMamJmZNfnOWKZ1sXPBMAzDMM+fDnUplmEYhmEYhmk5NrBjGIZhGIbpJNjAjmEYhmEYppNgAzuGYRiGYZhOokPdPMEwDPM8yMvLQ/nDuzAov8EeXMwwTIfCBnYMowXR0dFYuHAh/vrrr3rTzJ49G3/99RcOHDjwTGUJBALs378f/v7+z5RPR3Dnzh3Y2to2Ka2pqSkqKiqgVCohFArRo0cPuLm5wdjYGDk5OSAimJubo2vXrgCAsrIyKBQKjBgxAkFBQUhLS0NRURGsrKxQXV2N3bt3o7S0FESEF154AU5OTggKCqr3lVlqeXl5cHJyQn8bHVx4T4oBkeXcq8YuX77MDe6WLVtW552qTSUQCCAWi2Fubg4LCwuYmZnBwcEBd+/ehbGxMaZOnYpLly7h6tWrEAgE6N+/P+Lj41FWVobKykq4ubmhV69eXHtUKlWjr+Z6nnX29jFMsxDDPAet3sk9AAAgAElEQVQiIyPJy8uLjIyMCAA9fPiwvavEExUVRSYmJg2m+euvv7RSbwC0f//+Z86nOUpKSggAlZSUaC1PiURCADrUpqurS0uXLm2w3nK5nABQwvYQomBjyj7xE8XExBAAksvlRETt3o7a7fHz8yOZTMYLl8lkFBsbq7Vz2Z5iY2M7dfuYv6+Wfu+yNXbMc0GhUMDb2xsrVqxo76q0mImJCbp06dLe1egQDA0NoVAoWrUMPT29euN0dJ589UkkEt7DtvX19bF+/Xp89NFHAJ587i5cuKCxrg4ODgAAF2dnuLi4cOECgUAr9W8JdbvUPwHg4MGDEAqFSE1NRVlZGVJTU+Hm5obJkycjLi6uvaqqFXFxcZg8eTLc3Nw6ZfsYpkVaaaDJMDw1NTUUFhZGDg4OZGBgQO7u7rR3714iIlq9ejXZ2trSvXv3uPS+vr7k6elJKpWKl8/JkydbNGN38+ZNev3116lLly5kZmZGr776Kl27do2L/+9//0uvvPIKmZubk7GxMY0cOZKbfVF7+PAhzZkzh6ysrEgkElHv3r3p0KFDRPS/GbvExERydnYmQ0NDGjt2LN2+fZs7ftasWeTn58fte3l50b/+9S9aunQpmZqakrW1NQUHB/PKvHz5Mnl6epJIJCIXFxc6evRonRm7htpWUVFBrq6uNGfOHC791atXydjYmLZt29bk/tPmjF1RUVGrzlIJBALup46ODgGgsWPHcvEWFhYkFApJX1+f7O3tqbq6msaPH09CoZB0dHTIysqKdHV1qaqqipudq/1ZUIdln/iJKNiY6FY6FzZlypQ2mYkTCoUkFAp5+wKBgAQCAY0fP566d+9Oenp6BID09fVJKBRSVVUV1waVSkW+vr7k4OBASqXymc9pe1AqlSSTycjX17fO90RnaB/DsBk7pkP75JNPEBUVhS1btuDixYtYtGgRZsyYgVOnTmHlypWQyWR45513AABbt27F6dOnsWvXLt7MQ0spFAq8/PLLkEqlOH36NM6cOQOpVApvb29UV1cDeLIea9asWUhOTsbZs2fx4osvYty4cSgrKwMA1NTUwMfHBykpKYiJiUF2dja++OIL3joehUKBDRs2YNeuXTh9+jRu3LiBJUuWNFi3H374AYaGhkhLS8OXX36JNWvW4NixY1yZEydOhFAoxNmzZ7F161YsW7asWW0zMDDAjz/+iB9++AEHDhyASqXCm2++iZdffhlz5sypt15VVVUoLS3lbdrSr18/reWlyejRowEARISamidr36RSKRffrVs3qFQqLF68GNevX8fvv/+OlStXQqVSoaamBqNGjYJSqcS3336LiooKAEBOTg4uXLiACxcuICcnB8CTPlJTp9u7d2+rtk1NpVJBJpPx9qdPnw4igqOjI27cuIERI0YAAHr37g2VSoVvv/2WS6+jo4Ply5fj2rVrSE5ObpM6a1tycjIKCgqwYsWKOt8TnaF9DNNirTLMZJhaysvLycDAgFJSUnjhgYGBFBAQQERE+fn5ZGRkRMuWLSOJREIxMTEa82rJjN2OHTuoV69eVFNTw4VVVVWRWCymI0eOaDxGqVSSkZERNyN35MgR0tHRodzcXI3po6KiCABduXKFC4uIiCBra2tuX9OM3YgRI3j5DB48mJYtW8aVKRQKqbCwkIs/fPgwb8auqW378ssvycLCgv71r3+RjY0N3b17t57eeiI4OFjjTJE2ZuxEIlGrzmaFhITUCfvHP/7B/e7i4kIAKC8vjwDQ7t27qbS0lIufPXs2AaD58+dza+c0beo1dnQrvcF0rbU5OTnx9tPT0wkAvfvuuwSApk+fTgBo+PDhXHtqU7d59+7dz3xO28Pu3bsJAJWVlWmMf97bxzBsxo7psLKzs1FZWYkxY8ZAKpVy286dO5Gfnw8A6NGjBzZs2ICwsDD4+vpi+vTpWitfLpfjypUrMDIy4so2MzNDZWUlV35xcTHmzp0LJycnmJiYwMTEBOXl5bhx4wYAICMjg7tzsj4SiQQ9e/bk9m1tbVFcXNxg3dzd3Xn7tY/JyclB9+7d8cILL3DxHh4ezW4bAHz44Yfo1asXvv76a0RFRcHCwqLBei1fvhwlJSXcVlhY2GD65mjtdYa//fZbnTBTU1Pud/Vdrzt27ADwpM+zsrK4ePV6up49e3KzYjExMZDL5ZDL5YiJiQEA7u5bALzZs7aiUql4++Hh4QAAsVgMALh9+zYAfntqU7e5qXcldzTqetc+d7U97+1jmJZijzthWp36clhCQgJvoToAiEQi7vfTp09DKBSioKAASqUSurra+XjW1NRg4MCB+PHHH+vEWVpaAnjyKJK7d+9i8+bNsLe3h0gkgoeHB3epVv3HsiFPL9YXCAQgomYfo+4vTcc+vTC/KW0Dngxcc3NzIRQKkZeXB29v7wbrJRKJeOdGmzIyMlr1j+2JEycAPOkrdX+Wl5dz8bdu3YJQKMTGjRthb2+P4cOH47XXXoNQKAQRISkpCbq6uggKCuIGBy4uLhgwYACvnNr9o/58TJkypU0ux6r/ndTe//HHHyEQCHDlyhV0794dZ86cAQBcvHgRQqEQQUFBXPqamhqEhobCwcEBnp6erV7f1uDp6QmZTIaQkBAcOHCAdzm2M7SPYVqKzdgxrc7V1RUikQg3btyAo6Mjb7OzswMA7NmzB3FxcUhKSkJhYSHWrl2rtfIHDBiAvLw8WFlZ1SnfxMQEwJP1Oh988AHGjRuH3r17QyQS4d69e1we7u7uuHnzJi5fvqy1ejXG1dUVN27c4GZeACA1NZWXpiltA4C3334bffr0wc6dO/HRRx8hOzu7zdrxNBsbG0gkklbLXz0gFgqF3CD5yJEjXPy9e/dARKiursbdu3chk8mQkJAAlUoFAwMDFBcXY9GiRY0+z06Tjz/+WDuNaIRKpeLN2KlUKhARBAIBEhIScPPmTTx+/Bi6urqorq6GTCaDXC7n7hr19/dHfHw8NmzY8Nw+700oFCI8PBzx8fHw9/fn3RXbGdrHMC3FBnZMqzMyMsKSJUuwaNEi/PDDD8jPz0d6ejoiIiLwww8/4ObNm5g3bx7CwsIwYsQIREdHIzQ0FGfPnuXyuHPnDjIyMnDlyhUAQGZmJjIyMvDgwYNGy58+fTosLCzg5+eH5ORkXLt2DadOncKCBQtw8+ZNAICjoyN27dqFnJwcpKWlYfr06bxZOi8vL4wcORKTJk3CsWPHcO3aNRw+fBiJiYla7q3/eeWVV9CrVy/MnDkTf/zxB5KTk7Fy5cpmty0iIgKpqanYuXMnpk2bhsmTJ2P69OncbGR7ePToUasO7gBAqVTWG6ce8CkUCt7Aubq6GkuXLuUeLOzs7Ay5XA5nZ+cml9vYLG1rUrdL/RMA/Pz8oFKpMGzYMBgbG2PYsGHIysrCvn37MHHixPaqqlZMnDgR+/btQ2ZmZqdsH8O0BLsUy7SJtWvXwsrKCqGhobh69Sq6dOmCAQMGYPny5Zg9ezaGDBmC+fPnAwDGjBmD+fPnY8aMGcjIyIBUKsXWrVuxevVqLr+RI0cCAKKiojB79uwGy5ZIJDh9+jSWLVuGiRMnoqysDN26dcPo0aNhbGwMAPj+++/x7rvvon///ujevTtCQkLq3NEaGxuLJUuWICAgAI8ePYKjoyO++OILLfYSn46ODvbv34/AwEAMGTIEMpkMX331Fe8yamNtu3TpEpYuXYodO3Zws6MRERHo27cvPv30U4SFhbVa/Rvz6NGjDv/mCYlEUucSrHrN2qVLl+ACIOfSJeQU8de7ERF780QbmThxIvcfm87YPoZpLgG1538vGYZ5LpSWlsLExAQlJSXcYPjvavv27ZgzZ06jrxRjGIZ5Fi393mUzdgzDMM2gfkev64sy5KjuYce47iBdAxgZGbFBHcMw7Y7N2DHPvZCQEISEhGiM8/T0xOHDh9u4Rp0Pm7FjGIZpWy393mUDO+a59+DBg3pvohCLxXUescI0HxvYMQzDtC12KZb52zIzM4OZmVl7V4NhGIZh2h173AnDMAzDMEwnwQZ2DMMwDMMwnQQb2DEMwzAMw3QSbGDHMAzDMAzTSbCbJxiGYVogLy8P5Q/vwqD8Biql3SE1tWTPsWMYpt2xGTvmb0Umk2Hz5s3tXQ2Nnq6bQCDAgQMH2rFGTH3y8vLg5OSEQD9PuJx+D4F+nnByckJeXl57V41hmL85NmP3N7Zt2zbs3r0bFy5cQFlZGR4+fIguXbo0K4+TJ09i/fr1SEtLQ0VFBWQyGXx8fLB48eJnfn6cQCDA/v37uSf9a8O5c+dgaGiotfwAYNWqVThw4AAyMjK0mm9RURFMTU21mmdH5Ovri/j4+Cal1dfXx4svvojKykqUl5fD0NAQUqkUd+/exaNHjwAAUqkU3bt3h7u7O4gIV69eRUlJCQYNGoSNGzdCLBY/c53LysoAAOvWrQMKv8C6desw/p0VXDgAfPrpp0/in5FYLEbPnj1RUVHBtdnY2BhCoRCDBw/G+vXrcf78edy6dQt3796FpaUlunXr1mHfl9oa763tzO/CZZjmYgO7vzGFQgFvb294e3tj+fLlzT4+MjISQUFBmDVrFmJjYyGTyXDjxg3s3LkT4eHh2LhxY4vqVV1dzXsRuzZZWlq2Sr6twcbGpr2r0OoEAkGz0ldXV+PixYsNpiktLcXt27dx9uxZXvj58+exdetW+Pn5NXsmVKFQ4NKlS3B2doZEIuHCHRwcgML//7OW5rarIRUVFcjKytIYJ5fLsXXrVo1xMpkM4eHhmDhxotbq8qzi4uLw4YcfoqCggAt71nq2Rp4M8zxjl2KfY0SEL7/8Ej169IBYLEbfvn2xb98+AMCaNWvQtWtX3L9/n0v/6quvYuTIkaipefLC8oULF+Ljjz/GSy+91Oyyb968iQ8++AAffPABvv/+e4waNQoymQwjR47E9u3b8dlnnwEA7t+/j4CAALzwwguQSCRwc3PDTz/9xMtr1KhRmD9/PhYvXgwLCwuMGTMGMpkMAPDaa69BIBBw+wBw6NAhDBw4EAYGBujRowdWr14NpVLJxa9atQrdu3eHSCRC165d8cEHH3BxT1/u3LhxI9zc3GBoaAg7OzsEBQWhvLyci4+OjkaXLl1w5MgRuLi4QCqVwtvbG0VFRfX2zezZs+Hv748NGzbA1tYW5ubmeP/99/H48WMuTXFxMXx9fSEWi+Hg4IAff/yxTj5PX4q9efMm3njjDZiZmcHQ0BCDBg1CWlqaVvqlPWhz8NMQHZ0nX3Pq2eiDBw82exb40qVLGDhwIC5dutRo2rZq19OsrKzw3XffwcfHBwBgYWGByZMnIy4url3q87S4uDhMnjwZbm5uSE1NRVlZGVJTU+Hm5tbierZGngzz3CPmubVixQpydnamxMREys/Pp6ioKBKJRJSUlERKpZI8PDzI39+fiIi2bNlCJiYmVFBQUCefkydPEgB6+PBhk8veuHEjAaDbt283mO7mzZu0fv16Sk9Pp/z8fPrqq69IKBTS2bNnuTReXl4klUpp6dKldOnSJcrJyaHi4mICQFFRUVRUVETFxcVERJSYmEjGxsYUHR1N+fn5dPToUZLJZLRq1SoiItq7dy8ZGxvTr7/+StevX6e0tDTatm0bV5a9vT1t2rSJ29+0aRP99ttvdPXqVTpx4gT16tWL5s2bx8VHRUWRnp4evfLKK3Tu3DmSy+Xk4uJC06ZN49IEBwdT3759uf1Zs2aRsbExzZ07l3JycujQoUMkkUh49fDx8aE+ffpQSkoKnT9/noYNG0ZisZhXNwC0f/9+IiIqKyujHj16kKenJyUnJ1NeXh7t2bOHUlJStNIvjSkpKSEAVFJS0uRjGjJhwgQC0GablZUVCYVC8vb25sIUCkWT6yuXywkAyeVy3n72iZ+Igo0p+8RPBICmT5/eJu3R1dXVGK5QKEilUpGvry/JZDKaMGECOTg4kFKp1Mp5aymlUkkymYx8fX1JpVLx4tT1bW49WyNPhulIWvq9ywZ2z6ny8nIyMDDg/rCrBQYGUkBAABER5efnk5GRES1btowkEgnFxMRozKslA7t58+aRsbFxi+o+btw4+vDDD7l9Ly8v6tevX510tQc2ap6enhQSEsIL27VrF9na2hIRUXh4ODk5OVF1dbXGsp8e2D3t559/JnNzc24/KiqKANCVK1e4sIiICLK2tub2NQ3s7O3teX9QpkyZQlOnTiUiotzcXALAG9zm5OQQgHoHdpGRkWRkZET379/XWO9n7ZenVVZWUklJCbcVFhZqdWDXloM6ADRq1CgCQAsWLODC3n///SbX98yZMwSAYmJiSC6XU0xMDAGg9F+jiYKNKf3X6DZvk6ZN3aaUlBQCQN988w0BoJMnT2rlvLWU+jsmNTVVY7y6vs2pZ2vkyTAdSUsHdmyN3XMqOzsblZWVGDNmDC+8uroa/fv3BwD06NEDGzZswHvvvYepU6di+vTpWiufiJp0yUmlUuGLL77Anj17cOvWLVRVVaGqqqrODQyDBg1qUrlyuRznzp3D559/ziujsrISCoUCU6ZMwebNm9GjRw94e3tj3Lhx8PX1ha6u5o/6yZMnERISguzsbJSWlkKpVKKyshKPHj3i6iiRSNCzZ0/uGFtbWxQXFzdYz969e/MWb9va2iIzMxMAkJOTA11dXV6bnZ2dG7xxJSMjA/3796/3nbja7pfQ0FCsXr26wTY+T9TLDyoqKriw5tzBql6/NWPGDF747du30e///+wI1G3q06cPAHA3ijS0dKAtqMtX1+tp6vDm1LM18mSYzoCtsXtOqf9QJSQkICMjg9uys7O5dXYAcPr0aQiFQhQUFPDWWz0rJycnlJSUNPqlGR4ejk2bNuGjjz7Cb7/9hoyMDIwdOxbV1dW8dE29U7WmpgarV6/mtTkzMxN5eXkwMDCAnZ0dcnNzERERAbFYjKCgIIwcOZK3vk3t+vXrGDduHPr06YPY2FjI5XJEREQAAC+9np4e7ziBQAAiarCemo5RnzP1sc1Zi9XYnZza7BcAWL58OUpKSritsLCwyXXtiNTr7Gr3Y3OeOade4xkTEwO5XI6YmBgAQNeuXXk/25u6TeqbLdQDWVtb23arU+3y67sJRB3enHq2Rp4M0xmwgd1zytXVFSKRCDdu3ICjoyNvs7OzAwDs2bMHcXFxSEpKQmFhIdauXau18idPngx9fX18+eWXGuP/+usvAEBycjL8/PwwY8YM9O3bFz169GjyTImenh5UKhUvbMCAAcjNza3TZkdHR94f71dffRVfffUVkpKSkJqays2W1Xb+/HkolUqEh4fjpZdegpOTU5vMvLi4uECpVOL8+fNcWG5uLtdnmri7uyMjIwMPHjzQGK/NfgEAkUgEY2Nj3qZNEyZM0Gp+jcnOzoZQKERubi4Xtn79+iYfrx4Quri4YMCAAXBxcQHwpJ9q/9TmrHhD6ptpXb9+PWpqahAaGgqZTIbExEQ4ODjA09OzTepVH09PT8hkMoSEhHD/wVFT17e59WyNPBmmM2CXYp9TRkZGWLJkCRYtWoSamhqMGDECpaWlSElJgVQqxejRozFv3jyEhYVhxIgRiI6Oxvjx4+Hj48PdBXvnzh3cuXMHV65cAQBkZmbCyMgI3bt3r/eSn5qdnR02bdqE+fPno7S0FDNnzoRMJsPNmzexc+dOSKVShIeHw9HREbGxsUhJSYGpqSk2btyIO3fucH8YGyKTyXDixAkMHz4cIpEIpqam+OyzzzBhwgTY2dlhypQp0NHRwf/93/8hMzMT69atQ3R0NFQqFYYOHQqJRIJdu3ZBLBbD3t6+Tv49e/aEUqnE119/DV9fX/z+++/1PjpCm3r16gVvb2/MmTMH27Ztg66uLhYuXNjgrFxAQABCQkLg7++P0NBQ2NraIj09HV27doWHh4dW+6UtHDp0qE3vii0uLoaJiQkSExMBAH5+flp5nt3TFi9erPEOZ23TNPtuZWWFXbt24cCBAzh8+DAGDRqEhIQE7Nu3r92f6SYUChEeHo7JkyfD398fy5cvR58+fZCVlYXQ0FDEx8c3u56tkSfDdAqtseCPaRs1NTX073//m3r16kV6enpkaWlJY8eOpaSkJBo9ejSNHTuWampquPSLFi2inj17UllZGRE9WfQPDQuwo6KimlyHY8eO0dixY8nU1JQMDAzI2dmZlixZwt0te//+ffLz8yOpVEpWVlb0ySef0MyZM8nPz4/Lw8vLixYsWFAn719++YUcHR1JV1eX7O3tufDExETuLlJjY2MaMmQId4fn/v37aejQoWRsbEyGhob00ksv0fHjx7ljn755YuPGjWRra0tisZjGjh1LO3fu5N1IEhUVRSYmJrx67d+/n2r/09F080Tt9hERLViwgLy8vLj9oqIiGj9+PIlEIurevTvt3LmzTt3w1M0jBQUFNGnSJDI2NiaJREKDBg2itLQ0rfRLY7R9V6yaps9fa29Pn5umePToEcnlcnr06BERESUnJxMAiosIJgo2poTtIQT8767Z9mjX05uDgwPFxsZq83Q9s9jYWJLJZFqtZ2vkyTAdQUu/dwVEjSwWYhjmb6+0tBQmJiYoKSnR+mXZ5/HNE9u3b8ecOXPQ30YHF96TYkBkOdLv1ODy5cvcOjf25gnN2JsnGKZpWvq9ywZ2DMM0qjUHds+je/fu4cCBA3B9UQZT1T1USrtDamrZrBsyGIZhGsIGdoxWhYSEICQkRGOcp6cnDh8+3MY1YtoTG9gxDMO0LTawY7TqwYMH9d6BKRaL0a1btzauEdOe2MCOYRimbbX0e5fdFctoZGZm1uidsQzDMAzDdCzsOXYMwzAMwzCdBBvYMQzDMAzDdBJsYMcwDMMwDNNJsIEdwzAMwzBMJ8EGdgzDMAzDMJ0EuyuWYRimBfLy8lD+8C4Mym+wBxQzDNNhsIEd02EUFBTAwcEB6enp6Nevn9byFQgE2L9/P/z9/duk3FGjRqFfv37YvHnzM+elLTKZDAsXLsTChQsBNN4nbUWlUsHb2xvHjx9v1nFGRkawsrKCTCbD/PnzcfDgQRw6dAhVVVWwsbGBv78/bGxsYGVlhaKiIhw7dgx//fWX1l4rlpeXBycnpwZfKbZv3z5MmTLlmcoBnrzs3tTUFJaWlujZsydMTU0xbdo06Ojo4MiRI9izZw+qq6vRs2dPfPzxxzh//jyAJ5/DUaNG1ftqrY7wGq6OUAeG6XS0+8pa5u8kMjKSvLy8yMjIiADQw4cPnym/a9euEQBKT0/XUg2fAED79+9vs3K9vLxowYIFWslLW4qLi7kX2BMRFRUVUWVlZZOPb+nLqBsSGxur9RffN3Xz8/N7prrL5XICQAnbQ4iCjSlhewgBILlcTkTUbu16erOysqLY2FiNfS+TyXhpZTKZxrStpSPUgWE6spZ+77I1dkyLKRQKeHt7Y8WKFe1dFaYRlpaWkEgk3L6NjQ1EIlG71ScuLg6TJk3Ser6121iblZUVgCftBoCDBw82e7ZSoVDgwoULUCgUXJiDgwPvJ/BkNrQtWVtb1wmztbXFiBEjUFxcjMmTJyMuLo6Li4uLw+TJk+Hm5obU1FSUlZUhNTUVbm5uddK2lo5QB4bptFppoMk8B2pqaigsLIwcHBzIwMCA3N3dae/evUREtHr1arK1taV79+5x6X19fcnT05NUKhUvn5MnT7Zoxi4tLY369etHIpGIBg4cSHFxcXVmzpKSkmjw4MGkr69PNjY2tGzZMnr8+DEXb29vT5s2beLl27dvXwoODub2AdC3335L3t7eZGBgQDKZjH7++WcuXtOM3cWLF8nHx4cMDQ3JysqKZsyYQXfv3m1Su56esXvw4AG9+eab1KVLFxKLxeTt7U2XL1/mHbNv3z5ydXUlfX19sre3pw0bNvDi7e3tac2aNRQQEECGhoZka2tLX331VZPqoz6+dj+hkVnMp2lzxk6pVLbaDJVQKCQfHx9emL6+PslkMpowYQLJZDJevEKhaHK91bN0crmc+z37xE9EwcaUfeInAkBhYWFtPisnFApJLBaTlZUV6erqcuEPHjygCRMmkEQiIQcHB1IqlaRUKkkmk5Gvr2+df8cqlYp8fX25tK2lI9SBYZ4HbMaOabZPPvkEUVFR2LJlCy5evIhFixZhxowZOHXqFFauXAmZTIZ33nkHALB161acPn0au3btgo7Os39sHj16hAkTJqBXr16Qy+VYtWoVlixZwktz69YtjBs3DoMHD8Yff/yBLVu2YMeOHVi3bl2zy/v0008xadIk/PHHH5gxYwYCAgKQk5OjMW1RURG8vLzQr18/nD9/HomJifjzzz/x+uuvt6its2fPxvnz5/HLL78gNTUVRIRx48bh8ePHAAC5XI7XX38db7zxBjIzM7Fq1Sp8+umniI6O5uWzfv16uLu748KFC1i+fDkWLVqEY8eOtahOjamqqkJpaSlv05bk5GSt5fU0lUoFJycnXlh1dTUKCgrg7e2NgoICjB8/notbunRpk/OuqKgAAOTk5HCfnaqqKt7PZcuWPVP9m0MqlQJ40uaKigqsW7cOSqWSi/f19cWKFSugUChw7do1JCcnIzk5GQUFBVixYkWdf8c6OjpYvnw5l7a1dIQ6MEyn1jrjTKajKy8vJwMDA0pJSeGFBwYGUkBAABER5efnk5GRES1btowkEgnFxMRozKslM3aRkZFkZmbGW/e1ZcsW3szZihUrqFevXlRTU8OliYiIIKlUyv1Pv6kzdnPnzuWlGTp0KM2bN4+I6s7Yffrpp/TPf/6Tl76wsJAAUG5ubqNtqz1jd/nyZQJAv//+Oxd/7949EovF3KzhtGnTaMyYMbw8li5dSq6urty+vb09eXt789JMnTqVfHx8Gq2P+vjmzNgFBwdrnB3Sxozd7t27W3UG691339UYvmPHDt5PAHXOc0NiYmLq5Pn0Gru23Ozs7Hj7t2/frhNfWlrK7Xdj2jIAACAASURBVO/evZvr+7KyMo1tVKffvXv3M5/n+nSEOjDM84DN2DHNkp2djcrKSowZMwZSqZTbdu7cifz8fABAjx49sGHDBoSFhcHX1xfTp0/XWvk5OTno27cvb02Uh4dHnTQeHh68NUvDhw9HeXk5bt682azyns7bw8Oj3hk7uVyOkydP8vrF2dkZALi+aaqcnBzo6upi6NChXJi5uTl69erFlZ+Tk4Phw4fzjhs+fDjy8vKgUqla1IZntXz5cpSUlHBbYWGh1vK2tbXVWl6a1HfHq3rGTf0TQLMeTyKTyQAAMTExiImJAQB07dqV97MtPXz4kLcfHx/P2+/evTuysrK4fVtbW67va4fXpg5vzXPUEerAMJ0Ze9zJ31RNTQ0AICEhAd26dePF1V5Uf/r0aQiFQhQUFECpVEJXVzsfGSJqUpqnF6Krj1OH6+jo1MlLfYmzMfUtcq+pqYGvry/CwsLqxDX3j0197azdtoba2ZjWWqgvEola7eYKT0/PVskXePJokMuXL/PC9PX10bVrVyQmJkImkyEhIYGLW79+fZPzVg8YXVxcuDB1H6l/hoWFtdnl2PLycgBP2qyvr49PPvkEurq63OXYQ4cOYebMmZBIJLC2tub6XSaTISQkBAcOHOBdCq2pqUFoaCgcHBxa9Rx5enq2ex0YpjNjM3Z/U66urhCJRLhx4wYcHR15m52dHQBgz549iIuLQ1JSEgoLC7F27Vqtlv/HH3/wZk/Onj1bJ01KSgpvkJOSkgIjIyNuMGppaYmioiIuvrS0FNeuXatT3tN5nz17lpuFe9qAAQNw8eJFyGSyOn1jaGjY7HYqlUqkpaVxYffv38fly5e5AYKrqyvOnDnDOy4lJQVOTk68Z3o1pw0dmVAoRGxsbKvkra+vj8OHD/PCqquroVAoEB8fj8rKSi7ez8/vmZ9n97RXXnlFq/k1hYWFBSoqKlBcXMwN6mxtbeHr64v4+HhUVFRgw4YNEAqFEAqFCA8PR3x8PPz9/Xl3pPr7+yM+Pp5L21o6Qh0YplPT7hVh5nmycuVKMjc3p+joaLpy5QpduHCBvvnmG4qOjqbCwkIyNTXl7rw8evQo6enpUWpqKnd8UVERpaen03fffUcA6PTp05Senk73799vtOyysjKysLCggIAAunjxIiUkJJCjoyNvrdvNmzdJIpHQ+++/Tzk5OXTgwAGysLDgrZ/7+OOPycbGhk6fPk2ZmZnk7+9PUqm0zho7CwsL2rFjB+Xm5tJnn31GOjo6dPHiRSKqu8bu1q1bZGlpSZMnT6a0tDTKz8+nI0eO0FtvvdWkO/WevivWz8+PXF1dKTk5mTIyMsjb25scHR2purqaiJ7cbamjo0Nr1vw/9u48Lqrq/x/4axgGmGGVHUkZFFFwB7VQEfyYCeaWa6UpffiaafURU3PLXCiM1E9qkmkalKhlgZriWoGSmBpSKbjggrigLCqLrDO8f3/4m/txBGSbYWB8Px+P+5B77rnnvO+Z63C499xzl9PFixcpKiqKpFIpRUZGCmW4uLiQhYUFhYeH08WLF2n9+vUkFovp4MGDtcaj2r+5PBWr0tLmsXv48CElJycL/wJVn4ptyfPYubq66nweu6aOgbHmrKHfu9yxe4ZVVlbS2rVrqWPHjiSRSMjOzo6GDBlCCQkJNGjQIBoyZIjagwuzZs2i9u3bC4Oeaxpg/3iH5GlOnDhB3bt3JyMjI+rRo4fwi74+053k5+fT+PHjycLCgtq0aUNRUVHVPjwRERFBgwcPJmNjY3JxcaEdO3YI26ub7uTSpUv0yiuvCFOUdOrUiUJCQtTaoyY1TXdiaWlJUqmUhgwZUuN0JxKJhNq2bUsrV65U2+7i4kLLli2j8ePHk0wmIwcHB1qzZk3tjfzY/s2tY0f0aOqLF198sd4dFnNzc2rfvj0NGjSIdu3aRUFBQWRjY0NmZmbk5uZGc+bMoVWrVtF3331H4eHh9OKLL1KvXr3o7bffrtcUJzVJTEwkABQbsaTaCYqJiH788UeNdM7EYjHZ2tqSh4cHDRs2jN544w06cOAAHTp0iN5//31ydnYmOzs7euGFF2j37t304Ycf0ocffki//PLLU/8QUSgUFB8fT9u3b6f4+HidTC/SHGJgrLlq6PeuiKiOg3kYYzrz5CvB6svJyQmhoaHC9DX1VVBQAEtLS+Tn58PCwqJBZeiTzZs3Y+rUqU99pRhjjDVGQ793+eEJxvRYcXExjh8/jrt376Jz5866DkdvqN5a4dlBjvPKXGwZ2hZmrey4U8cY0znu2DGtCAsLQ1hYWLXbfH19qwxwbykyMzPh6elZ4/a0tDS0bdu2CSMCtm3bhmnTplW7jYhgYmKCkJCQKtOlsIaztbVt8NVPxhjTJr4Vy7Ti3r17uHfvXrXbpFJplSlWWgqFQoGMjIwat8vlco1NCVNXhYWFuHv3brXbJBIJXFxcGl0H34pljLGmxbdiWbNibW0Na2trXYehcYaGhnBzc9N1GGrMzc1hbm6u6zAYY4w1AzyPHWOMMcaYnuCOHWOMMcaYnuCOHWOMMcaYnuCOHWOMMcaYnuCHJxhjrIHS09NRWFgIkaIUJkWZKDVrCzI0gbm5Oc9pxxjTCb5ix5qcv79/rW9QiIqKgpWVlUbrDQoKEiaW1WfaaDtWVXp6Otzd3eHt7Y3gkb7wODYNwSN94e3tDXd3d6Snp+s6RMbYM4iv2DEAwKZNm7B9+3acOXMGhYWFuH//vtY6B7GxsZBIJMJ6Y1+XpS0JCQkYOHCgVtuiroKCgvDgwQPs3r271rwTJkzA0KFDmyCqxlMqlfjvf/+LDz74QONli8ViODg4QKFQIDc3F5WVlcI2kUgEsVgMU1NTWFpawtzcHN27d0dQUBD+9a9/QSwW11p+YWEhACA6OhpeTmLg2DRs27YNZ7KUmDRpkrD9cQMHDkRCQoLGjvFpDAwMIJPJYGBggKKiIgCAvb09OnTogGvXriEvLw8ikQhSqRRt27aFt7c3XF1dsX//fhARbGxs4OjoiOzsbBARLC0t8frrr0MikeDOnTu4e/cucnJykJGRgdzcXJiamsLX1xczZsxAUlKScJz+/v7w9/cHACQmJuLWrVvIycmBnZ0dnJ2d4evrK7S3UqlEQkICfvvtN2RmZqJt27b417/+BX9//6d+JkqlEomJicjKyoKTk5NamYw9a7hjxwA8evVUQEAAAgICsGDBAq3WpY/z2zUXFRUVkEqlkEqlug6lVrGxsRgzZozWylcqlbh9+3a124gICoUC+fn5yM/PBwCkpqZi+/btsLCwwOLFizFjxgzIZLJa6/Hw8ICHowFwDPDo1AklVpXV5hOJRA0/mAaorKwUOnQqd+7cwZ07d9TSiouLkZeXh5SUlFrL3Lp161O379mzB3PmzFFL+/jjj2FhYQETExNkZ2dX2Ucul2P16tUAgLfffhs5OTlq28PCwmBvb48NGzZg9OjRVfaPjY3F7Nmz1SYOV5VZXX7G9B3fitUTRITPPvsM7dq1g1QqRffu3fHTTz8BAJYvX47WrVsjLy9PyD9ixAgMGDBAuIoREhKC+fPn44UXXqh33WPGjMF7770nrIeEhEAkEiE1NRXAo7c1mJub49ChQwDUb8X6+/vj+vXrmDVrFkQiUZVffocOHYKHhwfMzMwQEBCArKysOsWkVCrx/vvvw8rKCjY2Nvjggw/w5EtWysrK8J///Af29vYwMTFB//79cfr0aQBARkYGBg4cCABo1aoVRCIRgoKCaq3X398f7733HkJCQtCqVSs4ODhg06ZNePjwId58802Ym5ujffv2aq9UUyqVCA4OhqurK6RSKTp27Ii1a9cK25cuXYpvv/0We/bsEdooISEBGRkZEIlE2LlzJ/z9/WFiYoLo6Gi1W7FEhBdffBEBAQHC8T948ABt27bFokWL6tSW2qDtTl1jFBQUYO7cufjyyy81VmZTd+oa68l4VW9Tqek47O3tq6SNHz8ev/76Kzp16oSCggJkZ2dDJBIhMDAQX3/9NQIDAwE8ej3bmDFjMGbMGKFT5+Pjgy+++EJ4DV52djbGjh2L2NhYtTpiY2MxduxYdO3aFSdOnEBhYSFOnDiBrl27VpufsWcCMb2wcOFC6tSpEx08eJCuXLlCkZGRZGxsTAkJCaRQKMjHx4dGjRpFREQbNmwgS0tLysjIqFJOfHw8AaD79+/Xue5169ZRly5dhPUePXqQra0tRUREEBFRUlISGRoaUmFhIRER+fn50cyZM4mIKC8vj5577jlavnw5ZWVlUVZWFhERRUZGkkQioRdffJFOnz5NycnJ5OHhQa+//nqdYgoPDydLS0v66aefKC0tjYKDg8nc3JxGjhwp5PnPf/5DrVu3pv3791NqaipNmTKFWrVqRXl5eaRQKCgmJoYA0MWLFykrK4sePHhQa71+fn5kbm5OoaGhdOnSJQoNDSUDAwMKDAykTZs20aVLl2j69OlkY2NDDx8+JCKi8vJy+uijj+jUqVN09epVio6OJplMRj/88AMRERUWFtL48eMpICBAaKOysjK6du0aASC5XE4xMTF09epVunXrFkVGRpKlpaUQ082bN6lVq1a0Zs0aIiKaMGEC9erVi8rLy+vUlkRE+fn5BIDy8/PrvE9NFAoFSaVSAtCsl9atW5NCoajxOJKTkwkAJScnE91KIVpiQXQrRT2diPz9/XV+LDUtBgYGT90mkUiE9cd/Vi329vb08ssvk4uLC5mYmAj7GRgYkKGhIRUXF5NcLid7e3sSiUQkk8mE806pVNLw4cPV9pVKpTRs2DBSKpVCnmHDhpFUKiWZTEaurq7CZ6JQKEgul9Pw4cOF/Cqqsh/Pz1hL09DvXe7Y6YGioiIyMTGhpKQktfTg4GB67bXXiIjoypUrZG5uTvPmzSOZTEbR0dHVltWQjt0///xDIpGIcnJy6N69eySRSOjjjz+mcePGERFRWFgYPf/880L+xzt2REQuLi70+eefq5UZGRlJAOjy5ctCWkREBDk4ONQpJicnJ/r000+F9YqKCnruueeEjl1RURFJJBLatm2bkKe8vJxat25Nn332GRE1rC38/Pyof//+wrpCoSBTU1N64403hLSsrCwCQCdOnKixnBkzZtCYMWOE9SlTpqh1SolI6NipOmwqT3bsiIh27txJxsbGtGDBApLJZHTx4sWnHkdpaSnl5+cLy40bNzTWsVO1a0tYNm7cSMnJydUu0dHRBIB+//13tY7d77//TgAoOjpa6OS11GXevHnCz15eXlW2z5kzh5KSkmrc/5133iEANHv2bCEtPj5eOBeq2/fJ/xdP5lHtrzqPavp/pNrv8foYa0ka2rHjMXZ6IC0tDaWlpRg8eLBaenl5OXr27AkAaNeuHVatWoVp06ZhwoQJmDhxosbq79KlC2xsbHD06FFIJBJ0794dI0aMwLp16wA8egjBz8+v3uXKZDK0b99eWHdycqp2jM6T8vPzkZWVJdzGAR7dSurVq5dwO/LKlSuoqKhAv379hDwSiQR9+vTB+fPn6x3r47p16yb8LBaLYWNjg65duwppDg4OAKB2LF999RU2b96M69evo6SkBOXl5ejRo0ed6uvVq1etecaNG4ddu3ZhxYoV2LBhA9zd3Z+af8WKFVi2bFmd6q+vut5Obw6mTZtWa56MjAz0c+2stg4AkyZN0lZYTSY4OBjh4eEAUO24zXbt2qFLly417q96Mrhdu3ZC2uOff3X7Ppn25Lpqf9W/NdWvSm9J5xtjmsAdOz2gGicXFxcHZ2dntW3GxsbCz8eOHYNYLEZGRgYUCoUwbqaxRCIRBgwYgISEBBgZGcHf3x9dunSBUqnE2bNnkZSU1KAnXh9/clZVDz0xTq6hVOU8OWaIiBo9Hqq6uB9PU5Wv+tx27tyJWbNmYfXq1fDx8YG5uTlWrlyJkydP1qk+U1PTWvMUFxcjOTkZYrG4TtNwLFiwAO+//76wXlBQgDZt2tQpnto4OTlppJymsHHjxho7zufPn8ekSZMgl8vV0lXr0dHR8PDwgLe3t5aj1J4tW7YIP5eUlFTZfvXqVZw7d67G/Tt06IDDhw/j6tWrQtrjn391+547d05trO+TeVT7q/59Mv+T+7Wk840xTeCHJ/SAp6cnjI2NkZmZCTc3N7VF9cv4hx9+QGxsLBISEnDjxg2EhoZqNAZ/f38kJCQgISEB/v7+EIlE8PX1xapVq1BSUqJ2ZexJRkZGUCqVGovF0tISTk5O+OOPP4Q0hUKB5ORkYd3NzQ1GRkb4/fffhbSKigr8+eef8PDwEOICoNHYqpOYmIi+fftixowZ6NmzJ9zc3HDlyhW1PI1to9mzZ8PAwAAHDhzAunXr8Ntvvz01v7GxMSwsLNQWTfH19W0RT+22bt0awcHB8PLyqnZRnSdPHotq3cPDA15eXsJUH82RgUHNvwIMDAzw3//+V1g/e/ZslTzfffcdPvnkE7i4uMDExETYz8DAAIaGhli5ciXkcjm2bt0KkUgEmUwmfBdUVlZixYoVavtKpVJ88sknwh89lZWVCAsLg1QqhUwmg6urK3x9fQE8Oo/kcjnCwsLUprJ5vOzH8zP2rOCOnR4wNzfHnDlzMGvWLHz77be4cuUKUlJSEBERgW+//RY3b97E9OnTER4ejv79+yMqKgorVqxQ6/jcuXMHf/31Fy5fvgzg0Zf4X3/9hXv37tUpBn9/f6SmpuLs2bPCF6m/vz+2bdsGLy+vp3YM5HI5jh07hlu3biE3N7cRLfE/M2fOxKeffopdu3bhwoULmDFjBh48eCBsNzU1xfTp0zF37lwcPHgQaWlpmDp1KoqLixEcHAwAcHFxgUgkwr59+5CTk1Nl6ghNcXNzw59//olDhw7h0qVLWLx4sfB0ropcLsc///yDixcvIjc3FxUVFXUuPy4uDt988w22bduGwYMHY/78+ZgyZQru37+v6UOpE7FYjOjoaJ3UXR+rVq3SyFxo8fHxGohGO57sEKmIRCJUVlYK55mhoSEqKiqqXM3Ozs5GXFwciouLUVpaKpRZWVmJ0aNH4/jx48I0J0SEkpISjBw5Eps2bcKwYcOwd+9e2NnZCfuWlJRg37596NevH9atW4e+ffti3759KCkpQUlJidpnIhaLsXr1auzbtw+jRo1Seyp21KhR2Ldvn8Y+Q8ZaFM0P92O6UFlZSWvXrqWOHTuSRCIhOzs7GjJkCCUkJNCgQYNoyJAhVFlZKeSfNWsWtW/fXnhSdcmSJdUOfo6MjKxz/XZ2dtSrVy8hLSUlRRhg/bgnH544ceIEdevWjYyNjUl1Slb3AMCuXbuorqdsRUUFzZw5kywsLMjKyoref/99mjx5stoDCCUlJfTee++Rra0tGRsbU79+/ejUqVNq5SxfvpwcHR1JJBLRlClTaq33yWMjqv7hEAC0a9cuInr0oEJQUBBZWlqSlZUVTZ8+nebPn0/du3cX8mdnZ9PgwYPJzMxMGBCuengiJSVFrezH2y47O5scHBwoLCxMrW369OlD48ePr/V4VDT5VKyK6qnj5rZYWlpSTExMrfEnJiYSAPr6668p7dcdREssKO3XHcJDFaqnYlV0fVy6XCwsLMje3r7aba6urhQTE0MxMTFkZ2dXbR57e/saP5OYmBiSy+XVlslYS9bQ710RkYYGLTHG9FZBQQEsLS2Rn5+v0duyLfnNE5s3b8bUqVMBAD0dDXBmmhm8NhYh5c6jei5dulTlfbH85gl+8wRjddXQ713u2DHGaqWtjl1Llpubi927d6NTp04wNTKASVEmSs3aggxNYG5uXqVTxxhj9cEdO6Y1YWFhCAsLq3abr6+v2lsUmoqZmVmN2w4cOKCVAdOZmZnw9PSscXtaWhratm2r8XqbA+7YMcZY0+KOHdOae/fu1fgQhVQqrTLFSlNQPeRRHWdnZ608dalQKNTeR/kkuVyusSlkmhvu2DHGWNNq6Peufv4WYhplbW0Na2trXYehxs3NrcnrNDQ01Em9jDHGWF3xdCeMMcYYY3qCO3aMMcYYY3qCO3aMMcYYY3qCO3aMMcYYY3qCO3aMMcYYY3qCn4pljDE9l56ejqL7OWqTKAPgiZQZ00PcsWPNRkZGBlxdXZGSkoIePXporFyRSIRdu3Zh1KhRTVKvv78/evTogTVr1jS6LE15sg1qaxP2yKlTp/D8889rvR4jIyPY29sLrzlzdHQU1tu0aQNra2s8ePAABgYGwiu66vrKrPT0dLi7u1f72jOg6qvPgoOD8c0332j8GKsjkUggFothbm4OZ2dn2NjYwNXVFXfu3MGlS5cgk8kglUrRvXt3dOjQAV27dkVubi7s7e0BALdv38bJkyehVCohEolgZWUFsVhc7zZiTJ9wx4412KZNm7B9+3acOXMGhYWFuH//PqysrHQdFqtGVlYWWrVqVeM6q0okEjVZXeXl5bh586awnpaWVmPejz/+GPb29tiwYQMCAgJw4cIFdOrUCTKZrNr8hYWFwn648Sm2bduGEit3nD9/HpMmTRK2A017zABQUVGBiooKlJaWIicnp8Z8J06cqFe5j7fR6NGjGxsmYy0Kj7FjDVZcXIyAgAAsXLhQ16GwWjg6OsLY2LjGdaauqTs49dGpUydkZ2dj7Nix+PLLL+Ht7Y0LFy7Uup+rqysAwKNTJ3h5ecHDw0Nte3M+ZhXVFbiaXimo6tw6OzsLbRQbG9tk8THWHHDH7hlGRPjss8/Qrl074XbHTz/9BABYvnw5Wrdujby8PCH/iBEjMGDAAFRWPrqNExISgvnz5+OFF15oUP2nTp1Cz549YWJigl69eiElJaVKnqNHj6JPnz4wNjaGk5MT5s+fD4VCIWyXy+VVbnn26NEDS5cuVUvLyspCYGAgpFIpXF1d8eOPPz41trS0NAwdOhRmZmZwcHDAG2+8gdzc3AYd5/379zF58mS0atUKMpkMgYGBSE9PV8sTExODzp07w9jYGHK5HKtXr1bbLpfLERoaitdffx1mZmZo3bo1vvjiizrHIBKJsHv37hrX2f+cOnVK1yFUYWxsDKlUCplMhtLSUrz88suQSqX4/PPPNVJ+cHCwRsrRNGdnZxgY/O/XlFKphKGhIYqKimBnZwcTExOIRCK8/PLLGDZsGOzs7ODg4IA7d+5g6NChkEqlmDNnDpRKpQ6PgrGmxR27Z9iHH36IyMhIbNiwAampqZg1axYmTZqEo0ePYtGiRZDL5fi///s/AMBXX32FY8eOYevWrWpftA318OFDDBs2DB07dkRycjKWLl2KOXPmqOW5desWhg4dit69e+Pvv//Ghg0bsGXLlke3lOpp8eLFGDNmDP7++29MmjQJr732Gs6fP19t3qysLPj5+aFHjx74888/cfDgQdy9exfjx49v0LEGBQXhzz//xM8//4wTJ06AiDB06FBUVFQAAJKTkzF+/Hi8+uqrOHv2LJYuXYrFixcjKipKrZyVK1eiW7duOHPmDBYsWIBZs2bhyJEjDYqpNmVlZSgoKFBbnhVNMaauvsrKylBSUoLi4mJkZGQgMDAQxcXFuH37NgDg/PnzOHPmTLWL6jwvKytTK7OkpETYt6nG1NXXrVu3hD8kVVTj6zp37ozS0lLh/9PChQtx/fp1TJw4EUqlEh06dEBxcTGuXbuGxMREXYTPmG4QeyYVFRWRiYkJJSUlqaUHBwfTa6+9RkREV65cIXNzc5o3bx7JZDKKjo6utqz4+HgCQPfv369z/Rs3biRra2t6+PChkLZhwwYCQCkpKUREtHDhQurYsSNVVlYKeSIiIsjMzIyUSiUREbm4uNDnn3+uVnb37t1pyZIlwjoAevvtt9XyPP/88zR9+nQiIrp27ZpavYsXL6aXXnpJLf+NGzcIAF28eLHWY/Pz86OZM2cSEdGlS5cIAB0/flzYnpubS1KplHbu3ElERK+//joNHjxYrYy5c+eSp6ensO7i4kIBAQFqeSZMmECBgYG1xkP0qA127dpV4/qTlixZQgCqLPn5+XWqryWr7rib27Jly5Z67xO3OYxoiQXRrUfneXR0tM6PoyGLo6MjASA/Pz8h7ZtvvqGCggICQOvXrycA9NZbbwnbt2/fruOzirH6y8/Pb9D3Ll+xe0alpaWhtLQUgwcPhpmZmbB89913uHLlCgCgXbt2WLVqFcLDwzF8+HBMnDhRY/WfP38e3bt3Vxvw7ePjUyWPj4+P2tiffv36oaioSG2geV08WbaPj0+NV+ySk5MRHx+v1i6dOnUCAKFt6ur8+fMwNDRUuwpkY2ODjh07CvWfP38e/fr1U9uvX79+SE9PV7uFVJ9jaKwFCxYgPz9fWG7cuKGVeljDqK62qURHRyM5ObnaJTo6GgDQunVrtX3kcrmwb0uiumPw+PdCSUkJzp07BwC4evUqAEAqlQrbnZycmjBCxnSLn4p9Rqlub8TFxcHZ2Vlt2+OD6o8dOwaxWIyMjAwoFAoYGmrmlCGiOuV5ckC3aj9VuoGBQZWyVLc4a1PTYPHKykoMHz4c4eHhVbbV9xdETcf5+LE97Thro60B78bGxs/swxUnT55sdrdjjY2NYWBgAJFIBHt7exw4cAAymQxWVla4ffs2PDw84OXlVWsZj1N1fDw8PPDvf/+7Wd6OdXZ2RlZWltrt2OzsbABAamoqTExMUFZWhv379+PAgQNwcXHBtm3bIBaLkZ6eDplMBgcHB/j6+urqEBhrcnzF7hnl6ekJY2NjZGZmws3NTW1p06YNAOCHH35AbGwsEhIScOPGDYSGhmq0/r///lvtysMff/xRJU9SUpJaJycpKUmY8woA7OzskJWVJWwvKCjAtWvXqtT3ZNl//PGHcBXuSV5eXkhNTYVcLq/SNqampvU+ToVCgZMnTwppeXl5uHTpkvBUoqenJ37//Xe1/ZKSkuDu7q42D1d9joE1XJ8+fXQdQhWPj7EzMTFBXFwcSkpKMGvWLI2USymqOAAAIABJREFUv2XLFo2Uo2lPjrETi8VQKBQwMzNDTk6OMMYuLi4O+/btQ05ODu7evQtHR0fs378fJSUlWLVqFc9nx54tGr0hzFqURYsWkY2NDUVFRdHly5fpzJkztH79eoqKiqIbN25Qq1ataN26dUREdPjwYZJIJHTixAlh/6ysLEpJSaGvv/6aANCxY8coJSWF8vLyaq27sLCQbG1t6bXXXqPU1FSKi4sjNzc3tbFuN2/eJJlMRu+88w6dP3+edu/eTba2tmrj5+bPn0+Ojo507NgxOnv2LI0aNYrMzMyqjLGztbWlLVu20MWLF+mjjz4iAwMDSk1NJaKqY+xu3bpFdnZ2NHbsWDp58iRduXKFDh06RG+++SYpFIpaj+3xMXZERCNHjiRPT09KTEykv/76iwICAsjNzY3Ky8uJiCg5OZkMDAxo+fLldPHiRYqKiiKpVEqRkZFCGS4uLmRhYUHh4eF08eJFWr9+PYnFYjp48GCt8ajaoD5j7J7U0LEeLRmawXiymhZ7e3uKiYmhhw8fUnJystpY1SclJiYSAIqNWEK0xILSft1BycnJwhi75OTkFnHMDW0jxlqqhn7v8q3YZ1hoaCjs7e2xYsUKXL16FVZWVvDy8sKCBQsQFBSEPn364N133wUADB48GO+++y4mTZqEv/76C2ZmZvjqq6+wbNkyobwBAwYAACIjIxEUFPTUus3MzLB37168/fbb6NmzJzw9PREeHo4xY8YIeZydnbF//37MnTsX3bt3h7W1NYKDg/Hhhx8KeRYsWICrV69i2LBhsLS0RGhoaLVX7JYtW4bvv/8eM2bMgKOjI7Zt2wZPT89qY2vdujWOHz+OefPmYciQISgrK4OLiwsCAgIa9ERwZGQkZs6ciWHDhqG8vBwDBgzA/v37IZFIADy6Qrhz50589NFHCA0NhZOTE5YvX16lDWfPno3k5GQsW7YM5ubmWL16NYYMGVLveFjdEFGLePNEbbdgVXPchYaG4pVpZpg4caLamyfMzc2Fn4mI3zzBWAsnIqrjYB7GmM7I5XKEhIQgJCSk0WWVlZXBxMQER44cwYsvvlinfQoKCmBpaYn8/HxYWFg0OgbWdHJzc7F79254dpCjlTKX3xXLWAvR0O9dvmLH2DOkoKAAsbGxMDAw4PF5zwhbW1thPkrGmP7jhyeYVoSFhalNF/L4EhgYqOvwGiwzM7PG4zIzM0NmZmaTx7Rt27Ya4+ncubNa3iVLlmDevHkIDw/Hc8891+SxMsYY0y6+Fcu04t69e7h3716126RSaZUpVloKhUKBjIyMGrfL5XKNTQlTV4WFhbh792612yQSCVxcXBpdB9+KZYyxpsW3YlmzYm1tDWtra12HoXGGhoZwc3PTdRhqzM3N1QbAM8YYe3bxrVjGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BD08wxhirk/T0dBTdz4FJUSYkTp3h5tFV1yExxp7AHTv2zPD390ePHj2wZs2aGvNERUUhJCQEDx48aMLINCshIQEDBw7E/fv3YWVlpetwmi2lUolx48Zh165d9d5XLBZDJpPBysoKrVq1QkFBASQSCdzd3SGTyZCamoqCggIUFRVBJBJBLpdj3LhxKCoqEl4L5uvri8TERCQkJAAAfH19IRaLkZ2dLbwyKzs7G05OTsI2pVKJxMREZGVlCekAcPjwYYSFheH333+vNXaZTAYnJyfI5XLMnDkTaWlp2Lt3LwCga9eu6Nu3L9q0aSPUqZKeng53d3f0dDTAmWlm8NpYhB+OXUCHDh2wZMkSLF++vN7t+DgDAwMYGBigsvJ/rzt7/GexWAwbGxu0b98eo0ePxn/+8x8YGRk1qs6WQKlUIiwsDB999FG1221tbWFnZwcnJyc4OjpCLpfjX//6l169Uq26815fjk0rNP7WWsbqYePGjeTn50fm5uYEgO7fv6+1uvLy8qigoEBYd3Fxoc8//1wtT2RkJFlaWmothoZasmQJde/evU55y8rKKCsriyorKzVWf0NfRt1cxcTE6Pwl9SKRqM555XI5zZ07l+RyuVq6nZ0dGRkZaSU+uVxOMTExQpslJycTAIrbHEa0xIJ6OhoIabpqv7lz5+rwLNK+xpyn9vb2ap9fSxUTE1PlvH/y3NRXDf3e5TF2TKeKi4sREBCAhQsXar0ua2trvZ/vraKiAkZGRnB0dIRIJNJ1OM1SbGwsxowZo+swQP9/bvjx48dDJBKpzfvo4eGB/v37AwBWrFgBW1tbrFy5Era2tjhx4gQKCwuxYsUK5OTkoLy8XCPxPPfcc5DJZMK6QqHA2LFjERsbq5bP1dVV+Nnb21sjdTcEEWHlypX44IMPdBaDNjX2PM3Ozq7282tJYmNjMXbsWHTt2lU470+cOIGuXbu2+GPTKq10M9kzo7KyksLDw8nV1ZVMTEyoW7du9OOPPxIR0bJly8jJyYlyc3OF/MOHDydfX19SKpVq5cTHx9f7it3o0aPp3XffFdZnzpxJAOjcuXNERFRRUUFmZmZ08OBBIiLy8/OjmTNnCj/jib9wif53xe7gwYPUqVMnMjU1pSFDhtDt27frFNOUKVNo5MiR9Mknn5C9vT1ZWlrS0qVLqaKigubMmUOtWrUiZ2dn2rJli9p+H3zwAXXo0IGkUim5urrShx9+SOXl5UJMT8YaGRlJREQAaMOGDTRixAiSyWT00UcfVWnLN998k7p27UqlpaVERFReXk5eXl70+uuv17mt9eWKnUKhaNKrSiYmJjVebbK3tycTExMyNDSkYcOGUWlpKUmlUhKLxSSXy6m8vJyGDx9Ocrmc5HI5OTg4kFwuJ4VCQQqFgtq0aaPRWF1cXKi0tJTs7OyEtP79+5OrqyspFArh6lzarzuEK3ZN2ZY1LYaGhlRWVqbrU0ujFAoFSSSSRp97MplM+PxaGoVCQXK5nIYPH17l94VSqaThw4e32GOrq4Z+73LHjjXKwoULqVOnTnTw4EG6cuUKRUZGkrGxMSUkJJBCoSAfHx8aNWoUERFt2LCBLC0tKSMjo0o5DenYrVu3jrp06SKs9+jRg2xtbSkiIoKIiJKSksjQ0JAKCwuJSL1jl5eXR8899xwtX76csrKyKCsri4gedaIkEgm9+OKLdPr0aUpOTiYPD486d4KmTJlC5ubm9M4779CFCxdoy5YtBICGDBlCn3zyCV26dIlCQ0NJIpFQZmamsF9oaCgdP36crl27Rj///DM5ODhQeHg4EREVFxfT7NmzqXPnzkKsxcXFRETCLZctW7bQlStXKCMjo0pbFhYWUrt27SgkJISIiObNm0dt27alBw8e1HgcpaWllJ+fLyw3btzQi46dqm2awzJ79mzh54iIiCqxxcfHU1JSkrC+adMmIV1bxxEfH08bN24U1l966SUCQBs3bqTo6GgCQCn7o5pVxw5AlSEVLZ2mP9/4+HhdH1K9qdrgxIkT1W5X/d9oicdWV9yxY02uqKiITExMKCkpSS09ODiYXnvtNSIiunLlCpmbm9O8efNIJpNRdHR0tWU1pGP3zz//kEgkopycHLp37x5JJBL6+OOPady4cUREFBYWRs8//7yQ//GOHVHNY+wA0OXLl4W0iIgIcnBwqFNMU6ZMIRcXF7W/MDt27Ei+vr7CukKhIFNTU9qxY0eN5Xz22Wfk7e0trNc0xg6A0GFTqa4tk5KSSCKR0OLFi8nQ0JCOHj361ONYsmRJtb8gWnrHbvv27TrvhKiWiIgI4edvvvmmSmzbt2+ngoICYf327dtCuraOY/v27XTr1q2n5nl8jJ2u21C1PH7lXh9o+vPdvn27rg+p3lRtoPrD/Emq/xst8djqisfYsSaXlpaG0tJSDB48GGZmZsLy3Xff4cqVKwCAdu3aYdWqVQgPD8fw4cMxceJEjdXfpUsX2NjY4OjRo0hMTET37t0xYsQIHD16FMCjp0P9/PzqXa5MJkP79u2FdScnJ2RnZ9d5/86dO8PA4H//tRwcHNC16/+mhVA93fd4mT/99BP69+8PR0dHmJmZYfHixcjMzKxTfb169ao1j4+PD+bMmYPQ0FDMnj0bAwYMeGr+BQsWID8/X1hu3LhRp1iaOycnJ12HILh69arwc0lJSZXYnJyccO7cOWF93759Qrq2jsPJyUmoBwBeeuklAMDGjRsRHR0NAGjdurVW6m6Mx/+/6gNNf77N6byvK1XMj/8feJwqvSUem7bxdCeswVRTEcTFxcHZ2Vltm7GxsfDzsWPHIBaLkZGRAYVCAUNDzZx2IpEIAwYMQEJCAoyMjODv748uXbpAqVTi7NmzSEpKQkhISL3LlUgkVeqh/z/QvaH7V5emar8//vgDr776KpYtW4YhQ4bA0tIS33//PVavXl2n+kxNTWvNU1lZiePHj0MsFiM9Pb3W/MbGxmqfob5QTQ/SVExMTFBaWlolXSQSYevWrTAxMYFCocCBAwcQHBwMqVSK8vJytGnTBv369cOYMWMgl8sBAIsXL4ZcLheOoU2bNhrtcLu4uMDHxwfjx48X0oqLi+Hq6org4GD8/fffANDszgtDQ0PMmDFD12FolK+vLyQSCSoqKhpchomJCQwMDODg4NDk570m+Pr6Qi6XIywsDLt371b7Y7myshIrVqyAq6trizw2beMrdqzBPD09YWxsjMzMTLi5uaktbdq0AQD88MMPiI2NRUJCAm7cuIHQ0FCNxuDv74+EhAQkJCTA398fIpEIvr6+WLVqFUpKStCvX78a9zUyMoJSqdRoPA1x/PhxuLi4YNGiRejVqxc6dOiA69evq+VpbKwrV67E+fPncfToURw6dAiRkZGNDbtFEovFiImJabL6quvUAQARITs7G6WlpRg9ejTi4uLg5OSEkpISKJVKmJiYYODAgdi7dy/eeust2Nra4u7du7C1tcWpU6dQXFyM6dOnazRWpVIJa2tr5OTkCGnHjx/HqlWrmvWcYbNmzdK7+ezEYjG+//77RpVRWlqKkpKSZv/51UQsFmP16tXYt28fRo0apfZU7KhRo7Bv374We2xap5Ubw+yZsWjRIrKxsaGoqCi6fPkynTlzhtavX09RUVF048YNatWqFa1bt46IiA4fPkwSiURtMGxWVhalpKTQ119/TQDo2LFjlJKSQnl5eXWqXzXOTiKRCOMQ1qxZQ2KxmHr37q2W98kxdoMHD6YRI0bQzZs3KScnh4iqn8du165dVNf/KqqnYp9WL5H6+L7du3eToaEh7dixgy5fvkxr164la2trtTi2bdtGpqamlJKSQjk5OcITrgBo165damU/OcYuJSWFjIyM6OeffyYios2bN5O5uTlduXKlTsdEpD9Pxaq0tHnsXF1dq53Hzt7eXmvz2Dk7O6uNX6ruqViex067eB676uexc3V11Ytjq01Dv3f5VixrlNDQUNjb22PFihW4evUqrKys4OXlhQULFiAoKAh9+vTBu+++CwAYPHgw3n33XUyaNAl//fUXzMzM8NVXX2HZsmVCeaqxX5GRkQgKCqq1/i5dusDW1hYuLi6wsLAAAPj5+UGpVNY6vm758uWYNm0a2rdvj7KysnrdbtWkkSNHYtasWXj33XdRVlaGl19+GYsXL8bSpUuFPGPGjEFsbCwGDhyIBw8e1Ll9SktLMXHiRAQFBWH48OEAgODgYMTFxeGNN94QbpM/a0aPHg2FQtHi3jyxYsUKnb15ori4GABw4cIFeDxWHhHxmye0RHWePstvnhg9ejRGjhzJb56oBxHp6rcZY6zFKCgogKWlJfLz84UONHu2bN68GVOnTq32lWKMMc1r6PcuX7FjjDFWq1GjRgEAPDvIcV6Zi50TOsONO3WMNTt8xY41W2FhYQgLC6t2m6+vLw4cONDEEQFmZmY1bjtw4IDePqHFV+wYY6xpNfR7lzt2rNm6d+8e7t27V+02qVRaZYqVpnD58uUatzk7O0MqlTZhNE2HO3aMMda0+FYs0zvW1tZqL0ZvDtzc3HQdgk6o/v4rKCjQcSSMMfZsUH3f1vf6G3fsGGO1KiwsBABhfkLGGGNNo7CwEJaWlnXOz7diGWO1qqyshLu7O5KTkyESiaps7927N06fPt3otIKCAuGNCtq+5VtdLNrav7a8T9te07a6tK+u2ram+LSxb13y1qcNa0rnc7f+2/ncbVxeIoK3tzcuXbqk9uaN2vAVO8ZYrQwMDGBkZFTjX41isbjKF25j0iwsLLT+BV5dvdrav7a8T9te07a6tKWu2ramurWxb13y1qcNa0rnc7f+2/ncbXxeIyOjenXqAEC89PFZUBlj7Cn69OlTr231TSsrK8Onn36KBQsWNMk7SZ92PJrev7a89W3bmtKfTNNV29YUnzb2rUve+rRhTel87tZ/O5+7jc9b31j4VixjrNngp2+1h9tWu7h9tYfbtn74ih1jrFkRi8Xw9/eHoSGPFNE0blvt4vbVHm7buuMrdowxxhhjeqJ+I/IYY4wxxlizxR07xhhjjDE9wR07xhhjjDE9wR07xhhjjDE9wR07xhhjjDE9wR07xliLUVxcDBcXF8yZM0fXoegdQ0ND9OjRAz169MD//d//6TocvXLt2jUMHDgQnp6e6Nq1Kx4+fKjrkPTGxYsXhfO2R48ekEql2L17t67D0ime7oQx1mIsWrQI6enpaNu2LVatWqXrcPSKra0tcnNzdR2GXvLz88PHH38MX19f3Lt3DxYWFjwfmxYUFRVBLpfj+vXrMDU11XU4OsNX7BhjLUJ6ejouXLiAoUOH6joUxuosNTUVEokEvr6+AABra2vu1GnJzz//jEGDBj3TnTqAO3aMsSZw7NgxDB8+HK1bt4ZIJKr2VsmXX34JV1dXmJiYwNvbG4mJiWrb58yZgxUrVjRVyC2KJtq3oKAA3t7e6N+/P44ePdpUoTd7jW3b9PR0mJmZYcSIEfDy8kJYWFhTht/saeLcVdm5cycmTJig7ZCbPe7YMca07uHDh+jevTvWr19f7fYffvgBISEhWLRoEVJSUuDr64vAwEBkZmYCAPbs2QN3d3e4u7s3ZdgtRmPbFwAyMjKQnJyMr776CpMnT0ZBQUFThd+sNbZtKyoqkJiYiIiICJw4cQJHjhzBkSNHmvIQmjVNnLvAoz9Mjh8/zlf0AYAYY6wJAaBdu3appfXp04fefvtttbROnTrR/PnziYho/vz59Nxzz5GLiwvZ2NiQhYUFLVu2rMlibkka0r5PCggIoNOnT2stxpaqIW2blJREQ4YMEbZ99tln9Nlnn2k/2BaoMefud999RxMnTtR6jC0BX7FjjOlUeXk5kpOT8dJLL6mlv/TSS0hKSgIArFixAjdu3EBGRgZWrVqFqVOn4qOPPtJFuC1OXdr3/v37KCsrAwDcvHkTaWlpaNeuXZPH2tLUpW179+6Nu3fv4v79+6isrMSxY8fg4eGhi3BbnLq0rwrfhv0fHsHJGNOp3NxcKJVKODg4qKU7ODjgzp07OopKf9Slfc+fP49p06bBwMAAIpEIa9euhbW1tS7CbVHq0raGhoYICwvDgAEDQER46aWXMGzYMF2E2+LU9bshPz8fp06dQkxMTFOH2Cxxx44x1iyIRCK1dSKqkgYAQUFBTRSRfnla+/bt2xdnz57VRVh6obZzNzAwEIGBgU0dlt6orX0tLS1x9+7dpg6r2eJbsYwxnbK1tYVYLK5ydS47O7vKX+qs/rh9tYfbVru4fRuGO3aMMZ0yMjKCt7d3lScFjxw5gr59++ooKv3B7as93Lbaxe3bMHwrljGmdUVFRbh8+bKwfu3aNfz111+wtrZG27Zt8f777+ONN95Ar1694OPjg02bNiEzMxNvv/22DqNuObh9tYfbVru4fbVAp8/kMsaeCfHx8QSgyjJlyhQhT0REBLm4uJCRkRF5eXnR0aNHdRdwC8Ptqz3cttrF7at5/K5YxhhjjDE9wWPsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOMMcb0BHfsGGOM6UxCQgJEIhEePHig61AY0wvcsWOMMdYk/P39ERISopbWt29fZGVlwdLSUkdRAa6urjh48KDO6mdMkwx1HQBjjLFnl5GRERwdHXVW/z///IO8vDwMHDhQZzEwpkl8xY4xxpjWBQUF4ejRo1i7di1EIhFEIhEyMjKq3IqNioqClZUV9u3bh44dO0Imk2Hs2LF4+PAhvv32W8jlcrRq1QrvvfcelEqlUH55eTk++OADODs7w9TUFM8//zwSEhJqjWvPnj0YMmQIjI2Nq90uEomwefNmvPLKK5DJZOjQoQN+/vlnYfv9+/cxceJE2NnZQSqVokOHDoiMjGxcYzHWCNyxY4wxpnVr166Fj48Ppk6diqysLGRlZaFNmzbV5i0uLsa6devw/fff4+DBg0hISMDo0aOxf/9+7N+/H1u3bsWmTZvw008/Cfu8+eabOH78OL7//nv8888/GDduHAICApCenv7UuH7++WeMHDnyqXmWLVuG8ePH459//sHQoUMxceJE3Lt3DwCwePFipKWl4cCBAzh//jw2bNgAW1vberYOY5rDt2IZY4xpnaWlJYyMjCCTyWq99VpRUYENGzagffv2AICxY8di69atuHv3LszMzODp6YmBAwciPj4eEyZMwJUrV7Bjxw7cvHkTrVu3BgDMmTMHBw8eRGRkJMLCwqqt59atW/j7778xdOjQp8YTFBSE1157DQAQFhaGL774AqdOnUJAQAAyMzPRs2dP9OrVCwAgl8vr0yyMaRx37BhjjDUrMplM6NQBgIODA+RyOczMzNTSsrOzAQBnzpwBEcHd3V2tnLKyMtjY2NRYz88//4x+/frB2tr6qfF069ZN+NnU1BTm5uZC3dOnT8eYMWNw5swZvPTSSxg1ahT69u1b94NlTMO4Y8cYY6xZkUgkausikajatMrKSgBAZWUlxGIxkpOTIRaL1fI93hl8Ul1uw9YUj6ruwMBAXL9+HXFxcfjll18waNAgvPPOO1i1alWt5TKmDTzGjjHGWJMwMjJSe+BBU3r27AmlUons7Gy4ubmpLTXd9i0qKkJ8fDxGjBjR6Prt7OwQFBSE6OhorFmzBps2bWp0mYw1FF+xY4wx1iTkcjlOnjyJjIwMmJmZ1XoLtK7c3d0xceJETJ48GatXr0bPnj2Rm5uL3377DV27dq12DN3BgwfRoUMHtGvXrlF1f/TRR/D29kbnzp1RVlaGffv2wcPDo1FlMtYYfMWOMcZYk5gzZw7EYjE8PT1hZ2eHzMxMjZUdGRmJyZMnY/bs2ejYsSNGjBiBkydP1vjk7Z49e+p0G7Y2RkZGWLBgAbp164YBAwZALBbj+++/b3S5jDWUiIhI10EwxhhjTUWpVMLe3h4HDhxAnz59dB0OYxrFV+wYY4w9U/Ly8jBr1iz07t1b16EwpnF8xY4xxhhjTE/wFTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGGOMMT3BHTvGGHuGfPfdd3j11VfRsWNHGBgYQC6Xa7T8mzdvIiQkBH5+frCysoJIJEJUVFSN+X/55Rf4+PhAJpPB1tYWQUFByM7OrpKvoqICy5Ytg1wuh7GxMTp16oQvvvhCo7E3VmpqKmbMmAEfHx+YmppCJBIhISFBY+VfunQJc+bMgbe3N6ysrGBtbY1+/frhp59+qjZ/dnY2goKCYGtrC5lMBh8fH/z666/V5q3r58CaP+7YMcbYM2Tr1q1ITU1Fnz590L59e42Xf/nyZWzbtg1GRkYYOnToU/MePXoUgYGBcHBwwJ49e7B27Vr88ssvGDRoEMrKytTyzpgxAytWrMA777yDQ4cO4ZVXXsHMmTMRFham8WNoqD///BO7d++GtbU1Bg0apPHyDx8+jLi4OIwZMwY//vgjtm3bhg4dOmDcuHFYvny5Wt6ysjIMGjQIv/76K9auXYs9e/bAwcEBAQEBOHr0qFre+nwOrAUgxhhjzwylUin8/PLLL5OLi4vWyj99+jQBoMjIyGrz9u7dmzw9PamiokJIO378OAGgL7/8Ukg7d+4ciUQiCgsLU9t/6tSpJJVKKS8vT6PH0FCPH/uPP/5IACg+Pl5j5efk5FBlZWWV9JdffplkMhmVlpYKaREREQSAkpKShLSKigry9PSkPn36qO1f18+BtQx8xY4xxpqppUuXQiQSITU1Fa+99hosLS3h4OCAf//738jPzxfyff/99xCJRFi/fr3a/kuWLIFYLMaRI0eENAMD7X7t17X8W7du4fTp03jjjTdgaGgopPft2xfu7u7YtWuXkLZ7924QEd588021Mt58802UlJTg4MGD9Y4zIyMDIpEIq1atwn//+1+4urrCzMwMPj4++OOPP4R8W7duhUgkwokTJ6qUsXz5ckgkEty+fRuA9tvW1tYWIpGoSnqfPn1QXFyMe/fuCWm7du1Cx44d4ePjI6QZGhpi0qRJOHXqFG7dugWgfp8Daxm4Y8cYY83cmDFj4O7ujpiYGMyfPx/bt2/HrFmzhO2vvvoq3n77bcyePRt//vknAOC3337Dxx9/jIULF2Lw4MH1rpOIoFAo6rQ0xLlz5wAA3bp1q7KtW7duwnZVXjs7Ozg6OlbJ93hZDREREYEjR45gzZo12LZtGx4+fIihQ4cKHecJEybA0dERERERavspFAps3LgRr7zyClq3bl3vepVKZZ3atrKystay4uPjYWdnB3t7eyHt3LlzNbYt8Gg8oCrf4+lP5m1M2zLd4I4dY4w1c8HBwVi2bBlefPFFzJo1C8HBwdixYweISMizZs0adO7cGePjL5NXAAAgAElEQVTHj8f58+fx+uuvw9fXF0uXLm1QnUePHoVEIqnTkpGRUe/y8/LyAADW1tZVtllbWwvbVXmry2dqagojIyO1vPVlbm6Offv2YeTIkRg5ciS2bNmC+/fv48CBAwAAIyMjTJs2DT/++KPawwSxsbG4ffs23n333QbV2759+zq17ZNj5560efNmJCQk4MMPP4RYLBbSa2ozVZqqzerzObCWwbD2LIwxxnRpxIgRauvdunVDaWkpsrOz4eDgAAAwNjbGzp074e3tDS8vL1hYWGDHjh1qv+zrw9vbG6dPn65T3oZcsVKp7tZidek15attW21efvlltTZSXbm6fv26kDZ9+nSsWLECX3/9NRYtWgQAWL9+Pbp27YoBAwY0qN69e/fW6cGEp7XtgQMH8M4772Ds2LF47733qmyvT5vV9XNgzR937BhjrJmzsbFRWzc2NgYAlJSUqKW7ubnB19cXcXFxmD59OpycnBpcp5mZGXr06FGnvI+Pzaor1TFVd0Xo3r17aleQbGxs8Ndff1XJ9/DhQ5SXl1d7tam+cahU17YODg6YMGECNm7ciPnz5yM1NRWJiYnYuHFjg+v19PRUu+Jak5rG7R06dAijR4/G4MGDsW3btiodMBsbmxrbFvjfFbr6fA6sZeBbsYwxpic2b96MuLg49OnTB+vXr8fJkycbXJa2b8V26dIFAHD27Nkq286ePStsB4CuXbsiJycHd+7cqZLv8bK0aebMmbhx4wb27NmD9evXw8rKChMnTmxweY25FXvo0CGMGjUKfn5+iImJgZGRUZU8Xbt2rbFtgf+1WX0+B9Yy8BU7xhjTA2fPnsV//vMfTJ48GV9//TX69u2LCRMmICUlBa1atap3edq+Fevs7Iw+ffogOjoac+bMEW6H/vHHH7h48SJCQkKEvCNHjsSHH36Ib7/9FvPmzRPSo6KiIJVKERAQUO/668vb2xt9+/ZFeHg4zp07h7feegumpqYNLq+ht2IPHz6MUaNGoX///ti9e7dwhfFJr7zyCmbMmIGTJ0/i+eefB/DogY/o6Gg8//zzQrn1+RxYy8AdO8YYa+EePnyI8ePHw9XVFV9++SWMjIywc+dOeHl54c0338Tu3buFvGlpaUhLSwMA3LlzB8XFxcKbCzw9PeHp6Qng0UMFvXr1alA8qvKuXr0K4NHEvWZmZgCAsWPHCvnCw8MxePBgjBs3DjNmzEB2djbmz5+PLl26qE1t0rlzZwQHBwvTt/Tu3RuHDx/Gpk2b8PHHH6vdLkxISMDAgQOxZMmSBj84UpOZM2diwoQJEIlEmDFjRpXtxcXF2L9/PwAIU6YcPXoUubm5MDU1RWBgoJC3a9eu9a7/999/x6hRo+Do6IiFCxdWuT3t6ekJCwsLAMC///1vREREYNy4cfj0009hb2+PL7/8EhcvXsQvv/yitl9dPwfWQuh2Gj3GGGM1WbJkCQGgnJwctfTIyEgCQNeuXSMiokmTJpFMJqPU1FS1fKpJcj///PMqZVa3LFmyRCNx11R+db9yDh8+TC+88AKZmJiQtbU1TZ48me7evVslX3l5OS1ZsoTatm1LRkZG5O7uTuvWrauSb+/evQSAvvrqq6fGeO3aNQJAK1eurDb+6tqirKyMjI2NKSAg4KllVrdoYiLop312qGYy5Dt37tDkyZPJ2tqaTExM6IUXXqAjR45UW3ZdPwfW/ImI6jB6kzHGGGsBPvjgA+zYsQPp6ekwMTHRaNl79+7FiBEjEBcXV+vr0hjTFe7YMcYY0xu9e/fG1KlT8dZbb2mszLS0NFy/fh0zZ86Eqakpzpw5w9OAsGaLO3aMMcbYU/j7++P48ePw8vLCt99+i06dOuk6JMZqxB07xhhjjDE9wfPYMcYYY4zpCe7YMcYYY4zpCe7YMcYYY4zpCZ6gmDFWq8rKSty+fRvm5ub8NCBjjDUBIkJhYSFat25d4zuDq8MdO8ZYrW7fvo02bdroOgzGGHvm3LhxA88991yd83PHjjFWK3NzcwCPvmBUryxijDGmPQUFBWjTpo3w/VtX3LFjjNVKdfvVwsKCO3aMMdaE6jv8hR+eYIwxxhjTE9yxY4wxxhjTE3wrljHGqpGeno6i+zkwKcpEqVlbmLWyQ4cOHXQdFmOMPRV37BjTgKioKISEhODBgwc15gkKCsKDBw+we/fuRtUlEomwa9cujBo1qlHl6JJSqcRnn32GhQsX1ppXKpVi3Lhx6NixI/bu3YvLly+jpKQE5eXlqKyshIGBAaytrTFz5kzMnj0bRkZGVepKSEhAQkICKisrYW1tDUdHRzg7O8PX1xdisbhKnenp6XB3d0dPRwOcmWYGr41FSLlTiUuXLqFDhw7Iz89H27ZtUVBQ0KDjd3Z2Rr9+/VBeXo6+ffuiY8eOWLduHW7cuIE2bdpg7ty5GDhwIBISErB161YUFRWhf//+eO+996oc39MolUokJibi1q1byMnJgZ2d3VOPmzGmB4ixFmDjxo3k5+dH5ubmBIDu37+v65DUREZGkqWl5VPzPHjwQCNxA6Bdu3Y1upz6yM/PJwCUn5/f6LJiYmIIgNaWuXPnqtVlZ2dXY165XE4xMTFERPTw4UNKTk4W/gVAcZvDiJZYUNzmMAJAycnJ1L59e63G/7TFwMBA7fhqa2e5XF7rcTPGmqeGfu/yGDvWIhQXFyMgIKBOV3iaK0tLS1hZWek6DJ2KjY3FmDFjtFrHypUr8cEHHwh15eTkoFOnThCJRPDx8UG3bt2EvLa2thg7dixiY2Nx4cIFeHt748KFC8J2V1dXtX9HjhyJK1euaC32/v37w97eXi0tODgY+/btQ7du3VBZWSkc39PExsZi7NixsLW1hUgkQmBgIL7++msEBgYCUD9uxpie0VJHkzE1lZWVFB4eTq6urmRiYkLdunWjH3/8kYiIli1bRk5OTpSbmyvkHz58OPn6/j/23j0uyjr9/3/NDDAHTnIQQQMGJQTygIdNTRHLXPBA8tHMtVy1NTc1W0+5fjU3MgsyJVzL9VAtrJK7VqKboGS5EBpqivhZDUJESUwMT3GQkzPz+v3hb+4PAwMMOIiH9/PxuB8z9/twva/rfd9zzzXXvA+h1Ov1JnLS09PbFLG7ePEin3vuOXbq1Imurq585plneP78eSn/+++/59NPP003Nzc6OTlx+PDhzM7ONpFx48YNzpo1ix4eHlQqlXzssce4Z88ekv8XsUtLS2NgYCDt7e0ZHh7OS5cuSfWnT5/O8ePHS+dhYWF89dVXuWTJErq4uLBLly6Mjo42afPMmTMMDQ2lUqlkUFAQ9+/f3yhi15xt1dXVDA4O5qxZs6Ty586do5OTE7ds2WJx/1kjYqfT6ahUKq0WvZLJZE3mKRQK+vj4UK1Wc+zYsdRqtYyMjKRer6der+e4ceOo0Wio1Wo5btw4+vn58fvvv5eicsaIXe6Bf5LRTsw98M92jcS5u7tTLpdToVDQ29u7UXRNp9NRr9dz7NixVCgUtLGxYW1tbZP9bLSrvt0kqdfrGRkZaWK3Tqdr8zUVCATth4jYCe5pVqxYgYSEBGzcuBE//PADFi5ciKlTp+Lbb7/F66+/Dq1Wi5deegkAsGnTJmRmZmLbtm2t2kalKaqqqvDkk0/CwcEBmZmZOHToEBwcHBAREYG6ujoAQEVFBaZPn46DBw/iyJEjePTRRzFmzBhUVFQAuL2l1ujRo5GVlYWkpCTk5ubi3XffNRmnVFVVhbVr12Lbtm3IzMzEhQsX8NprrzWr2z/+8Q/Y29vj6NGjeO+99/DWW2/h66+/ltqcMGECFAoFjhw5gk2bNmHp0qWtsk2lUuHTTz/FP/7xD+zevRt6vR6///3v8eSTT2LWrFlN6lVbW4vy8nKT4045ePAgamtr71iOkRdeeKHJPL1ejwsXLqC6uhpjxoxBUVERli9fDrlcDrlcjuXLl6OqqgpFRUWIiIjA+fPnceTIEQBAXl4e8vLyAEDS15p6m8POzg4GgwF6vR7FxcUmeUVFRTh48CDkcjlef/116PV66HQ6/O1vfzMr6+DBgygqKsLo0aNN7AYAuVyOZcuWmdh98ODBdrVNIBDcZdrJ0RQIJCorK6lSqZiVlWWSPnPmTE6ZMoUkWVhYSEdHRy5dupQajYZJSUlmZbUlYvfJJ5+wZ8+eNBgMUlptbS3VajW/+uors3V0Oh0dHR2liNxXX31FuVzO/Px8s+UTEhIIgGfPnpXSNmzYwC5dukjn5iJ2w4YNM5Hzm9/8hkuXLpXaVCgULC4ulvL37dtnErGz1Lb33nuP7u7ufPXVV+np6ckrV6400Vu3iY6ONhtZupOI3fbt260a5crJybGo3N///ncCYEVFhaRLeXm5lP/JJ58QAOfOnduobsMxdu11dOrUqdn87du3N9J73rx5zfazObvryzDabZQtEAjuLUTETnDPkpubi5qaGowaNQoODg7SsXXrVmm8Uvfu3bF27VqsXr0akZGRzUZjWkt2djbOnj0LR0dHqW1XV1fU1NRI7ZeWlmL27NkICAiAs7MznJ2dUVlZiQsXLgAATp48iUceeQQBAQFNtqPRaNCjRw/p3MvLC6Wlpc3qVn+8V8M6eXl58PHxMdkjcMiQIa22DQAWL16Mnj174oMPPkBCQgLc3d2b1WvZsmUoKyuTjoZRpLbg5eV1xzLqExcXZ1G56upqAMDp06eltPrvjfmBgYEAgKSkJCQlJQEAunbtavLaXmg0mmbzjX1XX+/695q5subsrn9uzLf2dREIBB2LWO5E0O4YDAYAQGpqKrp162aSp1QqpfeZmZlQKBQoKiqCTqeDjY11bk+DwYABAwbg008/bZTXuXNnALeXIrly5QrWrVsHX19fKJVKDBkyRPqrVq1Wt9iOra2tyblMJgPJVtcx9pe5ug23lrHENuC245qfnw+FQoGCggJEREQ0q5dSqTS5NtYgNDQUSqXSan9rmrPZiEKhQLdu3XDlyhXs3bsXWq0WMTEx0lIzMTEx0Gg08PDwQFpaGvz8/DB48GAAQFBQkCTH2AfW7ouG1NXVQS6XQyaToWvXriaOtFarRWhoKAwGA9555x0oFArIZDLMnTvXrKzQ0FBotVrs27fPxG65XA6DwYDY2FhotVrJ7tDQ0Ha1TSAQ3F1ExE7Q7gQHB0OpVOLChQvw9/c3Oby9vQEAO3bsQHJyMjIyMlBcXIxVq1ZZrf3+/fujoKAAHh4ejdp3dnYGcHtc0p/+9CeMGTMGjz32GJRKJa5evSrJ6NOnDy5evIgzZ85YTa+WCA4OxoULF3Dp0iUp7fDhwyZlLLENAP7whz+gV69e2Lp1K/785z8jNzf3rtlhRKFQYPv27VaT15zTvGjRIsTHx6O6uhqpqalQqVRISUnB0KFDERISgpSUFFRVVcHd3R2pqalYu3atReu61Y+eWpOrV6/CYDBg0KBBqKmpMcl76qmnkJqaipCQEKSmpkKv12PhwoVNrmenUCgQFxeH1NRUuLu7IyUlBePGjcOWLVswbtw47Nmzp9V2CwSC+4j2+F9YIGjI66+/Tjc3NyYmJvLs2bM8ceIEP/zwQyYmJrK4uJguLi5cv349SXL//v20tbXl4cOHpfolJSXMycnhRx99RADMzMxkTk4Or1271mLbN2/e5KOPPsoRI0YwMzOT586dY0ZGBv/0pz9J49dCQkI4atQo5ubm8siRIwwNDaVarWZ8fLwkZ8SIEezVqxf379/Pc+fOce/evdy3bx9J8+vY7dq1i/U/YubG2M2fP9+kzvjx4zl9+nSSt2cwBgcHc+TIkTx58iQzMzM5YMAAkzF2ltj24YcfslOnTrxw4QJJcurUqQwJCWlyVqU5HtR17Pz8/MyuY3fw4EECYPKG6AdyHbv6dgsEgnuTtj53hWMnuCsYDAb+9a9/Zc+ePWlra8vOnTszPDycGRkZHDlyJMPDw00mACxcuJA9evSQBn43NZg/ISHBovZLSko4bdo0uru7U6lUsnv37pw1a5b0gTlx4gQHDhxIpVLJRx99lJ9//jl9fX1NHLtr167xxRdfpJubG1UqFXv16sWUlBSS7ePYkWR+fj6HDRtGOzs7BgQEMC0tzcSxa8m2vLw8qtVqkwHyZWVl1Gq1/POf/2xR3xnrWMuxI29PTomJsWxCglqt5rRp0/jOO+9w8ODBdHd3p729PW1tbalQKGhra8suXbowJibGrLOq0+n4zTffcMWKFVy+fDnXrl3LpKQkpqenN7nUh/EHRD9PORntxH6ecgLgmTNnSN5ebNrJyanNDlq3bt343HPPMSoqiu+99x7//e9/c+TIkQwICODIkSOZlpbG2tpafvXVV5w6dSqjoqK4du3aVjnjRtvT09OZlJTE+Pj4Fu0WCAT3Dm197srIFgYBCQSCh57y8nI4OzujrKwMTk5OHa1Ou3P16lXs3r0bwY9q4aK/KvaKFQgEd522PneFYycQCFrkYXPsBAKBoKNp63NXTJ4Q3PfExMSYLKNS/zBuoSQQCAQCwcOAiNgJ7nuuX7+O69evm81Tq9WNllgRtB4RsRMIBIK7S1ufu2IdO8F9j6urK1xdXTtaDYFAIBAIOhzxV6xAIBAIBALBA4Jw7AQCgUAgEAgeEIRjJxAIBAKBQPCAIBw7gUAgEAgEggcEMXlCIBAIWklBQQEqb1yBqvICahx8QBsVHB0dxQLGAoGgw3mgHLvExEQsWLAAv/76a0erYjWKiorg5+eHnJwchISEICMjA08++SRu3LiBTp06dbR69x1arRYLFizAggULOlqVRjTUTSaTYdeuXYiKiupgzdqP/Px8BAYGWlTWzs4OPj4+iI+Px+jRo6FQKFBXV4f169cjOTkZly5dgr29PTw9PeHh4QGFQgFfX1889dRTCA0NxcGDB5GRkQEAGDFiBEaMGAGFQtFqnQsKChAQEIB+nnKceNkB/TdXIueyAQBw5swZPProozh79mybnTyZTAaZTAYHBwcEBgaisrISKpUKXbt2BQCQREFBATQaDdRqNfr27YtHH30UvXv3xtWrV+Hl5YXQ0NBW26bX63Hw4EGUlJS0WUZr6Yg2BYIHHmvvbdYSmzdvZlhYGB0dHQmAN27caFV9NNgnsz5VVVX85ZdfrKGmVTC3F2hrOX/+PAEwJyeHJFlbW8uSkhKTfVU7kv/85z8cPXo0XV1dqVarGRQUxEWLFvHixYt3LLu5a91WSktLefPmTavKjI6OZt++fe9YTsO9aUtKSlhTU3PHcq2BtfeKJdnmfVYB0MbGhuPHj6dMJrOovLlyHh4e3LlzZ6v1zs7OJgCmfhxDRjsx98A/mZSURADMzs62WKf2PLRabats27lzJ7Va7R3JaC0d0aZAcD/R1ufuXR9jV1VVhYiICCxfvtzqstVqNTw8PKwut7XU1dW1m2w7Ozt4enpCJpO1WxuWsnnzZjz99NPw9PTEzp07kZubi02bNqGsrAxxcXFtltue/de5c2doNJp2k29NPD09oVQqO1qNduFO71+dTod///vfoIXrqxvLvfnmmzhw4ACGDRuG0tJSPPvss0hOTm6xflVVFU6cOIGqqiopzc/PDwAQFBiIoKAgAMDAgQMt1sna2NraAgBeeOEF9O7d22LbkpOT8eyzz6J37944fPgwKioqcPjw4VbJaC0d0aZA8NDQWg/SYDBw9erV9PPzo0qlYp8+ffj555+TJFeuXEkvLy9evXpVKh8ZGcnQ0FDq9XoTOenp6VaP2CUkJNDZ2Vk6N0ZStm7dSl9fXzo5OXHy5MksLy+3yB6S1Ol0/MMf/kCtVkuVSsWAgACuW7fOpN3p06dz/PjxjImJoZeXF319fUk2jtj5+vrynXfe4YsvvkgHBwd6e3tz8+bNJrKOHj3KkJAQKpVKDhgwgMnJySYRO3P9dujQIQ4fPpxqtZqdOnXib3/7W16/ft0i+65fv87nn3+e7u7uVKlU9Pf359///vcWr0NxcTHt7Oy4YMECs/lG/a5evcrf/e537NatG9VqNXv16sXt27eblA0LC+Mrr7zChQsX0s3NjcOHD6evr6/JL3ljn5Lkl19+yf79+1OpVNLPz49vvvkmb926JeVHR0fT29ubdnZ29PLy4quvvmpyDepHxeLi4tirVy9qNBo+8sgjnDNnDisqKqR84z2VlpbGwMBA2tvbMzw8nJcuXTJpr37Ezng/rFmzhp6ennR1deXcuXNZV1cnlfnll184btw4qlQqarVaJiUlNdKt4b1eXFzMyZMn08XFhRqNhgMGDOCRI0es0i8tYc2I3Y8//mjV6JRMJqNKpaJKpaJaraadnV2jMnK5nGq1mn5+ftTpdNTr9Rw3bhw1Go2U1hzGKF12drb0PvfAP8loJ/LnHCntbh9yubxRFNLGxobV1dWMjIxs0TadTketVsvIyMhGz2i9Xm+RjNbSEW0KBPcjbX3uttqxW758OQMDA5mWlsbCwkImJCRQqVQyIyODOp2OQ4YMYVRUFEly48aNdHZ2ZlFRUSM5d8uxc3Bw4IQJE3jq1ClmZmbS09OTy5cvt8gekqyrq+Mbb7zB77//nufOnWNSUhI1Gg137NghyZg+fTodHBz4+9//nqdPn+apU6dImnfsXF1duWHDBhYUFDA2NpZyuZx5eXkkycrKSnbu3JmTJ0/m6dOnuWfPHnbv3r1Zxy4nJ4dKpZJz5szhyZMnefr0aX7wwQe8cuWKRfa98sorDAkJ4bFjx3j+/Hl+/fXX/PLLL1u8Du+//z4BmDg45rh48SLXrFnDnJwcFhYWcv369VQoFCYOSVhYGB0cHLhkyRL++OOPzMvLY2lpKQEwISGBJSUlLC0tJUmmpaXRycmJiYmJLCws5P79+6nVavnmm2+SJD///HM6OTlx7969/Omnn3j06FFu2bLF5BrUd57i4+P5n//8h+fOneOBAwfYs2dPzpkzR8pPSEigra0tn376aR47dozZ2dkMCgri888/L5Ux59g5OTlx9uzZzMvL4549e6jRaEz0GD16NHv16sWsrCweP36cTzzxBNVqdZOOXUVFBbt3787Q0FAePHiQBQUF3LFjB7OysqzSLw2pqalhWVmZdBQXF1vNsVMoFO3q7CxdurTZ/PT0dJJkVlZWo7SmOHToEAEwKSlJ+ts1Z2+i5NgZ8zv6GDFiBAEwPj5esq8524zPk8OHD5vNt0RGa+mINgWC+5G74thVVlZSpVJJXyZGZs6cySlTppAkCwsL6ejoyKVLl1Kj0TApKcmsrLvl2Gk0GpMI3ZIlSzho0CCL7THH3LlzOXHiROl8+vTp7NKlC2tra03KmXPspk6dKp0bDAZ6eHhw48aNJG+PP3R1dTUZA7Zx48ZmHbspU6Zw6NChZvW0xL7IyEi++OKLTdraFHPmzKGTk1Or65HkmDFjuHjxYuk8LCyMISEhjcqZu9ahoaGMiYkxSdu2bRu9vLxI3o7ABQQEmETH6tPQsWvIZ599Rjc3N+k8ISGBAHj27FkpbcOGDezSpYt0bs6x8/X1NYk4TJo0iZMnTyZJ5ufnE4CJc5uXlyd9IZuzf/PmzXR0dOS1a9fM6n2n/dKQ6Ohos46DNRy79nZuzpw502y+MWJcXl7eKK0pjM5c/cM4xo4/55jN74hj+PDhBMB58+ZJ9jVn2/bt2wnAJEpdH0tktJaOaFMguB9pq2PXqlmxubm5qKmpwahRo0zS6+rq0K9fPwBA9+7dsXbtWrz88suYPHkyXnjhhdY0YXW0Wi0cHR2lcy8vL5SWlgKwzB4A2LRpEz7++GP89NNPqK6uRl1dHUJCQkzq9O7dG3Z2di3q06dPH+m9TCaDp6enpE9eXh769u1rMgZsyJAhzco7efIkJk2aZDbPEvvmzJmDiRMn4sSJE/jtb3+LqKgoPPHEEy3aQdKicVJ6vR7vvvsuduzYgZ9//hm1tbWora2Fvb29SbmBAwe2KAsAsrOzcezYMbzzzjsmbdTU1KCqqgqTJk3CunXr0L17d0RERGDMmDGIjIyEjY35Wz09PR0xMTHIzc1FeXk5dDodampqcPPmTUlHjUaDHj16SHXq30NN8dhjj5nM7vPy8sKpU6cA3L7ONjY2JjYHBgY2O8v55MmT6NevX5N74lq7X5YtW4ZFixZJ5+Xl5fD29m7WZktRKBTQ6/VWkWWOTz75pNl8Ly8vAMDp06cbpTWFVqsFACQlJQEApk6denuWarFpfkcjl98eNt2jRw/JvuZsq98XgwcPbpRviYzW0hFtCgQPE61y7AyG21P6U1NT0a1bN5O8+oO8MzMzoVAoUFRUBJ1O1+SXx93AOKDYiEwmk+ywxJ7PPvsMCxcuRFxcHIYMGQJHR0esWbMGR48eNSnf0FFpiz5sw6BrtVrdZJ4l9o0ePRo//fQTUlNT8c0332DkyJF45ZVXsHbt2mbbDQgIQFlZmbRMQVPExcUhPj4e69atQ+/evWFvb48FCxY0miBhaf8ZDAasXLkSEyZMaJSnUqng7e2N/Px8fP311/jmm28wd+5crFmzBt9++22jvv/pp58wZswYzJ49G6tWrYKrqysOHTqEmTNn4tatW1I5c9espWtlyXVuzQSC5q4zYN1+AW7fH+01ceOHH36weIkTS5DJZJKuMpkM8fHxjcrI5XIolUp4enoiNDQUBoMBMTEx0Gg06NKlC0JDQ5ttw9j/xkkSgOkzr6Xr017I5XLpvgJu/5izsbHB7Nmz8dxzz8HPz69Z20JDQ6HVahETE4Pdu3dLjiFw+56KjY1tUUZr6Yg2BYKHiVbNig0ODoZSqcSFCxfg7+9vchh/ze/YsQPJycnIyMhAcXExVq1a1S6KWwNL7Dl48CCeeOIJzJ07F/369YO/vz8KCwvbTZ///d//RXV1tZR25MiRZuv06dMHBw4caFJeS/YBt2eKzpgxA0lJSVi3bh22bNnSoq7PPvss7Ozs8N5775nNN64lePDgQYwfPx5Tp05F32yR6sEAACAASURBVL590b17dxQUFLQoH7jtHDWM7PTv3x/5+fmN7PH395e+INRqNZ555hmsX78eGRkZOHz4sBQtq8/x48eh0+kQFxeHwYMHIyAgAJcuXbJItzshKCgIOp0Ox48fl9Ly8/ObXX+xT58+OHnyJK5fv24235r90t707NnTqvJIoqamBjU1NVJEvSEGgwHV1dWYNm0a0tPTMXz4cKSkpKC6uhpr16612tppd3u2en2nztbWFqWlpXjuuefw3HPPISUlpUXbFAoF4uLikJKSgqioKJMZqlFRURbJaC0d0aZA8DDRqlCao6MjXnvtNSxcuBAGgwHDhg1DeXk5srKy4ODggJEjR2LOnDlYvXo1hg0bhsTERIwdOxajR4+WQu6XL1/G5cuXcfbsWQDAqVOn4OjoCB8fnyb/ZmrI+fPncfLkSZM0f3//1phikT3Tp0+Hv78/tm7diq+++gp+fn7Ytm0bjh07Ji11YE2ef/55vP7665g5cyZWrFiBoqKiFiNny5YtQ+/evTF37lzMnj0bdnZ2SE9Px6RJk+Du7t6ifW+88QYGDBiAxx57DLW1tUhJSTGJSjSFt7c34uPjMW/ePJSXl2PatGnQarW4ePEitm7dCgcHB8TFxcHf3x87d+5EVlYWXFxc8P777+Py5csWtaHVanHgwAEMHToUSqUSLi4ueOONNzBu3Dh4e3tj0qRJkMvl+O9//4tTp07h7bffRmJiIvR6PQYNGgSNRoNt27ZBrVbD19e3kfwePXpAp9Phgw8+QGRkJL777jts2rSpRb3ulJ49eyIiIgKzZs3Cli1bYGNjgwULFjQb9ZkyZQpiYmIQFRWF2NhYeHl5IScnB127dsWQIUOs2i93A0v/ym8KGxsbjB07Fl9++aVFkW5jlHXlypVSmoeHBzZu3Gg2ytmQwMBAZGdnIzAwED/++GOT5Y4fP95hS54Yo8zbt2+Hn58fvvjiC4tsmzBhAr744gssXrzYZBhGa2S0lo5oUyB4WGj1f6SrVq2Ch4cHYmNjce7cOXTq1An9+/fHsmXLMGPGDDz++OOYN28eAGDUqFGYN28epk6dipMnT8LBwQGbNm0yebgOHz4cAJCQkIAZM2ZYpEP9sT9G0tPTW2tKs/YY19mbPXs2Tp48icmTJ0Mmk2HKlCmYO3cu9u3b16b2msPBwQF79uzB7Nmz0a9fPwQHB2P16tWYOHFik3UCAgKwf/9+LF++HI8//jjUajUGDRqEKVOmWGSfnZ0dli1bhqKiIqjVaoSGhuJf//qXRfrOnTsXAQEBWLt2Lf7nf/4H1dXV0Gq1GDdunHSN/vKXv+D8+fMIDw+HRqPBH//4R0RFRaGsrKxF+XFxcVi0aBE++ugjdOvWDUVFRQgPD0dKSgreeustvPfee7C1tUVgYCBeeuklAECnTp3w7rvvYtGiRdDr9ejduzf27NkDNze3RvJDQkLw/vvvY/Xq1Vi2bBmGDx+O2NhYTJs2zSL774SEhAS89NJLCAsLQ5cuXfD222/jL3/5S5Pl7ezssH//fixevBhjxoyBTqdDcHAwNmzYAABW7Ze7Bcn7ZucJjUaD/v37A4C0lt2PP/6IIAB5P/6IvJL/iywbDIb7bueJCRMmYPz48Xd1F4iOaFMgeBiQsSN+WgoEgvuK8vJyODs7o6ysDE5OTh2tTofy8ccfY9asWc1uKSYQCAR3Slufuw/UXrECgUDQ3hj37g1+VIs8/VV8MsYHtFHB0dFROHUCgaDDuacidjExMYiJiTGbFxoa2i5/fwrMI66FoD4iYicQCAR3l7Y+d+8px+769etNzvpTq9WNluwQtB/iWgjqIxw7gUAguLs8EH/Furq6WjwzVtC+iGshEAgEAsH9R6vWsRMIBAKBQCAQ3LsIx04gEAgEAoHgAUE4dgKBQCAQCAQPCMKxEwgEAoFAIHhAuKcmTwgEAsH9QkFBASpvXIGq8gJqHHzg4NJZrGMnEAg6HBGxEzxUaLVarFu3rqPVMEtD3WQyGXbv3t2BGgmaoqCgAAEBAZg5PhRBmS9j5vhQBAQEoKCgoKNVEwgEDzkiYvcQs2XLFmzfvh0nTpxARUUFbty4gU6dOrVKRnp6OtasWYOjR49Ke8WOHj0aixYtuuO17mQyGXbt2iWt9G8Njh07Bnt7e6vJA4A333wTu3fvxsmTJ60qt6SkBC4uLlaVeS+Sm5uLxx57rFV1VCoVbt26BblcDicnJ7i5ueHnn39GXV0dDAYDDAYDZDIZFAoFvL298fjjj8PHxwe//vorLl++jOrqagwcOBAjR47EiBEjAKBVe5ZWVFQAAN5++22g+F28/fbbGPvScikdAOLj483ua90WZDIZVCoV7O3tIZfLQRJOTk5wcnJCt27dEBQUhJ9++gkFBQW4efMmvL29sWTJEjz99NOSHXq9HhkZGU3ul6vX69tl39b2kisQCJqAgoeW+Ph4xsbGMjY2lgB448aNVtXftGkT5XI5X3zxRaanp/P8+fP89ttvOXPmTC5cuLDNetXW1pIkAXDXrl1tlnO3iI6OZt++fe9Yjq+vL+Pj462gkfUpKysjAJaVlVlVLoAOP5ycnOjh4WGS5uvryzVr1vDmzZtm9c7OziYA5h74JxntxNwD/yQAZmdn3zN2AaBGo+HOnTu5c+dOdu7cuVG+h4eHlK/Vak3ytFotd+7ceUfXt73kCgQPA2197grH7j7GYDBw9erV9PPzo0qlYp8+ffj555+TJFeuXEkvLy9evXpVKh8ZGcnQ0FDq9XoTOenp6a127IqLi2lnZ8cFCxaYzTfKunr1Kn/3u9+xW7duVKvV7NWrF7dv325SNiwsjK+88goXLlxINzc3Dh8+nL6+vo2+aI18+eWX7N+/P5VKJf38/Pjmm2/y1q1bUn50dDS9vb1pZ2dHLy8vvvrqq1JeQ+cpLi6OvXr1okaj4SOPPMI5c+awoqJCyk9ISKCzszPT0tIYGBhIe3t7hoeH89KlSybt1Xfspk+fzvHjx3PNmjX09PSkq6sr586dy7q6OqnML7/8wnHjxlGlUlGr1TIpKamRbg0d2+LiYk6ePJkuLi7UaDQcMGAAjxw5YpV+aYn2cOzuBaen/nlsbCwrKip4+PBhDh8+nAC4Zs0as7o359h1pE1yubzZ/GHDhvHAgQM8cOAAhw0bJqXLZDJGRkby8OHDUh9ERkZSJpO12QnbuXNnu8gVCB4WhGP3ELJ8+XIGBgYyLS2NhYWFTEhIoFKpZEZGBnU6HYcMGcKoqCiS5MaNG+ns7MyioqJGctri2L3//vsEYOLgmOPixYtcs2YNc3JyWFhYyPXr11OhUJg4JGFhYXRwcOCSJUv4448/Mi8vj6WlpQTAhIQElpSUsLS0lCSZlpZGJycnJiYmsrCwkPv376dWq+Wbb75Jkvz888/p5OTEvXv38qeffuLRo0e5ZcsWqa2GzlN8fDz/85//8Ny5czxw4AB79uzJOXPmSPkJCQm0tbXl008/zWPHjjE7O5tBQUF8/vnnpTLmHDsnJyfOnj2beXl53LNnDzUajYkeo0ePZq9evZiVlcXjx4/ziSeeoFqtbtKxq6ioYPfu3RkaGsqDBw+yoKCAO3bsYFZWllX6pSWs7dj98MMPHeb8KJVKajQa+vj4SI6QSqWin58fdTodSfLYsWMEwG7duklp9WnKsXv11Vc73GEdPXo01Wo1lUqlieM2duxYkx91er2eY8eOpUwmo0ajMfnhYcyPjIw06RdL0el01Gq1jIyMbPRD8k7kCgQPE8Kxe8iorKykSqWSvtiNzJw5k1OmTCFJFhYW0tHRkUuXLqVGo2FSUpJZWW1x7ObMmUMnJ6c26T5mzBguXrxYOg8LC2NISEijcvUdGyOhoaGMiYkxSdu2bRu9vLxI3o7ABQQENPqSMtLS352fffYZ3dzcpPOEhAQC4NmzZ6W0DRs2sEuXLtK5OcfO19fX5Etr0qRJnDx5MkkyPz+fAEyc27y8PAJo0rHbvHkzHR0dee3aNbN632m/NKSmpoZlZWXSUVxcbFXHrqXIUkcd6enpJMlDhw5JaZs3b2Z2drbJkZSURADM2ZtIRjsxZ29ih+tuPCZOnGg2fcOGDY2uw4cfftjI9vpkZWU1mdccxmfK4cOHzea3Va5A8DDRVsdOTJ64T8nNzUVNTQ1GjRplkl5XV4d+/foBALp37461a9fi5ZdfxuTJk/HCCy9YrX2SkMlkLZbT6/V49913sWPHDvz888+ora1FbW1towkMAwcOtKjd7OxsHDt2DO+8845JGzU1NaiqqsKkSZOwbt06dO/eHRERERgzZgwiIyNhY2P+Vk9PT0dMTAxyc3NRXl4OnU6Hmpoa3Lx5U9JRo9GgR48eUh0vLy+UlpY2q+djjz1mMkDcy8sLp06dAgDk5eXBxsbGxObAwMBmJ66cPHkS/fr1a3L/Xmv3S2xsLFauXNmsjXeCwWBoN9l3QklJCQCgqKhISnv55ZebLH/p0iWE/P+v9wo3btwwm65Wq5tNM9pen169ejWZ1xzG8sb61pIrEAhaRjh29ynGL8bU1NRGs0+VSqX0PjMzEwqFAkVFRdDpdE1+kbeWgIAAlJWVSTPdmiIuLg7x8fFYt24devfuDXt7eyxYsAB1dXUm5SydqWowGLBy5UpMmDChUZ5KpYK3tzfy8/Px9ddf45tvvsHcuXOxZs0afPvtt7C1tTUp/9NPP2HMmDGYPXs2Vq1aBVdXVxw6dAgzZ87ErVu3pHIN68lkMpBsVk9zdYzXzFjXEsfYiLkv5fpYs18AYNmyZSYzOsvLy+Ht7W2xvi0hl8vvSefOeC9rtVopbfPmzY1+eOTl5WHq1Kno2rUrUIzbr/cITc2krq6ubjbN3Of49OnTTeY1h7H86dOnMXjwYKvJFQgELSPWsbtPCQ4OhlKpxIULF+Dv729yGL+Ad+zYgeTkZGRkZKC4uBirVq2yWvvPPvss7Ozs8N5775nN//XXXwHcXkJi/PjxmDp1Kvr27Yvu3btbvNaXra0t9Hq9SVr//v2Rn5/fyGZ/f3/I5bdvZ7VajWeeeQbr169HRkYGDh8+LEXL6nP8+HHodDrExcVh8ODBCAgIuCuRl6CgIOh0Ohw/flxKy8/Pl/rMHH369MHJkydx/fp1s/nW7Bfg9o8D43IaxsOaNNXu3UCpVEKj0cDHx0fqG5VKBT8/P4SGhkplAKBbt26YOXMm+vfvb3IEBQWZlDO+vvrqq3fbnEZUVVVBrVab/MCTyWTYu3eviTNtMBiwb98+yGQyaDQaDB061ESOwWBAbGysSb9YSmhoKLRaLWJiYho58HciVyAQtIyI2N2nODo64rXXXsPChQthMBgwbNgwlJeXIysrCw4ODhg5ciTmzJmD1atXY9iwYUhMTMTYsWMxevRo6Rf05cuXcfnyZZw9exbA7S9bR0dH+Pj4NPmXnxFvb2/Ex8dj3rx5KC8vx7Rp06DVanHx4kVs3boVDg4OiIuLg7+/P3bu3ImsrCy4uLjg/fffx+XLl6UvxubQarU4cOAAhg4dCqVSCRcXF7zxxhsYN24cvL29MWnSJMjlcvz3v//FqVOn8PbbbyMxMRF6vR6DBg2CRqPBtm3boFar4evr20h+jx49oNPp8MEHHyAyMhLfffcdNm3a1Iar0Tp69uyJiIgIzJo1C1u2bIGNjQ0WLFjQbFRuypQpiImJQVRUFGJjY+Hl5YWcnBx07doVQ4YMsWq/3A2Cg4M7pF0AqK2tBQBcvXpVcjpqamowa9YsVFVV4fTp03j77bchk8mwZs2aVq25NmPGDHzwwQftorclyOVy7Nu3r1E6SaSmpiIsLAzR0dEAbq+/+N133wG4HbmbOHEili1bhl69euH06dOIjY1FSkoKvvjii1avO6dQKBAXF4dnn30WUVFRVpMrEAgsoB3G+wnuEgaDgX/961/Zs2dP2trasnPnzgwPD2dGRgZHjhzJ8PBwGgwGqfzChQvZo0cPaTmP6Ohos4OsExISLNbh66+/Znh4OF1cXKhSqRgYGMjXXntNmi177do1jh8/ng4ODvTw8OCKFSs4bdo0jh8/XpIRFhbG+fPnN5L95Zdf0t/fnzY2NibLnaSlpUmzSJ2cnPj4449LMzx37drFQYMG0cnJifb29hw8eDC/+eYbqW7DyRPvv/8+vby8qFarGR4ezq1bt5pMJDEud1KfXbt2sf5Hp6nlTuozf/58hoWFSeclJSUcO3YslUolfXx8uHXr1haXOykqKuLEiRPp5OREjUbDgQMH8ujRo1bpl5Z42Nax8/Pza3Y5joMHDxIAkzdEk9FOTP04hsCDtY5dS31gCe0lVyB4GGjrc1dGtjBYSCAQPPSUl5fD2dkZZWVlVv9b9n7ceeLjjz/GrFmz0M9TjhMvO6D/5krkXDbgzJkz0n6xYucJtKtcgeBBp63PXeHYCQSCFmlPx+5+5OrVq9i9ezeCH9XCRX8VNQ4+cHDpLDl1AoFAcKcIx05gVWJiYhATE2M2LzQ01Ow4HsGDi3DsBAKB4O4iHDuBVbl+/XqTMzDVanWjJVYEDzbCsRMIBIK7S1ufu2JWrMAsrq6uLc6MFQgEAoFAcG8h1rETCAQCgUAgeEAQjp1AIBAIBALBA4Jw7AQCgUAgEAgeEIRjJxAIBAKBQPCAIBw7gUAgEAgEggcEMStWIBAI2kBBQQEqb1yBqvKCWKBYIBDcMwjHTnDPUFRUBD8/P+Tk5CAkJMRqcmUyGXbt2oWoqKi70u6IESMQEhKCdevW3bEsa6HVarFgwQIsWLAAQMt9cjf5z3/+g5EjR7aprq2tLQYPHoxHH30UeXl5uHTpEtRqNXQ6HWQyGXx8fEy21qq/vZWHhwcAoLS0tNVbXRUUFCAgIKDZLcWys7MxcODANtlVHwcHB2g0Gri7u6NPnz4YMGAAunTpgl9++QUnT55EZWUlvLy88MQTT8Db2xtPPPEEsrKyJBuNNgONtxG713kYtyN7GG0WWBnrblkreJjYvHkzw8LC6OjoSAC8cePGHck7f/48ATAnJ8dKGt4GAHft2nXX2g0LC+P8+fOtIstalJaW8ubNm9J5SUkJa2pqLK7f1s2oWwLtsPG9uUOj0XDJkiWNNqSvf2i1Wos3p8/OziYApn4cQ0Y7MfXjGAJgdnb2XbXL3GFjY9NsvoeHh8V2diQ7d+5sdL1ac43uRx5GmwVN09bnrhhjJ2gzVVVViIiIwPLlyztaFUELdO7cGRqNRjr39PSEUqnsQI1uRw3vFlVVVVizZg3c3d0RGxsLmUyGYcOGYdiwYQCA2NhY9O7dG88++yySk5Mb1T1x4gSqqqoayfXz8zN5Be6uXUY8PT2l93Z2diZ5xoXG33zzTQwbNgylpaVm7byXSE5OxrPPPovevXvj8OHDqKiowOHDh5u8Rg8CD6PNgnainRxNwX2AwWDg6tWr6efnR5VKxT59+vDzzz8nSa5cuZJeXl68evWqVD4yMpKhoaHU6/UmctLT09sUsTt69ChDQkKoVCo5YMAAJicnN4qcZWRk8De/+Q3t7Ozo6enJpUuX8tatW1K+r68v4+PjTeT27duX0dHR0jkA/u1vf2NERARVKhW1Wi0/++wzKd9cxO6HH37g6NGjaW9vTw8PD06dOpVXrlyxyK6GEbvr16/z97//PTt16kS1Ws2IiAieOXPGpM4XX3zB4OBg2tnZ0dfXl2vXrjXJ9/X15VtvvcUpU6bQ3t6eXl5eXL9+vUX6GOvX7ye0EMVsiLUjdgcOHGi3iJVKpaK7u7vZPB8fH2q1WkZGRlKv11Ov1zMyMpJ+fn6sq6uT3ut0OklXY3TOGI2rn5Z74J9ktBNzD/yTAJiQkHBXo3NqtZpjx46lr68v1Wo1AVAmk1GlUlEmk3Hs2LG8deuWiY3jxo2jRqNpZOe9gk6nM7lG9al/ve5F3dvKw2izoGXa+twVjt1DzPLlyxkYGMi0tDQWFhYyISGBSqWSGRkZ1Ol0HDJkCKOiokiSGzdupLOzM4uKihrJaYtjV1lZyc6dO3Py5Mk8ffo09+zZw+7du5s4WBcvXqRGo+HcuXOZl5fHXbt20d3d3cRps9Sxc3Nz40cffcT8/HyuWLGCCoWCubm5JBs7dpcuXaK7uzuXLVvGvLw8njhxgqNGjeKTTz5pkW0NHbtnnnmGQUFBzMzM5MmTJxkeHk5/f3/W1dWRJI8fP065XM633nqL+fn5TEhIoFqtZkJCgomdjo6OjI2NZX5+PtevX0+FQsH9+/dbpFNrHbuamhqWlZVJR3FxsVUdu/Z2eBYtWtRs/uHDhyVdsrKyCIDp6ekm740cOnSIAJiUlMTs7GxmZ2czKSnp9j2zN5GMdmLO3sS76tDVPz788MMm8zZs2NCkjQ3tvFcwPk/qX6P6mLtG9zsPo82ClhGOnaBVVFZWUqVSMSsryyR95syZnDJlCkmysLCQjo6OXLp0KTUaDZOSkszKaotjt3nzZrq6upqM+9q4caOJg7V8+XL27NmTBoNBKrNhwwY6ODhIv2otdexmz55tUmbQoEGcM2cOycaO3V/+8hf+9re/NSlvdGzy8/NbtK2+Y3fmzBkC4HfffSflX716lWq1WooaPv/88xw1apSJjCVLljA4OFg69/X1ZUREhEmZyZMnc/To0S3qY6zfGscuOjrarKNwvzh2zTk7AFhRUSHpUl5eTgDcvn27yXsjRifO3NFwjF1HHJ988kmTeX//+9+btLGhnfcK27dvb3SN6mPuGt3vPIw2C1pGjLETtIrc3FzU1NRg1KhRcHBwkI6tW7eisLAQANC9e3esXbsWq1evRmRkJF544QWrtZ+Xl4e+ffuajPsaMmRIozJDhgwxGbM0dOhQVFZW4uLFi61qr6HsIUOGIC8vz2zZ7OxspKenm/RLYGAgAEh9Yyl5eXmwsbHBoEGDpDQ3Nzf07NlTaj8vLw9Dhw41qTd06FAUFBRAr9e3yYY7ZdmyZSgrK5OO4uLidmmnvTh37lyz+adPn2703svLy+S9Ea1WCwBISkpCdnY2srOzkZSUBADo2rWryWtHUF1d3WKeORuN5/caRp3q61kfc9fofudhtFnQfojlTh5SDAYDACA1NRXdunUzyas/qD4zMxMKhQJFRUXQ6XSwsbHOLUPSojINB6Ib6xnT5XJ5I1m3bt2ySIemBrkbDAZERkZi9erVjfJa+2Btys76tjVnZ0u010B9pVLZrpMrDhw40OYlTlpCpVJh69atZvN8fHwgl8sRExOD3bt3A7g9ccLPzw9Dhw7FxIkT4efnh9DQUKmOWq0GAAQFBaF///4m8ox9ZHxNSEjAiy++aHWbmkKtVmPfvn3w9fVFaWkpqqurIZPJoFQqUVtbi7179+KPf/yjiY0TJkyARqNBly5dTOy8VwgNDYVWq5WukVz+f/EHg8Eg2XIv6t5WHkabBe2HiNg9pAQHB0OpVOLChQvw9/c3Oby9vQEAO3bsQHJyMjIyMlBcXIxVq1ZZtf3//d//NYk2HDlypFGZrKwsEycnKysLjo6OkjPauXNnlJSUSPnl5eU4f/58o/Yayj5y5IgUhWtI//798cMPP0Cr1TbqG3t7+1bbqdPpcPToUSnt2rVrOHPmDIKCgqQyhw4dMqmXlZWFgIAAk/WrWmPDvc5TTz3VbrJrampw9epVs3keHh744x//iJSUFISFhWH48OHYs2cPZs2ahYkTJyIlJQVr165t87phffr0uRPVW011dTVSU1NRW1srfZbUajVqampAEqmpqfDw8MCePXswbdo0PPnkk0hJSUF1dfUd2dmeKBQKxMXFISUlBVFRUSYzRKOiou74Gt2LPIw2C9oRq/4hLLiveP311+nm5sbExESePXuWJ06c4IcffsjExEQWFxfTxcVFmnm5f/9+2tramgzuLSkpYU5ODj/66CMCYGZmJnNycnjt2rUW266oqKC7uzunTJnCH374gampqfT39zcZ62acPPHKK68wLy+Pu3fvbjR54v/9v/9HT09PZmZm8tSpU4yKiqKDg0OjMXbu7u785JNPmJ+fzzfeeINyuZw//PADycZj7H7++Wd27tyZzz77LI8ePcrCwkJ+9dVXfPHFFy2aldZw8sT48eMZHBzMgwcP8uTJk4yIiDCZPJGdnW0yeSIxMdHs5AknJyeuXr2a+fn5/PDDD6lQKJiWltaiPsb699Ks2Pp63I3DknXs/Pz8zK4XdvPmTWZnZ5uMB21qVqxYx856mFvTralr9KDwMNosaJq2PnfFX7EPMatWrYKHhwdiY2Nx7tw5dOrUCf3798eyZcswY8YMPP7445g3bx4AYNSoUZg3bx6mTp2KkydPwsHBAZs2bcLKlSslecOHDwdw+++oGTNmNNu2g4MD9uzZg9mzZ6Nfv34IDg7G6tWrMXHiRKlMt27dsHfvXixZsgR9+/aFq6srZs6ciRUrVkhlli1bhnPnzmHcuHFwdnbGqlWrzEbsVq5ciX/961+YO3cuPD098emnnyI4ONisbl27dsV3332HpUuXIjw8HLW1tfD19UVERITJXySWkpCQgPnz52PcuHGoq6vD8OHDsXfvXtja2gK4HSH87LPP8MYbb2DVqlXw8vLCW2+91agPFy9ejOzsbKxcuRKOjo6Ii4tDeHh4q/W5lyB5V3eeiI2NbfXOExqNptFfsMY17X788UcEAY3uOZJi54k7ZMKECRg/fvxDtQvDw2izwPrISAsH8wgEgg6j4ZZgrcXLywurVq3CSy+91Kb65eXlcHZ2RllZGZycnNok40Hi448/xqxZs5rdUkwgEAjuhLY+d0XETiB4gKmqqsJ3332HX375BY899lhHq/PAYNxjN/hRLfL0V/HJGB84uHQWTp1AIOhwhGMnaBdiYmIQExNjNi80NBT79u27yxpZhwsXLjT5Fy5wexkZHx+fu6gR8Omnn+Lll182m0cSKpUKCxYsaLRciqDtuLu7tzn6KRAIB2YMQAAAIABJREFUBO2J+CtW0C5cv34d169fN5unVqsbLbFyv6DT6VBUVNRkvlartdqSMJZSUVGBX375xWyera0tfH1977gN8VesQCAQ3F3EX7GCewpXV1dp8/EHCRsbG/j7+3e0GiY4OjrC0dGxo9UQCAQCwT2AWMdOIBAIBAKB4AFBOHYCgUAgEAgEDwjCsRMIBAKBQCB4QBCOnUAgEAgEAsEDgpg8IRAIBG2koKAAFRUVkOlqoKq8gBoHH9BGZVLG0dFRrG8nEAjuGsKxE9x1RowYgZCQEKxbt67JMomJiViwYAF+/fVXq7U7Y8YM/Prrr9i9e7fVZN6LtEffCRpTUFCAgIAAAGi0A0VDxI4UAoHgbiEcOwEAYMuWLdi+fTtOnDiBiooK3LhxA506dWqXtpKTk6V9UoE73y6rvcjIyMCTTz7Zrn1hKa1xSidPnowxY8bcBa2sg16vx3vvvYfly5e3e1t2dnbo0aMHDh06dMfL8VRUVAAAkpKS0N9LAWS+jE8//RTVnQKkMnl5eZg6dapUtiliY2Pviv3NoVQqoVKpUFZWBgCQyWSwZJlTW1tbkIRMJgMAyOVyuLq6wsfHB25ubsjPz8eNGzdQW1sLGxsb2NjYQKPRwM7ODgaDAWVlZSAJJycn/Pa3v8XQoUNx48YNuLm54dq1a+jcuTO6detm0Z6pxn1xf/75Z1y5cgUuLi44duwY9Ho9FAoFfvOb3+DGjRvNytTr9Thw4AC2bduGyspKDBs2DK+++irs7OxM2jC3l2tzeQ11FHvBCtoL4dgJANzeeioiIgIRERFYtmxZu7b1IK5vd69w69YtqNVqqNXqjlbFIpKTkzFx4sS71l5dXR3y8vLg5uaGLl264PLly3csMygoCEGeciATCAoMBLqGtKq+0SHqaGpra1FbWyudW7p2/a1btxqllZSUoKSkpMk6165da5R248YNfPTRR/joo4/M1tFqtYiLi8OECRPM5icnJ2Px4sXNLiDekszk5GS8+OKLKC8vl8rs3r0bf/7zn7F48WIMHjy4URtGGQCazKsvv6UyAsEdQ8EDgcFg4OrVq+nn50eVSsU+ffrw888/J0muXLmSXl5evHr1qlQ+MjKSoaGh1Ov1JnLS09MJgDdu3LC47QkTJnDevHnS+fz58wmAp0+fJkneunWLDg4OTEtLI0mGhYVx/vz50nsAJgdJJiQk0NnZmWlpaQwMDKS9vT3Dw8N56dIli3TS6XRcuHAhnZ2d6erqyiVLlnDatGkcP368VKampoavvvoqO3fuTKVSyaFDh/L7778nSZ4/f76RXtOnT2+x3bCwMM6bN4/z589np06d6OHhwc2bN7OyspIzZsygg4MDu3fvzr1795ro+oc//IFarZYqlYoBAQFct26dlB8dHd1Il/T0dEnHHTt2MCwsjEqlkn//+9+lviNv3xcjR45keHg4DQYDSfLGjRv09vbm8uXLLepLkiwrKyMAlpWVWVynJXbu3NnIrrt9dOnSpc36Z2dnEwCzs7PJn3PIaKfbr02VMUNH238vHxqNhgDYr18/AuDAgQMpk8m4c+dOs/eSTCaTyvj5+REAbWxsCIAqlcrk3JhfX2b9+9HV1ZUffPABU1JS2KdPHxO9IiMjefjwYVZUVPDw4cOMjIwkAMpkMrN59eW3VEYgqE9bn7vCsXtAWL58OQMDA5mWlsbCwkImJCRQqVQyIyODOp2OQ4YMYVRUFEly48aNdHZ2ZlFRUSM5bXHs1q9fz169eknnISEhdHd354YNG0iSWVlZtLGxYUVFBUlTx+7atWt85JFH+NZbb7GkpIQlJSUkbzt2tra2fPrpp3ns2DFmZ2czKCiIzz//vEU6rV69ms7Ozvziiy+Ym5vLmTNn0tHR0cSx+9Of/sSuXbty7969/OGHHzh9+nS6uLjw2rVr1Ol00oM+Pz+fJSUl/PXXX1tsNywsjI6Ojly1ahXPnDnDVatWUS6Xc/To0dyyZQvPnDnDOXPm0M3NjTdv3iRJ1tXV8Y033uD333/Pc+fOMSkpiRqNhjt27CBJVlRU8LnnnmNERITUR7W1tZJjp9VquXPnTp47d44///yziWNHkhcvXqSLi4vkLE6ePJkDBw5kXV2dRX1JWt+x0+l0VCqVHe48AOC1a9faZMOdOnYxMTEdbvu9fMjlco4dO5ZarZbjxo2TXv38/KjT6Uzupfplxo4dSxsbG3p4eNDX15ceHh5UKBTs0qULfXx82KVLFyoUikayfXx8KJPJ2KVLF966dUuSr9frOWbMGMl5q66uNrmOdXV1VKvV1Gg0jT5Ter2ekZGR1Gq11Gq1jIyMbPRj2limoV0CgXDsHmIqKyupUqmYlZVlkj5z5kxOmTKFJFlYWEhHR0cuXbqUGo2GSUlJZmW1xbH773//S5lMxitXrvD69eu0tbXl22+/zUmTJpG8/QU2aNAgqXx9x44kfX19GR8fbyIzISGBAHj27FkpbcOGDRZHWLy8vPjuu+9K57du3eIjjzwiOXaVlZW0tbXlp59+KpWpq6tj165d+d5775FsW1+EhYVx2LBh0rlOp6O9vT1///vfS2klJSUEwMOHDzcpZ+7cuZw4caJ0Pn36dBOnlPy/qGL96B7JRo4dSX722WdUKpVctmwZNRoN8/Pzm7WjpqaGZWVl0lFcXGxVx87Yt/fC0aNHD2ZnZ7f6SEpKIgAeOnSoScfu0KFDBMCkpKRG9Tva7vvhMEb/P/zwQ5PX9PT0RvfShg0bTOq89tprBMDFixebvC5atMisbOPx0UcfNbpf65dp+Kyqfy/X18tIVlaWlN/UZ95Yxlx9wcNLWx07McbuASA3Nxc1NTUYNWqUSXpdXR369esHAOjevTvWrl2Ll19+GZMnT8YLL7xgtfZ79eoFNzc3fPvtt7C1tUXfvn3xzDPPYP369QBuT0IICwtrtVyNRoMePXpI515eXigtLW2xXllZGUpKSjBkyBApzcbGBgMHDpTGDRUWFuLWrVsYOnSoVMbW1haPP/448vLyWq1rffr06SO9VygUcHNzQ+/evaW0Ll26AICJLZs2bcLHH3+Mn376CdXV1airq0NIiGVjtQYOHNhimUmTJmHXrl2IjY3Fxo0bpdmcTREbG4uVK1da1H5baG781d2msLAQAwYMaHP9oqIiDPV7rMk8AJg6dWqb5T/MVFdXA4A0ZtT4Wv/+Mb435hnrdO/evdnXhrKNjBs3rpEe9csUFhaa5JnTpT69evUy+95cmXvpcyG4fxGO3QOAwXB7eYXU1FR069bNJE+pVErvMzMzoVAoUFRUBJ1OBxsb61x+mUyG4cOHIyMjA3Z2dhgxYgR69eoFvV6PU6dOISsrq00zXuvPnDW2QwsHdLeEUU7DgeusN7uvrZjTu36aUb7xun322WdYuHAh4uLiMGTIEDg6OmLNmjU4evSoRe3Z29u3WKaqqgrZ2dlQKBQoKChosfyyZcuwaNEi6by8vBze3t4W6WMJXl5eVpN1p/To0QOfffZZq+sZZ7xqtdomyxjzkpKSEBQUZJJ3J87kw0JDZ834Wv/+Mb5v6KidO3eu2deGso2kpKTgpZdeMkmrX6b+j82mdKnP6dOnTd4PHjy4yTL30udCcP8iHLsHgODgYCiVSly4cKHJyNiOHTuQnJyMjIwMTJ48GatWrbJqRGbEiBHYsmUL7Ozs8NZbb0EmkyE0NBRr165FdXW1SWSsIXZ2dtDr9VbTxdnZGV5eXjhy5AiGDx8OANDpdMjOzkb//v0BAP7+/rCzs8OhQ4fw/PPPA7g9u+/48eOSE1p/eYP25ODBg3jiiScwd+5cKa1hVOBO+2jx4sWQy+XYt28fxowZg7Fjx+Kpp55qsrxSqTT5UWBtQkNDoVQqTWZhdhTff//9Hc3Ubm4GsjEvKChIuveMxMTEdPgSJ/cycrkcZ8+ehVarRVpamvTq5+eH0NBQqVxoaCi0Wi327dsHrVaLs2fPwsbGBlu3boWvry+2bdsGhUKBpKQk+Pj44NNPP4VCoWgk22AwoLi4GCtWrMCMGTOkH74GgwF79+4FcPtH2ezZs030HDp0KNRqNWQyWaPnnMFgQGxsrOTgx8TEYPfu3ZDL5Y3KNLRLIGgz7fC3sKADeP311+nm5sbExESePXuWJ06c4IcffsjExEQWFxfTxcWF69evJ0nu37+ftra2JuM9SkpKmJOTw48++ogAmJmZyZycHIsHlhvH2dna2krjAdatW0eFQsHf/OY3JmUbjrEbNWoUn3nmGV68eJFXrlwhaX6c2K5du2jpLfvuu+/SxcWFycnJzMvL46xZsxpNnpg/fz67du3Kffv2mUyeuH79Osnbkw5kMhkTExNZWloqTf5ojoa2kebHEALgrl27SN7uJycnJ6alpTE/P58rVqygk5MT+/btK5V/55136OPjwx9//JFXrlxhXV2dNMYuJ8d0XFfDvktJSaGdnZ00gH/FihV85JFHJDstQcyKbYyYFdu+R0fPiv3rX//Kf//73+zdu7eJXpGRkczKymJ5eTmzsrIazYptmGduVmxTZQSC+ojJEw85BoOBf/3rX9mzZ0/a2tqyc+fODA8PZ8b/1969hzVxpX8A/yaBQEIgiiigLUkUBVEURe2ii2BbFW1Rqq5WsZVefHqzW221XvBui2vF9bJatdWFVqu9CFoXKq11QalQbRFvSBWpFOyyWkC5iCAk7+8Pf2QNEAiQC8T38zx5NHNmzrzzJgyHMzPnpKQ0GO6CiGjevHnUq1cvbWOlsSE1AFBMTIzB++/atSsNGTJEuywzM5OA+zcxP6h+4yc9PZ0GDBigfUqSqO0Nu5qaGnrrrbfIycmJOnXqRG+//XaD4U7u3r1Lb775Jrm4uDQY7qTO6tWryc3NjQQCgcHDnbS0YVdVVUUREREkl8upU6dO9Nprr9GiRYt0GnY3b96k0aNHk0wmI0B3uJOmGnY3b94kV1dXioqK0snNsGHDaOrUqc0eTx1TNOyILNu4a0ujjogoNTWVgPs32186tp9ohRNdOra/0Qcs9DXsiLhxZ+hLpVI12fiJi4sjpVLZpjrj4uLIycmpwXpCoZAWLFjQ6D7q6miqrKkYmzsu9vBq7XlXQGSkm5YYY1arrKwMcrkcpaWlcHJyMmrdHXXmiV27dmH27NkA2j6lGM88wTNPMFZfa8+73LBjjDXLlA27jqqoqAiHDh2Ct7c3HMRC2Ffko0rmAbKx11nP0dGR54lljLUYN+yYyURFRSEqKqrRssDAQBw5csTMEQEymUxv2ZEjR0xyE3J+fj58fHz0ll+6dAkeHh5G3297wA07xhgzL27YMZMpKSlBSUlJo2USiaTBECvmcPXqVb1lPXr0MMlcqbW1tU3OQ6lUKo02hEx7ww07xhgzr9aed63ztxAzKmdn5zbfj2Rsnp6eZt+njY2NRfbLGGOMGUrY/CqMMcYYY6wj4IYdY4wxxpiV4IYdY4wxxpiV4IYdY4wxxpiV4IYdY4wxxpiV4KdiGWPsIZKTk4OKW39oB1SWde7KAygzZkW4Ycfajby8PKhUKmRmZsLPz89o9QoEAhw8eBBhYWFm2W9wcDD8/PywadOmNtdlLPVz0FxOWOup1WqDxzOUSCQQiUTo1q0bPDw8UFNTA6VSiVmzZiEoKAgpKSn45JNPcO3aNVRUVOD69evQaDTw8fFBQkICMjMzkZKSAuD+9y4wMBBpaWl6p6vKyclBnz59GkyBVjflWVJSEsaNG9fmHNjb20Mmk0EkEsHR0RFeXl6QyWQoKCiAra0tcnJyUFZWBuD+YOMajQbOzs6QSCSQSCRQqVSYNWsWHn/8caNMt2Xsabx4WjDWrhlzwlr2cNm5cycFBQWRo6MjAaBbt261qT59k9q3FQA6ePCg2fYbFBREb731llHqMpbCwkKqqqrS+745rZ2M+mETFxdn1InvW/oSCoU675VKJe3bt48yMjLozp07lJGRQQAocVcU0QonStwVRQC0y9vbSy6XU1xcXJs/E6VS2SAvra3X2PUxpk9rz7t8jx1rtcrKSoSEhFh88nLWPDc3N9jZ2el9z9ouPj4ekydPNvt+3d3dsXLlSgCARqMBAOzduxfp6enw9fVFeHg4/P398csvv2i3UalUOv/6+/ubN2gDlZaWYvLkyYiPj2/V9vHx8ZgyZQp8fX2Rnp6O8vJybV6mTJnS4nqNXR9jJmGihibrADQaDa1bt45UKhXZ29vTgAED6KuvviIiolWrVpG7uzsVFRVp1w8NDaXAwEBSq9U69SQnJ7eqx+7UqVPk5+dHdnZ25O/vT/Hx8Q16zlJSUmjo0KEkFovJzc2NFi5cSDU1NdpyhUJBGzdu1Kl34MCBtGLFCu17APThhx9SSEgI2dvbk1KppC+//FJb3liPXVZWFo0bN44cHByoW7duNHPmTPrjjz8MOq76PXYlJSX03HPPUadOnUgikVBISAhduXJFZ5sDBw6Qj48PicViUigUFB0drVOuUCho9erVNH36dHJwcCB3d3fasmWLQfHU5eDBXsv675vDPXZNq62tNXnvVXl5OY0fP77RMg8PD3r66afpqaeeIqlUSiqVimpra0mtVtPIkSMJAJ0+fVrbM3fp2H6iFU506dh+i/fKNfUSCAQkEAhIqVRSbW1tiz8TpVJJoaGhDc5ZarWaQkNDtXmyRH2MNYd77FiLLV26FDExMdi+fTuysrIwb948zJw5E8ePH0dkZCSUSiVefvllAMCOHTtw4sQJ7NmzB0Jh2782d+7cwdNPPw0vLy9kZGRg5cqVmD9/vs46v//+O8aPH4+hQ4fi3Llz2L59O3bv3o333nuvxftbtmwZJk+ejHPnzmHmzJmYPn06srOzG123sLAQQUFB8PPzw88//4ykpCTcuHEDU6dObdWxRkRE4Oeff8bhw4eRnp4OIsL48eNRU1MDAMjIyMDUqVPx7LPP4sKFC1i5ciWWLVuG2NhYnXrWr1+PAQMG4MyZM1i8eDHmzZuHo0ePtiqm5lRXV6OsrEznxfRLTU01af3Dhg2DTCbD+PHjGy3Pz89HZGQkIiMjUVlZiWvXriE1NRVCoRAzZswAABw6dEj7na+urtb5t70iIhAR8vLyWpzj1NRU5OXlYcmSJQ3OWUKhEIsXL9bmyRL1MWYypmhlsvavoqKC7O3tKS0tTWf5Sy+9RNOnTyciotzcXHJ0dKSFCxeSVCqlvXv3NlpXa3rsdu7cSc7OznTnzh3tsu3bt+v0nC1ZsoS8vLxIo9Fo19m2bRvJZDLtX8yG9ti9+uqrOus89thj9NprrxFRwx67ZcuW0ZgxY3TWLygoIAB0+fLlZo/twR67K1euEAA6efKktryoqIgkEom213DGjBk0evRonToWLFhAPj4+2vcKhYJCQkJ01pk2bRqNGzeu2XiIWt5jt2LFikZ7ULjHrnH79u0zac/VypUriYho9+7dTfbolZWVad/v27ePiIg+/vjjBuvWv8euI7zqjqeln0l5eXmj5XW5MrReY9fHWHO4x461yKVLl1BVVYXRo0dDJpNpX59++ilyc3MBAD179kR0dDTWrVuH0NBQhIeHG23/2dnZGDhwIKRSqXZZQEBAg3UCAgIgEAi0y0aMGKF9OrAl6tcdEBCgt8cuIyMDycnJOnnx9vYGAG1uDJWdnQ0bGxs89thj2mVdunSBl5eXdv/Z2dkYMWKEznYjRoxATk4O1Gp1q46hrRYvXozS0lLtq6CgwCT7sRbu7u4mrf+bb74BANy9e1fvOhcvXsTFixcbxFT3HVqyZAn27t0LAOjevbvOvx1BS3Nct/6DOXlQ3XJD6zV2fYyZCg938pCqu8k6MTERPXr00Cl78Kb6EydOQCQSIS8vD7W1tQYP49AcIjJonQcbdQ9uV7dcKBQ2qKvuEmdz6tddR6PRIDQ0FOvWrWtQ1tKTtr7jfPDYmjrO5ug7hrays7PjhytaIDAw0KT1nz59GhUVFdoGXn0eHh54//33QUSQSqVwdXVFYGAgNBoN9u3bBwAICwvTDslR99m298+47vutUChanOPAwEAolUpERUXh0KFDOpdPNRoN1q5dC5VKZXC9xq6PMVPhHruHlI+PD+zs7JCfnw9PT0+d16OPPgoA+OKLLxAfH4+UlBQUFBRgzZo1Rt3/uXPndHogfvzxxwbrpKWl6TRy0tLS4OjoqG2Mdu3aFYWFhdrysrIyXLt2rcH+6tf9448/anvh6hs8eDCysrKgVCob5MbBwaHFx1lbW4tTp05plxUXF+PKlSvo27evdp0ffvhBZ7u0tDT06dNHZ2yslhwDMy+RSIS4uDiT7sPR0bHRhp27uzsiIiKQkJCAxMREVFZWYs2aNTh9+jTCwsK093x1xHHW6P/vsduwYUOL4xeJRNiwYQMSEhIQFham8xRrWFgYEhISEB0dbXC9xq6PMZMx4uVg1sFERkZSly5dKDY2lq5evUpnzpyhrVu3UmxsLBUUFFDnzp21T15+9913ZGtrS+np6drtCwsLKTMzU3sPz4kTJygzM5OKi4ub3Xd5eTm5uLjQ9OnTKSsrixITE8nT01PnXrfr16+TVCqlN954g7Kzs+nQoUPk4uKic//cokWLyM3NjU6cOEEXLlygsLAwkslkDe6xc3Fxod27d9Ply5dp+fLlJBQKKSsri4ga3mP3+++/U9euXWnKlCl06tQpys3NpW+//ZZeeOEFg554q/9U7MSJE8nHx4dSU1Pp7NmzFBISQp6ennTv3j0iIsrIyCChUEirV6+my5cvU2xsLEkkEoqJidHWoVAoyMnJidatW0eXL1+mrVu3kkgkoqSkpGbjqcsBPxVreu1tHDuVSqUzjl1qaioBoPhtKx7qcexUKpVRx7FrS32M6dPa8y437B5iGo2GNm/eTF5eXmRra0tdu3alsWPHUkpKCj3xxBM0duxYnQcX5s2bR7169dLePKzvBvsHGyRNSU9Pp4EDB5JYLCY/Pz/tL8WWDHdSWlpKU6dOJScnJ3r00UcpNja20Ycntm3bRqNHjyY7OztSKBS0f/9+bXljw51cuXKFnnnmGe0QJd7e3jR37lydfOijb7gTuVxOEomExo4dq3e4E1tbW/Lw8KD169frlCsUClq1ahVNnTqVpFIpubq60qZNm5pP8gM54IadebRk6BOJREIymYx69uxJwcHBNGLECAoPD6fvvvuOqqur6dtvv6UZM2ZQQEAA+fr6UufOnUkul1NAQAAVFxfT999/T0uXLqWlS5fS999/T9XV1ZScnEz79u2j5OTkBn+I1P0RNshNSLTCiQa53W8I1n0fjxw5YpQGmb29Pbm4uJCrqyt5enrSU089RdOmTaPhw4dTUFAQde/enWQyGclkMnJzc6Nu3bqRt7c3DRo0iIYPH67NgbGGDqmtrW0yL5auj7HGtPa8KyAy8GYexpjFKJVKzJ07F3Pnzm1zXdXV1bC3t8fRo0fx5JNPGrRNWVkZ5HI5SktL4eTk1OYYmGUUFRXh0KFD8OmtRGd1Ec8Vy1g71trzLj88wdhDpKysDPHx8RAKhXx/3kPIxcVFOzYlY8w68cMTzCSioqJ0hgt58GWMScYtJT8/X+9xyWQy5Ofnmz2mzz77TG88/fr101l3xYoVWLhwIdatW4dHHnnE7LEyxhgzLb4Uy0yipKQEJSUljZZJJJIGQ6x0FLW1tcjLy9NbrlQqjTYkjKHKy8tx48aNRstsbW2hUCjavA++FMsYY+bFl2JZu+Ls7AxnZ2dLh2F0NjY28PT0tHQYOhwdHeHo6GjpMBhjjLUDfCmWMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xK8MMTjDHGDJKTk4OKW3/AviKfBzdmrJ3ihh17aAQHB8PPzw+bNm3Su05sbCzmzp2L27dvmzEy40pJScGoUaNw69YtdOrUydLhtFtqtRovv/wyYmNj21SPQCCAWCyGVCrFiBEj8Mknn+DTTz9FTk4OampqkJubi4KCAshkMnh7e0OlUuHxxx9HcHCwdsJ4tVqN1NRUFBYWwt3dHYGBgQZPJq9Wq3Hs2DFs3boV//rXv5pdXyKR4KWXXkJtba02/k6dOkEgEMDJyQmZmZnIysqCXC5HWFgY/vrXv0IsFiMnJwd9+vTBIDchzrwiw+CdFcj8rwZXrlzB6dOnMXPmzNYn8f+JxWK4urrCyckJvr6+GDRoEEpLSyEUChEcHKzNWVvy1RGVlpbq/VkWCoVQqVSYOHEiKisrIRQK0bt3b7z++usQi8VmjtT4HrbP2ihMML0ZYwbbuXMnBQUFkaOjIwGgW7dumWxfxcXFVFZWpn2vUCho48aNOuvExMSQXC43WQyttWLFCho4cKBB61ZXV1NhYaFB89oaytrmiq2bl9iSr27dulFcXFyjk8orlUqDJpWPi4sjJycnk8YpEAhowYIFlJGRQQAocVcU0QonStwVZZGcLViwoNX56oh69erVqlzZ2NjQggULLB1+m7TlZ8MatPa8y/fYMYuqrKxESEgIlixZYvJ9OTs7W/14bzU1NRCLxXBzc4NAILB0OO1SfHw8Jk+ebPb91u9luHnzJiZPnowpU6bA19cX6enpKC8vR3p6Onx9fTFlyhTEx8frra/uOMrKykwSb/fu3QEARIT169dj8+bNAACVSqXzr7l4e3vj5s2bWL9+PVxcXFqcr47I09MTubm5rdrWwcEB69evx7vvvmvkqMwjPj6+1T8bDz3TtDPZw0Kj0dC6detIpVKRvb09DRgwgL766isiIlq1ahW5u7tTUVGRdv3Q0FAKDAwktVqtU09ycnKLe+wmTZpEc+bM0b5/6623CABdvHiRiIhqampIJpNRUlISEREFBQXRW2+9pf0/6v2FS/S/HrukpCTy9vYmBwcHGjt2LP3nP/8xKKZZs2bRxIkT6f3336du3bqRXC6nlStXUk1NDc2fP586d+5MPXr0oN27d+ts9+6771LkASR4AAAUWUlEQVTv3r1JIpGQSqWipUuX0r1797Qx1Y81JiaGiIgA0Pbt22nChAkklUpp+fLlDXL5wgsvkK+vL1VVVRER0b1792jw4ME0Y8YMg3NtLT12tbW1Zu1hsre3J4lEQmKxmIRCIYWEhGjL7OzsSCAQkFQq1X7WddRqNYWGhpJKpaLa2tpGj8PDw8MkMYeEhJBUKiV3d3ed5SKRiADQpWP7iVY40cer55gtjwKBgDw8PEgikZBIJCKlUqmTl+by1RHdvn271fmSSCSkUCjI1dWVbGxsqLq62tKH0yK1tbWkVCopNDS0we8Ka/ys9WnteZcbdqxNlixZQt7e3pSUlES5ubkUExNDdnZ2lJKSQrW1tRQQEEBhYWFERLR9+3aSy+WUl5fXoJ7WNOy2bNlC/fv317738/MjFxcX2rZtGxERpaWlkY2NDZWXlxORbsOuuLiYHnnkEVq9ejUVFhZSYWEhEd1vRNna2tKTTz5JP/30E2VkZFDfvn0NbgTNmjWLHB0d6Y033qBffvmFdu/eTQBo7Nix9P7779OVK1dozZo1ZGtrS/n5+drt1qxZQydPnqRr167R4cOHydXVldatW0dERJWVlfTOO+9Qv379tLFWVlYS0f2GXbdu3Wj37t2Um5tLeXl5DXJZXl5OPXv2pLlz5xIR0cKFC8nDw4Nu376t9ziqqqqotLRU+yooKLCKhl1dbsz9WrhwIQHQ/vFR/5WcnNwg1rS0NL1lpjwOfTHWvTK/iSVa4USD3IQWyaW+nDWVr45oxIgRbc7R22+/TQAa3HLS3tV9v9PT0xstt7bPWh++FMvM7s6dO/j73/+Of/7znxg7dix69uyJiIgIzJw5Ezt37oRIJMLevXtx7NgxLFq0CO+88w62bdtmlLlLgfsPQ2RlZaGoqAi3bt1CVlYW5s6di5SUFAD3HyLw9/eHTCZrsK2zszNEIhEcHR3h5uYGNzc3bVlNTQ127NiBIUOGYPDgwZgzZw6OHTtmcFzOzs7YsmULvLy88OKLL8LLywuVlZVYsmQJevfujcWLF0MsFuPkyZPabZYuXYrhw4dDqVQiNDQU77zzDr788ksA9292l8lksLGx0cYqkUi0286YMQMvvvgievbs2WhuZTIZ9u7di23btmH58uXYsGED9uzZA7lcrvcY1q5dC7lcrn09+uijBh9/e1ZYWGiR/b700ksAgLt37zZa3lhc/fv311tmyuPQF2Od//znPybbd0vUz0FT+eqI8vPz21xHz549AaDVl3Mtpe4zrPtM67O2z9rY+KlY1mqXLl1CVVUVRo8erbP83r17GDRoEID7J5bo6Gi88sormDZtGsLDw422//79+6NLly44fvw4bG1tMXDgQEyYMAFbtmwBcL9hFxQU1OJ6pVIpevXqpX3v7u6OmzdvGrx9v379IBT+728mV1dXnROUSCRCly5ddOo8cOAANm3ahKtXr6KiogK1tbUGT/o8ZMiQZtcJCAjA/PnzsWbNGixcuBAjR45scv3Fixfj7bff1r4vKyuzisadu7u7Rfa7e/duANBpkD+osbguXryot8yUx6Evxjrdu3cHCky2e4PVz0FT+eqIPDw8UFDQtkT/+uuvAKBzPusI6j7Dixcv4k9/+lODcmv7rI2Ne+xYq2k0GgBAYmIizp49q31dunQJBw4c0K534sQJiEQi5OXlaYdYMAaBQICRI0ciJSUFx48fR3BwMPr37w+1Wo0LFy4gLS0NwcHBLa7X1ta2wX6IqE3bN7asLn8//vgjnn32WYwbNw4JCQnIzMxEZGQk7t27Z9D+HBwcml1Ho9Hg5MmTEIlEyMnJaXZ9Ozs7ODk56bysQWBgoFn3Z29vD4lEgo0bN0IoFOLy5cvaMjs7OwgEAu0wKQ/SaDRYu3YtVCpVozEHBgbCw8PDJDFfvnwZUqm0wS/Nuoc/7OzsAACvv/66SfbfGIFAAA8PD0gkEohEIiiVSp28NJevjigxMbHV20okEigUCnz22WewsbEx62dlDIGBgVAqlYiKitKeJ+tY42dtbNywY63m4+MDOzs75Ofnw9PTU+dV17vzxRdfID4+HikpKSgoKMCaNWuMGkNwcDBSUlKQkpKC4OBgCAQCBAYGIjo6Gnfv3m3wC/NBYrEYarXaqPG0xsmTJ6FQKBAZGYkhQ4agd+/e+O2333TWaWus69evR3Z2No4fP45vv/0WMTExbQ27QxKJRIiLizPb/qqqqnD37l3cu3cPAoEASUlJ2rLq6moQEe7evYvJkyfrPPkXFhaGhIQEREdHNzpml0gkwsaNG00Sc1JSEiorK1FTU6OzvH5ve1M/W8ZGRJBKpbh79y7UajVcXFxw+vRpg/PVEcnl8lb3tN29exe3b9/GjRs3MG/evA43np1IJMKGDRuQkJCAsLCwFv1sMIAfnmBtEhkZSV26dKHY2Fi6evUqnTlzhrZu3UqxsbFUUFBAnTt3pi1bthAR0XfffUe2trY6N8QWFhZSZmYmffzxxwSATpw4QZmZmVRcXGzQ/s+fP08CgYBsbW21N5hu2rSJRCIRDR06VGfdBx+eICIaPXo0TZgwga5fv05//PEHETU+jt3BgwfJ0B+Vuqdim9ovke4YeocOHSIbGxvav38/Xb16lTZv3kzOzs46cXz22Wfk4OBAmZmZ9Mcff2ifcAVABw8e1Km7/sMTmZmZJBaL6fDhw0REtGvXLnJ0dKTc3FyDjonIep6KrdPex7FTqVTtdhy7uqdiLx3bb5GcNTaOnaH56oh4HLuH57Our7XnXb7HjrXJmjVr0K1bN6xduxa//vorOnXqhMGDB2Px4sWIiIjAsGHDMGfOHADA6NGjMWfOHMycORNnz56FTCbDjh07sGrVKm19dfd+xcTEICIiotn99+/fHy4uLlAoFNrLhUFBQVCr1c3eX7d69Wq88sor6NWrl7b3xBImTpyIefPmYc6cOaiursZTTz2FZcuWYeXKldp1Jk+ejPj4eIwaNQq3b982OD9VVVUIDw9HREQEQkNDAdy/kT8xMRHPPfec9jL5w2bSpEmora1tNzNPTJw4sVWj60+aNAkTJ040y8wTP/zwAwDgl19+QV8A165dAwBkZGQgOzvbrDNPrF279qGZjeDq1asP7cwTdd/vh+WzNhYBWeq3GWOswygrK4NcLkdpaanV3G/HWmbXrl2YPXt2o1OK8XyxjBlfa8+73GPHGGOsWWFhYQAAn95KZKuLsHu8B2Sdu3KjjrF2hnvsWLsVFRWFqKioRssCAwNx5MgRM0eERsfEq3PkyBGrfUqLe+wYY8y8Wnve5YYda7dKSkpQUlLSaJlEIkGPHj3MHNH9+1306dGjR7NjgHVU3LBjjDHz4kuxzOo4OzvD2dnZ0mHo8PT0tHQIFlH395+pJpxnjDGmq+5829L+N27YMcaaVV5eDgBWMfsEY4x1JOXl5U1OAVkfX4pljDVLo9GgT58+yMjIgEAgaFA+dOhQ/PTTT21eVjd1WUFBgckv+TYWi6m2b27dpsr1lRmSX0vlVl98ptjWkHVbkkN9y/m72/Jy/u62bV0igr+/P65cuaIzTWVzuMeOMdYsoVAIsVis969GkUjU4ITblmXmmMassf2aavvm1m2qXF+ZIbm0VG717dsU2xqybktyqG85f3dbXs7f3bavKxaLW9SoAwDRygdHQWWMsSYMGzasRWUtXVZdXY2//e1vWLx4sXZOUlNq6niMvX1z67Y0t/qW119mqdzqi88U2xqybktyqG85f3dbXs7f3bav29JY+FIsY6zd4KdvTYdza1qcX9Ph3LYM99gxxtoVkUiE4OBg2NjwnSLGxrk1Lc6v6XBuDcc9dowxxhhjVqJld+QxxhhjjLF2ixt2jDHGGGNWght2jDHGGGNWght2jDHGGGNWght2jLEOo7KyEgqFAvPnz7d0KFbHxsYGfn5+8PPzw8svv2zpcKzKtWvXMGrUKPj4+MDX1xd37tyxdEhW4/Lly9rvrZ+fHyQSCQ4dOmTpsCyKn4pljHUYkZGRyMnJgYeHB6Kjoy0djlVxcXFBUVGRpcOwSkFBQXjvvfcQGBiIkpISODk58bAdJlBRUQGlUonffvsNDg4Olg7HYrjHjjHWIeTk5OCXX37B+PHjLR0KYwbLysqCra0tAgMDAQDOzs7cqDORw4cP44knnnioG3UAN+wYY2Zw4sQJhIaGonv37hAIBI1eKvnwww+hUqlgb28Pf39/pKam6pTPnz8fa9euNVfIHYox8ltWVgZ/f3/8+c9/xvHjx80VervX1tzm5ORAJpNhwoQJGDx4MKKioswZfrtnjO9unS+//BLTpk0zdcjtHjfsGGMmd+fOHQwcOBBbt25ttPyLL77A3LlzERkZiczMTAQGBmLcuHHIz88HAHz99dfo06cP+vTpY86wO4y25hcA8vLykJGRgR07duD5559HWVmZucJv19qa25qaGqSmpmLbtm1IT0/H0aNHcfToUXMeQrtmjO8ucP8Pk5MnT3KPPgAQY4yZEQA6ePCgzrJhw4bRq6++qrPM29ubFi1aREREixYtokceeYQUCgV16dKFnJycaNWqVWaLuSNpTX7rCwkJoZ9++slkMXZUrcltWloajR07Vlv2wQcf0AcffGD6YDugtnx3P/30UwoPDzd5jB0B99gxxizq3r17yMjIwJgxY3SWjxkzBmlpaQCAtWvXoqCgAHl5eYiOjsbs2bOxfPlyS4Tb4RiS31u3bqG6uhoAcP36dVy6dAk9e/Y0e6wdjSG5HTp0KG7cuIFbt25Bo9HgxIkT6Nu3ryXC7XAMyW8dvgz7P3wHJ2PMooqKiqBWq+Hq6qqz3NXVFf/9738tFJX1MCS/2dnZeOWVVyAUCiEQCLB582Y4OztbItwOxZDc2tjYICoqCiNHjgQRYcyYMXj66actEW6HY+i5obS0FKdPn0ZcXJy5Q2yXuGHHGGsXBAKBznsiarAMACIiIswUkXVpKr/Dhw/HhQsXLBGWVWjuuztu3DiMGzfO3GFZjebyK5fLcePGDXOH1W7xpVjGmEW5uLhAJBI16J27efNmg7/UWctxfk2Hc2tanN/W4YYdY8yixGIx/P39GzwpePToUQwfPtxCUVkPzq/pcG5Ni/PbOnwpljFmchUVFbh69ar2/bVr13D27Fk4OzvDw8MDb7/9Np577jkMGTIEAQEB+Oijj5Cfn49XX33VglF3HJxf0+Hcmhbn1wQs+kwuY+yhkJycTAAavGbNmqVdZ9u2baRQKEgsFtPgwYPp+PHjlgu4g+H8mg7n1rQ4v8bHc8UyxhhjjFkJvseOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcYYY8xKcMOOMcaYxaSkpEAgEOD27duWDoUxq8ANO8YYY2YRHByMuXPn6iwbPnw4CgsLIZfLLRQVoFKpkJSUZLH9M2ZMNpYOgDHG2MNLLBbDzc3NYvs/f/48iouLMWrUKIvFwJgxcY8dY4wxk4uIiMDx48exefNmCAQCCAQC5OXlNbgUGxsbi06dOiEhIQFeXl6QSqWYMmUK7ty5g08++QRKpRKdO3fGm2++CbVara3/3r17ePfdd9GjRw84ODjgscceQ0pKSrNxff311xg7dizs7OwaLRcIBNi1axeeeeYZSKVS9O7dG4cPH9aW37p1C+Hh4ejatSskEgl69+6NmJiYtiWLsTbghh1jjDGT27x5MwICAjB79mwUFhaisLAQjz76aKPrVlZWYsuWLfj888+RlJSElJQUTJo0Cd988w2++eYb7NmzBx999BEOHDig3eaFF17AyZMn8fnnn+P8+fP4y1/+gpCQEOTk5DQZ1+HDhzFx4sQm11m1ahWmTp2K8+fPY/z48QgPD0dJSQkAYNmyZbh06RKOHDmC7OxsbN++HS4uLi3MDmPGw5diGWOMmZxcLodYLIZUKm320mtNTQ22b9+OXr16AQCmTJmCPXv24MaNG5DJZPDx8cGoUaOQnJyMadOmITc3F/v378f169fRvXt3AMD8+fORlJSEmJgYREVFNbqf33//HefOncP48eObjCciIgLTp08HAERFReEf//gHTp8+jZCQEOTn52PQoEEYMmQIAECpVLYkLYwZHTfsGGOMtStSqVTbqAMAV1dXKJVKyGQynWU3b94EAJw5cwZEhD59+ujUU11djS5duujdz+HDhzFixAg4Ozs3Gc+AAQO0/3dwcICjo6N236+99homT56MM2fOYMyYMQgLC8Pw4cMNP1jGjIwbdowxxtoVW1tbnfcCgaDRZRqNBgCg0WggEomQkZEBkUiks96DjcH6DLkMqy+eun2PGzcOv/32GxITE/H999/jiSeewBtvvIHo6Ohm62XMFPgeO8YYY2YhFot1HngwlkGDBkGtVuPmzZvw9PTUeem77FtRUYHk5GRMmDChzfvv2rUrIiIisHfvXmzatAkfffRRm+tkrLW4x44xxphZKJVKnDp1Cnl5eZDJZM1eAjVUnz59EB4ejueffx4bNmzAoEGDUFRUhH//+9/w9fVt9B66pKQk9O7dGz179mzTvpcvXw5/f3/069cP1dXVSEhIQN++fdtUJ2NtwT12jDHGzGL+/PkQiUTw8fFB165dkZ+fb7S6Y2Ji8Pzzz+Odd96Bl5cXJkyYgFOnTul98vbrr7826DJsc8RiMRYvXowBAwZg5MiREIlE+Pzzz9tcL2OtJSAisnQQjDHGmLmo1Wp069YNR44cwbBhwywdDmNGxT12jDHGHirFxcWYN28ehg4daulQGDM67rFjjDHGGLMS3GPHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYluGHHGGOMMWYl/g/aJFWXgSxhwQAAAABJRU5ErkJggg==",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 2 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt[:figure]()\n",
    "\n",
    "for (case,(nx1,ny1)) in enumerate([(200,100),(100,200)])\n",
    "    tag1=\"nx1=\"*string(nx1)\n",
    "    tag2=\"ny1=\"*string(ny1)\n",
    "    r_slices=[]\n",
    "    push!(r_slices, collect(results[@tagged tag1 && tag2]))\n",
    "    r_slice=r_slices[end]\n",
    "    funcs=[ e[1][1] for e in r_slice ];\n",
    "    times=[ e[2].times for e in r_slice ];\n",
    "    faster=sortperm(r_slice, rev=true, by=e->median(e[2]))\n",
    "    \n",
    "    ax=fig[:add_subplot](2,1,case)\n",
    "    ax[:boxplot](times[faster][:], vert=false)\n",
    "    ax[:set_xlim](5e3,5e7)\n",
    "    ax[:set_xscale](\"log\")\n",
    "    ax[:set_xlabel](\"time / ns\")\n",
    "    ax[:set_yticklabels](funcs[faster]);\n",
    "    ax[:set_title](tag1*\", \"*tag2)\n",
    "end\n",
    "plt[:tight_layout](h_pad=1.0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ex2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex2_double_loop_ij (generic function with 4 methods)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex2_double_loop_ij(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds for i in 2:nx-1\n",
    "        @simd for j in 2:ny-1\n",
    "            w[i,j]=u[i+1,j]+v[i,j-1]*alpha\n",
    "        end\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex2_double_loop_ji (generic function with 4 methods)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex2_double_loop_ji(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds for j in 2:ny-1\n",
    "        @simd for i in 2:nx-1\n",
    "            w[i,j]=u[i+1,j]+v[i,j-1]*alpha\n",
    "        end\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     27.537 μs (0.00% GC)\n",
       "  median time:      98.572 μs (0.00% GC)\n",
       "  mean time:        98.392 μs (0.00% GC)\n",
       "  maximum time:     1.341 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex2_double_loop_ij(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     9.111 μs (0.00% GC)\n",
       "  median time:      27.191 μs (0.00% GC)\n",
       "  mean time:        27.915 μs (0.00% GC)\n",
       "  maximum time:     594.166 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex2_double_loop_ji(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex2_CartesianIndices (generic function with 4 methods)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex2_CartesianIndices(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    @inbounds @simd for ij in CartesianIndices((2:nx-1,2:ny-1))\n",
    "        i,j=Tuple(ij)\n",
    "        w[i,j]=u[i+1,j]+v[i,j-1]*alpha\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     9.123 μs (0.00% GC)\n",
       "  median time:      26.790 μs (0.00% GC)\n",
       "  mean time:        28.055 μs (0.00% GC)\n",
       "  maximum time:     363.301 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex2_CartesianIndices(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex2_LinearIndices_CartesianIndices (generic function with 4 methods)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex2_LinearIndices_CartesianIndices(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    w_I=LinearIndices(CartesianIndices( (2:nx-1, 2:ny-1)))\n",
    "    u_J=LinearIndices(CartesianIndices( (3:nx, 2:ny-1)))\n",
    "    v_K=LinearIndices(CartesianIndices( (2:nx-1, 1:ny-2)))\n",
    "    @inbounds @simd for m in 1:length(w_I)\n",
    "        i=w_I[m]\n",
    "        j=u_J[m]\n",
    "        k=v_K[m]\n",
    "        w[i]=u[j]+v[k]*alpha\n",
    "    end\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  0 bytes\n",
       "  allocs estimate:  0\n",
       "  --------------\n",
       "  minimum time:     8.624 μs (0.00% GC)\n",
       "  median time:      25.673 μs (0.00% GC)\n",
       "  mean time:        25.281 μs (0.00% GC)\n",
       "  maximum time:     143.923 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex2_LinearIndices_CartesianIndices(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex2_view (generic function with 4 methods)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex2_view(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    w_sub=view(w,2:nx-1, 2:ny-1)\n",
    "    v_sub=view(v, 2:nx-1, 1:ny-2)\n",
    "    u_sub=view(u, 3:nx, 2:ny-1)\n",
    "    w_sub=u_sub+v_sub*alpha\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  303.53 KiB\n",
       "  allocs estimate:  6\n",
       "  --------------\n",
       "  minimum time:     21.394 μs (0.00% GC)\n",
       "  median time:      157.889 μs (0.00% GC)\n",
       "  mean time:        252.893 μs (36.87% GC)\n",
       "  maximum time:     67.270 ms (99.72% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex2_view(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ex2_dot_view (generic function with 4 methods)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function ex2_dot_view(u,v,w, nx=size(u,1),ny=size(u,2), alpha=0.3)\n",
    "    # @assert size(u)==(nx,ny)\n",
    "    # @assert size(v)==(nx,ny)\n",
    "    # @assert size(w)==(nx,ny)\n",
    "    w_sub=view(w,2:nx-1, 2:ny-1)\n",
    "    v_sub=view(v, 2:nx-1, 1:ny-2)\n",
    "    u_sub=view(u, 3:nx, 2:ny-1)\n",
    "    @. w_sub=u_sub+v_sub*alpha\n",
    "    0\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  192 bytes\n",
       "  allocs estimate:  3\n",
       "  --------------\n",
       "  minimum time:     9.849 μs (0.00% GC)\n",
       "  median time:      34.707 μs (0.00% GC)\n",
       "  mean time:        36.257 μs (0.00% GC)\n",
       "  maximum time:     376.272 μs (0.00% GC)\n",
       "  --------------\n",
       "  samples:          10000\n",
       "  evals/sample:     3"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@benchmark ex2_dot_view(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12-element BenchmarkTools.BenchmarkGroup:\n",
       "  tags: []\n",
       "  (\"ex2_double_loop_ji\", \"nx1=200\", \"ny1=100\") => Trial(9.248 μs)\n",
       "  (\"ex2_double_loop_ij\", \"nx1=100\", \"ny1=200\") => Trial(36.703 μs)\n",
       "  ⋮"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "suite = BenchmarkGroup()\n",
    "for (nx1,ny1) in [(200,100),(100,200)]\n",
    "    for f in [\n",
    "        :ex2_double_loop_ij,\n",
    "        :ex2_double_loop_ji,\n",
    "        :ex2_CartesianIndices,\n",
    "        :ex2_LinearIndices_CartesianIndices,\n",
    "        :ex2_view,\n",
    "        :ex2_dot_view ]\n",
    "      suite[string(f), \"nx1=\"*string(nx1), \"ny1=\"*string(ny1)] = @benchmarkable $(f)(u,v,w, $nx1, $ny1) setup=( (u,v,w)=make_uvw($nx1,$ny1, $rng))\n",
    "    end\n",
    "end\n",
    "tune!(suite);\n",
    "results = run(suite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "faster = [6, 2, 3, 5, 4, 1]\n",
      "faster = "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 2 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 2, 1, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "fig = plt[:figure]()\n",
    "\n",
    "for (case,(nx1,ny1)) in enumerate([(200,100),(100,200)])\n",
    "    tag1=\"nx1=\"*string(nx1)\n",
    "    tag2=\"ny1=\"*string(ny1)\n",
    "    r_slices=[]\n",
    "    push!(r_slices, collect(results[@tagged tag1 && tag2]))\n",
    "    r_slice=r_slices[end]\n",
    "    funcs=[ e[1][1] for e in r_slice ];\n",
    "    times=[ e[2].times for e in r_slice ];\n",
    "    faster=sortperm(r_slice, rev=true, by=e->median(e[2]))\n",
    "    @show faster\n",
    "    \n",
    "    ax=fig[:add_subplot](2,1,case)\n",
    "    ax[:boxplot](times[faster][:], vert=false)\n",
    "    ax[:set_xlim](5e3,5e7)\n",
    "    ax[:set_xscale](\"log\")\n",
    "    ax[:set_yticklabels](funcs[faster]);\n",
    "    ax[:set_title](tag1*\", \"*tag2)\n",
    "    ax[:set_xlabel](\"time / ns\")\n",
    "end\n",
    "plt[:tight_layout](h_pad=1.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.1.0",
   "language": "julia",
   "name": "julia-1.1"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}