diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/CAN_Firing_Fields_3d.m b/experiments/Figure_Creation/3D Firing Fields - CANs/CAN_Firing_Fields_3d.m new file mode 100644 index 0000000..674c0a9 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - CANs/CAN_Firing_Fields_3d.m @@ -0,0 +1,116 @@ + + +data = load("./data/data1.mat"); + +f = data.arr; +figure; hold on; + +thresh = 0.012 + + +b = data.b + + +x = -1:2./(b-1.):1.; + +y = x; +z = x; + +[x,y,z] = meshgrid(x,y,z); + +size(x) +size(f) + +% % +set(gca,'linewidth',4) +set(gca, 'XTickLabel', []) +set(gca, 'YTickLabel', []) +set(gca, 'ZTickLabel', []) +% +xticks([-1 0 1]) +yticks([-1 0 1]) +zticks([-1 0 1]) + +subplot(1,1,1); + + +isosurface(x, y, z, f, thresh); +isocaps(x, y, z, f, thresh, 'above'); + + + +azim = -25; +elev = 30; +lightangle(azim,elev); +daspect([1,1,1]); +camlight +lighting gouraud +grid on + + + + +view(22.5,15) + +% axis vis3d +colormap jet +% colormap copper + + + +v1 = [1 1 -1;1 -1 -1; -1 -1 -1; -1 1 -1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',.15, 'LineStyle','none'); + +v1 = [1 1 -1; + 1 1 1; + -1 1 1; + -1 1 -1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',.05, 'LineStyle','none'); + + +v1 = [-1 -1 -1; + -1 1 -1; + -1 1 1; + -1 -1 1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',.05, 'LineStyle','none'); + + + +v1 = [1 1 1;1 -1 1; -1 -1 1; -1 1 1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',0., 'LineWidth',4.); + +v1 = [1 -1 1;1 -1 -1;-1 -1 -1;-1 -1 1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','None','FaceAlpha',1., 'LineWidth',4.); + +v1 = [1 1 1 ; + 1 1 -1]; +f1 = [1 2]; +patch('Faces',f1,'Vertices',v1,'FaceColor','None','FaceAlpha',1., 'LineWidth',4.); + +v1 = [1 -1 -1 ; + 1 1 -1]; +f1 = [1 2]; +patch('Faces',f1,'Vertices',v1,'FaceColor','None','FaceAlpha',1., 'LineWidth',4.); + + + + +M = max(f,[],3); + +planeimg = mat2gray(reshape(M,100,100)); +size(planeimg) + + +% plot the image plane using surf. +surf([-1 1], [-1 1], repmat(-1, [2 2]), planeimg,'facecolor','texture') + + + +saveas(gcf, './Figures/3d_field.png'); + + diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/Create_Firing_Fields_CAN.ipynb b/experiments/Figure_Creation/3D Firing Fields - CANs/Create_Firing_Fields_CAN.ipynb new file mode 100644 index 0000000..89507c8 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - CANs/Create_Firing_Fields_CAN.ipynb @@ -0,0 +1,297 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "from torch import nn\n", + "import torch.nn.functional as F\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from src.twisted_attr import TwistedAttractor\n", + "from src.utils import MultiAttractor\n", + "from src.utils import get_path" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Torus attractors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "m = 3\n", + "mec = MultiAttractor(m=m, dt=0.4)\n", + "W = mec.attr[0].W\n", + "print(W.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y0 = torch.zeros(m, 20, 20)\n", + "y0[:,0,0] = 10.\n", + "y0 = y0.view(m, 1, 400)\n", + "\n", + "mec.reset(y0)\n", + "\n", + "for t in range(1, 300):\n", + " b = 0.2*torch.ones(m,1,400)\n", + " y0 = mec(torch.zeros(m,1,2), b)\n", + " \n", + "\n", + "plt.imshow(y0.view(m*20,20))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Path Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "w=40\n", + "paths = [get_path(T=500, w=w, vmax=0.5) for _ in range(20)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Path visualization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from src.plotting import scatter\n", + "\n", + "X,_ = paths[1]\n", + "scatter(X, mode=\"lines\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## path integration" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "A = torch.randn(m, 3, 2)\n", + "A = A/torch.norm(A, dim=1, keepdim=True)\n", + "A[0] = torch.eye(3)[:,:2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_input = []\n", + "\n", + "for x, v in paths:\n", + " model_input.append(4*v@A)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_output = []\n", + "\n", + "for i,v_ in enumerate(model_input):\n", + " T = v_.shape[1]\n", + " mec.reset(y0)\n", + " \n", + " if i%10 == 0: print(i, T)\n", + " \n", + " y = torch.zeros(T, m*400)\n", + " y[[0]] = y0.clone().view(1,m*400)\n", + " \n", + " for t in range(1, T):\n", + " b = .2*torch.ones(m,1,400)\n", + " \n", + " vel = v_[:,[t],:] + 0.3*torch.randn_like(v_[:,[t],:])\n", + " y[[t]] = mec(vel, b)\n", + " \n", + " model_output.append(y.clone())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = torch.cat([x for x,v in paths], dim=0)\n", + "print(f\"x: {x.size()}\")\n", + "\n", + "y = torch.cat(model_output, dim=0)\n", + "y = y.view(-1, m,20,20)\n", + "print(f\"y: {y.size()}\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Look" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import binned_statistic_dd as binst\n", + "from scipy.ndimage.filters import gaussian_filter\n", + "from src.plotting import plot_3d_iso\n", + "from scipy.io import savemat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(y.min(), y.max())\n", + "plt.imshow(y[10].view(m*20,20))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bins = 100\n", + "\n", + "vals = y[:,0,0,0].numpy() + \\\n", + " y[:,1,0,0].numpy() + \\\n", + " y[:,2,0,0].numpy() \n", + "\n", + "hist, be,_ = binst(x[:].numpy(), vals, bins=bins, statistic='mean')\n", + "hist = np.nan_to_num(hist)\n", + "print(hist.min(), hist.max())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values = gaussian_filter(hist, 3)\n", + "print(values.min(),values.max())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "X, Y, Z = np.mgrid[0:bins:1, 0:bins:1, 0:bins:1]\n", + "eps = .01\n", + "c = 0.001\n", + "\n", + "plot_3d_iso(X,Y,Z, values, c, eps)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scipy.io.savemat('./data/data.mat', mdict={'arr': values, 'thresh': c, 'b': float(bins)})" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/Figures/3d_field.png b/experiments/Figure_Creation/3D Firing Fields - CANs/Figures/3d_field.png new file mode 100644 index 0000000..bf5ea87 Binary files /dev/null and b/experiments/Figure_Creation/3D Firing Fields - CANs/Figures/3d_field.png differ diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/src/plotting.py b/experiments/Figure_Creation/3D Firing Fields - CANs/src/plotting.py new file mode 100644 index 0000000..3cf17e6 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - CANs/src/plotting.py @@ -0,0 +1,90 @@ +import plotly.graph_objects as go + +def scatter(X, w=1., mode="markers", ranges=None): + fig = go.Figure(data=[go.Scatter3d( + x=X[:,0], + y=X[:,1], + z=X[:,2], + mode=mode, + marker=dict( + size=5, + color= w, + colorscale='Jet', + opacity=1., + line=dict( + color='black', + width=1 + ) + ), + line=dict( + color='black', + width=2 + ), + opacity=1.)]) + + fig.update_layout(title=go.layout.Title( + text="", + xref="paper", + x=0 + ), + scene_aspectmode='cube') + + if ranges is not None: + fig.update_layout(scene = dict( + xaxis = dict(nticks=10, range=ranges[0],), + yaxis = dict(nticks=10, range=ranges[1],), + zaxis = dict(nticks=10, range=ranges[2],),)) + + + fig.show() + + + +def plot_3d_iso(X, Y, Z, values, c, eps): + + fig = go.Figure(data=go.Isosurface( + x=X.flatten(), + y=Y.flatten(), + z=Z.flatten(), + lighting=dict(roughness=0.3, specular=.9, diffuse=1, ambient=0.1), + lightposition=dict(x=45,y=15,z=25), + value=values.flatten(), + isomin=c, + isomax=c+eps, + colorscale='Jet', + opacity=1., + caps=dict(x_show=True, y_show=True, z_show=True) + )) + + + fig.update_layout(scene = dict( + xaxis = dict( + backgroundcolor="rgba(0, 0,0,0.1)", + gridcolor="white", + showbackground=True, + zerolinecolor="white",), + yaxis = dict( + backgroundcolor="rgba(0, 0,0,0.1)", + gridcolor="white", + showbackground=True, + zerolinecolor="white"), + zaxis = dict( + backgroundcolor="rgba(0, 0,0,0.2)", + gridcolor="white", + showbackground=True, + zerolinecolor="white",),), + width=700, + margin=dict( + r=10, l=10, + b=10, t=10), + + ) + + fig['layout'].update( + scene=dict(camera= dict( + up=dict(x=0, y=0, z=1), + center=dict(x=0, y=0, z=0), + eye=dict(x=1.5, y=2, z=0.6))) + ) + + fig.show() \ No newline at end of file diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/src/twisted_attr.py b/experiments/Figure_Creation/3D Firing Fields - CANs/src/twisted_attr.py new file mode 100644 index 0000000..cb41380 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - CANs/src/twisted_attr.py @@ -0,0 +1,84 @@ +#AUTOGENERATED! DO NOT EDIT! File to edit: dev/twisted_attractor.ipynb (unless otherwise specified). + +__all__ = ['TwistedAttractor'] + +#Cell +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +import matplotlib.pyplot as plt + +#Cell +from .twisted_torus import create_twisted_inh_weights, create_twisted_domain + +class TwistedAttractor(nn.Module): + M = torch.FloatTensor([[ 0., 1., 0., -1.], + [ 1., 0., -1., 0.]]) + + def __init__(self, n=8, sigma=0.2, dt=0.5, v=0.1, noise=0.001 ,cell_pos=None): + super().__init__() + + self.dt = dt + self.n = n + self.noise = noise + + if cell_pos is None : p = create_twisted_domain(n) + else: p = cell_pos + + self.cell_pos = p + + self.W = torch.Tensor(4, n**2, n**2) + for i in range(4): + off = v * self.M[:,[i]] + self.W[i] = create_twisted_inh_weights(p - off, p, sigma=sigma) + + + def activation(self, x): + return F.relu6(x) + + + def to_attr_control(self, v): + u = 1. + torch.matmul(v, self.M) + return u + + + def forward(self, x, v, b, dt=None): + """ + Evolves the dynamical system for ONE time-step with + initial condition `x`, and control signal `v`, + and feedforward input `b` + """ + if dt is None: + dt = self.dt + + f = self.activation + W = self.W + + u = self.to_attr_control(v) + x = x + torch.randn_like(x)*self.noise + y = torch.matmul(x, W); # assert(y.max() <=0) + y = torch.einsum("ubj, bu -> bj", y, u) + + x_dot = -x + f(y + b) + + return x + dt*x_dot + + + def evolve(self, x, V, B, dt=None): + """ + Evolves the dynamical system for MULTIPLE time-steps with + initial condition `x`, and time dependent control signal `V`, + and time dependent feedforward input `B` + """ + T = V.size(0) + n = x.size(-1) + + Y = torch.zeros(T,n) + Y[0, :] = x + + for t in range(1,T): + Y[t,:] = self.forward(Y[t-1,:], V[t-1,:], B[t-1,:], dt) + + return Y + diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/src/twisted_torus.py b/experiments/Figure_Creation/3D Firing Fields - CANs/src/twisted_torus.py new file mode 100644 index 0000000..5884c40 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - CANs/src/twisted_torus.py @@ -0,0 +1,106 @@ +#AUTOGENERATED! DO NOT EDIT! File to edit: dev/twisted_torus.ipynb (unless otherwise specified). + +__all__ = ['return_to_twisted_torus', 'twisted_distance', 'create_twisted_domain', 'create_twisted_inh_weights', + 'TwistedTorus', 't'] + +#Cell +import numpy as np +import torch +import matplotlib.pyplot as plt + +#Cell +def return_to_twisted_torus(x): + h = np.sqrt(3)/2. + x_ = torch.zeros_like(x) + + s = ((x[1]<0) + (x[1]>=h)).float() + + x_[0] = x[0] + s * 0.5 + x_[0] = x_[0]%1. + x_[1] = x[1]%h + + return x_ + +#Cell +def twisted_distance(X, Y): + h = np.sqrt(3)/2. + off = torch.tensor([ + [0 ,0], + [1 ,0], + [-1,0], + [0.5,h], + [-0.5,h], + [0.5,-h], + [-0.5,-h], + ]).t() + x = return_to_twisted_torus(X) + y = return_to_twisted_torus(Y) + + y = y.view(2,-1,1) + off.view(2,1,7) + + diff = x.view(2,1,-1, 1) - y.view(2,-1,1,7) + + norm = torch.norm(diff, dim=0) + dist, _ = torch.min(norm, dim=-1) + + return dist + + +#Cell +def create_twisted_domain(n): + h = np.sqrt(3)/2. + ticks = torch.arange(0,n, dtype=float)/n + m = torch.meshgrid([ticks, ticks]) + g = torch.stack(m).view(2,-1).float() + g[1] = g[1]*h + + return g + +#Cell +def create_twisted_inh_weights(x, y, sigma): + d = twisted_distance(x, y) + W = np.exp(-d**2/(2*sigma**2)) - 1. + W = W - torch.diag(W.diag()) + return W.float() + +#Cell + +class TwistedTorus(object): + def __init__(self, p=None, n = 10): + + h = int(np.sqrt(3)/2. * n) + self.shape = (h, n) +# self.c = np.stack(np.indices((h, n)), axis=2).reshape((-1,2)) + + m = torch.meshgrid([ + torch.arange(0,h, dtype=float)/h*np.sqrt(3)/2., + torch.arange(0,n, dtype=float)/n + ]) + + self.c = torch.stack(m).float().view(2,-1) + if p is None: + p = torch.rand(2) + p = p*torch.tensor([np.sqrt(3)/2., 1]) + + self.p = p + + def __call__(self, v=None): + if not v is None: + self.update(v) + + return self.cell_activity().view(*self.shape) + + def cell_activity(self): + d = twisted_distance(self.p, self.c) + print(d.shape) + return torch.exp(-d**2/0.01) + + def update(self,v): + p = self.p + p_ = p + v + p_ = return_to_twisted_torus(p_) + self.p = p_ + + return p_ + + diff --git a/experiments/Figure_Creation/3D Firing Fields - CANs/src/utils.py b/experiments/Figure_Creation/3D Firing Fields - CANs/src/utils.py new file mode 100644 index 0000000..7d20c15 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - CANs/src/utils.py @@ -0,0 +1,54 @@ +import numpy as np +import torch +from torch import nn +import torch.nn.functional as F +from src.twisted_attr import TwistedAttractor + +class MultiAttractor: + def __init__(self, m=3, n=20, dt=0.4): + self.attr = [] + self.m = m + for i in range(self.m): + attr = TwistedAttractor( + n=n, + sigma=2., + dt=dt, + v=0.1, + cell_pos=None) + + self.attr.append(attr) + + self.reset() + + def reset(self, y=None): + if y is None: self.y = torch.rand(self.m, 1, 400)*0.01 + else: self.y = y.view(self.m, 1, 400).clone() + + def __call__(self, v, b, dt=None): + for i in range(self.m): + self.y[i] = self.attr[i](self.y[i], v[i], b[i], dt) + + return self.y.view(1, self.m*400) + + + +def get_path(T=1000, w=35, vmax=0.4): + x = torch.zeros(T, 3) + x[0] = w/2. + + v = torch.zeros(T, 3) + v[0] = torch.randn(3) + v = torch.clamp(v, -vmax, vmax) + + + for t in range(1,T): + a = torch.randn(3)*0.05 + for i in range(3): + if x[t-1,i] <= 0: a[i] = 0.2 + if x[t-1,i] >= w: a[i] = -0.2 + + v[t] = v[t-1] + a + v[t] = torch.clamp(v[t], -vmax, vmax) + x[t] = x[t-1] + v[t] + + return x, v \ No newline at end of file diff --git a/experiments/MATLAB/As.m b/experiments/Figure_Creation/3D Firing Fields - Idealized/As.m similarity index 63% rename from experiments/MATLAB/As.m rename to experiments/Figure_Creation/3D Firing Fields - Idealized/As.m index d395112..b46f769 100644 --- a/experiments/MATLAB/As.m +++ b/experiments/Figure_Creation/3D Firing Fields - Idealized/As.m @@ -1,28 +1,28 @@ A1 = [ -1.3791 0.6494 0.0606 - 0.1599 -1.3973 -0.5910] + 0.1599 -1.3973 -0.5910]; A2 = [ 0.6827 -0.9140 -0.6783 - -1.1811 -0.3062 0.5223] + -1.1811 -0.3062 0.5223]; A3 = [ 0.9622 -0.2409 -0.8819 - -1.1338 0.5671 -0.3932] + -1.1338 0.5671 -0.3932]; A4 = [ -1.3433 0.0061 -0.7231 - 0.1444 0.7015 1.3470] + 0.1444 0.7015 1.3470]; A5 = [ -0.3914 -1.2575 -0.1644 - -0.8540 0.9061 0.4596] + -0.8540 0.9061 0.4596]; -A6 =[ +A6 = [ -0.6102 -1.1583 -0.2178 - 0.4668 0.7066 -1.0219] -A7=[ + 0.4668 0.7066 -1.0219]; +A7 = [ 1.0753 -0.6331 -1.2320 -0.4730 1.6882 -0.0325]; diff --git a/experiments/Figure_Creation/3D Firing Fields - Idealized/Figures/3d_field_idealized2__id_0_.png b/experiments/Figure_Creation/3D Firing Fields - Idealized/Figures/3d_field_idealized2__id_0_.png new file mode 100644 index 0000000..d3e3e31 Binary files /dev/null and b/experiments/Figure_Creation/3D Firing Fields - Idealized/Figures/3d_field_idealized2__id_0_.png differ diff --git a/experiments/Figure_Creation/3D Firing Fields - Idealized/Figures/example_bubbles.png b/experiments/Figure_Creation/3D Firing Fields - Idealized/Figures/example_bubbles.png new file mode 100644 index 0000000..bfcd4a2 Binary files /dev/null and b/experiments/Figure_Creation/3D Firing Fields - Idealized/Figures/example_bubbles.png differ diff --git a/experiments/Figure_Creation/3D Firing Fields - Idealized/Firing_Fields_3d.m b/experiments/Figure_Creation/3D Firing Fields - Idealized/Firing_Fields_3d.m new file mode 100644 index 0000000..4e75231 --- /dev/null +++ b/experiments/Figure_Creation/3D Firing Fields - Idealized/Firing_Fields_3d.m @@ -0,0 +1,207 @@ + +x = -1:0.02:1.; +y = x; +z = x; +[x,y,z] = meshgrid(x,y,z); +sz = size(x); + +x_ = reshape(x,1,[]); +y_ = reshape(y,1,[]); +z_ = reshape(z,1,[]); +X = vertcat(x_,y_,z_); + + +m = 2 +f = get_bubbles(m, X); +f = reshape(f, sz); + +R = 0.9; +min_f=min(f, [],'all'); +max_f=max(f, [],'all'); +thresh=(1 - R)*min_f + R*max_f; + + + +set(gca,'linewidth',4) +set(gca, 'XTickLabel', []) +set(gca, 'YTickLabel', []) +set(gca, 'ZTickLabel', []) +xticks([-1 0 1]) +yticks([-1 0 1]) +zticks([-1 0 1]) + + +subplot(1,1,1); +% ------------- +isosurface(x, y, z, f, thresh); +isocaps(x, y, z, f, thresh, 'above'); + +xlim([-1 1]); +ylim([-1 1]); +zlim([-1 1]); + +azim = -25; +elev = 30; +lightangle(azim,elev); +daspect([1,1,1]); +camlight +lighting gouraud +grid on +view(22.5,15) +colormap jet + +v1 = [1 1 -1;1 -1 -1; -1 -1 -1; -1 1 -1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',.15, 'LineStyle','none'); +v1 = [1 1 -1; + 1 1 1; + -1 1 1; + -1 1 -1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',.05, 'LineStyle','none'); + +v1 = [-1 -1 -1; + -1 1 -1; + -1 1 1; + -1 -1 1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',.05, 'LineStyle','none'); + +v1 = [1 1 1;1 -1 1; -1 -1 1; -1 1 1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','black','FaceAlpha',0., 'LineWidth',4.); + +v1 = [1 -1 1;1 -1 -1;-1 -1 -1;-1 -1 1]; +f1 = [1 2 3 4]; +patch('Faces',f1,'Vertices',v1,'FaceColor','None','FaceAlpha',1., 'LineWidth',4.); + +v1 = [1 1 1; + 1 1 -1]; +f1 = [1 2]; +patch('Faces',f1,'Vertices',v1,'FaceColor','None','FaceAlpha',1., 'LineWidth',4.); + +v1 = [1 -1 -1; + 1 1 -1]; +f1 = [1 2]; +patch('Faces',f1,'Vertices',v1,'FaceColor','None','FaceAlpha',1., 'LineWidth',4.); + +r = 0 +saveas(gcf,['./Figures/3d_field_idealized' num2str(m) '__id_' num2str(r) '_.png']); + +% ------------------------------------------------------------- +% ------------------------------------------------------------- + +function d = can_distance(X, Y) + global Rhom + Z = mod(X - Y,1); + Z = Rhom(:,[1; 3])*Z; + n1 = vecnorm(Z - Rhom(:,1), 2, 1); + n2 = vecnorm(Z - Rhom(:,2), 2, 1); + n3 = vecnorm(Z - Rhom(:,3), 2, 1); + n4 = vecnorm(Z - Rhom(:,4), 2, 1); + D = vertcat(n1,n2,n3,n4); + d = min(D,[],1); +end + + +function g = normalize(f) + g_ = f - min(f,[],'all'); + g_ = g_./max(g_, [],'all'); + g = g_; +end + +function M=RandOrthMat(n, tol) +% M = RANDORTHMAT(n) +% generates a random n x n orthogonal real matrix. +% +% M = RANDORTHMAT(n,tol) +% explicitly specifies a thresh value that measures linear dependence +% of a newly formed column with the existing columns. Defaults to 1e-6. +% +% In this version the generated matrix distribution *is* uniform over the manifold +% O(n) w.r.t. the induced R^(n^2) Lebesgue measure, at a slight computational +% overhead (randn + normalization, as opposed to rand ). +% +% (c) Ofek Shilon , 2006. + if nargin==1 + tol=1e-6; + end + + M = zeros(n); % prealloc + + % gram-schmidt on random column vectors + + vi = randn(n,1); + + % the n-dimensional normal distribution has spherical symmetry, which implies + % that after normalization the drawn vectors would be uniformly distributed on the + % n-dimensional unit sphere. + M(:,1) = vi ./ norm(vi); + + for i=2:n + nrm = 0; + while nrm" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", + "fig, axs = plt.subplots(figsize=(2., 2.), ncols=1, nrows=8, sharex=True, tight_layout = {\"pad\": 0})\n", + "\n", + "axs[7].set_xlabel(\"Coding Range\")\n", + "axs[0].set_title(\"N = 1\")\n", + "for m_ in range(8):\n", + " m = m_ + 1\n", + " \n", + " ax = axs[7 - m_]\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['bottom'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " ylabel = ax.set_ylabel(\"M={}\".format(m))\n", + " ylabel.set_rotation(0)\n", + " ax.set_yticks([])\n", + " ax.set_xscale(\"log\")\n", + " \n", + " h,_ = np.histogram(X[m_,:], bins=np.exp(x))\n", + "\n", + " ax.plot(np.exp(x[:-1]), h, alpha=1., color=\"black\", linewidth=1.)\n", + " ax.fill_between(np.exp(x[:-1]), h, y2=0, color=\"C2\", alpha=.4)\n", + "\n", + "\n", + "plt.savefig(\"./Figures/S1Fig_1d_distr.pdf\", dpi=300, transparent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", + "\n", + "fig, ax = plt.subplots(figsize=(2.5, 2.), ncols=1, nrows=1, sharex=True, tight_layout = {\"pad\": 0})\n", + "\n", + "ax.set_ylabel(\"Coding Range\")\n", + "\n", + "ms = np.arange(1,9)\n", + "ax.set_title(\"N = 1\")\n", + "ax.set_xticks(ms)\n", + "ax.spines['right'].set_visible(False)\n", + "ax.spines['top'].set_visible(False)\n", + "ax.set_xlabel(\"M\")\n", + "ax.set_yscale(\"log\")\n", + "\n", + "ax.set_xticks(ms)\n", + "ax.set_xlim(0.5,ms[-1]+.5)\n", + "\n", + "\n", + "\n", + "\n", + "k = 1\n", + "k_ = k - 1\n", + "valid = np.where(2*ms>=k)[0] \n", + "a = np.exp(log_mean - 2*log_std)[valid,k_]\n", + "b = np.exp(log_mean)[valid,k_]\n", + "c = np.exp(log_mean + 2*log_std)[valid,k_]\n", + "\n", + "\n", + "p = 0.2 * (1./(0.2**2))**ms\n", + "\n", + "\n", + "\n", + "ax.plot(ms[valid], p[valid], \n", + " color=\"black\",\n", + " linewidth= 3,\n", + " linestyle=\"-\",\n", + " alpha=1.,\n", + " marker=\"None\", markersize=8 , markerfacecolor=\"cyan\") \n", + "\n", + "ax.plot( [ms[valid],ms[valid]] ,[a,c], linewidth=1.,color=\"C0\",linestyle=\"-\", alpha=1.)\n", + "ax.plot(ms[valid], b, \n", + " marker=\"s\", color=\"C0\", \n", + " markerfacecolor= \"white\",\n", + " markersize=6,\n", + " markeredgewidth=1.,\n", + " linewidth=1., \n", + " linestyle=\"none\")\n", + " \n", + "plt.savefig(\"./Figures/S1Fig_1d_bench.pdf\", dpi=300, transparent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/experiments/Figure_Creation/Capacity Figures/Capacity Data Figures.ipynb b/experiments/Figure_Creation/Capacity Figures/Capacity Data Figures.ipynb new file mode 100644 index 0000000..077b7b1 --- /dev/null +++ b/experiments/Figure_Creation/Capacity Figures/Capacity Data Figures.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import skewnorm\n", + "from scipy.stats import norm\n", + "\n", + "import numpy as np\n", + "import pickle\n", + "\n", + "from src.prediction import construct_predictions\n", + "from src.utils import gather_data\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load ND data we want to analyse\n", + "\n", + "- **Width** data is a 4D array \"indexed\" by\n", + "(delta, module, dimension, trial)\n", + " - Here data for *one* delta only \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W shape is (9, 4, 60) indexed by module number, dimension, trial\n" + ] + } + ], + "source": [ + "\"\"\"\n", + " Load the ND data, \n", + " which we want to analyze\n", + "\"\"\" \n", + "\n", + "path_to_data = \"./data/m_k_normal\"\n", + "W = gather_data(path_to_data, \"width\")\n", + "\n", + "\n", + "\n", + "\n", + "W = W[0,:,:,:]\n", + "log_mean = np.mean(np.log(W), axis=2)\n", + "log_std = np.std(np.log(W), axis=2)\n", + "\n", + "print(f\"W shape is {W.shape} indexed by module number, dimension, trial\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Construct predictions from 1d data\n", + "\n", + "- **Width** data for prediction again is a 4D array \"indexed\" by\n", + "(delta, module, dimension, trial)\n", + " - Here we need data for 1D only \n", + "- **Prediction** is computed from log 1D data and will spit out a 3D array \"indexed\" by (modules, dimensions, delta)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction shape is (9, 7, 5)\n" + ] + } + ], + "source": [ + "path_to_data = \"./data/benchmark_normal\"\n", + "\n", + "X = gather_data(path_to_data)\n", + "X = X[:, :, 0, :]\n", + "X = np.swapaxes(X, 0, 1)\n", + "\n", + "logX = np.log(X)\n", + "prediction = construct_predictions(logX[:,:], \n", + " ms=range(1,9 + 1), #No. of modules\n", + " ks=range(1,7 + 1), #Input dim\n", + " ps=range(5), #Index into phase resolution subarray\n", + " raw=False)\n", + "\n", + "print(f\"Prediction shape is {prediction.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Figure 3a, 3b" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", + "fig, axes = plt.subplots(figsize=(5., 1.25), ncols=4, sharey=False, tight_layout = {\"pad\": 0})\n", + "\n", + "ms = np.arange(1,10)\n", + "ks = np.array([3,4,5,6])\n", + "\n", + "axes[0].set_ylabel(\"Range\")\n", + "for i,ax in enumerate(axes):\n", + "\n", + " ax.set_title(\"N = {}\".format(ks[i]))\n", + " ax.set_xticks(ms)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['top'].set_visible(False)\n", + " ax.set_xlabel(\"M\")\n", + " ax.set_yscale(\"log\")\n", + "\n", + " ax.set_xticks(ms)\n", + " ax.set_xlim(0.5,ms[-1]+.5)\n", + "\n", + " \n", + " k = ks[i]\n", + " k_ = i\n", + "\n", + " \n", + " valid = np.where(ms>=k)[0]\n", + "\n", + " \n", + " ax.plot(ms[valid], prediction[valid,k - 1,1], \n", + " color=\"black\",\n", + " linewidth= 3,\n", + " linestyle=\"-\",\n", + " alpha=1.,\n", + " marker=\"None\", markersize=8 , markerfacecolor=\"cyan\") \n", + "\n", + " valid = np.where(2*ms>=k)[0] \n", + " a = np.exp(log_mean - 2*log_std)[valid,k_]\n", + " b = np.exp(log_mean)[valid,k_]\n", + " c = np.exp(log_mean + 2*log_std)[valid,k_]\n", + " \n", + " ax.plot( [ms[valid],ms[valid]] ,[a,c], linewidth=1.,color=\"C0\",linestyle=\"-\", alpha=1.)\n", + " ax.plot(ms[valid], b, \n", + " marker=\"s\", color=\"C0\", \n", + " markerfacecolor= \"white\",\n", + " markersize=4,\n", + " markeredgewidth=1.,\n", + " linewidth=.5, \n", + " linestyle=\"none\")\n", + " \n", + "\n", + "plt.savefig(\"./Figures/Fig3a_Capacity.pdf\", dpi=300, transparent=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", + "fig, axes = plt.subplots(figsize=(3., 1.25), ncols=2, sharey=False, tight_layout = {\"pad\": 0})\n", + "\n", + "ms = np.arange(1,10)\n", + "ks = np.array([5,6])\n", + "\n", + "axes[0].set_ylabel(\"Range\")\n", + "for i,ax in enumerate(axes):\n", + "\n", + " ax.set_title(\"N = {}\".format(ks[i]))\n", + " ax.set_xticks(ms)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['top'].set_visible(False)\n", + " ax.set_xlabel(\"M\")\n", + " ax.set_yscale(\"log\")\n", + " ax.set_xticks(ms)\n", + " ax.set_xlim(0.5,ms[-1]+.5)\n", + "\n", + " \n", + " k = ks[i]\n", + " valid = np.where(ms>=k)[0]\n", + " for d in range(1,5):\n", + " l = 3. if d == 1 else 1\n", + " c = \"black\" \n", + " ax.plot(ms[valid], prediction[valid,k - 1,d], \n", + " color=c,\n", + " linewidth= l,\n", + " linestyle=\"-\",\n", + " marker=\"None\", markersize=2 , markerfacecolor=\"black\") \n", + "\n", + "\n", + "plt.savefig(\"./Figures/Fig3b_Capacity.pdf\", dpi=300, transparent=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", + "fig, ax = plt.subplots(figsize=(2., 1.25), ncols=1, sharey=False, tight_layout = {\"pad\": 0})\n", + "\n", + "\n", + "m = 9\n", + "ks = np.array([3,4,5,6])\n", + "\n", + "\n", + "ax.set_title(\"M={}\".format(m))\n", + "ax.spines['right'].set_visible(False)\n", + "ax.spines['top'].set_visible(False)\n", + "ax.set_xlabel(\"N\")\n", + "ax.set_ylabel(\"Range\")\n", + "ax.set_yscale(\"log\")\n", + "\n", + "ax.set_xticks(1 - 1./ks)\n", + "ax.set_xticklabels(ks)\n", + "\n", + "\n", + "\n", + "\n", + "p = prediction[m - 1,ks-1,1]\n", + "f = W[m-1,:,:]\n", + "\n", + "\n", + "ax.plot(1 - 1./ks, p, \n", + " color=\"black\",\n", + " linestyle=\"-\",\n", + " marker=\"None\", linewidth=3,\n", + " alpha=1., zorder=1000)\n", + "\n", + "\n", + "for t in range(50,60):\n", + " ax.plot(1 - 1./ks, f[:,t], \n", + " color=\"C1\",\n", + " linestyle=\"-\",\n", + " marker=\"o\",\n", + " markerfacecolor=\"white\",\n", + " markeredgewidth=0.5,\n", + " markersize=3,\n", + " linewidth=0.5,\n", + " alpha=1., zorder=-1000)\n", + "\n", + "\n", + "plt.savefig(\"./Figures/Fig4a_Trade_Off.pdf\", dpi=300, transparent=False)\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/experiments/Figures/Capacity_Figure_5a.pdf b/experiments/Figure_Creation/Capacity Figures/Figures/Fig3a_Capacity.pdf similarity index 54% rename from experiments/Figures/Capacity_Figure_5a.pdf rename to experiments/Figure_Creation/Capacity Figures/Figures/Fig3a_Capacity.pdf index 0b27b3a..f03ea8b 100644 Binary files a/experiments/Figures/Capacity_Figure_5a.pdf and b/experiments/Figure_Creation/Capacity Figures/Figures/Fig3a_Capacity.pdf differ diff --git a/experiments/Figure_Creation/Capacity Figures/Figures/Fig3b_Capacity.pdf b/experiments/Figure_Creation/Capacity Figures/Figures/Fig3b_Capacity.pdf new file mode 100644 index 0000000..23f7272 Binary files /dev/null and b/experiments/Figure_Creation/Capacity Figures/Figures/Fig3b_Capacity.pdf differ diff --git a/experiments/Figure_Creation/Capacity Figures/Figures/Fig4a_Trade_Off.pdf b/experiments/Figure_Creation/Capacity Figures/Figures/Fig4a_Trade_Off.pdf new file mode 100644 index 0000000..933d5d1 Binary files /dev/null and b/experiments/Figure_Creation/Capacity Figures/Figures/Fig4a_Trade_Off.pdf differ diff --git a/experiments/Figures/Capacity_Figure_5b.pdf b/experiments/Figure_Creation/Capacity Figures/Figures/S1Fig_1d_bench.pdf similarity index 56% rename from experiments/Figures/Capacity_Figure_5b.pdf rename to experiments/Figure_Creation/Capacity Figures/Figures/S1Fig_1d_bench.pdf index 960605f..b125d3f 100644 Binary files a/experiments/Figures/Capacity_Figure_5b.pdf and b/experiments/Figure_Creation/Capacity Figures/Figures/S1Fig_1d_bench.pdf differ diff --git a/experiments/Figure_Creation/Capacity Figures/Figures/S1Fig_1d_distr.pdf b/experiments/Figure_Creation/Capacity Figures/Figures/S1Fig_1d_distr.pdf new file mode 100644 index 0000000..0fff805 Binary files /dev/null and b/experiments/Figure_Creation/Capacity Figures/Figures/S1Fig_1d_distr.pdf differ diff --git a/experiments/prediction.py b/experiments/Figure_Creation/Capacity Figures/src/prediction.py similarity index 73% rename from experiments/prediction.py rename to experiments/Figure_Creation/Capacity Figures/src/prediction.py index b7fc88b..0fb7375 100644 --- a/experiments/prediction.py +++ b/experiments/Figure_Creation/Capacity Figures/src/prediction.py @@ -42,13 +42,17 @@ def get_interpolated_params(m_frac, ph, params): def predict_log_capacity(m,n,p, logX, params, raw=False): - x = np.linspace(np.amin(logX),np.amax(logX), num=100) m_frac = float(m)/float(n) - f = skewnorm.pdf(x,*get_interpolated_params(m_frac, p, params)) - f = f/np.sum(f) + a, loc, scale = get_interpolated_params(m_frac, p, params) + x_min = loc - 5.*scale + x_max = loc + 5.*scale + x = np.linspace(x_min, x_max, num=100) - C = np.random.choice(x, p=f, size=(n,100000)) + + f = skewnorm.pdf(x, a, loc, scale) + f = f/np.sum(f) + C = np.random.choice(x, p=f, size=(n,100000)) pred_raw = np.amin(C, axis=0) pred_mean = np.mean(pred_raw) @@ -63,6 +67,16 @@ def construct_predictions(logX, ms, ks, ps, raw=False): else: prediction = np.zeros((max(ms), max(ks), len(ps))) + # + # UNDERFLOW WARNING: + # + # The function `skewnorm` within `predict_log_capacity` can cause an + # underflow warning/error, but it doesn't seem to be an issue for our computations. + # The function f in `predict_log_capacity` looks fine even + # after normalization. So I just ignore the error :| + # + old_err_setting = np.seterr(under="warn") + for m,k,p in [ (m,k,p) for m in ms for k in ks for p in ps]: m_ = m-1 k_ = k-1 @@ -70,8 +84,10 @@ def construct_predictions(logX, ms, ks, ps, raw=False): pred = predict_log_capacity(m,k,p, logX, params, raw) prediction[m_,k_,p] = np.exp(pred) + np.seterr(**old_err_setting) + return prediction - \ No newline at end of file + diff --git a/experiments/Figure_Creation/Capacity Figures/src/utils.py b/experiments/Figure_Creation/Capacity Figures/src/utils.py new file mode 100644 index 0000000..6d36b19 --- /dev/null +++ b/experiments/Figure_Creation/Capacity Figures/src/utils.py @@ -0,0 +1,30 @@ +import numpy as np +import pickle +from os import listdir +from os.path import isfile, join + + +def gather_data(mypath, key="width"): + """ + Loads trials from a folder and + returns an array indexed by: m, k, t. + """ + filenames = [join(mypath, f) for f in listdir(mypath) if isfile(join(mypath, f))] + filenames = [f for f in filenames if f.endswith(".p")] + W = [] + for filename in filenames: + with open(filename, 'rb') as f: + data = pickle.load(f, encoding='latin1') + W.append(np.expand_dims(data[key], axis=-1) ) + + W = np.concatenate(W, axis=-1) + return W + + +def normalized_histogram(data, bins=200): + h, b = np.histogram(data, bins=bins) + h = h.astype(float) + h= h/np.amax(h) + return h, b[:-1] + + diff --git a/experiments/Figure_Creation/README.md b/experiments/Figure_Creation/README.md new file mode 100644 index 0000000..97fc44e --- /dev/null +++ b/experiments/Figure_Creation/README.md @@ -0,0 +1,3 @@ +# Figures and visualizations + +Examples of the figures created by the scripts in this folder can be found in `_Figures`. All figures in the paper that are created from data are versions and combinatinos of the ones found here. diff --git a/experiments/Figure_Creation/Tilted Planes/.ipynb_checkpoints/Tilted Planes and 3d Fields-checkpoint.ipynb b/experiments/Figure_Creation/Tilted Planes/.ipynb_checkpoints/Tilted Planes and 3d Fields-checkpoint.ipynb new file mode 100755 index 0000000..e027830 --- /dev/null +++ b/experiments/Figure_Creation/Tilted Planes/.ipynb_checkpoints/Tilted Planes and 3d Fields-checkpoint.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "from scipy.stats import ortho_group\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D \n", + "from src.utils import create_firing_field, get_3dA, lattice" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "step_size = 0.1\n", + "env_size = 2\n", + "b = int(env_size/step_size)\n", + "\n", + "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size, 0:env_size:step_size]\n", + "X = X.reshape((3,-1)).T\n", + "X = X - env_size*0.5\n", + "\n", + "\n", + "f = np.ones((5, b,b,b))\n", + "A = np.zeros((5,2,3))\n", + "for i in range(1,5): \n", + "\n", + " if i==1:\n", + " Q = np.eye(3)\n", + " else:\n", + " Q = ortho_group.rvs(3)\n", + "\n", + " A[i-1] = np.dot( get_3dA(s=1.), Q)\n", + " \n", + " g = create_firing_field(X, A[i-1])\n", + " g = g.reshape((b,b,b))\n", + " f[i] = f[i-1]*g" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(22,4))\n", + "\n", + "thresh = 0.7\n", + "for i in range(1,5):\n", + " ax = fig.add_subplot(1, 4, i, projection='3d')\n", + " ax.set_title(\"M={}\".format(i))\n", + " ax.set_xticklabels([])\n", + " ax.set_yticklabels([])\n", + " ax.set_zticklabels([])\n", + " g = f[i]\n", + " voxels = g > np.amax(g)*thresh\n", + " ax.voxels(voxels, edgecolor='k')\n", + " \n", + "plt.savefig(\"./Figures/3D_fields_lego.pdf\", dpi=300, transparent=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.signal import correlate2d\n", + "\n", + "step_size = 0.02\n", + "env_size = 2\n", + "b = int(env_size/step_size)\n", + "\n", + "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size]\n", + "X = X.reshape((2,-1)).T\n", + "X = X - env_size*0.5\n", + "\n", + "\n", + "Plane_base = np.array([\n", + " [np.cos(-np.pi/4.),0,np.sin(-np.pi/4.)],\n", + " [0,1,0]\n", + "])\n", + "\n", + "X_ = np.dot(X, Plane_base)\n", + "\n", + "\n", + "i = 1\n", + "img = create_firing_field(X_, A[i])\n", + "img = img.reshape((b,b))\n", + "\n", + "corr = correlate2d(img,img, mode=\"full\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "fig = plt.figure(figsize=(4,2))\n", + "ax = fig.add_subplot(1,2,1)\n", + "ax.axis(\"off\")\n", + "ax.imshow(img.T, cmap=\"jet\")\n", + "\n", + "ax = fig.add_subplot(1,2,2)\n", + "ax.axis(\"off\")\n", + "ax.imshow(corr.T, cmap=\"jet\")\n", + "\n", + "plt.savefig(\"./Figures/2D_Field_Tilted_Plane.pdf\", dpi=300, transparent=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80\n", + "[[ 1.25 -0.72168784 0. ]\n", + " [ 0. 1.44337567 0. ]]\n" + ] + } + ], + "source": [ + "\n", + "step_size = 0.05\n", + "env_size = 4.\n", + "b = int(env_size/step_size)\n", + "\n", + "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size]\n", + "X = X.reshape((2,-1)).T\n", + "X = X - env_size*0.5\n", + "\n", + "angle = np.pi*0.5\n", + "rot = 0.0\n", + "\n", + "Plane_base = np.array([\n", + " [np.cos(rot), np.sin(rot), 0],\n", + " [np.cos(angle)*np.cos(rot + np.pi/2.),np.cos(angle)*np.sin(rot + np.pi/2.), np.sin(angle)]\n", + "])\n", + "\n", + "\n", + "PL2 = np.array([\n", + " [1,0, 0],\n", + " [0,1, 0]\n", + "])\n", + "\n", + "\n", + "\n", + "X_ = np.dot(X, Plane_base)\n", + "\n", + "\n", + "\n", + "X_2 = np.dot(X, PL2)\n", + "\n", + "img = create_firing_field(X_, A)\n", + "img = img.reshape((b,b))\n", + "\n", + "thresh = 0.7\n", + "voxels = g > np.amax(g)*thresh" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import scipy\n", + "\n", + "\n", + "def get_3dA(s):\n", + " B = np.zeros((3,3))\n", + " B[:2,:2] = lattice(np.random.sample()*np.pi*2.,np.pi/3.)\n", + " B[:2,2] = np.random.randn(2)*0.05\n", + " B[2,2] = 1 + np.random.randn()*0.1\n", + " A = np.zeros((2,3))\n", + " A = np.linalg.inv(s*B)[:2]\n", + " return A\n", + "\n", + "\n", + "for _ in range(3):\n", + " A = get_3dA(s=0.8)\n", + " \n", + " img = create_firing_field(X_ + np.random.randn(3), A)\n", + " img2 = create_firing_field(X_2, A)\n", + " img = img.reshape((b,b))\n", + " img2 = img2.reshape((b,b))\n", + " \n", + " f = img\n", + " f2 = img2\n", + " f = f - np.median(f)\n", + " f = f/np.std(f)\n", + " \n", + " f2 = f2 - np.median(f2)\n", + " f2 = f2/np.std(f2)\n", + " \n", + " corr = scipy.signal.correlate2d(f,f, mode=\"full\")\n", + "\n", + " fig = plt.figure(figsize=(2,1))\n", + " ax = fig.add_subplot(1,2,1)\n", + " ax.axis(\"off\")\n", + " ax.imshow(f.T, cmap=\"jet\")\n", + "\n", + " ax = fig.add_subplot(1,2,2)\n", + " ax.axis(\"off\")\n", + " ax.imshow(corr.T, cmap=\"jet\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/experiments/Figure_Creation/Tilted Planes/Figures/2D_Field_Tilted_Plane.pdf b/experiments/Figure_Creation/Tilted Planes/Figures/2D_Field_Tilted_Plane.pdf new file mode 100644 index 0000000..8ce39a1 Binary files /dev/null and b/experiments/Figure_Creation/Tilted Planes/Figures/2D_Field_Tilted_Plane.pdf differ diff --git a/experiments/Figure_Creation/Tilted Planes/Figures/3D_fields_lego.pdf b/experiments/Figure_Creation/Tilted Planes/Figures/3D_fields_lego.pdf new file mode 100644 index 0000000..7fa05d3 Binary files /dev/null and b/experiments/Figure_Creation/Tilted Planes/Figures/3D_fields_lego.pdf differ diff --git a/experiments/Figure_Creation/Tilted Planes/Tilted Planes and 3d Fields.ipynb b/experiments/Figure_Creation/Tilted Planes/Tilted Planes and 3d Fields.ipynb new file mode 100755 index 0000000..e027830 --- /dev/null +++ b/experiments/Figure_Creation/Tilted Planes/Tilted Planes and 3d Fields.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "from scipy.stats import ortho_group\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D \n", + "from src.utils import create_firing_field, get_3dA, lattice" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "step_size = 0.1\n", + "env_size = 2\n", + "b = int(env_size/step_size)\n", + "\n", + "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size, 0:env_size:step_size]\n", + "X = X.reshape((3,-1)).T\n", + "X = X - env_size*0.5\n", + "\n", + "\n", + "f = np.ones((5, b,b,b))\n", + "A = np.zeros((5,2,3))\n", + "for i in range(1,5): \n", + "\n", + " if i==1:\n", + " Q = np.eye(3)\n", + " else:\n", + " Q = ortho_group.rvs(3)\n", + "\n", + " A[i-1] = np.dot( get_3dA(s=1.), Q)\n", + " \n", + " g = create_firing_field(X, A[i-1])\n", + " g = g.reshape((b,b,b))\n", + " f[i] = f[i-1]*g" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABNoAAADnCAYAAADIIDsqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9eXRk91m/+dxb+yKVttbS6k3qbi3dbXe32+1uJ3EyMQackA1DEggJA/zCJEDCQOYclsBhSAIhQwKEJMNwGMJAfiELARICcQIhxImx463dbbstlfZ9KZWkUu1Vt+reO3/I97qqdCWVSqWt+/uc43PcWqpuddd96/1+3vf9vJKu6wgEAoFAIBAIBAKBQCAQCASC7SHv9QUIBAKBQCAQCAQCgUAgEAgEtwJCaBMIBAKBQCAQCAQCgUAgEAiqgBDaBAKBQCAQCAQCgUAgEAgEgioghDaBQCAQCAQCgUAgEAgEAoGgCgihTSAQCAQCgUAgEAgEAoFAIKgC9k2+L1aSCgSCcpD2+gJ2ABH/BAJBOdyK8Q9EDBQIBOVxK8ZAEf8EAkE5rBv/REebQCAQCAQCgUAgEAgEAoFAUAWE0CYQCAQCgUAgEAgEAoFAIBBUASG0CQQCgUAgEAgEAoFAIBAIBFVACG23OSdOnMDpdLK4uFj09QsXLiBJEuPj42U/1ne/+11e+9rXEggEOHHiRHUvVCAQCKpMNePfxz/+cc6dO0dNTQ0dHR18/OMfr/LVCgQCQfWoZvz75Cc/SWdnJ7W1tRw+fJhf//VfJ5/PV/mKBQKBoHpUMwYaKIpCT08PR44cqdJVCg4yQmgT0NHRwRe/+EXzzy+88ALpdHrLj+Pz+fiFX/gFccAUCAQHhmrFP13X+dznPkckEuFb3/oWn/nMZ/jSl75UzUsVCASCqlKt+PfGN76RZ599llgsxs2bN3nuuef41Kc+Vc1LFQgEgqpTrRho8PGPf5zm5uZqXJrgFkAIbQLe9a538bnPfc7889/93d/xsz/7s1t+nHvuuYd3vetddHZ2VvPyBAKBYMeoVvz7jd/4De666y7sdjvd3d28+c1v5rHHHqvmpQoEAkFVqVb8O3nyJHV1dcBq0UGWZYaHh6t2nQKBQLATVCsGAoyNjfH5z3+e3/7t367W5QkOOEJoE3D16lVisRj9/f2oqsqXv/xl3vnOd5rf/9jHPkZdXd26/wkEAsFBZSfin67rPProo5w9e3a3XoZAIBBsmWrGvy984QvU1tbS1NTEc889x3ve857dfjkCgUCwJaoZA9///vfz0Y9+FI/Hs9svQ7BPEUKbAHhZ0f/2t79NT08P7e3t5vd+67d+i5WVlXX/EwgEgoNMtePf7//+76NpGj//8z+/Wy9BIBAIKqJa8e8d73gHsViMwcFB3vve99LS0rLbL0UgEAi2TDVi4Fe/+lXy+Tw//uM/vhcvQbBPse/1BQj2B+9617t49atfzdjYWMUtswKBQHAQqWb8+8xnPsPnPvc5Hn30UVwuV5WuUCAQCHaGaud/p0+f5uzZs/zyL/8y//zP/1yFKxQIBIKdY7sxMJlM8hu/8Rs8/PDDO3B1goOM6GgTAHD8+HE6Ojp4+OGHeeihh4q+99GPfhS/37/ufwKBQHCQqVb8+5u/+Rs+9rGP8Z3vfEdsnBIIBAeCncj/8vk8IyMjO33pAoFAsG22GwOHhoYYHx/nvvvuo7W1lYceeoi5uTlaW1sr2lwquHUQHW0Ck89+9rNEIhF8Pl/RWvYPfvCDfPCDH9z09zVNQ1EUcrkcuq6TyWSQZRmn07mTly0QCATbZrvx7+///u/54Ac/yHe/+12xEEYgEBwothv//vqv/5o3velNNDc309fXxx/90R/xoz/6ozt5yQKBQFA1thMDz507x9TUlPnnxx9/nPe97308++yzHDp0aMeuWbD/EUKbwOTkyZPb+v3vf//7vPa1rzX/7PF4eM1rXsMjjzyyzSsTCASCnWW78e93f/d3WVpa4vLly+bX3vnOd/KXf/mX2700gUAg2FG2G/8ee+wxfud3fodEIsGhQ4d461vfykc+8pEqXZ1AIBDsLNuJgXa7ndbWVvPPDQ0NyLJc9DXB7Ymk6/pG39/wmwKBQPAS0l5fwA4g4p9AICiHWzH+gYiBAoGgPG7FGCjin0AgKId145/oaLuF0HUdXddJp9NomobD4cBms2Gz2ZAkCUm6FT8HBQKBYBVjfF1RFOx2O3a7HZvNhizLIv4JBIJbGl3XyefzpNNpM/YV5oACgUBwq6LrOqqqkk6nkWUZm82G3W5HlmVkWVjSC/YG0dF2i6DrOrlcDlVVyefzqKpa9H1JksygI8Q3wQ5wK76RRPw7IBgHTCP25XK5NbHNiH+FiZeIf4Iqcau+kUQMPAAYB8x8Po+maaZPbiGyLIvig2AnuRXfTCL+HRCMuFcY/zRNM2OcJElF8U8UHwRVZt03kxDaDjiFB0wARVEYHh5GkiQCgQA1NTW43W7zZ3VdZ2BggNOnTxcJb0L1F2yTW/ETS8S/fU7hAdNIrMbHx0mlUtTW1lJbW4vP5zN/Vtd1ZmZm8Pv9BAIBbDab6PwVVINb9U0jYuA+p/CACTA/P8/CwgI1NTXU1tbi9/uRZdmMf9FolEQiQXt7uxn3hPgmqAK34htHxL99TmGTiSRJRKNRxsfH8Xq9Zgy021eH9zRNQ1VVhoeH6erqWtN8IsQ3wTYQo6O3GsahcnZ2FqfTSU1NDVNTU8zMzHDixAkkSSIejzM/P08mk8HlcplBJ5lMmglVPp9HURSh+gsEggOFpmmsrKwQjUZpa2tjcXGRoaEh2traaGlpIZFIMDExQSqVwmazUVNTQ01NDalUCq/XiyzLaJpGJpMBVmNq4biBEN8EAsF+xSiyDg4O0tnZSTKZJBgM4vV6aW9vJ5lMMjc3RyKRQNd1/H4/tbW15ni9Ef9UVSWbzZoxTnT+CgSC/Y4R/4aHhzl69CiapjE0NEQ6neb48eNks1kikQgTExPk83m8Xq9ZeE0mk9hsNmC1OaUQ0fkrqDaio+0AUljBHBsbQ9M0wuEwzc3NdHR0oGlaUcssQDabJRaLEYvFmJmZweVy4fF4zK6PmpqaItVf13UkSULXdaH6C8rhVnxDiPi3Dyns4l1ZWWFqaop8Po/D4aCrqwuHw0Eulyvqzs3lcsTjceLxOHNzc2iaZsY/owDhcrnMxy/8XDSKD6LzV7ABt2L8AxED9x1GF28ulwPgBz/4AQ0NDcRiMXp6eqitrS0qngKoqkoymSQWi7G4uEgikcDtdpuxr7a2Fq/Xaz5+6blAdP4KyuBWfEOI+LfPMJpMjPHQp59+mubmZmZnZzl58iTNzc1rrEN0XSeVSpln4Pn5ebxeLz6fz8wBSzt/CxGdv4IyEKOjtwKlY6LZbJZnn30WSZK4cOGCmSgZItx6geDZZ5/ljjvuMA+fsViMeDxepPobIweG6m+MJRgI1V9Qwq34jy/i3z7Caky0v7+fcDjMhQsXaGhoADAPoeuJYaOjo2aMM2JfLBYjm83icrmKxDen02kmXsLvQ7ABt+o/voiB+wirMdGbN29y5swZ2tvbzeJoqdBWSCQSYWlpiRMnTpjFh1gsRiqVwm63F4lvpbYjxv+Lzl+BBbfiP76If/uI0jHRlZUVrl27Rnt7O6dPn8Zut28a/3Rd55lnnuHSpUtm8SEej5NIJADMzt+amhp8Pp8ZU43/ROevYB3E6OhBpvSAqes6k5OTzM3NEQgEaGhoMEU2YNOb3fi+1+vF6/XS0tJiPo+h+odCIYaHh9F13VT9DfGtMJkrbLsVqr9AINgJSg+Y4XCY4eFhGhsbOXTokCmyQXnxT9d1nE4nTU1NNDU1Aavxz+j8jUajTE1Nkcvl1nS+GcWHXC5ndpWIzl+BQLBTlB4w4/E4AwMD+P1+fD4fR44c2fLj2e126uvrqa+vN7+ey+XMg2coFCKTyZjWJEYO6HK5inJSA9H5KxAIdgIrL/KhoSGy2Sw1NTV0dnaaE1nlIsuyaSdioKoqiUSCWCzG1NSUabNkxL+amhrzrK1pGtlslmw2a/6+6PwVWCGEtn1O4QFTkiSWl5cZHBykpaWFq1evMjU1tabbrJwb26qTUZIkfD4fPp+PtrY28/kN1X9mZoZEIoEkSWaAMkYOJEmy9PsoFPWE6i8QCLZCaYKVSqUIBoO4XC7uvvtuFEVhfHy8osctRZIk3G43breb5uZm8+fS6TSxWIylpSXGxsZQVbVo5KCmpmZDv498Pm92B4v4JxAIyqV0TNTwJEokEuaY6OOPP76lxzQKDVY4HA4aGxtpbGw0v5bNZs2ut5mZGRRFWTN2ahxySz1/jfjn8XjMA6iIfwKBoBxKx0R1XWd6eprp6WlOnTpFc3Mz169ft4xnhd1nhWwU/2w2G4FAgEAgYH4tn8+b8W9xcdHs/C20XTI6fws9f43n0jQNh8OBy+US4tttihDa9imlB8xMJsPAwAAAFy9exOPxANZBY5Nx4C3d5IWqf3t7O1Cs+htm47IsF3V9GNdnJGfd3d3mYwrVXyAQbERpF6+qqoyOjrK8vExPT4/ZhWEkYFthK7FGkiSz87e1tRVYTaasOn8LRw4KO3+vX7/OpUuXzMcUnb8CgWAzjKUFRnybnZ1lYmKCjo4Oent7dy1muFwuXC5XUedvJpMhHo9bmo2XFh9efPFFuru7cTqdwMu2I6LzVyAQrEdpk8nKygoDAwM0NTVx9epVM76UnoGN8+RW88L1sOr8VRTFFN+sFg7W1NSYnb9TU1NFxVvR+Xv7IYS2fYbVmOj4+DihUIiuri4z2TGoJKBsNwitp/obIwcjIyOk02lTxc9ms+RyOdNs3Er1F34fAoEA1o6JhkIhRkdHOXr0KFevXl0TF0o7ejdju/FPlmX8fj9+v7/oGoziw/T0NMlk0uz8zefzpNNpfD6f+bNi059AILDCakw0GAwSCAS4cuXKlkekStlu/JMkCY/Hg8fjKer8NYoP4XCY0dFRNE3D5/ORyWRIJpM4nU7zQCk2/QkEAiusxkQHBgbI5/OcP3++yCYJKj8Dbwen01nU+WtYKVnZjuTzeQKBAJqmbdj5a3UGFtwaCKFtH1Gq4C8tLTE0NERbWxtXr161VL2N1tRS1mub3SnsdjsNDQ1FXkmKojA/P08ymWRgYMA0Gy8cOTDMxoXfh0Bwe1OYYEmSRDKZJBgM4vF4uHz5stkRUch+iQlGR29tba35tXw+TyKRYHFxkYmJCZLJZJHZeE1Njdn5K/w+BILbm9IDZi6XY3h4mFQqxZkzZ4q8hLbDTsSQjWxHXnzxRRYWFswRf7/fb8bAQrPx9Tx/HQ6HKD4IBLc4G3mRG2OiVlSze61SJEnC5XJx6NAhDh06BLxsOzI6Oko8HueFF14gn8/j8/mKckAjhy30/IXi4oMhxIn4dzARQts+oDTBSqfTDAwMYLPZuOuuu8z5byv2oqNteXmZB1//BhaXlrjvFVd54IEHePOb31x0yIRV1b+uro5UKkVPT49pNh6Px9eo/oWBR6j+AsHtQ6kPkaqqjIyMsLKyQm9vb1HnbCl7Ef/KxW63U1dXh9Pp5OzZswBFm54XFhbMzl9DpCs0GxedvwLBrU+pDxHAzMwMk5OTdHZ2cubMmarf47sR/wzbEbfbzalTp3A6nRuajRd6/sL6nb9G8UGIbwLBrUFpk0kkEmFgYIDm5mauXLlijolasR+ENisM2xG/34/X66W5uRld10kmk+aymY0WDgJrig+i8/dgIoS2PaRUwdc0jfHxccLhMN3d3UXdYetRaZCpNDD96Z/+KR/56MewN53AdfxevnljjK9/+/f4lfe9H4fbg9Mm8+Y3vZHXve51vO51ryvqrCs0Gy9V/TczG99M9Rd+HwLBwaN0THR+fp6xsTGOHTtGd3d3WRtEd3t0dDs4HI41nb+FZuOzs7Nks9kis/Gampqizt9cLlcUU0Xnr0BwMCk9YMZiMYLBIPX19VUZE7Vit+Nf4XNtZDYej8cZGxvbktk4UHTwFMUHgeDgUNpkks1mGRgYQNd1Lly4sGZM1Ir9KrQZlPrHGbYjhZ2/iUSCeDy+6cLB9Tp/he3I/kYIbXuEpmmmmfaxY8dYXFxkaGiI9vZ2rly5UvZhabfm02/evMkP/fCDpNNJHPWH8Zy+F+fh03hPX119LT/4Mpmpm9iO3cE/Pfo8X/7qv6Fmk7i9fpoaAvR2d/Orv/qr3HfffUWvzcps3FD9yzEbh2K/D+Pvtbm5Waj+AsE+xfAh6uvro6enh2QySX9/P36/f90xUSv2e5JVDpuZjU9OTpLL5fB6vUXim1HlLe38jUQiRfFPFB8Egv2FccA0cj5JkhgcHCSbzXLu3Lki/8dbgY3iT7lm406ns0h8Mzp/S21HYrGYOZYvxDeBYP9h3Lezs7PYbDbq6+uZmJhgfn6e06dPm40Y5VBJsXW32Sj2FNqOrLdwMJlMYrPZLBcOGrYjmUwGSZJIp9NIkkRdXZ3o/N0nCKFtlylU8PP5PEtLSywtLeFwOLj77rvNhQHlstOjU/l8nne/+xf56te/jufkFfzeALnwGLEnv4KmpJFdPrScAlqeule9A9eRs+YNraaiLP/nXzE9M0coY+M7P/F2dFXBV1tH7+mTXLrrIh/+8IfXjMYWqv4GhWbj66n+Pp+PXC7H1NQUdXV1QvUXCPYZpRXM5eVlgsEgsViM3t7eNePnm7GfR0crZSOz8Xg8vsZs3Ih/fr8fWZYZHR2lvr5e+H0IBPuM0imGaDSKruuEQiFOnjxJS0vLjt+X+z3+wVqzcVjtdjHMxqenp1EUBbfbXXT4dDgczM/Pm8Vc0fkrEOwvCrt40+k0mUyGwcFBWltb1/Ui34iDEM+2ylYWDhbGP5fLRTweN2OjgbAd2VuE0LZLWPkQTU5OsrKywl133VVUzdsKsiwXBZloNEp/fz/5fN7sACs8hG2VlsNHyGXSuDvuwnPyHhz1rcBr0NU8sWv/SnrkSSTZji5JRJ/4Crr6Bew1h5C9AZSFUWz+Bpp+7APYa1YTJjUdRwmN8MzTX+Ppp5+msbGR3/zN3yzrdZaajauqalY9DdVflmUURSEcDm+o+oPw+xAIdgsrH6K5uTmSySQnTpygp6enonuvNMnKZDIEg0Hi8Ther7eoA2InxrB2i0KzcaPz1zAbj8fjzM3NkUgkgNUD6fz8fJHZOAi/D4FgLykdE41Go0QiEVwuF1evXt3Qh6hcVFVldHSUubm5ovFz4xB2kLEyG89kMsRiMZaXl5mYmDCLOHa7naampg07f4Xnr0Cwe5QWWTOZDDMzM0iStKkX+UYU5oC6rjM3N8fo6GjRmdE4Cx7k+3u9hYOG+DY3N0c2m0XXddxut2m/tNHCQSG+7Q4H9+RxgCj1IVpYWGBkZISWlhbq6uoqFtng5SCTy+UYGhoimUzS29uLw+EwOyCMDjDDdDaTyZBKpcoKPLlMCv+F15GdG2TpPz6DJMkg2dDzWZAkJHctda94O/baQ+SWplDmR8lMvYCaXMZee4h8NMTSw59EdvuwB1qw1R4iM3YdSbaBw73lDpZCbDYbdXV11NXVmV+Lx+MMDg6SyWQIh8NrzMaNkQMQfh8CwW6gaRr5fB5VVZEkiUQiQX9/vykEGe3ylWDEP03TmJycZGZmhlOnTtHT02Mewko7wDRNw+PxoGnage5qKDQRP3z4MLB60H766afRdX1Ts3Hh9yEQ7DylB0xFURgcHCSXy1FfX8+xY8e2LbLpus7i4iKDg4O0t7dz+fJlswMiFouZHWBerxe32002mzUFqZ1mp7pNCjt/W1pazOd6/vnncTgca+K+ldm42PQnEOwsVl7kExMThEIhGhsb8Xg8FYts8HIOaOSVPp+PixcvAphTUEYHmDF+ns/nyWazu1J82MluO6fTSVNTU5HtyMTEBJlMZs3CwcLON7vdLjx/dxEhtO0ghgBmHDCTySQDAwO43W4uX76MruusrKxs+zlisRhPPfUUHR0d9Pb2msJe6dy3YTq7srLC1NQUo6OjlhvvSqm98pNIskwuMsfSw59EyyTwdFxECU+gJpaIPv5l7PVt6GqO3NI0ztaT1F35SWSXD13XUGNhsrMDxG98E2YHsDUdx3v0DKn+R6tSxS3EZrPhcrk4ceKE+TVD9S80G3e5XEXim1D9BYLqUnrAzOVyjIyMkEgkOHPmDDU1NTz++OPbeg5Jksjlcjz55JM0NTVx9epV82ul3o/G+Pnk5CSRSITl5WVThLpVqp5GjDpy5Ij5tY3Mxo3XXmg2Ljp/BYLtU3rANMTvmZkZ04foxRdf3La/kK7rXL9+HVmWuXTpEi6XC0VRLDvA0uk04XCYTCbDc889h6ZpRZMPPp9vRw5WuxUvjHytubm5aHup4flbaDtS+Lo3MhsXnb8CQWWUdvEuLi4yPDxMW1sbV69eZX5+vuheqwRd15mcnCSTyZhb6hVFQdf1Nd6Pxvj57OwsfX19RSLUTk4+7Gb8M3I7o/i61YWDovO3+gihbQewGhMdHR0lEonQ09NjdmAZwaBSEokEQ0NDANxzzz04HI4Nf94wnfX7/Rw7dgy/31+08W5mZgZFUYoCD0iAzvIjf0s6+N84mo7S8CO/hM3lW32tap7s3CDRx7+ErubBZkeZCRL+tz/B5q7B0XQMm7+B5Iv/heypQUuu4G45YV5TtYW2wi2nBlaqv5XZuFXAFaq/QLA1rMZEZ2ZmmJycNIsB1figVhSFgYEBMpkM9957Lz7fakxa7+BqjBI0NDSgaRpHjhwxRajCqmc5xYeDhJXZeC6XM0cOQqFQkdl4od+H8W9Z2Pkrig8CwcaUHjBXVlYYGBjg0KFDRWOisixXLLQZnSHJZJKurq4iQc0KY/HUoUOHiMfjnDt3rsj7trQD9qAWH0pzwMKO3vXMxlOplOXrNh5PdP4KBOVTWGQ1DPqDwSB2u71oTHS7iwxCoRDz8/O0trZy/vz5ojOaVRw0ig/j4+NcvHixSIQKh8OMjIwULd7byeLDTlEa/6wWDmqaRiqVKnvh4Eadv6L4sDlCaKsymqYVCWihUIjR0VGOHTtGV1fXmgSgkiCTz+cZGRkhEolw7NgxksnkpiLbelhtvCsMPC99EWXqJva6VtTEEuF//kNktw/ZW4e9tons5AtI7hp0JU3dK96O59Q95MITKAujZCaeJzN+A+fhbpxNR4lf/yar4h3o6FUPYLq++WOuZzZe+LpHR0eLVP9Sn7tC1T8ej5vmlUL1F9zOlB4w4/E4/f391NXVceXKFctqoZU4vhG6rjMzM8PExASdnZ3EYjFTZNsqViKUUfU0Rq52q+q5mzgcjnXNxg27gfXMxks7f40NgS0tLUWHTyG+CW43Srt4s9ksg4ODqKrK+fPnzS4rg0qNvI0lMi0tLWbxoFxKc9BS71ur4oPVxs9y2W2j8nJywPXMxq2KLoWbntfr/J2fn6e9vV10/gpua0qbTDRNY2xsjMXFRbq7u9fEqUrPwKlUiv7+fhwOB62trRw6dKhij9/1Jh+qVXzYi/i32bXJsrylhYNG/DPy7NLiQzgcpqmpCZfLJcQ3Cw72aWEfYTUmGgwG8Xq9XL58GafTueZ3thpkdF1nYWGB4eFhjh49SldXFysrK6YJdrlslNytCTwSZMZvgGyj5tIb8J6+ipqOkVsYIzs3ROLGN3F3XMRR10qy73urr8vhxnW4G9fhbtzHLxD+pw/jbDpqvApAQlmaRsskmZ+f39K1b4ZxwN8qm6n+htm4VbUjFovhcDjwer3C70NwW2I1Jjo0NEQ6nebcuXNFH+iFGLGo3PsiFovR399PIBAwhbuxsbE1j7kRmx1u1xu5KvV78/v9azZ+lrIX27Aqfc6NzMYjkYhpNm4smTC6RIzt2U1NTZadv4WJ10GqDAsE5WI1Jjo5Ocnc3Jw5JmrFVnPAbDbLwMAAuVyOCxcu4PV6WVpaWnPPbxYDN4oRGxUfrHx/yik+7GbeU2kOaPW6jSKCkQMatiOFh26n08nMzAxtbW2i81dw21LqRR4OhxkeHqa9vZ0rV65YfvZvtdBgCHehUIienh4aGhoYGhqqap5VSfHBiAPrsdvxr5I8q9yFg3a7vUh883g8zM/PU1dXhyRJovPXAiG0bZPSA6bRbRaLxejp6SmqmJWylSBjKPhOp5O7777brChWUhHd2u9IrDz2RfRcBl76HZunFtvx87iOnCFx45s46lqLft7iCYtfy+gz6NkUyMVeQtVgq90xG1Go+heajRt+H0a1Q1EUU+kvx2y8MPm6XQOP4Nag9IAJMD09zdTUFCdPnqSlpWXD97dx0NwsMcjn8wwNDRGLxUx/t0rZaszcrOo5PT29btXzILOe2bhRfDBER6O4MDs7a44cCL8Pwe1CaRfv8vIyg4ODtLS0cPXq1Q1jW+nW+PUw/N2mpqY4deoUzc3NRYL2VsS6SnLGrRQf9nrkqpo5oNPpLOr81XXdtFspFB0zmQyTk5Pm4dOq8xeKxTdhOyK4FShtMkmn0/T39+NyuYrOqlZspdBgLHsx/N2M+6bcGLoddqL4sFNUM/5ZLRzM5XKm+LawsEA6nSaTyTA1NUVdXd2ahYPZbJZsNlv0mEbn7+1SfBBCW4VY+RDNzc0xPj7O8ePH6enpWffNk0gkWFhYoLOzc9Pn0TSN0dFRwuGwZevtdmfcy6H1HR8j9JXf2/TndF03xbiCr5rfUxZe6jyRbPjuuJ908LFd8WirJjabbY3qPzw8jN1uJ5fLFZmNFx66C0cOVFUVqr/gwFN6wIxGowSDQRobG9cdEy1ls0RL13Xm5+cZHR3dNK7uJuVWPR0OB9lslnA4fEv4vUmShM/nw+fz0dbWBsDS0hKhUAhJkszOX6DI78Pn8wm/D8EtRWmRNZPJMDAwAMDFixfLEtrLyd+i0Sj9/f3U19dbxtVKCgfbZSsjV+l0mlAoRF1d3a74ve1kDihJEm63G7fbbYqOqqpy7do13G43S0tLjI+Pk8/n8fl8RZ0fNpttQ89fUXwQHCSsvMjHxsZYWlqip6enSJRaj3KEtkwmQzAYRNf1dePqXkwObFZ8MPzeNE0jn8/jdDp3pfiw02dgh6NnhLQAACAASURBVMNBQ0NDkRbx1FNPEQgEiMfj5sJBt9tdFP+MhYOFnr/GmP+t3vkrhLYK0DSNpaUlc3ORsVa4pqZm06UEn/jEJ/i9D/8BWk7B5nTRUN/Aa151L69//et5y1veUuThUajgV6v1trLf0UFT0bJJdF1DkoqvQ9c1lPkRdCXNyvf/jsTz/46zrQtXWxeS0wO6Tqr/++h5BXQd78lLyLIdyvDS2CrVCjJ//Md/zB/+Xx/HbndwpP0w995zNw8++CAPPvig5SrqUp+U9czGC8W3QrNxofoLDgq6rpNMJolGozQ0NKAoCkNDQ2SzWe68884t+aVtVI1MJpP09fXh8XjWHb+vhEp9kTbDquqZTqe5cePGrvm97XSStd5zut1u02gcis3GrXxOampqROev4EBiHDCnpqZobW1F13XGx8cJhUJ0dXWZfrflsNFB0xi/TyaTZY3fb/U1VJv1ig/PPPMM2Wy2Kn5v5bDbMVDXdex2O62traboaHxGWpmNF9oNFBYfjM5fXdfXHDyF+CbYLxij8dPT0zQ0NGCz2VhYWGBkZISjR4+am9/LYaPYpWkak5OTzMzMFC17KWU3OtrKYb3iQ39/P8CuLZvZixxQkiQOHTpU5HlutXDQ6/UW5YCFCwdLO39vpYWDQmjbAoUVzOXlZSRJYmpqikQiQW9vb1GCUcoTTzzB29/xLsLLEWrv/Slch7vJR0NkFyf516eH+Md/ejf/4397L06Xm1Mdxzl7ppf777+ft73tbWsMdAvZqUNjIbquo2bTxJ78R6JPfAVH41Fch7txHuoAINn3fdBUsNmpvfwQkiyTmbpJ7Kl/RsvE0TUNm78B1/HzJG98i5fHS1cT1GvXrlUt8Gw3yMzMzPC6N76ZyelZ6l71TiSnm8XFKf7p0Rf48te+gZqKITtd9HSd5pX3XuXHfuzHOHz48JogsJ7ZeOmG10LVv9BsXGz6E+w3Cj8QU6kUs7OzJBIJZmZm1owzlYtVR4expXlxcZHe3t6itvVqsVuJmcvlwuFwcPLkSfN5d3Lkai+SLKvR383MxhcXF83O38JDd2nnbzabNV+P6PwV7DWFXbzj4+M4HA6GhobWjDOVi1X+pus6s7OzjI+Pl7Wleb3HWO93dvOeMe7X48ePm383Oz1ytdsx0Cr+GUV4K7NxY9lModm4kQMWFqkKCw8gOn8Fe0/hmOj09DR2u53R0dGKi6HrFRoikQjBYJCmpqaiLc1W7MYZuFJkWcblchV1gG3X720z9iIHhOLPlfUWDqZSKeLxeFHua3j+GsUHo/O31HbkIHf+CqGtDKx8iGKxGEtLS3R3d2+YCKVSKd7+jnfw7X//D5Dt2Dx+0sNPoaajeI6eR6tJk7v5HWRPLYErPwGyjYnFCYa+/yxf+erX+aVfeT9Hjx5hMNhv+fi70dGmxhaweWqovfQG7I3HSI88RXY2SGrgcZBt2GsacR45Szr4fWS3D1/Pq/Df+cMA5JamWfjqH+LpuPjSo+kgSaiJZbRclrq6Os6fP285clUYeMqtem4nyPz5n/85v/fhPwAd7HWt5JamcR+/E1/Pq/B0XmL5vz6LlMviv/B6JpUUI//2PT77ub9Hyym4PR5q/V5+5h3v4C1veQsXL15c8/hWG14LVf/1zMatVH9FUUgkErS0tNwyqr9g/1I6JppIJAiHw3g8nk0ToY0orUYuLCwwNDTEkSNH1u3i3S57+eG801uu9ovQZsVmZuPz8/NkMpkis3Gj48Wq87d0058oPgh2isIiq+FDZBQb7rrrLssu93IoPWgaW5r9fv+m0xEG+6WjrVx22u9tPwhtVhR2/Bndv4bZeDweN83GDXsSIwYao3Ji059grygdkze8qgcGBjh79uyGXuQbUZr/KYrC4OAgmUym7OmI/Sy0WbHTfm97JbRtRqHtSGHum0wmicfjGy4ctOr8jUajOJ1OAoHAvu/8FULbJpQeMOPxOMFgEJvNxrFjx0yTfCs+9alP8cHf+33kQCtNb/g/AMgtTqIsjJF88RHiT/8Lkn11btl97E4AHM2duFpPkT92J9EffIX8yiyzs7PrPodVkNnsjbalwGSzE/7qH4JkAx2cjUdwNq4uMNDVHLP/73txH7tj9WdXF4qWsPamz0y9iLoyB5pGW1vbuoGntPurnMBTycaVUCjEgz/2RsYmJglcfRugoyxOkpm+SeLmd5BsNvSXkuG6V/wUzsPdyHYnnL0fTcsT+c5nySxNIh0+y//991/jk5/+C0AnUFdP96lOfvHd/4O3ve1ta553I9W/NOn0+Xzm6/b7/SiKwvLyMo2Njeuq/slkEp/Pd+B9oQR7R2mClc1mGRwcRFEUamtrOX369LYe3+hoMwx0bTYbly5dqvjgWu5z7qfErJItV+uNXO1noc2Kcs3GPR5PkfjmcDjWbPor9fswvGO2szhDcHtT6kNkdLKFw2GcTifnz5/f1uMbQpuxRCsSidDb27ulg2slHm37Kf7tRPFhPwptVmxmNh4Oh9cUno3YPzc3R319PYqiWHb+yrJMLBZbd+ROINgMKy/y+fl5xsbGcDgcnD17dsNJrs0w8j9d15mZmWFiYqKsJVqlj7Gf4lklVLP4YORBBwEjptfU1BQtHDQ6f0tjvxH/vV4vKysr+P3+NZ59hZ2/kUikokmbaiOEtnUoPWDmcjmGh4dJpVKcOXOGRCJBOp22/N3nnnuOH339G1iJRpFsdmSbk+zsIO4T5/F0XkJNRdGzKZytp/D1vppcZA4lNMrK419Ezymr4lsui622CXfn3eQnrq97nVZBxhBqAoFAWRXRDdFUWn/+0yx85fcxFhusx+p3rd7Qq1/LRxcAUOPL+HruIz385LoqvVX3l1XgMQQoo+10qwfNdDpN15lz6Jq2Khja7DjbTuM+die6ppJ4/tsk+78Hsg00jegTX1n1qbM5sdU0ko/MIdkdNP7o+3DUt5nXqiYjJK4/zJNPPMHI6Iil0GaFldm4ofobK+YTiQT5fB5Zlpmbm1tX9f/d3/1dHnroIR544IGy/z4EAljbxavrOpOTk8zOznL69GkCgQAvvPDCtp9HkiQmJydZWVmhu7u7aNS6UnK5HIuLi+aBZC8/ZCsVviqtehoFod1kOwfNUqzMxo3YH4/Hi8zGM5kM09PT6/p9fOMb3yAYDPKRj3ykKtcmuL0oLLLCqmfu0NAQ7e3tXLlyhSeeeKIqz2Pcz8eOHaOrq6ui8fvCHFDXdZaWlnC73UV5wV5RySG4kuLDdkeuKqWa8Q+szcYVRSEWixGLxUyz8Uwmw8zMTNFrL+z8XVlZ4ed+7ud45JFHqnZtgtuH0iaTZDJpdttevnyZwcHBbQtcsiyTzWZNM/1yl2gVYmU/srKygq7r5hKSvaSSv6PtFB/2a0dbuWxkOxKPx82Fg7lcjtraWnRdL1o4WNj5+yM/8iNcv359z/8+hNBWgtWY6PT0NFNTU3R2dnLmzBlzdEBV1aLfzWQy/PTP/Azf+tZ/4Ol6BU333k1ueRYlPE5q6AfEr319VUTTVBx1rXh7XoWjpRNXWxeceQ3Z2QFWHvsiuprDFmjC23k3ajq24Y1amGQZG0oXFhaora1lcnLS3H4UCASKDFi3fPNvkkjkowvoyqqPW3amf9XDrbnT7ARLj14jHwsD4Dv7mpcSE73sILhZ4JmeniaZTJrbXdxud1kjVwsLC+hqntorP4EyO0jsyX9Ey6bB7oScAjYJyeWn7r534mw8Qj66gLI4QXr0WfKRGZwtneSjIZa++edITg+yJ4Cj4TBqKkp+cQJbbRMN9dsTDwrVfINQKMTy8jKaplmq/oqikEwm1zVQFgjWozTBikQiDAwM0NLSYo6JFh5AK2VpaYlwOFyxv1EpxobSkZER6uvrmZ2dJZPJFIlRtbW1B7YCWk7V0ygOGQew3dhypWnajq6xL4z9LS0twOrB8/nnn8fhcBSZjRuFF13XzYqnQLAVCn2IjFwvGAzicDi4++67q9YhnkqlmJycRJKkbS17KYxnxoZSn89HLpcjlUqtseEwPHB2k2ocdMotPmQyGSYmJnZk2YwV1RbarHA6nTQ1NRUVnp988kn8fj8rKytrCi8Oh4PFxUUR/wRbprTJxOi2jcViRV7k5WwM3QjjcePxOPfcc0/FneeF8c/YUKqqKna7naGhIdMHsba2lkAgYIpRu0k14l+5xQdFUdA0zZw62YviQ7Wxiv2G6GtstTYWDhpx37AY2WuRDYTQVkTpATMWixEMBi3XqlsFmZb2YyhKFltdKzZ/PbKrBk/HRVxHz7Ly6OdRkxE8p69i89aSnR8m+viX0XNZZKcHXZIgl8HRdBwtkwBTgJLQ9fWDmRFklpaWGBgYoK2tjXvuucfseCrshjIMWLPZLOl02lSE3W73xm9GXUdLJ4g88rcknv82zsPduFpP4Wg6BhSLaK4jZ9GVNPFr/4aWjqGrOSTZhpZN4jvzv5C8+R0zKdF1tlVtsAo8MzMzxOPxoi1XG/m9pVIpJJuDmguvgwuvQ8vnWXr4z1BCw3hP30MuMks+MsfKI3+DvbYZuaaJ3OIE6BqND74fR91Lol8uQ355hkTf98iMPgOyDd+5+8ktTuL1Vn8MzjhUHj161Pxaoer/iU98gv/8z/8kGAzymte8hne/+910dXVV/ToEtw6lPkTZbJaBgQF0fe1a9e0kWdls1kyGDh06RFtb27YPKqlUir6+PtxuN5cvXwZejo2GGLW4uMjY2BiKomCz2XC5XLsmRu0EVsWHVCpFMBhE1/Vd23K1GwdNq+d0Op20tbUVdf4aIwdf+9rX+OxnP4uqqoyPj/PWt76V+++/f1evUXCwKD1gGoXLpaUlenp6ipJ8eLmTYqvvfVVVGRsbIxwOmyNS2zkMSZJELpejr6+PRCLBuXPnzO4mSZKKuqGmp6fNav/k5KR5KNnrro9KsSo+PPXUU7hcLsLhMCMjI5aeP9WMV3sR/yRJQpZlmpubi2xHjM+6Gzdu8KEPfYhQKMQ73/lO7r//fn7hF35hV69RcLCwajKZm5tjfHycEydO0NPTU5Q3VJoDGgXR0dFR2tvbyWQy27J3kCQJVVWZmJhgenqarq4u6uvrzUKJlRiVTqcZHR01xbdtT37tEVYC1AsvvIDf79+xZTOl7FXRWtd16uvri4oJRuElEonwK7/yK0xNTfGWt7yFy5cv84EPfGDDxZI7iRDasB4THRwcJJvNrrtW3SrIqJqG/8LrUZMR0kNPEL/2r2B3Qz4LEtReegvuk3cjyzK+nvvQNZX49W+SGvhvkCR85+5HtjtJj11fVaEAdG3DYJbL5YjFYoyPj5uH4cKfL+xyMgxYh4aGcDgcphKcTqfNDrBAIGB64Kwioat5bN4avKd/FF2C7HQf6ZFn0DJxADQlje/sa0kN/gDXkTP4ul5hPn9q7AaR//xL/L2vLrohtUwSXc0RjUbL/4cqA1mW1whQxs1n5fcWCoWQ5NUkMzs7yNLDf4pkd9H4uv8dR+3LyZsxCpoZexYkCSSZ5W//P8guH/ZAK862LnLLkyihUWRvACQJ+aXuRd8O3Nyqqq5JjguD7qc//Wne+ta38rGPfYz5+Xnh0yZYl1IfIl1f3QY8Pz/P6dOnLT1eKkmyjPHT6elpTp8+TXNzM8FgcFtVUWNM5saNG/T29lJfX2+2joO1GBUOhwmHw+b6+GQyWbT9srAN/aAhSRIOh4MjR46YX6vU761c9uKgaRX/Cgsv73vf+8jn87S1tdHb23tLVHUFO4OVD9HCwgIjIyMbLmUxYuBW3vuLi4sMDg7S1tbGlStXCIfDxOPxbV17Op3m5s2bdHZ2mou5CjdWlnZD5fN5nn322aJuUKBIjPd6vVUV43erq8AQoFpbW3dk2YwVexH/YO3faeFn3YMPPkhjYyOf//zn+bVf+7UNfZ4FAqtlV/39/dTW1q67lMVms62Z6toM43GNLaWSJBEOh7d17YaFRGtrqzlxYZzlwVqMKuwGLZz8KsyJDmLxFVY/lxoaGsxFErfipnuwzgELCy//8R//wate9So++clP8vTTT+/pGfi2FtqsfIimp6eZnp7e1JDR6qApyzbcx+7A2dyx+vh5hegz/0Kq73s4mzuJP/dNYtf+BdlTg81bh5pYRs8ruI/fSWbi+VWDfVj1A1NzKOFxsjPBl0W3kmufmZkxV8zfddddZb/ZjSSj0IA6k8mYm1THxsZM/zPJZmP+f34AyeFG9tXh63kV3PUGALScwtxfv2f1a+tg99chmTfD6uvIhkZQZodAV6viyVSI1U2/0cjV7Ozs6t83kOx7BMnmAEli6Rt/huzyInsDOA+dIB8Lk1sYw1Z7CEm20fz2PyC/MoeyMIoyO0DyhW+j5bL4ul+JsjSJllxZfXJN3ZFDu6qqmx4eE4kEJ06c4MKFC1V/fsGtQWmCZfgQGUnLeh++W/1gXVlZob+/n8bGxqItpdsZ41xeXiYYDAJsafTUWLleKMYbBYtoNGp64BSuHa+0CrjbSYjV8+30lqv9IrSVkkgkaGpq4pWvfOUuXZXgoFEa/4yOUKMzdqPP2K0UG4yRJqBoS+l2OoNTqRT9/f1kMhl6e3vLNr03FoYUdoMa2y9jsZjpgWNMAhi2IwdVrN5pv7e9Eto2Ix6PEwgEuPPOO7nzzjv3+nIE+xCrMdHh4WESiQRnzpzZsNNsK7FLVVVGRkZYWlqit7fXXP6Rz+crjn/GtYbDYZqbm+nu7i77d202G01NTWY3qKZppFIpM/9LJBJVE+P3Ogfc6U33exX/NssBc7kcTqeTjo4OOjo6dvHK1nLbCm2lCVY0GiUYDNLU1FR0EFwPm81mIbTJ6OrLSrpkd+JoOILs8tL0hg8AoCYjKKFR4te+jq7l8Z55DZJWXBWQgFw0RD6xjKu9F2U2WPT9RCJBX18fNTU13H333Tz//PNbupFLD7eF2y8NDxxj5FTXVFre/ocs/uvHKV2GIMmrnV0lj178x8IutnQCgFxoFM/JS2TGb1S9Zbecm74w8LjdbnQ1R2byBdA1XEfP0fDAe9AyCZTwOEpohNTgD1CTEXxnXkN+aRo1k0CSZRwN7Tga2vH13MfKo58nM/kCstsLmgqyjJpcIb88y8xM9ZX0cg6axtZRgaCUUh8iY5xTkqSig+B2URSFoaEhUqkUd9xxx5ru4EoOmoUr4C9cuMCNGze29EFvJe45HI412y8Lq4DGCFJhIrIfjMZLKTepq+aWK03Tdn30rFyhTWwcFVhResBUVZXR0VEikQg9PT1FWyDXwyoHLEXTNCYmJpibm7PsDpZlecuFhsLH7O7uJhQKbbkIUPqcVtsvrcR4o/gQCATw+/0HduS0msWHvTholvOeEfFPsB5WY6Kzs7NMTEzQ0dFhdsZuRLm528LCAkNDQxw5coSrV69WZfzU6MQ9duwYgUCAVCq15me2InDJsozf78fv95uTX4YYH41GWVhYIJPJmHYjxn/7ceS0nNddzeLDfhXa4vH4vvGovO2EttIEyzi05XI57rzzzrKFCVmW17TNyrbVTrSirzlcq8LLS9h89Xg6L5GZfhEtl1lNtNBB19HVPNnZAXKRWZDt+M79EKg5sjP9wMtVgeXlZXMFvKqqFXWEbPY7hrotAZLbh+RYRyzSNdRUFGQbei5L4oVvo2cSOFs6X/Jwe6mLbXYAJTQKgPfcD5k3ZrWNardaPchkMuj5HJFH/gYtGcX7Unee7PbjPnoO99Fz6Lks6ZGnV0dBdW21660ELZ9FMoKNpqKl46SGnkCyOTh//nxVXlsh5Rw0d9qkXHDwKB0T1TSN8fFxFhYWqrb103geY1174RKZUraSaOm6zuzsLOPj43R2dtLa2mo+5lbu+3K66KyqgMba8VgsxsTEBMlkEpvNxtTUFPfeey91dXV7PqJd6dbR7VQ992tHm1gGIyjFakw0FAoxOjq65a2fm8WuSCRCMBjk0KFDXLlyxfL9arUxbyMKH9Po4l1YWNhSDlhuF7GVGF+4/TwejxcZje/EyOluUmnxYb/Gv0QiIeKfYA2lTSbxeJz+/n7q6uq2tPVzs/iXTqfp7+/HZrOtu0RmqxMNxmPa7XbzMUOh0JbPwOU8b6kYr+t6kQfYxMQE+Xy+KB74/f49727Vdb2ia9jOpvu9eM2bPe9+in+3zSncOGCGQiFSqRTt7e1MTU0xMzNjVhq3kiBYerTl86THbyC5vDgajiDZ7EgOF7q2do5dtjlAe+lGlyRAJ3Hzv1b/aHeh59KrIpwmg66zuLjIwMCA6RliXGslo1dbS4Qk0HXUVIzYk/+MMjeEs60LZ8tJsnMDSHYnqcEfIMk2JNmGurJA/Po30HIKqAqypxY0jdziFJ5T95AeevLlm0Mvf+touVTSpmuvbaLlp/+IxW9+Cmxrbwk9lzU793RNRbJbVDFyCsg2tEyCfHwRPa/g6XoFudDwjhgwbpZoHcStioKdwxiNT6VSDAwMcPbsWcLhMMPDw1Xb+mkQj8fp6+vb0N/DoNyODsPbw+fzrXlMIwbu9AGvdO34jRs3ePNDbyWyvLgqVPkDdB5v596rV/nxH/9xzp49u/mimSpTaZJlxVa2XAE0NTVt2++tXMo5aMbjcdHRITAxDpg3btzg/PnzJJNJgsEgXq+3oq2fVsVWWC3eDgwMoCgK58+f3/Dzv9xCg+EbnEql1hSEK+mKqwRJksyuj8OHDwOr96Hhfzs6OmrZBXFQKbf4kM/ncblc5uuu9rIZK0RHr2CrGE0mQ0NDNDU14Xa7GRoaIp1Or+tFvhHrdfQaxdv5+flNi7fl3ieGn+7s7CxdXV2m36TxGLsV/9xuN263u2jktHTZYGHeVFtbW3Hxs1Kq+XzlbrpXVXVXN90b17LR69xP8e+2ENoKFXxd14lEIszMzJhVwUrEHqsESUIjPfI0qcHH0XNZ7PWt2AOt6DkFNRHB5i/YWmV3ri46yKbITDy/KuSoOZztvTgPHSdx41svPeiqCDc1NcWlS5fWjHStF2Q2egNWJM55anA1HUPLJog+/S/omRiSJFNzz0N4TlxAjS+SW5xCWRglM9UHuor00mvUc1lcHXcheV5OurRcFl3XyGQyW7qOzaiko00yxLW8giStfS+sbk6VUVMx8kvT6HmFhX/8EK62Lpytp3G0dKDls6jpGMngfwMS9oZ27L4AOU3dkfHNchIt2B+rjQV7S+mYaDQaNc2wqzkmanhmRKPRojXwG7FZR4cx0rW4uFjk7VH6GDvR0bEemqbxnve+l3/4yj/h7XkVLQ/8MFo2SW5pipHwOH1f+ip/9defRbI5aGxooPtUBw888ABvetObOHz48I52fey04GhV9XzuueeoqanZtS1XIA6agvIpnWIwBLZYLEZPT48pnG+V0hzQ8PidnJzc1OPXYLNYpOs6c3NzjI2N0dHRYdkZvNWuuGrGB5vNtm4XhGE0nkwmefHFF28Zo/FSAXFiYgJFUYo23Vfq91Yu5cY/wwpGcPtSOiaqKAqzs7MsLy+XHaeskGXZnIwwWFpaYmBgYFOP360QjUbp6+ujqanJsjO40maTaohzVssG8/m8WXwIhUKsrKyQTCZpaGiwWDZYfXYyB7QqPhi+nru56b4cEonEvrFOuqWFtsIEy/AhGh8fJ5VKcfny5W11GhWq+ZqmMTY2hsfrx3PnG/Gevko+sUx66ElSo8+g6xrzX/hNJLsTV+spXO29qIll1EycZP/3sfnqQdewN5/A1dJpBgA1nSAz+RxIMhcvXtzwde4YkkToi78Nkg1Xey9aNkV26sXVkVKnl+z0i0i6huvIOVzHzpOZegFdVfCfux9n80lyS5MvLT8IoisZkG3Eb34XlDSwOsaRz+erdhDbapBJp9NI8upz56IhsrNB0qPP4Gw5ietwN86WTjQljZqKkRp4HMlux9F6GvfRs2Sn+0iNPI2WSayODEsy7s5L5BbGTPFO11Si0SjXrl2rauDZLNHa7SqKYP9ResDUNI3R0VGSySS9vb00NDRU5TlgdfxqZGSEY8eO0d3dvaXxq/Xil5G0GRv6NlrMsFsdnN/97nd560//DEo2i+xwk1uaJjnwGO4T53EfPUd+JYSWiuI+ege+3vtQIrNcmx3liT/5NB/68EewO9285Y2v5/3vf78ZCwKBQNUOYnuxAUqSJJqamsxOtp3ecgWr8W+zz4xkMnmgO2oE28PKh2h+fp5UKsXRo0fp6enZ1r1SmAMaHr/VHL9KJpP09/fjdrs37AzezfhXDqVdEE899RTHjx83l08lEgkkSSoSovbiIFYtjPFZ4+AJ1V02Y0W5o/Oi0HB7Y+VFPj8/v+U4ZUVh7DI8flVV5cKFC1WZ4snlcgwNDZFIJCz9fQ0qjX87FTPtdjsNDQ1mfh0MBmloaEDXdXPZoKqqZj4UCASq2gW2Fzmg2+3e0qb73Vius58Krbek0FbqQ6Trumkee/jwYRKJxLYDgTE2UKjgez0eki8tQ7D7G6i5+Do8Jy8T+tIHaXv3X6LM9JEeuUZy4HHU+CJoKp6Tl7HXNBK//k1QV4PW6k0iker/PrbapiKPt1Iq9eMpN8jouk7Dq/9Xlh/9n8Se+Rf0vELgle/A5m8gtziJsjBK/PlvE33iH0GygZbDd8cDuE9cxOarx9l8Al/vq4k/9++k+h/FdfQsNm8AJTRCLjLHmx96K3X1dRxvb+Mv/uIvqKurMwPPbmx4WVlZQVPz6Pkcdn8DztP34jx0nPT4dZJ9jxC79nX0TBJkGc+py+SWprD76qi99Ea49EZg9cNs4R/+TySHC0egGWV+GEm2o2VTaJkEbreb8+fPbxh4tjpytVmilUql9o2aL9hdrHyIjDHR9vZ2fD5fVUQ2Yw38wMBAWVv61nuM0oNmNptlYGCAfD7PxYsX8Xg8mz7GTne0ZTIZ3vEz7+Q73/0uvjt+mNpjd5JbmiIXHiczeo3EjW+ujp3rGvZAC66jMDhI7QAAIABJREFU57AF2nA0HsV76gq5lXlWHv08amqF+fl5zp49ax7Epqeni4zGjXhQSaf1XiRZqqoWJYk7veXKeM7N4qWIgbcvpQfMRCJBMBjE7/cTCAQq7uIoRJZlFEWhr6+vrC196z1GafwzCrcLCwv09PQUdYtZYfU69pP4ZjVyanUQq4bR+F68ZqtcrJrLZsp9zlL200FTsLtYeZEPDQ2RzWZpa2ujrq5u280Nxhl4YmKC6elpTp8+bY5UbvfajcLtiRMnNl3MsPP2SdtDkiRcLpf5uQNr86FEIoHNZiuKf5Xajux2Dlia/8HOb7o/aMtgbjmhrTTBWlpaYnBwkJaWFq5evWqu8N0uiqKQTCaZnJw0D4NOp4Nk6TIEpxu01TeiYa4PkHju34k/9+/Ya16aX5dk0FcFNU3JADquzss465qJP/sNFEXZ0iF2o5ttK4FJkiTS0y8iqTm0XBb3kV50XcNW24SjrhVP5yUSN79Dsu8RJElGcvpJvvgIqeBj6Foe2deAlo5BPkvgFW/Hc+Llzjxd18hO3mT58S+yvLRkVogNo3G73V60Xr4cIWqrxoyTk5Oo8UVmP/tLYLPjPnYnns5LeDovmT+z8PWPo2US2GsayYUnoMSjTZZlZJsNyUgMdY18agVlYRR0je7u7k0Dz/T0NIqilB14Nku09lPbrGD3KI1/hnmsy+UyzWNnZ2e3/TyqqpLNZnnhhRfo7e3d9DC4HoXjB4WjV6dOnSp77KUSoW2rHD95mkw6g73+CLLTg+z04jl+Hs/x88Se/Qb5xBKe4xdwNBwmGxohfu3rRB//IrLTC7IdLR3DXteCrf7wS58VTpqamkyvEcM/LxaLMT8/z9DQUEVG43shtJUTc6u55QrKXwZzULciCiqj9IBpjLPH43FznP369euW3mpbfZ5kMsn8/DynTp0qa0ufFaWxa3l5mWAwSGtr64ZdvKWPUcnmvr3EKh/KZDJrjMZ9Pp+Z/5VjNL5f41+1iw9iGYzACqsmk+npaaanpzl16hTNzc2rZ55txj9YnQaamZmhvb29YgumUlKpFP39/TidzrILt1ZTEdsd2a8mVjHJKh/K5XLmyOn8/DyZTKboPFhbW1uWELXbMbDcM/dub7oXyxB2gFIfIqOVFSjqirDZbNsKMoYp48zMDA6Ho2ikU1NV8olldDX/su+X3b3qU1b65n+p+8FEWh0zzIZGUeYGAQmH6ekmkUqltiS0VeNGu3nzJjoS2YkbBK7+JGo6jhIaJf7UV4kqKSSnBz2vgKYhOd3Uv+pncLacRMskUJamSI88jTI3iKu5EzW1QvQH/0Dsqa8he2qw1x9GsjvJjF/HXtdKfnmGxsZG8yaEVTHTCDwzMzNrhKja2to1N9tWg0xzczPO1lM0PPAeFv7pw5bLECRNRX5JXNM1Fdm29t9BV3PIcg16XkFXMujpBO7j51HmguuKENsJPOVsXNkvar5g5yk9YBreZsvLy2V1RWyFcDjM4OAgNptt2x5vRpJUuEBhqyMNlSRaW02ycnkV/4UHURMRkv2PEnv6a6vxL5cFNb/avdzzamRZxtv1CgCy88OsfO9v0fUMjsPduFs6yEz1Wd63kiTh8/nw+Xy0tbUBq/+GhhBlGI07HA7z4GklRO3FyHilW6e2U/UUy2AEhViNic7OzjIxMUFHR0eRELbdHNBYzJLP5zl58qTpzVMJxmd54QKFrY5e7afute1QrtG4IUQFAoE1XR8HKf5tp/gglsEISiktskYiEQYGBmhqaioSwrYb/4zuuGg0SkNDA11dXVW5dmOBQk9Pz5YnLm6F+OdwOGhsbDSXR+i6TiaTIRqNsri4yNjYWFlC1H4V2krZTvHhoHX0HnihrfSAqes6Y2NjhEKhNdtJYHtBZmVlhf7+fjNwPfnkk0XfT6cSJKe+Q+LGt7A3HMbV1o3rcDcgrY5/Fog4kmyHlxKk3NI0aCrqyjxqYhl3x11kxq+j6xoSgCSVvTQgn88zODjI0tJSUTWw0IC2nMTsQx/6EH/yZ3+O7Kkh8IqfwtXcAYCv+5VoSorl//wr1Pgi3o67UZanyK/Ms/Lff4+9rg17fRtKeAItFaP+/l/Eeeg4sCpS5VfmSA0/RXroCZBteE5dwe6vJx6ZXXPjWHV9pNNpotEoCwsLjIyMoOt60U241UTLWIYgu/1IDvfLAmkBupZHkmS0XBYtkyAzdZP49YdxtpzEceg4ssONruZQ03GyswOgqjiPnsPR0EZ2pq9ss+WtBJ5MJkMoFFq36imSrNsDqwOmcW8cPXqUq1evVu1DN51OEwwGkSSJS5cu0dfXt+0ER9d1FhYWCIVC9Pb2VmxMblyHYRMwNTWF2+0u6og1xLtKD6aezks4Go8Cq8tcsnPDLH/jE7iOniPR9wjx57+N7PZj8zdi89SQmbqJPdBCPrqA3W10l5a/FdRms1FXV1e0AMJKiPL5fGb8s2rj3w12c8uV4etps9mw2WwbjlwdVN8nQfmUHjDj8TjBYJBAIGAp2leaA+bzeUZGRohEIvT29hKJRLZ9r0nSahH16aefrtiYvDSeGRvqZVk2Y18gENiVbcDVZDOj8YWFBTKZTNHIqdfr3fX4V+lB04pyiw/GOFokEll38iGRSAiPytuA0iYTRVEYHBwkl8tZbj22WmJQ7vPMzMwwMTFBZ2cn7e3tTE9Pb/v68/k8Tz75JM3NzRUtUCgttCaTSfr6+lAUhZqaGjMGFk4EHITihCRJeDwePB6P5XnQWDRjTH4VivYHQWizotzig81mI5fLsbi4uO7kQyKRMIvWe82BFdpKfYgkSWJxcZGhoSHa2trWvWHXW0m8EUbgymQya1arF3Ky4wTpoy14e+4jNfQE2ckXSI9dA5ud+c99AEdLJ+4jZ3G2nlx9DWqe1MBjaNkUSDKSw433zGpXRAYJXcuTnZsEdKLRaJHZqhWhUIjh4WGOHz9OZ2enKUoZBrTGmziXy+H3+zdUvp955hkcDe1ITi8rj/x/oOvInhqwOVHjYRyNR2l6029i86yKObqukY8usPLYF1AGx5FdPrR0jMj3/hbZG8B56ATuo3eQnR8kPXoN2VePlk1iN7r2dDbtYikUogq7PozAMz4+TiQSMSstxg27UYKZzWZNcU1NREhcf5jc8iyuttM4mzux1R4CNYeaV1D6HgFNA38jqaEnSNz4FpqSwuarR02tQHwJZ1sXufAYNudLz6lrFYsHsH7geeqpp9bdcuXz+cTo6G1A6QHTaLv3eDybtt3//+y9eXgc93nn+amqvhtA4yAugiAAkiBAUKRE8ZItX9JYsS1btuM42d2sZnLu2slssslu5tns5HgmTsY5nHPzJE9mJs4xmXicrO3Y8RnHjk5LIilSpEjivgmgcQN9d9e5fzSqWN3oBqrRAAho8X2e5HkMgYUqoPvt9/e+36OUrZcp5w6HwznLi42MvJ1gYWGBoaEhgsEg58+f33JzkM+Kq66u5sKFCxYV3zSgNbeBXq8353PDCQTyqP9uL97DnYDAoQ/9nwBo8WXkuVFS42+QHruRXSIEQ8Tf/A6Y/97QraXQVlBoEGWyPsLhMCsrK9br4q1iNF5o+XDr1i0EQSi49aysrMTj8ezbZz6AM+QvWRVFYXh4mGQyuaFfmuktVArM3qq1tZWTJ09axuLl1L94PM7du3dRVZV3vOMdW06iMw+NsizT39+PqqqcPXvWGjqaIQSyLFs+kJqmOU4u30vINxo3DMMaRC0vLzM2NmYdtM3650RyWg6286BZCIVq/tjYGJlMpqjywe/3H4QhvMWxkRe5KRMthK0sGgopDmKxWFn1T1EUBgYGyGQyXLhwYcu+6Wb9s3tbdnV14fV6LauosbExSxVWVVWFLMuoqrory4ftHOjZz4Nm+IBdchoOh0kkEty+fXtHU9/t2On6V2j5sLy8zPj4eFHlg3kGPpCOloH8A2Y6naa/v9+RlKmUJss+wXeybfT5fBirWVP9qnNPw7mnAZj+Tz9J1Tt+mMxUL4m+F4m+/o8YmQS4XEgVdfhPvp1k7wsIHt/9F6wgkBx8DQEDDDa8Z13XeeONNxBFkQsXLuDxeJBl2ZIi2Q1oTWZUOBxmdna2qBTT5/PhOXyS6sd/OFvQowvIcyOsvvy3CG4vyuIES9/4Q0R/Je66VqRQM4nef0GU3NQ99Uncda3oSgZ1eQp5cYLUyOukBl/Jstg6L4OukR67af9tb6kYSJJEKBQiFArR2trKwMCARb2NRqObGo2nUqlsiAMgeCtwHzqCFp0nOvkmeiqWlfRqGhg6niOnUJemCJ58G5XnPpD93ctpUqOvs/r8X+E5ehZvXQvy3EjWl0nJYGjqpmbupcLlcuFyuWhra7O+Zt96/v3f/z1/9md/hs/n4zOf+QxPPvkk58+f3+CKB9hPKCQTHRkZYXV11RErzGy0nLzfTM8g0+PS/oG61UGbWa8BTpw4QSKRKHsoMjo6SiwWsw7YiqIgSdI6KVI8Hmd+fp54PM61a9dwu905rLeiw0kB2KRhkipq8VfU4go1kJ64iSt4/+9gYJCZGURZmuLMmY+X9aw5t5VnND43N0cymaS6urqg/Mh8zp2Ml99piKKIKIq0tLRYjbJ969nb28vP//zPk06n+ZVf+RUee+wxPvjBDz7guz7AdqEQi3d6eprJyUmOHTtGT0/PhvXE5XI5rlvm8sLtdlselya2MrCD+7L+xcVFurq6GBwcLPv9aB48TG9Lsz/OlyKZPpCKonDjxo2c9M9CUsy9DkEQciSnmUyGvr4+Wltbrf7PHMRvh9F4Iez0QTMfgiAgSRI1NTVFlQ8/8zM/w9TUFL/8y7/MY489xoc//OE9c+g8QPnIPwMvLy8zMDBAQ0MDly9f3nCAXsqgzfS4jEQilsel/Tpb6f8MwyAcDjM2NkZHRweRSKSsM5JpFWWy4i5fvmyx/MyzoYlMJkMkEmFubo6+vj4Mw8hRfm1n+mf+Pe4U8iWnV69e5fjx45YKwFR+mUFA5nPu1/oHWEqG48fXSEt5yodf+qVf4sUXX+Tu3bvMzs7y9NNP09rauqv3aMe+GrTlHzBNXffCwgJdXV2OdN1OX1zRaJS+vr6SPIN8Pl/Wsyz/Z4oSvsPdBDsfs74W732ByGtfuG+6L4iWZ5thGGAYSBU1+NofIXn7O2QymXXXNQyDe/fukUwm6erqytl4FYK5DUwmk4iiSHNzs/XiNOVmAJWVldmfZ2SbP0EQcIUacIUaiL7+FarOP4P/+EXkxQnk2REy072kb30DwzAwvCLRG1/H23wSX/sjuA+1kQkPoiUjWWmmvwpXsAY1urjmS6eTCQ+CIG7Lm9UwDOtQWcho3NxMm89569YtUqNDzP3dr4Cawn/sAoHOy9b15PkxFr76GdwN7Xjr21EXJhHc9w/josdHsPsdRL73OST/WiNj6OipCKnR18EwcnzntgOF/r72redP//RPU1tby927d2lubmZ4ePhg0PYWQKED5uzsLGNjYxw9epSuri5H9c3JoM1M/lQUpahnUKmNllmv7t27x2uvvUZDQwNPPvlkWVvRpaUllpaWaG1t5fLly9Z2cyMDWjMtsKenB1mWiUQiRCIRJicnixpw67pBZqYf0VeJVLGx351h/b/7X0lP3KKqIsg3v/PPXLx4ccvPuxkMw7AOYfnyo0gkss5o3Dxg7zTrY7uRz8axbz3b2tr45je/ySc+8QkuXrzIwMDAwaDtLYL8A2Y0GqW/P+uD6rRPczIgM9kRc3NzRT2DtiLBWlxcZHBwkMOHD+fUq60imUxy7949PB4Ply5d2nBgZ/eBnJqa4uLFi9aA2rTjSKVS1vI1FArtOBtiu2EYRkHJqaIo1nOWYzReCA/ioJn/+Z2vfPjud7/L448/zkc/+lGuXbtGJpM5GLS9BVBIJtrf349hGI69HZ0M2uzJn21tbQV7y60sGky2aSAQsOrV5OTkloOLVFVldHSUSCTC5cuXLRVPsfvyer00NDQwNzfHiRMn8Hq9BaWYdsl9Kd7oewHFVADmIrKcsMFC0HV91z8j8vu//Gf+0z/9Uz7xiU/wvve9zwotOhi0bYJ8mShgyURbWlocpzM5gaqqDA0NEY1GHcW12w90Ho8HQ02s/yZBxNBy5UJSIJRTuAQB0HW0VIz0+E3QdTyNx7LPtZYeaIcpOwiFQgSDwZKGOWZzV+gNaRpwm8O+9f82K9MSXB68TZ14mzqpfOT9hP/yZ6l5z48CIIcHSU/3Er/9HQRRxBBd+Dsvoy5MYFiprNnDcKLvxax/naFvS0Er1PRsZDR++PBhJtQQ7vo2Yje/hZDvE9fQgeT2I7nXPsAMHcG1viAZmoYoujHWniUz1YenpRt5um9bjejNZ9zsQymVStHR0cGzzz67rT/7AA8G+QfMRCJBX18fFRUVjtOZTGzUaNmHYab8oNjwrpRGy2QaJZNJfubn/g9Gx8YR3F70dBx/sJLT3Sf5V08+wTPPPMOFCxc2vZ7dPLy2tpbDhw87l4HaDrcejydHlqPruiU3mJqasmLXL547y53ef2buyhcQXB48DcdxNXUCBoYqI7hsv3/DyPpvri0RDE3lYx/7fv7is5/d8QNZMTms2WDa2X3mcxYyGt/rktPNZG+JRIJDhw7x4Q9/eBfv6gA7BfuSVRAEFEVhcHCQTCbDQw89VNIQYbODpjkM28iCBEpj9JrhXLqu54Rzmc9WKuzm4Q0NDfj9/i2x4vJlOXYDbjsbopjX0V5DsfrndrvXSU7NlFO7tcBW2C0PatC2WRiMKIo88cQTPPnkk7t4ZwfYCRTyIjff/52dnSWd/zZbkJq9pc/n27C3LKX+6brO6OgoCwsL68K5CoVZOcH8/LxlFWW+d0tFISmmGcJn9oB2H9ytLCX3ghec6ddpZ/dtJWywEB5U/dvsZ6bTaS5dusSpU6d26a6KY88P2swD5s2bNzl79qxlyF2Iyl8ODMNgdnaW0dFR2tra6O7udhwRbH7f1NQUyYGbyOEhvEdO4Wk+iafxxNqgLXfzKYiS5fqjyyl0VQZVJdn/Mq5QA7qq3P/5tjAEXdcZGRlhcXGRnp4eQqEQr7zyypaetxBMA24APRPPTVBdu5eC1wOkQDWexmP4Ox4lRDb8IPzZf4v/2HlcgSqsEZuuo0bmQNeQqhrwHj1D4uY3t43R5pTVU11djSRJiIFqKh/5AIk7/4IgrW9WDV1FECUMXcPQFOS5Edx1rbjrjiCIa4VIV9HlJOnh1wABX/fjuHwVyNN9ZaUyFoLTxClTMnyA/QuzwRoaGqKuro5AIMDIyAjRaHQdld8pih00I5EIfX19jtkhThotU3qwsrLCH/3RH/Hlr34df/s56j/6fyN6/OiZJMrSPe6MXef13/19fvu3fxvJ46OhsZHHL1/kmWee4SMf+Yj1HrLX6WPHjtHU1MSdO3dKev6NWCSiKFpSTDsb4r9/7m+JRqOsrKxw7do1XnnlFW7cukXC7WPmsz+NK9SAt7kLT/PJ7NDNMEj2vUhlwMvv/Zf/zA/90A+VdI9bhdMwmELPmc9uyTca32uS042e8yAM5q0Bk8U7OztLKpWipaWFe/fuMTU1teXwgGL1z5S0G4axbhhW7Dqb1T/DMJiammJycpLOzs6ivkmlIBKJ0NvbS319PY899hgzMzNlpQjaUciA2/TBLeR1tNek6E7rn/05GxsbrX9rl1/G4/F1RuNer3fd9ffioM3EXh2IHsAZTJJJIpFgaGiI06dPs7S0xODgIE1NTVsKD5AkqaBPrF3S7iSp3umgbWlpiYGBAZqbmwuSYgRBKEnVkE6n6evrs6ySNE0jEok4/vfmzyzWAxYK4SuUfpzPBtvovbYX34dbCRssJDndC4zeQojFYnsmDGbPDtryJ/ipVIqhoSGWl5cdFYFSYNJZnZiI22E2bOaL7OGHH+bOvIKv7SzpiZukx2+hpWMICKy++F/xtZ3F09SJsjRJ9OqXMeQkydHraKtzIIqAgf/k41kD7bvPg2GgxpcxVIVwOGz5JRUrWE7hRK6wtLREenyYmT//KVw1zXgPd+Ft7lrHzLt/zQJfWxtC3X9jGuhKhmT/y9nBoq7hqT9abHa3JZQabSzLMoIruw3XlTTJ4StZ+WnjMSR/9k1q6Bq6kiL15j+DrpEcvkpy8DXQVVw1TXibu8HQSQ1fxVXXgro0heSrAEPLSoK3GU6arGQyeSAV2MfIl4kqisLs7CxLS0u0t7c7WgQUQ36DpCgKQ0NDJBKJktghmzVa5sZxenqaf/uzP08sFs2yPcMDqM/P42k8ga/tEZJjN8jcu0vg5NuoOPMUWmKFxOIEX3t9mC999afQf/TH+Ikf/zE+85nP0NfXh9frzZFJFWvUtivm3O6B0dHRwblz53j22WdzkuBeeOEFrl+/Qe/tr7KysoxhGPzIsz/Mb/3Wb1lS9d2AyWTYCgqxW0zvR7vkND9efi/iIAxm/8PO4jUMg9XVVaanp6mrq+Oxxx7bspG/JEk5Vhy6rjM5Ocn09DQnT550zA7ZjNFrGogXSz8tFebCJRaLcebMGatO73SCnt0H10S+FF3TtF3xOtoM5dS/QsFT+UbjmUwmJ826srJyTw7aHsQ9HWB7Ya9/oigSjUa5efMmgiBs6kW+EQotCBYWFhgcHCxJIbZZ/2fKWhVF2XBx4XRgZ1db2Ot0vtpru5Hvgwv3/c4jkQjhcJh0Om35gJt1Yb8FzWwUNhiJRBgfHyeZTFq+xub/7VVG214Kg9lzg7ZCPkSmebVpyL0dhydzU2BO8E+dOmUxuZwiv0BIkoQ8P4qyMoW3uYvQ29+Nu/Usc3/zcwhuH/G+F9CvfQVBgGDPe1BjiyhzoyCKCJIHAwUttoArGEIQRDLhIbT4EhjZwdfo6KhjHf5GcNKYtbe3M2bUU/Hoh0gNXSF97zapsTfQUzEi3/vvpIav4m09jafxOJ5DbRtcaU1GZegYmSR6YgUQcB06ihZdIGvUVtbj5P60Eg/XmYxssdgMXUeeHyczPYCeiiJ6A3gaj2NkUmTu9SJILjyHu1GW7qGrCQRPAD2TIjV6HRDwd15GCoSIL01nXxtypigDsBw4ZbTtlSJzgNKQLxONx+PMzc0RDAY39eFxAnNBYBgGMzMzjI+P09HRwalTp0p67xRjdKRSKfr6+kin0/yHX/sUL7/yCsHT76Wx510YSgZlcRJ5YZzkyFWS/S8CZNltqSiZmUG8LadwVTVgKBnS9+6C5GJycpKbN2/S1dVlmb6ayK9ngiBsWOPKPZjmS9G7u7t54oknLDaY2YCFQiEr7U9V1V3xsdiu4SKsNxoHrO26ud2NxWLWEmwnjMa3ing8flD/9inyfYgURWFycpJ4PM7FixfLHqDaGW0rKyv09/dz6NChkod3xQ6ImqZZLN6enp5t2aqbB+GjR4+uW7IUqmc7/f4rJEUv5nWkqiqyLO+K19F21j9YbzSeb7pthvAMDg5ah+ztNBovhs0OmolE4mDRsE9RyIt8YmKCeDxesP8pFfb6ZyrEBEHg/PnzJQ3vikk+Sw0RdCIdjcfj61JPTRRatDpVo20VhdKPTTZYvg94KpUinU7vSl3YbhRasuRLa81BXCKRWBc2uFPQNG3Tc1AymdwzNXDPDdoAq8Akk0n6+/vx+XzU1tbS1NS0LS9USZIso8cjR45smR1mb7T+5E/+hM/+9d/gqmnBf/QsmbkRVl/6G/RMAkHyIC9MYKRjeA+fJPTYDyJ6778AdCVN9MoXSU+8iTw3hrfpBAigpaIET72L1PBV3G4358+f37U3qiiKYBi4KmqpPPcBK2Vz/mu/jzLVi7oyQyY8iCC5MJQ0guQmfuuf8HU8iqfxOFJlnXWvejpGauR1DCUrfw10vQ0pWJNl7QHa2vBtO1BqozU0MkIi2Y+ejiOKErVP/ASepuPoukpm8g7RG18HUcJ9qJXqd/ywxXLTM0mU5SmSg6+QmeoFBFyVdehKdrimxpdJj14HY/u3i04GbQcHzf0Lc8imKAojIyPWkqGysnJbJDqSJBGPxxkeHqaiomLLw7t8RofJDJmZmeHVV1/lV/7Dr6NrCqIngDw7CAL4Os7hrj9K/O5zoKSpeOQDeBo6UBYnycwOE7v+ZSKvfC6bBCyK+NsfQY3Mo6pq0TStnWZ0OEExr6PFxUXL+mA3vI62+6CZj3yjcUVRuH37NnV1dVbYTCqVymF9lGM0vlUc1L/9C1VVrUWAyTRraWnB4/FsS+MsSRKyLHPnzh3S6TRnz57dsr9PMWZIa2srJ0+eLPu9aKZoAkUPwoUOqrt9oNvI6ygcDnP37t2yvY6cYKfrXyFf46tXr9LS0kIkEllnNG4+63ZZ3JjYTDoVi8UOFA37FLquW16UCwsLDA8P09zcTDAYLHvIBvelo2NjY4TDYU6ePGnJB8uFORCrrKx0zOLdSDpq93YzrZIK/fut9H/b2TMWY4PZVQ8jIyP4fD6rJ3oQfdF2IF9y2t/fT3V1tRWgYR8yms+53b2upmmbWjuUw27ebuy5v7L5pjM3gt3d3VRXV/Pmm29uiw9FKpUikUgQDodLnuDnQxRFent7ef/TTxOLxqh67OP4O7LDsMDJtwGgLE+z/NxfYGTiCJKEPDfK4td+H1d1M96jDyF5g0RvfxcjsYy7oQ11ZZb0dD96OoH36FlEbwDW/CQ2eqGW0mA4KUyCIGAUoJoJgojor6DpX/8uhqaiLE+Tmekneu0rKNEF5Ne+gJ6OZodT9e0Ymkp69A1cdS0YBmgrM0jB+7JfeW4UNToPGI59JzZCqY1WfX0DsaiBuhLOBhlYP18kNXwVdXECQRRQl6dY+vaf4qpqyCaqtp3NDgfCQwjeCoxMcu0G9Gx4xfBVXKEm9PgC169fRxCEHLptOUbjTn5PiUTioNHapxAEgenpaSYnJy2m2fT0dEFfjVKhqiorKyvIsszZs2cLNi5OYT9omr5BqVSKn/7eiCfcAAAgAElEQVTZn2Ni8h6hxz6Ou75jjcE2Rnr8JvGb30JwezA0Lctcq6xHCjXhrjmMv+NRYje/RXL4CmgygZ6nkNwe1OgiXq+36Gu+1EZrNwZzpgfQoUOHWF1d5cyZM0W9juyNV7mD1J0+aObDDGbZzGhc0zRLcmqyPrbaBDnxYYrH4wf1b59CFEVWV1cZGBiwfMgymQwrKytlX9swDJaWlgiHw5w+fXpLHm8m7Ixe098Nig/ESr1PkxXixNstv5496MUD3D+Qeb1ezp07ty1eR5tht+sfkNPbmTAlp5FIxGI1b8VovBicMNoO6t/+hLDmyd3f348kSZZMNBwOb8v1V1ZWiMViNDQ0bMnjrRBMf7elpSVOnTpVUl9ZjBm8srJCX1/fplZJW+nndqNGmOnvwWCQ9vZ2AoGAJbm3B7BUVFTkSO73G+vNMAyCwSCVlZXrwgaj0ajV67rd7pxetxyG82b1by98/tmx5wZthmFw48YNmpqacjaCLperrIOmPaUpGAzS3d1dVjOk6zr/8dOf5mvf+Bbu+g4kw0P0tS8Se+MbSP4QnqbjCG4fibvPIUhuPA0dVJz9PrToAvLiBJmZAeTXv7KWUCcienxosWUMVUZZvIfg8SG6TA8i0QpDKISdeGMKggAFip9op+xKLjz1bXjq20j2vUDNu57F03Asy8aZGyE1fBV5uh9vxzk8Nc2kJm6Rw1wzdNTECoHOt5Ec/B43btzIaVpCoVDJMqRS2WOaruNvP0fFmfcy8xf/G4LoQl6aZvnrvweSi0Mf+Fmkqga0+HJ2YDA/SqL3eWLX/xFEF/4Tl9BiC8jhYfRMck1GCv6Tb0MA5OQSFy9etIzGo9EoIyMjpFKpLRuNO2W07RUjyAOUhoGBAXRdz9kIulwuZFne8jXtce2BQICWlpayhmyQbZBkWaa3t5d4PJ49uB4+AoKIu64VLZPCI7nxtZ7GVdVA+t5dBG+Aqkc/hC6nyIQHWf3e5zA0GdHtR1czCC4Pgc7HSA68jGCs1R8xKx8rhq0M2h4EtuJ1VFFRUdL9PohBWyFzYydG45IkbemQ7bT+mSEPB9hfCIfD3Lt3j4cfftiyydgsKdQJotGolaZXX19vMZK2CpPROzExwdTUVEn+bhvB9AyuqKjYtlCavYDd8Dp6EIO2QthMcurUaLwYNutzDxYN+xfpdJpbt27R1dVlLa+2A5lMhoGBARRFIRAIcPz48W25rpnSfPjwYS5dulTy4C6fkWsmSqdSKUdWSXuB0eYEdisOe19kngvtHmhmTxQKhUpavj6IAVOhWmSGDdrtuEy/X5PhZ74O7b2u01rvJAwB9k4IxZ4btAmCwMWLF9d9vVhSihOYqSemx9vt27fLatr+/M//nH/3i7+EIvmofe8ncddlqfK6KqMs3SM58ArJvhdBcoOm4mnupPLi9+MKhODQUaRgDfLsMJ7G44QufxxEEWVhAnl+DHl2GDU6h6EaGIaOrmTQ1cyGhtr56aebwUlhGh4eJjU8iJaM4D3Sg6fxGJ5D7RSVeNouJ4oi3uZOvM2dJPpeyD43ZIeKrHmwLE1hKBn8nZezrD2EnIGUmXySSqWsTaDZeG30Bis5DEG1paoaOpGrXyJz7y6CKCAGa0kMfA9f6xncjcfxV9ZhAOnxN0ByIYWacFXUoEZmQRBI9L2I6KsEBFyBEGp8GWktECJfWgZYrA+70Xj+IbvQh5bTg+ZBo7U/0d3dve7gVE79SyaT9PX14fF4uHDhAvPz82UfzAzDsKSCnZ2dlr+boSpUP/HjyHPDJAdeIvb6l606KHoD1Lzr3+Bp6AAg2P0O9HSclZf+G8rSPUCkoufdaz9BAEPH0HX0dIKRkZGi97KVRmuvbLxK8Toya+BGm0CnqXvbBaeLjVKNxjeSVpgsuo1w4FG0f9HU1LRuYFXOotUMEYhGo/T09CAIwob1xCkSiQRLS0sEAoGywhlM6LrO2NgY8/PzJXkGF3u/75Wh00YoxevIrIEbqQF2u/45RSHJqclwjkajluQ032i8mOTU9CEthgPp6P6F3+8v6kW+lfe0PUTgxIkTNDQ08Oqrr5Z9n5lMhmQyyb1798oKZzBVbPZlcEdHh1Wrnfz7vchocwJRFK3la2trK3B/ILW6usrk5GROAFW5aoCdgNMe0Ov1Ul9fb3222xnO4XCYWCyGIAjW8iEUChWt9Zsx2pyEJewm9tygDQpv6FwuV8nDsUwmQ39/P5qm5UzGt7odXV5e5qMf+wGuXrsGhoHgVom89v/irm/Dd/RhXLWHSU/eJjPVi+Dy4mt/BMHlQZ4dZvErvwWSB0EUQVfB5cFX14qhKbiC9UhHz+Cub0dLrKAmlkGVUaMLpMdvgaFv2HTlFxrzkGZSUvM3ZU4KU2dnJ4MrGlJFLcmBV4hd/xqGksqy79xeDENHWJeoWah4Gfe/rGtr6ZxX0JIREMS1Idf9eynmdRSJRNZtAgt5HZX6QaQqGogutFQMQ9eQw0PUvPtHECQX8uIE8uwIqy//LYYmI4guDE3Fd/QhlKUpi3GIrgEGvjWpb3L49bWv6xuGIWxmNG5KK+yFx+fzOZaOHjDa9icKvX63Uv80TWNsbIyFhYWcpOb81L1SYQ7uNE2jpaXF8uQBsr5qx84T7H4HkPWfXPra76NnEojeICvPfTZbQ3yVSBW1yPNjiL4gnsYTa8O2NQgCWnyZTHgQQ1UItZ8uej/59SyTyS4mPB4P1dXV6zZlu9lklVqPNvI6Ms1nN/I62m1finL8JwuxPsxav7i4mCOtsLM+VFU9YPS+hVEozXMrrC3DMJidnWV0dJS2tjYrRCCVSpW1aDUHd5FIhGAwSFdX15avZcIMZWhoaCjZMzjf48gc2KmqSnV19bZI0ncLG3kdmWqAZDJZ1OtoL/nybIaNjMbNHtCUnJrP6pThd+BRub9RqGcwz62l+HpFIhH6+vqoqanZluRjyB3cud1uzp07V9b1RDGr2BodHcXlcnHx4sWSZIX5/Z9hGITDYVZWVqz3V/4QcDd9fUv9OfkDKfu50FQDmB6QdjWA+b27Xf+cLD4LoRDDOb/Wp1IpPB5PjsrN7XZvegbea9L5PTloK4RSGB2mie7U1FRBf4utDNo+85nP8B9+/T/iqj9G/Yf/L0RvEGVlBnlhHDk8yMp3/zOCy4MhCAhuD5XnPoS/41w2LMAwSI/dIHr9q/iO9OBrPbP274ZI9L6AILkQXB70TAoxUEnw1LtI3P4O6uI9fO0PoyxObnhvZtEw065WV1dpbW0llUrlbMrMouPk2UVRxFVZR827f8T6mpqMsvjV30WLzDLzXz6J+1Ab3pZTeJs7MQwddWUGd+0RBJetqTOyRLb0dB9qJOvFZug6wdP/ai1xUMDQiv9d7TKk/E1gvtdRVVUViqI4OoiZWF5eQsm8xOpLfwO6TvD0O3HXNCP6KrLMm573IM+PsfLCX2GoCp7W07hrW5AXJxEECUNT0RKrYIC7tgU1tpQdEiQjpCduIQnOi2y+0Tjcl1ZEo1Hm5+dJp9Pouk4gELDYH4WaaEVRdiXl6wDbj2JNVimMDpPOX8jfolha6Gawy++7u7vRNG2db5IgihiaAmSNSkW3D6myDqnyELXv/V+zdWJ1Dnl2iMj3Pof7UCu+lm6U5WnMgbtZD9ITb+KubwOXB2mDBtGsf3Zfo6NHj6JpmrUps3sB+f3+PcNoc4J889mNvI5SqRTBYHDX2CxbbbIKoVCtL8Twg+zvYH5+3ko5zcfBQfOthVJfy/F4nL6+PgKBwLqDWzkyVJNldfToUTo7O7l+/fqWrmNCVVXS6TRDQ0NbDmWwHxpNX6PGxkYqKipYWVlhfHw8xwsoFArtq/pneh3Zl6/FvI7Mz7b9wOYrhEK1PplMWuxxk+GXTqcJh8NFjcYP6t/+RbHXrcnqdTIsM+WXyWSShx56aNuGDrFYjN7eXkKhEJcvX+bq1atlvdcMwyAWi1lhB1sJZbDXv1QqRW9vL16vl9raWmKxGLOzs2QymRxJ+oOQjW4Vhc6Fdg9IcyAfCASoqKhA07RdHbhtJ3ssv9ZDYYafLMvMzc1RW1tLZWXlup+/1xi9+2bQ5pTRsbq6Sl9fH3V1dUXp/KU2Ws8++yxf/MrXQHIj+ipQI/O4G4/jOXQUBEj2v4QYqKLq4kcxVBl5doRE73NEr30JMVCNoaQwlDRVl36AwPGsLNbb0g2AGpln+bnPYqQTiP5KgmshCgBSfRvu2haUpakN/ZkEQWBpaYmRkRFaWlq4ePEiiqLkvLntXkCLi4uoqkoqlbIar/wPa0EQLKmnCVegCldFLUZqlUMf+UWSg6+Rme4j2f8ieibJ6sufY+X5v8QVasRzuAvv4S7AIDn4KgIgBqrRkxGCXW+3rqnFlsiEBxz/LWBjr6Pp6Wnu3LmDrus5MsxidFuX2006voggiAROvYP05C3it7+N4PEj+aoQ/RXI82N4DrWhLE0iedaSTgwdXUmR6H0eQ1WxaHuGDoZOcvBVRH8VVf7yNsmFpBVDQ0MIgsDy8jLj4+PrjMa3O+HqAA8eTuuf3ZS7GJ2/EGNkM9gZF6aB7tLSUoFYdRHyBueC5EFXUtZ/d9c0465pJvb6PyL5197DQjblWF2dI33vTvY+Q434Wk8jz40gKxsP49PpNNevXycQCHD58mXrsFXIC2h6eppoNMqdO3dymAL7hQmxkdfR6OgoU1NTTExM5Phf7FTk+k5T9Asx/BYWFgiHw1aoUSaTyTEaDwQCB9L5/59C0zRGRkYsU+5CSoCtDNpSqRR9fX24XC4uXLiA1+vFMIyyJPjz8/MMDQ3hcrl49NFHt8w2EQQBTdPo7e0lkUjwyCOP4PF4UFV1nUeifTl58+ZNq4/aTwl4G3kdzczMEI1GuXbtWlleR06x01JVQRAIBoMEg0GL4aeqKteuXUNRlByjcbu07KD+7W8UYlw5WbYahsHMzAzj4+Mbyi9LtRtSVZWRkRFWV1c5deqUxRY3mcZb6S3MoZ2u63R1dW05+dRk9Jrkmq6uLmpqapBled3A2gwnWVxcJBaLUVNTY9XA/XRuKqQGSCaTLC8vI8tyTgCfWQNL9Tt3ip0e6hWSnF67dg2Xy8XMzAzxeDzH2z0YDB4M2pygmHRqI7mTLMsMDQ2RTCY5c+bMhr/kUhgd8XiclZUVPI3H8LU9Qma6L2vgrcoIooShZnDVtFDznh9F8meLj7/9HLoqs/riXyPPj+NvP4caXSB67cvErn8V0V+Fq7oJweMjPfYGUkUNQmVd3nMLiG6/9fsoNmhTVZVEIsHk5CTnzp0rytawewGFQiFisRh1dXU5qSCmOX8oFForxAV+Ry43IOCuOUzo8sesL4c/94vUPvmTuEKNpIZeIzX5JumJN0EQkSpq8bU9TGbiFnoqcv9ahk5mug9P43GU+VFHf49iMJ9vYmKC8+fPO/Y6kiQXwZOPkRr4HtXv+tfZ21KVrGx0LU3Vf/IxXIEQ8uI4iFKWPaPKqIlV3A0d6JkkWnwZXUmTCQ+CoeM/fhFDTuFRlsp6rnwIgoAoijnDN5NabDbRP/ETP8HKygq/8Au/wOXLl/nYxz62b5roAxTGZk2WrutMTEwQDofp7Ozc0JS7lIOmoigMDAyQTqfXMS4KybkMIHr9H/EdfRhP03Ekf1WW4ZqOrr+4KGEY95/JUGVS42+AYSBV1CKYknJBRC0ShmAYBqurqyQSCc6ePWttwvLrpX1grSgKt2/fpqOjw2q8TFaYvT5sR+O1W8wK8/kWFxetGl+O15FTPAipgjlo7OjIev3lG43/6q/+Krdu3eLTn/40733ve/noRz+65Sb+ALuPrb4mzcHVkSNHinocQWkyVHtd7erqsg425n1uhRmRTqfp6+tDFEUuXLjArVu3ymJYRCIRZmdn6erqsrwy8z8r7APr1tZWrl27Rnd3d04ysK7rVn3YyB9nL8Ks3ebQvb29fVe8jh5U/fN4PBw9etT6mizLRCIRIpEIf/zHf8yXvvQlGhsbUVWVp59+elvkzQd4sNhs2RqLxejr66OiooJLly5tOFg2l61OzgVmXW1tbc0JKIT7Z+lSBm3mMmR5eZmenh7m5+fLqjOJRIJkMkkqleLy5csFz/f2gfXhw4cZHBy0ark9GdhcTuZbcpSD3WDPmc/ndrtZWlrikUceyVFDzc3NkU6n10nut2P5utvsYdOf8siRI9bPtYcNPvfcc/zmb/4mhmHwqU99iieeeIJ3vvOdu3Z/hbBvTt/FDod2udCxY8ccGSg6OWiaccWLi4s0NTUhjkepOPsUFWefAkCNL7HwD5/GVd2ELqdY+PJvInqDiIEQkq+SzPwo7lAjhz7487gqzam6jhZdINH/MqnhKyBK+I9fxFVZR3riTXRVtr4PAXRNyQYiqDKjo+sHUWYBdLvdPPTQQ/j9fke/S/P3k2/CaJrzLy0t0d/fjzw3T6LvRTxNnbiqGxEEsYAv2/1rCpILyV+Z83ua/k8/ia/l1FrBul9w9HQi63d27AKSvxJlfszRvTuFU68jRVURdA3sHk4uN96mE7iq6om+/o+5YQ6aSnLgexhKBlfjcXwt3SSHroBhkLj7Qnao4PLgqqxDXpjA691++Wa+Pt1OLT5y5AhXrlzh8ccf5/3vfz/Xr1/fESbLAXYOpXq0mWyz+vp6q9HYCE7qn+lzMTY2RkdHB83Nzevuq2BDA8jz42Qmb6Mlo4i+CgSXB8HtRVmexlXTbNUQQZIwdB15cZLMVC8gIPoq8XecQ0usrMlJswO4+YUI+YjH49y9exdBEDhx4kQO3XwjmM9hb7xgPR1/Iy+0vQqz6XHidWQmHxfyOnKKB+UJYv+Z+Ubjn//853n66af5sR/7MQYGBojFYgeDtrcICjX1JttMkiSLbbYRnB4KTHXEoUOHHNXVzWAYBlNTU0xOTuYklG41NVSWZfr7+0mn09TX1+d6ZTpAvkes3ZJju+rDbsP++tjM6yiRSBRMPi4FD6L+FfIn8ng81rP+2q/9Gh6Ph6amJkKhkDUkPsD+RrFlq8k2W1lZ4dSpU47S5J34vZkLAUEQitZVc2DnlC1qBhMePnyYy5cvIwgCCwsLZVmZzM3N4fP51r3GncwBqqurc1hhJmHBtOSw14fNgqg2wm4Nouz1r5AaqpDfud3/bKvLld1eyOT3AXZv97a2NhobG/nyl79MT08P4+PjB4M2pyiUOmVST6uqqjad4NuxmXQqvxh84QtfwFDzGBIVdYi+SgKdj1Hx8PvQlQzK/BiZ8CDxm9/MhhlE5lh5/i9x1xzG2/oQnqYTJAZeITV2A6mqAS2+gqtybUMqSmAYaMloNtVSENEzSRK9L2Io6Zxnk2WZvr4+DMPgwoUL3L171+Fv8T4KTdntjVdHRwd3hseJvfEN9GQEDH0trGGVnIjRzX8QmEbda8U0Mz+GPDMAuo7kC5ATmLCDKOR/YRgGGDqCuP6tYGhq7mDR0EmNXEOqqAXJjWtN9mashTx4jpxCFCUys2uJZrrzD6BSsJkRZCaTIRgM8tRTT/HUU09t+88/wO6jUM2SZZmBgQFkWebhhx/eNAbdxGaDtkQiQW9vL4FAYMO6WuieXB4voff8KJ76dnRVJTNxk8jVL6FGF1j40m9gGDqe+na8R3owFDlbBwB3XSvqahjfkR5EbwAtGcHQNZIjr6NFFxFtTBJd160lSE9PD8vLy+s+6DdimxT7b4Xo+GbjNTU1tc6EtpzGa6ewkZSpFK+jYpYChX7ebh80nfjUJJNJnnjiCd73vvft0l0dYKdh9oBmPbJ7RuazzcqBoigMDQ2RSCQ2VUc4RTwet3rVfFPyUplx9pCH48eP4/f7uXfvXs73ODn45B9W8i05zINZNBplcXHRWvY6SYV7UNio/pXideTUUuBB1T8nYVg9PT183/d93y7d1QG2E4VqQv6y1Z7SefTo0XVss42wUQ9o9zi3LwQKwemSQJZlBgcHyWQylvKq1GvYEYlE6O3ttcJjXnvttZL+faHfr92Sw14fIpEI0Wg0J4jKrJN7LQF0I3ZZMb9zkwlmX67Yk4/3S5COHclkkubmZj7+8Y8/6FsB9uigbaPEFch+0AwPDxOJRHL04k4hSRJKASlSJpNhYGAAVVVzikFFRcW6QRuQDTrQstcR3V68Ld14W7pJ9D5H7VOfRKo8hDw7TGa6l9iNr6OnY+D2E+x6e/YQOXTl/sVEET25SnLge7hqDqNnUhirM7jqjmBoqmVwbbJM7CEPpTZqTopxRUUFviOnqX3vJwCQFyZIDV8h3v8SZBIsfeOP8LaextN4HHdd66bXU+PLaPFlWEv29Hc8mpWWst4LbrcgCAJyJoOwMIahaxiqkhvkoCkgZMMa0pPZe3W39OBraCN++ztZRo5hrH2fhLe+HXlhHAQRLRnJhiiEtl8nvpkv0l7Tpx+gfNjfs3ZmxPHjx2lsbCzpsFOsyTIHWPkppcVQqEESRckKMxBdLvzHL6BE5kmPvk7Dx38VeWmK1NCrWQZvJo7gchM49U70RAR1NXxfri4I6Mkoor8Cz+GTeMSsCb7JMmlqauLSpUuIosjy8vKO0PM3arzyE0D3SuNVSureRl5HdkuBjbyO9gKjrRBK2bIfYG9ho0Gx+Xc1l6FNTU2WZ2S5sB9c29vbLRlmObDX1J6enoJsk1IOmul0mt7eXtxut7UEiUajO1b/zIOZWR/Mg1kkEmF4eNiSI9lZYQ+SQV9q6mgxr6NIJEI4HGZwcHBDr6O9mvJ3EIbw1oOdbGImv3s8npJTOqF4D2imlNbW1hb1OLdjs9plXwocO3aMpqamkpai+bAH/m3XEmQjuN3ugkFUkUgkJwHU7nX5IJevpdY/k9Vn9zI1lyumB7g9+d3scffScqUQ9lr925ODtkJwuVwoisLs7Kw1we/q6trSH1ySJNLptPW/7QfXEydOWE2FCU3TUGOLyHOjuA8dRZCyvzZBcqGr6wd2giBi6Bru2hbctS0Ee94NQPiv/ne8h7sRfRVoqZj1/WpsCXV5BkNT8Xe9HVcgRCwyB95K/G0Pkx6/SSqV4saNG3i93nUsk2LT+WJwUtjywxA89W146tuyZuVTdxD8lSR6XyB67csYSgbB7WXxK7+Fu74D75EevM2duOs7wNBJ9L4AqgKiCwSR4Jn3WlJSXU6Rme57ULM2DE1BnR9DEARmPvtT94McmrsQPT5AIHH3eZDcWdbaoexQ0dB1DCA1+jq6nAJh7QNJ1zGUTDYAwu3lVHf3tt/zZpTvAyPc/Y2N3ruRSIT+/n6qq6u3HNdeqMlaXl6mv7+/YEppMRQctElSdvBs/5rLnWV9Ap66I3jqfhCAhX/4NGAgii4MQcgSZQ0DQ1NRV2cR3F6CXY+jLE2hydnnjkajBb3iSl00bPVgWqjxMuVWZuNlN6aWJGlXm5Jy/TJMr6NQKERLSwuf/OQn8fv9PPPMM7S3t6/zOkqn044tC7YLqqpuyN7cT4mKByiMYoyOZDLJwMAAmqatY0aUg3IProVgJoBuVlOdDNrsPWq+cfhW6lmpZugm8g9mdjnS/Pw8IyNZNr9djrSb78dy61++lxOwodfRgxjmb6ZogIMe8K0IkyAyPDzseBm60bXsNUdVVYaGhojFYiWllG7kd25PAN1MGeFk0WD2qC0tLVy6dKns9/lW6lKh5avdksjeH5l9VDmBOaViO8JZ8i0F7H7nExMTJBKJnB53N58PnPV3e63+7ZtBWyaTyYYSbEMjZD9o2uWnxQ6uPp8PLRlh8et/kJVx1h7Ge6QHPZPEUNLrvh9BtJhuuV92WQdOYS1lLzV+E3V1zkqrNAMVBEFAXEu4NASR+fl52tvbC8ojyjk4FoMoioWZZpIL0eWl9okfJ/LaF1Ajs/iOPsLqq39HxZnvA1UmNXqdxJv/jJ6OI0geXHWtGOk4amwRweUhNfgKkr8KQ1VJDV9FDIR4UANy0eXB23EedWmK2vf/zFqQw20y9+6gJbO+UO7aFryHu4jf/Kf7zbJhkB69gegLZgeIopiVD6/MgKbg77yMujq3I4fQzRhte63IHKB8KIpCOp1mYGCAnp6esrY19ubILj995JFHHMtP869jQlVVUuM3EbxB3LVHEEQRwe0FvUCQg+TGWEsjRRAxDA01ukB64hYYOq5D7dZ/S6/FsxdarpipUw8CgiBYciQT9sZreXnZajjtrLedGr5tlzHt+Pg4T73/gyxEYrgqavmrv/kcAgY1dYc4//AZHn/87Xz/938/KysrzM/PMzc3V5bXUSlwmnS617euB3AOM/Dizp07dHd3W4eAcq9pGIYlP+3u7rb8bMqBoigMDg6SSqUc1dTN+jdTyl9RUVGwR92J/s8pismRzPo3Pz9PMpnk9u3bVn3YqQRkKJ3R4QQbeR0tLi6ysrLCtWvXtsXryAmcDNoSiUTJSp8D7B0Ueu2kUilmZmZob293vAwtBvMMbBgG8/PzDA8P09bWRnd3d0mv20L2IYZhMDExwczMjCNJ/2ZWTqqqMjAwQCqV2tblynYh35LIHk43MTHB6uoqvb291NTU7GgCMuxMMMFmfufpdJqrV69ayo6qqqod9TN2UuMTiYTlPb8XsCcHbfYXihlKsLCwgNfr5aGHHir7+uZmYGBggJWVFXp6ejb8UGpvb8dVUUvj//SbqLElkoOvkL53Gy22SOLOv5AefR3P4W68LafwNp3IepJphQ6WLjCyBUVLrABGlrnhCeDvOEey76XswE2QwM4o0zVkWS5asLYiHd3s+yORCFpiGTW2lE0ANP8mgoCua8z9/a+gxZbx1LcTfe3vQEmT7H8RV81h/O2PkBi7gaCrhN72P+A70gNkPc+UlWnkuVHib34bBJCauvDVNJAafNXx/W8nDF0HXS8Y5JAOD7L09T/Ed6QnKx0WskmsmZmh7FD0UCuB1oeI3/4uhq5mmXuAGKzBVVmHujKNIAjE4/FtPVxvJh3Ya8HY1fgAACAASURBVLTZA2wddrm4mVJX7geYKIqoqsrU1BQTExNbkp+a17E3SLquIxo6qeGrJAdexlAV3HWtSP4qdDmFLqes5QGsSe8zBloqujZcA3VlGt/Rs2TCgwjWUFtD07SclDU7Sh207fTB1N54NTY2MjExQWtrq9V4mRtBu9xguxqv7Wi0fv3Xf53f/YM/wtf+KPXvfAbB5cYwDLT4MsriBN997V/49rf/ifn5eT7xiU8QCASoqakpy+uoFGxW/w4YbW8tmHJxYNuGbJIksbS0xODgII2NjWXJT833nF162tHR4SiYC4ozOuyJpz09PTnyHjvKYbTtBPK9IK9evcrx48etBOShoaEcOWYoFMLn823Lz96NBDz7cNHn8+HxeDh+/PiueR05ZbQd9IBvDZihBJlMhubmZittuxxIkkQqlWJ8fByXy7Vl8kp+7YpGo/T29lJXV+c4QMbsRwvBDPxrb293XE9h8yXbTta//HC6N998k/a1FGQzAVnTtB2RY+5WAqjZ49bV1bG8vMyFCxfWBUmYAzq75H47sB8ZvXty0GZiYWGBwcFBWlpauHz5MleuXNn8HzlANBpldnaWEydOWMknGyEUClkeba7KOqrOP0PV+WdI3H2O1Zc/h6v6MOnJN7MhBmTliLFb/4SWjOBp7sRT344guRFECV1OkRy5hhZbAsPAfagV75HT2XsQBAxdR1mZxVAVdCWVNQOPLZDJNBW9v50oGqlUCmV5mrnP/3sEyY2noQNf60NkwkOgKbgq66l98n+xDs5aKoayOEFy4HvEXv8KCCKCx5+VVqYTeBo7kCrqEEQ3qeErCG4fRiaBu7oRYy1cYWhoyHpjbtebcjMYhg66lpWG5kHQdQRRuv99CCT7s4mjGDq+5pPZ/6ZroCl4Wrox5DR6JusnZWgaXq+X8fHxTb2OSrvnjYvpXisyBygN5t82Ho/T19dHMBjk0qVLvPHGG9viCWPGoUej0S3LTyG3yTIPw4HKKvxnPkTgxGWUlVmSQ6+QHL6GIacI/+XPIFXU4l1bShhqBjU6j7I0mQ0YkVMEe96DILmQZ0dA18iEB5HnRvnoRz5c9D4eJKPDCeysN3MjmMlkiEajrKysMDExYTVeTkMIiqGcRiuZTPLBD3+E66+/DoZBZuouS0v38DQew9f+MK5QE5nwIFpyFVxeDh06ZL0ey/U6KgWbmYGb0q4D7F8IgkAmk2FoaIhkMsmZM2cIh8Pbcm1Zlkkmk4yOjpbM4s2HyepVFIXe3t4tHVoLDdpisRh3796lrq5u0yHgfqh/+QnIphwzEokwOztLJpPB7/db9W+rg/ndOmiaMOvfbnodOWW0HfSA+xv2QXtnZyeiKLKwsLAt141EIszMzPDQQw+VFSJj1i67d9rp06dLGvIWWpTmB/7tBEN+N2umx+OhqqoqJwHZtBwxz4fm95g1cCt9+W7XP3vKfSE/Y1NyHw6Hc2q8uXzdCrPZaf3bS4uGPTloy2Qy3Lp1C0EQOH/+/LY1zel0mv7+flRVpba2lra2Nkf/rqKiwjL4zoHkRnB5qH7iR3FV1KHLKeS5UVZf/hyC5CY59Bqxm9/EkFO4qpvRklnDbzFYTaD7nST7XkT0VeSwxVKj19BTcRAFjGQEIwCu2pYNJQ2FGq3N0kc2KzJHjhzBd6SH6qd+Gjk8QKL/ZaKvfyU7ZBJE5IVxVl/6b3hbuvG3n0P0+MnMjyMvTiK4PPiPX8RQFeT5UTLTfdlBlqYgrA203A0dyNN9CKKQZZQJAnV1dTmNVyAQyJEb7AQVVdd11PgSonv9a8zQFCsNVY3MgwCC24u/63ESN7+ZlYxClnnoq8TbeJz0xJsIopT9W0cXWV1dtViY5uHa3GrYvY6200g9Ho8fyAb2MXRdZ3BwkOXl5Zy4djPefauDMZMdvLi4iM/no6enp6z7NOtIb28viUSCs2fP4vN6SK3VSndNE6FLH8N7+BQr3/kzmv7NH5AauUpq7CbRq/+QHdgYBv6Tb0d0uUj0vWz5XxoCyLMjVNfW8J3nn+PSpUub3kcp971bKFaHvV4v9fX1BRsvM4TA4/HkDOad/N232mi98MIL/OD/+MPoFQ3Uf/TfI7jcKEtTKAsTyHPDLA++Chjg8hHsfiepkWv84f/zx1y5coUPfehDPPvsszm1q1SvI5P14aTxcsLoPThk7m9MT09bBtomk6FQ8nwpsLODfT4fp0+fLmvIBtnX+cTEBLOzs5w8eTLHO62Ua5j1S9d1RkZGWFpacnxg3WuMNicoJMfMH8zbGRGhUMjRYftBDdoKoVSvI6dG6k4OmrquH4TB7GNEIhFu375NfX29xQxbXV3dUGLpBOZC1O12c+zYsbKTmkVRZHV1lcHBQY4cObIl7zS7x669RhfyS98uPOge0C7HNCWOZgJ8/mC+lOXrXqp/xZavZv9nZzbbCTab3b+T+heLxQ4GbZtBkiRaW1u31LQUQn5ccTAYZGBgwPG/r66uLuy5Jrmz8qa1QATR48fXehpfSxdSVQOVj7wfADWxQmrwVWKvfwWpuonAsfNrgzsD8iUDOgRPP0ly8HsYgkKw+x2kpwcKpqSayDcDN2Vh5qAq/wPXyRtREASMtWurK2EyY9fxNHcRuvQxDE1BWZwgMzdKcugKsRtfB1EC0YXoD1Hzzv8Zd22LdS156R6RVz6P6PETOPk48sI48txI1ntp6LWsfFOVizZeMzMz66ioThuvzWBoCvLMAILby8rzf4X38Ek8jSeQquqt4Wpq7EZ20GZA4MSlNZ+97BQ/MzuSlftK2QbJ0DW0VJTk4KsgiJw7d876WYUO14lEgmg0mpNgs5nX0WZ/v4OD5v6GIAhUV1fT2dmZ87cu56C5uLjI4OAghw8f3lIceiHMz8+TSCRoa2uzEvo8bjfJ/DAEtxdDVxE9PoKn3kXw1LsAWP6Xz6LMjeAKhrKBIhgYukZmuh89scoHPvA+vvjFL246fM4/NJrNmiAIu8qOLQdOG6/KykqrPhRqvLZihnv37l2e+egPIEguPN4g8uww3tbTeJtO4Gk8BpKEvDgJmor/2DlEjw9D10mH2vjnV67zrW99i8HBQX7jN35jw5+zkdfRwsICIyMjGIaxqdeRkzCYvdRkHaB0eL3edWzbYkl5TmD6nAUCAS5dukRvb2/Zg6ZYLEYsFiMYDDqWSRWCyQoxwxPMGl2KTCr/WZaXl4nFYtTU1BSsE3vNv7DYYD4SiRCNRpmZmcmRo4dCoYI+QNthBl4KSmGYb+Z1dO/evZwU62JeR5qmbTiQM70HD7B/IYoiDz/8cM4ioJz+z/SNTCaTnD17dluS2mVZZn5+HqAsQozJaHManuAEiUTC8o0tRNJ40IuGQvB6vTQ0NOQM5s2EZ3P5asrRzfqQ3wftpUFbPuw13s5sNiX3Q0NDpFIp/H5/juQ+/xn3o3R+Tw7azGS37YCpGa+pqbHiimVZLqlhCwaDGKpM+K9/zpI9eZpPZtkXhYIPXN6c5D1XsIbKc0+THr8JazJJBBGMtQ9FTSE91QuGga/jYUSXCwEBXJ61bxU3HLTBfRrs4uIiAwMD1NfXs7KyknNAMxsUJx/EgiCgKwrhv/kFjHQc0VeJt7kLBBEpEEI6ehbvkdPEb3+HRN+LWfqoy4WeXGHl+b9EqqjD09SJFl8iPXGT4Jnvo+L0uxEEEX9HdvhkqArR618hNXIt62uX9/PzGy+TimoO3wo1XqVCEETcRx9Cjy+jJVeJXvsyejIKgoAUqAZNQUvF8B07T3osKw1G17Psw6EraKkoGDqi24OuZNCSEQw5jf/EJeTwYE46Yj7sWv58um0xr6OKiopN/3bxeHxbTJ0P8GAgCAKNjY3r/s5bOWhmMhn6+/vRdZ1HH310W4ZOpmeIKIoEAgHr0ABZibWyeA8tsYoUXJPRuLxZeXYeBMm9JsnG8qRM3H2ehkN1fPP6644Zd/amKZFIcPfuXYLBIC6Xi3A4nPMeqq6u3vA9uZewUeM1Ojqa4wNk1oetmIHfu3cP0e2l6vIPkJnpJ3brW0Re+3tEb0XWzkBJ4z92PhtcY0rsDR0jk0RLrILk3lL6WTEj9c28jjYLQzCHHwfYv6ivr19X61wuF5lMpqTr6LpuefyeOnXKkvaVM7TTNI2RkRGWl5eprKyko6OjbHP/iYkJdF3fkpTVvmg1vYfT6TShUIixsTESiYTFHDXrBOx9L0OXy7WOEWEuJu0+QOZzmb3tTplwF0K5Vg75RurmMxbzOgqFQo4OmrD3hqkHcI6qqqp1Q7Wt1CzDMJidnWV0dDTH5ywSiZRcS+3XNFlnVVVV1NTUlNVXCoLA6uoqCwsLjsITNru38fFxwuEwjY2NOSQNe53YD7DfswlzMbm0tMTY2Ni6s73ToKjtQrn1z+Vy5fh5msvXaDTK4uJizjOaNXAz6xA4kI6WDacTW1VVGR4eJhKJrKPgb5Zyko9Dhw6BrlP9jmdJjb5O7Oa30F/5PIaqIHr96OlEzveLLg96EQacbqXsARiosUXkuREElyfra2ZqFUXRxnYzWFhcLHp/giCgKAp37txBlmXOnz9vNV+CIKBpmiVLGh4eJpFIWMkwxVKg+vv7UcIDWX+eM+9Fnh8jcfdfiF77EqI3gOCtQEvFQM0gegNUv/NZPIfa0DMJ5MVJMtO9JAdfRnT7kQIhEre/TbL/JaRgNZ6mE/hauonffQ5lfhxXzeEsY2wTFKKi2puSWCxGKpVieHjYKjybUfENQ0cEXA0d1Lz7R6yvZ+ZGiF75Emp8mcoz784eKNegxpesfxt86EkSt/4JXU5mwxB0HanuKK7KOuRpreQ3+2ZeR+YzDg4OFvU6isfjjmXRB9g/KGWjaRgGU1NTTE5O0tnZWdBAvNTtl/2aJ0+epL6+nldeeSXnez7ywQ/w2f/6t8z1v4Tg8eNtPonr0FEMTcMwdATBJi90uUHXMTSFzFQfCAL/7ud/lk996lOO7wnub0THxsaYnZ2lp6eHQCBgsRvsdcJkjqZSKUZHR7c9jGAnkd94GYZhsd4WFxcZHR0lkUgwNDREdXW14/S7ZDKZZRv2vJtgz7sB0DMJ0hNvsvrCXxF46AlE0ZWVyEsu9HQCQ80gL4wR6Ho7mbE3tm2w5cTrKBaLMTQ0VDTFda9tMw+wPSj1oLm0tMTAwADNzc3rUvq2OmhbXl6mv7/fYp3dvn27rMTjhYUFpqenaWpqsljBpcKscaancUdHBw0NDaiqaj1zPnM0kUgwPDxMbW3tvmH92n2ACi1fp6amiMfjrK6uWoPG7bLjKIbt8Ey1w4nXUTQaJRAIkEqlCnod7fUB6gE2R6E6UCqjLZlM0tvbi8/nW+cbWSgxvpRr+v1+Ll26xOzsbFn1L5FIWP6t5bCCIfu5f/fuXWpqarh8+TKqqlq/R0VRiEQiVg+YTCYJBALIsrzjSfDbCVOObkpq8xeTsVjMslkwe9udSniGnal/5vLV/ox2W5VoNApkX8PF+ve9Zp+0JwdtxV7wZqHZ7FA0NzfH8PAwR48epaura931Sm2ysk2/ge/Yo/iPX7C+nuh7idXvfY7Fr/0eoq8Cb0uW7aarGfT4CloqhuS3NfySCzI6WjJCauwNEEX02BKew114m45n0ysNHUNTMVQFw9BJT/ejzI8Rp7hW3WSYdHZ20tzcjCAIyLKc87zmoeTo0aNWsfF4PMzOzjI0NJSzNXvfB55mZGSEqsd+iMAa+8x/7DwAWibB8rf/DC22iKu6CXU1DLpG/M3v4D3chbvx2FqK4JsEu99F8PQTCKKIrqRRlu4hz4+TGnqVZO/z4A0S7HkXWmQezcGgLR/5TYmu61y/fp3q6mqi0ShTU1M5VPyCjZehY+ia5R1nwtt4nMCJS6gr02vfpoEgkJ7qRVmYBCDY9XZLRkoyiudwF2pkDsnltv5NuRLOfGafoijcvn2bQ4cOFfQ6MgvSgXR0f6MQtd1p3YrFYvT29hIKhYqGHZiNltMP4Xg8Tm9vL1VVVRsGKPzO7/wOv/M7v4Oqqnz729/mi1/8Is+99ApxUST85z+Fp74dz5HTeJtPgmGgywkSd5+jva2Nb1/t31IkdzqdZnp62grNyU+xKnR4uXLlCpWVlUVZv04GVE6wk1R+QRDWNV7Xrl2jsbGRWCzGyMgIyWTSouIXa7xSqdR9v8k1iN4gnoYOEERE0bX2WjRQVmaRp3tB1/Adu4Dkq8guHHaQQZbvdXT16lWOHDlS0OtI13Wmp6cP6t9bEE4PmrIsZxeFisK5c+fw+/3rvqfUHlCWZQYHB8lkMjnXLHVpm3+PmqZx5MgR/j/23jw6rvM88/zdpTbsO0AsJLiAIACS4iKRsmN5UxRHXmLHaSfpziTd4/bEk7QzyXQm7jidTtpzks5JTk/sPsmMk0nbcXdi2Y41ie3YVtq2ZFvWRlIURREEiH0h9rX29d77zR+F7/JWoQqoKoAkJOM5x8c2UXXrXuDet97leZ+nsrKy5Dgh129mZmZs4fDs4jc7Trz66qvU19cTiURYWFggHo9n5Em5Vhb3IrIHkyMjIzYj0CnH4WTzleKumA+7XWjmQvY13rp1i9raWizLsmsdwB66rq6uvi4ap/soDoXGLDl0XFxcpKenJyfbvNj45zRmcB5TLWDbKt/xJicnWVxc5ODBg4RCoZIbQpZlkUgkuHHjBr29vTaz1Qm5JSeZoxMTE/bK/uTkJJFIBI/HkxEnStVCzsbdzAGzB5PLy8usra3h9XrtoQqQkduWakKVC/ci/jn7F5Du78hhqjQTk3rn1dXVrKysEIlE9tRWw55stOWDDA75Gm2xWIzBwUF0Xd/SqaSYmyyRSKSt5RUVYaRQXHeO6aptRdF0ah/7XxFGktjYy4SuPYUZXkVRdWL//d+i+irxtHbjae9FGMm0y97aDHrNAYy1CFrDQTwtRzdOTMUMrRKbH07rgwkLY20Wva6d6prNE3qZrIXDYbq6uuwp33aQLkkHDhywd6Xl1Gx0dJSxkWFUXxXBS08Svv5PaJUNeFpPoJVVE7zy92jltTS859+iV9YjhIURWCK1PEls4iqhV58CYaG4vCQWRkHV8B4+g15Wg6u+g9jYy2kHV1XD03wUVXezM3nPO5BrA9lUfClAm514VVZWpov9RHRTow1AWHeSemGmwLIw1ufwHjm7sQaMvUaq1bXjaTmKsT4HmoYRXsNKREumZ+eDFMPPp3X0xBNP8I1vfIPvfOc7fPOb3+RXf/VXOXXq1K6ewz7uD7YrNA3DYGxsDL/fT09Pz5YTHVkgFiKqLFevZBJT6Lm++93v5t3vfrf9b/39/TzxxBN886n/wcTTz5CMBlEUhV/72Mf45Cc/mbMg3u7cJicnmZ2dpb6+nq6uroLfq6rqJr1EuZbpbFA5XfDu5mRwN1FbW7ulDhpkJl6xWMw2oXBCmEZ6pRdsKYTk7ADeg6eJT99IMxIBLPOeTg+dArrZWkfPPPMMn/70p1ldXWV+fp6f//mf573vfe89O7d97A5y5WjbFYdCCGZnZ5mamuLo0aM0NzfnzfUKLTSdq1dHjhyhpaUl45i5HEO3O97i4iJjY2McPXqUlpYWJiYmSmYhSVFpXdc5c+ZMUbpu1dXVdvNaMuf9fr/NDHM2qHbikn6vUVZWRm1trT1UceqgOU2onHIcpRaelmXtWkFezGeWl5dTUVGxSetofHyc3/3d32V4eJif+qmf4tFHH+XXf/3X7+n57ePuIFuLOxekzmNzc/OWbsXFNNoCgQADAwM0NjZuOqamaUXXOMFgkJs3b9LU1MTFixftvKsUSHdmgAsXLhSco6mqag8e5HBX5klyOwCw84yamho8Hs/rgvXmdrtpaWnJkOOQjFinDtpu5Lb3otGWDdM08+qdBwIB/vRP/5Tp6Wne9a538fDDD/OJT3zivrPb9myjLRejI1+haVkW09PTzM3Nlez8lA1n0tbV1YWiauliw9FoQ3ehbKzUlB19iLKjDwEQ7n+GxPwwte/4CPHJq8TGrxK6+o+Y0QBYFmXH34xWVkXIP4+SpV2UmBnA3XIMM7yGGVmnrO8dGKvTGFmup3KSdfToUXw+X9FJUK6Of319ffr3q+oc+Ff/BTPiJ7kwSmLuFvGJVzACi+niSggiQ8/h6zyLu+EgrpoWYuNXSa3NUXb8TZSfeITU2gzJpUniU9cJv/Y/UHQ3wjRQXF7KTryF6MhLtqMn7I54a67JgaIom3TQZOI1OzsLmovU4ihaWRWplWn0uva0wQUbhSYKydUZErf7QSiU9b0TEQ8jT94Mr6UbbR7fxjlYmIElkvMjICyOHj264+tyIhcLyUm3/cQnPsHk5CQf+9jHbGHxfbwxsFVyJNeGOjo6OH78+LYJQSGJlkzacq1eSci1zUK+bNvb23nf+97HRz7yETo7O1lZWcHn89ki+MVAJlgNDQ10d3ezvr5e1PuzkWstUyZespgt1YzlXidnzs/Lp4MmC8+lpSUuXbqElYiQmBvG3dSZljFADhoUzIif2NjLoKiU974d1e0lPnUdVXNhJSJYRvK+M8ik1tHP/uzPEo/HicfjPPbYYyVN2/exN7HVoEEybisrK7dk3EoUEv8KEecuptEWj8cZGBjA5XJlrHIV26yDdA4zMDAAwIMPPsi1a9eKijO58iTJnHfmSYFAwHZJN02zaBe8e41cOWC2DpqzKJuenrYZsU6H50Lz6ftVaGbngFLr6Pz58/z5n/85n/zkJ/nUpz5lD1b28fpCsc+VZNzG4/GCdB4LYeJK+aVgMMipU6dyfscXw+g1TZPR0VH8fn/G8QppIGZDDoBXVlbo6+ujv7+/6PiX/Zm51jJlniR1L0th/d7LVe5c8U/TtE06aLFYzN6IcjJi88kR5cP9in/Z3+9OvfPPf/7zPPLII/zd3/0dly9fLnqAfzewZxttuZArOZLd9oaGhh3veEtIh6qKioo7SZuiELzyVbwHT+FuOYbqKU+zoITIMD4A0uwAYaHqOmXHLlJ27CIA69/7HMmFEbQy2fxQbDFwMxZCmEk8HSdxN3QQHb2ysbajgnJnFcqZYMlkLRwOF/Uwb/UApR+a9LG08hp8Rx+012Vn/+LD1P/kvyWxOE5ydpD1Z/4rdpPMSFLW8zYqTj+GqrvRyqrxtvchTIPg1X8kNn4FBFT0vtVxHirCNEitL9ifuRMUStGViZdpmiAEWnULiflhlr/+xwgjiauuHU97H2ZoBSseInH7JnptK2ZoJf3FIkwURSE+M0hqeSrtOqrqWKk4IpXATMbxdV0kPnpl14U3C2EhRSIRGhsbi2L47GNvIZ9GR/b0UK6NK4pSlPPTVoWmdKiKxWLbJm2ySNzqy9Y0TUZGRggGg5w+fdqmdEs2hWzWFYLsBKuyspLV1dVdT2ZyNaikC57UhMxeS8/FjNiLejnZiVdDQwNmPMzat/8cKxFFq2zE296D6q0EBNHhF9HrWjHW5lDdG/eXEKSCSyRnb/HWRx7h0UcfvX8XlIVQKERDQwOnT5++36eyj11ErpjlNCbo6ekp+Pt2qwJR6tfOzc1tK85diNaRU9uyu7t70yC42EbbwsICY2NjHDt2zDbNKSXObPcet9udl/U7Pj6esZZeU1OzJ1i/heSAzqLMyYh1NhWdrLetNJz2SqPNCblW1dnZSWdn5707sX3ccwghmJubY3JyMifjNh+2GzTIwW0++SWJQmOX1LZsa2vjwoULm4aBxcQ/JyPuwoULqKp6V1xEczWopF621AQvlPV7rwYShcQ/RVEoKyujrKwsI7eVsV1KCWQbDeaKOfeT0bYdGhsbec973nMPzmh77NlG23aMtlQqxcjICOFwOG+3vVjI3falpaUMhyoABCQWRolNvIIVC6KV1eBqPIQQJsLIbrS5wMhhhqC7Ec6AoihgGiTmhkkupidPitt352eOByYUCm9KsO4cprhABfmTrO0eUnfLMTxtPXDuPQghMINLLH3l9/F0niVxu5/o0HOonnK0ijpcjYeIT72GMJJ4Wk+kWV72CYAZC5KYHUz/TnYhRhb70EciERRVRfX4KO99K5VnHscILBIdfpH4zEB6DVRAed/bMMOrmNIEwUgh5Bpp5xni09exYiEi80Ngmrg7z6KX1yKElXkP7QJej9bG+9gd6LpONBoF0s/v9PQ0MzMztjFBMciVaDnXmg4fPmw7VG2F7RItKUje3t6eN2ErNFnLlWDJ9+eKZ7utjZHLBU9qImYzI15P7lY+nw9P81EafurjWPEw0dFLxCavY0y8grBMfMcuonp8GOvzgGT6Coz5YX7nt/8dH//4x+/ZuRaSTIfDYQ4fPnwPzmYfdwuFiIGvrKwwPDxsGxMU86zrup6hYyshXerr6+sLGtxuF7ui0Sg3b97MHNpmodD8LZFIMDAwgKZpGYy4nRgoFINCWL9yJbVY1u9uodTCL1dTUcb2yclJotFoRmyXAtx7sdEWCoXuO8N4H3cPMq+RhJDy8vK8jNt8yNdoc7rUFzK43S7+GYbB0NAQsVgsr15mofmfZVn2UCW75i82npUS/7L1siH3WrpTlqNYB+mdotR4lMv9MxaLZZjwOTc6JOttL8a/u6mJVyr2bKMtFzRNwzAMu+HU2dlZslMTZP5B/H4/g4OD9t549s2juT3UvfMjuOrbsVJxYuMvExu9gjCSBK9+nZR/Hk9rN+7moyiantb0ykJ67dJCCEFqbRYsAzO4jBUN4ut6mMTMTXubUlEUsKy0g+fMALg9LC0tbXKPka/dLUabrm+4y+V+56bj6NXNgEL1W/4FemVD2nV0YYzE/DCR/qdRPGWU9bwVK7xqv10ICyyT1OIErqZOVE85ybmhgs8/H4p9wKLRKKhaWlNuQwxcr26m6qEPUPXQBwi8+BVio5dQ3V5MywIUUuvzxKeugwJlfe9AxEMAGKu3cbedILkwiuba+PsIa9dXNwtptIVCof2V0TcgZPwLBAIMDg5SV1fHRPcmWgAAIABJREFUww8/XBKLIDvRkmtNuq7njDH5kC9JSqVSDA0NkUgkOHfu3JYJ23bxa6sES+J+MMeca+mSGSFdQKVDZiqVQlEU5ufnqamp2VUh2t1CPB63NSpVbwUVJx+l4uSjxKdvsPb0/4teWbfhrK1gRoPExtJs6698+Ut4vV5WVlbuWVFdKKN3f9DwxoOMWVI3VwixbWzJh2xGm3OtKdulvpjjSOQTD893jK1WnIUQzM/PMzExkddB+n4gH+tXFp5zc3Mkk0ni8TgzMzP3xAV0t4osWVRWVVXZGk7Zsd2yLNvZ2uPx3LNV2u2K2/1B6+sfWzHIUqkUU1NTrKysbCaEFIjs/C9bKqnQGLMVo3dpaYmRkRE6Ozu3HNoWUr/KzbWWlpZNjDgobf10N5BrLV026CXrN5lMcvv2bWpra++6C+huxT8n682pA+mM7YlEAk3TcLlcBAIBKisr70nTbbscUDrK7iW8rhptQghGR0epqqoqqhjMBVkgCiEYHh4mEolkrDXler0w0xNQ1eWlvPst+DrPMf/ffgO9op7E7CDRW89hxUOo3gqseJjlv/8DPB0n026cTUdAc6dNE0YvY0b9gApuN2W9b0dVVRKKirAM4rODGIElEBaJ2VvoNQeo0FJ5V2F2vZsvBCvf/FO8HSdxt3Thqu+4I5a9zceonnK8h07jPXSaxO0bKJ50YiVDsRkLEZ98FWGZqJX1eNt7SS5PFXzuW6HYIBMOh0GItHZcTjHwJEi9NmEhUnHiU9fRaw9ghlbTSfZGA8598CSehoMk50dQNNfG349dZ7UYhrFtoE4kEvd8kryP3UWu+1hRFFZWVggEAkUVg7kgEy3JjJudnS1J3zJXoiV1HwpdZdhqorldgiXfv1dWND0eD01NTXaiur6+zszMDMlk0haidVLy71VyshUSiUTaETsLwkyhbExHpMRBdPgFtOpmTP8C73jHO7hy5QqRSMQuqrPXDXb72gpl9O4zOt54UBSFRCLByy+/vOOGk7PQlMy49vb2gvQtncgVu6R+ZH19/ZaC5M5j5ItfcgDidruLZq1shbuxagXkNGq6dOkSiqLYZlTZrN/dNBO4m2yG7NhuWRY3btywN2Gi0SgejyeD9XG3jBK2usZIJLIf/96gsCyLK1eu2CzeUr9fnXmbkxlXiL6lE7kGDclk0h6EbGVK6DxGvvzPOQDZqj6H4oatdyv+ZTfohRBcvXoVjydNlJGaiTJGSJOF3cLdjH+5YvvU1BThcJi5uTnC4bDNepbXdzfq0EJW5/eS4yi8Thpt0l1ubm6OlpYWTpw4seNjaprG4uIiExMTHDp0aFtmnKbpiCwh3jQLQOA5eJLKM4+nzzUZJXD5q8RGX8LV0kV8+jUiN7+HlYigaG5EKo5WUUt536NEbz2LonvsYKkoStrNTdFQK+qwQquUn3onZmAZEZrJe267GTTSQVagldcRufVDgi9/HZFK4GrYcGa53Y+ntRvVs33HWAhhF2oAwrKIDj0PQqB4KxxeCGmNkbW1tR0lJ8UGmaWlJUBghtZA2fyFJYwkiqphxkLp1V4hKO97O2bEjxlatV8DoHkr5UWSWBzHDKR154aGhnY18cplhpAL97t438fuYnFxkeHhYXRdz9twKgaaphEOhxkfH6empqZkfUtnoiVXm1RV3TErTiZYgUBg2wTrbiVNuwHJdjh06BCwmZI/PDycsZJVXV29owFSKQiH75i7OJF2HVURRjLNqkbgO3wetayKaGARXdfRdd1e08zWMHEmXjL+7TTx2me0/WggO76FQiEGBgawLKvoYjAXNE0jmUzy2muvYRhGycw4Z8Eqmberq6tFDUJyrY46tZdy6bq9XqAoCpqm0dbWZpssJBIJgsEg6+vrNjPMuW7l8/l2ZUvlbkNVVXRdp7W11f5+kqu0q6urTExM7Oq1FYp9RtsbA868JplMcuvWLRKJBA888IDd7CgVqqraLvU5pZKKOI6MXU7mbba80XbHyJW/STOu1tbWbXPeUoat9yJnVBQFVVVpbm6245+TGTY/P08ikaC8vJyampods36FEPes9lMUBZfLleHwnEql7Gtz6hjLGng3hq+FalTuJezZRpt8qNbX17l16xZNTU0cO3ZsV1zE4vE44XBa86yQjjuAQGCsz+JuPnKH/aTpYJoZa6Kqu4yyI+dJzt2i5s0/Z/+7FQ+z9sxnSSyMUHb8TRsXqQJ3gpQQAtVTga/rIsmZAazwKqqqYymSOZUbu8lokwls7dv/lf1vRnCZ6NALpJanWH/mvyKMJHplA+4Dx/C09mzzYWAl4yQ2XDhRVHxHziHMJKnVdPNQWCYgdmyrXGySpes6qqccK5XE/8O/IXTtW3hau/G0ncDdcgxhpDBjIaJDz6PoHhRvJarbl26yKarDjVSgaDpWIgrCwgwuU3bsItGRl+ju7rYTr/HxcYQQO0q8cjmuZP8O9vHGQSwWY3BwEF3XeeCBBxgdHd1xom6aJqurq7ZD1U7WjGWjbXZ2lsnJyZL04rLjkUyw2traCmKY7OVGWzZyUfKdycnMzAypVKogIe7dQk1NDfHp68x//tdxt3Thae/diH9JhGUQGfgBankt6B706sZ0nMvDuMzWMMl1bdJAoqqqqujEa1+j8kcLshj0+/309PTQ39+/4yabHOotLi7S19dnrz2WAlmwZjs074QVF4/HuXnzJl6vd0dNxa3O4X7GTI/Hk6GHZpom4XAYv9/P6OgosVgMn8+XwfotdAh0r/V5stc4czkXylWysbExotEoXq8349p2m/UWCoX2zHrxPnYG50rnsWPHAHaF1RoIBIhEIgA7YsbJ2FWIQ3M+ZA8apHlWKBQqyEFVHmO35JPuNnIxw6QLci7Wr9SDLAT3I/4545fL5dqkYyyvbWZmhnA4jK7rduOtlMHy61Gjcs822lKpFAMDA8TjcR544AHKyspYXFwkHo+XfEyn+1NZWRnHjx8veMJuGSkCLz2J/7kncNW342nrxdN2AhRymCHoYGWy31RvBd6OPlIr03dep6oIS2AlY8QnX8WKBfG0nrCdRm2WgQLJLLfBjM/LCjKWZTE/P4+madTU1BR1I+cKuHpVI1UPvZ/Q1a/j7XwAT1sv8clXiU1eJzb2MgLB0t/9Hu7mo3ja+/Ac6MLVcAgQmOF1knNDKC4PoOA7+iB6RR2ptTkAEvMjJBfS9sLHjx8HSrdVLjbIxGIxFFVH9biofPPPgRDEJ68RvPJVrGgQYSRAUfEeOY8V9WMEVzY+J71GmnYjbcPwz2OG10jMDgJQdvKdKFZamylX4hUKhQgGgzkTr+12+At1XNlrOlD7KA5CCCYmJpifn7ed71KpVIYYeCmQ7k9SV2enWn6WZTE4OEh1dXXJRaFM1kzTZHh4mHA4XHCCBbmTrJWVFeLxOLW1tfdFF0062BWyOp6dnFiWZScnUojb7XZnxIjdLM7++I//mD/8wz/kmWee4Q/+4A+4fvnvARCJKGg6FWcex9vazdp3PpN+g7BQcjCAC7m2fImXc91gq++r/Ubbjw6kxk9HR0dGw30nxUQ0GrW1KOvq6nbUZJPnsrCwwPLyclExywnJxnDmpydOnNjS7XQ7hEIhVldX87oh76X8QNO0TSYLkvW7sLDAyMiIvZIlWR/5YsT9brRlI9e1Sdbb8vIyY2NjCCEyth62Gr4W0kzYZ/S+MSBZvJWVlXZutbq6uqMc0DAMWyrJ5/Nx9OjRHZ2jqqpEIhGuXbu2rUPzVseQjTaZn25lnpUL2c26ZDLJzMwMFRUVOWuqUgwE7xYURaGiooKKigqbGSZdkItl/e61+Jfr2lKpFIFAIOfwtRBGXyGMtv1GW4FYXFykrq6OAwcO2DdOtutUMQiHwwwMDFBVVcXFixdtZ5VCUV1bi9H7btzNx4gOv0B8+gbR4ecBhdTSBMnlqbSWmaqC5kLkEMhNM+HSX5TCNNL/SSWIDPwArawGtaIeRd5AavqajcAiscnraGph00mpD1JTU2Mnbk4nlJqami27/1tONhQF1VtF+Ym3UH7iLQBYiSjzX/g4NW/9lyTnbhEdep7QK99ApOIblyrwdJxEdbmJTV53FGgCMxrAigbQa1uxAgv2x5Rqq1ysA0o0GrWNK1RPGb7D5yjvecT++dI//CFWMomruol4eDW9RhoNbrinCsp7344ZXsXwz5GYGcDT3kPidtoVzDISOYtR2fyUNO1ciReQEVSdjYLtgkwqldo1HZd93D+EQiFM08xY6dzOkn0rJJNJhoeHSSQSnD17lrW1tR2xg6U+w8rKCkeOHKGzs7PkY6mqSjAYZHR0lPb2dk6cOFFUsuBMmpz6IGVlZRm6aLJI2+mX8PLyMpOTkzz00EM5f/7EE0/wq7/2G1hGEt3jo7WlmccefQcf+tCHCtZsyjZZkDHCyfrNFyNKga7r/MRP/AQvvvgiN+eCNH7wdzH8CwghcNe1Ep96DRQVy0gSn75R8nrrThOvQhtt+2Ywr2+Ypsny8vKmjQNZlBW75p5tTuD1erl169aOznFlZYXR0VEqKio4d+5cyc+foigkk0lefvnlknSSnLAsi/HxcVZWVmhsbMxwQ5bxTz4be5UFvBPW771cnYLiXf5yGUjIwbL8DnQy+uRmh7zfC/m8/UHDGwNyyOoc1klDrFIgBxdSKunFF1/c0flFIhH6+/sxDIM3v/nNJYv8y/xtYGCASCSS1510u2PIeLawsMDo6CgtLS0sLS3ZWyCy/r3XbvClxNlcLsihUCiDGZuL9XuvXUBL+TyXy7XJQCIXo885fHDmm/uro7uIjo6OTQGllEJTJh7Ly8v09vbaD1mxx/K4XKSMFHplPVXn30fV+fcBMPuX/wvJ5UlWvv4nCDOFu7ETvb4DKxYgMvB93C1d6LUH0k2XDWdLI7hCfPJaWgNHCLyHz+KqaSE2cQ0hBGYshLG+AMIiNnENvboFVyqY99wURcE0TXvf/uTJk7b1rgxizoc0EomQSqWYnp7eJMgt/zvdOGxHUbNv6MygoXrKUFUNd/MRyo7dKTyN8BpLT/5HtNo23A0dGP7FzKMYSRQUyk6+E2N5Aiu4dSOxEFtlj8eDaZpEIpGCHKCCwSCWaYB1x3U043M1F6proxlrmViJMNHhF1BcXlRX5R03UgHlvW8DTScxk2a1pQKLiO2cI9g+8ZKNAhlUo9Holg5me1EIch/FI5c1eKk6FAsLC4yPj2eYE2iaVjI7OBwOc/PmTVubYScOP4ZhsLy8jGmanDt3rugEC+4kWdKE4dixYzQ0NJBKpezfmWzUSxZVLBZjfHy8aEHuz3/+8/zGb/4WlmWiqjpNTU382MMP8f73v593vvOdfOjnfp6XLl+h6sLP4O04SWp9jrXlSf72qef43H/7G7AsvvTFL/D4448XdY25mLEy/kmmd1lZmR0XS9XCaGpqwlibYf6zv4q76TDu9l5EPISVjCIsk+jAD+jr7eHb//TUrhXqWyVezkZBoc2zZDK5bwbzOoeu6/T19W36d5m3FVPUSUOVxsZGu9GdTCZ3NLS4desWpmnS1dVFKBTakabY0tISS0tLnD17dkfaS3LI2tjYyIMPPohpmvZ5ScdM2aiPxWJYlkVTU9NddQzezRiRj/U7NTVFJBLB7XYTjUbx+/3U1dXdNSMCJ3ajsM01WI7FYgSDwU0C6jK324q5sm+G8MZAd3f3JjKIrutFx614PM6tW7dQFKVgqaStIDXTFxcXOXHiBLdu3dqRk+ba2hqRSISDBw9uq5WeD3JYMTIygqIo9hBUHsswjIxhntwSkBqyd9sxeKfHdmrdwh2Cht/vZ3Fx0Wb9CiHsZuK9yIF2I/45B8sSktHnrO/lYGW7RvNejH97ttGWC8Uy2rJ1M5w3RD5b9nxwu11gbmaAKLoLX+dZat/5r0mtzxMdep7Y1HWEZRK8+g1EIgJC4Go+gur2IZJxYuMv4246ghlexYxHcNW0yJPC8C+QmBlA0dMPSXnv27GSUayZG3nPLZFIMDMzQ1tbm32dTrZK9kMqnaxcLpftFpJBcdf0jcZhElfDQTxtfXjauqGIpEmvqEPzVqFtcrMTxGcHSS1NopZVbwSHtFFCMchlqzw/P283FQpZyZyensaKBUHV8riOplAULa3VFl5HpBL4jjyIGQ1gBJfSrxFpfTnVU4aVjIGiEJt4BSOwhLapSVkYtkq8IpEIIyMjaJqW0fGXjJZQKLTnuvn7KB678aXv1M3INifY6dCir6+PqqoqxsbGSqbgr66ucuvWLcrLy2loaCipyQZ3kiiZYLnd7oxry9Wov3TpEpWVlaytrdnUfKcTVLYwejgc5qd++oNcfeUa1Q9/CE/HSczgMtHlSb758ih//48fRSTjgMDbeRbVW4EQFu6Gg7jqO4jqbhJLEyCsDROWnSEf6/f69es5Wb/ZU8F8+JVf+RV+5Vd+hatXr/Lkk0/yzA9+yPjT3yURCaJoLj7x8f+D3/7t3wbSzb67MT3NxeiTidfc3BzRaJTV1dUtdez20mrcPkpDLua9zAELuZcNw2B0dJRgMMipU6cyku9i8z/AbuaPjY1x9OhRmpub8fv9BAKBoo4jEY1G6e/vtzXLSm2yWZZFIpGgv7+fkydPUllZiWVZGIZhPwfZjply68HpGJwtyF3MM3T79m3e9uhjBAJBTnQd5dF3voN//s//+a4Yl+VCrhiRSCS4du0a6+vrTE9PZ6xk7gbrNxfuBoPEyeiTw1fDMAiFQqysrBCLxbhy5UoG682pY7cXGR372B0Uw2hzrqLn084tdtUwGAzazXypRVlqM90wDFsaqKysjI6OjpKOA+ma9saNG3R3d9Pc3IwQgmQyaf9c1/WMRv3c3ByRSATTNO160ckQq6qqKuq5TiaTvPd97+fKK9foaG/lrT/2Zn7mZ36Gt73tbSVf01ZwEjQk69f5+xwYGNi0GZBLQmCnuFsMulyMvnA4TDAYJJVKceXKlbw6dnsx/u3ZRluuG6LQbn4qlWJ4eJhYLJZXN6OYQlMIgaYqtsNkxnnqbtsMwVV7gOqH/xkVpx5l8cv/gQO/+J8BSC5NEB1+kdjEKwjLoLz3bahuH9GRy1nXrGKE1/Adu4gZXiM5N4Tq9iJS8ZyNKCEEk5OTzMzM2GYRhUBVVVRV5cCBAxnUfKkrhGlw4CN/uWGC8DyJmZtEbz0LCIz1OVIr0+h17ek12a1/c/b/slIxQBAbexlQcDUdQcTD9ut2OvdUVZWysjKqqqro6urKWMnMZ6tcX1+Pq76D1NoMgZe+gvfwOTwHjuNq7ER1ecA0sCyDyMD3EZaJWt2CXt2EEV5HUTSM8BqJuWGQrmOJKABmNIS38wxiYWiHV5WGM/GSq3put9tmKS4sLBCPx1lfX+fpp5/Gsizi8XhJLmr7eP1DrnXOzc3l1c0ottEmWSHNzc0ZQ4utrNnzwTAM20Hr/PnzO2o8LS0tMTQ0hNvt5syZMwW/T1XVTYLcuXQhZeHZe/oMwVAYrbyO1Po8em0renUzWlUTwrKIzwyg6C60qiYSs4MkZgfSbsqqC6wUmAbuA8cx1mbuSmIiY4TL5aKnJ21Q41zJlFNB57rpVlPc8+fPc/78efv/Ly8vE4lEMlaE7+Wagky8EokEjY2NtLS02CLjktGiaRpf+cpXUFUVv9+/JfN3H69PFBq3lpeXGR4e5uDBgzm1foqNf87hpHNoUWrDTsbn3t5eNE1jYmKiqGNIhMNh+vv7gc2i5lsVVZqmUVlZmbFGKp8nqQvp8XgK0o79zGc+wyd+9/dwd5ykovc9jC9PMvSFr/LpP/u/UVUNl67yEz/+KL/4i7/Ij//4j981ppnH48HlcnHs2DH77xsKhfD7/SwtLdkSAs51q92IX/eiqa/rOrW1tbhcLlKpFD09PTl17J5++mlWVlZsoft9vH6xkxo4Wyop1zMnn5FCnkfpAu/3+zcNLUqBjM+dnZ20traWvMYq2cXxeJyTJ09m5LrbuZR6PB46Ojro6OjIYIg5nyfnumk+SZ4XXniBD/7sz5PUK6h6yy+w6l/ky09f4W++9BWwDHxl5fz7f/db/Nqv/VpJ11godF3H6/Xata0zpjs3A5ySSzuNxfcqB5QanVVVVczPz/PQQw9luFdPTU1hmib9/f1cunSJnp6ee75GuxX2bKMtFwrp5i8sLDA2Nsbhw4fp7e3N+7AVmmhJVsjK0hKBkf+P2MQreDpO4jnQjbvpMIqqZ7iOpg/uAuvOsd1Nh3E3HcbT3ov/+3+N6t5gbqiqzRJLrc+TWptDr25Br6jFiqxvGCIAG6uhTsj1rbq6Orq6uopeA8ueQmSu7yiAwFXTTPXFD8LFDwIw+5kPk1yeZPlrf5xek204iKfjJMIyiY28iPfg6U0NOCEE8ekbpFZnQQG1ohbv4XOY67MYiQhWIoqxNosidi5M6ZzO5FrJzLZVHhsbS2u0KSpaZSOxiVeIvPYdrGQUvaoJM5JmsbmaD2MloqjaRqC1TKx4mNjo5bRraTxEcmWaxMwACKjoextGcHlHdOp8kGszMvFyMlrm5uZ46aWXmJqa4q1vfSsXL17kz/7sz3b9HPZxf7HVFDIYDDIwMEB9fX2Gvls2Co1/0gEqGAxy+vTpTWvJUheiUGQnWIqilCRMm0qluHXrFoZhcObMGYaGdtbUzsUQc64vpkxBxanHEEKQmLlJZPAHoGyY3qgqiuai+s0/j7ftBEJYmMEVIiMvEh+7gqetFyseIrU0jgB+5z/8R7797W/zS7/0Szz22GM7Om8nsu+LXCuZMvGamJggEokUbMTibEpK3I9ExjRNXC5XRuIlEYlEOHnyJE899RTvf//7MQyD5557bs8kW/soDlsx2vIhkUhw69YthBCcP38+77Cp0OaIkxXS3d1tP0sSxQ4aZN5WU1Njx+dIJFJ0/JND1oWFBfr6+ujv7y+4yZbr54qi5NSFlE2q0dHRTYYE8XicB86eZXV5GV/Xm6g89x5U3Y3nQBecfoz47ACB57+EVdHMt1+d4Jvf+TAiFaeqpo5zp0/y7nc/zkc/+tGirruQ34u8tlx6uFJCQG5yOLc9SnHAu9eQ+V8uHTvDMFhZWeFb3/oWv//7v8/y8jJf/OIX6e3tvc9nvY/dgq7rJLYwxssnlZQLheZu0qCgtbWVCxcu7KixLPO2VCq1ZXwuBFJz7ujRo6iqWnTTyPndkoshlm9Q6VzNfPzxd/PSpZdw1XdQ+9Z/iearxNPSRfmJt2AlY6x//6+Jrs3y1FNP3fVGm7wmZw2ci/UbCAQ2bXLIuF4s6/d+5IDy75btXi0dUL/3ve/xrW99iyeffJLf+q3f4hd+4Rfu6fnlwuuu0ZavOJQTR13XN61JFXssSP8xb9++zczMDN3d3Zw+dZLLCwaar2qjIfPt9KqgZaFVNmTe4Jorrb+WBUXL7IgrigKWQXT0CmZ4DdVbgerdKGQVFZS01ll84hXERuPOOQ3t6+ujurqahYWF3bc2znU8VaWs603UvOVfpNdkh18gPvUawkwReu07hK59C2EauBoO4u04iZWIYAQWUTQX7tbjJBdG8Rw4np4CC7CSMSKDz6Koeg4tuOKxHQ0621a5vr4eRdNRFYXK8+/F3XAQACseJjpyicCLX8bVfBhvWw/R0cvg1rBSCczQMsJM4Tv+MIZ/CSseIjEziLv5GKnljcl0lu3xbiGfPo2iKLS1tfHII49gWRaf+tSnStag2cf9R777OJ8YuHPi2NfXty11upACcXV1laGhoS0doApldGyVYGWvum8H2ayTmnOpVGrXhb2zRft1XcfVfATvoQfg4gfxP/8lIjefwXf4LGYsSGplmsDzTxCpPYCr8TCptRmM9Xlq3/4/425OO3sJIdLrpiMv8bWvfY1vf+e7LC7M79o5bxf/nM0pOcWViZfTiCV73Sof7lejLV8zsLy8nA996EN87nOf49lnn71rq637uH/IN2wVQjA7O8vU1BRdXV32iuROEI1GuXnzJhUVFXlZIYU22pyNsewCuNj1K+eQNZvFVgy2+0yv10tLS0vGoFIWnp/97Gf5k//r06i1rXgPd5CYHSQ2lh48qhX1iGQUM7RK5fn3Utb1pjtmTtEAiZkBvveDr/O9H/zgrjbaspFLQsBZTN++fTtDC6iUFdq7ja3in67rvOtd7+JP/uRP+MY3vrHnm4b7KB5b1a1bSSUVeyy441AajUZLdlR2QjbGDh8+nGFyWCycQ1apObe6urrrNXCuQaXcIvrud7/Lv/n1/51wwsTX9SaSi+Msf/U/obi8aOU16JVNxOduobrcaNVNTE1N8cILLxRkhrUTbJcDZksISNZvIBDIMA4rlPW7l8wXVFXl7NmzHDx4kF/+5V/m8ccf3zM18J5ttOUr6rIfJmdD7Pjx45smjvmgaVre4i4SiXDz5k2bdqtpGj6fD9VjUf2mn0WmSEbUz9KXfo/k0jjzn/s3uFuO4e04iav5GFgmZmQdrfzO+kraUVQgLIvEwghGYAmEhTASlJ98B6nlSYQw04yIWACEIDZ6Gb26GRFesc+ruro644EtVSQ9L5Q0oy3HD+x/d9UeoPriz8DFn2H+r/83Gv/Z76FX1JNcmyU2/ALxqeuIZBzVV4Wv62HMQJYZAgIrHsJ78DRWPIy1MlnU+edCsQ/9+vo6lmmkg5Oj0ad6K6g49Sjh60+h+arlwbESUSIDPwBhodW0oJfXYqzNp80QTr0DKxYiuTyJEAIjsIgZi+34mrJRjLXx3WDU7ePeIR+jI/seWFlZYXh4mLa2toInjlslWalUiqGhIduhdCvttEKaZDLBcpoxOFFooSlXTpPJZIao7050QoqBEAIjtMrKV/8TlpGi7sd/GXfDIftnZmSd0KtPEb31Q1SXB5GM4X/uCbSKOjwHjuM9fI747ADR0UuoZTXk8F/Z8fkV69aabbLgZP0uLCyQSCQyEi+nycJea7RBphnMfvx74yHwT0d8AAAgAElEQVTX6lQkEmFgYGDHjp0SsikmHUq3WkEuhBWyXWOsmGZd9pC1VJRS5Eo24UMXHyZlmFQ99NP4jpy3j2UlIsRv9xO88lX7PeHXvkNs5BKupiP4jpxFJGKErv8TqrcCK5rf4GsnKObatmL9OldoJeNjK9bvvUAhRiDSDGYvNQj3UTzyrY5mDxoKkUrKha1yQJmzdXZ2lmxQIOE0j9mpGUP2kNXJ3iq20VZszijZr3/0R3/E//OXf0VZ18M0nHnc1vcWRork8gSBF75MfH0erbqZsiPniN/uZ2Zphcff9wEQJqf6+njuh88W9dmFoljX5VysX7mSPj8/z/Dw8Jas33udAxbqOr/XauA922grBKFQiIGBgQwafqHQNG0TBdfpppI9dSwrK0MYqxmv18tq0MqqUPR6qn/sXxAdfoHI4A8xX/4aiuZi4QsfR3WX4W7txtveh6K7EJa50awxUStqsUJrlJ94S/qAiopIxIgOPoeVjIKAsp63oKAQG17m+vXr9Pb22g+FRClBZpsXsPz3f4Cn4xSe1m7czUdRPYUFb3ddG+6HPwTA4hOfQKtuSrNe7GODFY+QWppA9ZTjqmslMTe0CyptxRea09PTpJbGASWPGYKZXi0VFlYqjghHcLd2Y0b8qLIxZ5mgKKi6G0tYKEB0+EWsWJDGxp1P1Ted0zbXuBeFIPexe5CMDrfbbScwhmFw7ty5omj4+ZIs6dxZ6NRxqyJRnp9lWVsmWIUUmisrKwwNDeU8r3vRaJMfF3rlG5jRtPi5/9m/QS2rxtNyHM+hBwi9/DWMtRmqH/4Qvs4zWMkYqZVpkotjxCavEb7xHVA1fEcfQpgpIlOvUdvQTHNLM4+86SJ/9Vd/taNzlC7TO0E269e5QisdW6XJwv1gTGyXaO2bwbxxkOtedjLaLMtiYmKCpaUlenp6NuVFpUA6d9bX1xfEPtiK0es8P2kek+8Y28WvfENWJ4rNf4qNmZ/73Of4jd/8rbQpmKoTuvZNooPP4mrqxNt5BiseIfTKN1B9VVgRP62//Jckl6dIzg8Tv93P+nf/CsGGlEpDB+EbTxf1+fcC2axfwNb6zcX6LdUIqFQU67i7jzcWsvM2Z762lVRSLuSKXclkksHBQYQQu+JQKs/v6NGjNjO2FOQbskrkygGLjYeF4i/+618DEBu7QmJ2EFddK56OU2iV9QQv/z1CWKDqd0wOAVd9O4qqk5gfYXJqetfPSWKn15xrJT2VStnD15mZGVKplM36TSaT97ShX0j8i0Qiey4HfF022qRTyOrqKr29vXkTmK2QHbCkm0pTU1POqaPP50OkNu/Gq94KrGQUz4GutDbFBmb/4iM0/9J/JrU4QWzsMqFXn8KK+hGWQK9pwdPRR3J2ACu8br9HUVSM9Tn0mmZcTYdJzAygesoRyRhCiLzNxGI1jrYtTC0Lz6EzJOduER16DiseRquoS+sRFZGcZTbPBAhBanWW1MoUiu5BLb8jxFus62jOzysyyLS2tuI7fJ7Y+FViE6/gPfQAeo2jiLcMhGUQHXoBkYrjajqCp+VYeo1U1TBjIYzgov07sRJRhGWiKAruA91UeDabZ9xt7Dfa3tiQE825uTkmJiZKTmCy418ikWBwcDDDubPQ4+SKPcUkWFs12pxOSvk0PUpttBUaLwYHBwkFAvCDz6O6y/C09VD3rn9DcnGc5Nwt4rdvEhn8PormQvGWk1wYRfVWpONFazfCSBAdfhF0N2pZDXplPan1eVS3j4ozP8ncS1/hy7OzO260FTvNLATZK7RwxwF0aWmJ9fV1rly5YideNTU1+Hy+u5Z8bZdo7cUkax+7B8lo8/v9DA4O5s3XCoWMAZZlMTY2xurqakGr9xL5YlcoFKK/v7+g89sqfxNCMD09zezsbM4hq/MYxeQ/xcbMj370o3zpyX8Atw8lpXLgw39OanWa5Pwo8dv9+L//eYSw0mZSta2Eb3wXRXPhaTmGp+UYlWffTWzsZfw//Bs8LUexUgko8pzvF7JZv07jnHg8zqVLlza5+90tlsd28U/+Tff673QfpUHmf/F4nMHBQTRNKypfc8KZAwohmJ+fZ2JigmPHjtn3eqHIfo6TySQDAwNF55O5sNWQVeJeMNokVFWj4QO/A5pOcn6YxMxNQq98AysZQ69qpOzYRaID37dfLyyL1PwIqq8KT2s3SmSO27dv35VYsRvD1my4XK4Mx1bLsohEIvj9ftvpPts4524Z3hTKaCulJ3Q3sWcbbfluFsMwuHTpEq2trba9cCmQ3fxC3VSWlpZIzAwQvPoNPG3duBsPo2h6mqUW3bw6peguVFXHd/gsvsNnAUitzrD0D3+I79CpjRdpdpNGGCmM4BKKtwLf4XOk1uburHBuBIV8N1iuoLGjh01VqTz7btQLPw2AlYoTG72C//ufIzLwA5JLE2lDiNbjtv5QPkKaoqqY8XDanVMIUqvTeA+dQRhxzIg/3WRLxlAUhUQisaMJSrFJWyKRAC1tZhHp/x6hl78OQuDaMK4QRpL4xKtolfWge+7o5wkLMxokNfR8+m+kqiTmh0kujIGqU348vbOvaRqhUOiu2CrnQyQS2dHkaB97B/mmdHKt/cKFC3mdkLaDTLKkicbk5GRJ2kbZhWYpCVa+pGd1dZVbt25x6NChLae1ux7/HPjkJz/Jn/6XP8N39AJ6TUvaBEEIVJcXb3sv3vZeqi58kIUv/Xt8B0+hVTakC8/nvgBmCsXlxUrG8LSdwIr4sRzO1cI0CFz+B7TqFqxQ2tVzKyfQ7XCvilbpAKppGh6PhyNHjtg6H2NjY0SjUXw+X4bOx26xMIpZHd3HGw+KojA/P8/S0lJOc5ZiIGNXMBi0tY0uXLhQVOGTHf+cDbuTJ08W1LDL16yLRqP09/dnSJjkw91m9a6srOBuOozqrSI+dQ1F03E3HcHddISKB36C6PCL+F/4Mu7GQwgjn5TA5vO7fPnyXXECvZuQxjnV1dUsLy/z4IMP2iYLs7OzhEIhm/Ur/1Pq93Q2TNPc1177EUE++aRwOMwrr7xSlFRSLsgcMB6Pc/PmTTweT0k5pWTkyhi0sLDA+Ph40flkdv5SyJBVopT4t6N4qSi4alpw1bRQ3vNWzPAai1/8HXydZ+QLQAjit29irM2C7qb8xI+lDQ91HVVV7Q0B6QQqV9N30qS6Fzmgqqq2ycLS0hJnzpyxtS5XVlYYHx8HyHC4L9ZkIR8KZbTt1BV3t7FnG23ZkLpByWSSc+fO7fgXqWka0WiUS5cuFaRtdPz4cZ5+/hKx8asbRghRXHVtmPEwOd+lapsNETQ9c+VJTWu2GYFFYpPXQVHSzDGwd5XMiJ/45KtbXkuxhWZhQenOz1WXl/KeR/A/+9/wHj6LXtNCYuYm0YHvYyUiKLqbxS/+Du7GQxuOrMdxNR0GITD8CxjTN1Dc6dVT37GH0curSS5N2hp0ZmQdTVUYHBwkmUxSXl5uO7sUI0ZbbJBJJpNpgwpVpelDv4/qKSe5PEls+CVi41cRgrQAetsJwv3fQ1E1hGViJWKIZBxv5xlSa7cxw+sklyZxNR5K6+4BwjIp83l33VZ5u+vbX516Y8KyLKamplhdXaWzs5PDhw/v6HiSRXH16lV8Pl/J2kZyYLGTBCu70HSK8J47d25LjTh5LcUmTdsxQIQQdHX3sLS4QM1b/ie8B0+mzy20ghlcznk8vbqZ8r53UHHqx9OabeFVlp78JJ72Ptz1bcQjgfTvPRkjuTiGMBJ4D59H85YTG0onKNlNqqqqqoILz3vNDpH6HE4ND3kect1qcXGRkZEReyVLvq7Ugcr+6uiPDrLvZel+WVFRwblz53Z8r6uqyuDgYNHaRtnHkLEnEAgwMDBAc3NzUQ277NVRp+7wdhpxEneb0aHrOnpdO+UnHyU+lTsfzf5z5ItHwjJJzN0C4MKFC8RiMfx+P3NzcxlNKll47laTarchGcS5TBaSyaTNenM6Fsr4V+pAZbv4l0wm9xtxb1DItXbDMHjzm9+84+GVqqr293N3d7fNWCrlOKZpkkqlGBgYQNO0oht22SZfhQ5ZJfLFs3wxaEffHQW9VRCf6UdR9TRRQ1Htf1cUlba2NntDQBpSra6u2k2qQg2pNn3qfcoBt2L9Li4uEo/HKSsrs+v6Upl8+4y2uwBZDMoC7siRI8RisR1/kRiGweTkJIFAgIsXLxaUYNXW1uKqbqHhA59IHyO0SnToeUL9z0A8xMq3Po334Gk8B7rQ69rSTRkzc7KnaDqIdEFpxsOk1ucAiE1cw32gC1VzY8gibsNlNDb8ElrtAcz1/O502UFGaoNYlkVNTU1pjIJcSZiionkrqb7wQbjwwfRnxaPM/+1vUv3IL2IG5olNvkrkxnc3NOYsUDS8h8+BmSJ++yaqfR7pBqPqq0SvbUOLpDvjQoicYrTOwjPftRQbZPx+P8LQ09e6oUzubuzE3dhJNTD7lx/B3di5cXALK5UgMvBseo30wFFcdQdIrUyCZVF+5jGM1Zm0zp5pYARXWNfL6evrA/LbKhfT8S+EFry/OvXGgyzgGhsbaW9v37bxtB3kOlI0GqW3t9fW4yoF0gzh1VdfRdf1kieistEmreQ7OjoKFuHNfo1cgwgEAvYXe7HnZJomSwtz6PUH8T//BdQrPlRfdVqP0bv9kEdRFPTKhrSjshTLFRZmPExkYEMI1zJR3d6NWKtw6tQpu0nl9/tZWFiwm1Sy8NzqWu5XkpUNRVHw+Xz4fL4Mx0KZeM3NzdkDFae7XyGJ1/7q6I8enGvtPT09rKys7Pg+X1lZIRgM0tDQQF9f346OJ4RgeHiY9fX1Lbci8sGZv8ViMfr7+22n00LztuwcUOrpSBH/7GJtR9eL2LKJFp8ZAEVh/nMfw91yFG/HKdwHuhCWCcLa0ChOS4k4NYGcTapAIMD6+nrJudK9wFZC4G63O6fJgt/vtwcqXq+3oLzWiUIGDXuNzbGPncEpldTT08PNmzd33GSLRCLMzc1RVlZWtL55NhRFYW5uzjYkbGxsLPoYcthQ7JDVeQ7O+JdIJBgbG8Pn81FTU7OJsLETBrAQ2HX85p8JUstTiFQCxVdN2fGHSd7ut3sBVjJOJBLJeE8uJ9BgMIjf72d+fn5TrrTVhtT9WMXPp6VaW1trD4mEELvC+i3GDGYvYU832mKxmE1plWtICwsLthh4KZBuKq2trViWVfAUs7KyEuFY+9Er66l68KcwAkvERi+h+ioJ3/guwUtPgmWBqrH81T/C29aLp6MX94HjKGq6qZNYGCM5P4ziSt8M5T1vRfWUkVqdQQiTxPwIyYVRQOA5eh5XRT1hf2GNNqkN0tjYiNfrzWAUyEKtqqpqmyCjEBu/ire9D61i62mq6i1D1Vz4OnrRet5iO7KasRCLX/wEruYjuKqbSK3OkGbJpc/ViodRXD7Ku3+M+O2bGdoSkpba3t4OYBeecqIt2RHyeuS9UKwDyvz8PLGZebCsnGYIWBZssHyEZZKcHUSva8UI+1Fd6cRVCAs21oSxLLBMIoPPIowkx4+ftQ+1G7bKr1fa7D5Kg2maDA0NEQwG7QJuampqk+tUMZAOeDL52EmTTQjBysoKy8vLPPDAAyUlWJB+5k3TZHBwkHA4vK3T6VZIJpN2IlpXV4ff72dqaiqjWKupqdk20ZLPXvPPfnLDTWqSxPwQ0ZvfJ+lfYP7zv46now/PgW7cB45vcUYbq/+mgRUPIRIRUFQ8B0+RnL21kaQIJIPY2aRyitEGAgGbHWGaJhUVFXb8k5poe6XRlgtbmSwUw/rdTofO6Ti1j9c3JLNrenraLuCCwWBe84FCkEwmGRoaIpVKUVdXR1NT046eGb/fTyQSKcrxORec19rT01N0XJbPv1xdXVtbo729nUgkYq9fOWOGEKJ4Ay1hpQtGIZj/7K/ibjmGp70Xz4FuhGUiTIPIze+nqW2WSd1PfozYyCXCN7+H9fJXEYkY6C5c1c24Wo4Ru/XDnJ8lV9Pl94nMlfx+v82OuFeaaFvBycDZDk6TBchk/S4tLdkmC874l6tYLMZ1fh+vbyiKYg8edyqVJOE0/GtpacHn8+2oyRaPxwmFQrjd7h1JmchrHR0dLWrIKuFkBc/PzzM+Ps7BgwdJpVJMTk4SiUTwer12/NuJiYllmSw9+X/iajiYjn+tJ+w6OTbyEmYslM7xmo/YcUkIQXzqNVJrs9uyrXI1qaQmmsyV3G53ButX/g33quZlLtZvdl5bCOu3UI3KvYY93WiT9sJOSmsue/dCkO2mAmn2RKGoqKjYxFAD0m6cikLdO/71nc9anmL563+Cr+MkViJC8PI/YMaCKKqebtgsjeM7dgErFiQxN4SibwQnRcWM+LEiATytx0ksjKH5qtKJyxb3j2T+jY+Ps7i4yMmTJ/H5fBiGYTMK5E0tC0+ZgMmHNWPiKUyCV/4B/7P/HdXlxd16HG/HyXSiVeCNrPkqUd1ld9w5Ie2HYCSJ3+7HjKyjVzfbPzC3aB54vV5aWloy2BHyAXW6oFiWlf47FRhsmpqbWao7TeTq17BiQbTyO03FtDmDAAGxiVfAMnG3deNpPka4/xkUVcdKxrDid6YTVjKKSEbR69sBZcuAWoqtciGJ3b4ZwhsHk5OTlJeX093dbd/PW1mybwUZH5aXl20HvNXV1e3fmAdS10M2tEptskG6Oby0tERXVxcnTpwoOVGQQ5Suri4aGhpIJpObGtt+v5+hoSFCoRCDg4O21k72xNOZICm6yza7cdW2svbMZ9Hr20nMjxCfeBUQCNMg3P8MVjKOp/U4roZDdvPeioWITL+WlhIQgvK+t6G6fSRnB7ESURIzA1RW5o8VLpdrEztCNulHR0ftJr3X6yWVSt0zy/WdfE4uk4VEIkEwGMxg/ToTr0Kar/uro28crKysEIlEMtbapRh4sRBCsLi4yNjYGEePHqW5uZmbN2+W3LST2r6BQACfz0dnZ2dJx4H0QDkajRIKhUpe4VcUhXA4zPDwME1NTTz00EOkUik7LjuLtcnJSdbX11lfXyccDttbD1s9y7dv3yYxt4ZaUYeiKNS/9zeJjbxEdOgFQq98E5GIgq6j17TiaT1O5MbTeNt68Lb12McIXv82oVf+Ee+h01jJWMHXlitXikaj+P3+TTpHhmFgGMZdE+N2wjTNHcW/Uli/+422Hx0kEgmmpqZ2NHh0Qhr+NTY2cvHiRRYWFkgmSzNsE0IwOzvL1NQUFRUVHD16tOQmm2maRKNRJiYmdnStcrNCVVUuXLhgDxPa29szGtsLCwusr6/bzTbZfCs0ZmiaTtWjHyW1PEH89k2ig8+m60BVRQiL8lPvJDrwrL1iKoTADCxiuctwH+iijMjWH5AFZ67kJJ9kOyFXV1cTj8d3NIi/l8iV18pttomJCbs56mT9Fuq6vNeajXu60fbAAw9s6jw77d0LQT43FcMwikqydF3HjAZIzN7C3XwERU+zqBSXN+3G6YC78RB6eQ3lvW+zzQIsyyIxfZ21p/6M8tM/gaqqJOPhO85LgEjFAYWyk+/EiqTdSO/cLvkbXPF4nOXlZbxer+1wlf07yr6pL126RFNTE4FAwLZNltpoiqrR/KFPgttLYvoGsdErhK//j7SZwdI4sYlXcLd0ofm2K2gEkJ40mLEgIIiOvITqq8LVfBSMDRdXIYpiKOq6vskFJRwOMzk5yfLyMouLiwXpHCWSKQQmiu5m4Qv/DtXtw918DE9HX3plVFGJDj6b3q8XAlf1hsmAsDCjAeLTN9IrvpqL2OSrGOsLaTOLQw8Qm7hW1BeGc4Uin61yIpHAsixmZ2fz6tftF5pvHBw7dmxTjNJ1PW3iUQSc2kHZDnjFTsCcCVZ3dzcVFRXcvHmzqPORkMXq2toatbW1HDx4sKTjGIZBLBZjdnbWZj7n+t5wFmtXr16lvb3djhuRSMSOGbLw3LhiskU5FKD6TT+Hu+EgVipBammc9R/8DYrLS3TkBULXvolIJXDVtWEloiTnhnA1dSKMBMb6Aqp7Iy4IQWz8Kh/4wPv5/F//dcHX62zAHzx40G7SLywsEI/Hefnll++JztFuN/Q8Hk9OJouzoZhIJJienraZLNlJVyQSsSem+3h9o6mpaZM+WSmDhnwOffkck7fD+vo6g4ODtLW1cfz4cV588cWijwGZsdTj8dDb21vycWKxGIODg5w+fTq9fZFDs9dZrMm1KmkuMTw8jKZpGSvqzsKzvr4ea+w24f5nAGw3UYnQa98h+PI/4jt4Mu0omgO6rxJVahWJzXG1UDjZEdk6R7Ozs7z6alpDrlSdo0Kx2/FvK9bv7du3CYfDJBIJNE2joaEhZ1zfb7S9ceDxeDh79uz2L9wGpmkyNja2abVdaqsVC7lpJtdOBwcHS2aIyViq6zqnTp0quckWjUa5ffs2J06csBvXziZidmN7bW2N5eVlqqqqMlbUZbyoqanZYv1QoFfW4et8gKqHPgBAan2epb/7fcq7f2zjJen4m1gcw1ifA3cZZb1vw1yfA6O4RlsuZGuiySb98vIyIyMjGIZhO8EXq3V+v+Bk/XZ0dCCEIJFI4Pf77YZiMpnE5/PZg5XsuL7PaNslFDPRjMViDAwM5HRTKTbIlJeXYyVjrH3nM1iJCHptK972Pozwapr4ZJkb5gbyAzLNEFRVxdtxyv7fwIZ6rIJIJYjdvokRWETxpLVqxMZrzFiQxMwgKCrxeDzjxpJaS9PT01RVVdHV1VXw9aiquomeKrvJoCAATdXxdZ7F15kO9rN/8RHMiB//D/8WKxZK2xW3pdcGQte+hffQA7hbjt0pJBEIM0Vs5BJm1A8CXC3H8B7oIrk4hoVCcnWG1Nos6KXTl51C216vl6ampoJ0jhLJFJpHQwiLAx/5DInpfmJjVwjf+C5W1J/WpKuox3PwFJHr/wSqjhAWwjJJLU3gbu8ltTSOSMYww2totS0g14stc8fud9m2yoFAwF6Dk/p1kkIsGR+RSGTPCUHuozTk0z4oNG6ZpsnIyEjG6qkT2QK02yE7wdJ1nWQyWVKS5ff7GRgYoK2tjVOnTjE6Olr0MeCOaK6u65w5c6bgZEJVVXuw4Jx4Sl2M4eFhAIz1efTa1s0mNhtf6KrLg6etB3fTITyt3ZT3vj39vg0Nz9TqbdztPXiaDqcNbzaKS2FZCGHx6U/9KR/+8IdLunb7fDaa9PX19aRSKbq7u++JzpFlWXeVOZKLyXL58mVcLhfz8/OEQqGMpmNZWdk+o/cNjmLyP2cjK5d2UK6B5FYwDIORkRHC4XDJ5gkSkhEsh6OXL18u6TjSmVQIwZkzZwrOOVRVxeVy0djYaA/2csUMZ27hO3yOijM/yeKXf3fT8TRvBaq6XTzZWKMXFsnlqU3mCTuBlOaYmpriwQcf3KRzlEgkMgrP3XCCv9vM4Vys31deeWVTc0CyfsvKyvYHrW8gbHV/Fjog/f/Ze+/oSPL7uvdT1bkbg5wGYQBMwgCDweTZXaZd5iTTNE3Tzwx+lHRMU5RFWjQpmTqUbNP2od9TOiTFR8mWRIq2xGQuZVGkuAzL5SZunN0d5DBIg5w6oHNXeH8UfjXVjc7AzGCHuOfs2TMI1VWNqm9/w/3ea109zVxtL3VoIdbbRUNL1CW5XJPzwZqbnjt3jvHx8bKaJIqiMDo6SjAYpKury2yyFYIkSciyvGOwl6mNJmJGdXW1ucooZRkQSA4nUkYsiN8YBk1B9lYiOz1GzwH95rBhDyGa9B6Ph76+Pmw2WxqD2coOK1u3/TZDkqQd22zCLCIajZpxXbB+xTXtN302eBk22ooJDlbXplxuKplOT/mgKAqpVArZ6eHwBz+HEg0QHXuS+OyLqIFlkGUiAz/G1dZrGCFIMpLNvtN1dNtlVIjaa9EQ6DrRsSeQnB5c7X2k1ma3f9jQ7olPXcVecxglEUlrtFlFc/v7+5mZmSnqWnLBqo1mvHSWwGmz4e46R839H0RTUsSnnzfcOTWV2OxLxK4/h5YIY6uoxdV2Gi0RI3FjENlbhbOlm+TiOM5aI2HQdVBCa+gb88guHy7b7jvR4sOnWJ2jjc1N1Jp6JMmGLNvxdJ4z7ZnVaJDl//kJPJ1nxcHRdZXY2JOg6bi7LuCoaSa1PAmSDW/vA4bopWxDS0RRo0aw3ktomobH46G9vZ329nbgJoV4fX2dj33sY0xNTfGpT32KV73qVbzzne/cE8r5AfYPii00RQOqvb09bfXUChFLC33gWuPpqVOn0vSDSk2yNE1jcnKSQCDA2bNn8fl8xGKxshK18fFxIpEIFy9e5OrVq7sqnLLFjPrGw6x/57+i6xqOxmPG+rymkHePfxtCwzMy8OObzF8JkCS0eITY1HO4nE4+8IEPlH3OmbAm36XoHAm9vlKLxtu1omqFLMscPnw4K+v3s5/9LA899BDXrl1jaWmJd7zjHebPHeDlh2zPc7HxJhqNMjQ0ZJoKZGsIl8Jo29jYYGxsjPb29qzr7cUWvrqus7i4yMzMDN3d3eaGQamwxuTe3l6mp6d33TjKFjNE4RkOh4HtQXXW8CeaaDrJ1WmQJFa+9juGC33rKZzNx42kT9OIjj2J1w7ff/gnuzrffNiNzlGxuBPxT9d1GhsbzXO1ygh84xvf4Atf+AIej4empibe+ta3cubMmdt6fgfYW2TTkhU5YD6WutVUINdQoJRGW754WmoOaB2yity0nGbd5uYmIyMjdHZ2ZmW3l4rMmKFpmhkzxCqjx+NBL5D/pQLLhp67y4vv9GtIzA2ag1ldSZJIlraRUgrE55Asy2Y9L9hh2ZzgrdJEpere3wn2mK7rVFdXmz0dK+v32rVrfOxjHyMSifDpT3+aBx54gDe84Q23/RyzYV832rIlDoUKzUgkwtDQEJWVlbt2U4GbCVZTU5PZOLN7q6k8/zYqz7+N8ODDBJ/4G8JDjxB67v+gayrOxmNoiSjhlx5Ci4VwtpzEXlFnXH1c7WEAACAASURBVI8kG9psNwbR4mEAHA2duFtPoWytm2uJsemrxkplaw+uxk62/EvEYjGqqqrMRE1MFSKRSMk3fcGfz/J9619DtjvwnrgX74l7Wfryb9D4zt/BVlGDlowTm3ya2PRVdDWFrbYFb+c5kutzmS+AriTx9d5PYmkMPREo6fxzXVOuZDPbPngsGiW68nhWIwRdTZkMRX276RgdeQybtxp0DZu30vye5DbEeHVNRUvGiIw8BrpGf3//rq/JimxNESuF+B/+4R94xStewXve8x6efPLJfUujPUD5KJQcpVIpxsbGSCQSBV2bikm0rAnWlStXdhSspSRIYoX18OHDXL582XxWS3WAEolaW1tb2Zpuxbzm1OQYAC+88AJvesvbiGytoSUMN+XEjUFklxfbofoiXt9gcWjxCGgKkbEnsFfWU1/h3NOVznzxL5/OkVhLEnR8UXgWYqvd7kIzW/yzsn7/6I/+iA9/+MO87W1vM4cPB422uwuFnjVd15mZmWFpaYmenp4dq6dWFBP/rAVrLv2gYpnBiUSCoaEhnE5n2VpsYAzXBgcH0xwDS42hxfy8tfCsqqpC3wgbBl6awvJf/zau9tO4W3tumsFoGtGxJwwtY01D9tUQn3nB+JqSRLIZ2wMX+s/y4x//cM/ZsPmupxSdo3xmBFbciUZb5mtai+UPfehDeL1e5ubmaGlpYXZ29qDRdhdCxK1cucPa2hrj4+N0dnbmNRUolrQyNzfHwsJCznhabMNO0zQmJiYIBoPmkFWglPgl2HBbW1tmjjs3N7fn8S9bsyoWiyEB69/9fVwtPYbMUPMJU0oqNvMSSnAZHC7crT2GSR6GkUx8fgRlfZZf+XcfL/o8S0WuHDCbJqQYUoocsBgzgmJe61YiUxczk/X74IMP8slPfpIrV64wOTl50GgrF7keaqubSm9vL1VVVVl+u3hkJliBQABd29ngk+wOJLuLhnf8FraKGpIbN4iNPk54fQ49lSD0zBJqNGiaCgDExp7EVlmP60g/iflhHLXbmjKSjK4kiY49ia2yATW0js1Xbb6WEHJ0OBxpidpurIqzQrKx/L8+ibOh05hItpzE2XjU+F6Bl5Gdbny99+PrvZ+l//nvcFRbqbzG1DO1uUhyeRLboQZkp9vQfitTlNOKUhIfWZY5VFmN3nUf0ZGf7fwBVTEntInFMZBknIdP4Go6xtbV74PNbmiRaCr69jqEloyiRUM423pRN2/s+h7ccUpFOK7YbDZe85rXcP/99+/pax/g9qPUQcPKygqTk5N0dXVx+PDhgh+C+RKkYhIsKI4ZbHXCy7fCWgiCDef3+4ta3cp3/aUkCOfPn8fp8SLXnzB1KuNzA2y98D0jLjQfRwmsoMVCyC4fzsMnsXnFs6+jJWMkRobQUnGwu/CeuIIaCWCTw0WfQzEoJfHJp3O0sbFhUvTz6Rzth0ZbJqLRKBcvXuTUqVO36awOsF+wtbXF0NAQdXV13HvvvQXvzUIF4vr6OmNjY3R0dOQtWAs12qw6wdlWWIuF9TjW1S24BTlgBsLhMKm1GZIrUzS9978RvzFIbPoF/BNfQVeTSJKMDrhauqm6//9m9W8+haupC5q6CA/8GDSF9rYWPvGJT/DBD37wlpxjqYVfLp2jQCDAwsKCabKVS+foTjTaIP9nVzgcprOzk/e///238YwOcDuRKwfMNPwr1CguxOgtlrRSTP4WDAYZGhqipaUlbchayjGsx7Gy4aD0+FdOvBQSHSsLczz00EN8+9vf5v98/38TTCW3N550dCVB03v/H9a+/Zmbv6hrKIElqmvr+dHTT9Hd3V3S65aCUmJgpjSR0DoPBAJMTU0RjUbxeDym3FKmYc6diH+qquYd0ITDYerq6njHO95xG8+qMF52jbZsYuCZbiq7/eNnS7AkSQJVRUtEkF2WTrzNgSTLpiOps64d5yv/BangCt7j9+A9eZ9hhHBjgNjk0yBJJktNCa4aB7E88Lqm4jn5CmSbncjWY0jo2w6YhoHBW9/6VtNJzzyHLEFjV51mXaf+7R8nfmOA2MwLRAZ+jJaMGk2lVLz4h9l6Trrh4BmfvYYa8WPzViO7feb3PLvQO7n5EqUlWilVQUvE0JIxlr76cVytPcZ/zccN9qIkER170rh2XcfVdGz7fdZRoyHi26xDSbYRHfu54Vxa24qrsZPI+uyei9IWu+a330UvD1A+shWHiUSCkZERJElKE/su5ljZkhuRYFVVVe2aFSxic3Nz8w6NEIFikqytrS0GBwfzHqdUlJJo/fbHP8b//OuvMTExgb3pGA3v+C3D5CW0SmJhlOCz3yGxOE5qYx4tEUV2+3C1nDJWBWav4eo8hw5oW2vYPJWoYf8OTY/dQkgSlAuhc2R1as2lc1RdXb0r171yUEz8C4fDBxqVdwmKvZdFI39jY4PTp08XrVFls9lIpXY6yVtZwRcvXiwopJ+vYE0kEgwPD2O323foBGci32d3MplkeHjYdNTLPM6tLjQ/+clPEvjd32Xyqb9mMxjA7qvG2XqKlCRR88aPQCqBpmtUdL8CNRo0hpSaSmJ+GF1J8Ru/8Rv8h//wH0peTyoFu41/mWYE1tWxbDpHiqLckUZbPoTDYZOxd4CXP7I9p5k5YC7Dv0LINWjQdZ3Z2VkWFxfp7e01WfC5kC9/sw5Z+/v7c9ZEhQa2mqYxNTXFxsbGDjYcGO9TuYYMpcJut/P2t7+dt7/97bzyVa9mWm7B1XmO5OIYlRf/0c1zApLrcyjBFU739fGjH/5w17rdhbCb+s9qRiCOFYvFCAaDOwxzhG7nnWi0FXJd3o8alfu60VZIDDyXm0opsN6YIsFKJpM7Eiy32w12J0tf+ZghkN92GndbD3oyZjDR1PSETbI5zK/Jsoyn4yyejrMszr50k+0gycY6pqahBFaIzb4IkozdV2WsKAFqPGyKaHd1de1oson3qZzufO5vgr26iarWUwhehhINsfJX/5b4zAss/cVHcDafwN1+2lwbUGMhbBXZWC8SKf8SiYUR0DW0ZAxf7wOkNm5ss8BiqBE/yT3QZSw1yKiKiuRwInuqqHrFe4hdf46t5/6OYDyErmlIkgyyDW/3Kw33UTC16+LXn8PZdJTk8gR6eAPJV4PkOYTNuX3PaOqeF3yFuvm3u/A9wO2HdZpp1fs5ceJE1tiQD5mGMNa1q2ISrHwQidH6+nrB2PyHf/iHPPjgd/jN3/y3vOtd70orxnRdZ3p6mpWVFfr6+vbsQ7TUZOSjH/0oH/3oR/nMZz7DF772PfMY9qom7FVNJBZGSG3O4+k8R2J9nuTKpBGPnB6q7/8g3pP3sfHQn6AjoasKSnCFhG9vnUB1Xd/T5z+fztHs7CwbGxtsbW1RV1dXts5RKSi20bYfE60D7C3EZ71YIz98+DBXrlwp6f632WzE4/G0r4m1q2JZwZDbWGt5eZnr168XFZtFDpft9VZXV5mYmMhbRJeiOWx9vWLx6le/mkcfeQQwVi4ffPBB/u7vvsuPZiUCP/4Skt2Fs6UbSUlgrzLOMTryGDWVPv74r75Cf38/Q0NDpFIpcz2purradD7dC+x1/Cukc7SxsQEYTLhydY72GpFI5MB19C6HNQcUpirZDP8KIVujLRwOMzQ0RE1NTVGsYMjdaCtmyCqQr1EWDocZHBykoaGBy5cvZz2n28Foy4bjx48z9PffJzL4E5yNRwlJMq6Wk6DrJBZHkdUU//H3fpd3v/vdTE9PE41G8Xq9JkusoqJiz2u2vYqngsHn9Xp3aJ1bhw+jo6NmPN8Lk618KKbRth/j375utGWDCDL53FSKhUhOJEkqLsHSFJre/wckZl8iOvU8gSe+jhYLITlcpNbnsFc1mXpfkt2x0wwB4Vi3Hdw0FR2N+I1BtEQER/0RlMCy+EEAEnOD2GtaUJSVnA9kqUkWFKPRlv5Pu7cSye7Ec+IevKdeTXT8SSKjjxF6/u/QFYW17/xXcz3W3d6Hs9lYs0ouT6LFt7BV1KJubeI9eS+yw1gX1eIRIsOPAjoOTwXJZHJXiUqpjbZYPI4eCSDbnQb78Pg95nEiI48RfOJvqDh5r9n01JWUoZ0n2/Acvwebr4rk8gSStwpf9yuIjD4ONjvK1gZaKlGSo1kxUFU1Lx38IMm6u5CP/SUcQD0eT9l6P9ZEq5wEKxcE+6ypqSlv8RsIBHjz297OtYEhXK2n+NVf/7d88Fd+lcrqWi6d6+dNb3oj9913H7W1tXvCVM5EOYmWEWuzJISScBNV0UIrkIobzfbL78RRf8R4LR1Dw3H4ZzQ11PEnn/8czzzzzJ4VnreazZqpczQ8PExzczOpVKpsnaNSUEyjLRaL7coN8gD7C7nEwOPxODMzM4TD4awMh2JgjX+pVIqRkRFUVS1q7cqKzELTyj4rlmGcLYdTFIWRkREURSl4nFu9OmqF2+3mve99L+9973sBY6jyk5/8hG9/+9v87InHDRMoXePd7/wl/uQLX2BsbIyjR4+aPyvWk65fv76nheftiH9WnaPFxUVzvTSbztGtaCQWwsGg4e6HzWZDURTm5uZ2OICWAuuAYDfSS5mDhlKGrNZjZDbaxOB3eXmZ06dP5yUu5NrqyvfM7EW8/KuvfBmAa9eu8bWvfY2f/PRnTD30Q7RYiKPHj/PIww8zMTHBkSNHzNeMRqMEg0Hm5+dNbVwR/6qqqva1G6hV6zwajXL9+nUOHz5MIBBgYmLCzL9uVSOxmEbbftxoeNk12nRdZ2NjI6+bSrEQE83JycmiEixJtiFJsqlBBhC/McjGD75I4PH/hf+nf4mjoQN3ex9aIkpqdRolsIytqunmh61suJEmVqdJLowCErpNxdf7AGgqin/J+P7iKACOxi7cracID/yYZB4ds71MsiQkdHIUk7qOq/k4rubj5pcX/uLf0PDOf4+6tU5s8hm2XvwBWvQb6Kk4OAzNNiW4ghreRFgq6OiowWVcbX0oW2tIxNMmnuJBLSVRKXl1NBFDmX4ee9XOVVxHVQOy3ZgO6ZoKSESGHwG7EzQNe0WNuV5qP1Rn/pwaXCW5NGGIX8bjPPfcc3l1jkpBoSCztbV1y6nJB7jzSCaTvPDCCzscQEuFSNimpqb2RNtS0zSmp6dZW1sryD770z/9U/7db38Ke30nDe/4LWS3kYxp8TCJxVEe/tl3ePinP2VsdISOjo6yzykXyi1MNU0juXyd9e//Me4j/bgOn8QunJSTcaLDj3KowsN9b3ojdrudZ1/4KWs//6bRnJNk9GScD33oX/EHf/AH5vFE4Tk5OZmWqJTqBnq718Y1TcPtdlNbW1uUzlF1dXVBgd18KHZ1/oDVe3dDVVWef/55Ojo6yjZDgZsFomCMHT16lObm5pKPZy0ShU5mKStccJPRIe5v4RpdLLOu1NWpvWzMybLMG9/4Rt74xjeaX4vH47jd7h0yL9nWk3IVnqWyZO9E/MuncyQaifl0jkp9vUK/u18ZHQcoD9nuZ03TGB8fN6WSyjUVEYMGoW1ZX19f1kDTuoJf7JA1E5nxKBqNMjg4aMqXFDpOOYy2vUR/f3+a+Z2If9leV2jjtrQY2uxCG3d9fd3UxhX50n5gyeaC+LwStS2kx/OFhQW2trZMky3x325McAptbYXD4X1ZA+/rRlvmw7C2tsbo6Cg2m42LFy/u+mFJpVI8//zzHD9+vKgEy9BiS292SQ43stNFzes/hL2ygcjoY8TnBkj5F5Ekidj1Z0G24Tx8EveRM6CpxOeGQFdxtnSTXL6Ou60H2elGS0TRNZXI0CNgs4GmmmumkiTtWHMQyJwGCF2QWCxmJixVVVVF04p1XSP4xNfxdJ43hL0P1eV9b2RJwuby4axrw9N5zvz6wpc/hqe1G9mZ7tSlpRKowVVslQ04G46ghFZJJhOcP3++YOFZUVGR81xKTbScLi/OY/0kVyZ3HktV0LePqQSXAR17bSvOxi4iw4Z5gq4kAQlJsqErKfRUEjURw3PiHmKTT3PPPffQ1dWVV+coU2A3HwoVmpFI5GCaeRdDsM40TdsTR2Vh+NLS0rJrxpiV3l9MgvXbn/491GQCbW2WzZ/8dxwNnXi6LqGrSUJXv4fs9KLFgjzyyCO8733vK+nDWZgmrK6uUllZacaO3TS5BX7v936P+++/n29961s88tiTLDzzIJqqGAOUZIx/+S8/wOc//3nz+ldWVojH42xubvKnf/qn/JN/8k94y1veYh7PWngeOXIkLVERbqBOpzPNDTSf6PrtLjQz/875dI6mp6d36BwdOnSo6Pu4GDOYA33KuxfJZJKxsTHi8Tj9/f1lsTis0DSNtbU1EolESdqWmbDZbCSTSV566SV0XS/rWILRpqoq4+PjRCKRovThBDILzaWlJaampnY07W/X81HKeecqPAVLVpIkM47nKzzvRPzL5sKdS+docXGRcDicVpyWkpcXM2g4yAHvXgjW2dLSEocPH961qL6u66YTcinalpkQA4vr168XNWTNdQxN09B1nfn5eW7cuFHQNdqKzPgnHO6tbuuVlZVp+cqtZACXkmtmauMqikIwGDRzQFVV01iyt3o9s1hky/+yxfNkMkkwGGRzc5OZmRk0TTPJJ6Xm5YUGqeFweM9NCPcC+7rRJmB1Uzl79izj4+O7utHE8ZLJJGfPni3+YZaNhkra12wOQAI1hb2ygaor74Ir7yL49LeRZBsVF99Banmc6NjPCQ/8CC0VR7K58Pa8Fj0RIbk8efOBl2SDLdV4BNfhE4RffAgwmFK6prG4uJj9vCzvhZjOHjt2DK/Xm6apo2ma+eGel1K77ZQXeu7/oEUDYHOYwt5Z16ZyQJYlBIPNMEPQUUNrxOeHAAlHlZj46ubDkavwFNT8fIVnqS4omqaih9dR/Ets/vjPcLWdxnX4BLbKRlNfLzb1HOqWwcRzt/WixcMgSagRP9Hrz4EOupIwmm9aCmfHOewVNaBpVFdXF9Q5ikQiRRfSL9f99AOUB/FcC6bY6uoqvb29DA0N7arJJqj9KysrtLS0cPz48cK/lAMiWRsYGChI77fC6fLge/UvY/PVkFwaIz57Df9P/we6Ds76I7haTrL14g/41x/9OB/+yK/jO1TJZ37v03zkIx/Jey6RSISBgQGampo4d+4csVgMv99viptXVFSYQv7liufef//9aa6+w8PDfOlLX+LNb34zv/RLv5T1d86fP8+f/dmfFTx2rsIzEAikFZ7WQk0Unre70CxGE7KQztHExASyLGe9nmyvd2AG84sFUUAJvTOxgribqTgY+mkTExO4XC7OnTtX+BfyQOgkdXd309zcXPgXskDozU1OTtLW1lYyU0+8T9a11bNnz5JKpdJyDbfbTXV1NYlEYt+uWOcqPEUOmKvw3A+DhkwU0jkSeXkxhXQx8W9ra2tfrk4dYHcIhUIMDw9TX1/P8ePHs5q4lHq8oaEhgJK1LTORSCS4ceMG7e3tZR9LlmUSiQRXr17F4/Fw5cqVkmK8eP5Frry+vs6pU6eQZTkt1xCNN5fLddvME0qF3W7fwZLd2tpKW8/0+Xxp65l3Iucptt52Op00NDSYbtvCZCsYDJp5eea6abnXEw6HaW9vL+t3byX2daNNiH1b3VRUVd2V9pVI2I4fP44syyUVrJqmsvad/4Kr5ZShQ9ZyaluTTc/agNNTcWRZxtVyClfLKQBWvvFpZG+10cEXN5OmoaXixGdfBEnC3Xpqu6GloyUiRIZ/hq4qOW8+SZJQVZXBwUFSqRSXLl0CjA900bTq7OxMY4vF43FTH8jK+JAkCVm2U3P/B7FX1huOqfNDhmOqrpOYfYnA43+Nq7XHYLu58zR2dB0kg/mV8i+BrhO/MYjz8En0VMJgCOo6eipBKkdQtRaera3GilauwjMWi5V0b2iahuQ6hOyrRlcVtq5+l2AkALINm68GVAUtGcPdeY743IBxSZoGOkQnnsZe3YwSWDH0+Ro6UTYXsDlcpjNpNjH5TJ0jwCw8C+kcHTTafvEgJnONjY0m62w3RYVIsBobGzl27NiuYqlg2EmSxKVLl0oS4rXbbKBrOBs6cDZ0UNH/JuKz19j86Z8bYrIASNS86n2EX/wHwoFlvve97+VttFn1PHw+H/F4HK/Xi8fjMT98RdNeNOREwlKILZsPvb29fOELX8j6vb0o/lwuF01NTWnrmdkKT13Xcbvdt63gLMfePVPnCIzPKcH6zadzVCj+FVOIHuDlBdHEstlsJlMsGAyWHbcE299ms9Hf32+u6pQDoesWiUQ4ceJE2U02TdNMvZty9eZEo250dJSjR4/S2NhIIpFAlmWamprMjY1kMmnmTqurq6yurpa1plnque0GxRaeXq8XRVH2dfyDdJ0jcZzM68mmc3TAaPvFg1gT9fv9JutsdXU153ZTMccTDs19fX0MDAzsapV5ZmaGhYUFamtrOXbsWFnHAaNBvLm5SV9fn/lclAIR25599lnq6uq4cOECiqKgqip1dXXU19cjyzLJZJKtrS3W1tbw+/0899xzZp5RXV1dUg5bLHbLnLMOIsXxRB47NzdnkjWEE/LtyoPKjX+5yCfWLQ6rbl1lZWXRTdf9qlO+rxttYuXG6qaSz0o4H6wJlkjYNjY2srpF5YLD6cZ95s2kNucJX/sR6rb2jmRzoKXSA59kd6LFQjuOIdkcoG2/piSDrqMEV4jPDSC7fTeNEraZYMnFMRx1R1DCGzkfnkAgQDgc5siRIzQ3N5sPttPpNLv84j2rqKjA5/OxtrbGhQsXzAd2YmLCLEwNGD8vyzKeI2fwHDnDwuQzyL5aUpsLxKevokZD2LyV6JrCxj98DnfnOVwt3TgajyI7tptDkSCx6RdMsXDvifuw+aqIzw+jqwrR8SfRYmHsh4oPrrkKz/X1dSYmJgDSdN5yTwgVbNEgjqom6t7868ZVaxqp5UmCzzyIHlrnUM9rUEJrhjydqpBYGgPAc/QSksOFEljB3ngUT1sPWxvzYLOTXLluuMcWGRzcbjdut7ugzlEkEiGRSOTUrdva2jpIsu4i6LrO3NzcDkFZoa1WSlJgtVkXx1teXs6r+5jvvERTq7e3l/Hx8ZKTCUMfRMn8otGcF5Ak/D/9S2RvJfbqwzmvNx6PE41GicfjXL58GTCuV8Q/VVWNhv52I6q5uZlgMMiRI0ew2+1pbFmXy5XGLt2Pel+5Cs/Z2Vm2trZYXV29LRPPchOtTBSrc6TrOpWVlTlf92DQcPdhbm6OtrY2cxoO2d3yCkHXdZaWlpienjZdQBOJRMnHERDmWUePHsXj8ZRd2AhNI1mW6evrK6vJpqqq6YB58eJF7Ha7qR9mzf/EqmNdXR2KYgxu6+rqzMJTDC1F3Kiurt41c/BWrGdlKzwjkQirq6vEYjGeffZZM46LQu1WFJ57Ff9yFdKZunVut5tUKoWiKDn/LvF4HI/Hk/V7B3j5YWVlBafTmWb4J/K/UiGGtsIFdLdSIUNDQ9TW1tLT08Pa2lpZxxEM3FgsRmdnZ1lNNl3XWV9fZ3l5mQsXLnDo0CFTP8xut5v5n2hAWRltJ0+eZGtrK21Ns9y1xtuFbOQTQdZQFIWrV6+aMaVU2ahSsFfxz0o+sZJpMnXrKisrURSFRCKRU0t/v5rB7OtGm9frpa+vL+1rpRYM2RIsgVITNrvdjrOhg0PnbmrsxGZeYvOHXyTws6+wdfW7uNv7cbX1GML4sRC6phpOowKyHTQVNR4mPvU8YDTaXG29OGpbCb/0ELquk9pcACSobMLdcYboyGM7phhCi8jv9+PxeDh8+LDB0pKknCKaiqIwPT1tFqEejwe3223e4LFYbPuN23n9kmzHUX+E2tf9qnE8JUns+rMEHvkK8qFa4rPXiAw+jJaMYq9qQktESS6N4zx8AslmJ7Ewiuy6ua6QWp3G5qtB9u0uoRPJ4+LiIsePH8flcpkTwvHx8TRqqlWrRFOSqEtjuNpP3/zzyIY9s+/kfYSCy+KNM5K54Z+hoxtNtMp61EggzQwBXSNxY8hYL91FgplL52hwcJD5+XnGx8ez6hzt1yBzgPIgSRL9/f07ihURt4r98MxMsERsyHSLKgbiPqypqTEZduUMPxLxKOrCKO7OC8jbz74k2w0jFjVFfHYANA1bfSve9jPEF0ayrksILSK3283Ro0dNNoM1AbCulos1tEgkgt1ux+Fw0NDQQGNjoznxDAQCO1YNRONtt4XnrYBIqmpqarDb7TQ3N5sTQjHxtDYQS9FFy4dbZTyQS+docnKSYDDI888/n1Xn6KDRdvehu7t7R4wSzvPFIh6PMzw8jMPhSBvaltOwS6VSjI2NkUwmTfOs6enpkuOfdVjR19fH9PR0Sb8vEAwGGRoawul00trais1mM2OgtTCHm/EvGAyytLTE0aNHsdvt1NTUUFtbiyRJKIpi5k6zs7Nmc1vEwP0ozC0KNSFj0NPTQzweJxAIsLq6yuTk5C0pPK3mFXuJXDpHoun20ksv5dQ5OjCDubvQ0tKyI9aJ5lGxUFWVyclJAoFAVhfQUhigmUPWqqoqAoFAWeQXMawQq7DlDD0SiQSDg4MANDc3U1FRYdbA4jmwPg+aphGLxZienqaqqsrUf6ysrKSjowNd180h3+joKMlk0pQb2WsX4b2EIGvMzc1x+fJlcz09GAya6+l73UDcq0ZbNuSSD1hdXTVlv6zDZFHT79caeP9VDXuIXAmWgM1mKzpAKIpiCNYq6QwQ1+HjSLLMoYvvRHK4iU1f3WZ7BZDsDhb//NdwNnbhOnIGV8spJFlGCa6QXLmO7VA9xCM423pw1ht6ZOg6sannUcMbgI592wwBSUpzcBLi442NjVy8eJEnnniCsbExk5KZLZGIxWLmnv+FCxdMloeV8WF0inWSy5PInkPpRgYSaQ0k2e7E1/1KQk98nZpXf8BYtwTU2BbR8ScI/fxbONv7cDUcIblyc0VD13X0ZAzZV4335L1EJ54iHA4Xl7iBCQAAIABJREFU9XfIB2uRLQowETxF4Sm0SlwuF5Jsx9V+BrLozunazQ83NRYyjCmqG3HUthCffWn7Z4wPBkm2oca2QNfQlCTek68gNvb4rq9HQOgc2e12Tp8+bRpjWLUHHn/8cZ566ilaW1tZX18vazJ0gJcHii00rQlWf3//DrZEKYWmruvMzs6yuLjI6dOn0wRHS2m0RaNR3vzWtxHe2kKKXyU6+hiypxJHbSv22lY0TSE89AiS3QmyjLNyW8dRktMabalUiuHhYSRJ4vLlywwMDDA6OkptbS01NTVZp/qapjE6OmoKlouiVLA9hOZYbW3tjlWDjY2NHY5Qxawa3E7dIGuBnTkhFIVnpi7arZx47hWEzpHH46G+vp6ampodOkezs7N885vfJBwOMzU1RVdX175MiA+wexQbt4T0yMzMDCdPnkxjxUHpg4b19XXGxsZ2OIGWOmiIRqMMDAzsalhh1SLq7+9nbW2N2dlZYrEYtbW1WRvOkiQxNzfH6uoq/f39ZowUepWicBK5kzgnUXgKdn02uZFcuJWC49leS5yLYC5b19P3uvAsRqNyr+B0Os0C8ujRozt0jqLRKJ/73OfQNI0XX3yR/v7+gzX6uwDZnq1SGG2BQIDh4WFaWlrShqwC4hkv5l7JNmS1HqNYKIpiNrHEsGJhYaHkWCEcnk+cOIHD4WBgYMAkKeRisW5sbJiu0A0NDWlsX3ENYg09U27k+vXrxGIx00V4N3IjtxqZ6+nCXTYQCJi6aD6fryxTPoHbKdVht9uprKzE6/Vy7tw5syEaDAaZmZkhGo3yta99jbm5OUZGRujt7d1XzN593Wgr9wa2Jljd3d05mw7FJmzCat1ut2fXYtM0kGQq+l5HRd/rAAgP/4zY5DNUv/p9REcfIzb5LOEXf4CeiIAs4zl2CZuvmvC1Hwu7gJvi58kYvtOvJTLwEyRJQ1cVNCXJ5OSkuU62uLhIb2+v2cG/5557CIVC+P3+NOMDERDW19eZn5+np6fHLJJzTTw1VSXw5NfRH/lL7JUNhklAWy9ohm5cIdg8hzh09i2Er34fm9ta3OsGW2X6KmrEj7OhS3zZZG/tBrmK2lyFp1jb1RNRIkM/xXn4JPaaw0iSjL691habeQklsASyHU/nWZTACkgyaiRAbPoqaBpKaJ3UmjGR9vW8BpIxpFuQgFmnlZk6R0ePHmV+fp7l5WXe85738P73v59f+ZVf2fNzOMDtRTbb8mLilt/vZ2RkJGeCVexxYKfVeuaHa7EDi+9+97u871/+MhxqpP4ffQKbtxo1tkVqbZr4/DCRl34Akg1n01FcLScJD/wEfTsm6YkY09MzwM14LLSINE2jr6+PSCSC3+9ndHSUeDxuFoQ1NTWmY2FHR4cpSm09f7DEv+3/W1cNampqTJ2w/bpqkK+pl6vwtApy75fryAVrYpeZSJ4+fZpAIMDXvvY1Pv7xj9Pa2soXv/jFO3m6B7hFsNvtaUPHbBDabm63m3vuuScrE7XYJomiKKbbaTYn0GIbdrquc+PGDebn5+nt7U3TcBWuo8VANOrq6uq4dOkSmqbR2tpKbW0tgUCAmZkZwuEwbrc7bfA6MjJCZWUlly5dSrv2TMaHGLxa5UYqKipMcyoxtBRyI9mYBVbc7kFDNhRbeOa7jkzcSkZHNqiqat7HmTpHmqbxiU98gl/7tV/jj//4j5mamuLRRx89YLfdhSiG0aaqKhMTE4RCIc6dO5fT+ETkgIXcvHMNWaG0Rtvm5iYjIyN0dnbS0tJS1rBCURRGRkZQFIVLly6ZA9OLFy8SCARYXl5mfHw8LXerqKhgamqKRCLBxYsXTWauGHIIZGu8idxJsEvF0NK6LSDq7EOHDmV14rzTsG5mQLopn2hUFbqOTNzu+GdtCEuSZJpsCa3z+vp6PvKRj/Dwww/zhS98ga985Sv09PTctvPLh33daIPshaYkSTn/yMUkWAKFCk1FURgfHycajXLx4kVikTDK098iuT5rmAE0HUOyO0BVQE1vwMlON5Is46hpoeq+f07VfcbX1/7+D1HDfuyVDQYjStfNYjK5OgWShPfkfcg2O0gSWjxMZOgRdDWFz+fj+eefp6KiIk2LSJKkHTo3YuK1vr7O6OgoYNyIQjgx2yRSvJ82u5O6d34Km6eK6MTPDZbezAvoahIlsExyZQpH/ZFtI4h8uPl305Ix0HUio48hO73YqpuRHMItb2/cX8R7UQwM0XANyeVDi21ta+59yxBobz6Grmto0RC6ksLZdGx7ldc4V11ViE48td0oCJFancJ95Azx2WtG0q2rtz241tXVUVtby5ve9Cbe/e5339bXPsDtRT5Gm0iwtra28iZYUDj+WQvDfFbrxSRJgUCAf/bP/y8kmxObkiQy9iTeo5exVzWg+WpJrkwhOT3oqnLTDEGW0ZLRbR3HLbyNJ0zx8QsXLuBwOExWgd1uN5kYnZ2d5sRrc3OTF198kUQiQXV1NalUiq2trayTSDP+WRpv4j0ViVepqwZ3itFRCLei8LzVyFcQiNXhK1eu8PnPf/42n9kBbhWy3XN2u51oNJr153VdZ35+nrm5OU6dOmXmQ+VCNPUzC0MrZFku6AIYj8cZHBzE5/NlHVaInDYfxLXduHGDnp4eU69QsPitJkvC3dfv9zMxMUEwGKSiogKbzUYwGMzJ+Cim8BTsUqvciLVgE86me6HxVgpKiX97UXjeiUZbrvgnXGZ9Ph9f/epXb9s5HeD2oxCjbXNzk9HRUdra2uju7s77TBTKAQsNWcUxCsUuVVUZHx8nHA5z4cKFHWyjYgcNfr+f4eFhOjs7aWpqMjexJEnaMUwUMiCLi4usrq6a64jBYDDnNkK2+GfdetB1HafTSWNjI01NTWlyI0tLS2kNPpE73S6UkmtmmvJZ3eCt12HdesiM5ULz83ZBUZS8DeGjR4+iKAqf//zn952EyL5vtGWDCA7WB6KcBCvfJFIEqyNHjtDT04MkSdQ3NLCmekksjBIdeQwtEcZefRjQ0TJWSiWbw2RFpZ2704sm+bd/SDZ+Nx4mOvYEWiIKuo4kGlSShOpfwtF0DC1qrAl2dnZSU1OzYw8913u0vr7O6dOnTdFbK+OjoqLCnIp5vV4zIIu4LLu9VJx5PRVnXg/Awn//EEpwhfXv/RG6ksBR34G7vQ9d14hdfxZ3x1lslY3mcYwgqBGdeh41ZIhlOhu6cLWcJD47YGhqLI6jRYMkk7u3mi9Vn0LXNPT4Fp6u81S/+v0AJFeniY7/nOjk0yDb8fbej7IxB9sst9TGDdA1PF0X0TUFde4a7u5XYnO6QTL0pRLzI2ja7SuwBSKRyIG1+y8AciVHpSRY+Y4DRoI1NDTEoUOHciZYAvniqNCRDAQCANS++ddJrk6RmLvG+tjjSDYnupLAXtuGs7GT6NiTwM2kIbkwgu1QPY6m46QUBa/Xy4kTJ8wES7iwZkLExtXVVVpaWujo6CAWi+H3+7MyPrIVUrk0PkpZNQiFQmZCd6tXDXazppqt8Myk5mfqQt5uFFrVOjCD+cVArkIzFosxNDSE1+stOGQthMwhaz6Gp81my8mws2oE58tLCw0rEomEOUC+fPmy2ZjLpccrSRJ2u53NzU3cbjdnz55FVVWT8TE2NpbGispWSInzylZ4ZsqNNDU1mUxhIWS9sLBAKBQimUwyPT19S51NYXfxr5zC804wOvLd05FIpCwzjQPsX5SyiSBiViQSKThkLXSsYoesUJjRK3QkW1tbOXXqVM54lS/+aZpmDgzOnz9vmhnkin9gDBMjkQixWIx7770Xl8tFIBAwm+li66umpsY0SMh2bZB960Gwf202W165kUgkwuTkpBk79qNMRy43+EAgYObM4v0S13EnGW25sF/NYF7WjTZxw4qiUEwLi02wbDbbDtc9a+f9/PnzaX80r8eDp66fijNvAECJhoiOPc7WU98icu1HpDZu4Ok4i7OlG2Qbupplymk3XEd1TSWxOAaSjLI5j+1QPb4zbyBy7Ueg64bml6aB+xDu1lPEJp+hrq7OvMHzBRjBaonFYly4cMEMINkYH36/n8nJSaLRKF6vl5qaGqPNl4VlJtkcuDv6qX39h1ACK0TGHic++xK6qrB19XuEnn7Q0FVqPoH7yBnQVOJTV5EcLhz1HaRWp3E2CwtondTajMHqc7j25OEoOdHSFJTAMu62XvNLzsYunI1dSDY7sevPGIFE00BXiYw8ajRPHW7sVQ2kNuZBB5u7ApQESBKR4UfRAdcdEA0+KDTvPuRidFgLTWuClRmz8iFbkpXJmsiXYAnkKhKFo15zc/N2cSjjbOjA3X4aLv4jdE0l8OhXic8N4DnSZwwa0NGVJLHZl9CTCWw1rXi7zpFcncZml2hraysY/3RdZ2FhwVzREs1nITCdyfiYn59na2sLh8NhFp67YXwIB+GWlhaWlpZIJpPIslz0qkG5KIXRWwhWav7s7Cz/4n0f4MK5fh544AFe85rXoKoq0WiU69ev55x47jWsq1PZsF+FcA+wt8hcnbIWhadOndq1DEW2IWs+5Ip/yWSSoaEh7HZ7Vo3gzGPkYiSsrq4yMTHBiRMnqKurM18rX9zw+/2MjY3R2dlpFk4OhyMr42N9fZ3r168DmHEpl85vocJT13WTLdvQ0EAikWBychKv15tmTGBlfOxV3Njr+JdZeCaTSYLBYNqwZmpqitra2pyF+l5CUZS8Dd+D/O8XA9lihWDeFhuzBLLlgKUMWcX5ZIt/Vqd7wbYs9RiQnkcKbfFCOaDQI6+qqkpblc9k8YvneX5+nlQqZRq/5NL5zRf/csmNPPfcc9TU1Jju9kJuRMTAvYobexn/ANMoTGibii05wd4Lh8N4vV4URaG6ujqNrHMrUIjRJrAf1+X3faMt2+qoKDR3m2BlBhmha9TW1pa18+51u9LMEOzeSirPv42tZ76D4/BJZM8htq79CO3n3zTWITWV5b/597jb+3C19eI6fBLZ7kJLxokMP2o0s3QNW/VhvEcviAsmsTpNamUKdA1ZaJxJsnnNhab6QvwyH6vFWkgJ7Y1oNIrfv822y7XOuf2nsFc3UXXPP4V7/imLf/lvaPxn/wnJU0lqeYLo+JOEBx9G1zRsVQ14uy6QWJ5MP8z239TX93pi40/i9/sJhUJUVFSU/aCUPtGUcDYdA9vOhFJXktuMQ9BSCfREFHtNC7K3mtTG3PbrGZp1siyTDK4CYK9sxF7TjLw6VtY15EIxQTQSiew7yuwB9h7WuFVugpV5HLjJCPH5fFy5cqXoAigzSdJ1nenpaVZWVujr67uZ/Fu0D41/2pC9VTfPWZJA1wkPPYLs9CA53di8h8zvaapWMMESdvEul8s0PMgGayEltDcSiQR+v5+VlRXGx8eRZXlXjA/BIKmurqaxsZHm5mYkSSq4alAu4+NWOM599rOf5b/9/h/gPflKfj4X5dHf/xzKf/xPeCoq6Wg9zDv/8Tt4z3vew8zMjOlQKCaee114FmK0HcS/uw+FxMBLLQqzQeQN+Yas+ZCN0WFtjlmd7nMhG6NDiIanUilTi6hQ/NM0jampKYLBIGfPns17DWIFyursJhgfVp3f3TA+NjY2TOZcXV2duWYrtiuscWO3zqa32nHT6XSmFZ7PPfccjY2NhEIhc6BSUVFhxr+9LjwLMUgO4t8vHqz6kdlWMgvBuvZZzpA18xgCVrO+XBrBVmSLf0IbbmlpidOnT+Pz+QrGPzCc6GdnZ+nu7s57DYKJJvoGmqaZjaRsOr/ZnudCciPBYBDAlBsRubJYU7fGjd06m97q+JepCzk5OWkyC6enp4lEIqZRRFVV1Z4OkaEwo+12yrSUin3faMsGm81GJBJheHiYysrKshMsUWgWq2vkdTt3mCEASA4ndl8NNa/9ZfNrW0M/ZevZv8XX+wDxuWvEpp5Di4eN5o2awl7Xhqv9DJFrP9yhdZZam8Vz/ArxmReRdB0tlUCNhxkeHs5544qgtLq6Sl9fX8kUcquluKZprP7vz+BoMFZDXa2ncDYe3d4pzX0zy7KMq6UbV0s3AIt/8es4G7usZwlAcnUGxb+Io6HTvJ6GhgYWFhZMZokIOqWsGpTSaDOYjDpKeANp3UVieRJnQ6f5t9CVFJIkE58bJLVxA8nlw9N13tCSkmyo4U0SC6OgacTnBrY13CTcHWdIBZbNSYZIIKuqqnZVeBbj8BIOhw9WR38BIDSKhoaGcgp0FwPxoS8YYLOzs/T09JQ1sBAJhnCmqq2tTXOmApBkacc6vWxzGCtImkpicRwAZ9MxXM3HiIw9YWhY6hpq2M9WMn+hsb6+zsTEhOkoVSpcLtcOwwC/38/GxkbJjA+x6lVfX09ra2ta8Wmz2airq8u5aiBJUhpFv9hVg710OE0kEtx73yuZmrtBzWv/Fc7GTvN7WjJG/MYgo09/m/93YoLf+Z3fAXZOPK0JZFVV1a4Lz0KFZjgcpqOjo+zjH+DlATFonZmZMU2hrMYCpUDEwFAolHfIWswxIF2o+/Lly0U3jTJZKmLoe+TIEZqbm9O0iHKdWyQSYWhoiMbGRi5cuFDys2a327MyPgKBQMmMD13XmZiYQNd1Tp06ZV6faJaL2CYKbKEPKZxNrQ37YpsHt9PhWbxebW2tuQ5sLaCnpqaIRqM7HAp3U3gWw+g9aLTdXch3PwsX5Hz6kYUghgTlDlnFOVqbdTMzMywvL3P69Omi65HM+BeLxRgcHKSyspIrV64UxWJLpVKMjo4iSRIXL14seUXTyrTNtfUldGuFwUKuxpskSWY9LhyArQYzotZub283SS5CbsT6OqU4gt6J+Cfkp8R1xGIxgsEgi4uLZi0v4nhlZeWu2MvF1MCFmrB3Ci+7Rpu4KcfGxujv7y87wQKjQIzFYjz99NO0trYW1DVaW1sjtjmHzVuFs+UU9qom4+dlO7qavoLqauwi4vRw6NxbOHTuLQBoqTibD/1/JNdn8XSc3f5JCTRjGqqG/aCpuE/eh91XbbA4klEiwz8DXdvhlicgDCCyOUqVA7vdzqHX/2uSq9eJzw0QGXwYLRk1Vl5TiRIf6O2f2w6isevPoUYDSJ5DyC6v+T2Hw8GJEyfMiWcgEChr1aDY84pGoyDJSJKN1OoUm//wObRkHEdtK64jZ1ACSyihVSS7C1t1M2wzGXVNRUvGiE4+g+zyocXDKMFV3B1nic8NGAfXjIBw/vx5s/AUCWS5hWcxwpMHjba7D9nuj2g0ytzcHN3d3WUnWHAzybp69Soej6dsXSNZNti2c3NzzM/PZ3WmAnA4nax+49M4m4/jPtJvrNhLMrqSJDL8MySnB3Qd1/Z6uSTJaIkI0ZHHqHA7+cbXv5319a2r8lZHqd3C4XDsYHyIVYNMZ+eamhqzkb68vMzMzEyaw7NAoVUD8V6KwrOUVYO9SrTGxsZ44A1vIpZIoStJ/I/+FbK3ClfzcTxdF9ESEbae/y6yuwKbdnPwlM0Jby8Lz0JJ1EGh+YsBwTytqKgoe8gqIMsyo6OjRKPRonWNsh1DsLdGR0fp6uri8OHDJT2Loli1alqeO3euKC0iwURZXFw0TRL2AtkYH5k6v9kYH6FQiOHhYY4cObLjfchmMAOY2xXCYEbEjfHx8TRjlnxMsdtdaEL657Msy+Z1ZBae1iFyuYXngUblAcBoKMViMebm5soesgoIHVu/31/WkBVuPgPCOKG6unrHkLWY8xCxYHFx0dS0tEol5Tve5uYmY2NjdHV1mYPS3SLf1lc+nV8hGeDz+bLW49nkRjweD2632zSYEc6ms7OzRcuN3O74lzn4lCQJr9eL1+s1exVi3V4MkYGy2cuFGm3FrpbeCez7Rpv1xhFsCV3XOXny5K6abKqqcuPGDfx+P/fee29RCVZ7eztTy9fYeumHaE9+HSQbrsMnjeZTKl0MV7Jtu5FaIDvcOA8fJ+Wft14guqoQnx8htTZj/Jy8fbNIMnosjLO1Bz0WynpOy8vLZlAqlupbDOwVNXg63wVX3gWAEg2w8tVPEL8xyNJf/huDudbeh+uw4RCoJWPYfJl/Dx2QSG4uklwxGCG6ksR3+nUkbgyCJKGE1tESEVNMWCQTt3rVIBAIbDu+pjh04ZeoOPsmlNA60bEniN8YQNlcBJsT7+nXklwYQVMVdFVB2VoHNYXnxD2o4U2SS+N4T78WLeIHSUaNBIjPDyO7nFkLTyEwLgpPr9drJl75Ck9FUQp+cB2I4d7dEBO7SCRCY2Oj+aFcDnRdZ3FxkWg0Sk9Pz67c+VRVZXp6mrq6uryFb3B9leeff56vfvWr/K+vf5PQs3+LnoqDLOM7/Voq73k3S3/56+b56ZqKujHPu/7pu/mrr3w56/0vmCjFDEp2C7vdvsPZWTA+FhYWSCaTZkPcqg1nRaFVA1U1HIvLWTXYi0Try1/+Mr/5id/CffxeGs69BXSN1MY8yZUpEkvjREceBUnGefgkNl81+uJQzmPd6sIzE5FI5KDQvMtgvZ8FW2JpaQmXy0V3d/eujh0IBAiFQtTV1dHb27urZ2dzc9Ns9JfLLo5Gozz99NMlaRGJos7j8ZjrpbcKgomWT+cXjFylu7ubhoaGnIyPYp1N29ragJvOpmJFKVvedCcabfmQq/AMBAJphaeVvZwvly1UaB4MGu5OWOWTxEq6w+Ggv79/V5+X8Xic5eVl3G73rsxjdF0nmUzy4osvlrRyaoUY+r744ovIsszly5fN3KfQqrwwnTp//vyumo6FYN36yqXzC8YgqKOjg/b29qw5azEGM2KtX8iNJBKJNLkRu92eZswiGHN3stGWDZnr9oqiEAqFzBwwlUpx6NChNPZyPu35QvFvv9a/+77RBul01N7eXjY3NwvaCeeDcEFpaGgwJ3HFoL6+HndbDzWv/VU0TSO5NEZ0/EnQVBKLowSe/Abutl6czceRbHZD6D8Dkmw3ty+V4CpoCmpoFS0WxNP9CuJTV40GkJIyGnU2O66mLuJz19Is5FOpFGNjY+i6zqVLl/bYyUTasSBq91YjOd242k7jO/0A0fGfEx74EaGnvgW6xuo3fxebrwZX22lDj257fTSxOIIWCWDzVqOGN/CeepX5ICn+ZdTIJmAEMDG9zWR8FLtqICY9xawaGO+lhJ6Mw/a6qL2ynsrL/5jKy/+Y9e/9MVosZCRwmoquKYYZgpJCqqjFfqgOJbQGkhE0tW29vejEU8guH82Hm3a8pizLZgFtLTzFdeQrPIuhzVoNQg5wd0EkWF1dXbS3t7OwsFD2seLxOMPDwzidTnw+X9lNNtGsm5+fp6mpiZ6enoK/c/HiRS5evMjCwgIPPTOE99T9OOrbcTUdNdZKdQ0tFSc+/QJSKs6f/Mmf8Mu//Ms7jrPbVfm9gJXxIQR7GxsbsdvtXL9+vSSNj8zESyRdpawaJBIJYrEYlZWVJSdcmqbx5re8jWeev2o6waY25nE2dOBs7MJe3UxybRrsTkDC1XwMJbRWUmG/14VnJg7MEO5ehMNhhoaGqK2t5d577+Wpp54q+1iqqjI5OUkwGKS6utosZspBIBBgcHAQm83GxYsXy9bW8fv9BAIBLly4ULQW0draGpOTk5w4ccJc97ydsDI+mpubGRwcNGU/VlZWuH79ekFnZyjOYMblctHY2JjmbCpWWsPhME6nMdh0Op1F5Up3Ctl08TK3HnIVngdmML+4SCaTjI6Ooqoqly5dYmBgoOwaWORtMzMz1NXVcejQobKbbGKbSlXVkldOrQgGg6ytrXH69GkaGxvN+q+QJuFuVuV3i0zDlOvXrxMIBDh69CjhcJhnn322aGdnyK1zKYa3wmBGbD0IIxshN+Lz+UilUqRSqdtSB5bjOmq323ewpMPhcFou6/V6zQailXyiKEre2n4/M3r3faNta2uLgYGBNM2fYDCY1d69EAQt3+/3c/bsWWw2G0NDuSfymfD5fOgpY4VQlmXcrT24W3tYmh8FXSO5OkVs4udo8TC2ijq0WIj1v/8j3J1ncbWcwl7TYmiA6Trx2ZdI+ZcACRxuvKcfQJZlJFlGjWwSnRg3Vkqd4saSTIdU4SjV0dGRc510NzCk2LIEcckILuK6BRb+4teof+e/R1mfJzb1HMGffwMtFgJVQQd8vfeTWr+BGt64eSxdR4348Z58BbGZF0zRyEKMj3yrBuvr60WvGkQiEWSnG9lXjSTvTMp0NQXbX9eVJFp4E3tNy7ag+3bDc7uRqmsqqfUboGu4O8+jJyJ43IUTPWvhKQTZcxWehT7A9rMQ5AHKRyqVYmBgwEywXC4X4XC4rPin6zpLS0tMT0/T3d1NfX09Tz75ZFnnJZgUDoeDY8eO5bV3z4YPf/jDDI38JgvPPUgwHsVZ346r/QzoOpGhR7hy+TLf+/vvZh2C5HKUuhOwrm2dOXMmjVGQz9k5l8YHFFd4Zls1GBkZYXl5mbm5uZKcTZeWlnj1a1/PRjhB9avfTyqwTHJpHP/D/wOQkFxetGQM2eHC1XqK5NKEcX2auuvktpTCUySguV7zgNFx90EwFlZXV0vS/MkFMWRtaWnh8uXLDA4Olhy7xHmJXLK3t5eZmZmynoV4PM7AwACSJHHkyBG8Xm9RrvIiz9nLVflyIda2rNqYYiCwV87OmYwP4YjX2Nhobj1MT08TDoe5evUqNpstjfFxqx2Ry0UphWcikThYnf8FxMrKChMTExw7dsxcixSGMKU++9Yh6z333MPKykoagaMULC0tMTU1RXd3N4lEoqxnTMSyra0t0zRKkCuKWZXv7e29480VoSdXX1/PpUuX0s77Vjg7i8+r6upqamtrzcbb2toafr+fa9euoWnaLXE2taKcRlsmrOQTII18IoYoYngjYmEu7Of4tz8/fSyIx+M7dCfsdru5algsQqEQQ0NDNDc3my4oqVSqpCTL5/OhKztf1+apANlG4zs/BYAWjxIe+glbz/4tksNN+NqPCT31vwEd2VOJlohu4FhBAAAgAElEQVSgq0l8Pa8hOvEUksOddsMm5kdwNh9HCa4YmmCJCMrWOsPDw+YktpCj1G6gpFIEfvZXuI9ext3SjaOhY9skILsZgiTZsPtqcTV04et5tfEeaApLf/4RPF0XkZ3p56lGgyjhDez1R7B5K0HXaWhoyFpEFcv48Hg8OBwO+vr6gMKrBtFoFGQbWjKGElxBi4eR3ZYiWZgh3BhCDa0hV9Th6TpPbOZFJNmGElontTEPuk509HG0VBzsThzVTSSWJvB6ygv+uQrPxcVFQqEQzzzzjMmSqaqq2kG13U+rEwfYPVKplEkhF7Db7SUXh4lEguHhYex2O1euXEn7gC+Vcr6ysmIyKRobG1leXjaHAMXida97HX/3tw/i9/uprKzki1/8Io889jgJj4/P/pfP8OEPfzjr7wn9s0KOUrcDqVTKdDjNtraVT+NjdnaWra2tshkfovAU8c/pdOJ0Ouns7KSioqKoVQOA73//+7z3/R/AVtNG3Vs/jGx3GnIAPa8xGoXXHiIy9AjINnynXmWYvkgyWiJKYmEETdrbBn+uwnNzc5NEIsGzzz6bpvPm8/nM9+ZAo/LuhN1uL1nzJxOZQ1bBgM10Xi4Ggr3a1NTElStXzJXxUiEK1VOnTpFMJpmZmTFZsrlyO6F/Vo5pw17D6nCabW1rL52dIX/hKcsyHo8Hr9dLW1sbqVSKUCiUJjdijX93ujmZC9kKz2g0SjAYJB6P88ILL+Q0C4tEImWZAB1gfyOVSu0wVik1B8w2ZAXjmYrH4yWdj3B2l2XZzCXHx8dLOgbcHHq0trbS0dHBs88+y8zMjNmEzwaRx96OVflisLKywtTUFD09PVmlrG61s7PIAwWjraKigt7e3rSG/eLiojmwzFU3loO9aLRlIhv5JJFImIzHra0t5ubmssby/ey6vO8bbY2NjTvYG3a7nUgkUtTvi2RgY2NjB+Og1CRrc3OT1OYCsemruA6fNBszks2RptEmu71UnHkDW89/l7o3f8T8emLlOsEnv4EaC1Fx+rXGFyXZZI9pqQS6ksLZ0o2r6ShKaA1diREZeQxJtlNdXY3dbr/lNFnZZsNW2UD8+jOEX/w+upLAUd+BnoxlXYfNegzZjiTbkIQLlXAcXZshuTAKsg27pRmVTCZ56qmnymJ8iOBbV1dX9KrB4OAgyDJ6Kklk9DHC136EzVtlrL229aInIqRCa0g2O5KnwmgIAmia0SgMrhgrVrqG5PTgauwiuWIw0HQlSSJR2odXLojCU1EUKioqOHLkiBlAJycnicViOJ1OfvCDH5j3853+8DnA3sHn8+0oCsQ0s1iIgu7kyZM7EvFStL1SqRQjIyNompaW+FmFbIuB1fr90qVLqKrK7//+75tMJr/fz1NPPWVO/WpqapAkaVeOUnsNIQh+7NgxM4kqhEyNDzAGAn6/n4WFBUKhkMn4yGyIWZGZeCmKwtTUFJqm4Xa7zRWjQqsGVVVVfOlLXwKHGyW4zNqD/xnZfQhHXRuuI2dJzA+TmHsJe2UDWsLQX9I1FVTF+Eyyu6itL108uRSIwtPtdhMIBDh79qxZeN64ccNcG3vssceIRqP7lrlygPJgs9lMPbBMFBu3sg1ZrccvNgfUdZ3p6WlWVlbo6+szmRRW1+ViIBr0kiSlaRG5XC7TACAWi5mObsLhc3Z2lvX1dc6cOXPHtWji8TiDg4PU1NSUlI9mOjtbGfy7YXwsLy+zsrJCb2+v2XjLNJgReZMwmBGFZ3V19S3VdtoNrJ8ZCwsLXL58Oa3wvH79uvnZODExceC6fBeivb19R3wpJQfMN2QtNXYJCZPjx4/T1JQuj1NsPNY0jenpadbW1ujv78fj8aBpGufPnzefz2xDyI2NjTu6Km+FqqqMjY2RSqVKkm7aS2dna/zb2tpifHyczs5O8+9ZUVFh1oxWuZHJyUni8bjJlC3F2dSKW9FoywZRy29ubtLS0oLX6yUYDJo5oKqqbG5u8vjjjwN3xhSnEF6WWWmxyZF18igSGisyLYVzQdd15ubmjO5xLEjw8b9GjYawVdTibu9DjYX+f/bePDiuvLz7/ZylN3VrtbVZlizJtizZsi0vshlmY6DqBhLCkoRMcRMYyGVShKXyTi7DBC4JGd57X/JCKkVW4IXJTQiZyw4BwjZhMnjs2WxmxrZ2WbKsfV+61ftZ7h+t3/HpVnertWsGfauoGmTp9OnT5zz9+z3Pd1n2wUqKakkLBVzlB/Edu4+FZ79x+/ckGdMw0OYnCN96GQzjdgNPkkHXcNe2oIcSr+Hz+Vb0algvFEUl/+QbcZbXA6AtTBDsukh84ibRwTZmn/hCIghh3xGU/GwFL3FtjWgIbW4MgNhYL576s8Smb1n/ZmpRHA4Hr3nNazIyPsT0LvUzXFhYoKOjI2nDm01qUF6eSIp96aWXLBZb0d2/j6vmBOEbLySkr899MyF9VZ3kHb2X8I0XkCQFU4+jh/2Y8QiehtcQG+9D90+Td+gcsalbIMlEx28Qnx5ErjqxoZ+JSFSxTzxFAZ2dncXhcDA9Pc2ZM2dobm7mq1/96oa+/i62B+m+MHKtf+kmj5mOtdIXZrZEvVwbbaKOCsq/qGWSJOFwONIGDczNzVms1KKiIqqqqtblz7leiM327OwsLS0t62YVZ2J8iAWtYHyIBVFq3Y9Go8s2vOkYH5IkLZMaBAKBBOvkYCuFd/0+2sIEsbEeIoPX8T/3DUxdw9t4F9r8GEY8kqipi3OYehzn/iYkJNyO8Lref64Q9c++8bRfs/b2dsbHx3nb296Gqqr84Ac/WFfAxy52NkTNyTZUyjZkFci1loogLruFif1ccm3WiTpaX1+/zItIeBMKOwwhO+/q6mJhYQG322016LdzMzE5OUlfX9+GBHDlyvhITXYWMAzD2vC2traiqmrGgJlMyabd3d05J5sKbKdVh9h4pqoehoeH+eu//ms+97nP8bnPfY577rln285xF5sLVVVzarRlG7JC7rVL0zS6urqsxlLqc5jrwDYUCnH9+nX27NlDa2trUuCL+F4XdhhiCDk4OMjMzAySJFFVVYXD4diyJk86CL/Qqqoqqqqq1lWH15rsLCD89kZGRjhx4oQ1gMnFbkQEU4lkU7fbbQ14V7IbEa+xlZ+BIJGkhpIZhkFXVxczMzM8//zznDx5kgcffJAPf/jDW3ZuK2HHN9rS3cQrFRl7x9w+eVwLhP46Pz+f1tZWvv2fz1D2jkcx4hFCPc8R7r+CHvKDobF47WcJL7Y9+0FWwTQSjCfJFoGr3L7kRiyMoUVBixEeeAlnVSPa7CgSJqZpWF5gjuJKjMgiIDE7O2t5d4kNWHFx8SY03m4vJNTCcgrP/zaLbU+iFJZhmgaBX/6Ahaf/FRQnGDrT3/8M7poTuJbCIGSnB8xE4ENsvDcRAgF4j92HrDqITd9CDy0QGWoHQ8fpdGZlfIyOjtLV1ZXE+PD7/UxOTi7b8OZiLpmfn4/k9IBpIikOZNWJt/EuvI13ATD++J+iFpYnjmXqmFqUYMcFTC2GsvcAqreYmGGAWOgbOmY0SGyiH9lbRH19/YZ+Gpk2FZIksWfPHn7/93+fZ555hieeeCKRqLqLVy1yGRCMj4/T19dnyTszQWw0M03kxOQuW6JeLlNRwYDw+Xy0trYCZPUiUhSFoqIiZmZmcDgc3HHHHVYTyh6AIiaeW8FIEMa/RUVFnD59elMWGamMj3g8ztzcXFLdF5tBgL6+Po4cOWIt1CB3qYGQHUmKI9HsLKrAUVSBt+ke5p/+KpHB68iuPEzDANMk3Ps8emgeXHm4SmuJTd7EvQneH+mQranicrn4vd/7Pb7whS/w/PPP4/f7dyWkr3KsxN5eaciaepxMME2ToaEhhoeHOXr0aFp5kD0VMBOEF1EwGOT06dM4nc6s9U80hhYXF4nH45w6dQpVVZP8Hr1er1X/1sJIWC3Ee4jFYpsQwJVANsaH3bNRsD16e3upqKigurraev+52o0IiZJYawrGR39/vxWqJWptqrpiOzf6qVBVlfvuu4/vfOc7fPrTn6alpWVNvoO72JlYy7A1lyEr5CZBFcOB2tpa9u3bl1FllO2ZEL5qQ0NDlhWUqH+Z/sbj8RCLxRgcHOTw4cMUFxdbzK9AIIDT6Uzye9zs59E0TUZGRhgZGeHYsWObIlPMJdlZqL4KCgoYGhpCluVlMtpcA2ZKS0uXsYtHR0ctP810EnX7Mbej0ZYKWZY5evQod911F83NzTz88MMsLi5u2Xnlgh3faEuHbEUmEAhYiaLnzp1b841gT2ZpamqipKSEK1euYGpLYQgON75jr8N37HVM/ehviA1dJ9h5Af/l74Fh4Kg4CLLC/IV/xV1zHNe+I8gub6IBh0FsZpjoUBuYJiDhPXovstODPj+OEQsT7bqIEQmCtHRjSYkwhIaGBiCxAROTv5s3bwJYTbeioqL1LYIkKZ0VG5Ks4CgopeR/S8hhDcMgOtzO7I//FkdZLdHJPkI9z2BEgyj5pZh6jNhYD67qZoxokPhEH7K6dF6mQXz6Fq79zcQmbmR8MNIxPqanE351uq6Tl5fHyMhIRsYHpN94xmIx1LxC9Gh46TNJga5ZzUF0jfjMEGpJNUYkgLL0HkxDA8PEiCwSmxoAwHvsdUSH2jdc2rFS4oo9cSrdZmAXvxqIxWJ0dnYCLPP1SIdstXR+fp6Ojg6qq6tpamrKuJFbaSpqN80tLi5ecYEF6ROlxAIDEs+w8ODp6OggFouRn59PSUnJpjTeRMJfalNrs+FwONIyPoTxt9vtZnJyklgslpbxAdkDZmKxGCjL64qpxW/L/g0tkcDsKcBRVofun176uY5D3ZpG20qSeMFchkR4zC5ePUjXyBLD1tT6ttoha7YhgRgOeL1ezp8/n/H+W6nB5ff7aWtro6qqisOHDyexODL9bTwet6TyZ8+etdY1dr/HYDDI3Nwc/f39lg9tcXExJSUlG954EyyOffv2sX///i1j02VifAwNDTE5OYnT6cTv9zMyMpIx2Rly23i63W7Ky8uT1ppCyiYk6mKd6fF4tnSTmQuDTqTubYbx+S52FrKRTXIdskL2tVvqcCDb/kOsI9PtvwTj3OVy0draarHus9U/0zQZGBhYJpW3e3eJoJVUEkZJScmGN96E3N/pdG6pN1wmn9/x8XFefvllZFkmPz+foaGhNfv8irVTqt1IPB5fJlG3e6OJ89sqrLQGFHtgofraSXhFNtrSFRnDMBgYGFjmn7EWiMIgklnsixwrcdJ+Pp584g435ff/30DChyzUdZHYWC+xsV4iAy8vJZEWoxaUYWpxokPtuGuOE5sexIyFbwcGSDLR4Q6UgjJkhwcjOI8enCM+NcBw5HYHXUghBR1YbMCE+athGEkeR6tpvGnxGKHe5xKvYwUhAEjYv+9lWcZTcxzJ4aTwNb+Lkpd4+IxoiFDPsyxc/Dfch87hKNhDZLjT+jtTi2NEQzhK63CW1hAbv2HRWVdCLBZjaGiIQ4cOUVFRYTUc7YwPu7lkukaDLMvEYrFEI83QMMILy5iHpqGBLBMZvI4RDaHuqcFz4DjBzqdBVojPjmKEFgCJYNdFJFlFzitCVhMMv2zpKGtBLkVmpxpB7mLtWM0XmZAb2tOpVkK6RpswDp+fn6elpWXFezmTdDSTF9FKC6xcEqWEB09RURF1dXXLGm/RaDSJ8bZWiadhGPT29lqMvu020TYMg8HBQYqLizlz5gymaVrvO5XxIRqO2QJmZmZmMSVHorGm2gIy9BjICrHpIeKTA+D04G26m8hodyIZO+QnPjnApF7EwsJCTlKD9SBX78md5s2xi81Burq1liGrkFHbYTcOb2xsXLME2TRN+vv7l3kRZat/cDvFs66uLmMdFzYiPp/PSvjM1HjL5neby3sYHR21GH3bnfAHWEmJd999N6qqbliyc2rATKrdiGB8TExMMD8/TzQapb+/32KgbKadSy6yvGAwuCM+n11sPtLVv9UOWTMdB24HFeQaupJpDSjWpIcPH7Y8tIVUPhPC4TDt7e3WGifT77rdbiorKy0f7kyNNxG0stb1yfz8PJ2dndTX1y/zpdtqSJKE3+9namqKs2fP4vV615zsDCsHzIjGpWi8BQIBS9YfDAbp6emxGm+b3eBfaQ0YDAZz9kveauz4RlsutFkxbduzZ8+606nENCCdpt3j8WBEgkRHunCWH7Q2JpLDBbYGnLO0FmdpLaGeZ9n7lodR8gotqWmw/SlMPY63+T5k1Ul8ZtiaVpmGkZAmFlWSV3eK8M2XMAyNUO/zyC5v1psoHeVeNN7sXhclJSUZG1ACEiaRwauEbjyHGY/g2FOD+8BJ0GNgrkxJl115+I6/gYXnvoHiTGaW6MF5wn2XMQ0dWQQMkL3wQjJt1z7hSNdwFN5Ot27dQtd1q/FmZ3yEw2FMScLQYsxf+Ffmf/EvOMrqE/LXfUcwdY3IUBsSEsgqan7J0nkYaHOjCSmvLINh4Np/DCMcwIgEMU0DI5ow695IrORHEwgEdhttr1JkkiaJxXemkIJckFpLheSqoqLCmj6uhHSLrExeRNk2mbFYjPb29jUlSqVrvKXzuhALh3QNqFQIVl1FRQUNDQ3b3sQRC75UM2BR2yC9x4fdVD2V8TG7ME9o6ibBzgs4SqoS3ptVTRiRILp/Cm1+AtmTj+RYquOGjhENE+p5Bklxcvjw4ZylButBLoy27f58drF1sA9b1zNkVRQlKTFZ1KB0xuGrgfAiKikpWeZFlOk+NQyDvr4+/H5/2hTPbEjXeBN+twMDAywuLuLxeJLMxVd6XsT3iqIoOyLhTzAM9+7dy+HDh63z36hkZ8huN6IoCnv27GHv3r1Eo1H6+vrIz89ndnbWUpVsVrJpLoOG3dTlVycy2SdFo7cD+NYyZIXl6z9Rg2ZnZ5PSmVdC6how1dPN7gWcbcg6Pj7OrVu3aGxsXLUyJ7XxJqxGxsfH6e7uRlXVpMbbSs+TnVW3EX6864WwcdE0LYnlvNnJzmIAIWStRUVFyLLM5cuXKS0tXSbrtwfMbOSabCWpql3VtdOw4xtt6SAeWvEgjI+Pc+zYsTV9yQgaq67rdHZ2Yppmxs2qz+fD1OLMPvF5jGgQx55q3DXH0RZnMfXlNF5JVqyfC6mpo6SK2Z/8bYL5lPglTMNAjywS7ruCGY/gKtlv/RumiafhtRihObQ0bLps1yjVXFw03gYHB9E0LYnxlhQd7XTju+99uPY1JIIQOp8mPPAiph4nPj1EqPsZnPuOoOavMOldksWaho4RTjSeQj3P4ig9gBEOJIIgdA3T0LNKz8RnI2QU2QpkqlGirutpGR9XrlwhPj2I5PSw9zc/AkiEui8R6nmWwEv/gRkNIeUVkNfwWkLt/wWymkiFjUcxTRNv412E+i5jGgbOvTVEbl0DTELdCekswMsvv5y08VxPA1iYgWfCLqPtVwtiYTMzM0Nvby/19fXWAmM1ELV0Pb6WdvmVruv09vayuLiYkxeRgJBmblSiVKrXRbbGm2C82c9vdHSUwcFBjh49uu2bF9M0uXXrFlNTUysu+Fbj8ZH43x7CB+7BffAsoe5LRG5dJdT1NEYkAJKC9+jdREd7Lb9RI5QIg3HXnkJfnKGgoMBqQq4kNViPncFK9U8weHbx6kOmYatIklzPkNW+0bSzL9Y6GRcDwcHBwZy9iCDx/d3R0ZEklV8PUv1uTdNMMhe3N6BKSkqWNd4WFhbo7OyktrZ2VRv3zcLMzAw9PT0rBjBk8/lNZXysJtk5tfE2MzODqqrWEHezk01zabQFg8FtT6PdxdZA1K31DFntx4HbjOCysrJl6cwrwd5om5ubo7Ozk5qaGioqKixpYrYmW2pTfyPYoekSju1BU8IHWNQC+/Ml/HgLCwuzsuq2CqFQiLa2NiorK1eU7mdKdp6enl5XsjPcDphZWFhIGu6kJpv29vYSiUTwer3WGnCzfUR38h74FdloE19qL7zwQtoUqNVAURQrRWmlzWp5eTmSolD5nr9BW5wj1HmByOBV4vOTYBqEui/hrGpE9e0RB09iugFIigIWgy1hso8eI9R1EbWwHJNCWGKwCPmi6i0kFl4gnmOcc6b3mSnVb2hoCE3TKCwsxOv1LrFnEueoFpZT+JrfoZDfYeSxD2JqUfyXv4seWkB2uHFWNYJhEHjpR7gPnMRZfhDZcZtCasTDRPtewIhHAPAcOoeav4dQ7/MYsQjBzgtgZE49FAvp6upqq2O/2vedjvFRWlqKo7QWbWEcSVZx7NmPs/R2NPrIFx4kr/ZUwnjeSLDUooPXQNdw1p5KJMMaBsiJQmQaOnpgGtlXjOTycurUKRobGy2pgSjs9o3nar5MVmK07coGfrUgyzJtbW0YhpE2BSpXKIpCKBSir6+PkpKSNflaikWW3++3fHwOHTqUE4tD+IBEo9FNlWama0CJxltPTw/hcBifz0dhYSGzs7OoqrphC771IB6PWyy/tSz4Mnl8CMaHP7AIxSqqr4SCM79JwZnfBGDie59GMnRkZ14i6AUSQ4TwInJhKY6SSvTAJHl5edbnnCo1sBuZpyYIrlZqsFL928mLrF1sPBRFYWxsjGAwuOYhqzhOPB7n+vXraJq2ps2qwFq9iHKRyq8XwuMyLy+PqqoqTNMkEokwOzub1HgrKioiGo3i9/s5ceLEtjevhfx2YWFhzd8P6012htsbT0mSrLCEpqYmK5jInmxaUFCQlBxrTzb1+XxJPm+5bjxzabSZprntrMNdbDwyMdoCgQAvvPDCmoescLvRdvPmTcbHx9dsuyQGHz09PZbliMvlWpVUfrOlmU6nk/Lycus1RONNDHlFHZBlmfHxcRobG7fUjzcTJiYmuHnz5pqHvutNdoZku5HR0VGGhoY4fvw4iqIkBcyIWmtPNp2fn2dgYIBQKGR9x4iAmY1sYO7kPfCOb7SlPqBiuh8Ohzlx4sS6jI81TSMUCjE0NJQxUc+O4uJiTCPR/Vd9xRS0vpWC1rcSuPpT/M9+Hf/l76H/YgHZmYdr/1EwTRbbn8RT34qzrA5JUZEUByYmeshPuP8KZjwhW/DUnUYtLCNy6xqmrhHu/2XCdNreZQ+F1/xeU5FqMiuK7c2bN0lc8eVSNUlRcVYeZs+vfSgRhHDrKqHe5zBNg/DNFwn3PIsRC6EWVeKuOQ6mQfjGCygFpaj5e9GmB2+z4EyT2GgXavE+tIUJIpHIstcbGxvj1q1bHDt2bMMeILHhdrlcKJ58tPlxUNI8BpJpNdEwDWIjnTjK69FmhlAcTuvnkuQgNj2INj+O5PbhbXgtwY6n8Hq9SVIDsfEUfnKrlRrkagS5i1cfUqWjU1NT+P1+Dh06xIEDB9Y8JRL+XoFAgJaWljXXUkmSCAaDdHR00NzcTF5eXk4LLL/fT0dHR84+IBsJkbpp3xSNj4/T29uLy+UiHA7T0dGxpal+qRDXp66ubsMWoKmMD0VVkeTldUUybntWmoaG7p9C9pUg5++x2NimruPxeKwFdarUwDRNCgoKLKmBruvWxnO1UgNd17PWx93696uDYDDIyMgIPp9v3VYhi4uLjI2N0dTURGVl5Zqf8Xg8zpUrV1blRRSNRuno6CAvL2/LpZmSJFkbIrEpWlhYoKOjw/qdrq6uLU31S0U0GqWtrY2ioiJOnTq1YfV3NcnOdsaHOJ+SkpJlVgKpjA/x/0Wtra6uBm4nm/b19Vns4kzJpnbkIp3fxa8G4vE4N2/eJBAIcMcdd6zLGyscDhMMBonH4+uqpbqu097eTlVVFWfPnrWegZWk8jduJILwViuV3wikNt5EPV5cXMThcNDX18fMzIzVhN/qoWuqP/BGpTyvJtnZ7m9sGEZS6nS6FNJ0yaZlZWVWI1iw60ZGRjbcbkSEwexE7PhGmx2CPimYV+tpsgl6q9Pp5OjRozk95AUFBYnpfoofjKQ4kBQnZb/zSXB6iA5cJdT7LEY8Srj3BULdz2DGozj21uAsrQUjwX5zlFRhmAb63Bhq4ZJUQZKJjfciu7yoJfvQ/dPEZkeIDndw4vVvWPP7zQahpzdNkzvvvBPDMIjPjuIsO5hkkC0hWWw8WZbx1J3CU3eK0cc+SNlv/RlKXgFayE+o+yKRgZdBknFWHsJVXk9kqN06jmmamHocdc9+PDXHWbz2RNJEJpMWfSMRiUQSDTbTAC22/BcMHWSZ8MDLYBo4q4/hKj1AYPoWyCrRif6ELFiLER3uAIcbtWDJ088wKCkpweFwJJlLAmuWGuTSaNupRpC72BiI5zQWi7F371727Nmz5s1HOBymra0N0zSpq6tbcy0VXkRCupALiy1TotR2wTRNBgcHmZiY4OzZsxZLKxgMMjs7a22KvF7vljTeBMtlbGxs01klwWAQU48v9zgz4uDwEJu8iR6YQcorwttwB6G+y0iSihaYRvNPWnU7m9RANN4gYb+Qyq6zSw3sG0/7Nd4Ng/nVhbgHxJB1dHSUffv24XQ617Ux7O7uJhAIUFJSsia2PNyuyZqmce7cOZxO54peRLDxUvn1QkgzGxoaLNVDqrm40+ncssabkPjbz2ezkC7Z2e7zaxgGbrebhYUFGhoa0kpp7YwPAbHuszM+3G43FRUVScmJ9mRTl8tlDV/t13g3DGYXkKgbPT09VnN8rU020zQZGhpieHgYl8tFQ0PDmo9z69YtpqenOXjwIPv377fYnblI5cvLy5P8FrcLordQXl5OS0uLZYWRGrQnmm7FxcWb2ngT6/OysrJN9wfOlOxst1nJy8uz9pjNzc2rTjYV9U80+crKypKusZ1VKIgn9ubmKz0M5hXTaLt16xYjIyMcPXqUoqIiZmZm1mSALLrECwsLtLS00NfXlzHePRWqqlqNMGf5QYsJICkqyAqmHkeRfXjqT+OpP83E1/+MonvejavyMJp/kmDHBcI3X8I0DEtCGRlsQ7iTCbmo7PbibbybyEgXZjyCNnI1nlMAACAASURBVNLBl//XF3nnO9+5qveaC4Quv6amxproGloc/wvfYeHS4zhK9uOqOY57/1FMDKvRlvEa5RVQcOrXKTj164x88UEcxckLWCMeJdz/S4zIIs6yeut9i279arTo60Fig5mQRE1++7+j5BXirGrCXd2Ms+IQAOGeZzENA0wDR+ESo8QwiI52YoT8iSYdEt6j9xC++TKSrKBHFjHiUfbu3YuiKFnNJVcjNYjFYlm/uHZykdnF+iHCBWpra9m3bx+dnZ0Z492zQaTIDQwM0NTURCgUyuqPmO04di+itrY2YrEYDocjp0SpoqKiHeF9IczPvV4vZ8+eTZIIpfpPbEaqXyo0TaOjowNVVTlz5syms1yCiwGiz30T/+Xv4apswF1zHOe+I5haHG1hClOLgcOJwzZE0IOzaLND/OlHH+aRRx5Je9xcN57ZpAbBYBCPx0NRURGhUCirbGI3DObVDfuQ9fz580xNTREMBtd0rPn5eYtJe+DAAXp6etZ0HLsX0eLiIrFYDFVVszbZRIMvHo/vmBTjvr4+AoEAp0+fTtq4b1Wqnx1iCDMzM7MtLBdY7vM7ODjI8PAw5eXljIyMMDAwsGKyM6TfeKYyPpxOJ6WlpVRUVCQlmwp2tfCRWokdvhsG8+qFJElJQ9YzZ84gSRLT09NrOp4IFcnLy+P8+fM8//zzaz7O9evXyc/Pt76/cwk8GBoaYmxsbMekGAvlVKo0MzVoTzSF5ubmLEWS3eNtoxhnounU1NS06kCIjUCqzcrc3Bzt7e3s3buXUCjE888/n3OyM2QPmJFlmZKSEvbs2ZPWbkSoInIJ79nJYTA7vtFmmiYvvviiVRTEhyZ8gVazEREeQpWVlZaHRqZ444yQZGZ+/LeYWgxnWR3umpOY8XAi1GCZH5tqebSpBWUUvuZ38B1/AxOP/+ltCaWcCDwwtRjhgavoizM4SqqXXkpGURVu9HRvOFtJFLzx8fFlrBJXnhf3XQ+gFu0j1PU0kcFrhDovYIYD6ME5NP8kSn5pDl/st5typhYDTIIdv0B2e5E8+UiqmqC8L0ks1qtFXw2qqqqIjX4XDIPy3/ufREe7CN+4jP+5b6KH/SDJSE4PnvqzBF/+MagqRjQEpokRCeE99jqC1/4Tuagi4WNkJgItYl0X+a23v50777wz6fVWMpdcSWoQjUa5cuVKRqnBTqbN7mJ96O/vZ2ZmJknebk/dyxWCGu9wODh//ryVXGVP3csFojnlcDisOlpRUcHLL78M3E7BTKXbiwXNWhKlNgOCxZELqyTXVL+SkpI1N97E0OPAgQNr9lxZLfK8BXhe+/vIrrxEEMzVn2I8+w3MeARUF96j9xLuuwxKItjHiIaQzTjf/OY3OHToEFevXs2Y7JyKXDaemaQGgUAAv9+f5PFhlxrsSkdfvZienqajo8MassLytLxcIKRKc3NztLS0kJeXRyQSyXnQaj9OX18fc3NznDx50mq0iAZaQUGBVQfsz4IIGBB+s9vdGAmFQrS3t1NaWpqTNHOjU/1SIb5XfD4fp0+f3vYhjGiKGoaRtPdYbbKzQDbGh9iACruR0tJSq8GysLDA6OioNYQVbA/75n43COHVi0gkwvPPP28NWSVJQtf1Va//TNNkbGyMmzdv0tjYuC6m6NjYGP39/dZabmFhgYGBAYaGhizmf0lJSdKzIDwsxVBzu/0ERfMSyEk5ldp4E15nYg1oGEZSwOBqG2/2ocdOGMIIZcX4+Dhnz5619h7p1r4bkewsvs9T7UYCgQAzMzOEw2FeeOGFjHYjQnWyE7HjG22SJNHc3LzsphMbzVweVnui3vHjx5Mm3+LDzAWmaSIpCuX3/3eMWIRQ5wVCvc+iL84CJpHBNjwHW1E8Swt+RV3WfENWLT8F0zQxtThgstj+FLLTg2NvTSJtNHHiVFdXb3iTTSxoPB5PEosj+c0u+dCdfQsFZ98CwMiX/whtYZLJr/8ZkuLAWdWIu/o4YBIb78FVfTwpCCFxGJPwzZfQ5icAcJbV4ao8TLD7GQxdJ9b7HJD4AhgbG9tQLXo2fOpTn+JTn/oU3vwCZKcHb8Nr8Ta8FgAt7GfiXx4i79A5TDOxCDcW5wj3vwiY5B29F0mWATORnLr0ORohPx/5yP/Jb/zGb9Dd3W01G9IVzNVKDcS1SSc16OrqYnJyctsL8y42B4J5YV+8r3ajOTExYUmV7PVktccRBtKHDh1i79691pdlXV0d9fX1aJqW5HcjvNACgQAul2tHBAwYhmEZbKeyOHJFqtfZU089xa+/5e34fF7Otpzg3nvv5Z577mHPnj3W4iPbRlYYzDY3N28pM0vTNRyqE/f+Y7j3H7t9Pv/yEI69tchOd4LFrGmEui6ypyifS09fsBL9IHOy80YwPoTUYHZ2lurqalwu1zKpwczMDJcvX94W9ssuNh/FxcVJjQ5Y/aAhEAjQ1tZGRUVFUqLeauvf4uKiJemxexGVl5dTUVFhhcLMzs5az0JhYSHxeNzyFd7ugAGA8fFxi9W8VtuAVK+zaDTK/Px8Uqpfro030YSsr6/fERYYgq1TUVGxTFmx2mTn9TA+JEmiqKiISCRCSUkJlZWVFuND2I3IsszFixezplHv4pULEa5iX9/bUz5zQSwWo6OjA0VROHfu3LI9Vq6MyHg8TkdHB5Ik0draap1HQUEBJ0+eTLLcEM+Cz+dDVVVmZ2c5cuTIjpDKC//bmpqaNdsGpHqdpZOcFxYWUlJSknEfKCD8H4uLizfUj3Kt0HWdzs5OZFnm9OnTSbU7XaK1YDtvVLKz3W4kPz8fh8NBJBKhqamJYDDI/Py8FaLm9Xq5dOkSiqJs+3XLhB3faINEsyG1qOS6QLLHv6dL1Mv1OEK6IEkyphbHUVxJ4Wvvp5D7idy6yszPPk/gl99n4dL/h+IrxlV9HDMeJTJ4DcVXglpShSTJCZabaSwx2F5eatLdbkBFx/sw4xEiwx3Ep26h2zY0GwGR8HLo0CGrM5+KxM26XCIqO9w4y+oo/rUPER3pINzzLIGX/gNT15h76p8x4xHUogrcNcdxVSXCIELdzyBJMkpRGfr8OK7Kw0tHM4kOXkf25INp4nK5OHny5NY/KKaR+ExskAzjdkCCkZCHhvt/ibPyMLGRrkTSylIohqQoicAHdL7/o//g3nvvTSq4g4OD6LpOQUGBVXgybQjTbTx1XWdoaAin04lhGGmlBr29vfT09PDhD3+Y8vJy/uEf/oGjR49uyuXaxdbD5XItq1G5bjRXin/Ptf5pmmbJmUWzLJ0Xm6qqSVO/yclJuru78fl8hEIhXnrpJWvauRbWw3ohvC/27t3L6dOnN6TefPSjH+Ufv/glvM1vQHP7uNDVzX/+4n9g6n9BYUEhZXtLeNe73sW9996b1HgTQx7hj7kdU17DMEBevgyQMFGWFuOmqRObuMFb3vo2/u2r/5r2OzRdsvNGMT5mZmYsg+J0UoMrV67Q2dlJZ2cnP/vZz3jkkUf47d/+7Y28TLvYRqjq7eGkQK51yzRNbt68ycTERNpEvdUcZ3Bw0EoH9fl8ab2IhMeMYN4Fg0GuXbtm3bvXrl1LYj1s9XBM1Btd1zd8qOlyudKm+qWme4p1kEisGxoaYmJigpMnT+6IZpFYI+cq3Vop2Vkkuq6V8REKhRgfH6e+vh7DMMjPz7ekurquW3LWzs5OWlpaePvb384nP/nJjb0ou9g2yLK8rE6sZt1iH46mC1USybkrHVPYl4hmuLg/7WvAVMsN0Zibn5/H4/HQ29vL+Pi4tQbc6uc9m5JrvUiVnIvwO7EP1DQtbe0X9ebIkSM7IuU0HA5z/fp19u3blzRQzQQRrLNRyc6pqq9YLGbJ9U3TtNKzxbmFQiF+9KMfMTExwalTpzh06BDf/OY3t50xaccrotGWDittNO3GuceOHcs4tVtpoSU8jYTkSVaU5Sw1xYHsdFPyax/CsWc/4d7nCfVdRgtMoy/OEOp+BjBxVjTgrmleSiN9CtnlxVFWR3y8D2d5wq9MkiRisyNIsoKj9ABe38YUIjuLYyXvC8Mwlph2aa9IIgihuhlPdTOQYLqVv/N/ABKh7ouEb76UeM+ShJxXhKfuFNHh9uTDGAZKwV7y6s8QePkn1NfXb3mTzTCWPOdSFvGmriEhJdJfb74Esozn8HkUt4/YaDemaSQCEGQFbXqIg4cO88yldouJkq7groXxAdDT04MkSZw6dSpxbmmkBm9961v56le/yje+8Q0KCwt3xMR8FxuHdPdGLhvE6elpKzY9kxRRUZQVJ6PC06i6uprKysqcAg8EDd7v99Pa2mrVGyEFTMd6EHTxzYKQpm+UdHV+fp7jJ04yOz9P8ev/EFdZLQB5B1sB8F/5d+ZvvEDIWcwn/5//ifkXn6J4zx5amo9y9913c8899xCLxaisrKS+vn5bFgZaXMNlpvn8DT0R+jLagxmL8IlPfIKPfexjOR0zG+Ojr68vZ387WZatRbFoCqSTGpw5c4aWlhbe/OY388ADDxAKhdZ1TXax85HLoCEYDFopkZkS9cQmMxuEp5HP56O1NfFs5xL4MjY2ZnlYinojPGhmZ2cZHBxct9xoNRDS9K2Srqam+onaPz09zY0bN4DEACcvL4+TJ09uOyPfbuy+VqYzLGd8QGLzKtZ/fr8/Z8aHGFbY/axSA2aqqqp45zvfid/v5/HHH2diYmKNV2AXryZommZ5+aYbsgqItWSmtZeu6/T09BAMBjl9+rQ19F/JN1CwVO3+36ZpEggEmJ2dtYZwgoRgT7jcDAgll0h53mxpupCB2/eBgoAxNDSEpmmWDPj48eM7wvpC2KkcPXp0XWGTqWxnUftXSna2Q5ZlIpEI165ds9KxM6m+/viP/5hvfetbXL16laGhoR3VZINXcKMt20ZTsBby8/OXSQ5Wc5x0XkQgEZ8ZQi2qsIUhOAAJ9Diyw4336L14j97LzE/+DnftKbyNdxGd6CPU+TSLbU+CrOAoq8NdeZjYRL/l0wZgGjqSrJJ37HVoM4PEMza8codYKJaUlOTE4ohFI4R+9g8o+XtxVzfj2n8M174GWCqUqbBkGJ588lveRH7LmwAY+cL/gefA8aSCZho60aF2jMgi7vKD1s8nJia4du3alqT6CYRCIVCdjD72gUToQ3Uzrv1NyC4fSBLBzgsJGa9ponqLMeJREs3EZzFiITAM3vimN/Ltb30r6+ushvEh0vbi8TjXrl2jrKyM6urqZbJBcRzTNPnhD39IZ2cniqLsCFr2LjYfwl8tHTRNo6enx4oFz9ZUz1b/RLNsdnbW8iLKZYFlT5RKrTdOpzMp4U2wHiYmJujp6dkUg+1UA/KN2Mz+/Oc/53fu/98xPIXI7gLmfv5FZLcPtbAC5/5jicCXwCTF9/0BrqU6pwfniE30c+Hlizz55JO8+c1v5tOf/jThcJjLly9vaaqfQHFRPmM//ltUX3Gizu8/hnNfA6auER3uwClpPH3hF5w+fXrNr7EaxofwXgPo7u5G1/Vl0oXU+tfd3c3jjz/Oxz/+cWvauYtXD1Y7aLAn6tl93dYC4UV05MgRiouLrcV9tmdTsIgVRVkmlU9NeBOsh9nZWcv82d542wiZvfDaGR0d3XJpuh322i+kvKWlpZimuaK/52ZDhNA4nc5N8YdbC+NjZGSEkZGRZYPxVNbv3Nwcn/zkJ6mtrUVVVcuYfhevHkgZ9l6ZINhndXV1VpMrE0QtTbcuEr7m+/bt48iRI5an9EpDVhFokiqVF1YiBQUF1NbWJu2FOjs7iUajSR6XG2UHkYuSa7Nhr/2xWIzr16/jdDrxeDz09PRk9ffcbIgQmtnZ2U3xh0td92eS2YrvPmER0tnZSWNjo7V3Tqd60DSNT33qU0Di/qqpqdnQc98IvCIabeke6HQTTXsSXmNjY040zEwLNhGjnOpFZBo68xe+wtx//RPO8kO4DxxHdic60aksMElxgJE4R1f5QWvDNfKFP8BZWpf4JVkGJExDIzraTXx6EMVXkriZJJlQKMTQ0NCam0+Tk5P09fUl3awrIc/rQ7n73RiRRcL9v7RSQjE0zIIyTNNAknJZiJjA0vkuscdCXRcTjDGnB8mx9DDbPJ42O9XPjmAwuBSG8FlC3ReJ3LpKqOvpxHtVVNT8UlyVDYmGGyR+jgSSRF7Dawl3X1yxyZYO2Rgf/f39BAIBYrEYFRUVK24SPve5z/HUU09x/fr1dZmb7uKVhUx1SyxYqquraWpqWvGZyeRRafciam1tTfKMycbiEBu6XBOlUlkPYgMyNjZGd3c3DofDWnispfkkrAPERGwjashDDz3El/7p/8XX8uvkNbw2kdQcWSQ2eZPQjecIvvgDTMNAcuURbP8v9MAM7toW5LwijFgIbWESVCeLi4tUVFRYC9GtSPVLxY2uDgYHB/nyl7/Miy++yIsvfovxn8+ArlFbXcUzly5ueDBNNsbH6OgonZ2d1qS7trY243FkWeaJJ57gz//8z/nud79LS0vLhp7nLnYuMjHaxFDR6/WuOGTNBiF5ApK8iFYaMogNXX19fVqZVipSWQ92g22RbLee5lM8Hqe9vR23270jDMjFGn1kZIQTJ04kSbdEql8q62GjU/1SIZiPgum3FUhlfMTj8SRv03A4jKqqHDx4MGvdHxgY4IEHHuDhhx/m/vvv35Jz38XOgCRJVnKjgJ19ttKQVSDdGlBI7icnJ2lubiYvL8+SymerfyJgpaSkJKdU+dS9kPC4FEmX620+rUbJtVUQDaTUpp9hGFbzSSif7Gy/zTp3TdOs74hTp05tyYA3nepLeE+OjIwQCoXQdZ3a2lrcbndGaXMwGOQP//APOXLkCNevX9/0814rXhGNtnRI3WiKRBOXy8W5c+dyXpAoikI8frtBZvciEuwH+wLL4/Xheu27kfOKCHVdINR9CX1xDiSJ2GQ/zopDyK7ExklSnOklmJKy1IBTMXUNSHiZYZo4yuoxo4uJ3zMMK8K+r6/PStUQRSeT1w3cLrixWIyzZ8+uepEiq07yjt2H79h9iVOJRRj75z8mPnWTsS9/AGdlw5IXWyMAZiwCnvQbsujkTbS50cRbd+XhqTtDuPsSpmEQHngZkJibm0ub6jc7O8vNmzc3pfG2sLCAJMuJ0Iczv0nBmd8EIDLcycxP/hZPbQt6OJD4bKeHiA61AybeI69FjyxuWEGyMz5cLhehUIjjx48TiUQYHBy0GB9i0enz+dA0jQ996EMUFBTw4x//eNtlF7vYPOQyaDAMg97eXhYWFqxEvVyQWkftbJBjx45l9CJKhUg0FbT8tW7oUjcgovk0MjJCV1cXTqfTqn+ZvG7E+xAbOvE+NgJf+tKX+F9f+jKyy7tUD8BTdwbZ7UNbnCE2OYC38W7yjtxJfGqA6FgPwbaf47/8XSTFgWnoeOpPExvv5xeXnqO0vAJ3no8//chDPPzww0mpfiL4xN50FDVgI/ztxGJ6bm6OT3ziE1YNicViPPnkk7zxjW9c38VaBQTjo6CggLa2No4cOYKiKEmhB+K9FxQUoKoqX/ziF/n+97/Pz372s5yaGrt49SDVDFxYfAwMDKw7Uc/OBikvL0/rRZQKkWi6uLi4rg1dqsF2avNJmOMLg+1sNUAw5g8ePLgjAgaEwbYkSWm/I7Kl+ommoz3deCMab1NTU/T19W1J0n02OBwOysrKKC4u5vr16+zfv5/CwsKk0APx3gsLC/F4PFy4cIGPfvSjfPnLX+bcuXPbdu672B6kSj6Fxcf+/ftpbGzMeX+UugYMhUJcv36dkpISWltbc7IKsUvl12PNYfe4rKuryxguI9aA2fY94XDYavptlB/veiCk6VNTU7S0tCyTydo9LIGkpmNHR4fF9ttIma0YMhw4cMBac28HBNuvuLjYCrmsqanB7/enVX3l5eUxMjLCu971Lj7wgQ/wwAMPbPvnmw2v2EabfaM5Pj5OX18fDQ0Nq6aF2otMLl5EqqJiajGce6pw3vlOALSFSSa+/mcE254k8OIPUQtKcdWcQI8EMCf7ic+PoxaW3zaMlGVMPU5kqJ/49C1AQvYU4K47jT4/RjzsJzreR2ysB8Xrpbq62mo+CeZTb28v4XAYn89n3aAejwdJkiwWhzAzXO0NmI6mLDvdyG4vjr01FJx9G6Gupwm2P4X/8nfB0Jn42v+F4ivGXX0cV/UxXPuOABAeeAkjOIecV4ARWrD8iwAig9cTzDhTX/a52VkP9sabPVLY4/EkGcyu5n0Gg0EuX74M8vKFqqSoliwY0wATosPtiTCEib7Ezw39djrsBsA0Tfr7+/H7/UnyNjvjY35+ntHRUd7//vdbk6YHH3xw26fUu9h62OuWoPdXVFTYJO6rP46dDSIW7rmwOARrtqGhYcNZlW63O6n5JJhPw8PD+P1+S3JYUlJi1QDBRnE6nRvO4tA0DbWonMI77icy3EGo93kCL/4wUUe0OO7603iPvg7Z6UapOY675jjxuVHmnnwMIxbGWX0cNX8vsfE+PAdb0QMzRMZ7eeqpp3j44YeXvffUVD+7zFZV1ZxT/VIhmC55eXnLpphOp3NLm2wCk5OT9Pf3J8nbRAPN3nD4+Mc/zqVLl/B4PDz66KO7UtFXOdLVHvvPhMWHqqqcP39+TZJDsdbr7e1lcXFxVV5EQipfUVHB4cOHN3TBn9p8Eswn4XMmNmf2cBmxlpibm9sxLA6xJl0NayxTqp+Q2dr97VZK9UuFuEYieXonDCqDwSDXr19PSl4V793u8/v444/z2GOPEQ6H+djHPrYrFf0VQLo9mVi7KYqSZPGxWoN/cRy7IqypqYmCggKr/q1VKr9epIbLCNbX7Oys5XOWLmBgLUquzYRYb3k8npyYfpC+6ZhOZrvWxptYbx07dmxH+MPF43Ha2tqsBFtJkigpKVmm+rp06RIPPfQQ0WiU+++/n7Nnz+7oJhu8QhptmTw6YrEYV69eBchq9pgNiqKgaRo3btxgZmZmRS8ih0NF02PJ56c4kBxOCu54B576M4S6nyXcf4XY1AASELn5Eigqrn2NuA+cACB04wUkwFlxiNjUAO6qpgSFV5LQQ/PooXkcpbV4zGDSdUj1ullcXLTkCpFIBEVRiEajNDU1rd2vK01AwNIZACbOslqcS8bfACNf+iNKf+tjxCZvEu67QvjmiwmZpWliREN4j91HdLgTI+S3vYaB7PTgOfwagld/suKDni5SWGy67ayvlZKd4HaBSWxgpYTMy/67ejxBy45HiQxeB0y8TfdgajHik/2YWpzocAdGDmlluUDXddra2vB4PLS0tKS93wXjY2pqing8zqc//WmcTif//u//zt13370h57GLVw5UVSUej9PX18fU1BTHjx9fE2tLLLLEsGI1XkSp3mdbsVlJ9boJh8OWsXggEEBVVcLhMDU1NRw4cGBTvoAlxYH7wEncB07Cne/EiIaY+PonUMvK0WZHmPz2o8guH0r+XtSicsJ9l1GLKjG1GIpYhJomoRuXkVUVpaA0p8VxOoPZlVL90kHIggVjZ7sh/EHm5uYyeuiJhoMsy4yOjvLe976Xc+fOcfHiRZqbm2lqatqGM9/FdmNiYoIbN25w+PDhNbO2JEmyjLv37dtHQ0NDzlL5oaEhxsbGcpbKrxeC+ZTqcSlqgEgiLyoqoqWlZUt9zjJhbGyMW7durdsfLluqn93nZ6VEV7Ghy8/P59SpUztikyYap5mukfD5zc/PZ2xsjNbWVj74wQ/ywgsvcOXKld1m268gVFVlYWGB/v5+ysvLOXfu3JruZUVRiEQivPTSS7hcLmtYm8uQQZjnbxVrNpX1lRouIxqGiqJw8uTJHTGE8/v9dHR0rHu9lU5mm+r1bQ/ZE8SbVJimSV9fH4FAYMOTp9cKMWTIdI1E78Pn83Hx4kVKS0v5y7/8S/r7+3niiSdobm7ehrPOHdv/LbxGhEIhy+x2PZTHaDTK2NgYNTU1nD17dkWarK7raAsTCZ8xZenyqQ4wdEwtjuzMw3f8DfiOvwH/5e9hGjr5rW8nNtJBqPsZAi/+ENM0kT1ePAfPoS9MABKmSH5b2uB6m+9D90+jL/iXnYOAvfG2b98+Ojo6MAyD0tJShoaG6O3ttTreJSUlOU82g4uL6E9+idD+owmGWlUjSkGZ6LMtPw9ZQvHtwVdamyw1feyP8DbdjSwrCL820zSJTd7EiIZw1y2Zzpqs+mGXJMkyvq6qqsI0TUtmNjQ0lLbxJklSUoH54Q9/CIbG6Jffj7P8YEIKu68RQ4slGHSdF0BxgCQju/LQ4hFM0yTYeQETcG+AWaWIUt6/f3/WSa9pmvzgBz/gM5/5DF/72tesjeU73vGOdZ/DLnY20tWhaDTK7OwsBQUFnDt3bs0yZl3XCYVCTExM0NramiRHyCVRaqsS7DLB4/FQVVXFvn37LE+R6upqAoEAzz33nCU3Lykp2ZCAlbTpmK48JNWF9+jryDt8HiMaIjbeS2TwGsGOX+CuPYWjqJzFa4laH58bQw/Ng+rE03g3seH2NbHuVkr1sy9KCwsLUVXVSl7dTlN0O3Rdp6OjA4fDQUtLS9b7uLOzk/e973188pOf5G1vexvAtjDvdrH1SGV0xONxwuGw1XRYa5PfNE1isRidnZ3LvIhWksq3t7fj9Xq31fvMXgOEr3BlZSWxWIwrV65YPo8lJSVbFrAiIAYxmqZtONMFckv1EzKzoqIiXC6XlbxqZ41tJ4ScbGZmZkVm3fz8PO9973u54447+Lu/+ztkWebee+/dwrPdxU6BUPj09vZy8uTJdTX5I5EI4+PjNDU1sWfPnpyk8rquc+PGDYLB4LayZu0BA2KAWFxcjKIotLe3b0q4TK4QnsVjY2PLQiE2Aum8vkXjTYShCbmlsJoSQ4bCwsKMpI6txszMDL29vSsy63Rd59FHH6W3t5cnn3yS/Px83vCGN2zhma4dr7hGm/BQ8/v9SdP91UJMI2/dGYWSKQAAIABJREFUupWUgLLSAsuIx1h8+ScEfvkDnGX1uGtO4qw4iKnroKeEIahOjOA8sizjrm7GXZ3ouo79y0O4yuoTPiPitUyD6EQ/sdFuJKcHWVYxJAlDN1JPYRnEpre2tjbpeoiO9+zsLB0dHcRisaTGWyZjSV9+AVr1afTgHIGXf8LCpcdBcWDGwlCYW0dedorCu/QgmyaYBuG+K+jBWVBUZBGGgLluvbkkSWnZLkJmtrCwQCwWIz8/n/r6ehRFQVVVZE8+JW/6b4S7nibU8yyBl36EGQuB4sRRUoVaUErkVoI1aYQDYJooBXtxFFWiTN9Y1zmLSURTU1NWTwPDMPjrv/5rnn76aZ544ond0INfYZimyeDgIMPDw7jdbg4dOrTmYwkvIlVVaW5utlgc2ZpswtcrXaLUdiESidDe3k5hYWFS09Hu8ygCVrxer1X/snlcZoIIxMkG2ZWH+8BJnPuOEOz4BY4iUTNNohN9GKF5kFWcJVXWuW7ERj012SlVZhaNRpFlmUOHDu0IOZmIbhcWB9kgQg++8pWvcPLkyS06w13sRNjr1vHjx9f87IRCIdra2pAkiRMnTuByubZdKr8WGIZBT08PkUhkWdNRyM3tASvrCZfJFeLaVlZWrsm+ZC1Il+gqGm/Dw8OWwXZdXR2FhYWbfj4rQXjWKYqyogn5jRs3eM973sMjjzzC7/7u7+6IDfIutg72z1t4qAEcOXJkzU02TdPo6uoiEAhQV1dnNdlykcq3t7dTWVlJQ0PDtt+LqX689uux0eEyuUKkGKuqypkzZ7ZkEGNPdD1w4ECS3PLGjRsEAgHi8fi6+iYbCdGDmZycXHHIEAgEePDBB2lqauI73/nOK84u6RXRaBMPstAm19TUUFlZyfj4+JqOJzZmeXl5nDhxgo6ODhYWFlb0+ZqdnaWoqAiz8Q24DrQQ6nyKUO+zBF76DzA04nOjGNEgsishA5KW/NyWvR9ZSTTmILFpMw3CN19KeL9VHERbmFr6N4NwJJLxfOzmiuk2vfaOd6qxZFtbm2UsKTae4kaXZAln6QE8538bSCzkYiMdzPzob4iOdjPxjT9PSKeqmnBWrLzR1/xTiaQ9TIxYQkoa7nkW04TISNeGep3ZIRpv+fn5tLe3c/jwYWRZtszFOzo6kGQF5579OO98J2LpFbj6BP5ffg/3/qNo8wkWSmSki/jkTZBVPAdOJnz31LU/7Jmi21MRDof58Ic/TGFhIT/60Y92BM13F9uDcDhsSV7Onz/PCy+8sKbjiI1ZIBDg9OnTXLlyhZmZGYv1lO3129vbKS4uztlnYrMhzPKPHDmyLGU6nc9jMBi0Fh6rCZcRGB0dRZufYOwrf4J7/zFc1c1LfpRpBiI2Bo4RC2MaOmY4gLfxHsK3EiEwpmGghwMsLi5uwNVIhpCZFRUVWebGwmB7cHAQ2JpUv3RIF92eDoZh8PnPf54f/vCHu6EHv+IQDKlwOMyZM2e4du0ahmGsetGd6kU0MDDA1NQUZWVlWVPtNE2jp6eHeDy+poCpzUAwGLT8OY8cObKsfmULl+ns7MTlcuUULrMaCNbsdgcMiMZbUVERvb29KIrC/v378fv91vp3K1L90iEajXLt2jUqKiqorq7O+ru/+MUveOSRR3jsscdobW3N+ru7ePXCHlR19OhRpqamlvm25Qr7Xtrr9bKwsJBVbmh//fHx8Q0NmFoPhD+cqqppmcUbGS6TKwRr9sCBA5a38HbArnhzOByEw2EaGhqIRCJJ619R/zZC8ZErDMOgs7MTgNOnT2f93hkcHORd73oXH/rQh3j3u9+97Y3dteAV0WgTCyy/328l6gUCgWWRxLnAHpxQUlKCrutUVVUxODjI4uIieXl51lRMbLzsiVLFRQXManEcS4bYhXckIrVHPv9ewjdfJNT9DEr+3oQXm66hzY+jLUygFJTdvkEUFdPUiE3eJDrSDVKi+ZbX/HqM0ALa/ASx6UGiwx0oSvobUEgX8vPz12SuCMnGksPDw5axZIJ9lvx37upm5LxCFN8e3AeOExm4SrDjF5ixEJKiMvm1j+OsasJdcwJXVSNqfqKwRUd70KYHkFQnZtzAdzRBdTdNM+F/pkXBNHj729++6s8yF4gknOPHj1s+SKL4Xbt2DUle/ggo7jzkpZ+bpoGpx4lPD+KsPER8eijxS4aOxOofeGG4HIvFVpx0jI+P8+53v5v777+fD33oQ6/IArOLjcHIyAgDAwM0NTUtayitBoFAwGIaCC+ihoYGy+NHMB5EuIAsyxuWKLWREM9RKBTK2R9OkqRlyca5hMvYUV1djVpYTv7ZtxDqfZ6F576BEfYjSQqhrqdBknDtO4KSd5sxofmnCPe/CIaB+9BZZHdeQoWvxwl1X8LnUvjsZz+70ZcIuM12PnTokLXYtDPe5ufnmZ+fT0r1E4vOzWokjI6OMjw8nDZ5y45YLMaf/MmfoOs6P/vZz7I2QXbx6sb8/Lxlpt/U1IQkSZbMfTX3qQhOcDgclhdRXV0d4+PjXLt2DdM0rY2HkCDB7edIDHm3+7vYXpNX09BaS7hMrhA1WTRCd0IjMhaLWUMGwb4RdTA11U8oHkT936zGmwgvSjccssM0Tf7pn/6Jr33ta/z4xz/e9WH7FUYkEuHq1at4vV7Onz+PoijMzc0lJc/nAsMw6OvrY25uzvIjj0ajGIZBV1cX0WjUWgPYyReRSISOjg58Ph9nz57dEUPWTEqubFhLuMxqMDo6ytDQ0I6x5hBD9VgsliTfFx7vYvAsFB8bbbWSDrFYjGvXrlFWVkZ1dXXW13j22Wd56KGH+Md//EfuuuuuDT+XrcIrotEWiURwuVxJ6RIixCBXiM63YRjWDSdkUlVVVZbPVzAYZHZ21ur4ut1ugsEgFRUVnDp1Cp83DyO0nKWGrOBtvJv8M28h1PMM4f7LxKcGwdCZ/MYnE2EIVU0JA21DJzbag2noOCsPEp8cwFXVhKyomJKMEYsQHenCUVaP7B9d9lLCgHK90oVMxpJLbmrp/8bhpOD0myk4/WYAtOAcE1/9KL4zbyU+NUDgyveZv/AVZGdiA6XNDuFpuIP4RD/awoTtSInj5zXfR/Dln274osxeYM6cOZOWqRONRhNSMNNIpJ+KM9M1kCSMyCLRkQ4AvMdej+6fAEle+nkXknN1RTgej3P9+nWKi4tXpFxfvXqV97///XzmM5/h137t11b1Ort4dUEEf6w1UU8cY2BggImJiWVeRPaJn2A8iI2Xy+UiGo1aaUk7YfMkZEnl5eXrki7kEi5j33iJxpsky+QdOkfeoaVkVk1j/F//BC04j//Zb6CHF1A8BTgrl5KX+3+Js/IIsfFeq86YpkF8aoDX3Xcf//69722KhGFkZITh4eGMEt/URaddZjEwMJCU6ldcXLzuz940TWsjfvr06azveXp6mgceeIA3velNfOQjH9kRC/tdbB/m5+etIauAPXk+F4hhgmg6Cy8in8/H4cOHgcQzMDc3x8zMDH19fdZ9p2namgNnNhqaptHZ2Yksy+v2PlspXMbj8Vj1z+fzZay1gm1dVla2I+RkkNiId3R0ZFwnp0v1szfe1pvqlw7j4+PcunVrRaP2eDzOxz72MWZmZnjiiSd2hEXDLrYP8/PzlrxTYLV7YOFhVlZWxtmzZy2rEKfTSW1trWWfJFRPgnzhcrlYXFzkyJEjO8bXcGBggOnpaU6ePLmu53KlcBkRQiIab5nWIbqu09XVhWma2+rZaUc0GuX69evs3bs3Lds53eA51WpFNN5Wqv+5QrD9Dh8+nLV3YZom//Zv/8Zjjz3GD37wAw4cOLCu191uvCIabT6fj9ra2qSfqaqaM6NtdnaWzs5OK9EiU6JU6o03ODjIyMgIpaWl+P1+nnvuOfx+P3owhhGPIjtuT9glWVkKQ3Dja349vubXE+p9jlDPs5S86Y+JjnQQ7rpE4Mr30UMLIKt4j92HGQ0SnxyApTCEhP+PiffY6zCjQbT5Ees1xDRCSL42esIvqPahRT/6c98iNj2Ie/9RnOWHkFQHUpowBNVbjKSoeJvuRjn1Jus8owMvM/vTv8PbfB+yrBK3/WF8fhwzFsFzqBVJShSkjdxIrVRgBPr6+tAWZxh77IM4Kw7jPnAC174jmHocU4sT7LqI5PAgORRkVUU3DNC1pZ+7qajInRacLro9HUzT5Pvf/z6f/exn+frXv05jY+Oq3/8uXl2QZZnDhw+vWSYgGlNFRUW0trZmDXyxMx6EF1JxcTGapnHlypVVSy03GiLBbjNkSfbGm/C4EBsvkeo0NjZGahGUVRXZ6abg7G+Sd+g8hqYR7r9MqPsSIOFpeA1qXiGx8V4AoqPdGJFFPvCBD2wKk80wjCQT8lwXfakyi7Wm+qWDPbr9xIkTWe+bjo4OHnzwQR599FHe8pa35Pwau3j1QjRC7BCMtpUgfH2j0WjSkDVd/VNV1Wo+Cy8kj8eD1+ulra0Np9OZFC6w1fVPsDg2S5YkwmXE4Fk03gYGBizFRyrjQcj3V/Ka3UoMDw8zOjq6ImvWjnSNt7Wk+qWDSPpbXFzMOPgVmJ+f5z3veQ933nknf//3f787ZNgFlZWVy5pqqqoSjUZX/Fvh6zs6OsrRo0fx+XwZA1/sz0BNTQ2dnZ1EIhHKysoYGBhgYGDAev43Smq5GqxFybUapAuYmpubY3x8nO7u7rThMsFgkLa2Nqtu7oQhg7DmWIk1a0c6q5VQKGQNXhcXF/F4PMsCBnPFxMQEAwMDSeqydNB1nb/4i7+gr6+Pn//85ztiuLVevCIabemQSzdfUNn9fj+nTp3K2ezWniglaLrieLIsExm8xtg/fRBHyf5Ec2Z/M0gyppZc9CRFxdTjyLKMp7oZz1IYwuS3/zuSoiKrDvSYbLGqYjMjRIeug6Qgq070WBhjqQEXCoVob2+ntLR00yPJ8wsKCeZVEB3pItR5ASMaxLGnGj0cQFmShGaDLMu4a1uW/nvpFluSo0aG2ojPDIMkISkO0saYrgOrKTClpaW4SuvIv+MdhLoustj2JP4XvoMZi4As46pqAkxiU7cwTRMtOI+px3Hub0IyDAwjyo0bNyyPo0xfOitFtwsYhsFf/dVfcenSJf7zP/9zXRLBXbz6IWTtmRYbpmkyOjrKrVu3aGxspLCw0NqsZg18sUnlz5w5Y0lo7IxfwUwSjK/VpBqvBcK4F9iUBLt0kCRpWZz65cuXMeKx5NTpxG9b/yWrKt6GO/AcOMHYP/83VJuMNDJ0HbcicenpC7S0tGz4OUciEa5fv055efmKtPyVkC7VTzTeRKqfnfGWqfG2UnS7HT/96U959NFH+cpXvsKJEyfWfO67eHUh3X2cC6Ntfn6ejo4OS/KZachqh12W2dTUlGScH4lEmJ2dtZLNBeNrM6U24pwGBweZmJjYshAae7L7/v37lzEeFhcXrXTCo0eP7oiAASGBMwxj3Sbk2VL97Ixn4fGUqfGmaRptbW34fD5OnjyZ9R7p7e3lD/7gD3jkkUd4xzvesSM27bvYmVBVlWAwmPV3IpGIde8Jf79c9sDz8/N0dXUtk8oLuwmxp8mV8bUR2Cgl12qQ2nhLDZcRqdWHDx+moqJi259XkXQ6Pj6+7jRYe+NN1H9hNSAYz8JqIJvHp2ma9Pf34/f7OX36dFZlRCAQ4H3vex/Hjh3j29/+9o5gBm4EXrGNNlmWl0047bB7EZ05cyanBRZkT5SSZZnGxka6g27y77ifUOcFIgP/P3tnHh9Vebb/a5bMkkkyWcgKCYEkZA87WlAJWGvrq7XV+nZ5RVRKVerSolbrVv3V5a11e621tSoqIiK21tZal4CAglVAULISsq+TZfb9nDnn/P4Iz/FMmMyWmckwnO/n0z8ah8lzTmbu8zz3cl1HYW/eA452wWPSgXGYeX0eiSwJYE7dCEpkSQBxruMYgOPgHmwDR7uhyC0Bre8/+Z88YBgGOp2O12eKxWZGKpNDPX8ZksvOBgB4bAY4Wj8BPd4HaqQbhoY/81psspSpkkFfJ9AYpxUemwHgGHhMI9BUnANHxyFwAKiR7oiYIQitlIOtYrrd7omR3twSKHNL+J8bP94GR+chKLLnghrpAiCBs+sLMNZxQJEMZXYx3LoOZKZrkZaW5jXfLxQXl8lkQVu3O51O/PznP0dmZqZoeiByChKJ5JSONtLR4evh5kuLKFhHqZaWFuTl5aGsrGzKjl8yajlZ44boe4Ta8eQPi8XCH5bJiNNMIJVKJ5I/bhuGXrgBiuy5UBYthHJOpZfxAQ/H8fk3xm4CWA8WFJdh/yf7onJQJp0XoVQxQ8FX4o24+pHEm7DjTalU8pvjmpoav+5oLMvi2WefxbvvvosPP/wwLkZUROIbfx1tpPvfYDDwWkTBxD+KotDa2oqkpCSfCX2VSoWCggIUFBR4dXwJXY1J4i2Ujid/kFiu0WhmVB9JePDKyclBY2MjUlJSkJycjN7e3rDMZSIJKTLk5eVFxenUl6sfSby1t7fzGp8k/iUnJ/POyiRh4Y+9e/fizjvvxJYtW7Bs2bKIrl3k9MbXZzlQRy/RIy8vL0dGRgZ/XvYXA1mWRXd3N6/hNvkcNVlugqIoGAwG3mBOoVB4afxG4jsoLPxGY5IrFIi5TE5ODtrb2+FwOFBYWMgnn8j1R9JcJljI+CowYTAQ6SSVsPBCOp4nF54mJ944jkNzczNUKhUWLVrk9/PQ29uLq666CjfddBPWrVs340nLSHJaJNp83XB/1cienh7odLpTtIj8feiFjlL+xLWTk5PBeSjIk7VIW3oJ0pZeAgAYfGETaMMgdNtug0ythbKoFrJkLRiHGbRhEPKMAn7NEpkcLEOBNung6vnyZLcXB03VaoBjQI/3gjIMwt3XCHAcRkdHY6qPNDEi+vXBUZ6SibTll8LW9glkSUpwHAvLobfB7DNBqkwGOBb6d5+Eat5iqGZXISl77sl/LwGlH4C7v2kimSaRIrl6zcm/Awf3QCtYp5kfmw0XYYAJpYrpcrkmdaVMIFVpIJUJzBBcVrAcg6TsYjBW/cSLWAYcx3nN9wsdbTo7O+F0OqFUKlFSUuL3s6fT6bBu3Tr8+Mc/xs9//vOECjAi0WMqMfCxsTG0t7efokUUqIuDOEqR8YJA+Or4IuYqfX19vMYX2XiE2oUmXFOgdvNYsXr1ajR9+QWOHj2Kzz//HA0f7cGJDxrAuF2wHn4HHssYHwNJBKVGe+AeasMN11+Pxx57LOJrIvdpZGRk2lXMUCBSAySpxzAMn3gdHByE3W4Hx3GYP3++32eX2+3G5s2bwXGcaHogEjRTdbQRLaLs7GwsX7486CIrSQqXlJQElej11fFFzFVIx1NaWtq0xPXJmsrKyviR7pmGaFgKE/pCjUuhuUy4o5bhrimW46u+Em/k+js6OmC1WkHTNGbPns0fOn1dP8dxePHFF7Fz5068//77M1pMEjl9mCr+ET1yjuOwfPlyyGSyoOIfmZrKysoK6ARJUCgUXq7GkzuepiuuH8tJrmBxOp18Qp9IE82ZM4f/b5PNZYSJt2itn6ypoKCAX0u0kUgkXlIDZB3k+s1mM9xuNzIzM5GTkzNl/AOATz/9FJs3b8af/vQnrFq1KibrjyWnRaIN8N3RMRnyYdNqtVixYoVfLSIhoThKpaSkgPOcaoYgU6dAnp6PzAtvgrPz4IQ+W9dhgKYw9taDACbc6FTFi8B5KHiMQxNOlrkloEY6ocwvhVShAks5wTEeuPuaoMgrg2ekE7W1tTENMFJfYmwnfy7TpCPrW5sAACzrgav7KIwNf4ZMkw5nx0HYvnwPnIeGIrsYAODub4aqaCE8piF4rONfB2+OA0s5kVx5HhzNe8JeqzDAhDofbzKZwLGeU8wQ4KEgkUrhsepB6ToBWRKSK1dPiJlLpROusKPdcKSVeL0fqfakpaXBbDajuLgYGo2Gn3EH4NXxlpSUhC+//BI33HADfv/73+Nb3/pW2PdB5Mxj8kaLFAtcLhefmA9lVH66jlJCc5WSkhJ+1NBgMPCulmTTEUjfg6IotLS0QK1Wx43LFU3TaGlpgVKpxCWXXIJLL70UD5/8b4cOHcJbb72F9xt2o+vYB2AoN5JmFQEAmNEOPP77R7F48WIcP348YuYCwERyq6WlBXK5PCqaJaFAxki0Wi1vYFRQUMA7RtI07SUurlKpeNODiy66CLfeemtc/J1F4o9gOjpIwnlgYADV1dV+tYiEMAyDjo4O2O32aXVMTDZXIRpfBoOB//wH2/HLsiy6urpgNptnvIuDwHEc3+3ia02+zGV8jVoKzWUisaa+vj6MjY3N+H0SXr9UKoXb7UZVVRXsdjs6Ozv5jj8S/zQaDTweD+68806YTCY0NDRE5J6InBn46mgjurqB9MiFEImR/v7+aU9NCc1VhKPm5PNPXN1Jx68/Yj3JFQxk4m2qUflImcuEAinGxINGJrn+5ORkWCwWVFVVgWVZftQ2KSmJv36icbpt2zZs2bIlIUwPpuK0SbT5g2hqdHd381/KYLWIenp6oNfrg9a9kEgk8NgMXiOiwMQ4KMfQE/o85SuhKV8JarQLhl1/Qd5P/hfuoeOwt30C69F/g7EbT3awnQdIZKBGOsGdXC/HeAAO0FSvBsCBHumIeRbfZDSCadwNzkNBWVABmTb35BokXvk3qVSO5JLlMO3Zgoz6ayBVTXTB0MYh2Jr3gtKdgKbqXEgVyaCNgyBzVB6rHpyHgrr8Gyc7x/xrTU3FdANMT08PqOGOCTOE/DKo5i6EsqACrMcN1mWDs/MQJIpkSJOUE2tjmYmf9xyFRJGMBQsWnPKevqzbfbn6vfrqq9i6dSusVivuvfdeXj9BRMQXgQ6aRIuosLAQFRUVYBhm2qPy02XyqCGxUh8bG8OJEycgl8v5TRcRlgW+7k4oLS3lvzszDXFLKp7CSn758uVYvnw5Hnlk4v+3tLTg5Zdfxr6PP8a7//oXZs2a5dNcgHT8kcR7KBCTC2FFcabxZd1O4qDQ1W/v3r247bbb4PF4cPnll+OHP/yhmGQTCQmhGDjRItJoNFix4qQbcBDxz2q1oqWlBfn5+RF3yxRqfBFxfVJ4IB2/JOki7PglDp6zZs3CkiVL4qKLg6Io3sxk8eLFQX1XfXV8TTaXmU7HH8MwaG5uhkKhCLoDJ9oQIxqGYfjpiszMTF5c3G63w2g0oqurCzfccANsNhvKysrw8MMPx0UyVSQ+CaRRyTAMTpw4wY9XKhSKkEflSfdbJNc8WVyfuLpP/v5nZmbyn38yocSybMz0eANBxlftdrvfibfJhGMuEyxkes9gMMx4kUHI4OAgBgcHvaYryNi8y+XiNe42b96ML7/8EhKJBE899ZTPfXWiMPOf4GkgkUjgcrnQ1tYGmUyGFStWQCqV8rpFwbTJZmZmhtwJwFj10L16G2SadCiLaqEqrAUHnNLpNqHFNpFAUxaUQ1lQDgAw7P4L6LFeSBXJ4Dz0ydFRFh7zCJzdXwLgJrrbaJdv7Z8ok5qaCqOHg/WrD2A+sGNCx2xOFViXDZwmcEIrKaMA6d+4Ao6mXZAqSPJy4jrcug5QwxPue1KpnE/cHTx48JRstz+Rd6H2WbgBJj8/H+rS5UiuXA1H2wHYGnfD8tlfwdEuQCKFunQFPMZhsLQTHMuAsRnBMTTUC1bCM9Z7SkUmkHU7cfXLzMwETdMoLi7GddddhyNHjuCtt97Chg0bwroOkTMTuVwOiqLQ0dEBvV7PaxGRLg5/8Y848TEMg2XLlsVkLH2ylbpQWLa1tRVKpXLCdMTjCcktLppwHMdvHEIZX62qqsKjjz7q9bPJiUdh4r2npwccx3kl3vxtMMfHx3HixIm4ESEHAlu3Cx3Njh8/Dq1Wi9tuuw1DQ0P44x//iN/97nczsGqR0xW5XA6HwxGWFpHQXIB0v0UbqVTqNWpNvv+k41cikUChUMBqtaKqqipuzJCIwdR0Cx++pAZIxx/R+CQdr8KDty+II2xhYWHcjFpSFIXGxkZkZWVh7ty5p3z2hBqnLpcLAHDjjTdCpVLh8ccfx/PPPx+zsX+R0x9SaCXF/YKCAixYsCBqo/LTZbKru7Dw1tTUBJqmkZycDLPZjLlz507bzClSkCJOVlZWQJ0xfwQylyEanyT++dO49Hg8vPZZsIWPaEPMJ91u95QSTiqVCvn5+dBoNLDZbLjwwgtx9tln4x//+AcyMzMTtuHktEm0+RodZRgGhw8f5jcAJMD4S7IJHaUqKipC7oQqKSmBPDULsy6/D84Tn8PR8TlM3a+AdVjAadJBm3SQkw4wqRwc68sMQQHupBkCx06YIVCjPeA8bijyykANt0/8Nw8NjuPgdrtjmq1OUiiRUlEPTcU5YFkW7oFmOI9/Co6hQRsGYTn4FpRzaqDIne9T42xi8QDpYGMpF1iHBWBoUCNdUJeeBVfPUQCSk51uwNlnn+2V7W5ra4NCoeCDDmnHj2SAoSgKElkSlHmlUOaV8j8f+9fj8Fj1kKdmTTiksizsrZ+Ao5yQpuVCrkkHPdrFH7pDsW53Op3YtGkTZs2ahXfffRdJSUm4/PLLw74GkTMXUvkrKCjAsmXLojIqH02IsGxeXh5cLhe++uorKJVKKBQKfPnll0hOTuYPprEW1gYm7m9rayskEgmWLVsWcXFZkngn2ksejwdGo5HfeEkkEq/Em0wm8xrfCqWyGm1GRkbQ3d0dMBnJsiz++Mc/4r333sMHH3wgmh6IBMVU2lbDw8NIS0sLSYvI5XKhpaVl2qPy00X4/SexxuFwICMjA+3t7UEXHqMFKWiOjY1FpfDhq+PPYrHAYDDwB29irpKZmcnHurGxMX58Ky0tLaJrCheiC1hSUhIwGblnzx7cdddd2LJlC5YuXQoAuO6662KxTJEEQiqVwuFwoKWlJSQ9cjIq73A4ZrQTSlh4Ky4uRm9vL4aGhjBr1iyMjIxAp9MFXXgflXimAAAgAElEQVSMFiQZWVFRgYyMjIi+t6+OP9LxSv4+k81VJBIJ7HY7mpqagjJYiRU0TaOxsREZGRkBO8N7e3uxbt063HLLLbjyyishkUjw4x//OIarjT2nTaJNCMMwOH78OCiKwtKlS5GSkhLUBouIRMpksrBbUic02mhI5QpoKs+FpvJcAIDurw+AMQ5j7M37IZHJoZhTDUXOPHCUE5SuE0k5xZBIJw5qEnnSRAebVQ9n1xcTb8wx0FScC4lCBWroOGjjMFy9XwEcy286hMLi0exAmbiFE0lNqVQKdVEt1EW1GNrWAQnLwNXfBHvzHrCUa0KHiGNh2r8d6nmLoSgoh0ydxv97j2Uczu4veHMETfUaSOVJADi4BlsnzAVOJlBJtlvYZmowGHhhyaSkJDgcDsyZMwfz5s2b9sF7wnX01PsolSsgIwlE1gPGOg5ZWjagSoHk5GeG89B84i9Y63adTocrr7wSV155JW644Ya4qNaInB4IPytEi2h0dBSFhYV8d0CgDVYgR6mZgoyvCjczwmof2XQQYe1g9D2mi81mQ3Nzc0w7JuRyuZejFzFXIa7GEokENE0jJSUFdXV1ceFMLLRuD2TY43a78ctf/hISiQQffPBB3Iw6iJx+6PV6HD9+HCqVCjU1NUF3cYyMjKCrqytqzrzhQGLN7NmzUV1dza/f7XbDYDBgcHAQra2tvLB2ZmZmxPR9poKmaTQ3N0OtVsdM+1F48AbgZa4zMDAAj8fDu2fX1dXFhTkO8HXir6amxm9npND04L333oubTjyR+Gfyd53IRrAsi+XLlwddZCWj8qT7LR7OICTWqFQqnHXWWXxBU1h47Ozs5DuCicZvNGMS2deYTKaYJSOFHa/CUVuhuUxSUhKcTicqKirixhzHbrejsbER8+fPD1g4PXDgAG699Vb8+c9/xsqVK2O0wpnntEu0mc1m/gBEURRomo5pm2xaWho4hj7l5/JkLeCyIecnvwM12AJH235YjzWAYxmMv/sEOIaGIrcEquJFYJ02sHYTnJ2HoMiZD0p3AvLMQkhVmpNdexxcPV9BWVgFd18Tli5dCoZh+E1Hb2+v15hRRkZGxLotWJYF4/H4HFmVSqSQpc9C9nfvAAB4LGOwt+4DPd4P2jAA91AbWKd1YqR2diUAwNl1GIq8MjA2AxiH6WSSDQDLgXGYkbzgbDjb/+NzLSqVCgUFBSgoKMDo6Cg6Ojowe/ZsOBwOfPbZZ1Cr1fzBO5yNp8FgAOfRgGNZSARBm/PQgFQGaqwHHvMopGotkktXwNF5GBKJDK7BVrB2E84//3x88cUXQVUWjh49ik2bNuGxxx7DBRdcENI6RUQILpcLzc3NSE5Oxrx580DTdEij8qE4SkUbhmHQ3t4OiqJOGV/1Ve0jY0atra1wu928sLiw2yESDA8Po7e3F9XV1UhNTY3Y+4YKMVfJzs6GzWZDY2Mj37l95MgR3nyAGBBEuuMuEEQjKRjr9rGxMaxfvx4XX3wxNm/eHBefP5HTD5Zl0d7ezo9X9vT0wOPxQCaTxd2ofCCEY+m+xleVSqVX4XGyvk+wY0ahYrFY0NLSwguqzxRCcx3SMZGUlAS1Wo3W1lYwDMObS0W7+OwLopFEuov9/X6apnHHHXfAYrGIpgciYUGSzIODg+jr60NlZSWam5tBURTkcrnfZ+pMjMoHA9Fr9HUun1x4pCgKRqMRIyMjXh2/womnSOB2u9HU1IT09PQZ1cgUjtoWFhaio6MDJpMJs2fPxsDAADo6OiJuLhMqpAgcaK/McRxeffVVvPzyy/jXv/6FoqKiGK5y5jltEm0cx/FaRHV1dVCr1UhKSkJ3dzcoioJWq0VWVtYpD1wiYmiz2bzE+cIlOTkZLOUEre+HPHMO/yWUyBQTZghSKVSFNVAV1oB126HbeisKNvwRlH4Qjta9sLfsA2s3gmMZqMtXQp6sBTXSwY+YEp235JMmAu6+RgDgRVWF+h5GoxF6vd4r25+ZmQmtVhtW0CGz6FaLBZ6Og5CqUqAsKIdUebJyOCngyNOyoT3rB7A37kL2d38FqSoFrIeaGKk98dmEzlnZCsg1GXB06Pl/xzjM4FgP1KWrIEnyf0AmY5lWqxXLly/n/7ZEWJLoG4UjLDk6OgbnUCMc7Z9OJEGL6qCcUwXO44bHpAPH0JAkqSBLPVn5ZhnQxiGoVSq83/ABOI5DRUWFX40kjuPw9ttv4/HHH8fOnTtRXl7ud00iIlNBtIgWLFiAzMxM3s3s4MGDU7o5RdJRKpKQLg5iRx7ouyoU1iYdfGTMiHQ7TLfjl3RKezyeuBHhBbzHMoUbZLLxHB0d5TeewsRbNJNZxO15zpw5ATszWlpa8NOf/hS//e1vcckll0RtTSKJi0QigdVqRVNTE29c4PF4oFKpcOjQISiVSmRlZfksuplMJrS1tWHu3LnIy8uLmy6OlpYWKBSKoMfSJwtr2+12GAwGvtuBHLoyMzPD2udyHIeBgQEMDw8HbQ4WC4j24+SOiUiby4QCcXtOSkrCokWL/MZao9GI9evXY/Xq1Xj22WfFIoNIWBBDEmJcIJVKkZ+fzwvKk7PP5G4vMiqfmpoaNw7upGPMaDQGfS5XKBTIzc3lk/9EaohMPEXC0ZMk/qJhDhYupMig1WqxbNky/roibS4TCiRxOz4+zptvTIXH48F9992Hvr4+7Nq1K26SvLFEMln3bBKxV+KfgpaWFgBAcXExOI4Dx3F8F5vQzcloNILjOH6meWBgAPn5+RETVjxy5AjOrV87oU3GAYrZ5VDPXQRn9xFQw+0o+Omf+NeytBvDW27E7Oue93oP65F3YWvaDU35ROuk9eh7kGfOQVJGPpzdRwCJDKl15/OvNRqNATs2yKHLYDDAbDZ7ZfuJja4/SMdfeXk5lp29EuM2CmA8E+6qqVlQza2D4/h/IE/PQ85ld3v926EXrkfelY/xrqMT1+7C8JYbkbro2wAAx4nPwTgtUBYsgLu/BeBYaGrWApDA0boPNov5lDUJA8z8+fP9XgMZNSP3wG638xpPxEp98r8/97x6dMjnQjm3Do7Wj+EeaAVjN4CjnIA0CZqqc+Hs+RJyTSaSZhXC3rYfszIz8OEH78NisaCurs5vSzHLsnj00Ufx+eef4/XXX4+bUZUoMfOnl8gTN/GPGG1UVlZCLpd7dfGSFnO9Xg+DwcAXHtLS0jA6OgqlUokFCxbEReJI2MVRVVUVsY4x4aHLYDAAgNfGM9BBloxi5OfnB5X4iwUsy6KzsxN2ux3V1dUBD47EXMJoNHo9AyKt8UTE0YNxe37vvffw29/+Fq+++ipqa2sj8vvjlJn/wESHuIiBLpcLBw8eRFVV1USxc9IUA+n2MhgMfLdXZmYmbDYbbDYbqqur46aLiHx/5s+fH7GOMWHHL3kGCB39Au0fPR4PL6tSXl4e8+7YqdDpdOjp6QnKiEZoLmM0GgEgKhpPLpcLjY2N/LPCH+3t7bj22mtx11134fLLL4+L50oUScSLi4v4x3EcPvvsM8yePRuzZs06xfCFpmn+u282m6FQKPjzxvDwcFyNypOpjPT0dMybNy8i+xKhoyc5/5FnACk+Bzo/9vT0QK/Xo6amJm5MSUiRIRjtR6G5jNFoDMlcJhSInih5Vvj7+1ksFmzYsAELFy7Eb3/727h5rkSJKT9gp02ijaIoeDwePsD4++PSNI329naMj48jKSkJSqUSmZmZyMrKQmpq6rQedoODg1hQWYXZP3se7uETsLfuAzXcDsZmBMBh1iW/4k0COJbF0HMbUHD9Fq/fafvqA1i/+gCa8pXgGBq2Y7sA6cTogzw9D4zdBE3luWDddtib90Kn04V8ICX6Zkaj0SvbP7nbSziLXlNTA6VSieqFS2CafTY0VfVgKRcc7Z/C2XkIlK4TUqUKacu/D+XsSshOmj74TLRRTgy/dBNSF30bnIeaMBOgXYBUDtW8RXD1HoOm4hx4zKNwD7bCbrV4rT+UAOMLobCk0Wj0CrwkCXvWylXoT6lE6sILvf7t8I67IFWlQp1fBvvxA5AmqcFYx/BfF30H9917LziOQ2Vlpd+g4XA4sGnTJuTk5ODJJ5+Mi1GVKCNusqIIwzCgKAoMM2Gi4m9UnmVZ9PX1oaenB0lJSXynU7BJp2hBNDLlcnnUD3NE38xgMMBkMvFjlr46fknHWDx1/JHqNdmMhvPMIhVf8gzwZS4TKiRJWldX53czyrIsnnnmGbz//vt48803p+VWeJqQiPEPiJMYyHEcXC4XWJb1KrJO9drx8XG0tbVBKpXy2l/k2T9TBiLkMDc+Po6ampqoJv6E+mZGo5EfsyT3QJh0IkL+c+fOjRtxbTKJ4nQ6UV1dHVaSjEx9GI1GmEwmn+YyoWI2m9HS0hKUOPqePXvw61//Gi+//DKWLFkS8u86DUnEGBgX8Q+YKKQxDBOUVJLNZkNraytcLhdkMhk/8ZCVlTWjBQeixxvtxJ+w49dgMMDpdHolnYR7F5qm0dTUBI1Gg9LS0rjo+APAmzbW1NSEpUcpnPowGo28ucx0noNutxvHjh1DXl4eCgsL/b62p6cHV111FX7xi1/gf/7nfxK9yAD4iX8z3+IQJHfffTfy8vKwZs0aLFiwYMrXCR2lzj33XEilUj7p1NfXB6vViuTkZH7MIFCmezJarRY4edhV5pdBmV8GABj524OQcCyMH70AxmGCIrsYqnmLAYkUrt6vJkYwFScDnEwOcBwYuwnOzsMAAIkyBcklS+Ex6cDYjKAMQ3D3HcPq1fVhdX0I9c2E2X6hjbBWq8Xo6CgyMjK8ZtElEgmv0SZVqJBSsxYpNWsxvO1X4GgnrF99APOnbwAyOZSzKyeqqV99ANXcOiiy53k5kTIOM5wdh8AxHgASaKpWQ6pQwcVxcA22gTGPnKIHRwJMMFXMqfAlLEkCLxFXt9kckKSdutmSQsJryXGMBx67Dv/v/z2A+vp6aDQan9btk9e/bt060fRAJGK8+OKL6O/vx5o1a/yONQodpb7xjW9AqVTyB46xsTGcOHEi5G7XSECcTouLi5GXlxf13yfUNwO+7vgdHh7G8ePH+aSTzWaDx+MJqLETS4hGUrhFBkIgcxmVSuWVePP3OQjGup3gdrvxi1/8AjKZTDQ9EIkIBw4cwBtvvIE1a9bgnHPOmXL8RDgqX1dXB61W65V06uvr4yceYll4IF0cWq02JuYCQn0z4OuOX4PBgO7ubgATHb8cx8FgMAQU8o8lFEWhsbERmZmZKCsrC/v5FMhchtwjUnwJ9DkYHh5Gf39/QAdWjuPw/PPP429/+xs++OCDuEleipy+mM1m3HzzzVi9ejXWrFnjV2dcOCqfn5/Pn330ej0/YiiUWopF4YFhGJw4cQIulysmbunC819RUZFXt1dzczOfdFKpVNDpdNPWbo8kRIeUmD2G24nrz1ymv7+fl1shz4lAfxOLxYLm5uagkqT79+/Hbbfdhueeew7f+MY3wlp/InHadLS1tbWhoaEBu3fvRldXFxYtWoT6+no+6EgkEgwMDKC/v9/vB2GqTDdJvAX6sLEsi9TUVBRc9wLvIgoAY/98FIqc+dCe/QMwLhvcA81wdhyCq+8YJElKcJQT8owCqOYuBEc54Tj+KTiPG0nZc+ExDEI1bwnkqVmgxvvgHmiFTCrBX577M370ox9F9D6SezA8PIwTJ05ArVaDYRiv2e7l31gFfe5ypNSs9fp3uu2/hiw5Ddnf+zVYlp24xuMH4Ow+Cqk6FRztOnlNxVDNroL16LsAAHlWITiXFYzThtS6bwIArF9+AMjkUBcvhrv7MKxmk1eAqaqqiuqoG8dxKK2ohi2nFmnLvguJwH1Ut/1OyLW5YOwGMCYd/vTHZ1BWVhbUwffo0aO44YYb8MQTT+Cb3/xm1NYfhyRiNjFu4p9Op8OuXbvQ0NCAI0eOYN68eXz8Kysrg1QqhV6vR0dHR8BReZJwMRgMfOGBJN4iKaoNxLaLIxRMJhOam5v5MdypOn5jDUkS1NbWRl0jiWhcks/BVOYyZIQ/mO66sbExXHXVVfjud7+LX/7yl3FTHY4BiRj/gDiJgXa7HXv27MGuXbtw4MABJCcn8/FvyZIlkMvlsNls6OzshEKhwIIFC6ZMnAjd7IxGY9QLD2NjY+jo6IjL8S3S8SKXy73uwUx9b0nHWCw0kmia9pJbEZrLCHWuiD60w+EI2F1H0zRuv/122O12vPDCC3HzvIsRiRgD4yL+MQyDzz77DLt27cJHH30Eh8OBlStXYs2aNVi1ahU0Gg3cbjd6e3thsVj8jsqTTiciNUKM9bKysqJSeLDb7Whubua7oOKh8YAk/oi0CoApO35jidvtRmNjI2bNmhWwoWO6EINF0vXrz1yGSNcE2pcKTQ/efPPNgF1vCcbpPzoqxOPx4ODBg3zQMZlMUCgUqKysxMMPPxywpVuIsL3SYDDwHzYSdHx94TSpaci84Hoo51TzXWrj/34S8rRcpJ/zE6/XDv7lZ8hb9zgAwN76MVzdR3ihffX8pZCnZsHWuBuqolpIFGo4Ow9BKZfi2JdHMXv27GncJd/4mkUXZvsNBgMu+u734NEWIaXuAijyyiA52d2le/0uyNSpyP7er73ec+iF65G37nFIlRrQphE4WvfC1dcIj2UMqqJaJKXnwdH+GRi3Dam13wTjtMDRth/qynpIwcHZ/inGR3UxCzCE/7lyHd79oAG0ywnFrCIo59ZBObsKhoY/gXU7kJaSjDde3w65XI66urqA1u1///vf8eSTT2L79u1nounBzD89I09cxj+SkP7www+xe/dudHZ2IjMzExRF4aWXXkJRUVHQ3x+ibUg2XaTwQA5d0+lGcrvdaG5uRmpqKkpKSuIm6TI+Po4TJ07wGmO+9B1TUlKQkZERs1ELlmV5I4aqqqqYj/cKzWWIzlVycjI0Gg1GRkZQWloaUE+qubkZGzduxIMPPoiLL744RiuPGxIx/gFxGAM5juMLD7t27cKRI0eg1WoxNDTEV9BDiTVut5vf+1gslogVHkgXKEnQzNTI6mTsdjuampp4YwWJRMLrO5KkE5FbCabbNVIMDAxgaGgItbW1M5Kg8qVzrNVqYTAYkJmZiZKSEr/3wWAwYP369VizZg3uuuuuuHnexZBEjIFxF/+ACWmdjz/+GA0NDThw4AAkEglMJhM2bdqEa665JqTufGHhwWQyeSXdp+PmSRo6+vr6ZtzBXQgxoiHaxVKplNd3JPdAaC4RK0d3ot05UwUZoc6x0WjkzWXcbjc8Hg/q6ur8JiA9Hg/uvfdeDAwMYOvWrWFPo53GJFaiTUhvby8uvfRSrF27FizLelU76+vrsWTJkpCCDsMwXtVOUuXKysriK33fuvBCHG1shcNqQlJGPpRzF8M92IqkjHxkrLnW6/2Gnr8euT9+BLKUr5N/jo7PYd6/HZrKcwEAtqaPIEvJgsc0jB/98Id4/i/PReUhHewsellFFXQGC8AyYN0OJGXNgap4EezNeyBLyULO5fd6X6Mg0UZg3XYMv/wLpC6a0D+zt/8HrNsOZUEl3P2NAMtAU/tNgKHhbP8PPnz/3zMWYPr7+ydsh997D+0nukE5LKiuqcWLLzzPj1jRND2lsCTLsvjd736HgwcPYseOHSElehMIcZM1A3g8Hlx88cXIyspCSUkJ9u3bB7vd7lXtDGUkiCTdSeLNn7aPP4i5Sjy5N7Esi66uLlgsFtTU1Ex58CXmEuTwLXRziqSoLIGIa+fk5ISUJI0mxLSiq6sLKSkpcLvdfs1l/v3vf+PBBx/Etm3bUFNTM4MrnzFm/o8WHeI+Bv7mN7/Bvn37cMEFF+DgwYPo6urC4sWLsWbNGtTX1/MTD8FAku7ku+9wOML67hNzldzc3Lj5TgNfmwsEOvhO7naNZtczy7Joa2sDy7IBtW9jiclkQlNTE9RqNWia9msuc/z4cWzYsAF33303Lrvssrj5e8eYRLzouI9/77zzDu655x5cfvnl6OjowNGjRzF//ny+4zdU3bHJhQe1Ws1PfAX73SfmKlKpFOXl5XFhxAV8rf0dSMJE2O1qMpm8dI4j3fErdHueqSKDL1wuF44dO8ZrogLw6vgV/k3NZjM2bNiAJUuW4IEHHoibGB5jEjfR5vF4MDQ0hKKiIgATH9qRkRGvamdxcfEpY1bBQlGUl5uLSqXig47T6cQrr7yCv//jnzjW2ASW8UCRWwJV8SKo5lRDnjUHwy/eiJwr7odc+/X8t7PrC5g+3gpN5bngGA/szXsgAYvt27bhkksuifg9Ar7WSJpske6LRctWYDRrEVJqvwmPzQBH68dw9n4Fj34QUlUytKt+AuXsCsjUaQCmSLS5bBje+kukLrxw4hpb9p00Q5BBVVQHV18jUmrWgNIPgBo+gfFRXdwEGIvFgt7eXiQlJfEVD9L5SLL9FEVhdHQUQ0ND2LdvH4qKivDEE0/Ejc7TDCBusmaIrq4uzJ8/n///VqsVn3zyCT788MNTCg+haj6QKpder4fRaIRUKuVFdX1tOIiINXH6ixd9LrfbjaamJmRkZIRsLjC545emaa/k43S+88SaPZ7Gyoh1+9jYGOrq6qBQKLzMZUgCApjQ4rDZbDh06NCZYnowFYkY/4DTIAZ2d3ejuLjYa9RZOPFACg9r167lx6yCxdd3nxy4pio8DA8Po7e3F1VVVUhLS4vYdU4H0gXtdrtRVVUVUszylXwk4upE5zhcSJEhLy8vbtyega8LRdXV1fzf0Je5zN69e6FWq/HKK6+cSaYHUxEff7zIEvfxT6fTIS0tjR/pI93xDQ0N2LVrF3p6erB48WL+DJydnT2twkNqaip/Bva1vyNnzXgyVxG63YdjLjA5+ahSqfj4J5TZCBWGYdDW1gYAqKioiJsEldPpxLFjx1BUVMT/DX2ZyzQ2NgIAXnjhBdx+++34yU9+EjcxfAZI3ERbIMgGI5C+W7AIg47dbkdqair/hWtqasIzzzyDQ0e+RP/AIO+QmrrkYqhLz4I8bRYAwNX7FYx7tkA1tw7OrsPI1Kbh0/2fBLQKDweO49Df3w+dThd0tnzJ8rOhy6hFSt0FXj8f3n4HOKcFkqRksE4LZJp0qIrq4Di+H2krLoOyqA7y9DxIJBIwLht0W3+J5PJVcJ74HJyHAjgOmqp6SFXJsH75PmTaXDDmEUgkUtgspohfezgEa93Osiz27duHhx9+GHq9HhqNBtdffz02btwYw9XGFYkYXU/7+EcKD2TTNZW+W7CQ8Rq9Xs8XHkjiTSKRoKWlBdnZ2TEb/w4Gg8GA48ePRyyZRbQtSNcz0Tgh4urBJDJJXB4ZGUFtbW3c2MmzLIvW1lZIJBJUVFRM+dkgybjNmzfzWp/19fX4wx/+EOMVxw3x8WGPPKd9DJw8ZuVL3y1YhKYCRqMREonES9uxvb0dwMShKV66OJxOJ99dFwmNJNLxS4ovRFydJB+DLa6QuExG+OMBEpdHR0dRW1vr91qcTifuuOMO7Nu3DwqFAsXFxXjttdfi5lpmgESMgad9/COFh4aGBnz00UdwOp2n6LsFC8dxXlJLpOhIpJYGBwcxOjqKmpqaqGvMBgvDMF57mkgks4i5oFBmI9SOX6fTicbGRhQUFPAj/PEAictVVVUT5o9TQNM0nnvuOWzduhUsyyIrKwuPP/44VqxYEcPVxhVnbqJtMkJ9t927d8Nms2HVqlVhjVlxHMePWQ0ODoKiKOTm5iI7OxsZGRk4fPgw7r77bnT3D2FsdAQShRqqwhpI1Wmwt+4DR7uxccO1eOqpp6J2rS0tLUhKSkJ5eXnQB+qlK87GsLYGKQu/5fXzkR13Q6rUIPv7d4Gl3XCe+AyOjoOgRjogVSSDo5wnnUgroMwvh/mznQDHQa7NA0c5wFIupNROGCxYj74HyBVQF9WC7m+E2aiP+PWHSijW7UeOHMGmTZvw5JNP4vzzz+cF5gsKCmK02rgjPp4SkSXh4p+w2kkKD8JqZ7iFh6GhIVitVmRkZCAvL+8UC/WZgOM4dHd3w2g0oqamJmrddUJ9D2HX32RRbQLZ+EmlUr/JrFgjtG4P1F0yOjqK9evX49JLL8UvfvELABMj+HPnzo3VcuONRIx/QILFQF/6bvPmzcOaNWvCGrMihQedTofx8XEkJyejoKBg2p0OkWJsbAydnZ2orKz0e2iaDpN1jomb3VQdv8KO2UDJrFhCRlg5jkNlZaXfzwExPXA4HHjhhRegUqnQ09MTVwWmGSARLzyh4h/wdeGBTDykpKTwbqbhFh7GxsYwPDwMmUyGgoICZGVlQavVzvjexmazobm5GXPmzImK5jkAn93+wgYcX/tg0jEbT0UGAF4jrP727xzHYevWrdi6dSt27tyJwsJC6PV6yOXyqD1nTgPERNtUkDGrhoYG7N+/H2q1mtf2CEbfjVQLZ82ahcLCQq8NBwAvJ6d//etf2L79dXz8n8/hcjjwt52v4/zzz4/adQUzi+6LeSVlsKhykbL4O1Bkz4NENhF4R3bcA6kyGdnfv8vr9UPPX4+8q54AklSghlrhaNsPt64DrNMCZUEFFLMKYT/+KTjahZSatWCcVjhaP4G6Zi0kHjeorsMznmgj1u2Buv6Epgc7duxAWVlZDFcZ14ibrNOQqcasgi08kNZ3lmVRUVEBl8vF67tRFOVlIx/LsWqKotDU1DQjRgy+RLXJc0Aul6O5uZkXIo8XQrFub2pqws9+9jM89NBD+K//+q8YrTDuScT4ByR4DJyq8BCsvptwYqC6uhpSqRQGgwF6vZ43VYnEiGU419XZ2cmP8MfSiMFXxy8Zt01NTUVbWxvvDDvTB3ECRVE4duwYsrOzA2rqEdOD888/H3feeWfcXEMckIgxMKHjHyk8kImHcPTdSNKorKyMNw8hex+FQsGPmca68EBG+GNtxEAacMh9oCiK1/nMyMjA8PAwxsfH467I0N7eDo/HE1An0xeAYf4AACAASURBVOPx4J577sHQ0BBeeeWVM9H0YCrERFswhKrvNjIygu7ublRUVPjMSk8WVFQoFFF3cuI4DkNDQxgYGAhrFh0Aqmpq0a/TAxwDlnZDkTMPquLFsB37ELJkLXJ+8Buv15NEm1T5dasw47BAt+02pJ7sirO37QfnoaAsqICr7xjAMkhZeCFYtx1U9xcwG8and+FhEop1O8uy+N///V8cPnwYr7/++plqejAV4iYrAZhqzMqXvpvVakVLSwvmzJmDgoKCU+IZy7JenV7kwEWqndHSoyDuTaWlpXGhGUa0fYaGhmAymZCWlobc3FxkZGTERddLsNbtwITpwUMPPYRt27ahuro6Ris8LUjE+AecYTEwFH03iqLQ0tICtVrtcwRfOGIpLDyQPWC0Cg8ulwtNTU3Iysry0q6bKYi2z+joKHQ6HVQqFd/1HA9dL6QoXVpailmzZvl97fHjx3Httdfi3nvvxfe///0Zv7dxRiLejDMq/pHCA3G096fvRpL5Vqt1Sj3eySOWGo2GT7xFq/DAMIyXg/tMj/CTjt/x8XEMDAxAIpEgNzeXH7edaV1viqLQ2NiIrKysgB25ZrMZ1157LZYtW4YHHnhgxmN3nCEm2sJBqO+2a9cuvtq5cuVK7NmzB+vXr8eqVauC/qKQ8ULi5KTRaLzmuqdLpGbRz1q5Cn3JC5C66DugjcNwtOyFa6AZHtMIpKoUZNRfDUX+AkgVE4HSd6LNDN2225G68FvgWAb25r0CM4RauHqPQVN3AejRbtCjXehoP47MzMyYVl49Hg8aGxuRlpaG+fPn+w0wDocD119/PQoKCvDEE0/MePCOQ8RNVoIxlb7b6tWrMTAwgKKiIlx55ZVBJ/N9OTkRfbdIFB7ISBLRCIkXcxWO49DT0wODwYCamhowDOOl8yl8DqjV6pgd3jiO4zfKtbW1AYsM//d//4fdu3dj586dAQ+kZyCJGP+AMzwGCgsP+/fvh0ajQX19PdLS0tDb24tbb7016GQ+y7Iwm828tpmw0ys9PT0ihQfSXRJP5irA1yOsVVVVUKlUXh2/pABN3DxjmbwaHR1FV1cXamtrAz7Hdu/ejXvuuQcvv/wyFi9eHKMVnlYkYgw8o+PfVPpu1dXV2L17N+69996gzaUmu7m73W6kpaXxEw+ROPsRt2eisR0viXC73Y6mpiYUFRUhJyfHqwANIOLPgWCx2WxoampCSUlJwOdYV1cX1q9fj9tuuw0/+tGP4ubexhFioi0SeDwe7NixA3feeSeKiorgcrlwzjnnhK3vZrfb+TEDoaBsOAmnSM6in73yHPSqy5C6+DteP9e9/muwNiMkCjVYlxXy9Dyo5i6CvbEB2lU/gWpuHWSaiS4vkmjTVKyCo+MgOMp10gzhPEhVKbAe/Tdk2jwwllHI5DIcPXwYRqMRDMN4CYtHK9vvcDjQ2NiI4uJi5Obm+n3t0NAQ1q1bh6uvvho/+9nPxADjm0S8KWL8E8CyLD7//HNcd9114DgOUqkUCxcuDFvfbXLhITk52avaGcp70TSN5ubmKbtLZgqPx4OmpiYkJyf7HMMQPgcMBgOcTifS0tL4jVe0dO7IujQaDUpLS/3ea5fLhVtuuQUqlQp//OMfY1oMOY1IxPgHiDGQh+M4DAwM4KabbsIXX3yBnJwczJ49O2x9N9LppdfrvQoPRGoklPjHcRy6urpgMpmiqkcZKmRdZrMZNTU1PmPH5OeAWq32MpiI1uRHd3c3TCYTamtr/e4zOY7Dc889h7fffhs7d+4MWYrlDCIRY6AY/wRYrVY8/PDDePHFF1FeXg6ZTBa2vhspPJDv/nQLD2TCLJp6lOFAkvlTjbDSNM0n3kwmE2QymddzIFp7WVL8qKmpCZi7+OSTT3D77bfj+eefx1lnnRWV9SQAYqItUrzyyitYunQpampqpq3vJmSyoCzDMF428v6CTqRn0b+x6lz0qOYjdbG3/s7IG/dCIpUh54r7wbpssLV+DFf3UdDjvZAo1OAoJ6SqFKgKa6HInQ/T/tcmzBDSZoFxOwHWg5TqegCA9ci7QJIaqsJqsMOtMI6PAjjV1QuIfLbfl3X7VHzxxRf4+c9/jqeeegpr166d9u9OYMRN1hnAgQMHMDY2hu9973vT1ncTMlXCiSTe/CV3LBYLWlpaMG/evIBJ81hCqoWh6GQKXb2MRqPXuFmkqr6+rNunYnR0FFdddRUuu+wy3HzzzXGTwIxDEjH+AWIM9GJ8fBwvvfQSNm/eDIlEwuu77dq1C93d3SHpu03GV+EhGCc7okeZlpaGkpKSuCkE0jSNpqYmpKSkBEzmEziO8xo3i0bHL8MwaG5uhlKpxIIFC/y+H0VRuO222+B2u/H888/PuMFPnBMfH7zIIsY/ARzH4ZFHHsGmTZug1Wqnre8mhBQeSMJJLpcHVXhgWRYnTpyA0+lEdXX1jI9iEoQTAzU1NUGvi6IoPv5ZLJaIS04JJyzq6uoCFhleeeUVvPrqq3jzzTcxZ86caf3uBEdMtEWbyfpuX3zxBYqLi/lqZ6hdFsTJjlQ7fWW5ozWLXlZeCYMsAylLLoYiZx4k0onk1siOeyCRyZBzxQNerx96/jrkXfUkIFPA2XUIzvbPQOt7wbqdUBSUQZldDHvLPnAch5TqejAOCxxtnyB54YXgnBaw/cdgOJlomwwZNzMajdPO9odi3c5xHP72t7/h6aefxuuvvy6aHgRG3GSd4YSi7xYIX4UHoY28XC7nO0yGh4fjyk4e+Lq6Gky10B+Tq74sy3o5+oUa84O1bgcmTA82btyIRx55BBdddFHY13CGkIjxDxBjYNCEou8WCI7j4HA4eH03Unggex+ydzEajWhra0NZWVlcjXOTIsN0ix+Tx81cLpeXsHioiS+Xy4Vjx47xuqL+0Ov1WL9+PS644ALccccdYpEhMIkYA8X4FyT+9N3CKTy43W6vhJOvwgMxI8zOzo4rx1+apnlZoukWP5xOJ5+AFBZgMjIyQu74ZRgGLS0tSEpKCmhG4/F4cPfdd0On0+Hll18WTQ8CIybaYo0vfbdFixbx1c7c3NyQviAky63X6/kst8PhQH5+PubPnx/RTcDCRUvQNTAEjuPA0W4ocksmzBC+/DdkyenIueJ+r9eTRJuXRpvdiJHtdyKl7gIAgK15LyCRQJFbCnd/IyRJKqRU18NjM4AdaIRhbCSotYWb7Q/Fup1lWTzyyCM4cuQIXn/99biyX45j4uMJF1nE+BcmU+m7TWUsEwiGYfjNhtFohFQqhcfjgUqlCqlaGG2IuYrNZovKush9IP+TSCR8x28gg4lgrdsB4N1338XDDz8smh4ETyLGP0CMgWEzlb5buGNWVquVT7wxDAOpVAqaprFw4cK4OgTpdDr09PRMu8jgC3IfyB6Qpmmkp6fzMdBfvCUmOZWVlQH3dG1tbdiwYQPuu+8+fO9734ubA3yck4g3SYx/YTKVvhuZeAin8EC+9w6HAwqFAna7HZWVlXFhekUg5irz589HTk5ORN/b130I1tna5XKhsbGR16/zh9lsxjXXXIMVK1bg/vvvF4sMwSEm2mYaj8fDVzt3794Nm83mVe0MZUMyMjKCzs5OZGdnw+FwwOFwIDU1lf+yTbe9/bzVa3BCWojUpReD0g/C0boXrv5mMJZxSFUaZKy5dsIMIWmiquoz0WYzYuT1iUQbx3hgb9kLjnZDkqSGLC0brMuG5AVnwz3YColFB6M+PNfRYLL9oVi3OxwOXHfddSgsLMRjjz0mmh4Ej7jJEpkSUu1saGjA7t27eWOZcPTdbDYbjh07hszMTL7jS6VS8WOm0dL1CQQZ4dJqtQHNVSKFL4MJcugkHb+k6EPTNKqqqvwm41iWxVNPPYU9e/bgjTfeiKsumTgnEeMfIMbAiMBxHHQ6HXbt2oWGhgYcPXoU8+bNC0vfjXRLyGQyqFQqmEwmSKVS3lgmmro+/mBZFh0dHfwIVyz2TpOdrVmW9ZIaIWsYGhrCwMAA6urqAu6Pd+3ahXvvvRevvPIKFi1aFPVrSCASMQaK8S9CkMLDhx9+iAMHDiAlJSUsfTfidmowGJCVlQWz2Qyapr2klmbq3DY8PIy+vj7U1NTEpPjhq+NXq9Xy94J0PpvNZrS0tKCiogIZGRl+31M0PQgbMdEWb/jSdxNWO31V5qaaRec4jq/y6fV6vspHgk6oXRVr1q5FK1eAtKXf9fr50Mu3QJlbCo9ZB49lFPL0AqiLF8H65fvIWH0VlEV1kKknNOIYmwEjr/8ayeWr4DjxOTjaBYkqFZqyFXCPdoOxjkMqV0BO2dHw4ftYsmRJmHfya3xl+1UqFWw2G0pKSgKOCgwNDeHKK6/Etddei40bN4oBJjQS8WaJ8S9KhKvvNjQ0hP7+flRXV3u9Rvi9t9vtES08BIPFYkFzczNKS0tntLpKxi2MRiMsFguSkpLgdDqRnZ0dsIvQ5XLh5ptvRnJyMp555hnR9CA0EjH+AWIMjArCwkMo+m5msxmtra2ndEtQFMUbK5DCA0m8xaLwQFEUGhsbkZmZieLi4hnbOxHJFVJ4ACb2hTKZDHV1dX5jGsuyeO655/CPf/xDND0Ij0SMgWL8iwKk8BCqvpvb7UZTUxMyMjK83E4na3tLJBJ+/6fVaqNeeCDFTIqiIirjFM46hBq/NE3ze8CFCxcG1HD/+OOP8atf/QovvPACVqxYEaNVJwxioi2eCUbfrbe3FzqdDvn5+QFn0RmG8bKRF44XpaenBww6a9eejxY2H2nLvBNtw6/8Epnf/BmUsyvB0i64h47D2XEIzs6DkCpUYN1OyFIyoZq7EEmzimD+5FVwLAtZ2iwwDjOU+WVQZBXCNdgGeqQTxfNK8J9P9wc0JAiXkZERdHR0ICcnBzabbcpsPwAcPnwYN954o2h6ED7iJkskbALpu7lcLnz11VfQarWorKz025UlLDwYDAZQFDWtwkMgSPKvtrY2rnTihJ1/NE3DZrNNKbA+MjKCq666Cj/4wQ9w8803i0WG0EnUGybGwBgQSN9NrVbj0KFDkEgkqK2t9TsiBJxaeEhJSeE7fiNdeCDdEgsWLEBWVlZE33s60DSNr776CgqFAklJSTCbzV7OrqmpqfxeWDQ9iAiJGAPF+BcDgtF3a25uhtVqRXl5OTIzM/2+n7DwYLFYoFQq+e99SkpKRPc3brcbjY2NmDVrVlzpxHEch/b2dlgsFmi1WpjNZt7ZlfyP7KM5jsPLL7+M1157DTt37hRND8JDTLSdTkzWdzt27Bg8Hg9uueUWXHbZZSHru5HxIlLtJLpmWVlZPoPOirPOQoeJQ+rSS6DILYFENpGdH976S2Su3QjlnCqv1w8+91PkX/MHQCKBo/0/cHYeBG0YAke7oMgrhTJnHmzNe6HML4NEJoez+ygW1tXh0wP7p3+zfDCVdbuvbP9bb70FuVyOvXv34q9//StKS0ujsqYzgPh4ukQWMf7NAJP13f7zn//A6XTi0ksvxbXXXhtQxHUywvEig8EAAPymK5jCg7/3PX78OGiaRnV1dUQckSOFL+t24uxKRk0dDgf2798Pp9OJf/zjH3jiiSfwne98Z4ZXftqSiPEPEGPgjCAsPOzbtw9msxnV1dXYvHlzyMYyZLyI6LsRJ+OsrKxpFx4GBwcxODgYVPIvltjtdjQ2Np7S+TdZYL29vR0dHR349NNPcckll+DOO+8U9YjCJxFjoBj/ZgChvtvu3bsxNDQEtVqNBx54AOedd17IY5nEyViv1/OFh2B0zQJBdB/jrcjg8Xh4MwahjMlkZ1ez2Yz3338fJpMJNE3j1Vdfjati8WmGmGg7XXn11Vfx2muv4cYbb8SRI0emre8GfG0jr9frYbPZePv0rKwsqNVq/POf/8RvH3oEnd29cLvsUObMh7J4EWxfvo/Mb17nI9G2EfnXPA2p4uuA5bGOY3THPUip+yYAwNa8B1JFMliHCU8+/hg2btw4/Zvjg1Cs22maxm233YZDhw7xwfbvf/+7ODIQHuImSyTiNDc3Y926dbj77rsxODg4bX034FRds3Ds04mwbE5OTkDdx1gitG6vra0NOCr1l7/8Bdu2bUNKSgqsVisee+wxnH/++TFcccIQHx+AyCPGwBnE7Xbj3HPPxTXXXIOUlJRp67sBp+qakS6HrKysgIYqwvdoa2sDy7IBO4xjzfj4ODo6OlBdXR1wVGrv3r145JFHIJFIYDKZsH79etx6660xWmnCkYgxUIx/M8y1116LrKwsnHPOOfjoo4+mpe8GTF14IHvAYAoPQsf7eCsyOBwONDY2ori4OKDjc19fH2655RZe566iogKvvfZajFaacIiJttMVq9UKjUbjtZEKR99tKkiXA0m8kfFKEnT6+/uxZcsWvPPeB+jq6gIAKGdXQjV3EZRzqiBPy/adaLOMY3TnPUip/SY4xgNb8x4kyaTY+9HuqAnMhmLdbrfbcf3116OoqAi///3vIZfLfd5rkaARN1kiEYdlWV5zjTB5zMpms2HVqlUB9d2mghQeiKEKKTyQ8crJGI1GtLW1BTXCEEtCsW5nWRZPPvkk9u7di507dyIrKws0TYOmabGiGR6JGP8AMQbOOGazGVqtlv//4eq7TYUvQxVSePVVeCBFhtzcXBQWFsZVkaGvrw9jY2MB9dgAoKGhAffddx+2bt2KhQsXguM4fsxKJCzi44MQWcT4N8NMjn/h6rtNBTHUIlJLpPBAJh4mFxEYhkFbWxsAoKKiIq6KDAaDAcePH0d1dXVASaaOjg5cffXVuOOOO/Df//3fkEgkp9xrkZAQE22JSjD6bqEGHYvFwmf7hS5OaWlpeOutt/D222/j0NFjGNENQ6JQgXXZkVF/LZRFtbwZgscyhtGd9yG57Gw4Ow4iMz0VRw4filp7bSjW7YODg1i3bh02bNiAn/70p3GzUTzNScSbKMa/0wB/+m6RLDxkZGRgZGQEIyMjqK2tjSsdn1Cs210uF2688UakpaXh6aefFk0PIkMixj9AjIFxTyB9t1DHrCYXHoiuY1ZWFpxOJ9rb24PaZ8USlmXR2toKiUSCioqKgEWGP//5z3jnnXewc+fOgF0fIkGTiDFQjH9xTjD6bqGc8ch4pV6v9yo8kG63pqYmFBQUYPbs2XFzdiQddjqdDnV1dV76474gpgcvvvgili9fHqNVJjxiou1MYbK+W1dXFxYtWsRXO0PVdyNBZ3R0FCMjI1AqlcjPz+fdrP7973/jN7/5DUYMZpgNeshTM6GcuxBJmXNgPrAdHMPg8su+h62vvBK1aw7Fuv3QoUO46aab8PTTT6O+vj5qazoDiY8nTmQR499pxmR9tyNHjmDevHl8tTPcwsP4+DgGBwfBcRwf/4RisjNJKNbtxPTgiiuuwE033RQ3G8UEIFFvpBgDTzOEhYf9+/dDo9F4TTyEOmZlt9uh1+sxODjIOxjn5OQgMzMzLpL0RIw8NzcXc+bM8RvTKIrCrbfeCpqm8fzzzwc8kIqERCLGQDH+nWYI9d0++ugjOJ1OL0f7cAoPRqMRQ0NDMJlM0Gq1yM3NPcVQaqYgY/wcx6GystLv/pbjOGzZsgU7duzAzp07MXv27BiuNOERE21nKh6Ph6927t69G1arFatWrQpJ302v1/NVTLVa7SUmq1ar+WonAGzfvh1//evfcPhYE9xOB578/e+ipsfGsixOnDgBt9sdUIyc4zi8+eabeOaZZ7Bjxw7R9CDyiJsskbhDOGYVrr6b0+lEY2MjCgoKkJeX56VvJJPJ+GpnWlpazMfOh4eH0dfXh7q6uoA6IceOHcN1112H3/3ud/j2t78doxWeMSRi/APEGHhaQ8asdu3a5aXvVl9fj7Vr1wY1ZiUcSS8tLYXNZuP3gAzDID09HVlZWUhPTw8piRcJLBYLmpubgxIjHx8fx9VXX40LL7wQt99+uygREnkSMQaK8e80x2q1Yt++ffzEQ6j6bhzHobe3F+Pj46ipqQHDMPzEg9PpRFpaGr8HjHXinqIoHDt2DNnZ2QG1gmmaxl133YXx8XG89NJLokRI5BETbSITEH23Dz/8EPv37+fHrHzpuwkDTG1t7SlBhOM4Lxt5h8OB1NRUPuhEc7SKpmk0NjYiPT0d8+bN8xtgGIbBQw89hMbGRmzfvl2cQY8O4iZLJO4JVd9tfHwcJ06cQFVVlc+4QVEUv+kSFh4yMzOh0WiiVu3kOA4dHR1wOByorq72u1nkOA7vvPMOHn30Ubz22muorKyMyprOcBIx/gFiDEwoptJ3m6rwQIS1CwsLfereMgzD67uRwgMxVoh24WFkZAQ9PT2ora0NeGhsaWnBxo0bcf/99+PSSy+N2prOcBIxBorxL4EIVd/N4/GgpaUFSqXS5zQEy7KwWq28vpvH40F6ejovNRLNwoPVakVzczNKS0sxa9Ysv681mUy45pprsHLlStx7771ikSE6iIk2kVMR6rs1NDTgyJEjvL7b8uXL8eabb2L9+vUoLy8P6otJxGRJ4o2mab7aGcmgM5V1+1Svve6661BcXIxHH3005hXXMwhxkyVy2jF5zCo5ORlr1qzBeeedh127duHcc8/FypUrgxqR4jjOy0Y+WoUHYt2empqKkpISv8k8lmXxxBNP4JNPPsGOHTviyoI+wUjE+AeIMTChERYedu/eDYfDwY9ZjY+Pg6ZpXHbZZQGFtQmk8GAwGGA2m6FSqZCVlRXRwgPHcejq6oLFYkFtbW3APd2HH36I+++/H1u3bkVdXd20f7/IlCRiDBTjXwJDxi7JxEN3dzeWLFmC+vp65OXl4dNPP8XVV1+N/Pz8oN6PYRiYTCZe300ikfATX5EsPIyOjqKrqwu1tbUBR2E7OjpwzTXX4Fe/+hVveiASFcREm0hgiL7btm3b8Kc//Qnl5eUoKSnhs/2h6ruRoEOqnRKJxMtGPpygE4p1+8DAANatW4eNGzdiw4YNYoCJLol4c8X4dwZBqp3vvPMOHnroIWi1WsydOzdsYxmO42C1WvnEGyk8kGpnKCYNBNJhMnfuXOTl5fl9rdPpxE033QStVounn346rN8nEjSJGP8AMQaeUVitVuzduxcPP/ww+vv7UVZWhvPOOy8sfTcAXhMPxD16OoUHj8eD5uZmJCcno7S0NGCR4dlnn8W7776LN998M2BRVmTaJGIMFOPfGQRN0/j888/xzDPPoKGhAVVVVViyZEnY+m4URfHGCqTwQBJv4RQeOI5Dd3c3TCYTamtrA+7p9u3bhzvuuANbtmzBsmXLQvpdIiEjJtpEguemm27Chg0bUF1djUOHDvGikkTfbc2aNTjnnHOC0ncTQtO0V7VToVDwQSclJcVv0AnVuv3gwYO4+eab8Yc//AGrV68OaZ0iYSFuskQSgmeeeQbZ2dm44oorpq3vJoRhGJjNZj4GksIDsZEPlMQLxbpdp9Phqquuwg9/+EPceOONYpEh+iTqDRZj4BnGZ599hrfffhsPPvggxsbGpqXvJkRYeDAYDKAoKqTCA9HKLCwsDNhhQlEUNm/eDJZl8dxzz4mmB7EhEWOgGP/OMCwWCzZt2sQXJ4X6btMxlgEmYpher+cLDykpKfwZOFDhgWEYNDc3TznGKoTjOLz44ot44403RNOD2CEm2kSmz1T6bvX19Vi6dGnIHRNkzMpgMMBms0Gj0fBBRyjsHYp1O8dx2LlzJ5599lns2LEDJSUlYV+vSEiImyyRhCZUfbdg3k9Y7Zyq8BCqdftXX32F66+/Ho8++iguvPDCsK9XJCQSMf4BYgwUOUmo+m7BvB+ZeDAYDADAd7tNLjwYjUa0tbVNqZUpZHx8HOvXr8dFF12EW2+9VdQjih2JGAPF+CcC4FR9tyNHjmD+/Pn8xEM4hQebzcYn3iiKglar5aWWhOdpl8uFY8eOYfbs2QGTZjRN484774TRaMRLL70U0CRLJGKIiTaRyDKVvhupdoYzZiV0s3K5XNBqtUhLS8PQ0BDy8/MDWrczDIMHH3wQzc3NeO2110TTg9gibrJEziim0nerr68/xVgmGFwuFz9mSgoPGRkZvMh4MNbt//znP/H73/8e27dvR0VFxXQvUSR4EjH+AWIMFJkCf/pu55xzTshjVqTwYDAY/n979xMS1R6GcfzRsQyhMSeyVmX/Fik1WYuhRSEtWkS1maAgmTQlCwqKgjRbVFOLUKiIiFoIEUEjQVmL0iTdSFAtkjTBP4sgCBNTRxPsTDN3ce/MdbxqOh5npnO/n6XIcI4DD8f3d9731eDgYOTgIfzzTZs2/fatj0+fPqm0tFSXL1/Wvn375nJ7mD0rZiD5h0lNNt8tPz8/8gw4l4OHgYEBhUIhZWVlKT09XV++fFFubq6WLFky7WcMDAyoqKhI27dv14ULFzhkiC8KbZhf4fluDQ0NkTarzZs3xzzfLRgM6uvXr+rq6lJ6enpkm1X4tNNms0X9/sjIiMrKyrRmzRpdu3aNpQfxx0MW/rfCp52NjY2R085wm1Ws890GBwfV3t6u1NRUpaSkKDMzM/LGx8TW+WAwqOrqarW0tMjn88nhcJh9i5ieFfNPIgMxQxMPHubaZjU6OqqOjg6Njo7KZrNF2qwcDsekW0br6+t16dIllh4kjhUzkPzDjITnu4U7HsIHDzt37oxpvpthGOrp6VFvb68WLlwY1fGwePHi//w/3dXVpeLiYlVUVGj//v2MC4k/Cm2IL8Mw9P79ezU0NMQ0323i6vZAIBB12pmWliaHw6G+vj5lZ2eruLhYR48e1ZEjRwiYxLDiH538Q0zGt1nFMt9t4ur2YDAov98faTMIBoPKysrS0NCQVq1apfLycjkcDt28eZOlB4lhxfyTyEDEYPzBQyzz3QzD0MePH5WVlaWcnBxJf2+QD7/xG+54MAxDS5cu1ZMnT/TixQvV1tay9CBxrJiB5B9iMjw8HPN8t1AopM7OTo2NjSkvL082my3S8fD9+3cN2orMkQAABGxJREFUDw8rIyNDixYtkmEY+vbtmyorK1VTU6OtW7fG8S4xDoU2JNZM57vNdHX72NiY+vv7deLECb179055eXk6ePCgPB7PrGclwRQ8ZAFTmM18t5msbg8fPFy/fl2PHz9WRkaGPB6PCgsLI/+YIq6smH8SGQgTzGa+28jIiNra2rR27VotW7Zsys/z+/2qq6vTjRs3NDAwoMLCQh04cEAulyuet4Z/WTEDyT/M2WzmuxmGoba2NmVmZmr16tWTHsiGQiH9+PFDra2tqqioUHd3t3bv3i232y232x3v28PfKLQheUw1323btm1qbm5WeXm5XC7Xb7eQ+nw+3blzRz6fT4FAQI2NjSoqKpq0rQDzjocsYIYmm+9WUFCgz58/y+l0qqSk5Ldvpn348EHHjx9XVVWVnE6nXr9+LafTqdzc3DjdBcaxYv5JZCDmwVTz3ex2u3p7e3X16tXfHpj29fXp8OHD2rNnj8rKytTS0qLU1FTt2rUrTneBCayYgeQfTDfVfLe8vDw1Nzfr9u3bWrFixbSfYRiGzp07p6GhId27d0/t7e3q7OyUx+OJ011gAgptSF7BYFBNTU0qKSlRTk6O+vv7p53v9uvXL3m9XnV0dOjhw4ey2+0JvHr8g4csIAbht3gPHTqknz9/KhAIRBbLTDbfLRQKqa6uTtXV1Sw9SB5WzD+JDEQc+P1+nTp1Sk1NTVq+fLnS09OnbbMKLz3wer3au3dvgq4aE1gxA8k/zDvDMHTr1i1VVVVpw4YN8vv90853Cy892LFjhyorK1l6kBymzD8mxiPhUlNT5ff75fP55HK5oua7FRcXR813y8/P1+nTp7V+/Xo9ffr0P0sRAOBPkpKSokAgoGPHjqmoqCiqzerixYtR890KCgp0//59vXnzRo2NjSw9APDHW7BggdatW6e7d+8qLS0tMt+tpqZGJ0+ejJrv1tPTI6/XqwcPHmjjxo2JvnQAmJNw90Jra6uys7Oj5rtduXIlar6b3W5XaWmpzp8/L7fbzUzyPwBvtCHpjZ/v9ujRI505c0Znz54lYJKLFb8M8g8JN77Nqra2VitXrtSzZ89YepBcrJh/EhmIBBt/8PD8+XN1d3fr7du3U85vQ8JYMQPJPyTU+Plur1690suXL1VfX68tW7Yk+tIQjdZRWEMoFKLAlpys+KWQf0gq5F/SsuqXQgYiqZCBScuKXwr5h6RC/iUtCm0A5pUVk5/8AzATVsw/iQwEMDNWzEDyD8BMTJl/TNADAAAAAAAATEChDQAAAAAAADABhTYAAAAAAADABBTaAAAAAAAAABNQaAMAAAAAAABMQKENAAAAAAAAMAGFNgAAAAAAAMAEFNoAAAAAAAAAE1BoAwAAAAAAAExAoQ0AAAAAAAAwAYU2AAAAAAAAwAQpoVAo0dcAAAAAAAAA/PF4ow0AAAAAAAAwAYU2AAAAAAAAwAQU2gAAAAAAAAATUGgDAAAAAAAATEChDQAAAAAAADABhTYAAAAAAADABH8BJWFSt15l0wkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(22,4))\n", + "\n", + "thresh = 0.7\n", + "for i in range(1,5):\n", + " ax = fig.add_subplot(1, 4, i, projection='3d')\n", + " ax.set_title(\"M={}\".format(i))\n", + " ax.set_xticklabels([])\n", + " ax.set_yticklabels([])\n", + " ax.set_zticklabels([])\n", + " g = f[i]\n", + " voxels = g > np.amax(g)*thresh\n", + " ax.voxels(voxels, edgecolor='k')\n", + " \n", + "plt.savefig(\"./Figures/3D_fields_lego.pdf\", dpi=300, transparent=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.signal import correlate2d\n", + "\n", + "step_size = 0.02\n", + "env_size = 2\n", + "b = int(env_size/step_size)\n", + "\n", + "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size]\n", + "X = X.reshape((2,-1)).T\n", + "X = X - env_size*0.5\n", + "\n", + "\n", + "Plane_base = np.array([\n", + " [np.cos(-np.pi/4.),0,np.sin(-np.pi/4.)],\n", + " [0,1,0]\n", + "])\n", + "\n", + "X_ = np.dot(X, Plane_base)\n", + "\n", + "\n", + "i = 1\n", + "img = create_firing_field(X_, A[i])\n", + "img = img.reshape((b,b))\n", + "\n", + "corr = correlate2d(img,img, mode=\"full\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO0AAABzCAYAAAB0IYW8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO1925LjOJLlUZAiqVuEKiO7sq2ma63adh7m6/Yb5tf2L/phxrrXure3uyYjS5FSSKRERuwD4IDD6QCpuGaOhZvRJFEkSII4OH4DMHl4eMC7vMu7fD9y8dY38C7v8i7nyTto3+VdvjN5B+27vMt3Ju+gfZd3+c7kHbTv8i7fmeTJf//35AFXAK6Brz9N8c/sE/6Kn/FX/Iy/4Bf8Gb/gL/gj/hP/E3/7P78Af5oCfwLwHwD+wrYdAPyTbVMAPwL4ZAoHgI8A/gDgFwD/ard/Ay7+7Q6/fPoL/hX/gV/wF7v9GT/jr/gJf8en5lcsfr0HbgDcAmjYk5UArsylvvxY4f/hJ/wdP+Gv+Dm49z/jF/zjP/8I/GnSv/+/Adg9APjV/vhit68AZnab20+qTto/ZZ/035RV8AlAa7/v7feD3X8Qm9/38PC/Jsn3dqZMJv/+AiGE6fAhLy6nt76BJ8nDw7+r7zkN2spuJdBmGY4o0CFDhwwtMnTI0SFLXzl9hVGS2YZNV87dlTsU9T1Qw4C1gfneAe627sw2v6sxW+wxg9nmOKBEgxn2KHEEqgaoKv/MOdswsV+mCAHY2u0kHpT2D1UAHUPgPbH9rXKs3PcSkgKbBgJ+fD5iv5Qxz6SdT+Vr9xSr+8fW37cF/jSkSrOdSuCI0gI16wG1RQa0z4DOhGToAMCBNUOHEkfkHTxYCbwt/JNlAO6A6g6YLw4WrEfMGXjn2GNaHXHioOXgBRCClX4TWAnQJDk79mA/T+wc+gT7D/DAlb+5vCRw6Rm0d9kiDmiuRUiNQtYNl6Fn07STWDvjHSD9nonfKaCnypTa0dtKGmkLACXQ5bAwydEKlg0APKo9UQWMa3xZ3vnv7BwC7qS2RRHT3sGDlj4rs3/e7THP9phjjwKNY9sCR8yXe9xWl33AVnRFanyyEWpsK1nxgH7D5S9fsqz8nwP5pTpHCVjZwPmzIXKsrKMcwx0BSQwMWmfJP/m5msZCDYF3lLQvJZr2xK/7duAdVI8fKuBYTW3TLnBEqQP2iZcaSyBZoKC3RhUmpiXgtggZ14J2tjthdrXHDAfHsDP7WZRHYIk+YIk0W94I6TuB8YQ+mM9RCbXGxve/lmisKMEhn4uDktvvWn1J4c/JWZGXG2NvrSxej/Q9R9ipcvDFgCe1CtkhD53/sjKoHjcl0GRlTz0mwBIDoz3HNyIb59BNdo7bAXi7tutMEWTHkorMi70zz4EFML0D5lcGpIZtj45pSzRAdQKqqa4it7whymfhDYPkHLDFGpysp5c1QbwMqcd0XynAckecZFxNlSXgctHYOtUBUL1xxx1Xuca8E41hYyz9NsBNtoJTaViWHFAacNvnZNsREijmbWcYlQDLnVG53Q8Y0JJDqtljXpI9G35eVEfcV9M+yzpnFGcNruZroDrnWTlIZYPmAHnJBiIBkWIaqVHweuFglcDl5cpnlc8tGZv2zdh3LtTZcaBO4QGsgXeoTjXN4hzGfhlJtqzDcoomM1zUoAyA2zLAdp0F7lMdnCPODTzJ7b1nWumMamDAah1RqM1nUd9jVnoHFH2WOKKoGtTLhW7X7oC+wyWmetExMZGMJW27lu1/i9BJjM3kc3JQ0fc5PHj5RsDmZUmmJecRiWTtmF+ByjvY6+/hwcvNmP2op08/9xRvDdwkaI1abJTHIwo0jHEN35kNwPOZXgngZ049tp8tO547oyhWS+VYmxZ3oYo8w8E+lfEmz5cH1DLkM+hBJu+wdNCMeYmamgi2T2soLykx9XPoPghAXBXmgJVxbCB89gP6Ni2VK1XsWCdGxx0ix/LrxVRlaQLw+02d97qSbAVHFNhj7pj2aNm2t7VCRR7FuOIFnVEXLl7b2fPIGUXAJbuWAHcXbvNujyIzdiwxbYEjiqzR7VlXS0M9/SMeRmUbHhbSGs5riKYey+eSqisHGW2X7Lv0ezwg7Axm7Boc/Lk/Nxcb4NtbPYHvILbsGXjnyu99TMfK61z7/vpe5WQL2GMeMG2HDI1i13ZtdqZqzHs9SsZJO7JILc4Z204IsDzsw2O1ZNMK4M52J8yvvD1LTGuSLFLOqFgYQzpm5G++L1UX0pml9fov0Sg4K2lOoyGm5yjirEiAnUfOIz+B5sij/QysauKLFWoDO1jwXg7c72NVW+ljeH32HWTaBmTTpu1aJ89l0ybKcZ5k6iiIaWVWFJVBjihr104bBIkVjmnReGeUbBw9D7LsxeXLjzWGqfJw3I59CxuWRAtZSaaHOGYqNmnPWsBKrSUwbbiTT7kE9y1oiS+OaeH9Dxsg3lnQs2p+iFiGlby3WAN9eft2kGkJpDG7FgDas5k2IaKcnurNhYDJN860JHcwiSJcReZqMbyqXFQN6irijKqpcQF9FXkIsBpY+UOTvJb6GxPNgyw1B+05ZFyWQIs00Oidae1Hnkdx9CX6TEvl7Nh+B1zJ4hC/Y6q/NHm0DvX12TbtiLLNeY+ZY9u+XZujkymMo+6/Tf7U9tEV6TsAD1zOsPRJotm1jUmomLuQj8mOKqujd0bJJAtXmMZIWhzzXJFgobK4mvpaMlW+y9AW9xxrDqhJCLYYaHPlN9g5BFIO2uCdIGRavn8DACvl+cirLAGXAmCss9I66Jdj2yRoD4JpKULaSOByph2p4hoRauHIzsqlM3L1mNu3kmkpvVGEfni8lpIsZuUet5r3uOdB1rysQy+Kv0z5PdYZcHkt4EqbfUiF5McLz20MaCnQUlEStGuEHYBLMYUHray2FsBuAgNcGfvmz/ZYtoyd/3LAHcW0PoXR27W9wQPyeZPPn3gYBfyU68wl4zatVI0laDMY9ZiBd3oHzK5sfBZHBt4jUD0A1STi9JCApe/cO5nyLNP/McDKV6K1wpcS/qC52C+vP1U+uV077duhBD4SUovHgJY+JXD5bRFo5e06z/Kl3clTHGUyhtRs6N3IGK8G0NdRkweZtrVM29jtyNRkckTdt+ckV0QuOUI9jp5HLEuMy9VjejdcPbZsO8chACt1S71helEPcoz1NIdNzCklj3tLR5SUlDMN0NVkVi8cdBrQKnig0Xsj4aBdow/aJcaBljqGz7DvjsJKmr2qxcZJKGmDjtc6MilDnffjZIBpyVvsmdZnAdNnDpB6TDJKRZYhjql63j1zRPUGKHBg0sbTGluYF0v27g4B25ZdgzLzTEvdkhumJ73HvY5Uqsipl0LAJYeU9ETHVO7XkhizauGelOOMoUayrMaOdLhUbXP0Ab9mm2TuFub9us4VoZOrhrVvCbRco6B2GAMsrwv+zFrjTrHt88RyB5h21mNaYtvWgrnr7FhazaZ9jJxbBmfYmAc5hwn7cNu28fFaYlrKkCqrBqdokoUGLi14zx+IhIBLaXl0rqZyv7VIR9RQhySSK7hPQAKXhIOWA42fS+wqQUtg5vhZwgITYVvgA0l2E/Szs+gZNMbVQCgdciRjwfg0e3cU03Kbtjd4oM2AdtJnyXPBF1OP2749C4Rja3vXJGYlydEDLLdrzdjavQv7zBYH7DTAVrAvXdhuyYeQvatUKfn3mF37VhJjhljnQhU1CZ14qfiqBlogBLpk2o8IQUvn7kTZErQOvFqnK7PQ5LvkBZ8Qak2ynDHyeOAmW8fextk80xaObX24h6nGo4DaRj4RAk+Uo47d5cfyBAsCLux+smnppe3gVGUzi8VBuNqasIHJxtZrtAQ4ftOphi5ZVvv+vUne/yk3qR5D/FdHzpWgD9TtE5B3xkQjE6uOnMNVZ5eNNZZZuBowFb+1dz2m3McBNwnao2NaP3CAbFxKsmhj4Z5RMnDDtjwO2OjAe9FxPLRA2wF5C0wyBMPzONvO4JmWO6RMY5hGPMgcYFoVSkcF9d6a3aj1+m/JtLEOI5VIwr/b3xJwsVittGkl03Jv8RKGZdcA1idU6y3K6gjAJOE0yxKnagVgEnbQPaal6/BON2bX5vADGkj4sSdWzmNsw/OBO8C0Jg2MQEpqMoVgGhQmsYID9im2rca0NnEjOVOGvHYDHBqgbYE8t2F+ckjxaWnugLI5Yl72mTY5traXzqgBjVeANtyMvsuypMr9VnKOTcu1h9x/xOzax6jHZNuuAXyssVxvsVxsUeKIDB26MkOzKLCrGuza3/VV450tgzumarp3br+C3QR/p3yon2RbTUUey7bny6AjCoBzRh2dI4oGEOQ41UUcqMG+mNE6ELMdEg5Y65R6aA1gD41hWgCYk3NqB8+0NTC/u0dZSjfbMUxnlMDtDRyQclL+kyEi2dDHhJJeGsxPLZ+dn3JExUAr/RBLKKA9YbneYr3YYIUtZtgjR+faaLk4ov19hrr94M0gvtXsOq598oEL9Af3mEu/RSuOyfE0oJ7HtoOOKMCwnB/xw9i2ywCpHqsA1qbVVW5SZdqJY9joLBnCg9x2BrAnACcb/pkTYHn45w6Y1HDTqtLWS2eUNlYAWE1VJkeFVIn58dLG1Vibv8yX67n78hTwilE5MbsU8IxHItVjDlarKlcWsGuEoAVMe83QobvK8Pe6xP1u4cG6seUQaKmKd+yabqQZZ1+ITxr3q73Xx9q258koR1SHnCmOpWfeukAv3JO8xxjbJg5vDVhbBtxg8L1y/Kn1Q6sBYNoB+ztgTllRQk0ucQy2Akcz0ZtkWccS9HKlLRrLitLAK/drHmmuN76VaNcf8HLzPkzWn/T4xphWMvQSwLLG6mqHFbYOtCtsXR76EYVxIgJoPpX4r93cePsJsFxF5o+lDljg7EuqMQGWYr1SRdbs/pjPQ8p4tn1Lj8e7fPMiOyVAB3DPU+e/xsI+VJTUYvg+oR4v11sH1DUM29J0uIBxnBY4orGDXLYfl6g3H4zzaoNQRYYtF+xeNGIFxXVJeAokt1/P6Vyl7XyeJEF7ZOpxI2K03nM86V9bPnxUlNkrIowdZVcpnbFnSUEFTPJZTiqyGO2DxqvH3t3WmDiwxrLuFmKx2pRwFZhvQ86opwXjxwuxyBNFAlELn5HUvbONSCfUssZscQhYdo3fsMLOsytKFGicCXe4muNvH1fAZmqYdmPL2tlr8KgNt3P5fzXggdvCpDPS+Gl6T6RhkW0LvOQ7G6UeA2BOKDYgXlON1d5KiuaoEcLK42CNApccUTDqcYtQWZ13wENtbNhgIjjrQS7Lo1t9gLbhgQNcONCcYp5+Ricx4H6LcgajxMAbxEsjRQeqcY1quccKW8yxD5jW7DP13SFDica11S1W2HzcYLf5nck9JhV5J67F1WUJWgJ0S8Dl6jGx7pT9Pif8IythHNBHM23r4rN2iF6XGc8xtwdGMywXuskHz9pKOf25lrOoudB24aC/A+z8fI1lWz4tTW2G6RUlD2o1fuBAXg3EaocAprGq3DTGldPv0LGxdMlvTHhdabZtzKaV6nEFVEsz6R4BdmlV5B8scAsckaFFhxyZ9STvMcc1brBZrLFbr4E1Y1sCrwZSiE9i4B3gUjQdJWimwbkgPN9nMcC0c1cZvXTGukh7jgMVN3ZTA04o+9l1mVtQK7mqQWvCPXwoAvn7DgAOtQ39CBWZZmikNX6IaYOBAz31WAJWqrMp0YAMxAELtu8Z1NdBGaEJqcISK0hSqnLKcemY9oSyOrrlXKRNS3Zths4xbYcMOwvvNTaGbT/+zqvHZMvW8I6xmHrMZQf41iQ9/rHO9PnV5AGmLQAUAPjYWutBbjOgniaAasX9jk33cfIHtnp5XZuhy/qrG8SegOxZAi4ddtDmkrLfuT3rkiz4wAEJ3FYDrGytUmQMVrJsDLBcnnWVywEh2nukSLAGnyeYyEPkeWy9X1RmYoKZnV1khgNW2PVUZPIgkyOKXFYb/GDZ9iOwnHiWBeLhJv4pSbQmNTk2XSuvLypI6wCHpruJy+OYtilwrMu4LZvqQceIKKtrM3QlmxydgKulI3f+VKkiHwCcGmAq7dpGhn2M9Z7lXb/R9RyFKUaSNCP3899T9ACpvf8Xl9Ssi2eIVoSrS5svzHOG6X9u0y5PmC/34Csdcqb1wP2NTUPU4ogCWyyxwRpr/IY1Nvj88TfU6w9eRQZC0MbacS5+10A4pY7mhBoj1G7On6pmNNPyIXpdm+GeMqE0m5ZklPe49d+Jaelcdj7FZ3m8NiYcsHuECsyhBqYyVrszTOs9yCJWm0ywkJ/0X0w4O2uJGehjmvY9tTM8Sx6rIgvR2DbvMGU5w/eAuRZPerAsW1Q06d7ebRy41/iMFbYoG1NeXnY4khMKP+Azrs3xVzvUHz94hxQQrvsk14AKQMr2VWAT/MkOmcdt6eHHvrDxx45gWtODOaZtCjR1aVQbCdiomqzNzRPpTZQer2XD8zhw1cbNipFMe4JxRl3yfFQb9iEPcolw9LAK2BzwwfexoqnT3K5NTMZND/Si8gi/wzni+qYHTKsjsrxFnndo2wxHwAOXpDqhqBoUme9EZ2ymEQLtD90GlzcnN6qruPyC5qqwoF3jBtf41bLxzfoa9+tFyLRcBU6pxy18YoZjW+mbkA87hnnPt3mToG1QgFLEWmQ4diWaurBe40nYG8VU5Z5ok2rZ71qltXCzPQYzQHKmFaTLuwj+nbzIml07vyMP8jHYkLOwjzpEb0ysVnNSSdeq+Klp0K/KtI8R0fjkI+YA8hZZ3rrROQCAqvHAbXMgb3FRHVFWvhPl451X8EkWq9sT8AXOTp3WwMflDbbZCje4Duze1XqL2/XCO6KW6JOiZNtcHOuAS55kejD+XqW9GpPHvcwkaA/N3C3q3LVmwPuxLgGyZ+VQpyRgY72JkmBBn9ym7YV8cnP3ES35FBYRvJNTI1RkG7+lBlIETGvDPjEwqWqxZFKI/RLsCstW7FBeL28mz+ABtapxnnfI8g5Z1qHLM6Au0OUdUB1x33a4yDsUVYMs76zZcggm35uRitxsMbkBcAPg1l6jAS6rEz7+fIMb3ARe5lW5xe362oR/gBC0moYo/XDU5t3YX2nb8oHxY14YtUqeWTV8Xppp6wK5BW3bZuja3MzZ1E7iqjGUT/VG5L5T+Bfb7tuI55i+JtRkKvXAtlMrnFGBB9nnH2fofNgnGqslGXLeSMDSPoVle+ElvDLTUkOSwg2O1D5WjJALBtgMLZABhWXdpi4dSeR5hyJrhLlytGOfjZq8uL03LHsD4Ku9nl0t8frDF1wvPuMan4M85Wq9NQ4pILRjx4CWQkQuOUOqxy1CxxTVz/NK2hFVl6YHhHUYtJlhWW1AcdKmjYnywtXK80uQ9KZuHbBpeZGkIh9qkWQReJApjdH08lne4qSBKQf6C03HVGTF2aQBNmo/4xXBynt+us/U8UoGkPb+7bNkBFq0zvRCZvaXVYO2zQxgrWpMb5vMFVoZYoWtYddbeOBSSK8Eqmtg/ceNTcD4zbPt1Q718kOo6oJ9DoGWz4qxkyoy37R0Rl6XcvTWeNs2Cdr73Rz3eQvnmm9zY8tysKbU47MaWts/z5Xpl9UkR5TLiKItMT6ezzFwgo3X0n0z8PolQtjIYRqip70XNVYL+BehCfc6Kqpxb0SRKPLV1eSXyp/1ulMDoChNtIKY1jBxF6wkRYMDZthjflcbwJJ6/AW+E14A+BX4+NMN1qUB7g8u5XGPi/Ud7rEIBw9onWMMtMS2LkuKM62WaKF1fCmQpgGc1unqCZAzu4zbsZxpNdbtiUSjTH+IHN4CNKaWO6JaZHjIgYls2KIIzrYHvo96ZaYilx15KxunHrtYraoekwzFaukzcpzsDLRrccP8zSXGwuNujgBJkYkSRzQAstz3vFyvKnF0IKeYbXUHoxJ/hWdaDtoPwOLXe1z/bOzaJXNezZd77NoMWFb+llOgpf8o4hBkdUmmpXqJOneYnGfLkgyAVhwhQZtSjQPwjumtT/4aytZfFzdHm9lmk6WfhFcf2bVu8ACxbg0U9Qnl4hioyW7NWlVtlQ4l2YPEWFjEaFOqMcf8NwHYEZK4zyyP/5llHbouQ5Z5vYqv3URALtCEmh6N3qLJ/Nik9I6Z3eR9DYpKSVGl+5btne+nY4PMOKDvbDwnP1yy6vCLToOWehUSqQ6PYlg5a4U8iP8WgwbYJu3ZDhm6HJhywGZAnvVLlyGgFmzwAGfaBigWjVCTj/EXFo3VauqN9CjniMZmY86oV1OPtUnLzhTNXLLi36Tf6dg2a+0x/k37ubvYO7mDt2lpoxk3FwCuYVTk/2FUZJ9FtcMq2wJr4MtmZRMloGNFMi21eR7+q6V6DHaSZFEJN3nBcXbtMNPy3meIaRHZp6rBch8b5qQybW4nkzMcaEB7AeT3CbW1X7oDLpXNVo6nsA81KnJIuYWmNQYEkI7VDniYNbBqrPvq6rGknVRjOrEtUpQizhGl/PagbZ3TimerBYM+yKa9hQHsEs7WXdzc44efNoEHeYUtuizDdr3Fqb2ki+v3SSoxB2xvWRJNRQZC9VevAW8HJypKOSsupB7HQMtt2qhqzG9Ee6mROC19J9B2fNCAAW+XZx60lmEnuW5pUb/nVOQGuOTLY9rlRMiGKtEgt44QkycbA226CvvCnVDolxlj2hcFLI0R1ea1Gur5lYHzSc2rLzk6N6yOhMDK7dncgrjsGq8SE8tS2KeBs2nxK4AvwPqnELBz7NEhw3a5wm1dAG2lv0aNsOSqfTlgogh8CpqhUT/AU+b+ejxouYocBeyQyOwoln8smbbNcMyKQD1ushLITt6mHbBriWkdx7cIbFqygXiP7mK10QQLzaaVqqXGxMye1YDKbS1e/y8K3KEOaMzFHxAMfIi0CdJmAOOvIFXZfPc2rTnWv/USRxT1KWRa65D6egPM7oDpAoZ5rYNq1W2xzjxwl9iiRYZVuUWzLIwDuS6hjjjifh0CrZzDuaWURunHIBBrjrvYgIFhOR+0KXtWtWG4JclljNfYb01doC37dm3Q0C14U/jlKrL0HvPRPoGKnLdmiJ4El5Nzc5DF8WNUZF43Ly7U2KSKPHROJEGG7ZMLkHN29ft63osQuDy+fgdgB+xvgRub6fYHCgNZtfny5oT1j78FKnKHHFusMF/aub3zLljs7YJ+5yUA62ehmSFpXK6za/lSMbRxe3aofZyj2Qy9Ee6IoutLdk15kVWRtk/L9rd+V49pfZyWL2rda/BKvJYrIjy90TEtexbeo5OKnMfCPk41otJJpFMC4nsOt95NSi2OxWpfRR7rhGKNVPo5IiKBmwcglWk1LSbkiyAV+Svw5c5owzmAD1+AOWNafAFWP3L1+IAjSvOZbYEl3OAFAC4LEACa+ohTbpmU7Ft16c6ow0MI/08yMRC2neES+qINEpZ27VmAlX8k2FdRj2lJElqqpIUdU0ubrS+Fy4Jiqdt4aG3YhxpAF8ZqneeyOuoAy4F4ggUXrhpPw90x4Mbiwi8OWskMY9hWuamextU/TGNZrxL7yXJpv8uiovWarHp8uvPacA7gn3fAH3nSxQ3cwHnPtBlW2Jr2lGXIFj7cRNfvkKOojtjnLer2BzOIXgI2cEa19oKAHquV9fi4XvhxoE2xLcR3qTaB7wf7rw3/EpvMP6ZZIQNGssCV6fvaFVsAbQdMBdMW9Qn5wjQWAm6WdQOxWmAcK50BXMm68iG+SaF3rfslNOmtfqhICNzOlMVMm687T6qAWe/9D1+AKXmUb4H17Q6rKw/aBgXm2GNvl3PNjBfS3pPvTI5ZASyNpneqL8MpawIVmfstpCNKamEkmh+BOslHZ0SJI+VLiHmQnfAY7RiDO64eo/XsGqjHJUxll3DAzTMg73fi7i4c27bAlMon73Hr0xnJe2w8yEhoQBKMI9WjFMP2YsI4z8R8ksjGNKanUN6vJBqnMfUfQnNEcWdV8EnvzDoRv3Y+MQr285+3wB/Iq3wLTL8CqyvjhDKjhApssMccc3TIoYWbAJtamXXolhlulzMzQkhj25oASy+Mq72xDLLx+cZczgct7R+TEeVumL90LTYr9musXU8du5J63KBQwTTNDYPyvk+LEgexWtvxTBuvmrlURnR9IFGd9NaB4cJZWLFtxzCs9Cm8qHDVmC52jl1L75MlyYhO/b620xWVpdVmjMihlwDN91TYjtovZI4KvrNWzCHnNSFgs9zyHD4tsnRJG4W7rkz6KAC0yFCUR7MoG19JsZdow82gsaKFgNJAPg+0QFxFVgErDRpFFe79b1847WIdhFeLKfST41QCU6o8y7Z5DuRN/woyweIUuXdyQvUSLChWS/XRY1tNVdZSGBEHbMqufRPVWDqkZKdLn1SB9ns99e8uWE9niv3OjNPusswkSljhwy5bGwaaY44tVihxdFbp6RKYXsFkPV0Bn66A/3trQrOAUY8vM5j6Y74O2SnwPHb5n1TbM7TI8g73QYeNCILGeov5NYYdUPJsXfgIiB7zoQcq3X5J3Yi0d+OOKLRAuJaQXfEgt6mMpB4T0yLd75FN67zHVj1Gwz3Iz5lgwe+ExQMlu8Zmf3xx0BLLyl5e6/lb9h8JD+2dPGjlqnUb4FStsM9bYAk0WemcPgCcM6hDhhwd9jjggDm2OPoZFq+W+N3VDrgC8AGYfgB+vPVDaj8AuFzCtAli5dzP322eIAwzJKfmlRI1lWIa1/PKeNCSDKnEQcOSOn1KGAtrCRa1z4o6WuC2yHCspqiqk688smkRWpixIJNToVhH5BxQbLugXjZq18ouQqtaMUhAsrYW7uklp7+2SENaak+w/1NW1N7+nodRhgC8E9T5Cl2bo6y8SsRDLl1lwFtYsGbomO93id9d7ww6r8326VcT9iHQThcwmVELOC1MmxzQzYJif8vUyh6YFStHR9EY8MqXOqwaD5esgRZIM2wSuFqrG58VdawLHBd+PaEjSp8VVcL1rJTKmOr3AruHgGs3YtfArtVA60Tyubxq5C6GVGN1RMlLinRAkWo85sJKA9AAu4G106c4tTlOVeETGaxcUMx0CRRZgz3mKNDwmaGAD/8wgP1gtvkH4BkLMqQAABhySURBVNOdueMPCxgdeQHXLh5yyl/n+VY+Itwy8JJoISkA/Q43+OMxMl41Hr4KB61m06bsWjywG9F655iHso1eo7UzWASDBpDOipLjL3rCQz524+qxC+zzGSxU9VjrIhIR4xRgY3Ytr6YXE9nza8K9odyW5duDnzCBA5ZP14IJ0FZ2JkYv9/kDagvi+dUcWyyRoXUzLG7wA75eT3H54eSYFtfAp692VpIre50FXB02pTa8MxzqOaQiuzbAq0ftwM8BL/XG41iWzogLAUZrNIO2LJAc+aGKsGlFLLhrc+c9NplRJkvYsSyzYYaY1t0uV4/tdeSrzNGZGSxiQFOBpLEvA7FUjTWmlUCm+31VkeEK6YMgO5iSCwjAB6Cdx9kW9tBeSigATICqQg1gWx2xKrfImXq8wRrbbIXL6y+OafEBmNolXownCl49XgDHahp09ARQnmsFeHXYDGKgfeIGVbDa+x6UMYBOj8kdZlrtBofY1h1EEqTpI7BfA+ZlxyjsfapJNQ5HvAaqJAsDcP5LapdCRS67JphdoZCrDfRAK7uHkW7/sUz7ZqDl9uyY0T602TlCuBnFgTv0PI58KuyrObaltGkNcP/lwxfgR5jtC0yGVAnjoKLNqshNVgaeYgojcTWZJEOn2reqJDvvlI6ndYJcc4m3oWHQylH9ox1RJ7ljpLT+o7eFCRbUc7rkCnLzl8CsBGaNBy6tusLFpTICAdtmbYcyaxAkrmcCtCRJ21bbn/uPGGClTfvqoKWLxAYNcAcUN3P4yzoAuAzByqdrobakMS0DwClfYb/eIstCpv0Na9xdX2Bxfe9tW5p8ngbBc6ZlHX0b6FAexCTZGE9yFDl80MDQ8Dxe2HiN9DyblpuovBdNqsgQO+XNcdZNhHxq9BIsSEV+sM4n7t7Pc5MokUqwiF0ra++RlX7QANm1KtBcBcnYrGbfRgCr7YuB9sVFGygQ6ylkT07nUyNkoR8C7Ab+WZbQ+wTe1qoJtpsVsAa2mVmfh4D7ubzG4sf/Mkx7AwNYagOCbcPl1UoW62eGkA03mQkdw/hxoCJr7+zRQi3zueK0mk1L+5MsS04obtNqkIntExk1rGMIR7valfxKoBI27awE8ru+bdvjDMo/pueyqYyaXRtVj50to1Wn3KfYPUP27KuBViLo3JE+Ssw91cFr0YkAsOaYU13YyIEBm1k/b+5NIx7eAUL/hq1H09GHqjAfQ9R1dl+XuSlvpMhhhYEk7a/nlfPVY/oes2vdAdo4WmnL8iflNm2LWKz22JU4ZqVTjxsUPlZLNm0FTCo/97vkQVXIpgWQd/qYzjhoMeYK/phYOd8E05LQ+xkCLleVuTPKqsjttG/XUpvSmFaaATmAXYV93mG7MOrxjq3T89OPfzcq8if4AfElbIaF2WrLtHvMhD3LumQWcuqyPGDbjoF6WLQX9ZghjuddwUtMPQZCoCZVYyAEb6o7EsyrdAq0Vm0wQ3FWAuUpzIDJPMPKRRt6Dy2ea9ICPGHdg/YByCcCrFx4Oofkd+WEGMP2bNoHgM8//cyNwEgKnLFURnk8ddRMPQb6TqiKnTIE2grABrjHAvtPJqXxNzb9uFORuXqcwYeCroD9onLMvLefbgVIC8iuzdxE6UcUKEqTJJdbp9Tzi+aIGifnqcca0/ZG9zygn4uaugCJsG0jTNvUBZqycExLarIDK6UzVsAs8wMHYi4VJyJeG440IZu2RTz/+AwqHLJlAyA/AFXjltMw8hKg5cJtrJztix0H6OqX7SqlXTsEWqki27ju9naJzdXaxWoJuJ9+/C9UNO8xvf9LOJt2i5VbBcilv9quuIFRvZu6BACXpdXlfv1jYuKuzXRy6vXJMX1fE15/4wzk8eoxlcu/q6ox/aklDmo3r2REoY12DDxW61d5KTzLMvDOKjtnEMLqSIa/7S1Ke9bYtB1UFdcJv8KAjFaNm2BpyG9PtDguZ9qTV5EJsDt2egy0vFOzbbDerLC98h7kG3w02+IG//Lpiwct4PKS764u7EIiM2V5tQLHrrTrVJllby7yzgG4qI5ABsfEPGsruF9VSNs6Kftix79EcoVUXdQxtBywkaF30YuRKLFa21PzWC2fobiXYFGZgQN8XbOkn4A/B8PGYP6xk6FURrYvR/9TZdwHXNg1brKAaV9SpC2b1E+YEFippvmSZyLJghc3BrQE8s0U29+vsCn9Wng3uDYLR/+0xWV98qBdAg/XwLY0ID/YJamNmlzgYEFMK0GaRdJzswxOdTRplLVfpqRtM2OaPIuz6Wma0vMwraoaxwDLg/CyUOG4Uh1efA0132M+WOcTB++09O9/inCS0Gi1WTVZDsBW84+BAeAm/kupx862bczCytURRWZGHL2NpFqqRKB0NjIVmTMtJwCtE+PjiB1oge1mhe2nFfwCloZxV9kWsx//YYZpAkAJbK+mQULGHjM01q51jsy6MICt7ftpp7gHjAvKDmagFSPR5v0236ualzZdHsu09J/KsvJpIkPveqKAnTGsDxlMxLLPhmn3iwssyvvQti2BOfya3VKR61Vvj2G9IwpAmH8M8RmEA/h35SWOsmfNiumlBSytIPe6MjbkI3ORaR/PkJqGTEsTgGumXC7+o7THDXC/WWDzyayF9xnXuMZHN8tieXXEujIHN6VfDZ5s2oNdJNO1m6606y1Pw7Hj8MClVSNPdYFgnPezSMzeTcNyWO+R7Cr/67GsFpsdckhJEbFa6YxCGdglDYxzalHWfoZ5y1iz0iRZEMsCI2xa+0zkiAIM87pZGYGIisxloJsYsmnzFmXVoCgpFeA1mXasSiyPJT2Go47evRhAIE+X9Urtijuu1gA+A9vfL7G98mGfNX7DClsUaNCWPgZLC116pp27rUGJo2NZhJGSGiDg3pNJQqqxmrL7VEmm/vRk3JvhvR7f1zuIPmPqr3aOBDZ3Rk17gEUNO12JZ1kXaF/WoW1LzqjGW1syJzkm6iyA/k+lkcVmrlAL7/8WbHtRmXxn7zo5OvZ/OdGYNRbeSQlnW8W25fXXm75H/E/HAIZxN0D9+QfrRf7Bq8fYocDRZS51yMIBBgy4FLPd7+ZmjVkOWn49TGGmQWkNG8eA+qzgHV68awC0ymzx0eNkIoV8QtUIViSSyhh4kLMg7BOM9iH1mJxRZd8RFURQtRBcF07ulTObNm7Pnimabcy2wrKsT7prgtS6lxfZS2tMwMMVEN95B0ygnRm25fasxrRA6EvhoN0B2EywuVvjZuFZdoUtSjRmIjY7QmePOQPsEgfM7DbHoZmHLBuox0xyu9wrb4PPyrYxFTl9RkJsRSeHHFHKImdY6VzSXrhmyUditWJqm6YuXUqbX0etDL3HnG0zYNb5KxHTqtzBbqc36jI10qfn3pIqjxiSR6KqxyfkeRcYAHMcXoFpz5WhhAzpp7BsuxOHqj4CeEDT8ZS7/BnYfV5jszBs+xk7LLFFhg4N/PQ1RxTOWRWoyN0cTV14lpX2tbw3up9UMpH7fn6yhJHnyj12FU1TiUjw8hxjIARuDKxcTqxsTU1Gn2lt2IfYlas7p4WYZsQOgqZ4LX8SgtgkaZeGsxe4kT5UQFRif+b+I7l1xmOMkGn5eq2vI2Ns21i2FO/IW/hpaGx3WbPDYhoH4B1XLYyvYkPbFJuPhm1X2OJXfAKNgaU62mPmwLrjoN3NUO/mHrDSpuWgrMQ+GeZ8Vtt2nAy8EXoB1vvXO1zaoTwTSjoixgBZlieKccDlK5Uytq0uMK3ue2w7K4H5nVfSQE8TW4y6DdXjTIJFbWCxtWoTopVTwSRTZIZVKe+LgPvyIkE41inF9RieYMHbzhxukGQ7CYfpaeoxL7KFn/mC2HZt2PYG104jaVCitPXUoMQWy8CDvMXKAHZXhYBVbVoho0e1pero6SGhEUybEqn+jFUNtDCQvJZgWqYeo54EtqyJv1kP8qLu2bWTygB0JnA3padPrCTP1dHe8LykSHWZ7ZafYsvy1kWiiyCP5y3CPmNEpjPmYr9kW2Z21dDrhLMcV49JRd4A+DzF5/U1Zld7p5UcUbrOjXKNuTPqcDfzgOVbTD3m+0bPQPoUGXZGDTS9PUzvSMKfQHM4aKwqbdyUyDKgqsdoYW0Wz7gHG4cDhX34Zr3I7Z1wRuVQF+yS4nKPufRsWi4jvceq/fSAPKcZM/zkcgTgt7FpOeWNPV6qx5x1SSxwpXtD1ilnX2LbzwDW5EneYY6Dc0TRXMrcg+zU5M2qD1jJtEPqMW+L/L7VZ5civfHnv8+n+D/f5b+txBxMWgPjrEpC7Ero44Clzxah6pxY05aYkLKpHNMCWE5ws7xG+cmrxKQet8jsnMkWtLdLw7Ib9IcLxmxaybSaBzlWNe6PWNjscR3wCPVY9hZc5eHHSAeEVhbfr5XLjwVcgoWsKBar5WpygyKYNjPIjFqYmfpIRZ7CqscRVZfYlcdrg4Hwqgw4oGJ/BVtrnVB+onSya+fYf4PqsaZTnsQ+evc06c/e7pdqNP1mmUc7VgRnWgda4H65wOfqGtmVcURR3XHQbu7WqDcrHzbS1GOS2CgkTTUOBsvwtavOlWdLrpC2p0bp0rWveQ+5cAVVi+3ybKoWsQQLM0TPq8W0PVTAhGdFlfb7nVGRUQNtZ2e24CvI03KZivAVyZHb2HVSPabnk7aJsrKA4jnOMlq1z3uQ59i/clbU2BRGKdTKpZpID8jrhGeKcXQw9uVqKDmu+Mp1Frh1/gE3eYdmUTjbn4be7e6sWryZ6qAd4z2mR5POqx5HPTbkM/78MxxRsUOVnOGelzjmNU7F+GyZkVjtsS5xvCqci4a2/eICC/IgE3itU2pmR4C0rbFnJxysMTtTk+gx08QBuf9QbVmzTStjtxYuocLrEWTXfntCgNPCP/RwBEzOuvx8IEQHnTP1795614NJz9kAi13+Ec26dKOiANO51xywtMkJ57QJH6R6HDhDxTHBc4wNdz5uIPwZTBsT6WzgT6ElWki1SZYjUxlZkQy49zU149Lx0R4z70FW1OTJwmZG5ZZl2fo/qdoIQj55C5PehnA7V+S5gef46FRznj5CnuTXk6ewLRC2fvnuaT4R+m/KPjlbw+wjliOmJbAGK7JPcKovcVqe4Gb5oMEApE5zoG7Ydw7QCjpogX5sNwCtRlaI/NbqdRx4nxjykRfi6q0EJKAPCpbX4JZ9KlY7dWNqKQmcvMhY1J5pWZIFGmDSwaxJS5cfAdje90GQPiJeazfyHHtvcedGDpOK/LoyFriabWs7OAfYqfg9RqhyxER/cgvmU57CpR5qKq3GlNx7TENSpeorHVA9puUHvpw8E9PyY6VdKkEaK1+q16xs6QAgu1ZjWspBlgv/Ltj5ZLvm8EzM7VvVMSVsSZVptTjFQBWLjiPL/ZBAOXL49fOPSc5h3JiKLNlWNmzJsrKcKYIZMDjb8jokkMrf3OvM52DWmDamHgN90DtHFE/nlc8l1X/+3/nyjEwrWVYDa8z1LcvjqrId0iUcUaiBw90M+4Uf2ExM69IZOdtSsgWvP64ei5qIrlZOS15K0ZSGmGjXzAHkD8hyckL5GK1MZ3wbORe4XGKNliqN27waYOH/2028CkvA5XVZw3TWmvMoZdNK980Y0AbqMU0dODY34U1tWqBv14L91tSh2ANpqnYbOqPYRgMHDpZhSU0+LKeYlqcQsAv4Fd8B/+I5gBIeZFUea89qZeQA8tYt7+jtWe9mM+rxWzqihjpdTUXm53EzKXZuzK6l3/NQFebvsIUZcyuntOEA5UzL47W8SQ7ZtHJz9xcz9bTfsnPSzEldnoFpAT0rioqPAVcrg64pOgvNhggGDtCYWvs7K4HFyQN2CT8fLrEr4JcTkcwngMtV44u8M6u8aZpwbwpVRdTz6PrB9NnuM5yn462YlovszFMg5sfQebFMO01F5te09dpO/UoFG1FMi/480dzuleqxBC0nfyIKGbdVM6k4w2q+nZimcr6K/IxMKyV2g5qzQjtOhH1UB0TJlMbCTSmyxwxY7Pqzz+/gGRfoM+xY5tSOiarHAx0fu+ZF7md+5CEePkTvbWzacySm4sq2tIeuEsvfB7aPyvtgTCa+xAhdOgVaDlzpoJLOSQ5enh8tNb6Wno2bdFzblM8u2ZbvU71aPRmp3MmCNGeCZFnuwoc4LnYLml3MnFE9u3YSgJXAG9i1PPSzRDAPlLNrpZqc91cAj85ekazBhA2omXcIp24lZxS3aecum+hbEvmeuU75GE9qzN6j2O4WwMrbt1w00FKb4QwrQctvW4JWOrp4B+DuUQt3pp4L6ONnnIxk2tQA3ZS9wit+yIkhdXrRCXDAsu+HZm7TGUvGtHMzTG9xH7ItLYVIQqvsEcsKttWcUark8ssZ082wRpHl4aB7Wo3eJFv4VYy+TYl10GNzmLXjJdtKueyrx6TOagwsQduzS62MBW0LGK8xn1KHg1cQT68jexFHlLRJNFtDHneuZ0YaExp7IwRs4IyidMYZi9cW2JdzLBa7/ogfeatseUz3G55p+QLEyUfs7RtRD+KQLOf2rB/pUzqWPXyjTKtJrK0AfRLQHFgpVqIyrGOKL1LNQRtTaXvhGuXWuRNKlkXnAgjBKrVNrWC6d4jjUueF8kw2LS8u5ZSIuPGD33Rd/p2FfUTlH+sS+6sZswDJi2ztWp5cwe3ZDh6wQjVOeZAzckQB4ct8ithyaAUBYlaeZPHtMy2Q1qg00MUQwyv1pOyTMveeYAr3SOeRNK3cpeXsK3RvOdxsoFHZI2RZadfGQj+pBKNhzD2T95h6PS33VgMr7ZfH8Z5ZeKQjAwfuax/B9FNkmsm7TqW1awmwtOAwvxxPdWTqcasxLJeYF/hcyeXP0Bnlkyz8slHfj2hOqXOIgLeRVOyzBbCCm6JVY1q+AfBg5Sot7Ek0ZJDWXNSmWSKgfmXnE3A1jZGLdLzJ5zsp54RnjxAewpGxOg7YIZtOS7iQ+r68eQvcqAd56pxRx8CDbOO1FPqR6jF5BLlqbO3bB+aIap2aPKaq6OWmBg4oErFpc2bXerb9lpkW6LcP2RnHvqckpj6fxHc772admoiQMyBXa7lM2X8xIjqgz7TSexxTeVOmw7CMVI/lBej3HHHAjqUfTT2ma0c8yFJF7kocM68Wk6q8z+a4XNyGoCXViC5LgGVM22YAX3z47McAMMoZ1bNpxeyPgV3bfMPe43NEa7CSDGIqJQeBVKE5EGmG69j59ClZlt8PjytTzrS8nuaAOrBj+DPz55RDEemYlDYR3l1CpNeGX3Am/pNgHZPyJm0gzrb8HpgHWXiPUQP73Qz7qzmbvHzmAHxa3IahH1KPScvkCRd265z3OAs+e/JcNi2VBT/4Pm7XfutMS8LfrVSTn8Y0YYyXNja3cm9aG7ofwAOM7ksLVQL9Ni3Ve87UmjNKA2HquZ8t5EMXkiInIkXkN5Tfsf/4C+UPze5B8R5jZ5xRzZVnWm7X9kI/DYwTiux/vjymtYW6/IIB9nwv8FnCgJ9l4SwZql3bNeelWr6pxIDLZQi8ml1LL4+ro9R2YjOHAn0gad7eYL5O9p3uVZ7LgcvLk9ehciTrpu5PlxHqsYy1cluWitDs2jEieyEqT/aA1oPcioED9vO+LoKlDPlnL/RDDFsjVI0pXlsCXR4uv/V0GevQA3L07dpg8EB98trCdyEacPl+TZsbU6YEL9mhqXYoQcQBK73HnK1THUBM7ZbX4t9TeQ/DcqZ6zHseqhwJ2LEjQeTlZY/J74F5kKPOKL54RuhJPi12RkVeIhw0QLdAgLVM22YE2NzegQfxec91Rl3kD66bAKACt+walA2+M9ACfeACfYCmGnIM7Dn75AwriYXO459UrtZJ8Eno6F61e6LyJGi1zoFEe+7Ysbo8QrGL2a9aD8eNeU34DXLVWKo/zIMsWNapyI1JqDgE6rFdt4V7kWv03zef3Nw5oTznja6WpIzvWT1gW2fHlpZlJzJ757sRzatMMoZhY6q2Fqqh35pooRjNEaXNZaXdU4q9tXeuRUvkf+m6GOk9nrINbB8vQmNa+bCyMqTX8CT2Kb2XZtfWwH7H0xlnbqLqPeahFzkGWqsqP1T9LChu13btuWw7Qt1jb4ED1ncdlutb4LsK06qisczYDk1jaQlUOZleKj485rpamdr5Gvhi1x2TFpy+ozMPkQa69pufR+jgrEuVQMzKy5ZOKIS/FcDSMD3ugAqWNMQM9eIWFSVYUN5/Dq8WW6ZtM6BBwaAz4EF+LsnFgASgpx5PG/w3AC2Xx3qPNQfOW8s5z/LY5zYyeXh4ylyt7/Iu7/LacvHWN/Au7/Iu58k7aN/lXb4zeQftu7zLdybvoH2Xd/nO5B207/Iu35m8g/Zd3uU7k/8P0GtNSIWZx/8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "fig = plt.figure(figsize=(4,2))\n", + "ax = fig.add_subplot(1,2,1)\n", + "ax.axis(\"off\")\n", + "ax.imshow(img.T, cmap=\"jet\")\n", + "\n", + "ax = fig.add_subplot(1,2,2)\n", + "ax.axis(\"off\")\n", + "ax.imshow(corr.T, cmap=\"jet\")\n", + "\n", + "plt.savefig(\"./Figures/2D_Field_Tilted_Plane.pdf\", dpi=300, transparent=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80\n", + "[[ 1.25 -0.72168784 0. ]\n", + " [ 0. 1.44337567 0. ]]\n" + ] + } + ], + "source": [ + "\n", + "step_size = 0.05\n", + "env_size = 4.\n", + "b = int(env_size/step_size)\n", + "\n", + "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size]\n", + "X = X.reshape((2,-1)).T\n", + "X = X - env_size*0.5\n", + "\n", + "angle = np.pi*0.5\n", + "rot = 0.0\n", + "\n", + "Plane_base = np.array([\n", + " [np.cos(rot), np.sin(rot), 0],\n", + " [np.cos(angle)*np.cos(rot + np.pi/2.),np.cos(angle)*np.sin(rot + np.pi/2.), np.sin(angle)]\n", + "])\n", + "\n", + "\n", + "PL2 = np.array([\n", + " [1,0, 0],\n", + " [0,1, 0]\n", + "])\n", + "\n", + "\n", + "\n", + "X_ = np.dot(X, Plane_base)\n", + "\n", + "\n", + "\n", + "X_2 = np.dot(X, PL2)\n", + "\n", + "img = create_firing_field(X_, A)\n", + "img = img.reshape((b,b))\n", + "\n", + "thresh = 0.7\n", + "voxels = g > np.amax(g)*thresh" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import scipy\n", + "\n", + "\n", + "def get_3dA(s):\n", + " B = np.zeros((3,3))\n", + " B[:2,:2] = lattice(np.random.sample()*np.pi*2.,np.pi/3.)\n", + " B[:2,2] = np.random.randn(2)*0.05\n", + " B[2,2] = 1 + np.random.randn()*0.1\n", + " A = np.zeros((2,3))\n", + " A = np.linalg.inv(s*B)[:2]\n", + " return A\n", + "\n", + "\n", + "for _ in range(3):\n", + " A = get_3dA(s=0.8)\n", + " \n", + " img = create_firing_field(X_ + np.random.randn(3), A)\n", + " img2 = create_firing_field(X_2, A)\n", + " img = img.reshape((b,b))\n", + " img2 = img2.reshape((b,b))\n", + " \n", + " f = img\n", + " f2 = img2\n", + " f = f - np.median(f)\n", + " f = f/np.std(f)\n", + " \n", + " f2 = f2 - np.median(f2)\n", + " f2 = f2/np.std(f2)\n", + " \n", + " corr = scipy.signal.correlate2d(f,f, mode=\"full\")\n", + "\n", + " fig = plt.figure(figsize=(2,1))\n", + " ax = fig.add_subplot(1,2,1)\n", + " ax.axis(\"off\")\n", + " ax.imshow(f.T, cmap=\"jet\")\n", + "\n", + " ax = fig.add_subplot(1,2,2)\n", + " ax.axis(\"off\")\n", + " ax.imshow(corr.T, cmap=\"jet\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/experiments/utils.py b/experiments/Figure_Creation/Tilted Planes/src/utils.py similarity index 60% rename from experiments/utils.py rename to experiments/Figure_Creation/Tilted Planes/src/utils.py index 5608140..7f8bb2e 100644 --- a/experiments/utils.py +++ b/experiments/Figure_Creation/Tilted Planes/src/utils.py @@ -1,35 +1,7 @@ import numpy as np -import pickle -from os import listdir -from os.path import isfile, join from scipy.stats import ortho_group -def gather_data(mypath, key="width"): - """ - Loads trials from a folder and - returns an array indexed by: m, k, t. - """ - filenames = [join(mypath, f) for f in listdir(mypath) if isfile(join(mypath, f))] - filenames = [f for f in filenames if f.endswith(".p")] - W = [] - for filename in filenames: - with open(filename, 'r') as f: - data = pickle.load(f) - W.append(np.expand_dims(data[key], axis=-1) ) - - W = np.concatenate(W, axis=-1) - return W - - -def normalized_histogram(data, bins=200): - h, b = np.histogram(data, bins=bins) - h = h.astype(float) - h= h/np.amax(h) - return h, b[:-1] - - - hex_base = np.array([ [1., np.cos(np.pi/3.)], [0., np.sin(np.pi/3.)]]) @@ -79,5 +51,3 @@ def create_firing_field(X, A): - - diff --git a/experiments/Figure_Creation/_Figures/2D_Field_Tilted_Plane.pdf b/experiments/Figure_Creation/_Figures/2D_Field_Tilted_Plane.pdf new file mode 100644 index 0000000..8ce39a1 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/2D_Field_Tilted_Plane.pdf differ diff --git a/experiments/Figure_Creation/_Figures/3D_fields_lego.pdf b/experiments/Figure_Creation/_Figures/3D_fields_lego.pdf new file mode 100644 index 0000000..7fa05d3 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/3D_fields_lego.pdf differ diff --git a/experiments/Figure_Creation/_Figures/3d_field.png b/experiments/Figure_Creation/_Figures/3d_field.png new file mode 100644 index 0000000..bf5ea87 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/3d_field.png differ diff --git a/experiments/Figure_Creation/_Figures/Fig3a_Capacity.pdf b/experiments/Figure_Creation/_Figures/Fig3a_Capacity.pdf new file mode 100644 index 0000000..f03ea8b Binary files /dev/null and b/experiments/Figure_Creation/_Figures/Fig3a_Capacity.pdf differ diff --git a/experiments/Figure_Creation/_Figures/Fig3b_Capacity.pdf b/experiments/Figure_Creation/_Figures/Fig3b_Capacity.pdf new file mode 100644 index 0000000..23f7272 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/Fig3b_Capacity.pdf differ diff --git a/experiments/Figure_Creation/_Figures/Fig4a_Trade_Off.pdf b/experiments/Figure_Creation/_Figures/Fig4a_Trade_Off.pdf new file mode 100644 index 0000000..933d5d1 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/Fig4a_Trade_Off.pdf differ diff --git a/experiments/Figure_Creation/_Figures/S1Fig_1d_bench.pdf b/experiments/Figure_Creation/_Figures/S1Fig_1d_bench.pdf new file mode 100644 index 0000000..b125d3f Binary files /dev/null and b/experiments/Figure_Creation/_Figures/S1Fig_1d_bench.pdf differ diff --git a/experiments/Figure_Creation/_Figures/S1Fig_1d_distr.pdf b/experiments/Figure_Creation/_Figures/S1Fig_1d_distr.pdf new file mode 100644 index 0000000..0fff805 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/S1Fig_1d_distr.pdf differ diff --git a/experiments/Figure_Creation/_Figures/example_bubbles.png b/experiments/Figure_Creation/_Figures/example_bubbles.png new file mode 100644 index 0000000..bfcd4a2 Binary files /dev/null and b/experiments/Figure_Creation/_Figures/example_bubbles.png differ diff --git a/experiments/Figures/Decoding_Figure_4b-c_bottom.pdf b/experiments/Figures/Decoding_Figure_4b-c_bottom.pdf deleted file mode 100644 index 3f357ea..0000000 Binary files a/experiments/Figures/Decoding_Figure_4b-c_bottom.pdf and /dev/null differ diff --git a/experiments/Figures/Decoding_Figure_4b-c_top.pdf b/experiments/Figures/Decoding_Figure_4b-c_top.pdf deleted file mode 100644 index dddd095..0000000 Binary files a/experiments/Figures/Decoding_Figure_4b-c_top.pdf and /dev/null differ diff --git a/experiments/MATLAB/Copy_of_test.m b/experiments/MATLAB/Copy_of_test.m deleted file mode 100644 index 62477bd..0000000 --- a/experiments/MATLAB/Copy_of_test.m +++ /dev/null @@ -1,209 +0,0 @@ -global Rhom -Rhom = [cos(0) sin(0); cos(pi/3.)+cos(0) sin(pi/3.)+sin(0); cos(pi/3.) sin(pi/3.); 0 0]'; - - - -x = -1:0.02:1.; -y = x; - - -z = x; -[x,y,z] = meshgrid(x,y,z); - - -sz = size(x); -x_ = reshape(x,1,[]); -y_ = reshape(y,1,[]); -z_ = reshape(z,1,[]); -X = vertcat(x_,y_,z_); - - -n = 4; - - -A = zeros(n, 2, 3); -B = zeros(n, 3, 3); -size(A); -for i = 1:n -% --------------------- - -B(i,[1;2],[1;2]) = Rhom(:,[1; 3]); -% B(i,:,3) = [0;0;1]; - -B(i,[1;2],3) = randn(2,1); -B(i,3,3)=1; -B = B.*1.; -Ai = inv(reshape(B(i,1:3,1:3),3,3)); -A(i,:,:) = Ai(1:2,:)*RandOrthMat(3); - -% --------------------- -end - - -clf; -for i = 2:n -% --------------------- - -Ai = reshape(A(i,:,:), 2,3); -f = can_distance(Ai*X, zeros(2,size(X,2)) ); -f = exp(-f.^2/.1); -f = reshape(f, sz); -colormap jet - -thresh=0.8; - - -azim = 0; -elev = 45; - -subplot(2,n,n+i); - - -a=.5; b=-.0;c=1;d=0; -[x_ y_] = meshgrid(-1:0.01:1); % Generate x and y data -z_ = -1/c*(a*x_ + b*y_ + d); % Solve for z data -h =slice(x,y,z,f,x_,y_,z_, 'linear'); -set(h,'edgecolor','none'); -xlim([-1 1]) -ylim([-1 1]) -zlim([-1 1]) - -lightangle(azim,elev); -daspect([1,1,1]); -camlight -lighting gouraud -grid on -view(20,20) -set(gca, 'XTickLabel', []) -set(gca, 'YTickLabel', []) -set(gca, 'ZTickLabel', []) - - - -subplot(2,n,i); -isosurface(x, y, z, f, thresh); -isocaps(x, y, z, f, thresh, 'above'); -xlim([-1 1]) -ylim([-1 1]) -zlim([-1 1]) - -lightangle(azim,elev); -daspect([1,1,1]); -camlight -lighting gouraud -grid on -view(20,20) - -set(gca, 'XTickLabel', []) -set(gca, 'YTickLabel', []) -set(gca, 'ZTickLabel', []) -% --------------------- -end - - -h = subplot(2,n,1); - - -vert = [0 0 0;1 0 0;1 1 0;0 1 0;0 0 1;1 0 1;1 1 1;0 1 1]; -fac = [1 2 6 5;2 3 7 6;3 4 8 7;4 1 5 8;1 2 3 4;5 6 7 8]; -patch('Vertices',vert,'Faces',fac,... - 'FaceVertexCData',hsv(6), 'FaceAlpha', 0.2); - - -lightangle(azim,elev); -daspect([1,1,1]); -camlight -grid on -view(20,20) - -set(gca, 'XTickLabel', []) -set(gca, 'YTickLabel', []) -set(gca, 'ZTickLabel', []) - - -h = subplot(2,n,n+1); -a=.5; b=-.0;c=1;d=0; -[x_ y_] = meshgrid(-1:0.01:1); % Generate x and y data -z_ = -1/c*(a*x_ + b*y_ + d); % Solve for z data -surf(x_,y_,z_, 'EdgeColor', 'none', 'FaceColor', [0,0,0],... - 'FaceLighting', 'flat',... - 'FaceAlpha', 0.3); - -xlim([-1 1]) -ylim([-1 1]) -zlim([-1 1]) -lightangle(azim,elev); -daspect([1,1,1]); -camlight -grid on -view(20,20) - -set(gca, 'XTickLabel', []) -set(gca, 'YTickLabel', []) -set(gca, 'ZTickLabel', []) - -print('tuning', '-dpng', '-r300'); - - -save('mydata', "A","B") - - -function d = can_distance(X, Y) - global Rhom - Z = mod(X - Y,1); - Z = Rhom(:,[1; 3])*Z; - n1 = vecnorm(Z - Rhom(:,1), 2, 1); - n2 = vecnorm(Z - Rhom(:,2), 2, 1); - n3 = vecnorm(Z - Rhom(:,3), 2, 1); - n4 = vecnorm(Z - Rhom(:,4), 2, 1); - D = vertcat(n1,n2,n3,n4); - d = min(D,[],1); -end - - -function g = normalize(f) - g_ = f - min(f,[],'all'); - g_ = g_./max(g_, [],'all'); - g = 1 - g_; -end - -function M=RandOrthMat(n, tol) -% M = RANDORTHMAT(n) -% generates a random n x n orthogonal real matrix. -% -% M = RANDORTHMAT(n,tol) -% explicitly specifies a thresh value that measures linear dependence -% of a newly formed column with the existing columns. Defaults to 1e-6. -% -% In this version the generated matrix distribution *is* uniform over the manifold -% O(n) w.r.t. the induced R^(n^2) Lebesgue measure, at a slight computational -% overhead (randn + normalization, as opposed to rand ). -% -% (c) Ofek Shilon , 2006. - if nargin==1 - tol=1e-6; - end - - M = zeros(n); % prealloc - - % gram-schmidt on random column vectors - - vi = randn(n,1); - % the n-dimensional normal distribution has spherical symmetry, which implies - % that after normalization the drawn vectors would be uniformly distributed on the - % n-dimensional unit sphere. - M(:,1) = vi ./ norm(vi); - - for i=2:n - nrm = 0; - while nrm" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\"\"\"\n", - " Figure 5a\n", - "\"\"\"\n", - "\n", - "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", - "fig, axes = plt.subplots(figsize=(6., 1.55), ncols=len(ks[:4]), sharey=False, tight_layout = {\"pad\": 0})\n", - "\n", - "axes[0].set_ylabel(\"Capacity\")\n", - "for i,ax in enumerate(axes):\n", - "\n", - " ax.set_title(\"N = {}\".format(ks[i]))\n", - " ax.set_xticks(ms)\n", - " ax.spines['right'].set_visible(False)\n", - " ax.spines['top'].set_visible(False)\n", - " ax.set_xlabel(\"M\")\n", - " ax.set_yscale(\"log\")\n", - "\n", - " ax.set_xticks(ms)\n", - " ax.set_xlim(0.5,ms[-1]+.5)\n", - "\n", - " \n", - " k = ks[i]\n", - " k_ = i\n", - "\n", - " \n", - " valid = np.where(ms>=k)[0]\n", - "\n", - " \n", - " ax.plot(ms[valid], prediction[valid,k - 1,1], \n", - " color=\"black\",\n", - " linewidth= 3,\n", - " linestyle=\"-\",\n", - " marker=\"None\", markersize=2 , markerfacecolor=\"black\") \n", - "\n", - "\n", - " valid = np.where(2*ms>=k)[0] \n", - " a = np.exp(log_mean - 1*log_std)[valid,k_]\n", - " b = np.exp(log_mean)[valid,k_]\n", - " c = np.exp(log_mean + 1*log_std)[valid,k_]\n", - " \n", - " ax.plot( [ms[valid],ms[valid]] ,[a,c], linewidth=1.,color=\"black\",linestyle=\"-\", alpha=1.)\n", - " ax.plot(ms[valid], b, marker=\"s\", color=\"black\", markerfacecolor= \"white\",markersize=4,linewidth=1., linestyle=\"none\")\n", - " \n", - "\n", - "plt.savefig(\"../Figures/Capacity_Figure_5a.pdf\", dpi=300, transparent=False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\"\"\"\n", - " Figure 5b\n", - "\"\"\"\n", - "\n", - "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", - "fig, axes = plt.subplots(figsize=(6., 1.55), ncols=len(ks[:4]), sharey=False, tight_layout = {\"pad\": 0})\n", - "\n", - "axes[0].set_ylabel(\"Capacity\")\n", - "for i,ax in enumerate(axes):\n", - "\n", - " ax.set_title(\"N = {}\".format(ks[i]))\n", - " ax.set_xticks(ms)\n", - " ax.spines['right'].set_visible(False)\n", - " ax.spines['top'].set_visible(False)\n", - " ax.set_xlabel(\"M\")\n", - " ax.set_yscale(\"log\")\n", - " ax.set_xticks(ms)\n", - " ax.set_xlim(0.5,ms[-1]+.5)\n", - "\n", - " \n", - " k = ks[i]\n", - " valid = np.where(ms>=k)[0]\n", - " for d in range(1,5):\n", - " l = 3. if d == 1 else 1\n", - " c = \"black\" \n", - " ax.plot(ms[valid], prediction[valid,k - 1,d], \n", - " color=c,\n", - " linewidth= l,\n", - " linestyle=\"-\",\n", - " marker=\"None\", markersize=2 , markerfacecolor=\"black\") \n", - "\n", - "\n", - "plt.savefig(\"../Figures/Capacity_Figure_5b.pdf\", dpi=300, transparent=False)\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.10" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/experiments/jupyter notebooks/Firing fields - Figure 4 and 6.ipynb b/experiments/jupyter notebooks/Firing fields - Figure 4 and 6.ipynb deleted file mode 100644 index ef2cff7..0000000 --- a/experiments/jupyter notebooks/Firing fields - Figure 4 and 6.ipynb +++ /dev/null @@ -1,280 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "from scipy.stats import ortho_group\n", - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import Axes3D \n", - "\n", - "%matplotlib inline\n", - "\n", - "import sys\n", - "sys.path.append(\"../\")\n", - "\n", - "from utils import create_firing_field, get_3dA\n", - "\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Conjunctive firing fields" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "step_size = 0.1\n", - "env_size = 2\n", - "b = int(env_size/step_size)\n", - "\n", - "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size, 0:env_size:step_size]\n", - "X = X.reshape((3,-1)).T\n", - "X = X - env_size*0.5\n", - "\n", - "\n", - "f = np.ones((5, b,b,b))\n", - "A = np.zeros((5,2,3))\n", - "for i in range(1,5): \n", - "\n", - " if i==1:\n", - " Q = np.eye(3)\n", - " else:\n", - " Q = ortho_group.rvs(3)\n", - "\n", - " A[i-1] = np.dot( get_3dA(s=1.), Q)\n", - " \n", - " g = create_firing_field(X, A[i-1])\n", - " g = g.reshape((b,b,b))\n", - " f[i] = f[i-1]*g" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\"\"\"\n", - " Figure 4b-c (top row)\n", - "\"\"\"\n", - "\n", - "fig = plt.figure(figsize=(22,4))\n", - "\n", - "thresh = 0.7\n", - "for i in range(1,5):\n", - " ax = fig.add_subplot(1, 4, i, projection='3d')\n", - " ax.set_title(\"M={}\".format(i))\n", - " ax.set_xticklabels([])\n", - " ax.set_yticklabels([])\n", - " ax.set_zticklabels([])\n", - " g = f[i]\n", - " voxels = g > np.amax(g)*thresh\n", - " ax.voxels(voxels, edgecolor='k')\n", - " \n", - "plt.savefig(\"../Figures/Decoding_Figure_4b-c_top.pdf\", dpi=300, transparent=False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\"\"\"\n", - " Figure 4b-c (bottom row)\n", - "\"\"\"\n", - "\n", - "fig = plt.figure(figsize=(22,4))\n", - "\n", - "\n", - "for i in range(1,5):\n", - " ax = fig.add_subplot(1, 4, i)\n", - " ax.set_title(\"M={}\".format(i))\n", - " ax.set_xticklabels([])\n", - " ax.set_yticklabels([])\n", - " ax.set_xlabel(\"x-coordinate\")\n", - " ax.set_ylabel(\"$Pr$\")\n", - " \n", - " g = f[i]\n", - " \n", - " ax.plot(np.max(g, axis=2), color=\"C0\")\n", - " ax.axhline(np.amax(g)*thresh, 0, b)\n", - " \n", - "plt.savefig(\"../Figures/Decoding_Figure_4b-c_bottom.pdf\", dpi=300, transparent=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Firing field on tilted planes" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(20, 20)\n" - ] - } - ], - "source": [ - "\n", - "step_size = 0.1\n", - "env_size = 2\n", - "b = int(env_size/step_size)\n", - "\n", - "X = np.mgrid[0:env_size:step_size, 0:env_size:step_size]\n", - "X = X.reshape((2,-1)).T\n", - "X = X - env_size*0.5\n", - "\n", - "\n", - "Plane_base = np.array([\n", - " [np.cos(-np.pi/4.),0,np.sin(-np.pi/4.)],\n", - " [0,1,0]\n", - "])\n", - "\n", - "X_ = np.dot(X, Plane_base)\n", - "\n", - "\n", - "i = 1\n", - "img = create_firing_field(X_, A[i])\n", - "img = img.reshape((b,b))\n", - "\n", - "g = f[i]\n", - "voxels = g > np.amax(g)*thresh\n", - "\n", - "print img.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 73, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAALwAAAH+CAYAAAAmrmR4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvXmYHWWZ9/+p5ezn9Dm9r9mXzk4WkgABZHNBRBDEQUbBnXFD1PGdn6PjT995Z3TQARfgFRAXRBGQXWQJEAghITtJJ93pTjrdnd6Xs+91qup5/6icY3fSKzIQTX+9vC5N16l6qupbz3Mv3/t+JCEE05jG6QL5nR7ANKbxdmKa8NM4rTBN+GmcVpgm/DROK0wTfhqnFaYJP43TCtOEn8ZphWnCT+O0wjThp3FaQZ3i8dNp2WmcqpAmc9D0DD+N0wrThJ/GaYVpwk/jtMI04adxWmGa8NM4rTBN+GmcVpgm/DROK0wT/q/EdMXY3xammniaxnGYpommaWQyGVRVLfxXURQkaVI5kGm8A5gm/BQhhEDXdXRdZ2hoiFgsRlFREW63G0VRiMfjKIpCIBAofACyLE9/BKcIpgk/BZimSW9vL9lslqGhIQzDIBAI0NvbSyKRKBDb5XIhyzIOh6NAdEVRsNlsKIpSWAWmP4K3H9IUbdDT0mAVQpDL5dB1ncbGRoaGhliyZAnl5eVomoYsW66QruscPXqUTCYDQDqdxuVyUVRUhM/nw+v1oqrWHCNJ0ggzaNoU+qsxqYc3TfhxIITAMAxyuRzJZJKmpiYkSaKkpIR58+YV7Pg84QF6enowTZO6ujqEEGQyGaLRKLFYjHg8jmmaeL1e/H4/Xq8Xt9s9YhXIrwSyLE+bQlPDpB7UtEkzBkzTLMzqbW1thVk9lUoVZvCJkDdvXC4XVVVVABiGQSKRIBaLcezYMVKpFDabrbAK+Hw+hBD09fUxe/ZsFEUprAT5j2Aabx7ThD8Bw53SUChES0sL1dXVrF+/HlmWSafTmKY55u8lSRo3VKkoCn6/H7/fz4wZMwDQNK2wCnR3d5PNZjEMA5vNhs/nKzjEALIsjzCFpleBqWGa8MOQN1E0TaOlpQVN01i5ciVut7twzFtFrlQqxWUf+CCmafCBy97PNddcw7x58wp/a25uRpblEQ6xz+crrATTDvGbw7QNjzWrp1IpJEmir6+P9vZ25s6dS1VV1UnEGRgYIBqNsmDBglFt+L6+PjRNY+bMmWNe70c/+hH/ecuPkEtm4qxdTPrYfnL9R5Edbmpqali3ajlLlizhpptuwul0ApZDHIvFiMViRKNRstksTqdzhCmUXwVOU4d42mmdCHmnVNd1tmzZgsvlwul0Ul9fj81mG/U3g4ODRCKRAuFzudwIMo1H+Fgsxoc+fA27du9Fsjkxs0kUVxFGLguGTtmlX8LMpohsfRCRSSCEgaeohIVzZ3LxhRfwne98Z8TYhzvEsVgMIcSIVSAYDOLxeCgpKTkdTKFpwo+H4U5pR0cHra2trF27luLi4nF/Nzg4SCgUor6+flTC9/f3k8lkmDVr1km/nTl3AdFYDNntx167FMwc6aZXkRxuECYCkAQgTNTSOnwr34+RjhDdfD+SaicaGhx3bMMd4mg0SjgcxuFwUFpaWvgIVFUtjPfEVeBv3CGejtKMhuFOaSQSobm5mYqKCjweD4FAYMLfy7I8rlM6rtOqqPjXfxg9FSF54CUwcqCoKK4iJLuLXLAbx+wVuOevI922l9BzPwPFhmv+OjId+yYc24kOcWtrKx6PB0VRiMVidHZ2ous6Ho+n8AF4PJ4C0WVZLkSF/l5NodOK8HmbO5fLcfjwYVKpFCtWrMDj8TAwMIAQYsIXPFEUZjzIkkQulyG5/3mQFDzLLsJRu4Toaw+gh7pAUci07yXb1YikqMiuIsxclpJLbqT3V1+a8vWEENjtdkpKSigvLy/8WzKZJBqNnuQQ53MDJzrEf0+5gdOC8MNn9YGBAVpbW5k9ezZLliwpvLzJEvnE4078SMY7TzqTwextQXb68K25nEz7GyQaXkT2BLBVzcdROY/iCz9NpmMfg49/n+pP3UHvL79Isvm1N/WRjfYBS5KE1+vF6/VSW1sLjHSI+/r6yGQyIzLEwWCQQCBAaWkpkiSNyA38ra0Cf9eEH+6UptNpDh06hKqqrF27FrvdPuJYWZYxTbMQ6RgLoxFospAMnWzvYWy+Uvzrr8a//mr6HvgmjppF5AbbrWMUFbWkFiQJkU0CEN36B3iLCD8aVFWlpKSEkpKSwu/yDnEwGGRgYIBgMEgoFCp8BE6ns2DenfgBnMqrwN8t4U3TZHBwELfbTU9PDz09PdTX11NaWlo4pqOjg4vecym9vb0UBYo5e80ZbNiwgc9+9rP4/f5RzytJUiHxNNpLHW+Gd3l9MKuebMcb6NF+lKIKAPRoP9new2S6mjAzCWylM0AI+n73vwBB5XU/YPCBb075GUyW8ADf+973+Mmdd1NdXcWGdWu47LLLeO9731vIEJeVlRV8gY6OjhEZ4vxHMDyydarmBv7uCD/cfGlubsYwDMrKyli/fn1h9jZNkw9/+Br+/OyzKEUVlF31b+jhHp594V6eef4Fvv2d7+IqCjB/1gyu/ciH+frXv144/1/z0kwhEDkNM5Og5xdfAEUBUyAMDcnuwlY5BzOnEX/jWQACG/6RyNbfIwnzLTNpTkQoFGLVmjMJh8OUXPJ5kpg8uvklHnzkcYSh4wmUMKe2iiWLF3HzzTezbNmyQoY4m80WTKGJHOJTxRT6uwpL5sOEmqZx9OhRenp6WLp0KZWVlYVjnnrqKT77+S8R10xc89eTPdZALtiJZHcidA13/Qa8y99Nqmkzif3P4/T6iQz1F34fj8dpa2tjxYoVCCHQNG3EiwsGg0QikULWdDjKqurQ0gnU4hqqP30nWncTg0/8AOfcNZjJCLbiGkou+Ry5cA+9v76Z6k/8mN5ffwUkGUydaHD8sOSJaGpqoq6uDp/PN+rfH3roIf7pS19BKZ2FqSXJBbuRHS7MTApb+WxK3n0jRjpK6M8/RRg5EAJZUSktL+Os1Wdw//33jzjfcIc4Foud5BDLskx/fz+LFy8G/uIQNzU1sXz58pPMzCni9AlLnliUcfjwYWbMmEFZWRkulwuw9Cofv/4GnvzT0whhItucpDveQKSTIKsEzr8BoWVINr7MwIPfBkXFu/JSRMfuEdfKmyxCCLq7uy1zqKgIv99PUVHRuOMsKi4mOXMFuYE2ZFnGOWMptpI6VHeATLCLXLgbbbADSbZWosgr9wHgPeN9pBuen/JzMU1z3Fn0M5+7EUmxIZIh1JIZqLIdPdKDpCjkhjoY+OP3QJiAhK10Bu6FZ4NiY+DlX/HUwMkf33gOcTQaJRQKkUwmOXjw4AjJ9Je//GWee+65v5bwk8LfNOGHO6WZTIbm5mYA1qxZg9PpLMhxAapmzCaVSOCctRzf6g+QbNpMunkrakktwtCIbPolkt1lZT+LysHuwbPkXcTad464piRJ6LrO7t27cblczJ8/n0QiwdDQEEePHkXXdWRZxuPx4Pf7cTqdf4kEAQjQI330PfCvuGavxEzHSOx71ppBFTt9938DoWtIskK2vxWBhHfZhaQPbHxTz2esZJJpmmAaVH3yZ8R3PUGy8RUkuwtyGRR/JcgKergX9+Lz8Cw8h8yxBiJbfg+Au/5ctGNvTGoMwx1iv99PMBiktraWWCxGMBjkZz/7Ga2trXzta1/jpptuYvny5VO+z6ngb5bwefPFMAy6u7vp7Oxk4cKFhXgz/CXyAqBpOYrWfIBcqJvBx38AwkS2u1C8JXiXXkhs758xk2EcVQvxLLuQ2M7HSR3eTnaYFFgIQW9vL+FwmFWrVlFSUoKmaXg8noLZFAwG6e3tJZPJFLKubrcbv99PPB7DyHZZmdaKOSQPbUGPDSK7irAFKrFXzKHkos+Qat3J4BM/oPLD36H3t/9MdNtDmIY+5Wc0ng2vaRogkek8QLLxZSTVgWveWlyzVxHZ+iBGpBfJ7ibdso10yzYk1YFkcyL0LEXrriTc3TDl8RiGgaqquN1u3G43VVVVfPe732Xjxo188pOfnFTi76/F3xzhh5sviUSCpqYm/H4/69evL1QT5SHLMoZhWP9bUXAvOg9H9QLCm39LunUn/rM+bM1cr/4WW8VcnDOXY2biCCOHER8i0fAC6nHCpFIpDh48iNPppKSkhNLS0lEdyXxp3+zZswvjTaVSRKNRbKqKlo4i292UXPxZAPp+/00ctYvQ+lsL57AFqpBklVywE4RJtvsQsjL1VzUe4WOxGADp1t2ogSq8y99Dun0vwWd+jGRzopbW4ZqzmsD516OHe+i550aqPn0n/fd9jcT+jei53JTHYxjGSWHf/Cp09tlnvy1O7N8U4U3TZGBgAK/XS1tbG6FQiCVLloxpO4+UAUgYiSBCzEdS7UiqHc/i8/EsPp9sdxOeJeejh/tIH9lBpm0vQggqrvgXwn/6Ie3t7fT09LB48WJcLhcHDx4cc4yjxek9Hg8ejwe3x4tZNZt0227SbXtw1NRbdvvAUYSWJtO2l1T7PpyVc0GYDD313whJovxD/0roke9O+XmNR3iriEWQ7WzAUVNP0dorKFp7BQOP/Sey04s+dAzJZmVcVX8FSBLkrNUueehVXMdVnFOBYRhjmlhvV8Tmb4Lww2f1hoYGVFWlpqaG9evXj/ugFEUpzPCGrjH05A9BUZFdPhCCbG8L9oq5SIqK1neETPsbmOk4sjcA2TRmNolpGGiaVghrZrPZSY13NGiahpHTMLU0A0/8CPQ0kt1NYMNHyfYdJn10F2a0j3R8CJHTcC8+l1TLdvRwD4b+1po06XQayebEvfAscqFujHQMxVWEMHKYqQhasJNcpA8jOoC9eiFICv1/+BYCKHvfTehbfzPl8eSLWiY7xv8JnNKEH+6UZrPZQlHG2rVrC9GX8TDchvd4fTjedSOyw0X4lfvQ+lvpf+g7iJxFYG2gHbW4GhIh6j73C7rv+RzBp3+MQLBw4cLCOYcnnkbDeImnbDpFZmgHks0Jhobk8GBmEkR3PIpsdyO0LL7Vl+GcdQbpjv0k9vwJEASfux1Mk4997GN87GMf4/zzz8flck1IlPHIlEqlQJYxkhFyQ5103X49irsIoecwtRRICq65azCSEaLbHkRSVHwrLyXR8AIim0R/Ez6FYRgFfX8eeRnD24VTlvDDndLe3l46OjqYN28e8Xj8pIc2FoYTXlFUMHWcM5bhW3Up0S2/p/bGe9Cj/fT9/ps456xB9ZUQ3fI768eGgWvBWWSP7hhxzr9GPObx+khrOpgGstuPb+Wl2GsXMfTUjzASISSbg8T+jcQPvAS65VSWvveLqKUzSOx7lieffJJNr7zKM08/VeiIkFdHDi8AyWM8wg8MDCB0jcyx/bjrz6P00i+TPrKD4HO341l8AdnuRlxzz8S77CL02CA9v/g8rgXrie9/ntDGn+P1eqZ8/6NJNxKJBB7P1M/1ZnHKEf7ETgGHDh3C4/Gwbt06bDYb7e3tk9K8wEinNZWMI7Y+SC7Si9BzCNP6d9Vfia20Dtlmx0zHQJLpufcLmFoS94J1ZI68PuKcExF+rL/feeedDPb34Zy5DN/K95HpaiLy2gNWqFJRkVQb3lWXkRtoJ9O+B8/yS9Cj/YRe+gUYOYRhYK+aj9tmFJJe6XSaaDRKX18fhw8fRpblQk7A7/ePS3hFUZAdXmwldUiKgqza8Sw6l9j2P2IrrSXdvscydVJRhK6BJBF7/Y9gmrjqN1Cq9Uz4/E/EaE5rIpHA6/VO+VxvFqcU4YcXZbS3tzM4OMjixYtHhKvydvlkCZ87Hk0oKvITlewkD2wiF+sHLUPvr2/GOWc1RipKtrcFDB1kBUfdErK9h0kd2XkSeSdD+NFw60/vQLY7yHTsQ+s7YsXddY3AJTfiqJpHovFl4tsfQZg6kmIjfXQXttI6FF8pRmwQxVeOb83lKAeeLFwnH96rrq4GrCRPNBolGo3S3d1NPB6nqamJQCCA3+8fkerPZrPIqg0jFSUX7CD43O04ZyzHzKaJ7XwcoWeJv/EssR2PINucls/T34rkcOOonIejf2jC538iRntvyWTy9JvhTyzKOHToEFVVVYVOAcMx3BGdCMNNGrfbhTHvImt27TxI/x+/h2vBWaTbdqNH+pBUO751VxPb9geKL/4s/b///0i37kCcYKtOxqQZ7e8ut5vA8ivwLL0Arfcw/Q9+G3tNPZGXf4U4rtiQ7U5KLrkZe8Vswi/eQ6ZtD5LDi3/DR0ke3IQe6iF7PJw4GlRVpbS0tCCQ27FjB7NmzSIajXLs2DGSySQ2mw2/309jYyNGJoHkcaCWzECPDRF+5dcYqShqoBo9NkTl1d/GXr2A+K4/EdlyP6UXf47wi/eQ2P88EqlJvYPhGC1Kk0wmT58ZfjjR80UZmUzmpE4BwzGcxBNh+LF6Loce6cPMZY+H2yCw4VoCG65l8KkfAaA4PYBMqmkzeriXwIWfJvLSPSPO+WZneOm41EO2OXHOtLKJlf/w70g2B6EX7iJ9ZAeOmsVEXrwbIxMHWcUxczkIkCSFXLiX2K7HKS0pHfX8Y40lX+BdV1cH/EXwZRgGwjQhPoiz/hyK33U9AF0//zSBs/+B4HM/Q7a7kGUVR81CZJsTPdqPmU0iTJNFKxdPehx5jGXDnxaEzwuvWlpaME2TYDDInDlzqK6unnSocSIoilIgfC6bIf7GM8R2Po5SVIbIaaSO7EAuqiDbdRBUG5muJhAm4Zd/jeRwI9vsCDG5j+vEezsRQ4MDZMNPYKQiOOuWFv5dkmQUlx/FV0b5Ff8LgMEn/gskGdVfQaplK9HtfwQkis6+Fnf31imPZzgcDgfl5eWUlpZiL6nBNA2MRBAjGUHxBMDUSbS8jtAy9D74HTxzViE7vZZ4bcvvkV0+3IvOw+Uae6UZC2OZNH/3hM/P6Ol0mv7+fux2+6hFGaNhqiZN/liHww5IqCV1SKodI9LH4JM/RMLEVj4HIzaAmY5bKfaFZ2NEegk+f6elVByGyZQAjobikhL6cw5Sh18nvutJkGR6f/NVXHNWo8eHkEZcxzpHbqANPdx7XC1pWB+g+dYIVuPxOMI0EFqG1JEdJJs2Izu9mMkI5tEdKEVlGIkQqSM7LKfVNI9Xae1Bj/QRMbUpX/NUcFrfkTL1fKeAffv2UV5eTnV19aSVclM1aY4dO8ac+Qvo6h2g+MJP4V12EVLejtSzyE4fniUXUHrFN7HVLAIjR7brIGY2iXvhOZYjO0WMNsPb7Ha8i8+n5oYfM+Om34ORs4RjB14k3baHbE8zXXdcz+ATt5ALdpJq3kKm6yAIk+pP/AQUlejORwmHglMez2g4evQoenQAIxkhcPZHqL35QSSHB8nhRnJ48Cy/hOobbsNZu8hSTEoCxRMgF+4h074Hm81GZ2cnsVhs0u9jNDHbaTHDd3R0YBgGZ511Fn19fZPKXuYxlRn+jjvu4P/84BYkVxFC14i88hsUfzl6bADZU4zi9IGiEn7xbqTjWhXJ6cWI9GFIMr7Vl5NqfBld10/S6YyFsWz8bCaDkYogTMOS/8oK7sXnU/rufyJx4CXie5+maO1VpFpeQ49bURnXwnNI7HwMe/ksS+xmc1FZNrq2faqoqKjAUb0QPRlBjw/Rc+cNyE4fZZd+hWx/K6lDrxJ77QFQ7ThqF5PtaSK28zEkWcFRt4x58+YhyzJdXV0kEglUVS2EQ/1+/5h9fU5EMpksVFW9HXhHCD9v3rwCaVVVtbJ+k8RkCN/Z2cmZZ20gFo+jeMvwn/VhHDOWMvDw99CD3YBAyCqyr9QyGYQgcMEncS84i1TLNsIv/QIkSDa9AqqdVCo1ql7HMIyCtmd4F+DRkEokiO18nOjrf8ReOReGzYqyy4ckq3gWbcCzaAODj38fye5CwgQEQ3/+CZKs4Fn+bpSBHWNeYyrQNM2SAEf7Sex7FsVTjB7tJ/jc7ciuIvTEEJLDg2PGMissaRhINhe2spmAicfjoba2tqB7z/fHjEQiHDt2DF3XC4Uffr9/zCDEaTHDDyfGVGZsGGmXj4Z//udvcMddd+OuP5fSc1aT7thH8NnbrRlcVpFsdvwbrkMb6iR18EVc89ZhFlcT2XwfkVd+gxAm9qr5aL2H0QbawbC09icSPhqNcvDgQQKBAAMDA6RSKVwuFx6PB03TME1zxPJdVlEBqz6Ec/YqkgdeQutpJnngRYxECMVbjB4bINWyFUftEhCQGzpGLtgFQKbzAELPoUf7CAXfGpPm4MGDZI41HG8H4sO74r246zcQeuEuMsf2o/qrcFTPx8gk0HpbQFFwzVtDpnUXRiLE0NDIRlN2u53y8vKCPNs0TRKJBNFolLa2NpLJJJlMhvb29kKxjKIopwfhh0NRFPQpCKOGR15OhKZp3Hn3LxCmQaplG+muJkQmhqTaKfvg/wJhkDzwEpFN9yIMHdnhRo/04ZyxDCFJaF2NyDYXVR//Ecdu+SCepReRfOPpESaXaZpkMhkOHTrEihUrCr5HPvM5ODhIJpNh165dqKpKIBA4njgTIAT20jrs77qe2PY/Yq+uR7I5SbW8jpmOEdx4l5XtNQ2QFezls9D6Wqm78R46brmcZMOLlM6s+6uedx7V1dXWNSrm4qipJ3loM5EtVoczR80iFG8xZk4j07oTVAcoDnL9R9FjAyguHytWrBj3/Pmsb1FRETNmzMA0TXbu3InL5WJwcJDW1lZaWlrYs2cPVVVVLFmypJBA+5/EKUH4qczwoykW8/3Ujx49imKzU3ndD0BWiO143CpusDkYeuIHSIodU0tir1pA+VXfIjd0jMjm+4jteATJ4aH0spsJbbwbIxGyziuBMA2i0SgzZswgHo9z8OBBJEli7dq1SJJUyOTmM5+VlZVEo1FWrFhRWOaDwSC9PT1kB59F6BrOGUtBlrGV1FD6ni+QOrKD2I5HqbruB5imTt/9/4ItUI3i8aP1HyUX6gYBvrVXUpRqeUueu2EYKC4ftvJZFF/0aYqBwad+CEhgGmR7WzATIWzVC5FVO9nOA2T7W3HNPwsj0jNmnexYEEKgqiqVlZWFYplFixbx5JNPMjg4yJYtW7jmmmveknsbD++4SaOq6pQJP/z4TCZDY2MjNpuNdevWISsKwtBxVM7DXX8Omfa91H7h1+iRPvof/Daqy4sRHaD7/34K2eHGzGWxV85DdgdQ3AEwcvTc83mQFZI7H4fj6si2tjb6+vpYtmwZDQ0NY7bcG35vw5f5yooKjiUEyaZXiG1/BAwDPTpALtI3oueMLKuongCSaiM3dAyESe+vbwIJZLsLMz71qNFo6Ovrw9QyVk/L45oboeeQZAWtvxUjEUItqsQ1YxmZjv2g2HHOXIGkyOjRQRKJxJSuN1pI0uv1IoTg61//+rjdlt9KnBIz/FRMmnxYMl9E3dHRQX19PWVlZQAYuRyx3U/hSccAYUVFJAlbcTWqvxJH7SKKz78ePRGi91dfpvS9XyI31EGmYx/RbQ8hTJ3Au24gvOle7LOWofe3snv3bjZs2DCq1GE0gdZoH4Ld4cA7Yx1Fa68EoOO/LkfrabY+LkUBI0f33Z/DOesMsv2tmOm41XsSKH7flwk99SPiOx9jwDP1wovREIvFENkEyYObSDW/hr12MXqoGz3cAzYnnjPei97fSqptN0a4F9lTDEaOVNMOkFXmz58/peuNpX867Wz4NzPDZ7NZdu/ejdvtPqm0z6YqaP1HyB7bj5GMABB8/k6cs84A07CSKIDqLUG2u5AkEFrKcsxsTshlsQUqkSQZe3Edev9RysrKRmjix8N4BRdGMowwdMuBlmQkpxe0FJLisP6/p5hE81YkPYN//dUYyQiZ9r2Enr4NFDuKt5TZs8omNY6J9D5lZWXI3lK8yy/BOXM5yabNZDoPYKtZhKyoSEKgh/swchlkuxszkyDbdRDHrJXoQ+0Tdmg4EWNVO50WhD+xF+NUEheDg4MMDAwUiqhPhNPtxXvODbgXno0eG6L7rk+T2Pc8ycZXEFqa3GAHZiaJa/YZCNMkvOUBzEQQJPl4TPxFks1bEcIgcXgrkqEV7PTJYjSyJRNx4p3PENv1JHJRhWUqZxJUXX8rGDqpw9ss+a1iA1kh3bEP15zVSG4/xENIqoK7/hzSoTc4fPgwfr+fQCAwZsJuokqi/D5VsmrHNXslrtkr0UPdOGatIHN0N4k9T4Niw3/BDSR2Pg6ZBLK3BNfsM4j2Nk9Z4TiWpHu0Kqj/SbzjM/xky7vyRdT5fuejkR1AUeTCLC47vSDJFJ9/PZ6lFxB8+TfoQx2YmTjhzb/FSIaRPQF8a68ktv0R3IvOJdn4MqnmLVYNp2Eg2d0TZoGHk2usxFNVVQ25xe8nF+0l1fASrjmryQU76bvv6ygeP0Y2g+wpxl4+C1v5HFKHthDb9hAoNiRJgCQT3/UU/V47paWlRCIRurq6CvHuvAQ4Xwk1EeFbWlowU1Eyx/Zjq5iDo3axVRBydA+5wXYcc9dghHsgp2Gm49hq6iGbJLbrSRDmmHH1sTBWAffbjXec8BNBCEFHRwc9PT0sWbIEu91e6D8zGpLxGOmnbyO283Gcs1daZoyRQ/EU46pbQkbPUn7FvwDQ+5ubcdefi2SzTIrMsQa0viP41l5JYs/TqKUzMeODx1tanIx8v8TJvDhD14htfwRh5JCdXhRfGb51V5PY/zzplq1g6Aiho4X7rFrSZBhH3VJK3vN5ZJuDoadvJdvViGbzjGh8apom8XicaDTKkSNHSKfTuN1uioqKMAzjpHxAHjW1dfSGEuRCPQSfux0zFQNhINmcSHY3ngVnE932B6Kv/ta6V1MnF+lD8ZaiJyNUVFRMeM8j7n8MG/60qGmd7A0mEgkOHjxIcXHxiCLq8Wz+6poagmVnABLpo7sAieShLcjuAGYmjpEMY2ZTyA43KDaMRAit7zAIwdDj30dyelF9ZSBMTC2JngjR1tZ20nXGelGjfQD33nsvjYdacM5ZTeCsD5PtbSa+588kD26yDpBlitZ8CDVQRXT7oyhOD95lF5Np203vr26yzikr2Cvn4dDDI84ty3KAb9/OAAAgAElEQVQhmzlz5sxCW5BgMIimaezatQu73V4wgfIJHy1noDhc+NdfjW/1ZZi6RvfPP0PROf9AYsdjJBs3YaaieFd/gGTDRrSeZqtD2wWfYOix/5hyD5nJFu38T+OUmeGHE8g0Tdrb2+nv72fJkiUjOvlOFLd3OezIDg9Fa68kcO51dPzX5QgtTWz7H9Hjg0iySudPr0MtrsZMx9C6D6H4SkGSKf/I90jsfZrI5vuszOZgB5LdNaLjMDApk2E4vv/DW5EUlUzbLgb6WgAJMxnBf97H8NSfQ6bzIJHNv8HMHpdYGAG03hYcs1aSC3Zh6hr+DdeS62/F7B8/05pvC2Kz2QiFQqxcuZJsNkskEmFwcJAjR45YorquTkROg+MaIvl46xJJCIxMDD2TACQ8i84l8cYzuBaeQ7arkXTLViTVPmltUR6jEV7TtLfVfod3kPDDZ8I8iVVVLSR38h1/T1yOJ1JLJuJRMqkGHLWLsVfOs7aMmbuaknd/nkTzNuI7HqHymu+SOPgSkVd/h2PWGXiXX0xo412ovlIwTRRvCWYmCZKE4nCftBHxeGbMaH9zud0UX3gF7voNZLsbGfrTrSjeYqJbfkd81+MIXUfoGcqu+CaO6vlkjjUQ2vhz0m178K29ikzrDmTZhh7uJZlMTur5Dv8gHQ7HiISPrus4nU6i0TihjT8nsf95XHNWI7IJS0cElF39HYJPfJ/Iq/cjyQpycQ2ibQ/Jlm0jdECTxalQ3genyAyvqiq5XI62tjaCwSBLly4dM5M30R5LPo+HztYmBh7+LmYuY8lwtTQAis1yPmWnl6I1HyTTsd9KNh0v8gg+81O0nmZ8az5IquU1sLkw0jFaW1tHXGOqnQusaieB4vLhnr8eSVYo/9C3sJXOINtziIGHvoOtYg5DT/4A2eY6XtTtQGhpilZdSqZ1O5FXfwumQXnJ6H3rT8R4K5CqqtgdLhSXD9/q92Nm06RadyGMHJ4lF5A6vA20FELXyEX7EbkMyR2PgyxR/qFvM/TEf0763vMwDOMk5//t1sLDO6SHPxGmabJ7925UVWXdunVTTlsPR01NDZ5lFzPjKw9Q8+k7QFZJNr1K1+0fJ7rjMUtOsOV3ZI5ZvREz3U2Enr8Tcbzyx7XwHIxMDCMeRB/qwEhHT4o5T3WGD4dDpA5tIXloC0YybEWAEMh2J67ZKwGo/tiPmHnzw5Re+mVELkPtF34JskKqZSt6pA/FV4Zj9qpJ1w1MZHIlk0mEMLEV11L8ruupueE2JMWGd9X7wDQY+tN/gzCp+sdbQJKx19ZbWdlc6qSimMlgtLDk2x2Dh3eQ8JIkYRgGzc3NxONxFixYwJw5c/7qrROdTiciZ83otuIaJLsT55zVFF9yI8LQC8KywSd+QPrwdvRwL94z3oekqJRd/g1UXwnJhhetWdbuxFG94KQXNdUZ3uNxk4sOEN50L13/95OIXJbo1gdJHNyEHvtL22lJtWErnwNIoOtWueErlj+hOL1IiEJPyIkwEeHTyQQilyXTeQBtsB0hTIRpEN/5OAiTwPkfByHQg50gKxSt/dDxD+FWMA12797NkSNHGBoamlSe4rQ3aUKhEI2NjdTW1lJVVfWW9Qbv6uoi0bCfXLAL19w1SIAkTDyLzkUNVDH05C3UfOp2AAafvhUjncQ190ySBzdhRAdIt+/FOesMzEwcPREBJIInSHKH94gfHBwsbP2S39voJBve5cZf/z58qz+AqWt03n496SPbyXQeKMgHhv703zjnrLb8CAQ9934eSVaQfKUE1l1NfO/TaEMduDyOST2HiXrDu7xFpINBUs1bSTS8AMJA5LKkjx1A6BrepRcTefnXDD7y7yAEsR2PItkc+DdcR2rXY6xYsaLQEqSjowPTNEf0xDmxm9ipUN4H7yDhk8lkoTtBS0vLlPQ042HlypUcHMphr5xHsvEVzFwWbaCNZNOrKB4/Qs8W0vuKw6rhTLfuQpgGg0/+F7KrCOfMM8h0vIGZiaP1RujvXzTiGpIkkclk2L9/Pw6HAyEELS0t2O12AoEAuq6PiH/nPw6woiGKw41aPouKq/+NdFcjQ4/8b5AkotsfxkyEEELgmrOGRMNGPLPXWHr56ACSYhtz76kTMV5veADd0JHtDsou/xrOmSvI9h2h7zc3U/2Jn9Jz5/UMPXc7kmqn5L1fJPTcHeTCvQhdx1FTTwqw2WyUlZX9RcNkGMTjcSKRSKFNuNfrLYRD833zh+O0IvzMmTML4cWpSoTzcoTRXqjb7Ua2OSi56DMAdP78U5ipGOFNv8RIhpEUhWO3XYOjegFCz6H1t5LtbUEIQdFZ1yDbnMT3/hkzHQXDwFY5d8SWOWCF0/bv38+SJUvw+XwF8yGbzRIOhwsbJiiKQiAQYLC/j8TRX5Fqfg3XnDUI/fj2MU4vnvnrGJIVyi77GpJqQwt20fubr1L6vi+RaNiIMDQS+19AdvqwldSQzfZN6hlNaMPH41gSTCssaK+0tugxU1GQZHIDRxGmgaNyPkgyFVd+k/6Hvs3QE7cgGSebMPl7zcfn89vfRCIROjo6CnmBkpKSQj7gtLLhh2OqArKxQpN5EyMX6iHb04wwDRS7G1vpDOq+8CuqP2U5sVU33IajdonVLcDppeLD/z+yrOCsqcdSWOrYqhYgqZZgK59p1XWdAwcOkMlkWLFixUnxeYfDQVVVFU6nk7Vr17Js2TK8Xi9l5RV4V16KvWoByabNmNkEuUgfycaX0eNWBy9h/EVXL8ky6ba9ACT3P0+2uxG1qAwzm5q0rmciwtudLoSpM/jo/2bgsf8g8cYzgET/774BkkzlR7+PJCsMPvEDALK9h5AkGbW4Crdv4lUmv/1NXV0dS5cupaioiPnz5+N0Ounr62Pz5s3ceuutbNq0iVdeeWVS9/RW4JQIS76Zqqd83D6PdDrNgQMHcDgc6PHgX8KSgBqwioQVh6X/cJTPxnHBJ5CdHlKHtyOrVv+Z+N4/k+nYh71uKbKikpNkst2NNDQIIpEIjY2NzJw5k1wuV7j2eA6s3W63iqUddtSiCorWXgHAsdtvQOTShDf/FjMRRlJsdP70Omzls3BUzgNhMvjY/wHTwF63hKI1VxB+6R7MTBx3zeQKnicivBAmQlLwn30tWt8RotsfRVLtBM77GJHN95EbOJ5dlhWEJBF59XcgSfjWfBBz++8mNYbhME2zsMNfVVUVixYt4uqrryYej9Pb2zvl871ZvKNRmjzeTNVT/nghBF1dXezdu5f58+ezatUq7KW1zPjKA1R/8mfIbj96uJeuOz9B6OV7EVqa6OsPk+1pBknCSIaPb94lyPY041l2sbW/Um8LIptEklXKy8tpbm5m5cqV1NXVTZgLOBHxeJzcUEdhNlfsdmzlM6n7p3up+9pDiJxG5cduwb3wbLK9hxGmSdXHbwVJwlGzGEwdYeioZbMmLdqaiPC5bBYJgXvOasov/zrVN9yGECbu+nNBkhh68hYASi7+LJIkU37FvyApKvG9T5OMRyd973mMZoKapsmGDRu49tprp3y+N4tTYoZ/M5p40zTJZrMcOHAAp9PJunXrUFUVr9eLqVklgPbSOmyldeRMg+ILPkHi4MsgK8T3PU9s+yNWNlVRcS86j/ThbQQu+gySaRT2PEJWcM5Zha7rrF27dsSeo1MhvGnoJFu2kTi4yWp2lElgd1lmgSyrIEs4KubgrF6IZ+EG+u7/htUdQEC25xCJN55B8VciKzbC4ckVcU8ofTjePTndvgfJ7kSSVSRJIvT8HZbC9KJPEdn8W9Ltb4AwrdYiwiQ3eIza6sqxzzsOThxPIpH4q3IubwanBOHfTNVTf38/fX19J21kls1m0aN9VleveWcisikQAs+SC3AvOo9jP7yS2s/djSRJRLY+SKLhRYrP/zjplq2IbJJ0+xso3hIc1fUkW7ahR3rpkdURs9NUCV9aVkZ6wXvwrf0g6cPbGfrTrWi9h60xzl0DQpA48BLOWWcgjv9n8JF/R1LtaL0tuOadiZlOkBvqQC720tfXRyAQGLdP/kSElxQVkUkR2/k4kVd+g6RYYWFtsAOBhK1slhWX3/UEQpIZfPz7ICv4N1yLs/u1Sd/7eDitnNY3a9JomkYoFCIUCrFu3boRZAeYO3cukt2Nc96ZpFp3oQW7MLMJEgc3FbKcQrdWANVXiiQrVs0mgvBLvyDbcwjFV46pZ0DPku1rHVM8NlnIkgwIZFnFU78BxRNALZ1hjfHobpBVIq/+jt5ffpG++74Gpk4u2ofQs/jWXI6n/ly0gVZMXaO4uLiwReeOHTtobGykp6eHVCo1YkwTEd40DSRFpfr6W6n76h/xX/gpa1+rq76FLMsEn/kJCCi+8FNIsoJ76QVINgda72Eib1H3s3eC8KfEDD9Zk2ZwcJCWlpZCN9zRlHY+nw8JQfG5/0jxuf/I0LM/I7nveSKbf4uZiiCpdjp/ci32ygUo7iKMZIjQCz9HGDqueevwLr2Q0It3Y2biIATeM96LqqZHXGOqhO/u6iR+tBMzHcM5ayUgIdsdhTF23PJB6j5/L0JSSDRsJPzC3dR86g6O3XK51TGguwnFXYzs9JBMJgs7BOZ7v0QikYIW3uv1EggEJqwiM03D0hApNmuT5JqFyKrDmuGFiaTYrS7LimoVfMw9k1TjZlItW5m3uH7S9z4eUqnUtEkzGnRd59ChQ2iaxplnnklnZ+eYL9Tj8WDmMqRbd+GoW4Ls8IAsU/f5X2KaOp23fYTyq75DtrPBKvszDWo+dTs99/wTzrolVvTC0HHXn0eycROSEPT394+4xlQJX1NbSyJskulqItHwovXhSRK5UDdqcU3hOIt49ciqHT3SB0jEdj4OSNhrF1n69GEz4vDeL3ktfDKZJBwOF5I/yWSS4uJiAoEAHo+nMOvLSJiSZN33zOXYimsQCELP3Q6KncC51xF87nZCL96DMAzCL94DkoRn2SWUFE2tY8FYWd/TaoafrEkTCoVoampi9uzZ1NTUIEnSuMf7/X5L8/HsT60qHtVmVT0JE1lWkVUH9vJZuOeuxlG7iNDGu1A8xSBMUq070HoPI3uLUdx+y7be9yzpuXNOGvtUCK+qKq7ZS/Cf/RHACksaqQi9v/4KyDLICj2/ugnX3DWoRRUIYdD7qy9b8uSiCnxrLie+83GM+BBULBj3mea3frfZbGSzWcrKygrJn0QigcvlIhAIWG3AdY2Sy75akBcI0yBw3seJ7XyMTMc+hK5hr15oFX+oDhS3gtC1KbVGhLGLP94Jp/WUSDyNRmDDMGhqaqK1tZXVq1dTW1tb+EjGI3xpaSkImPHF+6j94n24Zq86bsZ8lIFH/wMQxLb/kXTHPjBNhKHR99uvI6k2sr1H8K68FEm2kTz0qrWUL34XxaUj62enSvh0Km3tlXQ8MqI4nFYy7OaHKL/q38DI4ZqzxoqHb3sQYZqUXPI5y9lefJ61NU06btW8TkEtKctyoQfk0qVLWbduHfPnz0dV1ULbbXf9uZRf8S+UXf51ZLsTW0kNIpchceBFZJff0skLk6IzP4iRjpNqfGXKlUtjET6bzeJwTE4b9FbhlDBpToxr5/s21tbWsmjRopOWQ1mWxzSB8pELYRqo7iKcM5eTbt1J2fu/SqrltUKIMNn4CmYmYWVTayrJDXbgXfch3AvWk9j/PLKrCLC6g6Ui+0ZcY6qEj8WjJFo3knjjGezVCzCSEWS7G1mWcc1cboUBL/iEtV/swFH6//AtPEsvJPjsz8gNHSPxxjOogUowcmPW156I0ZzW4ftCYVoZ22TDCzhmLi/IHUIv3AWAf8N1JN54hlTza2DoJJs2I3QNR8XcN9WTZixdz1+rjp0qTgnC52GaJq2trYRCIc4444wxpaOKooz74iXVRtedn8Q1ZyUIgaTYcNbW41l4Ft0//wzlV30Le8Uckkd2MPT0rVRe9W90/OhKyCZJ7H8BSbHhW/FuIlt+T2znE/S4R86qwwk/mTK/GXV1JGe/C/fCc0g0bCTb00JuqIPgsz/DOXsVAFrfEezVC0AAAqvSSLGTatmGrXwWqreYbFcTjpmT2/JmvCjNcP8nuu1hjI0/ty4qyVYbcUlBAvTYIFIqBkKg9beils1AdvumXJY3mhb+nehYAKdIWBKsWWD79u0oisK6devG1UlPFMYUQuDf8FGMbKqQOInt/hPZviOgqJhZq0xO9RQjS4qlWxGCxL7nSLfuRLI5C02c1KJyKqpGNvl8cxVPYC+fRclFn0H2liC7fOjxoFVSJ6v0P/wdOm+7hqGnb0WYhmVT6xq+NR/At/JSMscaMHMndzEe7xmMRfj8ZCGpDmpvvJu6rz6Mb91VYHPgP/ODmFqayJb7ke1evMsuPi4puByRipHp2E97ezvBYHDSuZPxCrjfzo4F8A7P8HnVY1tbG5lMhrPOOmtSTsxEhJcVFfe8NRStupRk06sMPfNjUodeJb7nTwgjZ/WYLKrAXjEHYeQs3YoQqGWzKLv8nxl44F9J7H8OJAnv8kvIdW4+adz5PaoaGxsRQlBcXExxcfGoyaCurk5SmR4Utx/nzOUoNgeS6qPymu8CVtu9uq8+hB7qJvr6w+RC3dT+0y/puv0fUdwBcuFuFF+ZZXKEQpN6thPuwg1w3JSUZRl7aR2yzUXm2AHMXBpndT2mnkNPDIGkoAe7MOJDyK4iVq5cSTgcLnRzyEuAA4HAqLP/aISfSK//P4V3lPDJZJKGhgaKi4vxeDyTrn6ZzLY3if0bcddvsPqf292UX/lN7BVz6L73ixStvQKh6yQPbESYOtWf+Cn99/8zanEV5LIIYVB01keIvv4wyZZtZMIjN+GVJIl4PM6RI0eYNWtWofi8paWFbDZLJpOht7eXQCCAy+WiqqqKvrZ+YrueJLzpl4hcBrWkFlNLI9tdcLy/jb18FkVrryTTtgdxXPgW3/UEppbGOXsluaGOSe+WMR7hrUJwq0tw548/gqN2sdVOLxUh1bINtagSe+0i4rueJDd4FEyd9NGdOOqWIrQUlZWVBTs+vzdsfiME0zRHfAB2u31UwqdSqbe92gne4V38jhw5Qn19PYFAgGg0Oq5zMxwTzfASgsSBTcR2PYHIZZEdnkIht2x3oXpKcM07E9fc1fT+6iZsxZbJovUdpf/Bb4Oiorj9SJKENnCUqoq/9HMUx2fZTCbD6tWrUVUV0zTx+XzU1NQU6nOz2SzNzc2FzRHcC8+h+PyPI4Sg844bMOIhOn/yUWwlNSBJDD72n7jmrUV2ehFmvmOwDKqdolXvJ3noNYx4cNLbA41H+GjUEn9JDjflV36L5IEXrM3LJAn/2qtINm8h3bINIQSOmnqynQdxzl2LmQyTC/UQiUQK5zpxb1jDMAofQFdXV4HsTqdzRFTm7d5yvjDet/2KxyFJEitXrizM1Pnk02QcookIrzhclHzwGzhq6om/8SyhTffS/8C/Yiutw8xlie54FCMdxVZcC8Kg7/5vIIwcQssQOP/jxF5/mOhrDyBMk+ILr4dDzwBWP8aGBqv4u6ysrJATyEuF89twFhcXF7aDyVc7iVymQELF6UHyFlPxkX8neeAFIpt+halrRLc/YlU8Ab4z3k9s11P4Vl2GpNqsGLzdNWm7eTzCWx+NQJIUnHWLcdYtxrbrSRING0EY6EMdSA4PzjmrwdDA4bZ6xnc1gqxQXz92plVRlJM6o7W2tpJOp2lsbCSXy+Hz+Xjttdfe9p40cApFad7s/qvDoet6oQ1ffka3l89Ctjkpef9X0CP9RF7/Ixg5Ilt+b2lrhGntp+TwYisqx7vsIqJbfmeZHLkMeriXSDjMwMAAhw8fZuHChTidTrq7u9m/fz9CiILp0tXVxaxZs6ipsbKnpmliGAbhcJhEVyPJAy/hmLUCMxVDKSpDdRfhX3cVkZd/TeU137V0PT3N9D/8XfznXEts91Po4R7S7Xuwlc3EiA+dpOsZC+PZyNlsFlQ7ZiZOZNuDuGaegchlMBIRYjseQykqxzljGdrQMfRQN+RyZNp245h1Bnrw2JQ6B8uyjMPhwOfzUVVVVWgNePToURoaGjjvvPPYvHnz22bPnzKEn4pEeLR9nvKx+xkzZmDqBgMPfxdbSS22itmAFZHwr7+abFcT7vqz8S67GCMdo+tnH6Pq2v+g+67PYmppwq/cZ1Xpn3kFwefvJL7nT3i9Pjo7O1m1ahU2mw1JkliwwMp45nI5WltbOXr0KHa7ne7ublKpFCUlJYXd7ObMmUOwYg2umctJHHwJU0sjQt1EXr3f6n8JGIkgalEF0vH7i+95Gum4tkb1V6EUlZEbbJv0MxqvpjUej4MpEIpKunkb8R2PW9ohWcVesxDZ7kZPhMgNtCM7PQhdQ/FXYgtUoXU3TZmcw234fGvA97///Zimye233/7331syjxPlBZNdrk8sAGlra2NgYKAQu/cW+VDO/DRGMmIlTHJZYjsexUzHEQj06IC1UYJq2ZPptr0YiSBC1xBaCmHoVoGIaRI49zrEwedYvnx5oXlqfty6rtPU1ISqqpx77rkoikIulyM8bEVQFIV0Oo0Elt8w70y67vocIpsgdXS3RWzFRvfdN6I4fdjKZyKMHNHtjyBMA9+qD6D6ywm/+lswJmfy5Z/LWEQaGBgABLZABdWf+DEAwRfuItt7BHvpTJKNLwMCd/055ELdSC4fitNHYt9zIMuFFWyyGG8H7tMqLDkcU91h2zRN0uk0DQ0NBAIBa7ub4zOaTVURig3/+qtx12+g59c3YWZTRLb8znL8jjUQe/1h7NX1IIQVllRsyDYXNZ+5i87bPkxi/0YEINmcZLLZQguOPGKxGI2NjcyePXtE5MRms1FRUVHorqtpGv39/aTjvdjKZuCcuQLZ5gC7g5obbgOg478+QN1X/kCmfS+x3U8hDJ2aT99Jzy++gBqoRI/0YgvUYqat/pCHDx8uCMLG6vE4HuGdTifYnQg9V2gsKys2JGGQbtsDkoStbDay3Y0RG8QUAjM2iL1uKVpv81vSSPWdEI7BKUT4qZg0+c3E9uzZw+LFi0/qFZ9MxNGPh/NspTORJIWi1ZfhXfEehp69HdVXinvh2ST2PUe28wAV191C+LnbMdIx9Ki151LxpTcRef4OwpvuLZgxYBGps7OTvr4+VqxYMWHJnd1up7a2lmP7W4hufdDqcqZrqMW1CCOHpNhAkpDtLjyLzkP1lTHw6H8cv54gtvMxzHQM98INpNv2MGfOHPx+P+FwmPb2diRJwu/3U1xcjN/vL3wAE8bhhYGRDFuNZQNVIEnowU4kh8fqvhbptXIRimrtRu7w4qk/B63r4KRbheQxWvTttCf8ZE0aXddpbGxE13XOOeecUZf4kuJi+lM5YtsfwYgHEZJELtJvbVVpcyLJCvby2ZRcciPxvX9G9ZUiclmMRIi++756fDwqCPAsPh+69gOWvd7Y2IjD4eDMM8+ctA7E7Xbjrj+Hkos+g2madN35CYxEkGO3fcTapBiJ4LO345p3plWJZBr03vf14y3tJHyrLiN9dDdCSyNJEiUlJRQXFxeeRzweJxgM0tbWhiRJBAIB0un0mNng1tZWyGawz1hGxVXfInHwJaJbH0Qtm8X/Y+8846Mq0z58namZnmRSgUBCCS0QOhELFrD3hm1ta3ddX1131V3Lrtusq6uuK9ZVEQEXC4oURUFB6TUhCSQQ0sv03s4574dhZom0BBHQzPXF308mM6f8z3Pu+37uok7PJWarJ2rbhbZgBDFnEwpzDnLAjWvFTASVuttNs/bXhClxDkeSY8qGP1gLCqfTydatWykqKsLn8+3XnjUZjfgHTMA87gLEcJDGf07Du/5TPKs/QKlPRxYjxHyOeHmdIND27v3xsJ8kYT3/d9g+foKOT58BSULbawj+uvW43W4qKyspKiraq0/NwQiHw8gRIelIqvRm0FvIvvgP+DYuJNJaS7SjjlDdekS/G0GpRF98Ev6tX2OZeDFSJEjMa0dWKJOx7MRgN6VSiVqtToonGo3i9Xrp6Oiguro62RwqIyMj2Rs+KysrPv1bqUw2lg03VwMCMXsjkY46BK0O/eDjcX3zDoIYQ/TZUWb2Idaxq9utsvfXV/JITe7bk2NmhVepVHu1pU6QiOU6nU5Gjx6NXq+nrq5uv98VjYSIOpriO5m7OwZbJl6CbvDx2OY/G99AsTXEMwFlOZ4wZc4m0l6LflBZvNCh+DgCNWtwrZgJsTDbtm2jtLR0rxZyXaG9vR3/9h0Etn1LWt9SRL8LpSEddXoeGSdfj2f1XPJ+8TSCQklg1yY6Pn6S9BOvxb/1ayK2BoLbV6LtPZRIc1UyEpSZmYlOp0sKac8HAOJ+zpAhQ1CpVHg8Htra2qipqUGlUtHS0oIkRgk3bqX9o7+jHzAe0eeMD3bbXeUV2rUxPl5TihFrqwFBQfqkK7B/+nS3zz9lw++D/Zk0fr+f8vJysrKyksOAE+zXTpVE/FuX4du0GLW1ID7NIxZBk9kb4+BJRF1tWE+/HYCGf15B5ik34v5uFnIsSvvcPyEoFOiHTCZYsxqFIRO87eTk5CCK4iGNaCkqKqIhrT/6gRPxlX8RD0tGQ7hWvJfsHiwFPCiNGSiUKhSCgHdTPJfHt2khSksuSoMFKRov4YtGo1RVVREKxZPJEiZOWloafr+frVu3MmDAAMxmM5IkodFokvH7cDgcz4GJhFDlD0JQKHGteC8+70qjQ2GM1/mKXjsKvQVZFNEWjSPStBX38pmg6L5kUoLfzYGqnhJzWOvr6xk+fPhejlIiUrOvLLyioiLaM0dimnAxvk0LcXfsxLvuE0R3OygUxFytRDrqUGf1iw8g3vZtvJA7GkL02JEFBd5NC5BlCVPJFHzfzUShUFBbW0sgEMBoNCZ3E7uy4iccUF3/Mej6j6Hx1duRAy4C21fhXTsPQamh8eUbUBqtaKwFyGIUz5oP44UX4y9EUKfh/sqhdwEAACAASURBVHY2SPGZTYWFhRQWFiJJEh6PB6fTSUVFBYFAAFEU6d+/P+np6SiVyr3eAAqFgn79+iFodKgz8sk+77cAtM36A5q8gQR3rMO7bh4oVGSefgcd//0TqvRcwrs2EAv7DymMuK9F4mh0DoZjaIXfM0oTiUSoqKhITtfel82Y2G3dl+DT0tKQOoKoDOmkT7oC9/L30OQOQIz4CTdsRY5FaJ0Rv9FyLIJ33TxUllxirlZ63fgCDf+8gkhTVbxGtPobRDFGQUEBBQUFyLKM1+tNlh5GIhHMZjNWq5WMjH1XJNXV1RFqsuNd/ylp/UpRqNVgzKTX7hj4rifOpfdd7xKsWY13/XxkMUb+tf+g9Z3foErPJ9xYgaZXMdH2uk7DxBQKRbJPYyQSQalU0qdPH9xuN5s3b0YURSwWS/INoFarUSqVcWdWEIg5Wwg1VqDNL0aOxU2cmLMZ3ZATCNdtJFD1NShV+DfMj48EOvdenB///bDc76PRSBWOIcEnTBq73U5VVRUDBw48oHOY2G3dl+Pa1NSEb8sWYp529AMnglKBKj2PrLN+jW/LEgLbV5Jz8R8INVTQNucR0k+9iWjrdmKuVkL1m5GiYawX3IPj02eIOZuAznNlE4XTiVXW7XbjcDhoaGhAFEXS09OTIlOpVPTu3ZuqRjue9fNxLv1PPFvSkosUDcdj8gjxaRwjp6JOz6Nj3lPJ33Mtfxc5EsQw8nSibbV7PfyRSIQtW7aQmZlJcXExgiB06ujrcrlwOp3s2rUrmQaxefNm5EiYqLOZjg/+mkzDQBAQFGr0AyYQqlmDv+pbiEVJG3wCoerleDd8hiiKNDQ0kJ6e3uWNo/0VcB/pelY4hkwaQRDweDzs3LmTsWPHHrDJEBx4o6q0tJSK9ggqU3a86l+SiLRuj/djV/yvL01awXBUJisKZKK2ehCjtL//p3jvGr8TkLGecReO+c/s9zgUCkUyFx5I5s44HI5kmDAYDKIrGoX1jF8hSRJNL9+EGHDT8Nw0NNn9QBCwf/ZPdP3HxaeDSFHaZj4Qd6g1enRDTyKwfSUQ76GZIDEPa+DAgUmRf/8a7ZnJGIvFcLlc8b0DAYwjppB56k1EXa20vn0vprHn49v4Gc6lbyID2Zc+TMfsR9D3H0No27eEd21Ck5aGIAjs2rULv9+PXq/fZ1eEg9EjBZ/A5/MlsxDHjh3bpYu2vwQy2N0yW6vDeuavANj17DRi7g46PvxbclJe08s3oRs4HikSwvHlawi7nbHcq5+g48O/xWs7ZZmovaFb1U2JsF9WVhbBYJDNmzcTi8UQAx5kSUShUKLUm0CbRs7lf8a7aSGR9jqijiZCuzYh+l0IShX6YScTqFyGpeySeG/2aCSevbn7wWppaaG+vp4RI0Z02RZWqVRkZWWRnp4eH9u5G3V6HgqdCTkWQQx6UWX2QfK7kIM+BIUCxxevgEKF9ey7CS59NTkgTZZlgsFgcqFK5LgnHoADbcoFAoFuDzc+HBxVwSeGDjc1NVFSUkJ5eXmXV4h9JZAlcDqdu4cgfB23mTVpaHKKyL3sj3g2LcKzci6m8RcQqF6OHA2iye5HWuEYPN/NRpPVD8QY5uOm4V05h+DaD/h47pxun5vNZqOmpoYhQ4YQjUYJ1VXQ8OxlaPKLEb02lDozKpOVjBOuxrPiPfKueQpBEAjsWI9t/j+wlF1KoHIZ4aYq/NUr0A+cSKB6OUajkW3bthEMBhk7dmy3Y+KJY5PCAbwbPsO/dRm6wlFIAU88DClLZJ35a1rfuQfbJ0+BDNqCIUSaKgnWrAYpPgFQkqSkD6XX68nLyyMxI9bj8SRTgvV6PbFYjEAgkJwSDnEn+lCO/YdyVAUvSRKRSCQ5dLg7HMik6du3b3y8/NK3EP12EGNIpixkWUZtyUWZZsA85hzMY86h5e3foBs4ITmuvvnNuxDDfjRZ/ZBlmR3bKruVOyLLMjt27MDlcjFmzBg0Gg2FhYVUhtMxT7wE34YFhFu2I0WCOL54BV3RGABi7jbU6XkISmXcvFvzEQC+iq9QZ/Qi3rdeYseOHZx00kmMHDnykBOvrrvuOlZ8twr9+EtQZxXgr/gKKRbBNPpsfFsW41n7EYJKS/rJN+D6+m0sEy6i46MqYjtWMXvGW3g8HkwmUyfBJlKhTSYTBoOB/Px8ZFnG7XZTW1vL9u3bCYfDGI1GbDbbUcmFh6MseJVKlUyz7S77E7zX68Xr9aLO7EP+9f9EioRofPkGoh11NPxzGprcAUQdjfE88MIxCAolwe0ridp2gUKJOqsAFCqcX72KoFB2S+yRSITy8nLMZjNjxoxJClIQBJAkNNYCMqfcQrB+M5LPkXwLodLS8vod8VChtSDe7KhyWdzJPPEaRL8T77pPQYphtVrp37//IV2zBJdffjnPPPc8TWoNhsHHYxh8PA0vXE1a0Si8Gz+L97sUY2jzB8X9i8Uvodcb2LJhDbFYjPr6erxeLzqdLhmeTQxDTiBJUjIIYbVaKSwsTL4BVq1aRVNTE6NGjeKjjz6iqKjoAEd7eDnqNnx3OwAk+H5dayKpq7GxkaKiIsSgN1kzqjJaEZQq0k/5Je7v3keWJPwVy/Cs+gA57Ad1GoYhJ+Gv+pqss++hbdbvkVXpiO6OAxxBZxKpBwMGDNirwWtNTQ3BHTU4v3qDtKIxCIIChd5C3lXxEN+uJ86l971zCe1cj2fVXORYlLxr/0Hru79DqTMR3LEW3YDxBGtXo9VqsdlsZGRk/KBR7vW7duGva0YKB0grHIUsRrF99jwolORe+XfaZvyG9v/+CVmMclzpUBbM/ySZO5So5AoEAjidTnbs2JGMq2dkZJCZmYlWq6WyshKj0Uj//v2RZTn5Bhg5ciThcJh169b17L400IW+5rvZc4WPRqPJuP3YsWPZvHkzUtBLw/NXorYWIPocKPUWdH1HoEwz0vHBX+l900sAtMx8AFVmb7Q5RfirvsGze5ZrxpRbcSzcTkVFBZmZmVit1n3G2BMDGVpaWvabejBw4EC2NDoJNVfjK1+CFHCjNFqJee27p/bFh50Zio9DoU7D/tlzSGEfIMcdRsA09nyCNSuxWCzY7XZqa2tRKpVJgVkslm6Jx5JpJSybCOxYj3fDfORwEE3fgUTqNxOz1yMICjT5xci2nSxaMH+vv0+MuDcYDPTp0yfZ19LhcFBdXY3T6cRkMpGVlUUoFEKn06FQKPj888959NFH+eabb3qeDf99DrSZtK/PJuLMFRUVFBUVJVfWoqIiFFodede/Gt9pXfUBkqsF22fPocntjxTxE3U2o0rPR6WzIAfceDd8Bsh41n+C0pRFuKEClPHpHz6fL7mRkxBYIlpSWVmJQqFg7Nix+z1utVqNJruQ7PPuA6DxtduQPDaapt8U72EpKGif/TD64jIQFMhihPb3/4gsy2hy+qPOKcS7YT4oVBgMhmRNaSQSwel00tLSkkwUSzycB4qRh0IhwuEIxpEnYhw5FYBdT15A1hl30PzaHTgWPI8MmMdfiG/RP7t07xJ9LQGam5sZNWoUarUap9NJVVUVVVVVvPPOOzQ3NzN37lyGDRvWpe893Bx1we9p0iQ2n7oieIVCQUtLS3Jl1Wq1yWokkykeYkvstIYaKog0VyP6XbhWzIFohJY37to9+UKJ6HOiTM8HQUne1U/h/GJ6fPy6GCUtLY2cnBz69++fjGPb7Xa2bdtGKBTCarVSUFBwwNXV4XAgetqJeWyozFkoNQYEk0z+DS8QqF6B/dNnQKPDs+6TeDozYB5/Ed518zCPPZdQ/WZUllyi7Ts7mUsajSYZIoR4jN7hcFBXV4fP50Ov1ydtbL1ejyAIuN1utm7dis/vR9FSjbb3UFSZvQEZ59L/xEdVTr0dx5JXcC17Cym874S+/Z3ntm3bksPcAMxmMwUFBcybN4+0tDSuueYaqqurGTFiRJe/93By1AW/J12tegqHw9TV1aFUKpPO4Z6ld1qtFikSouWd36AfdBxEQwgqDbmX/ZGY107z63fQ+66ZhHaswbH436hz+2OZcBH2xS8j+uxE7Q2Yxp2PZ+V/CQaDyaLlRBw7sblUWlpKJBKhsbERj8eTFJjVau0UghNFkUhHHc2v3oIizYQUDaHUW1CoNBiHn4L902fIvfgPAARq12Jb8DyGoSfiXfcx/splhOo2Yhx9NtH2HQdsPqrT6Tp1S0iYGNu3bycYDCYzUkeMGIECmcD2VfgrliZ7wIebq+KTD01WkGVEvxNLF5325uZmGhsbGT16dKdjjEQi3HXXXZhMJj799NOjYsbsyTHRPThBVwRvs9lYu3ZtsgK+tbWVaDTaKb7rdrtBlknrOxL/1qWE23cihf3xIgpZAjluNhkGlaEfVIbKaCXSXgeyRPt//4gUDSMotSDLnXqwSJJEdXU1LS0tjB07FqvVSn5+PsOHD6esrIyBAwcmhxSvXLmSrVu30traSm5uLrqisfS5Zw4Zp9yALMvEXG20zX4Y7/q4fRyq34Ici5+HsHsaCTKEGspR5/Qn0lqLoNJ2uWNAwsTo27cvpaWlyZ3YXr16UVtbi6BSYz3jTvr83xys58ZNrbyrn4qPqvzwrwCkT74OzUHCh7IsU1tbS3t7O2PHju0kdrfbzWWXXUZJSQkvvvjiURc7HAMr/J52pkql2m/VkyRJbN++HY/Hw+jRo1GpVGRkZOBwOCgvLycWi2E0GnG5XLtf+xIZk68jY/J12Ba+iH/z4ngufMgLCiWN/74B3YDxxNxthOvLCdVvRhYUpE+6kkhHHe5vZ8ZXud0PYCgUSqYpJ3JWvn8eCSeub9++yUxGu92Ow+HYvcuqwjDsZDxr5hHz2VCl5+NZNw9BpaH9w78iR8OoTFnI0TBReyMyYJ1yG6H6zQSqVyDHwofUube8vBy9Xs+4ceM6vXVkMT4dO61gOCiUBHesBUFAP3AiwV2bCG5fScC5/9Z+kiRRWVmJUqmktLS00zVpbm7myiuv5J577uHKK688Km319sVPYoUPBAKsWbMGlUqVdIYS7R6KiooYO3YsBQUFOJ1OzGZzclV2r5pLpKMuvo0uCBTcNYNeN78CsQimsecnBxijUGI98y4UShVphaPiobqisSi0ekKhEA6Hgw0bNtC/f38KCwu7dPMSmYwDBgzA7XYTrFlN68wHcK/+ECkaQKFOw3rGHfS+eTpyLELfu2fR66Z/x9uKyDI5lzwc770Z8hGq34J+2OR4nk03CIVCrFu3juzsbAYNGtTpuCOhILZPn6Hx3zfi+Hw6CApcy94CBAzDTkaOhQnuWE9OdvY+Uzii0SgbNmzAaDTu1dK8oqKCiy++mCeffJKrrrrqmBE7HAMr/J7sq5C7tbWV2tpahgwZgtls7mSrQ3ylqq6uJhaLMXHixP9tfsjgK1+C+9tZyLuzAaVoGJUlnl5rHnc+lgkX4f52NoEdaxE0OmRZwjb/WURvB+YJlxBuKKeqqgpJkhgzZswhN+8fPHgwaxs8aHIH4NvyOTF3GwpVGsGdG9D2+V+0Qp2eh3Hk6URathNp20Fi0Jqg0aNQ63bXuHaNhHM6dOjQfW6eqbU6Ms77HaLHhq98CSBgPftu7Iv+heOLlwEB83GXom5bw6pVq0hLS0s6wEqlki1btlBUVNQpXRlg6dKlPPjgg8ycOZOSkpJDul4/Jkdd8PvrTSOKYnKuU6KH4/fFnqiGSjhqnbIvVWryrvw7Sr0F+xev4N+8mIZ/TkObNwiUapxfvh5PKZAlRE8Htk+eRkbeXe10Er7Ni0GMEQwGGTNmzA/aIFEqlSi0BjJPvQmA5v/cTdTegO3Tp5HCfgSlmsaXrkc3YBwKrQE5Gop3NxAEjCOnIkUjeNd9AgdpIJugpaWFhoYGRo0atd8CFUkUUWr06EtPR1c4iubX70zOYkWhQtAaET0dBP0+jjvuuGQEaPv27TidTtLT04lEIskcGYBZs2bx2muvsWDBgm73rjlSHJMmjc/nY/Xq1RiNRoYPH75PsTc3N7NlyxaGDRtGnz599n5tCgoiHXXIshRvlirL5F/7LNreQwEI7FiH7ZOncC+fiRhwYxg2GYVCRcapN6FIMwICgtZAr169fvBuYH19PdGOOvxVyxGDXgSVFpXJSsFd79Lr5leRxSimcRcSc7XH+8KLMTJOvwNBqULXfxxSwIVu4AQ4QMIc/K9BbVtbG2PGjDlgNVY0HML22bM4l/2HUP0WEMD26TOAgKXsMuSwD3/5l+Rkx51dnU6HRqMhEolQVlbG4MGDk0789OnTOf3003nhhReYOXPmMSt2OAZW+D1RKpW0tbXR2NjIsGHDkvnV3zdhqqri1Ujjxo07oOff8cFf4oPBjNb4f/XpZJxyI95Ni8i/+nGUhgxc383BV/4lxtIz8Fd+g7/yGwJVX6MvPp5wQ3mn/PNDJTs7GzHoxfnl64gBJ0gSSpMVWZZRmeOCsky4EMuECwlsX4Xji5fRWPuALONc+iaiz4554qUEa1azZs0a1Gp1MvxpMpkQBKGTc/p9B3JfCEoluqKxhOq34Nu4KD5PqmQKgW3f4itfgiyL6IuPIysrbiI2NDQkIzEJs9FoNJKfn88bb7xBfn4+paWlVFdXH9HcmO5y1AWfuDHRaJSGhgZisViy58v3xe7z+aioqKBPnz7JiX77Q6nWkH3F3xCDXtzfzED0dNA+9zH0Q05EEBSEGirQD5yIUp+OIIm4vn47PsmvajnaXkOJeTqIBVysWLGCkpISrFZrsk60u5jNZtIKhpNzySNIoQBNb96J6HfT+MJVaPuWAuBe/SG6otGAjByL0fHh30CWkCURbZ8SvBs+Q1AoKSsrSzrSiSSuRPF2nz59KNw9w/WgyDKm0WeTOeUWwq01tM95BF1hKf6Kr+LjbSx5CEp1MswaiUQYPXp0p7edz+fj+uuvp6ysjIceeuiI58UcCkdd8BB3sMrLy8nOzk6G8TIzMzt10UpsbAwfPrxLtZAKhQI5GkbXdwTSmHOwL3oJdXa/eNeAWAT7ohexffoMSkMGUtCDLMTHK2WedjNS0IPr2/dQaPUMGzaMjIwMbDYb27dvT3YAsFqtXarwkXfPeZVCvngYME2PypSNiILM02+P+woqDd51n+BeMTPejUyhQp1fTKR9B5lTb8O3+XMErQEpFJ+PmpaWRq9evejVq1eygDsrKyuZZmCxWA5YYwsgiTG8mxZiGHJivFW4LGNf9C8QBMxll+Jd/RGByq8ZOfVOFAoFw4cP73Sura2tXHXVVdx2221cd911x1Qk5kAcdcF7PB4qKysZOXIkWq2W9PT0ZBetRKzd5XKh0WgYN25cl1dYMRajbdbvSes7Mj6HFTCPuwBNThEN/76BnEseQaFOw/H5y4Sbqsib9heaX/8VUtCDv+IrTKVnEt61iWg0SnZ2dnJLPxQKYbfbkxmCJpMJq9WazBDck2g0Snl5OS6Xi0j7TuqfvZy03kMQPW2gUKEfMA5d/7HUP3kefW5/AwDXt7PxrPuEjMnX0fb+o4R2rCW0cz2m0efgXf9Jp+9POKdjx45N2ut71tjW19cnx/FkZmZ2ekPJUoxg3ca4zxAJIijVKC19kCN+om21SGEfTz7+dy688EJ69+7d6Xerqqq48cYbefLJJzn99NO7ecePLkdd8B0dHfTu3RutVotCoehUg2m329m6dSsajYZwOExVVVXy3w9WQKAzGFCVnk+0YyeB2jUgS/i2fIGx5FQUSg3EIqhzijCNOpOoozHuuCHj+vptBKUaTf5gfJsX7xWDTktL67R97/F4cDgcbNmyBVEUk6E7tVrN1q1b6d+/PyUlJXy700X6yTfi27iAUMt2kGI4l/2HtKKxAIhBD0qdGU1WAQqVOr7ySxK+zV+gMKQT6agDxW6x7t7d9Pl8yQhWgj1rbAcMGEAsFsPpdCabsKrVaqxWK4KgIO+Kv6LUW+JDI5a9hWn02TiXvIIUK+efz/6Diy66aK9+9MuXL+e+++7jnXfeobS09Afe/SPPURd8VVUVzzzzDH6/n8mTJzNlyhQmTJhARUUFoigyZswYDAZDsnrGbrfT0NAAkHTcLBbLXq9UpVKJOiMPy/gL8Kz5CO/6+Yg+B+3v/wkpEqB15v1o8gahsuQih/04Pn8ZWYqRc/ljdHz0d+zz/8EtN93IHXfcsd9jTzQyTWyAJcS1a9eu5CZYMBgkFoshi7H4FL+ptxFqrSFmqydUX453w0JQaWl88VpU6bmoLHlIIT/+6hXIgkDm6bcRrP4unnogi8RiMSoqKrrsnKpUqr3eUA6HA1mWiNrqUfQZFm8Atdus0mrUzJ7xFmVlZZ1MR1mWmTt3Li+++CLz58+noKDgUG/5UeWoC/68887jvPPOw+128+WXXzJ79myuvfZaRowYwQUXXEBOTk4y0y8xKGvAgAFEo1HsdjtNTU1UVlZiMBiSq39aWhqyKOL6+h1irlbEsB9BqSL7gvsBqH/+KtInXoUUdOOv/AZZjJF3zZO0vH0vgcqvQRJ57ZWXufLKK7t1LkqlErfbjSAInHTSScRiseTqH2qspGPeU+gHTgBJRKEzkv+Lp5Flifonz6f3r2YQqFyGZ/18ZCRyLvg9to+fQKFUE7Htwlh6Ov5Ni1i/fn3SaT8UEvZ/Uf8BNHz0N8RYNP7QRwL0653LP15/l8GDB3cyz2RZ5oUXXmDJkiUsXry42+2yjyWOuuATWCwWLrroIvLz8znjjDMoLS1lwYIF3HPPPbS3t3P88cczdepUTjjhBHQ6HWq1mry8vGTxsN/vx2azUVFRQSwWY8abr/Lhhx+yZNky6uvrYPcuqn7QxLjJkt0PXf+x6AaMp+OjxxE0epBltG3lrN2ysdsrWMJeN5lMjBo1CkEQUKvV9O7dm/Hjx/NdxU5kKbY7zOhAkWYgamtAmdkLEFAZ0jGPuwCl0Ypz6ZtIATeyLGOb/1y8ZbVChQwUFxcfFsGVb1wPwPr163nxxRdxOl08/PBD9O3bF5fLxcaNG5FlmdWr/xcKnT9/frc7Bx9rCN0srzsq45P9fj9ff/01CxYsYPny5WRnZ3PaaacxdepUBg0atFc4TBRFHA4Hdrsdl8uFSqVi0aJFLF22jC1VNfg88Yojw/BTUBrS4zkkssTA/oWsWfltt7P6fD4f5eXl++0s/Oijj/LinEXkXhkv6Wt6615i9l3xgcUKFXI0iLbXEPSDj0eORXCv/gCiIWRBgX7gRKSQN94KUBDwe1x7ff8PIZEAplAoGDx4cKdr6fF4uO2222htbSUWi/HVV18dlV4yXaRLYaKfhOA7HcDuETcLFy5k0aJF7Ny5k4kTJzJlyhQmT568V/psolrJbDYTi8VTBSKRCJ9//jkLP1/CtppapFiMPz3yEL/5zb3dPp62tjZ27tzZqejh+9x66628N28R1tPvQFswgva5fyLmaqPXra8R2rGOjrl/Qj/sZCJttYieeB2tecLFeNd9QtYF9+P6+h1U6XmEdqzB6+h6ne3BiMVibN68mczMzHi/yT38gY6ODq6++mquvfZabr755p9C2PHnKfjvEw6HWbFiBQsWLGDp0qUYDIbk6t/U1ERGRkYnMUqSlKxacjqdyazLvLy8bs0cSkRKvF4vJSUlB4wa3X///fxr+msIGh1S0Bvf9dWZ6XPnW7tt+Avod3885Ojb+jWur98i66y7af/o76hMmcRcrZjKLsO36gPc9rbDssETCoXYtGkThYWFe72VampquO666/jLX/7COeec84N/6wjRpRt3zNjwh4pWq+XUU0/l1FNPTW5QffLJJ1xzzTUIgsCkSZOS/56ZmYlCoeg0RzQcDmO325NlcYm4+v6KtmHf9vqBMJvNaPMGknvV48Q8Nlpm/BbR76Tx5RtJ6z8ekPFVfIWucFQ8A1iMYl/wPLIkIoWDqKz98K35CFmWWL063rkgEfvvTnu7BF6vl/Ly8n1mUq5atYq7776bN954g3HjxnXre38K/OQFvyeCINC7d29uuOEGjEYj06ZNY/Xq1SxcuJDp06cDcMoppzB16tRk/Fqr1SZ3LRNxdbvdzqZNm5BlmczMTLKysjCbzSgUioPa6/siFAohhgPIYhSVOQt1Zm8iYhTLcVfgr/gKlBqcX72BPeSLTxaUoqgyMyHkw3rOPbiXvwuWXGRPG2VlZQSDwWTngkAgkOxenJmZeVCnMtERrbS0dK9Wd/PmzeOpp57i448/PqbzYX4IP3mTpqvIsozNZmPx4sUsXLiQDRs2MHToUKZMmcLUqVPJzc3da6WMRqNJ59ftdqNUKgmFQgwfPrzLA4IB7rzzTt6aORtZjKHtPYSYswVkiT53vo0sidQ/fSH9fvcJUjSM4/OXCdasIev8+7B9/ASG4Sfj27SYrAvux/HZP/DY2vY6rz0rq6Td/ScTuT97mj+NjY3JYWx7PhiyLDN9+nTmzZvH3Llzu3VuxxA9w4Y/VCRJYuPGjSxYsIDFixcTCASSG19lZWV7CaKmpgaXy4XVao2nCkQiSWEdrCnSk08+yeOvzSHzrLvxrf8U75bPQRIxT7iYtMKxtL/3AAX/NxuFVo9/61KcX88grc8wAjUr4wlcohgvw2vfjq2l4YDnlYj9OxwOXC4XWq2WzMxMfD4fsViMkpKSTscqiiIPP/wwLS0tvPXWWwft2nwMkxJ8d3C73SxZsoSFCxfy3XffUVRUxJQpUxg/fjxbt25l3LhxDBw4sFNNqNPpTDq/iaSyrKys5EZZgqeeeoq/vfwu+bvnsja+fBOGYSch+pwE6zYiB+OdhdVZfVGZrITqy0GhiHfsPfNX2D97lrycHNauXNHtGHzCBEuMjtxzeIMkSdxyyy3079+fxx9//Ad1MjsGSAn+UJEkiaqqKt566y1effVVRowYwYgRIzptfH2fhF1tt9sJBALJjMXMzEymT5/O/Q/+nrR+peiLJ+H+bg4Zk6/DMGwyUixCwzMXk3/b6wQqvsK30KZqbAAAIABJREFUaTFiyEvWOb/BsehFQCY/K5Oqis3djs5EIhE2b95MXl4effr0SRaWOxwO3nnnHWbMmEFJSQn/+te/ul0cfgySEvwPZcuWLQiCQFFREcuWLUtufOXk5Bxw4yuRsZiwqwVBwG6388EHH7Dk629pbWmODyIefDzaojHYPvjL/8KS5V/i/nYW5nEX4Pz6LW6+7hqeffbZbh+73+9ny5Yt+xyWUFdXxy9+8QvuueeeZBH2kCFDDv1CHRukBP9jkGiHndj4qqurO+DGF8RX2sTq7/V6kWWZxYsX8+13K1m3uYKQ14Umvxh98STkSBDvhk8hFuWeX9/JY4891u1jdLlcVFZWUlJSstfO6Pr167njjjt45ZVXKCsrO+TrcAySEvyR4EAbXyUlJZ1Wf1mWk711MjIycDqdiKJIOBxm3rx5LFqyNDlOftH8eRx33HHdPp7W1lbq6+sZOXLkXg7owoUL+fOf/8ycOXMOuU35MUxK8EeaxMbXwoULWbhwIZWVlYwePZqpU6cyduxYNm3aRElJCQMGDEg6tYmoSiLvJ7GplJOT060hyIlpKg6Hg5EjR3bKB5JlmTfffJM5c+Ywd+7cvdp5/0xICf5oE4vFWLVqFbNmzeLdd99l9OjRHHfccUyZMmWvwg0g2XM9Yf6Ew2HS09OTzu/+oiiJ7gGyLDNkyJBObxVJknjssceoqalhxowZR2Wu0hEiJfhjhVWrViGKIoMGDWLRokUsWhTPax82bNgBN74kSeoU+lSpVMnQZyKlIBaLsWXLFtLT0/fqihYOh7njjjvIzs7m2Wef/amHHQ9GSvDHMqIodtr4CgaD+934SpCop7Xb7cmJGx6Ph8LCQvr06dPpsy6Xi2uuuYZzzjmHe++996eQ7fhDSQn+p4TL5eq08dW/f3+mTJnC6aefTkFBwV6C9Xg8bN68mYyMDAKB+CjORKcHWZa59tpr+e1vf8u0adOOxukcDVKC/6mSKMpYsGABixYtwmazccIJJzB16lSOP/546urqcLvdnWa0JkoeX3rpJd58801KS0t54YUXGD58+FE+myNGSvA/F3w+X3Lja968eWi1Wm655RamTJnSaeNryZIlPPzww8ycORNRFMnNzd2r2enPmJTgf274/X4eeOABbr31VpYuXZrc+ErY/Bs2bOCDDz4gLy/vaB/q0SAl+J5AOBzmm2++4ZlnnuH999/vUle2nykpwafoUXRJ8Md+98sUKQ4jKcGn6FGkBJ+iR5ESfIoeRUrwKXoUKcGn6FGkBJ+iR9HdRkw/+5S7FD9vUit8ih5FSvApehQpwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JH0d1mqqmhZimOVVJDzVKk+D4pwafoUaQEn6JHkRJ8ih5FSvApehQpwafoUaQEn6JHkRL8D0CWZWKxGLKc2p74qdDdjacUxIXu9/sJhUIolUqam5spKChApVKhUqlQKpUoFAoEITX08FgjJfhuIkkS0WiUtrY26uvrEQSBQCCAVqvFZDKh0WiSQt/zAUg8BCmOLinBd5GE+ZIQe01NDWazmUGDBrF+/Xr8fj8tLS1EIhH0ej0mkwmz2YzBYECpVAKgUCg6PQBKpTL1FjjCpAR/EGRZRhRFYrEYgUCAqqoqNBoNxcXF+Hw+1Go1KpWKoqIiBEFAlmUCgQAej4f29na8Xi9A8gEwGo3odLqk0JVKZac3gSAIqYfgRyQl+AOQMF9isRgNDQ20tLQwZMgQMjMz6ejo2KezKggCBoMBg8FAfn4+AKIo4vF48Hg81NXVEQwGkyaQ2WzGZDKhUqmQZRmbzUavXr2SD0LqLXB4SQl+HyTMl1gshtvtpqqqiqysLMrKyvZphydW9v0JU6lUkpGRQUZGRvL/hUIhPB4PTqeTXbt2IUkSBoMBp9OJTqdDr9cnfythCqUc4h9OSvDfI7GqRyIRampq8Pl8jBgxAqPR2OlzCoUiucInBN8d0tLSSEtLIycnJ/m7Pp8Pp9NJU1MTPp8PlUqVfAOYTCa0Wm3y75VKJWq1upMvkHoIDk5K8LtJ2N6CIGCz2aipqaFfv34MHTp0v0I6nPF3hUKB2WxGo9EwbNgwAKLRKB6PB7fbfVCHWBCEvaJCqQdgb3q84Pd0SleuXIler0epVDJu3LhOK+r32XNVP5QVviuo1WqsVitWqzV5rN1xiGOxGBqNBp1Oh0KhSJlC9HDBy7JMJBJBFEUaGxsJBoMMGjSI3Nzcg/7tnnb7jyX4ff1mdxziYDBIRkZG8nwEQegUFUo8BD2JHin4xKoejUbxer1UVlaSkZGB2WwmMzOzS99xpER+MA7kEDscDnw+H01NTRgMhqQ/0JMd4h4n+IRTGo1Gqa2txe12M3z4cEwmE2vWrOmyiI+ESXOoJBxir9dLeno6GRkZ+Hw+PB7PXg5xwhTqKQ5xjxH8nqFGu93Otm3b6NOnD4MHD07eTIVCgSRJXfq+Y1nwCRImV8IhNpvNyX/b0yFubm7uMQ7xz17wezqloVCI6upqZFlm7NixpKWldfpsd4Sb+GxCVPv7u+XLl1NeXs7AgQM57bTTjqhQDrQ30F2H2GQysWPHDgYOHIhWq/3JmkI/a8Hv6ZQ2NzdTX1/PoEGDkrHv79PdFX7P/+6Lv/ztcf792n/QFI0h2vgSl557Bs8981T3T+QQkWW5y07pwRzinTt34nQ6qa6uxmKxJB+CPVf7n0Ky3M9S8IlVPZHgVVtbi8lkYuLEiahU+z/l7pom+zNplixZwm2/+jXtbW30vu0NlIZ0pHCA2f+5gztuvZni4uJDP7lucKAVvit83yFet24dgwYNIhAI7LVDnHgADAZDJxPxWEuW+9kJfk+ntLGxEYVCQUlJCRaL5aB/u+fuaXc+mxC8zWZj+vTpPPvCvzCedCPKwPsoDenxzyhVCGotr732Gtdff31yc+nHRJKkwyowWZbR6/UYjca9doi74xAfzWS5n43g93RKHQ4H27ZtQ6lUUlJS0slZOxCCIHTZpIH4zRZFEYDm5mZOP+scgmoLqn6jMQ4/Bfe3s/BuWoR+8PG0zvgtyjQT769t4O2ZZ/Gf16Zz5plnHtK5dpUfusLv6/u+b6b8EIfY6XSi0WiYNWsWt912GwaD4bAd6/74yQteluXkqh4Oh9m+fTuRSIRRo0axY8eObpko3bHhI5EIbreb5cuX8/cnn2H16lXoR56Bvs9wPKs/AKWS7EseoX3OwzgWvYS2z1Byr/x7fPNn4CT+7777qfqJCb6rdNUhlmUZn8/H3Llzuf3224/Isf2kBS/LcjJ9t7W1lbq6Ovr3709eXl4yHNedFbsrNrwsyzQ1NVFXV8eWLVuY8d4cdkX0aAeMR5PdD93ACXg3fErLW/cgh4MotAYMw06GPV7dCrUOW1sLr7/+OhdeeGFSGIeboyX477M/h7iyspKtW7fS1NREWVkZTz31FGecccaPeizHnhvdBRLmSygUwuv1sn79elwuFxMmTCA/P/+Q4upd+XwgEGDt2rV4PB4+nPcJjz39PBVV1ZhOugHdgAl4Vn9IzN2GfshkYs5mUChIP+kXGAZPIrB1KeHWGkIN5bTN/gPawSfy5zc+puz4E2lra/vB12RfHCuC3xeJza0LL7yQjIwMNm7cyJQpU3703/3JrfB7FmXs2rWLtrY2hg4d2mlrPcHhWuFlWaa+vp6mpiZ27tzJgw8/SkdHB71vf5PIe78naqvHMOxkIm21tLx1D8gSOZc+gm/Ll0TtDRgGH4950jTaZv0eZJmMU3+JqTRuzri/fJUnn36ap5988rCL81gWPMRX+UT8PvFG/rH5yQh+T6fU5XJRVVVFbm7ufosy4NBW+O8L3u/3U1FRQSQS4csvv+SZ53dHYL6bg1JnJuPkG+j45GnU2f2Itu0g/cRrcK+YidpagGXS5bTO+B2hXZviwh86mUjLdtTWfsnvFyWZr75ayhNPPMHUqVMJh8PY7XbMZjNqtfrQLtZufgqC33M390hwzAs+4ZSGQiE2btyITqcjEAhQWlp6UK/+UFb4xOdlWaauro6WlhZUKhWXTruSiNqEZvBJGIaehGvFTDzr52MYciJKnRkp4EKZZsQ87nzCzVU4l75F5mk3oe09hEhbLVLAQ+aUW3CtmBV/IM69F/eqDwhUL8c2/GReevcj1m7czD133YnT6aSurg5JkjCZTFgsFiwWS6fU365eu8MlpB8jdSIR4TqSG1THtOD3dEo7OjpwOBwMHz6cYcOGdelGKhSK5EXtCokHxOfzUVFRgSAIPPPPF/niyy/RT7iMNJWWYM0qUKrIufRR2mY/hPPL19DkFJJ14e9pffMuxJAP6xl30jb7YRr+dS2CQkXv29+k+ZWbidobST/+Sjo+fpzGl28CSaT37W+gMmYii1FWzrib7du3c/zxxwNxQfh8PtxuN7W1tQQCAXQ6XfIBSOx0Huj6HS7BS5J02IUpiiLhcPiIhCMTHJOC3zN9NxgMUlVVhVqtRq/X07t37y5/j1Kp7NYKD9DW1pbMK7/rnt/gtBQj6a1o8gaiyRmAb+MCWt97EDnoRaFOwzBsMnIsgtqcjXHk6bS+fS+KNBNRewMZp9yIf/PnKNMMZJx6E21zHkGdnkekfQeZU2/HtfRNlIa47yFLEpKs4OOPP6a4uJhJkyahVCqT4k5cl1AohNvtpq2tje3btyMIQvIzFoul0ybP4dx4+rEEHwgEjqjgj7kojSRJRCIRIpEIu3btYtOmTRQWFjJy5MhuX/DumDQej4f6+npEUeS5F19i2rU3UVe3C9MpN6ErHI1n5X8BGUPpmURba5CjQTJO/SWGoZMJVK8g3FqDYcRUpIALOezDOPxUjMNPRfQ78W5ZQlrhKASFEjHsR5M3COOIU1EaM3B/O5uY107LW/9HTGtmnT+DS668lnfembHXMQqCgE6nIy8vj8GDBzN+/HhGjRqF1WrF7/dTWVnJ6tWrqaiooLGxkVgs1q3rdSB+DMEnmlh9v174x+SYWeH3dEo9Hg9VVVVYrVYmTpx4wNf2geiK4CVJora2FrvdzqrVq3nz7Rk0u8NkX/kU/uk3IYUDpJ9wNR0fP0HDC78AWSTvqsd3hyA70A+cSMZJ19H23u8BMI87H6U5m+D2lQgaHdmXPkL7nD/iWPg8uqIxmMsuw/7ZcyCK5Fz6CK3v/R73ivfQ5A0g54q/IggCkaGTeeAPD/GLX1xz0HNUqVRkZmYmC1cSbQDdbjfhcJj169ejUqk6vQUOxRn+MQSf2HjqcYJPmC+JogyPx0NJSckPvhAHE7zL5WLr1q2YzWY+//wLnnvlTcgdgqZAj9KQjmnUWbTOfBBtr2LC9ZtIP+5yXCveRZNfjOW4y2ib/TDhlmrCjVtJ6zsCKexHk19MWr+R+DZ8Rut7DyIF3Cj1ZvTFx6HQp6PtPRRN3iBa/nM3siyCJGKZNI2Y15Y0P2RkfB4XTz/9NNOmTaOgoKDL5ywIAkajEaPRSHNzM+PGjSMajeJ2u3G5XNTX1xOLxTo5w3q9/qCmz48heACfz9dzTJpE+m4kEqGjo4M1a9ZgNBqZMGHCfsV+OFIFRFGkqqqKbdu20dLSwuRTp/DEs89jnHInxpLTCNSsJua1Y5p0BXLIQ7B6BercAVgmXY46qx+eNR+hzulP2oBxBLevQvR0kHXefeiKxuBZ8yGIMYxjziXaWgPRMBmn/BLDkBPxb/mcaMdOjCOnEvO0IwhKLGWXYRhyIsHtKwnuXE9gx3ra3r0f0+hzef6z9Uw6cTI1NTWHfI0FQUCj0ZCdnc3AgQMZM2YM48aNo1evXsRiMXbs2MHq1avZtGkTdXV1OJ3OfTr6h1vwCYfa7/f//Ff4PZ3ScDhMVVUVgiActFNAQsBdNXH2JXiHw5H8vbkffMj0V1/DeuljRJe8iiyK6IpGYxx1Fk0v/xJBpUZXNAb98FPwrv4AWZbJvvBB2mb9AdfydxEUCnrdPJ2W125D9DsxT7yEiL2RxpeuB1kmZ9pjeNZ8RNTVinnMOZgnXELrzAdBlsmcehtReyNRWz2m0WeTecav6Jj3FEgx0idfh3nMuQB49Rk8+cyzvPLvfx3y9d7XddmfM9zR0UFtbS0AZrM5+bnDLfjE9/UIwUejUdauXUtWVhaNjY0UFxeTnZ190L9TKpWdNisOxp6Cj8VibNu2jUAgQGZmJiefNpVY/nBkfSba3kMwjT0X+8LnsZxwFaEda1Fb+yCotOiHnBh3Wle8h+3Tp1Fo9EhBD8aRpxNt34HKmIHlhKtom/0Iaf1HE6pdjWn8hXi+m4M2v5j0SVfQNvthQvWbiTRVoi+eRKSlGnVWP3T9x9E64z5a3v0doqsVff8xxHwO1Ja8/12rgIfvVm5l+vTpXHfddXtVaR0OEs5wwiFOXC+v14vb7aa1tRW/348gCDQ0NGCxWDAajT/oAUjcxyMt+KNi0vh8PhwOB8FgkIkTJ3ZJ7ND9MGNC8DabjVWrVhGNRnngoUcZM34C0oATSD/5JiS/k6i9EePwU9AWlOBY8CLhxq3kXvk30gpHEaj6BkGpIvPsuwnVriVQ+TWWssuwTLiIqK2ecGsNpjHnotCkEdj6DUpDBhknXoO291Bc386Jmz6Fownt2owYcGM981fo+o/DvfxdUCjQDZhAzNGEFAmRfsov0Q8qw7V8BhFbPfbF/ya47Vvcvcr462v/5cxzzicajR7qZe8WKpWKjIwMCgsLKS0tpbi4mIyMDJRKJU1NTaxbt47169dTW1uLzWYjEol06/sTgvf5fJhMph/pLPbmqKzwiQ2U4uLibq0SiRW+q8iyjMPhSLatuPXOX2O3FKMfejJKoxWlIZ2M026h5e17EVRqZDFK/vXP0fL2PQhKDZbjLqd97p9peG4agkKJecJFiCEfkhhDZc7GesavaH33dwgIqLP6knPZo9jnP4ssiWSd91va5jyEZ82HCAolvW55heaXb0T02kg/8Re0z3uCxn/fCGKM3re+RvucR4h21GEaex4RWwMtb98LsQi97/hPfGNKltg5+3d8+eWXP3pG4f6upVarpVevXvTq1Qsg6Qy73e6kM2w0GrFYLKSnpx/QGd5zhS8sLDxi53FUBJ+fn09dXV2yM1ZX6c7OaXt7O9XV1QiCwJ/+8ndWba7E01JH39/8lVBDOfb5/0Cd1Q8UCpAlNJm9UFry0OQUYRhyIh0fP455/IVIARea3AFEOuricfaQj7b3HkTQpBFt34lCo0eTP4i03kPR5hejSs+jbe5jqIyZiB4bpjFnE2mqQqW3kH7itbTOfBBN7kDCdRtJP+EqPKvmojJnkXHqL+mY9xTqzD5EO3aSOfV2nIv/hVK/286OhomEQkx/9TUikQjnnXfeoVz6Q2ZfNrxarSYrK4usrKzkZxI7wzt37kwOikj4AmazOVli2aNMGoi/MruzWkPXVvhIJMLmzZtpampi7bp1/PLW2/lmYxWWK59BodERdTSiKxyFedIV2OY9gfPzl8k47SZMZZcT6ahDjkWxnvlrxICb9v/+ETHgJveKv6LJ6kuwdg2a7H6kT74ez4qZhGrXkHX+bzEOm0xg27fI0TCZZ9xFtGU7weoVGEedhWXcRUTtjYQayjGNPhtBqSLcXIkmbyDmcReg1Flwr5qLJn8wKmMGUtCDypKLacRpaHsPwfHFK4Q76mn5z91IphzWRvK57d4HefKpp3/I5e82XXFaE9VPBQUFlJSUMGHCBAYPHoxer8dms7Fx40bWrl1LdXU1NpstmTrxs3daIS7e7u4EHkzwra2t1NbW0rdvX6a/8iqvzPwAMbMQdXoaCpWajCm30DbrITR9hhGp34xp9NkEategtvZF23sI/oqlNL16KwpBQJJErGf9H961H8Vt+DN+RducR3AufxfCAbLOuw/3d7MRFEr0QycTatxKw4vXoFCqMQw/GYUhE9FrQ2nMIOvc39D+/h+RZQltryFkHncZzi9fByD70kdom/UQruXvos7oRfalv6ft3QeQQj6yLniQtvd+j2/TAtTZRWRf/DCCIBAbejJPPHkb9/3m3iOWeHWoUZpEU6hEu79EJ4Tm5mZWrlzJp59+Sk1NDb/73e+OiKl2VASfaOxzKCv8vpzWcDjM1q1bUSqVVFdv4+xzzycqSuRe8zRS2I9t3pOYxl+IfvCJuFe8R6R+C4I6DcuJvwBBgXv5u1jPuRdt3xKCNatQmDKxTLwE/aAy3MvfxfXdHNL6lSIA6ox8Yq5W9MXHIfqd2Be+SPrk64g6mlFn9EKORTEMOxmlKZvWd+7FoU4j5mxBodWj6TUYbX4xaX1HojRm0jbrD4CAHAlgGn0OUsiLJrMPxpJTaX7r/xAEJXLET/pJ1xFprU3aw2LARSwm8tv7H+CG666lpKTkMNyVAyNJ0gE7PnSVRCeEcDjM1KlTWbZsGbfeeusRs+OPmklzOFZ4WZZpbm5m7dq1RCIR/vvf/3LP7x7AevXTKHRmkCXS+gzDXHYZza/cSsM/p6FKzyP36ieQJRE5FsEy6QoU+gyaX7sN15evk3PpI+iKJxHp2IVCk0b2ZX/Cu+Ez2mY+gDqrgOxLHkWKhIg6mjCOOgttn6HYPn6CcMMW8q56PP6mqPwGpclKxpTb8G1cQLhpK9az7sYwdDL+iq+QQj7ST7mRSPsOYq4WLMdfiXHkVIK1awg1VmAYfgpSwIOgUGAaez6GoZMJ1W/GV/4lvspltL33IOayy3i/3MPUM89h3bp1h/v27MXhjsPvacOPHDmSwYMHH7bvPhBHzaQ5lBV+T6c1FApRUVGBVqslGo1y/sWXQnoflL1LUFsLMI4+B9snT2GZdCXBbd+iSs9FobegH3IiamsBaf1G0jbrIbQFwwntWI153IW4v5uNttdQ1Na+tM64j7bZDyF6OlDpLWgHnwCyjDLNQOZpN9My4754TD7gJmfan+l4/1EEtZaMU26kbfZDNDw3DWQJ61l34934GbIYRT/4eMKttTT++wYEpRrLcZcj+d3EPB1osvqSecadtP/3MZAlzBMuRqHWEm6uxlx2GVkXPojto78jR0PxjamxcafVq7fw5D+eY/a77xz2e7QnP4bgNRpNz3FaD3WFj8ViNDY2sm7dOkRR5KE/PsaFl1+F7pTbMJRNI9KxCykawjzhIlTpvbB99hyhhnLyrnkK/aAy/p+8846Pqs7e//tO7zPJTHoChBAILSEQQu+CKB0B24IKsmvvBbGLa1esKHZERVAEBFEpAgJSRaQEElpIn8xMMpnJ9Jl7f38MZHXXVfCLy75+e/5lZsjrc8/n3FOe5zn+0q0gRkm44DpiHjveXctQpeZiGXAl6ow8mnZ8hkxnRt9lKKHqQ4jBZhJH3IC+82B8hzYRrNiHwtYaQYwhV+nQZndH26ormjaFOFfNJeKqRIqGUaW2Q4pF0eX1x9RjDA1r5uH98UuC5XtQp+Yi15rQtinEWDQGf8lGHCufw/3dQlTJ2ahS2qFKaoOh20VEm+zULrgN1xfPoM7sFE+HdP+YkIZdlez5cS+PPjaHxsbGlrM614SNPyvC+/1+dDrdOfvd37Pz4vCndcrPNsLHYjEqKipoamrCYrEwbuIkdvpsRCQZqqQ2aFoXoMnqTPWbf8P+zvWEqg6QPOlhBJkc2Sk2EnIllS9fQe38a1FndsZ68W2giLdGbWPuxndoMxXPTaRp22ekTXsRRWImUa8TdWo7EodfT/2yv1O/5AEMhaOwDL6aSGMNUiyCbczdRNy12D958BSsYA5ynYlg+V507fui7dCPxvVvE6k/QfLkR1Fndcb742rkBiumXpMIHNlGrNmF9aJb47XD9s8QQz50eQOIueuQxBiW/lei7zQQ93cLCVbsx7nqBYIn9hDpNIp31/3EoGHD8fl8wLmn9/1ZDi9J0h9Gw/4RO69tyTON8JIkcfLkScrLy4nFYkybPpNeffoRMKRjLJ6Itm0P3Js/RAoHUGd2Rgo2I0aCGLqPRts6H02rfFyrX4pH30gIudaETK3D1HM8upyeRF2VNHz7Nv4jO4h56jF0GYLCZENpy8Lc73Ia1syjYf1buL9bgCYtD1VyDqrUdmiyC1Fas6h550bqFtyK6Gsgcdi1KMzJyGRybGPuxrHyGSpevhzfvrWkTn0WZHKQRBKHXkvYWUHF3Ck0bnyPlCueRmGwEmt2YSwagyolh+q3rsO9+UNSrnwapTWTsP0Y+k6D0XUciP2zR/Ef2kTqFU9jLLwY44ibacLA559/jiiKf4rDn0vHPE3g/k/beU1pziTC+3w+du3ahdfrpby8nBtuuZ0abTbmC2/h9J+fMHQmYthP5Utx57SNn4W++1ii7joAbGPvIewsp+6j+4jUlZF2zSsoU9sRrNiHTGMgaeKD+A9uoPHbtzAUjCRh6AzEYDOh6kNo23RDk90d754vibrrsE24D11ub7w7lyEGvOi7DiPW3IAkxjD3noKu40Aizko8P6xCQkCQQGVrjSo1F3VqLoYuQ6n//HH8Zdvj+JkOfZGpNKhT22HudwXOL57B9c3r+Es3x99IkogyMZOEITNo+PZtaj64De/uFVhH3AAyGYI6ng5IIR/BJhevzX+Lhx56iD179hAMBnE6necEjvBnRPjTXZ//76X2TrclfyvCnyZR19XVkZuby6TLruBwlYummpOkj5iNTKmhaevHuL55DaUti3BVCcbCC/H++BXa7O5oMjpSu/Au7EsfQ4hFiTU5MPeZgu/QJmRqHQlDZlD38Sx8Bzci+hvR5vZGkKuQa43I1Hpso+7AvuRhEGMICmUcFfnO9UiREMaiMUQaa6iadw2CXIH1olsJ1x9wSjaJAAAgAElEQVQj7KrEqDWSPPlR7J8+jBjwoO80GFPPcdQveYiYz03C8OuxfzwL19cvo7S1xnrRrdS8MQN/2ffoOw6g+eC3+A9tRKbWYxkwlXBNKY2b3sfc93JU1ixiXhcyrRFDl6EEju3Ctep5DN1H41o9F01WF+wZ+SxYsRa3p5mpV16O2+1uET01mUxYLBbMZvNZg9DOtU5lLBY7L4oK/5WTVq/Xy86dO4lGo/Tq1Yuvv/6a0jovpilPokzMJFSxH5laR9KEBwiUbqVpw3toc3uTOPwGlNZWNO9fh0xjwNz3UkLlewnVlpEwZDrGwosQ/W6aD3yLTGtGaUlB9DcRC/pIGHIt+s5D8PzwBb5Dm4k2O0ESUWd2RNOmEKUlBWPRWOxLHsKz50sCR3egz+uLIJOhzuqMqWg8wWO7sC95COeKp1CYbOg7DUaZmN5SgFa/fT3Vr01D9Luxjr4TmVqHTK4gacJsXF+/yskXLiFSd5TUK55GikWRoiFsY+4mWHGAqtemEW2qI+XKpxGDPqIeJ9aLbyPqb6J+8QPItCaso+7AkD8c0/iH+PijOEWwXbt29OjRg+7du5OcnNzCET5NBayursbn8/1ukXuuI3w0GiUSiaDVas/Zb56Jnde25D9HeFEUOXHiBPX19XTu3LlFoNNutyPYshEEGYkjrsf+6SM07VqG5KlHm9sLQf2PtpZt7D3YlzxIw/q3ECQR27hZ+A9vRowEkal1JE96BPuSh3B9/QoKvYX0v71NzdvXEXFVok7vQOIF19GwZh4gkjBkOkprFq6vXkYMNmMeMI1gxQHc695EbrRiHXUnjqVxzHvC4GswdB9N05YPERRqUsbeTSzYjGvV86gzO8VxO7EI8oS0eB7erpimrR/TsOEdFMYkpGgYbdseCDIFyuRstDlF1H3yAApzMtGGKkxFYwnbj6EwWrH0vyIOcFOqkUJ+Ei74K4Fju1siZrj+BKIg57EnnubeO29j4MCB/yJ9fZpe53a7OXHiBD6fr0URwWKxYDQaf+Hg5zqHF0WRQCDwH2U7wXmGFvw8wns8Hg4ePEhycjK9evX6xWH369ePJ557EU3n4SiT2qDUmYm66xBDfhJH3EjEVYn9k/tRp7VHUOshEkKX1o5QQw26dsXI9Zb4aD8aJuI8CWIMXYd+gIRMpSFh6LXUL52DKqsrkYqfMHQeQrC2FIUlDU2rruja96Fq/rXIBBmCRk/y5Edp/PYtAKwjb8H+2SNUPDcBBIG0qc/TsGYeUY8DXW5vzP2vpH7pnFOkj+sRg16CFfsxFU+IX75Fs4j5mjD1ugRd+z44lj5GzOsgYdhMat+9iZCrEkPXCzD2GEPtezfjP7IDbU4xTd8vRqYxoOkyFH3HgXi2L6Vp+2cgV9C05SMsA6dxUCbn0iuvYuF7b/2LjJ0gCC0Lj7OyslpIIG63m5qaGrxebwsX1mKxEI1Gz3kOHwgE/qM9ePgvGDydJlE3NDT86sZrgN69e/Pck49zx513EfQ3o05rT/q0F6h+dSpRrxNVcjbWUXfgWvUcgiSi7zQYy6CrqZp3dTxyp7XH3O9y3N8tBEEgady9yLQmHEsfI3KqcPTs+IzQ8R0IcjWWYTPx7lqOe/MHKExJKCypEIsiNyehL7gITet8BJUW19evoGldQKzJjj6vH8GKA6hS2mLufwXOVc8TKN9L4OgOdG2LCNcfR2nNRJWcjf/Idmre/BtSJIAqvQMKYxIypRp1ajtMvSdT/ebfEGQKNNmFaFp1JVRVgsKQiG38bJzLn0AMBzF0HYY6rQPN+9ciU+tJmvQwjk8fRgz5SRh8FcZTjClBpeWFV+b9rm7jz0kgpwVPTyskn94G+OOPP7YwoCwWy2+y087EfD7ffzzCyx955JGz+fxZffi3TJIkjh07Rk1NDRaLhc6dO//mARZ268Zdd97B/oMl1Brz0LbqiqDU0PDNq0R8Hnw74gwjmd6CNrsQdUYeckMijuVP4S/ZiP/wFqwX3ULEeRJdbl806R0QVBrqP3sUz7ZPkGlMpFz+NN69X2HqPgp1qy6EnZU0rJ1HsHwvSRPuR6Y1EbYfRZfXP07U2LwQ34F1aFoXYBt9F55dy1Cl5KDNLiTsOInv4LdIkSBpV80l1uzCV7IJbdsiYsFmQid/QpCrSBxxA6rktjSsm49cZyHiqiDaWIPSmoGx6wXoO/Sj6ftPCFUfxl/2PSChTu+AJqNjnH9bupWm7xfTvO8b1OkdUFqzUCRmok7NQZJEvLu+wFVewqFDhyjsVnDGWvkQfwvr9XqsVisOh4PCwkIUCgVer5fKykoqKytpamoiEokgk8lQKpVnXIjW1NQQCoU4evTouYI6P3omHzpvEf7YsWOEQiF69OhxxrdcLpfTtk1rNq/ahNR9NMYeY/DtX0vzrqUIciVp42fjK9mIZ/cKNNndUWfkIcgEpIAXZVIr9B0HEmtuoGHNayQMvZaw/TgypQZFQjq6Dv1QJqSi7zgA++IH0Ob0wn/wW4wFI/Hu/QpVajvUGXnYF82m9r2bIexHoU/E0GUYMY8TQaEiaey91C97AikWQaZQkj7jNWrfvQkx5MPS/0qcX71M1fyZIEZJn/4KDd++Tai2FFP30SQM+yuNa19HEmMkT3qYUOVBfCWb0HXoF+e7fj4HmUKNdcxdiAEv7i0fxtOtvAE0rp8fL9J7XYIYDuBa/SKCUoPvwHpEXwPavlexpvwE64YMY9f27/+wPPdpFtTpOuDn+Pfjx4+3EHssFgsWi+U3aYDnQ6IDzmOEVyqVOJ1OcnJyzvg7giCg0WioOXGUQyvm4d+zAlGQkzz5UXyHvsNUPB5VSjuiXhfO5U/R/NMaDF2HYRo4Ff/BjRi7jUSd2Ymoqwr35oVE7MdIvfJp5FoT/iM70HcaiCa7B95dKwiUbUVpzSJpwmxC1YeIOMrR5vREDPkIHNkOgozEi25GndmJxo3vItcakWJRAke2ocnsiCIxE1PhxYghH01bFxH1ufGXbMBYeBHhuiMkDJ2JKrktrq9exnd4C/6D32LqPYloUx36jgPR5fbBV7qVhm9exV+6hYRhMxGDzSgsqRg6DUIM+nB99RLB47tJmvgAMa8TJAlDl2FIgkDj+jeJumtIu+YV1Gm5qFvlE64+TFaChvz8/LN+XjU1Nf+i+iYIAmq1GrPZTEpKChkZGZhMphYVivLycurr6wkEAkiShFKpbBGsra2tbUmVhgwZctZ/z6/Yf3eENxgMf6gPK5fL+Wzxx5SWlnL9zbdzxFKEMrkt6ow8HMufQt9lGMGyrahTc4gFfeja90Gd1h5VentqP7wbla0V/rLvsQy+hsb1b6OwpKO0tSZYvpeqeVcjSCKKxEwsA6fi/eELAKwX30b90sfjhalMTtpVc3FvfJ+IsxJNZudTufWTSNEwpl6XoM3ujmPFU8R8bsyDriLwwV14ti9BlZxNwuBrCJbvpWnbEsy9J6FK70C4thQpFsXUaxIADV+/QsKQGUhhP0prFhFXJbrcPigT0nEse4Kw/Tj+0q3o2vUicHx3fDA1+BrqPr6P5v3riXnqsY68mYavX4FTZxxtbqC57gTPvfQqR46dYPase/7POfg/myAI6HQ6dDpdCw0wHA7jdrtxuVwcP34ciK/CPL3E4n8mwouiSEVFBZmZmWfl+JWVlbRq1QqbzcaOnTs5fLIWdZtCtKfwJ4FDG5BEkbTprxJprCZcdwxdbjGqtA4071xKuO4o2txeJA6ZTth+lGDFfjQZeYQcFYRrjyDX6DEPuhptdiHe3SsJuyqRQn78JRvQ5/Un5mskYfA1KKyZuL56iYj9GM17VqJKbYfcmIQmsxO6nJ6I4QDOL57Fs2MpMrUG64gbCVWXYMgfgTanB42bFtC48T1EfxPpM17H+8MX6PP6o23Xi5D9GI3fLUD0Okmf8TrB8r0gieg7DiAWbMb7w0qksJ+0q+YScVYQKN+DLrcPodoyYs0uEEWSxtwVl/n7YSWSIMO57O/o2vdFbD+UPVu/ZffWDUyaOOGMz726uvqsdD1P28/rgPT09JZlaJWVlcydO5fvvvsOv9/PwIEDz/q3/8nOKMKfVyGms5Wz/md7cPYslCd30LzqKVyL74NoEFPfy5EbbQhyJQkDpxFpqKLyxcuoe/cmdHkDSBhxA9Kpdqjt4tuIuuuoen0Gvh+/JO2quaiy8gnVlCJTakie8iiBI9tpWDsPbbteJF54M0gSgWO7Uae2Q9ehH77S74l6XdhG34mh8+B4gVlbhtyQGIcFmJMxFIxE27YHiDFcq1+MR+GmevSdhqBKykauM5Ew7K/UfTwL+0f34C/ZgHX49QgqLYJShfXi2/DsXsHJuZNp3v0FadOeA0FADHjjrc6Al6o3ZhCqOkjatBeQxBhhRzkJw2aCQk3D6hdRmJJJGHot2pyeGEfdw9pvvsbj8ZyrR3nGplAoMBgMpKamMmXKFObMmcPVV1/9H/v/z5vD/1HWE/wD+pqens72rd/xt3EDMcujJF54E4b8EcT8bjw/fEE04I0PezTxothUfAn6Dv2IOMpxrXkdz4+rCdcdwVAwApnWiDIxA8uAK/Ad+Ja6j+6l/uN7UFozMHQfjUxnQVAosY2fhWPV85x8bgK+gxtIn/kGMpWWmK8RfadBGApGUr/4Qdwb3sU25m50nQYTqtgfX3I26SGCJ/fRtHURxsJRWPpdSrj+OKHqQ+g7DY5zbhtrUWd0RN9lKEprFg3fvEa0uQFiUTRp7VEkpqNKbou5eCJ1i2bTuGkBoepDmHqMRmFOQa4zY73wBuoWzab6jRlE6sqwXnQzgvIf6Yv/2G5igoIxE6eweMmSMzrvPwOI5vP5sFgsZGZmnrPf/j07rxH+j2Dif/5WqK2t5fjx49xwww20apWFGGxGptaRMmUOTduXYn/vZsSAh7Rr30CRmEmw6mALWCxQugXP959g6HYRiUNnAAK+w1tQmJLR5fYmXHeEWMBH4ogbMXS9AN+B9fhKNhFrdoMYjasUZHREaUmND5c+fZjGrYvw7l6OrkNfBKUapa0Vxh5jiAU8VM+fSd37t6BOzcFUPBEEAYUpGeuo2+Na8i9OQWFKwjbmTmLeBhCjJE18gJD9GPVLHkJhTsE2+i5iHidhRzmm/lcgU2tp3r8OdXoe5j6XIga8ePd+jSqtfRwSrdahze2NrsMARH8TrrXzca1/i4avXyZxxI1UZQ7j9lkP/q7Tn2uHP1+KBXCexVT/KK81GAxy5MgRZDIZxcXFKJVKHrj3Li77y1XEvE5CVYcgFkGT2xtiUWRKNYnDr6P+s0fx7vkS0V2Ltl0xCHJkGj2CXEnSJQ9S/+nDOL94BkGhIm3GPByfP060qR5tm27YxtyNc+WzIMUwFU9El9uL+k8fIdrcgKnHGALHduPZugiZ1kTiyFto+PoV3N99gPXCG9G0LsCzcxkylRpT38uQKdXUfXQvckMCUY8TQa5AlZGHpk0hmtYFKG1Z1H5wF8hkiF4X5t6TiDTUIDckkDjieuo+vAdJjKE0p2C7+Da8P6xEUGpInvwI9Z89SsO6+ehye6PvPPgfw7bJj2D/6F7EsJ+Ewdeg7zig5Uznv7OAS6dM+bdn/mfgaM6Xw5/XlOaPRPhoNMqePXtIS0sjPz+/Rfp5+PDhrFz2GWOzZchdR0maeD/m3pMIVh4g7DiJKrUdysSMOI804I1H7oIReH9Yia9kExFHOVIkhLZ1PqqUHJSWVCwDpuJc+RwNG96lce1rqNPbo0zOQZmYgSq5LcYeY6l5+zqqXr6CiLOc5CueRJArQIyRMOyvSNEwla9OpWnbYtKmPY8yqS2hmlKU1iyso+9qGRhZL74dY9fh+Eo2xjE7g68m5rEjep2Y+kzBkD+C4Mm9ePet/YeOTnI22g790OX2RhJj1C/7O43fLYBYOD5TsGahzSlGldKOmjdnUvv+bahSc9Hl9kGKxlXCpFiE5v3rKDl0iIvHTeTAgQO/euZ/hq7k/2yEP1OHj0ajHDp0iGAwSEFBQYse+s+tb9++9O3bl6/XrEWmNqBKak3C0BnULrg1XkCaUsi8YQHVb0yPs5jS2sej8eoXEQQw970UXfu+1H10L9GmenS5vfAd3op313JAIG36PJoPbqBp2xJUyW1RJGaCKCLXG9B2HIwmoxOq5Gwcy59A07aIUNVBDF2G4i+N9/QThlxD/eIH8R/+jqizAkPBhQQrDiAoVGjbFROyH6PqlakISjWmorFIYoxIQzUKUxJJEx/EsfwJpHAAc9/LUJhseHatQOo1EdvYe6hbeAdIYryDZEnDufLZOEw6uzv+sq3I9QkYCy9GptHHcUWxKP7SrQgKFZZR91DiKOfCUWPYsXXzv+TUf2aE/0/K7MF5dvgzJYG4XC4OHz7cIuXwe3IRU6+4jLeXzEPsd3Vc3kKuRJ2YjqpNd+RaI5aB07Avug9tx8EES75F26YbEY8DpTUrXrj2u4zqd29CrlC2tDhr378VKRrGkD8ivrHj/VvjejXDr0eKhvAf2Q6n0Jl1H9xO47r5aLK6kHjhjQRP7sP70zcY8kegbl1A4OgOpGgYy8BpNO9bS8O6N0gcOpOouw6FORkkCW27XiiMNmoX3kl9s4uIqxqlJQ1BpUVutMa1cCr2U/XaVSAIGDoPQYxGiPrcGPJHYB4wlfrPHkGSJGwX307g+G6CJ/aQMHQGliHTaVjzOohRMm/+CLnGgCazE82OI6xZs4bp06f/4jz/TMWC/5kIfya81lgsRllZGT6fjx49eqDRaGhqavrdS/Loww+hVmv4bNmHuI6UkXLp40TdtXh2f4EYCWHsPhrf4c0071qGoIyP670/rqZp6ycok9ogN6fEB1AaPcpWBahsrTB2G4l9ycMYul1I4OB6tK3zCdmPo07vgMKSgr90KzXv3IggRkCpxTLoGkLVJQiCjKSJD8Rz629eQ6bWkT7zTWrenEm0sfbUBXLiWPkMUjhE5g3v07hpAc3715I4/DosQ66Jv4HkSpLG3UvEeRL3dx/EaYQ6C4JcgaDSou88BEGlxb7oPkS/m2D5T6hSc4k22VFYUrEMnErdx7NpPrwFKejBOup2Gr56GSnsB42BSEM1nhP7mPNUCVu27eCFZ5/GYrEAf05Kcz4UC+A8d2l+K6Vxu93s2LEDvV7f4uxwZm8FuVzOg/ffx95d2xGjYVTJ2eg6DkSZmEH1G9dQN+8qRK+LlMtP5dySiLH7KNTZhdS8dT2ulc/FCSP9rozL74kxEobNRFCqaVw7HzESxjbxATSt82nasRQEGfqCkcS8DqRYBMuAv2DoPJhwTSnubUsI1x1BDHrR5vRElZqLwpBAwrCZ1H08C8fyv+PdtQzLoKtBJiDT6EkYOoOw/TgVL0yi4cu5JE24H4UljainHn3HgRi6XUz90sfx7l5OyqWPo8no2JI2WQZPp/mnb4g01mAbcxe63N40bnwPKRpBlZwd77ZIYMjrj6nXROo/fZTGLYuo++AO9IWjUY28l/VljUy67MqW9u+fldKcrbboubDz7vD/7LyiKFJWVkZpaSkFBQW0atXqFy2xs5HMFgSBwqJeeLd8CGIMZVoHpHAISRAw9Z6EOiMPdXoejmVP4ju0meCh79C26gwKFZrWBejy+iPXGql55ybs799C1FVB4oU3xjH3gozEC/5G1OOg4tlxccec+CDqVgWEnRXI9RaSL32c5h9X07D2DYyFF5NwSnwp4qzEkD8chSmJ4Im9KBMyMBVejC6nGOeXc4m4a5FiEVS2+AJjbXZ3LP2vxLX6RZxr38C763MMnYeAII8LPg2dgf/EHipfuZLGNa+RNH42cq2RmK8Ry8CpyA0JVL97I4Gj20m9+kUElYZgxX7MfS5FkZCOZ9vi+CLl4gmoUtpivOB69v64h9LSUsLh8J+W0pwP+6/q0ni9Xnbs2IFSqaS4uPhXUZRnK+/xzvx5ZEUqqXxhEk0b3yV5yqNoOw0hXH8CQRBIGjeLqNeBe81rSEDS5EfRtOqK54eVIAgYe44n5nUQa27A3Pcy9B0HIChUNK5/k1DdEWKNVWhaFyAhom3TDXO/y2n+YSWO5U/hXPY4Cksq2pxi5PpElIkZJAyZQc0Ht1Hx/ESkaISkSQ8jhv1IsQjWUXcghvzYF81G9DWScuUzyDRG/Ed3os0pQtdhAL69XyNFIyQMm4mufR8avnmNWNCHXGuK69XIFGjb9sDc73LqP3uMxs0fEji6E2O3kci0JuQaI7bRd1G/7AmqXr2SUNUBrKPvQBKjSFI8kHh//IqoKDFmwmRm3TebkpIS3G43drudUCj0f372P79A/2le639F0SpJEidOnMBut9OlS5ffrNzPdtlwSkoK7789H5lMRu/+g9BkxZXJ4spiDyJEAvGNHr2nEDi6A0Emj/fsl86h4rmJLYVpxHmSSGMdglxJyqVz4gTw/etQJGaSNGUONW/OxHd4C/q8/hiLJ9D03UKQyUmfEieZuFY9j9KaiRQNx/Xkk9qga98XTVYXVMltqVs0G7k5hVDVQczFEwiW70WmUJI0fhb2z/8O0TAgkTr1uXieHvKROOJ6nCufp3bB7cjkCtKve4eaN2cSPLkPY7eLCFbsx7t7BUpLGgmDriZ4/Aeavl+MLq8fMqUamdaE0pqJvn0fmn9YRf3ypxCAcHUJSZMeRlCoWbL6VVJSUhgzehSBQICamhoikQhGo7EFBny2vNRoNHpOdCr/iJ1Xh1cqlQSDQXbu3EliYuK/UPt+zc42wguCgNvtjhdKSgWBEz+izS7E3PdyGta8BjIFtlG3o2nVleYfv6Rp1zI0rQqQ/E2orBmEHRXoOw8m5mukbuFdiAEPseZGpJAffdfhxAIeZDIZSeNmUb/0MZxfvYwgRkm54imcq54n6m1A27oAy+BrcK58DpCwjrwJKRqhed8ajEVjSRx5M7Xv3Uyk7iiG7qMx9RxP8751ePasQp3RCZkgIE9MR6YxoE5thyF/BPWf3I8qoxPB8h8x9RhL4Pgu5GodtjF3U7/iqbjagiAjacIDNK6bHxeHmvwI9Z89RtP2JWgyO2PudxmuVS8ghgPYJtxH3YI7kCJBEoZcgyazMwBiv2ksX/UFl06ZTJs2bWjTpg2iKOL1enG73ZSVlREKhTAYDL+4AL8VuU8z3c6H0583h5ckCbvdjsvlomfPni0Ltn7P5HL5Ga9XCQQCHDp0CFEU6du3L58tXsSkSy8nrDXRVF+DbezdNO9bewqSoCfl0sexL34Qzynp6pRpc6l5628Eju1Gl9uLxBE34Fr5LJIgkDTmbhTWLOo+uAN/2TYUiekIgMpkQxJkqNM7YOl/Bc4VT6LvdjH+A+vQnGJRKSxpqNJyCVbsOwVJltC0LkCV1p5IQ9Wpv+Ux7J8+iuh7F23bIsz9r6B+8YNEvS4sQ6Zj//Bumveujqcvp+RHPLtXoGldgEwmR2ayobSko23bnWZbK+yfPozckEDM48DQaXC8TsnsjL7TYKrnz4y3QrO7I9MYiHobABBDfpq+X0yDs5zR4y/h1RefZ/Dgwb9Yita6detfEMKPHj3aQs62WCwkJCT8yyaQWCxGMBj8j9P74Dy3JVUqVYtOypnamRatp3E2bdu2xW63I5PJGDhwIMfKDvPll19y+wOPo8vtjUxjwLHsCWI+dxyXHg2hadszjlSUybGOupP6z+cgW69F9DeROPy6+EQ0EkJpSSVpwmzqlz0JkQDanJ5Yhsyg7v1biTbVo+80mGBlCZ7vP0GQybBd+wburYtwf7cA60W3obC1hiPbkWmNGLuPRpnUmtoFt+NaMw8x4IFoMN6PT8xAldQGU/EEat65ASQJhTkJ68ibaT64AUGpJmXKY9QvfYzGjQvQte2BsXgizpXPIga82EbfRe2CWwlXH8bcZwra3F7YF81G17YHiuQ2IInITUnoOw9BmZhB3ceziPkaCZb/iColB9voOwk4yrn8L1fx3YZ15Obm/suz/GdCuM/n+4Uigk6na3kDRKPR//gG7tN2XlOazMxMamtrz+o7v5fDR6NRSkpKkCSJ4uJiYrEYNTU1Lf9uNBrp168fQbcDva8RTVYXLAOn4t74PgiQNPFBZCot9k8fJmw/hio5G4XWhBj0IFPrMHS9ALnOjPOrlxD9bvwn9iBTKFEkZ8fBZOZkLAOupOb9W5GrdcQCXlIue5z6Tx9FikWx9LuchrXzqX7rOoRTObln9xcETuxB0zqfpPGzqf/0ofieqItuRaY341zxNLq2RShTc0ESURhtGLoOR5fXH8/uFThWPocgyOLCTx36IDclo8mMc16r3/wrSHEerC5vANHmBlRJbbCOugPn6heRYpH4Ck3HSfylW7COup2EYTNxffUyiFHSrn4JmUqLwpyMWN6bDRs2/IvD/7P9fDlyZmYmkiTh9/tbFiP7fD5ee+21lt28RUVF/7Hi9bwRQOAfmpFns2k6FArh8Xh+dfNfY2MjP/30E+np6eTm5ra8Derq6n5BXjCbzYTCYb577ynEusM07lpFwqCrCNeXY+g8BFVKDgqDlfrPH8fz/SJU1kySL/s7nl0r0HcZijq1HYJCSdN3HxJ115Fy+RMozMl4dn6OLrc3ysR0mn/6BkES0bbrialoHJGGarx7vwKgee9qdDk9CDvKSRx+HeqMPNybFuDds4rmvasxFl6EIFehsGaga1eMTJ+Ac+Wz8Q2C/a9AnZpLsHwv+s5D0OUU07RlIRHHSRKGzECXU4x70wJUae3jHZ7SLShMSZiKxqLL6497w7uEXZX4D29BptYh1xrRte+DvtMgPHu+pHHTewTKvidp3L0ET8SJJXK9hWDVIRo2f8SG9etZ8+1Ghg0ZdMaE8NNvc5PJRHJyMna7nVatWrFv3z6cTicXXnjhuXD4/26KH/yxltSvFa2npT4aGxvp1q3bL+SX/x3J5OEH7mfk8AtYvHgxi4I+jN1HI4b8OL96mcQhMwhWHoVXpt8AACAASURBVEQmV6CwZaHN7YPCYMXc91LqPrgDVUpbghX7SRgyHfeWj5CptOjz+hNtrKF6/nSQKTAWjECd1RXPjqVIYgzrRbdgX/wgDWtfR2lOwTr6LqJuO03fL8bc91I0bQrwHdyAFAli6jOFUPVhnCufQww24z+yA4UpCRBQJ7dFndmRwIkfqH7jWqRoCG3bojiyMuhFnZGH5YK/4vj8CSQpRuIFfyPirsN/dCe6jgPi4lHL5gACqVc8RbB8L+5N72O96BYU5lRivgZiQV88PRt0FfWfPoKqVVeCZd9jPVXcH92zknGXTGHXti1/6BkKgoDZbKagoIC5c+ee9ff/L3ZeB0/nwuH9fj+7du1CJpPRs2fPf9Ea/y1WVa9evRg1ahRS0IskiZh6T0bTqoD6z+fgO7ielMufwNDtYnxl3yOGgxh7jEGm0hA48UMc6154MYYuw+Ky1RX7CdUeQa5PQGFKQtuuN7rc3sj1Fmrevw37h3cRcVaQMOhqZBojgiDEVdGO7qTi2XH49q8nfcY85MYkwjVlaNt0wzJgKk2bP4zLfk9+BF37PjRtW4wYDqDN7YMYakaQyTAVj8dUNBbPjqU0blmE94cvUZiT4po6iemYe08m1uyi6rWrcCybg6X/X1AmpBFrbsDYcxyaVgXUfXwf/sObSJv6fBwqcXgzxoILUaW3J1C6BVVqLvoO/ZBrTRj6XkFFRQVOp/Osnx/En/v5UCyA8+zwf8ROpymSJFFVVcXevXvJy8sjJyfnVy/QaZb8v7OBAwfSLsOGd+VTNG1dhO+nrzB2G4kUi6JIzMSQfwHKxAwqX/sLNa/+BbkhkaRLHkaKhOKa7YOuQmHNwr50DoFjO0mb9iLa7B40718HgGXQNYheB5HGWsx9L8WQP5yY303jpg8I1ZYSa6pDm1OEIiEdhdGGdcQNOFY8Re1Hs2jc8BYJQ69FkMfH7+Y+U5BbUql6bRrub98i5dLHUaW0I3ByH6rktiSOvInm3cuI1JVhG38fuvZ9cX+3EDHgQZXWASQRKRrB0PUCzH0vw7l6Lo2bPqD5wHoMXYYhKFTINAZsY++lYf1bVMydTKhiP0lj70X0NyHF4kPCWHMDsUj4Dzns6WdxPnA08F/i8GezrUImkxGJRNi7dy9ut5vi4uKz6vL8symVStZ9vZp7rxpLvrwaQ9tCEobMQNumkMYN7yCF/CjMyQiShEyjx1g0Dm2bbsgNidR/+gjuzR/iL9mIuccYBKUamd6CZcBfEH1uKl+6DPvCOzH1HI8+fwRRtx2ZSkvyZU/gL92Ka9ULaLO7Y734dmJeJ8Gqg2iyu6NMzSVsP4pca8GQPxxj4cU4lj2J/+hOwlUlaLLykWJRVKntSDilklb97k24vpyLZfA1yLQmpEgQc99LUdpaUf3ODXh3Lydt2lyU1iz8R7ajy+2NoesIvLtXABKWodeiSm1Hw7r5AAhyBUprFurMTmjb9URhzcC+aDYN69+macl9zJp17x8SQj2tC/8/6fB/ZBPI6c3P6enpdOnS5ZwMLzQaDbfeeitDBg9CroqD1Kyj7yDiqqbypcvxbPuU1CufRZ1dFMevy+QkTbiPqLsG767lcQ3JAX9BmZiBe9MCxEgQQaVFplAhSSKGggsxFY3FX7oF55dzaVj9AohRdHkDkBltyHVmbKPvxP7Zo1Q8N56Yq5K0qS8ghv3Egs1YBk1DaWuF88sXiPk9JE9+GHV6B5q2LUGRkIambQ9innqQJIzdLsJUPAHH8ifx7P2GwLHd6NsVI8gVyE1J2C6+lcaN71H56lS8u1eQPCkuCU4kSNL42URcldR9dC8Kg5XEC28iXFNKtKmepHGzUKbkIJZ+y8K3XuPuO+/4Q2d9euD0P5vSnCnNTxRFSktLKS8vR6fTtez9PBcWDAbZvXs3AwYMIFb5E95dywlWHCBSfwxddiGCSosqpS2W/lcSOL6b2gW3YX/3RhTGJEx9JoMgi+NyJj5IsHI/1a9fQ6hiH2nXvoHSloX/2O54ujLqdgJHthOqO0riRbdgKhqD78B6/Ee2I4kxBElCnZyNJqcIVVIrDPnDqf3gDuqXPo7/8GYSBk5FpokD12xj78F/ZDsVz4zDf+g70qfPA0Eg7DiJqWgc2uweuL99EykWJnH0nShtrXFvXojMlITClIygUKO0ZqJt0w1d3gDsi++nceN7hOuOYigYgdycgjqlLeZ+l1P73i1UvTYNVeVOVq9aybBhw/7wWZ8WZT1fffjz7vBnQvNrbm5mx44dqNVqioqKzilyz+Fw8MMPP9C6dWt69erFJx8tJDdUhnznB+jb9cR2yUMIcgX+IzuQ6y0YCi4k4jhJNBiXqTbkX0jw5F7cWxfhL/ueiOMkuvZ9UCRmINcasY68mabNC6l+6zqcnz+OZeBUVMk5SCEfqpScuAjs16/gWvUC5l6TMA+YSvDkPmIBL5YBU5HJFPH2YPs+GAtHIVPraVg3P768zetE06YbSmsrFCYbiSNuoG7RfdS+dwvN+9Zgveg2BLkSAUiacD/Bk/uofu1qxEATKZfOIepxEHHXkTD8ehDk+A6sR99pEObiiXFK4f51qDM7YWzbjd5F3Th8cD+FhYX/p/M+jZQ8XxH+vLclfyulkSSJyspKqqurfxdUdrYmiiJHjhzB6/VSWFiIIAiUlJRgs9lY+9UqZt//AB/+5EaQK0gaPxv70jmwMgSSSMoVT9G4/i2ijXXoktuSfNnfqf/kfoiEMPYYg6loHDXv3kjg5E9oWuWjTMomVF0CgLH7aOTmFFxfvUTU48Bftg25zoyg1KK0ZaFt2wNd5X6q3piOgIAqpS3W4gn4Dm0CmZzkKY9iX/IIvn1rUWd1xnbx7dS8eyPBqkNx2ezdXxBprEGT1Rl9p4H4Dn6LY8XTqLO6EHGeRN++D2I0hDIhDcuAv1C74DaQQGFIJGHwdIKVB1CYkkie/CgNa+bR1FjDiAuG8vqrL5/11pB/d+4KheK85fDn1eHh35NAQqEQBw4cQKfTUVxc/H/GT/9casLv97N//35sNhv5+fl4vV4OHz5M69atW6SiR144gvc+mk4ouzuCxoBMJiDXm0GlQ53eAfPAqThXPE2w8gChk3tRmFPi8Ft9AnK9BdvYe3AsfxIp6ENhtJIxcz7Vb/2NSGNtfJFav8txb1qAFAmTcd07+Mu+p2nbEpTJbVGl5iJIEgpD/I2ia98X74+rcXw+B2QKYk116LsMAzEaX20/6g7qP30YKRJElZxN0vhZNKydD7EoSRPux774Adzfvh2XET/l5IHjP6Bp3Q2Bhch0BvRdhmDIH07zT9/g+OJZlNZMlEE3zz7zBN0KCs5ZsDmd0vzPOvyvRXiHw0FZWRnt27f/1Ynq2ZogCC0Ofxpj07FjRwwGA1VVVdjtdrp27foLMNOQIUN47u+P8eCjj9HkbkLXrhfGvpdTt/BOol4n2tYFGIvG0bRtSZwbetNCwnXHcK1+EaU1CzHojYsnpeYgT26L3JBIwpAZ2D+6F2VyW0JVB7AMmYF7w9vxjdvdRxPzNVLz9vUIciXWUbcTrjtK4MQe9J0GkzThfuoW3oEYCpAw7Fo0rbpSt/Au1K26IijUgIQqNQdNdg80rbuhTm9Pzfu3gQBSOICpzxRiXhcKczK2cffi/OLZ+Gwh/wKUSW3wHdqEqed4Uqc+G99acmwjT/79EfLy8vB4PJSXl2O1WjGbzf+n4PNzPut/msAN/wUO//OiNRaLUVpaSjAYpGfPnr9J/zobcaDTrcwjR44QjUbp0aMHoiiyf/9+NBrNv60Lpk2byrRpU5kw5XL2yDqgTEjD3HsyNe/ejNKcRKShmqTx9+H84pm4xEd2IZYh03GueApBEOL5elI2rq9fJuZvwlBwIc0H1hM8uQelrQ2mwouINlThWP4kxl6TCJ74EVVyG6KNtajTOqBtU4h9yYNUvzkTwnFwmiTIiPmbUCakx5UMvngKKRzE3HsySmsm7s0fYioai3nQdOzv39yy31Wb24u6Bbfj3voJYjgAYgx1Wi7K5LYYug4jeGIP1W/+Fblai1GI8OGHC8jPz0ehULBnzx6MRiNOp5Njx44hk8lISEhoAf6dzQU4vb3vfzLC/5z15PF4OHDgAJmZmXTs2PE3nfn09PRMD1oURXbv3k1WVhapqak0NTVRWlpKTk5Oi7jnb1nvou7sWvQlYm5v9F0vwLt7eVw5OLsQXU5RfEvf0scwFY2n+Ycv4lPMSAhVUjaa1vnoOw2h6o0ZcVy7KZnkKXNo+PpVpFiEhCHTaVgzD9fKZwHIvOlDXKuep2nHZyQOm4m+81DcG99FkCsx9Z6MFItiX3QfUiRIuO4YcqUGmSUNhTkF7SlB1ap5VyMIcvSdByPTGAg7yjF2H0XypY9T/9kjiCE/1gtvQopF8OxYiqZ1PgkjbqBpxeNc1Lcbjz3yMKFQiEOHDuH3+1Gr1chkMrKyssjOziYSieDxeHA4HBw7dqxlf9TpC/BbTYXTffjm5ub/zQgvl8ux2+1UVVWRn59/Rrf+dBr0ew5/ehrr8/nIz8/HYrFw8uRJXC4X3bp1O+PByR2338aP+/az5o2riIoS2rY90HQYgGfb4vh+1n5XEPM10bA+njdn3vwRnh2fn8rJs1Gl5yEAcq0BQ7eRaFp1RZWcjX3RbJQpOfhKNmHqOYHmA+sQFCoSL7wRx4qnqHh2HMiVpP7lWRrXvUmo5jCGLsOwjrkb18pnkGJRUq98mnB9Oe6ti+KdIX0igkyOXGdGnzcAZVJr6j68G/viB4k21aG0tor33QUBfechxDwOat+7GUGM8pepU3l57gsolcqWdTdt2rTBYDDQ0NBARUUFgiBgMplasPByuZxQKITX68Vut3PkyBGUSmULFt5kMv3iAsRiMdRqNcFg8JwUwWdr59Xho9EoJ0+eRKFQUFxcfMbtxjMZVkUiEQ4ePIhSqSQlJYUTJ04QDoexWCx07979rF7DSqWSTz78AIfDwbCLRtNcOBp1egeaf1xN3cezUFrS8Jdtxdz/L3i2L0FQqDD3vRTXuvlUvXIlglJN4vDrifkaCFYewNh9FNYxd1H3/q00712NvtMQzP0uw390B40b30ffcQCiz40qOZuo14U6tR0JF/yV+k8foXn/eiL1x+IX5OAGpGgk7rj+JuyLZgOQPPFBfKVbaC7ZhHXkjfEL9PnjCIJA4iUPEXFV0bD2jXjRa7Si02r57JOPWiSrm5ubOXDgALm5uS3bQmw2W8u5NjY20tjYSEVFBTKZrOUCZGdnI5PJWi5AbW0tZWVlLbyHhIQEotFoS610PjZxn1d4sEwma+E3nk1xWl9fj8Vi+bc5vtvtZu/evWRmZraoHtTX12O1WgmFQpw8eRKPx9Oij3Kmzq/X61n/7QYq6t2oW+WjySmOa87XlmIoGNkymApXlyIzJOI/sA6ZUo0YDpB4wV9RZ3Wm+cev8Oxahm/3CmQaI8bCUcSaXejzBqBr3xvPzmU0bVuCXKMnddoLNP/4JYrEDLStuhJrbsRfuhUQSJ78KIJcQeO3byNT62netyaOWQ80Ye57Gbq2PfD+8AXuTe/jO7gB68ibiDTWoLS1OjUnSKfpu4WkRmp5d/48Bg0aBMQbBqWlpXTp0qVFl+bndlrv3WazkZmZ2fLcTi9AdjgcxGIxdDodqamppKenYzabiUajOBwO6uvrWb58OYcOHaK4uJjU1NRz5fhnBA8+rw4vCEJL/n42Du90OjGZTP+yweI0GfzkyZMt6dHx48epr6+nW7dupKamkpqaSkZGBmq1uqX7UFlZid/vB2jJV/+d9elVzMKXHid4ZBvurZ+gTG6Ltn1fpKAPXW6v+Fr6n77G8/1ipEiItGtfJ1RZQizgQdO6G3J9Ar59a0CSSBhxA9qcItybPyTqcRK2HydwZDu69n2QafRxbH56Ho6Vz+He+hGR+mOkXfUSzT99jaHzELRtuiFFgrg3f4jY3ED6jHlEGqoIlMd5uxFnZctCB9u4e1EkpONa9QLRJjti9UGSlBG2bFxPXl4ekiRRUVFBbW3tWaV7crkcg8HQcgFsNhuiKNLQ0NCSPoqiiF6vJy0tDZ/PR05ODsuWLaOuro7u3bv/6sX6A3ZGDi+cDXALOKsPn4k5nU7Ky8vp2rXrGX+npKSEtLS0luVaEO/b79+/H6PRSHZ2NqFQiIMHD2K1WsnOzv7NIjgajdLY2EhDQwNutxuFQkFiYiKJiYmYTKZ/+a7X62Xbtm1MvWYG5sueA5ksLmTUZSjIVXh3LkXXoR+RhmrSpj5P1OPA/ukjRJvsCJKEdfQd+Es2oc7qgqloLBG3HfuiWUghP6Y+l6LP60ftgtuxjrodZVJr7B/diyDIUFhSSbns73h+WIlnx+dxXPzRnVgGTsO9eSFZt3yMFI3gXP3SKQUGGRl/e4e6j+8hYdA16Dr0JVh9CPfyx5l59VTuv/9+TCYToihy+PBhAPLy8s5pqhEMBlvO1uFwsHfvXrZv387evXs5ceLEudSnOaOW3XkvWs9GUPW0/XMO73Q6KS0tJTc3l4SEhJb2WV5e3i8uxW/9DUlJSS1vmVAoRENDA5WVlXi9XnQ6HVarlcTERLRaLUajkV69emEwGIk01qBt042Uy5/C/vEsBDGCufdkDIUXU/PODfgObUaT3R25WoeoVCNFQug79EOZmIH9kwcI15YRqT+G0pyCoDUiKJQozCkkjZ+F84vniPndaHOKMA+YiuPTh4l6XXF57hN78B+O49RNRWMJVuzDseIZDF2GEq4tRdOmgIirMj6YGn0Xjs8fj2NpQh5mTr+Gp5/8OxDfwXR6CPfPolfnwjQaDcnJyTgcDlJTUzl27BiBQIBBgwaxY8cO+vbte07/v9+z/wqH/yMa8aelHo4cOYLH46GwsBCZTEZZWRnBYJAePXr8YRk3tVpNWloaaWlpLXxMl8tFWVkZgUCgRTnhmSfmcN1NtxLpNBRf2XaU1nRQaOITV62J5EsewrH8KWJfPIMyIZX0v75JzRvXEqo+hDqjI5Yh02lc+zqIMdInzyHaVIdj+VPItUYiDdWIpxYXqzO7oE7Oxlg0npp3bojrSSpUJE2YHZ/WijGSxt6DY+VzOFY+jzIhlaTx91Pz9t/w7luLoctQLEOvJbBxPl+vXkWPHj2AfxSnOTk552TA92sWiUT46aefMJlMPPDAAxQVFfHWW2+dl4IV/ksc/o9E+EAgwK5du7DZbBQUFBAIBCgpKSE1NZUOHTqcs0glCAJ6vR69Xk96ejolJSWIokhiYiIajYa5zz7Fvn37eH2XnYxpcwnVHMa1+kXkRhsxvxsx4EGTnov8/7V35vFRVuce/82SZGYyzGSSkAQSthCWkIRARIIY2sgOBWsFrNcFpSBUxAXqRywu7UVoAaGit1QvUsVeZIcCV0kQlc2i1oCYxQSyE0KWyQzZM5ntvX/EeS9gzhkSMrKc5/tnfp9z5szML2fO+5znPCekN1QBgQidtgTVe16DQmuAu96M0Gm/g/XzTXA110LTKx4hU56F5eD6tkrEv1gMSZJQd2ILAuNSERj7MzT8ezcAtF2OFjMSjWfSUbXjFahNPWArPo1uw6fAYS6G0s8fYTP/gJoDr8Oa9hZCw3tg1coVACAvJcrLy5m3n3cFzc3NyMzMhNFoxJNPPoknnngCc+bM+cmrjV3ODTd8Zy42a2xshMViQUJCAgwGA6qqqlBaWorY2NjrOgzi7TVzcnLQq1cv+UpGABg2bBjGjx+Pdza+C8nthLZfEkzjF8D68V+gUChg+vnj8I/oD/P+1XDWV0MTfQf8TD3RWlUIv6AI6AaNhsvWCPM/V8Jwx3Q0fvcJ/MP7wVlnhkof0larpuY8yt+eA4VSjW7DJkMdHNl2K7ckIfS+36Pyf5agqSwbhpG/giF5JirefwZ1X+2Bplcc9D37Y2jiQBw8sA9AW62egoICWK1W+Pn5oaCgQH5eCQwM7DIz1tXV4fvvv4e/vz/mzp2LVatWYfLkyV3S9/Vwww3fkQ/Y5XIhLy8PDQ0NiIiIgE6nQ25uLlwuF0aMGOGzSlaVlZUoKSlBfHz8j2ZDtVqNiIgIPDF/Prbtfw1+Q3+Bhn//EypDd7idDvh1742AyFgYRt6P8o0LoFAAfqZIRDzyetuup60R3RInwtVoQe2/tgEuJ3rMeQt1X+/Bpc/eRfCkpyD9cG2PUmuANiYZAVGxaD73JS7+fRHgaoVSZ4Rh1Cy4m+ug0nZD+H/8qe3C44y9eOjXs7Dmh/W62+1GSUkJlEolxowZA4VCgebmZlitVhQWFso56p5/gM6caALawsbFxcWw2WxYvHgxPvjgg+tOK+4qbmhYEoAcDvNWqqOxsRHffvstQkJC0KtXL5SXl+PcuXNQKpXo2bMntFptl1ek9Rw6qa+vR2JiIndncMK4cdCpJNSd/RIlZ7PRY+7fINmb0Zh9BNroOyC5HGg5dxJqnQH6YZMROOhuuJtqcenIJthKs9CU8xlMY+fBVvIdjMkzoOmdAEddFSzpb8F+MQ8RD6+B5LCh9eJZ6AbeBb+wfmg8/REguRE8bgG0MSNRe/R9OBtq4G6uA86fxvrX/4RlLy6Fv7//FWvpAQMGQKlUyuUzjEYjIiIiEBUVBa1Wi6amJpSVlaGkpAQNDQ1wuVzXvF9RVlaGiooKlJSUYM2aNdi/fz8GDx7clV8Li1sjLOl0OnHixAnm07okSSgvL8f58+cxZMgQ6HQ6VFRUoLy8HLGxsXC73bBYLLBarZAkCcHBwXJW3/U8GLW0tCA7Oxvh4eHo1avXNf8SlZSUYGRKKkKeeA9wu2D97F00fpcOpdofprFPwO1sRUvhNwib8SqgUKDyg8Wwm4uhjUlG2P0vw7x/Ndz2FuiHTkDdsc1QGcJhO5+J3r/bC8lph/mfK9BaUQBAQtCYR2GvOAd1aG8E3fUAnPU1sPzvGkQGAmtXrcTEiRMBtB2YzsrKQnR09DXlDnlwu92oq6uD1WrFpUuX4HK5EBQUhODgYJhMpit+USVJQn5+Pmw2G44dO4ZPPvkEu3fvvqYoWRdxa4QlPbSX/eh0OpGdnQ2VSiVnOObk5ECtVmPEiBHyjBMUFIT+/fvD4XDAarWioqICeXl50Gq1CAkJQUhIyI/Kd/CoqalBfn4+YmNjO7wp0rt3b/SJikTlsfcQEDcOTst5qANNcNuboYlOgkpnhK34NC789xNQwg2lLgjBE59CU+7xtutppi1BzcdvwPLxG1DpDAh74D9RvfMVXDr2AYLGPAx192i0VhYATif0CePg6n8nqrYuhaMyH2oF0M1Zh7T/PSIXnrJYLMjPz0dcXFyHk7U8WZEe07pcLjmtoLi4rdy4J2msvLwcGo0GW7ZsQW1tLQ4ePNjlV9t3BTd8hne5XDh58iSSkpKumDHq6uqQnZ2Nvn37IiwsDPX19T86pMEd6A/hRKvVipqaGthsNgQFBSEkJAQmk0m+/e/qNkVFRairq0N8fHynw5pmsxlPPbsY33zzDay1Degx/12Y96+Gf4+BCEp5CLYL2TDvXg6FSo2QKc9B03cYqrYuhdoQBpWhe9tO6tBJaL2Yix6z34Cr6RLMB15H6/lMKNT+6DnvHVTvXQHDnb+EPn4cHJcqcWnXMjw66z689NJLct5LWVkZKisrMXToUJ+Yz+FwwGw2o6CgACdOnMD27dvRq1cvvPfee4iOju7y1/PCNc3wN4Xhv/76a8TFxUGj0UCSJJSUlKCqqgpxcXEICAiQD2nEx8d3aKa+HM/Ps2f5o1Ao5OWPwWCQf00MBgOzxk1H+fzzzzFnyasIvP81OOtrUL3nP+GsrWpbd49fAFtZDtTGMASlPASXrRGV/1gCd6MV+hH3wpg8ExXvP43AxEnQ9klEzf5VUGq7wW23IXL+RtirilC9+49tFyHYG3DfvdPw7tsboFAo5FtUHA4HhgwZ4rPbNjxhx+DgYDz99NOYOnUqIiMjMXz48A7tnHcRt86SxrOR5Nn1CwwMRFJSEpxOJzIzM6HT6a778PbVP892ux1WqxXl5eXIzs6G3W5Hz549ERkZ2WWhufj4eLSaS6EsOgVNv+FQdesOx6UKwOVAYMJ4aPoMReWWF2CvKoS7rhLKAB0CouIASYIyQIewB1e2ldv41zYE9IhB6Iw/tpXv/qHGffCkRWhI+wv279uL0aNHQ6FQwOFwICsrCyaTqUv3I67GE3YMDAzEnDlzsHz5ckyfPt0nr9WV3HDDKxQKqNVqWCwWlJWVISYmBsHBwaitre3QIY2O4u/vj/DwcNjtdjQ1NSE2NhZNTU3Iy8tDa2ur/HAWHBzc6XBnWFgYdu/Yhkcem4PzuyqgCgxC5G//joq/L0Rr+ffQRMUheOqzsOxfDUlyI+LhNVCo1Kj8cKlcTMlpLUdAn6Ftyx1NILr/cinM+1dDctgQqNPgL2vXQKVS4dtvv4Ver4fZbEb//v0RERHRxZ/Y/+MJO7pcLsyfPx+bNm3CyJEjffZ6XckNX9I4nU588cUXkCQJiYmJ8PPzQ2lpKaxWK+Lj4312SMBTVtvPzw+DBg264tfD7XajtrYWFosFly5dgkKhkB9+20sm49HS0oKsrCwcO3YMGw58Cd2Ep9FSdAo1H62D0hgGt7UcQT9/HA3fpcOU+hto+w1Ha2UhzHuXAy4HjGNmI6DnQFTteAXdf7UMfqF90Hh8M+KNDny8f6/8z1hZWYlz585Br9ejtbUVgYGB8pKts/H09igrK0N1dTXKy8uxZs0a7Nq1C/379++y/q+DW2NJ09TUBKVSifDwcLjdbpw5cwZGoxFJSUk+y7fw5JCwHoCVSqU8uwNtyx+LxYILFy6gvr7+ms3kyb8ZMmQI3G431v71vxHQdAna6DsQEBWPloKv2m7ITvoFVIEmWD7+C7qNuBfNeV9AFWgClCootd3gHxaNkEmLYN63CrA3Ydz4iXj/3U2y2cvLy3HxeETWcgAAE0dJREFU4kUkJycjICBAvpDAc6Fza2srjEaj/J7ae2D3xuVhx4yMDOzbtw+HDx+WD4jcKtxwwx85cgRlZWWyeUJDQ6HX6+Wzj11NRUUFSktL2901ZeHv739FMpnHTLm5ufIpKk/0R61Wy3Xva2pqkJSUhICAAIwaNQpPL5iHN958CuoAHeytDkQ8ug7VO1+Bq6VBTjG49PkmSM5WRC3agpaiDNQe2wyV1gBFgA46rRYb/rYeM2fOBNBmQs8dS5ef4rr8QoI+ffpc8cB+/vx5eb8iODgYQUFBXj9nl8uFnJwcBAQEYOfOnSgrK0N6enqX/nL8VNzwJU1paSkWLFiAnJwc9OjRA2PHjkVycrL8RVy+kXQ9D2CeXVNP5KKr0hBcLhdqa2thtVphtVrlU1w6nQ7x8fE/ipBUVFRg+fLXcKDQAWPKQ7h0dDOa87+EJioezXnHYRg1C7X/2oqoRVug0ujRcCYd9Se3ITTIgD+8tBSzH30UQNuSLCsrCwaDAdHR0R36bDzH9Dz5//7+/vLnrNfrr+jLs0NrMpnw2muvISoqCq+//voNu2eVw60RlgSAU6dOYfjw4bDb7Th+/DjS0tJw/PhxREREYMqUKfIa23O0LCQkpENx5c7umnaUlpYWefvec9NdYGCgvP73PI9s3LgRy9/Zhm6/fBkKhRJVO/8A+4Uc+HXvg4hH18F6+B3Yq4thSL4frqoiKPI/x+l/fyXH11taWpCZmYk+ffp0ycOpzWaTw7WNjY3ymHU6Hc6ePYvQ0FA8++yzuO+++/DMM8/c0GxHDreO4dt9oR9ybNLT03Ho0CHk5+dj7NixSElJkb94z6zE+1m+nl3TjnD5et2Tsem53c5jJrvdDpPJBL1ej/945DEUVdfBJUloqqmEIXkmmr4/gojZbwCSG3Vf7kRDxn5M/8UUrFqxHL179wbQdq1PXl7eFa/TlXjG7Hku2LhxI7KysjBr1iysWLHiJ78qvgPc2oa/GofDgZMnTyI9PR1HjhyBTqfDtGnTEBcXB7VaLacRhIaGQqvVQpIkFBYWor6+/rp2Tb3h+cc0m81ISEjg/vJ4lj8WiwVmsxmnT5/Ghzt2ozx8NPRx96By61KogyKg6T0UrrNHcN89d+Fvf31Tbn/x4kW5nIkvS1x4wo6SJGHx4sWYN28ezGYzXnrppZsyXeAHbi/DX47njtdDhw7h0KFDyMzMxOjRo5GamooePXrAbrdDkiSYTCbExsb6LG3Y5XLh+++/h1qt/lFo81pobW3F/CefwqcXAGPKw3DbW1Dz0TroG8uxbOnvMG/uXPkGk4KCAjQ3N7f7XNCVeMKOVVVVWLlyJXbs2IGBAwf67PW6kNvX8Ffjcrlw6tQppKWlYc+ePaipqcHChQuRlJQEjUYDPz8/ee3fVYccPPH1yMjIK24I7CiFhYUYkzoWiv53A+oA2LM/wdrVf5LP43oSs7p169ZlKQ/tcXXYcceOHdizZ49PNv18hDiGv5xXX30VM2bMQF5eHtLT05GRkSGfSurduzfcbjeMRqN8KLszMWmr1YqzZ8922XNBaWkpPvzwQzicTsycMQNxcXFwuVxyJS+lUikfJG8vknK9eMKOGo0GO3bsQG5uLrZu3drpvKUbhJiGvxq3243s7GykpaXh0KFDaGhowNSpUzFixAjo9XoolUp57d+tWzeukTzr9erqap9lIHqora1Fbm6u/E9ls9nkzE9P5V3PP+31jMNut8sJYKtWrYLRaMSbb77ps2WgDyHDt0dDQwOOHDmCtLQ0nDx5EjExMZg0aZK8Pe4xUkhIyBUPui6XC7m5uVCpVJ1ar3eEiooKlJWVISEhod3NHUmS0NDQAIvFAovFApfLdcVG0rWu8T3ZjmFhYXjuuecwadIkPP/88zdr2NEbZHhveHYqPbN/ZWUlJkyYgLvuugtBQUFyCrFer0dpaSkiIyMRFRXl0/EUFhaisbGxQxe2eQpJWSwWeSPJ80/LembxZDuaTCYsWLAAS5YswYMPPnirmh0gw3eclpaWH218jRw5EqGhoRg4cKA8+4eGhnZ5WNDlcsk3nsTExFyX8VpaWmC1WmGxWNDU1ASDwSDvWfj7+8thR5VKhUWLFuGtt95Campq172ZGwMZ/nqQJAmbN2/Gn//8ZwwZMgSFhYW45557kJKSgrCwMLjdbphMJoSGhnZoGdEeNpsNmZmZiIqKuqIESFcgSRLq6+vlza+WlhYUFxejpqYGO3fuxPbt2zFkyJAufc0bxK2RLXmzolAo8MADD+Chhx5CQEAA7HZ7uxtfnqWHRqO54vzstc7QnqXFtZYF7Mz7MBqN8qkutVqNqqoqbNu2DWq1GsXFxbeL4a8JmuE7gWfjy5P2kJWVhVGjRuGee+5BZGSkfLrfE0VhrcUrKyvlSse+zDy8POy4d+9eZGRkYOfOndDr9XC73Tes7F0XQ0uanwqXy4WMjAykpaXh8OHDcLvdmD59OoYNGyZvfF0eQweAoqIi1NfXIyEhwachQE/YMSQkBOvWrYNSqcTbb7/dqf2Hmxwy/I1AkiRYrVYcPnxY3vhKTEzEhAkT0LdvXzgcDjgcDhiNRsTFxfk0GcsTdoyIiMCSJUuQkpKCZcuW3S4z+tWQ4W8GPLcFpqWl4cCBAyguLsYjjzyCn/3sZ/LGV1fl/F+O59kgNDQU8+fPx8KFCzF79uxbOezoDXpovRlQKpVITExEYmIi9Ho9oqOj4XA48PHHH8sbX5MnT0ZMTAwkSep0zv/lVFdXo6ioCFqtFrNnz8batWsxYcKELn5ntyY0w99Art74unjxIiZOnIjRo0fDZDJdUTrwWo7iAW3ZjlVVVWhqasKLL76If/zjH0hMTPwJ3s0Nh5Y0txqXb3ydOHEC4eHhmDp1KgYPHgyFQvGjnP/LuTzb8ezZs9iwYQP27t3r053hmwwy/K2M5yC4J/RZUFCA1NRUjBkzRt748oQ+jUYj8vLyoNFocPDgQRw9ehQ7d+706QmvmxAy/O3E1RtfWq0W06dPx4ABA9DS0oKMjAycOXMGWq0Wu3btuplPJvkKMvztiiRJqKysxJYtW7B69WrExMSgvr4egwYNglqtxgsvvIA777zzRg/zp4YMf7vjOY43bNgwHDp0CFOmTLmdw47eIMMTQnFNhr8tt9wIggUZnhAKMjwhFGR4QijI8IRQkOEJoSDDE0LR0fRgYXc1iNsDmuEJoSDDE0JBhieEggxPCAUZnhAKMjwhFGR4QijI8IRQkOEJoSDDE0JBhieEggxPCAUZnhAKMjwhFGR4QijI8IRQkOEJoSDDE0JBhieEggxPCAUZnhAKMjwhFGR4QijI8IRQkOEJoSDDE0JBhieEwmdXzyv8QiVo+rYvmjgNA711zNGaOVotR6vjvSCvIcCdMwIMbC2GLfXX5DO1oPP13NFcMrO1Vk67CJ4TBrOl/ID+3PHUl3Huiq12clp+VyNJUndu553AZ4aHpi8wLKN9bSan3Sgv/fJGfIaj7eNoH/Fe8AB3OICWLfWawNb2sKV1gyYxtV8u+oQ7mj0b2FoBp93SYI7I+Qim9lvDHU/a4vvZ4noLp2VoKbfjTkJLGkIoyPCEUJDhCaEgwxNCQYYnhMJnURrVIAeMR8vb1Z5RvcVsl4qj3H7t8GdqB++YytTWT17M7vQ5DVvbfTd3PMBptsSLunGinWXoxRZ/zh/NjH9xRBtHW8SWdvWbxtTSytmfOQDgC57Iixv5BprhCaEgwxNCQYYnhIIMTwgFGZ4QCjI8IRQ+C0tGowhvqR5uV5u84Ri74S4vHfdkSxNWsmNgrf0CmNrb05awO90Xwh+P08rWSjjtOAlrf0teyNR0s3gpocC4WZ8yNTvYn8E/cR9TW+16kf2CL3NCugCQwRtvJr+tD6AZnhAKMjwhFGR4QijI8IRQkOEJoSDDE0JBhieEwmdxeENDIyZ/3n683fIsu90mF7/fVI6WnMzWBj17li2Gcjr1EmZGI0/8mi29wx5sri2Jqc2duZU7HM1g9r6ArVHHbvgp541u4bzgp/x9ASCNo7W/T9PGfC/9dg6a4QmhIMMTQkGGJ4SCDE8IBRmeEAoyPCEUvqstKYF5aj/YyG42lJNtCwDJnAP94BQY+BbD2GIep09u2BEAeMVNOSUEalrY2tqRbG0TJ7QIwBbEKRLJey81Ekf8N0e7wB0PMIMtPc9pttZLt52EZnhCKMjwhFCQ4QmhIMMTQkGGJ4SCDE8Ihc/Ckg0GHY5NjG9X+/k2dphrSrGXjjm1O//c6zmm9kHOk+yG23kveMrLgHhx1EiOxglL8sKZtfw7nlDLq+Dq4Ghe4sFMHufLv2VL8a9/w9SyKSxJENcPGZ4QCjI8IRRkeEIoyPCEUJDhCaHwWViyBP3wGD5oVxsz8QSznY57fzyQgTuY2ulDKeyGK3id8jL+2r+n6v+Zx5ZCOYVY+3K65H0r3pITL/BCj7wLoHjvM5YtRRj443mELS3GG0xtLr/XTkMzPCEUZHhCKMjwhFCQ4QmhIMMTQkGGJ4TCZ2FJe74GpVMGt6uVDm7/79cE78D1UY5m490nxMlADLqXPx5ONiAvkXDAoO+YmovztRTlxPHHs8mPo6WyNe5hdY5NovjD8RvM/mz7o5Df2AfQDE8IBRmeEAoyPCEUZHhCKMjwhFCQ4QmhIMMTQuG7Yqr1zUA648R/OqfgJ6sCq0wVRyvgaOFsKWgKW/Nyen7a3F1MbSlWMbWUi6eZWlMIex7aEfdr7nheeoOdB13ZGM1uuIlTwJVbFJY7HDjy2OnDJ+4ew2nJK+DaeWiGJ4SCDE8IBRmeEAoyPCEUZHhCKMjwhFD4LiwJDdin3Us47bK89MsLPWo52nS29CBbumvu59zRvIffMLXuD7Bzbi172X2GJLiZ2m/+uo07nqy7E5ja+pTfsxtu5twd5eSEgkt4d0MB2KxgSivjl3EaruP320lohieEggxPCAUZnhAKMjwhFGR4QijI8IRQ+C4sGaUEnmOEuo4OYbf7iKMBAA5zNF4mJaewKacG6zh8yh1N983s0GMmO5ESnKgk7j/D1obmc4cD/d0NbJH3bXtLUmXC/3ywaQJTslXysmZ9A83whFCQ4QmhIMMTQkGGJ4SCDE8IBRmeEAqfhSW7h1fi179b0662aR77XiTb815CVZvGc8QP2VInQ3KN6MYfzwC2NHQYW4vkJIWG3M/WzI/rucP5DJzP5wteSwtHq+ZopdzxcK+0/4id2ekraIYnhIIMTwgFGZ4QCjI8IRRkeEIoyPCEUPgsLNm7uRz/lbG0XS18BDvM9crjXoo5fso+FIwSTv1IJ+dK+y/YB5i3P8av5ZhwNzu++OuvdjC1EAv7oPYXPZOY2mq8yB3Pl38fyxa381ryajnyQsUx3PFwa3r6soYAA5rhCaEgwxNCQYYnhIIMTwgFGZ4QCjI8IRRkeEIoFJLkpRhmJxkRqpAyGPVLj73Pvk9ogoVXlQBwTGbfGYQMXv4rJwdYn8rW2JnMXvXouBympuKMJ/9sIrvTzV7G8w5Hq+V9PpzPVTOUraV6Gc9gLzqL9YpTkiSN6GRrJjTDE0JBhieEggxPCAUZnhAKMjwhFGR4Qih8l5/JueKpEP2ZzXhXlQMALvBEzgl55LIldj1UYP3d/PHs9mNKRVFx7Ha84qUlHK2GV10A4F4TD3baMVKi2NrLnB4ncUshYAROMbVmsNOyt6zndttpaIYnhIIMTwgFGZ4QCjI8IRRkeEIoyPCEUPgsLNkUocVXLwxsV3sDi9kNt3jpuLKeI5ZwNN619LxYJ+82JgAXOB/hBV6IlReX5IUey/nj4RVTHcEJPXKyLP8Ux/6+fl/mJX54kKP1Y0vebNBZaIYnhIIMTwgFGZ4QCjI8IRRkeEIoyPCEUPgsLJkvDcDk1vR2tbqXI9gNeYeQAfCvnk/maOyD4wjlFGjlX6kE1PI0TgFXbvFS3p1K3q5rv4MtPciWHot7m6n9PoMTeuTcRwUAaWVsbfJPf/M8zfCEWJDhCaEgwxNCQYYnhIIMTwgFGZ4QCp+FJV25fqgbxQg/nuGF69K89DyFLY1nHwrGI5wux9uYkkbPGytgy+PE1nZzxrM5la3V8DI7S7jj4YZROXUeh+MMW+ScC/+aE3YEgEyONrKO39YX0AxPCAUZnhAKMjwhFGR4QijI8IRQkOEJoSDDE0Lhu2KqLfXAGVYqbwmn4cP8fh9nx7aDN7FP9C9VrWJqv8I+puaPVu5wPktmVwlYm/w8U8vVcAqbruClOZdwxwP2lgJQw5bOYhBbvJctJX/NH07yRY44i6Mt4vfbWWiGJ4SCDE8IBRmeEAoyPCEUZHhCKMjwhFD4LiyJRrDzSjkpviM4KbUAsIIdd3tH9VumNmvDR+w+/8p5PQ1/OL9Zto2pNc9iv5enp21id8qrJFri5ai/k1OI9aMQpvT2+IVMLaAfOzQ7dSuvWirgDztTO8q7t37RGm6/nYVmeEIoyPCEUJDhCaEgwxNCQYYnhIIMTwiFQpIk33SsUJgBlPqkc0IE+kiS1L2rO/WZ4QniZoSWNIRQkOEJoSDDE0JBhieEggxPCAUZnhAKMjwhFGR4QijI8IRQ/B+CWaMfcTcjRQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\"\"\"\n", - " Figure 6 (Tilted planes)\n", - "\"\"\"\n", - "fig = plt.figure(figsize=(3,9))\n", - "\n", - "ax = fig.add_subplot(3,1,1, projection='3d')\n", - "ax.set_xticklabels([])\n", - "ax.set_yticklabels([])\n", - "ax.set_zticklabels([])\n", - "ax.voxels(voxels, edgecolor='k')\n", - "\n", - "ax = fig.add_subplot(3,1,2, projection='3d')\n", - "ax.set_xlim(-1,1)\n", - "ax.set_ylim(-1,1)\n", - "ax.set_zlim(-1,1)\n", - "ax.set_xticklabels([])\n", - "ax.set_yticklabels([])\n", - "ax.set_zticklabels([])\n", - "ax.scatter(X_[:,0],X_[:,1],X_[:,2], edgecolor='k', alpha=1, c=\"C0\")\n", - "\n", - "ax = fig.add_subplot(3,1,3)\n", - "ax.set_xticks([])\n", - "ax.set_yticks([])\n", - "ax.imshow(img, cmap=\"jet\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.10" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/experiments/jupyter notebooks/smoothly-varying-dimension.ipynb b/experiments/jupyter notebooks/smoothly-varying-dimension.ipynb deleted file mode 100644 index 62cdddf..0000000 --- a/experiments/jupyter notebooks/smoothly-varying-dimension.ipynb +++ /dev/null @@ -1,167 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "from scipy.stats import skewnorm\n", - "from scipy.stats import norm\n", - "\n", - "import numpy as np\n", - "import pickle\n", - "\n", - "import sys\n", - "sys.path.append(\"../\")\n", - "\n", - "from utils import gather_data\n", - "\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - " Load the ND data, \n", - " which we want to analyze\n", - "\"\"\" \n", - "\n", - "# Point this path to your data\n", - "\n", - "path = \"../data/smooth_k_filtered/20190728-185653-236bf935-b1a4-11e9-8919-acde48001122/out\"\n", - "W = gather_data(path, \"width\")\n", - "\n", - "W = W[0,:,:,:]\n", - "log_mean = np.mean(np.log(W), axis=2).T\n", - "log_std = np.std(np.log(W), axis=2).T" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "ms = np.array([5], dtype=\"int\")\n", - "ks = np.concatenate(\n", - " [[2.0],\n", - " (2 + (2**(np.arange(0, 13.5, 0.5)) / 10000)),\n", - " [3.0],\n", - " (3 + (2**(np.arange(0, 13.5, 0.5)) / 10000)),\n", - " [4.0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.0 2.0001 2.00014142136 2.0002 2.00028284271 2.0004 2.00056568542 2.0008 2.00113137085 2.0016 2.0022627417 2.0032 2.0045254834 2.0064 2.0090509668 2.0128 2.0181019336 2.0256 2.0362038672 2.0512 2.07240773439 2.1024 2.14481546879 2.2048 2.28963093757 2.4096 2.57926187515 2.8192 3.0 3.0001 3.00014142136 3.0002 3.00028284271 3.0004 3.00056568542 3.0008 3.00113137085 3.0016 3.0022627417 3.0032 3.0045254834 3.0064 3.0090509668 3.0128 3.0181019336 3.0256 3.0362038672 3.0512 3.07240773439 3.1024 3.14481546879 3.2048 3.28963093757 3.4096 3.57926187515 3.8192 4.0\n" - ] - } - ], - "source": [ - "# Use this output in the .sh file\n", - "print(' '.join(\"{}\".format(x) for x in ks))" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/anaconda3/envs/py2/lib/python2.7/site-packages/matplotlib/figure.py:2299: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " warnings.warn(\"This figure includes Axes that are not compatible \"\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.rc(\"font\",**{\"family\": \"sans-serif\",\"sans-serif\": [\"Arial\"],\"size\": 8})\n", - "\n", - "fig, axes = plt.subplots(figsize=(8., 1.55), ncols=len(ms), sharey=False, tight_layout = {\"pad\": 0})\n", - "\n", - "\n", - "(axes \n", - " if len(ms) == 1\n", - " else axes[0]).set_ylabel(\"Capacity\")\n", - "\n", - "for i in range(len(ms)):\n", - " if len(ms) == 1:\n", - " ax = axes\n", - " else:\n", - " ax = axes[i]\n", - "\n", - " ax.set_title(\"M = {}\".format(ms[i]))\n", - " ax.spines['right'].set_visible(False)\n", - " ax.spines['top'].set_visible(False)\n", - " ax.set_xlabel(\"N\")\n", - " ax.set_yscale(\"log\")\n", - "\n", - " ax.set_xlim(ks[0] - 0.5, ks[-1] + 0.5)\n", - "\n", - " m = ms[i]\n", - " m_ = i\n", - " \n", - " valid = np.where(ks/2 <= m)[0] \n", - " a = np.exp(log_mean - 1*log_std)[valid,m_]\n", - " b = np.exp(log_mean)[valid,m_]\n", - " c = np.exp(log_mean + 1*log_std)[valid,m_]\n", - " \n", - " ax.plot([ks[valid],ks[valid]] ,[a,c], linewidth=1.,color=\"black\",linestyle=\"-\", alpha=1.)\n", - " ax.plot(ks[valid], b, marker=\"s\", color=\"black\", markerfacecolor= \"white\",markersize=4,linewidth=1., linestyle=\"none\")\n", - " \n", - "\n", - "plt.savefig(\"../Figures/Smooth_Varying_Dimension.pdf\", dpi=300, transparent=False)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/experiments/jupyter notebooks/visualize-lattice-points.ipynb b/experiments/jupyter notebooks/visualize-lattice-points.ipynb deleted file mode 100644 index 64ef6e2..0000000 --- a/experiments/jupyter notebooks/visualize-lattice-points.ipynb +++ /dev/null @@ -1,2882 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import itertools\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.patches import Circle\n", - "\n", - "%config InlineBackend.figure_format = 'svg'" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def getHyperrectangleEdges(sideLengths):\n", - " edges = []\n", - "\n", - " for edgeDimension in xrange(len(sideLengths)):\n", - " for otherCoordinates in itertools.product(*[[0, sideLength]\n", - " for otherDimension, sideLength \n", - " in enumerate(sideLengths)\n", - " if otherDimension != edgeDimension]):\n", - " \n", - " start = list(otherCoordinates)\n", - " start.insert(edgeDimension, 0)\n", - " end = list(start)\n", - " end[edgeDimension] = sideLengths[edgeDimension]\n", - " edges.append((tuple(start), tuple(end)))\n", - " \n", - " return edges\n", - "\n", - "def printSteps(steps, A, L, phr, zoomOut=False):\n", - " numModules = len(A)\n", - " fig, axes = plt.subplots(numModules, len(steps), figsize=(len(steps)*6,numModules*5))\n", - " for t, (x0, dims) in enumerate(steps):\n", - " vertices = x0 + np.array(list(itertools.product(*[[0, dim]\n", - " for dim in dims])), dtype=\"float\")\n", - "\n", - " edges = x0 + np.array(getHyperrectangleEdges(dims))\n", - "\n", - " for iModule, (P, L) in enumerate(zip(A, L)):\n", - " if len(steps) == 1:\n", - " ax = axes[iModule]\n", - " else:\n", - " ax = axes[iModule, t]\n", - "\n", - " verticesOnPlane = np.matmul(P, vertices.T)\n", - "\n", - " bottomLeft = np.min(verticesOnPlane, axis=1) - phr/2\n", - " topRight = np.max(verticesOnPlane, axis=1) + phr/2\n", - "\n", - " boundingPoints = np.array([bottomLeft,\n", - " [bottomLeft[0], topRight[1]],\n", - " [topRight[0], bottomLeft[1]],\n", - " topRight]).T\n", - "\n", - " boundingPointsInLatticeBasis = np.matmul(np.linalg.inv(L), boundingPoints)\n", - " bottomLeftInLattice = np.ceil(np.min(boundingPointsInLatticeBasis, axis=1)).astype('int')\n", - " topRightInLattice = np.floor(np.max(boundingPointsInLatticeBasis, axis=1)).astype('int')\n", - "\n", - " planePoints = np.array([np.matmul(L, [latticePointX, latticePointY])\n", - " for latticePointX in xrange(bottomLeftInLattice[0], topRightInLattice[0] + 1)\n", - " for latticePointY in xrange(bottomLeftInLattice[1], topRightInLattice[1] + 1)])\n", - "\n", - " for px, py in planePoints:\n", - " circle = Circle((px, py), phr/2, facecolor='none',\n", - " edgecolor=(0, 0.8, 0.8), linewidth=3, alpha=0.5)\n", - " ax.add_patch(circle)\n", - "\n", - " for vertex1, vertex2 in edges:\n", - " v1 = np.matmul(P, vertex1)\n", - " v2 = np.matmul(P, vertex2)\n", - "\n", - " ax.plot([v1[0], v2[0]], [v1[1], v2[1]], 'k-', lw=1)\n", - "\n", - " ax.set_aspect(1.0)\n", - "\n", - " if not zoomOut:\n", - " xlim = np.array([verticesOnPlane.min(axis=1)[0], verticesOnPlane.max(axis=1)[0]])\n", - " w = verticesOnPlane.max(axis=1)[0] - verticesOnPlane.min(axis=1)[0]\n", - " xlim[0] -= w\n", - " xlim[1] += w\n", - "\n", - " ylim = [verticesOnPlane.min(axis=1)[1], verticesOnPlane.max(axis=1)[1]]\n", - " ylim[0] -= w\n", - " ylim[1] += w\n", - "\n", - " ax.set_xlim(xlim)\n", - " ax.set_ylim(ylim)\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "A = np.array([[[0.3219036345786383, -0.5715108200503918],[0.38397448074511314, 0.10075272793446001]], [[0.015710240766668767, -0.029339426539530814], [0.652071115450514, 0.23298983628080752]], [[-0.29021547130167635, -0.22604087057591798], [0.08669276235211387, 0.41127392987271916]], [[-0.2474131962195408, 0.2213900803989286], [0.22065694234010563, -0.21296441800663152]]], dtype=\"float\")\n", - "L = np.array([[[1.0, 0.5000000000000001], [0.0, 0.8660254037844386]], [[1.0, 0.5000000000000001], [0.0, 0.8660254037844386]], [[1.0, 0.5000000000000001], [0.0, 0.8660254037844386]], [[1.0, 0.5000000000000001], [0.0, 0.8660254037844386]]], dtype=\"float\")\n", - "phr = 0.2\n", - "exampleSteps = [[[57.196, 80.0824],[0.577738, 0.800824]],\n", - " ]" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "printSteps(exampleSteps, A, L, phr, zoomOut=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "printSteps(exampleSteps, A, L, phr, zoomOut=True)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.12" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}