diff --git a/archive/mapcopy.py b/archive/mapcopy.py new file mode 100644 index 0000000..52e3038 --- /dev/null +++ b/archive/mapcopy.py @@ -0,0 +1,204 @@ +import sys +import folium +import os +import pandas as pd +import matplotlib.pyplot as plt +import numpy as np +from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QLineEdit, QPushButton, QLabel, QFormLayout +from PyQt5.QtWebEngineWidgets import QWebEngineView, QWebEnginePage +from PyQt5.QtCore import QUrl +import preprocessing as pr +import constants +import socket + +# Step 1: Custom QWebEnginePage to handle the JavaScript interaction +class MyWebEnginePage(QWebEnginePage): + def acceptNavigationRequest(self, url, _type, is_main_frame): + # Handle any other navigation if needed + return super().acceptNavigationRequest(url, _type, is_main_frame) + +class StationPlotApp(QMainWindow): + def __init__(self, parent_path): + super().__init__() + + self.setWindowTitle("Station Plot App") + self.setGeometry(100, 100, 1600, 900) # Set window size + + self.central_widget = QWidget() + self.setCentralWidget(self.central_widget) + + self.main_layout = QHBoxLayout(self.central_widget) + + self.parent_path = parent_path + self.pre = pr.Preprocessor(parent_path) + + self.create_controls() + self.create_map() + + def create_map(self): + # Create map widget and add to layout + self.map_layout = QVBoxLayout() + self.map = folium.Map(location=[0, 0], zoom_start=2) + + # Save the map to an HTML file in the current directory + current_dir = os.path.dirname(os.path.abspath(__file__)) # Get the current file directory + map_path = os.path.join(current_dir, 'map.html') + self.map.save(map_path) + + # Set up QWebEngineView + self.web_view = QWebEngineView() + self.web_view.setPage(MyWebEnginePage(self)) # Use the custom page + self.web_view.setUrl(QUrl.fromLocalFile(map_path)) + self.web_view.loadFinished.connect(self.on_page_load_finished) # Connect loadFinished signal + self.map_layout.addWidget(self.web_view) + + # Add the map layout to the main layout + self.main_layout.addLayout(self.map_layout, stretch=4) + + def on_page_load_finished(self): + # Define the JavaScript function after the page has loaded + js_code = """ + function plotStation(stationId) { + console.log('Station ID: ' + stationId); + qt.python.call('plotStation', stationId); // Call the Python function + } + """ + self.web_view.page().runJavaScript(js_code) + + def create_controls(self): + # Create a layout for the control inputs and condense them into the top-right corner + control_layout = QFormLayout() + + self.load_percentage_input = QLineEdit() + self.load_percentage_input.setPlaceholderText("5") + control_layout.addRow(QLabel("Load Percentage:"), self.load_percentage_input) + + self.magnitude_threshold_input = QLineEdit() + self.magnitude_threshold_input.setPlaceholderText("Enter magnitude threshold") + control_layout.addRow(QLabel("Magnitude Threshold:"), self.magnitude_threshold_input) + + self.earthquake_count_input = QLineEdit() + self.earthquake_count_input.setPlaceholderText("Enter earthquake count") + control_layout.addRow(QLabel("Earthquake Count:"), self.earthquake_count_input) + + self.load_plot_button = QPushButton("Load and Plot") + self.load_plot_button.clicked.connect(self.load_data) + control_layout.addRow(self.load_plot_button) + + self.info_label = QLabel("Load and filter data to see the details here.") + control_layout.addRow(self.info_label) + + # Create a container widget for controls and add it to the top-right corner + controls_container = QWidget() + controls_container.setLayout(control_layout) + self.main_layout.addWidget(controls_container, stretch=1) + + def load_data(self): + load_percentage = int(self.load_percentage_input.text() or 5) + magnitude_threshold = float(self.magnitude_threshold_input.text()) if self.magnitude_threshold_input.text() else None + earthquake_count = int(self.earthquake_count_input.text()) if self.earthquake_count_input.text() else None + + # Load and filter the data + self.tenvs = self.pre.load_combined_df(load_percentage=load_percentage, + target_magnitude=magnitude_threshold, + eq_count=earthquake_count, save=True) + + self.update_map() + + def update_map(self): + # Filter stat_position_df based on the stations in main_df + filtered_stations = self.pre.load_station_info() # Load station information + + station_ids_in_main_df = self.tenvs['Station ID'].unique() + filtered_stations = filtered_stations[filtered_stations['Station ID'].isin(station_ids_in_main_df)] + + # Re-create the map with filtered stations + self.map = folium.Map(location=[0, 0], zoom_start=2) + for index, row in filtered_stations.iterrows(): + station_id = row['Station ID'] + + # Get the magnitudes and count of earthquakes for this station + station_eqs = self.tenvs[self.tenvs['Station ID'] == station_id] + magnitudes = station_eqs['Event Magnitude'].dropna().tolist() # Filter out NaNs + earthquake_count = len(magnitudes) + + # If no magnitudes are available after filtering, skip this marker + if earthquake_count == 0: + continue + + # Create a popup with magnitudes and earthquake count information + popup_content = f""" + Station ID: {station_id}
+ Earthquake Count: {earthquake_count}
+ Magnitudes: {', '.join(map(str, magnitudes))}
+ + """ + popup = folium.Popup(popup_content, max_width=300) + + marker = folium.Marker( + location=[row['Lat'], row['Long']], + popup=popup, + icon=folium.Icon(color='red', icon='info-sign') + ) + marker.add_to(self.map) + + # Save the updated map and reload it in the web view + current_dir = os.path.dirname(os.path.abspath(__file__)) + map_path = os.path.join(current_dir, 'map.html') + self.map.save(map_path) + + # Reload the web view with the updated map + self.web_view.setUrl(QUrl.fromLocalFile(map_path)) + + def showPlot(self, station_id): + station_eqs = self.tenvs[self.tenvs['Station ID'] == station_id] + displacement_data = [] + + # Calculate displacements for each unique event ID + for event_id in station_eqs['Event ID'].dropna().unique(): + event_data = station_eqs[station_eqs['Event ID'] == event_id] + + if len(event_data) >= 2: + event_data_sorted = event_data.sort_values('Date') + day_before = event_data_sorted.iloc[0] + day_after = event_data_sorted.iloc[-1] + + delta_e_displacement = abs(day_after['Delta E'] - day_before['Delta E']) + delta_n_displacement = abs(day_after['Delta N'] - day_before['Delta N']) + delta_v_displacement = abs(day_after['Delta V'] - day_before['Delta V']) + + displacement_data.append( + [day_after['Event Magnitude'], delta_e_displacement, delta_n_displacement, delta_v_displacement]) + + if displacement_data: + self.plot_displacement(displacement_data, station_id) + + def plot_displacement(self, displacement_data, station_id): + displacement_df = pd.DataFrame(displacement_data, columns=['Magnitude', 'Delta E', 'Delta N', 'Delta V']) + displacement_grouped = displacement_df.groupby('Magnitude').mean().reset_index() + displacement_grouped[['Delta E', 'Delta N', 'Delta V']] = displacement_grouped[ + ['Delta E', 'Delta N', 'Delta V']].apply(lambda x: x / x.max()) + + fig, ax = plt.subplots(figsize=(12, 6)) + bar_width = 0.2 + index = np.arange(len(displacement_grouped)) + + ax.bar(index, displacement_grouped['Delta E'], bar_width, label='Delta E') + ax.bar(index + bar_width, displacement_grouped['Delta N'], bar_width, label='Delta N') + ax.bar(index + 2 * bar_width, displacement_grouped['Delta V'], bar_width, label='Delta V') + + ax.set_xlabel('Magnitude') + ax.set_ylabel('Normalized Displacement') + ax.set_title(f'Normalized Displacement by Magnitude for Station {station_id}') + ax.set_xticks(index + bar_width) + ax.set_xticklabels(displacement_grouped['Magnitude'].round(2)) + ax.legend() + + plt.show() + +if __name__ == '__main__': + parent_path = constants.PATHS.get(socket.gethostname(), '/default/path/to/data') + app = QApplication(sys.argv) + window = StationPlotApp(parent_path) + window.show() + sys.exit(app.exec_()) \ No newline at end of file diff --git a/browsing.py b/browsing.py index cab3565..2d091d7 100644 --- a/browsing.py +++ b/browsing.py @@ -13,146 +13,123 @@ def __init__(self, parent_path): super().__init__() self.setWindowTitle("Station Plot App") - # Increase the window height for larger plots self.setGeometry(100, 100, 1200, 900) self.central_widget = QWidget() self.setCentralWidget(self.central_widget) - self.layout = QVBoxLayout(self.central_widget) + + # Use a horizontal layout for the main layout + self.main_layout = QHBoxLayout(self.central_widget) self.parent_path = parent_path self.pre = pr.Preprocessor(parent_path) + self.filtered_tenvs_list = [] + self.create_plot() self.create_controls() - self.create_input_fields() def create_plot(self): - # Increase the figure height self.fig = Figure(figsize=(10, 9), dpi=100) - self.axs = [self.fig.add_subplot(311), self.fig.add_subplot( - 312), self.fig.add_subplot(313)] + self.axs = [self.fig.add_subplot(311), self.fig.add_subplot(312), self.fig.add_subplot(313)] self.canvas = FigureCanvas(self.fig) - self.layout.addWidget(self.canvas) + self.main_layout.addWidget(self.canvas) def create_controls(self): - control_layout = QHBoxLayout() + control_layout = QVBoxLayout() - self.search_bar = QLineEdit() - self.search_bar.setPlaceholderText("Search Station") - control_layout.addWidget(self.search_bar) - - search_button = QPushButton("Search") - search_button.clicked.connect(self.submit_search) - control_layout.addWidget(search_button) - - prev_button = QPushButton("Previous") - prev_button.clicked.connect(self.prev_station) - control_layout.addWidget(prev_button) + self.load_percentage_input = QLineEdit() + self.load_percentage_input.setPlaceholderText("5") + control_layout.addWidget(QLabel("Load Percentage")) + control_layout.addWidget(self.load_percentage_input) - next_button = QPushButton("Next") - next_button.clicked.connect(self.next_station) - control_layout.addWidget(next_button) + self.magnitude_threshold_input = QLineEdit() + self.magnitude_threshold_input.setPlaceholderText("Enter magnitude threshold") + control_layout.addWidget(QLabel("Magnitude Threshold")) + control_layout.addWidget(self.magnitude_threshold_input) - self.layout.addLayout(control_layout) + self.earthquake_count_input = QLineEdit() + self.earthquake_count_input.setPlaceholderText("Enter earthquake count") + control_layout.addWidget(QLabel("Earthquake Count")) + control_layout.addWidget(self.earthquake_count_input) # Station list self.station_list_widget = QListWidget() - self.station_list_widget.currentItemChanged.connect( - self.on_station_select) + self.station_list_widget.currentItemChanged.connect(self.on_station_select) scroll_area = QScrollArea() scroll_area.setWidget(self.station_list_widget) scroll_area.setWidgetResizable(True) - self.layout.addWidget(scroll_area) - - def create_input_fields(self): - form_layout = QFormLayout() - - self.load_percentage_input = QLineEdit() - self.load_percentage_input.setPlaceholderText("5") - form_layout.addRow("Load Percentage", self.load_percentage_input) + control_layout.addWidget(scroll_area) - self.magnitude_threshold_input = QLineEdit() - self.magnitude_threshold_input.setPlaceholderText( - "Enter magnitude threshold") - form_layout.addRow("Magnitude Threshold", - self.magnitude_threshold_input) + self.search_bar = QLineEdit() + self.search_bar.setPlaceholderText("Search Station") + control_layout.addWidget(self.search_bar) - self.earthquake_count_input = QLineEdit() - self.earthquake_count_input.setPlaceholderText( - "Enter earthquake count") - form_layout.addRow("Earthquake Count", self.earthquake_count_input) + search_button = QPushButton("Search") + search_button.clicked.connect(self.submit_search) + control_layout.addWidget(search_button) - self.plot_button = QPushButton("Plot") - self.plot_button.clicked.connect(self.load_data) - form_layout.addRow(self.plot_button) + self.load_plot_button = QPushButton("Load and Plot") + self.load_plot_button.clicked.connect(self.load_data) + control_layout.addWidget(self.load_plot_button) - self.info_label = QLabel( - "Load and filter data to see the details here.") - form_layout.addRow(self.info_label) + self.info_label = QLabel("Load and filter data to see the details here.") + control_layout.addWidget(self.info_label) - self.layout.addLayout(form_layout) + self.main_layout.addLayout(control_layout) def load_data(self): load_percentage = int(self.load_percentage_input.text() or 5) - magnitude_threshold = float(self.magnitude_threshold_input.text( - )) if self.magnitude_threshold_input.text() else None - earthquake_count = int(self.earthquake_count_input.text( - )) if self.earthquake_count_input.text() else None + magnitude_threshold = float(self.magnitude_threshold_input.text()) if self.magnitude_threshold_input.text() else None + earthquake_count = int(self.earthquake_count_input.text()) if self.earthquake_count_input.text() else None # Load and filter the data self.tenvs = self.pre.load_combined_df(load_percentage=load_percentage, target_magnitude=magnitude_threshold, - eq_count=earthquake_count) + eq_count=earthquake_count, save=True) - self.filtered_tenvs_list = tenv_utils.split_combined_df_to_list( - self.tenvs) + self.filtered_tenvs_list = tenv_utils.split_combined_df_to_list(self.tenvs) self.index = 0 # Update the station list self.station_list_widget.clear() for df in self.filtered_tenvs_list: station_id = df['Station ID'].iloc[0] - num_eqs = df['Event ID'].nunique( - ) if 'Event ID' in df.columns else 0 + num_eqs = df['Event ID'].nunique() if 'Event ID' in df.columns else 0 self.station_list_widget.addItem(f"{station_id} - {num_eqs} EQs") - self.info_label.setText( - f"Loaded {len(self.filtered_tenvs_list)} stations.") + self.info_label.setText(f"Loaded {len(self.filtered_tenvs_list)} stations.") # Initially clear the plot for ax in self.axs: ax.clear() self.canvas.draw() + # Plot the first station's data if available + if self.filtered_tenvs_list: + self.plot_tenv_data(self.filtered_tenvs_list[0], self.filtered_tenvs_list[0]['Station ID'].iloc[0]) + def plot_tenv_data(self, tenv_df, station_name): for ax in self.axs: ax.clear() - # Print the station name and first few rows for debugging - print(f"Plotting data for station: {station_name}") - print(tenv_df.head()) - # Plot Delta E - self.axs[0].scatter(tenv_df['Date'], tenv_df['Delta E'], - label='Delta E', c='blue', s=10) + self.axs[0].scatter(tenv_df['Date'], tenv_df['Delta E'], label='Delta E', c='blue', s=10) self.axs[0].set_title(f'{station_name} Delta E', fontsize=10, pad=15) self.axs[0].set_ylabel('Delta E') self.axs[0].legend() self.axs[0].grid(True) # Plot Delta N - self.axs[1].scatter(tenv_df['Date'], tenv_df['Delta N'], - label='Delta N', c='green', s=10) + self.axs[1].scatter(tenv_df['Date'], tenv_df['Delta N'], label='Delta N', c='green', s=10) self.axs[1].set_title(f'{station_name} Delta N', fontsize=10, pad=15) self.axs[1].set_ylabel('Delta N') self.axs[1].legend() self.axs[1].grid(True) # Plot Delta V - self.axs[2].scatter(tenv_df['Date'], tenv_df['Delta V'], - label='Delta V', c='red', s=10) + self.axs[2].scatter(tenv_df['Date'], tenv_df['Delta V'], label='Delta V', c='red', s=10) self.axs[2].set_title(f'{station_name} Delta V', fontsize=10, pad=15) self.axs[2].set_xlabel('Date') self.axs[2].set_ylabel('Delta V') @@ -162,41 +139,25 @@ def plot_tenv_data(self, tenv_df, station_name): # Filter earthquake events for the current station station_events = tenv_df[tenv_df['Event Magnitude'].notna()] - # Debug print to verify number of events - print( - f"Plotting {len(station_events)} earthquake events for station: {station_name}") - - # Debug print to show event data - if not station_events.empty: - print(station_events[['Date', 'Event Magnitude', 'Event ID']]) - - # Plot earthquake events on each axis if they exist + # Plot earthquake events on each axis and annotate their magnitudes if they exist if not station_events.empty: for ax in self.axs: for _, event in station_events.iterrows(): - ax.axvline(event['Date'], color='purple', - linestyle='--', label='Earthquake Event') + ax.axvline(event['Date'], color='purple', linestyle='--', label='Earthquake Event') + # Ensure magnitudes don't overlap by slightly adjusting vertical position + text_y_position = ax.get_ylim()[0] + 0.95 * (ax.get_ylim()[1] - ax.get_ylim()[0]) + ax.text(event['Date'], text_y_position, f"{event['Event Magnitude']:.1f}", + rotation=90, verticalalignment='center', horizontalalignment='right', color='purple') self.fig.tight_layout() self.canvas.draw() - def next_station(self): - self.index = (self.index + 1) % len(self.filtered_tenvs_list) - station_name = self.filtered_tenvs_list[self.index]['Station ID'].iloc[0] - self.plot_tenv_data(self.filtered_tenvs_list[self.index], station_name) - - def prev_station(self): - self.index = (self.index - 1) % len(self.filtered_tenvs_list) - station_name = self.filtered_tenvs_list[self.index]['Station ID'].iloc[0] - self.plot_tenv_data(self.filtered_tenvs_list[self.index], station_name) - def submit_search(self): station_name = self.search_bar.text().strip().upper() for i, df in enumerate(self.filtered_tenvs_list): if df['Station ID'].iloc[0] == station_name: self.index = i - self.plot_tenv_data( - self.filtered_tenvs_list[self.index], station_name) + self.plot_tenv_data(self.filtered_tenvs_list[self.index], station_name) self.station_list_widget.setCurrentRow(self.index) return print(f"Station {station_name} not found") @@ -205,15 +166,13 @@ def on_station_select(self, current, previous): if current: station_name = current.text().split(" - ")[0] self.index = self.station_list_widget.currentRow() - self.plot_tenv_data( - self.filtered_tenvs_list[self.index], station_name) + self.plot_tenv_data(self.filtered_tenvs_list[self.index], station_name) if __name__ == '__main__': hostname = socket.gethostname() parent_path = constants.PATHS.get(hostname, '/default/path/to/data') - app = QApplication(sys.argv) window = StationPlotApp(parent_path) window.show() - sys.exit(app.exec_()) + sys.exit(app.exec_()) \ No newline at end of file diff --git a/constants.py b/constants.py index f280158..0a9497c 100644 --- a/constants.py +++ b/constants.py @@ -1,4 +1,5 @@ -PATHS = {'Sarps-MBP':'/Users/sarpvulas/geodesy.unr.edu/gps_timeseries/tenv/', +PATHS = {'Sarps-MacBook-Pro.local':'/Users/sarpvulas/geodesy.unr.edu/gps_timeseries/tenv/', 'Kemalcans-MacBook-Pro.local':'/Users/kemalcankucuk/Documents/kuis-matam-summerproject/geodesy_data', + '192.168.1.105':'/Users/kemalcankucuk/Documents/kuis-matam-summerproject/geodesy_data', 'Zeyneps-MacBook-Pro-2.local':'/Users/zeynepaydin/geodesy.unr.edu/gps_timeseries/tenv/', 'Zeyneps-MBP-2.home':'/Users/zeynepaydin/geodesy.unr.edu/gps_timeseries/tenv/'} \ No newline at end of file diff --git a/intro.py b/intro.py index 9838a9c..503c9f2 100644 --- a/intro.py +++ b/intro.py @@ -3,7 +3,7 @@ import pandas as pd import os from matplotlib import pyplot as plt -from matplotlib.widgets import Button +from matplotlib.widgets import Button, TextBox import preprocessing as pr import tenv_utils @@ -11,7 +11,7 @@ def main(): hostname = socket.gethostname() # kendi hostnaminizi print ettirin ona göre path ekleyin. - if hostname == 'Sarps-MBP': + if hostname == 'Sarps-MacBook-Pro.local': print("kral hoşgeldin.") parent_path = '/Users/sarpvulas/geodesy.unr.edu/gps_timeseries/tenv/' elif hostname == 'Kemalcans-MacBook-Pro.local': @@ -27,74 +27,129 @@ def main(): # Load 5% of the available tenv files by default as a list of DataFrames tenvs = pre.load_tenv_file_df(pre.tenvs) - # If 1-1 mapping is required. - #pre.create_index_file_mapping() + # Define the parameter ranges for Grid Search + n_neighbors_range = [5, 10, 15, 20, 25] + contamination_range = [0.01, 0.02, 0.05] + + #best_params = tenv_utils.manual_lof_optimization(tenvs, cols=['Delta E', 'Delta N', 'Delta V'], n_neighbors_range=n_neighbors_range, contamination_range=contamination_range, search_type='grid') + + #print(f"Best LOF parameters found: {best_params}") # Outlier points are deleted, series containing huge gaps are eliminated. gap_tolerance = 100 - filtered_tenvs, stations_with_gaps = tenv_utils.apply_filtering(tenvs, gap_tolerance=gap_tolerance) - filtered_tenvs = tenv_utils.split_combined_df_to_list(filtered_tenvs) - - fig, axs = plt.subplots(3, 1, figsize=(6, 9), sharex=True) + method = 'lof' # Choose the method to use: 'lof' + #kwargs = best_params # Additional parameters for the method + kwargs = {'n_neighbors': 20, 'contamination': 0.35} + filtered_tenvs, stations_with_gaps, outlier_counts = tenv_utils.apply_filtering(tenvs, gap_tolerance=gap_tolerance, + method=method, **kwargs) + filtered_tenvs_list = tenv_utils.split_combined_df_to_list(filtered_tenvs) + + fig, axs = plt.subplots(3, 2, figsize=(12, 9), sharex='col') fig.suptitle('GPS Timeseries Data', fontsize=16) index = [0] # Mutable index to track the current station - print(f"Currently, {100 * len(stations_with_gaps) / len(tenvs):.2f}% of the stations are being filtered out with a gap tolerance of {gap_tolerance}") + print( + f"Currently, {100 * len(stations_with_gaps) / len(tenvs):.2f}% of the stations are being filtered out with a gap tolerance of {gap_tolerance}") def next_station(event): - index[0] = (index[0] + 1) % len(filtered_tenvs) - station_name = filtered_tenvs[index[0]]['Station ID'].iloc[0] - plot_tenv_data(axs, filtered_tenvs[index[0]], station_name) + index[0] = (index[0] + 1) % len(filtered_tenvs_list) + station_name = filtered_tenvs_list[index[0]]['Station ID'].iloc[0] + plot_tenv_data(axs, filtered_tenvs_list[index[0]], tenvs[tenvs['Station ID'] == station_name], station_name, + outlier_counts) def prev_station(event): - index[0] = (index[0] - 1) % len(filtered_tenvs) - station_name = filtered_tenvs[index[0]]['Station ID'].iloc[0] - plot_tenv_data(axs, filtered_tenvs[index[0]], station_name) - - plot_tenv_data(axs, filtered_tenvs[index[0]], filtered_tenvs[index[0]]['Station ID'].iloc[0]) - - plt.subplots_adjust(bottom=0.15) + index[0] = (index[0] - 1) % len(filtered_tenvs_list) + station_name = filtered_tenvs_list[index[0]]['Station ID'].iloc[0] + plot_tenv_data(axs, filtered_tenvs_list[index[0]], tenvs[tenvs['Station ID'] == station_name], station_name, + outlier_counts) + + def search_station(event): + station_name = text_box.text.upper() # Convert input to uppercase + station_index = next((i for i, df in enumerate(filtered_tenvs_list) if df['Station ID'].iloc[0] == station_name), None) + if station_index is not None: + index[0] = station_index + plot_tenv_data(axs, filtered_tenvs_list[index[0]], tenvs[tenvs['Station ID'] == station_name], station_name, + outlier_counts) + else: + print(f"Station {station_name} not found.") + + plot_tenv_data(axs, filtered_tenvs_list[index[0]], + tenvs[tenvs['Station ID'] == filtered_tenvs_list[index[0]]['Station ID'].iloc[0]], + filtered_tenvs_list[index[0]]['Station ID'].iloc[0], outlier_counts) + + plt.subplots_adjust(bottom=0.35) axprev = plt.axes([0.35, 0.02, 0.1, 0.04]) axnext = plt.axes([0.55, 0.02, 0.1, 0.04]) + axbox = plt.axes([0.35, 0.1, 0.3, 0.04]) + axsearch = plt.axes([0.68, 0.1, 0.1, 0.04]) bnext = Button(axnext, 'Next', color='lightgoldenrodyellow', hovercolor='0.975') bprev = Button(axprev, 'Previous', color='lightgoldenrodyellow', hovercolor='0.975') + text_box = TextBox(axbox, 'Search Station: ') + bsearch = Button(axsearch, 'SEARCH', color='lightgoldenrodyellow', hovercolor='0.975') bnext.on_clicked(next_station) bprev.on_clicked(prev_station) + bsearch.on_clicked(search_station) + text_box.on_submit(search_station) plt.show() - -def plot_tenv_data(axs, tenv_df, station_name): - """Plot the Delta E, Delta N, and Delta V columns from the tenv dataframe and add navigation buttons.""" - - axs[0].cla() - axs[1].cla() - axs[2].cla() - - # Plot Delta E - axs[0].scatter(tenv_df['Date'], tenv_df['Delta E'], label='Delta E', c='blue', s=10) - #diff, peaks = tenv_utils.displacement_detection(tenv_df['Delta E']) - #axs[0].scatter(tenv_df['Date'].iloc[peaks], tenv_df['Delta N'].iloc[peaks], color='red', marker='x', label='Peaks') - axs[0].set_title(f'{station_name} Delta E') - axs[0].set_ylabel('Delta E') - axs[0].legend() - axs[0].grid(True) - - # Plot Delta N - axs[1].scatter(tenv_df['Date'], tenv_df['Delta N'], label='Delta N', c='green', s=10) - axs[1].set_title(f'{station_name} Delta N') - axs[1].set_ylabel('Delta N') - axs[1].legend() - axs[1].grid(True) - - # Plot Delta V - axs[2].scatter(tenv_df['Date'], tenv_df['Delta V'], label='Delta V', c='red', s=10) - axs[2].set_title(f'{station_name} Delta V') - axs[2].set_xlabel('Date') - axs[2].set_ylabel('Delta V') - axs[2].legend() - axs[2].grid(True) +def plot_tenv_data(axs, tenv_df_filtered, tenv_df_original, station_name, outlier_counts): + """Plot the Delta E, Delta N, and Delta V columns from the tenv dataframe with and without outliers removed.""" + + # Clear previous plots + for ax in axs[:, 0]: + ax.cla() + for ax in axs[:, 1]: + ax.cla() + + outlier_count_e = outlier_counts.get(station_name, {}).get('Delta E', 0) + outlier_count_n = outlier_counts.get(station_name, {}).get('Delta N', 0) + outlier_count_v = outlier_counts.get(station_name, {}).get('Delta V', 0) + + # Plot Delta E (original) + axs[0, 0].scatter(tenv_df_original['Date'], tenv_df_original['Delta E'], label='Delta E', c='blue', s=10) + axs[0, 0].set_title(f'{station_name} Delta E (Original)') + axs[0, 0].set_ylabel('Delta E') + axs[0, 0].legend() + axs[0, 0].grid(True) + + # Plot Delta E (filtered) + axs[0, 1].scatter(tenv_df_filtered['Date'], tenv_df_filtered['Delta E'], label='Delta E', c='blue', s=10) + axs[0, 1].set_title(f'{station_name} Delta E (Outliers removed: {outlier_count_e})') + axs[0, 1].set_ylabel('Delta E') + axs[0, 1].legend() + axs[0, 1].grid(True) + + # Plot Delta N (original) + axs[1, 0].scatter(tenv_df_original['Date'], tenv_df_original['Delta N'], label='Delta N', c='green', s=10) + axs[1, 0].set_title(f'{station_name} Delta N (Original)') + axs[1, 0].set_ylabel('Delta N') + axs[1, 0].legend() + axs[1, 0].grid(True) + + # Plot Delta N (filtered) + axs[1, 1].scatter(tenv_df_filtered['Date'], tenv_df_filtered['Delta N'], label='Delta N', c='green', s=10) + axs[1, 1].set_title(f'{station_name} Delta N (Outliers removed: {outlier_count_n})') + axs[1, 1].set_ylabel('Delta N') + axs[1, 1].legend() + axs[1, 1].grid(True) + + # Plot Delta V (original) + axs[2, 0].scatter(tenv_df_original['Date'], tenv_df_original['Delta V'], label='Delta V', c='red', s=10) + axs[2, 0].set_title(f'{station_name} Delta V (Original)') + axs[2, 0].set_xlabel('Date') + axs[2, 0].set_ylabel('Delta V') + axs[2, 0].legend() + axs[2, 0].grid(True) + + # Plot Delta V (filtered) + axs[2, 1].scatter(tenv_df_filtered['Date'], tenv_df_filtered['Delta V'], label='Delta V', c='red', s=10) + axs[2, 1].set_title(f'{station_name} Delta V (Outliers removed: {outlier_count_v})') + axs[2, 1].set_xlabel('Date') + axs[2, 1].set_ylabel('Delta V') + axs[2, 1].legend() + axs[2, 1].grid(True) plt.draw() diff --git a/map.html b/map.html new file mode 100644 index 0000000..4c69c44 --- /dev/null +++ b/map.html @@ -0,0 +1,1827 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + \ No newline at end of file diff --git a/map.py b/map.py new file mode 100644 index 0000000..ccbfc3b --- /dev/null +++ b/map.py @@ -0,0 +1,282 @@ +import io +import os +import socket +from flask import Flask, jsonify, Response, request, render_template +from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas +from matplotlib.figure import Figure +import matplotlib.pyplot as plt +import preprocessing as pr +import constants +import pandas as pd +import numpy as np + +# Get the hostname and initialize the parent_path based on the hostname +hostname = socket.gethostname() +parent_path = constants.PATHS.get(hostname, '/default/path/to/data') + +# Initialize the Preprocessor with the dynamic path +pre = pr.Preprocessor(parent_path) + +app = Flask(__name__) + +@app.route('/') +def index(): + return render_template('index.html') + +@app.route('/load_stations') +def load_stations(): + try: + load_percentage = int(request.args.get('load_percentage', 5)) # Default 5% + magnitude_threshold = request.args.get('magnitude_threshold', None) + earthquake_count = request.args.get('earthquake_count', None) + + magnitude_threshold = float(magnitude_threshold) if magnitude_threshold else None + earthquake_count = int(earthquake_count) if earthquake_count else None + + print(f"Loading stations with load_percentage={load_percentage}, magnitude_threshold={magnitude_threshold}, earthquake_count={earthquake_count}") + + # Load the filtered combined earthquake data + combined_df = pre.load_combined_df(load_percentage=load_percentage, + target_magnitude=magnitude_threshold, + eq_count=earthquake_count, + save=True) + + # Debugging: Print first few rows of combined_df + print(f"Combined DataFrame (first 5 rows):\n{combined_df.head()}") + print(f"Combined DataFrame contains {len(combined_df)} rows") + + # Check if combined_df has valid data + if combined_df.empty: + print("No data in combined_df") + return jsonify({"status": "error", "message": "No earthquake data found"}), 400 + + # Load station info + station_df = pre.load_station_info() + print(f"Station DataFrame (first 5 rows):\n{station_df.head()}") + print(f"Station DataFrame contains {len(station_df)} rows") + + # Filter out stations that do not have any corresponding earthquake data + filtered_stations = station_df[station_df['Station ID'].isin(combined_df['Station ID'].unique())] + print(f"Filtered Station DataFrame (first 5 rows):\n{filtered_stations.head()}") + print(f"Filtered stations with earthquake data: {len(filtered_stations)} stations") + + # If no stations are found after filtering, return an error + if filtered_stations.empty: + print("No stations found with earthquake data") + return jsonify({"status": "error", "message": "No stations found with earthquake data"}), 400 + + # Prepare station info with earthquake count and magnitudes + stations = [] + for station_id, df in filtered_stations.groupby('Station ID'): + lat = df['Lat'].iloc[0] + lon = df['Long'].iloc[0] + + # Get events related to this station from combined_df + station_events = combined_df[combined_df['Station ID'] == station_id] + eq_count = station_events['Event ID'].nunique() + magnitudes = station_events['Event Magnitude'].dropna().unique().tolist() + + print(f"Station {station_id}: {eq_count} earthquakes, magnitudes: {magnitudes}") + + # Prepare station info + stations.append({ + 'station_id': station_id, + 'lat': lat, + 'lon': lon, + 'eq_count': eq_count, + 'magnitudes': magnitudes + }) + + print("Filtered station data prepared and sent to the frontend.") + return jsonify({"status": "Data Loaded", "stations": stations}) + + except Exception as e: + print(f"Error loading stations: {e}") + return jsonify({"status": "error", "message": str(e)}), 400 + +@app.route('/plot.png') +def plot_png(): + try: + # Retrieve the station ID from the request + station_id = request.args.get('station_id') + if not station_id: + raise ValueError("Station ID is missing") + + # Load the combined data + combined_df = pd.read_csv(os.path.join(parent_path, 'combined.csv')) + + # Filter the data for the given station + station_data = combined_df[combined_df['Station ID'] == station_id] + + # Initialize a list to store displacement data + displacement_data = [] + + # Loop through each unique event ID to calculate displacements + for event_id in station_data['Event ID'].dropna().unique(): + event_data = station_data[station_data['Event ID'] == event_id] + + # Get the magnitude from the day of the event + event_magnitude = event_data['Event Magnitude'].iloc[0] + + # Ensure that the event date exists + event_date = event_data['Date'].values[0] + + # Find the closest non-NaN value before the earthquake + before_event_data = station_data[(station_data['Date'] < event_date) & station_data[['Delta E', 'Delta N', 'Delta V']].notna().all(axis=1)] + if before_event_data.empty: + print(f"No non-NaN data found before the event for {event_id}") + continue + day_before = before_event_data.iloc[-1] # Take the closest before + + # Find the closest non-NaN value after the earthquake + after_event_data = station_data[(station_data['Date'] > event_date) & station_data[['Delta E', 'Delta N', 'Delta V']].notna().all(axis=1)] + if after_event_data.empty: + print(f"No non-NaN data found after the event for {event_id}") + continue + day_after = after_event_data.iloc[0] # Take the closest after + + # Calculate the displacement for each delta component + delta_e_displacement = abs(day_after['Delta E'] - day_before['Delta E']) + delta_n_displacement = abs(day_after['Delta N'] - day_before['Delta N']) + delta_v_displacement = abs(day_after['Delta V'] - day_before['Delta V']) + + # Debugging: Print out the displacement for this event + print(f"Event {event_id}: Magnitude = {event_magnitude}, Delta E = {delta_e_displacement}, Delta N = {delta_n_displacement}, Delta V = {delta_v_displacement}") + + # Append displacement data along with the event magnitude + displacement_data.append([event_magnitude, delta_e_displacement, delta_n_displacement, delta_v_displacement]) + + # Convert the displacement data into a DataFrame + displacement_df = pd.DataFrame(displacement_data, columns=['Magnitude', 'Delta E', 'Delta N', 'Delta V']) + + # Debugging: Print the displacement data + print(f"Displacement DataFrame:\n{displacement_df}") + + # Check if any data remains after filtering + if displacement_df.empty: + print("No valid displacement data available after filtering.") + return jsonify({"status": "error", "message": "No valid displacement data available for this station"}), 400 + + # Group by Magnitude and calculate mean displacement for each component + displacement_grouped = displacement_df.groupby('Magnitude').mean().reset_index() + + # Plotting the displacement bar graph for each magnitude + fig = Figure(figsize=(12, 6)) + axis = fig.add_subplot(1, 1, 1) + + bar_width = 0.2 + index = np.arange(len(displacement_grouped)) + + # Plot bars for Delta E, Delta N, and Delta V + axis.bar(index, displacement_grouped['Delta E'], bar_width, label='Delta E') + axis.bar(index + bar_width, displacement_grouped['Delta N'], bar_width, label='Delta N') + axis.bar(index + 2 * bar_width, displacement_grouped['Delta V'], bar_width, label='Delta V') + + axis.set_xlabel('Magnitude') + axis.set_ylabel('Displacement (m)') + axis.set_title(f'Displacement by Magnitude for Station {station_id}') + axis.set_xticks(index + bar_width) + axis.set_xticklabels(displacement_grouped['Magnitude'].round(2)) + axis.legend() + + # Create an output stream and save the plot to it + output = io.BytesIO() + FigureCanvas(fig).print_png(output) + + return Response(output.getvalue(), mimetype='image/png') + + except Exception as e: + print(f"Error generating plot: {e}") + return jsonify({"status": "error", "message": str(e)}), 400 + +@app.route('/plot_averaged_displacement') +def plot_averaged_displacement(): + try: + # Retrieve the station IDs from the request + station_ids = request.args.get('station_ids') + if not station_ids: + raise ValueError("No station IDs provided") + + # Split the station IDs into a list + station_ids = station_ids.split(',') + + # Load the combined data + combined_df = pd.read_csv(os.path.join(parent_path, 'combined.csv')) + + # Initialize a list to store displacement data across all stations + all_displacement_data = [] + + # Loop through each station and calculate the displacement for each event + for station_id in station_ids: + station_data = combined_df[combined_df['Station ID'] == station_id] + + # Collect displacements for this station + displacement_data = [] + + for event_id in station_data['Event ID'].dropna().unique(): + event_data = station_data[station_data['Event ID'] == event_id] + + event_magnitude = event_data['Event Magnitude'].iloc[0] + event_date = event_data['Date'].values[0] + + # Find closest non-NaN data before and after the event + before_event_data = station_data[(station_data['Date'] < event_date) & station_data[['Delta E', 'Delta N', 'Delta V']].notna().all(axis=1)] + after_event_data = station_data[(station_data['Date'] > event_date) & station_data[['Delta E', 'Delta N', 'Delta V']].notna().all(axis=1)] + + if before_event_data.empty or after_event_data.empty: + continue + + day_before = before_event_data.iloc[-1] + day_after = after_event_data.iloc[0] + + delta_e_displacement = abs(day_after['Delta E'] - day_before['Delta E']) + delta_n_displacement = abs(day_after['Delta N'] - day_before['Delta N']) + delta_v_displacement = abs(day_after['Delta V'] - day_before['Delta V']) + + displacement_data.append([event_magnitude, delta_e_displacement, delta_n_displacement, delta_v_displacement]) + + # Append to the list of all stations' displacement data + all_displacement_data.extend(displacement_data) + + # Convert the combined displacement data into a DataFrame + displacement_df = pd.DataFrame(all_displacement_data, columns=['Magnitude', 'Delta E', 'Delta N', 'Delta V']) + + # Check if any data remains after filtering + if displacement_df.empty: + print("No valid displacement data available after filtering.") + return jsonify({"status": "error", "message": "No valid displacement data available for the selected stations"}), 400 + + # Group by Magnitude and calculate the mean displacement across all stations + displacement_grouped = displacement_df.groupby('Magnitude').mean().reset_index() + + # Plotting the averaged displacement bar graph for each magnitude + fig = Figure(figsize=(12, 6)) + axis = fig.add_subplot(1, 1, 1) + + bar_width = 0.2 + index = np.arange(len(displacement_grouped)) + + # Plot bars for averaged Delta E, Delta N, and Delta V + axis.bar(index, displacement_grouped['Delta E'], bar_width, label='Averaged Delta E') + axis.bar(index + bar_width, displacement_grouped['Delta N'], bar_width, label='Averaged Delta N') + axis.bar(index + 2 * bar_width, displacement_grouped['Delta V'], bar_width, label='Averaged Delta V') + + axis.set_xlabel('Magnitude') + axis.set_ylabel('Averaged Displacement') + axis.set_title(f'Averaged Displacement by Magnitude for Selected Stations') + axis.set_xticks(index + bar_width) + axis.set_xticklabels(displacement_grouped['Magnitude'].round(2)) + axis.legend() + + # Create an output stream and save the plot to it + output = io.BytesIO() + FigureCanvas(fig).print_png(output) + + return Response(output.getvalue(), mimetype='image/png') + + except Exception as e: + print(f"Error generating averaged displacement plot: {e}") + return jsonify({"status": "error", "message": str(e)}), 400 + +if __name__ == '__main__': + app.run(debug=True) \ No newline at end of file diff --git a/notebooks/coseismic analysis.ipynb b/notebooks/coseismic analysis.ipynb new file mode 100644 index 0000000..aa88b97 --- /dev/null +++ b/notebooks/coseismic analysis.ipynb @@ -0,0 +1,695 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/kemalcankucuk/Documents/kuis-matam-summerproject/gps_timeseries\n" + ] + } + ], + "source": [ + "%cd ..\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os\n", + "from matplotlib import pyplot as plt\n", + "import preprocessing as pr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Initializations" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[93mINFO: Loaded 1154 of 3600 earthquake events. \u001b[0m\n" + ] + } + ], + "source": [ + "parent_path = '../geodesy_data'\n", + "pre = pr.Preprocessor(parent_path)\n", + "main_df = pre.load_combined_df()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "bsry = main_df[main_df['Station ID'] == 'BSRY']" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk8AAAHWCAYAAABuRm14AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gUVffHv1tSNoF0QgrphKZAICEQeiAQEFQQEXkVSERe9KWjoqAiiMprhQBRqgFRBKm+NpCEIC0QqsiPloSEECCUVCAFdvf+/lhmmJmd2ZJs2E1yP8/DQ3b2zsydsnO/c86558gIIQQUCoVCoVAoFJOQW7sDFAqFQqFQKPUJKp4oFAqFQqFQzICKJwqFQqFQKBQzoOKJQqFQKBQKxQyoeKJQKBQKhUIxAyqeKBQKhUKhUMyAiicKhUKhUCgUM6DiiUKhUCgUCsUMqHiiUCgUCoVCMQMqnihGWbt2LWQyGfLy8oy2DQ4ORkJCQp33SUhCQgKCg4Mf+35rw+eff47Q0FAoFApERERYuzsNkry8PMhkMqxdu9baXWHp27cv+vbta+1u1Jp58+ZBJpOZ1fb27dt13Ku6JTg4GEOHDrV2Nwyyd+9eyGQybNmyxdpdadBQ8WQCMpnM6L958+ZZu5uUesSff/6JWbNmoUePHkhJScEnn3wi2TYhIYF3rymVSgQEBODFF1/E2bNn9dofOHAAgwcPhr+/PxwdHREYGIinn34aGzZs4LUT3sMuLi7o06cPfvvtN7bN4MGD4e7ujhs3bujtp6ysDL6+vujatSu0Wm2Nz8XZs2cxb948k8S5FBs2bMDixYtrvH59oKKiAvPmzcPevXut3RVJPvnkE+zYscPi2xX+Brj/HB0dLbovS9yPDR1GDEv9KywstHYX8fvvv9fpuKyssy03INavXy/53bx585CTk4OuXbs+xh7ZLhcuXIBc/vg1+apVq2o1gD9u9uzZA7lcjjVr1sDe3t5oewcHB6xevRoAoFarkZOTg+XLl2Pnzp04e/Ys/Pz8AACbN2/GqFGjEBERgWnTpsHd3R25ubnYt28fVq1ahX/961+87Q4YMABjx44FIQSXL1/GN998g6effhp//PEH4uPj8fXXX+PJJ5/EjBkz9MTXnDlzcPv2bezcubNW1/zs2bOYP38++vbtW2Pr4YYNG3DmzBlMnz6dtzwoKAiVlZWws7Orcf9shYqKCsyfPx8AbMJy9d577+Gdd97hLfvkk0/w/PPPY9iwYRbfH/c3wEWhUFh0P5a4HxsL33zzDZo0aaK33M3N7fF3RsDvv/+O5OTkOhNQVDyZwMsvvyy6fPXq1cjJycGUKVMwePDgx9wr28TBwcEq+61vg+PNmzehUqlMEk4AoFQq9e7Dbt26YejQofjtt98wYcIEADox365dOxw+fFhv2zdv3tTbbqtWrXjbHTFiBNq1a4ekpCTEx8cjJCQEH3zwAd5++20kJCRg4MCBAICjR49i+fLlePPNN9GxY0ezjv1xUheWCYoOpVIJpfLxDSFivwFLUlVVZfLvkaLj+eefh5eXl7W7YRWo266G/N///R+mTp2KTp064fPPP+d9d+/ePbzxxhsICAiAg4MDWrdujS+++AKEEF47tVqNBQsWICwsDA4ODggODsacOXNQXV3Na8f42ffu3YuoqCioVCq0b9+eNd9v27YN7du3h6OjIyIjI3Hy5Em9/p4/fx7PP/88PDw84OjoiKioKPzvf/8TPa5+/fpBpVKhRYsW+Oijj8yy6Ahjnph4qYMHD2LmzJlo1qwZnJ2dMXz4cNy6dcvgtr744gvIZDJcvnxZ77vZs2fD3t4eJSUlAMRjnrRaLRYvXownnngCjo6OaN68OSZOnMiuAwAzZ86Ep6cn79pMmTIFMpkMS5YsYZfduHEDMpkM33zzjcE+m3JNZTIZUlJScO/ePdbMXZOYHB8fHwDgDWA5OTno0qWL6CDg7e1tdJtt27aFl5cXcnJy2GUzZ85Ehw4d8J///AdVVVXQaDR47bXXEBQUhA8++MDoNjdu3IjIyEg0bdoULi4uaN++PZKSkgDo7o+RI0cCAGJjY9nzwdzbP//8M4YMGQI/Pz84ODggLCwMCxYsgEajYbfft29f/Pbbb7h8+TK7PnMvSMU87dmzB7169YKzszPc3Nzw7LPP4ty5c7w2jGsiOzsbCQkJcHNzg6urKxITE1FRUWH0uAFg5cqVCAsLg0qlQnR0NPbv36/X5v79+5g7dy4iIyPh6uoKZ2dn9OrVC+np6WybvLw8NGvWDAAwf/58vXCB06dPIyEhAaGhoXB0dISPjw9eeeUVFBUVGewfIQReXl6YOXMmu0yr1cLNzQ0KhQKlpaXs8k8//RRKpRJ3797lnR8GmUyGe/fuYd26dWz/hPGPpaWlNT6XplBcXIw333wT7du3R5MmTeDi4oLBgwfj77//5rVj4oI2btyI9957D/7+/nBycsKSJUsM3o8MBw4cQHR0NBwdHREaGorvvvtOry9iz9Jvv/1WL35UKuxD+Cw19djEqK6uxtChQ+Hq6opDhw4BMO35WBtu3LgBpVLJWku5XLhwATKZDMuWLWOXlZaWYvr06ey42bJlS3z66ae88Yf5PX/xxRfsb8vBwQFdunTB0aNH2XYJCQlITk4GwA9PYDD0TDIZQjGbe/fukXbt2pEmTZqQCxcu8L7TarWkX79+RCaTkVdffZUsW7aMPP300wQAmT59Oq/tuHHjCADy/PPPk+TkZDJ27FgCgAwbNozXLigoiLRu3Zr4+vqSefPmkUWLFhF/f3/SpEkT8v3335PAwEDy3//+l/z3v/8lrq6upGXLlkSj0bDrnzlzhri6upJ27dqRTz/9lCxbtoz07t2byGQysm3bNrbd9evXSbNmzYi7uzuZN28e+fzzz0l4eDjp0KEDAUByc3ONnpugoCAybtw49nNKSgoBQDp16kT69etHli5dSt544w2iUCjICy+8YHBbly9fJjKZjHz22Wd634WGhpIhQ4bwzmVQUBCvzauvvkqUSiWZMGECWb58OXn77beJs7Mz6dKlC7l//z4hhJBt27YRAOSff/5h1+vYsSORy+Xk+eefZ5dt3ryZACBnzpwx2GdTrun69etJr169iIODA1m/fj1Zv349ycnJMbhNZ2dncuvWLXLr1i1SWFhIDh06RHr16kU8PT3JzZs32batWrUiAQEB5MqVKwb7SQghAMikSZN4y0pLS4lCoSBdu3blLT98+DCRy+Vkzpw5ZPHixQQA2blzp9F9/PnnnwQA6d+/P0lOTibJyclk8uTJZOTIkYQQQnJycsjUqVMJADJnzhz2fBQWFhJCCBk2bBh54YUXyOeff06++eYbMnLkSAKAvPnmm7x9REREEC8vL3b97du3E0IIyc3NJQBISkoK23737t1EqVSSVq1akc8++4zMnz+feHl5EXd3d949/sEHH7D37nPPPUe+/vpr8uqrrxIAZNasWUaPffXq1QQA6d69O1myZAmZPn06cXNzI6GhoaRPnz5su1u3bhFfX18yc+ZM8s0335DPPvuMtG7dmtjZ2ZGTJ08SQgi5e/cu+eabbwgAMnz4cPY4//77b0IIIV988QXp1asX+fDDD8nKlSvJtGnTiEqlItHR0USr1Rrs5zPPPEMiIyPZzydPniQAiFwuJ7/++iu7fMiQISQqKkrv/DCsX7+eODg4kF69erH9O3TokEXOpfA3wP1XVlbGtjt69CgJCwsj77zzDlmxYgX58MMPib+/P3F1dSVXr15l26WnpxMApF27diQiIoJ89dVXZOHCheT//u//DN6PzLO4efPmZM6cOWTZsmWkc+fORCaT8Z4N5jxLAZAPPvhA75iFz1Jzj23z5s2EEEIqKirIgAEDiLu7O8nMzGTbmfJ8lIK5nhcuXNC7HiUlJWy7fv36kXbt2umtP3/+fKJQKNjzeu/ePdKhQwfi6elJ5syZQ5YvX07Gjh1LZDIZmTZtGrse83vu1KkTadmyJfn000/JZ599Rry8vEiLFi3Yfh86dIgMGDCAAGCv4fr16wkhxp9JpkLFUw145ZVXCACybt06ve927NhBAJCPPvqIt/z5558nMpmMZGdnE0IIOXXqFAFAXn31VV67N998kwAge/bsYZcFBQURAOyDiBBCdu3aRQAQlUpFLl++zC5fsWIFAUDS09PZZf379yft27cnVVVV7DKtVku6d+9OwsPD2WXTp08nAMiRI0fYZTdv3iSurq61Fk9xcXG8h/iMGTOIQqEgpaWlBrcXExPDe7ATQkhmZiYBQL777jt2mVA87d+/nwAgP/zwA2/dnTt38pbfvHmTACBff/01IUQnHuRyORk5ciRp3rw5u97UqVOJh4eHwYHInGvKDAamwAgy4T9/f39y/PhxXts1a9YQAMTe3p7ExsaS999/n+zfv58nphkAkPHjx5Nbt26RmzdvkmPHjpFBgwYRAOTzzz/Xaz958mRiZ2dHmjRpQkaPHm1S36dNm0ZcXFyIWq2WbMMIU+49y1BRUaG3bOLEicTJyYl3Pw8ZMkRPPBMiLp4iIiKIt7c3KSoqYpf9/fffRC6Xk7Fjx7LLmAHilVde4W1z+PDhxNPTU/J4CCHk/v37xNvbm0RERJDq6mp2+cqVKwkAnnhSq9W8NoQQUlJSQpo3b87b961btyQHWrHz9OOPPxIAZN++fQb7+vnnnxOFQkHKy8sJIYQsWbKEBAUFkejoaPL2228TQgjRaDTEzc2NzJgxg11PKJ4IIcTZ2Zn3+xe2rcm5JET6NwCAxMfHs+2qqqr07vXc3Fzi4OBAPvzwQ3YZIzBCQ0P1zp2h+5F5FnPP6c2bN4mDgwN544032GXmPEtNFU/mHtvmzZvJnTt3SJ8+fYiXlxcrxAkx/fkoBXM9xf61bt2abceMR9yXU0IIadeuHenXrx/7ecGCBcTZ2ZlcvHiR1+6dd94hCoWC5Ofns8cLgHh6epLi4mK23c8//0wAkF9++YVdNmnSJL37kxDTnkmmQN12ZrJhwwZ8++23GDNmDMaOHav3/e+//w6FQoGpU6fylr/xxhsghOCPP/5g2wHgmcuZdgB4M54AoF27doiJiWE/MwHq/fr1Q2BgoN7yS5cuAdCZevfs2YMXXngBd+7cwe3bt3H79m0UFRUhPj4eWVlZuHr1Ktunbt26ITo6mt1es2bN8NJLL5l6eiT597//zTOb9urVCxqNRtQlx2XUqFE4fvw4z420adMmODg44Nlnn5Vcb/PmzXB1dcWAAQPYY759+zYiIyPRpEkT1iXSrFkztGnTBvv27QMAHDx4EAqFAm+99RZu3LiBrKwsAMD+/fvRs2dPg1Ozzb2m5uDo6Ijdu3dj9+7d2LVrF1asWIEmTZrgqaeewsWLF9l2r7zyCnbu3Im+ffviwIEDWLBgAXr16oXw8HDWXM9lzZo1aNasGby9vREVFYW0tDTMmjVL7xgA4OOPP4anpyfkcjkWLVpkUr/d3Nxw79497N69u0bHrVKp2L+Z+7dXr16oqKjA+fPnzd7e9evXcerUKSQkJMDDw4Nd3qFDBwwYMIC9hlxee+013udevXqhqKgI5eXlkvs5duwYbt68iddee43nQk1ISICrqyuvrUKhYNtotVoUFxdDrVYjKioKJ06cMOm4uOepqqoKt2/fRrdu3QDA6DaY3yJzf+zfvx+9evVCr169WDfjmTNnUFpail69epnUHylqci4ZuL8B7r///ve/bBsHBwd28oJGo0FRURGaNGmC1q1bi56HcePG8c6dKbRr1453Hpo1a4bWrVuzz1ygbp6l5h5bWVkZBg4ciPPnz2Pv3r28dCimPh+NsXXrVr3rkZKSwn7/3HPPQalUYtOmTeyyM2fO4OzZsxg1ahSvP7169YK7uzuvP3FxcdBoNOzzmWHUqFFwd3dnPzPXg3sNpKjtM4mBBoybQVZWFl577TW0atUKX3/9tWiby5cvw8/PD02bNuUtb9u2Lfs9879cLkfLli157Xx8fODm5qYnKrgCCQD7AA4ICBBdzvits7OzQQjB+++/j/fff1+0zzdv3oS/vz8uX74sOmuwdevWvM9lZWWorKxkP9vb2/MGIjGE/WdufGP+9ZEjR2LmzJnYtGkT5syZA0IINm/ejMGDB8PFxUVyvaysLJSVlUnG+XCDp3v16sUOmvv370dUVBSioqLg4eGB/fv3o3nz5vj777/1ZqoJMfeamoNCoUBcXBxv2VNPPYXw8HDMnj0bW7duZZfHx8cjPj4eFRUVOH78ODZt2oTly5dj6NChOH/+PO+cPPvss5g8eTLu37+Po0eP4pNPPkFFRYXo7DkXFxe0bt0at2/fRvPmzU3q93/+8x/89NNPbOqEgQMH4oUXXsCgQYNMWv///u//8N5772HPnj16A2xZWZlJ2+DCXAPhPQ3ofqO7du3CvXv34OzszC43dO9K3YPMfsLDw3nL7ezsEBoaqtd+3bp1+PLLL3H+/Hk8ePCAXR4SEmLKYaG4uBjz58/Hxo0b9SYGGDtPnTt3hpOTE/bv34/4+Hjs378f8+fPh4+PD5YuXYqqqipWRPXs2dOk/khRk3PJIPYbEKLVapGUlISvv/4aubm5vNg4T09Pvfamnl8uwmMAdMfBfZaZ+iw1B3OPbfr06aiqqsLJkyfxxBNP8L4z5/loiN69exsMGPfy8kL//v3x008/YcGCBQB0L79KpRLPPfccrz+nT59m4/qM9aem4wlQ+2cSAxVPJlJdXY1Ro0bh/v372Lhxo+j0zJpgapI5qem4UsvJwwBoJtjuzTffRHx8vGhb4WBvjGnTpmHdunXs5z59+hjNPWOsn1L4+fmhV69e+OmnnzBnzhwcPnwY+fn5+PTTTw2up9Vq4e3tjR9++EH0e+6PtGfPnli1ahUuXbrEvnXLZDL07NkT+/fvh5+fH7Rarclv3aZe09rSokULtG7dWu+tjMHJyYm1IHh5eWH+/Pn4448/MG7cON42mAHpqaeegpeXFyZPnozY2Fjew62meHt749SpU9i1axf++OMP/PHHH0hJScHYsWN595AYpaWl6NOnD1xcXPDhhx8iLCwMjo6OOHHiBN5+++3HlpqipveuqXz//fdISEjAsGHD8NZbb8Hb2xsKhQILFy7kWVwN8cILL+DQoUN46623EBERgSZNmkCr1WLQoEFGz5OdnR26du2Kffv2ITs7G4WFhejVqxeaN2+OBw8e4MiRI9i/fz/atGkjObiZSl2fy08++QTvv/8+XnnlFSxYsAAeHh6Qy+WYPn266Hkw1+oE1P0xMHDFEWD+sT377LPYuHEj/vvf/+K7777jvRCZ83ysLS+++CISExNx6tQpRERE4KeffkL//v15okur1WLAgAGYNWuW6DZatWrF+1yba1CbZxIXKp5M5M0338TJkyeRlJSETp06SbYLCgpCamoq7ty5w7M+MS6GoKAg9n+tVousrCzWKgXoZiiUlpay7WoL85ZrZ2dn9K0tKCiIdVNxuXDhAu/zrFmzeFOGuebTumDUqFH4z3/+gwsXLmDTpk1wcnLC008/bXCdsLAwpKamokePHkYfkIwo2r17N44ePcrmrunduze++eYb+Pn5wdnZGZGRkQa387iuKRe1Ws3OfjJEVFQUAJ3byhATJ07EokWL8N5772H48OEWEYL29vZ4+umn8fTTT0Or1eI///kPVqxYgffffx8tW7aU3MfevXtRVFSEbdu2oXfv3uzy3Nxcvbam9pO5BsJ7GtD9Rr28vHhWp5rC7CcrKwv9+vVjlz948AC5ubm89A5btmxBaGgotm3bxjsO4UxGqWMsKSlBWloa5s+fj7lz57LLxX7LUvTq1QuffvopUlNT4eXlhTZt2kAmk+GJJ57A/v37sX//fpMyaz+uFwcptmzZgtjYWKxZs4a3vLS01OQp9ZY4BlOfpYDu+cmd1QjoZmAKf6vmHtuwYcMwcOBAJCQkoGnTpryZwuY8H2vLsGHDMHHiRNZ1d/HiRcyePZvXJiwsDHfv3jU6RpmDoeto7JlkCjTmyQS2b9+OZcuW4ZlnntGLZRLy1FNPQaPR8KZgAsCiRYsgk8nYfFBPPfUUAOhlRf7qq68AAEOGDLFI3729vdG3b1+sWLFCdODkpgt46qmncPjwYWRmZvK+F76dtGvXDnFxcew/Y6KitowYMQIKhQI//vgjNm/ejKFDhxod4F544QVoNBrWVMxFrVbzHlYhISHw9/fHokWL8ODBA/To0QOAbkDJycnBli1b0K1bN6M5bR7XNWW4ePEiLly4wBuI09LSRNsybkljbgOlUok33ngD586dw88//1zrPgqnysvlcnTo0AEA2PQNzLUUDiDM2yX3bfL+/fuiLnNnZ2eT3Hi+vr6IiIjAunXrePs7c+YM/vzzT/Ya1paoqCg0a9YMy5cvx/3799nla9euNek4jxw5goyMDF47JycnAKadJ0D/PjREr169UF1djcWLF/Ni+3r16oX169fj2rVrJllenZ2d9fr3OFEoFHrnYfPmzWxcpylI3Y/mYOqzFNAJB6H1eOXKlXqWp5oc29ixY7FkyRIsX74cb7/9NrvcnOdjbXFzc0N8fDx++uknbNy4Efb29npJVF944QVkZGRg165deuuXlpZCrVabvV+p62jKM8kUqOXJCNevX8f48eOhUCjQv39/fP/996LtwsLCEBMTg6effhqxsbF49913kZeXh44dO+LPP//Ezz//jOnTpyMsLAwA0LFjR4wbNw4rV65k3ROZmZlYt24dhg0bhtjYWIsdQ3JyMnr27In27dtjwoQJCA0NxY0bN5CRkYGCggI2T8isWbOwfv16DBo0CNOmTYOzszNWrlyJoKAgnD592mL9MRdvb2/Exsbiq6++wp07d3iBhlL06dMHEydOxMKFC3Hq1CkMHDgQdnZ2yMrKwubNm5GUlITnn3+ebd+rVy9s3LgR7du3Zy1pnTt3hrOzMy5evGg03gmo22uqVqvZe0+r1SIvLw/Lly+HVqvlWSieffZZhISE4Omnn0ZYWBju3buH1NRU/PLLL+jSpYtRix2gC2qeO3cuPv3001pnin711VdRXFyMfv36oUWLFrh8+TKWLl2KiIgI1joXEREBhUKBTz/9FGVlZXBwcEC/fv3QvXt3uLu7Y9y4cZg6dSpkMhnWr18vapqPjIzEpk2bMHPmTHTp0gVNmjSRPNbPP/8cgwcPRkxMDMaPH4/KykosXboUrq6uFstGbGdnh48++ggTJ05Ev379MGrUKOTm5iIlJUUv5mno0KHYtm0bhg8fjiFDhiA3NxfLly9Hu3bteFZFlUqFdu3aYdOmTWjVqhU8PDzw5JNP4sknn0Tv3r3x2Wef4cGDB/D398eff/4paqGTIiYmBkqlEhcuXMC///1vdjljfQVgkniKjIxEamoqvvrqK/j5+SEkJMRi1Re4vwEhw4cPh7OzM4YOHYoPP/wQiYmJ6N69O/755x/88MMPonFmUkjdj6bkSWMw51n66quv4rXXXsOIESMwYMAA/P3339i1a5eeNammxzZ58mSUl5fj3XffhaurK+bMmWP281GKLVu2iIawDBgwgBcXOWrUKLz88sv4+uuvER8fr5eB/K233sL//vc/DB06FAkJCYiMjMS9e/fwzz//YMuWLcjLyzM7GSfzUj916lTEx8dDoVDgxRdfNOmZZBK1mqvXCGCmfRr7x51SeufOHTJjxgzi5+dH7OzsSHh4OPn888/1prk/ePCAzJ8/n4SEhBA7OzsSEBBAZs+ezZuCTYhuyio3pxEDRPL0MFM5hVPNc3JyyNixY4mPjw+xs7Mj/v7+ZOjQoWTLli28dqdPnyZ9+vQhjo6OxN/fnyxYsICd/l6bVAVHjx7ltWPOq9h0YDFWrVpFAJCmTZuSyspKve/F8jwRopsaHhkZSVQqFWnatClp3749mTVrFrl27RqvXXJyMgFAXn/9dd7yuLg4AoCkpaWZ1E9Tr2ltUxW4uLiQ/v37k9TUVF7bH3/8kbz44oskLCyMqFQq4ujoSNq1a0feffdddio6g9j9wzBv3jzR69OnTx/yxBNPmNRvQgjZsmULGThwIPH29ib29vYkMDCQTJw4kVy/fp3XbtWqVSQ0NJQoFArefg8ePEi6detGVCoV8fPzI7NmzWLTdHD7dvfuXfKvf/2LuLm5EQDsvSCWqoAQQlJTU0mPHj2ISqUiLi4u5OmnnyZnz57ltWGmY9+6dYu3nLmnTfk9fP311yQkJIQ4ODiQqKgosm/fPtKnTx9eqgKtVks++eQTEhQURBwcHEinTp3Ir7/+KnpPHzp0iERGRhJ7e3veFPeCggIyfPhw4ubmRlxdXcnIkSPJtWvXJKfBi9GlSxe96fUFBQUEAAkICNBrL5aq4Pz586R3795EpVLxnou1PZeGUhVw16+qqiJvvPEG8fX1JSqVivTo0YNkZGTonXNhLiQhUvej1LNYuH1CTH+WajQa8vbbbxMvLy/i5ORE4uPjSXZ2tmiqgtoc26xZswgAsmzZMnaZqc9HIYZSFYg9N8rLy9l74vvvvxfd5p07d8js2bNJy5Ytib29PfHy8iLdu3cnX3zxBZu/SWp8I0Q/5YNarSZTpkwhzZo1IzKZjL1XTX0mGUP2cKcUCoVCoVDqkLVr1yIxMRG5ubm0bl49h8Y8USgUCoVCoZgBFU8UCoVCoVAoZkDFE4VCoVAoFIoZ0JgnCoVCoVAoFDOglicKhUKhUCgUM6DiiUKhUCgUCsUMqHiiUCgUCoVCMQMqnigUCoVCoVDMgIqnx8gzzzyDwMBAODo6wtfXF2PGjMG1a9cMrlNYWIgxY8bAx8cHzs7O6Ny5M7Zu3arX7rfffkPXrl2hUqng7u6uV1ZDJpPp/du4cSP7/d69e0XbFBYW8rZz9epVvPzyy/D09IRKpUL79u1x7Ngx9vt58+ahTZs2cHZ2hru7O+Li4nDkyBGj+5HJZDh69Kg5pxPnzp3DM888A1dXVzg7O6NLly7Iz883axsUCoVCoZgLFU8Wpm/fvli7dq3od7Gxsfjpp59w4cIFbN26FTk5OUbrB40dOxYXLlzA//73P/zzzz947rnn8MILL+DkyZNsm61bt2LMmDFITEzE33//jYMHD4rWYktJScH169fZf2J1yy5cuMBrw63nVFJSgh49esDOzg5//PEHzp49iy+//JKtBQcArVq1wrJly/DPP//gwIEDCA4OxsCBA9kCxN27d+dt//r163j11VcREhKCqKgog+eCS05ODnr27Ik2bdpg7969OH36NN5//304OjqavA0KhUKhUGqEWcVcKEbp06ePXh0tKX7++Wcik8nYuj1iODs7k++++463zMPDg6xatYoQoqul5u/vT1avXm1wXwDI9u3bJb9n6iGVlJRItnn77bdJz549De5HSFlZGQGgV4ON4f79+6RZs2bkww8/5C3fv38/6dmzJ3F0dCQtWrQgU6ZMIXfv3mW/HzVqFHn55ZfN6guFQqFQKJaAWp6sRHFxMX744Qd0794ddnZ2ku26d++OTZs2obi4GFqtFhs3bkRVVRX69u0LADhx4gSuXr0KuVyOTp06wdfXF4MHD8aZM2f0tjVp0iR4eXkhOjoa3377rWh1+oiICPj6+mLAgAE4ePAg77v//e9/iIqKwsiRI+Ht7Y1OnTph1apVkn2/f/8+Vq5cCVdXV3Ts2FG0zf/+9z8UFRUhMTGRXZaTk4NBgwZhxIgROH36NDZt2oQDBw5g8uTJAACtVovffvsNrVq1Qnx8PLy9vdG1a1fs2LFDsi8UCoVCoVgMa6u3hoYxy9OsWbOIk5MTAUC6detGbt++bXB7JSUlZODAgQQAUSqVxMXFhezatYv9/scffyQASGBgINmyZQs5duwYGT16NPH09CRFRUVsuw8//JAcOHCAnDhxgvz3v/8lDg4OJCkpif3+/PnzZPny5eTYsWPk4MGDJDExkSiVSnL8+HG2jYODA3FwcCCzZ88mJ06cICtWrCCOjo5k7dq1vD7/8ssvxNnZmchkMuLn50cyMzMlj2/w4MFk8ODBvGXjx48n//73v3nL9u/fT+RyOamsrCTXr18nAIiTkxP56quvyMmTJ8nChQuJTCYje/fuNXg+KRQKhUKpLVQ81ZKPP/6YODs7s//kcjlxcHDgLbt8+TLb/tatW+TChQvkzz//JD169CBPPfUU0Wq1ktufPHkyiY6OJqmpqeTUqVNk3rx5xNXVlZw+fZoQQsgPP/xAAJAVK1aw61RVVREvLy+yfPlyye2+//77pEWLFgaPrXfv3jzXmJ2dHYmJieG1mTJlCunWrRtv2d27d0lWVhbJyMggr7zyCgkODiY3btzQ2/6VK1eIXC4nW7Zs4S2Piooi9vb2vHPICM6zZ8+Sq1evEgBk9OjRvPWefvpp8uKLLxo8JgqFQqFQaovSikavBsFrr72GF154gf380ksvYcSIEXjuuefYZX5+fuzfXl5e8PLyQqtWrdC2bVsEBATg8OHDiImJ0dt2Tk4Oli1bhjNnzuCJJ54AAHTs2BH79+9HcnIyli9fDl9fXwBAu3bt2PUcHBwQGhpqcOZZ165dsWDBAlRXV8PBwUG0TXR0NA4cOMB+9vX15e0HANq2bas3+8/Z2RktW7ZEy5Yt0a1bN4SHh2PNmjWYPXs2r11KSgo8PT3xzDPP8JbfvXsXEydOxNSpU/X6FBgYCABQKpWifeH2l0KhUCiUuoCKp1ri4eEBDw8P9rNKpYK3tzdatmxpdF2tVgsAqK6uFv2+oqICACCX80PTFAoFu25kZCQcHBxw4cIF9OzZEwDw4MED5OXlISgoSHLfp06dgru7u6RwYtow4gwAevTogQsXLvDaXLx40eB+AN1xCo+REIKUlBSMHTtWL+arc+fOOHv2rMFz2KVLlxr1hUKhUCiUWmNt01dDQyrm6fDhw2Tp0qXk5MmTJC8vj6SlpZHu3buTsLAwUlVVRQghpKCggLRu3ZocOXKEEKKbidayZUvSq1cvcuTIEZKdnU2++OILIpPJyG+//cZue9q0acTf35/s2rWLnD9/nowfP554e3uT4uJiQggh//vf/8iqVavIP//8Q7KyssjXX39NnJycyNy5c9ltLFq0iOzYsYNkZWWRf/75h0ybNo3I5XLeLLnMzEyiVCrJxx9/TLKyssgPP/xAnJycyPfff08I0bnrZs+eTTIyMkheXh45duwYSUxMJA4ODuTMmTO885GamkoAkHPnzumdq7///puoVCoyadIkcvLkSXLx4kWyY8cOMmnSJLbNtm3biJ2dHVm5ciXJysoiS5cuJQqFguzfv9/cS0ahUCgUillQ8WRhpMTT6dOnSWxsLPHw8CAODg4kODiYvPbaa6SgoIBtk5ubSwCQ9PR0dtnFixfJc889R7y9vYmTkxPp0KGDXuqC+/fvkzfeeIN4e3uTpk2bkri4OJ5Y+eOPP0hERARp0qQJcXZ2Jh07diTLly8nGo2GbfPpp5+SsLAw4ujoSDw8PEjfvn3Jnj179I7jl19+IU8++SRxcHAgbdq0IStXrmS/q6ysJMOHDyd+fn7E3t6e+Pr6kmeeeUY0YHz06NGke/fukucxMzOTDBgwgO1zhw4dyMcff8xrs2bNGtKyZUvi6OhIOnbsSHbs2CG5PQqFQqFQLIWMEJH56hQKhUKhUCgUUWieJwqFQqFQKBQzoOKJQqFQKBQKxQzobLsaotVqce3aNTRt2hQymcza3aFQKBQKhWIChBDcuXMHfn5+erPZTYWKpxpy7do1BAQEWLsbFAqFQqFQasCVK1fQokWLGq1LxVMNadq0KQDdyXdxcbFybygUI9y7BzDJWq9dA5ydrdsfCoVCsRLl5eUICAhgx/GaYHXxlJycjM8//xyFhYXo2LEjli5diujoaMn2mzdvxvvvv4+8vDyEh4fj008/xVNPPcV+n5CQgHXr1vHWiY+Px86dO3nLfvvtN3z44Yc4ffo0HB0d0adPH7MKyzKuOhcXFyqeKLaPQvHobxcXKp4oFEqjpzYhN1YNGN+0aRNmzpyJDz74ACdOnEDHjh0RHx+PmzdvirY/dOgQRo8ejfHjx+PkyZMYNmwYhg0bhjNnzvDaDRo0CNevX2f//fjjj7zvt27dijFjxiAxMRF///03Dh48iH/96191dpwUCoVCoVAaDlbN89S1a1d06dIFy5YtA6ALwg4ICMCUKVPwzjvv6LUfNWoU7t27h19//ZVd1q1bN0RERGD58uUAdJan0tJSSSuSWq1GcHAw5s+fj/Hjx9e47+Xl5XB1dUVZWRm1PFFsn3v3gCZNdH/fvUstTxQKpdFiifHbapan+/fv4/jx44iLi3vUGbkccXFxyMjIEF0nIyOD1x7QueSE7ffu3Qtvb2+0bt0ar7/+OoqKitjvTpw4gatXr0Iul6NTp07w9fXF4MGD9axXQqqrq1FeXs77R6HUG5RKYNw43T+l1b31FAqFUq+x2lP09u3b0Gg0aN68OW958+bNcf78edF1CgsLRdsXFhaynwcNGoTnnnsOISEhyMnJwZw5czB48GBkZGRAoVDg0qVLAIB58+bhq6++QnBwML788kv07dsXFy9e5BX55bJw4ULMnz+/NodMoVgPBwdg7Vpr94JSR2g0Gjx48MDa3aBQbAI7OzsouHGedUCDewV98cUX2b/bt2+PDh06ICwsDHv37kX//v2h1WoBAO+++y5GjBgBAEhJSUGLFi2wefNmTJw4UXS7s2fPxsyZM9nPTLQ+hUKhWAtCCAoLC1FaWmrtrlAoNoWbmxt8fHzqLA+j1cSTl5cXFAoFbty4wVt+48YN+Pj4iK7j4+NjVnsACA0NhZeXF7Kzs9G/f3/4+voCANq1a8e2cXBwQGhoKPLz8yW34+DgAAcHB6PHRaHYJIQAFRW6v52cAJrYtUHACCdvb284OTnRhL2URg8hBBUVFezEM2bMtzRWE0/29vaIjIxEWloahg0bBkAXMJ6WlobJkyeLrhMTE4O0tDRMnz6dXbZ7927ExMRI7qegoABFRUXsCYyMjISDgwMuXLiAnj17AgAePHiAvLw8BAUFWebgKBRbo6KCBow3MDQaDSucPD09rd0dCsVmUKlUAICbN2/C29u7Tlx4VnXbzZw5E+PGjUNUVBSio6OxePFi3Lt3D4mJiQCAsWPHwt/fHwsXLgQATJs2DX369MGXX36JIUOGYOPGjTh27BhWrlwJALh79y7mz5+PESNGwMfHBzk5OZg1axZatmyJ+Ph4ALq8TK+99ho++OADBAQEICgoCJ9//jkAYOTIkVY4CxQKhWI+TIyTk5OTlXtCodgezO/iwYMHDU88jRo1Crdu3cLcuXNRWFiIiIgI7Ny5kw0Kz8/P59Wd6d69OzZs2ID33nsPc+bMQXh4OHbs2IEnn3wSAKBQKHD69GmsW7cOpaWl8PPzw8CBA7FgwQKey+3zzz+HUqnEmDFjUFlZia5du2LPnj1wd3d/vCeAQqFQagl11VEo+tT178KqeZ7qMzTPE6VeQfM8NTiqqqqQm5uLkJAQODo6Wrs7FIpNYej3Ua/zPFEoFAqFUlvmzZuHiIgIa3eD0sig4olCoVAoj5WEhATIZDLIZDLY2dmhefPmGDBgAL799ls2nUxtts1MQqotMpkMjo6OuHz5Mm/5sGHDkJCQYJF9UOonVDxRrIJao0VSahZeXn0ESalZUGtq98CkUCj1C6YGaV5eHv744w/ExsZi2rRpGDp0KNRqtbW7xyKTyTB37lxrd4NiY1DxRLEKS/dkYVHqRRzIvo1FqRexdE+WtbvUsFEogOef1/2r48y7FIopODg4wMfHB/7+/ujcuTPmzJmDn3/+GX/88QfWcrLhl5aW4tVXX0WzZs3g4uKCfv364e+//xbd5rx587Bu3Tr8/PPPrGVr7969AIC3334brVq1gpOTE0JDQ/H++++blJV98uTJ+P77742W8KI0Lqh4oliF7SevGfxMsTCOjsDmzbp/NLiYYqP069cPHTt2xLZt29hlI0eOxM2bN/HHH3/g+PHj6Ny5M/r374/i4mK99d9880288MILrFXr+vXr6N69OwCgadOmWLt2Lc6ePYukpCSsWrUKixYtMtqnHj16YOjQoaLF6imNlwZXnoViW6g1WiSn5+BoXjG6BHtgUmwYlAqq2SkUW8KWfqdt2rTB6dOnAQAHDhxAZmYmbt68yaab+eKLL7Bjxw5s2bIF//73v3nrNmnSBCqVCtXV1XqVJ9577z327+DgYLz55pvYuHEjZs2aZbRPCxcuRIcOHbB//3706tWrtodIaQBQ8USpU5LTc7A49SIIgIPZtwEA0+LCMTzCH0kcV93wCH8r9ZBCoUj9Tq0BIYTN0fP333/j7t27ehnUKysrkZOTY9Z2N23ahCVLliAnJwd3796FWq02eZp6u3btMHbsWLzzzjs4ePCgWfulNEyoeKLUKUfzisEkEiMPPwPAlP4tIZfLeG+6lDqE5nmiGEDqd2oNzp07h5CQEAC6qhG+vr5s3BIXNzc3k7eZkZGBl156CfPnz0d8fDxcXV2xceNGfPnllyZvY/78+WjVqhV27Nhh8jqUhgsVT5Q6pUuwBw5m3wYBIHv4GQCUCrnV3mwpFAofqd/p42bPnj34559/MGPGDABA586dUVhYCKVSieDgYJO2YW9vD41Gw1t26NAhBAUF4d1332WXCdMPGCMgIACTJ0/GnDlzEBZGX/YaO1Q8UeoUxqJELUwUiu1ijd9pdXU1CgsLodFocOPGDezcuRMLFy7E0KFDMXbsWABAXFwcYmJiMGzYMHz22Wdo1aoVrl27ht9++w3Dhw9HVFSU3naDg4Oxa9cuXLhwAZ6ennB1dUV4eDjy8/OxceNGdOnSBb/99hu2b99udp9nz56NVatWITc3F6NGjar1OaDUX6h4otQp1MJEodg+1vid7ty5E76+vlAqlXB3d0fHjh2xZMkSjBs3jq1pKpPJ8Pvvv+Pdd99FYmIibt26BR8fH/Tu3ZutgSpkwoQJ2Lt3L6KionD37l2kp6fjmWeewYwZMzB58mRUV1djyJAheP/99zFv3jyz+uzh4YG3334bc+bMqe3hU+o5tLZdDaG17Sj1Chrz1OCgte0oFGlobTsKhUKhUCgUG4KKJwqFQqFQKBQzoDFPFEpjQKEAnnrq0d8UCoVCqTFUPFEojQFHR+C336zdCwqFQmkQULcdhUKhUCgUihlQ8UShUCgUCoViBlQ8USiNgXv3dOkJnJ11f1MoFAqlxtCYJwqlsVBRYe0eUCgUSoOAWp4oFAqFQqFQzICKJwqFQqFQbJS9e/dCJpOhtLTU2l2hcKDiiUKhUCiPlYSEBMhkMr1/gwYNeqz9mDdvHiIiIsxuN2/ePLbPSqUSXl5e6N27NxYvXozq6mqL9rF79+64fv06XF1dAejKjiQkJKB9+/ZQKpUYNmyYwfUPHjwIpVIpepxXr17Fyy+/DE9PT6hUKrRv3x7Hjh1jvyeEYO7cufD19YVKpUJcXByysrLY7xlhJ/bv6NGjvO188cUXaNWqFRwcHODv74+PP/7Y6HYKCwvZNgsXLkSXLl3QtGlTeHt7Y9iwYbhw4YK5p9Ni0JgnCoVCoTx2Bg0ahJSUFN4yBwcHK/XGfJ544gmkpqZCq9WiqKgIe/fuxUcffYT169dj7969aNq0qUX2Y29vDx8fH/azRqOBSqXC1KlTsXXrVoPrlpaWYuzYsejfvz9u3LjB+66kpAQ9evRAbGws/vjjDzRr1gxZWVlwd3dn23z22WdYsmQJ1q1bh5CQELz//vuIj4/H2bNn4ejoyAo7Lu+//z7S0tIQFRXFLps2bRr+/PNPfPHFF2jfvj2Ki4tRXFys198LFy7was15e3uzf//111+YNGkSunTpArVajTlz5mDgwIE4e/YsnK1Rq5NQakRZWRkBQMrKyqzdFQrFOHfvEgLo/t29a+3eUCxAZWUlOXv2LKmsrLR2V8xm3Lhx5Nlnn5X8fvTo0eSFF17gLbt//z7x9PQk69atI4QQotFoyCeffEKCg4OJo6Mj6dChA9m8eTPbPj09nQAgqampJDIykqhUKhITE0POnz9PCCEkJSWFAOD9S0lJEe3PBx98QDp27Cj5meHcuXPE3t6evPvuu6adiIdUVVWRWbNmkRYtWhB7e3sSFhZGVq9ezTuOkpISvfWMncdRo0aR9957T7S/b7/9NunZs6fkulqtlvj4+JDPP/+cXVZaWkocHBzIjz/+KLrO/fv3SbNmzciHH37ILjt79ixRKpXseRfD0DFKcfPmTQKA/PXXX6LfG/p9WGL8pm47CqUxIJcDffro/snpz77Bc++e9L+qKtPbVlYab1sHvPTSS/jll19w9+5ddtmuXbtQUVGB4cOHA9C5cb777jssX74c//d//4cZM2bg5Zdfxl9//cXb1rvvvosvv/wSx44dg1KpxCuvvAIAGDVqFN544w088cQTuH79Oq5fv45Ro0bVqt9t2rTB4MGDsW3bNnbZvHnzEBwcbHC9sWPH4scff8SSJUtw7tw5rFixAk2aNKlVX1JSUnDp0iV88MEHot//73//Q1RUFEaOHAlvb2906tQJq1atYr/Pzc1FYWEh4uLi2GWurq7o2rUrMjIyJLdZVFSExMREdtkvv/yC0NBQ/PrrrwgJCUFwcDBeffVVUctTREQEfH19MWDAABw8eNDg8ZWVlQEAPDw8DLarK6jbjkJpDKhUwN691u4F5XFhaOB96il+qR5vb+k0Fn368O+b4GDg9m1+G0Jq1MVff/1VTyDMmTMHc+bMQXx8PJydnbF9+3aMGTMGALBhwwY888wzaNq0Kaqrq/HJJ58gNTUVMTExAIDQ0FAcOHAAK1asQJ8+fdhtfvzxx+znd955B0OGDEFVVRVUKhWaNGkCpVLJc4vVljZt2uDPP/9kP3t5eSEsLEyy/cWLF/HTTz9h9+7drFAJDQ2tVR+ysrLwzjvvYP/+/VAqxYf5S5cu4ZtvvsHMmTMxZ84cHD16FFOnToW9vT3GjRvHxhs1b96ct17z5s15sUhc1qxZg/j4eLRo0YK3n8uXL2Pz5s347rvvoNFoMGPGDDz//PPYs2cPAMDX1xfLly9HVFQUqqursXr1avTt2xdHjhxB586d9faj1Woxffp09OjRA08++WSNzlFtoeKJQqFQKI+d2NhYfPPNN7xljBVBqVTihRdewA8//IAxY8bg3r17+Pnnn7Fx40YAQHZ2NioqKjBgwADe+vfv30enTp14yzp06MD+7evrCwC4efMmAgMDLX5MgC44WiaTsZ8nT56MyZMnS7Y/deoUFAoFT/DVBo1Gg3/961+YP38+WrVqJdlOq9UiKioKn3zyCQCgU6dOOHPmDJYvX45x48aZvd+CggLs2rULP/30k95+qqur8d1337H9WbNmDSIjI3HhwgW0bt2a/cfQvXt35OTkYNGiRVi/fr3eviZNmoQzZ87gwIEDZvfTUlDxRKFQKA0NjrtLD4WC//nmTem2QhdvXl6NuyTE2dkZLVu2lPz+pZdeQp8+fXDz5k3s3r0bKpWKnY3HuPN+++03+Pv789YTBp3b2dmxfzOiRqvVWuQYxDh37hxCQkJMbq9SqSy6/zt37uDYsWM4efIkK9q0Wi0IIVAqlfjzzz/Rr18/+Pr6ol27drx127ZtywahM9a4GzdusKKT+Sw2cy8lJQWenp545plneMt9fX2hVCp5Qq5t27YAgPz8fJ5o4hIdHS0qjiZPnoxff/0V+/bt41m4HjdUPFEojYF793QuF0A3AFpjdgrl8WHO9a2rtrWke/fuCAgIwKZNm/DHH39g5MiRrBBq164dHBwckJ+fXyuLjb29PTQajaW6jPPnz2Pnzp2YPXu2yeu0b98eWq0Wf/31Fy++qKa4uLjgn3/+4S37+uuvsWfPHmzZsoUVdj169NCb6n/x4kUEBQUBAEJCQuDj44O0tDRWLJWXl+PIkSN4/fXXeesRQpCSkoKxY8fyxCqzH7VajZycHNZ9efHiRQBg9yXGqVOneKKNEIIpU6Zg+/bt2Lt3r1kCtS6g4olCaSwIY1UoFCtSXV2tFzvD5Exi+Ne//oXly5fj4sWLSE9PZ5c3bdoUb775JmbMmAGtVouePXuirKwMBw8ehIuLi8lup+DgYOTm5uLUqVNo0aIFmjZtanK6BLVajcLCQr1UBREREXjrrbfYdsuWLcP27duRlpYm2Ydx48bhlVdewZIlS9CxY0dcvnwZN2/exAsvvCC6ztmzZ3H//n0UFxfjzp07OHXqFABdwLVcLteLA/L29oajoyNv+YwZM9C9e3d88skneOGFF5CZmYmVK1di5cqVAHRWuunTp+Ojjz5CeHg4m6rAz89PL7fUnj17kJubi1dffVWvr3FxcejcuTNeeeUVLF68GFqtFpMmTcKAAQNYa9TixYsREhKCJ554AlVVVVi9ejX27NnDix2bNGkSNmzYgJ9//hlNmzZl7x1XV1eLW+9Mosbz9Bo5NFWB7fJArSGLd18kL606TBbvvkgeqDXW7pL1oakKGhz1PVUBBGkCAJDWrVvz2p09e5YAIEFBQUSr1fK+02q1ZPHixaR169bEzs6ONGvWjMTHx7NT18Wmv588eZIAILm5uYQQXYqAESNGEDc3N7NTFTB9VigUxMPDg/Ts2ZMsWrSIVFVV6a0bFBRk8HxUVlaSGTNmEF9fX2Jvb09atmxJvv32W8njCAoKEj1/UkilVvjll1/Ik08+SRwcHEibNm3IypUred9rtVry/vvvk+bNmxMHBwfSv39/cuHCBb3tjB49mnTv3l1y/1evXiXPPfccadKkCWnevDlJSEggRUVF7PeffvopCQsLI46OjsTDw4P07duX7Nmzh7cNseM1dM3qOlWB7GGnKGZSXl4OV1dXlJWV8ZJ6UaxPUmoWFqdeBAEgAzA9rhWmxYVbu1vW5d69RzOw7t6lbrsGQFVVFXJzcxESEgJHR0drd4dCsSkM/T4sMX7bRMKX5ORkBAcHw9HREV27dkVmZqbB9ps3b0abNm3g6OiI9u3b4/fff+d9L5b6Xyrtf3V1NSIiIiCTyVjTJ6V+czSvGMwbAXn4mUKhUCgUS2F18bRp0ybMnDkTH3zwAU6cOIGOHTsiPj4eNyVmgBw6dAijR4/G+PHjcfLkSQwbNgzDhg3DmTNneO0GDRrEJj67fv06fvzxR9HtzZo1C35+fhY/Lor16BLsAWaisOzhZwqFQqFQLIXVxdNXX32FCRMmIDExEe3atcPy5cvh5OSEb7/9VrR9UlISBg0ahLfeegtt27bFggUL0LlzZyxbtozXzsHBAT4+Puw/br0ehj/++IOtt0OpW9QaLZJSs/Dy6iNISs2CWlN3U4UnxYZhelwr9GzphelxrTApVjpBHYVCoVAo5mLV2Xb379/H8ePHedM65XI54uLiJNO/Z2RkYObMmbxl8fHx2LFjB2/Z3r174e3tDXd3d/Tr1w8fffQRPD092e9v3LiBCRMmYMeOHXBycrLcQVFESU7PYeOQDmbrZn3VVRySUiGnMU5C5HKAKdRJy7NQKBRKrbCqeLp9+zY0Go1o+vfz58+LrlNYWGg0XfygQYPw3HPPISQkBDk5OZgzZw4GDx6MjIwMKBQKEEKQkJCA1157DVFRUcgzIfFbdXU1qqur2c/l5eVmHGnjRa3RIjk9BykHc2kckjVRqYCjR63dC0odQOf8UCj61PXvokHmeXrxxRfZv9u3b48OHTogLCwMe/fuRf/+/bF06VLcuXPHrERmCxcuxPz58+uiuw0arsWJgcYhUSi1h0lGWFFRYZ08NxSKDVPxsF6jMGmnpbCqePLy8oJCocCNGzd4y2/cuCFZqNHHx8es9oCuyKKXlxeys7PRv39/7NmzBxkZGXrJ0KKiovDSSy9h3bp1etuYPXs2z11YXl6OgIAAo8fY2OHOfAMAN5UdEnuE0DgkCqWWKBQKuLm5sZNrnJyceDXVKJTGCCEEFRUVuHnzJtzc3KAQliOyEFYVT/b29oiMjERaWhqbsVSr1SItLU2ykGJMTAzS0tIwffp0dtnu3bvZytpiFBQUoKioiE31vmTJEnz00Ufs99euXUN8fDw2bdqErl27im7DwcHB5MyzlEd0CfbAwezbbM6lxB4hNB7JGlRUAEwdq7NnARrn1yBgXhqlZidTKI0VNzc3g0aV2mJ1t93MmTMxbtw4REVFITo6GosXL8a9e/eQmJgIABg7diz8/f2xcOFCAMC0adPQp08ffPnllxgyZAg2btyIY8eOsSnl7969i/nz52PEiBHw8fFBTk4OZs2ahZYtWyI+Ph4A9KppN3mYPDAsLMyqhQYbIoyF6WheMboEe1CLk7UgBLh8+dHflAaBTCaDr68vvL298eDBA2t3h0KxCezs7OrM4sRgdfE0atQo3Lp1C3PnzkVhYSEiIiKwc+dONig8Pz8fcs7soO7du2PDhg147733MGfOHISHh2PHjh1szR6FQoHTp09j3bp1KC0thZ+fHwYOHIgFCxZQy5EVoDPfKJS6R6FQ1PlgQaFQHkHLs9QQWp6FUq+g5VkoFAoFQAMqz0KhUCgUCoVSX7C6247SOGHyP2XmFkFLALkMiA7xxKTYMCgVVNNTKBQKxXah4oliFcTyPx3KKQJQd5nHKRQKhUKxBFQ8UayCMP8TQDOP1yky2aNUBTQXEIVCodQK6h+hWIUuwR4QDuE083gd4uQE/N//6f7RHE8UCoVSK6jliWIVmHxPYjFPFAqFQqHYMlQ8UeocJjicmyjzUf4nGt9EoVAolPoFFU+UOmdpWjaS9mQBAA5k34ZWSzBjYCsr96qRUVEBdOmi+/voUeq6o1AolFpAY54odc72U1cNfqY8BgjR1bQ7e5aWZ6FQKJRaQsUThUKhUCgUihlQ8USpc4Z38jP4mUKhUCiU+gSNeaLUOVP6hUMuk/MCxsWQCiynUCgUCsWWoOKJUuc8mllnGG7W8YPZtwHQbOMUCoVCsT2oeKJYjNpajrhZx2m2cWqJo1AoFFuFiieKxait5ahLsAcOZt8GAc02DljYEieTAUFBj/6mUCgUSo2h4oliMWprOWJioYzFRjUWLGqJc3IC8vIs0CsKhUKhUPFEsRiRge448NBCwnw2B25sFHVZ1f58UigUCqVuoOKJYjlkxPBnDmqNFkvTstmEmcM7+eH1PmFYsS8XR/OKodESHL5U1LiDx804nxQKhUJ5fFDxRLEYxy+XGvzMJTk9hy3ZAgBJadnIzC1hBROXxho8bs75NEplJdC7t+7vffsAlarm26JQKJRGDhVPFIsRGeTGdzMFufG+r7qvRuLaYzh3vRxETyLh4XJ9GmvwuEUD6LVa4NixR39TKBQKpcZQ8USxHERm8HPi2mPIuFQkuXpbXxee5Skm1BMKuazRBo/TAHoKhUKxTah4oliM4/klBj+fu17O++ygkKG5q859JIx5aqxB4lyUCjkmxYYhOV0noJLT0ejPCYVCodgCVDxRLIYxN1NbXxee5alToDtiwrxwNK8Ycpnc5EzkjQmadZ1CoVBsDyqebBRbnqov1beJvUNw+FIRzl0vRxufplBrNHh59RF0CfbAxN4hiAp0x9nr5ah+oEHHFq4ghGBR6kUAtRcGtny+agPNuk6hUCi2BxVPNsrStGx2NtqB7NvQaglmDGxl5V7pELOGTIoN48U0Hc4txuFc3UB/MPs2Dl8q4sUznb9xF2WVD9htEgBbTxTUWPQ0VAtNpwBXXhB+pwBXK/aGQqFQKABQ/1/NGyhM/iOpz48TtUaLpNQsvLz6CJJSs5CZW8Szhmw9UYB+X/4lGQxOAJy9XsabSccVTgz5xRVYyklfYA7CPmXmSgem1xfUGi22n7zGW3Y0r0SitQl4een+USgUCqVWUPFEMQpj1TmQfRuLUy9CS3QxTQz5xRXIL64wuI2mjnYwpaLa2kOXodaYP5VeSwx/ro8kp+egoLSSt+x84Z2abczZGbh1S/fP2dkCvaNQKJTGCxVPNsrwTn4GPz9OhHE3chkwPa4Verb0QqCHk+g6Lo58j3B55X10C/VEgDs/OaNSzpdUZZUPkJyeY3YfBZtBQUlFjUSYLSEW39TW18UKPaFQKBQKFyqebJQp/cIx46FAmRHXClP6WS9+p0uwB2s1kgGIDvHEtLhwfP9qV4zo3ELUotTO14W3vLxKg8OXivBcpxa843q9T6jeujUJio4O8eR9vlJSWSMRZksIZyu2cFchJSHKSr2hUCgUCgMNGLdRbGnavqFkjczfKQdzUcqJY1LIZZge1wrfHriEsio1AJ3VatvJAgR5OvO2c+xyKS9eSqMl7Cw9UwPIJ8WGYeuJAp77sL7PTBM77zWeQVhZCQwerPv7jz9oeRYKhUKpBTJCSAOIDnn8lJeXw9XVFWVlZXBxoa6UpNQsdrabDDq33qTYMPT9Yi8KSir12jNtpsWF89IMcAsCA/pZxrnigVvupa2vCzoHuiJ57yX2+2n9W2LGgNZ1etzWoEZpGe7dA5o00f199y6Ne6JQKI0WS4zf1PJEMQljA7aYlSQ5PUdUOAH8nEVcK9vLq4/wZuUxFimx9APc1AgZl4qQX3yPt48jl4qh1mgbRL4nLg01LQOFQqHUF6h4opiEsQFbzM1oyG0mAxAZ6I6k1Cye4OJmKeciliBSWO7lWmkV7/Ph3GIkp+c0OGFBE2dSKBSKdaHiiWIShgZsKatUl2APXoLHbiEe6BrqgeOXS9El2ANaosXi1CwQ6BKBHr5UBLkM6BbqCblMl26AceGZUu5FzP/cEIWFsTI4FAqFQqlbbMKfkZycjODgYDg6OqJr167IzMw02H7z5s1o06YNHB0d0b59e/z++++87xMSEiCTyXj/Bg0axH6fl5eH8ePHIyQkBCqVCmFhYfjggw9w//79Ojm+hoBwxh13wBbmgUpOz4Fao4VWSxDo4YQAdxW6hXhAIZdBLpNjbWIXTIsLx/HLpXouuoM5ukzk0SGeWD8+mk2JwMRQcUlJiEJMqCdcHZVQiEz5a6jCYlJsmN55ESYyre9pGigUCsWWsbrladOmTZg5cyaWL1+Orl27YvHixYiPj8eFCxfg7e2t1/7QoUMYPXo0Fi5ciKFDh2LDhg0YNmwYTpw4gSeffJJtN2jQIKSkpLCfHRwc2L/Pnz8PrVaLFStWoGXLljhz5gwmTJiAe/fu4YsvvqjbA66nGJpxJ2aVSk4HluzJYpdfeRj7dCinCFotgVwuk0ysyWxDqQjXc7kJrVzrx0cjOT2HrZHHpVuop57gagiIuUi5Afs0DopCoVDqFquLp6+++goTJkxAYmIiAGD58uX47bff8O233+Kdd97Ra5+UlIRBgwbhrbfeAgAsWLAAu3fvxrJly7B8+XK2nYODA3x8fET3OWjQIJ4lKjQ0FBcuXMA333xDxZMEhlIniLmRuIKKC4Gu1MyV4grR7wFxixEjmrjpCBiRIOWaU8hlDS5YXAqT4qCcxBOaUigUCsU8rDqy3L9/H8ePH0dcXBy7TC6XIy4uDhkZGaLrZGRk8NoDQHx8vF77vXv3wtvbG61bt8brr7+OoiLDtc7Kysrg4SHt4qmurkZ5eTnvX0PGHDeQmBuJ6+bjwiyTEk6BHk6iLjrGNci1VjEiQcw111BddlIYcqsC0KUmuHdP94+mKaBQKJRaYVXL0+3bt6HRaNC8eXPe8ubNm+P8+fOi6xQWFoq2LywsZD8PGjQIzz33HEJCQpCTk4M5c+Zg8ODByMjIgEKh0NtmdnY2li5datDqtHDhQsyfP9+cw6vXmDMdXswqxXXzRQa6AzLCCxRfkpatl8uJace4/bjpEMQsWYxIYPaVmVsELdGVaokOsX2XHdcFGRnoDi3R4ue/rwPQleN5vU8YVuzLNSmfkyG3KoVCoVAsi9XddnXBiy++yP7dvn17dOjQAWFhYdi7dy/69+/Pa3v16lUMGjQII0eOxIQJEyS3OXv2bMycOZP9XF5ejoCAAMt33kYQuoG2nigwK8O1ITefWqOFXCbXEwW6uJ0sUcEmTGEQ6OGEEZ1bsOvq2oWz209Oz0FCytHaZ+auQ7gClTsrEQCS0rKRmVvCzjasiYClUCgUSt1gVfHk5eUFhUKBGzdu8JbfuHFDMl7Jx8fHrPaALqbJy8sL2dnZPPF07do1xMbGonv37li5cqXBvjo4OPCCzhs6wjQD+cUVGLMmUzLbtxjCDOApCVFwtFfqDfSMizDlYK5k3I45pUrqSxJJqbgwhrPXynjn49uDuuzpNRKDVVXAiBG6v7duBRwdze0uhUKhUB5iVfFkb2+PyMhIpKWlYdiwYQAArVaLtLQ0TJ48WXSdmJgYpKWlYfr06eyy3bt3IyYmRnI/BQUFKCoqgq+vL7vs6tWriI2NRWRkJFJSUiCX255lwpqI1YozlO1bjISUozicW8yuG/1JGsb3DNUb/KVmy0UGurNWJK5LjkHsu+gQT2TmFhkPnrYBpBKCMjA1AdnPlWosfniezBaDGg3ApPTQaMzsKYVCoVC4WN1tN3PmTIwbNw5RUVGIjo7G4sWLce/ePXb23dixY+Hv74+FCxcCAKZNm4Y+ffrgyy+/xJAhQ7Bx40YcO3aMtRzdvXsX8+fPx4gRI+Dj44OcnBzMmjULLVu2RHx8PACdcOrbty+CgoLwxRdf4NatW2x/DFmwrEGN6phZAKVCjhGdW7AWHC6mCBK1Roujl0t4y8qr+IM/c2wpB3PFNyIjPCsSw6GcR8H/Yt91C/WE7GE/bTlwXKqosiHEzr217hEKhUJprFhdPI0aNQq3bt3C3LlzUVhYiIiICOzcuZMNCs/Pz+dZhbp3744NGzbgvffew5w5cxAeHo4dO3awOZ4UCgVOnz6NdevWobS0FH5+fhg4cCAWLFjAut12796N7OxsZGdno0WLFrz+2FqdZGu6oLiuMm7BXlMESXJ6DjRa/XPJjZ8SE0Zcjl8uZdcRboMREGLfyWW6osP1JXjaRWVnsngSK2vDDcC3ZTclhUKhNBRkxNbUQj3BElWZTeHl1Ud4sUc9W3rh+1e71tn+pDDXuiHst5BAD13OIalEmQAwI64VAH3rkgw6cWTou9qKh8dhzeEmtgQAV5UdyiREVAt3FYI8nBAd4skTSzIAAR5OvPMoeo/cuwc0aaL7++5dmq6AQqE0Wiwxflvd8kQxjK3UMZMK8hZadxjBIbQ6OSjlqFY/yhUlJpq6Brvjenk1AN1Ufa7FiBvXFBWks7YcyytBt1BPgGhxpbQKd6oeoJ2vKyb2Dqn18T4Oi58wYPxJPxecuVaGsspHsU4yAJNjwzAtrhUr3l5adZgX00UIqRduSgqFQmkoUPFk49R1/p6aWljExAXAtwQx+ZvEcjuJIZPJsOeNPrz9iyXnzMwr5rkQu4V64mpJJQh0gemJa4+ZNStQDJMydtcCtUarJzCvlFSirY8LG2QP6CxOSkFuMqE31N9NhecjA+qNm5JCoVDqO1Q82SDigqZuYlhqamGREhfccV0hl7HuIya3k3AGH5fDucVITs/h7d9YXBQBcO56uV6BYZh5PELq2uKXnJ7D9pMhv7gC+cUViAn1xNXSSuQXV+BKSaXeDDu5IHW7Qi6jMU4UCoXyGKHiyQZ5nEHiNbWwSIkLKcHBuP2YQHHGtScUEML9G8uFBABtfV1YSxSX2liM6triZ6hfCrkMgZw4Jl2Op1ykHMxFW18XRAW54VDOI8tbdIin8R06OwM0vJFCoVAsAhVPNkhdu4y4mGthUWu0SNqdhXWH86CQy+Bkr8C4mCCeuBAKDilLmlqjxZg1mayAEtu/sVxIgR5OSEmIYsuYmDsrUIq6ztgtdVxiQhQAG0iecakIhJB6NZuQQqFQGhpUPNkgjzNI3FwLS3J6DpbuzWY/l1epsf3UNTagWUxwSFnSlAo51o+P1hNWYv1jAsYLSnSuLEB3bkZ0bgFHeyW7X2HizCOXbmP0yiJevTtbyIFkqPbfxN4h+GbvJQR4OKGs8oHeDLxTV0rx/atd68yVS6FQKBTD0FQFNaQuUxXYYtJDbkJLsZxEM0TSA0it4+qoRDs/1xoJGuG5mdg7hLU6cUUI1wLFYKk0BnWJ0Bonhdj5NkhVFTBmjO7v9etpeRYKhdJoscT4TcVTDXlceZ5shaTULNESKgyBHk4I9HASKfQrHewN1F7QmLIPLtbKk2Uqxs4zg9nHQfM8USgUCgCa56nBI2aBAmARq5S51i1jcVfMTLED2beRkXMb18qqcLO8iidqlHIZ1IJ59gQ6lxxgWDyZUsfOGLacA8lYqRphAs384gokpWbZhFWSQqFQGhtUPNkwxnIp1WYmnrkz+roEe+hlDGesTYxwYuDmKWJghIvYrDiRKi4G+8sgrGMnhYujEu39Xdnkmi+vPmJVd6iYcDWWkuFJPxdEh3iyqR7yiytqXiSYQqFQKLWCiicbRa3RYsvxK7xZd1uOX0Ggh5NFZuKZOqOPa/Fp4a5CgSBYe1pcuFHXmZvKDok9Qtj4pG8PXuJl0RbmLTLWXwYC4P+ulaJbqCcvkFyIXCbDDxO6PexnltVrwIkJV+HxOSrlqHqYkZ1JRzAtLhxH84p5KQwMXX+uSItp7ohJdXM4FAqF0uig4slGSU7P0RMDVx5m0bZEKQ5TZ/QJLSLcrOGMG1FYQFgY7NzW14Ud5CfFhkGrJUjak8V+HxVk/BikpvaXV2lw+FIRAh7WyhOjiaMSL68+gvziiseWAsIQYsJVeD0m9g6DXC7Tc9maet2EgecnzlZR8UShUCgWgoonG0VqYC8oqRQVMOZiaooCoUWEmzWcgZuiQK3RYmlaNrafugoA8HN1ZF11rOtRJpBAws8P4VpOIgPdMbV/S6w9mIeyKjWvHbM2133Xwl2Fu1VqNHFU4mpJJWsxA6etteKfxASQ2PUQcymaet2EGczprBAKhUKxHFQ82ShiMUYMYgLGXExNAikc6CMD3fUKAnMHeaVCjhkDW2HGwFYAgJdXHzFq7Tl+uVR031yr14Hs24gJ9YSrk72eeJIBGB7hr2epUSrkeHn1EZ5wEs4KtAZSQmlaXDgrGBNSjkqeX1PL51AoFAqlbqDiyUZh3FvL9+WgWs0vjvs4LSbCZI5HcovYgHBTA82F4iuTM7AbsgAJrV5cS0oLN0dAJsOdqgdo5+uK1/uGwtFeqSc+IoPcePtn4rQsRU1mRAoFkFqjZQUpNz9VbWvzccV3RGs/qMvKdf1wknZxUigUCsU4VDzZKIwFZ11GHk88KeUyZOYWISkVdT5bTCgMtETLm0lnaqB5t1BPNrWAlmh5IqhbqKekBchQaRaZTMbGhGVcKsKARfvwfGQAtESLJWnZrPiY2i+8TkuZWGJGpNRMO0vX5qMpDSgUCsUyUPFkg3BFSxNHJS87t1pLcDCnCIdydALEmFWiNtnKhcJALCjblEBzbiLMl1cf4bVTyGWS/ZnYOwSHLxXh3PVyNnaJ2V65wHV3paQSi1MvIkAwG/F4fkmdJsWUmrVoTmC6VPFjW67NR6FQKI0ZKp5sEKElggl+JiDsFH9TrRLm5nNiUGu02HqigCcChLRwV2Fi7xDR9aVEhdRsMTGRt2JfLuvCKq18wAuU33L8il7NN7HAcY2W1GleJ6njMac2odDCxj3Oib1DDMaYmUx1NTBxou7vFSsABwfzt0GhUCgUAFQ82STCrNlBHk5Y90o0b+q5qVYJU/M5CUlOz+ElvgR0QdmZecVsHwpKKpG49hhv5h8zsEuJCqnZYqbkPmIC5dUaLTJybovmdeIGjlsqfsgQYsej1mhZi1lbXxdJgSl0bcpAQCCDXKaLDdMSLQYu3s9ehwPZt7H1RAFGdG6hJ6KEsxyHd/LDlH7hj9qo1cC6dbq/k5OpeKJQKJRaQMWTjaHWaHFZIFrOXCvTKxZrKFaIi6l5gYQIRZajUg7IiF5CS6ZPQnEiJZKk3ElCkZdyMBdtfV1Ec1olp+eIZjGPCfXElP4tWcFgyky/2iJ2PMnpOaxoO3ypCCv25Yoes9C12S3U85HYyxEvDCyVWTw5PYeXOyspLRtyGXXdUSgUSl1AxZONkZyeo5eTqKxSrZd40lCsEBdT8wIJEbqSqtS6QGypcigEwNYTBbz9mDNwC/dXWvkAGZeK0C3EA0qFnNd3XS28R7iqlHilR6ieNSYyyI034ywyyM1gH2oTH8bFFGufmFtUKvZJiNg2hecE0GWkp4HiFAqFYnmoeLIhmAHVGOZYkGoaOMwIlZSDuWzAus5CQtAt1FMviBt4VBy4Ji4yZn/f7M1my5IAwMn8EnQKdMeW41ew9UQBhnfyg0ZQDK+dr6vevtQaLQ4LrDdaI0X0ahofJsQUa5+YW1RYNJkLtzCw2DbFVr1SUonk9BxqfaJQKBQLQ8WTDSE2oHJp4a5CkIcTokNMc9nVBq7o4rqWCGSiQdzc4sA1cZEx+2MK3zJUawjPRZeUlq3L8cShoKQCao2WZ2FJTs/BkbwSXruf/76ON+LbSPahpvFhQkyx9hnatlIu4wmpQA8n/Dm9F1bsy5XcplR9QJosk0KhUCwPtefbEMKBLsBdhW4hjywMV0sq2QKxAJCUmoWXVx9BUmoW1Bp+Ik1LoNZoodUSBHg4IcBdhehgd5zILxEN4h7RuQWY8dtYzTVD/X62o6/Rft2p1vA+MxYWLjURDV2CPUw6BmMwQvD7V7tiWly4XmB3UmqWpEgW26+/m8roPqNDPEWXW6sEDYVCoTRkqOXJhhC6e56PDOCJAK41xFIuJgaxeJ/k9Bws2ZPFiiWx2W3M4MzNydTGpynUGo1oigCxfjP7OppXbJIIdHFUwlVlxxMgQrEkVt7m2Q5+Bo+3pvFhYkjFTwnTUAR6OGF4hD8gIziWVwIt0blGW7ir2Ni3w5eKkLj2mN7MQe55iwx0R9dgd561rVuI9UrQUCgUSkOGiicbQmzwTk4XzxlkKRcTgympAoQEuKvYPnNzMh3OLWZdbQeyb0NLtJgxoLVkv5PTIZphm6GpoxJ3OEkxn+vsD7lMzlvnn6tl6P1ZOjtFf1JsGA5l3+K77h4WIFZrtLzZi1zxKSVAzQ0mlxK3wnMa6OHE1gFMSs2SzDR+7nq53mzEw5eKeIJqar9wdG/ZTLyPTk7AzZuP/qZQKBRKjaFuOxtCqZBjUmwYIgPdsfVEAfp9+RfUGg3+0ycUrio7OCjlyMi5jar7ar2ZY8ZmkhlDTNRw3VhitHDXDcKL/ryIb/ZmS4qf7SevsX+LucaMibQO/q6YEdcKPcI8ERPqqbPQaAmm9m+JwIdZz8sqHyC/uAJJadlITs+BUiHH9fJq3nZ+/vs6AJ2w4c5eNEV8MmLoQPZtLE69qOcmFGIoSSgXjZaw1jZDmcaZtA0MzGxEYTZ1KXchZDKgWTPdP5mhq0qhUCgUY1DxZGMw+XqYAOyl6TnY8fc1lFU+QJVaV1suIeUoQAQDoPCzmYiJmkmxYZge1wpuKjvRdeSyR/2tUpsWc8Vss2dLL0yPa4VJsWEG43JkAKKCdN9fKalExqUiHMwpwpI9WZDL5Kx44mJKORQhxmKDzLX0ScVPTYoNQ0zoo/ikw5eKWCEmFKsxoZ7seUpJiML0uFa6fFsi1CZGi0KhUCjmQd12NobYoHy9rIr3+dSVUj2X0fF8/swyc5EqJMu4sRY9TMzIIIMuSFmsv/YKGe5rHtlQhkf4s3+LpU6YFBumN8su0MMJgR5ObEHixalZPKsM1zomjG1iRMTwTn5ISst+1I9Ofuz33HViTEg4am6yUUPxU1dLH8WOcYWYsWK+k2LD8O3BSzyh6qqyQ3t/V+MxWtXVwMyZur+/+opmGKdQKJRaQMWTjSEmBuwUclRzBkwHO7leO8b9U9OEiIbyQTHB4GevlaGpyg6BHk7o+jBdQnI69PrLFU5M1m9DMUNKhRwjOrfgpUQY0bkF2x9upnAGrnVMqyW8siSMiJjSLxxymRyZuUXQEuBobjFGrzwMGQhiQj0hl4FN+2DsvBkLJhc7Pqms4sKZdl2CPYzGVDFxWkxtQ4aXowNgb6dkY8ckj0WtBr7+Wvf3Z59R8UShUCi1gIonG2NSbBgycm7zcht19HdF5uVHlqWx3YIwKTYMhy8VsbE7jPunLhIicoPBy6vUGBkZwCvDotUSbDtZgPIqNaoeaHhCj7GyGJsdKBQn3IK4Gi3hZTV3VMrRKdAdE3uHQKmQY8bAVmzQNRdGECal6gekywBMj2tl8vkylmzU1NmPQktdoIcTO2vO0PrCOC2G4/mlOJJbXKf1+ygUCoXCh4onG0OpkOtZDuyUckzrF85aV+QPMyIqOJkRmRlYgAHrgwimWDzEyohw+ztjYCvI5TLRmWL5xRXs9g3FDAnFiXDmWUyoJ66WViK/uEIX+2WgZpwQsUBsS9W6Y85fysFc3vFl5hYhKVXfBSe0GDI5nIydH6m+ni+8w1tv64kCWpKFQqFQ6hgqnmwQYXwNkwDxSnEFCIAlD4u+itWDEysaawhTLB5ibiYhhmbMMQLCnJgh4fYUchkCPZxqlMVceJ5gYh9MQZi3idm2RkvYODFuuoaJvUOw+fgVXg6n5PQco+dHzJ0LAE0clWz5HEAnVpemZUMul/GFW62PlEKhUCgM9Jlqg4jF1ySkHNWzTKxN7AJAv/6cORYoQxaPqvtqfHvwEq8942YSIiZQAH5skvCYDCElJowJMEPJL5nYJ26sU20Rijw3lR0Se4Rgy/ErvHbbT17DjAGtsWJfLq/ws/BaSp0foXvUxVEJfzcVz73L7uvUVVZoH8y+Da2WwL66EpMefq/WaOkPn0KhUGqBTdj2k5OTERwcDEdHR3Tt2hWZmZkG22/evBlt2rSBo6Mj2rdvj99//533fUJCAmQyGe/foEGDeG2Ki4vx0ksvwcXFBW5ubhg/fjzu3r1r8WMzF+7gHxnoDi3RIiHlqF4xXObztLhwJPYI0csBZEouIsBwSZLEtcf0ApSHd/ITFWRMCoIeYZ7oFuKBAHcVAj2cMLV/S97MPdEcRCLngCkLw90Gbx+hng9dY/wSL2L5mJh9/zChG378dzf8MKGb0T6YivD8JfYIwbS4cMgkcimJWcsiA92RnJ6DzNwiaLQEmbk6axT3uJQKOeRyGQpKKlFW+QAFJZW4JpiFyfQBAE8Qbz91Fcnpj2YdrvjrknA1CoVCoZiB1V9AN23ahJkzZ2L58uXo2rUrFi9ejPj4eFy4cAHe3t567Q8dOoTRo0dj4cKFGDp0KDZs2IBhw4bhxIkTePLJJ9l2gwYNQkpKCvvZQTC76KWXXsL169exe/duPHjwAImJifj3v/+NDRs21N3BmgDXDSR00whLdjDumczcInQL9cTZ62Ws2DHVrWXIInTuern+Cg/zSTEiT2jNiQp2x5K0bNY6JJfpx3CZcg6YsjDCbQgD5Q/l6P5nXI2WzrxuDKnzNzzCH0l7sth2TLoGsTQJkBEsSs0CF+FxMfvgHhsAXiB9oIcTRnRuAS3R8q4Btz0AnKhlWgsKhUJp7MgIIYaSO9c5Xbt2RZcuXbBs2TIAgFarRUBAAKZMmYJ33nlHr/2oUaNw7949/Prrr+yybt26ISIiAsuXLwegszyVlpZix44dovs8d+4c2rVrh6NHjyIqKgoAsHPnTjz11FMoKCiAn5+f6HpcysvL4erqirKyMri4uJh72JK8tOowDuboz6oCAAclP2UBNwYI0ImrqyWVvCBrhVxmUjkRMUavPKw3w6tnSy98/2pX0VIiMgABgj4x7c3h5dVHeALDUSmHt4sjm6eJm7tJuA9uv8ydUWdJuOJSoyW4WloJmUyGZzv6Qi6X4fjlUp5LViyeSXjuhMc2tZ/uuJiJBMy2mRp5jKDVEi2Wpl6EX/ktAMDI4T0wbWDrOj8HFAqFYotYYvy2quXp/v37OH78OGbPns0uk8vliIuLQ0ZGhug6GRkZmMkk+3tIfHy8nlDau3cvvL294e7ujn79+uGjjz6Cp6cnuw03NzdWOAFAXFwc5HI5jhw5guHDh+vtt7q6GtXVj8p9lJeLWGUsgNaAlK02ksW7oKSSFUwaLdErJGuuiEhJiELcon2stYvr1svMLdKLbxJaQ8TiksRiktQaLRLXHsO56+Vo6+uCzoGuPDFRpdaypVfEMopz92HIkiZ0iUJGeCLGUjPUuPvREvDikpam52BGXCueKJIKBhfm7hKvfZjDxjctFbhpY0I92WOdEtcKxy9717rgMYVCoVCsLJ5u374NjUaD5s2b85Y3b94c58+fF12nsLBQtH1hYSH7edCgQXjuuecQEhKCnJwczJkzB4MHD0ZGRgYUCgUKCwv1XIJKpRIeHh687XBZuHAh5s+fX5PDNAu5eKiMHoEeTnoZtAHdrLTvX+3KSyxprvuKO/iP6NRCT2QA0IvBAnRiaXiEv95MLy5is/u4briMS0XIL75ncl+F2cGFKQ/UGi0vXxQjKLlixdL5kcRm4HERXguhK5KBm7tLKqWEoVmOzPYOZN/GtH7hZlsAKRQKhSKO1WOe6oIXX3yR/bt9+/bo0KEDwsLCsHfvXvTv379G25w9ezbP4lVeXo6AgIBa91VIdIgnDuXoW3WE+Lup8HqfMGTmlrCDJNfSY25qAAYmkzWzzYPZtzG1XzhbwJfJYs0tMQLoXIr/6dvSqAVHLCZJGFt1rVQ/EJpBTJwx+xMTGEv3ZOkJTCGGxKWxPFjGjlEM4bVQKuRYPz6azRfFnTnJ9EsoOrVaArlcppdGQopfjuVhxu5Vug8ffwzY25u0nrWpyfmnUCiUusaq4snLywsKhQI3btzgLb9x4wZ8fHxE1/Hx8TGrPQCEhobCy8sL2dnZ6N+/P3x8fHDz5k1eG7VajeLiYsntODg46AWd1wVc1wzXtRQZ6I4juUWsCyjjUhES1x6DDAQt3FW4U/UA7XxdMbF3CIBHJVUYV9j4HkGsBcaQy0qYyZqZrcWd+g5AbzZZcxdHkyw3YqJOoyV6+xTiqlJibLcgQEZwNK9EdCAVs2ptP3nNaJ+YfjFwB+yauD+FaRu6hXiwM+O45WO4cC1m3Lgmpl9C0cm9JsBDS2SEP3td/7laypspqdSqgS++0H2YN6/eiCdTM7dTKBTK48Sq4sne3h6RkZFIS0vDsGHDAOgCxtPS0jB58mTRdWJiYpCWlobp06ezy3bv3o2YmBjJ/RQUFKCoqAi+vr7sNkpLS3H8+HFERkYCAPbs2QOtVouuXa3r2jBUBuTl1Ud4n4VunoxLRfhm7yXMGNiKV1Ll8KUiTFh/wiSXlZQFRmgtkppNZgyxuJ2JvUOQuPYYzl4rQ5Vay4vtclTKMaFXCORyGbafvMZaWph+M3E/R/OKkc8RE0y27ZvlfCuWMOgeAFwclVBrNOj16R6UV6lBCEF5FT9FA/fYa3KMQmuJlEVFKmZLKDqZ/jAEejjxStQs2n2BZ3F7uoOv0X7bIo979iSFQqGYgtXddjNnzsS4ceMQFRWF6OhoLF68GPfu3UNiYiIAYOzYsfD398fChQsBANOmTUOfPn3w5ZdfYsiQIdi4cSOOHTuGlStXAgDu3r2L+fPnY8SIEfDx8UFOTg5mzZqFli1bIj4+HgDQtm1bDBo0CBMmTMDy5cvx4MEDTJ48GS+++KJJM+2shVRgMZftp65ixsBWeoPOuevlohYd4YAk3IerSgk/V0fWysFNesmkSdAS4NjlYiSlZhl1qzACITkdPDfgj//uhqTULDYrN8PrfVsC0K9Nx/Q7OV3/OwZTXVrtfF30gq3FMCcxpzHriDAlxdYTBRjRuYXkukJRJUxHIOzXlH7hAJGxM/HqKzV1P1MoFEpdYnXxNGrUKNy6dQtz585FYWEhIiIisHPnTjYoPD8/H3L5o8G4e/fu2LBhA9577z3MmTMH4eHh2LFjB5vjSaFQ4PTp01i3bh1KS0vh5+eHgQMHYsGCBTy32w8//IDJkyejf//+kMvlGDFiBJYsWfJ4D94MmMSRrio7lHHKcUghHHTa+rqwlicuwgGJGaS3nihAfnEFyirVOJxbzM7i4ybu7BLswcvrJJabSAwpV4xU0VxudnVhv4XxRYEPE2vmF1fwxJNSLoNaS/SsTjGhnkaD9LuFeLB16cRcbjVxLQn7nV9cYbC0jlggvFwmlwzMZ5JqMqL3m73FmGL4MG0SczPTUygUyuPA6uIJACZPnizpptu7d6/espEjR2LkyJGi7VUqFXbt2mV0nx4eHlZPiGkO3MSRhmByIQkHnYm9Q7BiX65ozNPE3iF68VDlAoHGzOLT5RrKYoVCgIeT2W4VKVeMUPCN6NyCFS3cGCImGSRjwRKuMy0uXC8PlVowO5Apo8K4/aRyawFA11APzBignxdJqiiwKedArJyNsXWlEpNKBc0L3Zj1EUNubAqFQrEWNiGeKMYxNIOLmwyTK4S6BHtgbWIXdmCVGoS4QkPMLWgocJn53hy3ipQrRsrKYCiGyJR1hFYoQFdQNzNXJ5gm9g5h68aVVT7AvWo1NJyTffxyqehxSBUFNuUcCC18pqwrtj+utU84U5JCoVAodQMVT/UEoaXCVWUHV5Udhnfyw5R+j+q0cYWQlAtJGKMjlvCSwVWlxCs9QiUDl43ldRJDSvBIWRkM5W56JKb0j5GZbdjEUf82LyipREFJJQ7lFLHT/oM8nfVm/jHHLIZUUWBTzgFzTNyAd2PnT0xAC9MZUOFEoVAodQ8VTzaGObOwuK4aRkwIXTVibiBhjE63UE9ejTQu7XxdecLFlJlkxqitK8aUGKPEtcdYIVFa+QAt3FW4W6VmcygxiE3758LEXYkhFJJMUWC1RotFf17E9lNXQQiBv5sKCrkMUUEeeu5SxpVqyrkUc/UJrYJSVNnZY8AryXBxVGKrSiXZjkKhUCjGoeLJxpASBoYEh1RGayk3kND1JpfpasAdzSvG5aJ7uFLyKAFmQUkFqu6reYM8k0uKO1vucSYuFPZ/64kCvT4IE2/erVIjsUeIqJuN2Y4QbtyVGFIWtOT0HF4aB+Z8cuOqDmbfxuFLRWblkGK2z415igrygFqjQe/P0g1OJCAyObKaBekKEcsf37WiUCiUhggVTzZGTfLaCN053EK6zIArTPzIjVOKDvFkB21hfqArJZW8+nY1GfQtjTCdQn5xBVvGhKGtrwvPhdXGpym0WqILcOdYg5jCucyMQS5NH8ZFJaWKC0QpQWvKNROmjzAny/m6V6J5btqkVH6ahQB3FVq4O0EuAzoHuOPo5WKcL7yDtr4uSEmIEtsFhUKhUMyAiicboyZ5bYRiokqtxZXiCshlcl7mcK7VRSrIXK3RLz5cwLFEmTPo1xWTYsN4gdbg9IERGsLM650DXXnWoOc6+7Mz6Jhp/0v3ZPFm5ZVXqXEwp4gNyubGJxnK0m5KPi5h+ghD19qQm1Ls3Ad5OuvXsbt/H/jkE+CTncCcOfUmwziFQqHYIlQ82Rg1yWszKTYMGTm32dItgE7UbDl+RbKALJN6AIBockpDmDro1xVKhRwjOrcQLWPCFRoy6NyR0+LC0fuzdN42tp+8xoonxoIkVpwXEE/IKczSzgSdM8Kqa7A7juSVsG1cHJUY0zUQx/NLce56OZqq7AAQdHuYZ4pJOSCGIWukmFATvR4PHgBMYeu33qLiiUKhUGoBFU82hinB1GL5fs4V3tFrd6WkknVnGbJoGbIctXBX8SxPMaGeSEmI0gt0NoYlCrxytxEZ6I6p/VvyLD/MsQiFhlqjNZpYVK3RIirQHWevl6P6gQZeTRxwtbSSd76k0kUIg86Z/FdcyqvUOHGlDEdyddsoq1KjoKSSJ/CkEAaK5xdXYNGfFwEZwbG8EnQL8cDV0krIZDJJV21Mc0dMMngGKBQKhWIqVDzVQ6QCxMVghJEhi5aY9YKZdi81I8zQYC8mlGqShVut0WJpWjZbYsTP1ZEVHwezb2N6XCs995SYSExOz9ETT8JafMnpOVi291G5kxGdW/AsSVqiNVruxVhCSrESOaa4PYU5ofKLK3guSICfOFTMVXvibBUVTxQKhWIhqHiqhxhKmCmEsTAZEjyTYsP0XFZtfV1MEkqAvljiBmAzQqkmgfDCWWtc8SK1DTGRmJBylNcm0MMJr/cN5eWK4ua6IgCO55fw3JpMVnUAsJcD9zmhYQ5KuV79v+ER/sjMK+adU6kZfcbcnsw1YFJRiCFW3kUsoSmFQqFQag8VT/WQyEB3yYBke4UMKnslXByVeK6zv6hLTcwytH58NC87dcalIvT78i89a4bYtrjrSZVsMScQnlv2RAqpbYiJPaFlzd9NhW/+yuEJvG6hnrx1NFoCtUYrGi+mEWTFqlZrefX/mHOq1miRuPYYTuaXoEr9yHXInQ1nKNZJiLFAdLF4KO45p+iwhAuZQqE0bqh4qo/IpO0ITvZKnPpgoMHVue6cA9m3sfVEgc5NJRhhjRWrZbYlZl0RlmwxJxDekFtSKFBMYWLvEGw+foWN3Tp8qYiNZ2L6LJfpts0cy+FLRaLxYoBOWImhkMuwNrELktNzkJByFBotES/GLJNh/fhoswdssVmGjko5qh4WO5Yq8szEPGGRWbtrsNTEhUyhUChcqHiqZ6g1Wmw/eU3y+7a+LpLriRWMBR4GIKdeRAt3/czTxlxsYt+JlWwxJ6u4obxV3FI0Uoi5EYXpFoQwgffcNkywOZMfCgAIIbwkolzyiyswZk2mqGASthPmpTIFsVmGE3uHSZbHYc65WqPFit//YZerNdpG/cOviQuZQqFQuDTmZ2i9JDk9RzLuxd/NEVFBbnh59RE9d4QpQeYFIqLAmItN6EqKCfXElP4ta+UGEbqbXu/bUlJomBKcLpz5BujHJB2+VMQrU8MNNl+yJ4td1i3UU0882StkuK8hogWIpajpgF2T8jjJ6TlYsv8ydo39CjIA/TOuYmp8mxrtvyFQk1xqFAqFwsVk8fTKK68YbSOTybBmzZpadYgijVqjxdYTBZLfK+RyLEvP0XPHTYoN07PmBLirUF6llpzCH+jhhEAPJ6PuMUvUujNlm1KIuWCMBUozAo8bSC4sU8MNNhe696b1C+fNAOTm1xLi7+aIorv3QaCLjQL4A7a58TdSFjyx9BVMPNXRvGJo5Aqc9m0FALh8OB9EoWi0sT41yaVGoVAoXEwWTyUlJZLfaTQapKamorq6moonCyFlUTFk2SirvC/qjtt6ogD+bipemDMBeMJJIZexsTzMbDHGHWSofl1ti/yKUVMXn1Rw+rMd/HD0cjFOXSmFg50cUUFuAPQtENwyNQxSbWYM1AmRl1cf0euTq8oO7f1dodZo9YQVN6WAWLA9IB1/Y0hoiVkWmczowpit0soHRmPZGjJ1cc9SKJTGhcniafv27aLLf/75Z8yZMwcODg6YO3euxTrW2JGyqHAJcFfhuc7+OH65FBotEc2ODYB1JzHB1mJtGeEU6OGE4RH+OJJbxA78thxUK+aCEVoWtOSRiKlSa7E0PQfKh5YXbjsxC8TE3iE4fKkI566Xo41PU6g1GtYtOrF3iGjweEJMMGYMbKWX1RzQnV8mDokrnACd+MvMLQJgvAA095owFkmpHFJrE7tA/uA+1IsWo/KBBilRz+CBwq7RxvrQ2XYUCqW21Djm6eDBg3jnnXdw4sQJTJ48Ge+88w7c3d0t2bdGjSkWlecjA1hBI2YBEcKUZDHUNtDDCXK5TK/Ui60OtFJuQ67QEzveo3nFUCrCH1r0IGlhW7Evlw0AP5xbzBOUwpI4Lo5KJPYIxpR+LSX7yy0jIyZ2pWbyMX3m3hNM0WLhDDwGRkwqFXK83iMQyqdWAwDWdxoCtcKu0cb6GJptR4UVhUIxBbPF09mzZ/H2229j586dGDt2LH788Ue0aNGiLvrWqDFkUWHiWpjBc1JsmMHcT3i4jchAdySlZhl0/TFlSMSWm8LjHnxMccEYqv+WnJ7D1vU7kH0bhy8V8dIIGCrJcupKKW+Zm5M9Wy8PAIZ38kNSWjb7uVsI3yomxtVS8Zl8TJ+57rcz18pxMEfc2hjgrsLzkQHs/lb8dYmXYbxbqOn5pRoahmbb0TQGFArFFEwWT1euXMHcuXPx/fffY+jQoTh9+jTatm1bl31r1BhyKV0pqWQFEBPXIsz9FOCuwnOdWgAywtZ/0xItL1N2gLsK/m4qvbpoyenQm0Fn6kBri4PPpNgwaLUE209dBSEE/m4qHLl0G6NXFuHs9TJe24xLRRizJpMVUELBwiAD4GCnYHMsAUBpxX0s2n2BPd+v9wmDXCYXFZJSCS9lMul0lsIyLYbq9QV5OvOsKT//fZUnnhRyWaO1qAhfNCIDH1nMaRoDCoViCiaLp9atW0Mmk2HmzJno0aMHsrKykJWVpdfumWeesWgHGytiFhVdmRB+ULDUAz7I05kNamasQesOXeatG+jhhOgQT3Zwn9g7hJ2xFRPqyZuxpVTITbIq2eLgo1TIMWNgK8wY2Er0HArJ4CTIFMY8dQl2x8krZegS7AG1RoOl6TnseuVVatbSZEw4MkJoy/ErvNQHwzv5GTwOY2VaAP3p98npObhSzLdoNVaXHQC9F41tJwsgl8swKTaMpjEAdV1SKKZgsniqqqoCAHz++ef4/PPPRdvIZDJoNBrL9Iyih5gLifuAl3roi83EkkGXGJKbafzbg7msNUMG3bR97uBvilXJEoNPXT68Ta0LyIg+YcyTTCaD4mE2zUmxLfHz39dFhQxXOEodz7Q4JuaK/52x4xdawxyVckQEuPGEHSPOxNJbBHioGq3LDgCOXy7lfb5SUsnOPqRpDICladlsTckD2beh1RL2RawxQUUkxRAmiyetVmu8EaVOEXP1cGNXtFqCbScLUF6lxpbjV6AlWkzpF64nGNxUdhgXE4xtJ/kztLhuIDGrkVTAMvfhYonBpy5df5FBbqLuMgelXDQPk/DcCdMKjOjcgo2Z0tvXQ3eQobgqYxZGseNn3JBrM/JQVvkAVWotjuQWIybMiy1mzMCkt+Dmjn+2o3+jHgTEXLHM/a5UhFvdzWxtmBxm3M+NUTzZYggCxXagGcbrEWK1zc5dL0dyeg4mxerKdDAuoLLKB0hKy0ZmbgmiQ9x51qDEHiEAIFlmhCG/uAJJqVnsG5fQqsS1XHEfLrV9wNSp64+IxxT9u2colEq5nuiTinnipgE4fKlIPE3EQ/eQsP9ct6DY262x41cq5JDLZZJit+q+Golrj+Hc9XIQETvbxD6houegMcAtt1NW+YBnaW2MLjqKNLYYgkCxHah4qgdwB1h/NxWucGrTcRMeiv24My4VITrYg82cHRnoDi3RYt2hy5L7Y6wwwsLAQqtSZm4R7+GScjAXgHRCTVOpy7iT4/n8ZK9uKjsk9gjBxN4hWLEvV68995iF+bGYtALrx0djaVo2VuzL4QWQM+4hMYshc63E3m5NOX5DMyIT1x7TE3PVSju8OPoTPB8ZgOed9cvVNBa45XaAmhWabugIZ4kaisNryND4N4ohqHiqBwhjlmJCPXHuejlKH741c/NAibmkjl0uxg8TugFgXEJZIvaIRzjaPXJhcd+4hC6mRbu1vKnylspcXZdxJ8Jz1NbXRbQeHqA7Bm5x3aVp2Th7vZy1Vhx+aEGaFBuGzLxinnACdC5C5ni41ikptyDXmmXs+IXH0cJdxbpRhTMIHZVyRAV7ocvAthgWGwY0Yped0A3L5D6jPGJKv3C9WaKNERr/RjEEFU/1ALEHfmKPEHawZ3I4abUEAe4qXCur4iVbzCu6x06hz+dYrcSQAWjn68oGSRt84xJxgVnCvF2X5TOEQoYRQMZM9NwgWgjaJadD3G338PwoFXLWOsXEk6g1GizafYHnguUmtTR2/EKL2OFLRSgoqcShnCL4u6tQVqlm23YKdKcC4SGGrAk0QFiHofuvMZ0jWsaHYggqnuoBppYgWZKWLSqMrpZW8czwUjB11xgXlrE3LqELDLB987ZSIWdnywGPAt+Fib2F8V7CIFrg0bFKiUXu+WHilBiXKzfFAcCveWfqcXCzy3OFX6C7CgHuTjh3vRxtfV2QkhAFdVU19r/1CS4XV+DOmES8PqBNgx30DGHImkADhI1DzxGFooOKp3qAqSVITJmCD4BXIBh4FPfDfYs05YEoDKY2VwCYi6XeesUC34WWI25R5RGdW4AQ/tl1UMrxWu8wqDUa/HOV7yZjYDK6i8WICWFq3tUE4fF0DfXiBaO/+t1xKCsrsHbZhwCAts274VB+OS+TemPBkDWhIQYIW9pS1BDPEYVSE8wWTxqNBosWLcJPP/2E/Px83L9/n/d9cTH9MVkaU0uQcIVMC3cVCiRm0wnzPTHCydyHrJSoqyss9dbL7XdkoDu2nSyQbMsEzfu7qXjLOwW4QS6XISk1R3Q9B6VcZw1MzWHzaLVwV4m2ra21Tsqawj1fqvtVvHW4M/4aOqYKiIYYIGxpS1FDPEcUSk0wWzzNnz8fq1evxhtvvIH33nsP7777LvLy8rBjxw7MnTu3LvpIMQHhAMp1vUUGugMygnWHLrNB5oAukHhin1CDAdOGUGu0bPZtjZZgYu+QOhVPlnrr5YrRpNQsoykbCIA7VfxSKHIZ9JJPcqlWa7Fqfy5PqEqJ2drWmeMeD1coXC66Z9Aa2VisBqbe2w0xQFj4m9l6oqDGLzvcNA8A2HJOFEpjxGzx9MMPP2DVqlUYMmQI5s2bh9GjRyMsLAwdOnTA4cOHMXXq1LroJ8UIYtYp4We5TM5L6Fil1kIu0yVqrIkw4U6Jz7hUhMS1x/Djv7vV6jgMURdvvZm5+oHe3UI8cK2sihfM3VRlh/IqNc/VZ6hECgC92XdSWLLOnFg2eTEak9XA1Hvb1ADh+hA0zfRReI/mF1cgv7iiRlYobpoHGcA+O+oj9eEaUmwbs8VTYWEh2rdvDwBo0qQJysp08R5Dhw7F+++/b9neUSyKWJJNJjdTZJCb2cLk3PVyg58tTV1YBoSB4oBuEN3zRh+MWZPJisOCkkq23p+WACcEwfIKuQxdgtxxJFe//Iubyg5tfV3YGYxcLC1iTCk/0z3MEx1a+zcaq4GlRXd9CJoWiujAh9Yi5rcvJSINiYqGFO9UH64hxbYxWzy1aNEC169fR2BgIMLCwvDnn3+ic+fOOHr0KBwcHOqijxQLoNZokbQ7C4VlfNcRk5tpar9wTI9rxc48Y3IGGXoja+vrwgu0buvrUqfHUNupw2IDg1w/2wKb5kEh+JJJpihm2fFzdcT3r3ZFcnqOnkBt6+sCuUznnpPLgKggD0BGcPxyaZ3ksRLLiM49kjUJXQBnZ4vt01ZhrndmbhF77plC19zvzbU+1AcRIRTRgR5OvHtXSkQaEhUNKd6pPlxDim1jtp1y+PDhSEtLAwBMmTIF77//PsLDwzF27Fi88sorZncgOTkZwcHBcHR0RNeuXZGZmWmw/ebNm9GmTRs4Ojqiffv2+P333yXbvvbaa5DJZFi8eDFv+cWLF/Hss8/Cy8sLLi4u6NmzJ9LT083ue31ArdEiKTUL/b78C0v3ZuO+Rt8uQaCbVj8tLhzRIZ44fKkIB3OKsDj1IpLTxQOiASAlIQoxoZ5wU9khJtQTKQlRdXgktYcZGA5k32aPLTrEU68dk/uJSXLJEBnkJmnZ8XdTQamQY1JsGIZH+CPQwwmBHk7oFuLBns/Dl4oQHeKJGQNbYcaA1vj+1a5sIk5LMbF3CLqFesLVUQl/N0cEuKsQ6OGE1/s2vpIsTE3Bgzm6vF5a8sh6yfwmFgnuB1PoEuzBilFbFRFifZwUG4bpca3Qs6UXpse1EhXthkQFd/2p/cKhJVq8vPoIklKzoNbUr9qn9eEaUmwbsy1P//3vf9m/R40ahaCgIBw6dAjh4eF4+umnzdrWpk2bMHPmTCxfvhxdu3bF4sWLER8fjwsXLsDb21uv/aFDhzB69GgsXLgQQ4cOxYYNGzBs2DCcOHECTz75JK/t9u3bcfjwYfj56ZcWGDp0KMLDw7Fnzx6oVCosXrwYQ4cORU5ODnx8fMw6BmtgzhuzqTEwTBFbc97IHO2VdRrjZGkMZfNOOZirl7GdOScMRy4V41oZf9YaA2OlEsaFEEJ4+9TFWNWde2DFvlzWPVhWpUuUKQNAHHyAX3/VNWrAFmLub0MY78PMMASg95swx/pQHwLLTUlvIoYh65JwogVTqaA+ur3qwzWk2DZmi6d9+/ahe/fuUCp1q3br1g3dunWDWq3Gvn370Lt3b5O39dVXX2HChAlITEwEACxfvhy//fYbvv32W7zzzjt67ZOSkjBo0CC89dZbAIAFCxZg9+7dWLZsGZYvX862u3r1KqZMmYJdu3ZhyJAhvG3cvn0bWVlZWLNmDTp06ABAJwi//vprnDlzpl6IJ1P99WqNFltPFJiW/+lhEduGZJoXInZs3AFB6NIQDqaHcx99dlXZ8YrKMhYsYb0/bvFeQDzGypKIWcYIgMwr5cCrQ8RWsXks+bLAXNPaxJ7Vh8zTNe2jqaKivru96sM1pNg2Zoun2NhYXL9+Xc8yVFZWhtjYWGg0GpO2c//+fRw/fhyzZ89ml8nlcsTFxSEjI0N0nYyMDMycOZO3LD4+Hjt27GA/a7VajBkzBm+99RaeeOIJvW14enqidevW+O6779C5c2c4ODhgxYoV8Pb2RmRkpGR/q6urUV1dzX4uL6/b4GhDmPLgUmu0GLMm0+iMMAamiG1DfiMzdGxiqR4Oi5VceYiLoxIJ3YP04pY0RtSRWIxVTZASFGIxT4wwqI8zjJj7mImtM2blEIpHpsg1wBdIjzO5qy0jdk+YmyC3ob1kUSimYLZ4IoRAJtMfAYqKiuBsRhDq7du3odFo0Lx5c97y5s2b4/z586LrFBYWirYvLCxkP3/66adQKpWSKRNkMhlSU1MxbNgwNG3aFHK5HN7e3ti5cyfc3d1F1wGAhQsXYv78+aYeXp1iyoMrOT1HvN6aCNxtNOQ3MrFjEw4eaxO7QKmQIyk1i3f+hElHr5RUQi6T69WMu1qqn8uJyejOtVDVFinrIyMAmMB/Nki6ZyD2vPM5rpwtxOF2fXEg+zabPd2WRZTwPua+LIgN/MKCydVqLWJCPdlgf65Aqk8isq7g3kfm3BMN+SWLUrfUx5c4MUwWT8899xwAnfhISEjgzazTaDQ4ffo0unfvbvkemsHx48eRlJSEEydOiAo8QCf+Jk2aBG9vb+zfvx8qlQqrV6/G008/jaNHj8LX11d0vdmzZ/OsXuXl5QgICKiT4zDGpNgwaLWErbemJVqoNVreDSiWv4hLgLsKz3X2r5MZX5bgcfzADFk1hNa8IA8nyGUyniVPzOInvO9cVXYY3zOUZ9Hilmyp6XGJJT/kx7UIBPC9exj4xTsYCOC31j2hVijZ7OnMMdsiYueYEfpMQDigG/gPXypCSkKU3mxHhVymJ3Jt9XgfN0JLnan3REN+yaLULQ0lTYTJ4snV1RWATnw0bdoUKtWjUhP29vbo1q0bJkyYYPKOvby8oFAocOPGDd7yGzduSMYd+fj4GGy/f/9+3Lx5E4GBgez3Go0Gb7zxBhYvXoy8vDzs2bMHv/76K0pKSuDiopta//XXX2P37t1Yt26daKwVADg4ONhMKgZhkdkladmQy/gPM2OxNc9HBtj0Dfs4fmBiVg0mRQN38GUsRtEh+nFRQoZ38uMVYX6us//DDO66gerwpSI2oLs2xyW0sOQXV9So3Iqtx6sIjzOGk41d2O+MS0VYsS8XIzq3MHqdGBrKWzBQs2MRc/Pa+j1Bqd/U93g5BpPFU0pKCgAgODgYb775plkuOjHs7e0RGRmJtLQ0DBs2DIAuXiktLQ2TJ08WXScmJgZpaWmYPn06u2z37t2IiYkBAIwZMwZxcXG8deLj4zFmzBg2KL2iQjcoyuX8h4pcLodWW3+m2xqyPKg1WhSUiMc6cUuy2DKmxnWZO1gYmo0F6ESnMLmgMB7GkKtiSr9wyGVyXhupIObaPDjEEp6auq0ADxUu3tX1Rkpc2IqoEItFY/olFl/GnUHJzJhkptSLHUdDeQsG9I9FqyWQy2UGryFzfrn3Eo1hotQlDSVezuyYpw8++MBiO585cybGjRuHqKgoREdHY/Hixbh37x4rdMaOHQt/f38sXLgQADBt2jT06dMHX375JYYMGYKNGzfi2LFjWLlyJQBdMLinJz+mxM7ODj4+PmjdujUAnQBzd3fHuHHjMHfuXKhUKqxatQq5ubl6M/NsGUOWh+T0HNF6bTIAr/dtKTk42MqACZge12XuwGdoNla3EA/IZfyZWIEeTrxtGtu+mDtDKjdUbR4cSoXcbAsL82N/uoMf1CqVQZetrYgK4fnUTZF/dP2EsWgaLUFCylE2fk13HNJT6hvCWzDzu005mMs7lu2nrrLWaalryJxfscLgxvZnC88JSv2jocTLmSSeOnXqJBlDJOTEiRMm73zUqFG4desW5s6di8LCQkRERGDnzp1sUHh+fj7PQtS9e3ds2LAB7733HubMmYPw8HDs2LFDL8eTIby8vLBz5068++676NevHx48eIAnnngCP//8Mzp27GjydqyNoVIrwngnV5UdnvRz4WVXFsNWBkzAtB9YTQY+bioBIV1DPaDVEhzMeXT+OgW4mtlzfYSuEakAZnMx5yG04q9LmPTw72/25mDiUx304oC4WFNUmFoiBNDFoo2MDGAtUYwb9kD2bWw+fgWBHk6Sx6HWaHnWq/r6Fiz2QsA8rU29hubEMNnSc4JS/2go8XImiSfGrVYXTJ48WdJNt3fvXr1lI0eOxMiRI03efl5ent6yqKgo7Nq1y+Rt2CJCywPwqNRKt1BP3gyvV3qEmHSz2tJbeG0T+klhKBbs+OVSvUzJR/NKav2mLZWwsLZInSNufyMD3QEZwabDl1nxZMq1taZp3ZwSIVFBj/olnOlYUFKJW3cepRcRHocw5s3fXYWJvUMsfjx1jVBQKh8K86ggNyxLz7HINRS6u23lOUGhWAuTxJMlXXUUy8EMysLs2HIZzK5TVx/fwmti/pXKs8QcL2O9YzhfeKfWb9p18aZlSNAJp58DgOr+o2SdplxbU89tXbhwjJUI4fZLS7SsW04MJseTVOwal4KSSqzYl1vv3oqFlk31QwscIQRT+7c0OqOWWwOQl95CcE8xMxu51IfnBEBdjRTLY3bMEwCUlpZiy5YtyMnJwVtvvQUPDw+cOHECzZs3h7+/v6X7SJFAKjt2dIgnpsWFIyn10fJDD11RUgOD8C28W6hhF58tUBNREh3iiUM5RZIutMOXivSKHQuzhn978BIAw2K0rjEk6MRirO4r7fCfZ9+Bs70Cr8W3w38411ZqYDHl3NaFC8dYiRDu7EWuFQTgJ8XkQgjB1hMF2HqiAMM7+WFKv3C9uEGgflpRxF6iAF1G/K6hHgbds4C420/4vBA7L/UpuSh1NVIsjdni6fTp04iLi4Orqyvy8vIwYcIEeHh4YNu2bcjPz8d3331XF/2kGEBsRlJSapZeACljVREb9IUPR4Vc1iDfzIy50FISopC49hjOXS9HW18X9jOXskq12fmRLP3ma8g6IyYKNHIF/mjTE1P7hYPIZWxQtXA2oLkDS124eo1ZvQwF/TdrYg/IZLh1p5onorgTKJLSsgGiM0EKy+zUByuKEEZQCoU/AGw/eQ0zBrQ2uL5USR9j95RwMoUtY0shCQ2VxmbdM1s8zZw5EwkJCfjss8/QtGlTdvlTTz2Ff/3rXxbtHMU0jM1IYmBiogD9wbGhTB81hjGLilixYzFXn7kPYEu/+Rq6XmKTCdxUdkjsEcJzczH9qM3AYu59Y+gBK5XtXYhwsA/0cAKgm3FaUFoFGYCp/cLZafr/XC3TqzG4NiOPt6w+WVHEWJqWLVpRgBBiMCmr0F3PIHZPccVZfXtGNJbnmzVpbNY9s8XT0aNHsWLFCr3l/v7+vDIpFOshFkCqfviAlBocG8r00bpA6Opj0GiJZP4gIZZ+8zV0vcTSGLzSLQBTS05hSVoW5C5PQiNXsP2ozcBi7n1j6AFr6sNX2N8RnVvw8nYRAMcuF3NK4eiLA6GYqk9WFDGYagNC/N1UeueUm5aAO0MR0KV+CPJw0puZq1TIsX58tMnpDGwN+nyrexqbdc9s8eTg4CBaFPfixYto1qyZRTpFqR3CAFJnB6VB10RjM7caQzhbTUu0CPBwAiEEfq6OuFZWhfIqtcnFagHLv/kas6AJB4v/RPsAru0wFcDyGVtQYa9g+yE1sJhyX5gbd2boAWvqw1esv8np4LmVLhdXiApeQFfUubxKzVtmzvWoL7+XAHcVFHKZ3jlNToek2zPY01kyRqo+TzF/3H2vL/eIJWls1j2zxdMzzzyDDz/8ED/99BMAXS2v/Px8vP322xgxYoTFO0gxH2HWYEY4SbkmaloctKEiNlsN0D0QWrg7oaCkUrSchaEH5uN+8xUOFuryO+zf0SEeeOCo4s2oEhtYHncwuFD05xdXICk1S+8+FOuv0K1UIEgSy+Q6iwrywJHcIhzOfSTMYsycHGGL7glhWSBAd19yY72Y810XSVspfGzxHqlrGpt1z2zx9OWXX+L555+Ht7c3Kisr0adPHxQWFiImJgYff/xxXfSRYibM4CIsQSLlmqhpcdCGitTgQgCcu16u9x0z6Bh6YFr7rZ2bJDMztxgTn+pgtD/CWYa65Ku1OwZDD1ih6DfnPlQq5FBI5aGAzk2nJTr3Fvc3ERPqifXjo816SbBF98SUfuHYduIqTyxxBST3xSk5HXpJW2UgyC+pxLcHL7EFlh3t9YcHsRxi3FQIjfFlSwxbvEfqGms/4x43ZosnV1dX7N69GwcOHMDp06dx9+5ddO7cWa+mHMX6mGpGlSoOaonBsj4idj4A3Tls6+vCFvYF+INSQspRg9msrWnGP5Ffwv5NwK+FKIUwjthYsWlTMPSAFRP9UudRLCeRcEaYMG2BWEB1TWaV2qJ7QqmQ4/nIAEl3HPfFSUzAjlmTyYqtjEtFSFx7TG/iBCBtla1L64q1fzs1wRbvEYplqVGeJwDo2bMnevbsacm+UCyA8M3QWJI8tUYLrZYgwMMJN8qreIONJQbL+ghznjJzi6DRElwtrYRMJsPwTn54vU8YVuzLFX2QG3pgWtuM3znQnfeZWwtRCqEhx4Bhh0dtBztTzyMDk5NI6LoTy/ckJFJwXkyhrt0TNT1/k2LDoNUSbD91FWWVDyTjHMUE7Lnr5QY/MxiyytaVdcXav52a0NhcWOZgSlLW+oBZ4kmr1WLt2rXYtm0b8vLyIJPJEBISgueffx5jxowxuf4dpe4QPmimx7UymCQvOT0HS/aIZ2g2dbCsz4gNVAxXSip5leblMjkc7ZWSD25DD0xrm/En9gnVW2asD9xZhkzyVVOo7WBn6nlkYM6nUhGud8+6OCohl8nQxFGpFwcFAJCZ/4ZQ1+6Jmp4/pUIOuVzGFgMGTE/B0NbXRS85rBiGrLJ1ZV2x9m+nJjQ2F5Y5mJKUtT5gsngihOCZZ57B77//jo4dO6J9+/YghODcuXNISEjAtm3bsGPHjjrsKsUUzH3QGAoeNXWwrM+IDVSA/mwkU86loQemtc34wjc6S5ZoEVLbwc7YeRQma+Qei9BaysyqK618AIVcppfT6PjlUrP69jgQnj9TXKxi6wK6GXcAeElRxbYjlhxWDENW2bqyrtTVb6c+ugMbAqYkZa0PmCye1q5di3379iEtLQ2xsbG87/bs2YNhw4bhu+++w9ixYy3eSYrpmPugEb5JCsuVNHSkBnoxQVkTFw8D16UCAFqihVqjfXwPa3t7aNasQdq5W4gO80Hnlt4m16uTSlYpRV0KRbFM2txSQoaspULhZKuxKEKBaIqLlbsu99xrCUyyYoklhxWDEbZJqeDVusvMLTGwVu2oKxdYfXQHNgTErJe2+ls0hMni6ccff8ScOXP0hBMA9OvXD++88w5++OEHKp6sjNiDxtwp9I3p7UtqoBdzTdTExcMgdKksScuGXPYYTft2dlC88goGAhhopKk5g4rYvVXbwa7qvppnBVk1pjPWHLzMbk8okLhB39EhnjiYox8YLsRRKcfrfVva5AuCWIZ4U9/KuZYhLQHOXi8zyQporhVGuJ2MS0UmCzxzqSsXmDELKbVM1Q3Ce5Qb81SfMFk8nT59Gp999pnk94MHD8aSJUss0imKeYj/yMXLtdjaFHprY2igFxZara2Lp77EbpjTTymhVZt7KnHtMdaylHGpCIOWHMDVh7m1DmbfRrdQT8ge9s2U0jRieLs41riPdT2oimWIN/etnBuvx2AoQS73nJma9LWuiyrX9Xk2ZiGllqm64dGYU7/Ppcniqbi4GM2bN5f8vnnz5igpqTvTLUWH2APF2I+8vgza1kBKPDLLajOACbFq3JNaDezapfs7Ph5QSv/0xfopNZDVxb0lnOlVWFbF24cMBN1CPVnL1MTeIbz++bupeEHTYgzv5Ffj/j2OQbWm1juposmOSjkm9NLVNuSWFBJrb8p1rOtad2qNFmPWZJqVxd9cJvYOweFLRbz7iEtjfW5Si5tpmCyeNBoNlAYeuAqFAmq1WvJ7imUQe3Ab+5FbO1i5vmKpWAvu1NxuoZ6P3Uyt1mix4o//w6Rnhuo+l5VD6dJUsr14+RNxwVAX95Zw5pePqyNredJZnGRsrq3Dl4qwYl8uAH6QPxO7xyRyPJZXYjEXgSUHVamBqqYWYakJIFVqLY5dLmXPG1NJgDkGLqZcx7qudZecnsO7B+pCvKzYl6t3H3HPeU3ubWsKD0vtm1rcTMOs2XYJCQlwcHAQ/b66utpinaJII/bgNvYjpzlHagYzgDEPJWMzlqTgPoxkAKbHtXqsD6Pk9BysSM9mM4yv+OsSJj3dUbK92MAtJRhqUxdPCuHML27MU2SgO7adLDAa5K+Qywym6KgJzDFx3WG1FYyWHqikUgkA+tnxxVybgR5OGB7hr2ehUirkUGu0WJqWzU56GN7JD1P6hfNCBCyFmFCy9EufMRFck+emNYWHpfZd05eDxmaxMlk8jRs3zmgbGixe94gJJWM/8sYe1ySFsR97TeNBhFjb/C+0RnCzjZuKlECvi7p4YjO/mHWTUrN4JUiYvgH8IH+NlugN/sYwdj8IXVym5lAyhKXvDa4rqomjkmexE2bHZwj0cEKgh5PAypild+2S03OQtCeLXS+pDic9CGOqzK0/aAy1RsubfSkmgo09N8XuF2v+1i2178ggN965jwxyM2m9xmaxMlk8paSk1GU/KCYiNTuuId+kdYWxH3tN40GEWNtt2iXYAyfOFrCfhdnGTcHct/C6GkSE23FV2SEztwhRQR5sNn2NlrAiwZyHuDmxg4B0rUhzMCe+zBS4rqjSyge81CMTe4dgxb5cbDl+hSdAh0f4Y8bAVqLHyb12YtewrsSBsVnAtbVyCN2C/u4qZOYWISkVJm9L7H6x5m/dYvsmMsOfJbD2S+LjpsblWSjWgQoly2Hsxy4WP1KTh5K13aaTYsOgrKwAFuk+H79cjKTULLMGHHPvO0s8yMUGSKFbqqzyAQ7mFOFQThGbTf/l1UeMPsTNtRqYYqmoCebElxlDrdFi64kC3j0rdF9OiwuHlmiRlJbNLtt2sgByuYwVV1JuSbEZdvnFFWbfS6Zg7H6rrZVDeE8UlFSioKTSrEzXYvfL2sQuVsvnZqnnzHGBZVr4WQprvyQ+bqh4ojRajP3YhQN1Td001ha8SoUck/q1ZD9nXCrGnoIKHL5UhPXjo0Uf7LV9s7fEg1xsgORu93LRPdaCQvCokLVwkM8ruoeXVh3m1c8y12ogtFR0s5AbyZz4MmMI47EAnftSOHgLU25cKanEotSL+PZgLlsPD9C/37mJXksr7qO8So384gosSr0IrZbwrFd1TW2tHFKxYeZsS+x+MTWfW13EB1nqOWOOCBKrpcpMzjDXklffoOKJ0mgxNsA39ASiTGJDxtphivXD1Id+bR/kQisKwaMyJcx2R688zHM/MYYh4TR6MauClNUAkK6px4WbmNPS1HTwEgsAz7hUhDFrMnlVA6SEA1c4MXCvr1Ihx4yBrTBjYCv0/iydLX0DANtPXX2s4qm2Vg7ub5vr5jVnW1IJiYX3rZgYs+X4IHNefMRqqUaHeLLL6mPNOlOh4onSaDE2wIt9X29nlNjbI33yXOy5cBMPFI9+9kfzipGcrl/CQygumLdIbvD8gezbOHypiDcwGzoX5pw7MSuKsEyJMNM481mpkEMhUqeFO5AJBYRGS9jZlGLlaB6nS6Kmg5cUwlxJzPaEsU9CmPMtJq6tTW0tm9zftqHi4KZugyEpNUvvvhW7V2w5PsicFx+p47DVY7MkVDxRKGZgy2+MBrGzQ6/FH2DlmkyoBYkNTUl/wa2RxsWcJIaGrFnCKfDH8sTjLLgP4ugQTxzKeWQx4BayFrOucEWPlOWByX/EuKsMlTGqLZbI8SQWxA6IpyEg0AkmxnonjH2S2r6YuB7eyY+3bm2SjtYES7rCLbktoVAI9HASvVcsKcat+UIndRyNIfaJiqdGRr21nNgItvzGaAypxIbJ6foPO6FYyMzVn+LOxZRzIXXuxKbAx3BKsDCIlWLh9pGbY0qrJQjwcAIhBP5uKijkMl5yTO6AyQ0wB3TCY/HDord1WcbIEkJcOHgxoo+5xnlF91DAsS5dKanEmDWZSEmIwvaT1/S218JdxUtvICWu1yZ2gVwmtylrlC0gdj3Enq+WFOPWfKEzdBwN/d6g4qmBIxRLWqLFkrTs+mc5sRHq7YwSjQbYvx9KANNiewGcxIampL9ISgVr5QF0b9T+biqzYkWEgdxMMLOY6Dp7rexhDTsCAploZnAp14swhuX5yABeu6TULIMz+IDHI4wtIcSNXbuXVh3miSdAZy1MXHtM1DoV5OGEkZEBRsV1XU6CeJwveFL7qmkfTBVFlrZ2WeuFzlh5q4YMFU8NHOFbSYCHU721nNgC1k47UGOqqoDYWN3fd+8Czs7sV6Y8yKWO21CsiHAAGt8jCJuPX2EHcyaY+WqpftxNWZUahy8ViWZjN1bfkYvwHue2Y2K25DLd7LmCkgo2BuhxCGNLCHFj1y46xBMHc4r0lgvrB3LbC7fHXNfM3KLHMotKapZlXQgqKatNTa051phZW29f6Oo5VDw1cIRvJYTwh5fIGiRMbMxYO+2AtajJG2Zyeg4WPXR/Hci+zRNODNzp/64qO1Q/0KBKrQVg2kwlRgAJS48wCAcTYYwQt7Dt1H7hkMtlj00YPw4hzqQXWJuRx86mkwFo49MUh3P559ZRKcfE3iF6ljnm2iel4rHMohKzpIjFXVli34YSgoott8Wwh3r7QlfPoeKpgSN8K/F3U/Fn2MgMRbJQGjPCHC6QERy/XGryoCGWiNAQT/q5QEv4gsbYTCWAL8AYuJm1uYOJofw+x/NLLF4PzxCPQ4gz6QWm9G/JG/TVGo2eeOoU6I4V+3IlRYpQUKQczAVgeQuUmCWlrlxTUlYbqeW2OGHEFl/oDIlMWxSgNYGKpwaOWOAvF2HCPErDR63RIlnEuiBk6Z4sdkYVN1bJ1EFDLCM1F383R1wtrWI/a7SEN6BLJaKUEkAMMaGeksk/LZHfx1pYctA5kV/K++yqskNKQhRe/e64pEgRnvfSygd6gfWWQDzret3M4JKy2kgtr88TRh4nhkSmLQrQmkDFUwPHUOBvfRgwKJZnxV+XsPhggeTDixmkV/x1SXR9bt4nQ2+WmblFcHFU8pIptnBXIdjTmbV+LE3PYb87eaWUtx+pRJRCASS0PHHXExMc3PQITLzV8E5+Nu/uqE3ZljFrMtnzdCD7Nlq4q3izGdv6NMXAxfv1EmXmFd1DxPw/0dbXBavGdAagsziVPmxHoBPZhy8VISUhCo72tR9SxCwpdeWakrLaKBVyVrQxbkPh5AL6/JTGkMjkztxlniUAFU8UG4f6xyk//33V4NuzKYkXj10uYQORDb1ZCgnycGJdYy+vPsL7rvphrBMDt5q7WC4oJiM4VxiIlVXhxl0xJWmE6REyc0ts3p0gHJC2nigwOeGoUGAWlFSyrk0xARro4QQtIbzg/gnrT+DHf3cDwM/5pX64fuLaY+z3lsYarilj5YHo81MaqZm1SoUcWsGDQfi5vkDFUyPDFv3jlMfLleJKwN6R/Sx8exbGFDE0dVDgvoagWq3lCR2hAJNaH9A9KF9efQRdgj3QKcDVoFtPqwEbvCwc4JPSspGZW4L146NFc1dx+8KFKUkjtvzJeX9C/fBJbovuBKHbLL+4AvnFFUYzvUu5lq6WVmLPG32QkHJU77tADyecuVrGW8bM0GPO79I9Wez54n7fUBCznigV4TZ1T9gqwhJJhx/+7qbFhUtWBqhvWP21Kjk5GcHBwXB0dETXrl2RmZlpsP3mzZvRpk0bODo6on379vj9998l27722muQyWRYvHix3ne//fYbunbtCpVKBXd3dwwbNqyWR0Kh2DB2dsBnn+HH5ydDrVCwi8UyIHcJ9gD3eeaqsgMA3KnW6FmHuOtIrR8T6omeLb0QE+qJw5eKcCD7NhanXsRRiSziDD+fvobFqRdxIPu2aFA4I4QMIRVwLracKwQMxbOoNVos+vMien+Wjt6fpWPR7gtQa8TPiyWZFBuG6XGt0LOlF5tJnCGDc16F50TKtcSUXxH7vkuwB9r4NOUtYz4zL2DC9dr6uph9TLYM9z6mLjrzEJZI4v6eokM8eee1c4A7Rq88jIj5f2L0ysOouq/W254tYlXL06ZNmzBz5kwsX74cXbt2xeLFixEfH48LFy7A29tbr/2hQ4cwevRoLFy4EEOHDsWGDRswbNiw/2/vz+OjKu/+f/w1S5aJkhVlyc5aUCuQkBA3BKlYsR+h3j6oH2VJKQXLjtLPTT+9Xe7en3JbF0CkivUmWKs/LLXYX21LhQCikLAE0LohCQmBQECyAlnIzJzvH5Pr5DrXXOfMmWRmkknez8eDB8nkrNc5c673eS+vN44ePYqbb75Zs+z27dtRXFyMwYO92wa89957mD9/Pn79619j8uTJcDqd+Pzzz4N2nkR40dPDN50iMhJYtQoXd52Esz2MJVNA5tW5gY5WKTKtIEaekNitJ9zIK3kr8PZURNmtGuOsofmaYegQ8OTfFJVdUhPNPym9BLfixuMThyJ/yxF8ea5Bk3fFK6jzb8Yy+MlSFOEUvWBWS2gq59g+1u86qatrJeaQ8DpNn59rQENzx+TE1MLdbkUTEvU0udVW5I3P0MqaFMzNRv6WI/jqfCNGDYpFwdzswJ2shFB/L82E6PT64okh5iWTh4fFM6QrY9xyzam5H7LT46X5YeK48t/fYId/A4lFEYV/Qkhubi7Gjx+PV155BQDgdruRmpqKJUuW4N///d+9lp85cyauXr2KDz74QP1swoQJGDNmDF577TX1s6qqKuTm5uKf//wnpk2bhuXLl2P58uUAAKfTiYyMDDz77LOYN29ep4+9sbERcXFxaGhoQGxs73rj6uvwE5MFkAo1hiu+SojF/KHlU0YAkPe1A4DUBAf2PHm3qQesOOGLxtKEzERYLBZdg2ZCZiK+qr7sldQswtTP+e3wieqiivTm/eVe20xLjMGHy+/Epn3luonpPHcM6x9SmQP+OootWCZkJiJvaH/pNfbn3n7sjYOasGqoz1GkJ34v1374jSZ3blm7VhjLs2Os6AHHaoaujPEjrxdrviNG9yHPmGc/VAsQACDeEYHjT9/b1VMxJBDzd7d5nq5du4aSkhKsXr1a/cxqtWLKlCkoKiqSrlNUVISVK1dqPps6dSref/999Xe3241Zs2Zh1apVuOmmm7y2cfToUVRVVcFqtWLs2LGorq7GmDFj8Pzzz3t5r3haW1vR2tqq/t7Y2Lvi+0QHvbIc2eUCjh5tb88yTtOehSEmFvN9zACP5+J0bZM6UbPWJ2bfTNkb559KzuBMXbNXCNAmSX5ITXAgnTN62HHyFV8yRK/WlRan18TPPDkL7srElLX7NOf10LgUjeaRL7LSEqTikiKB8J6I+luna65q/l5V36xbledPwrNeZVl3eWY7870M9rEy7xL/uxhShclj7Qn4GmOj8RS/c19XX8bWBXmG+3O63Lg+2q75LodL+LfbjKdLly7B5XJhwIABms8HDBiAr7/+WrpOdXW1dPnq6mr19+eeew52ux1Lly6VbuPUKU/59TPPPIOXXnoJGRkZePHFF3H33Xfjm2++QWKiPK69Zs0aPPvss6bPjwhfemU5cksLkJMDAHA2NGLjoWov8UtZr7OstAQuXDRcN0xhBrad946e9fqbBZ5ciGLBu5OSEONl9DBDQM+wmTEmGYcqajWGoNEDOTrSjr1P3u11XnMLDhsaTtF2K26MjcaMsYMBKFi366RPGYFAaNyICusiFotFdwL0p2DEqCWPrIIx2AZUZ76X4li9d/Ss2jxZDFfL7msjw8vpcqOh+Zr0OMXrEi7PEF9jbHT/jhoUq/nOXR9tVyvs9Ni4p0zjNU1JcAQ9/BsoelW1XUlJCdavX4+jR4/CYpGn8Lvdnrfd//t//y8eeughAEBBQQFSUlKwbds2LFiwQLre6tWrNV6vxsZGpKamBvgMiJ5AbytHdrrc2LS7FIvaf391bynWHTinO/nyuBWtdygY1ZrRdisev3sYFk0a6iXiqleJw9qObD9eBUVRkBzvgM1qUZsHO11uv/JxZOclVrelJDg03qnH7x6mriPmc+l5GgLh1TSqZkxLjMGMsYNVcVNAWybuD3rXWq+CMdhhKf6aA55709d5iWNVWduEtbu+QVHZJeQOSVQV82UN0wHjljAb95Rp8seAjnwxWQ5ZOODr2Wd0/xbMzdZ4cKvqmn3eF+K9lJF0XUC0wkJBtx1l//79YbPZcOHCBc3nFy5cwMCBA6XrDBw40HD5jz/+GBcvXkRaWpr6d5fLhSeeeALr1q1DRUUFBg0aBAAYPXq0ukxUVBSGDBmCyspK3eONiopCVFSUfydJhCW9Tc5h454ybNrTYTz99bPzupOv3WrRVJ395dPzWDZlhM/Qhz/tGB68dZBGHHNMary6fHZGgiY5vbK2Cet3nfTap91mBSyK6i07U9eMZfd0GDN2m9WvpFPZ8YsTyYK7MtUcKFnbFz1dG55AeDWNFNaZV+VQeZ3qBSg6VYPH3jiIcw0eNfcZYwfj8YlDvc6FzwMzutYyz0pXwlL+hNYOVdSq1/xlE4n6eir3xeW1apKyUcN0I0NX/D3OEYEjFXXYuKcMS+4ZhhX3jvA6v860OfKHroQpzV57vfs3OtKOjKTrVOPJzMtBOHv5u814ioyMRFZWFgoLC1WZALfbjcLCQixevFi6Tl5eHgoLC9XkbwDYuXMn8vI8cdVZs2ZhypQpmnWmTp2KWbNmIT8/HwCQlZWFqKgonDhxAnfccQcAoK2tDRUVFUhPTw/wWRJE92PkqeCxALguyqZ5m25obsPkFz9SJyz+DVysQGOtTny1Y1g6eTgmZCaqk1dxeS02FJZ6JhtF62o6U9es2wJk+7FzXr+v+N5IM0OiUUF3uRV8eb5Rrcjjj1/cJ/tdFO188NZB2nPS8caY9WqKx1dV3wyLxaIaPoBHJJMPtbKqR7FMHICmao5pZMmul5mwolip2NVJz2woU5aT50so1ExVpey74XIryMlM8JrYxXueV2lvaG7D/rIar6bJYpiTEQwtsa6Ehc1ee0D//jVjDInG5NJ7hmmMyXChW/1jK1euxJw5c5CdnY2cnBysW7cOV69eVQ2d2bNnIzk5GWvWrAEALFu2DBMnTsSLL76IadOmYevWrThy5Ahef/11AEBSUhKSkpI0+4iIiMDAgQMxcqTnoRobG4uFCxfi6aefRmpqKtLT0/H8888DAB5++OFQnTpBhIzxGYk4+mVHntEPvjsY276u00y88Y4I5N+e6dUypaG5TVOJxr9N8r3veNikxiYz0dV/5HQtvqq+rFln+/EqLLlnmFcCrrjPrsAbPOJ5ifuTNb01kivYsKdMkyisd8xmvZp6Ku28LIKnfYjcU+Cr/99X5xulXhUzYUW7zWooTOovZkOZss+ZUKjeZC8zJGUoiqIJyxafqkFORiKWTxmh8Tzy1ahARwNqdhzsHPj7R+98glGM0pWwsEzBXubxNbp/zbwciEba8ikjurWKs7N0q/E0c+ZMfPvtt3jqqafUqrcdO3aoSeGVlZWwWjsu3G233YZ33nkHv/zlL/GLX/wCw4cPx/vvv29YJSfj+eefh91ux6xZs9Dc3Izc3Fzs3r0bCQkJvlcmiDBj0aShsDc3AWs9vz9+91C4Y6o1Jcn5t2eq3iS7zYbD7eERMYmcf5sUPT88TICRiSnyE/np2iap4bJxT5k0aR3weAKYMjl7oM8Yk6wpE58xJhmAfvhhQ2GpZnkjZE1vzbStYZ6IrnpjjLyFYl/BLfnjpR4XlncjMxT5Cif+WM2GUfQm0c6Ejczu06jRtJGhIN5/aYkxnnvFomD7sXOorG3CGS5pmW2vpLJOM6mv33VS2kfxDz/J9ZLh4O8fveMORpiqK2Ew8Tj577BZzLwc9JZq5m7PzFq8eLFumG7v3r1enz388MN+eYgqKiq8PouIiMALL7yAF154wfR2CCJcsdusWDR5mPZ3TjjRrXRMyCzXZ+MeeBkyaYkxak6NDNYnjcEeir4a+QKePBzxIRpltyI6wop+0RFqiImvmHr87iGwWi2aXJLH3jioG0KUebWM8KftDOAx3tjxmPXG6BkbRp4jt2KcyAx4rrHVasGZ2iZ1G3GOCMQ5IjA4LloTxpvAiZz6WywhHr8s8drXZGp2n4smDfUKVTKMDAU90VYAulWmgHdvRVmVqCj8KDZNZlIfYujQ13eps8jO1WzOlWx8g2HYyNoMyfIaezrdbjwRwaNXKmUTnSMiAnj6aQCA02qThq8OcInavMhfnMOOubdleKkki56f8ekJOFhe6/XWy7+Nis2AAU/oY8lkT74N/1BlPfTEiia+YuoPP8mF3TYc63edxNpd3l4lX2+2qQkOJMc71JyiwXHR0nMAvB/6EzITNUnYSyYPM/X9MpMrxhu3Ys7TkYo6vyv7AOCW5Dj84Se5XtfAZrWox+1vsYQYgtFLvDbC7D7tNiseGpei8fCwsJmR0WXkJXMZdaXl8u9kXtGUBIfmpUOU0ODvn5yMRFTVN2sqQ/3F1/Nc7++8V8wo50ocXwvM65f5A7tOzFCrrG3SzWvsyZDx1IsJhKYM0UuIjASeecZLRZxHb7JraHbiUHkd5hYc1jxAl9wzTONpMapGY4ihgbwhSSiYm60mR08YkgSrxZMorucRYBSX12LW/xzCW/NydCdpfgITq/xyMxLw9vwJmioz/hhyMpOw4K5MdfKQJbd2ZiLRC/+xXBm3W1G9A0x6gd/P+l0ncaCsRjc0w9pkHKusk46DaAQ6XW7c9Zs9AIxbicgmZzEEw/ald2z+vtCJyy+4KxOA3IvkC3FbTpdL8z3gk78BT24eQ1ZZV1XXjLN1zThQVgO3W4HVavG6f1he2su7T6rbZiFCMbHcF76e53p/1/OYit93WWsms/plMvSuNTNmWWqA7FjCATKeejG9JbZMBA6xYomHn+zEHA22Dv8AZQ9B9pCc9+YRuBXjLukL7spE8akajf7Sq3tPebW4yMm0eHkYjlXWoUVQJWcaQ7K8El4/CgCsFu0kO2FIf3Xi5Scevi0F/9YeqORWo/BffXObZixkE5avMFf+liOaaxznsOPHtw+RhuZkffqgWNQyex7Z5Czm2PgKXfr7QtfVF0A9L98npZcQZdfeD+I14Z1S4nnGOSJUj60CT8EDC5GKbU3MGi++8PU81/u72Zwr3sizwPN90dumGSPY17ULZ5kCgIynXk2435xEAHG7ga++wrn9n8GiXA9FMCRSExz4t6xUdbLTK++WPbRlnpT9ZTVSNedN+8rVCaz4VA027SuXtrj4cPmd3kbWR2XS6j6WV7J5/ylNiO+Gfh5dNuYx4z0JgCchmN9GZ6vPfCHKGgyOi9Z4OfKGJOGr843SdjOyfbZcc2JbyRlUN7Sg/NIVXHM68enZRnUSE9tksB3xnkOjMOr241VS40k2FnzrHrfi8dbkZCZJk9j1tmFEV8ffKMlfbA8kwr8EiKKsbiHcd6GxxatSjXkrnS75fvx9Jmelx2uMID4nC9B/3svkGmQ5V7KxzkpL0O4zzVNUZcao9XXtwl2MmIynXky435xEAGluBm6+Gc8B+P+v+BOaI6M1f54+ZrDm4ceXovNv7LIHvt6btSyXwexkKBpZr+49BcCC1AQHLl5uVSc+djx2mxVzb8vQGFfJ8Q7NAz43U3vc/OSjN/GIk8fYlHi/c0A27inTeJMqa5u8cnV4LSARUXDzvpc/6VBxrm/Bxr2ellNsEhPbZPRzRGjGgYWY2LU1i2yMmPdx/a6OXB+jcJTeZOzPPv3BrMaZjJxMj+wN87JsP14lDSXHRttVjTAGy+URPT4TMhOROyQRRyrqvAo1fAnPigabqImm97yXyTWkJcYYKuqzsRY7DMCiqPvgv8dMmoEP3fM6WLJrF+5ixGQ89WLC/eYkgsPiScOw4eA5TQjs98WVOFpZr4bdWL4GMBQbCktRVe+ZrGWtJowqw0QDSXxAszdzflJilXf8w5kPiwDyROElk4eroYbxGYk4VF6j2QY7h46D65hQdF80LNqzOny6Vk0oNxtGkhmIX51vRP7tmeqkuWjSUC/PGUMU3KxuT1IXYWNdMDdb05rGYoFG9Vkcy5R4B85yY+PJddEiy4fx5bWQIoyn1+8CXX0BFO/NvPZ8JL7BNU+U3Yob+0Xhh+OSNf3tjCQqLrd4XzM9zjW0oOS053vGXg70jE1ZMj4P7zkFjJ/3ZoxQ2VjPLTis3efpeq/tAZ5w89pd3+BA6bc4WNFxXBMyE9Xq0d728k7GE0H0MRZNHoZ3v6rVGCxMHZnBV96JeRBiGw+WSH2kog6fn2vwMgD4B7X4gHYrbk3ZvKzyjpk4/OTF9HUYYmgsKz0e2RkJmsRqsd8lP/mI+VtzCw4jKy0Bfz6mDSl+XX1ZYyT8qeSMWsKul2wtyzkRdaRknjOGAq22U0ykzcvTwe8rOtKuaU2zftdJFHHjwLbJuNzSphoVHUazFjHpefuxc7BarFJpBSMPEZt89X4X6eoLoMwg2LinTHOv80TZPE2VtxyowKHyOhTMzfbpvbJYAIVbwGYBXDoryLTTWJhP9D75m4xvhBkj1Ex/RyYrsOCuTLjdCl7Zc1JzrkdOaw26cw0t2PfzSaaPM5wg46mPQ3IGfRNRZkCEeQ8URdE8wD2Ne73beCyfMgJvz5/QLhnQEX7K4zSERIPLrbhVdz/DAkWjQyXTD9Lr9s6fz/rCUiybPFyjEO1rG2w7srJuxqhBsarHAIBGXHG9Tq81Pl/mYmOL6vETPTS850wMlfLaToAnVHSl1alJaubHWty/3lgCQEOLE8WnajRJziKiASGGZGV9ANfvOqnmQjHDLCs9PqR5mDKDwChvqrHVhcZWzzUtOlWD/C1HkJOZYNhAW4ymiYYT877IDCeGTJDS32R8GeLzXS8XTQ8jWQGr1eJ1rmJ2l6IoAZc66CmQ8dTHITmDvsmSe4bhUEWtz8q7YuHvbKIQQ2J/KjmjGkXLdMr5fRkmAFDZbowwA2rjHmi8W2y7vIQAC9GJiArRTpdbE9aTTT5GXoa0xBgUzM1Wczpkk6FsYmayDgCwpahCEy4VBQL53nn8pMePN+DRbMpOT1Q9baLXS/5S1LFtq8UqFXTUE1QU+7jx67Bz5J8bouI24CkiWDJpqMagNTIAgvViJwvl6SXsf3muAYqid0eY41xDC3Y/MdGrnZGYKyVLqOaT1A+W18BmtUjlK/To6vPdX1mB6yKsuHKt4/4eHOfQfOdlRSTh+gJPxlMfh+QM+h4bd5ei6EKLdw4QPDkf2ekJ6gNaNEpY3qn4tn2mrhln6pql5fwspLZpX5nP5N3LLR0TmNhQNW9IEt6alwO7zYq1O0+oE9EnpZcwIdPbg2EmQVV8cPOeEZHkeAd+8vsS9Q1eluSt50kRPWMMPYFAb2MEmhCkW5GHU/n96U2a/LZFQUReA0w0cPOGJKGqvkN/y8hzpGeE/uXT86bDOKKxXXyqRpPn1tkJVi+UJ8tr6ueI0ISVOwPzKokJ3qMHxeoKsgIdKvFsvDujDyW+5DDPMY8ZBXK9sKx4j9w0OE6T83SuodnQYynqzoXTCzwZT30ckjPwTbi+Genxyp5Sr2o7xsKJQ7DieyPV33MykzSTNqtA0tNy4g1wNm56LTVkjB4Up/4sGvJFXOK02Fevqr4ZyyYP13hizIQ1RCNjKRfqY6HFv3x6Hg3NbV4PeN4z4GufRi8lejkvPOKEL06KZjV/jLbpVty6nkjAk2e2+4mJmtwyt+LWVAICJpS7TSIaYIGaYGVGNBuLg6cuobKuGZdb2jB6UJwm2V4kJT4aFotFE7qNi7Zj1KBYHDtTr5FCkI2/zWrBUu6elY2lbD3Z9dR7RomXQXZZxJcUhqh4z9/rbsWNxyd63/9HOMMJgDQ3j3mq3Yobfz5apRk/9l0Ih2ctGU99HJIz8E2vCG1GRABPPom/fXYeTptNukhuhqdsnG/Aq3d/8EYVD2+Am2mky5OS4EDB3Gz1d1mi9br2tixiKMVi8Qg7yvSJjBCNDD7Ux96KZQm+hytqYbcNN71PPaFChq8mrEaeKMC7cbLeS5FROE+m+SSeg9gz72VJnpeRECtr3mwGvTHrrIfc6CWIz7OzCh6pA5LkcguAh7PTAGhz0VqcbqmnyuVWkJOZoLkm7EXEaCz1xkC83nrPKPElR/bSozeWYlhWdt3F+59XvwcgbQAOeLxosuIIoCOpvqc/a8l46uOQnIFvekVoMzISeP55lO46iTYdPaHzja1qIrF3fkLHPSKWrT946yBYrRaNqx8wp7EjSg7wb5kL7srE/3xySvP2qsDTliU5Xus582dS5jHyvOoZAUY9v/QmaP7Nne8nyCMLqeghbk/mFQO8jV6jFwFRg4knzhGhVvyZ8XrxRNutuDE2Wu3/B5jz5soa1QKd95CLHpbiUzVqGJj9XRwbXhH/OwP7YXxGAo6dafB60WTHqSe8WXyqBjkZiV75XnMLDmvGUvRALrgrE9tKzmi8XykJDq9+iHrPKD3PMY+RAnlWWgLWfviNWuzgjzdTzAmMtlu9OgSI8M3Fe/qzlowngvBBbwptytSGGQ3N1wzzExhi/s6R0/WaSYghJubGOSIQG21XG6P6SnzdtK9ctyT/SosTK0wmHhth5HmVPbhjo20YPSgOfz52Vg038EaInnFit3W8pTPDYfP+co0Rdbq2SeNN8JlQa1GkXjGWpyYzTAxfBAw0l5iUxYEyT+82o5J58bq3ON04U9ukycsy482VNQKWKWP7go2fWNlZJOhn6Y0NM1QOltcib2h/r/Y8YkK1DNGryRANF9EDuWlfucZwYpISvG4Xu8566uJAhwK8TJRz0aShXgZabLQNNw2O19znPGwfsnuTHTuflwgAY1Lj1RwvPfSai/dEyHgiCB/0itCm2w1UVsIO4K38bExe+7HmYc/36uIx41koOlWDDYWlXk2CfXmnfCkqyyroGKMGxQbEY+pLWFB8I29scXmFZfgxMuOlZPs8VF6j0Rs6295oVjQm9AwNMe8L8JY14D1RG/eUaa65ODmJmktpiTFIS4zReBAUeEI/RhVz7Hexmu/gqUt45HWPF0eBVgKDGTai0SgKc+o1LZZhJufOSMB1fEaiz+vJ9nG65qrXtlMSHKiqazY0BGTeNX4f4v6Yl1ZsDC32jGQNlM0owNttVqQnxmiMpzhHpEaSg4fvlWjozRMS5MenJyJvaH9NYjpTWucbcb+695RhHlhPgYwngvBBrwhtNjcDme0P1CtXNG/0YqNTHj3PgmhU8G+on5ReQlHZJc0b5JHT9V6hBl+KyhOGeIcYOo7BuK1HIJAZATL4MTLrpXS63NLkXcBbNqBgf7lmAv/t3lIcLK/xul6sEbIYVivY72l1w0+GMg+O6DFKjneo//NNb3Myk7wERXmDWK+ar7LdOJQhioYC8ka1/kyiRi1vGBU1V9FyzYnoSLvmJYkVC8iMTd7Id7rkOU4TMj0VmUzWwkiYUvwu8veM+F1zuRXVMOK9Sbw3melT8d5gX0agGN6zWCy6HqLRg+LU688EYhm8N09UQD92tt5UU21fOXU9BTKeCKIP4ks4Mc4RgThHhLSCTAz9WeBdVXP8TL3mYe3xNnT8LvPIiA94qwVqaE7Mnzh2pqGzp24amREgEmW3YlxaAhbclemzhQmPmE8l81LoJdy3Ot3SJOZIuxXvHT3r1Xi4nsuJYsh6m/H3BC/SCXTkpjGj4rE3DmqWkRnE4j22ef8pzf6i7VZER9i8tKYYehO+2epXvXwZXl/pbF0z8rccwf/vpxM013vth99oQk5842wzhRDnGlow780jqlfFCKPQ2qJJQ1FUdkk10IpO1eDVj8qwZPJw3fA7W27W/xxSPVVG4qSy+xaAbkI3Ox/Rk8lgxy8annp5giLhkmNKxhNB9EFEbxoTTmQhhIbmNjQ2t2ne9vlJKycjETmZCWoY7k8lZzSekKgIG1qdbvVhzStz63lkRK8N83AAWtHFYOZCyCZmIw9Uq9OtvumLGkiip4TftiwJWjS6+GRiPWKj7Wi65oLTraCxxYnGFicqa5swITMRX1dflnrM9MaPvycee+OgZt+sHY7nOpz0Oi7ZJCfeY+JkPzYtAROGJGkMEV40VM+LZ7b6VeYhTUuMQUPzNc1nX51v9FqXhY1E5hYcRiXXF1AP0dg30maShdb2l9WoulZfVWuPj7XGMZKVALTSDksFtX3eqBdb7xwqr4PV4gnPyXotsqRzmVEjU8NnXk634lbvHV/XLRxyTMl4IghCrQjj3fDihChrycLc8G7FrXlTnT0hDXabTZMD5SuEYZRbFqq8M72JWfVI6ISBxImsI3Fbm2iv57Hgk3IPlXvCHWIYTYZeQv25hhbk356p2R9f2SgqtIteAL0JTK+C0swkJzYsLpibre6Tb/+xdtc3eO/oWcwYk6xRlZdVcep5Jpg3RVTxfvC7g7H90yqNUTBqUKzhcQOecfYVAjRCDMXKBClFFXk94+hiY4tXuAzwbvDM71uWrM7Q09OSkZYYo14H8f5kRpJ4HszLyRvksvHwJY/S0yDjiSD6OEwBfEtRhVcejZlSZafLDSgWpHGek8cnDsWre0+pE6Jbcbcn+8pzF3yFYkKRd8ZyOPQSmY0qFWWIOU16hkeU3aopcWd5I/wkMjYlHodP1+Kr843o54hAWnuCr14itKIoXuEgqwU+dYHYOLAwjqIoSI53qKEYUYFdlJowQmxYzJBVq1XWNuHl3Sc1BrrT5cb6XScNk94ZGwpLpYruh0/XepX9M20x/h4cHBet2U9stF1XswgA4h0RiHVE6F4Pdpz8cYmClHwVoxEtTrd0PzPGJMNul/dGNDJsjYx0u9UCZ/uNbAHw0LgUjYyCKONwuKIWbgWa82CaVHyLH1loWvay0pMh44kg+jh6rUOi7VYcLK+RJsSKYRTe7b/92DkcKq/TGBl6TXP5Y/DVAyvYyHI46pvbsHbXN3Arbqz43ki8NS8HG/eUqQaJBYpuIrTVop2QZf3hAEi1gZjej9EkIjZh5kmOdxhWWhl5b8TrqUoylNVgQmailzfI3+sjM5RlEzjz3q3fJc/DMpIt+PMxb88MAHxdfVnze0bSdYiOtKvnreepKyq7JC3ZZ8y5LR1Wi9WrebPFYkFstB0/HJeMRZOGYvKLH0nX9xgUihpaE881zhGB1jaXRidJ1E3iE7JlY6yH2PyXhxlOqQkOpCTEaPKxNu0rV4+xuLxW85xgY6eXO6enc9VT85tkkPFEEH0cvQeWnlpytN2KBROH6Iph6nWPl5Wj88cgbmPtrm+8hAw7i55nyygPiWfLgdN4fOJQNfTINKo27inDAR0DJiczyaviKyXBASgKzta3GB4vr/djRnjzQkMzWrkW9zYuS1k0lMSQj1hFxlf3iRTraB35g8zboDeBn65tkirZA/Kkd0Zji9xLdH27B0nmkRHvQeapO1xRK+0DqUGxYNFkecJ9Y3MboFiwcU8ZLjbqX3cFFq/G0HwOokhUhM1Uk2lfyJr/ilgsFvV8ZAa4SFV9c7t3tMlrTPl7J1zym2SQ8UQQfQG7HfjZzzp+5vDVOkSkxenWJEObyc0B5OXo/DHItiEKGXYWvfCA2RYyDc1tyN9yRKrsLBJlt+Knd2aqb9Y8Z+uavdTR9WDbNmqQu+SeYVhx7wivhHpeSVocW36C5L03Zseiq94BmdfLbhuu9lDjG8XqSRsA3i1KeAM7NjpCmux8tq5ZN9QoTuRi4rMRJZV1ugn3CjwJ6Gd8JJqfrWtSNY30DBoWGucNKiYzoidqaxa97yAzw/nzeXVvKaIi5G2e2PHJDDExlB0u+U0yyHgiiL5AVBSwcaPmI/Z2e6i8BlaLvGko4NGsOX6mXvOWy+c7sfwYse3IhMxEnGtowcXGFnVdPde8UejAaLJm+Vp8c1KZkKJemEp8e+YnJxGZ3ILM8Gx1umG32WC3WZGVHu/19yofXidGxaUr+NGmIhzjZB+AjoRePrzJtH98JduLkxrvvTHTTgfounfAyNtgt1k1XjMRprB9urbJsFHwD8emSEPRAHC0sg7REVZVM4lX2gbkzZcBj5ECKFKjzFdvQUAbro13ROD6aLvGODxT14wNu09ixfdGqt9NMb+LJWRr709F8xP/fTEr6+Cr5ZIoZdLidKvf6Wi7FWNS49XWNXqGE+AxEEWDV6z6NSNn0BMg44kg+ihGIoKx0Xbckhynqv7mbzmi0XXSy3eS9aozIzPAHqKi58GXK1/M19LLrdKbsMXPmSEyt+Awjpyu0yTLyuQW9JLIWYjSrWeRmuBsfYup8J4vbwML8W3c4629Iwoy+vIg5g1JMvQOGFWTsfXcbgUpCQ40tjjRL8qGorJLOFReo4ZCxR57EzI9DYnZNjbsPqlRZlcAVUOK3XNL7hmmKt673Irm+rQ63arExNyCw6rqNatCBKAmPvM0NLchb0iSVy4SAJ+9BXnjwwIg//ZMHCqv8fKsbT92Diu+N9LLC5iWGIMZY5LhVtz4/JxWuqBfdAQam53S75dZWQfxe3zkdL2mMvPVvaeQkuDAuYYWtfcco8Xp1rSu4b/vImfqmnFGoqLP2LD7pFq1+0npJTXXsCdCxhNB9AUUBbjUPiH17w9YLIYencYWJ9yK5+EvGgcTuAlUfDv/4lwDDv3iHjUJF5C75vXeiO02q5qUbcaVrye2KaIXHpB9vnFPmaYHFwttyeQW2PHyBh/QEaJkb/KBQqzMA8wl2somYzHZ2kgkk1/eyBMghhgZ+7mfeWO3oblNNRBV4U+hx17ukETVG7OhsBSv7C3z2m9Ds1NjRPIeDafLjckvfiT1hhw/U69e6/3tIVGtcaTVOuJb04hjBMhazXiOoeWaE4fK67zap+wXxE4vNrZg/a6T0nJ/WBSpcGVaggMPZ6VKvy9mBSf15ApkYyKD5dKxytDczER8db4R10fbYbVYPIrliqIm3YvFAOy4xZZDzJjsiZDxRBB9gaYm4MYbPT9fuQJcd53PXCe9knyb1aImW58WJqTGFqeq2MyQJa/yb6ey6jpfORuysAbDlwCk7HO+1YgogtjYHoo02sZb83KwobAUm/aVaUKUIhMyE5E7JBElp+s1npmstAQUn7qEgxV1huctq8wDPJISRsjCk7JGvGLCsr/hE73QH5tcUxMcuuvqTe6s555eVaiv9VkLFJmXNSrCqrlefGgW8PR44706vHCrKCTKkOX2aSrTTtVg075yL/VwwOPFWbfrG6/my1lpCdhyoFx63mfrWzDerSArPR6HK2qxcU+HIcx7iYy8uHpeR9mYMHgZA6Ajz4l/pjS0a2xZ4HnpOsup6Mt6MIYTZDwRRB/A6XKrX/aNu0ux4P5b/NYtArxDdrKEXplis3gsvJ4S0FFdZ9ZNL3pSjNrJmMEoWZrJFfCJ2jJj4lBFrSYvDPBo77DwkSyMxW9j7U5F13iKjbYjzhGhXy5vMfIL+F/V1FldLSODvLK2Se2XJ4M/Lj2BTl9kpcdLP5fd6ykJDswYMxiv7ClT9yWGZvnrJ3pNRcOdlw4QDTm9JPk//CRXrXDk29ScrWvSSEK4FbdXrpXF4nEoV9Y2aYxK3hDR8xjLxocdp6gRxY+Jum8Ai+7uCI2errlqKOWgwLuh9EGhB+Oh8hrMGJOsOZcZY5J1t9ndkPFEEH2ATR+dwqL2nzfuKYXT4fE8yEJOaYkxSI53eOmzsKRy5m73KGh740uxWc9jBHgkAWQJ34B3exP+YX5LclyXyudlnpnG5jZNexNZgrKRwGhaYgyW3DNMPRe+tYks54N5WGTk35YJq9Wia+AZrQuEpqrJ6XLj2jWXodCj1eK5l/j7LcpuxY39olQtJKfLrYovshCX0+X2yrWRosiTzY3Cwb6U8MV7Uczp4duP8HlNvIEq5nE5XW5N4rTbrWiMhjN1zbBarOo9/dgbB71PVWc49DxwX55vRPZ/7VLV3fnQupHXkY0Jr22mwIIjpz2SHW/MzsKUtfvkB9OO6LUDgEde1z4/Ttc24X/mZMNqtaj7OnK6ViO/0JMg44kg+gBHuQ7n7OHKHpKipygtMQZb8sd7TTSa5NOyGo9mEYfNCoxPT1QVm/Uw8iA0NLfpShPoeYcCoQ8jhi2Yh0TWG46fnHyFkphSuN1m9Zl/YpSwXVJZhy354wHIvQPB8iSZwciA5GETKCtAOFZZh5b25O2z7caC3WbFxj1lXiEut+I25SEt4e5zWehRNgbiZ77GSS8EyvpDSg1UwTPIQnWql0jiOeTvD3/kRGQePADqtWG9GGVq74D8XvH87t1n8kB7Dz7RA52a4EBaYoyqbM+KAXjEosqzdc24d93HeGhcCrIzElRD1KgvYHdCxhNB9AHGcTkxstYI4t9kD1Bx0uAfmHwuD8vn0HtT9FXVZTapNS0xBmmJMQHxpPhKluY9cWZDSbzQJ1NbFttTyI7hUHkNTtc2acbX6XJjw+6TahjHTK/AQGKUA+XLgOQn0kPlNdJQMW9MyoxMIwFTRmcrzfw5V0A/BCr7zrBtvXngtHRfLBcsRaL9xYte6kl5iAntooAt0D7m5TVwcRFlX6F1I8TrI9vWv2WlGo51yzWnV74k0FE9mpoYYyrRvTsh44kg+gALJg5Rf140aRgWCK0RAI/2TP7tmboTsdHb77mGFvVN0ddExRsqWWkJmhYw/GQkTmJ8XzUmKxCot1E9gUNA3xMHyMdEnNB4Q4FJOWSlJcCtuPHo74qlb+diFRbf/sIfQyBQGBkivia2f8tKBeBbcFJPPmJ8RqKh8aRnRJutNBPvMz78JhvrBXdloqjsEo6fqUdUhBVOl0sVtxQxIzzq6f3ovYQoQ8GkPMRj5SvwWpxutbE0355HvJ9GDYrVDc/5KhIQr8+oQbFe97gvY35uwWFdAVQ2EkYvGj0BMp4Iog/APwQXTR4GtOvm8A/B/NszDSfkRZOGSkUsGZ15U7RaLdiSP17qRREn7KWTh2sSToPlbZFN3mwiarnmqSYs2F+OUYNi8btZ49QWKYBHXPBQea1u4rfNauG0cE5qJlW+7YUR3fEmbmSI6BnVotK6kQGRlhiDBXdlqmX6E9pz7JhBKeYE8bCk4veOnsV7R8+qQqlmk+R5vbNPSi8hzmE3vJc37StXDdkWpxsb9pTBbrNJvzuitzTeEYFZuel4s7gCjS0dBvZlnXYyvq714xM95f38d1JU5RfXj422Izs9XiPfIEoSiEr2vCEl5s+ZMbpEQ+3YmXrdcwLkifo9DTKeCKIvYLcDc+Z0/AxvD5Bbceu2uwD0S77zhiQhJzNBN1lWxGw4RZywSyrrupQUbhaj5GpeLLToVA1+8vsS5HKtUA5X1OkaTmK4T1YWvnl/OWZPSDMMa4b6TVxM1hb3z4wbXqYBABwRNthtnhYeYqiW16tiXsRXPyrTeFEmZCaqpfeP3z1ETSR2uRVU1TfDYrFgxtjBALT6R0wo1WySvGhc8F5D2Vib0RbTUwjPv92j78QbToBW6JLHTChS9p3cvL9cNfCzOY8t4OlTt2GPVitLJknAK9kXn/J0IRDHnj0nFtyVieJTNSjYX46iskvISovHX/9VDQDt1wgab16kXT/5Wyy06Kn0CONp48aNeP7551FdXY1bb70VGzZsQE5Oju7y27Ztw3/8x3+goqICw4cPx3PPPYf7779fuuzChQuxadMmrF27FsuXL/f6e2trK3Jzc/Hpp5/i2LFjGDNmTIDOiiB6EFFRwJYtmo/4UJWvSjAG34wW6GiHAgBWi1WtkuG7rwPQvHUeEkqU+eR1fqLzt7w+UBglV4v5HYcqtN3kZV65aLsVN8ZGa2QU9PK+GprbcLiiDsunjFDH0moBstMTpWrdoWDjnjLDkne7zYoV947wqgZkEg/vHT2LB787GLlcmx9mOPHim5Nf/EizX3mY0vu6yCrRPMaMuTGSh14j1JAUE7Q0Wl68N8VwnQVAcoID825Px8K3j3kdw9m6ZlVuQ2yNIuYvieX9/zMnG9tKzmjCYHxyuKIoWD5lhGGTYT1JAoYsWZ9X8+dfKvgQM1suTchhUtxyvTJmSPd0wwnoAcbTu+++i5UrV+K1115Dbm4u1q1bh6lTp+LEiRO4kYn6cRw4cACPPPII1qxZgwceeADvvPMOpk+fjqNHj+Lmm2/WLLt9+3YUFxdj8ODBuvv/+c9/jsGDB+PTTz8N+LkRRLigF5aRGTUr7h2BFfeO8NoGy6/gK/KKT9Wgqr5ZEx4QBQDF5HW9Fhc9wXUv5neYqZ5vcbpRWduE7cfOqR4RPjlcTOb9uvoyti7Ig8xQ4MU8Q9X7S/SqMJFUEeZ9OFxR6yWeuGGvtzI2IBfrFPEVutIzZsx6OGUaUMzAYNV+/HqyFwjx3hQ9iwo8BtL8t45iwpAkXcO5obkNVqtFV+tMvN/ciieMyBtONiuk95Ne4r1MQV+mni6DXRczCei8hMU1d8e+Z4xJ7rYXg67Q7ebdSy+9hPnz5yM/Px+jR4/Ga6+9hpiYGGzevFm6/Pr163Hfffdh1apVGDVqFH71q19h3LhxeOWVVzTLVVVVYcmSJXj77bcREREh3dY//vEPfPjhh3jhhRcCfl4E0aNQFODqVc8/SXLq+IxEtYGpKIS5btc3+KT0Etbu+gaz/ucQHnvjINbvOgkn94RmDT0L9pd7uf75B7ZnEvEIAN4xrD+WTxmBRZOG6ogIet5q//CTXLXlRihg58LOs+WaU/09Oy3B02vNoHmtHiwBeOOeMvXc3p4/ATkZSZrljHSyNuw+ibXc9dhgUOUWKPTuDRGmou00Y1FKtqUniGi0T7WhbYIDcY4IpCY4sOyeYdJ7qmB/udd9C3RoQK2YMgJ3DOuvNodm64mGG/O07X5iIh4al4KS0/XYuKdMs1294/3yXAOcTjdiHRG695DYooRHXMVq8T6+66O08x27n/jrCHgUwuMcdvzgloFwK2785PclAIA3ZmchJyMRqe2J+BMytevxMGV7X9puM8YkY/mUEYh3aI8tLTEGK+4doeaoecK0ZV7XqCfSrZ6na9euoaSkBKtXr1Y/s1qtmDJlCoqKiqTrFBUVYeXKlZrPpk6divfff1/93e12Y9asWVi1ahVuuukm6XYuXLiA+fPn4/3330dMjO/+U62trWhtbVV/b2zsfKknQYScpibg+us9P7e3Z+HR8/IY9bwCOt7kzVQVMUQBQMB/BexAw3vY+LduMZF2f+klLJ8yAnlD+3vlmUTbrbihX5RPpWWPuGiHJ6NgbjbytxxRRSFFnSz+2P5VVa/5Wyh6fxl5AI2ES3nFbRli+G/JPcMAwEsvykgZm29oawHwY67oQQyNytqmiOfAqjrN5O8Zebb0iiv6OSK8vHBMxsIMOZlJOFDWIZmR055vx393Hhufhr/86xyqG1owMC4arz46RpOIf7auCWfqmuF0K2hodmLjR6fU7ct62SmK0u4tVlBZ24yz9dz9bVHgdLmRnZaAL883orXNhVtT4pCdnqDJeVoyuSOHSdYkvLOyEt1JtxpPly5dgsvlwoABAzSfDxgwAF9//bV0nerqauny1dXV6u/PPfcc7HY7li5dKt2GoiiYO3cuFi5ciOzsbFRUVPg81jVr1uDZZ5/1uRxBhCN6eT5GPa/02k8AWhe9DPFt2UyIrrP91sygZ/yJibTsvLfkj/fqS9b/+kiv9SdkeiqL+J50p2ubNIn50ZF2XcFCo2Pzl86On91mbS+Rh6Z3GhO0lPWMA4AxqfGoqm9GY4sT/aJsaGxxahKlxfCf3WaF1WrxysnRCxMCxlWA7B4SW5+I957YzHhCZqLa0FkWkmPjyHtZxe3KiitS2vWuxBL96yJtmnGReeDYPg+euoTkBAcut7Rh9KA4LLgrUx0bXr6gqr2HXFVdMx5/+7hGo8yoWbUscfxMXTPO1jVj+ZQRsFprNcYT87q9srfD2Lxt2A1YNmU4Vn1/lNf2zbykdUc1aWfo9pynQFNSUoL169fj6NGjsFjkzsYNGzbg8uXLGo+XL1avXq3xeDU2NiI1NbXLx0sQPRmWx8I6pFdxjT35N3Ix78Roope9zYvGGwud6SqcB/jtVK+hrazfGZMuyM1M0hhPZ+tbNOumJDhQVd/s1cz3bPtkZPYc9I4N8K/3l1iSX3yqBm/NyzFlQOmNvWySk7X3kSUp8yKQTpcbcwsO42C59/aMvJBZ6fGa+y4rPd7LSJw1IU1TXTY2NU5zb/FJ2AA0mmNM9VxvLPTOhxmcADSJ/zIHU5wjAvPuGGL44iDbJ5+PxRu3vAdQAXCssk7zuxF6ieMs7DlqUKzmxYg1AzZr+Bi9pPHXsaLmKlquOTUtZHoa3Xpk/fv3h81mw4ULFzSfX7hwAQMHDpSuM3DgQMPlP/74Y1y8eBFpaWnq310uF5544gmsW7cOFRUV2L17N4qKihAVFaXZTnZ2Nh599FG8+eabXvuNioryWp4gejt8N/j65jZV5FF8yBtpQMU57Jg9IV23gkiGbLIO5tupnodtwpAkFMzNlupQ8a1AZOiJADLMnoM4saQkOJCeGCNteWGEuC9RD8jXurKxlyVrs5whvYk6ym5Bq1PRNIM+VF6nMUQZPgUXxV52isXr3snNFKUG6nCwvFb9O1/AoNkUOipBNxSWqgniiqJIw5OiqCUvUskbPrxMAwD8cFyy2t5l454yzNl8yKvK8s0Dp6XH99s9J7F5fzkURfGSP2CIodNBsVGob7qGpmsuxETaMCs3DXa71Uu9Xvw+1ze3oehUDfKGJKlFIOL3vbMh90WThmoqBs/WNRu2kOkJdKvxFBkZiaysLBQWFmL69OkAPPlKhYWFWLx4sXSdvLw8FBYWamQHdu7ciby8PADArFmzMGXKFM06U6dOxaxZs5Cfnw8AePnll/Ff//Vf6t/PnTuHqVOn4t1330VubvB1ZAgiXBC9HkzkkcG/5SfHO3BGyHsBgDhHJI5W1qsTggzRWyCTMwhmXpQsxAN4zjc60u5XSNMfKmubsPbDb7yqjZi3o+WaE0Vll2C3WtRE7Kq6Zjzso/2FDJmhI+ZfGa0rG3uxUo3/m54a/TWndsT+fLQK315u9VouNcGBnMwEaWWh2vakqEKzzqZ9ZbihX5Tm3vm6+rJmmSOntZ4YqwWq+KrYMzArLcGrcTaPBcCNsdGqESEziEXPlijTwMRBZS8fojK4SKtLQavEq8fkMRRF0eTgxTkiNDpkjS1O2G02rPietnqWVzMXvxPHKutwQz+tI8FsqyS90LHdZsUVwfjrSguZUNDtPrGVK1dizpw5yM7ORk5ODtatW4erV6+qhs7s2bORnJyMNWvWAACWLVuGiRMn4sUXX8S0adOwdetWHDlyBK+//joAICkpCUlJ2uqViIgIDBw4ECNHehIrea8UAFzfnkg7dOhQpKSkBPV8CSKc8GWwiOEE/q2UIb6hyhp9it4CmZxBMKUL+HCCLKFVBitZ//Oxs2peT0pCDGxWC9yKXBuHwbwPlbVNGuXsT0oveYyldgV4Ma8K6LzXTXy7B8xJLbB1Ae+xZ5VqstY1ep7ISMHzcr6hRVqhl5IQo9smRS901uJ0a4wFWfsQpyD4mZOZpG6XKciz5H2n2yW9jryxwLdzkd0zemPMZBr4Rru+iIu2Y/TgOHx5vkEj5inS4nTjTG1Te4J4M7dt771sP14llR7hvxN87pZsjH21SmJGE39PiNdUvE6+Kvi6m243nmbOnIlvv/0WTz31FKqrqzFmzBjs2LFDTQqvrKyE1doRc77tttvwzjvv4Je//CV+8YtfYPjw4Xj//fe9NJ4Igug6vgwWmWdq9xMTNRVY4gQqm/zFsBDvDeDfUINdgeOPgcYSnNnk1Njchoez09QQjOixSElw4EqL05M3YukwIkWYsfRJ6SVESZSYO+t1s9usSBcSlo0UF+ReAnnjW1kS+kPjUjRGQbTdirFpCRiXGqep8BINJ5vVgp9NHIKjlfW6YVqjPDDAU4Y/ON6BGWMH4/GJQzUijgxZL0c+TF18qgZfnm+Qbp83FpwuN6wWq+49IxtjX2rzMiwAfnzHENXgkiXqR9ksaHV5tqYA+OJcvdrqRs+gv9DQjEdeL9a0w9G0c9IJyfvTmFtm7CoADp66BKfL4+GyQEFKggONzdfQLzoCZ+uacNdv9qhCvD1NOLPbjScAWLx4sW6Ybu/evV6fPfzww3j44YdNb99XNV1GRgYUifYNQfQabDbg3/6t42eTGHWKZ2EO0UPkrVyufWjKJn/Rw8V7A0KJmcR1/iGulwuk55Fh667fdRJFZb5FCEXDIspuxc/uHtZpr5teqbsMMwn6vsr1AXidv9PlRmSEHa/uLfXKx7EAWDp5uGog8McqFigYhUydbgVnaptgtVgRHWmHTWLByHo5iteztU17fDarBYs5kVPAWJEe0I45oFVVN3MuDF6yYdGkoXA63XizuEKTu/SXT89rquEaW1woPlWjvojIaHUpHRIk7cK2Yk87WQsYI2+TURiep7KuWXMPWdrPkzfyeCXznkSPMJ4Igggy0dHAtm0B2ZQsVMc/bPkHZ1ZaApbeMwxHKurUnKeczCQ1z4NvLgr0LDVxwLcBYRTWNJpUfYW2GDYocHG/Z6XFd2kS8cezZiZB32gZvfNnn4vnHm234nHOMDQ6VrEvY/GpS149BRV4eryxajcevUR0MS/MLbxUL757mFd+kC/0jEjZ3/9V1SCtTAS0kg12mxV2u1VNEm9sceIvn2kNJ4YsZxDQ1+GSabktuCsTRWWXcPxMPaIirJg9Id3w3jEKw/NcbmnzuodkuU5mc/NCCRlPBEH4ha8kct7bxEQl356vrZoRlwF6piieLwNCNjGa0VNiBsSiSUM1lVyDYqM0RsC49ES1MsxjnCUZesJ84U/o00yCfleS+GeMHaxp6Ltg4hDNsRkdq7eHcJhXTg3gkUhgSdeikc+8YPy1YtIczIC41h4CS01wICUhBkdO12rkCAKBJrfow280OXAMMw2Kjao7XW7F6wXF6XJ5NQjm4e/3TfvK1fuw1emG3WYzPH+9MPzm/eUa43D0oDive0jMfQLM5+aFEjKeCILwC18TpszgMFNN11mCKZ4pvq2LWj6yCX7tzhOqUcASwP/wk1zpMbFWHyxhVzaZ8zIJbsVtqoFzV1HbniTGQFEUJMc7NM2e2bmIWkayZfRYMnm4Ya4QfyxGY8Lnw7EGwzJvnmjkA3LPoizEZ7FY1FwoWcGDEWb1ydiYxzkicLXVqQnZJid0jP+829Mx/62jOOZDKoOXROA1odh4vn9cvw0MoJ+XpQDYdqQSRWWX8HX1ZVUVn9dk0gvDL7gr00tN326zanoFZqfHo7LmCqoaWrlj6XnWExlPBNEXuHrVsD2LP/hq1+ESqplkTVpl1XSdJRjimWyCEVtaiFo+MsTeZMXltab1lGTGGP/7Y28cDJrWFQ/f9gSAWl0lGg68lhHLidlfVoNtJWdULSo9Y8esF0y8vmK7HPF4xER1oOMeMyuJIZNZ6Oy4m9Un27inTLeBMhNWPdA+tr40xABoKhr5/ZpVrOdzrMQxOVvfoorCFp2q8dJk0ntG6KnpW60WVeZkw54yxEZrTRNFt7te90HGE0EQfmE06W3cU6ZxubMH8NyCwz6r6TpLMMQzxSTWVB/NYn3x3tGzfnvEZB61UPUA1KsAM8p94uEneyNjx99jYTkxZkKpvLI3qyKTGfE8LLzFe0IevHUQDlfUqd4sf8fd7DUzc08pAKobtEr2vAaYHmaq+8QcKD7HykgEF/DOU2LPCHYPi1pdvhLKRcHPTvThDjpkPBEEETDECYA9gINZTRcMg0KcsAGY9pTNGJPslbdSWdtk2vvEkHnUgql1xWNUAaaX+6TnrfnyXINmLM0m/7IJlp+w9drliOscrqj18npt3AMvT9PZuiZMyExU5SFYeIsPpa7deUKjtZWbaW7cRe8lb8TJ0FNr51vdWAAMjIvWeJ6y0xOQN7S/l8gnoJXHmHd7OtbvOimVHHhoXIqXXlVWWoImv27G2MHq30X0NJn0vMJiq6CUBIdhP0yjqtDugowngiAChl6OUDCr6YJhUIgG2YwxybBaLab2seSeYQA8atf8m7y/3iqZR81uG274Rm+EP7lhetWAelVqotI4jzghmk3+FcNLvCK3rF2OuI4sxCd6ms7UNWt6oMo8WWIY9lxDi9/9AC3weFqNjGcmuso8XkzfiG2LnS/LefrqfCO+M7AfxmckSPPBeEOq+FQN5r91VGNY8ZIJzBvE56CJ+XVLJw/H8ikjvO6JlAQHCuZmS89JvIffO3pW1X/jOVvXrCb0u9yK5j7y2aKnmyDjiSCIgCFOumZyhLpKMMQz+YbIowbF4vG7h5huUsqSwK1Wi2m1coYvDS1GZ/K8/FmHT8D2ZXCxY7ZaPBOdBQrcClBV34zGFqdX6f2X5xt8Vqw5XW68d/SsxvBiitxGx+0rxGe1eLbDT94XGzvCYIEMhfobThaLB3jE82V5Q3zVKmv2zCoKRS8bPxaAdjzZ/o3y60oq6/CHn+R6GT8ZSdfpfjdkL1N6oT+W0B/MApBAQsYTQRABp5GbMIOZ2BwsRKVpVqmkh+yB78sjJlvHl4YWozN5Xp1Zx4xhKvOwANBNSm5odvo0qDcUlnpNsmIYSTapipO1mDSek5mEnEztsbUIvebE6ySGYWeMSdYZCS1G4WQ9A8Ffw0HMX+I1mkRtpeuj7WqPOjNGot7x+xMm578DouEU54hQDWt+O6HoJBAIyHgiCCIgyFqSMMQS/56Ov4aGnldHps7OdJ0amtvUyYOt40tDi9GZPK/OrGNmMtcbK6PonK8xZaErRpwjArAomjCS2614hVJFzycbX5lhJDa8ZZ4YUVX+8buHmA7Z8ojGMy8My4fUxFwg/j5i5ygmv/uSKxCLMsRQ2AQToTA9499MmJy/b8amxMPpcnt5+ObmZXRqXHsKZDwRRF/AZgPuv7/j5yAgVtoBHRU8oQjfBRJ/DQ1/ytFlIoh8mbyZ/XYmz6sz65gJ9YmJzi63gpzMBI0HSJb4LJMO0DOu4xwRKDmt7XW3/XiVWt7+SeklvHf0rGogiaElMURl1AQ6UNIXogdFrwEwf7+I9xF/jgyZXEGcw47Rg+I049tRYegxFHmqJErkvo7f1+c8/BiKSfA2K5CTkeRXKLwnEr5HThCEeaKjgb/9rUub8DXRyQyGG2Oj1Umsp4bvOhNyExHDRS63gsfeOKhZd0NhKTbtkys6s8nb7H47E9rozDpi3oysUk5MFi8+VYOcjESNFMWCuzLx6t5T6qQ9Y+xgqXQA87SIvUZnjB0Mq8WqMSzZMTF4Az0rLUEzaWelJXidm95YB0P6QtwuD29Iihpp7Bh4ZHIFFlikvRT1NJ06U/1pBvZdKthfrut5dLnNhcJ7OmQ8EQRhCjN93vgJK29IEnIyEzTlz8HSJeoKZkNuRvATLx+SYUm8VfXNuomyYtWT2WaroQiBipVxsko5u82qUeXmk4sZa3eewPrdpV7r+fK0yMJtfDWYWDrPjJ2s9HjtQVq8D1xvrAMpfaFXAMCTm+k5F1EZfYLw/eGxCdpOowbFas7HjBETDFV/swKcPfVFyh/IeCIIwhSysmNZqw7xTd5MC47uJBCeBn7i4quUAEhzwABPSHPBxCFYMnm436XvoeoHKIoTir+zSfR0zVXN56LxIpb7bz92Diu+N9LLUAG0xoVeuI3t22qxakrnmbEjXsOS0/UGZ6mls9IXZgsAvjrfqMm1OtfQIjWQvjrfiJyMRE1jbaZ0z9TDo+1WjE1L8JIKMGPEuNwKrjRfU2UPZG1W9NC7F0Xvml7zYbZ/p8sdFjmQMsh4Ioi+wNWrwI03en6+eFG3PYuRd0P0LImuf703+Z7umg+0yKaRwCTP43cP65LSdije3HMyk3CgTJtHw6M7SSu+JaH5/nmAJzQHwLSnUiankJWWALfi9hLW9OeadrbaS2ZQyAoA8m/P1ORaAfLk+vrmNry8+6SmsfZjbxxUW+UAQHZGorSgQNxvvCMCc/IycLC8RhX8LDpVg7G/2om2dtum6FQN5mw+hHcX3ubzXPXuRfG7xIftAW2FXfGpmqCEDkMFGU8E0VdokoeNeIy8G7IWDeHuegcCL7KpF8IDPJNHnCNCzfnxh6z0eG0ejxiaCgK+xkYvj6dEqAKTlfvz/fMs8HgoF00a6renkjd2PEnZHT359OQHgoFoULAKOYZeXpsYfuS9NaKRrCdCK4ZwRSMm//ZMLJsyHI+9cVBzzG2CU6ikst7Uueq9cBidmwVa40nvBYB0ngiCCDuMvBti09WemsPkL4HWleH7em0oLNUkSZsN0QHek4hbTDgy4d3pKr7GRuZlk1XSZaUlYNk9w1Byul6dEMV+h557rWtGjmjMNTS3YcFdmSGZfEWDwq1AKg8gjqlM2Zs3pngDyawIrahW7lbccLrcPr2iSvtffBkwvJHEvH3aAgmPN/BIRV273pQCBRacrTP2CLZcc2LK2n1qJWGowtOdgYwngiBUfIWwQtVbrTcg86z4M4mLXkC+OTHg7d3pDvxpwrt8yghNiEm817LSEjQ6YZ2ZOMXQckNzG/K3HFEVuYOJ+N3wVCZ2UFXfLG2nY7dZVUkBZowsvWcYth87JzWQWG6RryrWQ9wyLxeWqsZ2amKMRmOMJ7u9KtFXfp2et28/N/b8S9aEIUm6rWF48rcc0Ugw9OTEcjKeCIJQ8WUcySp6erp7vbvoao6SuD5gvjlxqOi4H4Zr7gdZE17x/EXvCJ+Po7eOESyHSqxo++p8Y2dOzW9EI8itQHMszBCSGSMyQ5NvI2MUvuPvBXYNxPC6rJKRtdKprGvG5ZY2jB4Upyaei9fuTyVndFXQ9a4z/9mxyjrDQgCG7Fr1hPtcBhlPBEGo+BPC6o7qr1DTFQOxq4reYm87f5oTdwfi/cC3B5Gdv91mhdVqUSd0mZSD2YnTSN1+1KDYgBv6Zkv1WXsdvjWJzCiUGdpG94/eS46vKjv+86r6Zux+YqJ0HMQI8Zm6ZjW52+x15sODYsWd3nUdNShWcw1TEhw97j5nkPFEEESn6I7qr1DTFQPRyIvn7+QbDp498X7g24PoGXt6CeeA59zNTpwydXt7+7gVzM0OuKFvtlSftdfh1cVlhqTMUDK6f/RecvTGk2murS/s0NoyEsoUJSnYtsV9+LrOhytqcbrmqqZCMNXAICqYm438LUc00gk99Z4n44kg+gJWKzBxYsfPASDQJf49ka4YiEZePH8n33BAvB9yMpN8GihiAnNKggNXWpw+J05Z6EhkyeQOodNAG/pmS/X1qtBE40H2984UMojjKeYWsTwq/jxk5GQmYX+Zdkz1GgPrXWf22SOvF2uMp5SEGN3rGh1p1yilb9pX3mNfGsh4Ioi+gMMB7N0b0E321uRxo9CZPwaiUajI38k3HOiMp43Pe2poblOThfn2Hb7EJ1noiEf0WgVTy8uMkeTLEPL1d7NhRz0jjCFWy2alJWiaIMuuCwCNtIa/33tfQqvi+ek1Te5pkPFEEESnCHSJf09BDJ1NyEzEufZeYqzku6uK4J3xUPT0BP3OeNrEvCcGb1D6Ep9koaMVQuhIr7Q+0Fpe/hhJZvGSqeDkC4wMCl/7l+kwsUo5sbnyintHYMW9I6TH4xlfc+fpS2gV0M/V6snpAGQ8EQRBcIihs3MNLerk/nJhKawWcxOkUaioM5NvOCXo+6rIKthfDsAzDrI8Hd6gNJNMnZ1u7EkKlGfH7Pa6Qss1J+556SNU1XsM9k9KLyE22h6QsKN43GIrIT3dKKN7zx9NKH9z33qy95WMJ4LoC1y9CmRkeH6uqNBtz0J4e4UA+D1xOV1uuLiSJXES6Mzk2xMT9M0kvosVWYCn9QibpH3l6ZhJpuY9KJ0xLMXjdbsVr8rGUHn58rccUQ0nRmOLU/05kAaFTDTTbDUgwx9NKKPj4PW5YqPtuDk5DrmZ5osGQg0ZTwTRV7h0yfcyhM8WE2YmLrH6a4IflWN69MR8qI17yrC23Qj6pPQSik/V4K15OboVWQX7y9WmuMwDNScvA0sF9XFfngsjD0pnDEvxeHlNpGB6+WTGp54uVVpiDNISYwKaXygqlgNyhXij3L9AGPWLJg3FtpIzas5bY4sTitJzPasAGU8EQRAafLXPMDNxiROIzWrpsueiJyboi+dZ1N7s1agii89tqW9uw/rdJzEhM1F3fMx6LrpiWAbC29gZZF4bUeuI8dC4lIAbE7LmyrKkfMBbNoMRCKPebrPiCuddA0InbtpZyHgiCIIwoKsl44HyEvXEBH0x3AJ4DI0t+ePVn/nJlv3/6t5SjXAiUxbvrJenq4ZlILyNnUHmtSmYm425BYdxrLIOsFhwY78o/HBcsulzMpu/5SsJ3KxsRqCMetFoHDUotlPbCRVkPBEEQQSYnuglCgaLJg1F8akaddJjhoaeocc+F9uHMDrr5eGbMW/cUybtIWdmfUZnvI2dQWZkR0fasXVBnsa4sVo63xNRL3/LV66S2ReAQBn1MoHMngwZTwRBEAGmJ3qJgoHdZtWIGpo1NGaMHaxRu+bxpyWLL/0noHN5M6G6fkZGdmfPxWz+lq9cpUC9AJj1hEVH2kPSwDlQkPFEEARBdJrOGBpLJg+H1WLVJJADnqRof1qyMOOCaRQB2lyl946e7XF6WDxGY9fZRGyz+Vu+PEuBMiDDSWLDH8h4Ioi+gNUKZGd3/OwnPV2gkQgv+ImZV7x+aFyK6ftKzMmRhQGN+rf1dDqbN7fgrkwUn6pRw1/Z6fF4ZU+Z3y1jAkVPlNgIBGQ8EURfwOEADh/u9Oq99e2R6F7MTOB6hrtMowgAouxWtHLJ6OE0WfPnmpWW4CXhYIZN+8rVHLSiUzVQFMVrO115GfJ33Z4osREIesSr48aNG5GRkYHo6Gjk5ubi0KFDhstv27YN3/nOdxAdHY1bbrkFf//733WXXbhwISwWC9atW6d+VlFRgXnz5iEzMxMOhwNDhw7F008/jWvXrgXqlAiiV9Fb3x67gtPlxvpdJ/HYGwexftdJOF1u3yv1QYzGiXmg/vCTXLVdiwgz3D8pvYR1u77Bxj1lADyG1/IpIxDniNAsf0O/KDVcFW6TNX+uL+8+CavFajg2MsTvZnF5rdd29MbU32M0sy67TncM64/lU0b0muKJbvc8vfvuu1i5ciVee+015ObmYt26dZg6dSpOnDiBG2+80Wv5AwcO4JFHHsGaNWvwwAMP4J133sH06dNx9OhR3HzzzZplt2/fjuLiYgwePFjz+ddffw23241NmzZh2LBh+PzzzzF//nxcvXoVL7zwQlDPlyDCkd769mgGsyraAHnjZHR1nHwa7orW95SW4MDDWalhWekYiJcUPfkIHrFdzqHyGgDmrol4jHyrHZmB11uLJ7rd8/TSSy9h/vz5yM/Px+jRo/Haa68hJiYGmzdvli6/fv163HfffVi1ahVGjRqFX/3qVxg3bhxeeeUVzXJVVVVYsmQJ3n77bUREaN9M7rvvPhQUFODee+/FkCFD8L/+1//Ck08+iT//+c9BO0+C6FaamjztWTIyPD/7SW99ezSD3ps2eePM0dVxGp+RKPUksevSIIgrnm1vbbIlf7xfHpuegN65+sOiSUORN0TbfNflVjSeP7cQ6xR/N3uMQEerHX+8V72BbvU8Xbt2DSUlJVi9erX6mdVqxZQpU1BUVCRdp6ioCCtXrtR8NnXqVLz//vvq7263G7NmzcKqVatw0003mTqWhoYGJCbq36itra1obW1Vf29s7NnqpwShQVGA06c7fvaTrrw9hnuyud7k35e8cV25hv6Mk2w/enlRYsJ4tN2KFqdbt7ltOBCIJG5RPsLlVlB8qkbj+bNatOuIv5s5RrHVTl97eehW4+nSpUtwuVwYMGCA5vMBAwbg66+/lq5TXV0tXb66ulr9/bnnnoPdbsfSpUtNHUdpaSk2bNhgGLJbs2YNnn32WVPbIwiig3APb+lN/n1FCBPo2jX0Z5z09iPbl3hdboyNVivuwnUyD1SIi9+OrO9fTmYSDpTVaNrndGbbfKVkb355kNHtOU+BpqSkBOvXr8fRo0dhsfg2p6uqqnDffffh4Ycfxvz583WXW716tcbj1djYiNTU1IAcM0H0ZsI9vCWWfi+4KxNA783lkNGVa+jPOOntx4xHyulyYQMXOspKjzd9jL0ZmfG/aNJQuN0Kth+vAgA4XS6s3XlCtzmzjL708iCjW42n/v37w2az4cKFC5rPL1y4gIEDB0rXGThwoOHyH3/8MS5evIi0tDT17y6XC0888QTWrVuHiooK9fNz585h0qRJuO222/D6668bHmtUVBSioqL8OT2CIBD+4a1N+8rVsEfxqRps2lfeZ4wmRrCvITOOeK0mWX6TkUdq7YffaLZ58FQtnC53jw4RhyKkLTNy7DYrrFaLqjzOG51mPYt96eVBRrcaT5GRkcjKykJhYSGmT58OwJOvVFhYiMWLF0vXycvLQ2FhIZYvX65+tnPnTuTl5QEAZs2ahSlTpmjWmTp1KmbNmoX8/Hz1s6qqKkyaNAlZWVkoKCiAtRPCgQRB+Cbc31DD3XMWCIJ9DXnjCPAojT80LkWa36R3DUoq6zS/F5fX9niBzFCEtPWMHDFnjNFX73F/6faw3cqVKzFnzhxkZ2cjJycH69atw9WrV1VDZ/bs2UhOTsaaNWsAAMuWLcPEiRPx4osvYtq0adi6dSuOHDmieo6SkpKQlKSN30ZERGDgwIEYOXIkAI/hdPfddyM9PR0vvPACvv32W3VZPY8XQRCdI9zfUMPdc9YZZB4RvWvYWe8Jv15luweEkZYY43eTWjMl+j2N7jTM9URG+8o93lW63XiaOXMmvv32Wzz11FOorq7GmDFjsGPHDjUpvLKyUuMVuu222/DOO+/gl7/8JX7xi19g+PDheP/99700nozYuXMnSktLUVpaipSUFM3flE5UIhFEj8diAUaP7viZME24e846gz8ekc56T0RvE0M2eZu5BosmDUXxqRpVXTscjIDuNMz5Mc1KSwAsit9q5n0Zi0LWQqdobGxEXFwcGhoaEBsb292HQxAEETAee+Ogxotzx7D++MNPcru8rNF6aYkxSEuM6VLuT7jJYoTb8fYWAjF/d7vniSAIguhZ+OMR6az3RFzvoXEpXQ7vhkuIWDSatuSPJ6MpzCDjiSAIgtDgT6iys2HNQIdDw8mLE+7aZwQZTwTRN2hqAsaP9/x8+DAQE9O9x0P0aPzx4MiWNWPIBNpLFE4GCVVwehNOxi9AxhNB9A0UBfjyy46fCSKIdIchE04GSV+s4PRFOBm/ABlPBEEEkXB7myQCQ3cYMllpCZoE9Ky0hKDvs7P0xQpOX4ST8QuQ8UQQRBAJt7dJIjB0i2fFohj/3oMIl8T2UBJu3jgyngiCCBrh9jZJBIbu8KyUnK43/J3o2YSbN46MJ4Iggka4vU0SgaE7PCt0r4U34eaNI+OJIIigEW5vk4GCcr1CT1+914jugYwngugLWCxAenrHzyEi3N4mAwXleoWevnqvEd0DGU8E0ReIiQEqKrr7KPoMlOtFEL0b8iMTBEEEmPEZiWD+Pcq/IYjeB3meCIIgAgzl3xBE74Y8TwTRF2hu9rRnGT/e8zNBEATRacjzRBB9AbcbOHKk42ciqFDCOEH0bsjzRBAEEWAoYZwgejdkPBEEQQQYShgneiJOlxvrd53EY28cxPpdJ+F0kRe6s1DYjiAIIsBQwjjRE6FwcuAg44kgCCLAkGAj0ROhcHLgoLAdQRAEQfQBKJwcOMjzRBB9hf79u/sICILoRiicHDjIeCKIvsB11wHfftvdR0EQRDdC4eTAQWE7giAIgiAIPyDjiSAIgiAIwg8obEcQfYHmZuD73/f8/I9/AA5H9x4PQbTjdLmxcU+ZJg/HbqP3eqJnQ8YTQfQF3G7go486fiaIHgJpDxHhCJn3BEEQRLdB2kNEOELGE0EQBNFtkPYQEY5Q2I4gCILoNkh7iAhHyHgiCIIgug3SHiLCEQrbEQRBEARB+AF5ngiirxAT091HQBAE0Ssg44kg+gLXXQdcvdrdR0EQBNEroLAdQRAEQRCEH/QI42njxo3IyMhAdHQ0cnNzcejQIcPlt23bhu985zuIjo7GLbfcgr///e+6yy5cuBAWiwXr1q3TfF5bW4tHH30UsbGxiI+Px7x583DlypVAnA5BEARBEL2Ybjee3n33XaxcuRJPP/00jh49iltvvRVTp07FxYsXpcsfOHAAjzzyCObNm4djx45h+vTpmD59Oj7//HOvZbdv347i4mIMHjzY62+PPvoovvjiC+zcuRMffPAB9u3bh5/+9KcBPz+C6BG0tADTpnn+tbR099EQBEGENRZFURTfiwWP3NxcjB8/Hq+88goAwO12IzU1FUuWLMG///u/ey0/c+ZMXL16FR988IH62YQJEzBmzBi89tpr6mdVVVXIzc3FP//5T0ybNg3Lly/H8uXLAQBfffUVRo8ejcOHDyM7OxsAsGPHDtx///04e/as1NgSaWxsRFxcHBoaGhAbG9uVISCI4HP1KnD99Z6fr1zx5EARBEH0QQIxf3er5+natWsoKSnBlClT1M+sViumTJmCoqIi6TpFRUWa5QFg6tSpmuXdbjdmzZqFVatW4aabbpJuIz4+XjWcAGDKlCmwWq04ePCgdL+tra1obGzU/CMIgiAIou/RrcbTpUuX4HK5MGDAAM3nAwYMQHV1tXSd6upqn8s/99xzsNvtWLp0qe42brzxRs1ndrsdiYmJuvtds2YN4uLi1H+pqak+z48gCIIgiN5Ht+c8BZqSkhKsX78eW7ZsgcVi8b2CSVavXo2Ghgb135kzZwK2bYIgCIIgwoduNZ769+8Pm82GCxcuaD6/cOECBg4cKF1n4MCBhst//PHHuHjxItLS0mC322G323H69Gk88cQTyMjIULchJqQ7nU7U1tbq7jcqKgqxsbGafwRBEARB9D261XiKjIxEVlYWCgsL1c/cbjcKCwuRl5cnXScvL0+zPADs3LlTXX7WrFn47LPPcPz4cfXf4MGDsWrVKvzzn/9Ut1FfX4+SkhJ1G7t374bb7UZubm6gT5MgCIIgiF5EtyuMr1y5EnPmzEF2djZycnKwbt06XL16Ffn5+QCA2bNnIzk5GWvWrAEALFu2DBMnTsSLL76IadOmYevWrThy5Ahef/11AEBSUhKSkpI0+4iIiMDAgQMxcuRIAMCoUaNw3333Yf78+XjttdfQ1taGxYsX40c/+pGpSjsAYEWKlDhOhAW8unhjI+Bydd+xEARBdCNs3u6S2IDSA9iwYYOSlpamREZGKjk5OUpxcbH6t4kTJypz5szRLP/HP/5RGTFihBIZGancdNNNyt/+9jfD7aenpytr167VfFZTU6M88sgjyvXXX6/ExsYq+fn5yuXLl00f85kzZxQA9I/+0T/6R//oH/0Lw39nzpwxPeeLdLvOU7jidrtx7tw59OvXDxaLBY2NjUhNTcWZM2coH8oHNFbmobEyD42VeWis/IPGyzzhMFaKouDy5csYPHgwrNbOZS91e9guXLFarUhJSfH6nJLJzUNjZR4aK/PQWJmHxso/aLzM09PHKi4urkvr9zqpAoIgCIIgiGBCxhNBEARBEIQfkPEUIKKiovD0008jKiqquw+lx0NjZR4aK/PQWJmHxso/aLzM01fGihLGCYIgCIIg/IA8TwRBEARBEH5AxhNBEARBEIQfkPFEEARBEAThB2Q8EQRBEARB+AEZT+2sWbMG48ePR79+/XDjjTdi+vTpOHHihGaZlpYWLFq0CElJSbj++uvx0EMP4cKFC5plKisrMW3aNMTExODGG2/EqlWr4HQ6Ncu8/fbbuPXWWxETE4NBgwbhxz/+MWpqaoJ+joEilGO1ceNGjBo1Cg6HAyNHjsTvf//7oJ9fIAnUWC1duhRZWVmIiorCmDFjpPv67LPPcOeddyI6Ohqpqan4zW9+E6zTChqhGq+WlhbMnTsXt9xyC+x2O6ZPnx7EswoOoRqrvXv34sEHH8SgQYNw3XXXYcyYMXj77beDeWoBJ1RjdeLECUyaNAkDBgxAdHQ0hgwZgl/+8pdoa2sL5ukFlFA+sxilpaXo168f4uPjA3w2wYOMp3Y++ugjLFq0CMXFxdi5cyfa2tpw77334irXUHXFihX461//im3btuGjjz7CuXPn8MMf/lD9u8vlwrRp03Dt2jUcOHAAb775JrZs2YKnnnpKXWb//v2YPXs25s2bhy+++ALbtm3DoUOHMH/+/JCeb1cI1Vi9+uqrWL16NZ555hl88cUXePbZZ7Fo0SL89a9/Den5doVAjBXjxz/+MWbOnCndT2NjI+69916kp6ejpKQEzz//PJ555hm1YXa4EKrxcrlccDgcWLp0KaZMmRK08wkmoRqrAwcO4Lvf/S7ee+89fPbZZ8jPz8fs2bPxwQcfBO3cAk2oxioiIgKzZ8/Ghx9+iBMnTmDdunX43e9+h6effjpo5xZoQjVWjLa2NjzyyCO48847A34uQaXTXfF6ORcvXlQAKB999JGiKIpSX1+vREREKNu2bVOX+eqrrxQASlFRkaIoivL3v/9dsVqtSnV1tbrMq6++qsTGxiqtra2KoijK888/rwwZMkSzr5dffllJTk4O9ikFjWCNVV5envLkk09q9rVy5Url9ttvD/YpBY3OjBXP008/rdx6661en//2t79VEhIS1LFTFEX5P//n/ygjR44M/EmEkGCNF8+cOXOUBx98MJCH3S2EYqwY999/v5Kfnx+Q4+4OQjlWK1asUO64446AHHd3EOyx+vnPf6489thjSkFBgRIXFxfoww8a5HnSoaGhAQCQmJgIACgpKUFbW5vmLfU73/kO0tLSUFRUBAAoKirCLbfcggEDBqjLTJ06FY2Njfjiiy8AAHl5eThz5gz+/ve/Q1EUXLhwAX/6059w//33h+rUAk6wxqq1tRXR0dGafTkcDhw6dCis3OA8nRkrMxQVFeGuu+5CZGSk+tnUqVNx4sQJ1NXVBejoQ0+wxqs3EsqxamhobN844QAACYlJREFUUPcTjoRqrEpLS7Fjxw5MnDixawfcjQRzrHbv3o1t27Zh48aNgTvgEEHGkwS3243ly5fj9ttvx8033wwAqK6uRmRkpFdMdsCAAaiurlaX4Y0B9nf2NwC4/fbb8fbbb2PmzJmIjIzEwIEDERcXF5Y3DxDcsZo6dSreeOMNlJSUQFEUHDlyBG+88Qba2tpw6dKlIJ9Z4OnsWJnBzHiGG8Ecr95GKMfqj3/8Iw4fPoz8/PyuHHK3EYqxuu222xAdHY3hw4fjzjvvxH/+538G4tBDTjDHqqamBnPnzsWWLVt6dANhPch4krBo0SJ8/vnn2Lp1a8C3/eWXX2LZsmV46qmnUFJSgh07dqCiogILFy4M+L5CQTDH6j/+4z/w/e9/HxMmTEBERAQefPBBzJkzBwBgtYbfrRvMseqN0HiZJ1RjtWfPHuTn5+N3v/sdbrrppqDuK1iEYqzeffddHD16FO+88w7+9re/4YUXXgjavoJJMMdq/vz5+N//+3/jrrvuCvi2Q0H4zUBBZvHixfjggw+wZ88epKSkqJ8PHDgQ165dQ319vWb5CxcuYODAgeoyYsUB+50ts2bNGtx+++1YtWoVvvvd72Lq1Kn47W9/i82bN+P8+fNBPLPAE+yxcjgc2Lx5M5qamlBRUYHKykpkZGSgX79+uOGGG4J4ZoGnK2NlBjPjGU4Ee7x6E6Eaq48++gg/+MEPsHbtWsyePburh90thGqsUlNTMXr0aDzyyCP47//+bzzzzDNwuVxdPfyQEuyx2r17N1544QXY7XbY7XbMmzcPDQ0NsNvt2Lx5c6BOI2iQ8dSOoihYvHgxtm/fjt27dyMzM1Pz96ysLERERKCwsFD97MSJE6isrEReXh4ATz7Tv/71L1y8eFFdZufOnYiNjcXo0aMBAE1NTV5eE5vNph5DOBCqsWJEREQgJSUFNpsNW7duxQMPPBA2nqdAjJUZ8vLysG/fPk0u2M6dOzFy5EgkJCR0/URCRKjGqzcQyrHau3cvpk2bhueeew4//elPA3L8oaQ77yu32422tja43e4ubSdUhGqsioqKcPz4cfXff/7nf6Jfv344fvw4ZsyYEbDzCRrdlane03j88ceVuLg4Ze/evcr58+fVf01NTeoyCxcuVNLS0pTdu3crR44cUfLy8pS8vDz1706nU7n55puVe++9Vzl+/LiyY8cO5YYbblBWr16tLlNQUKDY7Xblt7/9rVJWVqZ88sknSnZ2tpKTkxPS8+0KoRqrEydOKG+99ZbyzTffKAcPHlRmzpypJCYmKuXl5aE83S4RiLFSFEU5efKkcuzYMWXBggXKiBEjlGPHjinHjh1Tq+vq6+uVAQMGKLNmzVI+//xzZevWrUpMTIyyadOmkJ5vVwnVeCmKonzxxRfKsWPHlB/84AfK3XffrS4TLoRqrHbv3q3ExMQoq1ev1uynpqYmpOfbFUI1Vn/4wx+Ud999V/nyyy+VsrIy5d1331UGDx6sPProoyE9364Qyu8gT7hV25Hx1A4A6b+CggJ1mebmZuVnP/uZkpCQoMTExCgzZsxQzp8/r9lORUWF8v3vf19xOBxK//79lSeeeEJpa2vTLPPyyy8ro0ePVhwOhzJo0CDl0UcfVc6ePRuK0wwIoRqrL7/8UhkzZozicDiU2NhY5cEHH1S+/vrrUJ1mQAjUWE2cOFG6Hd6Q/PTTT5U77rhDiYqKUpKTk5X//u//DtFZBo5Qjld6erp0mXAhVGM1Z84c6d8nTpwYupPtIqEaq61btyrjxo1Trr/+euW6665TRo8erfz6179WmpubQ3i2XSOU30GecDOeLIoSJrEigiAIgiCIHkB4JI4QBEEQBEH0EMh4IgiCIAiC8AMyngiCIAiCIPyAjCeCIAiCIAg/IOOJIAiCIAjCD8h4IgiCIAiC8AMyngiCIAiCIPyAjCeCIAiCIAg/IOOJIIheydy5c2GxWGCxWBAREYEBAwbge9/7HjZv3uxXn7EtW7YgPj4+eAdKEETYQcYTQRC9lvvuuw/nz59HRUUF/vGPf2DSpElYtmwZHnjgATidzu4+PIIgwhQyngiC6LVERUVh4MCBSE5Oxrhx4/CLX/wCf/nLX/CPf/wDW7ZsAQC89NJLuOWWW3DdddchNTUVP/vZz3DlyhUAwN69e5Gfn4+GhgbVi/XMM88AAFpbW/Hkk08iOTkZ1113HXJzc7F3797uOVGCIEIKGU8EQfQpJk+ejFtvvRV//vOfAQBWqxUvv/wyvvjiC7z55pvYvXs3fv7znwMAbrvtNqxbtw6xsbE4f/48zp8/jyeffBIAsHjxYhQVFWHr1q347LPP8PDDD+O+++7DyZMnu+3cCIIIDdQYmCCIXsncuXNRX1+P999/3+tvP/rRj/DZZ5/hyy+/9Prbn/70JyxcuBCXLl0C4Ml5Wr58Oerr69VlKisrMWTIEFRWVmLw4MHq51OmTEFOTg5+/etfB/x8CILoOdi7+wAIgiBCjaIosFgsAIBdu3ZhzZo1+Prrr9HY2Ain04mWlhY0NTUhJiZGuv6//vUvuFwujBgxQvN5a2srkpKSgn78BEF0L2Q8EQTR5/jqq6+QmZmJiooKPPDAA3j88cfx//7f/0NiYiI++eQTzJs3D9euXdM1nq5cuQKbzYaSkhLYbDbN366//vpQnAJBEN0IGU8EQfQpdu/ejX/9619YsWIFSkpK4Ha78eKLL8Jq9aSA/vGPf9QsHxkZCZfLpfls7NixcLlcuHjxIu68886QHTtBED0DMp4Igui1tLa2orq6Gi6XCxcuXMCOHTuwZs0aPPDAA5g9ezY+//xztLW1YcOGDfjBD36A/fv347XXXtNsIyMjA1euXEFhYSFuvfVWxMTEYMSIEXj00Ucxe/ZsvPjiixg7diy+/fZbFBYW4rvf/S6mTZvWTWdMEEQooGo7giB6LTt27MCgQYOQkZGB++67D3v27MHLL7+Mv/zlL7DZbLj11lvx0ksv4bnnnsPNN9+Mt99+G2vWrNFs47bbbsPChQsxc+ZM3HDDDfjNb34DACgoKMDs2bPxxBNPYOTIkZg+fToOHz6MtLS07jhVgiBCCFXbEQRBEARB+AF5ngiCIAiCIPyAjCeCIAiCIAg/IOOJIAiCIAjCD8h4IgiCIAiC8AMyngiCIAiCIPyAjCeCIAiCIAg/IOOJIAiCIAjCD8h4IgiCIAiC8AMyngiCIAiCIPyAjCeCIAiCIAg/IOOJIAiCIAjCD8h4IgiCIAiC8IP/D4P99eS1OJxNAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Define the date range for zooming in\n", + "start_date = '2008-04-01' # Replace with actual start date\n", + "end_date = '2014-04-01' # Replace with actual end date\n", + "\n", + "# Filter the data within the date range\n", + "bsry_zoomed = bsry[(bsry['Date'] >= start_date) & (bsry['Date'] <= end_date)]\n", + "\n", + "# Filter the DataFrame for earthquake events within the date range (non-empty Event ID)\n", + "earthquake_events = bsry_zoomed.dropna(subset=['Event ID'])\n", + "\n", + "# Plot the zoomed-in data\n", + "plt.scatter(bsry_zoomed['Date'], bsry_zoomed['Delta N'], s=5, label='Delta N')\n", + "\n", + "# Plot vertical lines at earthquake event dates\n", + "for _, event in earthquake_events.iterrows():\n", + " plt.axvline(event['Date'], color='red', linestyle='--', label=f\"Event ID: {event['Event ID']}\")\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Delta N')\n", + "plt.title('Zoomed-in view of BSRY station data with Earthquake Events')\n", + "plt.legend(loc='best')\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define the date range for zooming in\n", + "start_date = '2008-04-01'\n", + "end_date = '2014-04-01'\n", + "\n", + "# Filter the data within the date range\n", + "bsry_zoomed = bsry[(bsry['Date'] >= start_date) & (bsry['Date'] <= end_date)]\n", + "\n", + "# Filter the DataFrame for earthquake events within the date range (non-empty Event ID)\n", + "earthquake_events = bsry_zoomed.dropna(subset=['Event ID'])\n", + "\n", + "# Plot the zoomed-in data\n", + "plt.scatter(bsry_zoomed['Date'], bsry_zoomed['Delta N'], s=5, label='Delta N')\n", + "\n", + "# Plot vertical lines at earthquake event dates\n", + "for _, event in earthquake_events.iterrows():\n", + " plt.axvline(event['Date'], color='red', linestyle='--', label=f\"Event ID: {event['Event ID']}\")\n", + "\n", + "# Fit a linear regression model to the pre-earthquake data\n", + "pre_eq_data = bsry_zoomed[bsry_zoomed['Date'] < earthquake_events.iloc[0]['Date']]\n", + "X_pre = np.array((pre_eq_data['Date'] - pre_eq_data['Date'].min()).dt.days).reshape(-1, 1)\n", + "y_pre = pre_eq_data['Delta N'].values\n", + "\n", + "model_pre = LinearRegression().fit(X_pre, y_pre)\n", + "y_pre_pred = model_pre.predict(X_pre)\n", + "\n", + "# Plot pre-earthquake best fit line\n", + "plt.plot(pre_eq_data['Date'], y_pre_pred, color='blue', label='Best Fit Line (Pre-EQ)')\n", + "\n", + "# Find a matching slope in the post-earthquake data with adjustable window lengths\n", + "post_eq_data = bsry_zoomed[bsry_zoomed['Date'] > earthquake_events.iloc[0]['Date']]\n", + "tolerance = 1e-8 # Lower slope tolerance to find a closer match\n", + "slope_pre = model_pre.coef_[0]\n", + "\n", + "# Initialize a variable to track whether a matching slope was found\n", + "matching_slope_found = False\n", + "\n", + "# Start by trying with a smaller window and increase the window size\n", + "min_window_size = 30 # Minimum window size to start with\n", + "max_window_size = len(post_eq_data) # Maximum window size (full dataset)\n", + "\n", + "# Iterate over possible start points in the post-earthquake data\n", + "for start_idx in range(0, len(post_eq_data), min_window_size): # Step by minimum window size\n", + " # Vary window size from min_window_size to max_window_size\n", + " for window_size in range(min_window_size, max_window_size - start_idx, 30):\n", + " window_data = post_eq_data.iloc[start_idx:start_idx + window_size]\n", + " if len(window_data) > 1:\n", + " X_post = np.array((window_data['Date'] - pre_eq_data['Date'].min()).dt.days).reshape(-1, 1)\n", + " y_post = window_data['Delta N'].values\n", + " model_post = LinearRegression().fit(X_post, y_post)\n", + "\n", + " slope_post = model_post.coef_[0]\n", + "\n", + " if np.abs(slope_pre - slope_post) <= tolerance:\n", + " # Once a match is found, extend the window and re-fit the model\n", + " extended_window_data = post_eq_data.iloc[start_idx:start_idx + window_size + 120] # Extend by 120 days\n", + " X_extended_post = np.array((extended_window_data['Date'] - pre_eq_data['Date'].min()).dt.days).reshape(-1, 1)\n", + " y_extended_post = extended_window_data['Delta N'].values\n", + " \n", + " # Re-fit the model on the extended data\n", + " extended_model_post = LinearRegression().fit(X_extended_post, y_extended_post)\n", + " y_extended_post_pred = extended_model_post.predict(X_extended_post)\n", + "\n", + " # Plot post-earthquake best fit line in orange, re-fitted on extended data\n", + " plt.plot(extended_window_data['Date'], y_extended_post_pred, color='orange', label='Best Fit Line (Post-EQ)')\n", + " matching_slope_found = True\n", + " break\n", + " if matching_slope_found:\n", + " break\n", + "\n", + "# If no matching slope was found, print a message\n", + "if not matching_slope_found:\n", + " print(\"No matching slope found within the specified tolerance.\")\n", + "\n", + "# Add labels, title, and legend\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Delta N')\n", + "plt.title('Best Fit Lines Before and After Earthquake')\n", + "plt.legend(loc='best')\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Initialize a list to store displacement data\n", + "displacement_data = []\n", + "\n", + "# Loop through each unique event ID to calculate displacements\n", + "for event_id in main_df['Event ID'].dropna().unique():\n", + " event_data = main_df[main_df['Event ID'] == event_id]\n", + " \n", + " # Ensure that we have data for the day before and after the event\n", + " if len(event_data) >= 2:\n", + " # Sort by date\n", + " event_data_sorted = event_data.sort_values('Date')\n", + " \n", + " # Get the data for the day before and the day after the event\n", + " day_before = event_data_sorted.iloc[0] # First row, before the earthquake\n", + " day_after = event_data_sorted.iloc[-1] # Last row, after the earthquake\n", + " \n", + " # Calculate the displacement for each delta component\n", + " delta_e_displacement = abs(day_after['Delta E'] - day_before['Delta E'])\n", + " delta_n_displacement = abs(day_after['Delta N'] - day_before['Delta N'])\n", + " delta_v_displacement = abs(day_after['Delta V'] - day_before['Delta V'])\n", + " \n", + " # Append displacement data along with the event magnitude\n", + " displacement_data.append([day_after['Event Magnitude'], delta_e_displacement, delta_n_displacement, delta_v_displacement])\n", + "\n", + "# Convert the displacement data into a DataFrame\n", + "displacement_df = pd.DataFrame(displacement_data, columns=['Magnitude', 'Delta E', 'Delta N', 'Delta V'])\n", + "\n", + "# Group by Magnitude and calculate mean displacement for each component\n", + "displacement_grouped = displacement_df.groupby('Magnitude').mean().reset_index()\n", + "\n", + "# Normalize the displacement values to a comparable scale\n", + "displacement_grouped[['Delta E', 'Delta N', 'Delta V']] = displacement_grouped[['Delta E', 'Delta N', 'Delta V']].apply(lambda x: x / x.max())\n", + "\n", + "# Plotting the scaled displacement bar graph for each magnitude\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "\n", + "# Set the positions for the bars\n", + "bar_width = 0.2\n", + "index = np.arange(len(displacement_grouped))\n", + "\n", + "# Plot bars for Delta E, Delta N, and Delta V\n", + "ax.bar(index, displacement_grouped['Delta E'], bar_width, label='Delta E')\n", + "ax.bar(index + bar_width, displacement_grouped['Delta N'], bar_width, label='Delta N')\n", + "ax.bar(index + 2 * bar_width, displacement_grouped['Delta V'], bar_width, label='Delta V')\n", + "\n", + "# Set labels and titles\n", + "ax.set_xlabel('Magnitude')\n", + "ax.set_ylabel('Normalized Displacement')\n", + "ax.set_title('Normalized Displacement by Magnitude for Delta E, Delta N, and Delta V')\n", + "ax.set_xticks(index + bar_width)\n", + "ax.set_xticklabels(displacement_grouped['Magnitude'].round(2))\n", + "ax.legend()\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [], + "source": [ + "def find_closest_non_nan(df, event_index, search_range=7):\n", + " closest_before = None\n", + " closest_after = None\n", + " \n", + " # Iterate backward to find the closest non-NaN values before the event\n", + " for i in range(event_index - 1, max(event_index - search_range, -1), -1):\n", + " if not pd.isna(df.loc[i, ['Delta E', 'Delta N']]).any():\n", + " closest_before = df.loc[i]\n", + " print(f\"Found closest_before at index {i} for event at index {event_index}\")\n", + " break\n", + " \n", + " # Iterate forward to find the closest non-NaN values after the event\n", + " for i in range(event_index + 1, min(event_index + search_range, len(df))):\n", + " if not pd.isna(df.loc[i, ['Delta E', 'Delta N']]).any():\n", + " closest_after = df.loc[i]\n", + " print(f\"Found closest_after at index {i} for event at index {event_index}\")\n", + " break\n", + " \n", + " if closest_before is None:\n", + " print(f\"No valid 'before' values found for event at index {event_index} within range\")\n", + " if closest_after is None:\n", + " print(f\"No valid 'after' values found for event at index {event_index} within range\")\n", + " \n", + " return closest_before, closest_after\n", + "\n", + "def calculate_displacements(main_df):\n", + " displacements = []\n", + " for idx, row in main_df[main_df['Event ID'].notna()].iterrows():\n", + " before, after = find_closest_non_nan(main_df, idx)\n", + " if before is not None and after is not None:\n", + " delta_e = after['Delta E'] - before['Delta E']\n", + " delta_n = after['Delta N'] - before['Delta N']\n", + " \n", + " # Calculate the Euclidean distance\n", + " displacement = np.sqrt(delta_e**2 + delta_n**2)\n", + " print(f\"Displacement calculated for event at index {idx}: {displacement}\")\n", + " \n", + " displacement_data = {\n", + " 'Station ID': row['Station ID'],\n", + " 'Event ID': row['Event ID'],\n", + " 'Event Magnitude': row['Event Magnitude'],\n", + " 'Distance from Epicenter': row['Distance from Epicenter'],\n", + " 'Event Date': row['Date'],\n", + " 'Delta E Change': delta_e,\n", + " 'Delta N Change': delta_n,\n", + " 'Displacement': displacement\n", + " }\n", + " displacements.append(displacement_data)\n", + " else:\n", + " print(f\"Skipping event at index {idx} due to missing before/after values\")\n", + "\n", + " # Convert to DataFrame for better readability\n", + " displacement_df = pd.DataFrame(displacements)\n", + " return displacement_df" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 125709 entries, 0 to 125708\n", + "Data columns (total 8 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Station ID 125709 non-null object \n", + " 1 Date 125709 non-null datetime64[ns]\n", + " 2 Delta E 125705 non-null float64 \n", + " 3 Delta N 125705 non-null float64 \n", + " 4 Delta V 125705 non-null float64 \n", + " 5 Event ID 60 non-null object \n", + " 6 Event Magnitude 60 non-null float64 \n", + " 7 Distance from Epicenter 60 non-null float64 \n", + "dtypes: datetime64[ns](1), float64(5), object(2)\n", + "memory usage: 7.7+ MB\n" + ] + } + ], + "source": [ + "def include_stations(df, station_ids):\n", + " \"\"\"\n", + " Includes only the rows from the dataframe for the specified station IDs.\n", + "\n", + " Parameters:\n", + " df (pd.DataFrame): The original dataframe to filter.\n", + " station_ids (list or array): The list or array of station IDs to include in the dataframe.\n", + "\n", + " Returns:\n", + " pd.DataFrame: A new dataframe including only the rows for the specified stations.\n", + " \"\"\"\n", + " filtered_df = df[df['Station ID'].isin(station_ids)]\n", + " return filtered_df\n", + "\n", + "# Example usage\n", + "rabbimin_sevmedikleri = ['PVEP', 'PVHS', 'TORP', 'PVRS', 'VTIS', 'CRHS', 'LBCH', 'LBC2', 'LBC1', 'CSDH', 'MHMS', 'HOLP', 'ELSC', 'NOPK', 'WRHS']\n", + "filtered_df = include_stations(main_df, rabbimin_sevmedikleri)\n", + "\n", + "# Displaying the filtered dataframe to ensure it works\n", + "# Reset index to ensure proper row indexing\n", + "filtered_df = filtered_df.reset_index(drop=True)\n", + "filtered_df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found closest_before at index 53 for event at index 54\n", + "Found closest_after at index 55 for event at index 54\n", + "Displacement calculated for event at index 54: 0.0043305192529303005\n", + "Found closest_before at index 3621 for event at index 3622\n", + "Found closest_after at index 3623 for event at index 3622\n", + "Displacement calculated for event at index 3622: 0.005438387720639303\n", + "Found closest_before at index 6994 for event at index 6995\n", + "Found closest_after at index 6996 for event at index 6995\n", + "Displacement calculated for event at index 6995: 0.001803780751643551\n", + "Found closest_before at index 6996 for event at index 6997\n", + "Found closest_after at index 6998 for event at index 6997\n", + "Displacement calculated for event at index 6997: 0.003360390453503899\n", + "Found closest_before at index 7948 for event at index 7949\n", + "Found closest_after at index 7950 for event at index 7949\n", + "Displacement calculated for event at index 7949: 0.004890685258600876\n", + "Found closest_before at index 11701 for event at index 11702\n", + "Found closest_after at index 11703 for event at index 11702\n", + "Displacement calculated for event at index 11702: 0.004432268033143747\n", + "Found closest_before at index 14963 for event at index 14964\n", + "Found closest_after at index 14965 for event at index 14964\n", + "Displacement calculated for event at index 14964: 0.004571389262611743\n", + "Found closest_before at index 14965 for event at index 14966\n", + "Found closest_after at index 14967 for event at index 14966\n", + "Displacement calculated for event at index 14966: 0.0015211838408795513\n", + "Found closest_before at index 16724 for event at index 16725\n", + "Found closest_after at index 16726 for event at index 16725\n", + "Displacement calculated for event at index 16725: 0.004222143931722535\n", + "Found closest_before at index 23018 for event at index 23019\n", + "Found closest_after at index 23020 for event at index 23019\n", + "Displacement calculated for event at index 23019: 0.004482822702284693\n", + "Found closest_before at index 23020 for event at index 23021\n", + "Found closest_after at index 23022 for event at index 23021\n", + "Displacement calculated for event at index 23021: 0.001990225812140069\n", + "Found closest_before at index 24308 for event at index 24309\n", + "Found closest_after at index 24310 for event at index 24309\n", + "Displacement calculated for event at index 24309: 12248.261125923595\n", + "Found closest_before at index 25920 for event at index 25921\n", + "Found closest_after at index 25922 for event at index 25921\n", + "Displacement calculated for event at index 25921: 0.0016521804335235932\n", + "Found closest_before at index 29716 for event at index 29717\n", + "Found closest_after at index 29718 for event at index 29717\n", + "Displacement calculated for event at index 29717: 0.0025653069860155915\n", + "Found closest_before at index 33913 for event at index 33914\n", + "Found closest_after at index 33916 for event at index 33914\n", + "Displacement calculated for event at index 33914: 12081.97696019784\n", + "Found closest_before at index 33913 for event at index 33915\n", + "Found closest_after at index 33916 for event at index 33915\n", + "Displacement calculated for event at index 33915: 12081.97696019784\n", + "Found closest_before at index 34272 for event at index 34273\n", + "Found closest_after at index 34274 for event at index 34273\n", + "Displacement calculated for event at index 34273: 0.007988216000356796\n", + "Found closest_before at index 38053 for event at index 38054\n", + "Found closest_after at index 38055 for event at index 38054\n", + "Displacement calculated for event at index 38054: 0.0024548930525134503\n", + "Found closest_before at index 41319 for event at index 41320\n", + "Found closest_after at index 41321 for event at index 41320\n", + "Displacement calculated for event at index 41320: 0.0038800002075731754\n", + "Found closest_before at index 41321 for event at index 41322\n", + "Found closest_after at index 41323 for event at index 41322\n", + "Displacement calculated for event at index 41322: 0.0006463745180472956\n", + "Found closest_before at index 43362 for event at index 43363\n", + "Found closest_after at index 43364 for event at index 43363\n", + "Displacement calculated for event at index 43363: 0.005844139799833677\n", + "Found closest_before at index 47172 for event at index 47173\n", + "Found closest_after at index 47174 for event at index 47173\n", + "Displacement calculated for event at index 47173: 0.0020939708689473075\n", + "Found closest_before at index 50511 for event at index 50512\n", + "Found closest_after at index 50513 for event at index 50512\n", + "Displacement calculated for event at index 50512: 0.004381253359485176\n", + "Found closest_before at index 50513 for event at index 50514\n", + "Found closest_after at index 50515 for event at index 50514\n", + "Displacement calculated for event at index 50514: 0.0009488988354929946\n", + "Found closest_before at index 57111 for event at index 57112\n", + "Found closest_after at index 57113 for event at index 57112\n", + "Displacement calculated for event at index 57112: 0.003053669787780388\n", + "Found closest_before at index 60356 for event at index 60357\n", + "Found closest_after at index 60358 for event at index 60357\n", + "Displacement calculated for event at index 60357: 0.004861367885524018\n", + "Found closest_before at index 60358 for event at index 60359\n", + "Found closest_after at index 60360 for event at index 60359\n", + "Displacement calculated for event at index 60359: 0.0019338045304920556\n", + "Found closest_before at index 62061 for event at index 62062\n", + "Found closest_after at index 62063 for event at index 62062\n", + "Displacement calculated for event at index 62062: 17198.23735285478\n", + "Found closest_before at index 62068 for event at index 62069\n", + "Found closest_after at index 62070 for event at index 62069\n", + "Displacement calculated for event at index 62069: 0.0071214392474771735\n", + "Found closest_before at index 65554 for event at index 65555\n", + "Found closest_after at index 65556 for event at index 65555\n", + "Displacement calculated for event at index 65555: 0.010441915526590606\n", + "Found closest_before at index 68919 for event at index 68920\n", + "Found closest_after at index 68921 for event at index 68920\n", + "Displacement calculated for event at index 68920: 0.006182919767860849\n", + "Found closest_before at index 68921 for event at index 68922\n", + "Found closest_after at index 68923 for event at index 68922\n", + "Displacement calculated for event at index 68922: 0.0008500587745611044\n", + "Found closest_before at index 70754 for event at index 70755\n", + "Found closest_after at index 70756 for event at index 70755\n", + "Displacement calculated for event at index 70755: 0.004472359445129574\n", + "Found closest_before at index 74243 for event at index 74244\n", + "Found closest_after at index 74245 for event at index 74244\n", + "Displacement calculated for event at index 74244: 0.003362171970060042\n", + "Found closest_before at index 77613 for event at index 77614\n", + "Found closest_after at index 77615 for event at index 77614\n", + "Displacement calculated for event at index 77614: 0.00402016204040991\n", + "Found closest_before at index 77615 for event at index 77616\n", + "Found closest_after at index 77617 for event at index 77616\n", + "Displacement calculated for event at index 77616: 0.002144411207331937\n", + "Found closest_before at index 79349 for event at index 79350\n", + "Found closest_after at index 79351 for event at index 79350\n", + "Displacement calculated for event at index 79350: 0.004251402709694766\n", + "Found closest_before at index 79350 for event at index 79351\n", + "Found closest_after at index 79352 for event at index 79351\n", + "Displacement calculated for event at index 79351: 0.0\n", + "Found closest_before at index 79351 for event at index 79352\n", + "Found closest_after at index 79353 for event at index 79352\n", + "Displacement calculated for event at index 79352: 0.005457029594935326\n", + "Found closest_before at index 81375 for event at index 81376\n", + "Found closest_after at index 81377 for event at index 81376\n", + "Displacement calculated for event at index 81376: 0.0034622156200906887\n", + "Found closest_before at index 81732 for event at index 81733\n", + "Found closest_after at index 81734 for event at index 81733\n", + "Displacement calculated for event at index 81733: 0.004195771749198977\n", + "Found closest_before at index 85539 for event at index 85540\n", + "Found closest_after at index 85541 for event at index 85540\n", + "Displacement calculated for event at index 85540: 0.00104076894934334\n", + "Found closest_before at index 88065 for event at index 88066\n", + "Found closest_after at index 88067 for event at index 88066\n", + "Displacement calculated for event at index 88066: 0.0049356054800336994\n", + "Found closest_before at index 88067 for event at index 88068\n", + "Found closest_after at index 88069 for event at index 88068\n", + "Displacement calculated for event at index 88068: 0.001436732527702292\n", + "Found closest_before at index 90019 for event at index 90020\n", + "Found closest_after at index 90021 for event at index 90020\n", + "Displacement calculated for event at index 90020: 0.004068082888687663\n", + "Found closest_before at index 93831 for event at index 93832\n", + "Found closest_after at index 93833 for event at index 93832\n", + "Displacement calculated for event at index 93832: 0.007532841508229113\n", + "Found closest_before at index 97209 for event at index 97210\n", + "Found closest_after at index 97211 for event at index 97210\n", + "Displacement calculated for event at index 97210: 0.003370949470615715\n", + "Found closest_before at index 97211 for event at index 97212\n", + "Found closest_after at index 97213 for event at index 97212\n", + "Displacement calculated for event at index 97212: 0.003499857335332858\n", + "Found closest_before at index 99811 for event at index 99812\n", + "Found closest_after at index 99813 for event at index 99812\n", + "Displacement calculated for event at index 99812: 0.003640013513317843\n", + "Found closest_before at index 103549 for event at index 103550\n", + "Found closest_after at index 103551 for event at index 103550\n", + "Displacement calculated for event at index 103550: 0.004587722733080425\n", + "Found closest_before at index 106881 for event at index 106882\n", + "Found closest_after at index 106883 for event at index 106882\n", + "Displacement calculated for event at index 106882: 0.004063409851261103\n", + "Found closest_before at index 106883 for event at index 106884\n", + "Found closest_after at index 106885 for event at index 106884\n", + "Displacement calculated for event at index 106884: 0.0013870830695401411\n", + "Found closest_before at index 108661 for event at index 108662\n", + "Found closest_after at index 108663 for event at index 108662\n", + "Displacement calculated for event at index 108662: 0.004382750576593622\n", + "Found closest_before at index 112457 for event at index 112458\n", + "Found closest_after at index 112459 for event at index 112458\n", + "Displacement calculated for event at index 112458: 0.002135275172803968\n", + "Found closest_before at index 115784 for event at index 115785\n", + "Found closest_after at index 115786 for event at index 115785\n", + "Displacement calculated for event at index 115785: 0.004455670759283663\n", + "Found closest_before at index 115786 for event at index 115787\n", + "Found closest_after at index 115788 for event at index 115787\n", + "Displacement calculated for event at index 115787: 0.0012868955609777388\n", + "Found closest_before at index 117442 for event at index 117443\n", + "Found closest_after at index 117444 for event at index 117443\n", + "Displacement calculated for event at index 117443: 0.004347528406191418\n", + "Found closest_before at index 120707 for event at index 120708\n", + "Found closest_after at index 120709 for event at index 120708\n", + "Displacement calculated for event at index 120708: 0.003119999999853462\n", + "Found closest_before at index 124070 for event at index 124071\n", + "Found closest_after at index 124072 for event at index 124071\n", + "Displacement calculated for event at index 124071: 0.004660686737954947\n", + "Found closest_before at index 124072 for event at index 124073\n", + "Found closest_after at index 124074 for event at index 124073\n", + "Displacement calculated for event at index 124073: 0.0009269841371126211\n" + ] + } + ], + "source": [ + "disp_df = calculate_displacements(filtered_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_displacement_vs_distance(df, magnitude_values):\n", + " plt.figure(figsize=(10, 6))\n", + " \n", + " # Loop over each magnitude value to plot\n", + " for magnitude in magnitude_values:\n", + " filtered_df = df[df['Event Magnitude'] == magnitude]\n", + " \n", + " if not filtered_df.empty:\n", + " plt.scatter(filtered_df['Distance from Epicenter'], \n", + " filtered_df['Displacement'], \n", + " label=f'Magnitude {magnitude}')\n", + " \n", + " plt.xlabel('Distance from Epicenter')\n", + " plt.ylabel('Displacement')\n", + " plt.title('Displacement vs Distance from Epicenter')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_displacement_vs_distance(disp_df[disp_df['Displacement'] < 2000], [6.4])" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 181, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(rabbimin_sevmedikleri)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "kickstart_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/intro.ipynb b/notebooks/intro.ipynb index d58e69a..91ce830 100644 --- a/notebooks/intro.ipynb +++ b/notebooks/intro.ipynb @@ -41,18 +41,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# read individual file\n", "sample = pre.read_tenv_file(pre.tenvs[0])\n", - "sample = pre.read_tenv_file('00NA')" + "sample = pre.read_tenv_file('HOLC')" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -86,43 +86,43 @@ " \n", " \n", " 0\n", - " 00NA\n", - " 08MAR27\n", - " -0.000000\n", + " HOLC\n", + " 94AUG13\n", + " 0.000000\n", " 0.000000\n", " 0.000000\n", " \n", " \n", " 1\n", - " 00NA\n", - " 08MAR28\n", - " 0.000717\n", - " 0.004027\n", - " 0.008450\n", + " HOLC\n", + " 94AUG14\n", + " 0.011992\n", + " -0.002505\n", + " -0.044683\n", " \n", " \n", " 2\n", - " 00NA\n", - " 08MAR29\n", - " -0.002996\n", - " 0.003628\n", - " 0.006840\n", + " HOLC\n", + " 94AUG15\n", + " 0.013895\n", + " -0.003906\n", + " -0.034812\n", " \n", " \n", " 3\n", - " 00NA\n", - " 08MAR30\n", - " -0.001808\n", - " 0.003665\n", - " 0.009446\n", + " HOLC\n", + " 94AUG17\n", + " 0.014954\n", + " -0.006623\n", + " -0.038863\n", " \n", " \n", " 4\n", - " 00NA\n", - " 08MAR31\n", - " 0.000027\n", - " 0.007322\n", - " 0.015839\n", + " HOLC\n", + " 94AUG18\n", + " 0.020008\n", + " -0.011624\n", + " -0.011132\n", " \n", " \n", " ...\n", @@ -133,68 +133,68 @@ " ...\n", " \n", " \n", - " 3185\n", - " 00NA\n", - " 18SEP21\n", - " 0.382259\n", - " 0.632339\n", - " 0.005029\n", + " 3609\n", + " HOLC\n", + " 05MAR18\n", + " -0.304294\n", + " 0.084482\n", + " 0.025487\n", " \n", " \n", - " 3186\n", - " 00NA\n", - " 18SEP22\n", - " 0.380626\n", - " 0.630517\n", - " 0.012494\n", + " 3610\n", + " HOLC\n", + " 05MAR19\n", + " -0.305943\n", + " 0.087587\n", + " 0.032082\n", " \n", " \n", - " 3187\n", - " 00NA\n", - " 18SEP23\n", - " 0.377591\n", - " 0.630658\n", - " 0.008150\n", + " 3611\n", + " HOLC\n", + " 05MAR20\n", + " -0.302598\n", + " 0.085605\n", + " 0.030015\n", " \n", " \n", - " 3188\n", - " 00NA\n", - " 18SEP24\n", - " 0.382457\n", - " 0.629258\n", - " -0.000452\n", + " 3612\n", + " HOLC\n", + " 05MAR21\n", + " -0.306308\n", + " 0.084874\n", + " 0.030289\n", " \n", " \n", - " 3189\n", - " 00NA\n", - " 18SEP25\n", - " 0.380070\n", - " 0.631905\n", - " 0.003815\n", + " 3613\n", + " HOLC\n", + " 05MAR22\n", + " -0.300774\n", + " 0.085387\n", + " 0.028945\n", " \n", " \n", "\n", - "

3190 rows × 5 columns

\n", + "

3614 rows × 5 columns

\n", "" ], "text/plain": [ " Station ID Date Delta E Delta N Delta V\n", - "0 00NA 08MAR27 -0.000000 0.000000 0.000000\n", - "1 00NA 08MAR28 0.000717 0.004027 0.008450\n", - "2 00NA 08MAR29 -0.002996 0.003628 0.006840\n", - "3 00NA 08MAR30 -0.001808 0.003665 0.009446\n", - "4 00NA 08MAR31 0.000027 0.007322 0.015839\n", + "0 HOLC 94AUG13 0.000000 0.000000 0.000000\n", + "1 HOLC 94AUG14 0.011992 -0.002505 -0.044683\n", + "2 HOLC 94AUG15 0.013895 -0.003906 -0.034812\n", + "3 HOLC 94AUG17 0.014954 -0.006623 -0.038863\n", + "4 HOLC 94AUG18 0.020008 -0.011624 -0.011132\n", "... ... ... ... ... ...\n", - "3185 00NA 18SEP21 0.382259 0.632339 0.005029\n", - "3186 00NA 18SEP22 0.380626 0.630517 0.012494\n", - "3187 00NA 18SEP23 0.377591 0.630658 0.008150\n", - "3188 00NA 18SEP24 0.382457 0.629258 -0.000452\n", - "3189 00NA 18SEP25 0.380070 0.631905 0.003815\n", + "3609 HOLC 05MAR18 -0.304294 0.084482 0.025487\n", + "3610 HOLC 05MAR19 -0.305943 0.087587 0.032082\n", + "3611 HOLC 05MAR20 -0.302598 0.085605 0.030015\n", + "3612 HOLC 05MAR21 -0.306308 0.084874 0.030289\n", + "3613 HOLC 05MAR22 -0.300774 0.085387 0.028945\n", "\n", - "[3190 rows x 5 columns]" + "[3614 rows x 5 columns]" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } diff --git a/preprocessing.py b/preprocessing.py index 2212872..99f83cd 100644 --- a/preprocessing.py +++ b/preprocessing.py @@ -65,7 +65,7 @@ def read_tenv_file(self, stat_name, target_cols=['Station ID', 'Date', 'Delta E' except Exception as e: print(f"An error occurred while reading {file_name}: {e}") - def load_tenv_file_df(self, tenvs, load_percentage=5): + def load_tenv_file_df(self, tenvs, load_percentage=20, point_thr=1000): '''Load the given percentage of the .tenv files according to the sorted file list. Args: @@ -82,14 +82,34 @@ def load_tenv_file_df(self, tenvs, load_percentage=5): if len(loaded_dfs) == 0: raise ValueError( "No time series data available for the given stations.") + filtered_tenvs = [df for df in loaded_dfs if len(df.index) >= point_thr] - combined_df = pd.concat(loaded_dfs, ignore_index=True) + combined_df = pd.concat(filtered_tenvs, ignore_index=True) + combined_df['Date'] = tenv_utils.strdate_to_datetime(combined_df['Date']) return combined_df + def load_station_info(self): + '''Load the station.txt file with the appropriate columns. + + Args: + None + + Returns: + stations (pd.DataFrame): Loaded dataframe from the station file. + ''' + station_file = 'llh.out.txt' # Adjust this to the correct filename + file_path = os.path.join(self.parent_path, station_file) + + cols = ['Station ID', 'Lat', 'Long', 'Hgt'] + stations = pd.read_csv(file_path, delim_whitespace=True, header=None, + index_col=False, names=cols) + + return stations + def load_eq_txt(self, target_cols=['Station ID', 'Date', 'Distance from Epicenter', 'Event Magnitude', 'Event ID']): '''Load the earthquakes.txt file with appropriate columns. - Args: + Args: target_cols (list, optional): The columns to be loaded from the EQ file. Defaults to ['Station ID', 'Date', 'Distance from Epicenter', 'Event Magnitude']. Returns: @@ -105,7 +125,7 @@ def load_eq_txt(self, target_cols=['Station ID', 'Date', 'Distance from Epicente eqs['Date'] = tenv_utils.strdate_to_datetime(eqs['Date']) return eqs - def load_combined_df(self, gap_tolerance=1000, load_percentage=5, target_magnitude=None, eq_count=None): + def load_combined_df(self, gap_tolerance=1000, load_percentage=5, target_magnitude=None, eq_count=None, save=False, method='lof', n_neighbors=20, contamination=0.35): '''Load and filter combined dataframe of .tenv files based on specified conditions. This function extracts .tenv files that have earthquakes, applies various filtering conditions, @@ -154,11 +174,39 @@ def load_combined_df(self, gap_tolerance=1000, load_percentage=5, target_magnitu eq_stats = eqs['Station ID'].unique() tenvs_df = self.load_tenv_file_df( tenvs=eq_stats, load_percentage=load_percentage) - - combined_df, _ = tenv_utils.apply_filtering( - tenvs_df, gap_tolerance=gap_tolerance) - combined_df = combined_df.merge(eqs[['Station ID', 'Date', 'Event Magnitude', 'Event ID']], - on=['Station ID', 'Date'], - how='left') - + #tenvs_df, _, _ = tenv_utils.apply_filtering(tenvs_df, gap_tolerance=100, method=method, n_neighbors=n_neighbors, contamination=contamination) + + + # append missing earthquake dates to the timeseries data with NaN values for the timeseries columns + all_stations_dfs = [] + for station_id, station_df in tenvs_df.groupby('Station ID'): + station_eqs = eqs[eqs['Station ID'] == station_id] + missing_dates = station_eqs[~station_eqs['Date'].isin(station_df['Date'])] + + if not missing_dates.empty: + missing_rows = pd.DataFrame({ + 'Station ID': station_id, + 'Date': missing_dates['Date'], + 'Delta E': np.nan, + 'Delta N': np.nan, + 'Delta V': np.nan + }) + station_df = pd.concat([station_df, missing_rows], ignore_index=True) + + all_stations_dfs.append(station_df) + + combined_tenvs_df = pd.concat(all_stations_dfs) + # combined_df, _, _ = tenv_utils.apply_filtering(tenvs_df, gap_tolerance=gap_tolerance) + combined_df = pd.merge(combined_tenvs_df, eqs[['Station ID', 'Date', 'Event ID', 'Event Magnitude', 'Distance from Epicenter']], on=['Station ID', 'Date'], how='left') + # sanity check + total_eqs = eqs['Event ID'].nunique() + loaded_eqs = combined_df['Event ID'].nunique() + print(f"\033[93mINFO: Loaded {loaded_eqs} of {total_eqs} earthquake events. \033[0m") + if save: + filename = f'loadp{load_percentage}' # @TODO: edit this so that it matches the called method arguments + # @TODO: gropby event id + filename = 'combined.csv' + filepath = os.path.join(self.parent_path, filename) + combined_df.to_csv(filepath, index=False) + print(f"\033[93mINFO: Successfully saved the combined dataframe to {filepath}. \033[0m") return combined_df diff --git a/static/style.css b/static/style.css new file mode 100644 index 0000000..4aacd6b --- /dev/null +++ b/static/style.css @@ -0,0 +1,3 @@ +body { + font-family: Arial, sans-serif; +} \ No newline at end of file diff --git a/templates/index.html b/templates/index.html new file mode 100644 index 0000000..f0bce0e --- /dev/null +++ b/templates/index.html @@ -0,0 +1,178 @@ + + + + + + Station Map with Multi-Station Selection + + + + + + +
+ + + + +
+ + +
+ +
+ + + +
+ + + + + \ No newline at end of file diff --git a/tenv_utils.py b/tenv_utils.py index 1e5eeb2..fb50bda 100644 --- a/tenv_utils.py +++ b/tenv_utils.py @@ -5,8 +5,11 @@ This module provides utility functions that are used to process .tenv files """ from datetime import datetime +import numpy as np import pandas as pd - +from sklearn.neighbors import LocalOutlierFactor +from sklearn.model_selection import RandomizedSearchCV +from sklearn.metrics import make_scorer def strdate_to_datetime(date_col): '''Convert the given date column of a dataframe to datetime format. @@ -72,7 +75,6 @@ def gap_filter(combined_df, gap_tolerance): filtered_df (pd.DataFrame): DataFrame of rows that aren't filtered out by the threshold. stations_with_gaps_df (pd.DataFrame): DataFrame of rows that are filtered out by the threshold. ''' - combined_df['Date'] = strdate_to_datetime(combined_df['Date']) filtered_list = [] stations_with_gaps = [] @@ -105,23 +107,78 @@ def gap_filter(combined_df, gap_tolerance): return filtered_df, stations_with_gaps_df -def apply_filtering(combined_df, gap_tolerance=120): + +def remove_outliers_lof(df, cols, n_neighbors=20, contamination=0.05): + """ + Remove outliers based on Local Outlier Factor (LOF). + + Args: + df (pd.DataFrame): The dataframe to be filtered. + cols (list): The list of columns to check for outliers. + n_neighbors (int): The number of neighbors to use for LOF. + contamination (float): The proportion of outliers in the data set. + + Returns: + pd.DataFrame: The dataframe with outliers removed. + dict: Dictionary with the count of outliers removed for each station and each column. + """ + outlier_counts = {} + + # To store the indexes of all outliers across columns and stations + all_outliers_indexes = pd.Index([]) + + for station_id, group in df.groupby('Station ID'): + combined_outliers = pd.Series(False, index=group.index) + + for col in cols: + lof = LocalOutlierFactor(n_neighbors=n_neighbors, contamination=contamination) + group[f'{col}_lof'] = lof.fit_predict(group[[col]]) + outliers = group[f'{col}_lof'] == -1 + combined_outliers = combined_outliers | outliers + + if station_id not in outlier_counts: + outlier_counts[station_id] = {} + outlier_counts[station_id][col] = outliers.sum() + + # Collect all outlier indexes to drop later + all_outliers_indexes = all_outliers_indexes.union(group[combined_outliers].index) + + # Drop all outliers at once + df = df.drop(all_outliers_indexes) + + # Drop the LOF columns if they exist + for col in cols: + if f'{col}_lof' in df.columns: + df = df.drop(columns=[f'{col}_lof']) + + return df, outlier_counts + + +def apply_filtering(combined_df, gap_tolerance=120, outlier_cols=['Delta E', 'Delta N', 'Delta V'], method='lof', + **kwargs): '''Outlier points are deleted, series containing huge gaps are eliminated. Args: combined_df (pd.DataFrame): Combined dataframe of all stations. gap_tolerance (int, optional): Amount of days to filter out a given station. Defaults to 120. + outlier_cols (list, optional): List of columns to check for outliers. Defaults to ['Delta E', 'Delta N', 'Delta V']. + method (str, optional): The outlier detection method to use. Defaults to 'lof'. + **kwargs: Additional parameters for the outlier detection method. Returns: - tuple: (filtered_df, stations_with_gaps_df) + tuple: (filtered_df, stations_with_gaps_df, outlier_counts) ''' + # Filter out stations with gaps exceeding the gap tolerance filtered_df, stations_with_gaps_df = gap_filter(combined_df, gap_tolerance) - if not combined_df.empty: - pass - # print(f'station: {self.get_station_name_by_index(0)} \n {combined_df.head()} \n') - # @TODO: outlier filtering - return filtered_df, stations_with_gaps_df + outlier_counts = {} + if not filtered_df.empty: + if method == 'lof': + filtered_df, outlier_counts = remove_outliers_lof(filtered_df, outlier_cols, **kwargs) + # Add other methods if needed + + return filtered_df, stations_with_gaps_df, outlier_counts + def split_combined_df_to_list(combined_df): """Split a combined dataframe into a list of dataframes, each corresponding to a unique station. @@ -136,4 +193,46 @@ def split_combined_df_to_list(combined_df): # Group the combined dataframe by 'Station ID' and convert each group to a separate dataframe station_dfs = [group for _, group in combined_df.groupby('Station ID')] - return station_dfs \ No newline at end of file + return station_dfs + +def custom_lof_scorer(lof_model, X): + """ + Custom scorer for LOF that returns the mean of negative outlier factors. + Args: + lof_model: An instance of a fitted LOF model. + X: Input features. + Returns: + score: Mean of the negative outlier factors. + """ + return lof_model.negative_outlier_factor_.mean() + +def manual_lof_optimization(df, cols, n_neighbors_range, contamination_range, search_type='grid'): + """ + Manually perform optimization for Local Outlier Factor (LOF) parameters. + Args: + df (pd.DataFrame): The dataframe to be filtered. + cols (list): The list of columns to check for outliers. + n_neighbors_range (list): List of values to test for `n_neighbors`. + contamination_range (list): List of values to test for `contamination`. + search_type (str): Type of search, 'grid' or 'random'. + Returns: + dict: The best parameters found for `n_neighbors` and `contamination`. + """ + X = df[cols].values + best_score = -np.inf + best_params = {} + + for n_neighbors in n_neighbors_range: + for contamination in contamination_range: + lof = LocalOutlierFactor(n_neighbors=n_neighbors, contamination=contamination) + lof.fit(X) + score = custom_lof_scorer(lof, X) + + if score > best_score: + best_score = score + best_params = {'n_neighbors': n_neighbors, 'contamination': contamination} + + print(f"n_neighbors={n_neighbors}, contamination={contamination}, score={score}") + + print(f"Best score: {best_score} with params: {best_params}") + return best_params