From 1ce9ea57774e9e8e5bb15f4a3de27ed25d08f835 Mon Sep 17 00:00:00 2001
From: Christophe LANNOY <christophe.lannoy@hotmail.com>
Date: Thu, 27 Jun 2024 12:14:01 +0200
Subject: [PATCH 1/9] Adding Schottky monitor element

---
 xtrack/monitors/schottky_monitor.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 xtrack/monitors/schottky_monitor.py

diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
new file mode 100644
index 000000000..e69de29bb

From 10458951ce134a76ed4aae50c79e510caffd6b88 Mon Sep 17 00:00:00 2001
From: Christophe LANNOY <christophe.lannoy@hotmail.com>
Date: Fri, 28 Jun 2024 14:31:35 +0200
Subject: [PATCH 2/9] Making some variables private in SchottkyMonitir

---
 xtrack/monitors/schottky_monitor.py | 209 ++++++++++++++++++++++++++++
 1 file changed, 209 insertions(+)

diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
index e69de29bb..231e1dbd2 100644
--- a/xtrack/monitors/schottky_monitor.py
+++ b/xtrack/monitors/schottky_monitor.py
@@ -0,0 +1,209 @@
+import numpy as np
+import scipy as sp
+from scipy.constants import c
+
+class SchottkyMonitor():
+    def __init__(self, f_rev, schottky_harmonic, n_taylor):
+        """
+        Tracking element computing Schottky spectra 
+        Equations based on JINST 19 P03017, C.lannoy  and al.
+
+        Parameters
+        ----------
+        f_rev : float
+                Revolution frequency.
+
+        schottky_harmonic : int
+                Harmonic of the Schottky monitor.
+
+        n_taylor : int
+                Number of term used for the Taylor expansion (4 is enough for LHC conditions).
+        """
+        
+        self.f_rev = f_rev
+        if n_taylor < 1:
+            raise ValueError('At least one coefficient for the Taylor expansion is needed')
+        self.n_taylor = n_taylor
+        # Taylor expantion around central Schottky frequency omega_c
+        self.omega_c = 2 * np.pi * f_rev * schottky_harmonic
+        self.x_coeff, self.y_coeff, self.z_coeff = [], [], []
+        self.initialised_with_first_tracking = False
+
+    def track(self, particles):
+        mask_alive = particles.state > 0
+        tau = -particles.zeta[mask_alive]/(c*particles.beta0[mask_alive])
+
+        # If first time calling the function, store bunch parameters for 
+        # computing the upper bound of the Taylor approximation
+        if not self.initialised_with_first_tracking:
+            self.tau_max = 4* np.std(tau)
+            self.x_max = 4* np.std(particles.x[mask_alive])
+            self.y_max = 4* np.std(particles.y[mask_alive])
+            self.N_macropart_max = len(tau)
+            self.initialised_with_first_tracking = True
+
+        # Calculates the longitudinal and transverse coefficients (L and T) as defined in Eqs (2.2) and (2.4)
+        z_terms = np.empty((self.n_taylor, len(tau)), dtype=np.csingle)
+        z_terms[0,:] = np.exp(1j*self.omega_c*tau)
+        for l in range(1,self.n_taylor):
+            z_terms[l,:] = z_terms[l-1,:]*tau
+
+        self.x_coeff.append(np.sum(z_terms*particles.x[mask_alive], axis=1))
+        self.y_coeff.append(np.sum(z_terms*particles.y[mask_alive], axis=1))
+        self.z_coeff.append(np.sum(z_terms, axis=1))
+
+    def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy, 
+                         x=True, y=True, z=True, flattop_window=True):
+        """
+        Compute Schottky spectra from the stored longitudinal and transverse coefficients
+
+        Parameters
+        ----------
+        inst_spectrum_len : int
+                Number of revolution used to compute a single instataneous spectra.
+                
+        deltaQ : float 
+                Frequency resolution of the spectra (in tune unit).
+
+        band_width : float
+                Range of frequency (in tune unit) where the spectrum will be computed for each band, 
+                should be between 0 and 1.
+
+        Qx, Qy : float
+                Transverse tunes used to set the central frequency around which the 
+                transverse side-bands will be computed. 
+
+        x, y, z: bool
+                Which band are to be computed. x, y, z stand for, respectively, 
+                transverse horizontal, transverse vertical and longitudinal bands.
+
+        flattop_window: bool
+                Multiply time signal by flattop window, else no windowing used (=rectangular window).
+        """
+        
+        if inst_spectrum_len > len(self.x_coeff):
+            raise ValueError(f'Not enough turns tracked to produce a single instataneous spectra \n \
+                               Number of turns tracked: {len(self.x_coeff)} \n \
+                               Length of instataneous spectra: {inst_spectrum_len}')
+        if band_width<0 or band_width>1:
+            raise ValueError('Band_width should be expressed in tune unit and between 0 and 1')
+        
+        # If it's the first time calling the method we need to initialise it.
+        if not hasattr(self, 'processing_param'):
+            self.processing_param = locals()
+            self._init_processing(deltaQ, Qx, Qy, band_width)
+        
+        # Not the first time calling this method, we will append the new instantaneous Schottky PSDs to the 
+        # existing ones. In this case we need to confirm that the processing parameters are identical.
+        elif any(self.processing_param[key] != value
+                 for key, value in locals().items() if key not in ['x', 'y', 'z']):
+            raise ValueError('Different parameters for the processing, ' +
+                             'keep the same parameters (exept x, y and z) or use "clear_spectrum()". \n' +
+                             'Existing parameters:' + str(self.processing_param) + '\n New parameters:' + str(locals()))
+        if flattop_window:
+            window = sp.signal.windows.flattop(inst_spectrum_len)
+        else:
+            window = np.ones(inst_spectrum_len)
+        window /= np.sum(window) # Normalising window
+        
+        region_to_process = []
+        if x: region_to_process.extend(['lowerH', 'upperH'])
+        if y: region_to_process.extend(['lowerV', 'upperV'])
+        if z: region_to_process.extend(['center'])
+
+        for region in region_to_process:
+            freq = self.frequencies[region]
+            if region == 'center':
+                coeff = self.z_coeff
+            elif region == 'lowerH' or region == 'upperH':
+                coeff = self.x_coeff
+            elif region == 'lowerV' or region == 'upperV':
+                coeff = self.y_coeff
+            else:
+                raise ValueError('Frequency region not defined:' + region)
+
+            # Computing instataneous Schottky spectra as defined in Eqs. (2.2) and (2.4)
+            n_freq = len(freq)
+            delta_omega = freq * 2 * np.pi * self.f_rev
+            alpha = np.empty((self.n_taylor,n_freq), dtype=np.csingle)
+            alpha[0,:] = np.ones(n_freq)
+            for l in range(1,self.n_taylor):
+                alpha[l,:] = alpha[l-1,:] * 1j * delta_omega / l
+            first_exponential = (np.vander(np.exp(1j*delta_omega/self.f_rev),
+                                           N=inst_spectrum_len, increasing=True) * window).T  
+            n_inst_spectra = len(coeff) // inst_spectrum_len
+            for i in range(len(self.instantaneous_PSDs[region]), n_inst_spectra):
+                print(f'Processing {region} Schottky spectrum {i+1}/{n_inst_spectra}', end='\r')
+                # Seclecting the coefficient (x, y, or z) needed to calculated the i^th instataneous Schottky spectra
+                inst_coeff = np.array(coeff[i*inst_spectrum_len:(i+1)*inst_spectrum_len])
+                spectrum = np.sum(np.dot(inst_coeff,alpha) * first_exponential, axis=0)
+                self.instantaneous_PSDs[region].append(abs(spectrum)**2 / self.N_macropart_max)
+            self.PSD_avg[region] = np.mean(self.instantaneous_PSDs[region], axis=0)
+            print(f'{region} band of Schottky spectrum processed')
+        self._check_Taylor_approx()
+
+    def _init_processing(self, deltaQ, Qx, Qy, band_width):
+        '''
+        For each region of the Schottky spectrum, create an array of normalised frequencies 
+        from -band_with/2 to +band_with/2 around the center of the Schottky band. 
+        '''
+        n_freq = band_width/deltaQ
+        center_freq = np.arange(-(n_freq//2), (n_freq)//2) * band_width / n_freq
+        self.frequencies = {
+            'lowerH': center_freq - (Qx%1),
+            'upperH': center_freq + (Qx%1),
+            'lowerV': center_freq - (Qy%1),
+            'upperV': center_freq + (Qy%1),
+            'center': center_freq
+        }
+        # Create dic where the instataneous and averaged PSDs will be stored
+        self.instantaneous_PSDs = {i: [] for i in self.frequencies.keys()}
+        self.PSD_avg = {i: [] for i in self.frequencies.keys()}
+
+    def _check_Taylor_approx(self):
+        #Longitudinal band, Eq. (2.3)
+        if self.processing_param['z']:
+            delta_omega_max = max(self.frequencies['center']) * 2 * np.pi * self.f_rev
+            max_error = self.N_macropart_max**0.5 * (delta_omega_max*self.tau_max)**self.n_taylor * \
+                        np.exp(delta_omega_max*self.tau_max) / np.math.factorial(self.n_taylor)
+            if np.sqrt(self.PSD_avg['center'][0]) < 100 * max_error:
+                print('Number of Taylor terms too low for the longitudinal band')
+            print(f'Maximal Talor truncation error in z plane to be compared against sqrt(PSD): {max_error}')
+
+        #transverse bands
+        if self.processing_param['x']:
+            delta_omega_max = max(self.frequencies['upperH']) * 2 * np.pi * self.f_rev
+            max_error = self.N_macropart_max**0.5 * self.x_max * (delta_omega_max*self.tau_max)**self.n_taylor * \
+                        np.exp(delta_omega_max*self.tau_max) / np.math.factorial(self.n_taylor)
+            if np.sqrt(self.PSD_avg['upperH'][0]) < 100 * max_error:
+                print('Number of Taylor terms too low for the horizontal bands')
+            print(f'Maximal Talor truncation error in x plane to be compared against sqrt(PSD): {max_error}')
+        if self.processing_param['y']:
+            delta_omega_max = max(self.frequencies['upperV']) * 2 * np.pi * self.f_rev
+            max_error = self.N_macropart_max**0.5 * self.y_max * (delta_omega_max*self.tau_max)**self.n_taylor * \
+                        np.exp(delta_omega_max*self.tau_max) / np.math.factorial(self.n_taylor)
+            if np.sqrt(self.PSD_avg['upperV'][0]) < 100 * max_error:
+                print('Number of Taylor terms too low for the vertical bands')
+            print(f'Maximal Talor truncation error in y plane to be compared against sqrt(PSD): {max_error}')
+
+    def clear_spectrum(self):
+        """
+        Clear the instantaneous spectra but keep the coefficients L and T.
+        Can be use to recompute Schottky spectra for different processing 
+        parameters (window, frequency resolution, band widths) without 
+        tracking the particles agan
+        """
+        if hasattr(self, 'processing_param'):
+            delattr(self, 'processing_param')
+            delattr(self, 'frequencies')
+            delattr(self, 'instantaneous_PSDs')
+            delattr(self, 'PSD_avg')
+
+    def clear_all(self):
+        """
+        Reinitialise monitor
+        """
+        self.clear_spectrum()
+        self.x_coeff = []
+        self.y_coeff = []
+        self.z_coeff = []
\ No newline at end of file

From 8a072f093f7c02c38d5e1b77d8e48229ed099648 Mon Sep 17 00:00:00 2001
From: Christophe LANNOY <christophe.lannoy@hotmail.com>
Date: Fri, 28 Jun 2024 14:33:43 +0200
Subject: [PATCH 3/9] Making the SchottkyMonitor class importable

---
 xtrack/monitors/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/xtrack/monitors/__init__.py b/xtrack/monitors/__init__.py
index d8bf6d53d..e315b5a07 100644
--- a/xtrack/monitors/__init__.py
+++ b/xtrack/monitors/__init__.py
@@ -4,5 +4,6 @@
 from .beam_position_monitor import *
 from .beam_size_monitor import *
 from .beam_profile_monitor import *
+from .schottky_monitor import *
 
 monitor_classes = tuple(v for v in globals().values() if isinstance(v, type) and issubclass(v, BeamElement))

From 3262c231f29c3cdc740dbb534a6ba235a4a8ea3e Mon Sep 17 00:00:00 2001
From: Christophe LANNOY <christophe.lannoy@hotmail.com>
Date: Fri, 28 Jun 2024 16:05:21 +0200
Subject: [PATCH 4/9] Adding notebook example for Schottky monitor

---
 examples/monitor/005_schottky_monitor.ipynb | 456 ++++++++++++++++++++
 1 file changed, 456 insertions(+)
 create mode 100644 examples/monitor/005_schottky_monitor.ipynb

diff --git a/examples/monitor/005_schottky_monitor.ipynb b/examples/monitor/005_schottky_monitor.ipynb
new file mode 100644
index 000000000..9b63c87f7
--- /dev/null
+++ b/examples/monitor/005_schottky_monitor.ipynb
@@ -0,0 +1,456 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0d0d094d-1239-4d1f-a1ec-eeb9e2e68c0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xtrack as xt\n",
+    "import xpart as xp\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2770ec4-ce5c-4521-bc12-9df7bcaccd11",
+   "metadata": {},
+   "source": [
+    "Create a simple model of the LHC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f00c683a-5c06-4f62-a6cf-e6ebd6ca662c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lmap = xt.LineSegmentMap(length=26658.8831999989, qx=0.27, qy=0.295, dqx=15, dqy=15, longitudinal_mode='nonlinear',\n",
+    "    voltage_rf=4e6, frequency_rf=400e6, lag_rf=180, momentum_compaction_factor=3.225e-04, betx=1, bety=1)\n",
+    "line = xt.Line(elements=[lmap])\n",
+    "line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, energy0=450e9)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e79c5557-4a34-4b26-bddb-8e705e9dfcba",
+   "metadata": {},
+   "source": [
+    "Compute the revolution period needed by the Schottky monitor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "61387be6-6111-48fb-8ee3-a617726fb576",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling ContextCpu kernels...\n",
+      "Done compiling ContextCpu kernels.\n"
+     ]
+    }
+   ],
+   "source": [
+    "twiss = line.twiss()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0aac7240-6a17-40cb-930c-bd5379ae31d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1/twiss.T_rev0, schottky_harmonic=427_725, n_taylor=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9b8ddd1e-e825-4ecc-8783-f477dafc8119",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling ContextCpu kernels...\n",
+      "Done compiling ContextCpu kernels.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<xtrack.tracker.Tracker at 0x7f4a502d86b0>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "line.discard_tracker()\n",
+    "line.append_element(element=schottky_monitor, name='Schottky monitor')\n",
+    "line.build_tracker()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5798208-76ff-4a9e-8aca-a7976360e7f9",
+   "metadata": {},
+   "source": [
+    "Create a bunch of particles and track them for 10k turns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "91d46d45-5857-439d-8a77-1f1a4ec2dc8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring collective elements in particles generation.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "*** Maximum RMS bunch length 0.11812759635051139m.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/clannoy/miniconda3/lib/python3.12/site-packages/scipy/integrate/_quadpack_py.py:1272: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n",
+      "  quad_r = quad(f, low, high, args=args, full_output=self.full_output,\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "... distance to target bunch length: -7.0000e-02\n",
+      "... distance to target bunch length: 4.4864e-02\n",
+      "... distance to target bunch length: 3.8881e-02\n",
+      "... distance to target bunch length: 8.5600e-03\n",
+      "... distance to target bunch length: -9.3055e-03\n",
+      "... distance to target bunch length: 4.5506e-04\n",
+      "... distance to target bunch length: -8.6681e-06\n",
+      "... distance to target bunch length: 2.2793e-08\n",
+      "... distance to target bunch length: -3.4673e-07\n",
+      "--> Bunch length: 0.07000002279329717\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring collective elements in particles generation.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--> Emittance: 0.2489315037483315\n"
+     ]
+    }
+   ],
+   "source": [
+    "bunch = xp.generate_matched_gaussian_bunch(num_particles=int(1e4), nemitt_x=1.5e-6, nemitt_y=1.5e-6, line=line, total_intensity_particles=1e11, sigma_z=7e-2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "4a06372e-d6ec-4943-b5e1-67fde8df3f11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Tracking:   0%|                                                                    | 0/10000 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Compiling ContextCpu kernels...\n",
+      "Done compiling ContextCpu kernels.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Tracking: 100%|███████████████████████████████████████████████████████| 10000/10000 [00:26<00:00, 372.13it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "line.track(bunch, num_turns=10000, with_progress=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe18ecff-2548-4580-97da-bc62d8c3b4d7",
+   "metadata": {},
+   "source": [
+    "Process the data to build Schottky spectrum"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f9b193fe-5c4d-48e6-9f65-293d62707523",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lowerH band of Schottky spectrum processed\n",
+      "upperH band of Schottky spectrum processed\n",
+      "center band of Schottky spectrum processed\n",
+      "Maximal Talor truncation error in z plane to be compared against sqrt(PSD): 3.80657433491217e-20\n",
+      "Maximal Talor truncation error in x plane to be compared against sqrt(PSD): 5.190120322201753e-22\n"
+     ]
+    }
+   ],
+   "source": [
+    "schottky_monitor.process_spectrum(inst_spectrum_len=10000, deltaQ=5e-5, band_width=0.3, Qx=0.27, Qy=0.295, x=True, y=False, z=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc18ccda-9ec8-4429-b33a-c956ccf8f480",
+   "metadata": {},
+   "source": [
+    "Since we only tracked 10_000 turns we have a single instataneous spectra"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "177a7ef3-9356-4faa-92cd-cdd6135a4c01",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKYAAAGGCAYAAABBiol3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACPhklEQVR4nO3deVxVZf4H8M+9LBdcwJVFQtE0l1wgTcIWbaKQGkenphzrF+aUTY3MVGQW5ZJaoeVWk0nZqDllWk7aomlGkaWoiWLuiqKgsojKLtu9z+8P4nrPuTvc/X7er9ed4Z77nHOeI/R87/k+y1EIIQSIiIiIiIiIiIgcTOnsChARERERERERkXdiYoqIiIiIiIiIiJyCiSkiIiIiIiIiInIKJqaIiIiIiIiIiMgpmJgiIiIiIiIiIiKnYGKKiIiIiIiIiIicgokpIiIiIiIiIiJyCiamiIiIiIiIiIjIKZiYIiIiIiIiIiIip2BiioiIiIiIiIiInMKrE1Pbt2/HmDFj0K1bNygUCmzcuNHp5xNCYObMmQgPD0dgYCDi4+Nx8uRJu9aLiIiIiIhsj/cbRETmeXViqrq6GkOGDMHSpUtd5nxvvvkm3nnnHaSnp2P37t1o27YtEhISUFtb65A6EhERERGRbfB+g4jIPIUQQji7Eq5AoVBgw4YNGDdunHZbXV0dXnnlFXz66acoKyvDwIEDMX/+fIwaNcou5xNCoFu3bnj++ecxdepUAEB5eTlCQ0OxatUq/PWvf231eYmIiIiIyPF4v0FEZJhXj5gyJzk5GVlZWVi7di1+++03PPjggxg9erTdhrrm5eWhqKgI8fHx2m3BwcGIjY1FVlaWXc5JRERERETOwfsNIiImpozKz8/HypUr8fnnn+P222/H9ddfj6lTp+K2227DypUr7XLOoqIiAEBoaKhke2hoqPYzIiIiIiJyf7zfICJqwsSUEQcPHoRarcYNN9yAdu3aaV8//fQTTp06BQA4duwYFAqFyddLL73k5CshIiIiIiJXw/sNIqImvs6ugKuqqqqCj48PsrOz4ePjI/msXbt2AIBevXrh6NGjJo/TuXNni88ZFhYGACguLkZ4eLh2e3FxMaKjoy0+DhERERERuTbebxARNWFiyoiYmBio1WqUlJTg9ttvN1jG398f/fr1s9k5e/bsibCwMGRkZGgDQ0VFBXbv3o2nn37aZuchIiIiIiLn4v0GEVETr05MVVVVITc3V/s+Ly8POTk56NSpE2644QY88sgjSEpKwsKFCxETE4OLFy8iIyMDgwcPxn333WfT83Xv3h0KhQLPPvssXnvtNfTp0wc9e/bEjBkz0K1bN8nTNIiIiIiIyPXxfoOIyDyFEEI4uxLOkpmZiTvvvFNv+8SJE7Fq1So0NDTgtddew+rVq3H+/Hl06dIFt9xyC2bPno1BgwbZ/HxA0yNcZ82ahQ8++ABlZWW47bbb8N577+GGG26w+nxEREREROQ8vN8gIjLPqxNTRERERERERETkPHwqHxEREREREREROQUTU0RERERERERE5BRet/i5RqPBhQsX0L59eygUCmdXh4jIKYQQqKysRLdu3aBUso/CFMYNIiLGDWswbhARWRc3vC4xdeHCBURGRjq7GkRELqGgoADXXXeds6vh0hg3iIiuYdwwj3GDiOgaS+KG1yWm2rdvD6DpHycoKMjJtSEico6KigpERkZq20QyjnGDiIhxwxqMG0RE1sUNr0tMNQ+nDQoKYqAgIq/HKQbmMW4QEV3DuGEe4wYR0TWWxA1OECciIiIiIiIiIqdgYoqIiIiIiIiIiJyCiSkiIiIiIiIiInIKJqaIiIiIiIiIiMgpmJgiIiIiIiIiIiKnYGKKiIiIiIiIiIicwqmJqWXLlmHw4MHaR6nGxcXh22+/NVp+1apVUCgUkldAQIADa0xERERERERERLbi68yTX3fddZg3bx769OkDIQQ++ugjjB07Fvv378eNN95ocJ+goCAcP35c+16hUDiqukREREREREREZENOTUyNGTNG8v7111/HsmXLsGvXLqOJKYVCgbCwMEdUj4iIiIiIiIiI7Mhl1phSq9VYu3YtqqurERcXZ7RcVVUVevTogcjISIwdOxaHDx82edy6ujpUVFRIXkRERERERERE5HxOT0wdPHgQ7dq1g0qlwlNPPYUNGzZgwIABBsv27dsXK1aswJdffomPP/4YGo0GI0aMwLlz54wePy0tDcHBwdpXZGSkvS6FyCJlNfV4YNlO/DfrjLOrQkREbmhP3mWM+fcv2J9/xdlVISIiG/n6wAWMXboD567UOLsqRA6nEEIIZ1agvr4e+fn5KC8vx/r16/Hhhx/ip59+Mpqc0tXQ0ID+/ftjwoQJmDt3rsEydXV1qKur076vqKhAZGQkysvLERQUZLPrILLUom0n8E7GSQDAmXn3Obk25K0qKioQHBzMttAC/LciR6tv1OCJ1XsR27MTptzZW+/zXqmboBGAj1KBU2/c64QakjdiW2g5/ltRS0S9tAkAMKpvV6yaNNzJtSFqPWvaQqeuMQUA/v7+6N276UvX0KFD8euvv+Ltt9/G+++/b3ZfPz8/xMTEIDc312gZlUoFlUpls/oStdbV+kZnV4GIiFzYxpzz2H7iIrafuGgwMaX5vUtRrXFq3yIREdlBZS3vFcj7OH0qn5xGo5GMcDJFrVbj4MGDCA8Pt3OtiIiIiByj4mqDs6tARERO4uQJTURO4dQRU6mpqUhMTET37t1RWVmJNWvWIDMzE1u3bgUAJCUlISIiAmlpaQCAOXPm4JZbbkHv3r1RVlaGt956C2fPnsUTTzzhzMsgsopCoXB2FYiIiIiIiIhcglMTUyUlJUhKSkJhYSGCg4MxePBgbN26FXfffTcAID8/H0rltUFdV65cweTJk1FUVISOHTti6NCh2Llzp0XrURERERERERERkWtxamLqP//5j8nPMzMzJe8XL16MxYsX27FGRPbH8VJERERERERETVxujSkiIiIiIiIib8QVpsgbMTFFREREREREREROwcQUkaNxLh8REZnABzIRERGRN2FiioiIiIiIiIiInIKJKSIiIiIiIiIXwFGz5I2YmCJyMAXn8hERkQkKhgkiIiLyIkxMETkYbziIiMgU9pYTERGRN2FiioiIiIiIiIiInIKJKSIiIiIiIiIXwEGz5I2YmCJyMM7kIyIiIiIiImrCxBQRERERERERETkFE1NEREREREREROQUTEwRORifykdERETkGNu3b8eYMWPQrVs3KBQKbNy40WT5L774AnfffTe6du2KoKAgxMXFYevWrY6pLBHAR7OSV2JiioiIXMrSpUsRFRWFgIAAxMbGYs+ePUbLLl++HLfffjs6duyIjh07Ij4+Xq/8Y489BoVCIXmNHj3a3pdB1GKCS98S2Ux1dTWGDBmCpUuXWlR++/btuPvuu7F582ZkZ2fjzjvvxJgxY7B//34715SIyHv5OrsCREREzdatW4eUlBSkp6cjNjYWS5YsQUJCAo4fP46QkBC98pmZmZgwYQJGjBiBgIAAzJ8/H/fccw8OHz6MiIgIbbnRo0dj5cqV2vcqlcoh10NERM6VmJiIxMREi8svWbJE8v6NN97Al19+ia+//hoxMTE2rh0REQEcMUVERC5k0aJFmDx5MiZNmoQBAwYgPT0dbdq0wYoVKwyW/+STT/CPf/wD0dHR6NevHz788ENoNBpkZGRIyqlUKoSFhWlfHTt2dMTlELWIgs9vJXIZGo0GlZWV6NSpk7OrQkTksZiYIiIil1BfX4/s7GzEx8drtymVSsTHxyMrK8uiY9TU1KChoUHvBiIzMxMhISHo27cvnn76aVy6dMmmdSeyJU7lI3IdCxYsQFVVFR566CGjZerq6lBRUSF5EbUUIwB5IyamiIjIJZSWlkKtViM0NFSyPTQ0FEVFRRYd48UXX0S3bt0kya3Ro0dj9erVyMjIwPz58/HTTz8hMTERarXa4DF4g0FERACwZs0azJ49G5999pnB6eTN0tLSEBwcrH1FRkY6sJZERO6Pa0wREZFHmDdvHtauXYvMzEwEBARot//1r3/V/jxo0CAMHjwY119/PTIzM3HXXXfpHSctLQ2zZ892SJ2JiMg1rV27Fk888QQ+//xzSWeHIampqUhJSdG+r6ioYHKKiMgKHDFFREQuoUuXLvDx8UFxcbFke3FxMcLCwkzuu2DBAsybNw/fffcdBg8ebLJsr1690KVLF+Tm5hr8PDU1FeXl5dpXQUGBdRdCRERu7dNPP8WkSZPw6aef4r777jNbXqVSISgoSPIiIiLLMTFFREQuwd/fH0OHDpUsXN68kHlcXJzR/d58803MnTsXW7ZswbBhw8ye59y5c7h06RLCw8MNfs4bDCIiz1FVVYWcnBzk5OQAAPLy8pCTk4P8/HwATZ0RSUlJ2vJr1qxBUlISFi5ciNjYWBQVFaGoqAjl5eXOqD4RkVdgYoqIiFxGSkoKli9fjo8++ghHjx7F008/jerqakyaNAkAkJSUhNTUVG35+fPnY8aMGVixYgWioqK0NxBVVVUAmm5IXnjhBezatQtnzpxBRkYGxo4di969eyMhIcEp10hERI6zd+9exMTEICYmBkBTnImJicHMmTMBAIWFhdokFQB88MEHaGxsxJQpUxAeHq59PfPMM06pPxGRN+AaU0RE5DLGjx+PixcvYubMmSgqKkJ0dDS2bNmiXRA9Pz8fSuW1PpVly5ahvr4ef/nLXyTHmTVrFl599VX4+Pjgt99+w0cffYSysjJ069YN99xzD+bOnQuVSuXQayMiIscbNWoUhDD+nLNVq1ZJ3mdmZtq3QkREpIeJKSIicinJyclITk42+Jn8huHMmTMmjxUYGIitW7faqGZERERERGRrnMpHREREREREREROwcQUERERERERERE5BRNTRERERC7ExHI4RERERB6HiSkiIiIiIiIiF8DOCfJGTEwREREREREREZFTODUxtWzZMgwePBhBQUEICgpCXFwcvv32W5P7fP755+jXrx8CAgIwaNAgbN682UG1JSIiIiIiIrIfhcLZNSByPKcmpq677jrMmzcP2dnZ2Lt3L/7whz9g7NixOHz4sMHyO3fuxIQJE/D4449j//79GDduHMaNG4dDhw45uOZEREREREREtsWpfOSNnJqYGjNmDO6991706dMHN9xwA15//XW0a9cOu3btMlj+7bffxujRo/HCCy+gf//+mDt3Lm666Sa8++67Dq45ERERERERERG1lsusMaVWq7F27VpUV1cjLi7OYJmsrCzEx8dLtiUkJCArK8vocevq6lBRUSF5ERERERERERGR8zk9MXXw4EG0a9cOKpUKTz31FDZs2IABAwYYLFtUVITQ0FDJttDQUBQVFRk9flpaGoKDg7WvyMhIm9afiIiIiIiIiIhaxumJqb59+yInJwe7d+/G008/jYkTJ+LIkSM2O35qairKy8u1r4KCApsdm4iIiIiIiIiIWs7X2RXw9/dH7969AQBDhw7Fr7/+irfffhvvv/++XtmwsDAUFxdLthUXFyMsLMzo8VUqFVQqlW0rTUREREREREREreb0EVNyGo0GdXV1Bj+Li4tDRkaGZNu2bduMrklF5Ir4pA0iIjKFYYKIiIi8iVNHTKWmpiIxMRHdu3dHZWUl1qxZg8zMTGzduhUAkJSUhIiICKSlpQEAnnnmGYwcORILFy7Efffdh7Vr12Lv3r344IMPnHkZRERERERERETUAk5NTJWUlCApKQmFhYUIDg7G4MGDsXXrVtx9990AgPz8fCiV1wZ1jRgxAmvWrMH06dPx8ssvo0+fPti4cSMGDhzorEsgsppC4ewaEBEREREREbkGpyam/vOf/5j8PDMzU2/bgw8+iAcffNBONSIiIiJyLvZfEBF5L8EJ3eSFXG6NKSIiIiJvxlsSIiIi8iZMTBERERERERG5AAXHzZIXYmKKiIiIiIiIyAVwKh95IyamiIiIiIiIiIjIKZiYIiIiIiIiIiIip2BiioiIiIiIiIiInIKJKSIHE5w2TkREJjBOEBERkTdhYoqIiIiIiIiIiJyCiSkiB1PwCbBERGQC4wQRERF5EyamiByMUzSIiIiIiIiImjAxRURERORC2IFBROS9GAPIGzExReRgnKJBRERERERE1ISJKSIiIiIiIiIXwE5s8kZMTBE5GIfnEhERERGRIbxXIG/ExBQRERERERGRF9FomAEj18HEFJGDcXguERERkWNs374dY8aMQbdu3aBQKLBx40az+2RmZuKmm26CSqVC7969sWrVKrvXk8iR3svMRfSc75BbUunsqhABYGKKyOE4PJeIiIjIMaqrqzFkyBAsXbrUovJ5eXm47777cOeddyInJwfPPvssnnjiCWzdutXONSVynDe3HEdFbSNe23TU2VUhAgD4OrsCRERERERE9pCYmIjExESLy6enp6Nnz55YuHAhAKB///745ZdfsHjxYiQkJNirmkROwQ5zchUcMUXkYJzKR0REROSasrKyEB8fL9mWkJCArKwso/vU1dWhoqJC8iJyB8xLkatgYorIwdgzQUREROSaioqKEBoaKtkWGhqKiooKXL161eA+aWlpCA4O1r4iIyMdUVWiVhO8MSEXwcQUERERkQsR7MMmciupqakoLy/XvgoKCpxdJSKLMC9FroJrTBERERG5EYWCNxNE9hIWFobi4mLJtuLiYgQFBSEwMNDgPiqVCiqVyhHVI7IpdoSQq+CIKSIiIiIXogAXIyRylri4OGRkZEi2bdu2DXFxcU6qEXkbR3Y8sJODXAUTU0REREQuxFwPNtNWRJarqqpCTk4OcnJyAAB5eXnIyclBfn4+gKZpeElJSdryTz31FE6fPo1p06bh2LFjeO+99/DZZ5/hueeec0b1ieyKiSlyFUxMERGRS1m6dCmioqIQEBCA2NhY7Nmzx2jZ5cuX4/bbb0fHjh3RsWNHxMfH65UXQmDmzJkIDw9HYGAg4uPjcfLkSXtfBhERuYC9e/ciJiYGMTExAICUlBTExMRg5syZAIDCwkJtkgoAevbsiU2bNmHbtm0YMmQIFi5ciA8//BAJCQlOqT95Hz7Bm7wR15gicjAGGyLj1q1bh5SUFKSnpyM2NhZLlixBQkICjh8/jpCQEL3ymZmZmDBhAkaMGIGAgADMnz8f99xzDw4fPoyIiAgAwJtvvol33nkHH330EXr27IkZM2YgISEBR44cQUBAgKMvkYiIHGjUqFEmnzy2atUqg/vs37/fjrUiMo6jmMgbccQUkYMx2BAZt2jRIkyePBmTJk3CgAEDkJ6ejjZt2mDFihUGy3/yySf4xz/+gejoaPTr1w8ffvghNBqNdn0QIQSWLFmC6dOnY+zYsRg8eDBWr16NCxcuYOPGjQ68MiIiIiIiMoSJKSIicgn19fXIzs5GfHy8dptSqUR8fDyysrIsOkZNTQ0aGhrQqVMnAE1riRQVFUmOGRwcjNjYWIuPSeRqFBx6S0TksRzZxDOckKvgVD4iInIJpaWlUKvVCA0NlWwPDQ3FsWPHLDrGiy++iG7dumkTUUVFRdpjyI/Z/JlcXV0d6urqtO8rKiosvgYiRzA1LYmIiNwbm3jyRk4dMZWWloabb74Z7du3R0hICMaNG4fjx4+b3GfVqlVQKBSSF9cIISKiefPmYe3atdiwYUOr4kJaWhqCg4O1r8jISBvWkoiIiIiIdDk1MfXTTz9hypQp2LVrF7Zt24aGhgbcc889qK6uNrlfUFAQCgsLta+zZ886qMZERGQvXbp0gY+PD4qLiyXbi4uLERYWZnLfBQsWYN68efjuu+8wePBg7fbm/aw5ZmpqKsrLy7WvgoKCllwOUYuZ6y3nVD4iIiLyJE6dyrdlyxbJ+1WrViEkJATZ2dm44447jO6nUCjM3qQQEZF78ff3x9ChQ5GRkYFx48YBgHYh8+TkZKP7vfnmm3j99dexdetWDBs2TPJZz549ERYWhoyMDERHRwNompq3e/duPP300waPp1KpoFKpbHJNRERERERkmkutMVVeXg4A2kVrjamqqkKPHj2g0Whw00034Y033sCNN95osCzXCiEich8pKSmYOHEihg0bhuHDh2PJkiWorq7GpEmTAABJSUmIiIhAWloaAGD+/PmYOXMm1qxZg6ioKO26Ue3atUO7du2gUCjw7LPP4rXXXkOfPn3Qs2dPzJgxA926ddMmv4hcDQdEERGRI3A9K3IVLpOY0mg0ePbZZ3Hrrbdi4MCBRsv17dsXK1aswODBg1FeXo4FCxZgxIgROHz4MK677jq98mlpaZg9e7Y9q05ERDYyfvx4XLx4ETNnzkRRURGio6OxZcsW7eLl+fn5UCqvzUJftmwZ6uvr8Ze//EVynFmzZuHVV18FAEybNg3V1dV48sknUVZWhttuuw1btmzh+oRERETkcpgrIm/kMompKVOm4NChQ/jll19MlouLi0NcXJz2/YgRI9C/f3+8//77mDt3rl751NRUpKSkaN9XVFRwIVsiIheWnJxsdOpeZmam5P2ZM2fMHk+hUGDOnDmYM2eODWpHZH/swSYiIkfgCF1yFS6RmEpOTsY333yD7du3Gxz1ZIqfnx9iYmKQm5tr8HOuFUJERERERETugLki8kZOfSqfEALJycnYsGEDfvjhB/Ts2dPqY6jVahw8eBDh4eF2qCERERERERGRYzQPmj10vhyf7smH4DBa8gJOHTE1ZcoUrFmzBl9++SXat2+vXbQ2ODgYgYGBAPQXup0zZw5uueUW9O7dG2VlZXjrrbdw9uxZPPHEE067DiIiIiIiIiJb+eO/m5a46RDoh8RBHIRBns2pI6aWLVuG8vJyjBo1CuHh4drXunXrtGXy8/NRWFiofX/lyhVMnjwZ/fv3x7333ouKigrs3LkTAwYMcMYlEBEREREREdnF0aJKZ1eByO6cOmLKkmGJ8oVuFy9ejMWLF9upRkRERERERERE5ChOHTFFRERERNbhwrhERETkSSwaMVVRUWH1gYOCgqzeh4iIXB9jAhER2RpjCxGR97IoMdWhQwcoFJb3zykUCpw4cQK9evVqccWIiMg1MSYQEZGtMbYQEXkvi9eYWr9+PTp16mS2nBAC9957b6sqRUREro0xgYiIbI2xhYjIO1mUmOrRowfuuOMOdO7c2aKD9urVC35+fq2qGBERuSbGBCIisjXGFiIi72VRYiovL8+qgx46dKhFlSEiItfHmEBERLbG2ELUxJIn1xN5Gps8la+srMwWhyEiIg/AmEBERLbG2EJke1Ys60ZkV1YnpubPn49169Zp3z/00EPo3LkzIiIicODAAZtWjoiIXBtjAhER2RpjC3kzax4C0FocnEWuwurEVHp6OiIjIwEA27Ztw7Zt2/Dtt98iMTERL7zwgs0rSERErosxgYiIbI2xhbwZp/KRN7L4qXzNioqKtIHim2++wUMPPYR77rkHUVFRiI2NtXkFiYjIdTEmEBGRrTG2EBF5F6tHTHXs2BEFBQUAgC1btiA+Ph5AU2ZXrVbbtnZEROTSGBOIHI9rgpCnY2whb+bIqXxErsLqEVP3338/Hn74YfTp0weXLl1CYmIiAGD//v3o3bu3zStIRESuizGByPE4y4M8HWMLeTNO5SNvZHViavHixYiKikJBQQHefPNNtGvXDgBQWFiIf/zjHzavIBERuS7GBCIisjXGFiIi72J1YiorKwvPPvssfH2lu/7zn//Ezp07bVYxIiJyfYwJRI7HWR7k6RhbiByD8YRchdVrTN155524fPmy3vby8nLceeedNqkUERG5B8YEItvjNA7ydowtRETexerElBDC4IJsly5dQtu2bW1SKSJPxtsN8iSMCUREZGuMLURE3sXiqXz3338/gKanBDz22GNQqVTaz9RqNX777TeMGDHC9jUkIiKXw5hAZD98IhN5K8YWIn2MCOQNLE5MBQcHA2jqwWjfvj0CAwO1n/n7++OWW27B5MmTbV9DIg/D4EKegDGByH44lY+8FWMLEZF3sjgxtXLlSgBAVFQUpk6dymG0RERejDGBiIhszV6xZenSpXjrrbdQVFSEIUOG4N///jeGDx9utPySJUuwbNky5Ofno0uXLvjLX/6CtLQ0BAQE2KQ+REQkZfVT+WbNmmWPehARkRtiTCAiIluzZWxZt24dUlJSkJ6ejtjYWCxZsgQJCQk4fvw4QkJC9MqvWbMGL730ElasWIERI0bgxIkTeOyxx6BQKLBo0SKb1YvIUhxDS97AosTUTTfdhIyMDHTs2BExMTEm1z7Yt2+fzSpHRESuhzGByLkUUIC3KuRp7BVbFi1ahMmTJ2PSpEkAgPT0dGzatAkrVqzASy+9pFd+586duPXWW/Hwww8DaBq9NWHCBOzevdvKKyIiIktZlJgaO3asdvHBcePG2bM+RETk4hgTiJxLMClFHsgesaW+vh7Z2dlITU3VblMqlYiPj0dWVpbBfUaMGIGPP/4Ye/bswfDhw3H69Gls3rwZjz76qNHz1NXVoa6uTvu+oqLCJvUnArg+LXkHixJTusNpOW2DqHV4O0HujjGBiIhszR6xpbS0FGq1GqGhoZLtoaGhOHbsmMF9Hn74YZSWluK2226DEAKNjY146qmn8PLLLxs9T1paGmbPnm2TOhMReSOr15hqVl9fj5KSEmg0Gsn27t27t7pSRETkXhgTiByHU/nIWzgjtmRmZuKNN97Ae++9h9jYWOTm5uKZZ57B3LlzMWPGDIP7pKamIiUlRfu+oqICkZGRdqsjEZGnsToxdeLECTz++OPYuXOnZLsQAgqFAmq12maVI/JEHI5LnoQxgYiIbM1WsaVLly7w8fFBcXGxZHtxcTHCwsIM7jNjxgw8+uijeOKJJwAAgwYNQnV1NZ588km88sorUCqVevuoVCrtNEQiIrKe1YmpSZMmwdfXF9988w3Cw8NNLkxIRPrYx02ehDGByPG4xhR5OlvFFn9/fwwdOhQZGRnadas0Gg0yMjKQnJxscJ+amhq95JOPjw+ApsQYERHZntWJqZycHGRnZ6Nfv372qA8REbkRxgQiIrI1W8aWlJQUTJw4EcOGDcPw4cOxZMkSVFdXa5/Sl5SUhIiICKSlpQEAxowZg0WLFiEmJkY7lW/GjBkYM2aMNkFFRES2ZXViasCAASgtLbVHXYi8AseTkCdhTCCyPXODMrjGFHk6W8aW8ePH4+LFi5g5cyaKiooQHR2NLVu2aBdEz8/Pl4yQmj59OhQKBaZPn47z58+ja9euGDNmDF5//XWb1IeIiPRZnZiaP38+pk2bhjfeeAODBg2Cn5+f5POgoCCbVY7IE/FWgjwJYwIREdmarWNLcnKy0al7mZmZkve+vr6YNWsWnzpLTsMZo+SNrE5MxcfHAwDuuusuyfaWLHSblpaGL774AseOHUNgYCBGjBiB+fPno2/fvib3+/zzzzFjxgycOXMGffr0wfz583HvvfdaeylERNRKtowJREREAGMLEZG3sTox9eOPP9rs5D/99BOmTJmCm2++GY2NjXj55Zdxzz334MiRI2jbtq3BfXbu3IkJEyYgLS0Nf/zjH7FmzRqMGzcO+/btw8CBA21WNyIiMs+WMYGImvAZAuTtGFvImzEGkDeyOjE1cuRIm518y5YtkverVq1CSEgIsrOzcccddxjc5+2338bo0aPxwgsvAADmzp2Lbdu24d1330V6errN6kZkL4w15ElsGROIqAmncZC3Y2whb8YYQN7I6sTU9u3bTX5uLKFkifLycgBAp06djJbJyspCSkqKZFtCQgI2btxosHxdXR3q6uq07ysqKlpcPyJbYKwhT2LPmEBERN6JsYXIMRTsMicXYXViatSoUXrbFDrjDVs651uj0eDZZ5/FrbfeanJKXlFRkfYpGs1CQ0NRVFRksHxaWhpmz57dojoREZFp9ooJRGQC7yPIwzG2EBF5F6X5IlJXrlyRvEpKSrBlyxbcfPPN+O6771pckSlTpuDQoUNYu3Zti49hSGpqKsrLy7WvgoICmx6fyFq8nyBPYq+YQERE3ouxhYjIu1g9Yio4OFhv29133w1/f3+kpKQgOzvb6kokJyfjm2++wfbt23HdddeZLBsWFobi4mLJtuLiYoSFhRksr1KpoFKprK4Tkb1wKh95EnvEBCIyg4GEPBxjCxGRd7F6xJQxoaGhOH78uFX7CCGQnJyMDRs24IcffkDPnj3N7hMXF4eMjAzJtm3btiEuLs6qcxMRkf20JCY0W7p0KaKiohAQEIDY2Fjs2bPHaNnDhw/jgQceQFRUFBQKBZYsWaJX5tVXX4VCoZC8+vXr16K6ERGR87QmthC5Kz6lj7yB1SOmfvvtN8l7IQQKCwsxb948REdHW3WsKVOmYM2aNfjyyy/Rvn177TpRwcHBCAwMBAAkJSUhIiICaWlpAIBnnnkGI0eOxMKFC3Hfffdh7dq12Lt3Lz744ANrL4XI6YQQkjUTiNyNLWMCAKxbtw4pKSlIT09HbGwslixZgoSEBBw/fhwhISF65WtqatCrVy88+OCDeO6554we98Ybb8T333+vfe/ra3X4I3IdDBvk4WwdW4jcGZ/SR97A6m/m0dHRUCgUELL/Qm655RasWLHCqmMtW7YMgP4ChytXrsRjjz0GAMjPz4dSeW1g14gRI7BmzRpMnz4dL7/8Mvr06YONGzeaXDCdiIjsw5YxAQAWLVqEyZMnY9KkSQCA9PR0bNq0CStWrMBLL72kV/7mm2/GzTffDAAGP2/m6+trdMo3kavhPQh5O1vHFiIicm1WJ6by8vIk75VKJbp27YqAgACrTy4PNoZkZmbqbXvwwQfx4IMPWn0+IiKyLVvGhPr6emRnZyM1NVVyvPj4eGRlZbWqnidPnkS3bt0QEBCAuLg4pKWloXv37gbL1tXVoa6uTvu+oqKiVecmIiLr2DK2EBGR67M6MdWjRw971IPIKwnBeePk3mwZE0pLS6FWqxEaGirZHhoaimPHjrX4uLGxsVi1ahX69u2LwsJCzJ49G7fffjsOHTqE9u3b65VPS0vD7NmzW3w+otZiWCBvx/sNIiLvYrPFz4nIMrzhIHKsxMREPPjggxg8eDASEhKwefNmlJWV4bPPPjNYPjU1FeXl5dpXQUGBg2tM3o5T+YiIiMibcPVXIgfjDQeRYV26dIGPjw+Ki4sl24uLi226PlSHDh1www03IDc31+DnKpUKKpXKZucjIiIispTg3QJ5IY6YIiIil+Dv74+hQ4ciIyNDu02j0SAjIwNxcXE2O09VVRVOnTqF8PBwmx2TyJE48paIyHtw2Q/yBhwxReRE7A8hkkpJScHEiRMxbNgwDB8+HEuWLEF1dbX2KX1JSUmIiIhAWloagKYF048cOaL9+fz588jJyUG7du3Qu3dvAMDUqVMxZswY9OjRAxcuXMCsWbPg4+ODCRMmOOciiVqJsYOIiIg8CRNTRETkMsaPH4+LFy9i5syZKCoqQnR0NLZs2aJdED0/Px9K5bXBvhcuXEBMTIz2/YIFC7BgwQKMHDlS+1TXc+fOYcKECbh06RK6du2K2267Dbt27ULXrl0dem1ERERERKTPZomp+Ph4nD59GqdPn7bVIYmIyE21JiYkJycjOTnZ4GfNyaZmUVFREML0+JG1a9daXQciInI9vN8gd7f1cBGqahvxwNDrLN7HzNccIo9gs8TUn//8Z5SWltrqcEReoemGmhPHyfMwJhDZD6MGeSvGFnJ3f/9vNgBgeM9OiOzUxsm1IXIdNktMTZkyxVaHIiIiN8eYQEREtsbYQp6iuKLW4sQUFz8nb9Cqp/IVFBSgoKDAVnUhIiI3xphARES2xthCROT5rE5MNTY2YsaMGQgODkZUVBSioqIQHByM6dOno6GhwR51JPJYnDJO7o4xgYiIbI2xhTyR7pqYvAcgkrJ6Kt8///lPfPHFF3jzzTcRFxcHAMjKysKrr76KS5cuYdmyZTavJBERuSbGBCLb40K35O0YW8jTmWrnHRkDOE2QXIXViak1a9Zg7dq1SExM1G4bPHgwIiMjMWHCBAYKIiIvwphARES2xthCnoidDkTGWT2VT6VSISoqSm97z5494e/vb4s6ERGRm2BMICIiW2NsIU8nTGSpOIqJvJHViank5GTMnTsXdXV12m11dXV4/fXXkZycbNPKEXk69pyQu2NMILI93ZsSUzcvRJ6KsYU8kaWtuSObfYYYchUWTeW7//77Je+///57XHfddRgyZAgA4MCBA6ivr8ddd91l+xoSEZFLYUwgsi/eKJA3YmwhT8eOBiLjLEpMBQcHS94/8MADkveRkZG2qxEREbk0xgQiIrI1xhbyJq6SouK0QXIVFiWmVq5cCaApy1tQUICuXbsiMDDQrhUj8gbCZcISkeUYE4icizcS5IkYW8jT6X7r5+ApIimr1pgSQqB37944d+6cvepDRERugjGByDl4Q0OejLGFvAE7p4mkrEpMKZVK9OnTB5cuXbJXfYiIyE0wJhDZH5NQ5G0YW8hTsT0nMs7qp/LNmzcPL7zwAg4dOmSP+hARkRthTCByPE7lI0/H2EKeiKOkiIyzOjGVlJSEPXv2YMiQIQgMDESnTp0kLyKyHHtOyN0xJhDZHm9eyNvZOrYsXboUUVFRCAgIQGxsLPbs2WOyfFlZGaZMmYLw8HCoVCrccMMN2Lx5c0svh0gfm3kiCYsWP9e1ZMkSO1SDiIjcEWMCERHZmi1jy7p165CSkoL09HTExsZiyZIlSEhIwPHjxxESEqJXvr6+HnfffTdCQkKwfv16RERE4OzZs+jQoYPN6kTeiR3SRMZZnZiaOHGiPepBRERuiDGByL54H0PeyJaxZdGiRZg8eTImTZoEAEhPT8emTZuwYsUKvPTSS3rlV6xYgcuXL2Pnzp3w8/MDAERFRdmsPkSAdW27Apy/TZ7P6ql8umpra1FRUSF5ERGRd2JMILIN3oQQXdOa2FJfX4/s7GzEx8drtymVSsTHxyMrK8vgPl999RXi4uIwZcoUhIaGYuDAgXjjjTegVquNnqeuro7xj+yG07vJG1idmKqurkZycjJCQkLQtm1bdOzYUfIiIiLvwZhAZHu8CSFvZ6vYUlpaCrVajdDQUMn20NBQFBUVGdzn9OnTWL9+PdRqNTZv3owZM2Zg4cKFeO2114yeJy0tDcHBwdpXZGSkxXUk76E7lY/T+oikrE5MTZs2DT/88AOWLVsGlUqFDz/8ELNnz0a3bt2wevVqe9SRiIhcFGMCERHZmjNji0ajQUhICD744AMMHToU48ePxyuvvIL09HSj+6SmpqK8vFz7KigosGsdyf2Z6oBgzoq8kdVrTH399ddYvXo1Ro0ahUmTJuH2229H79690aNHD3zyySd45JFH7FFPIiJyQYwJRERka7aKLV26dIGPjw+Ki4sl24uLixEWFmZwn/DwcPj5+cHHx0e7rX///igqKkJ9fT38/f319lGpVFCpVFZcIXkjjoYlMs7qEVOXL19Gr169AABBQUG4fPkyAOC2227D9u3bbVs7Ig/HYbzk7hgTiOxLMFCQF7JVbPH398fQoUORkZGh3abRaJCRkYG4uDiD+9x6663Izc2FRqPRbjtx4gTCw8MNJqWIiKj1rE5M9erVC3l5eQCAfv364bPPPgPQ1LNh7WNUt2/fjjFjxqBbt25QKBTYuHGjyfKZmZlQKBR6L2NzxImIyL5sGROIiIgA28aWlJQULF++HB999BGOHj2Kp59+GtXV1dqn9CUlJSE1NVVb/umnn8bly5fxzDPP4MSJE9i0aRPeeOMNTJkyxTYXR16La0wRGWf1VL5JkybhwIEDGDlyJF566SWMGTMG7777LhoaGrBo0SKrjlVdXY0hQ4bgb3/7G+6//36L9zt+/DiCgoK070NCQqw6LxER2YYtYwIRWYZP7SNPZ8vYMn78eFy8eBEzZ85EUVERoqOjsWXLFu2C6Pn5+VAqr/XVR0ZGYuvWrXjuuecwePBgRERE4JlnnsGLL75o02sk79PSXBTbfPIGViemnnvuOe3P8fHxOHbsGLKzs9G7d28MHjzYqmMlJiYiMTHR2iogJCSEPfHkETjXnNydLWMCERERYPvYkpycjOTkZIOfZWZm6m2Li4vDrl27rD4PkaV4B0AkZXViSq5Hjx7o0aOHLepisejoaNTV1WHgwIF49dVXceuttxotW1dXh7q6Ou37iooKR1SRiMgrOSMmEBGRZ2NsIU+gu2Yg1w8kkrJojal33nkHtbW1Fh80PT0dlZWVLa6UMeHh4UhPT8f//vc//O9//0NkZCRGjRqFffv2Gd0nLS0NwcHB2ldkZKTN60VE5E1cJSYQeQMBoOByDcb8+xf8L/ucs6tDZDeMLUSGcYYFeQOLElPPPfecVQ3/tGnTcPHixRZXypi+ffvi73//O4YOHYoRI0ZgxYoVGDFiBBYvXmx0n9TUVJSXl2tfBQUFNq8XkTXYQULuzlViApG3ePeHXBw8X47nPz/g7KoQ2Q1jC3k6YeRnvXK8WSAvZNFUPiEE7rrrLvj6Wjbz7+rVq62qlDWGDx+OX375xejnKpUKKpXKYfUhsgbjDrkjV44JRJ5AHhuKKy0fRULkrhhbyNPxez+RcRa1/LNmzbLqoGPHjkWnTp1aVCFr5eTkIDw83CHnIrIFBR+sQW7OlWMCkSdi2CBvwNhCXsVEkkrBmwXyQnZJTFmqqqoKubm52vd5eXnIyclBp06d0L17d6SmpuL8+fNYvXo1AGDJkiXo2bMnbrzxRtTW1uLDDz/EDz/8gO+++84u9SMiIn32iglEpE8I3qSQd2BsIY9n4Ygp+VQ+BbsnyAu0+ql8rbF3717ceeed2vcpKSkAgIkTJ2LVqlUoLCxEfn6+9vP6+no8//zzOH/+PNq0aYPBgwfj+++/lxyDyJ1wRC8REZnDWxIiIiLyZE5NTI0aNcrk4m6rVq2SvJ82bRqmTZtm51oRERERuQ4OmCIicn+6T9fjk/aIpCx6Kh8REREROYs0M8VEFRGR+9Edj8GF0ImkmJgiIiIicmHyRBRvaIiI3BvbcSIpJqaInMjUVFYiIiJO9yAi8gxszYmMsyoxVV1djZkzZ2LgwIFo164d2rdvj8GDB2POnDmoqamxVx2JiMgFMSYQOQen8pEnY2whIvI+Fi9+Xl9fj5EjR+LQoUNITEzEmDFjIITA0aNH8frrr+Pbb7/F9u3b4efnZ8/6EhGRC2BMICIiW2NsIU+mO1OCo6eIpCxOTC1btgznzp3DgQMH0LdvX8lnx44dw6hRo5Ceno5//vOfNq8kkadiUCJ3xZhAZD+MDeStGFuIiLyTxVP5vvjiC8yYMUMvSABAv3798Morr2D9+vU2rRwREbkmxgQiIrI1xhbyZLqdDlxnlkjK4sTUkSNHMGrUKKOf33nnnThy5Igt6kRERC7OnjFh6dKliIqKQkBAAGJjY7Fnzx6jZQ8fPowHHngAUVFRUCgUWLJkSauPSeRsuktI8d6FvAnvN8iT6bbnbNqJpCxOTJWVlaFz585GP+/cuTPKy8ttUikiInJt9ooJ69atQ0pKCmbNmoV9+/ZhyJAhSEhIQElJicHyNTU16NWrF+bNm4ewsDCbHJOIiJyD9xvkLThiikjK4sSURqOBj4+P8QMplVCr1TapFJG3YEwid2WvmLBo0SJMnjwZkyZNwoABA5Ceno42bdpgxYoVBsvffPPNeOutt/DXv/4VKpXKJsckcjaGBvJWvN8gTyZ0WndT9wC2iAHZZ69g2Gvf44t952xwNCL7s3jxcyEE7rrrLvj6Gt6lsbHRZpUiIiLXZo+YUF9fj+zsbKSmpmq3KZVKxMfHIysrq0X1bMkx6+rqUFdXp31fUVHRonMT2YvCfBEit8T7DfIW9u6AmPvNEZRW1SHlswO4/6br7Hw2otazODE1a9Yss2UeeOCBVlWGiIjcgz1iQmlpKdRqNUJDQyXbQ0NDcezYMauO1ZpjpqWlYfbs2S06H5EjcEQVeSreb5BH011jykRDbovOh9KqOvOFiFyITRNTRGQl3l2Qm/LkmJCamoqUlBTt+4qKCkRGRjqxRkRE3sGTYwuR5Kl8Jm4CeHtA3sjixJQxP/30E6qrqxEXF4eOHTvaok5EHo1TMMiTtSYmdOnSBT4+PiguLpZsLy4uNrqwuT2OqVKpjK5XReRohnrVGUfI2/B+gzyNvdeZVTBQkJuxePHz+fPnY8aMGdr3QgiMHj0ad955J/74xz+if//+OHz4sF0qSeRJ2AtCnsAeMcHf3x9Dhw5FRkaGdptGo0FGRgbi4uJaVE97HJPI3szdTzCOkKfi/QZ5Mt1klL3bcQW7MMjNWJyYWrduHQYOHKh9v379emzfvh0///wzSktLMWzYMK7JQeQEO3JLsev0JWdXg7yMvWJCSkoKli9fjo8++ghHjx7F008/jerqakyaNAkAkJSUJFnIvL6+Hjk5OcjJyUF9fT3Onz+PnJwc5ObmWnxMIldmaroHkafh/QZ5CyEETl+swph//4Ith4oMft4aSualyM1YPJUvLy8PgwcP1r7fvHkz/vKXv+DWW28FAEyfPh0PPvig7WtI5MFae8NRUduARz7cDQA48Voi/H0tzjUTtYq9YsL48eNx8eJFzJw5E0VFRYiOjsaWLVu0i5fn5+dDqbz2d37hwgXExMRo3y9YsAALFizAyJEjkZmZadExiYjINfB+gzyZ7vd+IYAX1v+Gg+fL8dTH2Tgz7z6bnkvBuXzkZixOTDU2NkrW3MjKysKzzz6rfd+tWzeUlpbatHJEnsiWYaLiaoP250aNBv6WD4IkahV7xoTk5GQkJycb/Kw52dQsKirKol5FU8ckcmVC2H8tEiJXwfsN8mTSqXwCVbWNRgo6pj5ErsTiu9jrr78e27dvB9DUY33ixAnccccd2s/PnTuHzp07276GRGQR3riQIzEmENkPO7rJWzG2kLcQAvAxMd+O3+vJ21g8YmrKlClITk7Gzz//jF27diEuLg4DBgzQfv7DDz9IplMQkXmtDTocpkvOwphA5BgCTFSR92BsIU+m+7VfCEBpbIgI23zyQhYnpiZPngwfHx98/fXXuOOOOzBr1izJ5xcuXMDf/vY3m1eQiCzDjhVyJMYEIsdhzzl5C8YW8hYmm3XB7/XkfSxOTAHA3/72N6PB4L333rNJhYjIcuxQIWdiTCCyv9Y+mYnI3TC2kKfSbc/ZthNJWbzGlFqtxvz583Hrrbfi5ptvxksvvYSrV6/as25EROSiGBOIHIdT+chbMLaQJ5Mufm6uLBNX5F0sTky98cYbePnll9GuXTtERETg7bffxpQpU+xZNyKPZ8uQwwBGjsSYQOQYApzKR96DsYW8hRACCs59INKyODG1evVqvPfee9i6dSs2btyIr7/+Gp988gk0Go0960dEJuj2ovO+hRyJMYHIfnizQt7KXrFl6dKliIqKQkBAAGJjY7Fnzx6L9lu7di0UCgXGjRvXqvMTyQnB0bBEuixOTOXn5+Pee+/Vvo+Pj4dCocCFCxfsUjEisg571MmRGBOIHMNQ2872njyVPWLLunXrkJKSglmzZmHfvn0YMmQIEhISUFJSYnK/M2fOYOrUqbj99ttbfG4iY8xO5XNILYhch8WJqcbGRgQEBEi2+fn5oaGhweaVIvIWNp1+xwhGDsSYQOQgbNvJi9gjtixatAiTJ0/GpEmTMGDAAKSnp6NNmzZYsWKF0X3UajUeeeQRzJ49G7169WrxuYl0SdaYEnyIEZEui5/KJ4TAY489BpVKpd1WW1uLp556Cm3bttVu++KLL2xbQyKyiIZd6ORAjAlE9mNuegenf5CnsnVsqa+vR3Z2NlJTU7XblEol4uPjkZWVZXS/OXPmICQkBI8//jh+/vlns+epq6tDXV2d9n1FRYVF9SPvInR6GoSZXgd+rSdvY3FiauLEiXrb/u///s+mlSEi6+iuQ8L4RY7EmEDkGIZuXnjDQp7K1rGltLQUarUaoaGhku2hoaE4duyYwX1++eUX/Oc//0FOTo7F50lLS8Ps2bNbXE/yPkLA4l4GdkaQN7A4MbVy5Uqbn3z79u146623kJ2djcLCQmzYsMHs4oKZmZlISUnB4cOHERkZienTp+Oxxx6zed2I3IFk8XPeqZAD2SMmEBGRd3N2bKmsrMSjjz6K5cuXo0uXLhbvl5qaipSUFO37iooKREZG2qOK5MYkU/nMldUdXWXHr/iWHru2QQ2VrxIKZsnITixOTNlDdXU1hgwZgr/97W+4//77zZbPy8vDfffdh6eeegqffPIJMjIy8MQTTyA8PBwJCQkOqDGRbbU2zlgT4IiIyP0YumngfQGRZbp06QIfHx8UFxdLthcXFyMsLEyv/KlTp3DmzBmMGTNGu635iYC+vr44fvw4rr/+er39VCqVZPohkTn27lC25fFLKmsx/PUM/KFfCFY8drPNjkuky6mJqcTERCQmJlpcPj09HT179sTChQsBAP3798cvv/yCxYsXMzFFbsOWYchRvSlEROQ45vJObO+JLOPv74+hQ4ciIyNDOytDo9EgIyMDycnJeuX79euHgwcPSrZNnz4dlZWVePvttzkKilpFt+l2p8XPN+4/DwD44ZjpJ1kStYZTE1PWysrKQnx8vGRbQkICnn32WedUiMjJpCOmeKdCRORp2LITtU5KSgomTpyIYcOGYfjw4ViyZAmqq6sxadIkAEBSUhIiIiKQlpaGgIAADBw4ULJ/hw4dAEBvO5G1dEcxmRrRJOBaHRBKDtMlB3CrxFRRUZHBxQsrKipw9epVBAYG6u3Dp2SQK7Np0HGhAEZERPbDewQiy40fPx4XL17EzJkzUVRUhOjoaGzZskV7T5Gfnw+lUunkWpK3sWLt8xaxdC0oS4pxXSlyBLdKTLUEn5JBnkw3F6VhYoqIyOMY6lV3pZ50IneQnJxscOoe0PRgJVNWrVpl+wqRV7J0Kp8j00CWxBMf5qXIAdyqeyAsLMzg4oVBQUEGR0sBTU/JKC8v174KCgocUVUio2x5QyEZEswhU0REHoGd00REns3Ut3b5Zy2JCbZc/JwjpsgR3GrEVFxcHDZv3izZtm3bNsTFxRndh0/JIE8mWWOKeSkiIo/Dpp2IyDNIv7cLkwkfV/pez7wUOYJTR0xVVVUhJycHOTk5AIC8vDzk5OQgPz8fQNNop6SkJG35p556CqdPn8a0adNw7NgxvPfee/jss8/w3HPPOaP6RK1my1FOLhS/iIiIiIhIwrZP0y6/2mDTkVHGMC9FjuDUxNTevXsRExODmJgYAE1PzYiJicHMmTMBAIWFhdokFQD07NkTmzZtwrZt2zBkyBAsXLgQH374IRISEpxSfyJX4ojAREREjsWmnYjI85jrnBZmklg/n7yIIbO/w/SNhwzuz+l35G6cOpVv1KhRJm+mDS02OGrUKOzfv9+OtSJyH5zKR0TkedieExF5Hvn39takjhZ8dwIA8MnufLz+50EGzsVAQu7FrRY/J3KUitoGvLnlGI4WVtj82JIeklbGDC54TkTk2djOExF5HpOLn1uQVHLoeCiOviIHYGKKyIC0zcfwXuYpJL79s7OrYhJHTBEReQM28ERE7k63JRfCdL6H3+vJ2zAxRWTA4Qvlzq6CRSQBjjcuREQeQRh9Q0RE7krSoWyicZevD2UogeXIQUwcL0WOwMQUkQHuuGAge1aIiDyV+8UkIiIyrmmNKcNtuxDmu5sZFcjTMDFFZIBdG3vbLTElmYPOvBQRkecROv9LRETuSy/d1IobDkd2orthfz25ISamiAxQukkDLJ2rzhsXIiIiIiJXp9GY/t7O7/XkbZiYIjLAXabyCRuOviIiIteg/2AL94hJRERknC2/t7tyVKhrVDu7CuSGmJgiMsBRjX3rO0OYjiIi8mRNUz/Y1hMRuTtbPk3bsYufS0825ZN9+NO7vxgc9fXjsRL0nb4Fy7efdlT1yEMwMUXkYPa6veCIXyIiz8CnrBIReTZz7Xyr16FtZT2WZZ5C2rdHDX626WAhfjtXjvuX7dT7LOWzHADA65sN70tkjK+zK0BELSdNRjW9OXyhHMGBfriuYxun1ImIiGyHnQ5ERJ5BNwnU6hFTdp7fMX/LMQDAQ8MiJaOzdNe+yiko09uPIYtaiokpIjcmXfwcKCy/ivve+QUAcGbefc6pFBERERERGSW0/2Pkc3MZHjN5qdakrXSTTxVXG2Sfmd7X3KLuRMZwKh+RA3z2awGyTl3S297a6RryRRTzSqtbdTwiInI+PtiCiMjzCHmPcivYc7yURhaDdM9lrtaMWdRSHDFFZGcHz5Vj2v9+A9A0ismWj3+VDwm297BeIiJyPq5BRUTk3swOLGplM9+a3U3dq2jM3ccwPFELccQUkQG2fNLF+bKrtjuYCbxRISLyDNJOdbbtRESeprXf2+35VD550kz3XOYSU2YTV0RGMDFFZGdKE4GjtW23/LGzTE4REXk+jo4lInI/8u/tJsua+U5vzzhgapF2s2tM8VaEWoiJKSI7U9qxS8NUgGMvOxGR+zPUlLMTgojIvZlqxS1p4c3dXrRu8XPjn6nNZJ4Yn6ilmJgiMsCWvRDywGHLfJGkRwNCEsmYlyIiclNswImIPI6pkUiuRF433fsic1P1XPm6yLUxMUVkASEEymrqbX/c1u5vasRUK49NRESuiVP5iIjcm6mRRQqYT/CYGzFlckSWueSSib01GjPn5Q0ItRATU0QWeG3TUUTP2YYfj5VYva8jG2gumEueYOnSpYiKikJAQABiY2OxZ88ek+U///xz9OvXDwEBARg0aBA2b94s+fyxxx6DQqGQvEaPHm3PSyACAFTVNdrluK2dKvHd4SLsPFVqo9oQEZElJF/NTTTjzv4Gr3cLYcXi55zKRy3FxBSRIbJeiP/8kgcAeG3TESdUxjIcMUWeYN26dUhJScGsWbOwb98+DBkyBAkJCSgpMZwU3rlzJyZMmIDHH38c+/fvx7hx4zBu3DgcOnRIUm706NEoLCzUvj799FNHXA55sYXfHcfAWVuRebwFHRq6P9u4MS+prMWT/83Gw8t3swODiMiBdFtcjRAmkzjm4oA9R85qTGTQ1GafymeHCpFXYGKKyArmFvwzxJ6PczX1pAzeb5A7WrRoESZPnoxJkyZhwIABSE9PR5s2bbBixQqD5d9++22MHj0aL7zwAvr374+5c+fipptuwrvvvispp1KpEBYWpn117NjREZdDXuzfP+QCAGZ9ddjmx27NDUnF1WujuOoazczJICIiu7Dme7qhe4nW3F+YfyKg7Fw6P5tfY4o3INQyTEwRWaElTa2pkUytbbz1Fj838hmRO6ivr0d2djbi4+O125RKJeLj45GVlWVwn6ysLEl5AEhISNArn5mZiZCQEPTt2xdPP/00Ll26ZPsLIDKgUW19WyzpZDDQlremfVdaMSWDiIhsR/d7v7nW15kJHlOntjapRWQpX2dXgMgVGeuEaG2MsHWQkY+QcpenfRAZUlpaCrVajdDQUMn20NBQHDt2zOA+RUVFBssXFRVp348ePRr3338/evbsiVOnTuHll19GYmIisrKy4OPjo3fMuro61NXVad9XVFS05rKIWs1e7TmnXBAROYerJHgM1cPU/Yq52SP6szkEFPacPkIegyOmiKzQ2lFI9kwWyQ/NxBRRk7/+9a/405/+hEGDBmHcuHH45ptv8OuvvyIzM9Ng+bS0NAQHB2tfkZGRjq0wkQ67xg0GCiIih5Gu3GRifSkLmmZrkz15pdV4Y/NRlFTWWjBaS/qz7rmsGWn77g8nEftGBs6XXbWqruSdmJgiskKrR0zZ8XjyGwxO5SN306VLF/j4+KC4uFiyvbi4GGFhYQb3CQsLs6o8APTq1QtdunRBbm6uwc9TU1NRXl6ufRUUFFh5JUStI2+/7dXZzBFTRESOozfTwcIpc80/v7zhIJJW7EGjWmP1SoN/fm8HPth+Gs+uzZFsNxRfTIUGjRVLEy747gRKKuuwYOtxy3cir8XEFJEBxm4CbDGVz5Yd1KbmqgsB5F+qwZrd+ajnArfkBvz9/TF06FBkZGRot2k0GmRkZCAuLs7gPnFxcZLyALBt2zaj5QHg3LlzuHTpEsLDww1+rlKpEBQUJHkRtVTr1xK0IyamiIhcjrH7kDW787H9xEXsybts9THLahoAAPvzy8zGJfmoKGsWPzekrlFt9T7kfZiYInIgW/dOm3qUrAAwcsGPeHnDQXyw/ZRtT0xkJykpKVi+fDk++ugjHD16FE8//TSqq6sxadIkAEBSUhJSU1O15Z955hls2bIFCxcuxLFjx/Dqq69i7969SE5OBgBUVVXhhRdewK5du3DmzBlkZGRg7Nix6N27NxISEpxyjUTmOGqGHRc/J2+xdOlSREVFISAgALGxsdizZ4/RssuXL8ftt9+Ojh07omPHjoiPjzdZnshyumvBmp7KZ2rmQ4NGtHgkrY/S8I47ckvx4/ES7fm1dZGVU7cgbrTkqebkfZiYIjLA2KO4bfkUPVuQVkfIhv1ee591mk8gI/cwfvx4LFiwADNnzkR0dDRycnKwZcsW7QLn+fn5KCws1JYfMWIE1qxZgw8++ABDhgzB+vXrsXHjRgwcOBAA4OPjg99++w1/+tOfcMMNN+Dxxx/H0KFD8fPPP0OlUjnlGsm7tLbVt+c6ULxVIG+wbt06pKSkYNasWdi3bx+GDBmChIQElJSUGCyfmZmJCRMm4Mcff0RWVhYiIyNxzz334Pz58w6uOXkyea5Gr60383TWlpIntIQANBqBRz7cjUkrf0VRea2kLhqNMLl0iCWYlyJL8Kl8RFZoSbtqalSTLZmIZ1wIndxKcnKydsSTnKEFyx988EE8+OCDBssHBgZi69attqwekUPZs/nmiCnyBosWLcLkyZO1I2/T09OxadMmrFixAi+99JJe+U8++UTy/sMPP8T//vc/ZGRkICkpySF1Js8kTCSbrGmOFTD+BHFL9pWfSjcWlFbVoWv7ax13AtJkVEuSTAw1ZAmXGDFlzfDaVatWQaFQSF4BAQEOrC15s9avMWXrUVPSNaaMJaN480FE5D7sm4zSOQ9DA3m4+vp6ZGdnIz4+XrtNqVQiPj4eWVlZFh2jpqYGDQ0N6NSpk72qSV5C/j1dGPnMUFk5a5/KZ4o8LsjvIXRP35JpeXwCLFnC6Ykpa4fXAkBQUBAKCwu1r7NnzzqwxuTNWpJU0g0b9pzKp9fm8+aDiMjt2b79tmyNEyJPUFpaCrVarZ0O3iw0NBRFRUUWHePFF19Et27dJMktubq6OlRUVEheRKboP7TIdHtsbXttrLihhJbe6C1JnICksi3p7GYHOVnC6Ykp3eG1AwYMQHp6Otq0aYMVK1YY3UehUCAsLEz7kgcbIls6fKFc+7OxtadMMblAeWtHYEmOJWRP6TP+xD4iInJdjpr2zXU/iEybN28e1q5diw0bNpicoZGWlobg4GDtKzIy0oG1JHdhqkPZ0NO1dT/Tba8VipZP5TN4bhPvhQD+t++c0bKWYKwhSzg1MdXS4bVVVVXo0aMHIiMjMXbsWBw+fNgR1SUvNfebI9qfWzviydY9BqYOp/uZ7Qb7EhGRNVrf7Ns2bkimbLDbgjxcly5d4OPjg+LiYsn24uJihIWFmdx3wYIFmDdvHr777jsMHjzYZNnU1FSUl5drXwUFBa2uO3k602tMydtn+T2EuZl8xj43tN1Ukqzsaj125102Wg9LcMQUWcKpiamWDK/t27cvVqxYgS+//BIff/wxNBoNRowYgXPnzhksz6G11BK6jbYts/xNCwja7nh6x5a9JyIiT2C77gXdmx32YpOn8/f3x9ChQ5GRkaHdptFokJGRgbi4OKP7vfnmm5g7dy62bNmCYcOGmT2PSqVCUFCQ5EUkJ5nZYCYRpb+vfIst15iSzrjQrWd9o0ZStiVrTBFZwulT+awVFxeHpKQkREdHY+TIkfjiiy/QtWtXvP/++wbLc2gttZZGpwFuyVQ+XbZOSpkMcOydICJyupaMStJb38OGNDr3GIwT5A1SUlKwfPlyfPTRRzh69CiefvppVFdXa5/Sl5SUhNTUVG35+fPnY8aMGVixYgWioqJQVFSEoqIiVFVVOesSyEPotrga+RIcJqbTfbLrrCR51Jr7kaan8snXlDJ+bnm9WpKX4ogpsoRTE1OtGV7bzM/PDzExMcjNzTX4OYfWUmvZtDG1snfEmsMJSB/vwRBAROR8re3QsDV7Jr2IXNH48eOxYMECzJw5E9HR0cjJycGWLVu0Mzby8/NRWFioLb9s2TLU19fjL3/5C8LDw7WvBQsWOOsSyAOZXI5D9i3+UnW9XnkbPpRPOmLKwFP5JHVryVQ+jfkyRL7OPLnu8Npx48YBuDa8Njk52aJjqNVqHDx4EPfee6/Bz1UqFVQqla2qTF7Clo29LruuMSX0AwsREbkhO3YymHyaK5GHSk5ONnpvkZmZKXl/5swZ+1eIvJJ8QXPdJ+RJ14ZV6LX9emtMtbAOCoXC/OLnkinf8rWurD8nR0yRJZyamAKahtdOnDgRw4YNw/Dhw7FkyRK94bURERFIS0sDAMyZMwe33HILevfujbKyMrz11ls4e/YsnnjiCWdeBnkwWzalNr/BkD15T3rDwSBAROSqTl+sgkYAvUPaWbVfa9t2Uz3hRETUMhfKrqJzO3+ofH0sKm8qGaRQ6Lf18ta6Xm16GJI1iSu9c+m8lZ+mJXGDoYYs4fTE1Pjx43Hx4kXMnDkTRUVFiI6O1hteq1Rem3F45coVTJ48GUVFRejYsSOGDh2KnTt3YsCAAc66BPJwhnoGdp2+hA37zuPle/sjuI2fyf2l88dNP4GjNYR8xJTtDk1ERC1kaARug1qDPyz8CQBwZE4C2vgb/zpm8zWmLIgTQghJTz4RERl36Hw5/vjvX9AnpB22pYw0Wk7aoWzdPYFkjSkFsP3ExRbV1VDLbuqpfGq9EVOtWzeRyBinJ6YA64bXLl68GIsXL3ZArcjT1TaocaSwAtHXdYBSKW2mJWuCGGiA//rBLgCAUgmk3W/6EcLShQ5bXF2zBxeyZp+9E0RErqlBpwv6UlU92nSSfh0z1Xy3tm2XL74r92XOebz61WGk/99QxPbq3LqTERF5ga8OXAAAnCwxs0C+bAkOYaKjQC9ZpDNySQFg0HUdcKCgTKe8wDsZuegb1h6jBxpfq9lQn4O8w0K3XmrZkKmWrBfFB/mRJdzuqXxEtpK8Zj/uf28nlv982mQ53bZU3pifulht9jxCljyyJXkiShrgGAWIiFxdo5lv7AJCEnssadlX7cjDbfN/QP6lGr3PzK1F+MzaHFypacBjK3+14ExERNQS+oko3afu6ZN3JNwgmwa+I/cSFn9/Ak99nN2qugghZCOmTNfDEpw2TpZgYoq81vdHm54GaTYxZaIt1VjUBWC/VWzliyhK1w6x7bmIiEgq/1INSipqrd7PXPvc2nWkXv36CM5duYo53xw2cGzLztNgZv0SIiJqYmmbbWrEqrkjmPu8uAWxCNBfCkQjfyqfLGC1LDHVoqqRl3GJqXxEzmSosdTtnTbVAFvSzmpkySJTw3atJX3st5Cci4ufExHZT1lNPe5460cAwJl591m1rzVf7PWfniQsns53tUFt4HiWxSD5uiJERGQ7Zp+MZ2KkkoD+LA7LW2zTT+VrihHXNshH9bYkNPCehCzBEVPk9cwt72qqLbWkobXnVD7JeSBPVNntVEREXu+MgWlyhhhcaLYVg5Fa36FxjcmOF8YQIiKrCSEwY+Mh/OeXPAOf6fxsYL9mhh4+IZ+GrZBFF0uTP/JDKxSQrlUlq6c8ThiKG+ZmkHAqH1mCiSnyeq0ZOmusHX73h5OYsmYfahvUZtfzaA3J8YS8x8O25yIiomta80VbGhf0j2OuLW/NA/N0byAYJ4iIbGtffhn+u+ss5n5zRO8z+UwH+VqxzRTQ78yWd3S3dMSUodFST/732rpUGo10BkajWp6Yku5fXtOAW9Iy8PKGgxafk8gQJqaIzGjJ8NMF353Apt8K8dOJi6bnk7eypZbvLR3myyhARGQvrWm/5VMyrDuv5V/y5T3q8vOpufAHEVGr6bbJV+v1p1Ab3MfMe1PnMNh0WxoXFKbvEeoaNXgwfaf2vXxatzxufPprPkoq67Bmd77RYzLUkCWYmCKv14qOZ7MxoL5RI13PQ7RsGoaxGyBTT+Fj7wQRkf1Yuqaf4SkZuvvq7yMdDCtr21vZ6cApFURE9uOjvNbmy6e4yWc6SD8z/T1ePtJWHlrkbbuh2GOJH46VoKK28dpx9a7B/NQ+Oa4xRZZgYoq8nrmmUrfB1WvizTS0SoX+AoPWWvpjLm6auw1nSqv1PpMPAZY+VYNBgIjIXlrzFFQhu8Gw+tzWljeysAnjBBFR6+m2pLqJqXoTTzfV73TQYSCnZG6kraWtuQKmb1/kdZaPmJLHO0vCCGMNWYKJKSIDdHsZTC5UaPY40sDTkob5ra3HcaWmAa9vPmqynHx6B0MAEZH9mFsnyvS+hn82xNB6INYscltUXovb5v+If2ectPrcRERkHd2BSnpPtNP92czasHr3HHqjdOWLn1tWP2ubffmIKXPLkhgaqMVYQ5ZgYorIDGufWqTbQCsVgEZjvLw17XSjoV4XWSLK3PQQIiKyDekI1dbsq7+zfFNrppy/88NJnC+7ioXbTjQdW7b4LhERtY6xplS+HpOQtf26n+o+xU8B/fZZ76l8ssBwpabeqjobI78WeXJN/yl90vLBgX56x8wtqTL75D4iJqbI6xn6wm/sJkC+3dBaH6VV1wKDfE0pgZYnjAwP25XeYLR2eggREVnG1OO0zdG9WWnJSFprdqlrkHZqcMQUEZFtNWoMT9kz9YAJ+ejX9J9OmTyHuenjb209brqSuscyeR7pp/rJNeP1AozfQ32yx/ji6EQAE1NErZqnbSgO1TVeexqHn49Sr3fEluRT96yZyldSWYsPfz6NMhv1sBARebqSilrM+foITl2salV7bmr6BiDvdNDf15ozm5p20dyhsXH/eZy6WKW/r0Zgwdbj+PFYiRVnJCLyLquzzmp/rm24dh+gl9SR/WwqjMg/0lv83EydLO1kl5PHDPk1yN9bGgv/l30O72XmYtr6A+w8J4N8nV0BIldn7VMt/H2v5XsD/X1wWWfNcnO9DCbrYWCb/ObG1M2MXPKa/diTdxkb9p/Hpn/dbnlFiIg8XH2jRtKWN3t2XQ52nrqE/+07h39PiNFutzZJ1ZoHVQgIg1/qG9Qa+Pno19nUGicaAXx7qAjPrssBAJyZd5+k7LeHivDuj7kGPyMiIn3nrlzV/mx2xJSRbgZzT3PVX4DcwJRwY+c1WqNr9dKlv/i56TWmjF3y0cIK5BSUAQAeGhaJYVGdzNSEvA1HTBEZoBsOdBtceaAwONpKZ6NaI2RBx3Brve1IMfIMPHXP3LnkJaRBy/Qee/IuAwAOX6gwe2QiIm9xsrgS/WZ8i9e+OaL3WfbZKwCA8qsNVq8xJYTA8aJK1DWqJfuaunEBjN+46Fq7Jx99p39rcGSTWja0Vz6Kd3/+FaPHLa6oNXtuIiK6Rrd9f3+7bHqekL4x9lU9t6RKr/2Vj3bVvSXR7/g2E1dMrZ8rey9fG8rcernG1pKqa7wWi67qjCojasbEFHk9a4aTyssa2lfeEy7v4ZDfZOw8VYrJq/fizgWZFtdDe35JXcxPDyEiItMWf38CGgF8qLMQbTNj3QyWxJGNOeeRsGQ7nv54n8Ge75PFlSiprP39eMaPY2gq30tfHIRGAH//OFuvfIPa+E2FRggoTYwKNjRqTFdlbQOTV0TktZrb/nHR3bTbdBMzK3eckZaXzWww1da//MVB2b7XqIWAQqcbXSOEZNFxIVr+0Ax5x7Z81K25EVSWjAIWwnynDHkfJqbIq9Q2qCVrQFnC2mZT/mQ8c8mi/fllVp5B93g6AQ6y+edW15yIiBQmvs4b6wnWiKZRVIu3ndBbq6k577Pq9xuUH46V6PV8Xyi7irsXb8fw1zP0jm2od9rY934f+aheA1/+9Z7eauLuxd/A1EBddy38CbFvZKCEySki8jJfHbiAmLnbkHXqkqRd1R0ZJCd5UjdMJ3HyL9dI95WNtJWMmALwx8HhBssaYvJT2YfyuKc/lU9aXp64MuSLfecw6NWt+OVkKYCm9XkPFJTxyX1ejokp8hr1jRpEz/kOsW9kmO3dNtaBLJ/KZ/gx39IRU5LeEb1QYHitEFM0mqabmKa9dc+r/94aX+acx2/nyqzbiYjI05hI1EjafEmCR+DVrw7j7YyTSHz7Z4P7Bvj56BwHkp+PFdlmSrWvUr/yemtMyWKUqRFTfr7XPjPUu11SWQcA2PX71HAiIm/xr0/3o6ymARNX7EGD+lrGSZ6YOllciS2HCgHI1/izLnmkm9QylBzSbcpbk9+R76o/Qsp4+doGtcEHQ8ltzLmAmno1/rbqVwBN/5Zjl+7Ah7+ctr7C5DGYmCKvUVRei9oGDcpqGkz2Zugx0bg3f1H/YPspfPZrQVNx2Q2HXu+0jLXB45WNBzFi3g/YcqhQNmJKyHrhLT9mTkEZnlmbgz+9u8O6yhAReRhT0x8k7blsSkbzun31RuKLNDElTQ7pLlquN2VcdhxTnRlKpXwdRKG3xpQ8Jpm6Xt161crWBGlexBYAGtVWxFQiIg9Sr9ZI7isaZO3h3Yu346mP9+GXk6V639PNTdvWJR0xJVsPF/LkUcszU+am8m367YLR8t/8VmjRiKlmzfXeergYALD8Z/0p9OQ9mJgir6HU+WvXDRrmmk9TjbtGAAWXa/DG5mOY9r/fIITQX9TWzNOXrI0dn+5pSoAt2nbCwFM5dH42cGUzvzyE0Uu2o7ZBjT4h7bTbC2TDhYmIyDT5Wk3mBPhdC0LyxJSPTkJJfhMAQG/KhjHyEVNCADtyL8lKWT5iSndqoPxm65UNB41+RkTkTU4UV2p/NtY5kX32it46hS1NIMmnvBWVyxdKt25/XXrTv2Xvd52WjZDV+bispt6qa9JLvnEqn1fzdXYFiBxF98t3o9p0wyfthbjmfNlVSTm1RqC6vlHyXtobLX+vv+ZUS4OSj1KpdyxzI6ZWZ50FAHx7qFDy79FOda0pqG1QS3r2iYi8iaHHdBsiHx1r/HhN/3+h7NqNQ1XttbghhHRkUn2jRm8NKkvJR0wZIo9JFuwCwMACuDrv683EVCIiT3a1/tqIUmOzMtRCPrPB8tVglQrZiCkhJLFq/pZj6NTWX/ve3L3Fqp1njH4mv0cyt0i5vKPFmtsavemKfHKTV+OIKfJK87ccM/m5dP0P070Kuj3KO09d0nuEuNk55FY0wrkl13pkfJUK2WLnlte7oVH6mUrnyUsVVxssrg8RkaeR52nqGtXIK63WK6eWtL/m2/GD58u1P5+7cq2T42hhBXTXGDfW2649l4lTGVr8XFdVXaP+SC+dfeTXqXuNjWqBzOMl2PRb01opuomqBmumxxMReRjddtvYQ5Y0Gv2kjaWJGPnSIBohXfy8pl4tK298nrYQwNrfZ18A+vHLVCeEIboDZg2N+DXF3NR18i5MTJHX0G1Y1/56rUEuq9FPxOiW9VOa/s9Et8ciacUevS/95qZ7HCm0fNHbpz/ep/1ZqVToPa5cPkTYUnU6UaWilokpIvJejbI1mR56fxfuXJCJHbmlku26X6hzi6VP4jNHt31+bdNRSZyQ97brteWmElNKhd5NhG4v+pXqer3OE917l+q6RujSPVaDWoPHVv6KKWv2obiiVrKuFKfyEZE30/0eXddgYsSUzvvSqnqrvqxL2m6NkDxB1tTTVw0x1ZkiX5fQ3JpRK3ZcWxeqtQOeOGDKuzExRW5PCIFn1u7H1M8PmBx9ZC7jr6tDGz/tz+0CpDNe5U80ks/6kH8uGdVkoArdOgRaVCcFpHPIfZUKvevVvVEw17jr1rtWp6el/GqjgdJERJ6tuZd788EiyfYDvy/y/dneAsl23ZDyr7U5LTpXM8m0uEZNi3uNfZQKbD9xUfteQEimatc1avSmXUjWrzLRm687bb20qg4NOtM9rO0lJyLyJLojpuqNJOrlndVHCytw2sBoXGN0119Sa6Rtt/wex9xsDN3iCtnQKmtHTOl6a+txi8sa8+HPp7H5YGGrj0Puh4kpcnuXq+vxZc4FrM8+h21HihG/6Cf8fLLpi/l/d53FsNe+x7GiCoueEvH9kWJsO1IsCRzyuda67bNaI/Qaf5NrSgF6o5osXN5DW76Zj1Kht8aUZFF3vUfJGr/+Qp2El7lpJEREnmbbkWIMmLkVH5lYd0O+SLhu0uZSdZ1V56ttMN4jXa+WJq3kTbepnm4fpQK/nbs2ZVAIaYdFTX2jrLNE2uveIO8p13krH02lO7KMcYOIvEFZTT2mbzyI7LNXjJYplC1E3qw168oC0oSRWrY+YKNGPkPD9LF0k1zymCIfAWvPdZ/kRy6/2oDXNh3FPz5pmiFyvuyqVYkxcm9MTJHb+9uqX7U/P/nfbOSWVOEfH+9DTX0jZmw8hNKqOry4/jezT3oov9qAJ1bvxeTVeyU9w/qPTdXofCb94i4vr9YISYOvEfqJLGuaW9199deYEpIFaHWPq1BA0rstD0L/+eXaMFxjPT1ERJ7q9U1HoNYIzPrqsNEy8tGxul+W5Q+fkOz3e+LHz+faAeQjpnTzQXWNGqseIW6qjgLShclr6tWSc2mkS0zpd8ToXGNlrfRBH5aMECAi8iQrd5zBx7vy8cCynUbL7Mm7bHB70z1By+nGHI1Guvi5/Nimk0nCZGe9PA6Ye2CUvcz5+ghunfcDUj7Lccr5yfGYmCK3d0Cnd7hZZV0jMo9fm85Q16jB/t+nYxhTcLlG+7PuE5PkQ1p1v9SXVtXprUcinyZhagSVteQjpuTHbjAxlc/UGiC9ura9Vo4930TkZYz1cOuSj5iyti2XTKmTjZhqMDn6yPITyesIIe1M0R8xJet1l8WJUp2RYNV115Jp9Y0a6WK/RtZUISLyJL+dK2vxvoZmWVi7v/ZnISQzLhrVGklHgkb2ebnOg42EgMnO+oZWTOWzlhDAQQP3ccC1tau+zLlgt/OTa2FiitxW+dUGkw38lZp6yftp638zebz12ee0P1frrLkkb7zlvQzLt5+WvNfNU+kP2xV60+90CSFwtLAC//ikaeSXnG6Q8VUqMPXzA9fOK6RJJb2RXnpTEq+9j+zURvtzg1qDxdtOYIXOKCoiIk9m7PHeuuTTrq2d3qA7fa9WNmJKt302+1Q+E58pYOAJSzrHrq5TG1hjSncqn3TfN7dcWy+kqu7ajU1tg0YySupqA9cmJCLPp/L1afG+rZ0Sp3v/IU8WNWqka9pW1jZKIkFxhXTJDlO5phNFlZL3liyF0hr/Wrvfrscn9+FrvgiRaxFC4IX1v2F99jm9aQu6dB+bfUzWyMrllVZjlc7aIjX1xkdMqWUJno2yTH6NbBqgfM63/KZB93O1RuDh5btwpaYBP58sxYGZ92g/UygUkhsI3d5roCnQGBsxlVNQJrmJUGukNys1OmuHnLlUg7czTgIA/jo8Em38TTcTS3/MRcXVBryU2E9SPyIid5BbYjw+6HZ+yJs3azqRhRCSZJR8hJHuSKV6tUYSJ9Qa6eK0pjpklArZ2oMQ0gRSvVrvkeO6Nzi1DYYfcw4AVToxp65RLZkefrm6HrO/Pow/9AvB7X26Gj0GEZE7u1xdb76QEfLkkbV07z80sql7jWrpDI30zFOSfXVPK596LR9pe7VBPtXcvokp3aQZeTcmpsjtZJ+9oh3dZKp9VyotT5KcvSR9KobuIq/yXoniStMNaI3uaCvZuiNNI6iM76sWAldqmnqlK2sb9XopJE9ukgWWqw1qfHngWpKsslbau62btGrUaCQJN90678u/tqDjhbKr6B3S3mh9y682aJ/AMf7mSPTq2s74xRERuRCNRkCpVOBCmfE2vcHE2hryL+u67/J0nrSUf7mmKdmkU+DclauSfXXbY/mIKfn0OjnduKBQSGNOo2wtqOr6Rvj5XBssL18c3dTIMd0p7vLF27ceLgbQtP7KmXn3mawvEZGrq6lvxD8+2YdhPTqiQS3w0M2RiOgQiD1nDK8fZYlGten1A83RbZ+LK2sR6Hdt9FZ1faMkJhVX1klG+erGiUaNsGp6nr2fumrpGla1DU0jfs11mJP7compfEuXLkVUVBQCAgIQGxuLPXv2mCz/+eefo1+/fggICMCgQYOwefNmB9WU7O1kcSX+/N4O/HCsWO+zBrUGr31zBNP+Z3pKXjMfK0bvyG8+dEcjyRvvl784aPJYugun1zaoZVP3hP70Pd3F0WX3BPLGWje5JO/ZLqmsRVnNtWTUk//NNrpvfaNGcl26ialtR67921fU6k/P0A18q3VGmb2x+Si+O1ykPdf497Pwz085PJesZ+uYIITAzJkzER4ejsDAQMTHx+PkyZP2vARycZW1Dbh1/g946P0skyNvdddn+mzvOclndSYSRncuyJS8lydyvj8qjXHyJ9zJe7d144T8K7xu265QKCQdGvvzyyRla+rVksTVN78VIkdnfY/aeuMjpqolI4mNX/vOU6VGPwOa/u2vtGLUAVFL8F6DTDl9sQpp3x7Vjoj64zu/IPP4RSz47gTezjiJpP/s1ntohbWyz17BG5uPtnj/KWv2aX/+eFe+5OFL565clYzGkndoNEhmTQi0V1me3Dl8oaIFtbWcJVMFJ63cg7sX/4T4hT/xKbAezOmJqXXr1iElJQWzZs3Cvn37MGTIECQkJKCkpMRg+Z07d2LChAl4/PHHsX//fowbNw7jxo3DoUOHHFxzshUhBH49cxl7z1zG//1nN/bnl+Fvq/Zi/pZj+PDn0/j2YCF2nipFn1e+xYe/5OH0xWrzBwXwvM76SwDQtb3KaNnJq/dK3usOY5V/Ad9r4hGxAFCjk9Sa880R2bQJyG4wpIkq+bm+PVQoea/bayHv2T5aaHq6ou41rdmTj/Nl13rsdW84dK3PPoeK2gb834e7sfC74yivacCgV7ci6qVNWLsnHwu3ndCW/f5oCZ78bzaGv/49vsy5gN15l/H1gQvYdqTY4DDgrFOX8PxnB3iDQhL2iAlvvvkm3nnnHaSnp2P37t1o27YtEhISUFvL4eOeRAiBD7afwp68yyiprMW3BwubpjuIa6OGPtl9Fv/LPoedpy6hsLwWe/IuY+N+4wurmpq2MWOj9HuHfPqDrqOFxr/Y+/soJZ0j9WqN5AajQS0kNyCmHmyhAFBoYgRYTX0j/v1Drvb990eLsf3ERcnnxnygs55ig1rA39fwV8iHl+/Gyh152LC/KZH3y8lS/P2/e1FSUYvZXx/GoFe/Q8zcbZJRvc2KK2ox7LXv8aqJpyMSWYv3GtSsrlGNc1dq9LbP+PIQ3v/pNG6auw1Lf8zF6VLpvcapi9XoO31Lq8596mI1Sqts951XPi1Qd7p1o1p6fyG/Z9BdW/bQecOLjzuKJaO3fjx+EQWXr+JCeS3GLd2B1zcdkSSoahvUOFZk3wQa2Z9CtObxADYQGxuLm2++Ge+++y4AQKPRIDIyEv/85z/x0ksv6ZUfP348qqur8c0332i33XLLLYiOjkZ6errZ81VUVCA4OBjl5eUICgqy3YWQnuyzl7H3zBUkxUUh0L9puKlGI7B+3znc1L0D2vj7YuzSHbhYWWfmSO5l2ui+kgVj//WH3njn9xuBNZNj8fnec9iw/zwAYMuzt2P0kp+1ZXel3oVb0jK0732VCm0yalTfrpInDdrS9V3b4pSRhN+46G5662i1xLG5o+Hvo0RNgxoniitx/3tNj9p99JYeeDa+D05drMbNUR0BAAfPl6N/eJBkygnZlqu2hbaOCUIIdOvWDc8//zymTp0KACgvL0doaChWrVqFv/71r2br5Kr/Vt6ktkGNz7PP4Z4Boejc1h9Xahrw04mL6NLOH41qga7tVXhs5R7tVOjb+3TBzyelI3dG3xiGLb+P6nQ1L9/bD29sPgYA+NddfVBUflU7QmvZIzfh8+xz+OFY0030r6/E4+bXv9fuu2/G3bhp7jYAwI3dgkz2bt/SqxN2nW75VBRdN3XvgH2yEVnWmHLn9difX4bkO3ujf3gQDl0ox6P/uTaKZVfqXdhyqBD3DgpHSFCADWpMreWubaGj7zUA9/238hS1DWoUXK5Bn9D2UGuanlCnVCowccUe/HTiIr5Ovg19QtvhQEEZNh0sxOqss86ucqsNjAjCofNN7X9M9w64VFWP/N+fOL5q0s14bOWvTqmX7r2MPQzv2Qk9O7fFur0F+L9bumPu2IFYueMMRvXtitKqery++SjCgwLw9oToVi1eTy1jTVvo1MRUfX092rRpg/Xr12PcuHHa7RMnTkRZWRm+/PJLvX26d++OlJQUPPvss9pts2bNwsaNG3HgwAG98nItDRR1jWr8fKLpS27zP1jzP921982lheS95Jls2m2Gy8h/HfJFTCX7GNlXVg0z59P/3N9HCV8fBfx8lNAIAdXvvaKVtY1QawT255chKNAXg6/rgK2Hi/DNb4W4tXdnBAX44XzZVRy5UGH3+cjuanjPTsg+e0XbO/D3O3rhfZ1e6Nt6d8EvuaanQXiTJ+/oha9yLqCoohZ9QtohtlcnDIoIxq7Tl3FDaHsEBTYNRQ7w9UFNgxodAv0g0PQ3fKWmHjX1alzXMRC1DWr4+yhlU3auvdHdLp/Vo7ugu6su7R7VpY3JtcAMccUvzfaICadPn8b111+P/fv3Izo6Wltm5MiRiI6Oxttvv222Xi39t6qsbcDu35MAhtp4/dhxbau07dcvJ2/TjZ1D+5m5fQ3GK6G3DbKYYWhfS+rZTuWDNv6+UKBpJOih8+Woa9QgpL0KtQ0aKBSAUgEcOFeOoAA//G+fdBqdp2sf4IvK36dS9+zSVrJmVcrdN2CRzmjV8cMisW5vgcPr6EhT77kBXdqpsPVwEX48fhH9w4Mwfth1qKhtxPHiSkR0CETvkHZQKhTw91VCCIGaejUqaxsQ4OeD4EA/AND+zRHQJ7QdenRua9U+rhg3zHHGvQbQ8n+ry9X12Pf7yHxTcaNpu/7W1sQO+bkMH9O6+CHZbuA4xvfXLwcAfj5KBAX4oVGjwaWqeiiVTY+G8FUqcKG8FkEBvii/2iAZGUrArb07Y0fuJWdXw+kev60nurZXQQGgQxs/qHx9oPJVoq5RAz8fJWrqG1F+tQFhwQHaznG1RkCpUMDXirWLPdWNEUEIDw60ah9r2kKnrh5WWloKtVqN0NBQyfbQ0FAcO3bM4D5FRUUGyxcVGe4FraurQ13dtRE5FRUtG+ZXcbURT8ime9E1ntrY6d4c2MKePGlPtW5SCgCTUjK6U0dOllThZEmVE2vjup4aeT1eSuzn7Gq0mj1iQvP/OyNuXCirZdygFtGNO3myKSW6SSkAHp+UAoAF30mv+WhhBV79+oiTauMZXrm3Pybf0cvZ1bA7R9xrALaLG8eKKhg3yOYsuU9renhG08+Tbo3Cyh1nTJYf2qMjsn9Poj56Sw/8d5fhUWftVL74c0yE0c8d6T+/5Dm7Cm5t0UNDcP9N19nt+B6/rH1aWhpmz57d6uP4+SgQHdlB+755EIVC+14he9/8uaygiTLa90a26zJ+PunnhspAfj6dz4VoWhxVoWiaj+yjUKCuUQ2FQgGVb9OIkx25lzAksgP8lApcbVDj8IUKxHTvAI1G4HxZLUqrpFPz/H2VCA70g1ojEOCrRGSnNtgtS9BEdAhETPcOyDx+Ean39sOGfefRoBG4qXsHbcPYq2tbo+tLvTMhBqt3noFSqUCXdv7YfLDpy0N8/1C8lNgXmccv4khhBfqEtMevZy7jh2Ml6NmlLVZNuhnbjhTjjc1HEdW5LdqofHDuylVc1zEQM/94I4QQWP7zaRRV1GJo9464PqQdZn55GG38fTDjjwMw4vrOGPlWJgBg6cM3YcqafXrTGwZFBOPg7/O3B0YEoZ3KF7tOX8b1XdsipH0Ask43BYvundqgU1t/AE1ZfKVCgaraRgyN6oijhRWorG1E9tkreHDodbhUXY8fjpVgbHQ3pCb2x2ubjuCb35rWo5p+X398vOsszlyqwX2DwjFheHe8tfUYDvy+wK3ukFrd6S5LH74JPx4vwfrscwjwU2LlY8OxaNtx/HrmCh4bEYWgAF/tlESFApgwvDt2nb6EWWNuxOqdZ7D37BWEBqlQWFaLyrpG+PkosODBIQCA7w4XY9NB6XpZpnRq64/L1fVIHBiGbw9JvwjecUNXlFTUoqZejRtC26OuUd30NwvAR9n0qPQGjQb+Pko0/r6+jEKhkPSSm+3V035meB9X060Dp7nYkq3iRoCf0mTcaNqmMLCtuZx+4DBXTh5HdD83FUt0j21oBKG5cvK4Yqhccz0EBCprG7WxBgA6BPr93lupRlCgLyquNiVmLpRfRaCfD9QagdKqerRV+eDspRp0aeePPw2JQEiQCvO+PYbIToGYGBeF+waHY+rnB1BcUYdAPx8cPF+Oh4Zdp7dwebPQIBWKK+rQtb0Kk26Nwqd78jFmcDfc0qszklbsQbfgAFwob1qzSXe6XbMendugT0g7HCuqhEIB3Na7K77KOY/qejU6tfXHoIhgdOsQiKq6RuzPv4JXx9yIF9Yf0E45nPnHAViffQ419Y3oFxaEiI6BOFpYgasNau3C5d2CAxDRMRC/nrmCfmHt0aWdStuJMbRHR/gqFejRuQ0qaxtRXFGLg+fLMfn2Xvj5ZKk29rw2biBW7sjDqYvVuG9QOMYMCccvuaX4/kgJin5/VPfNUR2h1ghcKKtFhzZ+OHOpGrUNGvzfLd1x+mI1bu3dBet+LUBRRa12bY+JcT0Q2akN9heU4bn4PtiXX4Zp600/oOTNBwZj56lSHCuqxLGiprUR4/uHIP9yDa42qOGjUKBrexV+PdN0w9OlnT96dG6rHQl7rKgS3YIDEN29A/x9lDhzqQYqXyXa+PtALYCG3+vWVuUDH6UCl6vr4ats6vk2tQ6YKa7c/reUqXU3yXq2ihvtVX4Wxw3d7YbafN0ClsYOSz63vB76ZQ3VQ7e0qRgiRNO9SVVdI3yUCkAAvj4KaISARjQl9K/WN0KpVOD0xWrtSJh2Kl9U1ZnvZA7wU6JvWBAOFJQBAOaOvREzvpSud3f3gFCk3T8Iw15rmk695olYfHXgAtb+WoAFDw5BxzZ+ePyjvfjXXX3w9zt6YdNvhdAIgdQNB7XfKeP7hyI6MhgfbD+NitpGBAX4YuWk4XhgWdMSF+8/OhSj+nbFox/uwZ4zl7HgwSHo3M4f8789hrKaBqQ9MAgvfH4ApVX1mDC8O26O6og3txxH75B2CAr0xamSaigUTQmhvWevYMh1wWgf4IdhUR2h0Qjsyy/DwfPl+HNMBPx8FPj5ZCl8fRR484Eh+GxvAUbe0BV39gvBI7E9MPvrw6isbUSfkHYY3rMTdp66hNiendChjT/uuKEL7ngzEzdHdcScsTeiU1t/rNyRh/j+ofjXXX0w6veHgLw2biAGXxeMS9V1OF9Wi7/dGoVTJVWI7t4BX+w7j9ySKrwzIQb3LN5u8PfSL6w9woIDUF3XiNKqer3Oms5t/dHr93uqHadKUVbTgD4h7dChjZ82jjQbcX1ndGmnQvnVBjRqNKipV8NX2TRLqEGtQVuVL3wUClTUNkCtaRqv56tUQK0RJp+qDnhmnJDr2Mbfrsf3+Kl8hnowIiMj3WoYMhGRrbnilAxXmcrHuEFEpM8V44Y5jprKx7hBRKTPmrjh1JWF/f39MXToUGRkXFvsWaPRICMjA3FxcQb3iYuLk5QHgG3bthktr1KpEBQUJHkREZHrsUdM6NmzJ8LCwiRlKioqsHv3bsYNIiIP54h7DYBxg4iotZw+lS8lJQUTJ07EsGHDMHz4cCxZsgTV1dWYNGkSACApKQkRERFIS0sDADzzzDMYOXIkFi5ciPvuuw9r167F3r178cEHHzjzMoiIyAZsHRMUCgWeffZZvPbaa+jTpw969uyJGTNmoFu3bpLecyIi8ky81yAicn1OT0yNHz8eFy9exMyZM1FUVITo6Ghs2bJFu+hgfn4+lMprA7tGjBiBNWvWYPr06Xj55ZfRp08fbNy4EQMHDnTWJRARkY3YIyZMmzYN1dXVePLJJ1FWVobbbrsNW7ZsQUAA1+YiIvJ0vNcgInJ9Tl1jyhnccX48EZGtsS20HP+tiIjYFlqD/1ZERG60xhQREREREREREXkvJqaIiIiIiIiIiMgpmJgiIiIiIiIiIiKnYGKKiIiIiIiIiIicgokpIiIiIiIiIiJyCiamiIiIiIiIiIjIKZiYIiIiIiIiIiIip/B1dgUcTQgBAKioqHByTYiInKe5DWxuE8k4xg0iIsYNazBuEBFZFze8LjFVWVkJAIiMjHRyTYiInK+yshLBwcHOroZLY9wgIrqGccM8xg0iomssiRsK4WXdHhqNBhcuXED79u2hUCicVo+KigpERkaioKAAQUFBTqtHa/AaXAOvwTW42zUIIVBZWYlu3bpBqeSsblNaEzfc7e/CEF6Da+A1uAZvvgbGDcu5yv2Gpbz579qV8BpcA6/BdqyJG143YkqpVOK6665zdjW0goKC3PYPvhmvwTXwGlyDO10De7wtY4u44U5/F8bwGlwDr8E1eOs1MG5YxtXuNyzlrX/XrobX4Bp4DbZhadxgdwcRERERERERETkFE1NEREREREREROQUTEw5iUqlwqxZs6BSqZxdlRbjNbgGXoNr8IRrINvzhL8LXoNr4DW4Bl4DeSJP+JvgNbgGXoNrcMdr8LrFz4mIiIiIiIiIyDVwxBQRERERERERETkFE1NEREREREREROQUTEwREREREREREZFTMDFlR5cvX8YjjzyCoKAgdOjQAY8//jiqqqos2lcIgcTERCgUCmzcuFHyWX5+Pu677z60adMGISEheOGFF9DY2GiHK2jZNfz973/H9ddfj8DAQHTt2hVjx47FsWPHJGUUCoXea+3atW51Da78e7h8+TL++c9/om/fvggMDET37t3xr3/9C+Xl5ZJyrvx7sPQaXPn3AAAffPABRo0ahaCgICgUCpSVlemViYqK0vs9zJs3zy7XQLblCX8T9rqG1sRAR1xDbW0tpkyZgs6dO6Ndu3Z44IEHUFxcLCljzzZy6dKliIqKQkBAAGJjY7Fnzx6T5T///HP069cPAQEBGDRoEDZv3iz5XAiBmTNnIjw8HIGBgYiPj8fJkydtUldjbH0Njz32mN6/9+jRo+15CVZdw+HDh/HAAw9o//tcsmRJq49pC7a+hldffVXv99CvXz87XgHZgyf8XVhzDcuXL8ftt9+Ojh07omPHjoiPj9cr7+rtpCXX4Ort5BdffIFhw4ahQ4cOaNu2LaKjo/Hf//5XUsbRvwdb19/Vfwe61q5dC4VCgXHjxkm2O+O/BbME2c3o0aPFkCFDxK5du8TPP/8sevfuLSZMmGDRvosWLRKJiYkCgNiwYYN2e2Njoxg4cKCIj48X+/fvF5s3bxZdunQRqampLnMN77//vvjpp59EXl6eyM7OFmPGjBGRkZGisbFRWwaAWLlypSgsLNS+rl696jbX4Oq/h4MHD4r7779ffPXVVyI3N1dkZGSIPn36iAceeEBSzpV/D5Zcg6v/HoQQYvHixSItLU2kpaUJAOLKlSt6ZXr06CHmzJkj+T1UVVXZ5RrItjzhb8Je19CaGOiIa3jqqadEZGSkyMjIEHv37hW33HKLGDFihKSMvdrItWvXCn9/f7FixQpx+PBhMXnyZNGhQwdRXFxssPyOHTuEj4+PePPNN8WRI0fE9OnThZ+fnzh48KC2zLx580RwcLDYuHGjOHDggPjTn/4kevbsabc23R7XMHHiRDF69GjJv/fly5ftUv+WXMOePXvE1KlTxaeffirCwsLE4sWLW31MV7yGWbNmiRtvvFHye7h48aJd6k/24Ql/F9Zew8MPPyyWLl0q9u/fL44ePSoee+wxERwcLM6dO6ct4+rtpCXX4Ort5I8//ii++OILceTIEZGbmyuWLFkifHx8xJYtW7RlHPl7sEf9Xf130CwvL09ERESI22+/XYwdO1bymaP/W7AEE1N2cuTIEQFA/Prrr9pt3377rVAoFOL8+fMm992/f7+IiIgQhYWFeompzZs3C6VSKYqKirTbli1bJoKCgkRdXZ3LXIOuAwcOCAAiNzdXu01+XfZir2twx9/DZ599Jvz9/UVDQ4N2m7v9HuTX4E6/hx9//NFkEsLQl0BybZ7wN2Gva7DVf/OWaMm5ysrKhJ+fn/j888+1244ePSoAiKysLO02e7WRw4cPF1OmTNG+V6vVolu3biItLc1g+Yceekjcd999km2xsbHi73//uxBCCI1GI8LCwsRbb72l/bysrEyoVCrx6aef2rz+Qtj+GoRo+rIv//JsT9Zegy5j/4225pgtYY9rmDVrlhgyZIgNa0mO5gl/F639b6mxsVG0b99efPTRR0II92gn5eTXIIR7tZPNYmJixPTp04UQjv892Lr+QrjH76CxsVGMGDFCfPjhh3r1dcZ/C5bgVD47ycrKQocOHTBs2DDttvj4eCiVSuzevdvofjU1NXj44YexdOlShIWFGTzuoEGDEBoaqt2WkJCAiooKHD582CWuQVd1dTVWrlyJnj17IjIyUvLZlClT0KVLFwwfPhwrVqyAEMKm9Qfsdw3u9nsAgPLycgQFBcHX11ey3V1+D4D+Nbjj78GYefPmoXPnzoiJicFbb71lt+mIZDue8Ddhr2uw979Na8+VnZ2NhoYGxMfHa7f169cP3bt3R1ZWlqSsrdvI+vp6ZGdnS86tVCoRHx+vd+5mWVlZkvJAU1vXXD4vLw9FRUWSMsHBwYiNjTV6TFe7hmaZmZkICQlB37598fTTT+PSpUs2rz/QsmtwxjGddb6TJ0+iW7du6NWrFx555BHk5+e3trrkIJ7wd2GLa6ipqUFDQwM6deoEwD3aSTn5NTRzl3ZSCIGMjAwcP34cd9xxBwDH/h7sUf9mrv47mDNnDkJCQvD444/rfebo/xYs5Wu+CLVEUVERQkJCJNt8fX3RqVMnFBUVGd3vueeew4gRIzB27Fijx9W9CQegfW/quC3R0msAgPfeew/Tpk1DdXU1+vbti23btsHf31/7+Zw5c/CHP/wBbdq0wXfffYd//OMfqKqqwr/+9S+3uAZ3+T00Ky0txdy5c/Hkk09KtrvD76GZoWtwt9+DMf/6179w0003oVOnTti5cydSU1NRWFiIRYsWteq4ZF+e8Ddhr2uw57+NLc5VVFQEf39/dOjQQbI9NDRUso892sjS0lKo1WqDbZd8LUPd+hoq31zX5v83VcaW7HENADB69Gjcf//96NmzJ06dOoWXX34ZiYmJyMrKgo+Pj9OvwRnHdMb5YmNjsWrVKvTt2xeFhYWYPXs2br/9dhw6dAjt27dvbbXJzjzh78IW1/Diiy+iW7du2ptvd2gn5eTXALhHO1leXo6IiAjU1dXBx8cH7733Hu6++24Ajv092KP+gOv/Dn755Rf85z//QU5OjsHPHf3fgqWYmLLSSy+9hPnz55ssc/To0RYd+6uvvsIPP/yA/fv3t2h/S9nzGpo98sgjuPvuu1FYWIgFCxbgoYcewo4dOxAQEAAAmDFjhrZsTEwMqqur8dZbb1n8Zd8VrqG1HHENAFBRUYH77rsPAwYMwKuvvir5zB1+D4Dpa2gtR12DKSkpKdqfBw8eDH9/f/z9739HWloaVCqVXc9N+jzhb8IVrqG1XOEaWttGknX++te/an8eNGgQBg8ejOuvvx6ZmZm46667nFgz75KYmKj9efDgwYiNjUWPHj3w2WefGex9J+/gTn8X8+bNw9q1a5GZmWmz7+2OZuwa3KGdbN++PXJyclBVVYWMjAykpKSgV69eGDVqlLOrZhFz9Xfl30FlZSUeffRRLF++HF26dHFqXazFxJSVnn/+eTz22GMmy/Tq1QthYWEoKSmRbG9sbMTly5cNTtEDgB9++AGnTp3S68F94IEHcPvttyMzMxNhYWF6q/A3P0XI2HEdeQ3NgoODERwcjD59+uCWW25Bx44dsWHDBkyYMMFg+djYWMydOxd1dXUW3XQ5+xrc5fdQWVmJ0aNHo3379tiwYQP8/PxMlnfF34Opa3CX34O1YmNj0djYiDNnzqBv3742PTaZ5wl/E86+Blsc157XEBYWhvr6epSVlUlibnFxscn6WdtGGtKlSxf4+PjoPQHQ1LnDwsJMlm/+/+LiYoSHh0vKREdHt6ieptjjGgzp1asXunTpgtzcXJt/2W/JNTjjmK5wvg4dOuCGG25Abm6uzY5J9uMJfxetuYYFCxZg3rx5+P777zF48GDtdndoJ5sZuwZDXLGdVCqV6N27NwAgOjoaR48eRVpaGkaNGuXQ34M96m+IK/0OTp06hTNnzmDMmDHabRqNBkDTaPLjx487/L8FizltdSsP17wY6969e7Xbtm7danIx1sLCQnHw4EHJC4B4++23xenTp4UQ1xZ71l2F//333xdBQUGitrbW6ddgSG1trQgMDBQrV640Wua1114THTt2bE11DbLXNbjD76G8vFzccsstYuTIkaK6utqic7na78HcNbjD76GZqYWu5T7++GOhVCrt+oQPaj1P+Juw1zXYqu21REvO1bz4+fr167Xbjh07prf4uZyt2sjhw4eL5ORk7Xu1Wi0iIiJMLhz+xz/+UbItLi5Ob/HzBQsWaD8vLy+3+6K+trwGQwoKCoRCoRBffvmlbSotY+016DK1+HlLj9kS9rgGucrKStGxY0fx9ttvt6aq5ECe8HfRkmuYP3++CAoKMtiOu0M7KYTpazDEldvJZpMmTRIjR44UQjj+92Dr+hviSr+Dq1ev6uUTxo4dK/7whz+IgwcPirq6Oqf8t2AJJqbsaPTo0SImJkbs3r1b/PLLL6JPnz6Sx1efO3dO9O3bV+zevdvoMSB7IlBjY6MYOHCguOeee0ROTo7YsmWL6Nq1q0hNTXWJazh16pR44403xN69e8XZs2fFjh07xJgxY0SnTp20yYOvvvpKLF++XBw8eFCcPHlSvPfee6JNmzZi5syZbnMNrv57KC8vF7GxsWLQoEEiNzdX8jjTxsZGIYTr/x4suQZX/z0I0ZRw3r9/v1i+fLkAILZv3y72798vLl26JIQQYufOnWLx4sUiJydHnDp1Snz88ceia9euIikpyS7XQLblCX8T9rgGS47r7Gt46qmnRPfu3cUPP/wg9u7dK+Li4kRcXJz2c3u2kWvXrhUqlUqsWrVKHDlyRDz55JOiQ4cO2ieMPvroo+Kll17Slt+xY4fw9fUVCxYsEEePHhWzZs0Sfn5+4uDBg9oy8+bNEx06dBBffvml+O2338TYsWPt/hh0W15DZWWlmDp1qsjKyhJ5eXni+++/FzfddJPo06ePzTsaWnoNdXV1Yv/+/WL//v0iPDxcTJ06Vezfv1+cPHnS4mO6wzU8//zzIjMzU+Tl5YkdO3aI+Ph40aVLF1FSUmKXayDb84S/C2uvYd68ecLf31+sX79e8p2xsrJSUsaV20lz1+AO7eQbb7whvvvuO3Hq1Clx5MgRsWDBAuHr6yuWL18uuU5H/R5sXX93+B3IGXqKoKP/W7AEE1N2dOnSJTFhwgTRrl07ERQUJCZNmiRpHPPy8gQA8eOPPxo9hjwxJYQQZ86cEYmJiSIwMFB06dJFPP/886KhocElruH8+fMiMTFRhISECD8/P3HdddeJhx9+WBw7dky7z7fffiuio6NFu3btRNu2bcWQIUNEenq6UKvVbnMNQrj276F5FIOhV15enhDC9X8PllyDEK79exCi6fHKhq6hefRddna2iI2NFcHBwSIgIED0799fvPHGG3YLbmRbnvA3YY9rsOS4zr6Gq1evin/84x+iY8eOok2bNuLPf/6zKCws1H5u7zby3//+t+jevbvw9/cXw4cPF7t27dJ+NnLkSDFx4kRJ+c8++0zccMMNwt/fX9x4441i06ZNks81Go2YMWOGCA0NFSqVStx1113i+PHjNqmrI66hpqZG3HPPPaJr167Cz89P9OjRQ0yePNluCZ2WXEPz35H8Je9JN3VMd7iG8ePHi/DwcOHv7y8iIiLE+PHjRW5url2vgWzPE/4urLmGHj16GLyGWbNmacu4ejtp7hrcoZ185ZVXRO/evUVAQIDo2LGjiIuLE2vXrpUcz9G/B1vW3x1+B3KGElPO+G/BHIUQdng2PBERERERERERkRlKZ1eAiIiIiIiIiIi8ExNTRERERERERETkFExMERERERERERGRUzAxRURERERERERETsHEFBEREREREREROQUTU0RERERERERE5BRMTBERERERERERkVMwMUVERERERERERE7BxBQRERERERERETkFE1NEREREREREROQUTEwReYlRo0ZBoVBAoVAgJydH8tm///1v9OjRA76+vpg6darRYzz22GPaY2zcuNG+FSYiIqdi3CAiImswblBLMTFFbkm3wdJ95ebmOrtqLm3y5MkoLCzEwIEDtdsOHDiAlJQULFu2DAUFBZgzZ47R/d9++20UFhY6oqpERDbFuNEyjBtE5K0YN1qGcYNawtfZFSBqqdGjR2PlypWSbV27dtUrV19fD39/f0dVy6W1adMGYWFhkm3ffPMNhg8fjnvvvdfs/sHBwQgODrZX9YiI7Ipxw3qMG0TkzRg3rMe4QS3BEVPktlQqFcLCwiQvHx8fjBo1CsnJyXj22WfRpUsXJCQkAAA0Gg3S0tLQs2dPBAYGYsiQIVi/fr3kmNXV1UhKSkK7du0QHh6OhQsXYtSoUXj22We1ZaKiorBkyRLJftHR0Xj11VctPs+oUaPwr3/9C9OmTUOnTp0QFham3b+ZRqPBm2++id69e0OlUqF79+54/fXXsXr1anTu3Bl1dXWS8uPGjcOjjz5q1b9h7969MX36dOzcuRMKhQJJSUlW7U9E5E4YNxg3iIiswbjBuEGOwcQUeaSPPvoI/v7+2LFjB9LT0wEAaWlpWL16NdLT03H48GE899xz+L//+z/89NNP2v1eeOEF/PTTT/jyyy/x3XffITMzE/v27bPq3Jacp7mObdu2xe7du/Hmm29izpw52LZtm/bz1NRUzJs3DzNmzMCRI0ewZs0ahIaG4sEHH4RarcZXX32lLVtSUoJNmzbhb3/7m1V13blzJ3r16oW33noLhYWFeO+996zan4jIUzBuWIZxg4ioCeOGZRg3yCKCyA1NnDhR+Pj4iLZt22pff/nLX4QQQowcOVLExMRIytfW1oo2bdqInTt3SrY//vjjYsKECUIIISorK4W/v7/47LPPtJ9funRJBAYGimeeeUa7rUePHmLx4sWS4wwZMkTMmjXLovM01/G2226TlLn55pvFiy++KIQQoqKiQqhUKrF8+XKD1//000+LxMRE7fuFCxeKXr16CY1GY7B88zl1r0MIIaqrq4VSqRRZWVnabV9//bW44YYbRO/evY2eH4DYsGGD0XMREbkaxg3GDSIiazBuMG6Q43CNKXJbd955J5YtW6Z937ZtW+3PQ4cOlZTNzc1FTU0N7r77bsn2+vp6xMTEAABOnTqF+vp6xMbGaj/v1KkT+vbta3GdLDlPs8GDB0veh4eHo6SkBABw9OhR1NXV4a677jJ4nsmTJ+Pmm2/G+fPnERERgVWrVmkXaLTGb7/9BgAYNGgQAKCxsREpKSn48ccfERwcjKFDh+LPf/4zOnfubNVxiYhcEeMG4wYRkTUYNxg3yDGYmCK31bZtW/Tu3dvoZ7qqqqoAAJs2bUJERITkM5VKZdV5lUolhBCSbQ0NDVafx8/PT/JeoVBAo9EAAAIDA03WISYmBkOGDMHq1atxzz334PDhw9i0aZNV1wEAOTk56N27t/bfa8+ePbjxxhu1dU9MTMR3332HCRMmWH1sIiJXw7jBuEFEZA3GDcYNcgwmpsgrDBgwACqVCvn5+Rg5cqTBMtdffz38/Pywe/dudO/eHQBw5coVnDhxQrJP165dJY8wraioQF5ensXnsUSfPn0QGBiIjIwMPPHEEwbLPPHEE1iyZAnOnz+P+Ph4REZGWn2enJwcDBkyRPv+woULkgAXERGB8+fPW38BRERujnHDMMYNIiLDGDcMY9wgSzAxRV6hffv2mDp1Kp577jloNBrcdtttKC8vx44dOxAUFISJEyeiXbt2ePzxx/HCCy+gc+fOCAkJwSuvvAKlUvqMgD/84Q9YtWoVxowZgw4dOmDmzJnw8fGx+DyWCAgIwIsvvohp06bB398ft956Ky5evIjDhw/j8ccfBwA8/PDDmDp1KpYvX47Vq1e36N8lJycHf/rTn1q0LxGRJ2PcMIxxg4jIMMYNwxg3yBJMTJHXmDt3Lrp27Yq0tDScPn0aHTp0wE033YSXX35ZW+att95CVVUVxowZg/bt2+P5559HeXm55DipqanIy8vDH//4RwQHB2Pu3LnaHgxLz2OJGTNmwNfXFzNnzsSFCxcQHh6Op556Svt5cHAwHnjgAWzatAnjxo2z+t9Do9Hg4MGDmDFjhnZbt27dJD0W58+fx/Dhw60+NhGRJ2DckGLcICIyjXFDinGDLKUQ8smrRCQxatQoREdHY8mSJc6uip677roLN954I9555x2zZS25jsbGRvTv3x+ZmZnaxQh37typtxihQqHAhg0bWhSgiIg8HeMG4wYRkTUYNxg3vJ3SfBEicjVXrlzBhg0bkJmZiSlTpli833vvvYd27drh4MGDBj/39fXFwoULceeddyI6OhrPP/+8JEg89dRTaNeuXavrT0REjsW4QURE1mDcIEfiiCkiM1yxByMqKgpXrlzBjBkzMHXqVIv2OX/+PK5evQoA6N69O/z9/a0+b0lJCSoqKgA0PW5W/jQSIiJi3NDFuEFEZB7jxjWMG96JiSkiIiIiIiIiInIKTuUjIiIiIiIiIiKnYGKKiIiIiIiIiIicgokpIiIiIiIiIiJyCiamiIiIiIiIiIjIKZiYIiIiIiIiIiIip2BiioiIiIiIiIiInIKJKSIiIiIiIiIicgompoiIiIiIiIiIyCmYmCIiIiIiIiIiIqdgYoqIiIiIiIiIiJyCiSkiIiIiIiIiInKK/wer3upp9Akh6gAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "plt.figure(figsize=(12,4))\n",
+    "ax1 = plt.subplot(131)\n",
+    "ax2 = plt.subplot(132)\n",
+    "ax3 = plt.subplot(133)\n",
+    "for ax, region in zip([ax1, ax2, ax3], ['lowerH', 'center', 'upperH']):\n",
+    "    ax.plot(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])\n",
+    "    ax.set_xlabel(f'Frequency [$f_0$]')\n",
+    "    ax.set_ylabel(f'PSD [arb. units]')\n",
+    "    #ax.set_yscale('log')\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "969b2106-22fe-4a54-bfdc-6f213f653a25",
+   "metadata": {},
+   "source": [
+    "Tracking more turns to observe the mean value of the spectra "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "506e2d3f-0eae-4f9b-89f4-ea373b6e67c6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Tracking: 100%|█████████████████████████████████████████████████████| 100000/100000 [04:00<00:00, 415.31it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "line.track(bunch, num_turns=200_000, with_progress=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "94563a0e-fa86-422b-806a-b53c5c18644b",
+   "metadata": {},
+   "source": [
+    "We can now plot the average over 21 specta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "823b7193-2839-4269-aaf8-01e3ebdef380",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lowerH band of Schottky spectrum processed\n",
+      "upperH band of Schottky spectrum processed\n",
+      "center band of Schottky spectrum processed\n",
+      "Maximal Talor truncation error in z plane to be compared against sqrt(PSD): 3.80657433491217e-20\n",
+      "Maximal Talor truncation error in x plane to be compared against sqrt(PSD): 5.190120322201753e-22\n"
+     ]
+    }
+   ],
+   "source": [
+    "schottky_monitor.process_spectrum(inst_spectrum_len=10000, deltaQ=5e-5, band_width=0.3, Qx=0.27, Qy=0.295, x=True, y=False, z=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "09f88357-b97b-46e8-b5cd-2523fee01b7f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "plt.figure(figsize=(12,4))\n",
+    "ax1 = plt.subplot(131)\n",
+    "ax2 = plt.subplot(132)\n",
+    "ax3 = plt.subplot(133)\n",
+    "for ax, region in zip([ax1, ax2, ax3], ['lowerH', 'center', 'upperH']):\n",
+    "    ax.plot(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])\n",
+    "    ax.set_xlabel(f'Frequency [$f_0$]')\n",
+    "    ax.set_ylabel(f'PSD [arb. units]')\n",
+    "    ax.set_yscale('log')\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57c9167f-70a9-443a-a133-2b93ecf31edb",
+   "metadata": {},
+   "source": [
+    "Compute shottky spectrum for different processing parameters (but same tracking) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "7df0ea6b-a0e6-4e06-bb86-003b19c39045",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "lowerH band of Schottky spectrum processed\n",
+      "upperH band of Schottky spectrum processed\n",
+      "center band of Schottky spectrum processed\n",
+      "Maximal Talor truncation error in z plane to be compared against sqrt(PSD): 4.693176884032811e-22\n",
+      "Maximal Talor truncation error in x plane to be compared against sqrt(PSD): 1.749522590303493e-22\n"
+     ]
+    }
+   ],
+   "source": [
+    "schottky_monitor.clear_spectrum()\n",
+    "schottky_monitor.process_spectrum(inst_spectrum_len=5000, deltaQ=5e-5, band_width=0.1, Qx=0.27, Qy=0.295, x=True, y=False, z=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "b3b0cf65-2824-4dad-904f-255ff53275c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKQAAAGGCAYAAABFf1lKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZwd1Xkmjj9Vd+u9tUtoAZnF2DK2hDFg4tiGRAlREjvGscOMMzMEz5AZR+TrRJn4Z2YmeJYkJGOHMHF6QmKHYGeZkHhiMjGYAPIiYzCLQGAQIBaB9lZ3q/fuu9fvj6r31Funzjl1W2qpu9Xv8/noo15O1z333rpnec7zPK8XBEEAgUAgEAgEAoFAIBAIBAKB4AzBn+sOCAQCgUAgEAgEAoFAIBAIFheEkBIIBAKBQCAQCAQCgUAgEJxRCCElEAgEAoFAIBAIBAKBQCA4oxBCSiAQCAQCgUAgEAgEAoFAcEYhhJRAIBAIBAKBQCAQCAQCgeCMQggpgUAgEAgEAoFAIBAIBALBGYUQUgKBQCAQCAQCgUAgEAgEgjMKIaQEAoFAIBAIBAKBQCAQCARnFPm57sBCRbPZxJEjR9Dd3Q3P8+a6OwKBQHDSCIIA4+PjWLt2LXxfzilmEzJXCASCswUyV5w+yFwhEAjOFsx0rhBC6iRx5MgRbNiwYa67IRAIBLOGgwcPYv369XPdjbMKMlcIBIKzDTJXzD5krhAIBGcbWp0rhJA6SXR3dwMIX+ienp457o1AIBCcPMbGxrBhwwY1rglmDzJXCASCswUyV5w+yFwhEAjOFsx0rhBCaobo6+tDX18fGo0GAKCnp0cmDoFAcFZAbAKzD3pNZa4QCARnC2SumH3IXCEQCM42tDpXiAF8hti+fTv27t2LJ598cq67IhAIBAKBQCAQCAQCgUCwICGElEAgEAgEAoFAIBCcYfT19WHTpk24/PLL57orAoFAMCcQQkogEAgEAoFAIBAIzjDEeSEQCBY7hJASCAQCgUAgEAgEAoFAIBCcUQghJRAIBAKBQCAQCAQCgUAgOKMQQkogEAgEAoFAIBAIBAKBQHBGIYSUQCAQCAQCgUAgEAgEAoHgjEIIqRlCqmEIBAKBQCAQCAQCgUAgEJwahJCaIaQahkAgECwuXHfddVi6dCk+9rGPzXVXBAKBQCAQCASCswZCSAkEAoFA4MCnP/1pfPWrX53rbggEAoFAIBAIBGcVhJASCOYxXjgyiucPj851NwSCRY2rr74a3d3dc90NgcCKR18bxKOvDc51NwQCgUBwluDJN07g8Mj0XHdDsAgghJRAME9xaHgKH/7j7+Nnv/gIdu0bmOvuCATzErt27cKHPvQhrF27Fp7n4d5770216evrw8aNG9HW1oYrr7wSTzzxxJnvqEBwmvC9VwbwiS89jk986XHc99zRue6OQCAQCBY4nnzjBD5+52P4xJd+gEYzmOvuCM5yCCElEMxT7D0ypiaBB/cem+PeCATzE5OTk9i8eTP6+vqMv7/nnnuwY8cOfO5zn8PTTz+NzZs349prr8Xx48dVmy1btuCSSy5J/Tty5MiZehoCwUlj54vxvfzIq3J4IRAIBIJTw7MHRwAAbw5NYV//+Nx2RnDWIz/XHRAIBGYcODGlvh4Yr8xhTwSC+Ytt27Zh27Zt1t/ffvvtuOmmm3DjjTcCAO68807cd999uOuuu/DZz34WALBnz55Z60+lUkGlEn9ex8bGZu3aAoEJx8fL6uuB8eoc9kQgEAgEZwOGp+K55NXjE3j7OT1z2BvB2Q5RSAkE8xQTlbr6enS6Noc9EQgWJqrVKnbv3o2tW7eqn/m+j61bt+Kxxx47LY952223obe3V/3bsGHDaXkcgYAwNBFvHE5MyuGFQCAQCE4Ng+xw4+io5EgJTi+EkBII5inKtab6ulJvOloKBAITBgcH0Wg0sHr16sTPV69ejWPHWrfBbt26FR//+Mdx//33Y/369U4y65ZbbsHo6Kj6d/DgwZPuv0DQCk5MVo1fCwQCgUBwMpisxofiE5XGHPZEsBgglr0Zoq+vD319fWg05MMpOL2o1ON7jJNTAoHgzOLhhx9uuW2pVEKpVDqNvREIkuBq2vFy3dFSIBAIBIJs8IPwyYrMK4LTC1FIzRDbt2/H3r178eSTT851VwRnOZIKKSFABYKZYsWKFcjlcujv70/8vL+/H2vWrJmjXgkEswu+cSjXZK4QCAQCwamBzysTctAhOM0QQkogmKeosI1FRRRSAsGMUSwWcdlll2Hnzp3qZ81mEzt37sRVV101hz0TCGYPfK6YrjUQBFKiWyAQCAQnjyo7CJ+oCiElOL0Qy55AME9RZpOBKKQEAjMmJibw6quvqu/379+PPXv2YNmyZTj33HOxY8cO3HDDDXjPe96DK664AnfccQcmJydV1T2BYKGDn2Q3A6DWCFDMe3PYI4FAIBAsZIhlT3AmIQopgWCegquiRCElEJjx1FNP4dJLL8Wll14KANixYwcuvfRS3HrrrQCA66+/Hl/4whdw6623YsuWLdizZw8eeOCBVNC5QDDfcO8zh3H7Q/ucBxL1RhP1ZlIRNe2w7ZVrDfzWvc/jzx/ZL0oqgeAkcN1112Hp0qX42Mc+lvrdN77xDVx88cW46KKL8OUvf3kOeicQzA74vqPWkD2I4PRCFFICwTxFUiElk4FAYMLVV1+dubG++eabcfPNN5+hHgkEp47dbw7j1+7ZAwBYv6Qdv3D5BmM709xQqTWA9oKx/QPPH8Nf/uBNAMAFKztx9cWrZqfDAsEiwac//Wl88pOfxFe+8pXEz+v1Onbs2IFvf/vb6O3txWWXXYbrrrsOy5cvn6OeCgQnjyojoWp1ObwQnF6IQkogmKfgE0C10USzKROCQCAQLHS0okz67svH1dd7j45Z23FCqq0QLulcCqmX+8fV1995eSCzHwKBIImrr74a3d3dqZ8/8cQTeMc73oF169ahq6sL27Ztw4MPPjgHPRQITh1cmVtrZh+KHxstY2Sqejq7JDiLIYSUQDBP0dA2La1MCAKBQCAw48DQFF49PjHr1z14YgqvMKLHhrFyDT/zR9/D+37vWzg+Xna25cTRwHjF2o42DYWch85iKHovOyzeB09MGb82IQgCfGnX6/i7pw462/H2p+Pg5KG9/dj5Yn92Q8Gix65du/ChD30Ia9euhed5uPfee1Nt+vr6sHHjRrS1teHKK6/EE088MSuPfeTIEaxbt059v27dOhw+fHhWri0QuPB/njiAv378zVm95kwse8dGy/jxP/gOfuaPHpHMW8FJQSx7AsE8hZ4L0hCFlEAgEJwUDo9MY9v/2oVqo4lv/Or7cfGatMLhZDA0UcG1d+xCudbAQzs+iAtWdlnb3vvMYbxwJFQ7ffflAXz8PWYbHgCcmIxPmp2EVLRpaMvnUMiFZ4yuzcM4K999eGTa2g4Anth/Ar9z/4sAgA1LO3DVBXbr0Xi5ho/0fR897QX87S+/F6V8znntVvHUGydw01efAgD8080/ineu752V6wrOTkxOTmLz5s345Cc/iY9+9KOp399zzz3YsWMH7rzzTlx55ZW44447cO211+Lll1/GqlWhfXXLli2o19Mhzg8++CDWrl172p+DQDAT7B+cxC3/8EMAwOUbl+Gtq2dnbqvNwLL33KERTFYbmKxOY++RMVx67tJZ6YNg8UAIKYFgnkI/adYJKoFAIBC0hgeeP4bJanhy+919x2eNkLr/h0cxFV33B68POQmp3W8Oq69fyVBqDTFC6oTDBkGWvVLBRyGqrFd1ElI19fXYdM3aDgB2H4j7+88vHHMSUo++NoTXBiYBAA++0I8PbZ6djfujrw2pr7/98nEhpARObNu2Ddu2bbP+/vbbb8dNN92kqqzeeeeduO+++3DXXXfhs5/9LABgz549J/XYa9euTSiiDh8+jCuuuMLavlKpoFKJyeaxMbs1VyCw4Yn98Ri5f3By1ggpfgie5dAYmYrnkn3940JICWYMsewJBPMUuiJKMqQEAoHg5MCtei8dy7bXtYqnGMl0JENx9MbgpPq6f8xt2RtmhNSUo+Q22SNKTCFVb9jnigl2rfGMUt7HRuM+Zlkd97HX9NsvHXe0nBn4a/b6wOzbLQWLB9VqFbt378bWrVvVz3zfx9atW/HYY4+d8vWvuOIKPP/88zh8+DAmJibwzW9+E9dee621/W233Ybe3l71b8MGu2JSILDhzaHYes2VtacKnhqSZdkbZocmx8fsil6BwAYhpASCeQqdkBKFlEAgECSxa98A/vs/7cVkBrnCySKXBY7w9IFhPPD80cx2LzMi5uiIm2QanGCqp4yNw2QlzuEgZZcJSiGV91Hwsy17E8yyN1GpOwPWjzJC6uCwO2+KK7pcIeyEWqPZkg2dk2ZHRt2v73i5hs987Vn87RMHMq8rWHwYHBxEo9HA6tWrEz9fvXo1jh071vJ1tm7dio9//OO4//77sX79ekVm5fN5/MEf/AGuueYabNmyBb/xG7/hrLB3yy23YHR0VP07eLC1rDaBgIPPbVOOuWKm4Dm2WZa9YaaQGpgQQkowc4hlTyCYp9BDzSVDSiAQCGJU6038yl8/jYlKHV1teez4ibda244xq1oWGTReruEXv/Q4pmsNfP1XfsRqPwiCAK8zBY/LWhcEQWKhzi0OOhrNIGG7m4yII8/zUm3LUUW9Yt5HPhf+3pkhxQieIAg3MJ0l81JwlFn6hibcrxm3/70+MGntLxC+vj9x+y6s7C7hH37lR5SyywROoI06XjMA+Opjb+LvnjqEv3vqEH5281p0WZ6XQHAqePjhh62/+/CHP4wPf/jDLV2nVCqhVCrNVrcEixRc9Vp2VFidKRKWvQyFFH/coYz5dbrawCfvfhIru0v4X/9ii3WeECwuiEJKIJinEIWUQCAQ2HHgxKRajD/D8o5M4IRJFiG1+81hTEcLbAohN2Gq2kC1Hi/UXZlM5Voz0XbYmQuV3FTUNYKKg65ZzPvIK4WUea5oNoPE5gVIhpzr0NVUdcemZIQ992qjiTHHdb//6iCOjZXxw8OjeO7QiLUdPW78GO73jVsxnzvovq5g8WHFihXI5XLo709WbOzv78eaNWvmqFcCwamBj5GVWSSkmkHrhFSdZUxl9eEH+4fw2OtD+H/PHkG/2PsEEYSQmiH6+vqwadMmXH755XPdFcFZDp2QajhyQQQCgWCxgWdnZFWM4wRJVpj3E/tPqK8PnrBb1XRSadRx3Wltke6yGJZr6cU/t/Bx0EFF3vdQzKiyN1VrqFyQnB+eSrtKdE9Wk33UySyOEe210L/neIO9b4+x0HITEoRUhkLqzaFYrXZo2H0/CBYfisUiLrvsMuzcuVP9rNlsYufOnbjqqqvmrF+yrxCcCrhNr1J3E0czQTORIeXef/D9ij7X6RhklvkXW7B3CxYHhJCaIbZv3469e/fiySefnOuuCM5ypBVSszfRCAQCwUJHgpAannbmIfHqclO1hrNIBM9AGnRY1XSCxKUK0hfprqwPZcPL+YpkslkxGoqQiqvs2QipafaYve0FAO4NjE6audRUIxoZ51Kh8dft2UOj1nb6Y1bqSZWZjgOMPDyUQVAKzk5MTExgz549qlLe/v37sWfPHhw4EOaK7dixA1/60pfwla98BS+++CI+9alPYXJyUlXdmwvIvkJwKpicB5Y9XkhjOiPHih8yHMrIJhQsHojBXiCYp0hV2XNstgQCgWCxgWcyVepNTNca6CimlzWVeiOhOgoCoFw3twWSFeVGHTYxyqVqK/go15puhZS2SK/Um6g3msgb8pN4UDkQWuBsxBEppHK+l2nZIzVUMe+ra1cMaiyCTkDxHC4dlO/ke+HJuuu14OqpFw67CamJSvI65XoDxXz6NWs0gwTRNTyL1aYECwdPPfUUrrnmGvX9jh07AAA33HAD7r77blx//fUYGBjArbfeimPHjmHLli144IEHUkHnAsFCwelQSOkHNvVm4MwFrCcUUu4+cCu4HBwICEJICQTzFHqouWRICQQCQQyd9BiZqhlJJpOyZ7JiJ6+4/c9FrBCZs7qnDW8OTaFab6Jca6CtkEu1pZPrFV1FpbqaqjXQYyCkqG2pkAtVXxVYlUGNSDmbz3kqHNyW9VRlRJcipCyWvRojwXra8hgr162n70EQKIXUOb3tODwy7Typ58TRsbEyGs1AWQg56o1myr5YrjXQ01ZItdXthbpiS7A4cPXVVzuVkgBw88034+abbz5DPRIITi84ITVbCil9/wGEBw05S/44359k9YErpLKKZQgWD8SyJxDMU6Qse5IhJRAIFgFGp2r47P99Dvf/8KiznZ4FZcsYmorylzqKOXQUQ7LIZisYm66Dr8WdhFRE5izvLIIOjm35VGTZ62krIB+RL1OWXCha0LcVsokjmhfyvodCRpU9CkYPCalcdF1zW24DWdEVVgKzqakmKnU1X61d0gbAnSPCs7eagd3ex3OzSBVVrpr7oJOOrgwrgWA+QTKkFg+ePTiCff3j2Q1nAD7em/IHTwYmR4ar0neDRYpkWfZ4pdesPEfB4oEQUgLBPEUq1FwUUgKBYBHgf3/3VfztkwfxK3/9tHPc0zObbFXYiIgp5n2litIVNYTxcmskFxAv/tuLOaXasdnaaJHeVohJMVsf6LpthZwiYuwKKbLs+UohVbVZ9qLrFnM+SgU30UWn2MW8j6628DUrW9rSa1TK+1jSUQQATFuII96eMDBurrQ0Xoktkd0ldx8mUoSUe6Pzx996BVfdthNPZ1RnFAhONyRDanFgeLKKj9/5GH7yD3c57c8zBSekbNVYZwpTZK0rNoTbxLNCzcuMsJrN10GwsCGElEAwT2HycAsEAsHZjmfeHFFfvz4wYW2nn66OWkgIInOKOR+dpZAMmrKQQXoluVYUUm35HHra8872tEhvL+bQGZErVoVUnSuk3EomXmUvHymkrJY9UkgVcpkZUqRO6irlVVvb6Ts95yUdBbRHdkXXpkQnDnUSkEDvRVcpr2yQttN3/Rq29xcI37cvPLgPR0fL+KOdr1jbCQQCwWzh1YEJNQbznEITyrUG/u3dT+J37tvrbBcEQYIMmq19gsmy51ZIsT5kkGI11nZ02j5OCxYXhJASCOYpaGIhG4YopAQCwdmOIAiw73hsaTgyWra2pdPV7kjBY8sNohPkQo4ppCxkEClt1vSE1rNKlAtlAhE0pYKvqtbZCCm6RnsLCqlKLSa6WlZI5TxlBTRtJvg1irlsoovCxDkZZHsd6Dn3tjNCyvLcgiDAcEQcLu0IXzNbxUF6L7pKeaXosvVhXCMSXbaRQ8NxRljWxhCwv/YCgUDQKg6wqrBZRRd27RvAzpeO40vf2+9sm3ZSzM5YZdpv2OYVIEmE1TL2Kpywsh1GCBYfhJASCOYpaPCnst/1WZpoBAKBYDYxVq7hOy8fzywNXa41MvMlxsr1hN3q+JiDkIpOV9ctaQdgX9zy7KTOolshRTbAc5a0qVwoG8nEFVJL2kOrms0qxi17SiGVYdkrtZIhxRRSFAzemEmVPatlL/x5ZymfSV7Rc+5tL6C96FZIlWtNRfCsWxq+b1b7JCmk2vKZyisir1Z0FZ3tAODAiXhjeGh4OqWK4/jy917H237rm/jcPz5vbSMQCARZ4AcmrjEHCNVUhMOOSnS6IspWYXWmMBUG0F0biX6wuT9TIcUthkL2CyIIISUQzFPQCQWdkAsfJRAI5iM++RdP4pf+4knc8fA+a5vpagM/+8VHcMXvPoyXj9lDXQfGkwTUcUu+EBCrZVZFaiY9R4hAi95CzkdHKUMhFW0UetoKSvVkI5lmopCaZkHlSiFl6UOVKbrirCd3lb2c78H3WlNIlfK+svfZNjD0WnaX8mjLUCeRBW9JR5FZ68z9pUDzQs7Dyigs3WZd5AqpWKXlDjVf2R3eCzbVFQAcZIQUALwxOGlsV2808b92voJmAHzlsTdxxLEx3D84idvufzGhghAIWoGEmi8O8AOTLEKKj1Gutnpm1Gw5KYwKKRchxX7XDNzkFZ9zZivzSrDwIYSUQDBPoRNSopASCATzDYMTFTz1ZhgMfc+TB63tHnt9EK8en8B4uY4/+c6r1nY6AWULvAZigmVFZ6iK0UPOVTsWap6lkJqINg1dbXksySCZSF1UyufQk9E2JoNy6Cy6FVJNpnoihWxLGVK+295N1yjmfeRJeWvZEEwydRIppLIypHrbCyhSjpVlviJCqre9qJRiNoVUnCEVWwFtpBhZDFd1RxUB603r66CXGj9msYUeHJ5OVO/be2TM2A4AfuPv9uBPd72OW77+nLWNQGCChJovbJRrDavSlGOM5SVNZhBSvPKoq61efXu2M6Q8D0op7LLs6WNtzbFf4QopW4ahYPFBCCmBYB6Cny4oQmqWpLgCgUAwW3j24Ij6enCiisEJM4H0Sn9sQdj54nErEaITUERg6Gg2A0U0LY9sWraT5Fgh5akMKZuCZioiPDoKOfR2kA3P3AdeDW9Jh5uQ4sQRqbQmLMogWvj7npdplyN7Xs734bdISJXyviKvbBsYsst1lvJqDrJZMilMfkl7QRFdNuXVCMuP6lR5XjZyMFJptWWrtIg4IkLK1VZ/j/rHzYTUG0OTzu8JY+Uanj4wAgD4/qtD1scVCARnF46NlnHl7+7Etju+l2lVSyikLIcnhOHJuO2kQ+2pP2ZWH1oF8Uk5z0MuYqRcZ+LpfrjsfTNTSJVrjcw4AMHChxBSAsE8BN8kUClvoaMEAsF8wwHN/mRTkRxlKpTxSt26uR/U1Ct6JT0CX8guj6xftgypGlNIdUVV9sYtG4JaPSomkfdnoJBilj2LvY+HjyuVloWIoQOJnO9lhponMqRatOwV8z7yvp/4ex3cLlfIqN5HJNOSjoKar2wbCCIYl3YUlR3R9tzGTVX2MgipFYyQspGO+vt5YsJMOL6pWfkGLGSrfs+3EpQuEAgWPna+1I/R6RpeH5y0zmkEPue4LMUAcIIdgtjmCeD0WfaadCjie/FBR4uh5oCbkOLqqUYzcPb56Og03v0/HsLP/8mjxlwrwdkDIaQEgnmIJht4C9HGoSmDsUAgmGc4qtmdeAUzDp0Aem3AvHinxTcpjmw2PK4YWt7ZqkLKV9a6TPIq52eqnrhCKitDihNHZFWbsFjVaIHu+15m+HiDkVe5nDvUPCakcpnVW8lG192WV+SVrXoSt+xlkVfDjLxSdkRLW0WKteUziTme/ZVl7yPFG72/eoU+wlEtUH9w3ExcvaIRUHpGlUAgODvxAiOjT0yax37CGJtzspRBXEHlVkjpoeazW2XP98AUUrNv2QPcweZPvjGMqWoDzx0aTbzWgrMPQkgJBPMQCYVUPpwM5HRAIBDMN+iE1OER82ZcJ4BetxBSpIBZHYVT2xRSRNB4HrAsIqSsqidWZa+nzU101VSguKcUUrZQc26By1JT8fBxlZ1kIUJoj5HzZlchxftLFflsGxh6LTuLLSikolDz3o4iU0hZLHtRNsqyzmLmc6MNXFcpr4g5q5qKZX+1q5wwt0Jq/VJ3dUbKmjpveQcA4MSkWSGlV4J0VcUSCHRIqPnCBf/s28Z+Aj8wyaouV2YHENOWgwsgndU32wqpnOdl2ruB9DzSqmUPsB+2AMCx0Xgs/cHrQ/YOCxY8hJASCOYh+KSSVwqpueqNQCBYrJiuNvD6gN2CdDTafL9rfS8A4HCGQoo290dHze2IRFjdGxFSFrJAqX1yProjkqmVKns97SEZZCO6iEjJ5/w4Q2rarIypMQvcjBRSyrJnXohzy15mhhQRXTlPkUy2k2xu2SPiyLaBmWCh5lkV+UajsN5QIeW27J2YiivyUVvb5ozyyFZ2lZSayqYsiBVSeaWQsoXGU/n1DUvDe9FGTg5Fj/+WFZ2Jx9DRrxFSR0bMmVSHR6bx29/Yi8dlYyVgkFDzhYsBZve1zSmEaUaQ28ZzAld3Vl32t9MVas5UulnZhKbfuZRa+hjuIud4pqRtXBWcHRBCSiCYh0iEmufEsicQCOYGN9z1BH7sD76L//fsEePvSSG1ZcMSAPacHSKWLljZBSC9iSeUlUIqzALilYk4uNqnK1Ic2avsxRVLSSE1NGkhmRoxeZWlkOIkE1kBR2wKKRY+rix7VoUUCzWPcpZs1YgUgebHhJRtU0In0cUcV0jZMqTC59FdyrO8KVuoeUQytRcYeeXOm1rWWcgMSydCakV3rKaybeR45hUFoNvajqUUUhZCKrpHNi7vdLbrHwv7+Y61PQCAIxaF1P/4p7348iP78ct/udtKtAoEgoWDITbfZSmk+HjkImGCIEhUNHWROzNRJs0ENIXk2Lzi2oPoc46LvEorpOzPj2cGZr2+goWNRUFIXXfddVi6dCk+9rGPpX73jW98AxdffDEuuugifPnLX56D3gkEafDBPZ4M5qo3AoFgMeKlY2N44o0TAIC/+P5+YxsqT33Rqq7oe/OikTbzF6wMN/fHx83EFSmk1kQKqelaw7h453lI3W1E8LjVVIWcj4tWd6vnZsoYijOkvMwMKW7Dm4lCigi0yYwMqZwPpgzKypDy46yPjFDzUsFXxFHDQjJNRuqtrjZu2cvOkCpmWPaGmULKZcNrNgOVR7aquy3T3jeuKvIVUIxUZaa2QRAoUmzDskghZXnPyLK3MVL12QhEOsUnUvaIQf0XBAF2vTIAIHy9vvL9N4zXEggECwfcFmwruEDg45HLpqYTNK7Keakw8dkONfc8+F62QkqfG2yHF2FbTSHleH6cmBNC6uzGoiCkPv3pT+OrX/1q6uf1eh07duzAt771LTzzzDP4/Oc/j6EhkVIL5h7Kv+17iA6nJUNKIBCcUXztqUPq6xeOjKU2+JV6Qy3C37IiJKRGpszKo3FNIXV8zExI0fVWsWpppowfrpAiQqpcaxpPk3mVvfNXdGJtbxvKtSa+98qgoW1s2SNCKlMhxcirar1pJLp4+HiskGrBspehkOJEV5a1ghb+pZyvckFsxBEFfXeW8sg7SKZqvalCd5d0ZCukhifjKnuKZDK03Xt0DCNTNXSV8rh4TXemdZFX5Cs51FST1YZ6zVwZUkEQKIXWxhVuhRRtlN4akZ2DBrL18Mh0YvPa951XrdlVAoFgYWAmNjxOQrna6vOHbYwG0vsC2wHDTBGHmnuIhn83IZWy7Nnb6hZEV1h6OaGQMq8tBGcHFgUhdfXVV6O7uzv18yeeeALveMc7sG7dOnR1dWHbtm148MEH56CHAkESdbYh8TNOvQUCgWC2cWKyir96/E31fbXeTJWzp4245wHnLutQf6cjCAK1mb8wUlINjFeMJDst8Lva8k4rXiVaqJbysQUOMJMGPG/K9z28Z+MyAMD+wXQ2Frfs9ba7M6TqzIbXVcorNauJwEpW2QvJFXuoebwZUJXoMjKk8rns8FkitUqFXKYNj9RmXaU8u266Lb8HutuyM6SGmWUvzpBK9/e1KLfsHWt7UMj5ToVUEARK5dTdlndWJqT+FvM+VkXB+Sbl01S1oV7z85bHGVKme5bsd+dH6r/BiWqqHVWVfOvqLpy3vAPlWhOPv34idS2BQLAwEARBQhXlUj2Fv2/Nsleuta4gol9F24RZs+xxlW6W8jZsP4NQc71ti4SU7UBAcHZgzgmpXbt24UMf+hDWrl0Lz/Nw7733ptr09fVh48aNaGtrw5VXXoknnnhiVh77yJEjWLdunfp+3bp1OHz48KxcWyCwYWC8gif2n3AqntQJOZPLztLBh0AgEKDZDPD5f34J//4vnzJK4f/p2SMo15p4x9oeXLLOnI0zOhVbtZZ1heRNpd5MnBoDoeqJFp3nRwqpaqNpfFxa4LcXYiueyVJVZaqnQs5XQdamYHPeFgA2LAuVMQdOpCsC0mKZW/ZsCqkGI5k8z0NP1F/T8+Lh40S0TdkIqYRCym4/C/ubzpCyhpo3YmIun6GmIsted1teEUemTQY91+6IkCMCzbbJIIXUko6iM6h8MLLLrYyUcq6207WYPMqq3kcKvt72grMaH21+cr6n1HqNZpDaLDabgSK0KPy82mimss+oGtea3nZcGln7Xu4fTz0uEG7CRBEtEMxv6IcEWZXzKgnL3gwUUo62RBJljbszBQ0/Oa+1UPOZWPb05+O6Lh9vXcScYOFjzgmpyclJbN68GX19fcbf33PPPdixYwc+97nP4emnn8bmzZtx7bXX4vjx46rNli1bcMkll6T+HTliDmEVCFrBH3/rFfz+Ay/N6sIwCAL86z9/HL/wp4/hob391nZ8oxPNBaKQEggEs4avP3MYfd9+Df/8Qj/uNuTZPPXmMABg2yVrsLY3JHD0bBwiI5a0F9BZzKmsoROabY82974HLO0ooCMiAkzEDZED7cW8CiA3BUBztQ8QKqpsbblCCgBW94TKmMHxtPKJ1Dp5Fmo+Xq4bF8206CZyZ0lUlc/0vOosfLyjmBFqzgmpjOpyPEOKDi9smxJeZc9lwwOSIeEuGx7ZKOi5U1vT5qzWaCpr3TJu2TMoC1SgeVdJ9RmIlXEcpLoq5nx0FHNOex+/Z+k+1AlUgFUZLOXRUcypeVi32Y1X6mrztqKrpEhUPdyfCLYVXUWVY6YrDgHgmz88ik23PoD/9k97U78TnJ3o6+vDpk2bcPnll891VwQzgE4cuUimeqOZmENc5JVO5rhCzenwISakskmbx18fwu5ofreBVLqeN7NQ81b2K7UmXTv5tyZwBVoW4SdY2JhzQmrbtm347d/+bVx33XXG399+++246aabcOONN2LTpk2488470dHRgbvuuku12bNnD55//vnUv7Vr1zofe+3atQlF1OHDh61/U6lUMDY2lvgnOHvx6vEJfOHBffiT77yGVwyLxlO57kvHwlPRJ9+wy/XV4M4se8JHCQSC2UAQBLhj5z71/RNvpLMTnz88CgB41/olWLskJKQODycJqRGmkPK8ONhbVzTRJr67rRApiahdmpApM4WUKyic5yEBUOqkYUOGVZXZ8IBQRQOY7YVJy15B/dyk0lIHBxEJ0+Pob50RR3GouVkJQ5uBHK+yZ7GDcIUU9cO2GaBrlPJuhVSl3lCvWWcpj4JvP33ngeZA/Bqb2tL94nnhaxVb9gwKqSiHSSmkHHlTKpeqM7y/4twtg2Uv6sOSjgI6CnnVV70Pk4yQ8jzPWhmR7u1S3kdbIYeVEYE2mCKkoufTVVI5aq8cTyuk/nTX62gGwN2PvoHvv5rOOBOcfdi+fTv27t2LJ598cq67Ioiwr38cBw0KWg49xNxFmOjjlkvtk8pjchA29KtCND661EYA8MDzR3H9n/0AP/8nj+IVi0KTXyfne8qy5xIoUXsap13doFDztujgwK2QEkJqsWDOCSkXqtUqdu/eja1bt6qf+b6PrVu34rHHHjvl619xxRV4/vnncfjwYUxMTOCb3/wmrr32WmPb2267Db29verfhg0bTvnxBfMXLxwZVV9TWfPZwPPsurbTcSAZau5JhpRAIJhFPHtoFAdPxOTSy8eSC9NGM8Ch4XAxfsGqLqzqCTfZQxqBM0JkRKSOsREyY6oCWj5qZ1czkVqlo5hDr6PKnSJXIvLholWh6mTvkfRhUY0pg4CYkBqaTIdP0wlzIechn4vJo5EMkgmISRlTsDtXvVKGVKMZGE/Veah50UHaAECjEbfNqoZUSSik7KonbnvMUkiNMIIHgFLJmdoOM7tczvdU1pNJpRUrpML3ylWR75mDIwCgiFOXqmyEEWhk2QPSKqkJFeoeKfCIRNSC6IlUpXt/RQYhtaKrpCpNvjmY3PAGQYDX2AHYf7n3eWfgr0AgmH30j5XxoS8+gg/98SPGAhWEVNaTgzDRi1K48qZ0+5vLskeHF3mlYrI2BQD88HC8B9kTjZsmJAsrZVv2asrq7ibGGs1A9ZHGX9d1+Wsqlr2zG/OakBocHESj0cDq1asTP1+9ejWOHTvW8nW2bt2Kj3/847j//vuxfv16RWbl83n8wR/8Aa655hps2bIFv/Ebv4Hly5cbr3HLLbdgdHRU/Tt48ODJPzHBvMeRkZiEslWNOhkMsOo7rhKmyZKr4c8aQkgJBIJZwM4XQ7vwj164AkBoJ+IL7+PjZdQaAfK+hzU9bYxoSY5Z3P4EgCmfNEJqOlZI8XZmy164wW8r5NR1TRlOug3vyvPDoHKTFTpWSIWD6fLOkDQwKqQiyx6pd1wkE7fhAfHrYFZIRRlSvofOYhzCbgo2p3W3z6vszSBDylplz2DZM7Ul0qWjmEPO91RbV4ZUj6aQMm2i+qMcJSIEXVlPZHGj98pFSD0cvedb3x6uFV2VCYkUWxJZBum9m6ol3wdu2QNgVUgRqUoKPVJ0DWiV9k4oFVdREWfjlXrCAnh0tKwsjaW8j/2Dk3j20EjqOQgEgtOHR18bRKXexMhUDW8O2VVSpqqzNswkb0ofk1ux7NG4y39mAt/b6AdMpuv6XnaoebMZKAdHMVI92dry59KWz7YZcrWYKKTObuSzmyx8PPzww9bfffjDH8aHP/zhzGuUSiWUSqXMdoKzA7RwBtzE0UzBLSr66QoHjc+eB1Zlb9a6IRAIFjHICvThzWux+81hTNcaODpaVqHMhyJr3tol7cj5Hpa0UzZScgE7yhQv/H99zKQMKdq026x9QDwudhRzSnVjVkhRhlS4qP3gW1cCCFWojWagyBkgXgSXNIXUyHQN9UZTES5A2t63pKOAwyPTFoVUTDJlPa9ELqDvoaOYw1S1gclKA8u7km2bzLJXzLlDzSks3WfPN1MhxULNTeqkcVZhDwAKjip7SiGlE1KGPjwbnchvOicMyXfZ8JSiqAXL3guRKu6qC8IDRVeG1JAiusJ7oL2Yw3i5ngo2J5UYEVGdRXNlxDGNkCNFl66QIiKruy2PzlIeve0FjE7XcHS0rIhaUmNvWNaOLRuW4p+ePYIHnj+GS89dmnoeAoHg9KB/LP7sHhqewsVr0lXagTRR5FRI1Vu396Use46KdTRX0GELEB5e+/CM7fm4ZCuqQdcAwv1HTo3/5n7wn9Mca+OYEoRUIVshxdsLIXV2Y14rpFasWIFcLof+/uSJZ39/P9asWTNHvRIsBvDyorYKSycDblFxnaYEiE8nIjeIVN0RCASnjPFyDc8eCmX7P3LhcpyzJAz4Psoq6FF2xvqloZLDRgwRSUO/zyKklEKKiBvNsldvNBXh0F7IqaDsL3/vdfzRzlcSJ78q1DwiHzYu70R7IYdyrYk3hyYT16WFLJElSzsK8Lwwl29YG9+5ZS/x3A3zACeZXM8/vG5sgQDsiht+3VYUUrRXyfOsD8tUQa9DWyHHMqTslj0ipFwB6KPaPeCy7D19YAQA8O6IYLFlSAVBoIgjIniImNNVT8fHyhicqMD3gLevCYmukoO8IqUSkZKkVpvSrHiT1aTNtFPlfukKqeS9rSx7WmA+vabd0XXO6Q0/d4fZ524o2iwu7yxh2yXhGve+Hx5Nzf1PHxjGH3/rFUxV65iq1jPLzQsEgtbBx29OTunQiRRXqHlaTdW6QsplVYtzDJlCyrFXaLXSH00LYWxI+LVtD8IPKujgwObo4CpbKkjiCjXn7evNQCzMZzHmNSFVLBZx2WWXYefOnepnzWYTO3fuxFVXXTUnfZJqGIsDE5V4QtKDC00YK9dUWWdnOzbRmewEBBrLPbAMKRmIBQJBBj77f5/D+bfch3/cc9j4+6cPjKDRDHDusg6sX9qBdRRYzjbGZDeianQ2yx4PNQd4NpQ5+JkUUrTJ10PN+VjbzhRSzQC4/aF9+NZLcXVdWqSTZc/3PWyMFF5v6IRUIxm4yivo6bY93bK3ujt8DfYZAmB1kmlpJ6ljHBlSEWGjFDdVAyHFQ80dVjWAWyu4Zc/clogLniFl2gxQn6hyYdw2fd3j4+G8R9a6gsPeRwqpd58XElJFS9bTWLmufqZX2dPbUi7jBSu7VCaJqSLf0EQFP/fHj+Drz4SfCyKkqNLeVFW/ZyOFVFEjpCq6korsqOHvSdFlV0iF9x197o6wzx2vxHf1xSvRUczh0PB0oiJWEATY/tdP4wsP7sMn734SV932LfzYF75rzGMTCAQzB5/n9KqaHGklk0shFf6OyB1X2xlV2WMHEupnDiFRq4RUIxEb4i6sxF8HGtOtlr1m/DqoAHQXIaU9mTOdI1WuNfDtl48brfWC2cWcE1ITExPYs2cP9uzZAwDYv38/9uzZgwMHDgAAduzYgS996Uv4yle+ghdffBGf+tSnMDk5iRtvvHFO+ivVMBYH+Km1izgCwsniur7v4wOf/zbeGJx0tp1gi9mySyEVjc/+abLs/d43X8J/ufeHQnIJBGcRXj42jr998iCaAfA/H3jZeKK5Lwowf+e6XgDAmoh0OsaKN9BmXLfi6bY1vcKazbI2pm3auyzqIAqW9rxQ5UJkBIFXJiWygRREAHB+REi9PqArpMK2PGfDFmxe0yx7739rmLP1D08fTr2eRDJR23WR2uzQSLIaIRATNBSATmTPRDm90I1DzRm5YpkvaOHvecjMkFI2x7yPvG8njsY1hVTB0fZwlEmyLlLT5S0k03i5pjJLLlwVehSLebOaig53ukt5ZeuwEXMvHA7teu9Y26N+VsqnVWXffP6YUgYCwPKu2LIHAFPawZOqsqfds/rGZDK6Z7si4oru2QGdkConr7cq+tzxrKkhFnzeUczjJzeFmVjfeXlAtdnXP6GsfT94/QRGp2s4PDKN+587CoFgMeJ/f+dVvO/3voVXDVUrOYYmKvja7kNOggdIWtNdxYfqumXPYa2j8ZvGiVojsCqO9PHbNO4SaPyneQJw581WE4SUfQ+icmx9qBxbcm6k+sv6l0Uykcq2wGzjToWUrkLL2I+1iiAIWiKZ/vS7r+PGv3gSv3Xv87PyuAI75pyQeuqpp3DppZfi0ksvBRASUJdeeiluvfVWAMD111+PL3zhC7j11luxZcsW7NmzBw888EAq6FwgmE3wTUKWHH73m8N4bWAS5VoTT+w/4WzLJ0LXwBpvMuJQ89mqsjc6VcOd330Nf/WDA3j6wHD2HwgEggUBriA6PDKNP/nua6nS1S9HSp+3rg5zMVYaFB16UDNZ7Kr1ZiL8PLbsRVX2LKHmKkMqug6pTfYcHMG//vPHcV+0mSaFVEchB8/zFMFEOMCeS0VTSAFQGVi6QqrWSC/abcHmNc2y91PvOAeeBxwbK6dCYGuswh0ArFvSAQA4PJwmpHR7n3qtDCfwCcte3mxVI/BqSNQP2wl5TEjl2GbAYNlTFeaSCinTRo6eKyl+VN6U1pYUeEs6CjHRZQlAfy0iFDey979oIJmAWCH1jrW96mf0mvHN16useh0ArOkJ+0sKKSJDX+kfxx/tfAUHo+cVh5qH7fQN6rhGNJHFcIip5JrNABPVJMlnakf3F5FlV54fZmJxhdQzljlbr5g1XW3gn549okguwfyFOC9OHs1mgP/5wMs4PDKNP/3u6862//nrz+M//v2z+L1vvuRsxytujhsODAip8HFXLlQ0V7Sxyp42tc9MlFc0/udbyBAEkvsZ5x6EDkU87tIwt+WqJ5orbF2geaHQQhGOsH3r9sWZ4I+/9Sre9d8exHf3DTjb/fkj4T31D8+YFeeC2cOcE1JXX301giBI/bv77rtVm5tvvhlvvvkmKpUKHn/8cVx55ZVz12HBokBCIZURpPcCKzM+aCgjzsEX/06FVPQ/DzWfrQgpbs15bWDC0VIgEMxH7Osfx53ffQ1HR5PEB9+4AqFK6sN//EiiQtwripAKVSpxmfq4jR7UTJtoIDk2Uqj50pYzpJJqkz0HR/C9VwbxW/8Ynj5SsDSpVjau6FQ5VgBwcJgRUpQhxRRSRGC8dtycIVU0KaQm3Ja99mIOG5aGRJNOapA1jjYDpBIanKikyoXrAeg28g5IWvYUEWNZiNOUwq0VtqpF9DqUCr4zF0rPOypY7H3VelMRmZSJlFeWjeQp+aETSeIqvK45AP31wfB1vmBlmpCqavPm85FC6p3re1NtKw5CilRa7ZQhFd17v/53e3D7Q/vwT88eAcBDzc0KqQktAD7+PFWUAmKyWlfzN30G6P7jhOgAy5ACYhXjy8wu+kr0PHhoP5C2lP6nr/8Qv/p/nsG/+LMfpMhBwfyCOC9OHnzNnSX4f+CFsDr7Pzx9yNmOkx4uK+xMiCMiXdoLMSFlCytvzICEMWVIufJmOQnVSo6V72cfiicKdnhukkkpkPO+yjx0KaT013S2Dub/4KF9aDQD3PJ/n3O20+MHBKcPc05ILTTIScbiAJ8AsggpytAAzCW8OfgE1IpCyvfiQMHZGoh5BcGDJ9In+QKBYP7i1eMT+Pn//Sh+75sv4RNfejyx2STLwq0/u0mpm4ananhob1wYhFRGb4k2+5R5M5BQSFFVvJA0yfmeyjzi6lEKBNdDzfVF/Liy7KUJLiDclB8fLyuFFBFShZyP+371/fizf30ZgGRQdJwhFS/w335OqPp67tBI4nWhRS1XSJ27PCSZdFJet+wBwHlR2wOa2iyVIdVRUBuOI5ptzxaAblrwNtl1uVXNtNGI54r42jaHh8qQYnYJ08ZBt6vZ7H3DESGZ8z0sjVRynCjhGw06CDESUo3kcyNC8YKVcflBIhP5fDw4UcHhkWl4ns2yF5NXRyLytruUx3/90CZ1L3QUSCEVBoQTwUWIFVLmUPMJjWwldVOl3lR2PiJx8+z9NFlGVah5dA0iWE9MVhXJS8TT73zkEvyfm96Lv7kpPKB9bWAy8RrSyf8rxycyldsCwUIFt5oPT6Wz+0zgpJAJfG2uFzvgSCmkXMRRYCCkLHsLfV5xXZc+8okqe06F1MwsewmFlFX1RHNbTDJZM6RYW1JT2TIPgTRZ5SKvTgZ8TWAC5/2zrJ6CU4MQUjOEnGQsDtApOZAMRjWBn3Drgac6+CZJP0HnCFguyGxnSI0z0oyTaQKBYP7j9775kvoM7x+cxLejfJlyraEIkw9tXotnbv1J/IcPXgAAeOqNUDk1UakrEomIgZVdBsvedDLzCWCZR9FjN5qBIp562yPLnkUhNaZt2js1QgoADgxNKasEX7T3dhSwKSIbTkxW1dhoUki9fU0PetsLmKw28MPDcV6QXmUPiAkMrnAFOCEVr0Q3LAsJqUMaIRWTTOF1Pc9Tiq7DGiFV106yKQDeVZHPZwopwHxSzg8vYsteerIIgiC27BV8pw2P7q+uDMseqXuWdhTgR4/NXzeu1KLXY32kNgNikikIkpsoIgnPZ4QUr5xH9wC9x+ev6FRkJz0/ILn5oqDir33qR/BL73uL+nkcat4wHtCkCCk91Dz6nn7fUcyraw5G+VCctKLNHSmpEpa96Gv6THaV8qodVY58pT98bS5a3Y2rLliOSzeEAfGj0zX1fgyMVxLKq3+OlCECwdmGo4yQ0i3VHHztnVWoiI+zLnUSjYd5RRxlZyEV8vE4bbs2jYVtebI026/bUOSVrw6vXRlSCcueq8qeyrH1GCljvm6dHbZkHaDXVYYUt+yZ+xAEQYpc09VjJwNO3LveMyC2fwOtE56Ck4MQUgKBAbUZKKR4RQ5XAGJ43XjwczH9gWEyyFJIfful4/ibxw9kBpWXmT/++LjkSwgECwVj5Rp2RcqH910Y5ss8HKmfXh+YRDMIlTcruorI+R62bAgtP7Rxp7yfJR0FtYFf2R2SSTxcWWVItceb/G4t82i8XFPjlB5qniKkyAIYXYMTXYRjY+WYkComf08WpmqjqcZYWliXGGHj+x6ufMsyAGHgM4HGcE7uECH14tGxxKKXh64SyLJnVUgxEoYqE+pV1qwZUgZCSuWC5LzE8zPNRQ0+VzhCYsMQ3fDrUj7nPMkmAkVlSPnmyknDipAqqp9ZFVKUNcUsmHn2utHrHgQBXo8IqQtWpS17QRBf9/kopPxd65ck+kWqOXq9ms1A2VZJzUdoZ4SU/v4CMSHVFWVIZVn2AEY2ReqnMS1nCjBb9gaVQioO8yeC88hIGaPTNRyLFM6x5TCnyOXXo6Iqun3v4RePO208AsFCBVf8TxsqlhI4kZz1SUja2rIVUnSA4rTWsaIWRNrbKqcSkU8FHWwWbCCpkM1lZD3pj+k6FI8te8hUSJHCKZfLzoWqMgVyrNI1d9hEFrlei1bBCUknKdcMEtEqWYIDwalBCCmBwICkZc89CI0mFFJZhFR8XRchRb/ywDOk7O2nqw38h7/ajf/09R/i73cfdPaBD7DDU3Z/vEAgmF/Y+WI/qo0mLlzVhX//gVD9RNYcUpVcuKpLLSAviTJo9vWPo1Jv4FCUwcRzmWjzPF6uqwXquGbZA1hlvOh3RMR3FnOKLIhJljoefW0Q/+2fXsCJyWoqQ8qkkDo2WlaVztoLyaVJezGHtuhnw5Ph41YNJBMAvDcKgt7FwkpNqqe3rOhCW8FPEREmy96GZeHrtX/IppCKr0uEB/WToNswejtaCDX3vETulWkDQ/NCzvdUP0yHEnxOK+V95yaDbGn0fuUsRNcJyhDrjAkpqsgHJC1+dH/ye4+/xtS/wYkqxsp1eB6wcXlMSPGT6mq9iROTVXzlsTcBAO8+d0miX3qVvfFKXT1PnZBSoea1RspmCbAMKVYZ8tHXBnHl7z6M373/RUWQcrKJLHcDkcVUtSnFj708es2Gp6poNAPUG001H9PfA8AqZqmlz++KrpIifwHg/JWUnRa+xi9FlTQ/8NaVaCv4ODwyjRePuiuQCQQLEZzQn6ra1+rjlbhdVqW2xPrf0ZbGQwoqb8Wyl/e9hFXZ2JauW6DruvYKsbXOz7DLAcnn1tJ1W8iQihVSfmbmLSnV8oy8su2FOPlEY7rLjtgquHDA9VqV643E82ilKp/g5CGE1AwhGVKLA7WEtc49efFJMEshxQdeV9Aot+xlnU4AYaUhWnxzZYAJvILIhCOw8WTww0OjuP2hfZkknkAgaB1BEODX79mDX7/nWQDAT1+yBu/ZuFRVfxsYryhShW/i1y1pR2cxh3ozwMET06ri3volsW2qt72giBqyPMSh5vEmu1uz7JFVgqr00bWAcHP/S3/xJP7i+2/gt+/ba8iQSmd4HBstK/VmRzFNWJFKilQnvGIcx/svWgEAeOz1ITz22hCAeBHO1UY538O5kRWPXpcgCGJrBSOvNkcKnB8eGkm0dRFSI5ryyaaQMln2aGrI+WF+h63CHL8ut3ebTpG59byY8532PlU5rpQkpHS7BCmkljGFFA/BpTmuf6ysSJJ3n7tUtU3Y+6K2rzPiqo1ZNxPWxXoTf/fUQQxOVLC2tw0f3rIu0S+y7BGBR+qojmIudb90qFDzeqriIpAmUSerdfzeN19C/1gFf7brdWXz62Ykq36v6iHxQEziNYOwf/TYvpdUnK3qiQipsbIiOVcwwgqIs7aUQip6rbes78WPXrgSAPB/njggKinBWYcJplpxElIsq2+61nDnLLWooNEVUq4qe8pa58WqVxshRHMQjWOuvYI6vPY80FmA7bk1m0GCYHG9BvxQxEOrGVKxStceah7+nM9BtrZ8vxSrxU59DJtK3DP2PZutoqrg9EAIqRlCMqQWB5LWOjchxSesrNA7/nu9ChFHYpJpwbLHbYM85NEELlfNItBmio//6aP4o52v4J4n3SotgUCQjReOjOKj//v7+M/3Po+vR2WHc76Hn7t0HTqKebwlIp9ePDqGA5F6h0gWIBw/zovavDk0qXJ81rJgac/z1AZ6cLyCeiMOYzYqpKIxg9QaG9jjcZUIkQEP7+1nIelkf0qqVIDQukSLQ1Po7NLOSHkUkQs2hdRFq7vxc1vWAgDu+2FYKa1myJACYiseVe/j434+oZDqwFXnL0czAL75/FEAyYVxnqmCiEwY0fIm9Cp7KtR82hBqzk69AaCUSxIsybbh/4kMKcNUoWyLOR++74GenilvZELPkFJh6cm2RGByhVTYPtpIRR15MLKVvvvcJQkC0/M8RUrRa//aQDrQHAhfN3p+lXoTew6MAAB+6X0bE2oheo5hu/A+pvlxSXv6vuMZUvp7BsTvE1XZGy/XFbkGxIQiV/2RDZYyoZStj30+CjlfXfvEZFVVuVzWWUzYHld2hRbQgYmKUqTpKi+qRkhk3kuRZe/iNT34qUvWAAD+8gdv4r9/Y2/q+QkECxlctTITckEvTsDRqkOC1vMdxWwlE1fIFhzjOcAzpKLrtkAc5XxkBorr47eLkEpkSEVzhY3Q5s+NzhhsOVa1JldImYtlqOuyn58uhVS51rQSfnqgvSikTi+EkBIINDSaySA922BJ4GWoswLy9GvZ2P4AsS+8lVDzCSZHzgre44qv2WT8G81AXZvbZQQCwcnhf3xjL54+MIK/efwAgFBR8uc3vEdt1t8e5SDtPTqmFFLnLm9PXGPjipB0eWNoCv1joWLjnN62RBsiCQYnKokxgWc90df0++ejXKq3rIgVWTnfS+VD8SpylEnVyRRSpBoZma5hOho/KNeHg4geUomYMqQI11y8CgCwLwqAVhX5tLZkHzsU5RvxA4OiRl69/62h8uqHURU2PkfwDCkiGUY0O3SDVRcC3KHmvOQ2wEO605sjbtlznTjHirLwWq7y3BMWhZQ+X5FCarlOSEWvB813B6JAbq6OUm39pH2FrH06IQXE70m13sSLx8L3gWypHKWI0CS7zbAicoqptoqQqjSMFnYi2+iefXNoyriR7DIopCiXTbesxu2o0l5Vqanobwn02Tw+VokVadrrTeHvrw1MotkM8IoipLrxkS1r8dFLQwXZ3zx+wLlpFwgWGiY1csFGWExoa10XuZCsRJetempjGVI20qZpIqQsRIiyAragkApUhpTnHNNNP3cSUqy/WTY8yoAq5LzMiBFekY94d1sv6Hn7XnyY5OpzudbAp/5qN/7woX3WNkBaSTdpUdalKqoKIXVaIYSUYFHhj3a+gh337HEqmfTfZUlEExU5MgLQ9WvbBldTqLlLbs9ly1kVRHiQ4VS14ZzsZgI+WIu0VSA4NRwankrZb//+P/wIro7IFiBZKY5UPlwhBcTV9I6OTKtA5NUaIUUWoMGJiso06ijmEiohUjXRZ/t7rwwCAN534YrEtXS1CqHAArr55p1CrkemqiqU1qiQ6ogzd4A0wcJBJNn+wUkEQWAMKgdY9byIkOIHBtxOBsSv69FIZZZUSMVt9X4SUhlS7fYMqTi/I/y+6DhR55Y9FyFFf0vklmuTManlIuUt1z0REThphVTSOkhKoRXdSbIFiF/nqmbZo1wkjqKqtNdQZM/a3vZUO16RD2AKqY70vUkB+lO1hnrPVrF+dkaEVZch94yDk02UOfb6YPhcdAskgV634cmqIsP0PvIMKerf0g6zZe/AiSm8PjiJqWoDxbyPjcs7kM/5+INf2IzVPSVU6k1VVfK//r8X8Lv3v6iUjgLBQsS4RhLY1r8phZQjoDpBSLWQIcXnK3seUjz+F/NJEl5Ho5EMNXe5Kfjhhe9QyPK26nvHnqLBiC4vQ3lVazDyKqNyHj3nYi7Om7I9N1KG5XNxVVjXfux7rwzim88fw//a+YqTPNKJJhs5qd8jEkVyeiGElGDRYLxcw+0P7cM/PHMY33910NouRUhlEDbVGVj29MHUZgfkA3/WZAAkT39clTOA9KBaziDRWgWfAEyn/gKBoDU0mgG2//XTAMLN/bol7bjhqvOwZcOSRLtL1obqkGcODKtAZrKhEdZEG/ajY2UcJ0JKIwYo2HxwomoMNAdicmKiEpaXp7waChEn6H9H6G4rqLHM8zx8aPNaLO8s4lNXh+HsoUKKquylCSlShTyx/wS+tOt1RTLoqqfwOYeE29BEJbG5sCmkKBeKHy5w2xQQq8qI1ON5SrwtEQr6GKiCX3PpKnv6gpzndwBM8WO07PET8vBnpsMLGveJ3HKRV+MVs0Kq0QwS144VO8n3nIhMes6DFiUVgNTmzGbZA2KiaaxcV6fcOhnGr1mpNXB8vBxbCx0KqelqXd1TP/uu0PJ53vIOdc+agvg5+O9JtbXnwAjKtYYx+BxIkpJ0v+iELimkBsYrxqqGALC6p4TOYg6NZoAH9x4DAFy4sku9D57nqUqEzx0aRaMZ4G+fPIA/2/V65iGa4PRDsmlPHjqZYLuf9bHT1i4IgsTvWqqyx+Yr2x6AxvhWQs1jhRS7rmWvwKusxpbtU7fscSsgzW5ZRBdXPVkteyzUPCuEnfZehQz1L+EwI9ePjaYLVBD0e8amgtPJzaw8YcGpwT3DClLo6+tDX18fGg1hShcaXjbkPpig2+6ybHh88nKVfQXSoYc2O2BSITUzy960I9gRSD+far0JpA+uZwxOipnCYQWChYiRkRFs3boV9Xod9Xodn/70p3HTTTed1sd84cgono1K2n/+4+/CdZeuN7ajjS8pfEp5P5HRAzAiZbSsyJQ1ukKKbXpNgeZAnP80Ua7jhSOxXU/fQPPvLz13CZ6Jsn56tM34H/2LLWgGwKtRZbCRqZpSeprUKET0PLi3X2UShc/ZTF55Xjhm8rLgug1v/dKkQoqf3hIRQSBir3+sjGYzSBwmJEPNLQqpRjJDiuyLzSA8se1mRF6Dnabzfpur7EG1dc0VSlEWbXKUvUPbDARBkFJIccKt0QwUqXbCQpDQ60Gv54nIjkbEJwdtzuqNAOVaQyn9jJa9iGjqj3IS876Xuq+AJHF1xe/sVD/vNSqk4gwpWhf8zLvW4H0XLsfbzulR7fR7ctM5Pdh7NFQb9bTlE+q7t6/pwbol7Tg8Mo1vv3RczY06WUufldHpmpqXdYUUt9PaFGme5+HCVV149tAo/unZMOPsbWu6U/19aG8/Xj42hjeHJlGuNdFW8FXGnGDusH37dmzfvh1jY2Po7U1bUBcrgiAM4fa1wwGOVgkp/ee2tbr+c5dlj8Y3TkhV600YeG9FMvm+hyKpQrMypFi12XojgIkTV5Ztz23DBtJKJFc+bmA46Missscq59kcHVytHF/X3Adqm8/5KdWtCceiSAIA6B+r4MJV3cZ2+h7J9j7oYgRRSJ1eiEJqhpBQ84WLwYl4sBp2ECat2uoIM1FI6accNvkpDfxh5aTkz4zXZSRTluJJH2Rn64RUz7GSij6CswHd3d3YtWsX9uzZg8cffxy/+7u/i6GhodP6mCNTNbx1dRe2XbJGqTVMWNZZxEWr4o37W1Z0poiU1T0h+bSvf1yd8NHPCEQUDDDLXkohVYozpMj2s4lt2AmckPrJTWsSfeXwohNdVZVuqqoe26RG0f+eYLLsFXK+qvx2eDg+KdUJKVKTDU5UMF1tqAMC3a4HhNYpzwvH2hNT1YQFg7/myv44nhwD9Sp7bYWcIlj0A5JUqLkjQyq2VoTzBf97DrKeqAyp6KXQNynTtYbaIOgKKSA5Z52wZBrpFr+hCXM7AIk8ldcHJhEEIcGjV5IDYkKKKjwu7Sym7vfwOaZJSgBYaiCkOgqkkGoohdTSjiJ+/O2rld01vKafeB0oU4z6weH7Hn72XecAAP7fs0dUyXmd1CIybWy6blVI0WtWawRKyWd6Hm+PPosvRiTZxRoh9dbV4ff7+iewP1I3nr+iK6UEFAjmA6aqdfzYH3wXv/Cnj1ktXUDaimdXSGn2K4uTQP/7VjKkSjlfjb02ootylmakkGLjmO3wOmHZy9gr6HsZV72m5HXdJBN/blmkmFI9taKQYtelAHTXfozv8YacezzDobyxnXYviELqtEIIKcGiAVWxAeLsCxP0wWkmVfayyJ10qLlFNhz9H1a4cAcKAslBulq3BzuGj9naYDxT8ByrWiOQAEDBWYFcLoeOjpC4qFQq0ant6SVbP/DWlXjw1z+IP/lXl6Vyj3RcffFK9fXbDQQRKaTIitfbXkhYAYCYRDkxUVVV33razZa98UpdqZr0TS8AbIpyrTqLOVzxlmXq58s6zTLMXqYUIuVLt1EhZSak9OdCIGXJocjKyPMt1GN3FFT2z+GRKbWZyBtec05yDYxXUplQhFXd4es9XWsk8k1M7WPbXnKsTIWaKwua3bLnZahpq41kCLytIhOpeXwvzkbhVQSpfRAEqupbipBSG67ws0KE1HIDyURqq1q9iZeioPK3ndNjJJqIUCSln8kCCJhtnIDNsheRQuW6mrNM95rnecreBwBXbIzvbT0wGQC2vTMkpL7/6qA1Q4orpKjCn05ItRVySilB+Vomm6L+2X+b9v1bV4fE9avHJ+ICCFrenEAwX/DE/hPYPziJp94cxv6oKIIJuo2qanGvtEo06T9vNANrbAdXBhXYmGcCH9PjLDx32xJTSNkse8Yqq5Ylva6Gde1tqGs5liFlW/YkMqQyHB0qF8r3rYciqn+N+PWNFVL2tRc/2Jly7D/05229Z7T3pywKqdMKIaQEiwacPR9zWvaa2vf2ATC0bgQttQ2CIJ0hZbXsxQopderdgt+b4JKW6o9pG4xnCl0Gm2UdFAhmA7t27cKHPvQhrF27Fp7n4d5770216evrw8aNG9HW1oYrr7wSTzzxxIweY2RkBJs3b8b69evxm7/5m1ixYkX2H50hmELOOVZ2l8A5kzWaOgqIiZHxSk2plPSKYLSZnijXVRCyaUP7r957Hv7Ve8/FH3/i3biQqbdMSiYgueEm65yetQNAkUE6THlTQEx+kELKFJQOxLa9g8PTauy3kYA8zyeumpckTtqLOfXaHWcWAp6zQei1VNrjmwGAh3kbCKlm3NZ1kk1kVlEppMwn2Tw/ijYiJoXU6HRNbfJ0K15cZa+J8Upd9VuvIAfEJFOtEeDpA8MAzMo7IL6HSCE1E9UcYA7c74iq5/H1gckGCACdxfjnb1nRiR+NAv0/+NaVqbZvP6cbed/DWLmu4gL0z1RPCxlSQHzvU8VK02dBJ6S2RJlRhI0rOlHIeZio1PF4VCzh3OVCSAnmJ94YjEmoA0P24P2UiqVFy56tnUm1ZGtbV0SMH49jtraGDCmrVYzNFYqIsewVuJrWZsNWbbWHa73KHj2Wua2a23I+I8Uslr3oORfyPsvHNV+3niCvoufm2GPxfZ2tch4wg3tBbycKqdMKIaQEiwZDTCHlCv7WSSVXqLm+QbBNRqbrAtlV9jzPYyfZ1kunGH8XGaS3dUmSZwL9tciq9rfn4IjKohEIThaTk5PYvHkz+vr6jL+/5557sGPHDnzuc5/D008/jc2bN+Paa6/F8ePHVZstW7bgkksuSf07cuQIAGDJkiV49tlnsX//fvzN3/wN+vv7jY81F3jPxqVYv7QdXaW80d5XyPkJwkCvsAfEeVFj0/U4Q0qz7FHG0USlrogjCgXnWNZZxG9/5J245m2r0NteUCTOBavSmUAE2oST8sWVIaWjw0I0kSLrcKSQshFX50YV0V44PKoW/UWDZQ+ICanj4xU1jposT1QZjULk+WFEQiFlqbRHFohcjhRSUai5QyGVlfURVyUMr2WbVyYMah5OutGG4MhIrFLSVWrcsncimnc7iznje0Cbs3KtgQeeDwO5P3hxmuDhfafAWpNSKGxnXtqalE8dWp86teqSHHxOW7+0A//t596B7ddcgP/0M2839pUI2eNRRUCdaO1hCilFSBn6qPfbpPR62zmxWnHTOT2pvKxCzlfVJ3e+FI5fGwyfX4FgPmCUqUZJ5WqCvu60Zki12I7W5Ny2bVsj0zhdyHmqvbVyHhv/syx7DTa30HyRFZbu+7EN27avmEmoedN0KJ6VIeV7qq2NFKN5s+B7VpWuasvsfTNVSNkq5wHpvVir5KQopE4vJNRcsGgwwgYrNyHVWs6Tqa0r1JwTQcW8j2q96aiyF/7vs6BCV4aU/rAupVargzHh1+/ZgzeGJvGX//ZKZ+lrnYybcpBi4+Ua/sWfPYZyrYnd/2UrlhvCbgWCVrBt2zZs27bN+vvbb78dN910E2688UYAwJ133on77rsPd911Fz772c8CAPbs2dPSY61evRqbN2/G9773PXzsYx8ztqlUKqhUmBpzbKzFZ3JyKOVzeHjHB1FtNK0V7s7pbVOb4vMMqiYim8bLNaXC0EPNSd0xPFVVn+31S7MVFr//8+/EQ3uP45Pv22ht09NWQD9TExkVUhbywaqQitpT9UGbQurqi1fhn1/ox53ffR3viELibYREQiGlZUJxrF3SjtcGJhUZxqcQ3p5btjhoPFcKqag/FZNCKrFxcIWaJy17tqwPspfxkHXfoJCi1/WcJWmCk1RgtWaAoSjQ3DbG00bumYPDGJyoYklHQSmPdJC6K8uyZ7L7AbYMKbONzgT+PhXzPi5Y2YXfvPZt1vbrl3bgJVZMpbuUvDavtEifKdPjL9WqGOrf07U+81MX4x+fOYL/9nPvMPbnrau7sa9/Qq0BNohlTzBPwT9rrsxXIpbyvod6M2g51NzmIqAleSHnoxmE8RdZSiZOMlkzpJiSqZh3k0y6mqpSb1r3IQ12IJFzKGTD56Zb9hx7CoPyynZdXrAji2QyhZpnBaAnlFeOfdA4s05PVl2EVGvkpGRInVmIQkqwaMA9xa7ynTSh0OLXNWjrfFK10cwcXAGgLePaapMBZA7aQHyiQnB5w1P+aQchNTxZxdefOYxnDozge/sGrO2AmSmkDpyYUu/Bi0fHre0EglNBtVrF7t27sXXrVvUz3/exdetWPPbYYy1do7+/H+Pj4T06OjqKXbt24eKLL7a2v+2229Db26v+bdiw4dSeRAtoK+SsZBSQrKp3nsGmQ2TTeNmukOKh5o1mgELOU0ogF37sbatx20ffac2AAtJ5VaYMKZMqBLCrYaj94QxC6mOXrcf6pe2YqNTxyCuDAMyh5kCSkIo3I+nHp40+hVDzMTfHrs0JCY6mpqZSoeaGMVWRVxmhtjTOF/VQc61trNRJvid6UPnRiBQ6pzetsqHXr9FsquxGG6FI5N+BE+H7dMHKLqtlUhFSFGruuKdMMN2DOqGp34ungjW9yc+HTrRyQnLMYdnjzzPve9aDoV+5+kL8869/AJezfCsOCjYnCCElmK/gqlG9YikHkQb02bIRQvrBq+0glitOXdVNgWShiswMKZaHlHldsgLmvIT92dxfqP7abNh6f23fJ66bsOxFhJSlLc2FIcmUYdlTOY1xNlWWmirvz65CqtXCTnqG1Gy5SQRmCCE1Q/T19WHTpk24/PLL57orghmCK3Zc0ktS+pCUv9G0hxinS2a7SpjGgxlZHOwZUuH/PgsUdFv2WsumMv3ORUjR6TYQb+xs0K/jsg0eHYlLsb8+OOG8rkBwshgcHESj0cDq1asTP1+9ejWOHTvW0jXefPNNvP/978fmzZvx/ve/H7/6q7+Kd77zndb2t9xyC0ZHR9W/gwcPntJzmA1w0uD8leky70SM1JuBUlKlSCJtM72iq+Qsxz0T6Jk9pip77cUc3ramG56XtJPZ1DDLtAypNouSqpDzVUA1hWrbCBEKLD8+Xo4DVw2vAWVrUXg0X/ibFFI6IcVPvYFYIWXabCXLc9vDZ2PLXhRqbjlxHpk2h2tTe+rbYHSfrDSQkrHNJA40N1XN48+NFFcrHWpZmpNp02cKSdfBSdMNy9LkWTHvJ94TFyF17TvCceRGh9qPQyfr9OynmJCKq+wtySCkbJUFWwEFmwOhoo5XERQI5hNaUUg1m4EaC2hOsFfZa9Gyx6qWErFuy1mtsQwpGlezVE++l62mUocdnherTW0ZUow4ymUSPK0TUtQ1n9nwbCQTtyP6vnu/Uk8opFpvS3OKNWC+0UwUUnKLDlrbA6UsexkxJIJTg1j2Zojt27dj+/btGBsbQ29v71x3RzADTDEJp0t6SYN2eyGHEdTUz0yn5iYlUq3RRM5Pb374BoYmJBvbz0PNW7PstS7FnUmVvRFWjfDQ8OwRUvzE6/UBewUVwrMHR/D0gWH84pXnWSsoCQSnA1dccUXLlj4AKJVKKJXmlwWVh4tfdm5aPdFRzCHne2g0AxVYriukeKAzYFe8nAxsFf103PPLV2Fgooz/+v/24pFXB53XJDtXPJ7bx411UZbO/mgsygo17x8rx6e3hnmBNvoUvs3H3GSGVFzhjcOmkDItsptsA+WaK2wZUvrcYQvXzvseKohP709Em0STbY5UT/VGgBNk2bNUWaR5VRFSDtWdTqC0opD6xJXn4q2ru7Gko6Ceu46utrya61xKwy98fDM+8NYjuO7SdZmPCwCrWQGBQs5L2WDp+xOTFbUpM1v24udpC/dvBRcxhdSq7pK1QqVAMNfghJStKjYndLIIqdYte4zg8X0AdVTrNiKGZ0i5Q81pTM77HgIiryzXVUHlvsfUphluCj7+W5b0+rzQSoaUn2EFB2KSKO97oKnTdu24cIinDk7s9r54js1lEF3j2hzq2te0GrVSY6riar0pCqnTDCGkBIsGrSqkaPPAF2v1RgDT2s008Gd6vVlQoW61I9AVPC+7wkV4HZ2QchBuqSqCrRFSIw7ZNDAzyx4f2I9kKK+CIMC//cpTGJyooJj38YtXnuds+9hrQ7hodbdzYyNYHFixYgVyuVwqhLy/vx9r1qyZo16deXzssvXYe3QMbzeEHQPhONNVymN0uqaUkLoiyo+sQnQKOauEVAb5RejtKKC3o4B3n7sEj7w66My008kKm2UPCDOfAOBIRCDZLHukMNl7ZEwteE2h5vTYNH7yykDJKntuhRQt7qnvZstePK+4wmfpgIAsanyTEQSB+n50yqzUUSfU0dxChJTpPsiztmTZs6mZaCNH5J1r3NZD9G0ZUgBw20ffiXuePIhPXHmuUrbZsKq7pN4rV4ZUd1vBOf+Yrhv3tZRSNtFj8enbpNDi2Ve2cP9WwPPj/JNUWQkEZwJjLSikaiZCyrKe1X9uO5RuMDKo5KhuCmiqp7zXUtuc78PzglT/OXhRIzrwqFnW9Imsp4ycpZkcXCer9yV/poNnaWUdoPNcKCL/bGftygroZ1sB9cIgrkrjM82Q6mnLY3CiKgqp0wyRGggWDRKElEMhRQNpkZ2SZ04GPPQ1qxqGx+wPGScZHuJAWXeGVOuWPV36a5P3Apps2nJKRdBPD1ykGB/Ys6yAo9M1VZL7h4fcVfm+u28An/jy4/h3X3nS2U6wOFAsFnHZZZdh586d6mfNZhM7d+7EVVddNYc9O7NoK+Twu9e9E//6vfbNNKk1aHwwbYw5ATS7Cqn4up2RWsuFm3/sIvzGT7wVf/3vrrS20QmQNYasI4KehWVTjly0qhtdpTwmqw3sPRra+0yWPSINTkQkPl/48+ZExKVDzZOWvfaIoDMViuD2bpddgg4I6Lnx15hPAVaFVDQfUt9oTDaFlXOFFB04cLUQR0FTvDoJKS3zaJnDsvcvrzgX925/XyYZpfdNVzGdClb1MELK0NeuUj7xPnRr3xP4Z+1UPnf5nI/NG5YAAH787atO+joCwekGXyOOly0KKbbm7Myy7EXXUwUiMnKhfM9TanzbNWmcTVbOy7K1xVl41sp5bP1f8OOx1ISA9UGpkzIIKb63ybLh+b7bCs7bJm14WQopP86QaiFvKuu6+hw6E4WUjbyqanZQUUidXohCSrBokLTs2ZluGqC5Ncw2GdDJdynvq82CbUJSEwc7cbANxMkMqahfDuJoJt5wnShyteVKskyFlDZYuyr98YHdVUEFiE/OAWAooy2FEj97aBS1RtNqvRGcPZiYmMCrr76qvt+/fz/27NmDZcuW4dxzz8WOHTtwww034D3veQ+uuOIK3HHHHZicnFRV9wQhwgpgMTms5zoBoWoqilmacaC0C1whZbPrcRTzPn71xy9yttE37j+xyb4B10kLW1B6zvdw6blL8L1XBvGD14cAJBVPBLJYjUxVEQRBIvyWq2SI9NNPd3XLHimkTKrTpGUv/Jnp8IL+lq6VY/1oBAF8hN+TnVpX4tCGgOYal2WvwBRSrw2EGYEbV6Szy3hbgitDSg/lPhX7GgcnpFwKqRlfl91XJiug53noacurwx6TehFIZ0idCvo+cSn+4enDLedgCQRzAX5oPFGxEQax/StLzUQ/727LY2iyam1Hy+Ocnx0+HrCxNyak3ERXzvcVcWQjOGj09r3sUHO6rscyBG0kkzpsz/vq+debAYoGEpwrr2iqCCyx5nGWVtwH22E77T8Kvod6lvKKqanUnsnSdmw6adlzkUf63iRLIUUHQq5DdsGpQwgpwYLHd/cN4MWjY7jp/ec7T9aTCik7IaU2D7lwIA4C+0DEB23KYLFWuODlWTNUT2qT4SMz+A8wlXPNzshqK/go15pONRUfqLMUUmlCyt6HSuL0y14NA4AKWQbC7BYXeKjh6HQNKxybG8HZgaeeegrXXHON+n7Hjh0AgBtuuAF33303rr/+egwMDODWW2/FsWPHsGXLFjzwwAOpoPPFDt2iZ1RIsTYuu9RMwR/LFGh+MtAtZz964UprW12VY8saAoDLzluK770yiN1vjgCwWfbCx641AkxWG2o81tsS+TEy5Q41p/wrUy4fb+uaK+hvKRjcYzxaWDUx/JrGeZ340KvsuSx79Dy/u28Arw1MIud72HROT7pTSOd1uRRSa3uTxKFJnXUyWM2UTK4MqZmCk3odllD93vZCTEhZyDD+Gi89BcseAKxf2oH/L4PMFQjmGpx8t1VMowymQs7PVDPRz7siQsp2KM3HU7LhZSqZWEW+LEIq7zMbntWyF+dCqVDzDJIpx/YKWVX2inkfqMDZVh2K+x48uPcgDVYNj4bzrGrj+ZwPP3pP7Ja9mLzK2gedikIqi5Cisdu1VxKcOoSQEixoNJsBbrjrCQBhZaOffuc5xnaNZpBgzF3sOfdOF/zwJMGqkKJTj5yHfCMkpLInLzZxWEZi5SFHtn8bOLkqe22FHMq1plMhlSSksjKkkhO8qw/89R+vhGXkbWQiX4y4SrkCSXJrZEoIqcWAq6++2mlnBYCbb74ZN9988xnq0cKEnsekE1R6m1NVanBwEmC2FCp5RnSs6Co5iyGs6CqqwwcgDhE34fyVYY4UWdZMeVPthZwKQh2erCYCbTlI+aKPrTSF0JjYEZ3QmhVS4f+tZkhRtUGukOLtSQmrK+ByjJBqNANlRzRZ0Yhkuv+HYSXLX3jPeivRpFv2VjgIKc/z0FHMqcOlLGtnq+AKKZu18GTgeR6u2LgMT7xxAj91iTmzjt/vtnufE1uz2T+BYL6CHxpP1xrGNSKtOYv5GRBSKmsqy1rnZdr71NjrxeHj1up9zAKXZdmLHRLx/JIdBZId/G2KIwlJnzRZzq2LrWZI5XOxbbyVUPOszKuYvMo+xCdCioQBNgUc70MxF+7vKrZQc42Qcl1TcOoQP8sM0dfXh02bNuHyyy+f666c1Xjg+WP4o52vWAdhwsBErJ6h6lAm6At5l0KKTzKxXDZj8vJar5yXlLVa2iJNXrn23Pp1nJa96DVti1QArmBDPrlOVOrOjf+MFFJa2wkH0cRJKFflPiAktwij024CTSAQxODqp1LeN6qEOHF0ujKkTGXvTxY3vf8tAID/8jNvd7bL5/yE4stm2QPSwdomUsTzPGUnG5mqJUJfOYjMGZ6qJVSuvMoSEJNI3HZO4LYRPlfoY3XKsudzQipud2IyUkhphJSaC5tBZEWEsR1vS7Cpo4Dk5ggIyUEXyGr2Y2+bvQykC1bGVSj19/dU8cVPXIqvfvIK/Py71xt/38teP1tgOf+szaalUDA/IPuKJJraATIATBrGPmpTzPmxZc+WIaURUlnqJN+LYzus9j6jZS+DtGnBCsiVV/msbCruvMjIWaKnwcdn24qeZ15l7UHiCuJ+5mE7tS0wG57dskcZUr46bLHtbcj2TpZvVyV1qprYnqF8Uu0KopA6ExBCaobYvn079u7diyeflNDkmeLbLx/Hpf/9QXxt9yFnu6lqHb/y17tx+0P7cN8PjzrbHhqOM09c1i+9FGvZoZCKTzLSlYXsbVvxeof/J08yLDLcqK3neawakn0w1Adpm7yX/45UALZKf0ByIg6CmfmyXRlSOiGoV5ni4FbLyQxCaqLMqwK6LYYCgSAGVz+Z7Hp6m9OVIbVkFq/7//upt2HXb16Dj1y6LrPtSpb347Ls6RlHpgwpIFaQnZiqMht4si0REI1mkMiRojmEFvcdKkMqPf7yQxFeOU2fLnRCirelawRBECukOs1V9hrNQGX5LekoGHP60sSbXfXEVWO97QXnaw8A26+5EL9z3SX47Y9c4mw3E7xrfS962wtY2V1K5VSdKlb3tOEDb12p1AA6WlFItRdy2HRODzqKObz3/OWz2j/B3EP2FUmY1pkmdXyNkRuK5LFlSOkKqZaUTDlnW571WshQPTWYbTuLvOJjdz5jD8IP0LNIGx4+rh4ro7BSWL0v+pnluvzAJZdBXsW5X4y8suZNRf31s9VfpJAiJW4rCimaC7PUXJ0ZJKZgdiCWPcEZw+f+8QUMT9Xw3/7pBXzsMvNpIQAcPDGtBp2Xjo3j5xzX5BXaJi3Bh0CarW80A9QbzdQGAUieTmepnrgVIwi8ltp6Hpe1mvtLV+BBta4MqbRCypEhFT0onSi1qpACQiLJVoHqVBRSLqKLE1ImhQAHV1qZ7C0CgcAMrpAyBZrrbXTC4lTACbBTKWuvI5/zce7yjuyGCBeyL0bnH20Oy55uVbTZxpZFr8/wZFWRWHrbUj6H7lIe45U6hiarioyjIZk2I3SSWzYQ8tTWY9aK8OdxUDmQzpBKtI0uMl6pq/kgZdnz4o3R0IQ9PwqIK0MRXNZpbtlz5UcROop5/OKV52W2mwm62wrY+RsfRDHvq9f6TKG3PZsI9jwP/+/m92G61kD3LGZcCQTzEfzAksZHEyFFa85SK5a9FskFngvbai6U5yFT9cRt2IUM8ixe/7M9iIW8igtgIPug22Adz2rLD8XtaipeDY9+lqV6itu2kjdF17ORYmMaIeUqXEXknlJIWfZLcah5LtEfwemBKKQEZwwHToSWuqwQ62MsuPqNwUln235Wgc1FVpgGMdtkwL3TNHDbJqR6om3GxMHCB3Ne8me2th54qLnDhtfUySBX2/B3bRmnA0CaKHKRPFw+DdiVYkBaIeUKIOTva60RONtOsHur7JDsAsDfPXUQO+7Zk5lLJRAsBnS3oJDqZJv12apwBiQJsLnacK9iZIhLpdNZzCVsZro9jUCEzonJaiKcVceyrrgdgeeYAPGCeKqWHKv4vOZ7SFTw04d1GrvbDJY92oSNRHa99kIudfDAFVKuCntAmKnI4bLh8dN6V4W9040VXaVZDTRvFa0opIBwUyZklGAxgMaqQs5Tc5Fp30BrQZ4hZTvc5KHmgCOonFfZy7tzoZKH11HbDIVUvoUMKZ43mxWAHhdAynZexFlP8ZibZe/L+Z461sjMevKzc6GU6imX7f6oKzVVdrVxUkjRIYnroJ3C8LP2QEohpQgp+55iutrAd/cNOONgBG4IISWYE7iyiI4zQmpo0p0DdIKFwbpyiBpsgCdkSnZbOJ3gGwc1cdiktSbLXkbeFA8UdL1mevfcGVLRYJyfOSE15bDMxSdQFADY+nVd8lr9MV05UjxDypkT1gzwma89h3945jDu3XPY2k4gWCxIWPYsG1/+iZ5Nax3faPOw7TMJTkh1lOyElOd5CXWYHlROoIXx8FQ1tjQYyKslLGuK0GCbDCC2FkxXk+MkX5yH2YTm34V/G1n2qMqel17k03xqUj7R/NZoBirQfXmnJah8Bpa9IntNWlFInW3gJNSS9tn7TAkECxVlRp6TotN0GFpjypxizh08XdXIBWuoOVt7Z6meEpa9LDUVU7JmBaBDXTe2hNsIFh4F4mVY4LiaKh77s9pmV7iL90F+Zo4VPee872fa8CheJM+ua8umGosISzokcRZrUpY99/6O7pH2qKiI65D99x94CTfc9QT+5wMvW9sI3BBCSnDGwKsRuZQ2XLEyklHZjf/eRZbQgFNkQXq2kxQa73LsxCHLhpew92UopBITR1aVPZ4h5RD86BY91+kAndZThtRMLHsuMqhaJ0tI9uA9E4VUpZ5sW2mY+xAEQeLecRFSPAz/CLN9CgSLFZ0tKKS4jctVtW6m4Ne6ZJ09APt0gpMhNuUPgb8OOVuGFFNINdjCWgeFuPO5TG0GKEOKNmWaCpgP3V5GhlRZy5Di16fpg6r9mWyT9DwbzQBHRsMxc02vueIbP4Ev5nyrBRQAljFSy3a9sxn8Xlq1CAk5gUAHV3PSOtW0Xm80YiIky7JHYzCNf9W6eX3IiZiTCzXPUFMxe1+mQgpeZpU9HsKunBcZGVI5L1Y92Q66GzM4FOdZT1lV9qhtMc9CzVuy97mzqWakkNKseFaFVF1TSDmuefejbwAA7vr+fmsbgRuSISU4YwiHwPADPVGpK+JCxxQjEoYzgqmHJ+PfuxRS3DvteT7KtaZ94mIDcVZQeb0RT16e+lmWtDbeCNgGwjgXpEXLnkaCuSYvkte2YtnTJ2IXyUOvJymkZpYhZb8uyWvV9xbCr1xrJjZorr7yiowD4xVrO4FgsaA7YZszj83/8opz8cPDo3jfhStm/fH/9pffi2cOjOCai2evetpMsIqFmm9c3ulsyxVEBYtlj9qcmKwm5gkdRP6MTpsUUuH3SiFVayAIAqPVgZ9k678D4gMbTkiF7QP1eMOTDoUUO5w5MhKqmNcusRBS7Hku7yomrIQ61vTGJMyGWa5wtxBw7rI442wxEnICgQ6KW2gv5JR92pQJ1GDr+kKGtU1Vl87IA0qGmrttgDxnKbbhZbgeEkSXpW30f2jZy7hu9H8rxZK48tb3PDSDwK6QYkSXl0EG0Wuby3mgnZBV9dSIoz2y9jaxvc+H74d/ZyOvxqP5c2kLCindJWIjr+jwviPDsqcTdZOVeuKAT9Aa5BUTnDKOj5fhe54zuLTRDBLkxlSlAViK2UyxcPLRDEJqZDo+VXYREHySycFDuda0TjK83GkhQy7LK1HQmjurbSsTR4B4Mmgl1JyuU8r7qNSbDnlv/PPWQs2Tr6krl4neXyIaXacJOgHlUkjpk4BeMZGgq+5cfeX2mMEJtwpPIFgM6Cq1UO2rmMMfXr/ltDz+e89fPqcVxC47bymWdxaxpKOALecucbblhI0t1HzdkpBceW1ggimkDISUUkiFY1IQBLFK10tmSDWDcHNEhwl8/gg3DvF1+e+CIIir7LEcMN8H0IgX+XQAZLJjqlDzRoCn3xwGAFy8xqxm47larnUBAJy7LCb/LljV5Wx7NuKi1d0o5DzUGkHLAfwCwdmMilJI+arAhFEhxdRMpQyFFC1HiZDPzGTyoGyA9raI2mbb8HjlbKWmyuir53nK/myvssfnALfzgitv6TDCXumbHbZn5Dfx+Y2a2Igjen0KOZ8drBibqtc9z+zotudGBzrLlUIqe0/RlqGQIsKQ9jRBELbV53xdDPHq8Qls3rDE+vgCM4SQEpwSRqdruObz30Eh7+N7n7nGGrqpB4671EyTrG210bRWwwOSxILLTpay1pXrVlWOiTjKInh835tReVYV/GctuRr+74FLVV02vFgGW6k3M8uzAlwh5SCZ9Mp5LbRVCikHyaSTRU7Lnk5IWRYH+vvpIih5QKbrXhQIFgt4Bb3ZDCxfKFjT24Zdn7kGbYWclWQicELKliFFpNa+/gllCzZdt5cypKLDFb44VqHmTNXEK53yYd73dIVU/Du+meOElJ73oRRSRste2PblY2M4PDKNYt7H5RuXpp84kjZGV6A5AFywshO/vvWtGJ6q4sq3zB0hOVdY1lnEPf/+KnQUc3MSqi4QzDdMM3txrJBKr/vqjGCZuWUvy1rnoZARas7tcq1a9nhba5U91jYONbcprxC1ZVlPtv0KU0jRVGHbVTRM17UppJglnZ6nPQA9tuFlFXeqsyp7rj4EQYCxclIhZYtOAXiGVEaVvXpSIUX9z/nJjEnu1AGAl/vHhZA6CQghJTgl7D0yhslqA6g28OLRcVzxlmXGdjpZ5KpsxhVSAFCuN9FlIaQ4sVB22L5o3M/72UGFTUYyZfm3+clA1sRB1/WY19vG9kNNHMg8neD9oOeWNXEAcWlzp0JKe97OQb6eHOStzw0xedRZzGGy2nCGmuvElq2tTnK57gcefj6RUfVRIFgM4KHmpgyhxYBWZfZJhZR5blrRVcKWDUuw5+AIdr7UD8BMXi3tSCqk+LhJBxf5nI9izke10cRUtYElkZCGk1c86wNIHmDw+beN5XWpE3WlkKIMKXuo+eP7TwAArti4zGq756HmrkBzIFQBfHrrRc42Zzvefa6Z2BMIFiNoLVcq5JTyybSea7BQ8yySh8Y4IvPt7cL/fd9DKWuvwEib7Mp5vK3bXqgyZBFb9rKyaT0vWQnVBJ4hlUVeJUPNqV9ua1s+54HOge2qJ27Dy7LsRWoq310IaqJSV9elSq31ZpCwtyf7oO1VMqrstWuElF6BdljLOn6lf9x4PYEbEmo+Q/T19WHTpk24/PLL57or8wJvDE2qr4cm7Fk8euD4ZLU1hVT4t/a2/ORXr0DEQQOb72VLe2ncz3lepn+bK6SUvS+jekdLk4FBIeXgglQ/aFK2kUGcWFNV9logmQiuXChFSEWbFNtzA+IFB4Unm06/1HVTCinzdXWFlOt+GC/HJxque1EgWCzoSWRILU5CqlUsbyFDCoiJhhePhgvUVjKk+GEtrzhIBwjcmsw3CD7LGwSSGwL6m2LOT6iN9Q2Bqp5nUDVR3w9Haq8Ny+z2Mv4YWZY9gUAg4OAKKdr8m9aItDRMBJBnZMO2ZVj2+Do965qcDCpmZT2ZrIA25RX4vsLtvKBHSzgvLEtv7hSJSSZ3Wz6vZCmZ+HWzFFJFbtmzLNVrTCHlOpgnhVJ7IZfIv8wixYhosh3KU1/5wYvp/dUJqf4xyaU9GQghNUNs374de/fuxZNPPjnXXZkX4B/EoUl7Fo9OSLnyffSJouwgFjgJYQo9JDQNE5c1qJCdDGTZ8OLJKz5Btk4cBsue1evNJjo6gHdZ9hQhlXfb+/hgWmwpQ6p1Qopezw6lkLI2VXY6mjx0W57rMW2LgxkppMqikBIIOFZ0lRTp8Y615mwgQQheGc5l7zt/ZZiPdOBEWETBXGUvJH+Goiw7Pifwa9OimKuddIWULUOK5l96f/Xr0xB7LFpIr+lJh2vTXHh0NAw0d1WE40qwLMueQCAQcJRZhpRSSJlCzUmZw50PhrVkEASxZY8CquuWtbehyl6W6olX2c6qyOdxK6DVTRH+7yFW4GYRXV4ib9Z2gB7+T6Hm7rYxKYYM8krtP/zYWmdrqxRS+Wzyig7QCzmP2cvT7YYmw3lrWWcxMWdarXiUIZWpkCISM64IaHLLjGhZxycce+H9g5P4xJd+gG88d8TaZrFCLHuCUwLf2Ls+hNO15KbfHWKdHBz0sGoOfmriascr52UrpOIBnkimLAls3vfjvKlWpLUZCilOXlHVCgcflahG4epvnU3ged/93ICYZMr7HurNwDop8rYqgNepkCJCKlQHNJyWveR1rBlS2vvvIignJENKIEjA9z08+GsfxGS17lS/CPQqe/ZzvdUasWMir6iy2rGxkOjRSSYCjat8nktkSEXX9rxwrkgSUuEYp1sS9U3JsdHpRJ9Mbal/q3ochBRTja10EFcCgUCgIyakmELKsF6nda/veSg4yCM+TrZnWvZ4ZEd0eG0jmfjjtxhUztvqRYMIpJDyvOzYEG7vy6zezSJGsqJAeJZWVoZUjZF4rSqkChm5UGHbuL8ue98JVh2WH/pkWvEy1HJV1tdCLsznNd03JMzoLuUxXqk7xRm3/uPzePS1IbxyfAI/+6611naLEaKQEpwSEtYnVy6UppCaSVU1m2WvqVXuqzeDzKynsBqHe0LiA3E+43QinrzijYlVTcX6EFfZMzZNkFdx+KCd4KGJJjNDSklgPXXy0opCKqvsKcByoUrZvmx6PUkh5eqDvhiwZkhp95RNAQck79tKvelUn+3rH8f/eviVzIqPAsFCx7nLO/D2c0QdlYUNy9rV18W8fRmlkzF5g71vbVSN78RkFdPVhjHUHIgXz1whxW0gBNMJ9dh0OIfqodmqclE0dw6MRwopAyGl931Vd7oNgeZYAFi/VMhNgUAQ44Hnj+HL33vdWoionAg1dymk4vWsK++Jr8kVCZFxIJ3zMCPLXkFlyGaHmmfZ++Iqe9x54T689lpwXnACL8vex4m5bOVVnCHlZSivuGVPL6qhg+I0Okr5mEAzdHiIEVJJhZRb+dRecB/g1zRCCjALDuiAm6qkjkyZCal6o4nvvTIIABgYrzj3U4sRopASnBJooQu4FUr6xGOrcAekB3/bdU2Egy0AnYePx5Y9S5U9RhxlnU5wTzYpjlqqhtGCOonaZvmsgWSVPf4cbO0Kvg96mVxkDL3GXaU8xsp1u++eqafIWmKbDPj7qRRSjtdBXzjYFhK6Iso12Ov3VLXRTGyiOH7za8/h2YMjGJ2u4dYPbbJeUyAQLA6sWxITUuMOy69uVzMppHra8ugq5TFRqePI6HSCNOLNSSHFD3e48pf/TQPJRT5VIOppTy75cuzUeWCigmYQzpErOtOqJj283WXZ4787b7kQUgKBIMTTB4bxH/5qNwBgYKKCW7a9PdWG4hfaGCFlWu/Hh7y+kzzia+f2Yoa1jlv2MkPN4/G3qIiz7MiOLCsgbxsfimeTYjnDYQSHItt8fnDhJsV4lT1rqLlSMrWieuLkVfI56CCRQ1cpH6u/DG3psHhpRyFhFzeRR41mbN9sK2RkSNVj8qzgiGSZjOZkOoDSBRiEVwcmEt8fHSkrEksgCinBKYIrTWynHUCapHGpV/SB13ZdE6Fka8vZ/uzysFBt1WRgI3ga8YQYM+jZJyRZ5U7VJIN4U+JSSOmh5lme7FZOMoB40u6IrB42so2/lu2qJLm5bTl6j3wvPqFwKaT0+8HWB10h5bIX6u+963589uAIAOC+H4rnWyAQhKfRv/yB87Gss4gb37fR2k4P9DZV2fM8D+dEiqQjI9OJQw5eIYhUqlyJrDYN7LqeYUMwFgWmpxVS8cEIBbGu6i4lrmfru8uy96MXrcAH37oSv/QjGyXUXCAQKHz35QH19UMv9BvbKBVN3kcpWk86FVLMXmda93ESgTskTARLrE6aWeU8WvfaskuTaqp43Ws6PA7Y+r+QERtCPw0PuuFuywg0Gs2zA9DNcwpHnZF4rop8QRAfXLdi2ZuokOsi78ymig9cCvCZHdFEHvH3kg55sjKk8rm4wFXVkD1GLh6a62yunpeOJqvvjUzbrX2LEaKQEpwS+OmwSyGlDwy20wmg9QwpIhFIyVSuNY2TFpC04bWaIeVzuWxmRY5saW1SApsxybBJkaYOl5gqJqTckl1etSJrMgDi16hLEVIWdRKbhDsyBnk6Pego5tUg71JI0b3SXshhutZoOUPK9p7xa8Z/2wQMDhQ+qbqC+AUCweLCf/rpt+OzP/U2I3lDaIuq/tA8aQtAX7ukHa8cn8CRkWlcsLIrbKuVq6aKpPwQKM4widspewUbU/mCnYNbx8cim8EySwi53ncX0dRWyOErn7zC+nuBQLA48dyhEfX1/qFJlGsNpVQhxNk98XpdP3AEkhY0V7GipEIqfKwgCNeduhW5MYO9ArdMq4w/y6E4V1PxyqzVRhNtfvL5c5Ipq9J3kDi8bi1DKuG8yAo1Z+SV7VC8zohB176CP4dCzs8s2BQrpHJOVwnNrxQBUvB9VBtNY1u+P1MKKcNrGwRBMkPKUeBqspJUSNUaAar1ZsrOTzmRBKqsKwghCinBKYETUjYyCEh/4FvJkKJB2yZ/pEDzUt5XA4utDyaFVGaVPRY+aA0qN+RC2QiphAQ2s8oetWWbjRYIqWI+nmxN4KHmWb5wwEBI2exyjBwsFdwqrWkWWJnPeM34Y7Zl+L1pwRLnXc1EIWW+b7glVfzeAoGAw0VGEXiOlKnKHhDnSB0ZKSdyCTl6osU2n3P5Jkf1yXCSTH/T06aHmsfXoWDWpR1mQoorpJZ1Fp1h7gKBQGDCoeFp9XUQAAejCqQcPLsnJoXcCqmiox0nETj5ZVojJiM7sirnhf97nucMX+dteah52AdTCDtdGJmVvrm9j/YgNoKHftpaRT6uesrKm2rNhsefQzFxKJ5FSBWc/dUVwK4CUzWDm8O0p+A/K+Z85BxKNSraxQ9pTCqpfiGknJAVheCUwOWpM1FIuSxSNPjT4GKrllZrxpOWkstaVCx84nJ50gG2yOe5ULagcmavKPhuyx4/TcnyeptCzV3EEb2+xQx5rzrJyHlOCSxBWfaI5LFclwieUt7PPKWh+6S9yCsTZt8PavKwdJjukyw1F++v+lvLvXCChRNmhZ8LBAKBjjWs0p4p1BwAVkaqpBOT1YSal4Py9saYQopvRgimRT4t2Lt1yx4ppJqBqlS0xEJIcfLNlR8lEAgENgxOVBLfHx+vpNrQ+qyQ85ltzk4a5HKeMyicux5KTLViIppmEu/BYzhMRSc4+Pq/mCCkTOocRG1bOBRn5JVae2ccdHte9vo/kXnrsOHxvmVlSPGK2YVctlNkvELVYXPO644phVQh6of9urQv8FlovdnaF/9tPuc5KxiSQqq3vaDeW5OQQr/XhZBKQggpwSmhwgigmWRItaKQIvmljejiJBOdTmS1bSlDilfZy5gM+ClCXlXZmIFCagah5raWQRCoa2dnSEXWPt9XRJetDzz8j0ge22tGCqNS3s9UitF90lHIOycOAj1mW4YVUAWwt1C5r6pnmlmIzBOsfGujGVjVegKBQGACr1hXtKiKlnbGhBSfqzhcCine0nSAQQt2PdScb2BGWDCsCVwhtarHXmFPIFgMuO6667B06VJ87GMfm9HvFjNqjSaGo3HmbWu6AQDHx8uGdpHiP+cOK1fZRcyy5yKZePEh2zXjAwG0EGoe/u972XuQBBnE+uHqgwewfYXloDv6P2nZMzZNkGKZCimmvo0PLszX5a4Wlw2P3hvPy1Ze1RrNhEMjxw5PdOhFO3KO+BTqQ54FlRuJK/ZkCzn3vobUUJ3FHDpKucTPOAainEYiRYWQSkIIKcEpoZJQSNlJJv0D7ySkIhad8i5sqqc4UNzLtuwlJpkMaS3bEGRV2eM+6zioMCubylMV7rK83p4HFj7oJsWAFqrssVBzXmHJhERQeTEjqFzZJ3NxKdcMQqqtmFOVm9yh5uHv2vIZhFT03ne3pJBqrerjqBY66KqoJRAIBDrW9sYV+fRMCcKyToNCSiOkjAop+iKRIdV6qDlX6mZZ9nh/zl/RaWwjECwWfPrTn8ZXv/rVGf9uMYMO+HK+h7eujgipMYNCihEctF437RnIKsYr4vGD1LhdPKZ6HldTtaiQynA9hHsQqrKXlSGF6Lm5A9PDPiB2XmTkzfJ9hW2dztt6GQop/pqpv7cci6ug8rzbhqeIK9+PVFrUL5PqKF5rd5byTqfIuEUhZdqL1RnZ6dp/cGtfIRcXuDLta0gh1VHKozOqMk4/4yAC6i3R/CmEVBIthZqPjY3N+MI9PT0z/hvBwgMndVwZUvqgO5sKKT4ZWE8nWFvKOMqssudlV9njKq0sZZA6nfDjjYB14oj+b0Vayx8vVkiZ29ZUf/3M63KSxuW1DttGhFQhPkmwyYaVZa/gt6aQIsteBimmK6SchJQeam65F6aryZ+Pl2sJxYOgNcgcIlisWLc0JqSowpOO5Z2hBS5USIU/S4eapxVSZsse/Y4rpMyh5lwlOxOF1EWru4xtBIJWsdDnhKuvvhrf+c53Zvy7xQyy6y3tKKp11IDBskdkQCEfK6QqRvIo/D/veygwsr/WaCLHgsLVXiEa8Ao5D9WGhZBiDonsitzxwXE7y5BqNoOUwrWpjdXFvI/pWsNIdsUKKQ80Zdgr/cV9yHJeEKHkIc4ozKr0nfPNhxwcOtEEmNVUej6wq3rfRERIFfNhBXNlmTP0lyuUwj47MqRYH9zWvnhvR6o2wK2Q6ijm1D5l0qCQonl4TW8bXjo2niDdBC0SUkuWLEmUH86C53nYt28fzj///JPumGBhgG/kXZY9/QNvU6QA6QwpG9FVZ6cj7RkKKV6WVMlwGxkV+Xy0rpBilr0srzc/nbAqpJhk1zNsMEx9AGJCykYGcYVUlmSXJmHPgyLx7IRU2rKXpZDqKOYZiWd/fekx2x0VMYD4vacTCls7oPUMKZ3gHBOF1ElB5hDBYsWmc+JNtE0htbQznOuGHJa97lKkkJrmGVLxZoRgVkhRqLmtyl6cIUX2QR05lrJO6gaB4GRxOueEXbt24fOf/zx2796No0eP4utf/zo+8pGPJNr09fXh85//PI4dO4bNmzfji1/8Iq64QipDngqmqnXc/uA+vO2cHnzssvWp30+w4gpLIuJ7xKAS4aHmLlJIKaRYhhQQrud4eLmu9inmfUxWG8ZrcpI/O282bktEBBBm63YUk9trfiBNz40/V1MfPC8uhOFaz1IfXDlHvL/8oNtGMsVEV/ZeQb1feXfbuF34nHIOQogURhQX4jpAp8gNes/pNTNdl1fOc4kIamyvFF7T3ldyiLQXcipv17QfpsOkcyIydsqgolrMaImQAoCvfe1rWLZsWWa7IAjw0z/906fUqfmMvr4+9PX1oWEhM84WlGsN3Pw3z2Bldwm/e90lxoVDXSurafLMqra6Zc+hXtEVUq0ElWdZ9rgNQp24WK6bCJVVpxNun3XOyw4158qrLBVRMlDQnSHFr0Gh5tYMKfaaZZV9pUm4yE8nshRS+VxmBcFYIZXLVEjxyboto3pfhfnN9b9NXzdQbScqdWtwvk5I8ZLrgplB5hDBYsTFa2LyZmSqamxDCqnhqWrqNJ/QbciQUkpa1s40rusZGwRuryDLni3UnM+tF64UhZTg1HG65oTJyUls3rwZn/zkJ/HRj3409ft77rkHO3bswJ133okrr7wSd9xxB6699lq8/PLLWLVqFQBgy5YtqNfTa9oHH3wQa9eubbkviwl9334VX35kPzwP+NELV6TU5JTB2VnKozdSa5psS7Q+K+V9luNkqp7H1t+sYIS+9tMJKVf1PH4gQBawiUodQRCk9kEBO2RuY+rXcq0JfRjlBA8Qr9WdGVKeh0LGoS1XSGXFcCTUVIrgsR10h//nWnBp8BB6V1tl7Ytef5dlb0JV2MurPof9SrflB+JATCKZiaa4D62En6u+OtrSfVTM++o+0EnMRjNQz2lNT6iaNqmoFjNaIqTOO+88fOADH8Dy5ctbuuj555+PQsEs+17o2L59O7Zv346xsTH09vbOdXdOG767bwAPv9gPAPjUBy/Aucs7Um30D5yNtAl/F8ska43Aadmjk4BshVQ8ybRaZY+fethIsViG6yHvuScDThyp8MEM1ZPPJg57hYu4Le02rBlS7HVXlj1rhlRESOXc1TCA+PUJVU9u5RWRe8V8TF7ZTnSI5Gkr5OLwQUvbaoKQihRSsxFqXo9Jz4lK3XoCVtZOOSYcEtv/8Y29+Mc9h/FX/+5KvG3N/LEWzAfIHCJYrGgr5NBeyGG61sCPXrTC2IYUUo1mTAzpGVJkt8uushf+z+eL8bJZIcXDauMMKfPn7o2hSdZfM2klELSK0zknbNu2Ddu2bbP+/vbbb8dNN92EG2+8EQBw55134r777sNdd92Fz372swCAPXv2tPRYp4JKpYJKJbasnYyNcT5h175BAOG49Ohrg/jou5MqKVo/dRRzTkKqalJImaxt2gFrMeejysKwCXE1bF9dF8io3OfH42WjGWCy2lDkiHp8HhIeHXZX601jdEiTHUgDsUrIpZDyPajCSrb9Vaymyj5k5teNM5mMTRMxJ1mVvmmtXcz5LSmkioqQsu9BJlWFvbzqh+26/ECct3UTTSxmxfAe0HOieyXvUFNV2eF9yZIlxvcOa3rDAygpkpRES6Hm+/fvb3nSAIDnn38eGzZsOOlOCeYeh4en1dcHTkwZ2+ibeJfqSbdduQLF6QPfnUFIxZNRPAi0kjdVyvCFczVVIYMw4TLcuDyrOwCRq55mIq1tJUMqn5EhRcRaOBhHj2VprAbZfC4OYbe8DvyEIp9xSjOlLHu5zMBGHiyYlWNF/e1sKdQ8qaay3WP6/WQjPJvNAH/+yH4MTlRxz5MHrY+7WCFziGAx49v/8Wr8/s+/E9suOcf4+1I+p8YiylTxtdUZ38DRXKIyQQyWPRp+642mWgyTyipuG/5fqTdVSepzWAg7x49euCLxv0BwKpirOaFarWL37t3YunWr+pnv+9i6dSsee+yxU77+THDbbbeht7dX/VvIc16zGeCV4+Pq+1eOT6TakIuiiymkxjIse671enwoHbax2fviAkjh9yUHGcQdEm2FuBKbqZ98nQ7Ea1STXUsPNY+VX+n1rCKZwKJAshRSAHMyGJvGFm942cWSDBEjtj0If79cpFg6Q8reh1ghlVP9sPWBZ9gC7lBz3te8Y/8Rq77Ca7kIsXiv5CtSTN/jkruimPeVCtl1wL0YMStV9kZGRmbjMoJ5hKHJ+NTm0LCNkEoOuqbqFgRi98lXbSMLeKlNshfYSCaukMqsssdOUmwDBoG6kPM9NdHZTifip5sdaq4se352lT2+0YgnDmNTNUDmW7huHNTnnjiAeJBtSSHF2mYFK9J71F7MZb5mqkSr7ymyLcs2SMGGtUZglAIHQaCuS+SV7fHThJT5/jo8EhO4pqoxAjdkDhGczVjT24brLz83pXriWNEVLlKPjYVl0PMaI0UbuFojUONSPF3aFVJ80dttqbJ3aHgKQRCO39QPHf/mqo34/Mfehds++k7rcxAIZguna04YHBxEo9HA6tWrEz9fvXo1jh071vJ1tm7dio9//OO4//77sX79+gSZ5fodxy233ILR0VH17+DBhXuYdWh4OnFgxw+1CROsGpnbsheTAe4MqSTRVLQQTfEaOamQcl3Tj1RXvQZlqn5dGnOzsmzDttm2QVr/+x6rspepkELmIbNSSCWCyrMdHS7VUxAEzAbnzqYi8i2vKaRMa/oJTSFl21fw6JiSyqayv2bcspdzWvto7xFd0zO35fuJYj4WR+gxIOMsP41ybiVDKokZE1K///u/j3vuuUd9/wu/8AtYvnw51q1bh2effXZWOyeYOwxNxFkXJyy5F6YMJhvRRKqhDkYWmMB/nqWQUiRTrgXLHmP7MytnsLaFFk8nfI+x8pmh5q1MBuH/HrhCyi2X9X2PlfG2WfZigqdVy14x72dOdFwyG58kmK9Lp0dthZw6/WlYXt9anU0eGWQbEaQ8TNLl9waAzhLdj5ZQ82prhBRtIgHg+HjZ2EYQQuYQgSCN9UtDW/wbg6E1TueuOopx5h5VxOMbF4JeuYgCzdsLuVSoOs0Bb0Yq6PVL261B08W8j4+/ZwM2LEvb9wWCU8FCnBMefvhhDAwMYGpqCocOHcJVV13V0u84SqUSenp6Ev8WKvgaCDBXz5tiqhenZY9ZoIoO8khXSNF6XT9sjtfI4feFfJTflFFlD4htezSOcsQET9i2zWLXApL5TWEfIvLMEazueXEekm2NSitcn1WCsx0cz8R5wS17reRCARQFQs/BpZBKhpqbrqtb9mykGH8PSWxQUPsKQx+Y8klVOze0UzZELZdK36vwxw8VUuYgfCKkutsKat9hypAKggCf/+eX8Jt//6yT2FSP74i/WWiYMSF15513KlnpQw89hIceegjf/OY3sW3bNvzmb/7mrHdQMDcYZISUaSAG4g9iN/NV22x79OEmJZNVIcU+XGQvmLaQTEmFlH0iAJKDaxYhRW1bIZl4hoey7Fnzplq37HGvdzzAG5sqGx0PKrdW2WMkXqtV9oosb8qa3xS97qWCn/ncuGWPJiQbQUmVEHk2VVZ/uc/fdF3+s06l2HOruQg2VR1VqALMCyxBDJlDBII0iOh5cygkh3Q1FT+tpzGGb1wIejlvW6A5b3sgekwhmwRzgTM5J6xYsQK5XA79/f2Jn/f392PNmjWz+liLCToBZTqYm6hShlSskJqqNlL7AaViybeeIQXA2pbHewAsQ8oUKK4FoHc7iDNeORuI9zembCBekQ+IQ81dtkEvcShu2yukLXtWhRTitlm5UOpg3m+tcl74nNzZtDwyBBl9IEKqW6uyp7flwgh6/137FU6KuYpL1SyWPf3t4vvIYs5nbp1kQ7J8drflFclmuk8e338Cfd9+DX+/+xDue+5o6vccf/Dgy3j7rQ/gob39znYLBTMmpI4dO6Ymjm984xv4hV/4BfzkT/4kPvOZz+DJJ5+c9Q4K5gYnmGXPtsGmgaCTEwCWDTsNRKSQspFBfAAhssBWAY2Y6jwLNTd5t8O28eAaM9iWtixDKt8yycRPMmyWPaZkylARJcp5tzhx5Nh1bR5ypZDKqIYBxK9PkeVCtWLZy6qcV2ZV9rIUXRXmzc5l5E3pNjwgaQFV7di9R/ejLfdLt+zZ7kVOSA1PCSHlgswhAkEaG5aF2U37h0ghlVYq9XZYCKmEZS85ptJCWA80B+JF9psnwsdcv9ScHyUQnE6cyTmhWCzisssuw86dO9XPms0mdu7caVUynW709fVh06ZNuPzyy+fk8WcDgxPhnuGiVWEFTrNCKqqyV8wl7MP6HoNXbYtteEGKaKlr5FHRQjTV2SEzb2ckuTTVU090MG7OkEpet82RkauTVy6ijZ6lh5hEy7bsZVfv5qRYlkNCRZd4nmKOTJetJ4oquQPQ+SE39cPWluydKtTc0l96rfNs/+PMe1J7IC+h0NLvrZpGYsb5XJpCSiOkbPtLUkN1FvNq32HKkNr95rD6+uX+8dTvOb74rVfRaAb439951dluoWDGhNTSpUuVz/mBBx5QwYBBEKDRED/k2YJJ5m01DcRA/IFrL+YUi2xVSEWDVnvRrZDiWU/tRXdQOZ+MaHIbr5j7WmfXLVoklXofEpa9jAypsDyrO9ScTwZqwLSeZMRt1QbD2DIeIHPsJCPL3lfwY3lvpkIq72f212TZsxFS04yQylJT8Qks0zZYS5KegPl9q7IJjO4Fa4ZURHCq8PNWFFJTNevrL5A5RCAwYUNk2aONnClvKqWQMlj29I3GONlk2gwKqajtwRPTiT4IBGcSsz0nTExMYM+ePapS3v79+7Fnzx4cOHAAALBjxw586Utfwle+8hW8+OKL+NSnPoXJyUlVde9MY/v27di7d++CPpChcevt54S2w7FyPaUwJ0VIezEfrdvDMUknpHiGFKmZgPT+oqERUrZcJl0hZcua4tekMdVU3TS+LqK2YWPXYTd3PST6aiSv4utm7Ve4FTDbecHaakpa23XDPYi9Lb3WYYaVm+jiB8x0bVtb3bJnI7p4QSWC6q8jrLyNHYgDaRJPKaRULpVZdVVl96rvyCjm2bkktqjWm6l7kBO5+wcnYQPfY/SPnh0xIekVSgY++tGP4hOf+AQuuugiDA0NqdKqzzzzDC688MJZ76BgbsBJoHFLJQBehaCQ81FrNFTmj460ZS9bJkof7Oygcl/ZEcinq4NXzqDr2lRa9DnP+Z6awGpW4ige4LMCuk0ZUtaTjGYs2aUhM6vkap6RTJmh5szrnRUSXszFQeVWyx6bFGiMDywUGlVaaSvm1HtguR1Uf4v57D7QxNBWCEmxRjMwLjj46Vtc/tetkFrSUcBEJb3AIgwzQqraaKJSb6p7XZCEzCECQRrLtTBxJyE1pVv24raethifYiezOnQV1jlLRCElOPOY7TnhqaeewjXXXKO+37FjBwDghhtuwN13343rr78eAwMDuPXWW3Hs2DFs2bIFDzzwQCroXNA6SCF1wcouFPM+qvUmBicqKhsPiNeJFLGxpKOA8XLdSkiVWCYPEK6t+LpKJ6RsFfl4zirALXvptSTfKwDuDCmbZc+UZctteIk+mBa/jDiKI0bMa09+eO1SBrHLJg66bSfdsaPDrWTSK+y5Mm+rKUIK1uvqVfZsB91xhb34vmiFFCvl41Bzui5fsqvnpauudEJKU33ZSEm6J9oKfsLFMVVtoLc9vsc58ckPunXwfblN5bbQMGNC6g//8A+xceNGHDx4EP/zf/5PdHWF8syjR4/iV37lV2a9g4LWUGs08fWnD+PytyzDW1Z0nvL1uLe1bLHBcUljMe9jqtpwKKT0UHOLOonlIZGaymbDi0u5eugu2UvIAskKd60rpGIbXiuqp3ymmiqe6LLUPrHyKp5EsyaOrNMJ/jx4NQybmEdV2SvENrwsdRLPkLL1gV73tryv1F02RREf7LOsgHyyy7sIKZZLlUVIlRkhFVaRsVj2tOD/6WpDCCkLZA4RCNJY0p4kpIyWPU0hZVrI6+NvrEpIj0c657W801xhTyA4nZjtOeHqq6/OVCnffPPNuPnmm0+qv4I0iJBa2V3Cyq4SDo9MY2BcJ6RiJT2AaN0+nVq380poRa6QshBNeoaUvp6jg1/VzmHZa2jkVStV9miodimkdHufS6XF9xW2kGy9rcf6bFsj8/kiq8q22q/48aG4OdQ8Sdy486bi9xWsv6a2dE/Q62/br6i9R0IhZb9uws3hJQmpRF+byb5aFVIayWYjJWnv0JbPRXsPD7VGgKlqXT3H8HnHRNOwg5DiSiqT9W8hYsaE1GOPPYZf+7VfQz6f/NNf/dVfxaOPPjprHRPMDH/31EH8568/j4tWdeGhHR885evxjfdUzXyz1w2yWpvqiD7cmYQUI23UBzuDOMr7npLVtqKQck1GvK3Hg8ozSCYPyAw1N1W4sCmkuBUjSyGlCCnPywz+rifIK/d1VZU9ljeVnSEV2/Bs5BUfwKdrGSSTIdQ8q8peKSKaKvWmxbIXq66yQutJIbW0o5h4njr0iWOq1sBSY0uBzCECQRpLOpIZTyaFlB6Gqk7HWfiCbtueZkUkdOiPwRfGAsGZwmKfE/r6+tDX17egLetEki/tKGBld0hIHddypLg6BYirHOuHzlWmuvF9D3nfQ91wwEgHmrrySV+n0UG3aucobJRSSLWbbYVh2/D/lhRSmr2v6DgMVe4CL5k1FQRBugoqI8XiNXLqktF14z7E639zW76vcMWGKEIq6qde5ZWjynJpqR9A/NpwjChCqhhdN9kvdc2GwbJnsSNOVur45xeOqfZ8/rNZ9khoYDsQ122INgKxrA7tw3uko5jH6HQtEY8DAONcIWWpcA+kCalGMzCuGRYSZpwhdc011+DEiROpn4+OjiYksoIziweeDz9krxyfsG7YAeAf9xzGf/+nvc5ykkEQJCx7VoUSr1yXoTShCYEGbBtxpQbBXBxUXq03jc+JPz5NGqZTDP26pUgubAuopofKRRMhYA7HBqBGaJ+3zSCvuGXPHmoe/u8hrpxne1fr7LllVc6oqyB4P/OExJQhlaVOKuX9TKKLD+Cuk4x0H8L3zUaK8T647JOcaMu7ZNOI7/0lESFl+9zoi5VpQzlXwj+/cAyPvDJo/f3ZDplDBII0UoSUQSGlindE45Ar1FxXSJkIKX1zs1QUUoI5wGKfE86GDCk6DO5qy2NldwlAOticV2MGwk05kHRkBEGQsIEB3LbWmkJKb6crpAqOCne6Qiq27KX3FqqoUbSTdmdIJe191AdjADojr0hNFgTmdWrSspd8rNR1GXmVddDND9BdhZXogFepnlxtyYqptTX1dyQiY2hetNkRY4WUybKXbHv7Q/vwxP5wnCkVNEJKe21pr1TU1FxpQkwjpCz7S92u2hnNx5OaummMiSpGpmpWd47+2ZqwiDEWEmZMSBkZWgBDQ0Po7Dx1q5jg5MBLX5qqWwDhZvrTf7sHd31/P/5xz2HrtaqNJAGUZZnLJyphWCx7WpU9Ww4QZ+XpgwuYB3hVZS8Xh5qbfN788VpRSPEyqi0rpLwWFFKMQMsMNWfkVRbJxAMbs4ijupLMZtv7ZkJIJTOkWrtuiRNSFr6vShlSLYSaG0PYHT72Ut5XpXdt7xndI70R4Wk6+QLS5Vv1Uw/Cc4dG8O//cjdu+IsnMDRh/pye7ZA5RCBIo72QU/MokFQ98TZATIwnqrFG0A8alGWvkBbE66TXElFICeYAMicsfMSZPw5CSrPs0X5gih3gNZqBItqLGYQUt5Xx9jpxw/cVyXYmQgqJazpDzTWFVExG2G14dJu7XCXUew9IZWilrxurqbKcDOoA3eMWOPe+gkeBGKvsWYgbU9t0hpR9r0CHvERI2UimOEMqbdnTX64/f2S/+rotn0tY1vXXrKr2t0mFlL53pfc6zpCyhZrHGbdArHae1A6vx7X7zFa1W1cf2sQYCwktW/Y++tGPAggXO7/0S7+EUqmkftdoNPDcc8/hR37kR2a/h4KWMMykfUdGp7Gmty3V5vWBOLH/xaP2cpLlavKDZK9yxy174YfVpnyiDzGdiGRV2cv5HtoY4z1Vbai/1a+Z831VraPaaKJcS+f38MGVBx+aFkL8xCHvOEkBuH87JplaqciX7fUGNc7MeuIlbbMq8vFQ86zTFJPiKCsAvVTIZSqk4lyoXEwyZbQttBBqblJemfrLQ82zFFLUtivKKLMppPRJRSeoCI++NqT6tffoGN5/0Upju7MRMocIBHZ4nocl7QW10DTJ7/VcRT5XQX0d/k9jKqk1TQopTnoVcp6xjUBwuiBzwtkDIqS62/JY2RURUhNuyx6t6SfZeomTLoV8kkDSN/nqUDwayGIrXnL9pYef2wguwBRqHrkvnKHm4fe0Zyk7M6Qi8spCXABJNRXP0KrUGqric9wWqm3WOj1ZOc99cMzjU1xqKl4RMby2vW1Vy5BSNjytbRAEGImIGMpWtPWXDsP565S1BwFCAsuLXrNGM0i9ZnVNpWcNNVcKqfD9JCGFvlege4LukQ6y32uH17oSb6xcUwQvh072jk7XsMH8VBcMWiakent7AYQ3Snd3N9rb42osxWIR733ve3HTTTfNfg8FLWGIZdicmDD7TkcYaXXgxJT1WnpmlG1zHYeKx+HQ9lDzsC2vsmcigxIB3b6HnrY8xsp1jExVsaKrZG7rJSsImQKlG2wgpomgGYTkRiGX7AM/caCJzkaC8FKuKtS8hSp7uYyTDFOGlG1s5dUGVeGMDMtewY+tgFm5UMWcn5lNVTGQV9aw9EZ8opF1omMKNTcppJrNQL3upXxMdBkJKZZLlUU4ElFFhKetHU0qVF1m2pK79trxCfX16wOTi4qQkjlEIHCjN0FIpSVSbVbLXgz9AMMdah7/ZW970ahSEQhOF2ROODsQBIGyDHWVCmoDfXxMJ6SSeT+UITXFbEu88l3KspfKkKL9Qvh9ybIP0QmpeL9iWEtqqlNnqHkz3lcArSmkaFgn4sJs74Pqg+97KgDbrJCK2sKuItKvixacF4kqew4vlW7Zc0WB6AqpeK+QbDtZbaj1fKyQMvfXpJAyXVd/jGIuqt7neWggTUjpttFWQ83tCimLZY8dZjebgSJ2aS9hyi4DgGOj04nvF5VC6i/+4i8AABs3bsR//I//UWS08wj1RjOhkBq2BKFx6d+RkWljGyBt0atEGU76iS0nN1wnDkD84eYnsLVGgGJeI6Q0Ce6K7hLGynUMjFdx4arkNblCKhf1oVpvYrJaT2VhKFtbzkvYIqr1phpwCPzEoZBZZS9gbX13WzZ5tVplj59k2EgmPtl6npsM4q9Ztl0ubYGzqpMoG4CHmrdAMmUHoMcLGGrryoWi/hKRaFZIBapdwXe/ZxRsGIfxm/tJkwpVl7GRuP3sVGPIUUHjbITMIQKBGzxHKmfghvQMqaaBkaJpmsa+qZo9Q4oTUks7xK4nOLOQOSHEQg81r9Sbal3W1ZbHqm6LQsoQ7AzYFVJZ2VB8PcvbWS17GiHlypCitqRIMlUy43sFIFa/tJIh5QxAZ7EhQLhWrjUaZnsfVz216LxoRSHFnxtppFwKKXIbuPYVrVr2qEhQKe+r18m2VzBlSKnDdtYH3elDB9M53wMahip7LN4EgHVPoZwkyrJnVvNVNMueuveZQmqyWlevxfql7Xh9YNJaOf7IaDnxva3dQsKMM6Q+97nPLdpJY75ieKqWICBshNTIdPxz3X/KQR9cUoUAZqsSDxUvZFif6EPcXuCElGkyaKprAlCqqEFD3g6vsgfEjLMp86rOyCCdkNLBJ4MsSxfP8MgONYd6blmB4jzHKj7JMDaNX4ecW1oLxMRLPtdClT1TJlOWZS/vZ568mLOejE3Va8kr4pnUVHzwL+Z8daJjastDzVW4pbXKX9i202E1bTQDtahYES3EbITUIPvcnZhcnBlSMocIBGZQRSHAZtlL2gH0DREANWHQiEbzYWfRkCHFHkMPVRcIzhQW+5yw0EPNKdDc84COQg6resLIkONjyU2zrpAyZUjV2PqM1skq99WSIZXXiKZUlT2LZc+0ntNzqdq03D5T29YUUrHrIbyuvbiSEjKp67rsfdQ2dl7YDpn53obWyNaDbvY6xM6LdLv4/Upa9kzXVe6EjAB0PT+K+hG2TV5Tv6ds19Utl7S3tNkcdYWUzc3BHRe8HzopqSukukrpe58+R4Wcp0hdm0LqaKSQIsLUVmF+IaElhdS73/1u7Ny5E0uXLsWll17qlHU//fTTs9a52cJ1112H73znO/jxH/9xfO1rX2v5dwsFIxoBdWLSfAOPMIXUyFQVzWagGHUOGvR62wvqJp+qNlQIG6HO/MAlxwAPxBv+tkxCKvyfBomVLRBSuWgg7CjmMTxVM5IBXNpL1fPqzcA4wBN8nwfZWQLQo/89z2P2PreaKlGeNet0gk8GlmQoTrZl5k0ZQs1tbXkApe8gg3jbZOU80/MKEsorWylXAiePXKQYH/wLOY9NzG7ZcN6hauN97YgmD5Nkmk8oK7vCDaWtEMDQJCekFo9CaqHPIQLBmUAvCxX3DZ8RpZBSGVLJk3T+NW0IaHwyWfb4Q3AyTCA43ZA54eyBCjQv5uH7Hlb3xKHmfJ+RVonQpjxeL9XY+pBQsimkGjFpwv9G31vozouiI/O2wdbTvK/lWjpztsHW9GE/XRlSiNpq13XkTdF1bYQckJwDco6DWI6kQirDsue5D9BrWi6Ua/1fY+4EgNn7tMZ6flTYNtkvgh4WDpgtezws/IqNy3DdpesSbfXXTCekKN7DppCi50T90EnJsiLOkhlSXCFFtruetgKzipqUeQH6R8O9xEWru/DMgRGjgm+hoSVC6ud+7udU2OBHPvKR09mf04JPf/rT+OQnP4mvfOUrM/rdQoHOoA5bNrr8580gZFR7DaeiNfYBayv4KNeaxtOBGlPbuCpGAPGGPwySC0kQ0+aeyBwiFFZEG3wTIaWXfG03TG7x8w0S1y3mfdSrZglsfIrAbXg21VN86mEbsOK2UNfNUhzxgT+WyxqbJpRi8cmAuW1NtfUzJ6QEcZMR2F4xWOvMJyRJa52rGl54XQo195yh5tWEQsstXeah5rElM92OV3txKaTofsv7nqrIYioEEAQBhli+25Al6+1sxEKfQwSCMwHTiTCHNUMqLZBKKaRMlj1eZU8se4IzCZkTFhbGyzXkfd9IbKv8qMhVsaKrBM8L12onWP6rNdS8kiakeLZrdoZUi9Y+L6mk+tsnD+LCVV34d+8/n10TiWvy51upNxPER5wLRSRTKwqppL3PWLlZU76WWsqbikmmrFBzz+NkkKEd+/sc21e4FFJ6ULk51Dw+YObPT29Kbp5eo0JKs+wZFFKe4XUgYmfDsnb83X+4KnVdG9FE96GtaBWPIAHs71VMnEX3fsGukOpuy8eElEEhNTpdU6/lW1Z04pkDI4tHIfW5z33O+PVCwdVXX43vfOc7M/7dQsHIlF4m0rzR1RnU4amqkZCiwbuY81HK51CuNY1KIj4ZqCp7GdXzClEAerXeNFrbmtpksDyayEybd93eZ5L/6o9PE0cp72Oq2lBySw6+yJ9JlT1l/8qw9/keMr3e3IoRS2uNTbUMqeRj6aizyT7TsteIFw+m03oOng3gIsV0a11WWDqvyOcKNddPKfKO17fGnhep2kz3LX8fSR3IAzcJk5W4ilWHwzY6Vq4nyLTFpJBa6HOIQHAmkFBImSx7FkIqWWUvuchvNdRcLHuCMwmZExYODp6Yws9+8RH0tOfxjV99f2KcAoDxSrgHIftQIedjeWcRgxNVHB+rYEVXCc1mkFhT8v/5+ksPyQbsRJOufLIdjKsq27lkOwD47fteTBBS+uF1GyM69IJJfE0fPp9sa51qa6nGxvugK6RM1004LzIOeJPkVfQzQzv+92FhJbubQhFSGblQgCHU3GKDixVSacWw/txMCilTH7j6iMNG4tFrTde17VWqLFYEYPeArpCinN3oejFxFbcj8qmnvaD6aSKkBqP9cHdbXpG9Z4NCasYZUoRqtYpDhw7hwIEDiX8zxa5du/ChD30Ia9euhed5uPfee1Nt+vr6sHHjRrS1teHKK6/EE088cbLdPiuRUkhZCCl94LO1qzLlkyusvM5IJip5aa9Wxq5JuUzGa7aeIaUrpEzyX4KeN0XPyxko6HnMspdFHLGKfJbXgK6QtOxlqKkSk4GFZGKvmQo1N7bUQs0z8pt4UHlWLlRFUyjZ2lY1QspzTF5A0nftCjVXmy4tANGYIZWw7NkVUryvcah5+r2l073OUl49vmmRoU8YZ8OJxqlgtuYQgeBsQTLU3EBIReNQWbPsceiWPSKv2gsGQiqRISWWPcHcYrHOCX19fdi0aRMuv/zyue6KEf/w9GGMTtdw8MQ07nvuaOr3VGWYqzBXdkc5UuNhjhQnnVKb8ppJIcUIKQvRpK/rbdEhukKK2wF16IfXeaak1+11PCQciNUvreRNubKpaFTXySsj0aXathJqzg7FHet0vm72uULKMN+o9ytq5HJIVOrJ99a2r6A9rcnCrj+1mOhhVfYM17UphW2H1/HeIyKkLPEt6Sp75vdKXS/aK5vIS6NCylA9j/bDK7tKiy9DimPfvn34t//23+LRRx9N/Jy8tTOtEjE5OYnNmzfjk5/8JD760Y+mfn/PPfdgx44duPPOO3HllVfijjvuwLXXXouXX34Zq1aFZde2bNmCej39Zjz44INYu3btjPqzEDESfXhXdpcwMF6xKi90G9GIJSyNZ0OpicBkryP/ds5DoRkppGyWPSKvclxJZCeDaJBYrix7BoVUIyZXgFj+a1Kn6JOMTQIMaCRThmVPnZD4XqymspJX8YREc62NZKKBP5w46Gdm8BBGT/uZjpmEmnOSKasiR9KyF/U3QMpzz2Wwvp9tXSS1W2cpr15fU3/5QA7YZbhAUjZM97cp94vfG+0uQqoaK6R0BUPiuaQIKXtVjP2Dk/jT776Gf/Xe83DJul5ru4WI2Z5DBIKzBXwBbgw1T1XZC3/Ox1i7ZS+93OMPQaXaBYIzjcU+J2zfvh3bt2/H2NgYenvn33z/3KER9fUT+4fwiSvPTfxe5eMw0runLVmdjitGSrqahO0bTBlS9HUlRTSF36t1fYZCivYVusIr0VZTPQEhKVFr1FN7C13J5FJIpdtmH4rT8YIzQ4odXquDbtseRF3VSx1cJB6fPUzO8xhxlL5mOkNKfw68bfK9tR2Km8gj23X1bKawbXqvQHuUNu1gxrZXKNfi/Y+rnU6g0vWrjWYiP0237JnCz4l86i4VVPyHKdScCKnlXUW153HtJxYKZkxI3Xjjjcjn8/jGN76Bc845xxlE2Aq2bduGbdu2WX9/++2346abbsKNN94IALjzzjtx33334a677sJnP/tZAMCePXtOqQ8LHXTDvmV5JwbGKxieMt+Y09rAp4ehE2LGOw4rN1WCoMmg4HsIMkLN64w8clXko3b0IXZ92BraxNHusuxpMlwavJwDPDzF+tcygsoBe1nQuC3owkaPs6kPfmIysJFM8WSbGWrOiMGsSn+KZCpk500p8qqQS9hAgiCZbxJnPZGSKfy5TSk2qSpExdc1kYNKjhsN4i7pciWhkLLfizUDcWVqx0mzkuPUa5KpuKZrDUxWG2g0A+PG8398Yy++9dJxPLi3Hz+45cedJ3oLDbM9hwgEZwuyQs3TGVLpzZNur6C2xgwp9odUQEQgONOQOWF+g5eYv3fPEVzztlX48Oa16n3Sw8qBeO1O+VK0ngzdBElFEydwlEODjU1Fy3q9wda+QJz3kyaukvuKH71wBXrbC2rvVG801VpQr7JHz2u8XE8cNAZBnDEa7ytcCilEz19TSDlyoagLLqcKnwPiMO9Us1RblzuBr8cTzgsHyUQHxq7r6moiW0U+E3mkyCvdWqcRPYm2QbpdSVtL20LNbQopW9aUbkMNn0dT7Usr2t7HdO/TwXpPO8+QSu9nqVr3CqaQOhssezMmpPbs2YPdu3fjbW972+noTwLVahW7d+/GLbfcon7m+z62bt2Kxx577LQ/PkelUkGlEtvGxsbGzujjuzAaEUsbV3TgiTdOWCvokcw/53toNAMMW6rxxZ5gz6kkos15Pucr5t2ukIonmZiQylZIdRkqEai2WqAhhcRNmkLN9fBDhyebq5NokgoCGF9TThzxUHNdGcTbevAyq+wlQs0zSCZThlRWJlOB5zeZ37JklT2metIRBEFiUOYbqWYQwGc1oKrWExKLQorymUp568QBsIE88l27yCv+GijLnuFF4Kc5rjLB6uQjzxVS6Xb0XFb3lPDG0BSAcLFmynF7Yv8JAGHO1JNvnMD7LlyRarNQcSbnEIFgIYHb5nIGDlpZ9mrh6as64+BTDbNXBEGgNlH6yTCQJL1WCCElmCPInDC/0T9WTnz/6b/dg562Aq55W+hS0cPKAaQ2ynw96WkEDleJ1DXFDeCw7OnV8yg6RFdIafuKpZ1F7P4vW3Hhf/4mgDDfc1lnOPbqVfYAsCiG+Lp8GRqHj7sypMyWPVMAOs96ArKUV/QVCzXPzJByK5k46eJ73HmRvqb+frmuaws1T9vw0veTtW09Xn/HbdPPQyeECFaFlJYhZYtv0UP4k4RUQ83ZtMco5rV7hb3/SiHVVkBPe/j5MSmkhiIX1IquUor4XciY8bH7pk2bMDg4eDr6ksLg4CAajQZWr16d+Pnq1atx7Nixlq+zdetWfPzjH8f999+P9evXJ8gs1+84brvtNvT29qp/GzZsOLkndRpAN+x5yzsBhB9Yk++UFqZrekJvt10hRYN3rJAyl0eNSSZF8GQopHhlM9Pmvq5NBjEhlf6w6XYFCp42WfbqGiFFfmNzlb34unlW6cOkkopPPUJFmWprIEI40ZVlVUsopNRjmdvySTkrfDzO3XJXwwOSJwouNRWfJEt5Hx4bVfSnl6pckUGKqXymYt4ZVE4VJGlwzjuILk400XtmCivnfVXVFptB6j3jpz7tjlBzIkqXdBQVwWX6nA5PVhOnHc8dGk21Wcg4k3OIQLCQsIrZ5jykx3KucpquNdTYzdvyw4NKvanmElOoOa9kJZY9wVxB5oT5gdcHJlIb4Eq9YYwB2flSv/paV5MA8Xp8XFNIcbW3aVPurLJnzZDyE+0e3NuPv/zBm2p81J0XQHjYTO25q0IvrATAmA2aDP62E2xxe2ob/t/mrJyXVL46FVKIrYCtVu/mFfmMCin2w4TzwnDNqvZ+uVwa8Vo52TYdKJ62gJpIJsB875n2Nqasqdaum7Tspdb/2iF7PhdXD+d7o3ojea8aLXvT8cG6CjV3ZEiFCqmw3dmgkJoxIfX7v//7+MxnPoPvfOc7GBoawtjYWOLffMTDDz+MgYEBTE1N4dChQ7jqqqta+h3HLbfcgtHRUfXv4MGDZ6r7meAZUt3RJGCaQOgDdk5vSEjZrH115oktGmSFhFgh5akKC6aNPZAkhAqOXCo1weQ0QqpaTxEnejWMdkeouS7DdXuy4wG+mMsgmVhbTl6ZFDeJ04kWwwfDkwx15G0En5Sz7X3x5OHyhQPmXKhsQiqXUkhxpBRSGVbASWWHyznbfvvl4wCAC1d1hddVr2/6mpxAUuSoI0OKk6imtglCymHZm2LPRc9X4HhjaDLx/aHhqfSTWMBYiHPIxo0b8a53vQtbtmzBNddcM9fdEZyl4ISUaSHKT4Gnqo2UtQOIyalmECSIcVOoObegUF6jQHCmsRDnhLMNzxwYxtbbv4t/c1eyaNRAZA8q5nz8559+u/r5y8fG1ddGhZSeIaXZtXj7ZIZUWiGVGVYeNeXrtN+693n84PVQaU6HttwGCMQV9LjyKY4C4Za9tBWPr5vpELbNoKSK28dkUPjYrrbRdZFNdPHDa3odWimWFFfvzlBIZVTvrjOnDPUjfCzHYXAuGdmhX9ukkIrtiDp5ZVBTmSx7FoWUHrXy/OFR7LhnD54/HB4E0/uUsyikuOOCEEfdpK2otFc2h5qTQiq27JkUUgPj4f4+mSG18AmpGVv2tm7dCgD48R//8cTPT0f44IoVK5DL5dDf35/4eX9/P9asWTNrj9MKSqUSSqW5O0F8pX8c3903gOsv34BurWwl3bBL2gtY0lnAeKVuJJuUQioipEw3OpA8oXBlLcVWMV/dSFXL+8+JEFeGlC6XpVOWZhD2nwez6icOZNkzZkhp1y22dJLhJQaZWr0JaLcAPQNu2bM9N36abSsharpuqxlSPvN62xRHVTbZZ8l71aRQyMUqLQfB43nh+8tvFf3SiryhyYsmUGuoeVzBrt6oRX1IS2Z/8PoQAODntqwD4K5iyO2FrtB6eg9D4ipJTJbYyFlhMmQ944VjUlWiyaO7rYDBiapxEtHl8cdGy6k2Cxlncg6ZTTz66KPo6uqa624IzmLk2TgzYpjDfd9TGXTTjJDinj0ukp2qxaoEU1Ydz6comDyCAsEZwEKdE84mfPul42gGwLMHRzBerql9Bs+1uekD5+OqC5bjZ7/4CF49PqH+lh9eEvQCDGo9xcYZZVtj63A9kwiwFyHiexD98QHg9cEJXHXBcuXm0B0EbYUcxsr1BNHEIzD0fk6fpEKK503FCilXlb34QBrIypAK//cw02xau5pKP8B3qZ5qmg3PtV9JZ0jxw+u4Op4xQyqjyl5bhprKdI8CaXHAZ772HPYejUnwkqaQygo1p8eYqjY0K2qcucz7wd/TMfVZi0PNx6ZrqQiYoUmmkFrMoebf/va3T0c/jCgWi7jsssuwc+dOfOQjHwEANJtN7Ny5EzfffPMZ6wdHX18f+vr6zvgE+f/97R68eHQMo9M1/MZPXpz43ehUXCJzWUcRB09MKwsTR1m37FkJqZi0cA2EPNScPtRZVfbyOZ+pqRwKKcqFYjaDyUqSkOIV7gC3QormMRpUXCcZao0ftafMLZOii5965JllzzQh8L1DFhHDlVcuuSy/Rj6jPCugVdnLqPTHTx6IsDGXco0Hei4FBgwKKTUh0QmJXTYMxFbNjmJOeaR1kml4sopmEE5C5y3rAMAnD7vyqciUT3XDe8vJMxcx2aplTymkijlnWP9AVFGykPNQawQ4Pl5JtVnIOJNziECwUDFssdR3lkJCaqpWj+cf9vv4NDseh0zqKMB+yCEQnEks9jlhrvYVHDx79Y3BKbxzfS+AWOFEboXzV4bRIMNTNYyVa+hpK7AKYvE4o2ck1Q1WPJNCSu0r2JqL/sZu2UseNBMODU9H7ZBol+pjPU00cX7etK5LElLh/x0s448HpZvypkh1VW8GibbhtcP/W6nep2dTAa4oEGrrXnsrUo6u6SCZaiy6BbBXzuP9NxNSAejo25Uhpa//K5q1jrfl+xUVQaJZ9vQoEE5GhdedWah5/Dc19XybzUC9HvQ+lwrpe9+kkGoG4WeQC1HIsreyu6hcUROVujG7eCFhxoTUBz/4wVntwMTEBF599VX1/f79+7Fnzx4sW7YM5557Lnbs2IEbbrgB73nPe3DFFVfgjjvuwOTkpKq6d6YxF+VZR6aqeDH6kDz4Qn+akCKFVEcRS6NgvhOGxSwNpq0qpPI5dzYUDzWnD7VJGQTw7CIPRUeGlH464XlhsHq13kwRQnoZVVJTmQmpZuK6LkIgJrrC7wu5iJBy5U0hDhUPAjPBwYMKXQoeva3+fFPPjZ1mxHYNY1NWZY+FmlvacqKp0WxY2+pSWD4e6n2OT1M81WfXc4sJqTx8P7yn9ZeWAv6WdhTVZNiKZa+Qi0nEqqPKXiHyhBMxqd+3XLKrJOAG5Z1SSJXyTpktVdC4YGUXXjo2bv2cLlTM9hyya9cufP7zn8fu3btx9OhRfP3rX1cHGIS+vj58/vOfx7Fjx7B582Z88YtfxBVXXNHyY3iehw9+8IPwfR+/9mu/hl/8xV+c1ecgEOhYFR0c6aDN0WSlwZS08e/jA4xAHULZCKl/cfm5+MZzR/Evrzh3djotEJwEZntOWGiYi32FjgF28EUKDCAOSyYlRkcxj65SHhOVOgbHK+hpKxjVJyVtLaSq5xmsTdV6U22mKfYjGWpuJmT06nm6ypMO5vX1PyG24sXXbRoIHmWvq/N28XWobQ+rkjperqv9mElNxcm7cr2JLtZ3rmQCzGoavR+e53YGAPywPT68doWat6KQUvnAGZXzgHTeVDJvNq1mSlbZM1/XRIaayCubZS8rPoXee1uGrctiSs+Dx3zkVfh5mgydivYIXaU8Svmwune10cRYWSOkyLLXWVI/N7mIFhpm3PNdu3Y5f/+BD3xgRtd76qmnEpkcO3bsAADccMMNuPvuu3H99ddjYGAAt956K44dO4YtW7bggQceSAWdn83Y/eaw+lrfnAZBoJROve0FLI2q9OgKKV5tZ3W00B2zbHRpkC/mfDQK4dcVg6yUn05klSXlbZ0ZUobJoESEVKpyBhJt6XRiumaw7EVtacB2BcbxanhA+DqUa2lCjJ5b2Ifw+4IfDiA1hwyWyCsgO3zQ9+IBM7PKnhdPMjY5FSdPXEHlABvACzk16BszpLTTDF2Ga3p8/YTENBk0m4E6tesq5dV7p09IlJdGVVIAFmpuuG6cY5VT4YqmzK/Y802LHbNSzqSQKmcppEokh7cHFp6/svOsJKRmew6ZnJzE5s2b8clPfhIf/ehHU7+/5557sGPHDtx555248sorcccdd+Daa6/Fyy+/jFWrwipBW7ZsQb2eHjcefPBBrF27Fo888gjWrVuHo0ePYuvWrXjnO9+Jd73rXTPqp0DQCv7u31+FP9v1Oj73oU3G33cU4uIdpoMLQhDEhzMdhkBzAHjfhcvx+H/68UR2lUBwpjHbc4Jg5uCEFLcLj2sKKSDMq52o1DEwXsH5K7uYosWlkDJs3BmJUKk30VbIqc37zELN47U6B63vdYeE3sekZS/8P1Flz7CuS1bChnpuHcUcpqoNjE7XGCEVPyaRMJy8K9caideXOyQSz9+0B2H2PtqzWGpLGbNpTcv/lDDA8JwJ6uBWI69MWxtqS889x15jfmljhpRlr0Dr4x5G2Jj6oELNNRUd3WY2Eo9IS1W5OyPUPHyMpAOHCzXoHjXlTFFmbnsxrETZ017A4EQFo1M1rFvSHrap1NVefkV3CW0FXx2Wj5fripA6PDKN3/vmS/hXV56LK89fbnxu8w0zJqSuvvrq1M/4YmimktOrr77aahki3HzzzXNm0ZsPeOTVuPrI8fFyQt45WW2oD+iSDkZIafkTtUYsGSSFlK3KHg36+ZyHYtM+ECaUVI7wc/4Bzvt+SxlSeU3WO460L7upkUF0CkxKlERbbYB1KVR05VVoL6s7/dtEGuVzHqoNi0Iq+j8Rap4VPsjqJ9k+JjTR53It5E0xea06ITHZC4MgIUWl0wmzQipZvcJPTDLuwdt1SjPFFgndbXlrNQxSUXWyCd2Vj8UJJFJIGTOktLyrgu+jjGbqvqXctBILNTdmSFVjtRfdf2OG+28osuxdsLIralNDsxkkKsQsZMz2HLJt2zZs27bN+vvbb78dN910k1LV3nnnnbjvvvtw11134bOf/SyAsOy4C+vWhdlk55xzDn76p38aTz/9tJWQqlQqqFTixb2E8gpmgivesgxXvGWZ9fcdpTgrMWCHHASPLcanDfka0NqutiixBIIzhdmeEwQzx8AEJ6TivYFSSJXiDf/KrhL2D06qv4kVLQ6ViMOyF7aLCCm1/2AKKQMhww+6VbEijWwgssKukEpHd+h7Bf68OHEVsCU+X/MuaS8oQkpd06CQ8jwPpbyPSr2ZypEKtLYxeWHPvPXgZToO+AGGi2RqaHsrV/XumhZq3lKGlAo1Z5/xRN5TWvXkGUimIAiUG2hpJyek0n0whZ8DyVBz08E49YH2pLYYkiTRmrz3+X6QyFOTZU9l5kakUk97HoMTlYRwgvYHbQUfnRFx1VXKY3S6hvFyHat7wna/c99e3P/DY3h4bz9++F9/MvF5mq+YcQ+Hh4cT/44fP44HHngAl19+OR588MHT0cd5hb6+PmzatAmXX375GXvM770SE1LNILYoAbHKqZDz0FbIYVn0oTwxmcyd4RtkypAaK6cr1wFJD7dL+RSTR5xkMhBSbAOfZ6HmJtJGDx8HmLRRy3vSZa3EDJvye9R1fU0hZVCf6KfObrlsckPgsi7y/ioG33KSwQMQsyrR8Qoi1GcbxVs3hJqbLpusnMfbGhRSmhSWz/k2hRTdAy6lGC2E8r4XkWJmkqnaSE80qtqISSHFCSmHfZRX2QNiSbLeloefu0LNpyqxWkEPDOXgCikgfH8mDEH9QDjhZRH68w1ncg6pVqvYvXu3Cs0FAN/3sXXrVjz22GMtXWNychLj42FFoYmJCXzrW9/CO97xDmv72267Db29verfhg0bTu1JCAQMHSwrUd+4AGAHGHGVvXaLQkogmA9Y7PuK+QDuquAH2hOVONeGsDJSVJKqyrTZ1xVSJmsTPxglsoU7NAjxPsRc5S6vDpqTBZ+oaAOPteAwKqSMVfbcoeZc6dNjqI6WzJAyPb6+t0nuK4oOV0m8X3Gve3mffQ/OvYJOyrlIJj3Um+8rUgfSmkPCFu9RMaiZTAfoTx8YUdckMQbvdzNBcpkPZ3ie74RhPb6koxBd03x47SJa9Xuf903F4bB7aqoaZ+YCUDlSfJ9KJPCKrpJ6D7tYjhThuUOjAMJ79tHXhlLPaz5ixgopk7/5J37iJ1AsFrFjxw7s3r17Vjo2X3Gmvd6j07VENQsgtPnQqWYsyQ/fyt7oQ6nbfGjAzfkeVnSFk0mjGaTC0gDzxGFSPilmPMOyp/tnySblypDi4YOm4EPelj6U6uTYZNnTw9KjtpMG8kpXXhUcpIVOXhELbQw155a9rCp7CWlt9DNjy/j0J0F0Wa7LPdwuFVGSkMo5lUwVTUnkyr3igeLU57Bduq+0EOos5cPcLQt5RYN+MUFI2a2AcR/iDCldhguwvKvourZgTR5+3s5CLXVVU4URZ64MMwozXtPTrk7QRqdqCUkyALwxOImf/qPv4Yq3LMPdN7aehzTXOJNzyODgIBqNRsrivXr1arz00kstXaO/vx/XXXcdgPCk/qabbnIeSNxyyy3Keg6ECikhpQSzhfZCnJWo5mi2sPfYfEH2dVuGlEAwH7DY9xVzDR79AdgUUvF2Ma4AFv6uYlBi6hlSylHB1kSe5yGfCyM5KOaiamhXyqX3FzxmgdZZRB4QYoVURLDoVfYMmZ8mhZRJ+W6y7AExiZClkAJClcvodLrSXlPbVyg1jaEIE+0MWln/K5cG3O6EunoNksSROUMqScgkHRKMzGoGLMM23ZYvwU0KKZP665e/+pT6mtvSTWqqVhRSpuxXuu9tlkFTqLkeQs8rEVLfdNVfoxkoYpKeC635+b1EB9bLu2Kbvb6faDYDHGXVub/5/FF84K0rU89tvmHW0q9Wr16Nl19+ebYuJ4jwUhRmvm5JO3wfOHhiGqOsVDPPpQFCuSiQLhlNJ6VtUc4NBYWPTtcMhBQnLcLruqrshUHl4YfruUMj+Lm+7+OX338+fuZd5wAAGlwh5fsqJO63/vEF/NQl56jTFiCtZALA7IBuy16Ho8KZfurR5qxaEf6vMqRaUEjRdWOFlPskI7PKHqit56xwASQD42MZrrGp0cdvJpkaqq+FnGcc4FVbOs0oJE8zmoEh1FzPkHJYFydYwF94TXMfYoUUn7zsxKBJIdVoBqkKFRSuqSx7FhUgrxzSrmUicGUCPfdCgpBKk6d0ytHdlkdPewED4xWMTtegUxr3/fAopqoNfOflgUSZ5oWK+TqHnH/++Xj22Wdbbl8qlVAqSSaP4PSgk1n2aBzh2yyfMVLT1XDMEYWUYCFivs4JZxvGK/XEWomTUypDiimkaNyhQ8M4b9SukKL9gm6rKxIhVdeyplg7k2WPuwto3d3brimkyhohlfMSv1fKp2paIcUdTkZrH1vP83VjFiHFyStTlT/AkCHlKC6VCDXPyKbllcljl0a6bWyFjK6tiiUZDm6byT1F0iERwI/+lr93emQH7xvA8p4MlfOou7VGU7mFrn3H6sR7YLTsqSp79lBznRgE4vc2Z9mr6AoxIG1XrStbY9xH5RSKnhAnOyl+RCmk2D5BVdjrihVh6vMYtRsr1xKf5//zxEEMTVRx0wfOx+Ub7XEAc40ZE1LPPfdc4vsgCHD06FH83u/9HrZs2TJb/Vo0ePbgCH7n/hfxH3/yYmNuBJWgfPs5PTgyMg1gOqGqmNIk+XRCkFJIaXLFnrY8Bieqxg1xfJLhqwHJbdnz1AdwstrAswdHsP1vnsbPvOtnwutFMwcNmMvZB+nPH9mPz257m/qekyuEkjaxEVKWvejk2JQhpXvNTVJddV114hB+rwixjMkASA8ypusm1D7WDKlYTeWy1gHsRCfnKaLL1liRiDlPNTGTTDHr73nuyct08uB7HppBkOqGrpCyBZUD8eBKg60tQ8ok780ZJqS4v0TO5lDw47+pN4OE7Fa37BUVIWWXIScqp9QaSUKKPfdCW3gtk0KKn0h2l/IYGK8kpLiEA0NT6uv+scqCIaTO5ByyYsUK5HI59Pf3J37e39+PNWvWzOpjCQRnAi1b9hDEKlMhpATzGLKvmFuMagfYfF8waQg11y1CFWOouaaQqqfX9kC8Sae1qR6SDZgPhblCitbTepU9eh5K8aMrpAw5PqbYkHbDfiEI0u0AGyEV/14v2BRe1723KVpiS5L9cGenAjGJ53meU/VE62Z6vVwujTjzi+x9btVT+HySkR22tm3sftIPr8kumvc9/MkvXpbok8uyZw01ZwolE+i+TYeaB4nnBHCiMbqnmXiDUGBummYzwFT0WfK9uI897eHnjN9LlCG1gimk6PNI5DEVeirlfZTyPsbKdTy4tx+vDkzgW79xtfU5zjVmTEht2bIFnuelNpDvfe97cdddd81axxYL/su9z+OHh0fxW/c+j3/+9Q+kfr/3SEhIbVrbozavnC1VCqnohlzSHpI9ukJKL43Zzha1OuqGD5jO4ANJ4kqfCEzXo80//9CnKucZ5LIlw+kIwNRJUdt2VWWvkbJLNbVTj1ZCAmllXzDIhQl6lT01uWZ5vR3V5Xhbn4UP0uPpFZX4ZBufZJiuGSTsmPS+zCQXymXZ44uRcGIM0gop7d6ykUxAfPqmJLMWEs+UIWUq5VquNfCFf34Z+/pDC2ypkEucWNQbAfjhSZUpmgC7QoqTbLlILVhtNDFda2CpqV1UzhVIK6QSlQXb8upzPWXIkDo6Fktyj4+XceGqrlSb+YgzOYcUi0Vcdtll2LlzJz7ykY8AAJrNJnbu3LmoC2UIFi64ZU8/SedfN4M4C2YJy9cQCOYbFvu+oq+vD319fXMW3j6sFTjiB2VcsU1QG+Bo/VI2hpprGVIsm5YjXl+H770pMqRoWIPztR0nmn7nukvw9Jsj+L9PH0KjGaDWaBr3FWF/00RTq6HmcZXvxCWNhBS/r3lzq0JKa2vbA/F+gIea27Jp6VAcSWu3Dt2p4jkOxZUNzzcrpAj8vTPFe+hrdSDtugj7ELY7HhFSq7pLqYI/JkeHqXIfwNwUQVohtfXtq1k72lPokR3h3xgVUo4Kk3zvUWs21bq/o5hX/TdlSA2yDCkCHUbTYTbN+6t6Srjp/efj1n98AQDw+sAkGs0g9TmYL5gxIbV///7E977vY+XKlWhrWxyVWmZ74vjh4VEAwMv948bfk0Jq0zk9eDH62qiQKiQVUiPTyQlG/4Dz0tE6uIebblyXQqrAquxx1BpNFHJ+Sp109cUr8Zc/eNPYT1P4oC5/JOiWPbIyAOEESblavK80+NjCBIH0yUfRQkQAmrWO9dsUas6rYZgIE+Nz8+2ebP25haHm1K/0dTmzX/B9NJuNRL849NMEV9aT6eSBb4qSbc2WvWaQJttosdOpWfbSCilDhpSXPs3468cP4MuPxONXiVn2gHBSaEda0USqqYIl+4wmJHr8tkJMSHHQCWEh51tDzScZ8dRVyqt7esKg+utnHnFesnm+Y7bnkImJCbz66quJ6+/ZswfLli3Dueeeix07duCGG27Ae97zHlxxxRW44447MDk5qaruCQQLCTQmTFbqiUOOGPHmgbJglgohJZjHWOz7ijOdTUsIggAP7e3HMXa4BSTXJeOGDKmutpNRSCUP+AgFpTxJKqRMVfZo/RgEQWJtx/cLv3jlefj5d6/H/336EIDwgLqeQUjx/U1MNHmpdtOG8HP9gFgRUlPZCilSAOn7ED0KxBTqTuCHEjZbmem5uUgmfc+mk0Ecap2cp7bJ/QqBH8jq9jpa/wPhYT69X1whpR/i62IMDtU2UWWP9ilJtTAPgqd98rnLOvDbH7kEW85dwtrR4+vPP002lTQC02TrS7gzGkEq0BwwF9+KM6TiOb1LiwChAgVLO4r4N1dtxAcuWomrv/AdAMDR0WmsX9qB+YgZE1LnnXfe6ejHgsHpnDh0VU+t0cQrkZrjHWt78ODedO5MHGoepfJHhFS5FpYS1aWD9AGPFVJp5UWdlfFUQc4GMoY+iDnfNxJSI1M1rOwusQkmvNaPvW0VfnLTajy4t19JCwmm8EGdbSboEwcfvKaqFkKK2hbMJBfAM6RCzCRDquDILootezzUPNVM64OX2GxwT3bqufnxQG86IdGrHVYbZsURkM4E8C3qJMDszbZZ/PQqey6ybVLLLsj55tfMXGUv/fg/eD1ZaaKtkEtNChw17bqFLMte9Pv2Yg5j5XqK7OUWQFuoOS3wCpENlhaBkwbLHl9E6p+j+YzZnkOeeuopXHPNNep7ChS/4YYbcPfdd+P666/HwMAAbr31Vhw7dgxbtmzBAw88kAo6FwgWAtQitVxj9vLkAh8I5xtSSvOS2ALBfMNi31fMFf5+9yF85muxXbKjmMNUtZHYY0wYLHvdZNmbiUJKOSWS69e4enFMSABh0RkCz5D60+++hj98eB9+/+ffBSBc6+mkUBg1Ea4py7WGWrfqdkFTwSRTlT3aS0xV0kqqlELKEJuSUEix9jpxEbdPtrUVduJteah5lvOCRdMa1/Q6IWU7YAaSThnqB8GkkCppCjmK96BrJwoqsftJVz2Zcsvia4b/BwlCytw+GWoetukq5VMh4HmrQqr1UPNkhlRyr097eU6wmdR2gwbLnvo8Rq4SUjySMnrjik6s7W3DkdEyhiaqZw8hJZg96JvMsXItIa0/OlJGtdFEKe9j/dJ2tRBNKKSia3REN2RXMa8Y57HpWkqSShNGRzHN+BNqbEJw2dV4HlFBCwsEwtPZld0lVlkhlml+5NJ1eHBvf2KAB9JKJiD94Sbodjnf99BeyGG61givyxxMsQQV0evgUEghvl74+C5CKvyfnj0NODUTI8Qkvq4qcGHTmLzik61LXpvz3V5vTioWcj58L3ztqTwrfxz9xCse4NPXNWdImdvrles48djQyDYlFc+w7OmqK96Wn5DoyqZS3ocfqcqCIG2z1Mkz22ehqj2n/z977x4nV1Hm/3/6PvdLMrkQkhDuEAIThCSgIAEiEBW5qYiLBnDxshNvURRWBS+roCgb5TfArisiu6IoK6hfEJEIghAhBMMCATQYIFySkNtM5tbX+v3RXXWeqlN1unume2Z65nm/XnllpqfmdJ2ec05VPfV5Po/Nb8A8d5epeR9RhYVCITU4mc+KwVRWG6R211BAqtIsXbrUunNHWblyJafoMRMCqYLePZC2Po+pN4icmJpmvwzDMA88v137fu6UBjy/da8yAwfsVfZKUUgliEJKCOFM2TMLAaXIhriEbgpf/bt8ddwbH3wRgF/1BOTnzIloGEPpHJLpnNpsNFO7bNkXtpS9joIa5c0+T4lu+jxJgjykzPm8ax2iPGRD/vM3UVkaMNLlDIFDvs/emikwZc/wkFJqKktrUyFkbqBLUpZ5er4vIVB7D7PCt9dOPzdzI1g7piV10eZLRdtShVSdJcglrwfTQ6okU3NjDUyPlz+GUHN8WhjJy3gKTtkzPd3kRtQUUnWytSGO13uGfOm54wm38Q9TdV7dPah9v9NYVL7Rk//5rLZ6hEIhzyMp5d1lA4UbqKFwEYfDIfVApBexStkr3IwNAR5SaTIgJCymfxKlpAqHfHm59NiZrP8BL9+/31BomdUd8n12pezl/6cP+PbCDbizX09hMh+wZkla/biFwaDwvcs7CKBVK/Lfy0HUVNvoxw0FVpcD7OaD9BgUWqLVM0C3tNMCUiHt7+FLg3Om7NnUVP6UPVd7M8gTIn9ns+1eY2fO5Tfl7VBYSsSStmbQRk4GpErKZVboBaR0ablEVeNTKXv2YK937iEv5zuV0fpo7kbKnTnT1NyU2O8ax4MMwzCVQ6bf7RlIWcdA6SMo4E1MOWWPYRiTF9/s074/dGYzgPx8Q85L5EK50WJqLjfUbHNAOR8TIr+mUKbmDg+pjKGQsnlI0XXI3wo2J6ZRuYRuDLoVUv6AkK3K3oyWfOroNjLvMrMjJEEeUmZbV3ElFWRS65WgquDesbU5vWWu7gWvPDWVbVfDp5AqvG7PvNCtLXSFlNfOFZDy1FcyICU9mfTz0Q3QhXXeL7GZu9uqgQOmqble/ItCK3JTzA3pfJ/069VTkZFxOhTS1hSDSiHlvXdrvTfWS3bslQEpf5U9eT/uMhRSgLc2NguejSc4IDWGbNquDwbSPV8iF50zWvKR0HrLQlcqjGjeaVuD39g8qUzNZVqROxWIRnzjEfeD0KuI57WjyH7KBTyV6npmzSUopGRQrEieNQDMbM0PHFt79AW7HFzlQyWwyp4xyTfz121tvZS9wgMm0G+KpOwVUUjRyhn0/aznFg4FynBpBcMQMUCnfZOYqidz0LC39a4BV3tz4kInE+ZgZ06EXGmAScPDibalQSYzaCOvK8+IPnjnw6WQSipFYbA/Ga2yJwcQIfJBKYkZkGpK2APH5vVdSyl7DMMMH5l+t3sg5VMJA1QhJTggxTCME3PNIQNSQnibxf2WVCJlJVBoYxZNyn/tzceGMlm1Dogb2RTmhq/p3Ql480XqlSmndmaQyXt/bx4m54FmQChhse6wVdmb2VqHSDiEgVS2UO3c72ErCVRImX10bIybz/Vg25DCsUO6AsyWfUGVV95awdfM9xmYnxvFVEjRz4NujKey/nk64AWaZFN1LRmBJrN6ny0zQmIrwmTL5Mi/v2dqnrRcx94xHQGpjOV6NSrD23ym6PfpjFDr5TqLQkpeS4OprCpqNr3F89drMjxpbd6RSlk9jtcKHJAqk+7ubsyfPx+LFi0a8bHWvbRL+36Xoep5o7DonFm48FRAiixglYeUJe+URlVVqfvCMRrUsSxV9nLeDRb0IKSm5tLQjiKPrQIh5GZUCikjIOapfbzXZKDD9LHyHpreayogZShIzAHJy93O+dREPrmsDERYK1zov+uSdQJ6oEvG24qZD+pho+AqFzSX3tZO/g1VedYAdZKSt0rlXZCpufKQIgEhh9+TfGC2GL5Qtj5IqXiz0db8zGwDja2tmR4qBzwlGTeVT8bOh9rJcwxIZsqez9ScDEp1sYgawPqoX4Mhj29M2BVS20yF1DgeZBiGqRx0w4mma0jCZAzwvCQ4ZY9hGI9MNufbpDtmbrual+wdykAIQTYGvYUytRIQQlg3BeORsJpDD6WzXrEkM2VP2lzIgJQlvckWdJBELHYhAAlIZbJe4R+jrc2f1l5lL4Ij920FADz6Yt6LVHnYGhEpW2U0m9ef1kdj85J6yGr9tHneWrxp8/1zr0E0U3NLGp5SlMm1QsCGtOmP5FJIqeJDFg8pwFvPqU1rU8nkUEjZA1L65nX+GrUrqjRTc4sXmiTq8AdOZ/3n5UvZswRZ88f01h42LyoakBJCqHVtQzyi1lAAMK05L1qRWVVyPUC9I+W8YfcAK6QmDF1dXdi4cSPWrVs34mP9sZC/Le9fM2VPPtDaG/MXUr3F92kwXfCQKpJ3au5gKFNzm4cUqQYWpA6SN6IsdW+iFFIktU/SGLcrpOQDjyqkXH2w5XBLaa0ZkDIHGRqFNgNNPtVTUP622VYFLYJzvSNk0WBLr6M7JJpCyjJ4ZLWAVP61IIVUzGI+aDZX8taora0pWXWn7JltpTeBTFmj47MZaOpzKaRK8JCS1xpVU5nXjy/Q5DQrl39bfeLktdMnY/LeGnKYmst2DZZ7YK9xzi5Tcy+PvDDI9I/fQYZhmMohdz33DmXUs0gz9S18OZjOqmceB6QYhqFQD7qj57bh+AOm4i37tWsVgFOk4hlVSMmv01mBgVRWBR7qNJV8SAv4ZIqoROT7pI2NUyA4IOVSSMn3HkxlraqnfBt/BojN1BwAlhwwBQDwREFI4ErDs9kxUBUTRRVXStvXQfLUSvKxNVL2bJvHmkLKnbGnKsmZCqmgDfFiHlJJS2obbS/bDln8yPJ90I+bsqSJqrbGhjj9+/oVWl6gSaXsWdIAbWKDTDan3kNL2TOKiaUtvmiArg60pf7J4Ka8z7YSkQod8w+c1ggA2LyjPx9oLsQSpjRO0pS9ZcuW4YADDqjU4SY8vUNpvLJrAACwfMFMAMAuQz4rAzpSceEpL7ybq7+g+qgnKXu2sqNDRoBB7nbYFFJSKRIlgSZbuVE6wNgGDM9Dyj/AUA8pGrRQah9rlT37Q5s+APdxpOyZgwx94Ph3JwrHLXwfNyTFtj7I43q7PcFyWdcugtcHFNqaHlL+tjQgpQYOfzMvSq+CTP73k5i7CeGAPtgMLT3JrN52r6l60lL27AEp5SFlMSoE7B5SnlEhPSf/NQz4d+jUcUtM2fOZmjv80Uz/rEZLpUt5jcv7w2VqLgeV/TvyA5EZzK5FeAxhmOK01sfUmCBT8rSUvcL/UpofDYc0Q2KGqRV4TKgeqnx8Yxx3/svb8LOPHuerANxPVOV007uRrDeoOttUtdDsAlsqHv1e/txmAG3b8Ja40smoLYdSSIX141hNzQvTUNMs/ah92wAAfy9YrXhVvvX3pXYMcsM/5wiIFfOQkg/zoEwV2ThkHN9a6ZsqpODOepCV5MzPwLYh7vOFDdk3xoNNzUnwyOH1ZJ5bOSl7VHRgqp80hZSlYrjE5iFF13k2U/Mhw7bGDJ7SzXCbSXt9LKK+3zOYVpkRM0i6HgDMaq1HXSyMdFbg1d2Daj0wtdEzPm+rlwopfa0ghMCvnnwVr+4e8J3zaFOxWco555yDHTt2VOpwE57tvfnBoLkuiv2m5heVpnx2yAxIKVNzsoA1UvEAf343QMuySlNzqc4I8JCKeoEmW7oaTRWzPRQ8Dym/6qku7hke5isJ5r83vZ4Ad8lTm4eUUkiZAanCr0aJ2kVWI0ymswCpQiQfMSq9rwSFlOyCHPBspuYgg4GZ620++G07Gfn3cyufokQhZU3ZM4z1XOVZAX+J1JDRNkKSRGwpc16JVv24XkAqZumD3l85GZLXswxeuVL2tCp7Sgac/1kuJ9TgcfwBU3HJCfurtm4prtCOWzRlr/BzsySydzy9nRds8iYj3u6QVFHl7wszZU+qJ+dNbcS6l3YrPxmz/HEtwWMIwxQnUihcsmcgTTxgvPtePgPkQrGtIV7TzwVm8sJjQvWQz46pTbq/HDVIlhthdbGwpu6IRsKoi+Wr2NHNMDNwJOdO6WzO6aMj51/y57bA1XAUUsrUPJOzFksCYC3a5AoeSS9f6WPlzdH9aYDRcAiZnEDfUAZNiahvnSAplrLnrUHcXr50HaQppGwBKfjXFfasi/z/ch4dZNlhC7aEQyFkhdDWIa6qeF5F7oJCylUNz1gr2FLczLbKKJ18vub7e2sFoa49W8qezUOKrotLMTU3r2O6GW5bx4RCIbQ2xPDm3iT2DKSUjc8+bXpAKhwOYZ/Wemze0Y9tvUNq7Kf3tsqcMlL2/t//vYFVv3gK0XAIm771Tt95jyYVC0h1dXVV6lCTAvlQm9accJaAlwojGYiypezZos42D5shw+dHtrFV2VPKp3A4MBhDvaZiYf8NPJTK+tpJTIWSfODazAe9Shj2Knua+WAhILV9r1FlT0b8C21DoRDqYhEMpLIjLLmqS2tdldho21Ao2Dsp39Y7N+oiFbSbEQ6HfA93iksybeuDv8peCW2ph5RlhySTzSlDSJnzHGTC6EvZC9vb2aS7ZhVDOnD8cMWxmmIg6vibpVS1DxmQKgwepkLKuAfV/Zy0B6Sk31pDwh8UNqt8NDnM/6VCal5BIZXNCfQOZWq6vDuPIQxTGu0NcewZSCvfSatCqjDx5HQ9plaZLGNCd3c3uru7kc3aVdwjIZcT+OPz23HsvHat6patfDwANCcKHkhDabWpLS02KE2JKIbSKfUMikVCPj+lOFGVm0ViJG5T85F6SHkqFa9ynqmQ0s2nAZJNYbzl9Ga5thiCEMLqYQvk1xaNiSh6BtPoS6YB1Dk9pGwKLTp3V1kaUW8z1NzAlq3zmRfesW3+tLR6t2prW1Ooz0uul2Tf/G0zxsYtkO9HFqUppFRF7CIKKTPY5vKEAvzZFNTjzAwgUlPzwCp7KuvCf07057RPvpQ9h0IqnXWfT1t9PiDVM5jG1oJHlMwEonQ0xbF5Rz+29g6poBNN2Wtr8FfsA4AHX3gTgN33eLQZUcreli1bsGXLlkr1ZVLxZmEwmNaUIDnbeuRy0AxIWYJIKUN1QdvTdDylpIpKhZQ7ZS9FdigCTc3VTRb2DUT0OLabUSqUAD3QlLPsZEg1lSu1jraVN6Bp8qwGD8OoEPCbT5u7GSpVy5qGJ9uGCn0pBDdsbeVgAD1VzV4Nw2urfbTWwSP/v6yeR3+fYgYGdW8qHTMNL9BvypYyZ8k5f/HNfiQzOTQlothvSoN63auyEZyyF9H64LUNVkjp55Pvp7lDJ3cpHAopI2XP7yGl34NNCf/9LITwHa9RpfbR+1T3enOZmstKG9OaEuo4tWhszmMIw5SP9IPYVZh40jm2HC9s5doZZrwzGceESnrTmnx/zd/xz7c+gc/evkF7XaXsmQEpTSHlr7Anka9JpZUtMEDXDy5jZ7WJ61svePM024a3JBLyrz1of5JBCikjICSIqsc8rjSIHkrn1Sw2D1tJk5q3FVL2ylBI0bm7maUB+Ndigmyg00BToEIK7iwG+rtybu7yhAX8mRfQju1vZ86/Q2quriukzHY+DymH6oi2VSl7AWoqW8pesIeU9/nTrAca6DKrN2acHlLete8K2FELHrPQGUUGlv++LZ9SGgrpVfbknME0NafnY64zRpuyA1KZTAZf+cpX0Nrainnz5mHevHlobW3Fl7/8ZaTT49csq1JUqsoeVUhJt/zeQf1iMD2kGixmydKAXFNIWYJNLlNzMxgD6DcP3eEwSTvyjCXyd2z526FQyJPUkj7Y0vtk7rppwG4GgwAvCtw7lNYCPTnLIGN7f9pWPoSDS656D3igmKm5NyrR8dVaaY/s0pjpciY03zsU0C6V0R+KmoeU0V0zDS8wvS/tf5DaDMhf2LYXAHDIjCYtMCi/9JmaGxXn6HVm26Wgg41UPcmBNVnYeQyFgvO4gbz3ypt7kz5FkwpIFUntsykeqUJLeniptNmkXyElBzSXqblUSLXUR1XRg1oJSE32MYRhRoqcaEp1QsiSsieVl/WW9AOGGU/wmFA9bnv8FQDAAy+8qc2bdhQCSR2+lD3P1FzOOxri/gW6VE1JTxrbYj+mKaTsCn1zw9dU5wP5jWQzkCVxrT+iZLGftawr8u+hK1no52Met4GoxPqTGatliETOAeUc1tVWeQ25FFJGlgbgX4fQity031aFFFnbKIGUdfNa38D30vssbS1/V1tQzO0hJfsm0+vsKiV9HVRmyl5gQMqz7FDHtFXZIx5SyUwWG7bsUetn85zM6o22SnyAtyZOZXPWSpWAXqRsWyFuMN0SkJJZJ0++shsAsE9LnXYNuxRSNEC13SgGNtqUvXX2yU9+Er/61a/wne98B8cffzwAYO3atfjqV7+KnTt34sYbb6x4J8cTXV1d6OrqQm9vL1pbW4d9HBmQmt5cR1J87AqpBkMhRYNISZtCypqypz/kXWZ6gH7zBHpIBaSA0eOYZUEldbEI+o2UOSUVJU1dVctsD3l58wqRX7RLxVTWiPgD3kPH/xkYKXsR92dg7pK41DZ622Az7/y55f8PIaQHjnwtvb+DZmoeoJAqzUNKD4wEGavbJhCeqaHXTqbrzSt4pkny/RBa22xOqOtXGvDTASkrhHp42RRS8tzkwJok3kymZFflcedy6E9mcOp1f0IynVV+ZPFIRG9HJgTCslNjC0jR68HzkPIrpIbUZ2mamuvXaK8KSMUwtTGOV3cP1kxAarKPIQwzUsxnDF1nyadbn1pMskKKGd/wmFAdhBBaVa1Xdg2oQijOlD1iai6D2raiCE2FdtJDyrbYp+sH1zogaiikTHsRdaxIGGlLSqNpVC6hG41q/m8GhAwPKRrEMbM+IuH8JvpgOluoLGhP7QOosj3/2dOq2RTbOozOg0NkXREK5ef1+fm2XOeQ/obk//n5tC3zAmQNIo9tW1MohVTIa5/vm7+1LcUyYlmHmBkPXr/1ti6FFJD/G2RzAjkhvACOZf0ZUQGp/PdB6X1UIeVKK6XHzOYEvvqbZ/Gzx7fgjCNmFtqbgUYzZc9+7XsKKeEMsLXUe9XxZIC4pc6fhi/v48c27wLg2XlIpEKqdyiDTDanhAmv7vLMzE311GhT9kzltttuw89//nMsX75cvXbUUUdhzpw5uOCCC3jgKBHdQ8rbkaAMGpHiOlvKnqxwYPOQClJIWSr2SbwSlSFiSiiQywn1kBZCaKbmNmTfXHJFW8qcKRXV++pSMnmvySohe4cy2D2QCgxIFT9uQRmjFFL+wVAYg1LUUNtobQv/hxByqn28PugyXPN1W1vd1Nw9cMi/qR5kMgNS7pQ9d9tghZR8mMqJjK8t+RyoIb9sr+eQe79vq7InLzX/DoktN9z7mz37eq8K7PxjRz8Ab9CwVVu0mRraUnBpEEsOdjaFVFLdp2ZaX0YzLVcKqbqYUkiZ1TPGKzyGMMzIqI/rcwGqkJJfmh6UDDNe4TGhsiQz2ULwIqcpal7a0a8CUrLK975t9drvtlhS9hpsAanCa7I6uC11imYXuBb7cZVVUEjZcihk4tGw2rzbp7VOpS+51h9y3pYiCikzeGRW8KbzSlsqYGMiisF0Fn3JjNXDViI/m16lkMq/bm6G2lL2qMm4bB4KhZCIhlW6oGprCV4pTyb/0s5aLMmadeHz3LJvdNN1IA222Ob/vYX5cLMRTPEbkLt9nKg3VVCVPXlu8u8enLLnKaRsfsdeOy/I9bPH8ynF9z671dqHOjNlz1HlkWbUuBRksjrenoG0WivIzWyKDEjJc+6c06b9XFbnFSKvtupoSiCXE3i1IBQAgJ7BsV1DlK3lTiQSmDdvnu/1/fffH/F43P8LjBXlIdWcUNFOV0DKTNlLZnJq8W6TAtrS8bxqfGGtTZBCKkYUUoC++KZBFJeUVh7HS9kzH8Z+hZJsSx/crvRCVzWMdos00TTpy79/sDeVbJkgxnMmplw20NTcCDKph6bN1NwY7AJNBYkcWe02+Jv5vLzoZ2y2NxV1paX3UQ8p2V/vyKZJudmWDl6yZHldLKyOG3EExWyDjVkRw/WwB6hZYQ5v9Az6fi4DkraUPTrZU1X2rAopL61SXoMy2NSnVcPUc9jlZyWEfv3Lwb21PoYpDbWVssdjCMOMDPlMVJtO5Pksn30yINVgmdgzzHiCx4TKkc0JvOsHf8aSb63BM6/1aD/bXNhkA/LBKcCvpKAbav1KIWVJ2ZMBqf4ADymSXSDnqeZ6QQYy5FxKzsfrjecW3eSd0+73IDWJWhRSZkDAl7JH5pW248pAwEBhgxCwB6RkdTOpQqPZERTbGojO8emxbZkadN4eMn7HnrLnra9KSdmTy0qXQoquiWig0Rbs8ipsG/N/5+axOxUvq5mal5KyZ0+HA/Tq3dLWxKaQcinxbO3N68rln6au/ayw+kEDxENqMK0CsjbVs1l574SDOoz3CqtjyfXVjr6ktoYxK/CNNmUHpFauXIlvfOMbSCa9KmbJZBLf/OY3sXLlyop2biIjczX1KntpbQE/aFx8dKdTpvaUWmUv6VJIWavsEVPziD0gRR355YP/vcfMBgC8/ZBpWvu0pSwo7YsuVw1QMjlS9szxQJm39Xs3V9YSvJLHTWbsCikZsCmlyp48rGd8F5yyBxBZaZGdDABk8LDsZlgMG227HjalmmugMa+XctL7aHv6MfQXkezSttt6888Xat7n8t2ypQyaefS2NhKv9KpQu24UGZC0pewFBaSoQaAcmOiApKrskXQ800OqIR5R14A8XiqTU5M2TSFVIwEpHkMYZmR4aulCyh55Psuv5M9s/i8MM57gMaFybN7Rj03b+9AzmMb/rn9V+9lLO/NBqP5kRlWi3n+qGZCyKKSsVfYKxVSkh5TFd8fLsPAUIObiXSnUCxNhl0KG+izR6mGugFScqE+8DWm9jZwPZnICmWxOm9vavNKlb1ZfMus0Kge8eevWwnySBoIodTE9cAEYqifaV9mWqqm0lL1Q4f/897bMCy9Lwx5Ik5iZKqrfxiHpxjud24bD/jm9F5ByKaTy3wcrpDyllrf2dRuQC3XMEkzNs1QhZWnnEF4A/iCS8gYrnEuqiH9aJptz9lHa0PQMpnw2PhQapK2PRXDsvHZfG7l5fd/GbfjQjx7D7zdu035O03vHgpJS9s4991zt+/vvvx+zZ89GZ2cnAOCpp55CKpXCqaeeWvkeTlB2aFX28n8GWfrRTGWrjxd8n8iNN5DKoiEetapDrKbmxoJcRuZtpubUfFALSGUcAanCzX/NuUdi1TsOwW+eeh0P/e1NFW3O5uw3oy0gZcv1diqkHJJZad4mB0qaCqYrpAqfgRHoEkYwKNDUPKf3QaV1WYNXeeTeRDgcAnLCbmoO/bjhUAg5IazKp6xNIWVpaFPTqeMa7T3ZdAnpfZYHqdohoWl4smKL8TD1Bi+v7eYd+UoR1LxPC4oVMUuMKtly8V0XKpu1pb1JhVRQyh4teWxLwbXJ1Wk6niRpKKRCoRAa41H0JQuTw2Y9FbCpLuqsLDme4DGEYSqH3Eyh1Vgl8jEpx/E6Dkgx4xAeE6rD81t71dfST0YiFVIyMNXeEENrgx4gsJma2zykZHBmV5CHFDE1d6UtUVsQwFur1BkBLqrGoT8zN7rN11PZHPFZNQIH5DipbE5fK1gCNioVK521FvyRzC4EB17Ymi/k4/ndGseLujflAX3ebVNIaTEnY1Pcbu8B1efAlD1jA79chZStKt9elbLn2pCWf/9gDynZNigNzzw3r8KfLXhVSNkT1EPK/zd1XWeAxdSceJMJIZTIw+8h5an4XH2UAakde1OqTaMlQDy73Uu9PXyfZuu5tjfGgR39uPb3LwAAHv77Du3nY62QKikgZZp3n3feedr3c+bMqVyPJgGZbE4ZAU5rTqAxHlW5nb1DaS8gldIjxeFwXrGUIrsNtoVugyWAY+Zlu0zNhRCeoqmwyI5FQipY9o83+7B/R6O6wQDvRo1GwpjVVu97cKaJ6Tal3pIypx6YJSikXJJZqZCSKXsZR0Aq4fwMoB03ZhkIvP7qwSv5cAxqqwYOi3eS77iF70sZPKLhEJG/+ppZjfVcxzX9y2SKoRA2U3Nbyp5FISV37B0pe/LvKYRA9wMvAgCOJnnQdIJAd3+s728o1YI9pDyFVJ+RNgt4f/+glD16/1GFVDYnEAmHvEp89D4NUEjR3aHGRKQQkMr3rZdUH4yEQyogNZ49pHgMYZjKYS7W6BCo+UkBaIixqTkz/uAxoTo894YXkHqt4A9zQEcj/rGjHxte2YOhdBYv7cj7R+1vpOsB3vyll6TsWavsGR5S1pQ9i4dUPGqkLan5Vw6ZrFeNr85yPAmdH5nm4+q4ZLGvMi98Ve684yTTukLKpryiqViuIBMAnHhwPl1q3Uu78PqeQXhTf1MhZUnZIz+na5sECYZ5balCSu+3ba0Asl4JStmjvrS032bTtGUdSPtiU0i1GAEpc/M6SCFFvaGC0vBcKXs2FZ/ym80JVbXeppAKUpS5UvaEyK8rMg5RBg2aumxFpKn568ROxOYLWReLYP4+Ldj4Ri8uPG4/az+lnY2LmlBI/fjHPwaQXyhu2bIF06ZNQ319fZHfmph0d3eju7sbWUu1h1LZO5RRD4H2hhjC4RCaEnkj7t7BDKY36zmyNJc6EQ0XSkTmf2a7iH3+EqCm5mHtmNKPSj7UszlPLSMXz4loBOlsBl//7bP4/bPb8M1zFuD0QnUBwP/glooSqRJyRYdtD2MvZc9rRxVStK+uAUEqpGTFANcg4zJ2p7JWIFghJZEPK5usVh3XCHRFyGfuaiulsqFC5YygfO98KVf/zoTZju5QuY7reUjpQaasEL5jm35T9Bxp22Ipe3Jse3nnAF7ZNYBYJIRPLD3Qa0dNzQuHzRsRFoI9NGXPCPYFekiRiQtNs5PI3ZKglD16XHp+fckMWutjPkN5wKGQsnyW+d2QpOqb3GmSA3t7DXhI8RjCMJXDnKxrKXvGeMgpe8x4hMeE6vD8G3t9r71j/gz89qnX8XrPEH7/7Fa8urtQ8TggILVnwKvqZfp+At48Z2+hjW1u5W3mCi3zwtYmkxVKHQP4n3GL503B4y/tQiIa1n7mUq7ElRVDzlmAKWJsuMupsVlMSB2TrAXM+TxlzpQGLNi3Bc+81ov/e7VHGce7q+zRTXl7xoTVQ4qm95FsCsBVLMnrs1dlz71WkHNu18Z1hvjShrQxyB8U6ysxZW8oIL2Otg2a0/vTAIubmmdywmkv43pN4q+y571PMpP1xACOtXImICDVVghISTuRGCk2ZnLLJYvwwta9Pv8oydRGe0Bq3tQGvLRzQPNdHgvK8pASQuCggw7Cq6++WrzxBKWrqwsbN27EunXrhn0MaUjcGI+oxXCLUZmLBmlo/raM8MqLN2lZ6CaUBNZ7cCWNcvKmH9VDf3sT9z7zhtUbSh7798/m801vffRl54MI8Dx35INTRYd9clm/kivI60n2VeKqXCEVI/Lmog/miOW4/lRAvQ+2gcBsayqkTF8qwB/oClI9mcG2EALakioXSm3kawWrHNUlxTUDmHpbrx0NnNJJS8jStk+m7JkBKSPAKKu/HNDRpIKLEnP3hwYJbR5SnkIqwENKtc1ZFVLyd2KWlD1bKmBdLKKuGRlESlqUVKrKXkA1TMD7vKQnTO9gYaepMFB5Cqmx3d0oBR5DGGbkmIa/esqesfHDASlmHMNjQuXYM5DCmue3+16f0VKHs4/eFwDwp7+9iZcLKXvzpvoDUgdMa0IsEsLW3iE8taUHgN9mAfDP46wpexaFlL/SmBc4kgqNWCTkU4F+fOkBOGRGE35yyWJtflTM1FxWCHe19VRPWWXBYUvXo+eYzOSsBZgoB01rApBPk3R5SCVINTYvQ8D7uaaQUhUB7QEpn0LKsn9OPW9tc3SJWYjKVVTJVTnRtq4YSOfnraa6R37W8vy9Alxub6icoClutoCU7K+eIWE3Nc//r6Xs2Y5Jqpib+FL2tICUu8JkjGRnKMWXw9Rc/k1sfm6S6c11OPHgac5rst0RkHprIYC1hyik3ugZxCs7B5zvVQ3KCkiFw2EcfPDB2LlzZ7X6MykwF5SAvzIXDZIktGCT9/AUjpzXGHkQS8yFLpXDvtEzhA/f/Dg+/j9P4vmte8lx9ICMZDCdtaZ/SeJGQEzlbxttbSl7WcvA0RD3FvhUBWIzQAf8pubUo4mOhU0ytcoIQnjqJHk+BVmlzUPKkOLSAcvE9KYKktaaCqkgbyi6+xMU5LJF4F3HHbIMCrZdD6ruoTvxtrKvnkLK3N3X+yzNNqe3JHznYBo2aqbiloCUV0q2MHhZBjmqkNprVUjJgJQe5AK8IKU5INFCBYA9GCgrtvRr5ud+/wTZTgb0zFz8KY356308K6QkPIYwzMiJGWkvNCJlzkXjAWasDDPW8JhQGZKZLM78//4MID/PoM+B6S0JLNp/CgDgr6/swY5Cmt0MyxyrtT6GY/ZrBwC8sC2/HqBrFYlZer7UgJQvZY+sV2RhlimNcd+i+pTDZuC+z56E4w6YWpKHFN1AdCmkaL+TGc/83JUG6J1PNjBlD8gHAQFgZ1/Sa2t8RHJ+nRNkvaapnmg/8211DymvsfKmDaqyl5PHpdkU/r6bBZBc6wTXOtDWXq1BjVRMMzAWrJCSbYWa09uCTN5aJf+95zflDnJls0Kdt7nmlRS71uj7y/4PprLquP4qe9IGxMt6MtMKzU15W3C4VORaweS4A6YCyKsi09kcHv77m3j3D/6MU697EBtf77X+TjUoKyAFANdccw0uu+wyPPPMM9Xoz6SgV6XceBdHi2GE7PlHhbWHY5w8PDMkvS4Rifja0MW6mVYVDnuyv0df9CYCz77eo76Wiibzhs/QEq6WUpjy5lQlL2XlAl+VvYCUPUP+OaM1P3Bu6/WqoJlV6yReyl5BIUUCc3R3Rn7mvUO6ssRUPcULn23aopASxqBklvvU28rzgXaOlsOqMUke14v4+9tSI/hQQODKVlbUpbxKWkrvWnc9CkGSaDikp+yFLW2VH4E9ZU82fbMQkJrWbAtI6XJkGcAJh/TBwkyHdJVUBbzr0qWQMj2kUraUPeO4TUaA2e71VppCSgVuC+3M54dM2esZTGvebuMVHkMYZmT4d6TJeGm0DSpXzTDjAR4TRs7jm3dhy658Kt5n33GIlrazb1s9jty3FUDe0Pz1grfUlEb/HAvwK6dabQGpuKmQsnhI0aCQyqqwp+ylibduMa+b+hIUUmoDkZiVBwak0qSdQ2FC119BKXuAF8TbO5TxbVzbzkOu+eicmR7btq6js3Zzozuoyl44RNdNtpQ9PcXMK7JnpOzl7AEc24a0WSjJ1dbze3JX2cvmSlNImeuEoJS9LFFduQJPrr+17bjUyzltBPgkNlNz87M0PbdMD95ysN1XUxrjqipk72AaP3z4H/jQjx7Hzv4U0lmBO9a/is07+rG1Z8jqd1xJyj6zD3/4wxgYGEBnZyfi8bgv53vXrl2O32QkvQVZXEu99/HLr+ViUyqkzMU7fXi61CHUhFsIgZzwAiRUxVIfiyCVyeHV3Z4s7x9v5qW8kbBXNcwMSO0dyiBbeGDZSmGaD05vd0I/jqeQsqTsGQ+EfVrqsWXXIF7bM4Rj9su/5pLByptOVgzQFFKkqRxkTSM3lVoX0s/fppBSg1LhwFSC62sLPRUwHDBwmEExmzpJIgePSDgUmNqnDPssCimzCzZzbduuh0xJa4hHtL9DUFu3h5RUSOWDjraAlK+cK1F90fePkrxwgHgzWUwNlTdUVmBv0p/2FpSy5yo9KydrUv2UtgyeNoWUWQ0T8J4B8pnglc/Nv053L/cOZZyy3PECjyEMMzLMRR0dAc05s03FzDDjCR4TRo6cu582fwb+ZelBaIhFVBWteVMb0dYQQ3Nd3qtWZkJMccwVZrXpn78tINVgKKRsShU1d87mSEVie8peJpfTFFJBlJKyR4vQZIwUNIryfc1kkRP5OZVL9UQ3nG3ZHJSWOrqms6upYpGw8rAaSGfQipgeZNLe27+2sHnFBmdeFNYVCDnT8AC/36xrnSDnv+YYY0sHTFo2WwFv81qu00rxkBKC+kK5VU8lpezJ988Fp+wB+esnWfi6PhZRc3KbCXpDPIrdA2kMpLK+AJ+Epqu6PKSikTCaE1GVvTEST0h6X9XFwmhviONzpx2qKvntGUzjjvV66vRf/rETNz+yGQDw3NfPsBqqV4qyA1KrV6+uQjcmFzaFlDR6k8EqGS03vSLoQ4kGSKgUkF7Q6azQzM2poVx9LIKewTRe3eW5928tGKfRG8eM2PanMkhl7LsdtC9eyp4/XQmwV/qTYiZzh2Lu1AY8/tIuvFwoWwtQvyn9/eXNtaugkMqRdjRoIYOAvoCUoXoKCkiZ1fBsed7ecfXvIwFBJr+peeF1X0tPYZX3kHI3TGX9OcreoKT/gm03w7brIVVPZpDJDKBlsjk10Pg9pKC1lZOSDsvunVKVqcHLfp/QQQawez1JaMpef9IfSJTXqTVlzzGIqN2Rwr1nq8ZnC8jaBm35tVRSeQHtmDpmQzyCgVQWvUPpcR+Q4jGEYUaGmfZCh0tzF9c2WWaY8QSPCSPn5YLfy35TGwAA7zpqFm548EV0zmlTc4IDOhrx1KteFkRHk32uMNV43RaQMud81pQ9oip3rQPU5mFWKNuB4gEpkrLnSq8iRWiCUvFkv4fSOeeGuNk2lQlOAwTImm4orZmJm9TH8kWjBiwKKdrctg6hAR+10W2ogyg0zTBwk9tIxZPdMNcJtkJJtC/y2FTR5CrIIY/d71hTAHYPqVJMzVMB83+lkMp5KXu2zB/6/gCwT2sd/lFYj9r8ruSG80AyYy1qBHifmzTVz/fRf6zWhlhFAlIzW+vU1xcsnourzjwCALC9kHm0qz/lK+y0may5bZ9fJSk7ILVixYpq9GNSYfOQanF4SJnyRhqhlxd5OKQ/lOlFk8rmVAAsEQ1rN4Q8NlVI7ezPx39p0MK8iXLCU7uYgwttLx8CnlzRFZAiD1jHQ16Wp92807s5XJLZdmJqLoRQg5F5zBYjCGgeV+qN5DnaTM1NNVVQyp6p6AqS1pqBriDlk1KrhULWoJFE/h00D6mw/uAG8gPDoEUhZdv1kNdyU52petLb9pOgqOk9YA4eSklV5388maoyOYibSkI6yAAIfNjTlD0avJWYCik6IVDHNSZFchdB9i9lqTCjrv/CMYQQnkKK3PdU+gsAvYZCCshfywOprPp7jGd4DGGYkVFOyh4HpJjxzmQfEypRvVsalc8tpNtNa07gsX89VWuzvxGQcgV+zGpcVoWUmb1hUZ/TFDdXlT2vqIxQNhvlKKRMKxDvdU8lb5p0a/0mm/wuX9rAto40LuoLLNc1tqaNiSh6hzJq7mmrnAfon6VCawut77b0KnXskNuoHIBPUWZ6MklcgRa/qbh3XTtT9gqnZW64UmSfszkRGGQyvXRtVcMl8nLMaabm9r8pXWfPaKEBKbtCCsivfdLOdNXCtR+gkALyIgtZGdNMlS2HAwtG+wAwd0qD+pp+1qlMDk2JKH7+0ePw7uv/rMUiXIHaSjH8MwMwNDSEVEo30m1paRlRhyYDvUbZdsC7IFTKnmOhTVPCXDJE+sBPZ3IkxUe/weVDXV7ogGeMHHUoriRSVWQ1NTeq0nnSVv048v2tVfaMC1/u+mzZ5QXPzGp4kimFlL10VqCfGMqZg4wcZM2AlGlWSGXHQghtkDDbBlbZUwG0wv+GVNXeVk/vCxo8aBUIW6qvze/ItvORzgr1+9SA0Bbs2lqIrEsDR7OtFzjKX4PRcMiZby774Erty7eV55dv6wrcRo3AVSk7JOms0Ko4qmMZHlKZnMBzb/Si66dPoqOQVuhSSA0U+peWCilLNcz8zkx+F095wpHPvV6prQpV9mwedPVRbO31+6GNd3gMYZjy8aXshejXhgKBU/aYGmIyjgldXV3o6upCb28vWltby/rde55+Azc++CKefi0faNqPLDTNZ8H+Hd6CNB4NW+dYgN9bqjRTc8tmH7E5cBlgR0lGRakeUnQe51JIyaBCOkuUT5aIkJ6Gl3+tmIdUKkPVVPY+0gwQV0VwwJvfSesGM0PD66c/IEU9nWTzQFNzsmZSpuaWvtMq6vl+ez+jayCXh6q5yUxFB+Z1Ys7pTUsKSoRsoKuqdEUUUjc++CJ+svZlAP7sDNo2k/WCXC7fRXr9ULWR7dpXCqlUxqc4M88nUyTARgPCI0mZq4tF8JllB+PPf9+B93TO0l6nKYiL5rXj4BlN2u+aWSjVoOyts/7+fqxcuRLTp09HY2Mj2tvbtX9McWwRYHnzqZQ9RyoSlYy6crIj4ZC60FPZnKrKZZqjyQt7J6nOtbNQfSPmUFxJ9hR2MmzSRlVlr0RT81d2Daib0bXrMKVR94Wibc1nfH08ovq8uz/lPKYXBDSq7MkvZJCpYGouhJ6uBehVKwAvYDhkS9lThw1p/bHvZOgDqEsyC3hBl1g47DQfBOwV4Wy54TQok9BS9vx92OYMSKkzAeANto2JqG9QprseQHBAikp2/7ZtLy78r8cA+B/SYfKgB4JNDeUuxWAqYw34me3S2Ryu+8Pf8I8d/Xh8c97bwh+Qiqpjyt8B9IGbDmLJTE6baNAAW70RuJUqqGZrUYTxH5DiMYRhRoaZsufXRXm40g8YZrzAY8LwSWdzKhgF+A3JKXOnet5QUy2V7CRUoZSIhq0pSeZmeaCHFK2yZyqkIt7GnLRrMFMGTajhtS1LA/CCCnReZfeQyrcbTGWLpuzRAEIxNVVdzHt/V5AJ8BQvcvPSzLqQ2BRSdL7qpey5My8EaRtUkVsppIwqe+Z7phyKInVsY/4di4R8nxddgwghnAIK2jaT9RR3tkJFst2egRS+fe/z6nVbkCtKTM1dJu1eW6/vdM1jCxIphVQy6+yrsgvJ5QJTENvqvfthJAopAPjMskNwxyfeiqlNetCZBr32m9qIRDSiVfQblwGpL3zhC/jjH/+IG2+8EYlEAv/1X/+Fr33ta5g1axZuvfXWavRxwiEDICVV2YvbdyFoyl7QIjulKaSMgJTlApPBKRqQst2cQQopz1Q9fxO6KgxI9c2GLXtw4Y/ygQXXroO8IfcM0oBU/n/brgc1NncNMvIG7EtmtOpkpjqJPmxtPlL5tvn/vb+PTSGlB9CCTc2ht5UqIst7q1z2SMgpraV9p39bVZWPHFnKW0Mh/dryBjrvmF5ASn+4mf3oK3gzWYNMRlvp4xS0m5HNCVx339/UuZvXshw4vAExyEMqpPXRdjyA7PZlcr5SqOZx/Sl7/pLH9HeG0lnNd4zec+axVIC53qKwrIGUPR5DGGZk+FP2vK/Z1JypNXhMGD5vPbBD+35WW52jJTCn3VNPBQV9aMqey7PGfN3qIaX8mTyVkLkOUCl7xEPKLHVvoimkHAF3Ve2bZGDYAk1yXdSXzBRNw6NV0YJUV/k+egopGggyUfO7pO4h5VdI5dvpHlJEIVVobxb+odBK3+r4tqyLrFcoCdC3O2jzdJkKqTqLkohmXiSJ0MIUUMh+A57NBeCqxpf//42eIe11u+oq/79uah4ckATyHlIS23k1xj2FlEsdKEUaSeJfZlVINXixArOYQKVoI+8xu72+8BoxQa+imbmk7IDUb3/7W9xwww0477zzEI1GceKJJ+LLX/4yvvWtb+GnP/1pNfo4ruju7sb8+fOxaNGiYR+jx1plT0/Zk9HyBuNmU1FyUmXPFjCiaXPymK6UPRsuk3SJXBybaXi0fdpI2TN3J2hU+fHNu9AzkPb8nowHt7whewbSKrCjdh0sV7G8uXYPpJw7GfThJIN2VP0jaDIXcwAAlJVJREFUW9PPl1ZYA/xpgzZZrcTzpoJ2jsWktYA/J5riKaRCgYOMLUdZyWVJd5Nk8KC7NDYTxDf35j3HpjfrkyD5W7Ktp5ByD0ilpOx5+fHA37btVa/LoKfZTqrzgvKz5YSmr1BhLxSy95NWbTH9xHwKKalqCjA1D5P0RToQmxUD5cRvyOchZVFY1oBCarKPIQwzUoJS9vym5hyQYsY3PCYMH7MasSuFDQDmkHS+oLQ4m2eUSSyie9La0pbihWfPAPHm9KXsFeZq6VxOrY3airw/fS9XwF0p30lAyvYsbE7k3+u6P/wNa1/cCcCteqJ9DfKlAjyF1FA656wIDhB7h5Rcg+RfDxmqV5upOZ31ymMHbXRTpVZQyp5aU0R01RWgz/9dWTrmnF55OFnWnHRtI+evoZBdCSTXTLQQkG3961L+2VJPqd+sy+tJQq81qpCyekglPIWUy/xd3qv0/rB5PtL7caQKKRf0PWRAiiolx6VCateuXTjggAMA5PO6ZTnWE044AQ899FBlezcO6erqwsaNG7Fu3bphH0Om5bXW+xVSUuEwJKvsOXYhaJW9IKlsOlueQkpCBzXb8WUlBKupuWH+7IoOmzfx1t4hp6m5HKBS2ZwaYEpRSO0eSHlV6HwlN8Mqii0HQlvVimgkrAI3pkLKDBAphVRQyp5hap7zN/XOLaz/jhmPEkIQjy4vL9xuai4DmDTI5D8PW4W9/PH9bdUEokF/0IeN/vapChHuXQ+lphoK8pDygnh0UPo7CU7l+6rv0ASamiuFVP5966IR6yBHU/b6jUoUZvsGQ9XkMvSkAUzXbpNZZc+Wgusy6B+PTPYxhGFGiq/KHlm8mKOha3LNMOMFHhNGxsdPOhAANF8YG9NImo5L2QPoSqKgogh0jhakkJLBFsCfQizXBdmccM4nTeh7ufpnW+zbnoWyeE7PYBrfvOc5AG5fqKhFIeU2QPeyJby1ir+dDDB46xq7FYnNn9amgpLTe/tGt/wqOGUvbQZQSF9oc5epuTmnd60pAH2uruwoElGrmi1sCUjZ1qAu722b6kpePlRE4ErZo39rmhVirbJHAo2uCpP2oKktZa8yHlJB6AqpBt9r4zIgdcABB2Dz5s0AgMMOOwy/+MUvAOR3ONra2irauYmKzZTYq8ige0iZFzpdwLqi04AeFNpreT/bsSnFUvbkgty2O0CNDAGikDKOYyq23tybdJZnbYhH1M0rfaRcpuaAblguVTK2dqYyTVNIkebWChfwB8Wo6bzp9+RL2QtQSLk8pMzBg+6CRMNe4My262FXSPkDXUpe6yzP6r2mrmVj50GOY7K/AwGlXOnnkM15Ff7sVfby/2dzAjv6PO8z08PKVEglLdXrJPK6lIGw+njEusMir+s9A2ltkgP4B+R66QugAlL2gTtBjC9dbVSVvZT0kPIrHqXa0vRDG4/wGMIwI4NT9piJBI8JI+OTpxyE772vE98+76jAduFwCAv2zRvEv/XAqSUdO0hJRdP2rFX2IvpmGmBTSMn1gheQKqbQonNTl0JJpkMVC17Y0rhcwTpVFS2X89Yqjra0inhQlT3P1Fyvsme2tSuk/McNrLIHopBybHIDXuXuqFJIeT/TFFJFU/akQsq+pqBt8/5R9mwe1bbQETkXThjZBBJbkHBmSx0O38dfHEG+P03tdI2Z9DOlpua2S7BeVdnLWKts034OpoKvURoYchUiGCl0s14qpOi9X61AGKXsgNTFF1+Mp556CgBw+eWXo7u7G3V1dfjsZz+Lyy67rOIdnIhYTYkNg235APeZmsc8D6kghVSsFIVU3P3nL5qyV3h42uTBsn0mJ5DTZJD6jUargQDAjr6kUguZKXuhUAit9bqxuXw4WHcdpFwylfWOaWloKlnoM5w+6Mwgm0T5TRU+BplLnBMWA3QjZc8M2uht9XOzBYMA/T0ikZA6uO2YtgCm503ltXcFQ21V9uS1bAY7/Qop6QtlK7vqHbef7KRZ25LBQ57PITOacN35C63tsoVrL6iChbwu9yqFVNjqrxC0U+gLSCm5tp6yZw7cNMCczNh3UaipeS4nlJJLS/mtIYUUjyEMMzLMcdeWWi0Jem4xzHiAx4SR0ZiI4rxjZpe0aLzu/QvxlXfPx0VvmxfY7sPH7wcA+OSpB7nflyjeg1TldF5nrgPk4j+Zzqp5eLGAVClV9uTrMhgSCYeswQvbAt8V5FIbnVnhzOaQUDWQ3BC1Ba8ajCrKpoethNo7KCxtA6vskSJM8jdsm9dm6porBc4VaDHXNrJQkk0hRZVaQRX2AG89JNcotrWprb8fXDIX9616uzVDQ57jUBGVEqB/9h1EbWhWpQSoQirrrLKnrtGMtMCxX6NaNlV9dQJSGZKqI72jaMpekIClUpR9Zp/97GfV18uWLcPzzz+P9evX46CDDsJRRwVH55k8UlWip+x5xnrZnJeO5DIOTBUJSNGHl81zBgiW4GkKKcvx5aLYFs2lr6WyOXWhmw/56S11+O77OvH5X+YnInuH0oEy2Ja6KHb0JdV7B6XsqZKbyUzgTka9oT6hgRnahUQ0gr3I+KrnmUqmhDYI5bTP0TQ2DKqyZ5aJVdXzjKa6QirkDFwBdoWUKa0FSL53ERkuALKjZX+UeKVc3TsftHqfVCnFI2Frep3cIaFKoN99+u2+60V+L//2yUAPqXxb+d51sQj+/fyFWPWLp3Dpift77QKUBq4qewNGlT3zflGKunQWonAMczCk12h/KqM+/xZLQLunBgJSPIYwzMgI8oXyKaRc+QsMM07gMWH0OGRGMw6Z0Vy03ZXvno8Lj9svsC3dNLT5A8l5kZxfRy0LbhkQoNW+XQoZ771Iyp7L78lIh3I9B23BD1dAQqYbZnKiaEU+On+VgTa7h5SupleqJ/N4MZupOXxt1dy3mIdUwOa16Y9VVCFlzH/NdYhUHwWamufcGRfmuQ2qNYp9DWv+SaY3J3yb5qptoevUKN01via1NmF88pSD8OdNO3DSodN8baWH1ADxkDKvK3ntDqa8gJSNVlJlT3qeVZozj5qFe57eilMOm65eG+2UvRGH2vbbbz/st99+lejLpCCdzakHD4100gdw31DGq7JnRJRpHrHLl4a+ls5SGaT+5w6KeNKHN33YTGmMY1d/Sp2DLSeb9iedzTlTkQDgvcfMxl/+sRN3rH8VfcmsCiDYAvJNRlpjUMqeKrlJSrnaAgoNMT1/mz6bbcbSNNeX9kG2pLtEyXRW330pq8qefm42JRNgKKRIQCr/dkI7h7RFIRXsIRWskMrlBKn4ZldIye4pI3/LoCD7mM0Fm5/T40olUH0sYn2IU18CwPP0sg1gKmWv8N6JWAQHTmvCr7veprVz5ZXbjuuqsmfeq3WkaqZ6H5/ayjsWDQTTgKFK+U2O/5Q9Ex5DGKY8TAUxfe6bZriskGJqDR4Txp5oJFw0cNVYoodUv8qocM/Vega9dYprYe69lzffsil8AG8Nk3UEAyS24JfT1Jz4iMo6Ou6KfGRjPiNtQ/zt5Nqi38jSMNc1CVKoShKYsmezAoF3bHV8ywdo+v7SMcXmIWV+tmYBJLmRb0vrlJ9JliikbF5P9LjqeA6FlPnZBRmBmwopW9BUkjTWf5877VB87rRDrW0b1d+VVNnzqQN11ZsruEoDQ65g3Ug5Y8FM3PHx4zF/lpfWSFP2bOq2SlPSO/zgBz/A0NBQ8YYFbrrpJuzdu7d4w0kITamhD8J4NKz+4L1DaVVlr964kbQqe1m7koW2y3tI2WWQQQEprXoGedh0FFKZpATXtutAF+6pTA7pTPCAIIM2fcl0oAzW89mSCil38IoayinVlaVhnRE4oA9b2gXTx0cim9MKF1ZpLajqCVp/rAOHZeeDHkNCg1mRkL4UMdumLIFBsxoG4O0UmA8gqmQCgD6HWsfWVqb22aTYqtKfEGpQtklr5TkC3k5KoyOfWqX2ZXL46yu7VaDGdq/IicOAIwjstXM/LpuMAJoZwHR7SHmDoQww+w3So6qNnNg1xKPaoKnuoXHqIcVjCMNUDnN8pEMbe0gxtQCPCbUPXVPYUt9iRkqSaWhue62UCn90jmbb0AVsFc3sz8EDpzVZftcVkCoopLLC81lytA2FQmpuKefetpb+lD375J/600psFfnCZIPXhK41vHiUWyElxxk6ptBjpJ0KKdk2//9QgEJKvocQQq2PnWqmkH48V8qeGZAKSmWV0205Vw+a55uChCCo8s0VuFOm5lLg4Xjv0UjZC4VCOHbeFG3tpQXCiqgWK0FJAanPfvazZQ0EX/jCF/Dmm28Ou1MTGZU+l/DvAigfmKG0ejj5U/YsHlIBpuZ5Dyl7uhSV4MUiIW1woQ9ZKkmdWsiVHQjY8QiHQ1551KxAMuvuJ+ANZP1EIWULHkmpoqeQ8vdPQktuBklrG2L6YKA9sMlDvt4ozSqx+VhRXyCKt5vhBa8A+8BhpgLKsdU0Spe5yeFQ/nimQoqifJRsHlKWlD1TomkOdHLwyAdTgw3Q1UBjeZjSAWmgmEJKpuwN2lV/5jH3DmVwzg2P4rk3elVfTcyJi23QBIIXdmZgzKeQytgHJK3KnmPQogop199G3tt7k+MzZY/HEIapHL6AlONrgKvsMeMTHhNqH6o8MdcqgDeXkfNA2xzKfJaVEpCiawnbhq7tvVyBo0NnNuO693di3lTP09bpS0VUV3Ie7ErZy7f3hAFAcDaH6WPr8pDSTc3z2BRSWUv5bupPJX/FVuU7Y2Tf0OPTT1ttchuftZlNkVSb3P5rxFNToaiHlFwXUlNzG+bH7FpP0L4GXaMSR+zTinzP/mTG93lKzBREV6og9bSdN7Wx9E6MEOohVS1lFqWkUJsQAqeeeiqi0dIic4ODgyPq1ETGW5j7/7jNdVFs35tE72BGXaAuD6lkJus0lAPsCilTBkmjxvWxCOpiEdU2ZqicJB3N+YCUTB1yPbjj0TAyhchwkNcV4C3m9w5lAoNH8iElg3o0H9p3TBJAygUEuUwlC33e0OaulD2vIobXOBELY29S38nQ2ha+V8bbAeVZ5WHl8GE+EDMq1zusH9zSVqV4FvGQSjpS9jwfq+KqJzMV0Oab5rX1zm2gmEKq0HV5DbgGGtcizJ6yp18XToVUwMLO3B2U/ZcDp0v9VEeKFMQi9vuknlx7MqXRfC7Ie2O8KqR4DGGYymEu4uh4aS5kgvymGGas4DGh9qEbcTa1uitFiWI+n1yqdwqdb5vFg5zvHTB/O/cts/HcG7344cObAQSk7MmN9lwucF0hiUVCGEx7AZkgU3OvEqE988NTSBEPKUv1vmjARjddV6gqexaFlPT9lZ+DttFNjuuyojAzJJQvbUDKXq6UKnsqZa9MhVSseMqeJMiaoxxsCilXhUl5Pq7rLhGN4MHPL0UkHBoVc3EJTdkrJVA8UkoaCa666qqyDnrWWWdhypQpw+rQRKcnQNnhVdpLB1TZ8x5KgabmtoCUcUHRhXdjIqodhz5g6AOw0VAKuXJe87+fLfQz+OEhH8hDhSpigEMhJVUgKmUv/7rd1NyvkLLd7GbKnk3SCugqFYqXk+29plRsPgN0edyQ1h+7qbkemPOOr7c1z432wxxobIo6tUuieUjZdzPcvlD+aznkbOtO2cvmBPqz9oCLRF4X8niuEqiuuYe9yp49SOQ/Zl75JydATYmoCsyaOeoNxn2ScpmaR70BSX7tq7JHPovdhQqTpgSZprOa3mHjAR5DGKZymGOeppDypeyxQooZf/CYUPvQOb1tzmbO+W3rBfP5VO6C2yGQ8gVJiqUu07mpS00V01L23JvnZnu5hrJNy8zsC7dCym9qLqHZHPI8MzbpE7zMC1ehpPzvSrFDIWVPO4L3C641qDn/d60pAG/+nckKtdHsSkuTU3VVZc8xtpnz/0CFlNG2Up6LqrBWKuN9nsabyc9XXh9BQdN5HaOnjJLQlL2aDUgxbl7a2Q8AmNbsLxPZQgIuUllhLjxpsCMoIEVzl3sdpuY02FUfj2g3N10Uz26vV1/7TQqD/XbS2ZzVu0g/J0/1pVL2Aj2kdFNzq4cUeRgEBaRUyp5USJFnOB0Q6g1ZrcRmrO5K2TMN0INMzT1pbf5/8wEv8RRSIa0dPYbEtpthSmsBampu7np4qXUArbAXUDkPUk3lVgZSE8bBIgopeX4yEOSq/OB6sNsmTX6FVIDZf8QLSM1qq8PftvUBsKTsGQFML9e+hBRc0yCd9GdXoRKNed4yMJfJCSQzuVHdRSkFHkMYpnL4Fkwh65f2tgwzDuAxofahTxbbnK0UhZTZxpWGZTKjJYFtvUm8Y/5068/N+X6xQINmWeJK2aOm5mpd4T6mbJ8KCEg1mlX2HP6xccu6wtvkJu8Zlmuv4MwLV9YF4KXsRQrHousb2t5lM0FVT4DnIWazw9DFE8EKKfk3lZ+VTXFl9hdwb3ADpXuN6ccv2kQVzOpPZlVwMBYNvh/Gm5q5o8mLU9A4QLWojjsWY+Xxzbtw5a+fBQDs2+b/46qUtMG0M2VPGWZn3Z4zgLeoHUpn1c1r3uR00doQj6iHD6DfKBcsnosXtu7FKYdNx7qXdgHwghuuyW6CPGSCvK5oP4bSOZXPHJSyJ1UgNB/aRA6OfcngNMB6w6ycRv+1wTbmfZ4UW/56nATYbMj+ymePPWVPD3S5djNknngkYlFImQEpSwDTVmnDVVLVTO/rGcwHR+wBKX2wC8oNpzncnqm5QyEVLk2y65K+NliNN0tL2cu3DavdnrlTGlVAalpzXGsn+5/M5CcuxRRS+aqZ+d8x8/Ej4RDi0TBSmRx29ScB+APVjfEoQqH8Z7h3KDPuAlIMw1QOv4cUjUiVtxBjGIYZDjQ4YptzlaJSMl8rNSB176ffjld3D+LI2a3Wn5fqISWhm6WuthGyiVxayl5xDynTb9TbaLd/LrqHlL7JTftu95DybE5cWReAp66KhfX1Bz0GAFWwym9qbiqk3AWD6BxYZRw4Mh/kGlJaUzgVUr6AlDvUYR4iKGXvtkuX4F9++iS+cdYCZxtJvcXmxQx+mYrB8aZmrotF0P3Bt+Clnf04Zr/2qr8fB6RGkcP38UqozrIEpOwpe/YqezTQE1Q5bGdBUQEEK6Qa4lEtmEEHkrpYBNecdxQA4KlX92jHcEWT5fuveX47tvUmnf2krw+li5ia13lBJr0aniVlj+w6eMf0v7cZkMo5jusyNVdBMfLhJaQvkDNlL/9/KSl7noeU/rrE9JDSdzL0tmmLubzNQ6p4yl4pCildTRUUkKIlYqW5vEtiq6rnpe1qItXOFZAKkAxLAqtPks/uuAOm4NnXezCztc5nNEgHwMF0toQqe8EB5oZ4BKlMDjv6Uup7SjgcQlM8ir3JDPYOpa0KTIZhJgahUAjhkN9rEPCn7xUroc4wDDMc3n/sHNy69iWccphdpeSrKmZRrpcz/6K0N8bR3hh3/tyvfCmmkCojZS8n1Nw7EpBmpQJShYrodnsRe6Vvs2mQQooe11NxuRVSQGkpe16VPbtCKuUoWGXO/+WawubhSjNKZDtX5oP8fZn1Yzte/v3174MUUubfJEgh9dYDO7DhytOcP6fYgm/mhrQ5No9HNfO7jtpn1N6LA1KjSHNdDN8+70g8+MKb+Kclc30/t6Xs+RRSKiCVDUyFkzf5zr58MKguFvYNDqZCiuKSDpoPAFdqlHyvH6z5u+81E2rs7KmZ/O08D6m0piqympWTCgdZI2hDUalVMmXP4SHlNx5EoX3+/1Kq7PlS9kowNVdV9izV8ABPWmt7kJkBKZtCKmQEmQAirzVT9sL6cYMCUvIkczmBobR3rdqkuJqHlCMQa/ahWFUKt0Jq5Cl7kmnNCTz0hZMRDYecu1lAPogpd5L8VfY8X4BkQApufSyCPUg7U/YAoKkuH5CSu0wMw0xcIuEQcln/DjllPE5wGYaZGMyf1YI/f/EUp7+MT6VkU0gNM2WvGOZ7FUuHatFS9uxtverhOc/vNqC7yiMo7U7Zk6ldA0alb/PRnbBkXqh5O2krA2Q2KxB6bC9lz6KQkusKY/NaCMNDyqH8N4saJYMUUjFvDhykpMq3zb8uN7hLNTV3Ba4Ai2qpQiol2zrCrxgsP11wIsMBqTLp7u5Gd3c3sll7OlYxzl80F+cv8gejAE890jOYVg8nMzVHBaRI9Trbg1Ze+G/uzQekbAMGPXZjPKo9mFw3pc+k0HEDBRmtm8gHLZU2Bimk9g5ltL6GLIdtLKHCAUAM1S0KKRpkaCLvTfGCTEQh5UjZk4cuZmpOg2L+lL1ipuZeP2jLHNnR0VP29PMAqLzWrpCSTVVAqsG/S0Ulu/Qzs5mQR8hxB5LBCilflY0i5XlNbO19O3QBgxe9LxriUed9Eg6HUB+LYDCdxVAq59xJojLsdEDVTHmvqoCURYLcXBfFGz3jt9IewzCVI/8s9C8m6NBp25FnGIapFLZsD0mxBXj+tdKDB+VgqrGKVU+jKXsu1VO5puZybinnf0Epe4PprL4hbmwzxK0pe7It7WOo0EeLqTnZ6La4dSi8TXzvyOFQCFlilUL7YmYqqPl/oQveJrfFQ4oYv7vWHhI5X5ZeU6UGpFztgOqZmsciYcQiIU2pVixIGmRqPhmY3Gc/DLq6urBx40asW7eu4seeWpCfvr5nUAVGfAEpkpPsLXLdN7lM8bEGpMhN35iIaA8BV6TWfKgXMzWnOB8yUqVElB12U3NPQVYsZU8qYTI5oVRNtr6aZuXCUXK1rT7/t9lTqHImkd2wVtnLmCl7+rHNPGuJFhSD3tYcPFTKnqyGQXO9LeVZAf0haFNeJR2yWVNNtbNwbbU3BJmae4NHUyJq/bvS4w44zPwlykOqSOVGl0LKVn3Or5ByPxbp9d8YIAMGiKounfGCx0Z/qd+YF2B2K/lkCq5NgiyDfb0ckGKYCQ9dLOgpe/7nO8MwleWcc85Be3s73vve92qvb9myBUuXLsX8+fNx1FFH4Ze//OUY9XDsMRfc1ip7xiLcZVRdLuYc0OYfSqEBKVf1cHnMTE4E2ouo4xhBpKACTEIUfHSdCilvXSHXEmblbrOPJtQKJGSZ+0tsm/jyK9o+7VBI+UzNlQ1IsIdU6Sl7Ge13TVzpjjb8CqnKjZnmmtcMklbzvWuRsu78/v5+XHnllViwYAGamprQ3NyMo446Cl//+tcxMDBQrT5OGuZOaQAAvLB1r3rN9LyxeUhZq+xFdYWUDKhQ6gwPKfqwcO0mlFLG1fX7LRb/IMB7qAwQhZRt18FbcKc1RY+tC/Rzk0oeW1/9KXvymHpbWf5SGnlLbAaEni+QQyEl++2osmdTSJnvJwlWSPmltYBdIUXbuqvsyT7k/9+8I18x0vRPov0QQgT6R5nHlQGpRocJoaeQcgdvAHtAarrDV8kcJEpN2Ss2waFmla6Bm6bsyTa2QVYGoGQKri0gJQO24zllj8cQhqkMrp15OmSwfxQz3qnVMeHTn/40br31Vt/r0WgUq1evxsaNG3HffffhM5/5DPr7+8egh2NPNU3Ni2Gq5G3+oRQ6P7UFcwCiPsrlAjcQVftCH4JMzakivz+VsQaZAH3e7qlu/MEr6nNl4m2gh5y+tACsNie2itwub1RzozsZoJCS66VkOue0C5GY7+NUSPkqLLrHwWoppAA9sBYOFe/XZB+vS07ZS6VSOOmkk/DMM89g+fLlOPPMMyGEwHPPPYdvfvOb+N3vfoeHHnoIsZg9l5gpztyp+YCUVEHEI2GfqkdTSAUEpGS7NwsL2BaLQore9NFwCCAPRpd00BwsXNJWW2qfS01VpxRSwSl7LcTUnD5sbQ/5aCSMRDSMZCanVE0us2jAS9lzlVyVASmfQspiQOjykDIN0CMqEKMPCJpCqtBlt4eUXu2Q9lsrz0r6ogVgDGkt4JbX0gEplxN4aWchINXhD0jRwU4GSNwBqUJgTghnqqrErLLnDEiRP8js9nos2X8qTjtihrVtOROi2DAUUoMkIGUGaqlRpStoBXh/C5myZxvYZVpp31Da97PxAI8hDFM56OSVqqLo02OSz2+ZcU4tjwlLly7Fgw8+6Ht9n332wT775I2AZ86ciY6ODuzatQuNjf550kTHDArZ5mtmm0pVCA6H9cIPNv9QShPZBDW9YiVyXZTJemp+mw2Fal+Yy3kpe/Z+SnuHwVSWWHvo7ei8NJnJIh4Nk6IWFoWU1dScrJsC4i5WmxNLip+rgrqZTRFkak4rx0vvZFfapjk3d6fs2d/DRrnm9+VAr2XrtW+a/o+zKnujTckBqRtvvBGvvvoqnnrqKRx66KHaz55//nksXboUN910Ez75yU9WvJOThX1a6xGPhNXDyxYlljdgOivIItf/lJNRZxnptqXs0ZslHA6hntzcsahD+RQ1b157O7qobohHcPenTrS2y/dDz7MGglP2hNB9clyK2cZEFMlMSimkbH1VwbC0aShoKKQKCrPdJCDlUjIpk3ZflT3D1NyhkMpZjmuaBErMSh+u8qzUfJBG6W0eUq5BQamphMDW3iEMpXOIhkOY3e73EPAGJLcnlUT+rQUJXhVTSHlV9orvkMxqq8f33t9pbQf4A0DBCiniIVVUIUV9zPz+XYDuIZUM2HGTwS3597YqpBJ2n7PxAo8hDFM5nCl75OsgfxOGGWuqNSY89NBDuPbaa7F+/Xq88cYbuPPOO3H22Wdrbbq7u3Httddi69at6OzsxPXXX4/FixeP9JQ01q9fj2w2izlz5lT0uLVCKBTSfHRs3p6hUAiRcEjNgyulkALy8zUZNAmqtAboz0qzmrZ3vHybdDaHPQMF+4SAQJecy3mm5vbncWMiH5AaSGV9FbYlNKgiz8m2gS5VWZmcvv6g7cPhkNrEsKXsyb9FTFNI5f+nnrcpx7zWzKYIMiuX8+3BVFbNgV0b0uaaxF1lz/tE4pGw83MH/OIH23p6uNQXC0jVQJW90aTkO/9Xv/oVvvKVr/gGDQA47LDD8KUvfQl33HFHRTs32YiEQ9iXLO4bLQteamoeVJXLNGa2BaToDRIK6b/jiiibg0UppuYfOm4/7G9R0XjH9D9UrNLWWFjdsL1EBeLyyZC52b2DxRVSg6nCA17+wDgkTdmTgR4aR7JX2XOZmuf/lw9Cs8qesBzXpZAyzQdd5VldVd5sPlaufG8aZNqyKy+l37e93vq50kCXaxfFO26hbU4oz7OOJns5X3ncVEAw1iRoBwuwlR12PxbpuxVVSMlgZyrjDDZRDymX/Bnw59TbU/Y8BeF4hMcQhqkcpfhDBfmbMMxYU60xob+/H52dneju7rb+/Pbbb8eqVatw1VVX4cknn0RnZydOP/10bN++XbVZuHAhFixY4Pv3+uuvl9SHXbt24cMf/jD+8z//s+z+TyTo/MqlPqEL8UqZmgO6TYdrk9OGK2VPnksyk8OjL+4EABw0rcn9/hFvvQa4q6HKAAxN2TOf7+FwSK235PFsnrdyc9qaskcCWK5NbgBIy41uzUPK33tX2qKZ3jeoqme7rSZ2FLJ5APemsDk3L8VDKsg/Cqhuyl4dmaeXkq5aSXVWLVLy2W/cuBFLly51/vzkk0/Gxo0bK9GnSY00NgfsQSR6c/Un3aUvzRvaVZZVsm9bvXazJxwPBJ9Cqkg1CgBos1Rh0/vqP4bL/FqehzTUBgICUoUBaE/B98kWffYCUgWFlKycYTSVKY/prFDBBa3SH/wDqpmy57UPaedoVtmzKaRsXk8AVUj5VU+6h5TdBNz7NeIh5UzZ8/onU0FnNNfBBg2gycHTZVbppex5vlTTHH5P5nVRyuDh2m1xHdN17QP6rlNDkQmODIj2J6mHlEMhlc052wD+qnrWlL1EwfR/nAakeAxhmMqhp+x50E0JVkgx45lqjQnLly/Hv/3bv+Gcc86x/vy6667DpZdeiosvvhjz58/HTTfdhIaGBtx8882qzYYNG/DMM8/4/s2aNavo+yeTSZx99tm4/PLL8da3vjWwXW9vr/ZvokEX3a4NbDrnqaRCij4ji83XKG2O9RI9l2Qmh9nt9Vi8/xTncVQAKcBDCgAaYvm+DaayvkwKilpbpHWFFG0t+2irsleqqbmnkArOpnDNWeWyUJ6LynywbA631Odf295LAlKOa2Bmq77ecF0rdCOmWECqmil79Zotjk0hZa6nJ/d4XfInv2fPHkydOtX586lTp6Knp6cinZrMTCEBKZvvE1WZyJvctoA1b9TWevvD+PsfWIizF87C+4+doy1yXTe6WdHPdbPTftqqsOl9tSmk7G2lgkwqdILaymCT9H2yVtmTctEiJVepIaL83OmDPEQO7VRIqZ2Pwv8qZU/vkxboCulfmCrcbE73kMo39Q80KYdCSp4njYkllULK5SHlDR7TWuyBIzogJYsopGTXf/zIZvXa9BZHoMv4YxcbbAC38b76udEvU11IGSJpmMXeu0VVhUw7PaTUtZLOBSrJ/Aop//0sFVK3PfaKCuyNJ3gMYZjKUYoB6iSf3zLjnLEYE1KpFNavX49ly5ap18LhMJYtW4a1a9eO+PhCCFx00UU45ZRT8KEPfSiw7dVXX43W1lb1byKm9tH5jGsDmz7LKlVlD9DndsVS9gDgX5YeCABY8dZ59uMZ/T9sZnNgOphcc8i1gMu3qUFtXmY043ETmiED+NcUgLcWCDI1jxBTc3OTWwjhK5YEuNYVdlU/zaaQ5wXYsxWkyGDb3iHVf1dQSBb+krg2m+lnVyzI41dIVW7QpGsoWzaH+V6skCqRXC6HSMR9Q4fDYWSzdiM4pnSmNnkLfKtCilywSiFluYjNYMI0h5LlrIX7YvUHjkZdLKItel0BKXOwcAakyOvtjcEKKVvJUNdDXvoVvUwCUu687PzDT3pI2R4I8oGWE/kdD1fJ1XA4pAY0ab5uUzIBetUIilk9w5Wyp6cCmgopHZtCSg00dOBwBERssl2Z720GQWjlPPmZuoON3oAUlFoKeEGmV3cPAgAWz5viTLMzU1BKUUi5jPclpmw2KGVv0GF2aUMGlHsG0850PFVlL5tz+kwB/smUbXLV3uj9LV7c3ldyP0cLHkMYpnJoAalQyPYlp+wx45qxGBN27NiBbDaLGTP0IiczZszA1q1bSz7OsmXL8L73vQ/33HMPZs+erYJZjzzyCG6//XbcddddWLhwIRYuXIinn37aeowrrrgCPT096t+WLVuGf2LjFDq/KsVzNmhDsFw0hVQRU3MAuOz0Q/HUlafhbQd1WH9u9r/VUr2coqrsyZQ9x/NYznf7UxkvY8LSlG5gArD6TcmgRpCpeSgUInN/vU2a/B4NINrWCq6NVpqyd8f6V9EvDeAthY1aiDcwYE/rkxy+T4s2P3a1peuxYmsEM0hqBh1HAu2fLdjkMzWf5DtIJWsYhRA49dRTEY3afyWTGZ9pIrVGsZS9cDiEaDiETM4zgLan7OmvzWy1K1koNNjkVkiVlsMb0xRSwQ/tUCikKuIBwTu/s9vzEfJXdg4UbSsX7Z6pebDyZCiddZZcBfIBroFU1q6QIu1cKXtmW1fKns0sXf6Ome+tPKTIQJn/HaG1lTsZ5t/L7iFlNyCkA5IraOUd12vr7aIUHzwAYNVph1jb0eNKgqpnnHhwBx7++w6seOt+zjaAfwAKMjU3VW9ByIDUnsG0GuTN4GucTDCCTM3NnSBbH992YAfqYxHEIiEsOcAtIx8ranUMeeGFF3D++edr3//sZz/zmeQyzGjiGvuoupdT9pjxTK2OCQBw//33W18/4YQTkLMYSttIJBJIJIrPzWsZOp9xLfZpUGAsFVKhUAitARkdZkCqsUiQS3lIZYI9pJT/51AGojX/WrBCSp+H0md+VGVe+NcVVFGljm9W7s7ZswA8RZWHa6NVDjs9g2l87bdeyq1to9nMBAqyzKiLRXDIjCY881o+tdX1N6UZK8WUxHkBhLeecxX0Gg56QMp/XJ+peQXVWbVIyQGpq666qmib8847b0SdYfSUPZfvUzwaRiaVVdW0SlFITXcopFy/U4ryCSg1IFW8ZG+cBKSCJLBzCpLNl3bmU5KCnjXSQ0p+TnZTubCqbBhU4SJ/vAjehFeBg0pdNYWUI2XPrOAXLkEhJY/qMjWXuyCaCsgyzpSa6y2EwFCmSMpernjlPBrocgXDvLb69y7/qHx/S0/Z++GHj8W23iHsNzW43LJ5XQR5GAylS5toAkBLYZKxi/idxVxV9oiH1HBNzae31OG3nzwBiWhYGUWOJ2p1DDn00EOxYcMGAEBfXx/mzZuHd7zjHWPbKWbSQ9VP9AmmVdljhRQzjhmLMaGjowORSATbtm3TXt+2bRtmzpxZ0fdi9Dmna8GtpexVUCFF368cDykXZkCt2DGjRkCqmN/t3mTGW4NY2sm1nukhpSuk8t+ks/YMjXx7d8peimyk0w1UOfemG+beJqqZ5ZL//tnXdU8029y6uc70Rw0OSM6b2qgCUsXWH0DxII8URMi5fbVMzW3BWDMgVSybY6JT0YAUM3KmNpUWkBogJTJLUUhNd3j96L9DU/ZKMzV3BQToQ6BYyl7+/cLYW/g6KM1A5hC/XFBIBQWvTImua3emLpYPSA2mvQCSbeCQKYBSIaUFjkhzLyDlStnL/y+fe0EKKdlWbWY4FFI280FhUUj5cr2N0q/prJc/bkqnqeppsGhASp2M8729tqYM2h1MKSdlry4WKRqMAvw7KEEKqSmN8ZKr2MnzoNVDzOCxp5Cixufu1FKJa2fooOnuii9jzUQYQ37zm9/g1FNPRWNj8euKYaqJ7u9RvA3DjDfGYkyIx+M45phjsGbNGqVyzeVyWLNmDVauXDnq/QGA7u5udHd3T8iU9Zhmau7awPZv6FYC3dR85IGucDiEcMib+xertCxtQpIqIGVv10QUUjI+ZFuDKDsQo8qezTPJVEjpFiNwpux56YXFrUBcG93y2Lv7vc3YtoaYdb0Wi4TREI9gIKASH0VmyQDugCD9nEtJwauLRaoSkKLnYlNe+Ys0Te7xesSf/J/+9Cfcc8892L17dyX6M+mZ2ugFjvZtq7e2MRe1dlNz70aY0hgvadehvgSFlDlYuI5LH4auihUUek5Bk2gZkJJBgaDbt6NJD8K5HjQy0NSfzHgVLqwKqXw7+eC0mo/Dk5z6PKSMnYiwc+Dwjikf4MpQ0OiT3UPKr6ZKOYIdZl44DcqZQRCq0hpyGJ97x/UUUlIp5jQ1N/7eLQHqnmo8wH2m5gED4lffMx+hEHDte48qelwpRd5JBmV/lT3PQyrI1NycTBWrHFhLjHQMeeihh3DmmWdi1qxZCIVCuOuuu3xturu7MW/ePNTV1WHJkiV4/PHHh/Vev/jFL7T0PYYZK9wpex4cj2JqkZGOCX19fdiwYYNStm7evBkbNmzAK6+8AgBYtWoVfvjDH+InP/kJnnvuOXziE59Af38/Lr744kqdQll0dXVh48aNWLdu3Zi8fzWh6Xgug+mqmZqT966EQgrQrT8aHF6nZttiCqlmstmdMzauKXHjeBbfcvV5p82NbvJ13kPKr3gCQOwlwnrFVou9RzErkF0D3tz3Py48xt/ZAnQTOmj+DQCz2rxsn1I8pErZlNECRxU1NQ829A+FQtr7uUz/Jwsl36Hf/va30dfXh2984xsA8hfx8uXLcd999wEApk+fjjVr1uCII46oTk8nCVQhNceoKCApRaVEb4QZjoplQb/jCh6UqpCiC+hSKgfQvOGg58dM41yCHjazWvWAnquv7Q1xvNEzhF39KdTH6gt9sCmk8n20eUiVlrKnt7U94PPH9e96yK9MDymZ7617SMnjeO1cKiWzD9K0OxIOWYJXsq1w+kx5bb3+lpOyVx+LBKbhmTsspVTZK4ZfIeU+5imHzcDf/215Sde0UkjtTar3Md+LekgFpeyZg3SxXaTxSLXGkP7+fnR2duKSSy7Bueee6/v57bffjlWrVuGmm27CkiVLsHr1apx++ul44YUXMH36dADAwoULrX4l9913nyrz3dvbi0cffRQ///nPy+ofw1QD2yYEwCl7TO1QrTHhiSeewMknn6y+X7VqFQBgxYoVuOWWW3D++efjzTffxJVXXomtW7di4cKFuPfee31G58zIoTYFrnkT3airZMoefUYW83sqlVg4BBlmKaaQkueVCTAqB3SFlLlxTTH9aW0b6HItkDV8zHwKqcLX5rul5XzdoXqS/cvmhFo3+KxADIXU2QtnYckB7mqaLXUxvNGTr7JXLGVvH7KuM9P9zL7m+1Z8DKTz60oGhUoJdEXDYaQLykhWSJXI7bffjgULFqjv77jjDjz00EN4+OGHsWPHDhx77LH42te+VpVOTiYOnt6EhXPacPg+LThqdqu1jblgLaaQmlFCuh7gKYUAd9pUwqiI4goyfPj4eViy/xR88YzDSnrvUhVS9fGI9sAKSu+bZSjMmhwDkvTt2tWfQtC4IXdDBlRAqpiHVJGUPRLgoXiBK++1cjykQpbjOj2kjPQ+qZBqiEV8wR8vZc9rV2yHIic8dZY7IFX6pMG81INMzYdLsSovpZZmlUqvvYXrxTbYqGslG2xq7q+yV5ndvtGkWmPI8uXL8W//9m8455xzrD+/7rrrcOmll+Liiy/G/PnzcdNNN6GhoQE333yzarNhwwY888wzvn8yGAUAv/71r3Haaaehri44wJ9MJtHb26v9Y5hK4wo20eAUp+wx45lqjQlLly4tmDjr/2655RbVZuXKlXj55ZeRTCbx2GOPYcmSJZU4JcaA2kk4F+W0yl5FTc1Jyl5s9BVSLm8lk6aEN1c0N64pytRcBqQKr2uVVQufd9qosmduoIccG+JqrWDaexAPWdqO9ksi57C7B/IFpdqKFLZqqfc+x2IKqblEqOESW+geUiUIIkj/K7HJLanTAlIOe5swj9eSku/QzZs346ijvDSVe+65B+9973vxtre9DQDw5S9/Ge973/sq38NJRjQSxl1dbwtsU0qlO3ojTA8wiabQFMGZrfYbvVSF1LTmBG7/2PElva95nGI35dTGBF7bMwjA7Z0BAHOm6AGpRsfgQQNSMvpvy3VuisvSrDJlz/sZbe2usqfvZrhT9vx9sJVcpb8b1XbL6bvlKSatlYeVhu11lp0fWso1WSRlTwW6UJ6HVLHdMZ+HVAUHD9WfCg0KdJAF7AMSnWCkHEFDwJ9OW4sD11iMIalUCuvXr8cVV1yhXguHw1i2bJkq010qv/jFL/DRj360aLurr76aN2eYqqM988njgBVSTK3A64o8E9lDKlpCSlI5c8ByoHM501N2uNAgUzGFlHm+rmmb3IgtZhsi5+8yQ0FtcsP/GQd5SIVCus8rxWnvIZsXVhZJzfw8eF0Y5AsL6DYdxQJSh8xowvUXHI1ENOy0rqDrBFeaKEUr6FVJD6kSMoW0+6MKG+y1RMlnn8lktPKka9euxVvf+lb1/axZs7Bjx47K9o6xUopCikoZS1VT1MUiuH/VSbjvs293PhT8VfYq85CngZJik+g2UrWvmN/UCQd1qO+nNtkDc5pCqvCMtXWhgQwagN18HCDGg46UPTl4yIemv8qeTNnzXnN9JlYPKUvwypUOZraVA53NAJJW5CumkAqRQFeQ+T6gn1ux3TFflb1x/AA3B2Fb4Ji+NpAseG3ZquyRv0ctpusBYzOG7NixA9ls1peKMWPGDGzdurXk4/T09ODxxx/H6aefXrTtFVdcgZ6eHvVvy5YtZfebYYoRtmxC+NuMTl8YZjjwuiLPRPaQKqXKHp2rVtLUPENUQpUwNQf0IFOxtZVpZO2axyfIxqQIUEjJ6sleYR3/WkEGYDJZM2VP74eXgqdDPaRsffcKINmr8QHDCEiV4SEVCoVwZucsnHaEuyKmnrJXiql5dRRSWsqeY61Kg1CuNpOFkj/5Aw88EA899BAA4JVXXsHf/vY3vP3tb1c/f/XVVzF1qjtHdCw555xz0N7ejve+973a61u2bMHSpUsxf/58HHXUUfjlL385Rj0sD1elLgq9qfebaveisnHQ9CYcMqPZ+fNIOKRFnCt185ajkKJKp6DgVSgUwo8vXoTDZjZjSmMcR+5rT4G0KaRsXWhKmKbm8n10NZNKwzJNzY1Ak7vKnv/c3AqpgoeUFpDyp/e50sFM2W5QpQvaVgauXAaUqr85EWjWDeifdbHBqJwqe2NNYzyqV/sIUEgBwN6hvLzZ9jnRv0elJlajTS2PIa2trdi2bRvi8RIqhiYSaGlp0f4xTKUpZec3KKWdYcaaWh4TmNKg8x5Xyh6NnVQyIJUiKp5iVgylQoNqxSwmzLmcqyo4zaoQcCukpNCgdzA/V/TWIFRlUwhIFaneLTfGzTWFa77uVfr2tzPPyxQqUBGBDRqwqq9AyibtTynZBHUlFPQaDpo3lePap0Goya6QKjllr6urCytXrsTDDz+Mv/zlLzj++OMxf/589fM//vGPOProo6vSyZHy6U9/Gpdccgl+8pOfaK9Ho1GsXr0aCxcuxNatW3HMMcfgne9857gv6e1XSNkv9G+fdyT+sHEb3nvM7Iq+fywSRiYXXDmtXOg5FQsyUJlssfSqWCSM//fJExAK+Q2lJe2FgNTO/pRVAiuRuyF9hkLKbOlK2TPzvYul7OkBKX+QCbArpLwvvcZShmv+vTxfqIKHlAxIFUnZG1Sm5sU9pOTnkHC1JX0vFpDyKaQspVTHC+FwCM11MfQUJg/WgBR5TaaC2srD0p24Wq2wNxZjSEdHByKRCLZt26a9vm3bNsyc6d5hY5jxjk0Vm/+ajAWTfMeVGd/U8rqCKY1SqohRA+5KLspTJNJVqWchnccVVUg5gjomtBCSl6XhbyyVRL2FzUtvveIhP+NM1lxXeF9rCimXh5RDISXXCmlHah89H0nxlL3SPaTKpSRTcxJAq2jKXikeUlRBOMnH65I/+UsvvRQ/+MEPsGvXLrz97W/H//7v/2o/f/3113HJJZdUvIOVYOnSpWhu9qt+9tlnHyxcuBAAMHPmTHR0dGDXrl2j3LvyKdXH6fxFc/FfKxYpmWeloPdMpUq0xkuQ9UroIFDK/RuNBHvuTCkY7u0ZSBF1kr+dNEWXPksu88E6R8qe9+AvlrJHW+lfmwaEVg8pi1lhOlOQ4bo8pArfDwal7KngFTBUUH+5Tc1lW+EMhpl9AEpI2ashhRSgD8S2gTEUCpWUgqtLf8f3ObsYizEkHo/jmGOOwZo1a9RruVwOa9aswfHHl+5xxzDjDbepefE2DDMeqOV1BVMa0RIUUqaap1Ik05X35KJz7aIKKWNu5wo4eDYfOW/j2tKuRSmkDNsQmrKnFFL2DA1ANzU3A1LKQ8qx2SubB3nDmnP9SqbslUspVfPoJu9YmpoXW/tOdMoqO3DJJZc4B4cbbrhhWB146KGHcO2112L9+vV44403cOedd+Lss8/W2nR3d+Paa6/F1q1b0dnZieuvvx6LFy8e1vu5WL9+PbLZLObMmVPR41YD82YfywVqpaLJiTIW3DRYUomUhAYVaMpaDcW995UKqYKhIPxKJsBTSA2lcxBC+KreeSl7hdedpubea2Y1PImnkPI+M/lrtGkqa1e0hYzjeil7/keDl0Mu1EBfTCEFeJMCt4eU93UxWbV5uY33gBQ1No87zi0RDWvScmvKXo2qokyqMYb09fVh06ZN6vvNmzdjw4YNmDJlCubOnYtVq1ZhxYoVOPbYY7F48WKsXr0a/f39uPjii4f1fgwzHrBtQuS/9tpwyh4z3qnGmFBrTGRTc32z2T5fM+fAlSKVrfxx6RGLKaTMuZxrY1xlVaRzVg9ZiU8hVXhdqyonPaR86wrv63CIbnLr7dKOlD25xJDtg4rwmHP9lgqampdLKUEeuhFeyTUFnbe7UlHZ1Nyj5LPPZrP49re/jbe97W1YtGgRLr/8cgwODo64A/39/ejs7ER3d7f157fffjtWrVqFq666Ck8++SQ6Oztx+umnY/v27arNwoULsWDBAt+/119/vaQ+7Nq1Cx/+8Ifxn//5nyM+n9FAT28Ljbosnz7YKpayR3dRiqRhUQ8pV052OTQUHoCDqay1jKr5vgNJXSFltqWqMSoZhmqf/4WwUkjpv69UT+Qzce1meG1tCilqap7/2m9qrgfFBgJS9qiPVVFTc3ht5WfgeiDrCqnyPKTG+44CHWjjjr6an4stcFeK7Hi8U60x5IknnsDRRx+tUjtWrVqFo48+GldeeSUA4Pzzz8d3v/tdXHnllVi4cCE2bNiAe++912d0zjC1hGvc1xRSk3t+y4xzqjUm1BoT2dRcU4A4nlnVUkilMpUP8NHNw2J+niUrpEjKnjDWCRQ5n9w7JNcgftsQuW7wp+xRD6mQUz3rMjWXNibyMEHFiso3NffWdMUqF5ZLKQGmRhJYrKSHGQ10OQNSZJCe7KbmJSukvvWtb+GrX/0qli1bhvr6enz/+9/H9u3bcfPNN4+oA8uXL8fy5cudP7/uuutw6aWXqt3sm266CXfffTduvvlmXH755QCADRs2DPv9k8kkzj77bFx++eVadQ9bu2Qyqb7v7e0d9nuOlHL8lqpBNfKy6TkVk1hqCqkKvL8MNPWnMlZ1ktcu/77SQ0oGcXwBKXIuyUxO7X6YUlyXQkrmZtPBSymkjJoYctCx+YloCinXroeR3if9jlrr3QqpVCanJhCuFDsaFAuS9tJzA4qngJqDdKUCotObE9i+N4n9OyrrH6en7Nn7ahpA2trZTCtrjWqNIUuXLvUpB01WrlyJlStXjuh9GGY84VI/aR5SrJBixjHVGhOY8QO1iXBW2atSQMr0Z60ENCBVbP1l/jziWNtopuYBCilpai4L4MCyKe4ppMyUPb1tMQ8pc75uetMOBWxKm8GXliK2MVRB1ZAoK3GrKKX4MlHT9WpV2XMdl242V2I9W8uU/MnfeuutuOGGG/D73/8ed911F37729/ipz/9KXLGRV9JUqkU1q9fj2XLlqnXwuEwli1bhrVr1474+EIIXHTRRTjllFPwoQ99KLDt1VdfjdbWVvVvLFP76CK8kjdPqVTjIZ8wVF9B6FX2Rv7eUg00kMoGllxtNKrseX1wB0lopT3TrNxlam7zhQL0wJFEDjoxS/CK7oi45LVeoCvPnoEUAKC9wV9NTLal51+KqXnRgFQZpubmA7tSAdn/+NAxWHb4dPxoxbEVOZ6EDsSuYFupRQpc7WuFsRhDGGaiQtc2rrjTZJ/gMuMbHhMmPloVMZepeZENpeFy3fkLAQCfOvXgih1Ty3ooghmYKc9Dyt+2jrQDYG0rg37mukIY6w9Xyp5rrWB606qAlEXRRDdZY5FQUW9YOk+utEKqlA3cVrLeGe2AlO6xVptz+0pR8tm/8soreOc736m+X7ZsGUKhUMlpccNhx44dyGazvtSKGTNmYOvWrSUfZ9myZXjf+96He+65B7Nnz1bBrEceeQS333477rrrLixcuBALFy7E008/bT3GFVdcgZ6eHvVvy5Ytwz+xETLWCqlqkCjjnBrKqLJXCvJ4g6mss3Ie4Mk6+5O6XNYMSIVCIU2CKzF3KGyBI8CTL9MHlechBWtb3UPK33tXUMjzm8ofZ/eAVEj5dzTkedKAlDsNzzuuqrJXSspeUQ+p6qTsHT23Hf+1YhEOmNZUkeNJWsnOi+vcSknZo9TqPT8WYwjDTFRc6eq69yAHpJjxC48JE59STM2rsckNAKcfMROPf+lUfHZZBQNSmdIDUuZczu0hlW+XzQmlULI9uqnXFOBfUwBe0CvtqLInu6BsQIz3cFXPMxVVg6l8O9smcjuZ97bWx4paq9D1RjFfrvIpQSFF3r+iKXtkrWpblwH6NVGr2Q+VouS/fCaTQV1dnfZaLBZDOp2ueKcqzf333299/YQTTih5JyaRSCCRSFSyW8NGU0jV6OLUREvZKycgVQkPqcIDMJPzgid2hVT+ffuNKnu2HiSiYSQzOXU8wJ9uF1E7DvY0vKglDc9sm5VtyYPMFrxyBaTMUq5SIdVmUUjJQWUwJQ3Nw0UXRYIopMzUNLO/8phBmIPfeK84V0o5W59Cqsg51eo9X8tjCMOMN+gYRSe7mofU5J7fMuMcHhPyTGRTc7qB5lJI0UyCSjO9ua54ozIYSUDKFZCjc2P5Wdim1nJ+PJTRCyvRebj8vNOGksss2GQWNJLI8/N7SOnHGQoobNTR7K2VpzYWXzdThVSl/VJLWSLSlL1KVqWnCilz7Sah51tKRcCJTMkBKZneRoMyQ0ND+PjHP47GRs935Ve/+lXFOtfR0YFIJIJt27Zpr2/btg0zZ86s2PuUw3gYOOhDbizSd+JGVbCKHFMLsgU/QegDsBITbhrgkuonW5RJKqSG0jlksl6ut3UnIxYBhjLaQOtTSDlS9mQanh5ksu9meAopGrzyB7pUXrhv10OX4fYWPKTarAqp/P8yIOcyNDf7kHLkpJttgeIpe/Q9o+HRN/QvF5ob70rZozsyQef0gUVz8Ku/vobPnXZIZTs5SozFGMIwExXno488TzlljxnP8JiQp6urC11dXejt7UVra+tYd6eiaAtux9w+WeH1RDUpJ2XPX2WvuG2DLBhk2xQ3FVK2TfGiASnov+P0kHL4zSqFlPKQ8p9TR5N3P09p9G9umzSRjVv6u5WglCGQKrToJvJIoUE9lwaQBqFK8buayJT8ya9YscL32oUXXljRzpjE43Ecc8wxWLNmDc4++2wAQC6Xw5o1a8bMoHY8DBxaQGoM1BKXnXYovnnPc/inJXMrdky6WC8WJaa7CZVQSMUiYcQiIaSzQgVbrCl7xLtqIJ31JLCWh0hQyp7ss1RImVX2PKNyWmVPHsP0m/IboKv3I1/L3YyEEfAx1VS9heodtjKtYZ9Cyh08snpIOa5VumgqppCqjxc3yBxPtGpS4OIKqaB0vKvPPRJffvd8NFXY9HG0GIsxhGEmKppCijwKNedBTtljxjE8Jkx8YiV45Hxg8RzcuvZlHLtf+2h1a1QotcpeJBxSaxA5V7en7NFqfMK6KS7fM50VyOWEWp+Y6w/1uvEezip7xhokyNS8vSGGg6c34e/b+7DkgCnWc6ZEwiH8fx88Gj2DaXTOaSvavhxKsbg4ZEYzDpjWiP2nNpYUQBsOLuP+UgK2k4WSVzY//vGPq9KBvr4+bNq0SX2/efNmbNiwAVOmTMHcuXOxatUqrFixAsceeywWL16M1atXo7+/X1Xdm4xoC9jo6F/Al5ywP46Z144jZrVU7Jg0WFHspqRBi0p5ZDTEo+gZTKOvEJCx7SzHoyRwlcwE+k15A4c/ZU922VVlTyqmYhaFlFnK1aaQknEsqpAadAweZipg72CQh1T+fxm0Cw5IeceVQblSquyVo5CqBS8lKkV2BdtMA0gXoVCoZoNRQPXGEIaZjOgpex50SHRV4mOY8QCPCROfqJaSZH8e/es7D8f8fVpwyuHTR6tbo4I557UZgEsS0QjS2UxJCqmcyM/9lak5aUrnxelcDolwocq36SFVaONK2XPZe8jWQSl7oVAIN174Fqx9cSc+sLg04cK7j5pVUrtS+cTSA/HLJ17Fx086sGjbulgEa1adBKB6mziulD0qwKiFNU01GfPVzRNPPIGTTz5Zfb9q1SoA+Z2TW265Beeffz7efPNNXHnlldi6dSsWLlyIe++912d0PpkYaw+pSDiEt8yt7E5GnCzKi50TfQBWKiWhIR7JB6SS7sEAAJoSUeweyAeulFw2SFqbsaTsQd+hMFP2pGSWnpv8TMxSrraKfPL49Pk3lLYbEHoy3PxuS08hINVS7380+D2kglL28v9nskLtuBSryAcUNzVP1FpAqr4ED6kxrprJMEztUcrQxyl7DMOMJaXMb+pikZIDF2PNkfu24unXejBnSn3RtuZaRvrQWttGw0AyOH2RZpIkMzkVHaIegtQCIpXJkSCWUWVPKp6M90g7quxJ5HEGAwJSAHDQ9GYcNL3ZeS7V5otnHIYvnH5oyQGmaquJD9/HLuCIlBCwnSyMeUBq6dKlvgitycqVK8csRc9kPHhIlVORrlbQTc1H10MK8HYulIeUg6a6fEBqbzKj1DrWnQxZnjXtXSfegJD/3kvZcyikwv7PxKycYauyRyvcSVzyWuohNZjOquO1WIz9zCp7Qel1Kr2PnL+rPR0IXD5LEl0hNf4f3q31nvzXVb2DnnOtGpYzDDO6uFP27K8zDMOMNlHNkiF4w7EW6P7gW3DTQy/ioyceULStGYBrTrgNs+XcbyhQIeUdbyidVVkXdB2kKaTIeiFnpPfZvGbzv1MISBnZN6aHlGuTezwxHlLW/+vDx+LJV3bj7IX7Wn8e4yp7ijEPSNUa48FDKjYBFRX0QVvsAael7FUoIiUNy/sKASm3QioGYBB7hzKqz7YYgj1lr4CRsudTSFnS8GTlQTNlz6qQshigq5S9uN5Z6iEl1VHRcEgzejfbyqBdKabmQzQg5VA/0WfwREvZm9XmVXhxlX2lQajYBLmfGYapLi6rRS1lb5LvuDIMM7bEypjb1wJzpzbgW+ccWVJbc4Nx0Ty3n5Jcyw0FVNkLhUKqqFQyk4NKmDAKWUTCIWRzQis+ZWZ0uEzNVZU9Y4Ax7T1cNiCMzrL5M7Bsvjuji1aVn+xV9ib32dcoY21qXg3oOTXEg+OkdRU2Nc+/Z/6YKiDl+FibCx4+fUMZn0kgpZSUvagjIJW1VNmTUXQzZc9eZU9/P4CYmkdNhVT+/5wQ6C+kKzbEI9adBRn8k5+RLWil2hZ+Xaqp4pGwM3gYLmMHjebg10JAil7LU5vsZolUIVUL58QwzNhDn9GaKoq0YQ8phhn/dHd3Y/78+Vi0aNFYd6Xi0MBGsaI1Ew26rjnx4A60NrgVUmoTO0AhZbZTHlLm+xbmkXo1dF1NFTIUTxK5ZjH/Vj4PqZR9k5spDzY19+ArqQbRAlITRFGhB6SKKaSIh1SFJtyNJNAEuAeD5kJJ0L1DaRVICpLWSkNvmj6nUvYiLg8pv+rJK+VqpOxl/cEr+ZVmaq4GD7eHlOyrKygUMoJM9QGBQ7MinytdDTCq7BW5nmstZQ8Avv+BhbjorfPw3mNmW38ej9RWkI1hmLGHxvdDzq9r4xnJMJOZrq4ubNy4EevWrRvrrlQc+ghyVRqeqND56syWuoCW3hpIBoRcT2662W2rskePlcr6FVKqyp7F2gNwm5X7quwVWS8wpUFVURNFYDJcOGWvBtFSfCbIBZyIlBOQ8tq6KheUiwpIFdQ/rsGgodBuIJX1PKEsfwL5kE4W5Le0m3KRIANO6azdqDyieUiFrW3tCim3qbkpr5WDU054A6HLx0lV+iu8Z0MJpuZS1psIaEt30Iqq48hxakXeetbCfXGWI38cMD2keAHJMExxSlEHT5DpAcMwNQqdo082hVQ4HMK+bfV4bc8g3n7ItMC2Xspefs7s2kyQn2Eyk1NqJXMsiFkUUp6HlEzZ81t75N9frgPsfrPyz1lKcSOmODZrlskKB6TKZDyYmk9EhRRdlJcTlDADNMOlsRAE2ysDUo7BoL7Qz8F01rfjQDE9pOhDX7Z2eUhlVJULqpAKaT+T2DykzJ2PbE6onRK/qXn+/5wQKnjm2sUyM+6CStjKz2/zjv7CMd3XKTVPDDomoAcrzc+tVpmIAWaGYaqLKyBF0/fYQ4phmLGETlmLVVGeiNx80SI8+3oP3nXkPoHtlKl5Rgak7O0SJHClFFKONnR9JN0+vJS9/P/mnr6qnmfM2b3MC70de0iNjBhX2VPw6qdMxoO0lgahJsoClqYtBZVGzbclZU2zlQlKyCBY31De2Nv1XJDtBqlCKqjKniVlTzaXfztfQMpmal5QA6UdwSuqFjJ3PjRjcTMgRdrKvrqCR+Z5BgWPzM/vtT2DzraxMtRx9OcD6eCKiLWCppCaIAFmhmGqi1MgxSl7DMOME6jvaaWKENUSh85sxrlvmV303KUiSSqUXM3jhaBeKpPzfGmNtjLIoafsmVX29NclqiK3z94j/79K2auBKnu1QHQCFikbLpP77GuURBl+S7WC9GYCgJY6t/EfoA9qlVJINRWCYHuLeEjJh+9AKouc8pDytzNNzWkcSS4SIsqoXB8QpMyWKpWiDoWU8puiHlKOahj5Y9qr7OWE8FL2HA9Fc3HTGBiQKn3iQXf0G4uo42gfpAl7rcMKKYZhyoU+Y3WDcw82NWcYZiw5YlbLWHehJpDzQLkx7K7KXAg2kZQ9s63ykMr410fhYil70tTcVwDJs/cASOCKA1IjIqoJDyb3eM0pezUIXbROlIfB9JaE+np2e33Jv1epgFSD6SHlVEjlP+9SU/bkQ1vAr5ByVdnzcrj9Znc+U/OcTO8jCilHrnci6q90J78Xwh4Io5hnObUpYW1na3vu0W4PJbqDVixljyLPq9ZJaEbtHJBiGKY4rrkrDU5xyh7DMGPJW+a243vv60TnnLax7sq4xlszFBRSjqkgNSwXXkTK2UZiZnS4UvaGHN5Q3lAiFVKyHc9ZKwV7SDE1B5X1lbOAH880xKP4748sxu6BNA6e0Vzy79l2AIZDIzErB4I8pAoBqVQmOGXPUEhppuaF/yMOU3Nb6pxUQPlMzS0V+eRX8i3l8WzXilJT5UTJpuaS6c3ugBRtGw4BV593pLMtpRzJKg1k1TIJzROOF5AMwxQn7FBFaV/z44RhmDEkFArhPEeFYcbD3MR2KqSI+kmuC8x9B7upef5/OSbQCtuUIbVeMD2kdIXUoKMaH1Me9OPnKntMWYwLU3Ny0U6kh8GJBwdXobBRaVNziWtjuV5TSMkqewEeUmm3ZFb6PpkKqaQ1ZS/fNmMopNJSIUWCGnJnJWfmeluUTzYPKddD0TzN6c3uMrZ0IXT2wn0Dy/0uPWQ64pEwDtun9EAk4FeL1SqJCegJxzBMddHS9BzjFafsMcz4ZzysK5ixJW4opFyP7jgJNoXD+Xm1L2XPUpXbqZAyji8DYuac3VRUyWAXK6QqR3SSV9nmK6lMxpup+URJ2RsulVZISVweSEohlc6RlD1/O6/KXv7hnrOYmitfKF9Ayq+Qiim/KcNDKiMKP/ebmsO3k+G/3TUPKUe5V9XWOFGaZuk/rte2qS447t3aEMP6ryzDLz9+fGA7yTuPnAkAuOit80pqP97hgBTDMOXiTtnzvuaUPYYZ/4yHdQUztsSNNYMrS0O1y+a8KnuulD2yPjLbhozXJYOOlD3Tm1ZuCPOcdWRQOxf2kGJqDj1lb3I/DCqlkTHNtIt6SKUyxNS83JQ9qZCye0glLR5SSoLr8JCikfWwMXAMBUhrPdkuSjA117+e2hi3tgP0/PfmIgGpfJtgI3vKN88+EqfNn4l3FimjWyvEtZS9yX0/MwxTGs6UPa6yxzAMU1MoU/MyquxJfAEpS8qeUBvoUiGlp+BJhhzKJ7VWKHwv/ak4IFU5Jvt4zQGpGiQRYRNkiWnIN1waE2bKnqPKXqkpe2q3oxCQIj+Th444VE/2lL3gKnuxiBEtgvfZBJVn1avs+ZVZelvvPaY0xAMN+DSFVKL0YFMptDfGcXaASXqtQf/OQZULGYZhJE6FFAlPTfLpAcMwTE0gN6BloMcVmqDpeGaQSbWJ2lL28v8rhZRKwfNWJ7mcUEEsM/uGthfCazfZ16BM5eArqQahwZO2erdKZTJgyk2Hi5my54pUNxQe0gOpbHDKnvKQCkjZC9t9oawpew4PKRmgihJJkqmQCkrZg1Uh5UjZI+fZ1hAcZKKpIsVS9iY7VBXVEOfPimGY4ugeUnY/KfaQYhiGGf/EI6VtitN0vJxj/SPXC8lMgIdU4XV6BNreX2XPWytQm5HJbsQ9UiolqpgI8OqnBolGwvjSOw/H06/14LgDpox1d8aUGa1uY+1y8HtI2dtJU/OhVFal2g03Zc9TSOV3HOSiIpnxK5pkel/a9JAq9IGm7JkDjUzZs/mN2T2kiiukWuuDA1I0F7qFA1KB0MCjqdRjGIaxEXYEoSiTPQWAYRimFvDZNTge3QkSkBJK9eRSSBH1k/SQKnwfNjIpAG/zGnAXzMoJoSmvYlwZekSYKZOTGQ5tlkl3dzfmz5+PRYsWjWk/Ln37AfjBBUcHpk1NZG668C1oSkTxpXceXpHjmalSrkesDOoMpLNKnRVsal54cNOAVKE9TbOjDyUVGCpDIUV3KULGQJMswUMqJ4BUNjhlL1RWQMo7RlOCA1JB0M+HFVIMw5RCKf6nbGrOMAwz/jEDUkUVUtmcWlaYLW2m5nIvW44JtpQ9uXkdj4R9YwcNYMliSrItM3yG0lxZU8KrnzLp6upCV1cXent70draOtbdmbScsWAfnH7EzIrtAJdcZU+ZmtOUvSAPqfzDhlZSkO3pAz+TyyESjmi/YwtI0Z2JbE6oPtDAZNgYaAYDA1Je22RaFN7XvjNCbaqKBqRI43IMyycj05q9aoWu645hGIZCvQt1U3PqIcXPE4ZhmPGOuRFczEMqr5ByVNlTRZC8YIdZAElmatAtbhkcsWVJ0Cp7yucqxGPMSOEpvweHNpmapZLpCLFIWEtpcx1btklmcuoBbw1IyXYFtVNOS9nLQ1VEtNKe8nKKUfP6/G+lSECKBqf0lD19oAkyNadqqmJV9mh/igWkqNEhK6SCoZ8Pj+0Mw5SCK3jtqrjHMAzDjE/KVUglM55Cym1q7q0r5BpD+grSAJMkePPaW1fQCnucFj4yPn7Sgdi/oxGXLz9srLsy5vBKkWEKNNVF1QPZFRigKVX9yUJbS/xGGoh7HlJ+U3O6s0AHDltgyAxwAbqxYCxMU/by/8uBZijA1Jy2lcosXy67cU4A0NoQbKZPPaSa2UMqkFAohA8dtx82bNmDMztnjXV3GIapAcKOyBObmjMMw9QWPoWU49Edj1oUUmabiD9lT64X/Cl73u95m9eWtQJke4F0xm8VwgyPGS11eODzS8e6G+MCXikyTIHmuije3JsE4B4M6KAxkMoAKGZqLlP2POSOAg3aUIXUYMq/S2GmAAKefxRgKKSMgaaUXY+c8AYjl0KqLlq6QorCAanifOPsBWPdBYZhagi3QopT9himluju7kZ3dzeyWfaTmayYwR1nQEql41FTc71NjLSRyDWGzMwIEcWTJBlQAIlmU6SVQorHF6ZycHiTYQpQryPXZD8cDqmHdV8yKCClK6RyllzvcDikdrkzpHqeDHQ1EKN1GUwaStOUPW8oiWp+IjLIJLTfCaqyJ4hCylVdo66MlL0ZLV71Q9Ofi2EYhhkZdCxxpelxOgXDjH+6urqwceNGrFu3bqy7wowRpm+T69kdUwqpLAkm2VP2ghRSptcsAAwFrAG8bAov0OXKpmCY4cArRYYp0Kx5+bgn8vXxCAbTWfSrgJS/TcKU1ToM0KPhMFLZnKaQGkj5dym8FEC/SWEsEtIGLzOFMBmUskeCV0FeU4A+YE5pDA5IzetoxOrzFyIWCWt+UgzDMMzICTvS9Ci8gc0wDDP+iUdKq/Sd0EzN86+Za5C4WeUbQE4qpExTcyKRGkwV1gCWwkYqgAWhNsN5bs9UEg5IMUwBmloWtLHsKaTygR5bWgQ1AE9mcsrU3GwZCYeALJApPOCzOaEGEaoskgNEOiuQzQlEwiH1O1EjAmUONEEpeyq9D6TChtNDyvv9KY0JaxvK2UfvW7QNwzAMUz6ubDz6MqfsMQzDjH/MDeNipuapbM6aeUGPJef0QICHFPk95Tcbt6wV1Oa1p7xiDymmkvDVVCbd3d2YP38+Fi1aNNZdYSoMrXYWlOpQX3hYy9Q6W1sa1MlXw8g/9v0Kqfz3crCQxwTsKXuAN2hI2WzU2AZ3m5oHe0jJQcapkCLnNLUx2NScYRiGqR5hS5o2wCl7DMMwtcYUY05dkqm5bGtsdcsNbBqQyhYyKqJGQCpnS9mzbEqrfW8hiIcUhxCYysFXU5lwrvfERfeQcreTgaKglL0o8YdKZrJKIWVKpCKFYJIcLKSheShkVNkjX8tBJuOQzVLzQaCYqXn+/3zKnju1DwCmN3u+UNNbiiukGIZhmOrgDjaxqTnDMEwtMa1Zn1M7FVK0gp5TIeWvyp0yMirsKXsB2RRUISUDUlEeX5jKwSl7DFOgqa40D6k6w9TcNukPhUJIRPNeU8l0Tg0YZlM5OHgKqfyA0BiPGr5QIcQjeb+poYKSyVXpIuxTSLlNzb3glVDHTVjyx4H8gPnLjx+P9oa4sw3DMAxTfcKaEsr+NcejGIZhxj9NiSga4xH0p4IrLcoMjcG0Z2puLlfq44WUPeI5q9LsomHf7wghEAqFlF2I1W+WmKCnM6yQYioPX00MU6Ap4QVZgjIdGlTKnlQz2RsniBG5Ks9qSKRUyl5h96K/kLJXb8nhThh54Zmcy0MqjxysgpRPXqWNYPNzyaJ5U3DQ9CbnzxmGYZjqo5mak9dDjjYMwzDM+CQUCuGQmc3qe9ezW3rL9ifJusJoa0vZkwWRZECKHl8eR7YP2rzOCa/CN3tIMZWEryaGKdAQJx5SzhoX1NRcpuw5AlJRGUByV8OQ6ipZZU9KZhssASlThptxKKSo6in//qUMMp5CyuUhxTAMw4wPSlE/cUCKYRimNth/aqP62vXoll63e4fSnqm50UYWVRqiKXsqAyLs+x3/5nVQlT0vOyPuKIDEMMOBryaGKdBIFFJBk30Z2JEeUq7S2jKtLV9lT+Z6GwqpiDQ1zz/gperKFjxSlTMKOx1ylyJq7FJQ1RPgDUpBpuapTE4FxVxV9hiGYZjxAR1LXEbm7CHFMAxTG1Bjc9ejW1YD708FKKQKa4XBdOkpe7R9wuoh5bVNccoeUwX4amKYAo3x0jykZDpd31BpCqlkxp3rHTFS9mSVvcaE397NlOHKXYqob+QqKKQK3w0GpOLJ/tCBixVSDMMw4xvXuKOl73E8imEYpiaY2uQZm7usQKRCKpsTat5utqyL+VP25Ma03Cinx88Zm9e2DfGwyrwgpuau3XiGGQYckGKYAjQIFA64M+SAIM0HXbJVz0Mq55TWxgpvlDVMzW0pe+p4MmUvZ9+l8JuaF5fhDhJpLyukGIZhxjeaqTnsailWSDEMw9QG7Q1epW/XZkJDPKJ+1juUBuBXU9mq7KnN7rgMSHntBcy1gmUNQNYVXkElXiswlYOvJoYpoKuS3BP5fdvrte+jjl0ClbJHPaSMkUMppIyAlDVlz6eQyv+O30Mq/78QQC4nSOUMt4fUYGGwikfDAeXEGYZhmPGAppByVtnjZznDMEwtQIsZuXxsQ6EQmgrZHL2DGfWadpzCXD+Vzfk3uwvrHM1DyjA1D7L3YA8pplrw1VQm3d3dmD9/PhYtWjTWXWEqTGO8NA+puVMatO9duwRayp5DISWDWXLQ2FtIA2yui8FEyXALHlIZp4eUZ2oug1FAsAx3z0B+p6XF8r4MwzDM+MIVa6ILGQ5IMQzD1AY0EBQkPmqq84zNAVvKnvfLsrqemX1hr7KX8/2+RLbOK6S4yh5TefhqKpOuri5s3LgR69atG+uuMBWmIVGah9R+pBIG4H4oK9lsJqf8nMzjSoWU3HGQA4w0LtSPp6fsuXYzlEIKeg55UMre7oEUAKCtgQNSDMMw4x06lrhGK87YYxiGqQ3opnEkYA3iVdrLb2CbA4DMpgC8IJNM2WsoIWWvmIdUkk3NmSrAVxPDFGgipubSn8nGvm312kS/uEKKVtnT20gPKZmyJ3PCWywBqYRhVCiVUnWGbFbukOeI6WE8Erb6icj+yB2PtnoOSDEMw4x3nJsm7CHFMDUFZ14wgJGyFxCQavYppPS24XBIbZTLNYCnkIr6fkcppDIBVfaUFQh7SDHVga8mhinQkPAewoOprLNdPBpGB6mG4TQ1lwGptLs8ayxqKqTyuxgtlsCQ8pAq7E7IPtbHiyukEjaTQvgXNayQYhiGGf9opuYOtZTpWcgwzPiDMy8YwFBIBTy7mwrWGr2q0re/jZzzyzVAf9Jtai43zOWagiqsJCGikEpLhVSUxxemcnBAimEK0Gj/YNodkAKAma116mtbRTyAmJoHVdkrvGcqowekbCl75gCjzMqjZkDKGzgGA0wKaVtJa33c2o5hGIYZP7iCTfSZzh5SDMMwtUFdiQEpuT7oHSwopCxN64yMij2Ftq2FTWc9ZQ+FtgEeUqrKnreBnmCFFFNB+GpiGAuDaXfKHgBMb/YCUnp1Pg8ZQEpmSJU9Y+SQslqZMud5SAUopNLBCqmwGjiEamvLCadtJa2csscwDDPucXlI0a+DfEgYhmGY8YOesuduJy09eh0pe4A35x9K5yCEQE8hINXWEPf9jlyfSAN0c00BeGsFAYGUqvDNIQSmcvDVxDAW0pnggNTMVi9lzxmQ0qrs5V/zeUhFZUAq/36yjKut2p1UYg0WzAld6Xj0LTzjc/utbg5kNmUWwzAMM77QU/aKt2EYhmHGL9QP1hZkkkhTc7nhbFPLekWQshhK51QWhvSJpb8iSknZk960RCEVc9iVMMxw4KuJYSzIB66LGUQh1dFoT3NTKXvpnKpi4VJIeSl77ip7MvDVl8wPGoOOihgyZSOvkHJXzcj3R/+eA1IMwzDjH1c6Hn2ZPaQYhmFqA6pMClqDmBkUNqGSTNkbTGexZzBfRTsaDpEqezZT85z2uxQ1lAih1iuskGIqCV9NDGOhWEDqkJnN6us5UxqsbfQqe/bjqIBUtriHVFPBdH1AKaTsg4dXDcNrY6uakW+rL1hcai+Gmcx897vfxRFHHIEFCxbgf/7nf8a6OwyjBZ60r8nOOntIMQzD1AZUmSTT52w0GfN023OeWnzsGZDpejE156e/IZBf82QLCxXbBra30e2tj+IRHl+YysGrT4axID2dXJx0yDS89cCpmNVWj9nt9dY2nodUVkliw0YImFbZy+YE9ibdVfZkuda+pJ6y51NIEWltMVNzcwPdHOgYZrLz9NNP47bbbsP69eshhMDJJ5+Md7/73WhraxvrrjGTmFIUUryBzTAMUxtQRWsqwDaklIAULYIk/aOoR6xZZW+IFHJyVeUG8h5SKmWPBximgvDqk2EszOuwq54kdbEIbrv0uMA2epW9/GtmXjitsicDTUBwyl6/EZAy/aGo+aAXtHJ4SBkDGQekGEbnueeew/HHH4+6unyabmdnJ+6991584AMfGOOeMZMZ3dTcYXDOCimGYZiaI2hT3MxksFXkU1X2MlmikPLsRcyUPbl5HQp52R2UMFFISVPzOHtIMRWEryaGIfzvJ96Kc9+yL772ngUjPpZK2UvnAOUhpbeJE1NzWcI1EQ2rYBZFBosGUrqHVHDKXpkKKfaQYmqMhx56CGeeeSZmzZqFUCiEu+66y9emu7sb8+bNQ11dHZYsWYLHH3+85OMvWLAADz74IPbs2YPdu3fjwQcfxGuvvVbBM2CY8nGamlOFFAekGIZhao5kgEKqIWGvrE2pI1X2dg/kPaTajMyLENm8Tkp7j2jYupEhX8oJgVQhnTDKCimmgvDqk2EIx+zXjmP2a6/IsWjKnlJIOUzN01mhBo0pDpN0OQiZKXtmsEnuZIiSTM0ND6k4PxKY2qK/vx+dnZ245JJLcO655/p+fvvtt2PVqlW46aabsGTJEqxevRqnn346XnjhBUyfPh0AsHDhQmQyGd/v3nfffZg/fz4+9alP4ZRTTkFrayuOO+44RCL2+4lhRotS1E/sIcUwDFN7SJsPG76UPUtEqp6k7MliSdNb6rQ2IRS2yoXbAkQSLbxHLic8/1pWSDEVhFefDFMltCp7KiClt5EBqWQmh139+YBUe4M9IOVXSOUHBX+Vvfz/QuTluoBbIWX2h6vsMbXG8uXLsXz5cufPr7vuOlx66aW4+OKLAQA33XQT7r77btx88824/PLLAQAbNmwIfI+Pfexj+NjHPgYA+Od//mccfPDBzrbJZBLJZFJ939vbW+qpMEzJuAroaabmvF5gGIapGc59y774/TNb0XXyQc425saxTQnrKaSy2NGXn4/MaElobcKhEHJClOQ3GyOb58UyLxhmOPB0pUy6u7sxf/58LFq0aKy7woxzvCp7WeQKESlz2IiRlL1iCimZN15MIQViau6qxKdacpU9ZgKTSqWwfv16LFu2TL0WDoexbNkyrF27tuTjbN++HQDwwgsv4PHHH8fpp5/ubHv11VejtbVV/ZszZ87wT4BhHNh8QwB9k4EVUgzDMLXD997XifVfeYezejfgV0gFekils9jaMwQAmGkqpDS/2eC1gheQyql0Qg5IMZWEA1Jl0tXVhY0bN2LdunVj3RVmnENNzaVCylwg0If8rv68rLbdFZCK54+XyuSQzuacElubqblpfG62Ve+R4AGGmTjs2LED2WwWM2bM0F6fMWMGtm7dWvJxzjrrLMyfPx8XXnghfvzjHyMadQdur7jiCvT09Kh/W7ZsGXb/GcYF3UzQviZtXEErhmEYZvwRCoWKBnpMDylb+rZMpxtK57CtVyqkzJQ9ae9RXCEVjXgVwYutKxhmOLAcgmGqRF3MS8eT+eC+lL2oV2VvdyFlb0qDbjwoaSAy3YFklgwg+qDgmQ8WH2RogCwesZupM8xkpxw1VSKRQCKRKN6QYUaAWyFFUvZYIcUwDDOh8CmkLM/5BFVI9eYVUtONlD1qVC6rdzc5NqXjnLLHVBkObzJMlfA8pLKQ9oTmAiFOdh12qZQ9+2I2Hg2rQaEvlSlqag7hVc5wGRXS7rA6iplodHR0IBKJYNu2bdrr27Ztw8yZM8eoVwwzcrQqe+R1PWVv1LrDMAzDjAKJaFjbkLAVu5Prgh19SeVPa6YBUr9ZaQXisu2IaQopaWrOawamcnBAimGqRIIopHKOihkxYmquFFKNdoUU4AWN+pMZNSjUxw35buF/AThVVF5bb1BrYkNzZoIRj8dxzDHHYM2aNeq1XC6HNWvW4Pjjjx/DnjHMyAhrKXv2NjEuy80wDDOhCIVCysIDACKW6hVyE/q5N/YCADqaEmip09cWdP7fXywgRbI5vGJJPL4wlYNXoAxTJTxTc7eHVDxKPaQKVfYcHlJAfrDYPZDGzr6Ues1USMmUjZwoLq2lO+hm5Q6GqQX6+vqwadMm9f3mzZuxYcMGTJkyBXPnzsWqVauwYsUKHHvssVi8eDFWr16N/v5+VXWPYWoRVzpeNudtfpipHQzDMEzt05iIoncoH0SS6wiKDBbJdL0DOhp9bcK2lD3HOiBWCHr1pzJqPZPglD2mgvBshWGqhGdqTqrsGWsIWkq1ZzBvaj6lISAgVRgsdvZ7ZeXronYPqVKMCsMkItXMCimmBnniiSdw8sknq+9XrVoFAFixYgVuueUWnH/++XjzzTdx5ZVXYuvWrVi4cCHuvfden9E5w9QSdFOc7nTTIYarpjIMw0w86LPdHpDS5/z7WwJScvM6n7KX9R2XEovm276xJx/gikfCaOE1A1NB+GpimCqRiHrBJrlr7feQ8mSw2x3GgxSZsicVUrFICFEjLUMuTnICRUu50jx0XrwwtcjSpUtV0QAXK1euxMqVK0epRwxTfWxGtgBw7Lwp+OCSuZjaGLcuVBiGGRnnnHMOHnzwQZx66qm444471Ot79uzBsmXLkMlkkMlk8OlPfxqXXnrpGPaUmajQ+XoiQCElect+bb421N6jmKm53Dz/x45+APkAl626H8MMF16BMkyVSJABQQaGXFX29g6llfx2WrNempUiB6EdfXmFlC3QJGNMAgLJgkLKZWpOdzja6t3eVQzDMMz4IeTwkIqEQ/jWOUeOQY8YZnLw6U9/Gpdccgl+8pOfaK83NzfjoYceQkNDA/r7+7FgwQKce+65mDp16hj1lJmo0Lm7NSBlGI4fd4D/GrRV2XObmuvvceLBHWX1l2GKwdtnDFMl4hEakMoHhswdBfmQf13KYKPBMlhpSri91x2Qsqfs2W91anLYygEphmGYmsBVZY9hmOqydOlSNDc3+16PRCJoaMhXMksmkxBCFFXvMsxwmN1er762rQOov9M+rXWYa1TYA8yUvdKq7ElmtdVb2zHMcOGAFMNUiWgkjGhh1SADQ+bCQSqkUtm8gmp6cyJQBtvakA8avVFI77Mpn8JqkPFMzZ0KKRKE4opMDMMwtQFNt2YYJs9DDz2EM888E7NmzUIoFMJdd93la9Pd3Y158+ahrq4OS5YsweOPP16x99+zZw86Ozsxe/ZsXHbZZejoYCUJU3nmTfU8oaZaCiE1kCp8xx0w1bqu8F4SGEjl1wquQhjxiL6GaGvgDWymsvAKlGGqiJTSysCQuYYwA0XTm93+UYCXVre1ZxCAQ/lUhqk5lfpGIrzAYRiGqQXCjpQ9hpnM9Pf3o7OzE93d3daf33777Vi1ahWuuuoqPPnkk+js7MTpp5+O7du3qzYLFy7EggULfP9ef/31ou/f1taGp556Cps3b8Ztt92Gbdu2VezcGEay9NDpAPIbE/tN9RuWz2r1FExvO8geFA2HPL/ZYgqp+ri+huCMCqbSsIcUw1SRRCyC/lTWmbJnPtSnB/hHAd6uxNYet0JKmppnhShqah4KhbBoXjueeHk3zjxqVrHTYRiGYcYBHIRiGD/Lly/H8uXLnT+/7rrrcOmll+Liiy8GANx00024++67cfPNN+Pyyy8HAGzYsGHE/ZgxYwY6Ozvx8MMP473vfa+1TTKZRDLpVUzu7e0d8fsyk4NDZzbjRyuORTgUwjTLRnZrQwz/fML+eGHbXrzzyJnWYyhTcy0gZV8rmK9zQIqpNByQYpgq4imk8oEhUyHVUq/fgkEV9gCgrT4vzZUG6IkAU/NkJqdec3lIAcB/rViEbb1DOGSG3xOBYRiGGX/oKXscnWKYYqRSKaxfvx5XXHGFei0cDmPZsmVYu3btiI+/bds2NDQ0oLm5GT09PXjooYfwiU98wtn+6quvxte+9rURvy8zOTn18BmBP//yu+cH/lz5zUJgz0C+cnd7gz/9DwAa4/pahVP2mErDKXsMU0VkQMrzkNIXDvWxiGYWWDRlzxgErAqpwuFk1QxXO0lrfYyDUQzDMDVEmCVSDFMWO3bsQDabxYwZ+kJ+xowZ2Lp1a8nHWbZsGd73vvfhnnvuwezZs1Uw6+WXX8aJJ56Izs5OnHjiifjkJz+JI490V7y84oor0NPTo/5t2bJleCfGMMNAZmzkcsCegTQAd6DJTOVrYYUUU2FYIcUwVSRRKL3qpezpPw+FQpjSGMe2QtW8YpUr2ozdC5vySS5UdhcGmMZ4BFE2LGcYhpkwsIcUw4wN999/v/X1xYsXl5Xul0gkkEgEb0IyTLWQw0ZfMoNMLl8NUmZhmDSwhxRTZXiVyjBVJBEzFFKWhcNxB0xVXx8wrSnweCUppAr/9xQkuGYQi2EYhqltuMgew5RHR0cHIpGIz2h827ZtmDnT7rPDMBMVuR7Z1Z9fKySiYZ95uYQWQMp/7866YJjhMCkCUueccw7a29t9xoJ79uzBscceqypq/PCHPxyjHjITlTpDIWVLs7j0xAMQDYcwvTmBw2YGp861GbsSVrNyQyHF0lqGYZiJBR1LhBjDjjBMjRCPx3HMMcdgzZo16rVcLoc1a9bg+OOPH7N+dXd3Y/78+Vi0aNGY9YGZfHjZFHLz2r1WMAsyMUylmRQpe5/+9KdxySWX4Cc/+Yn2enNzMx566CE0NDSgv78fCxYswLnnnoupU6c6jsQw5aEUUim3QmrBvq24f9VJaKqLOqvhSVobigek5M65HGRa6yfFbc4wDDNpCIdpQIojUgwDAH19fdi0aZP6fvPmzdiwYQOmTJmCuXPnYtWqVVixYgWOPfZYLF68GKtXr0Z/f7+qujcWdHV1oaurC729vWhtbR2zfjCTCzmC7C5iaM4wo8GkWKkuXboUDz74oO/1SCSChoYGAPnyq0IIntgxFcVfZc++yzCvo7HE40XQlIiqEq22gJQ0Tt9bqMTHud4MwzATC5qyl+NpC8MAAJ544gmcfPLJ6vtVq1YBAFasWIFbbrkF559/Pt58801ceeWV2Lp1KxYuXIh7773XZ3TOMBMdqXra3S83r4PXCkfPbcNfX9mDqY0cuGIqz5in7D300EM488wzMWvWLIRCIdx1112+Nt3d3Zg3bx7q6uqwZMkSPP744xV7/z179qCzsxOzZ8/GZZddho6Ojoodm2FknrX0kKoEtBKfzUPK9BbhgBTDMMzEIkIe9DneSGMYAPkNaLm5TP/dcsstqs3KlSvx8ssvI5lM4rHHHsOSJUvGrsMMM0Z4HlLBFfYkn3vHoThsZjO+/4Gjq901ZhIy5gGp/v5+dHZ2oru72/rz22+/HatWrcJVV12FJ598Ep2dnTj99NOxfft21UZ6QJn/Xn/99aLv39bWhqeeegqbN2/Gbbfd5jM7ZJiR4CmkZMreyPOwO0hAqjFhUUhxQIphGGZCo3lIjWE/GIYZGewhxYwFIcPeo1jK3gkHd+Dez7wdJxzMwg2m8ox5yt7y5cuxfPly58+vu+46XHrppSq/+6abbsLdd9+Nm2++GZdffjkAlFVm1cWMGTPQ2dmJhx9+2Gd+DuRT+pLJpPq+t7d3xO/JTHxkxQqZPhetQGkkqpBqrvPfwmbQiwNSDMMwEwv6mGerAYapXdhDihkLpL2HrLJnetQyzGgy5gqpIFKpFNavX49ly5ap18LhMJYtW4a1a9eO+Pjbtm3D3r17AQA9PT146KGHcOihh1rbXn311WhtbVX/5syZM+L3ZyY+csfhzb58MDNSgYDUNBKQakr4BxBTIdWYGPO4M8MwDFNBIiFO2WMYhmGGh1kAiU3NmbFkXAekduzYgWw26zMbnDFjBrZu3VrycZYtW4b3ve99uOeeezB79mwVzHr55Zdx4oknorOzEyeeeCI++clP4sgjj7Qe44orrkBPT4/6t2XLluGfGDNpkDnZqUze1LwSCiktIGVTSEF/j8Y4B6QYhmEmEjRlL5cbw44wDMMwNYfMppAKqXZWSDFjyKRYqd5///3W1xcvXlxyul8ikUAikSjekGEIU4xqFJVQSE1vrlNfN1k8pMy3kGmDDMMwzMRAS9kbu24wDMMwNYgcQqSlyJRGXuMyY8e4Vkh1dHQgEon4jMa3bduGmTNnjlGvGKZ0TAlsJRRSs9q8gBQNTknMlL0GDkgxDMNMKEKcsscwEwI2NWfGAnOtYG6gM8xoMq4DUvF4HMcccwzWrFmjXsvlclizZg2OP/74MekTDxxMOZhlVMMVCEi9ZW47Tjy4A6cfMQOz2+t9Pw8bowwrpBiGYSYubGrOMLVLV1cXNm7ciHXr1o11V5hJhFkAiQNSzFgy5il7fX192LRpk/p+8+bN2LBhA6ZMmYK5c+di1apVWLFiBY499lgsXrwYq1evRn9/v6q6N9pwNQymHKYaEthKKKTqYhH890eWOH+eiOpx5gb2kGIYhpmw5DgexTAMw5SBuRrhgBQzloz5SvWJJ57AySefrL5ftWoVAGDFihW45ZZbcP755+PNN9/ElVdeia1bt2LhwoW49957fUbnDDMemdpkekhVX5QYi+jv0cgKKYZhmAkLp+wxDMMw5UCzKWKREFosRZIYZrQY86tv6dKlReXmK1euxMqVK0epRwxTORriESSiYSQrWGWvGHFDIcUpewzDMBMXVkgxDMMw5UAz9tob4r4UPoYZTca1h9R4hD2kmHIIhUKYSmSw0Uj1H/imQopT9hiGYSYu7CHFMLULryuYsYbT9ZixhgNSZcLmg0y5TG3yfKTqYtVXK5kKKa6yxzAMM3HheBTD1C68rmDGApqyZ9qLMMxowwEphqkydOfBNByvBnGikAqFRuc9GYZhmLGBPaQYhmGYcqAZelOMAkwMM9rwSpVhqowekBpdhVRjPMp54QzDMBMY9pBiGIZhyoEuDaZyyh4zxnBAqkw415spFxqQqouNbpU9NjRnGIaZ2LCHFMMwDFMONGWPPaSYsYYDUmXCud5MudAHfUtdrOrvRxVS7B/FMAwzseGUPYZhGKYcaO5EOwekmDGGA1IMU2W0gFR99QNSMVLJr34UTNQZhmGYsYPjUQzDMExZUFNzDkgxYwwHpBimyuw3pUF9PaOl+saBtJIfK6QYhmEmNuwhxTC1C1uBMGNBmEikpjezqTkztnBAimGqzMK5behoSmCf1jocMqO56u/XRlRYjYlo1d+PYRiGGTs4ZY9hahe2AmHGmpmtdWPdBWaSw6vVMunu7kZ3dzey2exYd4WpERriUfz+MyciHApp6qVq0UoCUmGusMcwDDOhYVNzhmEYphz2DmXU19ObOSDFjC2skCoT3slghsPUpsSomQZGI3xbMwzDTBY4ZY9hGIYph57BtPqaFkNimLGAr0CGmcBEwqyQYhiGmciwQIphGIYph8FUPtOHEymY8QAHpBhmAvKJpQeiKRHFZ5YdPNZdYRiGYarAWQtnIRYJ4QOL54x1VxiGYZga4jvvPQqxSAhXn3PkWHeFYRASbD4wLHp7e9Ha2oqenh60tLSMdXcYxkcmm+P0PaYk+HlWPfizZaqFEALprOB0C2bU4OdZ9eDPlhlt0tkcYrxOYKpAuc8zNjVnmAkKB6MYhmEmLqFQCPEo51swDMMw5cPBKGa8wFdimXR3d2P+/PlYtGjRWHeFYRiGYRiGYZgahdcVDMNMdjhlb5iwtJZhmIkCP8+qB3+2DMNMFPh5Vj34s2UYZqJQ7vOMFVIMwzAMwzAMwzAMwzDMqMIBKYZhGIZhGIZhGIZhGGZU4YAUwzAMwzAMwzAMwzAMM6pwQIphGIZhGIZhGIZhGIYZVTggxTAMwzAMwzAMwzAMw4wqHJBiGIZhGIZhGIZhGIZhRhUOSJVJd3c35s+fj0WLFo11VxiGYRiGYRiGYRiGYWoSDkiVSVdXFzZu3Ih169aNdVcYhmEYhmEYhmEYhmFqEg5IMQzDMAzDMAzDjDKcecEwzGQnOtYdqFWEEACA3t7eMe4JwzDMyJDPMflcYyoHjxUMw0wUeKyoPF1dXejq6kJPTw/a2tp4rGAYpuYpd6zggNQw2bt3LwBgzpw5Y9wThmGYyrB37160traOdTcmFDxWMAwz0eCxovLwWMEwzESj1LEiJHibY1jkcjm8/vrraG5uRigUKvn3ent7MWfOHGzZsgUtLS1V7OHYwOdX2/D51TbDPT8hBPbu3YtZs2YhHOZM7koy3LFitOF7o7bh86ttauX8eKyoHryusMPnV9vw+dU2o7WuYIXUMAmHw5g9e/awf7+lpWVCXrgSPr/ahs+vthnO+fFud3UY6Vgx2vC9Udvw+dU2tXB+PFZUB15XBMPnV9vw+dU21V5X8PYGwzAMwzAMwzAMwzAMM6pwQIphGIZhGIZhGIZhGIYZVTggNcokEglcddVVSCQSY92VqsDnV9vw+dU2E/38mOox0a8dPr/ahs+PYexM9GuHz6+24fOrbUbr/NjUnGEYhmEYhmEYhmEYhhlVWCHFMAzDMAzDMAzDMAzDjCockGIYhmEYhmEYhmEYhmFGFQ5IMQzDMAzDMAzDMAzDMKMKB6QqzK5du/BP//RPaGlpQVtbGz7ykY+gr68v8Hc+9rGP4cADD0R9fT2mTZuGs846C88//7z6+VNPPYULLrgAc+bMQX19PQ4//HB8//vfr/apWKnG+QHAK6+8gne9611oaGjA9OnTcdlllyGTyVTzVKyUe367du3CJz/5SRx66KGor6/H3Llz8alPfQo9PT1au3Xr1uHUU09FW1sb2tvbcfrpp+Opp56q9ulY+1uN8wOAW265BUcddRTq6uowffp0dHV1VfNUnFTzHAFg586dmD17NkKhEPbs2VOls3BTjfMbT88YpjoM59k9NDSErq4uTJ06FU1NTTjvvPOwbds2a9tauy+A4uc31vdFd3c35s2bh7q6OixZsgSPP/54YPtf/vKXOOyww1BXV4cjjzwS99xzj/ZzIQSuvPJK7LPPPqivr8eyZcvw97//vZqnEEglzy+dTuOLX/wijjzySDQ2NmLWrFn48Ic/jNdff73ap+Gk0n8/ysc//nGEQiGsXr26wr1mxppyrpsf/vCHOPHEE9He3o729nYsW7ZMa1/r90Wx8zMZD/dFNc7vueeew3ve8x60traisbERixYtwiuvvFLN03BS6fPr6+vDypUrMXv2bNTX12P+/Pm46aabqn0agZRzjr/61a9w7LHHoq2tDY2NjVi4cCH++7//W2tTy2NvsfOr2DNGMBXljDPOEJ2dneIvf/mLePjhh8VBBx0kLrjggsDf+Y//+A/xpz/9SWzevFmsX79enHnmmWLOnDkik8kIIYT40Y9+JD71qU+JBx98ULz44oviv//7v0V9fb24/vrrR+OUNKpxfplMRixYsEAsW7ZM/PWvfxX33HOP6OjoEFdcccVonJJGuef39NNPi3PPPVf85je/EZs2bRJr1qwRBx98sDjvvPNUm71794opU6aIiy66SDz//PPimWeeEeedd56YMWOGSKVSo3FaimqcnxBCfO973xOzZs0SP/3pT8WmTZvEU089JX79619X+3SsVOscJWeddZZYvny5ACB2795dpbNwU43zG0/PGKY6DOfZ/fGPf1zMmTNHrFmzRjzxxBPiuOOOE29961utbWvtvhCi+PmN5X3x85//XMTjcXHzzTeLZ599Vlx66aWira1NbNu2zdr+kUceEZFIRHznO98RGzduFF/+8pdFLBYTTz/9tGpzzTXXiNbWVnHXXXeJp556SrznPe8R+++/vxgcHKz6+ZhU+vz27Nkjli1bJm6//Xbx/PPPi7Vr14rFixeLY445ZjRPS1GNv5/kV7/6lejs7BSzZs0S//7v/17lM2FGk3Kvmw9+8IOiu7tb/PWvfxXPPfecuOiii0Rra6t49dVXhRC1f18UOz/KeLgvqnF+mzZtElOmTBGXXXaZePLJJ8WmTZvEr3/9a+cxq0k1zu/SSy8VBx54oHjggQfE5s2bxX/8x3+ISCQyZmuIcs/xgQceEL/61a/Exo0bxaZNm8Tq1atFJBIR9957r2pTy2NvsfOr1DOGA1IVZOPGjQKAWLdunXrtd7/7nQiFQuK1114r+ThPPfWUACA2bdrkbPMv//Iv4uSTTx5Rf8ulWud3zz33iHA4LLZu3ara3HjjjaKlpUUkk8nKnUARKnV+v/jFL0Q8HhfpdFoIIcS6desEAPHKK6+oNv/3f/8nAIi///3vlTuBIlTr/Hbt2iXq6+vF/fffX/E+l0u1zlFyww03iJNOOkmsWbNmTBbe1T4/ylg8Y5jqMJzrZs+ePSIWi4lf/vKX6rXnnntOABBr167V2tbifVHO+VFG675YvHix6OrqUt9ns1kxa9YscfXVV1vbv//97xfvete7tNeWLFkiPvaxjwkhhMjlcmLmzJni2muvVT/fs2ePSCQS4mc/+1kVziCYSp+fjccff1wAEC+//HJlOl0G1Tq/V199Vey7777imWeeEfvttx8HpCYY5V43JplMRjQ3N4uf/OQnzja1dF+YuM5vvNwX1Ti/888/X1x44YUV7+twqMb5HXHEEeLrX/+61u4tb3mL+NKXvlSZTpfJSM9RCCGOPvpo8eUvf1kIUftjrw16fjaG84zhlL0KsnbtWrS1teHYY49Vry1btgzhcBiPPfZYScfo7+/Hj3/8Y+y///6YM2eOs11PTw+mTJky4j6XQ7XOb+3atTjyyCMxY8YM1e70009Hb28vnn322cqeRACVOD8g/7dpaWlBNBoFABx66KGYOnUqfvSjHyGVSmFwcBA/+tGPcPjhh2PevHmVPg0n1Tq/P/zhD8jlcnjttddw+OGHY/bs2Xj/+9+PLVu2VPwcilGtcwSAjRs34utf/zpuvfVWhMNj8+is5vnZ2oz2M4apDsO5btavX490Oo1ly5ap1w477DDMnTsXa9euVa/V6n1R6vmZjMZ9kUqlsH79eq1v4XAYy5Ytc/Zt7dq1WnsgP47K9ps3b8bWrVu1Nq2trViyZEng+VaDapyfjZ6eHoRCIbS1tVWk36VSrfPL5XL40Ic+hMsuuwxHHHFEdTrPjBnDuW5MBgYGkE6nA59RtXRfmNjOb7zcF9U4v1wuh7vvvhuHHHIITj/9dEyfPh1LlizBXXfdVY1TCKRaf7+3vvWt+M1vfoPXXnsNQgg88MAD+Nvf/obTTjut4udQjJGeoxACa9aswQsvvIC3v/3tAGp/7KXYzs/GcJ4xHJCqIFu3bsX06dO116LRKKZMmYKtW7cG/u4NN9yApqYmNDU14Xe/+x3+8Ic/IB6PW9s++uijuP322/HRj360Yn0vhWqd39atW7VgFAD1fbHjVpKRnJ9kx44d+MY3vqH9bZqbm/Hggw/if/7nf1BfX4+mpibce++9+N3vfhcYEKg01Tq/f/zjH8jlcvjWt76F1atX44477sCuXbvwjne8A6lUqqLnUIxqnWMymcQFF1yAa6+9FnPnzq1on8uhWudnMlbPGKY6DOe62bp1K+LxuG9CMWPGDPU7tXxflHJ+JqN1X+zYsQPZbNY6LgadT1B7+X85x6wW1Tg/k6GhIXzxi1/EBRdcgJaWlsp0vESqdX7f/va3EY1G8alPfarynWbGnOFcNyZf/OIXMWvWLF9wU1Jr94WJ7fzGy31RjfPbvn07+vr6cM011+CMM87Afffdh3POOQfnnnsu/vSnP1X8HIKo1t/v+uuvx/z58zF79mzE43GcccYZ6O7uDgx4VIvhnmNPTw+ampoQj8fxrne9C9dffz3e8Y53AKj9sRcIPj+T4T5jOCBVApdffjlCoVDgP9Oku1z+6Z/+CX/961/xpz/9CYcccgje//73Y2hoyNfumWeewVlnnYWrrrqqYtHj8XR+1WA0zg8Aent78a53vQvz58/HV7/6VfX64OAgPvKRj+Btb3sb/vKXv+CRRx7BggUL8K53vQuDg4Mjft+xPr9cLod0Oo0f/OAHOP3003HcccfhZz/7Gf7+97/jgQceGPH7AmN/jldccQUOP/xwXHjhhSN+DxtjfX6UajxjmOowWteNi4lyX5QC3xe1Qzqdxvvf/34IIXDjjTeOdXcqwvr16/H9738ft9xyC0Kh0Fh3hxmHXHPNNfj5z3+OO++8E3V1db6f1/p9YTu/iXRf2M4vl8sBAM466yx89rOfxcKFC3H55Zfj3e9+95gbf5eL6/q8/vrr8Ze//AW/+c1vsH79enzve99DV1cX7r///jHsbXk0Nzdjw4YNWLduHb75zW9i1apVePDBB8e6WxWj1PMbyTNm9OQZNcznPvc5XHTRRYFtDjjgAMycORPbt2/XXs9kMti1axdmzpwZ+Putra1obW3FwQcfjOOOOw7t7e248847ccEFF6g2GzduxKmnnoqPfvSj+PKXvzzs8zEZ6/ObOXOmz+FfVjoqdtxSGI3z27t3L8444ww0NzfjzjvvRCwWUz+77bbb8NJLL2Ht2rUqpeW2225De3s7fv3rX+MDH/jA8E6swFif3z777AMAmD9/vnpt2rRp6OjoqFgVkLE+xz/+8Y94+umncccddwDIy1YBoKOjA1/60pfwta99bRhn5THW5yep1jOGqQ7VvG5mzpyJVCqFPXv2aCqibdu2qd+p5fuilPOTjPZ90dHRgUgk4qtoaOubZObMmYHt5f/btm1Tz2z5/cKFCyvY++JU4/wkckL88ssv449//OOoq0CA6pzfww8/jO3bt2tKxGw2i8997nNYvXo1XnrppcqeBDPqDOe6kXz3u9/FNddcg/vvvx9HHXWU7+e1el9IXOc3nu6LapxfR0cHotGoNr8GgMMPPxx//vOfK9f5EqjG+Q0ODuJf//Vfceedd+Jd73oXAOCoo47Chg0b8N3vftep9KsWwz3HcDiMgw46CACwcOFCPPfcc7j66quxdOnSmh97geDzk4z4GVOy2xRTFGms+sQTT6jXfv/735dtODw0NCTq6+vFj3/8Y/XaM888I6ZPny4uu+yySna5LKp1ftLUnDr8/8d//IdoaWkRQ0NDFet/MYZ7fj09PeK4444TJ510kujv7/f9/Ac/+IGYOXOmyOVy6rV0Oi0aGxvFT3/608qeRADVOr8XXnhBANBMzXfu3CnC4bD4/e9/X9mTKEK1znHTpk3i6aefVv9uvvlmAUA8+uijo1rppFrnJ8T4eMYw1WE41400/b7jjjvUa88//7xm+l3L90Up5yfE2N0XixcvFitXrlTfZ7NZse+++waaYr/73e/WXjv++ON9pubf/e531c97enrG1Fi1kucnhBCpVEqcffbZ4ogjjhDbt2+vTsdLpNLnt2PHDu1ee/rpp8WsWbPEF7/4RfH8889X70SYUaXc60YIIb797W+LlpYWZzGGWr4vhAg+v/F2X1Tj73f88cf7TM3PPvvsolVkq0Glz6+np0cAEPfcc4/2+kc/+lHxjne8o3IdL4PhnKPJxRdfLE466SQhRO2PvTbo+QlRmWcMB6QqzBlnnCGOPvpo8dhjj4k///nP4uCDD9YeGq+++qo49NBDxWOPPSaEEOLFF18U3/rWt8QTTzwhXn75ZfHII4+IM888U0yZMkVN6J9++mkxbdo0ceGFF4o33nhD/RuLgaUa55fJZMSCBQvEaaedJjZs2CDuvfdeMW3aNHHFFVeM+/Pr6ekRS5YsEUceeaTYtGmT9vfJZDJCiHzlpkQiIT7xiU+IjRs3imeeeUZceOGForW1Vbz++us1f35C5Eu+H3HEEeKRRx4RTz/9tHj3u98t5s+fL1Kp1KieXzXPkfLAAw+MaXn7Sp/feHrGMNWh3OtGCCE+/vGPi7lz54o//vGP4oknnhDHH3+8OP74453vUUv3hRDFz28s74uf//znIpFIiFtuuUVs3LhRfPSjHxVtbW2qGu2HPvQhcfnll6v2jzzyiIhGo+K73/2ueO6558RVV10lYrGYePrpp1Wba665RrS1tYlf//rX4v/+7//EWWedNaalpyt5fqlUSrznPe8Rs2fPFhs2bND+XqNZrbda52eDq+xNPMq9bq655hoRj8fFHXfcoV3ze/fuFULU/n1R7PxsjOV9UY3z+9WvfiVisZj4z//8T/H3v/9dXH/99SISiYiHH354QpzfSSedJI444gjxwAMPiH/84x/ixz/+sairqxM33HDDqJ+fEOWf47e+9S1x3333iRdffFFs3LhRfPe73xXRaFT88Ic/VG1qeewtdn6VesZwQKrC7Ny5U1xwwQWiqalJtLS0iIsvvli78TZv3iwAiAceeEAIIcRrr70mli9fLqZPny5isZiYPXu2+OAHP6hF9q+66ioBwPdvv/32G+Wzq875CSHESy+9JJYvXy7q6+tFR0eH+NznPhdYkr5alHt+cgFm+7d582b1e/fdd59429veJlpbW0V7e7s45ZRTAkuLV4tqnV9PT4+45JJLRFtbm5gyZYo455xzxCuvvDLKZ5enWudIGcuFdzXObzw9Y5jqUO51I4QQg4OD4l/+5V9Ee3u7aGhoEOecc4544403nO9RS/eFEMXPb6zvi+uvv17MnTtXxONxsXjxYvGXv/xF/eykk04SK1as0Nr/4he/EIcccoiIx+PiiCOOEHfffbf281wuJ77yla+IGTNmiEQiIU499VTxwgsvjMapWKnk+cm/r+0f/ZuPJpX++5lwQGpiUs51s99++1mv+auuukoIUfv3RbHzszHW90U1zu9HP/qROOigg0RdXZ3o7OwUd9111yidjZ9Kn98bb7whLrroIjFr1ixRV1cnDj30UPG9731PyyoZbco5xy996Uvqb9Pe3i6OP/548fOf/1w7Xi2PvcXOr1LPmJAQBdMHhmEYhmEYhmEYhmEYhhkFuMoewzAMwzAMwzAMwzAMM6pwQIphGIZhGIZhGIZhGIYZVTggxTAMwzAMwzAMwzAMw4wqHJBiGIZhGIZhGIZhGIZhRhUOSDEMwzAMwzAMwzAMwzCjCgekGIZhGIZhGIZhGIZhmFGFA1IMwzAMwzAMwzAMwzDMqMIBKYZhGIZhGIZhGIZhGGZU4YAUwzAMwzAMwzAMwzAMM6pwQIphGIZhGIZhGIZhGIYZVTggxTCMj6VLlyIUCiEUCmHDhg3az66//nrst99+iEaj+PznP+88xkUXXaSOcdddd1W3wwzDMMyow2MFwzAMUwweK5ggOCDFTHjoA4z+27Rp01h3bVxz6aWX4o033sCCBQvUa0899RRWrVqFG2+8EVu2bMHXv/515+9///vfxxtvvDEaXWUYhhkxPFYMDx4rGIaZTPBYMTx4rGBcRMe6AwwzGpxxxhn48Y9/rL02bdo0X7tUKoV4PD5a3RrXNDQ0YObMmdpr/+///T8sXrwY73znO4v+fmtrK1pbW6vVPYZhmIrDY0X58FjBMMxkg8eK8uGxgnHBCilmUpBIJDBz5kztXyQSwdKlS7Fy5Up85jOfQUdHB04//XQAQC6Xw9VXX439998f9fX16OzsxB133KEds7+/Hx/+8IfR1NSEffbZB9/73vewdOlSfOYzn1Ft5s2bh9WrV2u/t3DhQnz1q18t+X2WLl2KT33qU/jCF76AKVOmYObMmer3JblcDt/5zndw0EEHIZFIYO7cufjmN7+JW2+9FVOnTkUymdTan3322fjQhz5U1md40EEH4ctf/jIeffRRhEIhfPjDHy7r9xmGYcY7PFbwWMEwDFMMHit4rGAqBwekmEnPT37yE8TjcTzyyCO46aabAABXX301br31Vtx000149tln8dnPfhYXXngh/vSnP6nfu+yyy/CnP/0Jv/71r3HffffhwQcfxJNPPlnWe5fyPrKPjY2NeOyxx/Cd73wHX//61/GHP/xB/fyKK67ANddcg6985SvYuHEjbrvtNsyYMQPve9/7kM1m8Zvf/Ea13b59O+6++25ccsklZfX10UcfxQEHHIBrr70Wb7zxBm644Yayfp9hGKaW4bGiNHisYBhmMsNjRWnwWMEoBMNMcFasWCEikYhobGxU/9773vcKIYQ46aSTxNFHH621HxoaEg0NDeLRRx/VXv/IRz4iLrjgAiGEEHv37hXxeFz84he/UD/fuXOnqK+vF5/+9KfVa/vtt5/493//d+04nZ2d4qqrrirpfWQfTzjhBK3NokWLxBe/+EUhhBC9vb0ikUiIH/7wh9bz/8QnPiGWL1+uvv/e974nDjjgAJHL5azt5XvS8xBCiP7+fhEOh8XatWvVa7/97W/FIYccIg466CDn+wMQd955p/O9GIZhxgM8VvBYwTAMUwweK3isYCoLe0gxk4KTTz4ZN954o/q+sbFRfX3MMcdobTdt2oSBgQG84x3v0F5PpVI4+uijAQAvvvgiUqkUlixZon4+ZcoUHHrooSX3qZT3kRx11FHa9/vssw+2b98OAHjuueeQTCZx6qmnWt/n0ksvxaJFi/Daa69h3333xS233KIMGcvh//7v/wAARx55JAAgk8lg1apVeOCBB9Da2opjjjkG55xzDqZOnVrWcRmGYcYLPFbwWMEwDFMMHit4rGAqBwekmElBY2MjDjroIOfPKH19fQCAu+++G/vuu6/2s0QiUdb7hsNhCCG019LpdNnvE4vFtO9DoRByuRwAoL6+PrAPRx99NDo7O3HrrbfitNNOw7PPPou77767rPMAgA0bNuCggw5Sn9fjjz+OI444QvV9+fLluO+++3DBBReUfWyGYZjxAI8VPFYwDMMUg8cKHiuYysEBKYYxmD9/PhKJBF555RWcdNJJ1jYHHnggYrEYHnvsMcydOxcAsHv3bvztb3/TfmfatGlaidLe3l5s3ry55PcphYMPPhj19fVYs2YN/vmf/9na5p//+Z+xevVqvPbaa1i2bBnmzJlT9vts2LABnZ2d6vvXX39dG/D23XdfvPbaa+WfAMMwTA3CY4UdHisYhmE8eKyww2MFI+GAFMMYNDc34/Of/zw++9nPIpfL4YQTTkBPTw8eeeQRtLS0YMWKFWhqasJHPvIRXHbZZZg6dSqmT5+OL33pSwiH9ToBp5xyCm655RaceeaZaGtrw5VXXolIJFLy+5RCXV0dvvjFL+ILX/gC4vE43va2t+HNN9/Es88+i4985CMAgA9+8IP4/Oc/jx/+8Ie49dZbh/W5bNiwAe95z3uG9bsMwzATDR4r7PBYwTAM48FjhR0eKxgJB6QYxsI3vvENTJs2DVdffTX+8Y9/oK2tDW95y1vwr//6r6rNtddei76+Ppx55plobm7G5z73OfT09GjHueKKK7B582a8+93vRmtrK77xjW+onYxS36cUvvKVryAajeLKK6/E66+/jn322Qcf//jH1c9bW1tx3nnn4e6778bZZ59d9ueRy+Xw9NNP4ytf+Yp6bdasWdrOxWuvvYbFixeXfWyGYZhahccKHR4rGIZh/PBYocNjBUMJCTMRlWGYYbN06VIsXLgQq1evHuuu+Dj11FNxxBFH4Ac/+EHRtqWcRyaTweGHH44HH3xQmQ8++uijPvPBUCiEO++8c1gDFsMwzESExwoeKxiGYYrBYwWPFZOBcPEmDMPUMrt378add96JBx98EF1dXSX/3g033ICmpiY8/fTT1p9Ho1F873vfw8kn///t3TFqg3AYxuF3cvIM4hG8Qm/jrqvHdXERXFw7dAgNgTYk+Qjt8+yi2ws/lf9HhmHINE3fRmMcx7Rt+/DzA/B6tgKAn9gKns0XUvBE7/gmo+/77PueZVkyz/OvrlnXNed5Jkm6rkvTNHffd9u2HMeR5Os42etTRwD+K1txYSsAbrMVF7bi7xKkAAAAACjllz0AAAAASglSAAAAAJQSpAAAAAAoJUgBAAAAUEqQAgAAAKCUIAUAAABAKUEKAAAAgFKCFAAAAAClBCkAAAAASglSAAAAAJQSpAAAAAAo9QkR97zLssonIwAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "plt.figure(figsize=(12,4))\n",
+    "ax1 = plt.subplot(131)\n",
+    "ax2 = plt.subplot(132)\n",
+    "ax3 = plt.subplot(133)\n",
+    "for ax, region in zip([ax1, ax2, ax3], ['lowerH', 'center', 'upperH']):\n",
+    "    ax.plot(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])\n",
+    "    ax.set_xlabel(f'Frequency [$f_0$]')\n",
+    "    ax.set_ylabel(f'PSD [arb. units]')\n",
+    "    #ax.set_yscale('log')\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "db917c47-90d3-40fb-951f-43dbf1867674",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (xsuite_dev)",
+   "language": "python",
+   "name": "xsuite_dev"
+  },
+  "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 2ff09019d53b294bf02eaec553d9f75abc70d666 Mon Sep 17 00:00:00 2001
From: Christophe LANNOY <christophe.lannoy@hotmail.com>
Date: Tue, 25 Feb 2025 15:02:38 +0100
Subject: [PATCH 5/9] use scipy factorial function

---
 xtrack/monitors/schottky_monitor.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
index 231e1dbd2..f3b0318be 100644
--- a/xtrack/monitors/schottky_monitor.py
+++ b/xtrack/monitors/schottky_monitor.py
@@ -6,7 +6,7 @@ class SchottkyMonitor():
     def __init__(self, f_rev, schottky_harmonic, n_taylor):
         """
         Tracking element computing Schottky spectra 
-        Equations based on JINST 19 P03017, C.lannoy  and al.
+        Equations based on JINST 19 P03017, C.lannoy et al.
 
         Parameters
         ----------
@@ -165,7 +165,7 @@ def _check_Taylor_approx(self):
         if self.processing_param['z']:
             delta_omega_max = max(self.frequencies['center']) * 2 * np.pi * self.f_rev
             max_error = self.N_macropart_max**0.5 * (delta_omega_max*self.tau_max)**self.n_taylor * \
-                        np.exp(delta_omega_max*self.tau_max) / np.math.factorial(self.n_taylor)
+                        np.exp(delta_omega_max*self.tau_max) / sp.special.factorial(self.n_taylor)
             if np.sqrt(self.PSD_avg['center'][0]) < 100 * max_error:
                 print('Number of Taylor terms too low for the longitudinal band')
             print(f'Maximal Talor truncation error in z plane to be compared against sqrt(PSD): {max_error}')
@@ -174,14 +174,14 @@ def _check_Taylor_approx(self):
         if self.processing_param['x']:
             delta_omega_max = max(self.frequencies['upperH']) * 2 * np.pi * self.f_rev
             max_error = self.N_macropart_max**0.5 * self.x_max * (delta_omega_max*self.tau_max)**self.n_taylor * \
-                        np.exp(delta_omega_max*self.tau_max) / np.math.factorial(self.n_taylor)
+                        np.exp(delta_omega_max*self.tau_max) / sp.special.factorial(self.n_taylor)
             if np.sqrt(self.PSD_avg['upperH'][0]) < 100 * max_error:
                 print('Number of Taylor terms too low for the horizontal bands')
             print(f'Maximal Talor truncation error in x plane to be compared against sqrt(PSD): {max_error}')
         if self.processing_param['y']:
             delta_omega_max = max(self.frequencies['upperV']) * 2 * np.pi * self.f_rev
             max_error = self.N_macropart_max**0.5 * self.y_max * (delta_omega_max*self.tau_max)**self.n_taylor * \
-                        np.exp(delta_omega_max*self.tau_max) / np.math.factorial(self.n_taylor)
+                        np.exp(delta_omega_max*self.tau_max) / sp.special.factorial(self.n_taylor)
             if np.sqrt(self.PSD_avg['upperV'][0]) < 100 * max_error:
                 print('Number of Taylor terms too low for the vertical bands')
             print(f'Maximal Talor truncation error in y plane to be compared against sqrt(PSD): {max_error}')
@@ -191,7 +191,7 @@ def clear_spectrum(self):
         Clear the instantaneous spectra but keep the coefficients L and T.
         Can be use to recompute Schottky spectra for different processing 
         parameters (window, frequency resolution, band widths) without 
-        tracking the particles agan
+        tracking the particles again
         """
         if hasattr(self, 'processing_param'):
             delattr(self, 'processing_param')

From 62b7cc438576c87d21086049ee3e4eab51257e6d Mon Sep 17 00:00:00 2001
From: Christophe Lannoy <christophe.lannoy@cern.ch>
Date: Sun, 17 Aug 2025 18:46:50 +0200
Subject: [PATCH 6/9] Add Schottky monitor example and plotting functionality

---
 examples/monitor/005_schottky_monitor.ipynb | 456 --------------------
 examples/monitor/005_schottky_monitor.py    |  71 +++
 xtrack/monitors/schottky_monitor.py         |  55 ++-
 3 files changed, 125 insertions(+), 457 deletions(-)
 delete mode 100644 examples/monitor/005_schottky_monitor.ipynb
 create mode 100644 examples/monitor/005_schottky_monitor.py

diff --git a/examples/monitor/005_schottky_monitor.ipynb b/examples/monitor/005_schottky_monitor.ipynb
deleted file mode 100644
index 9b63c87f7..000000000
--- a/examples/monitor/005_schottky_monitor.ipynb
+++ /dev/null
@@ -1,456 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "0d0d094d-1239-4d1f-a1ec-eeb9e2e68c0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xtrack as xt\n",
-    "import xpart as xp\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d2770ec4-ce5c-4521-bc12-9df7bcaccd11",
-   "metadata": {},
-   "source": [
-    "Create a simple model of the LHC"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f00c683a-5c06-4f62-a6cf-e6ebd6ca662c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "lmap = xt.LineSegmentMap(length=26658.8831999989, qx=0.27, qy=0.295, dqx=15, dqy=15, longitudinal_mode='nonlinear',\n",
-    "    voltage_rf=4e6, frequency_rf=400e6, lag_rf=180, momentum_compaction_factor=3.225e-04, betx=1, bety=1)\n",
-    "line = xt.Line(elements=[lmap])\n",
-    "line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, energy0=450e9)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e79c5557-4a34-4b26-bddb-8e705e9dfcba",
-   "metadata": {},
-   "source": [
-    "Compute the revolution period needed by the Schottky monitor"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "61387be6-6111-48fb-8ee3-a617726fb576",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Compiling ContextCpu kernels...\n",
-      "Done compiling ContextCpu kernels.\n"
-     ]
-    }
-   ],
-   "source": [
-    "twiss = line.twiss()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "0aac7240-6a17-40cb-930c-bd5379ae31d2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1/twiss.T_rev0, schottky_harmonic=427_725, n_taylor=4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "9b8ddd1e-e825-4ecc-8783-f477dafc8119",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Compiling ContextCpu kernels...\n",
-      "Done compiling ContextCpu kernels.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<xtrack.tracker.Tracker at 0x7f4a502d86b0>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "line.discard_tracker()\n",
-    "line.append_element(element=schottky_monitor, name='Schottky monitor')\n",
-    "line.build_tracker()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b5798208-76ff-4a9e-8aca-a7976360e7f9",
-   "metadata": {},
-   "source": [
-    "Create a bunch of particles and track them for 10k turns"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "91d46d45-5857-439d-8a77-1f1a4ec2dc8a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Ignoring collective elements in particles generation.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "*** Maximum RMS bunch length 0.11812759635051139m.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/clannoy/miniconda3/lib/python3.12/site-packages/scipy/integrate/_quadpack_py.py:1272: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n",
-      "  quad_r = quad(f, low, high, args=args, full_output=self.full_output,\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "... distance to target bunch length: -7.0000e-02\n",
-      "... distance to target bunch length: 4.4864e-02\n",
-      "... distance to target bunch length: 3.8881e-02\n",
-      "... distance to target bunch length: 8.5600e-03\n",
-      "... distance to target bunch length: -9.3055e-03\n",
-      "... distance to target bunch length: 4.5506e-04\n",
-      "... distance to target bunch length: -8.6681e-06\n",
-      "... distance to target bunch length: 2.2793e-08\n",
-      "... distance to target bunch length: -3.4673e-07\n",
-      "--> Bunch length: 0.07000002279329717\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Ignoring collective elements in particles generation.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "--> Emittance: 0.2489315037483315\n"
-     ]
-    }
-   ],
-   "source": [
-    "bunch = xp.generate_matched_gaussian_bunch(num_particles=int(1e4), nemitt_x=1.5e-6, nemitt_y=1.5e-6, line=line, total_intensity_particles=1e11, sigma_z=7e-2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "4a06372e-d6ec-4943-b5e1-67fde8df3f11",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Tracking:   0%|                                                                    | 0/10000 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Compiling ContextCpu kernels...\n",
-      "Done compiling ContextCpu kernels.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Tracking: 100%|███████████████████████████████████████████████████████| 10000/10000 [00:26<00:00, 372.13it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "line.track(bunch, num_turns=10000, with_progress=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fe18ecff-2548-4580-97da-bc62d8c3b4d7",
-   "metadata": {},
-   "source": [
-    "Process the data to build Schottky spectrum"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "f9b193fe-5c4d-48e6-9f65-293d62707523",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "lowerH band of Schottky spectrum processed\n",
-      "upperH band of Schottky spectrum processed\n",
-      "center band of Schottky spectrum processed\n",
-      "Maximal Talor truncation error in z plane to be compared against sqrt(PSD): 3.80657433491217e-20\n",
-      "Maximal Talor truncation error in x plane to be compared against sqrt(PSD): 5.190120322201753e-22\n"
-     ]
-    }
-   ],
-   "source": [
-    "schottky_monitor.process_spectrum(inst_spectrum_len=10000, deltaQ=5e-5, band_width=0.3, Qx=0.27, Qy=0.295, x=True, y=False, z=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fc18ccda-9ec8-4429-b33a-c956ccf8f480",
-   "metadata": {},
-   "source": [
-    "Since we only tracked 10_000 turns we have a single instataneous spectra"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "177a7ef3-9356-4faa-92cd-cdd6135a4c01",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x400 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "plt.figure(figsize=(12,4))\n",
-    "ax1 = plt.subplot(131)\n",
-    "ax2 = plt.subplot(132)\n",
-    "ax3 = plt.subplot(133)\n",
-    "for ax, region in zip([ax1, ax2, ax3], ['lowerH', 'center', 'upperH']):\n",
-    "    ax.plot(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])\n",
-    "    ax.set_xlabel(f'Frequency [$f_0$]')\n",
-    "    ax.set_ylabel(f'PSD [arb. units]')\n",
-    "    #ax.set_yscale('log')\n",
-    "plt.tight_layout()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "969b2106-22fe-4a54-bfdc-6f213f653a25",
-   "metadata": {},
-   "source": [
-    "Tracking more turns to observe the mean value of the spectra "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "506e2d3f-0eae-4f9b-89f4-ea373b6e67c6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Tracking: 100%|█████████████████████████████████████████████████████| 100000/100000 [04:00<00:00, 415.31it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "line.track(bunch, num_turns=200_000, with_progress=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "94563a0e-fa86-422b-806a-b53c5c18644b",
-   "metadata": {},
-   "source": [
-    "We can now plot the average over 21 specta"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "823b7193-2839-4269-aaf8-01e3ebdef380",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "lowerH band of Schottky spectrum processed\n",
-      "upperH band of Schottky spectrum processed\n",
-      "center band of Schottky spectrum processed\n",
-      "Maximal Talor truncation error in z plane to be compared against sqrt(PSD): 3.80657433491217e-20\n",
-      "Maximal Talor truncation error in x plane to be compared against sqrt(PSD): 5.190120322201753e-22\n"
-     ]
-    }
-   ],
-   "source": [
-    "schottky_monitor.process_spectrum(inst_spectrum_len=10000, deltaQ=5e-5, band_width=0.3, Qx=0.27, Qy=0.295, x=True, y=False, z=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "09f88357-b97b-46e8-b5cd-2523fee01b7f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x400 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "plt.figure(figsize=(12,4))\n",
-    "ax1 = plt.subplot(131)\n",
-    "ax2 = plt.subplot(132)\n",
-    "ax3 = plt.subplot(133)\n",
-    "for ax, region in zip([ax1, ax2, ax3], ['lowerH', 'center', 'upperH']):\n",
-    "    ax.plot(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])\n",
-    "    ax.set_xlabel(f'Frequency [$f_0$]')\n",
-    "    ax.set_ylabel(f'PSD [arb. units]')\n",
-    "    ax.set_yscale('log')\n",
-    "plt.tight_layout()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "57c9167f-70a9-443a-a133-2b93ecf31edb",
-   "metadata": {},
-   "source": [
-    "Compute shottky spectrum for different processing parameters (but same tracking) "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "7df0ea6b-a0e6-4e06-bb86-003b19c39045",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "lowerH band of Schottky spectrum processed\n",
-      "upperH band of Schottky spectrum processed\n",
-      "center band of Schottky spectrum processed\n",
-      "Maximal Talor truncation error in z plane to be compared against sqrt(PSD): 4.693176884032811e-22\n",
-      "Maximal Talor truncation error in x plane to be compared against sqrt(PSD): 1.749522590303493e-22\n"
-     ]
-    }
-   ],
-   "source": [
-    "schottky_monitor.clear_spectrum()\n",
-    "schottky_monitor.process_spectrum(inst_spectrum_len=5000, deltaQ=5e-5, band_width=0.1, Qx=0.27, Qy=0.295, x=True, y=False, z=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "b3b0cf65-2824-4dad-904f-255ff53275c8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x400 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "plt.figure(figsize=(12,4))\n",
-    "ax1 = plt.subplot(131)\n",
-    "ax2 = plt.subplot(132)\n",
-    "ax3 = plt.subplot(133)\n",
-    "for ax, region in zip([ax1, ax2, ax3], ['lowerH', 'center', 'upperH']):\n",
-    "    ax.plot(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])\n",
-    "    ax.set_xlabel(f'Frequency [$f_0$]')\n",
-    "    ax.set_ylabel(f'PSD [arb. units]')\n",
-    "    #ax.set_yscale('log')\n",
-    "plt.tight_layout()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "db917c47-90d3-40fb-951f-43dbf1867674",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python (xsuite_dev)",
-   "language": "python",
-   "name": "xsuite_dev"
-  },
-  "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.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/examples/monitor/005_schottky_monitor.py b/examples/monitor/005_schottky_monitor.py
new file mode 100644
index 000000000..d7c5c4993
--- /dev/null
+++ b/examples/monitor/005_schottky_monitor.py
@@ -0,0 +1,71 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2021.                 #
+# ######################################### #
+
+"""Schottky monitor example.
+This script builds a simple LHC-like ring using a LineSegmentMap, inserts
+a Schottky monitor, tracks a Gaussian bunch, and produces Schottky spectra.
+"""
+
+import xtrack as xt
+import xpart as xp
+import matplotlib.pyplot as plt
+
+# Build simple LHC-like lattice
+length_lhc = 26658.8831999989
+lmap = xt.LineSegmentMap(length=length_lhc, qx=0.27, qy=0.295, dqx=15, dqy=15,
+                         longitudinal_mode='nonlinear', voltage_rf=4e6,
+                         frequency_rf=400e6, lag_rf=180,
+                         momentum_compaction_factor=3.225e-04,
+                         betx=1, bety=1)
+line = xt.Line(elements=[lmap])
+line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, energy0=450e9)
+
+# Twiss to get revolution frequency
+tw = line.twiss()
+
+# Create and insert Schottky monitor
+schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1/tw.T_rev0,
+                                               schottky_harmonic=427_725,
+                                               n_taylor=4)
+line.discard_tracker()
+line.append_element(element=schottky_monitor, name='schottky_monitor')
+line.build_tracker()
+
+# Generate a matched Gaussian bunch
+num_particles = 10_000
+bunch = xp.generate_matched_gaussian_bunch(num_particles=num_particles,
+                                           nemitt_x=1.5e-6, nemitt_y=1.5e-6,
+                                           line=line,
+                                           total_intensity_particles=1e11,
+                                           sigma_z=7e-2)
+
+# Track for 10k turns and process a first spectrum
+line.track(bunch, num_turns=10_000, with_progress=True)
+schottky_monitor.process_spectrum(inst_spectrum_len=10_000,
+                                  deltaQ=5e-5, band_width=0.3,
+                                  Qx=0.27, Qy=0.295,
+                                  x=True, y=False, z=True)
+
+schottky_monitor.plot()
+# Or plot specific regions in log scale
+#schottky_monitor.plot(regions=['lowerH','center','upperH'], log=True)
+
+
+# (Optional) accumulate additional statistics: uncomment for more averaging
+# line.track(bunch, num_turns=200_000, with_progress=True)
+# schottky_monitor.process_spectrum(inst_spectrum_len=10_000,
+#                                   deltaQ=5e-5, band_width=0.3,
+#                                   Qx=0.27, Qy=0.295,
+#                                   x=True, y=False, z=True)
+# schottky_monitor.plot(regions=['lowerH','center','upperH'], log=True)
+
+# Re-process with different processing parameters (without tracking again)
+schottky_monitor.clear_spectrum()
+schottky_monitor.process_spectrum(inst_spectrum_len=5000, deltaQ=5e-5,
+                                  band_width=0.1, Qx=0.27, Qy=0.295,
+                                  x=True, y=False, z=True)
+schottky_monitor.plot(regions=['lowerH','center','upperH'])
+
+plt.show()
diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
index f3b0318be..fa6294b3d 100644
--- a/xtrack/monitors/schottky_monitor.py
+++ b/xtrack/monitors/schottky_monitor.py
@@ -206,4 +206,57 @@ def clear_all(self):
         self.clear_spectrum()
         self.x_coeff = []
         self.y_coeff = []
-        self.z_coeff = []
\ No newline at end of file
+        self.z_coeff = []
+
+    # ------------------------------------------------------------------
+    # Plotting utilities
+    # ------------------------------------------------------------------
+    def plot(self, regions=None, log=False):
+        """Plot Schottky spectra (average PSD only).
+
+        Parameters
+        ----------
+        regions : list(str) or None
+            Regions to include. If None, automatically select the available
+            standard regions in the order: ['lowerH','center','upperH','lowerV','upperV'].
+        log : bool
+            If True, use logarithmic y-scale.
+
+        Returns
+        -------
+        fig, axes
+            Matplotlib figure and list of axes.
+        """
+        import matplotlib.pyplot as plt
+        if not hasattr(self, 'PSD_avg'):
+            raise RuntimeError('No processed spectrum found. Call process_spectrum() first.')
+
+        # Determine regions to plot
+        default_order = ['lowerH', 'center', 'upperH', 'lowerV', 'upperV']
+        available = [r for r in default_order if r in self.PSD_avg and len(self.PSD_avg[r]) > 0]
+        if regions is None:
+            regions = available
+        else:
+            # Keep original order but enforce strict presence
+            missing = [r for r in regions if r not in available]
+            if len(missing) > 0:
+                raise ValueError(f'Requested region(s) not processed: {missing}. Available: {available}. Call process_spectrum() with the appropriate parameters first.')
+        if len(regions) == 0:
+            raise RuntimeError('No spectra available to plot.')
+
+        fig, axes = plt.subplots(1, len(regions), figsize=(4 * len(regions), 4))
+        if len(regions) == 1:
+            axes = [axes]
+
+        for aa, region in zip(axes, regions):
+            freq = self.frequencies[region]
+            psd_avg = self.PSD_avg[region]
+            aa.plot(freq, psd_avg)
+            if log:
+                aa.set_yscale('log')
+            aa.set_xlabel('Frequency [$f_0$]')
+            aa.set_ylabel('PSD [arb. units]')
+            aa.set_title(region)
+            aa.grid(True, which='both', ls=':', alpha=0.5)
+        fig.tight_layout()
+        return fig, axes
\ No newline at end of file

From 741e8427ea8be0ef72ed84e6ae55421ccb17ced1 Mon Sep 17 00:00:00 2001
From: Christophe Lannoy <christophe.lannoy@cern.ch>
Date: Sun, 17 Aug 2025 19:30:26 +0200
Subject: [PATCH 7/9] Clean schottky_monitor.py

---
 xtrack/monitors/schottky_monitor.py | 114 +++++++++++++---------------
 1 file changed, 52 insertions(+), 62 deletions(-)

diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
index fa6294b3d..f6ebb789d 100644
--- a/xtrack/monitors/schottky_monitor.py
+++ b/xtrack/monitors/schottky_monitor.py
@@ -1,86 +1,84 @@
+"""
+Schottky spectrum monitor
+
+Author: Christophe Lannoy
+Date: 2025-08-17
+"""
+
 import numpy as np
 import scipy as sp
 from scipy.constants import c
 
-class SchottkyMonitor():
+
+class SchottkyMonitor:
     def __init__(self, f_rev, schottky_harmonic, n_taylor):
         """
-        Tracking element computing Schottky spectra 
-        Equations based on JINST 19 P03017, C.lannoy et al.
+        Tracking element computing Schottky spectra.
+        Equations based on JINST 19 P03017, C. Lannoy et al.
 
         Parameters
         ----------
         f_rev : float
-                Revolution frequency.
-
+            Revolution frequency.
         schottky_harmonic : int
-                Harmonic of the Schottky monitor.
-
+            Harmonic of the Schottky monitor.
         n_taylor : int
-                Number of term used for the Taylor expansion (4 is enough for LHC conditions).
+            Number of terms used for the Taylor expansion (4 is enough for LHC conditions).
         """
-        
         self.f_rev = f_rev
         if n_taylor < 1:
             raise ValueError('At least one coefficient for the Taylor expansion is needed')
         self.n_taylor = n_taylor
-        # Taylor expantion around central Schottky frequency omega_c
+        # Taylor expansion around central Schottky frequency omega_c
         self.omega_c = 2 * np.pi * f_rev * schottky_harmonic
         self.x_coeff, self.y_coeff, self.z_coeff = [], [], []
         self.initialised_with_first_tracking = False
 
     def track(self, particles):
         mask_alive = particles.state > 0
-        tau = -particles.zeta[mask_alive]/(c*particles.beta0[mask_alive])
+        tau = -particles.zeta[mask_alive] / (c * particles.beta0[mask_alive])
 
-        # If first time calling the function, store bunch parameters for 
-        # computing the upper bound of the Taylor approximation
+        # First time: store bunch parameters for truncation error estimate
         if not self.initialised_with_first_tracking:
-            self.tau_max = 4* np.std(tau)
-            self.x_max = 4* np.std(particles.x[mask_alive])
-            self.y_max = 4* np.std(particles.y[mask_alive])
+            self.tau_max = 4 * np.std(tau)
+            self.x_max = 4 * np.std(particles.x[mask_alive])
+            self.y_max = 4 * np.std(particles.y[mask_alive])
             self.N_macropart_max = len(tau)
             self.initialised_with_first_tracking = True
 
         # Calculates the longitudinal and transverse coefficients (L and T) as defined in Eqs (2.2) and (2.4)
         z_terms = np.empty((self.n_taylor, len(tau)), dtype=np.csingle)
-        z_terms[0,:] = np.exp(1j*self.omega_c*tau)
-        for l in range(1,self.n_taylor):
-            z_terms[l,:] = z_terms[l-1,:]*tau
+        z_terms[0, :] = np.exp(1j * self.omega_c * tau)
+        for l in range(1, self.n_taylor):
+            z_terms[l, :] = z_terms[l - 1, :] * tau
 
-        self.x_coeff.append(np.sum(z_terms*particles.x[mask_alive], axis=1))
-        self.y_coeff.append(np.sum(z_terms*particles.y[mask_alive], axis=1))
+        self.x_coeff.append(np.sum(z_terms * particles.x[mask_alive], axis=1))
+        self.y_coeff.append(np.sum(z_terms * particles.y[mask_alive], axis=1))
         self.z_coeff.append(np.sum(z_terms, axis=1))
 
-    def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy, 
+    def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy,
                          x=True, y=True, z=True, flattop_window=True):
         """
-        Compute Schottky spectra from the stored longitudinal and transverse coefficients
+        Compute Schottky spectra from stored longitudinal and transverse coefficients.
 
         Parameters
         ----------
         inst_spectrum_len : int
-                Number of revolution used to compute a single instataneous spectra.
-                
-        deltaQ : float 
-                Frequency resolution of the spectra (in tune unit).
-
+            Number of turns used to compute one instantaneous spectrum.
+        deltaQ : float
+            Frequency resolution (in tune units).
         band_width : float
-                Range of frequency (in tune unit) where the spectrum will be computed for each band, 
-                should be between 0 and 1.
-
+            Range of frequency (in tune units) where the spectrum will be computed for each band,
+            should be between 0 and 1.
         Qx, Qy : float
-                Transverse tunes used to set the central frequency around which the 
-                transverse side-bands will be computed. 
-
+            Transverse tunes used to set the central frequency around which the 
+            transverse side-bands will be computed. 
         x, y, z: bool
-                Which band are to be computed. x, y, z stand for, respectively, 
-                transverse horizontal, transverse vertical and longitudinal bands.
-
+            Which band are to be computed. x, y, z stand for, respectively, 
+            transverse horizontal, transverse vertical and longitudinal bands.
         flattop_window: bool
-                Multiply time signal by flattop window, else no windowing used (=rectangular window).
+            Multiply time signal by flattop window, else no windowing used (=rectangular window).
         """
-        
         if inst_spectrum_len > len(self.x_coeff):
             raise ValueError(f'Not enough turns tracked to produce a single instataneous spectra \n \
                                Number of turns tracked: {len(self.x_coeff)} \n \
@@ -200,32 +198,24 @@ def clear_spectrum(self):
             delattr(self, 'PSD_avg')
 
     def clear_all(self):
-        """
-        Reinitialise monitor
-        """
+        """Fully reset monitor (coefficients and spectra)."""
         self.clear_spectrum()
         self.x_coeff = []
         self.y_coeff = []
         self.z_coeff = []
 
-    # ------------------------------------------------------------------
-    # Plotting utilities
-    # ------------------------------------------------------------------
+    # Plotting utility -------------------------------------------------
     def plot(self, regions=None, log=False):
-        """Plot Schottky spectra (average PSD only).
+        """
+        Plot average Schottky spectra.
 
         Parameters
         ----------
         regions : list(str) or None
-            Regions to include. If None, automatically select the available
-            standard regions in the order: ['lowerH','center','upperH','lowerV','upperV'].
+            Regions to include (default: all available among
+            ['lowerH','center','upperH','lowerV','upperV']).
         log : bool
-            If True, use logarithmic y-scale.
-
-        Returns
-        -------
-        fig, axes
-            Matplotlib figure and list of axes.
+            If True use logarithmic y-scale.
         """
         import matplotlib.pyplot as plt
         if not hasattr(self, 'PSD_avg'):
@@ -248,15 +238,15 @@ def plot(self, regions=None, log=False):
         if len(regions) == 1:
             axes = [axes]
 
-        for aa, region in zip(axes, regions):
+        for ax, region in zip(axes, regions):
             freq = self.frequencies[region]
-            psd_avg = self.PSD_avg[region]
-            aa.plot(freq, psd_avg)
+            psd = self.PSD_avg[region]
+            ax.plot(freq, psd)
             if log:
-                aa.set_yscale('log')
-            aa.set_xlabel('Frequency [$f_0$]')
-            aa.set_ylabel('PSD [arb. units]')
-            aa.set_title(region)
-            aa.grid(True, which='both', ls=':', alpha=0.5)
+                ax.set_yscale('log')
+            ax.set_xlabel('Frequency [$f_0$]')
+            ax.set_ylabel('PSD [arb. units]')
+            ax.set_title(region)
+            ax.grid(True, which='both', ls=':', alpha=0.5)
         fig.tight_layout()
         return fig, axes
\ No newline at end of file

From 190adb3b47aa047844da6c8f9b847b3fc4229de4 Mon Sep 17 00:00:00 2001
From: Christophe Lannoy <christophe.lannoy@cern.ch>
Date: Wed, 20 Aug 2025 21:02:53 +0200
Subject: [PATCH 8/9] Add tests and modify naming convention

---
 examples/monitor/005_schottky_monitor.py | 12 ++--
 tests/test_schottky.py                   | 75 ++++++++++++++++++++++++
 xtrack/monitors/schottky_monitor.py      | 30 +++++-----
 3 files changed, 96 insertions(+), 21 deletions(-)
 create mode 100644 tests/test_schottky.py

diff --git a/examples/monitor/005_schottky_monitor.py b/examples/monitor/005_schottky_monitor.py
index d7c5c4993..d8093f95c 100644
--- a/examples/monitor/005_schottky_monitor.py
+++ b/examples/monitor/005_schottky_monitor.py
@@ -44,8 +44,8 @@
 # Track for 10k turns and process a first spectrum
 line.track(bunch, num_turns=10_000, with_progress=True)
 schottky_monitor.process_spectrum(inst_spectrum_len=10_000,
-                                  deltaQ=5e-5, band_width=0.3,
-                                  Qx=0.27, Qy=0.295,
+                                  delta_q=5e-5, band_width=0.3,
+                                  qx=0.27, qy=0.295,
                                   x=True, y=False, z=True)
 
 schottky_monitor.plot()
@@ -56,15 +56,15 @@
 # (Optional) accumulate additional statistics: uncomment for more averaging
 # line.track(bunch, num_turns=200_000, with_progress=True)
 # schottky_monitor.process_spectrum(inst_spectrum_len=10_000,
-#                                   deltaQ=5e-5, band_width=0.3,
-#                                   Qx=0.27, Qy=0.295,
+#                                   delta_q=5e-5, band_width=0.3,
+#                                   qx=0.27, qy=0.295,
 #                                   x=True, y=False, z=True)
 # schottky_monitor.plot(regions=['lowerH','center','upperH'], log=True)
 
 # Re-process with different processing parameters (without tracking again)
 schottky_monitor.clear_spectrum()
-schottky_monitor.process_spectrum(inst_spectrum_len=5000, deltaQ=5e-5,
-                                  band_width=0.1, Qx=0.27, Qy=0.295,
+schottky_monitor.process_spectrum(inst_spectrum_len=5000, delta_q=5e-5,
+                                  band_width=0.1, qx=0.27, qy=0.295,
                                   x=True, y=False, z=True)
 schottky_monitor.plot(regions=['lowerH','center','upperH'])
 
diff --git a/tests/test_schottky.py b/tests/test_schottky.py
new file mode 100644
index 000000000..3e131687c
--- /dev/null
+++ b/tests/test_schottky.py
@@ -0,0 +1,75 @@
+import xtrack as xt
+import numpy as np
+from scipy.signal import find_peaks
+
+# Function used for testing
+def extract_qs_spacings(f, psd, window_width=0.15, threshold=0.01):
+    # Extract the distance between succesive peaks in the spectrum
+    # Only works for single particle spectra
+    
+    # Restrict to a window around central frequency
+    mask = np.abs(f- np.mean(f)) < 0.5 * window_width
+    f_win = f[mask]
+    psd_win = psd[mask]
+
+    # Find peaks in the windowed PSD with minimum heights threshold
+    peaks, _ = find_peaks(psd_win, height=np.max(psd_win)*threshold)
+    peak_freqs = np.sort(f_win[peaks])
+
+    # Compute spacings
+    spacings = np.diff(peak_freqs)
+    return spacings
+
+def test_qs_qx_qy_linear_rf():
+	# Create a line with a linear RF and add Schottky monitor
+	lmap = xt.LineSegmentMap(length=26658.8831999989, qx=0.27, qy=0.295, dqx=15, dqy=15, 
+						  longitudinal_mode='linear_fixed_qs', qs=0.004, bets=1, betx=1, bety=1)
+	line = xt.Line(elements=[lmap])
+	line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, energy0=450e9)
+	twiss = line.twiss()
+	schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1/twiss.T_rev0, schottky_harmonic=427_725, n_taylor=4)
+	line.discard_tracker()
+	line.append_element(element=schottky_monitor, name='Schottky monitor')
+	line.build_tracker()
+	# Track single particle
+	particle = line.build_particles(
+                        x=1e-3,
+                        px=0,
+                        y=1e-3,
+                        py=0,
+                        zeta=1e-2,
+                        delta=0)
+	line.track(particle, num_turns=10000, with_progress=True)
+	schottky_monitor.process_spectrum(inst_spectrum_len=10000, delta_q=5e-5, band_width=0.45, qx=line.elements[0].qx, qy=line.elements[0].qy)
+
+	# Test syncrotron tune on each band
+	for region in ['lowerH', 'center', 'upperH', 'lowerV', 'upperV']:
+		spacings = extract_qs_spacings(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])
+		# Assert that each value in spacings is close to line.elements[0].qs or an integer multiple of it (some peaks might have a height of 0)
+		qs_ref = line.elements[0].qs
+		multiples = np.round(spacings / qs_ref,)
+		np.testing.assert_allclose(spacings, multiples * qs_ref, atol=1e-4) #atol = 2*delta_q (resolution of the spectra)
+
+	# Test vertical and hoirizontal betatron tunes
+	for region in ['lowerH', 'upperH', 'lowerV', 'upperV']:
+		window_width = 0.45
+		f = schottky_monitor.frequencies[region]
+		psd = schottky_monitor.PSD_avg[region]
+
+		# Restrict to a window around central frequency
+		mask = np.abs(f- np.mean(f)) < 0.5 * window_width
+		f_win = f[mask]
+		psd_win = psd[mask]
+		# Check that full band is used to compute com and no overlap with band from adjacent harmonics
+		assert np.all(psd_win[:300] < 0.001 * np.max(psd_win))
+		assert np.all(psd_win[-300:] < 0.001 * np.max(psd_win))
+
+		# Center of mass using full spectrum
+		f_com_full = np.sum(f_win * psd_win) / np.sum(psd_win)
+		f_com_full = np.abs(f_com_full)
+		if region in ['lowerH', 'upperH']:
+			np.testing.assert_allclose(f_com_full, line.elements[0].qx, atol=5e-5) #atol = delta_q (resolution of the spectra)
+		elif region in ['lowerV', 'upperV']:
+			np.testing.assert_allclose(f_com_full, line.elements[0].qy, atol=5e-5) 
+
+# To Do: add test for non-linear RF
\ No newline at end of file
diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
index f6ebb789d..666514ec5 100644
--- a/xtrack/monitors/schottky_monitor.py
+++ b/xtrack/monitors/schottky_monitor.py
@@ -56,7 +56,7 @@ def track(self, particles):
         self.y_coeff.append(np.sum(z_terms * particles.y[mask_alive], axis=1))
         self.z_coeff.append(np.sum(z_terms, axis=1))
 
-    def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy,
+    def process_spectrum(self, inst_spectrum_len, delta_q, band_width, qx, qy,
                          x=True, y=True, z=True, flattop_window=True):
         """
         Compute Schottky spectra from stored longitudinal and transverse coefficients.
@@ -65,12 +65,12 @@ def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy,
         ----------
         inst_spectrum_len : int
             Number of turns used to compute one instantaneous spectrum.
-        deltaQ : float
-            Frequency resolution (in tune units).
+        delta_q : float
+            Frequency resolution expressed as normalised frequency f/f_rev.
+            Physical spacing of Fourier bins is delta_q * f_rev.
         band_width : float
-            Range of frequency (in tune units) where the spectrum will be computed for each band,
-            should be between 0 and 1.
-        Qx, Qy : float
+            Width of each processed band in normalised frequency f/f_rev (0 < band_width < 1).
+        qx, qy : float
             Transverse tunes used to set the central frequency around which the 
             transverse side-bands will be computed. 
         x, y, z: bool
@@ -83,13 +83,13 @@ def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy,
             raise ValueError(f'Not enough turns tracked to produce a single instataneous spectra \n \
                                Number of turns tracked: {len(self.x_coeff)} \n \
                                Length of instataneous spectra: {inst_spectrum_len}')
-        if band_width<0 or band_width>1:
-            raise ValueError('Band_width should be expressed in tune unit and between 0 and 1')
+        if band_width <= 0 or band_width >= 1:
+            raise ValueError('band_width must be a normalised frequency f/f_rev with 0 < band_width < 1')
         
         # If it's the first time calling the method we need to initialise it.
         if not hasattr(self, 'processing_param'):
             self.processing_param = locals()
-            self._init_processing(deltaQ, Qx, Qy, band_width)
+            self._init_processing(delta_q, qx, qy, band_width)
         
         # Not the first time calling this method, we will append the new instantaneous Schottky PSDs to the 
         # existing ones. In this case we need to confirm that the processing parameters are identical.
@@ -140,18 +140,18 @@ def process_spectrum(self, inst_spectrum_len, deltaQ, band_width, Qx, Qy,
             print(f'{region} band of Schottky spectrum processed')
         self._check_Taylor_approx()
 
-    def _init_processing(self, deltaQ, Qx, Qy, band_width):
+    def _init_processing(self, delta_q, qx, qy, band_width):
         '''
         For each region of the Schottky spectrum, create an array of normalised frequencies 
         from -band_with/2 to +band_with/2 around the center of the Schottky band. 
         '''
-        n_freq = band_width/deltaQ
+        n_freq = band_width / delta_q
         center_freq = np.arange(-(n_freq//2), (n_freq)//2) * band_width / n_freq
         self.frequencies = {
-            'lowerH': center_freq - (Qx%1),
-            'upperH': center_freq + (Qx%1),
-            'lowerV': center_freq - (Qy%1),
-            'upperV': center_freq + (Qy%1),
+            'lowerH': center_freq - (qx%1),
+            'upperH': center_freq + (qx%1),
+            'lowerV': center_freq - (qy%1),
+            'upperV': center_freq + (qy%1),
             'center': center_freq
         }
         # Create dic where the instataneous and averaged PSDs will be stored

From c3b114fc68446f4c778066c2fe8458a918756074 Mon Sep 17 00:00:00 2001
From: Christophe Lannoy <christophe.lannoy@cern.ch>
Date: Wed, 20 Aug 2025 21:29:38 +0200
Subject: [PATCH 9/9] Fix typos and format

---
 examples/monitor/005_schottky_monitor.py |  6 +-
 tests/test_schottky.py                   | 81 +++++++++++++++---------
 xtrack/monitors/schottky_monitor.py      | 68 ++++++++++++--------
 3 files changed, 94 insertions(+), 61 deletions(-)

diff --git a/examples/monitor/005_schottky_monitor.py b/examples/monitor/005_schottky_monitor.py
index d8093f95c..2c4544b4e 100644
--- a/examples/monitor/005_schottky_monitor.py
+++ b/examples/monitor/005_schottky_monitor.py
@@ -26,7 +26,7 @@
 tw = line.twiss()
 
 # Create and insert Schottky monitor
-schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1/tw.T_rev0,
+schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1 / tw.T_rev0,
                                                schottky_harmonic=427_725,
                                                n_taylor=4)
 line.discard_tracker()
@@ -50,7 +50,7 @@
 
 schottky_monitor.plot()
 # Or plot specific regions in log scale
-#schottky_monitor.plot(regions=['lowerH','center','upperH'], log=True)
+# schottky_monitor.plot(regions=['lowerH','center','upperH'], log=True)
 
 
 # (Optional) accumulate additional statistics: uncomment for more averaging
@@ -61,7 +61,7 @@
 #                                   x=True, y=False, z=True)
 # schottky_monitor.plot(regions=['lowerH','center','upperH'], log=True)
 
-# Re-process with different processing parameters (without tracking again)
+# Reprocess with different processing parameters (without tracking again)
 schottky_monitor.clear_spectrum()
 schottky_monitor.process_spectrum(inst_spectrum_len=5000, delta_q=5e-5,
                                   band_width=0.1, qx=0.27, qy=0.295,
diff --git a/tests/test_schottky.py b/tests/test_schottky.py
index 3e131687c..8e477580d 100644
--- a/tests/test_schottky.py
+++ b/tests/test_schottky.py
@@ -4,63 +4,84 @@
 
 # Function used for testing
 def extract_qs_spacings(f, psd, window_width=0.15, threshold=0.01):
-    # Extract the distance between succesive peaks in the spectrum
-    # Only works for single particle spectra
-    
-    # Restrict to a window around central frequency
-    mask = np.abs(f- np.mean(f)) < 0.5 * window_width
-    f_win = f[mask]
-    psd_win = psd[mask]
+	# Extract the distance between successive peaks in the spectrum
+	# Only works for single particle spectra
 
-    # Find peaks in the windowed PSD with minimum heights threshold
-    peaks, _ = find_peaks(psd_win, height=np.max(psd_win)*threshold)
-    peak_freqs = np.sort(f_win[peaks])
+	# Restrict to a window around central frequency
+	mask = np.abs(f - np.mean(f)) < 0.5 * window_width
+	f_win = f[mask]
+	psd_win = psd[mask]
 
-    # Compute spacings
-    spacings = np.diff(peak_freqs)
-    return spacings
+	# Find peaks in the windowed PSD with minimum heights threshold
+	peaks, _ = find_peaks(psd_win, height=np.max(psd_win) * threshold)
+	peak_freqs = np.sort(f_win[peaks])
+	
+	# Compute spacings
+	spacings = np.diff(peak_freqs)
+	return spacings
 
 def test_qs_qx_qy_linear_rf():
 	# Create a line with a linear RF and add Schottky monitor
-	lmap = xt.LineSegmentMap(length=26658.8831999989, qx=0.27, qy=0.295, dqx=15, dqy=15, 
-						  longitudinal_mode='linear_fixed_qs', qs=0.004, bets=1, betx=1, bety=1)
+	lmap = xt.LineSegmentMap(
+		length=26658.8831999989,
+		qx=0.27,
+		qy=0.295,
+		dqx=15,
+		dqy=15,
+		longitudinal_mode='linear_fixed_qs',
+		qs=0.004,
+		bets=1,
+		betx=1,
+		bety=1,
+	)
 	line = xt.Line(elements=[lmap])
 	line.particle_ref = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1, energy0=450e9)
 	twiss = line.twiss()
-	schottky_monitor = xt.monitors.SchottkyMonitor(f_rev=1/twiss.T_rev0, schottky_harmonic=427_725, n_taylor=4)
+	schottky_monitor = xt.monitors.SchottkyMonitor(
+		f_rev=1 / twiss.T_rev0, schottky_harmonic=427_725, n_taylor=4
+	)
 	line.discard_tracker()
 	line.append_element(element=schottky_monitor, name='Schottky monitor')
 	line.build_tracker()
 	# Track single particle
 	particle = line.build_particles(
-                        x=1e-3,
-                        px=0,
-                        y=1e-3,
-                        py=0,
-                        zeta=1e-2,
-                        delta=0)
+		x=1e-3,
+		px=0,
+		y=1e-3,
+		py=0,
+		zeta=1e-2,
+		delta=0,
+	)
 	line.track(particle, num_turns=10000, with_progress=True)
-	schottky_monitor.process_spectrum(inst_spectrum_len=10000, delta_q=5e-5, band_width=0.45, qx=line.elements[0].qx, qy=line.elements[0].qy)
+	schottky_monitor.process_spectrum(
+		inst_spectrum_len=10000,
+		delta_q=5e-5,
+		band_width=0.45,
+		qx=line.elements[0].qx,
+		qy=line.elements[0].qy,
+	)
 
-	# Test syncrotron tune on each band
+	# Test synchrotron tune on each band
 	for region in ['lowerH', 'center', 'upperH', 'lowerV', 'upperV']:
-		spacings = extract_qs_spacings(schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region])
-		# Assert that each value in spacings is close to line.elements[0].qs or an integer multiple of it (some peaks might have a height of 0)
+		spacings = extract_qs_spacings(
+			schottky_monitor.frequencies[region], schottky_monitor.PSD_avg[region]
+		)
+		# Assert that each spacing is close to qs or an integer multiple (some peaks may be zero)
 		qs_ref = line.elements[0].qs
 		multiples = np.round(spacings / qs_ref,)
 		np.testing.assert_allclose(spacings, multiples * qs_ref, atol=1e-4) #atol = 2*delta_q (resolution of the spectra)
 
-	# Test vertical and hoirizontal betatron tunes
+	# Test vertical and horizontal betatron tunes
 	for region in ['lowerH', 'upperH', 'lowerV', 'upperV']:
 		window_width = 0.45
 		f = schottky_monitor.frequencies[region]
 		psd = schottky_monitor.PSD_avg[region]
 
 		# Restrict to a window around central frequency
-		mask = np.abs(f- np.mean(f)) < 0.5 * window_width
+		mask = np.abs(f - np.mean(f)) < 0.5 * window_width
 		f_win = f[mask]
 		psd_win = psd[mask]
-		# Check that full band is used to compute com and no overlap with band from adjacent harmonics
+		# Check that full band is used to compute com and no overlap with adjacent harmonics
 		assert np.all(psd_win[:300] < 0.001 * np.max(psd_win))
 		assert np.all(psd_win[-300:] < 0.001 * np.max(psd_win))
 
@@ -72,4 +93,4 @@ def test_qs_qx_qy_linear_rf():
 		elif region in ['lowerV', 'upperV']:
 			np.testing.assert_allclose(f_com_full, line.elements[0].qy, atol=5e-5) 
 
-# To Do: add test for non-linear RF
\ No newline at end of file
+# TODO: add test for nonlinear RF
\ No newline at end of file
diff --git a/xtrack/monitors/schottky_monitor.py b/xtrack/monitors/schottky_monitor.py
index 666514ec5..6a4619e22 100644
--- a/xtrack/monitors/schottky_monitor.py
+++ b/xtrack/monitors/schottky_monitor.py
@@ -80,9 +80,9 @@ def process_spectrum(self, inst_spectrum_len, delta_q, band_width, qx, qy,
             Multiply time signal by flattop window, else no windowing used (=rectangular window).
         """
         if inst_spectrum_len > len(self.x_coeff):
-            raise ValueError(f'Not enough turns tracked to produce a single instataneous spectra \n \
+            raise ValueError(f'Not enough turns tracked to produce one instantaneous spectra \n \
                                Number of turns tracked: {len(self.x_coeff)} \n \
-                               Length of instataneous spectra: {inst_spectrum_len}')
+                               Length of instantaneous spectra: {inst_spectrum_len}')
         if band_width <= 0 or band_width >= 1:
             raise ValueError('band_width must be a normalised frequency f/f_rev with 0 < band_width < 1')
         
@@ -96,14 +96,14 @@ def process_spectrum(self, inst_spectrum_len, delta_q, band_width, qx, qy,
         elif any(self.processing_param[key] != value
                  for key, value in locals().items() if key not in ['x', 'y', 'z']):
             raise ValueError('Different parameters for the processing, ' +
-                             'keep the same parameters (exept x, y and z) or use "clear_spectrum()". \n' +
+                             'keep the same parameters (except x, y and z) or use "clear_spectrum()". \n' +
                              'Existing parameters:' + str(self.processing_param) + '\n New parameters:' + str(locals()))
         if flattop_window:
             window = sp.signal.windows.flattop(inst_spectrum_len)
         else:
             window = np.ones(inst_spectrum_len)
-        window /= np.sum(window) # Normalising window
-        
+        window /= np.sum(window)  # Normalizing window
+
         region_to_process = []
         if x: region_to_process.extend(['lowerH', 'upperH'])
         if y: region_to_process.extend(['lowerV', 'upperV'])
@@ -123,19 +123,31 @@ def process_spectrum(self, inst_spectrum_len, delta_q, band_width, qx, qy,
             # Computing instataneous Schottky spectra as defined in Eqs. (2.2) and (2.4)
             n_freq = len(freq)
             delta_omega = freq * 2 * np.pi * self.f_rev
-            alpha = np.empty((self.n_taylor,n_freq), dtype=np.csingle)
-            alpha[0,:] = np.ones(n_freq)
-            for l in range(1,self.n_taylor):
-                alpha[l,:] = alpha[l-1,:] * 1j * delta_omega / l
-            first_exponential = (np.vander(np.exp(1j*delta_omega/self.f_rev),
-                                           N=inst_spectrum_len, increasing=True) * window).T  
+            alpha = np.empty((self.n_taylor, n_freq), dtype=np.csingle)
+            alpha[0, :] = np.ones(n_freq)
+            for l in range(1, self.n_taylor):
+                alpha[l, :] = alpha[l - 1, :] * 1j * delta_omega / l
+            first_exponential = (
+                np.vander(
+                    np.exp(1j * delta_omega / self.f_rev),
+                    N=inst_spectrum_len,
+                    increasing=True,
+                )
+                * window
+            ).T
             n_inst_spectra = len(coeff) // inst_spectrum_len
             for i in range(len(self.instantaneous_PSDs[region]), n_inst_spectra):
                 print(f'Processing {region} Schottky spectrum {i+1}/{n_inst_spectra}', end='\r')
-                # Seclecting the coefficient (x, y, or z) needed to calculated the i^th instataneous Schottky spectra
-                inst_coeff = np.array(coeff[i*inst_spectrum_len:(i+1)*inst_spectrum_len])
-                spectrum = np.sum(np.dot(inst_coeff,alpha) * first_exponential, axis=0)
-                self.instantaneous_PSDs[region].append(abs(spectrum)**2 / self.N_macropart_max)
+                # Selecting the coefficients (x, y, or z) needed to calculate the i-th instantaneous Schottky spectrum
+                inst_coeff = np.array(
+                    coeff[i * inst_spectrum_len : (i + 1) * inst_spectrum_len]
+                )
+                spectrum = np.sum(
+                    np.dot(inst_coeff, alpha) * first_exponential, axis=0
+                )
+                self.instantaneous_PSDs[region].append(
+                    abs(spectrum) ** 2 / self.N_macropart_max
+                )
             self.PSD_avg[region] = np.mean(self.instantaneous_PSDs[region], axis=0)
             print(f'{region} band of Schottky spectrum processed')
         self._check_Taylor_approx()
@@ -143,51 +155,51 @@ def process_spectrum(self, inst_spectrum_len, delta_q, band_width, qx, qy,
     def _init_processing(self, delta_q, qx, qy, band_width):
         '''
         For each region of the Schottky spectrum, create an array of normalised frequencies 
-        from -band_with/2 to +band_with/2 around the center of the Schottky band. 
+        from -band_width/2 to +band_width/2 around the center of the Schottky band. 
         '''
         n_freq = band_width / delta_q
         center_freq = np.arange(-(n_freq//2), (n_freq)//2) * band_width / n_freq
         self.frequencies = {
-            'lowerH': center_freq - (qx%1),
-            'upperH': center_freq + (qx%1),
-            'lowerV': center_freq - (qy%1),
-            'upperV': center_freq + (qy%1),
-            'center': center_freq
+            'lowerH': center_freq - (qx % 1),
+            'upperH': center_freq + (qx % 1),
+            'lowerV': center_freq - (qy % 1),
+            'upperV': center_freq + (qy % 1),
+            'center': center_freq,
         }
-        # Create dic where the instataneous and averaged PSDs will be stored
+        # Create dict where the instantaneous and averaged PSDs will be stored
         self.instantaneous_PSDs = {i: [] for i in self.frequencies.keys()}
         self.PSD_avg = {i: [] for i in self.frequencies.keys()}
 
     def _check_Taylor_approx(self):
-        #Longitudinal band, Eq. (2.3)
+    # Longitudinal band, Eq. (2.3)
         if self.processing_param['z']:
             delta_omega_max = max(self.frequencies['center']) * 2 * np.pi * self.f_rev
             max_error = self.N_macropart_max**0.5 * (delta_omega_max*self.tau_max)**self.n_taylor * \
                         np.exp(delta_omega_max*self.tau_max) / sp.special.factorial(self.n_taylor)
             if np.sqrt(self.PSD_avg['center'][0]) < 100 * max_error:
                 print('Number of Taylor terms too low for the longitudinal band')
-            print(f'Maximal Talor truncation error in z plane to be compared against sqrt(PSD): {max_error}')
+            print(f'Maximal Taylor truncation error in z plane to be compared against sqrt(PSD): {max_error}')
 
-        #transverse bands
+    # Transverse bands
         if self.processing_param['x']:
             delta_omega_max = max(self.frequencies['upperH']) * 2 * np.pi * self.f_rev
             max_error = self.N_macropart_max**0.5 * self.x_max * (delta_omega_max*self.tau_max)**self.n_taylor * \
                         np.exp(delta_omega_max*self.tau_max) / sp.special.factorial(self.n_taylor)
             if np.sqrt(self.PSD_avg['upperH'][0]) < 100 * max_error:
                 print('Number of Taylor terms too low for the horizontal bands')
-            print(f'Maximal Talor truncation error in x plane to be compared against sqrt(PSD): {max_error}')
+            print(f'Maximal Taylor truncation error in x plane to be compared against sqrt(PSD): {max_error}')
         if self.processing_param['y']:
             delta_omega_max = max(self.frequencies['upperV']) * 2 * np.pi * self.f_rev
             max_error = self.N_macropart_max**0.5 * self.y_max * (delta_omega_max*self.tau_max)**self.n_taylor * \
                         np.exp(delta_omega_max*self.tau_max) / sp.special.factorial(self.n_taylor)
             if np.sqrt(self.PSD_avg['upperV'][0]) < 100 * max_error:
                 print('Number of Taylor terms too low for the vertical bands')
-            print(f'Maximal Talor truncation error in y plane to be compared against sqrt(PSD): {max_error}')
+            print(f'Maximal Taylor truncation error in y plane to be compared against sqrt(PSD): {max_error}')
 
     def clear_spectrum(self):
         """
         Clear the instantaneous spectra but keep the coefficients L and T.
-        Can be use to recompute Schottky spectra for different processing 
+        Can be used to re-compute Schottky spectra for different processing 
         parameters (window, frequency resolution, band widths) without 
         tracking the particles again
         """