diff --git a/code_new/Sumit/NR_dynesty_t0_loop.ipynb b/code_new/Sumit/NR_dynesty_t0_loop.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9c7b92a1aaa34f936f43682afe0719998afb3fca
--- /dev/null
+++ b/code_new/Sumit/NR_dynesty_t0_loop.ipynb
@@ -0,0 +1,1814 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Generate ringdown templates in the time and perform parameter estimation on them.\\n'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "\"\"\"Generate ringdown templates in the time and perform parameter estimation on them.\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Import relevant modules, import data and all that\n",
+    "import time\n",
+    "import numpy as np\n",
+    "from scipy import interpolate\n",
+    "import corner\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.ticker import MaxNLocator\n",
+    "from matplotlib import rc\n",
+    "from configparser import ConfigParser\n",
+    "import codecs\n",
+    "#plt.rcParams['font.family'] = 'DejaVu Sans'\n",
+    "#rc('text', usetex=True)\n",
+    "plt.rcParams.update({'font.size': 16.5})\n",
+    "from dynesty import utils as dyfunc\n",
+    "\n",
+    "\n",
+    "from multiprocessing import Pool\n",
+    "import h5py\n",
+    "import pandas as pd\n",
+    "import json\n",
+    "import qnm\n",
+    "import random\n",
+    "from multiprocessing import Pool\n",
+    "import dynesty\n",
+    "from dynesty import plotting as dyplot\n",
+    "from dynesty.utils import resample_equal\n",
+    "import os\n",
+    "import csv\n",
+    "import argparse\n",
+    "import pickle\n",
+    "import scipy.optimize as optimization\n",
+    "from scipy.optimize import minimize\n",
+    "from scipy.interpolate import interp1d\n",
+    "from pycbc.conversions import get_lm_f0tau_allmodes\n",
+    "from scipy.optimize import fsolve\n",
+    "import romspline\n",
+    "import rdown as rd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rdown=rd.Ringdown_Spectrum(1,0.9,2,2,n=0,s=-2)\n",
+    "w0, tau0 = rdown.QNM_spectrum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rdown.rd_model_wtau([w0, tau0,1,2]);\n",
+    "rdown.rd_model_wq([w0, tau0,1,2]);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rdown=rd.Ringdown_Spectrum(1,0.9,2,2,n=0,s=-2,fixed=True)\n",
+    "rdown.rd_model_wq_fixed([1,2]);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "usage: ipykernel_launcher.py [-h] [-c CONFIG_FILE]\n",
+      "ipykernel_launcher.py: error: unrecognized arguments: -f /work/francisco.jimenez/.local/share/jupyter/runtime/kernel-62651e0b-c9d3-4156-9280-59d4da4ffa95.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Cell that calls the arguments from your 'config.ini' file. \n",
+    "try:\n",
+    "    parser = argparse.ArgumentParser(description=\"Simple argument parser\")\n",
+    "    parser.add_argument(\"-c\", action=\"store\", dest=\"config_file\")\n",
+    "    result = parser.parse_args()\n",
+    "    config_file=result.config_file\n",
+    "    parser = ConfigParser()\n",
+    "    parser.read(config_file)\n",
+    "    parser.sections()\n",
+    "except SystemExit: \n",
+    "    parser = ConfigParser()\n",
+    "    parser.read('config_fixed_m_af.ini')\n",
+    "    parser.sections()\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# path\n",
+    "rootpath=parser.get('nr-paths','rootpath')\n",
+    "\n",
+    "simulation_path_1 = parser.get('nr-paths','simulation_path_1')\n",
+    "simulation_path_2 = parser.get('nr-paths','simulation_path_2')\n",
+    "metadata_file = parser.get('nr-paths','metadata_json')\n",
+    "simulation_number = parser.get('nr-paths','simulation_number')\n",
+    "simulation_number = np.int(simulation_number)\n",
+    "\n",
+    "output_folder = parser.get('output-folder','output-folder')\n",
+    "overwrite = parser.get('setup','overwrite')\n",
+    "downfactor = np.int(parser.get('setup','plot_down_factor'))\n",
+    "sampler = parser.get('setup','sampler')\n",
+    "nr_code = parser.get('setup','nr_code')\n",
+    "\n",
+    "if parser.has_option('setup','export'):\n",
+    "    export=eval(parser.get('setup','export'))\n",
+    "else:\n",
+    "    export=True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if parser.has_option('setup','nb_cores'):\n",
+    "    nbcores = np.int(parser.get('setup','nb_cores'))\n",
+    "else:\n",
+    "    nbcores = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not os.path.exists(output_folder):\n",
+    "    os.mkdir(output_folder)\n",
+    "    print(\"Directory \" , output_folder ,  \" Created \")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# time config\n",
+    "tshift=parser.get('time-setup','tshift')\n",
+    "tshift = np.float(tshift)\n",
+    "\n",
+    "tend=parser.get('time-setup','tend')\n",
+    "tend = np.float(tend)\n",
+    "\n",
+    "t_align=parser.get('time-setup','t_align')\n",
+    "t_align = np.float(t_align)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# n-tones & nlive\n",
+    "\n",
+    "nmax=parser.get('n-tones','nmax')\n",
+    "nmax = np.int(nmax)\n",
+    "\n",
+    "npoints=parser.get('n-live-points','npoints')\n",
+    "npoints = np.int(npoints)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<bound method MappingHDF5.values of <Attributes of HDF5 object at 139825649827280>>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename = \"/work/sumit.kumar/projects/ringdown/xisco/feb2021_injections/intrinsic/injection_2tones.hdf\"\n",
+    "files = h5py.File(filename, 'r')\n",
+    "files.attrs.keys()\n",
+    "#gw[simulation_number][\"Extrapolated_N3.dir\"][\"Y_l2_m2.dat\"] \n",
+    "#magic.from_file(filename)\n",
+    "#help(files.attrs)\n",
+    "files.attrs.values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model: w-tau-fixed-m-af\n",
+      "nmax: 0\n",
+      "tshift: 0.0\n",
+      "error: False\n",
+      "error value: False\n",
+      "export: True\n",
+      "nr code: SXS\n"
+     ]
+    }
+   ],
+   "source": [
+    "# model\n",
+    "model=parser.get('rd-model','model')\n",
+    "error_str = eval(parser.get('rd-model','error_str'))\n",
+    "fitnoise=eval(parser.get('rd-model','fit_noise'))\n",
+    "#fitnoise=False\n",
+    "if error_str:\n",
+    "    error_val=np.float(parser.get('rd-model','error_val'))\n",
+    "    if error_val==0:\n",
+    "        error_type=''\n",
+    "    else:\n",
+    "        error_type=error_val\n",
+    "else:\n",
+    "    error_type='False'\n",
+    "    error_val =0\n",
+    "\n",
+    "if model == 'w-q':\n",
+    "    tau_var_str='q'\n",
+    "else:\n",
+    "    tau_var_str='tau'\n",
+    "    \n",
+    "#tshift=10\n",
+    "#npoints=10000\n",
+    "#export=False\n",
+    "print('model:',model)\n",
+    "print('nmax:',nmax)\n",
+    "print('tshift:',tshift)\n",
+    "print('error:', error_str)\n",
+    "print('error value:',error_type)\n",
+    "print('export:',export)\n",
+    "print('nr code:',nr_code)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if error_str:\n",
+    "    output_folder_1=output_folder+'/'+model+'-nmax'+str(nmax)+'_'+str(error_str)+'_'+str(error_type)+'_fitnoise_'+str(fitnoise)\n",
+    "else:\n",
+    "    output_folder_1=output_folder+'/'+model+'-nmax'+str(nmax)+'_'+str(error_str)+'_fitnoise_'+str(fitnoise)\n",
+    "\n",
+    "if not os.path.exists(output_folder_1):\n",
+    "    os.mkdir(output_folder_1)\n",
+    "    print(\"Directory \" , output_folder_1 ,  \" Created \")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "corner_plot=output_folder_1+'/Dynesty_'+str(simulation_number)+'_'+model+'_nmax='+str(nmax)+'_tshift='+str(tshift)+'_'+str(npoints)+'corner_plot.png'\n",
+    "corner_plot_extra=output_folder_1+'/Dynesty_'+str(simulation_number)+'_'+model+'_nmax='+str(nmax)+'_tshift='+str(tshift)+'_'+str(npoints)+'corner_plot_extra.png'\n",
+    "diagnosis_plot=output_folder_1+'/Dynesty_diagnosis'+str(simulation_number)+'_'+model+'_nmax='+str(nmax)+'_tshift='+str(tshift)+'_'+str(npoints)+'.png'\n",
+    "fit_plot=output_folder_1+'/Fit_results_'+str(simulation_number)+'tshift_'+str(tshift)+'_'+model+'_nmax_'+str(nmax)+'.png'\n",
+    "samples_file=output_folder_1+'/posterior_samples-'+str(simulation_number)+'tshift_'+str(tshift)+'_'+model+'_nmax_'+str(nmax)+'.csv'\n",
+    "results_file=output_folder_1+'/results_'+str(simulation_number)+'tshift_'+str(tshift)+'_'+model+'_nmax_'+str(nmax)+'.pkl'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sumary_data = output_folder_1+'/summary'+str(simulation_number)+'_'+model+'_nmax_'+str(nmax)+'.csv'\n",
+    "best_data=output_folder_1+'/best_values_'+str(simulation_number)+'_'+model+'_nmax_'+str(nmax)+'.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vary_fund = True\n",
+    "\n",
+    "#sampler parameters\n",
+    "dim = nmax+1\n",
+    "ndim = 4*dim\n",
+    "numbins = 32 #corner plot parameter - how many bins you want\n",
+    "datacolor = '#105670' #'#4fa3a7'\n",
+    "pkcolor = '#f2c977' #'#ffb45f'\n",
+    "mediancolor = '#f7695c' #'#9b2814'\n",
+    "\n",
+    "#Import data and necessary functions\n",
+    "#TimeOfMaximum\n",
+    "def FindTmaximum(y):\n",
+    "    \"\"\" It determines the maximum absolute value of the complex waveform.\n",
+    "    \"\"\"\n",
+    "    absval = np.sqrt(y[:,1]*y[:,1]+y[:,2]*y[:,2])\n",
+    "    vmax=np.max(absval)\n",
+    "    index = np.argmax(absval == vmax)\n",
+    "    timemax=y[index,0]\n",
+    "    return timemax\n",
+    "\n",
+    "def save_object(obj, filename):\n",
+    "    with open(filename, 'wb') as output:  # Overwrites any existing file.\n",
+    "        pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL)\n",
+    "\n",
+    "\n",
+    "def EasyMatchT(t,h1,h2,tmin,tmax):\n",
+    "    \"\"\" It computes the time-domain match for (h1|h2)  complex waveforms.\n",
+    "    \"\"\"\n",
+    "    pos = np.argmax(t >= (tmin));\n",
+    "    \n",
+    "    h1red=h1[pos:];\n",
+    "    h2red=h2[pos:];\n",
+    "    \n",
+    "    norm1=np.sum(np.abs(h1red)**2)\n",
+    "    norm2=np.sum(np.abs(h2red)**2)\n",
+    "\n",
+    "    myTable=h1red*np.conjugate(h2red)\n",
+    "    res=((np.sum(myTable)/np.sqrt(norm1*norm2))).real\n",
+    "    \n",
+    "    return res\n",
+    "\n",
+    "def EasySNRT(t,h1,h2,tmin,tmax):\n",
+    "    \"\"\" It computes the time-domain snr for (h1|h2)  complex waveforms.\n",
+    "    \"\"\"    \n",
+    "    pos = np.argmax(t >= (tmin));\n",
+    "    \n",
+    "    h1red=h1[pos:];\n",
+    "    h2red=h2[pos:];\n",
+    "\n",
+    "    myTable=h1red*np.conjugate(h2red)\n",
+    "    res=2*np.sqrt((np.sum(myTable)).real)\n",
+    "    \n",
+    "    return res\n",
+    "\n",
+    "def wRD_to_f_Phys(f,M):\n",
+    "    \"\"\" It converts NR frequencies to physical units in [Hz].\n",
+    "    \"\"\"  \n",
+    "    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;\n",
+    "    return (c**3/(M*MS*G*2*np.pi))*f\n",
+    "\n",
+    "def wRD_to_f_NR(f,M):\n",
+    "    \"\"\" It converts Physical frequencies to NR units in [1/M].\n",
+    "    \"\"\"  \n",
+    "    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;\n",
+    "    return (c**3/(M*MS*G*2*np.pi))*f\n",
+    "\n",
+    "def tauRD_to_t_Phys(tau,M):\n",
+    "    \"\"\" It converts NR times to physical units in [s].\n",
+    "    \"\"\"  \n",
+    "    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;\n",
+    "    return ((M*MS*G)/c**3)*tau\n",
+    "\n",
+    "def tauRD_to_t_NR(tau,M):\n",
+    "    \"\"\" It converts Physical times to NR units in [M].\n",
+    "    \"\"\"  \n",
+    "    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;\n",
+    "    return 1/((M*MS*G)/c**3)*tau\n",
+    "\n",
+    "def twopoint_autocovariance(t,n):\n",
+    "    \"\"\" It computes the two-point autocovariance function.\n",
+    "    \"\"\"  \n",
+    "    dt=t[1]-t[0]\n",
+    "    res = np.zeros(len(n))\n",
+    "    taus = np.zeros(len(n))\n",
+    "    for tau in range(0,int(len(n)/2)):\n",
+    "        ntau=np.roll(n, tau)\n",
+    "        taus[tau] = t[tau]\n",
+    "        res[tau]=np.sum(n*ntau).real\n",
+    "    return (taus[:int(len(n)/2)],res[:int(len(n)/2)])\n",
+    "\n",
+    "grav_220 = [qnm.modes_cache(s=-2,l=2,m=2,n=i) for i in range (0,dim)]\n",
+    "def QNM_spectrum_old(mf,af,l,m):\n",
+    "    \"\"\" It computes the RD frequencies and damping times in NR units.\n",
+    "    \"\"\"     \n",
+    "    omegas_new_v2 = [qnm.modes_cache(s=-2,l=l,m=m,n=i)(a=af)[0] for i in range (0,dim)]\n",
+    "    w_m_a = (np.real(omegas_new_v2))/mf\n",
+    "    tau_m_a=-1/(np.imag(omegas_new_v2))*mf\n",
+    "    \n",
+    "    return (w_m_a, tau_m_a)\n",
+    "\n",
+    "def QNM_spectrum(mf,af,l,m):\n",
+    "    \"\"\" It computes the RD frequencies and damping times in NR units.\n",
+    "    \"\"\"     \n",
+    "    omegas_new=np.asarray([grav_220[i](a=af)[0] for i in range (0,dim)])\n",
+    "    w_m_a = (np.real(omegas_new))/mf\n",
+    "    tau_m_a=-1/(np.imag(omegas_new))*mf\n",
+    "    \n",
+    "    return (w_m_a, tau_m_a)\n",
+    "\n",
+    "def QNM_Berti(mf,af,l,m):\n",
+    "    \"\"\" It computes the RD frequencies and damping times in NR units.\n",
+    "    \"\"\"     \n",
+    "    position=np.argmax(rdowndata[0,0] >= (af))\n",
+    "    #w_m_a=f1+f2*(1-af)**f3\n",
+    "    w_m_a=[None]*(nmax+1)\n",
+    "    tau_ma_a=[None]*(nmax+1)\n",
+    "    \n",
+    "    for i in range(nmax+1):\n",
+    "        qnm=rdowndata[i,1:3,position]\n",
+    "        w_m_a[i] = qnm[0]/mf\n",
+    "        tau_ma_a[i] = -1/(qnm[1])*mf\n",
+    "\n",
+    "    return w_m_a, tau_ma_a\n",
+    "\n",
+    "f_fpars= [[2.95845, -2.58697, 0.0533469], [2.12539, -1.78054, \n",
+    "  0.0865503], [1.74755, -1.44776, 0.123666], [1.78287, -1.53203, \n",
+    "  0.129475], [2.04028, -1.83224, 0.112497]]\n",
+    "\n",
+    "q_fpars=[[0.584077, 1.52053, -0.480658], [0.00561441, \n",
+    "  0.630715, -0.432664], [-0.197965, 0.515956, -0.369706], [-0.275097, \n",
+    "  0.455691, -0.331543], [-0.287596, 0.398514, -0.309799]]\n",
+    "\n",
+    "def w_fpars_Berti(n):\n",
+    "    return f_fpars[n]\n",
+    "\n",
+    "def tau_qpars_Berti(n):\n",
+    "    return q_fpars[n]\n",
+    "\n",
+    "def mass_from_wtau(n,w,tau):\n",
+    "    f1,f2,f3 = w_fpars_Berti(n)\n",
+    "    q1,q2,q3 = tau_qpars_Berti(n)\n",
+    "    res=(f1 + f2*(2**(-1/q3)*((-2*q1 + w*tau)/q2)**(1/q3))**f3)/w\n",
+    "    return res\n",
+    "\n",
+    "def spin_from_wtau(n,w,tau):\n",
+    "    f1,f2,f3 = w_fpars_Berti(n)\n",
+    "    q1,q2,q3 = tau_qpars_Berti(n)\n",
+    "    res=1 - 2**(-1/q3)*((-2*q1 + w*tau)/q2)**(1/q3)\n",
+    "    return res\n",
+    "\n",
+    "def mass_from_wtau_loop(w,tau,l,m):\n",
+    "    res=[None]*dim\n",
+    "    for n in range (0,dim):\n",
+    "        f1,f2,f3 = w_fpars_Berti(n)\n",
+    "        q1,q2,q3 = tau_qpars_Berti(n)\n",
+    "        res[n]=(f1 + f2*(2**(-1/q3)*((-2*q1 + w[n]*tau[n])/q2)**(1/q3))**f3)/w[n]\n",
+    "    return res\n",
+    "\n",
+    "def spin_from_wtau_loop(w,tau,l,m):\n",
+    "    res=[None]*dim\n",
+    "    for n in range (0,dim):\n",
+    "        f1,f2,f3 = w_fpars_Berti(n)\n",
+    "        q1,q2,q3 = tau_qpars_Berti(n)\n",
+    "        res[n]= 1 - 2**(-1/q3)*((-2*q1 + w[n]*tau[n])/q2)**(1/q3)\n",
+    "    return res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def FFT_FreqBins(times):\n",
+    "    Len = len(times)\n",
+    "    DeltaT = times[-1]- times[0]\n",
+    "    dt = DeltaT/(Len-1)\n",
+    "    dnu = 1/(Len*dt)\n",
+    "    maxfreq = 1/(2*dt)\n",
+    "    add = dnu/4\n",
+    "\n",
+    "    p = np.arange(0.0,maxfreq+add,dnu)\n",
+    "    m = np.arange(p[-1]-(2*maxfreq)+dnu,-dnu/2+add,dnu)\n",
+    "    res=np.concatenate((p,m))\n",
+    "    \n",
+    "    return res\n",
+    "\n",
+    "def hFromPsi4FFI(tpsi4,f0):\n",
+    "    \n",
+    "    timecheck1=tpsi4[-2,0]-tpsi4[-1,0]\n",
+    "    timecheck2=tpsi4[1,0]-tpsi4[0,0]\n",
+    "    \n",
+    "    if np.abs(timecheck1-timecheck2)>=0.0001:\n",
+    "        print(\"The data might not be equally sampled!!\")\n",
+    "\n",
+    "    times,data= tpsi4[:,0],tpsi4[:,1]\n",
+    "\n",
+    "    freqs = FT_FreqBins(xaxis.real).real\n",
+    "    position = np.argmax(freqs >= f0)\n",
+    "    freqs[:position]=f0*np.ones(len(freqs[:position]))\n",
+    "    freqs=2*np.pi*freqs\n",
+    "\n",
+    "    fdata=fft(data)\n",
+    "    len(myTable)*ifft(- fdata/floor**2);\n",
+    "    np.stack((times,data)).T\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "126.13393146339718"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "2*np.sqrt(12/2*1/tauRD_to_t_NR(1.3*10**-47,70)*(5*10**(-21))**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "662.9070277672074"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1/tauRD_to_t_NR(1.3*10**-47,70)*(5*10**(-21))**2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "124.03473458920845"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "2*np.sqrt(0.004/2*1/(1.3*10**-47)*(5*10**(-21))**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1386.7504905630728"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(1/(1.3*10**-47)*(5*10**(-21))**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gw = {}\n",
+    "gw[simulation_number] = h5py.File(simulation_path_1, 'r') \n",
+    "if nr_code=='SXS': \n",
+    "    gw_sxs_bbh_0305 = gw[simulation_number][\"Extrapolated_N3.dir\"][\"Y_l2_m2.dat\"] \n",
+    "    times = gw_sxs_bbh_0305[:,0]\n",
+    "    gw5 = {}\n",
+    "    gw5[simulation_number] = h5py.File(simulation_path_2, 'r')\n",
+    "    gw5_sxs_bbh_0305 = gw5[simulation_number][\"Extrapolated_N3.dir\"][\"Y_l2_m2.dat\"]\n",
+    "\n",
+    "elif nr_code=='Maya': \n",
+    "    dt=0.1\n",
+    "    gw_sxs_bbh_0305_amp = np.asarray(gw[simulation_number]['amp_l2_m2/Y'])[6:] \n",
+    "    times_1 = np.asarray(gw[simulation_number]['amp_l2_m2/X'])[6:] \n",
+    "    gw_sxs_bbh_0305_amp_int = romspline.ReducedOrderSpline(times_1, gw_sxs_bbh_0305_amp)\n",
+    "    gw_sxs_bbh_0305_pha = np.asarray(gw[simulation_number]['phase_l2_m2/Y'])[6:]\n",
+    "    times = np.asarray(gw[simulation_number]['phase_l2_m2/X'])[6:]\n",
+    "    gw_sxs_bbh_0305_pha_int = romspline.ReducedOrderSpline(times, gw_sxs_bbh_0305_pha)\n",
+    "    \n",
+    "    tmin=max(times_1[0],times[0])\n",
+    "    tmax=min(times_1[-1],times[-1])\n",
+    "    times=np.arange(tmin,tmax,dt)\n",
+    "    amps=gw_sxs_bbh_0305_amp_int(times)\n",
+    "    phs=gw_sxs_bbh_0305_pha_int(times)\n",
+    "    gw_sxs_bbh_0305 = np.asarray([times,amps*np.cos(phs),amps*np.sin(phs)]).T\n",
+    "    gw5_sxs_bbh_0305 = gw_sxs_bbh_0305\n",
+    "    \n",
+    "elif nr_code=='LaZeV': \n",
+    "    #gw_sxs_bbh_0305_amp = np.asarray(gw[simulation_number]['amp_l2_m2/Y'])[6:] \n",
+    "    #gw_sxs_bbh_0305_amp_err = np.asarray(gw[simulation_number]['amp_l2_m2/errors']) \n",
+    "    #times_1 = np.asarray(gw[simulation_number]['amp_l2_m2/X'])[6:] \n",
+    "    #gw_sxs_bbh_0305_amp_int = interp1d(times_1, gw_sxs_bbh_0305_amp, kind='cubic') \n",
+    "    #gw_sxs_bbh_0305_amp_errs_int = interp1d(times_1, gw_sxs_bbh_0305_amp_err, kind='cubic')\n",
+    "    \n",
+    "    #gw_sxs_bbh_0305_pha = np.asarray(gw[simulation_number]['phase_l2_m2/Y'])[6:]\n",
+    "    #gw_sxs_bbh_0305_pha_err = np.asarray(gw[simulation_number]['phase_l2_m2/errors'])\n",
+    "    #times = np.asarray(gw[simulation_number]['phase_l2_m2/X'])[6:]\n",
+    "    #gw_sxs_bbh_0305_pha_int = interp1d(times, gw_sxs_bbh_0305_pha, kind='cubic')\n",
+    "    #gw_sxs_bbh_0305_pha_errs_int = interp1d(times, gw_sxs_bbh_0305_pha_err, kind='cubic')\n",
+    "    #position = np.argmax(times >= times_1[0])\n",
+    "    #times = times[position:]\n",
+    "    \n",
+    "    \n",
+    "    #amps=gw_sxs_bbh_0305_amp_int(times) \n",
+    "    #amps_err=gw_sxs_bbh_0305_amp_errs_int(times) \n",
+    "\n",
+    "    #phs=gw_sxs_bbh_0305_pha_int(times)\n",
+    "    #phs_err=-gw_sxs_bbh_0305_pha_errs_int(times)\n",
+    "\n",
+    "    #gw_sxs_bbh_0305 = np.asarray([times,amps*np.cos(phs),amps*np.sin(phs)]).T\n",
+    "    # the sqrt(2) is to correct the double weight of the errror\n",
+    "    #error_lav = np.sqrt(amps_err**2+ (amps**2)*phs_err**2)/np.sqrt(2)\n",
+    "    #gw5_sxs_bbh_0305 = np.asarray([times,gw_sxs_bbh_0305[:,1]+error_lav,gw_sxs_bbh_0305[:,2]+error_lav]).T\n",
+    "    \n",
+    "    dt=0.1\n",
+    "    gw_sxs_bbh_0305_amp = np.asarray(gw[simulation_number]['amp_l2_m2/Y'])[6:] \n",
+    "    times_1 = np.asarray(gw[simulation_number]['amp_l2_m2/X'])[6:] \n",
+    "    gw_sxs_bbh_0305_amp_int = romspline.ReducedOrderSpline(times_1, gw_sxs_bbh_0305_amp)\n",
+    "    gw_sxs_bbh_0305_pha = np.asarray(gw[simulation_number]['phase_l2_m2/Y'])[6:]\n",
+    "    times = np.asarray(gw[simulation_number]['phase_l2_m2/X'])[6:]\n",
+    "    gw_sxs_bbh_0305_pha_int = romspline.ReducedOrderSpline(times, gw_sxs_bbh_0305_pha)\n",
+    "    \n",
+    "    tmin=max(times_1[0],times[0])\n",
+    "    tmax=min(times_1[-1],times[-1])\n",
+    "    times=np.arange(tmin,tmax,dt)\n",
+    "    amps=gw_sxs_bbh_0305_amp_int(times)\n",
+    "    phs=gw_sxs_bbh_0305_pha_int(times)\n",
+    "    gw_sxs_bbh_0305 = np.asarray([times,amps*np.cos(phs),amps*np.sin(phs)]).T\n",
+    "    gw5_sxs_bbh_0305 = gw_sxs_bbh_0305"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f2bb229ea90>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtsAAAHaCAYAAADRxIWQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABIbUlEQVR4nO3de5xcdZ3n/9enc+l07rcmhEsCASQJiAIRBBxhUJbh4ioKC4KG8FtEYVVwZgdnXEZRcARGfwO4wzggCogzKwbUVUGdoAwuiuEiBllDuAQIJJAL6dw76ct3/zhVqepKdXd1d51cX8/Hox9Vdc73nPr2odK8+9uf8/1GSglJkiRJ9dewozsgSZIk7a4M25IkSVJODNuSJElSTgzbkiRJUk4M25IkSVJODNuSJElSTgbv6A7kZeLEiemAAw7Y0d2QJEnSbu6JJ55YmVJqrrZvtw3bBxxwAI8//viO7oYkSZJ2cxHxcnf7LCORJEmScmLYliRJknJi2JYkSZJyYtiWJEmScmLYliRJknJi2JYkSZJykuvUfxHRCHwJ+CgwDvgD8D9SSg/28Tz3A6cBN6WUrqh3PyVJ0p5j7dq1LF++nLa2th3dFe3EBg8ezLBhw2hubmbYsGH9P08d+1TNHcCHgBuB54E5wAMRcWJK6be1nCAizgDenVP/JEnSHmTt2rW88cYb7LvvvjQ1NRERO7pL2gmllGhvb2f9+vW88sorTJo0iTFjxvTrXLmVkUTEMcB5wJUppStTSrcCJwOvANfXeI6hwD8CN+TVT0mStOdYvnw5++67L8OHDzdoq1sRwZAhQxg3bhz77bcfq1at6ve58qzZPhtoA75Z3JBSagVuB94VEZNrOMflQBPw1Vx6KEmS9ihtbW00NTXt6G5oF9LU1MTmzZv7fXyeYftIYGFKaX3F9vlAAG/v6eCI2Bv4O+BzKaWNufRQkiTtcRzRVl8M9POSZ9ieDCyrsr24bZ9ejv8K8Cxwdz07JUmSJG0ved4g2QRUG3NvLdtfVaHeezZwYkop1fqGEXEJcAnAlClTau+pJEmSlIM8R7Y3AY1Vtg8r27+NyMbqbwLuTSn9n768YUrp1pTSrJTSrObm5j51VpIkSXuWq6++OveyojzD9jKyUpJKxW1LuznuLOAY4J8j4oDiV2Hf6MJr72yQJEmqcO+99xIR/OAHP9iu7/vYY49xxhlnMG7cOEaOHMnb3vY27rjjju3ah51VnmUkTwGXR8TIipskjy08/qGb46aQ/RLwyyr7Lip8nQb8rE79lCRJ2i0sWLAAgCOOOGK7vecDDzzA+9//fk466SSuueYahgwZwqJFi1iyZMl268POLM+wPRf478DFZIvaFFeUvAh4JKW0tLBtCjA8pbSwcNyPgZeqnO8HwE/Ipg58Msd+S5Ik7ZIWLFjAyJEjmTZt2nZ5vzVr1jBnzhwuvfRSbrrpptzeZ8OGDYwYMSK38+cptzKSlNLvgO8DN0TE9YWbF38JTAU+W9b0LuBPZce9kFL6YeVXYXdx3/K8+i1JkrSrWrBgAYcffnivdcgPPvggp556KqNHj2bChAl86EMf6jISfcopp3D44Ydvc1xHRweHHnoop59+OgD/+q//SktLC1/60pcAWLduHdXmtmhra2PhwoUsW1ZtorquinXUzz77LOeeey5jxozhzDPP3Lp/yZIlzJ49m7322ovGxkaOOOII/u3f/q3LOV5++WUuu+wyDj30UJqampgwYQLnnHMOL730Uq/vX2951mxDNqPITYXHm4EhwOkppUdyfl9JkqQ9yvr161m8eHGvJSS33norp5xyCkOHDuUrX/kKf/VXf8UjjzzCaaedRnt7OwAzZ87k+eefp6Ojo8uxd999N4sWLeLaa68FYN68eUyfPp3777+f/fffn9GjRzN+/Hj+5m/+psuxr732GjNmzOBv//Zva/5+PvjBD9LR0cH111/PRz7yEQCWLVvGO9/5Tn79619z+eWXc+ONN7LPPvtw/vnnd6kRf+yxx/jNb37Deeedx80338wnPvEJHnzwQU466SQ2bty+y7fkWUZSXDHyrwtf3bU5qcZzOQO9JElSN55++mlSSrz1rW/tts2CBQv45Cc/yXXXXceVV165dfu73vUuTjzxRB5++GFOPvlkDjvsMDZv3szixYs5+OCDAWhvb+eaa67hrLPO4qijjgLg+eefZ8mSJcyZM4crr7ySI488kp/85Cdcf/31tLa2cuONN/b7+zn66KO56667umy76qqraGho4Pe//z1jx44F4NJLL+W0007jc5/7HLNnz6ahoYEzzjiDs88+u8ux73vf+zjuuOO49957+ehHP9rvfvVVrmFbkiRpp/fjH+/oHnT1vvf167Cnn34a6PnmyGuuuYZp06Zx0UUXsXLlyq3bDzzwQABefPFFTj75ZGbOnAnAwoULt4btO++8kxdffLHLTCfr169n9erVXHfddXz2s1mV8Ac/+EHWr1/PLbfcwlVXXcXEiRM54IADqpaX9OQTn/hEl9cpJe677z7OP/982tvbu/T/L/7iL/jZz37GokWLmD59Ok1NpYnr2traWLt2LQcffDBjx47lySef3K5hO+8yEkmSJG0Hvc1EsnnzZu6//36effZZ9tprL5qbm7d+FRcDHD16NACHHXYYkIVtyALrtddey7nnnttl5LwYaj/84Q93ea8LLriAtrY25s+f3+/vp/gLQNGKFStoaWnhlltu6dL35uZmrrjiiq1tADZt2sTnP/959t9/fxobG5k4cSLNzc20tLSwZs2afvepPxzZliRJ2g0sWLCA/ffff2t5RaUXX3yRjRs38vd///e84x3vqNpm1qxZAIwbN4699957a9j+1re+xZIlS/jZz7rOvDx58mSeeeYZJk2a1GV78fXq1av7/f2Uj04DdHZ2AjBnzhwuuOCCqscUb+r81Kc+xbe//W2uuOIKjjvuOMaMGUNEcN555209z/Zi2JYkSXu2fpZt7GyefvppTjjhhG73b9qULd49c+ZM3vve9/Z6vpkzZ7Jw4UK2bNnCl7/8ZT7ykY9w6KGHdmlz9NFHM2/ePF577bUu0w2++uqrANRzRe/m5mZGjRpFSqnX/s+dO5cLL7yQr33ta1u3tba20tLSUrf+1MoyEkmSpF3cK6+8QktLS483Rx5yyCFEBPfee+82+7Zs2bJNecVhhx3GwoULue2223j99df5whe+sM1x55xzDgC333771m0pJb75zW8yYsQI3vnOdwJ9m/qvO4MGDeKss87ie9/7Hs8+++w2+4slJMW2lTXiX//617eZXWV7cGRbkiRpF1es1160aBHXXXfdNvs/9rGPMWHCBC6++GJuu+021qxZw6mnnkpbWxvPPfccc+fOZd68eYwZM2brMTNnzmTVqlVcffXVXHTRRdvUUEM2sj179my+8pWvsHz5co466ih++tOf8vOf/5wbbrhhaw14ceq/Cy+8cEDLuF933XX86le/YtasWVxyySVMnz6dlStX8thjj/Hkk09unUf7zDPP5Dvf+Q5jxoxh5syZ/Pa3v2XevHlMmDCh3+/dX4ZtSZKkXVxxJpL77ruP++67r8u+hoYGLr/8cgBuvvlmpk6dyt13380vfvELRo4cySGHHMKnPvUppk+f3uW44k2S69at46qrrur2vW+77TamTJnCnXfeyZ133sm0adP4xje+wcc//vF6fotAViM+f/58vvjFL3LPPffwxhtvMHHiRI444oitc38D3HTTTQwaNIjvfve7tLa2csIJJzBv3jxOPfXUuvepN9HXaVh2FbNmzUqPP/74ju6GJEnaifzpT39ixowZO7ob2sX09rmJiCdSSrOq7bNmW5IkScqJYVuSJEnKiWFbkiRJyolhW5IkScqJYVuSJEnKiWFbkiRJyolhW5IkScqJYVuSJEnKiWFbkiRJyolhW5IkScqJYVuSJEnKiWFbkiRJe6Srr76aiMj1PQzbkiRJu4l7772XiOAHP/jBdn3fxx57jDPOOINx48YxcuRI3va2t3HHHXds1z7srAbv6A5IkiSpPhYsWADAEUccsd3e84EHHuD9738/J510Etdccw1Dhgxh0aJFLFmyZLv1YWdm2JYkSdpNLFiwgJEjRzJt2rTt8n5r1qxhzpw5XHrppdx00025vc+GDRsYMWJEbufPk2UkkiRJu4kFCxZw+OGH91qH/OCDD3LqqacyevRoJkyYwIc+9KEuI9GnnHIKhx9++DbHdXR0cOihh3L66acD8K//+q+0tLTwpS99CYB169aRUtrmuLa2NhYuXMiyZct6/R6KddTPPvss5557LmPGjOHMM8/cun/JkiXMnj2bvfbai8bGRo444gj+7d/+rcs5Xn75ZS677DIOPfRQmpqamDBhAueccw4vvfRSr+9fb4ZtSZKk3cD69etZvHhxryUkt956K6eccgpDhw7lK1/5Cn/1V3/FI488wmmnnUZ7ezsAM2fO5Pnnn6ejo6PLsXfffTeLFi3i2muvBWDevHlMnz6d+++/n/3335/Ro0czfvx4/uZv/qbLsa+99hozZszgb//2b2v+fj74wQ/S0dHB9ddfz0c+8hEAli1bxjvf+U5+/etfc/nll3PjjTeyzz77cP7553epEX/sscf4zW9+w3nnncfNN9/MJz7xCR588EFOOukkNm7cWHMf6sEyEkmSpN3A008/TUqJt771rd22WbBgAZ/85Ce57rrruPLKK7duf9e73sWJJ57Iww8/zMknn8xhhx3G5s2bWbx4MQcffDAA7e3tXHPNNZx11lkcddRRADz//PMsWbKEOXPmcOWVV3LkkUfyk5/8hOuvv57W1lZuvPHGfn8/Rx99NHfddVeXbVdddRUNDQ38/ve/Z+zYsQBceumlnHbaaXzuc59j9uzZNDQ0cMYZZ3D22Wd3OfZ973sfxx13HPfeey8f/ehH+92vvjJsS5KkPdqPf7yje9DV+97Xv+OefvppoOebI6+55hqmTZvGRRddxMqVK7duP/DAAwF48cUXOfnkk5k5cyYACxcu3Bq277zzTl588cUuM52sX7+e1atXc9111/HZz34WyEak169fzy233MJVV13FxIkTOeCAA6qWl/TkE5/4RJfXKSXuu+8+zj//fNrb27v0/y/+4i/42c9+xqJFi5g+fTpNTU1b97W1tbF27VoOPvhgxo4dy5NPPrldw7ZlJJIkSbuB3mYi2bx5M/fffz/PPvsse+21F83NzVu/pkyZAsDo0aMBOOyww4AsbEMWWK+99lrOPffcLiPnxVD74Q9/uMt7XXDBBbS1tTF//vx+fz/FXwCKVqxYQUtLC7fcckuXvjc3N3PFFVdsbQOwadMmPv/5z7P//vvT2NjIxIkTaW5upqWlhTVr1vS7T/3hyLYkSdJuYMGCBey///5byysqvfjii2zcuJG///u/5x3veEfVNrNmzQJg3Lhx7L333lvD9re+9S2WLFnCz372sy7tJ0+ezDPPPMOkSZO6bC++Xr16db+/n/LRaYDOzk4A5syZwwUXXFD1mOJNnZ/61Kf49re/zRVXXMFxxx3HmDFjiAjOO++8refZXgzbkiRpj9bfso2dzdNPP80JJ5zQ7f5NmzYB2c2P733ve3s938yZM1m4cCFbtmzhy1/+Mh/5yEc49NBDu7Q5+uijmTdvHq+99lqX6QZfffVVAJqbm/vzrVTV3NzMqFGjSCn12v+5c+dy4YUX8rWvfW3rttbWVlpaWurWn1pZRiJJkrSLe+WVV2hpaenx5shDDjmEiODee+/dZt+WLVu2Ka847LDDWLhwIbfddhuvv/46X/jCF7Y57pxzzgHg9ttv37otpcQ3v/lNRowYwTvf+U6gb1P/dWfQoEGcddZZfO973+PZZ5/dZn+xhKTYtrJG/Otf//o2s6tsD45sS5Ik7eKK9dqLFi3iuuuu22b/xz72MSZMmMDFF1/Mbbfdxpo1azj11FNpa2vjueeeY+7cucybN48xY8ZsPWbmzJmsWrWKq6++mosuumibGmrIRrZnz57NV77yFZYvX85RRx3FT3/6U37+859zww03bK0BL079d+GFFw5oGffrrruOX/3qV8yaNYtLLrmE6dOns3LlSh577DGefPLJrfNon3nmmXznO99hzJgxzJw5k9/+9rfMmzePCRMm9Pu9+8uwLUmStIsrzkRy3333cd9993XZ19DQwOWXXw7AzTffzNSpU7n77rv5xS9+wciRIznkkEP41Kc+xfTp07scV7xJct26dVx11VXdvvdtt93GlClTuPPOO7nzzjuZNm0a3/jGN/j4xz9ez28RyGrE58+fzxe/+EXuuece3njjDSZOnMgRRxyxde5vgJtuuolBgwbx3e9+l9bWVk444QTmzZvHqaeeWvc+9Sb6Og3LrmLWrFnp8ccf39HdkCRJO5E//elPzJgxY0d3Q7uY3j43EfFESmlWtX3WbEuSJEk5MWxLkiRJOTFsS5IkSTnJNWxHRGNEXB8RSyNiU0Q8GhHvqeG4CyLilxHxekRsjoiXIuLbETE1z/5KkiRJ9ZT3bCR3AB8CbgSeB+YAD0TEiSml3/Zw3NuA14D7gTeBqcAlwBkRcURK6fUc+yxJkiTVRW5hOyKOAc4DPpNSurGw7S7gj8D1wLu7OzaldGWV8/0IeAL4CPDVHLosSZIk1VWeZSRnA23AN4sbUkqtwO3AuyJich/P93LhcWxdeidJkvZIu+u0x8rHQD8veYbtI4GFKaX1FdvnAwG8vbcTRMT4iNgrImYB3y5sfrCuvZQkSXuMwYMH097evqO7oV1IW1sbgwYN6vfxedZsTyaru660rPC4Tw3nWAQU19VcBXwypfSrOvRNkiTtgYYNG8b69esZN27cju6KdhFr165l1KhR/T4+z5HtJmBzle2tZft780HgdOAvycpIevxOI+KSiHg8Ih5fsWJFX/oqSZL2AM3NzaxYsYKNGzdaTqJupZTYsmULK1euZPXq1YwfP77f58pzZHsT0Fhl+7Cy/T1KKT1cePpARPwQ+GNErE8p/c9u2t8K3ArZcu197rEkSdqtDRs2jEmTJvH666+zeXO1MUEpM2jQIEaNGsWUKVNobKwWaWuTZ9heRlZKUqm4bWlfTpZSWhwRTwAXAFXDtiRJUm/GjBnDmDFjdnQ3tIfIs4zkKWB6RIys2H5s4fEP/ThnE+C/DkmSJO0S8gzbc4EhwMXFDRHRCFwEPJJSWlrYNiUippcfGBHNlSeLiKPJZjB5Isc+S5IkSXWTWxlJSul3EfF94IbCnNovABeSrQY5p6zpXcCJZNMBFr0cEfcATwPrgcOA/w9YB1yTV58lSZKkesp7ufbZZOF4NjAOWACcnlJ6pJfj/gl4L/ABYDhZ/fc9wDUppcW59VaSJEmqo9hdp72ZNWtWevzxx3d0NyRJkrSbi4gnUkqzqu3Ls2ZbkiRJ2qMZtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJwYtiVJkqScGLYlSZKknBi2JUmSpJzkGrYjojEiro+IpRGxKSIejYj31HDcByPiexGxOCI2RsTCiPiHiBiTZ38lSZKkesp7ZPsO4DPA3cDlQCfwQEQc18txtwIzgO8AnwZ+Xnh8JCKG5dZbSZIkqY4G53XiiDgGOA/4TErpxsK2u4A/AtcD7+7h8LNTSg9VnO8J4M7COe+of48lSZKk+spzZPtsoA34ZnFDSqkVuB14V0RM7u7AyqBd8IPC44w69lGSJEnKTZ5h+0hgYUppfcX2+UAAb+/j+fYuPK4cYL8kSZKk7SLPsD0ZWFZle3HbPn0832eBDuC+gXRKkiRJ2l7yDNtNwOYq21vL9tckIs4H/itwQ0rphR7aXRIRj0fE4ytWrOhTZyVJkqR6yzNsbwIaq2wfVra/VxHxZ2R13j8F/q6ntimlW1NKs1JKs5qbm/vSV0mSJKnu8gzby8hKSSoVty3t7QQR8TbgfwMLgHNTSh31654kSZKUrzzD9lPA9IgYWbH92MLjH3o6OCIOAn4GLAfOSCltqHsPJUmSpBzlGbbnAkOAi4sbIqIRuAh4JKW0tLBtSkRMLz8wIvYGfkG2CM6pKSVnIJEkSdIuJ7dFbVJKv4uI7wM3FObUfgG4EJgKzClrehdwItl0gEU/A6YBN5DNyf2usn0vpJR+m1e/JUmSpHrJLWwXzAauKTyOI6u9Pj2l9Egvx72t8HhllX13AoZtSZIk7fRyDduFFSP/uvDVXZuTqmyLKk0lSZKkXUqeNduSJEnSHs2wLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOXEsC1JkiTlxLAtSZIk5cSwLUmSJOUk17AdEY0RcX1ELI2ITRHxaES8p4bjjomIWyLiiYjYEhEpz35KkiRJech7ZPsO4DPA3cDlQCfwQEQc18txpwMfKzx/IbfeSZIkSTnKLWxHxDHAecCVKaUrU0q3AicDrwDX93L4PwOjU0pHAz/Pq4+SJElSnvIc2T4baAO+WdyQUmoFbgfeFRGTuzswpfRGSmlTjn2TJEmScpdn2D4SWJhSWl+xfT4QwNtzfG9JkiTtDlpb4c03s8dd0OAczz0ZeK3K9mWFx33q/YYRcQlwCcCUKVPqfXpJkiRtL1u2wB//CK+Vxcn994e3vhUGDdpx/eqjPMN2E7C5yvbWsv11VagLvxVg1qxZzmAiSZK0A23aBC+/DK++CinB9OlZXq7pwN/8BjZu7Lp9yZJshPuYY6Bh15jBOs+wvQlorLJ9WNl+SZIk7WY6O+H//l946aUsZBc99VS2b+rUXg5+7LGuQXv48NLrFSvg2Wdhxowcel5/ef5KsIyslKRScdvSHN9bkiRJO8izz8LixV2DdtHTT8PKlT0cvHgxrFmTPW9ogHe8A97zHnjLW0ptXnih1GYnl2fYfgqYHhEjK7YfW3j8Q47vLUmSpB1g3bosCxeNHw9HHgmjR2evU4Lf/x7a26sc3N4Ozz9fej1jBuy9d/b80ENhwoTSSZ5+Opf+11ueYXsuMAS4uLghIhqBi4BHUkpLC9umRMT0HPshSZKk7WTBgtKI9vjxcPzxsN9+cOyxMHRotr21NSsx2caLL2Y3RkJWOnLAAV33v+1tpVrt1avhjTdy+A7qK7ea7ZTS7yLi+8ANhTm1XwAuBKYCc8qa3gWcSDYdIAARMRX4aOHlMYVtVxVe/yGl9OO8+i1JkqT+WbIkm6UPIAKOOCJ7BBg2LBuo/kOhtuGFF+DAA8smFunoyMJ20Vvesu1NkCNGZAG82O6552DSpLy+nbrI8wZJgNnANYXHccAC4PSU0iO9HHdg4bhyxdd3AoZtSZKknUhbW3ZTZNFBB8GoUV3b7LcfLFqUTTayZUs2q9/W2ZpffTU7CWSj2vvtV/2NDjooGxbv7MxGt9euLdWo7IRynTMlpdSaUvrrlNLklNKwlNIxKaV5FW1OSilFxbaHUkrRzdecPPssSZKkviuvAGlqgkMO2bZNQwNMm1Z6vXgx1V8ceGBpSLzSsGGlOm7I5hbcie0aExRKkiRpp9XZ2TUrz5gBg7upn9h//1LpyNq1hbKTlpbszkrIDuxtccLyuQOXLas+7clOwrAtSZKkAVm1qlQB0tQE+/SwTviQIbDvvqXXixeTBeaivffuPqkXTZgAjYXlXDZvLhWK74QM25IkSRqQ8klBJk/uvgKk6MADS89ffx3alrze9QS9iejabunOu3yLYVuSJEkD0tJSet7c3Hv70aNhzJjseeeGjSxfWph0e/Bg2Guv2t60fPh8Jy4lMWxLkiSp3zo7uy7mWAzRvdk6ML26haVvFkpC9tpr2+n+ujN+fNdSktWraztuOzNsS5Ikqd/Wr88CN2T12sX825utA9MtLSxvaaS9I7rOMtKbiK5zbC9fXvux25FhW5IkSf1WXkJS66g2ZOvTjGrcAuvX05mClesaa6tBKbeDw3ZnJ/zylz23MWxLkiSp38pLSMaO7duxkwav2vp8eefE0nrutZo4sXQ35po12Trw29Hq1bBhQ89tDNuSJEnqt/KR7b6G7b06S7OQLKfGGyPLDR6c1W4XrVjR93MMwMqVvbcxbEuSJKlfOjoGMLLd2cm4za8zeFA2i8impnGsX9+PTuzAUhLDtiRJknKzZk1pxr2RI7MFa2r25ps0dLYzcfTm7K7KpuH9y8rldd61pN86aW+vbQIUw7YkSZL6pTwcjxvXx4MLJR+Txm7ZOiTer7A9alSp1nvLltKy7zl7883apvY2bEuSJKnPVq6EF14ovS6v5qjJquzmyObRm7NVbgqbOjr6eJ6IbPn2ivPmrdZBdMO2JEmS+uyZZ0rza48a1cew3d6+9c7KpsZORu0zCsjO16+sXB62t1MpiWFbkiRJuWhthbVrs+cNDXDMMbUv/Ah0rcEYPZrmyYO37hpw2N4OI9vt7aXvvzeGbUmSJPVJ+XR/48bB8OF9PEF5IJ44ceBZeTvXbbe0lH5XGDWq57aGbUmSJPVJ+RR9hXLrvimvwZgwoctU2S0tdajbzrmU5M03S8/L+16NYVuSJEl9Ur5q4siRfTy4vb3r5NwTJjB0aGmEOKXaptTbRnnY7tcJamfYliRJUm7KV0UfNqyPB69e3aVeuzg594BLScpTb45hu/KXAcO2JEmS6mpAYbu84LssqdalbnvQoOz5xo2weXM/TtK7deuywXnI1uLprV7dsC1JkqQ+GfDIdlHZ+u6VA9PFaQVr1tAAY8ZUf5866ksJCRi2JUmS1AedndmEH0WNjX08QeVUJgXDhsGIEaX3KC/rrln5MpblqbiODNuSJEnKTXl1RmNjNhFIzTZtKp1g8OBSui4oz8r9GpjeDnXbfanXBsO2JEmS+qBu9dpjx26T1AcctsvKUlizph+1KD3bsiUrB4esaqWWaQ8N25IkSapZHvXaRQMO28OGQVNT9ryjo/ZlHmtU/rvC6NG1rZpp2JYkSVLN6jayXZ6sC8onFNm0qet71SzHUpLKgflaGLYlSZJUs36H7c7OXtNq5YQi5c1rVn5ew7YkSZJ2JZs2lZ4XKzZqsnZtaR32pqZuk/qAS0nKT9CvtN49w7YkSZJy1e+wXeM0HgMO22PGlG683LAB2tr6cZJtVU6kUusy9YZtSZIk1awuYbtKvXa1XS0tpZXda1Y5TUi/JuzeVvmodnme77U7dXl3SZIk7Va2bIGHHoIHHigtn55S15rtPoXtGleDqcuEIuU1HnUqJelPCQkYtiVJklTF4sWwbh20t8OCBdm2detKI82NjbVNfQdkCb04JD5oUK8TVA84Kxu2JUmStDNbsaL0fP16ePll+I//KG0bNaoPJysf1a6ymE2lAd/jWOewnVLXahTDtiRJkgakvb3r6+LodtGECX04WR/XOB/w7H0jR5aG3cvvbOynjRtL91kOHQrDh9d+rGFbkiRJWxVDdk8LygwbBlOn9uGk5YXXNQwLl9+AWCxl6ZO6TNhd/fC+jGoDDB7QO0uSJGnXltLWZPvii/CnP2UDw93NmDdmDJxwQmmlx5qUh+0a6k8GD86aFQ9bs6aPI+mQpeLisHhLC0ya1McTlBi2JUmS1DcpwZNPsvLZVaxqns7kket45sF22HsSayft3e1hU6f2MWhv3pxNbQLZgTXWYIwdWwrbq1f3M2wXDXBku7yUpa9hO9cykohojIjrI2JpRGyKiEcj4j01HrtvRNwTES0RsTYifhgRB+bZX0mSpN3epk2wfDmdS19n88uv87uFY1j08Ov8x/0bsmD8ypJsafVu1FBy3dW6daXno0bVPEH1zjIjSWdn/2+OhPxHtu8APgTcCDwPzAEeiIgTU0q/7e6giBgJ/AoYBXwZaAc+AzwUEW9PKdV3oXtJkqTdXUdH9vXww/zxuUZeWt7EkEET6EwV4TelbCS6ynLqxfKOPikvIellyr9yA56RZMSIrMPt7dn3s2lTHycGz6xfX/rdo6kpm/KwL3IL2xFxDHAe8JmU0o2FbXcBfwSuB97dw+GXAQcDR6eUfl849oHCsZ8BPp9XvyVJknYLHR10vrqUNzvHMmblCyx/ZgWvrhzG6OFDWfxGVsqxpb2bUebW1qphu19lz5Uj2zUaNSqrOunoyHJyN13qXkQ2DL1yZfa6paVfYXsg9dqQ78j22UAb8M3ihpRSa0TcDnw5IianlJb1cOyjxaBdOHZhRDwI/BcM25IkaXeTUlbGUW198ohseHXQoGx/e3s2xNrSkj1u3kxau47Ng4Yz6OUXWfTSUDrWbWTjpmDF2uJQbDY7x/I1NQzNlt0duffeWRlFBBx6aD++r36ObEdkN2MWp+huacn60ieVYXvy5D6eYNtl2vsqz7B9JLAwpbS+Yvt8IIC3A9uE7YhoAI4Abq1yzvnAKRExPKW0sb7dlSRJ2nE6Wtv40+2PEpEIsrAZkWXrlGDwoERbRzCoAdrag84UNA7pZPX6IQSJtZuGsLmtgSzedQJ9GQausH49DBkMo8ew994NzJpVc6l1Vyn1e2Qbsqw84LBd1M+67YHUa0O+YXsy8FqV7cWAvU83x40HGqkSxAvbonDuFyp3RsQlwCUAU6ZM6WN3JUmSdpzOTraWd+xwK1ZkX5MmMez4qf0L2pDVf3R0ZM+HDu1zwXPdV5Ism+awFp2dXQfm+zOynedsJE1AteV6Wsv2d3cc/Tk2pXRrSmlWSmlWc3NzzR2VJEna0TpTwJAhXb+GDu36fNCg7Ka/IUOygxob+znkXKM33qBxSPczk/SqnyUkRdWycp80NWXXDbLSmw0b+nT4unWlmyOHDy+dqi/yHNneRDZCXWlY2f7ujqOfx0qSJO2SBjcN4fCPHrm1bKT4VdTRkeXszZuzzN3ZkVi3PujY3M76tZ0MGtLAxiWrsoC5alWWThsaBrxU+TBagX6OuPdxMZtKxYC7ZUtWRr5hQ7bgTp+MHQvLl2fPW1r6dIKB3hwJ+YbtZWTlHpWK25Z2c9ybZKPa3R2bqF5iIkmStMsaNAgO7NOKIsUR7VKca2ubxBtvQFPTaBYtyu4NHLz2Tdo3d2She2l38au6oYM7Gdo5gLBdXvDcnxoMslKSN97InvcxK2cqw/Z++9V86EBvjoR8w/ZTwOURMbLiJsljC49/qHZQSqkzIp4GZlXZfSzwnDdHSpIkbWvIkFKWPO64bDR80KDxvPEGtLclGt5o4PE/DCFefonU2X1NxpBBnbR1NDB1r8Kce/1Vh7Q6dmzXsN2HrJwZQOH3QG+OhHxrtucCQ4CLixsiohG4CHgkpbS0sG1KREyvcuw7I+LIsmMPBU4Gvp9jnyVJknYbxWXVJ02CffcLJh+9Dyee3cyJ5+/LtL03VF13fdiQDv78iFUcP/1N3rLP+v6XoWzeXArqgwb1q4wEuobc1f1Z1rD8BGvW9Lg6Zrl63BwJOY5sp5R+FxHfB26IiOLsIRcCU8lWkiy6CziR0t9CAG4BPgbcHxFfI1tB8i/Jykf+Ma8+S5Ik7e5GjwZG78P0/cYz8vXBDH7mD2x+o4VnXsnC8OFT19E4pLN0Y2TZnNt9Uj4sPHp0v2/kLM/Ka9dmIbihL8PFQ4dmdeybNmUHr1tXU3Jeu7ZUMz9iROme1L7Ke7n22cA1hcdxwALg9JTSIz0dlFJaFxEnkQXrvyMbgf8VcEVKaVWeHZYkSdoTDBoxjKkHAfvMJP3+KYbvN4TGljcYN7IiXPc3bNej4JksK48Ykd0cWRxt7nNJx9ixWdgu9quG/tTj5kjIOWynlFqBvy58ddfmpG62vwqck0/PJEmSBEBTE3H8cewN8OyzsGhR1/31CNsDSauFw4uz9rW09DNsL1tWOsHUqb0eUod7O4F8a7YlSZK0KznkkGxKlPIJpbds6d+56nF3YZXD+1W33Y+bJOv1u4JhW5IkSZmGBjj8cJhVNilcf0a2W1u73hzZ5/n6uhrwSpLlQ9Pr1pVWtexGR0fXVeYd2ZYkSVL9DHRku7Jee4CrXJbfX7l+fT/y/+DBpcCfUtdR9yrKb44cOTI7vL8M25IkSeqqfOqN/oxs17FeG7LB8fLV3vs1ul259nsP6tl9w7YkSZK62snCduVptmfYHkgJCRi2JUmSVGnQoNJk1p2dvdY4byOHsD3guu0+hO063ttp2JYkSVIV/a3b3rixNBo+ZEg2SXYdDHhGkjFjSr9AbNjQ7Yh9e3tWFw5ZnXh5+Up/GLYlSZK0rf6WkuQwqg1db1QsXwm+Zg0NXZeM72Z0e82a+t0cCYZtSZIkVdPfke3yYec6hu2IOoxu11BKUn7e8tKV/jJsS5IkaVvlI9t9CdurVpWejx9fv/6wfW6SNGxLkiQpf8OGlZ7XWrPR1la6uzCiPmm1jCPbkiRJ2j30J2y/+Wbp+ejRXUfH66A8/JbXVtds1KhsphXousplwaZNWT04dF0HZyAM25IkSdrW8OGl5xs21HZMeQnJhAn17Q9Z/i/+DlA+a0jNein8riw3H+DCl4BhW5IkSdWUz3n35pvZfNu9KR/ZziFsQx3qtsvryMv7S/1LSMCwLUmSpGpGjiwNI2/ZAq++2nP79vau6bfON0cWDbhuuzxFG7YlSZK0Q0TAgQeWXr/0Us/tV68uFVGPHt116sA6GvBKkuW/BKxZs3V1zM7OritHGrYlSZKUr6lTS8/Xru25lCTHKf/KjRnTtUt9XUmeIUNKi9uktHU4e82a0rc3fHj9flcwbEuSJKm68uXWU4J167pvm/PNkeVdKs4SklLX0eiaVanbLq8oqefvCoZtSZIkda98ifO1a6u36ejoWtORY9iGOtRtVwnbef2uYNiWJElS98pnJeluZLulpVSDMXIkNDbm2qXyMFwekmtWHrZXryZ1ptwmUjFsS5IkqXvlI9vdhe28ajC6URm2+7y4zfDhXSbsXvfaWtraspeNjaXKmXowbEuSJKl75WG7u1Vkyms5tkPYHjGi6+I2A63bXvVi6QT1roAxbEuSJKl7I0aUllLcuDFLt+VS2u4j2wATJ5aer1zZjxM0N299umpxqRbdsC1JkqTtp6GhNP0HbHtH4oYNbK3BGDq0vjUYPRhw3XZZWn/z1Y1ba84N25IkSdq+ykaBWbKk677yOu7ySbBzVj6yvWpVbavJdzF8OIwYwdqNg9m8GVi/nqFDu/5eUQ+GbUmSJPVs//1Lz5cuhdbW0uvyOu7y+u6cDR8OTU3Z88qZB2s2cSIr1hRWr1m7lubmUsVMzXpZVcewLUmSpJ6NHl2qr0gJ3nijtK98ZLvew8K9KB9wX768fyeoDNt90tkJ//7vPTYxbEuSJKl3kyaVnpcPI5ePbG/nsF3epfL8X6uOcRNZta4Qtjesp3lsW99OsHJlqV69G4ZtSZIk9a68Hrs4mp3SDisjgaxuu6GQZteu7VrdUotVa4fQOSLr86hh7Qxb08fE/vrrvTYxbEuSJKl35aPWxbDd2lqqWR4yJJuNZDsaPLjrTIN9LSVZvpyta783j9lcU3jeKiXDtiRJkupk2LAsUEM213ZrazacXLSdR7WL+ltKkhIsWwaMG5edZ+yWLH33csPjVi0tZNOY9MywLUmSpNpUjm6X3xw5evT27w9dw/by5b2WUG+1Zk2h7KSpiaGjGpkwaksWtFesqO0ENY6CG7YlSZJUm8ql23eCke0RI0rl5J2dtVeCLFtWej7p4FGlKf+WLq3tBDW2M2xLkiSpNuUj23/8I7z2Wun1dlzQptK++5ae15KBU+ra9b3fWjbn37JlvQ+Pv/lmtnQ9lEprumHYliRJUm26G70eOnTrjYY7wj77lJ6vWAFbtvTcftUq2LQpez50KOx10KhSGUxnZ++JvXwVzfI3r8KwLUmSpNp0N4/2YYf1Y+nF+mlqKs1KkhK88krP7cv377tvYfrA8lUyX365+4Pb2rqG8fLjqjBsS5IkqTbF9dHL/dmfwX77bf++VJgypfT8pZey0F1Na2vXeu2tx+23X2nS7jVrsgVrqnnppWw2FshG+guzmXQn17AdEWMj4taIWBERGyLilxHx9hqP/U8RcXtEPB0RHRHxUp59lSRJUi8iuobLffbZoeUj5fbdtzTN96ZNXQN1ucWLs0oRyL6VrZOoDB3aNbE/99y2B3d0ZCcoOuigXvuVW9iOiAbgp8B5wNeBK4FJwEMR0XvP4PzC1zrgtV7aSpIkaXuYMSMb0R0/Pisf2Uk0NMDUqaXXCxeWQnXR5s3ZwHTRwQdXnOSgg0rlMCtXbju1yXPPlebWHjas652Z3fWrpt73z9nA8cDslNKXUkr/BJwEJOALNRz/OWB0Sul44MnceilJkqTaTZgAJ50EJ5yQBc6dyLRppclBNmzoOggN8Kc/lSpARo7sOkc3AMOHdx3dXrCgdCflm2/C88+X9h16aKnspAd5h+2lwI+KG1JKK4B7gA9ERI/zpKSUlqaUapyWXJIkSXu6oUPhkENKrxcuzDIyZDdFlk8i0u09nTNmQGNj9nzzZnjkkexEjz5aKgQfN67XGyOL8gzbRwJPpLRNefp8YBRQOXAvSZIkDciBB3Zd5Oa3v4Xf/Ab+8IdSm332gb326uYEQ4bA0UeXkvimTVn5SHEZ96FDu+7vRZ5hezJQrTS9uK3nSQn7ISIuiYjHI+LxFbUutSlJkqTdRkNDloWLg9Odndm82kWjRsHb3tbLSSZMgGOOgcGDu24fPhyOP776rCzdGNx7k603Ow6tpW1KqbXwtAnYXKVJ+f66SindCtwKMGvWrG4mfJEkSdLubMSIrKT8ySehpaW0fa+94Kijts3QVe21F5x8Mrz6aja6PXp0dkPkoEF96ktNYRt4N/CrWhpGRHNKaSWwCWis0qRYSb+pxveWJEmS+mTEiGwK8NWrs5XVR47sx4ryjY01Te/Xk1rD9kLgohrbris8LiMrJalU3FbDyvWSJElS/40b1+u6M7mqKWynlF4H7ujjuZ8Cjo+IqLhJ8lhgPfB81aMkSZKk3USeN0jOJbsJ8v3FDRExETgH+FH5tH4RcVCNC91IkiRJu4xay0j6Yy7wKHBXRHwVWAlcRhbwr65o+2Dh8YDihog4AvjPhZdvAcZExFWF1w+nlB7Op9uSJElSfeQWtlNKHRFxOvAPwKfJZh+ZT7aiZC0lJEcB11RsK77+ImDYliRJ0k4ttl1zZvcwa9as9Pjjj+/obkiSJGk3FxFPpJRmVduXZ822JEmStEczbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTnJNWxHxNiIuDUiVkTEhoj4ZUS8vYbjGiLiooj4cUQsKRz7x4j4XEQ05tlnSZIkqV5yC9sR0QD8FDgP+DpwJTAJeCgiDurl8OHAt4CJwDeAK4D5wDWFc0qSJEk7vcE5nvts4HjgrJTSDwEi4h5gEfAFYHYPx24BTkgp/aZs220R8RLwxYg4KaX0UB6dliRJkuolzzKSs4GlwI+KG1JKK4B7gA9ExJDuDkwpbakI2kU/KDzOqGdHJUmSpDzkGbaPBJ5IKaWK7fOBUcDB/Tjn3oXHlQPpmCRJkrQ95Bm2JwPLqmwvbtunH+e8ElgD/KK/nZIkSZK2l5pqtgs3Ow6tpW1KqbXwtAnYXKVJ+f6aRcTngPcCH08premmzSXAJQBTpkzpy+klSZKkuqt1ZPvdwKZaviJiYuGYTUC1afqGle2vSUScC1wL/EtK6dbu2qWUbk0pzUopzWpubq719JIkSVIuap2NZCFwUY1t1xUel5GVklQqbltay8ki4hTgLuDHwH+rsQ+SJEnSDldT2E4pvQ7c0cdzPwUcHxFRcZPkscB64PneThARx5LNQPIYcF5KqaOPfZAkSZJ2mDxvkJxLdhPk+4sbCiUm5wA/Sim1lW0/qHKhm4iYQbaAzUvA+1JKNZedSJIkSTuDPBe1mQs8CtwVEV8lm67vMrKAf3VF2wcLjwcARMQo4OfAOOAfgDMiorz9gpTSgrw6LkmSJNVDbmE7pdQREaeTheVPk80+Mh+YnVLqrYRkArB/4fl1VfZ/ETBsS5IkaaeW58g2KaXVwMWFr57aHVDx+iUgqjaWJEmSdhF51mxLkiRJezTDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlBPDtiRJkpQTw7YkSZKUE8O2JEmSlJNcw3ZEjI2IWyNiRURsiIhfRsTbazz28oh4pHBsa0Q8FxE3RsTEPPssSZIk1cvgvE4cEQ3AT4G3Al8FVgGXAQ9FxNEppRd6OcVRwDPAXGAtcChwCfAXEXFkSmlTXn2XJEmS6iG3sA2cDRwPnJVS+iFARNwDLAK+AMzu6eCU0oWV2yLiUeBe4AyyEC5JkiTttPIsIzkbWAr8qLghpbQCuAf4QEQM6cc5Xy48jh1w7yRJkqSc5Rm2jwSeSCmliu3zgVHAwbWcJCImRsTeEfEu4GagHfiPuvZUkiRJykGeZSSTgV9W2b6s8LgP8KeeThARI4EVZZteBT6cUnquLj2UJEmSclRT2C7c7Di0lrYppdbC0yZgc5Um5ft7swk4BRgGvA34EDC6h35eQnYTJVOmTKmlu5IkSVJuah3Zfjfwq1oaRkRzSmklWVBurNJkWOGx19lEUkodwLzCy59ExDzg0YhYnlL6SZX2twK3AsyaNauyfEWSJEnarmoN2wuBi2psu67wuIyslKRScdvSGs+3VUrpdxGxBLgA2CZsS5IkSTuTmsJ2Sul14I4+nvsp4PiIiIqbJI8F1gPP9/F8RcOAMf08VpIkSdpu8pyNZC7ZTZDvL24orP54DvCjlFJb2faDIuKgstfDImJU5Qkj4v1AM/BEjv2WJEmS6iLP2UjmAo8Cd0XEV4GVZCtINgBXV7R9sPB4QOFxb+D3EfE9shlL2oCjgY+SzbV9U479liRJkuoit7CdUuqIiNOBfwA+TTb7yHxgdkqptxKSVcB3gT8nq88eCiwB/hm4tnADpiRJkrRTy3Nkm5TSauDiwldP7Q6oeL0O+GR+PZMkSZLyl2fNtiRJkrRHM2xLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5MWxLkiRJOTFsS5IkSTkxbEuSJEk5yTVsR8TYiLg1IlZExIaI+GVEvL0f5xkUEQsiIkXEFfXvqSRJklR/uYXtiGgAfgqcB3wduBKYBDwUEQf18XSfAKbVt4eSJElSvvIc2T4bOB6YnVL6Ukrpn4CTgAR8odaTRMR44EvADXl0UpIkScpL3mF7KfCj4oaU0grgHuADETGkxvNcA7wIfKfuPZQkSZJylGfYPhJ4IqWUKrbPB0YBB/d2goh4K/Bx4C/JRsQlSZKkXUaeYXsysKzK9uK2fWo4x83AD1NKv65bryRJkqTtZHAtjQo3Ow6tpW1KqbXwtAnYXKVJ+f6e3rNY8z2jlvctHHMJcAnAlClTaj1MkiRJykWtI9vvBjbV8hUREwvHbAIaq5xrWNn+qiJiGPBV4KaU0os19pGU0q0ppVkppVnNzc21HiZJkiTloqaRbWAhcFGNbdcVHpeRlZJUKm5b2sM5LgMmAN+NiAMK2/YrPI4vbHstpdRWY58kSZKk7a6msJ1Seh24o4/nfgo4PiKi4ibJY4H1wPM9HDsFGFk4R6W/K3zNIPslQJIkSdop1Tqy3R9zyab/ez/wQ4BCick5wI/KR6WLi9yklF4obLodeKjifHsB/wJ8C/gx8Gp+XZckSZIGLu+w/ShwV0R8FVhJVh7SAFxd0fbBwuMBACmlp4GnyxuUlZM8nVL6YR4dliRJkuopt7CdUuqIiNOBfwA+TTb7yHyyFSV7KiGRJEmSdgt5jmyTUloNXFz46qndATWc6yUg6tIxSZIkaTvIc1EbSZIkaY9m2JYkSZJyYtiWJEmScmLYliRJknISXdeb2X1ExArg5R3dj53URLKpGJUPr2++vL758vrmy+ubL69vvry+3ZuaUmqutmO3DdvqXkQ8nlKataP7sbvy+ubL65svr2++vL758vrmy+vbP5aRSJIkSTkxbEuSJEk5MWzvmW7d0R3YzXl98+X1zZfXN19e33x5ffPl9e0Ha7YlSZKknDiyLUmSJOXEsC1JkiTlxLC9i4uIQyPiHyPiNxGxKSJSRBzQTdvUzdcnqrTdNyLuiYiWiFgbET+MiAO7Oe9/jYg/RURrRCyKiP9W529zh6n1+kbE/hFxdUTMj4jVEbEyIn4VEe+p0vbqbv47vN5NH/b461vWvqZr4ee3exHxUA8/C9oq2r7UTbvrqpx3bETcGhErImJDRPwyIt6+3b6xnUREzOnh+g6r0v4/R8SThc/fKxHxhYgYXKWd1xeIiPdExLcL/1Y3RsQLheuyd5W2fn7rICIaI+L6iFha+Dn9aLX/t6l72/yD1i7nOODTwJ8KX0f20v7nwN0V235X/iIiRgK/AkYBXwbagc8AD0XE21NKq8vafhz4BvB94P8H/gz4nxExLKX0tf5+UzuRWq/v+4ErgR8Cd5L925oNzIuI2Sml71Q55uPAxrLXmyobeH1Lar0Wfn579WXgmxXbRpBdh19Uaf8EcGPFtj+Wv4iIBuCnwFuBrwKrgMvIrvnRKaUXBt7tXc7/AF6p2Lal/EVEnEb2M+OXwKfIrt/nyRYO+VRZO69vyfXAeLJ/s88B04BPAmcW/n0vr2jv53fg7gA+RHYdnwfmAA9ExIkppd/uuG7tQlJKfu3CX2Q/dEYVnl8BJOCAbtom4MYaznkl0AkcWbZtOllo+VLZtiaylaR+WHH83cBaYMyOvj7b6/oChwETK7Y1kgXIlyq2X104z9he3tvr249r4ee3X/8dPlK49udXbH+p8vp0c/x/KRz/gbJtzcBq4K4d/f1t52s5p3At3l5D22fIwuCgsm3XAh3AIV7fqtfs3UBDlW0JuLpiu5/fgV/vYwrX5oqybcPIQvfDO7p/u8qXZSS7uJTSmymldX05JiKaqv05s8zZwKMppd+Xvc9C4EGyH0pFfw5MAG6pOP6fyEYVT+tLv3ZGtV7flNIzKaWVFds2A/cDUyOiqcphERGjIyK6Oa3Xt6Qv18LPb9+dD2wAflRtZ+HPyMN7OP5sYGn58SmlFcA9wAciYkgd+7rLKPz7rvr/2YiYCcwE/iWl1FG26xayEs8PlW3z+haklB5OKXVWbgPeBGZUO8bP74CcDbRR9tewlFIrcDvwroiYvKM6tisxbO95Lib7n+qmiFgQEWeV7yz8j+EI4PEqx84H3lL2Q6v4J//Ktk9QGFmsW693XXsD64HWKvteAdYAayLiWxExvmK/17ekpmvh57fvIqIZOIVsBHBDlSb/iexnxoZCfewlVdocCTyRCsNeZeaT/eJycD37vIv4Ndm/7w0RMTciplTsr/r5SyktBV6l6+fP69uDQunYSLK/VFXy8zswRwILU0rrK7bPBwJ4+3bv0S7IsL1n+Q3wObL64v9GVuZwX0R8uKzN+ML2ZVWOX0b2j6v4m+xkYHNK6c3yRimlLWQ1b/vUtfe7mIg4GPggMLfih/hq4OtkNdvnkJUtXAj8MiIay9p5fUtqvRZ+fvvuXLJ7DL5bZd8C4Atko6wfIwsz/xIRf1PRbjLdX3PYc64lZMHu22Q/Yz8I3AScCTwSERPL2hU/h91dt30q2np9u3cFMJRsJLqcn9+B89rUgTdI7kQKo3JDa2lb+DNOn6SUTqh4vzvJbhS5ISL+VyEQFssdNlc5RfE9m8oet1RpV2xbrXRih8n7+la813CyG3g2kP2CU37umyqaz42IP5KVL8wGbits9/qW1HotdtvPbzV1uubnAyuAf69yzH+ueL9vA/8H+LuI+OeU0prCriZqu+a7lP5c35TS98n+7Rf9ICIeJrsB7zNkN05C75/V8rIHr283n9+IeDdZoP63lNJ/VByzR39+68RrUweObO9c3k02I0WvXxUjJP1S+JPxN4D9gEMLm4szYjRWOWRYRZtN3bQrtt1mdo0dbLtc34gYBPwvsvrBD6WUqo0KVPoG2cwk5dMpeX1Lar0Wu/Pnt5oBXfOImEY2I8z3Ukrtvb1Zobb4RrIgeFzZru6uZeU139XU5TOdUrofWMi2/76h++u2qaKt17dCREwHfgD8gWzkukd74Oe3Hrw2deDI9s5lIXBRjW37dFNkD5YUHov1wm+S/RZb7aaHyWR3JRfD4zJgaESML/9TfEQMJbvxbGmd+lgv2+v63gacAXy4cqSlOymlzoh4jdJ/B/D6lqv1WuzOn99qBnrNzy88Vish6U7lzwzIrmV31xx2jWtZTT0/00uAA8peFz+H1f5MP5ms7K+8rde3TETsTzZVZQtwRjf3G1SzJ31+68FrUweG7Z1ISul1svkst6dphccVhT50RsTTwKwqbY8FnkspFeeGfqrwOIuu8/POIvuryVPsRLbH9Y2IfyD7n8enU0qV9YM9HTcE2B94rGzzU4VHr2+N12J3/vxWU4drfj7wQkrp0T4c0+VnRsFTwPERERX3JxxLdoPw8wPo4w5T58/0NOCNstdPFR5nAU8WN0bEPmR/bXyqoq3XtyAiJpD9m20ETk4pvdHLIeX2mM9vnTwFXB4RIytukjy28PiH7d+lXY9lJHuIbv4EN4Fs4v7FKaXnynbNBd4ZEUeWtT0UOJmutYi/JBtJvKzi1JeS/YB6oD693zVExF8D/x34+5TS13to11xl81+T/Vnu52XbvL4lfbkWfn5rULg+M4B/7Wb/+Mpp6wpThv412Sjjb8t2zSW7Uer9ZW0nkt0A/KOUUpeVKXdn1f59R8T5wEGU/ftOKT1DNrJ7SaH0rOhSstlw7i3b5vUtiIgRZFOq7gucnlKqGoT9/NbNXGAI2UxmQDaVItmg0iOF2XPUi9h2phvtSiJiDKWVxo4DTge+RvantZdTYeXCiLia7AfJT8imnNsXuATYi2wi/5+UnXMU8HuyVeW+RrYYyF9SmOYnpbSqrO1lZDf2fZ9spOHPyG7y+2xK6YY8vuftqQ/X9yzgPrIVzb5U5VQ/KP6ZMyI2ktV0/5Gs5OHPye6W/z/An5fXznp9Sytv1not/PzWJiK+CvwVMD2l9GyV/XPIbuabS7Y4yASyWXPeAlyaUvpGWdtBZJ/fw8hW4FtJ9kvM/sDR3QWi3VFEPEc2feSTZIsjHUN23Z4Hjim7KY+IOBP432S/+H0POJxsNcR/SSldVtbO61sQET8k+3/Zt8hWii33Rkrp3wvt5uDnty4i4h7gA8A/Ai+QXcd3kP3/6pEd2LVdR3er3fi1a3yR1QCmbr4eKmv3n8hmG3idbAaGN8nujj+hm/PuRxZA1pCNAvxvYFo3bT9GNkKzmex/KJ/e0ddlB1zfq3to12VVRLKa7v9buK6bgWfJAnqT17f69e3rtfDz2+t1byCby/mJHtocDfy40G4zWXB8CDizm/bjyBa+WEk2C8+vgKN29Pe6A67ttWR/em8p/KxdTDb93/hu2n+A7JfDVrJ64i8Cg72+3V7fl2r8meznt37XfBjwD2T1261kc2y/d0f3a1f6cmRbkiRJyok125IkSVJODNuSJElSTgzbkiRJUk4M25IkSVJODNuSJElSTgzbkiRJUk4M25IkSVJODNuSJElSTgzbkiRJUk4M25IkSVJO/h/j5/YNkUb1VAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Test plot real part (data was picked in the last cell). Aligning in time\n",
+    "plt.figure(figsize = (12, 8))\n",
+    "plt.plot(times,gw_sxs_bbh_0305[:,1], \"r\", alpha=0.3, lw=3, label=r'$Lev6$: real')\n",
+    "plt.plot(times, gw_sxs_bbh_0305[:,2], \"b\", alpha=0.3, lw=3, label=r'$Lev6$: real')\n",
+    "plt.xlim(-1700,200)\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if nr_code=='SXS':\n",
+    "    metadata = {}\n",
+    "    with open(metadata_file) as file:\n",
+    "        metadata[simulation_number] = json.load(file)\n",
+    "\n",
+    "    af = metadata[simulation_number]['remnant_dimensionless_spin'][-1]\n",
+    "    mf = metadata[simulation_number]['remnant_mass']\n",
+    "\n",
+    "elif nr_code=='Maya':\n",
+    "    af = 0.6861\n",
+    "    mf = 0.9515\n",
+    "\n",
+    "elif nr_code=='LaZeV':    \n",
+    "    metadata = {}\n",
+    "    #with open(metadata_file) as file:\n",
+    "    #    metadata[simulation_number] = json.load(file)\n",
+    "    fread = open(metadata_file, \"r\")\n",
+    "    metadata = fread.readlines()\n",
+    "   \n",
+    "    af = 0.6919694604\n",
+    "    mf = 0.9520211506\n",
+    "    \n",
+    "#times --> x axis of your data\n",
+    "times = gw_sxs_bbh_0305[:,0]\n",
+    "tmax=FindTmaximum(gw_sxs_bbh_0305[round(len(gw_sxs_bbh_0305)/2):])\n",
+    "times = times - tmax\n",
+    "\n",
+    "#times 6--> x axis of your data\n",
+    "times5 = gw5_sxs_bbh_0305[:,0]\n",
+    "tmax5=FindTmaximum(gw5_sxs_bbh_0305[round(len(gw_sxs_bbh_0305)/2):])\n",
+    "times5 = times5 - tmax5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if parser.has_option('setup','qnm_model'):\n",
+    "    qnm_model='berti'\n",
+    "    rdownfolders=np.asarray([rootpath+'/RDmodes/l2/n'+str(i+1)+'l2m2.dat' for i in range(nmax+1)])\n",
+    "    rdowndata = np.asarray([np.loadtxt(rdownfolders[i]).T for i in range(len(rdownfolders))])\n",
+    "    w , tau  = QNM_Berti(mf,af,2,2)\n",
+    "else:\n",
+    "    qnm_model='qnm'\n",
+    "    w , tau = QNM_spectrum(mf,af,2,2)\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([3.])"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# loading priors\n",
+    "w_mins=np.empty(nmax+1)\n",
+    "w_maxs=np.empty(nmax+1)\n",
+    "tau_mins=np.empty(nmax+1)\n",
+    "tau_maxs=np.empty(nmax+1)\n",
+    "a_mins=np.empty(nmax+1)\n",
+    "a_maxs=np.empty(nmax+1)\n",
+    "ph_mins=np.empty(nmax+1)\n",
+    "ph_maxs=np.empty(nmax+1)\n",
+    "\n",
+    "for i in range(nmax+1): \n",
+    "    wp_min=parser.get('prior-w'+str(i),'w'+str(i)+'_min')\n",
+    "    w_mins[i] = np.float(wp_min)\n",
+    "    \n",
+    "    wp_max=parser.get('prior-w'+str(i),'w'+str(i)+'_max')\n",
+    "    w_maxs[i] = np.float(wp_max)\n",
+    "    \n",
+    "    taup_min=parser.get('prior-'+tau_var_str+str(i),tau_var_str+str(i)+'_min')\n",
+    "    tau_mins[i] = np.float(taup_min)\n",
+    "    \n",
+    "    taup_max=parser.get('prior-'+tau_var_str+str(i),tau_var_str+str(i)+'_max')\n",
+    "    tau_maxs[i] = np.float(taup_max)\n",
+    "    \n",
+    "    amp0_min=parser.get('prior-amp'+str(i),'amp'+str(i)+'_min')\n",
+    "    a_mins[i] = np.float(amp0_min)\n",
+    "    \n",
+    "    amp1_max=parser.get('prior-amp'+str(i),'amp'+str(i)+'_max')\n",
+    "    a_maxs[i] = np.float(amp1_max)\n",
+    "    \n",
+    "    phase_min=parser.get('prior-phase'+str(i),'phase'+str(i)+'_min')\n",
+    "    ph_mins[i] = np.float(phase_min)*2*np.pi\n",
+    "    \n",
+    "    phase_max=parser.get('prior-phase'+str(i),'phase'+str(i)+'_max')\n",
+    "    ph_maxs[i] = np.float(phase_max)*2*np.pi\n",
+    "    \n",
+    "priors_min = np.concatenate((w_mins,tau_mins,a_mins,ph_mins))\n",
+    "priors_max = np.concatenate((w_maxs,tau_maxs,a_maxs,ph_maxs))\n",
+    "prior_dim = len(priors_min)\n",
+    "priors=np.column_stack((priors_min,priors_max))\n",
+    "\n",
+    "if model == 'w-tau-fixed':\n",
+    "    priors_min = np.concatenate((a_mins,ph_mins))\n",
+    "    priors_max = np.concatenate((a_maxs,ph_maxs))\n",
+    "    prior_dim = len(priors_min)\n",
+    "    priors=np.column_stack((priors_min,priors_max))\n",
+    "\n",
+    "elif model ==  'w-tau-fixed-m-af':\n",
+    "    mass_min=[np.float(parser.get('prior-mass','mass_min'))]\n",
+    "    mass_max=[np.float(parser.get('prior-mass','mass_max'))]\n",
+    "    spin_min=[np.float(parser.get('prior-spin','spin_min'))]\n",
+    "    spin_max=[np.float(parser.get('prior-spin','spin_max'))]\n",
+    "    priors_min = np.concatenate((a_mins,ph_mins,mass_min,spin_min))\n",
+    "    priors_max = np.concatenate((a_maxs,ph_maxs,mass_max,spin_max))\n",
+    "    prior_dim = len(priors_min)\n",
+    "    priors=np.column_stack((priors_min,priors_max))\n",
+    "\n",
+    "\n",
+    "if fitnoise:\n",
+    "    l_int=1\n",
+    "    index_mass=-3\n",
+    "    index_spin=-2\n",
+    "    priors_fit_min=[np.float(parser.get('prior-noise','noise_min'))]\n",
+    "    priors_fit_max=[np.float(parser.get('prior-noise','noise_max'))]\n",
+    "    priors_min = np.concatenate((priors_min,priors_fit_min))\n",
+    "    priors_max = np.concatenate((priors_max,priors_fit_max))\n",
+    "    priors=np.column_stack((priors_min,priors_max))\n",
+    "    prior_dim = len(priors_min)\n",
+    "else: \n",
+    "    index_mass=-2\n",
+    "    index_spin=-1\n",
+    "    l_int=0\n",
+    "    \n",
+    "#a_maxs[1]=20\n",
+    "a_maxs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Select the data from 0 onwards\n",
+    "position = np.argmax( times >= (t_align))\n",
+    "position5 = np.argmax(times5 >= (t_align))\n",
+    "gw_sxs_bbh_0305rd=gw_sxs_bbh_0305[position+1:]\n",
+    "gw_sxs_bbh_0305rd5=gw5_sxs_bbh_0305[position5+1:]\n",
+    "timesrd=gw_sxs_bbh_0305[position:-1][:,0][:]-tmax\n",
+    "timesrd5=gw5_sxs_bbh_0305[position5:-1][:,0][:]-tmax5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f2bb1e77990>"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtsAAAHaCAYAAADRxIWQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAACViklEQVR4nOzdeZykZXnv/89de+/d092zbwyzz7APIMNElIAIiuIBD0YEmSOiSeBgEiWv488ICigmmhjU5ASMAcVzPMgSY6LGgCgIKgwC3QOz70vPTE/P9N61378/nqeqq7p7prd6qqqH7/v16nT3U1VPPdXTmG9dfd3Xbay1iIiIiIhI4flKfQEiIiIiIqcqhW0REREREY8obIuIiIiIeERhW0RERETEIwrbIiIiIiIeUdgWEREREfFIoNQX4JWmpia7cOHCUl+GiIiIiJziXnnllaPW2uaRbjtlw/bChQvZsGFDqS9DRERERE5xxpg9J7pNbSQiIiIiIh5R2BYRERER8YjCtoiIiIiIRxS2RUREREQ8orAtIiIiIuIRhW0REREREY+csqP/RERERDK6u7s5cuQIiUSi1JciU0QgECASidDc3EwkEpn4eQp4TcMYY8LAF4EbgQbgdeD/s9Y+M87z/AS4Evh7a+2nCn2dIiIicurq7u7m8OHDzJkzh4qKCowxpb4kKXPWWpLJJL29vezdu5cZM2ZQV1c3oXN53UbyMPBnwKPAHUAa+Kkx5qKxnsAY8x7g7Z5cnYiIiJzyjhw5wpw5c6isrFTQljExxhAMBmloaGDu3Ll0dHRM+FyehW1jzAXAh4A7rbV3WmsfBC4F9gJfGeM5QsDfAX/t1XWKiIjIqS2RSFBRUVHqy5ApqqKiglgsNuHHe1nZvg5IAN/OHLDWRoF/BtYZY2aN4Rx3ABXAVz25QhEREXlLUEVbJmqyvztehu1zgM3W2t4hx18CDHD2yR5sjJkJ/BXwWWttvydXKCIiIiLiIS/D9iygbYTjmWOzR3n8l4EtOP3eY2KMudUYs8EYs6G9vX2sDxMRERER8YSXYbsCGKnBJZpz+4jcfu+bgD+z1tqxPqG19kFr7Rpr7Zrm5uZxXayIiIiInPruvvvuorYVeRm2B4DwCMcjObcPY5xX//fAE9baX3t0bSIiIiKnhCeeeAJjDE899VRRn/fll1/mPe95Dw0NDVRXV3PWWWfx8MMPF/UapgIv52y34bSSDJU5dvAEj/sAcAHwWWPMwiG31brHDltrRwzrIiIiIm8lLS0tAJx55plFe86f/vSnvP/97+cd73gH99xzD8FgkK1bt7Jv376iXcNU4WXYfg24wxhTPWSR5IXu59dP8Lj5OBX3X4xw23r340rgZwW6zoJpeXwrx/b3Ewj58If8hCr8VE6LUNUYoW5uDbWzqtBiaBERESmklpYWqqurWbRoUVGer6uri5tvvpk//uM/5u///u89e56+vj6qqqo8O3+xeNlG8jgQBG7JHHB3lFwPvGCtPegem2+MWZ7zuB/jVLeHfgD8u/v17z287gnrOxajpyPO8bYoR/f0cXBzN9tfPMLrP97Lc//4Bj/90qv89pEt7NnQTjyaLvXlioiIyCmgpaWF1atXj9qH/Mwzz3DFFVdQW1tLY2Mj1157bV4l+vLLL2f16tXDHpdKpVi2bBlXXXUVAP/n//wfOjs7+eIXvwhAT08PIy2xSyQSbN68mba2keZl5Mv0UW/ZsoXrr7+euro63vve92Zv37dvHzfddBPTp08nHA5z5pln8n//7//NO8eePXv4kz/5E5YtW0ZFRQWNjY188IMfZPfu3aM+v5c8q2xba39njPkh8NfuTO0dwEeBBcDNOXf9LnAJzjhArLU73PvmcX+Bdlhr/9Wra56sVOLkAToVTdC+vYv27V20/sdeZi6vZ9G62Uybo0H7IiIiMn69vb3s2rWLyy677KT3e/DBB/nkJz/Je97zHr785S/T1dXFAw88wJVXXslrr71GIBBg5cqVPP/886RSKfx+f/axjz76KFu3bs2G26effprly5fzk5/8hDvvvJP9+/dTX1/PJz7xCe67777sYw8cOMCKFSv46Ec/OuZe7v/23/4bK1as4Ctf+QrBYBCAtrY23va2txEKhbjjjjuYNm0aP/rRj/jwhz9MLBbj5ptvBpwe8hdffJEPfehDzJ07l927d/OP//iPvOMd7+DNN9+ksrJynD/dwvCyjQSciSL3uJ8bgBbgKmvtCx4/b0msuWEZ8d44yViKVDRBrCdOX0eU3qMDHD8wwEBOl7lNpmjb2EHbGx00LKxn5RXzFLpFRERkXFpbW7HWcsYZZ5zwPi0tLdx2223cf//93Hnnndnj69at45JLLuG5557j0ksvZdWqVcRiMXbt2sXixYsBSCaT3HPPPXzgAx/g3HPPBWD79u3s27ePm2++mTvvvJNzzjmHf//3f+crX/kK0WiUr3/96xN+Peeddx7f/e5384597nOfw+fz8eqrr1JfXw/AH//xH3PllVfy2c9+lptuugmfz8d73vMerrvuurzHXn311Vx00UU88cQT3HjjjRO+rsnwNGy7O0Z+xv040X3eMcZzlX23c6Q+QqQ+MvKN1jJwqIu21qO0berk2FG3Cm7h+K5OXniwm5lnNLP63XOpqPaPfA4REREpnB//uNRXkO/qq8f9kNbWVuDkiyPvueceFi1axPr16zl69Gj2+GmnnQbAzp07ufTSS1m5ciUAmzdvzobtRx55hJ07d+ZNOunt7eX48ePcf//9/OVf/iXgVKR7e3v5h3/4Bz73uc/R1NTEwoULR2wvOZlPfvKTed9ba3nyySf58Ic/TDKZzLv+d7/73fzsZz9j69atLF++nIqKwaJlIpGgu7ubxYsXU19fz+9///uShW0ve7YllzFUzKpn0bsWc/H/PI93rD+N+UvC+Iz7S5hOc+j1w/zymxvZu7G7tNcqIiIiU8Jok0hisRg/+clP2LJlC9OnT6e5uTn7MX/+fABqa2sBWLVqFeCEbXAC67333sv111+fVznPhNo/+qM/ynuuG264gUQiwUsvvTTh15N5A5DR3t5OZ2cn//AP/5B37c3NzXzqU5/K3gdgYGCAz3/+88ybN49wOExTUxPNzc10dnbS1dU14WuaLK/bSGQkxlCzqJmzFjWzdH8Hm362hwN7kgAk+2K8/thmDm+ZydlXzyMYKvuCvoiIiJRIS0sL8+bNy7ZXDLVz5076+/v50pe+xPnnnz/ifdasWQNAQ0MDM2fOzIbt73znO+zbt4+f/Sx/ANysWbN44403mDFjRt7xzPfHjx+f8OvJrU4DpNNOJ8DNN9/MDTfcMOJjMos6b7/9dv7lX/6FT33qU1x00UXU1dVhjOFDH/pQ9jyloLBdYhVzGzn3Y9NY2LKf135ykL5+AxYOvXaI548McMGHF1Ndp7YSERGRgptA20a5aW1t5eKLLz7h7QPugrGVK1eOuogyc7/NmzcTj8e57777+MhHPsKyZcvy7nPeeefx9NNPc+DAgbxxg/v37wegkLt4Nzc3U1NTg7V21Ot//PHH+ehHP8rXvva17LFoNEpnZ2fBrmci1EZSDoxh2lnzuORPV3Pa0mD2cN/BLp7/pzdp3xc9yYNFRETkrWjv3r10dnaedHHkkiVLMMbwxBNPDLstHo8Pa69YtWoVmzdv5qGHHuLQoUPcddddwx73wQ9+EIB//ud/zh6z1vLtb3+bqqoq3va2twHjG/13In6/nw984AP8v//3/9iyZcuw2zMtJJn7Du0R/8Y3vkEqlZrw8xeCKttlxF9bxeobzqLh2a28/lwXqbQh2TPAS9/dzHl/tJSZi0ozskZERETKT6Zfe+vWrdx///3Dbv/4xz9OY2Mjt9xyCw899BBdXV1cccUVJBIJtm3bxuOPP87TTz9NXV1d9jErV66ko6ODu+++m/Xr1w/roQansn3TTTfx5S9/mSNHjnDuuefyH//xH/znf/4nf/3Xf53tAZ/I6L+R3H///Tz77LOsWbOGW2+9leXLl3P06FFefvllfv/732fnaL/3ve/le9/7HnV1daxcuZLf/OY3PP300zQ2Nk74uQtBYbvc+HzM+cPl1Mzcx++ePEA07iMdjbPh+1s4+78vZe6yqb+TkoiIiExeZhLJk08+yZNPPpl3m8/n44477gDggQceYMGCBTz66KP8/Oc/p7q6miVLlnD77bezfPnyvMdlFkn29PTwuc997oTP/dBDDzF//nweeeQRHnnkERYtWsT//t//m0984hOFfImA0yP+0ksv8YUvfIHHHnuMw4cP09TUxJlnnsm9996bvd/f//3f4/f7+f73v080GuXiiy/m6aef5oorrij4NY2HGe9IlqlizZo1dsOGDaW+jEkZ2H2Y3/yfXfQNON0+Jhjg3BtWMPt0zeMWEREZq02bNrFixYpSX4ZMYaP9DhljXrHWrhnpNvVsl7GKhTO4+KOLqa1x3hDZRJJXf7CFI3vVwy0iIiIyFShsl7nwnCYuunEx1ZXOyJp0NM6G/7uN40cSJb4yERERERmNwvYUEJrVyEUfPo2KsBO4U70DvPyDHQz0n5otQCIiIiKnCoXtKSKyYAYX/fd5BP1O4I61d/PSY7tJJkt8YSIiIiJyQgrbU0jV0jmcf8U0jLvFe/eOdl7/z0MlvioRERERORGF7Smm8W1LOPP8SPb7gy/tZ/fG3hJekYiIiIiciML2VGMM869cxYKFxvk+neaNH++k61hpd0cSERERkeEUtqeiQIDV1y2nttqdUNIfZcMPd5HQgBIRERGRsqKwPUX56mpYc81cAn6nf7t//zE2/uJIia9KRERERHIpbE9hVcvmctbayuz3+3+zj0O7teGNiIiISLlQ2J7iZl+6grlz3HnbqRSv/9seYrHSXpOIiIiIOBS2p7pAgNXXLCYSdBZIxtu7aP0vjQMUERERKQcK26eA4MxGzn5Hffb7tg0HOLhT7SQiIiIipaawfYpovngpC+YPtpNs/MleTScRERF5C3jiiScwxvDUU08V5fl++ctfYowZ8WPz5s1FuYapJFDqC5AC8ftZcfViDj+4lWjCT+xwJ5tf6OCMdzSW+spERETEQy0tLQCceeaZRX3eT33qU5x33nl5x2bPnl3Ua5gKFLYLKR6HaBRiMZg2Dfz+oj59cGYjq95WwyvP9wOw+9f7mXdGPfWNxb0OERERKZ6Wlhaqq6tZtGhRUZ/3kksu4Zprrinqc05FaiMppBdfhF/9Cn77W+jrK8klzH7HUqY3urtJxmK8/h/7sbYklyIiIiJF0NLSwurVqzHGnPR+zzzzDFdccQW1tbU0NjZy7bXXsm/fvuztl19+OatXrx72uFQqxbJly7jqqquG3dbT00MymRzTdb7xxhvceuutLFmyhMrKSmbPns369evp6OjIu9873/lO3vnOd/KrX/2KdevWUVlZycqVK3n++ecBeOyxxzj77LOpqqpi7dq1bN++Pe/xV111FRdffDEPP/wwZ555JpFIhMWLF/PQQw+N6ToLTWG7kCKRwa+jJVqgGApxxpVz8fuchN29/TC7WntLcy0iIiLiqd7eXnbt2jVqC8mDDz7I5ZdfTigU4stf/jJ/8Rd/wQsvvMCVV16ZDcsrV65k+/btpFKpvMc++uijbN26lXvvvTfv+I033khtbS0VFRW8613vorW19aTX8O1vf5t9+/axfv16HnjgAa655hq+973v8YlPfCLvfq2trRw5coSbbrqJd7/73dxzzz0cOnSIG264ga997Wt88Ytf5MYbb+TTn/40GzZs4I477hj2+G3btvHpT3+aa6+9lq9+9auEw2FuvfVWXnzxxZNeoxfURlJI4fDg16UK20Dl0rksXXmETRtTYGHrM/uYu3wFoVDJLklEREQ80NrairWWM84444T3aWlp4bbbbuP+++/nzjvvzB5ft24dl1xyCc899xyXXnopq1atIhaLsWvXLhYvXgxAMpnknnvu4QMf+ADnnnsuAKFQiOuuu44rr7ySpqYmWlpa+OpXv8q6det4+eWXWbp06YjXcd9991FZWZl3LBwO89BDD2GtxRhDW1sbHR0dRCIRXn31VZqbmwHo7+/n85//PD/84Q/ZsGEDEbfAuX37dp5++uns+bq6uti/fz8NDQ289NJL2dfx/ve/n0WLFvGDH/yAtWvXjvfHPCkK24WUW9ku5c4yxrDoiiXs3f4GfVE/iWM9bH6hgzPfqcWSIiIiWT/+camvIN/VV4/7IZlq8skq2/fccw+LFi1i/fr1HD16NHv8tNNOA2Dnzp1ceumlrFy5EoDNmzdnQ+ojjzzCzp078yadrF27Ni+wvu997+Pqq69mzZo1fOELX+D73//+iNeRG7SPHz9OKpVi2rRpxOPxYa/n3nvvzQZtgLq6OgC+/vWvZ4M2QG1tLaGcauLGjRsB+OxnP5t9DQDz5s1jwYIFeW0zxaKwXUhlUtkG8NXXsuriel56pgeAvS/uZ+E5DdTWq3NIRETkVDHaJJJYLMZPfvIT+vv7mT59+oj3qa2tBWDVqlWAE7bf+973kkgkuPfee7n++utPWjkHOOuss7jssst45plnRrw9mUzy8MMP861vfYstW7YwMDCQvW358uXZfvPW1laMMVw95I3H1q1bmTFjBhdeeGHe8U2bNuVV0jNh/SMf+ciwa7DWUlVVddLX4QWF7UIqh57tHDPWnk7zq6/QfsyPjcZ44+k2LrpuTqkvS0RERAqkpaWFefPmUV9fP+LtO3fupL+/ny996Uucf/75I95nzZo1ADQ0NDBz5szsrOzvfOc77Nu3j5/97GdjupZ58+adMGzfcMMNPPXUU9x88838+Z//OU1NTQSDQT7+8Y/nBfmWlhYWLFhAY2P+X+Nff/11zjnnnGGLQFtbW7nxxhuz32/cuJHp06czc+bMvPsdO3aM3bt3D+sPLwaF7UIqlzaSjFCIVX84k189fgRrDUc3HuLQBc3MnK/mbRERkYm0bZSb1tZWLr744hPenqkgr1y5kssuu2zU861cuZLNmzcTj8e57777+MhHPsKyZcvGdC07d+7Ma/3IaGlp4bHHHuMb3/gGt912W/b4jh072L17Nx/72MfyXs9IVfqWlhY++clP5h07ePAgx44dy7v/xo0b8Y8wevmf/umfsNaWZFShegoKqYzaSDJqVi9gwXz3m1SKN3++n3S6pJckIiIiBbB37146OztP2uKxZMkSjDE88cQTw26Lx+N0dXXlHVu1ahWbN2/moYce4tChQ9x1113DHtfe3j7s2K9//WueffZZrrjiimG37d+/HyCvhzoWi3HLLbcAgy0wqVSKTZs2DQvbu3fvpru7e9jxTMtI7uvfuHEjhw4dYufOnXnP/7d/+7dcf/31J1y86SVVtgup3CrbAD4fy961gAPf2U0i5aNv71H2bZnJghWVoz9WREREylamX3vr1q3cf//9w27/+Mc/TmNjI7fccgsPPfQQXV1dXHHFFSQSCbZt28bjjz/O008/nV18CE5lu6Ojg7vvvpv169dnF1Hmuv7666msrGTt2rU0NTWxceNGHnzwQZqamrj77ruH3f+cc86hoqKC22+/nTvuuIPe3l4eeeQRwm6RMhOit23bRjQaHRaqX3/99bz7ZbS2tuLz+bK95plJJmeeeSbvec97+NM//VO6u7v55je/SW1tLd/85jfH+qMtKIXtQvL7IRCAZBLSaWdHyTKYtxeaP5PFKw+yqTUJFrb84gBzly4p9gaXIiIiUkCZyu6TTz7Jk08+mXebz+fLzp9+4IEHWLBgAY8++ig///nPqa6uZsmSJdx+++0sX74873GZ4NrT08PnPve5EZ/3mmuu4fvf/z5f+9rX6O7uZvr06Xz4wx/m7rvvZv78+cPuP2vWLH7wgx/wmc98hs985jOsWLGCu+66iw0bNrBr1y4WLlyY93qGhuqWlhZCodCwa21tbeX000/PTjnJTCL5l3/5F77xjW/w2c9+Fr/fz3vf+17+5m/+ZlgfeLEYe4puL7hmzRq7YcOG4j/xs89Cr7uJzCWXgLvCt9RSR4/zi3/YTDThJOzlH1jBknNrSnxVIiIi3tu0aRMrVqwo9WWIx/7u7/6Ov/zLv6Svr49gMFjQc4/2O2SMecVau2ak29SzXWi5fdvl0koC+JsaWHbOYOvI9l8dIGespYiIiMiU1trayuLFiwsetCdLYbvQymz8X655lyyiusLZgjV5rJttL3eW9oJERERECmTjxo1l+RcMhe1CK8dFki5TW8OKCwZbR3a/cICcmfIiIiIiU5K1ljfffLMsw7YWSBZa7oLIMgvbADMvPp2G37/K8Z4A6Z4+tr54lLP+sKnUlyUiIiIyYcYYejNr5sqMp5VtY0zYGPMVY8xBY8yAMea3xpg/HMPjbjDG/MIYc8gYEzPG7DbG/IsxZoGX11sQuT3b5dgUXVHB8rXTst/ue6mNvt5Tc5GsiIiISKl53UbyMPBnwKPAHUAa+Kkx5qJRHncWcAD4KvDHwCPAu4GXjTEzT/bAkivzyjZA0wWLaGpwerdt/wDbXhw+nF5EREREJs+zNhJjzAXAh4A/s9Z+3T32XWAj8BXg7Sd6rLX2zhHO9yPgFeAjOCG8PJV7ZRsgFGLZ2kaO/kcnAPs3HGLJ2maqqk1pr0tERETkFONlZfs6IAF8O3PAWhsF/hlYZ4yZNc7z7XE/1xfk6rwyBSrbANPOXUjzNLe6PRBl6wuqbouIiIgUmpdh+xxgs7V2aLf6S4ABzh7tBMaYacaY6caYNcC/uIefKehVFtpUqGxDtrqdceCVQ/T2qHdbREREpJC8DNuzgLYRjmeOzR7DObYCh4GXgbXAbdbaZwtzeR7x+8nug55OQyJR2us5iYZzT2P6tCSg6raIiIiIF7wM2xXASH0U0ZzbR/PfgKuAP8dpIznp/uLGmFuNMRuMMRva20sYHKdKdTsYZNm65uy3B145RE+3qtsiIiIiheJl2B4AwiMcj+TcflLW2uestT+11v4dTg/4XxljbjvJ/R+01q6x1q5pbm4+0d28N0X6tgHqz17IjEanuk00ypZfq7otIiIiUihehu02nFaSoTLHDo7nZNbaXTjTSG6Y5HV5b6pUtmFYdbvt922qbouIiIgUiJdh+zVguTGmesjxC93Pr0/gnBVA3WQuykudndDWBns7qkgk3TF65R62gbqzFjKjyZlMQizGtheOlPaCRERERE4RXobtx4EgcEvmgDEmDKwHXrDWHnSPzTfGLM99oDFmWA+IMeY8nAkmr3h4zZPS0gIbNsDru2rpjbojzMu8jQSAYJClFw/+yA++eli7SoqIiMgp7dixYxhj+Md//EdPn8ezsG2t/R3wQ+Cv3S3bbwV+ASwA/jLnrt8FNg15+B5jzMPGmL8wxnzCGPMA8CugB7jHq2uerGyrdiAwpSrbAPVnLcibu739N+rdFhERmQqeeOIJjDE89dRTRXm+X/7ylxhjRvzYvHlzUa6hEFpbWwE444wzPH0ez3aQdN2EE45vAhqAFuAqa+0LozzuW8BlwDVAJU7/92PAPW7vdlnKhu1gkHjSfR8zFSrb4FS3L2qk3d1Vct+GwyxdN52KscyMERERkZJpaWkB4Mwzzyzq837qU5/ivPPOyzs2e/ZYJjuXh0zYXr16tafP42nYdneM/Iz7caL7vGOEYye8fznLrWzHo27YniKVbXB2lWz89QY6ugLY/gG2/66DM97ROPoDRUREpGRaWlqorq5m0aJFRX3eSy65hGuuucbz54nFYoTDIw24m5yNGzcyd+5c6uvrC37uXF72bL/l5IXtTGW7jDe1GSYUYsmF07Lf7n3pENHoSe4vIiIiJdfS0sLq1asxxpz0fs888wxXXHEFtbW1NDY2cu2117Jv377s7ZdffvmIVd5UKsWyZcu46qqrht3W09NDMpkc9RoTiQSbN2+mrW2k/Q4HvfOd7+TSSy/l2WefZd26dUQiEf7qr/5qzK8B4I033uDWW29lyZIlVFZWMnv2bNavX09HR0fe/VpbWz2vaoPCdkEFg+4XgQDxxNTq2c5oPn8hDTVJBmI+OtribP3d8VJfkoiIiJxAb28vu3btGrWF5MEHH+Tyyy8nFArx5S9/mb/4i7/ghRde4Morr8yG5ZUrV7J9+3ZSqVTeYx999FG2bt3Kvffem3f8xhtvpLa2loqKCt71rndl2zJGcuDAAVasWMH/+l//66TX2draysGDB/ngBz/IJZdcwte//nXe9773jfk1AHz7299m3759rF+/ngceeIBrrrmG733ve3ziE5/Ie6433njD835t8L5n+y0lW9n2+0mkpmBlGyASITyvmdZXnGkkB3/QxelrGqiqKvF1iYiIFNiPf1zqK8h39dXjf0xrayvW2pOGxpaWFm677Tbuv/9+7rzzzuzxdevWcckll/Dcc89x6aWXsmrVKmKxGLt27WLx4sUAJJNJ7rnnHj7wgQ9w7rnnAhAKhbjuuuu48soraWpqoqWlha9+9ausW7eOl19+maVLl47/hQBtbW10dHSQTCbZsGFD9hrG8xoA7rvvPiorK/POHQ6Heeihh7DWYoxh7969dHV1FaWyrbBdQCdsI7EWRvnTTrmIxaA9PI/KyC76o376jsV59t+6ee8f1Zb60kRERGSITDX5ZJXte+65h0WLFrF+/XqOHj2aPX7aaacBsHPnTi699FJWrlwJwObNm7NB95FHHmHnzp15k07Wrl3L2rVrs9+/733v4+qrr2bNmjV84Qtf4Pvf//6wa1i4cCHWnnyscOa1fP7zn88L2uN5DUBe0D5+/DipVIpp06YRz+k22LhxI+D9JBJQ2C6obNg2hrgNDt6QSORv4V7GDh6EVDDC7NMr2f6GM0nltV928a5ra6fKSxAREXnLGG0SSSwW4yc/+Qn9/f1Mnz59xPvU1joFtVWrVgFO2H7ve99LIpHg3nvv5frrrx81lJ511llcdtllPPPMMxN9Kdmw/d//+3+f8GtIJpM8/PDDfOtb32LLli0MDAxk77N8+fJsX3trayt+v58VK1ZM+HrHSmG7gHLDaJzcb+JTJmwfcTePbFg+g4qtOxnoihGLxXjt1/VccGlNaS9ORESkgCbStlFuWlpamDdv3gknauzcuZP+/n6+9KUvcf755494nzVr1gDQ0NDAzJkzs7Oyv/Od77Bv3z5+9rOfjela5s2bN6mw3dLSwsKFC5k7d+6EX8MNN9zAU089xc0338yf//mf09TURDAY5OMf/3jeG4bW1lYWL15MJBKZ8PWOlcJ2AQVzitlxcr+ZGoskUynI/GXGBAOsrtnDy3ucX8LWH/Rzzh9cmPcaRUREpLRaW1u5+OKLT3h7prK7cuVKLrvsslHPt3LlSjZv3kw8Hue+++7jIx/5CMuWLRvTtezcuZPm5mGbgI9Za2vriBX6sb6GlpYWHnvsMb7xjW9w2223ZY/v2LGD3bt387GPfSx7bOPGjUVpIQFNIymoQAB87k807QuSXcw7RRZJdnVBOu18Xd11gHNWJwj7ndW9x3YeZ/fvDpfw6kRERCTX3r176ezsPGloXLJkCcYYnnjiiWG3xeNxurq68o6tWrWKzZs389BDD3Ho0CHuuuuuYY9rbx++y/Svf/1rnn32Wa644ooRr2O00X+pVIpNmzaNGLbH+hr2798PkNfvHYvFuOWWW4DBVptkMsnmzZuLsjgSVNkuuFAIZza1u0iywp+eMpXt7H9v1lLff5CmGX5mz0iz6yD0xUPs/OkWFl00A7+/pJcpIiIiDPZrb926lfvvv3/Y7R//+MdpbGzklltu4aGHHqKrq4srrriCRCLBtm3bePzxx3n66aepq6vLPmblypV0dHRw9913s379+uwCxFzXX389lZWVrF27lqamJjZu3MiDDz5IU1MTd99994jXmhn999GPfpSHH3542O3btm0jGo2OGLZramrG9BrOOeccKioquP3227njjjvo7e3lkUceyW6Ikzn3tm3biMViRatsK2wX2LCwHU5Pqco2AH191AX7qQinmbUwxIHDKeIpPz27jrJnUz+LVlee9DwiIiLivcyCwieffJInn3wy7zafz8cdd9wBwAMPPMCCBQt49NFH+fnPf051dTVLlizh9ttvZ/ny5XmPyyyS7Onp4XOf+9yIz3vNNdfw/e9/n6997Wt0d3czffp0PvzhD3P33Xczf/78Sb2WEy30HMtrmDVrFj/4wQ/4zGc+w2c+8xlWrFjBXXfdxYYNG9i1axcLFy7Me65iVbbNaGNYpqo1a9bYDRs2FP15X3wROjqAAwd4W/VGmuvisGQJDPllLke/+hV0dwNtbaytep3G2gS/aV/Mmz/bw+62MEumdTDr8jP4wz9Zlm2XERERKXebNm0qytQJOXWN9jtkjHnFWrtmpNsUmQpscNa2n0Ry6uwiaS309rrf9PZQW+n0atfOr6dpRTNBX4r+RJDo9v3s3ao93EVERETGQmG7wAbDdjB/Y5syNzAwuDgyHO0mGHD+4lE7txbfzBnMakoykAxCNMr25w9m7ysiIiIiJ6awXWAj7iI5BSrbfX3uF4kEVX63ch0IUDW9CqqqaJ4XJpU2EIsxsK+D/dtV3RYREREZjcJ2gWXDtt8/pSrb2bA9MEBVxJ1ZWFNDVRVQWYm/poqGOuvs524t2399iFO03V9ERESkYBS2Cyy76UswODUr2wP9g2G7uppwGAKVIfD7aZxb4ex8k0zSt+coB3eX/+sSERERKSWF7QLLrWxnF0hOgcp2f3/miwGqws7iSGqc7dmrqg1UVOCvrWJGY8KpbqfTbHte1W0RERGRk1HYLrC8nu2Uu/tLMkm5ryjMhu1olMrwYBsJ4LSSRJxt25sX1RBIxQDo2dnOoX3l/0ZCREREpFQUtgssG7aBuA0OflPm1e2BAfeLWMzZiAfclA2VlWTDdqKqgYXT3WSeSrHt+UPFvVARERGRKURhu8CCufna5Cbv8u1vTibd9wLpNL5EjFDADdsVFYOf3K1OBxIBFq2M4Pc5/SNd245w5GCyBFctIiIiUv4UtgssL2wTHOxpLuOwHc1M8YvHiYTSGINTyXa3iYxEyFa2B2I+wnURFixwH5NKsfU5VbdFRERERqKwXWDGQCDgfhMIkEyV/yLJvBaSkNuvXVmZvb2igmzYjib8MDDA6RfPxGecdxLHtxzh6OFUEa9YREREZGpQ2PZAtrrt95NIlf+s7TGFbb8fAgEG4n5Ip4nMa2b+PLfdJJlUdVtERERkBArbHsiG7UBgSoz/y4bteHxwcWRO2A6F3I6SUIhkyjjV+liM09fNxrjV7Y5NRzh2tLwnroiIiIgUm8K2B0asbCfLdxFhtmc7FiMSdCvb7uLIDGeRpLPgcyDmg4EBKpfNY+5sN2AnEppMIiIiUgJPPPEExhieeuqpojzfL3/5S4wxI35s3ry5KNcwlQRGv4uM11SrbGfXbiYShINueHZ7tDMiEegLORNJogk/NdEo+HwsWTeT/Y8dwVrDkY1H6LxkJvXT9B5ORESkWFpaWgA488wzi/q8n/rUpzjvvPPyjs2ePbuo1zAVKGx7YKr1bOdOIzlR2K6oIPvCBuL+bO9J1Yr5zJ7exoHDAYjH2fbCEc6/emaRrlxERERaWlqorq5m0aJFRX3eSy65hGuuuaaozzkVqQTpgbywPQUq27GY+8VJKtu5s7ajcd9go7ffz5J1M7L3O/T6Ybq7tIe7iIhIsbS0tLB69WqMMSe93zPPPMMVV1xBbW0tjY2NXHvttezbty97++WXX87q1auHPS6VSrFs2TKuuuqqYbf19PSQHGOr7BtvvMGtt97KkiVLqKysZPbs2axfv56Ojo68+73zne/kne98J7/61a9Yt24dlZWVrFy5kueffx6Axx57jLPPPpuqqirWrl3L9u3b8x5/1VVXcfHFF/Pwww9z5plnEolEWLx4MQ899NCYrrPQFLY9kNdGMgUq27EYkEpBKuWEbZ8vf2A4bvZ2t8fMrWwD1KxewKzmZPZk215sL9KVi4iIvLX19vaya9euUVtIHnzwQS6//HJCoRBf/vKX+Yu/+AteeOEFrrzyymxYXrlyJdu3byeVyh/n++ijj7J161buvffevOM33ngjtbW1VFRU8K53vYvW1taTXsO3v/1t9u3bx/r163nggQe45ppr+N73vscnPvGJvPu1trZy5MgRbrrpJt797ndzzz33cOjQIW644Qa+9rWv8cUvfpEbb7yRT3/602zYsIE77rhj2OO3bdvGpz/9aa699lq++tWvEg6HufXWW3nxxRdPeo1eUBuJB3Ir2/FEeVe2EwlIp50v/D5LwG8hHHEGhufIDdvRuC+n9wQIBFiytpm2Hx0H4ODvD7FsXTPVNSd/hy0iIiKT09rairWWM84444T3aWlp4bbbbuP+++/nzjvvzB5ft24dl1xyCc899xyXXnopq1atIhaLsWvXLhYvXgxAMpnknnvu4QMf+ADnnnsuAKFQiOuuu44rr7ySpqYmWlpa+OpXv8q6det4+eWXWbp06YjXcd9991GZM+0MIBwO89BDD2GtxRhDW1sbHR0dRCIRXn31VZqbmwHo7+/n85//PD/84Q/ZsGEDEfcv8Nu3b+fpp5/Onq+rq4v9+/fT0NDASy+9lH0d73//+1m0aBE/+MEPWLt27Xh/zJOisO2BUGaX9ilQ2c5tIclOIhnSQgJuB4n7LiKWcMN2Op3dZbLurIVMf76dI8cCEI2y7cV2zrliehFegYiIyMT8+MelvoJ8V189/sdkqsknq2zfc889LFq0iPXr13P06NHs8dNOOw2AnTt3cumll7Jy5UoANm/enA2pjzzyCDt37sybdLJ27dq8wPq+972Pq6++mjVr1vCFL3yB73//+yNeR27QPn78OKlUimnTphHP2WU783ruvffebNAGqKurA+DrX/96NmgD1NbWEsoGL9i4cSMAn/3sZ7OvAWDevHksWLAgr22mWBS2PTCVerazYfskiyPBDdtue0kskRp8cGZEYDDI0rVNHPn3TgAOvHKIpRc3U1Wt6raIiIhXRptEEovF+MlPfkJ/fz/Tp49cBKutrQVg1apVgBO23/ve95JIJLj33nu5/vrrT1o5BzjrrLO47LLLeOaZZ0a8PZlM8vDDD/Otb32LLVu2MJDTjrp8+fJsv3lrayvGGK4e8s5j69atzJgxgwsvvDDv+KZNm/Iq6Zmw/pGPfGTYNVhrqaqqOunr8ILCtgdOOGfb2mHtGaU2lsWRkF0bCaEQ8f6481IGBvLmcTecexrNL26g/ZgfOxBly/NHOPfKGcPOJSIiIoXR0tLCvHnzqK+vH/H2nTt30t/fz5e+9CXOP//8Ee+zZs0aABoaGpg5c2Z2VvZ3vvMd9u3bx89+9rMxXcu8efNOGLZvuOEGnnrqKW6++Wb+/M//nKamJoLBIB//+MfzgnxLSwsLFiygsbEx7/Gvv/4655xzzrBFoK2trdx4443Z7zdu3Mj06dOZOTN/MtqxY8fYvXv3sP7wYlDY9kA2bBtDgpyFhsnksIWHpTZiZTubrAe5u7WTDAVJ9xkSSUMot28bIBhk2cVNtP/Y6d0+8Mohlq6brt5tEREpSxNp2yg3ra2tXHzxxSe8PVNBXrlyJZdddtmo51u5ciWbN28mHo9z33338ZGPfIRly5aN6Vp27tyZ1/qR0dLSwmOPPcY3vvENbrvttuzxHTt2sHv3bj72sY/lvZ6RqvQtLS188pOfzDt28OBBjh07lnf/jRs34vf7hz3+n/7pn7DWlmRUoaaReCA3TydszvuZMmwlGWtlG9wMHsjp284+eFDDOQuZ3jjYZrLlucMFvmIREREB2Lt3L52dnSdt8ViyZAnGGJ544olht8Xjcbq6uvKOrVq1is2bN/PQQw9x6NAh7rrrrmGPa28fPnXs17/+Nc8++yxXXHHFsNv2798PkNdDHYvFuOWWW4DBFphUKsWmTZuGhe3du3fT3d097HimZST39W/cuJFDhw6xc+fOvOf/27/9W66//voTLt70kirbHsgL27mV7XIP2zWjh+2+zCLJpJ+aEcI2wSDL/mA6R/7VmZl58NXDLLl4OrX1el8nIiJSSJl+7a1bt3L//fcPu/3jH/84jY2N3HLLLTz00EN0dXVxxRVXkEgk2LZtG48//jhPP/10dvEhOJXtjo4O7r77btavX59dRJnr+uuvp7KykrVr19LU1MTGjRt58MEHaWpq4u677x52/3POOYeKigpuv/127rjjDnp7e3nkkUcIu39Jz4Tobdu2EY1Gh4Xq119/Pe9+Ga2trfh8vmyveWaSyZlnnsl73vMe/vRP/5Tu7m6++c1vUltbyze/+c2x/mgLSmHbAz6f03aRSoH1B0imjDNSr9zD9knaSLKHgyevbAPUn7WAmb8+zKGjAae6/bx2lRQRESm0TGX3ySef5Mknn8y7zefzZedPP/DAAyxYsIBHH32Un//851RXV7NkyRJuv/12li9fnve4THDt6enhc5/73IjPe8011/D973+fr33ta3R3dzN9+nQ+/OEPc/fddzN//vxh9581axY/+MEP+MxnPsNnPvMZVqxYwV133cWGDRvYtWsXCxcuzHs9Q0N1S0sLoVBo2LW2trZy+umnZ6ecZCaR/Mu//Avf+MY3+OxnP4vf7+e9730vf/M3fzOsD7xYjLWn5m5/a9assRs2bCjZ8//Xf7mjqLdt5bL526gIp2HNGpg1q2TXNJLnn4fOTuDVV1m35DAN1Qm4/PIRq9utrbD71eOwbRur5vew6KwauOCCEc/b/eoOfvWkuyNUKMTbbzuTugZVt0VEpPg2bdrEihUrSn0Z4rG/+7u/4y//8i/p6+sjWOA1cqP9DhljXrHWrhnpNk/TjzEmbIz5ijHmoDFmwBjzW2PMH47hcf/NGPP/jDG7jDH9xpjNxpi/McbUjfbYcjE4kaS8Z23H4zhTUpIJQgG3sp0zrzLXWCvbALVnLGDW9FT2SdS7LSIiIl5qbW1l8eLFBQ/ak+V1qfFh4M+AR4E7gDTwU2PMRaM87kFgBfA94H8C/+l+fsEYM3JDcZkZ3LI9Z9a2ux1qOYnHcccS4oTtQCC7Uc1Q4wnbBAIse/vg2L/Drx/ieEe6gFcuIiIiMmjjxo1l+RcMz8K2MeYC4EPAndbaO621DwKXAnuBr4zy8OustWdaaz9vrf22tfYO4OPAKvecZW/EynbODknlIJ12838yiTGZrdpH7teGzDQSp81/1LAN1KxewJyZbnU7kWDLrw4V6MpFREREBllrefPNN99aYRu4DkgA384csNZGgX8G1hljTti8bK395QiHM/uElt9PcQRTobKd7WpJJgn6rbPfzglaSMAN234/+P1O2E6nT94a4/ez9O0zMcZZF9C+8TDHjpTXz0BERESmPmMMvb293HvvvaW+lGG8DNvnAJuttb1Djr8EGODscZ4vM87i6CSvqyimQs92ttCeGL1fG3KK3oGAE7Zh1Op29cr5zJlls8+z6RdtE79gERERkSnGy7A9CxgpWWWOzR7n+f4SSAFPjnbHcpC3ZXumsl2uYTuZHAzbJ2kjyebwYJB4cmxhG7+fZZfOwedWt49tPsLhfeXVTiMiIiLiFS/DdgUwUhKL5tw+JsaYDwMfA/7aWrvjJPe71RizwRizYaTdjYopL2yXe2U7mSQUHL2ynV07GQyStoZUCne+4clVLp3LgoXuG45Uik1PH+AUnTgpIiIiksfLsD0AjFQmjeTcPipjzB/g9Hn/B/BXJ7uvtfZBa+0aa+2a5ubm8VxrwQUCg18kU+Ve2U4QCrjp9yRhO3uz+04inhx9kSQAxrDkD+c7CzCBnl1H2b999JAuIiIiMtV5GbbbcFpJhsocOzjaCYwxZwH/BrQA11trU4W7PG/lV7bLPGwnxtZGAiOE7TFOWAkvmMnpS/3ON9ay+Zn9TmVcRESkCE7VTfzEe5P93fEybL8GLDfGVA85fqH7+fWTPdgYczrwM+AI8B5rbV/Br9BD2cq2308y00ZSZtNIchdIBv2jt5Fkb3Zf3HjCNsCiPzwtuyV89MAxdm8cunZWRESk8ILBIAMDY/qDusgwAwMDhEcpRp6Ml2H7cSAI3JI5YIwJA+uBF6y1B91j840xeZvdG2NmAj/H2QTnCmvtlJhAkmvEBZLJJOXUrJw7+i8UHEcbyQTDdmBGI0vPGPxl3farA+VW7BcRkVPQ9OnTOXDgAP39/apwy5hYa0kkEhw7doz9+/fT2Ng44XMFRr/LxFhrf2eM+SHw1+5M7R3AR4EFwM05d/0ucAnOOMCMnwGLgL/Gmcm9Lue2Hdba33h13YWSrWwbQzL3x5xM5iTx0hrv6L/szZk2koQZ90Y98995Ojvf2EhfLECivYvtGzpZcVH9+C5cRERkHGprawE4ePAgCVV5ZIwCgQCRSIT58+cTiUx8A3PPwrbrJuAe93MDTu/1VdbaF0Z53Fnu5ztHuO0RoOzDdm6eTpDzTTmG7TGO/oPJVbYBfPW1LD+/hld+7fw5b+fz+znt7DoiFWaUR4qIiExcbW1tNnSLFJOXbSRYa6PW2s9Ya2dZayPW2gustU8Puc87rLVmyDFzko+bvbzmQgnkFrNz39OU0TvqeBxIpcBaJ2z7fM4OkScxLGyPZRrJELPWnU5dtbM6Mt3Tz6bnSjumUURERMQrnobttzK/351JDaR9gcHJG2W0SDIbtsEJ22OouA8L24nEuPvQTVUlK/9gsPdp/0sH6ezQaBIRERE59ShseyhvIkm6vCaSWOsW2d3rCQbs2MO2WwGPJ33OiSbwmpouWMTM6W7rSjzOG/816iRIERERkSlHYdtD5bxlezYfJ5ME/BZjGHVxJLl3CQQGt2wfZ9925vErL5s9uI37psMc3KmNbkREROTUorDtofxZ2znj/8pANvOnUoMztsda2XbvG0+4r2kCfdsAVcvncdrpmV6bNG/+XBvdiIiIyKlFYdtD+btIuj/qMqls587YDma2ah9P2J5sZRucbdwvX5idhDJw4Bg7X++Z2LlEREREypDCtoemXGV7DG0k2YWfgQBpa5zXNdGwDQRnN7P87MHZldt+sY+ouklERETkFKGw7aFsoTiQU9kut7CdTBIMjL2NBCY/a3uo+ZcupqbS6R9JdfWy+bkjkzqfiIiISLlQ2PZQtrLty6lsl2MbiX/sbSQwJGxPYBfJoUxNNavWNWS/3/fbAxw7Uh5vSkREREQmQ2HbQ4OV7cDgNJJyq2ynUuOubIfDg/dNpCZf2QZovmgxs2ba7MW1/mTfeMd3i4iIiJQdhW0P5c/ZLtOwnUgMVrbH0LOdvVsB20jAOd+qK+bi9znX0r2znV0tWiwpIiIiU5vCtoeyhWKfj0SyTKeRjHP0X/ZubtiOJQoUtoGKxXNYutoN/Ba2/NdeLZYUERGRKU1h20PZynYgQKJcp5GMc/Qf5Fe2E8nJ92znWvSuxVRXOIslk119vPns4YKdW0RERKTYFLY9lDtnO1nOc7YnUdkuVM92hq+uhjMumZb9/sDLBznaVh4/MxEREZHxUtj2UG7PdlkukLQW0qmJV7aN27OdSEA6XbBra7rwdObMSmcvtOXf9xby9CIiIiJFo7Dtodye7aT1O1+n0wUNphOVSACpFFicynYg4O5WM7pgEDAG/DlTVgpZsQ8EWHnlAgLuws2+vR1sfel44c4vIiIiUiQK2x7KVraBhM39pvRtEckkTtgGp7I9xqo2nGAb+gK2kgBETpvFynMHd5bc/sxeujtL/yZFREREZDwUtj2Um1+T5ITtMmgliccHryPoT48rbGcnBAaDzqY24MkbiPmXL2NanfOGwEZjvPZjzd4WERGRqUVh20N+v9NtAZD2BQa7R0octrOdLMkkPmPx+5l8ZduDsG0qIpx11Rx8xknYXdsOs/N1zd4WERGRqUNh22PFCqbjkTuJJDDOrdrz7po70rDAbSQZ1SvmsXSl+1cBC1t+voe+XpW3RUREZGpQ2PbY4KxtP8kymbU94oY2Y9w9Epx1lH4/EAhgrXFel1dvIIzh9KuWUVvltJOkevp5/ScH1E4iIiIiU4LCtscGJ5L4vZncMQGT2dAmIxjETdzuxjYeviZfbTVnXT4d47aTdGxs01buIiIiMiUobHssb9Z2po2kHCvb4wzboRAQ9GZjm5HUn7uIxUvd8YnWsumnu+np0nQSERERKW8K2x7L7W8uuzaSSVe2nbCd3djGS8aw9H3Ls+0k6b4BXv03bXYjIiIi5U1h22O5G9uU3QLJSVS287ZsTxrPK9vgtJOc+55ZOdNJjrDt5U7Pn1dERERkohS2PTa4QLLMK9u5O/CMQV7YThWhsu2qWb2A5We4bwwsbHt6D51HSz+3XERERGQkCtseyxv9V24LJNPpyfVsuwsk4wlvF0jmMYZF71mRt9nN75/cXer3LyIiIiIjUtj22OACSR/J9Clc2S5CG0mGqazgnPfPz84I79t3jJanjxTt+UVERETGSmHbY4NhO0CyTKaRZJ8+lZrQpjbZu+f2bCcSFHP4deWSOZx5UVX2+wO/3ce+Lf1Fe34RERGRsVDY9lju6L9sz3aJ20jywrZvEgskjSnpSMM5f7icefPcb1IpWn+0g95ujScRERGR8qGw7bERw3Y5VLathXR6sLLt9l+PVXbDyUDAGf0HRW0lyTz3Gdcto7rSCdipngFeeXKPxgGKiIhI2VDY9ljZhu2Us8Aw4LdOmdqYcZ2jXBZ++qfVcd5VM7LjALt3tLPxl0eLfh0iIiIiI1HY9lhuKE2my6hnOzdsj3NxJORv1lPq+eG1Z53G6vPC2e/3PLeHfZv7SnItIiIiIrkUtj2W7c4wZjBsW5sNu6UwYmV7nHLbSLKV7WK3keRYcOVKZs92v0mlaHlqh+Zvi4iISMkpbHssN8cmyPmmhNXtZHLw+QO+9IQq27ntMYmUzxlEUsqFn6EQZ1+/jJpK501Ef2ecFx/dWcr8LyIiIqKw7bXcHJsyOd+UKGyn084HqRTGWKfyPoHKtjHuw9zHZsf/lZB/Wh1nv28+29sqadldy29+A49947AWTIqIiEjJKGx7zOdzPgDSxj8Y/EoUtrPdK6kUAd/ENrTJCAbJ9skUe2ObE9kRnUPjabXON9ay5XfH+a8fdpb0mkREROStS2G7CIa2XAAlC9uDM7aTE97QJmPEjW1KqKsLDh6EhtVzmdPQD4cPQVsbL377Tbb9VhNKREREpPgUtougnMb/ZfNwKmfG9gQr26EQ+Vu2lzhs79jhftHfz7mnHWdObQ8A6WiMZ7/6e47uGyjdxYmIiMhbksJ2EZRT2M4+bbJAlW23jSSeLG0bSSoFhw653+zbx7IFUa68wlIZdF7w4XYfL//Dy9phUkRERIrK07BtjAkbY75ijDlojBkwxvzWGPOHY3jcBcaYfzDGvGKMiRvj7lgyRWXDts9X8rCd37PtBs/J9GyXSRtJe7v72np7qU4cp64qybz5hlWXziDoSxFP++ncdoSX/s/2cmgtFxERkbcIryvbDwN/BjwK3AGkgZ8aYy4a5XFXAR93v95xsjtOBeVU2R5sI0kVtme7xG0khw+7X3R0MGtaDADfvDnMv2o1S1cG8BlLZ1+Ivq0HeOmx3aUccy4iIiJvIZ6FbWPMBcCHgDuttXdaax8ELgX2Al8Z5eH/CNRaa88D/tOrayyWvLCdLu1uiyO2kRRiGknSlLSNpKMDZ7Ogjg6m1zlhm3nzmDnbR9UZp3P6/CSd0Qh0d3N8yxE2/OiARgKKiIiI57ysbF8HJIBvZw5Ya6PAPwPrjDGzTvRAa+1ha+0ps5ptxMp2iUqr2bCdTk+6sh0K4YRtY5zKdjpdktc1MAB9fUB/P/50gvqqBITD0NhIUxOYpkYaFtbR1GRJ9gxAOs2RVw/w+s8PO5vxiIiIiHjEy7B9DrDZWts75PhLgAHO9vC5y0o2y5ZBG0nBK9vu4+OZLdtLULE/dsz9oquLhuqEM9e8qQmMIRCAulmVEIkwc2kdzQ1JJ50D+1/cw5vPdxT9ekVEROStw8uwPQtoG+F45tjsQj+hMeZWY8wGY8yG9vb2Qp9+wnIXSGbnbJe6jSR3geRkerYBAgESSfd1laCVpLPT/aK7m4Zq9+fa3Jy9vbERqK8Hn49pK2eyYJozEhALO5/ZxbaXOxERERHxgpdhuwKIjXA8mnN7QVlrH7TWrrHWrmnOCVulVk4LJPPCdiEWSEL+Zj0leBPR3Y3Tr93X57SQgFPZdjU2ArXOrpId/RWc8bYqZs10X3s6zeb/2MGO33cV96JFRETkLcHLsD0AhEc4Hsm5/S2h7MK2tfk92+4ix/HKr2yXro2kqwuIRiGVorYy6TSTVwy+l5s2Daiudu7bHyDdN8C5N6ygqdF9/akUb/7bdna+1l30axcREZFTm5dhuw2nlWSozLGDHj53WSm7sO0uYgz4rZOYjZnQucqhst3f7z5lXx9Bf5rKcMppGckRDEJ1QxAqKrDW0NUXwJeMc8HNK2mcNhi43/jXbex8XYFbRERECsfLsP0asNwYUz3k+IXu59c9fO6yUtZhe4KLIyHnocEAyZRxJnsUOWx3Z7JxXx91Ve7PdEjYzh6qqQGgqy8AHR3462u4cP1KpjXkBO6ntqnCLSIiIgXjZdh+HAgCt2QOGGPCwHrgBWvtQffYfGPMcg+vo+TydpDMzNkuh7DtS08qbBuTmbWds4tkkRdIdmVarfv6qK10g/4IYbuujsGw3R+E48cBnMB98wqm1buLRd0K97aXjnt74SIiIvKWMPGkNQpr7e+MMT8E/tqdqb0D+CiwALg5567fBS7BGQcIgDFmAXCj++0F7rHPud+/bq39sVfX7YWyrmxPcHFkRjAIiYC7sU3KR6jIle2eHpwe9P5+6qafuLJdVwdUVQFu2O4aXBAZmFbLhTev4HePbObYcQOpFJv/fTuJ6GmsfHvTsHOJiIiIjJVnYdt1E3CP+7kBaAGusta+MMrjTnMflyvz/SPAlArb2Tzr85FIu4sR3UWKzlDo4nHCthNKJ9tGAiNUtosctnt7gVgM0mmqI0lnM5vw8HW5dXU4x/1+egYsqYE4/oGB7ELKQGMdF65fyYbvbaK9HbCWHU/vJBFLc+Zl0yfa1i4iIiJvcZ4mPWtt1Fr7GWvtLGttxFp7gbX26SH3eYe11gw59ktrrTnBx81eXrMXcvNsyuR8U4LJHU7YdlomCha2cyrbxXxN7rQ/iDqDbaoiqWyryFCBAFRVG6iqwlpD90AwZ0C3e5+GGi74H6uZOTPzBLD3ud288m8HSrXhp4iIiExxxS2rvkXl5tmEzfmmyK0k1rodJGknbPt9U7uyPTDgvpT+AcLBNMGAzY74G0ldHVBZCUDPQCCvlSTDV13Jmv9xJnPnD/6n0bbhAL/5P7uIx7S3u4iIiIyPwnYRGJMzyrqEfdtDt2o3hgJVtt2wnfIVdYFkb6/7RTTqtJDACSvb2Zvcvu2eAf+wynaGqYhw9k1nsmjp4M/m+NZ2nv/2Fvq6VeIWERGRsVPYLpK8iSQlCtvZVojcrdonGbZDocFzxJPFbSPJhu2BgcGwfZLKdl7Y7g/kzA0czoRDrPrwWaw6L5I91n+om+cf3MSxtpE2RhUREREZTmG7SMphIkk2B6dztmqfZNgOBMiW7YvdRpJX2a5w30mMVtkOh8Hnc9pIYrGTV+L9fha9/wzOv6zOabkBEl39/OY7b7J3o2Zxi4iIyOgUtoukHMJ29ulS6YKF7VAIZ6KKz+e0kVhbtNeVnUSSSjmV7WBwxEkkGVVV4PMbqKggmvA7bw56ek7+JMYw85JlrL12FuGg89eAdDTB649toeXnhzLt7yIiIiIjUtgukrywXaKNbQbDduEq23lbtifdNxFFqm739+OEbdxJJCdpIQGnd766muy4v56Bk7eS5Ko/cz7rblpEbY37c7OWPc/v5cVHdxLtV+IWERGRkSlsF8lg2C5dz3Z+2C5Mz3Y2bAcCTmUbihK202lnGkkmbFeEUtl+7JOpqSE/bI9W2c5RuXA66z65mjnzBv+zOb7tKM/90yY6DkTHdf0iIiLy1qCwXSSDCyTLoY0kRcDnYWW7CBNJBgbcL2IxIsGUszeQO9bvZGpqyB//N46wDeCvreLc/3E2q86LYIzzM4wd6+PFh95g8/PtWE0HFBERkRwK20WSG0pLHrbThevZzr6uYHEr2/397hfRKJVhd3HkGMJ2bS0TaiPJEwiw6JozuejqZkJB9+eYSrHt57t48dGdDPSprUREREQcCttFktuznQ2lp1TPdqCoPdvZsB2LDYbtsbaRhELutu0B54eSLZOPT+P5i7jkY4tpaho8dmzrUX71rY0c3Np74geKiIjIW4bCdpGU1zQSD8J2wHkTYS1lXdmuqHCGp1BRQSzh9s+Ps5UkV2ROI2/75NksP3uwrSTRE+WVRzfxyr/u066TIiIib3EK20VSdgskC7SpjTGZWdvOeZKp4sza7u/HeUGplBO2fb6Tjv3LMMYtgLvBvHfAP7FWktxzhkMsufZMLr52FhUR9+dqLQdfaePZb26kbZuq3CIiIm9VCttFUjYLJNNpsNapbOftIz9xzpbt7sY2RdqyPXfsX2U45YRnY8b02KoqoMLZGbIvFoC+voJcU8NZ87nkj1cx77TBNzDxzgE2fG8Trzy1l9iAerlFRETeahS2iyQbtgMBkukShm13z/aA3066qp3hhG2nn6RYu0gOC9tj6NfOqK4GIs4iyd4Bf85WlJMXnFbD2evP4cL3NBEJD87kPvj7Q/zi71vZ9coxTSwRERF5C1HYLpLByraPZCkXSLpbHhY8bPtzKtseh+1Uyi2ex2L4jCUSSo+pXzvDCdtOZbs3Ov7xf6MyhulvW8Q7/mQl8xYO/uUg2Rdj479u5/l/3srxQ7HCPqeIiIiUJYXtIimbBZKeVbadcxWjsp0dHhKNEgmlne6RcYTtqiqciSQ+nxO2EwlPWl+C02o4+3+cy9veN52qysFydteeTn79vzfy2r/t1e6TIiIipziF7SIZcfOXUoZtX7pgYTsUoqiV7Whms0Z3Qxtg/JVtYyASoS/qd9o6CthKkscYms9fyDvuOIvl51biM4Nzufe9fIhf/N3rbP7VYZIJ9ZaIiIicihS2iyS3jSRl3R97Op1t6yiGYlS24wnj+QLJ3N0jK8Luz28cYTsUcq+5ooJU2hBL+LwL2y5fZYQlH1jNOz+2iBmzBhdypqIJtj29h2f+fiO7f3+smL8OIiIiUgQK20WSm2sTNuebIla3PQ3buZXtZBIvVwFmw3Y8TkXIrWy7u0KO1bC+bY/DdkblgmYu+OR5XPSBmdTVDR6Pdw3wux/s4rF7t9Dyq+OZfyYRERGZ4gqTtmRUuRP2UiaAdSfvkUy6fRje83SBpM832CJjrfNk2d6ZwopGcVpVrHXaSAKBcT9XdTUcz4TtAT9NRQrbAPh8NJ07nz84YzYHXthNy6+O8cbuKrr7g5CI88bvdvJfD/m4/MNNrH73PGcTHhEREZmSFLaLJLP5SzJJdpFkMGCLVtnO3dDG77NO0C9k2Ib8regTCc/C9sAA2VaVinA6W6EeD2fWtlMN74sVdvzfWJlggBkXLybUH6cu0Ub/KwdJ9joN6Z3d8MT9x9n271s4+49WMv/CWQRDY5sjLiIiIuVDYbuIyiVsF2qr9ozBLdsDg4s/PVwkmRe2QymoqB33Oaqrye442TsQgP4up+pf5DLyq6/CQDLIrGkxpp+RJt7ez5ZdYeIpP2lreOMNMA/+jq3PLWD+mumcdtFMKmv1n62IiMhUof+vXUT5s7aLO5HEi63aM05Y2fZINEo2bEdC6XH3a4Mbtv1+CIfpjaac1pe+PqipKezFnkRbGxw+7H5xvJPzV/YzpzFNp6+Cf/2xj72b+0mk/Oxqi7C04gA7o0l2/fYwM5fXs/DCGTQuqB7rppkiIiJSIgrbRZQ3azvtA1KnWGXbT6Lf28p2MumeOh7HZyzh4MTCdnbDyXCY/u6YU9Tu7S1a2LYWNm/GedNw4AALp/czpzEKixZRv2oV77kAXvzBHjp+t4NDB4N0Hu6jvroPW1VF28YO2jZ2UDW9kvnnNDHvvOmEK9TYLSIiUo4Utosob8v2UlW202kPw3ZwsLLt0fi/7IzteNypasOEwrbP50wL7K+sgO5u+qJ+aorYt93W5raJHzhAwJdm+dxeqKuDFSsAaG6G0y5ZgC8Rp3lBB8njlsZ4Gx0Vi7KtLn1H+tn0n3vZ8osDzFxez7xzm2k+vVbVbhERkTKisF1Eg5XtEreReBW2/X4SKW8r2yOO/ZvAAklwqtv9ESeo90YDRQ3b27cDsRgcbee0Wf1O//7KlXk948uXw4HdC0l2dxNorGP+aZYzTguw53CE/Vv6sv3x6USKg60dHGztIFQTZs6qeuacM52G2eN/EyIiIiKFpbBdRIM928Xfsj0vbIcKG7bdqX+kAgGsNSRThkAxwnb1xGZsZ1RXQ7sb1PuixZtI0tXlfHD4MD4si2b0QVOT85EjFILTlwfZcmQO7NnL9kPVXDK7g9UfvIwV0QQHNxxk76sdHOsYnGke74mx67eH2fXbw1Q2VTJnVT2zVjdSN1PBW0REpBQUtosotwJ8Ki2QBOe1pTIb2yS9C9vRKE7Dczw+uHvkJMJ2pireFyvexjZ79+JsLtTezqxpMUJBC4sWjXjf006D7Vunkzp0mJ4BOHIEZuzZg3/RIuZdsoh5bz+Nnl1H2ff7dg5s6R1sswH6j/az7Vf9bPvVQSqmVTBrWS0zVzUybb4WVoqIiBSLwnYR5S2QTHo/tSPXiG0kBZyDHQxC1H2BiZSPCo96tgcGyO5QGQmmnCfO3TFoHKqqcMrHfj+9A37nvLFYdiSgF9JpOHAA6OyEVIr5zQNO8/j06SPePxiEBaf52HloJuzZw45DVczYsQMWLnT+pGAMNYuaWbmomRWJJB2b2znw+lHadvQPjmEEBo4NsPM3A+z8zWFCNWFmnF7N9KX1NC1pIBTR4koRERGvKGwXUV7YjrlBqEj7co+4QHKCIXUkwSDZFxhP+jx7ExGLZf7PxMf+ZVRXu19EIvRG3evt7fU0bHd0uD+ajg4qwykaa+IwfxEnKzWffjrs2t6EPXiQjh7oOdZNzYEDMG9e3v1MMEDTGbNoOmMWZwzEOLyxnbY3j3Fk90Be8I73xNj3Wox9r3WAz0f97EqaT69l+tJ66udWa8dKERGRAlLYLqLcBZLF2Pwll9eV7VCIbHhPJI1nryt3xvZEx/5lRCJOcTgdiRDvcxYcBnt7obGxQFc7XFsbzj9GVxczZ0SdjD1nzqjXOXOOn7ZDM2D/fva0V7J69+5hYTuXryLMrPPnMuv8uaRjCTo2t3No03EO7ejLazUhnaZzfy+d+3vZ9quDBCIBps2tZNr8ahoX1VE/r0bhW0REZBIUtosob4Fk2k0wxezZtnawsm2MZ5XtRMrjynbC3dAmmJrwJBJwfgRVVdCT2bY96qfew75ta+HQIeD4cbCWWQ0xqK932khGsWABtO1thgMH2H80woqOdvydnc7jR+ELB2k+azbNZ81mdTJF585jHNlynPadPXR2JLF2sOqdjCY5sr2bI9u74RcH8QX9NMxxwnfDvGrq59cSrizc742IiMipTmG7iPLaSEqxQNJtWQn40gUN2uCGbY8r29a6YTvunHuylW1wWkl63MDeGw14GraPH3ev/9gxwsE0DdUJmD17TI9taoKq+iB906aR6Ojg4LEI83bvhrPPHtc1mICfhqXNNCxtZhmQ6Orn6NZjHNnaSfue/sFpL650IkXH7h46dve4J4CKujD1syqon1tN/bwa6udUEQip/C0iIjIShe0iGjFsF7NnOxO2/bagk0jgBJVta0/aizxe8bhzSuJxgv60094wyf7qqiqgojjj/w4dwvmH6O5iZpPbQjLGsG2MU91+8/AM6Ohg95FK5h044MzmDoUmfE3BukpmnV/JrPPngrX0H+qmY0cnx/b00LF/gL5em/8ACwOdMfqPx9i0oZfO3g6iA2nC/hTTplnmLgiw6Jw6GlfNpHJaRFNPRETkLU9hu4hGDNvF7NlOexy23daUbD96MlnQvnB3XSQkEoO7R06ijQTcRZLhCBinsk1/l/OmpMCVf3DG9tHdDRZmNsScHSPHUZmfNw82b64mXVlJZ18/3b0+avftc1ZQFoIxVM6qo3JWHfPWAdYS6+h1wve+PjrbBuhqj9PVH2DPkUr6O+PQ0wVJ53e4fQdseRl++eRRZta9wdzTI9QtmU5Nc4TqpgjVzRVUNVdS1VSBz68ULiIibw0K20U02LNdoh0kU05A9SxsAwQC+Vu2exS2w8HChO2qKpxVkqEwvVH336KvD2prJ3XeoaJR6OkBurrwGetMIZm+YFznCIVg5kw4eHgG7NrFvqMRVu3ZU7iwPZQxhJtqmN1Uw+wLnUNb30zy6vM9TO/fSV93F31+y0DSR279O5X2ceB4JcdfS7CobRuVcxvz3lQYn6GiLkT1tBBV08JUN0WonOZ8VEyrwB9QEBcRkVOHwnYR5VW2Mwsk0+mCt1uMZFgbSQFDMAzZst2jSSvZKRrxOOFKN2xPso0kO/6vooK+bvcJensLHraPHnW/6OpiWk3CKZyfYLb2ycyfDwf3TYO9e9nXXsGKue34jh4dtvukF958E3ZstlR27KeyMYW/uYoF0/tprIrR76/hwJEA27ZaOg4MMNCbpj8Z5M2D9SweaKd+fm12MadNW/qPO60o7OjJfxID4aoglXVBKutDVNaHqGiIUNkQpqI+TKQ+ov5wERGZUhS2iyi3mJzM/dEXuN1iJEVZIAn5le0Ch+1YDOfNSSrlTCIxZlL9yuA8PBiERCRCqtMQjfuIeNC3feQIMNAP8TjN02POkzY0jPs8TU1QUe1noLGRxJEjtB2PMGfPHs/D9vbtsGNzAjZvhoEBplXHOW9xF5El82DFCggGWQSss7Bre4pNzx4itn0vA91Jov3NhJLHqPOl6Is00t9/kieyEOtNEOtNcPzAyHcMhP1EqgNEaoLO59oQkZogFfVhwjUhInXOZ7WqiIhIOfA0bBtjwsAXgRuBBuB14P+z1j4zhsfOAf4OeBfgA34B/Jm1dpd3V+yt3Hybwj9Y0C522Pa4sh2PeVjZds8ZCaWdqnYB/iJQXQ3H3TaH3mig4GHbWrey3dkFQHNdHJqaJ3TtxjjV7S0d0+HIEfa2VzDn0CFPd75sa4NNb6Rh2zYYGGBmQ5TzFnfjO/dsmDt32PUtWuKneeYcXnqukWDLdmr7+4kzh+lze1h0rp/0ytX0tffTe6Sfvo4ovcfiDHTF6e9KMNCXyhtFOJJkLEVvLEVvR+yk9wuEfIQqA4Qq/ISrnM+hqiAEg6QDQUJhQzgEVfUBaqZXEqwOK6CLiEjBeV3Zfhi4Fvg6sB24GfipMeYSa+1vTvQgY0w18CxQA9wHJIE/A35pjDnbWnvc28v2hjFOdTuZJLtIMhiwnvdtp1LuFI9UCp+xzhSPYvRse1HZTuSM/Ztkv3ZGVRUcjwxOJGkqcNju6XGvvauLUCBNbWVyQi0kGfPmwdatldjqao5299I/YKjctw8WLy7cRbuiUXj9dWDfPujtpbEmznmnd+E779yTbsZTUwPrLovwcs1Kjr+yE44d4429NVjbyemJV6lZs4aa+cMr+zaZInp8gP6OAfqPRZ12k84Y/V1Jor1Jon0p0umxXXsyniYZj9N51NDRHaKrM01fZ4JUNOlOyxk8kd9YKiJp6uugqdnQMDtCaFoNwYoAwYg/+xEI+QiE/c5HJEAg7Mcf9hMIB/KOGZ9Cu4iIODwL28aYC4AP4VSjv+4e+y6wEfgK8PaTPPxPgMXAedbaV93H/tR97J8Bn/fqur1WirA94lbtBQ7b2W6OQGBw8ae702OhDNs9skBhu7qa7Ll6PRj/19GB846np4emhrhT0J5E2K6ogOZmODJ9OvT2sre9guWZhZIF7v1vbYXEoQ44fJjKcIrzl3TiW71y1F0vwSm0v22tj9/5TufYa0E4fJg399VgbQ+Lk7+FCy8c9hcWE/BT0VxNRXM1I+7jaS3xnhjRzijR7rjzuSfhfN2bJNqTIDaQJjaQors/QNvREF1HE9jebkid+L+zlDX0DvjpHYD9hyD4xgCNVZ00NkFVU6Wz8dA4fra+gM8J5kHjfA758AcM/uDgZ1/Al/3eF/Q7Xwd9zteZ+wT9+ENOeLfGeRPrM9YJ/xUBfEE/Pr/BF1Afu4hIufKysn0dkAC+nTlgrY0aY/4ZuM8YM8ta23aSx/42E7Tdx242xjwD/HemeNgGirqxzYhbtRc4bPt87tbnfj9pa5zpeZ5UtnN2jyxQ20RVFU7o8/vpiwacYByNFizMd3TgTDix7hSS6upJn3vBAjjS1gB+P/vaIyybcxRz9KiTwgvk4EE4tDcOu3cDcNZp3QTnzRzX9JNAAC58m+El3wI6WoOwfz+b9teQtr0sTb0Ib3vb+P4djSFUGyFUG+FES1h7emDja0kSrx5gvm0jUZkkmbAk4z4ScWcXVZ9NkkpCIu2nL+ojFnOyeGaqSiLt51BPJYd6ILIvSVN1O43TfYQbqsY0rjGdTBNPphnv281YwkdvH/R1pejvTRGPQSKWJpVwF1Lb/LK+3wcBf5pwyBIKGyIVhooKiFT4qKj2E6n2E4gE8YWDGJ9xg7nB5zMYAz6/89n4fc5nn8Hncz7nfRjnDUTmPkM/fH6DxfmDQTKeJp1Mk/0ThLXYlMUY67yx8Bn8IV/2sz/zxiTsxxf0g9+fPa/7Tw7GDH72meHHcm7Le0zme98I9xn6OfdcIiIF5GXYPgfYbK0dWiZ8CTDA2cCwsG2M8QFnAg+OcM6XgMuNMZXW2pMtsypbg2Hb504kSRUvbCeTnoVtcKrb0ZyNbQodtp2ebefFFLyyDVBRQe+A2wfc01Ow8x87hjNfG5hWk4DGiVe1M6ZPh3Cln1hzE9FDhznSGWLG7t0FC9vxOGzcCOzaBakUC5r7aZoVHPeOleAG7gvhJTObo34f7NnLlgPVpG0fy1MvwEUXTXonUHB+z7duhZ0vd2D37iMQjxOo9BGpDNFUG2fOjCRNSxqoXDjdmYyS85zRAcux/f0c2trNgU3d9B/qItUfJ5mwpFJ+kokQR/uhNhWlqa6X+lkVUFtDyh9221Xcj4QllUyP2ncOkExBX7+P3u40fT1penvSJKOpk1bgh0qlnVGLsQTQl3uLxem+SxL09RMOOoE8HDaEwxCu8BGKGPxBP76QE3KNz+cMR8LJ9Wn3f5qSSUgm0iQTuG9a0iSS7tcJ697uLgmxY+zxOQGDU7nPtLv5/YNv5H0+55jP775pcO9jfD4sBmsMFgNpS9o6U2+sNdi0JW2N85rSFtzP2dtwP6edH1va5r+vybzBwDm7G8rBZwb/2GHM4Ac412uMxRj3cW6IzxzL3M/iXrMxbq8fzuvIvOuzmfvk/oTcm3Lnbeb+up3o+Al/5jb7GnIfa/JOlHPc5B8fer8TPqUZ0+Wc1ImuqZDsBK5y6M+kZMr+jaK3F7hy5jEuW7bf+WW+/XZPn2u8vAzbs4ADIxzPBOwTbZ03DQgzQhB3jxn33Dsme4GlMDhruwSV7XTamUSSdyGFEwxC1F0FGk/6iBQwbCeT7v8zj8edP6MHbEF7tgGIROjv85NOg6+vryDBtbfXrcj39BD0p6mpSBZkcojP5/Rub++cDocOs/doBTMOHy5YRf6NNyB24Ch0dREJplgxrxfOXjvh3xu/Hy64AF42M2n3B2DXTrYdrCKd7mNl+gWnwp191zN+Bw7Amy/3Ed2yJ9sGZIxlbmOUxYuhevVCZzHnCabwRCoMs5dUMXtJFedcNYujR2H/ph7a3jhGqv1YzvqDCmLA0QFLUzDKzJkJpi2spWbBNHwNdU67CZCKp0hGkySjSVKxJAN9aY4ditN1aIDOQwMcPxSj91iC9EA/pCwVPgjXQLoK0ilD2kI6ZbFugThtcWOZJZ02pKwhmXRCYiYcn0gi7ScR89MbA3qG3joYysuBxWnpSVkDaUa5rKEJc6Qfgh3yeay35dzLuaiT3mdkZsjnoV9nnrtMgpq49O/hHW9/tl2+GExr93yU8kR4GbYrgJHGBURzbj/R45jIY40xtwK3AsyfP39sV1lkJW0jSXvXRgJDtmxPmoIukMxuaBOPD+4eWaA2Er/fyafRSARrDQNxP1UF6ts+dgwnLfX2Mq0u4fxvQOOI3cjjNn8+bN9eATU1HO60xOKG8L59sGTJpM575Ajs35WAPXsAOHNhN8ElC2HatEmdNxO4N/iaOOz3w/bt7DhURTQR5az4C/gvXDPun01PD2x8NcHR1/ZDe3v2eGNNnDOWRKk5b6nzrmQc/+NrjPM+q7m5hjMvrqHt4Hz2v9HF0W3HsB3HIZUilTYc7gxzuBPY3I8xfVSGdhMOQ7AyCIEAKfzEY5aBAUgMJLPTgACqQ1A9EyD/jVHQn6a+JkX9zAj1c6qobKok0lBBqL7S+dNRIJD3WhJx6/Ssd8Xo63AWlPYei9F3PMFAd4L+7gTpaBybSGGtU81Np50Qb3Gqt85xC5hsdTcvxLvVXmzmvpmvcz+cinHAlyIQMBh/pl3D4LaaY93zp1OQtoZ0Ku1O8nTazlIpi01nnsyt6Oa+i7CDbyrcp8u/jcHbMsdOeF+bd5fB+57410JEZMK8DNsDOBXqoSI5t5/ocUzksdbaB3HbT9asWVOW/7tZ0rCdTBEIFilsp3wFXSCZDdvJZMF2j8xVXQ3RzPi/gcKF7Y4OnEprbr92AXvNGxuhY/p0bE8P+9ojLN6zx5lKMsF39skktLTg9GmnUsxpjDJjth+WLy/INft8sGYNvGIaOORbCtu2caAjQl+Ln3P7X6LqzNOd6/edfMFfIgFbNqXZ/dIR7P4D2SAbDqZZtaCXOWtmwdKlkx5x6ffD3HmGufPqib6jngP70uxr7aRndwd0dg7+6d8a+mIB+mJAt8VZrnLyN5s+Y6mtTFI/PUTDnErq51ZTNaceU1sz6uvPCIYMwcYQNY0hmhfVDLs9nXb+2NHfncxuJDTQGaO/y1lUmuyPk47GScVTzihSLD7STgtH0EcwZJxZ9BF/dnRiqDLgfFQFBz+qQwQqgphQcFJVJXeMPqlEmlQ8NfiRSA8eS7jtOu7XpNMYm8akU04Pek4fuS/gyx7zBf1OG0rAN/jh3sf4fXnHjd/nvFmwzhsApyXF6cW3mTcjOcdtKo113zzkHXPvk07ZvK8z71IMzjGDzWtDMT7jHnPe9DhvW2z2Nhh8w+C0f9hsv3nm33GYnH8Xa3NaVXL+uXLbn/Le5ww53dBWC+e92vB/d3uSxo8T/TXGjvanmsny8tyFUO7XB2V7jTXVi6Hu4lJfxoi8DNttOO0eQ2WOHTzB447hVLVP9FjLyC0mU0LJF0hGpmZlO3f3yEiNWyEs4Fzpqio46obtvljA3Vt98jo6yJ6rsSYOjaNP8RiP+fOho70BAgH2tldw+qwOzKFDMGuk/3xGt2kTDBw4BsePEwqkWT2/G866sKC/Lz4fnHcevBGpY7d/OWzdSmcf/LJlGks79nPa3oMEVi1z9qYf8v/AEwnYtSXOzpeOkth/OPs7ZozltBn9LD27iuBZk2tJOZFIBE5f4uP0JdPo65tG++E0R3d207Wvm/6j/Tgl7JF/533GUl0N9dN81M6ooH5uNXVza5zWEw/+W8w+r8/pbKmsDMDMAFB1wvsWYSPbUWX6s4NBH1T6AG/3HxARKQYvw/ZrwB3GmOohiyQvdD+/PtKDrLVpY0wrsGaEmy8Etk3VxZGQu/mLj2RmHnVRp5F427Od6YlNpHzZySGFEI3ilL0ylW1jChq2q6tx/kxvnMo20X7nBzeJn9PAgPNBdzd+n1PFLFQLScasWbAx7CMxfTp9Bw9yuDPMzO3bJxS2jx2D3dsG20dWL+ghdPq8gk44yfD54IwzoKammo3h1djtO0j39LB5fzU72tLMenMrjU3biMysx1ZV0zvg5+jhFEf2Rkn39Ob9vb+xJs7qFSlqL1gJM2YU/FpHUlUFVYt8LFxUD9STTLpZuz9BvC+BSSbw2RSBsJ+KKh/h2jAmPLndTr1W6qAtInKq8jJsPw58GrgFZ1ObzI6S64EXrLUH3WPzgUpr7eYhj/2yMeacnDnby4BLgfs9vGbPZddn+fwk46VYIOlxZTsTtpPGeeIClctyN7Qp5O6RGdXVOAkwHKE36r5J6OuDuroJn7Ojg8F+7Zq40xlQ4LDt9zvV7R39M6CtjR1tlcxsOO5sWTmOhZipFLz2GrB3LyQSzKiPOaO0V64s6PUOtXAhTJsW4tVpy+neeggOHiSRgr3tFextBzZFGVyqka8ynGLF4gSzL5jrnGiMrRdeCAScjXyoCaJqrIiI5PIsbFtrf2eM+SHw18aYzPSQjwILcHaSzPgucAn5y7T/Afg48BNjzNdw1qT/OU77yN95dc3FkLut+ak0Zxvc12YM+P35u0iGJl/RG7Z7ZIG3Js9OJKmI0Nvr/uGkt3fyYdudrz2tJuE8SQH7zDMWLYJdu4Kkm5s5duQIx3qCTNu6dVxhe+tW6Nt/HDo6CPgtZyzohjPXTLrneSxqa+EP3m7Yv2gW295opH/3EWeV5gn+u6irTHD6ihCzz5mDmTe3pCFbRERkNF5v134TcI/7uQFoAa6y1r5wsgdZa3uMMe/ACdZ/Bfhwtm//lLW2w8sL9lpuz3aimG0kzpDZwbB9ghFok5G3ZXvSfSNRoLDtzNh2w3YgVfDQWlnpbsoTqSB23EciaQhOsm87d7620689sT7q0UQizlS7vQOzoP0IWw9U8bYaZ9fHsbRVHD8OOzYnspvXrJzXQ8XiOUVryQDnZz9/PsybF6Kzcy6H22bTe7iPWHs3/nScsD9FfaOf6fMjVM2bVvA3WyIiIl7xNGxba6PAZ9yPE93nHSc4vh/4oDdXVjq5YTuV2f+hGGHbndYQ8Nth48MKJbdqn30jEY/nlI0nLhYjO90k20ZSQMY4rSTd7iLJnoEA0yYRtmMxd9xzTw8+Y6mvShS8hSTX6afDvn1hbPN02o8c4UhniOlvvunsfnOSf+tUCl59Feyu3ZBI0FgTZ/48C6tWeXatJ2MMNDRAQ4MPVtYAwydsiIiITCX6+2uR5e4gmUgWsbLtbp0c8KU9m36QLWAPrWwXQF5lu4C7R+aqqSG7KUnPQCBblZ6I3Pna9VUJ5w8JHobt6mqnMsycOeD38+a+GmxPL+zcedLHbdoEfTsOwfHjBPyWsxd1Y846syjtIyIiIm8FCttFVrIdJN0toLOVbQ9kTxsIEE/m9GxPUjrtFrWLEbYjETBu2O7vn/C/zbFjOP3a6bTTr11ZWZAtyU9m2TLwR4IwaxY9AwG2t1XB5s0nHGN44ADseq0L9u0FYNX8HiqXzy9q+4iIiMipTmG7yEo2Z9vtWfEybGcr20MXSE5Sdm+ceJxwMO10RXjQs1tTg9M8HKlwwjZMeN72sWODj51WHfe0qp0RDrubR86cCZWVbD1QxfFuP7z0Us6uQI7jx+G157ph+3awMLMhyvwlYc+nj4iIiLzVKGwXWV7YTue0kXi4I9OIPdseOOECyUnKbmiTSHiye2RGTaY9uLJyUmE7mYSuLrJtKNNqEuOaDDIZixc7G6dw+iLSxs9LW+vpPhqHF15wLwqOtlt++1Qb6U1bIJWiOpLk7BVxZ2tHTfYQEREpKK+nkcgQ2ZxrDEmbMxEklfIsBBcrbPv97kSPQIC0NaRS4C/Alu3ZomwiQaTS3T3Sg7BdWem8hlRFBbEOH/GEITSBvu3jx52tmuntpbYySTBgi1LZBmeB4bnnwq9/XUl88enEt23j129OY/GsPmr3/47D8Xr2Hghk/5oSCqS54IwBgusu9LzNRURE5K1IYbvIcifupUxgcM+XSe5WeDJ5YdvDBZLgVLdjmS3bUz78Bahsx2I4lf/cyrYHbSSZiSRdlYMTSRonELaPHcPp906nnRaSIvRr56qqggsugN/8poGUXUJq5062HMjdvtwJ2uFgmovWJKh6x0XZhaEiIiJSWPqbcZEZk7tI0ud533Y67Q4iSacwxjph3+OwnbeLZKHaSDzcPTJXTQ1QMbmJJLnztafVeDvy70QaGuAP/gBq5jc4fdgN9XnbRjU3w9uvbabm3RcraIuIiHhIle0SCGT+iu8ukgwGrGdhe3D3SG+3as8IBgfPn0j5ChK2c2dshwMpTzc0qa3FOb/fT1d/EBIDMDAw5sp0Ou20keRvZlP8sA3OG4e3vx3a2io4cmQpiYEkFQwwa46PpvmVnr1hERERkUEK2yVQzIkkxdqqPSMvbHtQ2fZq7F9Gdnf2ykq6+tyVmZ2dYw7bXV2QSqShr4/KcMqpxJcobIPTQz9njvPh/OeuTWJERESKSW0kJXDCiSQeKEnYzrSRpHw5c/smLhYjv42kGGG7qoqegYDTgtPZOebHZ/u1UymnX7uiQm0aIiIib2EK2yWgyvb4RKMMtpEEC79Ve65g0M3GVVWkraE3Ghh/2M60kNSWpl9bREREyofCdgkUc4Fk9rTplDOJJO8CCi9b2TZuZTuVym4VP1F5le1gytPKNrjV7WpnekdXX8DpDRnDHHRroaODwcWRRdrMRkRERMqXwnYJlKaynS5eZRvAHyCRmvzGNomEm9UTCQJ+d5pKMcJ2OAyBgLtIMuG0hoyiqwsS0RT09BAOpqmuSDljP0REROQtS2G7BEoSttM5YTt32HeBDYZtP/HE5Ldsz+4eGY87k0jA0zYSyO/b7upz/7HG0Epy9CjQ2wvW0lQbd6rj2ihGRETkLU1huwRO5QWSoRDZ50imJ1/Zzts9MuTdVu258sJ2f9DpIBlr2Ha3RG+qjauqLSIiIgrbpXDKL5CE/Mr2JCaSZHePTHq7e2SucNjN89VVpNLG2dzm2LGTPiadzl8c2VwbU9gWERERhe1SKMkCyVTOAslsIi687KmDQWeBJEy+jSSRAAuRUMopnfu8/7WdNg2orgEDHd1BtyH7xK/j+HFIDcShv5+qcNLpHmlq8vw6RUREpLwpbJdAbvW3qNNIityznUhOvo0kb0ObgLcztnNNm4bzrqiikmO9Iae6fpLqdns7+S0k06Z5+nMWERGRqUFhuwTye7aLELZTKbA4Ydvn87QynA3bgUBBKtvO2D+nDSUS8nbGdq7sxL7aWo71uC/q6NET3v/wYbJhfHp9HGbM8PYCRUREZEpQ2C6B/J7tIiyQdOdcB/zW035tcE5vDOD3k0qb7Ni+iXLCtvOz8Xqr9lw1Ne6PqraGaMJPf8x/wrA9MADdx5LQ3Y3PuJNIZs0qynWKiIhIeVPYLoGiL5BMOSPzihG2YcgukpPcsn3Y7pFFCtvGuK0kNbVgDO1dIWfx48DAsPsePkx245um2jiBabUa+SciIiKAwnZJ5C6QzPY1FyNs+9LFD9uT3LI9FiMbtiPBVNHaSACmT8fpu66t5XCn+7xtbcPu19aG27QNM+pjqmqLiIhIlsJ2CeRWtlPF6tkGgoGpVdlOpdycnkhgjHWuv0iVbXDDNsC0abR3hZwf45CwHY3C0QOx7Mi/mQ0xmDu3aNcoIiIi5U1huwTyKttpd2KFtdne6kJyeradsO33lSBsJ82Ew3Z2Q5t4nHAg7fSCFzFsV1U5m0BSX08aw9HukLMIMqeV5MABslXtpto4kTmNaiERERGRLIXtEsidCJcyAWeHQvCkuu1Utou3QBIKV9kuxe6RQ82YgfOCamo5cMwN0Xv2ZG/ftzsFR44AMLdxAObPL+r1iYiISHlT2C4BY06wSHISvc0jsdbtICniNBI4Qc/2BKr20ShF3z1yqDlz3C9mzKDtWNh5Pbt3QzzO0aPQs/0wJJP4fZZZc3wwc2ZRr09ERETKm8J2iYzYt+32VhdKsbdqzwgGyb6jmMysbWfsn7N7ZDiYLtrukbnq6qC2FqeVJBRh95FK55o2bmTrhm63jwTmNQ0QWL646NcnIiIi5U3JoESKMZFkxK3aixC2QyGyzxXPvLYJtJLk7h4ZCaaK3kKSsWgRzpuH+fPZ0VZJNO7jQEsHHS9sBmsxxrJoaUAtJCIiIjKM98lLRpS/i6QPSHkbtotY2c4L2wn3/dwEwvbw3SMrC3OB4zRnDmzbBn00kJg2g+ffsIMVe2Dh7ARVF5/t7uYjIiIiMkiV7RIpRs92ycN2MEBsEmHb2dDG+ZkUc0OboXw+OOss95uFC4k2zyOFs8q1qrmSZR880x1bIiIiIpJPle0SGTFse9WznU6XqLIdJB5zw3Z2tMjYlUsbCUBjI5x9NrS0GNJz58Ls2VRXpjn/ogBB5WwRERE5AYXtEhkM2z7PtmzPr2y7Pdu5cwc9kh0YEgwST06yjSSe00ZSwrANMG+eE7qPHIFg0MfMmb5i/DhFRERkClPYLpHBBZL+4oTtUIl6ticYtq3NmUYChALpoo/9G0llJSxcWOqrEBERkalCPdslMnyBJKdMz3Yg4E7ACwRIpY3THTPOsJ27e2QokHbOV+LKtoiIiMh4KWyXyIg926fINBJwq9vuc8WT499FMhp1vyjh7pEiIiIik6WwXSKn8gJJGCFsj3OBZCxGdvfISND9uZRBG4mIiIjIeChsl0jRF0gWcVMbcMN2MAhMorJd4t0jRURERCZL6aVE3BzqLJBMezhn29r8ynaRxmdMto0kd3FkOUwiEREREZkIT8O2MabeGPOgMabdGNNnjPmFMebsMT72XcaYfzbGtBpjUsaY3V5ea7FlM6/fTzKzG6EXlW23NSUYsE74LdIuh+Ewzos0xtnYJp0e1+tzKttOQA8HUmohERERkSnJs7BtjPEB/wF8CPgGcCcwA/ilMeb0MZziw+5HD3DAq+sslWxl2+ue7bTTPuL32aK1kEDuLpITm7Wdu3ukKtsiIiIyVXlZ2b4OWAvcZK39orX2W8A7AAvcNYbHfxaotdauBX7v2VWWSNGmkbgBPuAvUdgOBIgn3Nc3jrBdbhvaiIiIiEyE12H7IPCjzAFrbTvwGHCNMSZ4oge69z1orS1sE3MZGdzUxuMFkpk2En+6dGF7opVtt2c7HFTYFhERkanJy7B9DvCKtdYOOf4SUAMs9vC5y96Im9qkUs6CxgLJbSMpWWU7t41kjOP/hu4eGQmmFLZFRERkSvIybM8C2kY4njk228PnLnu5Q0GSBAYzdgGr27mV7bLo2R5j2I7H3fcc8ThBv7t7pBZIioiIyBQ0pvTlLnYMjXpHwFqb2fuvAhgpXeXeXlDGmFuBWwHmz59f6NMXlDFO9k0mAZ+PVNo41edkMmf15MRZO0LPdpHG/kF+2I4lxhe2s3fT7pEiIiIyxY21sv12YGAsH8aYJvcxA8BI5chIzu0FZa190Fq7xlq7prm5udCnLzgvF0lmB5ukUvh91pn4V6LKdiJlnEr1GMN2NIrT/pJIOP3axihsi4iIyJQ01vS1GVg/xvv2uJ/bcFpJhsocOzjG852yvAzbebtHFnmrdnA2ewwGIREMYq0hkTSEotHRH0j+4shI0J2xXaT54CIiIiKFNKb0Za09BDw8znO/Bqw1xpghiyQvBHqB7eM83yknN2wnUj4gVfiwnU4PbtVegPaU8QiFnLANzi6SofFUtt37RkJpqCh4x5GIiIhIUXi5QPJxnEWQ788ccFtMPgj8KHesnzHm9DFudHNKGQzbhR//N2Jlu4g92+CuaXTDdjThH18bSWbGdjClsC0iIiJTlpd9BY8DvwW+a4z5KnAU+BOcgH/3kPs+435emDlgjDkTeJ/77VKgzhjzOff756y1z3lz2cUzOGvbTyp9arWRgNtmHQiAwVkkmYg6vdi+k7/HGxggG7YrwpqxLSIiIlOXZ+nLWpsyxlwF/A3wP3Gmj7yEs6PkWFpIzgXuGXIs8/0XgFMnbPv9JJKnXtgOh3HHrgyZSDJKpVqVbRERETlVeJq+rLXHgVvcj5Pdb+EIxx5m/H3iU0o2+wYC3raRBEsYtmH4+L9RwvOwyrbCtoiIiExRXvZsyyjytmzP7CLp5QLJEobtaNx9faNMJEml3EEk8Tg+YwkFFLZFRERk6lLYLqGiL5AsRc825Fe23Yr1iWSzeDxOJJR2Jv6pZ1tERESmKIXtEspdIOll2A4GStxGEgoRS7qTUEapbA8M4JS3k0mnX9sYbdUuIiIiU5bCdgkVq2fb7yt1z3ZgsLI9lrDtbmiTnUSiDW1ERERkilLYLqHsHjM+H0mvRv+lS9dGkt2yPRQmlvA5W7aPErY1iUREREROJQrbJZTdY8bvJ5nyYIFkOg0WZ4GkzzfqfOtC8/ncwO2+q4glfG7p+sQGBshuflMRUtgWERGRqU1hu4Q8XyCZSgE4PdtFrmpnhMNk+0nGErbzKtvaql1ERESmOIXtEsq2kfg96tlOOyP//L7She3BXSSNu4tkIvsmYCTDKtuVlcW5UBEREREPKGyXUN6cbQ8r2wF/iSvbxkAoRDQx+kSSaJRs2I6E0grbIiIiMqUpbJdQ7nbthd7UJpFgsI3Eny5Z2M52gQSDDMTc13iCVpJUyu0giUYxxhIOKmyLiIjI1KawXULZBZLGkLR+Z1oHFCRwD6tsZ5+suLJhOxxmIH7yynZ/P07rSyJBRWZDG/Vsi4iIyBSmsF1CxuRXt1MFGv9nbfm0keTuIpndsv0Ele3+frKLIyvD7iSSIk9QERERESkkJZkS86JvO7v+MJ3G77NOhbjUbSTh0Ngq226/dmVYiyNFRERk6lPYLrG8vu0Che3c3SNLtaFNxmDPdk7YPlllW2FbRERETiEK2yXmedj2pYc8UXEFg267eDhMKm1IJA309Y143/5+slVvhW0RERE5FShsl5gXE0lyw3YwUNrKNrjVbXdjm4G430nV2dWgg5zKdk7Yrqoq4lWKiIiIFJ7Cdol5UdlOJNwvyqCNBNywHQhAIOCM/0unR+zb7u8HBhS2RURE5NShsF1iXiyQzD48nSbgd9tIsttVFl+2bzsSGezbHtJKkkhAMp6GWBS/z52xXV1d3AsVERERKTCF7RLLrWwnkl70bJe+sp0d/5c7a7u/P+8+2cWRNmfsXwmvWURERKQQFLZLzNOe7WSyLHq2s90gkQh90ZEr2729ZFtLqiJJVbVFRETklKCwXWKeTiNJpwd7tkvYRpIXtmPuCx4pbLsjAasjKYVtEREROSUobJfYiGE7u8JxYvIWSJZ49B/khO1w+ISV7Z4ecsJ2EmpqineBIiIiIh5R2C6xbAYOBApf2U4my2IaSSjkFtbdWdvRuM8pZeeM/8ttI6muUGVbRERETg0K2yWW37NdmMr2YBtJeYz+A7e6HQxCMOhUt9PpbHXbWujrSWcXTaqyLSIiIqcKhe0Sy28jKeACyVQKLE7Y9vmcjxLKFqorKgb7tru7ASdjp/ujYC2RYIpgTcQph4uIiIhMcQrbJeZFz3YyiVM5BoL+dEkXR2Zk+7arqugdcPu23bDd20u2yl1dkYL6+qJfn4iIiIgXFLZLLJuDC72DpHuOgN+WvIUEcsJ2ZSV9MTdsd3UBbubOhO1IEurqin+BIiIiIh5Q2C4xzyrbqZRz/jIJ29kW7KoquvrcdxjHj4O1Tubu6QGgriqpyraIiIicMhS2Syx3u/ZE2q34WpsNyxMxLGyXQRtJdbXbNh6JMGAjxBPGeVPR3U1Xezw79q++JgXTppX2YkVEREQKRGG7xPx+MG5BO+ULDk7Dm0QrSV7Y9qXLorLt80FtrftNTQ1d/c4bgHhbB/2HnN5tn7FUz6pxfigiIiIipwCF7RIzJr+6PdlWknTaXRuZSmGMdXJrGVS2IacVu7aWrj7nRR/fcgQ6OpzDlUl8M5pLdHUiIiIihaewXQZyN7ZJTHL8X/ZhqRQBX3nM2M7ItmI3NNDRFwHg6P6B7ELJxpo4zJlTmosTERER8YDCdhnInUiSSE6usp27VXswUF5hu6nJ/SIYpMM/nXQa2rvC2dubT6uGysrSXJyIiIiIBxS2y0Ahx/9l11WmcnaPLJM2ksrKwRGAqZlz2NNeSc+A80bA54Np559ewqsTERERKTyF7TKQV9nOtJEUoLId8Dkb25RLZRtg+nT3i8pKNobPhYoKqKhg+tsW4W/WFBIRERE5tZRPCnsLG+zZzmkjKUTPtr+82kgAFiyAXbvcb+obnA9gwXmluyYRERERr6iyXQaylW3f5CvbuWE727NdJm0k4GxuM2NG/rG6OmjWEBIRERE5BSlsl4HcaSST7dnODdv+MptGknHWWdDY6HxdVwdr1gzOGhcRERE5lZRXCnuLyuvZjhdwGom//Hq2AcJhWLvWmQfu09s9EREROYV5GnWMMfXGmAeNMe3GmD5jzC+MMWeP4XE+Y8x6Y8yPjTH73MduNMZ81hgTHu3xU03+NJICztkus2kkQyloi4iIyKnOs7hjjPEB/wF8CPgGcCcwA/ilMWa0GW+VwHeAJuB/A58CXgLucc95SskWngswZ7vcF0iKiIiIvJV4mcKuA9YCH7DW/iuAMeYxYCtwF3DTSR4bBy621r6Yc+whY8xu4AvGmHdYa3/pxUWXQiHnbCtsi4iIiJQPL/+Qfx1wEPhR5oC1th14DLjGGHPC3gZrbXxI0M54yv28opAXWmp5le1CTCNxd7YJ+tPg92v1oYiIiEiJeBm2zwFesdbaIcdfAmqAxRM450z389HJXFi5GXG79slUtt2wHfDbsu3XFhEREXkr8DJszwLaRjieOTZ7Aue8E+gCfj7SjcaYW40xG4wxG9rb2ydw+tLIayNJF2AHyZQT1AN+qxYSERERkRIaUxJzFzuGxnJfa23U/bICiI1wl9zbx8wY81ngMuAT1tquEzz3g8CDAGvWrBlaUS9bI7aRpNMTmo3nVLadkX8BX1phW0RERKSExprk3g4MjOXDGNPkPmYAGGlMXyTn9jExxlwP3Av8kxuoTyl+/2CmTvsCpN3x2BOpbjuVbbdnO6A2EhEREZFSGmvZczOwfoz37XE/t+G0kgyVOXZwLCczxlwOfBf4MfCnY7yGKScQgHicbHU77Es7Zerw+MaKJxJk+72DflW2RUREREppTEnMWnsIeHic534NWGuMMUMWSV4I9ALbRzuBMeZCnAkkLwMfstamxnkNU0YwmBO2k4ZwkHEvksx0npBOY4zF70dhW0RERKSEvFwg+TjOIsj3Zw64LSYfBH5krU3kHD996EY3xpgVOBvY7AauttaOue1kKhpx1vY420jyt2ov790jRURERN4KvCx7Pg78FviuMearOOP6/gQn4N895L7PuJ8XAhhjaoD/BBqAvwHeY/JnRbdYa1u8uvBSyBagAzmLJMdZ2c7ePZl0WkjyTiwiIiIixeZZErPWpowxV+GE5f+JM33kJeAma+1oLSSNwDz36/tHuP0LwCkVtrMFaN/Et2zP3j2t3SNFREREyoGnScxaexy4xf042f0WDvl+N/CW2vYwG7YDgQnP2h5sI0k7k0jyTiwiIiIixeZlz7aMQ96s7QnuIpkN27ltJArbIiIiIiWjsF0m8rZsT02ssp3N5qnUYGVbbSQiIiIiJaOwXSYGF0gGJj+NJJkkkKlsh8a08aeIiIiIeEBhu0zkVbYnu0Ayd/SfKtsiIiIiJaOwXSbyF0hOLGyPOPpPlW0RERGRklHYLhO5bSSJ5CSmkVgLKY3+ExERESkHCttlYsQFkvH4uM6RSAApZ0f7YMA6Qdu8pSYoioiIiJQVhe0ykddGMpkFkpmw7U9r7J+IiIhIiSlsl4m8OduZynYqBen0mM+RTJJt3A4GrMK2iIiISIkpbJeJ3FycIIi1mW/GXt3OrWwH/ArbIiIiIqWmsF0mjMnv255IK0kiwWBlW20kIiIiIiWnsF1Gcvu24+OcSGKtm7NV2RYREREpGwrbZWQyG9vkztgO+K0zhERhW0RERKSkFLbLSHb/mQlUtvN3j3QXVSpsi4iIiJSUwnYZmcys7bzdIwN2yAlFREREpBQUtstINhsHg+NuI8mtbAd8qmyLiIiIlAOF7TKSbSPx+yfeRqLKtoiIiEjZUNguI7nTSBLjHP2XbSNRz7aIiIhI2VDYLiP500jGV9nOtna700jyTygiIiIipaCwXUYKNY0kFFBlW0RERKQcKGyXkcnM2VbPtoiIiEj5UdguIyNWtsc4+i8eB9JpsNapbPt84Pd7cp0iIiIiMjYK22VkxDnb46lsu1u1B/1pCAQKf4EiIiIiMi4K22VkxLCdSjkV61HE42RHkoSCVi0kIiIiImVAYbuM+P1O9wfGkPYFMoXqMVW3EwmyYTvoTytsi4iIiJQBhe0yM9GNbeJxIOVWtgPpnBOJiIiISKkobJeZvC3bU2NbJGmtm8cTbmU7YBW2RURERMqAwnaZydtFMjP+b5Swnd090t3QxhgUtkVERETKgMJ2mZnI+L/c3SOzG9oobIuIiIiUnMJ2mcmrbI+xjSRvQxu/wraIiIhIuVDYLjMTaSMZDNsJbdUuIiIiUkYUtstMtiAdDE6gjSQ1uFW7KtsiIiIiJaewXWYm0rOtNhIRERGR8qSwXWbyw/bY2kjyFkgGVdkWERERKRcK22UmHHa/CASIJfzO1+Po2VZlW0RERKR8KGyXmbzKdmIcle1UCqy7e2R233cRERERKSUlsjKTF7ZTbmU7kYB0+oSPicfJ7myjrdpFREREyofCdpkJBnF2gDSGBMHBjJ3tFRkuFhu8PRTUVu0iIiIi5cLTsG2MqTfGPGiMaTfG9BljfmGMOXuMj73DGPOC+9ioMWabMebrxpgmL6+51IzJn7U9lokkuZXtcFCVbREREZFyEfDqxMYYH/AfwBnAV4EO4E+AXxpjzrPW7hjlFOcCbwCPA93AMuBW4N3GmHOstQNeXXuphcNugHbDdiSUPmnYjsVQG4mIiIhIGfIsbAPXAWuBD1hr/xXAGPMYsBW4C7jpZA+21n506DFjzG+BJ4D34ITwU9LgxjajV7aTSbedO5nEZywBv9pIRERERMqFl20k1wEHgR9lDlhr24HHgGuMMRPZT3yP+7l+0ldXxgYXSQaJJdx/olhsxPtmM3gi4bSQQM78QBEREREpJS/D9jnAK9ZaO+T4S0ANsHgsJzHGNBljZhpj1gEPAEngVwW90jKTzcrB4OD4vzGE7VBAYVtERESknHjZRjIL+MUIx9vcz7OBTSc7gTGmGmjPObQf+CNr7baCXGGZGmwjCRLPVLaj0RHvm83gCtsiIiIiZWdMYdtd7DimRmBrbSYVVgAjlWNzbx/NAHA5EAHOAq4Fak9ynbfiLKJk/vz5Y7ncspQbtmP942gjqVDYFhERESknY61svx14dix3NMY0W2uP4gTlkVJfxP086jQRa20KeNr99t+NMU8DvzXGHLHW/vsI938QeBBgzZo1Q9tXpoy8ynZy7GE7VKuwLSIiIlJOxhq2NwPrx3jfHvdzG04ryVCZYwfHeL4sa+3vjDH7gBuAYWH7VJHNyqHQqAskYzHAWkgmCKuNRERERKSsjClsW2sPAQ+P89yvAWuNMWbIIskLgV5g+zjPlxEB6ib42Ckhkqn9BwJjm0aSTIJ1d48MBsGnjUFFREREyoGXqexxnEWQ788ccHd//CDwI2ttIuf46caY03O+jxhjaoae0BjzfqAZeMXD6y65bGHa7yeadntK0ukRt2x3NrRxt2rXhjYiIiIiZcXLaSSPA78FvmuM+SpwFGcHSR9w95D7PuN+Xuh+ngm8aoz5fzgTSxLAecCNOLO2/97D6y65THE6nYaUL0gyZZzNamKxnL3cHfE4kMjZql0tJCIiIiJlw7Owba1NGWOuAv4G+J8400deAm6y1o7WQtIBfB94J05/dgjYB/wjcK+7APOUFolAfz8QDBKN+6iuSDnj/6qr8+4Xi5GteIcC6ZweFBEREREpNS8r21hrjwO3uB8nu9/CId/3ALd5d2XlLzdsxxJu2B7St22tO37bDduRYEqVbREREZEyopV0ZSp3Ikk04Xe+HhK243EncJNIEPSn8ftR2BYREREpIwrbZSrbDeK2kQDDdpHMfptIEAlp7J+IiIhIuVHYLlPZzOy2kQAnDtvxuNNCAurZFhERESkjCttlKpuZw+HBNpL+/rz75IXtTGVbYVtERESkbChsl6m8sJ1pIxnI3+F+xLBdUVGU6xMRERGR0Slsl6kTtpGk09n7RKM4u0em004bid8/bA63iIiIiJSOwnaZyla2fT6i5LSG5PRtR6O4u9rgVLZV1RYREREpKwrbZSoUcgrVAMlAhETSON/ktJLkhe1gSmFbREREpMwobJexbHYOhRiIu8n7RGE7pN0jRURERMqNwnYZyw3b/bH8iSTptJuzo1GMsYSDaaisLMl1ioiIiMjIFLbLWDY7h8MMxPInkmQL3LEYkWAaY4CqqmJfooiIiIichMJ2GctWtsMh+oe0kWRHbsdiVIbdDW1U2RYREREpKwrbZWywsh1hINNG0tsLQF+fe1s0Ohi2VdkWERERKSsK22Ust42kLxZwvh4YgGTSqWwnEpBOO2E7GHRGmIiIiIhI2VDYLmPZQrXPRx9VWOt+39fnhG135nZVJKUWEhEREZEypLBdxkKhwQ0hU+GKwW3be3udsO02bleEUlBTU5qLFBEREZETUtguc9XV7heRCnqjTiuJ7e5xWrfdsF0dSUJtbWkuUEREREROSGG7zGXDdmUlfVFnkWT/oW5SKaC/n3AwTShoFbZFREREypDCdpnLhu3qanoGnMp2T1uvs6vNwAA1FUnn9rq60lygiIiIiJyQwnaZy2bocJjOuLMIsqcH6OiAdNoJ2xUVmkQiIiIiUoYUtstcbsG621dPOg1dfQHYuxfACdvNzSW6OhERERE5GYXtMhcKDU71S9c10DMQ4FhvCKdpGxqqEwrbIiIiImVKYXsKqK93v2hoYHd7FbGE888W9KepqUorbIuIiIiUKYXtKSCbpQMB9qbnZo831sYxC+YPDuMWERERkbKisD0FzJwJxrjfzJ/vlLoNNC+uhxUrSnhlIiIiInIygVJfgIwuFHKq20eOAIEALF2K32eZfbnRv6CIiIhIGVNle4pYsQL8/sHvly4zmvYnIiIiUuZUF50iamvhkkvgwAFoaNCaSBEREZGpQGF7CqmqgqVLS30VIiIiIjJWaiMREREREfGIwraIiIiIiEcUtkVEREREPKKwLSIiIiLiEYVtERERERGPKGyLiIiIiHhEYVtERERExCMK2yIiIiIiHlHYFhERERHxiKdh2xhTb4x50BjTbozpM8b8whhz9gTO4zfGtBhjrDHmU4W/UhERERGRwvMsbBtjfMB/AB8CvgHcCcwAfmmMOX2cp/sksKiwVygiIiIi4i0vK9vXAWuBm6y1X7TWfgt4B2CBu8Z6EmPMNOCLwF97cZEiIiIiIl7xOmwfBH6UOWCtbQceA64xxgTHeJ57gJ3A9wp+hSIiIiIiHvIybJ8DvGKttUOOvwTUAItHO4Ex5gzgE8Cf41TERURERESmDC/D9iygbYTjmWOzx3COB4B/tdY+X7CrEhEREREpksBY7uQudgyN5b7W2qj7ZQUQG+Euubef7DkzPd8rxvK87mNuBW4FmD9//lgfJiIiIiLiibFWtt8ODIzlwxjT5D5mAAiPcK5Izu0jMsZEgK8Cf2+t3TnGa8Ra+6C1do21dk1zc/NYHyYiIiIi4okxVbaBzcD6Md63x/3chtNKMlTm2MGTnONPgEbg+8aYhe6x/7+9O4+Vs6rDOP59KBSQfdGytIIJIAUMZQ+GmKoQwhKoQhVEFCMRqYossZAIAoJK0ypLgUADCFWiLVWKpJCoQJXFBilcqJCikLJZwJZNClSg/PzjnLGv7525d+bOzJ1p5/kkb+be854798yTM/OeeZfzjs6PW+ayf0bEe7WeYOHChcslPVtnm1tta2B5h/732sD5Ncf5Nc8ZNsf5Ncf5Nc8ZNsf5NW6HWivU//rF1pB0C+k0kNHFiyQlzQCOB7asNViWdBnw3UH+xdiIWNyi5raUpIciYt9Ot2NN5fya4/ya5wyb4/ya4/ya5wyb4/xaq94920MxhzT939HAXIB8islE4LbiQLtyk5uIeDoXXQ/MLz3fR4BrgRuA24EX2td0MzMzM7PmtXuwvQCYKWka6XDEJNJ54heU6t6VH3cEiIhFwKJihcLpJIsiYm47GmxmZmZm1kptG2xHxCpJhwNTgdNIs488SLqj5FPt+r9dYkanG7CGc37NcX7Nc4bNcX7NcX7Nc4bNcX4t1LZzts3MzMzMel07b2pjZmZmZtbTPNg2MzMzM2sTD7ZbRNL6kqZIWirpHUkLJH220+3qNpL2k3SVpCckvSXpOUm/lrRTlbqflHSfpLclvSTpckkf6kS7u5mkyZJCUl+Vdc6witwP50l6TdIKSY9KOqlU5yhJD0tamfvp+ZLaeVH5GkPSzpJmSXohv4+fkHSOpPVL9Xq6/0naVtIlku6R9GZ+n46vUbeu/iZpc0kzJC3L2d8taVybX0rH1JOhpK0kfU/SvTmX1yX9RdLEGs/ZMxk20gcLf7NDfs9GtVx6Kb9W8WC7dW4EzgB+SZoj/APgTkkHdrJRXehs4PPAH0k5zQDGA49IGluplN+4d5HuOHomcB1wCjBreJvb3SRtA5wLvFVl3TicYT+SDgPuB9YDzgPOIvXHMaU6c4FXge/kn38AXDq8re0+krYnXex+AHAl6XNvIfATUh+r1BuH+9/HSZ95o4HHalWqt79JWgeYBxwHTAcmA6OA+ZUpdNdC9WR4IPAj4BXgYuD7pLtUz5Z0XrFiD2ZYVx8smUYaw/TTg/m1RkR4aXIB9gcCOL1QtgHwFPDnTrevmxbSjY5Glsp2BlYCNxbK7iDNpb5xoezknPNnOv06umUhfcm7mzQvfV9pnTPsn9dmwMvA5YPUe5w0gBxRKLsYWAXs3OnX0eEMz859aPdS+RzgPWC9/HvP9z9gE2Cr/POE/NrHV6lXV38DvpCfY0Kh7MPAa8DMTr/eTmUIfAzYoVQm0pe9t4ENezXDevtgof544D+5/wUwrrS+p/Jr1eI9261xLGkj87+9OhGxknRznoMkVbttfU+KiAci4t1S2T9IG5uxAJI2BQ4hvXFXFKrOBFaQ3uw9T9L+wJdJew3L65xhdV8CNiftNUTSJpJUrCBpN2A34NqIWFVYdTXpaOAxw9PUrrVpfny5VP4S6XNwlftfEhFvRsQrA9VpsL8dCywFbiv8j2XAbGCCpPVa1fZuUU+GEbEkIp4tlQXpCMGG5Ht4ZD2VYT35VUgaAVxOOmJVa4rmnsqvVTzYbo29gMWljQqkQ60Cxg17i9YgebAzinTjI4BPkOaAf6hYLw/S+0h597Sc2XTgpojoq1LFGVZ3MLAYOFzS88C/gVfzOY0jcp1KNuXslpL21PZqdhV/yo/XS9pT0hhJJwAnAVMi4gPc/xrRSH/bC1iYB5JFD5L2YPa79qXHbZMflxfKnGFtpwDbAxcNUMf5DYEH262xLfBilfJK2XbD2JY10QmkN/js/HvlSECtTJ0nfIW0N+zcGuudYXU7kc7NvjEvxwC3kk6N+Gmu4+wGEBG/J53rfghp4Pwc6VqVKRFxYa7mDOvXSFbe1tRJ0pak05bm5z2vFc6wipzXRcAFEfH6AFWd3xD4yvrW2JB0jlPZysJ6q0LSrsBVwH3AL3JxJa9amfZ0npI2AS4BLomIah964Axr2RjYAjgnIqbkst9K2hiYJOliBs+uZ2bTGMAS0nUCt5IuSjsCuFDSsoi4Bve/RjTS37ytqUO+iO9m0jUap5VWO8Pqfgj8C7hmkHrObwg82G6Nd4D1q5RvUFhvJXkmjXmkCysm5sPPsDqvWpn2ep7nAu8CPxugjjOsrvK6f1UqvxmYSLrY2dkNQNJxwLXALvlUB0hfWNYBpkmahTNsRCNZeVtTn+nAocAJEbGotM4ZlkjaA/gmcFREvD9Idec3BD6NpDVeZPWhwKJK2dIq63qapM2AO0l7Hg6NiJcKqyt7a2tl2rN55ottTycdDRglaUdJO5I+6Ebm37fAGdZSyaV8cV/ld2c3uEmkczbLOfwO2AjYE2fYiEay8rZmEJLOJ/XRyRFR/lINzrCaHwMPA08Utilb53XbSRpTqOv8hsCD7dboA3bNh6KLDsiPjw5vc7qbpA2A24FdgCMj4slSlb8B7wP7lv5uJOli0772t7JrjQJGAlNIh/IrywGk2VyWkM4/dobVLcyP25fKR+fHZazOppzddrleH71tFDCiSnllFoJ1cf9rRF9+rKe/9QH7lGfQIb3/V1B7BomeIOlbwAXApRExrUa1Ppxh2UeB/fj/bcrUvG4e8NdC3T6cX8M82G6NOaQNzcmVAqU7qX0NuL/KHqCelWd8mEW6CcHEiFhQrhMRb5BuMnJi6QvMiaRzbm8ZjrZ2qSXA56osjwPP5J9nOsOaKq/765WCvNE4mXRjoAUR8ThpxpJvFGYoATiVdKOH3wxTW7vV34F9q9zA4njSvNCPuf/Vr8H+Nod0AdrRlQJJW5NOgbotIt5rf4u7k6QvAleQTgk7a4CqzrC/M+i/TZme151JmmmowvkNgfrP3mJDIWk2acL4S4Gnga+Svil+OiLu72DTuoqky0h3jryd1bOPVKyIiLm53t7AA6Q9ZNeR9vCcBdwTEYcPV3vXFJLmA5tHxLhCmTOsQtJNpEHf9aRDp0fkZXJETM11jiSdFnE36cvhHsC3SXMhT+pEu7uFpE+RcllOmo/3VeBI4DDgmog4Nddz/wMkVWYMGkua5/0G0pfm1yPiylynrv6WB+P3AbuT7vK3nHTKxBhgn4hYK/cqDpZhvufAvcAbpCN75QHfHyLi5fxcPZdhPX2wyt+cBPwc2Ks4vWwv5tcSnb6rztqykM6ZnUo6n2klac7Jgzvdrm5bSDMYRI3lmVLdg0i31X6HdE7tFcBGnX4N3bhQ5Q6SzrBmViNJU1w9R7rQdDFwSpV6E4BH8vv5eeBCYN1Ot78bFtKFpHfkz7t3gSeBcyjcATHX6/n+18DnXV39jXRdwXWkQc5bwD3A3p1+nZ3MkLTntVadanec7KkM6+2Dpb+pZDrOfbD5xXu2zczMzMzaxOdsm5mZmZm1iQfbZmZmZmZt4sG2mZmZmVmbeLBtZmZmZtYmHmybmZmZmbWJB9tmZmZmZm3iwbaZmZmZWZt4sG1mZmZm1iYebJuZmZmZtYkH22ZmZmZmbfJfMtn2DMBTghgAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Test plot real part (data was picked in the last cell). Aligning in time\n",
+    "plt.figure(figsize = (12, 8))\n",
+    "plt.plot(timesrd, gw_sxs_bbh_0305rd[:,1], \"r\", alpha=0.3, lw=3, label=r'$Lev6$: real')\n",
+    "plt.plot(timesrd, np.sqrt(gw_sxs_bbh_0305rd[:,1]**2+gw_sxs_bbh_0305rd[:,2]**2), \"r\", alpha=0.3, lw=3, label=r'$Lev5\\,amp$')\n",
+    "plt.plot(timesrd5, gw_sxs_bbh_0305rd5[:,1], \"b\", alpha=0.3, lw=3, label=r'$Lev5: real$')\n",
+    "plt.plot(timesrd5, np.sqrt(gw_sxs_bbh_0305rd5[:,1]**2+gw_sxs_bbh_0305rd5[:,2]**2), \"b\", alpha=0.3, lw=3, label=r'$Lev5\\,amp$')\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#[plt.errorbar(csv_data_fixed[i]['t_shift'], -csv_data_fixed[i]['dlogz'], yerr=csv_data_fixed[i]['dlogz_err'], fmt='o',color=colors[i],label =tags_fixed[i]) for i in range(len(csv_data_fixed))] "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gwnew_re = interpolate.interp1d(timesrd, gw_sxs_bbh_0305rd[:,1], kind = 'cubic')\n",
+    "gwnew_im = interpolate.interp1d(timesrd, gw_sxs_bbh_0305rd[:,2], kind = 'cubic')\n",
+    "\n",
+    "gwnew_re5 = interpolate.interp1d(timesrd5, gw_sxs_bbh_0305rd5[:,1], kind = 'cubic')\n",
+    "gwnew_im5 = interpolate.interp1d(timesrd5, gw_sxs_bbh_0305rd5[:,2], kind = 'cubic')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if timesrd5[-1]>= timesrd[-1]: \n",
+    "    timesrd_final = timesrd\n",
+    "else:\n",
+    "    timesrd_final = timesrd5\n",
+    "\n",
+    "gwdatanew_re = gwnew_re(timesrd_final)\n",
+    "gwdatanew_im = gwnew_im(timesrd_final)\n",
+    "gwdatanew_re5 = gwnew_re5(timesrd_final)\n",
+    "gwdatanew_im5 = gwnew_im5(timesrd_final)\n",
+    "\n",
+    "gwdatanew = gwdatanew_re - 1j*gwdatanew_im\n",
+    "gwdatanew5 = gwdatanew_re5- 1j*gwdatanew_im5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.5557886630104557]\n",
+      "[11.740978066949138]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#taus, corr= twopoint_autocovariance(timesrd,gwdatanew-gwdatanew5)\n",
+    "#plt.figure(figsize = (12, 8))\n",
+    "#plt.plot(taus, corr,'ro')\n",
+    "#plt.show()\n",
+    "#vmax=np.max(corr)\n",
+    "#index = np.argmax(corr == vmax)\n",
+    "#taus[index]\n",
+    "print(w)\n",
+    "print(tau)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "error estimate: 0.20053883528563624\n",
+      "mismatch: 0.02010791222885977\n",
+      "snr: 229.43188441714122\n"
+     ]
+    }
+   ],
+   "source": [
+    "mismatch=1-EasyMatchT(timesrd_final,gwdatanew,gwdatanew5,0,0+90)\n",
+    "error=np.sqrt(2*mismatch)\n",
+    "print('error estimate:',error)\n",
+    "print('mismatch:', mismatch)\n",
+    "print('snr:', EasySNRT(timesrd_final,gwdatanew,gwdatanew,0,0+90)/error**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if error_str and error_val==0:\n",
+    "    error = np.sqrt(gwdatanew*gwdatanew-2*gwdatanew*gwdatanew5+gwdatanew5*gwdatanew5)\n",
+    "    error_est=np.sqrt(error.imag**2+error.real**2)\n",
+    "    plt.figure(figsize = (12, 8))\n",
+    "    plt.plot(timesrd_final, gwdatanew.real, \"r\", alpha=0.3, lw=2, label='Lev6')\n",
+    "    plt.plot(timesrd_final, gwdatanew5.real, \"b\", alpha=0.3, lw=2, label='Lev5')\n",
+    "    plt.plot(timesrd_final, error_est, \"b\", alpha=0.3, lw=2, label='error')\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if parser.has_option('rd-model','phase_alignment'):\n",
+    "    phase_alignment=eval(parser.get('rd-model','phase_alignment'))    \n",
+    "else:\n",
+    "    phase_alignment=False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "error estimate: 0.007733513376553806\n",
+      "mismatch: 2.9903614572668324e-05\n",
+      "snr: 1194.6164108903329\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Phase alignement\n",
+    "if phase_alignment:\n",
+    "    phas = np.angle(gwdatanew)\n",
+    "    phas = np.unwrap(phas)\n",
+    "    phas5 = np.angle(gwdatanew5)\n",
+    "    phas5 = np.unwrap(phas5)\n",
+    "    position = np.argmax(timesrd_final >= (t_align))\n",
+    "    dphase = phas5[position]-phas[position]\n",
+    "    gwdatanew = (gwdatanew_re - 1j*gwdatanew_im)*np.exp(1j*dphase)\n",
+    "    gw_sxs_bbh_0305rd6=gw5_sxs_bbh_0305[position5:-1]\n",
+    "    timesrd=gw_sxs_bbh_0305[position:-1][:,0][:920]\n",
+    "    mismatch=1-EasyMatchT(timesrd_final,gwdatanew,gwdatanew5,0,+90)\n",
+    "    error=np.sqrt(2*mismatch)\n",
+    "    print('error estimate:',error)\n",
+    "    print('mismatch:', mismatch)\n",
+    "    print('snr:', EasySNRT(timesrd_final,gwdatanew,gwdatanew5,0,0+90)/error)\n",
+    "    if error_str:\n",
+    "        error = np.sqrt(gwdatanew*gwdatanew-2*gwdatanew*gwdatanew5+gwdatanew5*gwdatanew5)\n",
+    "        error_est=np.sqrt(error.imag**2+error.real**2)\n",
+    "    else :\n",
+    "        error = 1 \n",
+    "        EasySNRT(timesrd_final,gwdatanew,gwdatanew5/error,0,0+90)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Test the new interpolated data\n",
+    "if error_str and error_val==0:\n",
+    "    plt.figure(figsize = (12, 8))\n",
+    "    plt.plot(timesrd_final, gwdatanew.real, \"r\", alpha=0.3, lw=2, label='Lev6')\n",
+    "    plt.plot(timesrd_final, gwdatanew5.real, \"b\", alpha=0.3, lw=2, label='Lev5')\n",
+    "    plt.plot(timesrd_final, error.real, \"b\", alpha=0.3, lw=2, label='error')\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Test the error data\n",
+    "if error_str and error_val==0:\n",
+    "    plt.figure(figsize = (12, 8))\n",
+    "    plt.plot(timesrd_final, error_est, \"r\", alpha=0.3, lw=2, label='all error')\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Test the error data\n",
+    "if error_str and error_val==0:\n",
+    "    plt.figure(figsize = (12, 8))\n",
+    "    plt.xlim(1,40)\n",
+    "    plt.ylim(-300,300)\n",
+    "    plt.plot(timesrd_final,gwdatanew.real/np.sqrt(error.imag**2+error.real**2), \"r\", alpha=0.3, lw=2, label='all error')\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Take the piece of waveform you want\n",
+    "position_in = np.argmax(timesrd_final >= tshift)\n",
+    "position_end = np.argmax(timesrd_final >= tend)\n",
+    "timesrd_final_tsh = timesrd_final[position_in:position_end]\n",
+    "#gwdatanew_re_tsh = gwdatanew_re[position_in:position_end]\n",
+    "#gwdatanew_im_tsh = gwdatanew_im[position_in:position_end]\n",
+    "gwdatanew_re_tsh = gwdatanew_re[position_in:position_end]\n",
+    "gwdatanew_im_tsh = gwdatanew_im[position_in:position_end]\n",
+    "if error_str and error_val==0:\n",
+    "    error_tsh=error[position_in:position_end]\n",
+    "    error_final=(error_tsh.real**2+error_tsh.imag**2)\n",
+    "    norm_factor = 100*len(error_final)/2*np.log(2*np.pi)\n",
+    "\n",
+    "elif error_str and error_val!=0:\n",
+    "#    gwdatanew_re_tsh+=random.uniform(0, error_val)\n",
+    "#    gwdatanew_im_tsh+=random.uniform(0, error_val)\n",
+    "    error_tsh=error_val\n",
+    "    error_final=(error_tsh.real**2+error_tsh.imag**2)\n",
+    "    norm_factor = 100*len(error_final)/2*np.log(2*np.pi)\n",
+    "\n",
+    "else:\n",
+    "    error_tsh=1\n",
+    "    error_final=(error_tsh.real**2+error_tsh.imag**2)\n",
+    "    norm_factor = 0\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Fitting\n",
+    "#RD model for nmax tones. Amplitudes are in (xn*Exp[i yn]) version. Used here.\n",
+    "def model_dv_q(theta):\n",
+    "    \"\"\"RD model parametrized with the quality factor q.\n",
+    "    \"\"\"  \n",
+    "    assert int(len(theta)/4) == dim, 'Please recheck your n and parameters'\n",
+    "    \n",
+    "    wvars = theta[ : (dim)]\n",
+    "    qvars = theta[(dim) : 2*(dim)]\n",
+    "    xvars = theta[2*(dim) : 3*(dim)]\n",
+    "    yvars = theta[3*(dim) : ]\n",
+    "    \n",
+    "    ansatz = 0\n",
+    "    for i in range (0,dim):\n",
+    "        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh*np.pi*wvars[i]/qvars[i])*(np.cos(wvars[i]*timesrd_final_tsh)-1j*np.sin(wvars[i]*timesrd_final_tsh))\n",
+    "    # -1j to agree with SXS convention\n",
+    "    return ansatz\n",
+    "\n",
+    "def model_dv_tau(theta):\n",
+    "    \"\"\"RD model parametrized with the damping time tau.\n",
+    "    \"\"\" \n",
+    "    assert int(len(theta)/4) == dim, 'Please recheck your n and parameters'\n",
+    "    \n",
+    "    wvars = theta[ : (dim)]\n",
+    "    tvars = theta[(dim) : 2*(dim)]\n",
+    "    xvars = theta[2*(dim) : 3*(dim)]\n",
+    "    yvars = theta[3*(dim) : ]\n",
+    "    \n",
+    "    ansatz = 0\n",
+    "    for i in range (0,dim):\n",
+    "        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh/tvars[i]) * (np.cos(wvars[i]*timesrd_final_tsh)-1j*np.sin(wvars[i]*timesrd_final_tsh))\n",
+    "    # -1j to agree with SXS convention\n",
+    "    return ansatz\n",
+    "\n",
+    "def model_dv(theta):\n",
+    "    \"\"\"RD model parametrized with the damping time tau and with the QNM spectrum fixd to GR. \n",
+    "    \"\"\" \n",
+    "    xvars = theta[ : (dim)]\n",
+    "    yvars = theta[(dim) : 2*(dim)]\n",
+    "    \n",
+    "    ansatz = 0\n",
+    "    for i in range (0,dim):\n",
+    "        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh/tau[i]) * (np.cos(w[i]*timesrd_final_tsh)-1j*np.sin(w[i]*timesrd_final_tsh))\n",
+    "    # -1j to agree with SXS convention\n",
+    "    return ansatz\n",
+    "\n",
+    "def model_dv_ma(theta):\n",
+    "    \"\"\"RD model parametrized with the damping time tau and with the QNM spectrum fixd to GR. The QNM spectrum is given from the mass and spin.\n",
+    "    \"\"\" \n",
+    "    xvars = theta[ : (dim)]\n",
+    "    yvars = theta[(dim) : 2*(dim)]\n",
+    "    mass_vars = theta[index_mass]\n",
+    "    spin_vars = theta[index_spin]\n",
+    "    \n",
+    "    w_m_a , tau_m_a = dict_omega[qnm_model](mass_vars,spin_vars,2,2)\n",
+    "    \n",
+    "    ansatz = 0\n",
+    "    for i in range (0,dim):\n",
+    "        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh/tau_m_a[i]) * (np.cos(w_m_a[i]*timesrd_final_tsh)-1j*np.sin(w_m_a[i]*timesrd_final_tsh))\n",
+    "    # -1j to agree with SXS convention\n",
+    "    return ansatz\n",
+    "\n",
+    "# Logprior distribution. It defines the allowed range my variables can vary over. \n",
+    "#It works for the (xn*Exp[iyn]) version. \n",
+    "\n",
+    "def prior_transform(cube):\n",
+    "    \"\"\"RD uniform priors. The values for priors_min and priors_max must be given out of this function.\n",
+    "    \"\"\" \n",
+    "    for i in range(prior_dim):\n",
+    "        cube[i] =  priors_min[i]+ cube[i]*(priors_max[i]-priors_min[i])\n",
+    "    return cube\n",
+    "\n",
+    "# LogLikelihood function. It is just a Gaussian loglikelihood based on computing the residuals^2\n",
+    "def log_likelihood(theta,sigma=1):\n",
+    "    \"\"\"chi2 likelihood.\n",
+    "    \"\"\" \n",
+    "    modelev = dict[model](theta)\n",
+    "    result = -np.sum(((gwdatanew_re_tsh - modelev.real)**2+(gwdatanew_im_tsh - modelev.imag)**2)/(2*theta[-1]*error_final))\n",
+    "    if np.isnan(result):\n",
+    "        return -np.inf\n",
+    "    return result\n",
+    "\n",
+    "    \n",
+    "\n",
+    "def log_likelihood2(theta,sigma=1):\n",
+    "    \"\"\"chi2 likelihood.\n",
+    "    \"\"\" \n",
+    "    modelev = dict[model](theta)\n",
+    "    modelevre= modelev.real\n",
+    "    modelevim= modelev.imag\n",
+    "    \n",
+    "    sigma2 = error_final + l_int*(modelevre** 2+modelevim**2) * np.exp(2 * theta[-1])\n",
+    "    \n",
+    "    result = -0.5*np.sum(((gwdatanew_re_tsh - modelevre)**2+(gwdatanew_im_tsh - modelevim)**2)/sigma2+l_int*(2*np.log(sigma2)))-l_int*norm_factor\n",
+    "    if np.isnan(result):\n",
+    "        return -np.inf\n",
+    "    return result\n",
+    "# Logposterior distribution for the residuals case.\n",
+    "# The evidence is just a normalization factor\n",
+    "def log_probability(theta):\n",
+    "    \"\"\"Posterior likelihood.\n",
+    "    \"\"\" \n",
+    "    lp = log_prior(theta)\n",
+    "    if not np.isfinite(lp):\n",
+    "        return -np.inf\n",
+    "    return lp + log_likelihood(theta)\n",
+    "\n",
+    "def posterior_samples(sampler):\n",
+    "    \"\"\"\n",
+    "    Returns posterior samples from nested samples and weights\n",
+    "    given by dynsety sampler\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    dynesty_samples = sampler.results['samples']\n",
+    "    wt = np.exp(sampler.results['logwt'] -\n",
+    "                       sampler.results['logz'][-1])\n",
+    "    # Make sure that sum of weights equal to 1\n",
+    "    weights = wt/np.sum(wt)\n",
+    "    posterior_dynesty = resample_equal(dynesty_samples, weights)\n",
+    "    return posterior_dynesty\n",
+    "\n",
+    "dict = {'w-tau': model_dv_tau , 'w-q': model_dv_q, 'w-tau-fixed': model_dv,'w-tau-fixed-m-af': model_dv_ma}\n",
+    "dict_omega = {'berti': QNM_Berti , 'qnm': QNM_spectrum}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/work/francisco.jimenez/venv/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "/work/francisco.jimenez/venv/lib/python3.7/site-packages/scipy/optimize/_numdiff.py:497: RuntimeWarning: invalid value encountered in subtract\n",
+      "  df = fun(x) - f0\n"
+     ]
+    }
+   ],
+   "source": [
+    "nll = lambda *args: -log_likelihood(*args)\n",
+    "if model == 'w-tau-fixed-m-af':\n",
+    "    if fitnoise:\n",
+    "        initial = np.concatenate((np.ones(2*dim),[0.8,0.9,1]))\n",
+    "        soln = minimize(nll, initial,bounds=priors)\n",
+    "        vars_ml=soln.x\n",
+    "    else:\n",
+    "        initial = np.concatenate((np.ones(2*dim),[0.8,0.9]))\n",
+    "        soln = minimize(nll, initial,bounds=priors)\n",
+    "        vars_ml=soln.x\n",
+    "elif model == 'w-tau-fixed':\n",
+    "    if fitnoise:\n",
+    "        initial =  np.concatenate((np.ones(2*dim),[0.2]))\n",
+    "        soln = minimize(nll, initial,bounds=priors)\n",
+    "        vars_ml=soln.x\n",
+    "    else:\n",
+    "        initial = np.ones(2*dim)\n",
+    "        soln = minimize(nll, initial,bounds=priors)\n",
+    "        vars_ml=soln.x\n",
+    "else:\n",
+    "    if fitnoise:\n",
+    "        initial = np.concatenate((np.ones(ndim),[1]))\n",
+    "        soln = minimize(nll, initial,bounds=priors)\n",
+    "        vars_ml=soln.x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "122.80929666700001\n"
+     ]
+    }
+   ],
+   "source": [
+    "mypool = Pool(nbcores)\n",
+    "mypool.size = nbcores\n",
+    "\n",
+    "start = time.process_time()\n",
+    "f2=dynesty.NestedSampler(log_likelihood2, prior_transform, prior_dim, nlive=npoints,sample=sampler,pool=mypool)\n",
+    "if parser.has_option('setup','dlogz'):\n",
+    "    dlogz=np.float(parser.get('setup','dlogz'))    \n",
+    "    f2.run_nested(dlogz=dlogz,print_progress=False)\n",
+    "else:\n",
+    "    f2.run_nested(print_progress=False)\n",
+    "\n",
+    "print(time.process_time() - start)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Summary\n",
+      "=======\n",
+      "nlive: 4000\n",
+      "niter: 45989\n",
+      "ncall: 933022\n",
+      "eff(%):  5.358\n",
+      "logz: -7.755 +/-  0.049\n"
+     ]
+    }
+   ],
+   "source": [
+    "res = f2.results\n",
+    "res.samples_u.shape\n",
+    "res.summary()\n",
+    "samps=f2.results.samples\n",
+    "postsamps = posterior_samples(f2)\n",
+    "samps_tr=np.transpose(samps)\n",
+    "half_points=int(round((len(samps_tr[0])/1.25)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if export:\n",
+    "    save_object(res, results_file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if model=='w-tau-fixed':\n",
+    "    rg = (nmax+1)\n",
+    "elif  model=='w-tau-fixed':\n",
+    "    rg = (nmax+1)+2\n",
+    "else:\n",
+    "    rg = (nmax+1)*2\n",
+    "\n",
+    "\n",
+    "if model=='w-tau-fixed-a-mf':\n",
+    "    npamps = np.empty((nmax+1))\n",
+    "    for i in range(0,(nmax+1)):\n",
+    "        amps_aux = samps_tr[i+rg][half_points:-1]\n",
+    "        npamps[i] = np.quantile(amps_aux, 0.5)\n",
+    "else :\n",
+    "    npamps = np.empty((nmax+1)*2)\n",
+    "    for i in range(0,(nmax+1)*2):\n",
+    "        amps_aux = samps_tr[i][half_points:-1]\n",
+    "        npamps[i] = np.quantile(amps_aux, 0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "evidence = res.logz[-1]\n",
+    "evidence_error = res.logzerr[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "summary_titles=['n','id','t_shift','dlogz','dlogz_err']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if export:\n",
+    "    if not eval(overwrite):\n",
+    "        if os.path.exists(sumary_data):\n",
+    "            outvalues = np.array([[nmax, simulation_number, tshift, evidence,evidence_error]])\n",
+    "        else:\n",
+    "            outvalues = np.array([summary_titles,[nmax, simulation_number, tshift, evidence,evidence_error]])\n",
+    "\n",
+    "        with open(sumary_data, 'a') as file:\n",
+    "            writer = csv.writer(file)\n",
+    "            if (outvalues.shape)[0]>1 :\n",
+    "                writer.writerows(outvalues)\n",
+    "            else:\n",
+    "                writer.writerow(outvalues[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "samps=f2.results.samples\n",
+    "samps_tr=np.transpose(samps)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigma_vars_m = np.empty(prior_dim)\n",
+    "sigma_vars_p = np.empty(prior_dim)\n",
+    "sigma_vars = np.empty(prior_dim)\n",
+    "sigma_vars_ml = np.empty(prior_dim)\n",
+    "for i in range(prior_dim): \n",
+    "    amps_aux = postsamps[:,i]\n",
+    "    sigma_vars_m[i] = np.quantile(amps_aux, 0.05)\n",
+    "    sigma_vars[i] = np.quantile(amps_aux, 0.5)\n",
+    "    sigma_vars_ml[i] = samps[-1,i]\n",
+    "    sigma_vars_p[i] = np.quantile(amps_aux, 0.95)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wstr = r'$\\omega_'\n",
+    "\n",
+    "if model == 'w-tau':\n",
+    "    taustr = r'$\\tau_'\n",
+    "elif model == 'w-q':\n",
+    "    taustr = r'$q_'\n",
+    "elif model == 'w-tau-fixed':\n",
+    "    taustr = r'$dumb_var}'\n",
+    "elif model == 'w-tau-fixed-m-af':\n",
+    "    taustr = r'$\\tau_'\n",
+    "\n",
+    "ampstr = r'$A_'\n",
+    "phasestr =  r'$\\phi_'\n",
+    "\n",
+    "w_lab = [None] * dim\n",
+    "tau_lab = [None] * dim\n",
+    "amp_lab =  [None] * dim\n",
+    "pha_lab =  [None] * dim\n",
+    "mass_lab =  ['mass']\n",
+    "spin_lab  =  ['spin']\n",
+    "\n",
+    "for i in range(dim):\n",
+    "    w_lab[i] = wstr+str(i)+'$'\n",
+    "    tau_lab[i] = taustr+str(i)+'$'\n",
+    "    amp_lab[i] = ampstr+str(i)+'$'\n",
+    "    pha_lab[i] = phasestr+str(i)+'$'\n",
+    "\n",
+    "\n",
+    "labels = np.concatenate((w_lab,tau_lab,amp_lab,pha_lab))\n",
+    "\n",
+    "if model=='w-tau-fixed':\n",
+    "    labels = np.concatenate((amp_lab,pha_lab))\n",
+    "\n",
+    "if model=='w-tau-fixed-m-af':\n",
+    "    pha_lab[i] = phasestr+str(i)+'$'\n",
+    "\n",
+    "    labels = np.concatenate((amp_lab,pha_lab,mass_lab,spin_lab))\n",
+    "\n",
+    "if fitnoise:\n",
+    "    noise_lab = ['noise']\n",
+    "    labels = np.concatenate((labels,noise_lab))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigma_vars_all = [sigma_vars,sigma_vars_ml,sigma_vars_m,sigma_vars_p]\n",
+    "sigma_vars_all=np.stack([sigma_vars,sigma_vars_ml,sigma_vars_m,sigma_vars_p], axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if export:\n",
+    "    key =['max val','max val ml','lower bound','higher bound']\n",
+    "    dfslist = [pd.DataFrame(np.concatenate(([tshift],sigma_vars_all[i])).reshape((-1,prior_dim+1)), columns=np.concatenate((['tshift'],labels)), index = [key[i]]) for i in range(4)]\n",
+    "    df2 = pd.concat(dfslist)\n",
+    "    if not eval(overwrite):\n",
+    "        if os.path.exists(best_data):\n",
+    "            df2.to_csv(best_data, mode='a', header=False,index = True)\n",
+    "        else:\n",
+    "            df2.to_csv(best_data,index = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if model == 'w-q':\n",
+    "    tau_val = np.pi*w*tau\n",
+    "    truths = np.concatenate((w,tau_val,npamps))\n",
+    "elif model == 'w-tau':\n",
+    "    tau_val = tau\n",
+    "    truths = np.concatenate((w,tau_val,npamps))\n",
+    "elif model == 'w-tau-fixed':\n",
+    "    truths = npamps\n",
+    "elif model == 'w-tau-fixed-m-af':\n",
+    "    truths = np.concatenate((npamps,[mf],[af]))\n",
+    "\n",
+    "if fitnoise:\n",
+    "    truths = np.concatenate((truths,[1]))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 67,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 698.4x698.4 with 16 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fg=corner.corner(postsamps,quantiles=[0.05,0.5,0.95],show_titles=True,max_n_ticks = 4,bins=50,truths=samps[-1],labels=labels,truth_color='red')\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 396x396 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if export:\n",
+    "    fg.savefig(corner_plot, format = 'png', bbox_inches = 'tight')\n",
+    "if model == 'w-tau-fixed-m-af':\n",
+    "    truths=np.concatenate((w,tau))\n",
+    "    samples_2=res.samples\n",
+    "    if fitnoise:\n",
+    "        fmass_spin=(samps.T)[-3:-1].T\n",
+    "    else:\n",
+    "        fmass_spin=(samps.T)[-2:].T\n",
+    "        #fmass_spin=new_samples[-2:]\n",
+    "    fmass_spin_dist=[None]*len(fmass_spin)\n",
+    "    labels_mf = np.concatenate((w_lab,tau_lab))\n",
+    "    weight=np.exp(res.logwt - res.logz[-1])\n",
+    "    for i in range(len(fmass_spin)):\n",
+    "        fmass_spin_dist[i]=np.concatenate(dict_omega[qnm_model](fmass_spin[i,0],fmass_spin[i,1],2,2))\n",
+    "        \n",
+    "    fmass_spin_dist_v2=np.asarray(fmass_spin_dist)\n",
+    "    new_samples = dyfunc.resample_equal(fmass_spin_dist_v2, weight)   \n",
+    "        \n",
+    "    figure = corner.corner(new_samples,truths=truths,quantiles=[0.05,0.95],labels=labels_mf,smooth=True,color='b',truth_color='r',show_titles=True)\n",
+    "    if export:\n",
+    "        figure.savefig(corner_plot_extra, format = 'png', bbox_inches = 'tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x1152 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#lnz_truth = ndim * -np.log(2 * 10.)  # analytic evidence solution\n",
+    "fig, axes = dyplot.runplot(res)\n",
+    "fig.tight_layout()\n",
+    "if not eval(overwrite):\n",
+    "    fig.savefig(diagnosis_plot, format = 'png', dpi = 384, bbox_inches = 'tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 154,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x648 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "figband = plt.figure(figsize = (12, 9))\n",
+    "plt.plot(timesrd_final_tsh,gwdatanew_re_tsh, \"green\", alpha=0.9, lw=3, label=r'$res_{240}$')\n",
+    "onesig_bounds = np.array([np.percentile(samps[:, i], [5, 95]) for i in range(len(samps[0]))]).T\n",
+    "samples_1sigma = filter(lambda sample: np.all(onesig_bounds[0] <= sample) and np.all(sample <= onesig_bounds[1]), samps)\n",
+    "samples_1sigma_down = list(samples_1sigma)[::downfactor]\n",
+    "for sample in samples_1sigma_down:\n",
+    "    plt.plot(timesrd_final_tsh, dict[model](sample).real, \"r-\", alpha=0.1, lw=1)\n",
+    "plt.title(r'Comparison of the MC fit data and the $1-\\sigma$ error band')\n",
+    "plt.legend()\n",
+    "plt.xlabel('t')\n",
+    "plt.ylabel('h')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if export:\n",
+    "    figband.savefig(fit_plot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if export:\n",
+    "    with open(samples_file,'w') as file:\n",
+    "        writer = csv.writer(file)\n",
+    "        writer.writerow(labels)\n",
+    "        writer.writerows(samps[::downfactor])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 477,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To convert back from mass and spin to tones\n",
+    "\n",
+    "#if model == 'w-tau-fixed-m-af':\n",
+    "\n",
+    "#   fmass_spin=(samps.T)[:2*(nmax+1)].T\n",
+    "#   fmass_spin_dist=[None]*len(fmass_spin)\n",
+    "#   weight=np.exp(res.logwt - res.logz[-1])\n",
+    "#    mass_spin_dist=[None]*len(fmass_spin)\n",
+    "#    for i in range(len(fmass_spin)):\n",
+    "#        fmass_spin_dist[i]=np.concatenate(dict_omega[qnm_model](fmass_spin[i,0],fmass_spin[i,1],2,2))\n",
+    "#        mass_dist = mass_from_wtau_loop(fmass_spin[i,:dim],fmass_spin[i,dim:],2,2) \n",
+    "#        spin_dist = spin_from_wtau_loop(fmass_spin[i,:dim],fmass_spin[i,dim:],2,2) \n",
+    "#        mass_spin_dist[i]=np.concatenate((mass_dist,spin_dist))\n",
+    "\n",
+    "#    fmass_spin_dist_v2=np.asarray(fmass_spin_dist)\n",
+    "#    new_samples = dyfunc.resample_equal(fmass_spin_dist_v2, weight) \n",
+    "#    figure = corner.corner(new_samples,quantiles=[0.05,0.95],truths=[mf,af,mf,af],smooth=True,color='b',truth_color='r',show_titles=True)\n",
+    "\n",
+    "#if export:    \n",
+    "#    figure.savefig(corner_plot_extra, format = 'png', bbox_inches = 'tight')"
+   ]
+  }
+ ],
+ "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.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/code_new/Sumit/NR_dynesty_t0_loop.py b/code_new/Sumit/NR_dynesty_t0_loop.py
new file mode 100644
index 0000000000000000000000000000000000000000..16c5890ba9b3c67f4d2e36b5e8137bebbf0749f4
--- /dev/null
+++ b/code_new/Sumit/NR_dynesty_t0_loop.py
@@ -0,0 +1,1333 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[3]:
+
+
+
+"""Generate ringdown templates in the time and perform parameter estimation on them.
+"""
+
+
+# In[4]:
+
+
+#Import relevant modules, import data and all that
+import time
+import numpy as np
+from scipy import interpolate
+import corner
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MaxNLocator
+from matplotlib import rc
+from configparser import ConfigParser
+import codecs
+#plt.rcParams['font.family'] = 'DejaVu Sans'
+#rc('text', usetex=True)
+plt.rcParams.update({'font.size': 16.5})
+from dynesty import utils as dyfunc
+
+
+from multiprocessing import Pool
+import h5py
+import pandas as pd
+import json
+import qnm
+import random
+from multiprocessing import Pool
+import dynesty
+from dynesty import plotting as dyplot
+from dynesty.utils import resample_equal
+import os
+import csv
+import argparse
+import pickle
+import scipy.optimize as optimization
+from scipy.optimize import minimize
+from scipy.interpolate import interp1d
+from pycbc.conversions import get_lm_f0tau_allmodes
+from scipy.optimize import fsolve
+import romspline
+import rdown as rd
+
+
+# In[5]:
+
+
+rdown=rd.Ringdown_Spectrum(1,0.9,2,2,n=0,s=-2)
+w0, tau0 = rdown.QNM_spectrum()
+
+
+# In[6]:
+
+
+rdown.rd_model_wtau([w0, tau0,1,2]);
+rdown.rd_model_wq([w0, tau0,1,2]);
+
+
+# In[7]:
+
+
+rdown=rd.Ringdown_Spectrum(1,0.9,2,2,n=0,s=-2,fixed=True)
+rdown.rd_model_wq_fixed([1,2]);
+
+
+# In[8]:
+
+
+# Cell that calls the arguments from your 'config.ini' file. 
+try:
+    parser = argparse.ArgumentParser(description="Simple argument parser")
+    parser.add_argument("-c", action="store", dest="config_file")
+    result = parser.parse_args()
+    config_file=result.config_file
+    parser = ConfigParser()
+    parser.read(config_file)
+    parser.sections()
+except SystemExit: 
+    parser = ConfigParser()
+    parser.read('config_fixed_m_af.ini')
+    parser.sections()
+    pass
+
+
+# In[9]:
+
+
+# path
+rootpath=parser.get('nr-paths','rootpath')
+
+simulation_path_1 = parser.get('nr-paths','simulation_path_1')
+simulation_path_2 = parser.get('nr-paths','simulation_path_2')
+metadata_file = parser.get('nr-paths','metadata_json')
+simulation_number = parser.get('nr-paths','simulation_number')
+simulation_number = np.int(simulation_number)
+
+output_folder = parser.get('output-folder','output-folder')
+overwrite = parser.get('setup','overwrite')
+downfactor = np.int(parser.get('setup','plot_down_factor'))
+sampler = parser.get('setup','sampler')
+nr_code = parser.get('setup','nr_code')
+
+if parser.has_option('setup','export'):
+    export=eval(parser.get('setup','export'))
+else:
+    export=True
+
+
+# In[10]:
+
+
+if parser.has_option('setup','nb_cores'):
+    nbcores = np.int(parser.get('setup','nb_cores'))
+else:
+    nbcores = 1
+
+
+# In[11]:
+
+
+if not os.path.exists(output_folder):
+    os.mkdir(output_folder)
+    print("Directory " , output_folder ,  " Created ")
+
+
+# In[12]:
+
+
+# time config
+tshift=parser.get('time-setup','tshift')
+tshift = np.float(tshift)
+
+tend=parser.get('time-setup','tend')
+tend = np.float(tend)
+
+t_align=parser.get('time-setup','t_align')
+t_align = np.float(t_align)
+
+
+# In[13]:
+
+
+# n-tones & nlive
+
+nmax=parser.get('n-tones','nmax')
+nmax = np.int(nmax)
+
+npoints=parser.get('n-live-points','npoints')
+npoints = np.int(npoints)
+
+
+# In[14]:
+
+
+filename = "/work/sumit.kumar/projects/ringdown/xisco/feb2021_injections/intrinsic/injection_2tones.hdf"
+files = h5py.File(filename, 'r')
+files.attrs.keys()
+#gw[simulation_number]["Extrapolated_N3.dir"]["Y_l2_m2.dat"] 
+#magic.from_file(filename)
+#help(files.attrs)
+files.attrs.values
+
+
+# In[15]:
+
+
+# model
+model=parser.get('rd-model','model')
+error_str = eval(parser.get('rd-model','error_str'))
+fitnoise=eval(parser.get('rd-model','fit_noise'))
+#fitnoise=False
+if error_str:
+    error_val=np.float(parser.get('rd-model','error_val'))
+    if error_val==0:
+        error_type=''
+    else:
+        error_type=error_val
+else:
+    error_type='False'
+    error_val =0
+
+if model == 'w-q':
+    tau_var_str='q'
+else:
+    tau_var_str='tau'
+    
+#tshift=10
+#npoints=10000
+#export=False
+print('model:',model)
+print('nmax:',nmax)
+print('tshift:',tshift)
+print('error:', error_str)
+print('error value:',error_type)
+print('export:',export)
+print('nr code:',nr_code)
+
+
+# In[16]:
+
+
+if error_str:
+    output_folder_1=output_folder+'/'+model+'-nmax'+str(nmax)+'_'+str(error_str)+'_'+str(error_type)+'_fitnoise_'+str(fitnoise)
+else:
+    output_folder_1=output_folder+'/'+model+'-nmax'+str(nmax)+'_'+str(error_str)+'_fitnoise_'+str(fitnoise)
+
+if not os.path.exists(output_folder_1):
+    os.mkdir(output_folder_1)
+    print("Directory " , output_folder_1 ,  " Created ")
+
+
+# In[17]:
+
+
+corner_plot=output_folder_1+'/Dynesty_'+str(simulation_number)+'_'+model+'_nmax='+str(nmax)+'_tshift='+str(tshift)+'_'+str(npoints)+'corner_plot.png'
+corner_plot_extra=output_folder_1+'/Dynesty_'+str(simulation_number)+'_'+model+'_nmax='+str(nmax)+'_tshift='+str(tshift)+'_'+str(npoints)+'corner_plot_extra.png'
+diagnosis_plot=output_folder_1+'/Dynesty_diagnosis'+str(simulation_number)+'_'+model+'_nmax='+str(nmax)+'_tshift='+str(tshift)+'_'+str(npoints)+'.png'
+fit_plot=output_folder_1+'/Fit_results_'+str(simulation_number)+'tshift_'+str(tshift)+'_'+model+'_nmax_'+str(nmax)+'.png'
+samples_file=output_folder_1+'/posterior_samples-'+str(simulation_number)+'tshift_'+str(tshift)+'_'+model+'_nmax_'+str(nmax)+'.csv'
+results_file=output_folder_1+'/results_'+str(simulation_number)+'tshift_'+str(tshift)+'_'+model+'_nmax_'+str(nmax)+'.pkl'
+
+
+# In[18]:
+
+
+sumary_data = output_folder_1+'/summary'+str(simulation_number)+'_'+model+'_nmax_'+str(nmax)+'.csv'
+best_data=output_folder_1+'/best_values_'+str(simulation_number)+'_'+model+'_nmax_'+str(nmax)+'.csv'
+
+
+# In[19]:
+
+
+vary_fund = True
+
+#sampler parameters
+dim = nmax+1
+ndim = 4*dim
+numbins = 32 #corner plot parameter - how many bins you want
+datacolor = '#105670' #'#4fa3a7'
+pkcolor = '#f2c977' #'#ffb45f'
+mediancolor = '#f7695c' #'#9b2814'
+
+#Import data and necessary functions
+#TimeOfMaximum
+def FindTmaximum(y):
+    """ It determines the maximum absolute value of the complex waveform.
+    """
+    absval = np.sqrt(y[:,1]*y[:,1]+y[:,2]*y[:,2])
+    vmax=np.max(absval)
+    index = np.argmax(absval == vmax)
+    timemax=y[index,0]
+    return timemax
+
+def save_object(obj, filename):
+    with open(filename, 'wb') as output:  # Overwrites any existing file.
+        pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL)
+
+
+def EasyMatchT(t,h1,h2,tmin,tmax):
+    """ It computes the time-domain match for (h1|h2)  complex waveforms.
+    """
+    pos = np.argmax(t >= (tmin));
+    
+    h1red=h1[pos:];
+    h2red=h2[pos:];
+    
+    norm1=np.sum(np.abs(h1red)**2)
+    norm2=np.sum(np.abs(h2red)**2)
+
+    myTable=h1red*np.conjugate(h2red)
+    res=((np.sum(myTable)/np.sqrt(norm1*norm2))).real
+    
+    return res
+
+def EasySNRT(t,h1,h2,tmin,tmax):
+    """ It computes the time-domain snr for (h1|h2)  complex waveforms.
+    """    
+    pos = np.argmax(t >= (tmin));
+    
+    h1red=h1[pos:];
+    h2red=h2[pos:];
+
+    myTable=h1red*np.conjugate(h2red)
+    res=2*np.sqrt((np.sum(myTable)).real)
+    
+    return res
+
+def wRD_to_f_Phys(f,M):
+    """ It converts NR frequencies to physical units in [Hz].
+    """  
+    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;
+    return (c**3/(M*MS*G*2*np.pi))*f
+
+def wRD_to_f_NR(f,M):
+    """ It converts Physical frequencies to NR units in [1/M].
+    """  
+    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;
+    return (c**3/(M*MS*G*2*np.pi))*f
+
+def tauRD_to_t_Phys(tau,M):
+    """ It converts NR times to physical units in [s].
+    """  
+    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;
+    return ((M*MS*G)/c**3)*tau
+
+def tauRD_to_t_NR(tau,M):
+    """ It converts Physical times to NR units in [M].
+    """  
+    c=2.99792458*10**8;G=6.67259*10**(-11);MS=1.9885*10**30;
+    return 1/((M*MS*G)/c**3)*tau
+
+def twopoint_autocovariance(t,n):
+    """ It computes the two-point autocovariance function.
+    """  
+    dt=t[1]-t[0]
+    res = np.zeros(len(n))
+    taus = np.zeros(len(n))
+    for tau in range(0,int(len(n)/2)):
+        ntau=np.roll(n, tau)
+        taus[tau] = t[tau]
+        res[tau]=np.sum(n*ntau).real
+    return (taus[:int(len(n)/2)],res[:int(len(n)/2)])
+
+grav_220 = [qnm.modes_cache(s=-2,l=2,m=2,n=i) for i in range (0,dim)]
+def QNM_spectrum_old(mf,af,l,m):
+    """ It computes the RD frequencies and damping times in NR units.
+    """     
+    omegas_new_v2 = [qnm.modes_cache(s=-2,l=l,m=m,n=i)(a=af)[0] for i in range (0,dim)]
+    w_m_a = (np.real(omegas_new_v2))/mf
+    tau_m_a=-1/(np.imag(omegas_new_v2))*mf
+    
+    return (w_m_a, tau_m_a)
+
+def QNM_spectrum(mf,af,l,m):
+    """ It computes the RD frequencies and damping times in NR units.
+    """     
+    omegas_new=np.asarray([grav_220[i](a=af)[0] for i in range (0,dim)])
+    w_m_a = (np.real(omegas_new))/mf
+    tau_m_a=-1/(np.imag(omegas_new))*mf
+    
+    return (w_m_a, tau_m_a)
+
+def QNM_Berti(mf,af,l,m):
+    """ It computes the RD frequencies and damping times in NR units.
+    """     
+    position=np.argmax(rdowndata[0,0] >= (af))
+    #w_m_a=f1+f2*(1-af)**f3
+    w_m_a=[None]*(nmax+1)
+    tau_ma_a=[None]*(nmax+1)
+    
+    for i in range(nmax+1):
+        qnm=rdowndata[i,1:3,position]
+        w_m_a[i] = qnm[0]/mf
+        tau_ma_a[i] = -1/(qnm[1])*mf
+
+    return w_m_a, tau_ma_a
+
+f_fpars= [[2.95845, -2.58697, 0.0533469], [2.12539, -1.78054, 
+  0.0865503], [1.74755, -1.44776, 0.123666], [1.78287, -1.53203, 
+  0.129475], [2.04028, -1.83224, 0.112497]]
+
+q_fpars=[[0.584077, 1.52053, -0.480658], [0.00561441, 
+  0.630715, -0.432664], [-0.197965, 0.515956, -0.369706], [-0.275097, 
+  0.455691, -0.331543], [-0.287596, 0.398514, -0.309799]]
+
+def w_fpars_Berti(n):
+    return f_fpars[n]
+
+def tau_qpars_Berti(n):
+    return q_fpars[n]
+
+def mass_from_wtau(n,w,tau):
+    f1,f2,f3 = w_fpars_Berti(n)
+    q1,q2,q3 = tau_qpars_Berti(n)
+    res=(f1 + f2*(2**(-1/q3)*((-2*q1 + w*tau)/q2)**(1/q3))**f3)/w
+    return res
+
+def spin_from_wtau(n,w,tau):
+    f1,f2,f3 = w_fpars_Berti(n)
+    q1,q2,q3 = tau_qpars_Berti(n)
+    res=1 - 2**(-1/q3)*((-2*q1 + w*tau)/q2)**(1/q3)
+    return res
+
+def mass_from_wtau_loop(w,tau,l,m):
+    res=[None]*dim
+    for n in range (0,dim):
+        f1,f2,f3 = w_fpars_Berti(n)
+        q1,q2,q3 = tau_qpars_Berti(n)
+        res[n]=(f1 + f2*(2**(-1/q3)*((-2*q1 + w[n]*tau[n])/q2)**(1/q3))**f3)/w[n]
+    return res
+
+def spin_from_wtau_loop(w,tau,l,m):
+    res=[None]*dim
+    for n in range (0,dim):
+        f1,f2,f3 = w_fpars_Berti(n)
+        q1,q2,q3 = tau_qpars_Berti(n)
+        res[n]= 1 - 2**(-1/q3)*((-2*q1 + w[n]*tau[n])/q2)**(1/q3)
+    return res
+
+
+# In[20]:
+
+
+def FFT_FreqBins(times):
+    Len = len(times)
+    DeltaT = times[-1]- times[0]
+    dt = DeltaT/(Len-1)
+    dnu = 1/(Len*dt)
+    maxfreq = 1/(2*dt)
+    add = dnu/4
+
+    p = np.arange(0.0,maxfreq+add,dnu)
+    m = np.arange(p[-1]-(2*maxfreq)+dnu,-dnu/2+add,dnu)
+    res=np.concatenate((p,m))
+    
+    return res
+
+def hFromPsi4FFI(tpsi4,f0):
+    
+    timecheck1=tpsi4[-2,0]-tpsi4[-1,0]
+    timecheck2=tpsi4[1,0]-tpsi4[0,0]
+    
+    if np.abs(timecheck1-timecheck2)>=0.0001:
+        print("The data might not be equally sampled!!")
+
+    times,data= tpsi4[:,0],tpsi4[:,1]
+
+    freqs = FT_FreqBins(xaxis.real).real
+    position = np.argmax(freqs >= f0)
+    freqs[:position]=f0*np.ones(len(freqs[:position]))
+    freqs=2*np.pi*freqs
+
+    fdata=fft(data)
+    len(myTable)*ifft(- fdata/floor**2);
+    np.stack((times,data)).T
+
+
+# In[21]:
+
+
+2*np.sqrt(12/2*1/tauRD_to_t_NR(1.3*10**-47,70)*(5*10**(-21))**2)
+
+
+# In[22]:
+
+
+1/tauRD_to_t_NR(1.3*10**-47,70)*(5*10**(-21))**2
+
+
+# In[23]:
+
+
+2*np.sqrt(0.004/2*1/(1.3*10**-47)*(5*10**(-21))**2)
+
+
+# In[24]:
+
+
+np.sqrt(1/(1.3*10**-47)*(5*10**(-21))**2)
+
+
+# In[25]:
+
+
+gw = {}
+gw[simulation_number] = h5py.File(simulation_path_1, 'r') 
+if nr_code=='SXS': 
+    gw_sxs_bbh_0305 = gw[simulation_number]["Extrapolated_N3.dir"]["Y_l2_m2.dat"] 
+    times = gw_sxs_bbh_0305[:,0]
+    gw5 = {}
+    gw5[simulation_number] = h5py.File(simulation_path_2, 'r')
+    gw5_sxs_bbh_0305 = gw5[simulation_number]["Extrapolated_N3.dir"]["Y_l2_m2.dat"]
+
+elif nr_code=='Maya': 
+    dt=0.1
+    gw_sxs_bbh_0305_amp = np.asarray(gw[simulation_number]['amp_l2_m2/Y'])[6:] 
+    times_1 = np.asarray(gw[simulation_number]['amp_l2_m2/X'])[6:] 
+    gw_sxs_bbh_0305_amp_int = romspline.ReducedOrderSpline(times_1, gw_sxs_bbh_0305_amp)
+    gw_sxs_bbh_0305_pha = np.asarray(gw[simulation_number]['phase_l2_m2/Y'])[6:]
+    times = np.asarray(gw[simulation_number]['phase_l2_m2/X'])[6:]
+    gw_sxs_bbh_0305_pha_int = romspline.ReducedOrderSpline(times, gw_sxs_bbh_0305_pha)
+    
+    tmin=max(times_1[0],times[0])
+    tmax=min(times_1[-1],times[-1])
+    times=np.arange(tmin,tmax,dt)
+    amps=gw_sxs_bbh_0305_amp_int(times)
+    phs=gw_sxs_bbh_0305_pha_int(times)
+    gw_sxs_bbh_0305 = np.asarray([times,amps*np.cos(phs),amps*np.sin(phs)]).T
+    gw5_sxs_bbh_0305 = gw_sxs_bbh_0305
+    
+elif nr_code=='LaZeV': 
+    #gw_sxs_bbh_0305_amp = np.asarray(gw[simulation_number]['amp_l2_m2/Y'])[6:] 
+    #gw_sxs_bbh_0305_amp_err = np.asarray(gw[simulation_number]['amp_l2_m2/errors']) 
+    #times_1 = np.asarray(gw[simulation_number]['amp_l2_m2/X'])[6:] 
+    #gw_sxs_bbh_0305_amp_int = interp1d(times_1, gw_sxs_bbh_0305_amp, kind='cubic') 
+    #gw_sxs_bbh_0305_amp_errs_int = interp1d(times_1, gw_sxs_bbh_0305_amp_err, kind='cubic')
+    
+    #gw_sxs_bbh_0305_pha = np.asarray(gw[simulation_number]['phase_l2_m2/Y'])[6:]
+    #gw_sxs_bbh_0305_pha_err = np.asarray(gw[simulation_number]['phase_l2_m2/errors'])
+    #times = np.asarray(gw[simulation_number]['phase_l2_m2/X'])[6:]
+    #gw_sxs_bbh_0305_pha_int = interp1d(times, gw_sxs_bbh_0305_pha, kind='cubic')
+    #gw_sxs_bbh_0305_pha_errs_int = interp1d(times, gw_sxs_bbh_0305_pha_err, kind='cubic')
+    #position = np.argmax(times >= times_1[0])
+    #times = times[position:]
+    
+    
+    #amps=gw_sxs_bbh_0305_amp_int(times) 
+    #amps_err=gw_sxs_bbh_0305_amp_errs_int(times) 
+
+    #phs=gw_sxs_bbh_0305_pha_int(times)
+    #phs_err=-gw_sxs_bbh_0305_pha_errs_int(times)
+
+    #gw_sxs_bbh_0305 = np.asarray([times,amps*np.cos(phs),amps*np.sin(phs)]).T
+    # the sqrt(2) is to correct the double weight of the errror
+    #error_lav = np.sqrt(amps_err**2+ (amps**2)*phs_err**2)/np.sqrt(2)
+    #gw5_sxs_bbh_0305 = np.asarray([times,gw_sxs_bbh_0305[:,1]+error_lav,gw_sxs_bbh_0305[:,2]+error_lav]).T
+    
+    dt=0.1
+    gw_sxs_bbh_0305_amp = np.asarray(gw[simulation_number]['amp_l2_m2/Y'])[6:] 
+    times_1 = np.asarray(gw[simulation_number]['amp_l2_m2/X'])[6:] 
+    gw_sxs_bbh_0305_amp_int = romspline.ReducedOrderSpline(times_1, gw_sxs_bbh_0305_amp)
+    gw_sxs_bbh_0305_pha = np.asarray(gw[simulation_number]['phase_l2_m2/Y'])[6:]
+    times = np.asarray(gw[simulation_number]['phase_l2_m2/X'])[6:]
+    gw_sxs_bbh_0305_pha_int = romspline.ReducedOrderSpline(times, gw_sxs_bbh_0305_pha)
+    
+    tmin=max(times_1[0],times[0])
+    tmax=min(times_1[-1],times[-1])
+    times=np.arange(tmin,tmax,dt)
+    amps=gw_sxs_bbh_0305_amp_int(times)
+    phs=gw_sxs_bbh_0305_pha_int(times)
+    gw_sxs_bbh_0305 = np.asarray([times,amps*np.cos(phs),amps*np.sin(phs)]).T
+    gw5_sxs_bbh_0305 = gw_sxs_bbh_0305
+
+
+# In[26]:
+
+
+#Test plot real part (data was picked in the last cell). Aligning in time
+plt.figure(figsize = (12, 8))
+plt.plot(times,gw_sxs_bbh_0305[:,1], "r", alpha=0.3, lw=3, label=r'$Lev6$: real')
+plt.plot(times, gw_sxs_bbh_0305[:,2], "b", alpha=0.3, lw=3, label=r'$Lev6$: real')
+plt.xlim(-1700,200)
+plt.legend()
+
+
+# In[28]:
+
+
+if nr_code=='SXS':
+    metadata = {}
+    with open(metadata_file) as file:
+        metadata[simulation_number] = json.load(file)
+
+    af = metadata[simulation_number]['remnant_dimensionless_spin'][-1]
+    mf = metadata[simulation_number]['remnant_mass']
+
+elif nr_code=='Maya':
+    af = 0.6861
+    mf = 0.9515
+
+elif nr_code=='LaZeV':    
+    metadata = {}
+    #with open(metadata_file) as file:
+    #    metadata[simulation_number] = json.load(file)
+    fread = open(metadata_file, "r")
+    metadata = fread.readlines()
+   
+    af = 0.6919694604
+    mf = 0.9520211506
+    
+#times --> x axis of your data
+times = gw_sxs_bbh_0305[:,0]
+tmax=FindTmaximum(gw_sxs_bbh_0305[round(len(gw_sxs_bbh_0305)/2):])
+times = times - tmax
+
+#times 6--> x axis of your data
+times5 = gw5_sxs_bbh_0305[:,0]
+tmax5=FindTmaximum(gw5_sxs_bbh_0305[round(len(gw_sxs_bbh_0305)/2):])
+times5 = times5 - tmax5
+
+
+# In[29]:
+
+
+if parser.has_option('setup','qnm_model'):
+    qnm_model='berti'
+    rdownfolders=np.asarray([rootpath+'/RDmodes/l2/n'+str(i+1)+'l2m2.dat' for i in range(nmax+1)])
+    rdowndata = np.asarray([np.loadtxt(rdownfolders[i]).T for i in range(len(rdownfolders))])
+    w , tau  = QNM_Berti(mf,af,2,2)
+else:
+    qnm_model='qnm'
+    w , tau = QNM_spectrum(mf,af,2,2)
+    
+    
+
+
+# In[30]:
+
+
+# loading priors
+w_mins=np.empty(nmax+1)
+w_maxs=np.empty(nmax+1)
+tau_mins=np.empty(nmax+1)
+tau_maxs=np.empty(nmax+1)
+a_mins=np.empty(nmax+1)
+a_maxs=np.empty(nmax+1)
+ph_mins=np.empty(nmax+1)
+ph_maxs=np.empty(nmax+1)
+
+for i in range(nmax+1): 
+    wp_min=parser.get('prior-w'+str(i),'w'+str(i)+'_min')
+    w_mins[i] = np.float(wp_min)
+    
+    wp_max=parser.get('prior-w'+str(i),'w'+str(i)+'_max')
+    w_maxs[i] = np.float(wp_max)
+    
+    taup_min=parser.get('prior-'+tau_var_str+str(i),tau_var_str+str(i)+'_min')
+    tau_mins[i] = np.float(taup_min)
+    
+    taup_max=parser.get('prior-'+tau_var_str+str(i),tau_var_str+str(i)+'_max')
+    tau_maxs[i] = np.float(taup_max)
+    
+    amp0_min=parser.get('prior-amp'+str(i),'amp'+str(i)+'_min')
+    a_mins[i] = np.float(amp0_min)
+    
+    amp1_max=parser.get('prior-amp'+str(i),'amp'+str(i)+'_max')
+    a_maxs[i] = np.float(amp1_max)
+    
+    phase_min=parser.get('prior-phase'+str(i),'phase'+str(i)+'_min')
+    ph_mins[i] = np.float(phase_min)*2*np.pi
+    
+    phase_max=parser.get('prior-phase'+str(i),'phase'+str(i)+'_max')
+    ph_maxs[i] = np.float(phase_max)*2*np.pi
+    
+priors_min = np.concatenate((w_mins,tau_mins,a_mins,ph_mins))
+priors_max = np.concatenate((w_maxs,tau_maxs,a_maxs,ph_maxs))
+prior_dim = len(priors_min)
+priors=np.column_stack((priors_min,priors_max))
+
+if model == 'w-tau-fixed':
+    priors_min = np.concatenate((a_mins,ph_mins))
+    priors_max = np.concatenate((a_maxs,ph_maxs))
+    prior_dim = len(priors_min)
+    priors=np.column_stack((priors_min,priors_max))
+
+elif model ==  'w-tau-fixed-m-af':
+    mass_min=[np.float(parser.get('prior-mass','mass_min'))]
+    mass_max=[np.float(parser.get('prior-mass','mass_max'))]
+    spin_min=[np.float(parser.get('prior-spin','spin_min'))]
+    spin_max=[np.float(parser.get('prior-spin','spin_max'))]
+    priors_min = np.concatenate((a_mins,ph_mins,mass_min,spin_min))
+    priors_max = np.concatenate((a_maxs,ph_maxs,mass_max,spin_max))
+    prior_dim = len(priors_min)
+    priors=np.column_stack((priors_min,priors_max))
+
+
+if fitnoise:
+    l_int=1
+    index_mass=-3
+    index_spin=-2
+    priors_fit_min=[np.float(parser.get('prior-noise','noise_min'))]
+    priors_fit_max=[np.float(parser.get('prior-noise','noise_max'))]
+    priors_min = np.concatenate((priors_min,priors_fit_min))
+    priors_max = np.concatenate((priors_max,priors_fit_max))
+    priors=np.column_stack((priors_min,priors_max))
+    prior_dim = len(priors_min)
+else: 
+    index_mass=-2
+    index_spin=-1
+    l_int=0
+    
+#a_maxs[1]=20
+a_maxs
+
+
+# In[31]:
+
+
+#Select the data from 0 onwards
+position = np.argmax( times >= (t_align))
+position5 = np.argmax(times5 >= (t_align))
+gw_sxs_bbh_0305rd=gw_sxs_bbh_0305[position+1:]
+gw_sxs_bbh_0305rd5=gw5_sxs_bbh_0305[position5+1:]
+timesrd=gw_sxs_bbh_0305[position:-1][:,0][:]-tmax
+timesrd5=gw5_sxs_bbh_0305[position5:-1][:,0][:]-tmax5
+
+
+# In[32]:
+
+
+#Test plot real part (data was picked in the last cell). Aligning in time
+plt.figure(figsize = (12, 8))
+plt.plot(timesrd, gw_sxs_bbh_0305rd[:,1], "r", alpha=0.3, lw=3, label=r'$Lev6$: real')
+plt.plot(timesrd, np.sqrt(gw_sxs_bbh_0305rd[:,1]**2+gw_sxs_bbh_0305rd[:,2]**2), "r", alpha=0.3, lw=3, label=r'$Lev5\,amp$')
+plt.plot(timesrd5, gw_sxs_bbh_0305rd5[:,1], "b", alpha=0.3, lw=3, label=r'$Lev5: real$')
+plt.plot(timesrd5, np.sqrt(gw_sxs_bbh_0305rd5[:,1]**2+gw_sxs_bbh_0305rd5[:,2]**2), "b", alpha=0.3, lw=3, label=r'$Lev5\,amp$')
+plt.legend()
+
+
+# In[33]:
+
+
+#[plt.errorbar(csv_data_fixed[i]['t_shift'], -csv_data_fixed[i]['dlogz'], yerr=csv_data_fixed[i]['dlogz_err'], fmt='o',color=colors[i],label =tags_fixed[i]) for i in range(len(csv_data_fixed))] 
+
+
+# In[34]:
+
+
+gwnew_re = interpolate.interp1d(timesrd, gw_sxs_bbh_0305rd[:,1], kind = 'cubic')
+gwnew_im = interpolate.interp1d(timesrd, gw_sxs_bbh_0305rd[:,2], kind = 'cubic')
+
+gwnew_re5 = interpolate.interp1d(timesrd5, gw_sxs_bbh_0305rd5[:,1], kind = 'cubic')
+gwnew_im5 = interpolate.interp1d(timesrd5, gw_sxs_bbh_0305rd5[:,2], kind = 'cubic')
+
+
+# In[35]:
+
+
+if timesrd5[-1]>= timesrd[-1]: 
+    timesrd_final = timesrd
+else:
+    timesrd_final = timesrd5
+
+gwdatanew_re = gwnew_re(timesrd_final)
+gwdatanew_im = gwnew_im(timesrd_final)
+gwdatanew_re5 = gwnew_re5(timesrd_final)
+gwdatanew_im5 = gwnew_im5(timesrd_final)
+
+gwdatanew = gwdatanew_re - 1j*gwdatanew_im
+gwdatanew5 = gwdatanew_re5- 1j*gwdatanew_im5
+
+
+# In[36]:
+
+
+#taus, corr= twopoint_autocovariance(timesrd,gwdatanew-gwdatanew5)
+#plt.figure(figsize = (12, 8))
+#plt.plot(taus, corr,'ro')
+#plt.show()
+#vmax=np.max(corr)
+#index = np.argmax(corr == vmax)
+#taus[index]
+print(w)
+print(tau)
+
+
+# In[37]:
+
+
+mismatch=1-EasyMatchT(timesrd_final,gwdatanew,gwdatanew5,0,0+90)
+error=np.sqrt(2*mismatch)
+print('error estimate:',error)
+print('mismatch:', mismatch)
+print('snr:', EasySNRT(timesrd_final,gwdatanew,gwdatanew,0,0+90)/error**2)
+
+
+# In[38]:
+
+
+if error_str and error_val==0:
+    error = np.sqrt(gwdatanew*gwdatanew-2*gwdatanew*gwdatanew5+gwdatanew5*gwdatanew5)
+    error_est=np.sqrt(error.imag**2+error.real**2)
+    plt.figure(figsize = (12, 8))
+    plt.plot(timesrd_final, gwdatanew.real, "r", alpha=0.3, lw=2, label='Lev6')
+    plt.plot(timesrd_final, gwdatanew5.real, "b", alpha=0.3, lw=2, label='Lev5')
+    plt.plot(timesrd_final, error_est, "b", alpha=0.3, lw=2, label='error')
+    plt.legend()
+
+
+# In[39]:
+
+
+if parser.has_option('rd-model','phase_alignment'):
+    phase_alignment=eval(parser.get('rd-model','phase_alignment'))    
+else:
+    phase_alignment=False
+
+
+# In[40]:
+
+
+# Phase alignement
+if phase_alignment:
+    phas = np.angle(gwdatanew)
+    phas = np.unwrap(phas)
+    phas5 = np.angle(gwdatanew5)
+    phas5 = np.unwrap(phas5)
+    position = np.argmax(timesrd_final >= (t_align))
+    dphase = phas5[position]-phas[position]
+    gwdatanew = (gwdatanew_re - 1j*gwdatanew_im)*np.exp(1j*dphase)
+    gw_sxs_bbh_0305rd6=gw5_sxs_bbh_0305[position5:-1]
+    timesrd=gw_sxs_bbh_0305[position:-1][:,0][:920]
+    mismatch=1-EasyMatchT(timesrd_final,gwdatanew,gwdatanew5,0,+90)
+    error=np.sqrt(2*mismatch)
+    print('error estimate:',error)
+    print('mismatch:', mismatch)
+    print('snr:', EasySNRT(timesrd_final,gwdatanew,gwdatanew5,0,0+90)/error)
+    if error_str:
+        error = np.sqrt(gwdatanew*gwdatanew-2*gwdatanew*gwdatanew5+gwdatanew5*gwdatanew5)
+        error_est=np.sqrt(error.imag**2+error.real**2)
+    else :
+        error = 1 
+        EasySNRT(timesrd_final,gwdatanew,gwdatanew5/error,0,0+90)
+
+
+# In[41]:
+
+
+#Test the new interpolated data
+if error_str and error_val==0:
+    plt.figure(figsize = (12, 8))
+    plt.plot(timesrd_final, gwdatanew.real, "r", alpha=0.3, lw=2, label='Lev6')
+    plt.plot(timesrd_final, gwdatanew5.real, "b", alpha=0.3, lw=2, label='Lev5')
+    plt.plot(timesrd_final, error.real, "b", alpha=0.3, lw=2, label='error')
+    plt.legend()
+
+
+# In[42]:
+
+
+#Test the error data
+if error_str and error_val==0:
+    plt.figure(figsize = (12, 8))
+    plt.plot(timesrd_final, error_est, "r", alpha=0.3, lw=2, label='all error')
+    plt.legend()
+
+
+# In[43]:
+
+
+#Test the error data
+if error_str and error_val==0:
+    plt.figure(figsize = (12, 8))
+    plt.xlim(1,40)
+    plt.ylim(-300,300)
+    plt.plot(timesrd_final,gwdatanew.real/np.sqrt(error.imag**2+error.real**2), "r", alpha=0.3, lw=2, label='all error')
+    plt.legend()
+
+
+# In[44]:
+
+
+#Take the piece of waveform you want
+position_in = np.argmax(timesrd_final >= tshift)
+position_end = np.argmax(timesrd_final >= tend)
+timesrd_final_tsh = timesrd_final[position_in:position_end]
+#gwdatanew_re_tsh = gwdatanew_re[position_in:position_end]
+#gwdatanew_im_tsh = gwdatanew_im[position_in:position_end]
+gwdatanew_re_tsh = gwdatanew_re[position_in:position_end]
+gwdatanew_im_tsh = gwdatanew_im[position_in:position_end]
+if error_str and error_val==0:
+    error_tsh=error[position_in:position_end]
+    error_final=(error_tsh.real**2+error_tsh.imag**2)
+    norm_factor = 100*len(error_final)/2*np.log(2*np.pi)
+
+elif error_str and error_val!=0:
+#    gwdatanew_re_tsh+=random.uniform(0, error_val)
+#    gwdatanew_im_tsh+=random.uniform(0, error_val)
+    error_tsh=error_val
+    error_final=(error_tsh.real**2+error_tsh.imag**2)
+    norm_factor = 100*len(error_final)/2*np.log(2*np.pi)
+
+else:
+    error_tsh=1
+    error_final=(error_tsh.real**2+error_tsh.imag**2)
+    norm_factor = 0
+
+
+# In[46]:
+
+
+#Fitting
+#RD model for nmax tones. Amplitudes are in (xn*Exp[i yn]) version. Used here.
+def model_dv_q(theta):
+    """RD model parametrized with the quality factor q.
+    """  
+    assert int(len(theta)/4) == dim, 'Please recheck your n and parameters'
+    
+    wvars = theta[ : (dim)]
+    qvars = theta[(dim) : 2*(dim)]
+    xvars = theta[2*(dim) : 3*(dim)]
+    yvars = theta[3*(dim) : ]
+    
+    ansatz = 0
+    for i in range (0,dim):
+        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh*np.pi*wvars[i]/qvars[i])*(np.cos(wvars[i]*timesrd_final_tsh)-1j*np.sin(wvars[i]*timesrd_final_tsh))
+    # -1j to agree with SXS convention
+    return ansatz
+
+def model_dv_tau(theta):
+    """RD model parametrized with the damping time tau.
+    """ 
+    assert int(len(theta)/4) == dim, 'Please recheck your n and parameters'
+    
+    wvars = theta[ : (dim)]
+    tvars = theta[(dim) : 2*(dim)]
+    xvars = theta[2*(dim) : 3*(dim)]
+    yvars = theta[3*(dim) : ]
+    
+    ansatz = 0
+    for i in range (0,dim):
+        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh/tvars[i]) * (np.cos(wvars[i]*timesrd_final_tsh)-1j*np.sin(wvars[i]*timesrd_final_tsh))
+    # -1j to agree with SXS convention
+    return ansatz
+
+def model_dv(theta):
+    """RD model parametrized with the damping time tau and with the QNM spectrum fixd to GR. 
+    """ 
+    xvars = theta[ : (dim)]
+    yvars = theta[(dim) : 2*(dim)]
+    
+    ansatz = 0
+    for i in range (0,dim):
+        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh/tau[i]) * (np.cos(w[i]*timesrd_final_tsh)-1j*np.sin(w[i]*timesrd_final_tsh))
+    # -1j to agree with SXS convention
+    return ansatz
+
+def model_dv_ma(theta):
+    """RD model parametrized with the damping time tau and with the QNM spectrum fixd to GR. The QNM spectrum is given from the mass and spin.
+    """ 
+    xvars = theta[ : (dim)]
+    yvars = theta[(dim) : 2*(dim)]
+    mass_vars = theta[index_mass]
+    spin_vars = theta[index_spin]
+    
+    w_m_a , tau_m_a = dict_omega[qnm_model](mass_vars,spin_vars,2,2)
+    
+    ansatz = 0
+    for i in range (0,dim):
+        ansatz += (xvars[i]*np.exp(1j*yvars[i]))*np.exp(-timesrd_final_tsh/tau_m_a[i]) * (np.cos(w_m_a[i]*timesrd_final_tsh)-1j*np.sin(w_m_a[i]*timesrd_final_tsh))
+    # -1j to agree with SXS convention
+    return ansatz
+
+# Logprior distribution. It defines the allowed range my variables can vary over. 
+#It works for the (xn*Exp[iyn]) version. 
+
+def prior_transform(cube):
+    """RD uniform priors. The values for priors_min and priors_max must be given out of this function.
+    """ 
+    for i in range(prior_dim):
+        cube[i] =  priors_min[i]+ cube[i]*(priors_max[i]-priors_min[i])
+    return cube
+
+# LogLikelihood function. It is just a Gaussian loglikelihood based on computing the residuals^2
+def log_likelihood(theta,sigma=1):
+    """chi2 likelihood.
+    """ 
+    modelev = dict[model](theta)
+    result = -np.sum(((gwdatanew_re_tsh - modelev.real)**2+(gwdatanew_im_tsh - modelev.imag)**2)/(2*theta[-1]*error_final))
+    if np.isnan(result):
+        return -np.inf
+    return result
+
+    
+
+def log_likelihood2(theta,sigma=1):
+    """chi2 likelihood.
+    """ 
+    modelev = dict[model](theta)
+    modelevre= modelev.real
+    modelevim= modelev.imag
+    
+    sigma2 = error_final + l_int*(modelevre** 2+modelevim**2) * np.exp(2 * theta[-1])
+    
+    result = -0.5*np.sum(((gwdatanew_re_tsh - modelevre)**2+(gwdatanew_im_tsh - modelevim)**2)/sigma2+l_int*(2*np.log(sigma2)))-l_int*norm_factor
+    if np.isnan(result):
+        return -np.inf
+    return result
+# Logposterior distribution for the residuals case.
+# The evidence is just a normalization factor
+def log_probability(theta):
+    """Posterior likelihood.
+    """ 
+    lp = log_prior(theta)
+    if not np.isfinite(lp):
+        return -np.inf
+    return lp + log_likelihood(theta)
+
+def posterior_samples(sampler):
+    """
+    Returns posterior samples from nested samples and weights
+    given by dynsety sampler
+    """
+    
+    dynesty_samples = sampler.results['samples']
+    wt = np.exp(sampler.results['logwt'] -
+                       sampler.results['logz'][-1])
+    # Make sure that sum of weights equal to 1
+    weights = wt/np.sum(wt)
+    posterior_dynesty = resample_equal(dynesty_samples, weights)
+    return posterior_dynesty
+
+dict = {'w-tau': model_dv_tau , 'w-q': model_dv_q, 'w-tau-fixed': model_dv,'w-tau-fixed-m-af': model_dv_ma}
+dict_omega = {'berti': QNM_Berti , 'qnm': QNM_spectrum}
+
+
+# In[47]:
+
+
+nll = lambda *args: -log_likelihood(*args)
+if model == 'w-tau-fixed-m-af':
+    if fitnoise:
+        initial = np.concatenate((np.ones(2*dim),[0.8,0.9,1]))
+        soln = minimize(nll, initial,bounds=priors)
+        vars_ml=soln.x
+    else:
+        initial = np.concatenate((np.ones(2*dim),[0.8,0.9]))
+        soln = minimize(nll, initial,bounds=priors)
+        vars_ml=soln.x
+elif model == 'w-tau-fixed':
+    if fitnoise:
+        initial =  np.concatenate((np.ones(2*dim),[0.2]))
+        soln = minimize(nll, initial,bounds=priors)
+        vars_ml=soln.x
+    else:
+        initial = np.ones(2*dim)
+        soln = minimize(nll, initial,bounds=priors)
+        vars_ml=soln.x
+else:
+    if fitnoise:
+        initial = np.concatenate((np.ones(ndim),[1]))
+        soln = minimize(nll, initial,bounds=priors)
+        vars_ml=soln.x
+
+
+# In[48]:
+
+
+mypool = Pool(nbcores)
+mypool.size = nbcores
+
+start = time.process_time()
+f2=dynesty.NestedSampler(log_likelihood2, prior_transform, prior_dim, nlive=npoints,sample=sampler,pool=mypool)
+if parser.has_option('setup','dlogz'):
+    dlogz=np.float(parser.get('setup','dlogz'))    
+    f2.run_nested(dlogz=dlogz,print_progress=False)
+else:
+    f2.run_nested(print_progress=False)
+
+print(time.process_time() - start)
+
+
+# In[49]:
+
+
+res = f2.results
+res.samples_u.shape
+res.summary()
+samps=f2.results.samples
+postsamps = posterior_samples(f2)
+samps_tr=np.transpose(samps)
+half_points=int(round((len(samps_tr[0])/1.25)))
+
+
+# In[50]:
+
+
+if export:
+    save_object(res, results_file)
+
+
+# In[51]:
+
+
+if model=='w-tau-fixed':
+    rg = (nmax+1)
+elif  model=='w-tau-fixed':
+    rg = (nmax+1)+2
+else:
+    rg = (nmax+1)*2
+
+
+if model=='w-tau-fixed-a-mf':
+    npamps = np.empty((nmax+1))
+    for i in range(0,(nmax+1)):
+        amps_aux = samps_tr[i+rg][half_points:-1]
+        npamps[i] = np.quantile(amps_aux, 0.5)
+else :
+    npamps = np.empty((nmax+1)*2)
+    for i in range(0,(nmax+1)*2):
+        amps_aux = samps_tr[i][half_points:-1]
+        npamps[i] = np.quantile(amps_aux, 0.5)
+
+
+# In[52]:
+
+
+evidence = res.logz[-1]
+evidence_error = res.logzerr[-1]
+
+
+# In[53]:
+
+
+summary_titles=['n','id','t_shift','dlogz','dlogz_err']
+
+
+# In[54]:
+
+
+if export:
+    if not eval(overwrite):
+        if os.path.exists(sumary_data):
+            outvalues = np.array([[nmax, simulation_number, tshift, evidence,evidence_error]])
+        else:
+            outvalues = np.array([summary_titles,[nmax, simulation_number, tshift, evidence,evidence_error]])
+
+        with open(sumary_data, 'a') as file:
+            writer = csv.writer(file)
+            if (outvalues.shape)[0]>1 :
+                writer.writerows(outvalues)
+            else:
+                writer.writerow(outvalues[0])
+
+
+# In[55]:
+
+
+samps=f2.results.samples
+samps_tr=np.transpose(samps)
+
+
+# In[56]:
+
+
+sigma_vars_m = np.empty(prior_dim)
+sigma_vars_p = np.empty(prior_dim)
+sigma_vars = np.empty(prior_dim)
+sigma_vars_ml = np.empty(prior_dim)
+for i in range(prior_dim): 
+    amps_aux = postsamps[:,i]
+    sigma_vars_m[i] = np.quantile(amps_aux, 0.05)
+    sigma_vars[i] = np.quantile(amps_aux, 0.5)
+    sigma_vars_ml[i] = samps[-1,i]
+    sigma_vars_p[i] = np.quantile(amps_aux, 0.95)
+
+
+# In[57]:
+
+
+wstr = r'$\omega_'
+
+if model == 'w-tau':
+    taustr = r'$\tau_'
+elif model == 'w-q':
+    taustr = r'$q_'
+elif model == 'w-tau-fixed':
+    taustr = r'$dumb_var}'
+elif model == 'w-tau-fixed-m-af':
+    taustr = r'$\tau_'
+
+ampstr = r'$A_'
+phasestr =  r'$\phi_'
+
+w_lab = [None] * dim
+tau_lab = [None] * dim
+amp_lab =  [None] * dim
+pha_lab =  [None] * dim
+mass_lab =  ['mass']
+spin_lab  =  ['spin']
+
+for i in range(dim):
+    w_lab[i] = wstr+str(i)+'$'
+    tau_lab[i] = taustr+str(i)+'$'
+    amp_lab[i] = ampstr+str(i)+'$'
+    pha_lab[i] = phasestr+str(i)+'$'
+
+
+labels = np.concatenate((w_lab,tau_lab,amp_lab,pha_lab))
+
+if model=='w-tau-fixed':
+    labels = np.concatenate((amp_lab,pha_lab))
+
+if model=='w-tau-fixed-m-af':
+    pha_lab[i] = phasestr+str(i)+'$'
+
+    labels = np.concatenate((amp_lab,pha_lab,mass_lab,spin_lab))
+
+if fitnoise:
+    noise_lab = ['noise']
+    labels = np.concatenate((labels,noise_lab))
+
+
+# In[58]:
+
+
+sigma_vars_all = [sigma_vars,sigma_vars_ml,sigma_vars_m,sigma_vars_p]
+sigma_vars_all=np.stack([sigma_vars,sigma_vars_ml,sigma_vars_m,sigma_vars_p], axis=0)
+
+
+# In[59]:
+
+
+if export:
+    key =['max val','max val ml','lower bound','higher bound']
+    dfslist = [pd.DataFrame(np.concatenate(([tshift],sigma_vars_all[i])).reshape((-1,prior_dim+1)), columns=np.concatenate((['tshift'],labels)), index = [key[i]]) for i in range(4)]
+    df2 = pd.concat(dfslist)
+    if not eval(overwrite):
+        if os.path.exists(best_data):
+            df2.to_csv(best_data, mode='a', header=False,index = True)
+        else:
+            df2.to_csv(best_data,index = True)
+
+
+# In[60]:
+
+
+if model == 'w-q':
+    tau_val = np.pi*w*tau
+    truths = np.concatenate((w,tau_val,npamps))
+elif model == 'w-tau':
+    tau_val = tau
+    truths = np.concatenate((w,tau_val,npamps))
+elif model == 'w-tau-fixed':
+    truths = npamps
+elif model == 'w-tau-fixed-m-af':
+    truths = np.concatenate((npamps,[mf],[af]))
+
+if fitnoise:
+    truths = np.concatenate((truths,[1]))
+
+
+# In[67]:
+
+
+fg=corner.corner(postsamps,quantiles=[0.05,0.5,0.95],show_titles=True,max_n_ticks = 4,bins=50,truths=samps[-1],labels=labels,truth_color='red')
+plt.show
+
+
+# In[68]:
+
+
+if export:
+    fg.savefig(corner_plot, format = 'png', bbox_inches = 'tight')
+if model == 'w-tau-fixed-m-af':
+    truths=np.concatenate((w,tau))
+    samples_2=res.samples
+    if fitnoise:
+        fmass_spin=(samps.T)[-3:-1].T
+    else:
+        fmass_spin=(samps.T)[-2:].T
+        #fmass_spin=new_samples[-2:]
+    fmass_spin_dist=[None]*len(fmass_spin)
+    labels_mf = np.concatenate((w_lab,tau_lab))
+    weight=np.exp(res.logwt - res.logz[-1])
+    for i in range(len(fmass_spin)):
+        fmass_spin_dist[i]=np.concatenate(dict_omega[qnm_model](fmass_spin[i,0],fmass_spin[i,1],2,2))
+        
+    fmass_spin_dist_v2=np.asarray(fmass_spin_dist)
+    new_samples = dyfunc.resample_equal(fmass_spin_dist_v2, weight)   
+        
+    figure = corner.corner(new_samples,truths=truths,quantiles=[0.05,0.95],labels=labels_mf,smooth=True,color='b',truth_color='r',show_titles=True)
+    if export:
+        figure.savefig(corner_plot_extra, format = 'png', bbox_inches = 'tight')
+
+
+# In[69]:
+
+
+#lnz_truth = ndim * -np.log(2 * 10.)  # analytic evidence solution
+fig, axes = dyplot.runplot(res)
+fig.tight_layout()
+if not eval(overwrite):
+    fig.savefig(diagnosis_plot, format = 'png', dpi = 384, bbox_inches = 'tight')
+
+
+# In[154]:
+
+
+figband = plt.figure(figsize = (12, 9))
+plt.plot(timesrd_final_tsh,gwdatanew_re_tsh, "green", alpha=0.9, lw=3, label=r'$res_{240}$')
+onesig_bounds = np.array([np.percentile(samps[:, i], [5, 95]) for i in range(len(samps[0]))]).T
+samples_1sigma = filter(lambda sample: np.all(onesig_bounds[0] <= sample) and np.all(sample <= onesig_bounds[1]), samps)
+samples_1sigma_down = list(samples_1sigma)[::downfactor]
+for sample in samples_1sigma_down:
+    plt.plot(timesrd_final_tsh, dict[model](sample).real, "r-", alpha=0.1, lw=1)
+plt.title(r'Comparison of the MC fit data and the $1-\sigma$ error band')
+plt.legend()
+plt.xlabel('t')
+plt.ylabel('h')
+plt.show()
+
+
+# In[90]:
+
+
+if export:
+    figband.savefig(fit_plot)
+
+
+# In[91]:
+
+
+if export:
+    with open(samples_file,'w') as file:
+        writer = csv.writer(file)
+        writer.writerow(labels)
+        writer.writerows(samps[::downfactor])
+
+
+# In[477]:
+
+
+# To convert back from mass and spin to tones
+
+#if model == 'w-tau-fixed-m-af':
+
+#   fmass_spin=(samps.T)[:2*(nmax+1)].T
+#   fmass_spin_dist=[None]*len(fmass_spin)
+#   weight=np.exp(res.logwt - res.logz[-1])
+#    mass_spin_dist=[None]*len(fmass_spin)
+#    for i in range(len(fmass_spin)):
+#        fmass_spin_dist[i]=np.concatenate(dict_omega[qnm_model](fmass_spin[i,0],fmass_spin[i,1],2,2))
+#        mass_dist = mass_from_wtau_loop(fmass_spin[i,:dim],fmass_spin[i,dim:],2,2) 
+#        spin_dist = spin_from_wtau_loop(fmass_spin[i,:dim],fmass_spin[i,dim:],2,2) 
+#        mass_spin_dist[i]=np.concatenate((mass_dist,spin_dist))
+
+#    fmass_spin_dist_v2=np.asarray(fmass_spin_dist)
+#    new_samples = dyfunc.resample_equal(fmass_spin_dist_v2, weight) 
+#    figure = corner.corner(new_samples,quantiles=[0.05,0.95],truths=[mf,af,mf,af],smooth=True,color='b',truth_color='r',show_titles=True)
+
+#if export:    
+#    figure.savefig(corner_plot_extra, format = 'png', bbox_inches = 'tight')
+
diff --git a/code_new/Sumit/condor_submit.sub b/code_new/Sumit/condor_submit.sub
new file mode 100755
index 0000000000000000000000000000000000000000..a3f46f71cc21ae5c64dd79c641d8ab561505fdc5
--- /dev/null
+++ b/code_new/Sumit/condor_submit.sub
@@ -0,0 +1,20 @@
+universe   = vanilla
+getenv     = true
+# run script -- make sure that condor has execute permission for this file (chmod a+x script.py)
+executable = run_m_af.sh 
+# file to dump stdout (this directory should exist)
+output     = ./out_files/run_m_af.out
+# file to dump stderr
+error     = ./out_files/run_m_af.err
+# condor logs
+log     = ./out_files/run_m_af.log
+initialdir = .
+notify_user = frjifo@aei.mpg.de
+notification = Complete
+arguments  = "-processid $(Process)" 
+request_memory = 16GB
+request_cpus = 8
+on_exit_remove = (ExitBySignal == False) || ((ExitBySignal == True) && (ExitSignal != 11))
+accounting_group = cbc.dev.test
+queue 1
+
diff --git a/code_new/Sumit/config_fixed_m_af.ini b/code_new/Sumit/config_fixed_m_af.ini
new file mode 100644
index 0000000000000000000000000000000000000000..cca7dd1afb20bb5ff3045e28227da8bf20cccbff
--- /dev/null
+++ b/code_new/Sumit/config_fixed_m_af.ini
@@ -0,0 +1,151 @@
+[nr-paths]
+rootpath = /work/francisco.jimenez/sio/git/rdstackingproject
+simulation_path_1 = /work/francisco.jimenez/sio/git/rdstackingproject/SXS/BBH_SKS_d14.3_q1.22_sA_0_0_0.330_sB_0_0_-0.440/Lev6/rhOverM_Asymptotic_GeometricUnits_CoM.h5
+simulation_path_2 = /work/francisco.jimenez/sio/git/rdstackingproject/SXS/BBH_SKS_d14.3_q1.22_sA_0_0_0.330_sB_0_0_-0.440/Lev5/rhOverM_Asymptotic_GeometricUnits_CoM.h5
+metadata_json = /work/francisco.jimenez/sio/git/rdstackingproject/SXS/BBH_SKS_d14.3_q1.22_sA_0_0_0.330_sB_0_0_-0.440/Lev6/metadata.json 
+simulation_number = 0305
+
+[output-folder]
+output-folder = /work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/NR_Model_Noise
+
+[setup]
+export = True
+overwrite = False
+plot_down_factor = 100
+sampler = rwalk
+nr_code = SXS
+dlogz = 0.01
+qnm_model = berti
+
+[rd-model]
+model = w-tau-fixed-m-af
+error_str = True
+;error_val = 0
+;sumit change this line!
+error_val = 0.0002
+;end of the change.
+phase_alignment = True
+fit_noise = True
+
+[time-setup]
+tshift = 0
+tend = 90
+t_align = 0
+
+[n-tones]
+nmax = 0
+
+[n-live-points]
+npoints=4000
+
+[prior-mass]
+mass_min = 0.5
+mass_max = 1.5
+
+[prior-spin]
+spin_min = 0
+spin_max = 0.95
+
+[prior-w0]
+w0_min = 0.4
+w0_max = 0.6
+
+[prior-w1]
+w1_min = 0.35
+w1_max = 0.7
+
+[prior-w2]
+w2_min = 0.35
+w2_max = 0.7
+
+[prior-w3]
+w3_min = 0.35
+w3_max = 0.7
+
+[prior-w4]
+w4_min = 0.35
+w4_max = 0.7
+
+[prior-tau0]
+tau0_min = 8
+tau0_max = 16
+
+[prior-tau1]
+tau1_min = 0
+tau1_max = 7.7
+
+[prior-tau2]
+tau2_min = 2.35
+tau2_max = 3.05
+
+[prior-tau3]
+tau3_min = 1.8
+tau3_max = 2.35
+
+[prior-tau4]
+tau4_min = 0
+tau4_max = 1.8
+
+[prior-q0]
+q0_min = 12
+q0_max = 30
+
+[prior-q1]
+q1_min = 0
+q1_max = 15
+
+[prior-q2]
+q2_min = 0
+q2_max = 15
+
+[prior-q3]
+q3_min = 0
+q3_max = 15
+
+[prior-q4]
+q4_min = 0
+q4_max = 15
+
+[prior-amp0]
+amp0_min = 0
+amp0_max = 3
+
+[prior-amp1]
+amp1_min = 0 
+amp1_max = 15
+
+[prior-amp2]
+amp2_min = 0
+amp2_max = 30
+
+[prior-amp3]
+amp3_min = 0
+amp3_max = 30
+
+[prior-amp4]
+amp4_min = 0
+amp4_max = 50
+
+[prior-phase0]
+phase0_min = 0
+phase0_max = 1
+
+[prior-phase1]
+phase1_min = 0
+phase1_max = 1
+
+[prior-phase2]
+phase2_min = 0
+phase2_max = 1
+
+[prior-phase3]
+phase3_min = 0
+phase3_max = 1
+
+[prior-phase4]
+phase4_min = 0
+phase4_max = 1
+
+[prior-noise]
+noise_min = -30
+noise_max = 3
diff --git a/code_new/Sumit/run_4_m_af.sh b/code_new/Sumit/run_4_m_af.sh
new file mode 100755
index 0000000000000000000000000000000000000000..badd52a3a867d7af82d961475ba07935932b3533
--- /dev/null
+++ b/code_new/Sumit/run_4_m_af.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+times=(0 0.2 0.4 0.8 1.2 2 2.5 5 7.5 10 12 15 18 20)
+times=(20 18 15 12 10 7.5 5 2.5 2 1.2 0.8 0.4 0.2 0)
+times=(7.5)
+times=(0)
+configfile=config_fixed_n4_m_af.ini
+pythonfile=/work/francisco.jimenez/sio/git/rdstackingproject/code_new/NR_dynesty_t0_loop.py
+#pythonscript=/work/francisco.jimenez/local/python-3.7.7/bin/python3
+pythonscript=/work/francisco.jimenez/venv/bin/python
+awk -v  a="10" '/^tshift/ && $3 != "supplied" { $3=a } { print }' $configfile > tmp && mv tmp $configfile 
+for i in ${times[@]}; do
+    echo "submit a simulation with this parameter:"
+    echo "$i"
+    awk -v  a="$i" '/^tshift/ && $3 != "supplied" { $3=a } { print }' $configfile > tmp && mv tmp $configfile
+    $pythonscript $pythonfile -c $configfile
+done
+