Calcium_Cartography_2021_Figure_2_E.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Obtain all necessary imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "from IPython import get_ipython;   \n",
    "get_ipython().magic('reset -sf')\n",
    "\n",
    "import numpy as np\n",
    "import random\n",
    "import math\n",
    "import os\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import scipy\n",
    "import pandas as pd\n",
    "\n",
    "from numpy import dot, multiply, diag, power\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from matplotlib import colors\n",
    "from matplotlib import animation\n",
    "from IPython.display import display, HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create the pouch class and pouch operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pouch(object): \n",
    "    def __init__(self, params=None, size = 'xsmall', sim_number=0, save=False, saveName='default'):\n",
    "        \n",
    "        \"\"\"Class implementing pouch structure and simulating Calcium signaling.\n",
    "        Inputs:\n",
    "        \n",
    "        params (dict)\n",
    "            A Python dictionary of parameters to simulate with the keys:\n",
    "            ['K_PLC', 'K_5', 'k_1' , 'k_a', 'k_p', 'k_2', 'V_SERCA', 'K_SERCA', 'c_tot', 'beta', 'k_i', 'D_p', 'tau_max', 'k_tau', 'lower', 'upper','frac', 'D_c_ratio']\n",
    "        \n",
    "        size (string)\n",
    "            Size of the pouch to simulate:\n",
    "            [xsmall, small, medium, or large]\n",
    "        \n",
    "        sim_number (integer)\n",
    "            Represents ID of a simulation to save the figures with unique names and set the random number generator seed\n",
    "        \n",
    "        save (boolean)\n",
    "            If True, the simulation outputs will be saved\n",
    "        \n",
    "        saveName (string)\n",
    "            Additional distinct name to save the output files as\n",
    "        \n",
    "        \"\"\"\n",
    "        # Create characteristics of the pouch object\n",
    "        self.size=size\n",
    "        self.saveName=saveName\n",
    "        self.sim_number=sim_number\n",
    "        self.save=save\n",
    "        self.param_dict=params\n",
    "        \n",
    "        # If parameters are not set, then use baseline values\n",
    "        if self.param_dict==None:\n",
    "            self.param_dict={'K_PLC': 0.2, 'K_5':0.66, 'k_1':1.11 , 'k_a': 0.08, 'k_p':0.13, 'k_2':0.0203, 'V_SERCA':0.9, 'K_SERCA':0.1,\n",
    "            'c_tot':2, 'beta':.185, 'k_i':0.4, 'D_p':0.005, 'tau_max':800, 'k_tau':1.5, 'lower':0.5, 'upper':0.7, 'frac':0.007680491551459293, 'D_c_ratio':0.1}\n",
    "        \n",
    "        # If a dictionary is given, assure all parameters are provided\n",
    "        if sorted([r for r in self.param_dict])!=['D_c_ratio','D_p','K_5','K_PLC','K_SERCA','V_SERCA','beta','c_tot','frac','k_1','k_2','k_a', 'k_i','k_p','k_tau','lower','tau_max','upper']:\n",
    "            print(\"Improper parameter input, please assure all parameters are specified\")\n",
    "            return\n",
    "            \n",
    "        # Load statics for wing disc geometries    \n",
    "        disc_vertices=np.load(\"./geometry/disc_vertices.npy\",allow_pickle=True).item() # Vertices\n",
    "        disc_laplacians=np.load(\"./geometry/disc_sizes_laplacian.npy\",allow_pickle=True).item() # Laplacian Matrix\n",
    "        disc_adjs=np.load(\"./geometry/disc_sizes_adj.npy\",allow_pickle=True).item() # Adjacency matrix\n",
    "        \n",
    "        self.adj_matrix=disc_adjs[self.size] # Adjacency Matrix\n",
    "        self.laplacian_matrix=disc_laplacians[size] # Laplacian Matrix\n",
    "        self.new_vertices=disc_vertices[size] # Vertices\n",
    "        \n",
    "        # Establish characteristics of the pouch for simulations\n",
    "        self.n_cells=self.adj_matrix.shape[0] # Number of cells in the pouch\n",
    "        self.dt=.2 # Time step for ODE approximations\n",
    "        self.T=int(3600/self.dt) # Simulation to run for 3600 seconds (1 hour) \n",
    "        \n",
    "        # Establish baseline parameter values for the simulation\n",
    "        self.K_PLC=self.param_dict['K_PLC']  # .2\n",
    "        self.K_5=self.param_dict['K_5'] # 0.66\n",
    "        self.k_1=self.param_dict['k_1'] # 1.11\n",
    "        self.k_a=self.param_dict['k_a'] # 0.08\n",
    "        self.k_p=self.param_dict['k_p'] # 0.13\n",
    "        self.k_2=self.param_dict['k_2'] # 0.0203\n",
    "        self.V_SERCA=self.param_dict['V_SERCA'] # .9\n",
    "        self.K_SERCA=self.param_dict['K_SERCA'] # .1\n",
    "        self.c_tot=self.param_dict['c_tot'] # 2\n",
    "        self.beta=self.param_dict['beta'] # .185\n",
    "        self.k_i=self.param_dict['k_i'] # 0.4\n",
    "        self.D_p =self.param_dict['D_p'] # 0.005\n",
    "        self.D_c =self.param_dict['D_c_ratio']*self.D_p\n",
    "        self.tau_max=self.param_dict['tau_max'] # 800\n",
    "        self.k_tau=self.param_dict['k_tau'] # 1.5\n",
    "        self.lower=self.param_dict['lower'] # Lower bound of standby cell VPLCs\n",
    "        self.upper=self.param_dict['upper'] # Upper bound of standy cell VPLCs\n",
    "        self.frac=self.param_dict['frac']   # Fraction of initiator cells\n",
    "\n",
    "        self.disc_dynamics=np.zeros((self.n_cells,4,self.T)) # Initialize disc_dynamics to save simulation calcium, IP3, calcium_ER, ratio\n",
    "        self.VPLC_state=np.zeros((self.n_cells,1)) # Initialize VPLC array for cells\n",
    "    \n",
    "    def simulate(self): # Simulate dynamics of system\n",
    "            np.random.seed(self.sim_number) # Set the seed for reproducibility (keep initiator cells consistent each run)\n",
    "            \n",
    "            self.disc_dynamics[:,2,0] = (self.c_tot-self.disc_dynamics[:,0,0])/self.beta # Initialize simulation ER Calcium\n",
    "            self.disc_dynamics[:,3,0]=np.random.uniform(.5,.7,size=(self.n_cells,1)).T # Initialize simulation fraction of inactivated IP3R receptors\n",
    "            self.VPLC_state=np.random.uniform(self.lower,self.upper,(self.n_cells,1)) # Initialize the values for VPLCs of standby cells to be random uniformly distributed from lower to upper\n",
    "            stimulated_cell_idxs=np.random.choice(self.n_cells, int(self.frac*self.n_cells)) # Choose which cells are initiator cells\n",
    "            self.VPLC_state[stimulated_cell_idxs,0]=np.random.uniform(1.4,1.5,len(stimulated_cell_idxs)) # Set the VPLC of initiator cells to be random uniformly distributed between 1.3 and 1.5\n",
    "            \n",
    "            V_PLC=self.VPLC_state.reshape((self.n_cells,1)) # Establish the VPLCs to be passed into the ODE approximations\n",
    "            \n",
    "            # ODE approximation solving\n",
    "            for step in range(1,self.T):\n",
    "                # ARRAY REFORMATTING\n",
    "                ca=self.disc_dynamics[:,0,step-1].reshape(-1,1)\n",
    "                ipt=self.disc_dynamics[:,1,step-1].reshape(-1,1)\n",
    "                s=self.disc_dynamics[:,2,step-1].reshape(-1,1)\n",
    "                r=self.disc_dynamics[:,3,step-1].reshape(-1,1)\n",
    "                ca_laplacian=self.D_c*np.dot(self.laplacian_matrix,ca)\n",
    "                ipt_laplacian=self.D_p*np.dot(self.laplacian_matrix,ipt)\n",
    "                \n",
    "                # ODE EQUATIONS\n",
    "                self.disc_dynamics[:,0,step]=(ca+self.dt*(ca_laplacian+(self.k_1*(np.divide(np.divide(r*np.multiply(ca,ipt),(self.k_a+ca)),(self.k_p+ipt)))**3 +self.k_2)*(s-ca)-self.V_SERCA*(ca**2)/(ca**2+self.K_SERCA**2))).T\n",
    "                self.disc_dynamics[:,1,step]=(ipt+self.dt*(ipt_laplacian+np.multiply(V_PLC,np.divide(ca**2,(ca**2+self.K_PLC**2)))-self.K_5*ipt)).T\n",
    "                self.disc_dynamics[:,2,step]=((self.c_tot-ca)/self.beta).T\n",
    "                self.disc_dynamics[:,3,step]=(r+self.dt*((self.k_tau**4+ca**4)/(self.tau_max*self.k_tau**4))*((1-r*(self.k_i+ca)/self.k_i))).T\n",
    "            \n",
    "    def make_animation(self, path=None): # Creation of calcium video\n",
    "        colormap = plt.cm.Greens\n",
    "        normalize = matplotlib.colors.Normalize(vmin=np.min(self.disc_dynamics[:,0,:]), vmax=max(np.max(self.disc_dynamics[:,0,:]),1))\n",
    "        with sns.axes_style(\"white\"):\n",
    "                fig=plt.figure(figsize=(25,15))\n",
    "                fig.patch.set_alpha(0.)\n",
    "                ax = fig.add_subplot(1,1,1)\n",
    "                ax.axis('off')\n",
    "                sm = plt.cm.ScalarMappable(cmap=colormap, norm=normalize)\n",
    "                sm._A = []\n",
    "                cbar=fig.colorbar(sm, ax=ax)\n",
    "                cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=15,fontweight=\"bold\")\n",
    "                for cell in self.new_vertices:\n",
    "                    ax.plot(cell[:,0],cell[:,1], linewidth=0.0, color='w', alpha = 0.0)\n",
    "                patches = [matplotlib.patches.Polygon(verts) for verts in self.new_vertices ]\n",
    "                def time_stamp_gen(n):\n",
    "                    j=0\n",
    "                    while j < n: # 0.2 sec interval to 1 hour time lapse\n",
    "                        yield \"Elapsed time: \"+'{0:02.0f}:{1:02.0f}'.format(*divmod(j*self.dt , 60))\n",
    "                        j+= 50\n",
    "                time_stamps=time_stamp_gen(self.T)\n",
    "                def init():\n",
    "                    return [ax.add_patch(p) for p in patches]\n",
    "\n",
    "                def animate(frame,time_stamps):\n",
    "                    for j in range(len(patches)):\n",
    "                        c=colors.to_hex(colormap(normalize(frame[j])), keep_alpha=False)\n",
    "                        patches[j].set_facecolor(c)\n",
    "                    ax.set_title( next(time_stamps) ,fontsize=50, fontweight=\"bold\")\n",
    "                    return patches\n",
    "\n",
    "                anim = animation.FuncAnimation(fig, animate, \n",
    "                                               init_func=init, \n",
    "                                               frames=self.disc_dynamics[:,0,::50].T, # Disc dynamics: Array of: [n cells x 4 x time-samples]\n",
    "                                               fargs=(time_stamps,),\n",
    "                                               interval=70,\n",
    "                                               blit=True)\n",
    "        if self.save:\n",
    "            if path!=None:\n",
    "                if not os.path.exists(path):\n",
    "                    os.makedirs(path)\n",
    "                anim.save(path+\"/\"+self.size+'Disc_'+str(self.sim_number)+'_'+self.saveName+'.mp4')\n",
    "            else:\n",
    "                print(\"Provide a path for saving videos\")\n",
    "        \n",
    "    def draw_profile(self, path=None): # Draw the VPLC Profile for the simulation\n",
    "        colormap = plt.cm.Blues\n",
    "        normalize = matplotlib.colors.Normalize(vmin=.0, vmax=1.5)\n",
    "        with sns.axes_style(\"white\"):\n",
    "                fig=plt.figure(figsize=(45,25))\n",
    "                ax = fig.add_subplot(1,1,1)\n",
    "                ax.axis('off')\n",
    "                fig.patch.set_alpha(0.)\n",
    "                sm = plt.cm.ScalarMappable(cmap=colormap, norm=normalize)\n",
    "                sm._A = []\n",
    "                cbar=fig.colorbar(sm, ax=ax)\n",
    "                cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=80,fontweight=\"bold\" )\n",
    "                for cell in self.new_vertices:\n",
    "                    ax.plot(cell[:,0],cell[:,1], linewidth=1.0, color='k')\n",
    "                for k in range(len(self.new_vertices)):\n",
    "                        cell=self.new_vertices[k]\n",
    "                        c=colors.to_hex(colormap(normalize(self.VPLC_state[k]))[0], keep_alpha=False)\n",
    "                        ax.fill(cell[:,0],cell[:,1], c)\n",
    "\n",
    "        if self.save:\n",
    "            if path!=None:\n",
    "                if not os.path.exists(path):\n",
    "                    os.makedirs(path)\n",
    "                fig.savefig(path+\"/\"+self.size+'Disc_VPLCProfile_'+str(self.sim_number)+'_'+self.saveName+\".png\",transparent=True, bbox_inches=\"tight\")\n",
    "            else:\n",
    "                print(\"Provide a path for saving images\")\n",
    "    \n",
    "    def draw_kymograph(self, path=None): # Draw the calcium Kymograph for the simulation\n",
    "        with sns.axes_style(\"white\"):\n",
    "            centeriods= np.zeros((self.adj_matrix.shape[0],2))\n",
    "            for j in range(self.adj_matrix.shape[0]):\n",
    "                x_center, y_center=self.new_vertices[j].mean(axis=0)\n",
    "                centeriods[j,0],centeriods[j,1]=x_center, y_center\n",
    "            y_axis=centeriods[:,1]\n",
    "            kymograp_index=np.where((y_axis<(-490)) & (y_axis>(-510))) # Location of where to draw the kymograph line\n",
    "\n",
    "            colormap = plt.cm.Greens\n",
    "            normalize = matplotlib.colors.Normalize(vmin=np.min(self.disc_dynamics[:,0,:]), vmax=max(1,np.max(self.disc_dynamics[:,0,:])))\n",
    "            fig=plt.figure(figsize=(30,10))\n",
    "            kymograph=self.disc_dynamics[kymograp_index,0,::][0][:,::2]\n",
    "            kymograph=np.repeat(kymograph,60,axis=0)\n",
    "\n",
    "            plt.imshow(kymograph.T,cmap=colormap,norm=normalize)\n",
    "            ax = plt.gca()\n",
    "            plt.yticks(np.arange(0,self.T/2,1498) , [0,10,20,30,40,50,60],fontsize=30, fontweight=\"bold\")\n",
    "            plt.xticks([])\n",
    "            plt.ylabel('Time (min)',fontsize=30,fontweight='bold')\n",
    "            if self.size=='xsamll':\n",
    "                plt.xlabel('Position',fontsize=20,fontweight='bold')\n",
    "            else:\n",
    "                plt.xlabel('Position',fontsize=30,fontweight='bold')\n",
    "            \n",
    "            if self.save:\n",
    "                if path!=None:\n",
    "                    if not os.path.exists(path):\n",
    "                        os.makedirs(path)\n",
    "                    fig.savefig(path+\"/\"+self.size+'Disc_Kymograph_'+str(self.sim_number)+'_'+self.saveName+\".png\",transparent=True, bbox_inches=\"tight\")\n",
    "                else:\n",
    "                    print(\"Provide a path for saving images\")\n",
    "\n",
    "        del kymograph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Establish simulation parameters to replicate four calcium patterns\n",
    "### NOTE:\n",
    "All wings are 'large' wings where the only difference in simulation parameters is the increasing range of $V_{PLC}$ values for standby cells. Initiator cells are the same for each simulation, which is determined by the same random number generator seed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_params_Spikes={'K_PLC': 0.2, 'K_5':0.66, 'k_1':1.11 , 'k_a': 0.08, 'k_p':0.13, 'k_2':0.0203, 'V_SERCA':0.9, 'K_SERCA':0.1,\n",
    "            'c_tot':2, 'beta':.185, 'k_i':0.4, 'D_p':0.005, 'tau_max':800, 'k_tau':1.5, 'lower':0.1, 'upper':0.5,'frac':0.007680491551459293, 'D_c_ratio':0.1}\n",
    "\n",
    "sim_params_ICT={'K_PLC': 0.2, 'K_5':0.66, 'k_1':1.11 , 'k_a': 0.08, 'k_p':0.13, 'k_2':0.0203, 'V_SERCA':0.9, 'K_SERCA':0.1,\n",
    "            'c_tot':2, 'beta':.185, 'k_i':0.4, 'D_p':0.005, 'tau_max':800, 'k_tau':1.5, 'lower':0.25, 'upper':0.6,'frac':0.007680491551459293, 'D_c_ratio':0.1}\n",
    "\n",
    "sim_params_ICW={'K_PLC': 0.2, 'K_5':0.66, 'k_1':1.11 , 'k_a': 0.08, 'k_p':0.13, 'k_2':0.0203, 'V_SERCA':0.9, 'K_SERCA':0.1,\n",
    "            'c_tot':2, 'beta':.185, 'k_i':0.4, 'D_p':0.005, 'tau_max':800, 'k_tau':1.5, 'lower':0.4, 'upper':0.8,'frac':0.007680491551459293, 'D_c_ratio':0.1}\n",
    "\n",
    "sim_params_Fluttering={'K_PLC': 0.2, 'K_5':0.66, 'k_1':1.11 , 'k_a': 0.08, 'k_p':0.13, 'k_2':0.0203, 'V_SERCA':0.9, 'K_SERCA':0.1,\n",
    "            'c_tot':2, 'beta':.185, 'k_i':0.4, 'D_p':0.005, 'tau_max':800, 'k_tau':1.5, 'lower':1.4, 'upper':1.5,'frac':0.007680491551459293, 'D_c_ratio':0.1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create the pouch objects for each calcium pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_Spikes=Pouch(params=sim_params_Spikes, size='large', sim_number=2400, save=True, saveName='Fig_2E_Spikes') \n",
    "p_ICT=Pouch(params=sim_params_ICT, size='large', sim_number=2400, save=True, saveName='Fig_2E_ICT') \n",
    "p_ICW=Pouch(params=sim_params_ICW, size='large', sim_number=2400, save=True, saveName='Fig_2E_ICW') \n",
    "p_Fluttering=Pouch(params=sim_params_Fluttering, size='large', sim_number=2400, save=True, saveName='Fig_2E_Fluttering') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run simulations for each of the calcium patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_Spikes.simulate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_ICT.simulate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_ICW.simulate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_Fluttering.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create dataframe for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(columns=['vplc', 'category'])\n",
    "j=0\n",
    "\n",
    "for v in p_Spikes.VPLC_state:\n",
    "    df.loc[j]=[v[0],'Spikes']\n",
    "    j+=1\n",
    "\n",
    "for v in p_ICT.VPLC_state:\n",
    "    df.loc[j]=[v[0],'ICT']\n",
    "    j+=1\n",
    "\n",
    "for v in p_ICW.VPLC_state:\n",
    "    df.loc[j]=[v[0],'ICW']\n",
    "    j+=1\n",
    "    \n",
    "for v in p_Fluttering.VPLC_state:\n",
    "    df.loc[j]=[v[0],'Fluttering']\n",
    "    j+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# $V_{PLC}$ distributions for each calcium pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with sns.axes_style(\"white\"):\n",
    "    fig=plt.figure(figsize=(20,15))\n",
    "    ax = plt.axes()\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['left'].set_linewidth(5)\n",
    "    ax.spines['bottom'].set_linewidth(5)\n",
    "    ax.tick_params(axis='both', which='minor', labelsize=5)\n",
    "    legend_properties = {'weight':'bold','size':20}\n",
    "    plt.yticks(fontsize=30, fontweight=\"bold\")\n",
    "    \n",
    "    plt.xticks(np.arange(3), ('Tom', 'Dick', 'Harry'),fontsize=50, fontweight=\"bold\")\n",
    "    plt.ylabel(r'$V_{PLC}$' ,fontsize=50,fontweight='bold')\n",
    "    plt.xlabel('off')\n",
    "    sns.violinplot(\"category\", \"vplc\", data=df)\n",
    "    ax.set_ylabel(r'$V_{PLC}$',fontsize=60, fontweight=\"bold\")\n",
    "    ax.set_xlabel('')\n",
    "\n",
    "\n",
    "saveFolderName = './simulationResults/Figure_2' # The folder where simulation results are to be saved for this notebook\n",
    "if not os.path.exists(saveFolderName): # Create the folder if it does not yet exist\n",
    "    os.makedirs(saveFolderName)\n",
    "    \n",
    "#fig.savefig(saveFolderName+'/Panel_E',transparent=True)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKkAAAN4CAYAAAAIhru6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XuQZnddJ/73ebp7unu6e6bnfktIBoFBEviRFQQl4iq6sMpFIwEEy/1FubqGLVYsf4lBSVh1t0q0cFO6IBTWDxGHNVtSRARZw29NxUAUNYmBTGJMSCaTSWcufb/3c35/9GW6p3suPd09p7vzelWdep7n+5zu5xNCTp/zfj7f7ynKsiwDAAAAABWqVV0AAAAAAAipAAAAAKickAoAAACAygmpAAAAAKickAoAAACAygmpAAAAAKickAoAAACAyjVWXcBqcODAgXljhw4dqqASAAAAgGcnnVQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVK5xMTvX6/U88sgjue+++3L//ffn/vvvz6FDhzI2NjZnv3379uWOO+5Y1kJP19PTky9/+cu588478/DDD+f48eMZGRnJ1q1bs23btuzfvz+veMUr8opXvCKXXXbZitYCAAAAwNIsKqS66aabctttt61ULeelLMv80R/9Uf7gD/4gPT09894/evRojh49mgceeCC33357Ojo68vd///cVVAoAAADA+Vp0J1WVRkdH88u//Mv58pe/XGkdAAAAACyvRYVUC9mwYUNGR0eXo5Zzuummm84YUG3ZsiU7duzI8PBwurq6Mjw8fFFqAgAAAGDpFhVSbd68OVdffXVe/OIXz2wHDx7MrbfeulL1zfjSl76UL3zhC/PGX//61+c973lPXvCCF8wZP3r0aO688878wz/8w4rXBgAAAMDSLCqkuuGGG1aqjrMqy3LBIOy9731vPvCBDyz4M7t37861116ba6+9dqXLAwAAAGCJalUXcD7uvvvuPPLII3PGnvOc5+T666+vqCIAAAAAltOS16S6GO666655Y6973evy4IMP5k//9E9zzz335OjRo2loaMjOnTvzPd/zPbn22mtz1VVXVVAtAAAAAIu1JkKqf/zHf5w39rWvfS1/+Id/mLIs54w/9thjeeyxx3LbbbflDW94Qz7ykY+ktbX1YpUKAAAAwAVYE9P9jhw5Mm/s4YcfnhdQne6LX/xi/uN//I8ZHx9fqdIAAAAAWAZrIqTq6ek56/t79+7Nzp07F3zvrrvuymc+85mVKAsAAACAZbImQqrR0dEFx/fu3ZsvfOEL+drXvpY777wzn/3sZ9PZ2Tlvv0996lPn7LoCAAAAoDprIqRqb29fcPw//af/lBe+8IUzr1/2spflXe9617z9nnnmmTz44IMrVh8AAAAAS7MmQqpNmzYtOP7KV75y3tj3fu/3Lrjvk08+uaw1AQAAALB81kRI9bznPW/B8a1bt84b27Zt24L7joyMLGtNAAAAACyfNRFSveQlL1lw/MSJE/PGjh8/vuC+CwVaAAAAAKwOlYVUhw8fzoEDB+Zthw8fnrfva1/72gV/x9e//vV5Y/fcc8+8sYaGhlxxxRVLLxoAAACAFbEmOqme+9znLrj+1Mc+9rE5C6J/85vfzCc/+cl5+73qVa8647pWAAAAAFSvcTE7Hzx4MAcPHpwz1tXVNW+/rq6uXHPNNXPGrrzyytxyyy0XUOKkD33oQ/nJn/zJjI6OzowdOXIkb3rTm7Jv376Mj4/n6aefnvdzjY2N+cAHPnDBnwsAAADAyltUSNXV1ZUHHnjgnPuNjY3N26+trW1xlZ3mec97Xj7ykY/kxhtvzMTExJz3znTnvqIo8uEPfzgvetGLlvTZAAAAAKysNTHdb9pP/MRP5NZbb82uXbvOue+2bdvyB3/wB7n22msvQmUAAAAALMWiOqlWgx/+4R/O933f9+ULX/hCvva1r+Whhx7KiRMnUhRFtmzZkhe96EX5wR/8wbzxjW9MS0tL1eUCAAAAcB6KsizLqouo2oEDB+aNHTp0qIJKAAAAAJ6d1tR0PwAAAADWJyEVAAAAAJUTUgEAAABQOSEVAAAAAJUTUgEAAABQOSEVAAAAAJUTUgEAAABQOSEVAAAAAJUTUsEF+OpXv5pf//UPp16vV10KAAAArAtCKrgAH/nIR/K1r92RwcHBqksBAACAdUFIBUswPj5edQkAAACwLgipYAnGxsaqLgFYR06ePJlvfetbVZcBrDN33nlnPvrRj6Ysy6pLAYCzElLBEgipgOX0oQ99KO9973szMjJSdSnAOvJrv/Zr+cIXvpD+/v6qSwGAsxJSwRKY7gcsp/vuuy9JMjo6WnElwHoyMTGRxLEFgNVPSAVLoJMKWAmOLcBK8OUaAKudkAqWwMkesBKEVMBK0EkFwGonpIIlcLIHrAQBOLASHFsAWO2EVLAEw8PDVZcArEM6qYCV4Ms1AFY7IRUsgZAKWAlCKmAlCKkAWO2EVLAEQ0NDVZcArEMjIyNVlwCsQ85bAFjthFSwSPV6fea5TipgJTi2ACtBSAXAaiekgkWaffHoQhJYCS4kgZXg2ALAaiekgkWaHUw52QNWgmMLsFxm39HPsQWA1U5IBYskpAJWwuypxI4twHKZfTxxbAFgtRNSwSINDAzMPB8cHKywEmA9MZUYWAmzz1tmPweA1UhIBYvU19c387y/v7/CSoD1ZHaHgwAcWC69vb0zz2efwwDAaiSkgkWaDqbKouZkD1g2uh2AlTD7XMV5CwCrnZAKFmkmpGpuT1+fTipgeejSBFbCzLGlJqQCYPUTUsEiTZ/glRs60jOrhR5gKWYHUy4kgeUy8+VaWzln6h8ArEZCKlik6ZO9enObbgdg2UwHUx1NdccWYNnMhN5tSU9vT7XFAMA5NFZdAKw1/f39KZqaUzY2Z7DbujHA8pgOpna01tPnQhJYJr29vUltspOqr0uXJnDhRkdH841vfCNf+cpXcuL48TnvNTY25hWvfGVe+9rXZvv27RVVyHogpIJF6uvrSxqbk4bmjI2NZmRkJM3NzVWXBaxx090O21vqedx0P2CZ9PT0pNZSS725noH+gUxMTKShoaHqsoBVrizLdHV15ZFHHsnDDz+c++69N/fde29GxsbSUatlZ70+Z/+hosjH7703H//4x3P5ZZfle172srzgBS/I8573vFx++eVpamqq6J+EtUZIBYvU09OTekNzyqaWJJPfUO7YsaPiqoC1rq+vL00NSWdzPQ8cN90PWB49PT0pN5TJhsmLzr6+vnR2dlZdFrAKDAwM5JlnnskzzzyTrq6uHDlyJE8++WSePHw4Tx4+nP7BwZl9d9Zquapez/OTfFe9noYUc39ZmTyT5MEkj3znO/ni449ntCyTJA21Wvbs3p19l16affv2Ze/evdmzZ0927NiR7du3Z8uWLcJzZgipYJG6e3oy0TA53S+ZPPkTUgFL1dfXl/YNRdoaywwMDul2AJZFd3d36hvqSfOp10IqWJ/KsszAwEB6e3tz8uTJnDx5Mt3d3TPPT548mRMnTuRYV1eOHTuWoZGROT9fS7KlVsuWej0vSrIzye6prbleJqcHU6fZkSI7kvxAknpZ5niSo0mO1us5fuRIHn/qqdybIsPl3C6sWq2WrZ2d2bFzZ7bv2JHOzs5s2bIlW7ZsmXm+devWbNq0KZs2bUpjoxhjPfNvFxapu7snadw4J6QCWKre3t60N9bT0TT5raNuB2A5nOw+mXJDmbJ58tjivAVWv/Hx8fT396evr2/ONnust7c3PT096enpSW93d3p6etI3MJD6adPwprXUamlL0lavZ1OSS5JsOm3bnKThPMKo81GbCqx2JHnx9GCZlKlnMEl3kt7prV5P34kT6T1xIg8/9FAGkvTX6ynP8Ls3trZmU0dHNnd2ZnNn50x4tWnTprS3t6ejoyMdHR1znnd0dKSlpSVFsfR/NlaWkAoWqa+vN2X7lpSNp6b7ASxVb29P2hom0iakApZRT0/P5FXirE4qYOWUZZnh4eEMDAykv78//f39c54v9Lq/vz/9vb2TjwMDGT6tw+l0TUWRjUWR1iSt9Xo6kuxK0ppk49RjezIZSk1tTfXpyGf5Qpp/nIqRrlrE7yxSzNS0b6EdpuqsJxlK0p9MhlZTrweTDA4NZXBoKENdXTlSFHmkKDKYZOgMAd20xoaGtG3cmPb29rR3dExu7e3ztra2tgWfb9y4UZf7RSCkgkUYHx/P4MBAys6WycXTI6QClkdvT0+2NtXT3jR5guXYAizVxMRE+vv6J1smNkyO6aSCs5uYmFgwRBoYGJjpZjr9/b7e3gxMjQ8MDmbiHGFJLZOdTa1JmssyLWWZjUm2JmmZ2lpnbbPHWpI0lUnK5Q+dFusfph6vWoHfXZsVZp3VrP8t6klGMhlmDSUZPu1xaGIiw319k9tTT6UryRO1WoaTDJflzBpaZ9Pa0nLOoGs62Oro6JgTcrW3t7vh1nkQUsEiTN8ivmxsnumkcrIHLIfe3t48p6Wc6aQSUgFL1dfXl7KcXDR9upPKeQvPFiMjI+nt7Z2ZFjf78fRpdH09PTMB1ODw8OR/N2fRXKvNBEfN9XpaMtmweOn0WE4FSy2zxmZCpiRFffZnmIK2HGopZoK98zbr38NEJgOthbaR6efDw5PbiRMZSHKiKDJSFJNhWL2es8eTyYamprS3taWjoyObNm9O+6zpiB0dHXOmLm7atCmbN2+emcb4bJmqKKSCRZg+sSsbW5JaQ4qGJheSwLLo6+tPW0eZ9lnT/QCWYiaQak7SkBSNhZCKNassy/T39+fYsWN55pln5iwGPrM4+IkTOXniRHp6ezMyOnrG39VUFGktiskAaSpk2p1TIdLs7qXZXUzNU1uDgGldajjf7q3ZZnVylUnGcqpzayTzu7mGx8Yy3N2doe7u9D/xRI4VRYZnhVxnUqvV0tHWNrmg/LZt8xaW37JlS7Zt25YdO3Zky5Yta3px+bVbOVRgJpCamuqXphYne8CSjYyMZHRsLG2NZdoadVIBy2Pmy7WpRdOLFiEVq1tPT08OHz6cJ598MkeOHMmRI0dy9OjRPPP00zl2/PiCwVNjUaS9KLKxLNNWltmX5PmZuz7TxtOer5bpcqwvRYpsyGTz6qbz/aHTpitOr7s1NOv59Hpbg319Gejry4nHH88TtVoGsvA6XLWiyJapuyXu2Lkze/fuzb59+2Yed+/evarX1hJSwSLMnOw1TU71qzc2u5AElmy6a6qtqZ6NjTqpgOUxE0hNrUdVbigtnM6q0dfXl3vvvTf//M//nH/5l3/Jvzz0UE6c9v/PTbVaOuv1bElyWSYv/DtmPbZlck2nYqaxSeDE2nXe63AlM9MUxzMZYvVNbb1JessyfSdPpufkyTz48MO5uywzPmsKa3NTU/Y/97l53vOfnwMHDuSqq67KpZdeumqmEwqpYBGmA6lyqpOqXtuQbt9IAks0vd5dW2OZhlrS2lQIqYAlmwmkphrA6xvqOdl9srqCeNbr7e3NV7/61fzvr3413/72t1MvyzQURXYmubQs8/Ik2zK5gPjWTN+RbnVcOMNq1Jgim3KWzq16mXrK9CU5keR4kq6xsRw9dCh3PPxwbr/99iTJ9q1b84M/9EN53etelwMHDlyU2s9ESAWLcGpNquapx5Z0dwupgKU51UlVTj3qpAKWTicVq8Xw8HA++9nP5vN/+qcZGhnJnqLID5Zl9ie5pCzTlCLCKFgZtRTZnGRzkv2zxst6PSeS/GuSh0+cyBf+1//Kbbfdlpe/7GX5xeuvz/79+xf8fStNSAWL0NPTkxS1pNaUZHLaX09PV8VVAWvdTEg1NdVvY2NdSAUsWV9fX4qG4tQZ/4ak75hjCxfXgw8+mJs//OE8eeRIrkzy6iR7ykQoBdUqUmRbJrsXX55kqCzzzSR3fvMf8nPXXZeff+c78/a3vz21Wu2i1nVxPw3WuN7e3hQbWpKp+bplY3OGBgcyMTFRcWXAWnZ6J9XG2riQCliynp6eFM2zgoANydDgUMbHx6srimeNsizz+c9/Pr/wvvel/+jRXJfkrSmyRzgFq1JrilydIu8v63lhvZ5PfOIT+eAv/VJOnDhxUesQUsEi9PT0pGxomXldNjanLEsXk8CSzF6TKpkMq/p6TSUGlqa3tzflhlOL5U6vTeW8hZXW3d2d/+dXfiW33nprnjcxkV+o1/Nc4RSsCW0p8tYkb0py7z/8Q677D/8hf/d3f3fRPl9IBYvQ29ubiYYNM6/LxpaZcYALNR1Stc5M9yszMDUGcKF6entSb5p1e/KpUxjnLaykb33rW/n5667LPd/4Rn48yduTbBRQwZpSpMjLUuQ9ZZmmvr588IMfzKc//enU6/Vz//ASCalgEXp6emcWTU+STD33jSSwFH19fWluLNI49Ve5rbFM/8BAtUUBa153d/dMMJVkpqtKSMVKufvuu/P+66/P+MmTeXdZ5pUpUgio1qUyZXqTPJPknpQpU57rR1iDdqXIe+r1/F9lmU9/+tP5jf/yX1Z8yriQChahp3duSDX93MkesBT9/f1pazr1emNTmaHhEevGAEvS23fadD+dVKygf/mXf8mHbrop28fH8556PXuFU+va3yU5kWQgyRenXrM+bUiRa5K8JslX//f/zsc//vEV/TwhFSxCf3/fgiGVTipgKQYGBrKx8VT79MapaX+Dg4NVlQSscWVZZqBvYE4nlZCKlfTff+/3smFiIj9blmkTUK17D57jNetLkSL/NkVenuTzn/98Hn/88RX7LCEVnKeRkZGMjY4mDbNCqgadVMDS9ff3p7V26i6h0yFVv3WpgAs0PDw82Y25QEjlyzWW2+DgYP7xn/4pL6vXBVTPEmPneM369G8z+SXI17/+9RX7DCEVnKfpE7q5a1JNnu0JqYCl6OvrnQmmklMhlQtJ4ELNnJvMDqmmphU7trDcpqent5xjP2Btm74SHh0dXbHPEFLBeZo+2Zu+o1+SpKilaGp2sgcsSf8ZQiqdVMCFmvlybfaaVEVSa675co1l19HRka1btuRw1YUAK+rJqcf9+/ev2GcIqeA8nQqpNsx9o7E5PT09FVQErBcDAwPZOOs28W1N5cw4wIVYsJNq6rWQiuVWFEW+9xWvyCO1Wuru8gbr1sNJGhsactVVV63YZwip4DzNdEvNnu6XpN6wQbcDcMHKskz/wOCcTqpWnVTAEp0ppKo31XWAsyKuuOKKDNXr8f8uWL+ezmQX1caNG1fsM4RUcJ6mOxrKhrlne/VakwtJ4IINDw9nYqKetlkhVZuQCliimePHaSFV2VTqpGJFFMXkgun6qGD9KnPqv/WVIqSC8zR9snd6SFU2bEivbySBCzQdgLfqpAKW0Zk6qcoNZbp7uy9+Qax7//qv/5rmosimqgsBVsyOJN957LGZmyWsBCEVnKeZtWEWCKn6+60bA1yY6SBqdidVrUhamwprUgEXrLe3N0WtSBpOe2ND0tfryzWW35NPPpltSWpZ2S4LoDo7koyMjeXEiRMr9hlCKjhPfX19KRqaktpp/9k0bsjgoAtJ4MJMrw0zu5MqSTY26qQCLlxfX1+K5iLz8oINyeDAYOr1+oI/Bxdqx44dOZ4iAyb8wbr1eJINTU3ZtGnleiaFVHCeBgYGktPv7JfJTqrhoaFMTExUUBWw1k13S22cF1LVhVTABevr65t/Z78k2TB5wwadmiy3a6+9NhMNtXy2KDIsqFr3hpO0trbmzW9+c1pbWzNcdUGsuLtT5p+S/NSb35yWlpYV+xwhFZyn/v7+eetRJafWqBocHLzYJQHrwPSxo+W0kKqlVndcAS5Yf39/6o0LdEs1TT4IqVhu+/fvz4c//OE8Vavl00WRIUHVujac5Md//Mfz/ve/Pz/+4z8upFrn/iZlvpTk1T/wA3nXu961op8lpILzNDAwkHqtaf4bUyGVkz3gQkwHUa2nrRvT0lDPkKnEwAXqH+hP2Tg/JCibJsect7ASXv3qV+c3fvM301Wr5c+sTbWutST5i7/4i/ze7/1e/uIv/iIr11dD1b6dMl9N8iM/8iP58M03p7GxcUU/T0gF52l0dDRlcfrqo0lZa5h5H2CxZkKq0y4mWxvLDJjuB1yg/v7+mUBqDp1UrLDv+77vy3U/93N5KGVO6KZat1qSDA0N5c/+7M8yNDQkpFrHvpFk3969ufHGG1c8oEqEVHDeRkZHZwKpOYRUwBIMDQ0lSVoaTpvu11Ca7gdcsP6B/plAag4hFRdBW1tb1SUAy6RM0tzcfFECqkRIBedtZGR0JpCaozb5H6uQCrgQAwMDaWpIGk77i9zSWGZwKsACWKyhgSEhFZX56l/9VXYWtWypuhBgyV6Y5F8ffTSPPvroRfk8IRWcp9HRkQVDqukpgEIq4EIMDg6mtXH+uh2tDWWGhoZTlqZKAItTr9czMjKSLPSl99SYkIqVdOihh/JdZT2FdalgzfuuqcdDhw5dlM8TUsF5OtOaVKb7AUsxPj6epgX+GjfVknpZZmJi4uIXBaxpY2Njk08WOtOfGhsfH79o9fDss//yy/NgUcuANalgTStT5ptTz/fv339RPlNIBedpdPRM0/0mx0ZGRi5yRcB6MDExkYZi/kl8rVbOvA+wGDMB1FlCqpkgC1bAB/7zf85AY0M+WdRyTFAFa9JEyvxFkr9N8qY3vSkHDhy4KJ8rpILzNDo6ZrofsOwmJiZSW2A2RG3W+wCLcT4hlU4qVtKVV16Z3/nd381Ye1s+UdTyr4IqWFOGU+b/TZFvJHnb296WD3zgAxfts4VUcJ6Kc0ypL861A8ACJjup5o9Pj9Xr9YtbELDmCalYDV7ykpfkE5/8ZHY959L8cVHkCUEVrAnjKfPHRZHv1IrccMMN+YVf+IXUahcvOhJSwXlqbGxKFrhYLMrJsaamhW6hA3B24+PjqS0w3W86pNJJBSzWWUOqYnITUnEx7NmzJ7/33/97tu3YkT+v1VIKqmDVuyfJd8oyv3rTTfn3//7fX/TPF1LBeWpsbEzKBS4Wp8YaGxe6hQ7A2VmTClhuM8eNMzV5F44tXDydnZ257ud/Pl31eo5UXQxwTvcWtVzxohflR37kRyr5fCEVnKempqakXGDajU4qYAnKcuFvlaevLU33AxZrw4YNk08WyqHKJPVZ+8BFcNVVVyVJDldcB8vn9CsfV0Lrw1jKHC3ruerf/JvKahBSwXlqampMsdDF4tSYTirgQrS0tGSsPv/P8ehEMfM+wGLMHDcWCqkmTtsHLoJdu3Zl+9atebjqQlg2LzzHa9amf01ST/LiF7+4shqEVHCezjTdr5ga00kFXIjW1tYMTcyfkzMspAIu0PmEVM3NzRetHiiKIj/2+tfnoSRHrEu1Lrw8ydYkbUneMPWata2eMv9fUWT71q152cteVlkdi2r9qNfreeSRR3Lffffl/vvvz/33359Dhw5lbGxszn779u3LHXfcsayFnsnDDz+cn/zJn5xXQ5L84i/+Yq6//vqLUgfrX1NjU1IOz3+j1EkFXLjW1taMLHAhOTxRZENTk2MLsGiNjY2p1Wqpjy/QAT61XrqQiovtbW97W77w53+eL/X15efLMsUZF01jLShSZNNU4Pi9/l2uC/clOVyWufG97620AWNRZ7433XRTbrvttpWqZdEmJiZyww03LBhQwXJraWlOUe+f/0Z98mzPyR5wIVpbWzM8VqYsk2LWOd7wRNLa6rgCXJgNzRsyPrHAHfxM96Mi7e3t+b+vuy4f+9jHciTJvqoLAua4uyjy3Msvz7/7d/+u0joWNd1vtS3e+qlPfSr3339/1WXwLNHZ2ZmGiZF548XY8Mz7AIvV2tqaiTIZP232w8h4kdaW1mqKAta8lpaWma6pOcZnvQ8X2dVXX50k7vIHq8xEyjxVlnnV1VenVqt2Vaglf3pVdwZ55JFHcuutt1by2Tw7dXZ2phifP92vGB9OURTp6OiooCpgrWttnQyihsfntsoPTxRp3bixipKAdWDr1q0phheYgjN1KrNt27aLWxDk1Je6PRXXAczVn8mbv66GxotFhVSbN2/O1Vdfnfe97335/d///dx5551597vfvVK1nVG9Xs+NN96YkZFTXS0WrWaldXZ2phwdSk67XXwxNpS29o40NDRUVBmwlrW3tydJBk4LqQbGi7QLv4ELtHPHzgVDqmJockxIRRWam5tz1UtfmruKIl9LmT6LqEOlxlPmWynzx0WRWq2Wl7+8+iXwF7Um1Q033LBSdSzKH/3RH+Wf/umfZl6/5S1vyV133ZUnn3yywqpY7zo7OycDqomRpPFUi3wxNpwtW7ZUWBmwlm3fvj1JcnKklt0bT02rPznalO/evqOqsoA1btu2bamN1DJx+i3+hifvtObcharcfMst+a+/9Vu54+67c0eSnbUil9fr2ZNkZ5IdSVotxA3LbiJljid5JsnTSR5P8kRRZLQss3Pb9vzWL38wl19+eaU1JosMqVaDxx57LB/72MdmXu/Zsye/8iu/kje+8Y0VVsWzwXTrYzE2nHJ2SDU+nK1bdlVVFrDGnQqpTp2Ql2VycrjIjh1CKuDCbN++PfWh+uT8jdnX+0PJps2b3DmUynR2dua//rf/lieeeCL/5//8n/zTP/5j7rvvvtwza5ZMR63I5rLM5rJMZ5LOJJuTtCfpSNKWpEmQBTPqKTOYyWl7/Ul6k3Rncmptd5LeWi0ny2Ri1qyg515+ed7wPd+Tl7/85XnFK16xamYGram/TtPT/IaHT60L9JGPfGRmqgSspDkh1ay1jBsmRnwbCVyw6SDq5MipGfhDE8nIRGk6DnDBtm3bNhlQDSeZdd5SDBcz4ThU6dJLL83P/MzP5Gd+5mcyMTGRp59+Oo899lgee+yxPPHEEzl69GiefuqpPPzMMxld4G7uLbViMrCq19OWZONZttYkzUlqgi3WgDJlxjJ5+B5IMpRkcIFtIMlAUctAkfTXyyx0m7utnZ3ZvWdPLt+zJ3v27Mn+/ftz2WWX5TnPec7MuqirzZoKqT7zmc/km9/85szrN7/5zfmBH/iBCivi2WQmpBofmjNejA+0+tHFAAAgAElEQVStigXmgLWpra0trS3NOTnrC5iTw5OBlU4q4ELNBFFDmRNS1YZq2Xn5zkpqgjNpaGjI3r17s3fv3nz/93//nPfKskx3d3eefvrpnDx5MsePH8+JEydy8uTJnDhxIsePHUv3yZM53NOTvv7+1MuF17kqMhlstSZpKcvJLZP/ebQmaTnHtiFJIeTiPI2nzHCSkUwehmc/Dk89n36cfF5kuFZkOMngaR1Pp2ttacmmjk3p3NKZ/du3Z8uWLdm6deucbfv27dmxY0dlN7pbijUTUj3xxBP53d/93ZnXu3fvXjVrZPHsMH2xWIwOnhqsj6ccHfaNJLAk27dty8nRvpnX011Vji3AhdqzZ0+SpBgoUm6dutgpkwwke/fura4wWKTpNdTOZ+ZCvV7PwMBAuru709vbm97e3nR3d6evr29m6+/vn3w+9f5TU2Nj4+Nn/d21JM21Yia0aq7X05xTIdb5PBd0rQ2zA6bhWdvI2Z4XRUaKYvJ5WWbsHPcEKIoibRs3pqO9PR2bNmXnpk3ZtGlT2tvb09HRkY6OjrS3t2fz5s0z26ZNm7J58+Z1f9O4NRFSlWWZG2+8MUNDpzpYTPPjYuvs7ExjU1NGR/tnxorRgSTJrl3WpAIu3Padu3Ly0cdnXp8QUgFLNBNE9c8aHE3KsVJIxbpVq9VmLvAXa2RkJAMDA+nv75/ZzvZ6cGAg/X19eXpqfGBoKPX6QhOuTpnu5poOr5rr9XkdWwt1dc0eW01TFv9N1QUsoEyZ0cztVjrTNv3+yFTANJzJgGn8PG462drcnLa2trS1taW9oyPbOzqycePGtLe3z2xtbW1nfN3a2pparXbuD3oWWhMh1Z/8yZ/knnvumXn9Uz/1U3n1q19dYUU8GxVFkR07duaJ4Vkh1cjk8507tc0DF27nzp35+wdPfSt23HQ/YIlaW1uzecvmnOw/eWpw6hRm37591RQFq1hzc3Oam5uzdevWC/r5siwzPDw8E2QNDAzMeX6msf7e3jzd35/+gYEMDg6ecbritJZakY0p0lKWaS3rM9MVW3NqDa620x5XqoPrqhUOzCamFgMfSOY8DubUOk0zU+ZqtcnHc0yVS5KW5ua0TwVMHZs2ZcesEGk6SJr9ePrYxo0bV80i4+vRqg+pDh8+nN/+7d+eeW2aH1Xas3t3nnzoiZnXNZ1UwDLYs2dPTgyXGa8njbXk2HAtW7dsTnNzc9WlAWvYJXsvSXdXd8pMXrAVA5MXlDqpYPkVRZHW1ta0trZecCd0vV7P0NDQTLfW9PTEmSmKs7be3t709vSkp7c3T/T2pm9g4IydXE1FkbaiSFtZpqMs05FTd0rsyOSdE7ckablIXVoTKU/ddS6T+XnfrK2/VptcMLx+5rBpY2vrzFS5HZ2d2bRp00wXXUdHx8zUuYU2dzdd3Vb9v53PfvazGRw8tQbQLbfcckHtm7Acdu3amYYHDs28Lkb6UxTukgMsza5du1KWk9P8drbWc2y4lt17XEQCS3PJJZfk2499O/Xpez5NdVJNr1cFrC61Wm2mc2exX4KXZZmBgYH09PSku7s73d3dM897enpmFpo/9swzeejYsfT09c37Ha21Ip1lmc6yzI4kO6e2HUkaFxlglSnTm+TpJF1T28kk3bVaeurT0fkpzRs2ZNu2bdm+ffvMYuCdnZ3p7OzM5s2b5zxu2rRJ0LSOrfp/s+OnLWD37ne/+7x/9tZbb82tt96aJPnZn/3Z/Oqv/uqy1sazz65du1KO9Cf1elKrpRjtz+bOLWvyrgnA6rF79+4kybGhqZBqpClX7HYRCSzNnj17Uh+oJxNJGpIMJFu2btGlCetQURQznULnM6V3bGxs8u6Ix4+nq6srTz31VJ566qkcPXo0Rw4fzkNHjmRiqjOroSiyr0wuS5kDSS7Nwmtj9abMt5I8muTxWi39szq7tnR25tJLL82BvXuze/fu7NmzJ7t27cqOHTuybdu2bNy4MUWxetbbojqrPqSC1WR67alibCBlc0dqIwPZtdd6VMDSTIdUzwzXUi+TY0OnxgAu1My0vsEkHZPT/S7Zd0mlNQGrQ1NTU3bt2pVdu3blRS960bz3x8bG8sQTT+TRRx/NQw89lPvuvTd3HzqUOycm0lGrpfW0/etJjk91SO3etSuveulLc8UVV2T//v3Zv39/Nm3adDH+sVgHKgupDh8+nNe85jXzxv/6r/86l1zijyer03TbbTEyGVI1jA9k967nVVwVsNbt3LkzRVHk2FAt3SNFJupCKmDpZkKqgSQdScNgg/WogPPS1NSU5z73uXnuc587c90+ODiYu+66K9/4xjcyNjY272f279+f17zmNbn00ksvdrmsI6u+k2rv3r254oorzrnfQw89NO8/lB07dsx0vviDzHKYvtNWMTa5YHoxOuDuW8CSNTU1ZdvWzhwbHs6xqTv7uSEDsFTT57/FQJFyokx9oG49KuCCbdy4MT/6oz+aH/3RH626FNaxRYVUBw8ezMGDB+eMdXV1zduvq6sr11xzzZyxK6+8MrfccsuiC7zuuuty3XXXnXO/H/7hH86TTz45Z+ytb31rrr/++kV/JpzJ9ALpxehAMj6acnxMSAUsix07dqa7qyvdI5Mh1fSXLAAXauvWrWlsasxo/+jklL/44haA1W1RIVVXV1ceeOCBc+43NjY2b7+2trbFVQarUFtbW5pbWjI2OjgZVCVCKmBZbNu+I995sjEnRya7grdt21ZxRcBaV6vVsnv37jwx8ETKgcl7aemkAmA1q1VdAKwlRVFk+/btKUYHZqb8TXdXASzF9u3bc3KklpMjtTQ2NFhgFFgWe/fsTTFYpBicvGuW9e4AWM2EVLBIu3buTG10ILXRyb55U3KA5bBt27b0j5Y5NlzL1q1bUqv5Ew0s3fbt21MbqSVDk6+3bt1abUEAcBaLmu53/fXXL9saT5dcckkOHTq0LL8rSe64445l+11wNjt27EjDtx7O+NR0P1NygOUwfSx5tLch2y/XoQksj23btqU+VE+Gko5NHWlqaqq6JAA4I1/TwiLt2LEj5chAitGBtHd0pLm5ueqSgHVgeurw00MN2bbdWnfA8ti2bVtSJkVPYYkCAFY9IRUsUmdnZ1LWUxvuzZYtWuaB5bFly5YFnwMsxXSXZnGyyA4BOACrnJAKFml6MeNiuDedmy1sDCyPjo6OBZ8DLMXMsgSlJQoAWP2EVLBI0yFVbbTf3beAZdPW1rbgc4ClmL1QemdnZ4WVAMC5CalgkWZ3OAipgOUyO5hqb2+vsBJgPZl9bNGlCcBqJ6SCRdq8efPMcyEVsFwaG0/dcFdIBSwXXZoArCVCKlik2cGUkApYCS4kgeUyOwB3bAFgtRNSwSLN7nAQUgErQScVsBIcWwBY7YRUsEi+kQRWWktLS9UlAOuQ8xYAVjshFSxBc3Nz1SUA61BTU1PVJQDrUGtra9UlAMBZCalgCYRUwEoQUgErYcOGDVWXAABnJaSCJRBSAStBSAWsBMcWAFY7IRUsgZAKWAm6HYCVIKQCYLUTUsESCKmAleBCElgJAnAAVjshFSyBkApYCbPvIgqwXATgAKx2QipYAt9IAiuhoaGh6hKAdUgADsBqJ6SCJfCNJLASajV/noHl59gCwGrnLxUsgZM9YCUURVF1CcA65LwFgNXOXypYAlNygJUgpAJWgpAKgNXOXypYAiEVALBWCMABWO2EVLAEQioAAABYHkIqWAJt8wAAALA8XGHDEgipAAAAYHm4wgYAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgckIqAAAAAConpAIAAACgco2L2bler+eRRx7Jfffdl/vvvz/3339/Dh06lLGxsTn77du3L3fccceyFjo8PJx77rkn9913X771rW/l8ccfT1dXVwYHB1Or1dLR0ZH9+/fnpS99ad70pjfl+c9//rJ+PgAAAAArZ1Eh1U033ZTbbrttpWo5o9tvvz033nhjRkZGzrjPyMhIjh07lr/7u7/LH/7hH+YnfuIn8qEPfSjt7e0XsVIAAAAALsSipvvV6/WVquOsjh07dtaAaiF//ud/np/7uZ/L8PDwClUFAAAAwHJZ8ppUGzZsWI46Fq2trS3f9V3flR07dpxxn3vvvTf/43/8j4tYFQAAAAAXYlHT/TZv3pyrr746L37xi2e2gwcP5tZbb12p+uZob2/PT/3UT+X1r399rrzyytRqkxnbd77zndx8882566675v3M5z//+bz//e+f2RcAAACA1WdRIdUNN9ywUnWcVXNzc971rnflve9974JrTF122WX5+Mc/nmuuuSYPPfTQnPeOHz+exx9/PJdffvlFqhYAAACAxVpUSFWVn/7pnz7nPk1NTXnDG96Qj370o/Pe6+7uXomyAAAAAFgm62oOXFtb24Lj27dvv8iVAAAAALAY6yqk+ud//ud5Y9u2bcuePXsqqAYAAACA87VuQqpHH300X/rSl+aNv+Utb0lDQ0MFFQEAAABwvtZFSHXixIlcf/31GR4enjO+b9++vPOd76yoKgAAAADO15oPqY4ePZqf/dmfzcMPPzxnfNOmTfn4xz++4N0AAQAAAFhd1nRIdejQobzlLW+ZF1B1dHTkU5/6VJ7//OdXVBkAAAAAi7FmQ6qvf/3recc73pGnn356zvj27dvzmc98Ji95yUsqqgwAAACAxVqTIdXtt9+ed77znenr65szfvnll+dzn/tcvvu7v7uiygAAAAC4EGsupPrUpz6VD37wgxkbG5sz/tKXvjSf+9zn8pznPKeiygAAAAC4UI1VffDhw4fzmte8Zt74X//1X+eSSy6ZN16v1/Obv/mb+cxnPjPvvde85jX5nd/5nbS0tKxIrQAAAACsrMpCqsUYGRnJL//yL+crX/nKvPfe/va350Mf+lBqtTXXFAYAAADAlEWFVAcPHszBgwfnjHV1dc3br6urK9dcc82csSuvvDK33HLLBZSYfPrTn14woGpsbMy9996bN7/5zWf9+euvvz4/9EM/dEGfDQAAAMDKW1RI1dXVlQceeOCc+42Njc3br62tbXGVnfb7FjI+Pn5e9Zw8efKCPxsAAACAlWeOHAAAAACVE1IBAAAAULmiLMuy6iKqduDAgXljhw4dqqAS1opXv/rVSZK/+Zu/qbgSYD1xbAFWgmMLAGuFTioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKiekAgAAAKByQioAAAAAKte4mJ3r9XoeeeSR3Hfffbn//vtz//3359ChQxkbG5uz3759+3LHHXcsa6GzHTp0KLfffnvuuuuuPP300+np6cmmTZuye/fuvOpVr8rrX//6HDhwYMU+HwAAAIDltaiQ6qabbsptt922UrWc08jISH7jN34j//N//s/U6/U57x0/fjzHjx/PAw88kE9+8pO59tpr86u/+qtpbm6uqFoAAAAAzteipvudHgxdTENDQ3n3u9+dgwcPnrOOer2egwcP5j3veU+GhoYuUoUAAAAAXKglr0m1YcOG5ajjnH77t387X//61+eNt7W15QUveEHa29vnvXf33Xfnox/96MUoDwAAAIAlWFRItXnz5lx99dV53/vel9///d/PnXfemXe/+90rVduMb3/72/mTP/mTeeNvfvOb87d/+7f54he/mLvuuivXXnvtvH0++9nP5sEHH1zxGgEAAAC4cItak+qGG25YqTrO6nOf+9y8KX779u3Lr//6r890crW0tOTXfu3Xctddd+XIkSMz+9Xr9Xzuc5/LzTfffFFrBgAAAOD8LXm630oryzJf/vKX542/9rWvnTfVcMOGDXnta187b9+//Mu/TFmWK1YjAAAAAEuz6kOqRx99ND09PfPGr7jiigX3v/LKK+eN9fT05Dvf+c6y1wYAAADA8lj1IdWZ1pPas2fPguO7d+9e1O8BAAAAoHqrPqQ6efLkguOdnZ2LGj/T7wEAAACgeqs+pOrv719w/PT1qM413tfXt2w1AQAAALC8Vn1IdSZnWgjdAukAAAAAa8+qD6na29sXHB8bG1twfHR0dMHxjo6OZasJAAAAgOW16kOqLVu2LDh+pjWmuru7F/V7AAAAAKjeqg+pXvjCFy44/tRTTy1q/Ey/BwAAAIDqrfqQav/+/dm8efO88QceeGDB/Rca37x5cy677LJlrw0AAACA5VFZSHX48OEcOHBg3nb48OE5+xVFkde97nXzfv4rX/nKvPWnRkdH81d/9Vfz9v2xH/uxFEWxvP8AAAAAACybVd9JlSQ//dM/nVptbqlHjhzJzTffnOHh4STJ8PBwbr755hw5cmTOfrVaLW9729suWq0AAAAALF7jYnY+ePBgDh48OGesq6tr3n5dXV255ppr5oxdeeWVueWWWy6gxOS7v/u78/a3vz1//Md/PGf8z/7sz/KXf/mX2bdvX5588skMDAzM+9l3vOMd1qMCAAAAWOUWFVJ1dXWdcS2o2cbGxubt19bWtrjKTvPBD34wDz/8cL7xjW/MGR8YGMhDDz204M+88pWvzC/90i8t6XMBAAAAWHlrYrpfkrS2tuYTn/hE3vrWt86b+ne6Wq2Wt771rfnEJz6R1tbWi1QhAAAAABdqUZ1UVWtpacktt9ySd7zjHfniF7+Yv/3bv81TTz2Vvr6+dHR0ZPfu3fn+7//+vPGNb8yBAweqLhcAAACA87SokOr666/P9ddfvywffMkll+TQoUMX9LPTdwIEAAAAYH1YM9P9AAAAAFi/hFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAAAAVE5IBQAAAEDlhFQAAPAsUJZl1SUAwFkJqQAA4FlgYmKi6hIA4KyEVAAA8CwgpAJgtRNSAQDAs4CQCoDVTkgFAADPAuPj41WXAABnJaQCAIBngeHh4apLAICzElIBAMCzQF9fX9UlAMBZCakAAOBZQEgFwGonpAIAgGeB/v7+qksAgLMSUgEAwDpVluXMc51UAKx2QioAAFinZi+WLqQCYLUTUgEAwDr12GP/P3t3Hh9leah9/PdMMllZQhKSAGHfCciiLLKD1upRSy1WPZ5W0J5j3aq2p/s5amu3U9u+Wnc/VXG37CgCgkjCToKyJ6yCbAESskD2zLO8fwymxiSYlSczub7/kNx5ZuZqP04yc829fF719dGjR90LIiIiUg8qqUREREREgtS+ffsAcNo7ZGZlupxGRETk4lRSiYiIiIgEqX379uGJ8OB0c/j8yOdUVFS4HUlERKROKqlERERERIJUZlYmVicLJ9bBtm0OHDjgdiQREZE6qaQSEREREQlCpaWlHD92HKeTA7H+sS+W/4mIiLRGKqlERERERILQnj17cBwHJ9aBSPBEedi1a5fbsUREROqkkkpEREREJMg4jsNrr7+GEWlAZ/+YmWyybt06jhw54m44ERGROqikEhEREREJMhs3bmTP7j1Ygy0I9Y85gxzwwgsvvuBuOBERkTqopBIRERERCSKmafLCiy9gtDdwejv/+kE4WAMttmzewo4dO9wLKCIiUgeVVCIiIiIiQWTFihUcP3Ycc6hZ49W+09/BiDJ47vnncByn9jsQERFxiUoqEREREZEgUVZWxsuvvAxxQLdaLggBa4jF/n37SUtLu8TpRERELk4llYiIiIhIEDBNk7///e8U5BdgXWaBUft1Ti8Ho6PBM88+w4kTJy5tSBERkYtQSSUiIiIiEuBKS0v55a9+yfLly7EH2RB/kYsNMK8wyTufx90/vJtdu3ZdspwiIiIXo5JKRERERCSA5eTkcO9995KRkYE9ysYZVo+9pmLBnG5SQgkPPfwQq1evbvmgIiIiX0MllYiIiIhIgNq/fz//9cP/4vPjn2NNtHD6NmAz9HZgTjOxOlk8/vjjvP7669pMXUREXKWSSkREREQkAG3atIkHfvQAheWFmNNMSGrEnYSDNcnC7mHzyiuv8Kc//Qmfz9fsWUVEROpDJZWIiIiISIBZuHAhv/rVr6iMqvQXVB2bcGch4IxxsFNsPvzwQ37y3z+hqKio2bKKiIjUV6jbAUREREREpH4yMzOZ89ocMtIzcLo62GPt5nlFb4AzxMGOttn16S7umHUHd3z/Dv7t3/6N8PDwZngAERGRr6eSSkRERESklduxYwevv/46n376KUa4gT3MxhnogNG8j+P0dDDbmeTtyuPJJ5/ktTde43u3f48bb7yRiIiI5n0wERGRr1BJJSIiIiLSCjmOw7Zt25jz2hx27dyFEWFgX2b7N0dvyVfxcWBNtSAXCvYW8Mwzz/DGm29w+7/fzowZM4iKimrBBxcRkbZMJZWIiIiISCviOA4ZGRnMeW0OWZlZGFEG9ggbp3cLl1NfZgAJYCX4y6pze8/xwgsv8OZbb/Lvt/073/nOd4iOjr5EYUREpK1QSSUiIiIi0go4jsOmTZuY89ocDuw/gBFtYI+8UE6FuBisM1idLciDoqwi/vGPf/D2O29z6y23cvPNN9O+fXsXw4mISDBRSSUiIiIi4iLbtlm/fj1zXpvD4c8OY7QzsC+3cXo5ress7jiwJ9mQDyV7S5gzZw7/nPtPbp55M7fccgsdOzbliEEREZEmlFTbt29n+fLlpKenk5OTQ3FxMTExMSQnJzNx4kRmzJhB9+7dmzMrAEeOHGH58uV8+umnHDlyhMLCQioqKggPD6djx4706NGDkSNHct111zFo0KBmf3wRERERkaZyHId9+/axZs0aPl7zMWdzz2K0N7BH2zg9Wlk59VWxYE+woRBK95by5ptv8u4/32Xc2HFcddVVjB8/nsjISLdTiohIADIcx3EacoOCggIee+wxVq5cedHrwsLC+MEPfsCDDz6Ix9P0v7KVlZX84Q9/YN68edi2Xa/bXHfddfz+97+nXbt2F71u4MCBNcb279/fqJzSNkyePBmAdevWuZxERIKJfreIBDfHcTh06FBVMXX61GkMj4GdaOP0dHC6tfJyqi7nwDhsEHIyBKfMwRvmZeKEiUyfPp1x48YRHh7udkIREQkQDZpJlZ+fz6xZszhw4MDXXltZWckLL7zAiRMneOKJJ5pcVP3sZz/jww8/bNBtVqxYQV5eHq+//nqzFGUiIiIiIg31+eefs2bNGlavXs2JEyfAACfBwbniQjEV5nbCJuoIzkgHc4QJZ8E+bpO2OY3U1FTCI8KZPGkyV111FaNHj8br9bqdVkREWrEGlVS//vWvay2oYmJi6Ny5M8ePH6e8vLzaz5YuXcrQoUOZPXt2o0N+8skndRZUMTExJCQkkJOTQ2FhYY2fZ2RkkJaWxvTp0xv9+CIiIiIiDXHixAnWrFnDR6s/4ujnR/2DCWCPsnGSHQjGyUUG0BmczhcKq1woO17G6nWr+eijj4iKjmLqlKlMnz6dUaNGERqq7XFFRKS6ev9l+Pjjj0lNTa0xfv/993PfffcRGhpKUVERP/3pT0lLS6t2zVNPPcUNN7xByX8AACAASURBVNxAfHx8o0KuX7++1vHHHnuM2267DY/Hg23b/POf/+S3v/1tjeu2bt2qkkpEREREWtSpU6dITU1l9cerOXTwkH8wHuwRF4qptrRNkwdIBCfRwbRNOAPFx4tZsXoFy5cvp32H9kybOo3p06czfPhwQkLcPL5QRERai3qXVO+8806NsZEjR/Lggw9Wfd++fXv+/Oc/M3XqVMrKyqrGy8rKWLRoEXfffXejQhYUFNQY69+/P7fffnvV9x6Ph9tvv5133nmHgwcPVru2pKSkUY8rIiIiInIxubm5pKam8vGaj9mbtdc/GAf28AvFVJS7+VoFD9AFnC4OpmXCaTh3/BxLly/l/fffJ6ZTDNOnTeeqq64iJSVF23SIiLRh9SqpCgoK2LRpU43xG264ocZYTEwMkyZNYtWqVdXGly1b1uiSqlu3bjXGSkpKcBwHwzCqxhzHqbWQ6tOnT6MeV0RERETky0zTZO/evWzZsoVNmzfx2aHPADA6GdjDLhRTFz+zp20LAbqB083BNE04BQXHC1j83mIWLVpEh44duHLclYwbN47Ro0fToUMHtxOLiMglVK+Sas+ePbWeqJeSklLr9UOHDq1RUh08eJDy8nIiIiIaHHLKlCk89dRT1TJkZ2fzyCOPcPfdd5OUlMSZM2d46aWXyM7OrnbbmJgYZsyY0eDHFBEREREB/we2GRkZbN68mfSMdEqKS/z7L8XjL6a6OdDe7ZQBKBToDnZ3G9tnY5wyKDxVyEdpH7Fy5UoMw2BIypCq0qp///7VPqAWEZHgU6+Sat++fbWOd+3atdbxxMTEGmOWZXHw4EGGDRvWgHh+gwYNYvbs2bz66qvVxufPn8/8+fPrvF3Xrl159tln6dSpU4MfU0RERETaJtu22bdvX9VsqYMHDuI4Dp5ID2aiiTPUgUQC/1S+1sQLTg8HeoDP8UE+GKcNsrKzyHw5k5dffplOsZ2qCqsrrriCdu00ZU1EJNjUe7lfbTp27FjreF2lUF33Ux+/+MUvSE5O5oUXXiA3N/ei13bo0IEHHniAmTNn6o+XiIiIiHytc+fOsXXrVrZs2cLmLZspOl/k/0Ec2ENsnC4OVozln0EVYIzP/aGdXo7LSerJAOLAiXMwU0wo9xdWeafyqjZe94R4GDZ0GFde6S+tevfurVlWIiJBoF4lVXFxca3jYWG1f3xU13hRUVE9Y9XuO9/5Do7j8OSTT9aZCeD8+fO8/vrrREdHc/PNNzfpMUVEREQk+Ni2zcGDB6tKqb1Ze/2zpSI8mAkmDPafTEe420mbLuBKqq+KuJC9F/6TAvPBPmWz6+gudu7cyYsvvkhcfBzjrxzPuHHjuPzyy4mK0o71IiKBqN6n+9XGcWr/Q1fXeFM+3diyZQs/+9nPyMnJqTYeHR1Nly5dOH36dLXi6uTJk/zP//wPW7du5f/+7//0yYqIiIhIG1dcXMwnn3xStYyvsKDQ/4NYsAfbOEkOVmxgzpZqMzxAPDjxDuYwE8r8s6zOnjrLBx9+wNKlSwkJDWHE8BGMGzeOcePG0aNHD70XEBEJEPUqqepaMufz+QgJCakxXllZ2aD7+TpZWVncfffdVFRUVI2Fhoby29/+lpkzZ2IYBo7jsGjRIh599FH/SSEXLFmyhFGjRnHrrbc26rFFREREJHAdP36cTZs2sXHTRnbt2oVt2RhhBlaiBf3ASXKg4ef6SGsRCU5vB6e34z9k6ax/ltW2Q9v49NNPee6550jqksTECRMZP348w4cPx+v1up1aRETqUK+Sqq49pgoLC0lKSqp1vCH383X+9re/VSuoAG677bZqS/kMw2DmzJlkZWXx1ltvVbv2tddeU0klIiIi0gaYpsnOnTvZvHkzGzZuIPuk/+Rno6OB1c/C6eJAHP4ZORJcPEACOAkOJiaUgHHK4NSpUyxcvJAFCxYQERnB2DFjGT/evzRQByyJiLQu9SqpBg0aVOt4dnZ2rSXVqVOnaoyFhITQv3//Bsbzz8pKT0+vMT5mzJharx89enSNkurw4cMUFxdrE3URERGRIFRYWEh6ejqbNm1iS/oWykrLMDwGdmcbZ6TjL6ai3U4pl1w0OP0cnH4OtmlDDpSeKmXd1nWsXbsWwzAYNHgQE8ZPYPz48fTt21fLAkVEXFavkmrYsGF4PB7/FNovyczMZNSoUTWuz8zMrDE2YMAAIiIaPpe6oKAAn89XY7yuPyB1jZeWlqqkEhEREQkCjuNw+PDhqtlSX2x6bkQaWEkXZksl0sTdVyWohAJdwenqYDomFPpnWe09vZe9L+/l5ZdfJi4+rmpZ4KhRowgPD4Jd80VEAky9/nTHxMQwfvx4NmzYUG182bJlfP/73682VlhYWOM6gOuvv77a9+np6dxxxx01rtu/f3+179u3b19rpoyMDK655poa41u3bq0xZhgGMTExtd6PiIiIiLR+FRUVbN++nU2bNrFh4wbO5p4FwIg1sAZfKKY6oU3P5esZQCdwOjlYQywo9xdWZ0+d5f1l7/Pee+/hDfNyxeVXMH78eK688koSEhLcTi0i0ibU+/Ol22+/vUb5tH37dp5++mnuu+8+QkNDOX/+PD//+c8pKyurdl1kZCQ33XRTowJGRUXRo0cPjh07Vm383XffJSUlhW9/+9tVs6eWLFnCu+++W+M+hgwZQlhYWKMeX0RERETckZ+fz8aNG9m0aRNbP9lKZUUlRqiBnWDjXH5hGV+k2ykl4EV8afN1y4Zc/+brW3ZvYfPmzQD06dunapbV4MGDtSxQRKSF1Lukuuqqq5g2bRqpqanVxp977jnefvttEhISOHbsGOXl5TVu+/DDDxMfH9/okN/5znd46qmnqo2Zpskvf/lLfv/735OUlMSZM2coKiqq9fZf3mBdRERERFqviooKNm3axIoVK8jIyMC2bYxoAyvZwunqQGeg5uHSIs0jBEjyn/poOiYUgZFtcPj0YQ6/eZg33niDbsnduO7a6/jmN79JYmKi24lFRIJKg1bq//GPf2TWrFkcOHCg2nhhYWGdJ/rdeOONtS7ra4gf/OAHrF69mj179tT4WXFxMYcOHarzthMmTNDJfiIiIiKtmOM4ZGZm8uGHH7L649WUlpRiRBlY/S2cHg50RMv45NIzgA7gdHCwBllQCcZJg5NHT/Lyyy/zyiuvMGLECK677jomT55MVFSU24lFRAJeg0qq2NhY3njjDR599FFWrVp10WvDwsK46667eOihh/B4mnbGb1hYGK+//jq/+c1vWLp0ab1u4/F4uPXWW/nlL39JSIg+bhMRERFpbc6cOcPKlStZ8eEKTp44iRFqYHW1cEZd2PhcxZS0JmH+ZYFWbwuKwThqsOPgDrZv387f/t/fmDZ1Gtdeey0jRoxo8vsfEZG2qsFnnnTq1IlnnnmGbdu2sXz5ctLT08nJyaGkpISOHTuSnJzMpEmTmDFjBt27d2+2oO3ateOvf/0r99xzDytWrGD79u0cPnyYc+fOUV5eTkREBDExMfTp04fLL7+cG264gR49ejTb44uIiIhI05WWlrJu3TpWrFjBjh07cBz/Ej77Chsn2QGv2wlF6qEdOCkO5hATzkLZ0TJWfrySDz/8kPiEeK775nVce+21zfp+SESkLTAcx3HcDuG2gQMH1hj76imDIl82efJkANatW+dyEhEJJvrdIsHKtm127NjBhx9+SGpaKhXlFRjtDKweFk5PB9q5nTC4edL8s3rsqbbLSYKc6d+/yjhqYJwxwPEf4HTdddcxffr0Ok8tFxGRf2nwTCoRERERkfo4ffo0S5cuZcXKFZzNOYsRZmB1s3B6ORCHlvNJcAkFp4fj30etzL8ccO+xvWT9LYu/P/13Jk2cxPXXX8/o0aN1OqCISB1UUomIiIhIsyoqKuKNN95gwcIFWJaFk+jgjHX8p/Pp1ae0BZHgDHIwB5pQAPZRm7RNaaSmppIyNIUfPfAjhgwZ4nZKEZFWRy8TRERERKRZ+Hw+Fi9ezJzX5lBSXILdy8ZJcUCHnklbZQCx4MQ6mMNNjM8NsrKyuOeee5g2fRo/vPuHdO3a1e2UIiKthkoqEREREWkSx3FYu3Ytz7/wPKdPnYZEsK60IMbtZCKtiAecPg5mdxPjgEHaujTWrVvHzTNv5o477tCeVSIiqKQSERERkSbYs2cPzz77LFlZWRgdDaxJFiSi/aZE6uK9cDJgHxNjj8HcuXP5YNkH3Dn7Tr797W8TFhbmdkIREdeopBIRERGRBjt58iQvvvgia9euxYg0sK+w/Ruiq5wSqZ9IcEY7WP0tSnaV8Oyzz7Jg4QLuvedepk6dqs3VRaRNUkklIiIiIvVWUlLCq6++yqJFi7ANG3uIjTNQG6KLNFoMWJMtOA1ndp/hscceY8iQITz44IPaXF1E2hyP2wFEREREJDAUFhbywI8eYP6C+fh6+DCvNf0bo6ugEmm6JDCvNrGvsNl7ZC/3P3A/69evdzuViMglpZJKRERERL7W2bNnuf+B+zl85DDWBAvnCgci3U4lEmQMcHo7mNeYWB0tHnnkEVavXu12KhGRS0YllYiIiIhcVHZ2Nvfdfx8nTp3AnGhCF7cTiQS5MLAmWdhxNr/73e9YunSp24lERC4JlVQiIiIiUqejR49y3/33cSb/DOYkExLcTiTSRngvFFWJNn/5y1+YO3eu24lERFqcSioRERERqdXBgwe5/4H7KSgpwJxsQpzbiUTamBCwJ9g4yQ7PPfccc+bMwXEct1OJiLQYlVQiIiIiUkNWVhY/evBHFJlFmFNNiHE7kUgb5QF7rI3dy2bOnDk8//zzKqpEJGippBIRERGRakpLS/nfR/6XMqMMc4oJ7d1OJNLGecC5wsHuazN37lzWrl3rdiIRkRahkkpEREREqnn99dc5m3sWc7QJ0W6nERHAf/LfCAcjxuCpvz9FaWmp24lERJqdSioRERERqXL48GHmzpuL3duGeLfTiEg1HjBHmeTn5TNnzhy304iINDuVVCIiIiICgOM4/PVvf8UJdXCGac8bkVYpDuzeNvPnz+ezzz5zO42ISLNSSSUiIiIiAHz44Yfs2b0Ha5gF4W6nEZG6OMMcnDCHv/z1L9i27XYcEZFmo5JKRERERDh//jzPPvcsxIPTS7OoRFq1cLCGWmRlZrFixQq304iINBuVVCIiIiLC4sWLKTpfhDXSAsPtNCLydZxeDsTBq3NexbIst+OIiDQLlVQiIiIibZxpmixeshgSgRi304hIvRhgDbDIzclly5YtbqcREWkWKqlERERE2riNGzeSn5eP1VezMUQCSlcwogwWL17sdhIRkWahkkpERESkjVu8eDFGtAFd3U4iIg3iAauXRUZGBidOnHA7jYhIk6mkEhEREWnDjh49yrZt27B6ay8qkUDk9HHAA++9957bUUREmkwllYiIiEgbtmTJEgyPgdNbJ/qJBKRIsLvafLDsA8rLy91OIyLSJCqpRERERNoo0zRZuWolVjcLItxOIyKN5fRxKCkuYfPmzW5HERFpEpVUIiIiIm3Uzp07KS4qxknWLCqRgJYARoTB2rVr3U4iItIkKqlERERE2qi1a9dihBqQ5HYSEWkSA6wuFhs3baSiosLtNCIijaaSSkRERKQNsm2btLVp2Ik2hLqdRkSaykl2qCivYOvWrW5HERFpNJVUIiIiIm1QZmYmhQWFWuonEiwSwAgzWLdundtJREQaTSWViIiISBu0du1a/6l+XVRSiQQFj3/J37r16/D5fG6nERFpFJVUIiIiIm3Q5i2bsTvb4HU7iYg0F6erQ2lJKfv27XM7iohIo6ikEhEREWljCgsLOX7sOE5nzaISCSqd/f/s2rXL3RwiIo2kkkpERESkjdm9ezeASiqRYBMORgeDnbt2up1ERKRRVFKJiIiItDG7du3CCDGgk9tJRKS5WXEWu3btwrZtt6OIiDSYSioRERGRNmbHzh04nRwIcTuJtDgHKAPOg/GZ4f9egls8lJaUcuTIEbeTiIg0mEoqERERkTakrKyMgwcPYsdrlkVbYBw2MIoNjAoDzzYPxmHD7UjSwr5Yxrtzp5b8iUjgUUklIiIi0oYcPXoU27JxYjWlpi0wso2Lfi9BKAo84R4+++wzt5OIiDSYSioRERGRNuTUqVP+L6LdzSGXiPU130vwMcCOtsnOznY7iYhIg6mkEhEREWlDqt64qqQSCVp2tM2JkyfcjiEi0mAqqURERETakFOnTuGJ8IDX7SQi0mKiITc3F9M03U4iItIgKqlERERE2pDs7GzsKG2aLhLUosG2bHJzc91OIiLSICqpREREWhnH0YbW0nJOZJ9QSSUS5Jxo/98R7UslIoFGJZWIiEgr4/P53I4gQexc4TmIcDuFiLSoC8/xc+fOuZtDRKSBVFKJiIi0MpWVlW5HkCDm8/kgxO0UItKiLjzH9aGHiAQalVQiIiKtjN5USEtxHAfTZ6qkEgl2F97l6UMPEQk0KqlERERaGb2pkJZSVYDqFaBIcLtQROvviYgEGr1EERERaWX0pkJaStV/W5pJJRLcVFKJSIBSSSUiItLK6E2FtJSq/7b0ClAkuGm5n4gEKL1EERERaWXy8vLcjiAiIiIicsmppBIREWkFTNOs+vr06dMuJpFgFh4e7v/CdjeHiLQwy/9PWFiYuzlERBpIJZWIiEgrkJubW/X1mTNnXEwiwazqDavlbg4RaWEXimiVVCISaFRSiYiItAJfnj116tQpF5NIMAsNDcUwDJVUIsHuwnO8avakiEiAUEklIiLSCnxRUnUKtzmj5X7SQgzDINQbquV+IsFOy/1EJECppBIREWkFvljiNzDG5PSpbJfTSDALCwvTTCqRYKflfiISoFRSiYiItAL79u0jPhK6t7M4m1/A2bNn3Y4kQSosXCWVSNC7cBaHlvuJSKBRSSUiIuKy3NxctmzZwriEcsYmVuI4DsuWLXM7lgSpiPCIqjewIhKkLhTRERER7uYQEWkglVQiIiIuW758ObZtM7VbBUlRNimxJh8sfR/L0nQXaX6RkZEYluF2DBFpSReKaJVUIhJoVFKJiIi4yLIslr7/HkNjTZKi/JuITO9WzpmcXLZu3epyOglGUZFRmkklEuS+KKIjIyNdTiIi0jAqqURERFyUkZFBTu5Zpncrrxq7vLOPDuHw/nvvuZhMglVERIRmUokEO+1JJSIBSiWViIiIi9577z06hsOozr6qsVAPTOlSxqbNm8nNzXUxnQQjLfcTaQO0J5WIBCiVVCIiIi45ceIEWzZvZnKXMkK/8hd5atdKbNtm8eLF7oSToBUWFoZhq6QSCWoXSirNpBKRQKOSSkRExAXZ2dn8+OGHiAyFq5Iravw8McpmXGIlb731Fu9p2Z80I6/XC7bbKUSkRV14jnu9XndziIg0UKjbAURERNqaEydO8NCDP6LsfD6/HHmO+Ain1ut+mFJChWXwt7/9DdM0mTlz5iVOKsHI6/VWzbIQkSB14TkeGqq3eyISWDSTSkRE5BI6duwYP3rgfsrP5/Grkefo3aHutsDrgYcuK+byzpX8/e9/Z968eZcwqQSrsLAwlVQiwc6GUG8ohqGlvSISWFRSiYiIXCKff/45D/7oAXwlBfx61Dl6tv/6piDUAz8aVsKYhEqeffZZ3nnnnUuQVIKZ1+vFsWufvSciQcLWUj8RCUya/ykiInIJfPbZZ/z44Yeg4jz/M+oc3aLrvylQqAfuH1qCJxNefPFFfD4fs2bNasG0Esy8Xi+OpZJKJKhZWuonIoFJv7lERERa2MGDB/nxww8R4ivmVyPP0bUBBdUXQjxwb0oJIYbDK6+8gmVZ3HnnnVrKIQ0WHh4ODv6NlTWnXiQ42TrZT0QCk0oqERGRFlJSUsKiRYt4+623iKCMX486R1JU449VC/HAD1NK8Rjw2muvcejQIe666y769evXjKkl2EVERPi/sFBJJRKszC8910VEAohKKhERkWb2RTn1z3ffoai4hJHxPr4/sJSEyMYXVF/wGPBfQ0pJirL5IH0jGzZsYPLkycyePVtlldRL1ewKE9CWNSJBybAMItqppBKRwKOSSkREpJnUVk7dNKSMPhc5wa8xPAbM6F3O1ckVfHgsnA83r2fdunUqq6ReqkoqnfAnErwsiIyIdDuFiEiDqaQSERFpoktVTn1VtNdhZt9yru2hskrqr9pyPxEJSoZlaLmfiAQklVQiIiKN5FY59VUqq6Qhqi33E5GgZFiGNk4XkYCkkkpERKSBvlpOjYj3cdPgMvp2dHdqisoqqY+OHTv6v6h0N4eItByj0vjXc11EJICopBIREamnwsJCli5d2urKqa+6WFl1++23M3jwYAzDcDumuCQ2NhYAo9zAwXE5jYg0OwfsMrvquS4iEkgaXVJt376d5cuXk56eTk5ODsXFxcTExJCcnMzEiROZMWMG3bt3b86s1eTk5LBixQo2bNjAkSNHyMvLw7Zt4uLiiI2NpX///owdO5Zx48aRlJTUYjlERCS45efns27dOtJSU9mxYwe247Tacuqr6iqruiQlMnXadKZMmaLCqg3q1KmT/4tyd3OISAupABxUUolIQDIcx2nQR2gFBQU89thjrFy58qLXhYWF8YMf/IAHH3wQj8fTpJBfVllZyXPPPcdrr71GefnXv7oaNGgQ77333kWvGThwYI2x/fv3NzqjBL/JkycDsG7dOpeTiEhLOHv2bFUxtXPXLhzHoUu0w5iEcsYlVtK9ne12xEYp8Rl8kuMlIyeMPfleLAcSO8czZdp0pk2bxuDBg5v1b7a0Xtdedy3FXYpxRmomVbDzpHkwcv9VRDudHeypgfk7TOrpHISsCuHxxx9n6tSpbqcREWmQBs2kys/PZ9asWRw4cOBrr62srOSFF17gxIkTPPHEE83yovf8+fPcd999bN26tcn3JSIi8mU5OTmsW7eO1NQ17NmTieM4dGvn8O1e5YxJrCQ52ibQJxxFex2mdKtkSrdKSnwGn+Z6ycjxsXDBPObNm0fn+DimTJ3GtGnTSElJUWEVxGJjYykpL9FyP5FgdOFzfM2kEpFA1KCS6te//nWtBVVMTAydO3fm+PHjNWY3LV26lKFDhzJ79uwmBbVtm/vvv7/Ogqpz587ExsZSXFxMTk4OPp+vSY8nIiLB78yZM6xdu5a01DXsycwCoHt7m+/0rmBMQiXdAnTGVH1Eex0md61kctdKSk3YlhtGxplK3lu0gAULFhAX26lqSeCwYcMICQlxO7I0o/i4eE4cP+F2DBFpAUaZ/xOVqqW9IiIBpN4l1ccff0xqamqN8fvvv5/77ruP0NBQioqK+OlPf0paWlq1a5566iluuOEG4uPjGx305ZdfJiMjo9qYx+PhP/7jP5g1a1a1/a8cx+HYsWOsX7+eEyf0AkxERP7l1KlTpKWlkZaWyt69+wDo2cHmu30rGJ1QSdfo4C2m6hIVChO7VDKxSyWlZgk7znrJOFPJ+0sWsnDhQmI7xTB5ylSmTp3K8OHDVVgFgS5durDrwC4sWve+aiLSCCVgGAaJiYluJxERabB6l1TvvPNOjbGRI0fy4IMPVn3fvn17/vznPzN16lTKysqqxsvKyli0aBF33313o0KWlZXxyiuv1Bh//PHH+e53v1tj3DAMevbsSc+ePRv1eCIiElxOnjzpL6ZS17D/wEEAenewuaVfOWMSfCRFtb1iqi5RoTA+ycf4JB/lZgk78vyF1fKlS1iyZAkxHTtUFVYjRowgNFQHBQei5ORk7FIbTHTWs0iwKYb4hHjCwsLcTiIi0mD1ellSUFDApk2baozfcMMNNcZiYmKYNGkSq1atqja+bNmyRpdUH3zwAYWFhdXGRo8eXWtBJSIiYlkW+/fvJyMjg/Xr1nLw0GcA9O1oc9uFYipBxdTXigiFcYk+xiX6KLdK2HXWS0ZOJSuXL+X999+nQ/t2TJo8hXHjxnH55ZfTrl07tyNLPXXr1s3/RTEQ42oUaWk+iIyM5Prrr2fZsmWU+krdTiQtzFPsoUfvHm7HEBFplHqVVHv27MG2a76YT0lJqfX6oUOH1iipDh48SHl5OREREQ0OuXHjxhpjN9xwA1u2bGH+/Pls27aN3NxcwsPD6dKlC2PHjuW2226jf//+DX4sEREJTHl5eWRkZJCRkcHWjHTOFxVjAH07Wtzev4IxCT7iI1VMNVZECIxJ9DEm0UelVcLOPC9bcypYs2o5y5Ytw+PxkJIyhLFjxzF27Fj69++vjddbseTkZP8XKqmCnw+uv/76qtUP81fMdzmQtDRPiedfz3ERkQBTr5Jq3759tY537dq11vHa1j9blsXBgwcZNmxYA+L5bd++vcbY22+/XWMTd5/Px8GDBzl48CBvv/02d955J//93/+tpQgiIkHI5/OxZ88eMjIySN+ymUOfHQagYzhcFlvBZT19DIs1aR+m08uaW1gIjE7wMTrBh2mX8tn5EHad9bLr6C5e3r2Hl19+mZiOHRg9Zixjx45l9OjR2sC3lfniDaxRbOiEv2Dn9a9ogAv/hrucR1pWJdgVtkoqEQlY9V7uV5uOHTvWOl7XC9G67udiLMvizJkzNcZrO2XwyxzH4dVXX6WwsJA//elPDX5ckfpwHAcj0M+kFwkg2dnZbN26lfT0dD79ZCtl5RWEGNA/xuSWfpUMjzPp3s7CE6BPy/XZ/v1DJnWtdDlJ/YV6YGCMxcAYi+9SzrlKg915XnbnVZC+bjUfffQRAAMG9Gfs2HGMGTOGlJQUfYDksqioKDrGdKSguOGvzSTAeKGssIwFCxb4v9eq3OBW7P+nakmviEiAqdcrxOLi4lrH69qMr67xoqKiesb6l/Pnz+M4dX/C5/H4p7MWFxeTn59f4+eLFi1i2rRpXHPNNQ1+bJGvY9u2TrkSaUHl5eXs2LGD9PR0MrZs5vjJbADiI2F8XAXD4nwMifURFSR9x9oALKm+qmOYU3VSD+MWBgAAIABJREFUoO2UcrQohF15Xnbm7OXttw7y5ptvEhUZyRWjRzNmzBjGjh2rE6hc0q1bNwpzCzWTSiSIGMX+T2nqWvEiItLaNellfV3lUV3jjZlxUllZ9wv1QYMG8fzzz1d9UrB69Wp+8pOfUFFRUe26f/zjHyqppEWopBJpXo7jcPToUdLT00lP38LOnTvx+Uy8ITA4xseUAT4ui/PRJcpGkxhbP48BvTtY9O5gMaN3OSU+g6yCUHblVbBr6zrWrVsHQM8e3Rk77krGjBnD8OHDCQ/XeqRLoWuXruw7tg8b7dUmEjQu7IuflJTkbg4RkUaqV0lV12k9Pp+v1jfodRVLjTn1Jzo6us6fPfLII9Wmsl599dXMnDmTd955p9p1u3fvprCwkJgY7QwqzcuyLLxer9sxRAJaUVERn376qX/T8/TN5OTmAdC1ncNVXSoYHudjYIxJmPrggBftdar2snKcUrJLPOzK87Ir/zCLFxxn3rx5hHm9jBg5krFj/ftZde/eXcuqW0iXLl2wS2xwAP1fLBIcSqB9h/ZERUW5nUREpFHqVVLVtcdUYWFhrS19YWFhg+7nYqKjowkNDcU0zWrjXq+XUaNG1bh+zJgxNUoqx3E4deqUSippdrWdeikiX+/kyZNs3LiRDevXs2v3bmzbJtJrMDSmghsH+xgW5yM+QkuQgplhQLd2Nt3aVXBdzwoqLNhXEMrOPC+7M9PJyMjgmWeeoUtSIhMmTmLChAkMHz5ce1k1o6SkJLCBMkDvZ0WCglFi0LWLlvqJSOCq1yu9QYMG1TqenZ1da0l16tSpGmMhISH079+/gfH8SwT79u3L/v37q43HxMTUerR1XFxcrffz1SWAIs3Bsiy3I4gEBNu22bdvHxs3bmT9urV8fvQYAMntHa7vUc7wOJN+HU1Ca/5alzYiPASGx5sMjzeBMnLKPOzKC2XH2RO8t2gBCxYsoF10FFeOn8CECRMYO3bsRWdby9fr0qWL/4sSVFKJBImQshC6DlFJJSKBq14l1bBhw/B4PDVmjWRmZtY6mykzM7PG2IABA4iIiGhUyMsuu6xGSVVYWIht2zWKqry8vFrvo67ySqQpSktLad++vdsxRFqliooKtm3bxoYNG9i4YT35BYV4DBgYY/K9AZWMjPeRGKXZiFK7hEibq5MruTq5knITdud72ZZbwZa1/hMDQ0NCGDlqJBMvzLJKSEhwO3LA+WLDeqPEwOmsmYsiAc8Bp8TRflQiEtDqVVLFxMQwfvx4NmzYUG182bJlfP/73682VlhYWOM6gOuvv77a9+np6dxxxx01rvtqGQVw7bXXMn/+/GpjPp+Pbdu2ccUVV1Qbz8jIqHH72NhYHcMqLaK4uFinUol8SWFhIZs3b2bDhg1szcigvKKCiFCDy2IrGJXiY0S8j3ZevRmWhokIpWovK9sp5UBhKNvOetmWtZUnt37Ck08+yYD+/Zg4aTITJkygX79+2seqHqq2QQjcwyRF5MsscCxHW5yISECr98YOt99+e43yafv27Tz99NPcd999hIaGcv78eX7+859TVlZW7brIyEhuuummRoecMGECPXv25OjRo9XGf/e739U43W/hwoU1bv/Nb36z1qWBIk1VVFTkdgQR1504cYINGzawYf169uzZg+04xEbAhM7ljIr3MSTWxKtfwdJMPAYM6mQyqJPJv/crI7vUw7ZcL9ty9zPn1UO8+uqrJCZ0riqsRowYoX2s6hAdHe0v81RSiQSHC89lzfIXkUBW71dtV111FdOmTSM1NbXa+HPPPcfbb79NQkICx44do7y8vMZtH374YeLj4xsd0jAMfvOb33DnnXdWG9+3bx9XX3013bt3p6ioiPz8/Bq3jY6O5t577230Y4tcTElJidsRRC4527bJysq6sPH5Oo4eOw5Aj/Y23+pVweWdffRqb6GJLNLSDAO6Rdt0i67gxl4VnKsw2H7Wy6e5lby/ZCELFy4kOiqSseOuZNKkSYwdO7ZRJw0HK4/HQ1R0FEU+feAiEhQulFT6PScigaxBHy3+8Y9/ZNasWRw4cKDaeGFhYZ0n+t144421LutrqPHjx/PjH/+YJ598stq4bds1Zlh9wev18tRTT2k5lrSY4uJityOIXBKmaZKRkVG1v1RB4TlCLsxo+f6ASkZ19tE5UvtLibs6hjtM7VbJ1G6VVFgl7Mnzsu1sBZ9sXMOaNWsICfEwYsRIJk6cyNSpU7VfJf43s0WVKqlEgoLP/49mUolIIGtQSRUbG8sbb7zBo48+yqpVqy56bVhYGHfddRcPPfRQsy21u+eee4iLi+Mvf/kL586du+i13bt3569//SsjRoxolscW+cKXT4pUSSXBrrCwkKVLl7Jk8SJyz+YR6TUYHlvBqKGVDI8zidb+UtJKhYfA5Qk+Lr+wj9WhcyFsyw3j032f8PdPP+W5Z59l6rRpzJw5kyFDhrTZPaw6dOjA6fOncdBzWSTgabmfiASBBm/S0KlTJ5555hm2bdvG8uXLSU9PJycnh5KSEjp27EhycjKTJk1ixowZdO/evdkDf/e73+Ub3/gGS5YsIS0tjcOHD1NQUEBoaChxcXFcdtllTJ8+nWuvvVZ7UEiL+PISP5VUEqz279/PwoUL+fjj1fh8JkNjTb53WTnD432Ean8pCTAeAwbEWAyIKeO2/mWcLPGQeiKctWs/ZvXq1Qwc0J+bv3sL06ZNIywszO24l1SH9h0w8tpmQScSbIxK/3NZy/1EJJA1usUZNWoUo0aNavQDjx07ttaT/OojJiaG2bNnM3v27EY/vkhjZWdn1/q1SKAzTZO1a9eyaOECdu/JJDzUYEpSGd/oXkG3aC3lk+DRLdrmewPLmNm3jA2nwvno5AH+8Ic/8Pyzz/Ctb9/EjBkzmrSXZiCJiorCsFRSiQQF0/9PdHS0uzlERJpAU41EGigzMxMAKzqe3Xv2uJxGpOkKCgp4//33WbJ4EXn5BSRGOXxvQBmTulRqOZ8EtchQ+Eb3Cq5OrmBPfiirjvt44/XXeeutN5kyZSozZ85k6NChQb0UMCoqCsMM3v99Im3KhZIqKirK3RwiIk2gkkqkgfbs2YMR0R6rUy9OHP+E8+fP06FDB7djiTTYvn37WLhwIWs+Xo3PtBgWZzJ7RBnD40w8es8qbYhhwLA4k2FxxZwp9bD6RDhr16eyZs0aBvTvx8ybv8v06dMJDw93O2qzi4yMrHpjKyIBzoSQkBC8Xq/bSUREGk0llUgD7d6zB190Z6x2CQBkZWUxbtw4l1OJ1I/P52Pt2rUsXDCfzKy9RIQaTL2wpK+rlvSJkBhl8x8DypjZp4yNp8NYdeIgf/rTn3j+uWf51oxvM2PGDBISEtyO2WwiIyNxfJoxKRIUTIiIjHA7hYhIk6ikEmmAnJwc8vPysHr2x27XGQyDzMxMlVTS6lmWxbx585g395/k5ReQFO3w/QFlTOpaQZT+EojUEBEKVyVXMr1bJVkF/qWAb735Jm+//TZTpkzh3nvvJSkpye2YTRYVFYVjOWADOhRBJLCZEBGhkkpEApvemog0wBf7UdntEiHEixMVyx7tSyWt3JkzZ/jd44+za/duhsX5uGtEOcO0pE+kXgwDUmJNUmKLySnzLwVcsz6NjPQt/Oznv2D69OluR2ySqr1rfEDwrWYUaVMMn6FN00Uk4KmkEmmAzMxMDE8odlQsAGZ0ZzKzsrAsi5CQEJfTidSUlpbGE3/+P8yKMu5JKWFil0q3I4kErIRIm9v7l3F1twqey2zHb37zG7Zu3cqDDz7o39spAFWdYliGSiqRAGeUGST0CZ7lyCLSNmlit0g9mabJ5s1bsKLjweMvpOx2iZSXlbFz506X04lUV15ezhNPPMGjjz5KYmgxfxhTqIJKpJkkRNk8cvl5vtWrjOXLlvGfP7iLAwcOuB2rUTp37uz/oszdHCLSdJ5yT1DtmScibZNKKpF6mj9/PsePH6MyKaVqzIztBRHtefLJp/D5fO6FE/mSQ4cO8V//+QOWffABN/Yq45HLz5EYpU3RRZpTqAdu6VfOr0YVUXz2JPfe80PmzZuHbQfWc+2LN7RGqdb/igQ0G+xSWyWViAQ8lVQi9XD69GleefVVrJgeWJ16/esHIV7Ke4zj6NHPmTt3rmv5RAAcx2HBggX88O7/4lzOcX4xqohb+5UTqt/0Ii1mSKzJH8cUMiymnGeffZaf//xn5Ofnux2r3mJjYzEMQzOpRAJduf+fqtmRIiIBSm9dRL6G4zg8+dRT+Eybil5X+nfR/RKrU0/MTj2Z89prZGdnu5RS2rrCwkJ++Ytf8PTTTzM0ppw/jilkaKzpdiyRNqF9mMOPhxcza2Ap2z/Zyp2zZ5GRkeF2rHoJDQ2lU1wnKHU7iYg0yYXnsGZSiUigU0kl8jXWr1/P5k2bKO82Eie8fa3XVPYcj2k7/L8nn8RxnEucUNq6M2fOcOfsWXySsYU7Bpbyk+HFdAjTf4cil5JhwDe6V/D4mHNEm4X89Kc/ZfHixW7HqpeuSV3xlOgloUggM0r8H6ImJia6nEREpGn0ikTkIkpLS/3FU3QcZuLQOq9zwqMp73Y5GenppKWlXbqA0uaZpslvHnuU0vOFPHbFea7pXvHVyX4icgl1b2fz+OhCRsT7eObpp8nKynI70tfq168fxnkD1G2LBK5C8Hq9JCcnu51ERKRJVFKJXMQrr7xCfl4+5T0ngOfiTxczcQhOdDxPPfV3iouLL1FCaeteeuklMrP28p+Di+jVwXI7jogAYSFwb0oJncItHnvkfzl//rzbkS5qwIABOJUOlLidREQay1PgoW+/voSGhrodRUSkSVRSidRhx44dLFiwAF/CQOz29Vjfb3go7zWBgsICnnnmGSxLhYG0rPXr1zN37ly+kVzO2ESdLinSmkR7HR5IOc/ZvLP84Q+/b9Wn/g0YMAAAo0DTMEUCkgPGOYNBAwe5nUREpMlUUol8hW3bvPvuuzz84x/jhLensvvo+t+2XWcqu1zGihUr+MlPfsLZs2dbMKm0ZdnZ2fzpj3+gdweb2wfoWC6R1qhvR4v/6FfK5s1bWvUJsL179/bPvihwO4mINEoJOJVOVeEsIhLIVFKJfElhYSE/+/nPeeGFF6js0J2SlBkQGt6g+/AlX0FFn8ns2LWH2bPvDJgTniRw+Hw+fvPYo9iVZfxoWBFe/SYXabW+0b2CMQmVvPTSS+zevdvtOLXyer307tNbM6lEAtQXz12VVCISDPTWRuSC7du3M2vWbD755FMqeo2nov9VDS6oADAMzM4DKEn5FufNEH7605/ywgsvYJpm84eWNun5559n3/4D/NfgIhIiW+8SIhHxn/r3n0NK6Bxh8dijj1BYWOh2pFoNGjgIT6FHm6eLBKICCA0NpXfv3m4nERFpMpVU0uZZlsWrr77Kww8/TEG5TemQb2EmDqGpR6Q5kZ0oSfkWvoRBvPvuu9x//wOcOnWqmVJLW5WVlcXChQu5tns5oxO0D5VIIIgKhQeGFlFYkM9LL73kdpxaDRkyxL95us79EAk4nnwP/Qf0x+v1uh1FRKTJVFJJm5abm8tDDz/Ma6+9RmVcP0pSZmBHxzXfA3hCqew9kfJ+09l38BB33nUXa9eubb77lzZn7ty5RHkNZvbVPlQigaR3B4spXSpYtWol+fn5bsepISUlBQAjT0v+RAKK7V/uNzRlqNtJRESahUoqabM2b97M7DvvZPeeLCr6TKGy7xQIaZlPoKy4PpSkfJsSI4pHHnmEJ598koqKihZ5LAlep06dYm1aGtO6lhGpE6ZFAs43e5Tj85ksWbLE7Sg19OjRg8ioSMhzO4mINMg5cEyHIUOGuJ1ERKRZqKSSNsfn8/Hcc8/xi1/8gvOWl5KUGZid+7f44zoRHSgdfAO+pGEsXryYH/7wHo4dO9bijyvBY+HChRg4XNO93O0oItIIXaNtRsb7WLxoYav7oMLj8ZAyJIWQghC3o4hIA3wx+/GL2ZAiIoFOJZW0GUVFRbz77rvceuttzJ07F1/CYEqH3IgTGXPpQnhCqOw5lvIB13Dk+ElmzZrF73//e/bv33/pMkhAKi4u5oOl7zM2sYK4CO1sLBKo/q1nOefOF7Fy5Uq3o9SQkpKCU+iAzvkQCRz5ENMphsTERLeTiIg0Cy0YkaB39OhRFi5cyPIVK6isqMDq0AXfwGuxYpJdy2R16kFJ9E14s3fx0ZpUVq1axbBhl3HLLd9l4sSJhITok2yp7oMPPqC0rJzrhrWu2Rci0jCDYkx6d7CZ+893ueGGG/B4Ws/nhUOGDPGf7lcIxLudRkTqI6QwhCEpQzCaeOCPiEhroZJKgpLjOGzdupV58+eTkZ6O4QmhMq4vvqQUnKhm3Bi9CZywaCp7XUll8uWE5u5n98Esdj/yCAmJidw8cybXX3897du3dzumtAKmabJg/jwGdTLp3cFyO46INIFhwHU9Snl+z0m2bNnC+PHj3Y5UpU+fPgAY5wyceM3YFGn1LHDOO/Tt29ftJCIizUYllQSV8vJyVq5cybz58zl+7BhGWBSVyZfjSxgE3ki349UuNAyzyzDMpBRCCo5x+kwmzz//PK+88irXX/9vzJw5k+7du7udUly0e/ducnLPctsw7UUlEgzGJPh4Kxw++uijVlVSJSQkEBEZQen5UrejiEh9FAPOvwpmEZFgoJJKgkJOTg6LFy9myXvvU1JchBMdT2WfKZhxfcATIEvnDA9WbC/KYnvhKTmL73Qmi5YsYdHixVw5bhy33HILo0aN0nTuNigjI4MQA4bG+dyOIiLNINQDl3WqYGtGOpZltZol3oZh0Lt3b7LOZuGgmVQirZ1xzv+asFevXu4GERFpRiqpJKBlZmYyf/580tLSsB0HM6YnvsFTsNsn+tdUBCg7Op7KvlPwdR9NaM5etny6g82bN9OzVy9uveUWvvGNbxAeHu52TLlE0rdspn+MSZR+Y4sEjWFxJhtOF3PgwAEGDx7sdpwqfXr3Yf/h/djYbkcRka9zDjwhHnr06OF2EhGRZqO3PBJwTNNk7dq1zJ07j3379mKEhlGZkIIvaQhOeHDt4eSEReFLvhxf1+GE5h3m8zOZPPHEEzz/wovc9O0Z3HTTTcTHa3fbYJaXl8ehzw5zS1/NohIJJsPifBj4Z0q2ppKqd+/e2OU2lAMRbqcRkYsxzht069YNr9frdhQRkWajkkoCxpEjR0hNTeX9pUvJz8uDyI5U9LwSs3N/CAlzO17L8oRidh6AGd8fT9EpzNOZvPnmm7z9zjtMnTKFa665hiuuuIKwsCD//6EN2rp1K+B/QyvBzXGgoMJDmWnw8YkwpnerDOQJofI1OoQ59Opgk5GRzqxZs9yOU6Vnz57+L4pQSSXSynmKPfQe0dvtGCIizUollbRajuNw5MgR0tLS+HjNGo4fOwaA1bEbvgHXYMV0D+glfY1iGNgdulLRoSuV5efxnskidf1G1qxZQ2RkFJMmTWTq1KmMHj1aywGDREZGBh3CoWd7neoX7D4+GcaZMv/eRHP2ReMAVydXuhtKWtSw2Ao+yMyiuLiYdu3auR0HgMTERACMMkP7Uom0Zg5Q+q/nrIhIsFBJJa2K4zgcPny4qpg6cfw4AHaHLvh6jseK7YUTFuVyytbBiehAZc9xVHYfTcj5bHz5R/godR2rVq0iIjKSSRP9hdWYMWNUWAUox3HYmpHOsE4VeNpYH9sWbc8Nq/G9Sqrgdlmcyfuf22zbto3Jkye7HQfwn/AHgA74E2ndfOCYzr+esyIiQUIllbjui2IqNTWVj9ekcvLEcTAMrPZJmL3GY3VSMXVRnhCsmO5YMd2ptK2qwmp12jo++ugjIiIjmThhAtOmTVNhFWDy8/M5d76IvkmaRdUWVFgX/16CT58OJuBfzt5aSqqoqCiioqMoLi12O4qIXMyFIlkzqUQk2KikElc4jsNnn31Gamoqa9akcvLkiWrFlBnbC7wqphqsWmFlXyisDvPx2g2sXr2a8IiIqsJq7NixKqxauezsbAASotRWiASjsBCIjTQ4efKk21GqSUhIoKSsRMv9RFqzCyWVZlKJSLBRSSWXjOM4HDp0qGopX/bJkxeKqS6YvSZgxvZUMdWcPB6smGSsmOQvFVb/n737DpOyvvf//7zvKbuzdZbtlbI0gZUmnQUUJYUVsERjCRo0JjY00a/5xpzEmHNdMeV49KR80zSWxJITf0ZRrEGadAWlSFV6X1iWLdPn/v0xLEoAXWCWe2Z4Pa7LS/Z23HmlzOzer3l/Pp/NvDNvAbNmzSItPZ1RI0dy4YUXMnz4cBVWCajtxrXYo6PgRVJVUXqInTt22B3jGCXFJWxdv5Uoeu8RSVSGL7YPgEoqEUk1KqmkQ1mWxcaNG48WU7t37YoVUzltxVQXcHnsjpn6jimsRmE27SJ0YDOz5y/knXfeIS0tnVGjRjJu3DiGDx9OerqOdEoEO3fuxDCgUCWVSMoq9kRYtXO73TGOUVhYiPGBNsJLGY4v+FqSUyuYpkleXp7dSURE4kollcSdZVls2LDhSDE1mz2724qpMsJdRxPO65z0xZRz/0YAwoU9bE5yGkyTaG4FwdwKgtYozMO7CR3czOx3Fx0trEaOHHF0wkqFlX127txJgQecpt1JRKSjFHuizN3VSGtrKxkZiTFNnJ+fT9QfhSig95+kZ5VZGHuMY76WFOCHXG8uDodaRxFJLSqpJC6i0SgfffQRc+fOZc6cuezdu+ffiqku4EqdssO5fz2QpCXVZxkm0dxygrnlBK2RRwurOQsWM3v2bFxuNyOGD2fs2LGMHDmSzMxMuxOfU3bu3EFResjuGCLSgdr2nNu9ezfV1dU2p4kpKCiI/cEPJEZvJmfA6mZhbbBip8H1tbC6qaRKBYbfoLCw0O4YIiJxp5JKTls4HGblypWxYmruPBoOHogtK8spI9y19sjEVOoUUynvuMJqD6GDm5m/5H3mzZuHw+lkyAUXMHbsWEaPHk1ubq7diVPent276Z+hpX4iqawwPfYaT6SSKj8/P/YHlVSpwQA8sb+sahVUqcIMmBTkF9gdQ0Qk7lRSySkJhUIsX76cuXPnMnfePJoOH8ZwOAnllBOuriHirQKn2+6YcqYMk2huGcHcslhh1bwX58EtLP5gDYsXL+ZXv/oVAwYMYNy4cdTW1n56QyNx5ff7Sc/WDYVIKkt3xl7jgUDA5iSfOvqe7rM3h4icnOEz9PuXiKQklVTyhQKBAEuXLmXOnDm8u2AhvtYWDKebUG4l4e5DiHgrwOGyO6Z0FMMgml1CMLuEYNUwzNYDOA5uZvnaT1i+fDmPPPIIffv1Y9zYsYwZM4aSkhK7E6eMUCis/ahEUpzryFZBwWDQ3iCf0Xbja/gNLFSUiyScKET9UZVUIpKSVFLJCbW2trJo0SLmzp3LokWLCQT8GK40grlVRCq6EsktA1P/9znnGAbRzAKimQWEKi7A8B3CeXAzqz/ZyupVv+W3v/0tPXv2Yty4sYwdO5bKykq7EyetaDRKOBLBZeoGUSSVOY+8xkOhxNl/Li8vD8MwNEklkqj8sb8d3T9ORCSFqGWQow4fPsyCBQuYO3cuS5ctIxwKYbgzCHq7EO7UlWh2KZga65AjDAMrI49QRh6hikEY/kacB7ewftdWNvzpT/zpT3+ic5cuXDhuHGPHjqVbt26xmx5pl7YbVpdeciIpre01nkglldPpJK9THvW+erujiMiJtMb+VlRUZG8OEZEOoJLqHHfw4EHmz5/PnLlzWbFiBdFIBCM9i2B+L8J5XYhmF4Ghu2T5YlZ6LqGy/oTK+mMEmnE0bGHzwa1sffJJnnzyScrKyxk3NjZh1bt3bxVWX6DthtWpSSqRlNb2Gk+k5X4Qu/k9cOCAlvuJJCDDF/sdSqf7iUgqUkl1DvL5fMyaNYs33niDVatWYVkWeHIJFvUl0qkr0cwCUIEgZ8BKyyJc0o9wST8IteI8uJXtDVt49rnnefbZZykoLOLi8Rdx6aWXakngSWiSSuTckIiTVAAlxSVs2LmBKDphVCThaJJKRFKYSqpzyKZNm5gxYwZvvPkmfp8PMvIIlg0g3KkrlidPxZR0DFcG4eLzCBefB2E/zoZt7D24mef//r88//zzDBgwkMmTJ1FbW4vbrZMh20SjsRtDw9AUg0gqM4/86G17zSeKoqIirFYLLEC/HogkFh+kpaeRlZVldxIRkbhTSZXifD4f77zzDi+/PIN169ZimA6CnboS7tqbaFaxiik5u5zphAt7Ei7siRFsxbl/Ax+sW88HHzxIdk4OdRMncumll1JRUWF3Utu5XLETM8NRvUZFUlnoSDfV9ppPFIWFhVhhC0KAPj8QSShGq0FBQYG2ThCRlKSSKkV9/PHHsampN97E52uFjDwCnYcTLugOznS744lguTMIlQ8gVNYfR+NOwvvW8tzzz/Pcc88xcOBAJk+eTG1tbcLduJ0tn5ZUNgcRkQ7VVkQn2ntdcXFx7A8tqKQSSTCGz6C0W6ndMUREOoRKqhTi9/uZPXs2L730MmvXfoRhOgjldSHU5Tyi2ZqakgRlGES8FUS8FQSDrTj3r2fF2g2sWPETcnK91E38Kpdeeinl5eV2Jz2r2m5YQ5qkEklpbZNUibbcuaysLPaHFiDP1igi8m/MFvOc+71IRM4dKqlSwObNm5kxYwavv/EGrS0t4PESqBpGuKAHuDQ1JckjNl018DPTVet49rnnePbZZxk0eDBTJk9m9OjROJ2p/9bldDoxDUOTVCIpLlEnqdpKKqPF0Al/IokkCNFA9NMiWUQkxaT+nV6KCgQCsampl1/mozVrPp2aqupNNLtEU1OS3AyTiLeSiLeSYLAF5/4NLF+9nuXv/5hcbx6X1k2krq4u5X9Bc7mchCy9lkVSWaLuSZWVlUVmViZNzU12RxGRz2qJ/a20VMv9RCQ1qaRKMlu2bIlNTb3+Bi2Yl9BWAAAgAElEQVQtzUempoYSLuipqSlJSZY789+mq9byt2ee4W9/+xsXXDCEyZMnMWrUqJScrnK5XJqkEklx4SNDSom23A+gvLyc9YfWa5JKJJEcKam03E9EUlXq3dWlqObmZv785z/z0ksvYRkG4bwuhKrGEM0u1dSUnBs+O10VaMG5fz3vr1rLe+8to1u3au677//Qp08fu1PGVVpaGoGIXt8iqaztNZ6WlmZzkuOVl5WzadcmoqgtF0kURkvsPUOTVCKSqlRSJTjLspg9ezb/8z+/puFQA6GiPgTLB4DLY3c0EdtYaZmEKgYRKh+A4+BmNm9fynduvZXJkyZxyy23kJ2dbXfEuMjweAiEVVKJpDL/kZLK40m8n+tdunRh9uzZEAISazWiyLnrEOR1yiMrK8vuJCIiHUIlVQLbtWsXD//3f7Ns6VKsrEL8fSYRzSq0O5ZI4jBMIvnVNOdW4t75Pi/PmMHcefO4a/p0LrroIowknzJM93gIHLI7hYh0pEACl1T9+vWL/eEAUGJrFBE5wnnASf8h/e2OISLSYUy7A8jxQqEQf/3rX/nGN6by3vIPCHQeTmufS1VQiZyM002w8wh8fSfTEHLy4IMPcs8997Jz5067k50RT0bm0SkLEUlNgUjs74lYUvXp0wfDMDAO6H1IJCH4INoS/bRAFhFJQSqpEsyHH37IN785jT//+c/4sstoqbmCcEk/MPQ/lcgXiWYW0NrnUgKdR/D+Bx8ydeoNPP3004RCIbujnRaPx0Mg4rA7hoh0oESepMrMzKRrt64qqUQSRX3sbzU1NfbmEBHpQGo+EkRjYyM///nPufPOO9m27yD+nhMI9LgYy51pdzSR5GKYhEv60lJzBb7sch577DFu/OY3+eCDD+xOdso8Hg/+qN6mRVKZ/8i+c+npiXlC7/k152MeNNHe6SL2Mw4YuNwuevToYXcUEZEOo7sfm1mWxeuvv861113Ha6+/QbD0fFr6XU4kr8ruaCJJzXJnEugxHn+vL7F9XwPTp0/noYce4tCh5NnkyePxaLmfSIpL5I3TITaxYYUsSJ63TpGUZdab9DmvD06nthUWkdSlkspGTU1N3HXX3Tz00EM0Wh5a+00hVDUUHDpCRyReIt5KWvpdQbD0fF5/402uve56Fi9ebHesdsnJyaE5aNkdQ0Q6UHPIIMOTnrA3nUOGDCEtPQ1zvX5lFLHVHqABamtr7U4iItKh9BuHTQKBAN///v/lw5UrCXQZhe+8OqyMTnbHEklNDiehqqG09ptCU9TFD3/4H6xatcruVF8oNzeXYOTTjZVFJPU0hwxyc3LsjnFSXq+Xa6+5FmOHcXQ/HBE5yyxwrnJSXFLMlClT7E4jItKhVFLZIBwO8+CDD7J69Wp83cYSLj4PDC3pEeloVkYnWnt9mZDTw333fZ8tW7bYHelz5ebmArGbWBFJTU0hkxyv1+4Yn+vrX/86eZ3ycKx0gIY7Rc46Y4uBdcji1u/citvttjuOiEiHUkl1llmWxSOPPMK7775LoPNwIvnd7I4kcm5xeWjt+WVaQ1G+97172Ldvn92JTurTkkpv1SKpqjnkwOvNszvG5/J4PHzr5m/BAWCH3WlEzjFhcHzkoPd5vbnwwgvtTiMi0uF053OWPfnkk7zyyisEy/oTLulrdxyRc5KVnk1rzy9x4FAj99xzL01NTXZHOqGcI0uAmoKapBJJVc1h82ghnci+8pWv0LlLZ5yrnaAlyCJnjbHBwGq1uPOOOzG08kJEzgEqqc6iGTNm8MQTTxAq6EGo4gK744ic06KZ+bR2v5ht27fzf//vDwgEAnZHOo73yBIgLfcTSV1NQeNoIZ3IHA4Hd95xJ1azhbHa0LI/kbOhARzrHYwZO4aamhq704iInBUqqc6S+fPn8/DDDxPxVhLsWqs9qEQSQDS3DF+3saxatYqf/vSnRCKJNR7QVlIdCuqtWiQVBSLgC1vk5SX2cr82Q4cO5asTv4q5wcRcZELY7kQiqcvYauCc7SQ/L5/bbr3N7jgiImeN7nzOgpUrV/KTnzxINLMQf/eLwNR/7SKJIpLfjUDnYcyfP59HHnkEy0qc8YDc3FzS3C4O+PWeIZKK2l7bxcXFNidpv+/f931uu+02zF0mznec0Gx3IpEUEwXjQwNzqUlN3xoef+xxysrK7E4lInLW6M6ng/l8Pn74Hz8i5MygtecEcLjsjiQi/yZc0o9gaX9mzJjBrFmz7I5zlGEYFBUVqaQSSVFtr+2ioiKbk7SfYRh8/etf57/+67/IiGTEiqq9dqcSSREBcLzrwNxgctlll/Hoo48mzaSliEi86M6ng7300ks0HmrA17UWXOl2xxGRkwhVXgAZnXj88b8QDifOGpaS0jLq/Q67Y4hIB6g/UlKVlJTYnOTUDRkyhMf+/BhVpVU45jsw1mufKpEzcgic7zhxHHBw33338d3vfhen02l3KhGRs04lVQdqbW3lr397hoi3gmh28ozyi5yTDAN/+UB27tyRUNNUxcXFHAjql1SRVFTvNzENg4KCArujnJby8nL++Ic/MmbMGMyVJsZSQyf/iZyOHeCc7cTr9vLb3/yWuro6uxOJiNhGJVUHevHFF2luOkywfJDdUUSkHSJ5XbAy83n8L08kzDRVcXExjX6LoG78Up4vbODxeLjyyivxeDz4wjpgI9Ud8JkU5HdK6mmJjIwM/vOn/8nNN9+MY7sD5ywnxjYDonYnE0kCjWAsNXAsctC7Z28ef+xx+vbta3cqERFbqaTqIC0tLTzz7LNEvFVEs5JnrwmRc5phECgfxJ7du3jrrbfsTgN8uqGy9qVKfa1hg4kTJzJ9+nQmTpxIq0qqlFfvd1BcUmp3jDNmGAZTp07l5z//OeXZ5ZhLTJxvODE2GBCyO51IgrGAveCY78DxloP0PelcffXV/ObXv0naqUoRkXhK3o/uEtwLL7xAS3MzwX4X2x1FRE5BxFuFlVXAX554ggkTJtg+4dC2V80Bv0lppkYTUlmG02LmzJkAzJw5kyKnNvhJdQeCTvon4X5UJzNixAiGDRvG4sWLefa5Z1n54UqMtQaRrhGs7hZk2J1QxEZRMLYbODY4sA5Z5Hpz+drNX2Py5Mnk5ubanU5EJGGopOoATU1NPPvc84TzOhPN1CciIknFMAiUD2bf+jd57bXXmDRpkq1x2kqq/ZqkSnkep4Wv2ccLL7wQ+9qrkiqVRaJwwAelpck/SfVZpmkycuRIRo4cydq1a/n73//O7NmzsTZaRCuiWL0s8NqdUuQsCoHxiYFjkwOr1aKiqoJrv30tF198MWlpaXanExFJOCqpOsA//vEPfK0thLpNsDuKiJyGSG4FVlYRTz75FF/96ldtnaYqKCjANE3qfSqpRFJJQ8AkaiXnyX7tdd555/GTn/yEb3/727zwwgvMeGUGgW0BKIZIzwgUA1rVKqmqFYyNBo7NDqyQRf+B/bnm69cwbNgwTFM/00VETkYlVZxZlsWrM1+LneiXmW93HBE5HYZBoPR86jf+i+XLlzN06FDbojidTgoL8tnv99mWQUTir/7IdGQql1RtSktLufPOO7nxxhuZMWMG//uP/6VhfgNGrkGkZwSr0gKH3SlF4qQBjPUG5g4T0zC56KKLuPrqq+nVq5fdyUREksJpl1QrVqzgtddeY8mSJezbt4/m5ma8Xi8VFRWMHj2ayZMnU1lZGc+sJ7RgwQKmTZt2wn/20EMPcfnll3d4hs/asGED9fv3Ee425qw+r4jEV8RbgeFwMW/ePFtLKoDS0jLqt+62NYOIxNd+37lTUrXJzs7muuuu46qrruJf//oXzz3/HFuWbcFYZRApj2CVW1CIjvWR5NMMxg4Dc6cJByHdk86kr03ia1/72tEDUEREpH1OuaRqaGjggQce4M033zzun+3fv5/9+/ezYsUK/vjHP3LTTTcxffr0DhtpbW5u5kc/+lGHfO/TNW/ePDAMwt4qu6OIyJkwnYRyK5g7bx7f/e53cTjs+5i/pLSUpRtctj2/iMRf2yRVUdG5dwKwy+XiK1/5Cl/+8pdZtmwZr7zyCosWLyL4cRAjzSBSEsGqsGLLATVhJYnIAhrB2Gng2BXbCB2ge4/uTPj6BOrq6sjKyrI3o4hIkjqlkurgwYPccMMNbNiw4QsfGwwG+f3vf8+OHTv45S9/2SFF1a9+9St27twZ9+97JmbPmUMkuxRc6XZHEZEzFO7UhcZNm1mzZg3nn3++bTlKSkpo8FmEo+DUhIFISqj3m3TKyz2nN042DIOhQ4cydOhQ/H4/y5YtY968ecx/dz6tW1sxnLHCinKwSi1QVy92soCDnymmmiwMw6BfTT/GXj+W2tralDsIQUTEDqdUUt1///0nLKi8Xi+FhYVs374dv99/zD975ZVX6NevHzfeeOMZBf13ixcv5u9//3tcv+eZ2rJlCzu2byfceaTdUUQkDiK5lWA6mDdvnq0lVX5+fuxD26BBfrpOfBNJBYcCJgWF594U1cmkp6dTW1tLbW0t4XCYFStWMG/ePObMnUPjkkYM0yBaHMUqt7DKLDh3uz05m6JAfWwpn2N37HQ+h8PBoEGDGDt2LKNHj6ZTp052pxQRSSntLqlmzZrF7Nmzj7t+++23c9ttt+F0OmlqauLee+9lzpw5xzzm0Ucfpa6ujoKCgjMODNDa2soPf/hDLCt2s+ZyuQiFQnH53mdi3rx5AEQ6dbY5iYjEhdNNJKeM2XPmcPvtt2MY9hxD1fbeeShgkp8esSWDiMRXQ8hJRUGh3TESktPpZMiQIQwZMoS7776bjz76iLlz5zJn7hz2vbcvdiJgIUTLo7HCKsPuxJJSIsDe2MSUc7eTaCCKy+1ixPARjBkzhhEjRpCdnW13ShGRlNXukurZZ5897trAgQOZPn360a+zs7P5xS9+wbhx4/D5Pj2Jyufz8eKLL3LLLbecYdyYhx9+mB07dhz9+o477uCRRx6Jy/c+E3PmziWaXYTlzrQ7iojESTivC/s3z2fDhg22ncyTnx87KfRQwCT227OIJLvGgEn/fJ0C/EUcDgc1NTXU1NRw++23s3HjxqMTVttWbIMVQKcjhVW5BeoO5HSEwNhjwE5w7HFghSw8GR5GjxnN2LFjGTp0KOnp2spDRORsaFdJ1dDQwMKFC4+7XldXd9w1r9dLbW0tb7311jHXZ86cGZeS6r333uOZZ545+nXfvn25+eabbS+pDhw4wKaNGwlXDrE1h4jEVzivM2mb57N48WL7S6qgPZNcIhJf4SgcDlhHX9vSPoZh0LNnT3r27MnNN9/Mtm3bjhZWG1ZtgFVg5BhEiiNYJUdOCtTG63IiFtAUK6aMPQZmvYkVscjx5jD2y2MZO3YsAwcOxOXSRmgiImdbu0qq1atXE41Gj7vet2/fEz6+X79+x5VUGzduxO/3n9GnED6fj/vvv/+YZX4///nPcTpP+ZDCuGvbqyuSpWNmRVKKKx0yvKxfv962CHl5eRiGcWSSSkSSXWPQwAKVVGeoqqqK66+/nuuvv569e/cyf/58Fi1axIoPVhDeGMZwGkQLolglVqy0yiK2VFDOTSFgX6yYcu51Em2J3dtUda5i+BXDqa2tpV+/frae5isiIu0sqdatW3fC62VlZSe8Xlx8fFETiUTYuHEjNTU1pxDvWI888ghbt249+vVtt91Gz549T/v7xdPGjRsBiGZo88SUZ1kYwVaIBHHuXUu4qDfYtFeRnB1hTyfWrf/iU007itPpJDcnm0NB/xc/WEQSXlvhrJIqfoqLi7nyyiu58sor8fv9fPDBByxZsoTFSxaz84PYSdBG1memrIo4xeODJOlYQGOslDL3mHAAiIInw8OQC4YwbNgwhg4desL7FhERsU+7l/udSG5u7gmv5+XlndL3aY/ly5fz17/+9ejXffv2jdseV/GwYcMGDE8uON12R5EO5ty3FjNwGIC0LQsAi3BxH1szSceKZuRTv/0TGhsbT/q+19EKCgo4eOiALc8tIvHVVlLF60AZOVZ6ejrDhw9n+PDh3MVd7Nq1i6VLl7JkyRLee/89Ah8HMEwDq8AiWhKbtCIHTVmlggAYew3YA859TqK+2LRUdfdqRnxpBEOHDqVfv34JsQpDREROrF3v0M3NzSe87nafuJA52fWmpqZ2xjpWIBDg/vvvP7rk0OVy8dBDDyXUD5h16zcQ8miK6lzgaNh23NcqqVJbJDM27bBp0yYGDx5sS4ai4hK27/vYlucWkfg64I+VVEVFRTYnOTeUlZUxZcoUpkyZQjAYZNWqVSxdupRFixexZeUWWAlmhkm4OPzplFWKfeZodbHsjtAxLODgkWmpvUempYCs7CyGjRzGsGHDGDJkiKYWRUSSyBm1PG17Q7X3+uke3/7oo4+yefPmo1/feuuttm1gfCJNTU3s27uHaMUFdkeRs8CIhj/3a0k90YzYtMOGDRtsK6mKi4v5cJn2pBJJBQcCJi6XE6/Xa3eUc47b7Wbw4MEMHjyYW2+9lf379x+dslqydAm+zb7YRFU+RIujWKUWeEn6KauUKqn8R07i2wOOfQ6sgIVhGPQ+rzfDJw1n2LBh9OrVS3tLiYgkqXaVVFlZWSe8HgqFTvgDIBgMntL3+TwffvghTz311NGv+/Tpw7e//e1T/j4dadOmTQBEM/UpjUhKcqVjpGcd3XvODkVFRbSELHxh8CTOEKmInIYDfpPCgnxMU8Wz3QoLC5k4cSITJ04kHA6zdu1alixZwqLFi9i4ZiOsAcNjECmJYJVZUIxODDzb2vaW2mVg7jbhYOyyN8/LiItiS/guuOAC25bji4hIfLXrVudke0wdOnSIkpKSE14/le/zeR5//HEikQiQmMv84NNN0yMqqURSVii9E+tt3Dy9bWPXg36T8qzjT1sVkeRxIOCguOuJD58R+zidTmpqaqipqeHmm2+moaGBZcuWsXDhQhYtXoRvsy92YmBRFKvMik1Znf6h1fJ5osD+WDHl2OPAav50Wmr0FaMZPnw43bt3P+1VGiIikrja1fb07t37hNd37dp1wpJq9+7dx11zOBz06NHjFONBOPzpUqpQKMTkyZPb/e/+4Ac/4Ac/+MHRP994442n/PztsXv3bgynG1wZHfL9RcR+UU8ue/aut+352/auORBQSSWS7A4GnHTTflQJLy8vjwkTJjBhwgRCoRAffPABCxYsYN78edS/Vx97UAFES2OlFdkk/bJAWwWPLOPbBY69DqyghcvlYsiQIYwePZoRI0ZobykRkXNAu0qqmpoaTNM8unF5mzVr1jBo0KDjHr9mzZrjrvXs2ZP09NT8uKmxsRFcqfmfTUSOcKYTCgbx+/22vJcdLan8Wh4kkswiUWjwW9o0Pcm0lSVDhgzhrrvuYtOmTSxYsID5785n46qNsAqMbINI6ZFlgfmA3q6/WMuRZXy7TKgHopCTm8Poi0czatQohgwZkrL3DyIicmLtKqm8Xi8jR47k3XffPeb6zJkz+cY3vnHMtUOHDh33OICJEyce8/WSJUuYOnXqcY9bv96+SYXT1djYSMSRZncMEelAljP2Gm9sbLTlF+bCwkLcLhe7W7QZikgy2+sziVpQUVFhdxQ5TYZh0KNHD3r06MGNN97Ivn37WLhwIe+++y7vL3+fyIYIZppJuCT86T5WLrtTJwgLaDiyjG+3A+tQbEP3yqpKar9ey6hRo+jTp482PRcROYe1e3Ona6+99rjyacWKFfz617/mtttuw+l0cvjwYe677z58Pt8xj/N4PFx22WWnFbBz58707dv3Cx93oumt8vLyoyfnFBQUnNbzt8ehxkaiTn3KI5LKrCOv8cbGxqP7Q51NDoeDLl06s+3A2rP+3CISPzuaYzff3bp1szmJxEtRURFTpkxhypQptLS0sGzZMubPn8/CRQtp2dqCYX5mH6syCzx2Jz7LIsC+z+wv1RrbX6pfTT9qr40VU5WVlXanFBGRBNHukmr8+PFceOGFzJ49+5jrv/vd73jmmWcoKipi27Zt+P3+4/7du++++7RLou9///vtelyvXr2Ou3bHHXdw+eWXn9bznopDhw5hOXWiiEgqs1yfllR26VbdncXbP7bt+UXkzG1rdmAaBl26dLE7inSAzMxMxo0bx7hx4wiHw6xevZp3332XefPnsWf5HlgOVolFtDoKpaT2HlZNYHxi4NjqwApYpKWnMXzYcEaNGsXw4cOPfpAsIiLyWad0TN7PfvYzbrjhBjZsOPaEq0OHDp30RL9LL730hMv6UsnhxsOQp70lRFLZZ5f72aW6upo33rA4HDTIcVu25RCR07e92UF5eRlpadomINU5nU4GDBjAgAEDuP3229m6dSuzZs1ixiszaFjQgJFpEOkSweqaQtNVUWIbn3/igL1gOkzG1I7hK1/5CoMGDdL/70VE5AudUknVqVMnnn76aX784x/z1ltvfe5j3W4306ZN46677sI0U3fnyEAgQCDgP7oUSERS02eX+9mlbXnQ9mYHfTuFv+DRIpKIdrS66dOvp90x5CwzjkzP3XTTTdxwww0sXLiQf770T95/7334CKyyI9NVRSTndFXrkampLQ4sn0VBUQFTbp7CxIkTdSKfiIicklMqqSB2HO9vfvMbli9fzmuvvcaSJUvYt28fLS0t5ObmUlFRQW1tLZMnTz4n1pc3NzcDYDndNicRkQ51ZJKqqanJtgjV1dWASiqRZOUPw94WqNN+VOc0p9PJmDFjGDNmDDt27OCVV17hlVdfoXlec+yEwK4RrC4WJPrQkQXsAfNjE2OPgYHB8OHDmTJlCkOHDtXm5yIiclpOuaRqM2jQIAYNGnTaTzxs2LC4nuRn16mAlnVkyY2RutNiIgJtH20ffc3boFOnTnhzc9jWFLAtg4icvh0t2jRdjlVRUcGtt97KtGnTmDdvHv986Z+sXrkaY41BpDyCVW1BPok1XeUHY7OBY7MDq8XCm+dl0jcmUVdXR0lJid3pREQkyZ12SSX/xsYbVxE5d/Ts1ZvNaxuBVrujiMgp+uRw7Neunj213E+OlZaWxiWXXMIll1zCJ598wowZM3j9jdfxbfNh5BpEukWwOlvgsimgBewH42MDc5cJURg4aCBTpkxh9OjROJ26pRARkfjQTxQRkVNgGPZ+nH3eeeexbNlS/BFI10oKkaTyyWEHed5ciop02IqcXLdu3bj77ru55ZZbeOedd3jxny+yacUmjLUG4YFhqDjLgVrB8b4D9kBmViYTr5zIpEmTqKqqOstBRETkXKCSSkQkifTu3RvLgq1NDnp5I3bHEZFTsLnJTe+aPraX3ZIcMjIyqKuro66ujjVr1vBfD/8XHy/6mGhlFGvgWdizyjqyrG+lA7fp5pY7b2HSpEk6oU9ERDqUNlI6Q/pFU+RckRhLenv37g3Ax436jEEkmbSGYVezQZ8+feyOIkmob9++/PlPf+amm27CtcuF8y0nbO/AJ2wBx3wH5vsm/fv156mnnuJrX/uaCioREelwKqniJjFuYEWkY9ldTOfn51NUkH90bxsRSQ5bDjux+LRoFjlVTqeTG264gccee4zuVd1xLHZgLjLBH8cnsWL7TjnfdpLWmMY999zDo488SllZWRyfRERE5ORUUp0hu29YReTc07tPXzY3ue2OISKn4JPDsU3kevXqZXMSSXbV1dX88Q9/5JZbbsG5x4nzLSfGduPMPy9tAcc8B+Zyk4E1A3n6qaeZPHkypqnbBREROXv0U+cMORxHdi62ovYGEZGOdeQ1ngi/rPfu3Zu9rdASUkkukiy2NDkpKS7E6/XaHUVSgNPp5Prrr+cvj/+FHl16YC42T3+qygJjk4HzLSfpTence++9PPLII5SWlsY9t4iIyBex/24rybndsWkGI6oNjEVS2pHXeCLsx1FdXQ3Ajha9hYski+0tLqq797Q7hqSYrl278off/4HvfOc7uPa5cM51QujUvofxkYG5wmTwgMH89em/MmnSJK0UEBER2+gO5wy5XK7YH1RSiaS0tiK6rZi2U7du3QDY3uywOYmItEcoCrtbjKOvXZF4cjqdXHvttTz8Xw9DExjvn8LSv71gfmTypS99iYcffpji4uIOzSoiIvJFVFKdIafTielwgKWSSiSlWYlTUhUVFZGZ4VFJJZIkdrU4iFqfTkGKdISBAwfyrW99C3O7ifFxOyahfOBc6qRzl85873vf0/SUiIgkBJVUceByubTcTyTVJdAklWEYdOtWzfZmnfAnkgzaCmVNUklHu/baaxk6bCiOlQ5o+JwHRsGx2IEbN//50//E4/GctYwiIiKfRyVVHLhdbi33E0lxibTcD6BbdTU7WlxYZ3qak4h0uG3NDlwuJxUVFXZHkRRnmiY/+o8fkd8pH+diJwRP/DhjtQH1cN//uY8uXbqc1YwiIiKfRyVVHLjcbi33E0l1iVZSdetGa8jiQEDLM0QS3fZmB52rqnA6Nf0oHS83N5efPvhTDJ+BudSEfRzzl/GxgbneZNKkSVxyySU2pxURETmWSqo4cLvdGNGw3TFEpCMdeY0nSknV9sn37hbtSyWS6Pb4XHTpqqV+cvb069eP2269DWO3gWOu45i/zOUm1d2rufPOO+2OKSIichx9pBcHGRke8J3ieb8iklTaiuhE2bejvLwcgH0+fdYgksjCUaj3ffqaFTlbrrrqKgYOHEhzc/Nx/+y8884jLS3NhlQiIiKfTyVVHGR4PBhRn90xRKQjRWNFdKKUVAUFBbhcTva2apJKJJHt95lYlkoqsUePHj3sjiAiInJK9BF8HGRkZGBENUklksqMSGJNUpmmSVlpKXs1SZUy0hyf/7Ukp7bXqEoqERERkS+mu5s48Hg8mNqTSiS1JdgkFUB5RSV7/S67Y0icDCwMfu7Xkpz2HZl2VEklIiIi8sVUUsVBenq6Nk4XSXGJNkkFUFFRwf7W2FIiSX7jy4MUeyLkuKJ8s3cL48tVUnxbZRIAACAASURBVKWCPT6T9LQ08vLy7I4iIiIikvBUUsWBx+M5OmUhIikqGsLhcOJyJc7kUnl5OYGIxaGgYXcUiQPDgLy0KGWZEcZXBDH0P2tK2OczKS8vw9D/oCIiIiJfSCVVHHg8HqywSiqRVGZEQqSlJ9ZJSG3Lh/Zo83SRhLXX56aissruGCIiIiJJQSVVHGRlZUE0AlryJ5K6IkEyMzPtTnGMiooKAPa06q1cJBFForCv9dPXqoiIiIh8Pt3ZxIHX6wXACPltTiIiHcUI+cnzJtaeMsXFxbicDvZqkkokIdX7TSKWSioRERGR9lJJFQe5ubkAGGGVVCKpyhEJkJfntTvGMRwOB6WlpZqkEklQba9NlVQiIiIi7aM7mzjQJJVI6jPD/qOv9URSUVnFHn/ibOYuIp9qm3JUSSUiIiLSPiqp4qBtkgpNUomkrpD/09d6AqmoqGBvq0HUsjuJiPy7PT4TT3oanTp1sjuKiIiISFJQSRUHRyepVFKJpKZoGCsSSshJqs6dOxOKxI65F5HEsr3ZSVVVFYZh2B1FREREJCnoriYOsrOzMQxDy/1EUlTbazsRJ6lqamoAWNfgtDmJiHxWKAqbDjs5v/8Au6OIiIiIJA2VVHFgmibZOTmapBJJUW2v7USdpPLmZLPukEoqkUSy+bCDUAQGDFBJJSIiItJeKqnipLCwECPYYncMEekARiD22i4sLLQ5yfEMw6D/wEGsO5RmdxQR+Yy1DbEDDdqmHUVERETki6mkipPioiKcoVa7Y4hIBzCCzQAUFRXZnOTE+vfvT70P6rUvlUjCWHfISdcunRNyAlNEREQkUemOJk6Kioo0SSWSooxgCw6HM2FvNtuWE2nJn0hiiERhY6ObAQMH2R1FREREJKmopIqToqIirJAfIiG7o0hHiwTxeDxceeWVeDweiATtTiQdzAy2kF9QgGkm5ltmt27dyM7KZM1BlVQiiWBzkwN/2KJ///52RxERERFJKol5x5WE2pYBaZoq9RnhIBMnTmT69OlMnDgRI6ySKtUZwRZKiovtjnFSpmkyZuw4Fu1NY0+r3tZF7GRZ8OInGWRkeLjgggvsjiMiIiKSVHQ3Eycqqc4dltPNzJkz+fWvf83MmTOxnG67I0kHc4ZaKSpKvE3TP+vmm2/GnZbO3zZk2B1F5Jy2vN7FygNOpk27iZycHLvjiIiIiCQVlVRx0nbql6mSKvU53Ph8Pl544QV8Ph84VFKlNMvCCjQn7KbpbfLz87nxm9P4oN7Fiv0uu+OInJOCEfjbxiy6dK7i8ssvtzuOiIiISNJRSRUnBQUFgCapRFJO2A9W9GgRnciuuOIKqior+NvGTIIRu9OInHtmbk1nfyvcdfd3cTq1R5yIiIjIqVJJFSdpaWlkZmVjBFvtjiIicdQ2HdlWRCcyl8vFXXd/l72tBq9vS7c7jsg5pd5n8srWDMaOHcvgwYPtjiMiIiKSlFRSxVFBQT5GSCWVSCppK56ToaQCGDJkCLW1tczYksEBv2F3HJFzxrMbPRgOJ3fccYfdUURERESSlkqqOCouKsKhkkokpbQVz8lSUgHccccdWKaT/1mZTb1Pb/MiHSlqwf/3cTpL97m5/htTKU7gk0BFREREEp3uXuKooKAAM+SzO4aIxFHbJFV+fr7NSdqvtLSUHz/wAHtCWfxwqZele7WRukhHOOA3+NnyHP652cOECRO45ppr7I4kIiIiktS0q2ccFRQUYAVbwIqCof5PJBUYwRZycr1JtwnymDFj6N69Oz954Mf8etUGxjf4ua6HD7fD7mQiqWHFfhd/WptNyHBz//338OUvf9nuSCIiIiJJT01KHBUUFIBlYYT8dkcRkTgxQq1JtdTvs8rKyvjd//s911xzDbN2pPPAe7nsbNHbvsiZCEXhr+s9PPxhFsWVXXn8L39RQSUiIiISJ7pbiaO25UDaPF0kdTjCPgoLkmep379zuVzceuut/OpXv6LJ9PKjpV7m7nRjWXYnE0k+e1pNHnwvlze3p3PFFVfwhz/+icrKSrtjiYiIiKQMlVRx5PV6ATC0L5VIyjDDfvLy8uyOccaGDRvGX554kn7nD+DPazP5f6szaQ3bnUokeby7281/LPVyIJrNz372M+666y7cbrfdsURERERSikqqOPq0pNJyP5GUYFlYQd/R13ayKygo4OH//m9uvvlmluxP5z+W5vHRQaemqkQ+R2PA4I9rMvjDmkx6ntePJ558itGjR9sdS0RERCQlJddOwAnu6I1sWCWVSEqIhiAaSYlJqjYOh4OpU6cycOBAHvzJA/xsOVRmR7mozM+o0gAZ+qkggmXBRw1OZu1I4/39bqIY3HjjDUydOjXpDlEQERERSSb6TSuOsrKycDicWu4nkiLapiJTZZLqs2pqavjr355h1qxZvPTPF3lq/Sae35TJiGI/4ysCdM2J2B1R5KxrChrM3+1m9i4Pu1sMsrMyueJrE5k0aRJVVVV2xxMRERFJeSqp4sgwDLJzcvBrkkokJRjh1C2pADweD3V1ddTV1bFu3TpefvllZv3rbebsSqNrTpSLyn2MKAmS7rA7qUjHsSzY2Ohg1o40lu5LIxSFfn37MG3KZYwbN460tDS7I4qIiIicM1RSxVme10t9g0oqkVTQNkmVm5trc5KO17t3b3r37s3tt9/OW2+9xcsv/ZPH127l2U1ZjC72cVFFgMqsqN0xReKmNQwLdqcxa2c6O5pNMjzp1E3+CpMmTaK6utrueCIiIiLnJJVUcdapUx7m/u12xxCROGhbupuqk1QnkpWVxeWXX85ll13G6tWreemll5gzZzZv70inhzfC+HI/Q4uCuDVdJUnqk8OxqanFe9MJRCx69ujOfZddzkUXXURGRobd8URERETOaSqp4qygoADHmg12xxCRODBCrQDk5+fbnOTsMwyDmpoaampqmD59Om+88QYvv/RP/rBmF3/bmEVtiY8LywOUZWq6ShKfPwyL9rp5Z6eHzYdN0tPcXPzlS5g8eTK9e/e2O56IiIiIHKGSKs4KCwuxAi1gRcEw7Y4jImfACLaQnZ1zzu9Jk5uby9VXX81VV13F8uXLefnll3lr/jxe35bOeXlhhhQFGVAQosijwkoShz8Caw66WLHfxZL96fhCFl27dObuaZcxYcIEsrKy7I4oIiIiIv9GJVWcFRUVgRXFCPmw3Jl2xxGRM2AEWygsKrI7RsIwDIPBgwczePBgDhw4wOuvv87rM1/l6fW7eHo9lGdZDMwPMKAgRI/cMA719HKW7feZrKh38UG9i7UNLkJRyPCkM3pcLVOmTKFfv34YhmF3TBERERE5CZVUcVZYWAjEbm5VUokkN2eolZLiSrtjJKT8/Hyuv/56rr/+erZv386iRYtYtHAhb3z4Ia9ujZDpMqjpFGBgQYjz80Nkuy27I0sKikRhY6OTD+pdfHAgjR3NsQKqoryMy64czYgRIzj//PNxuVw2JxURERGR9lBJFWdFR6YujGCLzUlE5EwZwZajr2k5ucrKSiorK7nqqqtoaWlh2bJlR0qrBSxecxjTgO65EQYUxEqriswoGmaR09UcMlh5wMmK/W5WNqTRErRwOEz6n9+fKaNGMWLECCorVS6LiIiIJCOVVHH22UkqEUlikTBWyH/0NS3tk5mZybhx4xg3bhzRaJR169axePFiFi54l//duIn/3QQFHuif72dgQYg+eWGdFCify7JgR0vbMj43mxqdRC3w5uYwZnyslLrgggu0x5SIiIhIClBJFWe5ubm4XG6CKqlEklpb0axJqtNnmiZ9+vShT58+TJs2jfr6+lhhtXABC5a9x6wdAdwOg755sX2sBhSEyE/XskCBYATWNjhjxdSBdOp9ses9ulfzjcmxZXy9e/fGNLXxmYiIiEgqUUkVZ4ZhUFhUhM/XbHcUETkDZqAJUEkVTwUFBdTV1VFXV0cgEODDDz9k0aJFLHx3Pk+s2wdAVXb06Obr1bkRTC0LPGcc9Bt8UO9iRb2Ljw6lEQhbpKe5GXzBEL45ciTDhw/XZKOIiIhIilNJ1QG6dunMrhUfEbA7iIicNsN3CIDOnTvbnCQ1paWlMXToUIYOHcr06dPZunVrrLBasIBXVq/m5S1Rst0G/fIC9C8IUdMpRG6apqxSSTgKGw45WXnAxcqDbrY1xaaiSoqLmDgpNi01YMAA0tLSbE4qIiIiImeLSqoO0LVrVxYsXATRCJjabEUkGZm+BrKys8nLy7M7SsozDIMuXbrQpUsXrrnmGpqamli6dCmLFy9myeJFLFpzGICuOVHO7xQrrapzIjhScKXX2LKg3RE6VL3f4MN6FysPuPioIQ1f2MLpcFBzfg1fHTackSNH0rlzZwztrC8iIiJyTlJJ1QG6dOkCVhTDfxgrQze4IsnI4T9Et67ddLNsg+zsbMaPH8/48eOJRqNs3LiRJUuWsGTxIl5Z8xEvb7HIdMX2supfEOL8/BB5KTJlVZtiJVUoCusaYtNSHx5MY1dz7PVUVFjAJV8dybBhwxg8eDAZGRk2JxURERGRRKCSqgN07doViE1iRFRSiSQfy8Lha6BbtxF2JznnmaZJr1696NWrF1OnTqWpqYn33nvvaGm19KMGILaX1fmdgvQvCNEjN4wzBaesksXeVjNWSh1wsrYhjUDEwuV00H/AAC4fPoKhQ4dqWkpERERETkglVQeoqqrCMIxYSWV3GBE5ZUawFSscjE1FSkLJzs7mwgsv5MILL8SyLD755JPYssAli3l91Spe3RrF44xNWZ2fH+L8ghAFOjGwQwUisWmpDw+4WHkwjT0tsfKprLSEiZNj01IDBgzA4/HYnFREREREEp1Kqg6QlpZGSWkZ21sb7I4iIqfB9MVeu21TkZKYDMOgurqa6upqrrvuOlpaWli+fPmRvawW8t66AwCUZ1n07xQrrXrlhXFpyuqMWBbsPjot5WLdITehiEWa28XAQYO4ethwhg0bRkVFhd1RRURERCTJqKTqINXdurJ7+Wqd8CeShIwjJZUmqZJLZmYmtbW11NbWYlkWW7duZcmSJSxevJi3P/yA17ZFSHMY9MkLcH5+mAuKgimzl1VHC0dh1UEnH9S7WHkwnf2tsetVlRVMuWgEw4YNo3///jqJT0RERETOiEqqDtKtWzfeXbAAomEw9V+zSDIxWw+Sk+vVyX5J7LMnBl599dX4fD5WrFgR28tq0UKeWr+Xp9dn0KdTmJElAYYUBcnQW/UxohZsOORk4R43S/en0xy0SE9LY/AFFzB1+HCGDBlCWVmZ3TFFREREJIXoV/IO0r17d7AsTN8hopkFdscRkVPg9DXQ87zudseQOPJ4PIwcOZKRI0di3X0327ZtY9asWbz15hv8+aM9PLkukwEFQUaWBBlQEDqnlwRubzZZsDuNxfvSqfdBepqb0WPGcMkllzB48GDcbrfdEUVEREQkRamk6iDV1dVAbCJDJZVIErGiGL4GqqvH251EOohhGHTu3Jlp06bxzW9+k7Vr1/L222/zzr/eZtnKw2S6DIYU+hlZEqR3XhjzHDiErt5vsHCPm0V709neZGKaJkOGDOE7l1zC6NGjycjIsDuiiIiIiJwDVFJ1kLKyMlxuN6HWg3ZHEZFTYPgaIRqJTUNKyjMMgz59+tCnTx9uv/123n//fd5++23mz5vLnF0BOqXD8GI/o0qCVGVFMFKosGoKGizd52LhnjTWH4r9OtC3Tx/uuuQSLrroIi13FREREZGzTiVVB3E4HHTr1o2PdqmkEkkmpi/2mm2bhpRzh9PpZNiwYQwbNgy//14WLFjAW2+9xZtLl/Da1nTKsixGFfsZURKkyBO1O+5pCURgxX4XC/a4WXnQTSQa2/z8piu+xCWXXKI9pkRERETEViqpOlCP7t3Z8PG/Yud1p9LH7yIpzGw5iOlw0LlzZ7ujiI3S09MZP34848eP59ChQ8ydO5e33nqTf6xazT8+9tDDG2FkcYBhxUFy3Il9QmAkCmsanCzc7ea9+nT8YYv8Tnlc+bUJXHzxxfTs2RNDP6NEREREJAGopOpA1dXVWKFXMUKtWO5Mu+OISDuYvoNUVVXhcrnsjiIJwuv1MnnyZCZPnszu3buPbrj+1Ppt/G1DBjX5IS7v5qNbTsTuqMdoDcMrW9KZt9tDYwAyMjxcNOFCLrnkEgYMGIDD4bA7ooiIiIjIMVRSdaBPN09vIKKSSiQpuPyH6F49zO4YkqBKS0u5/vrrue666/j44495++23ef21mTyw9DC1pQGu6u7Dm2bvZFXUgnm73PzvJ5k0BWHUqNFMmDCBESNGkJaWZms2EREREZHPc9ol1YoVK3jttddYsmQJ+/bto7m5Ga/XS0VFBaNHj2by5MlUVlbGLWhTUxNLlixh5cqVrFu3jm3btlFfX4/P58PlcpGdnU337t0ZPHgwU6ZMoaKiIm7PfbraMhj+RsD+PCLyBaJhLH8TVVVVdieRBGcYBt27d6d79+584xvf4Omnn+aFf/yDZfvTmdylhS9VBXCZZz/X+kMO/rohiy2HTfr17cP0u+6md+/eZz+IiIiIiMhpMCzLOqWPfBsaGnjggQd48803P/dxbrebm266ienTp2OaZ/ab+mOPPcYjjzxCOBxu1+MdDgdTp07lnnvuadeSnV69eh13bf369aec899ZlsWEL32J5txuBLuMPOPvJ4kh/aNXcTTtOfp1JLsEf586GxNJvBitB8lY9SIPPPAA48ePtzuOJJnt27fzu9/9loULF1GcYXFtjxYGFYTOypaE9X6D5zdmsHivm8KCfG697XbGjx+vvaZEREREJKmc0iTVwYMHueGGG9iwYcMXPjYYDPL73/+eHTt28Mtf/vKMiqq9e/e2u6ACiEQiPPHEE2zbto3f/e53tv2SbhgGFRUVrN9/2JbnF5FTY/obARJiElOST2VlJT//+S9YunQpv/n1//DIh9vp1ynM9T1bqMjqmNMAAxF4dUs6M7dlgOnkxhuv45prrsHj8XTI84mIiIiIdKRTao7uv//+ExZUXq+XHj16kJ6eftw/e+WVV3j66adPP+FJtD2n1+s96WNmzZrFCy+8EPfnPhWdq6pwBVVSiSQD0x97raqkkjMxdOhQnnjyKaZPn86WQA73L8nl6fUemkPx+8DEsmDRHhf3Lc7jn5s9jB47jr898wzTpk1TQSUiIiIiSavdJdWsWbOYPXv2cddvv/12FixYwKuvvsq7777LuHHjjnvMo48+Sn19/RkFBcjPz+e2225jxowZLFmyhFdffZUlS5bw4osv0rdv3xP+O88999wZP++ZqKysxPI3QTSxTn0SkeMZ/kZyvXlkZuqgAzkzTqeTK6+8kmefe55LJ03mXzs83LvIy9vb04ic4VDV5sMO/vP9HH63OotO5dX85je/4Sc/eZCSkpL4hBcRERERsUm7S6pnn332uGsDBw5k+vTpOJ2xVYPZ2dn84he/OO5TXJ/Px4svvnjaIbOzs7n33nuZM2cOd91113F7SPXt25cnn3yS/Pz84/7djz76iGAweNrPfaYqKirAsjACTbZlEJH2cfgbqaqK34EPIl6vl3vuuYfH//IXevQZwFPrM3hoRQ6h0yyq5ux08+OlOeyz8rjvvvv4058fo3///vENLSIiIiJik3aVVA0NDSxcuPC463V1x28W7fV6qa2tPe76zJkzTyNezPTp0/nWt76F2+0+6WNycnK4+OKLj7tuWRaNjY2n/dxnqu2Ew7a9bkQkcTmCTVRqqZ90gOrqah79n//hvvvuY12DgyfXZXBqx5bAugYnT6zP5IILLuDZ556nrq4Oh8PRMYFFRERERGzQrpJq9erVRKPHf+x7siV2/fr1O+7axo0b8fv9pxjv1GRlZR13zel0kpeX16HP+3lKS0sBMALNtmUQkXaIhrECrZSVldmdRFKUYRjU1dUxdepU5u5K463tae3+d+t9Jr9enU1ZaTk/efDBE/68ExERERFJdu0qqdatW3fC6ye7mSsuLj7uWiQSYePGjacQ7dStXr36uGu9evU6uhzRDl6vF6fLhRFUSSWSyIxAC3Di9y+ReJo2bRqjR43imY0ZrD7wxT+f/BF4ZFU2EYeHh37xC7Kzs89CShERERGRs6/dy/1OJDc394TXTza5dLLvEw/Lli1j6dKlx12/5pprOuw528MwDAoLizA1SZUyLNP5uV9LcmorklVSSUczTZP/+NGPqKqq4jdrctjTevIfxZYFf1qTybYmkwd+8iBVVVVnMamIiIiIyNnVrpKqufnEBcvJ9og62fWmpo7ZPHzbtm1873vfw/q3DT7OP/98Lrvssg55zlNRVlqCGWqxO4bESSSv6nO/luTUViSrpJKzISMjg5//4peY7gweWZlDa/jEj3t5czpL97n5znduZfjw4Wc3pIiIiIjIWdbu0/1O5N9LoS+6bhjGmTzdCa1fv57rr7+effv2HXO9rKyM3/72t7Yu9WtTXFyM4/9v787joir3P4B/ZmEHZZRNEBDcUMEV3HErM62utKmlom3m/aWl3Ztr6q28pqZloamVdtVraXlNc0ktA9wKN9xQUVkUUQEFhGEfZn5/ePGqzMw5M8xwBvi8X6/+6Mwzz/maeWQ+8zzfp5whVX2h8WoHrUMjaJWOKGvRBxqvdlKXRBYgK1f/d+Wjp9SlUAPh6+uLDz+aj5vFCqw454oT2XYP/bPnmgO2pDph8ODBGDVqlNTlEhERERFZnagEx1CD1oqKCr0nC5WXl5s0j7n+/PNPTJo0qdoKLR8fH6xbt85mVkR4e3tDV1YEaCsBOU9iqvNkMujsnQE4Q+PNgKq+kJUXwV3VxCaCbWo4unXrhsmTJ+Pzzz/H6dt21V5vFxKCadOmWeVLHiIiIiIiWyPq05ihHlP5+fnw8fHRe92Uecyxc+dOzJgxAxUVFQ9db9GiBdauXQs/Pz+L3aumqsIyWXkxdI5seEtki+RlajRrXv15RmRtzz//PHr27ImiouorboOCgmBnVz28IiIiIiKqj0SFVCEhIXqv37hxQ29IdfPmzWrXFAoFWrdubWJ5+q1ZswaffPKJ3h5Uq1evRpMmTSxyH0u5H1KVFTKkIrJRyooi+Pjof9YRWZstfbFCRERERCQVUT2pwsLCIJdXH5qUlKR3vL7rbdq0gaOjo4nlPUyr1WL+/PlYvHhxtYBq4MCBWL9+vc0FVADQrFkzAIC8zDqN44mohnRa6MoK7/9ZJSIiIiIiotonKqRyd3dH7969q13ftWtXtWv5+fk4dOhQtetPPfXUQ/+ekJCAtm3bVvvHkLKyMkyZMgUbNmyo9tpLL72EFStWwMnJScwvp9Z5eXlBJpNBxpCKyCbJyosBrZYhFRERERERkYREn+738ssvV7uWmJiIL774AhrNvbOzCwoKMG3aNJSUlDw0zsnJCc8++6zZRd69exevvPIK9u7d+9B1mUyGd999F//4xz/0NnC3FUqlEh6enlxJRWSjqgJkhlRERERERETSEX2M1WOPPYaBAwciNjb2oesrVqzAxo0b4eXlhWvXrqG0tLTae6dMmQIPDw+zi1yyZAlOnDhR7bqTkxP27t1bLbx61IcffojQ0FCz728Jzf38kHXlhqQ1EJF+VQGyr6+vxJUQERERERE1XCadtb5gwQKMGzcOly5deuh6fn6+wRP9nnnmGURHR5tfIVDtBL8qxcXFBvtiPUjfiUm1rVmzZlCcT5a6DCLSQ1ZWCJlMdv+QAyIiIiIiIqp9orf7AUCTJk2wfv16PPHEE4Jj7e3tMXHiRCxevFhv0/WGplmzZtCVFQOVGqlLIaJHyEsL0dTDA0qlSbk9ERERERERWZDJn8hUKhViYmJw8uRJ7N69GwkJCcjOzkZRUREaN26M5s2bIzIyEsOHD4e/v781aq6TqnrdyMoKoXNWSVwNET1IXlYAv5bc6kdERERERCQls5cNdO3aFV27djX7xj169EBysrjtbwsXLsTChQvNvpctaN26NQBAUZQDDUMqItuh1UJRkotWrSKlroSIiIiIiKhB4z68WhIYGAhnFxfIC7OkLoWIHiAvvgNdpUbywxWIiIiIiIgaOoZUtUQulyMsNBR2RdlSl0JED6gKjsPCwiSuhIiIiIiIqGFjSFWLwsLCgOI8QFMqdSlE9F8KdRY8PL3g5eUldSlEREREREQNGkOqWlS1UkNRyNVURDZBp4NdUTY6d+oodSVEREREREQNHkOqWtSuXTvIFQrI1exLRWQLZOVq6MqK2I+KiIiIiIjIBjCkqkWOjo5o1aoVlGyeTmQT2I+KiIiIiIjIdjCkqmXh3bpBrs6GrOSu1KUQNWw6HexuX4arWyMEBwdLXQ0REREREVGDx5Cqlo0YMQIODvawzzgqdSlEDZri7nUo7mbilfHjoFAopC6HiIiIiIiowWNIVcuaNGmCsWPGQJl3FfKCm1KXQ9Qw6bRwzDiKZr6+iIqKkroaIiIiIiIiAkMqSYwYMQJNPTzgmHEU0OmkLoeowVFmJwPFeXjr//4PdnZ2UpdDREREREREYEglCUdHR0x8803I1DlQ3LkidTlEDYumHI43TiIsrCMiIyOlroaIiIiIiIj+iyGVRAYPHozWrdvA8foJQKuRuhyiBsPu5mnoykswefIkyGQyqcshIiIiIiKi/2JIJRG5XI7JkycBZWrY3TwndTlEDYKsTA2HW0kYPHgwQkJCpC6HiIiIiIiIHsCQSkKdO3dGnz594HDrNJuoE1mbpgwOqQegVMgxYcIEqashIiIiIiKiRzCkktiUKVPg6+MNp4u7obx5jo3UiaxAVpwLl/M/w64oC3/727vw9vaWuiQiIiIiIiJ6BEMqiXl7e+Obr79G3z594HDtTzikxAGV7FFFZCmKO6lwOb8D7o5yxHzxBYYNGyZ1SURERERERKQHQyob4OLigvnz5+ONN96AMjcVzhd2QFZaIHVZRHWbTgu7awlwSeCGnAAAIABJREFUvPI72oW0wdo1axAWFiZ1VURERERERGQAQyobIZfLMXbsWCz55BO4ogwu57dDkZ8hdVlEdVNFCRwv7oH9zbOIiopCzBdfwMPDQ+qqiIiIiIiIyAiGVDame/fuWLPmGwT5N4dj8j7YZSayTxWRCeRFt+Fy/mc4lORg5syZePfdd2FnZyd1WURERERERCSAIZUN8vX1xapVK/H444/B/voJOFz+DdCUS10Wkc1T5lyC8/kd8HB1xJcrVmDo0KFSl0REREREREQiMaSyUY6OjpgzZw4mT54M+7sZcDn/M+TqbKnLIrJNFaWwTzsEh9QD6NypI9auXYOQkBCpqyIiIiIiIiITKKUugAyTyWR48cUX0bp1a7w/Zy6Q9DO0bj4o9wlFpSoAkDFjpIZNVnoXdjfPwf7OZegqNRg1ahQmTJgApZKPNiIiIiIiorqGn+TqgM6dO2Pzpu+xa9cubP7hR+Rc/g1waowyrw7QeLYGFOy3Qw2ITgd54S3Y3ToLZd41KJRKPPHEYIwcORLBwcFSV0dERERERERmkul07Mrdtm3bateSk5MlqESYRqPBwYMH8f33m3Dx4gXI7BxQ5hkCjXd76OxdpC6vwXA8vxMAUNr+aYkraUC0Wihy0+CQdQ4ydQ5c3RrhuWej8Oyzz6Jp06ZSV0dEREREREQ1xJAKdSukqqLT6XDu3Dls3rwZBw8ehE4mQ0WTYGh8wqB14Qd2a2NIVYs0ZVDmJMMh6zxQpoafX3OMGjUSQ4YMgaOjo9TVERERERERkYVwu18dJZPJEBYWhrCwMGRmZmLLli3YuXMXym5fQWUjX1Q0C0Nl4+aATCZ1qURmkZUWwi7rHOxvX4JOU4FOnTvjpVGj0LNnT8jl7MdGRERERERU33AlFermSip9CgsL8fPPP+OHH7cgL/cO4KxCmXcHaDxaAXLmkZbElVTWIy/M/m+/qXTI5XI8NmgQRowYoffPKREREREREdUfDKlQf0KqKhUVFYiNjcX3mzYh5coVyOydUOYZggrv9oCdk9Tl1QsMqSxMp4Ui7yrsb52DvDALzi4uiBo+HM899xy8vLykro6IiIiIiIhqAUMq1L+QqopOp8OpU6ewadMm/PHHH5DJFaho3ByaJkGodA8AlPZSl1hnMaSyAJ0OcnU2lLlpsM9Lh65MDW8fH4waORJDhw6Fs7Oz1BUSERERERFRLeIesHpMJpOhS5cu6NKlC65du4affvoJv8fGIS8l7l5g1cgPmqZBqHQPZGBFtUNPMKVQKtE9IgJDhw5FZGQkFAqF1FUSERERERGRBLiSCvV3JZU+Wq0W586dQ2xsLGLj4pB75w4gV0DTyA+VTYKgUTGwEoMrqUyg00GuznogmCqCQqlEj+7dMXDgQPTp0weurq5SV0lEREREREQSY0iFhhVSPUir1SIpKQlxcXH4PTYWd27fhkyugKaRLzRNgqFRBQBKB6nLtEkMqQRUBVN30mCf/79gqmePHhg4cCB69+7NYIqIiIiIiIgewpAKDTekepBWq8X58+fvBVa/x+L27RxALkdlIz9o7q+wYmBVhSGVHjod5IVZUOamwj7/KnRlRVDa2aFH9x4YOHAA+vTpAxcXF6mrJCIiIiIiIhvFkAoMqR6l1Wpx4cIFxMbG4vfYONzOyWZg9QiGVP+l0/43mEp7KJh6cMUUgykiIiIiIiISgyEVGFIZo9PpHgisYpGTXRVYPbgl0FHqMmtdgw6pHgym8tKhKy+GnZ09evXqiYEDB6JXr148mY+IiIiIiIhMxpAKDKnEqgqsqnpYZWdlAbKqwOq/K6zsGkZg1eBCKp0W8oJb/1sxVV4MO3t79O7VCwMGDGAwRURERERERDXGkAoMqcyh0+mQnJx8b4XV77HIyroFyGSodGsGjaoFKpsEQmdff7d5KXMuAwA0nq0lrsSKtJVQFNyAIjcN9vnXoKsovR9MDRw4ED179mQwRURERERERBbDkAoMqWpKp9Ph8uXLiI+PR2xcHK5nZAAAtG7eqFAFolLVAjrHRhJXSaJUVkBx9zqUuemwu5sBnaYcTk7O6NOnN/r374/u3bvDyclJ6iqJiIiIiIioHmJIBYZUlpaeno4DBw4gNi4OKVeuAAB0Lk1RoWoBjaoFdM4qiSukh2jKoMi/di+YKsiErlIDV7dG6N8vEv369UO3bt1gb28vdZVERERERERUzzGkAkMqa7px4wYOHDiAuPh4nE9KunfR2R3l7oGobBIErXNTQCaTtsiGqKIEyryrUOamQ1F4A9BqoWrSFAP690P//v3RsWNHKJVKqaskIiIiIiKiBoQhFRhS1Zbbt2/j4MGDiIuLx+nTp6DVagFHN1S4B0LTpAW0rt4MrKxIVlYERV46lHnpUBTeAnQ6eHv7YODAAejXrx/at28PuVwudZlERERERETUQDGkAkMqKeTn5+Pw4cOIj4/HsePHUanRQGbvjHL3AGiaBEHr1gxgYFJjstK797bx5V2FTJ0NAAgICLwfTLVq1QoyBoNERERERERkAxhSgSGV1IqKivDHH38gPj4ef/z5J8rLyiCzc0R5Y39UNmmBysZ+gJxbz0TR6SArybsXTOVfhazoDgCgdes2GDCgP/r164fAwECJiyQiIiIiIiKqjiEVGFLZktLSUhw7dgxxcXE4dPgISoqLIFPao7xJS1R4h0Dn3FTqEm2TphzK25fhkJMMFOdCJpOhfYcOGDhgACIjI9GsWTOpKyQiIiIiIiIyiiEVGFLZqoqKCpw8eRL79u1DbFwcNBUV0Lp5o8IzBJqmQVxdBUCuzoEy+wLsc9Ogq6xA69Zt8PTTTyEyMhIeHh5Sl0dEREREREQkGkMqMKSqC+7evYs9e/bgp23bcCMz8952wKatUOHVDjqnxlKXV7sqK6C8kwL7nGTI1Dmwd3DA4Mcfx/DhwxESEiJ1dURERERERERmYUgFhlR1iU6nw8mTJ7F9+3YcOHgQ2spKVDbyRYVXCCpVgYBcIXWJViMrzoVd9kXY37kCnaYcgYEt8OyzUXjiiSfg6uoqdXlERERERERENcKQCgyp6qo7d+5g9+7d2Lb9Z+RkZ0Fm74wyj9bQeIVA5+AmdXmWodVAkZsG++yLkBdmQaFUYtDAgYiKikJoaChP5iMiIiIiIqJ6gyEVGFLVdZWVlTh69Ci2b9+OP/74AzqdDpXu/vdWV7n7AzK51CWaTFZy97+rpi5DV1GKZr6+eDYqCk8++STc3d2lLo+IiIiIiIjI4hhSgSFVfZKVlYWdO3fi5593IC8vFzJHV5Q1bQONV1vo7F2kLs84rRaKvKuwy7kAxd0bkCsUiOzbF1FRUejSpQvk8roXthERERERERGJxZAKDKnqI41Gg8OHD2Pb9u04cfw4IJNB4x6ACr8u0LrY2Kl3leWwu3kWDjnJ0JUXw8PTC1HD/4Jhw4bxhD4iIiIiIiJqMBhSgSFVfXf9+nXs2LEDO3buglpdiPJmHVHh1wWQK6UuDfK7mXBKPwSUqdGrZ09ERUWhe/fuUCjqbwN4IiIiIiIiIn0YUoEhVUNRWFiIFStWYPfu3YCzCiVBkdC6eklTjKYc9hlHYZd9EX5+zTFr1kyEhYVJUwsRERERERGRDWBIBYZUDU1CQgIWLlqEO3fuoNwnFBXNu9XqqipF/nU4ph+CrLwIo0aNwquvvgoHB4dauz8RERERERGRLWJIBYZUDZFarcaXX36JnTt3Ak7u91ZVuXlb96aaMthfS4BdziX4BwRg9qxZaN++vXXvSURERERERFRHMKQCQ6qG7NixY/h44SLczslGhU8oypuHAwrLr6pS5F2D09XDkFWU4OWXX8a4ceO4eoqIiIiIiIjoAQypwJCqoSsuLsbKlSuxfft2wKkxSlpEQtvIxzKTa8pgf/VP2N2+jMAWLTB71iyEhIRYZm4iIiIiIiKieoQhFRhS0T0nT57Exx8vRFZWFiq826PcPxxQ2Jk9nyLvKpyuHoFMU4qxY8Zg7NixsLe3t2DFRERERERERPUHQyowpKL/KS4uxldffYWtW7cCLk1R1O4Zs7b/KW+egcO1owgObolZs2aiTZs2VqiWiIiIiIiIqP6QS10AkS1xdnbGlClT8PHHHwNFd2B/LcHkOeTqbDhkHEO/fv3x9ddfMaAiIiIiIiIiEoEhFZEeffr0wUsvvQS77AtQ5F4V/8bKcjilxMHT0xPTp0+DnZ352wWJiIiIiIiIGhKGVEQGvP7662jVqjWc0g9CVl4k6j326X9AVlaIeXPnws3NzcoVEhEREREREdUfDKmIDLCzs8M//jEPdnIdHFLjAYH2bYrbKbC7fRnjxo1Dx44da6lKIiIiIiIiovqBIRWREQEBAZjyzjtQ3L0Bu5tnDY6TlRXC6ephtO/QAdHR0bVYIREREREREVH9wJCKSMBTTz2F/v37w/76ccjVOdUH6LRwTImDo50S8+bOhVJp+mmARERERERERA0dP00TCZDJZJg2bRqSks7jdmosylXBD70uL70LeWEW3ps7F82aNZOoSiIiIiIiIqK6jSupiERwc3PDvHlz4arQweHm6Yf+sctLx3PPPYfHH39c6jKJiIiIiIiI6iyZTifQDboBaNu2bbVrycnJElRCRERERERERNQwcSUVERERERERERFJjiEVERERERERERFJjiEVERERERERERFJjiEVERERERERERFJjiEVERERERERERFJjiEVERERERERERFJjiEVERERERERERFJTmnuGxMTE7F7924kJCQgOzsbarUa7u7uaN68Ofr27Yvhw4fD39/fkrXaxL2JiIiIiIiIiMjyZDqdTmfKG/Ly8jBv3jzs3bvX6Dh7e3u89tprePvttyGXW2bBlrXu3bZt22rXkpOTza6TiIiIiIiIiIhMY1JIlZubi3HjxuHSpUuib/DMM89g8eLFNQ6qrHlvhlRERERERERERNIyKTmaNWuW3pDI3d0drVu3hqOjY7XXduzYgfXr15tfoQ3cm4iIiIiIiIiIrEt0SLV//37ExsZWu/7WW2/h8OHD2LlzJw4dOoQBAwZUG7Ns2TLcvn3b7CKlvDcREREREREREVmf6JDqu+++q3atS5cuePvtt6FU3uu/7ubmhkWLFsHJyemhcSUlJdi6davZRUp5byIiIiIiIiIisj5RIVVeXh6OHDlS7frTTz9d7Zq7uzsiIyOrXd+1a5cZ5Ul7byIiIiIiIiIiqh2iQqpz585Bq9VWu96hQwe940NDQ6tdu3z5MkpLS00sT9p7ExERERERERFR7RAVUl28eFHvdV9fX73Xvb29q12rrKzE5cuXTShN+nsTEREREREREVHtEL3dT5/GjRvrva5SqUyax1bvTUREREREREREtUNUSKVWq/Vet7e3N+l6YWGhyLJs495ERERERERERFQ7RJ/up49OpzPpukwmq8ntbObeRERERERERERkWaJCKldXV73XKyoq9F4vLy83aR5bvTcREREREREREdUOUSGVoT5P+fn5Jl03NI+t3puIiIiIiIiIiGqHqJAqJCRE7/UbN27ovX7z5s1q1xQKBVq3bm1CadLfm4iIiIiIiIiIaoeokCosLAxyefWhSUlJesfru96mTRs4OjqaWJ609yYiIiIiIiIiotohKqRyd3dH7969q13ftWtXtWv5+fk4dOhQtetPPfXUQ/+ekJCAtm3bVvunNu5NRERERERERES2RfTpfi+//HK1a4mJifjiiy+g0WgAAAUFBZg2bRpKSkoeGufk5IRnn33W7CKlvDcREREREREREVmfUuzAxx57DAMHDkRsbOxD11esWIGNGzfCy8sL165dQ2lpabX3TpkyBR4eHmYXKeW9iYiIiIiIiIjI+kSvpAKABQsWoE2bNtWu5+fn49KlS3pDomeeeQbR0dHmV2gD9yYiIiIiIiIiIusyKaRq0qQJ1q9fjyeeeEJwrL29PSZOnIjFixfrbXxuKinvTURERERERERE1iV6u18VlUqFmJgYnDx5Ert370ZCQgKys7NRVFSExo0bo3nz5oiMjMTw4cPh7+9v0WKlvDcREREREREREVmPTKfT6aQuQmr6ThVMTk6WoBIiIiIiIiIiooaJe+GIiIiIiIiIiEhyDKmIiIiIiIiIiEhyDKmIiIiIiIiIiEhyJjdObyj09akiIiIiIiIiIiLzGesBzpVUREREREREREQkOYZUREREREREREQkOYZUREREREREREQkOYZUREREREREREQkOZlOp9NJXQQRERERERERETVsXElFRERERERERESSY0hFRERERERERESSY0hFRERERERERESSU0pdAFFtGzRoEDIzMw2+7ufnh99//93oHDNmzMBPP/1kdMz+/fvRvHlzs2okIiIiIiIgJiYGy5cvNzpm/fr16NGjRy1VRA1FQkICoqOjjY6ZNGkSJk+eXEsVNQwMqRoojUaDK1euIDU1FWq1GoWFhSgrK4ODgwMcHR3h4uICT09PeHl5wcfHB25ublKXTERUp1VWViItLQ2ZmZm4desWioqKUFpaCqVSCVdXV7i4uMDPzw8tW7aESqWSulwikhCfF0RE1FAxpGpACgsLsWPHDvz8889ISkpCeXm56Pd6enoiODgYLVu2RFhYGDp16oTg4GDIZDIrVkxEZHlbt27FzJkzBcclJyfX+F5XrlzBr7/+igMHDuD8+fMoLS0V9T5PT090794dkZGR6NevH5o2bVptjNhfh7Xx22uqz+rL8wIASkpKEBERgYqKCoNzOTg44Pjx47C3txdd98SJExEbG2t0zIgRI/DRRx+JnvP27dvo06eP0TFBQUHYs2eP6DnJPLX1d40l/gwRUf3AkKoB0Gg0+Oabb7By5UrRP/A8KicnBzk5OUhISLh/rWnTpjhy5IilyiQiqjf279+PNWvW4MSJE2a9PycnB7t27cKuXbugVCoxaNAgjBo1Cr179+aXA0T1TG09L5ycnNC+fXucPn3a4FxlZWU4c+YMwsPDRd1bp9Ph5MmTguOOHz8uar4qx44dExwjtkYiW2WJFiTGtG3b1ujr3bt3x4YNG8yen8haGFLVczk5OZgwYQLOnz9v8bkLCwstPicRUV2WkpKC2bNnIzEx0WJzajQa7Nu3D/v27WOvO6J6RIrnRXh4uNGQCgBOnDghOgC6dOkS7t69KzguNTUVubm5aNKkiah5xQR2DKmIiOonnu5Xj+Xl5eGVV16xSkBFREQP27RpE6Kioiz6gZOI6iepnhdigh0xq5iqmLJCypSVYmJq6Natm+j5iIio7mBIVY/NnTsXly9flroMIqJ6b9GiRZg3b55Jvf6IqGGS8nkRHh4Oudz4j/+JiYmorKwUNZ8pwZPYQKugoACXLl0yOsbb2xv+/v6i701ERHUHt/vVU0ePHsW+fftEjZXJZPDy8oKnpyccHBxQUlKCu3fvIjc3FyUlJVautPbVZG83EdGjli5dirVr15r8PldXV3h4eEClUqG4uBh5eXnIy8sz2tSYiOo2qZ8XjRo1QuvWrY02qVar1bh48SI6dOggOJ8pK6nEjj158iS0Wq3RMdzqR0S1oUePHmzqLwGGVPXUxo0bBce0adMGb775Jvr164dGjRpVe12n0yE9PR0XLlzAyZMnERcXh4yMDGuUS0RUJ+3YsQNfffWV6PHe3t4YM2YM+vXrh5CQkGqvl5eX48yZMzhx4gR++eUXXLhwwZLlEpGEbOV5ER4eLvih69ixY4IhVUZGBrKyskTdEwAuXLgAtVoNV1dXwXsL4VY/IqL6iyFVPVRRUYHDhw8bHdO5c2esX78eDg4OBsfIZDIEBQUhKCgIw4YNw/vvv4+UlBTs3LkTW7ZsQX5+vqVLJyKqM27duoW5c+eKGiuTyfDXv/4VEyZMgJOTk8Fx9vb2CA8PR3h4ON58800cP34c69evx969e6uNfe655/Dcc8+JrjchIQHR0dGC49icncjypH5ePCg8PFzwy8wTJ05g/PjxRseYemJfZWUlTp06hb59+9Z4Xq6ksj1cbUJElsKQqh5KSUkRPHnv//7v/4wGVIa0bNkS77zzDt566y0cPHjQ3BJFKS8vx9mzZ5GSkoL8/HwoFAp4eXnB398fHTt2FOypQPeW7J87dw65ubnIz89HYWEhHBwc4O7uDnd3d4SEhMDHx8fi99XpdLh16xbS0tJw48YNlJSUoLi4GFqtFk5OTnB2doa3t/f9nhIuLi4Wr4HI2hYuXIji4mLBcXZ2dli8eDGGDRtm8j2qPoD++eef+PDDD80pk4hsgC09LyIiIgTnEhMUGRrj4OCAsrIyg+8xFlKVlpYiKSnJ6H0bN26MNm3aCNZHRNLRarW4dOkSrl+/jvz8fBQUFKCiouL+ZxBfX1+0b98eCoVCkvrUajVOnz6N9PR0FBYWQqPRwMnJCU8++ST8/PwkqUmfkpISnDp1CmlpaSgoKICDgwNUKhVatmyJDh06WPzzcFpaGi5duoTs7Gyo1Wq4ubkhICAAnTp1QuPGjS16L2MYUtVDt2/fFhwTEBBQo3solUoMHDhQ1NixY8fi6NGjRsc8+O3L9evXsXr1auzcudPgD3Senp4YNmwYJk6cKPo44yqDBg1CZmamwdf9/PxqrW/V7t278d5770Gj0Rgd1717d6xcuVJwiTwAXL16Fd9//z3+/PNPJCcnC/Z18Pf3R69evTB69Gi92wlMER8fj927dyM+Ph55eXmi3iOTyeDv74+QkBB07NgRERER6NChA+zs7GpUC5E1paSkYM+ePaLGzp4926wPnA/q2bMntm/fDp1OV6N5iKj22drzwtPTE4GBgbh69arBOXJzc5GSkoKWLVsaHGMopOrRowdSU1Nx/fr1aq8JNVpPTEwU7LPVtWtXyGQyo2OIHjVjxgz89NNPRseIXUlszmcJsauZH5SZmYm2bdsaHVN1r61bt2LmzJkmzX/06FHB+bt3744NGzaImq+0tBTbtm3Db7/9hsTERKjVaqPjXVxc0LVrV/zlL3/BsGHDoFSaHk2YWn9SUhJWrlyJuLg4vc+awMDAh0IqMb9vkyZNwuTJky1a5/nz5/H111/jt99+M3jIhkqlwogRI/DGG2/Azc3N6PzGaDQabNy4EVu2bDF4aIVCoUDfvn0xYcKEh1aymvo5XyyGVPWQmG146enpCAoKqoVqTLNhwwZ88sknBr+Bq5KTk4N169Zh+/btmD17Nv7yl7/UUoWWs3PnTkybNk3wBJ1BgwZh2bJlgivfrly5gmXLlmH//v2CwdSDMjIykJGRgR9++AH9+vXDzJkzERwcLPr9VfeeNWsWTp8+bdL7gHurrq5du4Zr167db/bv4+OD+Ph4k+ciqi0bNmwQFRgNGDAAL730kkXuyeCWqG6yxedFeHi40ZAKuBdCGQqp7ty5g/T0dL2vRUREoEmTJnpDqtOnT6O8vBz29vZ63yvmtEBu9SOyLeXl5fjqq6/w73//W/SX1ABQVFSEgwcP4uDBg1i2bBkmTZpkUhsDU+h0OsTExGDVqlWiTy+VQllZGRYvXoyNGzcK/r2Rl5eH1atXY+vWrfjqq6/Qvn17k+939uxZzJo1S/BE1crKSsTHxyM+Ph4jRozA+++/b9auLLG4X6oeEvM/zCeffGJSs0tr0+l0+OCDDzB//nzBgOpB+fn5eO+99/Cvf/3LesVZwbZt20QFVFFRUYiJiRH8Pf3xxx/xwgsv4NdffzUpoHrUgQMH8Pzzz2P79u2i35OYmIiXXnrJrIDKkNLSUovNRWRplZWVok9PnTJlipWrISJbZqvPCzFb/ow1MDf2Wrdu3QwGSWVlZTh79qxZ81ZhSEVkO9LS0jBixAjExMSYFFA9KjMzEzNnzsTf/vY3wRVY5nj//fexYsUKmw6ocnNzMWbMGPz73/82aeV8Tk4Oxo4di8uXL5t0v6NHjyI6OlowoHrUDz/8gPHjx1vl96kKQ6p6SMz2t5SUFAwdOhT//Oc/kZiYKPkf2KVLl+K7774z+/0ff/wxNm/ebMGKrKdqOa7Qf/Po6GgsXLhQcOnrggUL8P7776OkpMQi9RUXF2PatGn45ptvBMcWFRXhb3/7GwoKCixyb6K64Ny5c7hz547guPDwcLRr164WKiIiW2WrzwsxQY+xVU3G+lGFhYUZDcEMzVtRUSH4hZejo6PgqYNEVDtOnTqF5557zqInEe/cuRPR0dGieviJtWrVKmzZssVi81lDQUEBxo8fjzNnzpj1frVajenTpwu2kKly5swZvPHGG2b/dz558iQmT54s+n6m4na/eigkJAR2dnaCe/qLioqwfv16rF+/Hs7OzggLC0NoaChCQ0PRoUMHBAQE1Nqe/6+//rrGc3z88cfo2bMnAgMDLVCRdfz444+YM2eOYDo+efJkTJo0SXC+b7/9FuvWrbNUeQ9ZsmQJfH19jfbG+M9//mN0Tz5RfZSYmChq3KBBg6xcCRHZOlt9Xvj7+8PHxwe3bt0yOObGjRvIzMzU20TYUNDUsWNH2Nvbo0WLFvD09EROTk61McePH8eECROqXU9KShL8wq1Tp07c+myjhHruGHPs2DE0atTIgtWQtWVkZOCvf/2rRcOkKklJSZg6dSq+/PLLGjdWT0tLw8mTJy1UmfVcvHixxnMkJSVh3759gn0NS0pK8N5779V458qRI0dq9H5jGFLVQy4uLujSpYtgE7MHFRcXIyEhAQkJCfevubu7o1u3boiIiMCAAQNqtYeVl5cXmjVrhpKSEly7dk3UH6KSkhK8//77opv71bZNmzbhH//4h9GASiaTYc6cORg9erTgfCdOnMDixYtF3VupVCIwMBCNGzdGWVkZ0tLSBP9S0el0mD17NiIiIuDp6al3jNgtDJ6envD29oaDgwNKS0uhVquRnZ1tsdVfRLVJ7LLozp07W7kSIrJ1tvy8CA8Px86dO42OOXbsWLWQSq1WG2yE++BU5VwoAAAbH0lEQVQKrfDwcPzyyy/Vxpw8eRJarbbaqVTc6kdUN2i1Wrz11lvIzc0VNd7Lyws+Pj5QKBS4desWbt68KfieuLg4bNiwAePHj69RrfqC8rrC19cXXl5eyM3NxbVr10S9Z/PmzYIhVUxMjMGego+SyWQIDAyESqVCXl4erl69WiuH+DCkqqdeeeUVk0IqffLz87F//37s378fCxcuRIcOHfDCCy/ghRdeMNjwsqbCw8MxY8YMhIWF3b9WXFyMrVu34tNPP0VRUZHR9x89ehSnT59Gp06drFKfuTZu3IiPPvrI6B9qpVKJhQsX4plnnhE159KlSwX7T/n5+WHy5MkYMmQInJ2d71+vrKzE77//jkWLFiEjI8Pg+4uLi7F8+XJ88MEHel9PTU01ev+nn34ab7/9tt7VbTqdDjdu3MCVK1dw7NgxHD16FElJSVZbNkpkKTdu3BA1rqanZRJR3WfLz4tu3boJhlTHjx9HVFTUQ9dOnjxpsGXBgyFSRESE3pCqsLAQly5dqvZrNrSF0ND8RHVJu3btsH79+oeuvfvuu0ZPZffw8MCnn35qdN6qvrWRkZHV5hc6lS4kJASzZs0yOkbfCrft27cLntimVCoxevRojBkzptqp8qmpqVixYoXg82flypV44YUXRJ1uboo2bdqgU6dOUKlUKCwsxK1bt5CcnCz6eW1tkZGRmD59Olq3bn3/2rlz5zBz5kzBLz6OHz+O0tJSODo66n1drVZj06ZNouoYOXIk3nrrLXh7e9+/dvPmTSxfvtzq2ycZUtVTgwYNQv/+/S16QlpSUhKSkpLwzTffYNq0aXjyySctNjcA9OvXD19++WW1ZdzOzs4YM2YM2rVrh/Hjxxs8hrPKhg0bbCqkWrduHRYsWGB0jKOjIz7//HMMGDBA1JyHDh0SPAGnXbt2+Ne//gV3d/dqrykUCgwePBjh4eEYNWqU0TR9y5YteOedd/T2OjPWILF58+ZYsmSJwS2jMpkMfn5+8PPzQ//+/e/P9+uvv+Lw4cNGf21EUhLzzaGdnR1cXFxqoRoismW2/LwQ0zxdX3Bk6OcPhULx0Iqwbt26GZ33wZBKq9UKbslRKpVcoUp1VqNGjdCjR4+HrgkdjOTg4FDtPYZ4enoa3PlgSk1CKisrERMTY3SMUqnEl19+ef/n+0cFBwdj6dKl8PHxMdoDNz8/H5s3b8Zrr71mUo2GdO3aFXPmzDF4Ct7Zs2fh5uZmkXuZa/jw4Vi0aFG1z0+hoaFYu3YtnnrqKdy9e9fg+zUaDS5cuIAuXbrofX3Lli2Ciz6AewHqm2++We16s2bN8M9//hPNmjUT/P+gJtg4vR5bsmQJ2rRpY/F5MzMz8c477wgGL6ZwcXHBggULjPYZ6NatG1599VXBueLi4mp0wp0lffvtt4L/ndzc3LBmzRrRARUAvd9MPkgul2PJkiV6A6oHqVQq/P3vfzc6RqPR4NChQ3pfc3JyMvg+Z2dnk3uaqVQqjBgxAp9//rlJ7yOqTWK2Hzdu3LgWKiEiW2fLz4tWrVoJ/pyQlpZWrfG7oW15ISEhD614aNu2rcFf26NzXLp0SfAQlnbt2j20KpyIat/Zs2cF+9FGR0cbDKgeNGXKFMFgLS4uzpTyDBo4cCDWrVtnMKACgLCwMLRo0cIi9zOHr68vPvjgA4Ofnzw9PfHEE08IznP16lWDr4lZwNKlSxe9fQMf9NZbb6Fjx46Cc5mLIVU91qhRI2zatAlDhgyxyvzr1q3DihUrLDLXsGHDRKX/o0ePrtbD4FGFhYUmH8FpDWvWrMHChQuNjmnatCk2bNhg8vJ1Q6FRlS5duqBVq1ai5urevbvgmAMHDui97uvra/A9ly5dwqpVqwRXvhHVR7V16AQR1X1SPS9kMpnR1U5VHlxNVV5ejrNnz+od9+jPMjKZDF27dtU79tHVWGK2+olZ+UVE1iX0GQQAXnzxRVFz2dnZGVzxUyUxMRFqtVrUfIZ4enpi4cKFVmtXYynjxo0zugAAELc1vLCwUO/1yspKnDp1SvD9r7zyiuDfSzKZDOPGjROcy1zc7lfPubi44IsvvsChQ4fw6aefIikpyaLzL1++HEOGDBEdiBgiJm0H7jXea9euneCv48yZMzU6ZcQSvvvuO6Ov+/n5Ye3atSYn9hkZGUZP4wHu/fBnyV+/od5TvXv3NhoIfvbZZ/jqq6/QsWNHBAUFwd/fH/7+/ggICECLFi0ElzkT2SJD+/wfZGwpNhE1HLb+vIiIiMD+/fuNjjl27Nj9LzzPnDlj8MsnfSFSREQEYmNjq13PycnB1atX7/esFNM0XUygRkTWJebP6tChQy12v4qKCmRkZKBdu3ZmzzF69GjBVaO2QMwqqaZNmwqOMRRSpaamCh6cJZfLERkZKXgPABgwYABkMplVGqkzpGog+vbti759++LcuXP46aefcODAAdGnBBij1WqxatUqLFmypEbzmNIwtG3btoIhla2f5NCqVSusXbv2oUZ0YmVnZ1uhIuMM9dR4+eWX8d1336GiosLge4uKivDHH3/gjz/+eOi6QqFAYGAgOnbsiO7du6N///7w8PCwaN1E1qBSqQTHlJeXo7i4mFtTiBo4W39eiFnJ/eAqJ2MrnvSFSMZWPx0/fvx+SCXUZ9PYqiyyDUKNtKl+kOJzyKNbjk0ldNqdLVCpVEZ3qFQR8/eEoYMtxPx3DAgIEP13kaurK3x9fQW3f5qD2/0amNDQUMyZMwe//vrr/dPdRo8ejdDQUKP9oIyJj4+vcQ8ofU25DRHzA5+tr2KYN2+eWQEVYLxZubUYumeLFi0wZcoUs+asrKxEamoqtm3bhlmzZiEyMhITJkwQ/EGVSGpifogAgIsXL1q5EiKydbb+vGjfvr1g0/bk5OT738wbCqmCg4P1/izXvn17gx94quZKT08X/HKxZcuWJv2sSETWYUufQ8Ro3Lix3lPGbY3Yz4Xmfl4HxH0+FvM5uybjxWJI1YD5+fkhKioKc+fOxX/+8x+cOHEC69atw8SJE03aglZQUCB4HKYQMcvhq4hJd8WcWiClKVOm4MqVK2a9V6ixqDUYWyn1+uuvY+7cuTX+Blir1SI+Ph4vv/yy4HG7RFISeyBFYmKilSshIltn688LhUIh2BOm6uQ9rVZrsE5DK7KMnchX9aUUt/pRXWMrBzRJwdY+hwgxd1FAbXvw0AljatLDUEyfYFNDMGv1+WJIRfc5ODigZ8+emDp1Kvbs2YMVK1aI2vcK1Hzpp5jTb6oI7aUFYPNHv9+5cwfjx4832OvJGKXS9nbpjh49Gnv37sWkSZPg5+dX4/lWr16Nf/3rXzUvjMgKxB6Brq8PCxE1LHXheSFmy9+xY8dw4cIFgw2Mjc1h6LWrV68iOztbVNN0Uw+YITKH2PCppo286zJb/BxijJubm9QliCJ0MJip4/Rp1KiR4BhTF3pY689C3fq/jGqNTCbD448/Dg8PD4wcOVJwfE231+Xm5ooOlsQs+bSF498dHBxQVlZm8PWcnBxER0djw4YNCAoKEj2vmGWVzz//PBYsWCB6Tkvw8vLC5MmTMXnyZKSlpd3/gTY1NRXp6enIzs426ZunmJgYREVF1YlGh9SwdOzYESqVSvBZdOzYMVy8eNGknntEVL/UheeF2L5Uxk5hNjaHUF8qhlRkK4z93F5FrVY36JBKpVIZPcBJqVQiMTHRZk7SUygUUpdgM8R8Pr5586bo+XQ6nVX6UQFcSUUCOnfujJYtWwqOq+lWL1N6MYjZWmjsB6nasnjxYsHgLScnB+PGjcPVq1dFz9u8eXPBMZY+xdFUQUFBGDFiBObNm4d169YhPj4eZ86cwb59+7B69WpMnDhRcMWVWq1GXFxc7RRMZAKFQiHqBBYAWLZsmZWrISJbVheeF506dRL8QHnu3DkcPnxY72vNmjUz+nd6p06dDG4h2bVrF65fv2703r6+vqJ7exEZImYFiphVJBcuXLDKaWZ1hdDnEI1Gwyb6NiogIEBwTG5urujg6dKlS1ZrscOQqh4qKyurdpJaTYhJXWvaNC0+Pl7UuJycHFy4cEFwXMeOHWtUjyWEhoZi9erVgv22srKyMG7cOGRkZIiat0WLFoLLNS9evIiUlBTRtRpjqX33dnZ2CAwMxIABAzB16lRs375dsPcZe/qQrRo7dqyovgCxsbH44YcfLHLPiooKUf0EiMi22Przwt7eXvDnpoqKChw4cEDva0L9ohwcHBAWFqb3tf379wvWx35UZAliev6IaV+yb98+S5QjirXDMHPmDw0NFRyze/duc8qppiH3/rKGJk2aiNq9I/b3b/v27TUtySCGVPVQWVkZxo8fj5EjR9a4x0F5ebmovkk+Pj41us/u3bsFT3YBgI0bNxo8VrOKq6srWrduXaN6LCUiIgLLly8XbEJ38+ZNREdHC36bCNzbitmrVy/BcZ988onoOvW5ffs2Fi1ahI8//rhG8xji5uaGyMhIo2NqeuQskbW0bt1a9OqIjz76CHv27KnR/RISEhAVFSXJ0c9EVDN14XkhZjudoQ+0Yt5raMufmA/JxrYLEoklph+P0E6EnJwcbN261VIlCe5EqWmTcqH5zWnX0rdvX8Ex33//vajPNIZotVrs2LEDTz/9tNlzkH7du3cXHLNmzRrBLerXrl3Dxo0bLVVWNQyp6rFTp05h4sSJGDp0KFatWmXWw+LTTz9Ffn6+0THNmzev8TLsoqIizJo1CxqNxuCYU6dOYe3atYJzDRw4sEZN5SwtMjISS5cuFdwTfePGDURHR+PGjRuCc/7lL38RHBMbG4uFCxea/C3EmTNn8MEHH+Cxxx7D2rVrjTaqX7hwIaZPn46EhASzvo0RWg5s7P8HIqlNnz5d1Fbn8vJyTJ06FcuXLzfpkAjg3nPvnXfeQXR0tNknghKR9Gz9eVGTnk9iQqSazM9+VGQJYrY6bdu2zWC/qfLycsyYMcOi/aiEVnep1WpRPdsMEWo7kpKSYvLnw169egm2VSkpKcEbb7xhtHeVPrdv38b69esxbNgw/P3vf7fYrhD6nxdeeEFwTF5eHiZMmIDbt2/rff3q1at4/fXXTf47yhRsnN4ApKam4rPPPsOyZcvQuXNn9OjRA127dkWnTp30NqWuqKjA8ePH8c033+DQoUOC84tJ1MU4cOAAxo8fjxkzZjy0lLSkpARbt27Fp59+Kqqh4dixYy1SjyUNGTIECxYswIwZM4yGOZmZmfebqTdr1szguEGDBiE4OFhwldu3336LY8eO4bXXXkP//v31/mWVk5OD06dP49SpU9i3b59J/bGKi4uxbds2bNu2DSqVCj179kTv3r0REhKC4OBgg3/5pqSk4Msvv8TRo0eNzu/l5SW6FqLa5ufnh3nz5mH69OmCY7VaLWJiYvDjjz9i9OjRGDBggN6j6SsqKpCUlITjx4/jl19+wblz56xROhHVMlt/XnTt2hUKhUJwtfqj3N3dRfUuNXd+lUqF4OBgk95DpI+YViC3bt3C66+/jkWLFiEwMPD+9TNnzmDBggUWb0Ph5+cnOOekSZMwZswYhISEwNXVtdrW4c6dO8PBwUHve5s3b250p0plZSWio6Px0ksvoVWrVnBycqo2f48ePR76d6VSifHjxwvu2EhNTcVTTz2FV155BcOHD4e/v3+1MWVlZTh//jxOnz6NQ4cO4ciRIyY/I8g0HTt2RJcuXQT/vztz5gyefPJJREVFoWvXrmjcuDHy8vLw559/4ueffxb1mbwmGFI1IDqdDomJiQ/9T+nm5gaVSgWVSgW5XI6CggJkZGSI7mOgUCgsGgodO3YMzz//PLy9vdGsWTOUlpYiPT1ddFIbHh6OTp06WaweS4qKikJRURE+/PBDo+MyMjIwbtw4bNiwAd7e3nrHyOVyzJkzB6+88orgfc+dO4epU6dCLpcjICAA7u7u0Ol0uHv3LvLy8mp8MmOVvLw8/PLLL/jll1/uX/Pw8ECjRo3g4uICBwcHlJaW4saNG8jNzRU1p6EeFkS2IioqCsnJyaJWeQL3fgBeunQpli5dikaNGqFp06Zwd3dHSUkJ8vPzcefOHVRUVFi5aiKSgi0/L1xcXBASEmLywSvdunUT1W/L1dXVqvMTCQkMDERAQACuXbtmdFxiYiKGDBmC4OBguLm54ebNm8jKyrJKTWFhYdi5c6fRMXl5eYiJiTH4+v79+w02Mw8NDRUMIzIzM7FkyRKDr+vb9RAdHY0tW7YgLS3N6NxqtRoxMTGIiYlB06ZN4ePjAwcHB6jVauTl5SEvL4+7JiTw3nvvYcyYMYK7bQoLC7FhwwZs2LChlir7H4ZUDVxhYSEKCwsFH9iGvPDCC2jVqpWFq7rXTNzUvxAcHR0xf/58i9diSaNHj0ZRURGWLl1qdNzVq1fvr6gytJqod+/emDBhAr766itR99ZqtUhPTze15Bq5ffu2waWiQhwcHDBkyBALV0RkedOnT4dGo8H69etNel9BQUGN+00QUd1iy8+LiIgIk0MkU7bihYeHW3V+ImNkMhlefPFFwZ/BgXtf7NfGVrNBgwZh4cKFVmuQ/vjjj1slYLC3t8eyZcswatQolJSUiHrPnTt32GvWRnTr1g2vv/666M+Qhtjb28Pd3d0q/VJtp3EP1TmdOnUStWxdjEmTJtV4junTp4s6sUBqEyZMwMSJEwXHpaenIzo62ugy3XfffRcjR460ZHk2Y+rUqaKaXBLZgtmzZ2POnDmChyQQEdnq88KcBuWmhEjmzM+T/ciSXnrpJaPtNMSIiIgQ7MkkVkBAAAYOHGiRufTp2bMnQkJCrDJ3SEgIVq5cKarXHtmet99+G48//rjZ71coFFi0aJHgSe3mYkhFZunWrRu+/vprwYZ8Yk2ePBnR0dFmv3/atGl4+eWXLVJLbZg6daqobZJpaWkYP368wW8eZDIZPvzwQ8yfP99qf0lIscx+5MiRGD9+fK3fl6gmxowZg//85z82u+WYiGyHLT4vTN1a5+zsjPbt29vM/ERC3Nzc8PHHH5sdEPft2xerVq2Cvb29xWr68MMPLRZ66bNkyRKrfUbo1asXtm7dig4dOlhlfrIeOzs7fP7552adoOjs7IzPPvsMw4YNE2zJY+6fFYZU9ZCbmxu++eYbjB49Gn5+fhad293dHfPmzcPGjRvRuHFji849e/ZszJ0712DzP0P1LFq0CK+99ppFa6kNs2fPxnPPPSc47sqVKxg3bpzRPk4vvvgifvrpJzz55JNQKmu+i1epVKJfv35YsmQJZs+ebXBc1X59S/H09MT8+fPx4YcfsgcF1Ult27bFDz/8gOXLl6Nz584WmVOpVGLw4MFYs2aNxZ/pRCQdW3teqFQqUU3Qq3Tu3NmknzmaNGli1fmJxOjVqxdWr15t0hftCoUCEydOxOrVqwVP5DOVp6cntmzZgt69e1t03iqtW7fGjz/+aLUgKSgoCJs3b8a7775rsbCtRYsWmDx5Mn777TeLzEf6KZVKLF26FJ999pno37uePXtiy5Yt91uyCG3hNPdzIp/89ZBMJkNkZCQiIyMxd+5cpKSkIDExEWfOnMHp06eRkpJiUqNNlUqFbt264ZlnnsGgQYMs+u3Bo0aPHo1+/fph9erV2LVrF4qLi/WO8/T0xNChQ/HXv/4VTZo0sVo91iSTyTB//nwUFxdjz549RsdevnwZ48ePx7p166BSqfSOadGiBT7//HNkZWVh8+bNOHLkCJKSkkQ1wVcqlQgKCkJERAR69uyJHj166D358VHjx4/H2LFjcfr0afz55584d+4ckpKSTDpy1tnZGT179sSgQYPwzDPPwNHRUfR7iWzV4MGDMXjwYFy+fBn79u3DwYMHcf78edGnoXh4eKB79+6IjIxEv3794OHhYeWKiUgqtvS8CA8Px5UrV0SNNWcrnrXnJxKjT58+2Lt3L1auXImff/4ZhYWFesc5OjriySefxIQJE0wKWE3l4+ODb7/9FhcuXLh/UmdaWhoKCwtRVFQk2OBaSKtWrbB161YcP34cv/32G5KSknDt2jUUFhaiuLi4xj2x7Ozs8Oabb+LVV1/Fnj17sGfPHpw6dUp0X1oPDw907twZPXv2RK9evazS75gMGzZsGAYNGoQDBw5g7969SE5ORnZ2NoqKiuDi4oLAwEB07doVTz311EOnZGZlZSEzM9Po3Iaa+guR6azVqY1sllarRXZ2Nq5fv45bt26hqKgIJSUlKC4uhlKphIuLC1xcXNC0aVO0adPG4AlzYo0dOxZHjx41OkbfyRHl5eU4c+YMUlJSkJeXBzs7O3h6esLf3x+dOnWCXM6FgELKy8tx4cIF3Lp1637T1fLycjg7O8PFxQXu7u4ICgpCQECARXtjFBQUIDMzE5mZmbhz5w5KSkpQUlICmUwGJycnODs7w8vLC8HBwfDz8+PvJTUIGo0GqampyMzMRFZWFoqKilBWVnb/uevq6gpfX1+0atXKYBhNRA0DnxdEtUOj0eD06dNIT0+/f9pco0aN0LJlS3Tu3NmkHR70sIyMDFy5cgV3795FQUEB1Go17O3t4erqCldXVzRv3hzBwcHsQVtHLV++3OjJk8C9BShz5841eW6GVGR15oZURERERERERGRZVSulzHHmzBmMGzfO4K6nKl9++SUee+wxk+fn8gUiIiIiIiIiogZAo9Ggb9++mDlzJg4fPiyqPQwAVFRUYNOmTXj11VcFAyoPDw9ERkaaVR97UhERERERERERNRDFxcXYunUrtm7dCkdHR3Tt2hVt2rRBUFAQVCoVXF1dodPpUFRUhBs3buDChQuIj49Hfn6+qPnfeOMNs3tZM6QiIiIiIiIiImqASktLceTIERw5csQi84WFhWHs2LFmv5/b/YiIiIiIiIiIqEZ8fHywYsUKKBQKs+dgSEVERERERERERGZr164dvv/+e3h7e9doHm73IyIiIiIiIiIikzk4OOCtt97Ca6+9BqWy5hETQyoiIiIiIiIiogZAoVBgxowZ+PXXX5GYmAitVmvWPAEBAYiKisLzzz8PHx8fi9Un0+l0OovNRqTH2LFjcfToUaNjkpOTa6kaIiIiIiIiIrp79y5OnTqFU6dOISUlBdevX0d2djaKiopQVlYGOzs7uLm5wcXFBSqVCm3atEGHDh0QGhqK9u3bQyaTWbwmhlRERERERERERCQ5Nk4nIiIiIiIiIiLJMaQiIiIiIiIiIiLJMaQiIiIiIiIiIiLJMaQiIiIiIiIiIiLJMaQiIiIiIiIiIiLJMaQiIiIiIiIiIiLJ/T/kmpNFJqFsfQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with sns.axes_style(\"white\"):\n",
    "    fig=plt.figure(figsize=(20,15))\n",
    "    ax = plt.axes()\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['left'].set_linewidth(5)\n",
    "    ax.spines['bottom'].set_linewidth(5)\n",
    "    ax.tick_params(axis='both', which='minor', labelsize=5)\n",
    "    legend_properties = {'weight':'bold','size':20}\n",
    "    plt.yticks(fontsize=30, fontweight=\"bold\")\n",
    "    \n",
    "    plt.xticks(np.arange(3), ('Tom', 'Dick', 'Harry'),fontsize=50, fontweight=\"bold\")\n",
    "    plt.ylabel(r'$V_{PLC}$' ,fontsize=50,fontweight='bold')\n",
    "    plt.xlabel('off')\n",
    "    plt.ylabel('off')\n",
    "    sns.violinplot(\"category\", \"vplc\", data=df, width=0.9, scale='count')\n",
    "    ax.set_ylabel(r'$V_{PLC}$',fontsize=60, fontweight=\"bold\")\n",
    "    ax.set_xlabel('')\n",
    "    ax.set_ylabel('')\n",
    "\n",
    "    fig.savefig(saveFolderName+'/Panel_E.pdf',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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}