{ "cells": [ { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "using PyPlot\n", "using LinearAlgebra\n", "using Random\n", "\n", "Random.seed!(12345);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Exploring Low-Precision Training\n", "\n", "Let's look at how our logistic regression model from the previous couple of demos is affected by training in low-precision floating-point arithmetic.\n", "\n", "First, define a low-precision numeric type in Julia." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "rescale_bias (generic function with 5 methods)" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import Base.convert\n", "import Base.length\n", "import Base.zero\n", "import Base.one\n", "import Base.typemin\n", "import Base.transpose\n", "import Base.sqrt\n", "import LinearAlgebra.dot\n", "import Base.exp\n", "import Base.expm1\n", "import Base.isless\n", "import Base.log\n", "import Base.+\n", "import Base.-\n", "import Base.*\n", "import Base./\n", "\n", "\n", "abstract type NoDynamicBias end;\n", "\n", "# NB = number of mantissa bits\n", "# NE = number of exponent bits\n", "# EBIAS = extra exponent bias; default should be 0 which corresponds to a bias of (1 << (NE-1)) - 1\n", "# RM = rounding mode\n", "struct SimFP{NB,NE,EBIAS,RM} <: Number\n", " v::Float64;\n", " SimFP{NB,NE,EBIAS,RM}(x::Float64) where {NB,NE,EBIAS,RM} = new{NB,NE,EBIAS,RM}(quantize(x, SimFP{NB,NE,EBIAS,RM})); # NB, NE, EBIAS, RM));\n", "end\n", "\n", "function Float64(x::SimFP)\n", " return x.v\n", "end\n", "\n", "function convert(::Type{Float64}, x::SimFP)\n", " return x.v\n", "end\n", "\n", "function convert(::Type{SimFP{NB,NE,EBIAS,RM}}, x::SimFP) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(x.v)\n", "end\n", "\n", "function convert(::Type{SimFP{NB,NE,EBIAS,RM}}, x::Float64) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(x)\n", "end\n", "\n", "function convert(::Type{SimFP{NB,NE,EBIAS,RM}}, x) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(convert(Float64, x))\n", "end\n", "\n", "function (::Type{SimFP{NB,NE,EBIAS,RM}})(x) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(convert(Float64, x))\n", "end\n", "\n", "# function convert(::Type{T}, x::SimFP) where {T}\n", "# return convert(T, x.v)\n", "# end\n", "\n", "function zero(::Type{SimFP{NB,NE,EBIAS,RM}}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(0.0)\n", "end\n", "\n", "function zero(::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(0.0)\n", "end\n", "\n", "function one(::Type{SimFP{NB,NE,EBIAS,RM}}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(1.0)\n", "end\n", "\n", "function one(::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(1.0)\n", "end\n", "\n", "function typemin(::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(-realmax(Float64))\n", "end\n", "\n", "function typemax(::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(realmax(Float64))\n", "end\n", "\n", "function transpose(x::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return x\n", "end\n", "\n", "function sqrt(x::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(sqrt(x.v))\n", "end\n", "\n", "function dot(x::SimFP{NB,NE,EBIAS,RM}, y::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(dot(x.v, y.v))\n", "end\n", "\n", "function exp(x::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(exp(x.v))\n", "end\n", "\n", "function expm1(x::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(expm1(x.v))\n", "end\n", "\n", "function log(x::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(log(x.v))\n", "end\n", "\n", "function isless(x::SimFP{NB,NE,EBIAS,RM}, y::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return isless(x.v, y.v)\n", "end\n", "\n", "abstract type RoundingModeNearest end;\n", "abstract type RoundingModeRandom end;\n", "\n", "abstract type RoundingModeNearestFast end;\n", "abstract type RoundingModeRandomFast end;\n", "\n", "function quantize(x::Float64, nb::Int64, ne::Int64, ::Type{NoDynamicBias}, rm)\n", " return quantize(x, nb, ne, 0, rm);\n", "end\n", "\n", "function quantize(x::Float64, ::Type{SimFP{nb,ne,ebias,RoundingModeNearest}}) where {nb,ne,ebias}\n", " if (x == 0.0)\n", " return x;\n", " end\n", " # @assert(ne <= 11);\n", " xi = reinterpret(Int64, x);\n", " xir = (xi + 1 << (51 - nb)) & (~((1 << (52 - nb)) - 1));\n", " if (ne < 11)\n", " xir_pos = xir & (~(1 << 63));\n", " xir_sign = xir & (1 << 63);\n", " bias = ebias + (1 << (ne-1)) - 1;\n", " qf_max = (((bias + 1 + 1023) << nb) - 1) << (52 - nb);\n", " qf_min = (1023 - bias + 1) << 52;\n", " qf_min_d2 = (1023 - bias) << 52;\n", " if (xir_pos > qf_max)\n", " return reinterpret(Float64, qf_max | xir_sign);\n", " elseif (xir_pos < qf_min_d2)\n", " return Float64(0.0);\n", " elseif (xir_pos < qf_min)\n", " return reinterpret(Float64, qf_min | xir_sign);\n", " end\n", " end\n", " return reinterpret(Float64, xir);\n", "end\n", "\n", "function quantize(x::Float64, ::Type{SimFP{nb,ne,ebias,RoundingModeRandom}}) where {nb,ne,ebias}\n", " if (x == 0.0)\n", " return x;\n", " end\n", " # @assert(ne <= 11);\n", " mask = (1 << (52 - nb)) - 1;\n", " xi = reinterpret(Int64, x);\n", " xir = (xi + (rand(Int64) & mask)) & (~mask);\n", " if (ne < 11)\n", " xir_pos = xir & (~(1 << 63));\n", " xir_sign = xir & (1 << 63);\n", " bias = ebias + (1 << (ne-1)) - 1;\n", " qf_max = (((bias + 1 + 1023) << nb) - 1) << (52 - nb);\n", " qf_min = (1023 - bias + 1) << 52;\n", " if (xir_pos > qf_max)\n", " return reinterpret(Float64, qf_max | xir_sign);\n", " elseif (xir_pos < qf_min)\n", " xfr_pos = reinterpret(Float64, xir_pos);\n", " ff_min = reinterpret(Float64, qf_min);\n", " if (xfr_pos / ff_min > rand())\n", " return reinterpret(Float64, qf_min | xir_sign);\n", " else\n", " return Float64(0.0)\n", " end\n", " end\n", " end\n", " return reinterpret(Float64, xir);\n", "end\n", "\n", "function quantize(x::Float64, ::Type{SimFP{nb,ne,ebias,RoundingModeNearestFast}}) where {nb,ne,ebias}\n", " xi = reinterpret(Int64, x);\n", " xir = (xi + 1 << (51 - nb)) & (~((1 << (52 - nb)) - 1));\n", " return reinterpret(Float64, xir);\n", "end\n", "\n", "function quantize(x::Float64, ::Type{SimFP{nb,ne,ebias,RoundingModeRandomFast}}) where {nb,ne,ebias}\n", " mask = (1 << (52 - nb)) - 1;\n", " xi = reinterpret(Int64, x);\n", " xir = (xi + (rand(Int64) & mask)) & (~mask);\n", " return reinterpret(Float64, xir);\n", "end\n", "\n", "function +(x::SimFP{NB,NE,EBIAS,RM}, y::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(x.v + y.v)\n", "end\n", "\n", "function -(x::SimFP{NB,NE,EBIAS,RM}, y::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(x.v - y.v)\n", "end\n", "\n", "function *(x::SimFP{NB,NE,0,RM}, y::SimFP{NB,NE,EBIASY,RM}) where {NB,NE,EBIASY,RM}\n", " return SimFP{NB,NE,EBIASY,RM}(x.v * y.v)\n", "end\n", "\n", "function *(x::SimFP{NB,NE,EBIASX,RM}, y::SimFP{NB,NE,0,RM}) where {NB,NE,EBIASX,RM}\n", " return SimFP{NB,NE,EBIASX,RM}(x.v * y.v)\n", "end\n", "\n", "function *(x::SimFP{NB,NE,0,RM}, y::SimFP{NB,NE,0,RM}) where {NB,NE,RM}\n", " return SimFP{NB,NE,0,RM}(x.v * y.v)\n", "end\n", "\n", "function *(x::SimFP{NB,NE,EBIASX,RM}, y::SimFP{NB,NE,EBIASY,RM}) where {NB,NE,EBIASX,EBIASY,RM}\n", " return SimFP{NB,NE,EBIASX+EBIASY,RM}(x.v * y.v)\n", "end\n", "\n", "function /(x::SimFP{NB,NE,EBIASX,RM}, y::SimFP{NB,NE,0,RM}) where {NB,NE,EBIASX,RM}\n", " return SimFP{NB,NE,EBIASX,RM}(x.v / y.v)\n", "end\n", "\n", "function /(x::SimFP{NB,NE,EBIASX,RM}, y::SimFP{NB,NE,EBIASY,RM}) where {NB,NE,EBIASX,EBIASY,RM}\n", " return SimFP{NB,NE,EBIASX-EBIASY,RM}(x.v / y.v)\n", "end\n", "\n", "function /(x::SimFP{NB,NE,EBIAS,RM}, y::Int64) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(x.v / Float64(y))\n", "end\n", "\n", "function -(x::SimFP{NB,NE,EBIAS,RM}) where {NB,NE,EBIAS,RM}\n", " return SimFP{NB,NE,EBIAS,RM}(-x.v)\n", "end\n", "\n", "function +(::Type{NoDynamicBias}, ::Type{NoDynamicBias})\n", " return NoDynamicBias;\n", "end\n", "\n", "function -(::Type{NoDynamicBias}, ::Type{NoDynamicBias})\n", " return NoDynamicBias;\n", "end\n", "\n", "function rescale_bias(::Type{SimFP{NB,NE,EBIAS,RM}}, hint) where {NB,NE,EBIAS,RM}\n", " hint64 = Float64(hint);\n", " eb = -Int64(floor(log2(hint64)));\n", " println(\"based on hint ($(hint64)), setting exponent bias to:$(eb)\")\n", " return SimFP{NB,NE,eb,RM};\n", "end\n", "\n", "function rescale_bias(::Type{SimFP{NB,NE,NoDynamicBias,RM}}, hint) where {NB,NE,RM}\n", " return SimFP{NB,NE,NoDynamicBias,RM};\n", "end\n", "\n", "function rescale_bias(::Type{Float16}, hint)\n", " return Float16\n", "end\n", "\n", "function rescale_bias(::Type{Float32}, hint)\n", " return Float32\n", "end\n", "\n", "function rescale_bias(::Type{Float64}, hint)\n", " return Float64\n", "end" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# generate the data\n", "Random.seed!(424242)\n", "d = 50;\n", "N = 10000;\n", "wtrue = randn(d);\n", "wtrue = d^2 * wtrue / norm(wtrue);\n", "X = randn(N, d);\n", "X ./= sqrt.(sum(X.^2; dims=2));\n", "Y = (1 ./ (1 .+ exp.(-X * wtrue)) .>= rand(N)) .* 2 .- 1;\n", "sigma = 1e-3;" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "w0 = zeros(d);" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sgd_logreg (generic function with 2 methods)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function sgd_logreg(w0::Array{T,1}, alpha::T, gamma::T, X::Array{T,2}, Y::Array{T,1}, sigma::T, niters::Int64, wopt::Array{T,1}) where {T<:Number}\n", " w = w0\n", " (N, d) = size(X)\n", " dist2_to_optimum = zeros(niters)\n", " for k = 1:niters\n", " i = rand(1:N)\n", " xi = X[i,:];\n", " yi = Y[i];\n", " w += -alpha * sigma * w + alpha * xi * yi / (one(alpha) .+ exp.(yi * dot(xi, w)));\n", " dist2_to_optimum[k] = sum((w - wopt).^2);\n", " end\n", " return (w, dist2_to_optimum);\n", "end\n", "\n", "function sgd_logreg(::Type{T}, w0, alpha, gamma, X, Y, sigma, niters, wopt) where {T<:Number}\n", " (w, dist2_to_optimum) = sgd_logreg(T.(w0), T(alpha), T(gamma), T.(X), T.(Y), T.(sigma), niters, T.(wopt))\n", " return (Float64.(w), Float64.(dist2_to_optimum));\n", "end" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "# find the true minimum\n", "function newton_logreg(w0, X, Y, sigma, niters)\n", " N = size(X, 1);\n", " d = size(X, 2);\n", " w = w0;\n", " for k = 1:niters\n", " g = -X' * (Y ./ (1 .+ exp.(Y .* (X * w)))) + N * sigma * w;\n", " H = X' * ((1 ./ ((1 .+ exp.(Y .* (X * w))) .* (1 .+ exp.(-Y .* (X * w))))) .* X) + N * sigma * I;\n", " w = w - H \\ g;\n", " # println(\"gradient norm: \$(norm(g))\")\n", " end\n", " return w\n", "end\n", "\n", "wopt = newton_logreg(wtrue, X, Y, sigma, 20);" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "# define low-precision types\n", "\n", "Float16Rand = SimFP{10,5,0,RoundingModeRandom};\n", "Float16Near = SimFP{10,5,0,RoundingModeNearest};" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "alpha = 0.1;\n", "\n", "Random.seed!(123456);\n", "(w, dto) = sgd_logreg(Float32, w0, alpha, sigma, X, Y, sigma, 100000, wopt);\n", "\n", "Random.seed!(123456);\n", "(w2, dto2) = sgd_logreg(Float16Rand, w0, alpha, sigma, X, Y, sigma, 100000, wopt);\n", "\n", "Random.seed!(123456);\n", "(w3, dto3) = sgd_logreg(Float16Near, w0, alpha, sigma, X, Y, sigma, 100000, wopt);" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGiCAYAAAA1LsZRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzs3XlcVPX+P/DXMAwDg4CKKIsokntiIqapWVpuZan9vmWZZmR5rdTU0szu1cxubmmpdTPTMs1cssWVNHMhlyQ3XFFcQHAhBHHYB2bm/P4YODAyA4POmXPQ1/PxmEfnnDlzzpsJmdd8zufzOSpBEAQQERERycRN7gKIiIjo3sYwQkRERLJiGCEiIiJZMYwQERGRrBhGiIiISFYMI0RERCQrhhEiIiKSFcMIERERyYphhIiIiGTFMEJERESyqnYY+fPPP/H0008jODgYKpUK69evt3peEARMmzYNwcHB8PLyQvfu3XHq1CmnFUxERER3l2qHkby8PDzwwAP44osvbD4/Z84cfPrpp/jiiy9w8OBBBAYGolevXsjJybnjYomIiOjuo7qTG+WpVCr8+uuvGDhwIABLq0hwcDDGjRuHSZMmAQAMBgMaNGiA2bNnY+TIkc6pmoiIiO4a7s48WFJSEtLS0tC7d29xm1arxaOPPor9+/fbDCMGgwEGg0FcN5vNuHHjBvz9/aFSqZxZHhEREUlEEATk5OQgODgYbm7Vu/Di1DCSlpYGAGjQoIHV9gYNGuDSpUs2XzNz5kx8+OGHziyDiIiIZJKamoqGDRtW6zVODSOlbm3REATBbivH5MmT8fbbb4vrer0ejRo1QmpqKnx9faUoz+nMZgFd1nQGAEzIzMKzY87KXBEREZFrZWdnIzQ0FD4+PtV+rVPDSGBgIABLC0lQUJC4PT09vUJrSSmtVgutVlthu6+vb40JIwCg8XSDWaVCmEaoUXUTERE50+10sXDqPCNNmjRBYGAgtm/fLm4rKipCbGwsunTp4sxTKU5koaXfS7HMdRAREdU01W4Zyc3Nxfnz58X1pKQkxMfHo27dumjUqBHGjRuHGTNmoFmzZmjWrBlmzJgBnU6HF1980amFK40GlkFJxex0S0REVC3VDiOHDh1Cjx49xPXS/h4vv/wyvvvuO7z77rsoKCjAm2++iaysLHTq1Am///77bV1Dqkk0JQOkGUaIiIiqp9phpHv37qhsahKVSoVp06Zh2rRpd1JXjaMR2DJCRHdGEAQYjUaYTCa5SyGySaPRQK1WO/24koymuRft9NYBAOL8gjFI5lqIqOYpKirCtWvXkJ+fL3cpRHapVCo0bNgQtWrVcupxGUac7CzfUSKqJrPZjKSkJKjVagQHB8PDw4OTPpLiCIKA69ev4/Lly2jWrJlTW0j40ekkLfPq4Ix3Fh7L53gaIqqeoqIimM1mhIaGQqfTyV0OkV0BAQFITk5GcXGxU8OIU4f23sseMKUAADyLbshcCRHVVNWdQpvI1aRqseNvvpNcMFmmvi1myyoREVG1MIw4ibqWZfbZTK9QmSshIiKqWRhGnMRdrQEAmMAheUREgGUqiHHjxsldBtUADCNOkqMqAAD8rc6VuRIiIteJjo6GSqWq8Cg/U7cz2Qo4mZmZ6Nu3L4KDg6HVahEaGorRo0cjOztb3OeXX35Br169EBAQAF9fX3Tu3Bnbtm2TpEaqPoYRJzmuugAASHNnpxEiurf07dsX165ds3o0adLEZed3c3PDgAEDsHHjRiQmJuK7777DH3/8gddff13c588//0SvXr0QExODw4cPo0ePHnj66adx9OhRl9VJ9nFoLxGRwgiCgIJieS75emnU1R4xodVqxbu2VyYrKwtjx47Fpk2bYDAY8Oijj2LhwoVo1qwZAEsLx+jRo7Fnzx7cuHED9913H95//30MHjwYgKUVJjY2FrGxsViwYAEAy/3RwsLC8MYbb4jnady4Md5880188skn4rb58+db1TJjxgxs2LABmzZtQmRkZLV+XnI+hhEiIoUpKDah9VR5LiGcnt4HOg9pPhqio6Nx7tw5bNy4Eb6+vpg0aRKefPJJnD59GhqNBoWFhYiKisKkSZPg6+uLLVu24KWXXkJ4eDg6deqEBQsWIDExEW3atMH06dMBWOa9uNXVq1fxyy+/4NFHH7Vbi9lsRk5ODurWrSvJz0rVw8s0RER0RzZv3oxatWqJj+eee67CPqUhZOnSpejWrRseeOAB/PDDD7hy5QrWr18PAAgJCcGECRPQrl07hIeHY8yYMejTpw/WrVsHAPDz84OHhwd0Oh0CAwMRGBhoNfHW4MGDodPpEBISAl9fXyxdutRuzfPmzUNeXh4GDeINPJSALSNERArjpVHj9PQ+sp27unr06IFFixaJ697e3hX2SUhIgLu7Ozp16iRu8/f3R4sWLZCQkAAAMJlMmDVrFtauXYsrV67AYDDAYDDYPJ4tn332GT744AOcPXsW77//Pt5++218+eWXFfZbvXo1pk2bhg0bNqB+/frV/XFJAgwjREQKo1KpJLtUIgVvb280bdq00n3s3e1dEASxj8q8efPw2WefYf78+YiIiIC3tzfGjRuHoqIih+oobS1p2bIl/P390a1bN0yZMgVBQUHiPmvXrsWrr76KdevWoWfPng7+hCQ1XqaRgp1/dERE96rWrVvDaDQiLi5O3JaZmYnExES0atUKALBnzx4MGDAAQ4cOxQMPPIDw8HCcO3fO6jgeHh4wmaru3FsafgwGg7ht9erViI6OxqpVq9CvXz9n/FjkJAwjTvJcgzfLVsyc+IyIqLxmzZphwIABGDFiBPbu3Ytjx45h6NChCAkJwYABAwAATZs2xfbt27F//34kJCRg5MiRSEtLszpOWFgY4uLikJycjIyMDJjNZsTExGDZsmU4efIkkpOTERMTgzfeeANdu3ZFWFgYAEsQGTZsGObNm4eHHnoIaWlpSEtLg16vd/VbQTYwjDhJHc9yw9pyrspXCBGRQi1btgxRUVF46qmn0LlzZwiCgJiYGGg0lhmsp0yZgvbt26NPnz7o3r07AgMDMXDgQKtjTJgwAWq1Gq1bt0ZAQABSUlLg5eWFJUuW4OGHH0arVq0wbtw4PPXUU9i8ebP4usWLF8NoNGLUqFEICgoSH2PHjnXpe0C2qQR7F/Jkkp2dDT8/P+j1evj6+spdjsP+vX0+Nl79BgBwotFgoMf7MldERDVFYWEhkpKS0KRJE3h6espdDpFdlf2u3snnN1tGnERvulG2UshmPyIiIkcxjDhJHU//spWrnF6YiIjIUQwjTuLr4Ve24lP1tMhERERkwTDiJFq1RlwuLrhRyZ5ERERUHsOIk7SqGyEu50dwemEiIiJHMYw4SahPiLi87p/9MlZCRERUszCMOInOQysuH7h2QMZKiIiIahaGESfx1JTdR+Lheg/IWAkREVHNwjDiJNpyt7FWF/lVsicRERGVxzDiJFpN2VuZZMiUsRIiImXo3r07xo0bJ3cZd+ybb75B7969ZTv/tGnT0K5dO8nPM2HCBLz11luSn8cWhhEn8VC7wcdoaR0JMdeSuRoiIulFR0dDpVJVeJw/f16yc9oLOGPHjkVUVBS0Wq3dD25BEDB37lw0b94cWq0WoaGhmDFjRqXnMxgMmDp1KqZMmeKU+pXs3XffxbJly5CUlOTyczOMOImbmwq+xZZ+I1qNWeZqiIhco2/fvrh27ZrVo0mTJi6vQxAEDB8+HM8//7zdfcaOHYulS5di7ty5OHPmDDZt2oSOHTtWetyff/4ZtWrVQrdu3ezuU1RUdNt1K0n9+vXRu3dvfPXVVy4/N8OIEwXBck+aeqmbq9iTiKgSggAU5cnzqOa9U7VaLQIDA60e6nJ96MrLysrCsGHDUKdOHeh0OjzxxBM4d+6c+HxmZiYGDx6Mhg0bQqfTISIiAqtXrxafj46ORmxsLBYsWCC2wiQnJwMAFi5ciFGjRiE8PNzmuRMSErBo0SJs2LAB/fv3R5MmTdCuXTv07Nmz0p9vzZo16N+/v9W26OhoDBw4EDNnzkRwcDCaN28OAFi5ciU6dOgAHx8fBAYG4sUXX0R6err4ut27d0OlUmHHjh3o0KEDdDodunTpgrNnz1odf9asWWjQoAF8fHzw6quvorCw0Op5s9mM6dOno2HDhmJL0NatW8Xnk5OToVKp8OOPP6Jbt27w8vLCgw8+iMTERBw8eBAdOnRArVq10LdvX1y/ft3q2P3797d6z13FvepdyFGHvCx3MPzWzxd9Za6FiGqw4nxgRrA8537/KuDhLcmho6Ojce7cOWzcuBG+vr6YNGkSnnzySZw+fRoajQaFhYWIiorCpEmT4Ovriy1btuCll15CeHg4OnXqhAULFiAxMRFt2rTB9OnTAQABAQEOnXvTpk0IDw/H5s2b0bdvXwiCgJ49e2LOnDmoW7eu3dft2bMHQ4YMqbB9x44d8PX1xfbt2yGUBLiioiJ89NFHaNGiBdLT0zF+/HhER0cjJibG6rX//ve/MW/ePAQEBOD111/H8OHDsW/fPgDAjz/+iA8++AD/+9//0K1bN3z//fdYuHChVchasGAB5s2bh8WLFyMyMhLffvst+vfvj1OnTqFZs2bifh988AHmz5+PRo0aYfjw4Rg8eDB8fX2xYMEC6HQ6DBo0CFOnTsWiRYvE13Ts2BGpqam4dOkSGjdu7NB76wwMIxJI0HrIXQIRkUts3rwZtWqV9ZN74oknsG7dugr7lYaQffv2oUuXLgCAH374AaGhoVi/fj2ee+45hISEYMKECeJrxowZg61bt2LdunXo1KkT/Pz84OHhAZ1Oh8DA6t0D7OLFi7h06RLWrVuHFStWwGQyYfz48Xj22Wexc+dOm6+5efMmbt68ieDgisHQ29sbS5cuhYdH2d/74cOHi8vh4eFYuHAhOnbsiNzcXKv36OOPP8ajjz4KAHjvvffQr18/FBYWwtPTE/Pnz8fw4cPx2muvAQD++9//4o8//rBqHZk7dy4mTZqEF154AQAwe/Zs7Nq1C/Pnz8f//vc/cb8JEyagT58+ACyXqAYPHowdO3aga9euAIBXX30V3333ndXPFRJimcAzOTmZYYSI6J6m0VlaKOQ6dzX06NHD6pu1t7ftVpWEhAS4u7ujU6dO4jZ/f3+0aNECCQkJAACTyYRZs2Zh7dq1uHLlCgwGAwwGg91jVofZbIbBYMCKFSvEyyrffPMNoqKicPbsWbRo0aLCawoKCgAAnp6eFZ6LiIiwCiIAcPToUUybNg3x8fG4ceMGzGZL/8GUlBS0bt1a3K9t27biclBQEAAgPT0djRo1QkJCAl5//XWr43bu3Bm7du0CAGRnZ+Pq1atioCjVtWtXHDt2zGpb+fM0aNBArLv8tvKXkQDAy8sLAJCfn1/hZ5YSwwgRkdKoVJJdKnE2b29vNG3atMr9BDt9UQRBgEqlAgDMmzcPn332GebPn4+IiAh4e3tj3LhxTukgGhQUBHd3dzGIAECrVq0AWMKCrTDi7+8PlUqFrKysCs/dGpDy8vLQu3dv9O7dGytXrkRAQABSUlLQp0+fCvVrNGU3Vi392UuDi6NKX1eq/PtY2Xlu3XbreW/csNzo1dHLX87CDqxERCS51q1bw2g0Ii4uTtyWmZmJxMREMRTs2bMHAwYMwNChQ/HAAw8gPDzcqoMrAHh4eMBkMlX7/F27doXRaMSFCxfEbYmJiQBg93KEh4cHWrdujdOnT1d5/DNnziAjIwOzZs1Ct27d0LJlywqtDo5o1aoVDhywvqVI+XVfX18EBwdj7969Vvvs379ffB/vxMmTJ6HRaHD//fff8bGqg2HEicKKiuUugYhIkZo1a4YBAwZgxIgR2Lt3L44dO4ahQ4ciJCQEAwYMAAA0bdoU27dvx/79+5GQkICRI0ciLS3N6jhhYWGIi4tDcnIyMjIyxG/258+fR3x8PNLS0lBQUID4+HjEx8eLrRI9e/ZE+/btMXz4cBw9ehSHDx/GyJEj0atXL6vWklv16dOnwge/LY0aNYKHhwc+//xzXLx4ERs3bsRHH31U7fdp7Nix+Pbbb/Htt98iMTERH3zwAU6dOmW1z8SJEzF79mysXbsWZ8+exXvvvYf4+HiMHTu22ue71Z49e8QROK7EMOJE3rmN5C6BiEixli1bhqioKDz11FPo3LkzBEFATEyMeOlgypQpaN++Pfr06YPu3bsjMDAQAwcOtDrGhAkToFar0bp1a/FSCAC89tpriIyMxOLFi5GYmIjIyEhERkbi6lVL3xs3Nzds2rQJ9erVwyOPPIJ+/fqhVatWWLNmTaU1jxgxAjExMdDr9ZXuFxAQgO+++w7r1q1D69atMWvWLMydO7fa79Hzzz+PqVOnYtKkSYiKisKlS5fwxhtvWO3z1ltv4Z133sE777yDiIgIbN26FRs3brQaSXO7Vq9ejREjRtzxcapLJdi7kCeT7Oxs+Pn5Qa/Xw9fXV+5yqmXsB29gZ7glQZ94+YTM1RBRTVFYWIikpCQ0adLEZmdJktegQYMQGRmJyZMny12KpLZs2YKJEyfi+PHjcHe33aW0st/VO/n8ZsuIE+m0lv8xboqKd0REdCc++eQTq6G5d6u8vDwsW7bMbhCREkfTONGgDk2w+RpgVtnu2UxERDVP48aNMWbMGLnLkNygQYNkOzdbRpyojq5sqJfRbJSxEiIiopqDYcSJ1BqtuGwUGEaIiIgcwTDiRJ7FBeIyW0aIiIgcwzDiRD6nVonLxSbOOUJEROQIhhEnMrcYCFXp3RtNbBkhIiJyBMOIE7lnJ4vDkwxFrr3JEBERUU3FMOJEbtlX4F7SMpJXyDBCRETkCIYRJ3J7ej4K3CxvaeE/x6rYm4jo7ta9e3eMGzdO7jLu2DfffIPevXvLXYakHnzwQfzyyy+ynZ9hxIncfIPE5V/O/yhjJURE0ouOjoZKparwOH/+vGTntBdwxo4di6ioKGi1WrRr187mawVBwNy5c9G8eXNotVqEhoZixowZlZ7PYDBg6tSpmDJlilPql9t3332H2rVrV9g+ZcoUvPfee+KNB12NYcSZys24asi7LmMhRESu0bdvX1y7ds3q0aRJE5fXIQgChg8fjueff97uPmPHjsXSpUsxd+5cnDlzBps2bULHjh0rPe7PP/+MWrVqoVu3bs4uudpK70AshX79+kGv12Pbtm2SnaMyDCMSaVTgJ3cJRFRDCYKA/OJ8WR7VvXeqVqtFYGCg1UOtVtvcNysrC8OGDUOdOnWg0+nwxBNP4Ny5c+LzmZmZGDx4MBo2bAidToeIiAisXr1afD46OhqxsbFYsGCB2AqTnJwMAFi4cCFGjRqF8PBwm+dOSEjAokWLsGHDBvTv3x9NmjRBu3bt0LNnz0p/vjVr1qB///5W26KjozFw4EDMnTsXQUFB8Pf3x6hRo1BcXDalQ1FREd59912EhITA29sbnTp1wu7dux3+WQFLK9Do0aPx9ttvo169eujVqxcAQK/X41//+hfq168PX19fPPbYYzh2rKxrwLFjx9CjRw/4+PjA19cXUVFROHToEHbv3o1XXnkFer1efP+mTZsGAFCr1XjyyScr1OAqvDeNRL7WpeDuv5MBEUmhwFiATqs6yXLuuBfjoNPoJDl2dHQ0zp07h40bN8LX1xeTJk3Ck08+idOnT0Oj0aCwsBBRUVGYNGkSfH19sWXLFrz00ksIDw9Hp06dsGDBAiQmJqJNmzaYPn06ACAgIMChc2/atAnh4eHYvHkz+vbtC0EQ0LNnT8yZMwd169a1+7o9e/ZgyJAhFbbv2rULQUFB2LVrF86fP4/nn38e7dq1w4gRIwAAr7zyCpKTk7FmzRoEBwfj119/Rd++fXHixAk0a9asyp+11PLly/HGG29g3759EAQBgiCgX79+qFu3LmJiYuDn54fFixfj8ccfR2JiIurWrYshQ4YgMjISixYtglqtRnx8PDQaDbp06YL58+dj6tSpOHv2LABY3QCwY8eOmDNnjkPvp7MxjBAR0W3bvHmz1QfaE088gXXr1lXYrzSE7Nu3D126dAEA/PDDDwgNDcX69evx3HPPISQkBBMmTBBfM2bMGGzduhXr1q1Dp06d4OfnBw8PD+h0OgQGBlarzosXL+LSpUtYt24dVqxYAZPJhPHjx+PZZ5/Fzp07bb7m5s2buHnzJoKDgys8V6dOHXzxxRdQq9Vo2bIl+vXrhx07dmDEiBG4cOECVq9ejcuXL4uvnTBhArZu3Yply5ZhxowZVf6spZo2bWoVEHbu3IkTJ04gPT0dWq3lFiRz587F+vXr8dNPP+Ff//oXUlJSMHHiRLRs2RIA0KxZM/H1fn5+UKlUNt+/kJAQpKSkwGw2w83NtRdOGEaIiBTGy90LcS/GyXbu6ujRowcWLVokrnt7e9vcLyEhAe7u7lYftP7+/mjRogUSEhIAACaTCbNmzcLatWtx5coVGAwGGAwGu8esDrPZDIPBgBUrVqB58+YALKNkoqKicPbsWbRo0aLCawoKLLf48PT0rPDc/fffb3U5KigoCCdOnAAAHDlyBIIgiOcpZTAY4O/vX62ftUOHDlbrhw8fRm5urnic8rVeuHABAPD222/jtddew/fff4+ePXviueeew3333Vfle+Tl5SW+T15e1fs9uFMMI0RECqNSqSS7VOJs3t7eaNq0aZX72euLIggCVCWd/+fNm4fPPvsM8+fPR0REBLy9vTFu3DindNwMCgqCu7u7VUBo1aoVACAlJcVmGPH394dKpUJWVlaF5zQajdW6SqUSR6KYzWao1WocPny4Qv+Z0lYkR3/WW8OJ2WxGUFCQVf+TUqWjZKZNm4YXX3wRW7ZswW+//YYPPvgAa9aswTPPPGPzvSl148YN6HQ6lwcRgGGEiIhcoHXr1jAajYiLixMv02RmZiIxMVEMBXv27MGAAQMwdOhQAJYP3nPnzonPA4CHhwdMJlO1z9+1a1cYjUZcuHBBbCVITEwEADRu3Njmazw8PNC6dWucPn26WvOMREZGwmQyIT093e4oHEd+Vlvat2+PtLQ0uLu7IywszO5+zZs3R/PmzTF+/HgMHjwYy5YtwzPPPFPp+3fy5Em0b9/esR/SyTiaxsmey7TkuwB9qMyVEBEpR7NmzTBgwACMGDECe/fuxbFjxzB06FCEhIRgwIABACz9I7Zv3479+/cjISEBI0eORFpamtVxwsLCEBcXh+TkZGRkZIitEefPn0d8fDzS0tJQUFCA+Ph4xMfHiy0NPXv2RPv27TF8+HAcPXoUhw8fxsiRI9GrV68Kl1PK69OnD/bu3Vutn7V58+YYMmQIhg0bhl9++QVJSUk4ePAgZs+ejZiYGId/Vlt69uyJzp07Y+DAgdi2bRuSk5Oxf/9+/Oc//8GhQ4dQUFCA0aNHY/fu3bh06RL27duHgwcPiiEnLCwMubm52LFjBzIyMpCfXzZb+J49e2Sb3I1hxMnCYZlfpIU6VeZKiIiUZdmyZYiKisJTTz2Fzp07QxAExMTEiJc8pkyZgvbt26NPnz7o3r07AgMDMXDgQKtjTJgwAWq1Gq1bt0ZAQABSUlIAAK+99hoiIyOxePFiJCYmIjIyEpGRkbh69SoAwM3NDZs2bUK9evXwyCOPoF+/fmjVqhXWrFlTac0jRoxATEwM9Hp9tX/WYcOG4Z133kGLFi3Qv39/xMXFITQ01OGf1RaVSoWYmBg88sgjGD58OJo3b44XXngBycnJaNCgAdRqNTIzMzFs2DA0b94cgwYNwhNPPIEPP/wQANClSxe8/vrreP755xEQECB2jr1y5Qr279+PV155pVo/p7OohOoOKpdYdnY2/Pz8oNfr4evrK3c51bZmXgg+rlcXvfLy8embF+Quh4hqgMLCQiQlJaFJkyY2O0uSvAYNGoTIyEhMnjxZ7lIkM3HiROj1enz99deV7lfZ7+qdfH6zZcTJbpR0VtruXTM6nxERUeU++eQTq+HLd6P69evjo48+ku387MDqZIvqcOZVIqK7SePGjTFmzN09jeXEiRNlPT9bRpwspNgodwlEREQ1itPDiNFoxH/+8x80adIEXl5eCA8Px/Tp02W7E6CruUFRXXCIiIgUz+mXaWbPno2vvvoKy5cvx/33349Dhw7hlVdegZ+fH8aOHevs0ynOkFwdZtWx3Cyp/GQ+RERVUdh4AqIKpPoddXrLyF9//YUBAwagX79+CAsLw7PPPovevXvj0KFDzj6VIvXJThKXMwoyZKyEiGqK0qGt5ed8IFKi0nlb7N2Z+XY5vWXk4YcfxldffYXExEQ0b94cx44dw969ezF//nyb+5fOx18qOzvb2SW5VrmGkJsF+QjgoBoiqoJarUbt2rWRnp4OANDpdGxVJcUxm824fv06dDod3N2dGx+cHkYmTZoEvV6Pli1bQq1Ww2Qy4eOPP8bgwYNt7j9z5kxxMpa7QT1TWd+Y3EI2uRKRY0rvoloaSIiUyM3NDY0aNXJ6WHZ6GFm7di1WrlyJVatW4f7770d8fDzGjRuH4OBgvPzyyxX2nzx5Mt5++21xPTs7W5yhrqbSms0wuLlBreLIGiJyjEqlQlBQEOrXr4/i4mK5yyGyycPDA25uzh+I6/QwMnHiRLz33nt44YUXAAARERG4dOkSZs6caTOMaLVaaLVaZ5chnyfmQH16IQCgyJAnczFEVNOo1WqnX48nUjqnx5v8/PwKqUmtVt8zQ3vRfhjUJVdn1Kl75K2FiIioBnB6GHn66afx8ccfY8uWLUhOTsavv/6KTz/9FM8884yzT6VMag+oS+Ya0Z6u/AZMREREJMFlms8//xxTpkzBm2++ifT0dAQHB2PkyJGYOnWqs0+lTG5qsWUEef/IWgoREVFN4PQw4uPjg/nz59sdynsvyHS3XO/V6wJkroSIiEj5eG8aCf3qliN3CURERIrHMCKhRm5sGSEiIqoKw4iE9qtryV0CERGR4jGMSChY5yV3CURERIrHMCKB1iX32umR+qfMlRARESkfw4gE6pTcn8bIG10RERFViWFEAhrBMtEI70xDRERUNYYRCZRO3sKWESIioqoxjEjgD28dAGB7yX+JiIjIPoYRCcV5ecpdAhERkeIxjEigXaFlNM1P7EfuAAAgAElEQVRgPWdgJSIiqgrDiAQ02gcAAIKmgcyVEBERKR/DiARSVekAgHhNkcyVEBERKR/DiATScAMAcEbDwb1ERERVYRiRgJfAt5WIiMhR/NSUQAf3VgCApkW8TENERFQVhhEJ1PUIBQA0MHnIXAkREZHyMYxIwF1tCSFGmGWuhIiISPkYRiSQlGEJISYUy1wJERGR8jGMSKBZbW8AQBFvTUNERFQlhhEJmHOzAQD5birAzEs1RERElWEYkYBGWxsAUKhSASaOqCEiIqoMw4gEcnxaAwAuazRAfobM1RARESkbw4gEHmiqEZdN+jQZKyEiIlI+hhEJRNRvLi5fMwsyVkJERKR8DCMSaOEfLi4XFBXIWAkREZHyMYxIQO2mFpeT9SkyVkJERKR8DCMSKzJwNA0REVFlGEYkdibpJ7lLICIiUjSGEYndp/aXuwQiIiJFYxiRSGRhIQBAd3m7zJUQEREpG8OIRDxKRvRedXeXtxAiIiKFYxiRyD9qy4gancB5RoiIiCrDMCKRAjfLLXuPaT1kroSIiEjZGEYk8k/J5ZmNPrVkroSIiEjZGEYk0socAAB4pLiOzJUQEREpG8OIRGqrdAAAo2CSuRIiIiJlYxiRyF+qSwCA/R7ZMldCRESkbAwjREREJCuGESIiIpIVw4hE+ufkyl0CERFRjcAwIpFQv84AgIfzC2SuhIiISNkYRiTiobLMwJpeMhMrERER2cYwIpHz3r4AgETOwEpERFQphhGJJBallK1kX5WvECIiIoVjGJFIK6+wshVTsWx1EBERKR3DiEQerR1ZtpL7j3yFEBERKRzDiERUQe0BAL4mE6Dzl7kaIiIi5WIYkYhOW3JvGpUKMPP+NERERPYwjEhEp7GMoilWqQCzUeZqiIiIlIthRCLeGi0ASxgxm4pkroaIiEi5GEYkotWUTXaWXcip4YmIiOxhGJGIv5efuJxjyJOxEiIiImVjGJGIl6Zs5tXCokIZKyEiIlI2hhGJqFQqeJgFAEC+gTfLIyIisodhREJawRJGDAWZMldCRESkXAwjEtLAEkbcLu+XuRIiIiLlYhiRkKakZeRGvbYyV0JERKRcDCNSEiydWAtMnIGViIjIHoYRCblDBQAoNHI0DRERkT0MIxJyFyxhxGAyyFwJERGRcjGMSKi0ZaTIyDBCRERkD8OIhNxL3t5i3puGiIjILknCyJUrVzB06FD4+/tDp9OhXbt2OHz4sBSnUrTSeUYEww2ZKyEiIlIud2cfMCsrC127dkWPHj3w22+/oX79+rhw4QJq167t7FMpXl3jTUCrQ/2MP+UuhYiISLGcHkZmz56N0NBQLFu2TNwWFhbm7NPUCJqS/xaV9B0hIiKiipx+mWbjxo3o0KEDnnvuOdSvXx+RkZFYsmSJ3f0NBgOys7OtHncLj5LLNMUqhhEiIiJ7nB5GLl68iEWLFqFZs2bYtm0bXn/9dbz11ltYsWKFzf1nzpwJPz8/8REaGurskmTDMEJERFQ1p4cRs9mM9u3bY8aMGYiMjMTIkSMxYsQILFq0yOb+kydPhl6vFx+pqanOLkk2pWGkiGGEiIjILqeHkaCgILRu3dpqW6tWrZCSkmJzf61WC19fX6vH3SK17qMAgCIVgNx0eYshIiJSKKeHka5du+Ls2bNW2xITE9G4cWNnn0rxTFp/ACUtIzdthzEiIqJ7ndPDyPjx43HgwAHMmDED58+fx6pVq/D1119j1KhRzj6V4qk1llaeYpUKiP9B5mqIiIiUyelh5MEHH8Svv/6K1atXo02bNvjoo48wf/58DBkyxNmnUjyNRgegJIw06iJzNURERMrk9HlGAOCpp57CU089JcWhaxQPtQcAoBgAdHVkrYWIiEipeG8aCWlLwkiumxvAm+URERHZxDAioTPZfwEAdnrrgOICmashIiJSJoYRCfl6+JWtMIwQERHZxDAioXb+5TqtMowQERHZxDAioZS8M2UrRoYRIiIiWxhGJNTWvxMAQGs2A9unylwNERGRMjGMSKiuVy0AgMGt5G02GWWshoiISJkYRiRUp1bZDfJuuLkBh5fJWA0REZEyMYxI6FTmKesNMRPkKYSIiEjBGEYk1KdxH3HZLGMdRERESibJdPBkEV47XFwuclMBvvfenYuJiIiqwpYRF7np5gbcvCR3GURERIrDMOIiC+rUlrsEIiIiRWIYcZEstVruEoiIiBSJYcRFBuXkWBbSE+QthIiISGEYRlxkUe2Sm+Z9+ZC8hRARESkMw4iLpLtz4BIREZEtDCNEREQkK4YRIiIikhXDCBEREcmKYYSIiIhkxTBCREREsmIYISIiIlkxjEhMZfaUuwQiIiJFYxiRmAa+cpdARESkaAwjEnMTbIQRQXB9IURERArFMCKxFvWCKm40Frq+ECIiIoViGJFYYK2Aihtvprq+ECIiIoViGJFYULkwIl6c0afIUgsREZESMYxIrI5XWZ+RdLW6ZGMTmaohIiJSHoYRiYX5NhSXjaqShStH5CmGiIhIgRhGJOav8xeX81Ulb3fuPzJVQ0REpDwMIxK7z+8+cbm4tGWkQWt5iiEiIlIghhGJ1fKoBQiWtzm/TgvLRqNBxoqIiIiUhWHEBdTmugAAVU7JkN68DBmrISIiUhaGERcoMlreZrO5ZLKzP+fIWA0REZGyMIy4gEqdCwDIcit5u29ynhEiIqJSDCMu4OaeDwB4p0HJBGgdXpWxGiIiImVhGJGDVx25KyAiIlIMhhE58EZ5REREIoYROZiK5K6AiIhIMRhG5MB5RoiIiEQMI3I4GyN3BURERIrBMCKHvOtyV0BERKQYDCMuZpS7ACIiIoVhGHGBjoEdxWWDSlXJnkRERPcehhEXWNBjgbhcWBpGTGwjISIiAhhGXKKWRy1xOc1dbVkouCFTNURERMrCMOJiE+vXsywkbpW3ECIiIoVgGHGxVI3GsuDuKW8hRERECsEwIpe64XJXQEREpAgMI3LJSpa7AiIiIkVgGHERX01t6w2nfpWnECIiIoVhGHGRR0N6WW9o2U+eQoiIiBSGYcRF+oU/bb3h0j55CiEiIlIYhhEXySi8Ji7fdHMDGnWRsRoiIiLlYBhxEZ3GQ1yeXq8uYOYMrERERADDiMu0qNtcXN7r5cnRNERERCUYRlyknlc9cbnAzQ3Y+6mM1RARESkHw4iLeLl7WW8od78aIiKiexnDiIuoSu/WW6ooV55CiIiIFIZhxIV83C2XatwEQeZKiIiIlINhxIU6+vcHADyVmwe0GyJzNURERMogeRiZOXMmVCoVxo0bJ/WpFE+nsdypt1Cl4tBeIiKiEpKGkYMHD+Lrr79G27ZtpTxNjeGtsXRiLXRzA3LSZK6GiIhIGSQLI7m5uRgyZAiWLFmCOnXq2N3PYDAgOzvb6nG3quWhA1DSMpIUK3M1REREyiBZGBk1ahT69euHnj17VrrfzJkz4efnJz5CQ0OlKkl2PuXDCBEREQGQKIysWbMGR44cwcyZM6vcd/LkydDr9eIjNTVVipIUwUdrCSMFbgwjREREpdydfcDU1FSMHTsWv//+Ozw9PavcX6vVQqvVOrsMRfLRWvqMGEpbRoxFgLtHJa8gIiK6+zm9ZeTw4cNIT09HVFQU3N3d4e7ujtjYWCxcuBDu7u4wmUzOPmWN4au95TKN/u5tBSIiInKU01tGHn/8cZw4ccJq2yuvvIKWLVti0qRJUKvVzj5ljVHb0xsAUKAqyYAqTvNCRETk9DDi4+ODNm3aWG3z9vaGv79/he33Gr+SMJKjLgkhxQUyVkNERKQM/GruQqWTngFAmlrNMEJERAQJWkZs2b17tytOo3ie7mVhZJWvD95OOwY0jJKxIiIiIvmxZcSFtOqyUUPbvHXA5vEyVkNERKQMDCMu5Fauw6qJU40QEREBYBhxOY2qFgDg+excmSshIiJSBoYRFzPntgQAaARB5kqIiIiUgWHExQqKLPOsFLipgGZ9ZK6GiIhIfgwjLtag/lUAwJZa3oCxUOZqiIiI5Mcw4mJZxZYp4C9pNIDRIHM1RERE8mMYcTFvde2yFSMnPSMiImIYcbGGmkcBAHVNJuDaMZmrISIikh/DiIs18mkEAGhjKLJs4JTwRER0j2MYcbGGtX0BAAaVZdaz/NybcpZDREQkO4YRF0vTFwMA4rw8kaRxxw19tswVERERyYthxMVu5JrF5f4Ng/HBL0dlrIaIiEh+DCMu5qezfsszrqfJVAkREZEyMIy4mFmbaLXe23ObTJUQEREpA8OIizWu42+1vjT0H5kqISIiUgaGERfr1rCb1bpRXSxTJURERMrAMOJiUQ2i5C6BiIhIURhGZHBwyEG5SyAiIlIMhhEZeLp7yl0CERGRYjCMyCTYTSd3CURERIrAMCKTSfp8cVkQBBkrISIikhfDiExikSsuG4zmSvYkIiK6uzGMyKSuySQuG4oZRoiI6N7FMCKT5kVl84sUFJsq2ZOIiOjuxjAiky4FBeJyrsEgYyVERETyYhiRiZdXPXF588lLMlZCREQkL4YRmWhqN4JbySiaKzf1MldDREQkH4YRmajUWniWhJG2jTjnCBER3bsYRuTy0BtiGPnpSJLMxRAREcmHYUQuIVHwMlvCyNmr12QuhoiISD4MI3LR1cUVjTsAoJM2TuZiiIiI5MMwIpdyN8u7GHBSxkKIiIjkxTAiF5VKXLyp4aRnRER072IYUYBu+QVV70RERHSXYhiR0cAcy83yznhoYDTx/jRERHRvYhiR0d+eln4j193dcT2XU8ITEdG9iWFERldLRtMAwI8HL8tYCRERkXwYRhSi2GyUuwQiIiJZMIzIyA1lI2o8vdJkrISIiEg+DCMy2tR6tLhc/Pc4GSshIiKSD8OIjBrVChaX0z1zZKyEiIhIPgwjchLKhvM+WFCIi9dzZSyGiIhIHgwjcvLwFhe/qOOHxbEXZSyGiIhIHgwjcmrcRVy87u6O9YcuyFgMERGRPBhG5KTxslrVud3El7vPy1QMERGRPBhGFOSVBh9gztazcpdBRETkUgwjCnJcq0Wo6h+5yyAiInIphhEFifPyRA+3eBy4mCl3KURERC7DMCKz8VHjrdana5bjha8PyFQNERGR6zGMyOyV+1+xWi9QWaaI33c+Q45yiIiIXI5hRGYqlQqvRbwmrncMC0Wy54sYsjQORpO5klcSERHdHRhGFGDpiaUVtj3kdhrztifKUA0REZFrMYwoQP/7+lutZ7upUB9ZWLSbk6AREdHdj2FEAf7b9b9W6xlqNS4KQTJVQ0RE5FoMIwqgUqkwos0IcX1Aw2B8oflcxoqIiIhch2FEId6KestqPczNMvmZwWiSoxwiIiKXYRhRuGKTIHcJREREkmIYUaj1tbyhhgnFRg7vJSKiuxvDiIIEeZd1Wp0S4I/zni+hoJiXaYiI6O7GMKIg1/KuWa3/5OON4PmBMlVDRETkGgwjClLfq77V+vR6/pYF/WUZqiEiInINhhEF+eTRT2w/kbjVtYUQERG5kNPDyMyZM/Hggw/Cx8cH9evXx8CBA3H27Flnn+au1L5Be9tPFOW5thAiIiIXcnoYiY2NxahRo3DgwAFs374dRqMRvXv3Rl4eP1BvhxkAtk+FcH4HAODvpBv4ZNsZCAKH/BIR0d1BJUj8qXb9+nXUr18fsbGxeOSRRyo8bzAYYDAYxPXs7GyEhoZCr9fD19dXytIUKbcoF51XdxbXjyalwB1AsrkBGn94Fk0mxwAA/v1kK4x4JFymKomIiKxlZ2fDz8/vtj6/Je8zotfrAQB169a1+fzMmTPh5+cnPkJDQ6UuSdFqedSyWs9zs/wvCnP7B/9kl4W2j2MSXFoXERGRVCQNI4Ig4O2338bDDz+MNm3a2Nxn8uTJ0Ov14iM1NVXKkmqEqAZR4nKhSiUu7zl3XY5yiIiIJOUu5cFHjx6N48ePY+/evXb30Wq10Gq1UpZR43z5+JfotKoTAOswMvGn43KVREREJBnJWkbGjBmDjRs3YteuXWjYsKFUp7kr6TQ6uKssOXGWfx2r57waLodPq/dQ0rWVCP/e+29ELI9AgbFA7lKIiG6L08OIIAgYPXo0fvnlF+zcuRNNmjRx9inuCUbBCADYq/Oy/Nd0PwDA3cfSV0RbP0aewkhxNl7YCADo+ENHmSshIro9Tr9MM2rUKKxatQobNmyAj48P0tLSAAB+fn7w8vJy9unuCRFNGgHIARLKWkM8/O1f+iIiIqpJnN4ysmjRIuj1enTv3h1BQUHiY+3atc4+1T3Hp9X7cpdACrPvyj6r9U8PfSpTJUREt0+SyzS2HtHR0c4+1T3vz0SOrrnXvf7H61bry04tk6kSIqLbx3vTKNRfg/+qcp+Xl/3tgkqIiIikxTCiUG6qqv/XcEZ4IiK6GzCMKJROo3Nov2t6Due0K/MCEPc1YDRUvW8N1axOM7lLIFIks2DGjLgZ+DnxZ7lLIQcwjNRoJnSeuVPuIpTr8/bAbxOB/Z/LXYlkmvo1lbsEK8WmYiw5vgRzDs5BfnG+3OWQApgFM4xmo8vPuzVpK1afWY1pf01z+bmp+hhGajB332MAwDv4VuXSfrkrkEyxubjCtuc3Py9DJRbrEtdh4dGF+P709+IswnRveynmJfT7pR+KTRV/V6W08OhCcZl/I5WPYUTBYp6pfGIzr5AfAQAXrufin+xCV5RUM5WbUv9uUxpGzMW1xW2nM0/LVY6s564p8ovzsS5xHa7n3xuj4Y5nHMfVvKs4d/OcS897JfeKuJxZmOnSc1P1MYwoWH3v+g7t1/PTP9Fpxg5xff3RK9h6Mg0nr+hxLPUmzqfnYuvJNFzPuXv7TlTqLu4zEns5FgBgzG1htb3Q6PpwKggCjl0/5vLz1jTTD0zH9L+m47F1j8ldimRSs1MRsTwCS08sFbcd+eeIbPXIdcnw72t/I2J5BGIucsbsqkh6ozy6M1q1FiufXImhMUMd2t9sFnDqajbGrY23u0/yrH7OKq9SRrMR8w7Nw0NBD+HR0Eddck4rlw+XLSfvcf35nSSrMAtGsxEBuoBK91N7Wd/t+sEfHgQArHpyFSICIiSrr7y2K9q65Dw12c3Cm9hycYvcZUjuyV+fBAAsOLJA3HYk/QiGtnbsb5mzFZrkaTl+9fdXAQCT9kzCk+FPuvbkpmJArXHtOe8AW0YU7oGABxzeN8dgxMHkGxJW47iZcTOxMmElRu8c7fqTZyUDS2/51lkDrxkLgoBH1j6Cx9Y9VuU3O7XnVZvbX4x5EZkF0jdRX7h5QfJz3A26re1mtZ6kT7pn+jN0D+0u27ld3V9Fdr+MBD6qB5xaL3clDmMYqQG+bP0vu8951PtDXM7INSC0rg5q7zNw016Fyj3bFeXZ9GPij7KdGwtsBDhTkevruEPlv82l5aVVeP5m4U1xufhme7vHOX79uHMLs+FU5imb24tq4PvuSv3X9xe/Pd/tPNw8nHo8k9nk8L4z4mY49dyOKN9nBQD0Br24vOLUCjzx8xPILpLob/TxNZb/rntZmuNLgGGkBggJ6yEud8svwJO5eeK6NuAPqL3Pws3rEh6fF4uRa2Kga/QdvMMXolazGfBp9R4AM9z9DskaTgBg6YmleHbjs/j25LeY/ffsKv8hzjk4BxHLI/B78u+On8RkZwhh9hXb2xXsov6iuGwSTJi2fxoilkfgov4ikvXJVt+yC9OeQWHa0zaPU3oHaCl9ftT28OmJsRMlP3dNdzDt4F3VOmIw2e6jdfpG9Ts3X829ite2vYbdqbvFbXsu78Hj6x5Hu+/bYdlJx25/cDzDfiAvNhdL8v6fyTxjtb7h/AYAQMTyCHxy6BNczr2Mrqu7Ov28FUzzszxuJEl/rjvAMFIDhAe0EZdnp2cg0DvI6nldo2XwDlsEAFBpsiq83qfV+/AK/gm1ms1AVp7031TNgrnCtpyiHCw4sgBns87is8OfYWXCSrwb+67dYxhMBnx/+nsAwDux7zh+8mOrbG/POG/3JTsu7cDA9QMdGt2QlpeGjIIMx+uxodhcbPUtqTyzYMbFmxdhFsz4z97/iNvzjfn4+Zxl8qYB6wfg6fW3BA9Bg+KszjaP+e2JbyVvobDVcgMAO1OdMw/OqcxTWHNmjc3frZog7lpcpX1FYpLung6OKdkpNrc7GhzK++TgJ4hLi8OYnWOQX5yPPy//iTd3vIn0/HQAwKeHbd8YsrLLmpdzLmPOwTm4lnsNXx//Gu2/by9Jf6cJsROs1j859Am2Jm11+nkccdLDA3uXPCTLuR3FDqw1xImXT1jSLYDN5puA2laONAOCutLjHL6UhZ6tG0hQYRlbzad/XPqjwrZ9V/dV2AYAsamxt9/XZOMY29tXPQdMsx0Axu0eB8DSZP7Xi/bvCZRfnI9eP/UCAGz9v60IqRVSrdIGrh8IM8xI0lu+oewatAv1vOpZ7fPF0S+w5MQSjG0/FudvlgUoe+HFmu3vFiczTyJqZZTld0gCqTmpVe90B478cwQvb7U0N2vVWjzT7BlJzyeF135/rdLnz9w4g37hrulcLrVNFzY57ViloQOA3XlrzIK5wu0znt30bIX9YlNj8Wjooxi9YzQu6C/gwLUDOJdVNtw4oyCjwr/HO2GrRXLinxVbCg0mA7RqrdPOa8vgkEAAQExOKkJ9QiU91+1iy0gNVN9opzOWygRNncpvsKd2k37OjcSsRKv1U5mnMHX/VJv7RiyPwLXca1bbXNnp9XxW2Qd+bnGu3f0Oph20+mPY9+e+1TpPbGosLugviEEEAN79s2LL0JITSwBYRiHU9awrbv/mxDfVOp8tgiDg/T3v48ezzu3P8/kRaWe4LQ0iALDt0rYa1zry3cnvqtzH091T+kJcZMOFDTa31/Os/pegyi6vlLLVCmIrIJf+Xbmgt3S2Lh9EAKDHjz0qvMYVBqwf4NwDFlRsHS91az8WJWEYqYFMsB0oVG6F0Pja7khY6nqu9Peyib9uPbT4hc0vVLp/7597V3lMqa6pP7PRsW/Zw7cNr7CtOpdrbAWsg2kHK33NjcKykVFH0u3P0VCUWdZ3xJgfZne/tivaYtPFTfjowEdOez8FQcBvyb9Zbcs581H1D3TlCHCz6haWfVf24eHVD+Pbk99W/xwymXd4XpX7XMlR7odEdZX/vS0vxDtckvNV5wPWXkfrUvYuMUmpqvoNJkP1/r1+08dqtfxXV1eMrLtdDCM1Sajlmt/EG7aTb63mH1d5iMm/SXfTqINpBxG5IhKz/p5128ew963390sOdmJt0KbqfUrEpsZW2FadIYDOmG30w78+FJdvNyCoNHpEdwkDABRcGoG8C+NhKmhY6Wucda+QYb8Nq7hRqObcBlcOA0t6APMd+3+XU5yDzw5/hle3vYrlp5ZX71wu5mhfnU0XnXdpQ6lyDNWbeOxyzmWH9rN1Scaeqr4Y9fu1HyKWOzYvT1pems1/s4Ig4PF1jztcU2UyCjLw0KqHMH73+Gq86KzV6m6dl7hcz6seCo2FiFgegTkH5zilRmdhGKlJojcDAB4sNGBx09ubPEjlJs14e71Bj+Hbht/2yI09l/dAEAS7oWNC7AScyqj8Ww0A4PqZqvcpYau14lretQrbbN3/BXB8Rkl7rweAnxJ/EvvY/Jb0m939KlOU+TCKTaUhTg1zUQPkJ1d+qSu9IL3S5x11aytYztmKl+OqDD5Lys0Jo7f+lljZsOS/0/7G3ENzqy5SRlEro2xufy/qv/hXxEgXV+N6huuPoTDNchmiwFi9Vtn/7PtP1TtJJLfI/iVbANh8cTN6/dQL0w9Mt9puFsxou6KtVV+XO7EucR2MZiN2pOyoemc73m5QNmHiX/vniBMilg4QUAqGkZqk3Gx6Xc7b7vxZXhO/Jja2SnO9/eXf7mw8+5s73sT68+srHQr6wpbKv9UAAG794Gto+YeH2o0dqmPKvikVtl28edHGnsCl7EsOHbOq4a3tvm+HiOURVq0k1WEubAizjW9o5mJfu68pHX4Znx6P+HT7M/ZWvxgdAKAg9SVx0+Ljix1//c7/Wq0OiRni2GkFMwwmA4pNxdiatPWORzw5w+y/Z9t97t8r3ZGaZD36yWAyWMJYUZ6dV1UkCIJjLWpZyUCO7RFPzlS+VaFY3xZFGb1hNlg+DC/fdKQTdpnD/xyueqcSnxz8xOZ2w/Xba6H47PBnlT4/ec9kAJYvE0DZFw5bk/8dSap46WdkW/tBdHfqbjz969NIzErEl/FfitudcYnlm9zEqneSCcNITZVU8RLDrTYO3IhBzQdZbXPzuP0ZWlOyU7Ds5DKbl1JKO4XdiVs7uS7vextN8C3KjUgYcwQI6WBZvmkdHG7tNFvKVt+MWzvklvojpeIIoVt9f/p7h7/V5Bur14w9scNE5CePBOCGX49WvO7sprE/j8vQmKFIz0/HS7+9hJd+e8kp9+7IPV/WIddUWNZj/6tjXzl+kGq0bInnLcrFAyseQIeVHfDGH29g4p8TZb1zcamVCSsrff7Hg9bhYOyWl4DPWgMzgqs8tiAIOJp+FG1XtEXbFW0r7+tQmG2ZCHBeCyBTuplyb/2w1PhZWrUEs2WyM7XnPw4fq7oBecXpFWIoK//3qTirM3IS/mvvZXYd/Kfy/lzlnbh+Au2/b4/ordE2Ly3ZumjZUGXdabX8aLkxO8cgOTsZ/7fx/6z2kWtKe1dhGKnBhrSw31LwWXdLsp/UcZLVdo+Abbd9vn6/9sOnhz/FpD8nVXiuRZ0WFbYZrveqsK3oRlfkJFTdtwUANMX3Vb/ISyUtRs8sBvzvA+IW2dztm5OOj055f+/71a8Dlg8MKa/LTv3eH6YCS+tXbS8P7HjH8XsA5RTlWF3XdiRY3erWb+RCcZ2yZWMtcfnxRja+nWZfBXbNqPhtPa/6d7LtvLqshSEuLQ6AZUionK0j9ib+qszBavRBev2P163665T2ddiavLXiZbFvy438+vwNlTIAACAASURBVLw9UFi9FgpH3doqkJ9smTlapS67POPopZqXfnup0ufzLo6FIcN69Mtj6x5DRkGG1Zw3liBU/Rks+obZHy1365exF2NeBGBpyXlr11tVHtsn7/8wbs1xFGeXzW3iyO0UHLrL8/WzVe9T4tnmjve1cQWGkRqs9olf7T5XenM6D7UHjgwt+7avUt35KIqtyRUn7rF1M7yijO4VtpkKgwBUPhdKqae/2FvpNOe3MgtmRAT54umQIOCvLywb61lCUoGqbATS3INzsfbsWrvHsTcaAADyL42wWrc5JXXJ0Lo3/njD7nF2pTjWOc9RG0Z3xX0Btare0Y5/7/23YzsWF4oTyN06fLK/2/5ya2V/Wopzb2kB2DkWT/34GITY2ZZv6+Xpy455p9fdHb3BpBS6relWYdu7mZbfi155Za1QPqay3++i8sPuq7j0sv/qfpvbJ8ZOxJLjS6w3pt/S1yrXOf0ZbnU43fqyiqmgZPSMUBYG7nSIeu65yci7+BbMhiAUXe9p9VxGQQbe/fNd8RJK+XNXt3Xkvtq2vwgtPrYYD6xw/H5htlxNsVw6LrxWNpKvdGRdZWGtsr8norQT0Lu54R911X9jlXarBoaRGmzY1fN4uLAY069XvJborir7A6C55c6NGbll39r+upCJ9OzqN/+9++e7WBS/SPx2fD3X1nVuNQqv/T+rLaa8ZgCAnISPUZT5cJXnKUwbaLVe2S3qS/9IJHtoAJ+Spu6ol7HKpxY6hoVi61nL9d3lp60v/+QlW/8j//aEZdhoodHyvgxuObis/nzrP1Ltvm+HZH0ygJKWgiWPA7PDgGl+did1A4B6JjNedeAa+vsZjl1Wa+BbcZ6K0s6kpnxLf5kpnWzP9VIqYnkEIpZHVH5tekYQ8EUUcGEndqfsEjfP/ec6BqgtH5D73nsMbuX6Jv15o+zDMLMgEztTd+KSRoN36lc+wdSdTp4VXKvqyx2363/x/0PE8gixj1F+cb7YIlFsLq7woXIiKQVDs3Ow4fJVzEkva7G5dsHOnVyN9ltWcopyKq3ty2NfVvo8sm3fVLECQQD+XgJcdeySSfn+DeWV/zez+Phiy+SN+fZ/r0v/PZVnyOiO3MR/QzD6wWwo/f9a8QP3YNrBWy61ln7EWbeOCIL1R19Owiws77kRgd4lk4NdLJsR949Lf6Dzqs7YmrwVX8R/YbfuW336z3Ucs9FfRGQuG+Wy+eJmRH4fiY4/dLS7e2XzIIl+fhUPN26Ino1CkDZ4NQBAYyfY9muirEn2GEZqmuiyKaV1goBF167hmdw89L0lDKhU9ic3e/17yzeYnWf+weAlB9BxRvV7av+W9Bu+PPYl2q5oC71Bj5+O2p5uvfhmRxQm/BdbkrIQe+kyfIylfxTUMKTb/8cgNsEKHhBMZR+0jn7bLX7M0hNfaP4EZtazTB428cCHNoftCcV1UJzTWlz/MfFHLDyyEA/+8CDi0+ORX2T5YCjKskx6lp/8utXrn17/NCKWR6DtirbIvVp1p7uxNyw3uBuXpUdYke2RNoJRB931zmhfWL3m/gOTH8eE3s0tK2YdchJmIf/SG8hJmIV3v9M5dIzuP3avsC2jIAPjdo5FPgRkuLlh788v4pPDZSNZ+uQX4HH1UQBASG0veMD654pYHoGzN87i+LmygLHdW4csNxt/gkr+eM4/Ml/c9Hla9S/fVDWPy6qEVY41fdtQ2g9m/fn1yCnKQadVndDnpz54ZsMzaP+97dY8FYDwYqPVx6JgstOadfVo2XJxIZCeIL4vD6+pOsRXakV/x/b7sDYQMwH4uurLf0tPLK1eDXMqdq43mAyIuxZX4VYHOWenouh6Xwgmn+qdoxKe58v+DeenWi53DfnqrHiJp/xtDMbvHo/c4txq32epV36BzQ/YD92XoS6s+3MlZyc7NNy+tP/a3it7Kw7PFQT87Vk2k+uAQx/i4ui/UGzns6D+X9Xoy+UCDCM1TWPbN1aaWu4b9MonK+84N1TYBJjNGL7iT+jCvoCmbmyVPfJLb/Jky8NrHoYZ9j80P3BfjkbIQV2zGcc9RwAoPZf9wFSUUTbcM/+Sdc9zR/7RPrzjNQiCgOO5VY94EYy+MOU2F9cLjAXiTKgfHfgIGy7+AgDwqGPpj2AqCLN7rIENg1AM22OWIpIfw4mkFLymL/tDtOnKNRwt9+2puaEIO1Muw+vcGCzOPoi6t1wGCkl5AgCQl2R76G6gnydGP9asLJDcwtHRBYIgYNyucYhYHoG5B+eix489sCN1JzqFhaJH44Z4o9xwwfJ+eM0S2AaqK7YKPbvpWbx11HoCsIV1/Coe5MPaFTZ1KqzYeveEzdY4a2ILxdqXLN/IzZb/MxHLIzDz75l4bN1jlbzaMV1WdwFgGS5dfgr/Ug2LbQVOAfWRhZ0eb8PbaKNJfWW5zovf9AK+fAg4Zbks65QZaCtpeQGAQ1cOYFFtXzg6EcCCIwus1m9tbSzv2i2XEHKLchGxPAL/v70zj4/pev/4Z/bJHhFJBJGoVJDYYqt9D6LqSxdrUVXUFrSWokItabW6o/VVrarqt6V+SrWitUspoUIoJfsiZF9nPb8/bmbm3rn3zkzSRILzfr3yMs49d5kzM/c+5znP83k67+osLJtvFDei9SXBDl4hYChngqq12SNwQb4Ux1LSofn7DRhKmIlIuY6/5FpdPR5r43lhpTbUwNIyTJbHIl49E66oetD4mANjMP7QePOSDSc9tzwf0xpbVG7L9GV45pB4ILfmZv2qh0SNkYcNiQTw78hrdiMEn2XnYGPOfbRvxF/THBNsubmNytkMrGkAZcNTkDmlQ+17GD9etl3R0V7Ov8KNH3x3JZpRVp0o53pepsksehoVmdyIcQAoz3yWI5xl1HALA+69yRduszamygzluFt2FxOP2w4oK7nJuNkN5cKpv+xMGoPGx+axAOCuXI5OQQH4xYV7A22S/yl2ky8F95EDeC38DbxcUIi9mdloZDDiT/VsdJDeQSOD5cGzOTsHvxg+Q/H1GBgrLKJmU3sG8o45Z4DwTVqX38PuewAYl7ApC8h6WcsWPVsySy8xCsdmyj+4i892O7EMECdCcDQ1A9MLChGbmoGEpFRcUdmv51GmK2M8CtcPMA2x/NTtqpJfIS63LcTOLH4WSbJ6As6rZ6OFNBsR5ZblupNOjBfwJrQoq6g0WrMrtVZ+mIrZv8126JyfXLKznLDW9nd56tHp2NzAE30DbIvnAcJifUaR3xMADAng1nSylb5dnjFOdBsAQOK4sVCWPBvF19ejUQFjqHsbjQgjwll1ACOAeOHuBYePz6ZfOXeZbkphMRrdGYdNrCW6JfI91Tp2wv2aqTHVRsQrW1dQY+Rh5JXjgs09yiswtLQMKOVnEYxqaYm9SJUzjmKVt2XN31ZA5ytHXrF/TVJ+MJSzQobewfy4gJUKi+dGV9gFJf9wq1vqi20rca49t5Y3YxHKXhh3yPaNrOTmShCDCwC+wSOEUeN4bY0lVvEQN7Jtr/Ov2uWO+fnCMSRnUtLwa1oGepcLx/a09RfwLohADC5oq7G/9HMp55LdPvbYJvAQrgpBOuYzfraIGTtfgwHz8gvhZxAIGhYhNiUWSD5tadAU84oOcrJudOXMsogN9t3a5/D5l+bmcQxKIQJZnpPZfj74Q63CmKaN8cJBfrbDyfSTvLYpbafg9NjTnLYqabvYoFiwICcX64lKebrFuPjrzSEY3VGkoGRl4U/rInds5JoGSFaPx22VsMGiyRkmuq++JBghfm5oJ7mNdxVb4YliAFJ0llgmGHtVqzFW9jumyw7y9u+0qxOmH5nOa68OEgC/S97mPHAnyR3LYPOTtba5PeyrMHx741vgatXUtWu/SlnVoMbIo0jyaV4TW8Nilh/fxX61WDjlV2PQIC7LdvE9IbT5XSGXSfH1NOFKm2yIriG3wWh/xmtd5MoUbMrGXmqnyRBxFIV7gvnGaqsGjDX9Gk2z20diQ4zO3Ujgr2cewClG/ox2VAfhQM0nGvHfX6AkC2ly+6mOjs7AAeBAOisgkjVL7uZgvIvgAmF5Afa6MfEUfzoJF5ETK4vAZt25dcBXIywN8V/xStmbC6RpioF1fsA6X+Y1wLyfw0uA05b4FbnUsVTRRbn5mFBkCTrcrBeO1fCwMlZ+cmU+t+TSLM54ZgtkSKzpsQaLOi+Cu9Id3RsLlIi3tfzqYPmBNLkM+EM4RR4ADtw+wPm/vtgSl+XhrMDwML6hn2uKFSrOFlzaMvF/SsaTJZMQXFdNQbJ6PNxYyxtGrXgQdHnaNKwe0QoHVCvxrOwkPlJ8gg6Sf/CBkhtoG6P4L5YrdqOpJAe6Isek4AFAV2DxULPvB1MLGI/WM5o12KYXCVB2gF/TMnA2OQ3f3Ym123f9ufXAz6+JBqsKUd6onf1ODxBqjDyKFPILjnVpYAnQTFXwZXikSuEMCqHaH2WpU0VPXZE1CiW3F0GTbbsAXdQg9jKCxBzdrsmJgMlmjxltuTEU3+Cqk5bry6ExaHDwzkF8d+M75Guq5jpns+eV7mji6WS3n0vGcGy63hdR8h9QnjIT3vc6OHT8n062FGw3EsvcRGVjdf5jvcWr1VyaY85UeeuZtvhsUjjkIrPX2/f4MRX9pZfRpYpBsbY4nZJu9mAAsKSNho6BBMDujGz46m270uPUamCWVarq2xY3f4rA9xUABpSV4+vMqquKihYm+5slx5/AZF4h7RxwbitwdJV5k6PGyCeseJjAit34VC9cndXdyDVGDrixglpZ8TMGq6nshYkX8J9g5ncmkUiwbQg3pTfsqzDkFNlIId8iHH9m7X0Z3qwJ8o68AaTEIacsB+X6coR9FWa3cvU7Y5iHnUZvhL44hLPtmaaVBsrdqzaP0YrlNXKSMN7XU04LLR2MzihNepW3X8lNxlsTHm/RCOojS8B+lXhGmReKIcngLxuLUZFlicdwKwjBlaRUnEhJx8J8JkD9L9ISfaT2qw5bszHnPk6npMNfb4AbIfAyGrE0135WHQFEg1WFiM60P1F8kFBj5GGlO+sHqHAGJrJcdP9YZceU5UHxAdfiF3J0ZxUWghCCJSeXmNM8P77ELQ+vKwqDobQVNAIaIgBA9G4g2kaw5wSMGhiM62ssN7OSG+tRfD0G2lyLkNHYrgGsA3O9JW//+TY67+qMZaeWYe25tRi538EMARYmb4S3qwrdWzQ0izSJ8YeWiT6PkjNu+iMlB2x155xJiA6az82vnWwEAL+n56rozpQxGSmTngpERFs/B68BaIQCjJD9gUUOeBQcIUCng4fVgxS3K7MQKl3GYVotjqbxU0kvsoJ2ZzT2wd8KOTDhB3ObIwsxEgAdNFqcSUmDIVt8BlpglbGTXJTM65P9eW/gOiuV2LQM+P0US9tNpm6So4UgF1dmTZmogFKwXy+R5TcAWNPQIiSXa+UZMRrk6Lw2FoFLDyG3RMOqT2Rh4H7WuLxipdpsrT9SyZ9Z53ltfZs3xduXP8bA7wea008zSjJwI09cMff5LkzA6MWUfPhl9sdEVuB2YeV7yfg/8UBXMXFET1KE5JhIqOTM52qsCEDxde5n0txYhC2K9yFP/EHoEII4QYupMvuikCX/LEbx9fUAgB1ZdzEjvxDnNJ9DAsDL6vfgJrEdpMqWih9aUopLSakYWlrG+12NL7Kf1tsuKMDmdm8d12vSUlK/KkVTY+RhZcBKIHIT8PLvwPIsIKifZVs2K8BJW8qk0Wm4qWQdBL64ifdTcCnnEn5OEo+yrshgVF+19wdAX8LP2NCX2F7fNHPnGJyU9oV5Lr9pUXFlu1CrWjHXlE7rbjAg+l4ufkvNQN/KWUtLH1fM6tfCItIkwOdW8Q+hkjtQAPg0Owf9SsQNiU+zc/CJ4kOESfj1bUZ2t4zVJ4qPedvFWKwQj+9h4+nM9igQ/Kl+FeHSW2imN+CntEzMyyvAqZTqia9dSUrFoXSB4L/9M/ltVnxw9x5e1nJVfM9kngGCB1deKff76WPHs+JuJEgs34rYVOGb6w9u3PRZoQfojfxbliBXgElpPbIS8Gel6e5+zuZ1WPNcMfMA2ahjjEmDiNifmhCsFNGT+d7dDbcVchgBTPC3GJ593Vaj9Zu/4H4J4y0IX3sUwcsPQ2MlBMbB3b7uSqmuFF+KBCzvKuAHTlprwVgbBQAws28LHFMuwxIr4wwAPlaLm50qOyZpZDvu8k9ZCrMcWp4xFsdVr2GYzHFJdwBYq/gCixXfwcnawLaC6LzAxJ7cQOcKDeYUFPKmG7v1zKTqGY1tsTUFGA2ahKRUbLyXK6oVKwFXLK+qlKdPxNwcy1W6GYz43uC4YvODgBojDytKZ6DLNKBpZVVQGetrXHYfyIhnAsQcqHNhYsMfGzH3tyg7vWRYNPhJgChRnvaSwHYbX6nmLH2E+J0AgEiB9WQA2Pcqk/Xh6WyZTZoMoerwcmEREpJScSY1A2NKSuFjMMALRTj1SksgPwVNGzDZL6vu85erriSl4imrpY13FIxLvE95BTbl3MfrScJBej3LKzBCdg6vy60MiBkn8dYzlkDdnjLhWWrqf5iU6iLCzc6JkP7J1Byxwfk3BsFZKcPqkW1xcGIzzrZAvR7TC4vgaTQiNjUDL1VmqYihvct1ybNvvq0qvuR2vml7djmwrBwnjdz16l+TLfv8pwnX27NBQNRPCD+DAZcqb+yz8y0Pvg+9+KnC1hiFnFdnPwKST/GalVLmO0kMXG+d9YPYdMitBq5uhhCji8VnvqOa+qO91eTh4HnuufcrVyJZPR6dS/gGz1wfb8zybQSdcwOgA1en525xJk6mnzRnxHTfLRB3YoOdiTvNr/UpUwT7+KjEjclDruJxWw1h4/t9fhsWD2mFZPV4JKvHwxkVMJQFo/h6DBoVNRPfzwbBUub7fyQtE91Z2TBru69G7GgmDk9XwNxvW0rS8YNqDf8gAO4ST7yhZ1KUt8+JBF67JdivqmzKuQ+vKgRvm5AV94a+OBQu5Zb4mmKZFDdJ9captqDGyKPKtv68pj5ltutC3NVfRpFO3IVfnvE82vq7Y+5A8dz+ZPV49JNeQssGMqDQatbdlyUaVKmZsHZUKG+GAwCdAizu6QEhpqBNx2TkededPg4tK3Yi1cgN3N2k3IpmO7sCH7aDmjDGxrPFljiLD+7ew/70TMFFljZSi36JQmLAi4hDgoDaoumK+8gss8qE8HVA4/Y2helMBLTvBwA4ZOCu736mfB+IaQYYxGNNlHIpEtcMxeQegQj1E7/p+xkMWFCZpXJMwFNSljYZC2zEHmislx92P8/rczQ1Ay8WFuE3s8HDfe+JuYnMA3HQatxWco/XlW0INu0CPDEA6DABW6V8DQWTST6olPtd/7NSDGq2iD7KfJF2a48iAGiNjDdCItOg5OYKEIMTSm8zcQzP/cMsYYxkGRdsj8hgzTv4TF8p9tfbkkVW9eopDBIYkawejw5SprbJu/IveH2OuzjjtLMTIxPfrIu5/bxahUH7IjD7t9lot7OdYJmHqnDduAbuYH4/nAyaEotX0Y/l5QoTWVYw6l1QeicKixT/Ez/Zz6/B7w+LMZCotkyMwqTCVbYdxdNoxLbse4hNzcB3GVl45tup6L7uNIqvx6Aii/GOLZCLL/+8qF0KQIKDc3uhXVNPwNUHgRW70aJiF1pW7ET569UvBXEiNQNXKg1uU6CsLUa0GIGCdOb7tkhnWdo/Xk2PaG1CjZHHiA33ql847PmiYkwvTceXU5mbbefmDRAoyYJHXltzn26Va99fKjfiiGIR8H5bbmaPQOBfAxclPh3PVaxc9x9uau9/X+xsfs0uTe8oRp0X9JBjgs5Gwbv1FoPI5DYdWFaOJ3RVEz1a78AYhz0tLFjGoyfjpbq1bhjW6kWUZ885mMJpR0LchLfRCGOe5YFVkfECDCWtMVP+M5bm5sHLYDA/cB3hFe0CAExa7ut5BfCxMbM7l30OhtvHeO0rdKyA6WmxwKQfgVGbMWSGcNl4AGhpJTT2prcXbigVOOlsCVQ+N/6c6P7WJt4HDTwwuJk/jNf2c9qJwRUlN1fBqGUM5jdlPyAhKRXrrJZdfoliatXcIk2xQT8BiC4EBq7Esnb8zDd7hLGMs08UH3G2mbKuhNjy1xZ8o5aas5fYAlkAqqwwKsTXyg1YMjQEm15gBXdfsRgV0Q6UNyi9tRJGjR+aSeyo41pl+HSXJuIzxSYskDuQ4jpgBfMZLBEXRfQzGMxaHApw7wPExqMzj7ghOSYSoU24KfdGSKGHHE4ubsCb1Y/bMpnxC/MLBCdAbL49ZPFGl8DZfG9raDTi2+lV84LVNtQYeYxwNxJENLCt4SHGorwCLFHsgbcrM2td1y4Hx1WLcLrwMNSljdE+vxE+z7YU4JKaZtI7WRkEQkXlBHgunOs+lEol6FUppqUvaSO0CwdVbrhVC/PzTSOO64RUlxEl1V/XNTP8XSBkBNCLeZArZFJc3SAS5Z8rnhbJ4fw2XlP7is/xo4GfUfFlfgLGFJUgoqQUt7Qb4Q5mlj+hqAQnUjPwhW40orSvQkdk6KWpVN50FR7b40ZuxlGsIRyBFd8I9v04/mN0AHdW2+GfkVCHRFgaWN6kFr6O66ukKxR4rgnXA9dmJd/wAYD/erijU1AAohsyZQSOOzlhu6cHsuVytL9gEU3T5nfh7PeWgFfioKE7ZvRpgRA/d5xe0h/Dw/ywd5ZFeG5ar0D01zCqtK/nOvaASmBJfkfK+MGmCUmp+CVNeMkt5sJGvOfliRtK4Qyl6iKrXOZpL72DWf2sisydsCxfqY3CqafBWotOkR9y0UxyF12l9irQco+1R7kWEbILaC21/YAGYPFKOXkKTpKsaSzhLhUabDw676EBr423HC2VAlHC4mWv6WYItleFiswxKEvhB+TP0zIToZW6KVYxZXUPNUYeJUSk4tmsGMLXC+hmI5ofAA6lZcK58mZjWlpoFTvZvP3PnHPYVXBR+MvEFidrIR4wdWnlYAwM8cGiwU9CWZELlHJ//J9NMhkY9pc27udwAw2JzvLQumLk18QwsXCQ49LSYkgAkMqU3TFCcQBjv+X+308g17/d88DYb5gbpem4Yks6dlIjzVzmGgB7Db1QCFcs0PH1RLpIbyI6Nw/vVsZqXFHzb2r7jb0QrPka6aQR83BtJuwtSVzHzXKarlsEsc/wyn1uGuS55DSc0XVHsydaA9OPAfMdT5Mcp7VfhdgF5fiEZUCfrtQzMcWY7HVnAl/nCujyAIA2rw/n/0IiVgt1s7CwUpq/aQNnbJ4QjvDmlofVE41ckUSYGJkXixzzXh1My8QC+Q82tWma2PCQfOXhzjPMhBhZXALNXXFRMTZHBDKmAPAE5NxEgkP/l5GNn9Myofv7DfyhnotTqgUOndchxgss97B/T6M/52+3oq0kGQ1RiGekp6GCFk87iaug/hrVh9cWMyYMb45ogz+WscoxeAbwdEg+10fiB0NfBFfsRMeKrdipH4xYA3PvW6YT1itqwvLeavN6oPjvaOgKu8BQxg/IP2DsgTYVX+BrwxCUaqondV9bUGPkUWLSj+LbnhwGzL8CTzU/mK+7iDESf4eR3Q5gZzMcXmKu71Et2DPoaA9gF6My2cBFie1TumBu0XvAuy2BjS2AVIsb3UUlx0fj+DL4B9MyOUqfppgHtqorMViCP0dqhdMFAWDeactMN7xiCy4bn8B7ume5sSZdbaf/Pq9ZiZIb61FyexFm3BMYpyesaqEMWsXvo3CsoB0AfmmAf35jBLrY4kcCirxf6m1rRDhK1KBg5uHaTqAGxpjtjAZKU76hcnv9cFTYedA5EQIjpJjQLQBo0gloIC4xbr4e7asIq/gv4oxtcSHZ9gz5mnoalKxxmuXnw0kvtkcLO0qtAHBsaQRUcvFYJ8bIlGCzfiTyiCtc5PaF+Pz1esyX74MTbJeA/5RlaFWHgszx0Ob1RfHfb6JDhQbR93JxSMTokLC9FJXKqsi5wQjIsZhREoOKLG4lboCJmWmm1+OGUiQba0WOzSUVUV79A3gywnafZny9jd8NXI/eFuWHuKiehQ+Vm/G3egqkNpY9W/nxSxy4qRV4qVcQ/Dy4An7r9BMRpX0VG3TjsFg3He/omd+RDnLkwx1v6qdium4RAit241sDt67UXcLcyw+nZyJY2gpDA4dCc3ckYBQWCTRRBmZ7SGN3m/0eNNQYeZSQ21AuHfuN4M18X26FYLbBN5nZUEgEZlfntgJ3hN3bDtFrIff//1ipC/7F8hx8MQTItsz8R7ZnMoN+TsvAa7n5OJechuZ6PbpXaMxroXMrlmFgiA+IzhtlKdNQemcedkzpbnaNj+3iWAR5IVwwSvsWPjaMRl/t+4jvuA6YGw8M4oqvGYO5N7rzpDUACYi2EZ7SbEaPCu6aPu8zekKgcJ1MxH26UiCr5LzVrG7XaEag68Bc4H7lEs7GJ3i7+Uiqt2bdT2MpdOemlmO+KZg5W8BDE1YpZ/4SExh5pHKGN6VHIGRSCXR5fQVTQU0EVewGAFFRN2s2KaZjv7EXisEYc8MrNqKriKFtypq6Z61G25KbGrvTRu2c31RLsFG+FZ8oPsRoKV+m/Y7PIIfE9Aa19sU7+rHopPkc7jkxOPHCCSRMTsBH/T/i9d109x5M344Pmtj+Hfax4/G0xV9JqThsrIwpMDrjVNL7aFXUCAF6Pa4kpWLTXW48h6Dk/bd8AzWJNIauoBqxCnIV4ykc/73j+/i0AXwq0+d7zLW0z7GqNyPnP7yX6QQK9onBNpIi3xPvJ8J+Yy98Znga/zP0h14glDmirS/aNWUMPPb95Cs9c++RAIi/NhVDGr3G29cWrqrqhk3XDtQYeZRpxNL8kFpmZ3Hj4uDn4odhQcMQPOITvGEVVHYiJR3tNDZmXfvFhYrs0lWg1kO0B/NXJhDctrUnE6SZchYwMpkDzfQGTC4qNi8dAUCcoQ1W6qYgXtOfkAAAGzNJREFUztgGv91gZoSGsmAYNf7w81AjvHkDJMdEImaMYxLIelYGxPnlQ9DpmTlAwyeYlGoW0sb8ooRsMuEN9GctGVgvt0gkwLzLDl0TJ33bhFokbuLS18An1rEzFkyxHG+OaIMdejszRxbJhHHvJ8dEIiE6wrJ8JHRtJqQyDG9wEK/oFiHEzw3RI9uK97Vizyt2Hlx9l5pfthjOde3fJk1wJvlt3i7fZGZjTGXWlNJKPjtsJ/f7sbEhf/2fzXPykxghO4dNSn459mbTHSuENqaTJfPk5t1SeCob4IvTSWgk64QrL17B5UmXcWTMEfzWegUGszLihuR+LXQ4AMA9wnwvWtn6HVfydg7fcyYFE3DJZrSWMcQlYOpg2SQ/mflj86rF06nNtSxlyHR2vEEerKybJ4cAi20X9TSTw9IiGrIWWFUArLwPeFstx1p5Isdr38BdeDl2DoAxkl7+DYjYAHSpghEDYHw3fkZRE08nfDK+I9o388S4rs3w2aTOODCHCUTNhDeGa9YjUrMenxlG4LChC17XMd7a6TurV9SvvlC/TCNKzTLjJJC4H/Dizoxdla6IfbbSI5F5mXdjsVYR5FFSjQJow99l/pXaSM99RySe4/Bi5t+QEcLbAUzRLYYGSjzRyAWlGgOyiyzvyd3JytMw+zzwaeXSwbRYpkQ7DwluvDUUEgnE3eweAUCnF4GT7wAAfvd/BVbxl4hfORhwiWSC5MSWGbyCgJlngGv7gB62qwzj9dtA0gng7jXg1HtAO5b2ilBdCq1AQK1vGOInD4NKIYVaIcOdVl9g2sFEbE8RGgcLY7U2Kjd7WwngtebGiuyf3RNX0gvQoZl9zQ8AKL6xFgfn9uJlJPDovwwIGQ64+uEZVx/ojQQdmnlg0CbGU1EBFVZ0XI+3L1kyqdiGtr10dzFO2kiNjNGNxX144F0RGXtrrD+1Hy6mY81B5kGaHBMJmUSGxq6Nca5BH9istdtmFP68egO/GsKx19Abl9QzsT07Bz+5umBoSSm2DF6I/93kx08MKy2DZ1YOZjS2HP2JCr6ho4Xl/bjYq4HyoYCR3qA5ACYFWZMzFE7eZ2AgBhTcXgqoJvP7m5holR3jXAVDgY1EIux1tPKMpLt1BAp1GKtdgT1K26JlGFkpVti0M/NXRdaNCsWoDk1w+GoWdpxJxukl/c2aRyPacTWikmMiEbj0EBJJoLltls6x2JpmXk64W6iB1k7RxrqEGiOPGhP3ArvGMJkYciUTDGkTgmasmJBhJfx6JjWCkEekqtzgV9Y0YdK6uH2vFMkxkegZ8zsyCpgHjbva6mveqBWT1meD5JhI8Y3Pfw2c/RiY/BOgUDPBlXl3MCB0DLCMq17r5VKpmdF7ocCBWPiFMn/2cPEGQscAucxNHfcrK5ASAtwTkOZma36ETwWeZgq+sR/xLRq5YvvUrkC07VN/uXohLiTncwIwzYRYCXuFcMdPKZeic6DwQ8So9YRUaREpK70zFyBytHF0TbvSOyUB8Gw4v+T9+WtNoZKpoDFoeEaEMyEIuDURqcG7ePtZo72+Cmecp6OB0WhT8WarYaRV7SXb9GvFDZA1GSLWvLA9HsA3SFYLVLCt/D7ntsnGf3ddBADoiAweRgMmVgbGrnxqJc8Y2Z51l/F0VHAnJGJqseeMIegmZb5nB9IzEe3thXdz7uPyoG/R4ajtKtlQOGFc1wB8ez4VgBQFiZb4reCKnbilflF4v0Z8pWe8kQlcP8j8/v4nst9yBydNVuUCji0ZjNS8MvyZ1A44ZMcY6SRybgeRSCToGuSFrkFeWPW04x7DqrL/1Z4o0ejRd+PxWjvHv4Uu0zxqtBzEuCMHRTvWv3EHSMGojMYlp+EdIbXL6ELAnX+TBwA8xdLMaDu6ihf779iuFw+APFyp6wAALsoatrnbjARejmVuhAATXBn2LCCRiJdLr2lM+i13jgG/LmcKqm0WWNJgK4gG9uJvd5ROk6FWyNAr2FtYxl8q5Rp4dpavAKBbEGOcWJcQMOo9Kw9Z/SLn7M/hwF+ZuDDxAhIi96GBgNfvmt6+EajN6wENnHBU28eu9F5yTCSiBgk8QEVwtvp+lrCyHMZv+wNZheVmhVR72WStG1tiXNi1jz7oeBiEEHw26L9QSpX4bNDniExtzRGU25uehSCtDvjH8pt2UnDf7Zu6KebXQTo9+qSFo0vpLviFDXAo20nIWASYgM0YJete8txXjM6OUJwUAChdgPYvAG0Eig9GFzJ/CtuBnGLIpBIEebswtXVe/l28Y3/7GVs1zZ31wzFvYDD+enOIw/tM6RGIhq4qBHhVITC+DqDGyKNIFSo3mvpKALjacr0uFJYrR8Q6y4//uR2OrefO4Af7VYcY/ThkRmVj9zBLmt2pxYzyrLtagSML+uDYa/3sP9Qmi3tcqso8G+q0NUoSq+hZ3CeO7ZNy1vb2mZUGjkTgcdt3sWPnmBXHZHX52K9RtHt6d+x7tQc0d628KkbhgnJVYT2r4jMAfHE6CfAOhnHyIXyjtwQNj9ZEO3Q8bS6Tlr5UbzubqloZHwC+ekk4Nfrs7Vw8teF3BLE8bocNXQT7AkBDV0uAdCmcEFixG4EV3+CDuHwELfsZ4z++j9xrazD+4zzsKZ3MkfJ/UqfDgYwsVOiYVOP4lYNxdXUEJ+j7FuEaE2/pGRFCmVQCeNoo1NaF8YyaittZ8+307liybK3lXtJ2FDB4te1YJBPsDLdl1Sz+5imyhNpUPO4KPedX71z/AqlUgoWDn4SHswI+bjYSFiqZO6ClOUaLLQ9w4vV+tXWJ1YYaIxTbPPOp5bUjkexODYDA3oxst4kgK32Rxu2ZG86yDMBHxDVp51wnnngdl1dHwt/TCeO7BSA5JhLJMZFoxrL+n/R1Q5C3/VRJBPXm6n3MPGN/HxECHTlfXdHLzvqyXxjjVVuVx3w+rVhLLe4Oenx82/DTl0WQSSWVsv9SlKczCrNGvRtA/r0Yk9pqRv/ekb+h1RvR4rNCLNdPQ2DFbhS9lo54IuzB0JdaNBqKb6wG0VsWtvprRDIm+i3jaMNUhZ5PNHS47/syq5pQr/5hfimcISFujGugRLcKrjGrgxynl/SHl4sSMqkEMWPa4a9VQ3BhxSBcWGkJdp6htdSx8nZVMhMbgTRZLE4CIpmYsbb+7lAr+I+d7i28HCqPIMjwjcDSVCb9V+Vqv78Q8/9ism+GiKf+87CVvfgAOL98EG6vF65WrVZI0b2FFxYNacVpT46JRNKG4WjesP7dp2jMCIUpYJciIkvtaRXJzsZFQAxKImFiKQBm6QAQDzhTuQKvnrXoEph4+XdmRjL9d2DbACYO5vJuc1l6zDyNvn5h/OP9G145DhCjeFptFfhz+SB8duI2Jj1lXxej2oSMsBlDI4inA2nN7AfC0x8AKWeYDIHqPigcRF8cWlkynnlQ3VzrmNiWo5RqDWi3mlvAz83F8uAqubkCYR0PYtPAtRj83lkQvXi8ShJpjMCK3UhWj7c0PvcVM5uvJo6mLwNAu7ZtgSRvpiDm0lReRtXNtcNw5vZ9TN3hWNXau/DCNv1wTJdbvC+mIEoTHqwg8KODfsZPPx/EEaMlYNNsSEw7wv09ewRwfv8SiQTX1wzleHo4+1cXsawyR5FIgFfj/t0x6gCZldd35Yg2eKlnILQGI5Qi36l/Pda1BPWMUICphyyvp3BvEvC1Wk9nu6GnHhY+nkTC/I34gEkvHvxW1a7H5BptEs7M0FsOAp79wuLCrWlDBGCyfGrAEAGARm4qrBjRpnZnH+3tVDC2Fk4TELuzi6sPsCQZGLjSbteaQQaAcUMrRdz5VcFU+dlEhY4bLyKRSNApgBkXYnDFlQtjMejtqzYNERNXV0cAb2RZGoRiF2qJ1yNaAYtvM78FgYewUi5F/1Y+vJpPYrwzph3e1jPfpxMG+6nvg3r1xPtr14vXZwmrVEDuMQ+Yw5err68PQ1Ge3cFvG2InsPUB8sbwEPPrab2CIJFIoJLLHrpxlhBiL0frwVJUVAQPDw8UFhbC3b1+KcQ9VpTlAbpywEPAPV+YwaT3NnHsZufQudhpvXYyXShgsmdWixgY0YVAUSawbSBQnMkItfWKEu5bD/i/yxmYv8eitXLujYHwda9e8KE1gUsPiW5LjonEr9eyMePriw4d60r0EOQUadDSp5pLAXawda1s/lk3zGFPiiPHTNowHLfvlZjToQE72WSV/Jmch0+P/YNVT7flL4cajbwsFTb/+zMNi/daAl4dOV+dwvb29HvDkq1YTzAYCc9LUhf8m+c39YxQhHH2EjZEAKa9pgwR07koVUMiEY70H/gm86+7P7DoOmOY1GNDBODrKYgFOdYGBpHCbda0buwOd7Wi1gwRADj/hoAarwBVWdKxx8uVM+mWPuJKs2J0CfTCl1O7Csdl2TBEAG5WTfxK2/o29Y5+S+qVIQLwl2seRmjMCKV+MGAFEL8TeOlIXV/Jw0PTymUsbSmT6khIrcd21AYyqQSTn2qOr+KYJUBP55q70SeuiUCbN3/lte+YygRYBztoXOyb1cN+p3+JjwPeoLhljgUHm/hkfEfM2X0JMaPDMLpTU4z85DRuZBdjYvcAeDop8VqEJcBx84ROePWbeOx+WSAItYaRSiX13xvCJroQyLsDePGLz1FqBrpMQ6FQ6gV37pXAw0nBSU+tCZ759Az+SrOIqp1ZOoBTM+b92Jv48LdbvP3Cmnhgzyvd4fIAa3jEHL6BrScYQTvTwzqzoBw9Yn7ntFWFCp2Bl11EodQG/+b5TY0RCoXyyGOKndg/u6egJD07tiLAyxnHHdGnoVAoHP7N85su01AolEee5JhIGI3EIQPjfzOeooYIhfKAoQGsFArlscBRA8PPo2YyeSgUiuNQzwiFQnnsubN+OBKzitDWny4NUyh1ATVGKBTKY49UKkFok3+p4kmhUKoNXaahUCgUCoVSp1BjhEKhUCgUSp1CjREKhUKhUCh1CjVGKBQKhUKh1CnUGKFQKBQKhVKnUGOEQqFQKBRKnUKNEQqFQqFQKHUKNUYoFAqFQqHUKdQYoVAoFAqFUqfUmjGyefNmBAUFQa1WIzw8HKdOnaqtU1EoFAqFQnmIqRVj5LvvvkNUVBSWL1+OS5cuoXfv3hg2bBhSU1Nr43QUCoVCoVAeYiSEEFLTB+3WrRs6deqELVu2mNtat26NUaNGYcOGDZy+Go0GGo3G/P/CwkIEBAQgLS0N7u60aBWFQqFQKA8DRUVFaNasGQoKCuDhUbVaTzVeKE+r1eLixYtYunQpp33IkCE4e/Ysr/+GDRuwevVqXnuzZs1q+tIoFAqFQqHUMsXFxXVvjNy/fx8GgwG+vr6cdl9fX2RnZ/P6L1u2DAsXLjT/32g0Ii8vDw0bNoREIqnRazNZbdTrUrvQcX4w0HF+MNBxfnDQsX4w1NY4E0JQXFwMf3//Ku9b48aICWtDghAiaFyoVCqoVCpOm6enZ21dFgDA3d2dftEfAHScHwx0nB8MdJwfHHSsHwy1Mc5V9YiYqPEAVm9vb8hkMp4XJCcnh+ctoVAoFAqFQqlxY0SpVCI8PByxsbGc9tjYWPTo0aOmT0ehUCgUCuUhRxYdHR1d0wd1d3fHypUr0aRJE6jVaqxfvx7Hjh3Djh07an0Jxh4ymQz9+vWDXF5rK1QU0HF+UNBxfjDQcX5w0LF+MNS3ca6V1F6AET175513kJWVhdDQULz//vvo06dPbZyKQqFQKBTKQ0ytGSMUCoVCoVAojkBr01AoFAqFQqlTqDFCoVAoFAqlTqHGCIVCoVAolDqFGiMUCoVCoVDqlMfGGNm8eTOCgoKgVqsRHh6OU6dO1fUl1Rs2bNiALl26wM3NDT4+Phg1ahT+/vtvTh+NRoO5c+fC29sbLi4uGDlyJNLT0zl9UlNT8fTTT8PFxQXe3t6YN28etFotp8+JEycQHh4OtVqNFi1aYOvWrbzreVw+qw0bNkAikSAqKsrcRse55sjIyMDEiRPRsGFDODs7o0OHDrh48aJ5OyEE0dHR8Pf3h5OTE/r164dr165xjpGfn49JkybBw8MDHh4emDRpEgoKCjh9EhIS0LdvXzg5OaFJkyZYs2YNrPMC9u7dizZt2kClUqFNmzb48ccfa++NP0D0ej1WrFiBoKAgODk5oUWLFlizZg2MRqO5Dx3nqnPy5Ek8/fTT8Pf3h0Qiwf79+znb69OYOnItDkEeA/bs2UMUCgXZtm0bSUxMJPPnzycuLi4kJSWlri+tXhAREUF27NhBrl69Si5fvkwiIyNJQEAAKSkpMfeZOXMmadKkCYmNjSXx8fGkf//+pH379kSv1xNCCNHr9SQ0NJT079+fxMfHk9jYWOLv70/mzJljPsadO3eIs7MzmT9/PklMTCTbtm0jCoWC/PDDD+Y+j8tndf78eRIYGEjatWtH5s+fb26n41wz5OXlkebNm5MpU6aQc+fOkaSkJHL06FHyzz//mPvExMQQNzc3snfvXpKQkEBeeOEF0rhxY1JUVGTuM3ToUBIaGkrOnj1Lzp49S0JDQ8mIESPM2wsLC4mvry8ZO3YsSUhIIHv37iVubm7k3XffNfc5e/YskclkZP369eT69etk/fr1RC6Xkz/++OPBDEYtsnbtWtKwYUNy8OBBkpSURL7//nvi6upKPvjgA3MfOs5V5+effybLly8ne/fuJQDIjz/+yNlen8bUkWtxhMfCGOnatSuZOXMmpy0kJIQsXbq0jq6ofpOTk0MAkBMnThBCCCkoKCAKhYLs2bPH3CcjI4NIpVLyyy+/EEKYH49UKiUZGRnmPt9++y1RqVSksLCQEELI4sWLSUhICOdcM2bMIN27dzf//3H4rIqLi0lwcDCJjY0lffv2NRsjdJxrjiVLlpBevXqJbjcajcTPz4/ExMSY2yoqKoiHhwfZunUrIYSQxMREAoBz442LiyMAyI0bNwghhGzevJl4eHiQiooKc58NGzYQf39/YjQaCSGEPP/882To0KGc80dERJCxY8f++zdax0RGRpKXXnqJ0zZ69GgyceJEQggd55rA2hipT2PqyLU4yiO/TKPVanHx4kUMGTKE0z5kyBCcPXu2jq6qflNYWAgA8PLyAgBcvHgROp2OM4b+/v4IDQ01j2FcXBxCQ0M51RojIiKg0WjMrvG4uDje5xAREYELFy5Ap9M9Np/V7NmzERkZiUGDBnHa6TjXHAcOHEDnzp3x3HPPwcfHBx07dsS2bdvM25OSkpCdnc0ZA5VKhb59+3LG2sPDA926dTP36d69Ozw8PDh9+vbtyyn2GRERgczMTCQnJ5v7CH0ej8JY9+rVC7/99htu3rwJAPjrr79w+vRpDB8+HAAd59qgPo2pI9fiKI+8MXL//n0YDAZekT5fX19eMT8Ks/63cOFC9OrVC6GhoQCA7OxsKJVKNGjQgNOXPYbZ2dm8MW7QoAGUSqXNPr6+vtDr9bh///5j8Vnt2bMH8fHx2LBhA28bHeea486dO9iyZQuCg4Px66+/YubMmZg3bx527twJAOb3aWsMsrOz4ePjwzu2j4+P3bFmn0Osz6Mw1kuWLMG4ceMQEhIChUKBjh07IioqCuPGjQNAx7k2qE9j6si1OEr9EKV/AEgkEs7/CSG8NgowZ84cXLlyBadPn7bb13oMhcbTXh9SGSwlkUg4r20d42ElLS0N8+fPx5EjR6BWqx3ej45z1TEajejcuTPWr18PAOjYsSOuXbuGLVu24MUXXzT3szcG/3asHT3Pw8p3332HXbt2Yffu3Wjbti0uX76MqKgo+Pv7Y/LkyeZ+dJxrnvo0pjUx7o+8Z8Tb2xsymYxnpeXk5PCsuceduXPn4sCBAzh27BiaNm1qbvfz84NWq0V+fj6nP3sM/fz8eGOcn58PnU5ns09OTg7kcjkaNmz4yH9WFy9eRE5ODsLDwyGXyyGXy3HixAl89NFHkMvl8PX1peNcQzRu3Bht2rThtLVu3RqpqakAmDECYHMM/Pz8cPfuXd6x7927Z3esAdjt8yiM9euvv46lS5di7NixCAsLw6RJk7BgwQKz54+Oc81Tn8bUkWtxlEfeGFEqlQgPD0dsbCynPTY2Fj169Kijq6pfEEIwZ84c7Nu3D7///juCgoI428PDw6FQKDhjmJWVhatXr5rH8KmnnsLVq1eRlZVl7nPkyBGoVCqEh4eb+1h/DkeOHEHnzp2hUCge+c9q4MCBSEhIwOXLl81/nTt3xoQJE8yv6TjXDD179uSlp9+8eRPNmzcHAAQFBcHPz48zBlqtFidOnOCMdWFhIc6fP2/uc+7cORQWFnL6nDx5kpNafeTIEfj7+yMwMNDcR+jzeBTGuqysDFIp9zEik8nMqb10nGue+jSmjlyLw1Qp3PUhxZTGuH37dpKYmEiioqKIi4sLSU5OrutLqxfMmjWLeHh4kOPHj5OsrCzzX1lZmbnPzJkzSdOmTcnRo0dJfHw8GTBggGDK6cCBA0l8fDw5evQoadq0qWDK6YIFC0hiYiLZvn27aMrp4/JZsbNpCKHjXFOcP3+eyOVysm7dOnLr1i3yzTffEGdnZ7Jr1y5zn5iYGOLh4UH27dtHEhISyLhx4wTTI9u1a0fi4uJIXFwcCQsL46RHFhQUEF9fXzJu3DiSkJBA9u3bR9zd3TnpkWfOnCEymYzExMSQ69evk5iYmIc25dSayZMnkyZNmphTe/ft20e8vb3J4sWLzX3oOFed4uJicunSJXLp0iUCgGzatIlcunTJnHpfn8bUkWtxhMfCGCGEkE8//ZQ0b96cKJVK0qlTJ3PaKoVJHRP627Fjh7lPeXk5mTNnDvHy8iJOTk5kxIgRJDU1lXOclJQUEhkZSZycnIiXlxeZM2cOJ22MEEKOHz9OOnbsSJRKJQkMDCRbtmzhXc/j9FlZGyN0nGuOn376iYSGhhKVSkVCQkLI559/ztluNBrJqlWriJ+fH1GpVKRPnz4kISGB0yc3N5dMmDCBuLm5ETc3NzJhwgSSn5/P6XPlyhXSu3dvolKpiJ+fH4mOjjanRpr4/vvvSatWrYhCoSAhISFk7969tfOmHzBFRUVk/vz5JCAggKjVatKiRQuyfPlyotFozH3oOFedY8eOCd6TJ0+eTAipX2PqyLU4goQQK7k1CoVCoVAolAfIIx8zQqFQKBQKpX5DjREKhUKhUCh1CjVGKBQKhUKh1CnUGKFQKBQKhVKnUGOEQqFQKBRKnUKNEQqFQqFQKHUKNUYoFAqFQqHUKdQYoVAoFAqFUqdQY4RCoVAoFEqdQo0RCoVCoVAodQo1RigUCoVCodQp/w8hK8N4wR+lJwAAAABJRU5ErkJggg==", "text/plain": [ "Figure(PyObject