From e63f565227004e1a50e9fe83c57ba8e5516b3bf1 Mon Sep 17 00:00:00 2001 From: bsomps Date: Thu, 28 Dec 2023 20:26:55 -0700 Subject: [PATCH] Initial commit of project files --- ColumnSelectionDialog.py | 43 + OGP_v10.py | 5104 ++++++++++++++++++++++++++++++++++++++ OpenGeoUI2.py | 960 +++++++ Test_1_rc.py | 1865 ++++++++++++++ help_ogp.txt | 147 ++ pics.py | 2477 ++++++++++++++++++ requirements.txt | 11 + 7 files changed, 10607 insertions(+) create mode 100644 ColumnSelectionDialog.py create mode 100644 OGP_v10.py create mode 100644 OpenGeoUI2.py create mode 100644 Test_1_rc.py create mode 100644 help_ogp.txt create mode 100644 pics.py create mode 100644 requirements.txt diff --git a/ColumnSelectionDialog.py b/ColumnSelectionDialog.py new file mode 100644 index 0000000..71bd77b --- /dev/null +++ b/ColumnSelectionDialog.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'ColumnSelectionDialog.ui' +# +# Created by: PyQt5 UI code generator 5.15.9 +# +# WARNING: Any manual changes made to this file will be lost when pyuic5 is +# run again. Do not edit this file unless you know what you are doing. + + +from PyQt5 import QtCore, QtGui, QtWidgets + + +class Ui_ColumnSelectionDialog(object): + def setupUi(self, ColumnSelectionDialog): + ColumnSelectionDialog.setObjectName("ColumnSelectionDialog") + ColumnSelectionDialog.resize(568, 531) + ColumnSelectionDialog.setModal(True) + self.column_listWidget = QtWidgets.QListWidget(ColumnSelectionDialog) + self.column_listWidget.setGeometry(QtCore.QRect(120, 160, 256, 192)) + self.column_listWidget.setObjectName("column_listWidget") + self.plot_button = QtWidgets.QPushButton(ColumnSelectionDialog) + self.plot_button.setGeometry(QtCore.QRect(140, 80, 84, 25)) + self.plot_button.setCheckable(True) + self.plot_button.setObjectName("plot_button") + + self.retranslateUi(ColumnSelectionDialog) + QtCore.QMetaObject.connectSlotsByName(ColumnSelectionDialog) + + def retranslateUi(self, ColumnSelectionDialog): + _translate = QtCore.QCoreApplication.translate + ColumnSelectionDialog.setWindowTitle(_translate("ColumnSelectionDialog", "Dialog")) + self.plot_button.setText(_translate("ColumnSelectionDialog", "Plot")) + + +if __name__ == "__main__": + import sys + app = QtWidgets.QApplication(sys.argv) + ColumnSelectionDialog = QtWidgets.QDialog() + ui = Ui_ColumnSelectionDialog() + ui.setupUi(ColumnSelectionDialog) + ColumnSelectionDialog.show() + sys.exit(app.exec_()) diff --git a/OGP_v10.py b/OGP_v10.py new file mode 100644 index 0000000..49f6c56 --- /dev/null +++ b/OGP_v10.py @@ -0,0 +1,5104 @@ +from PyQt5 import QtWidgets +from PyQt5 import QtCore, QtWidgets +from PyQt5.QtWidgets import QVBoxLayout +from PyQt5.uic import loadUi +from PyQt5.QtWidgets import QMainWindow +from PyQt5.QtWidgets import QListWidget, QListWidgetItem +from PyQt5.QtWidgets import QApplication +from PyQt5.QtWidgets import QFileDialog +from PyQt5.QtGui import QStandardItemModel, QStandardItem, QFont, QColor +from PyQt5 import uic +import traceback +from matplotlib.widgets import SpanSelector +from collections import defaultdict +from matplotlib.patches import Rectangle +import json +from PyQt5.QtGui import QCursor +from PyQt5.QtCore import QSize +from PyQt5.QtGui import QColor, QPalette, QIntValidator +from PyQt5.QtCore import Qt +from PyQt5.QtCore import pyqtSignal +import copy +from PyQt5.QtCore import pyqtSlot +from PyQt5.QtWidgets import QSizePolicy +from PyQt5.QtWidgets import QMessageBox +from PyQt5.QtWidgets import QDialogButtonBox +from PyQt5.QtWidgets import QInputDialog +from mpl_toolkits.mplot3d import Axes3D +from matplotlib.text import Annotation +from PyQt5 import QtGui +from PyQt5.QtWidgets import QFrame +import math +import Test_1_rc +import OpenGeoUI2 +import pandas as pd +from matplotlib.ticker import FuncFormatter +import pickle +print(pd.__version__) +from sklearn.decomposition import FactorAnalysis +from sklearn.preprocessing import StandardScaler +from pandas import DataFrame +from ColumnSelectionDialog import Ui_ColumnSelectionDialog +import os +from functools import partial +from OpenGeoUI2 import Ui_MainWindow +import sys +import numpy as np +import seaborn as sns +import matplotlib.patches as mpatches +import factor_analyzer +from factor_analyzer import FactorAnalyzer +import matplotlib +matplotlib.use('Qt5Agg') +from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas +from matplotlib.path import Path +from matplotlib import patches +from matplotlib.figure import Figure +from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar +import matplotlib.pyplot as plt +from matplotlib.lines import Line2D +from matplotlib import colors as mcolors +from matplotlib.colors import LinearSegmentedColormap +import traceback +from matplotlib.cm import ScalarMappable +from matplotlib.colors import Normalize +import mplstereonet +from mplstereonet.stereonet_math import pole, plane +from mplstereonet.stereonet_axes import StereonetAxes +import numpy as np +from matplotlib.patches import Polygon +import rasterio +from rasterio.features import geometry_mask, geometry_window +from shapely.geometry import LineString +from scipy.interpolate import griddata +from sklearn.cluster import DBSCAN +from pykrige.ok import OrdinaryKriging +from scipy.interpolate import Rbf +from scipy.spatial import ConvexHull +from PyQt5.QtWidgets import QDialog, QVBoxLayout, QComboBox, QPushButton, QColorDialog, QLabel, QSpinBox, QListView, QScrollArea, QWidget, QDoubleSpinBox, QLineEdit, QGroupBox, QHBoxLayout, QGridLayout, QFileDialog, QTableView, QApplication, QSlider, QCheckBox, QTextEdit + + + + + + + +class ColumnSelectorDialog(QDialog): # Lithology parameters window + + plot_requested = pyqtSignal(dict) + + def __init__(self, df): + super().__init__() + + # Create a QVBoxLayout for the dialog + self.dialog_layout = QVBoxLayout(self) + + # Create a QScrollArea + self.scroll = QScrollArea(self) + self.dialog_layout.addWidget(self.scroll) + + # widget of the QScrollArea + self.scroll_content = QWidget(self.scroll) + self.scroll.setWidget(self.scroll_content) + self.scroll.setWidgetResizable(True) # Enable the scroll area to resize the widget + + # QVBoxLayout for the content of the QScrollArea + self.layout = QVBoxLayout(self.scroll_content) + + self.setWindowTitle("Column and Color Selector") + + # Select lithology column + self.layout.addWidget(QLabel("Lithology Column:")) + self.lithology_combo = QComboBox() + self.lithology_combo.addItems(df.columns) + self.layout.addWidget(self.lithology_combo) + + # Select from_depth column + self.layout.addWidget(QLabel("From Depth Column:")) + self.from_depth_combo = QComboBox() + self.from_depth_combo.addItems(df.columns) + self.layout.addWidget(self.from_depth_combo) + + # Select to_depth column + self.layout.addWidget(QLabel("To Depth Column:")) + self.to_depth_combo = QComboBox() + self.to_depth_combo.addItems(df.columns) + self.layout.addWidget(self.to_depth_combo) + + # Lithology column changed + self.lithology_combo.currentTextChanged.connect(self.lithology_column_changed) + self.from_depth_combo.currentTextChanged.connect(self.from_depth_column_changed) + self.to_depth_combo.currentTextChanged.connect(self.to_depth_column_changed) + + # Hold color variables + self.color_buttons = {} + self.length_spin_boxes = {} + self.df = df + + # Cancel or accept + self.buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self) + self.buttons.accepted.connect(self.accept) + self.buttons.rejected.connect(self.reject) + self.dialog_layout.addWidget(self.buttons) + + + self.setLayout(self.dialog_layout) # Set dialog_layout as the layout of the dialog + + def lithology_column_changed(self, text): + self.lithology_column = text + self.update_lithology_controls() + + def from_depth_column_changed(self, text): + self.from_depth_column = text + + def to_depth_column_changed(self, text): + self.to_depth_column = text + + def update_lithology_controls(self): + for widget in self.color_buttons.values(): + self.layout.removeWidget(widget) + widget.setParent(None) + + for widget in self.length_spin_boxes.values(): + self.layout.removeWidget(widget) + widget.setParent(None) + + self.color_buttons.clear() + self.length_spin_boxes.clear() + + # Reference to self.lithology_column + unique_values = self.df[self.lithology_column].unique() + for value in unique_values: + color_button = QPushButton(f"Choose color for {value}") + color_button.clicked.connect(lambda _, v=value: self.choose_color(v)) + self.layout.addWidget(color_button) + self.color_buttons[value] = color_button + + length_spin_box = QDoubleSpinBox() + length_spin_box.setRange(0, 0.5) # Adjust the range + length_spin_box.setSingleStep(0.1) # Allow for decimal point precision + self.layout.addWidget(QLabel(f"Choose length for {value}:")) + self.layout.addWidget(length_spin_box) + self.length_spin_boxes[value] = length_spin_box + + def choose_color(self, value): + color = QColorDialog.getColor() + if color.isValid(): + self.color_buttons[value].setText(f"{value} color: {color.name()}") + + def get_colors(self): + colors = {} + for value, button in self.color_buttons.items(): + if ":" in button.text(): + _, color = button.text().split(": ") + colors[value] = color + else: + colors[value] = 'white' + return colors + + def get_lengths(self): + return {value: spin_box.value() for value, spin_box in self.length_spin_boxes.items()} + + def get_parameters(self): + parameters = { + 'lithology_column': self.lithology_combo.currentText(), + 'from_column': self.from_depth_combo.currentText(), + 'to_column': self.to_depth_combo.currentText(), + 'colors': self.get_colors(), + 'lengths': self.get_lengths() + } + + return parameters or {} + + +class OrderDialog(QtWidgets.QDialog): # Change order for grpahic log window + def __init__(self, hole_ids, parent=None): + super().__init__(parent) + self.setWindowTitle("Change Order") + layout = QtWidgets.QVBoxLayout(self) + + self.comboboxes = [] + for _ in hole_ids: + combobox = QtWidgets.QComboBox(self) + combobox.addItems(hole_ids) + self.comboboxes.append(combobox) + layout.addWidget(combobox) + + button_box = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel, self) + button_box.accepted.connect(self.accept) + button_box.rejected.connect(self.reject) + layout.addWidget(button_box) + + self.setLayout(layout) + + def get_order(self): + return [combobox.currentText() for combobox in self.comboboxes] + + +class PlotWindow(QtWidgets.QMainWindow): # Graphic log plot window + def __init__(self, parent, data, hole_ids, parameters, initial_unit="ft"): + super().__init__() + + self.setWindowModality(QtCore.Qt.NonModal) + + self.data = data # Store lithology column + self.hole_ids = hole_ids # Store the list of hole IDs + self.parameters = parameters # Store the selected parameters + self.figure = Figure(figsize=(8, 12)) + self.canvas = FigureCanvas(self.figure) + self.setCentralWidget(self.canvas) + self.lith_depth_unit = initial_unit + self.main_window_reference = parent + + + self.save_button = QtWidgets.QPushButton(self) + self.save_button.setText("Save plot") + self.save_button.clicked.connect(self.save_plot) + + self.change_order_button = QtWidgets.QPushButton("Change Order", self) + self.change_order_button.clicked.connect(self.change_order) + + + # Set the layout + layout = QtWidgets.QVBoxLayout() + layout.addWidget(self.change_order_button) + layout.addWidget(self.save_button) + layout.addWidget(self.canvas) + widget = QtWidgets.QWidget() + widget.setLayout(layout) + self.setCentralWidget(widget) + + # Set the size + base_width = 500 + max_width = 2000 + required_width = base_width * len(hole_ids) + final_width = min(required_width, max_width) + self.resize(final_width, 1200) + self.create_graphic_log() + + + def updateLithDepthUnit(self, value): # Choose m of ft + + self.lith_depth_unit = "ft" if value == 0 else "m" # Meter to ft slider + + + def create_graphic_log(self): # Function to create graphic log + + # Clear Prevoius figure + self.figure.clear() + + # Compute the maximum depth across all selected hole_ids + max_depth = self.data[self.data['hole_id'].isin(self.hole_ids)][self.parameters['to_column']].max() + + num_holes = len(self.hole_ids) + + # Find hole_id and depth columns + for idx, hole_id in enumerate(self.hole_ids): + hole_data = self.data[self.data['hole_id'] == hole_id] + ax = self.figure.add_subplot(1, num_holes, idx+1) + + if len(self.hole_ids) == 1: + hole_min_depth = hole_data[self.parameters['from_column']].min() + ax.set_ylim(hole_data[self.parameters['to_column']].max(), hole_min_depth) + + else: + ax.set_ylim(max_depth, 0) + + + if idx == 0: + ax.set_ylabel(f'Depth ({self.lith_depth_unit})') # only label y-axis for the leftmost plot + + else: + ax.set_ylabel('') # remove y-axis tick labels for other plots + + self.figure.subplots_adjust(left=0.15, wspace=0.45) + + # Sore variables + previous_lithology = None + previous_end_depth = None + segment_start_depth = None + y_positions = [] # List to store y-coordinates of plotted labels + depth_range = hole_data[self.parameters['to_column']].max() - hole_data[self.parameters['from_column']].min() + label_buffer_percentage = 0.015 + label_buffer = depth_range * label_buffer_percentage + + # Find lith columns and colors + for _, row in hole_data.iterrows(): + lithology = row[self.parameters['lithology_column']] + from_depth = row[self.parameters['from_column']] + to_depth = row[self.parameters['to_column']] + color = self.parameters['colors'].get(lithology, 'white') + length = self.parameters['lengths'].get(lithology, 0.0) + + # Check if the lithology has changed + if lithology != previous_lithology: + # If the previous lithology is not None, draw the span for the previous sequence + if previous_lithology is not None: + ax.axhspan(previous_end_depth, segment_start_depth, xmin=0, xmax=prev_length, facecolor=color_prev, edgecolor='k', linewidth=0.5, alpha=0.7) + + y_center = (segment_start_depth + previous_end_depth) / 2 + if all(abs(y - y_center) > label_buffer for y in y_positions): + ax.text(0.45, y_center, previous_lithology, fontsize=8) + y_positions.append(y_center) + + # Reset segment_start_depth for the new lithology + segment_start_depth = from_depth + + color_prev = color # Store the color of the current row to be used in the next iteration + prev_length = length # Store the length of the current row to be used in the next iteration + previous_lithology = lithology + previous_end_depth = to_depth + + # Plot the last segment + if previous_lithology is not None: + ax.axhspan(previous_end_depth, segment_start_depth, xmin=0, xmax=prev_length, facecolor=color_prev, edgecolor='k', linewidth=0.5, alpha=0.7) + + y_center = (segment_start_depth + previous_end_depth) / 2 + if all(abs(y - y_center) > label_buffer for y in y_positions): + ax.text(0.45, y_center, previous_lithology, fontsize=8) + + + ax.set_xlim(0, 0.7) # Full range of X-axis + + + ax.set_xlabel('') + ax.set_xticks([]) + + if self.lith_depth_unit == "ft": + ax.annotate(f'{max_depth} ft', xy=(0, max_depth), xytext=(10, -10), textcoords='offset points') + else: + ax.annotate(f'{max_depth} m', xy=(0, max_depth), xytext=(10, -10), textcoords='offset points') + + ax.set_title(f"Hole ID: {hole_id}") + + self.figure.subplots_adjust(left=0.15) + self.canvas.draw() + self.show() + self.setWindowTitle("Graphic Log Generator") + + def change_order(self): + dialog = OrderDialog(self.hole_ids, self) + if dialog.exec_() == QtWidgets.QDialog.Accepted: + new_order = dialog.get_order() + if len(set(new_order)) != len(self.hole_ids): + # Ensure there are no duplicate selections + QtWidgets.QMessageBox.warning(self, "Invalid Order", "Please select distinct holes for each order position.") + return + self.hole_ids = new_order + self.create_graphic_log() + + def save_plot(self): + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + file_name, _ = QFileDialog.getSaveFileName(self,"Save Plot","","All Files (*);;JPEG (*.jpeg);;PNG (*.png)", options=options) + if file_name: + self.figure.savefig(file_name, dpi=200) + + def closeEvent(self, event): + if self in self.main_window_reference.plot_windows: + self.main_window_reference.plot_windows.remove(self) + event.accept() # window close + + + +class DownholePlotWindow(QtWidgets.QMainWindow): # Plot window for downhole geochem + def __init__(self, main_window, data, hole_id, column_data, column_name, depth_column, plot_bars=False): + super().__init__() + + self.setWindowModality(QtCore.Qt.NonModal) + + # Store viariables + self.data = data + self.hole_id = hole_id + self.column_data = column_data + self.column_name = column_name + self.main_window = main_window + self.plot_bars = plot_bars + self.figure = Figure(figsize=(8, 12)) + self.canvas = FigureCanvas(self.figure) + self.setCentralWidget(self.canvas) + + self.save_button = QtWidgets.QPushButton(self) + self.save_button.setText("Save plot") + self.save_button.clicked.connect(self.save_plot) + self.depth_column = depth_column # Save depth column + self.geochem_depth_unit = "ft" # Default to feet + + # Set the layout + layout = QtWidgets.QVBoxLayout() + layout.addWidget(self.save_button) + layout.addWidget(self.canvas) + widget = QtWidgets.QWidget() + widget.setLayout(layout) + self.setCentralWidget(widget) + + self.resize(400, 1100) + self.setGeometry(0, 0, 400, 1100) + self.plot() + + def updategeochemDepthUnit(self, value): + self.geochem_depth_unit = "ft" if value == 0 else "m" + self.update_labels() + + def closeEvent(self, event): + # Disconnect the signal for updating y-axis label + self.main_window.geochem_ft_m.valueChanged.disconnect(self.updategeochemDepthUnit) + + # Construct the key for this window + window_key = f"{self.hole_id}_{self.column_name}" + + # Remove the reference of this window from the geochem_plot_windows dictionary + if window_key in self.main_window.geochem_plot_windows: + del self.main_window.geochem_plot_windows[window_key] + + event.accept() # let the window close + + + def plot(self): + self.plot_data() + self.update_labels() + self.canvas.draw() + self.show() + + def plot_data(self): + + # Create a mask where the column_data is not zero + mask = self.column_data != 0 + + # Use the mask to filter the x data + y = self.data[self.depth_column] + x = self.column_data[mask] + y = y[mask] # Ensures y-values correspond to the filtered x-values + + self.ax = self.figure.add_subplot(111) + + if self.plot_bars: + width = 3 # Adjust as necessary + self.ax.barh(y, x, align='center', height=width, color='gray') # Using horizontal bars + else: + self.ax.plot(x, y) + self.ax.invert_yaxis() # To display depth with min at the top and max at the bottom + + # Set the y-axis limits based on the minimum and maximum depth values in the data + self.ax.set_ylim(y.max(), y.min()) # Use the actual depth data + + # Set the x-axis limits based on the minimum and maximum values in the data + upper_limit = x.max() + 0.10 * x.max() + self.ax.set_xlim(0, upper_limit) + + + self.setWindowTitle(f"Hole: {self.hole_id} - {self.column_name}") # Updated + + # make the plot fit the pop up window + self.figure.subplots_adjust(left=0.18) + + + + def update_labels(self): + self.ax.set_xlabel(self.column_name) + self.ax.set_ylabel(f'Depth ({self.geochem_depth_unit})') + self.ax.set_title(f"Hole ID: {self.hole_id}") + + + def save_plot(self): + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + file_name, _ = QFileDialog.getSaveFileName(self,"Save Plot","","All Files (*);;JPEG (*.jpeg);;PNG (*.png)", options=options) + if file_name: + self.figure.savefig(file_name) + + +class CorrelationMatrixWindow(QtWidgets.QMainWindow): # window for correlation matrix + def __init__(self, data, hole_id, tag='_ppm', parent=None): + super(CorrelationMatrixWindow, self).__init__(parent) + + # Create the matplotlib Figure and FigCanvas objects. + self.hole_id = hole_id + self.fig, self.ax = plt.subplots(figsize=(9, 12)) + self.canvas = FigureCanvas(self.fig) + + + # add save button + self.save_button = QtWidgets.QPushButton(self) + self.save_button.setText("Save plot") + + # Adjust the button size and position + self.save_button.resize(100,30) # Size of button + self.save_button.move(20,20) + + self.save_button.clicked.connect(self.save_plot) + + # Set the layout + layout = QtWidgets.QVBoxLayout() + + # Create and add the toolbar + self.toolbar = NavigationToolbar(self.canvas, self) + layout.addWidget(self.toolbar) + + + layout.addWidget(self.save_button) + layout.addWidget(self.canvas) + widget = QtWidgets.QWidget() + widget.setLayout(layout) + self.setCentralWidget(widget) + + + # Compute and draw the correlation matrix + self.draw_correlation_matrix(data, tag) + self.ax.set_title(f"Correlation Matrix - {self.hole_id}") + + def draw_correlation_matrix(self, data, tag): + # Select columns with the specified tag in their names + selected_columns = [col for col in data.columns if tag in col] + data_selected = data[selected_columns] + + # Compute the correlation matrix + corr_matrix = data_selected.corr() + + # Generate a mask for the upper triangle + mask = np.triu(np.ones_like(corr_matrix, dtype=bool)) + + # Generate a custom diverging colormap + cmap = sns.diverging_palette(230, 20, as_cmap=True) + + # Draw the heatmap with the mask and correct aspect ratio, without annotations + sns.heatmap(corr_matrix, mask=mask, cmap=cmap, vmax=1, vmin=-1, center=0, + square=True, linewidths=.5, cbar_kws={"shrink": .5}, ax=self.ax) + + self.canvas.draw() + self.show() # Show the window + + def save_plot(self): + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + file_name, _ = QFileDialog.getSaveFileName(self,"Save Plot","","All Files (*);;JPEG (*.jpeg);;PNG (*.png)", options=options) + if file_name: + self.fig.savefig(file_name) + + + +class ColumnSelectionDialog(QtWidgets.QDialog, Ui_ColumnSelectionDialog): # Window for downhole plot selection + def __init__(self, parent=None): + super(ColumnSelectionDialog, self).__init__(parent) + self.setupUi(self) + + self.plot_button.clicked.connect(self.accept) + + # Initialize depth column combo box + self.depth_column_combo = QtWidgets.QComboBox(self) + + # Initialize QLabel for depth column + self.depth_column_label = QLabel("Select Depth Column") + + # Initialize QLabel for attributes + self.attributes_label = QLabel("Select Attributes to Plot") + + # Initialize checkbox for bar plot + self.plot_bars_checkbox = QtWidgets.QCheckBox("Plot using bars", self) + + # Layout to organize widgets + layout = QVBoxLayout(self) + + # Add QLabel and QComboBox to layout + layout.addWidget(self.depth_column_label) + layout.addWidget(self.depth_column_combo) + + # Add QLabel and QListWidget to layout + layout.addWidget(self.attributes_label) + layout.addWidget(self.plot_bars_checkbox) + layout.addWidget(self.column_listWidget) + + + # Add the plot button + layout.addWidget(self.plot_button) + + # Set layout + self.setLayout(layout) + + def load_columns(self, columns): + for column in columns: + item = QListWidgetItem(column) + item.setCheckState(Qt.Unchecked) + self.column_listWidget.addItem(item) + + def load_depth_columns(self, depth_columns): + self.depth_column_combo.addItems(depth_columns) + + + + +class CrossSection(QDialog): # Cross section window + MAX_BAR_LENGTH = 50 # for auxiliary bar plot + def __init__(self, data, hole_ids, azimuth, attribute_column=None, attributes_model=None, attributes_dict=None, DEM_data=None, remove_outliers=True, remove_outliers_auxiliary=True, checkbox_add_grid_lines=True, upper_quantile=75.0, lower_quantile=25.0, IQR=3.0, x_buffer=120.0, y_buffer=0.05, line_width=4, selected_hole_ids_for_labels=None): + super().__init__() + print(selected_hole_ids_for_labels) + + # Storing the data, hole_ids, and azimuth as instance variables + self.data = data + self.hole_ids = hole_ids + self.azimuth = azimuth + self.attribute_column = attribute_column + self.attributes_dict = attributes_dict or {} + self.categorical_encodings = {} + manage_attributes_dialog = ManageAttributesDialog(data) + self.drag_region = None + self.is_plan_view = False + self.generate_contours_flag = False + self.canvases = [] + self.DEM_data = DEM_data + if DEM_data is not None: + self.DEM_loaded = True + else: + self.DEM_loaded = False + + + self.overlay_image_state = { + 'x': None, + 'y': None, + 'width': None, + 'height': None, + } + + self.remove_outliers = remove_outliers + self.upper_quantile = upper_quantile + self.lower_quantile = lower_quantile + self.IQR = IQR + self.x_buffer = x_buffer + self.y_buffer = y_buffer + self.line_width = line_width + self.selected_hole_ids_for_labels = selected_hole_ids_for_labels + print("CrossSection - selected_hole_ids_for_labels:", self.selected_hole_ids_for_labels) + self.filtered_bar_data = self.data + self.remove_outliers_auxiliary = remove_outliers_auxiliary + self.bar_vmin = None + self.bar_vmax = None + self.checkbox_add_grid_lines = checkbox_add_grid_lines + self.attributes_model = attributes_model + self.setup_attribute_list_view() + self.attributes_model.itemChanged.connect(self.on_attribute_selection_changed) + self.pencil_mode = False + self.sky_color = 'lightsteelblue' + self.remove_topo_and_sky = False + self.currently_drawing = False + self.drawing_lines = [] + self.current_overlay_image_display = None + self.overlay_image = None + self.overlay_image_state = {'x': 0, 'y': 0, 'width': 0, 'height': 0} + self.use_user_defined_grid = False + self.filtered_grid_points = None + + + + # Set up the main vertical layout for the QDialog + main_layout = QVBoxLayout(self) + + # Create a Figure that will hold the plot + self.figure = Figure(figsize=(10, 15)) + + # Create a FigureCanvasQTAgg widget that will hold the Figure + self.canvas = FigureCanvas(self.figure) + + # Connect press events and click events + self.cid_key = self.canvas.mpl_connect('key_press_event', self.on_key_press) + self.cid_press = self.canvas.mpl_connect('button_press_event', self.on_mouse_press) + self.cid_move = self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move) + self.cid_release = self.canvas.mpl_connect('button_release_event', self.on_mouse_release) + + self.dragging_overlay = False + + # Create and add the toolbar + self.toolbar = NavigationToolbar(self.canvas, self) + main_layout.addWidget(self.toolbar) + + # Create a QHBoxLayout for canvas and buttons + self.layout = QHBoxLayout() + + # Create a QVBoxLayout for the buttons + button_layout = QVBoxLayout() + + # Add "Topo Line Settings" button + self.topo_line_settings_button = QPushButton("Topo Line Settings", self) + self.topo_line_settings_button.clicked.connect(self.on_topo_line_settings_clicked) + button_layout.addWidget(self.topo_line_settings_button) + + # Add hover tool + hover_tool_btn = QPushButton("Hover Tool") + hover_tool_btn.clicked.connect(self.activate_hover_tool) + button_layout.addWidget(hover_tool_btn) + + # Add image overlay + add_image_btn = QPushButton("Add Image Overlay") + add_image_btn.clicked.connect(self.add_image_overlay) + button_layout.addWidget(add_image_btn) + + # Add plan view + self.toggle_view_button = QPushButton("Change to Plan View", self) + self.toggle_view_button.clicked.connect(self.toggle_view) + button_layout.addWidget(self.toggle_view_button) + + # Add bar plot + self.secondary_bar_plot_button = QPushButton("Auxiliary Bar Plot", self) + self.secondary_bar_plot_button.clicked.connect(self.secondary_bar_plot) + button_layout.addWidget(self.secondary_bar_plot_button) + + # Add Generate Contours button + self.generate_contours_button = QPushButton("Interpolate Contours (RBF)", self) + self.generate_contours_button.clicked.connect(self.generate_contours) + button_layout.addWidget(self.generate_contours_button) + + # Add Pencil tool button + self.pencil_tool_button = QPushButton("Pencil", self) + self.pencil_tool_button.setCheckable(True) # Make the button toggleable + self.pencil_tool_button.clicked.connect(self.toggle_pencil_tool) + button_layout.addWidget(self.pencil_tool_button) + + # Add "Save to CSV" button + self.save_to_csv_button = QPushButton("Export Plot to CSV", self) + self.save_to_csv_button.clicked.connect(self.on_save_to_csv_clicked) + button_layout.addWidget(self.save_to_csv_button) + + + # Create the QLabel for the title + attribute_list_label = QLabel("Change Attribute") + attribute_list_label.setAlignment(Qt.AlignCenter) # Center align the text + + # Set the font to bold + font = attribute_list_label.font() + font.setBold(True) + attribute_list_label.setFont(font) + + # Add space above the label + button_layout.addSpacing(20) # Adjust the spacing value as needed + + # Add the QLabel to the layout + button_layout.addWidget(attribute_list_label) + + # Add space below the label + button_layout.addSpacing(10) # Adjust the spacing value as needed + + # Add the attribute list + button_layout.addWidget(self.attribute_list_view) + + # Add "Redraw Plot" button + self.redraw_plot_button = QPushButton("Redraw Plot", self) + self.redraw_plot_button.clicked.connect(self.on_redraw_button_clicked) + button_layout.addWidget(self.redraw_plot_button) + + # Add a stretch to push the buttons to the top + button_layout.addStretch(1) + + # Add the QVBoxLayout to the QHBoxLayout + self.layout.addLayout(button_layout, stretch=1) + + # Add the canvas to the QHBoxLayout + self.layout.addWidget(self.canvas, stretch=5) + + # Add the QHBoxLayout to the main QVBoxLayout + main_layout.addLayout(self.layout) + + # Set the main QVBoxLayout as the layout for the QDialog + self.setLayout(main_layout) + + # Resize the QDialog + self.resize(1200, 825) + + # Include maximize and minimize buttons + self.setWindowFlags(self.windowFlags() | Qt.WindowMaximizeButtonHint | Qt.WindowMinimizeButtonHint) + + self.plot() # Create the plot + self.setWindowTitle("Cross Section Visualizer") + + def on_save_to_csv_clicked(self): + # Open a file dialog to choose where to save the CSV + options = QFileDialog.Options() + fileName, _ = QFileDialog.getSaveFileName(self, "Save CSV File", "", + "CSV Files (*.csv)", options=options) + if fileName: + try: + # Save the extended data to CSV + self.export_data.to_csv(fileName, index=False) + except Exception as e: + # Handle exceptions (e.g., IOError) + print("Error saving file:", e) + + def toggle_pencil_tool(self): + self.pencil_mode = self.pencil_tool_button.isChecked() + if not self.pencil_mode: + self.clear_drawings() + + + def on_topo_line_settings_clicked(self): + dialog = QDialog(self) + layout = QVBoxLayout(dialog) + + # Color picker for the sky + color_label = QLabel("Select Sky Color:") + color_picker = QPushButton("Choose Color") + color_picker.clicked.connect(lambda: self.choose_sky_color(color_picker)) + + # Checkboxes for removing sky and both topo line and sky + remove_sky_checkbox = QCheckBox("Remove Sky") + remove_topo_and_sky_checkbox = QCheckBox("Remove Topo Line and Sky") + + # Offset input + offset_label = QLabel("Topo Line Offset: Postive values to move up, negative values to move down") + offset_input = QLineEdit() + offset_input.setText("0") # Set the default value to 0 + + # OK and Cancel buttons + buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) + buttons.accepted.connect(dialog.accept) + buttons.rejected.connect(dialog.reject) + + # Add widgets to layout + layout.addWidget(color_label) + layout.addWidget(color_picker) + layout.addWidget(remove_sky_checkbox) + layout.addWidget(remove_topo_and_sky_checkbox) + layout.addWidget(offset_label) + layout.addWidget(offset_input) + layout.addWidget(buttons) + + result = dialog.exec_() + if result: + # Process selected color + selected_color = color_picker.property("color") + if selected_color: + self.sky_color = selected_color + + # Process remove sky + if remove_sky_checkbox.isChecked(): + self.sky_color = 'white' + + # Process remove topo line and sky + self.remove_topo_and_sky = remove_topo_and_sky_checkbox.isChecked() + + # Process offset + try: + offset_value = float(offset_input.text()) + self.offset = offset_value + self.generate_contours_flag = False + except ValueError: + QMessageBox.warning(self, "Invalid Input", "Please enter a valid number.") + + self.plot() # Replot with the new settings + + def choose_sky_color(self, button): + color = QColorDialog.getColor() + if color.isValid(): + button.setStyleSheet("background-color: %s;" % color.name()) + button.setProperty("color", color.name()) + + + + def select_contour_column(self): + # Get a list of numerical columns + numerical_columns = self.data.select_dtypes(include=[np.number]).columns.tolist() + if not numerical_columns: + QMessageBox.warning(self, "Warning", "No numerical columns found in the data.") + return + + # Create a custom dialog + dialog = QDialog(self) + dialog.setWindowTitle("Select Contour Options") + layout = QVBoxLayout(dialog) + + # Column selection combo box + column_label = QLabel("Choose a numerical column for contouring:") + column_combo = QComboBox(dialog) + column_combo.addItems(numerical_columns) + layout.addWidget(column_label) + layout.addWidget(column_combo) + + # Input for Q1 percentile + Q1_input = QDoubleSpinBox(dialog) + Q1_input.setRange(0, 100) + Q1_input.setValue(25) # Default value + Q1_input.setSuffix("%") + layout.addWidget(QLabel("Enter Q1 percentile:")) + layout.addWidget(Q1_input) + + # Input for Q3 percentile + Q3_input = QDoubleSpinBox(dialog) + Q3_input.setRange(0, 100) + Q3_input.setValue(75) # Default value + Q3_input.setSuffix("%") + layout.addWidget(QLabel("Enter Q3 percentile:")) + layout.addWidget(Q3_input) + + # Input for IQR scaling factor + scale_input = QDoubleSpinBox(dialog) + scale_input.setRange(0, 100) + scale_input.setValue(1.5) # Default value + layout.addWidget(QLabel("Enter IQR scaling factor:")) + layout.addWidget(scale_input) + + # Checkbox for disabling outlier capping + disable_outliers_checkbox = QCheckBox("Disable outlier capping", dialog) + layout.addWidget(disable_outliers_checkbox) + + + # OK and Cancel buttons + buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, dialog) + layout.addWidget(buttons) + buttons.accepted.connect(dialog.accept) + buttons.rejected.connect(dialog.reject) + + # Show the dialog and get the result + if dialog.exec_(): + selected_column = column_combo.currentText() + Q1 = Q1_input.value() + Q3 = Q3_input.value() + scale = scale_input.value() + + # Store the selected options as instance variables + self.contour_column = selected_column + self.outlier_Q1 = Q1 + self.outlier_Q3 = Q3 + # Store the state of the disable outliers checkbox + self.disable_outliers = disable_outliers_checkbox.isChecked() + self.outlier_scale = scale + + + + + def generate_contours(self): + # Call the method to select the contour column and set outlier parameters + self.select_contour_column() + + # set the flag and replot + if hasattr(self, 'contour_column'): # Check if the column was successfully selected + self.generate_contours_flag = True + self.plot() # Replot with contours + + + + def setup_attribute_list_view(self): + self.attribute_list_view = QListView(self) + self.attribute_list_view.setModel(self.attributes_model) + self.attribute_list_view.selectionModel().selectionChanged.connect(self.on_attribute_selection_changed) + + def on_attribute_selection_changed(self, item): + # Check if the item is checked + if item.checkState() == Qt.Checked: + # Uncheck all other items + for row in range(self.attributes_model.rowCount()): + other_item = self.attributes_model.item(row) + if other_item != item: + other_item.setCheckState(Qt.Unchecked) + + # Store the selected attribute + self.attribute_column = item.text() + + def on_redraw_button_clicked(self): + if self.attribute_column: + self.update_plot(self.attribute_column) + + def update_plot(self, attribute_column): + self.attribute_column = attribute_column + self.generate_contours_flag = False + self.bar_column = None + self.plot() + + self.redraw_image() # Redraw the overlay image after updating the plot + + + + def add_image_overlay(self): + options = QFileDialog.Options() + image_path, _ = QFileDialog.getOpenFileName(self, "Open Image Overlay", "", "Images (*.png *.xpm *.jpg *.bmp);;All Files (*)", options=options) + if image_path: + self.overlay_image = plt.imread(image_path) + + # Get the initial dimensions of the image + initial_height, initial_width = self.overlay_image.shape[:2] + + # Compute the initial x and y coordinates + ax = self.figure.axes[0] # The first axis is the cross-section plot + x_center = (ax.get_xlim()[1] + ax.get_xlim()[0]) / 2 + y_center = (ax.get_ylim()[1] + ax.get_ylim()[0]) / 2 + + initial_x = x_center - (initial_width / 2) + initial_y = y_center - (initial_height / 2) + + self.overlay_image_state = { + 'x': initial_x, + 'y': initial_y, + 'width': initial_width, + 'height': initial_height, + } + + # Display the overlay image using the computed x and y values + self.current_overlay_image_display = ax.imshow(self.overlay_image, extent=[initial_x, initial_x + initial_width, initial_y, initial_y + initial_height], zorder=0) + self.canvas.draw() + + + + + def on_mouse_press(self, event): + if self.pencil_mode: + if event.inaxes: # Click is inside the plot + # Start a new line + line = Line2D([event.xdata], [event.ydata], color='black', zorder=6) + self.figure.axes[0].add_line(line) + self.drawing_lines.append(line) + self.currently_drawing = True # Start drawing + else: # Click is outside the plot + self.clear_drawings() # Clear drawings + self.pencil_tool_button.setChecked(False) # Turn off the pencil tool + self.pencil_mode = False # Update the pencil mode state + else: + # Ensure the mouse press is within the overlay image + if (self.overlay_image_state['x'] <= event.xdata <= self.overlay_image_state['x'] + self.overlay_image_state['width'] and + self.overlay_image_state['y'] <= event.ydata <= self.overlay_image_state['y'] + self.overlay_image_state['height']): + + + # Determine the region of the image that was clicked + x_diff = event.xdata - self.overlay_image_state['x'] + y_diff = event.ydata - self.overlay_image_state['y'] + + # margin within which a corner or edge is considered clicked + margin = 50 # pixels + + # Explicitly handle each region + if x_diff < margin and y_diff < margin: + print("Detected bottom_left corner") + self.drag_region = 'bottom_left' + elif x_diff > self.overlay_image_state['width'] - margin and y_diff < margin: + print("Detected bottom_right corner") + self.drag_region = 'bottom_right' + elif x_diff < margin and y_diff > self.overlay_image_state['height'] - margin: + print("Detected top_left corner") + self.drag_region = 'top_left' + elif x_diff > self.overlay_image_state['width'] - margin and y_diff > self.overlay_image_state['height'] - margin: + print("Detected top_right corner") + self.drag_region = 'top_right' + elif x_diff < margin: + print("Detected left edge") + self.drag_region = 'left' + elif x_diff > self.overlay_image_state['width'] - margin: + print("Detected right edge") + self.drag_region = 'right' + else: + print("Detected center of the image") + self.drag_region = 'center' + + # Store initial mouse press location and set dragging_overlay to True + self.drag_start = (event.xdata, event.ydata) + self.dragging_overlay = True + + self.canvas.setFocusPolicy(Qt.StrongFocus) + self.canvas.setFocus() + + + def on_mouse_move(self, event): + if self.pencil_mode and self.currently_drawing and event.inaxes and self.drawing_lines: + # Add point to the current line + line = self.drawing_lines[-1] # Get the last line + xdata, ydata = line.get_data() + xdata = np.append(xdata, event.xdata) + ydata = np.append(ydata, event.ydata) + line.set_data(xdata, ydata) + self.canvas.draw_idle() + elif self.dragging_overlay: + if not self.dragging_overlay or event.xdata is None or event.ydata is None: + return + + # Calculate how much the mouse has moved + dx = event.xdata - self.drag_start[0] + dy = event.ydata - self.drag_start[1] + + # Determine how to adjust the overlay based on the drag region + if self.drag_region == 'center': + self.overlay_image_state['x'] += dx + self.overlay_image_state['y'] += dy + + # Redraw the overlay image with the updated position + self.redraw_image() + + + # Update the drag start position for the next move event + self.drag_start = (event.xdata, event.ydata) + print(f"Image moved/scaled to {self.overlay_image_state['x']}, {self.overlay_image_state['y']}.") + + def on_key_press(self, event): + + if any(val is None for val in self.overlay_image_state.values()): + print('Some overlay image state values are missing.') + return + + + scale_factor = 1.05 # Scale the image by 5% each time + + if event.key == '=': # Scale uniform bigger + self.overlay_image_state['width'] *= scale_factor + self.overlay_image_state['height'] *= scale_factor + + elif event.key == '-': # Scale uniform smaller + self.overlay_image_state['width'] /= scale_factor + self.overlay_image_state['height'] /= scale_factor + + elif event.key == 'a': # Scale left side in + self.overlay_image_state['x'] += scale_factor + self.overlay_image_state['width'] -= scale_factor + + elif event.key == 'w': # Scale top side down + self.overlay_image_state['y'] += scale_factor + self.overlay_image_state['height'] -= scale_factor + + elif event.key == 's': # Scale bottom side up + self.overlay_image_state['y'] -= scale_factor + self.overlay_image_state['height'] += scale_factor + + elif event.key == 'd': # Scale right side in + self.overlay_image_state['width'] -= scale_factor + + elif event.key == 'i': # Scale top side up + self.overlay_image_state['y'] -= scale_factor + self.overlay_image_state['height'] -= scale_factor + + elif event.key == 'j': # Scale left side out + self.overlay_image_state['x'] -= scale_factor + self.overlay_image_state['width'] += scale_factor + + elif event.key == 'l': # Scale right side out + self.overlay_image_state['width'] += scale_factor + + elif event.key == 'k': # Scale bottom side down + self.overlay_image_state['height'] -= scale_factor + + elif event.key == 'backspace': # Detect backspace key press + if self.current_overlay_image_display: + self.current_overlay_image_display.remove() # Remove the displayed image + self.current_overlay_image_display = None # Set the display reference to None + self.overlay_image = None + + # Redraw the image with the new scale or after deletion + self.redraw_image() + + + def redraw_image(self): + ax = self.figure.axes[0] + if self.current_overlay_image_display: + self.current_overlay_image_display.remove() + + # Only draw if overlay image is set + if self.overlay_image is not None: + self.current_overlay_image_display = ax.imshow( + self.overlay_image, + extent=[ + self.overlay_image_state['x'], + self.overlay_image_state['x'] + self.overlay_image_state['width'], + self.overlay_image_state['y'], + self.overlay_image_state['y'] + self.overlay_image_state['height'] + ], + zorder=-1 + ) + self.canvas.draw() + + + def on_mouse_release(self, event): + if self.pencil_mode: + # When in pencil mode, stop drawing on mouse release + self.currently_drawing = False + else: + # Existing logic for releasing the overlay image + self.dragging_overlay = False + self.drag_region = None + + + + def clear_drawings(self): + for line in self.drawing_lines: + line.remove() + self.drawing_lines.clear() + self.canvas.draw_idle() + + + def calculate_coordinates(self): + # calculate x, y coordinates of points along the cross-section line + # based on the azimuth and the original x, y coordinates + self.data['x_cross'] = self.data['x'] * np.cos(np.deg2rad(self.azimuth)) - self.data['y'] * np.sin(np.deg2rad(self.azimuth)) + self.data['y_cross'] = self.data['x'] * np.sin(np.deg2rad(self.azimuth)) + self.data['y'] * np.cos(np.deg2rad(self.azimuth)) + + + + def column_type(self, column, dataframe): + if pd.api.types.is_numeric_dtype(dataframe[column]): + return 'continuous' + else: + return 'categorical' + + def set_DEM_data(self, DEM_data): + self.DEM_data = DEM_data + + + def run_DEM_calc(self): + print("Executing run_DEM_calc") + if not hasattr(self, 'DEM_data') or self.DEM_data is None: + QMessageBox.warning(self, "No DEM", "Please load a DEM first") + return + + if self.data is None: + QMessageBox.warning(self, "No data", "Please load desurveyed data first") + return + + + if self.DEM_data is not None: + self.DEM_loaded = True + + self.hole_ids = [self.model_cross.item(index).text() for index in range(self.model_cross.rowCount()) + if self.model_cross.item(index).checkState() == Qt.Checked] + + start_point, end_point = self.create_profile_line(self.hole_ids, self.azimuth, self.max_z) + + # Transform to plotting coordinates + transformed_start_point = self.transform_coordinates(*start_point) + transformed_end_point = self.transform_coordinates(*end_point) + + # Extract the topographic profile using real-world coordinates + profile = self.extract_topographic_profile(start_point, end_point) + + # Plot the profile using transformed coordinates + self.plot_elevation_profile_on_existing_plot(ax, profile, transformed_start_point, transformed_end_point) + + + def extract_topographic_profile(self, original_start_point, original_end_point): + print("extract_topographic_profile method invoked.") + line = LineString([original_start_point, original_end_point]) + ##print(f"Start Point: {original_start_point}") + ##print(f"End Point: {original_end_point}") + window = geometry_window(self.DEM_data, [line]) + cropped_data = self.DEM_data.read(window=window) + + # Create a mask of the DEM that represents the path of the line + mask = geometry_mask([line], transform=self.DEM_data.window_transform(window), invert=True, out_shape=cropped_data.shape[-2:]) + + profile = np.extract(mask, cropped_data) + nodata_value = -999999.0 + profile = profile[profile != nodata_value] + + ##print("Elevation Profile Extracted") + ##print("Profile Length:", len(profile)) + ##print("Profile values range from:", profile.min(), "to", profile.max()) + + + ##print("Elevation Profile:", profile) + + return profile + + + def create_profile_line(self, hole_ids, azimuth, max_z, min_x=None, max_x=None): + + self.calculate_coordinates() + + # Filter the sheet by hole_ids + filtered_df = self.data[self.data['hole_id'].isin(hole_ids)] + + # Find the row with the maximum z value + max_z_row = filtered_df.loc[filtered_df['z'].idxmax()] + + # Extract x and y coordinates of the max_z_row + x_origin, y_origin = max_z_row['x'], max_z_row['y'] + + if self.azimuth >= 180: + adjusted_azimuth = self.azimuth - 180 + else: + adjusted_azimuth = self.azimuth + + ##print("Input azimuth:", azimuth) + theta = np.radians(adjusted_azimuth) + ##print("Theta in radians:", theta) + + # Define the length of the line to extend from the origin + line_length = 2000 # 2000 meters in EITHER direction + + # Calculate changes in x and y based on the new azimuth + dx = line_length * np.cos(theta) + dy = line_length * np.sin(theta) + print("dx:", dx, "dy:", dy) + + # Calculate left and right endpoints of the profile line based on dx and dy + x_left_end = x_origin - dx + y_left_end = y_origin + dy + x_right_end = x_origin + dx + y_right_end = y_origin - dy + + # Print the calculated endpoints + ##print("Calculated start point:", (x_left_end, y_left_end)) + ##print("Calculated end point:", (x_right_end, y_right_end)) + + # Return the start and end coordinates of the profile line + return ((x_left_end, y_left_end), (x_right_end, y_right_end)) + + + def transform_coordinates(self, x, y): + x_cross = x * np.cos(np.deg2rad(self.azimuth)) - y * np.sin(np.deg2rad(self.azimuth)) + y_cross = x * np.sin(np.deg2rad(self.azimuth)) + y * np.cos(np.deg2rad(self.azimuth)) + return x_cross, y_cross + + + def plot_elevation_profile_on_existing_plot(self, ax, adjusted_profile, start_point, end_point): + # Calculate the x values (distance along the profile) + x_values = np.linspace(start_point[0], end_point[0], len(adjusted_profile)) + + # Print the x and y values + ##print("X Values:", x_values) + ##print("Adjusted Y Values (Elevation Profile):", adjusted_profile) + + # Adjust the alpha level based on whether to remove topo line and sky + alpha_level = 0 if self.remove_topo_and_sky else 0.5 + + # Plot the adjusted topographic profile on the given axes + ax.plot(x_values, adjusted_profile, color='black', alpha=alpha_level, zorder=4) + + def secondary_bar_plot(self): + + # Get a list of numerical columns + numerical_columns = self.data.select_dtypes(include=[np.number]).columns.tolist() + if not numerical_columns: + QMessageBox.warning(self, "Warning", "No numerical columns found in the data.") + return + + # Create a dialog for the user to select a column + column, ok = QInputDialog.getItem(self, "Select Column", "Choose a numerical column for the secondary bar plot:", numerical_columns, 0, False) + + if ok and column: + self.bar_column = column # Store the selected column as an instance variable + self.plot() # Re-draw the plot + self.canvas.draw() + + + def plot_bars(self, bar_column, ax): + + # Ensure bar_column is valid + if bar_column not in self.data.columns: + print(f"'{bar_column}' is not a valid column in the data.") + return + + # Filter the data for only the selected holes + selected_holes_data = self.data[self.data['hole_id'].isin(self.hole_ids)] + + # Get the min and max values of the bar column for normalization + min_bar_value, max_bar_value = selected_holes_data[bar_column].min(), selected_holes_data[bar_column].max() + print(f"Bar column: {bar_column}") + print(f"Min bar value: {min_bar_value}, Max bar value: {max_bar_value}") + + # Determine the range of the bar_column values based on outlier removal + filtered_data = selected_holes_data.copy() + if self.remove_outliers and self.remove_outliers_auxiliary: + # Only filter outliers if both conditions are met + filtered_data = filtered_data[pd.to_numeric(filtered_data[bar_column], errors='coerce').notna()] + Q1_bar = filtered_data[bar_column].quantile(self.lower_quantile / 100) + Q3_bar = filtered_data[bar_column].quantile(self.upper_quantile / 100) + IQR_bar = Q3_bar - Q1_bar + filtered_data = filtered_data[~((filtered_data[bar_column] < (Q1_bar - self.IQR * IQR_bar)) | (filtered_data[bar_column] > (Q3_bar + self.IQR * IQR_bar)))] + self.bar_vmin = filtered_data[bar_column].min() + self.bar_vmax = filtered_data[bar_column].max() + else: + # Use original, unfiltered data + self.bar_vmin = selected_holes_data[bar_column].min() + self.bar_vmax = selected_holes_data[bar_column].max() + + self.filtered_bar_data = filtered_data + + y_min, y_max = ax.get_ylim() + + # Compute the offset based on the y-axis range + OFFSET_FRACTION = 0.01 + offset = OFFSET_FRACTION * (y_max - y_min) + + # Compute the maximum bar length based on the y-axis range + MAX_BAR_LENGTH_FRACTION = 0.05 + MAX_BAR_LENGTH = MAX_BAR_LENGTH_FRACTION * (y_max - y_min) + + for hole_id in self.hole_ids: + hole_data = filtered_data[filtered_data['hole_id'] == hole_id] + if hole_data.empty: + continue + + # Sort the hole_data based on depth for proper segment computation + hole_data = hole_data.sort_values('z', ascending=True) + + for i in range(len(hole_data) - 1): + # Get the start and end points of the current segment in the drill trace + start_x, start_y = hole_data.iloc[i]['x_cross'], hole_data.iloc[i]['z'] + end_x, end_y = hole_data.iloc[i+1]['x_cross'], hole_data.iloc[i+1]['z'] + + # Compute the direction vector of the segment + delta_x, delta_y = end_x - start_x, end_y - start_y + magnitude = np.sqrt(delta_x**2 + delta_y**2) + normalized_dir_vector = (delta_x/magnitude, delta_y/magnitude) + + # Compute the perpendicular vector + perp_vector = (-normalized_dir_vector[1], normalized_dir_vector[0]) + + # If hole is dipping eastward, adjust (mirror) the perpendicular vector + if delta_x < 0: + perp_vector = (-perp_vector[0], -perp_vector[1]) + + # If hole is vertical or near-vertical, force bars to stick to right side + VERTICAL_THRESHOLD = 0.5 # Small threshold value + if abs(delta_x) < VERTICAL_THRESHOLD: + perp_vector = (1, 0) # Force bars to the right side + + # Compute the midpoint of the segment and offset it using the perpendicular vector + mid_x = (start_x + end_x) / 2 + perp_vector[0] * offset + mid_y = (start_y + end_y) / 2 + perp_vector[1] * offset + + # Compute the end point for the bar, based on the value in the selected column + bar_value = hole_data.iloc[i][bar_column] + normalized_bar_value = (bar_value - self.bar_vmin) / (self.bar_vmax - self.bar_vmin) + bar_length = MAX_BAR_LENGTH * normalized_bar_value + + end_x = mid_x + bar_length * perp_vector[0] + end_y = mid_y + bar_length * perp_vector[1] + + # Plot the bar + ax.plot([mid_x, end_x], [mid_y, end_y], color='gray', zorder=10, alpha=0.5) + + + + def add_bar_legend(self, ax, bar_column): + # Check if bar_column is None; if so, do not draw the legend + if bar_column is None: + return + + x_position = -0.11 # places the legend slightly to the right of the plot area. + + # Start and end y-positions for the bar + y_position_max = 0.15 + y_position_min = y_position_max - 0.1 + + # Draw the single gray bar using ax.plot() + line, = ax.plot([x_position, x_position], [y_position_min, y_position_max], color='gray', linewidth=6, transform=ax.transAxes, zorder=10) + line.set_clip_on(False) + + # Add labels + ax.text(x_position - 0.03, y_position_max, f'{self.bar_vmax:.2f}', va='bottom', ha='right', transform=ax.transAxes) + ax.text(x_position - 0.03, y_position_min, f'{self.bar_vmin:.2f}', va='top', ha='right', transform=ax.transAxes) + + # Set the title for the legend + ax.text(x_position, y_position_max + 0.05, bar_column, va='center', ha='right', transform=ax.transAxes, fontweight='bold') + + def calculate_tick_interval(self, min_value, max_value): + distance = max_value - min_value + if distance > 2000: + return 500 + elif distance > 600: + return 200 + else: + return 100 + + + def plot(self): # Main drill hole plotting function + + # Save the pencil line data + pencil_line_data = [] + for line in self.drawing_lines: + xdata, ydata = line.get_data() + pencil_line_data.append((xdata, ydata)) + + self.calculate_coordinates() + self.figure.clear() # Clear the entire figure + ax = self.figure.add_subplot(111) + + # Re-add the pencil drawings if there + self.drawing_lines = [] # Clear existing line references + for xdata, ydata in pencil_line_data: + line = Line2D(xdata, ydata, color='black', zorder=6) + ax.add_line(line) + self.drawing_lines.append(line) + + self.canvas.draw_idle() # Redraw the canvas with the new plot and pencil lines + + min_x_plan, max_x_plan = float('inf'), float('-inf') + min_x_cross, max_x_cross = float('inf'), float('-inf') + min_z, max_z = float('inf'), float('-inf') + min_y, max_y = float('inf'), float('-inf') + + self.min_x_cross, self.max_x_cross = float('inf'), float('-inf') + self.min_z, self.max_z = float('inf'), float('-inf') + + # Filter the data based on selected hole_ids + selected_data = self.data[self.data['hole_id'].isin(self.hole_ids)] + + # Update logic to determine actual axis limits + for row in selected_data.itertuples(): + self.min_z = min(self.min_z, row.z) + self.max_z = max(self.max_z, row.z) + + # Initialize + filtered_data = None + vmin, vmax = None, None + + # Set up normailzation + if self.attribute_column and self.column_type(self.attribute_column, self.data) == 'continuous': + if self.remove_outliers: + filtered_data = self.data[pd.to_numeric(self.data[self.attribute_column], errors='coerce').notna()].copy() + Q1 = filtered_data[self.attribute_column].quantile(self.lower_quantile / 100) + Q3 = filtered_data[self.attribute_column].quantile(self.upper_quantile / 100) + IQR = Q3 - Q1 + + # Remove outliers from filtered_data for the other plots + filtered_data = filtered_data[~((filtered_data[self.attribute_column] < (Q1 - self.IQR * IQR)) | (filtered_data[self.attribute_column] > (Q3 + self.IQR * IQR)))] + + vmin = filtered_data[self.attribute_column].min() + vmax = filtered_data[self.attribute_column].max() + else: + # Use the original data without filtering for outliers + vmin = self.data[self.attribute_column].min() + vmax = self.data[self.attribute_column].max() + + if hasattr(self, 'bar_column') and hasattr(self, 'bar_vmin') and hasattr(self, 'bar_vmax'): + pass # bar_vmin and bar_vmax are already set as instance attributes + else: + self.bar_vmin, self.bar_vmax = None, None + + + print(f"vmin: {vmin}, vmax: {vmax}") + print(f"bar_vmin: {self.bar_vmin}, bar_vmax: {self.bar_vmax}") + + color_dict = {} + + + # For RBF contour plotting + if self.generate_contours_flag: + # Check if the necessary parameters are set + if not hasattr(self, 'contour_column') or not hasattr(self, 'outlier_Q1') or not hasattr(self, 'outlier_Q3') or not hasattr(self, 'outlier_scale'): + QMessageBox.warning(self, "Warning", "Contour parameters not set.") + return + + # Extract necessary data + data = self.data[self.data['hole_id'].isin(self.hole_ids)] + x_cross, z, values = data['x_cross'], data['z'], data[self.contour_column] + + # Convert to numpy arrays and remove NaNs + x_cross, z, values = map(np.array, [x_cross, z, values]) + mask = np.isfinite(x_cross) & np.isfinite(z) & np.isfinite(values) + x_cross, z, values = x_cross[mask], z[mask], values[mask] + + if not self.disable_outliers: + Q1_percentile = np.percentile(values, self.outlier_Q1) + Q3_percentile = np.percentile(values, self.outlier_Q3) + IQR = Q3_percentile - Q1_percentile + upper_threshold = Q3_percentile + self.outlier_scale * IQR + lower_threshold = Q1_percentile - self.outlier_scale * IQR + + # Cap the outliers + values = np.clip(values, lower_threshold, upper_threshold) + + # Extend the grid for the boundary + boundary_width = 0.1 # adjust as needed + extended_grid_x = np.linspace(min(x_cross) - boundary_width, max(x_cross) + boundary_width, num=50) + extended_grid_z = np.linspace(min(z) - boundary_width, max(z) + boundary_width, num=50) + extended_grid_x, extended_grid_z = np.meshgrid(extended_grid_x, extended_grid_z) + + # Perform RBF interpolation on the original data + rbf = Rbf(x_cross, z, values, function='multiquadric', smooth=0.05) + z_pred = rbf(extended_grid_x, extended_grid_z) + + # Create a mask for the original data range + mask = ((extended_grid_x >= min(x_cross)) & (extended_grid_x <= max(x_cross)) & + (extended_grid_z >= min(z)) & (extended_grid_z <= max(z))) + + # Apply the mask to set boundary values to zero + z_pred[~mask] = 0 # Set values outside the original data range to zero + + # Plotting + contourf = ax.contourf(extended_grid_x, extended_grid_z, z_pred, levels=10, cmap='Spectral_r', alpha=0.5, zorder=0) + + + # levels to be made transparent + num_transparent_levels = 3 + + # Find collections corresponding to the first 3 contour levels and set their alpha to 0 + for collection in contourf.collections[:num_transparent_levels]: + collection.set_alpha(0) # Set alpha to 0 for these levels + + # New DataFrame to store the extended data + self.extended_data = pd.DataFrame() + + + # Drill hole plotting + for hole_id in self.hole_ids: + hole_data = self.data[self.data['hole_id'] == hole_id] + if hole_data.empty: + + continue + + # Plot the full hole trace as a thin black line + if self.is_plan_view: + ax.plot(hole_data['x'], hole_data['y'], color='black', linewidth=0.5, alpha=0.5, zorder=4) + else: + ax.plot(hole_data['x_cross'], hole_data['z'], color='black', pickradius=50, linewidth=0.5, alpha=0.5, zorder=1) + + + hole_data.sort_values('z', inplace=True, ascending=False) + + # Initialize a list to store colors for each point + hole_colors = [] + + # Contineous data plotting + if self.attribute_column: + if self.column_type(self.attribute_column, self.data) == 'continuous': + cmap = plt.get_cmap('Spectral_r') + norm = plt.Normalize(vmin=vmin, vmax=vmax) + for i in range(1, len(hole_data)): + current_value = hole_data[self.attribute_column].iloc[i] + + if pd.notna(current_value): # Only plot when current data point has attribute data + if self.is_plan_view: + x_values = hole_data['x'].iloc[i-1:i+1] + y_values = hole_data['y'].iloc[i-1:i+1] + + ax.plot(x_values, y_values, color=cmap(norm(current_value)), linewidth=self.line_width, zorder=5, picker=True, pickradius=50, label=str(i)) + + else: + x_values = hole_data['x_cross'].iloc[i-1:i+1] + z_values = hole_data['z'].iloc[i-1:i+1] + + ax.plot(x_values, z_values, color=cmap(norm(current_value)), linewidth=self.line_width, zorder=5, picker=True, pickradius=50, label=str(i)) + + + sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + sm.set_array([]) + + # Categorical data plotting + else: + if self.attribute_column in self.attributes_dict: + for i in range(1, len(hole_data)): + x_values = hole_data['x_cross' if not self.is_plan_view else 'x'].iloc[i-1:i+1] + y_values = hole_data['z' if not self.is_plan_view else 'y'].iloc[i-1:i+1] + + if pd.notna(hole_data[self.attribute_column].iloc[i]): # Only plot when attribute data exists + color_val = hole_data[self.attribute_column].iloc[i] + + if color_val in self.attributes_dict[self.attribute_column]: + settings = self.attributes_dict[self.attribute_column][color_val] + + # Check if line_width is 0, if so set to 0.5 and color to black + line_width = settings["line_width"] if settings["line_width"] != 0 else 0.5 + color = settings["color"] if settings["line_width"] != 0 else "black" + + ax.plot(x_values, y_values, color=color, linewidth=line_width, zorder=5, picker=True, pickradius=50, label=str(i-1)) + + else: + # Default when the color value is not found in the predefined attributes dictionary + ax.plot(x_values, y_values, color="black", linewidth=0.5, alpha=0.5, picker=True, pickradius=50, zorder=4) + else: + # Default when the attribute data is missing + ax.plot(x_values, y_values, color="black", linewidth=0.5, alpha=0.5, picker=True, pickradius=50, zorder=4) + + else: + # If the attribute column isn't in the predefined attributes dictionary, use default color mapping + unique_vals = self.data[self.attribute_column].unique() + colors = plt.cm.get_cmap('tab20', len(unique_vals)) + color_dict = dict(zip(unique_vals, colors(range(len(unique_vals))))) + + for i in range(1, len(hole_data)): + x_values = hole_data['x_cross' if not self.is_plan_view else 'x'].iloc[i-1:i+1] + y_values = hole_data['z' if not self.is_plan_view else 'y'].iloc[i-1:i+1] + + if pd.notna(hole_data[self.attribute_column].iloc[i]): # Only plot when attribute data exists + color_val = hole_data[self.attribute_column].iloc[i] + + if color_val in color_dict: + ax.plot(x_values, y_values, color=color_dict[color_val], linewidth=self.line_width, zorder=5, picker=True, pickradius=50, label=str(i-1)) + else: + # Default when the color value is not found in the generated color dictionary + ax.plot(x_values, y_values, color="black", linewidth=0.5, alpha=0.5, zorder=1) + else: + # Default when the attribute data is missing + ax.plot(x_values, y_values, color="black", linewidth=0.5, alpha=0.5, picker=True, zorder=1) + + # No data plotting + else: + x_values = hole_data['x_cross' if not self.is_plan_view else 'x'] + y_values = hole_data['z' if not self.is_plan_view else 'y'] + ax.plot(x_values, y_values, color='black', linewidth=0.5, alpha=0.5, zorder=4) + + + # Color collection for Continuous and Categorical data plotting + for i in range(len(hole_data)): + color = 'black' + if self.attribute_column: + # Determine the color for continuous data + if self.column_type(self.attribute_column, self.data) == 'continuous': + current_value = hole_data[self.attribute_column].iloc[i] + if pd.notna(current_value): + cmap = plt.get_cmap('Spectral_r') + norm = plt.Normalize(vmin=vmin, vmax=vmax) + color = cmap(norm(current_value)) + else: + color = 'black' # Default color for missing data + + # Determine the color for categorical data + elif self.attribute_column in self.attributes_dict: + color_val = hole_data[self.attribute_column].iloc[i] + if pd.notna(color_val) and color_val in self.attributes_dict[self.attribute_column]: + settings = self.attributes_dict[self.attribute_column][color_val] + # Set color to black if line_width is 0, else use the predefined color + color = 'black' if settings["line_width"] == 0 else settings["color"] + else: + color = 'black' # Default color + else: + color = 'black' # Default color for no data + + # Append the color to the list + hole_colors.append(mcolors.to_hex(color)) + + # Update extended_hole_data with the colors + self.extended_hole_data = hole_data.copy() + self.extended_hole_data['color'] = hole_colors + + # Initialize a list to store line widths + line_widths = [] + + # Iterate over each row in hole_data + for i, row in hole_data.iterrows(): + if self.attribute_column and pd.notna(row[self.attribute_column]): + # Check if the attribute_column is categorical + if self.column_type(self.attribute_column, self.data) == 'categorical': + # For categorical data, get line width from the predefined dictionary + color_val = row[self.attribute_column] + if self.attribute_column in self.attributes_dict and color_val in self.attributes_dict[self.attribute_column]: + settings = self.attributes_dict[self.attribute_column][color_val] + line_width = settings["line_width"] if settings["line_width"] != 0 else 0.5 + line_widths.append(line_width) + else: + # If color_val is not in self.attributes_dict, use the default line width + line_widths.append(self.line_width) + else: + # If the attribute_column is not categorical, use the default line width + line_widths.append(self.line_width) + + else: + # If the attribute column does not exist or the data point has no attribute data + line_widths.append(0.5) + + # Assign the list of line widths to the extended_hole_data + self.extended_hole_data['line_width'] = line_widths + + self.extended_data = pd.concat([self.extended_data, self.extended_hole_data]) + + # Keep only necessary columns + export_columns = ['hole_id', 'x', 'y', 'z', 'color', 'line_width'] + + # Add the attribute column if it's valid + if self.attribute_column and self.attribute_column in self.extended_data.columns: + export_columns.append(self.attribute_column) + + # Keep only necessary columns + self.export_data = self.extended_data[export_columns] + + # Find min and max's + min_x_plan = min(min_x_plan, hole_data['x'].min()) + max_x_plan = max(max_x_plan, hole_data['x'].max()) + + self.min_x_cross = min(self.min_x_cross, hole_data['x_cross'].min()) + self.max_x_cross = max(self.max_x_cross, hole_data['x_cross'].max()) + + self.min_z = min(self.min_z, hole_data['z'].min()) + self.max_z = max(self.max_z, hole_data['z'].max()) + + min_y = min(min_y, hole_data['y'].min()) + max_y = max(max_y, hole_data['y'].max()) + + min_depth_index = hole_data['z'].idxmin() + + print(self.selected_hole_ids_for_labels, hole_id) + if self.selected_hole_ids_for_labels is None or hole_id in self.selected_hole_ids_for_labels: + + if self.is_plan_view: + self.plot_label_within_limits(ax, hole_data['x'].loc[min_depth_index], hole_data['y'].loc[min_depth_index], str(hole_id)) + else: + self.plot_label_within_limits(ax, hole_data['x_cross'].loc[min_depth_index], hole_data['z'].loc[min_depth_index] - 1, str(hole_id)) + + if not self.is_plan_view and hasattr(self, 'bar_column'): + try: + self.plot_bars(self.bar_column, ax) + except Exception as e: + print("Error while plotting bars:", e) + + + + if 'sm' in locals(): # Legend variables + self.figure.colorbar(sm, ax=ax, orientation='vertical', label=self.attribute_column, shrink=0.5) + + if self.attribute_column and self.column_type(self.attribute_column, self.data) != 'continuous': + if self.attribute_column in self.attributes_dict: + legend_elements = [] + for val, attributes in self.attributes_dict[self.attribute_column].items(): + if attributes['line_width'] != 0: + legend_element = Line2D([0], [0], color=attributes['color'], lw=4, label=val) + legend_elements.append(legend_element) + else: + legend_elements = [Line2D([0], [0], color=color_dict[val], lw=4, label=val) for val in color_dict] + + if legend_elements: # Only add the legend if there are any elements to show + ax.legend(handles=legend_elements, loc='center left', bbox_to_anchor=(1, 0.6)) + + # Add the bar legend + if hasattr(self, 'bar_column'): + self.add_bar_legend(ax, self.bar_column) + + # buffer x and y/z + self.buffer_x = self.x_buffer + self.buffer_yz = (self.max_z - self.min_z) * self.y_buffer + + if self.is_plan_view: + ax.set_xlim([min_x_plan - self.buffer_x, max_x_plan + self.buffer_x]) + ax.set_ylim([min_y - self.buffer_yz, max_y + self.buffer_yz]) + ax.set_xlabel('Easting', labelpad=15) + ax.set_ylabel('Northing', labelpad=15) + ax.set_aspect('equal') + + else: + # For cross-section view + min_x_with_buffer = self.min_x_cross - self.buffer_x + max_x_with_buffer = self.max_x_cross + self.buffer_x + + ax.set_xlim([min_x_with_buffer, max_x_with_buffer]) + ax.set_ylim([self.min_z - self.buffer_yz, self.max_z + self.buffer_yz]) + ax.set_xlabel('Distance along cross-section line (m)', labelpad=20) + ax.set_ylabel('Elevation / Depth (m)', labelpad=20) + ax.tick_params(axis='x', labelsize=8) + ax.set_aspect('equal') + + # Calculate and set dynamic ticks using distance + tick_interval = self.calculate_tick_interval(min_x_with_buffer, max_x_with_buffer) + offset = -min_x_with_buffer # Adjust offset for buffer + tick_values = np.arange(min_x_with_buffer, max_x_with_buffer, tick_interval) + tick_labels = [f"{int(tick + offset)}" for tick in tick_values] # Adjust for offset + ax.set_xticks(tick_values) + ax.set_xticklabels(tick_labels) + ax.set_aspect('equal') + + # colors for sky + colors = ["white", self.sky_color] + cmap_bg = LinearSegmentedColormap.from_list("", colors) + + # If the DEM is loaded + if self.DEM_loaded: + print("DEM_loaded is True. Proceeding with topographic profile plotting.") + + # Create the profile line using the new version of create_profile_line + start_point, end_point = self.create_profile_line(self.hole_ids, self.azimuth, self.max_z) + + # Transform these to plotting coordinates + transformed_start_point = self.transform_coordinates(*start_point) + transformed_end_point = self.transform_coordinates(*end_point) + + # Extract the topographic profile + profile = self.extract_topographic_profile(start_point, end_point) + + # Adjust the profile values to raise the topographic profile + adjusted_profile = [value + getattr(self, 'offset', 0) for value in profile] + + # Adjust the alpha level based on whether to remove topo line and sky + alpha_level = 0 if self.remove_topo_and_sky else 1 + + # Plot the adjusted topographic profile using transformed coordinates + self.plot_elevation_profile_on_existing_plot(ax, adjusted_profile, transformed_start_point, transformed_end_point) + + # Calculate the x values for the topographic profile in transformed coordinates + x_start_transformed = start_point[0] * np.cos(np.deg2rad(self.azimuth)) - start_point[1] * np.sin(np.deg2rad(self.azimuth)) + x_end_transformed = end_point[0] * np.cos(np.deg2rad(self.azimuth)) - end_point[1] * np.sin(np.deg2rad(self.azimuth)) + + # Calculate the x values for the topographic profile using transformed coordinates + x_values = np.linspace(x_start_transformed, x_end_transformed, len(adjusted_profile)) + + # Define the upper boundary for the gradient + upper_boundary = np.full_like(adjusted_profile, self.max_z + self.buffer_yz) + + + # Use fill_between to fill the area above the topographic profile + ax.fill_between(x_values, adjusted_profile, upper_boundary, color=self.sky_color, alpha=alpha_level, zorder=3) + + + + else: + # If the DEM is not loaded, plot the gradient + alpha_level = 0 if self.remove_topo_and_sky else 0.5 # Adjust alpha for gradient + + gradient = np.linspace(0, 1, 256) + gradient = np.vstack((gradient, gradient)) + gradient = np.transpose(gradient) + ax.imshow(gradient, aspect='auto', cmap=cmap_bg, extent=[self.min_x_cross - self.buffer_x, self.max_x_cross + self.buffer_x, self.max_z, self.max_z + self.buffer_yz], origin='lower', alpha=alpha_level) + ax.axhline(self.max_z, color='k', linestyle='--', alpha=alpha_level) + + ax.set_aspect('equal') + + # Set up the titles + if self.is_plan_view: + ax.set_title('Plan View') + else: + if self.azimuth == 90: + ax.set_title('Cross-Section View (Facing East)') + elif self.azimuth == 180: + ax.set_title('Cross-Section View (Facing South)') + elif self.azimuth == 270: + ax.set_title('Cross-Section View (Facing West)') + elif self.azimuth == 0 or self.azimuth == 360: + ax.set_title('Cross-Section View (Facing North)') + else: + ax.set_title('Cross-Section View (Facing Azimuth: {} degrees)'.format(self.azimuth)) + + # If grid lines added + if self.DEM_loaded: + if self.checkbox_add_grid_lines: + ax.grid(True, linestyle='-', linewidth=0.5, alpha=0.3, color='gray', zorder=-1) + else: + if self.checkbox_add_grid_lines: + # Draw vertical grid lines + for tick in ax.get_xticks(): + ax.plot([tick, tick], [ax.get_ylim()[0], self.max_z], linestyle='-', linewidth=0.5, alpha=0.3, color='gray', zorder=-1) + + # Draw horizontal grid lines + for tick in ax.get_yticks(): + if tick < self.max_z: + ax.plot([ax.get_xlim()[0], ax.get_xlim()[1]], [tick, tick], linestyle='-', linewidth=0.5, alpha=0.3, color='gray', zorder=-1) + + self.canvas.draw() + self.canvases.append(self.canvas) + + def plot_label_within_limits(self, ax, x, y, text, fontsize=8): # Plots the labels inside the plot area + x_min, x_max = ax.get_xlim() # Get x-limits + y_min, y_max = ax.get_ylim() # Get y-limits + + # Calculate the buffer as 5% of the y-axis range (which represents depth or the vertical dimension in the plot) + buffer_y = 0.025 * (y_max - y_min) + + # Adjust the y-coordinate for the label to be slightly below + label_y = y - buffer_y + if label_y < y_min: + label_y = y_min + + # horizontal alignment based on the hole's orientation + if x > (x_max + x_min) / 2: # If the hole is on the right half of the plot + ha = "right" + else: + ha = "left" + + # Plot the label + ax.text(x, label_y, text, fontsize=fontsize, zorder=6, ha=ha) + + + def toggle_view(self): + self.is_plan_view = not self.is_plan_view # Toggle the view attribute + if self.is_plan_view: + self.toggle_view_button.setText("Change to Cross Section View") + else: + self.toggle_view_button.setText("Change to Plan View") + + self.generate_contours_flag = False + self.plot() # Replot the data + + + def activate_hover_tool(self): + # Display a dropdown to select a column + columns = self.data.columns.tolist() + column_name, ok = QInputDialog.getItem(self, "Select a Column", "Choose a column:", columns, 0, False) + + if ok and column_name: + # Activate hover functionality on the cross-section plot + self.add_hover_functionality(column_name) + + def add_hover_functionality(self, column_name): + # Filter the data for the plotted hole_ids + filtered_data = self.data[self.data['hole_id'].isin(self.hole_ids)].reset_index(drop=True) + for canvas in self.canvases: + ax = canvas.figure.axes[0] # the first axis is the cross-section plot + canvas.mpl_connect('motion_notify_event', partial(self.updated_on_hover, data=filtered_data, ax=ax, canvas=canvas, is_plan_view=self.is_plan_view, column_name=column_name)) + + + def updated_on_hover(self, event, data, ax, canvas, is_plan_view, column_name): + # Check if the event is within the axes + if event.inaxes == ax: + + # Compute squared distances based on the view + if is_plan_view: + distances_squared = (data["x"] - event.xdata) ** 2 + (data["y"] - event.ydata) ** 2 + else: + distances_squared = (data["x_cross"] - event.xdata) ** 2 + (data["z"] - event.ydata) ** 2 + + # Get the index of the closest data point + closest_index = distances_squared.idxmin() + + # Print the hover coordinates and closest data point coordinates + print(f"Mouse hover coordinates (canvas): x={event.xdata}, y={event.ydata}") + if is_plan_view: + print(f"Closest data point coordinates: x={data.iloc[closest_index]['x']}, y={data.iloc[closest_index]['y']}") + else: + print(f"Closest data point coordinates: x_cross={data.iloc[closest_index]['x_cross']}, z={data.iloc[closest_index]['z']}") + + # Compute the actual distance to the closest point + closest_distance = np.sqrt(distances_squared[closest_index]) + + # Define a threshold distance + threshold_distance = 5 + + if closest_distance < threshold_distance: + # If there's an existing annotation, remove it + if hasattr(ax, "_last_annotation"): + ax._last_annotation.remove() + + # Get the column name and value for the closest data point + value = data.at[closest_index, column_name] + + # Add the annotation based on the view + if is_plan_view: + annotation = ax.annotate( + f"{column_name}: {value}", + (data.iloc[closest_index]["x"], data.iloc[closest_index]["y"]), + backgroundcolor='#FFFFE0', + color="black", + fontsize='small', + fontstyle='italic', + zorder=6 + ) + else: + annotation = ax.annotate( + f"{column_name}: {value}", + (data.iloc[closest_index]["x_cross"], data.iloc[closest_index]["z"]), + backgroundcolor='#FFFFE0', + color="black", + fontsize='small', + fontstyle='italic', + zorder=6 + ) + + # Store the annotation for later removal + ax._last_annotation = annotation + + # Redraw the figure to show the annotation + canvas.draw() + else: + # Remove any existing annotation if the cursor is not close to a data point + if hasattr(ax, "_last_annotation"): + ax._last_annotation.remove() + delattr(ax, "_last_annotation") + canvas.draw() + + +class ManageAttributesDialog(QDialog): # attribute manager button for cross section + def __init__(self, data, initial_attributes=None, parent=None): + super().__init__(parent) + self.setWindowTitle("Manage Attributes") + + self.data = data + self.attributes = initial_attributes or {} + self.attributes_dict = {} + + self.column_combo_box = QComboBox() + self.column_combo_box.addItem("-- Select a Column --") + self.column_combo_box.addItems([col for col in self.data.columns if col not in ['x', 'y', 'z', 'hole_id']]) + + self.save_button = QPushButton("Save") + self.save_button.setEnabled(False) + + main_content = QWidget() + self.main_layout = QVBoxLayout(main_content) # Set layout for main content + + self.main_layout.addWidget(self.column_combo_box) + self.main_layout.addWidget(self.save_button) + + scroll = QScrollArea(self) # Create a QScrollArea + scroll.setWidget(main_content) # Add the main content to the scroll area + scroll.setWidgetResizable(True) # Make the scroll area content resizable + + layout = QVBoxLayout(self) # Main dialog layout + layout.addWidget(scroll) # Add the scroll area to the main dialog + self.setLayout(layout) + + self.column_combo_box.currentTextChanged.connect(self.update_values_widget) + self.save_button.clicked.connect(self.save) + + self.values_widget = None + + def update_values_widget(self, column): # Update based on user input + if self.values_widget is not None: + self.main_layout.removeWidget(self.values_widget) + sip.delete(self.values_widget) + + if column != "-- Select a Column --": + unique_values = self.data[column].unique() + self.values_widget = QGroupBox("Unique Values") + + layout = QVBoxLayout() + self.values_widget.setLayout(layout) + self.value_widgets = {} + + for value in unique_values: + sub_widget = QWidget() + sub_layout = QHBoxLayout() + sub_widget.setLayout(sub_layout) + + color_button = QPushButton("Choose color") + line_width_spin_box = QDoubleSpinBox() + line_width_spin_box.setValue(4.0) + + sub_layout.addWidget(QLabel(str(value))) + sub_layout.addWidget(color_button) + sub_layout.addWidget(line_width_spin_box) + + self.value_widgets[value] = {"color_button": color_button, "line_width_spin_box": line_width_spin_box} + layout.addWidget(sub_widget) + + color_button.clicked.connect(lambda _, button=color_button: self.choose_color(button)) + + self.main_layout.insertWidget(1, self.values_widget) + self.save_button.setEnabled(True) # Enable save button once unique values are loaded. + + # Resize the dialog to a specific width and height: + self.resize(400, 600) + else: + self.save_button.setEnabled(False) + + def choose_color(self, button): + color = QColorDialog.getColor() + if color.isValid(): + button.setStyleSheet(f"background-color: {color.name()}") + + def save(self): + column_name = self.column_combo_box.currentText() + self.attributes[column_name] = {} + + for value, widgets in self.value_widgets.items(): + color = widgets["color_button"].palette().button().color().name() + if color == '#000000': + color = 'black' + line_width = widgets["line_width_spin_box"].value() + + self.attributes[column_name][value] = {"color": color, "line_width": line_width} + + self.accept() + + msg = QMessageBox() + msg.setIcon(QMessageBox.Information) + msg.setText("Parameters saved!") + msg.setWindowTitle("Success") + msg.exec_() + + def get_attributes_dict(self): + return self.attributes + +class ScatterPlotWindow(QMainWindow): # Scatter plot window + def __init__(self, data): + super(ScatterPlotWindow, self).__init__() + + self.figure = Figure(figsize=(10, 10)) + self.canvas = FigureCanvas(self.figure) + self.setCentralWidget(self.canvas) + self.save_button = QtWidgets.QPushButton(self) + self.save_button.setText("Save plot") + self.save_button.clicked.connect(self.save_plot) + + self.data = data + + def plot_scatter(self, x, y, column, color_ramp=None): + ax = self.figure.add_subplot(111) + + # Clear the current plot + ax.clear() + + # Filter outliers using the IQR method ####### add to settings!! + Q1 = self.data[x].quantile(0.25) + Q3 = self.data[x].quantile(0.75) + IQR = Q3 - Q1 + filtered_data = self.data[(self.data[x] >= Q1 - 1.5 * IQR) & (self.data[x] <= Q3 + 1.5 * IQR)] + + Q1 = self.data[y].quantile(0.25) + Q3 = self.data[y].quantile(0.75) + IQR = Q3 - Q1 + filtered_data = filtered_data[(filtered_data[y] >= Q1 - 1.5 * IQR) & (filtered_data[y] <= Q3 + 1.5 * IQR)] + + # Plot the scatter plot on the subplot + if column: + if pd.api.types.is_numeric_dtype(self.data[column]): + # If column data type is numeric + if color_ramp in ['cool', 'Spectral_r', 'bwr', 'jet', 'viridis_r']: + sc = ax.scatter(self.data[x], self.data[y], c=self.data[column], cmap=plt.get_cmap(color_ramp)) + cbar = plt.colorbar(sc) + cbar.set_label(column) + else: + QMessageBox.warning(self, "Warning", "Please choose a numeric color ramp for a numeric column") + return + else: + # If column data type is categorical + if color_ramp in ['tab10', 'tab20']: + categories = self.data[column].unique() + for category in categories: + data_category = self.data[self.data[column] == category] + ax.scatter(data_category[x], data_category[y], label=category, cmap=plt.get_cmap(color_ramp)) + ax.legend() + else: + QMessageBox.warning(self, "Warning", "Please choose a categorical color ramp for a non-numeric column") + return + else: + ax.scatter(self.data[x], self.data[y], color="black") + + + # Set the title and labels + ax.set_title(f"{x} vs {y}") + ax.set_xlabel(x) + ax.set_ylabel(y) + + # Force the canvas to update and draw the new plot + self.canvas.draw() + + + def save_plot(self): + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + file_name, _ = QFileDialog.getSaveFileName(self,"Save Plot","","All Files (*);;JPEG (*.jpeg);;PNG (*.png)", options=options) + if file_name: + self.figure.savefig(file_name) + + + +class ScatterPlotDialog(QDialog): # Window for scatter plot inputs + def __init__(self, data, selected_hole_ids): + super().__init__() + + self.data = data + self.selected_hole_ids = selected_hole_ids + + self.layout = QVBoxLayout(self) + + self.xaxis_combo = QComboBox() + self.xaxis_combo.addItems(self.data.columns) + self.layout.addWidget(QLabel("Select x-axis column")) + self.layout.addWidget(self.xaxis_combo) + + self.yaxis_combo = QComboBox() + self.yaxis_combo.addItems(self.data.columns) + self.layout.addWidget(QLabel("Select y-axis column")) + self.layout.addWidget(self.yaxis_combo) + + self.column_combo = QComboBox() + self.column_combo.addItem("None") # None option first + self.column_combo.addItems(self.data.columns) + self.column_combo.currentIndexChanged.connect(self.update_color_ramp_combo) + self.layout.addWidget(QLabel("Select column for stylizing points")) + self.layout.addWidget(self.column_combo) + + self.interpolation_combo = QComboBox() + self.interpolation_combo.addItems(['10 equal bins', 'quantile']) + self.layout.addWidget(QLabel("Select interpolation method")) + self.layout.addWidget(self.interpolation_combo) + + self.color_ramp_combo = QComboBox() + self.color_ramp_combo.addItems(['cool', 'Spectral_r', 'bwr', 'jet', 'viridis_r']) + self.layout.addWidget(QLabel("Select color ramp")) + self.layout.addWidget(self.color_ramp_combo) + + plot_button = QPushButton("Plot") + plot_button.clicked.connect(self.plot_scatter) + self.layout.addWidget(plot_button) + + self.setLayout(self.layout) + + # Reference to ScatterPlotWindow + self.scatter_plot_window = None + + def update_color_ramp_combo(self): + column = self.column_combo.currentText() + + # Clear the combo box + self.color_ramp_combo.clear() + + # Add items based on the column data type + if column != "None": + if pd.api.types.is_numeric_dtype(self.data[column]): + self.color_ramp_combo.addItems(['cool', 'Spectral_r', 'bwr', 'jet', 'viridis_r']) + else: + self.color_ramp_combo.addItems(['tab10', 'tab20']) + + def plot_scatter(self): + filtered_data = self.data[self.data['hole_id'].isin(self.selected_hole_ids)] + x = self.xaxis_combo.currentText() + y = self.yaxis_combo.currentText() + column = self.column_combo.currentText() + + # Filter out rows where x, y, or column are zero + if column != "None": + filtered_data = filtered_data[(filtered_data[x] != 0) & (filtered_data[y] != 0) & (filtered_data[column] != 0)] + else: + filtered_data = filtered_data[(filtered_data[x] != 0) & (filtered_data[y] != 0)] + + if column == "None": # Handle the None option + column = None + + interpolation = self.interpolation_combo.currentText() + color_ramp = self.color_ramp_combo.currentText() if self.color_ramp_combo.currentText() != "None" else None + + self.scatter_plot_window = ScatterPlotWindow(filtered_data) + self.scatter_plot_window.plot_scatter(x, y, column, color_ramp) + self.scatter_plot_window.show() + + # Close the dialog after the scatter plot window is shown + self.close() + + +class StereonetPlotWindow: # Stereonet window + def __init__(self, data_structure, strike_column, dip_column, plot_type, color_coding_column=None): + self.data_structure = data_structure + self.strike_column = strike_column + self.dip_column = dip_column + self.plot_type = plot_type + self.color_coding_column = color_coding_column if color_coding_column != "None" else None + self.create_stereonet_plot() + + def create_stereonet_plot(self): + fig = plt.figure(figsize=(8, 8)) + ax = fig.add_subplot(111, projection='stereonet') + + if self.color_coding_column is not None: # If color coding column is not 'None' + # Use the tab10 color map + cmap = plt.get_cmap("tab10") + color_coding_data = self.data_structure[self.color_coding_column] + categories = pd.Categorical(color_coding_data).categories + color_code_dict = {category: cmap(i % cmap.N) for i, category in enumerate(categories)} + colors = [color_code_dict[val] for val in color_coding_data] + else: + colors = ['black'] * len(self.data_structure) + + for strike, dip, color in zip(self.data_structure[self.strike_column], self.data_structure[self.dip_column], colors): + if self.plot_type in ["Poles", "Both"]: + ax.pole(strike, dip, 'o', color=color) + if self.plot_type in ["Planes", "Both"]: + ax.plane(strike, dip, '-', color=color) + + # If there is color coding, add a legend + if self.color_coding_column is not None: + legend_handles = [] + for category in categories: + legend_handles.append(mpatches.Patch(color=color_code_dict[category], label=category)) + ax.legend(handles=legend_handles, loc='upper left') + + ax.grid(True, alpha=0.5) + + plt.show() + + + +class StereonetDialog(QDialog): # Stereonet user inputs + def __init__(self, parent=None): + super(StereonetDialog, self).__init__(parent) + + self.strike_label = QLabel("Strike Column:", self) + self.strike_combobox = QComboBox(self) + + self.dip_label = QLabel("Dip Column:", self) + self.dip_combobox = QComboBox(self) + + self.type_label = QLabel("Plot Type:", self) + self.type_combobox = QComboBox(self) + self.type_combobox.addItems(['Poles', 'Planes', 'Both']) + + self.color_coding_label = QLabel("Color Coding (optional):", self) + self.color_coding_combobox = QComboBox(self) + self.color_coding_combobox.addItem("None") + + grid_layout = QGridLayout(self) + grid_layout.addWidget(self.strike_label, 0, 0) + grid_layout.addWidget(self.strike_combobox, 0, 1) + grid_layout.addWidget(self.dip_label, 1, 0) + grid_layout.addWidget(self.dip_combobox, 1, 1) + grid_layout.addWidget(self.type_label, 2, 0) + grid_layout.addWidget(self.type_combobox, 2, 1) + grid_layout.addWidget(self.color_coding_label, 3, 0) + grid_layout.addWidget(self.color_coding_combobox, 3, 1) + + button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self) + button_box.accepted.connect(self.accept) + button_box.rejected.connect(self.reject) + grid_layout.addWidget(button_box, 4, 0, 1, 2) + + self.setLayout(grid_layout) + self.setWindowTitle("Stereonet Plot Configuration") + + +class RosePlot: # Rose plot window + def __init__(self, df, hole_ids): + self.df = df + self.hole_ids = hole_ids + + def plot(self, strike_column, dip_column, color_column=None): + # Filter DataFrame based on selected hole IDs + df = self.df[self.df['hole_id'].isin(self.hole_ids)] + + # Convert strike angles to radians + strike_angles = np.radians(df[strike_column]) + + # Determine colors for each row in DataFrame + if color_column: + unique_values = df[color_column].unique() + colormap = plt.cm.get_cmap('viridis', len(unique_values)) + color_dict = dict(zip(unique_values, [colormap(i) for i in range(len(unique_values))])) + colors = df[color_column].map(color_dict) + else: + colors = 'blue' + + # Create rose diagram + plt.figure(figsize=(8, 8)) + ax = plt.subplot(111, projection='polar') + + # Bin strike angles and get the counts for each bin + strike_bins = np.linspace(0, 2*np.pi, 36) + counts, bin_edges = np.histogram(strike_angles, bins=strike_bins) + + # Compute bin centers + bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2.0 + + ax.bar(bin_centers, counts, color=colors, width=2*np.pi/36) + + ax.set_theta_zero_location('N') + ax.set_theta_direction(-1) + + # If there is color coding, add a legend + if color_column: + legend_handles = [] + for category, color in color_dict.items(): + legend_handles.append(mpatches.Patch(color=color, label=category)) + ax.legend(handles=legend_handles, loc='upper left') + + plt.show() + + + def dialog(self): + # Create and configure dialog + dialog = RoseDiagramDialog() + + # Populate combo boxes with column names from DataFrame + dialog.strike_combobox.addItems(self.df.columns) + dialog.dip_combobox.addItems(self.df.columns) + dialog.color_coding_combobox.addItems(['None'] + list(self.df.columns)) + + # Show dialog, user to make a selection + result = dialog.exec_() + if result: + # Get selected columns + strike_column = dialog.strike_combobox.currentText() + dip_column = dialog.dip_combobox.currentText() + color_column = dialog.color_coding_combobox.currentText() if dialog.color_coding_combobox.currentText() != 'None' else None + + # Call plot function + self.plot(strike_column, dip_column, color_column) + +class RoseDiagramDialog(QDialog): # Rose diagram window + def __init__(self, parent=None): + super(RoseDiagramDialog, self).__init__(parent) + + self.strike_label = QLabel("Strike Column:", self) + self.strike_combobox = QComboBox(self) + + self.dip_label = QLabel("Dip Column:", self) + self.dip_combobox = QComboBox(self) + + self.color_coding_label = QLabel("Color Coding (optional):", self) + self.color_coding_combobox = QComboBox(self) + self.color_coding_combobox.addItem("None") + + grid_layout = QGridLayout(self) + grid_layout.addWidget(self.strike_label, 0, 0) + grid_layout.addWidget(self.strike_combobox, 0, 1) + grid_layout.addWidget(self.dip_label, 1, 0) + grid_layout.addWidget(self.dip_combobox, 1, 1) + grid_layout.addWidget(self.color_coding_label, 2, 0) + grid_layout.addWidget(self.color_coding_combobox, 2, 1) + + button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self) + button_box.accepted.connect(self.accept) + button_box.rejected.connect(self.reject) + grid_layout.addWidget(button_box, 3, 0, 1, 2) + + self.setLayout(grid_layout) + self.setWindowTitle("Rose Diagram Configuration") + + + +class FactorAnalysisDialog(QDialog): # Factor analysis window + create_factor_analysis = pyqtSignal(int, str) + + def __init__(self, parent=None): + super().__init__(parent) + self.parent = parent + self.setWindowTitle("Factor Analysis") + + self.layout = QVBoxLayout(self) + + # User inputs + self.factors_label = QLabel("Number of factors:") + self.factors_spin_box = QSpinBox() + self.factors_spin_box.setMinimum(1) + self.factors_spin_box.setMaximum(10) + + self.column_ending_label = QLabel("Column ending tag:") + self.column_ending_line_edit = QLineEdit() + + self.factor_scores_check_box = QCheckBox("Get Factor Scores") + self.factor_scores_check_box.setChecked(False) + + # Adding threshold input field + self.threshold_label = QLabel("Factor Contribution Threshold:") + self.threshold_line_edit = QLineEdit() + self.threshold_line_edit.setText("0.35") # Default threshold value as placeholder + + self.run_button = QPushButton("Run Factor Analysis") + self.run_button.clicked.connect(self.run_factor_analysis) + + self.layout.addWidget(self.factors_label) + self.layout.addWidget(self.factors_spin_box) + self.layout.addWidget(self.column_ending_label) + self.layout.addWidget(self.column_ending_line_edit) + self.layout.addWidget(self.factor_scores_check_box) + + # Adding the threshold elements to the layout + self.layout.addWidget(self.threshold_label) + self.layout.addWidget(self.threshold_line_edit) + + self.layout.addWidget(self.run_button) + + + + def run_factor_analysis(self): + # Collect user values + number_of_factors = self.factors_spin_box.value() + column_ending_tag = self.column_ending_line_edit.text() + get_factor_scores = self.factor_scores_check_box.isChecked() + + selected_hole_ids = [] + for index in range(self.parent.model_geochem.rowCount()): + item = self.parent.model_geochem.item(index) + if item.checkState() == Qt.Checked: # If the hole_id is checked + hole_id = item.text() + selected_hole_ids.append(hole_id) + + selected_columns = [col for col in self.parent.data_geochem.columns if col.endswith(column_ending_tag)] + + if not selected_hole_ids: + QMessageBox.warning(self, "No Holes Selected", "Please select at least one hole to run the factor analysis.") + return + + if not selected_columns: + QMessageBox.warning(self, "No Matching Columns", "No columns match the provided ending tag. Please provide a valid ending tag.") + return + + selected_data = self.parent.data_geochem[self.parent.data_geochem['hole_id'].isin(selected_hole_ids)][selected_columns] + + if selected_data.empty: + QMessageBox.warning(self, "No Matching Data", "No data matches the selected holes and column ending tag. Please select different holes or provide a different ending tag.") + return + + + # Scale the data with mean imputation ##### change from mean imputation? + scaler = StandardScaler() + scaled_data = pd.DataFrame(scaler.fit_transform(selected_data.fillna(0)), columns=selected_data.columns) ### This one for column means: scaled_data = pd.DataFrame(scaler.fit_transform(selected_data.fillna(selected_data.mean())), columns=selected_data.columns) + + + if scaled_data.isna().sum().sum() > 0: + QMessageBox.warning(self, "NaNs in Scaled Data", "The scaled data contains NaN values. Please handle these before running factor analysis.") + return # Stop execution + + if np.isinf(scaled_data).sum().sum() > 0: + QMessageBox.warning(self, "Infs in Scaled Data", "The scaled data contains inf values. Please handle these before running factor analysis.") + return # Stop execution + + # Check if the correlation matrix contains NaNs or infs + corr_mtx = scaled_data.corr() + if corr_mtx.isna().sum().sum() > 0: + QMessageBox.warning(self, "NaNs in Correlation Matrix", "The correlation matrix contains NaN values. Check your data for columns with constant values.") + return # Stop execution + + if np.isinf(corr_mtx).sum().sum() > 0: + QMessageBox.warning(self, "Infs in Correlation Matrix", "The correlation matrix contains inf values. Please handle these before running factor analysis.") + return + + # Run the factor analysis on the scaled data + fa = FactorAnalyzer(n_factors=number_of_factors, rotation='varimax') + fa.fit(scaled_data) + + # Get the factor loadings and variance + loadings = fa.loadings_ + variance = fa.get_factor_variance() + + # Save the loadings to a DataFrame + factor_results = pd.DataFrame(loadings, columns=[f'Factor {i+1}' for i in range(number_of_factors)], index=selected_columns) + + # Determine the variables for each factor + threshold = float(self.threshold_line_edit.text()) + variable_rows = [] + for i in range(number_of_factors): + factor = f'Factor {i+1}' + variables = factor_results.index[factor_results[factor].abs() > threshold].tolist() + variable_rows.append(pd.Series([', '.join(variables)], index=[factor], name=f'{factor} Variables')) + + # Create a DataFrame for the variance + variance_df = pd.DataFrame([variance[0]], columns=[f'Factor {i+1}' for i in range(number_of_factors)], index=['Variance']) + + hole_ids_df = pd.DataFrame([', '.join(selected_hole_ids)], columns=['selected_hole_ids'], index=['']) + + # Concatenate the factor results and variance DataFrames + factor_results = pd.concat([factor_results] + [variance_df] + variable_rows + [hole_ids_df]) + + if get_factor_scores: + factor_scores = fa.transform(scaled_data) + factor_scores_df = pd.DataFrame(factor_scores, columns=[f'Factor {i+1}' for i in range(number_of_factors)]) + + # Add the factor scores as new columns in the original DataFrame + for i in range(1, number_of_factors+1): + column_name = f'Factor {i} Score' + self.parent.data_geochem[column_name] = factor_scores_df[f'Factor {i}'] + nan_rows = self.parent.data_geochem[selected_columns].isnull().all(axis=1) + self.parent.data_geochem.loc[nan_rows, column_name] = np.nan + + # Prompt the user to save the factor scores to a CSV + filename, _ = QFileDialog.getSaveFileName(self, "Save Factor Scores", "", "CSV Files (*.csv)") + if filename: + self.parent.data_geochem[self.parent.data_geochem['hole_id'].isin(selected_hole_ids)].to_csv(filename, index=False) + + # Prompt the user to save the DataFrame to a CSV + filename, _ = QFileDialog.getSaveFileName(self, "Save Factor Loading Results", "", "CSV Files (*.csv)") + if filename: + factor_results.to_csv(filename, index=True) + + # Emit the signal at the end + self.create_factor_analysis.emit(number_of_factors, column_ending_tag) + + self.close() + + +class CustomPlotWindow(QWidget): # Custom plot window + def __init__(self, json_file_path, data): + super().__init__() + + # Open and load the JSON file + with open(json_file_path, 'r') as f: + self.plot_info = json.load(f) + + self.data = data + self.extract_plot_limits_from_json() + + self.figure = Figure() + self.canvas = FigureCanvas(self.figure) + + self.layout = QVBoxLayout(self) + self.layout.addWidget(self.canvas) + + self.setLayout(self.layout) + + def extract_plot_limits_from_json(self): + all_x_values = [] + all_y_values = [] + for polygon in self.plot_info.get('polygons', []): + for point in polygon['points']: + all_x_values.append(point[0]) + all_y_values.append(point[1]) + x_min, x_max = min(all_x_values), max(all_x_values) + y_min, y_max = min(all_y_values), max(all_y_values) + return (x_min, x_max), (y_min, y_max) + + + def plot_custom(self, x, y, log_x, log_y, color_column=None, color_ramp=None, data_points=True): + # Clear the current contents of the figure + self.figure.clear() + + # Create an axis + ax = self.figure.add_subplot(111) + x_limits, y_limits = self.extract_plot_limits_from_json() + ax.set_xlim(x_limits) + ax.set_ylim(y_limits) + + # Plot the data + if x and y and data_points: + if color_column: + if pd.api.types.is_numeric_dtype(self.data[color_column]): + sc = ax.scatter(self.data[x], self.data[y], c=self.data[color_column], cmap=plt.get_cmap(color_ramp)) + cbar = plt.colorbar(sc) + cbar.set_label(color_column) + else: + categories = self.data[color_column].unique() + for category in categories: + data_category = self.data[self.data[color_column] == category] + ax.scatter(data_category[x], data_category[y], label=category, cmap=plt.get_cmap(color_ramp)) + ax.legend() + else: + ax.scatter(self.data[x], self.data[y]) + + # Use the plot information from the JSON file + ax.set_title(self.plot_info.get('title', '')) + ax.set_xlabel(self.plot_info.get('x_label', '')) + ax.set_ylabel(self.plot_info.get('y_label', '')) + + + # Set the x scale + if log_x: + ax.set_xscale('log') + + # Set the y scale + if log_y: + ax.set_yscale('log') + + # Add the labels + labels = self.plot_info.get('labels', {}) + for label, (x_pos, y_pos) in labels.items(): + ax.text(x_pos, y_pos, label, ha='center', va='center', fontsize=8) + + # Plot the line segments + for line_segment in self.plot_info.get('lines', []): + print(line_segment) + ax.plot(*zip(*line_segment), color='black') + + # Extract polygons + polygons = self.plot_info.get('polygons', []) + + # Plot each polygon + for polygon in polygons: + points = polygon['points'] + style = polygon['style'] + + # Extract style information + fillColor = style.get('fillColor', '#FFFFFF') + fillOpacity = style.get('fillOpacity', 1) + borderColor = style.get('borderColor', '#000000') + borderWidth = style.get('borderWidth', 1) + + # Plot the filled polygon + ax.fill(*zip(*points), color=fillColor, alpha=fillOpacity) + + # Plot the border of the polygon + ax.plot(*zip(*points, points[0]), color=borderColor, linewidth=borderWidth) + + # Add label/name to the polygon + if "name" in polygon and "label" in polygon: + label_info = polygon['label'] + ax.annotate(polygon['name'], + tuple(label_info['position']), + color=label_info.get('color', 'black'), + ha=label_info.get('ha', 'center'), + va=label_info.get('va', 'center'), + fontsize=label_info.get('fontsize', 9)) + + if x and y: + self.data['polygon value'] = "None" + for index, row in self.data.iterrows(): + point = (row[x], row[y]) + for polygon in polygons: + poly_path = Path(polygon['points']) + if poly_path.contains_point(point): + self.data.at[index, 'polygon value'] = polygon['name'] + break + + # Apply the formatter + formatter = FuncFormatter(format_func) + ax.xaxis.set_major_formatter(formatter) + ax.yaxis.set_major_formatter(formatter) + + # Redraw the canvas + self.canvas.draw() + + self.close() + +def format_func(value, tick_number): + # Format the numbers as 0.01, 0.1, 1, etc. + return f"{value:.2f}" + +class CustomPlotDialog(QMainWindow): # Custom plot user inputs + def __init__(self, data, json_file_path, parent=None): + super().__init__(parent) + + self.data = data + self.json_file_path = json_file_path + + self.plot_window = CustomPlotWindow(json_file_path, data) + + self.x_select = QComboBox() + self.x_select.addItems(list(self.data.columns)) + self.y_select = QComboBox() + self.y_select.addItems(list(self.data.columns)) + + self.log_x_checkbox = QCheckBox('Logarithmic X-axis') + self.log_y_checkbox = QCheckBox('Logarithmic Y-axis') + + self.plot_button = QPushButton("Plot") + self.plot_button.clicked.connect(self.plot) + self.save_csv_button = QPushButton("Save CSV") + self.save_csv_button.clicked.connect(self.save_to_csv) + + + # create a central widget to hold our layout + central_widget = QWidget() + layout = QVBoxLayout(central_widget) + + layout.addWidget(QLabel("Select X-axis:")) + layout.addWidget(self.x_select) + layout.addWidget(self.log_x_checkbox) + layout.addWidget(QLabel("Select Y-axis:")) + layout.addWidget(self.y_select) + layout.addWidget(self.log_y_checkbox) + layout.addWidget(self.plot_button) + layout.addWidget(self.plot_window.canvas) + layout.addWidget(self.save_csv_button) + + # Add color column selection + self.color_select = QComboBox() + self.color_select.addItem("None") + self.color_select.addItems(list(self.data.columns)) + self.color_select.currentIndexChanged.connect(self.update_color_ramp_combo) + layout.addWidget(QLabel("Select color column:")) + layout.addWidget(self.color_select) + + # Add color ramp selection + self.color_ramp_select = QComboBox() + self.update_color_ramp_combo() + layout.addWidget(QLabel("Select color ramp:")) + layout.addWidget(self.color_ramp_select) + + # Add checkbox for polygon plotting + self.polygon_checkbox = QCheckBox("Attribute to Plot Polygons") # attributes each point to the polygon it falls in + layout.addWidget(self.polygon_checkbox) + + # set the central widget + self.setCentralWidget(central_widget) + + # Draw a blank plot for preview + self.plot_window.figure.clear() + ax = self.plot_window.figure.add_subplot(111) + x_limits, y_limits = self.plot_window.extract_plot_limits_from_json() + ax.set_xlim(x_limits) + ax.set_ylim(y_limits) + self.plot_window.canvas.draw() + + self.plot_window.plot_custom("", "", False, False, data_points=False) + + + self.plot_window.plot_custom("", "", False, False, data_points=False) + + self.resize(800, 800) + + def update_color_ramp_combo(self): + column = self.color_select.currentText() + + # Clear the combo box + self.color_ramp_select.clear() + + # Add the appropriate items based on the column data type + if column != "None": + if pd.api.types.is_numeric_dtype(self.data[column]): + self.color_ramp_select.addItems(['cool', 'Spectral_r', 'bwr', 'jet', 'viridis_r']) + else: + self.color_ramp_select.addItems(['tab10', 'tab20']) + + def plot(self): # Plotting Function + x = self.x_select.currentText() + y = self.y_select.currentText() + color_column = self.color_select.currentText() if self.color_select.currentText() != "None" else None + color_ramp = self.color_ramp_select.currentText() if self.color_ramp_select.currentText() != "None" else None + log_x = self.log_x_checkbox.isChecked() + log_y = self.log_y_checkbox.isChecked() + self.plot_window.plot_custom(x, y, log_x, log_y, color_column, color_ramp) + + def save_to_csv(self): + if self.polygon_checkbox.isChecked(): + csv_file_path, _ = QFileDialog.getSaveFileName(self, "Save CSV", "", "CSV files (*.csv)") + if csv_file_path: + self.plot_window.data.to_csv(csv_file_path, index=False) + QMessageBox.information(self, "Success", f"File saved to {csv_file_path}") + + +class DesurveyCalc(QDialog): # Desurvey settings window + def __init__(self, parent=None): + super(DesurveyCalc, self).__init__(parent) + self.initUI() + + def initUI(self): + layout = QVBoxLayout() + + # --- Drill hole data --- + self.btn_drill_data = QPushButton('Upload drill hole data', self) + self.btn_drill_data.clicked.connect(self.load_drill_data_csv) + layout.addWidget(self.btn_drill_data) + + self.drill_columns_label = QLabel("Choose columns for drill hole data:") + layout.addWidget(self.drill_columns_label) + + # Dropdowns for column selection for drill hole data + self.cb_hole_id = QComboBox(self) + self.cb_depth = QComboBox(self) + layout.addWidget(QLabel("Hole ID:")) + layout.addWidget(self.cb_hole_id) + layout.addWidget(QLabel("Depth:")) + layout.addWidget(self.cb_depth) + + # --- Survey data --- + self.btn_survey_data = QPushButton('Upload survey data', self) + self.btn_survey_data.clicked.connect(self.load_survey_data_csv) + layout.addWidget(self.btn_survey_data) + + self.survey_columns_label = QLabel("Choose columns for survey data:") + layout.addWidget(self.survey_columns_label) + + self.cb_survey_hole_id = QComboBox(self) + self.cb_depth_sur = QComboBox(self) + self.cb_azimuth = QComboBox(self) + self.cb_dip = QComboBox(self) + + + layout.addWidget(QLabel("Hole ID:")) + layout.addWidget(self.cb_survey_hole_id) + layout.addWidget(QLabel("Depth:")) + layout.addWidget(self.cb_depth_sur) + layout.addWidget(QLabel("Azimuth:")) + layout.addWidget(self.cb_azimuth) + layout.addWidget(QLabel("Dip:")) + layout.addWidget(self.cb_dip) + + + # --- Collar data --- + self.btn_collar_data = QPushButton('Upload collar data', self) + self.btn_collar_data.clicked.connect(self.load_collar_data_csv) + layout.addWidget(self.btn_collar_data) + + self.collar_columns_label = QLabel("Choose columns for collar data:") + layout.addWidget(self.collar_columns_label) + + self.cb_collar_hole_id = QComboBox(self) + self.cb_easting = QComboBox(self) + self.cb_northing = QComboBox(self) + self.cb_elevation = QComboBox(self) + + layout.addWidget(QLabel("Hole ID:")) + layout.addWidget(self.cb_collar_hole_id) + layout.addWidget(QLabel("Easting (X):")) + layout.addWidget(self.cb_easting) + layout.addWidget(QLabel("Northing (Y):")) + layout.addWidget(self.cb_northing) + layout.addWidget(QLabel("Elevation (Z):")) + layout.addWidget(self.cb_elevation) + + # Add the "Get Desurveyed CSV" button + self.btn_get_csv = QPushButton('Get Desurveyed CSV', self) + self.btn_get_csv.clicked.connect(self.generate_csv) + layout.addWidget(self.btn_get_csv) + + self.setLayout(layout) + + def generate_csv(self): + print("generate_csv triggered!") + + result_data = self.calculate_desurveyed_data() + + if not result_data.empty: + options = QFileDialog.Options() + filePath, _ = QFileDialog.getSaveFileName(self, "Save File", "", "CSV Files (*.csv);;All Files (*)", options=options) + + if filePath: + # Ensuring the file extension + if not filePath.endswith('.csv'): + filePath += '.csv' + + result_data.to_csv(filePath, index=False) + QMessageBox.information(self, "Success", "Desurveyed data saved successfully!") + else: + QMessageBox.warning(self, "Cancelled", "Save operation was cancelled!") + else: + QMessageBox.warning(self, "Error", "Failed to generate desurveyed data!") + + + def load_drill_data_csv(self): + fname, _ = QFileDialog.getOpenFileName(self, 'Open file', '/home') + if fname: + self.drill_data = pd.read_csv(fname) + self.update_combo_boxes(self.drill_data, [self.cb_hole_id, self.cb_depth]) + + def load_survey_data_csv(self): + fname, _ = QFileDialog.getOpenFileName(self, 'Open file', '/home') + if fname: + self.survey_data = pd.read_csv(fname) + self.update_combo_boxes(self.survey_data, + [self.cb_depth_sur, self.cb_azimuth, self.cb_dip, self.cb_survey_hole_id]) + + def load_collar_data_csv(self): + fname, _ = QFileDialog.getOpenFileName(self, 'Open file', '/home') + if fname: + self.collar_data = pd.read_csv(fname) + self.update_combo_boxes(self.collar_data, [self.cb_collar_hole_id, self.cb_easting, self.cb_northing, self.cb_elevation]) + + def update_combo_boxes(self, data, combo_boxes): + columns = data.columns + for cb in combo_boxes: + cb.clear() + cb.addItems(columns) + + @staticmethod + def vlookup_approx(value, lookup_array, result_array): + """ + Emulate the behavior of VLOOKUP with TRUE flag for approximate match. + Return the closest value that is less than or equal to the lookup value. + If no match is found, return the last value in the result_array. + """ + matches = [i for i, x in enumerate(lookup_array) if x <= value] + if matches: + index = matches[-1] + return result_array[index] + else: + return result_array[-1] # Return the last value if no match is found + + + def calculate_desurveyed_data(self): + print("calculate_desurveyed_data function started") + print(self.drill_data.columns) + print(self.survey_data.columns) + + # Extracting data from the UI elements + hole_id_col_drill = self.cb_hole_id.currentText() + depth_col_drill = self.cb_depth.currentText() + + hole_id_col_survey = self.cb_survey_hole_id.currentText() + depth_col_survey = self.cb_depth_sur.currentText() + azimuth_col_survey = self.cb_azimuth.currentText() + dip_col_survey = self.cb_dip.currentText() + + hole_id_col_collar = self.cb_collar_hole_id.currentText() + easting_col_collar = self.cb_easting.currentText() + northing_col_collar = self.cb_northing.currentText() + elevation_col_collar = self.cb_elevation.currentText() + + self.drill_data['x'] = np.nan + self.drill_data['y'] = np.nan + self.drill_data['z'] = np.nan + + unique_holes = self.drill_data[hole_id_col_drill].unique() + print(f"Found {len(unique_holes)} unique hole IDs: {unique_holes}") + + try: + for hole_id in unique_holes: + # Filter collar, survey, and drill data by hole ID + collar_data_filtered = self.collar_data[self.collar_data[hole_id_col_collar] == hole_id] + survey_data_filtered = self.survey_data[self.survey_data[hole_id_col_survey] == hole_id] + drill_data_filtered = self.drill_data[self.drill_data[hole_id_col_drill] == hole_id] + + # Identify the minimum depth value for this hole + min_depth = drill_data_filtered[depth_col_drill].min() + + # Initial coordinates for each hole + prev_x = collar_data_filtered.iloc[0][easting_col_collar] + prev_y = collar_data_filtered.iloc[0][northing_col_collar] + prev_z = collar_data_filtered.iloc[0][elevation_col_collar] + + # Populate the row corresponding to the minimum depth value with collar coordinates + idx_in_main_df = self.drill_data.index[(self.drill_data[hole_id_col_drill] == hole_id) & (self.drill_data[depth_col_drill] == min_depth)].tolist()[0] + self.drill_data.at[idx_in_main_df, 'x'] = prev_x + self.drill_data.at[idx_in_main_df, 'y'] = prev_y + self.drill_data.at[idx_in_main_df, 'z'] = prev_z + + # Initialize coordinates + prev_depth_F2 = min_depth + # Loop through drill data for the current hole + for index in range(len(drill_data_filtered)): + next_row = drill_data_filtered.iloc[index] + depth_F3 = next_row[depth_col_drill] + + # Get values for depth using the vlookup approximation + azimuth_F3 = self.vlookup_approx(depth_F3, survey_data_filtered[depth_col_survey].values, survey_data_filtered[azimuth_col_survey].values) + dip_F3 = self.vlookup_approx(depth_F3, survey_data_filtered[depth_col_survey].values, survey_data_filtered[dip_col_survey].values) + + # Apply the calculation (geometric transformation) for x, y, z using the depth difference + delta_x = (depth_F3 - prev_depth_F2) * np.sin(np.radians(azimuth_F3)) * np.cos(np.radians(dip_F3)) + delta_y = (depth_F3 - prev_depth_F2) * np.cos(np.radians(azimuth_F3)) * np.cos(np.radians(dip_F3)) + delta_z = (depth_F3 - prev_depth_F2) * np.sin(np.radians(dip_F3)) + + # Cumulatively add the deltas to the previous coordinates + new_x = prev_x + delta_x + new_y = prev_y + delta_y + new_z = prev_z + delta_z + + # Store these new values for the next iteration + prev_x, prev_y, prev_z = new_x, new_y, new_z + prev_depth_F2 = depth_F3 # Update depth for next iteration + + # Update the original DataFrame with new x, y, and z values + idx_in_main_df = self.drill_data.index[(self.drill_data[hole_id_col_drill] == hole_id) & (self.drill_data[depth_col_drill] == depth_F3)].tolist()[0] + self.drill_data.at[idx_in_main_df, 'x'] = new_x + self.drill_data.at[idx_in_main_df, 'y'] = new_y + self.drill_data.at[idx_in_main_df, 'z'] = new_z + + except Exception as e: + # Convert the exception message to a string before concatenating + QMessageBox.warning(self, "Error", f"Failed to generate desurveyed data! Error: {str(e)}") + return self.drill_data + + return self.drill_data + +class PlotSettingsDialog(QDialog): # Settings window for cross section plot + def __init__( + self, hole_ids, remove_outliers=True, remove_outliers_auxiliary=False, + add_grid_lines=False, upper_quantile=75, lower_quantile=25, IQR=3, + x_buffer=120, y_buffer=0.05, line_width=4, selected_hole_ids_for_labels=None + ): + super(PlotSettingsDialog, self).__init__() + self.hole_ids = hole_ids + + self.setWindowTitle('Plot Settings') + + # Create layout managers + main_layout = QVBoxLayout() + + # Create UI Elements for "Remove Outliers" + self.outliers_layout = QVBoxLayout() + self.checkbox_remove_outliers = QCheckBox("Remove Outliers?") + + # Create the new checkbox for "Apply to Auxiliary Bar Plot" + self.checkbox_aux_plot = QCheckBox("Apply to Auxiliary Bar Plot") + + # Create a horizontal layout to contain both checkboxes side by side + self.checkboxes_layout = QHBoxLayout() + self.checkboxes_layout.addWidget(self.checkbox_remove_outliers) + self.checkboxes_layout.addWidget(self.checkbox_aux_plot) + + # Add the horizontal layout containing checkboxes to the outliers layout + self.outliers_layout.addLayout(self.checkboxes_layout) + + self.line_edit_upper_quantile = QLineEdit() + self.line_edit_lower_quantile = QLineEdit() + self.line_edit_IQR = QLineEdit() + self.outliers_layout.addWidget(self.checkbox_remove_outliers) + self.outliers_layout.addWidget(QLabel(" Assign Upper Quantile:")) + self.outliers_layout.addWidget(self.line_edit_upper_quantile) + self.outliers_layout.addWidget(QLabel("Assign Lower Quantile:")) + self.outliers_layout.addWidget(self.line_edit_lower_quantile) + self.outliers_layout.addWidget(QLabel("Assign IQR Scaling Factor:")) + self.outliers_layout.addWidget(self.line_edit_IQR) + + # Create UI Elements for "Define x and y Axis Limits" + self.axis_limits_layout = QVBoxLayout() + self.line_edit_x_buffer = QLineEdit() + self.line_edit_y_buffer = QLineEdit() + self.axis_limits_layout.addWidget(QLabel("X axis Buffer:")) + self.axis_limits_layout.addWidget(self.line_edit_x_buffer) + self.axis_limits_layout.addWidget(QLabel("Y axis Buffer:")) + self.axis_limits_layout.addWidget(self.line_edit_y_buffer) + + self.line_width_layout = QVBoxLayout() + self.line_edit_line_width = QLineEdit() + self.line_width_layout.addWidget(QLabel("Line Width (1-5):")) + self.line_width_layout.addWidget(self.line_edit_line_width) + + self.hole_labels_layout = QVBoxLayout() + self.hole_labels_layout.addWidget(QLabel("hole_id labels")) + + # Create a QListView to display hole_ids with checkboxes + self.hole_id_list_view = QListView() + self.hole_id_list_model = QStandardItemModel(self.hole_id_list_view) + + #"Select All/Deselect All" checkbox + self.select_all_checkbox = QCheckBox("Select All/Deselect All") + self.hole_labels_layout.addWidget(self.select_all_checkbox) + + # add a "add grid lines" checkbox + self.grid_layout = QVBoxLayout() + self.checkbox_add_grid_lines = QCheckBox("Add Grid Lines") + self.grid_layout.addWidget(self.checkbox_add_grid_lines) + + # Add hole_ids to the list view with a checkbox next to each + for hole_id in self.hole_ids: + item = QStandardItem(hole_id) + item.setCheckable(True) + item.setCheckState(Qt.Checked) # Check all items by default + self.hole_id_list_model.appendRow(item) + + self.hole_id_list_view.setModel(self.hole_id_list_model) + self.hole_labels_layout.addWidget(self.hole_id_list_view) + + # Add layouts to main layout + main_layout.addLayout(self.outliers_layout) + main_layout.addLayout(self.axis_limits_layout) + main_layout.addLayout(self.line_width_layout) + main_layout.addLayout(self.hole_labels_layout) + main_layout.addLayout(self.grid_layout) + + # Set the main layout + self.setLayout(main_layout) + + # Initialize default values and connect signals + self.connect_signals() + self.select_all_checkbox.stateChanged.connect(self.toggle_select_all_hole_ids) + + self.ok_button = QPushButton("OK") + self.cancel_button = QPushButton("Cancel") + button_layout = QHBoxLayout() + button_layout.addWidget(self.ok_button) + button_layout.addWidget(self.cancel_button) + main_layout.addLayout(button_layout) + + # Set the initial state of the dialog's controls using passed-in settings + self.init_defaults( + remove_outliers=remove_outliers, + remove_outliers_auxiliary=remove_outliers_auxiliary, + add_grid_lines=add_grid_lines, + upper_quantile=upper_quantile, + lower_quantile=lower_quantile, + IQR=IQR, + x_buffer=x_buffer, + y_buffer=y_buffer, + line_width=line_width, + selected_hole_ids_for_labels=selected_hole_ids_for_labels + ) + + # Connect signals for buttons + self.ok_button.clicked.connect(self.accept) + self.cancel_button.clicked.connect(self.reject) + + def init_defaults(self, + remove_outliers=True, + remove_outliers_auxiliary=False, + add_grid_lines=False, + upper_quantile=75, + lower_quantile=25, + IQR=3, + x_buffer=120, + y_buffer=0.05, + line_width=4, + selected_hole_ids_for_labels=None): + # Set defaults or use passed-in settings + self.checkbox_remove_outliers.setChecked(remove_outliers) + self.checkbox_aux_plot.setChecked(remove_outliers_auxiliary) + self.checkbox_add_grid_lines.setChecked(add_grid_lines) + self.line_edit_upper_quantile.setText(str(upper_quantile)) + self.line_edit_lower_quantile.setText(str(lower_quantile)) + self.line_edit_IQR.setText(str(IQR)) + self.line_edit_x_buffer.setText(str(x_buffer)) + self.line_edit_y_buffer.setText(str(y_buffer)) + self.line_edit_line_width.setText(str(line_width)) + + # Initialize hole_id list view checkboxes + if selected_hole_ids_for_labels is not None: + for row in range(self.hole_id_list_model.rowCount()): + item = self.hole_id_list_model.item(row) + if item.text() in selected_hole_ids_for_labels: + item.setCheckState(Qt.Checked) + else: + item.setCheckState(Qt.Unchecked) + + + def toggle_select_all_hole_ids(self, state): + # Select or deselect all hole_id checkboxes based on the state of the select_all_checkbox + for row in range(self.hole_id_list_model.rowCount()): + item = self.hole_id_list_model.item(row) + item.setCheckState(state) + + def get_selected_hole_ids(self): + # Get a list of selected hole_ids + selected_hole_ids = [] + for row in range(self.hole_id_list_model.rowCount()): + item = self.hole_id_list_model.item(row) + if item.checkState() == Qt.Checked: + selected_hole_ids.append(item.text()) + return selected_hole_ids + + + def get_selected_line_width(self): + line_width = float(self.line_edit_line_width.text()) + return max(1.0, min(line_width, 5.0)) # Limit between 1 and 5 + + + def connect_signals(self): + self.checkbox_remove_outliers.toggled.connect(self.toggle_remove_outliers) + + def toggle_remove_outliers(self, checked): + self.line_edit_upper_quantile.setEnabled(checked) + self.line_edit_lower_quantile.setEnabled(checked) + self.line_edit_IQR.setEnabled(checked) + + +class CombinedPlotWindow(QtWidgets.QMainWindow): # Downline line plot and graphic plot merge + def __init__(self, main_window, plot_windows, geochem_plot_windows): + super().__init__() + self.setWindowModality(QtCore.Qt.NonModal) + + self.figure = Figure(figsize=(15, 12)) + self.canvas = FigureCanvas(self.figure) + self.setCentralWidget(self.canvas) + self.main_window = main_window + + self.main_window = main_window + self.plot_windows = plot_windows + self.geochem_plot_windows = geochem_plot_windows + + self.save_button = QtWidgets.QPushButton(self) + self.save_button.setText("Save plot") + self.save_button.clicked.connect(self.save_plot) + + layout = QtWidgets.QVBoxLayout() + layout.addWidget(self.save_button) + + self.merge_plots() + self.horizontal_lines = [ax.axhline(y=0, color='red') for ax in self.axs] # Initial horizontal line at y=0 for each axis + self.figure.canvas.mpl_connect('button_press_event', self.on_click) + self.canvas.draw() + self.show() + + + def merge_plots(self): + # Assumes all geochem plots have the same depth (Y-axis) range + num_plots = 1 + len(self.geochem_plot_windows) + + # Create subplots side by side + self.axs = self.figure.subplots(1, num_plots) + print("Total plot_windows:", len(self.plot_windows)) + print("Total geochem_plot_windows:", len(self.geochem_plot_windows)) + print("Total axes (axs):", len(self.axs)) + + # If only one plot, make it to a list + if not isinstance(self.axs, np.ndarray): + self.axs = [self.axs] + + + # Extract y-axis limits from the graphic log + graphic_log_window = self.plot_windows[0] # Since there's only one graphic log plot + ax = graphic_log_window.figure.axes[0] + global_min_depth, global_max_depth = ax.get_ylim() + y_ticks_graphic_log = ax.get_yticks() + y_ticklabels_graphic_log = [label.get_text() for label in ax.get_yticklabels()] + + # Merge lithology plots + for i, window in enumerate(self.plot_windows): + ax = self.axs[i] + + ax.set_ylim(global_max_depth, global_min_depth) + ax.margins(y=0) + + ax.set_yticks(y_ticks_graphic_log) + ax.set_yticklabels(y_ticklabels_graphic_log) + + # Copy lines + for line in window.figure.axes[0].lines: + ax.plot(line.get_xdata(), line.get_ydata(), color=line.get_color()) + + + # Copy patches + for patch in window.figure.axes[0].patches: + if isinstance(patch, patches.Rectangle): + new_patch = patches.Rectangle((patch.get_x(), patch.get_y()), patch.get_width(), patch.get_height(), + facecolor=patch.get_facecolor(), edgecolor=patch.get_edgecolor(), + linewidth=patch.get_linewidth(), alpha=patch.get_alpha()) + elif isinstance(patch, patches.Polygon): + xy = patch.get_xy() + new_patch = patches.Polygon(xy, closed=True, + facecolor=patch.get_facecolor(), edgecolor=patch.get_edgecolor(), + linewidth=patch.get_linewidth(), alpha=patch.get_alpha()) + else: + # If the patch type is not recognized, skip it. + continue + ax.add_patch(new_patch) + + + + # Copy texts over + for text in window.figure.axes[0].texts: + ax.text(text.get_position()[0], text.get_position()[1], text.get_text(), fontsize=text.get_fontsize(), color=text.get_color()) + + # Copy annotations (e.g., depth annotations) + for annotation in window.figure.axes[0].texts: + new_annotation = ax.annotate(annotation.get_text(), + annotation.get_position(), + color=annotation.get_color(), + fontsize=annotation.get_fontsize(), + ha=annotation.get_ha(), + va=annotation.get_va()) + + + # Match axis settings + ax.set_xlim(window.figure.axes[0].get_xlim()) + ax.set_ylim(window.figure.axes[0].get_ylim()) + ax.set_xticks(window.figure.axes[0].get_xticks()) + ax.set_yticks(window.figure.axes[0].get_yticks()) + ax.set_title(window.figure.axes[0].get_title()) + ax.set_ylabel(window.figure.axes[0].get_ylabel()) + + + for i, window in enumerate(self.geochem_plot_windows.values()): + ax = self.axs[len(self.plot_windows) + i] + + ax.set_ylim(global_max_depth, global_min_depth) + ax.margins(y=0) + + # Remove the y-axis labels but keep the tick marks + ax.set_yticklabels([''] * len(ax.get_yticks())) + ax.set_title(window.column_name) + + # Copy the content of the geochem plot window's axis to the new axis + for line in window.figure.axes[0].lines: + ax.plot(line.get_xdata(), line.get_ydata(), color=line.get_color()) + + # Copy bars if present + for bar in window.figure.axes[0].patches: + if isinstance(bar, patches.Rectangle): + new_bar = patches.Rectangle((bar.get_x(), bar.get_y()), bar.get_width(), bar.get_height(), + facecolor=bar.get_facecolor(), edgecolor=bar.get_edgecolor(), + linewidth=bar.get_linewidth(), alpha=bar.get_alpha()) + ax.add_patch(new_bar) + + # Ensure the x-axis limits match the original geochem plot + ax.set_xlim(window.figure.axes[0].get_xlim()) + + for ax in self.axs: + ax.set_ylim(global_max_depth, global_min_depth) + ax.invert_yaxis() + + + def closeEvent(self, event): + self.main_window.combined_plot_window = None + event.accept() # let the window close + + def save_plot(self): + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + file_name, _ = QFileDialog.getSaveFileName(self,"Save Plot","","All Files (*);;JPEG (*.jpeg);;PNG (*.png)", options=options) + if file_name: + self.figure.savefig(file_name, dpi=200) + + def on_click(self, event): + # Update the line position for each axis + for line in self.horizontal_lines: + line.set_ydata([event.ydata, event.ydata]) + self.canvas.draw() + + + +class UnorientedPlot: # plot window for small circles/unoriented core structures + def __init__(self, data_model, model_structure): + self.data_model = data_model + self.model_structure = model_structure + self.tca_column = None + self.selected_hole_ids = [] + self.setup_ui() + + def setup_ui(self): + + # QDialog to act as the main window for this class + self.dialog = QDialog() + + # Setup a vertical layout + main_layout = QVBoxLayout(self.dialog) + + # Add a label and dropdown for Drill Hole Azimuth column selection + azimuth_label = QLabel("Please choose Drill Hole Azimuth column:", self.dialog) + self.azimuth_dropdown = QComboBox(self.dialog) + self.azimuth_dropdown.addItems(list(self.data_model.columns)) + main_layout.addWidget(azimuth_label) + main_layout.addWidget(self.azimuth_dropdown) + + # Add a label and dropdown for Drill Hole Dip column selection + dip_label = QLabel("Please choose Drill Hole Dip column:", self.dialog) + self.dip_dropdown = QComboBox(self.dialog) + self.dip_dropdown.addItems(list(self.data_model.columns)) + main_layout.addWidget(dip_label) + main_layout.addWidget(self.dip_dropdown) + + # Add a label and dropdown for TCA column selection + tca_label = QLabel("Please choose TCA column:", self.dialog) + self.tca_dropdown = QComboBox(self.dialog) + self.tca_dropdown.addItems(list(self.data_model.columns)) + main_layout.addWidget(tca_label) + main_layout.addWidget(self.tca_dropdown) + + # Add a label and dropdown for structure column selection + structure_label = QLabel("Please select structure column:", self.dialog) + self.structure_dropdown = QComboBox(self.dialog) + self.structure_dropdown.addItems(list(self.data_model.columns)) + main_layout.addWidget(structure_label) + main_layout.addWidget(self.structure_dropdown) + + # Add a label and list widget for structure values + structure_values_label = QLabel("Please select structure values:", self.dialog) + self.structure_values_list_widget = QListWidget(self.dialog) + self.structure_dropdown.currentTextChanged.connect(self.update_structure_values_list) + + # Populate structure_values_list_widget with all unique structure values in the dataframe + all_structure_values = self.data_model.dropna().astype(str).values.ravel() + unique_structure_values = np.unique(all_structure_values) + + for structure_value in unique_structure_values: + item = QListWidgetItem(structure_value) + item.setFlags(item.flags() | Qt.ItemIsUserCheckable) + item.setCheckState(Qt.Unchecked) + self.structure_values_list_widget.addItem(item) + + main_layout.addWidget(structure_values_label) + main_layout.addWidget(self.structure_values_list_widget) + + + # Add a Plot button + self.plot_button = QPushButton("Plot", self.dialog) + self.plot_button.clicked.connect(self.create_unoriented_plot) + main_layout.addWidget(self.plot_button) + + + # Checkbox for structure_values_list_widget + self.structure_values_select_all_checkbox = QCheckBox("Select All/Deselect All", self.dialog) + self.structure_values_select_all_checkbox.stateChanged.connect(self.toggle_structure_values_selection) + main_layout.addWidget(self.structure_values_select_all_checkbox) + main_layout.addWidget(self.structure_values_list_widget) + + + self.dialog.setLayout(main_layout) + self.dialog.exec_() + + + def toggle_hole_id_selection(self, state): + for index in range(self.hole_id_list_widget.count()): + item = self.hole_id_list_widget.item(index) + if state == Qt.Checked: + item.setCheckState(Qt.Checked) + else: + item.setCheckState(Qt.Unchecked) + + def toggle_structure_values_selection(self, state): + for index in range(self.structure_values_list_widget.count()): + item = self.structure_values_list_widget.item(index) + if state == Qt.Checked: + item.setCheckState(Qt.Checked) + else: + item.setCheckState(Qt.Unchecked) + + def update_structure_values_list(self): + # Clear previous items + self.structure_values_list_widget.clear() + + # Get selected structure column + selected_col = self.structure_dropdown.currentText() + + # Populate structure_values_list_widget with unique values from the selected structure column + unique_structure_values = self.data_model[selected_col].dropna().unique() + for structure_value in unique_structure_values: + item = QListWidgetItem(str(structure_value)) + item.setFlags(item.flags() | Qt.ItemIsUserCheckable) + item.setCheckState(Qt.Unchecked) + self.structure_values_list_widget.addItem(item) + + + def create_unoriented_plot(self): + # Fetch the selected TCA column + self.tca_column = self.tca_dropdown.currentText() + self.azimuth_column = self.azimuth_dropdown.currentText() + self.dip_column = self.dip_dropdown.currentText() + + # Fetch the selected structure values + selected_structures = [] + for index in range(self.structure_values_list_widget.count()): + item = self.structure_values_list_widget.item(index) + if item.checkState() == Qt.Checked: + selected_structures.append(item.text()) + + # Define the structure column + structure_col = self.structure_dropdown.currentText() + + # Fetch the selected hole_ids and filter the data_model based on selected hole_ids and structure types + self.selected_hole_ids = [self.model_structure.item(index).text() for index in range(self.model_structure.rowCount()) if self.model_structure.item(index).checkState() == Qt.Checked] + filtered_data = self.data_model[self.data_model['hole_id'].isin(self.selected_hole_ids) & self.data_model[structure_col].isin(selected_structures)] + + + # Create the stereonet plot based on the filtered data + fig = plt.figure(figsize=(8, 8)) + ax = fig.add_subplot(111, projection='stereonet') + + structure_col = self.structure_dropdown.currentText() + cmap = plt.get_cmap("tab10") + unique_structures = filtered_data[structure_col].unique() + structure_color_dict = {structure: cmap(i % cmap.N) for i, structure in enumerate(unique_structures)} + + legend_handles = [] # List to store legend handles + + for structure_type, color in structure_color_dict.items(): + sub_data = filtered_data[filtered_data[structure_col] == structure_type] + + for i in range(len(sub_data) - 1): + azimuth = filtered_data[self.azimuth_column].iloc[i] + plunge = filtered_data[self.dip_column].iloc[i] + plunge = abs(plunge) + + tca = sub_data[self.tca_column].iloc[i] + tca = 90-tca + + strike = (azimuth + 90) % 360 + dip = 90 - plunge + + # Plot the pole + ax.pole(strike, dip, marker='o', color=color, alpha=0.5) + + # Plot the TCA circle using the cone method with an unfilled circle + circle = ax.cone(plunge, azimuth, tca, color=color, facecolor='none', alpha=0.5, bidirectional=False, label=structure_type) + + # Create a Line2D object for the legend (only for the first iteration to avoid duplicate legend entries) + legend_handles.append(Line2D([0], [0], color=color, marker='o', linestyle='', label=structure_type)) + + # Add the legend outside the plot + ax.legend(handles=legend_handles, loc='center left', bbox_to_anchor=(1.05, 0.5)) + + ax.grid(True, alpha=0.5) + plt.show() + self.dialog.accept() + +class InputDialog(QDialog): # Dialog for cross section topo line settings + def __init__(self, parent=None): + super().__init__(parent) + + self.setWindowTitle("Raise or Lower Topo Line (meters)") + layout = QVBoxLayout(self) + + # Label + self.label = QLabel("Enter value (positive to raise, negative to lower):") + layout.addWidget(self.label) + + # Textbox + self.textbox = QLineEdit(self) + self.textbox.setText("0") # Default value + layout.addWidget(self.textbox) + + # OK and Cancel buttons + self.buttons = QPushButton("OK", self) + self.buttons.clicked.connect(self.accept) + layout.addWidget(self.buttons) + + def get_value(self): + return self.textbox.text() + + + + + + + + + + + +class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow): # START MAIN WINDOW + def __init__(self): + super().__init__() + self.setupUi(self) # Set up the GUI ----- OpenGeoUI.py + + + # Set the window icon + self.setWindowIcon(QtGui.QIcon(r"C:\Users\bsomp\Downloads\opvicon.ico")) + + + # Initialize models for the list views + self.model_lithology = QStandardItemModel(self.hole_id_listView_lithology) + self.model_geochem = QStandardItemModel(self.hole_id_listView_geochem) + self.model_structure = QStandardItemModel(self.hole_id_listView_structure) + self.model_hole_id_cross = QStandardItemModel(self.hole_id_listView_cross) # Model for hole_id_listView_cross + self.model_attri = QStandardItemModel(self.listview_attri) # Model for listview_attri + self.model_cross = QStandardItemModel(self.hole_id_listView_cross) + + + # Initialize dataframes for different CSVs + self.data_lithology = None + self.data_geochem = None + self.data_structure = None + self.data_desurveyed = None + + + # Initialize user inputs + self.attributes_dict = {} + self.scatter_plot_windows = [] + self.views = [] + self.DEM_data = None + self.selected_parameters = None + self.combined_plot_window = None + + + self.factor_analysis_dialog = FactorAnalysisDialog(self) + self.help_button.clicked.connect(self.on_help_button_clicked) + self.current_save_file = None + + + self.checkbox_add_grid_lines = False + self.remove_outliers_auxiliary = False + self.remove_outliers = True + self.upper_quantile = 75.0 + self.lower_quantile = 25.0 + self.IQR = 3.0 + self.slider_state = "ft" + + + # Default Values + self.x_buffer = 120.0 + self.y_buffer = 0.05 + + self.line_width = 4 + + self.selected_hole_ids_for_labels = [self.model_cross.item(row).text() for row in range(self.model_cross.rowCount())] + + + + # Create a Figure that will hold the plot + self.figure = Figure(figsize=(8, 12)) + + # Create a FigureCanvasQTAgg widget that will hold the Figure + self.canvas = FigureCanvas(self.figure) + + # Connect main window buttons to their respective methods + self.import_lithology_csv_button.clicked.connect(self.import_csv_method_lithology) + self.import_geochem_csv_button.clicked.connect(self.import_csv_method_geochem) + self.import_structure_csv_button.clicked.connect(self.import_csv_method_structure) + self.create_graphic_logs_button.clicked.connect(self.create_graphic_log) + self.downhole_plots_button.clicked.connect(self.create_downhole_plots) + self.correlation_matrices.clicked.connect(self.create_correlation_matrices) + self.manage_attributes_button.clicked.connect(self.manage_attributes) + self.upload_des_data.clicked.connect(self.load_desurveyed_data) + self.create_cross_section_button.clicked.connect(self.create_cross_section) + self.stereonet_button.clicked.connect(self.create_stereonet_dialog) + self.alpha_beta_converter_button.clicked.connect(self.convert_alpha_beta) + self.view_3d_button.clicked.connect(self.create_3d_plot) + self.rose_diagram_button.clicked.connect(self.create_rose_plot) + self.XYscatter_plots_button.clicked.connect(self.create_scatter_plots) + self.stylize_logs_button.clicked.connect(self.stylize_logs) + self.clear_parameters_button.clicked.connect(self.clear_parameters) + self.show_lith_button.clicked.connect(self.display_lithology_csv) + self.show_geochem_button.clicked.connect(self.display_geochem_csv) + self.show_structure_button.clicked.connect(self.display_structure_csv) + self.show_desurveyed_button.clicked.connect(self.display_desurveyed_csv) + self.lith_ft_m.valueChanged.connect(self.updateLithDepthUnit) + self.geochem_ft_m.valueChanged.connect(self.updateGeochemDepthUnit) + self.factor_analysis_button.clicked.connect(self.factor_analysis_button_clicked) + self.help_button.clicked.connect(self.on_help_button_clicked) + self.actionOpen.triggered.connect(self.open_state) + self.actionSave.triggered.connect(self.save_state) + self.actionSave_As.triggered.connect(self.save_state_as) + self.custom_plot_button.clicked.connect(self.select_custom_plot) + self.desurvey_button.clicked.connect(self.open_desurvey_calc) + self.DEM_button.clicked.connect(self.load_DEM) + self.plot_settings_button.clicked.connect(self.on_plot_settings_clicked) + self.merge_plots.clicked.connect(self.merge_open_plots) + self.unoriented_button.clicked.connect(self.on_unoriented_clicked) + self.actionExport.triggered.connect(self.on_export_clicked) + + + # Initialize plot windows + self.lith_plot_windows = {} + self.geochem_plot_windows = {} + self.plot_windows = [] + + + # Create a list to hold the CrossSection instances + self.cross_section_dialogs = [] + + self.current_file_name = None + self.actionSave.setEnabled(False) + + + def on_export_clicked(self): + # Show a dialog to let the user choose which dataset to export + choice, ok = QInputDialog.getItem(self, "Select Dataset", "Choose a dataset to export:", + ["Geochem CSV", "Lithology CSV", "Structure CSV", "Desurveyed CSV"], 0, False) + if ok and choice: + options = QFileDialog.Options() + file_path, _ = QFileDialog.getSaveFileName(self, "Select File to Export", "", + "CSV Files (*.csv)", options=options) + if file_path: + if choice == "Geochem CSV": + self.export_to_csv(self.data_geochem, file_path) + elif choice == "Lithology CSV": + self.export_to_csv(self.data_lithology, file_path) + elif choice == "Structure CSV": + self.export_to_csv(self.data_structure, file_path) + elif choice == "Desurveyed CSV": + self.export_to_csv(self.data_desurveyed, file_path) + + + def export_to_csv(self, dataset, file_path): + try: + dataset.to_csv(file_path, index=False) + QMessageBox.information(self, "Export Successful", f"File successfully exported to {file_path}") + except Exception as e: + QMessageBox.critical(self, "Error", f"Failed to export file. Error: {e}") + + + + @pyqtSlot() + def on_unoriented_clicked(self): + # Check if data_structure is empty + if self.data_structure is None or self.data_structure.empty: + # Show a warning message + warning_msg = QMessageBox() + warning_msg.setIcon(QMessageBox.Warning) + warning_msg.setText("Please upload structure CSV first.") + warning_msg.setWindowTitle("Warning") + warning_msg.exec_() + return # Stop execution of the function + + plot_window = UnorientedPlot(self.data_structure, self.model_structure) + + def merge_open_plots(self): + """ + Combine the open lithology and geochemistry plots into a single window. + """ + + # 1. Check if there are any open windows to merge + if not self.plot_windows and not self.geochem_plot_windows: + QMessageBox.warning(self, "No Open Plots", "Please open some plots to merge.") + return + + # 2. Check if more than one lithology plot is open + if len(self.plot_windows) > 1: + QMessageBox.warning(self, "Multiple Lithology Plots", "Please only have one lithology plot open.") + return + + # 3. Check if more than one lithology plot is open + if len(self.plot_windows) < 1: + QMessageBox.warning(self, "No Lithology Plots", "Please have one lithology plot open.") + return + + # 4. Check if the hole_id from the lithology plot doesn't match the hole_id from the geochemistry plots + lith_hole_id = self.plot_windows[0].hole_ids[0] + for geochem_plot in self.geochem_plot_windows.values(): + if geochem_plot.hole_id != lith_hole_id: + QMessageBox.warning(self, "Mismatched Hole IDs", "Ensure the hole_id matches between lithology and geochemistry plots.") + return + + # 5. Check if multiple hole_ids have been selected for the geochemistry plots + if len(self.geochem_plot_windows) > 1: + unique_hole_ids = set([plot.hole_id for plot in self.geochem_plot_windows.values()]) + if len(unique_hole_ids) > 1: + QMessageBox.warning(self, "Multiple Hole IDs", "Please select only one hole_id for geochemistry plots.") + return + + # 6. Check if only one type of plot is open + if not self.plot_windows or not self.geochem_plot_windows: + QMessageBox.warning(self, "Insufficient Plots", "Please open at least one lithology and one geochemistry plot.") + return + + # 7. Check if the previously created merged plot window is still open + if self.combined_plot_window: + QMessageBox.warning(self, "Previous Merged Plot", "Please close the previously created merged plot window first.") + return + + # 8. Check if more than 7 geochemistry plots are open + if len(self.geochem_plot_windows) > 7: + QMessageBox.warning(self, "Too Many Geochemistry Plots", "Please open no more than 7 geochemistry plots.") + return + + # Close any existing combined plot window + if self.combined_plot_window: + self.combined_plot_window.close() + + # Create the new combined plot window + self.combined_plot_window = CombinedPlotWindow(self, self.plot_windows, self.geochem_plot_windows) + print(f"Merging {len(self.plot_windows)} graphic log plots.") + + + + + def updateLithDepthUnit(self, value): + if value == 0: + self.lith_depth_unit = "feet" + self.slider_state = "ft" + else: + self.lith_depth_unit = "meters" + self.slider_state = "m" + + + def on_plot_settings_clicked(self): + + # Get all hole_ids from the model + all_hole_ids = [self.model_cross.item(row).text() for row in range(self.model_cross.rowCount())] + + # Create the PlotSettingsDialog with all hole_ids and current settings + plot_settings_dialog = PlotSettingsDialog(all_hole_ids) + plot_settings_dialog.init_defaults( + remove_outliers=self.remove_outliers, + remove_outliers_auxiliary=self.remove_outliers_auxiliary, + add_grid_lines=self.checkbox_add_grid_lines, # Note: Make sure to call isChecked() + upper_quantile=self.upper_quantile, + lower_quantile=self.lower_quantile, + IQR=self.IQR, + x_buffer=self.x_buffer, + y_buffer=self.y_buffer, + line_width=self.line_width, + selected_hole_ids_for_labels=self.selected_hole_ids_for_labels +) + + if plot_settings_dialog.exec_(): + try: + # Retrieve and store the settings + self.remove_outliers = plot_settings_dialog.checkbox_remove_outliers.isChecked() + # Retrieve and store the settings for "Apply to Auxiliary Bar Plot" + self.remove_outliers_auxiliary = plot_settings_dialog.checkbox_aux_plot.isChecked() + self.checkbox_add_grid_lines = plot_settings_dialog.checkbox_add_grid_lines.isChecked() + + upper_quantile_text = plot_settings_dialog.line_edit_upper_quantile.text() + self.upper_quantile = float(upper_quantile_text) if upper_quantile_text else 75.0 # default value + + lower_quantile_text = plot_settings_dialog.line_edit_lower_quantile.text() + self.lower_quantile = float(lower_quantile_text) if lower_quantile_text else 25.0 # default value + + IQR_text = plot_settings_dialog.line_edit_IQR.text() + self.IQR = float(IQR_text) if IQR_text else 3 # default value + + x_buffer_text = plot_settings_dialog.line_edit_x_buffer.text() + self.x_buffer = float(x_buffer_text) if x_buffer_text else 120.0 # default value + + y_buffer_text = plot_settings_dialog.line_edit_y_buffer.text() + self.y_buffer = float(y_buffer_text) if y_buffer_text else 0.05 # default value + + line_width_text = plot_settings_dialog.line_edit_line_width.text() + self.line_width = float(line_width_text) if line_width_text else 4.0 # default value + self.line_width = max(1.0, min(self.line_width, 5.0)) # Limit between 1 and 5 + print(f"Updated line_width: {self.line_width}") + print(f"Line Width inside on_plot_settings_clicked: {self.line_width}") + self.selected_hole_ids_for_labels = plot_settings_dialog.get_selected_hole_ids() + + + + except ValueError: + QMessageBox.critical(self, "Error", "Invalid input in one or more fields") + + + + def load_DEM(self): + dem_file, _ = QFileDialog.getOpenFileName( + self, "Open DEM File", "", "DEM Files (*.tif);;All Files (*)" + ) + if not dem_file: # User cancelled the file dialog + return + + print("DEM file path:", dem_file) + try: + dem_data_temp = rasterio.open(dem_file) + if dem_data_temp is None: + print("Failed to load DEM data with rasterio.") + return + else: + self.DEM_data = dem_data_temp + except Exception as e: + print("Error while loading DEM with rasterio:", str(e)) + return + + print("DEM Data Loaded") + print("Shape:", self.DEM_data.shape) + print("DEM data type:", self.DEM_data.dtypes) + print("DEM values range from:", self.DEM_data.read().min(), "to", self.DEM_data.read().max()) + + self.cross_section_dialogs = [] + + # Inform the user of the successful upload + QMessageBox.information(self, "Success", "DEM Upload Successful") + + for cs_dialog in self.cross_section_dialogs: + cs_dialog.DEM_data = self.DEM_data + cs_dialog.DEM_loaded = True + cs_dialog.run_DEM_calc() + + + def open_desurvey_calc(self): + print("Button clicked!") + try: + self.desurvey_dialog = DesurveyCalc(self) + result = self.desurvey_dialog.exec_() + + if result == QDialog.Accepted: + + pass + + except Exception as e: + print("Error:", e) + + def select_custom_plot(self): + + if self.data_geochem is None: + QMessageBox.warning(self, "No data", "Please load geochemistry data first") + return + + # Count checked items in self.model_geochem, excluding the 'Select All' option + checked_items = sum( + self.model_geochem.item(index).checkState() == Qt.Checked + for index in range(1, self.model_geochem.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + + # Get the selected hole IDs + selected_hole_ids = [] + for index in range(1, self.model_geochem.rowCount()): + item = self.model_geochem.item(index) + if item.checkState() == Qt.Checked: + selected_hole_ids.append(item.text()) + + # Create a new data frame with only the selected holes + filtered_data = self.data_geochem[self.data_geochem['hole_id'].isin(selected_hole_ids)] + filtered_data['polygon value'] = "None" + + # Show a file dialog for the user to select the JSON file + json_file_path, _ = QFileDialog.getOpenFileName(self, "Open JSON file", "", "JSON files (*.json)") + + if json_file_path: # if user didn't pick a file, do nothing + # Create and show the CustomPlotDialog with the filtered data + self.custom_plot_dialog = CustomPlotDialog(filtered_data, json_file_path) + self.custom_plot_dialog.show() + + + + def factor_analysis_button_clicked(self): + if self.data_geochem is None or self.data_geochem.empty: + # Show a warning message + warning_msg = QMessageBox() + warning_msg.setIcon(QMessageBox.Warning) + warning_msg.setText("Please upload geochem CSV first.") + warning_msg.setWindowTitle("Warning") + warning_msg.exec_() + return # Stop execution of the function + + # Count checked items in self.model_geochem, excluding the 'Select All' option + checked_items = sum( + self.model_geochem.item(index).checkState() == Qt.Checked + for index in range(1, self.model_geochem.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + + self.factor_analysis_dialog = FactorAnalysisDialog(self) + self.factor_analysis_dialog.show() + + + + def create_rose_plot(self): + # Check if data_structure is empty + if self.data_structure is None or self.data_structure.empty: + # Show a warning message + warning_msg = QMessageBox() + warning_msg.setIcon(QMessageBox.Warning) + warning_msg.setText("Please upload structure CSV first.") + warning_msg.setWindowTitle("Warning") + warning_msg.exec_() + return # Stop execution of the function + + # Count checked items in self.model_geochem, excluding the 'Select All' option + checked_items = sum( + self.model_structure.item(index).checkState() == Qt.Checked + for index in range(1, self.model_structure.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + + hole_ids = [] + for index in range(1, self.model_structure.rowCount()): + item = self.model_structure.item(index) + if item.checkState() == Qt.Checked: # If the hole_id is checked + hole_id = item.text() + hole_ids.append(hole_id) + + # Create RosePlot object + rose_plot = RosePlot(self.data_structure, hole_ids) + + # Call dialog function + rose_plot.dialog() + + def convert_alpha_beta(self): + # Check if data_structure is empty + if self.data_structure is None or self.data_structure.empty: + # Show a warning message + warning_msg = QMessageBox() + warning_msg.setIcon(QMessageBox.Warning) + warning_msg.setText("Please upload structure CSV first.") + warning_msg.setWindowTitle("Warning") + warning_msg.exec_() + return # Stop execution of the function + + checked_items = sum(self.model_structure.item(index).checkState() == Qt.Checked for index in range(self.model_structure.rowCount())) + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + if 'alpha' in self.data_structure.columns and 'beta' in self.data_structure.columns: + if 'drill_hole_azimuth' not in self.data_structure.columns or 'drill_hole_dip' not in self.data_structure.columns: + QMessageBox.warning(self, 'Warning', 'No azimuth or inclination columns found.') + return + + self.data_structure["alpha_rad"] = np.deg2rad(self.data_structure["alpha"]) + self.data_structure["beta_rad"] = np.deg2rad(self.data_structure["beta"]) + self.data_structure["I_rad"] = np.deg2rad(self.data_structure["drill_hole_dip"]) + self.data_structure["B_rad"] = np.deg2rad(self.data_structure["drill_hole_azimuth"]) + + self.data_structure["n_x_BH"] = np.cos(self.data_structure["beta_rad"]) * np.cos(self.data_structure["alpha_rad"]) + self.data_structure["n_y_BH"] = np.sin(self.data_structure["beta_rad"]) * np.cos(self.data_structure["alpha_rad"]) + self.data_structure["n_z_BH"] = np.sin(self.data_structure["alpha_rad"]) + + self.data_structure[["n_x_G", "n_y_G", "n_z_G"]] = self.data_structure.apply(self.transform_to_global, axis=1) + + self.data_structure[["trend", "plunge"]] = self.data_structure.apply(self.compute_trend_and_plunge, axis=1) + + self.data_structure[["strike_converted", "dip_converted"]] = self.data_structure.apply(self.compute_strike_and_dip, axis=1) + + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + file_name, _ = QFileDialog.getSaveFileName(self, "QFileDialog.getSaveFileName()", "", "CSV Files (*.csv)", options=options) + + if file_name: + self.data_structure.to_csv(file_name, index=False) + else: + QMessageBox.warning(self, 'Warning', 'No alpha or beta columns found.') + + def rotation_matrices(self, row): + I = row["I_rad"] + B = row["B_rad"] + + + Y_rot = np.array([ + [np.cos(np.pi/2 - I), 0, np.sin(np.pi/2 - I)], + [0, 1, 0], + [-np.sin(np.pi/2 - I), 0, np.cos(np.pi/2 - I)] + ]) + + Z_rot = np.array([ + [np.cos(np.pi/2 - B), -np.sin(np.pi/2 - B), 0], + [np.sin(np.pi/2 - B), np.cos(np.pi/2 - B), 0], + [0, 0, 1] + ]) + + + return Y_rot, Z_rot + + def transform_to_global(self, row): + n_BH = np.array([row["n_x_BH"], row["n_y_BH"], row["n_z_BH"]]) + Y_rot, Z_rot = self.rotation_matrices(row) + n_G = Z_rot @ Y_rot @ n_BH + return pd.Series(n_G) + + @staticmethod + def adjust_trend(drill_hole_azimuth): + temp = 360 - drill_hole_azimuth + hemispheres = np.array([0, 180, 360]) + differences = np.abs(hemispheres - temp) + min_difference_index = np.argmin(differences) + closest_hemisphere = hemispheres[min_difference_index] + final_subtraction_value = temp - (closest_hemisphere - temp) + return final_subtraction_value + + @staticmethod + def hemisphere_adjustment(drill_hole_azimuth, alpha, beta): + if (alpha < 30 and (beta < 75 or beta > 285)): + # For these specific conditions, the hemisphere adjustment is reversed + if 90 <= drill_hole_azimuth <= 270: + # return adjustment for upper hemisphere + return 90 + else: + # return adjustment for lower hemisphere + return -90 + else: + if 90 <= drill_hole_azimuth <= 270: + # lower hemisphere + return -90 + else: + # upper hemisphere + return 90 + + + def compute_trend_and_plunge(self, row): + trend = np.rad2deg(np.arctan2(row["n_y_G"], row["n_x_G"])) - self.adjust_trend(row["drill_hole_azimuth"]) + self.hemisphere_adjustment(row["drill_hole_azimuth"], row["alpha"], row["beta"]) + while trend < 0: + trend += 360 # ensure trend is between 0 and 360 degrees + plunge = np.rad2deg(np.arcsin(-row["n_z_G"])) + return pd.Series([trend, plunge]) + + def compute_strike_and_dip(self, row): + dip = 90 - abs(row["plunge"]) + strike = np.where(row["trend"] >= 90, row["trend"] - 90, row["trend"] + 270) + return pd.Series([strike, dip]) + + + def create_stereonet_dialog(self): + + # Check if data_structure is empty + if self.data_structure is None or self.data_structure.empty: + # Show a warning message + warning_msg = QMessageBox() + warning_msg.setIcon(QMessageBox.Warning) + warning_msg.setText("Please upload structure CSV first.") + warning_msg.setWindowTitle("Warning") + warning_msg.exec_() + return # Stop execution of the function + + # Count checked items in self.model_geochem, excluding the 'Select All' option + checked_items = sum( + self.model_structure.item(index).checkState() == Qt.Checked + for index in range(1, self.model_structure.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + + dialog = StereonetDialog(self) + + if self.data_structure is not None: + column_names = self.data_structure.columns.tolist() + dialog.strike_combobox.addItems(column_names) + dialog.dip_combobox.addItems(column_names) + dialog.color_coding_combobox.addItems(column_names) + + if dialog.exec_() == QDialog.Accepted: + strike_column = dialog.strike_combobox.currentText() + dip_column = dialog.dip_combobox.currentText() + plot_type = dialog.type_combobox.currentText() + color_coding_column = dialog.color_coding_combobox.currentText() + + # Check if the selected color coding column is numerical + if color_coding_column != "None" and self.data_structure[color_coding_column].dtype in ['int64', 'float64']: + warning_msg = QMessageBox() + warning_msg.setIcon(QMessageBox.Warning) + warning_msg.setText("Color coding column cannot be numerical.") + warning_msg.setWindowTitle("Warning") + warning_msg.exec_() + return # Stop execution of the function + + # Filter the data for selected hole ids + selected_data = pd.DataFrame() # Initialize an empty DataFrame + for index in range(1, self.model_structure.rowCount()): + item = self.model_structure.item(index) + if item.checkState() == Qt.Checked: # If the hole_id is checked + hole_id = item.text() + + # Filter the DataFrame to get the data of the selected hole_id + hole_data = self.data_structure[self.data_structure['hole_id'] == hole_id] + + # Append the data of the selected hole_id to the accumulated DataFrame + selected_data = pd.concat([selected_data, hole_data]) + + self.stereonet_plot_window = StereonetPlotWindow(selected_data, strike_column, dip_column, plot_type, color_coding_column) + + + def create_scatter_plots(self): + + if self.data_geochem is None: + QMessageBox.warning(self, "No data", "Please load geochemistry data first") + return + + # Count checked items in self.model_geochem + checked_items = sum( + self.model_geochem.item(index).checkState() == Qt.Checked + for index in range(1, self.model_geochem.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + + # Get the selected hole IDs + selected_hole_ids = [] + for index in range(1, self.model_geochem.rowCount()): + item = self.model_geochem.item(index) + if item.checkState() == Qt.Checked: + selected_hole_ids.append(item.text()) + + # Create and show the ScatterPlotDialog + self.scatter_plot_dialog = ScatterPlotDialog(self.data_geochem, selected_hole_ids) + self.scatter_plot_dialog.exec_() + self.scatter_plot_dialog.close() + + + def manage_attributes(self): # for cross section + if self.data_desurveyed is None: + QMessageBox.warning(self, "No data", "Please load desurveyed data first") + return + + self.manage_attributes_dialog = ManageAttributesDialog(self.data_desurveyed, self.attributes_dict, self) + self.manage_attributes_dialog.exec_() + + self.attributes_dict = self.manage_attributes_dialog.get_attributes_dict() + + def load_desurveyed_data(self): # for cross section + filename, _ = QFileDialog.getOpenFileName(self, "Select desurveyed data file", "", "CSV files (*.csv)") + if filename: + print("Selected file:", os.path.basename(filename)) + try: + self.data_desurveyed = pd.read_csv(filename, header=0) + + # Create a new QStandardItemModel and set it as the model for hole_id_listView_cross + self.model_cross = QStandardItemModel(self.hole_id_listView_cross) + self.hole_id_listView_cross.setModel(self.model_cross) + self.add_check_all_option(self.model_cross) + + # Get the unique hole IDs from the data + unique_hole_ids = self.data_desurveyed['hole_id'].unique() + + # Print out the unique hole IDs to check they are correct + print("Unique hole IDs: ", unique_hole_ids) + + # Populate the hole_id_listView_cross with the unique hole IDs + for hole_id in unique_hole_ids: + item = QStandardItem(str(hole_id)) # Convert hole_id to string + item.setCheckable(True) + self.model_cross.appendRow(item) + + # Initialize self.selected_hole_ids_for_labels with all hole IDs + self.selected_hole_ids_for_labels = list(map(str, unique_hole_ids)) + + # Print out self.selected_hole_ids_for_labels to check it is populated correctly + print("MainWindow - selected_hole_ids_for_labels after loading data: ", self.selected_hole_ids_for_labels) + + + # Get the column names from the data, exclude x, y, z, and hole_id columns + column_names = [col for col in self.data_desurveyed.columns if col not in ['x', 'y', 'z', 'hole_id']] + + # Clear listview_attri + self.model_attri.clear() + + # Populate listview_attri with column names + for col_name in column_names: + item = QStandardItem(col_name) + item.setCheckable(True) + item.setForeground(QtGui.QBrush(QtGui.QColor("black"))) # Set the text color to black + self.model_attri.appendRow(item) + + self.listview_attri.setModel(self.model_attri) # Set the model for listview_attri + + except Exception as e: + QMessageBox.critical(self, "Error", str(e)) + + + def get_selected_ppm_column(self): # for cross section + for index in range(self.model_attri.rowCount()): + item = self.model_attri.item(index) + if item.checkState() == Qt.Checked: + return item.text() + return None + + + def create_cross_section(self): + print("MainWindow - In create_cross_section: ", self.selected_hole_ids_for_labels) + if self.data_desurveyed is None: + QMessageBox.warning(self, "No data", "Please load desurveyed data first") + return + + + selected_hole_ids = [] + + # Iterate over the items of the hole_id_listView_cross + for index in range(1, self.model_cross.rowCount()): + item = self.model_cross.item(index) + if item.checkState() == Qt.Checked: # If the hole_id is checked + selected_hole_ids.append(item.text()) + + if not selected_hole_ids: + QMessageBox.warning(self, "No hole IDs selected", "Please select at least one hole ID") + return + + azimuth, ok = QInputDialog.getDouble(self, "Input", "Enter the direction to view (0-360):", min=0, max=360) + + + if not ok: + + return + + # Get all selected attribute columns + selected_attributes = [self.model_attri.item(index).text() for index in range(self.model_attri.rowCount()) + if self.model_attri.item(index).checkState() == Qt.Checked] + + # If no attributes are selected, default to a list containing None + if not selected_attributes: + selected_attributes = [None] + + try: + # Loop over all selected attributes (or just once with None) and create a CrossSection for each + for attribute in selected_attributes: + print("MainWindow - Before creating CrossSection: ", self.selected_hole_ids_for_labels) + cross_section = CrossSection( + data=self.data_desurveyed, + hole_ids=selected_hole_ids, + azimuth=azimuth, + attribute_column=attribute, # or whatever the current attribute is + attributes_model=self.model_attri, # Your QStandardItemModel + attributes_dict=self.attributes_dict, # Your attributes dictionary + DEM_data=self.DEM_data if hasattr(self, 'DEM_data') else None, + remove_outliers=self.remove_outliers, + upper_quantile=self.upper_quantile, + lower_quantile=self.lower_quantile, + IQR=self.IQR, + x_buffer=self.x_buffer, + y_buffer=self.y_buffer, + line_width=self.line_width, + selected_hole_ids_for_labels=self.selected_hole_ids_for_labels, + remove_outliers_auxiliary=self.remove_outliers_auxiliary, + checkbox_add_grid_lines=self.checkbox_add_grid_lines + ) + cross_section.show() # Show the CrossSection window immediately + self.cross_section_dialogs.append(cross_section) # Append the dialog to the list + except Exception as e: + print(e) + QMessageBox.critical(self, "Error", str(e)) + + + + def import_csv_method(self, model): # all except desurvey + data = None + options = QFileDialog.Options() + options |= QFileDialog.ReadOnly + file_name, _ = QFileDialog.getOpenFileName(self, "QFileDialog.getOpenFileName()", "", "CSV Files (*.csv)", options=options) + if file_name: + print(f"Opening file: {file_name}") + data = pd.read_csv(file_name, header=0) + + # Check if 'hole_id' column exists in the data + if 'hole_id' not in data.columns: + QMessageBox.warning(self, 'Warning', "Please make sure CSV contains 'hole_id' column.") + return None + + # Clear the hole_id_listWidget and then populate it with the hole-ids + model.clear() + hole_ids = data['hole_id'].unique() + for hole_id in hole_ids: + item = QStandardItem(str(hole_id)) # Create a QStandardItem + item.setCheckable(True) # Make the item checkable + item.setForeground(QtGui.QBrush(QtGui.QColor("black"))) # Set the text color to black + model.appendRow(item) # Add each hole_id to the listWidget + + + return data + + + + def column_type(self, column, dataframe): + if pd.api.types.is_numeric_dtype(dataframe[column]): + return 'continuous' + else: + return 'categorical' + + + def create_3d_plot(self): + if self.data_desurveyed is None: + QMessageBox.warning(self, "No data", "Please load desurveyed data first") + return + + selected_hole_ids = [ + self.model_cross.item(index).text() + for index in range(1, self.model_cross.rowCount()) # Start from index 1 + if self.model_cross.item(index).checkState() == Qt.Checked + ] + + + selected_attribute = None + for index in range(1, self.model_attri.rowCount()): + item = self.model_attri.item(index) + if item.checkState() == Qt.Checked: + selected_attribute = item.text() + + fig = plt.figure(figsize=(12, 8)) + ax = fig.add_subplot(111, projection='3d') + + if selected_attribute and selected_attribute not in self.attributes_dict: + if self.column_type(selected_attribute, self.data_desurveyed) == 'continuous': + # Only calculate the IQR and remove outliers if the selected attribute is continuous. + data_copy = self.data_desurveyed.copy() + Q1 = data_copy[selected_attribute].quantile(0.25) + Q3 = data_copy[selected_attribute].quantile(0.75) + IQR = Q3 - Q1 + data_copy = data_copy[~((data_copy[selected_attribute] < (Q1 - 3 * IQR)) | (data_copy[selected_attribute] > (Q3 + 3 * IQR)))] + + attribute_min = data_copy[selected_attribute].min() + attribute_max = data_copy[selected_attribute].max() + cmap = plt.get_cmap('Spectral_r') + norm = plt.Normalize(vmin=attribute_min, vmax=attribute_max) + sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + sm.set_array([]) + else: + sm = None + else: + sm = None + + column_type = None + if selected_attribute: + column_type = self.column_type(selected_attribute, self.data_desurveyed) + + color_dict = None + for hole_id in selected_hole_ids: + hole_data = self.data_desurveyed[self.data_desurveyed['hole_id'] == hole_id] + hole_data.sort_values('z', inplace=True, ascending=False) + + if selected_attribute and selected_attribute in hole_data.columns: + if selected_attribute in self.attributes_dict: + for i in range(1, len(hole_data)): + x_values = hole_data['x'].iloc[i-1:i+1] + y_values = hole_data['y'].iloc[i-1:i+1] + z_values = hole_data['z'].iloc[i-1:i+1] + attribute_value = hole_data[selected_attribute].iloc[i] + + if attribute_value in self.attributes_dict[selected_attribute]: + color = self.attributes_dict[selected_attribute][attribute_value]["color"] + ax.plot(x_values, y_values, z_values, color=color, linewidth=3) + else: + if column_type == 'categorical': + unique_vals = self.data_desurveyed[selected_attribute].unique() + colors = plt.cm.get_cmap('tab10', len(unique_vals)) + color_dict = dict(zip(unique_vals, colors(range(len(unique_vals))))) + + for i in range(1, len(hole_data)): + x_values = hole_data['x'].iloc[i-1:i+1] + y_values = hole_data['y'].iloc[i-1:i+1] + z_values = hole_data['z'].iloc[i-1:i+1] + attribute_value = hole_data[selected_attribute].iloc[i] + color = color_dict[attribute_value] + ax.plot(x_values, y_values, z_values, color=color, linewidth=3) + elif sm is not None: + for i in range(1, len(hole_data)): + x_values = hole_data['x'].iloc[i-1:i+1] + y_values = hole_data['y'].iloc[i-1:i+1] + z_values = hole_data['z'].iloc[i-1:i+1] + attribute_value = hole_data[selected_attribute].iloc[i] + color = sm.to_rgba(attribute_value) + ax.plot(x_values, y_values, z_values, color=color, linewidth=3) + else: + ax.plot(hole_data['x'], hole_data['y'], hole_data['z'], color='black', linewidth=0.8) + + + bottom_of_hole = hole_data.loc[hole_data['z'].idxmin()] + ax.text(bottom_of_hole['x'], bottom_of_hole['y'], bottom_of_hole['z'], hole_id, fontsize=8) + + if sm is not None: + fig.colorbar(sm, ax=ax, orientation='vertical', label=selected_attribute, shrink=0.5) + + if selected_attribute and column_type != 'continuous': + if selected_attribute in self.attributes_dict: + legend_elements = [Line2D([0], [0], color=self.attributes_dict[selected_attribute][val]['color'], lw=4, label=val) for val in self.attributes_dict[selected_attribute]] + elif color_dict is not None: + legend_elements = [Line2D([0], [0], color=color_dict[val], lw=4, label=val) for val in color_dict.keys()] + ax.legend(handles=legend_elements, loc='upper left', bbox_to_anchor=(-0.7, 0.5)) + + plt.get_current_fig_manager().window.showMaximized() + plt.show() + + + + + + def add_check_all_option(self, model): + check_all_item = QStandardItem("Select All") + + # Set font to italics + font = QFont() + font.setItalic(True) + check_all_item.setFont(font) + + # Set the text color with reduced opacity + color = QColor(0, 0, 0, 200) # Black color with alpha set to 5 + check_all_item.setForeground(color) + + check_all_item.setCheckable(True) + model.insertRow(0, check_all_item) + + model.itemChanged.connect(lambda item, model=model: self.on_item_changed(item, model)) + + def on_item_changed(self, item, model): + if item.row() == 0 and item.text() == "Select All": + check_state = item.checkState() + for row in range(1, model.rowCount()): + child_item = model.item(row) + if child_item.isCheckable(): + child_item.setCheckState(check_state) + + def import_csv_method_lithology(self): + self.data_lithology = self.import_csv_method(self.model_lithology) + if self.data_lithology is not None: + self.hole_id_listView_lithology.setModel(self.model_lithology) + self.add_check_all_option(self.model_lithology) + + def import_csv_method_geochem(self): + self.data_geochem = self.import_csv_method(self.model_geochem) + if self.data_geochem is not None: + self.hole_id_listView_geochem.setModel(self.model_geochem) + self.add_check_all_option(self.model_geochem) + + def import_csv_method_structure(self): + self.data_structure = self.import_csv_method(self.model_structure) + if self.data_structure is not None: + self.hole_id_listView_structure.setModel(self.model_structure) + self.add_check_all_option(self.model_structure) + + def create_downhole_plots(self): + + if self.data_geochem is None: + QMessageBox.warning(self, "No data", "Please load geochemistry data first") + return + + checked_items = sum( + self.model_geochem.item(index).checkState() == Qt.Checked + for index in range(1, self.model_geochem.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + data = self.data_geochem + + dialog = ColumnSelectionDialog(self) + dialog.load_columns(self.data_geochem.columns) + dialog.load_depth_columns(self.data_geochem.columns) + + for index in range(dialog.column_listWidget.count()): + print(dialog.column_listWidget.item(index).text()) + + if dialog.exec_(): + plot_bars = dialog.plot_bars_checkbox.isChecked() + selected_columns = [] + for index in range(dialog.column_listWidget.count()): + item = dialog.column_listWidget.item(index) + if item.checkState() == Qt.Checked: + selected_columns.append(item.text()) + + # Iterate over the items of the QListView_geochem + for index in range(1, self.model_geochem.rowCount()): + item = self.model_geochem.item(index) + if item.checkState() == Qt.Checked: # If the hole_id is checked + hole_id = item.text() + print(f"Hole ID: {hole_id}") + # Filter the DataFrame to get the data of the selected hole_id + hole_data = self.data_geochem[self.data_geochem['hole_id'] == hole_id] + + selected_depth_column = dialog.depth_column_combo.currentText() + # Check if the selected depth column is numerical + if not np.issubdtype(self.data_geochem[selected_depth_column].dtype, np.number): + QMessageBox.warning(self, "Invalid selection", "Please select a numerical column for depth.") + return + + # For each selected column, create a DownholePlotWindow and add it to the list of PlotWindows + for column in selected_columns: + print(f"Creating plot for column: {column}") + # Create a copy of the data for this column and fill NaNs with 0 + column_data = hole_data[column].fillna(0) + + # Create a unique key for the window. It could be based on hole_id and column. + window_key = f"{hole_id}_{column}" + + # Create a new window and add it to the dictionary using the unique key. + new_plot_window = DownholePlotWindow(self, hole_data, hole_id, column_data, column, selected_depth_column, plot_bars=plot_bars) + self.geochem_plot_windows[window_key] = new_plot_window + + # Set the initial depth unit based on the slider + new_plot_window.updategeochemDepthUnit(self.geochem_ft_m.value()) + + # Connect the QSlider valueChanged signal to the new window's updategeochemDepthUnit methods + self.geochem_ft_m.valueChanged.connect(new_plot_window.updategeochemDepthUnit) + + + def create_graphic_log(self): + if self.data_lithology is None: + QMessageBox.warning(self, "No data", "Please load lithology data first") + return + + if self.selected_parameters is None: + QMessageBox.warning(self, "No parameters", "Please stylize logs first") + return + + # Count checked items in self.model_lithology + checked_items = sum( + self.model_lithology.item(index).checkState() == Qt.Checked + for index in range(1, self.model_lithology.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + # List comprehension for selected_hole_ids, starting from index 1 + selected_hole_ids = [ + self.model_lithology.item(index).text() + for index in range(1, self.model_lithology.rowCount()) # Start from index 1 + if self.model_lithology.item(index).checkState() == Qt.Checked + ] + + selected_hole_data = self.data_lithology[self.data_lithology['hole_id'].isin(selected_hole_ids)] + + + # Determine the unit from the slider's current position + current_unit = "ft" if self.lith_ft_m.value() == 0 else "m" + + plot_window = PlotWindow(self, selected_hole_data, selected_hole_ids, self.selected_parameters, current_unit) + self.lith_ft_m.valueChanged.connect(plot_window.updateLithDepthUnit) + plot_window.show() + self.plot_windows.append(plot_window) # Append the window to the list to keep a reference + print(f"Total graphic log plot windows: {len(self.plot_windows)}") + print("Selected hole IDs for lithology:", selected_hole_ids) + + + + + + def stylize_logs(self): + if self.data_lithology is None: + QMessageBox.warning(self, "No data", "Please load lithology data first") + return + + data = self.data_lithology + + dialog = ColumnSelectorDialog(data) + result = dialog.exec_() + if result == QDialog.Accepted: + self.selected_parameters = dialog.get_parameters() # Store the user's selections in an instance variable + print("Stored parameters:", self.selected_parameters) + else: + QMessageBox.warning(self, "No parameters selected", "Please select parameters") + + QMessageBox.information(self, "Success", "Log parameters saved!") + + + def clear_parameters(self): + self.selected_parameters = None + QMessageBox.information(self, "Parameters cleared", "Stylization parameters have been cleared.") + + def create_correlation_matrices(self): + if self.data_geochem is None: + QMessageBox.warning(self, "No data", "Please load geochemistry data first") + return + + checked_items = sum( + self.model_geochem.item(index).checkState() == Qt.Checked + for index in range(1, self.model_geochem.rowCount()) # Start from index 1 + ) + + if checked_items == 0: + QMessageBox.warning(self, "No selection", "Please select at least one hole.") + return + + # Get the ending tag from the user + ending_tag, ok = QInputDialog.getText(self, "Choose Ending Tag", "Enter the ending tag for the columns (e.g., _ppm):") + if not ok or not ending_tag: + QMessageBox.warning(self, "No ending tag", "You did not enter an ending tag.") + return + + # Count the number of columns that contain the user-specified ending tag in their name + selected_columns = [col for col in self.data_geochem.columns if ending_tag in col] + + if len(selected_columns) < 2: + QMessageBox.warning(self, "Insufficient data", f"Please add {ending_tag} values first") + return + + # Combine data from all selected holes + selected_data = pd.DataFrame() + selected_hole_ids = [] + + for index in range(1, self.model_geochem.rowCount()): + item = self.model_geochem.item(index) + if item.checkState() == Qt.Checked: + hole_id = item.text() + selected_hole_ids.append(hole_id) + hole_data = self.data_geochem[self.data_geochem['hole_id'] == hole_id][selected_columns] + selected_data = pd.concat([selected_data, hole_data]) + + # Check if there is any data to plot + if selected_data.empty: + QMessageBox.warning(self, "No data", "No data available for the selected holes and tag.") + return + + # Determine the title based on the number of selected holes + if len(selected_hole_ids) == 1: + title = selected_hole_ids[0] # Single selected hole + else: + title = "Combined Holes" # Multiple holes + + # Create a correlation matrix with the combined data + self.geochem_plot_windows[title] = CorrelationMatrixWindow(selected_data, title, ending_tag) + + + def display_lithology_csv(self): # Open the table + if self.data_lithology is None: + QMessageBox.warning(self, "Warning", "Please upload lithology data first.") + else: + self.display_data(self.data_lithology) + + def display_geochem_csv(self): # Open the table + if self.data_geochem is None: + QMessageBox.warning(self, "Warning", "Please upload geochemistry data first.") + else: + self.display_data(self.data_geochem) + + def display_structure_csv(self): # Open the table + if self.data_structure is None: + QMessageBox.warning(self, "Warning", "Please upload structure data first.") + else: + self.display_data(self.data_structure) + + def display_desurveyed_csv(self): # Open the table + if self.data_desurveyed is None: + QMessageBox.warning(self, "Warning", "Please upload desurveyed data first.") + else: + self.display_data(self.data_desurveyed) + + def display_data(self, data): # table display properties + model = pandasModel(data) + view = QTableView() + view.setModel(model) + + # Set the font of the horizontal header (the column names) to be bold + font = view.horizontalHeader().font() + font.setBold(True) + view.horizontalHeader().setFont(font) + + # Set the font of the vertical header (the row names) to be bold, if you want + font = view.verticalHeader().font() + font.setBold(True) + view.verticalHeader().setFont(font) + + view.resize(1100, 600) + view.show() + self.views.append(view) + + def updateLithDepthUnit(self, value): + if value == 0: + self.lith_depth_unit = "feet" + self.slider_state = "ft" # Add this line + else: + self.lith_depth_unit = "meters" + self.slider_state = "m" # And this line + + # Update all PlotWindows + for lith_plot_window in self.lith_plot_windows.values(): + lith_plot_window.updateLithDepthUnit(value) + + + def updateGeochemDepthUnit(self, value): + if value == 0: + self.geochem_depth_unit = "feet" + else: + self.geochem_depth_unit = "meters" + + # Update all DownholePlotWindows + for geochem_plot_window in self.geochem_plot_windows.values(): + if isinstance(geochem_plot_window, DownholePlotWindow): # Check if it's a DownholePlotWindow + geochem_plot_window.updategeochemDepthUnit(value) + + def on_help_button_clicked(self): + try: + with open('help_ogv.txt', 'r') as f: + help_text = f.read() + except FileNotFoundError: + help_text = "Help file not found." + + self.help_dialog = HelpDialog(help_text) + self.help_dialog.show_help() + self.help_dialog.show() + + def save_state(self): + # Logic to save the state of your application + hole_ids_lithology = self.get_model_data(self.model_lithology) + hole_ids_geochem = self.get_model_data(self.model_geochem) + hole_ids_structure = self.get_model_data(self.model_structure) + hole_ids_cross = self.get_model_data(self.model_cross) + attributes = self.get_model_data(self.model_attri) + with open(self.current_save_file, 'wb') as f: + pickle.dump((self.data_lithology, self.data_geochem, self.data_structure, self.data_desurveyed, + self.selected_parameters, self.attributes_dict, + hole_ids_lithology, hole_ids_geochem, hole_ids_structure, hole_ids_cross, attributes, self.slider_state), f) + + if self.current_save_file is None: + # If there is no current save file, show the "Save As" dialog + self.save_state_as() + else: + # Otherwise, save to the current save file + self.save_state_to_file(self.current_save_file) + + def save_state_as(self): + # Get data from the models + hole_ids_lithology = self.get_model_data(self.model_lithology) + hole_ids_geochem = self.get_model_data(self.model_geochem) + hole_ids_structure = self.get_model_data(self.model_structure) + hole_ids_cross = self.get_model_data(self.model_cross) + attributes = self.get_model_data(self.model_attri) + + # Open a file dialog to get the save file name from the user + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + fileName, _ = QFileDialog.getSaveFileName(self, "QFileDialog.getSaveFileName()", "", + "Pickle Files (*.pkl)", options=options) + + # If the user selected a file + if fileName: + self.current_save_file = fileName # Update the current save file + self.update_window_title() # Update the window title + self.save_state_to_file(fileName) # Save the state of the application + + def save_state_to_file(self, file_name): + # Get data from the models + hole_ids_lithology = self.get_model_data(self.model_lithology) + hole_ids_geochem = self.get_model_data(self.model_geochem) + hole_ids_structure = self.get_model_data(self.model_structure) + hole_ids_cross = self.get_model_data(self.model_cross) + attributes = self.get_model_data(self.model_attri) + + # Save the state of your application + with open(file_name, 'wb') as f: + pickle.dump((self.data_lithology, self.data_geochem, self.data_structure, self.data_desurveyed, + self.selected_parameters, self.attributes_dict, + hole_ids_lithology, hole_ids_geochem, hole_ids_structure, hole_ids_cross, attributes, self.slider_state), f) + + + def open_state(self): # Open a saved project + options = QFileDialog.Options() + options |= QFileDialog.DontUseNativeDialog + fileName, _ = QFileDialog.getOpenFileName(self, "QFileDialog.getOpenFileName()", "", + "Pickle Files (*.pkl)", options=options) + if fileName: + try: + with open(fileName, 'rb') as f: + loaded_data = pickle.load(f) + + if len(loaded_data) == 11: + self.data_lithology, self.data_geochem, self.data_structure, self.data_desurveyed, \ + self.selected_parameters, self.attributes_dict, \ + hole_ids_lithology, hole_ids_geochem, hole_ids_structure, hole_ids_cross, attributes = loaded_data + self.DEM_loaded = False + # You can set a default slider_state here if needed + self.slider_state = "ft" # or whatever default value you'd like + else: + self.data_lithology, self.data_geochem, self.data_structure, self.data_desurveyed, \ + self.selected_parameters, self.attributes_dict, \ + hole_ids_lithology, hole_ids_geochem, hole_ids_structure, hole_ids_cross, attributes, self.slider_state = loaded_data + + + # Load model data and add 'check all' option if data is present + self.load_model_data_and_check_all(self.model_lithology, hole_ids_lithology) + self.load_model_data_and_check_all(self.model_geochem, hole_ids_geochem) + self.load_model_data_and_check_all(self.model_structure, hole_ids_structure) + self.load_model_data_and_check_all(self.model_cross, hole_ids_cross) + self.load_model_data(self.model_attri, attributes) + + + + + # Update the current save file to the file that was just opened + self.current_save_file = fileName + self.update_window_title() # Update the window title + + # Enable the "Save" action now that we have a file to save to + self.actionSave.setEnabled(True) + + # Update selected_hole_ids_for_labels with all unique hole IDs from the loaded data + if self.data_desurveyed is not None: + unique_hole_ids = self.data_desurveyed['hole_id'].unique() + self.selected_hole_ids_for_labels = list(map(str, unique_hole_ids)) + + except Exception as e: + QMessageBox.critical(self, "Error", "Failed to load file. Error: " + str(e)) + + self.hole_id_listView_lithology.setModel(self.model_lithology) + self.hole_id_listView_geochem.setModel(self.model_geochem) + self.hole_id_listView_structure.setModel(self.model_structure) + self.hole_id_listView_cross.setModel(self.model_cross) + self.listview_attri.setModel(self.model_attri) + + if self.slider_state == "ft": + self.lith_ft_m.setValue(0) + else: + self.lith_ft_m.setValue(1) + + def load_model_data_and_check_all(self, model, data): + self.load_model_data(model, data) + if data: # Check if the data list is not empty + self.add_check_all_option(model) + + def update_window_title(self): + base_title = "Open Geo Plotter" + if hasattr(self, 'current_save_file') and self.current_save_file: + file_name = os.path.basename(self.current_save_file) + full_title = f"{base_title} - [{file_name}]" + else: + full_title = base_title + self.setWindowTitle(full_title) + + def get_model_data(self, model): + return [model.item(i).text() for i in range(model.rowCount())] + + def load_model_data(self, model, data): + model.clear() + for item in data: + new_item = QStandardItem(item) + new_item.setCheckable(True) # Make the item checkable + model.appendRow(new_item) + + + +class HelpDialog(QDialog): + def __init__(self, help_text): + super().__init__() + + self.setWindowTitle("Help") + + self.text_edit = QTextEdit(self) + self.text_edit.setReadOnly(True) + self.text_edit.setPlainText(help_text) + + self.layout = QVBoxLayout() + self.layout.addWidget(self.text_edit) + self.setLayout(self.layout) + + def show_help(self): + try: + with open('C:/Users/bsomp/Downloads/help_ogv.txt', 'r') as f: + help_text = f.read() + except FileNotFoundError: + help_text = "Help file not found." + + self.text_edit.setPlainText(help_text) + + +class pandasModel(QStandardItemModel): + def __init__(self, data, parent=None): + QStandardItemModel.__init__(self, parent) + self._data = data + for row in self._data.values: + items = [QStandardItem(str(i)) for i in row] + self.appendRow(items) + self.setHorizontalHeaderLabels(self._data.columns) + + def rowCount(self, parent=None): + return len(self._data.values) + + def columnCount(self, parent=None): + return self._data.columns.size + + +def exception_hook(exctype, value, traceback): + error_message = f"{exctype.__name__}: {value}" + QMessageBox.critical(None, "An unexpected error occurred", error_message) + sys.__excepthook__(exctype, value, traceback) + + + + + +if __name__ == "__main__": + QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) # enables high dpi scaling + QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) # uses high dpi pixmaps + app = QApplication(sys.argv) + app.setWindowIcon(QtGui.QIcon(r"C:\Users\bsomp\Downloads\opvicon.ico")) + + # Set the global stylesheet + stylesheet = """ + QListView { + color: black; + } + """ + app.setStyleSheet(stylesheet) + + window = MainWindow() + window.showMaximized() + window.setWindowTitle("Open Geo Plotter") + + sys.excepthook = exception_hook + + sys.exit(app.exec_()) \ No newline at end of file diff --git a/OpenGeoUI2.py b/OpenGeoUI2.py new file mode 100644 index 0000000..934e416 --- /dev/null +++ b/OpenGeoUI2.py @@ -0,0 +1,960 @@ +# -*- coding: utf-8 -*- + +# Form implementation generated from reading ui file 'OpenGeoLogger2.ui' +# +# Created by: PyQt5 UI code generator 5.15.9 +# +# WARNING: Any manual changes made to this file will be lost when pyuic5 is +# run again. Do not edit this file unless you know what you are doing. + + +from PyQt5 import QtCore, QtGui, QtWidgets + + +class Ui_MainWindow(object): + def setupUi(self, MainWindow): + MainWindow.setObjectName("MainWindow") + MainWindow.resize(1537, 830) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(MainWindow.sizePolicy().hasHeightForWidth()) + MainWindow.setSizePolicy(sizePolicy) + MainWindow.setMinimumSize(QtCore.QSize(150, 75)) + MainWindow.setAutoFillBackground(True) + MainWindow.setStyleSheet("") + MainWindow.setIconSize(QtCore.QSize(50, 50)) + MainWindow.setAnimated(False) + self.centralwidget = QtWidgets.QWidget(MainWindow) + self.centralwidget.setStyleSheet("background-color: rgb(230, 237, 255);") + self.centralwidget.setObjectName("centralwidget") + self.gridLayout_2 = QtWidgets.QGridLayout(self.centralwidget) + self.gridLayout_2.setObjectName("gridLayout_2") + spacerItem = QtWidgets.QSpacerItem(60, 20, QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Minimum) + self.gridLayout_2.addItem(spacerItem, 0, 6, 1, 1) + self.verticalLayout_6 = QtWidgets.QVBoxLayout() + self.verticalLayout_6.setContentsMargins(95, -1, 0, -1) + self.verticalLayout_6.setObjectName("verticalLayout_6") + self.label_7 = QtWidgets.QLabel(self.centralwidget) + self.label_7.setObjectName("label_7") + self.verticalLayout_6.addWidget(self.label_7) + self.hole_id_listView_cross = QtWidgets.QListView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.hole_id_listView_cross.sizePolicy().hasHeightForWidth()) + self.hole_id_listView_cross.setSizePolicy(sizePolicy) + self.hole_id_listView_cross.setStyleSheet("QListView {\n" +" border-radius: 10px; \n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" padding: 5px; /* Adjust padding as needed */\n" +"\n" +"/* Adjust the radius for desired roundness */\n" +" /* Additional styling properties as needed */\n" +"}") + self.hole_id_listView_cross.setObjectName("hole_id_listView_cross") + self.verticalLayout_6.addWidget(self.hole_id_listView_cross) + self.gridLayout_2.addLayout(self.verticalLayout_6, 3, 7, 2, 1) + self.horizontalLayout_3 = QtWidgets.QHBoxLayout() + self.horizontalLayout_3.setContentsMargins(-1, -1, 90, -1) + self.horizontalLayout_3.setObjectName("horizontalLayout_3") + self.help_button = QtWidgets.QPushButton(self.centralwidget) + font = QtGui.QFont() + font.setPointSize(11) + font.setBold(True) + font.setWeight(75) + self.help_button.setFont(font) + self.help_button.setStyleSheet("\n" +"\n" +"QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" color: rgb(170, 0, 0);\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.help_button.setObjectName("help_button") + self.horizontalLayout_3.addWidget(self.help_button) + self.label_8 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setPointSize(10) + self.label_8.setFont(font) + self.label_8.setObjectName("label_8") + self.horizontalLayout_3.addWidget(self.label_8) + self.gridLayout_2.addLayout(self.horizontalLayout_3, 9, 0, 1, 1) + self.horizontalLayout_2 = QtWidgets.QHBoxLayout() + self.horizontalLayout_2.setContentsMargins(-1, -1, 160, -1) + self.horizontalLayout_2.setObjectName("horizontalLayout_2") + self.ft = QtWidgets.QLabel(self.centralwidget) + self.ft.setObjectName("ft") + self.horizontalLayout_2.addWidget(self.ft) + self.geochem_ft_m = QtWidgets.QSlider(self.centralwidget) + self.geochem_ft_m.setStyleSheet("QSlider::handle:horizontal {\n" +" background: rgb(182, 182, 182);\n" +" border: 0px solid #5c5c5c;\n" +" width: 18px;\n" +" margin: -2px 0; \n" +"}\n" +"\n" +"") + self.geochem_ft_m.setOrientation(QtCore.Qt.Horizontal) + self.geochem_ft_m.setObjectName("geochem_ft_m") + self.horizontalLayout_2.addWidget(self.geochem_ft_m) + self.ft_4 = QtWidgets.QLabel(self.centralwidget) + self.ft_4.setObjectName("ft_4") + self.horizontalLayout_2.addWidget(self.ft_4) + self.gridLayout_2.addLayout(self.horizontalLayout_2, 5, 0, 1, 1) + self.verticalLayout_3 = QtWidgets.QVBoxLayout() + self.verticalLayout_3.setContentsMargins(-1, -1, 180, -1) + self.verticalLayout_3.setObjectName("verticalLayout_3") + self.label_4 = QtWidgets.QLabel(self.centralwidget) + self.label_4.setObjectName("label_4") + self.verticalLayout_3.addWidget(self.label_4) + self.hole_id_listView_structure = QtWidgets.QListView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.hole_id_listView_structure.sizePolicy().hasHeightForWidth()) + self.hole_id_listView_structure.setSizePolicy(sizePolicy) + self.hole_id_listView_structure.setStyleSheet("QListView {\n" +" border-radius: 10px; \n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" padding: 5px; /* Adjust padding as needed */\n" +"\n" +"/* Adjust the radius for desired roundness */\n" +" /* Additional styling properties as needed */\n" +"}\n" +"") + self.hole_id_listView_structure.setObjectName("hole_id_listView_structure") + self.verticalLayout_3.addWidget(self.hole_id_listView_structure) + self.gridLayout_2.addLayout(self.verticalLayout_3, 7, 0, 2, 2) + self.verticalLayout_7 = QtWidgets.QVBoxLayout() + self.verticalLayout_7.setContentsMargins(95, -1, 0, -1) + self.verticalLayout_7.setObjectName("verticalLayout_7") + self.label_6 = QtWidgets.QLabel(self.centralwidget) + self.label_6.setObjectName("label_6") + self.verticalLayout_7.addWidget(self.label_6) + self.listview_attri = QtWidgets.QListView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.listview_attri.sizePolicy().hasHeightForWidth()) + self.listview_attri.setSizePolicy(sizePolicy) + self.listview_attri.setStyleSheet("QListView {\n" +" border-radius: 10px; \n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" padding: 5px; /* Adjust padding as needed */\n" +"\n" +"/* Adjust the radius for desired roundness */\n" +" /* Additional styling properties as needed */\n" +"}\n" +"") + self.listview_attri.setObjectName("listview_attri") + self.verticalLayout_7.addWidget(self.listview_attri) + self.gridLayout_2.addLayout(self.verticalLayout_7, 5, 7, 3, 1) + self.formLayout_5 = QtWidgets.QFormLayout() + self.formLayout_5.setObjectName("formLayout_5") + self.import_geochem_csv_button = QtWidgets.QPushButton(self.centralwidget) + self.import_geochem_csv_button.setEnabled(True) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.import_geochem_csv_button.sizePolicy().hasHeightForWidth()) + self.import_geochem_csv_button.setSizePolicy(sizePolicy) + self.import_geochem_csv_button.setBaseSize(QtCore.QSize(40, 50)) + font = QtGui.QFont() + font.setPointSize(14) + font.setBold(True) + font.setWeight(75) + self.import_geochem_csv_button.setFont(font) + self.import_geochem_csv_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #808080; /* Darker gray border */\n" +" background-color: rgba(141, 148, 191, 0.6); /* Semi-transparent background */\n" +"\n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.import_geochem_csv_button.setIconSize(QtCore.QSize(40, 40)) + self.import_geochem_csv_button.setObjectName("import_geochem_csv_button") + self.formLayout_5.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.import_geochem_csv_button) + self.show_geochem_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.show_geochem_button.sizePolicy().hasHeightForWidth()) + self.show_geochem_button.setSizePolicy(sizePolicy) + self.show_geochem_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" background-color: #f2f2f2; /* Adjust background color as needed */\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.show_geochem_button.setText("") + icon = QtGui.QIcon() + icon.addPixmap(QtGui.QPixmap(":/Font_Awesome_5_solid_table.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off) + self.show_geochem_button.setIcon(icon) + self.show_geochem_button.setObjectName("show_geochem_button") + self.formLayout_5.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.show_geochem_button) + self.gridLayout_2.addLayout(self.formLayout_5, 0, 3, 1, 1) + self.label = QtWidgets.QLabel(self.centralwidget) + self.label.setEnabled(True) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.label.sizePolicy().hasHeightForWidth()) + self.label.setSizePolicy(sizePolicy) + self.label.setMaximumSize(QtCore.QSize(815, 376)) + self.label.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" background-color: #f2f2f2; /* Adjust background color as needed */\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.label.setFrameShape(QtWidgets.QFrame.NoFrame) + self.label.setText("") + self.label.setPixmap(QtGui.QPixmap(":/ogp5.png")) + self.label.setScaledContents(False) + self.label.setAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignTop) + self.label.setWordWrap(False) + self.label.setIndent(0) + self.label.setObjectName("label") + self.gridLayout_2.addWidget(self.label, 4, 3, 3, 3) + self.formLayout_4 = QtWidgets.QFormLayout() + self.formLayout_4.setObjectName("formLayout_4") + self.stereonet_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.stereonet_button.sizePolicy().hasHeightForWidth()) + self.stereonet_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.stereonet_button.setFont(font) + self.stereonet_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.stereonet_button.setObjectName("stereonet_button") + self.formLayout_4.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.stereonet_button) + self.alpha_beta_converter_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.alpha_beta_converter_button.sizePolicy().hasHeightForWidth()) + self.alpha_beta_converter_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.alpha_beta_converter_button.setFont(font) + self.alpha_beta_converter_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.alpha_beta_converter_button.setObjectName("alpha_beta_converter_button") + self.formLayout_4.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.alpha_beta_converter_button) + self.rose_diagram_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.rose_diagram_button.sizePolicy().hasHeightForWidth()) + self.rose_diagram_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.rose_diagram_button.setFont(font) + self.rose_diagram_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.rose_diagram_button.setObjectName("rose_diagram_button") + self.formLayout_4.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.rose_diagram_button) + self.unoriented_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.unoriented_button.sizePolicy().hasHeightForWidth()) + self.unoriented_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.unoriented_button.setFont(font) + self.unoriented_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.unoriented_button.setAutoDefault(False) + self.unoriented_button.setObjectName("unoriented_button") + self.formLayout_4.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.unoriented_button) + self.gridLayout_2.addLayout(self.formLayout_4, 1, 5, 2, 1) + self.formLayout = QtWidgets.QFormLayout() + self.formLayout.setObjectName("formLayout") + self.stylize_logs_button = QtWidgets.QPushButton(self.centralwidget) + self.stylize_logs_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +" padding-left: 5px; /* Adjust for desired padding on the left side */\n" +" padding-right: 5px; /* Adjust for desired padding on the right side */\n" +"\n" +"\n" +"}\n" +"\n" +"") + self.stylize_logs_button.setObjectName("stylize_logs_button") + self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.stylize_logs_button) + self.clear_parameters_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.clear_parameters_button.sizePolicy().hasHeightForWidth()) + self.clear_parameters_button.setSizePolicy(sizePolicy) + self.clear_parameters_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +" padding-left: 5px; /* Adjust for desired padding on the left side */\n" +" padding-right: 5px; /* Adjust for desired padding on the right side */\n" +"\n" +"\n" +"}\n" +"") + self.clear_parameters_button.setObjectName("clear_parameters_button") + self.formLayout.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.clear_parameters_button) + self.create_graphic_logs_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.create_graphic_logs_button.sizePolicy().hasHeightForWidth()) + self.create_graphic_logs_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.create_graphic_logs_button.setFont(font) + self.create_graphic_logs_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"\n" +"") + self.create_graphic_logs_button.setObjectName("create_graphic_logs_button") + self.formLayout.setWidget(0, QtWidgets.QFormLayout.SpanningRole, self.create_graphic_logs_button) + self.gridLayout_2.addLayout(self.formLayout, 1, 0, 2, 1) + self.verticalLayout_2 = QtWidgets.QVBoxLayout() + self.verticalLayout_2.setContentsMargins(-1, -1, 180, -1) + self.verticalLayout_2.setObjectName("verticalLayout_2") + self.label_3 = QtWidgets.QLabel(self.centralwidget) + self.label_3.setObjectName("label_3") + self.verticalLayout_2.addWidget(self.label_3) + self.hole_id_listView_geochem = QtWidgets.QListView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.hole_id_listView_geochem.sizePolicy().hasHeightForWidth()) + self.hole_id_listView_geochem.setSizePolicy(sizePolicy) + self.hole_id_listView_geochem.setStyleSheet("QListView {\n" +" border-radius: 10px; \n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" padding: 5px; /* Adjust padding as needed */\n" +"\n" +"/* Adjust the radius for desired roundness */\n" +" /* Additional styling properties as needed */\n" +"}\n" +"") + self.hole_id_listView_geochem.setObjectName("hole_id_listView_geochem") + self.verticalLayout_2.addWidget(self.hole_id_listView_geochem) + self.gridLayout_2.addLayout(self.verticalLayout_2, 6, 0, 1, 2) + self.horizontalLayout = QtWidgets.QHBoxLayout() + self.horizontalLayout.setContentsMargins(-1, -1, 160, -1) + self.horizontalLayout.setObjectName("horizontalLayout") + self.ft_2 = QtWidgets.QLabel(self.centralwidget) + self.ft_2.setObjectName("ft_2") + self.horizontalLayout.addWidget(self.ft_2) + self.lith_ft_m = QtWidgets.QSlider(self.centralwidget) + self.lith_ft_m.setStyleSheet("QSlider::handle:horizontal {\n" +" background: rgb(182, 182, 182);\n" +" border: 0px solid #5c5c5c;\n" +" width: 18px;\n" +" margin: -2px 0; \n" +"}\n" +"\n" +"") + self.lith_ft_m.setOrientation(QtCore.Qt.Horizontal) + self.lith_ft_m.setObjectName("lith_ft_m") + self.horizontalLayout.addWidget(self.lith_ft_m) + self.ft_3 = QtWidgets.QLabel(self.centralwidget) + self.ft_3.setObjectName("ft_3") + self.horizontalLayout.addWidget(self.ft_3) + self.gridLayout_2.addLayout(self.horizontalLayout, 3, 0, 1, 1) + self.formLayout_7 = QtWidgets.QFormLayout() + self.formLayout_7.setObjectName("formLayout_7") + self.upload_des_data = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.upload_des_data.sizePolicy().hasHeightForWidth()) + self.upload_des_data.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.upload_des_data.setFont(font) + self.upload_des_data.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #808080; /* Darker gray border */\n" +" background-color: rgba(141, 148, 191, 0.6); /* Semi-transparent background */\n" +"\n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.upload_des_data.setObjectName("upload_des_data") + self.formLayout_7.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.upload_des_data) + self.show_desurveyed_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.show_desurveyed_button.sizePolicy().hasHeightForWidth()) + self.show_desurveyed_button.setSizePolicy(sizePolicy) + self.show_desurveyed_button.setLayoutDirection(QtCore.Qt.LeftToRight) + self.show_desurveyed_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.show_desurveyed_button.setText("") + self.show_desurveyed_button.setIcon(icon) + self.show_desurveyed_button.setObjectName("show_desurveyed_button") + self.formLayout_7.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.show_desurveyed_button) + self.gridLayout_2.addLayout(self.formLayout_7, 2, 7, 1, 1) + self.verticalLayout_4 = QtWidgets.QVBoxLayout() + self.verticalLayout_4.setObjectName("verticalLayout_4") + self.DEM_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.DEM_button.sizePolicy().hasHeightForWidth()) + self.DEM_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(10) + self.DEM_button.setFont(font) + self.DEM_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.DEM_button.setObjectName("DEM_button") + self.verticalLayout_4.addWidget(self.DEM_button) + self.manage_attributes_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.manage_attributes_button.sizePolicy().hasHeightForWidth()) + self.manage_attributes_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(10) + self.manage_attributes_button.setFont(font) + self.manage_attributes_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.manage_attributes_button.setObjectName("manage_attributes_button") + self.verticalLayout_4.addWidget(self.manage_attributes_button) + self.plot_settings_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.plot_settings_button.sizePolicy().hasHeightForWidth()) + self.plot_settings_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(10) + self.plot_settings_button.setFont(font) + self.plot_settings_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.plot_settings_button.setObjectName("plot_settings_button") + self.verticalLayout_4.addWidget(self.plot_settings_button) + self.create_cross_section_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.create_cross_section_button.sizePolicy().hasHeightForWidth()) + self.create_cross_section_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(11) + font.setBold(True) + font.setWeight(75) + self.create_cross_section_button.setFont(font) + self.create_cross_section_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #808080; /* Darker gray border */\n" +" background-color: rgba(141, 148, 191, 0.6)\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.create_cross_section_button.setObjectName("create_cross_section_button") + self.verticalLayout_4.addWidget(self.create_cross_section_button) + self.view_3d_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.view_3d_button.sizePolicy().hasHeightForWidth()) + self.view_3d_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(10) + font.setBold(True) + font.setWeight(75) + self.view_3d_button.setFont(font) + self.view_3d_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #808080; /* Darker gray border */\n" +" background-color: rgba(141, 148, 191, 0.6)\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.view_3d_button.setObjectName("view_3d_button") + self.verticalLayout_4.addWidget(self.view_3d_button) + self.gridLayout_2.addLayout(self.verticalLayout_4, 8, 7, 2, 1) + spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) + self.gridLayout_2.addItem(spacerItem1, 0, 4, 1, 1) + self.gridLayout = QtWidgets.QGridLayout() + self.gridLayout.setObjectName("gridLayout") + self.label_10 = QtWidgets.QLabel(self.centralwidget) + self.label_10.setObjectName("label_10") + self.gridLayout.addWidget(self.label_10, 0, 0, 1, 1) + self.merge_plots = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.merge_plots.sizePolicy().hasHeightForWidth()) + self.merge_plots.setSizePolicy(sizePolicy) + self.merge_plots.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +" padding-left: 5px; /* Adjust for desired padding on the left side */\n" +" padding-right: 5px; /* Adjust for desired padding on the right side */\n" +"\n" +"\n" +"}\n" +"\n" +"") + self.merge_plots.setObjectName("merge_plots") + self.gridLayout.addWidget(self.merge_plots, 0, 1, 1, 1) + self.label_9 = QtWidgets.QLabel(self.centralwidget) + self.label_9.setObjectName("label_9") + self.gridLayout.addWidget(self.label_9, 0, 2, 1, 1) + self.gridLayout_2.addLayout(self.gridLayout, 1, 1, 1, 1) + self.verticalLayout = QtWidgets.QVBoxLayout() + self.verticalLayout.setContentsMargins(-1, -1, 180, 0) + self.verticalLayout.setObjectName("verticalLayout") + self.label_2 = QtWidgets.QLabel(self.centralwidget) + self.label_2.setObjectName("label_2") + self.verticalLayout.addWidget(self.label_2) + self.hole_id_listView_lithology = QtWidgets.QListView(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.hole_id_listView_lithology.sizePolicy().hasHeightForWidth()) + self.hole_id_listView_lithology.setSizePolicy(sizePolicy) + self.hole_id_listView_lithology.setStyleSheet("QListView {\n" +" border-radius: 10px; \n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" padding: 5px; /* Adjust padding as needed */\n" +"\n" +"/* Adjust the radius for desired roundness */\n" +" /* Additional styling properties as needed */\n" +"}\n" +"") + self.hole_id_listView_lithology.setObjectName("hole_id_listView_lithology") + self.verticalLayout.addWidget(self.hole_id_listView_lithology) + self.gridLayout_2.addLayout(self.verticalLayout, 4, 0, 1, 2) + self.formLayout_3 = QtWidgets.QFormLayout() + self.formLayout_3.setObjectName("formLayout_3") + self.downhole_plots_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.downhole_plots_button.sizePolicy().hasHeightForWidth()) + self.downhole_plots_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.downhole_plots_button.setFont(font) + self.downhole_plots_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.downhole_plots_button.setObjectName("downhole_plots_button") + self.formLayout_3.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.downhole_plots_button) + self.XYscatter_plots_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.XYscatter_plots_button.sizePolicy().hasHeightForWidth()) + self.XYscatter_plots_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.XYscatter_plots_button.setFont(font) + self.XYscatter_plots_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.XYscatter_plots_button.setObjectName("XYscatter_plots_button") + self.formLayout_3.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.XYscatter_plots_button) + self.factor_analysis_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.factor_analysis_button.sizePolicy().hasHeightForWidth()) + self.factor_analysis_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.factor_analysis_button.setFont(font) + self.factor_analysis_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.factor_analysis_button.setObjectName("factor_analysis_button") + self.formLayout_3.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.factor_analysis_button) + self.correlation_matrices = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.correlation_matrices.sizePolicy().hasHeightForWidth()) + self.correlation_matrices.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.correlation_matrices.setFont(font) + self.correlation_matrices.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.correlation_matrices.setObjectName("correlation_matrices") + self.formLayout_3.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.correlation_matrices) + self.custom_plot_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.custom_plot_button.sizePolicy().hasHeightForWidth()) + self.custom_plot_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(12) + self.custom_plot_button.setFont(font) + self.custom_plot_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.custom_plot_button.setObjectName("custom_plot_button") + self.formLayout_3.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.custom_plot_button) + self.gridLayout_2.addLayout(self.formLayout_3, 1, 3, 2, 1) + self.formLayout_6 = QtWidgets.QFormLayout() + self.formLayout_6.setObjectName("formLayout_6") + self.import_structure_csv_button = QtWidgets.QPushButton(self.centralwidget) + self.import_structure_csv_button.setEnabled(True) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.import_structure_csv_button.sizePolicy().hasHeightForWidth()) + self.import_structure_csv_button.setSizePolicy(sizePolicy) + self.import_structure_csv_button.setBaseSize(QtCore.QSize(40, 50)) + font = QtGui.QFont() + font.setPointSize(14) + font.setBold(True) + font.setWeight(75) + self.import_structure_csv_button.setFont(font) + self.import_structure_csv_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #808080; /* Darker gray border */\n" +" background-color: rgba(141, 148, 191, 0.6); /* Semi-transparent background */\n" +"\n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.import_structure_csv_button.setIconSize(QtCore.QSize(40, 40)) + self.import_structure_csv_button.setObjectName("import_structure_csv_button") + self.formLayout_6.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.import_structure_csv_button) + self.show_structure_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.show_structure_button.sizePolicy().hasHeightForWidth()) + self.show_structure_button.setSizePolicy(sizePolicy) + self.show_structure_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 1.5px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.show_structure_button.setText("") + self.show_structure_button.setIcon(icon) + self.show_structure_button.setObjectName("show_structure_button") + self.formLayout_6.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.show_structure_button) + self.gridLayout_2.addLayout(self.formLayout_6, 0, 5, 1, 1) + self.verticalLayout_5 = QtWidgets.QVBoxLayout() + self.verticalLayout_5.setObjectName("verticalLayout_5") + self.label_5 = QtWidgets.QLabel(self.centralwidget) + font = QtGui.QFont() + font.setPointSize(18) + font.setBold(True) + font.setWeight(75) + self.label_5.setFont(font) + self.label_5.setStyleSheet("color : rgb(141, 148, 191)\n" +"\n" +"\n" +"\n" +"\n" +"\n" +"\n" +"") + self.label_5.setFrameShape(QtWidgets.QFrame.NoFrame) + self.label_5.setObjectName("label_5") + self.verticalLayout_5.addWidget(self.label_5) + self.desurvey_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.desurvey_button.sizePolicy().hasHeightForWidth()) + self.desurvey_button.setSizePolicy(sizePolicy) + font = QtGui.QFont() + font.setPointSize(10) + self.desurvey_button.setFont(font) + self.desurvey_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}") + self.desurvey_button.setObjectName("desurvey_button") + self.verticalLayout_5.addWidget(self.desurvey_button) + self.gridLayout_2.addLayout(self.verticalLayout_5, 0, 7, 2, 1) + self.formLayout_2 = QtWidgets.QFormLayout() + self.formLayout_2.setObjectName("formLayout_2") + self.import_lithology_csv_button = QtWidgets.QPushButton(self.centralwidget) + self.import_lithology_csv_button.setEnabled(True) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(1) + sizePolicy.setVerticalStretch(1) + sizePolicy.setHeightForWidth(self.import_lithology_csv_button.sizePolicy().hasHeightForWidth()) + self.import_lithology_csv_button.setSizePolicy(sizePolicy) + self.import_lithology_csv_button.setBaseSize(QtCore.QSize(40, 50)) + font = QtGui.QFont() + font.setPointSize(14) + font.setBold(True) + font.setWeight(75) + self.import_lithology_csv_button.setFont(font) + self.import_lithology_csv_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #808080; /* Darker gray border */\n" +" background-color: rgba(141, 148, 191, 0.6); /* Semi-transparent background */\n" +"\n" +" /* Horizontal padding */\n" +" padding-left: 10px; /* Adjust for desired padding on the left side */\n" +" padding-right: 10px; /* Adjust for desired padding on the right side */\n" +"\n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"\n" +"") + self.import_lithology_csv_button.setIconSize(QtCore.QSize(40, 40)) + self.import_lithology_csv_button.setObjectName("import_lithology_csv_button") + self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.import_lithology_csv_button) + self.show_lith_button = QtWidgets.QPushButton(self.centralwidget) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.show_lith_button.sizePolicy().hasHeightForWidth()) + self.show_lith_button.setSizePolicy(sizePolicy) + self.show_lith_button.setStyleSheet("QPushButton {\n" +" border-radius: 10px; /* Adjust for desired roundness */\n" +" border: 2px solid #A9A9A9; /* Dark gray border */\n" +" \n" +" /* Other styling properties like padding, font, etc. */\n" +"}\n" +"") + self.show_lith_button.setText("") + self.show_lith_button.setIcon(icon) + self.show_lith_button.setObjectName("show_lith_button") + self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.show_lith_button) + self.gridLayout_2.addLayout(self.formLayout_2, 0, 0, 1, 2) + spacerItem2 = QtWidgets.QSpacerItem(20, 20, QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Minimum) + self.gridLayout_2.addItem(spacerItem2, 1, 2, 1, 1) + MainWindow.setCentralWidget(self.centralwidget) + self.menubar = QtWidgets.QMenuBar(MainWindow) + self.menubar.setGeometry(QtCore.QRect(0, 0, 1537, 25)) + self.menubar.setObjectName("menubar") + self.menuOpenGeoLogger = QtWidgets.QMenu(self.menubar) + self.menuOpenGeoLogger.setObjectName("menuOpenGeoLogger") + self.menuPreferences = QtWidgets.QMenu(self.menubar) + self.menuPreferences.setObjectName("menuPreferences") + MainWindow.setMenuBar(self.menubar) + self.statusbar = QtWidgets.QStatusBar(MainWindow) + self.statusbar.setObjectName("statusbar") + MainWindow.setStatusBar(self.statusbar) + self.actionSave = QtWidgets.QAction(MainWindow) + self.actionSave.setObjectName("actionSave") + self.actionSave_As = QtWidgets.QAction(MainWindow) + self.actionSave_As.setObjectName("actionSave_As") + self.actionOpen = QtWidgets.QAction(MainWindow) + self.actionOpen.setObjectName("actionOpen") + self.actionExport = QtWidgets.QAction(MainWindow) + self.actionExport.setObjectName("actionExport") + self.actionDEM_Adjust = QtWidgets.QAction(MainWindow) + self.actionDEM_Adjust.setObjectName("actionDEM_Adjust") + self.menuOpenGeoLogger.addAction(self.actionSave) + self.menuOpenGeoLogger.addAction(self.actionSave_As) + self.menuOpenGeoLogger.addAction(self.actionOpen) + self.menuPreferences.addAction(self.actionExport) + self.menubar.addAction(self.menuOpenGeoLogger.menuAction()) + self.menubar.addAction(self.menuPreferences.menuAction()) + + self.retranslateUi(MainWindow) + QtCore.QMetaObject.connectSlotsByName(MainWindow) + + def retranslateUi(self, MainWindow): + _translate = QtCore.QCoreApplication.translate + MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.label_7.setText(_translate("MainWindow", "Choose Drill Holes")) + self.help_button.setText(_translate("MainWindow", "?")) + self.label_8.setText(_translate("MainWindow", "Help")) + self.ft.setText(_translate("MainWindow", "ft")) + self.ft_4.setText(_translate("MainWindow", "m")) + self.label_4.setText(_translate("MainWindow", "Structure Hole IDs")) + self.label_6.setText(_translate("MainWindow", "Choose an Attribute to Plot")) + self.import_geochem_csv_button.setText(_translate("MainWindow", "Import Geochem CSV")) + self.stereonet_button.setText(_translate("MainWindow", "Stereonet")) + self.alpha_beta_converter_button.setText(_translate("MainWindow", "Alpha Beta Converter")) + self.rose_diagram_button.setText(_translate("MainWindow", "Rose Diagram")) + self.unoriented_button.setText(_translate("MainWindow", "Small Circles // \n" +"Unoriented core")) + self.stylize_logs_button.setText(_translate("MainWindow", "Stylize Logs")) + self.clear_parameters_button.setText(_translate("MainWindow", "Clear Style")) + self.create_graphic_logs_button.setText(_translate("MainWindow", "Create Graphic Logs")) + self.label_3.setText(_translate("MainWindow", "Geochem Hole IDs")) + self.ft_2.setText(_translate("MainWindow", "ft")) + self.ft_3.setText(_translate("MainWindow", "m")) + self.upload_des_data.setText(_translate("MainWindow", "Import Desurveyed Data")) + self.DEM_button.setText(_translate("MainWindow", "Upload DEM")) + self.manage_attributes_button.setText(_translate("MainWindow", "Manage Attributes")) + self.plot_settings_button.setText(_translate("MainWindow", "Plot Settings")) + self.create_cross_section_button.setText(_translate("MainWindow", "Create Cross Section")) + self.view_3d_button.setText(_translate("MainWindow", "View in 3D")) + self.label_10.setText(_translate("MainWindow", "<-")) + self.merge_plots.setText(_translate("MainWindow", "Merge Plot Windows")) + self.label_9.setText(_translate("MainWindow", "->")) + self.label_2.setText(_translate("MainWindow", "Lithology Holde IDs")) + self.downhole_plots_button.setText(_translate("MainWindow", "Downhole Line Plots")) + self.XYscatter_plots_button.setText(_translate("MainWindow", "XY Scatter Plots")) + self.factor_analysis_button.setText(_translate("MainWindow", "Factor Analysis")) + self.correlation_matrices.setText(_translate("MainWindow", "Correlation Matrices")) + self.custom_plot_button.setText(_translate("MainWindow", "Use Custom Plot")) + self.import_structure_csv_button.setText(_translate("MainWindow", "Import Structure CSV")) + self.label_5.setText(_translate("MainWindow", "Cross Section Visualizer")) + self.desurvey_button.setText(_translate("MainWindow", "Desurvey Your Data")) + self.import_lithology_csv_button.setText(_translate("MainWindow", "Import Lithology CSV")) + self.menuOpenGeoLogger.setTitle(_translate("MainWindow", "File")) + self.menuPreferences.setTitle(_translate("MainWindow", "Options")) + self.actionSave.setText(_translate("MainWindow", "Save")) + self.actionSave_As.setText(_translate("MainWindow", "Save As")) + self.actionOpen.setText(_translate("MainWindow", "Open")) + self.actionExport.setText(_translate("MainWindow", "Export CSVs")) + self.actionDEM_Adjust.setText(_translate("MainWindow", "DEM Adjust")) +import Test_1_rc + +import pics + + +if __name__ == "__main__": + import sys + app = QtWidgets.QApplication(sys.argv) + MainWindow = QtWidgets.QMainWindow() + ui = Ui_MainWindow() + ui.setupUi(MainWindow) + MainWindow.show() + sys.exit(app.exec_()) diff --git a/Test_1_rc.py b/Test_1_rc.py new file mode 100644 index 0000000..f4253fb --- /dev/null +++ b/Test_1_rc.py @@ -0,0 +1,1865 @@ +# -*- coding: utf-8 -*- + +# Resource object code +# +# Created by: The Resource Compiler for PyQt5 (Qt v5.15.2) +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore + +qt_resource_data = b"\ +\x00\x00\x71\x0a\ +\x89\ +\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\ +\x00\x03\xac\x00\x00\x00\x7e\x08\x06\x00\x00\x00\x20\x25\x9c\xfd\ +\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x1e\xc2\x00\x00\x1e\xc2\ +\x01\x6e\xd0\x75\x3e\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\ +\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\ +\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x20\x00\x49\x44\ +\x41\x54\x78\x9c\xec\xbd\x79\xbc\x65\x55\x75\xef\xfb\x1b\x63\x75\ +\xbb\x39\x7d\xf5\x7d\xdf\xd1\xa9\x34\x82\x04\x4c\x10\x6c\xd0\x80\ +\x88\x08\xe6\x86\xdc\x24\xe6\x46\x4d\x6e\x1a\x35\x37\x2f\x9a\x97\ +\xdc\x24\xef\xfa\x92\xcb\x4b\x5e\xc8\xd5\xe4\xde\xbc\x8f\xd7\x18\ +\xe3\x55\xb9\x46\x23\x21\x18\x5b\x6c\x08\xa0\x80\x88\x20\x48\x15\ +\x50\x45\x55\x51\x7d\x7b\xea\x34\xfb\xec\xbd\xd7\x9a\x73\xbc\x3f\ +\xe6\x9c\xe7\x6c\xca\x82\xaa\xda\x67\x9f\xa6\x8a\xf1\xfd\x7c\xf6\ +\xe7\x9c\xb3\xcf\x5e\x6b\xcd\xdd\xad\x35\x7f\x73\x8c\xf1\x1b\x80\ +\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\ +\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\ +\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\ +\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\ +\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\ +\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\ +\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\x28\x8a\xa2\ +\x28\x8a\x32\x73\xcc\x01\xb0\x70\xa6\x07\xa1\x28\x8a\xa2\x28\x8a\ +\xa2\x28\x8a\xa2\x28\x81\x14\xc0\xc0\xb2\x65\xcb\xfe\x7e\x60\x60\ +\xe0\x2b\x5d\x5d\x5d\xf3\x00\x94\x67\x7a\x50\x8a\xa2\x28\x8a\x32\ +\x15\xd0\x4c\x0f\x40\x51\x14\x45\x51\x94\x17\x50\x05\x70\x3e\x80\ +\x8d\x71\x1c\x6f\xea\xef\x5f\x79\x99\x48\x7d\xdd\xe8\x28\xe6\xe4\ +\xf9\xbe\xa4\x28\x0a\x02\x08\x49\x72\x1e\x98\x63\x34\x1a\x35\x00\ +\x31\xa2\xc8\x22\x4d\xab\x79\x96\x95\x46\x81\x6c\xdb\xe8\xe8\xfe\ +\x87\xf3\xfc\x89\x47\x00\x6c\x01\xf0\x18\x80\x63\x33\xf9\xa4\x14\ +\x45\x51\x14\xa5\x1d\x54\xb0\x2a\x8a\xa2\x28\xca\xcc\x52\x02\x70\ +\xd9\x9b\xa3\x8d\xef\xbc\x2f\xdb\x75\xc9\x48\xbd\xf6\x8a\xee\xee\ +\xee\x91\x0b\x2e\xb8\xa0\xba\x7a\xf5\xea\x82\xf9\xfa\xd2\xb5\xd7\ +\xda\x22\xcf\xd7\xc5\xe7\x9d\x47\xd2\xd5\xd5\x45\x87\x0f\xf7\x63\ +\x6c\x8c\x70\xde\x79\x16\x00\x30\x38\x38\x88\xd1\xd1\x51\xd4\x6a\ +\x35\xec\xdb\xb7\xcf\x6c\xdb\xb6\x8d\x1f\x7f\x7c\x77\xbe\x79\xf3\ +\xa1\xe8\xa9\xa7\x9e\x1e\x1d\x1e\x1e\xec\x8a\xe3\xca\x56\xa2\xb1\ +\x7b\x1a\x8d\x1f\xdf\x05\xe0\xdf\x00\x8c\xcc\xe4\x93\x56\x14\x45\ +\x51\x94\x53\x41\x05\xab\xa2\x28\x8a\xa2\x4c\x3f\x09\x80\x37\x55\ +\xab\xd5\x5f\x95\x5a\xf1\xfa\x6f\xc5\xbf\x9c\x4a\xa5\xa7\xfe\xfd\ +\x0f\x2f\x4b\x7f\xe6\xaa\xab\xb0\x78\xf1\x62\xb1\xd6\xd6\x99\xb9\ +\xeb\x6b\x5f\x4b\x9b\x97\x5c\xd2\xc8\x6a\x35\x36\x8b\x17\x5b\x06\ +\x80\x67\x9e\x89\x60\x8c\xd0\xc6\x8d\x56\x5a\xf6\x49\x22\x22\x44\ +\x04\x22\xca\x01\xc4\x22\xd2\x10\x11\x3a\x72\xe4\x48\x7a\xef\xbd\ +\xf7\x36\x3f\xfb\xd9\x6f\xee\x7b\xf2\xc9\x7d\x0b\xf6\xef\xdf\x9f\ +\x96\xcb\xd5\xef\xd7\x6a\x0f\xfd\x37\x00\x77\x02\x18\x9b\x81\xd7\ +\x40\x51\x14\x45\x51\x4e\x8a\x0a\x56\x45\x51\x14\x45\x99\x3e\x5e\ +\xb1\x61\xc3\x86\x3f\xdc\xbf\x7f\xff\xf5\xe5\x72\xb9\xf8\xf3\x45\ +\x6f\x3f\xf8\xf6\x43\xcb\x17\x3d\xf7\x9f\xde\x44\x0b\x7e\x7e\xe9\ +\x28\x33\x35\xac\xb5\xfd\x44\xd4\x10\x91\xec\xc0\x01\xc2\x8e\x1d\ +\x51\xdc\xdd\x2d\xc5\xa6\x4d\x36\x12\x11\x02\x60\xbe\xf6\xb5\x44\ +\x7e\xe6\x67\x0a\x4a\x53\x21\x11\x29\x88\x28\x12\x91\x38\x8a\x22\ +\x5b\x14\x45\xce\xcc\x29\x80\x06\x00\x06\x90\xc3\xd5\xbd\xd6\x89\ +\x68\x54\x44\xe6\xef\xd8\xb1\x63\xeb\x27\x3e\x71\x07\x7f\xee\x73\ +\x3f\x98\x3b\x34\x34\xd8\xbd\x78\x71\xd7\xfd\x5b\xb7\x7e\xfb\xf7\ +\x01\xdc\x37\x83\xaf\x8d\xa2\x28\x8a\xa2\xfc\x04\x2a\x58\x15\x45\ +\x51\x14\x65\x8a\x29\x95\x4a\x57\x5e\xb8\x70\xdd\xff\x34\xfb\x87\ +\xd7\x6d\xbc\xf9\xa7\xe9\x96\x9b\x6e\xc2\x35\x7f\x7d\x54\x30\xd2\ +\xc4\xf0\x1d\x3f\x5b\x7b\x62\x5b\x69\xcf\xf9\xe7\xdb\xd5\x22\x32\ +\x28\x22\x96\x88\xe6\x12\xd1\xde\xcd\x9b\x79\x11\x60\xeb\x22\x9c\ +\x6e\xdc\x68\x0c\x80\xc4\x18\xe0\x9e\x7b\xd2\xfc\xf5\xaf\x6f\x08\ +\x33\xb3\x17\xb1\xe1\x26\x00\x2c\x80\x3a\x80\x2e\x00\xfb\x89\x68\ +\x1e\x80\x51\x00\x43\x22\xb2\x84\x88\x1e\x03\xb0\x49\x44\x8c\x88\ +\x54\x9e\x78\xe2\x09\xfc\xc3\x3f\xfc\x2b\xbe\xf0\x85\x7f\x93\x6a\ +\xb5\x7b\x7f\xad\xf6\xc8\xaf\x0d\x0e\x1e\xfe\x67\xbf\x2f\x45\x51\ +\x14\x45\x99\x51\x54\xb0\x2a\x8a\xa2\x28\xca\xd4\xf1\xfa\x05\x0b\ +\x16\xdc\xbe\x7c\xac\x7a\xce\x6f\xbd\xee\x16\xbc\xe6\x2f\x7e\x85\ +\xe6\x3d\x35\x86\xea\x07\xbf\x83\xfa\xaf\xbe\x02\x8d\x5f\x38\x47\ +\x00\xd4\xb7\x6c\x89\x68\xc3\x06\xb3\x57\x44\x96\x12\x11\x00\x1c\ +\x26\xa2\x81\x47\x1f\x8d\xa9\xaf\xcf\x50\x51\xd0\xd0\xda\xb5\xa6\ +\x57\x44\x78\xdb\xb6\x68\xac\xd9\x44\x65\xe3\x46\x33\x46\x44\xb1\ +\x88\x44\x44\x34\x02\xa0\x9b\x88\xac\xb5\x76\x04\x40\xc6\xcc\xe4\ +\xc5\xec\x08\x9c\x8b\x70\x02\x60\x1b\x11\x2d\x87\x8b\xbc\xc6\xd6\ +\x5a\x26\x22\x88\x08\xea\xf5\x3a\x3e\xf1\x89\x4f\xc9\x47\x3e\xf2\ +\x35\x58\x6b\x0e\x0c\x0e\xde\xff\x9b\xc6\x98\xcf\x43\x85\xab\xa2\ +\x28\x8a\x32\x83\xa8\x60\x55\x14\x45\x51\x94\xce\xb3\x6a\xd1\xa2\ +\x45\x77\x34\x1a\x8d\x8b\xff\xf4\xe6\xdf\xa6\x1b\x2f\xbb\x86\xa2\ +\xeb\x36\xa2\xfc\xa7\x0f\x22\xf9\xf6\x0e\xd4\xfe\xea\x6a\x29\xce\ +\x99\x43\x00\xd0\x6c\x92\xec\xdd\x4b\xb5\x95\x2b\x05\x00\x12\x11\ +\x69\x02\x68\xd4\xeb\xdc\xfb\xf0\xc3\x11\xfa\xfb\xed\xae\x73\xcf\ +\xb5\xcb\x88\x24\x17\x91\xd2\x37\xbf\x99\x8e\x5c\x79\xa5\x49\xb3\ +\x4c\x72\xff\xf8\xc2\xd7\xac\xf6\x88\x88\xf1\xc7\x7f\x1e\xc0\x42\ +\x11\xc9\x00\x1c\x04\xd0\xeb\x6b\x5b\x9b\x5e\xc4\x76\x79\xa1\xfa\ +\x13\xf3\x80\x46\xa3\x81\x4f\x7f\xfa\x1f\xe5\x2f\xfe\xe2\x6e\xc9\ +\xf3\xda\x8e\x23\x47\xee\x7f\x1b\x9c\xcb\xb0\xa2\x28\x8a\xa2\x4c\ +\x3b\xd1\x4c\x0f\x40\x51\x14\x45\x51\xce\x22\x92\x05\x0b\x16\x7c\ +\xc8\x18\xf3\x85\x37\xbc\xe1\x0d\xcb\xbe\xf8\xc1\xbf\xc6\x25\xeb\ +\xcf\x27\x5c\xbd\x52\xba\x7f\xfe\x4b\x84\x5a\x8e\xda\x47\x5f\x0f\ +\xb3\xaa\x37\xa4\xef\xd2\xd6\xad\x4c\xab\x57\xdb\x14\x40\x42\x44\ +\xc4\xcc\xbb\x45\xa4\xfb\xb9\xe7\x38\x4b\x12\x6c\x4d\x12\x59\x3e\ +\x77\xae\x1c\x06\xd0\x43\x44\xf6\xd9\x67\x63\x5a\xbf\xbe\x68\x00\ +\x88\x7d\xed\x6a\x0d\x2e\x82\x4a\x70\xd7\xf5\x83\x44\xb4\x98\x88\ +\x36\x03\x98\x0b\x20\x03\xf0\x1c\x33\xcf\x17\x91\x12\x5c\x3d\x2b\ +\x01\x20\x22\x12\xb4\x2c\x5e\x8b\x08\xe2\x38\x96\x57\xbd\xea\x02\ +\x7a\xf7\xbb\xdf\x2a\x45\x31\x34\xf0\xd0\x43\xa3\xef\xee\xef\x9f\ +\xfb\xaa\x5a\x6d\xff\x97\xe1\xea\x62\x15\x45\x51\x14\x65\xda\xe0\ +\x99\x1e\x80\xa2\x28\x8a\xa2\x9c\x25\x5c\xda\xd7\xd7\xb7\x6b\xc9\ +\x92\x25\x7f\xf2\xe5\x2f\x7f\x39\xfe\xd8\x2f\xfd\x67\xe9\xe9\xed\ +\x21\x73\xde\x02\xdb\x7d\xed\xe7\xa9\xd8\x34\x07\xb5\xff\x76\x35\ +\xec\x82\x0a\xe0\xc5\x2a\x00\x10\xb1\xb8\x2c\x60\x10\x00\xb6\xd6\ +\xae\x02\xd0\x63\x0c\x06\x93\x04\xf3\x00\x0a\x0e\xbe\x0c\xc0\x00\ +\x12\x8b\xc8\xb8\x70\x24\xa2\x31\x38\x11\x5a\xf8\x7d\x64\xd6\xda\ +\x43\x22\xb2\x0a\xae\x86\x35\x23\xa2\x0d\x7e\xfb\x50\xeb\x0a\x00\ +\x70\xa6\xc2\x24\xfe\x77\x04\x01\x2b\x22\x92\x24\x09\xff\xee\xef\ +\xfe\x47\x79\xe0\x81\xff\xce\x1b\x36\x9c\xf3\xd6\x6a\xf5\xca\x7d\ +\x40\xf4\xb3\x53\xf8\xfa\x29\x8a\xa2\x28\xca\x4f\xa0\x82\x55\x51\ +\x14\x45\x51\x26\x07\xf5\xf6\xf6\x7e\xa8\x5c\x2e\xdf\xf7\xc1\x0f\ +\x7e\x70\xde\x57\xbf\xfa\x55\xbe\x10\x8b\x44\x12\x26\x1a\xac\x4b\ +\xd7\x3b\xef\xe4\xc6\x5b\xd7\xcb\xd8\xff\xf1\x6a\x48\x39\x06\x5e\ +\x20\x56\x5d\x27\x1a\xbf\x1f\x11\x11\xc0\x5f\x9b\xa3\x08\xfd\x44\ +\xd2\x97\xa6\xe8\x12\x91\x79\x00\x30\x3c\x4c\x51\xb5\x2a\x11\x11\ +\xa5\x70\xd1\x54\xc2\x44\x74\x35\xf6\xfb\xe9\x25\xa2\xb9\x70\xa6\ +\x4b\x4b\xfc\x7d\x1c\x8e\xe7\x0f\x14\x7e\x0f\xc7\x0f\x75\xaa\x04\ +\xc0\xa9\x58\x3f\x98\x95\x2b\x57\xe2\xae\xbb\xfe\x5a\x6e\xbf\xfd\ +\x97\x4b\x95\xca\xa5\xff\x3c\x30\x70\xfe\xdf\xc1\xd5\xc3\x2a\x8a\ +\xa2\x28\xca\x94\xa3\x35\xac\x8a\xa2\x28\x8a\xd2\x3e\xbd\x0b\x17\ +\x2e\xbc\x93\x88\xae\xf8\xe4\x27\x3f\x19\x5f\x7c\xf1\xc5\x96\x7f\ +\xb8\x9f\x79\xcc\x08\x6f\x39\x8c\xe4\x1b\x3b\xa9\xb8\x76\x95\xd4\ +\x6f\xd9\x48\x88\xc6\xc5\xe2\x78\x54\x93\x88\xb0\x65\x0b\xd3\xfa\ +\xf5\x46\x5a\x6b\x4a\x8b\x82\x64\xd7\x2e\xc6\xce\x9d\x11\x2e\xbb\ +\xac\x49\x69\xea\x0e\xf6\xed\x6f\xc7\xb8\xf4\xd2\x02\xa5\x92\xc0\ +\x9b\x33\x01\x2f\x14\x9b\xf0\xfb\x0d\x7a\x13\x2d\xc7\x0c\x8f\x6d\ +\xbd\xf6\xbf\x40\xa8\xb6\xfc\x6e\x01\xb0\xef\xeb\x2a\x22\xc2\x44\ +\x64\x77\xee\xdc\xc9\xb7\xde\xfa\x87\x66\xf7\xee\x03\xbb\x06\x07\ +\x1f\xba\x0a\xc0\x73\x9d\x79\x19\x15\x45\x51\x14\xe5\xc4\x68\x84\ +\x55\x51\x14\x45\x51\xda\xe3\xdc\x6a\xb5\xba\xf5\xb2\xcb\x2e\x7b\ +\xed\xf7\xbe\xf7\xbd\xe8\xe2\x8b\x2f\xb6\xfc\xd4\x61\xa6\xa1\xa6\ +\x8d\x1f\xde\x8b\xe4\xd1\x43\xc8\xaf\x5b\x23\x63\xb7\x6c\x20\x44\ +\x24\xae\x03\x8d\x13\xab\x41\x6c\x1e\x17\xdd\x04\xe0\xc4\xe6\xf6\ +\xed\x44\xcb\x96\x19\xe4\x39\x10\xc4\x2a\x00\xe4\x39\xa1\x5c\x86\ +\x04\xc1\xdb\xb2\xcd\x0b\x06\x26\x22\xc4\xcc\xd2\xf2\x7f\x69\xf9\ +\x9f\x10\x91\x3d\xee\xb9\x08\x7c\x4d\xab\x7f\x2c\x03\xb0\xcc\x8c\ +\xf0\xbb\x88\xf0\xca\x95\x2b\xcd\x37\xbe\xf1\x31\xbe\xfe\xfa\xcb\ +\x97\x67\xd9\x65\x4f\x02\xb8\xb2\xcd\xd7\x4e\x51\x14\x45\x51\x4e\ +\x09\x15\xac\x8a\xa2\x28\x8a\x72\xfa\xbc\x26\xcb\xb2\x07\x3f\xf0\ +\x81\x0f\x0c\x7c\xfc\xe3\x1f\x47\x77\x77\xb7\xd0\xbe\x51\xe2\x6d\ +\x83\x36\xfd\xca\x76\xc6\x60\x13\xf9\x65\x0b\xa5\x71\xe3\x3a\xe2\ +\x38\xb2\x22\x02\xdf\x42\x66\x3c\x25\x17\x3e\xaa\xc9\x4c\xe3\xd1\ +\x55\x1f\xcd\x14\x11\x92\x28\xc2\xf1\x2e\xbe\x41\x4c\xb6\x8a\xdc\ +\xf1\xb4\xde\x56\x11\xea\x8f\xf7\x82\x88\x2b\x26\x44\x69\x38\x96\ +\x6d\x4d\x47\x0e\x91\x54\x1f\x9a\x1d\x17\xad\xbe\x2f\x2c\x33\xb3\ +\xb1\xd6\x72\x92\x24\xb8\xfd\xf6\x3f\xb4\x7f\xf9\x97\xbf\x5c\x4e\ +\xd3\x2b\xee\x89\xa2\xf2\xdb\xa6\xe6\x25\x56\x14\x45\x51\x14\x15\ +\xac\x8a\xa2\x28\x8a\x72\x5a\xc4\x71\xfc\xfa\x52\xa9\xf4\xcd\xdb\ +\x6e\xbb\xad\xf2\xfe\xf7\xbf\xbf\x00\x40\x34\x56\x48\x7c\xff\x2e\ +\x24\xdf\xdd\xcd\xb2\xa0\x6c\xcd\xaa\x6e\x34\xdf\xb6\x8e\x29\x89\ +\x2c\xe0\x55\xa2\x13\x7f\x61\x37\x04\x40\x8a\x02\x12\xc7\xe3\xe2\ +\x52\x7c\x6d\x29\x44\x9c\x56\x25\x9a\x10\xa6\xc6\x08\x31\x23\xa4\ +\x12\x8f\x3f\xd6\xef\xcb\xb6\x46\x6b\xc3\xfd\xe1\x71\x2d\xf9\xc1\ +\xe3\x29\xc1\x41\x98\xfa\xed\xc8\x5a\x1b\xee\x63\x38\x01\x6b\xad\ +\xb5\x91\xdf\x97\x11\x91\xa8\xe5\xd8\xd1\x3b\xdf\x79\x53\xfe\xd9\ +\xcf\x7e\x20\x4e\xd3\x57\x7e\x8e\x79\xde\x6f\x4c\xd1\xcb\xad\x28\ +\x8a\xa2\xbc\xcc\xd1\xb6\x36\x8a\xa2\x28\x8a\x72\xea\xbc\x33\xcb\ +\xb2\x2f\x7c\xec\x63\x1f\x8b\xdf\xf1\x8e\x77\x58\x11\x89\xc5\x58\ +\x93\xfd\xe3\x96\x28\x7d\x60\x0f\xec\xe2\x1e\x31\x4b\xba\x28\xbf\ +\x76\x35\xa4\x9a\x58\x38\xf1\xe7\xdd\x7d\x41\xcc\x1c\xda\xc9\x18\ +\x22\xc2\xe1\xc3\x11\xaa\x55\xcb\x95\xca\xb8\x00\xb5\x44\xc4\x87\ +\x0e\x01\x71\x4c\x34\x3c\x4c\xb4\x6c\x99\x08\x00\xda\xb9\x33\x31\ +\x59\x66\x79\xfe\x7c\x27\x4e\x5b\xd2\x80\x89\x88\x0a\x00\x91\xdf\ +\xbe\xd5\x09\x38\x98\x28\x05\x11\x2a\x22\xc2\x18\xd7\xd0\x13\xad\ +\x6d\x88\x08\x3e\x8d\xd8\xfa\x7d\xb5\x46\x74\xc3\x31\xb8\x65\xfc\ +\xf1\xca\x95\x2b\xcc\x95\x57\xae\xa3\x2f\x7e\xf1\xc9\x6b\x8b\xa2\ +\xb0\x22\x23\xf7\x4e\xc3\x7b\xa0\x28\x8a\xa2\xbc\x8c\xd0\x08\xab\ +\xa2\x28\x8a\xa2\x9c\x1a\x6f\x2a\x97\xcb\x9f\xba\xe3\x8e\x3b\xf0\ +\xe6\x37\xbf\x19\x5e\xf8\xe5\xa5\xbb\xb7\x45\xf1\x83\xfb\x51\x6c\ +\x18\x90\xe2\xa2\xf9\x64\x2e\x5e\x24\xb6\x27\x35\x98\x68\x23\x63\ +\xe0\x23\x9b\x3e\x9a\x19\xfe\xc6\xd0\x10\xb8\xa7\x47\xc4\xa7\xdd\ +\xfa\xe8\xaa\x4b\xc1\x3d\x78\x10\x34\x67\x8e\x88\x8f\xbe\x9a\x3c\ +\x17\x44\xd1\xf8\xf6\x81\xd6\x14\x63\xe3\x53\x7a\xc7\xf7\x0f\x00\ +\x5e\x24\x0b\x7c\x1d\x2a\x33\xdb\x16\x23\xa5\x10\x31\xb5\xfe\xd8\ +\xec\x85\x6c\xd1\x32\x5e\xeb\x0e\x21\xb1\xbf\x5f\xe0\x1c\x89\x8d\ +\x88\xf0\x25\x97\x5c\xc2\x5f\xf9\xca\x6d\x79\xa5\xb2\xe2\x8f\x99\ +\xe7\xfc\xda\x14\xbd\xf6\x8a\xa2\x28\xca\xcb\x14\x15\xac\x8a\xa2\ +\x28\x8a\x72\x72\x5e\x9d\x65\xd9\x3f\xff\xcd\xdf\xfc\x0d\x5d\x71\ +\xc5\x15\xb1\x8f\x36\x9a\xf8\xe1\x7d\x69\x7a\xcf\x4e\x91\x65\x55\ +\xc9\xaf\x58\xc2\xb6\x9a\x58\xbb\xaa\xb7\x20\xa2\x90\xc1\x14\xea\ +\x4a\x43\x3a\xad\xc5\x84\x10\x24\x11\x12\xa2\xf1\xc8\x6a\x21\x22\ +\x6c\x0c\x38\x49\x80\xdd\xbb\x63\x59\xb6\xcc\x10\x33\x17\x22\x22\ +\xd6\x22\x62\x1e\x17\xa3\x8c\x96\x3a\xd6\x20\x54\x7d\x54\x94\xe1\ +\x84\xa5\xf5\xff\x0c\xd1\xd4\x08\x80\xb5\xd6\x1a\x00\x41\xb4\x52\ +\x8b\x13\x70\x48\x11\x6e\x15\xda\x20\x22\x0e\xe3\x03\x90\x04\x81\ +\x6b\xad\x8d\xfd\xf1\xf2\x4d\x9b\x36\xa5\x5f\xfc\xe2\x7f\x31\x49\ +\x72\xfe\x47\xa2\xa8\xeb\xe6\x29\x7d\x27\x14\x45\x51\x94\x97\x15\ +\x2a\x58\x15\x45\x51\x14\xe5\xa5\x59\x97\x65\xd9\xd7\x6e\xbb\xed\ +\xb6\xf8\x86\x1b\x6e\x60\x22\x6a\x8a\x48\x4c\x7b\x46\xa2\xf4\xef\ +\x9f\x10\xdb\x9b\x52\xfd\x5d\x17\x10\xef\x1a\xb6\x72\xf1\x22\x2b\ +\x22\x89\x17\x78\x21\x12\x1a\xc1\xa5\xe3\x06\x11\x49\xbe\x1e\x54\ +\xac\x15\x43\x44\xc6\x47\x2f\x23\x00\xb2\x67\x0f\xd3\xc2\x85\x16\ +\x79\x0e\x94\x4a\x94\x7b\x21\x19\xef\xdb\x47\x66\xc9\x12\x84\xb4\ +\xdc\x10\x55\x15\x38\xf1\x19\x22\xa3\xb9\xbf\x3f\x82\x13\x9c\xc6\ +\xd7\xb0\x06\x81\x2b\x44\x14\x79\x05\x6b\x98\xd9\xc0\x45\x4b\x83\ +\xa0\x0e\x63\x8c\x42\x2b\x1b\xef\x02\x15\xfb\x94\xe5\xa6\x37\x8f\ +\x22\x00\xc6\x47\x65\x63\x11\x69\x5c\x78\xe1\x85\xf1\xa7\x3f\xfd\ +\x9b\x51\x14\xbd\xe2\x53\x00\x5e\x3b\xc5\xef\x89\xa2\x28\x8a\xf2\ +\x32\x41\x05\xab\xa2\x28\x8a\xa2\xbc\x38\xbd\x69\x9a\x7e\xf3\x03\ +\x1f\xf8\x40\xcf\xad\xb7\xde\x0a\x2f\x2e\x53\x02\x8a\xca\x6d\x0f\ +\x0a\xa7\x31\x46\xfe\xe4\x72\x49\xbe\xbe\x5d\xf2\x37\xaf\x86\xb5\ +\x36\x21\xa2\xc2\x47\x4b\xc7\x85\xe2\xf1\xee\xc0\xcc\x6c\x5b\x7f\ +\x07\x50\xf8\xa8\x2b\xd7\xeb\x24\x95\x0a\x0a\x9f\xda\x0b\x2f\x80\ +\x8b\x46\x83\x4c\xb5\x0a\x04\xb1\xdb\xd2\xaa\xc6\xc2\x45\x44\xd9\ +\x8b\xcb\xdc\xdf\x1f\xc3\xb5\xa6\xc9\x7d\x64\x97\x01\xc4\x3e\x42\ +\x5a\xb4\xb8\x0a\x8f\xb7\xb4\x69\x69\x79\x63\x7d\xd4\x96\x00\x14\ +\x44\xd4\x04\x10\x8b\x48\xcc\xcc\x21\x92\x1b\x89\x88\x11\x91\x9c\ +\x99\x33\x22\x32\xaf\x7b\xdd\x55\xe6\xf6\xdb\xff\x7d\x9a\x24\xaf\ +\xfe\x57\x00\xcb\xa7\xf4\x9d\x51\x14\x45\x51\x5e\x16\xc4\x33\x3d\ +\x00\x45\x51\x14\x45\x99\xad\x74\x77\x77\x7f\xf2\xd2\x4b\x2f\x5d\ +\xf8\x3b\xbf\xf3\x3b\x0d\x66\x4e\xbd\x58\xcc\xcb\x7f\xf5\x68\xc4\ +\x07\xea\x3c\xf4\x99\x37\x37\x4b\x77\x3e\xcb\x8d\x6b\x57\x85\xeb\ +\xa9\x01\x00\x6b\x6d\x02\x27\x46\x9b\x98\xa8\xff\x8c\xe1\x0d\x8b\ +\xac\xb5\x85\xbf\x3f\xb1\xd6\xc6\x98\x58\x40\x36\x22\xce\x4d\x98\ +\x99\x23\x6b\x2d\x11\x51\x7e\xe0\x00\xd9\xbe\x3e\x61\x1f\xdd\x64\ +\x1c\x97\xee\xeb\x85\x66\x10\xb2\x46\x44\x9a\xcc\x1c\xf9\xe8\xa7\ +\xf8\x71\x59\x00\x91\xb5\x36\x62\x66\x46\xbd\x90\xe8\xd1\xfd\x36\ +\x3a\xd2\xc8\xad\xd8\x88\xa3\x88\xa5\x51\xb0\xf4\xa4\xa0\xa1\xa6\ +\x00\x62\x90\xc6\x2c\xc6\x26\xe4\x22\xb5\x56\x96\xf7\xb2\x39\x67\ +\x4e\x24\x09\x1b\x22\xca\x45\x24\x65\x66\x23\x22\x0d\x22\x4a\x45\ +\x84\x6e\xb9\xe5\xed\xf9\x83\x0f\x3e\x55\xfa\xa7\x7f\x2a\xee\x19\ +\x19\xf9\xc1\xb9\x00\x9a\xd3\xf4\x76\x29\x8a\xa2\x28\x67\x21\x2a\ +\x58\x15\x45\x51\x14\xe5\x04\x24\x49\xf2\x5b\xa5\x52\xe9\x8d\x7f\ +\xfb\xb7\x7f\x9b\x13\x51\x09\x2e\xdd\x96\xe2\x1f\xec\x8f\x93\x3b\ +\x9f\xc6\xd0\x77\xde\xd9\x4c\x7e\xb8\x9f\xcd\xfa\x81\x18\xbd\x59\ +\x21\x22\xc6\x8b\xc4\x04\x2e\x6a\x69\x64\xa2\xdf\x6a\x48\xc9\x35\ +\xd6\x5a\x62\xe6\x04\x00\x88\x10\x8c\x8e\xc4\x47\x65\x89\x08\x11\ +\x5c\x9b\x19\xeb\xd3\x8f\x71\xec\x58\xcc\xbd\xbd\xe3\x62\x35\x18\ +\x25\x11\x33\xc3\xff\xb4\x70\x11\xd6\xb8\xa5\x0d\x4d\xe1\xeb\x5a\ +\x63\x00\xb1\x58\x8b\xf8\xd1\x83\x12\xed\x19\x01\x08\x84\x2c\x96\ +\xe2\x95\xf3\x51\x5c\x56\x8e\xc6\xfb\xdf\x4c\xb8\x07\xe7\xc1\xfc\ +\xc9\x3f\x9f\x98\x88\x0c\xed\x1c\x32\xe9\xb7\x76\x02\xb9\x8d\x50\ +\x58\x14\x17\xcc\xaf\xdb\xd5\xbd\x09\x80\x4c\x44\x2c\x00\x61\xe6\ +\xf8\xb6\xdb\x7e\xaf\xf9\xe0\x83\x5b\x96\x3c\xff\xfc\x39\x1f\xad\ +\xd5\x7e\xfc\x9e\x69\x7c\xdb\x14\x45\x51\x94\xb3\x0c\x15\xac\x8a\ +\xa2\x28\x8a\xf2\x93\x5c\x08\xe0\xb6\x4f\x7f\xfa\xd3\x69\x7f\x7f\ +\x3f\x00\xd4\x44\x24\x81\x95\xb8\xfa\xde\x6f\x60\xe8\x9b\x37\x1b\ +\x34\x4c\x1a\xed\x18\x46\xe3\xfa\x35\x41\x18\x46\x5e\x30\x36\x31\ +\x61\x8c\x14\xb7\xa4\x05\x9b\x16\x07\x5f\x76\xa9\xbe\xcc\x21\x3d\ +\xd8\x47\x61\x2d\x40\xc6\xa7\xec\x32\x00\x30\x33\x5b\x2b\x11\x33\ +\x05\x33\x24\xf1\x91\xde\x90\x62\xcc\x3e\xc2\x0a\x38\xa1\x9b\xf8\ +\x6d\x0d\x00\x1b\x6d\x1f\xca\xe3\x47\x0f\x18\x21\x61\x7b\xf1\x62\ +\x6a\x5e\xb4\x20\x6a\x19\x1f\x79\x61\x5b\xf8\x14\xe3\x20\x50\x33\ +\x7f\x9c\xd0\xe6\xc6\x45\x67\x97\x75\x9b\xfa\xd2\xae\x9c\x88\x72\ +\x00\x59\xfc\xc4\xa1\x52\x72\xe7\x33\x82\x84\x6d\x71\xcd\x4a\xb6\ +\x29\x1b\x63\x4c\x2d\x4d\xd3\xec\x33\x9f\xf9\x70\x72\xf9\xe5\xff\ +\xf1\x97\x80\xe8\x6e\xc0\xfc\xcb\x94\xbf\x63\x8a\xa2\x28\xca\x59\ +\xc9\x6c\x10\xac\x09\x9c\xd9\x03\xc3\xa7\x4b\xc1\x5d\x18\x4d\xcb\ +\xad\x98\xb1\xd1\x29\x8a\xf2\x72\x84\x00\xa4\x00\xca\x00\x4a\xfe\ +\xef\xc4\xff\x6c\x4d\xfd\xb4\x70\x13\xff\x26\x80\xdc\xdf\xc6\xa0\ +\xe7\xac\x33\x9d\xb8\x54\x2a\x7d\xe6\x43\x1f\xfa\x50\x76\xd1\x45\ +\x17\x05\x37\xdd\x0a\x00\xd3\x73\xed\x17\xec\xe8\x87\x2f\xb7\xe8\ +\x4e\xe3\xe4\x7f\x3f\x65\x9b\x37\xac\x37\x70\x3d\x4b\xc3\xe7\xa2\ +\x00\x20\xd6\x5a\xf8\x14\x5d\x12\x91\x06\x7c\x9d\xa9\xbf\x2f\xf2\ +\xa9\xbd\x80\xab\x15\x6d\xbd\xde\xc1\x5a\xf1\x11\x4f\xf7\x59\x13\ +\x11\x66\x1e\xef\xab\x0a\xe0\x05\xbf\x8f\xdf\xe7\xc5\x2b\x82\x23\ +\x70\xfc\xf0\x3e\xe6\xdd\xc3\xb0\x2b\x7a\x4c\xfd\x86\x35\x85\x17\ +\x99\xa1\xaf\x2a\x03\x88\x79\xf7\x48\x14\x6d\x39\x92\x50\xbd\x70\ +\xa6\x4a\x4c\x56\x72\x03\x10\x19\x8a\x23\x16\x6b\x09\x85\x15\x8a\ +\x23\x0b\x2b\x62\x17\x77\x45\xf6\x9c\xb9\x25\x5b\x8e\x04\x80\x14\ +\xe7\xcd\x15\x3a\x7f\x1e\x63\x2c\x2f\xd2\xaf\x6f\xcf\xd1\x34\x51\ +\xf3\xea\x15\x15\xf4\x66\xf9\xaa\x55\xab\xf0\x37\x7f\xf3\xee\xe4\ +\xd7\x7f\xbd\xf9\xbf\x9a\xcd\x1f\x2c\x07\x70\xac\x63\xef\x90\xa2\ +\x28\x8a\xf2\xb2\x61\xba\x04\x2b\x03\xe8\x01\xd0\xe7\x7f\x96\x5b\ +\x6e\xd1\x4b\x6c\x17\x28\xe0\x26\x81\x35\xff\x73\xd0\xdf\x46\xd1\ +\xd2\x6b\x4e\x51\x14\xa5\x0d\x4a\x00\x7a\x5b\x6e\xdd\x70\xe7\xa6\ +\x13\x89\x82\x53\x25\x87\x3b\x5f\x8d\x02\x18\x02\x30\x0c\x37\x59\ +\xaf\x4f\x6a\xa4\xca\xb4\x90\x65\xd9\xfb\x17\x2f\x5e\xbc\xe2\xbd\ +\xef\x7d\xef\x10\x11\x55\x7c\xd4\xd4\x94\xff\xf8\x7e\xb6\xab\xfa\ +\xa8\x78\xc3\x2a\x8a\x1e\xdd\x9f\xdb\x73\xe7\x59\x49\x39\x02\xc0\ +\xde\x3d\xd7\x46\x51\xc4\x2d\x11\xce\x10\xa1\x8c\xe1\x52\x65\xc5\ +\x5a\x1b\x1e\x5f\x88\x48\x61\xad\x84\xc8\x2b\xf9\xfb\x23\x40\x22\ +\x00\xcc\x2c\xc7\x7f\x06\x43\xdb\x19\x1b\xa2\xa1\x70\x42\xd5\xf8\ +\x7e\xaa\x24\x22\x1c\x3d\x79\x88\xa2\xa7\x0e\x53\x71\xd9\x62\xca\ +\x2f\x5e\x00\x22\x8a\xc9\x89\x6a\xc1\x58\x61\xe3\x7b\x9f\x17\x6a\ +\x18\x21\x90\x31\x4b\xaa\xc6\x5c\xb9\x8c\x6d\x42\x31\xbc\x93\xb1\ +\xb5\x56\x98\x19\x70\x4e\xc1\x11\xdc\x62\x8d\x00\xb0\xbc\x6f\xd4\ +\x44\xdf\xdd\x45\x71\xad\x88\x48\x20\xf9\xa6\x39\x4d\xbb\xb6\xcf\ +\xa0\x14\x97\xea\x6f\x5e\x95\xc0\x4a\x91\x7d\x6d\xbb\x45\x1a\x27\ +\xcd\xab\x97\xcb\xdb\xde\xf6\xd6\xd1\x8f\x7f\xfc\x2b\xe9\xe3\x8f\ +\xd7\x6e\x1f\x1d\xdd\xfc\xae\x69\x79\x03\x15\x45\x51\x94\xb3\x8a\ +\xa9\x14\xac\x55\x00\x0b\x01\x2c\x80\x13\xaa\x93\x71\x24\x8e\xe1\ +\x26\x91\xdd\xc7\xdd\x5f\x00\x38\x0c\x60\x3f\x80\x7d\x50\x63\x07\ +\x45\x51\x4e\x0e\x01\xe8\x87\x3b\x37\x2d\x00\xd0\x35\x05\xc7\x48\ +\x30\x21\x80\x17\xb7\xdc\x5f\x03\x70\x04\x13\xe7\x2d\x3d\x67\xcd\ +\x3e\x16\x5a\x6b\xff\xe8\xf6\xdb\x6f\x4f\x93\x24\xc9\xac\xb5\x4d\ +\x00\xc3\xe9\xf7\xf7\x97\x92\xfb\x76\x47\x43\xdf\xb8\x39\x87\xb1\ +\x14\xed\x18\x4a\x9a\x6f\x5d\x4b\x98\x68\x57\x03\x22\x8a\xbc\x81\ +\x12\x44\x64\xac\xf5\x7e\x22\x4a\x8c\x31\xa1\xdd\x4d\x8e\x89\xf6\ +\x32\xec\xf4\x27\xc1\xf7\x44\x25\x2f\x16\x21\x82\x60\xa6\x64\x45\ +\xc6\x5d\x81\x8d\xff\x29\x44\x94\xf8\xfa\x57\xe7\x0a\x7c\xa8\x46\ +\xd9\x37\x76\xc4\xe6\xfc\x79\xd2\xbc\x69\x83\x13\xc0\x5e\xd4\xc6\ +\x0f\xef\x23\xde\x3b\x02\x29\xc5\x51\xf1\xda\x65\x62\xb3\xd0\x99\ +\x66\xa2\x97\x2b\x9c\xf8\xcd\x7c\x3b\x9e\xc2\xbb\x0d\x37\xe0\xf6\ +\x91\x01\x60\xbb\xb0\x9a\xdb\x85\xd5\x42\x44\x22\x66\x4e\xe8\xf1\ +\x03\xe5\xf4\xce\x67\x2d\xfa\x32\xc9\x5f\xbb\xcc\x4a\x44\x71\xe3\ +\x4d\xab\x2c\x1f\xaa\x8f\x96\xee\xd8\x1c\xe7\x97\x2e\xaa\x7e\xe4\ +\x23\xbf\x6b\x5e\xf3\x9a\x5f\xbf\x15\xc0\x47\x01\x3c\x3a\xd5\x6f\ +\xa0\xa2\x28\x8a\x72\x76\xd1\x69\xc1\x1a\x03\x58\x0a\x60\x05\x7e\ +\x52\x5c\x4e\x05\x31\x26\x26\x9d\xe7\xc3\x4d\x04\xb7\xc3\x89\x57\ +\x8d\xbc\x2a\x8a\xd2\x4a\x05\xee\xdc\xb4\x14\x6e\xf2\x3d\x53\x63\ +\xa8\xf8\x31\x08\xdc\x39\x6b\x1f\x80\x3d\x70\xc2\x40\x99\x61\xa2\ +\x28\xfa\xe8\x4d\x37\xdd\x54\xba\xf2\xca\x2b\xad\x37\x11\x4a\x88\ +\x28\x2b\xff\xee\xb7\x64\xf4\x7f\xbc\xa1\x61\xad\x35\xd9\x97\x9f\ +\x2b\xe7\x57\x2d\xb7\x70\x11\x73\x31\xc6\xc4\xcc\x9c\x88\x48\x44\ +\x44\xc6\xa7\x10\xa7\x00\x32\xaf\x0a\xc9\xbb\xfe\x5a\x38\x0d\x0a\ +\xf8\x36\x32\x71\x2c\xb6\x28\x08\x49\x02\xc6\xc4\xc2\xae\x15\x81\ +\xf1\x41\x7e\x23\x22\x62\xad\x80\x48\xe0\xa3\xa9\x21\xad\x37\x38\ +\x05\xdb\xe4\x5b\x3b\x99\x1a\x06\xf5\x9b\x37\xb8\xcf\x91\x08\x11\ +\x40\xe9\xbd\xbb\x63\x3a\x54\xe3\xfc\xd5\x8b\xa8\xb8\x64\x61\xe8\ +\xb5\x6a\x22\xe7\x54\x1c\x6a\x53\xe1\xc7\xc8\xc1\x59\xd8\x5a\x9b\ +\xf9\xf6\x36\x42\x44\x62\xad\x25\xbf\x6d\xc9\xdf\x67\xac\xb5\x46\ +\xce\x9d\x63\xe4\x82\xf9\x31\x06\xeb\x94\xde\xf5\x4c\xb3\xa8\xc4\ +\xd6\xbc\x7e\x25\x63\x7e\xa5\x5a\x7f\xe7\x46\x1b\xdf\xb7\xcb\x6e\ +\x90\x8c\x7f\xeb\xb7\xde\x40\x1f\xfd\x68\xfe\xe9\x3c\xff\xe1\x79\ +\x2d\xc7\x54\x14\x45\x51\x94\x93\x72\x2a\xe9\xb8\xa7\x42\x09\xc0\ +\x06\x00\xaf\x82\x8b\xaa\xce\xc4\x64\x90\xe0\x26\x82\x8b\x01\x2c\ +\x83\xbb\xf0\x0f\x41\x85\xab\xa2\xbc\xdc\x19\x80\x5b\xd0\x3a\xd7\ +\xff\x3e\x1b\x6a\xf7\x81\x89\x73\xd6\x7c\x00\xab\xe1\xa2\xb1\x05\ +\x5c\x14\x56\x99\x19\x2e\x2d\x95\x4a\xff\xf5\x8e\x3b\xee\xb0\x95\ +\x4a\xa5\x29\x22\x19\x33\x9b\xee\x5f\xfc\xb2\x14\x3f\xb5\x4c\xea\ +\xd7\xaf\x8e\x79\xb0\x91\xf1\xa1\x31\xd8\x4d\x73\xac\xaf\x5b\x4d\ +\x00\xa4\x3e\x72\x5a\x87\x8b\x9a\x07\x03\xa3\xd0\xc6\xa6\x09\x27\ +\x6e\x1b\x44\xd4\xf4\x91\x57\x0b\x00\xd6\x52\xd4\x68\x20\x29\x97\ +\x85\x7c\x9a\x70\x7e\xf0\x20\x4c\xa5\x82\xe2\xc0\x01\xb2\x2b\x57\ +\x4a\x3e\x32\xc2\xc2\x4c\xb6\xd9\x64\x3b\x6f\x9e\x6b\x79\xe3\xa2\ +\xae\x12\xf1\x68\xc1\xd9\xe7\x36\xc3\xbc\x7a\x91\xb1\x17\x2d\x34\ +\xf0\x02\x33\x7e\x64\x3f\x27\xf7\xef\x8e\x8a\x4b\x17\xe7\xc5\xc5\ +\x0b\x0a\xe9\xcd\x2c\x7c\x74\xd6\xb7\xba\x89\xe1\x0c\x96\xe0\xb7\ +\x31\x2d\xd1\xdf\xd0\xa3\x35\x38\x0e\x37\xe1\x16\x54\xea\x00\x72\ +\x1f\x01\x4e\x5a\x9c\x8d\x2d\x4a\x31\x9b\x8d\x73\x12\x1a\xa8\x24\ +\xe9\x97\xb6\x32\x8c\x2d\xec\x82\x2a\xd9\xe5\x3d\x11\x72\x5b\x7f\ +\x6d\x6d\x5e\xf1\x77\x0f\x7e\x7f\xce\x68\x6d\xdb\x16\x00\x4f\x4e\ +\xd7\x1b\xaa\x28\x8a\xa2\x9c\xf9\x4c\x76\xe2\x16\x01\x58\x09\x60\ +\x5d\x07\xf6\xd5\x49\xca\x00\x36\x01\x58\x05\xe0\x69\x00\xcf\x43\ +\x85\xab\xa2\xbc\xdc\xe8\x86\x5b\x48\x5b\x38\xd3\x03\x39\x05\x08\ +\x6e\x9c\x0b\xe1\xea\xf4\xb7\xc1\x9d\xb7\xd4\xbc\x69\x1a\x29\x95\ +\x4a\x7f\xf2\xae\x77\xbd\xab\x3e\x77\xee\xdc\x2e\x78\x11\x9a\x7d\ +\xf2\x49\xb2\x31\x45\xf5\x5f\x3c\x07\x44\xd4\x48\xbe\xb6\xdd\x36\ +\x6f\xde\xd0\x84\x48\x09\x6e\x71\xd6\x10\xd1\x18\x5c\x24\x34\x62\ +\xe6\x14\x40\xe2\x9d\x81\x4d\xa8\x4f\x25\xa2\x14\xce\x8c\x89\x99\ +\x39\x98\x1e\x71\x5f\x9f\x95\xe7\x9e\x63\x33\x77\x2e\x0a\xdf\xc6\ +\xc6\x32\x33\x8d\x8e\x5a\xa9\x54\x5c\xfb\x9a\xbd\x7b\x89\x57\xad\ +\x12\x53\xab\x8d\xf7\x61\x15\x11\xe1\x78\xdb\x31\x8e\x1e\xdd\xcf\ +\x8d\x9f\x3f\xa7\x10\x02\x91\x08\xf1\x81\x31\x4a\xbe\xb5\x23\x6a\ +\xbe\x6a\xbe\x98\x9b\x37\x1a\x7f\x1c\xf2\x37\xf6\xb5\xb2\x36\xd4\ +\xbb\x12\x51\x58\x60\x96\x89\xce\x36\xe3\xc6\x4d\xe2\xd3\x94\xcb\ +\xfe\xbe\x10\x21\xb6\x70\xa2\x96\xad\xb5\x15\xdf\x8f\xb5\x41\x44\ +\xc6\xf6\x67\x71\xe3\xa6\x0d\xe5\xf8\xc7\x87\x6d\xf6\xf9\xa7\xf3\ +\xfa\xdb\xd6\x16\x76\x6d\x5f\x99\x17\x75\xe1\x93\xdf\xba\xc6\xdc\ +\x7c\xf7\xd0\x9f\x0d\x35\x1f\xfa\x47\xcc\xcc\x35\x39\x03\x30\xaf\ +\x03\xfb\x11\x00\xbb\x3b\xb0\x1f\x45\x51\x14\xe5\x14\x98\x8c\xc8\ +\x9c\x0f\xe0\x02\xb8\xe8\xea\x6c\xa5\x04\x37\xc6\x15\x00\x7e\x08\ +\x67\x7c\xa2\x28\xca\xd9\x0d\x03\xd8\x08\xb7\x60\x35\x19\xe3\xa4\ +\x99\xa2\x0c\x17\x0d\x5e\x0f\x60\x07\x80\x67\xa1\xc2\x75\x3a\x38\ +\x47\x44\xae\x7e\xdf\xfb\xde\xc7\x70\x8b\x06\x0d\x34\x4d\x39\xfd\ +\x97\x67\x4b\xf5\x9f\xdb\x68\x65\x41\xb5\x88\x76\x0e\xc7\x76\x55\ +\x1f\x83\xa8\x02\xdf\x53\x35\x44\x3a\x7d\xb4\x35\x0a\x42\x15\x40\ +\xd3\xa7\xd2\x82\x99\xc9\xdf\x4f\xcc\x1c\x44\xa3\x00\x90\x28\x02\ +\x44\x88\x45\x6c\x1a\x6a\x53\x01\xd8\x5a\x8d\xa4\x5c\x26\xeb\x04\ +\x23\xf3\xf0\xb0\x70\x7f\x3f\x88\x99\x05\x00\xe2\xef\xee\x61\x32\ +\x36\x6a\xde\xb4\x01\x00\x62\x02\x90\x3c\xb8\x37\xa2\x23\x75\x6a\ +\xbe\x73\x93\x85\xab\x5f\x0d\x2d\x75\x5a\x3d\x24\x5e\x60\xdc\xe4\ +\xc5\x34\x89\x48\xe4\xc5\x6a\x01\xa0\xb0\xd6\x86\x68\x2d\xbc\x81\ +\x54\xe2\x6f\xa1\x66\xd7\x38\x7d\x4d\xc1\x94\xa9\x8a\x89\xfa\x5a\ +\x53\x9c\x33\x27\x32\x2b\x7a\x92\xf2\x67\x9e\x32\xcd\xd7\xaf\x1c\ +\xb6\x0b\xab\xf2\xca\xbf\xfa\x85\xae\x5f\xfc\xda\x8f\x56\xfc\xf7\ +\xe6\x63\xd7\x19\x34\xee\x9a\xb2\x77\xf2\xc5\xe9\x02\xf0\xca\x0e\ +\xec\x47\x05\xab\xa2\x28\xca\x34\xd2\x8e\x11\x12\xc1\x4d\xa4\x2e\ +\xc1\xec\x16\xab\xad\xf4\x02\xb8\x12\x6e\x02\xab\x28\xca\xd9\x4b\ +\x37\x80\x2b\xe0\x52\x6c\xcf\x44\xb1\xda\x4a\x02\x60\x2d\xa6\xc7\ +\x0f\xe0\x65\x4f\x77\x77\xf7\x9f\xdd\x7a\xeb\xad\x8d\xfe\xfe\xfe\ +\x86\xaf\xd3\x1c\xe8\xfe\xe5\xaf\x96\x9a\xd7\xaf\x2b\x9a\x57\x2d\ +\x6f\x88\x88\xc4\x0f\xef\x8d\xcc\xa5\x8b\x2c\x80\x21\x22\x3a\x0a\ +\x60\xd8\x5a\xdb\x74\xc6\x49\x12\x7b\x93\xa2\x61\x7f\x1b\xb5\xd6\ +\xd6\x89\x28\xb7\xd6\x0a\x26\xda\xb7\x8d\x3b\x48\x8b\xc8\xa8\x7b\ +\xdc\x78\xaa\xb0\x25\x22\x22\x42\x52\x14\x9c\x94\x4a\x48\xe1\xa2\ +\x82\xc9\xd0\x10\x67\x5d\x5d\x26\x15\x91\x72\x74\xdf\xae\x0a\xaa\ +\x49\x29\xbf\x62\x69\x04\x20\x42\xd3\x94\xd3\xcf\x6d\x2e\x9b\x45\ +\xd5\xb4\x79\xed\xaa\xc8\xd7\xcf\x26\xd6\xda\x50\x57\x2b\x70\x22\ +\xba\x81\x09\xc7\xfd\x51\x11\x19\x25\xa2\x11\x11\x19\xf5\xb7\xa6\ +\x4f\x15\x2e\x11\x51\xd6\xd2\x96\xc7\xc2\xa5\x33\xd7\x7c\xc4\xb8\ +\x24\x22\x15\x22\x62\x9f\xee\x3c\xe2\x9f\xb3\x15\x91\xc8\x5a\x9b\ +\x8b\xc8\x90\x54\x93\xa1\xc6\xbf\x3f\xcf\x44\x0f\xef\xed\x89\xb7\ +\x1d\xeb\xce\xba\x2b\x76\xfe\xef\x9d\x5b\x64\x95\x57\xfd\xbf\xd3\ +\xf4\xb6\x2a\x8a\xa2\x28\x67\x01\xa7\x2b\x58\x33\xb8\xc9\xe0\x7a\ +\x9c\x79\x93\x41\x86\x8b\x5a\x5c\x88\xc9\x39\x16\x2b\x8a\x32\x3b\ +\x59\x01\xb7\x30\xd5\x33\xd3\x03\x51\xce\x38\x56\xd5\x6a\xb5\x37\ +\xbe\xef\x7d\xef\x2b\x31\x73\xc9\x5a\x9b\x97\x3e\xbb\x79\xc4\xac\ +\xe8\x6e\xd8\x6a\x04\xf4\x97\xca\xd1\xb3\x83\x89\x5d\xdd\x97\x5b\ +\x6b\x8d\x88\x94\x45\xa4\x17\x40\x1f\x11\x75\xc1\xb5\xa3\x09\x35\ +\xad\x15\xb8\x45\x86\x1e\x66\xee\x06\xd0\xe5\xd3\x81\x0b\x00\x63\ +\x22\xd2\x10\x91\x26\x5c\x2d\x68\x0e\x20\x77\xed\x6d\x6c\x21\x22\ +\x85\x88\x18\x11\xb1\x22\x42\xd6\x5a\x06\x10\x11\x21\xca\x73\x44\ +\x59\x46\x94\x7c\x75\xbb\xd8\x79\x15\x53\x5c\x30\xcf\xd5\xc1\x1e\ +\x1e\x93\xd2\x3f\x3f\x6b\x9a\x37\xac\x33\x76\x79\x8f\x85\x4f\xff\ +\xf5\x91\x53\x04\xf7\x61\xb8\x5a\x5a\x6a\xfd\xbf\xbf\x1f\xbe\x26\ +\x36\x38\x0f\x17\x70\x11\xc4\xf0\x5c\xba\xfc\x73\xac\x02\x28\xf9\ +\xb6\x3c\xc1\x34\xa9\x2c\x22\x3d\x44\xd4\x4d\x44\x41\xc0\x5a\x2f\ +\xf8\xfb\xfc\xf6\xcd\xfc\xba\xb5\x47\x69\xc7\xb1\x9c\x9f\x3a\x1c\ +\xbf\xeb\x5d\xbf\x48\xd6\x9a\x25\x00\x5e\x3b\xb5\x6f\xa9\xa2\x28\ +\x8a\x72\xb6\x70\x3a\x29\xc1\x15\x00\x97\xc2\x5d\xb4\xce\x64\x16\ +\xc3\x09\xef\x87\xa1\x69\x76\x8a\x72\xb6\xb0\xde\xdf\x14\xe5\xb4\ +\x89\xe3\xf8\x97\xae\xbd\xf6\xda\x68\xf1\xe2\xc5\x4d\x11\x69\x12\ +\x51\x9a\x7e\x7e\x4b\x75\xec\x37\x2f\xa4\xe2\x82\x79\x96\x88\x9a\ +\xf1\x63\x07\xd0\x78\xfb\xfa\x1c\x22\x89\x17\xa6\x02\x67\x42\x54\ +\xf8\x08\x24\xc1\xf5\x3a\x8d\x7d\x84\x33\xb8\xf8\x1a\xff\x7b\xec\ +\xff\x6f\xe1\x22\x91\xc1\x00\x89\x98\x29\xf6\xa9\xc2\xc1\xc5\x57\ +\x44\x60\x7c\x1d\x29\x13\xb9\x7d\xc5\x5f\x7f\xce\xda\x35\x7d\xb9\ +\x5d\xdb\x57\x00\x40\xbc\x75\x30\xe3\xcd\x87\xa3\xfa\x3b\x36\xd4\ +\x31\xde\xc3\x15\x89\x4f\xed\x35\x7e\x8c\xa1\x5d\x4d\x04\x6f\x88\ +\xe8\x45\xa5\x77\x1f\xb6\x4c\x44\x0c\x2b\x94\x7e\x75\xa7\x64\x77\ +\x6e\x26\xda\x3d\x0a\xaa\x17\x80\xb1\x02\x62\xa0\x2b\x01\x12\xa6\ +\xfc\xa7\x16\x9b\xe6\xbf\x3b\x77\xcc\x2c\xac\x84\x7d\x13\x5c\x24\ +\xb7\xec\xa3\xcc\x75\xb8\x28\xae\xf8\xb1\x94\xad\xb5\x5d\xcc\x6c\ +\x8b\xd7\xad\x90\xf8\x9e\x1d\x45\x25\x2f\xe8\xd6\x5b\xaf\xca\x3e\ +\xf5\xa9\xda\x6f\x37\x1a\x4f\xde\x3b\xc5\x6f\xad\xa2\x28\x8a\x72\ +\x16\x70\xaa\x82\xb5\x1b\xc0\x65\x98\xb9\x56\x10\x9d\x66\x0e\x80\ +\xd7\x00\x78\x10\xda\x07\x51\x51\xce\x64\x08\xae\x26\x6d\xc9\x4c\ +\x0f\x44\x39\x73\x49\x92\xe4\x97\xdf\xf9\xce\x77\x5a\x00\xa9\x88\ +\x64\xdd\xff\xe9\x3b\x54\x7b\xcf\x2b\x0b\x3e\x54\x6b\xd8\xfe\x6c\ +\x2c\xd9\x35\x92\x16\xcb\xbb\x2b\x22\xd2\xe5\x5d\x74\x47\xe1\x16\ +\x3c\x05\x2e\x63\x27\x02\x90\xfa\xed\xad\x17\x6e\x79\x68\x71\xe3\ +\x45\x61\x24\x22\x09\xdc\x75\x37\x21\xa2\xd4\x5a\xeb\xcd\x8d\x04\ +\x3e\xba\x5a\x87\x6b\x69\x03\x00\xb0\xd6\x86\xda\xd7\xb4\xfb\x91\ +\xe7\x59\xce\xef\x32\x66\x6d\x9f\x05\x60\xa2\xa7\x8f\x0a\xef\x1c\ +\x4a\x1a\x6f\x5e\x2d\x70\xa9\xc8\x89\x38\x31\x4d\xf0\x35\xb4\xfe\ +\xa7\x05\x7c\x0f\x1d\x5f\x6b\x2b\x22\x91\x34\x8a\xa4\xfa\xe1\x07\ +\x91\x3c\xb4\x07\x10\x12\x61\x82\x5d\xd6\x2d\xf9\x0d\x6b\xeb\xc5\ +\x4f\x2d\x6d\xd8\xfe\x92\x0d\xcf\x4f\x44\xe2\xe4\xf9\x5a\x92\x7c\ +\xf2\xb1\xac\xf2\x6b\x5f\xed\xa1\xe1\x42\x24\x02\x64\x7e\xc5\xd6\ +\x7f\xf7\xd2\xa2\xb8\x60\x6e\x03\x4e\x30\x27\x22\x52\xf6\x26\x4c\ +\x75\x22\x1a\x02\x00\x71\x06\x55\x95\xe2\xea\x15\x92\xde\xbd\x55\ +\xde\xfd\x96\x37\xda\x4f\x7c\xe2\xab\x6f\x81\x5b\x08\x57\x57\x6c\ +\x45\x51\x14\xe5\x25\x39\x15\xc1\x5a\x02\xf0\x6a\x9c\x3d\x62\x35\ +\xd0\x0b\xf7\xbc\xbe\x0b\x77\x51\x57\x14\xe5\xcc\xe3\x7c\xa8\x58\ +\x55\x26\xc7\x15\x51\x14\xcd\xbb\xe6\x9a\x6b\x22\x00\x88\xf7\xd7\ +\x47\xb1\x67\xa8\x24\x0b\xca\x0d\xbb\xa6\x37\x65\xe6\x0a\x3f\xb0\ +\x8b\xf3\x9b\x37\x5a\x76\xd7\x0a\x16\x91\x8a\xdf\x36\xa4\xd8\x42\ +\x5c\x13\xd3\x02\x2d\x22\xb1\x25\x15\x97\xbd\x83\x70\xe4\x6b\x44\ +\x01\x6f\x68\xe4\x1e\x43\x46\x44\x0a\x38\x11\x9c\x5b\x0b\xdf\xf3\ +\x14\x0c\x10\x75\x6d\x39\xc8\xb6\x9c\x26\xc5\xb9\x73\x9d\x71\xd3\ +\x93\x87\x62\xda\x3b\x22\xcd\x6b\x56\x1a\x88\xc4\xcc\x1c\x8e\x15\ +\xca\x5d\x72\x11\x29\x98\x39\x6f\x89\xfe\x32\x00\x94\xff\xef\xef\ +\xa5\xe9\xbf\xed\x66\xb2\x22\xf5\x9f\x5d\x2d\x43\x5f\x7d\x87\x91\ +\x09\xd1\x1d\x0c\x94\x08\x6e\x3b\xf1\x82\x39\x2e\x96\x57\xa3\xfc\ +\x0f\x5e\x03\x04\x77\xdf\x91\x26\x25\xdf\x7c\x3e\x2a\xff\xd1\x7d\ +\x0c\x66\x98\xa5\x15\x19\xfb\xf3\xd7\x15\x48\xb9\xf0\xd1\xdc\x6e\ +\x6f\x38\x65\x89\xa8\x30\xc6\x8c\x01\x40\xe3\x2d\xab\xd3\x4d\x9f\ +\x7d\x2a\x5a\xb9\x68\x49\x73\xeb\xae\x27\xde\x06\x98\x4f\x77\xfa\ +\x0d\x55\x14\x45\x51\xce\x2e\x4e\x26\x58\x63\x38\x51\x57\x9e\x86\ +\xb1\xcc\x04\x7d\x00\x2e\x82\x4b\x0f\xd6\xb6\x37\x8a\x72\x66\xb1\ +\x09\xc0\xf2\x99\x1e\x84\x72\x66\x53\x2a\x95\x7e\xe5\xe6\x9b\x6f\ +\x96\x24\x49\x46\x45\x24\xa9\xbc\xff\x9e\xae\xe1\xff\xef\x4d\x48\ +\xbf\xb9\x23\x69\xde\xb0\xce\xd2\x91\xb1\x5c\xfa\x33\xeb\xeb\x4e\ +\x01\xdf\x77\x15\xae\x47\x69\x61\xad\x2d\x82\x59\x92\xb5\x36\x62\ +\xe6\xc8\x47\x1a\x83\x13\x30\xf0\x42\x21\x19\x8c\x8b\xc4\xbb\xef\ +\xc6\x44\x48\x89\x28\xf3\xb5\xa4\x26\x64\xf1\x56\xab\x64\x9a\xdb\ +\x6b\x71\x7c\x60\x44\x8e\x5e\xb1\xd2\x02\x36\xe2\x1d\xc7\x92\x78\ +\xd7\xb0\x69\xbe\x71\x55\x53\x9c\x58\xa5\x96\xc8\x2d\x7b\x81\x6a\ +\x7d\xea\x31\x00\x20\x3e\xd2\xe4\xf2\xef\x7c\xa3\x8b\x9e\x1f\x89\ +\x8b\x2b\x96\x63\xf8\x7f\x5f\x67\x6d\x6f\xda\x84\x8f\x02\xc3\xd5\ +\xb3\x46\xfe\x39\x25\x70\x0b\xd5\x5e\x34\x93\xb8\x31\x21\x08\xea\ +\x42\x44\x84\xba\x52\xca\xaf\x5f\x13\xe5\xd7\xaf\x49\xe3\x07\x76\ +\xa7\xc9\xf7\xf6\xd9\xea\xcf\xdd\x15\xc9\xbc\xaa\xa9\x7d\xe4\x75\ +\x83\x92\x46\x20\xa2\x54\x44\xca\xd6\xda\x94\x88\xa2\x10\x6d\xce\ +\xdf\xbe\x21\xff\x8b\xaf\x5d\x96\xde\x7a\xf4\xe0\x6f\x8f\x8e\x3e\ +\xac\x82\x55\x51\x14\x45\x79\x49\x4e\x26\x58\x2f\xc2\xd9\x6f\x60\ +\x32\x1f\xae\x05\xc6\x53\x33\x3d\x10\x45\x51\x4e\x99\x95\x00\xd6\ +\xcc\xc0\x71\x0d\x9c\xcb\xaa\x81\x73\x7b\x6d\x6d\xf7\x91\xc0\x45\ +\xa8\x94\x33\x07\xca\xf3\xfc\xba\x5b\x6e\xb9\x25\x16\x91\x2c\xfa\ +\xfe\x3e\xb2\x73\x4a\x40\xa3\xa8\x4b\x7f\xa9\x09\xa0\x9e\x7c\xfb\ +\xf9\x72\xf3\xfa\xb5\x80\x5b\xb8\x4d\xe0\xea\x4f\x1b\xcc\x3c\xe4\ +\x5b\xc3\x84\x9e\xa6\xb1\x8f\xa0\xa6\x70\x82\x36\x44\x5f\xc7\xcd\ +\x8c\xac\xb5\xb9\x77\x03\x2e\x42\x3f\x19\x00\x71\x92\x40\x1a\x0d\ +\x64\x59\x46\x99\xaf\x69\x35\x00\xd0\x5b\x32\x16\xff\xb2\x23\x3b\ +\x7a\xf5\x79\x6e\x1f\x43\x4d\xc4\x8f\x1f\x8a\x9b\xd7\xad\xf1\x42\ +\x97\xd8\xd7\xab\x46\x68\x11\x98\x70\xd7\x76\xc2\x70\x81\xea\x7b\ +\xbf\x92\xf2\x48\x93\x8a\x6b\xd7\xd8\xfa\x5f\xac\x83\x1d\x28\x09\ +\x11\x35\x88\xa8\x69\xad\x35\x5e\xd8\x92\x8f\xf6\x46\xfe\x27\xe0\ +\xa2\xc4\x12\x9e\x1b\xdc\x67\x5d\x7c\x9a\x73\x10\xdc\x39\x80\xbc\ +\xb8\x7c\x49\x3d\xbf\x64\x61\x92\xad\xed\xcb\x50\x2b\xd2\xae\x5b\ +\xee\x9e\x53\xfc\xec\x9a\xe6\xd8\xaf\x9c\x57\x23\xa2\x41\x3f\xb6\ +\xcc\x3b\x0b\x93\xa4\x44\xe7\xbc\xff\xcd\xb8\xfc\x5f\xbe\x73\xd1\ +\xd7\x5d\xc9\x91\xb6\x9c\x53\x14\x45\x51\x5e\x94\x97\x12\xac\xab\ +\xd1\x99\x06\xdb\x2f\xc5\x10\x80\xc3\xfe\xe7\x28\xdc\x04\xd0\xf8\ +\x71\xa5\x70\x06\x4f\x7d\x00\xe6\x62\x6a\xa3\xbc\xab\x01\x1c\x04\ +\x70\x68\x0a\x8f\xa1\x28\x4a\x67\xe8\x05\x70\xce\x34\x1d\x6b\x10\ +\xc0\x01\xff\xf3\x18\x9c\xa1\xcc\x4b\x91\x02\xe8\x87\x3b\x6f\xf5\ +\x03\x18\x80\xba\x92\xcf\x66\xce\xcd\xb2\xac\xf7\xc2\x0b\x2f\x8c\ +\x00\xd4\x2b\x1f\x7e\x20\x1e\xfa\xfc\xf5\x83\xd9\x3f\x6f\x2b\x37\ +\x6f\x58\x17\x13\xd1\x80\x30\x12\x61\x08\x4d\x2c\x52\x84\x68\x6a\ +\xc9\x9b\x22\xb5\xd6\x86\x72\x4b\xfd\x66\x10\xa5\xec\x23\x8c\x89\ +\x37\x22\x62\xdf\x0a\xc7\x78\xa7\x5e\x5e\xba\xd4\xc8\xce\x9d\x6c\ +\x57\xaf\xb6\x11\x80\x8c\x99\xac\x88\xf0\xc0\x3d\x9b\xf1\xf4\xcf\ +\x6c\x04\x11\x40\x56\x90\xfe\xcb\xb3\x68\xfc\xbb\x4d\x84\x89\x85\ +\x91\x90\x56\xdc\xfa\x19\x8b\x00\x44\xd5\xdf\xf9\x16\x78\xf7\x28\ +\xf2\xeb\x56\xa3\xb1\x71\x0e\x8a\x8b\x16\xb0\x88\x80\x99\x8d\xb5\ +\x36\x22\xa2\xd8\x0b\x66\xc0\x2f\xbc\x10\x51\x06\x27\x54\xc7\xe0\ +\xa3\xaf\x41\x10\x8b\x48\xc2\xcc\x89\x88\xf4\xc0\xf7\x8a\xf5\x29\ +\xbf\x4e\xed\x26\x11\x9a\xd7\xaf\x41\xb4\xe5\x88\x6d\x94\x23\x8a\ +\x7e\x7c\x28\xeb\xfe\xb9\xbb\xb3\xe1\x4f\x5e\x2b\x94\xc5\x85\x6f\ +\xf9\x33\xe4\xa3\xac\xd9\xdc\x0b\x56\x95\x9b\xf3\xbb\x0d\xf6\xe3\ +\x4a\x00\xff\x3a\x95\x6f\xb2\xa2\x28\x8a\x72\x66\xf3\x62\x82\xb5\ +\x1b\x2e\xea\x38\x15\x14\x00\x76\xfa\xdb\xc8\x49\x1e\x7b\x08\xc0\ +\x0e\xff\xfb\x00\x5c\xdb\x8a\xc5\xe8\x7c\x4b\x9d\x60\xdc\xf2\x1d\ +\xb8\x09\x89\xa2\x28\xb3\x93\x18\x2e\xf3\x63\x2a\x45\x60\x03\xee\ +\xbc\xb3\x13\xce\x05\xf6\x74\x68\x02\xd8\xef\x6f\x80\x1b\xef\x42\ +\xb8\x3a\xdb\xb9\x38\xf3\xda\x81\x9d\xd5\x30\xf3\xd5\x17\x5e\x78\ +\xe1\x30\x80\x3c\xf9\xd2\x73\x15\x7b\xde\xfc\x84\xe2\x78\x0e\x12\ +\x66\x44\x84\xe8\xa1\xbd\x22\x17\x2d\x2e\x98\x39\xa4\xf6\x12\x80\ +\x20\x4c\xc7\x3f\x83\xe2\x54\x5d\x01\xa0\xe1\x5d\x86\x0b\x11\x09\ +\x4e\xba\x0c\xc0\x78\x57\xe0\x14\x40\x89\x99\x13\xbf\x19\x11\x51\ +\x14\xc7\x40\x51\x50\x68\x2f\x03\x6b\x2d\x55\x7f\xbc\xbf\xb0\x1b\ +\x07\x4c\x83\x62\x61\x11\x3b\xe7\x2b\x9b\xd3\xfc\x3f\xac\x77\xea\ +\x90\xa8\xe9\x6b\x5e\x43\xed\x69\xd8\x37\xc7\x0f\xec\x2e\x4a\xff\ +\xd7\x03\x51\xf3\x5d\x17\x34\x30\x96\x47\xcd\x1b\xd6\x89\x54\x93\ +\x71\x87\xe2\x16\x71\x9d\xf9\xb1\xdb\x20\x7a\xfd\xb8\x73\x38\xb1\ +\x9a\x5b\x6b\x2d\x00\xf2\xcf\x9f\x44\x84\xfd\xf6\xe4\x5e\xbe\xf1\ +\xda\x59\x1b\xb6\xb5\x1b\xe7\x58\x3b\xb7\x22\x3c\xdc\x4c\x46\x6f\ +\xde\x24\x3d\xd7\x7e\xbe\x3c\xfa\xb1\x6b\x23\xb3\xba\x27\x01\x50\ +\x11\x11\xeb\x6b\x6b\x87\xe6\x5d\x39\x0f\xa5\xbb\x5f\x71\x63\xbd\ +\xfe\x98\x0a\x56\x45\x51\x14\xe5\x45\x79\x31\xc1\x7a\x01\xa6\x66\ +\x42\xb8\x7f\x85\x04\x30\x00\x00\x20\x00\x49\x44\x41\x54\x07\xc0\ +\x93\x38\x79\x94\xe2\x44\x1c\xf1\xb7\x67\xe0\xc6\x37\xd0\xc1\x71\ +\x01\xae\x66\x67\x13\x80\xc7\x3b\xbc\x5f\x45\x51\x3a\xc7\x26\x38\ +\x67\xd1\xa9\x20\x07\xf0\x2c\x80\xe7\x30\xd1\x67\x72\xb2\x14\x00\ +\x76\xf9\x5b\x09\x2e\x9b\x63\x39\x4e\xaf\xa5\x98\x32\x45\xc4\x71\ +\x7c\xcd\x35\xd7\x5c\x53\x62\xe6\xde\xd2\xc7\x1f\xe3\xe1\x7f\xba\ +\x41\xe2\xcd\x47\x0a\xb3\x69\xee\x98\x88\x34\x79\xe7\x50\xdc\xbc\ +\x64\x61\x0e\x91\x44\x44\x52\x1f\x61\x64\x78\x71\x0a\x5f\xa3\xca\ +\xcc\xb1\x4f\x9b\x8d\xbd\x18\xcc\xbd\x5b\xb0\x30\x33\xf9\x36\x38\ +\xe3\x29\xe3\xbe\x5e\x34\x88\xdc\x26\x80\x42\x04\x91\xaf\x17\xcd\ +\xa2\xa6\x8d\xb3\x3d\x43\x62\x6e\x58\x33\x36\xf6\x28\xc9\x8a\xe7\ +\x77\x47\x23\xeb\xe7\xcb\x40\x35\x4e\x7d\xbd\x6a\x0e\xa0\x2e\x22\ +\x25\x2f\x18\x73\x00\x69\xd7\xef\x7d\x47\x64\xb0\x41\xa3\x1f\xb9\ +\xfa\x58\xf2\xd8\x41\x6e\xfc\xc2\x39\x05\x5c\x4f\xd4\x04\xee\x33\ +\x5d\xf7\x11\x60\x82\xab\x77\x4d\x82\x6b\xb0\x1f\x57\x8c\x89\x0c\ +\xa7\xa2\x35\xc2\x8a\x60\xc6\xe4\xee\x6f\x5a\x6b\x0d\x5c\x7a\x34\ +\xf9\xc8\x71\x0a\xa0\x62\xad\x05\xcf\x2d\x37\xeb\x37\xac\x6b\x96\ +\xfe\xe9\x69\x1a\xba\xfb\xed\x07\x7a\x6e\xba\xab\x7f\xec\x03\x17\ +\xd7\xf3\xab\x97\x33\x5c\x2f\xd7\x8c\x88\xb2\xb7\xbc\xe5\x72\x73\ +\xd7\x5d\x3f\xd0\x7e\xac\x8a\xa2\x28\xca\x4b\x72\xa2\x49\xd3\x22\ +\xb8\x54\xb6\x4e\x62\x01\x3c\x01\x17\xb1\x98\x2c\x23\x00\x1e\x00\ +\xb0\x01\xc0\xba\x0e\xec\xaf\x95\x65\x70\x93\x55\xad\xa7\x51\x94\ +\xd9\x47\x2f\xa6\xce\x64\xe9\x00\x80\xc7\xd0\xde\x62\xda\xa9\x52\ +\x07\xf0\x63\x38\x51\xbc\xda\xdf\x34\x5d\x78\xe6\x60\x00\x57\x5d\ +\x75\xd5\x55\xa5\xf4\xfe\x3d\xd6\xac\xe9\xcb\x01\x0c\xf1\x93\x87\ +\x92\xe6\xdb\xd7\x5b\x6e\xda\x4c\xaa\x49\x09\xae\x5d\x4b\x01\xa0\ +\x29\x22\x63\x2d\x91\x47\x89\xa2\x28\x44\x1d\x43\x4b\x99\x54\x44\ +\x62\xff\xbb\x6f\x59\x33\x5e\xbf\x1a\xd2\x80\x23\x6f\x6c\x14\xc3\ +\xa5\x19\x37\x88\x28\x37\xc6\x89\x58\x6b\x2d\xfa\xef\xdd\x1a\x1f\ +\xb9\x6a\x3d\xe6\xc2\x4a\xf3\x48\x81\xee\xb1\x31\x39\xb0\x7e\x71\ +\x01\xd8\x71\x43\xa7\x89\x6c\x5e\x80\xeb\x22\xd5\xf7\x7c\x99\x9b\ +\xd7\xaf\xb1\xe6\x82\xf9\x63\xd1\xb3\x47\xb9\x71\xd3\xfa\xba\xaf\ +\xa9\x0d\x29\xc3\x63\x70\x22\xb7\xf0\x91\xdc\xd8\x47\x89\x53\x78\ +\xe1\xec\xa3\xc0\x80\x8b\x22\x27\x00\x52\x5f\xc3\x3a\xfe\x3c\x00\ +\xe4\xd6\xda\x71\x07\x62\x5f\x33\x0b\xbf\xff\x88\x99\x23\x6b\x6d\ +\xca\xdd\x69\xb9\x71\xc3\xba\x38\xbd\x7b\x6b\xf5\xd8\xdd\x6f\x6b\ +\xf4\xdc\x70\x67\x45\x06\x4a\x43\xe6\xc2\x05\x23\xbe\xc5\x4f\xf9\ +\xca\x2b\xaf\x2c\x17\xc5\x9f\xaf\x81\x5b\x80\x3e\x32\xa5\xef\xb6\ +\xa2\x28\x8a\x72\xc6\x72\xfc\x64\x89\xd1\xf9\x54\x60\x03\xe0\x21\ +\x74\x46\xac\xb6\xb2\x05\x9d\x8f\x86\x12\x5c\x04\x47\x51\x94\xd9\ +\xc7\xb9\xe8\x7c\x4a\xad\xc0\x19\xae\x3d\x84\xa9\x15\xab\xad\x34\ +\x01\x6c\x06\xf0\x6d\x4c\xa4\x0e\x2b\xd3\xcf\x0a\x63\x4c\x7a\xee\ +\xb9\xe7\x8e\x64\x7f\xf9\x90\xd4\xfe\xfc\x67\x72\x22\xea\x45\x16\ +\xf5\x10\x51\x57\xfc\x9d\x9d\x71\x7e\xf9\xe2\x31\x00\xc7\x44\x64\ +\x04\x6e\xc1\x41\x7c\x7b\x9a\x94\x88\xca\xc6\x98\x6e\xb8\x85\x94\ +\x1e\x22\xaa\xc2\x89\x50\xcb\xcc\xa1\x55\x9a\x05\x30\x26\x22\xa3\ +\xcc\x3c\xe2\x7f\x8e\xc2\xf5\x1e\x2d\x7c\x1a\x6f\xe4\xd2\x71\x9d\ +\x39\x53\xbc\x67\xd4\x36\xe7\x76\xd9\xb8\x4c\x51\x51\x50\x3c\xf0\ +\xad\x2d\x65\xbc\x75\x95\x41\x8b\xa1\x97\x77\xdc\x4d\x88\x28\x4a\ +\x9e\x3e\xc6\xdd\x6f\xfb\x42\x77\xfd\xcf\x5f\x07\xf3\xca\xf9\xc2\ +\xdb\x07\xe3\xfc\xda\xd5\x16\x40\x6a\x8c\x49\xe1\x22\xa3\x02\x17\ +\x0d\x6d\xf1\x7a\x42\x0c\xd7\xae\x4e\x00\xd4\x88\xa8\x06\xa0\xe6\ +\x45\xf9\x18\xdc\xe7\x54\xfc\x2d\x27\xa2\xe0\x92\x5c\x22\xa2\x5e\ +\x11\x99\x43\x44\xfd\x22\xd2\x0b\xa0\x5b\x44\xca\x00\x4a\xde\x74\ +\x8a\x44\xc4\x4a\x4f\xda\x2c\x2e\x59\x58\xa4\xf7\xee\x8a\x87\xff\ +\xe9\x7a\xaa\xfc\xc1\xbf\x0d\xf0\xae\xe1\x79\xd6\xda\x2e\x00\xc5\ +\xc0\xc0\xc0\xd1\xde\xde\x81\x61\x00\xaf\xe8\xfc\xdb\xab\x28\x8a\ +\xa2\x9c\x2d\x1c\x2f\x58\x97\xc0\x19\x1d\x75\x0a\x01\xf0\x08\xa6\ +\xce\xcc\x68\x27\x3a\xef\xee\x3b\x1f\xce\x30\x45\x51\x94\xd9\xc3\ +\x02\x74\xbe\x0c\x40\x00\xfc\x00\xc0\xd6\x0e\xef\xf7\x54\xa9\xc1\ +\xb5\xd4\xfa\x01\x9c\x38\x50\xa6\x97\x0d\xab\x57\xaf\xb6\xf1\x73\ +\x43\x5d\x76\x7e\x85\x45\x04\xd1\xe3\x07\x1b\xc5\x86\x81\x9a\x88\ +\xe4\x34\x9a\x47\xd4\x5b\xca\x00\x74\x11\x51\x37\xdc\x75\xa1\xd7\ +\x8b\xb4\x7e\x38\x91\x9a\xfa\x5a\xd5\x11\x00\x47\x44\xe4\x08\x80\ +\xc1\x16\x81\x4b\x41\x94\x62\xc2\x89\xd7\xc2\x1b\x38\xf9\xba\xd1\ +\x12\x80\xac\x54\x42\xc9\x18\x4e\xe3\xfb\x77\x67\xc7\x5e\xb1\x58\ +\x4a\x25\x61\xfb\xd0\xfe\xf2\xe1\x35\x4b\x92\xa4\x84\x6e\xa2\x71\ +\x97\x62\x00\x48\x45\xa4\x9a\x7e\x63\x47\x5a\xf9\xe0\x77\x92\xa1\ +\x2f\xdd\x28\x96\x85\xf8\xa9\xc3\x51\xfe\x86\x55\x09\x80\x2e\x3f\ +\xee\xaa\x8f\x94\x8a\x88\xc4\x44\x54\x62\xe6\x0c\x40\xd5\x1b\x2c\ +\x45\xf0\x6d\x6a\x8c\x31\xbe\x3c\x96\x42\xaa\x70\x10\x9e\x75\x00\ +\x23\x22\x32\x2c\x22\x47\x89\xe8\x08\x11\x1d\x15\x91\x51\x6b\xad\ +\xf5\xf5\xb8\x15\x00\x5d\xe2\xfa\xd3\x96\x99\x39\xf3\x69\xd0\xb1\ +\x5d\xd9\x1b\x21\xe2\x88\x9f\x1f\xe1\xa1\xcf\xdf\x60\x2a\xef\xfe\ +\x2a\x33\x33\x03\xa8\x8a\xc8\x9c\x8d\x1b\xd7\x74\x01\xc9\x86\x29\ +\x7f\xb7\x15\x45\x51\x94\x33\x96\xe3\x05\xeb\xca\x0e\xef\x7f\x0b\ +\x5c\xaa\xdd\x54\xb2\x15\xc0\xde\x0e\xef\x73\x65\x87\xf7\xa7\x28\ +\xca\xe4\x58\xdd\xe1\xfd\x09\x80\x1f\xa2\xf3\xe7\x8e\x76\xd8\x03\ +\x67\xf8\x36\xd5\xe7\x4a\xe5\x85\x6c\x58\xba\x74\xe9\x50\xe5\x43\ +\xdf\x69\xd6\xff\x9f\xd7\x0d\x12\x11\xf8\xb9\x63\x65\xb3\xb6\xaf\ +\x82\x86\x29\xa3\x92\xb0\xb5\x36\x86\x13\x75\x0c\xdf\xa6\xc6\xa7\ +\xd3\x0a\x5c\xf4\x74\xdc\xa0\x88\x99\x73\x5f\x1f\x1a\xc4\x68\xd3\ +\x9b\x23\xc5\x44\x54\x16\x91\x2a\x9c\xa8\xeb\x26\xa2\x0a\x5c\x2a\ +\xae\x78\x41\xd9\xb5\x7c\xb9\xad\x1e\xf8\xf6\x91\x9e\xe2\xfc\xb9\ +\x29\x33\x45\x95\x8a\xc0\x6c\x1e\x8a\x87\x97\xba\x75\x9a\x96\xd4\ +\x5b\x00\x40\x76\xf7\x36\xa4\x7f\xff\x04\x0f\x7d\xf1\xad\x02\x03\ +\x24\xdf\xd8\x8e\xfc\xba\xb5\x27\xea\x27\x4e\x70\x69\xcd\x19\x9c\ +\x48\xec\xf1\x3f\x33\xff\xff\x98\x88\xaa\x51\x14\x75\x8b\x48\xb7\ +\x88\x74\xf9\xf1\xc6\xcc\xdc\x24\x22\xd7\xab\xd5\xb7\xb9\xf1\x63\ +\x06\x11\x11\x33\x87\xd7\x46\xe0\x6b\x5b\x31\x5e\x93\xeb\xca\x7b\ +\x45\x84\xf3\x2b\x96\xd8\xe4\xe1\x7d\x16\xe5\x48\xea\x1f\xba\x0c\ +\x5d\xbf\xfe\xf5\x20\xf4\x07\x57\xaf\xae\x0c\xa6\xe9\xf9\xaf\xee\ +\xc8\x3b\xaa\x28\x8a\xa2\x9c\x95\xb4\x0a\xd6\x7e\xb8\xd4\xa6\x4e\ +\x71\x0c\xd3\x17\xb9\x78\x1c\x9d\x8d\x50\x2c\x86\x4b\x95\x52\x14\ +\x65\xe6\xe9\x05\x30\xa7\xc3\xfb\x7c\x06\xc0\xee\x0e\xef\x73\x32\ +\x34\xe0\xd2\x92\x9f\x44\xe7\x0c\x9f\x94\x97\x20\x49\x92\x73\x5e\ +\x79\xfe\xf9\x15\x49\xe3\xd4\x74\xc7\xfd\x00\x2a\x60\x27\xbe\x92\ +\x87\xf6\x9a\xe2\x92\x85\x4d\x22\x1a\x05\x30\x24\x22\xc3\x44\x34\ +\x0c\x17\x69\xac\xb7\x38\xf4\x96\xe1\x8c\x86\x2a\x3e\xcd\xb5\x9b\ +\x88\xba\x83\x28\xf5\xe9\xb1\xc1\xcc\xa8\x0c\xa0\xda\x62\xdc\x14\ +\x22\xad\x00\x90\x47\x11\x46\x4a\x3f\x3e\x58\x37\x9b\xe6\x0c\x8b\ +\x50\xbd\xff\x91\x9d\x72\xe8\xfc\x65\x85\x31\x68\x10\xd1\xb0\xb5\ +\x52\x83\x33\x4d\x92\xf4\x2b\xdb\x6d\x72\xc7\x66\x0c\x7f\xea\xcd\ +\x75\x00\x45\xf6\x85\x67\x4c\xe3\xc6\xf5\x10\x91\x9c\x88\x46\x00\ +\x0c\xfb\xb1\x37\xfd\xf1\xeb\x70\xed\xe3\x86\xfc\xf3\x08\xee\xd7\ +\xc6\x6f\x63\x7c\xb4\x37\x21\xa2\x92\x1f\x2f\xac\xb5\x19\x5c\xba\ +\x6f\x9f\x4f\x03\xee\x13\x91\x6e\xb8\x08\x6e\xc5\xd7\xeb\x1a\x11\ +\x19\x83\x6b\x4d\x37\x02\x60\xc8\x5a\x3b\x48\x44\x87\x01\x1c\x22\ +\xa2\x23\x00\x6a\xc5\x15\x4b\xf3\xe4\xfe\xdd\xc8\xaf\x58\x02\xd3\ +\x9d\x52\x76\xe7\xd6\x92\x88\xf4\xbd\xea\x55\x6b\xaa\xcc\x65\x2d\ +\xc5\x51\x14\x45\x51\x5e\x94\x56\xc1\xda\x69\x33\x93\x27\xe0\x1d\ +\x14\xa7\x81\x1c\xae\x26\xac\x53\x30\x5c\x7a\xb4\xa2\x28\x33\xcf\ +\xca\x0e\xef\x2f\xb8\x8d\xcf\x46\x9e\x03\x70\x1f\xd4\xf8\x6d\xca\ +\x29\x95\x4a\x17\xbc\xeb\x87\x4b\x4a\x8d\xdf\xbc\xd0\x00\x20\x3e\ +\xda\x28\xa4\xbf\x54\x67\xe6\x63\x74\x78\xac\x66\xfa\xb2\x11\x2f\ +\xf4\x0a\x22\x32\xd6\x5a\xf2\x6e\xba\x21\xda\x0a\x1f\x45\x8c\x89\ +\xa8\x0c\x57\x4e\xd3\xea\xc8\x9b\xc3\xd5\x86\x36\xbc\xfb\xaf\x01\ +\x30\x2a\x22\xc7\xe0\x16\x74\x87\xe1\xd2\xc2\x05\x80\x44\x3f\x3e\ +\x2c\xc3\x2b\xe6\x8c\x89\x48\xcd\x1a\xd3\x8c\x07\xeb\xb6\xd6\x53\ +\x26\x11\x6b\x45\xa4\x09\x70\x83\x88\x9a\xd1\xc3\xfb\x24\xfb\xbb\ +\xc7\x79\xf4\xd3\x6f\x19\x24\xa2\x22\xb9\x7f\xb7\xe4\x97\x2e\xca\ +\x91\x45\xf0\x46\x48\x4d\xb8\x05\x90\x5c\xfc\x00\xfd\xef\x75\x11\ +\xa9\x59\x6b\xeb\x3e\x2d\x19\x22\xd2\xf0\x02\x76\x08\x2f\xec\x87\ +\x0e\x38\x51\x1b\x44\x68\xd3\x5a\x2b\x2d\x6e\xc0\xc1\x31\x18\x3e\ +\x82\x9c\x01\x28\x8b\x48\x59\x44\x4a\xde\x18\x8a\xfd\xf1\x73\x00\ +\xa3\x66\x51\x75\x90\xf6\x8c\x8c\xc2\xc8\x91\xda\x7f\x7d\xed\xb1\ +\xd2\x3f\x3c\x61\x89\x08\x1b\x37\x6e\x4c\x89\x9a\xab\x3a\xfe\x06\ +\x2b\x8a\xa2\x28\x67\x0d\xc1\x25\x98\xe0\x6a\xc4\x3a\xc5\x41\x00\ +\x47\x3b\xb8\xbf\x53\xe1\x79\x00\x6b\xd1\xb9\x96\x17\x0b\x01\x6c\ +\xeb\xd0\xbe\x14\x45\x69\x0f\x86\xfb\x2e\x76\x0a\x01\xf0\x23\x4c\ +\xdf\x62\x5a\x3b\x0c\xc1\x89\xd6\xf9\xfe\xef\xd1\x19\x1c\xcb\x59\ +\x4b\xbd\x5e\xef\x9b\x5b\x4b\x38\x7f\xf5\x42\x00\xc8\xa3\x07\xf7\ +\x48\x71\xd5\x72\xb1\xd6\x96\x10\x51\xec\xd3\x76\x43\xbb\x17\x78\ +\x87\x5c\xf1\x62\x2f\x07\x50\x30\x33\xfb\x68\x24\x63\xa2\xd5\x4c\ +\x70\xdc\x05\x5c\x2a\x6e\x0c\x77\x8d\x4d\x7c\x1f\x54\x03\x17\x59\ +\x0d\x75\xad\x85\x88\x44\xf1\x53\x87\xb9\x76\xee\x26\x2b\x92\xa3\ +\xef\xfb\xbb\x38\xbf\x76\xa9\xe1\xa3\x14\x13\xb9\x54\x64\x40\x98\ +\x8e\xe5\x54\xf9\x93\x07\x68\xf8\xee\x1b\x9b\xd6\x5a\xa6\xb1\x82\ +\x68\xb0\x41\xe6\xf2\xc5\x42\x7e\x9c\xde\x54\x89\xad\xb5\x0c\x97\ +\x92\x0b\x66\xb6\xde\xd9\x18\xbe\x46\x95\xfd\x73\xca\xfd\x58\x04\ +\xce\x05\x38\xf2\xe3\x32\x70\x3d\x65\x1b\x70\x66\x4d\xa1\xef\x6c\ +\xc9\xdf\x18\x13\x29\xc0\x21\x23\xa0\xb5\xbd\x4d\xc9\x0b\xd9\xf0\ +\x72\x1b\x00\x26\xbf\x7a\xb9\xc4\xf7\xed\x92\xe2\xa7\x97\xe5\x8d\ +\xb7\xaf\x6f\x56\xfe\xf4\xc1\x68\xfe\x2d\xf3\xe3\x66\xb3\xde\xd3\ +\xe9\xf7\x57\x51\x14\x45\x39\x7b\x08\x82\xb5\x1f\xee\x22\xd3\x29\ +\x66\xc2\xc4\x44\xe0\x04\xe6\x79\x1d\xda\x5f\x78\x4d\xd4\x0c\x45\ +\x51\x66\x8e\xb9\x98\x30\x9a\xe9\x04\x3b\x70\x66\x44\x2f\x0d\x66\ +\x47\x7d\xed\x59\xcb\x85\xc9\xb2\x85\xc5\xc2\x0a\xa5\xee\xda\xc1\ +\x94\x5b\x2b\x59\x24\xf1\xbe\x9a\x31\xf3\x2b\xa1\x3f\xaa\x85\x4b\ +\x9b\x05\x00\xeb\x4d\x89\x00\x27\xce\x62\x11\x89\x44\x24\x23\xa2\ +\x52\xf8\x3b\xa4\xd7\xc2\x09\x3a\xaf\x23\xc5\xc0\xb5\x88\x49\x7d\ +\xa4\xd5\xf8\x68\x6d\x64\xad\x05\x8f\x16\x11\xfa\xca\x51\xa5\x22\ +\xa5\x66\x33\x32\xc9\x50\x3d\x91\x79\x15\xc2\x51\x70\x1c\x73\x6c\ +\x0c\xca\xcc\x44\xd5\x5b\xee\xac\x0e\x7d\xf6\x3a\x81\xdb\xb6\x9a\ +\x7e\x69\x6b\xdc\xbc\x71\x83\x30\x73\xe6\x05\x68\x42\x44\x16\x2d\ +\xe2\xd3\x47\x39\x93\x96\x3e\x38\xb1\x17\xd1\x16\x40\xe4\xa3\xa3\ +\xc1\x3a\x38\xf5\x62\xb6\xc1\xcc\xae\x97\x8d\x13\xab\x00\x10\x5b\ +\x6b\x13\x66\x8e\x99\xb9\x30\xc6\xd4\xfd\x6b\x94\x63\xc2\x85\x98\ +\x5a\xda\xe0\x44\xde\x64\x2a\x82\xaf\xa3\x95\x81\x32\xf3\xa1\x5a\ +\x2a\x22\x49\xe3\xd6\x73\xa2\xee\xb7\xdf\x15\x77\xfd\xca\x4a\xb2\ +\xb6\x28\xf9\xc7\xcc\xe6\x85\x24\x45\x51\x14\x65\x86\x08\x82\xb5\ +\x93\xd1\xd5\x31\x4c\x9d\x2b\xf0\xc9\xd8\x05\xd7\x96\x26\x3a\xd9\ +\x03\x4f\x01\x82\x8b\x70\xec\xea\xc0\xbe\xa6\x8a\x18\x2e\x0d\xad\ +\x0c\xb7\xe2\x1d\xc1\xf5\xd3\xcb\xe1\x52\xcd\xc6\x70\xf6\x4d\x00\ +\x18\x13\xcf\x39\xa4\xdf\x85\xa8\x00\xe0\x57\xf2\xe1\x52\xe2\xea\ +\x70\xaf\x43\x6d\xfa\x87\x39\xeb\x29\xc1\xbd\x8e\xc1\xc1\xd4\xc2\ +\xa7\x11\xc2\xbd\x6e\xb3\x65\xa1\x66\x51\x07\xf7\x25\x98\x39\x47\ +\x60\x65\x96\xf1\x9f\xc7\x5e\x53\xdd\xf3\xfe\x73\xb1\xd6\x7d\xde\ +\xc7\x60\x84\x01\x34\xf8\xe1\x3d\x69\xf1\xa6\xd5\x0d\x4c\xa4\xbc\ +\x12\x33\x93\xb5\x96\xbd\x00\x63\x38\xf3\xa5\xd8\x47\x2b\x83\x28\ +\x65\x22\xca\xbc\xc3\xae\x71\x1d\x64\x5c\xca\x30\x26\x22\xb5\xa9\ +\xff\x9b\xe0\x4b\x72\x88\x08\xc9\x77\x9e\x47\xe3\x0d\x2b\x4b\xcb\ +\x62\x8b\xbd\x5f\x3d\x8a\xf2\x45\x73\x71\xec\x98\x1b\xe7\x9c\x39\ +\x36\x3b\x74\x88\xb3\xb5\x7f\xfc\x65\x8c\xfd\xd1\xe5\x40\x5f\x06\ +\x00\x1c\x3d\x3f\x1c\xdb\x95\x7d\x40\x44\x21\x35\x19\xde\x48\xe9\ +\x27\xfc\x17\xbc\x7b\xef\x89\xe8\x9a\xc8\x1a\x1e\x6f\x61\x03\x9f\ +\xd2\x1b\xf9\xbf\x0b\x2f\x44\x23\x6f\xb2\x04\x6b\x2d\x79\xd1\x0b\ +\x38\x61\x2a\x32\xd1\xc3\x15\x13\xda\x18\xe2\x05\x34\x44\x24\x07\ +\x20\x66\x45\x6f\x33\xde\x3e\x54\x98\x55\xbd\xb6\x7e\xeb\xa6\xae\ +\xa5\xff\x63\x73\xe6\x5f\x97\x2a\x5c\xfa\xb1\x72\xe6\x11\x9c\xa9\ +\x5b\x23\xf0\xad\x41\x90\xb0\xf8\x53\xf7\xb7\x11\x4c\xa4\x9e\x2b\ +\x8a\xa2\x9c\x94\x70\xc1\xe9\x64\xbb\x88\x99\x34\x32\x29\x00\xec\ +\x43\xe7\xea\x4f\xe7\xa0\x3d\xc1\x1a\xa3\xfd\x88\x75\x03\x13\x46\ +\x1c\x27\x62\x2e\xdc\x24\x7e\x2e\x4e\xde\x82\x28\x07\x70\x18\xee\ +\x35\xd9\x7b\x92\xfd\xce\x56\x22\xb8\xe7\x1a\xda\x0d\xf5\xe0\xf4\ +\x7b\x71\x16\x70\x35\x63\x07\xe1\x9c\x58\x87\x3a\x39\xc0\x0e\x12\ +\xa1\x7d\xb3\xaf\x26\xdc\xf3\x7c\x31\x62\x38\x33\xb1\xf9\x70\x9f\ +\xeb\x93\x45\x2d\xc7\xe0\x5e\xaf\xbd\xfe\xe7\x4c\xd1\x49\xb3\xa5\ +\x3d\x70\xcf\x4b\xe9\x0c\x04\xa0\x1b\xee\x3b\x59\xc1\x0b\x27\xab\ +\x41\x94\x05\x77\xd9\xb0\x10\x32\x06\x17\xe1\x3e\x86\x19\x5e\x14\ +\xf9\x55\xbe\x9b\xbf\x32\xef\xf7\x04\x40\x4a\xc3\x79\x2c\xfd\x19\ +\x01\xe8\x26\x10\x49\xc2\x40\x8b\xa0\xf4\xd1\x4b\xb4\x88\x3b\x00\ +\x4e\xa5\x7a\xf7\xde\x20\x6e\xc7\xdd\x84\x43\xfa\x6f\x8b\x90\x0b\ +\xc2\xb6\x80\x77\xdc\xf5\x51\xcd\x18\x56\x12\x24\x9c\x43\xa4\x99\ +\x6e\x3d\xc2\x3d\xef\x5d\x53\x6c\xdf\xce\x25\x11\x24\xd5\x2a\xea\ +\xd9\x1d\x5b\xd0\x9c\xdb\xcd\x7c\xd9\xe2\x1c\x40\x99\x88\x6c\xf2\ +\xd0\xde\xe2\x4b\x7d\xcf\xf3\x91\xcf\xdd\x1b\xdd\x7c\xf3\xcd\x39\ +\xdc\x6b\x5f\xf7\x69\xba\x02\x17\x5d\x2d\xfb\xe3\x8e\xc1\x9f\x1f\ +\x44\x24\xf5\xc6\x4a\xa1\xbf\x6a\x88\x20\x47\x2d\x22\xd4\xf8\xa8\ +\xb0\xcb\x6b\x66\x8e\x5a\x22\xa5\xe1\xb9\x24\x44\x14\x5b\x6b\x5b\ +\xef\x3f\xfe\xf5\x79\xc1\x9f\x00\xac\xb9\x68\x01\xd2\x2f\x6d\x83\ +\x59\xd5\x6b\xf2\xb7\xad\xa3\xae\xcf\x6d\x8e\x99\x59\xac\x45\x37\ +\x54\xb0\x9e\x29\x64\x70\x81\x8e\xb9\x70\xd7\xe5\x76\x4a\xb1\x6a\ +\x78\xe1\x75\xb9\xfe\xd2\x0f\x57\x94\x59\x4b\x04\x77\x1d\xec\xc1\ +\x44\x30\x25\x83\x3f\x4f\xfa\xc7\x84\xf3\x7e\x13\x13\xc1\x94\xe0\ +\x1f\xf0\x52\x73\x37\xc5\x13\x26\x15\x9d\xac\x1f\xd9\xdf\xc1\x7d\ +\xb5\xc3\x01\x74\x4e\xb0\xb6\xdb\x8f\x75\x21\x80\x57\xb6\xb9\xed\ +\x83\x38\xb1\x40\x58\x02\x60\x3d\x4e\xaf\x4f\x6e\xe2\xc7\xb2\x10\ +\xc0\xb9\x70\x29\xd3\xdb\x70\x66\x08\xd7\x01\x00\x2b\xe0\xc6\x3e\ +\xd9\x88\x79\x0c\x27\x7c\xe6\x00\xd8\x08\x77\x82\xd8\xe9\x6f\xb3\ +\xc9\x91\x75\x00\xc0\xa5\x6d\x6e\xfb\x43\x9c\x78\x71\x25\x03\xb0\ +\x0e\xc0\x32\x9c\xde\xeb\x58\x86\x33\x62\x5b\x0e\x37\x89\xdc\x82\ +\xe9\x4f\x51\xcd\xd0\xb9\x9a\x74\x60\x76\x67\x4b\x9c\x29\x54\xe1\ +\x26\xaa\x0b\xe0\xca\x26\x8e\x6f\x8d\x76\x3a\x8c\xc0\x9d\xaf\xf7\ +\x62\x7a\x3d\x0f\x2a\x00\xb6\xee\x31\xc7\xa2\x4a\xa5\x62\x45\x44\ +\x92\xc7\x0e\xa0\x38\x6f\xae\x05\x60\xc5\xda\xc8\x8b\xb5\x13\xd1\ +\xaa\xc0\x82\x30\x0d\xd1\xd2\x20\xf6\x42\x9d\xaa\x6d\xd9\x26\x44\ +\x5b\x89\x88\xc8\x47\x28\x5d\xf4\x76\x7f\x8d\xec\xc2\x2a\x00\x90\ +\xe4\x26\x42\x1a\x31\xb3\x50\x51\x80\x99\x01\x6e\x14\xd1\x9c\x2f\ +\x3d\x19\xfd\xf8\xa3\x6f\x6f\xae\x97\xc2\xd5\x85\x3e\x3f\xc4\x9f\ +\x7f\xe4\x9e\xf8\x37\x3e\x73\x5b\x6c\x8c\xc1\xe3\x8f\x3f\x4e\x1f\ +\xfe\xf0\x87\xe1\x53\x94\x13\x1f\xf1\x8c\x42\x1a\x70\x4b\x9d\x2d\ +\x88\x28\xf2\x11\x53\x1b\x6a\x5e\x01\x80\x99\x61\xad\x0d\xf9\xce\ +\xe3\x22\x1d\x00\xac\x1f\xb0\x8f\x2a\x0b\x5c\x7a\xb4\xb1\xd6\x0a\ +\x9c\xa1\x13\xfc\x71\x5a\x53\xa6\x7f\x42\xc4\x12\x91\x58\x11\xc0\ +\x38\x43\x26\x66\x16\xf4\x96\x64\x4d\xdc\x2f\xcf\x34\xf1\x18\x80\ +\x9f\x46\xe7\x7b\xab\x2b\x9d\x81\xe0\xae\xc7\x2b\xe0\xae\xa5\xa7\ +\xbb\x70\x7c\x3c\x15\x7f\x0b\x59\x34\x47\x00\x6c\x87\x5b\x60\x9f\ +\x4d\xd7\xe5\x56\x08\x6e\x5e\x38\x00\xb7\x58\x57\x85\x9b\x67\x85\ +\xd6\x4e\x39\x26\x16\xe7\x8e\x01\x18\xf4\x3f\xcf\xb6\x4c\x37\x60\ +\x42\x8c\x85\xf3\x5e\x78\xee\x2f\x17\xfa\xe0\xae\x83\xf3\xd1\x5e\ +\x20\x25\x20\x70\x9f\x93\x03\x70\x8b\xea\xea\x59\xf1\x22\xc4\x70\ +\x2f\x74\x27\x52\x68\x01\xf7\x61\x1d\xec\xd0\xbe\xda\xe5\x20\xdc\ +\x07\x60\xb2\x27\x53\xc0\xa5\xb8\x04\x03\x8a\x99\x62\x0e\x80\x73\ +\x30\xf9\x96\x43\x09\x80\x0d\x70\xc2\xe5\x07\x98\xf9\xf7\xe9\xc5\ +\x98\x0b\x97\xd6\xdd\xc9\x16\x4b\xc7\xd3\x03\x57\xeb\xbc\x06\x4e\ +\x88\x9d\x8d\x42\x26\x86\xeb\x5d\xba\x1a\x13\x17\x94\x76\xe9\x02\ +\x70\x11\xdc\x44\xe2\x31\x4c\xdf\x45\xa9\xbf\x83\xfb\x0a\xd9\x06\ +\xca\xe9\x43\x70\xd1\xf9\xe5\xe8\x6c\xc4\xbb\xcb\xdf\x56\xc3\xad\ +\x34\x6f\x85\xcb\xd0\x99\xea\xc9\x5d\x1d\xc0\x5b\xe1\x16\x07\x41\ +\x44\x96\x8e\xd6\x61\x07\x4a\x05\x17\x22\x94\x46\xf0\x75\xa6\xc7\ +\x33\x91\x3b\xdb\x22\xcc\xe0\x26\xab\xad\xc2\x3d\x38\x02\x5b\x2f\ +\xfa\x82\xb0\x0d\xdb\x0a\x33\x9b\xf0\x6b\xfa\xe0\x5e\x34\xae\x5b\ +\x03\x22\xb2\xd9\x77\xf7\x61\xf8\x55\x8b\x8b\x3e\xc3\x02\xff\xbd\ +\x5d\xfb\xfb\x5f\x8a\x9e\xfb\x3f\xdf\x58\x27\x1a\x8f\xc8\x26\xc9\ +\xf7\xf7\xe3\xd2\xf7\xdf\x94\xbf\x23\xdf\x46\x7b\xf7\xee\xe5\xf7\ +\xbc\xe7\x3d\x06\x00\x33\x73\x10\xcb\xe2\x8f\x17\x56\xf7\xad\x37\ +\x8d\x7a\xc1\x58\x7c\xba\xae\xf1\xe3\x6a\xed\xf5\x1a\xc6\x68\xfd\ +\x36\xd2\x22\x40\xbd\x76\x15\x1b\xea\x65\xc3\x6b\xc2\xec\x34\x71\ +\x10\xc1\x68\xb9\x0e\x7b\x51\xeb\x22\xd2\x59\x24\xd4\xb4\xd6\xa6\ +\xa0\xfa\x9f\xfe\x74\xfe\x67\x5f\xb8\x27\xbd\x09\xf7\xbf\x1b\xce\ +\x25\x5b\x99\x7d\x2c\x82\x5b\xec\x3d\x9d\x05\xf3\xd3\x65\xc0\xdf\ +\xea\x00\x9e\x86\x33\xd2\x9c\x2d\x42\xaf\x1f\x6e\xee\xb4\x08\xa7\ +\xee\xa9\xb0\xcc\xff\x0c\x99\x7f\x7b\x30\x31\x3f\x05\x80\xa5\x68\ +\xaf\x1c\xef\x18\x80\x67\xdb\xd8\x6e\xb2\x54\xe0\xc4\xd9\x00\xdc\ +\xfc\xac\x82\x13\xcf\xb3\x1b\x70\x41\x81\x41\xb8\x85\xc8\x43\x98\ +\xbd\x0b\x10\xa7\x4b\x0c\xf7\xbe\x2e\x87\x5b\xb0\xe8\x04\x04\xf7\ +\xf9\xea\x87\x9b\xa3\x1f\x86\xeb\x62\x30\x53\xa5\x95\x27\x22\x05\ +\x70\x7e\x9b\xdb\xee\xc3\xa9\x67\xde\xf6\x00\x98\xe7\x7f\x66\x98\ +\xf8\xae\xe5\x00\xf2\x20\x58\x3b\xc5\x51\xcc\xfc\x09\xa6\x09\xb7\ +\x42\xd1\xd5\x81\x7d\x85\xe8\xf3\x74\x3b\x1e\x03\xee\x8d\x3a\x1f\ +\x6e\xa2\xd8\x49\x2a\x00\x7e\x0a\x2e\x22\x37\x9b\xfa\x50\x66\x00\ +\x2e\x40\x67\xeb\xa9\x4f\x46\x19\x2e\x12\xbe\x08\x4e\x88\xcd\x96\ +\xba\xcd\xc9\xb2\x00\xee\xb5\xec\x74\x2f\xe1\x85\x70\xdf\xab\x07\ +\x31\x3d\xa9\xb5\x9d\x3c\x37\x9d\x4d\x17\xcd\xe9\x64\x21\xdc\x44\ +\xb5\x13\xe7\xd3\x97\xa2\x1b\xee\xbb\xb8\x06\xae\xaf\xf6\x54\x9e\ +\x73\x2d\x80\x87\xa2\x28\x2a\x46\x46\x46\xe2\xbe\xbe\xbe\x44\x18\ +\x20\xa2\x94\xb7\x1e\x81\x59\x7f\xc2\x0a\x19\x41\xcb\xc2\x65\x08\ +\x5c\xfa\x1b\x05\x63\x22\xef\xc8\x1b\xc2\xa9\x21\x5d\x98\x5b\xb6\ +\xb1\x2d\x37\xc3\xcc\xb0\x84\x04\x4c\x10\x91\x82\x07\xeb\xb2\xe2\ +\xca\xb4\xf1\xdc\x73\x9c\x00\x64\xfa\xff\x6d\x5b\xdc\x9c\xdf\x65\ +\x47\xe7\x57\x0b\xb2\x5e\x25\x37\x8d\x20\x65\x2c\x58\xb0\xa0\x79\ +\xe3\x8d\x37\xd2\xd1\xa3\x47\xe3\x65\xcb\x96\xe5\x00\x12\x2f\x56\ +\xf3\x96\xb1\x59\x2f\x34\x0b\x22\xca\x83\x90\xf4\x42\xd3\xfa\xba\ +\xd2\x02\xce\xcd\x98\x5a\xc2\xc0\x21\x2a\x1c\x9e\x03\xac\xb5\xe2\ +\x05\x31\xfb\xd4\xe7\xd8\x3b\x26\x0b\x11\x05\x17\x61\xbf\xb9\x0b\ +\xda\xa2\x65\x42\xdb\x1a\x70\x2d\x36\xcd\x41\xf4\xcc\x51\x6b\xce\ +\x9b\x8b\x62\x20\x95\x41\xa9\x03\xc0\xf7\xa0\x69\xa1\xb3\x8d\x0a\ +\xdc\xf7\xb2\x93\x65\x63\x27\xa3\x04\x77\xfd\x5a\x06\xe0\x51\xcc\ +\xac\x07\xc5\x5c\xb8\xcc\xb6\xc9\x3c\xff\x18\x4e\x9c\x2e\x85\xbb\ +\x6e\x3e\x0d\xb7\x48\xbe\x02\xed\x2d\xca\x76\x2a\xc0\x74\x2a\x84\ +\x16\x8f\xcb\x71\xea\x63\xcd\xe0\x44\xc7\x3c\xff\x77\x01\x97\x45\ +\xb3\x1b\x13\x22\x6c\x21\x5c\x20\xe6\x74\x29\x00\xdc\xdb\xc6\x76\ +\x93\x85\xe1\xde\xaf\x75\xe8\xac\x41\xed\x89\x08\xd9\x80\x07\xe1\ +\x3a\x1a\xcc\x06\x0f\x96\x08\xed\xfb\x89\x9c\x2c\x62\xdc\x87\x89\ +\xc5\x9b\xf2\x4b\x3d\x30\x46\x67\x53\xee\x66\x4b\x6d\xe0\x10\x3a\ +\x37\xc1\xaa\x60\xfa\x05\xeb\x1c\xb8\x8b\xc4\x4b\xbe\x79\x93\x80\ +\xfc\xfe\x19\x6e\x15\x73\xa6\x59\x00\xe0\x15\x98\xfa\x13\xc1\x4b\ +\x1d\xff\x0a\x38\x21\x76\x26\xa7\x63\x44\x70\xe2\x62\x2a\x7b\x1a\ +\x76\xc1\xa5\x2d\xdf\x8f\xa9\x8f\xb4\x76\x72\x35\x7f\x26\x16\x9d\ +\xce\x64\x32\xb8\xef\xe4\xfc\x93\x3d\xb0\xc3\x74\x03\xb8\x1c\x2e\ +\x82\xb0\x65\x2a\x0f\x44\x44\x23\x23\x23\x23\x7d\x22\xd2\x40\x61\ +\x0b\x00\xb5\xe8\x99\xc1\xa4\xb8\x76\x55\x13\x4e\x84\x0a\x11\x05\ +\x43\xa1\x30\x49\x6c\xfd\xc9\x5e\xa8\x86\xd2\x1a\x00\xe3\x75\xac\ +\x61\xb1\x28\x6e\xb9\x3f\x6c\x37\x7e\x5e\x97\xdc\x00\xd9\xf8\xfc\ +\xb3\x22\x4c\x60\x46\xd5\x18\x80\x48\xb0\xe0\x1f\x1f\xc5\xe6\x8f\ +\xdc\xc8\x6c\x51\x21\x02\x44\x2c\x92\xfb\x76\x71\x7e\xf9\x12\x88\ +\x48\xf5\xf2\xcb\x2f\xf7\x2d\x6f\xc6\x8f\xd7\xba\x2a\x4d\x70\x75\ +\xac\x04\xa0\xbb\xb5\x9e\xd4\xff\xce\x2d\x8f\xc5\x71\xff\x1f\x37\ +\x6f\xf2\x91\x57\x13\x52\x98\x5b\xf6\x1d\xb0\x98\xa8\xc1\x0a\x8f\ +\x1b\x8f\xd4\xc2\x1b\x2f\x85\x08\xae\x88\x14\x76\x79\x37\x25\x77\ +\x6d\x2d\xd9\xf3\xe7\x15\xc7\x8e\x1d\xab\xfc\x07\x79\xb8\x82\xd9\ +\x33\x7f\x50\x1c\x8b\xe1\x84\xe3\x64\x33\x74\xda\xa5\x1f\xc0\x6b\ +\xe1\x16\xb0\xf6\x4c\xf3\xb1\x53\xb8\x2c\xac\x4e\x07\x0c\xca\x70\ +\xe7\xd5\x35\x98\xda\x68\x75\x27\x58\x06\x17\xf1\x2b\x4d\x72\x3f\ +\x21\x2a\xb9\x0c\x2e\xed\x7b\x33\xdc\x9c\xab\x1d\xed\x31\x13\xb5\ +\x9e\x3d\x70\xf3\xe5\xe9\x6e\xbd\x35\x0f\xee\xf3\xff\x23\xcc\xae\ +\xe0\x52\xa7\x18\x80\x9b\xaf\x9e\xf2\x62\x50\x8c\xc9\x7f\x18\x5b\ +\x99\x2d\xed\x22\x3a\x39\x8e\xa9\x12\x8d\x2f\xc6\x6a\xb8\x55\xbd\ +\x4e\xa4\x34\xbf\x14\x04\x77\x31\xaa\x61\x66\x53\x25\x57\xc3\xa5\ +\x00\x4f\xf5\xf3\x3d\x19\x15\xb8\x89\xf2\xfd\x98\x1d\x2b\x5a\xa7\ +\x4b\x2f\x5c\x1f\xe2\xa9\x8e\x84\xc1\x1f\xe3\x15\x00\xbe\x3f\xc5\ +\xc7\xe9\xe4\x77\x6f\xb6\xa6\xc0\xcf\x46\xe6\xc2\xa5\x80\x77\xb2\ +\x9d\xd0\xe9\x40\x70\x2b\xd9\x15\xb8\x4c\x90\x29\xc9\xda\x29\x95\ +\x4a\xf9\xe8\xe8\x28\x98\x39\x43\xc2\x89\x88\x44\x24\x22\x12\x33\ +\xe0\xd2\x5d\x0b\x66\x36\x22\x62\xbd\x71\x52\x6b\x4a\x70\xe4\xa3\ +\x8a\x09\x26\x5a\xc8\x08\x11\xd5\xe1\xfa\x97\xe6\xcc\x1c\x52\x63\ +\x23\x22\x2a\x8b\x48\xc6\xcc\x0d\x6b\xed\x78\x04\x34\xf9\xe1\xc1\ +\xc4\x9c\x3f\x3f\x11\x91\x38\xda\x39\x94\x9b\x65\xdd\xde\xa8\x09\ +\xd1\xa2\xcf\x3f\x9e\x1c\xbb\x64\x19\x8b\x60\x3c\x95\x17\x00\x68\ +\xb8\x09\xe9\x3b\xe5\xe4\x09\x0b\x27\xac\x9b\x98\x88\x10\x47\x98\ +\x68\x73\x33\x06\x17\x7d\x15\x5f\x9f\x1a\xfb\x71\x36\x45\xa4\x21\ +\x22\x4d\xff\x3f\x26\xd7\xdb\xb5\x44\x44\x25\xf7\x12\x48\xd3\x3f\ +\x1f\x83\x89\x89\xa4\xf8\xe7\x4c\x22\x42\x51\x14\x91\x88\x90\xb5\ +\x16\x3e\x02\x1b\x01\x48\x05\x88\x29\xa2\x14\x00\x6a\xb5\x5a\x30\ +\x5d\x52\x43\xb4\xd9\xc3\x1a\xb8\xeb\xf2\x4c\x13\x03\x78\x15\xdc\ +\x3c\x75\xdb\x34\x1d\xb3\x1f\xee\xfc\xd7\xc9\xb9\xf1\xf1\x4c\xc7\ +\x75\xba\x5d\xca\x70\xaf\xf9\x54\x44\xd5\x07\xe0\xe6\x59\x33\x9d\ +\x89\x79\xaa\xac\x84\x8b\x04\x4f\xc6\xab\x61\x32\xb4\x7e\xfe\xcf\ +\x96\x0e\x07\x29\x9c\xa7\xce\x69\x7b\x0d\x75\x3a\xc2\x3a\x5b\x2e\ +\x38\x9d\x1c\xc7\x54\x9e\xb4\x4e\xc4\xbc\x93\x3f\xa4\x63\x10\x80\ +\x0b\xe1\x52\x2c\x1a\xd3\x78\xdc\xc0\x06\xb8\x89\xe9\x6c\x21\x03\ +\xf0\x6a\x00\xf7\xe1\xcc\x73\x6d\x9b\xca\xa8\xea\x89\x08\x66\x5e\ +\xfb\xa6\xf0\x18\x9d\x3c\x37\x9d\x89\x8b\x10\x33\xc1\x32\xb8\x85\ +\xac\x99\x5e\x40\x02\xdc\x05\x4d\xe0\x44\x6b\xc7\x69\x34\x1a\x87\ +\x86\x86\x86\xfa\xf9\x40\x2d\xc6\x82\x6e\x30\x73\x64\x19\xec\x5d\ +\x74\x59\x44\xd8\x5a\x0b\x00\x96\x99\x8d\x37\x1e\x32\x3e\xf2\x1a\ +\x76\x93\x78\x91\x47\x5e\xdc\xe5\x00\x0a\x66\x2e\x30\x91\x1a\x1b\ +\x79\xc1\x27\xd6\xda\xa6\x88\xd4\x7d\xc4\x51\x68\xf7\x70\x97\x5c\ +\xb2\x30\x21\x11\x13\xff\xe8\x50\x6e\xde\xbc\x66\x18\x10\xe9\xea\ +\xb2\x95\xee\x7b\xb7\xa6\xdb\xff\xf6\x6d\xb6\x39\x8a\x66\x1c\xa3\ +\x69\x2d\x20\xd6\xc6\x12\x73\x37\x5c\x76\xc3\xa8\x88\xa4\x5e\x68\ +\x16\x44\x54\x15\x91\x06\x11\x8d\x89\x88\x65\xe6\xc8\x5a\x5b\x21\ +\xd7\x23\xb6\x19\xc6\x47\x44\x89\xb5\xb6\x0a\xa0\xe4\xeb\x50\xc7\ +\xbc\x9b\x71\x02\xd7\x2b\x36\xf4\x97\x15\x38\xb7\xe0\x02\x4e\xf4\ +\xc6\xde\x81\x38\x08\xde\xcc\x7b\x31\x19\x22\x2a\x64\xc2\x21\x39\ +\x02\x10\x31\x33\xfb\xfd\x44\x44\x34\x5e\x2f\xeb\xd3\x88\x2d\xc4\ +\xa5\xe8\x8f\x8c\x8c\x80\x28\x3a\x1b\x5b\xb0\x9d\xa9\xac\x85\x8b\ +\x7c\xcc\x16\x08\x13\xe9\xa3\x53\x2d\x5a\xe7\x01\xb8\x18\xd3\x9b\ +\x76\x3b\x9b\x98\x07\x37\x27\x9c\xea\xc5\xca\xd9\x70\x7d\x79\x29\ +\xc2\x67\x6e\xba\xe7\x55\x2f\xc6\x26\xb8\xc5\xc7\x33\xbd\xc6\x7f\ +\x2e\x5c\xb4\xba\x2d\x5d\x15\xa3\xb3\x75\x6e\xb3\xa5\xfe\xa4\x93\ +\xe2\x6b\xba\x05\xeb\x74\x93\xc1\x7d\x31\x1f\x9d\xe6\xe3\xae\xc1\ +\xec\x12\xab\x81\x2e\xb8\x54\xa0\x29\x99\x24\x9f\x65\x6c\xc0\xd4\ +\x0a\xd6\x4e\x9d\x9b\x42\x8f\xd9\x76\x60\x4c\x6f\x5d\xf5\x89\x18\ +\xc1\xf4\x64\xaf\x2c\x83\x8b\x9c\xcf\x26\x96\xc2\x3d\xff\x8e\x9b\ +\x8c\x64\x59\x76\x78\xf7\xee\xdd\x2b\xa2\xea\x31\x14\xeb\xfa\x63\ +\x11\x01\x09\x15\x70\xd7\x31\x1b\x22\xaa\x2d\xa2\x2b\x02\x10\x07\ +\x21\x86\x89\x56\x36\x80\x33\x29\x8a\xac\xb5\x19\xdc\x75\x35\x18\ +\x16\xb1\x77\xed\x4d\xbc\xf0\x0b\xfb\x75\xe6\x47\x4c\x6c\xad\x8d\ +\x99\xb9\x01\x23\x85\x61\x08\x81\x68\xe5\x03\x5b\xa2\x7d\xeb\x17\ +\x4b\xa5\x02\xb3\x7d\x3b\xc9\x25\x97\x48\xf3\x07\x3f\x88\x92\xf3\ +\xe5\x00\xec\xc6\x39\xa1\xb7\x69\x38\xc6\x78\xaf\xd3\x70\x7f\x10\ +\xd6\x3e\x42\x0c\xff\xbf\x10\x25\x0e\x06\x4c\x80\xef\xdf\xed\x05\ +\x2e\x44\x44\xac\xb5\x05\xb9\x7e\xb2\x69\x4b\xdd\xad\x60\xa2\xe7\ +\x75\x28\x77\x8d\x7d\x3a\x74\x48\x1b\x0e\x82\xd4\xf8\x9f\x4d\xb8\ +\xe8\x6d\xe8\x49\x2b\xde\x98\x89\x45\x24\x05\xa1\x2c\x22\xc9\x9e\ +\x3d\x7b\x4c\x92\x94\x8e\x99\x33\xc1\xbb\xfe\xec\x67\x19\x66\x97\ +\x58\x6d\x65\x13\xdc\x77\x73\xaa\xd2\x83\xe7\x00\xb8\x04\x33\x17\ +\x4d\x9b\x69\x16\xc2\x89\xd5\x97\xeb\xf3\x6f\xe5\x5c\xb8\xe8\xea\ +\x6c\xe2\x1c\xb8\x6b\xe1\x4c\xb6\x19\x6c\x17\x82\x9b\x2f\xae\x9d\ +\xcc\x4e\x62\x74\xb6\x3e\x61\x26\xa2\x74\x27\xa2\x93\xe3\x98\xa9\ +\xfa\x8d\xe9\x64\x09\x9c\x9d\xfc\x74\xd5\xf9\xcd\xc3\xe4\x2f\x8a\ +\x02\xe7\x96\x57\x87\x8b\x36\x84\x46\xe5\xdd\x98\xfc\x22\xc3\x52\ +\xb8\x8b\xe2\x81\x49\xee\xe7\x6c\xa7\x1b\xee\x22\x3f\x15\x29\xe5\ +\x2f\x30\x6c\x99\x24\xa1\x2f\x65\x3b\x24\x70\xe9\x61\x33\xc9\xd3\ +\x98\x7a\xc1\xba\x10\x2e\xb2\x3a\x1b\xd9\x00\x77\x91\x3e\xd6\xc9\ +\x9d\x36\x1a\x8d\xc7\x9f\x79\xe6\x99\x8b\x69\xce\x15\x2c\xaf\xce\ +\x20\x22\x11\x22\x8a\xe0\xde\xf3\x10\x59\x0c\x11\x55\x1b\x7e\x1a\ +\x63\x62\x66\x0e\x91\xc4\xe0\x08\x1c\x04\x22\xf9\xa8\xe7\x78\x4b\ +\x99\x96\x68\x2c\x03\xa8\x88\x48\x0a\x27\x70\xad\x30\xd2\x50\xf3\ +\x49\x4c\x31\x91\x4b\x93\x2d\xfd\xe3\x53\xd9\xa1\xff\x72\x23\xd1\ +\x31\xa0\xd1\x00\x77\x77\xdb\x68\x64\x84\xd3\xe8\xd8\x60\x54\xff\ +\xd9\xd5\x8c\x89\x14\xdb\x17\x7c\x47\x42\xea\xae\x3f\x16\x87\x9a\ +\x53\x11\x89\x99\x39\x6e\x11\xde\xec\xc7\x9e\xfa\x31\x16\x22\x12\ +\xbb\xa7\xc0\x91\x38\xf3\xa8\x4c\x44\x5a\xcf\xa5\x02\x27\x86\x83\ +\x01\x55\x10\xed\x06\x40\x53\x44\x0a\x2f\x84\xad\x8f\xa2\xb6\x3e\ +\xef\xf0\xba\x86\x39\x47\x04\x76\x43\x7b\xfa\xe9\xa7\x0d\x73\xf9\ +\x4c\x8f\x1c\x9c\x0d\x74\xc3\x2d\xd6\xce\x56\x08\x6e\x41\xed\x18\ +\x3a\xef\x35\x51\x85\x8b\xac\xbe\x5c\xc5\xda\x00\x54\xac\x06\x36\ +\x60\xf6\x89\x55\x60\xc2\x7b\xe6\x3b\x38\xb3\x0c\x42\x63\xb8\x39\ +\xd4\xc2\x4e\xec\xa8\x93\xa9\x0f\xb3\x65\x8d\xb4\x93\xe3\x78\xb9\ +\xa4\x86\xac\x03\xf0\xd0\x34\x1c\x27\x83\xcb\xc9\x6f\x57\x8c\x1c\ +\x82\x13\xd7\x07\xf1\xe2\xef\x73\x15\xee\x84\xb3\x1c\xed\xbf\x7f\ +\x1b\xf1\x42\x0b\x7a\xe5\xc4\x2c\xc1\xd4\x08\xd6\xb3\xf1\xbc\x34\ +\x5b\xa9\xc2\x5d\x08\x27\xb3\x40\x30\x02\xb7\xe0\x35\x02\xb7\x80\ +\x64\xe1\x04\x4a\x19\x13\x6d\x10\xda\xdd\x3f\xc1\x39\xa6\xdf\x37\ +\x89\xf1\xfd\x04\x79\x9e\x3f\xf5\xc3\x1f\xfe\xf0\x18\x5d\x22\x29\ +\x88\x2c\x59\x29\x09\x50\xf6\xe1\xc3\x04\x3e\x2d\xae\xc5\x11\x38\ +\xb8\x00\x87\x36\x2f\xb9\x88\xe4\xe2\x9d\x76\x7d\x5a\xad\xc0\x39\ +\xee\xc6\xf0\x69\xb3\x7e\x5f\xc6\xdf\x28\xfc\x4f\xac\x05\xa2\xf1\ +\xf9\x61\x49\x62\x86\x88\x24\xd1\x81\x31\x92\xbe\x72\x44\x04\xb2\ +\x16\x1c\x45\x1c\x5b\x9b\x57\xa3\x88\x22\x11\x44\x7e\x3c\xb1\x88\ +\x54\xd8\xf5\x91\x09\x82\x10\x5e\x80\x06\xb7\x5f\x22\xd7\x73\x35\ +\x88\xcf\x04\xbe\x1f\xac\x8f\xfa\x02\xc7\x2d\x5a\x7b\xe1\x4a\x70\ +\x02\x3c\xf2\x7f\x37\x00\xe4\xe4\xfa\xae\x1a\xf8\xf4\x60\xb8\x68\ +\x73\xe6\x7f\x2f\x85\xe7\xd8\xe2\x96\x1c\x22\xd1\x21\x1d\x3a\x9c\ +\x4b\x09\x80\xc0\x4a\x0e\x60\xe4\x91\x47\xb6\x1a\x6b\x87\x9e\xec\ +\xe4\x7b\xab\x9c\x36\x04\x77\x5d\xee\xc4\x79\x57\xe0\xce\x03\x75\ +\xb8\xd2\x9a\x14\xee\xba\xdf\x89\xba\xcd\x08\x6e\x9c\xf7\xa3\x73\ +\xd7\xe6\xf0\xdc\x67\xaa\x66\x7f\xa6\xa9\xe0\xe5\x1d\x59\x6e\x65\ +\x01\x26\x97\xf9\x17\x02\x29\x47\xe1\xca\x90\x82\xff\x40\x02\x77\ +\x9d\x1d\xc0\xe4\xbe\x07\x19\x9c\xa0\xfe\xd1\x24\xf6\x31\xdd\xac\ +\xec\xd4\x8e\xc6\x9b\x89\x77\x80\xd9\xd4\x32\xa2\x93\x63\x99\x2d\ +\x5f\xe2\x1a\x5c\xe4\xb8\x09\xf7\xbe\xa5\x70\x27\x9a\x4e\x4d\xec\ +\xe7\xc1\x7d\xa1\xa6\xda\x25\xf7\x1c\xb4\xe7\x06\xdc\x84\xfb\x92\ +\xee\x3d\x85\xc7\x8e\x02\x78\x12\xc0\x4e\xb8\x13\x71\x3b\xb5\x90\ +\x3d\x70\x0e\xa9\xfb\xdb\xd8\xf6\xe5\xc4\x54\xd5\x5c\x77\x52\xb0\ +\xce\xa6\x73\xd3\x6c\x23\xd4\xb1\xb7\x9b\x49\xb2\x17\xce\x0c\xe2\ +\x64\xa6\x56\x55\xb8\x89\xc0\xd2\x36\x8f\xd3\x07\x67\xab\x7f\x2a\ +\xdf\xff\x53\x65\xcb\xbe\x7d\xfb\xfa\x25\xa2\x58\x44\x1a\xd1\xe1\ +\x7a\x21\x03\xa5\x9a\xb5\xd6\x32\x73\x04\x27\x0a\x43\x14\x93\x5b\ +\x7a\x8c\x22\x38\xe6\xb6\x44\x34\xc9\x47\x57\x11\x1e\xef\x85\x69\ +\xec\x85\xed\x18\x7c\xbb\x19\xbf\x6d\xc6\x87\xeb\x99\x9d\x53\x4e\ +\x89\x28\xc7\x58\x6e\x91\x46\x10\x11\x94\xfe\xe0\xde\x74\xec\xf7\ +\x2f\x93\x55\x4b\x0c\xdd\x7b\x6f\x12\x01\xae\x06\x94\x59\x80\x89\ +\x68\x6d\x30\x48\x3a\xfe\x39\x85\x63\x8e\xdf\xd1\xe2\xee\x1b\x84\ +\xb6\x15\x91\x7a\x48\xe9\x25\xa2\xdc\x5a\xdb\xf0\xd1\xd1\x02\xee\ +\x9a\x17\x8b\x48\xc5\xef\xaf\x00\x90\xfb\x1a\x5e\xeb\x23\xc9\x00\ +\xc6\x1d\x91\x01\xf7\x7d\x8d\xbd\x78\x0d\xff\x93\xd6\x5f\x43\xca\ +\xb1\x4f\x15\xb6\x7e\x9c\x3d\x3b\x77\x36\xa8\x5e\xff\xd1\x74\x2c\ +\x96\x2a\x2f\xce\x0a\x4c\xde\x05\x75\x14\x2e\x1b\x64\x3f\x4e\xec\ +\x01\x91\xc1\x7d\x87\xd7\x62\x72\x59\x50\xa1\x0d\x46\xa7\x3a\x1c\ +\xac\xf5\xfb\x7c\x39\x12\xa2\xd6\x2f\x57\xb1\xde\x4a\x06\xb7\x70\ +\xdb\x0e\x02\x57\x5f\xba\x1d\x27\xf7\xcb\xe8\x87\x0b\x88\xb4\xdb\ +\xd3\x7c\x39\x5c\x2d\xf7\x99\xdc\xd1\xa2\x2d\x54\xb0\x9e\x9c\x99\ +\x8a\xb0\x1a\xb8\x94\xd4\x3d\x70\x56\xe0\x27\x4a\x73\x8e\xe0\x3e\ +\xf4\xab\x30\x79\xe1\x40\x70\xf5\x2b\x9b\x27\xb9\x9f\x97\xa2\x1f\ +\x6d\x38\x83\xc1\x4d\xf4\xbe\x87\xd3\x6f\x7b\x30\x0c\x17\x35\xbe\ +\x12\xed\xbd\x8f\x2b\x70\x66\x0b\xd6\x1c\xee\xb3\x53\xc3\x44\x0a\ +\x49\x0a\x37\x59\x98\x8b\xce\x5c\xa4\xca\x7e\x7f\x9d\xae\x5f\x9f\ +\xed\xa6\x0c\x67\x0b\x2b\xe0\xa2\x9f\xa7\x8b\x81\xab\x7b\x3f\xd5\ +\x1a\xe6\x51\xb8\xba\xf0\xa3\x68\xbf\x01\xf9\x6a\x74\x56\xb0\x6e\ +\x7e\xee\xb9\xe7\xd8\x1a\x53\x00\x10\x3a\x3a\x56\x92\x81\x52\xec\ +\xa3\x81\x39\x33\xe7\x70\x35\x98\xe3\xd7\x93\x90\x62\x6b\xad\x8d\ +\x30\x21\x1a\xbb\x7c\xfa\xef\xb8\x29\x13\x00\xb6\xd6\xc6\x3e\x5d\ +\xb8\xe1\x45\x61\x48\xa7\x65\x22\x12\xda\x3f\x1a\xcb\xc2\xaa\xb5\ +\xd6\x36\xe2\x1d\xc3\x85\x59\x52\xb5\x44\x04\x1e\x2e\x22\x59\xdd\ +\x4f\xa9\x88\x6d\x36\xb9\x99\xa6\x85\xe4\x39\xe5\xc6\x50\xea\xd3\ +\x79\x93\xe0\x36\xec\x5d\x8a\x59\x9c\x8b\x71\xe6\xeb\x47\x9b\xa1\ +\x46\xd5\x8b\xd2\x90\x8a\xdb\x10\x91\x86\x75\x4e\x52\x04\x17\x01\ +\x2e\x1b\x63\xe2\x28\x8a\xea\x7e\xdb\xdc\x47\x56\x83\xe3\x71\x19\ +\x6e\x22\xc7\x61\x9f\x3e\x65\x38\xc1\x44\x5a\x71\x21\x22\x4d\xff\ +\xbc\x85\x1c\x41\xd0\x13\x33\x87\xe3\xb1\x1f\x47\x46\x44\x39\x9c\ +\xfb\x72\xed\xa9\xa7\xb6\x30\x60\xa6\xb4\x85\x91\xf2\x92\x44\x70\ +\xbd\x46\x27\xc3\x6e\x9c\xdc\xd1\xbb\x01\x37\xa1\x7f\x1e\xae\xfc\ +\xa0\x9d\xb9\x40\x60\x83\x3f\xe6\x64\xe7\x7a\x25\x4c\xb2\xae\xee\ +\x45\x08\xfd\x90\x9b\x70\xd7\xd9\x0c\xb3\x27\xf8\xd1\xca\x0a\xb4\ +\x2f\x9c\xce\x36\x36\xa2\xbd\x39\xd1\x18\x5c\xc7\x84\x53\x2d\x59\ +\x39\x0a\x37\x9f\x3d\x0f\xee\xf5\x3f\x5d\x08\x2e\x6a\xf9\xb2\xcb\ +\x4a\x89\xe1\x1b\x9f\x77\x60\x5f\xb3\x69\x82\xd9\xc9\xb1\x4c\xb7\ +\x10\x2f\xe0\x56\x4f\xb6\xe1\xe4\x4e\xb5\x41\xd4\x1e\x80\xcb\x0f\ +\x9f\x6c\x4a\xcf\x22\x4c\xad\x60\x6d\xf7\xc2\xf0\x18\xda\xef\xd1\ +\x37\x02\xe0\x19\xb4\x57\x33\x3b\x0f\xee\x04\x36\xd5\xfd\x46\x3b\ +\x89\x81\x5b\xe4\xd8\x89\x97\xae\x49\x26\xb8\xcf\xcc\x79\x98\xbc\ +\xb9\x51\x0f\x3a\x2f\x58\x3b\x99\xc6\x3b\x1b\x27\x0a\xb3\x81\x18\ +\x6e\xe2\x77\xba\x58\x00\x0f\x63\xa2\x09\xfc\xe9\xb0\x03\x2e\x25\ +\xaa\x1d\xf7\xc5\x7e\xb8\xcf\x5a\xa7\xfa\x75\xee\x4a\x92\x64\x74\ +\xfb\x8e\xed\x3d\x4b\x69\x6d\x44\x23\x79\x61\xe7\x57\x86\xe0\x3e\ +\x7b\xa9\xaf\x35\xad\xc2\xb7\x70\x81\x9b\x70\xe7\xe2\x9c\x75\x1b\ +\x70\xd1\xd6\x10\x61\x4d\xad\xb5\xc1\x5c\x29\xb8\xe2\x06\x9b\xe0\ +\xd4\x3f\xce\xc0\xd5\x77\xc6\x00\x32\xde\x5f\xe3\x62\x4d\x7f\x0d\ +\x40\xce\x87\xc7\xc4\xae\x1f\x30\xb2\x67\x28\x91\x9e\x14\xd6\xda\ +\xc8\x8b\xcb\x22\xcb\x28\x1f\x19\x61\x13\x91\x50\xde\xb4\x11\x00\ +\x58\x6b\x0b\x38\x01\x0a\x6b\x6d\xe2\xdb\xd0\xa4\x3e\xfa\x9b\x7b\ +\x37\x62\x62\xe6\xdc\x0b\xc9\x20\x30\x01\x27\xc2\xc9\x47\x4b\x99\ +\x99\x2b\x22\x52\x0e\x86\x48\x98\x10\x97\x11\x26\x04\x48\xea\x6f\ +\xd6\xd7\xf6\x8e\x89\x48\xee\xc5\x6a\x48\x75\x16\xbf\x4d\x04\x9f\ +\x05\xc4\xcc\xe1\xb8\xb9\x38\x07\xe3\x61\x11\x29\x8c\x31\x51\x02\ +\x74\x1d\x3a\x74\xa8\x7b\x78\xf8\x18\xe0\xce\xf1\xca\xcc\xb0\x14\ +\x93\xeb\x81\xbe\x0b\xee\xfd\x3b\xd5\x14\x5d\x83\x09\x53\xc3\x76\ +\x45\x6b\x09\xae\x47\xea\xae\x36\xb7\x0f\xac\x43\xe7\x82\x12\x07\ +\xe0\x16\xf0\x0e\xe1\xc4\x51\xb6\x14\xee\xdc\xd7\x07\x97\x7a\x3a\ +\xd3\x42\x31\xc6\xe4\x17\x2a\x8e\xa7\x09\x27\xdc\x9a\x98\xf0\x16\ +\xc9\xe0\xde\xaf\x0a\x66\x6f\x24\xb7\x17\x2e\x60\x73\xba\x34\x00\ +\x7c\x17\xa7\xdf\x85\x40\x00\x3c\x01\xf7\x79\x68\xe7\x73\xb0\x14\ +\x6e\xae\xfe\xb2\x2a\x77\x0a\x6e\x86\x9d\x98\xd0\xcd\xa6\x49\x61\ +\x27\xc7\x32\xdd\x1f\x88\x1f\xa0\x3d\xb3\x9f\x7d\x70\xab\x3c\xaf\ +\x46\xfb\x82\xbd\x0a\xf7\x05\x1a\x69\x73\xfb\x97\xa2\x0b\x2e\xc5\ +\xf6\x74\x39\x82\xc9\x3b\xd1\xee\x44\x7b\x17\x26\x82\x13\xad\xd3\ +\xdd\xb4\xbc\x1d\x2c\x9c\x18\x78\x06\xa7\x56\x90\x2f\x70\xd1\xaa\ +\x41\xb8\x08\xf4\x64\x26\x2c\x53\xe1\xa4\xad\x75\xe8\x53\xcf\x72\ +\xb4\x37\x81\x78\x0e\xed\x89\xd5\xc0\x16\xb8\x0b\x6e\x3b\xc7\x5e\ +\x88\xce\x09\x56\x11\x91\x7b\x9e\xf8\xd1\x8f\xae\x5b\x8a\x6b\x62\ +\x1a\x2b\x32\xe9\x4e\x5d\x8a\xae\xfb\x0e\xd5\xfc\x63\x22\x00\x89\ +\x8f\xa4\x46\x3e\x8a\x5a\xc0\x09\x3f\x88\x48\x14\x52\x88\xbd\x68\ +\xcb\xe1\x16\x1b\xad\x8f\xc8\x86\x1a\xcf\x70\x5d\x72\xf5\xa5\x63\ +\x85\x95\x52\x04\x02\x22\x19\x6e\x44\xb6\x2b\xc9\xbb\x7e\xff\x81\ +\xea\xd8\x6f\xbc\x2a\xb8\xee\x16\x17\x5c\x60\x8a\x07\x1e\x88\x79\ +\xd9\xb2\xc2\x2e\xec\x1a\xe3\x23\xa3\x25\xea\xf7\x4e\xbf\x7e\xff\ +\x88\xa2\x28\xb8\xf8\x5a\x5f\x7f\x4b\xe4\x7a\xc4\x16\xe4\xda\xf3\ +\x58\x2f\xb2\xd3\x16\x77\xe0\xf0\xbc\x42\xdd\x6a\xe2\x85\x2b\x5a\ +\xc6\x69\xbd\xc8\x6e\xfa\x7d\x86\xf6\x3c\x6c\xad\x0d\x42\x3d\x86\ +\xeb\x33\xcb\x3e\xea\x9a\xfa\xfb\x8c\x17\xf5\x63\xbe\xc6\x57\xfc\ +\x63\x52\x22\xea\x66\xe6\x04\x11\xd3\xb7\xbf\xfd\x6d\x93\x24\xdd\ +\x5b\x1a\x8d\x8e\xbd\xa7\xca\xe9\xb3\x72\x12\xdb\x8e\xc1\x4d\xbc\ +\x4f\xb7\x9e\x54\xe0\x4a\x7c\xe6\xa0\xfd\xeb\xc7\x2a\x4c\x4e\xb0\ +\xa6\x68\xbf\x44\xa1\x95\x41\xb8\x68\xd7\xc9\x4c\x2b\x9b\x70\xf3\ +\x99\x23\x70\x01\x89\x37\x62\x66\x05\xdc\x2a\x4c\xee\xba\x1f\x08\ +\x73\x8f\x5d\x70\xe7\xe6\x97\xfa\x2c\x54\xe0\xe6\x81\x93\x4d\x0b\ +\xef\x34\x6b\xda\xdc\xee\x49\xb4\xdf\x32\x2f\x88\xd6\x9f\x6e\x63\ +\xdb\x04\xee\xbb\xf3\xb2\x32\x06\x65\x74\x6e\x62\x18\x56\x65\x67\ +\x03\x67\x72\xfd\xdb\x64\x8c\x04\x0e\xc2\x89\xb3\xc9\x30\x58\x3d\ +\x4c\x16\x00\x00\x20\x00\x49\x44\x41\x54\x15\xcd\xa2\x01\x77\x61\ +\x68\x47\x48\x4f\x76\x05\x15\x70\x17\x8a\x76\x1d\x90\x67\x7a\x15\ +\xf4\x54\x79\x02\xee\xe4\x79\xba\xee\x71\x63\x98\x7c\x6a\xc9\x54\ +\x38\x69\x77\xf2\x7b\x97\x61\x76\x65\x80\xcc\x06\x42\x5a\xd1\xe9\ +\x62\x30\xf9\x16\x33\x05\xda\xff\x5e\xb7\xb3\xe8\xf5\xa2\x34\x9b\ +\xcd\xaf\x3f\xfe\xe8\x63\x75\x11\x39\x88\xa1\xe6\xa8\x54\x92\x5c\ +\x44\x12\x11\xe9\x02\xd0\x2b\x22\x7d\x22\x52\x85\xeb\x4f\x2a\x5e\ +\xf0\x91\x17\x7f\x55\x00\x55\x9f\x8a\xcb\x44\xd4\xb4\xd6\xd6\x00\ +\x8c\x10\xd1\x28\x80\x51\x6b\xed\x28\xdc\x02\xe0\x08\x11\xd5\xbd\ +\x7b\xae\x33\x1d\x22\x10\xdc\x04\xae\x87\x0a\x5b\x41\x39\xee\xa2\ +\x83\xf5\xd8\x9c\x3f\x37\xa4\x12\xf3\xb2\x65\x36\x6e\x34\x28\x3d\ +\x7a\x94\xb2\x0d\x2b\x0b\xde\x73\x30\x65\x11\x11\x6b\x2d\x07\x57\ +\x5f\xff\x3b\x7b\x33\x25\xf6\x91\xe1\xc4\x1b\x30\x25\x44\x14\x31\ +\xb3\x81\x4b\x53\x2e\xfb\x71\xf7\xc0\xb9\xc2\x56\xbd\xd0\x1c\xaf\ +\x47\xf5\x42\x73\x84\x88\x8e\x01\x18\x12\x91\x61\x00\x23\x22\x32\ +\x02\xdf\xe3\x9c\x88\x4a\x7e\xfb\x5e\x11\xe9\x17\x91\x5e\xb8\x54\ +\x5f\x23\x22\xa3\x70\x42\xd5\xc2\xa5\x2f\xf7\x30\xf3\x1c\xb8\x32\ +\x84\x1e\x00\x31\x1d\xaa\xe5\x45\x77\x32\x7c\xd7\x5d\xdf\x3d\xc6\ +\x3c\xf6\xad\x4e\xbe\xa7\xca\x69\xd1\xed\x6f\xed\xf2\x14\xda\xef\ +\x59\x5e\x60\x72\x19\x5d\xbd\x98\x5c\xaf\xee\xa5\x98\xfc\x5c\x71\ +\x1f\x5c\x84\x6d\xba\x3a\x2c\x74\x0a\x42\x7b\xe9\xa8\xc7\x73\x10\ +\xc0\xb7\xe0\xe6\x10\xc7\x70\xf2\xf9\x6b\x0d\x2e\x2d\xbc\xa3\x8e\ +\xef\x93\xa4\x04\x97\x5d\x78\xba\x0c\x61\xf2\xc1\x8c\x61\xb4\xff\ +\xd9\xe9\xe8\xb5\xf0\x4c\x80\xd1\xd9\x89\x61\x27\x56\x6b\x3a\x41\ +\x27\x7b\xcb\x9e\x69\x21\xf7\x2d\x98\xdc\x7b\xda\xdf\xa9\x81\x1c\ +\x47\x3b\x27\x04\xa0\x73\x35\xa4\x47\xda\xdc\xae\x9d\xfa\xbe\x99\ +\x60\x32\xef\xf9\x5e\x4c\x2e\xed\x79\x2a\x56\x89\x05\xed\x4f\x84\ +\x8e\x87\x30\x7b\xce\x4d\xb3\x85\x7e\xb4\x37\xd9\x3b\x88\xce\xa4\ +\xc8\xb7\x1b\xa1\xed\x45\x67\x17\x24\xbf\xf9\xb5\xe7\x1f\xad\xe6\ +\x79\x3e\x97\xac\x8d\x28\xa6\x63\x22\x72\x80\x99\x8f\x88\x48\xdd\ +\xd7\x5f\x86\x9a\xce\x50\xe3\x19\x22\x87\x35\x11\x19\x23\xa2\x26\ +\x5c\x7a\x70\x46\x44\x65\x11\x29\x05\xd1\x18\x45\x51\xe2\x53\x75\ +\x4b\x00\x32\x66\x16\xbf\xed\x28\x19\x19\x83\x13\xb3\x35\x72\xae\ +\xbc\xec\x45\x2c\xfc\x73\x2c\x03\xe8\x9a\x37\x4f\xb2\x83\x07\xb9\ +\x5c\x2a\x21\x6b\xe4\xae\xdd\x93\xaf\x4b\x2d\x11\x51\xe2\xeb\x68\ +\x53\x84\xde\xae\x4e\xa8\x56\x00\x74\x89\x48\xb7\x88\x54\x82\x28\ +\x25\xa2\xc8\x5a\x1b\x5a\xe9\xe4\x70\x13\xc8\x51\x7f\xab\x03\x80\ +\x17\xec\x31\x5c\x6d\xec\x78\x5b\x1e\xff\x93\x82\x81\x93\xff\x3b\ +\xd4\xed\x5a\xff\xbf\x84\x88\x2a\x22\x52\x0d\x82\xde\x3f\x7f\x11\ +\x91\x51\x22\x3a\x62\xad\x3d\x1c\x6f\x39\x9a\xe3\xbc\xf9\xe5\xef\ +\x7f\x7f\x67\xf7\xd8\xd8\x8f\xee\xec\xe0\xfb\xa9\x9c\x1e\x93\x69\ +\x35\xd1\xc4\xe4\xb3\x9f\xf6\x60\x72\xe7\x93\xc9\x8c\xbf\xdd\x39\ +\x49\xe0\x08\x80\x47\x70\xe6\xcd\x11\x01\x27\x76\x26\x1b\xe1\xdc\ +\x0d\x57\x1a\x32\x36\xf9\xe1\xcc\x28\x8b\xd1\xde\x82\x76\xa7\x32\ +\xef\xda\xed\xab\x3a\x55\x73\xf5\xe9\xc2\xc2\x5d\x77\x0e\xc3\xcd\ +\x07\xf6\xfa\xdb\x21\x38\x11\x3f\x84\xe3\x02\x30\x31\xdc\x45\x6a\ +\x32\xab\x54\xad\x64\xe8\x7c\x2d\x5b\x3b\x74\x52\xb0\xce\x86\xe7\ +\x73\x3a\x34\xe1\xde\xf0\x76\x57\x5f\x26\xb3\xda\xfa\x62\x54\xfd\ +\xed\x74\x09\x75\x63\x9d\xa0\xdd\x93\xea\x54\xbc\x1e\xb3\x0d\x0b\ +\x77\x82\x68\xf7\x33\x33\x55\x69\x4d\x63\xe8\xdc\xeb\x5f\xc1\xec\ +\xe9\x13\x3d\x1b\x68\x77\xb2\xd6\xa9\xa6\xe5\x27\x73\x15\x7e\x31\ +\x08\xee\x33\xd1\xee\xf6\xc7\xf3\xf4\xe3\x66\xef\x81\x07\x1f\x7c\ +\x70\xce\xd5\xe9\xf2\x4c\x8c\x94\x28\x66\x03\xa0\xc6\xcc\x23\xd6\ +\x5a\xf1\x26\x43\x25\x4c\xa4\xf5\x36\xbd\x21\x51\x11\x5c\x73\x01\ +\x44\x5e\xe4\x85\x5a\xcf\x32\xbc\x3b\x2e\x4d\xb4\xc5\x69\x7a\xa3\ +\xa4\x26\x33\x1b\x08\x52\xbf\x8f\x18\xa0\x18\x45\xc1\x14\x45\xc2\ +\xcc\xb9\x31\xc6\xc2\x3b\x0a\xaf\x58\x61\xd2\x47\x1e\x49\x20\x29\ +\x53\x54\x14\xe1\x35\x78\xc1\x02\x8c\x37\x63\x0a\x30\xdc\xc1\x83\ +\xab\x6f\xde\x92\x26\x1c\x33\xb3\x18\x63\x0a\x5f\xf7\x3a\x6e\x2a\ +\xe5\x53\x84\x0b\xb8\x48\x69\xe6\x45\x70\xe8\x3f\x1b\xf9\x08\xac\ +\x11\x91\x26\x11\x35\x82\x6b\x30\xfe\xff\xf6\xce\x3c\xca\x8e\xab\ +\xbe\xf3\xdf\xdf\xad\xaa\xb7\xf5\xa2\x96\xd4\x52\x4b\x72\xdb\xd6\ +\x62\x59\x1b\x41\x10\x03\x76\xec\x04\x1b\x27\x38\x0b\xc4\x84\xcc\ +\x81\x90\x21\x24\x61\x8b\x27\x73\x72\x32\x59\x0e\xc3\x38\x86\xcc\ +\x4c\x42\x4e\x26\x93\xd8\x33\x24\x8c\xb3\x10\x06\x8e\x49\xc0\xc0\ +\x38\x86\x43\x4e\x40\x24\x0e\xb6\x81\xd8\x96\x8d\x91\x85\x56\x6b\ +\x69\x59\x96\x5b\x4b\xab\xf7\xa7\x7e\x4b\x55\xdd\xdf\xfc\xf1\xbb\ +\xb7\xfb\x59\x48\x72\xf7\xab\x7a\x5b\xf7\xfd\x9c\xf3\xdc\x6a\xf7\ +\xab\xaa\x5b\xdb\xbd\xf7\x7b\x7f\x9b\x24\x64\x52\xe6\x3b\x59\x88\ +\x55\x97\x99\xb9\xaa\x94\x2a\x6b\xad\xad\x4b\x70\xc6\x58\xae\x33\ +\x34\x56\xd6\xc7\x27\x4f\xf3\xc8\xc8\x08\x43\x4a\x94\x38\x5a\x43\ +\x12\x0f\xa2\x53\x48\x6e\xf0\xd0\x90\x49\xea\x35\x75\x6e\xbf\x12\ +\xe2\x5e\xbb\x50\xb2\x48\x96\x19\x38\x82\x24\x9d\xeb\xd4\xb2\x77\ +\x49\xc5\xfa\x24\x5e\x39\xc9\x56\xa7\x50\xef\xa2\x47\xab\xc7\xc2\ +\x1e\xa4\x6f\x74\x6c\x24\x45\x88\x0b\xf3\x38\xe4\x9c\xe7\x3b\x27\ +\xf7\x21\xef\x6a\xe0\x2f\x60\xa3\xf9\x90\x43\x7b\x98\xfa\xd3\xf4\ +\x8d\xef\x34\xc1\x0a\xc8\xaa\x67\xbd\xe2\x23\x8d\x5a\x69\x17\x53\ +\xef\xc0\x90\xe6\x62\x4a\xbd\x2e\xa1\x1e\x64\x72\xd8\x49\x85\x9a\ +\xeb\xa1\x88\xfa\x9f\x99\x46\x85\x02\x94\x91\x9e\x60\xed\x45\xe7\ +\xb9\x6d\x35\x92\xfe\x3a\xb7\x4b\x2b\xbe\xbd\x82\xfa\x13\xfe\x75\ +\x23\x3d\xc1\x0a\xdf\xf7\x1f\x7a\xf0\xc1\x07\x7f\xe5\xf6\xb7\x7d\ +\xa8\x82\x48\x2b\xf8\x2a\xab\xb5\xee\x01\xd0\x63\xac\x87\x21\x33\ +\x47\x4a\xa9\x19\xd3\xde\x0c\x33\xf7\x02\x80\xf9\x5b\x0c\x88\xc9\ +\xd1\x88\x36\xc2\xcb\xc5\xaa\x2d\x29\xa3\x4c\x1c\xa7\x4f\x44\x4a\ +\x83\x6d\xd9\x9c\x80\xb3\x5e\x90\x7d\x78\x88\xc3\xd7\xac\x8a\xb4\ +\xd6\x65\xeb\x7a\x2c\xed\x63\xae\x56\x11\xa0\x37\x4b\x7e\x29\x24\ +\xcc\xc5\xc8\xc6\x4a\xa9\xc0\xb8\x01\x47\x4a\x29\x4f\x6b\x9d\x51\ +\x4a\x69\xad\x75\x15\x62\x0d\xb6\x59\x7c\xbd\xd9\x63\x89\x25\x38\ +\xa3\xb5\x66\x23\x2c\x61\xda\x6f\xcb\xce\xc4\xa6\x9d\x36\x36\x15\ +\x90\x49\x51\x68\x04\xae\xcd\x16\x6c\xeb\xb1\x06\x00\xb2\x2c\x59\ +\x81\xab\x44\x34\x45\x35\x59\x8a\x01\xf4\x1a\xab\x2f\x66\x2d\xd5\ +\xcc\xfa\xef\xff\xfe\xe1\xb0\x50\xc8\x3d\x53\x2c\x76\xbc\x85\xa6\ +\x93\x49\xe2\x41\x94\x56\xfd\xed\x73\xa8\x5f\xb0\xd6\x3b\xb7\xe8\ +\x43\xb2\x30\x91\x21\x74\xb6\x65\x31\x49\x55\x09\x8d\xce\x16\xeb\ +\xb5\x78\xa8\xdf\x52\x99\x56\x59\x99\x7a\x17\xd2\x15\x64\x7e\xdc\ +\x88\x9c\x33\x69\x72\x0e\xe2\x32\x5e\xef\xf5\x8a\x60\x3c\xb2\xd2\ +\x16\xac\xdd\x68\x8f\x32\x20\x69\x5a\xc5\xea\x0d\xa8\x6e\x25\x49\ +\x12\x58\xd8\x09\x48\x9a\x99\x71\xeb\xed\x10\x7a\x01\xdc\x9e\x62\ +\x3b\xea\x25\x87\xc5\x2f\x58\xdb\xb1\xa6\x57\x9a\xef\x5e\xa7\xb8\ +\x76\x37\x03\x1f\xf5\x2f\x4c\xad\x40\x7d\xde\x12\x97\x22\x46\x7d\ +\xf1\xcf\xa9\x26\xeb\xa8\x54\x2a\x9f\xfe\xca\x57\xbe\xf2\xc1\x4f\ +\xfc\xdc\xef\x04\x5e\xcc\x61\x2c\x31\x9b\x31\xc4\x52\x98\x83\x58\ +\x63\xb2\xc6\xed\x95\x21\x35\x57\xb5\xd6\xda\x96\x86\xc9\x98\xff\ +\xaf\x8d\xd5\xb1\x02\x49\x3a\x14\x93\x94\xc8\x51\x30\x25\x70\x00\ +\xe4\x4d\x62\x24\x8d\x9e\x0c\x7b\x15\x4d\x9c\xf7\x89\x7b\xb3\x3a\ +\x78\xe8\x79\x9e\xf9\x9d\xd7\x57\x20\x56\x57\x9b\x0c\x91\x56\xae\ +\x64\x2e\x97\x59\x95\xcb\xac\x88\xa1\x99\x11\x02\x92\xa1\x37\x8e\ +\x63\x1b\x77\x5a\x8d\xe3\x38\x30\xa2\xd5\x23\x22\xd2\x5a\xc3\xc4\ +\xae\x6a\x23\x14\x61\x45\x2a\x24\x26\x37\x47\x92\xd5\x58\x1b\xe1\ +\x6a\x13\x47\xa1\x26\xf1\x14\x9b\xdf\x3d\x23\x60\x6d\xc6\x4f\x0b\ +\xd9\x73\x37\xc7\xf1\x88\xa8\x9b\xe7\xea\xbe\x12\x11\x69\x22\xaa\ +\x1a\x71\xaf\xbd\xc9\x6a\x96\x57\xe4\x33\x9f\xfb\xdc\x13\x71\xb1\ +\xf8\xf4\xff\x4a\xf3\x5e\x3a\x16\x44\xd2\xac\xad\x69\x25\xca\x9a\ +\x4e\xb0\xad\x7d\x1e\x17\x6a\x58\x48\x62\x5d\x65\x24\xcf\x15\xd2\ +\x4a\x0a\x48\xe6\x85\x38\x8c\xf6\x17\x49\xf3\xa5\xde\x85\x8b\x18\ +\xe2\x4a\x9c\x06\x49\xc2\x95\xf2\x68\xff\x7b\x31\x85\x94\xe6\x97\ +\x69\x0b\xd6\x76\x71\x9f\x4c\xb3\x1d\x9d\xb8\x8a\x96\xf4\x01\xce\ +\x22\x5d\xc1\x9a\xd6\x04\xb7\x55\x34\x22\xa9\x50\xbb\x91\x56\xbc\ +\x68\x9a\xa4\x29\x58\x3b\x25\x79\x56\x33\xe8\x45\xfd\xd6\x85\x7a\ +\xca\xe0\xa4\x4d\xda\xd9\x25\xbf\x0b\xe0\x85\xef\xec\x79\x7a\xfd\ +\x1b\x77\xae\xf5\xa9\x2b\xb0\x8b\x1b\x25\x66\x9e\x36\x62\x2e\xab\ +\x94\xca\x1b\x51\x57\x36\x16\x4c\x6d\xc4\x9f\x67\xdc\x67\xb3\x46\ +\x94\x32\x6a\xdc\x85\x8d\x58\x64\x18\xab\x2b\x44\x14\x2a\xee\xcb\ +\x01\xe3\x65\x20\xdf\xcd\x7a\x5d\x37\xab\x97\xa6\x95\xde\xdc\x47\ +\x00\xfc\x1a\x8b\x28\xf5\xf7\x2b\xbf\xab\x8b\xd4\xd0\x90\xc2\xf2\ +\xe5\x5a\x9f\x3a\xa5\xf8\x9a\x6b\x78\x36\x6e\xce\x08\x60\x18\xf7\ +\xdc\xd8\xb4\x27\x80\xc9\x22\x0c\x73\xaf\xcd\x77\xac\xc0\x8c\x21\ +\x31\xa7\x7e\xcd\xdf\x34\x24\x23\x70\xc8\x92\x05\x39\x86\x08\x51\ +\x32\x56\xdc\xd9\x44\x4e\x66\x9b\xd0\x58\x63\xad\xe0\x55\xe6\xfa\ +\x64\xcc\x79\xcf\x00\x28\x9b\xeb\x90\x85\x8c\x03\xa4\xbe\xf3\x22\ +\xef\x5e\x31\xae\xcf\x9f\x1f\x8b\x01\x7c\x2d\xe5\x7b\xe9\x98\x3f\ +\x49\xbc\x97\xaa\x48\x6f\x6e\x34\x03\x19\x7f\xea\x1d\x67\xf3\x58\ +\xb8\x60\x4d\x32\x27\x19\x47\x67\xce\x0b\x2d\x49\x17\x6f\x5f\x48\ +\xa5\x15\xed\x41\xbd\xd7\xc2\x83\xd4\x12\x6e\x35\x69\x86\x3f\xb6\ +\x3d\x0a\xe9\xad\x92\x01\xed\x11\x04\xec\x41\x26\x64\x69\xd1\x89\ +\xe9\xf6\x23\x24\xb3\x08\xa6\x9d\xa0\x26\x9f\xf2\xfe\x9a\xcd\x52\ +\x28\x8b\xd2\x8e\x82\x35\x35\xb7\x4f\xd4\x1f\x47\xbd\x18\x49\xcb\ +\xcd\xbe\x55\xa4\xfe\x3e\x56\x2a\x95\xff\xfb\xd0\x63\x5f\x23\x1a\ +\x2d\x97\x89\x68\x82\x99\xcb\x10\x61\xbc\x12\xc0\x0a\xa5\x54\xd6\ +\x24\x29\x2a\x43\x04\xdb\x32\x00\x3d\x5a\xeb\x9c\x89\x0f\xb5\x09\ +\x8c\x2a\xa6\x7d\x3d\xcc\xdc\x07\x60\x19\x11\xd9\x8c\xbc\x79\x22\ +\xf2\xad\x30\xd4\x83\xdd\x15\xf5\xe2\x54\x08\x20\xe2\x75\xdd\x0a\ +\x11\x2b\xcc\x3d\xa7\x05\xa5\x54\x4e\x29\x95\x63\xe6\x4c\x57\x17\ +\xd3\x85\x0b\x2a\xf6\x7d\x70\xa9\x44\xc4\x92\x21\xd8\xba\x14\x03\ +\x92\x20\x49\xd5\x08\x4f\xa5\x94\xca\xc0\x58\xa0\x98\x39\x4f\x44\ +\x79\x48\x5f\x5c\x80\xf4\xf1\x04\xb1\x04\x5b\x71\x0a\x23\x74\x73\ +\xcc\x5c\x30\xdf\xeb\x26\xa2\x6e\x88\x5b\x6f\xb7\x71\x11\x9e\x21\ +\xa2\x49\x22\x2a\x2a\xa5\x4a\xc6\x25\x3a\x60\xe6\x82\x89\x65\x2d\ +\x12\x91\xb5\x52\xf7\x30\x73\x3f\xc4\xbd\x1a\x00\x2a\xaa\x1c\x47\ +\x9f\xfa\xbb\xaf\x73\x10\xcc\x7c\x19\x2e\xae\xbc\x95\x24\x19\x97\ +\xd3\x0c\x95\x62\x24\x13\x80\xf5\x9c\x47\x92\x73\xef\xf4\xd0\x92\ +\x24\xfd\x7f\x88\xce\x3f\xff\x5a\xdc\x58\xd8\x41\xf8\x98\xab\x9b\ +\x94\x46\xd9\x87\x2e\x48\x47\xd0\xca\xd5\xa7\xe5\x48\xaf\x84\xc5\ +\x05\xa4\x6b\x69\x6c\x26\x11\xea\x17\x9e\x69\xc7\x24\x76\xfa\x2a\ +\x50\xbb\x94\x6b\x6a\x24\xed\xf8\x9c\xdb\x34\xf9\x69\xbd\xcf\x6b\ +\xb1\xf0\x92\x2c\x15\x00\xff\x58\xe7\xf1\xde\x5a\xe7\x76\x8d\xa6\ +\xd3\x07\xe9\xd4\xdf\x47\xad\xf5\x03\xff\xb4\xfb\xd1\xff\xfe\x91\ +\x83\x43\xb9\xfe\xed\x2b\xf3\x00\x4a\x26\xa3\xad\x8f\x39\xd7\x49\ +\x22\xa2\xd0\x08\x57\x6d\xdc\x64\x0b\x98\xab\x81\x6a\xe3\x56\xb5\ +\x75\x05\x36\x96\x52\x5b\xeb\xd4\xd6\x6e\x8d\x01\x68\x5e\xdd\x05\ +\x7a\x6a\x38\xd0\x5a\x6b\x52\xe4\x21\x8a\x0b\x36\xde\x14\x22\x00\ +\x67\xdb\xd7\xd7\xc7\xac\x14\x30\x31\x4d\x9e\xd2\x1a\xc6\x3d\xd7\ +\x26\x43\x22\x96\xfa\xa6\x04\x11\xae\x0c\xcc\x26\x51\xb2\xb5\x56\ +\xad\x15\x35\x86\x24\x7f\x8a\x6d\x3b\x30\x57\xbf\x55\x41\xe2\x6c\ +\x7d\xb3\x5d\xa6\x46\x10\x5b\x97\x67\xa5\x94\xb2\x09\xa8\x6c\xcd\ +\x57\x32\x16\x55\x6d\x8e\x9f\x37\x2e\xc9\x9e\x71\x8b\xbe\x60\x92\ +\x34\x65\xfc\xfd\xa3\x5d\x13\x1b\xf2\xfc\xd0\x43\x8f\x46\xd5\xea\ +\xe1\x8f\xa7\x7d\x1f\x1d\x0b\x22\xc9\xc2\x74\xda\x0b\x9c\x49\x32\ +\xed\xd6\x73\x1e\x49\xe6\x24\xed\x90\xa7\x25\x09\x4b\x59\xac\x5f\ +\x8c\x33\xa6\x74\x10\xb6\x0e\x6b\x92\x18\x82\x8b\x69\x75\x6d\xa0\ +\x81\x14\xf7\x95\xa6\x85\xa7\xd9\x24\x19\x50\xd2\x7e\x09\x96\xd4\ +\x4b\xd5\xa1\xb4\x63\x6a\xfe\x08\xe9\xc6\x67\x5c\x03\x57\x8f\x15\ +\xe8\xfc\x12\x3f\x8d\x58\x40\x1a\xae\xe6\xf1\xff\xbe\xfa\x99\x2f\ +\x96\xb5\xd6\x25\x88\x95\xb1\xdf\x58\x47\x6d\x6d\x52\x68\xad\x0b\ +\x2c\x35\x57\x67\x98\x79\x92\x88\x26\x20\x2e\xc2\xca\xc4\x6d\x56\ +\x58\xca\xdd\x4c\x33\xf3\x94\xb1\x34\x96\x4c\x42\xa6\x9c\x89\x89\ +\xcd\x10\x51\xa0\xb5\x0e\x08\x22\x0e\x45\x5c\x12\xb4\xd6\x1e\xe6\ +\x9e\x51\x36\x1f\x9d\xcb\x31\x29\x05\xef\xf4\xe0\x5a\xd5\x7d\xf0\ +\x6c\x50\x13\x4b\x1a\x40\x5c\x8c\xb3\x90\xfb\x6a\xc5\xe6\xc5\x30\ +\x33\xc7\xcc\x1c\xd7\x64\xf7\x65\x00\xac\xb5\xb6\xc7\xb2\x5f\xb4\ +\x31\xb7\x20\xc9\x86\x5c\x84\xcc\x11\x8a\x00\x2e\x30\x73\xd5\x7c\ +\x8f\x00\x84\x44\x34\x05\x99\xc4\x4f\x19\x31\xef\x19\x57\xe1\x29\ +\x73\x2d\x33\xcc\xbc\x02\x40\xb7\xf7\xfc\x18\xff\xef\xaf\x7f\xb1\ +\x1a\x04\xd9\x43\x90\x92\x18\x8e\xd6\x91\xe4\x3d\x4a\x5b\xb0\x36\ +\x7b\xbe\x92\x64\x4e\xd2\xe9\x5e\x01\xed\x10\xb7\xdc\x2e\x74\xfa\ +\x58\xb8\xa4\xe6\x33\xb6\xc3\x4a\x73\xd5\x64\x30\xc5\x7d\x2d\x14\ +\x42\x7a\x81\xd0\x40\x67\xaf\x26\xb5\x4b\xaa\x6b\xc2\xd2\xb0\x50\ +\x76\x3a\xed\xe8\x12\x0c\xd4\x5f\xaf\xf3\x52\x14\xd0\xfa\x05\xb5\ +\x76\xc0\xbd\x8f\x97\x60\xaa\x58\xfc\xfd\xdf\xdb\xfd\x40\x76\x78\ +\x78\x38\x07\xf1\x12\x9a\x30\xae\xbe\x81\xd6\x9a\x98\x39\xf2\x3c\ +\x2f\x24\x29\xcf\xd2\x47\x44\x7d\x10\x57\x57\x5f\x29\x15\x1b\x97\ +\xd7\x2e\x48\x48\x4a\x0f\x11\x15\x88\x28\xab\x94\xf2\x20\xfd\x71\ +\x8c\xb9\xfa\xaa\x5d\x44\xd4\x45\x44\x59\xfb\x3d\x80\x60\xea\xb4\ +\xc6\x24\xb5\x5d\x2b\x26\x56\xb6\x32\x30\xc0\x95\x73\xe7\x54\x18\ +\xf6\x77\x85\xea\x4c\x31\x8a\x63\x44\x90\x77\xd6\x96\xd5\x89\xcc\ +\x76\xa1\xfd\xd8\xff\x67\x93\x2a\x19\x77\xdd\x40\x29\x65\x13\x2e\ +\xe5\xcd\xb1\xbb\x58\xca\xcd\x58\x77\x64\x8f\x88\xaa\x5a\xeb\x8a\ +\x71\x17\x86\x69\x77\x46\x29\x55\x80\x08\xe5\x98\x99\xcb\xcc\x1c\ +\x69\xad\x33\x90\x9a\xaf\x7d\x26\xc6\x55\x9b\xef\x17\x94\x52\x5d\ +\xcc\xac\xb4\xd6\x53\xea\xf0\xd8\xf4\xcc\xda\x2c\xff\xf5\x5f\x3f\ +\x1e\x5c\xb8\xf0\xe4\x6f\x37\xf4\x66\x3a\xe6\x43\x12\xd1\xb6\x94\ +\x05\x6b\x3b\x7a\x23\x2d\x84\xa5\x7c\xee\x17\xe3\x8c\x29\x1d\x84\ +\x9d\xb8\xa4\x99\xd9\x77\x39\x1a\x53\x1a\x65\x3e\x0c\x20\x5d\xf7\ +\xd3\x73\x29\xee\xab\xd9\x24\x49\x14\xd4\xae\xe2\xc5\xd1\x38\xda\ +\x65\x81\xe3\x62\x92\x16\xa6\xbf\x98\xad\x58\x62\xab\x92\x97\xc0\ +\x0d\xd2\x97\xe6\x98\x06\xff\xc3\x7d\xf7\xdd\x37\x6d\x84\x5c\xaf\ +\x29\x41\x13\x9a\xd8\xd3\x5c\x1c\xc7\x21\x80\x49\x22\x9a\x34\x2e\ +\xbe\x0a\x22\x1a\xcb\xc6\xb2\x3a\x03\xc0\xba\xf5\xfa\xcc\x4c\x5a\ +\x6b\x36\x71\x9e\xa1\x11\xa2\x21\xe6\x92\x19\x01\x9a\x63\x66\xae\ +\xb2\x0f\xc6\x58\xa9\x42\x44\x25\xad\x75\x05\x40\x55\x29\x55\x61\ +\xe6\xc8\xf7\x39\xac\x56\x11\x0d\x0e\xea\x2a\x47\xac\x87\x8e\xa3\ +\x0a\x89\x23\x8c\x48\x4a\xef\x54\x20\x96\xde\x90\x99\xab\xc6\x0a\ +\x5a\x81\x24\x3d\x2a\x99\xf6\x95\xcd\x7e\x43\xd3\x66\x82\x3c\x0b\ +\x01\x64\xbc\x20\xaa\xa9\xc9\x4a\x52\xfa\xa6\x00\xa0\x40\x44\x05\ +\x88\xd5\x99\x8c\x95\x96\x95\x52\x8a\x88\x02\x92\x9a\xad\x04\xb1\ +\xbe\x4e\x43\x92\x55\xd9\x2c\xc1\x25\x22\x8a\x95\x52\x3d\xfe\xde\ +\x91\xde\x3f\x7f\xe2\x9f\xe2\x52\x69\xfa\x20\x80\x6f\x36\xe3\x86\ +\x3a\xae\x48\x92\x3e\x3f\xed\x3e\x34\xc9\xfe\x9a\x3d\x76\xb5\xa3\ +\x37\xd2\x42\x70\x82\x75\x0e\x37\x16\x76\x10\x56\xb0\x9e\x47\xba\ +\x22\x65\x53\x8a\xfb\x5a\x08\x1b\x53\xdc\xd7\x14\x3a\xb3\xa4\x8d\ +\x25\x89\x60\x4d\xb3\x43\xb6\x25\x0f\x1c\x8e\x7a\x18\x43\xba\x25\ +\x85\x7a\x50\x7f\xcd\xbf\xc5\xc2\x62\xa8\x9f\xd7\x10\xc2\x30\xfc\ +\x83\xcf\x7d\xee\x73\x85\x53\xa7\x4e\x59\xc1\xa7\x20\xd7\xeb\x02\ +\x33\x97\x8d\x4b\xef\x32\x66\xee\x26\x22\x0f\x22\xfc\x02\x22\xea\ +\x02\x90\xb3\x89\x85\x98\xb9\x64\xe2\x51\x03\x9a\xcb\x1c\x1c\x1a\ +\x61\x59\x62\xe6\x12\x80\x52\xbc\x65\x45\xec\x1d\x19\xf7\x89\x28\ +\xc3\x2b\x72\x14\xec\x3e\xe3\x1b\x97\x63\x32\xe2\x10\x44\xa4\xd7\ +\xac\xd1\x3a\x8e\x19\xc5\x22\x63\x74\xcb\x60\x98\xff\xde\x39\xc2\ +\x9c\x75\x95\xcd\xbf\xad\x15\x37\x86\x29\xab\x63\xff\x6d\x5c\x74\ +\x63\x09\x2d\xd5\xf6\xfe\x2b\xe3\xfe\x1b\x41\xc4\xef\x05\x66\x2e\ +\x02\x28\x1a\xe1\x5d\x31\x65\x71\x94\xd6\x3a\x32\xff\xbf\x68\xb2\ +\xff\x6a\x88\xd0\xf5\x98\xb9\xaa\x94\x8a\x94\x52\x59\xe3\x42\xdd\ +\xa5\x94\xd2\x00\xaa\xe6\xdc\x33\xfe\xd3\x67\xc2\xc9\xcd\x5d\xc5\ +\x8f\x7f\xfc\x6b\x88\xa2\xe7\x3e\xdc\xc0\x5b\xe8\x98\x3f\x49\xc6\ +\xe5\xb4\x33\xe7\x37\x7b\xbe\x92\xe4\xdc\x3b\x5d\xe4\x24\xe9\xff\ +\x17\xdb\xd8\xe1\xe6\xa6\x1d\x84\xed\x24\x34\x80\x11\x48\x52\x92\ +\x34\x18\x84\x24\x37\x69\x66\x6d\xc7\xd5\x90\x1a\x81\x69\xd1\x0e\ +\xf5\x64\x93\x90\x24\x4e\x21\xed\x18\x0d\x5b\x53\x70\xa1\x94\x01\ +\x3c\x9f\x72\x5b\xea\x61\xb1\xc5\x6d\x74\x12\x0c\xb1\xb2\xa6\x29\ +\x32\xb7\x41\xfa\xbb\x4e\x5e\x90\x4a\x42\xa7\x5b\x08\x1a\xc9\xbe\ +\x38\x8e\x1f\xb8\xe7\x9e\x7b\x7e\xf5\x81\x07\x1e\xb0\x96\x4b\x5b\ +\xb2\xa6\x36\xfb\x7a\x16\x62\x49\x2d\x93\xd4\x37\xb5\x96\x46\xdf\ +\xba\xd1\x32\x33\x29\xa5\x62\x23\x0a\xf3\x90\x9a\xa6\xb3\xe5\x6d\ +\x98\x99\xf5\xe6\xe5\x1c\x7c\xf5\x68\x1c\x6f\x59\x41\xe8\xca\x28\ +\x8c\x97\x32\x10\x97\x5c\x5d\x23\x2e\x75\xa1\xc0\x3c\x30\xc0\x34\ +\x3d\xed\xa9\xde\x8d\x39\x5d\x7c\xe0\x45\x9f\x7e\x61\x20\x34\x02\ +\x19\x66\xdf\x64\x13\x2e\xc1\x5a\x6f\x4d\x49\x1a\x88\x05\xcb\x33\ +\x59\x7e\x7d\xf3\xb7\x59\x61\x6b\x7e\xf7\x8c\xc0\x56\x90\x49\xb9\ +\x32\xc9\x94\x62\x63\x71\xcd\x63\xae\xb6\x2a\x31\x73\xc4\xcc\xa1\ +\x39\x6c\x60\xb6\x29\x43\x84\x79\x06\xe2\x3a\xcc\xb8\x10\xc6\xf4\ +\xd2\x94\xff\x5f\xbf\xf3\x60\xa6\x52\x29\xee\x86\x2b\x65\xd3\x2e\ +\x24\x31\x52\xa4\x2d\x58\x93\x88\xc0\x66\x0b\xd6\x4e\x2f\x73\xb7\ +\x94\xc5\xfa\xc5\x38\xc1\xda\x41\xd4\xbe\x78\x27\x91\x9e\x60\x25\ +\x00\x3b\x00\xec\x4e\x69\x7f\xaf\x84\x32\xc7\x4b\x0b\x06\xf0\x62\ +\x8a\xfb\x6b\x36\x5d\xa8\xbf\x63\x61\xa4\x9b\xb2\x1e\x98\x2b\x05\ +\xb1\x50\x3c\x74\x76\x81\x6e\x47\x3a\x9c\x40\xba\x82\xd5\x07\x70\ +\x03\x80\x27\xb0\x34\xdd\xdf\x93\x9c\xf3\x33\x68\xfd\x02\x4e\x43\ +\x05\x77\x1c\xc7\xff\x79\xd7\xae\x5d\xff\x6e\xd7\xae\x5d\xbd\x77\ +\xdc\x71\x87\x22\xa2\x8a\x49\x26\x94\x83\x24\x10\xaa\x2a\xa5\xaa\ +\x46\xa4\xf5\x58\x71\xc9\xcc\x91\x11\x72\x81\x52\x2a\x62\xe6\x8a\ +\xb1\x7a\x5a\xd7\xdb\xac\xc9\xaa\x1b\x9b\xef\x83\x01\x82\x16\xf1\ +\x1a\xbd\x79\xa3\xce\x7c\xfb\x14\x55\xdf\x7e\xbd\xc7\x59\xcf\x66\ +\xf7\x65\xf3\x5d\xee\xeb\x63\x3e\x71\x82\x10\xc7\x2a\x1e\x19\x5c\ +\x8d\x1d\xfb\xcf\x67\xa2\xed\x2b\x4d\x72\x60\x78\x46\x04\x9b\xcd\ +\x24\xeb\xaf\x52\xca\xe6\x10\xf0\x60\x44\xac\x52\xb3\x89\x84\x95\ +\xf9\x58\x0b\x30\x4c\xa2\x25\x65\xfe\x5d\x35\x96\x55\xbb\xe0\x18\ +\x98\x6c\xc4\xa1\x39\x57\x10\x51\x50\xb3\xbd\x26\x22\x9f\xa5\xe6\ +\xaa\xb5\x4a\x73\xf6\x2b\x47\xba\xf7\xee\x24\xfe\xcc\x07\xbf\x1d\ +\xc5\xf1\x9e\x5f\x69\xe4\xbd\x73\x2c\x88\x24\xe3\x7c\xda\xc9\x6a\ +\x92\x88\xc0\x7a\xaa\x52\xd8\xf7\xb9\x1e\x3a\x3d\x51\xcf\x52\x16\ +\xeb\x17\x53\xaf\x8b\x33\x03\x78\x14\xad\xb7\x38\x2f\x36\x17\xed\ +\x2b\x52\xfb\xf0\x9d\x87\x58\x44\xd3\xaa\x55\xb8\x1a\x62\x69\x3d\ +\x95\xd2\xfe\xae\xc4\x36\xa4\x5b\x63\xb1\xd3\xad\x2f\x49\xea\xd0\ +\xce\x20\xfd\x97\xf0\x02\xc4\x15\x73\xa1\x04\x10\x4b\x46\xa7\x67\ +\xe5\x73\x24\x63\x0a\xc0\x28\xa4\x26\x66\x5a\x2c\x03\xf0\xc3\x90\ +\x4c\xa5\xad\x1e\x74\x9a\x4d\x92\xb2\x63\x1e\x3a\xbb\x6f\x9c\x0f\ +\x63\x5a\xeb\x0f\xfd\xee\xef\xfe\xee\x9f\x3f\xf3\xcc\x33\x51\x36\ +\x9b\x2d\x10\x91\x6f\xb2\xeb\x32\x24\x96\xd3\xba\xbc\xb2\xb1\x26\ +\x2a\x48\xbc\xa8\x75\xcf\xf5\x21\x89\x95\xb4\x71\xeb\x65\x63\xad\ +\x64\x63\x8d\xd5\xc6\x65\x38\x8a\x57\xe4\x62\xef\x6c\x49\x57\xde\ +\xb6\x11\xfe\x57\x8f\xe4\x82\xc7\x5f\x44\xf8\xe6\xf5\x54\xe3\x1a\ +\x6c\xc4\xab\x58\x68\x89\x40\x5b\x7f\x7e\xb9\x7e\xe1\x93\x07\x83\ +\xc1\x1d\xfd\x6c\x5c\x87\x7d\xa5\x14\x8c\x78\x55\x5a\x6b\x65\xac\ +\xa9\xb3\x26\x58\xdb\x06\xd3\xf6\x08\x32\x71\x65\xf3\x1d\x05\xe3\ +\xe2\x8b\xb9\xb8\x58\x22\xa2\x8c\x11\xb0\x0a\x00\x1b\x8b\x31\xc3\ +\x94\xbf\x31\xc7\x9e\x01\xa0\x95\x52\x59\x48\x76\xe1\xd8\xec\xb3\ +\x10\x3c\x7e\x8a\xaa\x37\xad\x2b\xdd\xf5\xde\xff\xc4\x99\xcc\xd8\ +\xdf\x94\x4a\x38\xdc\x94\x3b\xe8\x98\x0f\x49\xfa\x81\x02\xe4\x59\ +\x49\x63\xf1\x48\x21\x59\xa9\xad\x7a\xce\xa3\x82\xfa\xe6\x24\x30\ +\xdb\xa5\x9d\x5b\xa1\x99\x24\x09\xb1\xa9\x57\xe4\xb7\x2b\xf5\xbe\ +\x03\xb6\x5f\x5d\xec\x63\x61\x5b\x51\xeb\xa6\xc9\x00\x5e\x48\x79\ +\xff\x3f\x84\x64\xe2\x69\x3e\xac\x01\xb0\x21\xe5\x7d\x9e\x48\x79\ +\x7f\xcd\x26\x89\x6b\x74\x23\x6a\x8c\x25\x71\x0d\xef\x4f\xad\x15\ +\x8e\x4e\xe6\x78\x03\xf6\xb9\x1a\xc0\x1b\xb0\xf8\x56\x8d\x5f\x89\ +\x24\xef\x63\x9a\x0b\x83\x6d\x4b\x1c\xc7\x9f\x1a\x1f\x1f\x3f\xf8\ +\x27\x7f\xf2\x27\xdd\x36\x11\x91\xb1\x26\x32\x64\x92\x12\x41\x16\ +\xd3\x08\xb2\xca\xcd\xcc\x5c\x30\x49\x8a\x94\x89\x19\x0d\x8d\x70\ +\x63\x66\xae\x12\x51\xd9\x24\x43\x8a\xcc\x76\x19\x22\xca\xc7\x37\ +\x0f\x66\xfd\xa7\x87\x73\x1c\x28\x8f\x62\x0d\xaf\x18\x45\x44\x54\ +\x31\x09\x9a\x62\xcc\x5a\x3f\x41\xbd\xbd\x5a\x4d\x4f\x93\xb7\x72\ +\x65\x14\x1c\xd9\xb8\x89\xfc\x7f\x7d\xc1\x23\xc1\x67\xe6\xc0\x7e\ +\x4c\x7c\x2d\x99\x76\x5b\x81\x5a\x35\x56\xdf\x0a\x33\xdb\xa4\x4b\ +\xd6\x75\x37\x67\x84\xb1\x66\x66\x98\x52\x37\xf2\x1f\xad\x95\xd9\ +\xb6\x6c\x2c\xae\x5e\xcd\xb9\x6b\x73\x1e\x5d\x46\xbc\x5e\xd0\x5a\ +\x47\x44\xa4\xfc\x7d\xa3\x8c\x9c\xaf\x3f\xf5\xcd\xaf\xe6\x8f\x1e\ +\x3d\x5d\x2a\x95\x8e\xdf\xd3\xd0\x9b\xe6\x58\x28\x17\x50\xff\x62\ +\x1d\x21\xbd\xe4\x9a\xdd\xa8\x3f\x73\xb9\x46\x7d\xa2\x21\xc9\x22\ +\x78\xbd\x42\xb7\x5d\x58\xca\xe7\x7e\x31\x49\x04\x67\xab\x92\xcb\ +\x2e\x59\x2e\xee\x24\x4e\x22\x5d\x6b\x96\x07\xe0\x46\x34\x6e\x92\ +\xd3\x0f\xb1\x92\xa4\xc9\x24\xc4\xc2\xda\xa9\x24\x2d\xed\xd3\x88\ +\x52\x3e\x49\xf6\x79\x55\x6a\xad\x70\x74\x32\x67\xd1\x98\x67\x73\ +\x15\x80\x5b\xb0\xf8\x06\xe2\x2b\x91\xa4\xee\xf6\x9a\xd4\x5a\xd1\ +\xde\x70\xa9\x54\xfa\x85\xfb\xef\xbf\xbf\xf4\xc8\x23\x8f\xf8\xa6\ +\xac\x4d\xc9\xb8\xe8\xe6\xac\x85\x94\xa4\xfe\x69\xd6\xfc\x5e\x35\ +\xc9\x86\x3c\x22\x8a\x8d\x70\x0b\x21\xe3\x6c\x9e\x99\xf3\x46\xf4\ +\xc6\x46\xb8\x8a\x3b\x97\x47\xc4\xa1\x26\x62\x04\x20\xa8\x70\xdb\ +\x8a\xc0\xdb\x7f\x3e\x30\xd6\xd0\x08\x92\x5d\x38\x62\x86\xbe\xe9\ +\xa6\x08\xfb\xf7\x8b\x46\xed\xdb\x92\x55\x23\xe7\x88\xe8\x74\x71\ +\x36\xe6\x14\x2f\x1f\xd3\x35\x80\x48\x6b\x1d\x42\xe2\x4a\xb5\x12\ +\xb2\x24\x25\x6d\x72\x90\xc5\x1a\x65\xce\xa5\x0c\x29\xa5\x13\x9b\ +\x52\x3c\x39\x22\xf2\x8c\x0b\x33\x01\xf0\x94\x52\x01\x64\x8c\x29\ +\x1b\x11\x4e\x26\xb1\x92\x75\x33\x2c\x10\x51\xa0\x86\x26\x4b\x74\ +\xb6\xc8\x7b\x7b\xc6\xd5\x3d\xf7\x7c\x3e\x2c\x95\x9e\xf9\x79\x24\ +\xb3\xe8\x39\xd2\x27\x69\x9d\xeb\xbe\x94\xda\xb1\x2c\xc1\xb6\x53\ +\xa8\xcf\xc5\x35\xc9\x79\xf7\xa3\xb3\x4b\x83\x25\x71\x05\xef\xc5\ +\xe2\xca\xb2\x9f\x64\x2c\x1c\x48\xad\x15\x8e\x79\x71\xf1\x4b\x17\ +\x01\x38\x92\xf2\x31\xb2\x90\x09\x61\x9a\x09\x91\x00\x89\xb7\x7d\ +\x3d\xd2\xef\x38\x0e\xa2\xb3\x5d\x04\x93\x96\xf6\x49\xb3\xee\xa5\ +\x65\x2c\xc1\xb6\xab\x90\x6c\x40\x73\x2c\x1e\xf6\xa1\x31\xef\x66\ +\x0f\x80\x1f\x03\x70\x1d\x16\x5f\x52\x89\x4b\x51\x46\xfd\xe2\xa1\ +\x17\x8d\xf7\x9a\x69\x17\x8e\x6a\xad\xdf\xf7\xfe\xf7\xbf\xbf\x7a\ +\xf6\xec\xd9\xd0\x08\x3c\x9b\x75\x37\xc7\xcc\x9e\x11\xa5\x31\x8c\ +\x95\xde\xd4\x4d\x8d\x99\x39\x47\x44\xd6\x6a\x19\x19\xf7\x5f\x1b\ +\x1b\x4a\x4a\x29\x2b\x32\x01\x00\xd1\xad\x57\x2b\xff\xdb\xa7\x10\ +\x6d\x5a\xae\xbd\xd3\xd3\x5a\x1d\x1a\xf5\x8c\x3b\xae\x6f\xdc\x88\ +\x63\x66\x49\x90\xa4\x35\x31\x00\x74\x75\x31\xbf\xf4\xaa\xf5\x1c\ +\x3c\xf6\x22\x53\xa8\x35\xe6\xde\x0d\x66\xe6\xd8\x24\x45\x8a\xe4\ +\x50\x08\x20\x56\xd4\xc0\xb8\x28\xcf\xba\x72\x1a\x71\xad\x8c\x6b\ +\x73\x46\x29\xe5\x6b\xad\x7d\x88\xd8\xad\xda\xa4\x4b\xcc\x9c\x31\ +\x71\xb2\xb1\x71\x13\xce\x1a\xf7\xe0\x92\x71\x85\xf6\x01\x30\x1d\ +\x1b\x67\xef\xe0\x68\x7e\xe2\xa6\x7e\xfd\xce\x77\x7e\xb4\xe2\xfb\ +\x23\x7f\x06\xe0\x5b\x8d\xbb\x4d\x8e\x04\x24\x59\x04\x4c\x2b\xe7\ +\x49\x2b\x16\xd8\x93\x08\xd6\x0c\x3a\xbb\x9e\x77\x12\x91\x16\x20\ +\xdd\xd0\x9c\x56\x93\xe4\xf9\x5f\x87\xa5\x31\x5f\x68\x1b\x2e\x25\ +\xf6\x5e\x40\xfa\xd9\x7d\x33\x00\x6e\x02\xb0\x19\xc9\x57\x67\x7c\ +\x88\xab\xf1\x0d\x48\xff\x61\x39\x87\xc6\x08\xb6\x66\xe1\x41\xe2\ +\x79\xeb\xe5\x02\x92\x75\x66\x97\xa3\x8a\xfa\x45\x2b\x01\x78\x35\ +\x9a\xbb\xaa\xe7\x03\xd8\x0e\x79\x66\xd3\x1a\x94\x1d\xc9\x99\x44\ +\xe3\x62\xe2\x15\xa4\x46\xeb\x9b\x00\x5c\x8b\xc5\xef\x26\x3c\x9a\ +\x60\xdb\xad\xa9\xb5\xa2\xcd\x89\xe3\xf8\x0b\xcc\xfc\xc5\xf7\xbd\ +\xef\x7d\x2a\x8a\xa2\xb2\x49\x28\x34\x9b\x09\x18\xf2\x9c\x44\x46\ +\xa8\x06\xc6\xe2\x4a\x4a\xa9\x08\x30\xd9\x8f\xc4\x25\x37\x36\xa2\ +\xd5\x37\xc2\x4f\x19\x97\xe1\x0a\x11\x45\xe8\x2f\x30\x8d\xcc\x78\ +\xa5\x0f\xdf\xa8\x32\x9f\xfa\xbe\x17\xef\x5c\x1d\x66\x9e\x3b\x6f\ +\xb3\x00\x67\x94\x52\x6a\x60\x00\x7a\x64\x84\x62\xa5\xa0\x2b\x15\ +\xe0\xda\x6b\x35\x82\x80\xf8\xe8\x0d\xdb\x38\xf3\x85\x43\x40\xcc\ +\x36\x49\x53\x04\x59\x7c\x66\xa5\x94\x6f\x84\xa8\x75\x5d\x8e\x21\ +\x2e\xcb\xbe\x71\x09\xd6\x2c\x35\x62\xab\xa6\xcd\x8a\x99\x3d\xa5\ +\x94\x8d\xbd\xb5\x31\xb4\xe4\x79\x5e\x68\xce\xc5\x87\x8c\xe9\xb1\ +\xb1\x20\xdb\x3a\xac\x55\xff\xc0\x28\x05\x27\x8b\x5e\xf5\xa7\x37\ +\x84\xbf\xf1\x1b\x7f\xa8\x8a\xc5\xa9\xfd\x33\x33\xc7\x3e\xda\x94\ +\x9b\xe5\xa8\x87\x24\xb5\xe6\x57\x22\x79\x4c\x63\x1e\xc9\xc2\x7e\ +\xea\xad\xe6\x30\x91\xe0\x98\x00\x70\x3d\x3a\xd7\xca\x9a\x44\xac\ +\x03\xc0\xd5\xa9\xb4\xa2\x3d\xa8\xa0\xfe\xeb\xe1\x43\x16\xb9\x1d\ +\x4d\xe2\x52\x2f\x1c\x03\xf8\x3e\xd2\xb7\x64\x28\x00\x5b\x20\x13\ +\xc2\x6b\xb0\x70\xb1\x19\x40\xea\xac\xda\x09\x65\xda\xc4\x00\xf6\ +\x37\x60\xbf\xcd\x24\x69\xf2\xa9\xe1\xb4\x1a\x92\xf2\xbe\x97\x01\ +\xd8\x89\xe6\x88\xd6\xb5\x00\x6e\x83\x3c\x6b\xfd\x90\x01\xd5\xd1\ +\x3e\x1c\x40\x63\x5d\x0b\x73\x90\x05\xb1\x9f\x80\x2c\x94\xac\xc6\ +\xe2\x5c\x45\x3d\x9d\x60\x5b\x9b\x50\xaf\x59\x04\x90\x7b\xf2\x16\ +\x00\x6f\x6c\xe2\x71\x01\x00\xd3\xd3\xd3\x77\xed\xd9\xb3\xe7\xd8\ +\x47\x3e\xf2\x91\x9c\xb1\x4c\xb2\x49\xaa\x14\x79\x9e\x57\x85\xb8\ +\x04\x7b\xe6\x6f\x36\x81\x11\x13\x51\xd5\xb8\xf5\x66\x21\x19\x76\ +\x15\x80\x48\x29\xa5\x4d\x42\x24\xa9\xbf\x2a\x82\x30\x8e\x6f\x1e\ +\x8c\xfc\x67\xcf\x10\x85\x4c\xf1\xa6\xbe\x80\x9e\x1f\xf5\x10\xeb\ +\xc8\xb8\x05\xfb\x7d\x7d\xb1\x3f\x3a\x4a\xd8\xb9\x33\x8a\x9f\x7c\ +\x32\xa3\xb3\xe2\x47\xc3\x13\x25\x0f\x95\xb7\x5f\xaf\xb3\x0f\x1e\ +\x24\x8e\x75\xac\xb5\xd6\x4a\x29\x28\xa5\x02\x96\x72\x34\x21\x44\ +\x5c\x7a\xe6\x5a\x2a\x00\xb1\x52\xaa\x6a\x05\x28\x49\x49\x1e\x6b\ +\x7d\x0d\x4d\x62\x26\xaf\x46\x5c\x57\x4d\xdc\xab\x67\xb2\x03\xc7\ +\x46\xcc\xe6\x21\xe2\x38\x0c\xbe\xf3\x52\x80\xc9\x0a\xaa\x6f\xba\ +\x3a\xfe\xf8\xc7\xff\x26\xf8\xfa\xd7\xf7\x4c\x4f\x4d\x7d\xf7\xa7\ +\xe1\x4a\x47\xb4\x33\x23\xa8\x3f\x71\x12\x41\xe6\x74\x49\xd8\x8a\ +\xfa\xc7\xf5\x10\xf5\x2f\xbc\x95\x90\x2c\x7e\xb1\x17\xb2\xa8\x5d\ +\x2f\x36\x06\xbc\x15\x44\x48\x66\x98\x58\x87\xc5\x65\x65\x4d\x32\ +\x37\xbd\x0e\xcd\xf5\x38\x2a\x40\xf2\x6e\xbc\x15\x32\x3f\x59\x52\ +\x5c\x6e\x85\xe8\x3c\x80\xa1\x06\x1d\xb3\x00\xb9\xd0\x6f\x86\xc4\ +\x9f\x5e\x03\x11\x24\x17\x5b\x34\x02\x48\x8c\xc4\x7a\x00\xaf\x33\ +\xdf\xdf\x8e\x64\xee\xae\x57\x62\x3f\x9a\x5b\x37\x36\x6d\xb6\x43\ +\xae\x55\xbd\x34\x22\xe9\x56\x2d\x2f\x21\x59\x39\x8d\x41\x88\x55\ +\x3d\x49\x7d\xd9\xcb\x41\x90\xd8\xbc\x9b\xcd\x31\x16\x5b\x26\xbc\ +\xc5\x44\x08\xe0\x59\x34\xde\x6d\xdf\x87\xf4\x4d\x6f\x00\x70\x07\ +\xe4\xd9\xd8\x01\x59\x5d\x5e\x09\x49\xb8\x70\xb9\x67\xd1\x47\xfb\ +\x3f\x43\x23\x48\x96\x2d\xf2\xd5\x68\x7c\x3c\x2b\x41\x62\xd8\x6f\ +\x83\x2c\x52\xb6\x6a\x82\x57\xaa\x54\x2a\x3f\xf1\xd9\xcf\x7e\xf6\ +\xec\xbd\xf7\xde\x6b\x6b\x9a\x46\x00\x7c\xad\xb5\x6f\x04\xa1\x67\ +\xc4\x9c\x06\xa0\xb5\xd6\x81\x4d\x62\x44\x52\x4f\x55\x19\xeb\xa7\ +\x86\xb8\x0c\x03\x12\xeb\x0a\x98\xc4\x4a\xd1\x40\xde\xf3\xce\xce\ +\x70\xe5\x9d\x5b\x39\xff\xc7\x4f\x52\xf8\xd6\xeb\x94\xbf\x6b\x28\ +\x03\x79\xd6\x23\x00\x8a\x08\xde\x8e\x1d\x31\x1f\x3f\x4e\x30\x49\ +\x8e\xb0\x7d\x7b\xc4\x47\x4f\x67\x29\x7c\xfb\xf5\x9c\xfd\xbb\x03\ +\xf0\x8a\x21\x8c\x55\x95\x59\xca\xf1\x28\x22\xb2\xed\xa9\x15\x9b\ +\xb5\x75\xd8\x6d\x82\xa6\xd9\xf2\x36\xf2\x43\xea\xc6\x6a\xad\x7d\ +\x66\xce\x1a\x51\x1e\x31\xb3\x32\x02\x3c\x56\x15\xad\xb2\x5f\x3c\ +\x9c\x8d\xaf\xea\x8e\xa2\x1f\x59\x87\x2f\x7d\xe9\x1f\xbc\x3f\xfe\ +\xe3\x87\x2b\xd5\xea\xd3\xb7\xa3\xb3\xf3\x41\x2c\x05\x62\xc8\xd8\ +\x5c\x2f\xb6\x3f\xac\x87\xd5\x48\x96\xa3\xe2\x14\x92\x8d\x03\x49\ +\x9f\xcd\xf5\x90\xf9\xc2\x42\xca\xdc\x04\x10\x4f\xc3\x37\xa1\xb5\ +\x5e\x3c\x49\x3c\x6c\x08\xc0\x6b\x91\x2c\xcb\x72\x3b\x25\x2c\x4a\ +\x22\x58\x09\x92\xa7\xa7\xd1\x39\x30\x14\x44\x1c\xdf\x8a\xce\x76\ +\x47\x4f\xc4\x95\x5e\x98\x43\x90\xf8\xc1\x46\xdd\x08\x1f\xb2\x52\ +\x53\x1b\xbf\x60\x07\x66\x1f\xcd\x9d\x9c\x9c\x45\xe7\xd6\xfb\x5c\ +\x01\x59\xa5\x4c\x1a\x23\x7c\x06\xe9\xd7\x5f\xad\x25\x84\x64\x5f\ +\x4e\xe2\x42\xb1\x06\xc0\x72\x00\x87\x21\x75\x72\x93\x8a\x16\x1f\ +\x22\x84\x37\x22\x59\x5a\x7d\x47\x73\x19\x87\xf4\x4f\x49\xdc\xdf\ +\x17\x82\x07\x79\xbf\x2e\xf7\x8e\xb5\xaa\xdf\x4a\x82\x86\x2c\x50\ +\x6d\xae\x73\x7b\x05\x99\xac\x1d\x82\x64\x70\x4e\x73\x01\xc1\x83\ +\xbc\x97\x1b\xd0\x3e\x13\x9b\x97\xca\xe5\xf2\x1b\xef\xbb\xef\xbe\ +\x67\xfb\xfb\xfb\xf3\xbf\xfc\xcb\xbf\xec\x1b\xab\xa3\x32\x65\x6a\ +\x62\x23\xe2\x3c\x88\x15\x35\x34\x6e\xb7\x80\x58\x5b\xe3\x9a\x32\ +\x33\xf6\x5a\x19\x63\xa8\xac\x1b\x13\x51\x5c\xfd\xc9\xf5\x08\xbe\ +\x79\xd2\xf3\x9f\x39\x83\x99\x9c\x22\xaf\x2f\xaf\xd5\xd0\x64\x46\ +\x6f\x58\x16\x01\x88\x88\x38\x08\x02\xe8\x5c\x8e\xf4\xe4\x24\xd1\ +\xb2\x65\x4c\xc5\xa2\x88\xcb\x4a\x90\x89\xf5\x7b\xb6\xeb\xcc\x97\ +\x8f\x66\xe2\x2d\x2b\x38\xde\xbe\xd2\xd6\x45\x25\x00\xe0\x9a\x1a\ +\xac\x46\x78\x2a\x00\xbe\x29\x5f\xa3\x4d\xac\xac\x52\x4a\x79\xe6\ +\x67\x64\xfe\xa6\x20\xa2\x37\x34\x6d\xb7\xd9\x92\xd9\x7f\xfa\x8c\ +\x52\x2f\x4e\x73\xf9\xed\xd7\x55\x29\xf0\x32\x8f\x3e\xfa\x98\xfe\ +\xcd\xdf\xfc\x4c\x1c\x86\xbb\x7f\x16\xc0\x9e\xa6\xdd\x1d\x47\x12\ +\x86\x90\xac\xce\xf5\xeb\x01\xec\xc6\xc2\xc2\x7e\x56\x20\x59\xc2\ +\x4c\x46\x72\xa3\xca\x30\x92\x7b\xeb\xad\x85\x08\x88\x93\x10\xf7\ +\xea\x31\xfc\xa0\xc5\x3a\x07\x11\xf5\xab\xcd\xf7\xdb\xc1\x95\xf8\ +\x2c\x92\x19\x38\x72\x90\xdc\x34\x07\x21\x73\xb1\xf9\x78\x51\x2c\ +\x33\xc7\x1c\x44\x7b\x8d\x93\x45\xc8\xe2\xc5\xaa\x3a\xb7\xcf\x42\ +\x16\xb4\xf7\x22\x99\xe7\xd2\xe5\xf6\x7d\xad\xf9\x34\xca\x58\xd7\ +\x31\x5c\x49\xb0\x6a\x48\x8d\xc2\x5b\xd0\xbc\x0b\x45\x68\x8c\x05\ +\xed\x4a\x14\xd1\x5e\x03\xeb\x0e\x88\x78\x9c\x80\xb4\x2d\x86\x71\ +\xb9\x82\xdc\xaf\x2c\xe6\x3a\xc0\x55\x10\x01\x97\x14\x06\xf0\x7c\ +\x0a\xfb\x79\x25\x8e\x43\x06\xc6\x24\x85\xb7\xb3\x10\xeb\xce\x16\ +\x48\xe7\x70\x1a\x12\xdb\x38\x5f\xeb\x6d\x0f\xe4\x9a\x0d\x40\xae\ +\x5f\x3b\x0c\x1e\x8e\x85\x73\x0c\xf2\x2c\x6c\x6c\x75\x43\xd0\x9a\ +\x7e\x2b\x0d\x86\x20\xa2\xb0\xde\x95\x7e\x82\x2c\x1a\x5c\x0d\x59\ +\x44\x3a\x8b\x64\xee\x9f\x3d\x10\x8b\x4b\xd2\x3e\xa2\x51\x1c\x29\ +\x95\x4a\x6f\xbe\xfb\xee\xbb\x1f\xef\xeb\xeb\xc3\x9d\x77\xde\x19\ +\x40\xce\x37\xd4\x5a\x67\x4c\xdc\x67\x0c\x11\x81\x31\xc4\xed\xd6\ +\x8a\xbf\xd8\xd4\x71\x55\x10\xcb\xa5\x8d\x11\xd5\xc6\x52\xc9\x44\ +\x04\xee\x0a\x94\x5e\xdb\xcd\xf1\x8f\x6f\xd0\x85\x3f\x78\xd2\x9b\ +\xf9\xfd\x9b\x54\xf6\x8b\x87\x39\xec\xcf\xfb\xdc\x93\x89\x00\x8a\ +\xb5\x8e\x83\xc1\xc1\x28\x3a\x71\xc2\xe3\x9d\x3b\x23\x1c\x3a\xa4\ +\xb0\x75\x6b\x4c\xfb\xf7\x7b\xd8\xb1\x83\xbc\xea\xdb\x37\xc3\xdf\ +\x3b\xa2\xb3\x0f\x3d\xef\x57\x7f\x66\x23\x38\xef\x03\x12\x57\xab\ +\xad\x5b\x6f\x4d\x7d\x56\x52\x4a\xb1\x39\x0f\x10\x11\x8c\x0b\x70\ +\x64\xc4\xb6\xb5\x28\xc7\xa6\x9d\x1e\x33\xc7\xde\xf1\x49\xf2\x9f\ +\x3d\xeb\x45\x37\xac\x89\xe3\x37\xac\x65\x62\xce\x3c\xf5\xd4\x53\ +\xe1\xbb\xdf\x7d\x9f\x57\xad\x3e\xfb\x8b\x00\xfe\xa5\x99\x37\xa6\ +\x45\x34\xd3\x2d\xfe\x52\x94\x91\x4e\xce\x8d\x69\xc8\x38\x5a\x6f\ +\xbe\x06\x1f\x62\x65\x3a\x0e\xe0\x28\xae\xec\x62\xec\x41\xfa\x9c\ +\xcd\x48\x16\x6a\x71\x0a\xc9\x6b\x60\x8e\x41\x5c\x83\x93\x86\xfd\ +\xd8\x73\xb2\xe5\x15\x43\xf3\xb1\x65\xa3\xda\x31\xa4\xe4\x3c\xc4\ +\xc3\x26\x49\x3f\x6b\xf3\xc9\x6c\x86\xcc\x59\xc7\x20\x5e\x8a\x76\ +\x61\x2b\x03\xb9\xb6\x2b\x20\xe1\x55\xed\x9c\xac\xef\x08\xea\x17\ +\xac\x80\x8c\xff\x37\x40\xae\xeb\xf3\x90\x45\xf5\x24\x25\xa3\x96\ +\x43\xfa\x97\x41\xb8\x39\xea\x2c\xaf\x34\x51\x99\x81\xac\x9c\xdd\ +\x8c\xf6\x7c\xe9\x92\x52\x01\xf0\x14\x6c\x79\x81\xf6\xa0\x1b\xcd\ +\x0f\xe4\x3e\x85\xc6\x24\x5b\xba\x98\x2a\xc4\xf5\xfa\xb5\x29\xec\ +\x2b\x0b\x59\xad\x5b\x6f\x7e\x9f\x81\x08\xfc\x10\x22\x5e\x6b\x93\ +\xa2\x04\x10\x0b\x6a\x17\x3a\x53\x58\x38\x2e\xcd\x01\xc8\xfd\x5c\ +\x4c\x49\x20\x9a\x49\x15\x32\x50\x27\xb5\x54\x77\x43\x06\xeb\x10\ +\x73\x13\x97\x29\x48\x9f\x72\x39\x01\x4b\x90\xc9\xcc\x32\xc8\x84\ +\x66\x15\xda\xc7\x9a\x7a\x25\x9e\x2c\x97\xcb\x3f\xfb\xeb\xbf\xfe\ +\xeb\x5f\x9d\x9c\x9c\xa4\xf7\xbc\xe7\x3d\xb6\x3e\x6b\x68\x5c\x6c\ +\xc9\x5a\x5b\xc5\xeb\x96\x35\x11\x29\xad\xb5\x67\xfe\x3f\x1b\x4b\ +\xab\xc2\xdc\xb5\x61\x00\x64\x5c\x8a\x39\xba\x61\x80\xd5\xb1\x71\ +\x95\xfb\xe7\x21\x46\x29\xa6\xea\x3b\xb6\x50\xf6\x73\x07\xb9\xf2\ +\xef\xb7\xf9\x41\xc0\x71\x18\x2a\x5e\xbd\x9a\x69\x68\xc8\xe3\x9d\ +\x3b\xa1\xac\x1b\x6f\x7f\x3f\xf3\xf9\xf3\xca\xef\xef\xd7\x51\xf4\ +\xea\x55\x5e\xb8\x6d\x05\x32\x8f\x9c\x24\xaa\xc4\x08\xdf\x74\x8d\ +\xe6\xde\x0c\x99\xf2\x34\xba\xd6\xda\x7b\x91\x30\xb5\xb5\x55\x6d\ +\x2c\x2e\xec\xef\x04\x90\xf7\x9d\x97\xb4\x1a\x99\x51\x7a\xfd\x32\ +\x84\xef\xdc\x1a\x6a\xad\x7d\x68\xcd\xff\xfc\xcf\xff\x12\xbf\xf7\ +\xbd\x7f\xe1\x97\xcb\xfb\xee\x02\x4a\x0f\x35\xeb\x66\xb4\x10\x02\ +\xf0\x9a\x16\xb7\x61\x04\xe9\x25\x89\x3c\x08\x59\xc4\xad\x77\x72\ +\xec\x41\x84\xcb\x7a\xd3\xa6\x51\x88\xa0\xb6\x0b\xed\x39\xcc\xbd\ +\xe7\x49\x17\xa3\x22\xc8\x02\x59\x52\x18\x22\xb2\x77\xa4\xb0\xaf\ +\x5a\x02\xb4\xff\x3c\x83\x21\xf3\xbe\x34\x16\x7c\x73\x78\xf9\x5c\ +\xac\x13\x19\x83\x58\xdc\x93\x64\xac\x06\x44\x98\xf7\x43\x16\x42\ +\x4e\x43\x0c\x4f\x53\xb8\x72\xcd\x63\x05\x99\x9b\xf6\x61\xee\x1d\ +\x69\xf7\x90\xa2\x96\x30\x9f\x95\xf5\x49\x48\xcc\xd8\x0d\x58\x5c\ +\x4a\x3f\x84\x88\xf1\xa5\x5e\x1b\xae\x0a\x19\xac\x9a\xc5\x4b\x48\ +\x1e\xbb\x72\x29\x0a\x70\x6e\xbd\x4b\x91\xbd\x90\xc9\x63\xab\xad\ +\x1d\x9d\xca\x71\xc8\x20\x9d\x46\xe9\x28\xbb\x78\x60\x17\x10\x18\ +\x73\x0b\x48\x76\x51\xd0\x5a\xa3\x73\x68\x2f\xb7\xb0\x85\xb0\xab\ +\x5c\x2e\xff\xe8\xdd\x77\xdf\xfd\xaf\xc3\xc3\xc3\x85\x0f\x7f\xf8\ +\xc3\x9a\x99\x03\xa5\x54\xa4\xb5\x56\x90\xd8\x54\x6b\xb1\x54\x46\ +\xa4\x02\x52\xc7\x34\x46\x8d\x20\x34\x49\x99\x6c\xec\x28\x99\x7f\ +\x23\xfc\xb9\xeb\xa1\xce\xcd\xa0\xf7\xae\x5d\x98\xfe\xec\x5b\x50\ +\x7d\xdb\x75\x94\xf9\xc2\x21\xbe\xf6\x17\xb6\x7a\xc7\x8e\xfb\x31\ +\x11\xbc\xc1\x41\x1d\x1f\x3f\xae\x28\x93\x01\xca\x65\xf0\xc0\x80\ +\xf6\xf6\xed\xf3\x75\x7f\xbf\x96\x58\xd5\xc0\xa3\xf0\xa7\x36\x00\ +\x31\x73\xe6\xf1\x53\x84\xe9\x0a\xb8\x10\xa8\xe8\x47\xd6\xb1\x2e\ +\xf8\xb3\xf1\xa9\xa6\x2d\xc4\xcc\xd6\xda\x0a\xad\xb5\x07\x80\x29\ +\x62\x0e\x9e\x39\x43\x34\x5a\x02\x69\xd6\xe1\x8d\xeb\xbc\xe8\x96\ +\xab\xc4\x22\x2b\xe7\x1c\x3e\xf8\xe0\x97\xfc\xdf\xfa\xad\x4f\x53\ +\xb5\xfa\xec\xbb\x80\xea\x97\x9a\x7d\x33\x1c\xa9\x30\x03\x11\x81\ +\x49\x17\xaf\x02\x88\xa5\xb6\x91\xd9\xf5\x0f\x22\xbd\xf0\xa5\x93\ +\x00\x36\x61\x69\x0a\x84\xe3\x10\x91\xb9\x98\xe6\xf5\x49\xd8\x0f\ +\x11\x8b\x69\x2c\x36\xe4\xf1\xf2\xc5\x00\x8d\xb9\x2c\xed\x76\x2c\ +\x54\x98\x1b\x0b\x1d\xf3\x60\xbe\xae\x60\x67\x21\x96\xc8\xd7\x2f\ +\x60\x9b\x76\xc6\x5a\x56\xa7\x5a\xdd\x90\x36\xe0\x39\x24\x4b\xbe\ +\x52\xef\x31\x0b\x48\xc7\x9d\xd9\xb1\xb4\x61\x88\x4b\xff\x24\x24\ +\xf1\x58\xa7\x8a\xa0\x56\xc1\x00\xbe\x0b\xe0\x47\x91\xbe\x1b\xae\ +\x75\x89\x6b\x47\xf7\xde\xa4\xec\x2e\x95\x4a\x6f\xf8\xc4\x27\x3e\ +\xf1\xd8\xc4\xc4\x44\xff\xc7\x3e\xf6\x31\x73\x7b\x44\x42\x00\x00\ +\x10\x73\x49\x44\x41\x54\x6d\x32\x05\x03\x92\x94\xc8\x87\x89\xf3\ +\x84\xc4\x7f\x6a\x53\xc3\xd4\x43\x8d\xd5\xd9\x58\x3c\x61\xac\x9c\ +\xb6\x8c\x0c\x28\xeb\x71\xe5\x17\xb7\x91\xff\xbd\xf3\x9c\xfb\xeb\ +\x3d\x54\xbe\xeb\x35\x08\xdf\xb2\x89\x72\x0f\x1e\x62\xbe\x61\x87\ +\xca\xe5\x89\x33\x19\xc6\xe8\xa8\xc2\x0d\x37\x44\x38\x7c\xd8\xe3\ +\x2d\x5b\x62\xb5\x75\x6b\xa4\x0f\x1f\xf6\x68\xeb\x56\xcd\xb3\xfb\ +\xf4\x15\x87\xb7\x5f\x43\xcc\xcc\x6a\x26\x22\x7f\xf7\x69\x45\x17\ +\x42\x30\x33\xc8\x57\x84\x98\xc1\x3e\x11\x95\x63\xe6\x9c\x07\x0a\ +\xb5\x82\xa7\x18\xcc\x60\x5f\xa9\xf8\x75\x6b\x34\xaf\xcc\xb3\xcd\ +\x66\x0c\x23\xb6\x89\x28\xbe\xf7\xde\xfb\x83\x3f\xfd\xd3\x7f\x2a\ +\x57\xab\x4f\xde\x01\x57\x6b\xb5\xd3\x39\x0e\x99\xb0\x27\x29\x33\ +\xd3\x68\xce\x20\xdd\xe4\x90\x31\xc4\x53\x27\x49\x3c\x6d\xa7\x52\ +\x86\x5c\xcb\x0d\xaf\xf4\xc5\x25\x42\x05\x62\x9c\x7b\x03\xd2\x9f\ +\x47\x28\xb8\x18\xd4\xc4\x2c\x44\x7c\x8e\x02\x78\x02\x72\x33\x3b\ +\xf9\xc2\x17\x21\x62\x75\xa9\x5b\x56\x81\xb9\xb8\xb3\x66\xa3\x21\ +\xd6\xed\x37\xc0\x89\x56\x47\x3a\x0c\x41\x16\x5e\x7e\x08\x8b\x63\ +\x51\xad\x99\xcc\x40\x44\xeb\x8d\x70\xab\xed\x0b\xe1\xc0\xcc\xcc\ +\xcc\x0f\x7f\xfe\xf3\x9f\x7f\x74\xff\xfe\xfd\xd7\x7e\xf2\x93\x9f\ +\xa4\x81\x81\x01\x86\x89\x61\xb5\xf1\xaa\x10\xb7\xdb\x59\xd1\x0a\ +\x53\xf6\x06\xf2\x87\xda\xec\xbc\xc6\x18\x2b\xa2\x15\x2b\xf3\x28\ +\xdd\x73\x23\xba\xfe\xc3\x37\x10\xaf\x5f\x86\xf0\x27\x37\xa0\xfa\ +\xd6\x4d\xd4\xff\xb7\x07\xd0\xf7\x1f\x37\xf3\x89\xd3\x19\x15\x86\ +\xc0\xc8\x88\x22\x80\x98\x88\xd8\xf3\xb4\xea\xe9\x61\x1e\x19\x61\ +\xea\x17\xd9\x31\x6b\xb9\x05\x40\xba\xe0\x93\xbe\xed\x6a\xfb\xff\ +\x81\xb9\x89\x59\xed\xef\xd6\xea\x6b\x63\x6d\x09\x26\x23\x30\x24\ +\x86\x95\x8b\xc5\x22\xee\xba\xeb\xa3\xea\xf1\xc7\x8f\x8c\x57\xab\ +\x4f\xde\x0a\x29\x85\xe7\xe8\x6c\x18\xc0\x33\x90\x10\xb0\x76\x8c\ +\x37\x9c\x40\x63\xf2\x8d\x0c\x43\xdc\xa1\xd3\xf6\xfa\xea\x04\x0e\ +\x43\xac\xe1\xce\xca\x27\x8c\x40\x2c\xad\xaf\x6a\x75\x43\x1c\x3f\ +\xc8\x42\x27\x27\x93\x00\x1e\x47\xe7\xa6\xaa\x3f\x05\xe0\xdb\x70\ +\x62\x15\x90\x95\xb5\x23\x2d\x3c\x7e\x08\x59\x38\x48\x2b\x06\xc7\ +\xe1\x78\x09\xc0\x63\x70\xcf\x54\x3d\x8c\x42\xde\xc7\x24\xa5\xa7\ +\x96\x22\x2f\x4e\x4f\x4f\xef\x38\x7e\xfc\xf8\xe7\x6f\xbe\xf9\xe6\ +\xf8\x91\x47\x1e\x51\x90\x18\xd1\x8b\x73\x3e\xb0\x89\x5b\x05\x8c\ +\x88\x9c\x33\xae\x8a\x98\x04\xe6\xca\xca\xd8\xdf\xe3\x8d\xcb\x30\ +\xf3\x97\x77\x70\xfe\x63\x4f\xc0\x3b\x31\x09\xee\xcd\x60\xf4\x67\ +\xb6\x73\x6e\xd7\x10\xfc\x53\x53\xd4\xd7\xc7\x18\x1d\x25\x14\x0a\ +\x9a\x8a\x45\xd9\x7e\xed\xda\x98\xce\x9c\xf1\x60\x0c\xac\x30\x96\ +\x5d\xaa\x3d\x86\x2d\x5b\x63\xdb\x73\x51\x19\x1b\xdb\x38\xeb\x2e\ +\x0c\xa5\x94\x86\xc4\x29\xea\x7d\xfb\xf6\xe1\xe6\x9b\xdf\xab\x9f\ +\x79\xe6\xf0\x33\xa5\xd2\x93\xd7\xc1\x89\xd5\xc5\x44\x04\x59\x4c\ +\x6e\xb7\x12\x7f\xd3\x90\x76\x35\xaa\x7f\xda\x0b\x99\xdf\x2e\x35\ +\x22\xc8\x62\xa5\xab\x95\x3c\xc7\x09\x00\xfb\xd0\xf8\xd2\x79\x8e\ +\x05\x52\x4f\x22\xa5\x18\xb2\x22\xa5\x21\x01\xc2\x9d\xe0\x82\x17\ +\x41\xdc\x50\x8f\xa0\x39\x2f\x66\x2f\x1a\x5f\xa3\x30\x09\x47\x20\ +\x6e\x30\xad\x46\x43\x16\x11\x62\x88\x1b\x52\x3b\x3e\x4b\x23\x90\ +\x8c\x6f\xcd\xa0\x0b\xf5\xc7\x62\x9e\x41\x32\x17\xf7\x00\xf5\x27\ +\x60\x98\x44\x6b\x2c\xf5\x97\x22\x82\x08\xd7\x2a\xc4\x7a\xdf\xe9\ +\xc9\xe2\x4a\x90\x77\xa4\xd8\xa4\x63\x9d\x87\xc4\x98\xb7\xab\x95\ +\xba\x82\xc6\xd6\x8b\xae\x87\xa8\x58\x2c\x3e\x0c\xe0\xc4\xc3\x0f\ +\x3f\xfc\x96\x52\xa9\xe4\xdf\x74\xd3\x4d\xec\x79\x2f\x7b\xf4\x6a\ +\x05\xe0\xec\xbf\x2f\x12\x8e\x97\xfc\x9d\x57\xe4\x10\xde\x7a\x0d\ +\xf7\xfe\xe2\x3f\x22\xbc\xf1\x2a\xe4\x37\x15\x2e\x9c\x5a\xb6\x2a\ +\x93\x79\x7a\x78\xea\xaa\xea\xa4\x3a\x5d\x58\xce\xab\x56\xe9\xb3\ +\x67\xce\x78\x3d\xab\x56\x71\x91\x88\x82\xfe\x7e\x4d\x07\x0e\x78\ +\x7a\xf5\x6a\x7e\xf9\xbe\x4c\x8c\xac\x24\x2c\x26\xfb\x07\x2b\x68\ +\x67\x85\xeb\xac\xa9\xd7\x7c\x87\x99\x29\x8e\x63\xbe\xff\xfe\xcf\ +\xa8\x5f\xfb\xb5\xbf\xd0\xc0\xb9\x3f\x1a\x1f\xdf\xfb\x4b\xe8\xbc\ +\xc5\xdf\x02\x16\x4f\x92\xb6\x19\x24\xab\xa1\x7a\x39\x6c\x1f\xba\ +\x02\xc9\x33\xe8\xa6\xc1\x79\x34\x3e\x39\x26\x43\x92\xe4\x34\x2b\ +\xe1\x8d\x75\xad\xaf\x67\xce\x73\x01\xe9\xde\xf7\xb2\xf9\x0c\xd4\ +\xd9\x9e\x66\xa2\x21\x99\xa8\x1b\xcd\x04\xe4\xfd\x5a\x8d\xf6\xf5\ +\x3a\x6a\xe6\xbc\x2b\xc9\xfc\x70\x0c\x29\x19\x11\x92\x4c\xe6\x6c\ +\x56\xad\x1c\x1a\x5f\x34\xb7\x5e\x18\xf2\x62\x3f\x8d\xe6\x89\x0e\ +\xa0\x7d\x05\x6b\x0c\x11\xee\x49\xeb\x97\xa5\xcd\x38\x44\x18\xf6\ +\xa2\xfd\x5c\x53\x9c\x60\x7d\x65\xda\x49\xb0\x5a\x26\x20\xc2\x26\ +\x84\x08\xd7\x76\x1d\x74\x2e\x45\x19\x52\xdb\xee\x20\x64\x61\xa9\ +\x19\x62\xb5\xf6\xd8\xa7\x20\x19\x7b\xdb\x31\x6b\x6f\x3b\x0a\x56\ +\x00\x40\x14\x45\x7b\xa3\x28\xfa\xd2\x91\x23\x47\xde\xfc\xc0\x03\ +\x0f\x2c\xdf\xbc\x79\x33\x6d\xd8\xb0\x01\x30\x65\x6c\x30\xe7\x0a\ +\x4c\x98\x0d\x57\xe5\x8b\x27\x88\x56\xcc\x5a\x41\xfb\x22\x33\x97\ +\x79\x79\x8e\x2a\x3f\xbb\x51\xf7\xfc\xea\xd7\x02\xb5\xcc\xaf\x0e\ +\xf7\x0f\xa0\x7c\xf5\x8a\xe2\x9a\x8d\x2a\x08\xbe\x7c\xc4\x1f\x2b\ +\x06\x65\xbd\xb2\x90\x5f\xb9\x32\x9e\x62\xe6\x6e\xa5\x28\xcc\x64\ +\xe8\xc2\xf0\x30\x55\xfb\xfa\xf4\x8b\x4a\xa9\x15\xb5\xd6\xdb\x5a\ +\xf1\x6a\x8f\x69\xad\xb0\x36\x01\x54\x6d\x5b\x9f\x7d\xf6\x59\xbc\ +\xf3\x9d\xf7\xe0\x1b\xdf\xd8\x33\x3a\x33\xf3\x6f\x3f\x51\x2e\x8f\ +\xfe\x5d\x83\x2f\x67\xa3\x70\x82\x75\x7e\x68\xb3\x6f\x05\xe9\x3f\ +\x5b\x21\x64\x6c\x16\xdf\xbd\xb8\x72\xa9\x9c\xb4\xd0\x90\x39\x6d\ +\x01\x8d\x9d\xd3\x4e\x40\xac\xc5\x83\xa8\x6f\x0e\x3e\x0d\x69\x67\ +\x9a\x4c\xa1\x79\xa2\xb5\x0a\xe9\xc7\xeb\x49\x6e\xd4\x2c\xc1\x0a\ +\xc8\x75\x3e\x03\x59\xb8\x69\xc7\x30\x48\x27\x58\x17\x48\x08\x59\ +\x95\x1a\x45\x7b\x65\x69\x65\xc8\x8d\x7c\x16\x92\x05\xae\x19\x9d\ +\x5d\x2d\x49\x04\xeb\x49\xc8\x7d\x49\x3b\x51\xc9\x08\x16\x5e\xdc\ +\xbb\x99\xd8\x49\xfa\x05\x88\x70\x6b\x65\x07\xa1\x21\xcf\xcf\x61\ +\xc8\xa0\xdd\x2c\xd7\x10\x27\x58\xd3\x45\x43\x16\x1b\x5e\x84\xf4\ +\x01\x5d\x68\x4f\xcb\x21\x43\xae\xe1\x29\xcc\x89\xd4\x11\xb4\xce\ +\x7a\x65\xbd\x68\xa6\x20\xa9\xf6\xdb\xa9\x44\xc3\x14\x1a\x37\x49\ +\x4f\x83\xd1\x52\xa9\xf4\x7f\x00\x0c\x3f\xfc\xf0\xc3\x6f\xde\xbd\ +\x7b\x77\x70\xe3\x8d\x37\x72\x6f\x6f\x6f\xad\x58\xb5\xd0\xc5\xff\ +\x8f\x88\x34\x11\x45\x00\xce\x32\x73\x16\x22\x16\x8e\x13\xd1\x00\ +\x77\x65\xa2\xca\xaf\xbe\x2a\xd3\xfd\x5f\x1e\xf3\xbb\x1e\x3f\x89\ +\xea\xdb\x36\xb2\xee\xca\xa8\x89\x0d\xab\xa9\xfb\xd4\x04\x96\x1d\ +\x18\x56\x33\x3a\x13\xe4\xaf\xca\x04\x00\xca\xb9\x1c\x17\xc6\xc6\ +\xd4\x71\x22\x6f\x53\xa1\xc0\x0c\x79\x0f\x7a\xcc\x71\x50\x73\xdc\ +\x59\x6b\x6f\x8d\x7b\x32\x03\xa0\xc9\xc9\x49\xfe\xbd\xdf\xfb\x53\ +\xba\xfb\xee\x07\x74\x18\xbe\xf8\x89\x89\x89\x3d\x3f\x83\x36\x5d\ +\x30\x98\x27\x4e\xb0\xce\x1f\xc6\x5c\x89\x9a\x66\x2f\x26\x8f\x43\ +\x5c\x55\x4f\xa1\xb9\xae\x99\x1a\x32\xa7\x9d\x81\xbc\x7b\x69\x8e\ +\x17\x11\xc4\xbb\xcd\x26\xba\xdc\x8a\xfa\xc4\xe1\x24\x64\xbc\x4f\ +\x9b\x29\xc8\xbd\x6e\xa4\x87\xcd\x39\x88\xb5\x7c\x05\x64\x3c\x5e\ +\x28\x21\x64\x11\xa3\x59\x54\x21\x73\xf2\x10\xd2\xe6\x76\x5a\xf8\ +\x4e\xb3\xac\xd5\x2b\xb1\x28\x04\xab\xc5\xba\xad\x9d\x81\xdc\xd0\ +\x1e\xb4\x66\x45\x2e\x84\xf8\x9f\xef\x81\x0c\xaa\xcd\xce\x7e\x6b\ +\x49\x22\x58\x0f\x41\x26\xad\xd3\x90\x01\x22\xa9\x4b\xce\x38\x64\ +\x85\xf2\x79\xb4\x57\xbd\xd9\xcb\x31\x0d\xb9\x77\xe3\x90\x67\xa8\ +\x80\xe6\x74\x12\x1a\xd2\x59\x1f\x85\x0c\x28\xd6\x0d\xb3\x99\x83\ +\xa5\x13\xac\x8d\x21\x86\xdc\xdb\x21\x48\x5b\x3d\xc8\xbb\xd5\xca\ +\xc1\xa7\x08\x11\x85\x47\x21\xf1\x32\x27\x20\x9d\x7a\x5a\xe5\x1a\ +\xd2\xa0\x08\x79\x17\x4b\x90\x67\xb3\x55\xd9\x7e\x2b\x10\xb1\xb5\ +\x1f\xc0\xb1\x16\xb5\x61\x41\x54\x2a\x95\x67\xab\xd5\xea\x5f\x4d\ +\x4f\x4f\x6f\xbc\xff\xfe\xfb\xb7\x8d\x8d\x8d\xd1\xf6\xed\xdb\xa9\ +\xbb\x7b\xce\x68\x5d\x63\xc9\x04\xa4\x9f\x39\x43\x44\x39\xad\x35\ +\xdb\xbf\x29\xa5\x14\x80\xd5\xcc\xfc\x02\x11\x0d\x80\x08\xd5\x77\ +\xef\xa0\xca\x77\xc7\xca\xd7\xfe\x8f\x6f\x76\xbf\xb4\xfe\xea\xf8\ +\xda\x1b\x73\xf4\x02\x7a\x68\x62\xb0\xbf\xec\xbf\x30\xd9\xbd\xea\ +\xf0\x30\xa9\x91\x99\x00\x57\xf5\x9e\x5c\xb1\x0a\xd7\x0c\x0f\x2b\ +\x95\xcd\xea\x72\x10\xa0\x0b\x73\x63\xc0\x18\x80\xae\x5a\xe1\x5a\ +\x63\x71\xc5\xc4\xc4\x04\xdd\x7b\xef\x5f\xf1\x07\x3e\xf0\x3f\xf9\ +\xc4\x89\x91\xef\x4e\x4f\xff\xdb\x2d\xa5\xd2\xd8\x17\xd0\xfc\xc5\ +\xdf\xb4\x71\x82\x75\xe1\x94\x20\x93\xf6\x22\xd2\x99\x93\x5c\x89\ +\x31\xc8\x7b\x9e\x66\xe9\x9a\x7a\x98\x82\x9c\x73\x04\x99\xcf\x26\ +\x11\x70\x56\x64\x7d\x0f\x73\xf9\x5f\x6c\xdd\xda\x7a\x98\x40\xe3\ +\xc6\xdb\x12\xa4\xaf\xf5\x21\xa5\xce\xd2\x9a\xc7\xcf\x60\xee\xbe\ +\xc6\x00\xae\x45\x7d\xcf\x51\x15\xad\xf1\x10\x9c\x40\x7a\xcf\x43\ +\x12\x8a\x90\xb9\xc2\x5e\xc8\xc2\x4a\xb3\x68\x0b\xc1\xda\x28\x51\ +\xe9\x41\x62\x12\x07\xcc\xa7\x91\xd6\xb2\x2a\x64\xd5\xe6\x34\xa4\ +\x33\x68\x87\xe0\xf1\x41\xd4\x5f\x54\xfc\x29\xbc\x3c\xa9\x55\x1e\ +\x92\xbd\xae\x1f\x62\xed\x78\xa5\x17\x85\x21\x9d\xed\x79\x88\xe8\ +\x9a\xae\xb3\x1d\xed\x82\x7d\x96\x56\x9a\x4f\x2f\xd2\x79\x6e\x35\ +\x44\xbc\x8c\x42\xae\xd5\x38\x5a\x3f\x19\xeb\x02\x70\x4d\x9d\xdb\ +\x0e\x23\x59\xd2\x88\x00\xc0\x75\x75\x6e\x3b\x8e\xc6\xac\xf8\x36\ +\x12\x05\x59\x31\x5d\x6d\x7e\xf6\xa2\x71\x02\x36\x84\xdc\x1b\xfb\ +\x19\x43\x7b\x09\xd3\xf9\x40\x90\xeb\x74\x15\x64\x31\xae\xd1\xe2\ +\xb5\x08\x79\x2f\xcf\x9a\x9f\x9d\x9c\x00\xe3\x55\x83\x83\x83\x7f\ +\x76\xfe\xfc\xf9\x3b\xee\xbc\xf3\x4e\xfa\xd0\x87\x3e\x84\x8d\x1b\ +\x65\xec\xb7\x35\x58\x89\x68\x12\x40\x17\x33\x1f\xd1\x5a\x6f\x52\ +\x4a\x11\x11\x9d\x65\xe6\x75\x00\xca\x44\x94\x65\xe6\x49\xc8\x3d\ +\x88\x00\xcc\x1c\xdb\x13\xf5\x6e\xfd\xad\xaf\x70\x3e\xab\xe9\xb9\ +\xff\x76\x27\x77\x5f\x97\x9f\x1c\x1a\xf2\x7a\x5e\xfd\xea\xc8\xcb\ +\xcd\x94\x8a\x99\xa7\x86\xf3\x54\xd5\xa1\x0e\x54\x76\x5f\xb4\x6a\ +\x6a\xd3\x4f\x75\xfb\x41\x56\xe5\x00\xec\x63\xe6\x57\x31\x73\x85\ +\x88\x72\x90\xcc\xbf\x20\x22\x9c\x3f\x7f\x1e\x7f\xf9\x97\x9f\xe5\ +\xbf\xfd\xdb\x47\x90\xcb\x61\xe8\xfc\xf9\x27\x3e\x08\xe0\x5f\x5b\ +\x74\xdd\x1a\xc1\x4a\x00\x3f\xd2\xea\x46\xa4\xc4\x08\x64\xbe\xd0\ +\x6c\x96\x41\x6a\x37\xaf\x46\x3a\xae\xb3\x53\x90\x39\xdc\x4b\x68\ +\xcf\xf9\x0a\x41\x9e\x9b\x35\x90\xf7\x6f\x3e\x06\x99\x2a\xa4\x9f\ +\x3f\x63\x3e\x17\x27\x8b\x2a\x00\xb8\xbd\xce\xf6\x1c\x85\x18\x36\ +\x1a\x4d\x01\x52\xf2\xe6\x2a\xd4\xdf\xdf\x4f\x43\x16\x19\x2f\xf6\ +\x54\x7b\x23\xea\xcb\x44\x3d\x0d\x49\xac\xd8\x4a\x14\x44\xd7\xd8\ +\x77\xa0\x91\x79\x32\xac\xf7\xd5\x79\x88\xc6\x69\x55\x62\xb0\x3c\ +\x80\x1f\xaf\x73\xdb\xd4\x9e\xd7\x66\x58\x41\x09\xf2\x82\xf7\x99\ +\xcf\x32\xc8\xc9\xd7\xf3\x02\x54\x20\x2e\xa3\x93\x90\x15\x8f\x09\ +\xb4\x5f\x36\x3b\x20\x5d\xc1\x5a\x0b\x41\x44\x4d\x1e\x22\x5c\x03\ +\xf3\x33\x32\x9f\x19\xc8\x44\x6f\x31\x67\xfa\x24\xcc\xc5\xd7\xe5\ +\x21\x8b\x21\x59\xc8\x75\xb0\x62\xde\xd6\x0b\x8c\xcc\x4f\x5b\xac\ +\x79\x06\xf2\xbc\x5c\x40\xe7\x25\x0b\x71\x34\x16\xdb\x4f\x2d\x83\ +\x0c\xd4\x79\x88\x35\x21\x07\x79\xbe\x08\x97\x5e\x2c\xb2\xcf\x58\ +\xd5\x7c\x6c\x02\x0b\xfb\x9c\xcd\x60\xf1\x3d\x6b\x04\x99\x6c\xac\ +\x84\xb8\xcd\xf5\x40\xfa\xa5\x7a\xc7\x13\xdb\xaf\x17\x21\x0b\x48\ +\xa3\xe8\x3c\x41\x3f\x1f\xae\xbf\xfe\xfa\xeb\xef\x7f\xe1\x85\x17\ +\xde\x74\xfb\xed\xb7\xab\x77\xbd\xeb\x5d\x7c\xc7\x1d\x77\x20\x9b\ +\xcd\x46\x2c\xec\x55\x4a\xbd\x86\x99\xa7\x4c\x7c\xeb\x0a\x88\x60\ +\x1f\x80\x4c\xd4\xba\x30\xe7\xbe\x4b\xfb\xf7\xab\xd0\xf3\x40\x3b\ +\xb2\x13\x54\xf8\xc0\xd7\xfd\x72\x89\x71\xf2\x3d\x37\xea\xf1\x5b\ +\x37\xd2\xb6\x6d\x31\x9b\x6d\xfa\x54\xcc\x67\xe9\xc8\xf8\xaa\x93\ +\x8f\x4c\x87\xd7\xae\x0b\x8b\x14\xd0\x0a\x55\x0c\x8f\x70\x77\xb0\ +\x09\x00\x58\x91\xda\xbb\x77\x2f\x3d\xfa\xe8\x73\xf8\x97\xe7\xbe\ +\xc7\x27\xd6\x65\x0e\x9c\x3b\xf7\xc4\x7b\x67\x66\x66\x9e\x6e\xd5\ +\x85\x6a\x20\x4e\xb0\xa6\x4b\x0e\xd2\x67\x2e\xc3\xdc\xdc\x24\x0b\ +\x99\x9b\x90\xf9\x19\x42\x9e\xdb\x10\xf2\xae\x97\xf0\xf2\x79\x5c\ +\xa5\xe9\xad\x4e\x86\xc2\xdc\x18\x61\xe7\x1d\x04\x39\xbf\x2a\xe6\ +\xd7\xe7\xaf\x01\xf0\xba\x3a\x8f\xff\x7d\x34\xd7\x2d\xdf\x2e\x56\ +\xda\xfe\xde\xde\xe7\x4b\xf5\xf7\x65\x48\xbf\x33\x06\x59\x84\xb8\ +\x9c\xc0\xfa\x29\xd4\x67\xa5\x6c\x87\x67\xbe\x16\x1b\xe3\xbd\x12\ +\xa2\x6f\xba\x91\x2c\x34\xd2\xbe\x1b\xd3\x98\x73\xc7\x6f\x87\xf9\ +\xfc\x92\x11\xac\x97\xc3\xc3\xdc\xa4\x50\x99\xdf\xed\x8b\x1f\x43\ +\x2c\x60\x76\x32\x68\x27\x81\xed\x60\x3d\x9d\x0f\x8d\x12\xac\x0e\ +\x87\xa3\xb5\x58\xe1\xda\x09\xee\xf5\xcd\xc4\x4e\xe2\x32\x90\x3e\ +\x3d\x03\xe9\xd3\xed\xa4\xd5\xf6\xe5\xb5\x8b\x48\x76\x70\x6e\x87\ +\x01\xb9\x99\x0c\x6e\xdc\xb8\xf1\xb7\x2b\x95\xca\x07\xc7\xc7\xc7\ +\xb3\xb7\xdc\x72\xcb\xb1\x0f\x7c\xe0\x03\x99\xdb\x6e\xbb\x6d\xad\ +\xef\xfb\x4c\x44\x15\x66\xce\x13\x91\xd2\x5a\x33\x80\xc0\xa4\xeb\ +\xb5\x89\x9b\x88\x88\xa2\x63\xc7\x08\xd9\x2c\x51\x36\x0b\x5a\xb9\ +\x32\x8a\x8e\x7e\x5f\xa9\x9d\x7f\xf6\x75\xbf\x74\x70\x0a\xdd\x2b\ +\x09\xe1\xbb\xb7\x73\xe9\x97\xb6\x69\x22\xaa\x12\x91\x1f\x45\x3a\ +\x7e\xee\xb9\x0c\x76\xee\x0c\x67\x80\x78\xd9\x93\x4f\x3e\x79\xe8\ +\xd3\x9f\xfe\xc7\xbe\x5d\xbb\xf6\xac\xc8\xe7\x73\x5e\x6f\x6f\xf9\ +\x0b\x43\x43\xbb\xff\x08\x12\x3e\xb2\x58\x71\x82\xd5\xd1\x0e\x6c\ +\x03\xb0\xa9\xce\x6d\xdb\x61\x8e\x68\xc7\x41\x3b\x67\xb7\x46\x93\ +\xf9\xcc\xd1\x93\x58\x97\x4f\x42\xdc\x61\xdb\x19\x1f\x73\xda\x26\ +\x03\x19\xff\x3c\x48\xdf\x6d\xe7\x0e\x76\x0c\xb4\xe3\xa1\x35\xa6\ +\xb4\xab\xc6\xb9\xdc\x82\xfd\x7c\xd0\x48\xc9\x7b\xb1\xdd\x53\x58\ +\x77\x2a\x4e\xb0\x3a\x1c\x0e\x87\xe3\x95\x78\x5d\x2e\x97\x7b\x7f\ +\x18\x86\x3f\xe7\xfb\x7e\xff\x86\x0d\x1b\x4e\xbe\xe3\x1d\xef\x18\ +\xbc\xf5\xd6\x5b\xe3\x9d\x3b\x77\x06\x44\x54\x22\xa2\x6e\x22\xaa\ +\x9a\x24\x4c\x31\x64\xf2\xc3\x00\x70\xf8\xb0\x07\x22\x60\xf3\xe6\ +\x88\x88\x88\x0f\x1c\xf0\xa8\xb7\x57\xeb\xb3\x47\x35\xdd\xf6\xf0\ +\xa3\x5a\x1d\x18\x51\x00\x58\x13\x51\x29\xac\xe0\x5c\x79\x52\x7f\ +\xb4\x54\x9e\xfc\xf2\xc8\xae\x9e\x6a\x35\x9c\xc9\xe5\xf4\x23\x33\ +\x33\xfb\xfe\x1c\xc0\xb7\xd0\xbe\x93\xa5\x34\x71\x82\xd5\xd1\x6a\ +\x08\x62\xad\xaa\x37\x89\xd5\x37\xd0\xba\xfc\x2c\x69\x70\x0d\x80\ +\x57\xd7\xb9\xed\x21\x34\x2f\x4b\xb0\xa3\xcd\x70\x82\xb5\x31\x38\ +\xc1\xea\x70\x38\x1c\x8e\x85\xb0\x05\xc0\xed\x85\x42\xe1\xa7\xa3\ +\x28\xba\x35\x8e\xe3\xfc\x75\xd7\x5d\x87\xf5\xeb\xd7\x57\xb7\x6f\ +\xdf\xde\xb5\x79\xf3\xe6\x78\xcd\x9a\x35\xde\xb2\x65\xcb\xd0\xdd\ +\xdd\x8d\xae\xae\x2e\x0c\x0f\xf7\xc1\xf3\x14\xd6\xae\x9d\x40\xb1\ +\x58\xc4\xb1\x63\x11\xb4\x1e\xc7\xb7\xbf\x9d\xd1\xf9\xfc\xb7\xd4\ +\x9e\x3d\x67\xcb\x27\x4f\x0e\xfb\x27\x4e\x9c\xd0\x00\xeb\x37\xd1\ +\xfa\xc3\x61\x3c\xf4\xb5\x47\xf5\xfe\x07\x21\xae\x85\x4b\x41\xa4\ +\xd6\x92\x81\xb8\xf0\x2d\x06\x2a\x10\x97\x5a\x47\x67\x91\x44\xb0\ +\x5d\x00\xf0\xcd\x14\xdb\xd2\x0a\x7e\x0c\xe2\x42\x5e\x0f\x4f\x40\ +\xdc\x64\x1d\x4b\x10\x27\x58\x1b\x83\x13\xac\x0e\x87\xc3\xe1\xa8\ +\x17\x02\xb0\x1e\xc0\xf5\x00\xb6\xf4\xf6\xf6\xbe\xb6\xbb\xbb\xfb\ +\x86\x38\x8e\xd7\x01\xe8\x2d\x97\xcb\xfe\xd4\xd4\x14\x31\xf7\x02\ +\x78\x2d\x80\x53\xe8\xee\x5e\xce\x99\x4c\x5e\x03\xf9\x0b\x9e\x87\ +\xd1\x72\xd9\x3b\x30\x3d\xfd\xd8\xb7\x80\x0b\x07\x20\x96\x89\x21\ +\x2c\x3d\xf7\x6b\x87\x63\x3e\x10\xc4\x8d\x93\xd1\xd8\x9c\x03\x3d\ +\x00\x7e\x14\xf5\x27\xea\xe9\x04\x97\xd8\x2b\xb1\x0e\xc0\x0f\xd7\ +\xb9\x2d\x03\xd8\x05\xd7\x87\x2d\x59\x9c\x60\x6d\x0c\x4e\xb0\x3a\ +\x1c\x0e\x87\xa3\xa1\xe4\x72\xb9\x8f\xc5\x71\xbc\x21\x0c\xc3\x77\ +\xb7\xba\x2d\x0e\x47\x07\x93\x01\x70\x87\xf9\xf7\x0c\x24\xeb\x7e\ +\xda\x59\x59\x07\x00\xec\x44\xb2\x0c\xeb\x8d\x9a\x1f\xae\x83\xc4\ +\x28\xda\x4c\xf6\x8d\xa0\x07\xc0\x2d\xa8\x3f\x16\x72\x0c\xc0\xbf\ +\xa5\xd7\x1c\x47\xa7\xd1\xaa\x5a\x42\x0e\x87\xc3\xe1\x70\x38\x12\ +\x50\x2e\x97\xff\x08\xed\x55\xcc\xde\xe1\xe8\x74\x0a\x90\x12\x6f\ +\xd7\x41\xdc\xae\x6d\xe6\xf2\x31\x2c\xbc\x36\xbb\x0f\x11\x83\xd7\ +\x40\xb2\xc8\x26\xa1\x82\x94\xea\x59\x5e\x82\x2d\x90\xec\xbf\x80\ +\xb8\x1d\x9f\x86\x64\xf9\x1d\x47\xf2\x92\x62\x0a\x52\xfb\x78\x1b\ +\x92\x69\x8e\x66\xd4\x1c\x76\xb4\x31\x4e\xb0\x3a\x1c\x0e\x87\xc3\ +\xd1\x99\x2c\xb6\x92\x49\x0e\x47\x3b\x91\x85\x08\xce\x75\xe6\x77\ +\x0d\x29\x39\x32\x05\x79\xf7\x42\xcc\x65\x7d\xb5\x65\x06\x7d\x88\ +\xf8\xb3\xa5\x7e\xd2\xf2\x64\x3c\x8e\xe6\xd4\xa3\xee\xc2\x9c\x60\ +\x8f\x21\x42\x7d\x0c\x62\x79\x9d\xc2\xfc\x4a\x8e\xf9\x90\xf3\x1f\ +\x80\x78\x1c\x26\xad\xdb\x1d\x43\x44\xb4\x63\x09\xe3\x04\xab\xc3\ +\xe1\x70\x38\x1c\x0e\x87\xc3\x71\x65\x14\xe6\xea\xce\x36\x93\x2a\ +\x9a\x5b\x7b\xd5\xe2\x01\x58\x65\x3e\xb5\x6d\xb9\x80\x97\x8b\x75\ +\x5b\xb2\xc5\x96\x74\xe9\x42\xba\x9c\x44\x67\x67\x46\x76\xa4\x80\ +\x13\xac\x0e\x87\xc3\xe1\x70\x38\x1c\x0e\x47\x7b\xb2\x1f\xed\x93\ +\x6c\x28\x83\xe4\x16\xd3\x85\x10\x01\x38\xd6\xc4\xe3\x39\xda\x14\ +\x17\xfb\xe2\x70\x38\x1c\x0e\x87\xc3\xe1\x70\xb4\x1f\x67\xb0\xb4\ +\xe3\x37\x0f\x61\x7e\x6e\xc8\x8e\x45\x8e\x13\xac\x0e\x87\xc3\xe1\ +\x70\x38\x1c\x0e\x47\x7b\x31\x09\x60\x4f\xab\x1b\xd1\x42\xce\xa1\ +\x35\xae\xd0\x8e\x36\xc4\x09\x56\x87\xc3\xe1\x70\x38\x1c\x0e\x87\ +\xa3\x7d\x98\x04\xb0\x1b\xed\xe3\x0a\xdc\x6c\xa6\x00\x3c\x8b\xe6\ +\x24\x9a\x72\x74\x00\x2e\x86\xd5\xe1\x70\x38\x1c\x0e\x87\xc3\xe1\ +\x68\x0f\x4e\x03\x78\x0e\x4b\x57\xac\x8e\x03\x78\x1a\x4b\xf7\xfc\ +\x1d\x97\xc0\x09\x56\x87\xc3\xe1\x70\x38\x1c\x0e\x87\xa3\xb5\x94\ +\x01\x1c\x00\x30\xdc\xea\x86\xb4\x08\x06\x70\x02\xc0\x41\x48\x09\ +\x21\x87\x63\x16\x27\x58\x1d\x0e\x87\xc3\xe1\x70\x38\x1c\x8e\xd6\ +\x50\x06\x30\x04\x11\x6b\x71\x6b\x9b\xd2\x32\x26\x21\xd9\x90\xc7\ +\x5a\xdd\x10\x47\x7b\xe2\x04\x6b\x63\x18\x05\xf0\xdd\x3a\xb7\x9d\ +\x4a\xb3\x21\x0e\x87\xc3\xe1\x70\x38\x1c\x8e\xcb\x12\x01\xd8\x07\ +\xa0\x0f\x52\x63\xb5\x1b\x00\x35\xf8\x98\x15\x00\x23\x10\x6b\xea\ +\x08\x96\x66\xac\x26\x43\xe6\xcb\x27\x20\xd9\x90\x1d\x8e\xcb\xd2\ +\xe8\x17\xd2\xe1\x70\x38\x1c\x0e\x87\xc3\xe1\xe8\x14\x3c\x00\x5d\ +\xe6\xd3\x6d\x7e\xe6\x21\xf5\x47\xb3\x58\x58\x1d\x52\x06\x50\x02\ +\x30\x03\xa0\x08\xb1\x24\x4e\x00\x98\x4e\xb1\xbd\x49\xc9\x43\x84\ +\xba\x15\xec\x3d\x00\x72\x0d\x3a\x56\x04\x89\x51\x3d\x07\xe0\x2c\ +\xe4\xba\x38\x1c\xaf\x88\x13\xac\x0e\x87\xc3\xe1\x70\x38\x1c\x0e\ +\xc7\xfc\x20\x88\x70\x55\x10\x71\x5b\xfb\x33\x82\x88\xd4\x18\x40\ +\xd5\x7c\x3a\x11\x1f\x73\xa2\x3d\x0f\x39\xdf\xda\x8f\x87\x1f\x3c\ +\x77\x86\x9c\xbf\x86\x9c\x77\x88\x97\x8b\xf5\x29\xf3\x73\x29\x5a\ +\x93\x1d\x09\xf9\xff\xf0\x09\xdb\x36\xde\xf5\x1d\xd7\x00\x00\x00\ +\x00\x49\x45\x4e\x44\xae\x42\x60\x82\ +" + +qt_resource_name = b"\ +\x00\x09\ +\x0c\x78\x54\x88\ +\x00\x6e\ +\x00\x65\x00\x77\x00\x50\x00\x72\x00\x65\x00\x66\x00\x69\x00\x78\ +\x00\x0a\ +\x0c\x2b\x9a\xe7\ +\x00\x6f\ +\x00\x70\x00\x67\x00\x65\x00\x6f\x00\x32\x00\x2e\x00\x70\x00\x6e\x00\x67\ +" + +qt_resource_struct_v1 = b"\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\ +\x00\x00\x00\x18\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ +" + +qt_resource_struct_v2 = b"\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\ +\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\ +\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x18\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ +\x00\x00\x01\x89\x2c\x0f\xba\x65\ +" + +qt_version = [int(v) for v in QtCore.qVersion().split('.')] +if qt_version < [5, 8, 0]: + rcc_version = 1 + qt_resource_struct = qt_resource_struct_v1 +else: + rcc_version = 2 + qt_resource_struct = qt_resource_struct_v2 + +def qInitResources(): + QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) + +def qCleanupResources(): + QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) + +qInitResources() diff --git a/help_ogp.txt b/help_ogp.txt new file mode 100644 index 0000000..ba1ee05 --- /dev/null +++ b/help_ogp.txt @@ -0,0 +1,147 @@ +** IMPORTANT NOTE FOR DATA IMPORT** All CSV’s must contain a column header titled “hole_id”. This is what populates your selection boxes. Any desurveyed data must contain columns “x”, “y” and “z” matching exactly, no uppercase. + +This application is designed to import, process, and visualize geological drill hole data. The application uses a graphical user interface built with PyQt5, a Python binding for the Qt application framework. + +When you start the application, you will be presented with a main window. The main window provides you with controls for importing data, selecting hole IDs, managing attributes, and generating plots. + +Import Data: The import buttons allow you to import your drill hole data. The data should be in a .csv format and contain columns for "hole_id" and depth, as well as any other attributes you are interested in. The program relies on a good clean CSV and does not provide any data manipulation in the table once it is imported. Please ensure your data does not contain NaNs (less than symbols etc) or inf values for numerical data. Most importantly, please ensure your column name for the hole ID is "hole_id" the program relies on this exact naming of the hole ID column. + +Hole IDs Tables: Please ensure your column name for the hole ID is "hole_id" the program relies on this exact naming of the hole ID column. Each Table is populated with unique hole IDs corresponding to the type of CSV you import (Lithology, Structure, Geochem etc). You can select multiple holes, but you always must select at least one. + +Saving Data: Once your data is imported, you can click file → save to save the datasets in the program. The save will preserve the populated hole_id tables, but not the check state of the hole_ids. The save button will also save the state of your customized attributes. Please ensure to add “.pkl” to the end of your saving name. Example: dont save as “drill_holes” save as “drill_holes.pkl” + + +GRAPHIC LOGS: The Graphic logs can be plotted using depth in meters in or feet. The sliding bar from ft to meters is to change the label of the y-axis not convert ft to meters or vice versa. Select your from_depth and to_depth columns. Once you select a column that represents lithology, you can customize by color and by width along the X-axis. The width values range from 0.0 to 0.5. 0.5 being the longest width. Selecting multiple hole_ids will place them in the same window and along the same depth axis as the deepest hole. + +XY SCATTER PLOT: This plots the values of two attributes against each other for each sample in the selected hole IDs. You can choose which attributes to plot on the x and y axes. you can further choose a categorical or numerical column to stylize the points, categorical data using tab10 coloramp and numerical data uses r_spectral coloramp + +DOWNHOLE LINE PLOTS: This creates a line graph for a selected attribute. Depth is increasing down the y-axis. You must select a depth column. Either calculate a center depth in excel for each data point or use your from_depth or to_depth column. There is an option to plot with bars instead of a line graph. + +MERGING LINE PLOTS WITH A GRAPHIC LOG: Create a graphic log of one hole_id. (be sure to only have one graphic log open) Next, create up to 7 downline plots of the same hole_id. With the plots still open, you can click ‘merge plots’ to place them in the same window and on the same depth axis as the graphic log. Once open, press anywhere on the plot to draw a red line ruler across the window. + +CORRELATION MATRIX: This plot will pull all data in the geochem CSV that ends in the user selected “ending tag”. For example if you want to run it on all data that ends in “_ppm” it will only pull columns that end in “_ppm”. If you have data that has percent, ppm, ppb, ect you can simply concatenate an ending tag in excel like “_FA”, then choose “_FA” as your ending tag in the program. + +CUSTOM PLOT: The custom plot button allows you to upload a custom plot in a .json format. These plots can include polygons drawn onto the plot, where any data points that fall within these polygons can be attributed to a new column in your data frame and exported to CSV. Example of a custom plot in .json format: + +{"polygons": [{"name": "Theolitic", "points": [[0, 0.3105802048], [1.294871795, -1.999], [1.292307692, -2], [0, -2]], "style": {"fillColor": "#FFFFFF", "fillOpacity": 1, "borderColor": "#000000", "borderWidth": 1}, "label": {"position": [0.401282050824999, -1.4223549488], "color": "black", "fontsize": 9, "ha": "center", "va": "center"}}, {"name": "Transitional", "points": [[0, 0.3105802048], [1.294871795, -1.999], [1.294871795, -1.3], [0, 1]], "style": {"fillColor": "#FFFFFF", "fillOpacity": 1, "borderColor": "#000000", "borderWidth": 1}, "label": {"position": [0.6551282051899999, -0.5002559728], "color": "black", "fontsize": 9, "ha": "center", "va": "center"}}, {"name": "Calc-alkaline", "points": [[1.294871795, -1.3], [0, 1], [1.294871795, 1]], "style": {"fillColor": "#FFFFFF", "fillOpacity": 1, "borderColor": "#000000", "borderWidth": 1}, "label": {"position": [0.8683760684599999, 0.26279863466666664], "color": "black", "fontsize": 9, "ha": "center", "va": "center"}}], "title": "Magmatic Affinity Diagram: Ross and B\u00e9dard (2009)", "x_label": "(log) Zr/Y", "y_label": "(log) Th/Yb", "xlim": [0.01, 10]} + +DESURVEYING YOUR DATA + +You will need three CSV’s to desurvey your data. 1) A collar table 2) A survey table, and 3) A table with your data attributed to depth. It is important that data is desurveyed using a coordinate system in meters (UTM Zone) and that the column you use for depth is in meters. When surveying data, use your ‘to_depth’ column rather than your ‘from_depth’ because the cross section will draw lines uphole to the next data point, not downhole to the next data point. The program will return a CSV with added columns x, y, and z to the CSV you choose for your data. You can now add this CSV to the “upload desurveyed data” button. (remember you will still need a column named exactly “hole_id”) + + +CROSS SECTION VISUALIZER + + The 'Cross Section Visualizer' is a tool designed to take desurveyed drill hole data in a CSV format, with columns for x, y, and z coordinates, as well as any number of attribute columns. +** location column names must be exactly “x”, “y” and “z” + + To use this tool, you will need to follow these steps: + +Load the data: Ensure it is formatted correctly with the necessary x, y, z coordinates, and the hole identifiers. Optionally, you can also have attribute columns, which are useful for representing different geological features. + +Select the holes: You can choose as many drill holes as you'd like to include in your cross-section. This is done by providing the identifiers of the holes you're interested in. + +Set the azimuth: The azimuth represents the direction you are viewing. So if you set your azimuth to 0 or 360, you are viewing north and your cross section line runs east-west This can be any angle between 0 and 360 degrees. + +Choose an attribute (optional): If your data includes attribute columns, you can choose one to visualize on the cross-section. This can represent both categorical and continuous (numerical) data. + + For numerical attributes, the tool will represent each value on a color gradient scale, with the option to remove outliers from the color coding for better visibility. The range of the color scale will be adjusted automatically based on the minimum and maximum values in your data. + + For categorical attributes, you will have the option to specify a color and a line width for each unique value in the attribute column. If not specified, the tool will automatically assign different colors to each unique value. + +Visualize the data: After setting up your parameters, the tool will generate a 2D cross-section of your drill hole data. Each hole is represented as a line, with the attribute values (if chosen) represented by the color of the line. + +Once the selected hole and parameters are set you can click "view in 3d" for a 3d visualization. + +Each time you generate a plot, a new window will open with the plot. The window includes navigation controls for zooming and panning the plot. + + +Plot Settings + +Outlier Handling: Users can opt to remove outliers from the color ramp through the 'Remove Outliers' checkbox. If selected, outliers can be defined based on upper and lower quantiles and an Interquartile Range (IQR) scaling factor, which the user can input. The IQR scaling factor determines how the data is shown on the color ramp, if you have a low scaling factor (1.5), the data will display as more closely clustered around the median, with a tighter range for identifying outliers. This means that the plot may show more data points as outliers, potentially leading to a more conservative representation of the central trend in the data. iIf you have a high scaling factor (10), the data will display as more spread out, with a broader range for identifying outliers. This results in fewer data points being classified as outliers, highlighting only the most extreme variations. Additionally, there's an option to apply these outlier settings to an auxiliary bar plot as well. + +Axis Limits and Grid Lines: The dialog allows users to set buffers for the x and y axes, effectively controlling the margins around the plotted data. Users can also add grid lines to the plot for better readability and structure, using the 'Add Grid Lines' checkbox. + +Visual Customization: Line width for the plot can be adjusted via a text input, giving users control over the thickness of the plot lines for visual clarity. (1-5) + +Labeling and Selection of Data Points: Users can select or deselect which hole ids are visible on the plot, and an additional option allows for quick 'Select All' or 'Deselect All' functionality. + + +Once the cross section window is open, you will have several tools available to supplement the plot, these include: + +Topo Line Settings: adjust the height of the topo line (positive for up, negative for down) the values represent meters. Choose a color for sky, or opt for no color. +Hover Tool: This allows you to select a column in your dataset, then hover over a location on the plot to display the value in a text box. +Change to Plan View: changes to plan view while retaining the plot's attributes. North is always up. +Add overlay image: adds an image to the lowest z-order in the plot. The image can be scaled using the following commands + +event.key == '=': # Scale uniform bigger +event.key == '-': # Scale uniform smaller +event.key == 'a': # Scale left side in +event.key == 'd': # Scale right side in +event.key == 'j': # Scale left side out +event.key == 'l': # Scale right side out +event.key == 'w': # Scale top side down +event.key == 'i': # Scale top side up +event.key == 'k': # Scale bottom side down +event.key == 's': # Scale bottom side up +event.key == 'backspace': # Delete overlay image + +Auxiliary bar plot: this plots bars alongside the drill hole data normalized to a certain length. Choose an attribute to plot bars and wait for the bars to render. Bar plot uses only numerical data. Bar plot lengths can be further normalized through the plot settings window. +Interpolate Contours (RBF): A Radial Basis Function (RBF) is a mathematical function used primarily for interpolation, where its value depends only on the distance from a central point. It's unique because it maintains radial symmetry, meaning its output is the same in all directions from the center. You will be prompted to set your normalization, and generate the contours. + + + +FACTOR ANALYSIS + +The Factor Analysis tool allows you to analyze your data using the statistical method of Factor Analysis. To use this tool, follow these steps: + +Specify the number of factors: Choose how many factors you want the analysis to consider, anywhere from 1 to 10. + +Provide a column ending tag: Enter the ending tag that is common to the columns of data you want to include in the factor analysis. + +Opt for Factor Scores: Check the box if you want to calculate factor scores in the analysis. + +Select the holes for the analysis: The tool will allow you to select the specific drill holes you want to include in the analysis. + +Run the analysis: Click on the "Run Factor Analysis" button to start the analysis. + +If no holes or no matching columns are selected, the tool will prompt you with a warning and stop the analysis. + +If the selected data is valid, it scales the data and runs a Factor Analysis. It will determine the factor loadings and variance, and variables for each factor. + +The tool will then prepare a results dataframe that includes the factor loadings and the variance for each factor, the variables for each factor, and the selected hole IDs. + +If you opted for Factor Scores, the tool will calculate them, add them to the original dataset, and offer you the option to save them as a CSV file. + +Save the results: At the end, the tool will prompt you to save the Factor Analysis results as a CSV file. + +Remember, Factor Analysis is a powerful statistical method that can help uncover complex patterns in your data. The value you get from it will depend on the nature of your data and the number of factors you choose to analyze. + + + ALPHA BETA CONVERTER + +This tool allows you to convert alpha and beta values in your structure data to strike and dip values. The process is as follows: + +Upload your data: Before you can start the conversion, you need to upload your structure data in CSV format. + +Select holes: Choose which holes you want to include in the conversion process. + +Check the validity of your data: The tool will check if your data contains columns named 'alpha', 'beta', 'drill_hole_azimuth', and 'drill_hole_dip'. If these columns are not found, the tool will warn you and stop the conversion process. + +Compute the conversion: If your data is valid, the tool will: + +Convert the alpha, beta, azimuth, and dip values to radians ->Compute the Cartesian coordinates of the structural vector in drill hole coordinates ->Transform these coordinates into global coordinates by applying two rotations based on the drill hole dip and azimuth ->Compute the trend and plunge of the structural vector in global coordinates ->Compute the converted strike and dip from the trend and plunge. + +Finally, you will be asked to save your converted data as a CSV file. + + +STEREONET AND ROSE PLOT + +This tool will plot your strike and dip values on a stereonet and rose diagram. Please ensure you have that your strike and dip are using the right hand rule. The tool is not able to compute dip direction. + +Both plots allow you to select as many holes as you would like from the structure hole_select list. You can further color map the attributes based on a different column in the CSV. + + +STEREONET SMALL CIRCLES FOR UNORIENTED CORE + +Assign a drill hole strike and drill hole dip column to your dataset where each row is a calculated strike and dip based on your surrey data. Using your TCA (to core axis) measurements on your structures you can be plotted as small circles on a stereonet. diff --git a/pics.py b/pics.py new file mode 100644 index 0000000..6e1cdab --- /dev/null +++ b/pics.py @@ -0,0 +1,2477 @@ +# -*- coding: utf-8 -*- + +# Resource object code +# +# Created by: The Resource Compiler for PyQt5 (Qt v5.15.2) +# +# WARNING! All changes made in this file will be lost! + +from PyQt5 import QtCore + +qt_resource_data = b"\ +\x00\x00\x82\x20\ +\x89\ +\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\ +\x00\x02\x2d\x00\x00\x02\x0a\x08\x06\x00\x00\x00\xef\x40\x7f\xfc\ +\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x11\x39\x00\x00\x11\x39\ +\x01\x1b\xd9\x93\x46\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\ +\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\ +\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x20\x00\x49\x44\ +\x41\x54\x78\x9c\xec\xdd\x79\x9c\x5d\xd5\x75\x27\xfa\xb5\xf6\x3e\ +\xe7\xdc\xa9\x66\xd5\xa0\x2a\x49\x25\x95\x54\x9a\x90\x10\x08\x24\ +\x26\x03\x02\xcc\x8c\x8d\x31\x36\x90\x0e\xfe\xa4\x43\x12\x32\x38\ +\x1d\xc7\xfd\x3a\xc9\xc7\x21\x6d\x3b\xed\x4f\x37\x49\x3a\xef\x25\ +\x4e\x27\x98\x7e\x18\x87\xe4\xc5\x49\x9c\xd8\x1d\xc7\x36\xc6\xd8\ +\x60\x33\x98\x49\xcc\x12\x93\x40\x33\x1a\x4a\x55\xaa\x52\x8d\xf7\ +\xd6\xbd\xf7\x9c\xbd\xf7\xfb\xe3\xee\x7d\x6a\xd7\x95\x04\x08\x24\ +\x06\xfb\xf7\xfd\x7c\xfc\xa9\xab\x3b\x9c\xa9\xca\x9c\x75\xd7\x5e\ +\x7b\x6d\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\xf7\ +\xbf\x4e\x22\x5a\x4f\x44\xf2\xbd\x3e\x10\x00\xf8\xf9\x20\xde\xeb\ +\x03\x00\x80\x0f\x0c\x41\x44\x39\x22\x6a\x20\xa2\x96\x25\x4b\x96\ +\xf4\x13\xd1\x8a\x35\x6b\xd6\x74\x13\x51\xa3\x7d\x3e\xf3\x1e\x1e\ +\x1f\x00\xfc\x8c\xe3\xf7\xfa\x00\x00\xe0\x7d\x83\x89\xa8\x99\x88\ +\x5a\x88\xa8\x89\x88\x1a\x82\x20\x68\xcc\x66\xb3\x4d\x95\x4a\x90\ +\x8d\xe3\x31\xef\xad\x92\x89\xda\x02\xa2\xbe\x3c\x51\x59\xd5\x9e\ +\x13\x4c\xa4\x0d\x91\xe0\x6c\x36\x9f\x10\x95\x8a\xe5\xf2\xd6\x03\ +\x44\xc5\x49\x22\x9a\x22\xa2\x31\x22\x1a\x25\xa2\xe9\x77\xf5\xac\ +\x00\xe0\x67\x06\x82\x16\x80\x9f\x5f\x79\xaa\x0d\xf1\x74\x48\x29\ +\x3b\x95\x52\xcd\x64\x87\x7a\xa4\x94\xd4\xd9\x79\x51\xa1\xab\x6b\ +\x91\x58\xb1\x62\x72\x52\x88\x53\x1b\x96\x2f\xaf\x4c\xcd\x99\x33\ +\x87\x0a\x85\x02\xed\xdb\xd7\x56\x68\x6c\xcc\x51\x53\x53\xb5\x5a\ +\x28\x94\xe2\x62\xb1\x48\x4a\x29\x1a\x1b\x1b\xa3\x91\x91\x11\x1a\ +\x1d\x1d\xa5\xbd\x7b\xa7\x82\x1d\x3b\xaa\x99\x81\x81\x83\x62\x74\ +\x74\xd4\xdb\xad\xae\x10\x6d\x7f\x9d\xa8\x38\x48\x44\x43\x44\x34\ +\x4c\x44\xc9\xbb\x7e\xf6\x00\xf0\x81\x83\xa0\x05\xe0\xe7\x87\xa0\ +\x5a\x90\x32\x6f\x1e\xb5\x2d\xf9\xaf\x74\xfe\x05\xbf\x47\xdf\x7f\ +\xb2\x2c\x75\x65\xc3\x86\x0d\xc1\x8a\x15\x2b\xaa\xa7\x9d\x76\x5a\ +\xb4\x7a\xf5\x6a\xea\xeb\xeb\x33\xdf\xfb\x5e\xae\xe7\x9a\x6b\xaa\ +\x03\x5b\xb6\x04\x85\x45\x8b\x92\xe9\x6c\x96\xb4\xdb\xd0\xe6\xcd\ +\xa2\x91\x48\xd2\x9a\x35\xf1\xe4\x5b\xd9\x71\xb1\x58\xa4\x57\x5e\ +\x79\x85\x5e\x7a\xe9\x25\xb3\x69\xd3\xcb\xfa\xd1\x47\x47\x1a\xb6\ +\x6f\xdf\x2d\x89\x0c\x13\x09\x25\xe5\xfe\xd7\x95\x3a\xb0\x9b\x88\ +\xf6\x12\xd1\xc4\x89\x39\x7d\x00\xf8\xa0\x0b\xde\xeb\x03\x00\x80\ +\x13\x8a\x89\x68\x2e\x11\x2d\x94\x52\x2e\x54\x4a\x45\x7f\x1c\x7c\ +\x78\xe5\x47\x33\xeb\x4f\xdf\xfa\x21\xfa\x3f\xf7\x7e\xfe\xbf\xa8\ +\x95\x2b\x57\xba\xff\x0e\x84\xc6\x98\x84\x99\x03\x22\xc9\xcc\xda\ +\x10\x11\x55\xab\x5a\xf8\x01\x4b\xed\x39\x12\x0d\x0d\xe6\x2d\x65\ +\x47\x84\x10\xaa\x50\x28\xc8\x75\xeb\xd6\xd1\xfa\xf5\xeb\x63\x63\ +\x4c\x44\x44\xd3\xc5\x62\x91\x9e\x7a\xea\x29\x73\xd7\x5d\x77\x1d\ +\xdc\xba\xb5\xab\xf7\xb5\xd7\x0e\x2e\x26\xaa\x6a\x29\xc7\x87\x94\ +\xda\xfd\x2a\x11\xed\x26\xa2\xb7\x14\x14\x01\xc0\xcf\x07\x64\x5a\ +\x00\x7e\x36\x15\xf2\xf9\xfc\x32\x21\xc4\xb2\xa9\xa9\xa9\x48\x4a\ +\x19\xdf\x74\xd9\x27\x73\x7f\xbc\x6b\xed\x45\x6d\x4b\xe6\x0e\x6f\ +\xfc\x9d\x8f\x6c\x3b\xf9\x34\x1a\x37\xc6\x24\x52\xca\x40\x6b\x4d\ +\x54\xfb\xef\x81\x11\x42\xe8\x97\x5f\x16\x4d\xa5\x92\x96\xa7\x9c\ +\xa2\x27\xb7\x6e\xcd\xe4\x57\xac\xa8\x14\xdd\x86\x4b\x25\x92\x0f\ +\x3d\x14\xb5\x5d\x7a\x69\x75\x58\x4a\x32\xf6\x69\xf7\x33\xfd\x6f\ +\x8a\x10\xc2\x68\xad\xd3\x7f\xcf\x04\x44\x44\x42\x88\x44\x6b\x1d\ +\x30\xf3\xb4\x31\x26\x47\x44\xb4\x73\xe7\xce\x3d\x0f\x3f\xfc\xf0\ +\xfc\xff\xf5\xbf\xee\xd6\xbb\x77\x4f\x34\x13\x11\xb7\xb4\x8c\xed\ +\x1f\x1b\xdb\xbe\x99\x6a\x01\x8c\x3a\x91\x17\x0c\x00\xde\xff\x10\ +\xb4\x00\xfc\x6c\xe9\x9c\x53\x68\x5e\x33\x56\x9e\xea\x26\x22\xba\ +\xf8\xe2\x8b\xe9\x97\x7e\xe9\x97\xe8\x8a\x17\x5b\xe6\x35\x3e\x30\ +\xb0\xbe\xf8\x6b\x27\x6f\x54\x1f\xef\xdf\xfd\xec\xb3\x22\xb3\x76\ +\xad\xf2\x03\x0e\x16\x42\xc4\x5a\xeb\x90\x88\x68\xd3\x26\xd1\x10\ +\x86\xc2\x08\x21\x69\xc9\x92\x4a\x29\x93\x11\x4a\x6b\x2d\x84\x10\ +\xea\xc5\x17\x45\x73\xb5\xaa\xc5\xa9\xa7\xea\xc3\x86\x71\x84\x10\ +\x4a\x6b\x2d\x5d\xc0\x62\x8c\xd1\xcc\x2c\xdc\x3e\xec\x7b\xd2\xfd\ +\xb8\xe7\x99\xf9\x20\x33\xb7\x6b\xad\x59\x08\x31\x32\x30\x30\xd0\ +\xf6\xed\x6f\x7f\x9b\xef\xbc\xf3\x91\xfc\xae\x5d\x13\x51\x36\x5b\ +\x99\x56\x6a\xf3\xb3\x71\x1c\xbf\x42\x28\xe4\x05\xf8\xb9\x85\xa0\ +\x05\xe0\x67\xc3\xfc\xc6\xc6\xc6\xb5\x7d\x93\xb9\xf9\xeb\x9b\x17\ +\x37\x76\x7e\xfa\xc2\x81\x5f\xfc\xc5\x5f\xa4\xee\x5c\xab\x2c\xfc\ +\xc1\xc3\xe7\x0b\xc3\xa2\xfc\xf9\xb3\xee\xad\xcc\x2f\x8c\xef\xdc\ +\x19\xf4\x76\x76\xea\x4a\x73\xb3\xa8\x6a\xad\x25\x33\x57\x8c\x31\ +\x19\xa2\x5a\xd0\x11\xc7\x3a\xd8\xb8\x31\xd3\xdc\xdf\x5f\x2d\x1d\ +\x38\x10\x64\x4e\x39\x25\x19\x36\xc6\x64\x5c\x40\xf2\xf4\xd3\x61\ +\x73\x6b\xab\x89\x97\x2c\x49\x4a\x47\x3a\x10\x1b\xa8\xb0\x31\x46\ +\x79\x99\x15\xed\x65\x5d\xd8\xbe\x2f\x66\xe6\xd0\x06\x38\x44\x44\ +\xa4\xb5\xde\x1d\x04\x41\xaf\xd6\x3a\x6d\xc7\xb0\x71\xe3\x46\xba\ +\xfd\xf6\x7f\x0e\xee\xb9\xe7\xd5\x1c\x91\x36\x85\xc2\x8e\x17\x27\ +\x27\x47\x9f\xa3\xda\x8c\x24\x00\xf8\x39\x82\x9a\x16\x80\x0f\xb6\ +\x9e\x7c\x3e\x7f\x5a\xa9\x54\x6a\xbd\xa6\xf5\xb4\xd6\x4f\xfe\xe2\ +\x47\x82\xf5\x5f\xbc\x71\x20\x8a\x22\xca\xfe\x60\x57\x57\x78\xe7\ +\xbd\x67\xeb\x4b\xfa\x5f\x9c\xbc\x79\xf5\x76\x92\x14\x0a\xa2\xf6\ +\x52\x49\x50\x63\xa3\x56\xcc\x5c\x26\xa2\xbc\x0b\x48\x94\x52\x46\ +\x6b\x1d\x6c\xdd\x1a\xe4\xf3\x79\xad\xe7\xce\xe5\xca\xde\xbd\x5a\ +\xb9\x80\x46\x6b\x2d\x89\x88\xf6\xed\xe3\xdc\xba\x75\xf1\xb8\x97\ +\x55\xf1\x33\x27\x64\x33\x2b\x44\x44\xc2\x0d\xff\xd8\x20\xc4\x65\ +\x55\xca\xc6\x98\x2c\x33\x87\xc6\x98\xd8\xbe\x37\xa0\x5a\xb6\x67\ +\xa1\x3f\xa4\x44\x44\x74\xe6\x99\x67\xd2\x99\x67\x9e\x99\xec\xdd\ +\xbb\x77\xf2\x8e\x3b\xbe\xc6\x7f\xf7\x77\xe1\x6a\x21\x82\x35\x42\ +\x3c\xf3\x7c\x92\x4c\x3f\x4f\x44\x45\x02\x80\x9f\x0b\xe8\x64\x09\ +\xf0\xc1\xd4\x9c\xcd\x66\xcf\x4b\x92\x64\x4d\x77\x77\x77\xee\xae\ +\x1b\xfe\xa8\xfd\x37\x3e\xf3\x69\xd3\x7b\xd3\x05\x23\x52\x4a\xca\ +\xdf\xfa\xe4\x9a\xf0\xfe\x5d\x2b\x2b\xbf\xb1\x66\x63\xf9\xfa\x65\ +\x7b\xfc\x36\x92\x07\x0e\x04\xba\xbb\x5b\x97\xb5\xd6\x39\xaa\x05\ +\x0a\x23\x5a\xeb\x3c\x33\xdb\xa0\x84\xa2\x6c\x36\xd0\xa5\x52\x5c\ +\x6d\x6b\x93\x51\xa1\xa0\xd3\x5a\x12\x66\x9e\xde\xb2\x25\x6c\x5e\ +\xbe\x3c\x1e\x67\x66\x4d\x44\xd2\x18\x53\x22\xa2\x0c\x33\x97\x85\ +\x10\x64\x8c\x11\xf6\xbd\x2c\x84\x08\x94\x52\x65\x9b\x51\x51\xf6\ +\xb5\x80\x99\x2b\x44\x54\x66\xe6\x9c\x31\x46\x1a\x63\xc6\xa5\x94\ +\x91\xfb\xec\x91\x34\x35\x35\xd1\x85\x17\x5e\x40\xbf\xfc\xcb\x57\ +\x54\x33\x99\xd1\xea\xb3\xcf\xaa\x85\x4a\x75\xae\x09\x82\x83\x42\ +\x6b\x3d\x44\x34\xbb\x58\x18\x00\x7e\xf6\x20\x68\x01\xf8\x60\x89\ +\x88\x68\x9d\x94\xf2\xec\xa6\xa6\xa6\xc6\x5b\x6f\xbd\x95\xfe\xdf\ +\x8f\xfc\x5e\xe7\x92\x75\xab\xaa\xfa\xac\x79\x63\x54\x26\xd9\xf8\ +\x99\x1f\x6f\x90\x4a\x98\xa9\x9b\x57\x3e\x97\x9c\xbb\xe0\x50\xfd\ +\x06\x86\x86\x4c\x43\x57\x97\x51\x42\x88\x51\x66\x9e\xd6\x5a\xcf\ +\xa1\xda\x90\x4d\xd1\x18\x23\x06\x07\x45\x2e\x08\x24\x15\x8b\x26\ +\xb7\x78\xb1\x9a\xb6\xcf\x4b\x29\xa5\x79\xf5\x55\x96\x61\x48\x99\ +\xde\x5e\x2a\x19\x63\x02\x22\x62\x63\x8c\xb4\x01\x0a\xdb\xcc\x4a\ +\xc6\xfe\x24\xaa\x4d\x43\x0a\x6d\x56\x26\x90\x52\x16\x6d\xd6\x25\ +\x22\xa2\x30\x08\x82\xfd\x4a\xa9\x3c\x33\xe7\x8d\x31\x6f\x69\xb8\ +\x3a\x97\xcb\xd1\xb9\xe7\x9e\x4d\x37\xde\x78\x61\x65\x74\x74\x47\ +\xb2\x79\xb3\xec\xcb\x64\xda\x56\x24\xc9\xd0\x04\xd5\x9a\xd7\x01\ +\xc0\xcf\x28\x04\x2d\x00\x1f\x1c\xbd\x51\x14\x5d\x4c\x44\x5d\xbf\ +\xf9\x9b\xbf\xc9\x77\xdd\x75\x17\x9d\x7b\xb0\x63\xae\x5e\xd0\x50\ +\x52\x6b\xbb\x26\xc2\xc7\x07\x5b\x0b\x9f\x7f\xe0\x02\xbd\x76\xc1\ +\xee\xf2\x7f\x5c\xf1\x9a\x5a\x39\xe7\xb0\x61\x93\x72\x99\x44\xb9\ +\x2c\x65\x5b\x9b\x8e\x8d\x31\x39\xfb\x3f\xc5\xcc\x83\x42\x88\xa6\ +\xf1\x71\x99\x15\x42\x50\xa9\x64\x04\x91\xe1\x9e\x1e\x31\x22\x84\ +\x30\xc6\x98\xac\x31\x86\x9f\x7c\x32\xec\x3e\xeb\xac\x78\x54\x4a\ +\xc3\x64\x6b\x53\xec\x70\x10\x1b\x63\x84\x1d\x4a\x32\x44\x14\x48\ +\x29\xc7\x89\x48\x0a\x21\xdc\xeb\x6c\x8c\x89\x98\xb9\xa4\xb5\x9e\ +\x60\xe6\x82\xd6\xba\xc9\x1b\x4e\x3a\x26\x85\x42\x81\xae\xb8\xe2\ +\x12\x73\xc5\x15\xa7\x54\x9e\x7f\xfe\xa5\x70\xff\xfe\xae\xd5\x41\ +\x30\xd5\xaa\xf5\xf4\x01\x22\xaa\xbe\xdd\x8b\x0c\x00\xef\x5f\x08\ +\x5a\x00\xde\xff\x32\x41\x10\x9c\xab\xb5\x3e\x65\xed\xda\xb5\xc1\ +\x37\xbe\xf1\x0d\xba\xee\xba\xeb\xa8\xf1\xfb\xaf\xf7\x24\xab\x5b\ +\xc7\xf5\xca\xf6\x62\xee\x1f\x5f\xed\xcd\xfc\xcb\x4b\xa7\x26\x97\ +\xf6\x6f\x99\xbe\x7e\xc9\x6e\xdd\x99\x3b\xe2\x4d\x7b\xdb\x36\x91\ +\xef\xed\x55\xe5\x20\x48\xa7\x28\xbb\xa0\xa3\xd1\x18\x23\xb6\x6e\ +\x95\xd9\xfe\xfe\xf8\xc0\xc1\x83\xb2\x49\x6b\x4e\xe6\xce\x35\xda\ +\x0e\x23\x11\x11\xf1\x2b\xaf\x70\xd3\xaa\x55\x7a\x52\x08\x11\xdb\ +\x62\x5b\xb6\xd3\xa6\xc9\xcb\x94\x30\xd5\x82\x94\x1c\x33\x57\x8d\ +\x31\x01\x33\x27\x6e\x18\x89\x88\x22\x66\xce\x1f\xaf\x8b\xd3\xd9\ +\xd9\x49\x9f\xfa\xd4\xc7\xd5\xbc\x79\xaa\xfc\xd3\x9f\xee\x6d\x57\ +\xaa\x75\xb5\x31\x07\x8b\x44\x34\x72\xbc\xf6\x01\x00\xef\x0f\x58\ +\x30\x11\xe0\xfd\xad\x3b\x8a\xa2\xab\x83\x20\xe8\xbd\xf5\xd6\x5b\ +\xe9\xfb\xdf\xff\x3e\xad\x5c\xb9\x92\xa2\x7f\x7b\xb5\x27\x39\xa5\ +\x63\x4c\x2f\x69\x2b\xe5\xbf\xf4\xf8\xa9\xbc\x69\x7f\x4f\xf9\xb2\ +\x45\x2f\x4f\x5f\xb3\x64\x8f\x69\xce\x1c\xb5\xe9\x9b\xd6\x82\xeb\ +\x1b\xc5\xf9\x8c\xd1\x52\x6b\x6e\xa9\x65\x63\x14\xb9\x02\x5b\x21\ +\x44\x42\x44\x53\xc6\x88\xc4\x18\x93\x10\xd1\xa4\xfd\x49\x44\x54\ +\x54\x4a\x4d\x12\xd5\x6a\x5e\x98\xb9\x24\x84\x30\xb5\xed\x99\x1c\ +\x11\xb1\xdd\x4e\xe3\x71\xba\x26\x47\x74\xe3\x8d\x37\xd2\xc6\x8d\ +\x7f\x3f\x7d\xe1\x85\x2b\x13\xa2\x33\x2e\x09\x82\x8e\xcb\xa9\xb6\ +\xc0\x23\x00\xfc\x8c\x40\xa6\x05\xe0\xfd\x89\x89\x68\x2d\x11\x9d\ +\xb5\x72\xe5\xca\xe0\x9b\xdf\xfc\xa6\xb9\xec\xb2\xcb\x58\x08\x41\ +\xd1\x77\xb7\x77\xeb\x15\x73\x26\xd4\xb2\xd6\x52\xe1\xb7\xef\x3f\ +\x5f\x77\xe5\x27\xd5\xd2\xd6\xe1\xea\xb5\x2b\xf6\x51\x21\x78\xc3\ +\x62\xd4\x81\x01\xca\x74\x75\x99\xa3\x0e\x9d\x0c\x0e\x72\x26\x49\ +\x88\x0f\x1d\x32\x99\xd5\xab\x75\xda\x8d\xd6\x18\x23\x4a\x25\xca\ +\x0d\x0e\x86\xb9\x25\x4b\x54\x99\x99\xb3\xb6\xa6\x85\x98\x39\xcb\ +\xcc\x59\xfb\xd6\x90\x6a\x9d\x75\xdf\x93\x76\x0a\x85\x42\x81\x3e\ +\xf9\xc9\x8f\xe8\x79\xf3\xa8\xf2\xe0\x83\xfb\xba\xb4\xce\x2f\x33\ +\x66\x64\x90\x30\x3d\x1a\xe0\x67\x02\x32\x2d\x00\xef\x3f\x99\x20\ +\x08\x2e\x26\xa2\xd5\x37\xdf\x7c\x33\xfd\xe8\x47\x3f\xa2\xe5\xcb\ +\x97\xb3\x10\xc2\x44\xf7\xee\xea\xd4\xfd\xcd\x93\xc9\xa2\xb6\x72\ +\xe3\x4d\x3f\xb8\x34\x3e\xaf\x67\xa7\xee\x2e\x4c\x56\xaf\x5b\xbe\ +\x97\xb2\xe2\x1d\xcd\x9e\x51\x8a\x38\x8a\x84\x1e\x1d\xe5\xb0\xb1\ +\x31\x9d\x8a\x9c\x7a\xed\xb5\xb0\xd0\xd7\x97\x14\x89\x88\xea\xa7\ +\x25\xbf\xdf\xdc\x78\xe3\x8d\xf4\xd0\x43\x7f\x3d\xd5\xd7\xd7\x13\ +\x10\x9d\x7a\x2d\x11\xad\x7a\xaf\x8f\x09\x00\xde\x39\x04\x2d\x00\ +\xef\x2f\x2d\x51\x14\x7d\x24\x08\x82\xae\x3b\xee\xb8\x83\xfe\xe4\ +\x4f\xfe\x84\xa2\x28\x22\x22\x22\x79\xdf\xce\x0e\x9e\xdf\x5c\x52\ +\xed\x51\xb5\xf1\xd7\xee\xbe\xb4\x72\xe3\xaa\xe7\x48\x13\x55\xaf\ +\x5b\xbe\x97\x42\x69\xde\x64\xbb\x6f\x6a\xd7\x2e\x91\x9b\x37\x2f\ +\x29\x1f\xed\xf5\x3d\x7b\x4c\xbe\xb7\x37\xf9\xc0\x74\xa3\xed\xeb\ +\xeb\x33\x0f\x3e\xf8\xf5\xea\xb5\xd7\x9e\x5c\x22\xda\xf0\xe1\x20\ +\x68\xbf\x80\x90\x5d\x06\xf8\x40\x43\xd0\x02\xf0\xfe\x31\x57\x4a\ +\x79\x45\x47\x47\x47\xfe\xbe\xfb\xee\xe3\x6b\xaf\xbd\x36\x7d\x41\ +\x3c\xbd\xbf\x99\xf2\x81\x8a\x85\xa2\x86\xcf\x3e\x72\x71\xf1\x96\ +\xf3\x1e\xe6\xc1\xc9\x5c\xf5\xda\xa5\xfb\x8e\x47\xc0\x42\x44\x54\ +\x2c\x92\x6c\x6c\x3c\xfa\xfa\x3e\xc6\x10\x87\x21\x1d\x97\x7d\x9d\ +\x68\xb6\xa6\x86\xb3\xd9\x2c\xdd\x71\xc7\x5f\xaa\x5b\x6f\xbd\x6c\ +\x54\xeb\xa5\xab\x89\xba\xae\xa0\x5a\x31\x30\x00\x7c\x00\x21\x68\ +\x01\x78\x7f\xe8\x93\x52\x5e\xbc\x72\xe5\x4a\xf9\xe3\x1f\xff\xd8\ +\xac\x5c\xb9\x32\x7d\x41\x6c\x1f\xcb\x07\xc3\xd5\x8c\x68\x6e\xaa\ +\x16\x6e\x7d\xe2\xbc\xa9\x3f\x3f\xfb\xc7\x99\xe7\xf6\xcf\xa9\x7e\ +\xa4\x7f\x3f\x65\xc3\x63\x1a\x12\x0a\x02\x71\xd4\xa0\xc3\xbd\x56\ +\x2e\x4b\x51\x28\xcc\x0e\x5e\x94\x22\x96\xf2\xe8\x9f\x7d\xb7\xb8\ +\x02\xdf\x37\xe3\x86\xaf\xdc\xfb\x7f\xfd\xd7\x7f\x9d\xfe\xe1\x1f\ +\xfe\xd3\x78\x26\xb3\x70\xbe\x94\x0b\xae\x21\xa2\xc2\x09\x3c\x4c\ +\x00\x38\x41\x10\xb4\x00\xbc\xf7\x96\x12\xd1\x87\x36\x6c\xd8\xc0\ +\xf7\xde\x7b\x2f\x77\x76\x76\xa6\x2f\xf0\xd0\x54\x14\x3c\x75\x60\ +\x4e\xd2\x16\x55\xa2\x5b\x1f\x3a\x7f\xf2\x6f\x2e\xfe\x51\xe6\xd1\ +\x83\x1d\xd5\x8f\xf4\xef\x7f\xa3\x59\x42\x47\x32\x3e\x2e\x83\xc6\ +\x46\x7a\xd3\xcf\x8c\x8c\x70\xb6\xb7\x57\xcf\x1a\x06\xda\xb5\x4b\ +\xe4\x3a\x3a\xcc\x71\x19\x1a\x7a\xab\x81\xc7\x91\x1c\x4b\x2d\x4d\ +\xfd\x2a\xd3\x97\x5d\x76\x19\xdd\x73\xcf\x9f\x14\x1b\x1a\x16\xb5\ +\x4a\xb9\xfc\xe3\x74\x82\x67\x33\x01\xc0\xf1\x87\xa0\x05\xe0\xbd\ +\xb5\x82\x88\xce\xfa\xe8\x47\x3f\xca\x5f\xff\xfa\xd7\x4d\x36\x9b\ +\x9d\xb9\x31\x97\x63\x11\xdd\xb7\x7b\xae\x5a\xd4\x3c\xd9\xf0\xd7\ +\xcf\x9d\x5d\xba\xfd\xb2\x1f\x46\x3f\xd9\xdd\x55\x39\x7b\xee\xb0\ +\x6a\x0e\x8f\x18\x7c\xbc\x51\x40\x30\x3c\x6c\xa2\x96\x96\xe4\xb0\ +\x02\xdb\x7a\x5a\x1f\x3e\x0c\x54\x2c\x92\xcc\x66\xd5\x51\xb3\x3a\ +\x76\xbf\x46\x08\x61\xde\x2c\x28\x79\x27\x45\xbc\x6f\x65\xfb\x47\ +\xd8\x4f\xfa\xfe\x53\x4e\x39\x85\x7e\xf8\xc3\x3f\x9f\x6a\x6f\x9f\ +\x93\x97\x72\xc5\xb5\x44\xd4\xf2\x76\x8f\x05\x00\xde\x7d\x08\x5a\ +\x00\xde\x3b\xcb\x88\x68\xfd\x27\x3e\xf1\x09\x73\xe7\x9d\x77\x52\ +\x14\x45\xb3\x6e\xe6\xd1\x77\xb7\xf7\x70\x4f\x43\xb1\x70\xdb\xb3\ +\x67\x4d\x7c\xf5\xaa\xfb\xc4\xe6\xa1\x96\xa4\xbf\x75\xd2\x2c\x68\ +\x9a\x55\x2c\xeb\xdf\xc4\xdf\x28\x20\x78\xa3\x9a\x95\x72\x99\x44\ +\x26\x53\xeb\xdf\xa2\xd4\xb1\x07\x15\x76\xbf\xac\xb5\x66\xad\x35\ +\x7b\xc1\x45\xfd\xcf\xc3\xb8\xf7\xbe\x95\x60\xc4\x6d\xdf\x7d\xee\ +\x8d\xde\xeb\xf6\x4b\x75\xab\xd9\xf7\xf7\xf7\xf3\xdd\x77\xff\xd5\ +\x74\x7b\x7b\x4b\x18\x86\x2b\x3e\x46\xc8\xb8\x00\x7c\x60\x20\x68\ +\x01\x78\x6f\x2c\x26\xa2\x33\xaf\xbc\xf2\x4a\xfa\xca\x57\xbe\xc2\ +\x61\x38\xbb\x36\x25\x7c\x70\x77\xbb\x68\x8c\xe2\xf0\x6b\x2f\x9c\ +\x51\xfc\xdb\xab\x7f\x14\xec\x18\xce\x52\xa2\x59\xaf\xe9\x9c\x24\ +\x9a\x75\x43\x7e\x4b\x99\x8b\x5a\x2b\xfe\xa3\x17\xd1\xee\xdb\x17\ +\x64\xbb\xbb\x93\xca\xd1\x5e\x2f\x16\x39\x68\x6d\x15\x6f\x9a\xa5\ +\x71\xbc\xe0\xa2\xfe\xe7\x51\xdf\xeb\xbf\x7e\x2c\x19\x9b\xa3\xbd\ +\xd7\xed\xd7\xfe\x73\xd6\xeb\x7d\x7d\x7d\x74\xf7\xdd\x7f\x5d\x69\ +\x6c\x6c\xcb\x10\x2d\xbe\x9a\x88\x1a\xde\xea\xb9\x01\xc0\x7b\x07\ +\x41\x0b\xc0\xbb\xaf\x87\x88\xce\x39\xef\xbc\xf3\xcc\x9d\x77\xde\ +\x69\xa4\x94\x64\x17\x11\x24\x22\x22\xb1\x65\xb8\x20\xc7\x92\x28\ +\xfc\x87\x17\x4e\x2f\x7d\xf9\x82\xfb\xf5\xd0\x68\x18\x6c\x1b\x6f\ +\x8a\x37\x2c\x18\x71\x37\xe8\xba\x1b\xf2\x61\xea\xb3\x1b\x5a\x6b\ +\x66\x3e\xfa\xfb\x8b\x45\x2d\xf3\xf9\x23\x67\x61\x94\x22\x2e\x16\ +\x65\xd0\xd1\x91\x1c\xd7\xf5\x7c\xbc\xc0\xeb\xb0\xa0\xa3\x3e\x88\ +\x39\xca\x67\x67\xbd\xd7\x0f\xe4\x8e\xe0\xb0\xe0\xa5\xaf\xaf\x8f\ +\xee\xb9\xe7\x2f\xa6\x5b\x5b\xe7\x35\x4a\xd9\x7b\x05\xd5\x16\x71\ +\x04\x80\xf7\x31\x04\x2d\x00\xef\xae\x16\x22\x3a\x7f\xf5\xea\xd5\ +\xf4\xcf\xff\xfc\xcf\x5c\x3f\x24\x24\x27\x63\x19\x3d\x35\xdc\x1a\ +\xfd\x9f\x2d\x6b\x2a\x7f\x71\xe9\x8f\x55\x73\x2e\x09\x1f\xda\xdb\ +\x19\x5f\xbd\x64\x80\xe8\x8d\x6f\xe6\x7e\xa0\x72\xa4\xec\x86\xcd\ +\xb4\xbc\xd1\x8d\xfd\x88\xdb\xdb\xb3\x27\x88\x1a\x1b\x4d\x25\x9f\ +\x17\x09\xbd\xc1\x30\xcf\x1b\x6d\x83\x8e\x10\x9c\x78\x81\xd7\x71\ +\xc9\xb2\xd4\x67\x56\xea\xb7\xe1\xa6\x41\xfb\x9f\xeb\xef\xef\xa7\ +\x6f\x7d\xeb\x8f\x8b\x42\x74\xcc\x21\x6a\xbf\x84\xd0\xc7\x05\xe0\ +\x7d\x0d\x41\x0b\xc0\xbb\x27\x27\xa5\xbc\xb8\xb7\xb7\x37\xfc\xd6\ +\xb7\xbe\x45\xd9\x6c\xd6\x7f\xcd\x10\x91\x09\xbe\xf7\xda\xfc\xf0\ +\x07\x5b\xd7\x4c\xfd\xe1\x99\x8f\x54\xe7\xe6\x2a\xd1\x77\xb7\xf7\ +\xa8\xab\x96\x0e\x28\x3a\x72\x0d\xc7\x9b\x04\x2a\xb3\x82\x14\x9b\ +\x69\xa9\xcf\xd0\x18\x21\x84\x36\xa6\xb6\x8d\xc9\x49\x92\xd9\xac\ +\x51\x44\x33\x41\x40\xa9\x44\x61\x2e\xa7\x8c\xcd\x06\xbd\x61\x06\ +\xa4\x9e\xcd\x80\x50\x6d\xa1\xe7\xb7\xf6\xd9\x23\x0d\x15\xbd\xc5\ +\xf7\xfa\xef\x73\xcf\x1f\x36\x8c\x56\x17\xe4\xd0\xda\xb5\x6b\xcd\ +\x1d\x77\xfc\xa7\xa2\x10\x4b\xfb\x88\x72\x67\xbf\xd5\x73\x03\x80\ +\x77\x1f\x82\x16\x80\x77\x87\x08\x82\x60\x43\x18\x86\x99\x7f\xfd\ +\xd7\x7f\xa5\xf6\xf6\x76\x77\x03\xd5\x2e\x03\x10\x3e\xb8\xb7\x23\ +\xba\x67\xf7\xaa\xf2\xaf\x9e\xf4\xa4\x3e\xa9\x7d\x4a\x3e\xbe\xaf\ +\xd5\x2c\x69\x99\x30\xad\x99\x98\xe8\xb0\xec\x82\x7e\xa3\x40\xc5\ +\xcb\x2a\x1c\x16\xa4\xd0\xe1\x37\x77\xc1\x5c\xdb\xc6\xd0\x90\xc8\ +\xb4\xb4\x88\x59\xb5\x2d\x49\x32\xeb\x66\xff\xa6\xd9\x9a\xfa\x4c\ +\xc9\x1b\x64\x87\xde\xb0\x40\xd7\xff\xfc\x11\x5f\x28\xc7\x82\x94\ +\xf2\x5f\x3b\xd2\xfb\xd2\xf3\x17\x42\x68\x22\x32\x75\xc5\xbc\x5a\ +\x6b\xcd\x1f\xfd\xe8\x47\xe9\xbf\xfe\xd7\x4b\xc6\x89\x4e\x3e\x95\ +\x88\x96\xbf\xd1\xf1\x00\xc0\x7b\x27\x78\xaf\x0f\x00\xe0\xe7\xc4\ +\xba\x24\x49\x3a\xbe\xfa\xd5\xaf\xd2\xb2\x65\xcb\x8c\xd6\x9a\xc8\ +\x06\x0c\x44\x44\xc1\xd0\x74\x94\xfb\xfb\x4d\xa7\xa9\x8b\xfa\x5e\ +\x51\x97\x2c\x3d\xc8\x7b\xc6\x32\x72\xac\x12\x55\xcf\x9e\x37\x4a\ +\xde\x0d\x96\x88\x5c\xfd\x8b\x9f\x89\xd0\xfe\x50\x8b\x7d\x8f\x7b\ +\xad\xbe\x58\xf7\x0d\x33\x1d\xc5\xa2\x94\x4d\x4d\x22\x36\xc6\x68\ +\x66\x66\x22\xe2\x20\x10\x26\x49\xd2\x1b\xbd\x31\xc6\xb8\x3a\x9c\ +\xc3\xb6\xe5\x02\x03\x22\x62\x21\x04\xd5\x67\x4c\xb4\xd6\xe4\x3d\ +\x7f\xa4\x63\x35\x7a\xbc\x12\x84\xaf\x0c\x37\xf1\x60\x29\x4b\xc6\ +\x3b\x5e\x26\x43\x86\x98\x12\xcd\x94\xb1\x0b\x43\xea\x99\xfa\x65\ +\x61\x88\x35\x69\x12\x24\x28\xee\xc8\x96\xe9\xa4\xce\x49\xd3\x9a\ +\x89\xdd\x31\x78\x75\x43\x2e\x33\x25\xdc\x73\x42\x08\xfd\xd9\xcf\ +\x7e\x96\x9e\x7e\x7a\x6b\xf1\x9e\x7b\xd4\x45\x44\xcf\x8c\x12\xd1\ +\xd0\x1b\x5d\x2b\x00\x78\xf7\x21\x68\x01\x38\xf1\x7a\x89\x68\xf9\ +\xef\xfe\xee\xef\xaa\x8f\x7d\xec\x63\xe2\x48\x37\xfb\xdc\x17\x9e\ +\x38\x27\x59\xdc\x39\x50\xfa\x95\x93\x76\x50\xac\x45\xf4\xd0\xde\ +\xae\xea\x0d\xcb\xf7\xfa\x81\xca\xac\x62\xdd\xa3\x3f\x9f\x06\x44\ +\xf6\xf5\x37\x0a\x52\x8c\xdb\x4e\x2d\x60\xd0\x54\xad\x2a\x51\x28\ +\x18\xc5\xcc\x2e\xe8\x48\x33\x2d\x16\x33\x33\x6b\x7d\xe4\x96\x2d\ +\xfe\xb1\xd4\xef\xcb\xee\x8f\x0e\x3b\xde\xc9\x8a\x0c\x9f\x3c\xd0\ +\x2a\x27\xab\x11\x11\x91\x8e\xa4\x4a\x96\xb6\x4c\xe9\xd3\x3b\xc7\ +\x44\x18\xfa\x01\xd9\x51\xd5\x37\x92\x13\x3b\xc7\x72\xc1\x53\xfb\ +\x5a\x45\x49\x05\x44\x44\xaa\x29\x88\xe3\x33\x7a\x46\x29\x1f\x2a\ +\xaa\xcb\x4c\xf9\xc7\x74\xfb\xed\x7f\x1a\x9f\x7d\xf6\x7f\xa0\xc1\ +\xc1\xfe\x4b\x95\xda\xf6\xaf\x44\x74\x5c\x8b\x8f\x01\xe0\x9d\x41\ +\xd0\x02\x70\x62\xe5\xa4\x94\x67\xaf\x5d\xbb\x96\x6e\xb9\xe5\x16\ +\x49\x75\xc3\x2a\x42\x08\x1d\xfd\xf1\x23\xa7\x6a\x56\xa6\xf4\xf9\ +\xf5\x2f\x10\x11\x47\xdf\xdf\xd6\x19\x9f\x3f\x6f\x80\xa4\xd4\x75\ +\x37\x78\x37\xbb\x47\xd4\x05\x07\x6e\x9b\x6f\x58\x33\x62\xeb\x56\ +\xdc\x4d\xdb\xd5\xa7\x48\xa2\x5a\x43\x39\x22\xa2\x38\x66\x11\x45\ +\xa4\xed\x6b\x44\x24\x29\x8a\x02\x5d\xad\xc6\xb3\xf6\x67\xb3\x2d\ +\xf5\xfb\x4b\x87\xa5\x8e\x70\x1c\xb3\x9f\x2b\xc5\x32\x7c\x72\xb0\ +\x95\x47\xa6\x43\xca\x48\xad\xcf\xe8\x1e\x2d\x77\xe6\xaa\x69\xb6\ +\x65\x66\xd8\x6b\x56\xa0\x76\xb4\x00\xa6\xfe\x38\x74\x5f\xcb\x74\ +\xb5\xaf\x25\xed\xe0\x1b\x0d\x57\xc2\xe8\xc1\x3d\x73\xa8\x1c\x07\ +\xd4\x94\x89\xab\xe7\xcc\x3b\xe4\x05\x30\x69\xb0\x57\x28\x14\xf8\ +\x9b\xdf\xfc\xf3\xe4\xa2\x8b\xfe\xaf\x26\xa5\x0e\x9e\x4b\x34\xfe\ +\x93\xa3\x5d\x4f\x00\x78\xf7\x21\x68\x01\x38\x81\x82\x20\x38\x37\ +\x08\x82\xf0\x8e\x3b\xee\x20\x6f\x48\xc5\x18\x63\xb4\x94\x52\xc8\ +\x27\x0f\xb6\x84\xcf\x0d\x2d\x2d\x7e\xe7\xda\x6f\x09\x22\x2d\xb6\ +\x1d\x2a\x98\x42\xa8\xcc\xfc\xe6\x84\x6a\x43\x2c\x6e\xb8\x45\xb8\ +\x00\x83\xe8\xc8\x43\x42\xf5\x6c\x00\xe0\x52\x22\xae\x6e\xe5\xb0\ +\xd9\x31\x71\x4c\x9c\xcd\x0a\x25\x04\x69\x22\xa1\xc9\x76\xfa\x17\ +\x42\x98\xbd\x7b\x29\x9c\x33\x27\x29\x0f\x0e\x8a\xdc\xcc\xa6\x88\ +\xa4\x94\x87\x35\x6d\x73\x59\x1b\xaa\x1b\xba\xb2\xc7\x20\xb4\xd6\ +\x22\xd8\x3e\x96\x0f\x36\x1d\x6c\xd1\x91\x54\xfa\x8c\xee\xd1\xb8\ +\x33\x37\x2b\x93\xe1\x0a\x77\xa9\xae\x0e\x85\x8e\x10\xa8\xb9\x21\ +\x9e\x23\x9c\xfa\xac\x1a\x1c\xad\xb5\xa8\xb6\x67\x62\xba\x72\xf1\ +\x10\x11\x91\x3c\x54\x96\xd1\x7d\xaf\x77\x10\x13\xc7\xe7\x74\x0f\ +\x9b\xf6\x7c\xec\xa6\x4c\x6b\xad\x69\xe5\xca\x95\xe6\x0b\x5f\xb8\ +\x7a\xe2\x8f\xfe\xc8\x9c\x44\xf4\xe4\x6e\x22\xda\x7e\xa4\xeb\x0b\ +\x00\xef\x3e\x04\x2d\x00\x27\x4e\x7f\x92\x24\x73\xbf\xfc\xe5\x2f\ +\xd3\xa2\x45\x8b\x8c\x52\x4a\xdb\xec\x84\x60\x66\xa9\xb5\xa6\xa6\ +\x2f\x3e\x70\xc5\xe4\xdf\x5e\xf3\x6f\x5a\x6b\x26\xa5\x82\xe0\xe9\ +\x03\xed\xd5\xeb\x57\xec\xb1\x35\x25\xf5\x43\x3f\x6e\x56\x8f\x7c\ +\xa3\x61\x18\x1b\xd0\xb8\x61\x28\x2f\x48\x11\xf5\xef\x53\x4a\x29\ +\x31\x3a\x2a\xb2\x85\x82\x52\x44\xcc\x49\xa2\x39\x08\xa4\x26\x4a\ +\x48\x6b\xcd\xc3\xc3\x22\xb7\x6c\x99\x2e\x8e\x8c\x88\xfa\xe2\xdd\ +\xc3\x82\x9f\xa3\x3c\x27\x88\x48\x84\x8f\xef\x6b\x0d\xf6\x16\xf3\ +\xbc\xa0\xb1\x58\xfd\xe4\xf2\x3d\x4a\xd5\x46\xa0\xea\x8f\xd9\x6e\ +\x9b\x79\xbc\x12\x04\x3b\xc7\xf3\x3c\x30\x95\xa3\xd8\x08\xbb\x31\ +\x12\xc4\x5a\x93\x11\x24\x85\x11\x5e\xbd\x8b\xd6\x9a\xd2\xe7\x22\ +\xa9\xd4\xdc\x7c\x39\xe9\x6b\x2e\xb9\xf5\x99\xbc\x22\x5c\xa9\xda\ +\xb2\x4a\x7d\x6c\xc9\x01\x59\xd6\x22\xf8\xc9\xee\x36\x59\x4e\xa2\ +\xca\xfa\xae\x43\xda\x76\x1a\xd6\x5a\xd3\x6f\xfc\xc6\x6f\xf0\xdd\ +\x77\x6f\x2c\x3d\xfe\xf8\xf2\xf3\x89\x5e\xdd\x4f\x44\xc7\x65\xdd\ +\x25\x00\x78\x67\x10\xb4\x00\x9c\x18\x39\x29\xe5\xba\xd3\x4f\x3f\ +\x3d\xb9\xe1\x86\x1b\x84\x1f\xa8\x08\x21\xb4\x52\x8a\x9a\x7e\xe9\ +\xee\x8f\x4c\x7f\x62\xc5\x93\xaa\x2b\x88\x85\x10\x26\xf8\xce\xb6\ +\x4e\xb5\xa1\x77\x90\x6a\x75\x23\x92\xa8\x16\xa8\x28\xa5\x48\x4a\ +\x29\xea\x82\x02\x3f\xd3\xe1\x6e\xfa\x92\xbc\x80\xc2\x2f\xc2\x15\ +\x42\x18\x66\xa1\x84\x20\xe5\xbd\x2f\x60\x66\x9a\x9c\x94\x41\x77\ +\x77\x52\xd1\xda\x30\x51\x28\x6a\x49\x94\x19\xa3\xa3\x52\xb6\xb7\ +\x53\x3a\xa3\xc8\x65\x70\xfc\x82\x60\xbf\x00\x77\x56\xc1\xeb\xd3\ +\x07\x9a\x83\x1d\x63\x4d\xfa\xf4\xb9\x87\xe2\xb3\xe7\x8d\x52\xed\ +\x80\x64\xad\xc6\x77\x86\x9e\xac\x84\x72\xf3\x50\x73\x78\xb0\x9c\ +\x25\x6d\x34\xe5\x82\xb8\xba\xa0\xa1\xa2\x37\x2c\x18\xb6\xc3\x38\ +\xb3\x08\x21\x66\x05\x81\xb3\x5e\x2c\xc7\x22\xd8\x35\x99\x0b\x37\ +\x0e\xb4\x89\x69\x25\x88\x89\xab\x3d\xb9\x92\x5e\xdb\x33\x41\x32\ +\x1d\x22\x23\x95\x25\x52\x57\xf6\x0d\xc7\x8a\x38\x7c\x60\x77\x9b\ +\x7c\x76\xb8\x29\xbe\x72\xe1\x41\x15\xd6\x2e\xf3\xed\xb7\x7f\x29\ +\x3e\xf3\xcc\xcf\x34\x55\x2a\xfb\xce\x24\x9a\x7a\xf0\x4d\x7f\xe3\ +\x00\x70\xc2\xa1\x91\x12\xc0\x89\x71\x4e\x26\x93\x69\xfd\xf6\xb7\ +\xbf\x2d\x5b\x5a\x5a\x58\x08\xa1\x98\xd9\x18\x63\x84\x31\x86\x0b\ +\x7f\xfa\xd8\x1a\xaa\x90\x4c\xfe\xdb\x79\xcf\x6a\xad\x99\x5e\x1f\ +\xcf\xc9\x89\x38\x4a\xd6\xb4\x4f\x7a\xef\x65\x63\x8c\x60\x66\x61\ +\x1f\x6b\x29\x25\x19\x63\x58\x08\x41\xc6\xd4\xda\xaf\x10\x11\x1b\ +\x63\x44\x2d\x30\x61\x6d\x8c\x71\xcf\x11\x33\x6b\x5b\x38\xcb\x83\ +\x83\x94\xed\xec\xd4\xb3\x5a\xf1\xd7\x86\x80\x38\xea\xed\xa5\xb2\ +\x31\x86\x77\xed\xe2\x7c\x67\x27\x95\x1a\x1b\x39\x36\xc6\x88\xc1\ +\x41\xce\x24\x89\xe0\x05\x0b\x4c\x89\x39\xdd\x2e\xbb\xe3\xb3\xfb\ +\x27\x66\x76\x91\x8e\x30\xc6\x70\xb0\x7b\x22\x1b\xdd\xbf\xbb\xdd\ +\xb4\x46\xd5\xf8\x92\xbe\x61\xdd\x96\x8d\x8d\x31\x4a\x4a\xa9\xed\ +\x87\x99\x14\x51\x66\xe3\x60\xb3\x7c\x6a\xdf\x1c\xb9\xb7\x98\xd7\ +\x7d\x4d\xc5\xf8\xac\x9e\xd1\x64\x45\x5b\x31\xe9\x6f\x99\x36\x1d\ +\xf9\x98\x42\xa9\x8d\xa9\x15\x06\x93\x37\xec\xa3\xb5\x66\x77\x5d\ +\xc8\x66\x8d\x98\x99\x8c\x31\x4c\x81\x34\xba\x3d\x17\xab\x25\x2d\ +\xc5\x64\x45\xdb\x54\xb2\xbc\x6d\x4a\x4e\xc4\x41\xf0\xe8\xeb\x2d\ +\xf2\xa5\x91\x66\x32\x86\x55\x7b\x2e\xb1\xd7\x4b\xb1\x64\xa3\xfa\ +\x9a\xcb\xaa\x3b\x5f\x89\xee\x7f\xbd\x4b\x0f\x97\x24\x2f\x6a\x29\ +\x35\x37\x37\x73\x26\x73\xb0\xfa\xe0\x83\x23\xf3\x89\x06\x06\x88\ +\x68\xe2\xdd\xf9\xd3\x01\x80\xa3\x41\xa6\x05\xe0\xf8\xeb\x22\xa2\ +\x85\xbf\xff\xfb\xbf\xaf\x16\x2d\x5a\xe4\x86\x73\xd2\x2f\x08\x99\ +\xc7\xf7\x36\xcb\x67\x0f\x2d\x9e\xfc\xdb\xcb\xef\xa6\x38\x96\x44\ +\x44\x99\x47\xf7\xb7\x57\x6f\x58\xfe\xba\x10\x62\x56\xa6\x44\x4a\ +\x99\xc4\xb5\xf7\xb0\x1d\x2e\x22\xa2\x59\x3d\x5b\xb4\x52\x4a\xdb\ +\x2c\x4e\xdd\x70\x50\x2d\xeb\xe2\xfa\xba\xb8\x27\x6d\xa6\xc1\x68\ +\xad\x83\x5a\xcf\x12\x12\x4a\x29\x72\xd9\x0f\x63\x38\xd0\x7a\x66\ +\x45\xe7\x6a\x55\x4b\xe6\xd9\x43\x3f\xf5\x43\x41\x69\xb6\xa3\x1c\ +\x8b\xe8\x9e\x1d\x73\xcd\x9c\x7c\xa5\xfc\xc9\x65\x83\xfe\x7b\x5c\ +\xa6\x89\xf7\x4d\x64\xb2\xcf\x1c\x6c\x23\xc3\x2a\x59\xd3\x3e\x96\ +\x9c\xdd\x35\x6e\x8f\x2b\x11\x87\x0f\x3d\x31\x33\xa7\xff\x9d\x12\ +\x42\x28\x6f\x9a\xb2\xab\xd9\x11\x5a\x6b\xff\x3d\x7e\xbd\x8f\x11\ +\x42\x50\xb2\xa2\xad\x48\x2b\xda\x8a\x44\x44\xe1\x33\x43\x8d\xd1\ +\xbf\x6c\xe9\x32\x9d\x85\x24\x3e\xb7\xe7\x10\x85\xd2\x08\x21\x8c\ +\x6a\x8a\xca\xd5\x6b\x96\xee\x95\xcf\x1f\x6c\xe1\x6f\xbc\xbc\x30\ +\xbe\xac\xef\xc0\xa7\x3f\xfd\xe9\xea\x9d\x77\xfe\xb0\xb4\x7f\xff\ +\xd2\xf3\x94\xda\xfa\x2f\xe4\x17\xf6\x00\xc0\xbb\x0e\x41\x0b\xc0\ +\xf1\xc5\x44\x74\x7a\x6f\x6f\xaf\xf9\xad\xdf\xfa\x2d\xe9\xf5\x20\ +\x71\x33\x72\x38\xf3\x57\xcf\x9e\x57\xfe\xd4\xaa\x8d\xd4\x18\x26\ +\x42\x08\x2d\x9f\xd8\x37\xa7\x7a\x52\xdb\xb8\x66\x16\xa2\x56\xa4\ +\x9b\xd8\x61\x0f\xe9\xdf\x8c\x9d\xba\x40\x45\x78\xb5\x21\xfe\x7b\ +\x12\xbb\x3f\x69\x87\x87\x34\xb3\x50\x44\xfa\xb0\x80\x83\x99\xd2\ +\xfa\x92\x5a\x20\x60\xfc\xe1\x1e\xb7\xbd\x34\xd0\x71\xdb\x57\x4a\ +\x09\xef\x73\x89\x78\x7e\xb0\x51\xbe\x30\xdc\x91\x7c\xa4\x7f\xbf\ +\x69\xcd\x54\x04\xcd\x04\x37\x42\x08\x4d\xaf\x0d\x17\x82\x4d\xc3\ +\x6d\xa6\x25\x53\x29\x5f\xb1\xe8\x00\x85\xb3\xc7\xa1\xea\x02\x0f\ +\xa5\x94\x32\x2e\x60\x71\x59\x26\xff\xd8\xed\x79\xb9\xda\x1d\x63\ +\x33\x39\xf5\x75\x40\x69\x80\x67\x8c\xd1\x44\x44\xf1\xe9\x9d\x93\ +\x74\x7a\xe7\x24\xef\x9b\xc8\x64\xbf\xbb\x63\xae\x69\xcd\x95\xe2\ +\x8b\x7b\x47\x99\x39\xd0\x5a\x93\x5e\x33\x67\xd2\x2c\x6d\x1c\xcf\ +\xdd\xbd\x7b\x5e\x72\x5a\xc7\xf8\x6d\xb7\x7d\xae\x74\xf5\xd5\x5f\ +\x6a\x23\xa2\x15\x44\xf4\xf2\x9b\xfd\x01\x00\xc0\x89\x83\xe1\x21\ +\x80\xe3\x6b\x31\x11\x2d\xbf\xed\xb6\xdb\x68\xe5\xca\x95\x6e\x08\ +\x85\xec\xf0\x0e\x37\x7d\xe6\xa1\x73\x93\x45\x4d\x83\xe5\x5f\x5d\ +\xb3\x93\x04\x91\xa9\x26\x32\x78\x72\xa0\x4d\x7f\xb8\xef\x00\x33\ +\x93\x0b\x42\xec\x70\x8f\xf6\x86\x61\x6c\xbb\xfd\xda\xf0\x92\x0d\ +\x16\x5c\x9b\x7a\xb7\x8f\x44\x4a\xe9\x86\xa0\x84\x31\x26\xbd\x79\ +\x1b\x63\xc4\xd4\x14\x85\xd9\xac\xd1\x61\x58\x0b\x46\x84\x10\x09\ +\x33\x9b\x03\x07\x28\xdb\xd5\x65\x2a\x42\x88\x64\xe7\x4e\x91\x6f\ +\x69\x51\x49\x73\x33\x27\x4a\x29\x33\x3c\x1c\x64\x8d\x31\x3c\x77\ +\x6e\xad\xa6\xc5\x6d\xd3\x66\x65\x6a\xd9\x8c\x58\x71\xe6\x3b\x5b\ +\x7b\x4c\x26\x30\xd5\x2b\x17\x0f\x99\xac\xd4\x6e\xb8\xc8\x18\x23\ +\x82\x81\xa9\x28\xfc\xfe\xce\x0e\x11\x48\xaa\x5e\xb6\xe8\x20\xf5\ +\xb7\x4d\x71\x20\x13\xbb\x2d\x1b\x50\xb1\xae\x3f\x5e\x3f\x90\xb2\ +\x43\x42\x69\x9d\x8f\x7b\xbf\xbb\xbe\x64\x33\x51\x76\xe8\x4c\x33\ +\x73\x52\xf7\x7a\xad\xc1\x8c\x3d\x70\x21\x84\xe2\xe6\x6c\x35\x5e\ +\xd9\x56\xe2\x40\xb2\xbc\x77\x7b\x37\x6b\x52\xd4\xdd\x50\x62\x66\ +\xa6\x40\x88\x64\xd5\x9c\xa9\xe0\xe9\x03\xad\x7d\xc1\x1c\xf9\xc8\ +\xbe\xa7\xc6\xf7\xed\x13\x8b\x8c\x19\x7e\x99\xe8\xc8\x0b\x4b\x02\ +\xc0\x89\x87\x36\xfe\x00\xc7\x8f\x20\xa2\x53\xd6\xaf\x5f\x6f\x2e\ +\xbf\xfc\x72\xf6\x87\x31\x84\x10\x26\xf3\xf7\x2f\x2f\x22\x11\x9b\ +\xf8\xe2\xde\xbd\x24\x49\x0b\x21\x92\xe8\x87\xbb\x3b\xe3\x0b\x16\ +\x1c\xd4\x5a\x87\x76\x28\x27\xf1\x66\x09\xf9\x9d\x6f\xdd\x50\x8f\ +\x36\xc6\x24\xae\xc8\xd6\xb6\xf3\xaf\x75\x93\xab\x65\x0a\x66\x7d\ +\x11\xf1\xb7\xd7\xdc\xcc\xf1\xe8\xa8\xf4\x87\x8a\x84\x9a\x69\x83\ +\xcf\x95\x8a\x8e\x32\x99\x5a\xcf\x16\xad\xb5\x48\x12\x0e\x83\x40\ +\xbb\x62\x5e\x51\x97\xe5\x10\x44\xc4\x3c\x34\x1d\x45\xdf\x7c\x75\ +\x7e\x7c\x51\xdf\x70\x7c\x76\xcf\xb8\xf7\xba\xd4\xa5\x24\x8c\xbe\ +\xbb\xb5\x5b\xbc\x30\xdc\x52\xfe\xe4\x92\xa1\xca\x39\xdd\x63\xde\ +\xb6\x42\xef\xdc\x34\xcd\xd4\xab\x68\x63\x4c\xec\xce\xcf\x66\x47\ +\x4c\xdd\xbe\xa5\x9f\xf1\xb1\x59\x25\x77\xbe\xba\x6e\xfb\xc6\xbe\ +\xee\xb2\x3a\xa6\x7e\x1b\x7a\x61\xe3\x54\xe5\xba\xe5\xbb\x64\x45\ +\x05\xc1\xbf\x6c\x59\xa4\xc7\x2b\xa1\xfd\x5c\x9c\x5c\xbe\x78\x40\ +\x37\x65\xcc\x5d\x57\xfc\x6a\x8f\x30\xad\x79\x22\x3a\xe9\xad\xfc\ +\x21\x00\xc0\x89\x81\xa0\x05\xe0\xf8\x59\x42\x44\x0d\xb7\xdc\x72\ +\x8b\xdf\xb3\x84\xb4\xd6\x6c\x0e\x8c\x65\xa2\x07\x76\x2d\x2d\x9f\ +\x39\x7f\x97\x9d\x45\xc3\x3c\x5a\xc9\x8a\x40\x18\xee\x6c\x28\xb9\ +\x1b\xaf\xad\x33\x99\x35\x04\x62\x8c\x51\xee\x46\x6e\x33\x31\x81\ +\x1b\xf2\x70\x33\x81\xbc\xc6\x73\x24\x84\x88\x8d\x31\xee\x46\x2e\ +\x5d\x60\xd2\xdc\xac\x92\xc9\x49\xce\xb9\x60\xca\x65\x75\x5c\x80\ +\x50\xad\x4a\xce\xe7\x4d\xc5\xed\x7e\x70\x50\xca\x8e\x0e\x2e\xba\ +\xed\xda\x63\x50\x76\x1f\x49\x66\xd3\x70\x21\xf3\xc4\xfe\x39\xd5\ +\x1b\x4e\xda\xab\x5b\xa2\x92\xf7\x9a\xca\x3c\x31\xd0\x10\x7d\x7f\ +\x5b\x77\xbc\xa1\xf7\x60\xe5\x92\x85\xfb\x45\x18\xba\xe3\x31\xfe\ +\xb1\x7a\xe7\xec\x1f\x53\xe8\x86\x7c\xc8\x0b\x68\x8c\x31\x89\x77\ +\x5e\xfe\x67\x5d\x00\xe3\xd7\xed\x18\x21\x84\x5b\xb3\x29\x20\x3a\ +\xbc\x97\x8d\x10\x42\x19\x63\xb4\x9d\x45\x15\x54\xd6\x75\x8d\xab\ +\x8f\x2e\xd9\x97\xbd\x7b\x7b\x7b\xb0\xe5\x50\xc1\x05\x92\xf1\x9a\ +\x39\x93\x73\x3e\xb6\x76\xe8\xcf\x4e\x5e\x53\x08\xe5\xc9\xeb\x88\ +\x28\x5b\xbf\x2d\x00\x78\x77\x20\x68\x01\x38\x3e\x98\x88\x4e\x3e\ +\xf7\xdc\x73\xe9\xbc\xf3\xce\xf3\xb3\x2c\x9a\x88\x4c\xc3\x2d\x1b\ +\xcf\x9d\xbe\x74\xd1\x96\x64\x55\xdb\x84\x10\xc2\x18\x63\x62\x79\ +\xff\xce\xf6\xf2\x05\xbd\xc3\xf6\xe6\x18\x90\xb7\x10\xa1\x9f\x51\ +\x61\x66\xe9\xdd\xc8\xc9\xbe\xae\x98\xb9\xea\xb7\xaf\x77\x37\x6d\ +\xad\x75\xe8\x6a\x41\xdc\x2c\x1b\x21\x84\x0a\x43\x32\xd5\xaa\x16\ +\x42\x88\xd8\x05\x49\xb5\xfd\xd4\x6e\xee\xc5\xa2\x0e\x5a\x5a\x44\ +\x92\x24\xb5\x20\x66\x62\x82\x33\x1d\x1d\x26\x0d\x30\xec\x36\x05\ +\x11\x91\xbc\x6f\xe7\x5c\x3d\x55\xc9\x94\xaf\x5e\x32\x40\x92\x8c\ +\x31\x26\xd2\x5a\x4b\x2a\xc7\x22\xf8\xf6\x96\x79\x71\x60\x44\xf5\ +\x13\xcb\xf6\x99\xe6\x4c\xe2\x4f\x4b\x76\xb5\x31\x76\x93\x86\x99\ +\xab\xde\x39\xcf\xca\x9a\x90\x2d\xc2\x75\xe7\xc7\xcc\x81\x3b\x2f\ +\x21\x84\x1f\xc0\x18\x21\x44\x5c\x2b\x2a\x4e\x83\x1f\x76\xd9\x16\ +\xdb\xf3\xa6\xea\xea\x8a\xdc\xc6\x75\x6d\xea\xb5\xf0\xb7\x67\xf2\ +\xa1\x29\xff\x87\x15\x83\x7c\xa0\x94\x8f\xee\xd9\xd1\x69\x03\x40\ +\xa5\xba\xf2\xea\x92\xbf\xfc\xe5\xa1\x4f\x9a\xfe\xc5\x21\x85\xc8\ +\xb6\x00\xbc\x47\x10\xb4\x00\x1c\x1f\x0b\x89\xa8\xf0\x99\xcf\x7c\ +\xa6\x3e\xcb\x22\x72\xff\xf8\xea\x42\x5a\xd4\x38\x1c\x04\x41\xac\ +\xd7\x74\x4e\x68\xad\x59\x1c\x2c\x17\x44\x73\x56\x89\x7c\x50\xf1\ +\x32\x14\xe4\x7f\xce\xde\xa0\xb5\x97\x99\x30\xc6\x98\x98\xec\x70\ +\x89\x0d\x14\xd2\x8c\x8b\x2d\x4c\x75\xdb\xd2\x7e\x40\x60\x3f\xeb\ +\xb6\x13\x90\xad\x67\xd3\x5a\x0b\x63\x92\x88\x88\xa8\x52\x91\x22\ +\x9f\x57\x14\xc7\xb5\xcc\x45\x92\xe8\xfa\xde\x30\xa4\xb5\xa6\xe8\ +\x7b\xdb\xe7\x8a\x79\x2d\xd3\xea\xbc\x05\x23\xde\x4b\x26\xd8\x72\ +\xa8\x10\x7d\x77\x7b\x4f\xf5\xa2\xbe\x21\xbd\xae\x67\xc2\xfb\x8c\ +\xa4\x99\xb5\x90\xd2\xcc\x08\xd5\x02\x8a\x88\xbc\x21\x30\x77\x5c\ +\x7e\x56\xa5\x7e\xc8\xc8\x06\x6a\x69\x00\x63\x3f\x17\x90\xcd\x38\ +\xd5\x05\x42\xc6\xd6\xba\x44\x36\xa0\x71\x19\x98\xf4\xba\xf8\xdb\ +\x73\xd7\x30\xb9\x70\xc1\xfe\x78\x69\xdb\x44\xf0\x8d\x97\xfb\x58\ +\xd7\xf6\x33\xf7\xe4\x25\xe5\xea\xa5\xe1\x4b\x5a\xae\x3a\x8d\x30\ +\x89\x01\xe0\x3d\x81\xa0\x05\xe0\x38\x90\x52\x9e\xb4\x72\xe5\x4a\ +\xba\xe8\xa2\x8b\xc8\xcf\xb2\xc8\x58\x72\x70\xff\xce\xe5\xe5\xab\ +\x97\xee\x54\xcb\x5a\x4a\xa6\x56\x45\x5b\xc9\xfc\x74\x4f\x5b\x79\ +\xc3\x3c\x97\x65\x71\x01\x04\x53\xed\xc6\x1b\xdb\xe0\xa4\xbe\xfb\ +\x2d\x33\x73\x68\x83\x1b\xbf\x98\xb6\x6a\x1f\x13\xd5\x86\x53\x4c\ +\x2d\x18\x99\x09\x08\xec\x4d\xd9\xdf\x8f\x71\xb3\x69\x6a\x4d\xe7\ +\x44\x5c\xad\x92\xc8\xe5\x94\x8a\x63\x91\x06\x08\xb5\x6d\xa7\x59\ +\x99\x24\xfa\xe6\xab\x5d\xfa\xa4\x39\x13\xe5\xe5\x4d\x13\x76\x5f\ +\x24\x84\x30\x99\x07\xf6\x34\xf1\x40\x31\x5b\xbd\x7e\xc5\x5e\x6e\ +\x8a\xca\x5e\x26\x27\x3d\x17\x2f\xa0\x20\xf7\x1a\x79\xc1\x83\x0b\ +\xbc\xec\x7e\x03\x2f\x5b\x24\xa4\x94\x69\x40\xa1\x94\x72\xdb\x36\ +\x76\xfb\xda\x0f\xde\xbc\xf3\x36\x4a\x29\xe5\x05\x3b\xb1\xad\x79\ +\xf1\xeb\x69\xfc\x55\xa6\xb5\x31\x46\xb9\x6d\x98\xa5\x2d\xe5\xf8\ +\xa2\xde\x03\xd1\x3f\xbd\x38\x57\x24\x26\x61\x66\xf9\xd9\x3f\xfa\ +\x1d\x56\x4a\x46\x44\xd4\xff\x36\xff\x54\x00\xe0\x1d\x40\xd0\x02\ +\xf0\xce\xb5\x2b\xa5\xe6\xdc\x7c\xf3\xcd\xca\xaf\xd7\xd0\x5a\x8b\ +\xec\x67\x7f\x78\xde\xf4\x6f\x9f\xf2\x98\x7c\x65\x38\x17\x9f\xda\ +\x39\xce\xcc\x42\xbe\x3e\xd5\xac\xe6\xe4\x13\x91\x99\xe9\xf4\x6a\ +\x8c\x49\xeb\x50\xec\xf0\x4e\xe8\x6d\x9f\xfd\x21\x1d\xa5\x94\xb1\ +\x43\x29\x46\x6b\x1d\xd8\x9b\x74\x3a\x24\xe2\x67\x6c\xec\xe7\xd4\ +\xcc\x3e\x84\x6b\x2e\x67\xa4\x94\x8a\x88\x88\x99\x04\x11\x71\x1c\ +\x13\x47\x11\x19\xad\x93\x34\x83\x53\xdb\xb6\x0e\x48\x29\x0e\xbe\ +\xf1\x72\x5f\x7c\x4e\xf7\x78\xb2\xa4\xa5\x64\xa7\x5b\x4b\x22\xa2\ +\xe0\xfb\xdb\xe6\xea\xd6\x0c\xc7\x17\xd6\x32\x2f\x36\xab\xe1\x02\ +\x8e\xf4\x5c\xbc\xec\x51\xfd\x3a\x45\x26\x08\x82\x34\x3b\x62\x87\ +\x72\x5c\x60\xa2\x44\xad\x37\x4b\x1a\x94\x78\xdb\x63\x22\x0a\xec\ +\xf0\x97\x45\x00\x77\xa6\x00\x00\x20\x00\x49\x44\x41\x54\x66\xe6\ +\x8a\xdb\xae\xbd\x3e\xba\xae\xfe\x27\x0d\x10\xed\x75\x89\xc9\x5b\ +\xbb\xc9\x1e\x5f\x3a\x45\xdb\x18\x13\x73\x67\x43\x25\xbe\x7a\xe9\ +\xc1\xe0\x5f\x5f\xe9\xa3\xb2\x16\xab\x56\xad\xd2\xcb\x97\xb7\x4d\ +\x48\xb9\x78\xed\xb1\xfd\x89\x00\xc0\xf1\x80\x14\x27\xc0\x3b\xb7\ +\xac\x50\x28\x98\xeb\xaf\xbf\xde\xb5\xe9\x57\x4a\x29\x1d\x3d\xb0\ +\xbd\x8b\x0b\x51\x45\x47\x52\x54\x97\xb4\x54\x6c\x66\x43\x8b\x8d\ +\x7b\x7b\xaa\x1f\xef\x1f\xf0\xbf\x31\xd8\x0c\x8a\xa1\xda\x6a\x85\ +\xd2\x16\xe0\xc6\xb6\x37\x49\x68\xb3\x03\xee\xbd\xae\x17\x49\x3a\ +\x04\x62\x8c\xa9\xda\x00\x41\xd8\xa1\x14\x57\xd3\x21\xfd\x7d\x30\ +\xeb\x90\x88\xca\xf6\xe6\x9d\x66\x5e\xb4\xd6\x41\xb5\x4a\xc2\x4d\ +\x87\x76\x59\x98\x5a\xc0\x23\x92\xe8\xdf\xb7\xf7\xa8\x73\x7b\x0f\ +\xf0\xfc\x86\x69\x53\x0b\x8c\x34\x95\x35\x07\xdf\x7a\xb9\x57\x5f\ +\xd8\x3b\xa8\xe7\x35\x15\xc9\x1e\xa3\x0d\x06\x5c\x66\x24\xa9\x1b\ +\x1e\x12\xde\xcf\x34\x83\x94\x24\x49\xc6\x1d\xa7\x31\x26\xb2\xdd\ +\x7e\xed\x5b\x6d\xa1\x6d\xc5\x24\xe1\x13\x83\xad\xe2\x85\x81\x6e\ +\xb3\xbf\x58\x08\x4a\xd5\x90\xd8\x04\x24\xd8\x50\x7b\xd3\x64\xdc\ +\x1a\x94\xe3\xb3\x7a\x86\xe8\xd4\xce\x09\xbf\x87\x0c\x33\x57\x6d\ +\x57\xe0\xd0\xdb\x68\xfa\xd8\xcd\x2e\xf2\x9e\x73\x05\xcf\xb5\x66\ +\x7e\xcd\x99\x44\x7d\x6c\xf9\x9e\xec\x37\xb7\x74\xc7\xd7\x2d\x1f\ +\xf8\xdc\xe7\x7e\x91\x6e\xba\xe9\x6f\x5a\x89\x68\x2e\x11\x1d\x38\ +\x96\x3f\x14\x00\x78\x67\x10\xb4\x00\xbc\x33\x21\x11\x2d\xbc\xe6\ +\x9a\x6b\xe2\x4c\x26\x13\x90\x5d\x8d\x99\x99\x65\xf6\xef\xb6\xad\ +\x2b\x7e\xf5\xc2\x7b\xa2\xbb\x77\xcf\x2f\x7f\x62\xd9\x01\x26\x92\ +\x3c\x5c\xca\x52\x53\x26\x21\x29\x8d\xd6\x5a\x08\x21\x54\x92\x24\ +\x49\x10\x04\xa1\xbd\x91\xa7\x37\x78\x5b\x7c\x4b\x64\x7b\xb1\xa4\ +\xdf\xfe\x99\x23\x5b\x60\x1b\xbb\x8c\x87\x10\x22\x72\x3d\x48\xfc\ +\x9b\xbe\x17\xdc\xd8\x6d\x04\xb1\x10\x49\x62\x87\x8b\xaa\x5e\x11\ +\x6f\x6c\x8c\xa8\x12\x69\x3b\x5c\x34\x33\x4b\xa7\xf3\xa7\xdb\xba\ +\x92\xcb\xdb\x87\x68\x7e\x43\x3a\xb4\xc3\xa5\x58\x86\xdf\xde\xda\ +\x53\xfe\xe8\xd2\xfd\xd4\x18\x26\x2e\xfa\x10\xb5\x35\x81\xc8\x56\ +\xff\xba\x21\xa8\xc0\x9e\x4f\xd5\x0d\xdd\x30\x73\xc5\x9e\x9f\xb0\ +\x8f\x03\x3b\x2c\x93\x48\x29\x39\xd8\x3d\x59\xc8\xde\xbe\x69\x35\ +\x6f\x3f\x34\x8f\xb5\x21\x23\x98\xb4\x20\xa3\x1b\x82\xa2\xe9\x2a\ +\x8c\x89\xf9\xb9\xf1\x6a\x77\xf7\x14\x31\xb1\xdc\x3f\x9e\xd5\x13\ +\xe5\x88\xf7\x96\x5a\x0a\x5f\x1e\xec\xa3\xc9\x4a\x46\x06\xb2\xd6\ +\x2e\xb7\x39\x33\x55\xfd\x50\xcf\x8e\xca\x0d\x27\xed\xa1\x2c\x29\ +\xe1\x35\xdd\x13\xb5\x26\x7d\xaa\x7e\x76\x91\x31\xc6\xf8\x2b\x72\ +\x0b\x21\xb4\x2a\x90\x54\x9f\x58\x3a\x14\xfd\xdb\xab\x0b\x2e\xfb\ +\xe4\x65\x7b\xf2\xf9\xaf\x25\xa5\x52\x76\x39\x51\x19\x41\x0b\xc0\ +\xbb\x08\x41\x0b\xc0\x3b\xb3\x88\x88\x82\x9b\x6f\xbe\x99\xa4\x94\ +\xda\x18\x53\x61\x66\x99\xfd\xd3\xc7\x4e\x29\x9f\x33\x77\x87\x19\ +\x8e\x0b\xaa\x3d\x17\xbb\x55\x9b\xc3\x87\xf7\x74\x54\xae\xe8\xdb\ +\x2b\x6b\x43\x36\x81\xbd\x79\xa6\x9d\x73\xa9\x16\x9c\x24\x36\x98\ +\xc9\xb8\x99\x46\xf6\xa6\x2e\x88\x28\xe3\x02\x92\xba\xe0\x84\x6d\ +\x86\xc3\x05\x4d\x55\x1b\xd8\x84\xa2\xd6\xbd\x96\x98\x39\x34\x66\ +\xa6\x5b\x6c\x2d\xf3\xc2\xe9\xd0\x09\x33\x45\x44\x54\x21\x72\x43\ +\x4e\x4c\xc1\xf7\xb7\xf5\x4c\xf4\xb6\x95\xe7\x2e\x69\x29\x91\xcb\ +\x8e\x94\x62\x29\xff\x3d\x0d\x58\x14\xd5\x82\x80\x74\xc8\xa6\x6e\ +\xf8\x26\x72\xfb\x33\xc6\xf8\xd9\x94\xf4\x3c\x5c\xf0\x92\xfb\xfa\ +\x0b\x0b\x83\xbb\x77\xaf\x10\x4a\xe7\x4c\x10\x26\xf1\x87\x7a\x5e\ +\xa8\x7e\x61\xfd\x33\x2a\x1b\x1a\x1b\xd8\x48\x3b\x1c\xa6\xea\xbb\ +\xe3\x3a\x65\xbb\x79\x22\x62\x51\x35\x5a\xde\xb3\xb5\x3d\x7a\x70\ +\xdf\xca\xe8\x9e\x1d\xa7\x70\x96\xa7\xaa\x0b\x5a\x0f\x55\x3e\xb3\ +\xfa\x25\xea\x6c\xaa\xba\x6c\x8a\x3b\x24\x9b\x91\x11\x36\xb3\x95\ +\x5e\x26\x72\x19\xa1\x7c\xa8\xd4\x05\x0b\x06\x9a\x7e\xb0\xbb\xe3\ +\xa6\x9b\x4e\x3b\x78\xfb\xed\xd3\x2b\xb5\x7e\xe6\x31\x22\x9a\xb5\ +\x9e\x13\x00\x9c\x38\x08\x5a\x00\xde\x99\x45\x8b\x16\x2d\x8a\x57\ +\xaf\x5e\xed\x32\x25\x19\x31\x51\x15\xc1\x2b\xa3\x9d\xe5\xbf\xbf\ +\xea\xfe\xf0\x5b\xaf\x2e\xa8\x7e\x74\xf1\x00\x11\x11\x95\x62\x49\ +\x61\xa0\x39\x17\xb9\xa6\x71\x8a\x6c\x66\xc5\x15\x89\x26\x49\x92\ +\xf1\x67\xd8\xb8\x1b\xbf\xf1\xc6\x4b\x82\x20\xa8\xc4\x71\x2c\x99\ +\x39\x70\xb3\x6a\x6c\x06\x43\x12\xa5\xc3\x3b\x91\x5b\x4b\xc8\x0e\ +\x1b\x11\x11\x91\x94\x24\xe2\x58\x87\x52\x92\x71\x85\xad\xb5\x61\ +\x29\x4d\xc6\x88\x58\x88\xb4\xae\xa4\xd2\xba\x65\x70\x7e\xb2\xb8\ +\x30\x59\xc9\x74\x4e\x13\x55\x89\x88\x8c\x28\x25\x49\xf0\xef\x5b\ +\x17\x54\x3f\xb6\x74\xaf\x68\xcc\x54\x6d\x0d\x8d\xb2\x35\x39\x59\ +\x63\x8c\xb2\xd3\x87\x33\xf6\xa7\xf2\x1e\x6b\x63\x4c\xe4\xa6\x3d\ +\x6b\xad\x83\xcc\x63\x83\x2d\xc1\xdf\x6f\x3a\x35\x18\xae\xb4\x24\ +\x3d\xd9\x91\xe9\xff\xb6\xe1\xd1\x64\x79\xe3\x54\xfd\x45\x76\x41\ +\x8e\x98\x59\x61\xda\x65\x6f\xfc\x2c\x4d\x4c\xde\x5a\x45\x3a\x62\ +\xa1\xaf\x59\x76\x28\xbe\x66\xd9\xa3\x54\xd6\x22\x7c\x78\x4f\x6b\ +\xf8\xcc\x81\x9e\x86\xcf\x3d\x72\xbe\xa4\xb0\x52\xfe\xf0\xbc\x6d\ +\xe5\x1b\x4f\x1a\x70\x85\xba\x5a\xeb\x34\x90\xb2\xe7\xa4\x8c\x31\ +\xa1\xbd\x4e\x86\x88\x48\xf5\x34\x26\x66\x5e\xa9\xfa\x6b\xe3\x17\ +\xb6\xdd\xa6\x1f\x8d\x89\xa8\x97\x88\xb6\x1f\x97\xbf\x24\x00\x78\ +\x53\x08\x5a\x00\xde\xbe\x2c\x11\x75\xdd\x70\xc3\x0d\xda\x66\x36\ +\x04\x33\x07\xd9\xcf\x3f\x74\xce\xd4\x6f\x9d\xf2\xac\x2e\x25\x21\ +\x85\x42\x53\x28\x0d\x13\x89\xe8\xbe\x5d\x6d\xc9\x79\x0b\xf7\x51\ +\x2d\x1b\xe2\xa6\xf7\xfa\x45\xa2\x69\x47\x57\xaa\x7d\xf3\x77\x43\ +\x28\x6e\xd8\xc4\xbd\x2f\x1d\x0a\xaa\x65\x4f\x66\x86\x82\x5c\x5f\ +\x18\xaa\x4d\x27\x8e\x6d\x8f\x94\xc0\x6e\x4b\x74\x76\xaa\xca\xd0\ +\x50\x68\xe6\xcd\x53\xb1\xd6\x3a\x34\xc6\x24\x5a\xcf\xb4\xa5\x97\ +\x52\x6a\x22\x45\x62\xc7\x58\x83\x99\xa8\x84\xf1\xda\xf9\x13\xc1\ +\x6b\xba\xd6\x4c\x4d\x91\x88\xbe\xb7\x63\x51\xf9\x9a\xa5\xfb\x29\ +\x1f\xa6\xeb\x10\x51\x6d\x65\xe7\x8c\xfd\xbc\xd0\x5a\x47\x44\x44\ +\x4a\x29\x21\xa5\x64\x2f\xa3\x22\xed\x63\x9d\xfb\xf2\x53\x2b\xc4\ +\x33\x43\xfd\x6c\x38\xae\x5e\xb9\xf4\xe5\xe2\x55\xbd\x07\xb9\x29\ +\x2a\x31\xb3\xa0\x5a\x90\x55\xb1\x19\xa3\xc0\xcf\x20\xb9\x6b\xe5\ +\x8e\xd7\xcf\xd8\x48\x29\xd3\x99\x56\xee\x7c\xdd\x39\x8a\x9c\xd4\ +\xf1\xa5\x0b\x47\xe2\x0f\xcf\x3f\x14\x3e\xb2\x7f\x3f\x0f\x4d\x67\ +\x83\x4d\x43\xf3\x1a\x6f\xba\x77\xb5\xba\x7c\xc9\x8b\xc5\xeb\xfb\ +\xf7\xda\x22\x5c\xc3\xcc\x31\x11\xb9\x59\x48\xee\xda\xba\xe2\x61\ +\xa9\xd7\x75\x8d\x2f\x19\x9e\xee\xfc\x50\xd7\x7c\xf1\xe8\xe0\x96\ +\x3e\xa2\x22\x82\x16\x80\x77\x09\x82\x16\x80\xb7\x6f\x01\x11\xf1\ +\xc7\x3f\xfe\x71\x69\x8c\x91\xcc\x4c\xe2\xe5\xe1\x02\xc5\x24\xf4\ +\x19\x3d\xe3\xd1\x0f\x76\x75\x24\x67\xf7\x0c\xd8\xd9\x2f\x01\x25\ +\x26\xd2\x6d\xd1\xac\x15\x8c\x6d\x03\x39\xe5\x6e\xfa\xb6\x3f\x49\ +\x60\x0b\x6a\xb3\x75\x43\x28\xae\x47\x89\x1b\x0a\x72\x41\x4c\x35\ +\x8a\x22\x63\x8b\x59\x15\xd7\xd6\x2b\x8a\xa4\x94\xfe\x5a\x3e\x19\ +\x63\x0c\xb5\xb7\x53\xbc\x79\xb3\x6a\xec\xee\xd6\x93\xee\x79\x22\ +\x97\xb5\xd0\x61\x1c\x6b\x29\x4a\x5a\xf2\xcb\x03\x73\x4b\xe7\xae\ +\x1e\x2a\x95\x12\x11\x86\xb5\xa1\x92\xe8\xdf\x5e\xeb\x89\x2f\xe9\ +\x3d\x40\xf9\xb0\xbe\xa3\xed\x11\x1f\xfb\x4d\xe5\x5c\x80\x93\xff\ +\xd2\xe3\xa7\xca\x9d\xe3\x1d\xdc\xd3\x78\xa8\x7c\xf5\x92\x17\xab\ +\x97\xf6\x1d\xb0\x43\x4c\xf5\x43\x46\x69\x60\x66\x09\xfb\x9e\x8a\ +\x10\x22\xd2\x5a\x8b\x20\x08\xca\x2e\x2b\xe5\x02\x9b\xfa\xf3\xb5\ +\xdb\x0a\xec\x35\x21\x11\x86\xd5\xe4\x82\xde\xfd\xa6\x9a\x64\x45\ +\x6b\xb6\xaa\x34\x6d\x93\x1b\x07\x16\x34\xfd\xca\xbd\x27\x97\x7f\ +\x7d\xd5\x53\xf1\xd9\xbd\xa3\xfe\xb0\x9b\x9b\xb5\xa5\xb5\x8e\xfc\ +\xe1\xa8\xea\xe5\x8b\x86\x7e\xeb\xff\x5b\x31\xef\xe9\x1f\xed\x5d\ +\x56\xa1\x67\x1e\x22\x0c\x11\x01\xbc\x2b\x30\xe5\x19\xe0\xed\x9b\ +\xdf\xd3\xd3\x93\xf4\xf7\xd7\x5a\x76\x08\x21\x4c\xc3\x5f\x3d\xb7\ +\x2e\xfe\xfc\x87\x36\x12\x11\x51\xa9\x1a\xe9\xf6\x1c\x13\x11\x67\ +\x36\x0e\x16\xf4\xaa\xf6\x31\xa2\x74\x4a\x6f\x6c\x1f\x07\x75\xb5\ +\x1e\x91\x94\x32\xed\x8c\x6b\x33\x06\xae\x0f\x8b\xdf\xbf\x25\x6d\ +\x10\x27\x84\x88\xdc\xec\x1b\x9b\x59\x70\x53\xa0\xd3\xcc\x83\xf0\ +\xda\xda\x33\xd7\xa6\x07\xdb\xe7\x13\xa2\xa0\x5c\x7b\x1c\xc4\xcc\ +\x5c\xe9\xd8\xb8\x7d\xee\xc1\x0d\x2b\xf6\xe4\x72\xa6\x5c\xa9\xb0\ +\xc8\x66\xe5\x74\xf6\x7b\xdb\x3b\x92\x75\x9d\x87\xf4\x9c\xdc\x14\ +\xd9\x86\x6c\xae\x59\x9d\xd7\xc8\x8e\x6c\x71\x70\xd5\x9e\x4b\xd5\ +\x1d\x6f\xe6\xaf\x9e\x5b\xd8\xf4\xcb\x3f\xb8\xd8\x74\x35\x4d\xc6\ +\x1f\x5e\xb8\xa9\xfc\x9f\xd7\x6d\xae\x7e\x62\xd9\xde\xa0\x35\x57\ +\x74\xdb\x08\x82\xc0\x1d\x93\x26\x6f\x51\x42\x1b\x98\xb9\x22\xe3\ +\xac\x3b\xa7\x24\x49\xb2\x36\x60\x49\xd7\x13\xb2\xc7\x50\x76\xd3\ +\xbc\x83\x20\xa8\xb8\x6e\xb9\x36\xe0\x0b\x8d\x31\x19\x0a\xa5\x29\ +\x5f\xdc\x7b\xd0\xac\xea\x98\x4e\x96\x34\x8e\x4d\xff\xd9\x87\x1f\ +\xca\xfd\xdd\xab\x2b\xf2\x7f\xf0\xd3\x53\xdd\x7e\x5d\x4f\x97\x24\ +\x49\x72\xde\x54\x69\xc5\xcc\x15\x63\x4c\x32\xff\x37\xcf\x1f\xbc\ +\x9c\xe6\x76\x11\x51\xf7\xdb\xf9\xe3\x01\x80\x63\x87\xa0\x05\xe0\ +\xed\x11\x52\xca\xb9\x57\x5f\x7d\x75\x9a\xad\x94\x8f\x0e\xb4\xa9\ +\x86\xb0\x9a\xf4\x14\xa6\xe4\xab\x87\xa4\xe9\x6d\x9a\x20\xb2\x0d\ +\xcf\xf6\x8e\xb7\x24\x2b\xda\x8a\x44\xae\xf7\x09\x49\xaf\x43\xad\ +\x61\xe6\x69\x77\xa3\xb5\x7d\x58\xfc\xec\x83\x0b\x42\xd2\x80\x84\ +\x88\xd8\x7f\x9f\xed\x51\xe2\x02\xa1\xb2\x0b\x16\xec\x4d\x3b\xd1\ +\x5a\x73\x92\x24\x76\xa5\xe8\x99\x7e\x24\xb5\xc2\x56\x17\xf0\x24\ +\x61\x78\xdf\xee\xf9\x93\xcb\xbb\x0f\x4d\x25\x41\xb6\xa5\x85\xb8\ +\x52\x21\xd1\xf4\xc2\xae\xae\x6a\x77\xae\xaa\xfb\x5a\xa6\x8d\x31\ +\x39\xaa\x15\xde\xce\xd4\x8e\xd4\x86\xaf\x5c\xa6\x28\xf2\x1e\x67\ +\x32\x3f\xdc\x3d\xaf\xf1\xa6\x1f\x5c\xca\x49\x52\x28\xff\xc2\xca\ +\xcd\x6a\x61\x61\xb2\xfc\xa9\x95\x43\xd5\xf6\x4c\x2c\x84\x20\x37\ +\x94\x44\xb3\x17\x45\x54\x4a\xa9\x34\x68\x73\xe7\x62\x83\x11\xf7\ +\x38\xed\xe5\x42\xb5\x26\x77\xe9\xef\xc1\x06\x36\xee\xfc\x22\x37\ +\x9c\x64\x8c\x49\x83\x45\xdb\x94\xaf\x9c\x2c\x28\x94\xab\xd7\x2d\ +\xdf\x1b\x3c\xb4\xab\xbd\xf4\x07\xeb\x37\x25\x67\xce\x3b\xd8\xf8\ +\xa9\xbb\xaf\x08\x9f\x3e\xd0\x44\xb5\x6e\xc4\x7a\x66\xb3\xb5\x6e\ +\xc4\xc6\x98\x0c\x33\x07\xab\xcf\x3f\x33\xd9\xd2\x54\x3d\x44\x14\ +\xcc\x3f\xa6\xbf\x1c\x00\x78\xdb\x10\xb4\x00\xbc\x3d\x9d\x4a\xa9\ +\xe0\xe2\x8b\x2f\x36\xae\x51\x59\xf6\xab\xcf\x9d\x56\xfc\x1f\x17\ +\x3c\xa9\xb5\x0e\xe5\x8b\xc3\x73\xf5\xfa\x79\x93\x42\x08\x23\xc7\ +\xe3\x40\x34\x65\x2a\xcc\x3c\xed\x35\x90\x63\x29\x67\x5a\xa8\x18\ +\x63\x72\x5e\xa6\xc0\x4d\xc1\x3d\x2c\xdb\x62\x67\xb8\x54\x88\x88\ +\x6c\x46\xa6\x36\x27\xda\x6b\xe8\x66\x8c\xc9\xba\x19\x3c\x2e\x1b\ +\x41\x54\xcb\xc8\xe8\x99\xee\xba\x72\xa6\xeb\x6d\x2d\xf0\xc9\x8e\ +\x94\x22\x11\x6b\x55\xea\x69\x9a\x9e\x98\x20\x2e\x14\x92\x32\x0f\ +\x94\xb2\x85\xa9\xd8\xd0\x19\xf3\x87\xdd\xb1\xb8\x1b\xb9\x3b\x17\ +\x63\x8c\x72\xc7\xe4\x67\x91\x9a\x7e\xf7\x81\xf5\xe1\xbd\xbb\x97\ +\x4c\xfd\xd9\x87\x1e\x12\x73\x1b\x47\xf4\x69\x5d\x63\xc9\x95\x8b\ +\x0f\xb8\xd7\x6b\x97\x61\xd6\x32\x04\x87\x35\xa4\xb3\x01\x82\x7b\ +\x9c\x75\x01\x88\x9b\x49\x64\xcf\x31\x71\xc3\x52\x7e\xf0\x67\x33\ +\x37\xfe\x12\x08\x19\x6f\x96\x53\x60\xb7\xc7\x14\x4a\x5d\xb9\x7e\ +\xf9\x0e\xb3\x65\xa4\xa0\x7a\x32\xa5\xe2\xdf\x5e\x7d\x4f\xf6\x6f\ +\x36\x9d\x1e\xfc\xd3\x8b\x8b\x74\x5d\x37\x62\xef\x5a\x1a\x66\xae\ +\x2e\x3c\x2b\x7f\x40\xca\x93\xd1\x1d\x17\xe0\x5d\x82\xa0\x05\xe0\ +\xed\xe9\x94\x52\xd2\x59\x67\x9d\xc5\x5a\xeb\x50\xde\xff\x5a\x97\ +\x69\x2f\x8c\x88\xbc\x28\x93\x22\x16\xa1\xd4\xa6\xd6\xeb\x44\xc9\ +\x87\x5f\x6f\x2f\x9f\xd5\x33\x6a\x8c\xc9\xf1\xec\xf5\x72\x88\xbd\ +\xb6\xf6\x7e\x50\x43\x44\xda\x65\x62\xfc\x6c\x8b\x9f\xc9\xb0\xf5\ +\x1c\xae\x28\x95\xbd\x2e\xb2\x86\x99\xed\x90\x8f\x50\xcc\x3c\x6d\ +\x1f\xc7\x5a\xeb\x72\x10\xd4\x9a\xd1\xb9\x0c\x06\x91\x48\x84\x31\ +\xba\xed\xa5\x03\x73\x2a\x57\xf6\xed\x27\xaa\xad\x3b\x14\x0a\xa1\ +\xf3\x4f\x0d\x74\xc6\x57\x2e\x1a\xf2\x8e\x37\xfd\x6f\x86\x94\x92\ +\xed\xcf\xf4\xf9\x20\x08\x38\xfa\xde\xae\x9e\xc6\x4f\xdd\x7d\x45\ +\xe5\xca\xbe\x6d\xf1\xef\x9f\xf1\x6c\xe6\x27\xfb\x3b\xca\x9f\x5c\ +\xbe\x2f\xe9\xcc\x55\x89\x48\xb9\x99\x50\xb6\x9e\x27\x71\xe7\xee\ +\x65\x8d\xdc\xf1\x6a\xef\x71\xba\x04\x80\xed\xfd\x92\x12\x42\x64\ +\xdc\xf1\xf9\xc1\x9f\x9e\x59\x88\xd2\xf5\x88\x71\xfb\xaa\xba\xeb\ +\xe3\x6d\x3b\x52\x57\x2d\x39\x28\x34\x31\x3f\xb3\xa7\x6d\xf2\xef\ +\x2e\x7b\x20\xdc\x38\xd4\x9b\xff\x9f\xcf\xae\x72\x81\xa2\xb7\x1c\ +\x80\xa9\xed\xca\x44\x57\x5d\x75\x51\xa4\x94\x69\x20\xa2\x86\x37\ +\xfd\x8b\x01\x80\x77\x0c\x41\x0b\xc0\xdb\xd3\x39\x6f\xde\xbc\xe9\ +\x6c\xb6\x36\xb1\x26\xfa\xc7\xed\xa7\x4d\x7d\xe9\xbc\x17\xb4\xd6\ +\x61\xf8\xe4\x40\x4b\x75\x55\xeb\xb8\xbb\x61\x06\x15\xad\x5c\xb1\ +\xa9\xcd\x9a\x54\x88\xd2\x96\xf4\xfe\xb0\x46\x1a\xd4\x68\xad\x43\ +\x29\xa5\x98\xc9\x86\x70\xc5\xdd\xe0\xb5\xd6\xfe\x30\x49\xfa\xd8\ +\x18\xa3\x5d\xcb\x7b\x3b\xeb\xc6\x2d\xac\x98\x73\xdb\x14\x42\x64\ +\x33\x19\xd2\xd3\xd3\x26\x37\x33\xd4\x94\x64\x83\x1f\xee\x9e\x3b\ +\xb1\xb6\x63\x78\x7a\xda\xe4\x6b\xdb\x25\x91\xb9\x7b\xdb\xc2\x91\ +\xf5\x8b\x86\x64\x44\xec\x67\x41\xbc\xe2\x5a\x17\x1c\x48\x17\x3c\ +\x85\x9f\x7f\x78\xbd\xbc\x7f\xc7\xd2\xc9\xaf\x7f\xe4\x07\x71\x77\ +\x3e\xa1\xe7\x0f\xb4\x96\x7f\x61\xc5\x5e\x9d\x99\x39\x2f\x2f\x00\ +\x4b\x33\x1f\x7e\xb0\xe1\x1d\xaf\x30\xc6\x64\x89\x88\x94\x52\x69\ +\x37\x5d\x63\x4c\xa2\x94\xd2\xee\xfc\xbd\x2c\x54\xfa\x58\x08\x11\ +\xbb\xf7\xd8\xfa\x9b\x8c\xbb\xb6\x36\xf0\xcb\xda\xd7\xb4\xdd\x36\ +\x13\x11\x25\xe7\xce\xdf\x1f\x4c\x25\x4a\x3c\xbd\xbf\xb9\xf8\x97\ +\x17\x3c\x46\x71\x95\x0a\xb7\x3c\x72\xb6\x3d\x56\xbf\x30\xd8\x08\ +\x21\xf4\x99\x67\x9e\xe9\xfe\xdd\x71\x6c\x7f\x3e\x00\xf0\x76\x20\ +\x68\x01\x38\x76\x2c\xa5\xec\xb8\xec\xb2\xcb\x72\x42\x08\x9d\x79\ +\x62\x6f\x0b\xcf\xc9\x4d\x52\x96\x14\x33\x57\xe4\x9e\x71\xa1\x97\ +\xd4\xea\x57\xe8\xe5\xa1\xe6\x78\x51\x53\x9a\x4d\xb1\x59\x93\x0c\ +\x79\x0b\x05\xda\xc0\xc3\x05\x27\xd3\x5e\x10\x92\x50\xad\xad\xbf\ +\x9b\x3d\xe4\x8a\x41\xb3\xde\xcd\xde\x7f\x9c\xf1\x03\x09\x57\x17\ +\x62\x0b\x78\xdd\x4d\xbe\x32\x6f\x5e\x52\xde\xb7\x2f\x0a\x5d\xb6\ +\x21\x9a\x8a\x95\x29\x27\x09\xf7\x34\x4e\xc7\x31\x97\x99\x85\xca\ +\xee\x3e\x54\x30\xad\xb9\xb1\x4a\x3e\x52\x41\x20\xd2\xcc\x84\x3d\ +\xd6\x74\x31\x44\xf7\x53\x54\x44\xdc\xf4\x9b\xf7\x5d\xa0\x9a\xb3\ +\xa3\x53\x7f\xb1\xe1\xe1\xf0\xf9\xa1\xa6\x70\xcf\x14\x55\xaf\xea\ +\x3b\x60\x8c\x49\xfc\xcf\x7b\x35\x2a\xd3\xf6\x3a\xa4\x99\x21\x3b\ +\x7b\x2a\xad\x3b\x71\x59\x19\x66\xf6\xd7\x2d\x8a\xfc\x21\x23\x2f\ +\x08\xca\x1a\xaf\xe6\x87\x67\xd6\x11\xf2\xeb\x62\x2a\x5e\x96\xc5\ +\x28\xa5\x94\x7b\x9f\xdb\x46\xe5\x92\x85\x13\xc1\x70\x35\x23\xb6\ +\x0c\x17\xca\x9f\x3f\x67\xb3\x6a\xcb\x14\xf3\x5f\x7a\xfc\x54\xf7\ +\x79\x63\x4c\x45\x29\xc5\x5a\x6b\xd1\xdf\xdf\x4f\xcd\xcd\xcd\x86\ +\x88\x3a\x8f\xf1\x6f\x08\x00\xde\x06\x04\x2d\x00\xc7\xae\x51\x29\ +\x15\xac\x5b\xb7\x4e\x11\x91\x89\xbe\xf6\xc2\xda\xa9\x5b\xce\x78\ +\x9a\x88\xc8\x4c\x57\x73\x3a\x17\x86\xee\x66\x1b\xbd\x36\xde\x54\ +\x3d\xb5\x73\xc4\xbb\x41\xbb\xe1\x89\x74\x15\x67\xff\x5b\xbc\xcd\ +\x38\xb8\x1b\x72\x44\x33\x05\xa6\xec\x86\x37\xec\xf0\xcf\xb4\x7d\ +\xde\x30\x73\xc9\x3e\x9f\x0e\x05\xd9\xa1\x17\x17\xfc\xa4\xb5\x2f\ +\xcc\x2c\xb2\x59\x52\x95\x8a\x0e\x5d\x10\x30\xe7\xf9\xdd\x3d\x93\ +\x17\x2c\x1c\x8f\x22\xa3\x2b\x15\x2a\x04\xcc\xb2\x71\xf7\x68\x73\ +\xe5\xbc\x9e\xe9\x24\xd1\xcc\xac\x43\x97\x99\xb0\x41\x52\x9a\x35\ +\x21\x22\x0a\x5f\x1c\x6f\x2d\xdc\xf4\x9d\x8f\x4d\xfd\xca\xaa\xe7\ +\x2a\xbf\xbb\x76\xb7\x7c\x66\x60\x0e\x8d\x4c\x47\x95\xab\x16\x4f\ +\xda\x7d\x06\xfe\xe7\xa5\x94\x6e\xc8\x26\x43\xb5\x61\x2d\xe3\x8e\ +\xc5\xd6\xe9\xb8\x6b\xa1\xec\xbf\xc9\x0b\x6a\xb4\x7f\x8e\xde\xf0\ +\x51\xe2\xcd\x88\xd2\xe4\x2d\x84\x98\x24\x49\xd6\x0b\x72\x32\xee\ +\x58\xec\xfe\xfc\x05\x13\xcb\x6e\x1b\xc9\x95\x8b\x07\xa3\x67\x0e\ +\xe6\xf5\x64\x59\x4c\xff\x97\x75\x5b\x44\xb5\x12\x64\xfe\xe6\x99\ +\xe5\xee\xf3\xde\x30\x99\x59\xbc\xb8\x75\x8a\x68\xc1\xdc\xb7\xfe\ +\xe7\x03\x00\x6f\x17\x82\x16\x80\x63\xd7\x4a\x44\xb4\x7a\xf5\x6a\ +\x49\x2f\x0c\x36\x9a\x4c\x54\xe2\xd6\x5c\x49\x08\x61\xc2\xe7\x86\ +\x9a\xe3\x93\xda\x46\xa5\x94\xca\x15\xac\x72\xc0\x81\x9b\x75\x43\ +\x94\x76\xab\x0d\x68\x66\xc1\xc3\x59\x37\x5c\x1b\x84\xb8\xba\x8f\ +\xb2\x1b\xf2\x71\x6b\xf9\xd8\xe1\x9f\xc8\x66\x67\xd8\x98\xda\x90\ +\x8e\x3f\x14\xc4\xb5\xa6\x73\x99\xba\xfd\xb9\x40\x83\x93\x44\x33\ +\x11\x89\x60\xcb\xa1\x42\xb8\xa8\x30\x51\x54\x59\x9d\xc9\x90\xae\ +\x56\x85\x9e\xff\xdc\x8e\xe6\x7d\xcb\xe6\x8f\x7a\x19\x8f\xb4\x9e\ +\xc4\xcd\x46\x72\xc7\x1d\xdd\xbb\xab\x33\x73\xeb\xa3\x67\x17\x6f\ +\xbf\xec\x7b\xfa\x8c\x9e\x71\xb9\x75\x4c\x46\xa3\x71\xa8\x2e\xe9\ +\x3b\xe8\xcf\xd4\xf1\x02\xae\xc4\xf5\x9b\x71\xe7\xe8\x35\xda\x73\ +\x45\xb8\x6e\x18\x27\x53\x3f\x64\x64\xfb\xd7\xb8\xc7\xee\xba\x12\ +\xd1\xcc\x10\x96\x52\x4a\xb9\x7a\x20\xae\x35\xfd\x73\xf5\x3d\x89\ +\x17\xec\x91\x0d\x1c\xd3\x21\x1f\x21\x44\xd6\xab\x17\xe2\xf2\xc7\ +\xfb\x0f\x45\xdf\xd9\xd6\x4b\x44\x54\xba\xf5\xa2\x27\xc3\x2d\x63\ +\x2d\xd9\x7f\xda\x32\xd7\x7b\xbf\x12\x42\x24\x1f\xfa\xd0\x7c\x25\ +\x44\xd7\x5c\x7f\x5b\x00\x70\x62\x20\x68\x01\x38\x76\xad\x52\x4a\ +\xd3\xdf\xdf\x4f\xb9\xaf\x6c\x5a\x57\xfa\xec\x19\x9b\x5d\xb6\x84\ +\x07\xa6\x72\x66\x49\x6b\x85\x88\x84\x78\x61\x28\xab\xe6\xd5\x5a\ +\xd2\x0b\x21\xe2\xba\x60\x24\x2d\x42\x25\xa2\xc0\x9b\xd6\x2c\x6c\ +\x10\x72\x58\x61\x29\x7b\x6b\x05\xd9\xed\xa4\x75\x32\x5e\x91\xa9\ +\x5f\xd0\x5a\x72\xfb\x72\x37\xeb\x20\x08\x66\xb2\x09\x49\x52\x11\ +\x9b\x86\x5a\xe8\x9c\xae\xe1\x89\x09\x61\x32\x19\xa3\x93\xdd\x93\ +\xd9\x4c\x3e\x29\x0f\xeb\xac\xbb\x29\x1b\xa2\x34\x03\x42\x4a\xa9\ +\xf4\xc6\x1c\xfd\xc3\x8b\x0b\x32\xff\xb2\xe5\x94\xa9\x7f\xba\xf2\ +\x07\xa6\x25\xa3\x78\x68\x3a\xca\x6c\x3a\xd8\x56\xbd\xac\x6f\xc8\ +\xee\xd7\x15\x12\xa7\x53\x87\x93\x24\x49\x0b\x8d\x93\x24\x49\x87\ +\x6c\x8c\x31\xae\x2e\xa5\xe4\xba\xfa\x4a\x29\x5d\x0f\x97\xd8\x1b\ +\x5e\xf2\x67\x52\x55\xbc\x6b\x68\x78\x66\x55\x67\xbf\x6e\x26\x12\ +\x42\x64\xed\xb5\x4d\x83\x1c\x57\xef\xe3\x5d\xdb\x4a\x5d\xe0\x38\ +\x2d\x1a\x32\xe5\xe4\xcc\x9e\x91\xf0\xc7\xbb\xdb\x89\x48\x97\xbe\ +\x72\xc9\xe3\xd1\x0f\x77\x9e\x12\x1d\x98\x76\x81\x8d\x24\xa2\x60\ +\xd5\xaa\x55\x52\xeb\x44\x12\x8a\x71\x01\x4e\x38\x04\x2d\x00\xc7\ +\xae\x79\xc1\x82\x05\x89\x8c\xa5\x94\xca\x08\xdd\xdf\x38\xcd\xcc\ +\x15\xd6\xba\x4a\x32\xd0\x44\xb5\x1b\x9a\xd8\x3a\x3a\x27\x3e\xb5\ +\x73\xca\xfe\x3b\xac\x0b\x46\x22\x22\x12\xae\xc3\x2d\x33\xa7\x8d\ +\xe3\xec\x0d\xd4\x0d\x81\xc4\xee\xb1\xad\xbf\xa8\xd8\xc7\xe9\x2c\ +\x1a\x5b\x93\xe1\x66\xf7\x64\xbc\x82\x55\x5b\x54\x3b\x93\x91\x48\ +\x92\x24\xcd\x26\x64\x36\x0f\x77\x99\xe5\x6d\x93\x2d\x2d\xa4\xa7\ +\xa7\x4d\x43\x3e\x4f\x3a\xfb\xcc\x81\x79\xd1\x35\x7d\x23\xd5\x2a\ +\x4b\x37\x25\x58\x6b\x2d\x5d\xf3\x3a\x37\xb5\x3a\xfc\xdf\xcf\xf7\ +\xcb\xa7\x87\xfa\x26\xef\xba\xfc\x3e\xad\x75\x60\xa6\xab\xd9\xf0\ +\xfe\x9d\x5d\xa5\x8f\x2f\x1e\xd6\x5a\x0b\xad\x35\x7b\x43\x42\x91\ +\x0b\x22\x6c\x00\xe1\x56\x59\x4e\x87\x8c\xbc\xac\x50\xde\x1e\x3f\ +\x2b\xa5\x0a\xee\xda\xd9\xa1\x24\x77\x2e\x6e\xda\xb2\xf0\x32\x31\ +\x89\x10\xc2\x0d\x9d\x95\x6c\x33\x3d\x37\x74\xe6\xd7\x0b\xb9\x20\ +\x27\x71\x81\x98\x2b\xd4\xf5\xb2\x2c\xc2\x0d\xd3\xe9\x25\x2d\x25\ +\x9e\xaa\x04\x3c\x56\x0e\xb4\xd6\x3c\xf5\xf9\x73\x1f\xce\xfc\xe1\ +\x43\xe7\x7b\xbf\xa3\x64\xe5\xca\x95\xe9\xdf\xc5\x3b\xfb\xb3\x02\ +\x80\x37\x83\xa0\x05\xe0\x18\x49\x29\x1b\x4f\x3a\xe9\xa4\x30\x7f\ +\xeb\x13\x6b\xca\x57\x2e\x7a\x95\xa8\x36\x94\x21\x5f\x38\xd4\xa6\ +\xfb\x5b\x27\xd2\x37\xc6\x89\xe2\xa0\x76\x03\x25\x9a\x1d\x8c\xd8\ +\xcf\x24\x64\xb3\x25\x7e\x87\x5b\x7b\x03\xf5\x87\x79\xfc\xe1\x90\ +\xac\xf7\xd8\x15\x9d\xa6\x41\x0b\xd5\x66\xb5\xf8\xdd\x60\xdd\xf6\ +\xfd\x21\x92\x72\x4f\x8f\x29\x4f\x3c\x39\xd1\xa8\x4e\x9b\x3b\x42\ +\x44\x14\xc7\x62\x3a\xdc\x3a\x9c\xaf\xcc\x69\x1c\x0f\x32\xc1\xb4\ +\xdd\x47\x89\x59\x28\x21\x84\x76\x59\x0f\x66\x2e\x47\x5f\xdb\x3c\ +\x3f\xf3\xd2\x58\x77\xe9\xcb\x17\x3e\x68\x8f\x37\xce\xff\xfb\x8e\ +\x39\xea\xaa\x25\x03\x1c\x04\x25\x77\x0c\x2e\xd3\x63\xa7\x72\xbb\ +\x80\xcc\x3d\xe7\x17\xf7\xfa\xd9\x21\x77\x9c\x69\x67\x5d\xfb\x33\ +\x6d\xf2\xe6\xce\x55\xd6\x1a\xdd\xf8\x9d\x72\xd9\x06\x4b\x79\xff\ +\xb1\xf7\x9e\x9c\x9e\x59\x2f\x29\xad\x65\x51\x4a\xa5\x85\xc2\xf6\ +\x5a\x4d\xbb\xe0\x90\x88\xc8\x5c\xb5\x62\x4f\x78\xdf\xce\x4e\x22\ +\x62\xdd\xdf\x38\x5d\x3d\xbd\xe3\xf5\xdc\xff\xf8\xe9\x7a\x17\xd8\ +\xf4\xf5\xf5\xb9\xb7\x22\xd3\x02\x70\x82\x21\x68\x01\x38\x46\x4a\ +\xa9\x42\x63\x63\x63\x51\xec\x1e\x6d\x4a\xae\x59\xbe\xdf\x3d\x1f\ +\xec\x18\xcb\xeb\x93\x5a\x6b\xc5\xa7\xc3\xa5\xd0\xb4\xe5\xb5\xbd\ +\xb1\xb9\x9b\x66\x1a\x8c\xd8\x7f\x47\x4a\x29\x41\x54\xeb\x75\xe2\ +\x65\x01\xdc\x8d\xdc\x65\x52\x4a\xee\xa6\x2e\xa5\x2c\xd6\x0f\xff\ +\x50\x2d\x48\x70\x19\x18\xe3\xb6\xa3\x94\x62\x37\x83\xc8\xad\x43\ +\xe4\xa6\x59\x77\xef\x1f\xce\x0e\xb4\xb7\x27\x33\xcd\xd2\x74\x36\ +\xd8\x3c\xdc\x7a\xe8\xa4\xae\x62\x92\x24\x2e\x03\x92\x37\xa6\xb6\ +\x14\x80\xcb\x7a\x64\xbf\xbe\x79\x59\xf4\xfc\xa1\xbe\xa9\xbf\xbe\ +\xe0\xa7\x2e\x68\x8a\x1e\xdb\xdf\x15\x9f\xd4\x5e\x56\xcd\x99\xc4\ +\xcc\x74\xcc\x95\x2e\xd3\x63\xa7\x72\xbb\xa6\x70\x6e\xdb\x69\xcd\ +\x8d\x7d\xcd\x2d\x12\xe9\x66\xf2\x70\xdd\x50\x98\xbb\x66\xae\xb8\ +\x58\x19\x63\xd2\x86\x76\x2e\x18\xf4\x67\x07\xf9\x8f\x6d\x10\x54\ +\xf1\xb6\x97\x76\xe0\x95\x52\xa6\xc1\xa0\x7d\x6f\xce\x78\x4b\x2b\ +\xa8\x88\x02\xea\x6c\x48\x82\xed\x63\x79\x22\xa2\xf2\x6f\x9f\xf6\ +\x92\xd8\x3e\xd5\x1c\x6c\x9f\x8a\x88\x88\x0a\x85\x02\x65\xb3\xf9\ +\x84\x10\xb4\x00\x9c\x70\x08\x5a\x00\x8e\x4d\x40\x44\xd1\x2f\x88\ +\x93\xfb\xf5\xf2\x39\xa3\xb3\x7a\x77\x08\x16\xaa\xd6\x14\x2e\x09\ +\x9f\x1f\x6e\x49\x4e\xe9\x18\x0f\x82\x60\xda\xff\x16\xcf\xcc\x25\ +\x7f\x4a\x6f\x18\x86\x55\xa2\xda\x90\x84\xbd\x49\xbb\xac\x8c\xdf\ +\x30\x2d\xef\x6e\xb0\x4a\xa9\x82\x37\x24\xe2\x0a\x70\x67\x15\xa7\ +\x7a\x41\x47\x5a\x80\xeb\x4f\x05\x26\x22\xc1\xaf\x8e\x34\x4d\x2e\ +\x69\x2b\xba\x59\x4e\xf9\x1d\x07\xf3\xc9\xe2\xd6\x49\x3b\xac\xe2\ +\x3a\xdd\xc6\xc6\x90\x76\xdd\x5f\xc3\x1f\x6f\x6f\x0f\x1e\xd8\xb3\ +\xb8\x74\xdb\x45\x0f\xb8\xe3\xe7\xe1\x52\x28\x0f\x95\xa5\x3a\xb5\ +\xe3\x90\xdd\xbf\xeb\x93\xa2\xbc\xf3\x8c\xdd\x79\x79\xbd\x53\xfc\ +\x16\xf9\xc2\x16\x1a\x13\xcd\x14\xe4\xa6\x8d\xf3\x8e\x52\x90\x9b\ +\x16\x1d\xdb\xe1\x27\xf7\x38\x9d\x1d\x54\x37\x53\x28\xed\x89\x53\ +\x5b\xca\xc0\xf8\x43\x43\xe9\x34\x6e\x5b\xb8\xeb\x17\xeb\x56\x92\ +\x24\xa9\x54\x37\x2c\x18\x11\xcf\x0e\xb5\x52\xad\xd6\x86\xaa\xff\ +\x7d\xc3\xc6\xdc\xff\xb3\xf1\x1c\xf7\xbe\x85\x0b\xbb\x05\x51\xb6\ +\xf1\xe8\x7f\x36\x00\x70\x3c\x20\x68\x01\x38\x36\x39\x22\xa2\x35\ +\xdb\xc4\x8a\xf2\xef\x9d\xf5\x5c\x7a\x43\x2e\xc5\x52\x47\x6c\x98\ +\x39\x90\x52\x4a\x9a\x98\x0e\x4d\x7b\x3e\x4e\x92\x24\xe7\x7f\x8b\ +\x37\xc6\xe4\x5d\xd6\x41\xd7\x16\xe3\x9b\xf9\x46\xaf\x54\xda\x4c\ +\x8e\x6a\xc3\x46\xee\x46\x9a\x16\x89\xb2\xd7\x40\x2d\x08\x82\x92\ +\x9b\xa1\x63\x33\x30\xc6\x4e\x09\x2e\x79\x9f\x2b\x7b\xaf\xd7\x32\ +\x39\x3b\x47\xc9\xcc\x2d\x4c\x0b\x11\xa4\x2d\xf7\x73\xdb\x46\xf3\ +\x7a\x5d\xd7\x98\x31\xa4\xbd\x6c\x86\x66\xae\x05\x16\x62\xf7\x78\ +\x94\xbd\xeb\x95\xf5\xc5\xdb\x3e\x7c\xbf\x99\xe9\x48\x6b\xc2\x9f\ +\xbc\xde\x55\xbd\x62\xf1\x80\xf7\x5c\xda\x36\x5f\xcc\xac\x9f\xe4\ +\x66\x52\x19\x6f\xdb\xb1\x37\xc3\x27\xad\xd9\xf1\xb2\x27\xe9\xb9\ +\x11\x91\x2b\xc8\x4d\x8e\x74\x6e\xcc\x3c\xed\x0d\x25\xa5\x5d\x85\ +\xd9\xeb\x29\xe3\x1d\x17\xd9\x6b\xef\x66\x53\xb9\x25\x14\xd2\xe0\ +\x4e\x08\xe1\x67\xc3\x32\xb6\x2f\x0e\x9b\xb6\x4c\x85\xf7\x4d\x64\ +\x88\x88\xab\xdd\xb9\x8a\xce\xc8\x6a\xf8\xf8\xeb\xad\xc6\x18\x55\ +\x28\x4c\x4e\x12\xf5\xb5\x1c\xe1\xef\x05\x00\x8e\x23\x04\x2d\x00\ +\xc7\x26\x93\x25\x92\x61\xae\x60\xa8\x16\x8a\xb0\x10\x42\xcb\x4d\ +\x43\x4d\xc9\x8a\xb6\x09\x21\x44\x62\x92\xa4\x22\x84\x74\x2b\x20\ +\x27\x36\xbb\xe2\xb7\x90\xf7\xbf\xc9\x97\xbd\xe9\xc0\x4a\x29\xe5\ +\x6e\xae\x7e\xff\x90\x59\xd3\x80\x5d\x21\x6a\x92\x24\x79\x97\x8d\ +\xb0\x19\x18\xb6\x53\x82\xf3\xde\x7b\xb3\xde\xeb\xb5\x0e\xbd\xcf\ +\x0c\xcd\x8f\xcf\x9a\x3b\x2a\xa5\x8e\x92\xc4\x64\x79\xcf\x44\x36\ +\xe9\xca\xda\x7d\xce\x9a\x61\x93\x21\xd2\x81\x2e\x95\x82\xfc\x2d\ +\x0f\x5f\x51\xf9\xbf\x3f\xfc\x13\x9d\xc9\xa4\xb5\x34\xf2\x89\x81\ +\x0e\xb3\xa2\x63\x5c\x07\x33\x2b\x55\x9b\x99\x6e\xb6\xb3\x7a\xb3\ +\xd8\x4c\x09\xbb\x80\xc0\x78\x8d\xe0\xdc\xd0\x93\x5f\x30\x6c\xb3\ +\x4b\x6e\x89\x82\x82\xb7\xcd\xc3\xce\xcd\x98\x99\xee\xbe\xa6\xd6\ +\x07\xc6\x5f\xc3\xc9\x65\x68\xfc\xfe\x2f\x89\x94\xd2\xd5\xfa\xa4\ +\xbf\x0f\x57\xb8\xeb\x67\xc2\xfc\xe0\x29\x3e\x7f\xfe\x48\xf0\xd8\ +\xfe\x26\x9b\x2d\xe2\xe2\x17\xcf\xda\x98\xfd\xda\xab\x6b\x89\x88\ +\xfb\xfa\x5a\x58\xca\x46\x64\x5a\x00\x4e\x30\x04\x2d\x00\xc7\x26\ +\xf3\x87\x74\xe1\x49\xc5\x0f\x75\x6e\x27\x1b\x58\x68\xad\x45\x78\ +\xb0\x9c\xd5\x7d\x2d\xd3\x5a\xeb\x50\xee\x9c\x68\x53\xf3\x1b\xcb\ +\x44\x33\x37\x5a\x9e\xdd\x42\xde\xff\x26\x9f\xf3\x5e\x4b\x83\x13\ +\xaa\xfd\x7f\xd3\x15\x9c\xa6\xcd\xe1\x6c\x81\x6b\x3a\xec\xe2\x65\ +\x18\xfc\x21\x8e\xb4\xbb\xac\x57\xeb\x51\xeb\x44\x5b\x8e\x05\x2b\ +\x55\xa4\x50\x9a\x79\xf3\xe2\x89\xed\xdb\x25\x85\x4f\x1e\x98\x33\ +\xba\x6a\xd1\xbe\xda\xb6\x67\x15\xd0\x96\x85\x08\xe2\xa6\xcf\xfe\ +\xf4\xbc\xe9\x5f\x3b\xed\x81\xea\xdc\x5c\xc5\x66\x7a\x2a\xa4\x88\ +\xc3\x5d\x13\x61\xbc\x66\xce\x24\xcf\xee\x32\x7b\xa4\x69\xca\xd3\ +\xc6\x2e\x31\xe0\x17\xe7\x7a\x4b\x11\xf8\xd9\x93\x8a\xff\x19\x9a\ +\xdd\x3c\x2f\xf6\x5e\xf7\x57\xb5\x9e\xb5\x88\xa3\x37\x64\x67\xdc\ +\x63\xae\x2d\xb0\xe8\x66\x55\xa5\x2b\x3f\x0b\x21\x22\x2f\xd0\xe2\ +\xba\x4c\x58\x30\x2b\x78\x0a\xa5\xe1\x4c\x18\x06\x89\x5d\x99\xba\ +\x25\xab\xcc\xdc\xc2\x44\xee\x87\xaf\x77\x34\x35\x15\x14\x11\xb9\ +\x21\x38\x00\x38\x41\x10\xb4\x00\x1c\x9b\x60\x19\xb5\x76\x4c\x5d\ +\xdb\xbf\x87\x6a\x5f\xe0\x13\x17\x44\x10\xd9\x2e\xae\x2f\x0e\x07\ +\x6a\xc5\x9c\x43\x44\xb5\x6f\xef\x52\xca\x22\xcf\xf4\x00\x49\xec\ +\x50\x8d\x26\x22\x0a\x82\x60\x3a\x08\x02\x77\x73\x8f\xb5\xd6\xae\ +\xa0\x56\x1b\xdb\xbb\xc4\xee\x67\xd6\xf0\x86\xc3\x33\xbd\x49\xfc\ +\x69\xcf\xae\xe3\xac\xf4\x87\xa2\x88\x48\x86\x8f\xee\x6f\x33\x17\ +\xf6\x15\x89\x88\x9a\x9b\x99\xd5\xa4\x6a\xa0\x48\x2a\x11\xe8\x0c\ +\x11\x09\x63\xb4\xf4\x8a\x65\xb3\xf3\xbe\xf5\xd4\xca\xea\xc2\x86\ +\x91\xe4\x82\x1e\x17\x08\x65\x8d\x31\x99\xe8\xc7\xbb\x3a\xaa\x17\ +\xcc\x1f\xb7\xcf\xf9\xb5\x23\xe9\x34\x65\x6f\xa6\x93\xeb\x20\x2b\ +\xdc\xb6\xb9\x36\x35\xdb\x1d\xa7\x5f\x83\xe3\x0a\x76\x43\x66\x66\ +\x21\x04\x31\xb3\x0b\x06\xd2\x29\xce\x6e\x7b\xee\x3a\xb8\xe0\xc4\ +\xab\x93\xf1\xaf\x99\xf1\xae\xe5\x61\x01\x9e\x0b\xae\xc2\x30\x74\ +\x99\x15\x7f\x9d\xa8\x74\xca\xb4\x10\x22\x49\x4e\x69\xdf\x17\x3c\ +\x76\x20\x2d\xb8\x9d\xfe\xc2\x79\x4f\x07\xff\xf6\xda\xca\xa6\xa6\ +\x26\xad\x54\xec\x32\x43\x00\x70\x82\x20\x68\x01\x38\x36\xf2\x26\ +\xba\xe7\xa1\x6c\x36\x9b\xb6\xe0\x37\x89\xc9\x68\x3b\x23\xd7\x06\ +\x0a\x05\xdd\x10\xb8\x82\x52\x56\x4a\x15\xcc\x4c\x0f\x90\xc0\x0e\ +\xd5\x08\x22\xa2\x24\x49\x72\x7e\xe1\xac\xeb\x5d\xe2\x0f\x95\xf8\ +\x43\x2d\x5a\xeb\xc0\xcf\x04\x78\x6b\x0d\x05\x6e\x9b\x64\xff\x7f\ +\x6d\x0b\x5b\x6b\x07\x2d\x25\x49\x29\x0d\x8f\x57\xa3\xca\x9c\xc8\ +\xcd\xa8\x31\x0d\x9b\x07\x9a\xf5\x99\x3d\x87\x8c\x21\xed\x3a\xd5\ +\x2a\xa5\x74\x14\x19\xa5\x9e\x9c\x6c\x68\xdc\x3a\xd4\x55\xfe\xc3\ +\xb3\x5f\xf0\x87\xb0\x44\x55\x19\x51\x56\xf2\xb1\x5d\x2f\x94\xbf\ +\xf8\xc5\x2f\x52\xb5\x5a\x4d\x3b\xd0\xba\xf7\xd9\xcc\x8a\x9b\xc5\ +\xa4\x6c\x3f\x1a\xa2\x99\xa9\xcb\xda\xd5\xef\xf8\xc5\xb9\xe4\xcd\ +\x14\x12\x42\x90\xd6\x9a\xdc\x0c\x2b\x5b\xac\xec\x66\x17\x49\x77\ +\x9e\xf6\x7a\xa4\x33\xb4\xec\xeb\xec\x05\x52\x5c\x9f\xdd\xf2\x6a\ +\x58\xb2\xee\x7d\x71\x1c\xbb\xcc\x8a\x3f\xf5\x3c\x9d\x32\xad\xb5\ +\x0e\xf4\xc2\x66\xc1\xe3\xe5\x34\x68\x51\x91\x22\xd6\x71\xd4\x9a\ +\x6b\xcd\x11\x19\x74\xc4\x05\x38\xc1\x10\xb4\x00\xbc\x75\xab\x88\ +\x68\x69\x99\xca\x2a\x8a\x22\x57\x03\x51\x91\xaf\x0c\x4b\x63\x3b\ +\xdf\x12\x11\xa9\x4a\xec\x4f\xaf\xad\xef\xb6\x6a\xfc\x6f\xfa\x41\ +\x10\xf8\xaf\x25\x41\x10\xb8\xfa\x0a\xed\x4d\xd7\xd5\xde\xf3\xca\ +\x4d\x6f\xb6\x35\x17\x69\x2f\x13\x6f\xd6\x4f\xd5\xb5\xc9\xf7\x82\ +\x09\x45\x13\x31\x53\x3e\xf4\x3b\xf1\x9a\x70\xb2\x12\x24\x9d\xb9\ +\x6a\x26\x63\xe2\x72\x59\xb2\x52\x9a\x84\x10\x49\x7b\xbb\xa9\x04\ +\x7f\xfa\xd3\x0d\x5b\x3e\x7d\xd1\x23\x6e\x5f\xf6\x33\x5a\xde\xff\ +\x7a\xfb\x57\x5e\xf9\xc1\xf0\x17\xbf\xf8\x45\xbe\xed\xb6\xdb\xe8\ +\x77\x7e\xe7\x77\xc4\x23\x8f\x3c\xe2\xb2\x11\x2e\xbb\xa1\xdd\xbe\ +\xbd\xb6\xff\x7a\xd6\xf1\xd4\x8a\x75\xfd\x29\xda\x9a\x66\x86\xc1\ +\xd2\x75\x96\xbc\x61\xa0\xd8\x65\xb5\x6c\xe6\x44\x7b\x8f\x89\x6a\ +\x43\x49\xe9\x75\xf2\x32\x28\xca\xbb\x96\xc6\x5e\xcb\x74\x4d\x23\ +\xe1\x2d\x50\x59\x37\xd3\xab\xe2\xff\x1e\xd3\x21\x2f\x9d\x16\x1d\ +\xd7\x56\x93\xbe\x6c\xf9\xe6\x0b\x1f\x4c\x56\xd8\xa7\xce\x21\xa2\ +\xae\xfa\x3f\x1c\x00\x38\x3e\x10\xb4\x00\xbc\x75\x73\xc8\x76\x3d\ +\xb5\x59\x00\x36\xc6\x64\xe4\xde\xa9\xb6\x78\xd9\x9c\x5a\x5d\xc6\ +\x78\x25\xe0\xe6\xac\xf0\xbe\xf1\xfb\x2b\x3b\xbb\xcf\xa4\x8b\x0e\ +\x26\x49\xe2\xbf\x16\x24\x49\xe2\xb2\x2b\xc2\xcb\xae\x08\xef\x79\ +\xe9\x32\x33\x76\x08\xc6\x15\xc0\x66\xf4\xec\x95\x9f\xd9\x6e\x23\ +\xed\x64\x2b\x37\xee\xed\x8c\x4f\xeb\x1a\x4b\x0b\x58\x0f\x14\x73\ +\x8d\xbd\xa2\xba\x6f\x1f\x67\x7a\x7a\x94\xd9\xb7\xcf\xe4\x99\x6b\ +\x19\x8a\xe5\x5f\x7f\xec\xe4\xc1\xb3\x96\xec\xd2\x8d\x61\xda\xbc\ +\xcd\xed\x93\xa7\xe3\xec\x4f\xb7\x3c\x13\xef\xd8\xb1\x83\x89\x88\ +\x9e\x78\xe2\x09\x3e\x70\xe0\x40\x5a\x28\x4c\x94\x66\x8a\x32\x75\ +\xc7\x23\xeb\x8e\x57\xfa\x9d\x73\xb9\xb6\x92\xb5\x2b\x32\x3e\xe2\ +\x39\xf8\x05\xb7\x5e\x46\xe4\xb0\x8c\x8a\xdd\x97\xcb\xa0\x48\xef\ +\xf8\xd9\x5e\x4b\xbf\x29\x5d\xe8\x1d\xb3\x3f\xd3\x2b\xe3\xff\x1e\ +\xdd\x90\x97\x5a\xdc\x5a\x0a\x5e\x1e\x6d\x70\xcf\x95\xae\x5b\x32\ +\xdc\x59\xca\x74\xdb\xb7\xcd\x25\x3b\x44\x06\x00\xc7\x1f\x82\x16\ +\x80\xb7\xee\x61\x22\x7a\x96\x88\xc8\x0e\x75\x90\x31\x26\x16\xc5\ +\x58\x8b\xe6\x4c\x4c\x44\x14\xbc\x7a\xa8\x41\xf5\xb5\x8c\xb8\x0c\ +\x08\x51\x9a\x4d\xa9\xaf\xa9\x48\x17\xf4\x73\xdf\xe6\x8d\x31\x8a\ +\x67\xaf\x7f\xe3\x67\x5a\xdc\x63\xe5\x3d\xf6\x0b\x53\xab\x5e\xf6\ +\xa6\x6c\x33\x14\xda\xab\x97\xa9\xca\xb1\x58\x98\xce\x5c\xda\x89\ +\x36\xf3\xd4\x60\x73\xcb\x15\x0b\x5e\x1f\x19\xe1\xa8\xa9\x89\x4b\ +\xa5\x52\xad\x0d\xbe\xdc\x3e\x29\x32\xc3\xc5\xc6\xc1\x2b\x4e\xde\ +\x16\x04\x41\xac\x14\xb1\xdb\x4e\xf0\xe8\xbe\x06\x3a\xb9\xe3\xe0\ +\x5d\x77\xdd\x45\x9f\xfb\xdc\xe7\x14\x11\xd1\xc3\x0f\x3f\x9c\x5c\ +\x7f\xfd\xf5\x6e\x1a\xb6\xdf\x79\xd7\x5f\x23\xc8\x75\xc9\xf5\x0b\ +\x69\xd3\xda\x11\x77\x8c\x6e\xe6\x8e\x7f\x0e\xde\xf5\x89\xeb\x8a\ +\x6f\x67\x75\xd1\x25\x22\xe3\xf6\x6f\xb3\x2b\xee\x5a\xfa\xd7\xcc\ +\xb8\x6d\xbb\xed\x78\x43\x5f\x09\xcf\xce\x90\x55\x83\x20\xa8\xcf\ +\xb4\x54\xe2\x55\x73\x26\xc4\xb6\xe1\x46\x7b\x4c\x09\x33\x57\xab\ +\x42\x4d\xf5\x51\x53\x8e\x88\xbe\x43\x44\x3b\xde\xc2\xdf\x12\x00\ +\xbc\x0d\x08\x5a\x00\x8e\x8d\x26\x22\xaa\x56\x6b\x31\x88\x94\x32\ +\xa0\x50\x84\xae\x9e\x84\x07\x4b\x59\xb5\xb8\x45\x9b\x99\x66\x6e\ +\x2e\x9b\x92\xfe\xbb\x2e\x4b\x10\x79\xd9\x89\x34\x13\x71\x84\x4c\ +\x8b\x7b\x7c\xb4\x4c\x4b\xe4\x65\x6f\xd2\x2c\x45\x5a\x2f\x93\x98\ +\x8c\x0e\xcd\xac\xcc\x84\xae\xc4\x61\x9c\x49\x8b\x76\x43\x66\x12\ +\x41\x40\x26\xff\xdf\x1f\xbf\xf0\xf5\x9b\xcf\x7a\x92\x48\x07\x51\ +\xa4\x39\x8e\x89\xe3\x38\xae\xad\x1d\x34\x30\xd5\x54\x5d\xd6\x5a\ +\x21\x22\xea\xef\xef\x17\xd7\x5d\x77\x1d\x45\x51\x24\x8d\x9d\x86\ +\xed\xde\xe7\x3a\xef\xba\x6d\xdb\x42\x59\xe1\x17\xda\x92\xfd\xef\ +\x8f\x7f\x0e\xee\xf5\x23\x65\x5a\xfc\x4c\x8c\xcb\xd4\xf8\xe7\x43\ +\x44\xec\xce\xd7\x66\x57\xd2\x85\x0d\xbd\x6b\xc6\x6e\xdb\x6e\x3b\ +\x3c\xb3\x02\x76\x60\x66\x67\xc8\x22\xbf\x8f\x4e\x7a\xbd\x25\xb1\ +\xb0\xff\xe9\x64\xe6\x80\x99\xc3\x67\x97\x57\xb6\xfe\x2a\x2d\xe8\ +\xa7\x99\x9a\x1d\x00\x38\x01\x10\xb4\x00\x1c\x1b\x4d\x44\x54\x2e\ +\x97\xc9\x18\xa3\x8d\x31\xb1\x4e\x74\xda\x7e\x5f\x28\x63\x38\xe0\ +\x52\x5d\x66\xa5\xe4\xbe\xb1\xd7\xcf\x1e\xf2\xd7\xb9\x61\x6f\x6d\ +\x22\xfb\xad\xde\x2d\x9a\x98\xd4\x3d\x9f\x66\x4f\xea\x32\x17\x69\ +\xa6\xc5\xbe\x57\xb9\xe3\x88\x5e\x19\xc9\xe8\x45\x2d\x63\xee\x73\ +\x54\xd6\x82\x24\x27\x5e\x03\x37\xad\x94\xa6\xbe\xc7\x5e\xee\x1c\ +\x99\xd3\x30\x5a\x6a\x6d\xac\x1a\x43\x9a\x59\xe9\x38\x26\x26\x22\ +\xcd\xe3\x95\xc0\x34\x44\xe9\xf4\xe2\x0d\x1b\x36\xe8\xdb\x6f\xbf\ +\x9d\x0a\x85\x82\x36\x33\xcd\xe5\x5c\x9d\x49\x3a\x4d\x5b\x29\xa5\ +\x8f\x54\x88\x4b\x33\x75\x25\xae\x8b\x6e\x62\xbc\x7e\x36\xf6\x75\ +\x53\x97\x59\x3a\x6c\x85\x67\x9b\xb9\x72\x4b\x1e\xb8\x1e\x38\xe9\ +\x54\x69\xaa\x75\xb1\x2d\x7a\xd9\x95\x92\xf7\xd9\x69\xb7\x2e\x93\ +\xad\xb3\xf1\x97\x49\xa8\xd6\xcf\x1e\xf2\x6b\x60\xec\x67\x34\x11\ +\x25\x9b\x7b\xca\x07\xfe\x37\xed\xde\xe2\xde\x0b\x00\x27\x06\x82\ +\x16\x80\x63\x13\x13\x11\x15\x8b\x45\x92\x52\x1a\x31\x34\x95\x35\ +\x2d\xe1\xcc\x74\x64\xc1\x82\x99\xb3\x75\x99\x95\xbc\xfb\xc6\x5e\ +\x3f\x7b\x48\x78\xeb\xdc\x18\x6f\x6d\x22\x7f\xca\xb0\x94\x52\x6a\ +\xad\x33\x44\x44\x4a\xa9\x74\x1a\x33\x33\xa7\xb3\x69\xec\x14\xe0\ +\x23\xcd\x5e\xa9\xdd\x70\x5f\x1b\xcd\xeb\x93\xbb\x26\xed\x73\x2a\ +\x7c\x6e\xa0\x59\x9d\xdc\x71\x48\x08\xa1\x16\x2e\xe4\xe9\xed\xdb\ +\x39\x10\x42\xe8\xb6\x07\xb6\x2f\x7b\xf5\x3f\x9e\xb7\xa9\xb6\x2f\ +\x93\x44\x91\x48\x2a\x15\x16\x42\x88\x6a\xb8\x71\xa0\x4d\x9d\x31\ +\x6f\xc8\x9b\x21\xe4\x77\xbc\x75\xbd\x63\x5c\xb0\xa6\x92\x24\x49\ +\x97\x03\xa0\x5a\xd1\x6d\xda\x6d\x57\x08\x91\xb8\x59\x43\x64\xbb\ +\xd5\xda\x75\x93\xdc\xb5\x54\x76\x78\x88\x94\x52\x87\x9d\x97\x7f\ +\xbe\xb6\x07\x8b\x9b\xe1\x93\x2e\x57\xe0\xcd\x18\x62\xd7\x7c\xcf\ +\xfd\x3e\xbc\xd9\x43\x39\x6f\xc6\x96\x24\xa2\x42\x5d\x16\x6c\xd6\ +\xec\x21\x9b\xe1\x09\x34\x93\x21\x45\x2c\xa5\x64\x22\xe2\x89\x89\ +\x09\x1a\x90\x15\x17\x24\x01\xc0\x09\x82\xa0\x05\xe0\xd8\x54\x88\ +\x88\x46\x47\x47\x6b\x53\x70\x5f\x9f\xc8\xab\xee\x42\xda\xe1\x96\ +\x0c\x25\x76\xf6\x4e\x7a\x43\x97\x52\x16\xfd\x0c\x82\x5b\x31\xd9\ +\xfe\x3b\xed\xb8\x1a\x04\x41\xd9\xab\xc3\x48\xb3\x0a\x44\xa4\x5c\ +\x07\x57\x9a\xfd\x4d\x9e\xeb\xa6\x3c\x4b\xa2\xda\xd0\x8a\x7d\x2e\ +\x1d\x22\xa1\x80\x33\x9a\x67\x6e\xd4\xf2\x60\x39\xab\x16\x37\x27\ +\x49\x92\x64\x9b\x9b\x55\x32\x39\x69\x1a\xbb\xbf\xb7\xa9\x5f\xaf\ +\xeb\xde\x6d\x6f\xd4\x24\xa5\xc9\x66\x32\x5a\x6a\x2d\x6b\xab\x25\ +\x4f\xc5\x81\x6e\x8b\xfc\x62\x5a\x57\x14\x1b\x99\x99\xee\xb4\x79\ +\x7b\x5e\xa1\x0b\x06\x84\x10\x39\xad\xb5\xb0\xc7\x93\x73\xc7\xc8\ +\x33\x4d\xf5\xfc\x15\xad\xd3\xce\xba\xf6\x33\xec\x0d\xf3\x84\x6e\ +\x9f\xfe\x14\x6f\x37\x25\xba\x76\xcc\xd2\xcf\xe0\xc4\xde\x63\xbf\ +\x8e\xc8\x6f\xfb\xef\x67\xb7\x8e\xd4\x11\x77\xda\x9b\x39\x45\xc6\ +\x98\xc4\x18\xa3\x54\x7b\xb6\x22\x5e\x1f\x4b\x0b\x8c\x27\x26\x8a\ +\xa1\x10\x33\xf5\x2f\x00\x70\x62\x20\x68\x01\x38\x36\x15\x22\xa2\ +\x83\x07\x0f\x6a\x66\xae\xca\x81\xe9\x50\xf7\xb6\xd4\x86\x68\x86\ +\x4b\xa1\x69\xce\x26\xb6\xf6\xc2\x65\x40\xa4\x52\xaa\xe0\xdd\xa0\ +\x23\xd7\xb6\xde\xfe\x3b\xed\xb8\x5a\x57\xfb\xc2\x3c\xd3\x1d\xd7\ +\xef\x5d\x92\x78\x19\x8e\xd8\x1f\xe6\x20\x9b\xcd\x70\x41\x51\x7a\ +\x43\x56\x8a\x4d\xac\xd3\x69\xd6\x52\xca\xa2\x9e\x79\xdd\x0e\x8d\ +\x04\xa5\xb6\x17\x07\x17\x54\xfe\xf3\x69\x2f\x2a\x55\xbb\x89\x67\ +\xb3\x3c\x55\xa9\x18\x55\xa9\x90\x08\x62\x9e\xa6\x9c\x54\xf6\x33\ +\x55\xb7\x7f\xf7\xd3\x1b\xa6\x3a\x6c\x78\xcb\x06\x02\xca\x16\xd5\ +\xa6\xdd\x76\xdd\x67\xdc\xf1\xda\xcf\xa4\x1d\x73\xbd\xc0\xc2\x75\ +\xc4\xf5\xd7\x1e\x4a\x87\xc6\xec\xe7\x5c\xa0\xa1\xbc\x6c\x8d\x1b\ +\xa6\xaa\xef\xe5\x92\xf5\x02\x2e\x3f\xbb\x75\xa4\x8e\xb8\x39\xb2\ +\x4b\x01\xd8\x63\xad\xd5\xe1\x34\x67\xaa\x34\x59\x75\xbf\x5b\x08\ +\xb0\x2a\x00\x00\x20\x00\x49\x44\x41\x54\x53\xb5\x73\xe7\x48\x12\ +\xc7\x93\xe9\xb4\x77\x00\x38\x31\x10\xb4\x00\x1c\x9b\x32\x11\xd1\ +\xe8\xe8\xa8\x30\xc6\x64\x8c\x36\x59\x2a\x84\x9a\x88\x48\xee\x2b\ +\x65\xaa\xed\xd1\x34\x79\xc5\x98\xec\x75\x5c\xb5\xff\x2e\xf9\x37\ +\x7d\x9e\xbd\x0e\x51\x5a\x07\xe3\x9e\x22\x3a\x7c\xc5\xe3\xba\x69\ +\xbf\xee\xf9\x3c\xd9\x25\x05\x5c\x50\xe4\x6e\xc8\xc1\xfe\x72\x26\ +\xe9\xc9\xa7\x8b\x04\xaa\x6a\xb5\x81\x98\x8c\xf1\x3a\xd9\xf6\xfe\ +\x68\xd3\xf2\xf2\xca\xae\xbd\xe3\xe3\x41\x26\x08\x38\x43\x44\xb4\ +\x68\x11\x99\xf1\xf1\x20\x57\xad\x92\x90\x9b\x07\x3b\x93\x65\x6d\ +\x93\x36\xab\x92\x4e\x11\x76\x3f\xdd\x31\x71\x6d\x75\x6a\x22\xa2\ +\xc0\x3d\x66\xe6\xac\x94\x52\xd8\xe6\x70\x69\xb7\x5d\x97\x41\x71\ +\xc7\x6b\x33\x29\x6e\x6d\x21\x7f\x3d\x21\xb7\x9a\xf5\xd1\xd6\x1e\ +\x4a\x83\x10\x5b\x64\x9b\x2e\x8b\xe0\x5d\x4b\xe3\x86\xa3\xec\x2c\ +\xad\x74\x36\x11\x7b\x6b\x43\x05\x41\x50\x09\x82\x20\x1d\xe6\xb1\ +\x33\x9a\xd2\xdf\x8b\xd6\x5a\x48\x29\x59\x34\x67\x13\x2e\xc6\xe9\ +\xf9\x97\x4a\x4d\xcd\x44\x3b\xc7\x09\x00\x4e\x28\x04\x2d\x00\xc7\ +\x26\x26\xa2\x78\xf3\xe6\xcd\xd3\xcc\x5c\x26\x33\x93\x05\x91\x23\ +\x45\x29\xba\x1b\xcb\xe4\x7d\x33\x37\x5e\xc7\x55\xfb\xef\xbc\x77\ +\x83\x0f\xbd\xba\x0b\xe3\x16\x15\xb4\xef\x4b\xb3\x05\x75\x43\x1b\ +\x69\x9b\x79\x2f\x43\x91\x66\x30\x8c\x31\xb1\x2b\x2c\x75\x45\xa3\ +\xbc\xe3\x50\xc1\x2c\x6c\x1e\x71\x53\x88\xe5\xb6\x71\x99\x74\x37\ +\x4c\x0b\x21\xd2\x4c\x4d\xef\xe6\x9d\x3d\x3b\x3e\x7e\xea\x8e\x7d\ +\xfb\x74\xc6\x98\x5a\xd0\x95\xcd\x9a\x44\x29\x4d\x95\x0a\x09\xde\ +\x3b\x59\xd0\x4b\x5a\x8e\xa9\x66\x43\x29\xe5\xae\x4d\x3a\x64\xe3\ +\x75\xbf\x3d\xac\xe8\xd6\x9f\xde\xec\x4f\x13\xb7\x43\x34\xe9\xf9\ +\xbb\xcf\xbb\xc7\xf6\xbd\x2e\xab\x93\x66\x8f\x82\x60\x66\x15\x6b\ +\x77\x8d\xed\x75\xf3\x97\x37\x70\xd9\x95\xb4\x6f\x4e\x92\x24\x79\ +\xef\xf7\x15\xd9\xa1\x2e\x17\x88\xb2\x52\x4a\xeb\x5c\x54\x12\xc5\ +\x38\xad\xb5\xd9\xb5\x6b\x50\x13\x15\x27\x8e\xe5\xfa\x00\xc0\xb1\ +\x43\xd0\x02\x70\x8c\xa4\x94\x53\x63\x63\x63\xb5\x60\x84\xd3\xc5\ +\xf9\xc8\x4c\x55\xf3\xaa\x25\x4c\xd7\xc1\x31\xc6\x24\x76\xe6\x4b\ +\xda\x13\xa4\x2e\xb3\x92\x2e\x1a\x28\x84\x50\x76\x71\x62\xf7\xed\ +\x3f\xf2\x16\xf8\xcb\x79\xc5\xa1\x69\x9b\x79\x2f\x43\x91\xae\xec\ +\xcc\xcc\x81\x10\x22\xad\x01\x21\x22\x29\xc7\xab\x91\xea\x2e\x28\ +\x7b\x5c\x26\xd8\x39\xd1\xa0\x97\xb7\x4d\x19\x63\xb4\x52\x8a\xc2\ +\x47\xf7\xb5\x99\x8e\xfc\xb0\xd6\x44\x71\x4c\x8a\x48\xcc\x2a\xa0\ +\x55\x8a\x0c\xc5\xaa\x6a\xb7\x59\x71\x43\x31\xfe\x4f\xb7\x66\x92\ +\x31\xc6\x9d\xaf\xf6\x3b\xcd\x92\x2d\xb6\x75\x43\x4a\x54\x0b\x52\ +\x5c\xf0\xa5\x85\x10\xda\x5b\x86\x60\x56\xcd\x8a\xd6\x3a\xbd\x16\ +\x2e\x53\xe3\x67\x5d\xec\xb0\x9a\x5b\x1d\x3a\xcd\xc0\xd4\x37\xee\ +\x73\x43\x3b\x36\x50\x51\x62\xf6\x1a\x43\xd3\xde\xbe\xd3\x19\x5d\ +\x96\xa2\xd9\xd9\xb3\x50\x37\x47\x01\x57\x6a\xc1\x67\xb9\x5c\xa6\ +\x52\x69\x2a\x20\xbb\x58\x24\x00\x9c\x38\x08\x5a\x00\x8e\x91\x52\ +\x6a\xea\x95\x57\x5e\x99\xb5\x80\x21\x33\x57\x38\xa6\xb2\x08\x67\ +\x66\x12\x49\x29\xd9\xce\x1a\x4a\x7b\x82\x98\xc3\xd7\xc0\x09\xed\ +\x36\x49\x29\xe5\xb6\x9f\x18\x63\xd2\x7a\x0d\xad\xf5\x1b\x4e\x7d\ +\x16\x42\xc4\x7e\xf1\xa8\x9b\xda\x4b\x76\xb8\xc8\x1e\x9f\xcb\x2c\ +\x48\x53\x55\x39\x6a\x0c\x95\xb1\x3d\x4a\xb2\xff\xb8\x65\xcd\xd4\ +\x17\xce\x7a\x41\x6b\x62\x29\x29\x24\x4a\xd7\x42\xca\x85\xa1\x60\ +\x63\xb4\xa0\x48\x66\xec\xf6\xfd\x7a\x90\xf4\xa7\x2b\xba\xf5\x86\ +\xa9\xd2\x2e\xb4\xfe\x30\x96\x10\xc2\x9f\x1d\x95\x21\x4a\x87\x74\ +\xd2\xf5\x7e\xdc\x71\xba\x99\x51\x52\x4a\xf6\x32\x1d\x69\xb0\xe1\ +\x35\xa0\x33\x5a\xeb\x69\xb7\x74\x81\x97\x8d\x71\x8f\x8d\xdd\x76\ +\xec\x05\x2a\xc2\xcd\x4a\xaa\xff\xbd\xf8\x33\xba\xdc\x53\x64\x33\ +\x41\xee\x89\x20\x08\xca\x5c\x49\xca\x42\x88\x64\xe7\xce\x9d\xee\ +\x69\xd4\xb4\x00\x9c\x60\x08\x5a\x00\x8e\xdd\xf8\xde\xbd\x7b\xa5\ +\x0b\x32\x88\xec\x8d\x2f\x14\xe9\xcd\xd7\xde\xe0\xd2\x45\x01\x6d\ +\xc0\x51\xf2\xfa\xb3\xf8\x85\xa4\x46\x4a\xe9\xd7\x88\xa4\xd3\x9d\ +\xb5\xd6\xa1\xbb\xd1\x73\xdd\x22\x8a\x6e\x7a\xaf\x52\xca\x4d\xbd\ +\x75\xb3\x95\x5c\x5f\x91\x5a\xb6\xc0\x50\x1a\xec\x30\x73\x59\x28\ +\x93\x16\xb8\x0a\x21\x34\x29\x4d\xdc\x9a\x9b\xea\xeb\x4b\x4a\xfb\ +\xf7\x87\xcc\x2c\x2a\x5a\x13\x6b\xad\xcb\x42\x48\x13\x8e\x25\x6c\ +\xf2\x72\xd2\x7d\xde\x0b\x90\xd2\x9f\x3c\xd3\x3b\x66\xda\xd4\x16\ +\x4b\xd4\xfe\x90\x8d\xeb\x53\x63\xf7\x69\x6c\x97\xda\xc3\x8a\x72\ +\xbd\x6b\x64\xbc\x5a\x20\xe5\x15\xfd\xa6\xfd\x5f\xec\xb5\x36\x5a\ +\x6b\x16\x42\xb8\x86\x71\xec\xd5\xc0\xb8\xc7\xfe\x52\x04\xfe\xa2\ +\x92\xb3\x86\xe0\xbc\xdf\x87\xae\x9b\x35\x24\x94\x52\xd2\xcf\x04\ +\xa9\xb1\x62\xc1\x34\x84\x91\xd6\x5a\x6e\xd9\xb2\xc5\x05\x89\xa8\ +\x69\x01\x38\xc1\x10\xb4\x00\x1c\xbb\xd1\x6a\xb5\xca\xbb\xb6\xec\ +\x10\x14\x86\x89\x9b\xc9\x22\x58\xb8\x60\x41\xdb\x21\x11\xe1\x65\ +\x3a\xdc\x0a\xc2\xae\x3f\x4b\xc4\xcc\x6e\xa6\x50\xda\x9c\xcd\xab\ +\x4f\x71\x43\x4a\xd3\xae\xbe\x85\x99\xcb\x61\x18\xfa\x2d\xe7\xfd\ +\x3e\x25\xe9\xaa\xc5\x71\x1c\xbb\xac\x45\x2d\xc0\x61\x4a\x83\x1d\ +\x63\x4c\x56\x4b\x4e\x0b\x5c\x73\x7f\xb3\x79\x59\x79\x6d\xc7\x5e\ +\x63\x4c\xae\xb9\xd9\x24\xa5\x92\xca\x77\x77\x2b\x3d\x32\xc2\x51\ +\x10\x04\x41\xb5\x1a\x8b\xfc\xc1\xb1\x82\xea\x6b\x73\xc3\x43\xa1\ +\xb4\xe3\x58\x4a\xa9\xf4\xa7\xb7\x7e\x4f\xc8\xcc\x6c\x8b\x6e\xd3\ +\x82\xdd\x24\x49\x5c\x1d\x4f\x3a\x4d\xd8\xd5\x8e\xf8\x45\xb9\xde\ +\x35\xf2\xd7\x11\x4a\x83\x38\x53\xeb\xfc\x9b\xce\xee\xa1\x99\x2c\ +\x4a\xda\x2b\xc6\x0f\x08\x99\xb9\xe2\x6a\x7c\x6c\x1d\x4d\xd9\xbe\ +\xe7\xff\x6f\xef\xde\x83\xe4\xba\xee\xfb\xc0\x7f\xcf\xb9\xb7\x1f\ +\xf3\x1e\x0c\xde\x00\x41\x12\x04\x41\x4a\xa1\x4c\x49\xa6\x29\xd1\ +\x8a\xe3\x28\x96\x45\x49\xde\x95\x14\xd3\x91\x5d\x2e\xd9\xeb\x4a\ +\x55\x6a\xbd\x2b\x39\xaa\xb5\x12\x97\x93\x4d\xb6\x36\x76\xed\x3a\ +\x76\xec\x4a\x4a\x71\x59\x95\x4a\xb4\x59\xae\x1d\xda\xd9\xa8\x44\ +\xeb\xb9\x22\x4d\x3d\x48\x51\xa4\xc4\x87\x48\x08\x7c\x00\xc4\x1b\ +\x20\x5e\x33\x18\x0c\x66\x30\xaf\xee\xbe\xf7\x9c\xb3\x7f\xdc\xfb\ +\xbb\x7d\xa6\x31\x33\x7d\xbb\xa7\x7b\xa6\x87\xf8\x7e\xaa\x50\x00\ +\x66\x7a\xba\x6f\xdf\xb9\x7d\xef\xef\xfe\xce\xef\xfc\x8e\xf4\x79\ +\x71\x8d\xdb\x90\x0e\xb7\x65\x43\x72\xd6\x5a\x15\x04\x81\x2c\x74\ +\x99\x0c\x6f\xcd\x55\x03\x57\x0a\x6b\x5a\x6b\xf3\xda\x6b\xaf\x39\ +\xad\x03\x0b\x80\x35\x2d\x44\x5d\xc6\xa0\x85\xa8\x75\xd3\x00\x70\ +\xfa\xf9\x1f\x6b\x37\x10\x54\xd3\x80\xa4\x64\x5d\xd6\xe0\x4c\x3b\ +\xe7\xb2\x69\xcf\xde\xb0\x4e\xd6\x01\x36\x0c\xc3\x8a\xd4\xbe\xa4\ +\x5f\x2b\x78\x3f\xeb\x67\x07\xfa\x54\xbd\x81\x5c\x21\x8a\x22\x09\ +\x4e\x6c\xfa\x98\x2c\x23\x91\x76\xc0\xcd\x86\x8f\xac\xb5\x15\x18\ +\xa3\xb4\x75\x59\x51\x6b\x18\x86\x15\x0d\x25\xdd\x63\x6b\xfa\xa5\ +\x4b\xb7\x9a\x4f\xfd\xe4\x1b\x2e\x5b\x91\xd9\x98\xbe\x3e\x67\xe7\ +\xe7\x93\x36\xfb\x5b\xb7\xba\x5a\xf5\x72\x65\xd0\xed\x1d\x94\xa2\ +\xd9\xc0\x0b\xc4\xb2\xbf\x65\x1b\xd3\x40\x42\xde\x97\xd4\x90\xf8\ +\xe7\x99\xac\x28\xd7\xcb\xd8\x18\x6f\xfb\xaa\xde\xfa\x42\xcb\x15\ +\xe0\x66\xef\xd1\x39\x97\x65\x60\xbc\xd7\x84\xd6\xba\x20\x01\xa1\ +\x73\xae\x24\x43\x57\xde\x14\x66\x00\xd9\xb0\x53\xd6\x83\x45\x29\ +\xb5\xe8\xad\x35\xe4\x94\x52\xd9\x70\x92\x0c\x77\x49\xc0\x14\x54\ +\x6c\x80\x81\x82\x33\xc6\xe8\xef\x7d\xef\x04\xac\xbd\x76\x45\xde\ +\x17\x11\x75\x0f\x83\x16\xa2\xd6\xcd\x04\x41\x60\xde\xf8\xf1\x91\ +\xa2\x1e\x4c\x66\xf5\xca\x37\xd2\xbb\x7c\xa9\xaf\x90\xa1\x1f\x9d\ +\x5e\x2c\x25\x10\x29\x4a\x03\xb8\x34\x2b\xe3\x0f\x53\x2c\xca\x85\ +\xd8\x1f\x56\x49\x2f\x9e\xd9\x73\x7a\x35\x17\x8d\x2b\x1b\x67\xd9\ +\x09\xad\x75\x59\x5d\xab\x86\x66\x38\xcc\xa6\xff\x46\x51\x14\x58\ +\x38\x9d\x0d\xc1\x84\xb0\x69\x9b\x7d\x03\x00\xf7\xde\x8b\xc9\x43\ +\x87\x0a\xb2\x18\x60\x65\xef\x5e\x57\x9d\xbb\xe6\xc2\xa8\x88\x45\ +\x6f\xfb\xfc\x59\x3f\x8d\x3d\x59\xb2\x61\x15\xaf\x2e\x27\x5b\x88\ +\x30\xcd\x88\x48\xb6\xc8\xa4\xf5\x28\x5a\xde\x5b\x1a\xf4\x48\x01\ +\x72\xd9\xfb\xb7\x0c\xf9\x64\xef\x51\x79\xab\x32\xa7\x41\x93\xcc\ +\xda\x52\x2e\x69\xf0\x67\xbd\x6d\xf2\xf7\x69\x63\xb6\x05\xe9\x6b\ +\xf4\x79\x6b\x0d\xa9\x74\x9f\xf9\x59\x30\x97\x16\xed\x56\x31\x17\ +\x6b\xd7\x1f\x18\xa5\x94\x3e\x7d\x7a\x61\x18\x38\x75\x71\xb5\x03\ +\x86\x88\x3a\x83\x41\x0b\x51\xeb\x9c\x31\x66\xf2\x85\xef\x3c\x5d\ +\x8b\x02\x58\xc9\x98\x68\xa5\x9d\xd6\xba\x98\x0e\x2d\xc8\x67\xcb\ +\x1a\x63\x8c\xae\xaf\x7b\x93\xad\xb2\x2c\xdf\x4f\xb3\x32\x7e\x66\ +\x25\xeb\xc9\xe2\x5d\x44\xb3\x22\x50\xe7\x9c\x3f\x1d\xb8\xe2\x05\ +\x39\x59\x03\xb9\x34\xd8\x71\xc1\x4c\xad\xe0\x46\xfa\x6b\x90\x96\ +\xf7\x55\x57\x42\x41\x59\x6b\xad\x2e\xfc\xd5\x6b\x77\xd6\x0e\x8e\ +\x4e\xa4\x35\x34\x45\x00\xb8\xf5\x56\x83\xab\x57\xb3\x5e\x28\xc9\ +\xdf\x1a\x05\x99\x91\x94\x6e\x5f\xd6\x28\x0f\xc8\x86\x6f\x64\xf8\ +\xa9\xcf\x6f\x91\xef\x7d\x5f\x86\x77\x4a\x5e\x6f\x19\xbf\x0e\x25\ +\x2b\xc0\xf5\x66\x4d\x39\xa4\x75\x27\x7e\xb1\x71\x3a\x83\xe9\x86\ +\xf7\xef\x96\xae\x02\x9d\xd5\x1c\xf9\x05\xcf\xe9\x3e\xcd\x16\x58\ +\x94\x9f\x4b\x5f\xc3\x29\xaf\xa9\x1d\x92\xe9\xcd\x81\x64\x94\xa4\ +\x3b\xaf\x52\xaa\x10\x5e\x9e\x2b\xba\x7d\x23\x0b\xa7\x4f\x9f\xc6\ +\xb5\x6b\x53\x0a\xc0\xc4\x2a\xc7\x0b\x11\x75\x08\x83\x16\xa2\xf6\ +\x4c\x5c\xbd\x72\xb5\x3f\xd2\x59\x2f\x12\x67\xa3\x38\xab\xab\x00\ +\x92\x0c\x03\x00\x1b\x04\x41\xe8\x05\x25\x59\xcb\x7b\x24\xd9\x05\ +\x87\x7a\x13\xb9\xac\x66\xc2\x25\x8d\xe7\x6a\xd9\x73\x27\x85\xb7\ +\x59\xdd\x8a\x37\x73\xa7\xec\x0d\x2d\x65\x2b\x3d\xa7\x14\x2a\x11\ +\x74\x41\x67\x33\x91\x0a\x0b\x71\xe4\xfa\x8a\x46\x29\x55\x2d\x3f\ +\x79\x61\x5f\xf5\xd7\xef\x3d\xe1\x07\x3b\x2a\xeb\x90\xab\x4d\x36\ +\xed\x37\x5e\xb2\x50\x61\x96\xc1\xf0\x33\x26\x7e\xd6\xc5\xcb\xc4\ +\xc8\xf4\x67\xe7\xd5\x95\xf8\x45\xbb\x15\xbd\x74\x28\xc8\xfa\xdb\ +\x90\xbe\x3f\xc9\x42\x65\x59\x91\x34\x30\xbc\xe1\xfd\xfb\x01\x11\ +\xd2\x25\x9b\xb2\x1d\xb1\xf4\x3d\x66\x35\x2f\xe9\x54\xe8\xac\x76\ +\xc5\x79\x4d\xed\xd2\x27\x51\xfe\xf2\x0a\xf2\x74\x76\x31\x2a\x99\ +\xa1\x82\x7d\xee\xb9\xe7\xe4\x6b\x0c\x5a\x88\xd6\x01\x83\x16\xa2\ +\xf6\x4c\x04\x91\x0b\x5e\x3d\x75\xdc\x38\xe7\xa2\x30\x0c\x6b\xd0\ +\x4a\x7b\x17\x4d\x19\xea\x90\x80\xc5\xf9\x41\x09\x92\x29\xb4\xb1\ +\x1f\x64\xa4\x33\x60\xb2\xe2\x55\x57\xef\x3c\x9b\xb5\xa9\xf7\x33\ +\x35\x0d\xc3\x2e\x56\x66\x0d\x01\x49\x8f\x12\x00\x50\x46\x07\xb6\ +\xa8\xeb\x19\x91\xf9\x68\xc0\x96\x94\x49\x33\x1b\x45\xb7\xa3\x54\ +\x4b\x33\x1e\xd9\xcc\xa5\x2d\x5b\x54\x75\x6e\x4e\x17\xad\x4d\xea\ +\x54\x9c\x32\x59\xcd\x4a\x1e\x32\x93\xc9\xfb\x19\x15\x86\xa1\xbc\ +\xcf\xd0\xab\x37\xf1\x3b\xfa\xf6\x79\x19\x16\x19\xfe\xd1\xcb\x4d\ +\x81\x4e\xbe\x95\x05\x49\xae\xa1\x5e\x68\x51\x6b\x6d\xac\xb5\xca\ +\x5f\x80\xd1\x7f\x8f\x69\xe0\x58\xf2\xa6\x86\x3b\x2f\xc0\x92\x1a\ +\xa4\x5a\x3a\x74\xa5\xe2\x38\xce\x8a\x74\xd3\x6d\x91\xf7\x57\x7d\ +\xe2\x89\xa7\x6a\x41\xa0\x17\x01\xc8\x62\x94\x44\xd4\x45\x0c\x5a\ +\x88\xda\x33\x0e\xa8\xf8\xdb\xcf\x7e\xcf\x28\xa5\x0a\x71\x1c\x97\ +\xa0\x9d\xcc\x0c\x8a\xd3\x61\x0b\x69\xe8\x86\xf4\xeb\x7e\xbf\x12\ +\xa0\x9e\x3d\x70\x7e\x2d\x88\x97\xad\xf0\xb3\x33\x37\x2c\x4e\x98\ +\x5e\xc8\x25\x48\xca\x1a\xa0\x29\xa5\xea\xc5\xac\x35\x53\x83\xce\ +\x02\x9e\x0a\x6a\x35\xa7\x03\xed\xbc\x2c\x8e\x9f\x31\x71\x00\xd4\ +\xd6\xad\xae\x16\x45\xa6\x30\x3d\xad\xfa\x00\x20\x08\x03\xed\x15\ +\x15\x67\x8d\xde\x24\x08\x48\xeb\x4c\xb2\xc0\xc8\x9b\x75\x93\xad\ +\xf7\xe3\x3d\x56\xc9\xb0\x8d\xd6\x3a\x6b\x40\x97\xee\x33\x99\xa1\ +\x54\x93\x21\x9b\xb4\x17\x8b\xfc\xbb\xea\x65\x71\x94\x73\xce\x5a\ +\x6b\x95\x4a\x1a\xce\x65\xc3\x6b\xb6\xbe\xee\x93\xdf\xc6\x5f\x86\ +\x92\xa4\xde\x26\x76\x69\x7b\x7e\xaf\xa7\x8c\x04\x23\x61\x3a\x04\ +\x16\x7b\xbd\x59\x9c\x4e\x3a\x08\xcb\x70\x15\x9c\x73\xa5\x27\x9f\ +\x1c\x1f\x35\xe6\xf5\x13\x2b\x1f\x26\x44\xd4\x49\x0c\x5a\x88\xda\ +\x63\xbe\x8f\xb3\x6f\xfc\xd7\xef\x7e\x35\x1b\xca\xd0\x2a\x94\x3b\ +\x7b\x9d\x0e\x5b\x64\x3d\x5b\xfc\xa6\x6f\xce\xb9\xc8\x39\x57\x93\ +\x8b\x2b\xd2\x62\x5a\xef\xc2\x2e\x17\x4d\xc9\xac\xc8\x5a\x45\x59\ +\x66\x45\x0a\x78\xfd\xe6\x71\x7e\xdd\x46\xf6\x6f\x6b\xfa\x6c\xa1\ +\x3e\xfb\xc8\x14\x03\x85\xd8\x20\xfc\xc6\xc9\x9d\xf1\x9e\xc1\x69\ +\xad\xb5\xf1\x86\x60\x62\xe7\x5c\xb4\x6f\x5f\xbc\x58\x2c\x06\xf3\ +\x47\x8f\x26\x81\x48\x7f\x60\xe7\x2f\x5e\x0c\xe4\x39\x2a\x48\x2e\ +\xe0\xae\x21\xe0\xa8\x78\xdb\x2b\xad\xf8\xb3\x80\x23\xcd\x32\xc9\ +\x05\x3f\xcb\x62\x48\x91\x2b\x00\x2d\x53\xb8\xd3\xd9\x3f\xd2\x56\ +\x3f\x0b\xf4\xfc\x95\xa1\xad\xb5\x05\x79\xbc\xb5\x16\xde\xf0\x8d\ +\x04\x80\xd9\x3a\x43\x7e\xb6\xc5\xdb\xaf\xa1\x52\xaa\xe8\x6d\x93\ +\x53\x49\xaf\x16\x09\x64\xb4\xf5\xba\xf2\x22\x69\x98\x57\x00\xe0\ +\xf4\x4c\x35\x46\x31\xac\xbd\xfa\xea\xab\x98\x99\x99\x0f\x80\xca\ +\x9b\xf9\x0f\x1b\x22\x5a\x0b\x06\x2d\x44\xed\xbb\x70\xea\xd4\xa9\ +\xe0\xdc\xb9\x73\x00\x80\x74\xca\xb3\x5f\x7b\xe1\xd2\x82\x58\x93\ +\x66\x20\xe4\x4e\x3e\xeb\x06\x9b\xd6\x83\x64\xf5\x12\x69\x96\xc4\ +\x60\x99\x2c\x4b\x3a\x64\x74\x43\x61\x6e\x5a\x27\x52\x6d\xfc\x77\ +\xa1\x50\x88\x9d\xd2\x35\x6d\xa1\x74\xda\x26\x3f\x28\x15\x2c\x8c\ +\xd2\x85\x67\x2f\xdc\x11\x7d\xe0\xd6\x73\x69\x96\x21\x6b\xfb\xef\ +\x9c\x2b\x0d\x0d\xc1\xec\xdf\xef\xa2\x53\xa7\x0a\x5b\x01\x60\x68\ +\xd8\x68\xc9\xba\x48\x46\x22\xed\xb5\xe2\xaf\x86\x5c\xf6\xb6\xd7\ +\xef\x74\x2b\x99\x25\xbf\xeb\xed\x72\x05\xb8\xfe\xd0\x9a\x1f\xcc\ +\xc8\x3e\x91\xe1\x9f\x6c\x18\x27\x9d\x1e\x6d\x92\x2f\x2b\xe9\xd9\ +\x22\x01\xa0\x0c\x35\x15\xe1\xf5\x63\x69\xa8\x67\x91\xfd\x28\x01\ +\x54\xd9\x25\xdd\x7d\x5d\xfd\xa5\x93\xe9\xe9\x5e\x53\xc0\x30\x78\ +\xf9\xf2\xae\xf8\x9d\x5b\x67\xbf\xf9\xcd\x6f\x1a\xc0\x3a\x00\x97\ +\x9a\x1f\x2a\x44\xd4\x09\x0c\x5a\x88\xda\x77\x16\x00\xbe\xfc\xe5\ +\x2f\x27\xc3\x1c\xb1\x8d\xd3\x8b\xb9\x64\x00\x54\x1c\xc7\x25\xef\ +\xc2\x6d\xd2\x21\x8a\xac\x91\x1c\xbc\x0b\x37\x90\x65\x49\x24\x1b\ +\x50\xf5\x32\x01\x4b\x0a\x73\x91\x64\x26\xb2\xac\x83\x1f\x78\x48\ +\xcd\x88\x31\x06\xb6\x5f\x3b\x35\x5b\x0b\x9d\x73\xb1\xd6\x3a\x76\ +\xa5\xd0\xea\x4a\x1c\xeb\xf1\x85\x81\xe8\x6f\xef\x9d\x52\x4a\xf9\ +\x43\x2e\xd9\xeb\x8d\x8c\xe8\x85\xc5\x45\x1d\xa4\xaf\x16\x6b\x1d\ +\x64\x4d\xdc\xd2\xed\xf1\xdb\xda\x3b\xef\xeb\xd2\x58\x4f\xa6\x34\ +\x67\xc3\x31\x5e\xd1\x6d\xcd\xfb\x77\xb5\xe1\xdf\xd9\xcf\x4a\x23\ +\x3d\x95\xf4\x86\x91\x17\xca\x86\x71\xfc\xf6\xff\x48\xb2\x5b\xfe\ +\x2c\xad\xac\xf0\x16\x49\x67\x62\xc9\xb6\x14\xbd\xfd\xad\xd2\xa9\ +\xe1\xb1\xf7\x58\x67\x8c\x89\x51\xaf\x6f\x91\xe9\xe9\x59\x7d\x8c\ +\x9a\xaa\x14\xed\xde\xe1\xea\x5f\xfd\xd5\x8f\x87\xc2\xf0\xec\x69\ +\x00\x7e\x91\x2e\x11\x75\x11\x83\x16\xa2\xf6\x2d\x02\x98\x78\xe4\ +\x91\x47\x62\x00\x21\x42\xed\x17\xd5\x1a\xef\x42\x88\xb4\x38\x54\ +\x86\x8d\xe4\x73\xe7\xbc\x59\x45\xb1\x9f\x51\x48\xbe\xe4\x4a\x7e\ +\x7d\x88\x57\xd7\x92\x2d\x40\xe8\x67\x56\x5c\xd2\x3e\x3f\xf2\x82\ +\xa6\xd0\x0d\x97\x1c\x16\xa3\x20\xad\x45\x29\x98\x52\x60\x5d\x6c\ +\xfa\x54\x21\x94\x61\xa5\xa2\x37\x64\x12\x20\x3d\x27\x18\x63\x10\ +\xc7\x71\x60\x0c\x94\x52\xca\x44\x95\x28\x48\x03\x15\xff\xe2\x2e\ +\x43\x30\x4b\xbe\xee\x05\x33\xd9\x4a\xcf\x69\x71\x6e\x56\x33\x22\ +\xaf\xd3\x30\x05\x3a\x0b\xd8\x9c\x73\x45\x69\xa4\x67\xad\x0d\xfd\ +\xfd\x92\x66\x58\xfc\xe0\xc4\xd8\xb4\x6b\x2d\xd2\x0c\x94\x5f\x78\ +\x2b\xbd\x5f\x24\xe8\x40\x5a\x78\xab\xeb\x8d\xe3\x0a\x5e\x41\xb4\ +\x4a\x33\x61\x46\x8a\x71\xe5\x57\x28\xbf\x0b\x1d\x86\xee\xd8\xb1\ +\x63\xea\xdc\xb9\x2b\x41\x1c\x4f\x9d\x5c\xfe\xd0\x20\xa2\x6e\x60\ +\xd0\x42\xb4\x36\x67\x4e\x9e\x3c\x59\x3c\x76\xec\x98\x82\x83\x93\ +\x1a\x14\xa9\x89\x90\x07\xf9\x8d\xcc\x64\xd6\x8f\xff\x35\x19\xfa\ +\xb1\xc9\x3a\x3a\x46\x25\xdd\x58\xb3\xd5\xa1\xbd\xf6\xfd\xce\xaf\ +\x5f\xf1\xb3\x2c\xe9\x45\x5b\x82\x81\x48\x29\x55\xd3\xc3\xa5\x58\ +\xcf\x1b\x67\xad\x4d\x66\xdb\xf4\x87\x11\x16\x4d\x96\x21\x81\x37\ +\xcc\x94\xd6\x70\x28\x00\xe8\xef\xb7\xc1\xd8\x98\xab\x1c\x3f\x1e\ +\xf6\x07\xbb\x4a\x71\x7c\x7e\xb1\x4f\xfa\x94\xc8\xfb\xf1\x82\x9d\ +\x25\xb3\x7c\xbc\xa2\xdc\xac\x50\x38\xed\xbf\x22\x41\x44\xb6\xbc\ +\x81\x4e\x1a\xe5\x65\xef\xcd\x0f\x48\xfc\x61\x99\x34\x53\x63\x50\ +\xaf\x2d\x41\xfa\xf5\x2c\xdb\x62\xad\x2d\xa4\x8b\x20\x4a\x13\xbe\ +\x2c\xa0\x43\xd2\x73\x45\x7e\x4c\xc9\xcf\xe9\x7a\x13\x40\x9b\xbe\ +\x9e\x64\x77\xc2\x34\xd0\x53\x52\x7f\x03\x00\xe1\x1b\x57\xcb\x66\ +\xf7\xc0\xdc\x17\xbf\xf8\x45\xd9\x7f\xe7\x72\x1e\x27\x44\xd4\x01\ +\x0c\x5a\x88\xd6\xe6\x0c\x00\xf3\x85\x2f\x7c\xa1\xa6\xa1\xac\x57\ +\x83\xa2\x50\xcf\x0a\x44\x58\xda\x35\x57\x6a\x53\x94\x4e\xd6\x1a\ +\xf2\x87\x81\x64\xc8\xa8\xe8\x65\x61\x4a\x69\xd6\xc1\x69\xad\x6b\ +\xf0\xea\x33\xe4\x82\x8f\x24\x6b\x93\x65\x03\xd2\x6c\x41\xd1\x0c\ +\x96\x8c\x5b\x8c\xca\x5a\xeb\x6c\xc8\x48\xa7\x53\x92\xa5\x8f\x4c\ +\xfa\xef\x6c\xf8\x49\x6b\x1d\xef\xdf\x6f\xa6\x67\x67\x83\xe2\xf5\ +\xeb\x56\x95\x0f\xf4\x5f\x1d\xb8\x3a\xdf\x77\xfd\x7a\xa0\x1a\xb2\ +\x3a\x12\x6c\x58\x7f\xe8\xca\xab\xaf\x71\xea\xc6\x7a\x9d\x6c\xdb\ +\xd3\x3a\x1b\x95\x16\x2a\x9b\x74\x68\x2d\x94\xa1\xa0\x74\xf8\x27\ +\xab\x4d\xf1\x82\x13\x59\xec\xd0\x7f\x2e\xbf\x3f\x4e\x96\x41\xf1\ +\x82\x29\x15\x04\x81\xf6\x67\x00\x39\xe7\xb2\xc6\x7f\xd6\x5a\x9d\ +\x0e\x03\x05\x69\x96\x2c\x0b\x66\x24\x5b\x04\x00\xe1\x1b\xd3\x5b\ +\x2a\x3f\xb1\x75\xee\x3f\xfe\xc7\xe7\x4b\xc0\x89\x63\xe0\xd0\x10\ +\xd1\xba\x62\xd0\x42\xb4\x36\x55\x00\x6f\x7e\xe9\x4b\x5f\x2a\xd4\ +\xe2\x6c\xa1\x42\x9b\x06\x14\xd6\xaf\x69\x91\xe1\x1b\xd4\xeb\x25\ +\xac\x64\x2f\xbc\xda\x8c\xac\xd9\x5c\x43\x1d\x0b\xb4\xd6\xd2\x7f\ +\x25\x2b\xd2\xf5\xb2\x1d\x91\x73\x2e\x9b\x9d\x94\xcd\xec\x29\xe8\ +\x58\xdb\x25\xab\x19\x07\x56\xb9\x2c\x33\xd1\x90\xb1\x91\x0c\x49\ +\xa8\xb5\x2b\x8e\x8e\x9a\x6a\x1c\x07\x61\x6d\xf7\x88\x1d\xae\xce\ +\x85\x17\x2f\x86\x7d\xde\xeb\x65\xc3\x3d\xe9\x7f\xfd\x1e\x2a\xd9\ +\xf4\x66\xbf\x51\x9b\x64\x92\xbc\x7f\x2f\x17\x90\xf8\xd9\x0f\xe7\ +\x0f\xd1\xf8\xf5\x37\x48\x03\x3e\xef\xe7\xa5\xa7\x8d\x46\x12\x78\ +\xf8\x6b\x0a\xd5\x74\xd2\x13\x47\xf9\x53\xb2\x95\x52\x3a\x6d\x2c\ +\x17\xcb\xf3\xa6\xdb\xa7\xbd\x21\x36\xad\x94\xd2\x5a\xeb\xd8\x55\ +\xe3\xd8\x3a\xb8\xef\x3c\xfd\xa4\x9b\x9d\x5d\x2c\x01\x33\x47\x9b\ +\x1d\x1c\x44\xd4\x59\x0c\x5a\x88\xd6\xee\xf8\xb5\x6b\xd7\xd4\x4b\ +\x3f\xfa\x91\x71\xce\x99\x20\x08\x54\x1a\x50\xc8\x94\x67\x23\xc3\ +\x33\x7e\xef\x12\xff\xc2\x2f\x0d\xcd\xd2\x61\x14\xb9\x60\x66\x81\ +\x84\xd6\x3a\x36\xe9\xf8\x86\x97\xd9\xc8\x32\x00\xe9\xeb\xdd\x30\ +\xfd\x39\x79\x4c\x36\x95\x38\x6b\x85\xaf\x2c\xfc\x2e\xb6\xd2\x83\ +\x44\x82\x05\x03\xc0\x15\x0a\xb0\x03\x03\x26\xbe\x78\x51\xf7\xc1\ +\x5a\xd4\x6a\x51\xe0\x4f\xd3\xf6\x02\x0d\xe5\x7d\x1d\xfe\xbf\xeb\ +\xdb\x90\xd5\xf9\xc8\x7b\xf0\x17\x3b\x74\x7e\x16\x46\x86\x82\x6c\ +\xd2\x83\xc5\x2f\xc2\x2d\x79\x01\x51\x90\xd6\x08\x49\xa6\x48\x66\ +\x61\xc9\x50\x8e\xbf\x82\xb3\x74\x0a\x5e\x12\x0c\x39\xe7\xb2\x40\ +\x46\x9e\x57\xde\x8f\x6c\x9f\x3f\x6b\xa8\xf8\xfd\x0b\xbb\xcc\xfd\ +\x3b\x26\xff\xe8\x8f\xfe\xdc\x06\xc1\xf4\x0c\x00\xae\x37\x44\xb4\ +\xce\x18\xb4\x10\xad\xdd\x65\x00\xd3\xdf\x7c\xec\x1b\x41\x7a\x91\ +\x95\x20\x41\x86\x3d\x02\xad\xb5\x04\x15\x92\x3d\xc8\xa6\x35\x03\ +\xf5\x1a\x0a\xa0\x1e\xc0\xc8\xf7\xd2\x61\x94\xd0\xbb\x60\xeb\xb4\ +\x56\x44\xea\x5f\xb2\xc7\xfa\x17\x5a\x48\xfb\x7f\x2f\xb3\xa2\x94\ +\x2a\x40\x05\xca\x28\xa7\x5d\xda\x71\xd7\x18\xe3\x8c\x31\x32\xeb\ +\xc9\xa5\xb3\x70\xa0\x94\x76\x40\x18\xd7\x03\x83\xb0\x9e\xc1\xf1\ +\x0a\x8d\x65\x18\xc8\xab\x45\xf1\x67\x01\xf9\x33\x73\x20\xc5\xbb\ +\xd6\xda\x20\x1d\xae\x91\x69\xca\x7e\x16\x66\xb9\xcc\x8b\x04\x1c\ +\xb1\x17\x6c\x21\x08\x02\x93\xbe\x4f\x99\xba\xad\xbc\x9f\xf3\x9b\ +\xd7\xc9\xec\x1f\x99\xde\x5c\x54\x4a\x85\xf2\x35\xff\xf7\x25\x3f\ +\x2f\xf5\x38\x32\xb5\x5a\x4d\x57\x4b\x6f\x2c\x8c\xc7\x87\x0e\x4d\ +\x8c\x18\x73\xe2\x10\xc0\x55\x9d\x89\xd6\x1b\x83\x16\xa2\xce\x78\ +\xfd\xec\xb9\x73\x78\xf6\xd9\x67\x81\xb4\xf9\x9a\x5f\x63\x82\x7a\ +\x47\x55\xe7\x5f\x94\xd3\x8b\x7a\x36\x7c\x93\x0e\x2d\x65\x01\x0c\ +\x90\xad\x4f\x04\x78\x01\x8f\x97\x8d\x09\xbc\xc7\x42\x29\x25\x0d\ +\xd1\x5c\x5a\xcc\x9b\x04\x1c\x49\x07\xd8\x64\xfa\xf1\x16\x2c\xea\ +\xaa\x0d\x51\xcf\xf8\x68\x2f\xd3\x90\xd5\xd3\xec\xde\x1d\x2f\x5e\ +\xba\x84\xe1\xbb\xef\x8e\x17\xcf\x60\x0b\xca\x6f\x4e\x8c\x78\xc3\ +\x49\x7e\x61\xed\x92\xa0\x23\x1d\x12\xcb\xa6\x63\xfb\x3f\xa3\xbc\ +\x2e\xb5\x7e\x56\x29\x79\xeb\x6e\x49\x03\x3e\x09\x76\x8c\x31\x59\ +\xd7\xde\xb4\x1e\x48\x86\xb1\xfc\xa2\xdc\x2c\x9b\x23\x59\xa8\xf4\ +\xf9\x0b\xde\x63\x43\x97\xc8\x86\xe8\xfc\x62\x68\xf9\x7d\x69\xad\ +\x63\x79\x4c\x5a\xeb\x52\xd2\xaf\x4f\x0e\xdb\xbd\x03\x33\x7f\xfc\ +\xc7\x9f\x8b\x83\xc0\xc5\x00\x8e\xe7\x39\x28\x88\xa8\xb3\x18\xb4\ +\x10\x75\xc6\x99\xaf\xe2\xd8\xe9\x3f\xfd\xd3\x3f\x05\xd2\xe6\x6b\ +\xe9\xd7\x65\x0a\xb0\xd4\x53\xe8\x34\x70\x89\xd2\xe1\x89\xd0\x0b\ +\x60\x9c\x74\x79\x85\x17\xe4\xf8\x43\x32\x12\xf0\xe8\xa4\x1f\x4a\ +\x76\xf1\xd5\xf5\xce\xb6\xaa\xe1\xb1\xda\xed\x1a\x5c\xd4\x67\xe6\ +\x86\x24\x30\x71\xbb\x47\x16\x54\xcd\x84\xe9\xcf\x2d\x19\x6a\x4a\ +\x5f\x33\x06\x80\x42\x01\x71\x1c\x6b\x5b\x28\xc0\x5d\xd9\xbe\x65\ +\x71\xe7\xe4\x54\x61\x7c\x5c\xf9\x41\x42\x96\x69\xf0\x33\x16\x85\ +\x42\xc1\x1f\x06\x92\xd9\x41\xfe\xf3\x47\xfe\x6b\x4b\xb6\x45\xd6\ +\x2d\x04\xb2\x21\xae\x6c\x76\x92\x3f\x63\x48\x9e\xc7\xd5\x3b\xf9\ +\xfa\xc5\xb7\x12\xc4\xf9\xcb\x27\x64\x81\x4c\x1a\xa0\x15\xbc\xef\ +\x67\xc3\x73\xde\x73\x84\x4a\xa9\x82\x6c\x9f\x73\xce\xea\xc3\x13\ +\x5b\xde\xbc\x4d\xcf\x7d\xf5\xab\x67\xb7\x18\xf3\xca\x21\xb0\x00\ +\x97\x68\x43\x30\x68\x21\xea\x0c\x53\x83\x79\xed\x89\x27\x9e\xc0\ +\x8b\x2f\xbe\x28\x43\x0d\x0e\x49\xb0\x92\x7d\xce\xd2\x2c\x09\x94\ +\x52\x59\x1d\x45\x7a\x67\x9f\x15\x98\xca\xdf\x12\xe4\x38\xe7\x96\ +\x04\x28\x48\x33\x00\x8d\x17\xdf\x20\x08\xa4\xb0\x35\x6b\xe4\x06\ +\x00\xe6\x27\xb6\x5d\xd3\x47\xaf\x0e\xca\xff\xe3\x03\x5b\xaa\x36\ +\x8a\xb2\xa9\xcb\x0d\x17\x79\x0d\x20\x00\x80\xad\x5b\xc3\xda\xc0\ +\x80\x8b\xcf\x9c\xd1\x7d\xa3\x3b\x8a\x8b\xba\x66\x31\x35\x55\x94\ +\x3e\x2a\xd6\x1b\x86\x02\x92\x06\x6e\x16\x48\x32\x23\x48\x83\x8f\ +\x74\xd6\x8e\xac\x6b\x04\x24\x0b\x48\x66\xc3\x5c\xfe\x2c\x29\x3f\ +\x80\x93\xd7\xf0\xf6\xcb\x92\x40\x25\x1d\xea\xf2\xeb\x6b\xc2\x74\ +\xc8\xca\x5f\x2b\x28\x96\xa0\x4f\xde\xa3\xbf\xcd\x7e\xa0\x95\x66\ +\xa8\x02\x6f\xdf\x65\x3f\x57\x7c\xee\xf2\x18\xde\xb1\xfd\xca\xbf\ +\xfe\xd7\xff\xce\x1a\x53\x31\x40\xf4\x2a\x88\x68\x43\x30\x68\x21\ +\xea\x9c\x37\x00\x2c\xfc\xe1\x1f\xfe\xa1\x0c\x0d\x65\xed\xfc\x51\ +\x1f\x8e\x08\x50\xbf\xbb\x37\x69\x10\x13\xa6\x17\x4d\xe5\x17\xab\ +\xa6\x96\x64\x07\xfc\xda\x8c\xf4\xb9\x4d\xa1\x50\x88\xfd\xd7\x4b\ +\x9f\x2b\x9b\xb1\x84\x81\x82\xd5\x91\x09\x25\xc3\xa3\xb5\x36\x01\ +\xb2\xa9\xc6\xb1\xf7\x5a\x4b\x86\x6c\xb6\x6d\xab\x99\x6a\x35\x2e\ +\x5e\xbb\x86\xc2\xc8\x48\x2d\xba\x32\xb4\x05\x85\xb3\x57\x87\xd2\ +\xd7\xf0\x8b\x72\x1b\x17\x4a\xcc\x86\x65\xd2\xff\x67\x6b\xf8\xf8\ +\x19\x28\xd9\x37\xfe\x8c\xaa\xf4\xfd\x4b\x87\xdc\x25\xab\x4b\x37\ +\x04\x2a\x7e\x01\x71\x96\x65\xf1\x9e\x5f\x59\x6b\xc3\x74\xa5\xe7\ +\xd8\x7b\x0e\x7f\xea\x79\xa0\xb5\x5e\x12\x0c\xc9\xbe\x4b\x1b\xe6\ +\x45\x1a\x70\xea\xcd\xd9\x81\x53\xc3\x8b\xd5\x2f\x7e\xf1\xe8\x88\ +\xb5\x2f\xbd\x04\x60\x61\xb5\x83\x80\x88\xba\x87\x41\x0b\x51\xe7\ +\x18\x00\xaf\x3c\xf9\xe4\x93\xea\xa9\xa7\x9e\xca\xb2\x2d\xde\x6c\ +\x96\x25\xed\xef\xe5\xc2\x2f\x43\x28\x69\xf0\x91\x05\x03\xe9\x63\ +\xfd\x8b\x7b\x6c\xad\x95\x0e\xaf\x59\x66\x44\x3a\xc7\x36\x16\xbd\ +\x22\x0d\x78\xfc\x59\x3e\xe9\xb0\x4b\x60\x8b\x2a\xd2\xc7\xa7\xfb\ +\x1a\xb6\x2b\xf2\x02\x26\xd7\xdf\xaf\xab\xbb\x76\xb9\xc5\x4b\x97\ +\xc2\x3e\xa5\xb4\xa9\xbe\x63\xe7\x64\xf1\xc4\xd4\x68\xfa\x78\x3f\ +\xab\xb1\x5c\x6d\x8e\xff\x7f\x79\xee\x25\x1d\x74\x65\xdf\xd8\xa5\ +\x4d\xf8\x96\x04\x3c\x48\xb3\x23\xfe\x73\xcb\x6b\x49\x4d\x4b\xc3\ +\x6c\x25\x09\xfc\xa2\x74\xb8\x6d\x49\x93\x3f\xdc\x18\x30\xca\xec\ +\xa1\x20\x1d\x62\x8b\xbd\xfd\x56\x28\x7e\xfb\xec\x76\xf3\xc0\xee\ +\xcb\xff\xea\x5f\xfd\xb1\xb3\x76\x36\x02\xc0\x2c\x0b\xd1\x06\x62\ +\xd0\x42\xd4\x59\xc7\x01\x4c\xff\xee\xef\xfe\xae\x8b\xa2\xc8\xcf\ +\xb6\x64\x0b\xf3\x79\xc3\x45\xf5\xf5\x6c\x94\x0a\x1b\x83\x0f\xff\ +\xb1\xde\xc5\x5d\xc1\x0b\x02\x1a\x32\x07\xd9\xd0\x4b\x63\x50\x61\ +\x06\x82\x4a\x30\xbe\x50\xbf\xb8\x0f\x0d\x2c\xea\xd7\xaf\x6c\xf1\ +\x03\x1a\x3f\x00\xd0\x5a\xa7\xfd\x5a\x00\xe7\xac\xd2\x1a\xb8\xeb\ +\xed\x76\xe1\xea\x6c\x50\xaa\x4e\x54\xb3\xc2\x5f\x8f\xf2\xff\xe3\ +\xb7\xed\x87\x37\xd4\x95\xbe\x57\x6d\xbd\x05\x24\x91\x04\x1a\x68\ +\x0c\x82\xbc\xde\x29\x3a\x7d\x8c\x64\xab\x42\x09\xf6\xbc\xa0\x4e\ +\x86\x92\xb2\x02\xdc\xf4\xf9\x97\xad\xbb\xf1\x02\x46\xe3\xff\x9c\ +\x37\x64\x17\x15\xaf\x54\x02\x5b\x33\xc1\x4b\x53\xa7\xcc\x97\xbf\ +\x7c\x7c\xd4\x98\x57\x9e\x43\xb2\x74\x03\x11\x6d\x10\x06\x2d\x44\ +\x9d\xe5\x00\xbc\x74\xe2\xc4\x09\xf5\xf0\xc3\x0f\xdb\x34\x78\x70\ +\x76\x69\x1b\x7f\x9b\x3e\x4e\xc9\x90\x46\x9a\x6d\x91\x29\xb9\x4b\ +\x82\x0f\xe7\xad\x78\x9c\xf2\x83\x00\x99\x75\xe3\x3f\x46\x2e\xdc\ +\x59\x90\x12\x3d\xb0\x77\x26\x78\x71\x7c\x3b\x90\x36\xb5\xab\x45\ +\x56\xbb\x2c\xeb\x20\xc3\x44\x8d\x53\x78\xd3\x96\xfe\x3a\x0e\x02\ +\xa8\x2b\x57\x5c\x59\xfd\x9d\xdd\xe7\xa7\xbf\x36\x71\x4b\xfa\xfc\ +\xd9\xf9\xa3\xf1\xf5\x1a\xbf\x2f\xef\xbb\x31\x73\x24\xef\x2d\xad\ +\x7d\xb1\xde\xff\xb3\x29\xde\xe9\xff\xb5\xb5\x16\xe9\x72\x06\x12\ +\xbc\x64\x6b\x1b\xa5\x35\x3e\x61\x1a\xfc\x64\x1d\x6d\x7d\x32\x34\ +\x97\x7e\x3f\xab\x77\xf1\x03\x95\xf4\xf5\x95\x8d\xa2\xa2\xfa\x9b\ +\xd3\x7b\xab\x0f\xee\xbf\xf4\x99\xcf\xfc\x9f\x41\x10\xcc\xce\x00\ +\x78\xbd\xf1\x39\x89\x68\x7d\x31\x68\x21\xea\xbc\x0b\x00\x2e\xfc\ +\xfe\xef\xff\xbe\xba\x7c\xf9\xb2\xd4\x59\xb8\x95\x02\x18\xc9\x98\ +\xa4\xf5\x1a\x7e\xad\x89\x5c\x54\x65\x9d\x1e\x09\x76\xfc\x61\x26\ +\xe5\x4d\x73\xce\x66\xd1\x78\x8f\x49\x32\x2e\x03\x05\x8b\x6a\x9c\ +\x65\x3a\x74\x51\x29\x3b\x50\x30\xea\xcd\xeb\xe5\x74\xd6\x8e\xbf\ +\x4d\x06\xa8\x77\xd1\x7d\xd7\xbb\xcc\xb5\x4b\x97\x54\x61\x6a\x2a\ +\x08\x7f\xe2\xa7\xf5\xf4\xf9\x71\x3d\xa8\x17\xcd\x92\x85\x11\x25\ +\x10\x40\x3d\xf0\x71\x0d\x43\x44\x48\xbf\x27\xf5\x27\x0a\x40\xf6\ +\xde\x00\x20\x8a\xa2\xd0\xff\x7f\xfa\x24\x7e\x40\xa5\xd2\x6c\x94\ +\xdf\x89\x57\x37\xec\xaf\x2c\x10\x94\xc7\xc8\x53\x35\xd4\xbe\x84\ +\xd6\x5a\xc9\x6a\x65\xb3\xbb\xd2\xe7\x33\xe5\xc7\xcf\x6d\xad\xbd\ +\x7f\xdf\xf8\x7f\xf9\xcb\xff\xa2\x5f\x7b\x6d\x6e\xd0\x98\x23\x4f\ +\x03\x58\x52\xff\x43\x44\xeb\x8f\x41\x0b\x51\x77\x3c\x57\xa9\x54\ +\xec\x67\x3f\xfb\x59\x7f\xa1\xbf\x65\x03\x18\x9b\x4e\x83\x96\x00\ +\xc3\xd6\x17\x5b\x6c\x0c\x60\xfc\x9e\x22\x8d\x75\x32\x59\x93\xb5\ +\x86\xc7\x64\x8b\x13\xba\xe1\x42\x25\xb8\x52\xd1\x5a\x6b\x17\xed\ +\x1b\xb9\x8a\x99\xc5\xb0\xf4\xf2\x95\x2d\xb2\x0d\xb2\xe1\x72\x51\ +\x97\xff\xef\xd8\xe1\xa2\xeb\xd7\x55\xb9\x56\xb3\x41\x10\xc0\x5d\ +\xbe\x73\xdf\xb5\xf0\xb1\x33\xbb\xe1\x0d\x09\x59\x6b\xb5\x31\xc6\ +\x3f\x9f\xa8\x20\x08\x96\xcb\xbe\x2c\xe9\x3c\x9b\x6e\x7f\x16\x8c\ +\xa5\xff\x37\xb2\x7f\xbc\x9a\x94\x25\xc3\x4f\x8d\xfb\xc5\x7f\x4c\ +\x43\x36\x47\x02\xab\xac\x6b\x6f\x5a\xcf\x22\x81\x4a\x98\xee\xff\ +\xfa\x34\xed\xd7\x27\x87\x4d\xbf\xc6\x78\x61\xa1\xfa\x2f\xfe\xc5\ +\x17\x07\xc3\xf0\xc4\x31\x24\x6b\x4c\x11\xd1\x06\x63\xd0\x42\xd4\ +\x1d\xf3\xc6\x98\x97\x1f\x7b\xec\xb1\xf0\xeb\x5f\xff\x7a\xd6\xce\ +\xbf\x31\x80\x91\x22\x53\x2f\x43\xa0\x91\x06\x35\xe9\xda\x44\x8d\ +\x01\x4c\x36\xf4\x21\x17\x7d\xf9\x59\x78\xb3\x8b\xe4\x62\xed\xd7\ +\xbc\x44\xef\xdd\x3b\x13\xbc\x78\x71\xbb\xb5\x56\xb9\xbf\x77\xe7\ +\x9b\xc5\x17\x27\x77\x21\x32\x0e\xe6\x86\x6c\xc4\x92\xa1\x15\x6b\ +\xad\x72\xae\x1e\x34\xec\x7b\x5b\x30\x7d\x72\xa1\xbf\x88\xd7\x27\ +\x07\xbd\x87\xa9\x34\x4b\xe2\x07\x32\x52\x87\xe2\x3f\x5f\xf6\xde\ +\x96\x3e\xbf\x73\xde\xfb\x0a\x1a\xb2\x25\x48\xf7\x9f\xf5\x82\x33\ +\x7f\xbf\x34\xbe\x46\xf6\xbc\x59\xc0\xe6\x4d\xd1\x4e\xeb\x59\xb2\ +\xfd\x2c\xc3\x44\xd6\xda\x20\x9c\x58\x2c\xea\x37\x26\x87\xa2\xf7\ +\xdf\x36\xf9\xd9\xcf\xfe\xef\xc1\xc2\xc2\x6c\x1c\xc7\x53\xcf\xae\ +\xf4\x4b\x26\xa2\xf5\xc5\xa0\x85\xa8\x7b\x8e\x06\x41\x70\xf5\xb7\ +\x7e\xeb\xb7\xec\xf8\xf8\x78\x76\x61\x6c\xc8\x8c\x64\xb3\x7b\x1a\ +\x83\x1a\x69\xfb\xdf\xf8\x58\x2f\x5b\xd3\x58\xeb\x82\x86\xe0\x47\ +\x2e\xd6\x49\xa0\x33\x54\x30\x58\x88\x43\x00\xa8\x3e\xb0\x7d\x5a\ +\x4d\xcc\x8c\xd6\x7e\x72\xc7\x4c\xe1\x87\x17\xb6\x78\x4f\xe1\x17\ +\xd0\x62\x6c\x2c\xac\x4c\x4f\x07\x7a\x74\xd4\x55\xa7\xa6\x82\x02\ +\x00\xdc\x73\x8f\xb9\x7e\x68\xf8\xb6\xc5\xf0\xd0\xc4\x16\x2f\xe0\ +\x59\x92\x21\x91\xaf\xa5\x53\x8e\xfd\x9e\x2e\xfe\x7b\xcb\x5e\x33\ +\xcd\xa8\xc8\xfb\xf2\xb3\x2e\xd6\x0b\xc0\xb4\x17\x9c\xd9\x86\xc0\ +\x6c\x49\xb0\x94\xfe\x33\x0b\x66\xd2\xe7\x97\x8c\x96\xdf\x43\x27\ +\xab\x29\x52\x33\xd5\x50\x7f\xe7\xec\xce\xda\xc7\xef\xba\xf4\xc8\ +\x23\x8f\xe0\xb1\xc7\xce\x0e\x02\xaf\x3c\x0d\x60\xae\xd9\x2f\x9a\ +\x88\xd6\x07\x83\x16\xa2\xee\x71\xc6\x98\xef\xcd\xcf\xcf\xdb\x4f\ +\x7d\xea\x53\xd9\xd0\x85\x9f\x19\xc1\x32\x77\xfb\x0d\xd9\x12\xd5\ +\x70\xa1\x36\xde\x05\x57\xea\x58\xfc\x0b\xf1\x12\x32\xe5\x39\xcb\ +\x7a\xbc\x6b\xd7\x64\xe9\xc5\xcb\xc3\xf2\x7d\xbb\x7f\x74\x31\xb8\ +\x30\xdf\x2f\x0f\x6f\x2c\x9e\xdd\xbd\xbb\x16\x5f\xbc\xa8\xfa\xdf\ +\xff\xfe\x68\xea\xf8\x71\xbd\x05\x00\x82\xc0\x62\xf7\xee\xb8\xfa\ +\xca\x6d\x77\xce\x17\xbf\x71\x72\x57\xf6\x5c\xc9\xcf\x6a\x2f\x68\ +\xf0\x5f\x7f\xb9\x73\x8d\x04\x5e\x8d\x99\x1d\xff\xdf\x4b\x82\x0d\ +\x79\x6c\xe3\x90\x96\xcf\xdb\x0f\x7e\x30\xe3\xbc\x7d\xdf\xd8\x43\ +\x07\x2a\xb2\xaa\xf4\xcd\xd3\xbb\x6a\x7f\xff\xc0\x85\x73\xe7\xce\ +\xa9\x7f\xfe\xcf\x1f\x19\x00\xce\x1c\x07\xc0\x95\x9c\x89\x7a\x08\ +\x83\x16\xa2\xee\x9a\x33\xc6\x3c\xff\xd4\x53\x4f\xe1\x73\x9f\xfb\ +\x9c\x9f\x41\xc8\x2e\xac\x0d\x43\x45\x76\x99\xa1\x22\x99\x2e\xbd\ +\x24\xd3\x92\x0e\xb1\xdc\x70\x21\x46\x43\x10\xe0\x0f\x27\xd5\x0e\ +\x0c\x57\xdd\xd9\xeb\x43\x00\xe0\x0e\x8c\x5c\x09\xff\xfa\xe8\x2e\ +\x7b\xdf\xae\x2b\xa5\x1f\x8e\x8f\x36\x6c\xb7\x03\xe0\x0a\x05\x6d\ +\xe3\x38\x79\x5e\x63\xea\xc5\xad\xc5\x22\xdc\x62\x5f\x9f\x89\xf7\ +\x0d\x2e\x14\x9e\xb9\x30\xe6\xbd\x17\x85\xe5\x2d\x19\xb6\x92\xc7\ +\xa3\xa1\x56\xc5\xff\x9a\xec\x0f\x3f\xd8\x58\xe6\xf1\x8d\xfb\x73\ +\xc9\x90\x58\xc3\x7e\xbe\xe1\x67\xad\xb5\xc0\x42\x14\x84\xff\xf5\ +\xc8\xad\xd5\x8f\xec\xbf\x5c\xd3\xce\xfc\xca\xaf\xfc\xd3\xb0\x5a\ +\xbd\x56\x01\x26\xbe\xb7\xc2\x7b\x21\xa2\x0d\xc2\xa0\x85\xa8\xfb\ +\x4e\x02\x38\xf5\x07\x7f\xf0\x07\xea\xa9\xa7\x9e\x92\x3a\x94\x1b\ +\x1e\xe4\x67\x0f\x1a\x86\x30\xe4\x62\xbd\x64\x68\xc3\xab\x21\x71\ +\x58\x3a\xac\xb2\xe4\xa2\xdd\xf8\x5a\x6e\xc7\xc0\xa2\x3e\x3d\xdd\ +\x57\xfb\x87\x3f\x79\xac\xf4\xad\xf3\x77\xd5\x0e\x0c\x57\xdd\xb9\ +\x6b\x83\x30\xc6\x5f\xbc\x30\x0b\x74\xc2\x50\xa7\x6b\x0a\xc1\x56\ +\x2a\x81\xd2\x5a\x9b\xbe\x3e\x1d\x1d\x38\x60\xe7\x5f\x2d\xed\x35\ +\x6a\x3e\x0a\xc3\xa3\x53\x03\xde\x76\x2f\x3b\x4d\x1b\xde\x0c\x25\ +\xef\x3d\x37\x66\x43\x6e\xc8\xa6\xac\x10\x84\x34\xee\xbb\xa6\x8f\ +\xf1\x77\x81\x3c\x26\x98\x89\x0a\xa5\xbf\x3e\xb6\x37\xfe\xa5\xbb\ +\xce\xb9\x91\x52\xf4\x3b\xbf\xf3\xbf\x05\xc7\x8f\x4f\xf5\x19\x73\ +\xfc\x6f\xc0\x9e\x2c\x44\x3d\x87\x41\x0b\xd1\xfa\x78\x0e\xc0\xf4\ +\x6f\xfc\xc6\x6f\xd8\xf3\xe7\xcf\x03\xe9\x85\x3a\xed\x33\xb2\x5c\ +\x11\xa9\x5e\xa6\x90\xd5\xcf\xa8\x2c\xf9\x3a\xea\x99\x84\x25\x43\ +\x45\x8d\xf5\x1e\x5a\x6b\x17\xbd\x6f\xd7\x54\xf8\xe2\xc4\x58\x6d\ +\x57\x5f\x15\x15\x53\x04\x80\xf8\xfe\x5d\x57\x0b\x4f\x9f\xdf\x2a\ +\xcf\xd7\x58\x54\x0b\x00\x3f\xfd\xd3\x66\xe2\x5b\xdf\x2a\xec\xb0\ +\xd6\xea\x3b\xee\x88\x2b\x6f\xbe\xa9\xfa\xe2\xd8\xaa\xf9\xbf\x77\ +\xfb\x15\x7d\x7a\x7a\x30\x3c\x3a\x35\x20\xd9\xa0\xc6\xa9\xcb\xb2\ +\x2d\xfe\xb0\xcc\x32\x43\x43\xab\x66\x53\xbc\xf7\xb3\x2a\xff\x31\ +\x8d\xaf\xe7\x05\x82\x2a\xbc\xb4\x58\x2c\x3c\x76\x7a\x67\xf5\x97\ +\xdf\xf6\xa6\x29\x07\xf8\x8b\xbf\xf8\x0b\xf5\xc8\x23\x47\x86\x81\ +\x43\x4f\x03\xb8\xd8\xec\x75\x88\x68\xfd\x31\x68\x21\x5a\x1f\xb1\ +\x31\xe6\xbb\xf3\xf3\xf3\xf1\xaf\xfe\xea\xaf\x62\x7e\x7e\x3e\xb9\ +\xd3\xaf\x77\x8e\x5d\xb1\xb0\x16\x0d\x53\x79\x53\x4b\x32\x14\x58\ +\x26\xb0\xf1\x02\x1e\xb7\x24\x88\x09\x02\xc4\xfb\x47\xe6\x0a\x87\ +\x26\x86\xe3\xf7\xec\x3a\x5d\xfa\xd3\x1f\xdd\x65\xf7\x8f\x2e\xa8\ +\xe9\x5a\x21\x98\xa9\xfa\x2d\xef\x97\xf8\x5b\x7f\xcb\xce\x5d\xb8\ +\xe0\x06\x01\xa8\x20\x00\xe2\xd8\xaa\x7b\xef\xb5\xb3\x47\x8e\x14\ +\x06\x6b\x1f\xb9\x63\x5c\x1f\xbb\x36\x1c\x9e\x9c\xee\x6f\xf8\x31\ +\xa7\xbd\xce\xb5\xfe\xfb\x6a\x16\xa0\xb4\x6a\x85\x0c\x8b\xc3\x8d\ +\x43\x68\xae\xf4\xe2\xf8\x88\x7e\xe1\xe2\xd6\xca\xaf\xdc\x75\x01\ +\x85\xc0\x3d\xf5\xd4\x53\xf8\x27\xff\xe4\x2f\x87\x80\xd7\x8e\x00\ +\x78\xa5\x53\xdb\x44\x44\x9d\xc5\xa0\x85\x68\xfd\xcc\x19\x63\xbe\ +\x7b\xe4\xc8\x11\xf3\xcb\xbf\xfc\xcb\xa8\xd5\x6a\xfe\xf7\xfc\xc2\ +\xda\x1b\x8a\x6a\xa5\xae\x63\x85\xe7\x5d\x36\x80\xf1\x02\x1e\xd5\ +\x18\xc4\xe0\x3d\xbb\xa7\xd5\xd1\xa9\x91\xea\x6f\xbe\xf3\x64\x78\ +\x68\xf2\x56\x00\xaa\xf6\xe1\xdb\xc7\x83\xbf\x39\xbb\xb3\xe1\xb9\ +\x5d\xb1\x68\x4d\x3a\x2c\x64\x4b\x25\x1b\x4f\x4e\xaa\xd0\xdf\xbe\ +\x62\xd1\xd8\x99\x99\x20\xac\x7d\xec\xc0\x25\x7d\x6c\x6a\xa8\xf0\ +\x83\x25\xb3\x91\x60\x93\xf5\x92\x64\xdb\x56\xb5\x5c\x80\xd3\xec\ +\xf1\xde\xeb\x2c\x9b\x55\x81\x1f\xf4\x45\x46\x15\x1f\x3d\xbe\x17\ +\x5a\xb9\xda\xc7\x0e\x5c\x02\x80\x37\xde\x78\x03\xbf\xfe\xeb\x7f\ +\x34\xa0\xd4\xc4\x65\x60\xe6\xc9\xbc\xaf\x4d\x44\xeb\x2f\x68\xfe\ +\x10\x22\xea\xa0\x79\x00\xb3\x17\x2e\x5c\xb8\xed\xcc\x99\x33\xee\ +\xe3\x1f\xff\xb8\x73\xce\x2d\x09\x46\x9c\x73\x2a\xfd\x5a\x96\x3d\ +\xf1\x1f\xa3\x93\x96\xff\xab\x06\x30\xe9\x63\xe4\xf1\xfe\x73\x2a\ +\x79\x3e\xd7\x17\xc6\xe1\x2b\x57\x86\xf5\xa5\xd9\x01\x15\x23\x32\ +\x6f\xdb\x3a\xe7\x8c\x41\x78\x76\xae\xdf\xee\x1d\xac\xc8\xf3\x8d\ +\x8c\x38\x73\xea\x54\xd0\xbf\x75\xab\x89\x2f\x5f\x2e\x96\x6a\x35\ +\xa5\x77\xef\x36\xd5\x72\x59\xdb\x2b\x57\x82\xe2\x81\x03\x66\xf1\ +\xe8\xd1\x70\x70\xd7\x2e\x5b\x35\x07\xb7\xcc\x07\xe3\x8b\xa5\xf0\ +\x47\xe3\x5b\xcc\xdd\x63\x73\xa8\x07\x0d\x37\x0c\x53\x35\x6e\x5f\ +\xc3\x7b\x5f\x95\xec\x83\x86\xc7\x3a\xff\x39\x1a\x9f\x47\x9d\xb8\ +\x36\x50\xfa\xd6\xb9\x9d\xf1\x83\x77\x8c\x47\xfb\x87\x17\x01\xe0\ +\xfc\xf9\xf3\xee\xa3\x1f\xfd\x4c\x79\x76\xf6\xca\xbc\x31\x67\xbe\ +\x06\x60\x49\x24\x49\x44\xbd\x85\x41\x0b\xd1\xfa\x9b\x06\x10\x1d\ +\x39\x72\x64\xef\xf8\xf8\xb8\x7a\xf0\xc1\x07\x65\xc1\xbf\x15\x67\ +\xd2\x20\x6d\x63\x0f\x20\xbb\xc0\xaf\x16\xbc\x34\x06\x28\xf2\x78\ +\xa5\x54\x3d\x40\x18\x2b\x47\xc5\xc3\x93\xa3\xd5\x8f\xdf\x76\xae\ +\xf4\x67\x87\xef\x8f\x3e\x7e\xe7\x29\xb7\x73\xa0\x56\xfc\xd1\xf8\ +\x16\xb3\xa5\xaf\x86\x81\x42\xd2\x21\x56\x03\x17\x2f\xa2\xbc\x73\ +\xa7\xab\xcd\xcd\xd9\xe0\xfc\xf9\x60\xe0\xee\xbb\xcd\x5c\xb9\xec\ +\xec\xd9\xb3\x41\xdf\xce\x9d\xb6\x66\x8c\xc3\xcc\x8c\x2a\x8c\x8c\ +\x20\xb6\x7b\x06\xab\xb6\x3f\x8c\x8b\xdf\x38\xb9\xdb\x0d\x16\x22\ +\xb7\xa5\x7c\x43\xfb\xfb\xe5\xb6\xcf\xff\xb6\x1f\xc8\xac\xf2\xfe\ +\xb0\xcc\xfb\xba\xe1\x67\x8a\xb3\x36\x08\xbe\x76\x6c\xb7\x8a\x8d\ +\xae\xfd\xf7\x77\x5e\x76\xe5\xc0\x02\xc0\xc4\xc4\x04\x3e\xf2\x91\ +\x4f\x95\x2f\x5d\x9a\x8a\x9d\x3b\xfe\x55\xb0\x1f\x0b\x51\xcf\x63\ +\xd0\x42\xb4\x31\x26\x01\xe0\xd0\xa1\x43\xbb\xae\x5d\xbb\x86\x0f\ +\x7c\xe0\x03\x2b\x06\x22\xfe\xd7\xfc\x7f\xaf\x96\x7d\x59\xee\x79\ +\x96\xcb\x3e\xc4\x77\x8e\xcd\x17\xbf\x71\x6a\xb7\xb2\x70\xe1\xf9\ +\x85\x62\x7c\xef\xb6\x99\xf8\xce\xb1\xf9\xe2\xd7\x8e\xef\x31\x07\ +\x47\xe7\x10\x06\x0e\x00\xc6\xc7\x55\x69\xe7\x4e\x57\x9b\x98\x50\ +\xc5\x62\x51\x99\x6a\x15\x7a\x6c\xcc\x45\xe3\xe3\x41\x69\xe7\x4e\ +\x5b\x1b\x1e\x86\x39\x7e\x5c\x0f\xec\xd9\xe3\xaa\x5a\x6b\xa7\x46\ +\xcb\xb1\xbd\x77\xc7\x4c\xf1\xe5\x89\x91\xf0\xb5\xab\xc3\x6e\xff\ +\xf0\x82\x0b\x96\x1f\x8d\x96\xa0\xc3\x0f\x3c\x9a\x65\x5b\xfc\x40\ +\x65\xc5\xec\x4c\x25\x52\xe5\x27\xde\xdc\xe9\x4e\x4d\x0d\xd4\x3e\ +\x72\xfb\xb8\xbd\x73\x6c\x3e\xdb\xf9\x93\xd9\xb7\x69\x13\x00\x00\ +\x20\x00\x49\x44\x41\x54\x93\xee\xc3\x1f\xfe\x47\xa5\x8b\x17\xa7\ +\xe1\xdc\xeb\x5f\x41\x12\x48\x12\x51\x8f\x63\xd0\x42\xb4\x71\xc6\ +\x01\x04\x2f\xbd\xf4\xd2\x8e\x89\x89\x09\x3c\xf8\xe0\x83\x4b\x32\ +\x21\xc2\x0f\x58\x56\xaa\x6b\x59\xe9\x67\xe4\xe7\x96\x7b\xde\xe4\ +\x9b\x40\xb0\x75\xa8\x82\xfe\x42\xb5\xf8\xe8\x1b\xf7\x56\x7f\xf1\ +\xe0\x49\x68\xc0\xde\x3a\xbc\x50\xfc\xfa\xa9\x3d\xe6\x1d\xdb\xae\ +\x03\xf5\xa0\x65\x6e\x4e\x85\xd6\x6a\x55\xab\x69\xbd\x6b\x97\xad\ +\xd6\x6a\x5a\x47\x91\x53\xfd\xfd\xb0\x63\x63\x3a\x3a\x71\xa2\xd8\ +\xbf\x7d\xbb\xad\xa5\xad\xf9\x55\xbc\x7f\x64\xd1\xed\x1c\xac\x16\ +\xbe\x75\x76\xa7\x3e\x31\x33\x68\x76\x0f\x2e\xa2\x14\x2c\xa9\x59\ +\x59\x35\xf0\x68\xdc\x5c\x6f\x58\x68\xa5\xc7\x87\x97\xe6\x8a\xc5\ +\xef\xbe\xb9\x23\x3c\x39\x33\x58\x7d\x60\xd7\x55\x77\xdf\xee\x19\ +\x3f\x60\xba\x74\xe9\x92\xfb\x85\x5f\xf8\x1f\xcb\xe7\xcf\xcf\xc0\ +\x98\x57\xbf\x0a\xe0\x6a\xb3\xd7\x25\xa2\xde\xc0\xa0\x85\x68\x63\ +\x5d\x06\xe0\x0e\x1d\x3a\xb4\xeb\xf4\xe9\xd3\xea\xc3\x1f\xfe\xb0\ +\xac\x1f\xb4\x5a\x20\x92\x0d\x15\xe5\xd1\x2c\x20\x30\xc3\x05\xa3\ +\x4f\x4d\x0f\xb8\xc1\x60\xbe\xf8\xa5\x63\x07\xa3\x9f\xbf\xfd\x02\ +\xca\xa1\x55\x7d\x61\x1c\xfe\xe0\xd2\x56\x73\xd7\x96\xb9\xb9\xb9\ +\x20\x2c\x97\xad\xdd\xb6\xcd\x45\xd3\xd3\xba\x30\x31\x11\x96\xb6\ +\x6f\x8f\xab\xdb\xb7\xdb\xe8\xc4\x09\x3d\xb0\x73\xa7\xab\x85\xa1\ +\x73\x93\x93\xaa\x18\x86\xd6\x95\xcb\xc8\x66\x42\xb9\x72\x60\xe3\ +\xbb\xc7\xe6\xcc\xee\xc1\xc5\xe2\x93\xe7\xb6\x07\xaf\x5d\x19\xd6\ +\x91\x82\xdd\xd9\x7f\x43\xfd\x48\x93\x7a\x9d\x95\x87\x8c\x66\xa3\ +\xa0\xf0\xc3\x8b\x63\xe1\x0b\xe3\x63\x98\xab\x85\xe6\xc1\xfd\x13\ +\xe6\x9e\x6d\xb3\xae\x2f\x5c\x32\xec\x76\xfa\xf4\x69\x7c\xf8\xc3\ +\xff\x73\xf9\xf2\xe5\x19\x6b\xcc\x6b\x5f\x41\x9a\xf1\x22\xa2\xcd\ +\x81\x41\x0b\xd1\xc6\x9b\x00\x50\x7b\xfd\xf5\xd7\xf7\x3e\xf7\xdc\ +\x73\xee\xa3\x1f\xfd\x28\x0a\x85\xc2\x6a\x41\x49\xd3\x9a\x96\x56\ +\x99\x3b\x46\x16\xf4\xe9\xd9\xfe\xe0\xe8\xd5\x5d\x81\x0e\x16\xe3\ +\x83\xa3\xf3\x76\xac\x1c\xa9\xd8\x20\xfc\xe1\xa5\xb1\xc1\xfb\x47\ +\xa7\x4f\x9f\x0e\xfb\x76\xec\xb0\xb5\x2b\x57\x74\xb1\xaf\x2f\x36\ +\xd3\xd3\x61\x61\xe7\x4e\x5b\x93\x2c\x0c\x00\x6c\xdb\x66\xa3\x57\ +\x5f\x2d\x0c\xed\xd9\x63\xab\x37\xbc\x48\x29\x70\xe6\xee\xb1\x39\ +\xf3\xf6\x6d\xb3\x18\x9f\x2b\x15\x9e\x39\xbf\x2d\x38\x72\x75\x48\ +\x5f\x9c\x2f\xb9\x82\xb6\x18\x29\xc5\xb9\xdf\xcf\x6c\x14\xe8\x37\ +\xae\x0e\x16\x9e\xbb\xb8\x35\x78\x6d\x72\x38\xb8\x34\xd7\x17\xbf\ +\x7d\xdb\x75\xf7\xbe\xbd\x53\x66\xff\xc8\xa2\xd3\x37\x06\x38\x2f\ +\xbc\xf0\x82\xfb\xd8\xc7\x7e\x67\xe0\xfa\xf5\x6b\x95\x38\x3e\xfa\ +\x15\x00\xd7\x3a\xb0\xeb\x88\x68\x1d\x75\xac\x47\x02\x11\xad\xd9\ +\x6d\x41\x10\xfc\xcc\x5d\x77\xdd\xa5\x1f\x79\xe4\x11\xdc\x7a\xeb\ +\xad\x2b\x3e\xb0\xc9\x14\xe8\xf6\x18\xa3\x4a\xff\xef\xd1\x5b\x8b\ +\x5f\x3f\x75\xcf\xec\x7f\xfe\xe8\xe3\x28\xc3\x00\x40\x78\x74\x6a\ +\x40\x1f\xbf\x36\xf4\xe2\x6d\x07\xe7\xef\xbd\xd7\xce\x1e\x3e\xac\ +\x87\x8a\x45\x6d\xaf\x5f\x77\x85\xfb\xee\x33\x33\x17\x2f\x86\xa5\ +\xe1\x61\x17\x8f\x8c\x98\x18\x00\x66\x66\x82\x70\x72\x52\x15\x0f\ +\x1c\x88\x17\xf2\xbc\xac\x9a\x5c\x28\x84\x6f\x5c\x1b\x0a\xae\x56\ +\x4a\x56\xc1\xc1\x41\x01\x16\x50\xda\x21\x8a\x35\x4a\x45\x8b\x6a\ +\x4d\x23\xd4\x2e\xeb\xd2\x50\x0e\x8c\xbd\x65\x70\x21\x3e\xb8\x65\ +\x1e\x85\xe0\x86\x29\xd2\x8d\xfb\xe7\xd1\x47\x1f\xc5\x3f\xfe\xc7\ +\xff\xd7\x50\x1c\x5f\x1e\x37\xe6\xec\x63\x48\x66\x71\x11\xd1\x26\ +\xc3\xa0\x85\xa8\xb7\x6c\x2f\x16\x8b\x3f\x57\x2e\x97\x0b\x5f\xf8\ +\xc2\x17\xd4\xcf\xfd\xdc\xcf\xad\xef\xab\x2f\x44\x41\xf9\xcf\x5e\ +\xba\xbb\xf0\xfa\xf4\xde\xd9\xff\xfb\x43\x4f\xc8\x97\xc3\xa3\x53\ +\x03\xe7\x9e\x9c\xdb\xbd\xe7\x7f\xba\xf5\xc4\xe1\xc3\x7a\xe8\x9e\ +\x7b\xec\xdc\xcb\x2f\xeb\xe1\xc1\x41\x1d\xbf\xed\x6d\xf1\xfc\xe1\ +\xc3\x7a\xe8\xde\x7b\xed\xac\x3c\xfe\xf5\xd7\xc3\xc1\x7d\xfb\xe2\ +\xc5\xa1\xa1\x24\xf0\xd9\x28\xc6\x18\xfc\xde\xef\xfd\x1f\xea\xf3\ +\x9f\xff\xc1\x50\x10\x9c\x3f\x65\xcc\xe5\x6f\x01\x88\x36\x72\x9b\ +\x88\xa8\x7d\x1c\x1e\x22\xea\x2d\x0b\xc6\x98\x33\x71\x1c\xef\xfa\ +\xd2\x97\xbe\xd4\xa7\xb5\xc6\xfb\xde\xf7\xbe\xf5\x7b\xf5\x42\xe0\ +\xcc\xdd\x63\xd3\xc1\xeb\xd3\xc3\xc5\xbf\x3e\x7a\x67\xf4\x0b\x07\ +\xce\x01\x80\xdd\xd6\x17\x5d\x9a\x2f\xa9\xdd\xcf\x1e\xdb\x76\x75\ +\x78\x2c\x1a\xdb\xa3\xaa\x53\x53\x61\xc1\x18\xa5\x1a\x87\x88\x00\ +\x60\xfb\x76\x5b\x7b\xe5\x95\xc2\xf0\xb2\xc3\x44\xeb\x64\x62\x62\ +\x02\x9f\xf8\xc4\x6f\x15\xbf\xf2\x95\x53\x43\xc0\x4b\x3f\x70\xee\ +\xfa\xd3\xc0\xc6\x06\x51\x44\xb4\x36\x0c\x5a\x88\x7a\x4f\xe4\x9c\ +\x3b\xe5\x9c\xeb\xfb\xfe\xf7\xbf\x3f\xf6\xec\xb3\xcf\xe2\x67\x7e\ +\xe6\x67\x30\x3c\x3c\xbc\x3e\xaf\xde\x5f\xb0\xd1\x03\xbb\x26\x8a\ +\xdf\x3a\xb7\xaf\xf0\xf4\x85\x9d\xd1\xcf\xdf\x76\x11\x00\x8a\x5b\ +\xc3\xda\xb9\xfe\xb1\xf8\xe0\x91\x53\xa3\x17\xa7\xc2\x42\xff\x2d\ +\xc5\xc5\x30\x54\x6e\x6a\x0a\xc5\xad\x5b\x75\x34\x3f\xaf\x83\x81\ +\x01\x9b\x05\x05\x43\x43\x36\x3e\x7d\x3a\xec\xdf\xb6\xcd\xae\x7b\ +\x66\xe3\xf1\xc7\x1f\xc7\x3f\xf8\x07\xff\xb2\xff\xec\xd9\x09\xeb\ +\xdc\x8f\xbe\x09\xd8\x23\xeb\xbd\x0d\x44\xd4\x79\x6c\xe3\x4f\xd4\ +\x9b\x0c\x80\x1f\x00\x78\xfa\x07\x3f\xf8\x41\xfc\xb3\x3f\xfb\xb3\ +\x78\xf4\xd1\x47\xd7\xef\xd5\xfb\x0b\x66\xfe\x8f\x7f\xf6\x19\x75\ +\x75\x61\x68\xf0\x7f\xf9\xf6\xdf\x06\xe0\x86\x87\xd5\xe2\xbc\x29\ +\x59\xfd\xc9\xbb\x4f\x99\xd7\xaf\xbb\xdb\x0f\x9d\x1c\x98\x9b\x51\ +\x85\x6b\xd7\x8a\x0b\x3b\x76\xc4\x93\x97\x2f\xab\x92\x52\xaa\xa6\ +\xb5\x8e\x00\x60\x68\x08\xa6\x54\xb2\x76\x62\x42\x15\xd7\x6b\xb3\ +\xe7\xe7\xe7\xf1\xd9\xcf\xfe\xaf\xfa\x93\x9f\xfc\xdc\x48\xa5\x32\ +\x31\x61\xcc\xab\xff\x0d\xc0\xd9\xf5\x7a\x7d\x22\xea\x2e\x66\x5a\ +\x88\x7a\xdb\xb4\x73\xee\xb4\x31\x66\xeb\x57\xbe\xf2\x95\x81\x97\ +\x5f\x7e\x19\x0f\x3c\xf0\x40\x57\xb3\x2e\x61\x18\x2e\x58\x6b\x0b\ +\xaa\x10\x2e\xd6\x7e\xe1\xc0\xd1\xf2\x53\x17\x6e\x0d\xff\xf3\x2b\ +\x3f\x59\xfb\xa5\xbb\x4e\x8e\x8f\xa3\xbc\x63\x87\x8d\xcf\x95\xb6\ +\x84\x3b\xee\x2e\x2d\xc6\xdf\x3c\x73\xcb\x2d\xdb\x23\xf7\x66\x34\ +\x50\x8e\x22\xad\x77\xee\x34\xc6\x39\x17\x00\x80\xd6\xda\x8c\x8e\ +\xda\x6b\xc7\x8e\x85\xa3\x5b\xb7\xa2\x12\x86\xa8\x01\x58\x71\x41\ +\xc6\xb5\x7a\xfc\xf1\xc7\xf1\x8b\xbf\xf8\xcf\xfa\x9f\x7b\xee\x52\ +\xc9\xb9\xe7\x9f\x89\xe3\x6b\x4f\x01\xd8\xb0\xe1\x29\x22\xea\x3c\ +\x06\x2d\x44\xbd\x2f\xb2\xd6\x9e\x04\x50\x39\x7f\xfe\xfc\xee\x87\ +\x1f\x7e\x58\x07\x41\x80\x77\xbf\xfb\xdd\x08\x82\x8e\x7c\x84\x9d\ +\x52\xea\x8a\x73\xae\x1c\x04\x81\x32\xc6\x48\x66\x24\x84\x46\xb5\ +\xfa\xc1\xdb\x4e\x17\x27\x2b\x85\xfe\xdf\x7b\xe6\xef\x4e\xfc\xd4\ +\x5d\x6f\x0e\xec\x54\xd5\xab\x57\x55\x71\xe7\x1d\xe1\x62\xff\x7d\ +\x5b\xa6\xae\xbc\xb8\x30\x56\x7a\x79\x62\xfb\xed\xef\x0a\xa7\x4e\ +\x5d\x19\x50\xdb\xb6\xb9\x9a\x52\x4a\x21\x99\x52\x3c\xb0\x6b\x97\ +\x35\x2f\xbf\x1c\x8e\xee\xd9\x93\xcc\x2e\x0a\x82\x60\x5e\x29\xb5\ +\xe0\x9c\x2b\x77\x62\xe3\xcf\x9d\x3b\x87\x4f\x7f\xfa\x9f\x05\xff\ +\xe6\xdf\x7c\x73\x28\x8e\x2f\x8c\xc7\xf1\x91\xaf\x03\x38\xdd\x89\ +\xe7\x26\xa2\xde\xc2\xa0\x85\x68\xf3\xb8\x6a\x8c\x39\xe9\x9c\x1b\ +\xfc\xee\x77\xbf\x3b\xf2\xe8\xa3\x8f\xe2\x96\x5b\x6e\xc1\xc1\x83\ +\x07\xdb\x7d\xbe\x79\x00\x15\x00\x65\x00\x03\x5a\xeb\x58\x29\xa5\ +\xac\xb5\x08\x82\x20\x4e\x33\x26\x25\xa5\x94\xaa\xde\xb7\xe3\x9a\ +\x39\xb0\xe3\xfc\xad\xbf\xf7\x8d\xbf\x7b\xf5\xcd\xa8\x0f\xef\xd9\ +\x77\xde\x39\xe3\xfa\xfb\x81\xd3\xd1\xd8\xc2\xb6\x9f\x1e\x9c\x9a\ +\x79\x6a\x72\x6b\xe1\xb9\xcb\x43\xa3\xa3\xb1\xb2\xdb\xfb\xe7\x95\ +\x52\x03\xce\xb9\x10\x00\x46\x47\x31\x7f\xe4\x48\x38\xb2\x6b\x97\ +\x9b\xb5\xd6\x96\x9d\x73\x7d\x48\x82\xa5\x71\xe7\x5c\x7f\x1a\xe4\ +\xb4\xb6\xf1\xf3\xf3\xf8\x93\x3f\xf9\x77\xea\x37\x7f\xf3\xf3\x43\ +\xa7\x4e\x4d\x2a\x6b\x7f\xf4\x3d\x63\xae\x3f\x0d\x60\xb1\xdd\x1d\ +\x42\x44\xbd\x8d\x53\x9e\x89\x36\xa7\x6d\xfd\xfd\xfd\xef\x5d\x58\ +\x58\x18\xfb\xa9\x9f\xfa\x29\xfc\xf6\x6f\xff\x36\x3e\xf4\xa1\x0f\ +\xe5\xfa\x41\xad\x75\x64\x8c\x51\x4a\xa9\x10\x00\x82\x20\x98\x75\ +\xce\x0d\x5a\x6b\x81\x74\x85\x68\x00\xd6\x5a\xbb\x00\x60\xc8\xff\ +\x59\x65\x55\xad\xfa\x3f\x3c\xf9\xd1\xad\xb3\x53\xfd\x2f\xfd\xd3\ +\x8f\x3d\x71\xf0\xef\x04\x73\x93\x93\xaa\x3a\x3b\xab\x46\xaf\x5e\ +\x0d\xdd\xae\x5d\x30\xa3\xaf\x9e\xda\x32\x36\xbb\x50\x70\x3b\xfa\ +\x2a\xf6\xbd\x7b\xae\x9a\x72\x30\x0b\x60\x68\x72\x32\x28\xcc\xcc\ +\xa8\xc2\xc1\x83\x76\x1e\x40\xac\xb5\x36\x71\x1c\x97\x01\x40\x29\ +\xb5\xa0\x94\xea\xcb\xd3\x7b\xa6\x52\xa9\xe0\xcf\xff\xfc\xcf\xf1\ +\x6f\xff\xed\xd7\xfa\x27\x27\x4d\xa1\x5c\x3e\xf5\x4a\xa5\x32\xf9\ +\x3c\x18\xac\x10\xbd\xe5\x31\x68\x21\xda\xbc\x14\x80\xfd\x7d\x7d\ +\x7d\xef\x5e\x5c\x5c\xec\x7f\xef\x7b\xdf\x8b\xcf\x7c\xe6\x33\x4d\ +\x83\x17\xa5\x54\xcd\x39\x57\x94\xbf\x91\xae\xaa\x8c\x24\x50\x91\ +\xe2\x7c\x85\x64\xb9\x80\x05\x00\x03\xf0\x96\x0e\x38\x74\xa8\x30\ +\xfc\xc0\xd5\xb3\xc5\xda\x9f\xbc\xf4\xc1\xfe\x3b\xca\x17\xe7\xfe\ +\xfd\xcf\x3f\x75\xf8\xb5\xc2\xd0\xdb\xdf\x1e\xcd\x1d\x3f\x1e\x0e\ +\xc4\xb1\x52\xf7\xde\x1b\x5d\x57\xe7\x67\x8a\xe1\xa1\x2b\x7d\x4a\ +\x05\xfd\x08\x94\x35\xf7\xef\xba\x72\x6c\xba\xbf\x2f\x0c\x5d\xed\ +\xb6\xdb\x5c\x2c\xc1\x91\x31\x46\x05\x41\x60\x01\x68\xef\xf5\x6f\ +\x70\xfd\xfa\x75\x3c\xfc\xf0\xc3\xf8\xfc\xe7\x9f\xe8\x9f\x9c\xac\ +\x05\x03\x03\x6f\x1e\x9f\x9f\x9f\x78\x11\xec\x6c\x4b\x74\xd3\x60\ +\xd0\x42\xb4\xf9\x29\x00\x07\x06\x07\x07\xdf\x35\x37\x37\xd7\x77\ +\xe7\x9d\x77\xe2\xd3\x9f\xfe\x34\x1e\x7a\xe8\x21\x0c\x0c\x0c\xf8\ +\x8f\xbb\x0e\x60\x0e\xc0\x1e\xa0\x1e\xbc\x68\xad\x8d\xb5\x56\x86\ +\x8a\x1d\x92\x6c\x4b\x64\xad\x2d\x00\x80\x73\x2e\x52\x4a\x15\xe4\ +\x6b\x33\x33\x2a\x9c\x9c\x54\xc5\xf9\x79\x04\xf7\xbf\xf0\xf2\xf6\ +\xe2\x57\x4f\xdd\x37\xbb\x6d\xe8\xda\xc5\x7f\xf9\x81\x67\xae\x57\ +\xcb\x7a\x6e\xce\xe0\xdd\xef\x76\xf3\x85\x82\x8b\xad\xb5\xa1\xd6\ +\xda\xa9\x2b\x0b\x41\xf0\xa3\xcb\xdb\x74\xc5\x04\x17\xaf\x04\xa5\ +\x72\xd9\xd9\x2d\x77\x94\xa6\x6b\xb7\x0e\x57\xf4\xd6\xbe\x9a\x29\ +\x07\xf2\xda\xc7\xb5\xd6\x07\xbc\xed\xc1\x99\xa3\x27\xf5\x5f\x7e\ +\xe1\xaf\x82\xff\xf0\xdf\x9e\x2f\x2f\x2c\xd4\xd4\xf0\xf0\xe5\x93\ +\xd7\xaf\x9f\x7f\x01\x5c\xe8\x90\xe8\xa6\xc3\xa0\x85\xe8\xad\x43\ +\x01\xd8\x37\x34\x34\xf4\xce\xd9\xd9\xd9\xd1\x81\x81\x01\x3c\xf4\ +\xd0\x43\xf8\xe4\x27\x3f\x89\xfb\xef\xbf\xbf\xa2\x94\x0a\xad\xb5\ +\xa1\x52\x6a\xd1\x5a\x5b\x55\x4a\x8d\x02\xc9\x2c\x1f\x6b\x6d\xa0\ +\xb5\xf6\x33\x2d\x70\xce\xd9\x20\x08\x94\xb5\x56\x49\x5b\xfc\xf4\ +\xb1\xfa\xf0\x61\x3d\xbc\x65\x8b\x8b\xfa\xfa\x60\xb6\x6d\x73\xd1\ +\xc0\x9f\x3d\x7f\x70\xee\xff\xbb\x72\xdf\x70\xbf\x9d\x7f\xed\x43\ +\xf7\x1d\x99\x7e\xcf\x2d\xe3\xf7\xde\x6b\x67\xb5\xd6\x59\xe0\x02\ +\x00\xf2\x1c\xaf\xbe\xaa\x47\xf6\x99\xeb\x6e\x6c\xfa\x5a\x29\x58\ +\x34\x01\x2e\xcd\x4d\xd9\xd1\xd2\x76\x28\x28\x65\xdc\x7c\x25\xaa\ +\xf5\xbf\x7c\xe8\x65\xf5\xad\xef\xbe\x58\x78\xe5\xf8\xe5\xe0\xba\ +\x56\xd1\xe1\x81\x17\xbe\x3f\x3b\x7b\xed\x30\x80\x99\x8d\xd9\xbd\ +\x44\xb4\xd1\x18\xb4\x10\xbd\x35\x8d\x0d\x0d\x0d\xbd\x2d\x8a\xa2\ +\xfd\x95\x4a\x45\xf7\xf5\xf5\x2d\xfe\xda\xaf\xfd\x9a\x7e\xe8\xa1\ +\x87\xdc\xfd\xf7\xdf\x1f\x03\x18\xd4\x5a\x1b\xe7\x5c\xe4\xcf\xe2\ +\x49\x83\x13\xc0\x3b\x37\x34\x06\x33\x00\xf0\xe3\x1f\x87\x83\xef\ +\x7e\xb7\x9d\x3d\x74\x08\xc3\x69\xfb\x7e\x37\x3e\x1e\x14\xed\xb1\ +\xeb\x43\xfb\xfe\xd3\x33\xef\xad\x8c\x47\x5b\xc7\xf6\x16\x2e\xd7\ +\xfe\xbb\x3b\x8f\x54\xfe\xfe\x6d\x17\x11\x04\xae\x31\xa3\x73\xf8\ +\xb0\x1e\xde\xb6\xcd\x5d\xd9\xb3\x27\x79\xfd\x85\x85\x85\xf1\x6f\ +\x7f\xfb\xdb\x3b\x3f\xf7\xb9\xff\x67\xf6\xb5\xd7\x16\x76\x45\x91\ +\xd1\xc3\xc3\xb5\x99\x4a\xe5\x8d\x43\xb5\x5a\xed\x24\x92\xa2\x61\ +\x22\xba\x89\x31\x68\x21\x7a\x6b\x0b\x01\xec\x43\xb2\x18\xe3\x5e\ +\x63\x8c\x1e\x1e\x1e\x36\x1f\xfc\xe0\x07\xdd\x03\x0f\x3c\x70\xfd\ +\x63\x1f\xfb\xd8\xd8\xd6\xad\x5b\x81\xb4\xae\xc5\x18\xe3\x94\x52\ +\xda\xcf\x8c\x2c\xf7\xa4\x0b\x0b\x08\x2e\x5d\x0a\x4b\xf3\xf3\x36\ +\xf0\xd7\x1c\x3a\x74\xa8\x30\xfc\xae\x77\x45\xd7\x9f\x7f\x3e\x18\ +\xdd\x7d\x6a\x62\xe8\x9e\x67\x0e\xdf\xae\x2e\xcd\x8d\x29\x05\x44\ +\xa5\xb0\xe6\xee\x1a\x7d\x33\x7e\xcf\xbe\x89\xda\xfb\x6f\xb9\x8a\ +\x32\xcc\x37\xbe\x71\xba\xff\xf1\xc7\xbf\x7c\xf9\xcc\x99\x1f\x8f\ +\xfd\xf0\x87\x93\x65\x6b\x75\x18\x04\xb5\x79\x63\x5e\x7c\x05\xc0\ +\x19\x00\x57\xba\xbe\x87\x88\x68\xd3\x60\xd0\x42\xb4\x76\x0a\xf5\ +\xcf\x92\x14\xb0\x22\xfd\xfb\x86\x15\x88\x37\x50\x01\xc0\x5e\x00\ +\x7b\x83\x20\xd8\x63\x8c\x29\x03\xc0\xc8\xc8\x48\xe5\x23\x1f\xf9\ +\x48\xf9\x9d\xef\x7c\x67\x7c\xcf\x3d\xf7\x84\xef\x78\xc7\x3b\x30\ +\x3a\x3a\xea\x67\x45\x96\x75\xf8\x70\x61\x28\x0c\x9d\x3b\x78\x30\ +\x9e\x2f\x14\x92\xf7\x99\xd4\xbb\x04\xc5\xdb\x6f\x8f\x17\xbf\xfc\ +\xe5\xf2\x9e\x5f\xfa\xa5\xca\x05\x20\xc9\xd6\x5c\x7a\xf2\xd5\xa1\ +\xe8\x91\x1f\xdf\x66\x8e\x5e\xd9\x5a\xbb\xb4\x30\x36\x35\x53\x0d\ +\xaf\x99\xc5\xea\xaf\xe1\xf8\x33\x41\x70\xf9\x92\x31\x6f\x9c\x00\ +\x70\x01\x49\xa0\xd2\x4b\xfb\x8d\x88\x7a\xc4\x7a\x06\x2d\x01\x92\ +\xbb\xbe\x20\xfd\xa3\xb1\xf4\x64\x0f\xd4\x4f\xf2\x16\x49\x1b\x73\ +\x03\x20\x06\x17\x39\xa3\xde\xa1\x91\x5c\xfc\xe5\x78\x96\xe3\x78\ +\x35\x72\x3c\xcb\xdf\xbd\x72\x4c\x8f\x01\xd8\x01\x60\x7b\x10\x04\ +\x3b\x8d\x31\x7d\xf2\x8d\xad\x5b\xb7\xba\xfd\xfb\xf7\xab\xfd\xfb\ +\xf7\x63\xef\xde\xbd\xd8\xb1\x63\x07\xb6\x6c\xd9\x82\xd1\xd1\x51\ +\x0c\x0c\x0c\x60\x60\x60\x00\xe7\xcf\x0f\xf6\x8f\x8d\xc5\xb5\xcb\ +\x97\x0b\xe5\xdb\x6e\x9b\x9e\x9b\x9d\x9d\xc5\xfc\xfc\x3c\x0e\x1d\ +\x2a\x0c\x0f\x0c\xbc\x31\x7b\xf6\x6c\xad\x78\xf8\xf0\xe0\xd8\xf5\ +\xeb\xcf\xcf\x5e\xb8\x70\x19\xd5\x6a\x25\xdd\x4f\xca\x05\xc1\xd4\ +\x84\x31\x67\xcf\x21\x09\x50\xc6\xc1\xe9\xca\x44\x94\x43\xb7\x83\ +\x16\x0d\xa0\x04\xa0\x88\xb5\xad\x73\x64\x01\xd4\x90\xb4\xe4\xb6\ +\x1d\xd8\x2e\xa2\x56\x68\x24\xc7\x70\x11\x9d\x6b\xc8\xe8\x00\x44\ +\x48\x8e\xeb\x75\x5f\x50\x70\x05\x25\x00\x5b\x00\x8c\x02\x18\x06\ +\x30\x54\x2c\x16\x87\x8d\x31\xfd\xc6\x98\x15\x3e\xbf\xef\x19\x01\ +\x46\x0b\xc0\x44\x15\xb0\x0e\xd0\x2a\xf9\x53\x52\xe5\xb2\xaa\x45\ +\xd1\xc2\x35\x63\x5e\x9d\x00\xe2\x59\x00\xd3\xe9\x9f\x19\xf4\x46\ +\xd0\x46\x44\x9b\x4c\xb7\x82\x16\x0d\xa0\x0f\xc9\x49\xbe\xd3\x22\ +\x24\xbd\x23\x18\xbc\x50\xb7\x69\x24\xdd\x62\x4b\x5d\x7e\x1d\x8b\ +\x24\x20\xaf\xa2\x77\x87\x45\x42\x24\xfb\xa1\x04\xa0\x70\xcf\x3d\ +\xf7\x94\xc6\xc6\xc6\xde\xfe\xf4\xd3\x4f\xef\xf8\xc4\x27\x3e\x71\ +\xe8\x3b\xdf\xf9\xce\xd4\xd5\xab\x57\xab\x48\x3e\x9f\xbd\xfe\x5e\ +\x88\x68\x93\xea\x46\xd0\x52\x4e\xff\x74\x3b\x8b\x53\x01\x53\xca\ +\xd4\x3d\x25\x24\x81\xf7\x7a\x0e\xa1\x3a\x24\x17\xfb\xcd\x72\x5c\ +\xef\x01\x70\x10\xc0\x33\x48\x86\xbc\x36\x13\x19\xe6\xeb\x04\x87\ +\xa5\x43\xdb\xbc\xa1\x22\xea\x92\x4e\x9e\x90\x15\x92\xce\x99\x9d\ +\x3a\x11\xe4\x11\x23\x69\x96\xc5\x3b\x3a\xea\x94\x8d\x38\x8e\x7d\ +\x06\x49\x13\x38\xea\xae\x22\x92\xdf\x73\x37\x48\xf0\x12\xa5\x7f\ +\x36\x5b\x40\x47\xd4\xb3\x3a\x35\x3e\xaf\x00\x0c\x62\xfd\x4f\xf4\ +\x72\xb7\x14\x81\x81\x0b\xad\x9d\x46\xb2\xd6\x4e\xb8\x81\xdb\x20\ +\xd9\x16\xea\xae\x00\xdd\x19\xbe\x06\x92\xf3\xa1\xc6\xd2\x21\x35\ +\x80\x75\x3c\x44\x6b\xb6\x96\xe2\x58\x21\x01\xcb\x46\x9d\xe8\x03\ +\x24\x17\x1a\x4e\xdf\xa6\xb5\x90\xe3\x98\x2b\x9f\x53\xa7\x69\x00\ +\xfd\x00\x46\xb0\xb1\x01\x31\xd1\xa6\xd7\x89\x13\xf4\x5a\x53\xe9\ +\x7e\x2f\x8b\x76\x03\x0f\x85\xe4\x64\x50\x5b\xc3\x76\xd0\xcd\xad\ +\x13\x19\x16\xd3\xf0\x47\x6a\x1b\x5a\xb9\x39\x60\xa6\x65\x7d\x74\ +\x33\xd3\xb2\x12\x85\x24\xeb\xe2\xc0\xac\x0b\x51\x5b\xd6\x7a\x92\ +\x96\x69\xa0\xad\xf2\xa7\x7a\xfa\xc3\x3a\x0a\x49\x00\x54\x68\xe3\ +\x79\x43\x24\x05\xc0\x6c\xf5\x4d\xad\xea\x43\xfb\x9f\x05\x99\x31\ +\x13\x63\xe5\x21\x4a\x85\xfa\x45\xb2\x80\xce\x64\x38\x69\xf3\xea\ +\x47\x72\xac\xf0\x26\x8b\xa8\x45\x6b\x09\x5a\x14\x92\x0f\x5f\x2b\ +\x2c\x80\x79\xac\x5c\x98\x26\x1f\xe4\x1a\x92\xe0\x63\x00\xad\x65\ +\x83\xfa\xd2\x9f\x65\xf5\x3e\xe5\x25\xc1\x6e\xab\x6a\x48\x66\xf9\ +\xe4\x39\xd6\x1c\x92\x63\x5e\x8e\xfb\x62\xfa\x9a\x1c\x8a\xba\x79\ +\xf5\x23\x39\x1e\xd6\x72\xae\xea\xc7\xea\xd9\xe9\x18\xcc\xda\xd1\ +\x5b\xcc\x5a\x4e\x9a\x7d\x68\x6d\x58\xc8\x20\x99\xe9\x93\x37\x2d\ +\x2a\x01\x8c\x74\x1d\xcd\x4b\xa3\x77\x9a\x75\x51\xef\x1b\x44\xeb\ +\xc3\x37\x0b\x48\x82\xea\x76\x8b\xbf\x0d\xea\x17\x93\xc6\xcf\x10\ +\x87\x87\xd6\xc7\x46\x0c\x0f\xf9\x24\xfb\xb6\x96\x6c\x8b\xd4\x60\ +\xad\xf4\x07\x6b\x7c\x7e\xa2\x9e\xd3\x6e\xa6\x45\xc6\x66\xf3\x72\ +\x48\x02\x96\x56\xef\x2a\xe4\xe7\x86\x91\xff\xc2\x52\x44\xfe\x3b\ +\x60\xba\xb9\x49\x3b\xfe\x56\xcc\xa3\x73\x41\x71\x25\x7d\xae\x7e\ +\xb0\x40\xb3\x97\xd5\xb0\x34\x3b\xec\x67\x37\x64\x96\x50\x3b\x37\ +\x80\x72\xfc\xb1\xbe\xa5\x75\x25\x34\xbf\x69\x9e\x47\xe7\x67\x95\ +\xf6\x63\xf5\x6b\x91\x4b\x5f\x97\xba\xa4\xdd\x13\x65\x11\xad\x15\ +\xcd\xae\xa5\x83\xad\xdc\xd9\x0e\xb6\xf0\x33\x25\x6c\x9e\x06\x5d\ +\xb4\x71\x5a\x1d\x16\x5a\x40\xe7\xb3\x78\x06\xc0\x6c\xba\x2d\x7d\ +\x4d\x1e\x4b\x1b\x23\xcf\x30\x4b\xbb\xdd\x93\xe5\x26\x8b\x5a\x13\ +\x60\x63\x7a\x29\x35\x0b\x50\x19\x80\x76\x59\xbb\x05\x81\xad\xa4\ +\x55\x65\xdd\xa0\xb5\x68\xb5\x41\xd3\x46\xa6\x7d\x69\x73\x90\x3b\ +\xe4\xbc\xba\x5d\x1f\x50\x41\xd2\x54\x8e\x17\xb0\xcd\xc9\x22\x09\ +\x6a\x17\x5a\xfc\x39\x66\xd8\x88\x5a\xd0\xce\x07\x46\xa6\x17\xe7\ +\xd5\xa9\x13\x7d\x05\xf9\xb3\x2d\x1a\xeb\x9b\x76\x0d\x50\x6f\x28\ +\xe5\xb7\xf2\xde\xa8\x86\x77\xf2\xfe\x95\xf7\x47\xb6\x47\x56\x1a\ +\xee\x65\xda\xfb\x23\x53\xe2\x0d\x3a\xbb\x3f\x5b\xbd\x4b\x5b\x8f\ +\x59\x69\x32\x55\xfa\x66\x21\x75\x1d\x8d\xab\xbe\xcb\x71\x2a\xbf\ +\xf7\xcd\xd4\x51\xb6\x8a\xfa\x0c\xc8\x3c\x58\x8c\x4d\xd4\x82\x76\ +\x82\x96\x56\x7f\xa6\x53\x41\x8b\x4c\x8f\xce\x3b\x2c\x15\xa2\xb5\ +\x0b\x40\xb3\x75\x66\x2c\x96\x5e\xb8\x02\xd4\x57\xb0\x5e\xee\xe7\ +\x64\x15\xdf\x2a\xd6\xe7\xa4\x2b\xd3\x69\xf3\x14\x2e\xcb\xc5\x40\ +\x56\xce\xee\x86\x66\x33\xcb\xfc\x62\x54\x20\xdf\x8a\xe0\x92\xed\ +\xe8\x44\x71\x61\x2b\xc7\xb1\xc1\xe6\x2e\xee\x96\xe0\x40\x8e\x0f\ +\x09\xb0\xe5\xb8\xf5\x03\xc3\x18\x4b\x67\x3a\x75\x43\x11\xc9\xef\ +\x3a\xef\xef\x40\x66\x5f\xc9\xcc\xc2\x5e\x27\x81\x4b\x1e\x7e\xa0\ +\x46\x44\x4d\xb4\x13\xb4\xb4\x72\x67\xd0\xe9\xbb\xe3\x18\xdd\xbb\ +\x83\x59\xed\x62\x29\xaf\x5d\x41\xfe\x15\xac\x15\xea\x7d\x6c\xaa\ +\x68\x3d\x6d\x9c\x57\x09\xc9\x58\x7a\x2b\x43\x7d\x92\x2d\x93\xe9\ +\xbe\x8b\xe8\xfc\xc5\xa0\xd9\xd8\xbe\x04\x4c\x0a\xf5\x45\x36\x9b\ +\x91\x6d\x2e\x61\xed\x6b\x4e\xb5\x72\xec\x6f\xd6\x80\x45\xea\x2c\ +\x9a\xd5\xa0\xc9\x85\xd3\x5f\x44\x50\x82\xf4\x4e\x06\xb5\x45\x24\ +\x9f\x9d\x56\x87\xa5\xfd\xfe\x4d\x72\xbc\xf6\xf2\xef\xa4\xd5\x6c\ +\x19\x83\x16\xa2\x9c\xd6\x23\x68\xe9\xa4\x6e\x06\x2d\x79\x14\x90\ +\xf4\x8e\x69\xb5\x73\x6f\x09\xc9\x89\x7a\xae\x83\xdb\xa2\xd3\x6d\ +\x59\xeb\x98\xb8\xff\x3c\xdd\x0a\xac\x56\x12\xa6\xaf\xdd\xea\x45\ +\x2c\x44\xd2\xc1\x76\x16\xed\x9d\xec\xe5\x02\x9d\x57\x2f\x5f\x20\ +\x57\xb2\xd6\xd5\xd6\xa5\xf5\x7c\x11\xc9\x6c\x88\xb5\xcc\xc6\x93\ +\x9e\x4e\x9d\xa8\x35\x0b\x90\x0c\x13\xf7\xf2\x2a\xef\xad\x1e\x93\ +\x9b\x29\x60\xf1\x6f\x78\x1a\x87\xa0\xfd\x95\xae\xfd\xac\x1d\x51\ +\xc7\xb4\x73\xc1\x6b\xe5\x64\xdf\xe9\xa0\xa5\x95\xe7\xeb\x74\xd7\ +\xd1\x10\xad\xcd\x60\x6a\x54\x40\x72\x97\xd9\x89\x13\xad\x9c\xb8\ +\x3b\xf9\x1e\x25\x33\xb2\x5e\x81\x4b\x3b\x5d\x8f\x7d\x01\x92\xfd\ +\xd9\xce\xf6\xb6\xba\xdf\x36\x53\x9d\x49\xa7\x57\xa9\xf6\x03\xc4\ +\x76\x03\x97\x6e\xac\x9a\x2d\x01\xd9\x7a\x07\xda\x79\xb4\x12\x28\ +\xfa\xcb\x98\xf4\xb2\x00\xf5\xac\x5d\x2b\xa4\xdf\x56\x05\x6b\x6f\ +\x43\xa1\x56\xf8\x77\x9e\xc7\x2f\x67\x33\xec\xf7\xe5\xc8\x24\x02\ +\x29\x05\x58\xa9\x76\x51\x82\xc6\x4e\xb6\xff\xd0\x68\x7e\x0c\x44\ +\x58\xfe\x9c\xe9\xb7\x07\x90\x20\xb7\xb6\xc2\x63\x57\xd4\xed\xa0\ +\xa5\xd3\xbd\x52\x5a\x39\xc8\x7a\xb1\x55\x7a\x19\x6d\xfc\x92\x1a\ +\x68\xb4\x16\xb0\xb4\x52\x07\x54\x42\xbd\x76\xa0\xdb\x3a\xb1\xc0\ +\x65\x09\xed\x9d\x0c\x5b\x3d\x36\x9a\x1d\x77\x52\xdf\xd4\x29\xed\ +\x5e\x88\xbb\xb5\x78\xa9\x1c\x73\xed\x64\xb6\x5a\x6d\x42\xd9\x8a\ +\x12\x6e\xac\x8d\xea\x05\xad\xec\xff\x5e\xef\x27\xb5\xd6\x2c\x99\ +\xf4\xf4\x2a\x22\xf9\xac\xb6\x5b\xd0\x1e\x20\xe9\xd7\xd5\x8a\x91\ +\x26\xdf\x9f\x41\xf3\xfd\x5f\x44\x12\x74\xe7\x15\x00\xd8\xb2\xca\ +\xf7\x1d\x80\xe9\x16\x9e\x4f\xf8\xfb\x71\xb5\x51\x04\xff\xdc\x26\ +\xe7\x24\xa9\xad\xec\x44\xc6\x58\xca\x23\x56\xd3\xb8\xb6\x96\x0c\ +\xeb\x2e\xf7\xb9\x88\xb1\x0e\x41\x4b\x2b\x3a\x1d\xc9\x6e\xd6\xc8\ +\xd8\xd7\x8f\xe4\xe4\xdf\xae\x3c\xc3\x29\x52\xac\xea\xa7\x66\x43\ +\xd4\x0b\x20\x57\x23\x4b\x21\x6c\x16\x72\x32\xec\x96\x3c\x17\x95\ +\x56\x9b\x2d\x36\xd3\x6e\xd0\x92\xa7\x49\x9d\xc5\xd2\x3b\x21\x49\ +\xf7\x37\x0b\x2c\xe4\x4e\xbb\x95\x4c\xa1\x9c\xac\x9a\x91\xa2\x75\ +\xa9\x81\x93\x1a\x96\x3c\xe7\xa7\xfe\xf4\x67\x7b\xe9\xe2\xdf\xca\ +\x05\xbe\x97\x87\x4f\x3a\x99\xd1\x55\xa8\xaf\xf1\xd5\x8d\xa6\x6f\ +\x6f\x65\xed\xd6\x82\x09\xa9\x07\xab\x21\x39\xb7\xac\xd7\xbe\x0f\ +\xd0\x85\xc6\x99\xed\x4e\x79\xce\x6b\xa3\x83\x96\x6e\x14\xb8\xc9\ +\x4c\x12\x49\xbb\xf9\x8b\xe1\xe5\xd9\x9f\x92\xd2\x6b\xe7\x24\xdb\ +\xec\x35\xa4\x83\xf0\x72\x27\x42\x49\x15\x1a\xac\x3e\xb3\x47\xd2\ +\x7f\xeb\x19\xb8\xc8\xec\x10\xb9\x60\xc9\x94\xed\x3c\x0a\x68\x3d\ +\x68\xe9\x44\x96\xa7\xd7\xe4\x19\x6e\x5b\xad\x0e\x24\xcf\x05\x4a\ +\x32\x5b\x79\x3f\x53\x79\x02\x16\x59\xde\xa3\xf1\xf3\x50\x41\x7d\ +\x48\xb6\xd9\xef\xab\x8c\xde\x19\x26\x92\x59\x7c\x79\xf5\x6a\xd0\ +\xd2\x6a\x46\x37\xaf\x02\xea\x59\x3b\x6a\xae\x1f\x9d\xbb\x21\x92\ +\x2c\x4d\xbb\xb5\x80\xad\xbe\x56\xb3\xb5\xb1\xda\xd2\xed\x4c\x4b\ +\xa7\x37\x78\x23\x2f\x36\xab\x2d\xf6\x28\x53\x71\x4b\xc8\xb7\x88\ +\x64\xbb\xd9\x81\x66\x17\x81\x45\x34\x3f\x09\x56\xd1\x3c\xf8\x59\ +\xaf\xa0\x45\x66\x64\x2d\x97\xb6\xcc\x5b\xa4\xdb\x4e\xc1\x75\x2b\ +\x1f\xd8\xcd\x12\xe0\x34\x4b\xd9\x2e\x62\xf5\x63\x4e\x82\x87\xd5\ +\x52\xf0\x32\x23\x2e\xcf\x70\x4c\x9e\x4c\x49\xb3\xe5\x3d\xe2\xf4\ +\xfb\x43\x4d\x9e\xa7\xdd\x61\xc2\x4e\x6b\xb5\xab\xb1\x64\x98\x7a\ +\x51\x3b\x05\xf2\x79\x85\x48\xce\x93\xbd\x12\x68\xf6\xaa\x01\x74\ +\xbe\x51\xaa\xdc\x9c\x74\x33\x68\x2c\xa1\x8b\xfd\x87\xda\x09\x5a\ +\x5a\xa9\x91\xd8\xe8\xa0\xa5\x93\xd1\xa4\x14\x36\xad\xa6\x8a\xfa\ +\x30\xcc\x6a\xda\xed\x8f\xb3\xda\x81\xd0\xca\x42\x7b\x51\x93\x6d\ +\x58\x8f\x2e\x9d\x11\x56\x9f\x4d\x15\x23\xdf\xf2\x0d\xdd\x0e\x2a\ +\x36\x43\xd0\x92\xe7\xd8\xc8\x13\x24\xcb\x8c\x8f\xd5\x7e\xff\x05\ +\xe4\x0f\x5a\x9a\xc9\x13\x68\x48\x8d\x55\xb3\xcf\x54\xde\xed\x6a\ +\x87\x34\x3a\xf4\xf9\xd3\xc4\x65\x78\xad\xd5\x8b\x7c\x15\xbd\x39\ +\x4c\xb2\x52\xfd\x41\x23\x83\xe4\x77\xd8\x38\xd4\x98\x67\xd6\x5a\ +\x09\xc9\xfb\xdf\x4c\x45\xee\xeb\x29\x4f\x5b\x0d\xa0\x3e\x34\x2a\ +\xd7\xe5\x3c\xeb\x60\xc9\xef\xa8\x5b\xc3\xea\x5d\x6d\x98\xd8\x6e\ +\xd0\x92\xd7\x46\x06\x2d\x1b\x75\x32\x90\x4c\xc6\x6a\xba\xd1\xd4\ +\xaf\x95\x34\x73\xb3\xc7\xca\x90\x57\x37\x4f\x28\x79\x7e\x3f\x79\ +\x1b\x0a\xb6\x3a\x0c\xd8\xea\x1d\x79\xaf\xf7\xd1\x68\x16\x20\xb4\ +\x72\x37\xdf\x2c\x68\xc9\x7b\xec\xe6\x79\x5c\xde\x6c\x5e\x9e\xa0\ +\x25\x44\xf7\x82\x96\xbc\x7d\x84\x5a\x91\x37\x90\x5c\x6f\xd2\x37\ +\xa9\x99\x95\x7a\x4f\x49\xd6\x79\x08\xcd\x2f\x5e\x7d\xc8\xdf\x06\ +\xa2\xb1\xb8\xd3\x6f\x8e\xb8\x92\x4e\x9c\xbf\x5a\x7d\x5d\x99\xb9\ +\xb3\xda\xf7\x9b\x91\xa0\x62\x35\x35\xac\xbc\x30\x70\x9e\xd6\x1c\ +\x12\x34\xf6\xf2\x79\x6d\x59\xed\x5c\x3c\x2d\xf2\x47\x52\x9d\x4e\ +\x2f\x6e\xe4\xcc\xa5\xbc\xfc\xda\x8c\x95\xc8\x1d\x5a\x2b\xdb\xd8\ +\xec\xc2\x24\x7d\x35\xf2\xc8\xb3\x1f\x35\x7a\xe3\x2e\x28\xcf\xf1\ +\xd6\xed\xa0\x25\x44\xef\xa6\xf1\x81\xe6\xc7\x86\x45\x6b\xb3\xcd\ +\x56\x93\xa7\x83\x6b\x9e\x9a\x24\x59\xea\x22\x8f\x3c\x01\xf9\x66\ +\x5b\xc3\x67\x3d\x0b\x22\x5b\x91\x67\x31\x5c\x83\xd5\x87\x76\x64\ +\xd8\x6f\xb8\xc9\x73\xb5\xb2\xca\xb5\x45\xb2\x36\x97\xc8\x53\xeb\ +\xd1\x89\xda\x8d\x08\x4b\x3f\xfb\xc3\x58\xfd\xd8\x6e\xdc\xce\x76\ +\x34\x1b\x62\x6c\xd6\xac\x34\x42\x52\xca\xb0\x5a\x96\x5a\x1a\x49\ +\x6e\xa6\x49\x17\x00\xda\x0f\x5a\xf2\xea\x74\x9a\xa8\x95\xe7\xdb\ +\xc8\xf1\x6d\x83\xe6\xfb\xb6\xd5\x2c\x54\xb3\xf7\x1e\xe4\x78\x4c\ +\x2b\x7a\x65\x58\xa4\x95\x20\x39\x2f\xe9\x8d\xd1\xca\x92\x10\xbd\ +\x1a\xb4\x48\x56\x6c\x35\x9d\xce\x14\x34\x0b\x5a\xf2\xec\xd7\x56\ +\x02\x62\xb9\x7b\x5d\x2d\xf0\xea\xc5\x16\x07\x2b\xa9\xa0\x77\x2f\ +\x16\x79\x87\xf5\x9a\x91\x85\x72\x9b\x05\x16\xad\x2e\xb7\xf2\x56\ +\x27\xfd\x57\x56\xe2\x90\x6f\x06\x9f\x4c\x16\x69\x36\xd4\xdb\xcd\ +\xe3\x50\x4a\x2a\x64\xf8\x4a\xce\x19\x72\xd3\xae\xd1\x46\x50\xd9\ +\x4e\xd0\x12\x23\x7f\x35\x73\xa7\xef\x7e\x5a\x5d\x95\x77\xa3\xe4\ +\xf9\x45\xb4\x1a\x14\xac\x77\x10\xd1\x2b\x41\x4b\xb7\xee\x46\x5b\ +\xe9\xae\x5c\xc0\xea\x27\x0a\x29\x62\x5d\x4d\x3b\x9d\x94\xf3\xd8\ +\x88\xdf\x53\xb3\x2c\x61\x9e\x00\xa2\x1b\x5d\x63\xdb\x9d\x95\xb7\ +\x9e\x9a\x15\x44\x6f\xb4\x3c\xc5\xd3\x79\x03\xf8\x08\xcd\xaf\x15\ +\xdd\xac\x45\xda\x8c\xf2\x0c\xf5\xe6\xfd\xec\x74\x6a\xa8\xb7\x55\ +\x55\x74\xb1\x30\xbe\x9d\x8d\x6e\x25\x2a\x96\xc2\xa0\x4e\x04\x10\ +\xad\x4c\x83\x05\x36\x36\x7a\xef\xf4\x85\xb6\x57\x02\x88\x8d\xd0\ +\x0b\x41\x8b\x2c\x36\xb8\xd2\xc9\x7a\x23\x67\x81\xf4\x62\x86\xa1\ +\x1b\xc7\x6b\x37\x6e\x04\xd6\x93\x43\x92\xb2\xef\xd5\x8c\x1d\x50\ +\xef\x54\xba\x9a\x56\x56\xaf\xcf\x73\xde\xe7\x2a\xd7\x4b\x35\xbb\ +\x26\xb7\x72\x5d\x6b\x16\x34\x48\x7d\x4e\x37\xda\x82\x74\xed\xe6\ +\xa1\xdd\xa0\xa5\x95\x31\x72\xe9\xb2\xba\x56\xad\xcc\x55\x97\xbe\ +\x1f\x1b\x25\xcf\xc9\xb3\x17\xc7\xb3\x6f\x26\x11\x5a\x9b\x9e\x5a\ +\x46\x6f\x5e\x70\x7a\xf1\x42\xdd\x8d\x63\x7b\x33\x7f\xa6\x56\x2b\ +\x9a\xec\x25\xdd\x18\xd6\x6b\x36\x0c\xdb\x8b\x41\xf7\x46\x91\x9b\ +\xfc\xd5\xf4\xa1\xb5\xf3\x56\x9e\xd7\xec\xd5\xcf\xcd\xb2\xda\x4d\ +\x0f\xe5\x49\xfb\x09\xe9\x49\xb2\xd6\xd6\xf5\xad\x04\x2d\x52\x0c\ +\xbb\x51\x3a\x7d\x82\xcd\xf3\x58\x83\xce\x8e\x4f\xf6\x6a\xd3\xab\ +\x4e\x31\xe9\x9f\xbc\x77\x7a\x32\x95\xbd\xd7\x6a\x11\xf2\x5c\x08\ +\xd7\xfb\xb3\xb0\x51\xc3\xa3\xbd\x74\xf2\x95\xce\xc3\xbd\xd0\x3f\ +\x26\xaf\x6e\x0d\xeb\x75\x7a\xf6\xdf\x5b\xd5\x46\xdc\x80\xf4\xe2\ +\x4d\xcf\xaa\xda\x0d\x5a\xa4\x91\x5a\x5e\x6b\x6d\x5d\xdf\x87\xd6\ +\x76\xee\x46\x8f\x91\xe6\xb9\x10\xb6\xfa\x21\x6d\x96\xdd\xea\xd5\ +\x29\x94\xbd\xac\x8a\xfc\x33\xae\x90\x3e\x36\x4f\xbf\x9e\xf5\x94\ +\xe7\x38\xaa\x62\x7d\x57\x44\xce\x73\x91\x6e\xf5\x0e\x3b\xcf\xe2\ +\x77\xdd\xba\xf0\xe5\x49\x77\x4b\xb1\xb0\x1c\x1f\x9b\xb1\xb8\x74\ +\x23\x87\xf5\x18\xb4\x6c\x4c\xd6\xe9\xa6\x09\x5a\xf2\x34\xa1\x6a\ +\x7c\x9d\x76\x57\x38\x96\x45\xa2\xf2\x92\x3b\x9c\x8d\x92\x67\x5c\ +\x58\xd6\x58\x69\x45\xb3\xa0\x25\x04\x3f\xfc\xad\xaa\xa1\xb5\x80\ +\x58\x16\x24\xec\xa5\xda\x84\x3c\xbf\xef\xf5\xae\x1b\xf0\x9b\x5d\ +\xad\xc4\x5f\xe9\xb5\x99\xbc\x9f\xa9\x6e\xa9\x62\xe3\x6f\x84\xd6\ +\x03\x87\xf5\x36\xd6\xa6\x0b\x20\x36\xc2\x5a\x22\xbb\x56\x03\x90\ +\x32\x5a\xbb\xab\x6d\xf7\x67\xd6\xf3\x8e\x72\x39\x79\x32\x50\xed\ +\x5c\xf0\xf2\xdc\xdd\x77\x6a\x8d\x8a\x9b\xe5\xc3\x93\x77\xfa\xa0\ +\x4f\x02\x97\xae\xac\xab\xd1\x86\xc6\xe6\x57\xcb\x69\xa7\x5b\xeb\ +\x5a\xe5\x39\x5e\x5b\x99\xbd\xd5\x89\xd7\xa3\xd5\xe5\x5d\x1c\xb4\ +\x15\x0c\x5a\xf2\xe3\x7e\xc8\x61\x2d\x53\x9e\xf2\xb6\xd7\xf6\x95\ +\xd2\xd7\x5c\xc4\xea\x17\x6e\xc9\xcc\xb4\xba\x7d\xb2\x4d\x1b\x25\ +\x40\xf7\x82\x96\x08\xcd\x7b\x6d\x94\x51\x5f\x18\xb1\x1d\xb2\x26\ +\x88\x42\xb2\x6c\xfb\xcd\x20\xcf\x5a\x4c\xcb\x91\x0c\x60\x2d\xfd\ +\xd3\x4e\xf6\xac\x53\x22\xe4\xeb\x3e\x3a\xbf\xc6\xd7\x91\xe3\x2f\ +\xcf\x30\x64\x84\xe6\xc1\x46\x09\xcd\x3f\xaf\x79\x57\xd0\xee\x95\ +\xcc\xd7\x66\xd6\xe9\xac\x9d\x34\x22\x5c\xcd\x66\xa9\xf7\x59\x0f\ +\x79\xf6\x45\x05\x9d\x2d\x03\xd8\x74\x81\xd2\x5a\xe7\x69\x2f\xa0\ +\xbe\x6a\x71\x5e\xb2\x60\x93\x4c\x13\xf5\x53\xc9\xb2\x8e\x47\x3b\ +\x77\x85\x32\xa5\x70\xa3\x48\xeb\xe4\x66\x64\x68\xad\x55\x32\x4e\ +\xbe\xda\x49\x43\xb2\x00\x8b\x68\x2d\x9d\x2d\x6d\xa3\xe5\x22\x73\ +\xb3\x9d\x48\xe6\xd1\xbc\x7b\xe7\x72\xe4\x82\x2a\x17\x55\xbf\x91\ +\x92\x6d\x78\x5c\x37\xd5\xd0\x3c\xa0\x2d\x22\xd9\xae\x76\x16\xa9\ +\x2b\xa6\xcf\x1f\x20\x7f\x70\x90\x67\xe8\x2d\xcf\xb0\x71\x9e\x85\ +\xfb\xd6\x12\xa8\x53\x9d\x04\xde\x9d\x1a\xd6\xcb\x73\x7d\xe1\xef\ +\xad\x2e\x6f\xd0\xb8\xe9\x02\x8d\x4e\x5a\x6b\xd0\x22\x81\x42\x9e\ +\xe5\xe3\x1b\xc9\x8a\xb1\x9d\x32\x8f\xee\x5e\x6c\x03\x24\x27\x50\ +\x99\x99\x24\x1f\x6e\xe9\xe1\x91\xf7\x0e\x64\x2d\x51\xf2\x22\xf2\ +\x2d\x20\xd8\x8f\xe4\x22\x53\x43\x3d\xd8\xf1\xb7\x59\xba\x11\x16\ +\xb0\x31\x43\x07\xbd\xc6\x22\x69\x0e\xd7\xce\x71\xec\xdb\xa8\x56\ +\xf2\x06\xf9\x33\x1b\x21\xea\x2b\x6b\xaf\x76\xf2\x93\xe3\xba\x84\ +\xf6\x6f\x22\x2a\x68\x3e\x3d\x53\x16\xe7\x93\x19\x86\x52\xbb\x25\ +\x81\x74\x9e\xcf\x15\x0b\xd0\x3b\x27\x42\xbe\xc5\x29\xf3\x64\xb4\ +\xf3\x9c\xdf\xdf\x6a\x41\xcb\x5a\xce\x1f\x79\x3a\x3f\xdf\xf4\xb5\ +\x8b\x9d\x38\xc9\xc6\x68\xbe\xce\x41\xb7\x2d\xa0\xfb\xe9\x61\x09\ +\xb2\xd6\x12\x68\xad\x75\xf8\x2a\x42\xfe\x99\x5b\x1a\x9d\x5f\xe4\ +\xed\xad\x4c\x8e\xe3\x6e\x75\xae\xed\xb6\x05\xe4\xcb\x16\x49\xf0\ +\x0d\xd4\xa7\x7d\x37\xb6\xd7\xce\x53\xf8\x9a\x87\x0c\xbd\xe5\x59\ +\x75\xb6\xdd\xf3\x47\x0d\x1c\x1a\xea\xa4\x3c\x41\x4b\x1f\xf2\x05\ +\xbd\x79\x57\x29\xee\x96\x8d\xb8\xb8\xaf\xf5\x73\xd3\xac\x9d\x88\ +\x42\xb2\xff\xdb\xc9\x98\xfa\x64\x8d\xa9\x4d\x57\x60\xde\xa9\x3b\ +\xec\x08\xc9\x9d\xea\x46\x44\x7f\xf3\xd8\x1c\x3b\xbe\x53\xc3\x57\ +\xeb\x11\xa0\xdd\xac\xe4\x38\xde\x8c\xc3\x63\x16\xad\x9f\xc8\xe4\ +\xc2\x22\x43\x5c\x52\xdb\xd3\xa9\xa0\x4d\x16\xce\xeb\xe6\x54\xe4\ +\xb5\x9e\xbc\x69\xa9\x1a\xf2\x75\x52\x5d\x2d\xb8\x97\x12\x80\x66\ +\xaa\x39\x5e\x6b\x25\x79\x8e\xa9\xbc\x85\xde\xad\x68\xb6\xbd\x79\ +\xd6\x02\x5b\x4d\x9e\x9b\x5a\x7f\x48\xba\x55\x21\x92\x15\xb8\x07\ +\xd0\x9d\xfd\xd3\x75\x9d\x1c\x16\x88\x90\xf4\x62\x59\xaf\xfe\x04\ +\x36\x7d\xbd\x5e\x6b\xf6\xb5\x1c\x39\x79\x77\xea\x62\x38\x87\xcd\ +\xf1\xbe\x37\xa3\x18\xc9\x2a\xad\x9b\x71\xff\xd6\xb0\xb1\x75\x5d\ +\xcb\x91\xa1\xb7\x6e\xb4\x0a\xdf\xa8\x1b\xa5\xb7\xba\x3c\xc3\x6d\ +\x05\x00\x23\x48\xee\xfa\x8b\xe9\xff\x8b\x48\x2e\x86\xc3\xc8\x77\ +\x6d\x59\xcb\xb0\x5e\x9e\xdf\x7b\x79\x95\xed\x68\x37\x38\xcf\xf3\ +\xba\x2b\xd5\x72\xe5\x09\x68\xf2\xd6\x67\xf5\x23\x09\x0c\xf3\x8c\ +\x96\xc8\x28\xc1\x50\xfa\x67\xb3\xad\x88\xbe\x44\xa7\x37\xde\x20\ +\x09\x24\x4a\x48\x0e\x98\x6e\xa5\xd9\xa5\x59\xd6\x66\x38\x61\xc9\ +\xc9\xb5\xd3\x77\xef\xd2\x2b\xa4\x0f\xac\x49\xe9\x34\xc9\x8a\x49\ +\x31\xe9\x7a\xf4\x39\x91\xba\x94\xb5\x06\x4b\x72\xa7\x9c\xa7\x80\ +\x75\xbd\x48\x20\x38\x80\xce\x9c\x73\x6a\x48\x32\x2c\x9b\xe1\xf3\ +\xbf\x19\x55\x51\xaf\x77\x5b\x8d\x42\xfb\x43\xd0\x6b\x5d\xd6\x20\ +\xcf\x85\x5d\x23\x09\xa0\x22\xd4\x6f\xa6\x03\xd4\x27\x7b\xcc\xa0\ +\xf5\x63\x28\xcf\x4d\x79\xa1\xe1\x75\xfd\x1a\x42\x00\x98\x6e\xf2\ +\xf3\x32\xd4\x9b\xe7\x75\x0a\x48\xf6\xe3\x4a\x43\xbd\x52\x1f\xf6\ +\x96\xd1\x8d\x37\x23\x05\x78\xb2\x2c\x79\x09\x9d\x09\x5e\x5c\xfa\ +\x9c\x1b\xd5\x16\x3b\x46\xf2\x61\xce\x5b\x1c\x28\xfb\xa1\x9b\x45\ +\x82\x32\x9e\x2f\x29\xfe\xb5\x5e\x5c\xe5\xa2\xc9\xe1\xa7\x44\x94\ +\xfe\x09\x91\xec\xdf\x02\x3a\x3b\x74\x22\xcb\xc7\xcb\x2c\xba\x4e\ +\x91\x20\xa1\xd3\x37\x0f\x52\x53\xd5\x0e\xc9\x8c\x36\xce\x54\x6b\ +\xf5\xf5\x2b\x78\xeb\x15\x6f\xf6\xa2\x79\x24\x77\xe5\xdd\x08\xd8\ +\xe5\x3c\xbe\x16\x79\x66\x3a\x01\x9d\x9f\xf0\x91\xf7\xd8\x5b\x69\ +\xe9\x99\xbc\x4b\xb2\x2c\x20\x7f\x8f\xb2\xc6\xa0\xe8\x2d\xad\x9b\ +\x11\x98\x45\x12\x4d\x2f\xa2\x1e\x11\x86\x68\x7d\xa5\x66\x39\xa9\ +\x6f\xf4\x7a\x42\x40\xbd\x27\x87\xcc\xac\x90\x88\x5d\x0a\xbe\xa4\ +\xd1\xd7\x7a\x6e\xaf\x43\xbd\x63\x67\x80\xfa\x9d\x44\xe0\x6d\x5b\ +\xe3\x07\xdb\x6f\x39\x2e\xfb\xb8\xd3\xdb\xdb\x6c\x98\x22\xef\x45\ +\xba\x8a\xe6\x27\x8a\x6e\xef\x67\x3f\x65\xeb\x1f\xc7\xb2\x8f\x9b\ +\xf1\xef\x84\xfc\x3f\xdd\x24\x41\xb3\x7f\xd7\xdc\x6a\x3b\x81\x6e\ +\x04\x56\x31\x92\xcc\xa3\x9c\x64\x65\x5f\x2a\xef\x8f\x7c\x96\x1a\ +\x8f\xcf\xcd\x58\x6b\xb4\x59\xc9\x90\xf6\x20\x3a\x1b\xb8\x54\xd1\ +\x99\x3a\x24\xb9\x89\xed\x54\x43\xcd\xbc\xe4\x58\xec\x76\xf6\xa2\ +\x0a\x4e\xa6\x58\xd6\x7a\xa5\x8d\xe4\x8e\x15\x58\x9a\xb6\x6a\x3c\ +\x51\x01\xf5\x8b\x69\x2b\x4b\xa0\xaf\xb7\xf5\xb8\xe8\xb4\x43\xb6\ +\x6b\xb9\x21\x06\x09\x5c\xd6\x6b\x9f\x76\xaa\x26\xa4\xd7\xf6\xb5\ +\x7f\x2c\x0b\x39\x96\x81\xa5\x17\xdd\x6e\xae\x87\x93\x97\x9c\xdc\ +\xe5\xf7\x21\xe3\xea\xcb\x7d\xfe\xfc\x60\x41\xfe\x74\x8b\xc5\xcd\ +\xd3\x1e\x7f\xb3\xb2\x48\x32\x76\x7d\x58\x7b\xc6\x5c\x6e\x62\x3b\ +\x59\x2b\x26\x37\xc4\xeb\x3d\x0c\x2a\xad\x27\xba\x3d\xcb\x70\x11\ +\xc9\xb9\xaf\x57\xba\x6f\xf7\x84\x8d\x18\xeb\x92\x6c\x44\x2f\x5d\ +\x88\x6e\x06\x1b\x7d\xf1\x7c\x2b\xdb\x4c\x19\x00\x07\x0e\xaf\x50\ +\x6b\x16\x91\x64\xed\xca\x48\x86\x5a\x5a\x09\x12\x0c\xea\xe5\x02\ +\x9d\x26\xd9\xa0\x01\xac\xef\xfa\x5a\xeb\xd9\x1e\x41\x7a\x6d\x49\ +\xc1\x73\xa7\x6c\xf4\x1a\x7d\x6d\x7b\x4b\x15\xe8\x10\x11\xe5\x24\ +\x17\x9e\xbc\x8f\xbd\xd9\xc9\x3a\x5d\x8b\xa8\x0f\xed\xf9\x19\x73\ +\x21\x19\xf2\x6e\x0c\x39\x2f\xc7\xa0\x5e\xbf\xd5\xca\x72\x1c\x6b\ +\xbd\x69\x8e\x90\x14\xf2\xb6\x12\xc8\xe5\x59\x27\x6c\x39\x16\xc9\ +\xb1\xba\x88\xfa\x4c\xad\x76\x7a\x29\xc9\xef\x44\x86\x7c\xdb\x21\ +\x19\xb3\x66\xaf\xd3\x35\x4c\x39\xd5\x8d\x60\xf5\x03\x2f\x46\x52\ +\x48\x48\x44\xd4\x0b\x9a\x0d\x51\xc4\xd8\xf8\x05\x64\xd7\xdb\x72\ +\xc3\x9f\x8d\x43\x9f\xdd\xc8\xf2\x4b\x53\x46\x3f\x88\xeb\xf6\xeb\ +\x4a\xfd\xa2\xc2\xf2\xa5\x16\x12\x24\xc9\x6b\xbf\x25\xb2\xed\xcc\ +\xb4\x10\x11\x6d\x4e\x73\x1b\xbd\x01\x3d\x68\xa3\x86\x3f\xbb\x5d\ +\x03\xb6\x9c\x9b\xb2\xcc\xa2\x57\xfa\x38\x10\x11\x11\x11\xad\x8a\ +\x41\x0b\x11\x11\x11\x6d\x0a\x0c\x5a\x88\x88\x88\x68\x53\x60\xd0\ +\x42\x44\x44\x44\x9b\x02\x67\x0f\xd5\x35\x5b\x40\x8b\xfd\x2d\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x29\xea\x08\x91\x00\x00\x01\x7d\x49\x44\ +\x41\x54\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\x88\ +\x88\x88\x88\x88\x88\x88\x68\x13\xf9\xff\x01\xca\x36\xd2\x5e\x97\ +\x28\x24\x4e\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\ +\x00\x00\x01\xca\ +\x3c\ +\x73\x76\x67\x20\x78\x6d\x6c\x6e\x73\x3d\x22\x68\x74\x74\x70\x3a\ +\x2f\x2f\x77\x77\x77\x2e\x77\x33\x2e\x6f\x72\x67\x2f\x32\x30\x30\ +\x30\x2f\x73\x76\x67\x22\x20\x76\x69\x65\x77\x42\x6f\x78\x3d\x22\ +\x30\x20\x30\x20\x35\x31\x32\x20\x35\x31\x32\x22\x3e\x3c\x70\x61\ +\x74\x68\x20\x64\x3d\x22\x4d\x34\x36\x34\x20\x33\x32\x48\x34\x38\ +\x43\x32\x31\x2e\x34\x39\x20\x33\x32\x20\x30\x20\x35\x33\x2e\x34\ +\x39\x20\x30\x20\x38\x30\x76\x33\x35\x32\x63\x30\x20\x32\x36\x2e\ +\x35\x31\x20\x32\x31\x2e\x34\x39\x20\x34\x38\x20\x34\x38\x20\x34\ +\x38\x68\x34\x31\x36\x63\x32\x36\x2e\x35\x31\x20\x30\x20\x34\x38\ +\x2d\x32\x31\x2e\x34\x39\x20\x34\x38\x2d\x34\x38\x56\x38\x30\x63\ +\x30\x2d\x32\x36\x2e\x35\x31\x2d\x32\x31\x2e\x34\x39\x2d\x34\x38\ +\x2d\x34\x38\x2d\x34\x38\x7a\x4d\x32\x32\x34\x20\x34\x31\x36\x48\ +\x36\x34\x76\x2d\x39\x36\x68\x31\x36\x30\x76\x39\x36\x7a\x6d\x30\ +\x2d\x31\x36\x30\x48\x36\x34\x76\x2d\x39\x36\x68\x31\x36\x30\x76\ +\x39\x36\x7a\x6d\x32\x32\x34\x20\x31\x36\x30\x48\x32\x38\x38\x76\ +\x2d\x39\x36\x68\x31\x36\x30\x76\x39\x36\x7a\x6d\x30\x2d\x31\x36\ +\x30\x48\x32\x38\x38\x76\x2d\x39\x36\x68\x31\x36\x30\x76\x39\x36\ +\x7a\x22\x2f\x3e\x3c\x2f\x73\x76\x67\x3e\x0a\x3c\x21\x2d\x2d\x0a\ +\x46\x6f\x6e\x74\x20\x41\x77\x65\x73\x6f\x6d\x65\x20\x46\x72\x65\ +\x65\x20\x35\x2e\x32\x2e\x30\x20\x62\x79\x20\x40\x66\x6f\x6e\x74\ +\x61\x77\x65\x73\x6f\x6d\x65\x20\x2d\x20\x68\x74\x74\x70\x73\x3a\ +\x2f\x2f\x66\x6f\x6e\x74\x61\x77\x65\x73\x6f\x6d\x65\x2e\x63\x6f\ +\x6d\x0a\x4c\x69\x63\x65\x6e\x73\x65\x20\x2d\x20\x68\x74\x74\x70\ +\x73\x3a\x2f\x2f\x66\x6f\x6e\x74\x61\x77\x65\x73\x6f\x6d\x65\x2e\ +\x63\x6f\x6d\x2f\x6c\x69\x63\x65\x6e\x73\x65\x20\x28\x49\x63\x6f\ +\x6e\x73\x3a\x20\x43\x43\x20\x42\x59\x20\x34\x2e\x30\x2c\x20\x46\ +\x6f\x6e\x74\x73\x3a\x20\x53\x49\x4c\x20\x4f\x46\x4c\x20\x31\x2e\ +\x31\x2c\x20\x43\x6f\x64\x65\x3a\x20\x4d\x49\x54\x20\x4c\x69\x63\ +\x65\x6e\x73\x65\x29\x0a\x2d\x2d\x3e\ +\x00\x00\x12\xa0\ +\x00\ +\x00\x01\x00\x01\x00\x00\x00\x00\x00\x01\x00\x20\x00\x8a\x12\x00\ +\x00\x16\x00\x00\x00\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\ +\x0d\x49\x48\x44\x52\x00\x00\x02\x00\x00\x00\x02\x00\x08\x06\x00\ +\x00\x00\xf4\x78\xd4\xfa\x00\x00\x12\x51\x49\x44\x41\x54\x78\x9c\ +\xed\xdd\x6b\x6c\xdd\x67\x61\xc7\xf1\xe7\xd8\xc7\xce\xfd\xde\x7b\ +\x28\xf4\x9e\x36\x1d\x0b\x50\x6e\x1d\x30\x14\x46\xe9\xba\x42\xc5\ +\x60\xd3\x06\x0c\x36\xa1\x89\x96\x6d\x65\x1a\x08\x04\x0c\x06\x93\ +\x98\xf6\x62\xd3\x98\x98\x34\x8a\x36\x0d\x69\x93\x60\x6c\x63\x2d\ +\x42\xdd\x04\x5d\xe9\x45\x29\xb4\xa4\x4d\x4b\x4a\xd2\x86\x34\x4d\ +\xda\xb4\x49\xeb\xc6\x4d\x73\xb3\x13\xfb\x5c\xf6\x66\x68\x0a\x76\ +\x68\xe2\xd8\xe7\x49\xf2\xfb\x7c\xde\x55\x3d\xe7\xff\xfc\xa4\xb8\ +\xee\xd7\xc7\xff\x73\xd2\x28\x00\xf4\xc4\xad\x77\xdc\xb1\xb5\x94\ +\x72\x5e\xed\x1d\x4c\xf0\xc0\xb5\xab\x57\xbf\xba\xf6\x88\x5e\xeb\ +\xab\x3d\x00\x00\xe8\x3d\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\ +\x00\x10\x48\x00\x00\x40\xa0\xe6\x86\xef\x7c\xe5\x75\xa5\xaf\x7d\ +\x61\xed\x21\x4c\x4d\xb7\xd1\xe8\xfc\xc2\x5b\x3f\xfc\xaf\xb5\x77\ +\x00\x70\x72\x69\x76\xfb\x3b\x37\x94\x6e\xe3\xf7\x6a\x0f\x61\x8a\ +\xba\xa5\x55\x4a\x11\x00\x00\x1c\x13\xbf\x02\x00\x80\x40\x02\x00\ +\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\ +\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\ +\xcd\xda\x03\x00\x12\x2c\x5b\xb6\xec\xb2\x75\x6b\xd7\x2e\x68\x36\ +\x7d\xdb\x3d\xd1\x8c\x8d\x8f\x9f\x71\xcd\x3b\xde\x71\x63\x4f\xce\ +\x3a\x78\x70\xec\xf6\xdb\x6e\xbb\xb9\x94\x32\xd4\x8b\xf3\x7e\x1e\ +\x5f\x89\x00\x3d\x70\xee\xf9\xe7\x9f\xbf\x68\xf1\xe2\x65\xcb\x4e\ +\x3b\xad\xf6\x14\x26\x3a\xf7\xa2\x8b\x2f\xfe\x52\x2f\x0e\xda\xb2\ +\x79\xf3\x33\xb7\xdf\x76\xdb\x77\x7a\x71\xd6\x8b\x11\x00\x00\x3d\ +\x32\x77\xde\xbc\xb2\x78\xc9\x92\xda\x33\xa8\x68\x70\xd6\xac\x6e\ +\xed\x0d\x3f\xe5\x1e\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\ +\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\ +\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\xe4\x93\x00\x01\x7a\x60\ +\xd7\xae\x5d\x07\x1e\xdd\xb0\x61\x64\xf3\xa6\x4d\x73\x6b\x6f\xe1\ +\x70\xad\x56\xeb\x85\x67\x77\xec\xb8\xb3\x17\x67\x8d\x8c\x8e\x8e\ +\xf4\xe2\x9c\xa3\x21\x00\x00\x7a\xe0\xa9\x6d\xdb\xee\x5a\x7d\xd5\ +\x55\x43\xa5\x94\xf3\x6a\x6f\x61\x82\x2d\xd7\xae\x5e\xfd\xeb\xb5\ +\x47\xf4\x9a\x5f\x01\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\ +\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\ +\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\ +\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\ +\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\ +\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\ +\x81\x04\x00\x00\x04\x6a\xde\xfd\xc3\x1f\x9f\xb5\x74\xe1\x82\xda\ +\x3b\x98\xb2\x6e\xe3\x0d\xaf\xbe\xec\xd7\x6a\xaf\x38\x92\x7d\x7b\ +\x0f\x1d\x5a\xff\x93\xc7\x7f\x50\x4a\x19\xa9\xbd\x05\x80\xff\xd7\ +\x1c\x7a\x6e\xcf\xca\xf3\x97\x9f\x59\x7b\x07\x53\xd7\xff\x99\x1b\ +\xdf\x73\x6b\xed\x11\x47\x72\xff\x8f\x36\xdf\xbf\xfe\x6f\x1e\x7f\ +\x5b\x11\x00\x00\x27\x94\x66\xa3\x51\xca\xb9\xe7\x9c\x5e\x7b\x07\ +\xa7\xa8\xf5\x8f\x6e\xeb\xd4\xde\x00\xc0\x44\xee\x01\x00\x80\x40\ +\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\ +\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\ +\x80\x40\x02\x00\x00\x02\x35\x6b\x0f\x00\x08\x31\x67\xff\xbe\x7d\ +\x7d\x8d\x3e\x3f\x77\x9d\x68\x3a\xed\x76\x7f\x29\x65\xd1\x34\x5d\ +\x6e\xcf\x34\x5d\x67\xc6\x09\x00\x80\x1e\x58\xb1\x62\xc5\x95\x3f\ +\x7a\xe8\xa1\x33\x67\x0d\x0e\xd6\x9e\xc2\xcf\x68\x77\x3a\x17\x7f\ +\xec\x93\x9f\xfc\xef\xe3\xbd\xce\xc3\x0f\x3f\x7c\xff\x77\x6f\xbd\ +\xf5\x23\xd3\xb1\xa9\x17\x04\x00\x40\x0f\xcc\x59\xb0\x60\xf6\x05\ +\x17\x5e\x38\xeb\xec\x73\xce\xa9\x3d\x85\x89\xe6\x95\x52\xae\x3c\ +\xde\x8b\xec\xd8\xb9\x73\xc7\x34\x6c\xe9\x19\xaf\x45\x01\x40\x20\ +\x01\x00\x00\x81\x04\x00\x00\x04\x72\x0f\x00\x51\x6e\xfe\x87\xdb\ +\x3f\xdf\x68\x34\xde\x57\x7b\x07\x93\xda\xf4\xce\xdf\x7f\xcb\xdb\ +\x6b\x8f\x80\x14\x02\x80\x28\x7d\x8d\xc6\x19\xdd\x52\x2e\xaa\xbd\ +\x83\x49\x1d\xac\x3d\x00\x92\xf8\x15\x00\x00\x04\x12\x00\x00\x10\ +\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x6a\x8e\x8d\ +\xb7\x0e\xde\xf7\xd0\xa6\xda\x3b\x98\xba\xee\xfe\x03\xa3\x3f\xae\ +\x3d\xe2\x48\x9e\xda\xb9\x6b\x67\xed\x0d\x00\x4c\xd4\xfc\xe5\xd7\ +\x5e\xbe\x6e\xce\xec\x59\x97\xd4\x1e\xc2\x94\xb5\x7f\xf9\x37\x3f\ +\xf1\xd6\xda\x23\x5e\xc4\xbe\xda\x03\x00\x38\x5c\x73\xf9\xd9\xa7\ +\x1d\x2c\xdd\xda\x33\x38\x4e\x43\xb5\x07\x00\x70\x72\x71\x0f\x00\ +\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\ +\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\ +\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\ +\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\ +\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\ +\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\ +\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\ +\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\ +\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\ +\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\ +\x00\x00\x40\xa0\x66\xed\x01\xd0\x43\x73\x36\x3d\xbe\x71\xd1\xfc\ +\x79\x0b\x6b\xef\x60\x12\xed\xd6\xf8\x60\x29\xe5\xe2\xe3\xbc\xcc\ +\xb6\x52\xca\xf8\xf1\xaf\x81\x53\x9f\x00\x20\xc9\xa2\xe7\x9e\x1f\ +\x7a\x5b\x7f\xbf\x2f\xfb\x13\x51\xb7\xdb\xbd\xe8\xaf\xfe\xf4\xef\ +\xef\x9f\xea\xf3\x37\x6e\x7e\xf8\xfe\xaf\xfe\xdb\x97\xdf\x59\x04\ +\x00\x1c\x15\xdf\x09\x89\x32\x7f\xee\x82\xfe\x0b\x5f\x76\x49\xed\ +\x19\x4c\xae\xaf\x94\x32\xe5\x97\x67\x9e\x7c\x7a\xeb\xc0\x34\x6e\ +\x81\x53\x9e\x7b\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\ +\x09\x00\x00\x08\x24\x00\x00\x20\x90\x77\x01\x00\xf4\xc0\xbe\xdd\ +\xbb\x47\x37\x6f\xda\x74\xf0\x89\xad\x5b\x67\xd7\xde\xc2\xe1\xda\ +\xed\xf6\xde\xdd\xc3\xc3\x3f\x3c\xde\xeb\x3c\xb3\x63\xc7\x13\xd3\ +\xb1\xa7\x57\x04\x00\x40\x0f\x6c\xd9\xb2\x65\xcd\x6b\xaf\xbc\xf2\ +\xd9\xbe\x46\xe3\x65\xb5\xb7\x70\xb8\x4e\xb7\xbb\xe5\xdd\xd7\x5c\ +\x73\xdd\x34\x5c\xaa\x3b\x0d\xd7\xe8\x19\x01\x00\xd0\x1b\xe3\xb3\ +\x67\xcf\x3e\xa9\xfe\x07\x11\xa4\x53\x4a\x19\xad\x3d\xa2\xd7\x04\ +\x00\x51\x86\x86\x9f\xd9\x7d\xff\xfa\x1f\x2c\xa9\xbd\x83\x89\xda\ +\x9d\xce\x81\xbd\xfb\x5e\x78\x60\xaa\xcf\xdf\xbe\xf3\x89\x6d\xd3\ +\x38\x07\x4e\x79\x02\x80\x24\xcf\xbd\xfe\x55\x6f\xfa\xde\x40\x73\ +\xe0\x82\xda\x43\x98\xa8\xd3\xe9\x3e\xf1\xde\x1b\xdf\x7e\xed\x71\ +\x5e\xe6\xc0\xb4\x8c\x81\x00\x02\x80\x24\xed\x85\xf3\x16\x8e\x7b\ +\x0d\xf6\x84\xd5\x29\xa5\xec\xaf\x3d\x02\x52\x78\x1b\x20\x00\x04\ +\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\ +\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\ +\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\ +\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\ +\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\ +\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\ +\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\xa8\xf9\xad\xdb\xee\xbb\ +\x64\xd9\xa2\xf9\xb5\x77\x30\x75\x7d\x1f\x78\xd7\x5b\x3e\x7f\xac\ +\x4f\x6a\x75\x3a\xad\xaf\xdd\x72\xe7\x3f\x97\x52\x9e\x9c\xfe\x49\ +\x00\x9c\xe8\x9a\xad\xf1\xd6\x4b\x56\x5d\x76\x41\xed\x1d\x4c\x5d\ +\xdf\xaa\xcb\x2e\xf8\xdc\xb1\x3e\xe9\xb1\x27\x76\x1e\xf8\xda\x2d\ +\x77\xfe\xfb\x4c\x0c\x02\xe0\xc4\xd7\x2c\xa5\x94\x05\xf3\xe7\xd4\ +\xde\x41\x8f\x0d\x0e\x34\x6b\x4f\x00\xa0\x22\xf7\x00\x00\x40\x20\ +\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\ +\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\ +\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\ +\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\xa8\ +\x59\x7b\x00\xf4\x50\xff\xee\xbd\xbb\x07\x07\x07\x66\xd5\xde\xc1\ +\x24\xba\xdd\x76\x5f\x29\x65\xe1\x34\x5f\xb6\x5d\x4a\x39\x30\xcd\ +\xd7\x84\x53\x82\x00\x20\xc9\xe9\x6b\xd7\xdf\xbb\x7a\xe9\xa2\xa5\ +\xb5\x77\x30\x89\x4e\xbb\x7d\xde\x47\x3e\xf8\x89\x5b\xa7\xed\x7a\ +\x9d\x4e\x63\xfd\x23\xeb\x6e\xb9\xfb\xbe\xef\xfd\xf5\x74\x5d\x13\ +\x4e\x25\x02\x80\x28\x67\x2c\x3d\x63\xc9\xaa\x95\x57\xd4\x9e\xc1\ +\xe4\xe6\x96\x52\xde\x38\x5d\x17\x3b\x78\x68\xb4\x3c\xb5\x73\xfb\ +\x3d\xd3\x75\x3d\x38\xd5\xb8\x07\x00\x00\x02\x09\x00\x00\x08\x24\ +\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\ +\xe4\x6d\x80\x00\xbd\xb1\x64\xe7\x8e\x1d\xcd\x66\xd3\xb7\xdd\x13\ +\xcd\xf8\xf8\xf8\x60\x29\xe5\xa5\x3d\x38\xea\xc9\x1e\x9c\x71\xd4\ +\x7c\x25\x02\xf4\xc0\xaa\x55\xab\x5e\xb3\xf3\xe9\xa7\xcf\x9a\x3b\ +\x77\x6e\xed\x29\xfc\x8c\x6e\xb7\x7b\xe9\x5f\x7e\xf1\x8b\x6b\x66\ +\xf2\x8c\xb5\xf7\xde\x7b\xf7\x7f\x7e\xe3\x1b\xef\x2f\xa5\x74\x67\ +\xf2\x9c\x63\x21\x00\x00\x7a\xa0\x31\x30\xd0\x3c\x7b\xf9\xf2\xe6\ +\xd9\xe7\x9c\x53\x7b\x0a\x13\x0d\x94\x52\xce\x9d\xc9\x03\x36\xac\ +\x5f\xbf\x60\x26\xaf\x3f\x15\xee\x01\x00\x80\x40\x02\x00\x00\x02\ +\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\ +\x02\x35\x4b\x29\x65\xdf\xfe\xd1\xda\x3b\xe8\xb1\xb1\xf1\x56\xed\ +\x09\x00\x54\xd4\x1c\x1c\x68\x3e\xf5\xa3\x47\x1e\xef\xc5\x27\x20\ +\x31\x23\x1a\x9d\x7b\x1e\xd8\xf8\x85\x63\x7d\x56\xbb\xdd\x69\x95\ +\x52\x94\x1f\x40\xa8\xe6\x3b\xae\x7a\xdd\x4f\x4a\xb7\xfc\x52\xed\ +\x21\x4c\x59\xe7\x86\x4f\xff\xdd\xe7\x6a\x8f\x00\xe0\xe4\xe2\x1e\ +\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\ +\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\ +\x02\x35\x6b\x0f\x00\x48\xb1\x6f\xef\xde\xd2\xd7\xe7\xe7\x2e\x4e\ +\x0c\x02\x00\xa0\x07\xb6\x6e\xde\xbc\x69\x7c\x7c\x7c\x68\xf7\xf3\ +\xcf\x9f\x51\x7b\x0b\x87\x1b\x3b\x74\xe8\xf1\x6f\xdf\x7c\xf3\x27\ +\x66\xf2\x8c\xa1\x9d\x3b\xf7\x95\x52\xba\x33\x79\xc6\xb1\x12\x00\ +\x00\x3d\xb0\x67\xcf\x9e\x2d\x97\xbf\xfc\xe5\x23\xb5\x77\x30\xa9\ +\xdd\x9f\xfa\xe8\x47\xbf\x59\x7b\x44\xaf\x79\x2d\x0a\x00\x02\x09\ +\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\ +\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\ +\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\ +\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\ +\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\ +\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\ +\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\ +\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\ +\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\ +\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\ +\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\ +\x20\x50\xf3\xeb\xb7\xdc\xf9\x8a\x25\x8b\xe6\xd7\xde\xc1\xd4\xf5\ +\x7f\xe8\xbd\xbf\xfa\xf5\x9f\xf7\x80\x5b\xef\x5a\xf7\xa5\xa7\x9f\ +\x1e\xfa\x41\xaf\x06\x01\x70\xe2\x6b\x0e\x0e\x0e\x2c\xbd\xfa\xcd\ +\x57\xd4\xde\xc1\xd4\x35\xae\x7e\xf3\x15\xbf\x7d\xa4\x7f\xb9\x7d\ +\xe7\xae\xf2\xc0\x86\xc7\xbe\xfa\xf4\xd3\x43\xbd\xdc\x04\xc0\x09\ +\xae\x59\x4a\x29\x8d\x46\xa3\xf6\x0e\x00\xa0\x87\xdc\x03\x00\x00\ +\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\ +\x00\x81\x9a\xb5\x07\x40\x2f\x3d\xbb\x6b\xe7\xf0\x7d\x0f\xdd\xb3\ +\xa4\xf6\x0e\x26\xea\x74\xda\xfb\x77\xbf\xf0\xfc\xbd\xd3\x76\xbd\ +\xd2\x6d\x3c\x37\xfc\xec\xce\xe9\xba\x1e\x9c\x6a\x04\x00\x49\x86\ +\xde\xf8\x9a\xd5\x77\x34\xfb\x9b\x17\xd5\x1e\xc2\x44\xdd\x4e\xe7\ +\xc9\xdf\xfa\xa3\x6b\xaf\x9b\xe6\xcb\x76\xa6\xf9\x7a\x70\xca\x10\ +\x00\x24\xe9\xcc\x9b\x33\xaf\xd5\xad\xbd\x82\x23\xe9\x94\x52\x46\ +\x6b\x8f\x80\x14\xee\x01\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\ +\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\ +\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x35\ +\xc7\xc6\x5b\x23\x6b\xd6\x6e\xa8\xbd\x83\xa9\xeb\xee\xde\x7b\xe0\ +\x88\x7f\x81\xca\xc1\x43\x87\xfa\x0f\x1c\x38\x38\xd6\xcb\x41\x00\ +\x9c\xf8\x9a\x57\xbd\xe9\x15\xeb\x66\x0f\x0e\x5e\x5a\x7b\x08\x53\ +\xd6\x7e\xfd\x3b\x3f\x7a\xcd\x8b\x3c\x46\x00\x00\x70\x98\xe6\x69\ +\x4b\x17\x8d\x15\x7f\x3b\xca\xc9\x6e\x4f\xed\x01\xc0\xa4\x66\x95\ +\x52\xce\xff\xe9\x3f\x6c\xdb\xba\x75\xa0\xd9\xdf\x5f\x71\x0e\x93\ +\x19\x1b\x1b\x9b\x5d\x4a\x89\xfb\x41\xd8\xdf\x06\x08\x30\x73\xe6\ +\xdc\x70\xe3\x8d\xff\x78\xe9\xe5\x97\xbf\xb2\x94\x52\x5a\xad\xd6\ +\xec\x76\xab\x55\x7b\x13\x3f\xa3\xdb\xed\x5e\xf6\xb7\x37\xdd\xf4\ +\x40\xed\x1d\xbd\xb4\xe6\xae\xbb\x6e\x15\x00\x00\x33\x68\xee\xbc\ +\x79\xfd\x17\xaf\x58\x31\xb7\xf6\x0e\x7e\xae\xbe\x52\x4a\xd4\x9f\ +\xd1\xbd\x6b\xd6\x34\xbd\x0b\x00\x00\x02\x09\x00\x00\x08\xe4\x57\ +\x00\x00\x33\x68\x6c\x6c\xac\xef\xc9\x27\x9e\xa8\x3d\x03\x26\x10\ +\x00\x00\x33\xe7\xe0\x3f\xdd\x74\xd3\x87\xe7\xcc\x99\xd3\x5f\x4a\ +\x29\x9f\xfd\xc2\x17\xbe\xd5\x1c\x18\x38\xbb\xf6\x28\x0e\x37\x36\ +\x36\xf6\xc8\x5f\x7c\xf6\xb3\xbf\x5b\x7b\x47\x2f\x8d\x8e\x8e\xb6\ +\x04\x00\xc0\xcc\x39\x38\x32\x32\xb2\x6e\x64\x64\xa4\x94\x52\xca\ +\xc5\x97\x5e\x7a\xa8\xf2\x1e\x26\x37\x32\x3c\x3c\xbc\xb6\xf6\x88\ +\x5e\x73\x0f\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\ +\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\ +\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\ +\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\ +\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\ +\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\ +\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\ +\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\ +\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\ +\x00\x10\xa8\x79\xc7\xf7\xd7\x9f\xb3\x74\xf1\x82\xda\x3b\x98\xa2\ +\x6e\xb7\xdb\xf7\xd6\x37\xbd\xf2\xdd\x35\x37\x0c\x0f\xef\x1d\x79\ +\x70\xe3\x96\x3b\x4b\x29\xa3\x35\x77\x00\x70\xf4\x9a\xc3\xbb\xf7\ +\x5d\x7a\xc9\x05\xcb\x6b\xef\x60\xea\xfa\x3e\x7e\xfd\xbb\xff\xa3\ +\xe6\x80\xef\xaf\xdd\x78\xef\x83\x1b\xb7\xdc\x53\x04\x00\xc0\x49\ +\xa3\xd9\x68\x94\xb2\xfc\xcc\x65\xb5\x77\x70\x12\x1b\x18\xe8\xef\ +\xd4\xde\x00\xc0\xb1\x69\x96\x52\xca\xa1\xb1\xf1\xda\x3b\x00\x80\ +\x1e\x6a\x76\xbb\x65\x68\xcd\xda\x8d\x2f\xad\x3d\x84\xa9\xea\x76\ +\xd7\x3f\xb2\xf5\xcb\x35\x17\x3c\x37\xfc\xc2\x50\x29\xc5\xab\x00\ +\x00\x27\x91\xe6\x6f\x5c\xfb\x86\x1f\x97\x6e\x79\x75\xed\x21\x4c\ +\x59\xfb\x8f\x3f\xff\x95\x3f\xac\x3d\x02\x80\x93\x8b\xb7\x01\x02\ +\x40\x20\x01\x00\x00\x81\x9a\xb5\x07\x00\xa4\xe8\x2b\x65\x75\xab\ +\xaf\x6f\xa0\xf6\x0e\x0e\x37\x58\xca\xc1\xda\x1b\x6a\x10\x00\x24\ +\x19\x18\x1a\x1e\x9a\x3d\x7b\xd6\xec\xda\x3b\x98\x44\xa7\xd3\xee\ +\x2f\xa5\xd4\x78\x4f\xf2\x70\xaf\x0e\xba\x66\xf5\xea\x6d\xbd\x3a\ +\x0b\x5e\x8c\x00\x20\xc9\xb2\x87\x1f\x5d\xf7\x2b\x4b\x97\x9c\x5e\ +\x7b\x07\x93\xe9\x74\xce\xfb\xf8\xf5\x7f\xf6\xdd\x5e\x1e\xb9\x61\ +\xd3\xc3\xeb\xfe\xeb\xce\x9b\xaf\x2f\xde\xc5\x42\x20\x01\x40\x94\ +\x65\x4b\x4e\x5f\xb0\x6a\xe5\x15\xb5\x67\x30\xb9\x39\xa5\x94\x57\ +\xf5\xf2\xc0\x1d\x43\x4f\x3d\xd5\xcb\xf3\xe0\x44\xe2\x26\x40\x00\ +\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\ +\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\xf9\ +\x20\x20\xa2\xec\xdd\xbb\xe7\xd0\xa6\x2d\x1b\x6b\xcf\x60\x12\xdd\ +\x6e\x77\x7c\xbc\x35\xfe\x4c\x2f\xcf\x1c\x3d\x38\xb2\xbf\x97\xe7\ +\xc1\x89\x44\x00\x90\x64\xf7\x4b\x5f\x72\xde\x6d\x73\xe7\xce\x7f\ +\x7f\xed\x21\x4c\xd4\x6e\xb7\x1e\xbf\xe1\x53\xbf\xf3\xb6\x0a\x47\ +\xfb\x18\x60\x22\x09\x00\x92\x1c\x3a\xef\x25\x17\xec\xef\xd6\x5e\ +\xc1\x91\x8c\x97\x52\x9e\xac\x3d\x02\x52\xb8\x07\x00\x00\x02\x09\ +\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\ +\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\ +\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\ +\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\ +\x00\x00\x02\x09\x00\x00\x08\xd4\xec\x6b\x37\xbe\xda\x69\x74\xee\ +\xa9\x3d\x84\xa9\xe9\x36\x1a\x9d\xda\x1b\x00\x38\xf9\x34\x57\x5e\ +\x7d\xc3\xdd\xa5\x94\xbb\x6b\x0f\x01\x00\x7a\xc7\xaf\x00\x00\x20\ +\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\ +\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\ +\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\x00\x08\x24\ +\x00\x00\x20\x90\x00\x00\x80\x40\xcd\xda\x03\xa0\xd7\xba\xdd\x6e\ +\xed\x09\x1c\x59\xe3\x18\x1e\xeb\x0f\x12\x8e\xc3\xb1\xfc\xc7\x06\ +\x27\xbb\xb3\xae\x7f\xdf\x47\xee\x5c\x38\x7f\xf1\x8a\xda\x43\x98\ +\xa8\xdd\x6e\xed\x7b\x76\xf8\x99\x3b\x8e\xe6\xb1\xad\xd6\x78\xf7\ +\x1b\xdf\xfe\x97\x4f\x97\x52\x36\xce\xf0\x2c\x38\x65\x79\x05\x80\ +\x28\xe7\x9c\x79\xee\x19\xab\x56\x5e\x51\x7b\x06\x93\x5b\x50\x4a\ +\xb9\xee\x68\x1e\xb8\x6d\xfb\x63\xad\xff\x0b\x00\x60\x8a\xdc\x03\ +\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\ +\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\ +\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\ +\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\ +\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\x48\ +\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\ +\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\ +\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\ +\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\ +\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\ +\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x9a\xb5\x07\ +\x40\x2f\x8d\x8c\x8c\x74\xb6\x6e\x7f\xac\xf6\x0c\x26\xd7\xe9\x74\ +\xcb\xd8\xd1\x3c\x70\xcf\x9e\xe1\xd6\x4c\x8f\x81\x53\x9d\x00\x20\ +\xc9\xde\xc5\x8b\x17\x7d\x77\x60\x60\xf0\x3d\xb5\x87\x30\x51\xab\ +\x35\xb6\xe5\x63\x7f\xfe\xa1\xeb\x8e\xe1\x29\x43\x33\x36\x06\x02\ +\x08\x00\x92\x8c\xac\xbc\xe8\x17\x5f\xe8\xd6\x5e\xc1\x91\x1c\x2a\ +\xa5\x3c\x5a\x7b\x04\xa4\x70\x0f\x00\x00\x04\x12\x00\x00\x10\x48\ +\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\x10\ +\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\x00\ +\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\x00\ +\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\x12\ +\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\x04\ +\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\x00\ +\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\x00\ +\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\ +\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\ +\x04\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\ +\x81\x04\x00\x00\x04\x6a\xd6\x1e\x00\x3d\x34\x7b\xcb\xf6\xcd\x0b\ +\x16\xcc\x5d\x58\x7b\x07\x93\x68\xb5\x5a\x03\xa5\x94\x97\xd5\xde\ +\x71\x9c\x3a\xa5\x94\xed\xb5\x47\xc0\xd1\x68\xd4\x1e\x00\x3d\x74\ +\xd6\xc7\x3e\xf4\x99\x07\xcf\x38\xed\xac\xb3\x6a\x0f\x61\x12\xdd\ +\x32\xde\x6a\xb5\x86\x6a\xcf\x98\xba\x6e\xe3\xde\x07\xd7\x7c\xeb\ +\xdb\xff\xf3\xcd\x3f\xa8\xbd\x04\x8e\x86\x57\x00\x88\xb2\x70\xfe\ +\xa2\x59\x2b\x2e\x58\x59\x7b\x06\x93\x1b\x28\xa5\x2c\xaf\x3d\x62\ +\xaa\x3a\x9d\x4e\x79\x70\xc3\xda\x79\xb5\x77\xc0\xd1\x72\x0f\x00\ +\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\x04\ +\x00\x00\x04\x12\x00\x00\x10\x48\x00\x00\x40\x20\x01\x00\x00\x81\ +\x7c\x10\x10\x51\x76\xed\x7e\x6e\xef\x43\x1b\xee\x5f\x52\x7b\x07\ +\x13\xb5\x3b\x9d\xd1\x03\xa3\xfb\x37\xd4\xde\x31\x75\xdd\xf2\xc2\ +\xbe\xdd\x27\xf1\x27\x19\x92\x46\x00\x90\x64\xd7\x2b\x2f\xbf\xe2\ +\xf6\xc1\x81\xd9\x1f\xac\x3d\x84\x89\x3a\x9d\xf6\xb6\x0f\xfc\xc9\ +\xbb\xae\xae\xbd\xe3\x38\x75\x6a\x0f\x80\xa3\x25\x00\x48\xd2\x5a\ +\xb6\xf8\xf4\x43\xdd\xda\x2b\x38\x92\x76\x29\xe5\xf9\xda\x23\x20\ +\x85\x7b\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\x00\ +\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\x09\ +\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\x02\ +\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\x00\ +\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\x00\ +\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\x02\ +\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\x40\ +\x02\x00\x00\x02\x09\x00\x00\x08\x24\x00\x00\x20\x90\x00\x00\x80\ +\x40\x02\x00\x00\x02\x09\x00\x00\x08\xf4\xbf\x1a\x48\x03\xfd\x03\ +\xdd\xcf\x13\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\ +" + +qt_resource_name = b"\ +\x00\x08\ +\x0e\x38\x59\xe7\ +\x00\x6f\ +\x00\x67\x00\x70\x00\x35\x00\x2e\x00\x70\x00\x6e\x00\x67\ +\x00\x1e\ +\x0b\xc7\xb2\x67\ +\x00\x46\ +\x00\x6f\x00\x6e\x00\x74\x00\x5f\x00\x41\x00\x77\x00\x65\x00\x73\x00\x6f\x00\x6d\x00\x65\x00\x5f\x00\x35\x00\x5f\x00\x73\x00\x6f\ +\x00\x6c\x00\x69\x00\x64\x00\x5f\x00\x74\x00\x61\x00\x62\x00\x6c\x00\x65\x00\x2e\x00\x73\x00\x76\x00\x67\ +\x00\x0b\ +\x0a\xcd\xb6\x7f\ +\x00\x6f\ +\x00\x70\x00\x76\x00\x69\x00\x63\x00\x6f\x00\x6e\x00\x2e\x00\x69\x00\x63\x00\x6f\ +" + +qt_resource_struct_v1 = b"\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x01\ +\x00\x00\x00\x58\x00\x00\x00\x00\x00\x01\x00\x00\x83\xf2\ +\x00\x00\x00\x16\x00\x00\x00\x00\x00\x01\x00\x00\x82\x24\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ +" + +qt_resource_struct_v2 = b"\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x01\ +\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x58\x00\x00\x00\x00\x00\x01\x00\x00\x83\xf2\ +\x00\x00\x01\x89\xbc\x6e\xa7\x44\ +\x00\x00\x00\x16\x00\x00\x00\x00\x00\x01\x00\x00\x82\x24\ +\x00\x00\x01\x89\xb4\x06\xea\x25\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ +\x00\x00\x01\x8c\x3c\xd9\x27\x6f\ +" + +qt_version = [int(v) for v in QtCore.qVersion().split('.')] +if qt_version < [5, 8, 0]: + rcc_version = 1 + qt_resource_struct = qt_resource_struct_v1 +else: + rcc_version = 2 + qt_resource_struct = qt_resource_struct_v2 + +def qInitResources(): + QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) + +def qCleanupResources(): + QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) + +qInitResources() diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..aedb5ff --- /dev/null +++ b/requirements.txt @@ -0,0 +1,11 @@ +PyQt5 +matplotlib +pandas +scikit-learn +seaborn +factor_analyzer +mplstereonet +numpy +rasterio +shapely +pykrige \ No newline at end of file