From f8a593036644f0cc27d4b020f32b3e9e8d1398a7 Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Mon, 26 Nov 2018 15:35:50 -0500
Subject: [PATCH 01/20] Ignore database files

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 66bd3a4..3b42279 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,3 +68,6 @@ target/
 *Theta45
 *checkpoint.ipynb
 *.png
+
+# ignores added by Lia
+*.hdf5
\ No newline at end of file

From d718a821b65bb44202d7fdc1aa7c5b201dda2042 Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Wed, 28 Nov 2018 10:59:58 -0500
Subject: [PATCH 02/20] There is no xrange in Python 3

---
 gas_opac/opacity_demo.py | 398 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 398 insertions(+)
 create mode 100644 gas_opac/opacity_demo.py

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
new file mode 100644
index 0000000..ff282bb
--- /dev/null
+++ b/gas_opac/opacity_demo.py
@@ -0,0 +1,398 @@
+# Demostrates how to open the opacity database and interpolate to a given P, T, and wavelength grid
+# Author: Ryan J. MacDonald - 8th November, 2018
+
+import numpy as np
+import h5py
+from scipy.ndimage import gaussian_filter1d as gauss_conv
+from numba.decorators import jit
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+
+#***** Begin function declarations *****# 
+
+@jit(nopython = True)
+def prior_index(vec, value, start):
+    
+    '''Finds the index of a grid closest to a specified value'''
+    
+    value_tmp = value
+    
+    if (value_tmp > vec[-1]):
+        return (len(vec) - 1)
+    
+    # Check if value out of bounds, if so set to edge value
+    if (value_tmp < vec[0]): value_tmp = vec[0]
+    if (value_tmp > vec[-2]): value_tmp = vec[-2]
+    
+    index = start
+    
+    for i in range(len(vec)-start):
+        if (vec[i+start] > value_tmp): 
+            index = (i+start) - 1
+            break
+            
+    return index
+
+@jit(nopython=True)
+def prior_index_V2(val, grid_start, grid_end, N_grid):
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        return int(i)
+
+@jit(nopython=True)
+def closest_index(val, grid_start, grid_end, N_grid):
+    
+    '''Finds the index of a UNIFORM grid closest to a specified value.
+    
+       Assuming a uniform grid dramatically speeds calculation'''
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        if ((i%1)<=0.5):
+            return int(i)
+        else:
+            return int(i)+1
+                        
+@jit(nopython = True)
+def P_interpolate_wl_initialise(N_T, N_P, N_wl, log_sigma,
+                                nu_l, nu_model, nu_r, nu_opac, N_nu,
+                                x, b1, b2, mode):
+    
+    '''Interpolates raw cross sections onto the model P and wl grid.
+       
+       Note: input sigma has format log10(cross_sec)[log(P)_grid, T_grid, nu_grid], 
+             whilst output has format cross_sec[T, wl_model]
+             
+       The input is in wavenumnber to take advantage of fast prior index location 
+       on a uniform grid, which wouldn't work for the (non-uniform) wavelength grid
+       Array reversal to output in increasing wavelength is handled by indexing
+       by a factor of (N_wl-1)-k throughout 
+    '''
+    
+    sigma_pre_inp = np.zeros(shape=(N_T, N_wl))
+    
+    N_nu_opac = len(nu_opac)   # Number of wavenumber points in sigma array
+    
+    for k in range(N_nu): # Note that the k here is looping over wavenumber
+        
+        # Indicies in pre-computed wavenumber array of LHS, centre, and RHS of desired wavenumber grid
+        z_l = closest_index(nu_l[k], nu_opac[0], nu_opac[-1], N_nu_opac)
+        z = closest_index(nu_model[k], nu_opac[0], nu_opac[-1], N_nu_opac)
+        z_r = closest_index(nu_r[k], nu_opac[0], nu_opac[-1], N_nu_opac)
+        
+        for j in range(N_T):
+            
+            # If nu (wl) point out of range of opacity grid, set opacity to zero
+            if ((z == 0) or (z == (N_nu_opac-1))):
+                sigma_pre_inp[j, ((N_wl-1)-k)] = 0.0
+                
+            else:
+                            
+                # Opacity sampling
+                if (mode == 1):
+                    
+                    # If pressure below minimum, set to value at min pressure
+                    if (x == -1):
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (log_sigma[0, j, z])
+                            
+                    # If pressure above maximum, set to value at max pressure
+                    elif (x == -2):
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (log_sigma[(N_P-1), j, z])
+            
+                    # Interpolate sigma in logsace, then power to get interp array
+                    else:
+                        reduced_sigma = log_sigma[x:x+2, j, z]
+                            
+                        sigma_pre_inp[j, ((N_wl-1)-k)] =  10 ** (b1*(reduced_sigma[0]) +
+                                                                 b2*(reduced_sigma[1]))
+                            
+                # Log averaging
+                elif (mode == 2):
+                    
+                    # If pressure below minimum, set to value at min pressure
+                    if (x == -1):
+                        sigma_in_bin = np.mean(log_sigma[0, j, z_l:z_r+1])
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+                            
+                    # If pressure above maximum, set to value at max pressure
+                    elif (x == -2):
+                        sigma_in_bin = np.mean(log_sigma[(N_P-1), j, z_l:z_r+1])
+                        sigma_pre_inp[j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+        
+                    # Interpolate sigma in logsace, then power to get interp array
+                    else:
+                        sigma_in_bin_P1 = np.mean(log_sigma[x, j, z_l:z_r+1])
+                        sigma_in_bin_P2 = np.mean(log_sigma[x+1, j, z_l:z_r+1])
+                        
+                        sigma_pre_inp[j, ((N_wl-1)-k)] =  10 ** (b1*(sigma_in_bin_P1) +
+                                                                 b2*(sigma_in_bin_P2))
+                                                
+    return sigma_pre_inp
+
+@jit(nopython = True)
+def T_interpolation_init(T_grid, T):
+    
+    y = 0  # Index in cross secion arrays prior to fine temperature value
+        
+    if (T < T_grid[0]):   # If temperature falls off LHS of temperaure grid
+        y = -1            # Special value (-1) stored, interpreted in interpolator
+        w_T = 0.0         # Weight not used in this case
+            
+    elif (T >= T_grid[-1]):   # If temperature falls off RHS of temperaure grid
+        y = -2                # Special value (-2) stored, interpreted in interpolator
+        w_T = 0.0             # Weight not used in this case
+        
+    else:
+            
+        # Have to use prior_index (V1) here as T_grid is not uniformly spaced
+        y = prior_index(T_grid, T, 0)      # Index in cross secion arrays prior to desired temperature value
+            
+        # Pre-computed temperature values to left and right of desired temperature value
+        T1 = T_grid[y]
+        T2 = T_grid[y+1]
+            
+        # Precompute temperature interpolation weight factor
+        w_T = (1.0/((1.0/T2) - (1.0/T1)))
+  
+    return y, w_T
+
+@jit(nopython = True)
+def T_interpolate(N_T, N_wl, sigma_pre_inp, T_grid, T, y, w_T):
+    
+    sigma_inp = np.zeros(shape=(N_wl))
+            
+    T1 = T_grid[y]
+    T2 = T_grid[y+1]
+            
+    for k in range(N_wl):   # Loop over wavelengths
+                
+        # If T_fine below min value (100 K), set sigma to value at min T
+        if (y == -1):
+            sigma_inp[k] = sigma_pre_inp[0, k]
+                    
+        # If T_fine above max value (3500 K), set sigma to value at max T
+        elif (y == -2):
+            sigma_inp[k] = sigma_pre_inp[(N_T-1), k]
+            
+        # Interpolate sigma to fine temperature grid value
+        else: 
+            sig_reduced = sigma_pre_inp[y:y+2, k]
+            sig_1, sig_2 = sig_reduced[0], sig_reduced[1]    # sigma(T1)[i,k], sigma(T2)[i,k]
+                    
+            sigma_inp[k] =  (np.power(sig_1, (w_T*((1.0/T2) - (1.0/T)))) *
+                             np.power(sig_2, (w_T*((1.0/T) - (1.0/T1)))))
+            
+    return sigma_inp
+
+
+def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
+    
+    '''Convienient function to read in all opacities and pre-interpolate
+       them onto the desired pressure, temperature, and wavelength grid'''
+    
+    print("Now reading in cross sections")
+    
+    # First, check from config.py which opacity calculation mode is specified
+    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
+    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
+    
+    #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
+    
+    # Open HDF5 files containing molecular + atomic opacities and CIA
+    opac_file = h5py.File('./Opacity_database_0.01cm-1.hdf5', 'r')
+    
+    #***** Read in T and P grids used in opacity files*****#
+    T_grid = np.array(opac_file['H2O/T'])            # H2O here simply used as dummy (same grid for all molecules)
+    log_P_grid = np.array(opac_file['H2O/log(P)'])   # Units: log10(P/bar)!
+    
+    #***** Read in wavenumber arrays used in opacity files*****#
+    nu_opac = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
+
+    N_P = len(log_P_grid)              # No. of pressures in opacity files
+    N_T = len(T_grid)                  # No. of temperatures in opacity files
+    N_species = len(chemical_species)  # No. of chemical species user wishes to store
+
+    # Convert model wavelength grid to wavenumber grid
+    nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
+    nu_out = nu_out[::-1]    # Reverse direction, such that increases with wavenumber
+    
+    N_nu = len(nu_out)    # Number of wavenumbers on model grid
+    N_wl = len(wl_out)    # Number of wavelengths on model grid
+    
+    # Initialise arrays of wavenumber locations of left and right bin edges
+    nu_l = np.zeros(N_nu)   # Left edge
+    nu_r = np.zeros(N_nu)   # Right edge
+            
+    # Find logarithm of desired pressure
+    log_P = np.log10(P)
+    
+    # If pressure below minimum, do not interpolate
+    if (log_P < log_P_grid[0]):
+        x = -1      # Special value (1) used in opacity inialiser
+        w_P = 0.0
+        
+    # If pressure above maximum, do not interpolate
+    elif (log_P >= log_P_grid[-1]):
+        x = -2      # Special value (2) used in opacity inialiser
+        w_P = 0.0
+        
+    else:
+        # Closest P indicies in opacity grid corresponding to model pressure
+        x = prior_index_V2(log_P, log_P_grid[0], log_P_grid[-1], N_P)
+        
+        # Weights - fractional distance along pressure axis of sigma array
+        w_P = (log_P-log_P_grid[x])/(log_P_grid[x+1]-log_P_grid[x])     
+         
+    # Precalculate interpolation pre-factors to reduce computation overhead
+    b1 = (1.0-w_P)
+    b2 = w_P  
+        
+    # Find wavenumber indicies in arrays of model grid
+    for k in range(N_nu):
+        
+        if (k != 0) and (k != (N_nu-1)):    
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        
+        # Special case for boundary values
+        elif (k == 0): 
+            nu_l[k] = nu_out[k] - 0.5*(nu_out[k+1] - nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        elif (k == (N_nu-1)):
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])
+    
+    # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
+    sigma_stored = np.zeros(shape=(N_species, N_wl))
+    
+    # Evaluate temperature interpolation weighting factor
+    y, w_T = T_interpolation_init(T_grid, T)  
+        
+    #***** Process molecular and atomic opacities *****#
+    
+    # Load molecular and atomic absorption cross sections
+    for q in range(N_species):
+            
+        species_q = chemical_species[q]     # Molecule name (defined in config.py)
+        
+        # Read in log10(cross section) of specified molecule
+        log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)      
+            
+        # Pre-interpolate cross section to desired P and wl grid 
+        sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, log_sigma, nu_l, nu_out, nu_r, nu_opac, N_nu, x, b1, b2, calculation_mode)
+        
+        sigma_stored[q,:] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
+        
+        del log_sigma, sigma_pre_T_inp   # Clear raw cross section to free up memory
+        
+        print(species_q + " done")
+    
+    # Clear up storage
+    del nu_l, nu_r, nu_out
+    
+    opac_file.close()
+    
+    return sigma_stored
+
+def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
+    
+    # Max number of species this can plot is 9 (clustered beyond that!)
+    
+    # Optional smoothing of cross sections (can improve clarity)
+    smooth = False
+    smooth_factor = 5
+    
+    # Specify cross sections to plot, along with colours for each
+    colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
+    
+    # Initialise plot
+    ax = plt.gca()    
+    #ax.set_xscale("log")
+    
+    xmajorLocator   = MultipleLocator(1.0)
+    xmajorFormatter = FormatStrFormatter('%.1f')
+    xminorLocator   = MultipleLocator(0.2)
+    
+    ax.xaxis.set_major_locator(xmajorLocator)
+    ax.xaxis.set_major_formatter(xmajorFormatter)
+    ax.xaxis.set_minor_locator(xminorLocator)
+    
+    # Plot each cross section
+    for q in range(len(chemical_species)):
+        
+        species = chemical_species[q]  # Species to plot cross section of 
+        colour = colours_plot[q]   # Colour of cross section for plot
+        
+        #print(species)
+        
+        species_idx = np.where(chemical_species == species)[0][0]
+
+        sigma_plt = sigma_stored[species_idx,:]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)
+        
+        if (smooth == True):
+            sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
+        
+        # Plot cross section
+        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, color= colour, label = species)
+    
+    plt.ylim([1.0e-28, 2.0e-18])
+    plt.xlim([min(wl_grid), max(wl_grid)])
+    plt.ylabel(r'$\mathrm{Cross \, \, Section \, \, (cm^{2})}$', fontsize = 15)
+    plt.xlabel(r'$\mathrm{Wavelength} \; \mathrm{(\mu m)}$', fontsize = 15)
+    
+    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\mathrm{T = }$' + str(T) + r'$\mathrm{K \, \, P = }$' + str(P*1000) + r'$\mathrm{mbar}$'), fontsize = 14)
+    
+    legend = plt.legend(loc='upper right', shadow=False, frameon=False, prop={'size':6}, ncol=2)
+    
+    for legline in legend.legendHandles:
+        legline.set_linewidth(1.0)
+    
+    #plt.close()
+    #plt.show()
+
+    plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+
+
+#***** Begin main program ***** 
+    
+# Specify which molecules you want to extract from the database (full list available in the readme)
+chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])
+
+# At what temperature and pressure do you desire the cross sections?
+P = 1.0e-3    # Pressure (bar)
+T = 1000.0    # Temperature (K)        
+
+# Specify wavelength grid to extract cross section onto
+wl_min = 0.4  # Minimum wavelength of grid (micron)
+wl_max = 5.0  # Maximum wavelength of grid (micron)
+N_wl = 1000   # Number of wavelength points
+
+wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   
+
+# Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription 
+opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg
+#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended
+  
+# Extract desired cross sections from the database
+cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)
+
+# Example: seperate H2O cross section, and print to terminal
+H2O_cross_section = cross_sections[np.where(chemical_species=='H2O')[0][0],:]    # Format: np array(N_wl) / Units: (m^2 / molecule)
+print (H2O_cross_section)
+
+# Plot cross sections
+plot_opacity(chemical_species, cross_sections, P, T, wl)
+

From 28f17f109d16734ccc940b1ca6fcc66ef9ea47df Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Wed, 28 Nov 2018 11:05:04 -0500
Subject: [PATCH 03/20] Can be imported without executing plotting example

---
 gas_opac/opacity_demo.py | 54 +++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 25 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index ff282bb..9ba3b5f 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -367,32 +367,36 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
 
 
 #***** Begin main program ***** 
-    
-# Specify which molecules you want to extract from the database (full list available in the readme)
-chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])
-
-# At what temperature and pressure do you desire the cross sections?
-P = 1.0e-3    # Pressure (bar)
-T = 1000.0    # Temperature (K)        
-
-# Specify wavelength grid to extract cross section onto
-wl_min = 0.4  # Minimum wavelength of grid (micron)
-wl_max = 5.0  # Maximum wavelength of grid (micron)
-N_wl = 1000   # Number of wavelength points
 
-wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   
-
-# Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription 
-opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg
-#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended
-  
-# Extract desired cross sections from the database
-cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)
+# This code will execute if you run the script from the terminal
+# Otherwise, no
+if __name__ == '__main__':
+    # Specify which molecules you want to extract from the database (full list available in the readme)
+    chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])
+    
+    # At what temperature and pressure do you desire the cross sections?
+    P = 1.0e-3    # Pressure (bar)
+    T = 1000.0    # Temperature (K)        
 
-# Example: seperate H2O cross section, and print to terminal
-H2O_cross_section = cross_sections[np.where(chemical_species=='H2O')[0][0],:]    # Format: np array(N_wl) / Units: (m^2 / molecule)
-print (H2O_cross_section)
+    # Specify wavelength grid to extract cross section onto
+    wl_min = 0.4  # Minimum wavelength of grid (micron)
+    wl_max = 5.0  # Maximum wavelength of grid (micron)
+    N_wl = 1000   # Number of wavelength points
 
-# Plot cross sections
-plot_opacity(chemical_species, cross_sections, P, T, wl)
+    wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   
+    
+    # Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription 
+    opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg
+    #opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended
+    
+    # Extract desired cross sections from the database
+    cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)
+    
+    # Example: seperate H2O cross section, and print to terminal
+    H2O_cross_section = cross_sections[np.where(chemical_species=='H2O')[0][0],:]    # Format: np array(N_wl) / Units: (m^2 / molecule)
+    #print (H2O_cross_section)
+    
+    # Plot cross sections
+    plot_opacity(chemical_species, cross_sections, P, T, wl)
+    
 

From f702578dd721007c4ac3979d6548adbe542919af Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Wed, 28 Nov 2018 11:06:30 -0500
Subject: [PATCH 04/20] Can grab gas opacities in jupyter notebook

---
 notebooks/test_gas_opac.ipynb | 153 ++++++++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 notebooks/test_gas_opac.ipynb

diff --git a/notebooks/test_gas_opac.ipynb b/notebooks/test_gas_opac.ipynb
new file mode 100644
index 0000000..a81f9ea
--- /dev/null
+++ b/notebooks/test_gas_opac.ipynb
@@ -0,0 +1,153 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import h5py\n",
+    "from scipy.ndimage import gaussian_filter1d as gauss_conv\n",
+    "from numba.decorators import jit\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.ticker import MultipleLocator, FormatStrFormatter\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/liac/python-lib/chandra_psf:/home/liac/dev/cloudacademyMap:/home/liac/dev/cloudacademyMap/gas_opac\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(os.environ['PYTHONPATH'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/liac/dev/cloudacademyMap/gas_opac\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd ~/dev/cloudacademyMap/gas_opac/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import opacity_demo as demo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Now reading in cross sections\n",
+      "H2O done\n",
+      "CH4 done\n",
+      "NH3 done\n",
+      "HCN done\n",
+      "CO done\n",
+      "CO2 done\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAETCAYAAAB0nQK/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzsnWd4VNXWgN89NZNMei+QEDqhExAVRWnCpYhiw95RsWD77IVrxXLFAlewgHoV7AgoCigISO+hJKEFCOm9Tabu78eEQEibTCYk6Hmf5zww++yy9snMWbusvZaQUqKgoKCgoNBaqFpbAAUFBQWFfzaKIlJQUFBQaFUURaSgoKCg0KooikhBQUFBoVVRFJGCgoKCQquiKCIFBQUFhVZFUUQKCgoKCq2KoogUFBQUFFoVRREpKCgoKLQqmtYWoK0REhIi4+LiWlsMBQUFhXOKbdu25UkpQ90pqyiiM4iLi2Pr1q2tLYbC35hLLrmEnj178sEHH7S2KAoKHkMIcdTdssrSXAMIIRq8br31Vo+0s2bNGiZMmEB0dDRCCObPn19nvtmzZ9OhQwe8vLwYMGAAa9eubbE8TS1z6623Mm7cuBppS5cuxdvbm2eeeabeem+99dbq56nVaomPj+exxx6jvLy8UZmagqvP+EzceVYKCgpN42+liIQQ8UKIT4QQ352W1l4IsVgI8akQ4smm1JeZmVl9ffTRR7XS3n33XY/IXVZWRs+ePXn33XcxGAx15vn666956KGHePrpp9mxYwcXXHABY8aM4dixYx7P407bZ/LFF18wadIkXnvtNV555ZUG+z9ixAgyMzM5fPgwL7/8MrNnz+axxx5rsExTceUZn4k7/W5NLBZLa4ugoOAeUso2cQGfAjnAnjPSRwMpwEHgSRfr+u60/48AplT9//PGyg4YMEDWxbfffiudj6tl8fHxkfPmzauVPmjQIHnnnXfWSOvUqZN88sknPZ7HnbZvueUWOXbsWCmllDNnzpQ6nU5+/vnn9dZZV7mT3HnnnTIiIqLRsu5S3zM+E1f6PXToUHnPPffIRx55RAYGBsqQkBA5c+ZMWVlZKe+77z7p7+8v27VrV+NZDB06VE6ZMkU++OCDMiAgQAYEBMjHHntM2u326jzLli2TQ4YMkQEBATIwMFCOGjVK7tu3r4YsJ9t+9NFHZUhIiExMTHTziSgoNB9gq3Tz/d+WZkTzcSqdaoQQamAWMAboAUwWQvQQQvQSQiw94wqrp94dwHVCiD+AVS0oP6+++ipGo7HBy52lHYvFwrZt2xg1alSN9FGjRrF+/XqP5nGn7dN57rnneOqpp/jhhx+46aabmtbRKgwGA1artVZ6Sz3fumhKv7/88kt8fX3ZtGkTTz75JNOmTWPixIl06dKFrVu3csstt3DnnXeSkZFRo4zD4WDDhg3MmTOHuXPnMnPmzOr75eXlTJs2jc2bN7N69Wr8/f0ZP358rVnP//73P6SUrF27ls8//9wjfVdQONu0GWMFKeUaIUTcGcmDgINSysMAQoiFwOVSyteAcbjGbcALVfV/B8zzkMi1uOeee7jmmmsazBMdHd3kevPy8rDb7YSHh9dIDw8PZ+XKlR7N407bJ1mxYgU///wzS5cuZezYsU3uJ8DmzZv56quvGD58eK17LfV866Ip/U5ISODFF18E4JFHHuH1119Hq9Xy0EMPAfD8888zY8YM1q9fz1VXXQVAZGQk7733HkIIunXrRmpqKv/5z3945JFHAJg0aVKNNubNm4efnx+bN29myJAh1ekdOnTg7bff9kifFTzL/Pnz6du3L3379mXatGmEh4djMpkIDQ3lgQceYMaMGWi1WvLz87n++utJSEhoE3L27duX3NxcpJSMHj2aJ554gttvv52rr76aadOm1RgweYo2o4jqIRo4ftrndOC8+jILIYKBV4B+QoinqhTWr8CLQojrgbR6yt0N3A3Qvn17t4UNCgoiKCjI7fKNIYSo8VlKWSvNU3ncabtnz54UFxczffp0LrzwQgICAhqs8yS//vorRqMRm82G1Wrl8ssv5/3336+Vr6Wfb1240u/evXvXyB8WFkavXr2q07RaLYGBgeTk5FSnDR48uEY9559/Ps899xwlJSX4+flx6NAhnnvuOTZt2kRubi4OhwOHw1Frf2rAgAEe6adCy/Dll1+yevVq9u3bx8yZMykqKmL69OkkJyfj6+vLfffdh91u57HHHuOdd95pdTn37t2Lj49PjX3drl27smbNGrcHl67Q1hVRXW/HekPKSinzgXvOSNsDXNVQI1LKucBcgMTERLdD1r766qu8+uqrDeZZtmwZF110UZPqDQkJQa1Wk5WVVSM9JyenesTuqTzutH2SyMhIFi9ezLBhwxgxYgQrVqwgMDCw0f5dfPHFzJ07F61WS1RUFFqtts58LfV866Ip/T5T3pMWgGemORwOl9sfP3480dHRzJkzh+joaDQaDT169Ki1NOfj4+NynQquM+y+phuk/DG79iD2hhtuoG/fvqSlpVFQUMC///1vnn/+ebKzsz0hJnzV8ACyTq6v/Yo7KeeePXvqHJQ+/PDDHjPOqou2rojSgXanfY4BMurJ2+q01NKRTqdjwIABrFixgquvvro6fcWKFdVLOJ7K407bZ/Zv9erVDBs2jOHDh7NixQqCg4Mb7J+3tzedOnVq9DmczaU5d55VU9i0aVON2dXGjRuJiorCz8+P/Px89u/fz6xZs7j00ksB2L59OzabrdntKrhGXUqluYwePZrLL7+cFStWcO2117Jo0SLefvttCgoKuPPOO92rtA6l0hyMRiPx8fG89dZbOBwORo92btvHx8efNP5qGdy1cmiJC4jjNKs5nIryMNAB0AG7gISWlKE1rOZKS0vljh075I4dO6TBYJDTp0+XO3bskEePHq3Os3DhQqnVauVHH30k9+3bJx988EHp4+Mj09LSPJ7n/fffl127dm1SmTOt37KysmRCQoLs3bu3zM3NrbfvdVnNtQSNPeMz+yyla/0eOnSonDp1ao1yCQkJ8oUXXqiRFh4eLt9///3qMkajUT744IMyOTlZfvvtt9Lf31+++eabUkop7Xa7DAkJkZMnT5YHDhyQq1evlgMHDpQajaaGtV9dbSsotBY0w2qu1ZVPtSCwAMgErDhnQndUpf8LSAUOAc+0tBytoYhWrVolcS451rhuueWWGvlmzZolY2NjpU6nk/3795d//vlnrbo8keeFF16o1dfGytSlUHJycmTv3r1lz549ZXZ2dp19P1uKqLFnXFefpWy83+4qoilTpsipU6dKf39/GRAQIB955BFps9mq8//+++8yISFB6vV6mZCQIH/99ddaZueKIlJoSzRHEQlneYWTJCYmSsXFj4KCgkLTEEJsk1ImulO2LZ0jUlBQUFD4B9LWjRUUFBQUzkkyMzOZNWsWwcHB6HQ6oqOjmThxIi+++CLTpk3D39+fxx9/nJiYGKZNm9Zm5Dx27BiRkZFkZmby/PPPnxXLTEURKSgoKLQAs2bN4sknn8RoNLJ69Wq++OIL0tLS2LhxY/X9q666qvpzW5Dzww8/5JZbbqFHjx7s27ePL774gnvuuafxSpqJoogUFBQUzmC6mN7kMi/IF2p8lrLm4efx48czceJEioqKcDgcHDhwgJycHJKSkrj33nvR6/VNbrOxg+h1caZdwOlytpbNgKKIFBQUFM7gTKXiDlOnTuW1116rsTR3EpVKxbvvvktaWhqLFi1ySwmBZxTH6XKqVCrmzZtHdHR09dLc2UCxmjsDxWpOQUFBoekoVnMKCgoKCucsiiJSUFBQUGhVFEWkoKCgoNCqKIpIQUFBQaFVUazmFBQUFFqA+fPns2TJEr7//vvqA6szZ86stpQbOXIkv/32GwcOHOCll14iJCSkVeRs7EDrqlWr2LNnD6mpqcyZM6feMC3NQVFECgoKCmdwKLTpMa065tYOU9+zZ0+WLl3qrPPQIWbOnElBQQFBQUEkJCSwc+dO1q5d6/bLffp0N847vVDTNN2VA63jxo3j/vvvx2KxKIpIQUFB4WxQl1JxhyuuuIKPPvoIKSUdO3Zk2rRp1TMicAakKy4uZseOHfj5+dG/f/8m1X+mUnEHVw60vvvuu0yYMKHF3P0oikhBQUGhBXnggQe47LLLuOKKK2qkL1u2jI0bN7JlyxYCAgI4fvw4/fr1c8tbQnNo7EDrW2+9xbZt25BSMnDgQJeiLjcV5UDrGSgHWhUUFM4GFouFt99+G19fXwoKCvDz8+O2224jPT2dhISE1havySgHWhUUFNokUkpslUqI87qoqKjA4XAQHx+Pv78/fn5+fP3116SkpLS2aGcdRREpKCi0GKlLUvnptp9aW4w2SUVFBZdccgljxoxhyJAh3HbbbUycOJGDBw8ye/ZsioqKWs0J6dlGUUQKCgotRtHRIvQB7jn0/DtTWVlJSkoKsbGxCCEYMGAAQgjCwsJ46KGHiI6OZtu2bfz00084HI7WFrfFURSRgoJCi2Eps6D3UxTRmSxatIjk5GSCg4Nr3dPr9UyYMIHy8nKKi4vJyclpBQnPLooiUlBQaDFslTZ8I30xFZhaW5Q2RUREBLfddhsGg6HO+0IILrjgAiZPnszSpUv/9kt0iiJSUFBoUYI6B5F/IL+1xWhzeHl5NXg/JCQEnU5Hnz59KCgoOEtStQ6KIlJQUGgxhBAEdQqi4ODf+0XaFNatW0dFRYXL+ePi4vj9998pLS1tQalaF0URKSgotBhSSgI7BFJ0pKi1RWkzlJaWEhoa6nL+0NBQxo0bx65du1pQqtZFUUQKCgothwS1To3dYm9tSdoEUkq8vLwYOHBgk8p5e3tjs9lIT09vIclaF7dd/AghegGDgAjACygAUoH1UspCz4inoKCg8PehvLwco9HoVtmhQ4eycuVKYmJiPCxV69MkRSSEiAfuBW4AwgEHUASYgQDAG3AIIf4EPga+llL+/Y3gFRQUamGtsKL19ryn5nOZk5633UEIgb+/Pxs2bOD888/3sGSti8tLc0KIj4G9QF/g30A/wEtKGSqljJFSGoEwYDyQBLwB7BdCDPG82AoKCm0dS7kFna8OAK9AL8WEm+YpIoDExMQmGTqcKzRlj6gS6CalHCml/FBKuVtKWWPhV0qZJ6VcJqWcBsQCzwPRHpRXQUHhHMFWaUPj5Vx0Ce4cTMEhxXKuqKgIf39/t8urVCrCw8NJSkryoFStj8uKSEp5v5TyaBPyO6SUX0spv3ZPNAUFhXOZ0xVRUKcgCg78sxWRxWIhPT0dlap5NmI9e/YkPT2dI0eOeEiy1kexmlNQUGgRTldEAR0CKDzyz7Zh2r17N8OGDfNIXcOHD+fEiRMeqast4JIiEkJcIYR4UAjR9Yz0+1tGLAUFhXOd0xWRRq/5x5twl5aWEhUV5ZG6dDodVqvVI3W1BRpVREKI14GHgE7ACiHEtNNu395SgikoKLRdUhan8Mdzf5CdlF1vHrvZXq2IFPB45FW73Y7N9veI9eTKjGgsMEJK+SBOS7kJQog3q+6d3Zi2jSCEmCiE+EgI8ZMQYlRVmo8Q4rOq9BtaW0YFhXMdq8nKjk928NeMv/hq7Ffk7sut0ynn6TOifzoOh8Pjiqh///5s2LDBo3W2Fq4oIpWU0gYgpcwHRgNxQohPXCzvEkKIT4UQOUKIPWekjxZCpAghDgohnmyoDinlIinlXcCtwLVVyVcC31WlT/CUvAoK/1QytmSQsjgFh9VByfESvhj5Bb89/Bs2c83ReV2KqE6FZf57jOobwmQy1etp212CgoKw2Wx/iyU6VxRJphCi/8kPUkoLzpe8BHp6UJb5OJVcNUIINTALGAP0ACYLIXoIIXoJIZaecYWdVvTZqnIAMcDxqv//sxepFRSaid1iZ8N/NhA/Ip7I/pHo/fSUZpSy+YPNtRybnqmIDIEG8pLzauSpLK5k+aPLz4rsrUl5eTk+Pj4er7dz584cOnTI4/WebVxRRLcCGacnVJlm3wlc5ClBpJRrcLoJOp1BwEEp5eEqBbgQuFxKmSSlHHfGlSOczACWSSm3V9WRjlMZgWIlqKDgNmXZZczpN4dLX7qUG5bdwJVfXsm4OeMYcM8ApF3Wcmx6piLqfWNvds7fWSPP0ruXkr07m3Uz1lGUVoTVdO6P7uuipRRRREQEa9euPefjFTW6gCulbMjLXr4QYhhOX3NnlvulOYJVEc2p2Qw4lcp5DeR/ABgB+AshOkkpPwR+AD4QQowFltRVSAhxN3A3QPv27T0gtoLC348dn+5g9LujCe8VDkBItxBCuoUQ2iOUnN05LBi/gBfkC9X5K4sr0fueis7qHeKNxkvDkVVHCO4cTNJXSez9Zi/xI+PZ8NYG9n2zj/A+4eQl53Htj9ciHZKyrDJ8I30xRrjnn62tUF5eTnh4uMfr1Wg0dO/enaKiIgIDAz1e/9nCrZ3EKoenC4Du1G2wIAF1M+SqbqqeuutESvke8N4ZaeXAbQ01IqWcC8wFSExMPLeHFgoKTcRhMqMyNBzOO3N7Jn/N+ItHMx6tdS+8dzjjPx5P3v48khcl021iNwAqcivwDvGukXfjOxspPFTIgCkDKM8t55ofrsFmspEakkpZVhkpi1Mw5ZtYOmUpUYlR5O7NpdeNvegytovnOtwKtNSMCKBHjx4cOXLkn6eIgE8BKzAOOAhYPCZRTdKBdqd9juGMZUIFBYXmUfjGJwQ8dBPqAN9683x9xdck3ptYrxPT0O6hhHYPZcmUJXQZ3wWVWoWUEqGqOZa8Y8MdfHL+J2TtzCL24li6X9EdAL8YP3yjfbFV2lh0yyLSN6RTcrwEU6GJ8L7hxF4cW2N2da7REsYKJwkMDOTjjz+mT58+qNWeGP+ffdxVRN2BSVLK3zwpTB1sAToLIToAJ4DrgOtbuE0FhX8U9txCrAePoU5MqDdP+yHtCesZVu/9k7Q7vx0HfjlA1/FdkY7aiwthCWGEdAshY0sGKs2pLdvYi2NrtJWTlEPmjkwqCyvZ/pFzu7fvrX0xhp97S3RSSsrLyz1uvn0SIQRjx44lPz+fsLDG/0ZtEXc37zcDHt1MEUIsADYAXYUQ6UKIO6rMxu8HfgP2A99IKfd6sl0FhX860mLFmla/u5jCI4UEdgqk9w29G62r9029SVmcgrXCWms2dJKrFl7FkKeHcOfGO+u8P+rtUQx5agjtL2yPXzs/tN5atv53Kyc2nZsubdLS0jh48GCLthETE8PRoy67Am1zuDsjuhtYIISoAFbhjElUAyllk3yVSykn15P+C+AJwwcFBYU6UAX6Yy8oqff+wgkLaX+Ra+NOlVpF9q5svr3mW4a+MLTOPIHxgQx/ZXiDdcSPiMcrwIvI/pGkLE5h25xtFB4uxG61o9aeW8tPhw8f5oEHHmjRNvz9/SkuLm7RNloSdxVRHpAGfN5AnnPr26Kg8A9FHeiLo6S0znvFx4px2B2MeX+My/VNnD+RkG4h9c6IXCUq0emXrdvEbsReHMvM2Jn4x/pX7yudK6jV6mZ73HaFk8qoOWEmWgt3FdH/gPOBt2hZYwUFBYWWRqUCe92BlNNWp9FtYjdUatdfpKE9Qj0lWTWGIAO3rLqF5Y8tp8vYLqh1yjj3TLp3705SUtI5Gb3VXUV0KXCXlPIrTwqjoKBQP2VlZXh7e3t0dC0dDhCiTkVkq7RxYssJxrzn+myoJYlKjGLcnHH88sAvjJ09tknK8Z+A0WikvLy8tcVwC3f/kmnA3y9erYJCGyU5OZn58+ezffv2xjM3AVluQmU0IB2OWqfzc/fn0mFYhxaz9nKHkK4h9L2lL8k/Jp/z3gRaAl9fX0pL615mbcu4q4geB54RQsR5ThQFBYX6yMvL47rrriM/P5+ysjKP1WsvLkPl54smOgx7dn6Ne7s+24VftJ/H2vIU7S5ox67PdrHvu32tLUqbo2vXrqSkpLS2GE3GXUU0Haf5dqoQIlUIsfnMy4MyKii0WYqPFWMuNVd/tltbxq9uWVkZISEhDBo0iJ9//hmLxTPbso7iUlT+RrTxMVgPHa9xb9O7m/CNrv+Qa2ty7aJr+W1abY/f/3QCAgLOSes5dxXRHpwm1V8CfwF767gUFP72rH9rPb8//TvSIclOymbNy2s83kZycjLBwcGA8xT9wIED2bZtm0fqdhSdVETtsB45dU7HXGIm4ZqENuvjTaVWMWnBJH5/6vfWFqXNYTAYzrm9IreMFaSUDfpuU1D4JyClRO+vJ6xnGNlJ2aQuSaUi1/Nbp+vWrWPSpEnVn+Pj40lLS3O7PtP6nXgN7o1QqXCUlKGJDkcTFUruwzMwXjUSlZeeHZ/uYOgLQ9u0QUDsxbFkJ2WTsyfHJa8PrUFr7GN169aN1NRU+vXrd9bbdpe2+y1TUGijbJvrPFx54OcDRA2IIvbiWA6vOIzD5sAQbPD4y6djx451OrR0OOo2uW6Mki9/xnrY6VTfXlyGyt+IUKnQD+yJNSUNgIqcfAK8zEh72w7h1XlMZ9a+upbiY21vOcput7Nx48az7v8tMDCQ9PT0c8qYwy1FJIToI4T4Vz33/iWEaNwXiILCOUhech6lGaUkfZVExrYMuozvgm+kL6YCE1JKAmIDKD7quZei3W6v80VmNBr5+uuva7xsij/5AYCcnJzqtNIfV1LxxybKf12HeZ8zgJrQaSh4eQ6l36/AUVyGyt+5DxT06JXk3HwdeWv20tv+EjnTnsO8OxVZUDOGUFsiMD6Q8XPH89cbf5G1K6u1xamB1Wpl+fLlLeZ1uz6EELRv3578/PzGM7cR3J0RvUP9cYEGVt1XUPjbsXP+TgZPG4zdYnfGy/l6GQDBXYNBQtTAKE5s8ZxPtMrKSry8aoX7IioqitTUVIqLi8l/9SOs6dnkv/Qh+R9/xw+ffkbukj8o/O9CCt+YR+Hbn5H/7w/JffA1jl9yG+rQILyHD6bi941Y9hxA5esM1aANdeA7JgLV4hvx6uIL5ixy73sY08c3eaw/blO4u95bOqOOwI6B/DK1bXkCOzlj9fM7+5aHsbGx55TvOXcVUX+cRgp1sQE4dxYnFRRcID81n2UPLaNjQCEaS4UzUpbdTsFrH+MoN9Hpsk5ED4omrGcYJza3vCKKiYlh0qRJ5Bw/gWn1FtJH3IGuVxd+Td1DidnEN2t+Z+fmrei6x1cdWLWj7RKL8aqRqIP88btpPEFP3YX/XVchqmZc2uggAm69DNERvDsYiHz9fCJf6YfGOwfpcGDLzsf01w6P9a1JpP2vwduxF8Xi5e/F7v/Vr7DONvaqZU1f37NveRgQEEBRUS0XoG0Wdz0rqIH65ps+gM7NehUUmo0tI4eC1z9B36sz/ndd5XY9uftyq93VbPtoG6PeHkXB0zMpfGsefkcdWC0S/zuupOyHlfhOHkOXcc7gbf7t/cnalUVwl2C0hrrj97iK2WyuUxGBc+9o68pVhBcVEfLDO2zfupWeeh+uvmI0OcfS2b59O5X7swgadh6+N4zFlpaBys8HR6nToELbLgLaRZyq0F4JtjK8DJmoCIH8VaiCE5EhJoqeug17YRGVaeFEff8OKt+zu9yEteFDmlGJUQx5agirnltFzOAY/Nr5odG7+3rzDA6HAx8fH0JDPe/yyBW0Wi1msxm9vu3HcXJ3RrSFqtDadXA3sNXNehUU3Ma0YRe5//cfimYtxPfa0djznCNCc9IBKncmN6kuKSWzE2Zjt9gpOFhAYHwg5d8tx2f0EEJefQi/IDXq40fxv+NKzDuTKXr3y+qyg6YO4uCvB5l30Tx+e7R5IbvqmxEB2H9dT96Kv9hy63CW7dhMrhYSJv0LnU5HTKd4pF5L1mWJ+N04DiEE2g7RqIMD0MZF1d2Yw4w0F6DTFIPGCBXHoTIHvMNR2zehC8nCejSD3MffxnYim4o/t2IvPkun+G2Nt9N+SHtGzBjB99d/z3fXfncWhGoYu93OyJEjz4rD07ro3r07yclN+963Fu4OGV4EVgohNgGfAVlAJHAz0AcY6RHpFBRcxJx0gIrlfxH6xiPVaaYNO8m87nHUUaE4Ckrwu3k83sPq29qsSUVuBe0vak9eSh57v97LoHFh2JPN1eUjbhqBl58XKl8fgqdPJefB18h/ZS7a9pH4XjuaIU8ModfkXuz9Zi/5qfkEdwl2q19lZWVERdVWHNJswZx0gInv/BsHTg/PUsoa7njGjx/P6tWrXW/MbsZWeBSLbI+PTywU7oTY6xFhF2MonYu686VYS3ZT+ucOch9/G8uBY/jfPhF1cAC+14x2q3+uy2YChw1UDb+yogdFc+emO1nz8hqyd2cT3ju8ZeVqAIfD0WpKCCA0NJRdu3a1WvtNwa2nJKVcA4wCHMD7wHfAu4ANGCmlXOsxCRUUXKBs8SqCnp1SIy3osdsImfEwIa88RNgHT2PekYztRLZL9RUfL6brhK6kLE7BEGzA8tdW/CafMhQ1nt+L6Oedx+lURm9C334cW0YOec+9T9ZtzwLOJbpBDwxi3evrsJS55wmhuLiYgICAGmnS4aB85UZ8/nURQq2utqo70yfcyZegS2a81hKwV2LNTUMEJIBXBEw4BFGXQegQtAFlqOyZBI3JJvipKwh6dgq6Tu0onPk/zHsP4aiodKt/LuOwOZWRCwgh6DiyI2tfXUvan2nk7M0hP/XsW5DVZ/F4NtHr9Vit1laVwRXcVtdSytVSyvMBX6Ad4CelvFBRQgpnG1llnSTq+NFrY6NQGfSojN743TaR0u9WuFSn6dd1RPcKJO277XTpZ6TsuxUI/amtTyEEKh9D9Wd1oB+hbzxKxKcvYc8rpGSB04JLo9fQ/67+7PzMPRNom82GRlNzFlDyxRLynnwH/YAejZbv2LEjO3e60PZ3weAwo7YcxavLcDBEgah6PRg7gjYADFGIfq/iO6gSfQdvwj99GcOF/Shd8AtH4kfjKG3B0/zSdUUEEDM4homfTeSnW3/i0ws+5afbf2o52eqhtWdE4JwVHT58uFVlcIVmPyUpZYWU8kRTI7Iq/D2x5xVStnjVWW2zYuUGvIcmNppPHeSPo6QMaa3fP5mUksqte7F//xOOF19leNxhKt+ZS+BjtzZav8rHgPew8wh6+m530O07AAAgAElEQVQq/9qB5dAxAKIHRpO2Ks0tP3R1eb52FJcR9eO7LnnFjo2NpaCgoOFMJQecL/q8DVRYolG1uxw6nGayrdJA9HjoNR0iR8G+GbDlXlQGPWHvPUX0z7PxvmQgZYtXY8vKa5lDsE2YEZ1Eo9dwy6pbeOjIQ7S7sB17vt5zVg95toUZUXx8PMnJydUWfG0VlxWREOImIUSTnqoQopMQ4qKmi6VwrmLelUrZoj/O6on8yq378LrQtRMDPqOHUL58fb33zdv3kf/yHIon3ULYT7MxDOpNyOsP4zvJ9W1P76GJhM58gsIZn5J1x/OYN+7kkmcvYMsT37tcR304TGbsOfnoOrkWuhuch18bDA2w7UGncULqB6QV3F41GzpDySU8CWqdMz32OvDvBYc/R2X0Rtc5lpA3HqHg9Y8pnPkFOQ++7mbvGkDaoCLDuYTYBALiAjAEGRg5YyTZu7NZfPvis6aM2sKMSKfT0bFjxzZ/uLUpT+lR4JAQ4iUhRJ/6MgkhgoUQNwghlgA7cBoxKPyNseUUkPfsewCYk1Lxu2Echf9pKIq8ZxEq4XLMHH1iApXrd9b7MrLsPUT4rGcot+rwDjES9NSd6LvHN10mjYbwuS9ivPxSsu9+Efsb7+GzdgWHP2ueU9TyX9eijYtuUpl6fdNJCVsfgJIUp3IBRGDvU0ty9dHnFbDkw/Zp1Una9pHE7voeoVZj3tYCPo+lDbJWQoH78ZiGvTyMwsOFbHpvEzazDUt51b5d0R4PCVmTtjAjAoiOjub48eONZ2xFXFZEUsq+wBM4o7PuEEKUCCE2CSF+FkL8IIT4QwhxBMjBabhwCOgmpfymRSRXaDPYjmViWr8Ty6Fj2ItK8B5+HkKjxnKg5U9223ILUQcHNJ6xCiEEXoN7Y95Vd8wW24kc1FFhSIdEqJofEM444VLCZj+HcdJI4uc9TfnbH2PLaWSprAHsuUUYrxjepDIhISFkZmbWvlG0CwL7gX930Dl92fW8foBrlepDIGxojSShUuE96gIMF/WnYvWWJsnYKA4bWAqbvDx3OkIIxn80ntTFqczqNou1r1RtZx+YDYc+BYdnN/XbiiIKDAxsfHm2lWnSvFFK+bWUcgjQGWdwvJ04LeV8gGycptyjgUgp5TQppeeOmCu0WWwncgh8+GbyX/wv2hjnAUnjVaMo/aZ5Z2hcoXLTbvQDezapjPeI86lYsaHOeydNoD25fON9yUB8J43Ep2cHUiIvJnP2IrfqcVRUkv/Mu6iC/JtUTgiBl5cXJtMZL/GKE+DfE3q9CJ2mcCTvZjTeLh5U7fEE6IPh0Lwayd5DE0Gtpui/X1PxpwePE6r1YCkAW/O2ooO7BHPhExdy4283UllcSfKiZEoP7oWi3c2u+0zawtLcSWJiYjh69CiHDx9uk85Q3TXfPiSlnCOlnCKlvFxKeZmUcrKU8kUp5QopZdu3F1TwGLbMHAwXDyDyi9fwv9MZrkDbLgJ1cAC2jJxGSjcP8+5U9H26NqmMyqBHVppr/SDtBcWoA32xW+2otS0zkp3w/c3krdmPeXdqrXvSbq93JiHNFio37MJ71AVuhe6Oi4sjPT29ZqIpEwwREDwQaYwnLf9WULnYb40PmPPhxOJat0JefoCor9+i8K35npsVq7ycMyJLIax131sGQMdRHQnuEszYWWPJ2JqBoziN8vQTUH4Uu8VzgfbayowInJFbDx8+zO7du6msbGFTezdoG+pa4ZzGUVyGyq92ADXfa0dT+vWvLdp2U/aHTkfbIQbb8ZremitWbcZwcSL5KflOJ6YtgM6owzbpanI+WlLrni09m8KZX9RZruR/Syl853MiPn/VrXajoqJqL89VZoGX88Bn7t5cAuNrh5pokIt+cCqkvTVlElXm5r6Tx5Dz0OtYko+4JXMNNAbnjCh7FZgyml9fFcNeHoZvYCmW/BOUfT+G1bdNxZR+yCN1t6UZkUqlwuFwUFBQQEVF2zNwbhtPSeGcpy5loA70a/Sg4+4v3XdSKc0WhNY9X26Gi/pTNGthjTTLvkPoenQkO6llT+QPmJJIepYK07q/nHsfJ9s/cAyhrdtzgD2ngKif3qvzrJQraDQabLbTRvu2Cig94FzyApIWJNFrcq+mVSoEDJoLtrrPD/ldP5aIz16l/Oc1WI82U3moDc7ZUHma06rPg6i0egJDclCF9KFrjz+wbniQvJQ8HHb34j2dpC3NiMC5PKdWqyktLa29TNvKKIpIoUXRhAU1uDn/440/unW+BsCSfARd9w5uldXGRqHtEIUtKw8AR6UZ4aVHCEHu3lyCO7fMjAhApVHhGDAAku6ChVrMJWZ2zt9JwcYD6Ht2wl5Y00TZejTDuXfVzJeaWq0+dco+c7nTUKEKIQRqnRv1a7zBbob02jM8AE1oIAhB7qNv1rkc6TInFZEpE3SuG6e4hCECyo/g7Q9eE5ZzYGMAm/+zjIwFz5O+Mb3x8vVgs9nalCLq2rUrI0eOZP/+/SxcuLDxAi5iLyrFerx5saAURaTQongN6kXl5qR674d0CyE/JZ9Dyw81eRO1Ys1WvM7v67ZsxonDKVv0BwCmPzbhfekgpJRIKVFpWvCnkb6EwY9eiKVqVPrzfT+Tl5JH1poUjFeMoOzH3wGn4YQ9t4DieT8S+OANDVaZW2Qjt7D+/Y0jGRY6d+7MgQMHnAlFSdD5XgBKM0oxRtReWnWZ3v+GgvoNEwIfuZmw/z5P6XfLq71gNBm1wTmLM+c4vTx4CofNWZ90gL2CkF4d6D/tGsZc8QH+5R+x+8vdWE3ubXmXl5djNDbjubYAYWFhpKSk1HIb5S62nAKybnySove/bDxzAyiKSKFZSLsd1PV/jXQ9O1G5tf5zGoEdAyk4WMDyx5aTuy+3aW2XmVAHuh90TBMRgj3b6Qmgcvt+9AN6cGLzCSL6RjReuDnkrEadvhD/iDQADi/YxOApfVCrBeou8eStT0FKic1mw3Ekg6DHbkNl9G6wyrQMK2mZzhem1SbZllxzSfTXDeVEREScit7qsFQvy23/ZDu9bmjistzpaLyBhgcRmtBAjJdfSu4jb7jXhtoLHJXOZUBNw8/CFWyZzu+a6a/NEHI+nPdJtdWc8O0IlQX4hITSf5Jgw9S7WTf2dSqO59Woo7HlxrrcM7U2Go2GXr164efnh5Sy2jv3hg11W5E2hJSSog++onLT7mbvAzZLEQkhugghhlWFB69xNUsqhXMGe04BmrD6l7GEWo3a14jDZK5Os5mdI3drhZWwnmGsf2s9/W7vR+HhwhaX90yMV40i9+E30MZFI4QgeVEy3a/s3rKN2sog9b3qj9cOPY7pg8/wDjGw4v9WcHi/mfTLplC6fifqkopGlRA4lY/F5lQGV/5fOhuSau4BlFU4cEjhjBpavL/aSAHAYXVgCDTQLHRBUNiwp2evAQloY6MomrWg6fWrvZzxktTezrYOu3dg2pKaRvnKjRTNWkDpD79RMnsWtiKV03LQXOqclQf0xBS0gIrsEUTk3UDv/rkEb/ud9G82IB2OakvAwrfmI82Wei0D26KZNMDw4cPR6XRs3ryZlStXArB8+XKXytqy88l5eAaF73xOzpTpOMoq8JlwKaH/+b9myeSWIhJC9BBCJAH7gZXA0jOuuheMFf522DJyUEc2HPjLe8wQyqv8z0kpmdt/LoWHCynLLiOkWwiR/SPpdX0vFk5YSF5KnksOQu35RaiaMRs6iT6hE77Xj8X3hrE4bA7UWjWqBmZ4HsFaApGXOZ2JAlGP29CGmwmJ96fD8A70/vAe8oZdRdaTb2OsOiNVaXFgtdX/YrPanBdAeaWktNxe40VYaZFUWpxnpBwlByHEGc7CYXc0e1MegK4PwrHGz657jx5C+YoNVKza3MQGqv4mk/Kcz23PdKdiAuyFJZQs+AVpseKoPDXgqfh9ExV/bsVRWk7xx99T+N6XVG7bhyUpFXteEXLTE4SP/wrTpv0UfPAbsugIFb+uo3jej9iOZWHaY8N0vCOavDQMYRLencnuS+4je9oblC9bS8XqLZh3pVD6zW9Iux17YQmmv3YgrTb27NmDXq9Hmi1U/LGpiX1teS644AKOHz9OXFwc4LSqq2HMUgdSSmwnsjGt24Fp3Xb8p1yN4YK+RHzy7ya5nKoLd+eNc3BGYb0S2Ae45+Ne4ZzHdiIHbSNfQn2PjpT94Bx5Ze/KpvdNvTnyxxFCe4TiE+7DmPfGIKVkwqcTWDplKeG9w+l5Xc8GI2xWbt+PV3/PzFwMg3sDkLEjg8j+LeyRqng/lB6CwL7Q7WFIX4xabca3124ccfcT0q0bAHsWqOh4+xXY49sBsC25El9vFb071R0kz2qTOCS89Klz+chkllhtoKsyKjSZHVgs0mnGfWIl0b2dhgr7v99fHVm2WQgVCDXYLU6fdPWg7x5P1I/vkv/8BwidFoOLPgIBmHDEacbtHQNlh6H8KA4RQ+5jb+EoKcNRUo5Qq/Aedh75r8x1Dn7UarwG90Yd4IdpjVMpabvG4Sgpx3hlGQDWPVspTQKfyRpyXn4NabNjHHsxpi25+N37FdZV84l9YgZC2KlUmdn13yHIjxdjz8oj8+anUXl7UbllD96XDMRRVkHBG59SdvsYeg5OdAYSfOwtAh660RlGRKtx67iBp1Gr1Vx55ZWsWbMGq9WKn58fFRUV+PnVHtxJKZHlJnIfeQNthxiCHrsVW1YeXgMS8BqQ4BF53FVE/YDrpJRLPSKFwjmLLSMXw8UueL4OC8Z6NIOja47T/87+LHtgGUvuWsIdG+8AnFZbva7vxYlNJ+gyvgvpG9MJiA3AK9ALrbe21gFTS9IB/O+91qN9OfLHEQbc7aKLG3fJ2+g0m9b6QfgwyN8CA2ej/sYHdXgc4PQRrPPVox5+ARpz1cvSKqkw1Z4RffBtIaPO88FqkxSVOdiy17kkZ7ZKrDaJTiv4ZHERlRaJ2SqJjY1l7dYcogc5l+aOrz/O6JkeCmrX4WY4+KFzdtQAQggC7rmGwne/RNc1DnWIK+eXJBjjnP81RIEuENPa37BZelC+eBXq0CBUfkb0PTuReeOTCC8dwdOn4igtx++2K1AH+FK+bB3mpFSCHr+N9CEj8OlyCKupCwF3DsUY8RRZt+jxHtENfZ9u6LrG4XvdGHTdOqDv9QqkJUDSdLysB7C3v5FlX+8jMSyUqGemYijLxXvkBZiTUrGmpKGJiaB8zVYyX56PLisfw8WJyHITBTM+wV5QjP/tV6Lv1bnZj7u5qFQqfH192b9/P8EGE6bSwjoVkWX/YbJufgp9ry5YDh3H/75rUfv7elQWdxXRIaDuoVkrIoSYCIwFwoBZUsrldaW1pox/NxzFpaj8G7cM8rv+XxTNXkhFeQcMwQaGvjAUKSWR/U7NQDR6DeM+HIe1wsp3136HIchARP8I1r22jkczH60xknRUmlEZ9B7rh5QSU4Gp+XsljTZkA3uF09u12st5abyh98uw+1no+SxofYkbGsfxrccJ6x8GgMUqsTscJB2spFfVrEhKyQ+rSklOMzNykA9pGRaiQrWkHrNQaXHuGfkAX/5aQpf2OmZ/X8jTtwSTnW8GlZaio0WePbjr28kZWtwFNNHheI8YzIlxU4lc8CaWA0fR9+mKJrw+eU797S0nTKgqwqhYuRhde2d8KW3n9gQ+eAP6Pl0RBi98LrsQYfRGVpjQhAUBYLz8UoyXXwpAzM+vw8oL0Vy1AuEbjU6lJur7dxA+3qgD6njJxl0Pxnj4fRiJb55Px6n9WHz3Zgz6cKwdOmOzexNyxQgKXvsYr8QeWDdsJOCm8fh2isV75AXYMnLIvPFJMFvRdY0DtQpd9/jWmx1ZS8FSSP+uoew7WkrfyEIqSnMoLg5g165dXHTRRchKC46CIkoXLkNoNPhOHoPPqAtbRBx3FdGjwBtCiO1SSo9EXRJCfAqMA3KklD1PSx+N04mqGvhYSlmvj3kp5SJgkRAiEHgLWF5XmifkVTiFKz8mldEbbWwUxoUbkRWDCe4azPi54+s8u6L11nLtomtRqVV8euGntB/SnuKjxQTEOU1OpcPh8R/wiU0naHd+O4/WWSfS5rRY0/g63daoq8ZzPZ9xmhDvfAIGziZqYBQbF28k+jynp22LDY6fsPDKvFIWvBzFjpRKhiU6/cIVlNjJyLORXWAnwKhCpYJKs4PlG8vxMTj3VlKPWcguULFjfzEVFjV7D1ew952tjH7hQg4ct9ApRuuZZ6r1hfKj4BPbaFafURdguKAvGZOmYc8pIGTGw2jqetFJCUJgPZpB6XfLqdy4G7WqB6GP9cGyZQnt/voOla8Pmqq9yoB7rjmtcN2zLYENhq1E+J9aVtZEN3KI2TsGIkagS36aML/uXP7V//HlmC8JiAsgqHMQl396OQH3T0YY9Bjjgwns2w+drw9CpUIbG0W7NZ8hhCDvhVnkPf429uJSQl9/GG3nWGzpWR5b5nKJLVOh4igiZy0JA94jU1/Ex98uo0PwEnz8wsi6+Rf0PTtTvmwNqDV4D++GJqblrEndVUSvAdFAshAiDSg6M4OUclAT65wPfABUm8NUxT+aBYwE0oEtQojFOJXSa2eUv11KeXI49mxVudOpK02hiVTkV2AIMpx6aTXBMsj32tFUrism/8VZBD58M6Ylf1K4YRfGSSMQBi8M5/epjnp60mBg1NujUGlVHN9wvFoRWQ+no+0Y49F+pSxOYegLQxvP2FxOenjWGp3m0yo9m/aaOC/BQJYpjOCitWgBtVaNxqihPKOcbaZKzBYHf+020b+rnv9+X+iMECsg0E9Fn85epB6zkFtkp2t7HQ4HHDhuRaetoG/nUwsXBr2gLCeZzJIQFszeTDuLii//rOSPrRXMejycsCAPmBpHjob8zS4pInAOUPT9uoME6yFnqALLwWMUzV6I4YK+GCeNpPSL7/GOKSPr/qfwGXMRQc/cjXlHEqoD1+DV/TLoEtd0OW0mp9JsCt4xMPBDyFmNKEkhrGcY045OY/FdiylNL+X4huMEdgjESwsOAdoqJXSSk7+ZkOlTyX/1I+xVFmia8BCk1Yr3iPPxGtwbw4X9ECoVtuz8BmaIzcBSBDl/gr3c+Xc6Mp9wrxgujA+iv+9GdqX7Y+yVjK1sNJGvJaAe/DhigQpHhyfqrM5hczT73J2737w9VZfHkFKuEULEnZE8CDh4ctYlhFgIXC6lfA3n7KkGwvmXfh1YJqXcXl+agnscW3eMpVOWcsUXVxDZPxJps0ETfWnZgsIIfuJych9/C32vzvjfew0Vv66jckcypV8uJeCB6/HqfyoEdszgGKRDkvLTqbAN5m370Cc2Hib7dPLy8rBYLERF1XYPU5ZdhleAV4PGER7jpEsfjW/10tzyTeWcl2Bgl2kMA3QHCKnKGj8qnvVz97AqKgCLVZJfbOemMX7MW1KMn1HF4rU2YsK0RIVq2HvYTF6RjcRuXsSEaUjPsWGxSgpKnF4r7r86kEV/llJRmEGJLQKOpKKdfAWHcmx0iNJyJNPqGUXk3wPSm+ZdPPT1hwHImfY6ec+8h2X/IQxDBmBavQXrwWPYThzGvvlPwt77AnVUGJrQQLz6doOvcL5UoXrW5DJ2E3iFNUlOALyjnMt0SS+BvRKh9uK8B8+jLLOM9W+uR61TE9EvAsd5Dc/ag5++C0e5ifwXZqGJCqN85QZKv/qZyq17KV3wC9qO7bAdy8L7koFNDvvRIMX7YPMUpxI6bx4OG4ii9Yii3Vzi+xumFB/89aWYw/LwHxyKxveUHdrpS+G5+3MJ7R5KWXYZOz7dwUVPNS/+qVvfPCnlbc1q1XWigdMjOqUD5zWQ/wFgBOAvhOgkpfywnrQaCCHuBu4GaN++eWaIbZ3i48X4t2taGAFw7kfs/2E/N/9xMzs+2YE2PhT9X+vxqrI4cwWHzYFKrULl7UX4rGer0w3nOeuQVhsFr32Mvl/3Gj9ioRI1TIyth9MxXnNZk+TfuHEjKpWKkJAQdLqaVl0HfjlAtyu6Nak+t5EnFZERVHro+iDHllq44+VMLhngj1mnBSlZvrmCDZsqCFVpubC7llW7LdwxwZ8+nb3wN5aSkWtDqxFc2MdAu3AtJeUOrDbw9VFx5aW+BBhVfPt7KUmHzHSK0RIfrWXMBUYC01fjf2wQJTHeCL2WrHwTnWK0FJV6KKKuSgtZK6DTFKfrnCYQPH0qeU++Q/hH01EHB2AvKSPn7umEzrgVkemH+kwv6wM/hJR3YNNdEDMRose63pjd5PTW4C4dboI9r0D7SUT06Qt9IKBDAGteWoOpwETh3kLyI/LRGXX4xdR9zEDlYyD0rccAp/cJa3o21iPpWHanYsvMxXLgKJWbkyj7eQ363l1wlFXgf9tEpMWKNtbpnkpdNWM6+XsxrduOYUj/6jasRzOo3JyE75iuTmexxfucXtNH/gV+XSl4aiYa1VG0XiloA004OszD5/iHFAZeQYghE3bPAp8OTuOajF+dBjZqHRv+s4EJH02gLLOMkuNNi5pb57NoTmEhRJQQYpIQ4i4hxJVCCM96Izx9h/IU9a4FSSnfk1IOkFLec1Lh1JVWR7m5UspEKWViaGjDZ2LOdda9tg5pt1Pw+sfkvzynXqekthPZ1e5YSjNK2TZ3GxH9IjCGG7FWWPlxeQEFq3ZguMh1K7Oy7LIGXckIrQZdQkdMa7bVuhfRN4Kja5wHB0/GDHIVs9lMYGAggwcPZvfu2k5WCw4WENQpyOX6moW0OV+afl2QwN4TRg6lW8krsrP7gBmzNLL/rx94/bN8Uo5WEjK0C12OHyLQT8UNo/2JCNbw3qPh3He1c+/jor7eDOljoKzC+bfy0gk0aoGvjxq1WpCRZyM8WENkiIbJo/wY6vUBcTodQR0DKa+UFJfZ8fZSUVHp/Fmt312BxdrMg5iDPnJGU20ian9fwv/7fHWgQ7WfkYivZqAJ9kEdVodS04c4X6o5a8Ba3LTG7KbmeWgwxjmtH4+e8tkW0jWEK/93JeYSMzlJOczqPot1r68DYO83jUet1caE433RAAKmTibk5QfR9+5C6DtPoO/REeGlp3LLHsp/XUfWrc9iy8oj54FXKV/6J3lPvMOxC29EWqzkvzib/JfnkHXL05R+vwLTuh2U/7yWyrU/4Uidj+2vNyhJHUr+zJWU/fg70mKlfJcfptJbEaN+w3vk+YQPuoYM7/GQuw6rKoDcPQvBrxtsvR9O/AT2SgpSnf4jy7LKKMssc/85VuHugVa1EGI2cBT4Fue5ou+Ao0KIWUI0FmvYZdKB03eQYwDP+YD/B1J4uNAZFE6jxmf0EIrnflsrj5SSvGfep/wn5yHU4xuO88czf9B+iHO2qPXW4rfoRz71Hd4khVCaUYpvdMPr8sbLL6V82dpa6T2u6sG+7/ex/cONCH3TPG7n5+cTEhJCUFAQJSU1R282sw2VWnX2rJccVjLLgsgqFCxdV8a8Jc6lpdBANXsPm7Fbyuh+7Crivfej1UhEiD/m3HKC/U4Zdeh1Ksacb+T2CQF0iNaiUQu0GsGjNwSh1wk0ajBbHESHanA4QK8VeOlO9W/wvZdwfi8jJWVmDHoV5SYHpkqnIlv0Zxlb9zfTM7NfN8j+o4ZncXcRSDjymdOw40wCesOoDXDRd2B2MQJpxQko2ut059OcGRHAkIWQuw4KdtQIhTHqzVHEXRrHwPsHovfXYyow8ftTv1OeU7eX8voIff1hDIN7E/jIzfhOGoEmKpSK3zeh69yezBueQB3gS/btz1GxajP+t1/J4Q6Xoe0Qjfew8zDvOUjhm/Oo/PkDfDsto+L7T7Dv/BJz5BwKPsnAMCQRVCoMFycS8fkMgmc8g7ZLT9T+vvhdeB1W4U2hz0WkMYSDlr7OAIrGDrD3NdgylcrMIyAlJeklaH20zfYi4e6i8HTgduBp4Guc0VnDgWuBfwP5wPPNkszJFqCzEKIDcAK4DrjeA/X+48jYlkH6xnQKDxVi3lFJ4BO3I1QqKlZvxl5YUu2zrfizn8Bmx/+uSZT9+Du63p3JS85j0AODqo0FSrvGof/xV/bHjcPukKhdDKldeqIU/9iGlwWFRoNXv+5YUo6g63rKs7YQglFvjWLPC9+R52OkKfOXvLw8oqOd1mcqlaqGe/7kH5PpennTAus1C4eNCouKtz/Jw89HhY9BxazHw/l5fRlxkVqSvJ4gyj6b+OAijpQFY7ULAuP88c/IwnkC4RTjhpyaXf74ZjReOhVL1pai1QgG9zRwXk8Dv20sR6cV6HWCysISft5wE2OvCkUeKcK6P59Jw9qzcHkJCPhmZQlhgWoKShzY7RK12k3lLAQYop2hyIPcPJdlMzkVUPpPzuipiXXYGflVncVx2ODYt3DiF4huwLtY+XHYfJfTTZDDCvG3uifb6Vy6HFLehV3PQMLTgDPmlHeIN91v746l1MKyB5cx5KkhZGzLQO+rJzQhtMnHBNTBAYS89AAl83/C/75rUXnpkXY7/vdcg6OkHMPQRDSxUWCzOY08Lh9G0FN3IrKWItdeiXePDlji/8C7zyAiF0Sj793wIWZvb29WZV1KUkoSvaJ7Qkc7eYdMhIiVyOJ93POiGUdyCKZjAQyabGD9W+vdfoTg/tLczcCzUso3pZTHpJTmqn/fBJ4Dbm1qhUKIBcAGoKsQIl0IcYeU0gbcD/yG053QN1LKxue4CrUoPlZM6pJUSjNLkchqax6/myZQ8rkzyqa02rDsTkXaHRgu7EfQ8/dQ+tUv2C12LnnhEoQQ2O2STI0voUZJXqGND75x3T9caUYpvlGNWyp5jxlC6be1rezVWjXRXgUczvFGOlwfgRUWFlZ7G46MjKwRIC5rV1bLe1M4HWnDYteQnGbBbofpd4fSIVpLt1g9T9wczAfflbDO9zPO725Dr4XySuh9Qy/8T2Q2WK2XTlX9r1otUKkEapXg3kkB6HUCtcPBzjl/0j6xI146FZGRkfoPVs0AACAASURBVHiRR48OeorKHCSnWZjzYxEVlZKKSgdzF9UyhG0acZPh18YPOteJlLBiCGT+Bv3fgcD+Dc9eVBo4scS5X1QfpYfgwGyIHONcXspc1vwZETiX947U9nunUquI7BdJZP9Ikr5MIuHaBFa/sJplDyxj4zsbyd3vdLpacMjFmRz8P3vnHSZZVaf/z7mVQ+c83T3dE3qYDMMkmAFmYAARJYggooJiBDFgAPZnQtd115U1o6JrQEBAkCQZhihhMkzOHWc6d1dXDjec3x+nu7qrcxiC7rzPU0933bp176mqe8/3fNP7YsvPIe+rV6G5VdGAsNlwL12A98wVCE3Dd/Yp+M47DYD8b38OYZPQ/hJixW8RmoHrpJUIIcY0QqAogC688EJWzJ5Jd1MAYo007Mqnxfk9EqkiOkMno+/+PavnXkVF7gOIcS5GR8JkDVExMJKi2Q4GL93GgV6p8TIppUNKWSGl/EPv9ieklHOklLOklD+Y5Hj/zyPaHsWV5cKT78FM9Sf+7SUFyJSOGQyjH27CfdoScj+rpJht2X40vxeRSnDz7zo40JjizieDGLEEBbMK+MWlgtys8eutRDui+Ip8Y+5ny/ZjLykguetQxnapG2gOBws+vIjnfjn+AkjLstIeUHV1NXV1iinYSBjY3W8v5Yqu6+yut1S4zKXO63ZqvP80Pw674ANr/cTsMyiXrzCzKMKBRhNfjpMFsz1EWseOxbucgoEkFJety2ZOpZNdd++kdIGb5WfMBCArKwufM051mYOULjnSbvD1j+XTHjCIJyWHjqToDpnsODRJWemsGiiZZLVXshOyZsEZD0HOXCha1d9vNRJ81ZA1R3k6Zqq/mi60Xxmhvf8De2+BykvgshBccGD8suhjIXcxlJ4L8aGaPE6/k09v+jSuLBcnXX0Siz66iH0P7eO1H71GIpjgoSsfIhFU3/Ex4fzrhQjugpcvgf0/U57f3K9M+Bh2u505xaswQgYyez5h+ynU7juZQ62fxbno08hgr5Jt5+ucetnUMiaTNUQHUGGy4fBhYP8Irx3HMUb02dfpvuVPhO59ctT9Yh0xPAUeCqt86FbmDZh1xflEHliP3tiMoyqz3sR71krcdQcozLVxxxNBlfwOt1D6nhMJbGqYWGxYMu6VU/anLiF016MZxRSx5zbgOWsF7nllvP700Ql5RX1wuVykUqokdd/D+5jzvmPAszYBGLqObtgozreR6x96+33uA3lcuG461Yl7KfG209qtyoDnXzqf2ufG7h13O8WQkNq6E5207WijOnEZuFQxjhCC+TOdOB2CLK/Ge0/1sXqxh89cnIuUkvpmnYYWnf0Nk6SR1BxQepYSzZsoNlwNVVf0Py9cNXap9Wn3Q+k62PZ1ePlCeO1KxfJQ+2fY+GkVIsxfpir57D7FknCssOouxSrx2AnD9tWVL1dh4WXXLGPll1ay/LrltO9u57VbXiN/Vj6Hnz5M02tNPHvDs8duTA33QsFyWPoL9VvMvX5Cb991r+rOiXfH6XH1cCTnSho0k+4mSUPtErJXX4vrPfdhlH8MEu2IzonLSAzEZA3RfwCfEEKsF0JcI4T4gBDic0KI9cDHe18/jrcBRnM7yW176PrGz0fdzzIscmfkUlRmJ+nI9EocFSUYrZ0YR9qHdE/LqioitUfQTJPpJSqlOJc2vItnkQgksExJIGxijcMoTMRoCU0j74sfoefnd6W3Jd/Yh3vpfA416SRqKjj01KFRjjDyOf1+P+FwmLadbUxbdqwLPUcfSzyRwkBVseX6h67InQ6BzZ2Dhk62vYe2brVKLphTQPvOselzCnNt5GdnHvfV/36VFV9coSrLCvu7H+x2O6Zp8rcflnPDlQVk+2ycWOPGtBRXXX2LzpF2g2371WIgMNESb28VRCahU5NoVd5NH0rWQM4YBLeaXVUj1t+lSoybH1fl1TYPnPwTmPUpeM8GNSkfa2gOCB9SYz74GwgNr0Tbp4K77JplXPj7CyldUsr5vzqf9t3tPP+t5zP0uCzTmnwBwN4fq78110LFhWPuvvMeJVxZ90IdekxHSsmjn32UcEuYaHuU7Eg29/7uXshSlYGrblilPk/F+dgL50HuIlUaPgVMyhBJKe8DzgN8KPqdB4BfAF7gPCnl0FKs43hLYHZ041oyD9+FazG7Ro/r51bnUlhiI5oaejMKITA7urEV9is3hpvDvPyDl+lauYqryxuobda59KxsSsJtOGZUULmqkuShNv78WJD2wDHqQxkAe3kJ9qoy4q9vx2jrQjgdCLudzh6D7KXTqX1u6CQnpWT9+vVpSntd14f0Dc2YMYO62rq3Xu5hEGIJyb4Gi9ICNyV5di4/dwQZC6HxWk0DOcHHMS2td5PAW+gl3Bwe9Rwzy53Mmd7/eQ8/cxh3rpv8mbmw8Nvg7Ke8KSoqor29HYc904OKxC2Kcm00tuq0dhnc9oDKA97xxARLpEvWQP1fJsS+Qc8umPMFyJ0E3Y3Q4OJGRb66/FdQdzvMvxHyl0ys2XUyWHGbaubd/g0I7Rtz95LFJcz/4Hxc2S723L+H+hfqkaYk3Bym/sV6/v7Jv9P0atOYxxkWB3+jQpXuonExXDz4kQcBOPz0YRr+0UCkNcK8D8yj9Y1WIi0R6kP1VIYqmb50Oqd+9VTyZ+X3S5IUrFSP1ucmN9ZeTPpOlFI+I6U8FfAApYBHSrlKSnkM/cvjGBOmRf6Nn8T/gbNJ7R05dCOlpOzkMkoqnPREhv7s9ooS9MbWDEqSXffuIqssi+iZpxP/xzb+89oi5kx3Ig0D4XQwY90MvLXNbNoTp30UmeqpIOuK80ls2kn3f/+B7M98EIBA2GLNEh93bIHOfZmqmYcPH0bXdXbuVKu8eDyOx5OZlC4oKKBhZwPlK8rfkjGPBN2QRFN2aqq8+Lwafs/It9/yhXmYOSdz3w/6PdSFH17I3of2jvt80pLUrq/l1K+eqkguB0lsl5WV0do6NK8xvcTB9FIH4d7epL5QX0vnBH9jbwVknwBdE9DjaX0Opg0hTRk/7D4Vfqu5Fi5pS6vQvuXwz4Dpl6lG1/DBCYesl3x6Cet+uI4jG49Q/1I9dS/UEWmbZH9O+fuh4qJRd2l6rSndl+fwOYh1xRA2wZENR9j7wF4WfmQhDS83IGyCwnmFLLm8X64jEDZ59B+9Yytdp4zeunfIEPVBSmlJKdullMcu03YcE4Z75SLiG0eqH1EoqCnA79QJR22YeqYH41mzbAg1fSKYYO5nVpCX70I4HRDvzdf0huFcWS6yHSYr5nv4wyNBovGRL4G+woCJQghB3pc/RvFPbsSW7ceyJLc/FmTFAjfTLlrE1j+8gWGq8XR1dVFbW8uaNWvo6FTVSLFYDK83s3HRZrPRXddN1Zrx8aEdK6R0STDuJD7jiyybN3ry3ePWEN5yClz9VVXZFdn01I+vmk1KyfPffp5FH+mVAK+7U3XHD0BOTg49PUOP94G1WZy70kc8KUnpErdTpMN0A/Ht28Yh7V5xoWo4Hd+gofM1cBeOve94MFaBw7FG+fth2S/h4G0IffxVh0ULirjgdxdQMKeAf/zgH+RW5TL/svnEOmJsv2M7z9zwDEc3Hx3fweJt4MgZM6e2/c7ttO1sQ4/pzL14LrXra7E5bKQiKZ7+ytNUrKxgy21bkJbE5rRRMKcAr9fLli1b0PV+NWAA8harcv0pYNyGSAixSQgxv/f/zb3PR3xMaVTHMWFobpeiaB4GB588mGa5lskU1efUZMSjARzTywaxFis0telUltjxX7CW6GMvYYYiaNn9Oaay6iw+daaDT16Yw4ZdIzRC6uFxl26Phe6QyZc/nIemCZYt8rGxSePJR1R8uqOjk5yiE3jkFYOt+5LsrU/S0dFBQcFQ4kgzZXKk/ciUxzMR7G9MEUtIfP5sTj5hHJOkt0L1xwxA+fJyjm4aY1I6eBt77nyBE1esp3Rhlqog2/pFlXsZgNGqBT1uDZ9b4PdqLJjp4hf3dtPSaZBIWaR0SUunQUuXweY9YzS/OrIh1pRWUx0VB34JRW+NzMDbCk9Zf9XeOLD0c0tVWXWWi3X/uY6TPnESZ//wbB6/9nFa32wFifqLouiSUqYfA/Hf//UfpJ4+U7Gfj4BNv1JTs7fAS7w7TrQ9yrRl01Sje2cMp8/JtbuuxZ3r5qbATaz7wTqklFiWxcqVK+np6UE3ldbVwy/1holLzwbX1JhJJuIR7QbiA/4f63EcbzecdmRyaJXTnr/t4aSPn5R+Xra0jJato/elgJqomtoMKkscOOfOILnjAIlNu3ANICWtOb+GQ08cYvFsFwcaB53bTELLs/BA4TEzRM9uilFaoDyrLK/GwYpqel5UyeE9h8P88M4I2w8kiMUtbnugh/aOLvLyMg1RuCVMTX4Nhw4dIhaLTXlM48XNv+tEIsjLHmfZsKcUUpl9JnM/MJdNt24aGraRMp2LSdRvosr4BIXybkVw2fQQzP4snDC0ckoIgWUN9WS9LkFJvp0cn8a65V7ePJhkeqnSOjrQmOK1HTFOmuOmvkUf+3OUrIPgOKaEIw+D91+A63Hl71UPVGIcHiMw65xZ/f+fq/63OWxUr63GX+bnnB+dQ+hIiK4DXTx9/dPsvHsnt912G7fcckvGcf7fN7/Df7y4GLnyjyOea+/fVGhXs2tYhpXmWax9ppZoW5S1311L4QnKI+1bqAw0ejNnzmTHG5swDElds85966fOMwcTMERSyqullHW9/3+i9/mIj2MyuuMYFVI3wD6A+mXRHBJvZiZKN/5iI/5Sfz/xohDkVueOO8TT3m1QlKvO4btwLT0/vwvXSf0EoQVzCug62IUQglnlDvbW95brWgZsvgaaHoTyCwkfDU3JEB1t1wlGTFq7DE6sUXH/aMKiYkYWqaRJT30PnYEY5SU+2gMmCcPJ3toQe+uSvL4rczW+5297OPFDJ7Jw4UJ27do1ZXqSicLvmUDiPNml6Gh6YXPYmHvxXPY+MChXdPQxaH6CyOFd7H3WILLgCVh9tyoWeOPr0PSAkp4YhOLiYtra2oZsz/JplBfbyfbbyMuyke3TmFvl5PqftPPGgQTxpArZJVPj+O580xWrwWgwUyAckLtw9P3+GeCrVn1Umz8/pcMsuHwBOZU56ZaHV3/0Ku/52Xvo2t9FuC3Mztd38vh1j9Oxp4PWN1uRUtLSYufQU4cxdZN9D+/DSBpIKdl9/270mE7rm6207Whj8683076jndDRELlVuRzdfJSqrw3f92VZVoYhisfj6IYkFLU41DTJ8v5BmCzX3HdGIjgVQpQJIY4Fvc9xjAGzozutPgngOX2p4pEbgH0P7aNuvaous2IJhMc9rgbOvvJRCWi9N4Jn5WKKf/mNIcqodrcdUzc5Z6WPl7b1TpqxRjCisOS/ofAUcoP/RU755DvZ73giyE23dlBeZE+zCKw92ctnL86hffFcXvv1VjbvDnL5uYWU5NvIzsln7Yk6b+xP0NqVGbKMtkfJLs+mvLyc3Nxctm4dSrJ6rHHbgwFcWpwrKn4zsQZaVyE03JOxad4l8+g60MWBxwaUCXdvJd6wDecrq1h4/RcpXblQhblmfFwRreYvH/bw06dPp6lpqJEoL3LwnlN8rFzgxu/VWD7fzdxqJ1/7aD5H2w0MU2K3gWFK6prHmIy80+G1j0C0ceR9dn4HAttUP84/O2xOKDkTjHC//tQkULSgiKL5qu9Lj+kULyompzKHRE+Czk2dtNa10rmnkz1/28ODf1KVbx2NEUJHQhx66hB/+/DfeOMPb9D0WhMvfOsFnrnhGWa/dzabfrWJjz7xURZ8eEGavPTEe67m6d3D53j7QnN9ZLjJZJJosIlgxDxm1bKTLVa4GUVAOhym9b5+HG8xjLYubCX9iV3N40LL9qfLuJPhJDPPnYmZUheL0dSCo3J81Pztu9opWVQyhP7cUT10/THrnFkcfPwgQgjys20EI6ZKms78pMoRzPsaPaFZuOThyX1QYH9DimXz3Fx0Rv+qvij+HFVt3+LZ3RYvH4L5eSlOnuvlm58s5NrLq3nP0hQfODObnvAACYmYjm0A9cCcOXMIBidYljxBBCMmPrfGsvJ62mfcMvYbBmLxdyFSP2Tzkk8u4eCTB9n6u62Em8MEDjbRtekl7OWn4CgbwO920g+hYIUqLR4Gfr+fSGT46iwhBCfWuLHbBDdeWcDqxR58bkEipSQnHHZBc4fBX58dvaQcdyGs/qvqtRkJjmxYOnov3D8VhAYzr4ad/65IUSeBqtOrKFmsVGMXfGgBs9+jjPS+h/eRaEzgrnQTWhvi8NOHuetXfwKgZV8LwcYgLz/0MsapBkc3HWXHnTv4/O7PE++Ks+zaZey6ZxepbB+B3AKObFR50h2Ne7HL4em6gmEDw7DSBL2mJYl37yEUNuk4RtWykzVEgpHlGCqA8ROQHcekYTS1Yp+WWR3jv/gsIn9XrNmRlgg503P47LbPAqA3tmKfrgyRM8tJMjxy13vTq00UnFyOxz32JVJxSgXNW1XBQHmxnbZuUyXGB+jRxFLloyZRR0MiZRGOW1QU23H1ekOkArDlOrQDP2e6/whbSmchm7rwugV+j0ZeXh7NzU1MK8mhrNCeZpTefd9u5l2S2RxZVlZGQ8PkxjYe/OWpEKYlOW/uIZL5Zx2TY5YsLuGMb51B2842HvzIvQhXHuULLLQTb1aTYB88pTD9cjjpRyMeazyhSYddUJhrx+3SsGmCWMLC49LYui/B9oPjKETIma+KFoYfgMonVv+L8Rn7Z8K+/1HkrVNE+fJyCueqRecX9n+BBZcvQAjBl777JaLtUarOsdA0jZRM8Y8f/IO8JXnkr80nakSZf9l8NLvGpfdeStXpVbg+fy5Jl5t4bjYrv7ySuro6fvGzH7Nz41+xLCtdhWqaagH76CthAmGDzqB6XlJeg9R82GMbiSUlz22OjquhfTRMpGru40KI54UQz6OM0G/6ng94vAbcBbw0pVEdx7igH27CMasyY5tjehlGk4r5h1vCZJVlpUNBRlMr9kpF8JlbnUuwYWRPINIWIen1pvNDo2EgbU9Rrp2GFh16doKn32lO6CWK82sS2Lo3wRlLvJmMAdu+rlb7VVfw+2vq+fH1pUybX0Dts6qXymaz0dXVRUFBAWtP9vKt2zoxTUnHng6KF2Ya73nz5nHgwPDd8McCTW06dzwRokDsR2TXjP2GXqQNhN2rONMGIassi/N/eT5X/O1scufOQeTOVQShgzH706PyqhUUFNDZ2Tni6wPhcalKukDYJD9bw+UU9IQtnt0Y5e6n+6+nQ02ptLQEoCoAR1qI7PsptL0wrvP/U8E/E6QF0fophegG48Mf+zAF8woIh8Pk5+eTV+0lpcdwOBz4Z/m5oeMGSpeUcqjrEO6L3Mxcl0ln9HSsiGhcYpqSVV9bxV133UWuN8ZLT91B7ZEIz2yI8thjj/G9730PUF7H0SNHOHq0k/vuu4/cgumInFNJmQKvW2PnoSS/fWhqJLkT8YhiKHmHrt6xBQc873vUAT+iV+30OKYGyxid5sOKxofkawDsVWWkDjcSaYngL+sPZZmdAWxFqrM+t2rsgoVESqaJOceCr8hHpC1CWaGdPz3Wg2Xq6X4Qy7QwyYXk+KqIBmLznjjPbopy4el+ZlX0MgboYUX5Mv1SWP4b7PFGTpzjprgmj8ZX+vMQPp+P0tJS/F6N6jIHW15ooXDe0B4VIQRut5tweIwQ0yTR0mmQ6+jEcE7D6Rh/fiidSyo6DTZdM+J+Ti0ArmJYdivYJ56Hq6mp4eDBg+Pa1+PSyPJqdARMCnJsuJwadpvK4W0/2O9h7ziUpKNnQP7A5gIrOZQYVEpVUbfm7xMe97sergJY/O9qAfb0KcfssA8++CCGYdDZ2UlpaSn6oh3ErCzFIOKFex65B9M0CQQCGAM0ofo8HbdTIxyz0uwIhmGgp2KYlkk8YRFLWuzZs4fubpU/EsLiT3/8Le2BGB0dHRgmrN8cw62FqXC+Sk/ExDPOeWIkTKRq7n4p5WVSysuAPwOf7ns+4PFRKeX3pZRdUxrVcQDw8g9e5vuO7w/7Wuiux3CfPDz/Vtbl5xH+yxNEWgcpog5QNs2tzqWnYXhD1Gf8kinFEj0eTD9tOk2vNZHl1fj6Rwto6eqfhAK1AaVlNAmer6Y2g66gyYxpTgpyelf1Dff0l/navRBvAT2kSlJNi1RUJc/PO+883G7Vr3P52Vn8+lvbhoTl+rB8+XK2b98+4fGNhX31akKe5dtL5dyVlORPQgKs+HQlNmeMIKzWs1MZ5knqUfp8vnGXsfd5RF0hk/xsGzPLHZy3yk93yOz/fYB40iKWyEx+S2yw87vpCRFQeaPaP4Izk/XhXwbZ8xXhaN6Jx/SwhmHQ09NDbl4Bn/zpL4gZLux2O4lEgkOHDnHvvffS09OTJvgFuPTfjiKlxOUUhGMWhtl/rFQiSiRqEIwo9vWdh+I88YrycG0axOJJIjETKWXagCU8q/HYgvR0D2XnmCgmmyP6OTDsHS2EOF8IsXjyQzqOPugxHW/B8HLGem0TvvPPGPY1ze1COO0kuqO4c4dvnPQWeYl1DD/59BmwpC7HbYhKFpfQtl2FBE+cJWjp7r+02ra3UbakTFHMTKDRDyAUNYc2f+64WVGq9KH6o9CmosHzLpnH/r+rMFZWVn+5+KrFHhaWgTtn+O/D7XZn3LTHCn/4e5B4UnLdeZ3klM0dwus2bkz/oBKJGw6Rw4pKZwpwu93E42Mrs+Zn21g0y8VPry+htMDOyvlu1izxcsmZWRTn2di6L8EfH+2hK2jyzd900NimQlKJlMWjzR/CkE7uGRDC480b4QP/wqLLFRcowlVXEWy69pgd1jAMkskkwZiKEkRjisoqlUqRSqXYsGEDwWAQXVfff0/YJBS1sCzF0H7/c6H0gsAwDBKJKKZlEuo1RHvrEiSSOtv2JQBJLK4jkBk5pIvWFmEnBtE9TJVYZ7KG6CfAyhFeWw6MolB1HOOFw+Ng2bXLhoTnpGkiPKN35ruWLcTZ0jhiqbAQYkQZhY49HRTNLyKZkv3FAWOgzxsBsKVaSdpLSfTqHnXs7VCJ1qwaCI8vBATKM6tr1rn6gkGr5dmfVRT3ffBNTyfCpy2dRvuuoSzV9U8dxH9iBZ09I1f5HGtdokTKYk+dClf5RLcqxZ4sSs4ahUxz6uSts2fP5vDhsXN4Po9iWigrtGOzCc49xU9liT0dNv3BHzt5blOUh1+KEAhb/OERtfCIJyWtiXJi/uV4k7t58vXeSr3cRYqJ4F8dyQ7FCD7OJteR0DcX6LqOy+VC9NIYxWIxsrKy0oYoGo0SCARIpVIcOHBA5W2BA4cbCTRvoqlNleDv2LEDXTdIJqIgTXoiBnvrknSHdDSh8+cnghRkaySSKZx2STxppj2p81f7Oen0q4knLZKRd0aP6GTg1RFeex1YMsJrxzFBOLOcpCKZK3WrJ4wtd/TmUM/qJbia6/vfE4khfOPLH6QN0QQ8IgCH16HGGmumamYVG3obSc2kqSiGsmpGpMgfDoGQxZLxUOG4i2HLdSoxjPJ6wi39+R4jYVD/Yj2VZ8/mQ99o5vCR4T2f8XoF40VP2CKeVBOH02aOOzQ5bF5QaBNjsZ4gRmpsHQ9y/DbWnqw891MXefjIeTnk9GotHTqic+eTQT5401HiSUnAdyYlqZfYu6eON3e3EdGH9/j/5eCfBbM+o5ixJ4hv39aBaUqicYtgKIHX6yUej+Pz+RCauj8cDgd+vz9tiCKRCD09Pfz617/mhBNOIBBR98afHmogGVGsKoYJf/7zn0mmDJKJGFJahMIme+qSSCkpyYOGFh23C+qOxGgP6LyxP05P2OS/v1CEwy4oyrNzOLySeGiUHrFxYLKGyIaSgBgOPsA5wmvHMUG4c90kApnlsWYghJafw+77dvPcN4dnvdU8LrReKYQ/Px4kVd+MozJz5Wn32NHjQ6t5Yh0xfEU+ZYicwxii0MFhq4Bmnj2Tw88ehngzZRVVNLXq6HE9zXOHfyZEx69P09SuU1E8KKdipoZO6EKDU+9QQmjAkk8tYfuf+/M9O+/ZyZJPLaGyV09pJENUVVVFfX39uMc3FsIxC59b8Jfv5JB9ZHw9MslkkvXr1w//omYHa7gGwqkbqIF0LlM5RkGujfet9jOjTP1Gbd0Gf3pUheJiCYuwWYTLbGed/ConbS+lSVs71aH/c6DqchWmG2SIghFzxOuxD23dBgebUuyqTbJ1Tzf5+fls39+Dz+fD1XsruFyuDEMUjUbp6elJs9Dfd9/9GKkwoahBPKK8MsOUvPnmmzz91JOYRgqkyVOP3Y5ugNMuEdIgFLVwOSCV0lk8y0kyaXLbgz3UVKopPj/bhoUd2zskFb6ZkSvjPgtsmeRxj2MQfEU+oh2ZSWqzqweR5adlWwtGwhi2H0hKieH1E6htY/2mKEc312FOz+xBHquEW4XmhrnADtwKtX8asnna0mk0b2mGeAs2XxmmJal7vo4Z63rzOTYnWOPPw2zcFWfBjEFVgZHa4dU1S89Jd+57C7zocZ1AbYBwS5i2HW0ULyhm8WwXpyx0E4wOH88uLS0dVhZhsrj3mRBul0aZfR9i5ifG9Z62tja6ukao9fGUQ2RsMcDJoqioaNxl3MNBE2mnlLNX+PjuZwpZs0R5PBec7ieWlETiFp1mNSe4XuH56LXEPSeNcsR/IWTNpsOcjenIh1QPyZTKtdz7TIjnNg8tQgnHLDoCBsmURY7fRlfIJJmSdAci5OTk8fLWblUV6lTXvMfjIZpyo+s6PaEEqZSe0aj8ykvP0PjmbwlHdd58+TaktLjryRC79uynqakRw9CR0uRo02H+7eMF5Pogqes47OB2gmXpnHeqF7tN8on353C0cR+JRAKfPYzTYaLZp+Z7TNYQfRdYJ4TYKIT4vBDiEiHEdUKIjcCZwLen33PaugAAIABJREFUNKrjSKNgTgFd+7t46vUIuw4rg2MFQkRigpLFJSz6yCIOPjE075LoSSAXLOTxH73Asvlu/vHwPr79tDtDqiFvRh6BupF7j5OpYUJzRlR1wUcbQM/syBeaQGgCK9ENzjwaWg0aXj1CxSkDDOAEVtxOhxjaUBupVWGOQbBcxQizfzyrb1zNzrt3su3321jznTVqfEKQ7bMRGsEQadrUcy0D8cLWmOKV69kJ824Y13u6urpwu900NzfT0TEonzDtfNj3M/W/mYItX1YPR84xGe/MmTOprR1bjnw0nDhHLRzOX+3njCVe5lY78bqVHHkiKdlTl+T12BU83Pkl3kh+kHBMtSgcPpKiI2AQGUVK5J8dz79hsSO8CvnoCdz5ZIhgxCIU7afOAdJ0SW/sT/DTe7pZvzlGllcjFLGIJiy6A2E8vhx8Lh2fz4fbrr6vmpoaOpKzsdlsbNsXJqVnRixcLjtzp2tsXP8bpJng1IVOpLTobG8llVLzirQsEokUZy3z4naBZRpMK7TjdIC0dOw2STRuYkbreOqpp+js7ORXt/6EhRVhvv//rpzSdzNZhdaXgXMBC/gl8DdUJZ0BnCOl/MeURnUcaeTNyqP7cDeNrYo3DcDsDlK/tZNpy6dRemIpRzYMlTMIHw1jmzuD5O7DzKtyMq/CRmmJh78OYMvNnZFLoDbTEEXbo3iL1Co2NVyO6MX3Ka+m7QV489+GnLfqjCqC9V2g2cl1SzoCRqYSqt0Heu8YRjFKI4aIEi3DJrd1Xcdh6z+m0+fkjG+dwZpvr8GT158bK863MQzZ9PjOPQFYlsTnFpwwLaEaGr2Vo+4vpeT+++8nGAySnZ3N7t27WbVqVeZO3mnq+4u3QeBN6NkBwV3HrDR4NLqf8eDK83NYNi8zD1ld5qCy2IHPo7GvIUlVqQNN09hq+yrN5kIeeTnMX54K8dBLYe58MsTzw3gH/yqw2WCr7Wuk8teSiAb5xV+7CUUVXVJfSfSn/qOVYMQkEDLxezQ6e0y+/rF8AiGTX98foDsYxuXJxakl8Pv9aJoNIQQVFRXMqpmLJQWxmI5lGr3nVOHoFQv8ZHsFPV1H0PUEpfkCy0hgZYR6LUI97Wzc8BoepzI+S+e6sWsgLYNouBuPC27++iUcPHiQVCpFMpnky1cUoIm3iVlhMKSUL/YqtGYBlUC2lHL1cSN0DCEtrCOtWIaF0yHQTUlDi068oQPT4aGgpgDNrpE/O39IT1D34W5kYTbhFacwp2EbNZVOvnF1IZog7RX5in1E2zNv/PZd7RQvUMwDpiXT6pxpFK6CuV+B0x8Ytvejem11eiyn00JiwYzMHWZcpUJ7AK9/fFhjJKXkYJOObzgF00QbuEuGbE6lUjj9xaPzmQFXvz8H05Lpir7ByMvLIxCYOkPVr/8W4NMX5/KVymug/cUxpaq7u7txOBw0NDSkSSbLy4cRG5t7PTxzCoT2worfwVnPKpXMYwS73Z4u+T0WWD7fw7wZyiu6+dOFnLXMS3fIoqrMiU0T1DXrPPxSmKPtBn6varTc1rvgemFLlJ2HEumKr39mxBMW8YREuEshcpjC5Csc7VA5mHjS4kPf6NeYeuTlCJv3JvC6NaSUeN0ard0m7S0HCAUjON052EQSIZx0x5zY7crY5Ga5kVLDGhD+tjuUh2qz2QCTVCKKnkpQVSIw9cx7XxMW0WAbmzZtQsT3IS2D81f7yc/R8LlM/vS/P+G5R39J89FGLMtC13WSySQOu21YKZGJ4FgotMaklEellG+fsMv/AZi6if/Am3T/z+0gJa7OdrxujW//toOjr9Sy+DMr0vvOfs9s6l+sz3h/+8529JI8zrl2Ff43t6Ur5uZWu3hlu/qphBAkQ0mMZH9Jc9vONooXjaLuqDkVf5mnDOz+IU2WNocNaUmCTUE63mhBqy7KfL93mnrPc2dD9xbVAzMI8aTkj4/2kOMb5vI0U8PKP6dSKZz586BjdDVQIQSLZruobx5+cisuLqa9fWj590SxZW+Cknw7Ln8RZI3d43PkyBFWr17N5ZdfzimnnMKZZ545/I7eCsXsvPdHqpdqkk2sI6GqqorGxqlVQA3GFedms3i2i3nVLoQQdPYYLJjhpDDXRjBikUxJAiETm1B9V3c+ofKWm/cmePL1KLtrR+ZEfDejj38tFDW5q5dv0GaDsPcUFnAPnT0moahJIGwRjFj8/eUwfo/g9seCNLbqeN39i5d9+w+w9/mvEwpHcHpykWaC6QWCjkQhdocTwzDJ8rlwujxYpjJE3/3Zi8yZr9oc7HY7UpqYRgwpJWuXejD1zClbSpNUKsaRI0fYtGkjlmWQ67eBlGjCIpmIE+wJYJom0Wg07RFpmpbmpZsspnQVCyHmCyGuFEJ8QwhR2rttthBi6gpo/8cRaQ3j1sM4KkpwtzQw+45fcekaL5eu9dHTY5BV1v8V583KI3A4cxVvJA2auiRV0xQjt3uFkoxeMd/N4SP9k/Cc982h6bV+Msp4Vxxf0UgFkYOQuxB6dg3ZXDAnn4c//jAzzprBPc+E6Bjcu1O4WhUcnP2y0skZACklgWCCBYlfkO0bjh9t+BCArus4s6apHNIYOKnGzfpNUUxz6LGKioqG5mYmgWDUoiTfBr4qmPOFUfcNBAJ0dnZSVFSE2+3G5/MpupaRcMKX1DG1SbA0jIHKysphZSGmgqI8OzOmOdMeblu3yYlz3ORl2bjju2Vc9b4ceiIWgYjJle/NprlDXS8dAZNEcvw0U+82/PlxZVADIYuuXsLQvz4b5gX5A1rMeaoqLWYRCJvcdFU+7QGTHL8Nt0vQ3GngcWn0ze9Hmw6TXTCD51/dx9FuL0ida99XRFeyAKfTDcJGTpYLh8tLnk+9aX5NGSWlFVRWVmKz2VRDaq+2lWEY6MkgRUX9C0XLNDFScaLRKIZhkO2xyMvWeoXxTJLJfsMVDofTHhFMvQdvsnpEfiHEfcBO4PfA91HyDwD/yXEZiCkjdP96HKcsxbmoBv+BNzly9kVE//Ioi2Q3ySxfhjLm4IugL8cRjVv4vRr5/+/TeFYqsgtNExm8UMULi+ncN8lKqZyFKkcxEJZBTmUeVz5zJXPeN4f/uKaItq5Bq6XSdVDzOcVFp2cqPN72YA8vvVpLkXaAbP/4L89UKoXD6QTEmAURPo/Gmct8PLtpaD7C4XBgGFOjtjdMyZlLvUwvcSgPMn/0trpHH300fUOPC3knQc2x69IfCJvNNuXV7ViYM91JXpbGh8/NpqLYQbZPw+fRaGo1OGOJl2Xz3MSTFi1dSprcOVk2incA27ZtS99/zZ0Gr7wZ4+rvtxAIq+/05s8Usm1/koRWxt+W1FDqqE3ngwpybFQU27nho/mKAcEliPcKDzo0nZoTTiLQsgObKxuv0+BAs5PVi52YuBCandwcNw6nF9nbWpHtd5CdnYPT6cRmsyEtEyOlcoCmaaInApSV9edbTdNET8WIxWLouo5pquOkUilcDkkiHiM7WwlshsPhtEckB1CHTRZTYVZYBZyNyhENHMUTwHlTGtVxkDzYhGfFfDyrl+A5sJOuklkYTW0ceuoQS1YX8/Ibg93q/sk3dCRETuXIlVRul5ZmRvaV+Ii2qQlZWjKDSXtMeCsgdjRzW7wFPOVodnVpFefZh2qW2FyQ36uZY/OC2d8nZVrQUNfIeSX3Mzf2y3EPJZVK9ZI+lqsxjIH5M5w0dx4bLZWBiCct2gMmNdOdQ/NrI6C0tJT584fXC3onkJ2d/ZYRwAL85qZShFCVdKAEDn/85WKa2nRmVTgpK7Tzn3/qornDwLLI5KZ7l2Pv3r3pibk90C8c17f4m13hYG99isS0D1Hr+BA/PuG9BMIWfo9GeZEdw4Qzl/k4aY4Lj0tL5zKz3DoV5SXIVAdZWXm46GF/cA4ep4Upneimhs/rxO7wYBpqUTOtyMW5556dNkQgMXpfM02Tq86VTJvWry8mpcQ0EmlDZFkWR48e5fbbb0cTFrGY8pTuvvtuIpEIqVSKRCLBI488MuWK08m++xLgJinlC8Dg5VMDUDWlUR0HsZYQhQtKseVlI6/4EGZPHCMnjxyvgdOpoeuZN2dudS7dhxVbbsvWFpJlhRTlDR+6mV5ip6ldTcIDqX4CtQFyZ0yAfFKzK/XPgUh1K9bhXhTn2zjaMcqEn7MAgnvST/0ewelzlIemxWqh9Tk43NuzZKZADP+ZdF1XhihnAYT2DLvPQPSt4IbTUbHZbJP2im57sId7nwlRXeZQEt/1d466fyymVpnV1dWTOt9bgYqKCo4cGVqJ+VbB5dQoLbBTUaK6M90uQUGOjaoyB6YFjW0G9z6jPOddh5NjNoC+U7j//vs5dOgQXV1d6IZBIKRyQCsXuNX1gGoA/dLlecyvKaJkzipajHl8puqH+L0aOX6NUFRNpz+5vgSPS5DoZeZYvVjjlCXlyFQHfn8ueiJM1DYTTVh4PG6iCRtV1bMJy5q0J1Ne4uZzV1+M0+lM54j6ogWGYeDSQhkeEajquFgshmEYWJaFaZrp/6PRKKZpphcqL774Il1dXWzYsOEd84g8KNmH4ZDFUON0HBOAlJJkOJkmPPV/7CLMQJTGUA6Vej1aXg4elyA5oPJr1jmz0lo8bTvb2G/4eM8pw+d6ZlU4OdDYfzP3eVN1z9dRvaZ6ooPNfJ7qBucA+XKXlqa5GRZ5iyGQyXp9WuVe+FBUhaCSnf0FDfFm5fEMg1QqhcPhUGzHwVEMUeMDcPTx9NgeeGHQyj/RTlHh+PV5BqMi8GtCUZPZFU7Va7Xou6Pu39XVRWHhFDjo3gKUlJRMmu5nKuijCXI7VajuinOyME3JHY8HefNggr11SfY3JGnpNKYsxHaskUqlyMnJITc3l1//+te8+PphEilJe8DE6RAqCpGUaJrgrGU+Fs5ykT3nIt5MXsSS3FcpzbeR47dlNFu7nSJ970gzxalLpiHMEG6Ph1QijOkpR1oG5SV+nt6YoLCojHPWLlIsCfRVyqlws81mU4aoFz/60Y8IBAKUlpamq+4UJNGoipAMNESmaaY9JY/HQyQS4eabb+bgwYPpgoWpYCrMCleN8NqlwGuTPO5xAKGmEN7Cfg4uf6kfMxAjFHegtbXiv/gsyosdNLX1r9pzpucQbFLJUTNlIhz2EZmeSwvstHX1v7dkUQm162vp2Nuh5BomAs2h1DX7kOwGV37GLlVljnSj3hD4qtO0P5YlaWzVlddj9ypy06rL1TksXRGbjtCPkw7NuQshMgqNUMc/oHsboKq5jrYb6pwAm78AD0+nuPYm2nbcO66P3wfDlLR0GlyW+22qyxzqu48dGZ4FYgA6OzvfdYZI07Qpl+NOBpecqQpwPC5BdZmDSFyS7dewJDR3GNz3XJijHQYvvRHjzQPvrkq6+voGamrmsHTpUvJnfoDpNavo7DFp7zZwOQXTCu0caR/kZXsrMGZcwz+6zsPX8FOyfVpGs3WWT0tXcCYSCYqKiohGw/hcklRPPTm5BZimSW62h+mlqlnd43Kh65mGqM8jEgMWjbfeeiumafLe976XnJzMMH6fJIhlWWljZFkWqVQKy7Jwu93pfjObzUYymXzHPKJvAZcIIdYDn0aVMp0vhLgTuIzjxQpTQvvOVrwDKte8RV70I924clyU/O/3sBfns2K+mw27Mgk6bQ4byfD4LopQ1Er3Z8y/bD5dB7pY+cVMQvVx9XUWngKdG9T/0Ubo2pjhEYGSYNi4awQ5aaGleWHaAyYrZ/WoEu+BKDkTmh5SKqVZwyucpkNzoEhQh9PukVJJUcj+Qo/WboMdh3ontdZnoPBU8vRdBDqaxq2q2RU0+eV9Af7+2EZCei4LCnsNYddGZWhHQTAYHDIRvBtwLEpyJ4vKEgcLZrk4d6WPr1yRT0m+jcWzXWzeEycYsWjtMghG3tmgy8Cc7Pbt23noya08/JqbsuoVZOVNZ9UydZ22dZu4nRrL5rk5ac7QtoPLzi3iw5/8JAR343EJzj+1/77Pz7bx6lO/5LnnniOZTFJQUEA0GqXC24Dunc0lZ2VjGAZut5sPv6eAC0734/G4MPQkDkd/f1FfjsjrHsTiLyWnn376iIZISolpmmlD1FdQ4/F40jnEZDJJKpV6ZzwiKeUrwDrABdyKKlb4HjATOFtKuXlKo/o/jJ76Hg7ft43cJdXpbTaHDc3v5oQL+/tRPG5tSBJ30UcX8dSXnmLuB+aOeZ4rz8/mzYPKOAghWP755eTNzEu/HolZuF3juDyKz4Cd34HgXtj/c9CD4Mk0JNKIcmj/G2kqk8OHD2dWiWkOMFM0turMzjsKvkFNsMVnKJqcWKMqhx4G6dAcqJBeYBiRu2RXRv4KIC/LRnfIhM3XQem5sPj7aGevR+YshA1Xj/35UX0i2w8k8LY/gGvaqSw7eh50bVYMFCOEEvtwLCqO3gqUlJQck36qyWDOdCfTCu34vUoNdtEsFx88K4trLlHXZ3u3yROvRUdsSn47cO+zaiLWdZ329nbioUbeOGjx3BY1ifeJBMYSFm6nktS+bF32sMfKKj0BPBUIIfjCh/oXcQXZNoLBDi655BKam5vxeDzY7XYKXAF0U6OyRFV49m0XQuD1ONH1FB6PO8MjstlGbjr1+/0Zzwd7RFJKdF1P5009Hk/6WLFY7B31iJBSviqlPB3IBiqArF5mhZHkIY5jDJi6yau3vMqic8pwzcycwHKvWEnRvMzm0MEeS0FNARf96SIlQjcGCnJsBEIjryq37EuwbN44JBhsblh4M7xxAyz4Bqz47RAWgX379pHv6eTwURUy2LFjR6Yaau6JENxJY5tOmbspU/QuDak+8CgXfPpmyDs5HX7LQPyIasR15EJK9V0tmOlS9Cqdr4GvEopPg6zZypPJnjcmU4NlSfbVp2hsMzhxlg2XNw9x2n1K/lobnQhS9We8u3IdfZg+fToNDQ3v9DDQNEFeto0Z05y8/zQ/X7o8j3DMYuu+BP/7cM875hl19hg8+EKYf//5i1TPnE9clhIIm+kK0dICG7/4WgkpYwTi4MFwZMG+TBk3j1sj2xlk0aJF7NixAyEEHR2d5LmCGJY6pmma6dAbgNvtwjBSeDyeIaG5kTzcgQKSwJAcEajQYB9crn7PTtd1otHoO2eIBkAAHwRuEUJ8WwhxvGJukqh7vo4Fly0g253CXlk65v4uhxgixzxeCCEwR3lrfXOKWeXjlPYuWK48oUHeRh/i8TjTirM53BAgGAxSWVmZyWlWsBy6NhGOWniNEbweVyGY49QK8pQoozMQZgJ2fk8JzA0okHj/aX4ammPUm6th/k3p3d1uN/GSD8A/LoWWZ0c8VUuXwS13dWMTOovn+GHVXVCyBmZ+AhZ+a9Rh7t+/n+nTp4/vM73NmIh8+FuNK8/vDx3l+G0kUpJ51U4ONels3pPgoRfD3PlkkNauY1+OPxKicUltfQtdgTD/738luztP5sQad7okXQhBRbEd04TivOEasweh5hpwFkDdXRmbi3NUyLmPdio3N4ccdwKHUxkDr9eLYRjpaIDP60RPJfF6velwWZ9HNJoh6jNa0O8R6bqeZqPv0+nSNC2j2dowDCKRyNsXmhNC/FgIcWDQtixgG/Az4HLgO8B2IcScKY1qkhBCXCyE+F8hxCNCiHMHbPcJIbYKId7/ToxrvIh3xcmaloXR1Iq9fCif2mDMqXJysGnypawOu8hg/h0MbXBPUeyoKiIYhIP1rSTPGEFDB7VqW7FsEU1NTRw8eJDq6upMb8Bb3t+PZCaUlzUYNdfASf815mdKw1UE8QGSDq3rFQO2Kx8KVkLn6+mXbjxvD+U9v8sw6iUlJbTHfFD+PsWNN0K+KBSxKM6z8fvrOiF38Ziccn3QdZ2//vWvzJgxnPd3HAPhH4Zz8Fc3lvKT64vZfjDB/c+FaOs22Lynf6HyzIbJk7eOhXg8TrztBbTEXsoKnQghiBnZqom51JHuHcryadx6QwkXnD4OohlHNsy8CsL9U2wkEiEWi+FwOOju7k5v97q0tOHp0yDq84i8Hld6ex+cTiemaY4oL7JmzZoML6fPEDU1NfHggw8CpI2Ypmnk5ORw3XXXpfd/uz2iM4G7Bm37OjAH+IyUshDFrlDPJGQghBB/FEK0CyF2Ddp+nhBivxDikBBiKN3zAEgpH5ZSfgb4BMow9uEm4L6Jjumdgkym0DxDE5uDMa3IQcsUmjKXD1PwMCqSnSpsNQgNDQ0ji7n1orS0mJ5AB93d3RQWFg5TIiwQWEP7kvpgc4+qcDokxFV2LnS80v+8exvkn6z+d2SB3l+27Qu/yi21P+f9Xz2SNszFxcVs23WU+ztugFQA6+9z2LajJX2eeNLiP2/vZMOuODWVTgqMLcrAjRO6rrNo0aKMlei7DVlZWYRCobF3fJtxx3dV6NlmE8ytdrFwpos5lc4020hrlypAeasaYaPRKFp8N4nwUVy5czFNydxqJwtmurjgdD+fuVhVnto0wczyCer0JNoh2kQikeDGG28kEongdDozDNGCmZ60V+Lz+RTxaK9hmjtvPgsWLc8wRG63m927d/P888+nnw/ExRdf3J9fpf9e6iM2HQhN0/D7/dx6663cc889/d/H21isUA1sHbTtg8AeKeUfAaSUHcCPgdWTGMvtDGJkEELYgF8B7wXmA1f08tstEkI8NugxkKnzW73vQwhxNrAHePsbIyaLQauLRMrC5Rz6UxXn2dKrr8lgbpWTfQ1DPapgxCQYGSZuZ0QU0ekgRCKREfMJlmXR3d2NpmnYrCDSqbSJampqOHRoQP7F4SfHOjRmldlI5xgC34xM3jkznulpufJVqbllIpqfgspLmVet+qsONKbw+Xy8sTfA0xviHMj+OoYluOO+N6hr1nl6Q4TDR3Se3xzjzidDfOqiXPyydWi13yjQdf1d7w0N+Y3eJago7p8037faz3mn+ikvdpDjt2Gakj/8vYejHUaG9taxRGNLhA7tPEpqLsKXVUC2T+OKc7MpLVBKpXlZU1hcLPoe7P0RtVsfprHuAHV1dcybN68/TBrYTlbRrLQh8vv9JJPJtEe0fFEJM6un8a1v9YeFr7rqqoww6+AquVmzZnHBBRcMO5xUKnN+GGhw+ryoSCQyZY9oIqyJdiCdsRJC5APz6J3wB6AeGDvBMQhSypeFENWDNq8ADkkpa3vPeS9wkZTyv4AhYTahvo0fAk9KKfuy1Wei5MvnA3EhxBNSSmvQ+z5Lr+LsuzFm3xU001U4A2G3iSk19gkhcNpVD4x9AB3Nhl3xdE9HBoyo0sMZBI/HQ27u8P1H4XCY5uZmAK799CU8/JLywFwuV+ZFnr+UKuMRyBqBdXoUbNq0iYqKTPVZHP50QQKROnAPuiTLL4Qt1ynDt/CbXL4gh121Sd7Yn+C1HXEuXZdFZ49BfY/O/zy/nM+tvZvpzhf4+V+XsvNQkjOWeJhWZGdmuYOSPBt0TGxFqOt6xir03YicnByCwZEVfN8tOHmuWmC0dBq850tNOOyCpC7ZuCvO3U+H+PanCplVMTUF0T6EYxZ3P9lJV9iOzeHDY1ekrtnDMcVPBp4S8FWx56FvYOvp4YtXnsm/3/wNPnbRKtj3c9h2PY6zD+F0/h2AG264gbVr1/bngxwCh8OWcT8uWLAgneMBuPHGG7nhhhvSxsPhcGSQnw7EQI/I7XZnGKI+b/7t9ogOAGsHPO8zBE8P2q8Y6ObYoBwYSAV8pHfbSPgiiv/uUiHENQBSym9KKa8H7gb+d7AR6t3nd1LKZVLKZSP9IG8XpGUN8YgaW41hDdEQtD4H7ROTg6oodgzhXDvaYVBRPMwaxYgO6xE5nU7Ky8uHTYYmEgnWrVN6OVk+F+s3x9LhxI6ASU8vGWQqaylVxuOqgm4C2LdvHxs3bhzeu3AVqabSfT9VjbEDkT0H5t2oQnjl72dWhZMLT/eT0iWWlNzxRBAhBPOrnTS06NxwZxnT3I10B01mTHNQ36xTVebgkxfmZpDIjhf/DIZICIFpmu/ayr7BcNjBkpDsDa82thmce4qPvfWZq/o7nwzy2CvjzyGZplQl/qi2htbOKOG4EvtzOwWFubZjZ4gAStaxM3IS5546kwq24N75FRbzV9h2PVReijO7PH3teL1e1qxZw+mnn55+u6ZpGdeWpmkZhqiiogLLsvB6vRn7DIeBi0W3250RSu4rXLAs623NEd0K/JsQ4hdCiG8CtwB1wDOD9jsXGKoNMDkM9+lGvCuklL+QUi6VUl4jpbxt0Gu3SykfO0bjessgu3qwFWc2hD7yUpgZ08YxaYX2Q3D3hCaOudVOfvtgpqieYARa92FCc31hsZKSkrTnMxDxeByPp1+186tX5PPaDhUmaOkyaWpVF/rGgy5217wK7oktBLZs2cJVV101iKakF1Ufgj23gDNPaSgNRv4S1SzbCyEEn7ool9NO9FJWaGf1kkLWniRZvdiLJgS5Bfn8fu31nFwVpMb+PGcu9VKUa+vtTxo/O4KUkt/97nfvekMEMG3atGF/13cj1i338R/XFGK3QV62Ru3RFOeu9GW0KUgpefzVCD+5u3+tbJpy1DBebbPO137WxqGmFNf8sBVpJjGkk/xsG7l+G4trXONbKI4X+UsgdxHX/WQLX758IdTeruTg598Ecz6Pw+EYVSZE07SM+0EIkWGIBuaX+jDQwAzcPtAj8ng8QzyivnzTVD2icYfmpJS3CyHKgOuAXFS13HVS9repCyGKgItQza3HAkdQ6q99qAD+Oe6KScJqbcdRmdkHNLdaXfTDwekQJFIWbqcGiVawDFK6xDlY4nsEVBQ7mF3RPyFu2BnPiMFnYJjQ3J133onb7Wb16tVs2rSJyspMCp54PE5+fr9hLc6385WftdPYZhBOeGlu72FRjYcf/6Wb39w0sYhuHytBXl7e8Dt4KyCwbQjTw1j42HuzEULQ0BDHNOOcvKCQ95/mpzTnRlxNN/GZ5VZFAAAgAElEQVTxM1px9TTgOLH3u+isHZPKZyD6mnn/GQxRTU0NGzZsGF4t9l0Gu01wykIPZyzxsni2i+e3xMjPtmFakvufC3FijZuOgMHMaQ48A3p7Dh/VqWtOsWyeh/xsbcgizLIknT0mP7u3G69b4EzGMXGTl21jyRzXW9uQfMaD8Oa/waKbVXhZCGyQsbgbDJvNlmGIBntEfYZoJI9o7969LFy4kFAoNMQQDewnstls6TzR29pHJKX8LyllhZTSL6U8Q0q5c9DrHVLKUinlb6Y0qn5sBmqEEDOEEE7gw8Dfj9Gx33Y8+drw4YBkyuKVN3u7mVvasE/PnJBH+5HLCuy0dvWy6ia7QLOTTMRxjdMQgepHSqQU5c8DL4Q5Z+UIwnhGZIgh8vl8eL1enE7nsBLT8Xg8o0qnKM/GFz+Ux/NbohQX5dPa2oWUkovX+CkrnJjQW21tLfv27Rt9p3XPQ/nEqvb7vu/CwkI6OzupLnNw8lw308pyoPoj+FvuwGEMIEWNTMwQDZwU3u1wOBxDEtbvZmiaoDjPxgWn+/npV4rRNIFhwm8e6OGhF8P/v70zj5OrLPP996mlq7qru3rvdJbOvkEICZIECIskCIJgWAVhGBAZZRx0nFFnro7OdRl0xqt37mUcuMKMCuqMioqyiMKMbAJRiYAkJBAIZOkk9JL0Xt1d23v/OOdUn6o+tXVXdVV3v9/Ppz/ddda3Tled33me91k41hdj9WIf73zH2E24bzBGaETx0ycGxhXoveUfjzI0rBCBvQfDLG06isc1SqDSQ0PQXTQRShy3oh42/j8jEdt2LrvVkkqqa05EEsEKIpIQIvv30i5EVpFUyGwRuVyuhBCVquhpwRGRHwDbgVUi0i4iNyulosBHMeah9gD3KaVeKeU4J8poOM7X/8N56mz/0QjP/HGYeFwR7+jGsyBZiDK52ha2eo2inSNvGx1TW84h3vlbxyi7dLS1enngqUH+49G+zMl3kfGuuZaWFi6++OK0u8RisSSz3+MWLntnNT+8bT7vv6iNx547yo49I7mVE0qhr68vKZ/BEZcXln8o72OD8cRoZZknaDoDjjwCtkrGDL2VV7RfKBSiqanJ2Z1Yhvh8vmklnjdvq0NEEjfzzp4oa5f7ePVAmGf+OJxowW3lHfUNxhkeidPTH0vKJfv7u7roOB7j+7/sw+9zUV3pwhd+ldFYDetW+IwOvFOBQzv41LI8dtK55qw5HUuI7NskfUc9noSw2B9CnFxzJbGIiolS6lql1FyllNe0ur5lLn9EKbVSKbVMKfXlUo9zogwNK2rTTGge6ojym5dCHHg7mnMOkUXbHK9RvHRwvxGyXLOC+MCb+HMpK2KyboWPlno3H7+mgU9dn8WNNc5tkXmiMh6Pj3taEhEClS5qa4OsXxph+85hTliUParJLgpKKUZGRpLcC4XG8X25vLDkBuNJ1SI2Ap70rhI77e3tHD9+nG3bto3rBVOurFmzJrkkU5mT2pBweFRxzbtqON4XY8eeEfoG4sTicL/ZAqR3MMbPnhrkSHeU0KjiPx/tY+cbIzz7x2Hee3Y1L70+ytxGD411bjz+BoY8a1m3wk/lBB6eCkWmQrlOwQpWYqzP53O0Yux/ezweR4soNWrObhFNlrIRoplOOKqoqnQ5VjIYCSvee3a1UYstJfIsW+BBhVeIxJTZkK4JKudT0fkL5zmi6PC41twAwYCbLRsCBCrH+8dtAyFdnEgmIVJKpTXbRYQ1y3w88twQa5Zl/0A//fTTib8HBgZK1z7hlP9lJMTu/4HhDnWq9J2Gjo4OOjs7xyUVljP19fXjLcNpRE2Vi6XzK2iqc7N0vpfT11bS0x9j575RvvBvXQyG4hzri7H/SIRjvTEeeGqQO3/Sy7nvqOLiM6s5bY2fuU0eNi54GYn3c8baSrZsKN4DUCwWy+rqsucJpZLOIrKsoRUrVrBp06Zx1o3L5TLy/cy/IXuwwoxzzc10whHFyrYKHnGYJxoNx7nu3UFW977KsciYZaCU4sXXRgkGcnABxEJG+R2Xh6Gqd1AXf238Nl2/gWevg+OpeclZ6HkZ9n0r62ZO8wnZLKaaQAV3f7opKY/JiePHj9Pb25soDdTZ2Zk296GQVFRUJFcKtxh6Cw7+CJ7/CKz+q5yPF4lEGBwcnFZCBEbQwjPPPJN9wzKkbY6XZlOErnt3kDVLfXzs6nq2bghQYStzddpJRqWR808LML/Fw8JWD62NHv7x1hbmNXtoqokQqF/JNe8KTi5pNQvHjx9PCvBxIpNb18kiGhkZoaamhoqKCqqrq2ltbR1n3Xg8HrZu3ZpUMNX6Prvd7qJGzWkhmiLCEcXWDVWOFa9HIwqfV5hbE+X1hacklh89FuMr93RnLZro8wqRkUFwG09p3dWXUBtxiKAPHYYN3xhXWDEr/Xvg2O+N0jgZaGxsTCpFAs6uOTvNzc14VE/G48ZiMb7xjW8wPDzMM888w+23385LL700Pom1CDQ1NTnX6Dr7fggshfmXGtF5ORKNRhkaGsoYfluOLFy40DEYZTpw7QVB3G7h8nNr2LrBmOT3Vbg4aWkFJy3z0TMQ54y1lVy5pYad+0a54T21rGirIDQy5gE499Qq6moD1DUvyzkidSJ0dHTQ1dVFS0tL9o3T4GQRKaUIBAJJLSHs38sPfvCD+P1+Nm/e7Oia83g8SQJlnccSorKaIxKRPNt7zh7C0fQh1eGIwusRKjwuhm2TpW8dDnPOKVXMd0outdE2x0tPz0CiIGlPfAHV6tD4DYePGL2CKucm1VrLSt8eo+11mqZ0Fk1NTXR1dSVl42dyzYEhRF1dXRmPGwqFEjW19uzZQ19fH3PmzJmSOm1W5Nw4RKDlbCMhNg8sIZoOodupVFVVJapAT0dOXJLs/r3g9Gpa6j30DMT48keaqa12MzAUp8IrBKtdDITGvosL53gRMVzhxRSiBQsWcPDgwUkJkVP4NpAQIqsDr/17OXfu3CSXXGqwgiVE6Vxzqa0k8mVCQiQiHxGRv7W9Xi8i7cAxs8p18R9Vpxn23B6nsjzjKl0DoRHFlVtqWDIv89PzwlYvfX1jFlH/SBU+l0OUUzwMbp/RZ6c/S9izRd9uo1xOcJXR5ycDVkmYhx56aOyUWVxz9fX146yoVPbs2UMgEMDj8XD06FEgc/hqIck4vrbL807AjUQiBeloWQpOPfVUnnzyyZK0ES8W1VUuegeM99Pa6OGuzxgRq1U+V1IEXTgcRkTYempVYasopLB27VqeeOKJSbmdncK33W43S5Ys4Zvf/GbCQnIKIrK3joAxi+jiiy+mqakpbbDCnDnZuwVkHPME9/sYYJ/1/heMRNM/MY/5T5Ma1QzEEqJ5zZ6MFbOrK92JciLhqGEpOaJUojPe/GYPQ4OD4DYitwaH41RkMqJqTzAEJhe6t0PbVXDK143GcRmw+qZ0dnYmyv1kEyKXy5UxICMajbJjxw5qa2tZtGgRjY2NXHLJJRnDVwtJtvHlSzQanVZ5OXY8Hg9z587lxRdfLFkb8UKzalEFX/3o2E2/ym/cEqurXERtb7Gvr4+mpiZaGozCpsWipaWFPXv2FNw153a7WbRoEVu2bEksSxUiK1gBxgvR6tWr8fl840K+LSG66abcuhmnHfME91sIvAaJagpnAn+rlPoh8A/A1kmNagYSjigqPMLcJg9HMzTwmtvk5q0jxj8/ksGdx/7vQ8cTgNFXaHAoSp9ZYHd4VOHNJESBJUYh0FwYMhvVuXOb0zh8+DBbt25NCvfN5j8OBoP09vY6rhsZGaGnp4fq6mqi0Sg1NTW0tbVN6otaKI4cOcLXv/71vPax2i5PVzZu3EhPTw+7dhWqildp8XqE2urxLt53rPLx9zePNXq03MPFpr6+nr1792YNVshEqhBZAmMPkHESInvuVaoQWcewW1rlEKwwClh3pi1ACLCqbR7HKAGksWHNEc1t9HCkK70QtdR7jLwgxuaOHOndZQQQmKxoq+Ch3wyilOKRZwcRhyS4BC43GUr2jSePicjW1lZOPvnkhLDkMom5bNky3nzzTcd1o6OjRKNR2traOOmkk6irq6OlpSVtte9i4HK5HC2AY8eOce+99+Z1rIqKiuKWhCkybrebd73rXYm5QMtN197eTmdnJ2DU/zt27Fja/+l0QESMslkmoVCoqDlrAI8//jhHjx6lu7t7UvOfqZ8xyyK65JKxCiN268dpmTWXZFnv1jp7kI3dNVeqYIXfA7eKyBrgL4FfKZVINV/KDK8HNxEs11xTnXtctWs71VUu+gZjSfs44q6E0a6Ee25Og4dIVNHZEzNaK3trIZxqZRT/BnjZZZfhco3lI+Xi1qqvr087CW7Vtlq3bh0LFy5kzZo1hRtsjjQ0NDjOE6UN7c6Ax+PhE5/4RKGGVjICgQCPPfYYnZ2dRCIRnnnmGe655x4efPBBQqEQjz76KDt27GBgII+gmDKlp6eH++67L2N9t0LwyCOPsH379rSdVHMlNcnUEqIzzzwzaVmqeKTOEbnd7oRFZK1LZxFNZT8iO5/EqPm2E6NNwwdt664Bnp3UqGYgoRFFpU/MJy2jj5BTgIIdo09Qhg3qTzEqbteuBqC1ycO/P9DLzdvqYGiREelWMQnLIR4lL8tpEqT7II+MjNDQ0JD4gixfPr5DbLFpbm6mu7t73ASyx+PJ282mlCrrrqy5snHjRrq6unjqqadoaGhg8+bNbNmyhfr6+sRT8/DwMH/4wx8466yzSjzaydHT08MVV1wx6ciwbDQ1NREOh9m5c2f2jTPwkY98JOm1iIzLO8pmEfl8voQQWSIkIuOEqKmpib/4i7+YuurbdpRSu4HlItIIHFfJj72fAt6e1KhmIAOhODVVxj9rToOHzp4YrY3ZL3/GJ42GU6HnxYQQXbApQDDgMo+70BCi+vz6+yTRvwdqT5r4/uT+pFRZWeno/ujt7eWcc86Z1BgmS0NDg2On0ng8PiNEZSJ4PB62bdtGKBTirbfeoq2tbdz/2vqfdnd3l64KRgHo6+tjyZIlRXepWtfopJMm951zqpSeKkROc0T2GnMVFRV4PB5GRkYSYd1KqSRry6rC4Pf7S5tHpJQ6ZhchEalTSu00W4ZrbBjhksY/qz7oTiS22jVcmdaH3T2XkZoVMPB64qXbLZx5snkjD5gWkUU85lg8MSOhw3kla9rxer1EIpGcI85WrlzpWEm7r6+PdesmIaYFIF1l8dSCrrORqqoq1qxZk/ZGdN555/H8889P8agKS39/f9GtITDEYc+ePUU5di4WkdfrTSw766yzEp9tt9udEC77HJG9LFBJghV0HtHkaAi66TE7k9otJQDEyOJ+4OkMHSStm7vLAyrNfJOv2ZhDshh5O7k5nK8RhjvYvn17erEYPmokv06AmpqavOYHGhsbHdtSl+PEfldXF3feeWfeQhSNRqdNxe1C4Xa7qampyXsurZyYKss3HA4XLQgnF4vILkQXX3xx4j37fD7HqDlrmdN8U77oPKIpImbLAayrdtFjJtH1D8XH1ZJrrvMQi2WwJOIRIzEVYHznc4PUD0aoHSptzweNp8Gx3/Pkk0+mL/E/fMRoxjUBrACEfD6g06Ul9fDwMLfeeisdHR153aBCoVDRJ7zLkZNPPplHH310xuQeFYtito/PxSLyeDyJ76s9BNzn8yUCHlLniEpqEaHziPIiNBIn4B+71HU1bnpNi6h/KE6wOs9/Q2wY3GZOQPVSGNiXefsdfwmHH0pOSA0shtAh6urq6O8fX5EbMDuypr9xxuPxtPumizTLRHV1ddlGWbndbqJRw/oUERobG3nzzTfZtWtXoulYNrq7u2elEAWDQU4++WT2799f6qHkTTQanTKrfCqFKNsckTX/A2Oh3Jlcc6WyiHQeUR6895PttNq6j1Z4hUjUePrvH4w7lgzx+1zjukUmiI2MCVHtSRnK9ZgfDrcfDt6XPN/jb0aNdFFXV+ecTKqU0XsnA729vWmrSDs2lcvC3LlzefvtsTiXcnJlpV6na6+9NnFjtY85E1Zb9dlIW1sbe/funTZWL0BnZyf//M//zKJFi6bkfOFwuGjFcPOdI7IsIEgWonSuuVJZRDqPyMbQcNyxfpyFUqStoH28P+ZYUn7JXG+i1M844iPgMm9oVfMMF5pjmLUY/Yd8zbD8FvDang/ERTgSp62tjfb2doeB7TDmkTIQiUTSVsCeSGkcK0zaYnBwcMpK+WTDbuEppZgzZw5Hjx7llltuySvvYzZaRGA8Pa9evbpok/HF4MCBA7znPe9h4cKFU3K+crOIrH3q6oyOt9ddd11STbnKykoWL15cUovok8CJGHlEbcBnbetmXR7RnT/p4dHfjj39x+MqqXLv8gVe5jU5P9l3HI86itSKhRU0BNPMP0SHE3Xl8Lca0W3isG3lHKOXUGUrnPDJcfNGPd2HqBrcMT4fRil467tGJ9IMFPqL4/f7EwmsUL5CBMaXcGhoiDlz5uQsRK2trVMSfVWuLF68OGfrsRwYGhpizZo1UxYZWcygiHwtIrtrrqqqCpfLRVNTU5LFVl1dzeWXX166YAWl1G6l1HKgGVislNprW/0p82fWMKfRk1Qtob0ryq3/a+wLt/nkSuocrB6lFNGYc+Xtxlo3f3pRmnbAcZtrzuWBkaPOVaArFxj16ALOroXvvrgUNdxBa0NVcquDgdehYWPWZNhsroTJfjgHBgbKRoiqqqqSgjr8fj9DQ0M0NzfnLESrVq2a1UJkVX2eLiilyjJqcyLkaxGJSCJ53Ov1Jq6Dk2u5lMEKFj7gChH5kIhcKSLzZmMeUTyusGtJNKpwZ+k46nIJ//37EJvWpJ8zqK5K8++xzxEBjHSA36EMe3Cl0UW06czx64BNp5/FO86+gibXW8k9gXbdllMibDaLaKI3HWu/t99+e9Ll5YuBldgXCoVoaWnh2LFjtLe3c9ttt2Xdb7YTDAYdw/Q1xWUiFtFVV10FjAUlAHzmM58Zd+ySueZExC0idwIHgB8Dd5m/D4jIHZKx4ubMxP5/GBqO43WTCEhworXBzfN7hlm7zFYXKtcbVaoQDbzhbPXUrID528wip2nGHVxOLYfHbg5Dh2D/97I2wYPi+LRramoYHBzLoSrXvj1W+ZPGxkZ6enrYu3cvv/71r0s9rLJn1apV7N27N/uGJSYWi025NXT33XcX7di55hFZ79lyt1VXVycJlFPwUCmDFb6IUV/u74DFQKX5++/M5V+Y1KimIW6XEDVzf4ZGFKes8nM4Q5Xt+S1eDhyNjHfL5fLht4dvA6z+hHPTOnHB+q9kPpa3Dm+8NxGazB8/C+u+nOj2molsrjm325137ojV5bUcsYdwg+HTr6ioIB6P09nZSUtLi7Z6shAMBpMeNMqR7u5u7r77btraMvffKiSxWCzR9LEY5GIR1dXVMW/ePMDoFLtt2za6urqora1l2bJlaY9dymCFG4DPKaW+ppQ6qJQaNX9/Dfh74AOTGtU0pD44lhsUGomzbEEFb2eost02x0Nj7QQnJqMh8Nh6oyz7YF6tGpIQGUuKVQqGUxJfM5DNIqqqqso5x8bC3jq83PzzqQEL9soK27dvZ9GiRXzxi18s1fA0BeLQoUNcddVVLF26dMrOWezKE04WUer3a968eVxwwQWJ7Zubm/H7/TQ0NHD++eenPXYp54hagJfTrHvZXD+rqKka63E/NBxn2XwvR7qjxGLO80XBgJuv/MUEL1N0MFmIJou4DREaeB2W3AiLr8tpt1gsljHPJxAI5C1EE9lnqmhsbOTYsWMJqycWiyW+gHV1dVRVVaVtGHf06NEka2o2E4/Hy7rdeG9vL01NTVP6IGSPFi0GuVhE6SL2skXylbLEz17g/WnWvR+z6sJsoqbKRf+Q8eUaGIrTNsdL/1As0Zm1oEQHwVPAaLLaNUi4CzWwD2pWGpF4OZCtDXggEBjXGyUXlFLs27cvbY+iUtHY2JiwiEQkYRHZr0F7e7vj0+1DDz3EkSOzKr0uLYsXL+bgwYOlHoYjsVhsSqspWAwPD3PHHXcU7fi5zBFNVIhKaRHdBnxARP5bRP5cRC4XkVtE5L+BG831s4qagIsBU4jCthbfoxGFr6LQQjRUWCFq3kwgfoSh4wfzqradLbw1EAhMKPxaROjo6Ci7ltoVFRWJjpUwlvcxOjqKz+dDKUU4HKa9vZ1YLMahQ4cS286ZM6dsAy+mmra2tqRrU0688MILnHLKKVN+3pGRkaKG9qe60J3EI908UNlaREqp+4ALgQBwO/BTjMKnVcCFSqkfT2pU0xC7a85OaFRR5Su0EIXGEloLQdUC6tQheo/sTK7QnYVsQlRTU5NxkjMdHo+HY8eOlU15n3RYzcN6enqor68HjMn4gwcPJrp6WgSDQa6//vpSDbWsSNdWoxwYGBgoSe+kkZGRopZ/ShUTJ4voAx/4QE77plISi0hEvCJyJrBLKXUGRsRcK1CplNqslPqvSY1omhIMjLnm7AyPxPH7ivAkXGDXQd1J19PbcGnW+nJ2jB5L6d9bRUUFS5YsyX8sdXUcOXKkbHv9WHNEfr8ft9udiB4UERYuXMhvf/tbhoeHk6wnKL/gi1LicrnKrhp3KSMeh4eHiypEucwRpSMXISqFRRQDHgdOAFBKxZVSnUql60cwO6j0CcOjyZegIehm/9EIVf5C34AK/4WpnXsSfeHsIdtJoyjSF9fqyVKOFpHf72d0dNRo+e7343K5kqIHGxsbueuuuzhw4EDZPvWXA4sXL3bseltKStlJdmRkpKh1CHOZI0pHWbrmTMF5HSi/lPcS4vSP2LoxwH8+2k9lMSyiAjNRd0kxnvLr6+tpbm4uSyFqbGxMtKqorKxM5BZZQlRVVUVXVxf9/f3jLCLNGIsWLeLNN98sq7yrO++8c0pzh+wU2zVXbIuoVMEKnwX+p4isndTZZwj271IsPtYSvLrSRVwxMYuoBAZmvjeFYt1EAoEAp512Gg0NDUU5/mSwd5K1XHNWeXylFF6vl2g0qoUoCyLCunXreOmll0o9FMAIPNm8eXNirm+q+fKXvzyhCNNcSQ1WyMciuuWWWzKuL2VC6+eARuAlETkoIs+LyO/tP5Ma1TTCfjNWCj79r1001409QUSiCk+WunPjGDoIL/5Nhg2KM9dQLnMYIsL8+fPZuHFjqYcyjrq6OgYHBxOuOatrpf2LXlVVRX9/f5KFWS7XtpyYN28enZ2dRc+hyYWenp6S1jU888wzOfXUU4t2/MlYRPPnz8+4vhAlfibq+9hl/pQVInIZcDFGQu0dSqnHzLp3/wAEgR1KqXsLec6e/nhSu4bWRjfnnzaWbPpPtzYzpyHPy9z1LAztL9AIi8dsvLm63e5xwQoejyepTpclRNoiys6GDRv4zne+w+rVq9myZUvJxtHd3U1jY+b+W8XEXli0GExmjigbJbOIlFI3ZfvJ95gi8m0R6RSRXSnLLxSR10TkDRH5dJZx/Vwp9SGMEkPXmIsvBeYDEcChA1zu3PNwL+FIsjvqK/d00zbHeBqe0+ChpsqVZAEtaPHizTehNXwcmjZDr4PWH7ofmNVxIWWDFaxgt4iUUgkh6uvr49FHHy3xKMubxsZGzjvvPI4fP57ciqTAOHYhttHZ2VmyQIWpmCebjEWUjSkteioijSLyUxF5d4Zt3m1uM5HaNfdg5CbZj+cG7gAuwmjEd62InCgia0Xk4ZQf+zk/Z+4HsArYrpT6BPCRCYwrwS+fG6LHrCcXMwucvvDaKAtajH/y8rYK6tM1s0tHdNgoNGoiIhDuhcbTYOhAyrYh6HgSVkzqbaRFRMq69Eq5oJRCKZVkEdmLv1pC1N7ezvbt2xP7aJxZuXIlGzZs4Nvf/nbSdXrjjTc4cOBAhj1z5+mnnx4XjKOUYnh4mOHhYaLRaFHnaDJR7Ig5YJzITmeL6K8w2oA/lmGbx4AlGB1c80Ip9TRwPGXxJuANpdSbSqkw8EPgUrPn0SUpP51i8FXgl0qpF8xjtANWrZhJJS401Lo53mcc4l9/bBzy/RcEaTFdb8sXeLnojDwrCfS8BP2vQt+rY8viEaheDMOHk7ftfRmaz4LKuRN9CxlJ7ZCqcaayspJ4PD5ujshK8J07dy4DAwN0dnbS399f6uFOCxYtWsQ555zDCy+8wCuvvAIY5ZL+8Ic/FOQz2dvbm/hfWGL3k5/8hPvvv5/f/e53nHjiiZM+x0Tp6+ujtjZNE8wC8dd//ddJrwshHhZnn332pK3JfIToauCbKsOjnbnuLgx3WCGYD9hrgbSby9LxMeBdwFUi8ufmsvuBd4vIN4CnnXYSkQ+LyA4R2ZGpBUFjrZtjphC9/MYosZiiwmbxulySvpldOgZeh/nvhVBK7S1/KwyntFX+zVVQe0J+x8+DiVTLno0Eg0EikUgifNuaI7J43/veR39/f5IQzcb5tHxZv349brebPXv28Nhjj3H06FFOP/109u7dmygYa1mj+RKLxRJh90899RRvv/02oVCIq6++mtdff52WltLVaZ4KIUqlkBbRCSecMGmLLp+RLAJ257DdHozeRIXA6dubSQj/RSl1qlLqz5VS3zSXhZRSNyulPqaUcqwqqJS6Wym1QSm1obnZoeW2SV21iz6zekI8rjjYUYCExXgYqpdByG79KKPwqLIZcCoOS2+CuuJFzBdDiD7/+c8X9HjlgCVE5557LtXV1UnBCkopLr/8cnp7ezl27Fji5qfJjt/vZ/369SxYsAC/309jYyMtLS08+eSTPPHEEyil+NWvfsVbb72V13GVUsyZM4dDhw7x8ssv093dzb333suGDRvwer3cdNNNJX1QKIUQFXKOqBDkM5JhjMizbFSb2xaCdsCeYbYAKFkJ40Cli0GzntzSBRW8cagAQqQiEFgIw/a35fClOPoYzClcVJFT5exiCNGXvvSlgh6vHPD7/USjUTZt2oTP50u45jweD9FolGNZk94AABlYSURBVLq6usTEeyAQ0PNueXL66adzzjnncP755+PxeFi/fj1Lly7l2WefZdeuXUk9oXIhFArR1NREd3c3e/bswefzsWXLFlatWgWUvoLHdLeICkE+I3kB2JbDdpea2xaC54EVIrJERCowWkw8WKBj541VxiceV8ypH3PTTYp4FNwBiI9mrtwTOgTBlZM/n4m9qZtFqhB1dHTw9NOO3sxZTWpJE8siqq6upr+/H5fLlZjXmDdvHp/73OfKtu1BOWNd43POOYdly5axe/dubrzxxrytzP7+foLBINu2bWPevHn4/X42bdpUcgGy0BZRfkJ0B3CziNyYbgMRuQG4CfjXfAciIj8AtgOrRKRdRG5WSkWBjwKPYrj87lNKvZLvsQvNaFgRrHYzNBx3bHqXF/GIWWjUOk6a440eg4rC5TnkIkThcJjXXpt1raXyxrKI1q5dy+7dhvfayiHyeDwcOHBAB4EUgOXLl9Pc3My+fft4++23s+9gYgmR2+2mpqam7Irp9vb2znqLKOdHAqXU/SJyO/AdEfko8CvgIMZz/ELg3cAG4P8opX6W70CUUtemWf4I8Ei+xysmw6OKSp/Q06/yD05IRUUyVLy2iVJsGDyFC/G0eunY8Xq9SSGusViMI0eO8OKLL5akR0u5Yu/Qag9W2LJlCxs2bACM1s+33347XV1dRKPRsqs0PR3ZunUrANu2bePw4cO0tubWsqS/vz9RHaCmpqbsOuX29fUlCv1OFS0tLWUlRHmNRCn1SQzXWz/wKYwIubuBvwEGMEKrP1XoQZYbodE4VT4XI6NjDfAmTDzqIETFzzlxsohSCYfD3HDDDXrC3QGfz0dHRwcwZhG5XK7Ek+369eu58sorGRgYIBaL5fUEr8lMU1NTot5fLgwNDREIGNVO5s6dO6HWJMVkcHBwQg0kJ8Ott946fYUIQCn1kFLqPKAGmGv+1Cil3qWUerjQAyxHBkJxagIuqqtceCZr5ccjIOkMU5Xm78mTTojscx+RSIRAIKCf5h2orKxMJFteffXV4/IoHn74YebPn08sFqO3t5cf/ehHpRjmjMTlcuUUAPLzn/88Ee5tL79UylI+TmTr6zUbmPBsnTl/01HAsUwbBobiBAMu/uzSWgqSMC9C8txQ8UNJc7WIrPbYpZhQLWfcbjfDw0Zw6Ny56ROMY7EYXq+37OYlZjovvPACe/bsYfHixbqqxTRgdsvwBBkIxampcpkTfoUUDZX821UBsVFzWWHFKR8h6u3t5Te/+U1Bzz+dSa64nvkmF41Gqaio0CJeYHw+H6Ojo2nXt7e309DQwAMPPMC8efOmcGSaiaCFaAL0mxZRQfFUIa6Uas3eWoj0G/NIad13EyMWi2V1B1idRy+88EKCwVxSyGYPIpLITcmEVcNsqiejZzp1dXUZ54lGR0dpbW3lyiuvZPXq1VM4Ms1E0EKUJ/4KF/uPRCYfLZeKpxqXK8X6qaiFSB9EB8BbU9DT2dtb27EXPo1EIng8Hmpra3VSpgO5tLuOxWIEAgFtERWYefPmsXfv3rTrPR4PGzZsYM2aNVM4Ks1E0UKUI7G4MeG5boWP+S0e3AV1yWEIkdsSItPd4zWFKDJ1QlRZWZmY+7AnbnZ3d7Njx46CjmG6YrnjgsEgIsKhQ4fSbltZWcmJJ57IsmXLpmp4s4L6+nrC4TBDQ0Pj1oXDYfx+P/Pnz9c1/qYJWohyJBxR+LzCCUt8vO+8wooCAF67RWQtq4Vwn+Ge80yNENmTWu3zH+FwOKkk/8DAAC+//HJBxzSdsG5wp512Gq+++mra7SorK2ltbS2bLP6ZxIoVKzhyZHzFr1dffZVdu8qub6cmA1qIciQcGcsZKspTlqcal3vEKG4q5r/FG7RZRIWdo8lFiOxs3bqV+vr6RCh3f38/PT0947abbYhIRpFxu92JPjc6equwVFdXJyyizs5OXnnlFeLxOPv27WPTpk0lHl1uaJe3gRaiDPzov4wS/jvfGGE0rPBVFNHM9wRMiyg2luBagjmidELU2tpKQ0NDoq2BfsIfw+PxOLYFHxwcJBAIJKovlFtG/3QnEAgkhOjw4cM8++yz7Ny5k9WrV/POd76zxKPLjYMHD7Jw4cJSD6PkaCHKwO63Ruk8HuVr3z9O72AcfyGFKPXpODFHFAUxw6qtqLnIQElcc6nU1dUlrKDZLESpls26det4/vnnx2134MAB+vv7cbvduulgEbBy3Do6OnjwwQe54oorePzxx8uuckImdu/eXdKmfOWCFqI0xOKKw11RegfjLGz18on/28HcpgLefJ98D/S/PvbaU43LNYKoeLIQWXNEJXbNgTFB3NvbC2g3k909GwwGGR0dHVeBIhQKJVx3fr8/Y96LZuLs27eP1atX09jYyMc//nH8fn+ph5QzPT09NDQ0lHoYJUcLURoGQ3H6h+KEI4ql840b9vzmAgpRqB2ig2OvExZRbCxnyOUBFTWEqKKw4b/RaNTRqsnkQqqpqRnXbllj4HK5uPPOO5Pq8lm5WpZFZEUjagpHZ2cnHR0dXHnllWVXUToXQqEQVVVVpR5GyZm9/pUs9A/FqfAKoxHFuhV+LjunhtrqApZpqag15n4svIZFZAhRynmKEDVnr7+VKy6XKyFAWoiSaW5uJhgMcvToUWpqjP+VVb3C7XZTUVGRVNlcUxhOPfVU+vr6pq2reHh4WAsRWojSMhpW1Ne46B+MMbfJQ0NtgWuFeYLG3I+Fy4/LFcFRiFTMsI4KSDYRcurgmjSkPIRoIqJXzji995UrV1JfX8++fftYudJoYGhvE6GDFYrD8uXLSz2ESREKhaisLFx7l+nK9LJjp5BITNFY66a7L1acaDlvTYoQuQGFEC+46EyEbC4DpVSitH4m7JUaZhKpwur1epk3b17SPJDV88kSo2eeeYYf//jHUz1UTRkzMjIyrea0ioUWojREooqGoJuuntjkew6louJG8EHUoc+PcrCIphgRYXBwMOFismM1z1NKcckll2Q9ltvtnlVtJJqbm9m/f3/itV2IHn74YV588cXSDU5Tlswkb8FE0UKUhmgUGoJuuntj+AotRNEh8LcmW0QWEit4gdN8UUpx/Phxx2geK3cjV3fbTBSiTG7JNWvWJEr+KKWSXHORSISKioqpGqZmGqDnWg20EKUhElM01rnp6o3iqyjwZYqNgq8pOWrORJzmiKYYl8vFsWPHqK+vH7fOCu/OR4j6+/v53ve+V4yhlox0793j8SQJr90imokuSo2mEGghSkM0qmgslkUUD4On0nDRpVIGrjm/309/f7/j0/tELKJQKER7e3sxhlqWWE+5IpIkRDpYQZOKdssZaCFKgzVH1DcUxztZT1mq4MTDRtM7R0ofrFBZWZk2+XIiFtHo6OisTea0u+Ysi0i7YzQW+rNgoIUoDZEoVPqEBc2eyT219L4CT703eVlCiJw+hNEUi2jqn5gyJV9apWryEaJwOOxYi226ku3mYb8udovI6/Vm7Syq0cxGtBA58K0HeonGFB6PsGzBJCeXB/cxTkwyWERJJX7AKIAan9qbeGVlZdq6aFapmtluEeX6cJIqRPZCnRqNds0ZaCFy4D8e7Sc0EsfrFm54zyRL6wwfhqr5ycsyuuZSouZiw+Ce2oS3YDCYtsWDy+UiHo/nLEQulythEc2mORKl1LioOa/XS0VFBbt37y718DRlgnbNGWghcmB+s4dDHVG8Xpl8odNUCwcyC1FqsEK4FyrqJjeGPKmtreWiiy7KuI1SKqe6XiJCNBpldHSUr3zlK4UaYlkTCATo7u4GxltEV111FTfeeCOHDx8u8Sg1mvJBC1EKhzujzGv2cODtCJ6CBK/J+JYP2YIV7EJUswLqTirEQPJizZo1GdfnahFZQhQOh9NW9Z5uZHuKPfnkk9m7dy9giJLP50sIUVNTE2+99ZYWIg2gXXMWpa8lU2YMjcRpCLrZuW8Ur6dAH5LUD1tsNK27TYgmR82t/nhhxlBg8hWi0dHRGVX0M9N7r6io4PDhw9TU1HD99dcjIvT29ibabmzcuFH3JtIA2jVnoS0iB5rq3PQOxHAX5Oo4fNAyuuYcXHllhjX/kasQRSKRGRc5lwkRYc+ePQSDwcQ1siwigDvuuCPRTkOj0WghcqS+xk1ttbuAZrND1JzbZwiOSi1/U/oSP7kwEYtopghRLk+xTU1NbN68OfHaLkTBYJDt27cXbXya6UE8Hp92/ZOKhb4KDlT6hGXzx3cvnRBONy3LInL7IZ4c1lwOJX5yYbZbRNnee0NDQ9I2qUI0WwI3NOnp7++ntrawDS+nK1qIHPBVCO8+PXuLg9xJl0ck4+eKpoFrDvQcUTZS6/SlCpFG09PTQ13d1EbElivl7wMqAc11btYuL1SPkAwW0aqPOcwVFb4JXqGxKknnYxHFYrEZZRFlY+vWrUmv7UIUCAS47bbbdC+aWU5vb68WIpMZZRGJyGUi8m8i8oCIXGAuWygiD4rIt0Xk09mO4XbBCUt8hR7Y2N8j3RANjbnmJPVfUP6uOasEUD4WkdvtnjEWUS5zRKkFY+1CBDBnzhw6OzsLPjbN9KGnp8exwv1spGyEyBSKThHZlbL8QhF5TUTeyCYkSqmfK6U+BHwAuMZcvBL4hVLqg8CJ2cZRV+PG4y5kbH/KTWv/92BgL7jTlfiZeUIUiUTweDwzyiLKN5AlVYjOO+88fvnLXxZ6WJppRG9vr54jMikbIQLuAS60LxARN3AHcBGGiFwrIieKyFoReTjlp8W26+fM/QBeBN4vIo8DTxT9XThiu2mFDsNod+4lfsoQn883qy2iiVBVVcWWLVsSrxcvXszRo0dLOCJNqQmHw9o1a1I2QqSUeho4nrJ4E/CGUupNpVQY+CFwqVJqp1LqkpSfTjH4KvBLpdQL5jFuAj6vlNoKXDxFb8a5+2q4D17935mFSEWM0O4yxqrAnWutuUgkkqjCPVvxeDycccYZidc6o14TjUbxeMr7oXOqkHLK7BWRxcDDSqmTzNdXARcqpf7MfP2nwGlKqY+m2f8vgRuB54GXlFLfFJGTgC8A3cCgUupTDvt9GPiw+XIN8MoE30It0DeF+wEsBA5O8TlL8T71NSrevhO9PpM5Z6k+C/oaFe+ca5RSE6vQbGXJl8MPsBjYZXv9PuDfba//FPhGkcdw91TvO8lzds2S96mvUfHOOaHrM93ep75GRT/nhK9R2bjm0tAOtNleLwCOFPmcD5Vg38mcs7cE5yzF+9TXqHj7TvT6TOacpfos6GtUvHNO+BqVu2vOA+wFzgMOY7jcrlNKTdR1NuMQkR1KqQ2lHkc5o69RZvT1yY6+RtmZzDUqG4tIRH4AbAdWiUi7iNyslIoCHwUeBfYA92kRGsfdpR7ANEBfo8zo65MdfY2yM+FrVFYWkUaj0WhmH2VjEWk0Go1mdqKFaBqQruqEbb2IyL+Y1SdeFpF3TPUYS4mItInIEyKyR0ReEZFx3QT1NRK/iPxeRP5oXqMvOmzjE5Efmdfod+ac7axDRNwi8qKIPOywbtZfIxHZLyI7ReQlEdnhsD7v75oWounBPaRUnUjhImCF+fNh4P9NwZjKiSjwSaXUCcDpwK0iklrOabZfo1Fgq1JqHbAeuFBETk/Z5magRym1HPg/wFeneIzlwscx5qSd0NfIYItSan2a4IS8v2taiKYByrnqhJ1Lge8qg98CdSIyd2pGV3qUUkeVWUlDKTWAcROZn7LZbL9GSik1aL70mj+pE8SXAveaf/8EOE9mWQkIEVmAUYHl39NsMuuvUQ7k/V3TQjQzmA8csr1uZ/yNeFZgukpOAX6XsmrWXyPT5fQS0An8l1Iq7TUyI1b7gMapHWXJ+b/A3wLxNOv1NTIeYB4TkT+YVWlSyfu7poVoZuD0RDbrwiFFpBr4KfBXSqn+1NUOu8yqa6SUiiml1mMkhm8yy1/ZmdXXSEQuATqVUn/ItJnDsllzjUzOVEq9A8MFd6uInJOyPu9rpIVoZlCKChRlhYh4MUToP5RS9ztsMuuvkYVSqhd4kvHzjolrZCaT15LZJTzTOBPYJiL7MQosbxWR76dsM9uvEUqpI+bvTuBnGMWp7eT9XdNCNDN4ELjBjFY5HehTSs2aHgOmj/5bwB6l1D+n2Wy2X6NmEakz/64E3gW8mrLZgxhFgwGuAh5XsyjRUCn1GaXUAqXUYuD9GO//+pTNZvU1EpGAiNRYfwMXAKnRvHl/13QN8mmAWXXiXKBJRNqBz2NMNqOU+ibwCPAe4A0ghNH6YjZxJkZB3J3mHAjA32FUTNbXyGAucK8YPb5cGFVKHhaRLwE7lFIPYoj590TkDYyn/PeXbrjlg75GScwBfmbGZ3iA/1RK/UpE/hwm/l3TlRU0Go1GU1K0a06j0Wg0JUULkUaj0WhKihYijUaj0ZQULUQajUajKSlaiDQajUZTUrQQaTQajaakaCHSaDQaTUnRQqSZNojIzSKizArJ9uVfNZdfn7L8fHP55qkdKYjIPU69Wqbw/FeLyAcclk94XGam/B9F5MbsWxcGEblDRL41VefTlAYtRJrpxHPm71Rh2YyRwe20fBTIVMRypnI18IEiHLMe+M8CHzcTXwP+RESWT+E5NVOMFiLNdOJVjLIqCcExi52eCnwXZyHaoZQanbIRzmz+EvieUioyVSdUSu0HngE+MlXn1Ew9Wog00wazuOR2kgXnFIyy83cCa20FGV3AaZhWlIicISIPisgRERky2xz/if34InKTiIxaxUFty9eYLr7zzNdnichTIhISkWMi8m/WeTORbT/LbWa6FF82x/mMiKxxONZHReSQuc3PReQ8c4znisg9wJXAO81lSkS+kLJ/1nOkbL8c47r/xLbsSRH5Scp255rnO8m2zHpfF4vIbvP9/0JEGkRkuRht3ofMbU52OP1PMawifb+aoeh/rGa68Ryw3qwgDXAGhuttF9CLIT4AazBK9D9rvl5k/v1nwHsxbm7fEZFrbce22kdcnnLOazCayT0pImcCvwbexqi+/FcYBR6/k2nQeey3EMMd9WXgWqAFuE9krAuoiFwOfAOjyvHlwMsYxTgt/gF4AngR4/qcQXLH0azncOA8YAj4Y6b3mYGFwJeAz2G0j94M3I3RbuGHGNfEA/zQYRzPYRTbXDvBc2vKHF19WzPdeA6j8vhG4GmMG9p2pZQSkd+ar/+bMavpOQCl1A+tA5g3uqcx+qR8CPiBuU2fiPwKQ3jsAnEN8GOlVExE/gl4Til1je14h4Ffi8hJSqnUkvgWue7XgNF47HVzGxdGz5dVjLVt+DvgEaXUrebrx0SkCdN9pZTaJyLHAZfZqjmVXM6RyqkYbTbSdS7NRgNwhlJqn3nOk4G/AW5USn3XXCbAL4DVGO3eLV4BYhh9byYqhJoyRltEmunG74EoY0KzGcNdB/DblOWvK6W6AESkXkT+RUQOABHz58PAypTj/wg4z7yxIyLrzW1+JCJVGNbFfSLisX4w5jAiGDfrceS5335LIEx2m78XmMdyA+sxrCE7qa8zkfEcaWgFuvM4h9M599lev2H+ftxhWVJbabMld685Bs0MRAuRZlqhlAoBLwGbxQjjXsCYEG0HTjef8Dcz5pYDuAfDsvkaRjOvjcC3AX/KKR7EEIcrzNfXAIcxRKMecGPMR0VsP6MYVlobzuSzX2/KvmHztzXOZgxPRlfKdqmvM5HtHE74McY7UdKds9dhmdM4RtMs18wAtGtOMx15DrgOQ2z227o//g6oAd4JLAe+CiAifuBi4KNm4y7M5eMexJRSgyLyCwwBuhsjZPk+0/XXCyjgCxjNv1JJ1w55ovs50YVhETanLE99XWiO42yRpN5DAkU6fx2zrCX3bEILkWY68ixGKPGNjFlDKKUGROQV4FPmIivvyIdhkSSe6M1otW0YApHKDzFcce8FlpqvUUoNmfNQq5RSX8p1sBPdL82xYmJ0ob0UuMu2alvKpmEKa0G8huFeTGVVyusNBTwnYLQ5B6qAvYU+tqY80EKkmY5YLreLgI+nrNuOEYDQgznhbQYhPA/8TxHpB+LAp4E+IOhw/F9gJMjeBbyllPq9bd3fYgQYxDFCmQcwIsIuBj6rlEp3s5zofk58BbhfRP4Vw5V4pnkczPcGRtDBpSJyGdAOHFFK5WN5pfIsxvVrtubdTFaa4/gZcCLGAwLAJSLSkbLtRNmA8cDwXLYNNdMTPUekmXYopQ4DBzHyh7anrN5uLTfzjiyuA97CSHy9HSN8+7tpjj+CcYOfixG8YF/3DHAOhivse8BDGCJzCOjIMOYJ7ZfmWD/DuOFfBvwcY77LsgL7zd93Ao9hzIM9jxGYMRmexHCNXZiy/BGM9/QwxkPBtRjh9J/ACJ8vBBcCTymljhXoeJoyQ5K/qxqNZjoiIp8DPgs0KKWGi3SO24HlSqmLzddPAt1KqauKcT7zHG7gAPBppdT3i3UeTWnRrjmNZpphzpl8BiNpNQScDfwP4FvFEiGTrwGvicjKPF2Jk+F9wDDmPJ1mZqKFSKOZfoQxkj5vwHB/HcVwN/59MU+qlGoXkZsxXJZTJUQC3GzmEmlmKNo1p9FoNJqSooMVNBqNRlNStBBpNBqNpqRoIdJoNBpNSdFCpNFoNJqSooVIo9FoNCVFC5FGo9FoSooWIo1Go9GUFC1EGo1Goykp/x/hbU9YpSy0ogAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Specify which molecules you want to extract from the database (full list available in the readme)\n",
+    "chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])\n",
+    "\n",
+    "# At what temperature and pressure do you desire the cross sections?\n",
+    "P = 1.0e-3    # Pressure (bar)\n",
+    "T = 1000.0    # Temperature (K)        \n",
+    "\n",
+    "# Specify wavelength grid to extract cross section onto\n",
+    "wl_min = 0.4  # Minimum wavelength of grid (micron)\n",
+    "wl_max = 5.0  # Maximum wavelength of grid (micron)\n",
+    "N_wl = 1000   # Number of wavelength points\n",
+    "\n",
+    "wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   \n",
+    "\n",
+    "# Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription \n",
+    "opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg\n",
+    "#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended\n",
+    "  \n",
+    "# Extract desired cross sections from the database\n",
+    "cross_sections = demo.Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)\n",
+    "\n",
+    "# Example: seperate H2O cross section, and print to terminal\n",
+    "H2O_cross_section = cross_sections[np.where(chemical_species=='H2O')[0][0],:]    # Format: np array(N_wl) / Units: (m^2 / molecule)\n",
+    "#print (H2O_cross_section)\n",
+    "\n",
+    "# Plot cross sections\n",
+    "demo.plot_opacity(chemical_species, cross_sections, P, T, wl)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "cloud-academy",
+   "language": "python",
+   "name": "cloud-academy"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 57e0e9a0ab0939a0a1af06ae9b8c297474a283a6 Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Wed, 28 Nov 2018 13:21:35 -0500
Subject: [PATCH 05/20] Removed colours from plotting function

---
 gas_opac/opacity_demo.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 9ba3b5f..42f57a5 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -316,7 +316,7 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
     smooth_factor = 5
     
     # Specify cross sections to plot, along with colours for each
-    colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
+    #colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
     
     # Initialise plot
     ax = plt.gca()    
@@ -334,7 +334,7 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
     for q in range(len(chemical_species)):
         
         species = chemical_species[q]  # Species to plot cross section of 
-        colour = colours_plot[q]   # Colour of cross section for plot
+        #colour = colours_plot[q]   # Colour of cross section for plot
         
         #print(species)
         
@@ -346,7 +346,8 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
             sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
         
         # Plot cross section
-        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, color= colour, label = species)
+        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, #color= colour,
+                     label = species)
     
     plt.ylim([1.0e-28, 2.0e-18])
     plt.xlim([min(wl_grid), max(wl_grid)])

From 2139cc356a17c335e618432d63193a7118a483f1 Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Thu, 29 Nov 2018 11:17:56 -0500
Subject: [PATCH 06/20] don't save figure

---
 gas_opac/opacity_demo.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 42f57a5..4c3261e 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -364,7 +364,7 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
     #plt.close()
     #plt.show()
 
-    plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+    #plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
 
 
 #***** Begin main program ***** 

From 3cbf7b93344a3b6726b68427830c8a8af0f2ce0c Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Thu, 29 Nov 2018 11:49:25 -0500
Subject: [PATCH 07/20] make sigma_stored a dictionary instead of 2D array

---
 gas_opac/opacity_demo.py | 69 ++++++++++++++++++++--------------------
 1 file changed, 35 insertions(+), 34 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 4c3261e..fdbced3 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -276,7 +276,11 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
             nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])
     
     # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
-    sigma_stored = np.zeros(shape=(N_species, N_wl))
+    #sigma_stored = np.zeros(shape=(N_species, N_wl))
+    # Lia -- Making this a dictionary instead of a numpy array. It's easier to use for plotting.
+    # Later, a 2D numpy array will be faster for summing across a large number of species
+    # But for now, two dozen is not a lot.
+    sigma_stored = dict()
     
     # Evaluate temperature interpolation weighting factor
     y, w_T = T_interpolation_init(T_grid, T)  
@@ -290,11 +294,12 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
         
         # Read in log10(cross section) of specified molecule
         log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)      
-            
+        
         # Pre-interpolate cross section to desired P and wl grid 
         sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, log_sigma, nu_l, nu_out, nu_r, nu_opac, N_nu, x, b1, b2, calculation_mode)
-        
-        sigma_stored[q,:] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
+
+        #sigma_stored[q,:] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
+        sigma_stored[species_q] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
         
         del log_sigma, sigma_pre_T_inp   # Clear raw cross section to free up memory
         
@@ -307,7 +312,7 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     
     return sigma_stored
 
-def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
+def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, **kwargs):
     
     # Max number of species this can plot is 9 (clustered beyond that!)
     
@@ -319,53 +324,50 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
     #colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
     
     # Initialise plot
-    ax = plt.gca()    
+    #ax = plt.gca()
     #ax.set_xscale("log")
     
-    xmajorLocator   = MultipleLocator(1.0)
-    xmajorFormatter = FormatStrFormatter('%.1f')
-    xminorLocator   = MultipleLocator(0.2)
+    ax = plt.subplot(111)
+    #xmajorLocator   = MultipleLocator(1.0)
+    #xmajorFormatter = FormatStrFormatter('%.1f')
+    #xminorLocator   = MultipleLocator(0.2)
     
-    ax.xaxis.set_major_locator(xmajorLocator)
-    ax.xaxis.set_major_formatter(xmajorFormatter)
-    ax.xaxis.set_minor_locator(xminorLocator)
+    #ax.xaxis.set_major_locator(xmajorLocator)
+    #ax.xaxis.set_major_formatter(xmajorFormatter)
+    #ax.xaxis.set_minor_locator(xminorLocator)
     
     # Plot each cross section
-    for q in range(len(chemical_species)):
-        
-        species = chemical_species[q]  # Species to plot cross section of 
-        #colour = colours_plot[q]   # Colour of cross section for plot
-        
-        #print(species)
-        
-        species_idx = np.where(chemical_species == species)[0][0]
-
-        sigma_plt = sigma_stored[species_idx,:]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)
+    for species in chemical_species:
+        #species_idx = np.where(chemical_species == species)[0][0]
+        sigma_plt = sigma_stored[species]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)
         
         if (smooth == True):
             sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
-        
+            
         # Plot cross section
-        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, #color= colour,
-                     label = species)
+        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, label = species, **kwargs)
     
     plt.ylim([1.0e-28, 2.0e-18])
     plt.xlim([min(wl_grid), max(wl_grid)])
     plt.ylabel(r'$\mathrm{Cross \, \, Section \, \, (cm^{2})}$', fontsize = 15)
     plt.xlabel(r'$\mathrm{Wavelength} \; \mathrm{(\mu m)}$', fontsize = 15)
     
-    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\mathrm{T = }$' + str(T) + r'$\mathrm{K \, \, P = }$' + str(P*1000) + r'$\mathrm{mbar}$'), fontsize = 14)
+    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\mathrm{T = }$' + str(T) + \
+                                         r'$\mathrm{K \, \, P = }$' + \
+                                         str(P*1000) + r'$\mathrm{mbar}$'), fontsize = 14)
     
-    legend = plt.legend(loc='upper right', shadow=False, frameon=False, prop={'size':6}, ncol=2)
-    
-    for legline in legend.legendHandles:
-        legline.set_linewidth(1.0)
+    legend = plt.legend(loc='upper right', frameon=False, prop={'size':6}, ncol=2)
     
+    '''for legline in legend.legendHandles:
+    legline.set_linewidth(1.0)'''
+
     #plt.close()
-    #plt.show()
+    plt.show()
 
-    #plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+    if savefig:
+        plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
 
+    return
 
 #***** Begin main program ***** 
 
@@ -398,6 +400,5 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid):
     #print (H2O_cross_section)
     
     # Plot cross sections
-    plot_opacity(chemical_species, cross_sections, P, T, wl)
-    
+    plot_opacity(chemical_species, cross_sections, P, T, wl, savefig=True)
 

From 73c46b52d6b1ceb4e5c219ec7bacb9b457500162 Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Thu, 29 Nov 2018 11:51:50 -0500
Subject: [PATCH 08/20] move plot style choices to kwargs

---
 gas_opac/opacity_demo.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index fdbced3..bda6088 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -345,7 +345,7 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, *
             sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
             
         # Plot cross section
-        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, label = species, **kwargs)
+        plt.semilogy(wl_grid, sigma_plt, label=species, **kwargs)
     
     plt.ylim([1.0e-28, 2.0e-18])
     plt.xlim([min(wl_grid), max(wl_grid)])
@@ -400,5 +400,5 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, *
     #print (H2O_cross_section)
     
     # Plot cross sections
-    plot_opacity(chemical_species, cross_sections, P, T, wl, savefig=True)
+    plot_opacity(chemical_species, cross_sections, P, T, wl, savefig=True, alpha=0.8, lw=0.5)
 

From af517a9ba8ae5b7ba16caaa006ab7300e58f723b Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Thu, 29 Nov 2018 11:58:31 -0500
Subject: [PATCH 09/20] Checked that script runs from start to finish

---
 gas_opac/opacity_demo.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index bda6088..47dacb3 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -197,7 +197,8 @@ def T_interpolate(N_T, N_wl, sigma_pre_inp, T_grid, T, y, w_T):
             
     return sigma_inp
 
-
+# Notes from Lia:
+# Not sure what the slowest portion of the script is. I'll start with print statements
 def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     
     '''Convienient function to read in all opacities and pre-interpolate
@@ -238,6 +239,8 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
             
     # Find logarithm of desired pressure
     log_P = np.log10(P)
+
+    print("interpolating...")
     
     # If pressure below minimum, do not interpolate
     if (log_P < log_P_grid[0]):
@@ -361,12 +364,13 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, *
     '''for legline in legend.legendHandles:
     legline.set_linewidth(1.0)'''
 
-    #plt.close()
     plt.show()
 
     if savefig:
         plt.savefig('./cross_sections_' + str(T) + 'K_' + str(P*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
 
+    plt.close()
+    
     return
 
 #***** Begin main program ***** 
@@ -396,7 +400,7 @@ def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, *
     cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)
     
     # Example: seperate H2O cross section, and print to terminal
-    H2O_cross_section = cross_sections[np.where(chemical_species=='H2O')[0][0],:]    # Format: np array(N_wl) / Units: (m^2 / molecule)
+    H2O_cross_section = cross_sections['H2O']    # Format: np array(N_wl) / Units: (m^2 / molecule)
     #print (H2O_cross_section)
     
     # Plot cross sections

From 91ae09180fd01fb098f74bcf3f3f1d7b8c3ec247 Mon Sep 17 00:00:00 2001
From: eblur <lia@astro.wisc.edu>
Date: Thu, 29 Nov 2018 12:00:14 -0500
Subject: [PATCH 10/20] latest check of opacity_demo

---
 notebooks/test_gas_opac.ipynb | 489 ++++++++++++++++++++++++++++++++--
 1 file changed, 468 insertions(+), 21 deletions(-)

diff --git a/notebooks/test_gas_opac.ipynb b/notebooks/test_gas_opac.ipynb
index a81f9ea..d827d66 100644
--- a/notebooks/test_gas_opac.ipynb
+++ b/notebooks/test_gas_opac.ipynb
@@ -53,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -62,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -77,18 +77,6 @@
       "CO done\n",
       "CO2 done\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAETCAYAAAB0nQK/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzsnWd4VNXWgN89NZNMei+QEDqhExAVRWnCpYhiw95RsWD77IVrxXLFAlewgHoV7AgoCigISO+hJKEFCOm9Tabu78eEQEibTCYk6Hmf5zww++yy9snMWbusvZaQUqKgoKCgoNBaqFpbAAUFBQWFfzaKIlJQUFBQaFUURaSgoKCg0KooikhBQUFBoVVRFJGCgoKCQquiKCIFBQUFhVZFUUQKCgoKCq2KoogUFBQUFFoVRREpKCgoKLQqmtYWoK0REhIi4+LiWlsMBQUFhXOKbdu25UkpQ90pqyiiM4iLi2Pr1q2tLYbC35hLLrmEnj178sEHH7S2KAoKHkMIcdTdssrSXAMIIRq8br31Vo+0s2bNGiZMmEB0dDRCCObPn19nvtmzZ9OhQwe8vLwYMGAAa9eubbE8TS1z6623Mm7cuBppS5cuxdvbm2eeeabeem+99dbq56nVaomPj+exxx6jvLy8UZmagqvP+EzceVYKCgpN42+liIQQ8UKIT4QQ352W1l4IsVgI8akQ4smm1JeZmVl9ffTRR7XS3n33XY/IXVZWRs+ePXn33XcxGAx15vn666956KGHePrpp9mxYwcXXHABY8aM4dixYx7P407bZ/LFF18wadIkXnvtNV555ZUG+z9ixAgyMzM5fPgwL7/8MrNnz+axxx5rsExTceUZn4k7/W5NLBZLa4ugoOAeUso2cQGfAjnAnjPSRwMpwEHgSRfr+u60/48AplT9//PGyg4YMEDWxbfffiudj6tl8fHxkfPmzauVPmjQIHnnnXfWSOvUqZN88sknPZ7HnbZvueUWOXbsWCmllDNnzpQ6nU5+/vnn9dZZV7mT3HnnnTIiIqLRsu5S3zM+E1f6PXToUHnPPffIRx55RAYGBsqQkBA5c+ZMWVlZKe+77z7p7+8v27VrV+NZDB06VE6ZMkU++OCDMiAgQAYEBMjHHntM2u326jzLli2TQ4YMkQEBATIwMFCOGjVK7tu3r4YsJ9t+9NFHZUhIiExMTHTziSgoNB9gq3Tz/d+WZkTzcSqdaoQQamAWMAboAUwWQvQQQvQSQiw94wqrp94dwHVCiD+AVS0oP6+++ipGo7HBy52lHYvFwrZt2xg1alSN9FGjRrF+/XqP5nGn7dN57rnneOqpp/jhhx+46aabmtbRKgwGA1artVZ6Sz3fumhKv7/88kt8fX3ZtGkTTz75JNOmTWPixIl06dKFrVu3csstt3DnnXeSkZFRo4zD4WDDhg3MmTOHuXPnMnPmzOr75eXlTJs2jc2bN7N69Wr8/f0ZP358rVnP//73P6SUrF27ls8//9wjfVdQONu0GWMFKeUaIUTcGcmDgINSysMAQoiFwOVSyteAcbjGbcALVfV/B8zzkMi1uOeee7jmmmsazBMdHd3kevPy8rDb7YSHh9dIDw8PZ+XKlR7N407bJ1mxYgU///wzS5cuZezYsU3uJ8DmzZv56quvGD58eK17LfV866Ip/U5ISODFF18E4JFHHuH1119Hq9Xy0EMPAfD8888zY8YM1q9fz1VXXQVAZGQk7733HkIIunXrRmpqKv/5z3945JFHAJg0aVKNNubNm4efnx+bN29myJAh1ekdOnTg7bff9kifFTzL/Pnz6du3L3379mXatGmEh4djMpkIDQ3lgQceYMaMGWi1WvLz87n++utJSEhoE3L27duX3NxcpJSMHj2aJ554gttvv52rr76aadOm1RgweYo2o4jqIRo4ftrndOC8+jILIYKBV4B+QoinqhTWr8CLQojrgbR6yt0N3A3Qvn17t4UNCgoiKCjI7fKNIYSo8VlKWSvNU3ncabtnz54UFxczffp0LrzwQgICAhqs8yS//vorRqMRm82G1Wrl8ssv5/3336+Vr6Wfb1240u/evXvXyB8WFkavXr2q07RaLYGBgeTk5FSnDR48uEY9559/Ps899xwlJSX4+flx6NAhnnvuOTZt2kRubi4OhwOHw1Frf2rAgAEe6adCy/Dll1+yevVq9u3bx8yZMykqKmL69OkkJyfj6+vLfffdh91u57HHHuOdd95pdTn37t2Lj49PjX3drl27smbNGrcHl67Q1hVRXW/HekPKSinzgXvOSNsDXNVQI1LKucBcgMTERLdD1r766qu8+uqrDeZZtmwZF110UZPqDQkJQa1Wk5WVVSM9JyenesTuqTzutH2SyMhIFi9ezLBhwxgxYgQrVqwgMDCw0f5dfPHFzJ07F61WS1RUFFqtts58LfV866Ip/T5T3pMWgGemORwOl9sfP3480dHRzJkzh+joaDQaDT169Ki1NOfj4+NynQquM+y+phuk/DG79iD2hhtuoG/fvqSlpVFQUMC///1vnn/+ebKzsz0hJnzV8ACyTq6v/Yo7KeeePXvqHJQ+/PDDHjPOqou2rojSgXanfY4BMurJ2+q01NKRTqdjwIABrFixgquvvro6fcWKFdVLOJ7K407bZ/Zv9erVDBs2jOHDh7NixQqCg4Mb7J+3tzedOnVq9DmczaU5d55VU9i0aVON2dXGjRuJiorCz8+P/Px89u/fz6xZs7j00ksB2L59OzabrdntKrhGXUqluYwePZrLL7+cFStWcO2117Jo0SLefvttCgoKuPPOO92rtA6l0hyMRiPx8fG89dZbOBwORo92btvHx8efNP5qGdy1cmiJC4jjNKs5nIryMNAB0AG7gISWlKE1rOZKS0vljh075I4dO6TBYJDTp0+XO3bskEePHq3Os3DhQqnVauVHH30k9+3bJx988EHp4+Mj09LSPJ7n/fffl127dm1SmTOt37KysmRCQoLs3bu3zM3NrbfvdVnNtQSNPeMz+yyla/0eOnSonDp1ao1yCQkJ8oUXXqiRFh4eLt9///3qMkajUT744IMyOTlZfvvtt9Lf31+++eabUkop7Xa7DAkJkZMnT5YHDhyQq1evlgMHDpQajaaGtV9dbSsotBY0w2qu1ZVPtSCwAMgErDhnQndUpf8LSAUOAc+0tBytoYhWrVolcS451rhuueWWGvlmzZolY2NjpU6nk/3795d//vlnrbo8keeFF16o1dfGytSlUHJycmTv3r1lz549ZXZ2dp19P1uKqLFnXFefpWy83+4qoilTpsipU6dKf39/GRAQIB955BFps9mq8//+++8yISFB6vV6mZCQIH/99ddaZueKIlJoSzRHEQlneYWTJCYmSsXFj4KCgkLTEEJsk1ImulO2LZ0jUlBQUFD4B9LWjRUUFBQUzkkyMzOZNWsWwcHB6HQ6oqOjmThxIi+++CLTpk3D39+fxx9/nJiYGKZNm9Zm5Dx27BiRkZFkZmby/PPPnxXLTEURKSgoKLQAs2bN4sknn8RoNLJ69Wq++OIL0tLS2LhxY/X9q666qvpzW5Dzww8/5JZbbqFHjx7s27ePL774gnvuuafxSpqJoogUFBQUzmC6mN7kMi/IF2p8lrLm4efx48czceJEioqKcDgcHDhwgJycHJKSkrj33nvR6/VNbrOxg+h1caZdwOlytpbNgKKIFBQUFM7gTKXiDlOnTuW1116rsTR3EpVKxbvvvktaWhqLFi1ySwmBZxTH6XKqVCrmzZtHdHR09dLc2UCxmjsDxWpOQUFBoekoVnMKCgoKCucsiiJSUFBQUGhVFEWkoKCgoNCqKIpIQUFBQaFVUazmFBQUFFqA+fPns2TJEr7//vvqA6szZ86stpQbOXIkv/32GwcOHOCll14iJCSkVeRs7EDrqlWr2LNnD6mpqcyZM6feMC3NQVFECgoKCmdwKLTpMa065tYOU9+zZ0+WLl3qrPPQIWbOnElBQQFBQUEkJCSwc+dO1q5d6/bLffp0N847vVDTNN2VA63jxo3j/vvvx2KxKIpIQUFB4WxQl1JxhyuuuIKPPvoIKSUdO3Zk2rRp1TMicAakKy4uZseOHfj5+dG/f/8m1X+mUnEHVw60vvvuu0yYMKHF3P0oikhBQUGhBXnggQe47LLLuOKKK2qkL1u2jI0bN7JlyxYCAgI4fvw4/fr1c8tbQnNo7EDrW2+9xbZt25BSMnDgQJeiLjcV5UDrGSgHWhUUFM4GFouFt99+G19fXwoKCvDz8+O2224jPT2dhISE1havySgHWhUUFNokUkpslUqI87qoqKjA4XAQHx+Pv78/fn5+fP3116SkpLS2aGcdRREpKCi0GKlLUvnptp9aW4w2SUVFBZdccgljxoxhyJAh3HbbbUycOJGDBw8ye/ZsioqKWs0J6dlGUUQKCgotRtHRIvQB7jn0/DtTWVlJSkoKsbGxCCEYMGAAQgjCwsJ46KGHiI6OZtu2bfz00084HI7WFrfFURSRgoJCi2Eps6D3UxTRmSxatIjk5GSCg4Nr3dPr9UyYMIHy8nKKi4vJyclpBQnPLooiUlBQaDFslTZ8I30xFZhaW5Q2RUREBLfddhsGg6HO+0IILrjgAiZPnszSpUv/9kt0iiJSUFBoUYI6B5F/IL+1xWhzeHl5NXg/JCQEnU5Hnz59KCgoOEtStQ6KIlJQUGgxhBAEdQqi4ODf+0XaFNatW0dFRYXL+ePi4vj9998pLS1tQalaF0URKSgotBhSSgI7BFJ0pKi1RWkzlJaWEhoa6nL+0NBQxo0bx65du1pQqtZFUUQKCgothwS1To3dYm9tSdoEUkq8vLwYOHBgk8p5e3tjs9lIT09vIclaF7dd/AghegGDgAjACygAUoH1UspCz4inoKCg8PehvLwco9HoVtmhQ4eycuVKYmJiPCxV69MkRSSEiAfuBW4AwgEHUASYgQDAG3AIIf4EPga+llL+/Y3gFRQUamGtsKL19ryn5nOZk5633UEIgb+/Pxs2bOD888/3sGSti8tLc0KIj4G9QF/g30A/wEtKGSqljJFSGoEwYDyQBLwB7BdCDPG82AoKCm0dS7kFna8OAK9AL8WEm+YpIoDExMQmGTqcKzRlj6gS6CalHCml/FBKuVtKWWPhV0qZJ6VcJqWcBsQCzwPRHpRXQUHhHMFWaUPj5Vx0Ce4cTMEhxXKuqKgIf39/t8urVCrCw8NJSkryoFStj8uKSEp5v5TyaBPyO6SUX0spv3ZPNAUFhXOZ0xVRUKcgCg78sxWRxWIhPT0dlap5NmI9e/YkPT2dI0eOeEiy1kexmlNQUGgRTldEAR0CKDzyz7Zh2r17N8OGDfNIXcOHD+fEiRMeqast4JIiEkJcIYR4UAjR9Yz0+1tGLAUFhXOd0xWRRq/5x5twl5aWEhUV5ZG6dDodVqvVI3W1BRpVREKI14GHgE7ACiHEtNNu395SgikoKLRdUhan8Mdzf5CdlF1vHrvZXq2IFPB45FW73Y7N9veI9eTKjGgsMEJK+SBOS7kJQog3q+6d3Zi2jSCEmCiE+EgI8ZMQYlRVmo8Q4rOq9BtaW0YFhXMdq8nKjk928NeMv/hq7Ffk7sut0ynn6TOifzoOh8Pjiqh///5s2LDBo3W2Fq4oIpWU0gYgpcwHRgNxQohPXCzvEkKIT4UQOUKIPWekjxZCpAghDgohnmyoDinlIinlXcCtwLVVyVcC31WlT/CUvAoK/1QytmSQsjgFh9VByfESvhj5Bb89/Bs2c83ReV2KqE6FZf57jOobwmQy1etp212CgoKw2Wx/iyU6VxRJphCi/8kPUkoLzpe8BHp6UJb5OJVcNUIINTALGAP0ACYLIXoIIXoJIZaecYWdVvTZqnIAMcDxqv//sxepFRSaid1iZ8N/NhA/Ip7I/pHo/fSUZpSy+YPNtRybnqmIDIEG8pLzauSpLK5k+aPLz4rsrUl5eTk+Pj4er7dz584cOnTI4/WebVxRRLcCGacnVJlm3wlc5ClBpJRrcLoJOp1BwEEp5eEqBbgQuFxKmSSlHHfGlSOczACWSSm3V9WRjlMZgWIlqKDgNmXZZczpN4dLX7qUG5bdwJVfXsm4OeMYcM8ApF3Wcmx6piLqfWNvds7fWSPP0ruXkr07m3Uz1lGUVoTVdO6P7uuipRRRREQEa9euPefjFTW6gCulbMjLXr4QYhhOX3NnlvulOYJVEc2p2Qw4lcp5DeR/ABgB+AshOkkpPwR+AD4QQowFltRVSAhxN3A3QPv27T0gtoLC348dn+5g9LujCe8VDkBItxBCuoUQ2iOUnN05LBi/gBfkC9X5K4sr0fueis7qHeKNxkvDkVVHCO4cTNJXSez9Zi/xI+PZ8NYG9n2zj/A+4eQl53Htj9ciHZKyrDJ8I30xRrjnn62tUF5eTnh4uMfr1Wg0dO/enaKiIgIDAz1e/9nCrZ3EKoenC4Du1G2wIAF1M+SqbqqeuutESvke8N4ZaeXAbQ01IqWcC8wFSExMPLeHFgoKTcRhMqMyNBzOO3N7Jn/N+ItHMx6tdS+8dzjjPx5P3v48khcl021iNwAqcivwDvGukXfjOxspPFTIgCkDKM8t55ofrsFmspEakkpZVhkpi1Mw5ZtYOmUpUYlR5O7NpdeNvegytovnOtwKtNSMCKBHjx4cOXLkn6eIgE8BKzAOOAhYPCZRTdKBdqd9juGMZUIFBYXmUfjGJwQ8dBPqAN9683x9xdck3ptYrxPT0O6hhHYPZcmUJXQZ3wWVWoWUEqGqOZa8Y8MdfHL+J2TtzCL24li6X9EdAL8YP3yjfbFV2lh0yyLSN6RTcrwEU6GJ8L7hxF4cW2N2da7REsYKJwkMDOTjjz+mT58+qNWeGP+ffdxVRN2BSVLK3zwpTB1sAToLIToAJ4DrgOtbuE0FhX8U9txCrAePoU5MqDdP+yHtCesZVu/9k7Q7vx0HfjlA1/FdkY7aiwthCWGEdAshY0sGKs2pLdvYi2NrtJWTlEPmjkwqCyvZ/pFzu7fvrX0xhp97S3RSSsrLyz1uvn0SIQRjx44lPz+fsLDG/0ZtEXc37zcDHt1MEUIsADYAXYUQ6UKIO6rMxu8HfgP2A99IKfd6sl0FhX860mLFmla/u5jCI4UEdgqk9w29G62r9029SVmcgrXCWms2dJKrFl7FkKeHcOfGO+u8P+rtUQx5agjtL2yPXzs/tN5atv53Kyc2nZsubdLS0jh48GCLthETE8PRoy67Am1zuDsjuhtYIISoAFbhjElUAyllk3yVSykn15P+C+AJwwcFBYU6UAX6Yy8oqff+wgkLaX+Ra+NOlVpF9q5svr3mW4a+MLTOPIHxgQx/ZXiDdcSPiMcrwIvI/pGkLE5h25xtFB4uxG61o9aeW8tPhw8f5oEHHmjRNvz9/SkuLm7RNloSdxVRHpAGfN5AnnPr26Kg8A9FHeiLo6S0znvFx4px2B2MeX+My/VNnD+RkG4h9c6IXCUq0emXrdvEbsReHMvM2Jn4x/pX7yudK6jV6mZ73HaFk8qoOWEmWgt3FdH/gPOBt2hZYwUFBYWWRqUCe92BlNNWp9FtYjdUatdfpKE9Qj0lWTWGIAO3rLqF5Y8tp8vYLqh1yjj3TLp3705SUtI5Gb3VXUV0KXCXlPIrTwqjoKBQP2VlZXh7e3t0dC0dDhCiTkVkq7RxYssJxrzn+myoJYlKjGLcnHH88sAvjJ09tknK8Z+A0WikvLy8tcVwC3f/kmnA3y9erYJCGyU5OZn58+ezffv2xjM3AVluQmU0IB2OWqfzc/fn0mFYhxaz9nKHkK4h9L2lL8k/Jp/z3gRaAl9fX0pL615mbcu4q4geB54RQsR5ThQFBYX6yMvL47rrriM/P5+ysjKP1WsvLkPl54smOgx7dn6Ne7s+24VftJ/H2vIU7S5ox67PdrHvu32tLUqbo2vXrqSkpLS2GE3GXUU0Haf5dqoQIlUIsfnMy4MyKii0WYqPFWMuNVd/tltbxq9uWVkZISEhDBo0iJ9//hmLxTPbso7iUlT+RrTxMVgPHa9xb9O7m/CNrv+Qa2ty7aJr+W1abY/f/3QCAgLOSes5dxXRHpwm1V8CfwF767gUFP72rH9rPb8//TvSIclOymbNy2s83kZycjLBwcGA8xT9wIED2bZtm0fqdhSdVETtsB45dU7HXGIm4ZqENuvjTaVWMWnBJH5/6vfWFqXNYTAYzrm9IreMFaSUDfpuU1D4JyClRO+vJ6xnGNlJ2aQuSaUi1/Nbp+vWrWPSpEnVn+Pj40lLS3O7PtP6nXgN7o1QqXCUlKGJDkcTFUruwzMwXjUSlZeeHZ/uYOgLQ9u0QUDsxbFkJ2WTsyfHJa8PrUFr7GN169aN1NRU+vXrd9bbdpe2+y1TUGijbJvrPFx54OcDRA2IIvbiWA6vOIzD5sAQbPD4y6djx451OrR0OOo2uW6Mki9/xnrY6VTfXlyGyt+IUKnQD+yJNSUNgIqcfAK8zEh72w7h1XlMZ9a+upbiY21vOcput7Nx48az7v8tMDCQ9PT0c8qYwy1FJIToI4T4Vz33/iWEaNwXiILCOUhech6lGaUkfZVExrYMuozvgm+kL6YCE1JKAmIDKD7quZei3W6v80VmNBr5+uuva7xsij/5AYCcnJzqtNIfV1LxxybKf12HeZ8zgJrQaSh4eQ6l36/AUVyGyt+5DxT06JXk3HwdeWv20tv+EjnTnsO8OxVZUDOGUFsiMD6Q8XPH89cbf5G1K6u1xamB1Wpl+fLlLeZ1uz6EELRv3578/PzGM7cR3J0RvUP9cYEGVt1XUPjbsXP+TgZPG4zdYnfGy/l6GQDBXYNBQtTAKE5s8ZxPtMrKSry8aoX7IioqitTUVIqLi8l/9SOs6dnkv/Qh+R9/xw+ffkbukj8o/O9CCt+YR+Hbn5H/7w/JffA1jl9yG+rQILyHD6bi941Y9hxA5esM1aANdeA7JgLV4hvx6uIL5ixy73sY08c3eaw/blO4u95bOqOOwI6B/DK1bXkCOzlj9fM7+5aHsbGx55TvOXcVUX+cRgp1sQE4dxYnFRRcID81n2UPLaNjQCEaS4UzUpbdTsFrH+MoN9Hpsk5ED4omrGcYJza3vCKKiYlh0qRJ5Bw/gWn1FtJH3IGuVxd+Td1DidnEN2t+Z+fmrei6x1cdWLWj7RKL8aqRqIP88btpPEFP3YX/XVchqmZc2uggAm69DNERvDsYiHz9fCJf6YfGOwfpcGDLzsf01w6P9a1JpP2vwduxF8Xi5e/F7v/Vr7DONvaqZU1f37NveRgQEEBRUS0XoG0Wdz0rqIH65ps+gM7NehUUmo0tI4eC1z9B36sz/ndd5XY9uftyq93VbPtoG6PeHkXB0zMpfGsefkcdWC0S/zuupOyHlfhOHkOXcc7gbf7t/cnalUVwl2C0hrrj97iK2WyuUxGBc+9o68pVhBcVEfLDO2zfupWeeh+uvmI0OcfS2b59O5X7swgadh6+N4zFlpaBys8HR6nToELbLgLaRZyq0F4JtjK8DJmoCIH8VaiCE5EhJoqeug17YRGVaeFEff8OKt+zu9yEteFDmlGJUQx5agirnltFzOAY/Nr5odG7+3rzDA6HAx8fH0JDPe/yyBW0Wi1msxm9vu3HcXJ3RrSFqtDadXA3sNXNehUU3Ma0YRe5//cfimYtxPfa0djznCNCc9IBKncmN6kuKSWzE2Zjt9gpOFhAYHwg5d8tx2f0EEJefQi/IDXq40fxv+NKzDuTKXr3y+qyg6YO4uCvB5l30Tx+e7R5IbvqmxEB2H9dT96Kv9hy63CW7dhMrhYSJv0LnU5HTKd4pF5L1mWJ+N04DiEE2g7RqIMD0MZF1d2Yw4w0F6DTFIPGCBXHoTIHvMNR2zehC8nCejSD3MffxnYim4o/t2IvPkun+G2Nt9N+SHtGzBjB99d/z3fXfncWhGoYu93OyJEjz4rD07ro3r07yclN+963Fu4OGV4EVgohNgGfAVlAJHAz0AcY6RHpFBRcxJx0gIrlfxH6xiPVaaYNO8m87nHUUaE4Ckrwu3k83sPq29qsSUVuBe0vak9eSh57v97LoHFh2JPN1eUjbhqBl58XKl8fgqdPJefB18h/ZS7a9pH4XjuaIU8ModfkXuz9Zi/5qfkEdwl2q19lZWVERdVWHNJswZx0gInv/BsHTg/PUsoa7njGjx/P6tWrXW/MbsZWeBSLbI+PTywU7oTY6xFhF2MonYu686VYS3ZT+ucOch9/G8uBY/jfPhF1cAC+14x2q3+uy2YChw1UDb+yogdFc+emO1nz8hqyd2cT3ju8ZeVqAIfD0WpKCCA0NJRdu3a1WvtNwa2nJKVcA4wCHMD7wHfAu4ANGCmlXOsxCRUUXKBs8SqCnp1SIy3osdsImfEwIa88RNgHT2PekYztRLZL9RUfL6brhK6kLE7BEGzA8tdW/CafMhQ1nt+L6Oedx+lURm9C334cW0YOec+9T9ZtzwLOJbpBDwxi3evrsJS55wmhuLiYgICAGmnS4aB85UZ8/nURQq2utqo70yfcyZegS2a81hKwV2LNTUMEJIBXBEw4BFGXQegQtAFlqOyZBI3JJvipKwh6dgq6Tu0onPk/zHsP4aiodKt/LuOwOZWRCwgh6DiyI2tfXUvan2nk7M0hP/XsW5DVZ/F4NtHr9Vit1laVwRXcVtdSytVSyvMBX6Ad4CelvFBRQgpnG1llnSTq+NFrY6NQGfSojN743TaR0u9WuFSn6dd1RPcKJO277XTpZ6TsuxUI/amtTyEEKh9D9Wd1oB+hbzxKxKcvYc8rpGSB04JLo9fQ/67+7PzMPRNom82GRlNzFlDyxRLynnwH/YAejZbv2LEjO3e60PZ3weAwo7YcxavLcDBEgah6PRg7gjYADFGIfq/iO6gSfQdvwj99GcOF/Shd8AtH4kfjKG3B0/zSdUUEEDM4homfTeSnW3/i0ws+5afbf2o52eqhtWdE4JwVHT58uFVlcIVmPyUpZYWU8kRTI7Iq/D2x5xVStnjVWW2zYuUGvIcmNppPHeSPo6QMaa3fP5mUksqte7F//xOOF19leNxhKt+ZS+BjtzZav8rHgPew8wh6+m530O07AAAgAElEQVQq/9qB5dAxAKIHRpO2Ks0tP3R1eb52FJcR9eO7LnnFjo2NpaCgoOFMJQecL/q8DVRYolG1uxw6nGayrdJA9HjoNR0iR8G+GbDlXlQGPWHvPUX0z7PxvmQgZYtXY8vKa5lDsE2YEZ1Eo9dwy6pbeOjIQ7S7sB17vt5zVg95toUZUXx8PMnJydUWfG0VlxWREOImIUSTnqoQopMQ4qKmi6VwrmLelUrZoj/O6on8yq378LrQtRMDPqOHUL58fb33zdv3kf/yHIon3ULYT7MxDOpNyOsP4zvJ9W1P76GJhM58gsIZn5J1x/OYN+7kkmcvYMsT37tcR304TGbsOfnoOrkWuhuch18bDA2w7UGncULqB6QV3F41GzpDySU8CWqdMz32OvDvBYc/R2X0Rtc5lpA3HqHg9Y8pnPkFOQ++7mbvGkDaoCLDuYTYBALiAjAEGRg5YyTZu7NZfPvis6aM2sKMSKfT0bFjxzZ/uLUpT+lR4JAQ4iUhRJ/6MgkhgoUQNwghlgA7cBoxKPyNseUUkPfsewCYk1Lxu2Echf9pKIq8ZxEq4XLMHH1iApXrd9b7MrLsPUT4rGcot+rwDjES9NSd6LvHN10mjYbwuS9ivPxSsu9+Efsb7+GzdgWHP2ueU9TyX9eijYtuUpl6fdNJCVsfgJIUp3IBRGDvU0ty9dHnFbDkw/Zp1Una9pHE7voeoVZj3tYCPo+lDbJWQoH78ZiGvTyMwsOFbHpvEzazDUt51b5d0R4PCVmTtjAjAoiOjub48eONZ2xFXFZEUsq+wBM4o7PuEEKUCCE2CSF+FkL8IIT4QwhxBMjBabhwCOgmpfymRSRXaDPYjmViWr8Ty6Fj2ItK8B5+HkKjxnKg5U9223ILUQcHNJ6xCiEEXoN7Y95Vd8wW24kc1FFhSIdEqJofEM444VLCZj+HcdJI4uc9TfnbH2PLaWSprAHsuUUYrxjepDIhISFkZmbWvlG0CwL7gX930Dl92fW8foBrlepDIGxojSShUuE96gIMF/WnYvWWJsnYKA4bWAqbvDx3OkIIxn80ntTFqczqNou1r1RtZx+YDYc+BYdnN/XbiiIKDAxsfHm2lWnSvFFK+bWUcgjQGWdwvJ04LeV8gGycptyjgUgp5TQppeeOmCu0WWwncgh8+GbyX/wv2hjnAUnjVaMo/aZ5Z2hcoXLTbvQDezapjPeI86lYsaHOeydNoD25fON9yUB8J43Ep2cHUiIvJnP2IrfqcVRUkv/Mu6iC/JtUTgiBl5cXJtMZL/GKE+DfE3q9CJ2mcCTvZjTeLh5U7fEE6IPh0Lwayd5DE0Gtpui/X1PxpwePE6r1YCkAW/O2ooO7BHPhExdy4283UllcSfKiZEoP7oWi3c2u+0zawtLcSWJiYjh69CiHDx9uk85Q3TXfPiSlnCOlnCKlvFxKeZmUcrKU8kUp5QopZdu3F1TwGLbMHAwXDyDyi9fwv9MZrkDbLgJ1cAC2jJxGSjcP8+5U9H26NqmMyqBHVppr/SDtBcWoA32xW+2otS0zkp3w/c3krdmPeXdqrXvSbq93JiHNFio37MJ71AVuhe6Oi4sjPT29ZqIpEwwREDwQaYwnLf9WULnYb40PmPPhxOJat0JefoCor9+i8K35npsVq7ycMyJLIax131sGQMdRHQnuEszYWWPJ2JqBoziN8vQTUH4Uu8VzgfbayowInJFbDx8+zO7du6msbGFTezdoG+pa4ZzGUVyGyq92ADXfa0dT+vWvLdp2U/aHTkfbIQbb8ZremitWbcZwcSL5KflOJ6YtgM6owzbpanI+WlLrni09m8KZX9RZruR/Syl853MiPn/VrXajoqJqL89VZoGX88Bn7t5cAuNrh5pokIt+cCqkvTVlElXm5r6Tx5Dz0OtYko+4JXMNNAbnjCh7FZgyml9fFcNeHoZvYCmW/BOUfT+G1bdNxZR+yCN1t6UZkUqlwuFwUFBQQEVF2zNwbhtPSeGcpy5loA70a/Sg4+4v3XdSKc0WhNY9X26Gi/pTNGthjTTLvkPoenQkO6llT+QPmJJIepYK07q/nHsfJ9s/cAyhrdtzgD2ngKif3qvzrJQraDQabLbTRvu2Cig94FzyApIWJNFrcq+mVSoEDJoLtrrPD/ldP5aIz16l/Oc1WI82U3moDc7ZUHma06rPg6i0egJDclCF9KFrjz+wbniQvJQ8HHb34j2dpC3NiMC5PKdWqyktLa29TNvKKIpIoUXRhAU1uDn/440/unW+BsCSfARd9w5uldXGRqHtEIUtKw8AR6UZ4aVHCEHu3lyCO7fMjAhApVHhGDAAku6ChVrMJWZ2zt9JwcYD6Ht2wl5Y00TZejTDuXfVzJeaWq0+dco+c7nTUKEKIQRqnRv1a7zBbob02jM8AE1oIAhB7qNv1rkc6TInFZEpE3SuG6e4hCECyo/g7Q9eE5ZzYGMAm/+zjIwFz5O+Mb3x8vVgs9nalCLq2rUrI0eOZP/+/SxcuLDxAi5iLyrFerx5saAURaTQongN6kXl5qR674d0CyE/JZ9Dyw81eRO1Ys1WvM7v67ZsxonDKVv0BwCmPzbhfekgpJRIKVFpWvCnkb6EwY9eiKVqVPrzfT+Tl5JH1poUjFeMoOzH3wGn4YQ9t4DieT8S+OANDVaZW2Qjt7D+/Y0jGRY6d+7MgQMHnAlFSdD5XgBKM0oxRtReWnWZ3v+GgvoNEwIfuZmw/z5P6XfLq71gNBm1wTmLM+c4vTx4CofNWZ90gL2CkF4d6D/tGsZc8QH+5R+x+8vdWE3ubXmXl5djNDbjubYAYWFhpKSk1HIb5S62nAKybnySove/bDxzAyiKSKFZSLsd1PV/jXQ9O1G5tf5zGoEdAyk4WMDyx5aTuy+3aW2XmVAHuh90TBMRgj3b6Qmgcvt+9AN6cGLzCSL6RjReuDnkrEadvhD/iDQADi/YxOApfVCrBeou8eStT0FKic1mw3Ekg6DHbkNl9G6wyrQMK2mZzhem1SbZllxzSfTXDeVEREScit7qsFQvy23/ZDu9bmjistzpaLyBhgcRmtBAjJdfSu4jb7jXhtoLHJXOZUBNw8/CFWyZzu+a6a/NEHI+nPdJtdWc8O0IlQX4hITSf5Jgw9S7WTf2dSqO59Woo7HlxrrcM7U2Go2GXr164efnh5Sy2jv3hg11W5E2hJSSog++onLT7mbvAzZLEQkhugghhlWFB69xNUsqhXMGe04BmrD6l7GEWo3a14jDZK5Os5mdI3drhZWwnmGsf2s9/W7vR+HhwhaX90yMV40i9+E30MZFI4QgeVEy3a/s3rKN2sog9b3qj9cOPY7pg8/wDjGw4v9WcHi/mfTLplC6fifqkopGlRA4lY/F5lQGV/5fOhuSau4BlFU4cEjhjBpavL/aSAHAYXVgCDTQLHRBUNiwp2evAQloY6MomrWg6fWrvZzxktTezrYOu3dg2pKaRvnKjRTNWkDpD79RMnsWtiKV03LQXOqclQf0xBS0gIrsEUTk3UDv/rkEb/ud9G82IB2OakvAwrfmI82Wei0D26KZNMDw4cPR6XRs3ryZlStXArB8+XKXytqy88l5eAaF73xOzpTpOMoq8JlwKaH/+b9myeSWIhJC9BBCJAH7gZXA0jOuuheMFf522DJyUEc2HPjLe8wQyqv8z0kpmdt/LoWHCynLLiOkWwiR/SPpdX0vFk5YSF5KnksOQu35RaiaMRs6iT6hE77Xj8X3hrE4bA7UWjWqBmZ4HsFaApGXOZ2JAlGP29CGmwmJ96fD8A70/vAe8oZdRdaTb2OsOiNVaXFgtdX/YrPanBdAeaWktNxe40VYaZFUWpxnpBwlByHEGc7CYXc0e1MegK4PwrHGz657jx5C+YoNVKza3MQGqv4mk/Kcz23PdKdiAuyFJZQs+AVpseKoPDXgqfh9ExV/bsVRWk7xx99T+N6XVG7bhyUpFXteEXLTE4SP/wrTpv0UfPAbsugIFb+uo3jej9iOZWHaY8N0vCOavDQMYRLencnuS+4je9oblC9bS8XqLZh3pVD6zW9Iux17YQmmv3YgrTb27NmDXq9Hmi1U/LGpiX1teS644AKOHz9OXFwc4LSqq2HMUgdSSmwnsjGt24Fp3Xb8p1yN4YK+RHzy7ya5nKoLd+eNc3BGYb0S2Ae45+Ne4ZzHdiIHbSNfQn2PjpT94Bx5Ze/KpvdNvTnyxxFCe4TiE+7DmPfGIKVkwqcTWDplKeG9w+l5Xc8GI2xWbt+PV3/PzFwMg3sDkLEjg8j+LeyRqng/lB6CwL7Q7WFIX4xabca3124ccfcT0q0bAHsWqOh4+xXY49sBsC25El9vFb071R0kz2qTOCS89Klz+chkllhtoKsyKjSZHVgs0mnGfWIl0b2dhgr7v99fHVm2WQgVCDXYLU6fdPWg7x5P1I/vkv/8BwidFoOLPgIBmHDEacbtHQNlh6H8KA4RQ+5jb+EoKcNRUo5Qq/Aedh75r8x1Dn7UarwG90Yd4IdpjVMpabvG4Sgpx3hlGQDWPVspTQKfyRpyXn4NabNjHHsxpi25+N37FdZV84l9YgZC2KlUmdn13yHIjxdjz8oj8+anUXl7UbllD96XDMRRVkHBG59SdvsYeg5OdAYSfOwtAh660RlGRKtx67iBp1Gr1Vx55ZWsWbMGq9WKn58fFRUV+PnVHtxJKZHlJnIfeQNthxiCHrsVW1YeXgMS8BqQ4BF53FVE/YDrpJRLPSKFwjmLLSMXw8UueL4OC8Z6NIOja47T/87+LHtgGUvuWsIdG+8AnFZbva7vxYlNJ+gyvgvpG9MJiA3AK9ALrbe21gFTS9IB/O+91qN9OfLHEQbc7aKLG3fJ2+g0m9b6QfgwyN8CA2ej/sYHdXgc4PQRrPPVox5+ARpz1cvSKqkw1Z4RffBtIaPO88FqkxSVOdiy17kkZ7ZKrDaJTiv4ZHERlRaJ2SqJjY1l7dYcogc5l+aOrz/O6JkeCmrX4WY4+KFzdtQAQggC7rmGwne/RNc1DnWIK+eXJBjjnP81RIEuENPa37BZelC+eBXq0CBUfkb0PTuReeOTCC8dwdOn4igtx++2K1AH+FK+bB3mpFSCHr+N9CEj8OlyCKupCwF3DsUY8RRZt+jxHtENfZ9u6LrG4XvdGHTdOqDv9QqkJUDSdLysB7C3v5FlX+8jMSyUqGemYijLxXvkBZiTUrGmpKGJiaB8zVYyX56PLisfw8WJyHITBTM+wV5QjP/tV6Lv1bnZj7u5qFQqfH192b9/P8EGE6bSwjoVkWX/YbJufgp9ry5YDh3H/75rUfv7elQWdxXRIaDuoVkrIoSYCIwFwoBZUsrldaW1pox/NxzFpaj8G7cM8rv+XxTNXkhFeQcMwQaGvjAUKSWR/U7NQDR6DeM+HIe1wsp3136HIchARP8I1r22jkczH60xknRUmlEZ9B7rh5QSU4Gp+XsljTZkA3uF09u12st5abyh98uw+1no+SxofYkbGsfxrccJ6x8GgMUqsTscJB2spFfVrEhKyQ+rSklOMzNykA9pGRaiQrWkHrNQaXHuGfkAX/5aQpf2OmZ/X8jTtwSTnW8GlZaio0WePbjr28kZWtwFNNHheI8YzIlxU4lc8CaWA0fR9+mKJrw+eU797S0nTKgqwqhYuRhde2d8KW3n9gQ+eAP6Pl0RBi98LrsQYfRGVpjQhAUBYLz8UoyXXwpAzM+vw8oL0Vy1AuEbjU6lJur7dxA+3qgD6njJxl0Pxnj4fRiJb55Px6n9WHz3Zgz6cKwdOmOzexNyxQgKXvsYr8QeWDdsJOCm8fh2isV75AXYMnLIvPFJMFvRdY0DtQpd9/jWmx1ZS8FSSP+uoew7WkrfyEIqSnMoLg5g165dXHTRRchKC46CIkoXLkNoNPhOHoPPqAtbRBx3FdGjwBtCiO1SSo9EXRJCfAqMA3KklD1PSx+N04mqGvhYSlmvj3kp5SJgkRAiEHgLWF5XmifkVTiFKz8mldEbbWwUxoUbkRWDCe4azPi54+s8u6L11nLtomtRqVV8euGntB/SnuKjxQTEOU1OpcPh8R/wiU0naHd+O4/WWSfS5rRY0/g63daoq8ZzPZ9xmhDvfAIGziZqYBQbF28k+jynp22LDY6fsPDKvFIWvBzFjpRKhiU6/cIVlNjJyLORXWAnwKhCpYJKs4PlG8vxMTj3VlKPWcguULFjfzEVFjV7D1ew952tjH7hQg4ct9ApRuuZZ6r1hfKj4BPbaFafURdguKAvGZOmYc8pIGTGw2jqetFJCUJgPZpB6XfLqdy4G7WqB6GP9cGyZQnt/voOla8Pmqq9yoB7rjmtcN2zLYENhq1E+J9aVtZEN3KI2TsGIkagS36aML/uXP7V//HlmC8JiAsgqHMQl396OQH3T0YY9Bjjgwns2w+drw9CpUIbG0W7NZ8hhCDvhVnkPf429uJSQl9/GG3nWGzpWR5b5nKJLVOh4igiZy0JA94jU1/Ex98uo0PwEnz8wsi6+Rf0PTtTvmwNqDV4D++GJqblrEndVUSvAdFAshAiDSg6M4OUclAT65wPfABUm8NUxT+aBYwE0oEtQojFOJXSa2eUv11KeXI49mxVudOpK02hiVTkV2AIMpx6aTXBMsj32tFUrism/8VZBD58M6Ylf1K4YRfGSSMQBi8M5/epjnp60mBg1NujUGlVHN9wvFoRWQ+no+0Y49F+pSxOYegLQxvP2FxOenjWGp3m0yo9m/aaOC/BQJYpjOCitWgBtVaNxqihPKOcbaZKzBYHf+020b+rnv9+X+iMECsg0E9Fn85epB6zkFtkp2t7HQ4HHDhuRaetoG/nUwsXBr2gLCeZzJIQFszeTDuLii//rOSPrRXMejycsCAPmBpHjob8zS4pInAOUPT9uoME6yFnqALLwWMUzV6I4YK+GCeNpPSL7/GOKSPr/qfwGXMRQc/cjXlHEqoD1+DV/TLoEtd0OW0mp9JsCt4xMPBDyFmNKEkhrGcY045OY/FdiylNL+X4huMEdgjESwsOAdoqJXSSk7+ZkOlTyX/1I+xVFmia8BCk1Yr3iPPxGtwbw4X9ECoVtuz8BmaIzcBSBDl/gr3c+Xc6Mp9wrxgujA+iv+9GdqX7Y+yVjK1sNJGvJaAe/DhigQpHhyfqrM5hczT73J2737w9VZfHkFKuEULEnZE8CDh4ctYlhFgIXC6lfA3n7KkGwvmXfh1YJqXcXl+agnscW3eMpVOWcsUXVxDZPxJps0ETfWnZgsIIfuJych9/C32vzvjfew0Vv66jckcypV8uJeCB6/HqfyoEdszgGKRDkvLTqbAN5m370Cc2Hib7dPLy8rBYLERF1XYPU5ZdhleAV4PGER7jpEsfjW/10tzyTeWcl2Bgl2kMA3QHCKnKGj8qnvVz97AqKgCLVZJfbOemMX7MW1KMn1HF4rU2YsK0RIVq2HvYTF6RjcRuXsSEaUjPsWGxSgpKnF4r7r86kEV/llJRmEGJLQKOpKKdfAWHcmx0iNJyJNPqGUXk3wPSm+ZdPPT1hwHImfY6ec+8h2X/IQxDBmBavQXrwWPYThzGvvlPwt77AnVUGJrQQLz6doOvcL5UoXrW5DJ2E3iFNUlOALyjnMt0SS+BvRKh9uK8B8+jLLOM9W+uR61TE9EvAsd5Dc/ag5++C0e5ifwXZqGJCqN85QZKv/qZyq17KV3wC9qO7bAdy8L7koFNDvvRIMX7YPMUpxI6bx4OG4ii9Yii3Vzi+xumFB/89aWYw/LwHxyKxveUHdrpS+G5+3MJ7R5KWXYZOz7dwUVPNS/+qVvfPCnlbc1q1XWigdMjOqUD5zWQ/wFgBOAvhOgkpfywnrQaCCHuBu4GaN++eWaIbZ3i48X4t2taGAFw7kfs/2E/N/9xMzs+2YE2PhT9X+vxqrI4cwWHzYFKrULl7UX4rGer0w3nOeuQVhsFr32Mvl/3Gj9ioRI1TIyth9MxXnNZk+TfuHEjKpWKkJAQdLqaVl0HfjlAtyu6Nak+t5EnFZERVHro+iDHllq44+VMLhngj1mnBSlZvrmCDZsqCFVpubC7llW7LdwxwZ8+nb3wN5aSkWtDqxFc2MdAu3AtJeUOrDbw9VFx5aW+BBhVfPt7KUmHzHSK0RIfrWXMBUYC01fjf2wQJTHeCL2WrHwTnWK0FJV6KKKuSgtZK6DTFKfrnCYQPH0qeU++Q/hH01EHB2AvKSPn7umEzrgVkemH+kwv6wM/hJR3YNNdEDMRose63pjd5PTW4C4dboI9r0D7SUT06Qt9IKBDAGteWoOpwETh3kLyI/LRGXX4xdR9zEDlYyD0rccAp/cJa3o21iPpWHanYsvMxXLgKJWbkyj7eQ363l1wlFXgf9tEpMWKNtbpnkpdNWM6+XsxrduOYUj/6jasRzOo3JyE75iuTmexxfucXtNH/gV+XSl4aiYa1VG0XiloA004OszD5/iHFAZeQYghE3bPAp8OTuOajF+dBjZqHRv+s4EJH02gLLOMkuNNi5pb57NoTmEhRJQQYpIQ4i4hxJVCCM96Izx9h/IU9a4FSSnfk1IOkFLec1Lh1JVWR7m5UspEKWViaGjDZ2LOdda9tg5pt1Pw+sfkvzynXqekthPZ1e5YSjNK2TZ3GxH9IjCGG7FWWPlxeQEFq3ZguMh1K7Oy7LIGXckIrQZdQkdMa7bVuhfRN4Kja5wHB0/GDHIVs9lMYGAggwcPZvfu2k5WCw4WENQpyOX6moW0OV+afl2QwN4TRg6lW8krsrP7gBmzNLL/rx94/bN8Uo5WEjK0C12OHyLQT8UNo/2JCNbw3qPh3He1c+/jor7eDOljoKzC+bfy0gk0aoGvjxq1WpCRZyM8WENkiIbJo/wY6vUBcTodQR0DKa+UFJfZ8fZSUVHp/Fmt312BxdrMg5iDPnJGU20ian9fwv/7fHWgQ7WfkYivZqAJ9kEdVodS04c4X6o5a8Ba3LTG7KbmeWgwxjmtH4+e8tkW0jWEK/93JeYSMzlJOczqPot1r68DYO83jUet1caE433RAAKmTibk5QfR9+5C6DtPoO/REeGlp3LLHsp/XUfWrc9iy8oj54FXKV/6J3lPvMOxC29EWqzkvzib/JfnkHXL05R+vwLTuh2U/7yWyrU/4Uidj+2vNyhJHUr+zJWU/fg70mKlfJcfptJbEaN+w3vk+YQPuoYM7/GQuw6rKoDcPQvBrxtsvR9O/AT2SgpSnf4jy7LKKMssc/85VuHugVa1EGI2cBT4Fue5ou+Ao0KIWUI0FmvYZdKB03eQYwDP+YD/B1J4uNAZFE6jxmf0EIrnflsrj5SSvGfep/wn5yHU4xuO88czf9B+iHO2qPXW4rfoRz71Hd4khVCaUYpvdMPr8sbLL6V82dpa6T2u6sG+7/ex/cONCH3TPG7n5+cTEhJCUFAQJSU1R282sw2VWnX2rJccVjLLgsgqFCxdV8a8Jc6lpdBANXsPm7Fbyuh+7Crivfej1UhEiD/m3HKC/U4Zdeh1Ksacb+T2CQF0iNaiUQu0GsGjNwSh1wk0ajBbHESHanA4QK8VeOlO9W/wvZdwfi8jJWVmDHoV5SYHpkqnIlv0Zxlb9zfTM7NfN8j+o4ZncXcRSDjymdOw40wCesOoDXDRd2B2MQJpxQko2ut059OcGRHAkIWQuw4KdtQIhTHqzVHEXRrHwPsHovfXYyow8ftTv1OeU7eX8voIff1hDIN7E/jIzfhOGoEmKpSK3zeh69yezBueQB3gS/btz1GxajP+t1/J4Q6Xoe0Qjfew8zDvOUjhm/Oo/PkDfDsto+L7T7Dv/BJz5BwKPsnAMCQRVCoMFycS8fkMgmc8g7ZLT9T+vvhdeB1W4U2hz0WkMYSDlr7OAIrGDrD3NdgylcrMIyAlJeklaH20zfYi4e6i8HTgduBp4Guc0VnDgWuBfwP5wPPNkszJFqCzEKIDcAK4DrjeA/X+48jYlkH6xnQKDxVi3lFJ4BO3I1QqKlZvxl5YUu2zrfizn8Bmx/+uSZT9+Du63p3JS85j0AODqo0FSrvGof/xV/bHjcPukKhdDKldeqIU/9iGlwWFRoNXv+5YUo6g63rKs7YQglFvjWLPC9+R52OkKfOXvLw8oqOd1mcqlaqGe/7kH5PpennTAus1C4eNCouKtz/Jw89HhY9BxazHw/l5fRlxkVqSvJ4gyj6b+OAijpQFY7ULAuP88c/IwnkC4RTjhpyaXf74ZjReOhVL1pai1QgG9zRwXk8Dv20sR6cV6HWCysISft5wE2OvCkUeKcK6P59Jw9qzcHkJCPhmZQlhgWoKShzY7RK12k3lLAQYop2hyIPcPJdlMzkVUPpPzuipiXXYGflVncVx2ODYt3DiF4huwLtY+XHYfJfTTZDDCvG3uifb6Vy6HFLehV3PQMLTgDPmlHeIN91v746l1MKyB5cx5KkhZGzLQO+rJzQhtMnHBNTBAYS89AAl83/C/75rUXnpkXY7/vdcg6OkHMPQRDSxUWCzOY08Lh9G0FN3IrKWItdeiXePDlji/8C7zyAiF0Sj793wIWZvb29WZV1KUkoSvaJ7Qkc7eYdMhIiVyOJ93POiGUdyCKZjAQyabGD9W+vdfoTg/tLczcCzUso3pZTHpJTmqn/fBJ4Dbm1qhUKIBcAGoKsQIl0IcYeU0gbcD/yG053QN1LKxue4CrUoPlZM6pJUSjNLkchqax6/myZQ8rkzyqa02rDsTkXaHRgu7EfQ8/dQ+tUv2C12LnnhEoQQ2O2STI0voUZJXqGND75x3T9caUYpvlGNWyp5jxlC6be1rezVWjXRXgUczvFGOlwfgRUWFlZ7G46MjKwRIC5rV1bLe1M4HWnDYteQnGbBbofpd4fSIVpLt1g9T9wczAfflbDO9zPO725Dr4XySuh9Qy/8T2Q2WK2XTlX9r1otUKkEapXg3kkB6HUCtcPBzjl/0j6xI146FZGRkfoPVs0AACAASURBVHiRR48OeorKHCSnWZjzYxEVlZKKSgdzF9UyhG0acZPh18YPOteJlLBiCGT+Bv3fgcD+Dc9eVBo4scS5X1QfpYfgwGyIHONcXspc1vwZETiX947U9nunUquI7BdJZP9Ikr5MIuHaBFa/sJplDyxj4zsbyd3vdLpacMjFmRz8P3vnHSZZVaf/z7mVQ+c83T3dE3qYDMMkmAFmYAARJYggooJiBDFgAPZnQtd115U1o6JrQEBAkCQZhihhMkzOHWc6d1dXDjec3x+nu7qrcxiC7rzPU0933bp176mqe8/3fNP7YsvPIe+rV6G5VdGAsNlwL12A98wVCE3Dd/Yp+M47DYD8b38OYZPQ/hJixW8RmoHrpJUIIcY0QqAogC688EJWzJ5Jd1MAYo007Mqnxfk9EqkiOkMno+/+PavnXkVF7gOIcS5GR8JkDVExMJKi2Q4GL93GgV6p8TIppUNKWSGl/EPv9ieklHOklLOklD+Y5Hj/zyPaHsWV5cKT78FM9Sf+7SUFyJSOGQyjH27CfdoScj+rpJht2X40vxeRSnDz7zo40JjizieDGLEEBbMK+MWlgtys8eutRDui+Ip8Y+5ny/ZjLykguetQxnapG2gOBws+vIjnfjn+AkjLstIeUHV1NXV1iinYSBjY3W8v5Yqu6+yut1S4zKXO63ZqvP80Pw674ANr/cTsMyiXrzCzKMKBRhNfjpMFsz1EWseOxbucgoEkFJety2ZOpZNdd++kdIGb5WfMBCArKwufM051mYOULjnSbvD1j+XTHjCIJyWHjqToDpnsODRJWemsGiiZZLVXshOyZsEZD0HOXCha1d9vNRJ81ZA1R3k6Zqq/mi60Xxmhvf8De2+BykvgshBccGD8suhjIXcxlJ4L8aGaPE6/k09v+jSuLBcnXX0Siz66iH0P7eO1H71GIpjgoSsfIhFU3/Ex4fzrhQjugpcvgf0/U57f3K9M+Bh2u505xaswQgYyez5h+ynU7juZQ62fxbno08hgr5Jt5+ucetnUMiaTNUQHUGGy4fBhYP8Irx3HMUb02dfpvuVPhO59ctT9Yh0xPAUeCqt86FbmDZh1xflEHliP3tiMoyqz3sR71krcdQcozLVxxxNBlfwOt1D6nhMJbGqYWGxYMu6VU/anLiF016MZxRSx5zbgOWsF7nllvP700Ql5RX1wuVykUqokdd/D+5jzvmPAszYBGLqObtgozreR6x96+33uA3lcuG461Yl7KfG209qtyoDnXzqf2ufG7h13O8WQkNq6E5207WijOnEZuFQxjhCC+TOdOB2CLK/Ge0/1sXqxh89cnIuUkvpmnYYWnf0Nk6SR1BxQepYSzZsoNlwNVVf0Py9cNXap9Wn3Q+k62PZ1ePlCeO1KxfJQ+2fY+GkVIsxfpir57D7FknCssOouxSrx2AnD9tWVL1dh4WXXLGPll1ay/LrltO9u57VbXiN/Vj6Hnz5M02tNPHvDs8duTA33QsFyWPoL9VvMvX5Cb991r+rOiXfH6XH1cCTnSho0k+4mSUPtErJXX4vrPfdhlH8MEu2IzonLSAzEZA3RfwCfEEKsF0JcI4T4gBDic0KI9cDHe18/jrcBRnM7yW176PrGz0fdzzIscmfkUlRmJ+nI9EocFSUYrZ0YR9qHdE/LqioitUfQTJPpJSqlOJc2vItnkQgksExJIGxijcMoTMRoCU0j74sfoefnd6W3Jd/Yh3vpfA416SRqKjj01KFRjjDyOf1+P+FwmLadbUxbdqwLPUcfSzyRwkBVseX6h67InQ6BzZ2Dhk62vYe2brVKLphTQPvOselzCnNt5GdnHvfV/36VFV9coSrLCvu7H+x2O6Zp8rcflnPDlQVk+2ycWOPGtBRXXX2LzpF2g2371WIgMNESb28VRCahU5NoVd5NH0rWQM4YBLeaXVUj1t+lSoybH1fl1TYPnPwTmPUpeM8GNSkfa2gOCB9SYz74GwgNr0Tbp4K77JplXPj7CyldUsr5vzqf9t3tPP+t5zP0uCzTmnwBwN4fq78110LFhWPuvvMeJVxZ90IdekxHSsmjn32UcEuYaHuU7Eg29/7uXshSlYGrblilPk/F+dgL50HuIlUaPgVMyhBJKe8DzgN8KPqdB4BfAF7gPCnl0FKs43hLYHZ041oyD9+FazG7Ro/r51bnUlhiI5oaejMKITA7urEV9is3hpvDvPyDl+lauYqryxuobda59KxsSsJtOGZUULmqkuShNv78WJD2wDHqQxkAe3kJ9qoy4q9vx2jrQjgdCLudzh6D7KXTqX1u6CQnpWT9+vVpSntd14f0Dc2YMYO62rq3Xu5hEGIJyb4Gi9ICNyV5di4/dwQZC6HxWk0DOcHHMS2td5PAW+gl3Bwe9Rwzy53Mmd7/eQ8/cxh3rpv8mbmw8Nvg7Ke8KSoqor29HYc904OKxC2Kcm00tuq0dhnc9oDKA97xxARLpEvWQP1fJsS+Qc8umPMFyJ0E3Y3Q4OJGRb66/FdQdzvMvxHyl0ys2XUyWHGbaubd/g0I7Rtz95LFJcz/4Hxc2S723L+H+hfqkaYk3Bym/sV6/v7Jv9P0atOYxxkWB3+jQpXuonExXDz4kQcBOPz0YRr+0UCkNcK8D8yj9Y1WIi0R6kP1VIYqmb50Oqd+9VTyZ+X3S5IUrFSP1ucmN9ZeTPpOlFI+I6U8FfAApYBHSrlKSnkM/cvjGBOmRf6Nn8T/gbNJ7R05dCOlpOzkMkoqnPREhv7s9ooS9MbWDEqSXffuIqssi+iZpxP/xzb+89oi5kx3Ig0D4XQwY90MvLXNbNoTp30UmeqpIOuK80ls2kn3f/+B7M98EIBA2GLNEh93bIHOfZmqmYcPH0bXdXbuVKu8eDyOx5OZlC4oKKBhZwPlK8rfkjGPBN2QRFN2aqq8+Lwafs/It9/yhXmYOSdz3w/6PdSFH17I3of2jvt80pLUrq/l1K+eqkguB0lsl5WV0do6NK8xvcTB9FIH4d7epL5QX0vnBH9jbwVknwBdE9DjaX0Opg0hTRk/7D4Vfqu5Fi5pS6vQvuXwz4Dpl6lG1/DBCYesl3x6Cet+uI4jG49Q/1I9dS/UEWmbZH9O+fuh4qJRd2l6rSndl+fwOYh1xRA2wZENR9j7wF4WfmQhDS83IGyCwnmFLLm8X64jEDZ59B+9Yytdp4zeunfIEPVBSmlJKdullMcu03YcE4Z75SLiG0eqH1EoqCnA79QJR22YeqYH41mzbAg1fSKYYO5nVpCX70I4HRDvzdf0huFcWS6yHSYr5nv4wyNBovGRL4G+woCJQghB3pc/RvFPbsSW7ceyJLc/FmTFAjfTLlrE1j+8gWGq8XR1dVFbW8uaNWvo6FTVSLFYDK83s3HRZrPRXddN1Zrx8aEdK6R0STDuJD7jiyybN3ry3ePWEN5yClz9VVXZFdn01I+vmk1KyfPffp5FH+mVAK+7U3XHD0BOTg49PUOP94G1WZy70kc8KUnpErdTpMN0A/Ht28Yh7V5xoWo4Hd+gofM1cBeOve94MFaBw7FG+fth2S/h4G0IffxVh0ULirjgdxdQMKeAf/zgH+RW5TL/svnEOmJsv2M7z9zwDEc3Hx3fweJt4MgZM6e2/c7ttO1sQ4/pzL14LrXra7E5bKQiKZ7+ytNUrKxgy21bkJbE5rRRMKcAr9fLli1b0PV+NWAA8harcv0pYNyGSAixSQgxv/f/zb3PR3xMaVTHMWFobpeiaB4GB588mGa5lskU1efUZMSjARzTywaxFis0telUltjxX7CW6GMvYYYiaNn9Oaay6iw+daaDT16Yw4ZdIzRC6uFxl26Phe6QyZc/nIemCZYt8rGxSePJR1R8uqOjk5yiE3jkFYOt+5LsrU/S0dFBQcFQ4kgzZXKk/ciUxzMR7G9MEUtIfP5sTj5hHJOkt0L1xwxA+fJyjm4aY1I6eBt77nyBE1esp3Rhlqog2/pFlXsZgNGqBT1uDZ9b4PdqLJjp4hf3dtPSaZBIWaR0SUunQUuXweY9YzS/OrIh1pRWUx0VB34JRW+NzMDbCk9Zf9XeOLD0c0tVWXWWi3X/uY6TPnESZ//wbB6/9nFa32wFifqLouiSUqYfA/Hf//UfpJ4+U7Gfj4BNv1JTs7fAS7w7TrQ9yrRl01Sje2cMp8/JtbuuxZ3r5qbATaz7wTqklFiWxcqVK+np6UE3ldbVwy/1holLzwbX1JhJJuIR7QbiA/4f63EcbzecdmRyaJXTnr/t4aSPn5R+Xra0jJato/elgJqomtoMKkscOOfOILnjAIlNu3ANICWtOb+GQ08cYvFsFwcaB53bTELLs/BA4TEzRM9uilFaoDyrLK/GwYpqel5UyeE9h8P88M4I2w8kiMUtbnugh/aOLvLyMg1RuCVMTX4Nhw4dIhaLTXlM48XNv+tEIsjLHmfZsKcUUpl9JnM/MJdNt24aGraRMp2LSdRvosr4BIXybkVw2fQQzP4snDC0ckoIgWUN9WS9LkFJvp0cn8a65V7ePJhkeqnSOjrQmOK1HTFOmuOmvkUf+3OUrIPgOKaEIw+D91+A63Hl71UPVGIcHiMw65xZ/f+fq/63OWxUr63GX+bnnB+dQ+hIiK4DXTx9/dPsvHsnt912G7fcckvGcf7fN7/Df7y4GLnyjyOea+/fVGhXs2tYhpXmWax9ppZoW5S1311L4QnKI+1bqAw0ejNnzmTHG5swDElds85966fOMwcTMERSyqullHW9/3+i9/mIj2MyuuMYFVI3wD6A+mXRHBJvZiZKN/5iI/5Sfz/xohDkVueOO8TT3m1QlKvO4btwLT0/vwvXSf0EoQVzCug62IUQglnlDvbW95brWgZsvgaaHoTyCwkfDU3JEB1t1wlGTFq7DE6sUXH/aMKiYkYWqaRJT30PnYEY5SU+2gMmCcPJ3toQe+uSvL4rczW+5297OPFDJ7Jw4UJ27do1ZXqSicLvmUDiPNml6Gh6YXPYmHvxXPY+MChXdPQxaH6CyOFd7H3WILLgCVh9tyoWeOPr0PSAkp4YhOLiYtra2oZsz/JplBfbyfbbyMuyke3TmFvl5PqftPPGgQTxpArZJVPj+O580xWrwWgwUyAckLtw9P3+GeCrVn1Umz8/pcMsuHwBOZU56ZaHV3/0Ku/52Xvo2t9FuC3Mztd38vh1j9Oxp4PWN1uRUtLSYufQU4cxdZN9D+/DSBpIKdl9/270mE7rm6207Whj8683076jndDRELlVuRzdfJSqrw3f92VZVoYhisfj6IYkFLU41DTJ8v5BmCzX3HdGIjgVQpQJIY4Fvc9xjAGzozutPgngOX2p4pEbgH0P7aNuvaous2IJhMc9rgbOvvJRCWi9N4Jn5WKKf/mNIcqodrcdUzc5Z6WPl7b1TpqxRjCisOS/ofAUcoP/RU755DvZ73giyE23dlBeZE+zCKw92ctnL86hffFcXvv1VjbvDnL5uYWU5NvIzsln7Yk6b+xP0NqVGbKMtkfJLs+mvLyc3Nxctm4dSrJ6rHHbgwFcWpwrKn4zsQZaVyE03JOxad4l8+g60MWBxwaUCXdvJd6wDecrq1h4/RcpXblQhblmfFwRreYvH/bw06dPp6lpqJEoL3LwnlN8rFzgxu/VWD7fzdxqJ1/7aD5H2w0MU2K3gWFK6prHmIy80+G1j0C0ceR9dn4HAttUP84/O2xOKDkTjHC//tQkULSgiKL5qu9Lj+kULyompzKHRE+Czk2dtNa10rmnkz1/28ODf1KVbx2NEUJHQhx66hB/+/DfeOMPb9D0WhMvfOsFnrnhGWa/dzabfrWJjz7xURZ8eEGavPTEe67m6d3D53j7QnN9ZLjJZJJosIlgxDxm1bKTLVa4GUVAOhym9b5+HG8xjLYubCX9iV3N40LL9qfLuJPhJDPPnYmZUheL0dSCo3J81Pztu9opWVQyhP7cUT10/THrnFkcfPwgQgjys20EI6ZKms78pMoRzPsaPaFZuOThyX1QYH9DimXz3Fx0Rv+qvij+HFVt3+LZ3RYvH4L5eSlOnuvlm58s5NrLq3nP0hQfODObnvAACYmYjm0A9cCcOXMIBidYljxBBCMmPrfGsvJ62mfcMvYbBmLxdyFSP2Tzkk8u4eCTB9n6u62Em8MEDjbRtekl7OWn4CgbwO920g+hYIUqLR4Gfr+fSGT46iwhBCfWuLHbBDdeWcDqxR58bkEipSQnHHZBc4fBX58dvaQcdyGs/qvqtRkJjmxYOnov3D8VhAYzr4ad/65IUSeBqtOrKFmsVGMXfGgBs9+jjPS+h/eRaEzgrnQTWhvi8NOHuetXfwKgZV8LwcYgLz/0MsapBkc3HWXHnTv4/O7PE++Ks+zaZey6ZxepbB+B3AKObFR50h2Ne7HL4em6gmEDw7DSBL2mJYl37yEUNuk4RtWykzVEgpHlGCqA8ROQHcekYTS1Yp+WWR3jv/gsIn9XrNmRlgg503P47LbPAqA3tmKfrgyRM8tJMjxy13vTq00UnFyOxz32JVJxSgXNW1XBQHmxnbZuUyXGB+jRxFLloyZRR0MiZRGOW1QU23H1ekOkArDlOrQDP2e6/whbSmchm7rwugV+j0ZeXh7NzU1MK8mhrNCeZpTefd9u5l2S2RxZVlZGQ8PkxjYe/OWpEKYlOW/uIZL5Zx2TY5YsLuGMb51B2842HvzIvQhXHuULLLQTb1aTYB88pTD9cjjpRyMeazyhSYddUJhrx+3SsGmCWMLC49LYui/B9oPjKETIma+KFoYfgMonVv+L8Rn7Z8K+/1HkrVNE+fJyCueqRecX9n+BBZcvQAjBl777JaLtUarOsdA0jZRM8Y8f/IO8JXnkr80nakSZf9l8NLvGpfdeStXpVbg+fy5Jl5t4bjYrv7ySuro6fvGzH7Nz41+xLCtdhWqaagH76CthAmGDzqB6XlJeg9R82GMbiSUlz22OjquhfTRMpGru40KI54UQz6OM0G/6ng94vAbcBbw0pVEdx7igH27CMasyY5tjehlGk4r5h1vCZJVlpUNBRlMr9kpF8JlbnUuwYWRPINIWIen1pvNDo2EgbU9Rrp2GFh16doKn32lO6CWK82sS2Lo3wRlLvJmMAdu+rlb7VVfw+2vq+fH1pUybX0Dts6qXymaz0dXVRUFBAWtP9vKt2zoxTUnHng6KF2Ya73nz5nHgwPDd8McCTW06dzwRokDsR2TXjP2GXqQNhN2rONMGIassi/N/eT5X/O1scufOQeTOVQShgzH706PyqhUUFNDZ2Tni6wPhcalKukDYJD9bw+UU9IQtnt0Y5e6n+6+nQ02ptLQEoCoAR1qI7PsptL0wrvP/U8E/E6QF0fophegG48Mf+zAF8woIh8Pk5+eTV+0lpcdwOBz4Z/m5oeMGSpeUcqjrEO6L3Mxcl0ln9HSsiGhcYpqSVV9bxV133UWuN8ZLT91B7ZEIz2yI8thjj/G9730PUF7H0SNHOHq0k/vuu4/cgumInFNJmQKvW2PnoSS/fWhqJLkT8YhiKHmHrt6xBQc873vUAT+iV+30OKYGyxid5sOKxofkawDsVWWkDjcSaYngL+sPZZmdAWxFqrM+t2rsgoVESqaJOceCr8hHpC1CWaGdPz3Wg2Xq6X4Qy7QwyYXk+KqIBmLznjjPbopy4el+ZlX0MgboYUX5Mv1SWP4b7PFGTpzjprgmj8ZX+vMQPp+P0tJS/F6N6jIHW15ooXDe0B4VIQRut5tweIwQ0yTR0mmQ6+jEcE7D6Rh/fiidSyo6DTZdM+J+Ti0ArmJYdivYJ56Hq6mp4eDBg+Pa1+PSyPJqdARMCnJsuJwadpvK4W0/2O9h7ziUpKNnQP7A5gIrOZQYVEpVUbfm7xMe97sergJY/O9qAfb0KcfssA8++CCGYdDZ2UlpaSn6oh3ErCzFIOKFex65B9M0CQQCGAM0ofo8HbdTIxyz0uwIhmGgp2KYlkk8YRFLWuzZs4fubpU/EsLiT3/8Le2BGB0dHRgmrN8cw62FqXC+Sk/ExDPOeWIkTKRq7n4p5WVSysuAPwOf7ns+4PFRKeX3pZRdUxrVcQDw8g9e5vuO7w/7Wuiux3CfPDz/Vtbl5xH+yxNEWgcpog5QNs2tzqWnYXhD1Gf8kinFEj0eTD9tOk2vNZHl1fj6Rwto6eqfhAK1AaVlNAmer6Y2g66gyYxpTgpyelf1Dff0l/navRBvAT2kSlJNi1RUJc/PO+883G7Vr3P52Vn8+lvbhoTl+rB8+XK2b98+4fGNhX31akKe5dtL5dyVlORPQgKs+HQlNmeMIKzWs1MZ5knqUfp8vnGXsfd5RF0hk/xsGzPLHZy3yk93yOz/fYB40iKWyEx+S2yw87vpCRFQeaPaP4Izk/XhXwbZ8xXhaN6Jx/SwhmHQ09NDbl4Bn/zpL4gZLux2O4lEgkOHDnHvvffS09OTJvgFuPTfjiKlxOUUhGMWhtl/rFQiSiRqEIwo9vWdh+I88YrycG0axOJJIjETKWXagCU8q/HYgvR0D2XnmCgmmyP6OTDsHS2EOF8IsXjyQzqOPugxHW/B8HLGem0TvvPPGPY1ze1COO0kuqO4c4dvnPQWeYl1DD/59BmwpC7HbYhKFpfQtl2FBE+cJWjp7r+02ra3UbakTFHMTKDRDyAUNYc2f+64WVGq9KH6o9CmosHzLpnH/r+rMFZWVn+5+KrFHhaWgTtn+O/D7XZn3LTHCn/4e5B4UnLdeZ3klM0dwus2bkz/oBKJGw6Rw4pKZwpwu93E42Mrs+Zn21g0y8VPry+htMDOyvlu1izxcsmZWRTn2di6L8EfH+2hK2jyzd900NimQlKJlMWjzR/CkE7uGRDC480b4QP/wqLLFRcowlVXEWy69pgd1jAMkskkwZiKEkRjisoqlUqRSqXYsGEDwWAQXVfff0/YJBS1sCzF0H7/c6H0gsAwDBKJKKZlEuo1RHvrEiSSOtv2JQBJLK4jkBk5pIvWFmEnBtE9TJVYZ7KG6CfAyhFeWw6MolB1HOOFw+Ng2bXLhoTnpGkiPKN35ruWLcTZ0jhiqbAQYkQZhY49HRTNLyKZkv3FAWOgzxsBsKVaSdpLSfTqHnXs7VCJ1qwaCI8vBATKM6tr1rn6gkGr5dmfVRT3ffBNTyfCpy2dRvuuoSzV9U8dxH9iBZ09I1f5HGtdokTKYk+dClf5RLcqxZ4sSs4ahUxz6uSts2fP5vDhsXN4Po9iWigrtGOzCc49xU9liT0dNv3BHzt5blOUh1+KEAhb/OERtfCIJyWtiXJi/uV4k7t58vXeSr3cRYqJ4F8dyQ7FCD7OJteR0DcX6LqOy+VC9NIYxWIxsrKy0oYoGo0SCARIpVIcOHBA5W2BA4cbCTRvoqlNleDv2LEDXTdIJqIgTXoiBnvrknSHdDSh8+cnghRkaySSKZx2STxppj2p81f7Oen0q4knLZKRd0aP6GTg1RFeex1YMsJrxzFBOLOcpCKZK3WrJ4wtd/TmUM/qJbia6/vfE4khfOPLH6QN0QQ8IgCH16HGGmumamYVG3obSc2kqSiGsmpGpMgfDoGQxZLxUOG4i2HLdSoxjPJ6wi39+R4jYVD/Yj2VZ8/mQ99o5vCR4T2f8XoF40VP2CKeVBOH02aOOzQ5bF5QaBNjsZ4gRmpsHQ9y/DbWnqw891MXefjIeTnk9GotHTqic+eTQT5401HiSUnAdyYlqZfYu6eON3e3EdGH9/j/5eCfBbM+o5ixJ4hv39aBaUqicYtgKIHX6yUej+Pz+RCauj8cDgd+vz9tiCKRCD09Pfz617/mhBNOIBBR98afHmogGVGsKoYJf/7zn0mmDJKJGFJahMIme+qSSCkpyYOGFh23C+qOxGgP6LyxP05P2OS/v1CEwy4oyrNzOLySeGiUHrFxYLKGyIaSgBgOPsA5wmvHMUG4c90kApnlsWYghJafw+77dvPcN4dnvdU8LrReKYQ/Px4kVd+MozJz5Wn32NHjQ6t5Yh0xfEU+ZYicwxii0MFhq4Bmnj2Tw88ehngzZRVVNLXq6HE9zXOHfyZEx69P09SuU1E8KKdipoZO6EKDU+9QQmjAkk8tYfuf+/M9O+/ZyZJPLaGyV09pJENUVVVFfX39uMc3FsIxC59b8Jfv5JB9ZHw9MslkkvXr1w//omYHa7gGwqkbqIF0LlM5RkGujfet9jOjTP1Gbd0Gf3pUheJiCYuwWYTLbGed/ConbS+lSVs71aH/c6DqchWmG2SIghFzxOuxD23dBgebUuyqTbJ1Tzf5+fls39+Dz+fD1XsruFyuDEMUjUbp6elJs9Dfd9/9GKkwoahBPKK8MsOUvPnmmzz91JOYRgqkyVOP3Y5ugNMuEdIgFLVwOSCV0lk8y0kyaXLbgz3UVKopPj/bhoUd2zskFb6ZkSvjPgtsmeRxj2MQfEU+oh2ZSWqzqweR5adlWwtGwhi2H0hKieH1E6htY/2mKEc312FOz+xBHquEW4XmhrnADtwKtX8asnna0mk0b2mGeAs2XxmmJal7vo4Z63rzOTYnWOPPw2zcFWfBjEFVgZHa4dU1S89Jd+57C7zocZ1AbYBwS5i2HW0ULyhm8WwXpyx0E4wOH88uLS0dVhZhsrj3mRBul0aZfR9i5ifG9Z62tja6ukao9fGUQ2RsMcDJoqioaNxl3MNBE2mnlLNX+PjuZwpZs0R5PBec7ieWlETiFp1mNSe4XuH56LXEPSeNcsR/IWTNpsOcjenIh1QPyZTKtdz7TIjnNg8tQgnHLDoCBsmURY7fRlfIJJmSdAci5OTk8fLWblUV6lTXvMfjIZpyo+s6PaEEqZSe0aj8ykvP0PjmbwlHdd58+TaktLjryRC79uynqakRw9CR0uRo02H+7eMF5Pogqes47OB2gmXpnHeqF7tN8on353C0cR+JRAKfPYzTYaLZp+Z7TNYQfRdYJ4TYKIT4vBDiEiHEdUKIjcCZwLen33PaugAAIABJREFUNKrjSKNgTgFd+7t46vUIuw4rg2MFQkRigpLFJSz6yCIOPjE075LoSSAXLOTxH73Asvlu/vHwPr79tDtDqiFvRh6BupF7j5OpYUJzRlR1wUcbQM/syBeaQGgCK9ENzjwaWg0aXj1CxSkDDOAEVtxOhxjaUBupVWGOQbBcxQizfzyrb1zNzrt3su3321jznTVqfEKQ7bMRGsEQadrUcy0D8cLWmOKV69kJ824Y13u6urpwu900NzfT0TEonzDtfNj3M/W/mYItX1YPR84xGe/MmTOprR1bjnw0nDhHLRzOX+3njCVe5lY78bqVHHkiKdlTl+T12BU83Pkl3kh+kHBMtSgcPpKiI2AQGUVK5J8dz79hsSO8CvnoCdz5ZIhgxCIU7afOAdJ0SW/sT/DTe7pZvzlGllcjFLGIJiy6A2E8vhx8Lh2fz4fbrr6vmpoaOpKzsdlsbNsXJqVnRixcLjtzp2tsXP8bpJng1IVOpLTobG8llVLzirQsEokUZy3z4naBZRpMK7TjdIC0dOw2STRuYkbreOqpp+js7ORXt/6EhRVhvv//rpzSdzNZhdaXgXMBC/gl8DdUJZ0BnCOl/MeURnUcaeTNyqP7cDeNrYo3DcDsDlK/tZNpy6dRemIpRzYMlTMIHw1jmzuD5O7DzKtyMq/CRmmJh78OYMvNnZFLoDbTEEXbo3iL1Co2NVyO6MX3Ka+m7QV489+GnLfqjCqC9V2g2cl1SzoCRqYSqt0Heu8YRjFKI4aIEi3DJrd1Xcdh6z+m0+fkjG+dwZpvr8GT158bK863MQzZ9PjOPQFYlsTnFpwwLaEaGr2Vo+4vpeT+++8nGAySnZ3N7t27WbVqVeZO3mnq+4u3QeBN6NkBwV3HrDR4NLqf8eDK83NYNi8zD1ld5qCy2IHPo7GvIUlVqQNN09hq+yrN5kIeeTnMX54K8dBLYe58MsTzw3gH/yqw2WCr7Wuk8teSiAb5xV+7CUUVXVJfSfSn/qOVYMQkEDLxezQ6e0y+/rF8AiGTX98foDsYxuXJxakl8Pv9aJoNIQQVFRXMqpmLJQWxmI5lGr3nVOHoFQv8ZHsFPV1H0PUEpfkCy0hgZYR6LUI97Wzc8BoepzI+S+e6sWsgLYNouBuPC27++iUcPHiQVCpFMpnky1cUoIm3iVlhMKSUL/YqtGYBlUC2lHL1cSN0DCEtrCOtWIaF0yHQTUlDi068oQPT4aGgpgDNrpE/O39IT1D34W5kYTbhFacwp2EbNZVOvnF1IZog7RX5in1E2zNv/PZd7RQvUMwDpiXT6pxpFK6CuV+B0x8Ytvejem11eiyn00JiwYzMHWZcpUJ7AK9/fFhjJKXkYJOObzgF00QbuEuGbE6lUjj9xaPzmQFXvz8H05Lpir7ByMvLIxCYOkPVr/8W4NMX5/KVymug/cUxpaq7u7txOBw0NDSkSSbLy4cRG5t7PTxzCoT2worfwVnPKpXMYwS73Z4u+T0WWD7fw7wZyiu6+dOFnLXMS3fIoqrMiU0T1DXrPPxSmKPtBn6varTc1rvgemFLlJ2HEumKr39mxBMW8YREuEshcpjC5Csc7VA5mHjS4kPf6NeYeuTlCJv3JvC6NaSUeN0ard0m7S0HCAUjON052EQSIZx0x5zY7crY5Ga5kVLDGhD+tjuUh2qz2QCTVCKKnkpQVSIw9cx7XxMW0WAbmzZtQsT3IS2D81f7yc/R8LlM/vS/P+G5R39J89FGLMtC13WSySQOu21YKZGJ4FgotMaklEellG+fsMv/AZi6if/Am3T/z+0gJa7OdrxujW//toOjr9Sy+DMr0vvOfs9s6l+sz3h/+8529JI8zrl2Ff43t6Ur5uZWu3hlu/qphBAkQ0mMZH9Jc9vONooXjaLuqDkVf5mnDOz+IU2WNocNaUmCTUE63mhBqy7KfL93mnrPc2dD9xbVAzMI8aTkj4/2kOMb5vI0U8PKP6dSKZz586BjdDVQIQSLZruobx5+cisuLqa9fWj590SxZW+Cknw7Ln8RZI3d43PkyBFWr17N5ZdfzimnnMKZZ545/I7eCsXsvPdHqpdqkk2sI6GqqorGxqlVQA3GFedms3i2i3nVLoQQdPYYLJjhpDDXRjBikUxJAiETm1B9V3c+ofKWm/cmePL1KLtrR+ZEfDejj38tFDW5q5dv0GaDsPcUFnAPnT0moahJIGwRjFj8/eUwfo/g9seCNLbqeN39i5d9+w+w9/mvEwpHcHpykWaC6QWCjkQhdocTwzDJ8rlwujxYpjJE3/3Zi8yZr9oc7HY7UpqYRgwpJWuXejD1zClbSpNUKsaRI0fYtGkjlmWQ67eBlGjCIpmIE+wJYJom0Wg07RFpmpbmpZsspnQVCyHmCyGuFEJ8QwhR2rttthBi6gpo/8cRaQ3j1sM4KkpwtzQw+45fcekaL5eu9dHTY5BV1v8V583KI3A4cxVvJA2auiRV0xQjt3uFkoxeMd/N4SP9k/Cc982h6bV+Msp4Vxxf0UgFkYOQuxB6dg3ZXDAnn4c//jAzzprBPc+E6Bjcu1O4WhUcnP2y0skZACklgWCCBYlfkO0bjh9t+BCArus4s6apHNIYOKnGzfpNUUxz6LGKioqG5mYmgWDUoiTfBr4qmPOFUfcNBAJ0dnZSVFSE2+3G5/MpupaRcMKX1DG1SbA0jIHKysphZSGmgqI8OzOmOdMeblu3yYlz3ORl2bjju2Vc9b4ceiIWgYjJle/NprlDXS8dAZNEcvw0U+82/PlxZVADIYuuXsLQvz4b5gX5A1rMeaoqLWYRCJvcdFU+7QGTHL8Nt0vQ3GngcWn0ze9Hmw6TXTCD51/dx9FuL0ida99XRFeyAKfTDcJGTpYLh8tLnk+9aX5NGSWlFVRWVmKz2VRDaq+2lWEY6MkgRUX9C0XLNDFScaLRKIZhkO2xyMvWeoXxTJLJfsMVDofTHhFMvQdvsnpEfiHEfcBO4PfA91HyDwD/yXEZiCkjdP96HKcsxbmoBv+BNzly9kVE//Ioi2Q3ySxfhjLm4IugL8cRjVv4vRr5/+/TeFYqsgtNExm8UMULi+ncN8lKqZyFKkcxEJZBTmUeVz5zJXPeN4f/uKaItq5Bq6XSdVDzOcVFp2cqPN72YA8vvVpLkXaAbP/4L89UKoXD6QTEmAURPo/Gmct8PLtpaD7C4XBgGFOjtjdMyZlLvUwvcSgPMn/0trpHH300fUOPC3knQc2x69IfCJvNNuXV7ViYM91JXpbGh8/NpqLYQbZPw+fRaGo1OGOJl2Xz3MSTFi1dSprcOVk2incA27ZtS99/zZ0Gr7wZ4+rvtxAIq+/05s8Usm1/koRWxt+W1FDqqE3ngwpybFQU27nho/mKAcEliPcKDzo0nZoTTiLQsgObKxuv0+BAs5PVi52YuBCandwcNw6nF9nbWpHtd5CdnYPT6cRmsyEtEyOlcoCmaaInApSV9edbTdNET8WIxWLouo5pquOkUilcDkkiHiM7WwlshsPhtEckB1CHTRZTYVZYBZyNyhENHMUTwHlTGtVxkDzYhGfFfDyrl+A5sJOuklkYTW0ceuoQS1YX8/Ibg93q/sk3dCRETuXIlVRul5ZmRvaV+Ii2qQlZWjKDSXtMeCsgdjRzW7wFPOVodnVpFefZh2qW2FyQ36uZY/OC2d8nZVrQUNfIeSX3Mzf2y3EPJZVK9ZI+lqsxjIH5M5w0dx4bLZWBiCct2gMmNdOdQ/NrI6C0tJT584fXC3onkJ2d/ZYRwAL85qZShFCVdKAEDn/85WKa2nRmVTgpK7Tzn3/qornDwLLI5KZ7l2Pv3r3pibk90C8c17f4m13hYG99isS0D1Hr+BA/PuG9BMIWfo9GeZEdw4Qzl/k4aY4Lj0tL5zKz3DoV5SXIVAdZWXm46GF/cA4ep4Upneimhs/rxO7wYBpqUTOtyMW5556dNkQgMXpfM02Tq86VTJvWry8mpcQ0EmlDZFkWR48e5fbbb0cTFrGY8pTuvvtuIpEIqVSKRCLBI488MuWK08m++xLgJinlC8Dg5VMDUDWlUR0HsZYQhQtKseVlI6/4EGZPHCMnjxyvgdOpoeuZN2dudS7dhxVbbsvWFpJlhRTlDR+6mV5ip6ldTcIDqX4CtQFyZ0yAfFKzK/XPgUh1K9bhXhTn2zjaMcqEn7MAgnvST/0ewelzlIemxWqh9Tk43NuzZKZADP+ZdF1XhihnAYT2DLvPQPSt4IbTUbHZbJP2im57sId7nwlRXeZQEt/1d466fyymVpnV1dWTOt9bgYqKCo4cGVqJ+VbB5dQoLbBTUaK6M90uQUGOjaoyB6YFjW0G9z6jPOddh5NjNoC+U7j//vs5dOgQXV1d6IZBIKRyQCsXuNX1gGoA/dLlecyvKaJkzipajHl8puqH+L0aOX6NUFRNpz+5vgSPS5DoZeZYvVjjlCXlyFQHfn8ueiJM1DYTTVh4PG6iCRtV1bMJy5q0J1Ne4uZzV1+M0+lM54j6ogWGYeDSQhkeEajquFgshmEYWJaFaZrp/6PRKKZpphcqL774Il1dXWzYsOEd84g8KNmH4ZDFUON0HBOAlJJkOJkmPPV/7CLMQJTGUA6Vej1aXg4elyA5oPJr1jmz0lo8bTvb2G/4eM8pw+d6ZlU4OdDYfzP3eVN1z9dRvaZ6ooPNfJ7qBucA+XKXlqa5GRZ5iyGQyXp9WuVe+FBUhaCSnf0FDfFm5fEMg1QqhcPhUGzHwVEMUeMDcPTx9NgeeGHQyj/RTlHh+PV5BqMi8GtCUZPZFU7Va7Xou6Pu39XVRWHhFDjo3gKUlJRMmu5nKuijCXI7VajuinOyME3JHY8HefNggr11SfY3JGnpNKYsxHaskUqlyMnJITc3l1//+te8+PphEilJe8DE6RAqCpGUaJrgrGU+Fs5ykT3nIt5MXsSS3FcpzbeR47dlNFu7nSJ970gzxalLpiHMEG6Ph1QijOkpR1oG5SV+nt6YoLCojHPWLlIsCfRVyqlws81mU4aoFz/60Y8IBAKUlpamq+4UJNGoipAMNESmaaY9JY/HQyQS4eabb+bgwYPpgoWpYCrMCleN8NqlwGuTPO5xAKGmEN7Cfg4uf6kfMxAjFHegtbXiv/gsyosdNLX1r9pzpucQbFLJUTNlIhz2EZmeSwvstHX1v7dkUQm162vp2Nuh5BomAs2h1DX7kOwGV37GLlVljnSj3hD4qtO0P5YlaWzVlddj9ypy06rL1TksXRGbjtCPkw7NuQshMgqNUMc/oHsboKq5jrYb6pwAm78AD0+nuPYm2nbcO66P3wfDlLR0GlyW+22qyxzqu48dGZ4FYgA6OzvfdYZI07Qpl+NOBpecqQpwPC5BdZmDSFyS7dewJDR3GNz3XJijHQYvvRHjzQPvrkq6+voGamrmsHTpUvJnfoDpNavo7DFp7zZwOQXTCu0caR/kZXsrMGZcwz+6zsPX8FOyfVpGs3WWT0tXcCYSCYqKiohGw/hcklRPPTm5BZimSW62h+mlqlnd43Kh65mGqM8jEgMWjbfeeiumafLe976XnJzMMH6fJIhlWWljZFkWqVQKy7Jwu93pfjObzUYymXzHPKJvAZcIIdYDn0aVMp0vhLgTuIzjxQpTQvvOVrwDKte8RV70I924clyU/O/3sBfns2K+mw27Mgk6bQ4byfD4LopQ1Er3Z8y/bD5dB7pY+cVMQvVx9XUWngKdG9T/0Ubo2pjhEYGSYNi4awQ5aaGleWHaAyYrZ/WoEu+BKDkTmh5SKqVZwyucpkNzoEhQh9PukVJJUcj+Qo/WboMdh3ontdZnoPBU8vRdBDqaxq2q2RU0+eV9Af7+2EZCei4LCnsNYddGZWhHQTAYHDIRvBtwLEpyJ4vKEgcLZrk4d6WPr1yRT0m+jcWzXWzeEycYsWjtMghG3tmgy8Cc7Pbt23noya08/JqbsuoVZOVNZ9UydZ22dZu4nRrL5rk5ac7QtoPLzi3iw5/8JAR343EJzj+1/77Pz7bx6lO/5LnnniOZTFJQUEA0GqXC24Dunc0lZ2VjGAZut5sPv6eAC0734/G4MPQkDkd/f1FfjsjrHsTiLyWnn376iIZISolpmmlD1FdQ4/F40jnEZDJJKpV6ZzwiKeUrwDrABdyKKlb4HjATOFtKuXlKo/o/jJ76Hg7ft43cJdXpbTaHDc3v5oQL+/tRPG5tSBJ30UcX8dSXnmLuB+aOeZ4rz8/mzYPKOAghWP755eTNzEu/HolZuF3juDyKz4Cd34HgXtj/c9CD4Mk0JNKIcmj/G2kqk8OHD2dWiWkOMFM0turMzjsKvkFNsMVnKJqcWKMqhx4G6dAcqJBeYBiRu2RXRv4KIC/LRnfIhM3XQem5sPj7aGevR+YshA1Xj/35UX0i2w8k8LY/gGvaqSw7eh50bVYMFCOEEvtwLCqO3gqUlJQck36qyWDOdCfTCu34vUoNdtEsFx88K4trLlHXZ3u3yROvRUdsSn47cO+zaiLWdZ329nbioUbeOGjx3BY1ifeJBMYSFm6nktS+bF32sMfKKj0BPBUIIfjCh/oXcQXZNoLBDi655BKam5vxeDzY7XYKXAF0U6OyRFV49m0XQuD1ONH1FB6PO8MjstlGbjr1+/0Zzwd7RFJKdF1P5009Hk/6WLFY7B31iJBSviqlPB3IBiqArF5mhZHkIY5jDJi6yau3vMqic8pwzcycwHKvWEnRvMzm0MEeS0FNARf96SIlQjcGCnJsBEIjryq37EuwbN44JBhsblh4M7xxAyz4Bqz47RAWgX379pHv6eTwURUy2LFjR6Yaau6JENxJY5tOmbspU/QuDak+8CgXfPpmyDs5HX7LQPyIasR15EJK9V0tmOlS9Cqdr4GvEopPg6zZypPJnjcmU4NlSfbVp2hsMzhxlg2XNw9x2n1K/lobnQhS9We8u3IdfZg+fToNDQ3v9DDQNEFeto0Z05y8/zQ/X7o8j3DMYuu+BP/7cM875hl19hg8+EKYf//5i1TPnE9clhIIm+kK0dICG7/4WgkpYwTi4MFwZMG+TBk3j1sj2xlk0aJF7NixAyEEHR2d5LmCGJY6pmma6dAbgNvtwjBSeDyeIaG5kTzcgQKSwJAcEajQYB9crn7PTtd1otHoO2eIBkAAHwRuEUJ8WwhxvGJukqh7vo4Fly0g253CXlk65v4uhxgixzxeCCEwR3lrfXOKWeXjlPYuWK48oUHeRh/i8TjTirM53BAgGAxSWVmZyWlWsBy6NhGOWniNEbweVyGY49QK8pQoozMQZgJ2fk8JzA0okHj/aX4ammPUm6th/k3p3d1uN/GSD8A/LoWWZ0c8VUuXwS13dWMTOovn+GHVXVCyBmZ+AhZ+a9Rh7t+/n+nTp4/vM73NmIh8+FuNK8/vDx3l+G0kUpJ51U4ONels3pPgoRfD3PlkkNauY1+OPxKicUltfQtdgTD/738luztP5sQad7okXQhBRbEd04TivOEasweh5hpwFkDdXRmbi3NUyLmPdio3N4ccdwKHUxkDr9eLYRjpaIDP60RPJfF6velwWZ9HNJoh6jNa0O8R6bqeZqPv0+nSNC2j2dowDCKRyNsXmhNC/FgIcWDQtixgG/Az4HLgO8B2IcScKY1qkhBCXCyE+F8hxCNCiHMHbPcJIbYKId7/ToxrvIh3xcmaloXR1Iq9fCif2mDMqXJysGnypawOu8hg/h0MbXBPUeyoKiIYhIP1rSTPGEFDB7VqW7FsEU1NTRw8eJDq6upMb8Bb3t+PZCaUlzUYNdfASf815mdKw1UE8QGSDq3rFQO2Kx8KVkLn6+mXbjxvD+U9v8sw6iUlJbTHfFD+PsWNN0K+KBSxKM6z8fvrOiF38Ziccn3QdZ2//vWvzJgxnPd3HAPhH4Zz8Fc3lvKT64vZfjDB/c+FaOs22Lynf6HyzIbJk7eOhXg8TrztBbTEXsoKnQghiBnZqom51JHuHcryadx6QwkXnD4OohlHNsy8CsL9U2wkEiEWi+FwOOju7k5v97q0tOHp0yDq84i8Hld6ex+cTiemaY4oL7JmzZoML6fPEDU1NfHggw8CpI2Ypmnk5ORw3XXXpfd/uz2iM4G7Bm37OjAH+IyUshDFrlDPJGQghBB/FEK0CyF2Ddp+nhBivxDikBBiKN3zAEgpH5ZSfgb4BMow9uEm4L6Jjumdgkym0DxDE5uDMa3IQcsUmjKXD1PwMCqSnSpsNQgNDQ0ji7n1orS0mJ5AB93d3RQWFg5TIiwQWEP7kvpgc4+qcDokxFV2LnS80v+8exvkn6z+d2SB3l+27Qu/yi21P+f9Xz2SNszFxcVs23WU+ztugFQA6+9z2LajJX2eeNLiP2/vZMOuODWVTgqMLcrAjRO6rrNo0aKMlei7DVlZWYRCobF3fJtxx3dV6NlmE8ytdrFwpos5lc4020hrlypAeasaYaPRKFp8N4nwUVy5czFNydxqJwtmurjgdD+fuVhVnto0wczyCer0JNoh2kQikeDGG28kEongdDozDNGCmZ60V+Lz+RTxaK9hmjtvPgsWLc8wRG63m927d/P888+nnw/ExRdf3J9fpf9e6iM2HQhN0/D7/dx6663cc889/d/H21isUA1sHbTtg8AeKeUfAaSUHcCPgdWTGMvtDGJkEELYgF8B7wXmA1f08tstEkI8NugxkKnzW73vQwhxNrAHePsbIyaLQauLRMrC5Rz6UxXn2dKrr8lgbpWTfQ1DPapgxCQYGSZuZ0QU0ekgRCKREfMJlmXR3d2NpmnYrCDSqbSJampqOHRoQP7F4SfHOjRmldlI5xgC34xM3jkznulpufJVqbllIpqfgspLmVet+qsONKbw+Xy8sTfA0xviHMj+OoYluOO+N6hr1nl6Q4TDR3Se3xzjzidDfOqiXPyydWi13yjQdf1d7w0N+Y3eJago7p8037faz3mn+ikvdpDjt2Gakj/8vYejHUaG9taxRGNLhA7tPEpqLsKXVUC2T+OKc7MpLVBKpXlZU1hcLPoe7P0RtVsfprHuAHV1dcybN68/TBrYTlbRrLQh8vv9JJPJtEe0fFEJM6un8a1v9YeFr7rqqoww6+AquVmzZnHBBRcMO5xUKnN+GGhw+ryoSCQyZY9oIqyJdiCdsRJC5APz6J3wB6AeGDvBMQhSypeFENWDNq8ADkkpa3vPeS9wkZTyv4AhYTahvo0fAk9KKfuy1Wei5MvnA3EhxBNSSmvQ+z5Lr+LsuzFm3xU001U4A2G3iSk19gkhcNpVD4x9AB3Nhl3xdE9HBoyo0sMZBI/HQ27u8P1H4XCY5uZmAK799CU8/JLywFwuV+ZFnr+UKuMRyBqBdXoUbNq0iYqKTPVZHP50QQKROnAPuiTLL4Qt1ynDt/CbXL4gh121Sd7Yn+C1HXEuXZdFZ49BfY/O/zy/nM+tvZvpzhf4+V+XsvNQkjOWeJhWZGdmuYOSPBt0TGxFqOt6xir03YicnByCwZEVfN8tOHmuWmC0dBq850tNOOyCpC7ZuCvO3U+H+PanCplVMTUF0T6EYxZ3P9lJV9iOzeHDY1ekrtnDMcVPBp4S8FWx56FvYOvp4YtXnsm/3/wNPnbRKtj3c9h2PY6zD+F0/h2AG264gbVr1/bngxwCh8OWcT8uWLAgneMBuPHGG7nhhhvSxsPhcGSQnw7EQI/I7XZnGKI+b/7t9ogOAGsHPO8zBE8P2q8Y6ObYoBwYSAV8pHfbSPgiiv/uUiHENQBSym9KKa8H7gb+d7AR6t3nd1LKZVLKZSP9IG8XpGUN8YgaW41hDdEQtD4H7ROTg6oodgzhXDvaYVBRPMwaxYgO6xE5nU7Ky8uHTYYmEgnWrVN6OVk+F+s3x9LhxI6ASU8vGWQqaylVxuOqgm4C2LdvHxs3bhzeu3AVqabSfT9VjbEDkT0H5t2oQnjl72dWhZMLT/eT0iWWlNzxRBAhBPOrnTS06NxwZxnT3I10B01mTHNQ36xTVebgkxfmZpDIjhf/DIZICIFpmu/ayr7BcNjBkpDsDa82thmce4qPvfWZq/o7nwzy2CvjzyGZplQl/qi2htbOKOG4EvtzOwWFubZjZ4gAStaxM3IS5546kwq24N75FRbzV9h2PVReijO7PH3teL1e1qxZw+mnn55+u6ZpGdeWpmkZhqiiogLLsvB6vRn7DIeBi0W3250RSu4rXLAs623NEd0K/JsQ4hdCiG8CtwB1wDOD9jsXGKoNMDkM9+lGvCuklL+QUi6VUl4jpbxt0Gu3SykfO0bjessgu3qwFWc2hD7yUpgZ08YxaYX2Q3D3hCaOudVOfvtgpqieYARa92FCc31hsZKSkrTnMxDxeByPp1+186tX5PPaDhUmaOkyaWpVF/rGgy5217wK7oktBLZs2cJVV101iKakF1Ufgj23gDNPaSgNRv4S1SzbCyEEn7ool9NO9FJWaGf1kkLWniRZvdiLJgS5Bfn8fu31nFwVpMb+PGcu9VKUa+vtTxo/O4KUkt/97nfvekMEMG3atGF/13cj1i338R/XFGK3QV62Ru3RFOeu9GW0KUgpefzVCD+5u3+tbJpy1DBebbPO137WxqGmFNf8sBVpJjGkk/xsG7l+G4trXONbKI4X+UsgdxHX/WQLX758IdTeruTg598Ecz6Pw+EYVSZE07SM+0EIkWGIBuaX+jDQwAzcPtAj8ng8QzyivnzTVD2icYfmpJS3CyHKgOuAXFS13HVS9repCyGKgItQza3HAkdQ6q99qAD+Oe6KScJqbcdRmdkHNLdaXfTDwekQJFIWbqcGiVawDFK6xDlY4nsEVBQ7mF3RPyFu2BnPiMFnYJjQ3J133onb7Wb16tVs2rSJyspMCp54PE5+fr9hLc6385WftdPYZhBOeGlu72FRjYcf/6Wb39w0sYhuHytBXl7e8Dt4KyCwbQjTw1j42HuzEULQ0BDHNOOcvKCQ95/mpzTnRlxNN/GZ5VZFAAAgAElEQVTxM1px9TTgOLH3u+isHZPKZyD6mnn/GQxRTU0NGzZsGF4t9l0Gu01wykIPZyzxsni2i+e3xMjPtmFakvufC3FijZuOgMHMaQ48A3p7Dh/VqWtOsWyeh/xsbcgizLIknT0mP7u3G69b4EzGMXGTl21jyRzXW9uQfMaD8Oa/waKbVXhZCGyQsbgbDJvNlmGIBntEfYZoJI9o7969LFy4kFAoNMQQDewnstls6TzR29pHJKX8LyllhZTSL6U8Q0q5c9DrHVLKUinlb6Y0qn5sBmqEEDOEEE7gw8Dfj9Gx33Y8+drw4YBkyuKVN3u7mVvasE/PnJBH+5HLCuy0dvWy6ia7QLOTTMRxjdMQgepHSqQU5c8DL4Q5Z+UIwnhGZIgh8vl8eL1enE7nsBLT8Xg8o0qnKM/GFz+Ux/NbohQX5dPa2oWUkovX+CkrnJjQW21tLfv27Rt9p3XPQ/nEqvb7vu/CwkI6OzupLnNw8lw308pyoPoj+FvuwGEMIEWNTMwQDZwU3u1wOBxDEtbvZmiaoDjPxgWn+/npV4rRNIFhwm8e6OGhF8P/v70zj5OrLPP996mlq7qru3rvdJbOvkEICZIECIskCIJgWAVhGBAZZRx0nFFnro7OdRl0xqt37mUcuMKMCuqMioqyiMKMbAJRiYAkJBAIZOkk9JL0Xt1d23v/OOdUn6o+tXVXdVV3v9/Ppz/ddda3Tled33me91k41hdj9WIf73zH2E24bzBGaETx0ycGxhXoveUfjzI0rBCBvQfDLG06isc1SqDSQ0PQXTQRShy3oh42/j8jEdt2LrvVkkqqa05EEsEKIpIQIvv30i5EVpFUyGwRuVyuhBCVquhpwRGRHwDbgVUi0i4iNyulosBHMeah9gD3KaVeKeU4J8poOM7X/8N56mz/0QjP/HGYeFwR7+jGsyBZiDK52ha2eo2inSNvGx1TW84h3vlbxyi7dLS1enngqUH+49G+zMl3kfGuuZaWFi6++OK0u8RisSSz3+MWLntnNT+8bT7vv6iNx547yo49I7mVE0qhr68vKZ/BEZcXln8o72OD8cRoZZknaDoDjjwCtkrGDL2VV7RfKBSiqanJ2Z1Yhvh8vmklnjdvq0NEEjfzzp4oa5f7ePVAmGf+OJxowW3lHfUNxhkeidPTH0vKJfv7u7roOB7j+7/sw+9zUV3pwhd+ldFYDetW+IwOvFOBQzv41LI8dtK55qw5HUuI7NskfUc9noSw2B9CnFxzJbGIiolS6lql1FyllNe0ur5lLn9EKbVSKbVMKfXlUo9zogwNK2rTTGge6ojym5dCHHg7mnMOkUXbHK9RvHRwvxGyXLOC+MCb+HMpK2KyboWPlno3H7+mgU9dn8WNNc5tkXmiMh6Pj3taEhEClS5qa4OsXxph+85hTliUParJLgpKKUZGRpLcC4XG8X25vLDkBuNJ1SI2Ap70rhI77e3tHD9+nG3bto3rBVOurFmzJrkkU5mT2pBweFRxzbtqON4XY8eeEfoG4sTicL/ZAqR3MMbPnhrkSHeU0KjiPx/tY+cbIzz7x2Hee3Y1L70+ytxGD411bjz+BoY8a1m3wk/lBB6eCkWmQrlOwQpWYqzP53O0Yux/ezweR4soNWrObhFNlrIRoplOOKqoqnQ5VjIYCSvee3a1UYstJfIsW+BBhVeIxJTZkK4JKudT0fkL5zmi6PC41twAwYCbLRsCBCrH+8dtAyFdnEgmIVJKpTXbRYQ1y3w88twQa5Zl/0A//fTTib8HBgZK1z7hlP9lJMTu/4HhDnWq9J2Gjo4OOjs7xyUVljP19fXjLcNpRE2Vi6XzK2iqc7N0vpfT11bS0x9j575RvvBvXQyG4hzri7H/SIRjvTEeeGqQO3/Sy7nvqOLiM6s5bY2fuU0eNi54GYn3c8baSrZsKN4DUCwWy+rqsucJpZLOIrKsoRUrVrBp06Zx1o3L5TLy/cy/IXuwwoxzzc10whHFyrYKHnGYJxoNx7nu3UFW977KsciYZaCU4sXXRgkGcnABxEJG+R2Xh6Gqd1AXf238Nl2/gWevg+OpeclZ6HkZ9n0r62ZO8wnZLKaaQAV3f7opKY/JiePHj9Pb25soDdTZ2Zk296GQVFRUJFcKtxh6Cw7+CJ7/CKz+q5yPF4lEGBwcnFZCBEbQwjPPPJN9wzKkbY6XZlOErnt3kDVLfXzs6nq2bghQYStzddpJRqWR808LML/Fw8JWD62NHv7x1hbmNXtoqokQqF/JNe8KTi5pNQvHjx9PCvBxIpNb18kiGhkZoaamhoqKCqqrq2ltbR1n3Xg8HrZu3ZpUMNX6Prvd7qJGzWkhmiLCEcXWDVWOFa9HIwqfV5hbE+X1hacklh89FuMr93RnLZro8wqRkUFwG09p3dWXUBtxiKAPHYYN3xhXWDEr/Xvg2O+N0jgZaGxsTCpFAs6uOTvNzc14VE/G48ZiMb7xjW8wPDzMM888w+23385LL700Pom1CDQ1NTnX6Dr7fggshfmXGtF5ORKNRhkaGsoYfluOLFy40DEYZTpw7QVB3G7h8nNr2LrBmOT3Vbg4aWkFJy3z0TMQ54y1lVy5pYad+0a54T21rGirIDQy5gE499Qq6moD1DUvyzkidSJ0dHTQ1dVFS0tL9o3T4GQRKaUIBAJJLSHs38sPfvCD+P1+Nm/e7Oia83g8SQJlnccSorKaIxKRPNt7zh7C0fQh1eGIwusRKjwuhm2TpW8dDnPOKVXMd0outdE2x0tPz0CiIGlPfAHV6tD4DYePGL2CKucm1VrLSt8eo+11mqZ0Fk1NTXR1dSVl42dyzYEhRF1dXRmPGwqFEjW19uzZQ19fH3PmzJmSOm1W5Nw4RKDlbCMhNg8sIZoOodupVFVVJapAT0dOXJLs/r3g9Gpa6j30DMT48keaqa12MzAUp8IrBKtdDITGvosL53gRMVzhxRSiBQsWcPDgwUkJkVP4NpAQIqsDr/17OXfu3CSXXGqwgiVE6Vxzqa0k8mVCQiQiHxGRv7W9Xi8i7cAxs8p18R9Vpxn23B6nsjzjKl0DoRHFlVtqWDIv89PzwlYvfX1jFlH/SBU+l0OUUzwMbp/RZ6c/S9izRd9uo1xOcJXR5ycDVkmYhx56aOyUWVxz9fX146yoVPbs2UMgEMDj8XD06FEgc/hqIck4vrbL807AjUQiBeloWQpOPfVUnnzyyZK0ES8W1VUuegeM99Pa6OGuzxgRq1U+V1IEXTgcRkTYempVYasopLB27VqeeOKJSbmdncK33W43S5Ys4Zvf/GbCQnIKIrK3joAxi+jiiy+mqakpbbDCnDnZuwVkHPME9/sYYJ/1/heMRNM/MY/5T5Ma1QzEEqJ5zZ6MFbOrK92JciLhqGEpOaJUojPe/GYPQ4OD4DYitwaH41RkMqJqTzAEJhe6t0PbVXDK143GcRmw+qZ0dnYmyv1kEyKXy5UxICMajbJjxw5qa2tZtGgRjY2NXHLJJRnDVwtJtvHlSzQanVZ5OXY8Hg9z587lxRdfLFkb8UKzalEFX/3o2E2/ym/cEqurXERtb7Gvr4+mpiZaGozCpsWipaWFPXv2FNw153a7WbRoEVu2bEksSxUiK1gBxgvR6tWr8fl840K+LSG66abcuhmnHfME91sIvAaJagpnAn+rlPoh8A/A1kmNagYSjigqPMLcJg9HMzTwmtvk5q0jxj8/ksGdx/7vQ8cTgNFXaHAoSp9ZYHd4VOHNJESBJUYh0FwYMhvVuXOb0zh8+DBbt25NCvfN5j8OBoP09vY6rhsZGaGnp4fq6mqi0Sg1NTW0tbVN6otaKI4cOcLXv/71vPax2i5PVzZu3EhPTw+7dhWqildp8XqE2urxLt53rPLx9zePNXq03MPFpr6+nr1792YNVshEqhBZAmMPkHESInvuVaoQWcewW1rlEKwwClh3pi1ACLCqbR7HKAGksWHNEc1t9HCkK70QtdR7jLwgxuaOHOndZQQQmKxoq+Ch3wyilOKRZwcRhyS4BC43GUr2jSePicjW1lZOPvnkhLDkMom5bNky3nzzTcd1o6OjRKNR2traOOmkk6irq6OlpSVtte9i4HK5HC2AY8eOce+99+Z1rIqKiuKWhCkybrebd73rXYm5QMtN197eTmdnJ2DU/zt27Fja/+l0QESMslkmoVCoqDlrAI8//jhHjx6lu7t7UvOfqZ8xyyK65JKxCiN268dpmTWXZFnv1jp7kI3dNVeqYIXfA7eKyBrgL4FfKZVINV/KDK8HNxEs11xTnXtctWs71VUu+gZjSfs44q6E0a6Ee25Og4dIVNHZEzNaK3trIZxqZRT/BnjZZZfhco3lI+Xi1qqvr087CW7Vtlq3bh0LFy5kzZo1hRtsjjQ0NDjOE6UN7c6Ax+PhE5/4RKGGVjICgQCPPfYYnZ2dRCIRnnnmGe655x4efPBBQqEQjz76KDt27GBgII+gmDKlp6eH++67L2N9t0LwyCOPsH379rSdVHMlNcnUEqIzzzwzaVmqeKTOEbnd7oRFZK1LZxFNZT8iO5/EqPm2E6NNwwdt664Bnp3UqGYgoRFFpU/MJy2jj5BTgIIdo09Qhg3qTzEqbteuBqC1ycO/P9DLzdvqYGiREelWMQnLIR4lL8tpEqT7II+MjNDQ0JD4gixfPr5DbLFpbm6mu7t73ASyx+PJ282mlCrrrqy5snHjRrq6unjqqadoaGhg8+bNbNmyhfr6+sRT8/DwMH/4wx8466yzSjzaydHT08MVV1wx6ciwbDQ1NREOh9m5c2f2jTPwkY98JOm1iIzLO8pmEfl8voQQWSIkIuOEqKmpib/4i7+YuurbdpRSu4HlItIIHFfJj72fAt6e1KhmIAOhODVVxj9rToOHzp4YrY3ZL3/GJ42GU6HnxYQQXbApQDDgMo+70BCi+vz6+yTRvwdqT5r4/uT+pFRZWeno/ujt7eWcc86Z1BgmS0NDg2On0ng8PiNEZSJ4PB62bdtGKBTirbfeoq2tbdz/2vqfdnd3l64KRgHo6+tjyZIlRXepWtfopJMm951zqpSeKkROc0T2GnMVFRV4PB5GRkYSYd1KqSRry6rC4Pf7S5tHpJQ6ZhchEalTSu00W4ZrbBjhksY/qz7oTiS22jVcmdaH3T2XkZoVMPB64qXbLZx5snkjD5gWkUU85lg8MSOhw3kla9rxer1EIpGcI85WrlzpWEm7r6+PdesmIaYFIF1l8dSCrrORqqoq1qxZk/ZGdN555/H8889P8agKS39/f9GtITDEYc+ePUU5di4WkdfrTSw766yzEp9tt9udEC77HJG9LFBJghV0HtHkaAi66TE7k9otJQDEyOJ+4OkMHSStm7vLAyrNfJOv2ZhDshh5O7k5nK8RhjvYvn17erEYPmokv06AmpqavOYHGhsbHdtSl+PEfldXF3feeWfeQhSNRqdNxe1C4Xa7qampyXsurZyYKss3HA4XLQgnF4vILkQXX3xx4j37fD7HqDlrmdN8U77oPKIpImbLAayrdtFjJtH1D8XH1ZJrrvMQi2WwJOIRIzEVYHznc4PUD0aoHSptzweNp8Gx3/Pkk0+mL/E/fMRoxjUBrACEfD6g06Ul9fDwMLfeeisdHR153aBCoVDRJ7zLkZNPPplHH310xuQeFYtito/PxSLyeDyJ76s9BNzn8yUCHlLniEpqEaHziPIiNBIn4B+71HU1bnpNi6h/KE6wOs9/Q2wY3GZOQPVSGNiXefsdfwmHH0pOSA0shtAh6urq6O8fX5EbMDuypr9xxuPxtPumizTLRHV1ddlGWbndbqJRw/oUERobG3nzzTfZtWtXoulYNrq7u2elEAWDQU4++WT2799f6qHkTTQanTKrfCqFKNsckTX/A2Oh3Jlcc6WyiHQeUR6895PttNq6j1Z4hUjUePrvH4w7lgzx+1zjukUmiI2MCVHtSRnK9ZgfDrcfDt6XPN/jb0aNdFFXV+ecTKqU0XsnA729vWmrSDs2lcvC3LlzefvtsTiXcnJlpV6na6+9NnFjtY85E1Zb9dlIW1sbe/funTZWL0BnZyf//M//zKJFi6bkfOFwuGjFcPOdI7IsIEgWonSuuVJZRDqPyMbQcNyxfpyFUqStoH28P+ZYUn7JXG+i1M844iPgMm9oVfMMF5pjmLUY/Yd8zbD8FvDang/ERTgSp62tjfb2doeB7TDmkTIQiUTSVsCeSGkcK0zaYnBwcMpK+WTDbuEppZgzZw5Hjx7llltuySvvYzZaRGA8Pa9evbpok/HF4MCBA7znPe9h4cKFU3K+crOIrH3q6oyOt9ddd11STbnKykoWL15cUovok8CJGHlEbcBnbetmXR7RnT/p4dHfjj39x+MqqXLv8gVe5jU5P9l3HI86itSKhRU0BNPMP0SHE3Xl8Lca0W3isG3lHKOXUGUrnPDJcfNGPd2HqBrcMT4fRil467tGJ9IMFPqL4/f7EwmsUL5CBMaXcGhoiDlz5uQsRK2trVMSfVWuLF68OGfrsRwYGhpizZo1UxYZWcygiHwtIrtrrqqqCpfLRVNTU5LFVl1dzeWXX166YAWl1G6l1HKgGVislNprW/0p82fWMKfRk1Qtob0ryq3/a+wLt/nkSuocrB6lFNGYc+Xtxlo3f3pRmnbAcZtrzuWBkaPOVaArFxj16ALOroXvvrgUNdxBa0NVcquDgdehYWPWZNhsroTJfjgHBgbKRoiqqqqSgjr8fj9DQ0M0NzfnLESrVq2a1UJkVX2eLiilyjJqcyLkaxGJSCJ53Ov1Jq6Dk2u5lMEKFj7gChH5kIhcKSLzZmMeUTyusGtJNKpwZ+k46nIJ//37EJvWpJ8zqK5K8++xzxEBjHSA36EMe3Cl0UW06czx64BNp5/FO86+gibXW8k9gXbdllMibDaLaKI3HWu/t99+e9Ll5YuBldgXCoVoaWnh2LFjtLe3c9ttt2Xdb7YTDAYdw/Q1xWUiFtFVV10FjAUlAHzmM58Zd+ySueZExC0idwIHgB8Dd5m/D4jIHZKx4ubMxP5/GBqO43WTCEhworXBzfN7hlm7zFYXKtcbVaoQDbzhbPXUrID528wip2nGHVxOLYfHbg5Dh2D/97I2wYPi+LRramoYHBzLoSrXvj1W+ZPGxkZ6enrYu3cvv/71r0s9rLJn1apV7N27N/uGJSYWi025NXT33XcX7di55hFZ79lyt1VXVycJlFPwUCmDFb6IUV/u74DFQKX5++/M5V+Y1KimIW6XEDVzf4ZGFKes8nM4Q5Xt+S1eDhyNjHfL5fLht4dvA6z+hHPTOnHB+q9kPpa3Dm+8NxGazB8/C+u+nOj2molsrjm325137ojV5bUcsYdwg+HTr6ioIB6P09nZSUtLi7Z6shAMBpMeNMqR7u5u7r77btraMvffKiSxWCzR9LEY5GIR1dXVMW/ePMDoFLtt2za6urqora1l2bJlaY9dymCFG4DPKaW+ppQ6qJQaNX9/Dfh74AOTGtU0pD44lhsUGomzbEEFb2eost02x0Nj7QQnJqMh8Nh6oyz7YF6tGpIQGUuKVQqGUxJfM5DNIqqqqso5x8bC3jq83PzzqQEL9soK27dvZ9GiRXzxi18s1fA0BeLQoUNcddVVLF26dMrOWezKE04WUer3a968eVxwwQWJ7Zubm/H7/TQ0NHD++eenPXYp54hagJfTrHvZXD+rqKka63E/NBxn2XwvR7qjxGLO80XBgJuv/MUEL1N0MFmIJou4DREaeB2W3AiLr8tpt1gsljHPJxAI5C1EE9lnqmhsbOTYsWMJqycWiyW+gHV1dVRVVaVtGHf06NEka2o2E4/Hy7rdeG9vL01NTVP6IGSPFi0GuVhE6SL2skXylbLEz17g/WnWvR+z6sJsoqbKRf+Q8eUaGIrTNsdL/1As0Zm1oEQHwVPAaLLaNUi4CzWwD2pWGpF4OZCtDXggEBjXGyUXlFLs27cvbY+iUtHY2JiwiEQkYRHZr0F7e7vj0+1DDz3EkSOzKr0uLYsXL+bgwYOlHoYjsVhsSqspWAwPD3PHHXcU7fi5zBFNVIhKaRHdBnxARP5bRP5cRC4XkVtE5L+BG831s4qagIsBU4jCthbfoxGFr6LQQjRUWCFq3kwgfoSh4wfzqradLbw1EAhMKPxaROjo6Ci7ltoVFRWJjpUwlvcxOjqKz+dDKUU4HKa9vZ1YLMahQ4cS286ZM6dsAy+mmra2tqRrU0688MILnHLKKVN+3pGRkaKG9qe60J3EI908UNlaREqp+4ALgQBwO/BTjMKnVcCFSqkfT2pU0xC7a85OaFRR5Su0EIXGEloLQdUC6tQheo/sTK7QnYVsQlRTU5NxkjMdHo+HY8eOlU15n3RYzcN6enqor68HjMn4gwcPJrp6WgSDQa6//vpSDbWsSNdWoxwYGBgoSe+kkZGRopZ/ShUTJ4voAx/4QE77plISi0hEvCJyJrBLKXUGRsRcK1CplNqslPqvSY1omhIMjLnm7AyPxPH7ivAkXGDXQd1J19PbcGnW+nJ2jB5L6d9bRUUFS5YsyX8sdXUcOXKkbHv9WHNEfr8ft9udiB4UERYuXMhvf/tbhoeHk6wnKL/gi1LicrnKrhp3KSMeh4eHiypEucwRpSMXISqFRRQDHgdOAFBKxZVSnUql60cwO6j0CcOjyZegIehm/9EIVf5C34AK/4WpnXsSfeHsIdtJoyjSF9fqyVKOFpHf72d0dNRo+e7343K5kqIHGxsbueuuuzhw4EDZPvWXA4sXL3bseltKStlJdmRkpKh1CHOZI0pHWbrmTMF5HSi/lPcS4vSP2LoxwH8+2k9lMSyiAjNRd0kxnvLr6+tpbm4uSyFqbGxMtKqorKxM5BZZQlRVVUVXVxf9/f3jLCLNGIsWLeLNN98sq7yrO++8c0pzh+wU2zVXbIuoVMEKnwX+p4isndTZZwj271IsPtYSvLrSRVwxMYuoBAZmvjeFYt1EAoEAp512Gg0NDUU5/mSwd5K1XHNWeXylFF6vl2g0qoUoCyLCunXreOmll0o9FMAIPNm8eXNirm+q+fKXvzyhCNNcSQ1WyMciuuWWWzKuL2VC6+eARuAlETkoIs+LyO/tP5Ma1TTCfjNWCj79r1001409QUSiCk+WunPjGDoIL/5Nhg2KM9dQLnMYIsL8+fPZuHFjqYcyjrq6OgYHBxOuOatrpf2LXlVVRX9/f5KFWS7XtpyYN28enZ2dRc+hyYWenp6S1jU888wzOfXUU4t2/MlYRPPnz8+4vhAlfibq+9hl/pQVInIZcDFGQu0dSqnHzLp3/wAEgR1KqXsLec6e/nhSu4bWRjfnnzaWbPpPtzYzpyHPy9z1LAztL9AIi8dsvLm63e5xwQoejyepTpclRNoiys6GDRv4zne+w+rVq9myZUvJxtHd3U1jY+b+W8XEXli0GExmjigbJbOIlFI3ZfvJ95gi8m0R6RSRXSnLLxSR10TkDRH5dJZx/Vwp9SGMEkPXmIsvBeYDEcChA1zu3PNwL+FIsjvqK/d00zbHeBqe0+ChpsqVZAEtaPHizTehNXwcmjZDr4PWH7ofmNVxIWWDFaxgt4iUUgkh6uvr49FHHy3xKMubxsZGzjvvPI4fP57ciqTAOHYhttHZ2VmyQIWpmCebjEWUjSkteioijSLyUxF5d4Zt3m1uM5HaNfdg5CbZj+cG7gAuwmjEd62InCgia0Xk4ZQf+zk/Z+4HsArYrpT6BPCRCYwrwS+fG6LHrCcXMwucvvDaKAtajH/y8rYK6tM1s0tHdNgoNGoiIhDuhcbTYOhAyrYh6HgSVkzqbaRFRMq69Eq5oJRCKZVkEdmLv1pC1N7ezvbt2xP7aJxZuXIlGzZs4Nvf/nbSdXrjjTc4cOBAhj1z5+mnnx4XjKOUYnh4mOHhYaLRaFHnaDJR7Ig5YJzITmeL6K8w2oA/lmGbx4AlGB1c80Ip9TRwPGXxJuANpdSbSqkw8EPgUrPn0SUpP51i8FXgl0qpF8xjtANWrZhJJS401Lo53mcc4l9/bBzy/RcEaTFdb8sXeLnojDwrCfS8BP2vQt+rY8viEaheDMOHk7ftfRmaz4LKuRN9CxlJ7ZCqcaayspJ4PD5ujshK8J07dy4DAwN0dnbS399f6uFOCxYtWsQ555zDCy+8wCuvvAIY5ZL+8Ic/FOQz2dvbm/hfWGL3k5/8hPvvv5/f/e53nHjiiZM+x0Tp6+ujtjZNE8wC8dd//ddJrwshHhZnn332pK3JfIToauCbKsOjnbnuLgx3WCGYD9hrgbSby9LxMeBdwFUi8ufmsvuBd4vIN4CnnXYSkQ+LyA4R2ZGpBUFjrZtjphC9/MYosZiiwmbxulySvpldOgZeh/nvhVBK7S1/KwyntFX+zVVQe0J+x8+DiVTLno0Eg0EikUgifNuaI7J43/veR39/f5IQzcb5tHxZv349brebPXv28Nhjj3H06FFOP/109u7dmygYa1mj+RKLxRJh90899RRvv/02oVCIq6++mtdff52WltLVaZ4KIUqlkBbRCSecMGmLLp+RLAJ257DdHozeRIXA6dubSQj/RSl1qlLqz5VS3zSXhZRSNyulPqaUcqwqqJS6Wym1QSm1obnZoeW2SV21iz6zekI8rjjYUYCExXgYqpdByG79KKPwqLIZcCoOS2+CuuJFzBdDiD7/+c8X9HjlgCVE5557LtXV1UnBCkopLr/8cnp7ezl27Fji5qfJjt/vZ/369SxYsAC/309jYyMtLS08+eSTPPHEEyil+NWvfsVbb72V13GVUsyZM4dDhw7x8ssv093dzb333suGDRvwer3cdNNNJX1QKIUQFXKOqBDkM5JhjMizbFSb2xaCdsCeYbYAKFkJ40Cli0GzntzSBRW8cagAQqQiEFgIw/a35fClOPoYzClcVJFT5exiCNGXvvSlgh6vHPD7/USjUTZt2oTP50u45jweD9FolGNZk94AABlYSURBVLq6usTEeyAQ0PNueXL66adzzjnncP755+PxeFi/fj1Lly7l2WefZdeuXUk9oXIhFArR1NREd3c3e/bswefzsWXLFlatWgWUvoLHdLeICkE+I3kB2JbDdpea2xaC54EVIrJERCowWkw8WKBj541VxiceV8ypH3PTTYp4FNwBiI9mrtwTOgTBlZM/n4m9qZtFqhB1dHTw9NOO3sxZTWpJE8siqq6upr+/H5fLlZjXmDdvHp/73OfKtu1BOWNd43POOYdly5axe/dubrzxxrytzP7+foLBINu2bWPevHn4/X42bdpUcgGy0BZRfkJ0B3CziNyYbgMRuQG4CfjXfAciIj8AtgOrRKRdRG5WSkWBjwKPYrj87lNKvZLvsQvNaFgRrHYzNBx3bHqXF/GIWWjUOk6a440eg4rC5TnkIkThcJjXXpt1raXyxrKI1q5dy+7dhvfayiHyeDwcOHBAB4EUgOXLl9Pc3My+fft4++23s+9gYgmR2+2mpqam7Irp9vb2znqLKOdHAqXU/SJyO/AdEfko8CvgIMZz/ELg3cAG4P8opX6W70CUUtemWf4I8Ei+xysmw6OKSp/Q06/yD05IRUUyVLy2iVJsGDyFC/G0eunY8Xq9SSGusViMI0eO8OKLL5akR0u5Yu/Qag9W2LJlCxs2bACM1s+33347XV1dRKPRsqs0PR3ZunUrANu2bePw4cO0tubWsqS/vz9RHaCmpqbsOuX29fUlCv1OFS0tLWUlRHmNRCn1SQzXWz/wKYwIubuBvwEGMEKrP1XoQZYbodE4VT4XI6NjDfAmTDzqIETFzzlxsohSCYfD3HDDDXrC3QGfz0dHRwcwZhG5XK7Ek+369eu58sorGRgYIBaL5fUEr8lMU1NTot5fLgwNDREIGNVO5s6dO6HWJMVkcHBwQg0kJ8Ott946fYUIQCn1kFLqPKAGmGv+1Cil3qWUerjQAyxHBkJxagIuqqtceCZr5ccjIOkMU5Xm78mTTojscx+RSIRAIKCf5h2orKxMJFteffXV4/IoHn74YebPn08sFqO3t5cf/ehHpRjmjMTlcuUUAPLzn/88Ee5tL79UylI+TmTr6zUbmPBsnTl/01HAsUwbBobiBAMu/uzSWgqSMC9C8txQ8UNJc7WIrPbYpZhQLWfcbjfDw0Zw6Ny56ROMY7EYXq+37OYlZjovvPACe/bsYfHixbqqxTRgdsvwBBkIxampcpkTfoUUDZX821UBsVFzWWHFKR8h6u3t5Te/+U1Bzz+dSa64nvkmF41Gqaio0CJeYHw+H6Ojo2nXt7e309DQwAMPPMC8efOmcGSaiaCFaAL0mxZRQfFUIa6Uas3eWoj0G/NIad13EyMWi2V1B1idRy+88EKCwVxSyGYPIpLITcmEVcNsqiejZzp1dXUZ54lGR0dpbW3lyiuvZPXq1VM4Ms1E0EKUJ/4KF/uPRCYfLZeKpxqXK8X6qaiFSB9EB8BbU9DT2dtb27EXPo1EIng8Hmpra3VSpgO5tLuOxWIEAgFtERWYefPmsXfv3rTrPR4PGzZsYM2aNVM4Ks1E0UKUI7G4MeG5boWP+S0e3AV1yWEIkdsSItPd4zWFKDJ1QlRZWZmY+7AnbnZ3d7Njx46CjmG6YrnjgsEgIsKhQ4fSbltZWcmJJ57IsmXLpmp4s4L6+nrC4TBDQ0Pj1oXDYfx+P/Pnz9c1/qYJWohyJBxR+LzCCUt8vO+8wooCAF67RWQtq4Vwn+Ge80yNENmTWu3zH+FwOKkk/8DAAC+//HJBxzSdsG5wp512Gq+++mra7SorK2ltbS2bLP6ZxIoVKzhyZHzFr1dffZVdu8qub6cmA1qIciQcGcsZKspTlqcal3vEKG4q5r/FG7RZRIWdo8lFiOxs3bqV+vr6RCh3f38/PT0947abbYhIRpFxu92JPjc6equwVFdXJyyizs5OXnnlFeLxOPv27WPTpk0lHl1uaJe3gRaiDPzov4wS/jvfGGE0rPBVFNHM9wRMiyg2luBagjmidELU2tpKQ0NDoq2BfsIfw+PxOLYFHxwcJBAIJKovlFtG/3QnEAgkhOjw4cM8++yz7Ny5k9WrV/POd76zxKPLjYMHD7Jw4cJSD6PkaCHKwO63Ruk8HuVr3z9O72AcfyGFKPXpODFHFAUxw6qtqLnIQElcc6nU1dUlrKDZLESpls26det4/vnnx2134MAB+vv7cbvduulgEbBy3Do6OnjwwQe54oorePzxx8uuckImdu/eXdKmfOWCFqI0xOKKw11RegfjLGz18on/28HcpgLefJ98D/S/PvbaU43LNYKoeLIQWXNEJXbNgTFB3NvbC2g3k909GwwGGR0dHVeBIhQKJVx3fr8/Y96LZuLs27eP1atX09jYyMc//nH8fn+ph5QzPT09NDQ0lHoYJUcLURoGQ3H6h+KEI4ql840b9vzmAgpRqB2ig2OvExZRbCxnyOUBFTWEqKKw4b/RaNTRqsnkQqqpqRnXbllj4HK5uPPOO5Pq8lm5WpZFZEUjagpHZ2cnHR0dXHnllWVXUToXQqEQVVVVpR5GyZm9/pUs9A/FqfAKoxHFuhV+LjunhtrqApZpqag15n4svIZFZAhRynmKEDVnr7+VKy6XKyFAWoiSaW5uJhgMcvToUWpqjP+VVb3C7XZTUVGRVNlcUxhOPfVU+vr6pq2reHh4WAsRWojSMhpW1Ne46B+MMbfJQ0NtgWuFeYLG3I+Fy4/LFcFRiFTMsI4KSDYRcurgmjSkPIRoIqJXzji995UrV1JfX8++fftYudJoYGhvE6GDFYrD8uXLSz2ESREKhaisLFx7l+nK9LJjp5BITNFY66a7L1acaDlvTYoQuQGFEC+46EyEbC4DpVSitH4m7JUaZhKpwur1epk3b17SPJDV88kSo2eeeYYf//jHUz1UTRkzMjIyrea0ioUWojREooqGoJuuntjkew6louJG8EHUoc+PcrCIphgRYXBwMOFismM1z1NKcckll2Q9ltvtnlVtJJqbm9m/f3/itV2IHn74YV588cXSDU5Tlswkb8FE0UKUhmgUGoJuuntj+AotRNEh8LcmW0QWEit4gdN8UUpx/Phxx2geK3cjV3fbTBSiTG7JNWvWJEr+KKWSXHORSISKioqpGqZmGqDnWg20EKUhElM01rnp6o3iqyjwZYqNgq8pOWrORJzmiKYYl8vFsWPHqK+vH7fOCu/OR4j6+/v53ve+V4yhlox0793j8SQJr90imokuSo2mEGghSkM0qmgslkUUD4On0nDRpVIGrjm/309/f7/j0/tELKJQKER7e3sxhlqWWE+5IpIkRDpYQZOKdssZaCFKgzVH1DcUxztZT1mq4MTDRtM7R0ofrFBZWZk2+XIiFtHo6OisTea0u+Ysi0i7YzQW+rNgoIUoDZEoVPqEBc2eyT219L4CT703eVlCiJw+hNEUi2jqn5gyJV9apWryEaJwOOxYi226ku3mYb8udovI6/Vm7Syq0cxGtBA58K0HeonGFB6PsGzBJCeXB/cxTkwyWERJJX7AKIAan9qbeGVlZdq6aFapmtluEeX6cJIqRPZCnRqNds0ZaCFy4D8e7Sc0EsfrFm54zyRL6wwfhqr5ycsyuuZSouZiw+Ce2oS3YDCYtsWDy+UiHo/nLEQulythEc2mORKl1LioOa/XS0VFBbt37y718DRlgnbNGWghcmB+s4dDHVG8Xpl8odNUCwcyC1FqsEK4FyrqJjeGPKmtreWiiy7KuI1SKqe6XiJCNBpldHSUr3zlK4UaYlkTCATo7u4GxltEV111FTfeeCOHDx8u8Sg1mvJBC1EKhzujzGv2cODtCJ6CBK/J+JYP2YIV7EJUswLqTirEQPJizZo1GdfnahFZQhQOh9NW9Z5uZHuKPfnkk9m7dy9giJLP50sIUVNTE2+99ZYWIg2gXXMWpa8lU2YMjcRpCLrZuW8Ur6dAH5LUD1tsNK27TYgmR82t/nhhxlBg8hWi0dHRGVX0M9N7r6io4PDhw9TU1HD99dcjIvT29ibabmzcuFH3JtIA2jVnoS0iB5rq3PQOxHAX5Oo4fNAyuuYcXHllhjX/kasQRSKRGRc5lwkRYc+ePQSDwcQ1siwigDvuuCPRTkOj0WghcqS+xk1ttbuAZrND1JzbZwiOSi1/U/oSP7kwEYtopghRLk+xTU1NbN68OfHaLkTBYJDt27cXbXya6UE8Hp92/ZOKhb4KDlT6hGXzx3cvnRBONy3LInL7IZ4c1lwOJX5yYbZbRNnee0NDQ9I2qUI0WwI3NOnp7++ntrawDS+nK1qIHPBVCO8+PXuLg9xJl0ck4+eKpoFrDvQcUTZS6/SlCpFG09PTQ13d1EbElivl7wMqAc11btYuL1SPkAwW0aqPOcwVFb4JXqGxKknnYxHFYrEZZRFlY+vWrUmv7UIUCAS47bbbdC+aWU5vb68WIpMZZRGJyGUi8m8i8oCIXGAuWygiD4rIt0Xk09mO4XbBCUt8hR7Y2N8j3RANjbnmJPVfUP6uOasEUD4WkdvtnjEWUS5zRKkFY+1CBDBnzhw6OzsLPjbN9KGnp8exwv1spGyEyBSKThHZlbL8QhF5TUTeyCYkSqmfK6U+BHwAuMZcvBL4hVLqg8CJ2cZRV+PG4y5kbH/KTWv/92BgL7jTlfiZeUIUiUTweDwzyiLKN5AlVYjOO+88fvnLXxZ6WJppRG9vr54jMikbIQLuAS60LxARN3AHcBGGiFwrIieKyFoReTjlp8W26+fM/QBeBN4vIo8DTxT9XThiu2mFDsNod+4lfsoQn883qy2iiVBVVcWWLVsSrxcvXszRo0dLOCJNqQmHw9o1a1I2QqSUeho4nrJ4E/CGUupNpVQY+CFwqVJqp1LqkpSfTjH4KvBLpdQL5jFuAj6vlNoKXDxFb8a5+2q4D17935mFSEWM0O4yxqrAnWutuUgkkqjCPVvxeDycccYZidc6o14TjUbxeMr7oXOqkHLK7BWRxcDDSqmTzNdXARcqpf7MfP2nwGlKqY+m2f8vgRuB54GXlFLfFJGTgC8A3cCgUupTDvt9GPiw+XIN8MoE30It0DeF+wEsBA5O8TlL8T71NSrevhO9PpM5Z6k+C/oaFe+ca5RSE6vQbGXJl8MPsBjYZXv9PuDfba//FPhGkcdw91TvO8lzds2S96mvUfHOOaHrM93ep75GRT/nhK9R2bjm0tAOtNleLwCOFPmcD5Vg38mcs7cE5yzF+9TXqHj7TvT6TOacpfos6GtUvHNO+BqVu2vOA+wFzgMOY7jcrlNKTdR1NuMQkR1KqQ2lHkc5o69RZvT1yY6+RtmZzDUqG4tIRH4AbAdWiUi7iNyslIoCHwUeBfYA92kRGsfdpR7ANEBfo8zo65MdfY2yM+FrVFYWkUaj0WhmH2VjEWk0Go1mdqKFaBqQruqEbb2IyL+Y1SdeFpF3TPUYS4mItInIEyKyR0ReEZFx3QT1NRK/iPxeRP5oXqMvOmzjE5Efmdfod+ac7axDRNwi8qKIPOywbtZfIxHZLyI7ReQlEdnhsD7v75oWounBPaRUnUjhImCF+fNh4P9NwZjKiSjwSaXUCcDpwK0iklrOabZfo1Fgq1JqHbAeuFBETk/Z5magRym1HPg/wFeneIzlwscx5qSd0NfIYItSan2a4IS8v2taiKYByrnqhJ1Lge8qg98CdSIyd2pGV3qUUkeVWUlDKTWAcROZn7LZbL9GSik1aL70mj+pE8SXAveaf/8EOE9mWQkIEVmAUYHl39NsMuuvUQ7k/V3TQjQzmA8csr1uZ/yNeFZgukpOAX6XsmrWXyPT5fQS0An8l1Iq7TUyI1b7gMapHWXJ+b/A3wLxNOv1NTIeYB4TkT+YVWlSyfu7poVoZuD0RDbrwiFFpBr4KfBXSqn+1NUOu8yqa6SUiiml1mMkhm8yy1/ZmdXXSEQuATqVUn/ItJnDsllzjUzOVEq9A8MFd6uInJOyPu9rpIVoZlCKChRlhYh4MUToP5RS9ztsMuuvkYVSqhd4kvHzjolrZCaT15LZJTzTOBPYJiL7MQosbxWR76dsM9uvEUqpI+bvTuBnGMWp7eT9XdNCNDN4ELjBjFY5HehTSs2aHgOmj/5bwB6l1D+n2Wy2X6NmEakz/64E3gW8mrLZgxhFgwGuAh5XsyjRUCn1GaXUAqXUYuD9GO//+pTNZvU1EpGAiNRYfwMXAKnRvHl/13QN8mmAWXXiXKBJRNqBz2NMNqOU+ibwCPAe4A0ghNH6YjZxJkZB3J3mHAjA32FUTNbXyGAucK8YPb5cGFVKHhaRLwE7lFIPYoj590TkDYyn/PeXbrjlg75GScwBfmbGZ3iA/1RK/UpE/hwm/l3TlRU0Go1GU1K0a06j0Wg0JUULkUaj0WhKihYijUaj0ZQULUQajUajKSlaiDQajUZTUrQQaTQajaakaCHSaDQaTUnRQqSZNojIzSKizArJ9uVfNZdfn7L8fHP55qkdKYjIPU69Wqbw/FeLyAcclk94XGam/B9F5MbsWxcGEblDRL41VefTlAYtRJrpxHPm71Rh2YyRwe20fBTIVMRypnI18IEiHLMe+M8CHzcTXwP+RESWT+E5NVOMFiLNdOJVjLIqCcExi52eCnwXZyHaoZQanbIRzmz+EvieUioyVSdUSu0HngE+MlXn1Ew9Wog00wazuOR2kgXnFIyy83cCa20FGV3AaZhWlIicISIPisgRERky2xz/if34InKTiIxaxUFty9eYLr7zzNdnichTIhISkWMi8m/WeTORbT/LbWa6FF82x/mMiKxxONZHReSQuc3PReQ8c4znisg9wJXAO81lSkS+kLJ/1nOkbL8c47r/xLbsSRH5Scp255rnO8m2zHpfF4vIbvP9/0JEGkRkuRht3ofMbU52OP1PMawifb+aoeh/rGa68Ryw3qwgDXAGhuttF9CLIT4AazBK9D9rvl5k/v1nwHsxbm7fEZFrbce22kdcnnLOazCayT0pImcCvwbexqi+/FcYBR6/k2nQeey3EMMd9WXgWqAFuE9krAuoiFwOfAOjyvHlwMsYxTgt/gF4AngR4/qcQXLH0azncOA8YAj4Y6b3mYGFwJeAz2G0j94M3I3RbuGHGNfEA/zQYRzPYRTbXDvBc2vKHF19WzPdeA6j8vhG4GmMG9p2pZQSkd+ar/+bMavpOQCl1A+tA5g3uqcx+qR8CPiBuU2fiPwKQ3jsAnEN8GOlVExE/gl4Til1je14h4Ffi8hJSqnUkvgWue7XgNF47HVzGxdGz5dVjLVt+DvgEaXUrebrx0SkCdN9pZTaJyLHAZfZqjmVXM6RyqkYbTbSdS7NRgNwhlJqn3nOk4G/AW5USn3XXCbAL4DVGO3eLV4BYhh9byYqhJoyRltEmunG74EoY0KzGcNdB/DblOWvK6W6AESkXkT+RUQOABHz58PAypTj/wg4z7yxIyLrzW1+JCJVGNbFfSLisX4w5jAiGDfrceS5335LIEx2m78XmMdyA+sxrCE7qa8zkfEcaWgFuvM4h9M599lev2H+ftxhWVJbabMld685Bs0MRAuRZlqhlAoBLwGbxQjjXsCYEG0HTjef8Dcz5pYDuAfDsvkaRjOvjcC3AX/KKR7EEIcrzNfXAIcxRKMecGPMR0VsP6MYVlobzuSzX2/KvmHztzXOZgxPRlfKdqmvM5HtHE74McY7UdKds9dhmdM4RtMs18wAtGtOMx15DrgOQ2z227o//g6oAd4JLAe+CiAifuBi4KNm4y7M5eMexJRSgyLyCwwBuhsjZPk+0/XXCyjgCxjNv1JJ1w55ovs50YVhETanLE99XWiO42yRpN5DAkU6fx2zrCX3bEILkWY68ixGKPGNjFlDKKUGROQV4FPmIivvyIdhkSSe6M1otW0YApHKDzFcce8FlpqvUUoNmfNQq5RSX8p1sBPdL82xYmJ0ob0UuMu2alvKpmEKa0G8huFeTGVVyusNBTwnYLQ5B6qAvYU+tqY80EKkmY5YLreLgI+nrNuOEYDQgznhbQYhPA/8TxHpB+LAp4E+IOhw/F9gJMjeBbyllPq9bd3fYgQYxDFCmQcwIsIuBj6rlEp3s5zofk58BbhfRP4Vw5V4pnkczPcGRtDBpSJyGdAOHFFK5WN5pfIsxvVrtubdTFaa4/gZcCLGAwLAJSLSkbLtRNmA8cDwXLYNNdMTPUekmXYopQ4DBzHyh7anrN5uLTfzjiyuA97CSHy9HSN8+7tpjj+CcYOfixG8YF/3DHAOhivse8BDGCJzCOjIMOYJ7ZfmWD/DuOFfBvwcY77LsgL7zd93Ao9hzIM9jxGYMRmexHCNXZiy/BGM9/QwxkPBtRjh9J/ACJ8vBBcCTymljhXoeJoyQ5K/qxqNZjoiIp8DPgs0KKWGi3SO24HlSqmLzddPAt1KqauKcT7zHG7gAPBppdT3i3UeTWnRrjmNZpphzpl8BiNpNQScDfwP4FvFEiGTrwGvicjKPF2Jk+F9wDDmPJ1mZqKFSKOZfoQxkj5vwHB/HcVwN/59MU+qlGoXkZsxXJZTJUQC3GzmEmlmKNo1p9FoNJqSooMVNBqNRlNStBBpNBqNpqRoIdJoNBpNSdFCpNFoNJqSooVIo9FoNCVFC5FGo9FoSooWIo1Go9GUFC1EGo1Goykp/x/hbU9YpSy0ogAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -111,22 +99,481 @@
     "#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended\n",
     "  \n",
     "# Extract desired cross sections from the database\n",
-    "cross_sections = demo.Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)\n",
-    "\n",
+    "cross_sections = demo.Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_wl) / Units: (m^2 / species)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "# Example: seperate H2O cross section, and print to terminal\n",
-    "H2O_cross_section = cross_sections[np.where(chemical_species=='H2O')[0][0],:]    # Format: np array(N_wl) / Units: (m^2 / molecule)\n",
-    "#print (H2O_cross_section)\n",
+    "H2O_cross_section = cross_sections['H2O']    # Format: np array(N_wl) / Units: (m^2 / molecule)\n",
+    "#print (H2O_cross_section)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copy/paste plot function from opacity_demo.py because I'm getting some weird errors\n",
+    "\n",
+    "def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, **kwargs):\n",
+    "\n",
+    "    # Max number of species this can plot is 9 (clustered beyond that!)                                                                                                  \n",
+    "\n",
+    "    # Optional smoothing of cross sections (can improve clarity)                                                                                                         \n",
+    "    smooth = False\n",
+    "    smooth_factor = 5\n",
+    "\n",
+    "    # Specify cross sections to plot, along with colours for each                                                                                                        \n",
+    "    #colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])                                             \n",
+    "\n",
+    "    # Initialise plot                                                                                                                                                    \n",
+    "    #ax = plt.gca()\n",
+    "    #ax.set_xscale(\"log\")                                                                                                                                                \n",
+    "\n",
+    "    ax = plt.subplot(111)\n",
+    "    #xmajorLocator   = MultipleLocator(1.0)\n",
+    "    #xmajorFormatter = FormatStrFormatter('%.1f')\n",
+    "    #xminorLocator   = MultipleLocator(0.2)\n",
+    "\n",
+    "    #ax.xaxis.set_major_locator(xmajorLocator)\n",
+    "    #ax.xaxis.set_major_formatter(xmajorFormatter)\n",
+    "    #ax.xaxis.set_minor_locator(xminorLocator)\n",
+    "\n",
+    "    # Plot each cross section                                                                                                                                            \n",
+    "    for species in chemical_species:\n",
+    "        #species_idx = np.where(chemical_species == species)[0][0]\n",
+    "        sigma_plt = sigma_stored[species]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)                                                          \n",
+    "\n",
+    "        if (smooth == True):\n",
+    "            sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')\n",
+    "\n",
+    "        # Plot cross section                                                                                                                                             \n",
+    "        plt.semilogy(wl_grid, sigma_plt, label = species, **kwargs)\n",
+    "\n",
+    "    plt.ylim([1.0e-28, 2.0e-18])\n",
+    "    plt.xlim([min(wl_grid), max(wl_grid)])\n",
+    "    plt.ylabel(r'$\\mathrm{Cross \\, \\, Section \\, \\, (cm^{2})}$', fontsize = 15)\n",
+    "    plt.xlabel(r'$\\mathrm{Wavelength} \\; \\mathrm{(\\mu m)}$', fontsize = 15)\n",
+    "\n",
+    "    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\\mathrm{T = }$' + str(T) + r'$\\mathrm{K \\, \\, P = }$' + str(P*1000) + r'$\\mathrm{mbar}$'), fontsize = 14)\n",
     "\n",
+    "    legend = plt.legend(loc='upper right', frameon=False, prop={'size':6}, ncol=2)\n",
+    "\n",
+    "    '''for legline in legend.legendHandles:\n",
+    "        legline.set_linewidth(1.0)'''\n",
+    "    return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
     "# Plot cross sections\n",
-    "demo.plot_opacity(chemical_species, cross_sections, P, T, wl)"
+    "plot_opacity(chemical_species, cross_sections, P, T, wl, lw=0.5, alpha=0.8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Grab all the opacities possible\n",
+    "\n",
+    "Based on gases present both in Ryan's library and in the static weather output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Grabbed from Readme.txt\n",
+    "RMcD_gas = np.array(['H3+', 'Na', 'K', 'Li', 'Rb', 'Cs', 'H2', 'H2O', 'CH4', 'NH3', 'HCN', 'CO', \\\n",
+    "                     'CO2', 'C2H2', 'H2S', 'N2', 'O2', 'O3', 'OH', 'NO', 'SO2', 'PH3', 'TiO', 'VO', \\\n",
+    "                     'ALO', 'SiO', 'CaO', 'TiH', 'CrH', 'FeH', 'ScH', 'AlH', 'SiH', 'BeH', 'CaH', \\\n",
+    "                     'MgH', 'LiH', 'SiH', 'CH', 'SH', 'NH'])\n",
+    "\n",
+    "RMcD_gas_upper = np.array([g.upper() for g in RMcD_gas])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False,  True, False, False, False, False,\n",
+       "       False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False, False])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.array(RMcD_gas_upper) == 'TIO'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/liac/dev/cloudacademyMap\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd .."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from maplib import load_out3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/liac/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd ~/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# An example file to work from. I hope all of the reported columns are the same\n",
+    "PHI, THETA = -180, 0\n",
+    "\n",
+    "# Get gas information\n",
+    "thermo = load_out3('thermo', PHI, THETA)\n",
+    "\n",
+    "# Get wavelengths for later\n",
+    "wavel = load_out3('wavel', PHI, THETA)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO', 'TIO2', 'TIS', 'SIO', 'SIS', 'SIH', 'H2O', 'H2', 'H2S', 'MGH', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FEH', 'FE(OH)2', 'ALOH', 'ALH', 'AL2O', 'ALO2H', 'CAO', 'CA(OH)2', 'CAS', 'CAOH', 'CAH', 'C2', 'C3', 'C2H', 'C2H2', 'CH4']\n"
+     ]
+    }
+   ],
+   "source": [
+    "thermo_gas = []\n",
+    "for k in thermo.keys():\n",
+    "    x = k.split('n_')\n",
+    "    if len(x) == 2:\n",
+    "        thermo_gas.append(x[1])\n",
+    "print(thermo_gas)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Gases in static_weather model that are also in Ryan's opacity library\n",
+    "gases, gases_missing = [], []\n",
+    "for g in thermo_gas:\n",
+    "    if g in RMcD_gas_upper:\n",
+    "        ig = np.where(RMcD_gas_upper == g)[0]\n",
+    "        gases.append(RMcD_gas[ig][0])\n",
+    "    else:\n",
+    "        gases_missing.append(g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gases in both static_weather and Ryan's opacity library: (13 total)\n",
+      "['TiO', 'SiO', 'SiH', 'H2O', 'H2', 'H2S', 'MgH', 'FeH', 'AlH', 'CaO', 'CaH', 'C2H2', 'CH4']\n",
+      "\n",
+      "Gases missing opacities: (25 total)\n",
+      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO2', 'TIS', 'SIS', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FE(OH)2', 'ALOH', 'AL2O', 'ALO2H', 'CA(OH)2', 'CAS', 'CAOH', 'C2', 'C3', 'C2H']\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Gases in both static_weather and Ryan's opacity library: ({} total)\".format(len(gases)))\n",
+    "print(gases)\n",
+    "print(\"\\nGases missing opacities: ({} total)\".format(len(gases_missing)))\n",
+    "print(gases_missing)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/liac/dev/cloudacademyMap/gas_opac\n"
+     ]
+    }
+   ],
+   "source": [
+    "cd ~/dev/cloudacademyMap/gas_opac"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Takes a few minutes to read in**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Now reading in cross sections\n",
+      "TiO done\n",
+      "SiO done\n",
+      "SiH done\n",
+      "H2O done\n",
+      "H2 done\n",
+      "H2S done\n",
+      "MgH done\n",
+      "FeH done\n",
+      "AlH done\n",
+      "CaO done\n",
+      "CaH done\n",
+      "C2H2 done\n",
+      "CH4 done\n",
+      "CPU times: user 1min 19s, sys: 27.4 s, total: 1min 46s\n",
+      "Wall time: 2min 12s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "sw_xsects = demo.Extract_opacity(np.array(gases), P, T, wavel, opacity_treatment)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.2, 330)"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_opacity(np.array(gases), sw_xsects, P, T, wavel, marker='o', ls=':', alpha=0.5)\n",
+    "plt.semilogx()\n",
+    "plt.xlim(0.2, 330)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "304"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(thermo['p'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## To do next\n",
+    "\n",
+    "* Load opacities for different temperatures. Interpolate densities in each vertical profile to match the temperatures provided in the code.\n",
+    "\n",
+    "* Calculate dtau_dz for each element and vertical profile.\n",
+    "\n",
+    "* Save the dtau_dz profiles to a file.\n",
+    "\n",
+    "* Add those dtau_dz values to the atmosphere depth calculation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Look at densities as a function of temperature"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(500, 3000)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for g in gases:\n",
+    "    plt.plot(thermo['T'], thermo['n_' + g.upper()])\n",
+    "plt.semilogy()\n",
+    "plt.xlim(500, 3000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Sanity check for pressure, temperature interpolation\n",
+    "# Suggested by Ryan\n",
+    "\n",
+    "T0 = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500]\n",
+    "T1 = np.arange(100, 3000, 50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Now reading in cross sections\n"
+     ]
+    },
+    {
+     "ename": "TypingError",
+     "evalue": "Failed in nopython mode pipeline (step: nopython frontend)\nInvalid use of < with parameters (reflected list(int64), float64)\nKnown signatures:\n * (bool, bool) -> bool\n * (int8, int8) -> bool\n * (int16, int16) -> bool\n * (int32, int32) -> bool\n * (int64, int64) -> bool\n * (uint8, uint8) -> bool\n * (uint16, uint16) -> bool\n * (uint32, uint32) -> bool\n * (uint64, uint64) -> bool\n * (float32, float32) -> bool\n * (float64, float64) -> bool\n * parameterized\n[1] During: typing of intrinsic-call at /home/liac/dev/cloudacademyMap/gas_opac/opacity_demo.py (150)\n\nFile \"opacity_demo.py\", line 150:\ndef T_interpolation_init(T_grid, T):\n    <source elided>\n        \n    if (T < T_grid[0]):   # If temperature falls off LHS of temperaure grid\n    ^\n\nThis is not usually a problem with Numba itself but instead often caused by\nthe use of unsupported features or an issue in resolving types.\n\nTo see Python/NumPy features supported by the latest release of Numba visit:\nhttp://numba.pydata.org/numba-doc/dev/reference/pysupported.html\nand\nhttp://numba.pydata.org/numba-doc/dev/reference/numpysupported.html\n\nFor more information about typing errors and how to debug them visit:\nhttp://numba.pydata.org/numba-doc/latest/user/troubleshoot.html#my-code-doesn-t-compile\n\nIf you think your code should work with Numba, please report the error message\nand traceback, along with a minimal reproducer at:\nhttps://github.com/numba/numba/issues/new\n",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypingError\u001b[0m                               Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-34-fef96fb3509b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_T0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdemo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExtract_opacity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgases\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwavel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopacity_treatment\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/dev/cloudacademyMap/gas_opac/opacity_demo.py\u001b[0m in \u001b[0;36mExtract_opacity\u001b[0;34m(chemical_species, P, T, wl_out, opacity_treatment)\u001b[0m\n\u001b[1;32m    284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    285\u001b[0m     \u001b[0;31m# Evaluate temperature interpolation weighting factor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 286\u001b[0;31m     \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw_T\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mT_interpolation_init\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mT_grid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    287\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    288\u001b[0m     \u001b[0;31m#***** Process molecular and atomic opacities *****#\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/cloud-academy/lib/python3.6/site-packages/numba/dispatcher.py\u001b[0m in \u001b[0;36m_compile_for_args\u001b[0;34m(self, *args, **kws)\u001b[0m\n\u001b[1;32m    346\u001b[0m                 \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch_message\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 348\u001b[0;31m             \u001b[0merror_rewrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'typing'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    349\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mUnsupportedError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    350\u001b[0m             \u001b[0;31m# Something unsupported is present in the user code, add help info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/cloud-academy/lib/python3.6/site-packages/numba/dispatcher.py\u001b[0m in \u001b[0;36merror_rewrite\u001b[0;34m(e, issue_type)\u001b[0m\n\u001b[1;32m    313\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    314\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 315\u001b[0;31m                 \u001b[0mreraise\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    316\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    317\u001b[0m         \u001b[0margtypes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/anaconda3/envs/cloud-academy/lib/python3.6/site-packages/numba/six.py\u001b[0m in \u001b[0;36mreraise\u001b[0;34m(tp, value, tb)\u001b[0m\n\u001b[1;32m    656\u001b[0m             \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    657\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 658\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    659\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    660\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mTypingError\u001b[0m: Failed in nopython mode pipeline (step: nopython frontend)\nInvalid use of < with parameters (reflected list(int64), float64)\nKnown signatures:\n * (bool, bool) -> bool\n * (int8, int8) -> bool\n * (int16, int16) -> bool\n * (int32, int32) -> bool\n * (int64, int64) -> bool\n * (uint8, uint8) -> bool\n * (uint16, uint16) -> bool\n * (uint32, uint32) -> bool\n * (uint64, uint64) -> bool\n * (float32, float32) -> bool\n * (float64, float64) -> bool\n * parameterized\n[1] During: typing of intrinsic-call at /home/liac/dev/cloudacademyMap/gas_opac/opacity_demo.py (150)\n\nFile \"opacity_demo.py\", line 150:\ndef T_interpolation_init(T_grid, T):\n    <source elided>\n        \n    if (T < T_grid[0]):   # If temperature falls off LHS of temperaure grid\n    ^\n\nThis is not usually a problem with Numba itself but instead often caused by\nthe use of unsupported features or an issue in resolving types.\n\nTo see Python/NumPy features supported by the latest release of Numba visit:\nhttp://numba.pydata.org/numba-doc/dev/reference/pysupported.html\nand\nhttp://numba.pydata.org/numba-doc/dev/reference/numpysupported.html\n\nFor more information about typing errors and how to debug them visit:\nhttp://numba.pydata.org/numba-doc/latest/user/troubleshoot.html#my-code-doesn-t-compile\n\nIf you think your code should work with Numba, please report the error message\nand traceback, along with a minimal reproducer at:\nhttps://github.com/numba/numba/issues/new\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_T0 = demo.Extract_opacity(np.array([gases[0]]), P, T0, wavel, opacity_treatment)"
+   ]
   }
  ],
  "metadata": {

From df4a468b3d1ef6a189cf3e0af601883badceea7d Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Wed, 5 Dec 2018 10:33:38 -0700
Subject: [PATCH 11/20] Small attempts at vectorizing

---
 gas_opac/opacity_demo.py | 47 ++++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 47dacb3..5991ea2 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -197,24 +197,14 @@ def T_interpolate(N_T, N_wl, sigma_pre_inp, T_grid, T, y, w_T):
             
     return sigma_inp
 
-# Notes from Lia:
-# Not sure what the slowest portion of the script is. I'll start with print statements
 def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     
     '''Convienient function to read in all opacities and pre-interpolate
        them onto the desired pressure, temperature, and wavelength grid'''
-    
-    print("Now reading in cross sections")
-    
-    # First, check from config.py which opacity calculation mode is specified
-    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
-    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
-    
-    #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
-    
-    # Open HDF5 files containing molecular + atomic opacities and CIA
+
+    print("Reading opacity database file")
     opac_file = h5py.File('./Opacity_database_0.01cm-1.hdf5', 'r')
-    
+
     #***** Read in T and P grids used in opacity files*****#
     T_grid = np.array(opac_file['H2O/T'])            # H2O here simply used as dummy (same grid for all molecules)
     log_P_grid = np.array(opac_file['H2O/log(P)'])   # Units: log10(P/bar)!
@@ -222,6 +212,12 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     #***** Read in wavenumber arrays used in opacity files*****#
     nu_opac = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
 
+    # First, check from config.py which opacity calculation mode is specified
+    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
+    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
+    
+    #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
+    
     N_P = len(log_P_grid)              # No. of pressures in opacity files
     N_T = len(T_grid)                  # No. of temperatures in opacity files
     N_species = len(chemical_species)  # No. of chemical species user wishes to store
@@ -234,37 +230,42 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     N_wl = len(wl_out)    # Number of wavelengths on model grid
     
     # Initialise arrays of wavenumber locations of left and right bin edges
-    nu_l = np.zeros(N_nu)   # Left edge
-    nu_r = np.zeros(N_nu)   # Right edge
+    #nu_l = np.zeros(N_nu)   # Left edge
+    #nu_r = np.zeros(N_nu)   # Right edge
+    # Look below for definitions of nu_l, nu_r
             
     # Find logarithm of desired pressure
     log_P = np.log10(P)
 
     print("interpolating...")
-    
+
     # If pressure below minimum, do not interpolate
     if (log_P < log_P_grid[0]):
         x = -1      # Special value (1) used in opacity inialiser
         w_P = 0.0
-        
     # If pressure above maximum, do not interpolate
     elif (log_P >= log_P_grid[-1]):
         x = -2      # Special value (2) used in opacity inialiser
         w_P = 0.0
-        
     else:
         # Closest P indicies in opacity grid corresponding to model pressure
         x = prior_index_V2(log_P, log_P_grid[0], log_P_grid[-1], N_P)
-        
         # Weights - fractional distance along pressure axis of sigma array
         w_P = (log_P-log_P_grid[x])/(log_P_grid[x+1]-log_P_grid[x])     
-         
+            
     # Precalculate interpolation pre-factors to reduce computation overhead
     b1 = (1.0-w_P)
     b2 = w_P  
-        
+    
     # Find wavenumber indicies in arrays of model grid
-    for k in range(N_nu):
+    # Vectorized by Lia
+    nu_edges = np.append(nu_out[0] - (nu_out[1] - nu_out[0]), 
+                         nu_out)
+    nu_edges = np.append(nu_edges, nu_out[-1] + (nu_out[-1] - nu_out[-2]))
+    nu_l = 0.5 * (nu_edges[:-2] + nu_edges[1:-1])
+    nu_r = 0.5 * (nu_edges[1:-1] +  nu_edges[2:])
+    
+    '''for k in range(N_nu):
         
         if (k != 0) and (k != (N_nu-1)):    
             nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
@@ -276,7 +277,7 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
             nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
         elif (k == (N_nu-1)):
             nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
-            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])
+            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])'''
     
     # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
     #sigma_stored = np.zeros(shape=(N_species, N_wl))

From 7eb5d4fe755de4fcd60b8c0ff625379aae9913d9 Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Wed, 5 Dec 2018 13:22:11 -0700
Subject: [PATCH 12/20] First pass at loading once, but memory will be an issue

---
 gas_opac/opacity_demo.py | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 5991ea2..b04a116 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -197,10 +197,10 @@ def T_interpolate(N_T, N_wl, sigma_pre_inp, T_grid, T, y, w_T):
             
     return sigma_inp
 
-def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
-    
-    '''Convienient function to read in all opacities and pre-interpolate
-       them onto the desired pressure, temperature, and wavelength grid'''
+
+## Written by Lia
+## To separate out reading step
+def load_db(chemical_species):
 
     print("Reading opacity database file")
     opac_file = h5py.File('./Opacity_database_0.01cm-1.hdf5', 'r')
@@ -212,10 +212,24 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     #***** Read in wavenumber arrays used in opacity files*****#
     nu_opac = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
 
+    # Read in log10(cross section) of specified molecule
+    log_sigma = dict()
+    for q in chemical_species:
+        log_sigma[q] = np.array(opac_file[q + '/log(sigma)']).astype(np.float64)      
+
+    return T_grid, log_P_grid, nu_opac, log_sigma
+
+def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
+    
+    '''Convienient function to read in all opacities and pre-interpolate
+       them onto the desired pressure, temperature, and wavelength grid'''
+
     # First, check from config.py which opacity calculation mode is specified
     if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
     elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
     
+    T_grid, log_P_grid, nu_opac, log_sigma = load_db(chemical_species)
+
     #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
     
     N_P = len(log_P_grid)              # No. of pressures in opacity files
@@ -296,11 +310,9 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
             
         species_q = chemical_species[q]     # Molecule name (defined in config.py)
         
-        # Read in log10(cross section) of specified molecule
-        log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)      
-        
+        lsigma = log_sigma[species_q]
         # Pre-interpolate cross section to desired P and wl grid 
-        sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, log_sigma, nu_l, nu_out, nu_r, nu_opac, N_nu, x, b1, b2, calculation_mode)
+        sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, lsigma, nu_l, nu_out, nu_r, nu_opac, N_nu, x, b1, b2, calculation_mode)
 
         #sigma_stored[q,:] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
         sigma_stored[species_q] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)

From 381f7f56f3f1ea4d152c63e5dd6552006fb6b940 Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Wed, 5 Dec 2018 13:30:17 -0700
Subject: [PATCH 13/20] Made a separate function for loading one (p,T) value

---
 gas_opac/opacity_demo.py | 73 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index b04a116..5c11b33 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -219,6 +219,79 @@ def load_db(chemical_species):
 
     return T_grid, log_P_grid, nu_opac, log_sigma
 
+def _get_one_PT(log_sigma, T_grid, log_P_grid, new_P, new_T, wl_out, opacity_treatment):
+    
+    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
+    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
+
+    N_P = len(log_P_grid)              # No. of pressures in opacity files
+    N_T = len(T_grid)                  # No. of temperatures in opacity files
+    N_species = len(chemical_species)  # No. of chemical species user wishes to store
+
+    # Convert model wavelength grid to wavenumber grid
+    nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
+    nu_out = nu_out[::-1]    # Reverse direction, such that increases with wavenumber
+    
+    N_nu = len(nu_out)    # Number of wavenumbers on model grid
+    N_wl = len(wl_out)    # Number of wavelengths on model grid
+    
+    # Initialise arrays of wavenumber locations of left and right bin edges
+    #nu_l = np.zeros(N_nu)   # Left edge
+    #nu_r = np.zeros(N_nu)   # Right edge
+    # Look below for definitions of nu_l, nu_r
+            
+    # Find logarithm of desired pressure
+    new_log_P = np.log10(new_P)
+
+    # If pressure below minimum, do not interpolate
+    if (log_P < log_P_grid[0]):
+        x = -1      # Special value (1) used in opacity inialiser
+        w_P = 0.0
+    # If pressure above maximum, do not interpolate
+    elif (log_P >= log_P_grid[-1]):
+        x = -2      # Special value (2) used in opacity inialiser
+        w_P = 0.0
+    else:
+        # Closest P indicies in opacity grid corresponding to model pressure
+        x = prior_index_V2(log_P, log_P_grid[0], log_P_grid[-1], N_P)
+        # Weights - fractional distance along pressure axis of sigma array
+        w_P = (log_P-log_P_grid[x])/(log_P_grid[x+1]-log_P_grid[x])     
+            
+    # Precalculate interpolation pre-factors to reduce computation overhead
+    b1 = (1.0-w_P)
+    b2 = w_P  
+    
+    # Find wavenumber indicies in arrays of model grid
+    # Vectorized by Lia
+    nu_edges = np.append(nu_out[0] - (nu_out[1] - nu_out[0]), 
+                         nu_out)
+    nu_edges = np.append(nu_edges, nu_out[-1] + (nu_out[-1] - nu_out[-2]))
+    nu_l = 0.5 * (nu_edges[:-2] + nu_edges[1:-1])
+    nu_r = 0.5 * (nu_edges[1:-1] +  nu_edges[2:])
+    
+    '''for k in range(N_nu):
+        
+        if (k != 0) and (k != (N_nu-1)):    
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        
+        # Special case for boundary values
+        elif (k == 0): 
+            nu_l[k] = nu_out[k] - 0.5*(nu_out[k+1] - nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        elif (k == (N_nu-1)):
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])'''
+    
+    sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, 
+                                                  log_sigma, nu_l, nu_out, nu_r, 
+                                                  nu_opac, N_nu, x, b1, b2, calculation_mode)
+
+    sigma_result = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
+
+    return sigma_result
+
+
 def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     
     '''Convienient function to read in all opacities and pre-interpolate

From 907f391e2b8438f20f08e9f5e9b71455bb1fa9e4 Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Wed, 5 Dec 2018 13:41:33 -0700
Subject: [PATCH 14/20] Interpolation algorithm moved to _get_one_PT function

---
 gas_opac/opacity_demo.py | 98 ++++++----------------------------------
 1 file changed, 14 insertions(+), 84 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 5c11b33..103aae8 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -200,10 +200,10 @@ def T_interpolate(N_T, N_wl, sigma_pre_inp, T_grid, T, y, w_T):
 
 ## Written by Lia
 ## To separate out reading step
-def load_db(chemical_species):
+def load_db(filename='./Opacity_database_0.01cm-1.hdf5'):
 
     print("Reading opacity database file")
-    opac_file = h5py.File('./Opacity_database_0.01cm-1.hdf5', 'r')
+    opac_file = h5py.File(filename, 'r')
 
     #***** Read in T and P grids used in opacity files*****#
     T_grid = np.array(opac_file['H2O/T'])            # H2O here simply used as dummy (same grid for all molecules)
@@ -212,14 +212,13 @@ def load_db(chemical_species):
     #***** Read in wavenumber arrays used in opacity files*****#
     nu_opac = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
 
-    # Read in log10(cross section) of specified molecule
-    log_sigma = dict()
-    for q in chemical_species:
-        log_sigma[q] = np.array(opac_file[q + '/log(sigma)']).astype(np.float64)      
+    return T_grid, log_P_grid, nu_opac, opac_file
 
-    return T_grid, log_P_grid, nu_opac, log_sigma
 
-def _get_one_PT(log_sigma, T_grid, log_P_grid, new_P, new_T, wl_out, opacity_treatment):
+# Algorithm for loading cross-sections from one pressure and temperature
+# from cross-section table of a single species (log_sigma)
+def _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac, 
+                new_P, new_T, wl_out, opacity_treatment):
     
     if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
     elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
@@ -282,6 +281,9 @@ def _get_one_PT(log_sigma, T_grid, log_P_grid, new_P, new_T, wl_out, opacity_tre
         elif (k == (N_nu-1)):
             nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
             nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])'''
+
+    # Evaluate temperature interpolation weighting factor
+    y, w_T = T_interpolation_init(T_grid, T)
     
     sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, 
                                                   log_sigma, nu_l, nu_out, nu_r, 
@@ -297,75 +299,8 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     '''Convienient function to read in all opacities and pre-interpolate
        them onto the desired pressure, temperature, and wavelength grid'''
 
-    # First, check from config.py which opacity calculation mode is specified
-    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
-    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
-    
-    T_grid, log_P_grid, nu_opac, log_sigma = load_db(chemical_species)
-
-    #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
-    
-    N_P = len(log_P_grid)              # No. of pressures in opacity files
-    N_T = len(T_grid)                  # No. of temperatures in opacity files
-    N_species = len(chemical_species)  # No. of chemical species user wishes to store
-
-    # Convert model wavelength grid to wavenumber grid
-    nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
-    nu_out = nu_out[::-1]    # Reverse direction, such that increases with wavenumber
-    
-    N_nu = len(nu_out)    # Number of wavenumbers on model grid
-    N_wl = len(wl_out)    # Number of wavelengths on model grid
-    
-    # Initialise arrays of wavenumber locations of left and right bin edges
-    #nu_l = np.zeros(N_nu)   # Left edge
-    #nu_r = np.zeros(N_nu)   # Right edge
-    # Look below for definitions of nu_l, nu_r
-            
-    # Find logarithm of desired pressure
-    log_P = np.log10(P)
-
-    print("interpolating...")
+    T_grid, log_P_grid, nu_opac, opac_file = load_db()
 
-    # If pressure below minimum, do not interpolate
-    if (log_P < log_P_grid[0]):
-        x = -1      # Special value (1) used in opacity inialiser
-        w_P = 0.0
-    # If pressure above maximum, do not interpolate
-    elif (log_P >= log_P_grid[-1]):
-        x = -2      # Special value (2) used in opacity inialiser
-        w_P = 0.0
-    else:
-        # Closest P indicies in opacity grid corresponding to model pressure
-        x = prior_index_V2(log_P, log_P_grid[0], log_P_grid[-1], N_P)
-        # Weights - fractional distance along pressure axis of sigma array
-        w_P = (log_P-log_P_grid[x])/(log_P_grid[x+1]-log_P_grid[x])     
-            
-    # Precalculate interpolation pre-factors to reduce computation overhead
-    b1 = (1.0-w_P)
-    b2 = w_P  
-    
-    # Find wavenumber indicies in arrays of model grid
-    # Vectorized by Lia
-    nu_edges = np.append(nu_out[0] - (nu_out[1] - nu_out[0]), 
-                         nu_out)
-    nu_edges = np.append(nu_edges, nu_out[-1] + (nu_out[-1] - nu_out[-2]))
-    nu_l = 0.5 * (nu_edges[:-2] + nu_edges[1:-1])
-    nu_r = 0.5 * (nu_edges[1:-1] +  nu_edges[2:])
-    
-    '''for k in range(N_nu):
-        
-        if (k != 0) and (k != (N_nu-1)):    
-            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
-            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
-        
-        # Special case for boundary values
-        elif (k == 0): 
-            nu_l[k] = nu_out[k] - 0.5*(nu_out[k+1] - nu_out[k])
-            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
-        elif (k == (N_nu-1)):
-            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
-            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])'''
-    
     # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
     #sigma_stored = np.zeros(shape=(N_species, N_wl))
     # Lia -- Making this a dictionary instead of a numpy array. It's easier to use for plotting.
@@ -373,9 +308,6 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     # But for now, two dozen is not a lot.
     sigma_stored = dict()
     
-    # Evaluate temperature interpolation weighting factor
-    y, w_T = T_interpolation_init(T_grid, T)  
-        
     #***** Process molecular and atomic opacities *****#
     
     # Load molecular and atomic absorption cross sections
@@ -383,12 +315,10 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
             
         species_q = chemical_species[q]     # Molecule name (defined in config.py)
         
-        lsigma = log_sigma[species_q]
-        # Pre-interpolate cross section to desired P and wl grid 
-        sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, lsigma, nu_l, nu_out, nu_r, nu_opac, N_nu, x, b1, b2, calculation_mode)
+        log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)
 
-        #sigma_stored[q,:] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
-        sigma_stored[species_q] = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
+        sigma_stored[species_q] = _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
+                                              P, T, wl_out, opacity_treatment)
         
         del log_sigma, sigma_pre_T_inp   # Clear raw cross section to free up memory
         

From 0df978feb540a35133a0c88bdc1eccbf1f0fc9db Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Wed, 5 Dec 2018 13:51:43 -0700
Subject: [PATCH 15/20] bugs fixed, it works in jupyter notebook

---
 gas_opac/opacity_demo.py | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 103aae8..49723d7 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -225,7 +225,6 @@ def _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
 
     N_P = len(log_P_grid)              # No. of pressures in opacity files
     N_T = len(T_grid)                  # No. of temperatures in opacity files
-    N_species = len(chemical_species)  # No. of chemical species user wishes to store
 
     # Convert model wavelength grid to wavenumber grid
     nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
@@ -240,7 +239,7 @@ def _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
     # Look below for definitions of nu_l, nu_r
             
     # Find logarithm of desired pressure
-    new_log_P = np.log10(new_P)
+    log_P = np.log10(new_P)
 
     # If pressure below minimum, do not interpolate
     if (log_P < log_P_grid[0]):
@@ -283,13 +282,13 @@ def _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
             nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])'''
 
     # Evaluate temperature interpolation weighting factor
-    y, w_T = T_interpolation_init(T_grid, T)
+    y, w_T = T_interpolation_init(T_grid, new_T)
     
     sigma_pre_T_inp = P_interpolate_wl_initialise(N_T, N_P, N_wl, 
                                                   log_sigma, nu_l, nu_out, nu_r, 
                                                   nu_opac, N_nu, x, b1, b2, calculation_mode)
 
-    sigma_result = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, T, y, w_T)
+    sigma_result = T_interpolate(N_T, N_wl, sigma_pre_T_inp, T_grid, new_T, y, w_T)
 
     return sigma_result
 
@@ -311,21 +310,16 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     #***** Process molecular and atomic opacities *****#
     
     # Load molecular and atomic absorption cross sections
-    for q in range(N_species):
-            
-        species_q = chemical_species[q]     # Molecule name (defined in config.py)
+    for q in chemical_species:
         
-        log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)
+        log_sigma = np.array(opac_file[q + '/log(sigma)']).astype(np.float64)
 
-        sigma_stored[species_q] = _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
+        sigma_stored[q] = _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
                                               P, T, wl_out, opacity_treatment)
         
-        del log_sigma, sigma_pre_T_inp   # Clear raw cross section to free up memory
+        del log_sigma   # Clear raw cross section to free up memory
         
-        print(species_q + " done")
-    
-    # Clear up storage
-    del nu_l, nu_r, nu_out
+        print(q + " done")
     
     opac_file.close()
     

From 91d6216367a91d4310804810c4133d41cfdac6f3 Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Wed, 5 Dec 2018 13:53:38 -0700
Subject: [PATCH 16/20] Uploading notebook that works with new opacity_demo

---
 notebooks/test_gas_opac.ipynb | 248 +++++-----------------------------
 1 file changed, 34 insertions(+), 214 deletions(-)

diff --git a/notebooks/test_gas_opac.ipynb b/notebooks/test_gas_opac.ipynb
index d827d66..0d29d32 100644
--- a/notebooks/test_gas_opac.ipynb
+++ b/notebooks/test_gas_opac.ipynb
@@ -25,25 +25,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "/home/liac/python-lib/chandra_psf:/home/liac/dev/cloudacademyMap:/home/liac/dev/cloudacademyMap/gas_opac\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "print(os.environ['PYTHONPATH'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/home/liac/dev/cloudacademyMap/gas_opac\n"
+      "/Users/lia/dev/cloudacademyMap/gas_opac\n"
      ]
     }
    ],
@@ -53,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -62,14 +44,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Now reading in cross sections\n",
+      "Reading opacity database file\n",
       "H2O done\n",
       "CH4 done\n",
       "NH3 done\n",
@@ -104,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -115,7 +97,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -172,7 +154,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -204,7 +186,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -219,48 +201,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([False, False, False, False, False, False, False, False, False,\n",
-       "       False, False, False, False, False, False, False, False, False,\n",
-       "       False, False, False, False,  True, False, False, False, False,\n",
-       "       False, False, False, False, False, False, False, False, False,\n",
-       "       False, False, False, False, False])"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "np.array(RMcD_gas_upper) == 'TIO'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/home/liac/dev/cloudacademyMap\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "cd .."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -269,24 +228,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/home/liac/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "cd ~/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity/"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -302,17 +253,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO', 'TIO2', 'TIS', 'SIO', 'SIS', 'SIH', 'H2O', 'H2', 'H2S', 'MGH', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FEH', 'FE(OH)2', 'ALOH', 'ALH', 'AL2O', 'ALO2H', 'CAO', 'CA(OH)2', 'CAS', 'CAOH', 'CAH', 'C2', 'C3', 'C2H', 'C2H2', 'CH4']\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "thermo_gas = []\n",
     "for k in thermo.keys():\n",
@@ -324,7 +267,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -340,21 +283,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Gases in both static_weather and Ryan's opacity library: (13 total)\n",
-      "['TiO', 'SiO', 'SiH', 'H2O', 'H2', 'H2S', 'MgH', 'FeH', 'AlH', 'CaO', 'CaH', 'C2H2', 'CH4']\n",
-      "\n",
-      "Gases missing opacities: (25 total)\n",
-      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO2', 'TIS', 'SIS', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FE(OH)2', 'ALOH', 'AL2O', 'ALO2H', 'CA(OH)2', 'CAS', 'CAOH', 'C2', 'C3', 'C2H']\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"Gases in both static_weather and Ryan's opacity library: ({} total)\".format(len(gases)))\n",
     "print(gases)\n",
@@ -364,17 +295,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/home/liac/dev/cloudacademyMap/gas_opac\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "cd ~/dev/cloudacademyMap/gas_opac"
    ]
@@ -388,32 +311,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Now reading in cross sections\n",
-      "TiO done\n",
-      "SiO done\n",
-      "SiH done\n",
-      "H2O done\n",
-      "H2 done\n",
-      "H2S done\n",
-      "MgH done\n",
-      "FeH done\n",
-      "AlH done\n",
-      "CaO done\n",
-      "CaH done\n",
-      "C2H2 done\n",
-      "CH4 done\n",
-      "CPU times: user 1min 19s, sys: 27.4 s, total: 1min 46s\n",
-      "Wall time: 2min 12s\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "sw_xsects = demo.Extract_opacity(np.array(gases), P, T, wavel, opacity_treatment)"
@@ -421,32 +321,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(0.2, 330)"
-      ]
-     },
-     "execution_count": 42,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "plot_opacity(np.array(gases), sw_xsects, P, T, wavel, marker='o', ls=':', alpha=0.5)\n",
     "plt.semilogx()\n",
@@ -455,20 +332,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "304"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "len(thermo['p'])"
    ]
@@ -497,32 +363,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(500, 3000)"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "for g in gases:\n",
     "    plt.plot(thermo['T'], thermo['n_' + g.upper()])\n",
@@ -532,7 +375,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -545,32 +388,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Now reading in cross sections\n"
-     ]
-    },
-    {
-     "ename": "TypingError",
-     "evalue": "Failed in nopython mode pipeline (step: nopython frontend)\nInvalid use of < with parameters (reflected list(int64), float64)\nKnown signatures:\n * (bool, bool) -> bool\n * (int8, int8) -> bool\n * (int16, int16) -> bool\n * (int32, int32) -> bool\n * (int64, int64) -> bool\n * (uint8, uint8) -> bool\n * (uint16, uint16) -> bool\n * (uint32, uint32) -> bool\n * (uint64, uint64) -> bool\n * (float32, float32) -> bool\n * (float64, float64) -> bool\n * parameterized\n[1] During: typing of intrinsic-call at /home/liac/dev/cloudacademyMap/gas_opac/opacity_demo.py (150)\n\nFile \"opacity_demo.py\", line 150:\ndef T_interpolation_init(T_grid, T):\n    <source elided>\n        \n    if (T < T_grid[0]):   # If temperature falls off LHS of temperaure grid\n    ^\n\nThis is not usually a problem with Numba itself but instead often caused by\nthe use of unsupported features or an issue in resolving types.\n\nTo see Python/NumPy features supported by the latest release of Numba visit:\nhttp://numba.pydata.org/numba-doc/dev/reference/pysupported.html\nand\nhttp://numba.pydata.org/numba-doc/dev/reference/numpysupported.html\n\nFor more information about typing errors and how to debug them visit:\nhttp://numba.pydata.org/numba-doc/latest/user/troubleshoot.html#my-code-doesn-t-compile\n\nIf you think your code should work with Numba, please report the error message\nand traceback, along with a minimal reproducer at:\nhttps://github.com/numba/numba/issues/new\n",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypingError\u001b[0m                               Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-34-fef96fb3509b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtest_T0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdemo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExtract_opacity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgases\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwavel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopacity_treatment\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/dev/cloudacademyMap/gas_opac/opacity_demo.py\u001b[0m in \u001b[0;36mExtract_opacity\u001b[0;34m(chemical_species, P, T, wl_out, opacity_treatment)\u001b[0m\n\u001b[1;32m    284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    285\u001b[0m     \u001b[0;31m# Evaluate temperature interpolation weighting factor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 286\u001b[0;31m     \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw_T\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mT_interpolation_init\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mT_grid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    287\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    288\u001b[0m     \u001b[0;31m#***** Process molecular and atomic opacities *****#\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/cloud-academy/lib/python3.6/site-packages/numba/dispatcher.py\u001b[0m in \u001b[0;36m_compile_for_args\u001b[0;34m(self, *args, **kws)\u001b[0m\n\u001b[1;32m    346\u001b[0m                 \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch_message\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 348\u001b[0;31m             \u001b[0merror_rewrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'typing'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    349\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mUnsupportedError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    350\u001b[0m             \u001b[0;31m# Something unsupported is present in the user code, add help info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/cloud-academy/lib/python3.6/site-packages/numba/dispatcher.py\u001b[0m in \u001b[0;36merror_rewrite\u001b[0;34m(e, issue_type)\u001b[0m\n\u001b[1;32m    313\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    314\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 315\u001b[0;31m                 \u001b[0mreraise\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    316\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    317\u001b[0m         \u001b[0margtypes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/envs/cloud-academy/lib/python3.6/site-packages/numba/six.py\u001b[0m in \u001b[0;36mreraise\u001b[0;34m(tp, value, tb)\u001b[0m\n\u001b[1;32m    656\u001b[0m             \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    657\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mtb\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 658\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    659\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    660\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypingError\u001b[0m: Failed in nopython mode pipeline (step: nopython frontend)\nInvalid use of < with parameters (reflected list(int64), float64)\nKnown signatures:\n * (bool, bool) -> bool\n * (int8, int8) -> bool\n * (int16, int16) -> bool\n * (int32, int32) -> bool\n * (int64, int64) -> bool\n * (uint8, uint8) -> bool\n * (uint16, uint16) -> bool\n * (uint32, uint32) -> bool\n * (uint64, uint64) -> bool\n * (float32, float32) -> bool\n * (float64, float64) -> bool\n * parameterized\n[1] During: typing of intrinsic-call at /home/liac/dev/cloudacademyMap/gas_opac/opacity_demo.py (150)\n\nFile \"opacity_demo.py\", line 150:\ndef T_interpolation_init(T_grid, T):\n    <source elided>\n        \n    if (T < T_grid[0]):   # If temperature falls off LHS of temperaure grid\n    ^\n\nThis is not usually a problem with Numba itself but instead often caused by\nthe use of unsupported features or an issue in resolving types.\n\nTo see Python/NumPy features supported by the latest release of Numba visit:\nhttp://numba.pydata.org/numba-doc/dev/reference/pysupported.html\nand\nhttp://numba.pydata.org/numba-doc/dev/reference/numpysupported.html\n\nFor more information about typing errors and how to debug them visit:\nhttp://numba.pydata.org/numba-doc/latest/user/troubleshoot.html#my-code-doesn-t-compile\n\nIf you think your code should work with Numba, please report the error message\nand traceback, along with a minimal reproducer at:\nhttps://github.com/numba/numba/issues/new\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "test_T0 = demo.Extract_opacity(np.array([gases[0]]), P, T0, wavel, opacity_treatment)"
    ]

From 5205df6160257067c4b83b6497b5e7ae6224e31c Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Thu, 6 Dec 2018 18:43:46 -0700
Subject: [PATCH 17/20] just got a new file from Ryan

---
 gas_opac/opacity_demo_V2.py | 455 ++++++++++++++++++++++++++++++++++++
 1 file changed, 455 insertions(+)
 create mode 100644 gas_opac/opacity_demo_V2.py

diff --git a/gas_opac/opacity_demo_V2.py b/gas_opac/opacity_demo_V2.py
new file mode 100644
index 0000000..52d55b4
--- /dev/null
+++ b/gas_opac/opacity_demo_V2.py
@@ -0,0 +1,455 @@
+# Demostrates how to open the opacity database and interpolate to given (P,T) and wavelength grid
+# Author: Ryan J. MacDonald
+# V1.0: Evaluates cross sections at a single P,T point (8th November 2018)
+# V2.0: Evaluates cross sections on a grid of (P,T) points (6th december 2018)
+
+import numpy as np
+import h5py
+from scipy.ndimage import gaussian_filter1d as gauss_conv
+from numba.decorators import jit
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+
+#***** Begin function declarations *****# 
+
+@jit(nopython = True)
+def prior_index(vec, value, start):
+    
+    '''Finds the previous index of a grid closest to a specified value
+    '''
+    
+    value_tmp = value
+    
+    if (value_tmp > vec[-1]):
+        return (len(vec) - 1)
+    
+    # Check if value out of bounds, if so set to edge value
+    if (value_tmp < vec[0]): value_tmp = vec[0]
+    if (value_tmp > vec[-2]): value_tmp = vec[-2]
+    
+    index = start
+    
+    for i in range(len(vec)-start):
+        if (vec[i+start] > value_tmp): 
+            index = (i+start) - 1
+            break
+            
+    return index
+
+@jit(nopython=True)
+def prior_index_V2(val, grid_start, grid_end, N_grid):
+    
+    '''Finds the previous index of a UNIFORM grid closest to a specified value.
+    
+       A uniform grid dramatically speeds calculation over a non-uniform grid.
+    '''
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        return int(i)
+
+@jit(nopython=True)
+def closest_index(val, grid_start, grid_end, N_grid):
+    
+    '''Finds the index of a UNIFORM grid closest to a specified value.
+    
+       A uniform grid dramatically speeds calculation over a non-uniform grid.
+    '''
+    
+    if (val < grid_start): 
+        return 0
+    
+    elif (val > grid_end):
+        return N_grid-1
+    
+    else:
+        i = (N_grid-1) * ((val - grid_start) / (grid_end - grid_start))
+        if ((i%1)<=0.5):
+            return int(i)
+        else:
+            return int(i)+1
+                        
+@jit(nopython = True)
+def P_interpolate_wl_initialise(nu_grid, N_P_out, N_T, N_P, N_wl_out, N_nu_out, 
+                                log_sigma, x, z_l, z, z_r, b1, b2, mode):
+    
+    '''Interpolates raw cross sections onto the output P and wl grids.
+       
+       Note: input sigma has format log10(cross_sec)[log(P)_grid, T_grid, nu_grid], 
+             whilst output has format cross_sec[log(P)_out, T_grid, wl_out]
+             
+       The input is in wavenumnber to take advantage of fast prior index location 
+       on a uniform grid, which wouldn't work for the (non-uniform) wavelength grid
+       Array reversal to output in increasing wavelength is handled by indexing
+       by a factor of (N_wl-1)-k throughout. 
+    '''
+    
+    sigma_pre_inp = np.zeros(shape=(N_P_out, N_T, N_wl_out))
+    
+    N_nu = len(nu_grid)   # Number of wavenumber points in sigma array
+        
+    for i in xrange(N_P_out):        # For each pressure in output array
+        for j in xrange(N_T):        # For each temperature in input array
+            for k in xrange(N_nu_out):   # Note that the k here is looping over wavenumber
+                            
+                # If nu (wl) point out of range of opacity grid, set opacity to zero
+                if ((z[k] == 0) or (z[k] == (N_nu-1))):
+                    sigma_pre_inp[i, j, ((N_wl_out-1)-k)] = 0.0
+                
+                else:
+                    
+                    # Opacity sampling
+                    if (mode == 1):
+                    
+                        # If pressure below minimum, set to value at min pressure
+                        if (x[i] == -1):
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (log_sigma[0, j, z[k]])
+                            
+                        # If pressure above maximum, set to value at max pressure
+                        elif (x[i] == -2):
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (log_sigma[(N_P-1), j, z[k]])
+            
+                        # Interpolate sigma in logsace, then power to get interp array
+                        else:
+                            reduced_sigma = log_sigma[x[i]:x[i]+2, j, z[k]]
+                            
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] =  10 ** (b1[i]*(reduced_sigma[0]) +
+                                                                        b2[i]*(reduced_sigma[1]))
+                            
+                    # Log averaging
+                    elif (mode == 2):
+                    
+                        # If pressure below minimum, set to value at min pressure
+                        if (x[i] == -1):
+                            sigma_in_bin = np.mean(log_sigma[0, j, z_l[k]:z_r[k]+1])
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+                            
+                        # If pressure above maximum, set to value at max pressure
+                        elif (x[i] == -2):
+                            sigma_in_bin = np.mean(log_sigma[(N_P-1), j, z_l[k]:z_r[k]+1])
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] = 10 ** (sigma_in_bin)
+        
+                        # Interpolate sigma in logsace, then power to get interp array
+                        else:
+                            sigma_in_bin_P1 = np.mean(log_sigma[x[i], j, z_l[k]:z_r[k]+1])
+                            sigma_in_bin_P2 = np.mean(log_sigma[x[i]+1, j, z_l[k]:z_r[k]+1])
+                        
+                            sigma_pre_inp[i, j, ((N_wl-1)-k)] =  10 ** (b1[i]*(sigma_in_bin_P1) +
+                                                                        b2[i]*(sigma_in_bin_P2))
+                    
+    return sigma_pre_inp
+
+@jit(nopython = True)
+def T_interpolation_init(N_T_out, T_grid, T_out, y):
+    
+    ''' Precomputes the T interpolation weight factors, so this does not
+        need to be done multiple times across all species.
+    '''
+    
+    w_T = np.zeros(N_T_out)  # Temperature interpolation weight factors
+    
+    # Find T index in cross secion arrays prior to fine temperature value
+    for j in xrange(N_T_out):
+        
+        if (T_out[j] < T_grid[0]):    # If fine temperature point falls off LHS of temperaure grid
+            y[j] = -1                 # Special value (-1) stored, interpreted in interpolator
+            w_T[j] = 0.0              # Weight not used in this case
+            
+        elif (T_out[j] >= T_grid[-1]):    # If fine temperature point falls off RHS of temperaure grid
+            y[j] = -2                     # Special value (-2) stored, interpreted in interpolator
+            w_T[j] = 0.0                  # Weight not used in this case
+            
+        else:
+                
+            # Have to use prior_index (V1) here as T_grid is not uniformly spaced
+            y[j] = prior_index(T_grid, T_out[j], 0)     # Index in cross secion arrays prior to desired temperature value
+                
+            # Pre-computed temperature values to left and right of desired temperature value
+            T1 = T_grid[y[j]]
+            T2 = T_grid[y[j]+1]
+                
+            # Precompute temperature interpolation weight factor
+            w_T[j] = (1.0/((1.0/T2) - (1.0/T1)))
+  
+    return w_T
+
+@jit(nopython = True)
+def T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T):
+    
+    '''Interpolates pre-processed cross section onto the output T grid.
+       
+       Note: input sigma has format log10(cross_sec)[log(P)_out, T_grid, wl_out], 
+             whilst output has format cross_sec[log(P)_out, T_out, wl_out].
+             
+       Output is the final interpolated cross section as a 3D array on the
+       desired P_out, T_out, wl_out grids.
+    '''
+    
+    sigma_inp = np.zeros(shape=(N_P_out, N_T_out, N_wl_out))
+    
+    for i in xrange(N_P_out):       # Loop over output pressure array
+        for j in xrange(N_T_out):   # Loop over input temperature array
+            
+            T = T_out[j]            # Temperature we wish to interpolate to
+            T1 = T_grid[y[j]]
+            T2 = T_grid[y[j]+1]
+            
+            for k in xrange(N_wl_out):  # Loop over wavelengths
+                
+                # If T_out below min pre-computed value (100 K), set sigma to value at min T
+                if (y[j] == -1):
+                    sigma_inp[i, j, k] = sigma_pre_inp[i, 0, k]
+                    
+                # If T_out above max pre-computed value (3500 K), set sigma to value at max T
+                elif (y[j] == -2):
+                    sigma_inp[i, j, k] = sigma_pre_inp[i, (N_T-1), k]
+            
+                # Interpolate sigma to output temperature grid value
+                else: 
+                    sig_reduced = sigma_pre_inp[i, y[j]:y[j]+2, k]
+                    sig_1, sig_2 = sig_reduced[0], sig_reduced[1]    # sigma(T1)[i,k], sigma(T2)[i,k]
+                    
+                    sigma_inp[i, j, k] =  (np.power(sig_1, (w_T[j]*((1.0/T2) - (1.0/T)))) *
+                                           np.power(sig_2, (w_T[j]*((1.0/T) - (1.0/T1)))))
+            
+    return sigma_inp
+
+def Extract_opacity(chemical_species, P_out, T_out, wl_out, opacity_treatment):
+    
+    '''Main function to read in all opacities and interpolate them onto the 
+       desired pressure, temperature, and wavelength grids.
+    '''
+    
+    print("Now reading in cross sections")
+    
+    # First, check from config.py which opacity calculation mode is specified
+    if   (opacity_treatment == 'Opacity-sample'): calculation_mode = 1
+    elif (opacity_treatment == 'Log-avg'):        calculation_mode = 2
+
+    #***** Firstly, we initialise the various quantities needed for pre-interpolation*****#
+    
+    # Open HDF5 files containing molecular + atomic opacities and CIA
+    opac_file = h5py.File('./Opacity_database_0.01cm-1.hdf5', 'r')
+    
+    #***** Read in T and P grids used in opacity files*****#
+    T_grid = np.array(opac_file['H2O/T'])            # H2O here simply used as dummy (same grid for all molecules)
+    log_P_grid = np.array(opac_file['H2O/log(P)'])   # Units: log10(P/bar)
+    log_P_out = np.log10(P_out)                      # Units: log10(P/bar)
+    
+    #***** Read in wavenumber arrays used in opacity files*****#
+    nu_grid = np.array(opac_file['H2O/nu'])     # H2O here simply used as dummy (same grid for all molecules)
+
+    # Convert model wavelength grid to wavenumber grid
+    nu_out = 1.0e4/wl_out    # Model wavenumber grid (cm^-1)
+    nu_out = nu_out[::-1]    # Reverse direction, such that increases with wavenumber
+    
+    N_nu = len(nu_grid)                # No. of wavenumbers in each opacity file (2480001)
+    N_P = len(log_P_grid)              # No. of pressures in opacity files
+    N_T = len(T_grid)                  # No. of temperatures in opacity files
+    N_species = len(chemical_species)  # No. of chemical species user wishes to store
+    
+    N_P_out = len(P_out)      # No. of pressures on output pressure grid
+    N_T_out = len(T_out)      # No. of temperatures on output temperature grid
+    N_nu_out = len(nu_out)    # No. of wavenumbers on output grid
+    N_wl_out = len(wl_out)    # No. of wavelengths on output grid
+    
+    # Initialise arrays of wavenumber locations of left and right bin edges
+    nu_l = np.zeros(N_nu_out)   # Left edge
+    nu_r = np.zeros(N_nu_out)   # Right edge
+    
+    # Initialise arrays of indicies on wavenumber opacity grid corresponding to nu_l, nu_out, and nu_r
+    z_l = np.zeros(N_wl_out, dtype=np.int)   # Bin left edge
+    z = np.zeros(N_wl_out, dtype=np.int)     # Bin centre
+    z_r = np.zeros(N_wl_out, dtype=np.int)   # Bin right edge
+    
+    # Initialise array of indicies on pre-calculated pressure opacity grid prior to defined atmosphere layer pressures
+    x = np.zeros(N_P_out, dtype=np.int)
+    
+    # Weights
+    w_P = np.zeros(N_P_out)
+            
+    # Useful functions of weights for interpolation
+    b1 = np.zeros(shape=(N_P_out))
+    b2 = np.zeros(shape=(N_P_out))
+    
+    # Now find closest P indicies in opacity grid corresponding to output pressures
+    for i in xrange(N_P_out):
+        
+        # If pressure below minimum, do not interpolate
+        if (log_P_out[i] < log_P_grid[0]):
+            x[i] = -1      # Special value (1) used in opacity initialiser
+            w_P[i] = 0.0
+        
+        # If pressure above maximum, do not interpolate
+        elif (log_P_out[i] >= log_P_grid[-1]):
+            x[i] = -2      # Special value (2) used in opacity initialiser
+            w_P[i] = 0.0
+        
+        else:
+            x[i] = prior_index_V2(log_P_out[i], log_P_grid[0], log_P_grid[-1], N_P)
+        
+            # Weights - fractional distance along pressure axis of cross section array
+            w_P[i] = (log_P_out[i]-log_P_grid[x[i]])/(log_P_grid[x[i]+1]-log_P_grid[x[i]])     
+         
+        # Precalculate interpolation pre-factors to reduce computation overhead
+        b1[i] = (1.0-w_P[i])
+        b2[i] = w_P[i]  
+            
+    # Find wavenumber indicies on input grid closest to values on output grid
+    for k in xrange(N_nu_out):
+        
+        if (k != 0) and (k != (N_nu_out-1)):    
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        
+        # Boundary values of each output wavenumber point
+        elif (k == 0): 
+            nu_l[k] = nu_out[k] - 0.5*(nu_out[k+1] - nu_out[k])
+            nu_r[k] = 0.5*(nu_out[k] + nu_out[k+1])
+        elif (k == (N_nu-1)):
+            nu_l[k] = 0.5*(nu_out[k-1] + nu_out[k])
+            nu_r[k] = nu_out[k] + 0.5*(nu_out[k] - nu_out[k-1])
+        
+        # Calculate closest indicies to output wavenumber bin left, centre, and right edge
+        z_l[k] = closest_index(nu_l[k], nu_grid[0], nu_grid[-1], N_nu)
+        z[k] = closest_index(nu_out[k], nu_grid[0], nu_grid[-1], N_nu)
+        z_r[k] = closest_index(nu_r[k], nu_grid[0], nu_grid[-1], N_nu)
+        
+    # Initialise molecular and atomic opacity array, interpolated to output (P,T,wl) grid
+    sigma_stored = np.zeros(shape=(N_species, N_P_out, N_T_out, N_wl_out))
+    
+    # Evaluate temperature interpolation weighting factor
+    y = np.zeros(N_T_out, dtype=np.int)
+    w_T = T_interpolation_init(N_T_out, T_grid, T_out, y)
+        
+    #***** Process molecular and atomic opacities *****#
+    
+    # Load molecular and atomic absorption cross sections
+    for q in xrange(N_species):
+            
+        species_q = chemical_species[q]    # Species name specified by user
+        
+        # Read in log10(cross section) of specified species
+        log_sigma = np.array(opac_file[species_q + '/log(sigma)']).astype(np.float64)      
+            
+        # Pre-interpolate cross section to desired P and wl grid 
+        sigma_pre_inp = P_interpolate_wl_initialise(nu_grid, N_P_out, N_T, N_P, N_wl_out, N_nu_out, log_sigma, x, z_l, z, z_r, b1, b2, calculation_mode)
+                
+        # Interplate to desired temperature
+        sigma_stored[q,:,:,:] = T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T)
+        
+        del log_sigma, sigma_pre_inp   # Clear raw cross section to free up memory
+        
+        print(species_q + " done")
+    
+    # Clear up storage
+    del z, z_l, z_r, nu_grid, nu_l, nu_r, nu_out, y, w_T
+    
+    opac_file.close()
+    
+    return sigma_stored
+
+def plot_opacity(chemical_species, sigma_stored, P_desired, T_desired, wl_grid):
+    
+    # Max number of species this can plot is 9 (clustered beyond that!)
+    
+    # Optional smoothing of cross sections (can improve clarity)
+    smooth = False
+    smooth_factor = 5
+    
+    # Specify cross sections to plot, along with colours for each
+    colours_plot = np.array(['royalblue', 'purple', 'crimson', 'orange', 'black', 'grey', 'green', 'magenta', 'chocolate'])
+    
+    # Initialise plot
+    ax = plt.gca()    
+    #ax.set_xscale("log")
+    
+    xmajorLocator   = MultipleLocator(1.0)
+    xmajorFormatter = FormatStrFormatter('%.1f')
+    xminorLocator   = MultipleLocator(0.2)
+    
+    ax.xaxis.set_major_locator(xmajorLocator)
+    ax.xaxis.set_major_formatter(xmajorFormatter)
+    ax.xaxis.set_minor_locator(xminorLocator)
+    
+    # Plot each cross section
+    for q in range(len(chemical_species)):
+        
+        species = chemical_species[q]  # Species to plot cross section of 
+        colour = colours_plot[q]   # Colour of cross section for plot
+        
+        #print(species)
+        
+        species_idx = np.where(chemical_species == species)[0][0]
+
+        sigma_plt = sigma_stored[species_idx,:]*1.0e4   # Cross section of species q at given (P,T) pair (cm^2)
+        
+        if (smooth == True):
+            sigma_plt = gauss_conv(sigma_plt, sigma=smooth_factor, mode='nearest')
+        
+        # Plot cross section
+        plt.semilogy(wl_grid, sigma_plt, lw=0.5, alpha = 1.0, color= colour, label = species)
+    
+    plt.ylim([1.0e-28, 2.0e-18])
+    plt.xlim([min(wl_grid), max(wl_grid)])
+    plt.ylabel(r'$\mathrm{Cross \, \, Section \, \, (cm^{2})}$', fontsize = 15)
+    plt.xlabel(r'$\mathrm{Wavelength} \; \mathrm{(\mu m)}$', fontsize = 15)
+    
+    ax.text(min(wl_grid)*1.05, 6.0e-19, (r'$\mathrm{T = }$' + str(T_desired) + r'$\mathrm{K \, \, P = }$' + str(P_desired*1000) + r'$\mathrm{mbar}$'), fontsize = 14)
+    
+    legend = plt.legend(loc='upper right', shadow=False, frameon=False, prop={'size':6}, ncol=2)
+    
+    for legline in legend.legendHandles:
+        legline.set_linewidth(1.0)
+    
+    #plt.close()
+    #plt.show()
+
+    plt.savefig('./cross_sections_' + str(T_desired) + 'K_' + str(P_desired*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+
+
+#***** Begin main program ***** 
+    
+# Specify which molecules you want to extract from the database (full list available in the readme)
+chemical_species = np.array(['H2O', 'CH4', 'NH3', 'HCN', 'CO', 'CO2'])
+
+# Specify temperature and pressure grids on which to evaluate cross sections. Example:
+P = np.logspace(-6, 2.0, 10)            # 20 pressures logarithmically spaced from 10^-6 -> 10^2 bar.
+T = np.linspace(1000.0, 3000.0, 100)    # 100 temperatures linearly spaced from 1000K -> 3000 K.
+
+# Specify wavelength grid to extract cross section onto
+wl_min = 0.4  # Minimum wavelength of grid (micron)
+wl_max = 5.0  # Maximum wavelength of grid (micron)
+N_wl = 1000   # Number of wavelength points
+
+wl = np.linspace(wl_min, wl_max, N_wl)  # Uniform grid used here for demonstration purposes   
+
+# Can use any P,T,wl grids, doesn't have to be uniform, but MUST be a numpy array.
+# Note: if you use a v. large number of (P,T,wl) points, the memory usage could be quite high!
+# This example has 10x100x1000 = 10^6 cross section values stored for each species.
+
+# Either sample the nearest wavelength points from the high resolution (R~10^6) cross section database or use an averaging prescription 
+opacity_treatment = 'Log-avg'           # Options: Opacity-sample / Log-avg
+#opacity_treatment = 'Opacity-sample'   # Opacity sampling is faster, but for low-resolution wavelength grids log averaging is recommended
+  
+# Extract desired cross sections from the database
+cross_sections = Extract_opacity(chemical_species, P, T, wl, opacity_treatment)   # Format: np array(N_species, N_P, N_T, N_wl) / Units: (m^2 / species)
+
+# Example: seperate H2O cross section at 1 bar and 2000K, and print to terminal
+P_desired = 1.0
+T_desired = 2000.0
+P_idx = np.argmin(np.abs(P - P_desired))  # Closest index in the P array to desired value
+T_idx = np.argmin(np.abs(T - T_desired))  # Closest index in the T array to desired value
+
+H2O_cross_section = cross_sections[(np.where(chemical_species=='H2O')[0][0]),P_idx,T_idx,:]    # Format: np array(N_wl) / Units: (m^2 / molecule)
+#print (H2O_cross_section)
+
+# Plot cross sections at the desired P and T
+plot_opacity(chemical_species, cross_sections[:,P_idx,T_idx,:], P_desired, T_desired, wl)
+

From d0090ef502b23b636698622aa5b864dd2737a8fb Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Thu, 6 Dec 2018 18:49:00 -0700
Subject: [PATCH 18/20] prepping to use dictionary

---
 gas_opac/opacity_demo_V2.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/gas_opac/opacity_demo_V2.py b/gas_opac/opacity_demo_V2.py
index 52d55b4..0435eb8 100644
--- a/gas_opac/opacity_demo_V2.py
+++ b/gas_opac/opacity_demo_V2.py
@@ -3,6 +3,8 @@
 # V1.0: Evaluates cross sections at a single P,T point (8th November 2018)
 # V2.0: Evaluates cross sections on a grid of (P,T) points (6th december 2018)
 
+# 2018.12.06 - Modified slightly by liac@umich.edu
+
 import numpy as np
 import h5py
 from scipy.ndimage import gaussian_filter1d as gauss_conv
@@ -322,7 +324,9 @@ def Extract_opacity(chemical_species, P_out, T_out, wl_out, opacity_treatment):
         z_r[k] = closest_index(nu_r[k], nu_grid[0], nu_grid[-1], N_nu)
         
     # Initialise molecular and atomic opacity array, interpolated to output (P,T,wl) grid
-    sigma_stored = np.zeros(shape=(N_species, N_P_out, N_T_out, N_wl_out))
+    # Lia - modified to use a dictionary instead (easier for reference in her codes)
+    #sigma_stored = np.zeros(shape=(N_species, N_P_out, N_T_out, N_wl_out))
+    sigma_stored = dict()
     
     # Evaluate temperature interpolation weighting factor
     y = np.zeros(N_T_out, dtype=np.int)
@@ -342,7 +346,8 @@ def Extract_opacity(chemical_species, P_out, T_out, wl_out, opacity_treatment):
         sigma_pre_inp = P_interpolate_wl_initialise(nu_grid, N_P_out, N_T, N_P, N_wl_out, N_nu_out, log_sigma, x, z_l, z, z_r, b1, b2, calculation_mode)
                 
         # Interplate to desired temperature
-        sigma_stored[q,:,:,:] = T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T)
+        #sigma_stored[q,:,:,:] = T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T)
+        sigma_stored[q] = T_interpolate(N_P_out, N_T_out, N_T, N_wl_out, sigma_pre_inp, T_grid, T_out, y, w_T)
         
         del log_sigma, sigma_pre_inp   # Clear raw cross section to free up memory
         
@@ -411,9 +416,10 @@ def plot_opacity(chemical_species, sigma_stored, P_desired, T_desired, wl_grid):
     #plt.close()
     #plt.show()
 
-    plt.savefig('./cross_sections_' + str(T_desired) + 'K_' + str(P_desired*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
+    #plt.savefig('./cross_sections_' + str(T_desired) + 'K_' + str(P_desired*1000) + 'mbar.pdf', bbox_inches='tight', fmt='pdf', dpi=1000)
 
 
+"""
 #***** Begin main program ***** 
     
 # Specify which molecules you want to extract from the database (full list available in the readme)
@@ -452,4 +458,4 @@ def plot_opacity(chemical_species, sigma_stored, P_desired, T_desired, wl_grid):
 
 # Plot cross sections at the desired P and T
 plot_opacity(chemical_species, cross_sections[:,P_idx,T_idx,:], P_desired, T_desired, wl)
-
+"""

From 884c8a4e3ea99c96ce444096dedeb2481cc024d0 Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Thu, 6 Dec 2018 18:55:55 -0700
Subject: [PATCH 19/20] Wrote function for extracting opacities from a list of
 (p,T) pairs

---
 gas_opac/opacity_demo.py | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/gas_opac/opacity_demo.py b/gas_opac/opacity_demo.py
index 49723d7..642fef4 100644
--- a/gas_opac/opacity_demo.py
+++ b/gas_opac/opacity_demo.py
@@ -325,6 +325,46 @@ def Extract_opacity(chemical_species, P, T, wl_out, opacity_treatment):
     
     return sigma_stored
 
+# Written by Lia for a set of (p,T) values
+def Extract_opacity_PTpairs(chemical_species, P, T, wl_out, opacity_treatment):
+    
+    '''Convienient function to read in all opacities and pre-interpolate
+       them onto the desired pressure, temperature, and wavelength grid'''
+
+    assert len(P) == len(T)
+
+    T_grid, log_P_grid, nu_opac, opac_file = load_db()
+
+    # Initialise molecular and atomic opacity array, interpolated to model wavelength grid
+    #sigma_stored = np.zeros(shape=(N_species, N_wl))
+    # Lia -- Making this a dictionary instead of a numpy array. It's easier to use for plotting.
+    # Later, a 2D numpy array will be faster for summing across a large number of species
+    # But for now, two dozen is not a lot.
+    sigma_stored = dict()
+    
+    #***** Process molecular and atomic opacities *****#
+    
+    # Load molecular and atomic absorption cross sections
+    for q in chemical_species:
+        
+        log_sigma = np.array(opac_file[q + '/log(sigma)']).astype(np.float64)
+        
+        result = np.zeros(shape=(len(P), len(wl_out)))
+        for i in range(len(P)):
+             result[i,:] = _get_one_PT(log_sigma, T_grid, log_P_grid, nu_opac,
+                                       P[i], T[i], wl_out, opacity_treatment)
+        
+        sigma_stored[q] = result
+        
+        del log_sigma   # Clear raw cross section to free up memory
+        
+        print(q + " done")
+    
+    opac_file.close()
+    
+    return sigma_stored
+
+
 def plot_opacity(chemical_species, sigma_stored, P, T, wl_grid, savefig=False, **kwargs):
     
     # Max number of species this can plot is 9 (clustered beyond that!)

From bc3382e5aa0532626c16a5e2646e3e93881b827f Mon Sep 17 00:00:00 2001
From: Lia Corrales <liac@umich.edu>
Date: Fri, 7 Dec 2018 08:15:46 -0700
Subject: [PATCH 20/20] dtau dz profiles made for each gas phase element

---
 notebooks/test_gas_opac.ipynb | 452 +++++++++++++++++++++++++++++++---
 1 file changed, 413 insertions(+), 39 deletions(-)

diff --git a/notebooks/test_gas_opac.ipynb b/notebooks/test_gas_opac.ipynb
index 0d29d32..d688348 100644
--- a/notebooks/test_gas_opac.ipynb
+++ b/notebooks/test_gas_opac.ipynb
@@ -39,13 +39,22 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import opacity_demo as demo"
+    "import astropy.units as u"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "import opacity_demo as demo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -86,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -97,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -154,7 +163,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -186,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -201,25 +210,48 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False,  True, False, False, False, False,\n",
+       "       False, False, False, False, False, False, False, False, False,\n",
+       "       False, False, False, False, False])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "np.array(RMcD_gas_upper) == 'TIO'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/dev/cloudacademyMap\n"
+     ]
+    }
+   ],
    "source": [
     "cd .."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -228,16 +260,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity\n"
+     ]
+    }
+   ],
    "source": [
     "cd ~/Dropbox/Science/cloud-academy/Les_Houches_Cloud_Activity/"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -253,9 +293,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO', 'TIO2', 'TIS', 'SIO', 'SIS', 'SIH', 'H2O', 'H2', 'H2S', 'MGH', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FEH', 'FE(OH)2', 'ALOH', 'ALH', 'AL2O', 'ALO2H', 'CAO', 'CA(OH)2', 'CAS', 'CAOH', 'CAH', 'C2', 'C3', 'C2H', 'C2H2', 'CH4']\n"
+     ]
+    }
+   ],
    "source": [
     "thermo_gas = []\n",
     "for k in thermo.keys():\n",
@@ -267,7 +315,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -283,9 +331,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gases in both static_weather and Ryan's opacity library: (13 total)\n",
+      "['TiO', 'SiO', 'SiH', 'H2O', 'H2', 'H2S', 'MgH', 'FeH', 'AlH', 'CaO', 'CaH', 'C2H2', 'CH4']\n",
+      "\n",
+      "Gases missing opacities: (25 total)\n",
+      "['H', 'Na', 'Mg', 'Fe', 'Ca', 'Al', 'Ti', 'C', 'TIO2', 'TIS', 'SIS', 'MGOH', 'MG(OH)2', 'FEO', 'FES', 'FE(OH)2', 'ALOH', 'AL2O', 'ALO2H', 'CA(OH)2', 'CAS', 'CAOH', 'C2', 'C3', 'C2H']\n"
+     ]
+    }
+   ],
    "source": [
     "print(\"Gases in both static_weather and Ryan's opacity library: ({} total)\".format(len(gases)))\n",
     "print(gases)\n",
@@ -295,9 +355,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/lia/dev/cloudacademyMap/gas_opac\n"
+     ]
+    }
+   ],
    "source": [
     "cd ~/dev/cloudacademyMap/gas_opac"
    ]
@@ -311,9 +379,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading opacity database file\n",
+      "TiO done\n",
+      "SiO done\n",
+      "SiH done\n",
+      "H2O done\n",
+      "H2 done\n",
+      "H2S done\n",
+      "MgH done\n",
+      "FeH done\n",
+      "AlH done\n",
+      "CaO done\n",
+      "CaH done\n",
+      "C2H2 done\n",
+      "CH4 done\n",
+      "CPU times: user 2min, sys: 54.3 s, total: 2min 54s\n",
+      "Wall time: 3min 17s\n"
+     ]
+    }
+   ],
    "source": [
     "%%time\n",
     "sw_xsects = demo.Extract_opacity(np.array(gases), P, T, wavel, opacity_treatment)"
@@ -321,9 +412,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.2, 330)"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plot_opacity(np.array(gases), sw_xsects, P, T, wavel, marker='o', ls=':', alpha=0.5)\n",
     "plt.semilogx()\n",
@@ -332,9 +446,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "304"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "len(thermo['p'])"
    ]
@@ -345,13 +470,17 @@
    "source": [
     "## To do next\n",
     "\n",
-    "* Load opacities for different temperatures. Interpolate densities in each vertical profile to match the temperatures provided in the code.\n",
+    "[x] Load opacities for each (p, T) value\n",
+    "\n",
+    "[x] Calculate dtau_dz for each element and vertical profile.\n",
     "\n",
-    "* Calculate dtau_dz for each element and vertical profile.\n",
+    "[x] Save the dtau_dz profiles to a file.\n",
     "\n",
-    "* Save the dtau_dz profiles to a file.\n",
+    "[ ] Write a function for reading in file.\n",
     "\n",
-    "* Add those dtau_dz values to the atmosphere depth calculation."
+    "[ ] Write a function for summing the gas contributions to dtau/dz.\n",
+    "\n",
+    "[ ] Add those dtau_dz values to the atmosphere depth calculation."
    ]
   },
   {
@@ -363,37 +492,282 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0xb2836d278>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "for g in gases:\n",
-    "    plt.plot(thermo['T'], thermo['n_' + g.upper()])\n",
+    "    plt.plot(thermo['T'], thermo['n_' + g.upper()], label=g)\n",
     "plt.semilogy()\n",
-    "plt.xlim(500, 3000)"
+    "plt.xlim(500, 3000)\n",
+    "plt.xlabel('Temperature (K)')\n",
+    "plt.ylabel('$n_Z$')\n",
+    "plt.legend(loc='lower right', frameon=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Sanity check for pressure, temperature interpolation\n",
     "# Suggested by Ryan\n",
+    "#T0 = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500]\n",
+    "#T1 = np.arange(100, 3000, 50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading opacity database file\n",
+      "TiO done\n",
+      "SiO done\n",
+      "SiH done\n",
+      "H2O done\n",
+      "H2 done\n",
+      "H2S done\n",
+      "MgH done\n",
+      "FeH done\n",
+      "AlH done\n",
+      "CaO done\n",
+      "CaH done\n",
+      "C2H2 done\n",
+      "CH4 done\n",
+      "CPU times: user 6min 11s, sys: 51 s, total: 7min 2s\n",
+      "Wall time: 7min 19s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "opacity_treatment = 'Log-avg'\n",
+    "test = demo.Extract_opacity_PTpairs(np.array(gases), thermo['p'], thermo['T'], wavel, opacity_treatment)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.00000000e+00, 0.00000000e+00, 2.14347212e-22, 4.47281423e-22,\n",
+       "       1.29905700e-21, 3.53249151e-22, 1.04683496e-22, 2.52623100e-23,\n",
+       "       8.56768717e-24, 1.58196485e-24, 9.39862143e-26, 3.68280847e-26,\n",
+       "       2.96488882e-27, 5.33163439e-28, 3.14810018e-29, 3.65333659e-30,\n",
+       "       3.32698108e-30, 1.56147535e-30, 2.14301779e-31, 1.40997078e-29,\n",
+       "       6.98666068e-31, 2.51045302e-27, 2.40541312e-30, 2.66165606e-31,\n",
+       "       5.96403292e-30, 4.35892019e-29, 7.09350429e-33, 8.54948670e-28,\n",
+       "       1.86176468e-34, 1.76090418e-32, 0.00000000e+00])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test['TiO'][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calc_dtau_dz(gas, opac_dict):\n",
+    "    n_z = thermo['n_' + gas.upper()]\n",
+    "    sigma = opac_dict[gas]\n",
+    "    \n",
+    "    NP  = len(n_z) # number of vertical data points\n",
+    "    NWL = len(sigma[0,:]) # number of wavelengths\n",
+    "    \n",
+    "    result = np.zeros(shape=(NP, NWL))\n",
+    "    for i in range(NP):\n",
+    "        result[i,:] = n_z[i] * sigma[i,:] # cm^-1\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dtau_dz = dict()\n",
+    "for g in gases:\n",
+    "    dtau_dz[g] = calc_dtau_dz(g, test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0xb27c64e10>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "iw = 10\n",
+    "p = thermo['p'] * u.dyne / u.cm**2\n",
+    "for g in gases:\n",
+    "    plt.plot(dtau_dz[g][:,iw], p.to(u.bar), label=g)\n",
+    "plt.loglog()\n",
+    "plt.ylim(1.e3, 1.e-6)\n",
+    "plt.xlim(1.e-35, 1.e-8)\n",
+    "plt.xlabel(r'$d\\tau/dz$ (cm$^{-1}$)')\n",
+    "plt.ylabel('p (bar)')\n",
+    "plt.legend(loc='lower left', frameon=False, ncol=3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Make a 3D array and save it\n",
     "\n",
-    "T0 = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500]\n",
-    "T1 = np.arange(100, 3000, 50)"
+    "I'm going to use a FITS file for now. Seems like the simplest thing??"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from astropy.io import fits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def write_opac_fits(opac_dict, filename):\n",
+    "    hdr = fits.Header()\n",
+    "    hdr['COMMENT'] = \"dtau/dz for gas phase elements of HATP-7b\"\n",
+    "    hdr['COMMENT'] = \"Made from opacity tables of R. MacDonald\"\n",
+    "    hdr['COMMENT'] = \"See out3_*.dat files for p, T, and z profiles\"\n",
+    "    \n",
+    "    primary_hdu = fits.PrimaryHDU(header=hdr)\n",
+    "    hdus_to_write = [primary_hdu]\n",
+    "    for k in opac_dict.keys():\n",
+    "        hdus_to_write.append(fits.ImageHDU(opac_dict[k], name=k))\n",
+    "    \n",
+    "    hdu_list = fits.HDUList(hdus=hdus_to_write)\n",
+    "    hdu_list.writeto(filename, overwrite=True)\n",
+    "    return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
-    "test_T0 = demo.Extract_opacity(np.array([gases[0]]), P, T0, wavel, opacity_treatment)"
+    "write_opac_fits(test, 'test.fits')"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tt = fits.open('test.fits')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Filename: test.fits\n",
+      "No.    Name      Ver    Type      Cards   Dimensions   Format\n",
+      "  0  PRIMARY       1 PrimaryHDU       7   ()      \n",
+      "  1  TIO           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  2  SIO           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  3  SIH           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  4  H2O           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  5  H2            1 ImageHDU         8   (31, 304)   float64   \n",
+      "  6  H2S           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  7  MGH           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  8  FEH           1 ImageHDU         8   (31, 304)   float64   \n",
+      "  9  ALH           1 ImageHDU         8   (31, 304)   float64   \n",
+      " 10  CAO           1 ImageHDU         8   (31, 304)   float64   \n",
+      " 11  CAH           1 ImageHDU         8   (31, 304)   float64   \n",
+      " 12  C2H2          1 ImageHDU         8   (31, 304)   float64   \n",
+      " 13  CH4           1 ImageHDU         8   (31, 304)   float64   \n"
+     ]
+    }
+   ],
+   "source": [
+    "tt.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {