diff --git a/VItamin_Korean_BBH_waveform_test.ipynb b/VItamin_Korean_BBH_waveform_test.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..69dcba4ded72e4a13243a82cd9261993dd5d0873 --- /dev/null +++ b/VItamin_Korean_BBH_waveform_test.ipynb @@ -0,0 +1,457 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a notebook to generate Korean BBH waveforms for VItamin box to test. \n", + "We produce random injection parameters first, and Minke will give waveforms. Then we whiten the waveforms and add Gaussian noise." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import minke.sources\n", + "import lalsimulation\n", + "import lal\n", + "import numpy as np\n", + "import minke.distribution\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nr_path = '../h_psi4/{}'\n", + "waveforms_merge = {\n", + " 1: \"h_m1_L0.9_l2m2_r300.dat\",\n", + " 2: \"h_m2_L0.87_l2m2_r300.dat\",\n", + " 4: \"h_m4_L0.5_l2m2_r300.dat\",\n", + " 8: \"h_m8_L0.35_l2m2_r280.dat\",\n", + " 16: \"h_m16_L0.18_l2m2_r300.dat\"\n", + "}\n", + "nr_waveform = waveforms_merge[1]\n", + "\n", + "duration = 1\n", + "sampling_frequency = 256\n", + "epoch = \"0.25\"\n", + "geocent_time = 0.25\n", + "\n", + "num_samples = 4\n", + "locations = minke.distribution.uniform_sky(num_samples)\n", + "distances = np.random.uniform(1000, 3000, num_samples)\n", + "total_mass = 115" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([3.01617093, 6.04781136, 0.75714575, 4.06214126]),\n", + " array([-0.45504638, -0.5027633 , 1.13408584, 0.83943672]),\n", + " array([4.16975228, 5.06352657, 0.0317775 , 3.93614481]))" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "locations" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1525.40619263, 1155.95688485, 2108.11537646, 2559.92018662])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "distances" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_for_detector(source, ifos, sampling_frequency, epoch, distance, total_mass, ra, dec, psi):\n", + " \"\"\"\n", + " Generate an injection for a given waveform.\n", + " \n", + " Parameters\n", + " ----------\n", + " source : ``minke.Source`` object\n", + " The source which should generate the waveform.\n", + " ifos : list\n", + " A list of interferometer initialisms, e.g. ['L1', 'H1']\n", + " sampling_frequency : int\n", + " The sampling_frequency in hertz for the generated signal.\n", + " epoch : str\n", + " The epoch (start time) for the injection.\n", + " Note that this should be provided as a string to prevent overflows.\n", + " distance : float\n", + " The distance for the injection, in megaparsecs.\n", + " total_mass : float\n", + " The total mass for the injected signal.\n", + " ra : float\n", + " The right ascension of the source, in radians.\n", + " dec : float\n", + " The declination of the source, in radians.\n", + " psi : float\n", + " The polarisation angle of the source, in radians.\n", + " \n", + " Notes\n", + " -----\n", + " This is very much a draft implementation, and there are a number of \n", + " things which should be tidied-up before this is moved into Minke,\n", + " including bundling total mass with the source.\n", + " \"\"\"\n", + " nr_waveform = source.datafile\n", + " data = {}\n", + " data['data'] = {}\n", + " data['times'] = {}\n", + " data['meta'] = {}\n", + " data['epoch'] = epoch\n", + " data['meta']['ra'] = ra\n", + " data['meta']['dec'] = dec\n", + " data['meta']['psi'] = psi\n", + " data['meta']['distance'] = distance\n", + " data['meta']['total_mass'] = total_mass\n", + " data['meta']['sampling_frequency'] = sampling_frequency\n", + " data['meta']['waveform'] = nr_waveform\n", + "\n", + " \n", + " for ifo in ifos:\n", + " det = lalsimulation.DetectorPrefixToLALDetector(ifo)\n", + " hp, hx = source._generate(half=True, epoch=epoch, rate=sampling_frequency)[:2]\n", + " h_tot = lalsimulation.SimDetectorStrainREAL8TimeSeries(hp, hx, ra, dec, psi, det)\n", + " data['data'][ifo] = h_tot.data.data.tolist()\n", + " data['times'][ifo] = np.linspace(0, len(h_tot.data.data)*h_tot.deltaT, len(h_tot.data.data)).tolist()\n", + " \n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "waveforms = []\n", + "ifos = ['V1', 'L1', 'H1']\n", + "for distance, location in zip(distances, np.vstack(locations).T):\n", + " \n", + " hyper_object = minke.sources.Hyperbolic(\n", + " datafile = nr_path.format(nr_waveform),\n", + " total_mass = total_mass,\n", + " distance = distance,\n", + " )\n", + " hyper_object.datafile = nr_waveform\n", + " \n", + " data = generate_for_detector(hyper_object, ifos, sampling_frequency, epoch, distance, total_mass, *location)\n", + " waveforms.append(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# We need to pad the beginning of the waveform with zeros \n", + "def pad_waveform(ifos,num_samples,waveforms):\n", + " for i in range(num_samples):\n", + " for ifo in ifos: \n", + " for j in range(256-len(waveforms[i]['data'][ifo])):\n", + " waveforms[i]['data'][ifo] = waveforms[i]['data'][ifo] + [0] \n", + " return waveforms" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "waveforms = pad_waveform(ifos,num_samples,waveforms)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "times = np.linspace(0.25,1.25,256)\n", + "plt.plot(times,waveforms[0]['data']['L1'])\n", + "plt.title('L1')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Load ASD file of Ligo and Virgo.\n", + "asd_file_Ligo = './aLIGO_ZERO_DET_high_P_asd.txt'\n", + "asd_file_Virgo = './AdV_asd.txt'\n", + "freq_Ligo = []\n", + "asd_Ligo = []\n", + "freq_Virgo = []\n", + "asd_Virgo = []\n", + "\n", + "with open(asd_file_Ligo, 'r') as f1:\n", + " while True:\n", + " lines = f1.readline() \n", + " if not lines:\n", + " break\n", + " pass\n", + " freq_tmp, asd_tmp = [float(i) for i in lines.split()] \n", + " freq_Ligo.append(freq_tmp) \n", + " asd_Ligo.append(asd_tmp)\n", + " pass\n", + " \n", + " # Transfer data format from list to array.\n", + " freq_Ligo = np.array(freq_Ligo) \n", + " asd_Ligo = np.array(asd_Ligo)\n", + " pass\n", + "\n", + "with open(asd_file_Virgo, 'r') as f2:\n", + " while True:\n", + " lines = f2.readline() \n", + " if not lines:\n", + " break\n", + " pass\n", + " freq_tmp, asd_tmp = [float(i) for i in lines.split()] \n", + " freq_Virgo.append(freq_tmp) \n", + " asd_Virgo.append(asd_tmp)\n", + " pass\n", + " \n", + " # Transfer data format from list to array.\n", + " freq_Virgo = np.array(freq_Virgo) \n", + " asd_Virgo= np.array(asd_Virgo)\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def whiten_signal(signal, asd):\n", + " \n", + " signal_rfft = np.fft.rfft(signal)\n", + "\n", + " whitened_signal_rfft = signal_rfft / asd\n", + " whitened_signal = np.fft.irfft(whitened_signal_rfft, n=Nt)\n", + " return whitened_signal" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Interpolate asd data linearly.\n", + "\n", + "# Vitamin box requires sampling frequency = 256Hz, duration = 1 second.\n", + "Nt = 256\n", + "dt = duration/sampling_frequency\n", + "\n", + "freq_Ligo_rfft = np.fft.rfftfreq(Nt, dt)\n", + "asd_Ligo_interp = np.interp(freq_Ligo_rfft, freq_Ligo, asd_Ligo) \n", + "plt.loglog(freq_Ligo, asd_Ligo,'-o',label='Ligo ASD')\n", + "plt.loglog(freq_Ligo_rfft, asd_Ligo_interp, 'x',label='Interpolation')\n", + "\n", + "freq_Virgo_rfft = np.fft.rfftfreq(Nt, dt)\n", + "asd_Virgo_interp = np.interp(freq_Virgo_rfft, freq_Virgo, asd_Virgo) \n", + "plt.loglog(freq_Virgo, asd_Virgo,'-o',label='Virgo ASD')\n", + "plt.loglog(freq_Virgo_rfft, asd_Virgo_interp, 'x',label='Interpolation')\n", + "\n", + "plt.grid('on')\n", + "plt.ylabel('ASD (strain/rtHz)')\n", + "plt.xlabel('Freq (Hz)')\n", + "plt.legend(loc='upper center')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "asd_interp = {}\n", + "asd_interp['H1'] = asd_Ligo_interp\n", + "asd_interp['L1'] = asd_Ligo_interp\n", + "asd_interp['V1'] = asd_Virgo_interp\n", + "\n", + "for i in range(num_samples):\n", + " for ifo in ifos: \n", + " waveforms[i]['data'][ifo] = whiten_signal(waveforms[i]['data'][ifo],asd_interp[ifo])\n", + " waveforms[i]['data'][ifo] += 1.0*np.random.randn(256)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'waveform')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEWCAYAAABv+EDhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABz90lEQVR4nO29d7glR3Utvqq7T7hx7mSNEhLKQiiAECCCBYjwMMkYDMYG48QPHjhg4/CMMf45PCdsg439sGywgQfGgMFgMAiQRRBZQkIooZxmpNHkuemc06HeH927ald19wn3nnTn1Po+fZp77znd1d3VtWvtvfbeQkoJBwcHB4fJgzfqATg4ODg4jAbOADg4ODhMKJwBcHBwcJhQOAPg4ODgMKFwBsDBwcFhQuEMgIODg8OEwhkABwcHhwmFMwAODj1ACHGvEOJy63dVIcTHs79JIcRloxmdg0NvcAbAwaE/uAbATwN4eNQDcXDoFsGoB+DgsNEhpWwBeCcACCHi0Y7GwaF7OAbg4ODgMKFwBsDBwcFhQuEMgIODg8OEwhkABwcHhwmFCwI7OPSOihCizn6OAPgARPZzNft7U7p66w5jDOHmp4ND9xBC3AvgUdav/xipBNT+/alSynuHMCwHhzXBGQAHBweHCYWLATg4ODhMKJwBcHBwcJhQOAPg4ODgMKFwBsDBwcFhQjEyGWgmk/sqgFo2jo9LKd/e7jvbtm2Tp5xyyhBG5+Dg4HDs4Lrrrtsvpdxu/36UeQBNAM+UUi4JISoArhFCfE5K+a2yL5xyyim49tprhzdCBwcHh2MAQoj7in4/MgOQJcgsZT9Wsv+cJtXBwcFhSBhpDEAI4QshbgDwCIAvSim/XfCZ1wkhrhVCXLtv376hj9HBwcHhWMVIDYCUMpZSXgjgRACXCCHOK/jMFVLKi6WUF2/fnnNhOTg4ODisEWOhApJSHgZwNYDnjXgoDg4ODhODkRkAIcR2IcRC9u8pAM8GcNuoxuPg4OAwaRilCmgXgPcLIXykhuijUsrPjHA8Dg4ODhOFUaqAbgRw0ajO7+Dg4DDpGIsYgIODg8Mocc/+ZXz9zv2jHsbQ4QyAg4PDxOOKr96N3/jY90c9jKHDGQAHB4eJRytK0IqTUQ9j6HAGwMHBYeIRJwmiZPIKEUyMAfjuvQfxzHd8GcvNaNRDcXBwGDPEEoidATh28cOHF3H3/mXsX2qOeigODg5jhjhJkDgDcOyCrHsjnDw/n4ODQ3tEsXQuoGMZYRbgaUbxiEfi4OAwbkikRCKdAThmETkG4ODgUIIocQzgmIZ2ATkG4ODgYCJOJKTExMUBJsYAaBeQYwAODg4maIMYT5gbaGIMQBQ7BuDg4FAMZQAcAzg2ESaOATg4OBTDGYBjHLFjAA4ODiWInAvo2AY9YMcAHDYKkkTilj1HRz2MiQBJQGmjOCmYGANAQWDHABw2Cq65cz+e/zdfw30Hlkc9lGMeFCN0DOAYBT1gxwAcNgoOr4YAgMWGq181aBADcDLQYxTKBeQYgMMGQZwJFyYxQWnYoHs8afd6ggyAUwE5bCyE5JZI3JwdNBKnAjq24fIAHDYaaM5GExaYHAUiZwCObbhMYIdR4raHj+L3P30zZA9BRtr5T9qiNAq4TOBjHK4WkMMo8eUf7sO/fONeHO0hoEsuoEnzS48CLhHsGEfoDIDDCEELS6sHBhqNOQN415fuwDfu2j/qYfQFzgV0jCNyLiCHEYL8+L00Hh93Zco/fu1ufP6mh0c9jL5AJYKN6b0eFEZmAIQQJwkhrhZC3CKEuFkI8SuDPN+kBoGllHjg4MqohzHxoN18TwxgzFVArShRbqqNDtogOgMwPEQAfl1KeS6AJwF4oxDi3IGdbEJloN+86wCe/hdXOyMwYtAuPjxGGICUEq04UQvnRocLAg8ZUsqHpJTfy/69COBWACcM6nzRhMYA9i01IWX6f4fRYU0xgDHeleochfEb21oQOxfQ6CCEOAXARQC+XfC31wkhrhVCXLtv3741nyOc0FIQdN2rrckyfOOGtZQiUQxgDN0sFMsIj5EF06mARgQhxCyAfwfwq1LKXOlDKeUVUsqLpZQXb9++fc3niVQxuMkyALTjXHEGYKRYXwxg/BYluo5jzgU0hvd6kBipARBCVJAu/h+SUn5ikOeiB9uMJmshJJ/zSssVFBslaDffmwpofGsBkQE4FoLAUkrQLXYGYEgQQggA7wVwq5TyrwZ9PtURrM8M4F+/cz++d/+hvh6znyAD4FxAg0eSyNIgL9WZD3tgAONcCyhU8YnxG1uv4Iu+MwDDw1MAvBrAM4UQN2T/PX9QJ+M67H6WfH3HlT/Ex659oG/H6zdasXMBDQvvvOoOvOw93yz821oYwDhXA6VYxjiOrVdEE2wAglGdWEp5DQAxrPNxqtqMEkxV/b4ctxUlYxmkIxBVX50w9dMo8ODBFew+tKp+pro/QohjNgbQi6x1XMHv77Fg0HrByIPAwwKnqv2MA7TiZCxfUIKLAQwPYSK13z5O8MT/fRU+dcOe9Oc1yEBJYTOOixLNq3He/HQLrv1PXB7AsYkolpiqpLv+fiqBwjgZyxeUQMzHuYAGjyhODFfjI4tN3HcgTcCL11AKYpyqgV5zx36j7ANdxzjP/W7B+wCPw70eJibGAIRJgtl66vHqFwOI4gSJHO9Jo1xAY2QAkkTiBw8eGfUw+o50M2AujPbPPTGAMeoH8N5r7sa7r75D/axkoGMaBI4T2fWc5wxgnN/lQWBiDEAUS8zWUgPQLwagy/WO50sAjGcQ+Gt37scL330N7t1/bDU7D2Op/fbWjl/FAHpiAOOjAoolwIfRGnMX0PuuuQfPfedXu/qsUwEd45BSIkokZmrkAurPYthSUrjevrfSioa2Iw/HMAh8JGt2Tk3PjxWQO5DmG5AP5PbGAMbHzZIk0vCPt8ZcBfTAoRU8cGhFBeKvunUvdh9eLfysMwDHOOihEgPoVzmItWqhf/lfb8Bvf+LGvoyhE8YxD4CyR3tZDDcC+GJPO347WNpTMbgxUgHFiQSPj457JnAzTCClftff9OHr8YFv3Fv4WcMArDMI3AjjsXrXOmEiDECkDEAFQB8ZwBp3QfsWG3jk6HCKs7XGUAWkAqUbxACstmK87gPXdqyoygOjesFfOwOIVRxh9AYgkdJYHMmQjWsmcCOL86WGQGI1jLFc8g7w+7vee/22/7gJ//ND163rGMPERBmA+SwI3K/FUDOA3iZNxHaIg0YrGj8VUKj84eMzpna4/+AKvnDL3o4Z33zXT3NCLZRrKEcejpEKKJFlLqDxNOKU8b8axqwScEmWNru/600S3X14FXuHtLnrBybDAGQv4a6FOgDgkcX+PKC1+mjjRA5t56RcQGMUA1CVMTdIYT5a7DppxCOm2tExAHMR76kW0BiJDHIuoDEuVQ1oBrAaxuodKGP+/UwEa4Sx8bw+ft2DWGyMb6xrIgwALbY75+sIPIGHjjT6clzazfX6EsRDZQDjpwKiF7KXxXCU6DbYz11AmgGYweBeagGNU5/aRKKQAYyrC0gxgFaMMCIG0NkArJcBNEKdF7Tn8Cre8rHv48qb967rmIPERBgAWmyrvoed83Xs7ZMB0DLQNRiAYTOAMTIAujLrxjAAdA87LQ58x24HgdfGAMZHaplIaSyUWgY6ns+QGEAjitVYu3EBrTcI3IziXLxnnMtlTIYByF6gwPewa1O9bwyg24XBRsxkgoMGLwUhxyTNfS1JUaNEt8F+rvgpiwGsJQg8HgygWAU06oYw/37dg3hegd6fGECj1YULqCQRbKkZ9SwYaYQ6G3wjdBmbDAOQPYDAEzhuUx0PH+2TAVijCiiK5dB2Tq1sMiZycDvue/cv47G/f2XXfYeVC2iDGAC1i+9gQEMm9bT7+a4pD2AMqoEeWQ2RJBJxUuwCGvXidue+Jdz28GJuc8NjAJ0KInIZN7+e895+JZ71l1/paTycAYyTAS/DZBiA7AUOfJExgNW+7Iaba8wDSGMAw5kULVb2YlBuoPsPrmCxEeGBQ90ZgLW0RxwlumV63N1jL/iRlRlMONoIcX2JumjUeQBLzQhP/pOr8IVb9uYSwfi1jpJZlklluQqoEwPgLjb7OGXJY2XgMQBnAMYEtDMLvDQG0AgTlY26ruOukQHEcvAxgEPLLexbbBpBupUBKYF6pbprcYeMEq0uF2LaaISxzCnEyhjAv377frziH75V6Ce26wkNG0dXQ6y0Yjyy2MhkoPpv/DrWGwj+xPcexENHeltoCZEVZCdQva9GmHSOAfBqoOtcrFMGYLKjca4wOhEGgB5ExRfYtWkKAPoSB7CTfHoZz6Bf6rd96ib8ykeuRxgnqgrq6oCSweKSl7AMejc8PoHpduhWBhqyBduOAZTVAjq8GpaWFLclpMOGwWikNBZHfh3rGV8jjPFrH/0+Pnn97jV9XzfNMe+ryQCIcQ5WBkry7sha+Mchka8ME2EAaMfpZzEAAHi4DwaAFrBed/PDyAM4tNLCI4tNtKIEm6bSDOhBSUHjHif6RisF0W2+B8+OjZQBMO+Nfc3klig6drRGlVm/oFxfsqgWEHMHrWMzs96icnbNJYJSAbEgcJkL1JCBFhj5blmBepbWc3MuoBGDHkglUwEBfWIA0doZwKAnRRhJrDQjtGJtAAYVA+i1auVGUwF1k/HNE6XiROoewPTdkvIX5JaICxbAUS8gtMiniz9MFxBjAOtxZ4Y9BJMfPLSCF7/7GhxcbqnfKaZlBXLJ8K6GsTpHo2S+GQyg4Fq6dRfbeUGJ9f9xxIQYgCwI7AnsmKsBAPb1IRu41aU6JDeeJBm4NrgVJ1jOdj+KAQwqBlASiCtDWUB0XKFcQG2uLzQWRKYCstiD/dw1AyiKAYw2D4DOH2c5ACYD0HNpPYo2ui/dBJJve2gR33/wCO7Zv5T7Pl/EuaunEcZMrCHbxlqAYgZwgBmcdrCf5TjVcirDZBgAkoH6HgLfg++JvizAa5XCJcngJ0UYJ1hpRQhjiU3Tw2EA3S5Uqi7ORikF0YWh5/MpLMoELgl8t3UBjZgB2EofbgC5C3M9c1m9Q10YANutRmMDzLnH5xVnAPSzDX5dRYb4YI8GgFxmdE0uCDxi0EMNvLQHve+JvizAOvGnt4WMgoSDlM9FcUqD40Rivj7gGMAaGUBzTBjA7sOr+PxND5X+PWSukNLPGItSPhNYub1KGYB5bO5SGpUKiLuA4jYqoLUwlCMrIT51w25m5Dp/p2ixL2JWDYsB8GdTJAXl975oHAeXu/MWcJURsSY+7nHERBgAJQP1UwMQeKIviVi9VANtRQne9h834ZGjDfUiDZIF8BeCGuHwa44TiVv2HO3LuXqPAYxXEPjfvnM/3vjh60sNcjeJYPzekuGl7yZsMbdzH2hHascAQutZjQL8ussSwYC1BYE/9f3d+JWP3KDEGN3skpVRNfz95jv40r//Ov7Pl+9Sf19lQWCgmHUmHWSg3bqAuOuJx/mcARgxeBAY6B8DaPWg0rh97yI++K37cM2d+3PjGgT4TnO6mpbB5i/Cl27dix/926/1RQ3VqwooLAmIjgqtbMEui0l00wCdl0Qwq4GaSX/5GECxjLGfFSrXCp4AJ61SEM11GqjFRipJXmpGXR+jSPNv91344cOLRtnu1TA2nmuRC6iIUfDxHFzq1gXEWBGLmTgDUAIhxPuEEI8IIW4a5HkiJgMFUkPQj4fSSwzgaKYkaK5z59QtDAZQ9bPf6XEeWm5BSvSlVG2ZFK/082MmA6VdZFlmcldBYO4SSRIj0E3zr+KL0hiAPYeiAj/3sGEwALshjJEI1vtzXM4WfurN0c01ahdQ3vjwmAuvx98IE+OeF7mA6Lp8TzDtvv7OwZUuDQBnALFU7qT1FpgbJEbNAP4FwPMGfRLFALz+MoBe+gEczXY8zdCcJIMCX+yna3kGQItdP/IRaGHsOgaQfa4sMWfYoNtSVipAu/rKj8EXjLQYnJ4bdL3T1QCJNBcweg72veObg9ExAO2fz6mA4gT1Svo+rYXJUjxquUmB0x6CwAXsKEzSzl+tOMGBJW0AeCkIoDgbmIxH1fcKNzPdBoGbobkJsN1T44iRGgAp5VcBHBz0eVQQeEAxAKCz1vdoY8gMgJ1nOmMAfCGhxbcfk1PT5i5jAGMmA407qJJ0QlT5veKJUWk5aL0zpWdBz8FwSbSKn8M4NCrn1y0lsv+0+45ci2sJUtsMoBsDoIxqAQPgFVjpds3VgywI3J4B0LOqBp7ezKzFAHBpbMIYgDMAa4cQ4nVCiGuFENfu27dvTcfIBYF90VcXEFC8S2uEsZpwRS6g4cUAyAWUD4b1wwjRS9MtmxhGEDiME3z0uw90ZeiJopcxkm5cfXwR5EFgQCcgTdFziPjfilVARl7BiFRAPAZA10PrNC8x0g8G0M1ewG6uA7BciSTJzb+F6UoWBNa/bycDrQaecTzCgZIYQK4CaWgZACcDXT+klFdIKS+WUl68ffv2NR2DJm+QuYACz+sLre5UD+Vxf/hFPO3PrwbAXEBGAs0gXUB6bLXAz+U+KNdDH8bQjV794SMNFfAbZBCYXsp3//ed+M1/vxGfu+nhjt+hcZcVC+um8Y+hi2eJYIDe5dOC2YxNmWI6BvPcqoeFJwbqKmwHVQSP9QOOGQNQ6rI1vEvUoF0xgB5iAHbWL5DJnq17uDBVTRvCdIgBKAbge8oQ8WsqygT+o8/cgif88ZeMcRsy0FgWsolxw9gbgH6AFj5iAGkMoB8uoPxOhGOlFauMY2IAjXB9O7vb9y7izLd+DvcfKC+9nPpr9c/VQGRur7wLqB/3oZuiV6/6x2/hb666wzhnvw3AL7z/u/j9T98MAPjm3QcA6EW3HXR56hIG0EU5aHPHbjGAbNGZyVwmdN1SSq0CshYJupe1oD+blbUgZMHvxNrNtqIEUwXqsm6xku38iQn0kghWpNqJkiTXbjNlAEkh8+VI2L3msRsgNQpF8+KfrrkH+5da+MIte9GKErzqH7+Fb99zgI2LuQEdAxgt6EFUFAMQPVvlP/v8bfjUDWbFQj7h7N2vXWpCxwBMmtgr3v+Ne9GKE3z59kdKP2O/kBXfQ9X3DMbSVwaggoXlC8H+pSb2Z8G5QfUDuP7+w/jIdx/AkdUQtz3UfY6DcgGVMICibNUkkdjLGgvZi1JU4HYgFxAdr9lm/pCRrFf8kccAeFIT3YJWnCh12VrmEDGA5Z4YAAkXShhAzgVURSM0GUChDJS5gOgQ5DqcrQeFGfRPO2MbAOBdV92B/UtNfOOuA7j6Nu2ijhPpagF1ghDiXwF8E8BZQogHhRA/P4jzRBYDWEsM4FPX78ZVt5qLbsva9XHcvnfR+Jl0z611yuceyQzLttlamldwx/7cZ+zgasX3EPim0dNtDte/CKs8gDYLQStOdNxhADLQKE5wcKWFZpTgUzfsVi63bu6xcgGVMICihjBfvHUvnvZnV+NQFiC0awFxY0gMYNqS49o+Y/N60p/rFX/keQBpElj6uzQgnKptisQF3YJ2/sQEutklF7nieOVN+1kvTFWUCqiSvftFLiBiNUYQOPv/bC1AI0py/n768daHjqp3e7UkBuBqAZVASvmTUspdUsqKlPJEKeV7B3Ee3hISAPw1xABiKXNUsF225m0PpwaAdkmFLqBYdq0wIHBm8Xf/fSf+/XsP5j5jU+FqkNZA4ot9PxmATZuL0IoS5nbKdtx9VAEdXGmpl/Jv//tOfd4eDEAnFRBfpB5ZbKIVJ4rZ2S6gdjGAohaFtiHmLqBhM4BPXv8gnvwnV7HqluY8j5JUFdQPFdByn/IACg3AdAVxIrHSijGXlUMpivPQO1Bl7wj9brYWFJZv5+ei2JY9VtcQZkwQxRK+JyAEk4H23MYx77JotaHwt2cGYD6rxFkUBP78zQ/jyX9yFQ53mWgCaAPQjGI0orhwh2svxFVyATH1ib0Yrwed5G5RnBg9iZUM1NpZ3bznCJ73zq+uKTlt/2J6D3/6SSerXTmdo/P42zOAooxv1RTdykQF8tm/tNBP10gGqrtV8e9w0CJXq/hDVwHdu38FDx1pqE0Lv7ZE6sVveh0uIMUAWmvIAyhSAVmBdyGgamAdbYSYqvio+KLQBUQGruJ7oFtNx52tp0bO/h5/75YLDACPAzkZ6IgRJona/QNriwEkUuboYzsV0G2ZC4gWiiIZ6P0HV9CMEhxe6X7BUwYgTF0qdN6HjzTwC++/FouNMLfoKRcQZwCWO2Y9KOvKRNAt+fKBZ/4y3/rQIm57eBF7DvdenoLiCy++8AT85U9cgLOPmzPO3X783cUAzGqY5jUb18QygQF93ZoB5F1A+RjA6BgAXdtigRtNSqnux9QaXUBSSqYCygxAF9OwaJ7xGACf97XAU+M7uhqhGnioV/zSTGDfE8Y7Qs9vLkuibFrf49dcaADixBmAcUEUS1UHCFhbDCBOZI4B2LSf4979ywCYAaAgcJjfORQtUlJKfPfeg8YOmderaYTEANK///UXb8eXbt2Lz9z4UEEQWKDie4Uy0H5MTiWdKzGqdM1FbifOiGh8a8kQJgOwbbaGF194Aj7yuicB6I0BlAWli4r+hda12AzAjAHogC6gFzDbZ8yhYwDDVwHR+YriKInU95RUTb0mVTbCRLnrVCmIXmIAhSog0wVUC3xlcI+shqj4AvWKXzi3oiQ1AJ4QOgicHXeulAHoMRS5gFwtoDFCnD1ggu95Rjp5N0gSmdsh8oQe/sJLKdWkaGXVIOlnPgGVAShYeG7ecxQvf8838d17D6nfcdXJUjOClHoxWcpepJlakPNXVgMPgSeM3ysX0BBiAGS0OOvIvHGFQfG1qIO0AagC0IX/ugoCy/yOnKMoE5iuKbT+D2g/OYEWj1qQlU5I8uezFwnStNcrPqQcrpKEnslSM+8C4psQldjW49iWWW9qVQqilzyAon4AiekCqlc8ladweKWFiu+hXvEKYwBJIuELAd8TuWxjcgHZ34s6uID4HBjjNIDJMADTVR/HzdfVzwF70N2iKAjcYuoCwz+c0T/fE2jFCRazxRowF7elbPIXLXjEGHgSyoOHVtnfzeAZTcLZmp9b9Kq+h4rvFdag6UcmcNxhp0MLCs96VZr4mBuA9q6Ydti/1EIt8DCbUfZqtthyA3Pv/mX889fvyY+/AwMoygTWBiAfmAxjs8k7BYHrVuZs06oeaYwp1i6gor8PEjR/dOKeubmha9YxgN6eFyl/gN4YANf8278LY2mIH2qBr2IAB5ZTAzBV8QslnVEiEXhkANLf0fObrWXNlApcQFQLabnkmL2WSR8FJsIA/ObzzsaVb366+nktMYA4kbldQCsqToenSbYwVYGUMIKSfJFpxwDUYsiMzgMHdfLXkRVTfUIvVdX31eJEi2DF91DxLQYQ6kXtf33iB/jK7Wsrs0HHAMoXKbrmJkt6ot1ZMQPo3QW0b7GJbbM1I9AP6AAuAPz4//kG/v//vCV3fJ0J3J4BFAWBVWVT7rKxgsB03Fo2V2hBMBmAtcNkDAAYrpKE5jLFAPjcTqS+5rq6nrUzgJWSWkhF0HkAeQYQJ4mxmahXPKX8aUYJqn4WAyiYW0ki4fsCvtAbQ2I1ygXUsl1AidrE0H0CtOovThLFapwLaMzQTQzgcz94CJf+yVU6ACiLYwBT1fxLQJOaevEeYB2FCl1ABTuo0Fo0AeChIykD8D2hmAG9nMtsJ0XfpfNXMhmoGQOIs2uQ+Ni1D+Br/TAAJTtBnfiUnTPRhcQMA1CQINUt9i81sT3r9wwAQghUA884PjX2sNfSqEsGwBdh5fqxrn26GiBMTAZAC309ILdU+re2MQAWBC76O8dnb3wIV97cueRFEXYfXsVz/voram6l4ysPAidSGzfaAfdaUXallXeZdKUCKmBbEWNi9HchMgYwFajPVQMPW2eqhf0vInIBsXVBuYAyRmkbjiiW6t0nVxmQumDp76oWUJvp/Kefuw1/9cXbO136wDCRBqCbPIDb9y5hz5GGkiSmQeD8LkAxAMMApBOcevHuW9QMgLMIWrSLGQDtLPXf9i02sWmqgvl6oFxEdF69k9JFsRYyA0Ay0OJy0KnvtEwC2Q2iDgxAxQAi3R2L3AfNAgZQthNvB2IAHPY1E8oqb5YzgPxOzmYAdJ6pLHO3KAZg75iN2jElQeBakH2nzSL7xg9/D//fB68r/Xs73LrnKG7fu4Tb9+pG62TUaO5zH3+c6IVWs9/eDPZyM3+fu2oIUzDPuNKGnsHp22dxwsKUYgBAKoQ49/h53PHIUu45k7vWFyLXrU8ZgJbtAtIMgF8PfZ7nAbST8X79zv34OmsSNWxMpAGodJEHQC/tSitOG2LL4jyAIoq+wlxAgA5QAqacjBaAIgOgA6f68/uyXW4t8DUDyK6D2ESaEp/+biEzQBWfJG75BYyobVkhtG7QieqqGEAYq5gDvTz8nraU22ttMYDtc1XjdzYDINj+5rIYQJKk0l9dC0j/zdb/0/9rmQuIu3RWLRVQkaFrhgne/G83qAzyULlZiAEMxo9MG4lVtisP1eZAGj8DKXuiZ0gurV6DwMUMIP+5Q8stY07xNpsEXR8oUeN41ysvwrt+8kLlvgFSN+hjjt+EOJG4gxk7Oq7vCSM/SCWCtVEBUV4HVwFNswJ5yji1uT2rYVwYRB4WJtIA+FaFRSklrrljvyG5XGU6ZXqQrSixtOCaBnI/qTIA0+mCRNm+9YpX6O5pxfkdUViwGO5bbGL7bA31ipd3AbHWenSOS0/bhmedvQNCCASeZ6mAMgMQkgHIj+Ebd+43mmuUoSMDUC4UoNHKXCXtYgA9MoAkkTi4nGcARR246PMcZQzgLR//Ps5+2+fZi1zAAJg2PfCEYh1hLFUMRgeBPeN8fFF56EgDn7x+N76dFbGjz/TiZ1+Lr5ncPCst7o4qjkcAmQsom0cVzzOUM92iiAHYz2SlFeGpf/bf+OT1uv6WisUUxADCRLs+Z2o+aoGvAr9A6gY9d9c8gDThkIMMgOeJXCLYXIkKiMcA6N2bqfpqDsYJdwGVP5fVVmzEEIaNiTQAgS+MXcsPdh/BT7/326qCJKBfzuVWZL742SSkeig0wR44tIIv3rI3/a4VA6AksLl6pXB3284FlDMAGQM4umq6gEiJwPXQLzh/F9772icASCuCFsUAaPLaE/xoI8Sr/unb+OWPXJ8b24GlpuEOU9VAy2IAzMApuWqhCmhtMYDlVoRE6sxPQjXozQVkn/cT3zOL/9lKL8DMAwgY04oTqcs/RyQDNXfM3NCthpFxDvpMLyqgboy1DZpH3AC0rC2rmQksjdpaaxFUEAPgyZk2Kzuw1MJyK8bd+/Ru3XapSBaP4C4gnvNDcYCq7+HkLdOYrQW4eY9ZKDCWmQpIFCWClaiAYqncmMQAPvyLT8KvPftMAOlctusKffGWvfj1j37fOM5qGBtB8WFjIg1AumvRE4520zwjl16I1VZsUH+tZTf9oB/85n14w/+9DkkiGQPQqehAmlVYFOtqGwMoMgAVD4vK5WN+t+xFCDwtA+W1TchY2fGNm3anu6RHjpqLSjOK8dQ/uxpn/e7n8aXM4PGCXEXg10AGZ7raTgXUmwHQiVbmdK74XmG9oTIXkM0ASOJLKMoE5v+veJ7qNRExA5BjAOQCirSM2FbDrEVp8/DR3jOoaR5xlYs9p/gz4kHgwKMEw94MwLL1fgD5XTK9i7wZi10Kgn8lZC4gPu8pDlDx0x3+ObvmcItVKTZKJDyPgsDp75QMVDEAywWUJCrgSwbgrOPmDAZA46Vr++/bHslVFF5txVhqRLlicxxHVkJ86Za9hiu5X5hIA8AXQ0Av6tyXRw98uWkygIZSz2RBv6rONowSiRVm0SkGQAZmlvkkOdqxAr5TX27FGQPwWGcmK3iYSJWgFrAFjL+oReVxm2GC+w4sKznozbvTl+TR22eM4x9ZDdV3Pn5dWoiuU8Yjvz6iu/Ty8LEUlUjoBrbMklD1vVxhPCCvytAdwcw/EINTnyuIoegYQJKqrbJ2o3GiFWJ2EJgWhtVWrIKGdmtI+n8vDKBI4dIJRQzAZk2mC0j/HGQlRspcQJ+98SH8zid/kPv9SjMyavUAeaN8eDVd+LmCzmYAdh9metbccM/XzbyQM3fO4c5HrBhArBmAloFmrsqqDyHySXtcyECbmqrvKVYTJbocNF3bweWmwdCllFgNY0RJXmHIcee+JfzCB65Vm7J+YkINgMkA6OavMANAL+1qGJuftWro0C5PVTdsRtoFRAxgNYIn9AJgo+jh2zEAsv7bZ2vKlQDk1UlJojsjVdlOKM0DMI0KoF/8RhTjn752D978bzcASN1i/PoIS8xfaZdIWAsDMEsir40B0PXY97cWFMdcSoPAluGxDUCRDJS7DAKqJ5NJEmnxVgYgMA1AI4wxVUm7tdFn7F2unTtQBPKk7C1hALx+jw1ipyshf67tXUCqxWoWOC0LAn/mxj34j+t3536/3IoxUw3UogzociIE2jTtZwxAsy2Jl7/nG3g3q/rKF9ZiBpD+bvN0FYuN0CyxIiU8lQlsGuDAE7kEMjoPbWKWmzGCLIYQ+DrOYydIUixQbboK3osi0Lyjjob9RFdHFEKcKoT4KyHEJ4QQn6b/+j6aIcG3YgBqt9/KL4zLzdigp7TY0E5W7QKyXf9iI2IqoDQIzKsRFqEbFxAVgSMGQIiSxAgiRQnfCZn1j4r07loFFGOpGamJSLsNvjPk1w0wP7jltshdX0Ha/ElbpjFd9fG9+w/lrrmbRLB//OrdeO0/fycbe+YuCfIuoKIYQFkQeD0MIM0KzzKuszwAYgC0aaiRooe5gOpkAHIMwHQBtWMANM4yF9CVN+/F4//oiyp5kEPVsm/DAIw8gES7/Cq+l2PTHPcdWDFEFISVVoSpqm/Mz1IXUBEDiBP88OFF/PBh3XODVwM1YwBaCg2kQd1Emu96nKTxG24AdB/xNJDMZdJ0HtocLTUjdU6fMQDbnUR5KKutGB+79gGjFHxRPSF9bdI4dj/RrUn5DwD3AvhbAH/J/tuQqHheIQPgVpheiBUrCEyf/VYWMH7cozYD0IvQUjPCaiujuFkA6shqiHrFL7XghYlglj/cMADM1x3G0igXwfMAKgFnAF5hcplWASVYaUVoRgkWGyHuzorZ2cEvWjCEyCdIdZKBAnqiz9QCPOOsHbjy5r1MZUU78c4M4JaHjioj1QiLGQCXgRbJCe2fbddTzgAYYgDT6KUFB0lKmPp/acdPQc+alQjWDGNVp6mUAZALqI2fXVeELfYR37N/GYuNCDfuPpz7W5ELKF+a2goCKxeQyDUaIkgpcX+WuW4HOVuRzMqT6AXNTgSjOV0UA0jzVhJjbsaJZjlFLqCKMgDpM+Ulx1MVUPoc9K49u0YvLSK32uLuJq02IhCbIRdQnOimQDYDuHnPEfzGx2/Ep27Yo77fzgDQ90dpABpSyr+RUl4tpfwK/df30QwJZOmJBnJ/P4HnAZiNn9Pff+X2fdg+V8NjT9hkHHu5mTKAqYqvXDVHlQHongG0rN3wviXOAEwX0FFmACImA63YMYDEPGZ6faQCitUiwHdWeQaQnmvrTDWnhOnFBVTxBJ573nHYv9TE9RkL6CUInDaYyXbSls6eXzOdm2vPu80D4C4Kuyxzy+qnECUJAt9LCw3GqQqIgr40lyq+B0/o87XiBLXAM1xACTue7wn1DNsFgWkMZS4gylS9aXe+TWbPDIC5gCrZoln03A+thGpRs90bUZIGvw0XkB0DyHpkrLRiXS9IbRQStKLEjFskUklxqRwIkHcBkayTM9k4kfAF4BUyAJEVkeP3x2QA/PhlDCCKE2XUSFhhFHdsIwWlezMIA1AclczjXUKItwP4AgC1zZBSfq/vIxoCeKCm4gvNANiE0gwgzjGAKE7wtTv249nn7jToJpBOrOVWjOmqryb4YjPCjvm6EZTloEXq/d+4F5tnqnjRBcerQG4zTPA3V92Bd37pdgiR+jDrBgNIVGE4wFIBeZwB6FpAZS4geqFopzJd9UtdQFtnarkqmd0wALrHge/hqWdsQTXw8Onv78HFp2zpyQXUzBYBGjuQj1dUAw+tWOJ919yjXHVA3t1QVJ3Tvh67Ny8P/qbXKFXNpXSHmJbfCDyhDFS6Y9aGuBUlmgG0LIOSMQrf6xwEpr+VuYBocblpTz6IqGIAPBGspDsZkAaBaWfrZ9dTlKR234Fl9e+cAYglgsxdpo5rXR9ntffsX8bO+bq613YvgfSYiZLichALrwTp78sMQOB5WRDYjgHk+wjwIDixzJrNAGJWDlpKHF4NlXCDXEGPLOrn1U4KytlIv9GtAXgsgFcDeCYAetoy+3nDwWe7qoqvX3z+EhguICsG8IPdR3BkNcRlZ23PWWVyAXEfp5SpBLDUBZQtZP/yjXtxytbp1ACwUhC8VojvCYMBRAUMIIwTFZQiBJnbS1o1jXhAil6oQ9nua8tM1cgQBbRscMtMVflntdtCH/fbdx/Ah79zP975igsNFxftCgNfYK5ewQvPPx4fv+5B/Nqzz2QZsp0ZQDNKM3RJSQHkZaBpF7QY7/nKXUZWaJ4BFDMPHvycqvjGIqVLQegdeyVbENP5kuigMFtMApaESAbA9zx1DTSWlpKV6rn6wW/dhzhO8NqnnGqMk1wSuw+tqqQmDqo6W6QiOVqQCMbLnNswGYDIlRkn3M8KFy5ZiV80P7lIgZ7JfQeW8Z/f34NDLF7xo39zDQDgjB2zADhrMWNfrSjJbciIAVQ7uIA8L323EpnlF8RpyXKfgsBh/v4EnkAtY5nE1OjehwlrCZmYrV/p37y9a7tksHGIAbwcwKOllD8ipXxG9t+GXPwBvTO2g6J8opouIP3dRpioyX32cfM5q0wuIFvlMFXxyxlA9gIfWGqqxU9nxSbYOlOFJ4Dfef7ZAGAEgePEjgGkL6j9ItAEDWNZqAJKDUA6Cenl2zpTLXUBbZmpaj22tWsCgG/efQCfumEPlpqRGQNokAsoHd8vPO1UrLRifOjb97NSEJ0ZQNpOMvMHt4kBhHGal3HfAb0gtYsB2A14CFNVH3GmpkkzfU25YEhBYE+oYnB+ppMneAKGyySMOzCAzD2U/j7Bp2/YbWTGAum9TyTwqK3TWA3NxCkCuYDuO7BizJVGGHfVn9g+n04Ey5cZJ/D7nXcBpfOTvx90ys/+4CG84wu345Y9Rw3WBujnsVSUvRwniJLEMCpAXgY6X8AAUteRvtek4ad3e6pqMgClsgs8FWej4wvWV4Cr43gso8gAFGVHq3szQBdQtwbgJgALfT/7iOAzmgboBYdkoK1IKwryQeBYPcxts9ViBhDGmKr6xmQktQeBT35aVI42IjUWHgNYbkX4xac9Gq97+mkATAMAmOWmqTWerTjiDVL4Tpf/m5QXdLyts7VcGdzFRoTpqo96xWflEPIxAFog02vKxwDIGJ6zax4XnLSAr/xwX0/VQFvK9ZKgEZkqG33NQt0/w41hHV7t1GTxNQAUAwB+5SPX47c+fmNxJnBWU57KQQfMAJBvusJcJlSm2Pe0G5LXuyGZJf2+GSW52vO0GF100gIALd/lWMp09wBwG0uC4ougkQnc5v7ze0TKmSL3FDcAdoAzjBMEvmkc7cV99+HVXA6KPc/M8hVp/kvOBWTFAGaLXEAyXRPUuiDp+aXfqQW+qucE6GceeJ56x/n7TPekjAEcKDAAvKKoDZ541290awAWANwmhLjyWJCB0iShl6dhJYLx3ZAtY2uGCQ4sN+F7AvP1Ss6tQzLQ6QIDwB8gX8SbUaLcLg0r03g1jNEIdflkIJ/wtNjkk1mqnaV5zVpNQiob20jQ7pC7gFasXfFiI8RcPUA1EGoRtP2mgNkLuRXrDmB0j/m5t81UsRJGemHswgVEx29FidLvFzGAI8z3Ssi5gKRUWnpufMwOUz7iJMHuw6u47+AKk4GSIch2874OAgdM6RIwFwEtIC1KHmP3gs5JslIeVGyEsZGrkp43/fyZx81hquIXG4BGhK0zaYbqYcYAyP9f9T0zE7hNvMEOAldKVEAPHFpR5bmLYgDpd/MuIG4sHr1t1vqeOS+4yzaK0/wXm/mqGECBC+ibdx1I9fpZwJ0zADLAQAEDYKUweM8NQiVz88UsBnCQyVmpZAc35rabjIPeK28ABqDbGMDb+37mEYIWba3+0O4ewFRErDRjQ6LWjBIcXG5hy0wVnidgu/WXmiGWmxE2T08XuIC4qsTHInQ/gEPL1DQ+yzTOFhhyx3DJmc0AlpsRqr6HRMpMBpp/EarM6NE5pquB4RIgcBcQ7TxpcV1sRJirVzL/en7XSqBF4uhq2qR+thpgsRmpYJfvmcZxtRWr1P5ug8B0Tl1v384E9gvjCUUuoJlsfI1QZ+faLQZJakiMjV8nMYBKlhkbJZQoRQxALxTcBVRjizzAVEBKVkrlI9KGRCsFNWnSa/XwmOPn8YMH8wZgsRlhx1wN+5eaxtymXfCO+ZqxSLdro0lzDEBWQbM4CLzYiHDCwhT2LTZLVEAeqkH+urkBOG5THbO1AEvNCDNVP2eY+I9RJn+2XUBk+Gaz92em6sMTwHfuOYg/+dxteN9rL05Ve1XfYFuUGwCk+SVmEDgzgMwA8PMSA+C1gA4UxAA42qqARskAhBA+gH/g8s+NLgPlKiBA7ziXixhAaAaBG2GM/UstbJ2pZseyF+MYq6GpAgIyA8AeIA9YtqJYTQo7BnBIKXIYA7AMwEorzoKJIgsC56lwUOACooXOBp1zS3aN9qIxVw+MJKuilpDEDo5kBoCCsLTTMe9FulC3enEBsc82wgSeyDOaSlD8wtia8zjRpX0NBsAWwk1TFSQyvX+LjUjXjY+1D51yPaKMAfieXiBokfc9ob5DQWCu1uLGwWYAzSg22immvyc25+G8Ezbh5j1HcwZuuRmp3Th3m5B44Lj5uvo9b/lYeO8SbfQqvkClpOT2Sis1OkBREDhlR3zRpGfCF8JNUxWcuTNlAc0oyV2XeR/SBEh73p+ybQYf+LlL8MyzdwJIffSztUApovYvtrDYiDBfD+AJzgCk2qRMVc0gsIqBMBbD33USAvBaQAeXW2rO83gAkK4F7TKB6TgjiQFIKWMAPxRCnNzvkwshnieE+KEQ4k4hxG/3+/hlUC+VJTvU8jJd22OlabmAGAPgxyJwFxCnlbYKyI4BkAGgBcjOsjUYgOXqWGlFKpgYx1K5DziU0Yu1CsgOshEOrbTge0IlQvFd52IzYwAFSVaG/5xcQI00CDxbDyAEywMw3GPpDqsXFVCL3adGtvhy/TcA1Pzi6c2fJ/V6oOqkxk4vlrj8nB348C88EY/aOgMqtU0adX7N5BpLK80mKgawa1Pai5ruP1cFkWqFzyGuQ6daO/T7Rpi2PWwVuKkCX+Cs4+awGsZGdy8gXVR3KAOgFxpiADvn62qB7VRziBLB/CymUfW9QoO93IywdTYVLxQyAK8kBtA0DcDHXn8pfuVZZ7StlyMEsrhLft4DwNPP3G68b3P1CvZmWvyjjRCLjRCztUDd6yhzC9GGghgqgecItGUAhguoheOyuWAnfm6fq419IthmADcLIa7qVwwgYxZ/B+B/ADgXwE8KIc5dzzG7BX/QgF5wGmGSvWjpw946W83HAKIYB5aa2JpV/bNp2VIzxGorVjt2NYmqWgXkCXPCtOIEB7NFhfzZNg3vyAB8xgCivBpCNUmPtc98poQBHF5JS1eoYmbGohEqBkA0165gycdPMYBq4KEWeGqHx3dqpLPuLQ8gC5ZnGaFFdZaKFgPA1JzT2KeKqpMmCWoVH5eevg2eEFm7TWn4bnn7xDQmlGrJ42wH+Zxz050nuQB4+WTqGVAUAwjjBFVfMAagXV1FSVsVz9Pdq6wMWSoiaH+XYgA759OFaZU9gzJQPwCa97WSktvLzVQJN5O5cDiiOFNIcRWQpO/pzy5MV1IZZtXMqLZRD3yEcYJWgfqtCFwSfHglRCNMlFsTyEQgjEXXK77qZgeYrIs2GWblXVMFJGXq9tk+V8utF54AtkxXR2YAuo0BvK3vZwYuAXCnlPJuABBCfATAiwHcMoBzGSiLAQApCyA6vHW2ivsOrJgqoDDBgWXtAvI8ASF0n9mlZoSVVqR211XfQyNM+wbQ4uJn+nAgaxITJTi4ZDIAm4abMQBzsVtupgygGQm1i8szABYE7uACOrwaYvN0Ve2KV2wXUC0wDApX0SRJWlpXxQAaqQuo6nuoBT7LBDbdY5xi9+ICamUuILsOEIBcIJzAn6ddP8YuGUEvrO+ZSXbq+3Eqi1xpxZirV7IgvITvpe6I5523C7//n3pKU7loGju57vQ5ifklWa2dPHNbbkWq0GDEdqO6/DRTXbV03kbgCYPN7c9UKMRSVlqRmlueSJ9n1TcL6kkJQ2ZcLSi4FydpbsZMLcBsLcgxAHJvVQsYwGLm719uxdiSNVSiDU8ZOaH4TFigfisCr0K6J2NLc/XAqN7KVUB0XxtRurHTKiDGANqogAAor8BUxTdEG9PVALP1vJHk4Elp/UZXBkBK+RUhxE4AT8h+9R0p5SPrPPcJAB5gPz8I4In2h4QQrwPwOgA4+eT+eKF89lIB5oKz0ozVLmnrTA23PbRo7BgXGxEWG5EyAACMZJgDSy0kUu8oq4EPIEKdJRJR8AxI6WiLqYBoQbUXmhlDBVQWA/BUIlheBkp5ANqFMFXiAkoLmXnKiJkGIFMBsZiCsWhKCQ9a1nh0NVILXS3wVEkLkwF4SKSOvaQaf5lz6XAoGWicoBHFqBdci70r481DCETTq2qRYcYh1osAZYnaix0vxjdX14tdK0rdJET71Tj8tOkINRTiizwfG0kaVTY5S1wy1C8sK5UvYFJK/Mw/fxdzmZGfqaULHGcAtz28iJO3TBuxHvKDz9YCHG1EuYqqXDUDwBADEFYVw/QxUwtyWa5RYl4boI3ycjPC887bhSecshmXnLoFgLnh4ZstQi3ws/pLxS4gG5wB7DlMBqCiztMIY1VWAtDS0aVGhOlqwEqtaJVXbq7FpgFYbcVYmK6gXjUNQL3iY7YW4MCSls3aUDGANu/DWtGVSRFC/ASA7yBNCPsJAN8WQrys76MpgJTyCinlxVLKi7dv396XYwaMVgMmZSYdP5AygCjzvRJox7BlVhsA9TIEntL20uJJuxeuAqKMUCCdjDwGAOhaJxxFKiB6gcgFRNSzKCPSzgOoBl7OTcRhuoC0W0rRZWIAVnDOVgQdbYRoRjGqgY9aRfcxsF1AQLrDo/vSjBLsW2zmFBMPHFzBais2ehs0wzinAOL3B0gTpQhJAQOoFjAAbkg9Ni6OMJaGAaAsc34t//XLT8MHfu6S9LqzxYEXeyuMAWSL2XQlXXx4ZixPGuIacbqPq2GMK29+GF+9fR+uui1t2jNbC7LSHnrxueWhozh317xh6FUnrGyXbMebEikRJlLdF4oFSSlxf6b9J6nqtHIB5ZVLgWcVg6MYQCPCwnQFr7zkZPW+cJdn0XOuV7w1u4D2HG6o+0PzvRHGyk0F6L4eJKHl1VDLGAAvBw2kz6Tqe7lyJVNVDzO1AIuNtIz8n3/+NiPGBJilN/qNbjnFWwE8QUr5M1LK1yB136zXLbQbwEns5xOz3w0cdgygGSVqp7TS0vX8qbsP3309lDXdIHkZoC3ztpmqOia9VDTJqe47kGWE+mQAKmkMgC10zSjvizVjAOmxZ9mYTRVQUR6AvmZyyZRlJtN4py0X0BJb6LRBMSe63SnryGqoEp74yxtYMlACvZzNKMEv/ev38Duf0A1FkkTi+e/6Gt57zd3qd8oFVMlPZW7g3nDZ6XjFxel047eWkgGLGAAvq0DP2DbMaQKfbvnJXVt0jeceP4+nn7ld/S5KErWLrPqmOMBWAdGidIgtCsuW/j09LncBRXjHF9LyIbR5ma0HmK4GrMx5hHsPLOPc4+eZj13PO3oO9n1NZBrroTGTAfjyD/fhsndcjYeOrKoYyUzNx2zNL3EB6SBwxU/jK0kWr7BjU5zxFj1nqtMUFTDfIswxFxA10ZmvB8qN2AgTw426OXNFUaIkr4ZaDcyNHqCfMfccrGaVX3MGoOJjy3QV+5ea+KPP3oK///Jd+HerFSnN11EmgnmWy+dAD98tw3cBnJH1GqgCeCWAoSSX2TGARhirHb3BADJqzCkbUcatBQxg25w2CudlVUJpYalVeFKQlo/N1wM0Q9MANMIkHwMoCAITKyAXUOCLtCFMYSmIbMGOkqxypWgbVKpXfLYz1L0OAOQZQCxVoleOAWRB4FrgGS9yEQMANN1uhjHufGTJqAe/1Iqw2Izw4CGtcuEqIBvcCP7YRSfg1U9+lDFGQLsedNVN/X2eT1G2+4oYA5ivB8Z1FRlYKp/MSxcXMQDKA6gG6bzh84NLQXkTFFrIj65GuPORJaPl4lwtMBqb3PbwIqRMM7HJ0K8yA0CbC/u+SgoCcwYQp2wtkWmly2XOAKr5GIDtAqoHPqTU/aLnbAPANg5Fz7mWlfwoyn8pAu/M11IGr2Iw3ogZf7qPZIR5IlyVGTFC2iXNYgDZO0oGrMo8Ay+56AQ0owQf+vb9AHSDHwIxAG9ULiAAn8+ygF8rhHgtgM8C+K/1nFhKGQF4E4ArAdwK4KNSypvXc8xuoQo2KdVJovygK82YBYEzHXNByvwWHgPIJgExhrl6gHN3zQMwHzTpij2hU/znpypoZgyAJhExAP68ub+eXoLZrGH1SitWroSOMQDKE/BM/bmNqaqfa2mod7qBOl4rThBL3f1KZ7JSEJjHAFj5XCsITKBrOrIaYv9Sy3C50HPgu+G0FER7FRCxL3ru9i6ff9Z2DwUWA7ARJoliiPNTFcNQFxlY/oyANEbEd3Y8Szhg4y9lAEwGSvdxf2Y0zz5uTn0uZQC6uiv1xT33+HnD0NPiNlvCAGLlAtLyxzDWBfmWmlpEMVNNg8B2obMwYxB0DNoY0Ofs1ql8d23voNPv+yoRrBcX0Dw7z2w9UHOoEcUGmyA5NDXU0bWQhEpmM/IAsmfMM6TTALunzkGy3HrFx3knbMLTztimPmu7PUdWCkIIUQMAKeVvAPgHAOdn/10hpfyt9Z5cSvlfUsozpZSnSSn/eL3H6xZcWw2kDIB2+8utNBvUE9r3RxOTP+Rt3AXEJHEA8NTTt6kAJu0Q0uqgGQPwdJnfeYoBrGidcMoAErWYVK3CWXSeWd6QQsUAivMA6OcoTtTkpvtg1jXXv9M9T00DMF+vqDFQ3STbh67yAFa1CqheygCYRjvb/d21Ly0nzMtCkFLiMPOHt3UBKaaUHpOn+hPo3zR+TtvTnapnfJejFngGA5irB9g+r+dF0QtLtYCIAeRVQJoB0JimqwEOLvMgcEFZAk+7FyjR6Ozj5tXnZqqpj5tUQLc+dBTz9QDHb6obhj5kO2Ig73NPJMwgcHaP6dksNkJloKZLgsBxFkOg66ONwRGV9W4aAGPulzCAOGMA7dyaBLq2s5iBnKsHWu2TuYDoGjdnawP1KQ6Z0dUMIB8D4JsJUlTRvSbpLb1jv/W8s3H5OTtQC7ycAUiSlGEPohREJ3P5TQAQQnxQSvkJKeWvZf99su8jGSJ4JjCVR6Yd/XLGAIwFMJvAZPkfvW1G1RjhxyOr/tLHnaj+RhODF4PjjT5oMraiBCcupIHKZpRWaZxVCg6r122FDIAeQzXw4AkWAyiRgYZxoig4D0QT6D5MVX318lMeAC28m2cqRlA5SaR6Me0YwNGGzgM4Zasu7sUXx6kCF9BdWVVL3oqPFlrDAMQJVlvtg8BkKIlCFzEA+qwhEWX1YIro93TVzzKDdQxg55xW/RQZDQoCN5kLiC9adH5ei2a66hsF/7hLRQckBerV9Bqo1sw5u8wFbrrqo5EZjwcOruDUbTMQQhhBYDsGYCvOKFM4sDY9lFW82IiUi4ryAMr6AXD3KKBrUeVdQJ1jAGFWAqWdsIHw7HN24o3POA0XnbzZuD80jtWQGEC2gcjKRByyGEDFKw4C82xwDh4DoLWCDMJ5J2zCP/3ME3DSlmkcXG7h8EpLGdUokQNRAAGdDUBVCPEqAJcKIV5q/zeQEQ0BvL5KGEtICWyZ0YWr0mqegdr9UeIUPc+/fsWFhkSRXvRXPfFR+MwvPRXPzpJ/ANMFRG6PNA8g/Tef7Kdm1Q8pBkCLIQ8AA+kOfK4W4FFsQaUYQKqHbl8OmjTOgdphpvVRhNB0d6riw8sCi3afgM3TVSMPIEq0C4h3uwLSnWEjC4C97QXn4oKTFrBzvmbcv5rhAjINQBEDsF1AzSgu3BnSNdsMgAzA7XsX8Uim2qpa46cyy7yIm43papD2Y2AMYEcHBkCZwMQAapl8l8BbQlKi1HTNV4mCgMkAeJJQ1U87jlEj9R3zdWzO/NcztSwInDV/33N4FccvTKnrANK5T+d/4qlb8ILzd+Exx28yxp9IaSyOdN/oHqQNkSgG4GOuHuRKkIdWJjAZb2KYuSAwjwEUqoB8Vb6hGwZw3KY6fuO5Z6u5TjkqtDg3VR5AeiwhBBamqzoI3EUmMNUT4uAGgBiA7bpM+2y0cOEffBGX/cWXAZhihH6jUx7A6wH8FNJqoC+0/iYBfGIAYxo4jOzKSAd8fU/g8GoLq60YU1VNzWm39pcvvwDb5mq4ICu9S+A7tZO2zBl/o4WRM4DAE6hYGmMAODVb0CkGUMYA6hUf3/ydZ+GOvYv4l2/cCwBZJrDOA7BfBL5jp50tD+TVAh9C6N04/X+mpt0G9AJsmtIMQDU8t2IA5AKSMjVo5P/81BufklPS8F2dYgCPLKl7QaAYAK9o2c4FVLNdQKrWS/r3n/3n7+K0rMmIHQMIWbYnUGYANAOoV1KfNiUvpd/Jj4ka8+gYgKfmQjo2zaDo99OVwOqqli/cVvE9CJEa7P0ZA5ipBjh5yzRWw0UVJF5tpTkCDx1p4EfO3AEg3YR4It2B03PbOV/Hu1/1OPztVXcY448THcQF9MJHLGixEakg5mwtwAxzI9aCdKGWkoQQGYuwGICdoMhZSFHuigoCF8if24FYjlY8sSAwqwUEpIHgI8oFxPMAChiAL9CI4lzV2arvq3wVysy2YxpbZ6q4I5v79Bx5QmK/0dYASCmvAXCNEOJaKeV7BzKCEYAmXpTo0sj1qo/N01UcXG7h0EoLC1NVHejMXorzT9yEM3bO5Y5Hvrl2gch6RcsuvSwgaQdGSatOKgR6EWwGAKQvCZ/sqhZQ5l8ulYHGtFPSuQikTvA9oXbS9KLx5KFDyy1MVdJeAHR8Cv6RHE4zAGlkkfLx2GPjL4EdA2gYDCBdIPhiSCqgouAgp/AAVOVW8vMfWG5iy3LV+CwVtrTT78sMwP6lWFVITc/B1CAlLqBUs64XEX5sXSZCL2b2ordSlAdAsZuqr8pOpBuSaezJpI7TGZs7upoGao9fqKsxb5qq4PBKqPzbdG7b75xk5caJzVaUAUiN0lIzVGOZrvmYZeWX0yZCLIBq6fzJjTTXJghc7ALKNiMFJVDawTYA9CwaUQzq8EZYmKqoir28I1hROWgVA0jMVqycAWyZSVm0bew2z1Tx4CEzKSwaIQMgfEQI8bsATpZSvk4IcQaAs6SUnxnIqAYMHgykJLBa4GHrTBUHllrYv9TE9tmachURAygLwgTKAJQHIqeySpH0+cBPM2P5YnjSltQAkKujjAEQbANAteabBXkAKnM3SdTk5iWK61nHMjJi9P/pivbhHloJlUuBjrfK7h9gxgC2zVbV4lNWloGfC9AvI92DZhSrrOCitnlkLNvJQHNB4MyN0QgTtZumctnaB28qL4p8sKkLqKGqSRI2T1dwaCUsjgFkbjoVBLbyMXgQmLvoOIoYAD3LesVXuSqztQBvfMbpeNEFK+o4q2GM3ZmUedemKTbmKg6ttBQDUAlw1nWTDNT2fXMGQJuRqu8pIQXt7lXpDeY/rykXUHpd3biA+MJKv2t1GQQmzGWKM54XkEplk9yiuzBdVfctSnS7SNUQpiQTOFVJ6XeE1ojpqo/3/PTjcKa1odw6U80VQxykC6hbc/k+AC0Al2Y/7wbwRwMZ0RCgA6I6GFcLPGyZSRnAgaUWts7W1EtARqIsEOOzl88GVwFxf/JTTt+KF5y/y1gYSfVjy+GKGABgKmk0AygJAvM8AFa7HtAGYKYaYKqiDRYAnLh5CvdmDb6PrLawkLk4aNwUVLRjAGGc4MmnaWlbp6xjwuk7ZnHCgl6YEskrbuYNAC08RcZXdYHKuYCkUjYRu1GJYGoBNl1ARcZ/puYjjCWONkJjEVGFAgsWI99L3RWcGRkqIClVmQgySvz5L0xXTAbAgsBAei/pGUzXfJyzax7Pecxx6d+qAaSEep67FnTAetN0BUdWQ6PQWTpec/z0PGwVED2bxWaE5WZa9yb1nWdZtAUSyseeuAlvuOw0XHraVgCaAZSJHtJ/p38j/739915cQPPZMfguvF7xMhmoGUdbmK7gCMsDqHipy83Oyge0my9KZI75KtdqNcAzz96JEzfrDHXAlJcTc42lLHQn9gPdHvU0KeWfAwgBQEq5AmAwJmkI0E3hWTORio8ts2kA5sBSC9tma7kYQJkVplaARZOPJ7vowmICLzj/ePzJS89XE4jvDnIMoKRmj9FhzNetBaXML7g8EzjMNOY0qaoZG5nKWj0C2u1w7vHzuGvfMhphnDKAmRIGkH2PZ7LunK/hLc85E0D7nqfccM7XK/jkGy/FSy48HpedlWbP3rT7CN74oe8VNtKgnWU740s7SlrEEylV0hEFVFUxOKu3gXYB5cc9XQ1Uf4AiJVVR8S5qGKMTwcxMYB48LGIAW2aqVh6AOTe5u2jG2jjQce7MfMzHMwawMFXBoZWWyt8oYwCxVXMnZwAaEZabkbrntGGwk6iCLPD6W887W210jq6GKiDLUZQHwAu68cDwemIAQFaZNqsAzN93YnVApg6zagAZLqCs3lMiZY6lK2Zd8k5zA7Ar2wjF8eBiAN3erZYQYgpp4BdCiNMANNt/ZXxBwTVeY5xcQA8eWkErc1/Qw2t1cAH5niisRgnoeiEeU/4U9QbeOlNlVNjcCZWVbQ6syRV4QvcyKHEBUbE5kwEIzE9VsDBVUS8TvWjn7ppHnEjcvncxjY1kLzQpVFQMIDv+L77/WvzDV+5SSTlvuOx0vP2F5+Inn8irfpjgL3gl8LBjro53vvIiPPPsNEj55R/uw2d/8BBuLGh3SG6DdjLQfBBYKreWfb90LZ72CyGQvsRpHkBoLEjbsixxOwgI6JaQpgrIjAHohit5A7B1pprrhcs/yw1hvu5M+vNd+5YQeEIFIoHUBXR4JcwxH3vTozKBSQZqBYGXGqGqfAnoLFrtAiIJJVPRZff2yGqYSwIDzM0MbZLmShlADy4gZQCYMan4aGQiDCMGMF3N2rOaCqEq28ARVElwiwHQJgsApkveaV5ihubtOMQAfh/A5wGcJIT4EICnAHjtQEY0BPAYAKlM6hU/C1KlL9S22Zqy8vSZMhcQL8Rl4znn7lQTtMifTC/Qltmq+hypXSgrtswAVCxD4ntC+Q9zQWAyenGayTnNgo8V38P//rFzEXgC//z1e9T9AKBkgLfsOYrDRTEAcgFlYz+w3MK19x0yxvSzTzm1cPwEz0updNNScdCiTsWxSBnEQW4DW68O5BPmPPbciWXZiy2pgCLLt160m5+qphmoR0sYwKECxlLxPaVZB7ThJsSJZCqT/K5+YbqKBw7qIGFkxSq0i8HPbVimmQHYOV83FpVN0xUcWQlZkLbYACTSDFDTPKP6P4uNCPNTmgGQq8aWUPLj0jiPNsLCnbEQQtUcqhe4gPi71xsDoBiAfnZTWXc6mwHQ+Y6uhoXXbweBqVcGN15VX1fYLWP1xLAB7Y5M5IgNgJTyC0KI6wA8Canr51eklPsHMqIhwIgBhCYDIGydrRYEgYuP57cxAJeevg2Xnr5NfY7/nx9760xNLVj5GEDxsQ0mkS3otKO1X4S0gxPLBGaMpBJ4OD2TQ9ouoBM3T2Eua6F3eKWlCmPRxG5YQWBA7/Z62Y1R0w3+HW5UAORqplcDT7Glovu/MF3FH77kPNWUhecB2D1YdSZw+rOtruG3k0oqpDJQqUpkE2gXRwlZHKQQ4S4ggwEkkgViMwaTuXJqmWpkpZW2EH3WX34ZT8nmFi8bARTvMJUBeGQZ550wb/xt83QVi01dCLGM+aQdwcxaQBxLzTQRTBdD9DBXC5gLyLw2QG+Iyhr70LWnBiD9nhED4AyyBwMwm9VH4kyoXvFUTSRu9DcrV1Zo1kIqkoF6ojQG8JQztuF3f/Qc9b7Z4AyA5iBnHP1GVwZACPGfAD4M4NNSyuWBjGSICFgMwGQA+uZvm9Xde1QMoDQILAp3oDZ0MTh9HJl61XDmzlm106GFbtNUBS++8Hg89fRt+YPBdgGlKqMVK6hJEEKg4nloxbqYFzEIvktRMtCK3jWfs2se37r7IBKpXzxeihowlRpHlQHo/mWcqvg4kvmA1Viycxxaye+kgbSMBu0si2SgAPDqJz1K/ZvnAdjZqdQ/OFYMgHbWWRCYPfuFqQqaUcLqxyeGC+hnLj0FNzxwGK9+8im58VQ8kQsC85ebFliA1TKqamUWlXTec3gVh1ZC3PbwYvZZky0U7TB5ueiTrOAjuWooiYwnLXLEWY0bOwhMoESw4+atAPOKqQLi7wAdqxGW6/hrgY9FRCwGkMV1hDnPetl0+J7AJ994qRGIrVd8LDWjnPZeM5kWwkQbh53zdQgBw4hQPk4s8wZgvl7BLzzt0aVjKmIAcZIMpAwE0H0M4B0AngbgFiHEx4UQLxNC1Dt9aVzBG203QlMFRNg6W1WTtNUhCJzGAIoXIPNz+cXksjN34E9f+li85blnAQDqgaf8qbXAw7teeREuPmVL4fH4ZCd3C49p2EgrUSbpBDZcQPo4dUsFBAAXnLRJBQ5pJ0TfsWWgAGcA3RsAOm+lwBjxOjgcs7VAJctsZglYZVB5AFLm2YSfnoteOq5XB2C5S6q5Eg68P8SWmSre/3OXGIsCgeZAI9SG2sgEZg17lJ6e9ZaYrvpYbsbq+2RsA0uJVuQ25GqiC09eMP5GsR3qZ0ExHnvTIyX19NUCAo6lZoQlFgROj11RyXu2bBXQLqDVVqyUTzZ4QiWgFTw8ox0AHnvCQu677XD2cfOWCijNewlZHSggVVQBVCZC90O44KQFfOd3Lsep28wyJ1FWIqViuYA6oRb4+PMfPx/nnTCv4iWDTATr6g2VUn5FSvk/ATwaaVG4nwCw3o5gI4PZZk8zAAreCZH26VTZrtlnyqzwSy48Aa94QnmQ0z4vf5ieJ/DKS05Wu8laxdfF5zpMGDuYzI9btPhWssSsKJZGKn6R3537namWPaB3KIGflh1oZwDaaf9t0IvN+8QqBsB86ZtZiePZeqDKc/DSx2UoCgITVDloqWk3/z1/9gtTaf9YXtGUuw/bgRZ1xdQK8gDsJjXTjAFMVQOshrpiLbnA8jGAchcQADyO1cGhawKgO7Zlx7NJr+oJXOICAtKS0FzKuTBVVSzOlq0CuvxxsyCBkUAMm+YJudx8Tyijffk5O3Du8fOF3+8WU5krkgrWEeqK7cVKRUewDb1qCSmtGECX78NPPOEkPHrbrBIkjLIUhEKmAnohgFcAeByA9w9kREMAZwBHV9OFYKriqwVny3Q1e8BZueiwvQvoxx9/YuHvbbSrK0OoV7QLqNMOmi9AVd/LxQRsVLOU+ShO4HteTsoGaKrLE5suOXWL6tu7wHbaFd/L5QEA5uLWLZQB4NLW7KXjdXB2ztdVkhVnKVu6WIB58J83dgfyeQCqCxNL3iO85KLj8YRTtxgLRDcMBNALn2EA7BhAbDMAXZqZrpl21I0wgSe0gZpWKpM8I+X3i5eK5uNXDKDHIDCg+wivhjGmKiYD2MOSqNJry8cAmmHc1gWU3gPtoqR794yzduAtzzkTP//UctdKt6hXPKy0otyiq7uFdS47nSapZXLsNhnw7RB4wtiMjDQRTAjxUaQ1+58J4N1I8wJ+aSAjGgJEVo8/ThJ8+54DOHnLNDbPVLEwXYUQutlLt3kA3SIo8aty1ALNADr5Mz1PqN1TLTB3kkWTjfq3RtnuxpayAcCPnr8LH/7FJ2IH8+HWAh9POT1N1uELXTXwcnkAHOt1AdHveOkHGhcvkc3VFe0gRBoIT6TMJZWpIHDGKHTTj7xy65ln78SvPftMYxHjDYLagQzKSitC4AlVFoTGwOsE2TLQWqAr1B5kAWY+Dh0DaM8AAuvZEIPat9iEJ8pLYKggsJKBciOsd8Jn7tRBTtMFZN5XQBuvRlRuAOhZ79pUx88/9VQ88+wdqfvMF9g0XcGbnnlGaY/rXlCv+EogUFSxdjXMl4mw4XueEeQnFLlly48hVLe6ccgEfi/SRf/1UsqrpZRJx2+MOXxPYLWV4Jt3HcDTz9Qqnc3TVdXYhQwFBezWbwDIBVR+2w0G0MWECdhOrCi/gCNlALwcNC26PAbg49LT8kHnF114AubrAXayapdV38vlAXD0EpCbKnQB5V9oKqObdspKP7swXWnbQJ6Dmrvng8DpsXgpBkDfX+4CKuoCtRYGQOPnpUSihOcBmIFdzgAOspLYfDHVMYD8vSO//EWW/x9IA7VA6gLii1ZOBZS5qCiZkoLngM5/AKCyj4HUBXR4pZV+17qvgDauYSzLXUAs4/ZtLzgXj9o6k3N79gNTFV+xQ8roBvRmhArFtTtv4Am1kagGfN50b6DIjQSMsBgcQUp5pRDiPCHEuQDq7PcfGMiohoDAE/juvQex3IrxtDO0j/v0HbNGfQ4q3wuUu4C6PmeBP9kGVUwEunOhBJ5AC5kBYOMrjgEItKJESdy0lK3zxHzRBcfj+ecdl0s+s/MAjPOtJQbAZaAF3+cGgO5PN+4fgpdR63wMgBiAxEv+7utqR1y0E6ZFjxvyhS4NAB2HWgQCgM/UPtRBjY9Ju4B0l7aDyyUMQGWa5l/tesXHv7/hUqMRCmGuFiiJKncVFbmAorg4CJxunFJVEn8mC9MVJDItExEmpnvLPkfZnKe5wD9bCzyjt0M/wJnsSZY6CIBKErMZFAcvS2Iq7HpjAAlzAQ2iHSTQvQz07QAuA3Au0laQ/wPANQA2rgHwPfxg9xH4nlC1SADgAz93ifmyex4aaJ8J3PU5C/zJNuo91jVRbhzfVJMULZ6KAcTkAsp2skF312VP+orvFeYBqPOtKQbg5X4HpAv/I4tNZQB4Ib1uAsAEX6RBw7wKSDOAO/YuYqpKFSIzo11gXMsWsXag61tmBsAO4BKrouczY6mAAKjKlHyMADCVNYUpKyD4+EdtLvy9EAILUxUcYK1JAX3dVHwtThKjTwKJARIJ1QvhtZeeYhybjOORTEPP7wNgvldlrJHYYGCxXN52sR/gxu+kLbpURi3wIERa+yotPlg+t+1GTerfPbwPAWMAacOl7r/bC7oNAr8MwAUArpdS/qwQYieA/zuQEQ0JNJHO2TWXSwXn8LsI3HZ9zi6OZfTN7cKFwoNxnWIASgWUyUDtZJZeUWWS1bLzdYt6xVc+cQKf9JecugWPHG2qAnNVZgB6YQDpLrcoqUyrgGIpc/JK/sxo7vRyffz8QNplje47/Y7Xo+djol1/raKblhxgDMAIVraRgXbCKdtmcGC5ZbpnPG0AhUgrzQL5SrSNMMG5u+bxmjeegvNPMJvIkMLo8GrLKAanziHaz1tAzwWbLfTbG00LuyegGuYAqYGsB77qFha0ub+zbD2x71O38FgMIEokpkdcDK6R+f0jIcQ8UgloZ93jGIMmEu+bWgS1APSBgnVqMA70zgB4Qo7BXIpUQH5aboFa+vFqoGtBxdcuoOJ6/N3fs5mqn2MR/OfjF6bw0dc/OUuY0wXsgO7dLwApVfIuIJ4HQH2VAbbTZUyL4g28EVC34DLQHAPIjkOyY5p7ygUUcBeQVkYFBaypKAjcCZefk2ZM71/ixoX+L+AJoRRxgbUQA+nzuvCkhRxTJunwIaPfAGcZ+rPlKqC8SGBQMQAgLZVtj2Wq6jMVUPl5SxnAGlVAcSLRw6vUE7od0XeFEAsA/hHAdQC+h6xf8EYFadVtOZwNrQNf/zlVfZU2T5MzgG4mjGIAlpywLAhMiqbA0y6jtRoA2vkB6SJ81a//CN71ygt7Gj/hNU8+BX/1iguN36WLbfpvWmSFEJiu+KhlMkDAzA3oBPJz2wyA3GC8/DSgFzpyhfBrovtmNzBpB1qs06Qnc1c7raSGZoVS1Tyo4jEDUOIC6lBtsh2e+5jUAHC3Ol23L1LFWVggiKBmQEVBewDYNJU1VV9p5WosAbYLqMwA+AXn9frCzDnIgJ64eSr/t0z1FiVmmQgbhgHIrkeI9q5fGx5zAaUy0NG6gOYBvBzAl5EWhZuXUt44kBENCbQQdmQAvn4B1otuGMBTT9+GL926F3Eiu1pYaHx2VcnCPADfUw3eeVP4Xnbq5vFMhdRp22dx/4EV9vfuJ+3JW6dx8lazPAHVW2+EibGjnaoGqDEZaLcKHBpnGgSOMVPVig9aeKJEGgugrYfn94ruPXchdgJ9Z7kVqQQiWkxo8Sajys/1pEdvxfknbMJ0pq/n5TEKZaBrcAE9enu+Pg0ZACHS59FO3ljmp+YVQWmBLQ0Cd1ABGSXQAw+rAzIAJ2+Zzv8ta6jTqfcwr2jKpcrdKtUAXU8ISFnpSFVASGWgTwPwtwBOA3C9EOKrUsp3DWRUQ8TZu9ozAFULph8xgBJtNcePP/5EvOSiE9AI49JGMBzcBdSJAVR8T9Xlr/jCiB+sBfx7RfXo18osOGpBSrv5caerviED7cUAeCwIvGW2iuWDaYJS4KU5ArTDJdj9APg10dzojQEwF1BZDMBiAEAqTgCARxbTbl9xAUsB0vLdv/7sM43s7V7wwZ+/RNW952PzPQFfiJxrDOAlkYsZAMUADi2H2D6XZ508wN6LCqga+PC9fJOg9YBcsCcVGICpio9mGBe2XOUoYgC9vmN+1lRGyrT/wqirgV4thPgqgCcAeAbSZvGPAbAmAyCEeDnSEtPnALhESnntWo7TD2ybzddr4ehm0e4WdIxO1tz3RNc7OCXHC7xCrbrxWZa4FXgeHrV1Gs9/7HGlypCO5y7QcnPXQy8y0DLUKx6OrJqqlvmpQBkBwCyg1Qmkr15uRThtxyweyAyAWuCshvVKuqvUMPqayFXTGwNgLqASFRAdt2iXWbQpMIyS7+GXnnVG1+OxwSXRgL5uL3MBUQzAzkIHyhlA4KcVQQ+vtnQpETZXO8WugOIYwM8+5ZRcLGe9oGfAFUCEepYNb/d/sME3BBVlHHs0AEK7JEdeCkIIcRWAGaR+/68BeIKUcj21gG4C8FKkdYXGGspv3wcXECWW9fNhciVPxxiA76kXppL1//37n3r8ms/NjYztx6ZzrBe0q+QL3x+/5LGYrvr44q17AfTOAJabEaQ06/f4mQLJNgAVJd3N7+SoDs/8GhhAxAqFnb5jFqdum1EumHbJdUXB9kEtDvzYXhYEbs8Ayhc53W/ArLIKmO9WmST5pC3T2DZbMwzAM87a0evldMTZx83jmWfvKEyGTJPEIiw2o7asb6aIAfTIhnXF4lSVNmoX0I0AHg/gPABHABwWQnxTSrm6lpNKKW8F0JNPrN/4wpufXlpCmKOoGNh68JOXnJzbZa0HgZfuzHiLR7/EyFQDwcparH93XilwAXEZ7VrlpRy0qHDDcsFJCwCAr9y+D0DvMQBauHn+ADEA2wUUWCIAbtR+5MztOPu4Ofzq5d3vuG0fNpDKL69+y2X4j+t3A9C77KJkIwoIc0PVD0NbBqUCEqaBtBMCgXIXEKCbzhfJQPlULJszL3v8iXjxhScM1NgBqaF632ufUPi3esXH/QdXICXaMoBp/g4E+Y1DN+B1q+JYDqwcdLcuoDcDgBBiDmknsH8GcByA9v6TPkAI8ToArwOAk08+uW/H5dm+7aB8oH0yVn/4kvP6chxCwIKhnYK6VcNVsP7r4TtoLYlk9LcPBkD3UM1P1cccvwmPOX4ex23qvjJ5WgIk3WHzl5hULi3bAFh5AGaj8Co+/6tP7/rcgLlwFjXtAbgKqPgZTVV8wwC0U6SsF9oFlP6nDECBu7FdchTVA2rXDwAoXyjTXhmj2zAC6fXtPZrGYNoxgCJXbM8GQBBTTMaiIcybkAaBHw/gXgDvQ+oKavedLyE1EjbeKqX8VLcDlFJeAeAKALj44ov7m/bXBcoaY4wLAk/kgollu6i1Ns4oA1dK2NUogbUHlzmKGADhyadtxWd/+Wk9Hc8TWmXDX2JyAYVWZqmtAluvUWvnpssbgOJzTVd9JWPmYxwEbBdQMy4wAF0wgE1TFew+tKoL3XEZaIcSJuMCKhUNdB/3WS8DSJIxaAmJtP7PXwG4TkrZVdRFSnn5mkc1RrBdAOOGwBdKh62rexa/iGbbuvVfEFdKqOqQWcq8lL3pnstAgcW1JDYVwfcEGlmiFflqvUzi6HsCrcgsEx2wBRBYv1uLL9a2AEFlCXcwAOS6LOqj3G/wIHCZDJT+3S4GoF1A0ihfzc8B9MdtOChwJdr8VHfzsRvjWASaJ8QARq0CesdAzr4BQJR9kDR7PQg8LyeRK+uqNFAGoPTiaaJWGMu+xHioEUdRffu1IM1mTRdYkuvxbG/uWkn7KFsMYJ1uCD6P7L6wgWIAiVGS2QYtRFtnqthzpDGUIHAaV4IykNyQdcoDAFIX0JGsobod2zAL7Y3newaY8a1ODIA2QZU1BoHpfaIYwKjLQfcVQogfE0I8CODJAD4rhLhyFOPoBjoTdMQDKUHFFzoG0KZLk/37vjMAoyBZ0LfAJC0qa8lsLYInBJNvZgwguxW2C8iQKq6zbIY6JrsvtgHgDKBdtUliANSGcpBBYDMGwFRAXAbapQsokWkJi4r1Mhm1gAZ4LesFNwCdlF8UCK50eCfLQHOPalONWgXUV0gpPwngk6M4d6/oZx7AILBzvq66SxWVK+DodxCYJ7zwl3i66qvOT+tFLfAhBLrqudwNfE8oF4vNAOwgcFGew7pdQGwenb7dZgDpsZth3PY8xACoAcsg2SkNI80DELl+xUB3QWBSau1fauaMGx/+OMcA+PV1YgBT1QDLrRiBl1ZLXWsMIIrlWJSCmFjQhBxUPe714m0vOFfVDS/SqnP0mwFwcAM5naXM9wP1iofpit83GZznaQbAYwBAsQvI/vd6XRR88dtsVTGlR9IIk7YGmhgAqbAGGQRWtYCyTOlCFRArd1CGBaPhjMUAulABjQOmDBdQ+6WTynJ7npbu9gJDBppIDMouOgPQAd2UcB4lOC0tkipyVPrMADjs/qnVRn9m7KWnbUOfyAQAwBe67SOVoOZdv8K4WF/vDYAB5P+WHnu1TW9cQLvDaFddGSgD0LEd3ysOAk9X01aV7WI+ZAD2L7Zym49OjYzGBWQAqoGXKxtf9lk/u2+1Hq+L9y2PHQMYHcp6o44jeMniIpiVLPtzPVtmqji43DJe/umq37fjv/CC4/HCC47vy7EAu+xAujPju9wyfX1RMbi1oJ0B4DJQ20/OoYLAs8NkAFkAvcAAvPrJj8ITH72l7XGoIuj+pWYub6ObaqDjAFr0u8n8poZCXpZg2HsMIP18WCC77SecAeiAivIPj78B8DsEnIxKln3aUXz89U/Gp7+/x3gpZqpBxx3SqGBLDmusiJ6dCcyNBf1zvQsU3Re7axagX/LVMG7b5GYqqwhKnxnU4gCYiZBC6FLZXPJ54uZpnLg5XzyNg0p28xIYBP5Meq2ZM0xoA9A5B4CCwGGUpI18ehQx0C1qqcx9ZwBGgnF3AXF0YgD85erXrvHR22fxq5efafzul591hpGoNE6w/c21wDeSnZqtYhcQuUDWawBmagGu+93LC8tX0DiaYdJ2USf/sjIAA9w1cxeQsVD32KJw05ReNO1r2zAuoGwR76b6K312NYzxrldeiFO2zvR0LnL5tAr6L/QTzgB0gKoHvxEYgNeJAeSTdwaB86yWgOMEu/Ikv1ee0H0igPzCupZgXhG2llSgpbG14vbJXVQWY7YWYPtcTbmCBgHuHvONnXqviU0eTt4yjfsPrnRQAY3ve1bPnn03WcAUA1hpxXhW1mmtF9AtKurA1k84A9ABenc44oF0gV5UQBuB0QwCdtmBWuCp2vqe5QKyX7o/eNFj1lw6uxsEXfrCaXGpV3x89pef2pVLYq3QPYEBvgdai6vmrOPmcP/BlY2rAsp29d1kAf/ys87AD3YfwVNPz1cV7QaaAZgS735jfO/2mGAjuYBozeiqFtBGsGgDgN01jfdRyAWBrYXqlZecjDO6LCK43rG1W2RoIZqq+NgxVx9ovIV2/Z7tAlrDQk3tV3kzGzo2YZxLQdB9nqt1NrhnHTeHr/7mM3JS325Bm4GivIt+wjGADthQQWDq8duFC2iQypFxhsEAAmEwAN+zGcBwFyN+Pu4zt3Hi5ilUfIFtc4Nz/RBENqS0WJ7+91riDtR+9T7WNpSORxjrGECl+xjAekHztDngIPD43u0xwUZiAKMIAm808FujGADb5ZLKZWG6MpQX3RgbeyYkmyzCU0/fhu/8zuXYMdd9Gew1j4ndG/r3WpU6Z2UMYMnq4mWUghhjF5BSAbUxzv0CvZ/KAAxoA+oYQAd008h9XEBGquwFdS4grmpJ/z1XryCKKQagP/enLz0f550wP9Sx8RhAOwYghFiza6FXcIUU5XqsdZE+ZWuxVJS/WuPMADZNVXDmzlk8dggiB99yATkV0IigWkJuIAZQ9hJVHQMwevsKIfC2Hz1XBdr4Mz5py1RHbfugxgaY3cpGCbshDLB2BkDv0llWHEVkzXgSOd4qoGrg4Qtv/pGhnMu3XEAuBjAijHsxOI7OMtD+J4JtNNhNc07emi9pzT83THTLAIYJngjmKRfQ2oPOt/7B8woVdb4n4GO0bWLHCTYDGFQM0hmADlDF4DaAAeipGNwY77QGCb+NG4Mv+oPMri0DjwEsjIkBoNvgeUK9A+vJ1i3LiPWEGMk9H1foGEDWf2FAG7bJ3Ab2gH73BB4kdOPyEgPAVUAT+rJ5yk2Wv36z+ufwX41xZADknjFcQD1mAXcD3xNj3Qxm2KD1ZtAxAHfHO6CygVRAtKudKtGF8+bxk0q12/X2NVxAI7g/fI5tGpMYAEDdwPrjAio9h1h/mY1jCS4IPCYINlAewI65Ov76FRfgmWcXp57TCzap7h+gfW9f/o75I7hH3OiMCwMAdD9gbQD6v1B7nhjrJLBhQzUHKui/0NfzDOSoxxB0HsCIB9IlfuyiE0v/FmRNPSZVAgro51i02xx5DICdc6GgWNyoQDkA/YgBlKFfdZaOFdAr6lxAI4ZqGL4BXECdIDKaPYrd7bigXRCYs7xRMD7ulpvpUw/kfkC7gNKfB+EC8sR4S0CHjWBI1UCdAegAYgAbwQXUDWq+N7ESUKD7IPCog+TjFKOhQnCdek6v7xyOAXAMKwbg7ngHbKQgcDeoBN5E77TaBoG5CmiC75ENKgW93kSwTudwQWAN1RtiwDEAd8c7YCMFgbtB1fcmOgjcLllu1CqgcQUpgFQQeAAyUM+pgAxoA5CVg3YGYDTYSJnA3aASiIkOAmsXUEEQmKuAjpHn3Q886dFbcf5JmwYrA/XEWLeDHDZsF5BTAY0IG6kWUDeo+t4xcy1rgQoCd3IBTfA9svHuVz0OAPD1O/cDcC6gYUD1AzgWW0IKIf4CwAsBtADcBeBnpZSHRzGWTjjWgsBUBG1SoRhAUSmIMXABveD8XXjiqVtGcu5OEANkAE4FZIL3h+Y/9xujYgBfBPC/pJSREOLPAPwvAL81orG0BblLRq0K6RdqgQfZ+WPHLHQQuFwF5InR1X6i3fY4wh9gDOBnLj0FO+cH399go0CVgoiPQReQlPIL7MdvAXjZKMbRDRQDOEYMQMX3kMjJNQHt2mZ6x1i8p98YpAroNU8+pe/H3MjwsqRNLQMdjHtsHGIAPwfg38r+KIR4HYDXAcDJJ588rDEpbKSGMN3grOPmJtoAqFIQhSqg9P/OABRjkEFghzwCT7BqoBuMAQghvgTguII/vVVK+ansM28FEAH4UNlxpJRXALgCAC6++OKhr1w6CDzsMw8Gf/xjjx31EEaKdnkA9LdJTpRrh/V2BHPoDZ4Quh/ARjMAUsrL2/1dCPFaAC8A8Cwpx3dLSpb3WHEBTTpod98uEcw96mLQLXNyzeEg8MSxKQMVQjwPwG8C+BEp5cooxtAtaKE4VlxAkw5VzqAoCEwM4Fihe33GIKuBOuThewLLrcG6gEb1JN8NYA7AF4UQNwgh3jOicXSE7wKDxxTaMQCtAnLPughKBlrSb8Khv/A9gThJnSMztcHs1UelAjp9FOddC2ZqPuoVD5vHqDyvw9rRLggsVAzAGYAiDFIF5JCHzyTog7rn46ACGmtMVwNc9euXYcdcbdRDcegD2gaBPfq/MwBFoPviDMBwQBuRmVowsORNZwC6wAkLU6MegkOfQGt7u0xgZwCK4WSgwwXNw9kBuX8AVwzOYcKgW0LmF3n6m3MBFYM2oYPIBHbIw1cMYHAG1z1Jh4lCN3kAjgEUw6mAhgvHABwc+oy2/QCc4qstdAzAuYCGAZ/FAAYFZwAcJgrt+gF4jgG0BbmAXCbwcBA4BuDg0F+06wfgVEDt4VxAwwXdb8cAHBz6BFrkHQPoHe2Mp0P/QZWIB8kAnAzUYaLgtSlo5jsVUFu85KLjsXO+5upiDQnDCAI7A+AwUaAyBvUCKaMrBdEep++Yw+k75kY9jImB71xADg79xaWnbcU7Xn4BHnvCptzfVCkI15rQYQygGEDdMQAHh76g4nt42eNPLPybzgNw+yKH0UPHAFwimIPDwKFUQI4AOIwBlAqo6lxADg4Dh+cYgMMYweUBODgMEU4F5DBOoI3IIGMAzgA4OGRwzX8cxgnkknQqIAeHIUC4RDCHMUJADMAZAAeHwcNVA3UYJ7hqoA4OQ4SrBeQwTvA9ASGA6aqTgTo4DBye6wnsMEbwPYGZ6uDaQQLOADg4KKhSEM4AOIwBdszVcOLmwbajdZnADg4ZHANwGCf8yuVn4A2XnTbQczgD4OCQwXUEcxgn1AJ/4N3XRuICEkL8oRDiRiHEDUKILwghjh/FOBwcOJQKyFUDdZgQjCoG8BdSyvOllBcC+AyA3xvROBwcFKgChO+KATlMCEZiAKSUR9mPMwDkKMbh4MDhGIDDpGFkMQAhxB8DeA2AIwCeMapxODgQXC0gh0nDwBiAEOJLQoibCv57MQBIKd8qpTwJwIcAvKnNcV4nhLhWCHHtvn37BjVcBwdWCsKpox0mAwNjAFLKy7v86IcA/BeAt5cc5woAVwDAxRdf7FxFDgODLgY34oE4OAwJo1IBncF+fDGA20YxDgcHDtcRzGHSMKoYwJ8KIc4CkAC4D8DrRzQOBwcFWvddDMBhUjASAyCl/PFRnNfBoR1cKQiHSYPjug4OGVwpCIdJgzMADg4ZPNcPwGHC4AyAg0MG1xLSYdLgDICDQ4bAGQCHCYMzAA4OGU5YmMKbnnE6Ljtr+6iH4uAwFLhy0A4OGTxP4C3PPWvUw3BwGBocA3BwcHCYUDgD4ODg4DChcAbAwcHBYULhDICDg4PDhMIZAAcHB4cJhTMADg4ODhMKZwAcHBwcJhTOADg4ODhMKISUG6fJlhBiEcAPRz2OIWMbgP2jHsSQ4a752MekXS8w2mt+lJQyl+K+0TKBfyilvHjUgxgmhBDXums+9jFp1zxp1wuM5zU7F5CDg4PDhMIZAAcHB4cJxUYzAFeMegAjgLvmycCkXfOkXS8whte8oYLADg4ODg79w0ZjAA4ODg4OfYIzAA4ODg4TirE0AEKI5wkhfiiEuFMI8dsFf/81IcQtQogbhRBXCSEeNYpx9hOdrpl97seFEFIIMVZysl7RzfUKIX4ie843CyE+POwx9htdzOuThRBXCyGuz+b280cxzn5CCPE+IcQjQoibSv4uhBB/k92TG4UQjxv2GPuJLq73p7Lr/IEQ4htCiAuGPUYDUsqx+g+AD+AuAI8GUAXwfQDnWp95BoDp7N9vAPBvox73oK85+9wcgK8C+BaAi0c97gE/4zMAXA9gc/bzjlGPewjXfAWAN2T/PhfAvaMedx+u++kAHgfgppK/Px/A5wAIAE8C8O1Rj3nA13spm9P/Y9TXO44M4BIAd0op75ZStgB8BMCL+QeklFdLKVeyH78F4MQhj7Hf6HjNGf4QwJ8BaAxzcANAN9f7iwD+Tkp5CACklI8MeYz9RjfXLAHMZ//eBGDPEMc3EEgpvwrgYJuPvBjAB2SKbwFYEELsGs7o+o9O1yul/AbNaYzB2jWOBuAEAA+wnx/MfleGn0e6g9jI6HjNGTU+SUr52WEObEDo5hmfCeBMIcTXhRDfEkI8b2ijGwy6uebfB/DTQogHAfwXgF8aztBGil7f92MJI1+7NlopCANCiJ8GcDGAHxn1WAYJIYQH4K8AvHbEQxkmAqRuoMuQ7pK+KoR4rJTy8CgHNWD8JIB/kVL+pRDiyQA+KIQ4T0qZjHpgDv2FEOIZSA3AU0c5jnFkALsBnMR+PjH7nQEhxOUA3grgRVLK5pDGNih0uuY5AOcB+LIQ4l6kvtJPb+BAcDfP+EEAn5ZShlLKewDcjtQgbFR0c80/D+CjACCl/CaAOtICYscyunrfjyUIIc4H8E8AXiylPDDKsYyjAfgugDOEEKcKIaoAXgng0/wDQoiLAPwD0sV/o/uGgQ7XLKU8IqXcJqU8RUp5ClLf4YuklNeOZrjrRsdnDOA/kO7+IYTYhtQldPcQx9hvdHPN9wN4FgAIIc5BagD2DXWUw8enAbwmUwM9CcARKeVDox7UoCCEOBnAJwC8Wkp5+6jHM3YuICllJIR4E4ArkSon3ielvFkI8QcArpVSfhrAXwCYBfAxIQQA3C+lfNHIBr1OdHnNxwy6vN4rATxHCHELgBjAb4x6t7QedHnNvw7gH4UQb0YaEH6tzOQiGxVCiH9Fasi3ZbGNtwOoAICU8j1IYx3PB3AngBUAPzuakfYHXVzv7wHYCuDvs7UrkiOsEOpKQTg4ODhMKMbRBeTg4ODgMAQ4A+Dg4OAwoXAGwMHBwWFC4QyAg4ODw4TCGQAHBweHCYUzAA4OFoQQC0KI/5n9+3ghxMdHPSYHh0HAyUAdHCwIIU4B8Bkp5XmjHouDwyAxdolgDg5jgD8FcJoQ4gYAdwA4R0p5nhDitQBeAmAGaVmKdyAt7fxqAE0Az5dSHhRCnAbg7wBsR5rc9ItSytuEEC9HmhgUI814ffpQr8rBwYJzATk45PHbAO6SUl4I4Desv50H4KUAngDgjwGsSCkvAvBNAK/JPnMFgF+SUj4ewFsA/H32+98D8Fwp5QUANmzmusOxA8cAHBx6w9VSykUAi0KIIwD+M/v9DwCcL4SYRdr0g8qUAEAt+//XAfyLEOKjSOvBODiMFM4AODj0Bl55NmE/J0jfJw/A4Yw9GJBSvl4I8UQAPwrgOiHE4zdyfSOHjQ/nAnJwyGMRaQnuniGlPArgnszfTz1vL8j+fZqU8ttSyt9DWuXzpDaHcnAYOBwDcHCwIKU8kHUiuwnArWs4xE8B+D9CiN9FWgnyI0h7AP+FEOIMpP1vr8p+5+AwMjgZqIODg8OEwrmAHBwcHCYUzgA4ODg4TCicAXBwcHCYUDgD4ODg4DChcAbAwcHBYULhDICDg4PDhMIZAAcHB4cJxf8DJgB5b733mlMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "times = np.linspace(geocent_time, geocent_time+1.0, 256)\n", + "plt.plot(times,waveforms[0]['data']['L1'])\n", + "plt.title('L1')\n", + "plt.xlabel('times')\n", + "plt.ylabel('waveform')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "y_data_noisy_array=np.zeros((num_samples,3,256))\n", + "\n", + "for i in range(num_samples):\n", + " y_data_noisy_array[i][0,:] = waveforms[i]['data']['H1']\n", + " y_data_noisy_array[i][1,:] = waveforms[i]['data']['L1']\n", + " y_data_noisy_array[i][2,:] = waveforms[i]['data']['V1']" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py\n", + "\n", + "x_data_list = []\n", + "for i in range(num_samples):\n", + " with h5py.File(f'data_{i}.h5py','w') as f:\n", + " x_data_list = [57.5,57.5,distances[i],geocent_time,locations[2][i],locations[0][i],locations[1][i]]\n", + " x_data=np.array(x_data_list)\n", + " d1 = f.create_dataset('x_data',data = x_data)\n", + " d2 = f.create_dataset('y_data_noisy',data = y_data_noisy_array[i])" + ] + } + ], + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}