{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# probability of firing analysis \n", "\n", "include(\"utilities.jl\");\n", "default(show=false)\n", "default(fontfamily=\"Computer Modern\")" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "isolate_gclamellae (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "labels = [\"HC_CTRL\", \"LR_CTRL\", \"NR_CTRL\", \"HC_LITM\", \"LR_LITM\", \"NR_LITM\"]\n", "psc = Dict(\"HC_CTRL\"=>[], \"LR_CTRL\"=>[], \"NR_CTRL\"=>[], \"HC_LITM\"=>[], \"LR_LITM\"=>[], \"NR_LITM\"=>[])\n", "\n", "\n", "function load_spike_files(\n", " patterns::Union{UnitRange{Int64}, Vector{Int64}}, \n", " model_label::String,\n", " neuron_ids::Dict;\n", " neurons_per_pattern::Int64=6, #\n", " data_dir::String=\"data/dgnetwork/\")\n", "\n", " df = DataFrame()\n", " for p ∈ patterns\n", " spike_fname = data_dir*\"DGsp-\"*string(p)*\"-\"*string(neurons_per_pattern)*\"-\"*model_label*\".txt\"\n", " stims_fname = data_dir*\"StimIn-\"*string(p)*\"-\"*string(neurons_per_pattern)*\"-\"*model_label*\".txt\"\n", " spont_fname = data_dir*\"NoiseStimIn-\"*string(p)*\"-\"*string(neurons_per_pattern)*\"-\"*model_label*\".txt\"\n", " spikes = CSV.read(spike_fname, delim=\"\\t\", header=0, DataFrame)\n", " stimin = CSV.read(stims_fname, delim=\"\\t\", header=0, DataFrame)\n", " spont = CSV.read(spont_fname, delim=\"\\t\", header=0, DataFrame)\n", "\n", " if size(spikes, 1) > 0\n", " rename!(spikes, [\"Time\", \"Neuron\"])\n", " spikes[:,\"Population\"] .= \"DG\" \n", " spikes[:,\"Pattern\"] .= p\n", " spikes[:,\"NeuronsPerPattern\"] .= neurons_per_pattern \n", " spikes[:,\"Model\"] .= model_label\n", " for k ∈ keys(neuron_ids) \n", " lb, ub = neuron_ids[k]\n", " spikes[lb .<= spikes[:, \"Neuron\"] .< ub, \"Population\"] .= k\n", " end\n", "\n", " df = [df; spikes]\n", " end \n", "\n", " if size(stimin, 1) > 0\n", " rename!(stimin, [\"Time\", \"Neuron\"])\n", " stimin[:,\"Population\"] .= \"PP\"\n", " stimin[:,\"Pattern\"] .= p\n", " stimin[:,\"NeuronsPerPattern\"] .= neurons_per_pattern \n", " stimin[:,\"Model\"] .= model_label\n", " df = [df; stimin]\n", " end\n", "\n", " if size(spont, 1) > 0\n", " rename!(spont, [\"Time\", \"Neuron\"])\n", " spont[:,\"Population\"] .= \"Spont\"\n", " spont[:,\"Pattern\"] .= p\n", " spont[:,\"NeuronsPerPattern\"] .= neurons_per_pattern \n", " spont[:,\"Model\"] .= model_label\n", " df = [df; spont]\n", " end\n", " end\n", "\n", " return df\n", "end\n", "\n", "\n", "function load_connectivity_file( \n", " model_label::String,\n", " run_number::Int64,\n", " neurons_per_pattern::Int64=6, \n", " patterns::Int64=0,\n", " data_dir::String=\"data/dgnetwork/\")\n", "\n", " connectivityfile = data_dir*\"DGNC-\"*string(patterns)*\"-\"*string(neurons_per_pattern)*\"-\"*model_label*\"-\"*string(run_number)*\".txt\"\n", " dgnc = CSV.read(connectivityfile, delim=\"\\t\", header=0, DataFrame)\n", " rename!(dgnc, [\"neuronA\", \"neuronB\"])\n", " return dgnc\n", "end\n", "\n", "function isolate_gclamellae(\n", " connectivityfile::DataFrame,\n", " lamellanumber::Int64, #lamella number, from 0-5\n", " )\n", "\n", " basketcellnumb = \"BasketCell[\"*string(lamellanumber)*\"]\"\n", " lam1 = connectivityfile[findall(in([basketcellnumb]), connectivityfile.neuronA), :]\n", " gcl1 = lam1[[occursin(r\"GranuleCell\", s) for s in lam1[!, :neuronB]], :]\n", "\n", " gc_save = OrderedDict(\"Lamella1\"=>[])\n", " for i ∈ 1:length(gcl1[!, :neuronB])\n", " gcstring = lam1[i, :neuronB]\n", " gcindex = gcstring[13:end-1]\n", " gcnumb = parse(Int64, gcindex)\n", " append!(gc_save[\"Lamella1\"], gcnumb)\n", " end\n", " return gc_save\n", "end\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Dict{String, Vector{Int64}} with 4 entries:\n", " \"DG\" => [0, 500]\n", " \"MC\" => [506, 521]\n", " \"BC\" => [500, 506]\n", " \"HIPP\" => [521, 527]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "populations = Dict(\n", " \"DG\" => [0, 500],\n", " \"BC\" => [500,506],\n", " \"MC\" => [506, 521],\n", " \"HIPP\" => [521, 527]\n", ")\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "compute_aggregate_WTA (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# FUNCTIONS\n", "\n", "function makechunks(convolution::Vector, n_neurons::Integer)\n", " chunks = length(convolution) ÷ n_neurons\n", " return [convolution[1+chunks*k:(k == n_neurons-1 ? end : chunks*k+chunks)] for k = 0:n_neurons-1]\n", "end \n", "\n", "function compute_aggregate_WTA(\n", " spike_train::DataFrame, \n", " n_neurons::Int64;\n", " delta::Int64=3, \n", " n_bins::Int64=1, \n", " duration::Float64=10.0)\n", " \n", " # Create kernel\n", " tri_rng = collect(1:round(Int64, delta/n_bins))\n", " triangular_kernel = [tri_rng; reverse(tri_rng)[2:end]]'\n", "\n", " # Create bins for histograms \n", " bins = collect(1:n_bins:(duration + n_bins))\n", "\n", " convolved_series = zeros(round(Int64, n_neurons * duration / n_bins)) \n", " for i ∈ 1:n_neurons\n", " s = spike_train[spike_train.Neuron .== (i-1), \"Time\"]\n", " timeseries, _ = np.histogram(s, bins)\n", " idx_low = round(Int64, (i-1)*duration/n_bins + 1)\n", " idx_high = round(Int64, i*duration/n_bins)\n", " convolved_series[idx_low:idx_high] = np.convolve(timeseries, triangular_kernel, \"same\") #TODO: consider scipy.signal.fftconvolve as alt.\n", " end\n", " LFP = makechunks(convolved_series, n_neurons)\n", " return sum(LFP)\n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[111.0, 143.0, 125.0, 97.0, 83.0, 86.0, 97.0, 97.0, 93.0, 55.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[50.0, 84.0, 110.0, 119.0, 121.0, 108.0, 91.0, 60.0, 35.0, 13.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[22.0, 34.0, 42.0, 40.0, 31.0, 29.0, 35.0, 43.0, 33.0, 17.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[91.0, 101.0, 87.0, 65.0, 48.0, 43.0, 36.0, 30.0, 16.0, 6.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[50.0, 77.0, 95.0, 107.0, 99.0, 98.0, 100.0, 101.0, 75.0, 37.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "6\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[25.0, 27.0, 23.0, 18.0, 29.0, 62.0, 113.0, 142.0, 133.0, 75.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[30.0, 50.0, 70.0, 79.0, 75.0, 64.0, 59.0, 55.0, 45.0, 24.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "8\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[83.0, 110.0, 125.0, 134.0, 134.0, 128.0, 115.0, 96.0, 69.0, 34.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "9\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[75.0, 106.0, 116.0, 124.0, 121.0, 127.0, 128.0, 125.0, 103.0, 57.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[38.0, 43.0, 46.0, 46.0, 50.0, 66.0, 77.0, 83.0, 63.0, 34.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "11\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[77.0, 105.0, 105.0, 76.0, 55.0, 48.0, 54.0, 53.0, 44.0, 24.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "12\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[64.0, 86.0, 87.0, 72.0, 54.0, 45.0, 39.0, 36.0, 26.0, 14.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "13\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[35.0, 55.0, 75.0, 109.0, 144.0, 178.0, 183.0, 146.0, 91.0, 36.0]]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "14\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[109.0, 145.0, 140.0, 112.0, 87.0, 74.0, 67.0, 51.0, 38.0, 18.0]]\n" ] }, { "data": { "text/plain": [ "14-element Vector{Any}:\n", " [485.0, 520.0, 353.0, 174.0, 74.0, 72.0, 72.0, 66.0, 46.0, 22.0]\n", " [530.0, 579.0, 403.0, 201.0, 87.0, 88.0, 101.0, 100.0, 76.0, 38.0]\n", " [465.0, 491.0, 332.0, 157.0, 73.0, 75.0, 80.0, 69.0, 53.0, 27.0]\n", " [499.0, 537.0, 360.0, 159.0, 49.0, 48.0, 54.0, 51.0, 35.0, 17.0]\n", " [446.0, 504.0, 342.0, 171.0, 57.0, 58.0, 66.0, 68.0, 52.0, 25.0]\n", " [542.0, 604.0, 406.0, 189.0, 60.0, 62.0, 78.0, 79.0, 66.0, 34.0]\n", " [457.0, 521.0, 369.0, 200.0, 87.0, 80.0, 73.0, 64.0, 39.0, 17.0]\n", " [555.0, 632.0, 436.0, 230.0, 99.0, 92.0, 75.0, 53.0, 30.0, 13.0]\n", " [535.0, 575.0, 403.0, 206.0, 108.0, 112.0, 112.0, 89.0, 58.0, 26.0]\n", " [471.0, 524.0, 355.0, 170.0, 56.0, 50.0, 53.0, 46.0, 33.0, 14.0]\n", " [519.0, 589.0, 428.0, 233.0, 103.0, 86.0, 85.0, 81.0, 64.0, 33.0]\n", " [464.0, 507.0, 359.0, 183.0, 80.0, 67.0, 67.0, 61.0, 44.0, 21.0]\n", " [491.0, 536.0, 365.0, 181.0, 67.0, 61.0, 60.0, 57.0, 46.0, 24.0]\n", " [463.0, 509.0, 352.0, 180.0, 85.0, 86.0, 83.0, 69.0, 48.0, 24.0]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "hcctrl_m = OrderedDict(0=>[], 1=>[], 2=>[], 3=>[], 4=>[], 5=>[])\n", "hcctrl_se = OrderedDict(0=>[], 1=>[], 2=>[], 3=>[], 4=>[], 5=>[])\n", "hclitm_m = OrderedDict(0=>[], 1=>[], 2=>[], 3=>[], 4=>[], 5=>[])\n", "hclitm_se = OrderedDict(0=>[], 1=>[], 2=>[], 3=>[], 4=>[], 5=>[])\n", "\n", "#n_patterns = 0:24\n", "n_patterns=0:24\n", "lamellae = 3:3\n", "runs = 1:14 #actual 14\n", "n_runs = length(runs)\n", "conditions = [\"HC_CTRL\", \"HC_LITM\"]\n", "\n", "\n", "hccrm_sv = []\n", "hccac_sv = []\n", "hclrm_sv = []\n", "hclac_sv = []\n", "\n", "spont_hcc = DataFrame()\n", "spont_hcl = DataFrame()\n", "\n", "for run ∈ runs\n", " df = []\n", " df2 = []\n", " hcc_rm = []\n", " hcl_rm = []\n", " hcc_ac = []\n", " hcl_ac = []\n", "\n", " println(run)\n", " \n", " for condition ∈ conditions\n", "\n", " for pattern ∈ n_patterns\n", " for lamella ∈ lamellae \n", "\n", " neuronnumb = 500 + lamella\n", " confile = load_connectivity_file(condition, run)\n", " gc_save = isolate_gclamellae(confile, lamella)\n", "\n", " duration = 200\n", " spikes = load_spike_files(n_patterns, condition*\"-\"*string(run), populations)\n", "\n", " gcspikes = spikes[(spikes.Population .== \"DG\") .& (spikes.Pattern .== pattern), :]\n", " spont = spikes[(spikes.Population .== \"Spont\") .& (spikes.Pattern .== pattern), :]\n", "\n", " lam1spikes = gcspikes[findall(in(gc_save[\"Lamella1\"]), gcspikes.Neuron), :]\n", " lam1spont = spont[findall(in(gc_save[\"Lamella1\"]), spont.Neuron), :]\n", " sponts = sort!(lam1spont)\n", "\n", " bc_0 = spikes[(spikes.Population .== \"BC\") .&(spikes.Neuron .== neuronnumb) .&(spikes.Pattern .== pattern), :]\n", "\n", " # TODO: \n", " # -- [X] Isolate the GC activated by spontaneous spike \n", " # -- [X] Isolate the remaining GCs \n", " # -- [] write code that computes activity level per unit time (will have to be average across SA instances to begin with) \n", "\n", " # Isolate GC activated by spontaneous spike \n", " gcsspont = lam1spont.Neuron\n", " lam1spike_postsa = lam1spikes[findall(in(gcsspont), lam1spikes.Neuron), :]\n", "\n", " lam1spike_remain = lam1spikes\n", " for x ∈ 1:length(gcsspont)\n", " lam1spike_remain = lam1spike_remain[(lam1spike_remain.Neuron .!= gcsspont[x]), :]\n", " end\n", " \n", " # remaining GC spikes post spontaneous activation (not directly attached to GC getting activated)\n", " for spont in 1:length(sponts.Neuron)\n", " \n", " starttime = lam1spont[spont,\"Time\"]\n", " timelimit = lam1spont[spont,\"Time\"] + 10\n", "\n", " spikeinlim = lam1spike_remain\n", " postspike = lam1spike_postsa\n", "\n", " for x in 1:length(lam1spike_postsa[:,\"Time\"])\n", " if lam1spike_postsa[x, \"Time\"] .> starttime && lam1spike_postsa[x, \"Time\"] .<= timelimit\n", " #println(lam1spike_remain[x, :])\n", " timepost = lam1spike_postsa[x, \"Time\"] - starttime\n", " postspike[x,\"Time\"] = timepost\n", "\n", " #df2 = [df2; [Vector(postspike[x, :])]]\n", " append!(df2,[Vector(postspike[x, :])])\n", " end\n", " end\n", "\n", "\n", " for x in 1:length(lam1spike_remain[:,\"Time\"])\n", " if lam1spike_remain[x, \"Time\"] .> starttime && lam1spike_remain[x, \"Time\"] .<= timelimit\n", " #println(lam1spike_remain[x, :])\n", " timepost = lam1spike_remain[x, \"Time\"] - starttime\n", " spikeinlim[x,\"Time\"] = timepost\n", "\n", " #df = [df; [Vector(spikeinlim[x, :])]]\n", " append!(df, [Vector(spikeinlim[x, :])])\n", " end\n", " end\n", " #println(df)\n", " end\n", " #return sponts\n", " end\n", " end\n", "\n", " if condition == conditions[1]\n", " #print(\"hello\")\n", " hcc_rm = stack(df, dims=1)\n", " #println(df)\n", " hcc_rm = DataFrame(hcc_rm, [:Time, :Neuron, :Population, :Pattern, :NeuronsPerPattern, :Model])\n", " hccrm = [compute_aggregate_WTA(hcc_rm, 500)]\n", " println(hccrm)\n", " hccrm_sv = append!(hccrm_sv, hccrm)\n", " \n", " hcc_ac = stack(df2, dims=1)\n", " hcc_ac = DataFrame(hcc_ac, [:Time, :Neuron, :Population, :Pattern, :NeuronsPerPattern, :Model])\n", " hccac = [compute_aggregate_WTA(hcc_ac, 500)]\n", " hccac_sv = append!(hccac_sv, hccac)\n", " \n", " #spont_hcc = sponts\n", " else\n", " #println(\"goodbye\")\n", " hcl_rm = stack(df, dims=1)\n", " hcl_rm = DataFrame(hcl_rm, [:Time, :Neuron, :Population, :Pattern, :NeuronsPerPattern, :Model])\n", " hclrm = [compute_aggregate_WTA(hcl_rm, 500)]\n", " hclrm_sv = append!(hclrm_sv, hclrm)\n", " \n", " hcl_ac = stack(df2, dims=1)\n", " hcl_ac = DataFrame(hcl_ac, [:Time, :Neuron, :Population, :Pattern, :NeuronsPerPattern, :Model])\n", " hclac = [compute_aggregate_WTA(hcl_ac, 500)]\n", " hclac_sv = append!(hclac_sv, hclac)\n", " \n", " #spont_hcl = sponts\n", " end\n", " \n", " end\n", "\n", "end\n", "\n", "return hccrm_sv \n", "return hccac_sv\n", "\n", "return hclrm_sv\n", "return hclac_sv\n" ] }, { "cell_type": "code", "execution_count": 601, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "spont_hcc[!, \"Time\"] == spont_hcl[!, \"Time\"] #solid" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10-element Vector{Float64}:\n", " 290.07142857142856\n", " 296.5\n", " 198.21428571428572\n", " 94.21428571428571\n", " 45.214285714285715\n", " 46.57142857142857\n", " 47.642857142857146\n", " 42.0\n", " 30.071428571428573\n", " 14.428571428571429" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# transform those ugly dfs into something actually usable \n", "mean(hccac_sv)\n" ] }, { "cell_type": "code", "execution_count": 629, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "compute_aggregate_WTA (generic function with 1 method)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Dict{Symbol, Any} with 3 entries:\n", " :scalefontsizes => 20\n", " :theme => :default\n", " :fontfamily => \"DejaVu Sans\"" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "const PLOTS_DEFAULTS = Dict(\n", " :theme =>:default,\n", " :fontfamily => \"DejaVu Sans\",\n", " :scalefontsizes => 20\n", ")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"/Users/selenasingh/Desktop/spiketrainBDDG/wSA/figures/wta/aggregate_timeseries_hc_rm_l3_cosyne.png\"" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "\n", "sumfig = plot(mean(hccrm_sv), yerror=(std(hccrm_sv)/sqrt(n_runs)), label = \"CTRL\", color = :black, msc=:black, linewidth = 3)\n", "plot!(mean(hclrm_sv), yerror=(std(hclrm_sv)/sqrt(n_runs)), label = \"LITM\", color = :grey70, msc=:grey70,\n", " xlabel = \"Time Post-SS (ms)\",\n", " ylabel = \"RM Population Activity\", grid = false, size=(300, 300), dpi=300, fontfamily = \"DejaVu Sans\", linewidth = 3)\n", "\n", "savefig(sumfig, \"figures/wta/aggregate_timeseries_hc_rm_l3_cosyne.png\")\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"/Users/selenasingh/Desktop/spiketrainBDDG/wSA/figures/wta/aggregate_timeseries_hc_ac_l3_cosyne.png\"" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "sumfig = plot(mean(hccac_sv), yerror=(std(hccac_sv)/sqrt(n_runs)), label = \"CTRL\", color = :black, msc=:black, linewidth = 3)\n", "plot!(mean(hclac_sv), yerror=(std(hclac_sv)/sqrt(n_runs)), label = \"LITM\", color = :grey70, msc=:grey70,\n", " xlabel = \"Time Post-SS (ms)\",\n", " ylabel = \"AC Population Activity\", grid = false, size=(300, 300), dpi=300, fontfamily = \"DejaVu Sans\", linewidth = 3)\n", "\n", "savefig(sumfig, \"figures/wta/aggregate_timeseries_hc_ac_l3_cosyne.png\")\n" ] }, { "cell_type": "code", "execution_count": 500, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABLAAAAQaCAIAAADcxBYQAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeUBU9f7/8QMDw76KgCIqiICIKy433M0l9yW360aZW92vlV5Tb5rZreuW7d+rRmkakWZXTXPJQkuu11zCLRMVU0EBFdmRHeb3x/ndk18zGWBmPjNzno+/3gfHOS8UcV6cM5+PjU6nkwAAAAAA6mMrOgAAAAAAQAwKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSFMKHq6ioqKioEJ0CAAAAAIyIQvgQly5dCgwMbNSo0dmzZ0VnAQAAAABjsRMdwBzt3r379u3bkiTt2LGjXbt2ouMAMJ3U1NTdu3fLs5OT0/Tp08XmAQAAMCoK4UMoN4tWVlaKTQLAxNLT0zdv3izPXl5eFEIAAGDdKIQAAAAATG3y5MkZGRnyvGTJkr59+4rNo1oUQgAAAACmdu/evYKCAnnmvjyBWFQGAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSbDthUvfu3Rs2bJhyGBcXFxAQIDAPUGf//ve/X331VXn29fXdunWr2DwALM6hQ4feeOMNeW7cuPFnn30mNo8FOX/+/PPPPy/P9vb2Bw4cEJsHgEWjEJqUTqdTtluRJKmqqkpgGKA+KioqlC9mZ2dnsWEAWKLKykrl24iHh4fYMJalqqpK+aPTarViwwCwdNwyCgAAAAAqRSEEAAAAAJWiEAIAAACASlEIAQAAAEClKIQAAAAAoFIUQgAAAABQKbadqMHu3bs3bNggz61bt16+fLnYPIo9e/Z89NFH8hweHr5q1SqxeQAAQFpa2pw5c5TDL7/8km0hzNbRo0eVl0++vr7KyyrUaPbs2ZmZmfI8f/78Hj16iM2DeqIQ1qCwsDA9PV2e/fz8xIa5X1FRkRKsQYMGYsMAAABJkiorK5X/nSVJ0ul0AsPg0UpLS5W/rOrqarFhLMvt27eVP7qSkhKxYVB/3DIKAAAAACpFIQQAAAAAlaIQAgAAAIBK8R5C83L58uUDBw7Is5eX1+TJk8XmAQAYUGxsbFlZmTyPHDkyMDBQbB4AgEEkJycnJCTIc4MGDSZOnCg2T61QCM3Lr7/+unnzZnlu1qwZhRAArMmWLVsKCwvluWvXrhRCALAOV65cUV7Dt2jRwrIKIbeMAgAAAIBKcYUQAH7j4+PTr18/eXZxcREbBoAlqqqqSktLk+enn376gw8+YHcooA4yMzMXLFigHH700UeOjo4C81gxCiEA/CY0NHTlypWiUwCwYDqdrrS0VJ4vXbpUUVEhNg9gocrLy5OTk5VD9oo0Hm4ZBQAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSLCoDAAAAwNTi4uKUpWKcnJzEhlEzCiEAAAAAU3N1dRUdAZLELaMAAAAAoFoUQgAAAABQKW4ZBQAAAGBeqqurq6qqlEOdTicwjHWjEAIAAAAwL5mZmZcvX1YOS0pKXFxcBOaxYtwyCgAAAAAqRSEEAAAAAJXillGTcnFxOXTokHLIYruwXD179lS+mG1t+dESgFrr06cP30bqJjIy8v6XEwBQHxRCk7KxsXF3dxedAjAAOzs7vpgB1Ie9vb29vb3oFBZJo9HwHRiAofADOQAAAABQKQohAAAAAKgUt4xCXUpLS8vLy+VZq9U6OjqKzQMAAACzUlhYqGx76OzsbGdn5Y3Jyj894AHvvPPO9u3b5XnkyJFLliwRmwcAAABmZdSoUXl5efL8/vvvR0dHi81jbNwyCgAAAAAqRSEEAAAAAJXiltEajBgxonfv3vKs1WqFZvk/hg4d2qNHD3k2q2AAAKhWYGBgfHz8xIkT5UMbGxuxefAIjz322K5du+RZo9GIDWNZ1q9fX1lZKc9eXl5iw6D+KIQ1cHV1Nc/t4802GAAAqmVvb9+oUSP2V7QITk5OAQEBolNYJD8/P9ERYEjcMgoAAAAAKkUhBAAAAACVohACAAAAgErxHkLzEhYWNmfOHHl2d3cXGwYAYFgzZsyoqKiQ5yZNmogNAwAwlFatWimv4T09PcWGqS0KoXkJDg4ODg4WnQIAYBTK4pMAAGsSEhISEhIiOkUdUQgBlTp16lROTo48h4SENG/eXGgcAAAACEAhBFRqw4YNx48fl+e//OUvTz/9tNg8AGAdPDw84uLilMMGDRoIDANYLl9f36CgIOXQ0dFRYBjrRiEEAAAwGI1G06pVK9EpAItnb29/fwm0tWUtTGPhTxYAAAAAVIpCCAAAAAAqRSEEAAAAAJXiPYQA8JujR48+//zz8uzl5fXdd9+JzQMAgDqlp6cnJycrh8XFxc7OzgLzWDGuEAIAAACASnGFEIBZu3z5cl5enjw3bty4SZMmYvMAAABzkJmZeePGDXl2c3Njdd86oxACMGvr169PTEyU5xkzZsyaNUtsHgAAYA4OHjz47rvvynPHjh1jY2PF5rFc3DIKAAAAACrFFUIAAAAAprZu3brc3Fx5HjlyZERExP2/amtrq9FoRORSHQohAAAAAFP79ttvlTcBdurU6YFC2KhRo9DQUOWQJUaNh1tGAQAAAEClKIQAAAAAoFIUQgAAAABQKQohAAAAAKgUhRAAAAAAVIpCCAAAAAAqxbYTUBdHR0d3d3dlFhsGAAAA5sbNza26ulqe7eysvy5Z/2cI3G/u3Llz584VnQIAAABmaufOnaIjmBS3jAIAAACASnGFEAAAAICpnTlzJi8vT57Pnz8/YMAAsXlUi0IIAAAAwNTKysrKy8uVWWwYNeOWUQAAAABQKQohAAAAAKgUhRAAAAAAVIpCCAAAAAAqRSEEAAAAAJWiEAIAAACASrHtBKBSHTt2dHNzk+egoCCxYfR34MCBtWvXynOLFi3efvttsXkAAIAQp06d+vXXX+W5qqpKbBiLRiEEVOqZZ54RHaEu7t27l56eLs/u7u5iwwAAAFFKSkqUbQxLS0vFhrFo3DIKAAAAACpFIQQAAAAAlaIQAgAAAIBK8R5CAAAAABYmNze3srJSnu/duyc2jEWjEALAb6Kjo3/66SfRKQAAULtmzZo9+n/krKwspRAWFhaaJJR14pZRAAAAAFAprhDCOhUWFj733HPK4dtvv92wYUOBeVBnoaGhylrSAQEBygLTAAAY1r/+9a9du3bJc1RU1Isvvig2Dx7NxcXF1vb/X9zSarViw1g0CiGsU1VVVXJysnJYUVEhMAzqY/bs2fcf7tixQ1QSAIB1y8rKUl48+Pn5iQ2DGgUEBCg90NvbW2wYi0YhBAAAMC8ZGRk6nU6efXx8HBwcxOaBGaqurs7MzFQO/f39NRqNwDywXBRCAAAA8zJp0iRlkYy1a9d26dJFbB6Yodzc3BEjRiiH+/bt8/X1FZinDoKCgm7fvi3PzZo1ExtGzSiEAAAAAEzN19e3rKxMnn18fMSGUTNWGQUAAAAAlaIQAgAAAIBKUQgBAAAAQKUohAAAAACgUhRCAAAAAFApCiEAAAAAC1NdXf3QGbXFthMAAAAALMyVK1dKS0vl+c6dO2LDWDSuEAIAAACASlEIAQAAAECluGUUAAAAgKmtX7++srJSnr28vMSGUTMKIQAAAABT8/PzEx0BksQtowAAAACgWjVcIczNzU1KStLriezsOnbs6O7u/tBfvXXrVnJysp+fX0BAgIeHR61jAgAAAAAMrYZC+MMPP4wePVrP59q4cePTTz/90F9aunTpRx99JEmSra1t586dR4wYMW3aNC4TAwAAAIBANdwyOmrUqO3btzds2PCPHmBvb9+5c+fZs2dv2LBh1KhRf/Sw2NjY/Pz8pKSk+Pj4sLCw1atXh4SELF26tKioqO7ZAQAAAAD1UPOiMqNHj+7WrdusWbN27dp1/8e7d+8+derUJ5980tvbW58zubu7d+zYsWPHjhMmTCgvL4+NjV22bNm2bdt27NgRERFRx/gAAAAAgLrSa5VRPz+/r7766qOPPpo5c6YkSR06dFi5cuWAAQPqfFatVvs///M/kyZNmjRpUteuXbdu3TpkyJA6P5s6paWlXb58WZ49PDw6d+4sNg+sw/1fV15eXlFRUWLzAIAQSUlJubm58hwaGtq0aVOxeYBHq6qqSkxM9PT0lCTJ1ta2b9++ohPBkui77UR1dfXBgwclSZo7d+7q1avt7AywX4WXl9fu3btnzZo1duzYhISE6Ojo+j+nehw9enTNmjXy3LZtWwohDCIxMfHdd9+V544dO8bGxorN83sDBw7s2rWrPNvb24sNA8Baffjhh6dOnZLnuXPnTpo0SWwe4NHKysreeOMN+fW5g4ODSgphUFDQjz/+KM+PeIMbaqRvr5s3b962bds2bNgwbdo0Q57ezi42NjYtLW348OE//fRT8+bNDfjkAKyPi4uLi4uL6BQAAEAwe3t7GxsbedZoNGLDWDS9CuG2bdvee++9NWvWGLYNyjQazeeff96mTZsFCxZs27bN4M8PmLPy8vKlS5cqh/PmzfP19RWY59KlS+np6fLs7OwsMAnq4O7du8qNA5IkLVu2zNHRUWAeAACszMKFCxMTE+U5Ojr6rbfeEpvHIGouhGVlZfPmzRswYMBf//pXI4Vo2LDhyy+//OKLLx49epQbR6EqVVVVCQkJyuGsWbMEhpEk6e7duwUFBfKclZUlNgxqq7i4+P4vpyVLlggMAwCA9UlKSjp37pw8W81bV2rYdkKSpPj4+Fu3br333ntGzTFr1qyGDRvKexUCAAAAAEyg5iuEGzZs6NGjR3h4uFFzODg4DBo0aO/evdXV1ba2NddUAAAAAKrVpEmTBg0ayHNgYKDYMBathup19+7d48ePjxgxwgRR+vfvn5WVdfbsWROcCwAAAIDlatasme9/sTJlfdRQCE+ePFlVVdWyZUsTRJE3+blx44YJzgUAAAAAqOGW0Vu3bkmS5OfnZ4Io8v4h8hmBenJzc4uLi1MO2Z0GAAA82pgxY3r37i3Pbm5uQrMAplNDIczLy5MkqaioyARR5LUN8/PzTXAuWD2NRtOqVSvRKQAAgMVo2LAhP0GGCtVQCJ2cnCRJUvYlM6qbN29KksSW0wAAQOUaNWrk7u4uzw4ODmLDwDzZ2toGBATIc35+vnwVB6iDGgqhvEd2SkqKCaLIZ+EHMwAAQOU+//xz0RFg7ry8vHbt2iXPp0+fnjFjhtg8sFw1LCoTGhoqSdK+fftMEGX37t2SJJlmARsAAAAAQA1XCMPDw93d3U+ePJmUlBQVFWW8HOfOnfvxxx+dnZ0jIiKMdxYAAAAA5u/GjRsxMTHK4Z49e5ydnQXmsWI1XCG0s7OTV1tasWKFUXOsWLFCp9P16tVLq9Ua9UQAAAAAzFx1dXXBfUTHsWY1FEJJkiZOnChJ0vbt2/fv32+kEIcOHfriiy8kSfrzn/9spFMAAAAAAB5QcyEcOXJk48aNJUmaNWtWdna2wRPk5eVNnz5dp9P5+PiMHj3a4M8PAAAAAHiomguhg4PDokWLJEm6cePGE088Ydh9AouLi4cOHXrt2jVJkl566SX2nAAAAAAAk6lhURnZ7NmzN2zYcPbs2Z9++ql///7bt28PDAys/7nv3Lkzfvz4//znP5IkhYaGvvDCC/V/TgAAAPyRTz/9VN75WZKk/v37d+7cWWweoM60Wq2yXSdXlepDr0Job2//ySefREdHl5aWnjx5sl27dsuWLZsxY4a8bX0dlJeXb968efHixVlZWfLzb9iwgX1XAQAAjOqHH344d+6cPAcHB1MIYbnGjRs3btw40SmsQc23jMo6dOiwfv16ec7NzX3hhReaNGkyf/782u5Zn5qaunjx4qZNm86cOVNug5IkrV69unv37rV6HgAAAABAPel1hVAWExNz69Yt+f2EkiTl5OS89dZbb731Vtu2bfv37x8VFRUREdGgQQNvb29lk5CSkpLc3Nzs7Ozk5OSffvrp4MGDZ86cqa6uvv9p582b9+KLLxrq8wEAAAAA6KkWhVCSpIULF2o0mgULFuh0OuWD586dU+49kDk4ODg7O5eUlJSWlj76CV966aVVq1bVKgMAAAAAwCD0vWVUMX/+/G3btinv4HyosrKy3NzcR7dBJyen2NjY1atX29jY1DYDAAAAAKD+al0IJUkaM2bMqVOn+vbtW+ezdu3a9fjx4zNmzKjzMwAAAAAA6qkuhVCSpBYtWhw8eHDHjh1RUVG1+o2RkZGfffbZjz/+2KZNm7qdGgAAAABgELV7D+EDRo0aNWrUqKNHj37xxRcHDhy4dOnSHz0yJCSkf//+48eP79mzJ/eIAgAAAIA5qFchlEVHR0dHR0uSdPfu3eTk5GvXrhUUFNy7d8/FxcXNzS0oKCgsLMzPz6/+JwIAAAAAGJABCqHCx8enR48ePXr0MOBzAgAAAACMxJCFEKbUtGnTfv36yXOzZs3EhoHV8PHxUdYQbtiwodgwACBKVFSUt7e3PDdt2lRsGKBGnp6eystCe3t7sWFgcSiElkq5UxcwoLCwsICAAHkODw8XGwYARJk1a5boCEAtBAUFrVy5UnQKWKo6rjIKAAAAALB0prhCmJ+fr9FoXF1dTXAuwLJotdr7f6Tn6+srMIwkST179vT395dnLy8vsWFQWz4+Pvd/OTk6OgoMAwCA9Zk3b9758+fl2WrupTJFIYyIiGjbtu3+/ftNcC7Asmg0GuWmf3PQtGlT3i1juZydnc3qywkAACszePDgwYMHi05hYKYohFqttrCw0AQnAgAA1m3Pnj3Xrl2T5y5dunTt2lVsHgCwdCYqhBcvXqyurra15S2LAACg7g4dOpSYmCjPWq2WQggA9VRDIbxy5crevXtLS0trfCJnZ+cRI0Y89GYzBweH7Ozsvn379urVy9nZ+Y+ewcPDY8qUKS4uLjWeCwAAAABQfzUUwps3by5cuLCsrEyf5/Lw8Jg6dervP67VaiVJOnz48OHDhx/x2729vceMGUMhtFYpKSl///vf5dnOzu6TTz4xzXnj4uK+/fZbee7evTsriT/avn37tmzZIs/h4eGLFy8Wm+f3Dh06pHzxBAUFKV9UAH5v3rx5WVlZ8jxnzpwuXbqIzQMAMEM1FMLevXsfO3YsJibm3LlzD31A06ZNe/fuHRUV1bVr106dOj30MXIhfDRnZ+edO3f6+PjU+EhYqJKSkuTkZHk25Zapt2/fVs4bHBxssvNaqJycHOWPy8nJSWyYh8rLy1MSAni0K1euZGRkyHNBQYHYMAAA81Tzewjbt29/8uTJZcuWrV69uqqqSv6gvb19TEzM1KlTu3fvbmNj8+hn0Gg0j36Aj4/Pzp07u3fvrmdoAHVTWVl5+/Zt5bBRo0a8sxcAAEDN9FpURqvVLl++vFu3bkOHDpUk6cknn1y5cmVISIie56isrHz0A1599VXaIGAC6enpTz75pHKYmJj4iLf1AgAAwOrpu8rovXv3Xn/9da1W++677z777LO1OodcCCdMmBATE9OwYUP5gzqdLjMz8/Tp02vXrp0zZ05ubu4rr7xSq6cFAAAAANSHvoUwJibm9OnTe/bs6d+/f23PUVFRYWdnFxsb6+bm9sAvDRs27KWXXpo6derSpUtbtWo1ZsyY2j45rN6nn36q0+nkefDgwcrPFAAA9/vyyy+Li4vluU+fPg9d9xs1On78+MWLF+U5JCSkW7duYvPAgLKysvbt2yfPNjY2D10KEVAhvQrh+vXrd+zY8fnnn9ehDUqSVFFRERER8fs2KHNyctqyZcvt27eff/75IUOGmOc6FhBo7dq1yl3HHTp0oBACwEN98sknd+7ckefmzZtTCOvm8OHD27Ztk+dhw4ZRCK1JZmbmBx98IM92dnYUQjMXGBh46NAh5ZCOYDw1ryeRmZn50ksvTZgwYcKECXU7R2VlpYeHxyMeYGdnt2bNmszMzPj4+LqdAgAAAIDVsLW1db9PjctYos5qvkL45ptvlpeXv/nmm3U+R0VFRY27C3bp0iUsLOyrr76aPn16nU8E4NHu3Llz7do15bC0tJRFZQAAEOLgwYObNm2S5+Dg4Ndee8005z1//vyqVavk2cXFZf369aY5L8xWDYWwurr6iy++6NevX0BAQJ3PUVFRoc9WhEOGDFm3bl1xcTGvUAEjqaioKC0tVQ6rq6sFhgEAQM3u3/vXlLtA3bt3Tzmvu7u7yc4Ls1XDF9/ly5czMjKGDRtWn3MMGjRIn1vwe/XqVVJScubMmfqcCxkZGen/VVZWJjoOAAAAAPNVwxXCs2fPSpIUFBRUn3PExsbq8zD5ImRmZmZ9zoU///nP9+7dk+d169Z17txZbB4AAGA+YmJisrOz5bldu3ZiwwAwBzUUQvlbhmnWdZTfZ3jr1i0TnAsAAECFevXqJToCAPNSQyGU7zlUfpJkVHIVLCkpMcG5AEDNrl+/furUKXn29PTs27ev2DwAHmrHjh3K3KdPHy8vL4FhAFirGgqhfNUuPT3dBFEyMjIkSXJ1dTXBuQBAzU6fPr18+XJ5DgsLoxAC5mnFihU6nU6ew8PDKYQAjKGGRWX8/f0lSbpw4YIJosg/rm7UqJEJzgUAAAAAqOEKYVhYmCRJX3/99erVq42aQ6fT7dy5U5Kk0NBQo54IAAB1ysnJWbJkiXK4atUqNzc3gXkAQKALFy787//+rzy7uroau+yYsxoKYWhoqI+Pz8WLFxMSEvr162e8HLt377569aq3t7dcQQEAgGGVl5efOHFCOayoqBAYBgDEysvLU74lenp6ig0jVg23jNrY2Mg9UHm3iTFUV1evWLFCkqTHH3/clPtyAmrzwE70yltThCgqKir4r8rKSoFJAAhRUVGhfBMoKioSHQcAVKrm9jVp0iRJkr7//vvPPvvMSCHWrVt3/Phx5VwAjOTOnTul/5fAMKNHj+77X8eOHROYBIAQ33//vfJNYMqUKaLjAIBK1VwIBw0a1LJlS0mSXnzxxbS0NIMnuHjx4t/+9jdJkpo3bz548GCDPz8AAAAA4KFqeA+hJEkajWbJkiUxMTHZ2dn9+vVLTEyUlx41iBs3bgwcOLCwsFCSpMWLF9vb2xvqmQH8XklJyf23iVZVVQkMAwCwbomJiXfv3pXntm3bhoSEiM0D4KFqLoSSJE2ZMmXDhg2JiYkpKSm9e/fevn1769at63/u06dPjx07Vr7q2LVr12nTptX/OQE8QlFR0f2FsLy8XGAYAIB1i4uLO336tDzPmzePQgiYJ71WcLGxsdm4caO8/M6lS5c6deq0ePHirKysOp81MzNz/vz5Xbt2/fXXXyVJcnV13bhxI8vJAAAAAIAp6XWFUJKkFi1afPrpp6NGjaqqqiotLV2+fPlbb701ZsyYZ599Njo62sbGRp8nqa6uPnLkyNq1a3fs2KGsdm1ra7tx48aIiIg6fgbW5eTJk5988ok8+/n5vfrqq2LzADCl3bt3f/PNN/Lcvn37mTNnis0DAEBt3b59+7XXXlMO33nnHQcHB4F5UCN9C6EkScOGDYuNjZ0+fbp8y1lZWVl8fHx8fLyvr+/jjz/esWPH1q1be3l5eXt7e3l5ubm5FRQU5Obm5ubm5uTknD9/Pikp6dChQ8qt5Ip333137NixhvycLNndu3eVHVGaNWsmNgwAE7t586byHcDFxUVsGAAA6qCkpOT+LU9ZsMD81aIQSpI0bdo0e3v7Z5555v7dbO/cubNly5YtW7bU9twajeb9999/7rnnavsbAQAAAAD1V7tCKEnSlClTmjRpMmnSpMzMzPqc2NfX97PPPuvfv399ngQAAKjK0KFD27VrJ8/KAACos1oXQkmS+vTpc+bMmblz527ZsuX+FQv1ZGNjM27cuHfffdeA21cAAAA16Nu3r+gIAGBV6lIIJUny9fWNj4//n//5n+XLl+/du1fPWmhjYzN48OCXX345Ojq6bufF+fPnb926Jc9NmzYNDQ0VmwfqcevWrfPnz8uzs7Mz/4oBAACsQB0Loeyxxx77+uuvr1+/vm3btm+++eb48ePFxcW/f5iLi0uXLl0GDhw4bty4oKCg+pwRW7duVRYhnDRpkgUVwpCQkLi4OHnWc1lag5gyZcqQIUPk2cPDw2TntVCDBw+OioqS5wcWNTlz5sySJUvkuWnTpjt27DB1OEmSJKlPnz6tWrWSZ0dHRyEZAEvxzjvvKNuNBgQEPPT/aACAytWrEMqaN2++YMGCBQsWVFZWpqWlpaWlZWdnV1dX29ra+vj4NG3aNDAw0M7OACeCRXN2dlZex5uSn5+fn5+f6c9roby9vb29vUWneBQvLy8vLy/RKQDL0KJFi/sPKYQAgN8zZE+zs7MLDg4ODg424HOqRFFR0RtvvCFJ0tWrV9PT0/39/TUajehQ5uLGjRvV1dXynJmZ2bZtW7F56mndunWpqanyPHz4cBPfeKnRaO6/PGvKS7X198033/zwww/y3KZNm0mTJgmNA9RRbGzs1atX5Xnw4ME9e/YUmwcAauvw4cP79++X5xYtWsyYMUNsHkNJTU1dt26dPNvZ2ckvztWAC3dmoby8PCEhQZKk/Pz8goICX19fCqGioKBAKYSFhYViw9TfyZMnz507J8/t27c3cSH09va+vwRa1i2XV65ckf+ZSJKk0+kohLBQSUlJSUlJ8ty6dWuxYQCgDq5fv678j1xQUCA2jAHl5eUpn5dWqxUbxpRsRQcAAAAAACza/x8AACAASURBVIjBFUKYOx8fn6qqKnk287e3AYBAY8aMuXfvnjwHBgaKDWO5unbt6uTkJM9C3voO4/H19Y2JiZFnbsUCFBRCmDs/P7/Kykp59vHxERsGAMzWtGnTREewBr169erVq5foFDAKf3//OXPmiE4BmB0TFcKtW7fK79EcNGjQokWLTHNSAObj6NGjygqHbdq0YelXAABgYocPH66oqJBn5XoDTFQI09LSEhMTJUliH0JAoAYNGtz/JmkHBweTnfrNN9+8ceOGPC9fvnzAgAEmOzUAAGaoX79+kZGR8qzcqGwCkZGRytbQart19rXXXlNWwZk9e7bYMOaDW0YBFbG3t7e1/W0pqftnAABgSqJ21nVxceH9sbgfhdDaNG7cWLkxz5TXfwAAAABYHAqhtdmyZYvoCAAAAAAsAzeMAQAAAIBKcYUQgCXJz8+/fft2VlbWyZMnW7Zs+eGHH4pOZJGCgoJGjx4tz6z4CpitUaNGKbOnp6fAJACsGIUQgCXR6XRVVVXl5eUFBQXK22VRW+3bt2/fvr3oFABq8PLLL4uOAMD6UQhhMKdOnVJ2dAkPD3d3dxebBwAAAMCjUQhhMPPnz1e2dvnnP//ZtWtXsXkAAPfz9vZeu3atcujm5iYwDACIFRQUpHxLtLNTdSdS9ScPAIB6aLXaLl26iE4BAGbB1dWVb4kyCiHM1JEjRxITEyVJysjIsLe3F7Jzq/WxtbXVaDSiU/x/rq6uyj3GKv/JHKBOdnZ2ypsLXFxcxIYBYH1WrFih0+nk+amnnmrcuLHYPA/IyMjYtGmTPNvY2Pztb38TlYQXYTBTFy9e3LFjhyRJOTk5Li4uFEKDaNSoUWhoqHLo7OwsMIz89wtAtfr27du3b1/RKQBYrZ07d1ZXV8vz8OHDza0Q5uTkKK+FbG1tBRZC9iEEAAAAAJUy0RXCWbNmjR07VuIt7IBQbm5uyu5zEjdqAgCMqUePHkFBQfIcEhIiNgys1V/+8pfk5GR5fv7550eOHCk2jyUy0ctBDw8PDw8P05wLwB/x9vZmVysAgGlMnTpVdARYv+LiYmWV+/LycrFhLFTNt4ympKSsWrXq8uXLRs1x7dq1VatWXbp0yahnAQBIkpSXl5f8X9euXRMdBwAACFPzFcILFy4sWrSoZcuW969FYXApKSmLFi0KDw8PCwsz3lnMn4uLS9OmTVeuXNmgQQNHR0fRcQCY1PDhwzt16iTPRl1I6fvvv//HP/4hz2FhYfHx8cY7FwBAVfz8/O7f8pQXtOZP31tGS0tLjZqjuLhYkiStVmvUs5g/Ozs7Ozu7Dh06+Pv7i84CwNSaNGnSpEkT0SkAAKg7Jycn9vezLPoWwsLCQqPmkO/9tbe3N+pZABjPt99+q9z13b59+x49eojNYzLHjh07efKkPAcHBw8ZMkRsHgAAAP3pWwiV1XuMRH4dSSEELNe///3v/fv3y3NFRYV6CuHp06c3b94sz71796YQAgAAC6JvIfz888/79OnTqVMng+9kXVxcfPr06U2bNkkUQgAAAAAwIX0LYVZWlgm29eA9hDWKjIysrKyUZ6Mu8wM8wN/fv1+/fvLs4+MjNgwAAAAMwry2peYKYY0mTJgwYcIE0SmgRu3bt2/fvr3oFAAAADAk8yqEsGLFxcWpqanybGNjEx4eLjYPAPN09erVsrIyeW7UqJGnp6fYPAAAWLeaC6Epr9pVVFSY7FxmxdXVdeXKlcqhVb4AunLlyrRp0+TZ3t7+xx9/1PM3BgQERERE/OUvf5EkqVmzZsbKZyrPPvtsfn6+PHPTb6088cQT4eHhR44c+fzzz7mbwIotXrw4JSVFnpcuXTp8+HCxeQxu5syZubm58tyyZUuxYQCgDnr16hUQECDP3t7eYsMYULNmzZQX5La2tmLDmFLNhTA0NNTb29vb23v69OnDhw93cHAwbILCwsKzZ8/Onz8/KyurvLzcsE9uKbRarfLuLDzAzc0tMDDQav58OnfuLDqCpQoJCQkJCSkoKNizZ4/oLEDdRUVFiY4AAPXSvHnz5s2bi05heJ6enlbzgrNWai6EISEhV69ejY+P37Bhw5o1ayZPnjx9+vTWrVsbMES7du0uXry4YsUK1V4hBAAAAADT0+tiqIeHx3PPPZeUlHT48GEHB4fevXt36tTpvffey8nJMVSOVq1aSZKkrJ8JAAAAADC22t0dGxERsXLlyps3by5cuHDPnj2BgYHjxo1LSEjQ6XT1zOHm5iZJkmpvGQUAAAAA06vLKqMODg5jx44dO3bslStXNm7cGBMT4+HhMW3atKlTp/r6+tYth7zfPbeMAtYqOjo6Oztbnv39/cWGAQAAKtSrV6+SkhJ5tqblcOqpXttOhISELF++/PXXX9+3b9+GDRteffXVJ5544plnnhk4cKBGo6nVUwUFBS1cuDA4OLg+eQCYrZdeekl0BAAAoGqvvvqq6AjmyAD7EGo0mmHDhg0bNuzWrVtffPHFwoULZ8yYMWXKlBkzZrRo0ULPJ2nZsuX9+y7AahQXF8sLrN+5c6eystLOjq0vAfHKysqUOzJKS0vFhgEA0ygvL8/KypJnGxubxo0bi80DS3fr1q2qqip59vb2dnJyEpunzgz56tzf3/+FF1544YUXkpKSYmNjO3To0LZt26lTp06ePFm+IxQq9O23377xxhuSJJWUlNy6dSsoKEh0IgDSmTNnrly5Is8FBQViwwCAaVy8eFHZEtnOzu7YsWNi88DSzZw5MyMjQ55XrlxpuVtWGGXLxaioqA8//PDmzZtTp0799NNPGzduPGvWrFOnThnjXAAAAACAujFKIZS5u7vPnDnzyJEjR48e9fLyGjhwYOvWrVetWqUsLAEAAAAAEMiIhVChbFaxbNmyhIQEA25WAUBthg4deui/1q9fLzoOAACAZTNFIZTJm1V89913ly9fjoqKmj59elhY2LJly9LS0kyWAYCl02q17v/l4uIiOg4AAIBlM10hVDRp0mThwoUpKSmDBg167bXXWrRoMWLEiK+//rqystL0YWBAHTt27PJfHh4eouMAAAAAqIGAPQBSU1M/+eSTTZs2paamSpJUWVm5e/fu3bt3BwcHHzp0qFmzZqaPBINYs2aN6AgAAAAAasF0hbCsrGzXrl0bNmxISEiorq7+/QNcXFwcHBxMlgcAAAAAVM4UhTA5OXnz5s0bN25UNgO9n1arHTFixJQpUwYPHqzRaEyQBxahe/fu3t7e8uzv7y82DAAAACzL3/72N2UNy8aNG4sN83uNGzd++eWX5dnGxkZgEiMWwoKCgq+++iouLi4hIeGhD2jVqlVMTMy0adMaNmxovBiwUOHh4eHh4aJTAAAAwCKNGjVKdIRH8fb2Hj16tOgUkmSkQpiUlBQbG/v5558XFRX9/lfd3d1HjBgxderUfv36GePsAAAAAAB9GLIQ3rp164svvvj444/Pnz//0AdERUXNnDlz4sSJrq6uBjwvAAAAABX65z//qWxV4OjoKDaMhTJAIayqqvr+++9jY2O/+uqrioqK3z/A399/3Lhx06dPb9OmTf1PBwAAAACSJDk7O4uOYPHqVQhTUlLi4+M/+eSTh24ub2tr27dv35kzZ44cOdLe3r4+JwIAGJCLi4vyY1QXFxexYQAAgEB1KYSlpaVff/11bGzswYMHlaV77hcYGDhx4sRnn32WTQUBwAxFRkYGBQXJc1hYmNgwAABAINtaPfrEiROzZ8/28/MbN25cQkLCA23QyclpypQp33//fWpq6sqVK2vVBo8fP96/f/8jR47UKg8AAAAAoM70ukKYn5+/adOmDRs2/Pzzzw99QFRU1LRp0yZOnOjp6Vm3HNevX09ISHjhhRfq9tsBCNe/f/+QkBB5joiIEBvGlP70pz8pb2AIDAwUGwYAAKBWai6EmZmZnTp1ysjI+P0veXl5TZo06Zlnnmnfvn09c1y/fl2SJAcHh3o+DwBRevbs2bNnT9EpBOjQoUOHDh1EpwAAAKiLmgvhuXPnHmiDNjY2ffr0eeaZZ0aPHm2o1V1/+OEHSZK0Wq1Bng0AAFifvXv3lpWVyXO3bt38/PweeEBxcfE333yjHA4dOpSXFgDwaDUXwtLSUmVu0qTJU0899fTTTwcHBxswxMGDBw8cOCBRCAEAwB9755138vLy5Pn999//fSHMz89fvny5ctinTx9eWgDAo+m7yqiTk9P48eMHDhyo0WiSkpKSkpLqf26dTnf37t1jx45t3bpVXp+GW0YBAAAAwGT0LYQlJSWbNm3atGmTMcNIdnb12hdRDbZu3XrmzBl57tGjx5AhQ8Tm0Z+tra27u3urVq0k/qIB/LGgoCDlW0SdFyoDLMLmzZuTk5Pl+fHHH+/fv7/YPADUSd/X5d7e3uvWrevcubMB/3uWrxD+5z//ee2111JTUyVJKi8vN9STW6vz588nJCTIs5+fnwUVQgcHhzZt2sTFxYkOAsCs3X+/H2Ddzp49m5iYKM+GfTMOAOhP30I4adKkcePGGfz03t7eoaGh/fr1Cw8PLy4uphACAAAAgMnouzG9UXcVCwwMHDNmjCRJytJhAAAAAABj07cQurm5GTVHly5dJG4ZBQAAAAAT0rcQOjk5GTWHv7+/xBVCAAAAADChmgthRETEypUrIyMjjZqjQ4cOK1euDA8PN+pZAAAAAACKmheVadmy5cKFC42dIzg42ARnAQAAAAAoBG8Ht2PHDkdHx3bt2gUEBIhNAiNxcXFR/nJ9fX3FhgEg4x8mABVycHBQvvVpNBqxYWAF/P39bWxs5NnZ2VlsmPoQWQiLiopeeeWVCxcu2NraDhgw4JVXXomOjhaYB8bQv39/dtoFzM2AAQMGDBggOgUAmFRYWNiuXbtEp4D1iI2NFR3BMPRdVMYYXF1df/nll9zc3O+++87X17dXr147duwQmAcAAAAAVEXwLaOSJHl6evbt27dv376tWrWaMWPGwIEDXVxcRIcCAAAAAOsn8grhAxYuXOju7r5//37RQQAAAABAFcyoENrY2ISHh6elpYkOAgAAAACqYEaFsKys7Oeff7boJXoAAAAAwILUpRDm5eWtWbOmU6dOnp6ejo6OrVu3Xrp0aW5ubn1y/PLLL/37909PT/f396/P8wAAAAAA9FTrRWUSExPHjx9/69Yt5SMXLly4cOFCbGzsli1b+vTpo+fzlJSUpKSknD9//uTJkwcPHvz555/lj3ft2rW2kQAAAAAAdVC7Qrh79+4nn3yysrLy9790+/btwYMH79mz5/HHH3/o7z19+vSJEyeSk5OTk5MvXrx448YNnU73wGOioqIaNWpUq0gAAAAAgLqpRSE8d+7cpEmTHtoGZaWlpePHj09KSmrWrNn9H//mm2+WLVt2/PjxGk8xd+5c/fMAAAAAAOpD3/cQVlVVTZ06taio6NEPy87OfvbZZ5VDnU73+uuvDxkyRJ82OHDgwIkTJ+qZB4CFmjlzZt//2rdvn+g4AAAAqqbvFcJ169adPXtWnhs1atS/f//IyEgvLy+NRpOfn3/+/Pl9+/ZlZmZKkrR///5vv/12wIABkiR98MEHS5cu1ef5u3bt+tlnn9nY2NTpswBgMYqKigoKCuS5vLxcbBgAAACV06sQVlZWLl++XJIkrVa7Zs2aWbNmabXa3z9m06ZNCxcuzMnJeeeddwYMGHDmzJkFCxbU+OTh4eEzZ8587rnnHBwc6vAJAADqIysr69q1a/Ls5OTUpk0bsXkAPEJ6enp6ero8e3p6hoaGis0DwAroVQgPHDggX/37+OOPp0yZ8vAnsrObPn36n/70p969ex84cODmzZvLli0rKyuTJMnNze3JJ5+MjIwMDAzUarWurq6SJHl4eNja2jZp0sTPz89wnw4AoHZ+/PHHv//97/LcsmXLLVu2iM0D4BH27t0bGxsrzz169HjnnXfE5gFgBfQqhFu3bpUk6amnnvqjNqiIjIz84IMPJk6c+NZbb3399deSJI0YMWLTpk2enp71zwoAAAAAMCC9FpU5duyYg4PDihUr9Hnw+PHjw8LC3nvvverq6okTJ+7YsYM2CAAAAABmqOZCmJOT8+uvv3bp0sXf31+vZ7S1HTx4sE6na9So0UcffWRrq+9CpgAAAAAAU6q5rd28eVOn09VqmYFu3bpJkvTss886OzvXPRoAAAAAwJhqfg9hXl6eJElNmjTR/0mbNm0qSVK/fv3qHAsAAOABQ4YMKSkpkeeH3rjk7Ow8evRo5ZAFzAGgRjUXQnnHsEaNGun/pPKbBuVaCAAAYBBz58599AM8PDxefvll04QBAOtQcyGsqqqSavkzNjc3N0mS5O0l9JSdnX369Om2bdv6+vrq/7sAmFhlZWVKSopyGBISYm9vLzAPAAAA6kOvbSckSarVaz4bG5va5khKSho4cODOnTtHjhxZ29+rKhMmTOjdu7c8cw0WpldQUHD/9jN79+5lK1EAqJuYmJjBgwfLc3BwsNgwAFRL30IoXyc0ntLSUkmStFqtUc9iBSIjIyMjI0WnAAAA9dWuXTvREQBAv30Ipf8WNuOR36nIvWcAAAAAYDL6FkJlUS8jSUtLkyiEAAAAAGBC+hbCo0ePGu+u0dTU1Pj4eIlCCAAAAAAmpO97COPi4nbu3Onl5aVPZ5OrY/v27W1tay6c+fn52dnZ8kwhBAAAAACT0bcQSpJUVFRUVFSk/+OvX79e2zQsKgMAAAAAJqPvLaOmoc8VRQAAAACAQZhXAausrBQdAQAAAADUoha3jLZp06Zjx44ODg6GTVBWVnbu3LnTp09LklReXm7YJwcAAAAA/BF9C2GvXr0OHTpkpFs6dTrdyJEjd+/eXVFRYYznBwAAAAD8nr4Fb8iQIcZ7g5+Njc2gQYMkSaIQAgAAAIDJ6NvxfHx8jJrD29tb4j2EAAAAAGBC+hZCV1dXo+Zwc3OTeA8hAAAAAJhQzYVQq9V6eXk5OTkZNYejo6OXl5dRTwEAAAAAuF/Ni8oMGjQoJyfH2Dn69OljgrMA5i83N7e4uFieXVxcPD09xeZ5QHl5Oe/1rY87d+4of4Cenp4uLi5i8wAAAJWrxbYTAEzggw8+2L17tzyPHTt24cKFYvM8ICUl5cqVK/JsY2MjNowlmj9//oULF+R50aJFY8aMEZsHAAConHltTA8AAAAAMBmuEAKohby8PGU1YK4QAgAAWDoKIYBayM7Oruf2MB999FFVVZU8Ozo6GiIUAAAA6ohCCMCkWEYFAADAfFAIAUDVfHx8unTpIs9NmjQRGwbAowUEBCj/YENDQ8WGAWAdKIQAoGrR0dHR0dGiUwDQy5AhQ4YMGSI6BQCrwiqjAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVYtsJALWg0WhsbX/7QZK9vb3AMDCeDz/88OzZs/I8aNCgYcOGic0Dg8jJyVmyZIlyuGrVKjc3N4F5AEv3j3/8Iz09XZ6nTJny2GOPic0D1A2FEEAtODk5abVaeba1tfX29habB0Zy+fLlEydOyHPbtm3FhoGhlJeXK3+tkiRVVFQIDANYgZ9//vnKlSvy/MQTT4gNA9QZt4wCAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgErZiQ4AAICKDB069NatW/K8evXqvn37is0DAFA5rhACAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkWlQHMi5eXV0BAgDx7enqKDfN7Wq1Wq9XKs42NTR2e4f3338/IyJDnJ598snPnzgYLZwl8fX3z8/Pl2cXFRWwYAAAACiFgXubMmTNnzhzRKf5Q8+bNW7RoIc92dnX5BnLs2LHLly/L85/+9Ce1FcI1a9aIjgAAAPAbbhkFAAAAAJXiCiGAWvD19Y2JiZFnjUYjNgwAAADqiUIIoBb8/f3N+Y5WAAAA1AqF0CxUVFScPn1aOWzfvr2ybofVKCoqunDhgjzb2Nio7Z1jKnT16tW7d+/Ks6+vb/PmzYXGAaCX7OzsX3/9VZ4dHR3btm0rNg8AK3bhwoWioiJ5btasmZ+fn9g8qkUhNAuFhYXPPfeccrhnzx5/f3+BeYzh6tWryudob2//448/is0DY4uPj9+1a5c8jxkzZtGiRWLzANDHiRMnXnnlFXlu1qzZ9u3bxeYBYMXeeuuts2fPyvNf//rXP//5z2LzqBaLygAAAACASlEIAQAAAEClKIQAAAAAoFIUQgAAAABQKRaVASxGRkbG5MmTlcNdu3a5ubkJzFMrkydPzsjIkCTpwoULHh4eFpQcANRj//79b775pjwHBwd//PHHYvMAMAEKIWAxqqurCwoKlEOdTicwTG3du3dPDl9RUWFZyQFAPSoqKpT/aO7duyc2DADToBACwG+Kiopu3LghzxqNJjQ0VGweAAAAo6IQAsBvzp079/zzz8uzl5fXd999JzaPKLNmzRo/frw8N27cWGwYGIq3t/fatWuVQ+7cBupp8eLFJSUl8hwUFCQ2DFBnFEIAwIO4NGqVtFptly5dRKcArEebNm1ERwAMgFVGAQAAAEClKIQAAAAAoFIUQgAAAABQKd5DCFiVlJSU+fPny7ONjc1XX30lNo8Bffrpp9u3b5fnbt26LViwQGweAKizt99++/Dhw/I8YsSIadOmPfRhI0eOVPbpWbNmTcuWLU2UD4CaUAgBq1JRUZGeni7PNjY2YsMYVkFBgfKpZWdniw0DAPWRm5urfEPLy8v7o4elp6crhbCiosIUyQCoD4UQQC1UVlampKQohyEhIfb29gLzAAAAoD4ohABqoaCgYMqUKcrh3r17/fz8BOYBAABAfbCoDAAAAACoFIUQAAAAAFSKW0YBADCdPXv2iI4AAMBvuEIIAAAAACpFIQQAAAAAlaIQAgAAAIBKUQgBAAAAQKVYVAaASfn6+j711FNRUVGSJEVERIiOAwAAoGoUQgAm5eLi0qFDh379+okOAgAAAG4ZBQAAAAC1ohACAAAAgEpRCAEAAABApXgPoVmwt7fv0qWLcqjVagWGMRJXV1flc7Sz4wvP+gUFBSl/482bNz9+/LjYPLAmGRkZCxcuVA43bNhgld82hfDx8VH+5fr5+YkNA8C6RUREODg4yLO/v7/YMGrG63Kz4ObmtnbtWtEpjCs4ONjqP0fcb/LkyZMnT1YOv/jiC4FhYGVKS0uTk5OVw+rqaoFhrEznzp07d+4sOgUAVfjrX/8qOgIkiVtGAQAAAEC1KIQAAAAAoFIUQgAAAABQKQohAAAAAKgUi8oAFqNx48aHDh1SDt3c3ASGqa24uDhl5Q8nJyexYQAAD/XEE0/07t1bnjUajdAsAEyEQghYDFtbW3d3d9Ep6sjV1VV0BABADbRaLZu4AGpDIQSA37i6urZq1UqezfMa7Ntvv33lyhV5HjNmTN++fcXmAQAAFo1CCAC/adu2bVxcnOgUj3Lx4sVTp07Jc7du3cSGAQAAlo5FZQAAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIvKAFYlJCRk165dolMYxdSpU0eNGiXP7GQIwKLNnTt39uzZ8vyIXXm++uorZW7YsKHRYwFQJQohYFW0Wm1AQIDoFEbh7u5uudswAsD9vL299XmYtX4/B2BWKIQAasHOzk7Zpk+SJHt7e4FhAAAAUE8UQgC14O7ububb9AEAAEB/LCoDAAAAACrFFUIAtZCTkzNgwADlcO/evX5+fgLzAAAAoD64QggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBMzR4cOHt23bVlVVJToIVOqnn36Ki4srLS0VHQQqlZycvGnTpvz8fNFBoFJpaWkbN268ffu26CBQqaysrI0bN16/ft00p7MzzWksy4ULF+Th/PnzYpNAnU6cONGnTx+dTrdy5cqFCxeKjgPVSU1NjY6OrqioOHHixAcffCA6zkM0adIkLi5OOdRqtQLDwOAKCwsfe+yx/Pz8Xbt27dy5U3QcqI5Op+vZs2dqamqnTp1OnjwpOg7UaOTIkUePHg0ICEhLS7O1NfoFPArhQ2RlZcnD3bt3xSaBOiUnJ+t0OnkQnQVqdOXKlYqKCsmMvwK1Wm2rVq1Ep4CxZGRkyNcGzfYrENatuLg4NTVV4isQ4shfe+np6fn5+V5eXsY+HbeMPoT8WhwAAAAArBuFEAAAAABUikIIAAAAACpFIQQAAAAAlaIQAgAAAIBKUQgBAAAAQKXYdgIALMmLL75YVFQkz02bNhUbBgAAWDoKIQBYkoiICNERAACA9eCWUQAAAABQKQohAAAAAKgUhRAAAAAAVIr3ED5Kfn5+QkKC6BRQnV9++UUeMjMzze0rsLCwsKCgQDlMTEz08vISmAfGcPr0aXnIyckxt69AqMGNGzfkobi4mK9AmF5paak8VFVV8RUIISoqKkx5OhudTmfK81mELl26nDx5UnQKAAAAAOqVk5Njgp+8c8voQ1CSAQAAAIhlZ2eK2zm5ZfQhvvzyy44dO5aVlXXs2NHR0VF0HKiOTqe7cuVKWVlZy5YtHRwcRMeBGl27dq2wsDAkJMTZ2Vl0FqhRenr63bt3g4KC3N3dRWeBGt25cycjIyMwMLBBgwais0CNcnJybty4MWHCBDc3NxOcjltGAQAAAECluGUUAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEAAAAAKBSFEIAAAAAUCkKIQAAAACoFIUQAAAAAFSKQggAAAAAKkUhBAAAAACVohACAAAAgEpRCAEAAABApSiEf0in04mOAPXiyw/m4/r16/v27ROdAirFN0OIwtcezJbBvzgpuLUfFAAAIABJREFUhP/HL7/8Mn369KCgoODg4NDQ0MjIyOeffz4tLU10LqiCTqfbsWPH0KFDvb29bW1tnZycwsLCZs2a9dNPP4mOBvUqLy8fPnz4Sy+9JDoIVKSwsPDDDz/s2bOnr6+vp6enp6fn4MGDjxw5IjoXrF9ZWdm6det69uzp4uLi7e3t7u7erVu3t99+u6CgQHQ0WJuioqKxY8cOGDBAz8dfvXp1zpw5ISEhzZs3b9WqVXh4+MyZMy9dumSQMBTC37z33nvt27fPzs7et2/f1atXU1JStm3bdunSpcjIyK1bt4pOBytXUFAwePDg5557rkePHtu3bz979uzmzZubNm0aGxvbuXPnqVOnFhUVic4INfrHP/7x888/V1ZWig4CtUhISIiMjHz99defeeaZS5cu5efn37lzZ/bs2TExMf/6179Ep4M1u3z5cufOnZOSktasWXPnzp3c3Nzbt28vWrQoPj4+IiLihx9+EB0QVuL27dvvvvtuq1at/vWvf92+fVuf3xIXF9e6devk5OQvv/zy+vXrFy9e3L9/f05OTvv27devX2+ATDrodDqdbvPmzZIkjRw5srq6+v6PV1VVjRkzRqPRxMfHi8oGq1dWVta9e/cBAwYUFhY+8Esvv/yy/E+1a9euRUVFQuJBtc6ePavVaiVJCg0NFZ0FqvDxxx/b2NhER0ffvXv3/o8fOXJk/PjxPj4+paWlorLBuqWmpjZr1uzrr7/+/S+VlZWNHz/e0dHxyJEjpg8Gq/H0/2PvzgOiKvc/jj8zDPuOICAEiiuYS+auqbml5FIqqamhZlmWyy3LtLx6LTPvTcv1ptmCmqKpuZa55ZJrmuVGbrihCLIJAgMzzPz+OPfO5SfKDDgzBzjv11/fmXnmnC+GNp85z3meESN69uwZGRkphGjRooVarRZCNG7c2Owbt23bplar27dvr9fr73vptddeE0LMmzfvEXtTGZkhLURmZma9evUyMjIuXrwYERFx36vJyck1a9Z0dnZOSEgICQmRpUNUbdOnT9+4ceORI0dcXFzue8loNHbs2PHAgQNCiJEjR3711VdyNAgl0uv1bdu2PXPmTH5+fr169aw1LwV4mNWrVw8dOjQsLOzEiRN+fn6m56X/CxcWFgohDh8+3Lp1a/l6RJXVt2/fmjVrzps374Gv5ufnR0VFubu7nzlzxs6NocqYOnVqtWrVgoKCWrZsGRER4ezsXFhY2Lhx4z///LOUd2m12qioqCtXrhw9erRly5b3vZqTk/PYY4/l5+f/8ccfUtQsH6aMCiHEJ598kpaW1q5du5JpUAgRHBzcpUuXnJycjz76yP69ocrLy8ubM2fOzJkzS6ZBIYRKpXr//fel+ttvv/3rr7/s2x2U69NPP33yyScfe+wxuRuBIly9enX06NEGg+Gf//xn8TQohMjJyZHSoBBCumQNWNeNGze2bNnSuXPnhw1wdXUdMmTI2bNnz549a8/GUJV8+OGHEyZMGDRo0APjxsMsWrToypUr9evXL5kGhRCenp7PPfdcYWHhBx988Ci9EQiFTqf79ttvhRDt27d/2Bjp+8j4+HitVmu3xqAQe/fuvXfvXp8+fTp27Hj37t2SA7p06eLm5iaEMBgMGzdutHuDUKILFy4sW7Zs1qxZcjcCpXjllVdycnLCwsL69+9/30v16tWbNm1agwYN3nnnnSeeeEKW9lC1/fbbb0ajMTMzs5QxtWrVEkIkJSXZqylACCGWLVsmhGjXrt3DBkghZevWrWlpaeU+C4FQHDx4MDU1VQhRyhfhNWrUEEJkZWVJM/cAK7p27ZoQwmAw7N+//+uvvy45QKPR1KlTR6q5Qgg7MBgMo0aNmjt3ro+Pj9y9QBFOnjy5a9cuIcRzzz0n3Vdzn+nTpyckJPzzn/9UqVR27w5VX05OjhBiyZIlpSygJUXBsLAw+7UFxTt37pz0wc9sSCksLPz555/LfSICoTh8+LBUBAQEPGxMUFCQVBw8eNAePUFJTL9d4uGzoZydnaWCla9hBwsXLqxVq1afPn3kbgRKsXDhQqno0KGDvJ1AmaRP20eOHBk2bFheXl7JAUajcevWreHh4XXr1rV7d1AuU0ipXr36w8aYPkYeOnSo3CciEIrTp09Lha+v78PGmF4yDQaspU+fPmPGjPH39x84cODIkSMfOMa0GWZwcLAdW4MSXb169fPPP//000/lbgQKsm3bNqlo1KiRvJ1Amdq1ayfduRofH9+4ceNffvnlvgGrVq06fvz4rFmzNBqNHA1CoSwJKaabrk+dOlXuExEI/zNhT5R6q7qjo6NUsEk9rM7BwWHRokV37tyJj493dXUtOeD27dvSrGYhRCm3vAOPzmg0jh49+l//+lcpMyYA67p8+bK0E5dKpapdu3ZRUdGyZctat24dERFRs2bNvn37rlq1ymAwyN0mqjJnZ+epU6dK9eXLl7t06fLKK69kZWVJz+zcuXPUqFEzZswYPHiwfD1CiewWUgiEIjk5WSpK+dbH9J/h5s2b9ugJKGb16tXS9jAhISHM4oNNLVu2zMvLq+SqHoDt/P7771Lh7u6uUqliY2OPHz++du3axMTE06dPd+jQYfjw4a1bt75x44a8faJqGz9+/IgRI6TaaDQuW7asYcOGGzZsmDZt2tChQ7/44gtTYgTspkwh5datW+XeTZAL3yI3N1cqTAm7JNNLpsGAfRQVFZn2Hvzggw9K+S0FHtGtW7dmz57NndKwM9PKeJ6engsXLqxbt+60adNMz7z99tvVqlUbMWJE27ZtDx48yJIesBGVSvX1118/9dRTY8eOlT7s3bp1q3///p6enseOHWvQoIHcDUKJyhRS9Hp9QUHBA/cwM4srhMK0k4SDg8PDxpj+rB94qzFgO0uWLJF2PXrhhRdGjx4tdzuoyt54441p06YFBgbK3QiUxbTWv06n27x5c8nrMMOHD2/evHlSUtLgwYOLiors3iAUZMSIEcuXLy/+TE5OztNPP71hwwa5WoKSlSmkiEfIKQRCYbq6Wsr/ZkwvcRsD7Ck5Ofnvf/+7EKJbt27Lly9nvXXYzsqVKwsKCoYNGyZ3I1Ac0yeetLS0fv36PXDbiWeffVYIcejQoXXr1tm1OShJXl7e+++/P3r06C+//PKTTz6RdgAWQty+fbt///6vvPJKYWGhvB1CaSwJKcX3Sil3TmHKqHB1dZX2n9HpdA8bY/onoHzXYYFy0Ol0AwcOTE9P7969+8aNG007TwBWl5aWNn369JIL6wF24Onpaaoftu1E/fr1peKLL74YOHCgPdqCwty4cePZZ581Go0nTpyQZibHxMS8/vrrO3bskAYsW7YsJSVl48aND/zOArAF01qDpYSU4i89cG1CS/A7LUzfAJXyZ20K36bBgK299dZbBw4ciI6O3rRpU7n/hgOWGDNmzDvvvFPKvreA7RQPhA/b5M3Ly0sqDh8+nJ+fb4+2oCRZWVndunXLycn5+eefTfepRkRE/PzzzytWrDCturxly5alS5fK1yYUx5KQYnpJpVKV+8IVgfB/Wz1acoWQXeBgH4sWLVq4cGFsbOzGjRu5Lg2b2rJlS2pq6quvvip3I1AoHx8fqXB2dn7YVAhTICwoKGC5b1jdO++8c/78+fnz59eoUeO+l4YOHXr27Nnu3btLDz/55JNyL+QIlFWZQkr16tVLudWwdEwZFREREceOHRPFbmMoyfR9JN+gww7i4+PHjRs3adKkWbNmcd8gbCo7O/u1116bO3euaen/+0j/MGq12hMnTkjP+Pn51apVy34toqqLioqSCp1OZzAYHjgfr/j0HNPucIBV3LlzJy4u7vHHH+/Vq9cDBwQEBGzduvXFF19ct27dtWvXzp49+/jjj9u5SShTRESEVNg6pBAI/3dngrQx7gOZtgFp2LChPXqCgu3evXvEiBELFy58/fXX73spOTn56tWrbdq0kaMvVE3Xr1+/devWoEGDzA5r3ry5VA8ePHjVqlW2bw1KERUV5eLiotVqDQZDbm5u8RmkJsX3fPLz87Njd6j6fv31V51O16JFi1K+gXV0dPzmm2/27t2blpZ29epVAiHsw24hhSmj/7uF3fQHWtKtW7ekom3btvboCUp1+vTpF154YfHixSXToBBi3bp1a9assX9XqMIef/xx48OZNoirV6+e6UnSIKxLo9E0bdpUqrOzsx84Rlr7TQjh7OxcclIf8Cikf+jMbnHp4eEhTRzlPg7Yjd1CCoFQtGnTRvo+Mikp6WFjpJdcXV2ffvpp+3UGhbly5Up0dPSCBQtGjBjxwAEnT56MjIy0c1cAYGumhUP/+uuvBw7IyMiQinbt2vFxHNYlrRlj+v6rFJ6eniqVynTRBrC1hg0bhoaGCgtCilqt7tGjR7lPRCAUrq6uw4cPF0Ls2rXrYWOOHj0qhOjXr5+3t7fdGoOipKWl9e7d+5NPPnnxxRcfOMBgMOzYscN0sw0AVBmDBw+W9lY+ePDgAwdIt/oLIV577TX7tQVlaN++vaOj4/bt283u4fb777+3bNmS5SRgNyqVavTo0UKIvXv3Ft9vsDjpn8cuXbqYvcpd2olYK0kIcfXq1aioqPz8/D///LNx48b3vXr58uW6deu6ubmdPXs2PDxclg5RteXm5nbp0iUlJaVFixb3vVRQUJCXl6fX68+fP5+cnHznzh1/f39ZmoQCJSUlSR99wsLCrl27Jnc7qMqmTp360UcfNWnS5Pfff79vXZmioqKoqKgLFy60a9du//797AIHqxszZsy///3v+fPnjx079mFjtm3b1rt377179z5st0zAclqt1t3d3WAw1K5d+9KlS6WMTEtLq1+/fkZGxq5du7p06VLy1ccee0yv1584caJkhCmDUu4eUZT58+cLIZ555hm9Xl/8+aKiomeffVYIMW/ePLl6Q9Wm0+mio6Mt+dtavXp1uZuFguTn53/yySfS755ard6+fXtRUZHcTaHK0mq10jdis2fPvu+lGTNmCCFCQ0OTkpJk6Q1VXk5OTtu2bTUazTfffPPAAT/++KOnp+ecOXPs2xeqpuzs7E8//VT636uDg8O6deu0Wm0p41evXq1SqVq2bFlyWGxsrBBiypQpj9gSgfB/Zs+e7ejo+Mwzz1y6dEl6JjExsUePHiqV6sMPP5S3N1RhK1assPDrm44dO8rdLBQhOjraw8Pjgb+EPj4+M2bMkLtBVE13797t1q2bSqV69913ExMTdTrduXPnpDmizZs3v3HjhtwNoiq7d+/eq6++qlKpevTosXnz5jt37hiNxtTU1C1btjz//PNeXl4rVqyQu0dUbgMGDPD19ZWmx5fk4uLi6+v73nvvPfC9X375paura7t27U6dOiU9c+vWrZiYGCHE+PHjH/3rWqaM/j/nz59fsmTJpk2bNBqNEEKn07Vp0+Zvf/ubab11wOquX79+4cIFS0YGBQWx1DXs4K+//pJW+XdzczNtFJ6bmyvtfhsYGCjd4w5YndFojI+PX7p06ZEjR7RarZubW5s2bYYNGzZs2DBmisIOTp069cUXX+zevfvixYtGo9HZ2blRo0a9e/ceM2YM92vgEV24cMG0YLKPj49pmxO9Xm96PiAg4GG3Al69evXLL79ct26dwWDQaDT5+fnNmzcfN26cVeYwEwgfTKfTCSEeFuIBAIBN3bt372FXqgFbMxqN2dnZLCWICqioqKioqMjJycmKxyQQAgAAAIBCMQEDAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACAAAAgEIRCAEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIHwwXQ6nU6nk7sLAAAAALAhAuEDnD9//rHHHgsODv7zzz/l7gUAAAAAbEUjdwMV0ebNm1NSUoQQGzZsaNKkidztQFmSk5PXrVsn1Q4ODmPGjJG3HwAAAFRhBMIHME0W1ev18nYCBUpNTY2Li5NqJycnAiEAAABsh0AI2NamTZvmzZsn1Q0aNFi8eLG8/QAAAAAmBELAtgoKCrKzs6U6Ly9P3mYAAACA4lhUBgAAAAAUikAIAAAAAApFIAQAAAAAhSIQAgAAAIBCEQgBAAAAQKEIhAAAAACgUARCAAAAAFAoAiEAAAAAKBSBEAAAAAAUikAIAAAAAApFIAQAAAAAhdLI3QCA/8jNzf36669v3ryZmpoqhPD39y/rEbZt25aYmCjVLVq0aN26tZVbBJTq559/vnDhglQ3a9asXbt28vYDAIC1EAiBiiIvLy8uLi4/Pz89PV0I4efnV9Yj7NmzZ9++fVLt6OhIIASsZd++fTt27JBqg8FAIAQAVBlMGQUAAAAAheIKIVAGw4YNy87Olupp06Y1a9ZM3n4AAACAR0EgBMogOTk5KytLqrVarbzNAAAAAI+IQAhUBVqt9sqVKxkZGVJMdXFxkbsjAAAAVAIEQqAquHbt2rBhw5KSknJycoQQkZGRcncEAACASoBFZQAAAABAobhCCNjK+fPnd+zYcfLkydTUVI1GU3IbieI7mz3xxBP169e3c4erVq2StrgQQnTr1q1BgwZ2bgCogJYvX3737l2p7tGjR926deXtBwAAmyIQArZy+fLluLi4zMzM9PR0Z2fnkoFw//79P//8s1QXFRXZPxBu3LjRtJF9rVq1CISAEGL9+vU3b96U6gYNGhAIAQBVG1NGAQAAAEChuEIIVCwODg5eXl5CiA4dOkgFAAAAYCMEQqBicXJyCgkJEUJMnTo1ICBA7nYAAABQlTFlFAAAAAAUikAIAAAAAApFIAQAAAAAhSIQAgAAAIBCsagMYFs+Pj5eXl5hYWErVqzQaPgbBwAAgAqEj6eAbalUKgcHB0dHR/aQAAAAQEXDlFEAAAAAUCgCIQAAAAAoFFNGgcohJyfHaDRKtZubG7cjAgAA4NHxmRKoHPr27ZudnS3VixYtatWqlbz9AAAAoApgyigAAAAAKBSBEAAAAAAUikAIAAAAAApFIAQAAAAAhSIQAgAAAIBCEQgBAAAAQKHYdgKooPLy8kz7TLi6usrbTNVjNBpzcnJMDz08PNRqviADAACKQyAEKgp3d/exY8eaHo4fPz4pKUmqP/zwQ0uO4O3tLUXHN998s0mTJrZossrIzMzs3r276eHWrVuDgoJk7AcVXI8ePerXry/VDRs2lLcZAACsiEAIVBRubm6xsbGmh5s3by7rETw9PaXipZde4noXYEUdOnTo0KGD3F0AAGB9BEJAHtu3bz9//nxWVpYQwt3d3c5n1+l0W7ZsuXnzptSAl5dXWY/w22+/3bhxQ6rr1KnTuHFjK7cIAAAA2yMQAmWwYsUKg8Eg1dWqVXuUQy1atOj48ePSXYKhoaFWaK4sCgsLP/7448TExIKCAiGEm5tbWY+wefPmn376SapffPFFAiEAAEBlRCAEyiA4OFjuFgAAAACrIRACVYGLi0tkZKTcXQAAAKCSIRACVUF4ePiKFSvk7gIAAACVDOsQAgAAAIBCcYUQsJUGDRqY9hX09vYuOcDb29vFxUUI8fzzz7dr185ujS1YsOCbb745f/58UVGRi4uLr6/v8OHDmXEKSGJjY3NycqS6bt268jYDAICtEQgBW4mIiIiIiChlgIeHh4eHhxCie/fuLVq0sFdf/+Pg4ODq6lqtWrUBAwaEhYXZvwGgAurXr5/cLQAAYD8EQqBCOHbsmLQFhRAiMjIyJCSk+Kt6vT4zMzM3N1d6qNPp7N0fAAAAqiICIVAhLFiwICEhQaqnTJly3zWKvLy8y5cvFxUVSQ/v3btn7/4AAABQFbGoDAAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFYlEZQEGmTJkyb948vV6v1+uNRqOrq6vcHQEAAEBOXCEEAAAAAIXiCiFgZRcuXMjKypLqGjVqhIaGytsPAAAA8DAEQsDKvvjii/3790v1K6+8Mnr0aHn7AQAAAB6GKaMAAAAAoFBcIQSsLC0t7fbt21J94MCBklcIf/jhh4SEhEuXLuXk5Li7u3t6elpyWLX6f1/fODg4WKtbAAAAKBmBELCynJyczMxMqU5ISCg54LffftuxY0dycrJOp1Or1RYGwjp16pjqJk2aWKVVAAAAKBxTRgEAAABAoQiEAAAAAKBQBEIAAAAAUCgCIQAAAAAoFIEQAAAAABSKQAgAAAAACsW2E0AF5e7u7uXlJdWOjo7yNlP1qNVq0x+v+P/bPAIAACgHgRCooJYvX26q09PTP/74YxmbqXp8fHz27NkjdxcAAAAy40txAAAAAFAorhAC1rFly5Zly5YJIY4dO6bT6cxO8vT29i4qKmrSpEmbNm1q1Khhlx7/H7Va7evrW7t27WeeecbDw6Osb2/evLmrq6tUN27c2PT8rFmzjhw5ItUxMTFDhw61Srd4oIEDB2q1WqmeOXPm448/Lm8/AACg0iEQAtZx7969mzdvCiG0Wq3RaDQ7PiAgQAjRrVu3cePG2by5B3FwcAgKCmrTps2UKVPK8fa+ffv27du35PMZGRnSn4MQIjs7+5FahDnJycl5eXlSXVBQIG8zAACgMmLKKAAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFYlEZQHE0Go1GowkICDh+/LjcvQAAAEBOXCEEAAAAAIXiCiFQIbRs2TIkJESqQ0NDi7/01ltvnT9//u7du0KIZs2a1apVy9nZWYYWAQAAUOUQCIEKYezYsQ976c6dOykpKd7e3kKIgQMH9uvXz459AQAAoCpjyigAAAAAKBSBEAAAAAAUikAIAAAAAApFIASsz2g06vV6vV6fnp6+fPlyudsBAAAAHoxACNiEFAjv3LmzcOFCuXv5n48//jj3v65evSp3OwAAAJAZgRAAAAAAFIptJwArc3R01Gg0RUVFQgi1mu9cAAAAUHERCAEr8/b21ul0hYWFQghHR0e52wEAAAAeikBYseTl5WVmZkq1RqMJDAyUtx/IRafTpaamSnVeXp7Vj28wGJKTk00PAwMDMzMzpRArhPD29vbw8LD6Sau8mzdvmuqAgAAnJycZmwEAVFXFPy46OjpWr15d3n5Q2REIK5Z9+/ZNnTpVqsPDw9evXy9vPygHV1fX+vXrp6WliYdMGX3uueeaN28u1fXq1XvgQa5fvz5w4ECpvnLlSs2aNVUqlRWbzMvL69u3r+nhhg0bZs6ceeLECenh+PHjhw0bZsXTKYHRaCz+R7pixYrIyEgZ+wEAVFW7du2aMWOGVNetW3f16tXy9oPKjkAIWJmTk1ONGjX0ev3DBrRs2bJly5b2bAkAAAB4IAIhYBO5ublarVYIoVKpDh061LZt2/sGrFu3Ljc3V6o7deoUHh5u7xYBAABKGD16tMFgkOq33367QYMG8vYDWyMQAjaRk5Mjze9XqVS7du0qGQjj4uJMd/E99thjBEIAAFARfPfdd0ajUap79uxJIKzyWBMfAAAAABSKQAgAAAAACkUgBAAAAACF4h5CoMIxGAz37t0rKip62IDCwkJpxRohhEajcXNzs1drAAAAqFIIhECFc/ny5aFDhyYmJkoPXVxc7hvw3XffLVq0SKpbtWplqgEAAIAyYcooAAAAACgUgRAAAAAAFIopo4B19O7du0OHDlJ95cqVQYMGyduPXCZPnjxhwgSp9vT0lLeZKi8+Pt60VZS/v7+8zQAAgMqIQAhYh4eHh4eHh1RnZWXJ24yM/Pz85G5BQWrUqCF3CwAAoHIjEAKVgF6vT05OFkIsXbp0165dTZs2lbsjAAAAVAUEQqASMBgMubm5QohLly6lpaU1btxY7o4AAABQFbCoDAAAAAAoFIEQAAAAABSKQAgAAAAACkUgBAAAAACFIhACFV1oaOiSJUvq1KlTp04dLy8vudsBAABA1cEqo0BFp9FoAgMDHR0d5W4EAAAAVQ2BEKiyFi9efP36danu06dP27Zt5e0HQOW1fPnyc+fOSXWXLl26desmbz8AAGshEAJV1m+//Xb69GmpbtasmbzNAKjU/vjjj/3790t1rVq15G0GAGBF3EMIAAAAAApl5grhvn375s2bl5OTY/ZA3t7e7777bsuWLR/46qpVqzZt2hQYGBgaGtq1a1cuVqBq8/f3f/LJJ0+ePCl3IwAA4D9OnTo1cuRIqdZoNEeOHJGrk3Hjxh06dEiqX3vttVGjRsnVCSDMBsKQkJA///wzMTHR7IHc3NyItwISAAAgAElEQVRefvnlh72qVqsdHByOHj26cuXKSZMmhYWFjR079s0333RxcSlzy0CFFxgY2LZt25s3b8rdCAAAAFAaM1NG69Sp88cff7z66qsqlarkqx4eHkOGDFm2bNkff/xx9+7dnj17Puw4gwYNWrVq1dGjR9PT0w8dOjRgwICZM2fWq1dv06ZNj/oTAAAAAADKxfw9hJ6enkuWLPnxxx9r1KhherJevXorVqxITU1duXLlyy+/3KRJE43GovVpVCpVmzZt5syZc/HixT59+vTv33/KlClFRUXl/wkAAAAAAOVi6aIyPXr0WLlypRDCzc1t0aJFZ8+eHTp0qKura7lP7O/vv3DhwjVr1nz22WdDhw41GAzlPhQAAAAAoBws3XbiypUrQ4YMiYiI2LBhQ5MmTax1+v79+1erVq179+7BwcFz58611mErLzc3t5CQEKkODAyUtxnISKVSOTk5SXXxi/PWolarTb9pQgiNRuPv7296xtPT0+pnVILif6Sm/3wAAFhX8Y+L1atXl7cZVAEWBcKsrKwePXo4Ojru27cvNDTUuh106tRpzpw548aNa9u27YABA6x78EqnY8eOHTt2lLsLyM/Jyal27dpSvWHDhuTkZOse383N7b47eGfOnGndUyiNSqXipmgAgB107dq1a9eucneBqsOiKaPvvfdeUlLS9u3brZ4GJWPHju3cufOkSZMKCgpscXwAAAAAQEnmrxBeuXLlq6++mjZtWmRkpO36mDlzZps2bZYtW/bGG2/Y7iyA3bRq1crNzU2qo6KiSg7o37+/aYfP8PBw+3UGAADwcM8++6xpdY86derI2wzswHwgnD9/vpeX18SJE23aR+vWrZ988sn169cTCFE1dOrUqVOnTqUMGD58uJ1aAQAAsNiaNWvkbgF2ZSYQGo3GdevWPffcc3bYQT46OnrWrFmZmZm+vr62PhdQ6Wi1WtMGLZmZmWV9e15e3rFjx6Rao9E0a9bMms0BAACgcjITCE+fPp2UlNS5c2c7tNKqVSu9Xv/nn3+Wfl0FUKa0tDTTFNPTp0+X9e1JSUkLFy6Uam9v7927d1uzOQAAAFROZhaVuXDhghDCRmvJ3CcoKEgIcfv2bTucCwAAAABg5gphamqqEMLDw8MOrUgrcKSkpNjhXEBZ7d69++jRo1IdFRX13HPPWff4v/32286dO6Xa2dnZy8urlMEajcY0QPqLU1RUNHv2bNOAUaNGsTERbOrMmTObN2+W6mrVqo0ePVrefgDAEllZWVqtVgihVqt37drF5g0oq0uXLq1du1aq3d3dx48fL28/VmEmEOp0OmGvq3bSTmumu6SACuX06dMbNmyQ6tzcXKsHwkuXLpmO36RJkz179pQy+Mknn1y+fHnxZwwGg+ntQoiYmBgCIWzq+vXrpl+5mjVrEggBVAp5eXl3794VQqhUqtOnTxMIUVbJycmm//1Vq1atagRCM1NGpasQN2/etEMrt27dEkJ4enra4VwAAAAAADNXCMPCwoQQx44de/XVV23dyuHDhwUbsqFq+fbbb02X8tq0aTNz5kx5+wEAAFCmixcvFp/PsmvXLrXazLUxhTATCKUNtbds2VJYWOjk5GS7PnQ63Q8//CCEaNCgge3OAthZYWFhdna2VOfn58vbDAAAgGIZDAbTpzIUZyYWBwcH16lTJzU1dcWKFTbt47vvvktOTg4PD5euSQIAAAAAbM38ddJevXoJIWbNmmW76xsFBQWzZs0ynQvAfapXr961a9ew/9JozFzbBwAAACxhPhAOHz5cCHH58uWpU6faqInp06dLGx4OGzbMRqcAKjUXF5egoCD3/2LKOwAAAKzC/MfKJk2adO/eXQjx+eefb9q0yeodbN++/dNPPxVCtG/fvlWrVlY/PgAAAADggSy6zvDhhx+q1eqioqKBAwdu377diqf/9ddf+/fvr9frVSoVCzACAAAAgD1ZFAhbtmz5xhtvCCEKCgr69Onzr3/9S6/XP+KJDQbD4sWLu3fvnpeXJ4SIjY3t0KHDIx4TAAAAAGA5S+9Emj179hNPPCGE0Ol077777hNPPBEXF6fVastxysLCwvj4eClkSgvV1KtXb968eeU4FAAAAACg3CwNhK6urhs2bKhRo4b08MyZM8OHDw8NDZ04ceLhw4eLiorMHsFgMPz222/vv/9+eHj44MGDT5w4IT3v5+f3ww8/eHl5le8HAAAAAACUTxkWr69Zs+bOnTs7d+6ckpIiPZOenj5nzpw5c+Z4eXk1bdo0KirK39/f19fX19fXw8MjLy8vIyMjMzMzPT09ISHh5MmTWVlZ9x3Ty8tr27ZtUVFRVvuBAAAAAACWKdtuZlFRUQcPHuzZs+fFixeLP5+dnb1///79+/eX6WghISHbtm1r0qRJmd4FwEJjxoy5e/euVN+7d2/jxo3y9gOg8oqNjY2OjpbqiIgIeZsBAFhRmbe3rl279vHjx1977bXVq1c/yom7dOmyYsWK4ODgRzkIgFK0aNHCVB8+fFjGTgBUdnx7CwBVVZkDoRDCy8tr1apV/fr1mzhx4rVr18r69qCgoFmzZsXGxqpUqnKcHahisrOz4+Lijh8/npiYKIRwd3c/d+5cenp6tWrVLDzC5s2bExMTU1NThRAeHh5ubm42bBcAILc9e/acPXtWqhs1atSpUydZ2wFQuZUnEEoGDBjQu3fvFStWLFy48M8//7TkLZGRkWPGjBk5ciQfWAGTnJycuLi49PR0aXpnQUGBVqvNyMiwPBDu3Lnz0KFD6enpQgi1Ws3fLwCo2g4ePLhp0yapHjBgAIHQQo0bNx45cqR1t9Qun/nz58vdAvA/5Q+EQghnZ+dRo0aNGjUqISHh559/Pnjw4Llz5xITE03bUbi4uERERDRo0KBdu3bdunVr1KiRNXoGAAAAAFjBIwVCk8jIyMjIyAkTJkgP9Xp9Tk6Op6enRmOd4wMVzaVLl/7xj39ItYODw7fffitrOxXahx9+eOHCBakeOnToM888I28/AAAAMLFJYNNoNL6+vrY4MlBB5OXlJSQkSDVffJTu2rVrpj8raV4rAAAAKgg+yALWpNfrTRt1CiGMRqOdGzAajTqdLiUlxc3NTaPRBAYG2rkBAAAAVCIEQsCabty4ERMTY3o4YsQIOzdQUFBw6dKl119/3dnZOTQ0lL0HAQAAUAq13A0AAAAAAORhjyuECxcuDAoKGjBggB3OBSxfvtw0UTM6OjogIEDefiqI1atXm3YNZR4pAAAAJPYIhLNnz65fvz6BEPaxaNGioqIiqW7WrBmBULJz586MjAypdnBwkLcZAAAAVBD2mDLq7Oxs+iQKAAAAAKgg7HGF0MnJ6fTp02fOnHn88cftcDqgKjl69OjChQuFEBcvXtTr9W3bthVChIaGlvU4arVarf7PF0B+fn6m59lQEQAAQMnMBMKNGzdOnjy5sLDQ7IFcXFw+/fTTnj17lnzJyclJr9c3atQoICDA09PzYUfw9PTcsGFDRESE2XMBypGdnW3axC88PHzx4sXlO46rq6uTk5NUN23a1PQ8GyoCAAAomZnPf+3btw8ODv7ll1/MHEWjefzxx6tVq/bAV00fQ+/cuXPnzp2HHaRnz541a9Ys/UQAAAAAAGsxEwj9/f137dq1YMGCyZMn5+fn3/dqw4YNBw8e/PTTTzdt2tTNze1hBzEFwlJ07NhxzZo1piltQEXTpUuXsLAwqS7HjE2z3N3dHR0dhRCBgYGW/JW5j0qlCg4OFkJERUWdO3eOa32wtccff3zKlClSXcrUDwCoUPr27dusWTOprlOnjrzNoDKqW7eu6X9/Li4u8jZjLeY/NarV6vHjxz/zzDOxsbHHjh2TnuzZs+eMGTOaN29ulSaGDx++ePFiV1dXqxwNsIVGjRo1atTI9PDUqVPWPb6zs7O0+Ke3t3f5VgH18fERQtStW/fWrVvW7Q0oKSwszPQVCQBUFi1atGjRooXcXaASCwoK6tevn9xdWJmllxEaNGgwefLk559/Pjg4ePny5V27drX8HDqdTgihUqnCw8OLTyu9ffv2rVu3jEZjcnJybm4ugRAV3927d3fv3i2EuHbtWlZWlpTBymTfvn3p6elS3aRJk9q1a1u5RQAAAMBilgbCgwcPvvjii61bt16/fn2NGjXKdA69Xi+E2Lx5c69eve57KSUlZe7cuZ9//nmXLl1+/fVX5h2hgktJSfn444+FEPn5+cnJyd7e3iqVqpTxQ4YMGTZsmFRL0zjj4uJMVxcnTpxIIAQAALCDunXr7tmzx/SQW9VMLPqDSEtLGzhwYP369bdv317WNCiE0Ol0/v7+0dHRJV8KDAycPXv2unXrzp8///bbb5f1yEAF5+zs7PVfpdxnCwAAAJtSq9VexcjdTgViUSAcNWqUVqv98ccfvb29y3EOvV4fERFRSgrv3bv33/72t6+//vr8+fPlOD4AAAAAoBzMB8IdO3Zs2rTpo48+ktYwLAedTufu7l76mEmTJmk0mri4uPKdAgAAAABQVuYD4fz580NCQl555ZVyn0On05mdLOfj49OhQ4ctW7aU+ywAAAAAgDIxEwjv3bu3c+fOfv36lW8dfIler7fk7dHR0WfOnLl27Vq5TwQAAAAAsJyZVUZPnjxZWFjYvn37RznHqlWrLLn5sEmTJkKIixcvhoeHP8rpAAAAAACWMBMIL126JIQo992Dkg4dOlgyLDAwUAhx+/btRzkXAKW5du3aiRMnpNrHx6dz587y9gMAAFCJmAmE2dnZQggXFxc7tFJQUCCESElJscO5AFQZf/zxh7Q5pBCiXr16BEIAAADLmbmHUNor4ubNm3ZoRTqLtHk3AAAAAMDWzARCadNG+wTCpKQk0xkBAAAAALZmJhDWrFlTCHHgwAE7tLJjxw4hREREhB3OBQAAAAAwEwgbNmyoUql++umnnJwcm/aRnp7+888/q1SqqKgom54IAAAAACAxc8Oev79/w4YNz5w5s2TJkokTJ9qujwULFuTl5TVs2DAgIMB2ZwEqIC8vr7FjxxqNxoMHDwohWrdurdFo/P39LT9Cnz59mjdvLtVarXbfvn02aRQAUDF06dIlLCxMquvXry9vMwAqO/MruDz33HNnzpz59NNPR44c6efnZ4smkpOT58+fL4To3bu3LY4PVGSenp6xsbFCiOHDh5fvCN26dTPV0tRrAEAV1rZt27Zt28rdBYAqwsyUUSFEbGysWq1OSUl56623bNTEG2+8kZmZqVKpXnrpJRudAgAAAABwH/NXCOvUqdOvX79169bFxcW1b99+1KhR1u1gzpw5P/zwgxCid+/ekZGR1j04YCPOzs61atWKi4tzcHBQqVRyt1OhTZ06NS8vT6oDAwPlbQYAAADFWbTp34wZMzZv3lxYWDh69GhXV9chQ4ZY6/RfffXVO++8I4TQaDQfffSRtQ4L2JparXZxcWnQoAE7Z5oVHh4udwsAAAB4MPNTRoUQkZGRkydPFkIYDIZhw4a9++67pu/7yy07O/vNN98cNWqU0WgUQrz99tuNGjV6xGMCsnN0dAwpRq226K+YFbm5uZnOzuU4AAAAlM7SixsffPDBvn379u7dazQa//Wvf8XHx7/55psjR44s01qIkpSUlC+//HLRokW3b9+WnmnTps2MGTPKehygAgoNDd20aZOMDbRv3759+/YyNgAAAIBKxNLLFxqNZu3ataaljW/cuDFp0qTQ0NBhw4atX78+KyvL7BEyMjLWrl07ePDgsLCwqVOnmtJgrVq11q1b5+TkVL4fAAAAAABQPmW4/SkgIGDHjh1PP/10YmKi9ExBQcHKlStXrlypUqkiIiIaNmzo5+fn6+vr6+vr4eFx7969zMzMjIyMjIyMs2fPmt5V3GOPPbZjx44aNWpY56cBhHjppZcMBoNUs62lSa9evWrVqiXVnTt3lrcZAAAAVBBlWw8jLCzs0KFDvXr1On78ePHnjUbj5cuXL1++XKajNW3adOvWrSEhIWV6F1C6N954Q+4WKqLp06fL3QIAAAAqnDIvkBgYGHjgwIGJEycuXrxYWg+mfEaPHv3ZZ5+5urqW+wgAyken0+3bt0+qExMTDQaD/Re/AQAAQEVQnhXzXVxcFi5cOHDgwPHjx588ebKsb2/atOnnn3/esWPHcpwaUJpWrVqtWLFCqq11q21+fv57770n1QaDYe7cudJ6pGyoCAAAoDTl30LtqaeeOnHixE8//bRo0aKdO3fqdLrSxzs6Onbt2vWNN96Ijo7mcydgIS8vLy8vL9sdX61W16lTJzQ01HanAAAAQIX1SHtqq1Sq6Ojo6Ojo9PT0PXv2HDx48K+//rp27VpmZmZhYaGTk5Ovr294eHiDBg3atWvXuXPnatWqWatvAAAAAMAjeqRAaFKtWrWYmJiYmBirHA0AAAAAYAesJAEAAAAACmWdK4SAQvj4+PTr18/0sOTinPv37zdt8BAUFLRq1ar7Bpw4ceLixYtSvXTp0kGDBtmqV6CqO3To0AcffCDV/v7+a9eulbcfAAAqIwIhUAbVq1efMmVKKQN0Ol12drZUe3h4lBzg5+dnWlSJbVeAR1H8r5uLi4u8zQAAUEkRCAHzcnJyEhISpFqlUrVo0ULefgDI4urVq6mpqVLt7+8fEREhbz82de7cuXv37kl1eHi4tDkNAKDqsVMgTE9PT0lJEUL4+PjUqFHDPicFrCUxMXHMmDFS7eTkdOjQIXn7ASCLNWvWfP/991Ldp0+fv//97/L2Y1OffvrpqVOnpPqdd94ZOHCgvP0AAGzETovKfPXVVw0bNmzYsGHp0+0AAAAAAHbDlFHAHjZv3nzmzBkhxLVr14qKihwcHO4bMHfuXK1WK9WDBw+uVauWvVsEAACA8hAIAXs4fvz4jz/+KIRIS0szGAwlA+HWrVtNy2N06dKFQAgAAAA7YB9CAAAAAFAoAiGAyq1mzZq9evXKzMzMzMw8efJk586db926JXdTAMpj0KBBnf/rwIEDcrcDAIrAlFEAlVuTJk0iIiK2bt0qPczOzi4qKpK3JQDlc+/ePdPkeZ1OJ28zAKAQXCEEAAAAAIUiEAIAAACAQhEIAQAAAEChuIcQqEx++umnS5cuSfWTTz7Ztm1befsBAACVxb59+06dOiXVkZGRXbt2lbcfVBAEQqAy2bt37+7du6VapVIRCAEAgIWOHj26du1aqe7duzeBEBKmjAIAAACAQhEIAQAAAECh7DRltFatWt27dxdCNGrUyD5nBAAAAACUzk6BMCYmJiYmxj7nAgAAAABYoqJMGdXpdJmZmYWFhXI3AgAAAABKUVEC4S+//OLn57dt2za5GwEAAAAApagogVCr1QohnJyc5G4EAAAAAJSiogTCnJwcQSAEAAAAADuqKIHw7NmzgkAIAAAAAHZkp1VGS5eYmPjtt98KIRwdHeXuBaj6HB0du3btanro5uYmYzMAAACQkZyBsKio6Jdffvnuu+9Wr15dUFAguEII2IWrq+snn3widxcAAACQnwyB0Gg0Hjp0KD4+/vvvv09JSSn+ElcIUQXodDqp0Gq1hYWFZf2ao6io6M6dOzdv3hRCuLm5+fr6Wr9FAAAAQAhh50B49uzZ77//fuXKlZcvX37gAKPRaM9+AKszGo2XLl2S6mvXrl2+fDkyMrJMR7hz584777zj7u4uhHjuuec++OAD63cJAAAACCHsEwgTEhLWrFkTHx9//vz50keaLq0AAAAAAGzNhoHwxo0bGzZs+P777w8ePGjhWwiEqMIMBkNmZqZOpzMYDHq9XqO5/2+fVqvNzc3Ny8uTBnh7e8vSJ+wsISHh2LFjUh0QEBAdHS1LG5s3b87MzJTqdu3a1alTR5Y2AACAnVk/ECYnJ69duzY+Pv7o0aOlTwFt1arVwIED+/Xrp9PpWrVqlZGRUVhYaPV+AHvq0KFDvXr1pFqlUhV/yWAwpKamqlSq6tWrBwQErFy58rHHHis+QKvVpqam6nS6/Pz8goICAqFCnDp1asGCBVLduHFjuQLhqlWrTLOdfX19K0UgbNeu3Z49e6Rara4ouygBAFC5WC0Qpqenr1+/Pj4+ft++fQaDoZSRjRo1GjRo0KBBgyIiIkxPDhkyZMGCBVwhRGXn6Ojo4OBQygCVSuXg4ODo6BgcHOzj42O3xoCqR6PReHl5yd0FAACV26MGwpycnI0bN8bHx+/cubP0OFezZs1hw4YNGjQoKiqq5KtNmzYVTBlFReXp6dmyZUupLjnVE4BChIeHm/4pKP6dZpUUFRXl4uIi1YGBgfI2AwCwnXJ+tM3Pz//xxx9Xr179448/5ufnlzKyevXqTz311Pr16ydMmDB+/PiHDZPW1icQomKKiIhYvHix3F0AkJk0vUXuLuxk4sSJcrcAALCHsgVCnU63c+fO+Pj4jRs35uTklDLSx8fn+eefHzRoUJcuXRISEtavX1/6kdu0abN27donn3yyTP0AAAAAAMrNokBoMBgOHTr0/fffx8fHp6amljLSxcWla9euMTExAwYMcHNzs7yPoKCgmJgYy8cDlUufPn1q1ao1c+ZMIYSzs3PJAW+99db+/fs3bNiQmZlZ+lV3AAAAwFrMBMJz584tXbp07dq1ycnJpQxzcnLq3r374MGD+/Tp4+HhYdUOgaqgefPmYWFhixYtetiAXr16FRYW7tmzR6vVarVae/YGAAAAxTITCFu3bl3K1FAHB4eOHTsOHjy4X79+fn5+1u4NgM1lZ2fv2rXL9LBv376lr5IKAACAqsRMIGzfvv1PP/1035MqlapVq1aDBg164YUXgoODbdYbAJtLS0v7+OOPTQ+jo6MrYyD08PAw7UcnPZSxGQDlFh8fb9q5qkw3ngAAys1MIPzxxx9/++23+Pj4NWvW3Lx5UwihVqvHjx//7rvvBgUF2aVDADBDpVKxHx1QBfBtDgDYn9rsiBYtWsyZM+f69esHDhwYN25cQEDAZ599FhIS0r59+3nz5pW+xgwAAAAAoMIyHwj/M06tlhLgzZs3Dxw4MGrUqNOnT0+YMKFGjRrdunVbvnx56btQAAAAAAAqGksDoYmDg0P79u2XLFmSmpq6efPmF1988fDhw7GxsdWrV+/du/fy5ctzc3Nt0SigWHl5edn/VVRUJHc7AAAAqDrKtjF9cc7Ozr179+7du/eSJUu2bt26fPnyHTt2bN269fXXX3/22WeHDRvWo0cPR0dHK/YKKNO0adN++eUXqX7qqafGjh0r1Y0aNZKvKQAAUMl07NgxMDBQquvUqSNvM6g4yh8ITVxdXWNiYmJiYtLT09etW7d69er169d///33/v7+AwYMGDRokK+vr9mD/PHHH//+979fe+21J5544tFbAqqqunXrxsbGyt0FAACofFq1atWqVSu5u0CFU+Ypo6WoVq3a6NGj9+7de/369blz50ZERHzxxRedOnXq2LGjECIjI6OU9x45cmTp0qXSQqYAAAAAADuwZiA0CQkJ+dvf/nb06NFLly599NFHISEhQogZM2bUr1//H//4x8WLF0u+Rdrt0MnJyRb9AAAAAABKskkgNKldu/b7779/5syZU6dOTZkyRa/XT58+vV69eq1atZo3b97t27elYatWrdqyZYsQwtnZ2ab9AAAAAABMbBsITRo1ajRz5szLly8fOXJkwoQJSUlJEyZMCA0Nbd26dePGjYcOHWo0GgVXCAEAAADAjuwUCE1atWr12Wef3bhxY8+ePS+//PJff/11+vRpKQ0KAiEAAAAA2JG9A+F/zqpWP/3000uWLElMTBw3bpzpeY3GCqueAgAAAAAsIU8gNPHz85s3b96ECROkh4WFhfL2AwAAAADKIXMglHz88cd+fn5CiIKCArl7AQAAAAClqBBTNF1dXV944YUvvvhCq9XK3QtgEwUFBfv378/OzpYeenp62rmB9PT0kydPSrWTk1OHDh3s3AAAAAAqoAoRCIUQDRs2FEwZRdV19+7djz766ObNm9LDunXr2rmB8+fPv/fee1Lt6+u7c+dOOzcAAACACqhCTBkVQrRs2TImJsbf31/uRgAAAABAKSrKFcKWLVuuXbtW7i4AKwgJCTHV5dhJxcHBwcnJyc3NLSQkxMfHx6qt/T95eXkzZszIysqSrlsGBgayzC8AAIDS8PkPsCaVSrVp06ZHOUJAQEBAQECDBg1Wrlxpra4eSKfT7dq1q6CgQLqzsXr16jY9HQAAACqgijJlFAAAAABgZ1whBOxErVZXq1ZNqgcNGuTm5nbfgPr168fGxkq15dfr5s6du2rVKqnu2bPnhx9+aI1mYT+RkZGm/+5BQUFytdGnT5/09HSprlOnjlxtwLrat29vWr576dKlzZo1k7cfAEAFZI9AmJeXt3v37oMHD167di0jI8PX17d69eqtW7fu2rUrs9SgHGq12vQLP2rUqJKBsGHDhtJyu1CUxo0bN27cWO4uxIsvvih3CwAAQAZmAuGdO3eOHDlidnvA9u3bBwcHl3w+Jyfn448/Xrp0aUZGxn0vLViwwMHBYfDgwR988EH9+vXL1DQAAAAA2MfZs2dzc3OlumbNmlXsmpaZQHj8+PHnn3++qKio9GFLlix59dVX73vy119/HTJkyPXr1x/2rqKiopUrV37//fefffbZ66+/bmHHAAAAAGA3s2fPPnfunFRPnjy5f//+8vZjXWYCYc+ePQ8dOvT666///vvv/+9tGk3Hjh2jo6ObNm3atGlTPz+/+964YcOGIUOG3HdpUaVSRUVFRUVFeXp6pqWlHT9+/NatWwUFBWPGjLlw4cJnn31mlR8JAAAAAGAJ8/cQtmzZ8tixY1988cU777yTn5/v5+c3YcKEMWPGmJbHKOn48eMl0+CIESPef//92rVrF3/ywIED06ZN++WXXz7//PPg4OB333233D8JAAAAAKBMLNp2wsHBwc3NTavV9uvX7/Lly1OnTpx9dM8AACAASURBVC0lDer1+pdeeql4GnRxcVmzZs3XX399XxoUQjz11FO7d++eNWuWSqWaOnXqxYsXy/djAAAAAADKyqJA+NNPP7366qsTJ05ct26dj49P6YNXrFiRkJBQ/JklS5a88MILDxuvUqnee++9adOmFRYWTp061ZJ+AAAAAACPzvyU0bt3744YMaJPnz6zZ89WqVRmx69evbr4w6effvqll14y+64pU6asWbNm69at+fn5rq6uZscDsAoHBwdfX18hRM+ePb28vBwcHOTuCAAAAPZj/grh119/nZWV9dlnn1mSBnNzc/fu3Vv8GQtvC3R0dBw+fHhubu6hQ4csGQ/AKjQaTVBQUFBQ0Lhx46ZMmeLo6Ch3RwAAALAf81cIv/nmmxdeeCEsLMySwx05ckSn05keurm5derUycJW2rZtK4S4ceOGheOBCiU5Odn02+vl5dWgQQN5+wEAq7t79+758+elWqPRNGvWTN5+AACPzkwgTEpKOn369OTJky083IEDB4o/bNeunYuLi4XvDQgIEEKkpaVZOB6oUHbu3Dl//nypbtGixb///W95+wEAq0tISHjzzTel2svLa8+ePfL2AwB4dGamjB4/flwIYflXgPv37y/+0PLLg0KI3NxcIYTZRWsAAAAAAFZh5gphSkqKEKJ69eqWHEun0x09erT4M2UKhNK1wcDAQMvfAlQ0mZmZOp3uzJkzCxYs6NixY+PGjYu/ajAYpN/zZcuWubu7x8bGenl5mT2mq6uraZizs7Mt2gYAAIAymQmEhYWFQgiNxvythkKI48eP5+XlmR66u7u3aNHC8lYuXbokhAgODrb8LUBFc/fu3fz8fK1WGxcXFxgYeF8gNBqN6enpQoj4+HiNRtO/f39LAuGMGTNs1S4AAACUzcyUUem+vlu3bllyrPvmi7Zr165MKxbu37/f1dW1UaNGlr8FAAAAAFBuZgJh3bp1hRAW3jW+efPm4g/LNF80Pz9/9+7d3bt3Z0YcAAAAANiHmUDYrFmz4ODg+fPn6/X60kcePXr08OHDxZ/p1q2b5X18++23aWlpo0ePtvwtAAAAAIBHYSYQqlSq4cOH//XXX1OnTi1l2L17915++WWj0Wh65sknn2zevLmFTaSnp8+cObNDhw49e/a08C0ArEWn02m12osXLyYkJNy+fVvudgAAkFliYmLCf929e1fudgDbMr9azLvvvrt06dJPPvlEpVJ99NFHavX9GTIpKWnAgAFnz54t/uTMmTMt7MBgMAwfPvzOnTsbN2608C0ArCgtLS0rK2vcuHGOjo4xMTGTJk2SuyMAAOT03nvvJSYmSvX06dN79eolbz+ATZm5QiiE8PHx+e677zQazaxZs5o0afLNN98kJSUZDIbCwsKTJ09Onjy5YcOG9+028corrzzzzDOWnD43N7dfv35bt25dunSp5VcUAQAAAACPzqL9JJ555pklS5aMHj36zJkzI0eOFEKoVKriE0SLe/755xctWmTJYbdt2zZp0qSzZ886OTllZWUVFRU5ODhY3jpQNWzZsuXq1atS3apVq5YtW8raDgAAgP1cvHhx+/btUu3t7f3SSy/J248CWRQIhRAjR44MDw8fNmxYcnKyEOKBadDJyWnSpEnTp08vOa3UJCUlJTExcefOnZs2bfr999+lJwsLCydMmLB69eovv/ySbSegNHv27Dlw4IBUOzs7EwgBAIByXLlyJS4uTqpDQ0MJhPZnaSAUQnTp0uXixYvz5s2Li4u7cOFC8Ze8vb0HDRr01ltv1atX72Fvj4uLGz16dEFBwcMGHD16tHnz5lu2bOnevbvlXQEAAAAAyqcMgVAI4e7uPmXKlClTply5ciUxMTEtLc3V1TUsLKxRo0ZmZ3t27979q6++ys3N/b/27j0u6irx//iZAeSOqIiKioKKinjZVknELBc101Q2y1uyimmaPcxyH649KrOH5oatuXkrNdcySqnI1cw2Xdu18haiZeIdFUQwhRAYhIFhZn5/fH7fyZWLgsMcmPN6/nVmPp+ZeYsjzns+5/M5Nezj4+PTvXv3WkUCGgUPD48hQ4aUlZVpl/HU6XQODhAQEDBkyBBt7O3t7eBXBwAAQMNUu0JoExISEhISUquHtGnT5sknn6zbywGNnZ+fX0JCQkFBgW12qIOFhYUlJCRIeWkAAAA0WHUshADqoKioyGQyaWPHHyQEAADArSwWi3aFFE3r1q0VvMglhRBwnC1btqSnp2tjPz8/uWG8vLy0Y4YfffTRwYMHFfz1BwAAFFdQUDBmzBjbzV27drVq1UpiHikohICi3NzctLMKDx48mJaWJjsOAAAAJLjzwvQAAAAAAKfEEUKgcZs3b968efNkpwDQEO3fv192BABAQ8cRQgAAAABQFEcIAQAAAKBaPXr08PHx0caBgYFyw9gdhRAAAAAAqrVgwQLZEeoRU0YBAAAAQFEUQgAAAABQFIUQAAAAABRFIQQAAAAARVEIAQAAAEBRFEIAAAAAUBTLTgD20aZNm8jIyOLi4vz8fA8PD9lx7uChhx7Ky8vTxl27dpUbBkBj0bRp08jISG3s7e0tNwwAwC4ohIB9DB06dOjQoVOnTk1LS5Od5c7Onz9fUFCgjVu3bi03DIDGonv37u+8847sFAAAe2LKKAAAAAAoiiOEgD2NGzdu8ODB2rhXr163bXVzcwsMDNTGERERfn5+Dg0HAAAA/C8KIWBPI0aMqGGrq6trixYttHHPnj19fHwcEgoAAACoGoUQcHKXL19OTU3Vxk2bNo2JiZGbBwAAAA0HhRBwcsePH//rX/+qjTt16kQhBAAAgA0XlQEAAAAARXGEEKijpUuXZmdna+O4uLioqCi5eerM19e3TZs22rhVq1ZywwAAIF1oaKi7u7s2btq0qdwwQH2jEAJ1dOLEifT0dG08fPhwuWHuRb9+/V566SXZKQAAaCgSEhJkRwAchymjAAAAAKAojhACkj366KN9+vTRxr1795YbBgAAwJHCwsLmzJmjjX19feWGUROFEJCMy34CAABldezYsWPHjrJTKI0powAAAACgKAohAAAAACiKQggAAAAAiuIcQsBx/Pz82rZtq42bN28uNwwAAIDi9Hq97bOZEMLFxUViGFkohIDjxMfHx8fHy04BAAAAIYTw9/ffsWOH7BSSMWUUAAAAABRFIQQAAAAalhUrVvT9PwsXLpQdB86MQggAAAAAiqIQAgAAAICiKIQAAAAAoCgKIQAAAAAoimUnADnWrVuXkZGhjUeNGhUdHW3f509KSvrpp5+EEOnp6YWFhU2bNrXv8wMAAMAJUAgBOVJTU7XCJoTo1auX3QthWlra3r17hRCFhYVGo5FCCAAAgMqYMgoAAAAAiuIIIdCAdO7cOT8/XxsvWLBgwYIFcvPY3dixY2/cuKGNly5dGhUVJTcPIF1OTs7kyZNtN3fs2OHr6ysxDwBANRRCoAExGo1lZWW2sdww9aG4uLioqEgbV1RUyA0DNAQWi8X2j0IIYbVaJYYBACiIQgjYR3p6uu3gXuvWrYODg+XmAQAAAO6IQgjYx6ZNm/bs2aON4+Li5s6dKzdPzVauXGkwGLTxwIED5YYBAACALBRCQEWPP/647AgAAACQj0IINDKnTp3avn27Nm7WrNkzzzwjNw8AAAAaLwoh0MhkZWVt27ZNGwcHB1MIAQAAUGesQwgAAAAAiuIIIeDkmjRpEhYWFh0dLYQICAiQHQcAAAANCIUQcHKenp5Dhgx54YUXZAcBAABAg0MhhFrKy8svXLhgu9m1a1e93qETp7Ozs3/66SchRFZWlsFg8PX1rcMz2NasZ23325SWlmZkZGhjnU7XrVs3qXEAAAAaOgoh1PLLL7/ExcXZbu7bt8/Hx6duT/Xyyy+XlpZq45CQkMOHD9/No5KSkl599VUhRHl5uRCid+/etX3dtWvXXrp0SRu3aNGitg93bhcuXJg6dao21uv1KSkpUuMAAAA0dBRCoI569uwpOwIAAABwTyiEAAAAkm3YsKGsrEwbx8bGtm/fXm4eAOqgEAIAAEi2detWg8Ggje+//34KIQCHYR1CAAAAAFAUhRAAAAAAFEUhBAAAAABFUQgBAAAAQFEUQgAAAABQFIUQAAAAABTFshNAg2a1WtesWWO7OX78eIlhAAAA4GQohECDZrVaN2/ebLs5dOhQiWEAAIBjzJs3b968ebJTQAlMGQUAAAAARVEIAQAAAEBRFEIAAAAAUBTnEAINkdVqNRgM2dnZFotFdhYAAAA4LQohIIerq6unp2dCQoIQIiws7NZNVqu1rKxs69at+/btE0KYzWYXF5faPv+ECRMeeughbRwcHHzvgQEAAOB8KISAHHq9vkmTJkOGDKmn54+IiIiIiKinJwcAAIBz4BxCAAAAAFAURwiBBuTYsWMmkyknJ+epp55ydXXCf56ff/657axILy8vuWGAhiAoKOg///mP7aavr6/EMAAABTnhJ06g8QoMDBRCWCyWJk2ayM5SL3x8fGRHABoWvV7v5+cnOwUAQF0UwkbmnXfeOXTokDZ+5JFHJk2aJDePc1u5cmVqaqo2HjVq1Lhx42rYuXPnzgUFBdq4ffv2Qoi0tLRly5Zp93h7e69bt64+w0qQkpKyevVqbRwQEPD3v/9dbh7UyuLFi8+fP6+N4+Lihg0bJjcPAACQgkLYyOTk5Jw+fVob33fffXLDOL3s7GzbTzsqKqrmnadNmzZt2rRb77l586bt4U55BMBgMNj+gEFBQXLDoLYyMzNtf32//vqr3DAAAEAWCiHwG4vFcvXqVdtNq9Vq95coKiqyPW0dnt9gMJhMpvoIBgAAAAVRCIHf3LhxY8yYMbab/fv3t/tLbN68uaysTBvX4aoqycnJly5d0q7L4uXlFRsba+d8AAAAUAmFEGhk9Hq9tk69h4dHZGSk7DgAAABoxCiEgN2cO3cuLS1NG7ds2bLylUK/++67kpISbcKnTqer7fOXl5efO3fOZDLZVm4AAAAA7gWFELCbw4cPr1q1Shv37ds3Pj7+th0+/vjjwsLCOp8BaDQaDx8+XF5ebrVa69AnAQAAgNvoZQcAAAAAAMjBEUKoxd3dvXv37raber2jvxPR6XTawT0XF5eWLVvW+Rn0en1AQADrvN/G09PT9vfLQVQAAIA7ohBCLa1atUpMTJQYwNXVVbskTGBg4CeffFKHZ9BOTWzSpElsbGzv3r3tnK+R69Spk9y/XwAAgMaFKaMAAAAAoCiOEAIAAEg2Y8YMk8mkjdu1ayc3DAClUAgBAAAkmzRpkuwIABTFlFEAAAAAUBSFEAAAAAAURSEEAAAAAEVxDiFgT2azOTs7WwhRWlqam5trNpu1RSYAAHB68+bNMxqN2vj5558PCwuTmwfA3aAQAvZktVpv3rypjS0Wi7u7u9w8AAA4TGpqaklJiTYuKiqSGwbAXWLKKAAAAAAoiiOEQEM3a9YsDw8PIURaWtqWLVtkx7krMTExhYWF2nj16tVRUVFy8wAAAKBKFEKgoZs0aZKvr68QYs+ePUlJSbLjAAAAwHkwZRQAAAAAFEUhBAAAAABFUQgBAAAAQFGcQwg0OK6urm3btrXd1Ov54gYAAAD1gkIINDht2rTZsWOH7BQAAABwfhx5AAAAAABFUQgBAAAAQFEUQgAAAABQFIUQaIi+/fbbTz/91Gw2yw4CRaWmpiYmJhqNRtlBoKjTp09/8MEHhYWFsoNAUZcvX960adO1a9dkB4GicnNzN23alJGR4ZiX46IyVTh16pQ2SEtLk5ukstmzZz/55JPauEWLFnLDOL3p06c/++yz2rgOP21PT8+1a9f6+/sLIVxcXO7+gSkpKYMHD7ZarQkJCQsWLKjt6zpMv379EhMTtbGbm5vcMKitV199taSkRBu3atXq1k2ZmZkDBgwwmUwpKSmrV6+WkQ5KMxgMUVFRhYWFO3bs+Oc//yk7DpRjtVoHDRqUmZnZt2/fI0eOyI4DFcXGxh48eLBt27aXL192wNXmKYRVyM3N1QZ5eXlyk1QWFBQUFBQkO4UqgoKCAgMD6/xwvV4fFhZWhyZ5+vRpq9WqDer86g7g5+fn5+cnOwXqqEOHDtVtSk9PN5lMosG/A+GscnJytGODvAMhRUlJSWZmpuAdCHm09152dnZhYWGzZs3q++UohFXQPotDQXq9/tYFAGt1WO8u2Y6kNW/evEmTJrV9uIuLi/YoDw8PB/yCAAAAgHOjEAK/adasWX0vANipUydtMHfu3G7dutX24QEBAQEBAUKIdu3avfDCC3YOBwAAAMVwURkAAAAAUBRHCAG7CQsLGzly5ObNm4UQVU4HfeCBB2wnboWFhdX2+du1a/fYY49pY+1aNQAAAMC9oBACdtO/f//Q0NDdu3dXt8PkyZPv5fnDw8PDw8Pv5RkAAACAWzFlFAAAAAAURSEEAAAAAEVRCAEAAABAURRCAAAAAFAUhRAAAAAAFEUhBAAAAABFsexETQoLC/fu3Ss7BRqTgoKCoqIi281vv/3Wz8+vtk9y8uRJbXD16tVG+g7Mz8+/efOmNj5y5IhtjEbhxx9/1Ab5+fmN9B2IRi0rK0sblJSU8A5sXAoKCoxGozZOSUkpKCiQm6dubH8Es9nMOxBSmEwmR76czmq1OvL1GoXIyMgjR47ITgEAAABAXfn5+c2aNavvV2HKaBUoyQAAAADkcnV1xHROpoxW4bPPPrvvvvvKysruu+8+Dw8P2XGgHKvVmp6eXlZW1qVLF3d3d9lxoKJLly4ZDIbOnTt7eXnJzgIVZWdn5+XlhYSE1GHWPXDvrl+/npOT0759+xYtWsjOAhXl5+dnZWVNmDDB19fXAS/HlFEAAAAAUBRTRgEAAABAURRCAAAAAFAUhRAAAAAAFEUhBAAAAABFUQgBAAAAQFEUQgAAAABQFIUQAAAAABRFIQQAAAAARVEIAQAAAEBRFEIAAAAAUBSFEAAAAAAURSEEAAAAAEVRCAEAAABAURTCalmtVtkRoC7efmg4MjIyvvrqK9kpoCh+GUIW3ntosOz+5qQQ/o+TJ09Onz49JCQkNDQ0LCwsIiLiueeeu3z5suxcUILVat22bdujjz7avHlzvV7v6enZtWvXmTNnpqamyo4GdZWXl48ePXr+/Pmyg0AhBoNh/fr1gwYNCgwM9Pf39/f3HzFixP79+2XngvMrKyt79913Bw0a5O3t3bx5cz8/v+jo6BUrVhQVFcmOBmdTXFz8xBNPDBs27C73v3jx4pw5czp37tyxY8fu3bt369bt6aefPnv2rF3CUAh/s3Llyj59+vz6669fffXVxYsXz58//+mnn549ezYiIiIpKUl2Oji5oqKiESNGzJ49+4EHHvj888+PHz++efPm4ODgDRs29OvX709/+lNxcbHsjFDR0qVLT5w4UVFRITsIVLF3796IiIglS5Y89dRTZ8+eLSwsvH79+qxZs6ZMmZKcnCw7HZzZuXPn+vXrd/To0eXLl1+/fv3GjRvXrl178cUXP/744/Dw8H379skOCCdx7dq1t99+u3v37snJydeuXbubhyQmJvbo0eP06dOfffZZRkbGmTNn/vWvf+Xn5/fp02fdunV2yGSF1Wq1Wjdv3iyEiI2NtVgst95vNpsff/xxFxeXjz/+WFY2OL2ysrKBAwcOGzbMYDDctumll17S/qnef//9xcXFUuJBWcePH2/SpIkQIiwsTHYWKGHjxo06nW7AgAF5eXm33r9///7x48cHBAQYjUZZ2eDcMjMzO3TosHPnzsqbysrKxo8f7+HhsX//fscHg9OIj49/5JFHunfvLoTo16+fXq8XQvTq1euOD9y1a5derx84cGBFRcVtm2bNmiWEWLly5T1m01mZIS3EjRs3wsLC8vPzz58/HxoaetvWq1evduzY0d3d/fTp023btpWSEM7ttdde2759++HDhz08PG7bZLVaH3zwwe+//14IMW3atH/84x8yAkJFFRUVAwYMSEtLKy0tDQsLs9e8FKA6W7dunTx5cnBw8NGjR5s3b267X/tfuLy8XAhx6NCh/v37y8sIpzVmzJiOHTuuXLmyyq2lpaXh4eHe3t5paWkODgansXDhwhYtWrRu3ToyMjI0NNTd3b28vLxXr17Hjx+v4VFGozE8PPzSpUs//PBDZGTkbVsNBkP79u1LS0t/+uknrWrWDVNGhRAiISEhLy8vOjq6chsUQrRp0yYmJsZgMLz++uuOzwanV1JS8tZbby1durRyGxRC6HS6l19+WRt/8MEHZ86ccWw6qGv58uW///3v27dvLzsIlJCRkTFz5kyLxfLmm2/e2gaFEAaDQWuDQgjtkDVgX1lZWTt37vzDH/5Q3Q6enp5PPvnkyZMnT5486chgcCZLlix5/vnnJ0yYUGXdqM7atWsvXbrUtWvXym1QCOHr6xsbG1teXv7KK6/cSzYKoTCZTB988IEQYuDAgdXto30fmZSUZDQaHRYMiti3b19xcfHo0aMffPDBwsLCyjvExMR4eXkJISwWy/bt2x0eECo6d+7cxo0b33jjDdlBoIoZM2YYDIbg4OCxY8fetiksLGzRokXdunWbP3/+7373Oynx4NyOHDlitVpv3LhRwz4hISFCiCtXrjgqFCCEEBs3bhRCREdHV7eDVlK+/PLLvLy8Or8KhVAcOHDg+vXrQogavggPCgoSQhQUFGgz9wA7yszMFEJYLJbvvvtu06ZNlXdwdXXt3LmzNuYIIRzAYrFMnz59xYoV/v7+srNACT/++OPevXuFELGxsdp5Nbd57bXXTp8+/eabb+p0Ooeng/MzGAxCiPXr19dwAS2tCgYHBzsuFpR36tQp7YPfHUtKeXn57t276/xCFEJx6NAhbdCyZcvq9mndurU2OHDggCMyQSW2d5eofjaUu7u7NuDK13CANWvWhISEjB49WnYQqGLNmjXaYNCgQXKTQE3ap+3Dhw/HxcWVlJRU3sFqtX755ZcdOnTo0qWLw9NBXbaSEhgYWN0+to+RBw8erPMLUQjFiRMntEGzZs2q28e2ybYzYC+jR4+ePXt2QEDA+PHjp02bVuU+tsUw27Rp48BoUFFGRsbbb7+9fPly2UGgkF27dmmDnj17yk0CNUVHR2tnriYlJfXq1eu///3vbTts2bIlNTX1jTfecHV1lREQirqbkmI76frnn3+u8wtRCP//hD1R46nqbm5u2oBF6mF3Li4ua9euzc3NTUpK8vT0rLzDL7/8os1qFkLUcMo7cO+sVuvMmTP/9re/1TBjArCvCxcuaCtx6XS6Tp06mc3mjRs39u/fPzQ0tGPHjmPGjNmyZYvFYpEdE87M3d194cKF2vjChQsxMTEzZswoKCjQ7vn3v/89ffr0xYsXT5w4UV5GqMhhJYVCKK5evaoNavjWx/bXkJ2d7YhMwC22bt2qLQ/Ttm1bZvGhXm3cuNHPz6/yVT2A+nPs2DFt4O3trdPppkyZkpqa+umnn168ePHEiRODBg2aOnVq//79s7Ky5OaEc5s7d258fLw2tlqtGzdu7NGjx7Zt2xYtWjR58uR169bZGiPgMLUqKTk5OXVeTZAD3+LmzZvawNawK7Ntsu0MOIbZbLatPfjKK6/U8C4F7lFOTs6yZcs4UxoOZrsynq+v75o1a7p06bJo0SLbPX/+859btGgRHx8/YMCAAwcOcEkP1BOdTrdp06YHHnhgzpw52oe9nJycsWPH+vr6pqSkdOvWTXZAqKhWJaWioqKsrKzKNczuiCOEwraShIuLS3X72H7WVZ5qDNSf9evXa6sejRs3bubMmbLjwJk9++yzixYtatWqlewgUIvtWv8mk+mLL76ofBxm6tSpffv2vXLlysSJE81ms8MDQiHx8fEffvjhrfcYDIbBgwdv27ZNViSorFYlRdxDT6EQCtvR1Rr+m7Ft4jQGONLVq1dfffVVIcTQoUM//PBDrreO+vPRRx+VlZXFxcXJDgLl2D7x5OXlPfbYY1UuOzFy5EghxMGDB5OTkx0aDiopKSl5+eWXZ86c+d577yUkJGgrAAshfvnll7Fjx86YMaO8vFxuQqjmbkrKrWul1LmnMGVUeHp6auvPmEym6vax/Qqo23FYoA5MJtP48eN//fXXYcOGbd++3bbyBGB3eXl5r732WuUL6wEO4OvraxtXt+xE165dtcG6devGjx/viFhQTFZW1siRI61W69GjR7WZyU888cQzzzyzZ88ebYeNGzdeu3Zt+/btVX5nAdQH27UGaygpt26q8tqEd4P3tLB9A1TDz9pWvm07A/Vt3rx533///YgRI3bs2FHnf+HA3Zg9e/b8+fNrWPcWqD+3FsLqFnnz8/PTBocOHSotLXVELKikoKBg6NChBoNh9+7dtvNUQ0NDd+/enZiYaLvq8s6dOzds2CAvJpRzNyXFtkmn09X5wBWF8LelHu/mCCGrwMEx1q5du2bNmilTpmzfvp3j0qhXO3fuvH79+tNPPy07CBTl7++vDdzd3aubCmErhGVlZVzuG3Y3f/78s2fPrlq1Kigo6LZNkydPPnny5LBhw7SbCQkJdb6QI1BbtSopgYGBNZxqWDOmjIrQ0NCUlBRxy2kMldm+j+QbdDhAUlLSc889t2DBgjfeeIPzBlGvioqKZs2atWLFCtul/2+j/WI0Go1Hjx7V7mnevHlISIjjIsLZhYeHawOTyWSxWKqcj3fr9Bzb6nCAXeTm5m7evDkiIuLRRx+tcoeWLVt++eWXkyZNSk5OzszMPHnyZEREhINDQk2hoaHaoL5LCoXwtzMTtIVxq2RbBqRHjx6OyASFffPNN/Hx8WvWrHnmmWdu23T16tWMjIyoqCgZueCcLl++nJOTM2HChDvu1rdvX208ceLELVu21H80qCI8PNzDw8NoNFoslps3b946g9Tm1jWfmjdv7sB0cH779+83mUz9+vWr4RtYNze3999/f9++3ss5awAABkFJREFUfXl5eRkZGRRCOIbDSgpTRn87hd32A60sJydHGwwYMMARmaCqEydOjBs37p133qncBoUQycnJn3zyieNTwYlFRERYq2dbIC4sLMx2J20Q9uXq6tqnTx9tXFRUVOU+2rXfhBDu7u6VJ/UB90L7RXfHJS59fHy0iaOcxwGHcVhJoRCKqKgo7fvIK1euVLePtsnT03Pw4MGOSwbFXLp0acSIEatXr46Pj69yhx9//LF79+4OTgUA9c124dAzZ85UuUN+fr42iI6O5uM47Eu7Zozt+68a+Pr66nQ620EboL716NGjXbt24i5Kil6vHz58eJ1fiEIoPD09p06dKoTYu3dvdfv88MMPQojHHnusadOmDgsGpeTl5Y0aNSohIWHSpElV7mCxWPbs2WM72QYAnMbEiRO1tZUPHDhQ5Q7aqf5CiFmzZjkuFtQwcOBANze3r7/++o5ruB07diwyMpLLScBhdDrdzJkzhRD79u27db3BW2m/HmNiYu54lLumF+JaSUKIjIyM8PDw0tLS48eP9+rV67atFy5c6NKli5eX18mTJzt06CAlIZzbzZs3Y2Jirl271q9fv9s2lZWVlZSUVFRUnD179urVq7m5uQEBAVJCQkFXrlzRPvoEBwdnZmbKjgNntnDhwtdff713797Hjh277boyZrM5PDz83Llz0dHR3333HavAwe5mz5797rvvrlq1as6cOdXts2vXrlGjRu3bt6+61TKBu2c0Gr29vS0WS6dOndLT02vYMy8vr2vXrvn5+Xv37o2Jiam8tX379hUVFUePHq1cYWqhhrNHlLJq1SohxMMPP1xRUXHr/WazeeTIkUKIlStXysoG52YymUaMGHE3/1oDAwNlh4VCSktLExIStPeeXq//+uuvzWaz7FBwWkajUftGbNmyZbdtWrx4sRCiXbt2V65ckZINTs9gMAwYMMDV1fX999+vcoevvvrK19f3rbfecmwuOKeioqLly5dr/726uLgkJycbjcYa9t+6datOp4uMjKy825QpU4QQL7300j1GohD+ZtmyZW5ubg8//HB6erp2z8WLF4cPH67T6ZYsWSI3G5xYYmLiXX598+CDD8oOCyWMGDHCx8enyjehv7//4sWLZQeEcyosLBw6dKhOp/vLX/5y8eJFk8l06tQpbY5o3759s7KyZAeEMysuLn766ad1Ot3w4cO/+OKL3Nxcq9V6/fr1nTt3/vGPf/Tz80tMTJSdEY3b448/3qxZM216fGUeHh7NmjV78cUXq3zse++95+npGR0d/fPPP2v35OTkPPHEE0KIuXPn3vvXtUwZ/R9nz55dv379jh07XF1dhRAmkykqKuqFF16wXW8dsLvLly+fO3fubvZs3bo1l7qGA5w5c0a7yr+Xl5dtofCbN29qq9+2atVKO8cdsDur1ZqUlLRhw4bDhw8bjUYvL6+oqKi4uLi4uDhmisIBfv7553Xr1n3zzTfnz5+3Wq3u7u49e/YcNWrU7NmzOV8D9+jcuXO2Cyb7+/vbljmpqKiw3d+yZcvqTgXMyMh47733kpOTLRaLq6traWlp3759n3vuObvMYaYQVs1kMgkhqivxAACgXhUXF1d3pBqob1artaioiEsJogEym81ms7lJkyZ2fE4KIQAAAAAoigkYAAAAAKAoCiEAAAAAKIpCCAAAAACKohACAAAAgKIohAAAAACgKAohAAAAACiKQggAAAAAiqIQAgAAAICiKIQAAAAAoCgKIQAAAAAoikIIAAAAAIqiEAIAAACAoiiEAAAAAKAoCiEAAAAAKIpCCAAAAACKohACAAAAgKIohAAAAACgKAohAAAAACiKQggAAAAAiqIQAgAAAICiKIQAAAAAoCgKIQAAAAAoikIIAAAAAIqiEAIAAACAoiiEAAAAAKAoCiEAAAAAKIpCCAAAAACKohACAAAAgKIohAAAAACgKAohAAAAACiKQggAAAAAiqIQAgAAAICiKIQAAAAAoCgKIQAAAAAoikIIAAAAAIqiEAIAAACAoiiEAAAAAKAoCiEAAAAAKIpCCAAAAACKohACAAAAgKIohAAAAACgKAohAAAAACiKQggAAAAAiqIQAgAAAICiKIQAAAAAoCgKIQAAAAAoikIIAAAAAIr6f+zHOXTUkL2iAAAAAElFTkSuQmCC", "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "starttime = 1\n", "timelimit = 10\n", "\n", "plots = []\n", "\n", "gs = scatter(hcc_ac[:, 1], hcc_ac[:,2], \n", " marker = (:vline, 5, 0.8, :black, stroke(2, 0.8, :black, :vline)),\n", " label=nothing, c=:red, msc=:black, #msa=1, ma=1, \n", " ylabel = \"SA-GC\",\n", " xlims = [(starttime-1),timelimit], grid = false, yticks=false )\n", "\n", "gr = scatter(hcc_rm[:, 1], hcc_rm[:,2], \n", " marker = (:vline, 5, 0.8, :black, stroke(2, 0.8, :black, :vline)),\n", " label=nothing, c=:red, msc=:black, #msa=1, ma=1, \n", " ylabel = \"RM-GC\",\n", " xlims = [(starttime-1),timelimit], grid = false, yticks=false )\n", "\n", "\n", "append!(plots, [gr])\n", "append!(plots, [gs])\n", "\n", "fig1 = plot(plots..., layout=grid(2, 1, \n", " heights=[0.5, 0.5]), \n", " size=(400, 350), dpi = 300)" ] }, { "cell_type": "code", "execution_count": 501, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "starttime = 1\n", "timelimit = 10\n", "\n", "plots = []\n", "s = scatter(spont_hcl[:, \"Time\"], spont_hcl[:, \"Neuron\"], \n", " marker = (:vline, 5, 0.8, :red, stroke(2, 0.8, :black, :vline)),\n", " label=nothing, c=:red, msc=:black, #msa=1, ma=1, \n", " ylabel = \"SA\",\n", " xlims = [(starttime-1),timelimit], grid = false, yticks=false )\n", "\n", "gs = scatter(hcl_ac[:, 1], hcl_ac[:,2], \n", " marker = (:vline, 5, 0.8, :black, stroke(2, 0.8, :black, :vline)),\n", " label=nothing, c=:red, msc=:black, #msa=1, ma=1, \n", " ylabel = \"SA-GC\",\n", " xlims = [(starttime-1),timelimit], grid = false, yticks=false )\n", "\n", "gr = scatter(hcl_rm[:, 1], hcl_rm[:,2], \n", " marker = (:vline, 5, 0.8, :black, stroke(2, 0.8, :black, :vline)),\n", " label=nothing, c=:red, msc=:black, #msa=1, ma=1, \n", " ylabel = \"RM-GC\",\n", " xlims = [(starttime-1),timelimit], grid = false, yticks=false )\n", "\n", "bc0 = scatter(bc_0[:, \"Time\"], bc_0[:, \"Neuron\"], \n", " marker = (:vline, 5, 0.8, :blue, stroke(2, 0.8, :black, :vline)),\n", " label=nothing, c=:red, msc=:black, #msa=1, ma=1, \n", " ylabel = \"BC\",\n", " xlims = [(starttime-1),timelimit], grid = false, yticks=false )\n", "\n", "append!(plots, [gr])\n", "append!(plots, [gs])\n", "\n", "fig1 = plot(plots..., layout=grid(2, 1, \n", " heights=[0.5, 0.5]), \n", " size=(400, 350), dpi = 300)" ] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.8.5", "language": "julia", "name": "julia-1.8" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.8.5" } }, "nbformat": 4, "nbformat_minor": 2 }